My only non-core class this semester has been in Structure Products. We've been surveying a wide variety of products, and the final project was to pick one to report on.
+Because these are all very similar, we decided to demonstrate all 3 products at once.
+
What follows below is a notebook demonstrating the usage of Julia for Monte-Carlo simulation of some exotic products.
In order to price the autocallable bonds, we need to simulate the underlying assets. Let's go ahead and set up the simulation first, as this lays the foundation for what we're trying to do. We're going to use JNJ as the basis for our simulation. This implies the following parameters:
+
+
$S_0$ = \$102.2 (as of time of writing)
+
$q$ = 2.84%
+
$r$ = [.49, .9, 1.21, 1.45, 1.69] (term structure as of time of writing, linear interpolation)
+
$\mu$ = $r - q$ (note that this implies a negative drift because of current low rates)
We additionally define some parameters for simulation:
+
+
T: The number of years to simulate
+
m: The number of paths to simulate
+
n: The number of steps to simulate in a year
+
+
+
+
+
+
+
+
In [2]:
+
+
+
S0=102.2
+nominal=100
+q=2.84/100
+σ=15.37/100
+term=[0,.49,.9,1.21,1.45,1.69]/100+1
+
+###
+# Potential: Based on PEP
+# S0 = 100.6
+# σ = 14.86
+# q = 2.7
+###
+
+# Simulation parameters
+T=5# Using years as the unit of time
+n=250# simulations per year
+m=100000# paths
+num_simulations=5;# simulation rounds per price
+
To make things simpler, we simulate a single year at a time. This allows us to easily add in a dividend policy without too much difficulty, and update the simulation every year to match the term structure. The underlying uses GBM for simulation between years.
+
+
+
+
+
+
+
In [3]:
+
+
+
simulate_gbm=function(S0,μ,σ,T,n)
+ # Set the initial state
+ m=length(S0)
+ t=T/n
+ motion=zeros(m,n)
+ motion[:,1]=S0
+
+ # Build out all states
+ fori=1:(n-1)
+ motion[:,i+1]=motion[:,i].*exp((μ-σ^2/2)*t).*exp(sqrt(t)*σ.*randn(m))
+ end
+
+ returnmotion
+end
+
+function display_motion(motion,T)
+ # Given a matrix of paths, display the motion
+ n=length(motion[1,:])
+ m=length(motion[:,1])
+ x=repmat(1:n,m)
+
+ # Calculate the ticks we're going to use. We'd like to
+ # have an xtick every month, so calculate where those
+ # ticks will actually be at.
+ if(T>3)
+ num_ticks=T
+ xlabel="Years"
+ else
+ num_ticks=T*12
+ xlabel="Months"
+ end
+ tick_width=n/num_ticks
+ x_ticks=[]
+ fori=1:round(num_ticks)
+ x_ticks=vcat(x_ticks,i*tick_width)
+ end
+
+ # Use one color for each path. I'm not sure if there's
+ # a better way to do this without going through DataFrames
+ colors=[]
+ fori=1:m
+ colors=vcat(colors,ones(n)*i)
+ end
+
+ plot(x=x,y=motion',color=colors,Geom.line,
+ Guide.xticks(ticks=x_ticks,label=false),
+ Guide.xlabel(xlabel),
+ Guide.ylabel("Value"))
+end;
+
Let's go ahead and run a sample simulation to see what the functions got us!
+
+
+
+
+
+
+
In [4]:
+
+
+
initial=ones(5)*S0
+# Using μ=0, T=.25 for now, we'll use the proper values later
+motion=simulate_gbm(initial,0,σ,.25,200)
+
+display_motion(motion,.25)
+
Now that we've got the basic motion set up, let's start making things a bit more sophisticated for the model. We're going to assume that the drift of the stock is the difference between the implied forward rate and the quarterly dividend rate.
+
We're given the yearly term structure, and need to calculate the quarterly forward rate to match this structure. The term structure is assumed to follow:
+
$d(0, t) = d(0,t-1)\cdot f_{i-1, i}$
+
Where $f_{i-1, i}$ is the quarterly forward rate.
+
+
+
+
+
+
+
In [5]:
+
+
+
forward_term=function(yearly_term)
+ # It is assumed that we have a yearly term structure passed in, and starts at year 0
+ # This implies a nominal rate above 0 for the first year!
+ years=length(term)-1# because we start at 0
+ structure=[(term[i+1]/term[i])fori=1:years]
+end;
+
Now that we've got our term structure, let's validate that we're getting the correct results! If we've done this correctly, then:
+
+
term[2] == term[1] * structure[1]
+
+
+
+
+
+
+
In [6]:
+
+
+
# Example term structure taken from:
+# http://www.treasury.gov/resource-center/data-chart-center/interest-rates/Pages/TextView.aspx?data=yield
+# Linear interpolation used years in-between periods, assuming real-dollar
+# interest rates
+forward_yield=forward_term(term)
+calculated_term2=term[1]*forward_yield[1]
+
+println("Actual term[2]: $(term[2]); Calculated term[2]: $(calculated_term2)")
+
+
+
+
+
+
+
+
+
+
+
+
+
Actual term[2]: 1.0049; Calculated term[2]: 1.0049
+
Now that we have the term structure set up, we can actually start doing some real simulation! Let's construct some paths through the full 5-year time frame. In order to do this, we will simulate 1 year at a time, and use the forward rates at those times to compute the drift. Thus, there will be 5 total simulations batched together.
We're now going to actually build out the full motion that we'll use for computing the pricing of our autocallable products. It will be largely the same, but we will use far more sample paths for the simulation.
+
+
+
+
+
+
+
In [8]:
+
+
+
full_simulation=function(S0,T,n,m,term)
+ forward=vcat(term[1],forward_term(term))
+
+ # And an S0 to kick things off.
+ final_motion=ones(m)*S0
+ fori=1:T
+ μ=(forward[i]-1-q)
+ year_motion=simulate_gbm(final_motion[:,end],μ,σ,1,n)
+ final_motion=hcat(final_motion,year_motion)
+ end
+ returnfinal_motion
+end
+
+tic()
+full_simulation(S0,T,n,m,term)
+time=toq()
+@printf("Time to run simulation: %.2fs",time)
+
Let's move into pricing a Phoenix without memory. It's very similar to the Athena production, with the exception that we introduce a coupon barrier so coupons are paid even when the underlying is below the initial price.
+
The Phoenix product has the following characteristics (example here):
+
+
Automatically called if the underlying is above the call barrier at observation
+
Coupon paid if the underlying is above a coupon barrier at observation
+
Principle protection up until a protection barrier at observation; All principle at risk if this barrier not met
+
Observed yearly
+
+
Some example paths (all assume that a call barrier of the current price, and coupon barrier some level below that):
+
+
At the end of year 1, the stock is above the call barrier; the note is called and you receive the value of the stock plus the coupon being paid.
+
At the end of year 1, the stock is above the coupon barrier, but not the call barrier; you receive the coupon. At the end of year 2, the stock is below the coupon barrier; you receive nothing. At the end of year 3, the stock is above the call barrier; the note is called and you receive the value of the stock plus a coupon for year 3.
+
+
We're going to re-use the same simulation, with the following parameters:
+
+
Call barrier: 100%
+
Coupon barrier: 70%
+
Coupon: 6%
+
Capital protection until 70% (at maturity)
+
+
+
+
+
+
+
+
In [10]:
+
+
+
call_barrier=S0
+coupon_barrier=S0*.8
+protection_barrier=S0*.6
+coupon=nominal*.06
+
+price_phoenix_no_memory=function(initial_price,year_prices,call_barrier,coupon_barrier,
+ protection_barrier,coupon,forward_structure)
+
+ total_coupons=0
+ t=length(year_prices)
+
+ fori=1:t
+ price=year_prices[i]
+ ifprice≥call_barrier
+ return(nominal+coupon+total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))
+ elseifprice≥coupon_barrier
+ total_coupons=total_coupons*exp(forward_structure[i]-1)+coupon
+ else
+ total_coupons*=exp(forward_structure[i]-1)
+ end
+ end
+
+ # We've reached maturity, time to check capital protection
+ ifyear_prices[end]>protection_barrier
+ returnnominal+total_coupons
+ else
+ put=(strike-year_prices[end])/strike
+ returnnominal*(1-put)
+ end
+end
+
+forward_structure=forward_term(term)
+price_function=(year_prices)->price_phoenix_no_memory(S0,year_prices,
+ call_barrier,coupon_barrier,protection_barrier,coupon,forward_structure)
+
+phoenix_no_memory=function()
+ year_indexes=[n*ifori=1:T]
+ motion=full_simulation(S0,T,n,m,term)
+ payoffs=[price_function(motion[i,year_indexes])fori=1:m]
+ returnmean(payoffs)
+end
+
+mean_payoffs=zeros(num_simulations)
+fori=1:num_simulations
+ tic()
+ mean_payoffs[i]=phoenix_no_memory()
+ time=toq()
+ @printf("Mean of simulation %i: \$%.4f; Simulation time: %.2fs\n",i,mean_payoffs[i],time)
+end
+
+final_mean=mean(mean_payoffs)
+println("Mean over $num_simulations simulations: $(mean(mean_payoffs))")
+pv=final_mean*exp(-(prod(forward_structure)-1)*(T))
+@printf("Present value of Phoenix without memory note: \$%.2f",pv)
+
+
+
+
+
+
+
+
+
+
+
+
+
Mean of simulation 1: $106.0562; Simulation time: 5.72s
+Mean of simulation 2: $106.0071; Simulation time: 5.85s
+Mean of simulation 3: $105.9959; Simulation time: 5.87s
+Mean of simulation 4: $106.0665; Simulation time: 5.93s
+Mean of simulation 5: $106.0168; Simulation time: 5.81s
+Mean over 5 simulations: 106.02850857209883
+Present value of Phoenix without memory note: $97.44
The Phoenix with Memory structure is very similar to the Phoenix, but as the name implies, has a special "memory" property: It remembers any coupons that haven't been paid at prior observation times, and pays them all if the underlying crosses the coupon barrier. For example:
+
+
Note issued with 100% call barrier, 70% coupon barrier. At year 1, the underlying is at 50%, so no coupons are paid. At year 2, the underlying is at 80%, so coupons for both year 1 and 2 are paid, resulting in a double coupon.
After taking some time to explore how the weather in North Carolina stacked up over the past years, I was interested in doing the same analysis for other cities. Growing up with family from Binghamton, NY I was always told it was very cloudy there. And Seattle has a nasty reputation for being very depressing and cloudy. All said, the cities I want to examine are:
+
+
Binghamton, NY
+
Cary, NC
+
Seattle, WA
+
New York City, NY
+
+
I'd be interested to try this analysis worldwide at some point - comparing London and Seattle might be an interesting analysis. For now though, we'll stick with trying out the US data.
+
There will be plenty of charts. I want to know: How has average cloud cover and precipitation chance changed over the years for each city mentioned? This will hopefully tell us whether Seattle has actually earned its reputation for being a depressing city.
Well, as it so happens it looks like there are some data issues. July's data is a bit sporadic, and 2013 seems to be missing from most months as well. I think really only two things can really be confirmed here:
+
+
Seattle, specifically for the months of October and November, is in fact significantly more cloudy on average than are other cities
+
All cities surveyed have seen average cloud cover decline over the months studied. There are data issues, but the trend seems clear.
+
+
Let's now move from cloud cover data to looking at average rainfall chance.
+
+
+
+
+
+
+
In [5]:
+
+
+
defsafe_precip(frame):
+ ifframeand'precipProbability'inframe:
+ returnframe['precipProbability']
+ else:
+ returnnp.NaN
+
+defmonthly_avg_precip(city,year,month):
+ dates=pd.DatetimeIndex(start=datetime(year,month,1,12),
+ end=datetime(year,month+1,1,12),
+ freq='D',closed='left')
+ precip_vals=list(map(lambdax:safe_precip(forecasts_df[city][x]['currently']),dates))
+ precip_samples=len(list(filter(lambdax:xisnotnp.NaN,precip_vals)))
+ # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.
+ withwarnings.catch_warnings():
+ warnings.simplefilter('ignore')
+ returnnp.nanmean(precip_vals),precip_samples
+
+defcity_avg_precip(city,month):
+ return[monthly_avg_precip(city,y,month)foryinyears]
+
+formonth,month_idinmonths:
+ month_averages={city:city_avg_cc(city,month_id)forcityincities}
+ f=figure(title="{} Average Precipitation Chance".format(month),
+ x_axis_label='Year',
+ y_axis_label='Precipitation Chance Percentage')
+ forcityincities:
+ f.line(years,[x[0]forxinmonth_averages[city]],
+ legend=city,color=city_colors[city])
+ show(f)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The same data issue caveats apply here: 2013 seems to be missing some data, and July has some issues as well. However, this seems to confirm the trends we saw with cloud cover:
+
+
Seattle, specifically for the months of August, October, and November has had a consistently higher chance of rain than other cities surveyed.
+
Average precipitation chance, just like average cloud cover, has been trending down over time.
I have to admit I was a bit surprised after doing this analysis. Seattle showed a higher average cloud cover and average precipitation chance than did the other cities surveyed. Maybe Seattle is actually an objectively more depressing city to live in.
+
Well that's all for weather data at the moment. It's been a great experiment, but I think this is about as far as I'll be able to get with weather data without some domain knowledge. Talk again soon!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/complaining-about-the-weather.html b/complaining-about-the-weather.html
new file mode 100644
index 0000000..c26c97d
--- /dev/null
+++ b/complaining-about-the-weather.html
@@ -0,0 +1,870 @@
+
+
+
+
+
+
+
+
+
+
+ Complaining about the Weather - Bradlee Speice
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
I'm originally from North Carolina, and I've been hearing a lot of people talking about how often it's been raining recently. They're excited for any day that has sun.
+
So I got a bit curious: Has North Carolina over the past few months actually had more cloudy and rainy days recently than in previous years? This shouldn't be a particularly challenging task, but I'm interested to know if people's perceptions actually reflect reality.
+
The data we'll use comes from forecast.io, since they can give us a cloud cover percentage. I've gone ahead and retrieved the data to a pickle file, and included the code that was used to generate it. First up: What was the average cloud cover in North Carolina during August - November, and how many days were cloudy? We're going to assume that a "cloudy" day is defined as any day in which the cloud cover is above 50%.
As we can see from the chart above, on the whole the monthly average cloud cover has been generally trending down over time. The average cloud cover is also lower than it was last year - it seems people are mostly just complaining. There are some data issues that start in 2012 that we need to be aware of - the cloud cover percentage doesn't exist for all days. Even so, the data that we have seems to reflect the wider trend, so we'll assume for now that the missing data doesn't skew our results.
+
There's one more metric we want to check though - how many cloudy days were there? This is probably a better gauge of sentiment than the average monthly cover.
On the whole, the number of cloudy days seems to reflect the trend with average cloud cover - it's actually becoming more sunny as time progresses. That said, we need to be careful in how we view this number - because there weren't as many samples in 2015 as previous years, the number of days can get thrown off. In context though, even if most days not recorded were in fact cloudy, the overall count for 2015 would still be lower than previous years.
In addition to checking cloud cover, I wanted to check precipitation data as well - what is the average precipitation chance over a month, and how many days during a month is rain likely? The thinking is that days with a high-precipitation chance will also be days in which it is cloudy or depressing.
As we can see from the chart, the average chance of precipitation over a month more or less stays within a band of 0 - .1 for all months over all years. This is further evidence that the past few months are no more cloudy or rainy than previous years. Like the cloud cover though, we still want to get a count of all the rainy days, in addition to the average chance. We'll define a "rainy day" as any day in which the chance of rain is greater than 25%.
After trying to find the number of days that are rainy, we can see that November hit its max value for rainy days in 2015. However, that value is 6, as compared to a previous maximum of 5. While it is a new record, the value isn't actually all that different. And for other months, the values are mostly in-line with the averages.
After having looked at forecast data for Cary, it appears that the months of July - November this year in terms of weather were at worst on par with prior years, if not slightly more sunny. This seems to be a case of confirmation bias: someone complains about a string of cloudy or rainy days, and suddenly you start noticing them more.
+
While this analysis doesn't take into account other areas of North Carolina, my initial guess would be to assume that other areas also will show similar results: nothing interesting is happening. Maybe that will be for another blog post later!
+
Coming soon: I'll compare rain/cloud conditions in North Carolina to some other places in the U.S.!
The following code was generates the file that was used throughout the blog post. Please note that I'm retrieving data for other cities to use in a future blog post, only Cary data was used for this post.
+
importpandasaspd
+fromfunctoolsimportreduce
+importrequests
+fromdatetimeimportdatetime
+
+# Coordinate data from http://itouchmap.com/latlong.html
+cary_loc=(35.79154,-78.781117)
+nyc_loc=(40.78306,-73.971249)
+seattle_loc=(47.60621,-122.332071)
+binghamton_loc=(42.098687,-75.917974)
+cities={
+ 'cary':cary_loc,
+ 'nyc':nyc_loc,
+ 'seattle':seattle_loc,
+ 'binghamton':binghamton_loc
+}
+
+apikey=''# My super-secret API Key
+
+defget_forecast(lat,long,date=None):
+ forecast_base="https://api.forecast.io/forecast/"
+ ifdateisNone:
+ url=forecast_base+apikey+'/{},{}'.format(lat,long)
+ else:
+ epoch=int(date.timestamp())
+ url=forecast_base+apikey+'/{},{},{}'.format(lat,long,epoch)
+
+ returnrequests.get(url).json()
+
+years=range(1990,2016)
+# For datetimes, the 12 is for getting the weather at noon.
+# We're doing this over midnight because we're more concerned
+# with what people see, and people don't typically see the weather
+# at midnight.
+dt_indices=[pd.date_range(start=datetime(year,7,1,12),
+ end=datetime(year,11,30,12))
+ foryearinyears]
+dt_merge=reduce(lambdax,y:x.union(y),dt_indices)
+
+# Because we have to pay a little bit to use the API, we use for loops here
+# instead of a comprehension - if something breaks, we want to preserve the
+# data already retrieved
+city_forecasts={}
+forcity,locincities.items():
+ print("Retrieving data for {} starting at {}".format(city,
+ datetime.now().strftime("%I:%M:%S %p")))
+ fordtindt_merge:
+ try:
+ city_forecasts[(city,dt)]=get_forecast(*loc,dt)
+ exceptExceptionase:
+ print(e)
+ city_forecasts[(city,dt)]=None
+print("End forecast retrieval: {}".format(datetime.now().strftime("%I:%M:%S %p")))
+
+importpickle
+pickle.dump(city_forecasts,open('city_forecasts.p','wb'))
+
+### Output:
+# Retrieving data for binghamton starting at 05:13:42 PM
+# Retrieving data for seattle starting at 05:30:51 PM
+# Retrieving data for nyc starting at 05:48:30 PM
+# Retrieving data for cary starting at 06:08:32 PM
+# End forecast retrieval: 06:25:21 PM
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/content/articles/2015-11-14-welcome.md b/content/articles/2015-11-14-welcome.md
deleted file mode 100644
index f6892a8..0000000
--- a/content/articles/2015-11-14-welcome.md
+++ /dev/null
@@ -1,58 +0,0 @@
-Title: Welcome, and an algorithm
-Date: 2015-11-19
-Tags: introduction, trading
-Modified: 2015-12-05
-Category: Blog
-
-
-
-
-Hello! Glad to meet you. I'm currently a student at Columbia University
-studying Financial Engineering, and want to give an overview of the projects
-I'm working on!
-
-To start things off, Columbia has been hosting a trading competition that
-myself and another partner are competing in. I'm including a notebook of the
-algorithm that we're using, just to give a simple overview of a miniature
-algorithm.
-
-The competition is scored in 3 areas:
-
-- Total return
-- [Sharpe ratio](1)
-- Maximum drawdown
-
-Our algorithm uses a basic momentum strategy: in the given list of potential
-portfolios, pick the stocks that have been performing well in the past 30
-days. Then, optimize for return subject to the drawdown being below a specific
-level. We didn't include the Sharpe ratio as a constraint, mostly because
-we were a bit late entering the competition.
-
-I'll be updating this post with the results of our algorithm as they come along!
-
----
-
-**UPDATE 12/5/2015**: Now that the competition has ended, I wanted to update
-how the algorithm performed. Unfortunately, it didn't do very well. I'm planning
-to make some tweaks over the coming weeks, and do another forward test in January.
-
-- After week 1: Down .1%
-- After week 2: Down 1.4%
-- After week 3: Flat
-
-And some statistics for all teams participating in the competition:
-
-| | |
-|--------------------|--------|
-| Max Return | 74.1% |
-| Min Return | -97.4% |
-| Average Return | -.1% |
-| Std Dev of Returns | 19.6% |
-
----
-
-{% notebook 2015-11-14-welcome.ipynb %}
-
-[1]: https://en.wikipedia.org/wiki/Sharpe_ratio
diff --git a/content/articles/2015-11-27-autocallable.md b/content/articles/2015-11-27-autocallable.md
deleted file mode 100644
index ad9dd9f..0000000
--- a/content/articles/2015-11-27-autocallable.md
+++ /dev/null
@@ -1,20 +0,0 @@
-Title: Autocallable Bonds
-Date: 2015-11-27
-Category: Blog
-Tags: finance, simulation, monte carlo
-Authors: Bradlee Speice
-Summary: For a final project, my group was tasked with understanding three exotic derivatives: The Athena, Phoenix without memory, and Phoenix with memory autocallable products.
-[//]: <> "Modified:"
-
-
-
-
-My only non-core class this semester has been in Structure Products. We've been surveying a wide variety of products, and the final project was to pick one to report on.
-Because these are all very similar, we decided to demonstrate all 3 products at once.
-
-What follows below is a notebook demonstrating the usage of [Julia](http://julialang.com) for Monte-Carlo simulation of some exotic products.
-
-{% notebook 2015-11-27-autocallable.ipynb language[julia] %}
-
diff --git a/content/articles/2015-12-26-testing_cramer.md b/content/articles/2015-12-26-testing_cramer.md
deleted file mode 100644
index 39e6db0..0000000
--- a/content/articles/2015-12-26-testing_cramer.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Title: Testing Cramer
-Date: 2015-12-26
-Category: Blog
-Tags: futures, data science
-Authors: Bradlee Speice
-Summary:
-[//]: <> "Modified: "
-
-
-
-
-{% notebook 2015-12-26-testing_cramer.ipynb %}
diff --git a/content/articles/2016-1-1-complaining-about-weather.md b/content/articles/2016-1-1-complaining-about-weather.md
deleted file mode 100644
index f3ec6e5..0000000
--- a/content/articles/2016-1-1-complaining-about-weather.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Title: Complaining about the Weather
-Date: 2016-01-01
-Category: Blog
-Tags: weather
-Authors: Bradlee Speice
-Summary: Figuring out whether people should be complaining about the recent weather in NC.
-[//]: <> "Modified: "
-
-
-
-
-{% notebook 2016-1-1-complaining-about-weather.ipynb %}
diff --git a/content/articles/2016-1-23-cloudy-in-seattle.md b/content/articles/2016-1-23-cloudy-in-seattle.md
deleted file mode 100644
index 167ac41..0000000
--- a/content/articles/2016-1-23-cloudy-in-seattle.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Title: Cloudy in Seattle
-Date: 2016-01-23
-Category: Blog
-Tags: weather, data science
-Authors: Bradlee Speice
-Summary: Building on prior analysis, is Seattle's reputation as a depressing city actually well-earned?
-[//]: <> "Modified: "
-
-
-
-
-{% notebook 2016-1-23-cloudy-in-seattle.ipynb %}
diff --git a/content/articles/2016-2-26-profitability-using-the-investment-formula.md b/content/articles/2016-2-26-profitability-using-the-investment-formula.md
deleted file mode 100644
index fe20f27..0000000
--- a/content/articles/2016-2-26-profitability-using-the-investment-formula.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Title: Profitability using the Investment Formula
-Date: 2016-02-26
-Category: Blog
-Tags: algorithmic-trading, python
-Authors: Bradlee Speice
-Summary: After developing a formula to guide our investing, how do we actually evaluate its performance in the real world?
-[//]: <> "Modified: "
-
-
-
-
-{% notebook 2016-2-26-profitability-using-the-investment-formula.ipynb %}
diff --git a/content/articles/2016-2-3-guaranteed-money-maker.md b/content/articles/2016-2-3-guaranteed-money-maker.md
deleted file mode 100644
index a2e0227..0000000
--- a/content/articles/2016-2-3-guaranteed-money-maker.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Title: Guaranteed Money Maker
-Date: 2016-02-03
-Category: Blog
-Tags: martingale, strategy
-Authors: Bradlee Speice
-Summary: Developing an investment strategy based on the Martingale betting strategy
-[//]: <> "Modified: "
-
-
-
-
-{% notebook 2016-2-3-guaranteed-money-maker.ipynb %}
diff --git a/content/notebooks/2015-11-14-welcome.ipynb b/content/notebooks/2015-11-14-welcome.ipynb
deleted file mode 100644
index 2fab0a3..0000000
--- a/content/notebooks/2015-11-14-welcome.ipynb
+++ /dev/null
@@ -1,293 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Trading Competition Optimization\n",
- "\n",
- "### Goal: Max return given maximum Sharpe and Drawdown"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "from IPython.display import display\n",
- "import Quandl\n",
- "from datetime import datetime, timedelta\n",
- "\n",
- "tickers = ['XOM', 'CVX', 'CLB', 'OXY', 'SLB']\n",
- "market_ticker = 'GOOG/NYSE_VOO'\n",
- "lookback = 30\n",
- "d_col = 'Close'\n",
- "\n",
- "data = {tick: Quandl.get('YAHOO/{}'.format(tick))[-lookback:] for tick in tickers}\n",
- "market = Quandl.get(market_ticker)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Calculating the Return\n",
- "We first want to know how much each ticker returned over the prior period."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "{'CLB': -0.0016320202164526894,\n",
- " 'CVX': 0.0010319531629488911,\n",
- " 'OXY': 0.00093418904454400551,\n",
- " 'SLB': 0.00098431254720448159,\n",
- " 'XOM': 0.00044165797556096868}"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "returns = {tick: data[tick][d_col].pct_change() for tick in tickers}\n",
- "\n",
- "display({tick: returns[tick].mean() for tick in tickers})"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Calculating the Sharpe ratio\n",
- "Sharpe: ${R - R_M \\over \\sigma}$\n",
- "\n",
- "We use the average return over the lookback period, minus the market average return, over the ticker standard deviation to calculate the Sharpe. Shorting a stock turns a negative Sharpe positive."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "{'CLB': -0.10578734457846127,\n",
- " 'CVX': 0.027303529817677398,\n",
- " 'OXY': 0.022622210057414487,\n",
- " 'SLB': 0.026950946344858676,\n",
- " 'XOM': -0.0053519259698605499}"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "market_returns = market.pct_change()\n",
- "\n",
- "sharpe = lambda ret: (ret.mean() - market_returns[d_col].mean()) / ret.std()\n",
- "sharpes = {tick: sharpe(returns[tick]) for tick in tickers}\n",
- "\n",
- "display(sharpes)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Calculating the drawdown\n",
- "This one is easy - what is the maximum daily change over the lookback period? That is, because we will allow short positions, we are not concerned strictly with maximum downturn, but in general, what is the largest 1-day change?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "{'CLB': 0.043551495607375035,\n",
- " 'CVX': 0.044894389686214398,\n",
- " 'OXY': 0.051424517867144637,\n",
- " 'SLB': 0.034774627850375328,\n",
- " 'XOM': 0.035851524605672758}"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "drawdown = lambda ret: ret.abs().max()\n",
- "drawdowns = {tick: drawdown(returns[tick]) for tick in tickers}\n",
- "\n",
- "display(drawdowns)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Performing the optimization\n",
- "\n",
- "$\\begin{align}\n",
- "max\\ \\ & \\mu \\cdot \\omega\\\\\n",
- "s.t.\\ \\ & \\vec{1} \\omega = 1\\\\\n",
- "& \\vec{S} \\omega \\ge s\\\\\n",
- "& \\vec{D} \\cdot | \\omega | \\le d\\\\\n",
- "& \\left|\\omega\\right| \\le l\\\\\n",
- "\\end{align}$\n",
- "\n",
- "We want to maximize average return subject to having a full portfolio, Sharpe above a specific level, drawdown below a level, and leverage not too high - that is, don't have huge long/short positions."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "'Optimization terminated successfully.'"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- "\"Holdings: [('XOM', 5.8337945679814904), ('CVX', 42.935064321851307), ('CLB', -124.5), ('OXY', 36.790387773552119), ('SLB', 39.940753336615096)]\""
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- "'Expected Return: 32.375%'"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/plain": [
- "'Expected Max Drawdown: 4.34%'"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "import numpy as np\n",
- "from scipy.optimize import minimize\n",
- "\n",
- "#sharpe_limit = .1\n",
- "drawdown_limit = .05\n",
- "leverage = 250\n",
- "\n",
- "# Use the map so we can guarantee we maintain the correct order\n",
- "# sharpe_a = np.array(list(map(lambda tick: sharpes[tick], tickers))) * -1 # So we can write as upper-bound\n",
- "dd_a = np.array(list(map(lambda tick: drawdowns[tick], tickers)))\n",
- "returns_a = np.array(list(map(lambda tick: returns[tick].mean(), tickers))) # Because minimizing\n",
- "\n",
- "meets_sharpe = lambda x: sum(abs(x) * sharpe_a) - sharpe_limit\n",
- "def meets_dd(x):\n",
- " portfolio = sum(abs(x))\n",
- " if portfolio < .1:\n",
- " # If there are no stocks in the portfolio,\n",
- " # we can accidentally induce division by 0,\n",
- " # or division by something small enough to cause infinity\n",
- " return 0\n",
- " \n",
- " return drawdown_limit - sum(abs(x) * dd_a) / sum(abs(x))\n",
- "\n",
- "is_portfolio = lambda x: sum(x) - 1\n",
- "\n",
- "def within_leverage(x):\n",
- " return leverage - sum(abs(x))\n",
- "\n",
- "objective = lambda x: sum(x * returns_a) * -1 # Because we're minimizing\n",
- "bounds = ((None, None),) * len(tickers)\n",
- "x = np.zeros(len(tickers))\n",
- "\n",
- "constraints = [\n",
- " {\n",
- " 'type': 'eq',\n",
- " 'fun': is_portfolio\n",
- " }, {\n",
- " 'type': 'ineq',\n",
- " 'fun': within_leverage\n",
- " #}, {\n",
- " # 'type': 'ineq',\n",
- " # 'fun': meets_sharpe\n",
- " }, {\n",
- " 'type': 'ineq',\n",
- " 'fun': meets_dd\n",
- " }\n",
- "]\n",
- "\n",
- "optimal = minimize(objective, x, bounds=bounds, constraints=constraints,\n",
- " options={'maxiter': 500})\n",
- "\n",
- "# Optimization time!\n",
- "display(optimal.message)\n",
- "\n",
- "display(\"Holdings: {}\".format(list(zip(tickers, optimal.x))))\n",
- "\n",
- "expected_return = optimal.fun * -100 # multiply by -100 to scale, and compensate for minimizing\n",
- "display(\"Expected Return: {:.3f}%\".format(expected_return))\n",
- "\n",
- "expected_drawdown = sum(abs(optimal.x) * dd_a) / sum(abs(optimal.x)) * 100\n",
- "display(\"Expected Max Drawdown: {0:.2f}%\".format(expected_drawdown))\n",
- "\n",
- "# TODO: Calculate expected Sharpe"
- ]
- }
- ],
- "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.5.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/content/notebooks/2015-11-27-autocallable.ipynb b/content/notebooks/2015-11-27-autocallable.ipynb
deleted file mode 100644
index 8e4038b..0000000
--- a/content/notebooks/2015-11-27-autocallable.ipynb
+++ /dev/null
@@ -1,3974 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "using Gadfly"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Athena/Phoenix Simulation\n",
- "\n",
- "## Underlying simulation\n",
- "\n",
- "In order to price the autocallable bonds, we need to simulate the underlying assets. Let's go ahead and set up the simulation first, as this lays the foundation for what we're trying to do. We're going to use [JNJ](http://finance.yahoo.com/q?s=jnj) as the basis for our simulation. This implies the following parameters:\n",
- "\n",
- "- $S_0$ = \\$102.2 (as of time of writing)\n",
- "- $q$ = 2.84%\n",
- "- $r$ = [.49, .9, 1.21, 1.45, 1.69] (term structure as of time of writing, linear interpolation)\n",
- "- $\\mu$ = $r - q$ (note that this implies a negative drift because of current low rates)\n",
- "- $\\sigma$ = $\\sigma_{imp}$ = 15.62% (from VIX implied volatility)\n",
- "\n",
- "We additionally define some parameters for simulation:\n",
- "\n",
- "- `T`: The number of years to simulate\n",
- "- `m`: The number of paths to simulate\n",
- "- `n`: The number of steps to simulate in a year"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/plain": [
- "5"
- ]
- },
- "execution_count": 2,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "S0 = 102.2\n",
- "nominal = 100\n",
- "q = 2.84 / 100\n",
- "σ = 15.37 / 100\n",
- "term = [0, .49, .9, 1.21, 1.45, 1.69] / 100 + 1\n",
- "\n",
- "###\n",
- "# Potential: Based on PEP\n",
- "# S0 = 100.6\n",
- "# σ = 14.86\n",
- "# q = 2.7\n",
- "###\n",
- "\n",
- "# Simulation parameters\n",
- "T = 5 # Using years as the unit of time\n",
- "n = 250 # simulations per year\n",
- "m = 100000 # paths\n",
- "num_simulations = 5; # simulation rounds per price"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Defining the simulation\n",
- "To make things simpler, we simulate a single year at a time. This allows us to easily add in a dividend policy without too much difficulty, and update the simulation every year to match the term structure. The underlying uses GBM for simulation between years."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "simulate_gbm = function(S0, μ, σ, T, n)\n",
- " # Set the initial state\n",
- " m = length(S0)\n",
- " t = T / n\n",
- " motion = zeros(m, n)\n",
- " motion[:,1] = S0\n",
- " \n",
- " # Build out all states\n",
- " for i=1:(n-1)\n",
- " motion[:,i+1] = motion[:,i] .* exp((μ - σ^2/2)*t) .* exp(sqrt(t) * σ .* randn(m))\n",
- " end\n",
- " \n",
- " return motion\n",
- "end\n",
- "\n",
- "function display_motion(motion, T)\n",
- " # Given a matrix of paths, display the motion\n",
- " n = length(motion[1,:])\n",
- " m = length(motion[:,1])\n",
- " x = repmat(1:n, m)\n",
- " \n",
- " # Calculate the ticks we're going to use. We'd like to\n",
- " # have an xtick every month, so calculate where those\n",
- " # ticks will actually be at.\n",
- " if (T > 3)\n",
- " num_ticks = T\n",
- " xlabel = \"Years\"\n",
- " else\n",
- " num_ticks = T * 12\n",
- " xlabel = \"Months\"\n",
- " end\n",
- " tick_width = n / num_ticks\n",
- " x_ticks = []\n",
- " for i=1:round(num_ticks)\n",
- " x_ticks = vcat(x_ticks, i*tick_width)\n",
- " end\n",
- " \n",
- " # Use one color for each path. I'm not sure if there's\n",
- " # a better way to do this without going through DataFrames\n",
- " colors = []\n",
- " for i = 1:m\n",
- " colors = vcat(colors, ones(n)*i)\n",
- " end\n",
- " \n",
- " plot(x=x, y=motion', color=colors, Geom.line,\n",
- " Guide.xticks(ticks=x_ticks, label=false),\n",
- " Guide.xlabel(xlabel),\n",
- " Guide.ylabel(\"Value\"))\n",
- "end;"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Example simulation\n",
- "\n",
- "Let's go ahead and run a sample simulation to see what the functions got us!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhcAAAF6CAYAAACqW3pRAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeXwU5f0H8M/3md0c3LeCQHYDAUwku5sEUAiI1YqKwTPWelJrtQrY1nqhWFcBRW391SJWqVq01gNqPVARbQtyCRiys8EEBMluQgC55cq1O8/398fsIkeAEJbMJnner5evl7sz88xndveZPMw88zyAoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoihKk1BYWN7D6gxKfGBmKigIdrc6hxIfAoFAUnHxxk5W52hMwuoAitJcEPHbVmdQ4kNJSYndbscbVudQ4sOePSKnttb4vdU5GpNqXChKjBDxKqszKPFh27Z0ycyFVudQ4gMR/UCEDVbnUBRFURRFabLI6gCxMv7W8dNBfAWAXrUJoa4zZ87cAQC/vvnX3Wya7TWAcwCECfhfTULo1zNnzqwEgLvH3u0WoFkMtCfQOpZ8w4w3Zuy08liUpsnnC4z0eJwLrc6hWI+ZxerVgdzMzNRFVmdRrFdQsLmL3R4+0+Xq/Y3VWRpLs7ktQkSzbeHQEAAHDn1faEIw8UtdHF17UlvRhwntE2oTHjq4HPQqSzw+Y9YMJ0jqJOiJRg+vNBPicasTKPGhpKTExiwetTqHEh9sttAAKeXPrc7RmGxWB4iV6bOmLwaA8WPHHfb+i7Ne/B7Ax5GX4XFjx30J8EAAuOu2u1Ih0XPGGzM+MJeKl6DxCgCHF6Io9UAk37I6gxIfiovTjf79y961OocSH5hlBRFa1FWsZnPloj7Gjh2bRMBYAf43ANgYvQBUAGAA2Fq9tRxA5wkTJiRaGFNpotxu58tWZ1Diw3XXkeFyOV6xOocSHzweZ9Dtds63OkdjajZXLk7E6/XadpRtfwuS509//cW5J7u9zxd8UQikEdF1O3f23tepU9k8Zmxxux23FBVtHMhsPAfw/1wu51O6XnYdEf9KSp7h8Tg/8PkCXiFoGCDHu1yp3+p64F1AdHC7U0atXl16hpTiTYC+cblSfufzBUYKQY8w0xy3O2Wmzxe8WwhcBYgnXK7ei3U9OJ0IA0KhhJ9nZ3ffWVRU9jmAbS6X48bCwrJ0TePnmfGl2+2Y4vcHrwHwawAvuVyO93Q9+CgRRhgG/SYrK6XE5wu+JQS6ZmamXLxq1ZbOdnvt28xY43Y77vH7y4cD8g8A/9vlcv5V18vuIOJ8KXmqx+Nc6PMF/iwEZQghbxo4MHWrrpfNB7Db7U653u8v7Q+IFwBa4nKlPO7zBa4UgsYx09/c7pTZfn/wYQAXEGn3Zmb2Wq3rwX8Q4cxdu1Iu7datol04bLwLYJ3L5Rjn8wWHCoHHmfGh2+14we8P/hLA9QCecrkc/9P14J+IkGkY4tasrN6bfb7gpwAOeDyOfJ9vQ5oQ2ovM+MrtdvzB7y/LA/gegF9zuZxv63rZg0R8kWHI+7KyUv1+f9ksgM9q1Sp0+Z49Islu1/7FTBvc7pRf+/2BcwGaDNDHLlfK8z5fYKwQdKOU9IzHk/KF3x98hpmvJLL/xOXqWaHrwbkAQm634+qiorJUZn5ZSqz0eByP+HzB0ULgt8z0utud8qbfH7wPwCgAD7pcjkJdD75KhN4HDmhj2rdP1MLhyvelRNDjcfzK5ysfJIR8khnz3G7Hc35/2S0A3wzwn1wu52e6XvYUEecYhrw9Kyu1zO8v+0BKSR6P84rCwtIUTROvMPMqt9v5kN8fuASg30vJb3o8ztd1PfA7IrpMSvGwx9P7a78/OBOA02ZrdVWrVgfCe/fSXGZsdLsdt/n9wSwAT0uJzz0ex7M+X/BGITBWSvzZ43F84vcHpwAYQkR3ZmamlOp68D0AiW6343K/v6InEP67lNA9Hsf9Pl/ZT4XgB5jxttvteM3vL7sH4DyAH3W5nMt1veyvRNw3FDKuBXZX2u1dPpWSN3s8zlsLC0tdmib+yMz/dbud0/z+wPUA/RIQ012u3h/peuBxIhoqpXG3x9Nnvd8fnM2Mtm6349KCgmB3ux1vMGO12+241+8P/gTARClptseT8jefLzhOCFwpJXk9npSluh58gQj9bTbtZ+npPX8oKiqbz4ytbrfjJr+//BxA/p+UWOjxOKYWFpZfL4TxOEAPud2O93W97A9EPJyIJ2RmOtfqevBtgDu73c6L/f7vugG2fzJzidvt/E1hYeB8TaNJzPye2+18SdcDvyaia4jk5MzM1EW6HnieiNINI3RDVlbadl0PfA7QTrfb8fNVq4Jn22z4CzMtdrtTntD14NVEuEtKmunxpMzx+YKPCIGRzPRbtzulWNeDbxLhjMzMlFErV27qmJQUfocZ37rdjvG6XpZLxI9JiQ88HscMn6/sV0Lwdcx40u12LND14HNEGGiz8c0ZGc7vdT04D+C9brfzZ7q+oR+RNoOZl7ndzsd8vsAVQtB4gF91uZzv+P2BiQD9RAj5+4EDU4t8vsDrQlCPUGjHZZrWubUQNEdKrPd4HHcXFgbP0zQ8AdBclyvlL7oevI0IPzcMejorK+U/uh78IxFczNpYt7vXJl0Pfgyg2u12XLt6dXkfKeVLzFjudjse1fWyy4n4N1Jilsfj+KfPV/aAEPxTZjzgdjt8ul72dyLu2a4d59XU1NhrapL+zcylbrfzTl0vHUwkpkrJn3g8zj/7fIFbhaCbmPmPbrdzvq4HniairFDI+GVOTp9yXQ98BJDhdjuuKizceL4QxvPM9KnHk/JwUVHwUmbcC9A/XK6UN3y+smEeT8rSU/5Dp5w+48eO23/HHXd0OfS9/Px8bfzYu98ZN3bcS4e+f9dtd6WOHztuGyIdW8ffPN4Zea0oJ83nK/vS6gxKfCguLk7w+4NfWJ1DiQ+6Xpbr8wWnWp2jMbWE2yJ0RpszXgOoesasGXcduuCvr/21FMQVE8befRUAsMZ3EeNf1sRUmj75mNUJlPiQnp4eJpKTrc6hxIdw2L5WCNGiBtlrPo+i/mLcy2CMBtADoO8BrH5h1gujJtwyYTALuQKgLQBLAADzghdef/FmAJhwywQPC/k6GB1BWEMkbpz+9+nbLTwURVEURVEURQF8vuDfrM6gxIeCggK7zxd80eocSnzw+QJuny/Yop5CbAm3RRSlkVA/qxMo8SE5OZmEQJrVOZT4QCTaAFATGyqKcvLWrl3b1uoMSvwoLt7WxuoMSnxYsIBty5ZtTLY6h6IoiqIoiqIoLZ16FFWJUo+iKodSj6IqitJgRLzZ6gxKfKiqqmJmbLE6hxIfpKRqIbDb6hyKoiiKoiiKorR0hYXlOVZnUOIDM4vIEOmKAp8v0GHVqo19rc7RmNRtEUWJESL+k9UZlPhQUlJiA/C01TmU+EAkzhHC+IXVORqTalwoSowQyYVWZ1Diw7Zt6ZK5ZU2xrRybEHKHEPyN1TkURVEURVEURWnpfL7gDVZnUOLD7Nms6XrgZ1bnUOKD31/Rs6iodITVORqTui2iKDFDd1qdQIkPGRklGhHdbnUOJT4wGw7DEKOsztGYVONCUWJECPzR6gxKfEhPTw9LiT9bnUOJD3a7/A4QH1idQ1EURVEURVGUlk7XA49bnUGJDwsWsE3Xg49anUOJD0VFgQF+f+DnVudoTOq2iKLECLMYaXUGJT5061YiiNCiOvApxyal6CIlnWN1jsakGheKEiNCGHdYnUGJD+np6SEpjbutzqHEB7s9WSfSXrQ6h6IoiqIoiqIoLZ2uBz+2OoMSH4qLixN0Pfi+1TmU+OD3B85taX1w1G0RRYkRZmprdQYlfhChjdUZlPjALGzMSLI6h6IoiqIoiqIoLV1hYXkPqzMo8YGZqaAg2N3qHEp8CAQCScXFGztZnaMxqdsiihIjRPy21RmU+FBSUmK32/GG1TmU+LBnj8iprTV+b3WOxqQaF4oSM7zO6gRKfKiqqmIpsd7qHEp8YJb7AWy2OoeiKIqiKIqiKC2dzxcYaXUGJT4ws2hpU2wrx1ZQsLmL31+uRuhUFKUhhJpbRAEAlJSU2JhFixrXQDk2my00QEqp5hZRFOXkEcm3rM6gxIfi4nQDwLtW51DiA7OsIOJFVudQFEVRFEVRFKWl0/XAnVZnUOLD7Nms+f3B263OocQHny/g0PXAKKtzNCZ1W0RRYoRZ3GB1BiU+ZGSUaAB+ZnUOJT4QiZ7M1KI6+KrGhaLEjHzM6gRKfEhPTw8TyclW51DiQzhsXyuEUIPsKYqiKIqiKIpiMZ8v+DerMyjxoaCgwO7zBV+0OocSH3y+gNvnC46zOkdjUrdFFCVmqJ/VCZT4kJycTEIgzeocSnwgEm0AtKiJDVXjQlFihJla1CA5yrGlp6eHQiHcYnUOJT60by8LEhK0P1mdQ1EURVEURVGUls7nK/vS6gxKfCguLk7w+4NfWJ1DiQ+6Xpbr8wWnWp2jManbIooSI0SsplRWAJhTrjNji9U5lPggJVULgd1W51AURVEURVEUpaXz+0v7W51BiQ/MTD7fBvW0iAIAKC7e1kbXN55ldY7GpG6LKEqMSKnNtDqDEh9KSkrsQmhqnAsFABAKVbmZjbutztGYVONCUWKESC60OoMSH7ZtS5fMUFNsKwAAIeQOIfgbq3MoiqIoiqIoitLS+XxBNSuqAsCccl3XA2pWVAUA4PdX9CwqKlWzoiqK0hB0p9UJlPiQkVGiEdHtVudQ4gOz4TAMMcrqHI1JNS4UJWb4ZasTKPGhuDjdYOZXrM6hxAciLahpcr7VORRFURRFURRFael0PfC41RmU+LBgAdt0Pfio1TmU+FBUFBjg9wda1MSGNqsDxMr4W8dPB/EVAHrVJoS6zpw5c0d9lo0bO24tAe0BGOY7dNMLs15Y2LjpleaAWYy0OoMSH7p1KxHhcOsW1YHvlHm9Al6vtDrG6SCl6MLM51idozE1m8YFEc3WwrVPhm329SezDADIJgZNf2V6xelPqTRnQhh3WJ1BiQ/p6ekhXS9tUYMmnbJC280AvwEQWx0l1uz2ZD0UqglYnaMxNZsOndNnTV/85zdn1jlR0PGWKUqsuFyp31qdQYkPRMQeT586/zGjHAMjD2OmZh98PcrbycI0MZWR0W2/291rk9U5GlOzuXJxKjgsF44fO44A/ryVqH7gmdde23fkOqtWBc+226lVbe32ouzs7PDq1eVZzFTjcvX+prh4WxvDqOrPzLtcLkeguDhwpmGIs5hDG12uvttWry7vw8wdmBPXulxnHli9ujRTSmFzuRyFxcXFCYbRZiCzsd/lSv22uHhjJ8OQTmZtq8vVs2L16u96Mdu7ASjNzEzZXVQUGACI1rW124tycnJCRUVl2YCozczstTqaA8DuzMyU0tWrS89g1noSGRUDB6ZuLSoqSwXQMZqjqGjjQEAmZGamrIrmAOSBzEzn2qKiso4AUolC2wYO7LvR76/oSWScEc3h95f2J9LaaNr+1RkZGbV+fzBLCBkeODC1yO//vjVRzQAi+mHgwN4b/P7vuhHZe2ma3JSR4fze7w86iaiTpiV/m5HRbb/fX34OEScOHNi7cNWqVbaEhK6ZoRBXZmc71vh8gQ6aJvpEc+j6xrOEkGdqmghkZPTapesb+glha5ucXPtNWlpajd8fzDIMaWRlpfoLCja3SkgInR3NUVi4vqvNltA7msPnCzg0TXROSKhaN2DAgH2H5PAtXAjRuXO5K5qjoGBD+4QEW9/a2vD2nJw+5YWF5T1sNu5eVaUFhwzpuVPXN/Rjtk3v0EFe4XQ6q3U96JFSyqysVP+yZRuT27SR6aGQ2JOd3eu7goLNXRISQim1tbw5J8exJZqjsrJ2/bnnpu3V9bIMIZC0dm1vHQAGDCh3h8OoyspKKVm+fH27Vq0S0sJhY0dWVmpZNEdtrb0sJ6fHDp9vQ5qm2drt3y9Khg7tVeXzBdwA4PE49UAgkLRvn8gwjPBej6fP+miOcJi2ZGX13lxYWJpis2ldamvD3+Xk9NlTWFiWbrMhee3a3np+Pnj16nKPlKh2u1OKozkMQ+70eJzBgoJg94QE6hEO15ZnZaVtX7VqY1+7XbaP5igsLHUJIYTb7fBFc0gZ3ud291m3YkVF5+RkwyGl+N7t7rWpoGBD74QEW9dojmjd27mzt3/kSBiH1r21a9e2ra1N7ndk3YvmiNa92lr7mpycHpWH1r3169cnVlUlnHNk3YvmiNY9w5AbPB7nD4fWveg54Mi6F83h96/vKaXtZSGMX7hcfbcdWfdWry7NZNbsh9a9aI5o3YueA46se9Ec0bp36DkgWvei54Bo3TvyHBCte9FzwKF1L3oOOFHdi54DDq170XPAkXXvWOeAQ+veoMf+eV6tEb52wQLWO3cud1047b37tl8x5QGf98Z9mib6ROteNMehde/Qc8ChdS+aI1r3oueAI+teNEe07h16DojWveg54Mi6F80RrXtt28pip9NZfWjd8/nKhgmBfCnDM+qqez5foIPH4/yhMf7eNZZmc+WiocigS1+YNSONQsJDRJ0qZdIzda2naXSRlDI/Obl34pw5EFLKfCn5MgAIhyu7SinzAR4CADU16G8ut/UFAMPgoebycEdzfZEnJV1rLmvTWkqZz0wXmNuGepnbhjMBQEq7O7L8LHN9ulBKmR8Ot09mZoqsO9rcdn9nKWW+YfC55ra2fuZrLS2S4zwpZX4odKAzADCHLzfLZqqqSko216WfmEcseppl291mWeFMKWU+kdEr8sn9REqZX1vbqpW5nK6VUlwOAELs7xTJcV4kR18pZX5NDSITe/G55rYHupjL+TIpZf6cORBt2rRJklLmaxouBAAicZZ5vFqW+To80Nw23DuS8wIpZf6uXcltIl/V1UKIPACw2YyO5rZGrvkd2vqYx09nm2VhiPm6VTdzU3mJlDJ/1apVWqdOWxOllPk2G10MAAkJorv5Wss2jzF8jpQyPykpnGKWpY0gwtm7d4fbRnJcJYR2BQC0bx9ubx5TeLiZqzpVSplvt1O6WZbIkVLmJyaKMyKfzygpZb7H852tZ8+KBCllvhByFAAkJYkzzbJETmTd9EjZzkiO4VLK/LZtQ+0iOa4kwlUAsHev0c4sSxsROQaH+Z1yRiRHdiTXmWZZ8mIpZX7PnhUJJSUltshv/BIAsNuTupmvxSDzNc42c9hSI2XnSinzExKMDuZr7QoAVwPAzp2Jbczfne1885jCKZH6cY75PYksM5fWw/y86KdSyvxOnbYmLlwIzfxdyksBoLY2uWvkNzzYfI0BZln2vpHf1jDzezM6mnVAjJES15jrJkXr3kjzdbi3+fkYkbqX4DFziLMiv/GLpJT5bdq0SQIQqXvyMnPbA10in8+5kd9lfyEoXUp7mrkthppl7+9kvhaXS4lrzW1btTK3NesekRE9B7gAgNlwRz7rnuYxmHWvqiopOVL2tczhywEgFDoQPQecZ25r72ceo1n3DMOsezU1+zub24ZHm2WDwuH20XPAhZHvLHIOSPCYr41Mc9tQL7NsusCsi0mtIzmuCYfNume3y06Rc+Qwc79m3autxYDI73aIWVZSFwAI7thzTa1h9ADo2m7dtift2H/gxh8qq6+CQddLSd0jv/ksc1uz7iUmmucAZtv5Usr8PXtaR+ve1UKIMZHfYQfzcw9HzwGRuofIOUAMllLmHzjQOlr3LpFS5peUlNjatt2SYH7/8mLzmOhMsyyRbW7LGWZZ0hn5vEZIKfP37jXamctxFYArI59dZyl5MJE23MwRdkZ+L+mRHM1uUjOyOkCsjR87bn9tQshxaKfN+iwDgHtuufsCKei5F2bN8Jz+pIqiKAoAIG/yxQDNAtABJIdBUg6IXgSwGnMnZVmcTmmAFn3l4oHbbms74fYJPQFgwoQJiYagWxjQrc6lNE2FheU9rM6gxAdmpoKCYHerczQdYhCIloLoEzD9DETjATwKIB2jpzb5pywCgUBScfHGZtOHpD6aTeNi/C/GvTx+7LgKAK0SahOKxo8dP/9Ey2rCbTtyWH42fuy4TbxXfgfAnqAl/N6iQ1CaOCJ+2+oMSnwoKSmx2+14w+ocTQd7wOwD432AfgWgL5JsfwXwOQTnW53uVO3ZI3Jqa40W9bel2XTofOHvM445r8Oxlj3/xvPlAJp8q1iJF7zO6gRKfKiqqmJNa62eFqm/bEj6G2ToK9hsrwF4C3Me2oO8KW8DeALAYxbnOyXMcj9Am63OoSiKoihxhgn53oSYF3vVk52RN0Uiz9sFAJA3ZS7yppgdYy9+tjXypuzHmCk/Dkg25um2yH8uOeY5lJhqNrdFFMVqPl9gpNUZlPjAzKLZTbE9ZrIb1drFMS83bGQDKMdcr9nRnjEZcyctBwB8fv8BMD0LxivI97ZBnrcLOPxfVFUOjHmO06igYHMXv7+8RV0lV40LRYkZoeYWUQAAJSUlNmbRvOYWYe0ygK6OebkksgEUHHz98aSVhy1PTpsCYCuqbbMA22KAs0HmY9xNhc0WGiClbFFzi6jGhaLECJF8y+oMSnwoLk43ALxrdY7YkpcCGIOR3tj21WPOBtGqYy6fc50BAzcBuBDAUgCvg/nsmGY4zZhlBREvsjpHY1KNC0WJEbfb+bLVGZT4cN11ZLhcjleszhEzo7ydABoCwI62Wqxv92RA8jfHXePTSWUQYhjmPvIrgFeD0KSuXHg8zqDb7Zx/4jWbD9W4UJQY0fXAMZ9YUlqW2bNZ8/uDt1udI2YSbKMAlIDxL5A4+taI19uwvyV3vGwH0AfgtSdc98OHSwBiENYATatx4fMFHLoeGGV1jsakGheKEiPM4garMyjxISOjRAPwM6tzxA5fDuBjCJ4D5muRP1s7uOiqJztjlS2vQcVu3ZkGQCK5f2m9twkZ3wBw4OJnWzdonxYgEj2ZqXl18D0B1bhQlJiRTfpZfCV20tPTw0RystU5YmKk1wbQJQDm4cxu/wWQgOp15x1cbhjXAXA1qGw2BgBYjznXGfXeZp63AsA+2KsGNGifFgiH7WuFEC1qkD3VuFCUGPF4nAutzqDEByKSmZmpzaMDX3vbYAAC+8LLMfPOEIDPDntqRNJNABr2h56pH0ANGXzuW2hak+nUmZPTY4fL1fv4/UqaGdW4UJQY0fXgc1ZnUOLDggVs0/XA01bnOCV5U2/AmKkbIbEE4M+x0Bs2F/AsgG9FnrcVLp+cBsJ5IDT0D/2AevW3OFpJU3pixO8vP0fXg7dZnaMxqcaFosQIM2VbnUGJD926lQgiatqzeTIGg3kpBFIwd9L1B9+fO+kLAFtB9psg6BYA34HRv2GdOmkAmL49+c2wBmg6Y10wcwdm9LE6R2NSjQtFiRFmalGD5CjHlp6eHgqFcIvVOU4JcR8QfY0PJ20EiA9dAMZfwDwBjJvBeBxAAr5OdJz8Trh/g65cMJeAuMk0Ltq3lwUJCdqfrM7RmFTjQlFiJCurt5qYSAEAEBHn5Di2WJ3jFPUFZN2TryW3eh1AdwCt0KPrbAClEOGT+2M/xtsDQHsI+5oGZCsGo09TmWPE6XRWZ2T02mV1jsakGheKEiM+X9mXVmdQ4kNxcXGC3x/8wuocDWbe4nDAEHU/Ijrn3ioQvwZgTqST51qAjt+p0xzT4kdS6wfQFnz04L6TzpdtlAGoQdX+fie9rQV0vSzX5wtOtTpHY1KNC0WJESI++ZOk0mwxY7/VGRrMZzsLQCJE6NjjT4RpBgh/BwAw1oBP0Klz87Y7MGZy/x/foAEAn3x/CwDweiUYOkCDG7R9IyOSYSJUW52jMcV2jHhFacHcbsflVmdQ4kNGRkYtgKusztFgBvcB0feY66085jqfTioDUAYAIFoDyDuOWybhRrDoD+CeyBsDADTkSZHI5rQCwBAAf2twGY3E5XIuB7Dc6hyNSV25UJQY8ftL+594LaUlYGby+TakHbXgyFsD8YrQB8CGeq8vjDUARa5cMCHf2+aw5VdO7gPQuQDfijFPtwWYQDwMkA3pbxHZDUcbF3GvuHhbG13feJbVORqTalwoSoxIqc20OoMSH0pKSuxCaC8etWDzjqbxRBGfZOOiVq4B0B5XT+2OvKmPotp2+JgOUtwA4AsAGyBrb0He1OsBOCBtbzY4o01bAeBss7ES30KhKjezcbfVORqTalwoSowQyYVWZ1Diw7Zt6ZIZR4/QSXwrLn2yqwWRTg6hD4jq37iY590LYDNC/ACAxwA6fJ4d5hvA9E8QvQCiCQCeBvPD+GTi7gZn/GBiEMAOIJzT4DIaiRByhxAnmPm1mVGNC0WJEbfbqeYWUQAAF1xAYbfbcfjcIld6OwAYDtHAobIbE4k+4JO4cmEqAfBbECYCnIUxT/UFAIx+IhtAbwjb+0hMfhtAZwBbkWO8eso5mVaAOe5vjWRmOte6XE41t4iiKCfP7y9r2MyQSrPDzMLnC44+7E3DdikAOwTHf98c5j4Qxsk2LtYAeBEfTXoGwHxIeSMAQNN+AeBDfPTgPsy5twrMfwMwAV6vPOWcxCsAql/j4tK/JB7+BtMp77+eiosDZ/p85YMaa3/xQDUuFCVGpMR9VmdQGtezS5d2m7poUfcj3y8pKbEJgd8e9ibzGABhQMb3lYurnuwMoAOkPLnGhZBvoXvX6DG/BcE3YMzU0WC+FUTTDq5ntH8ccyfF5skJphUATvw46pip18O2Z13k6pHp8inXxCRDPYRCoi8gr2ys/cUD1bhQlJjhl61OoDSOZ+fPb/30kiWPGszfaUIMP3J5cXG6wcyvHHzjjpftILoEwHsAxfeVi5DsA2AP5np3nNR2H/5hRWRALaAm8SMweoB5DoC78dEjRQfXm3dPTcyyGqGvAT4To59KrXO51ytw+ZQvwPwCQIkI20YBiH4fTzbW1QsiLahpcn5j7CteqMaFosSIx+N4y+oMSuMIt249jzF05ioAACAASURBVIExAEpB1PPI5dddR4bb7Xz34Bubd4wAUAPmNwDEd+PCHH/iZG+JHO7z+w8A/AGIXsPcSf+ITa46mB1JP4FmPFHn8gJbdxAuAoUzAX4TAuatyy3bLwOQhryne522bIdwuXpWZGamHt3BtxlTjQtFiRFdDzxudQbl9PvLp58mEjCEgJsYWAzmoxoX5pTrwUcPvkE8BsDH5myecCLfm1Bn4WMmjzlduU8of7aGMVN/D+IZAD485fIknkRi6N5TD3Yi/BswrsLlk0cevUz0BrATH3k3g/ExGJcgf7YG0Fhz09A5pz8fUFQUGOD3B5rGY8gxohoXihIjzGKk1RmU029/27ZuAAceGDZsHQGbqI4rF+aU6xhhvmICkAdgbmROjBBqE/oeVfDlk9PA9CbGTD3jtB7AsVSvuxPAbwFxOeZOqvtKwMn45NE1mOOtPfVgJzD30QAYT4FoxtGDlMneAMoBAPuNJQAEar69AuDLABRDUKM0LqQUXaRsnH3FC9W4UJQYYabfW51BqacxUzOR92SDOlYKIQYD+JqImJg31XXlIj09PQzgQQBA3lMjALRDuN1nkSck1sOQh98aufQviRDibQBtIeXx5+g4ffpD8geY+3DTm4DPaPcsADs2b//l4Qvox8bFQm8YwGdgegHgVQB/AEaj/MFnlt9Iqf29MfYVL1TjQlFiJCurd4HVGZR6GD35bDD/B5A68qb+JfJ0RL0xMAhEKwEARBUMHDWsMxFJl8tRaL4ybgfwj0M6Mn4LccQMora90acplpxwdtHTpx+I11m071Mz754aMB6FoEcw0pv04wLujej8JwAA+hhAd5CYBRLfAI3TuPB4nD9kZ/f6rjH2FS9U40JRYkTXgy1qkJwmafRTqRD0BZhfgaQcEIYiLP9wMkUQ8yAABQBgMG8C0N3LfNi51Hbl1ImffVn8LkZ5OwF0DST9OGAU4VvwIWNd5E2eAOBWSPlzAEWWNi6kaJqNCwDICc8B80600+788U3qDWDjwZdSzAOwDyI0Gwa+AXC22Qfj9CosLM/x+4Mt6lF11bhQlBhhph5WZ2iqnlu2LPmZRYvOP/J9L7N4avHikTHbkTAeBrAMH096BJ888g3A0+s9CBOAaQUF7QH0MwxjJQDYKys3AbDbFy/+sZ/EpU92DRvsveXl+XlIsHsB1s19RUisRfSJkbyptwM0FSxG4+NH1wO8FoIbv3FhDjCVAiGbbuPCnIb9UTBNRJ63FQBAcG/QIVcuPpm4G+D78YH3B7QKrQOgoebbo/u/xJgQnCQlOp7u/dTX4LMHzRqckfPx6dyHalwoSox4PClH/XFU6qeKuY+hab888v3kpUsvJKKJMdzVQBA+AYgBACxWAOw+evTGulFlZQ4Bmx4ZMWILANw/atQBALuFpv3Y78Jm3ASQb9u+yucBngDg8GGuBb4F0B95U/4A8J8BvhIfP/xVZNkasAXDgyfs7wMgFOlw2nR9PGkuiEKAdi4AgNEbJMsPW2fuJHOCQbOz6Trw6e9o6XanLPF4HI+cajnZ2dmtBp89+JHB6YP0wemDDgxOH1Q9KGNQ0eD0wV63293hxCU0HtW4UJQYWbt2bdzPzhivhJRpxHxN5MrAQRK4FcBFU7788tTHI/B6BYB0MK0++N7cid8CqIS2P6t+QcVgBlYe8W6FMIxD+l3QbQBeKZ52x1QQ/RxJxruHr27/FkAHgO4EYSTmPvq/g4tqjbUAeuPiZ1ufxJGdOmn0A7AhJkNyW41RAKKcyGypnaBphzcuog1L0zeN0bhYsIBty5ZtTD6VMtxudwetkr4C8X1geksIHs2Ecwk0DZAjEmvtt8cqb31kZ2fbj7fc1lhBFKW5q6pK/hiAunrRACREGphbobr6egAvA4B3+fJ2FA5fBSBgt9luATD1ROVMW7r0V8Q8uKpjx3HejIzDH4MsTEwFjCSE2xYfsmcGpqwA5HkAvjpR+Uw0uI71KiCEeeXiiilDIdF7dIbjvXC48n189MhPjyrkowf3IW/KO0DoHnx0xCiY87wVyJuyF/aqAQBWnShP7NAAAGsbb3+nEWElGIMhw59CoBr/fvh74FgXDWg1iD2nO1LHjuXnMvOlOHaQE0oI2Z+FQJoGI/OrksJDO4fqAN7y9PVEZ9sVg88ePBHEtwM4C4QKSHpp5ZqVzwLgowqu5zaD0gf9i0AMkqXMdBNV44yRjpFtFgYXVtdZYEMPVFGUIzXRnvZxgJjTAGwD8Ivoe8nhcD7MkSL/wMCtzMcfqvmpZcv6gvlPDIxM2r37v1OXLz98vAg2MgBsqGP46ZWgesxPAQDM5wE4bF4MAjYdHKVT4lYAcx6/tv9+KbH+mOVkh286zvDa6yG0xh7Fsy/AzeNpBgOFALIh0AtAxRFXKo4giwGkn+5IzHI/gM0N3T47O9sOxs/B/PpXxYV1fk++73zbAWBQxqAHQPwwgScTiwwCpoH48cEZOb+ta7uT24avICbZmir7t0Jlh4XBhcccyl1duVCUGPF4HL+yOkNTJYnSIOVzROSdtmRJxkO5ucUSuBXMrydq2vu1Ur749NKlwwAsqWt774IFNpLyH0z0j5rExPuTqqtn28Lh5wFc/+NadA4Iq4/amHkFiG45UcZnli7tI5k7VScmHv7IMVEFM/fFSK8NwLUgXJWTkxMCcPcxCzvu7QdeCzRyp07ifoBY1qj7PF0SqABhTgGQhegYF8fmB5CGMU/1xUcTT1vjyuNx6jCvMDSIqBW9ALTmQ2/p1Y0IeIgYf1qxpuC1yHvrB589KBWgRwD83ylus3FFydePADjh7TN15UJRYsTnC4y0OkNTRcxpgmglmD8A8MDTS5f+goBzJfNb9w4dWkVE7wIYe6ztk+z2pwB0qklMvN+bk1MJ5pcZOOJyt8wEUHTUxiFjOYAUXD7lqPEqDsVSDgWge3NyKg8r1XwctSfa2S8AUIus8BJmFkVFpSOeWry47gm1jodECUCn/V/Th2HqD+LmcVvk/Yd3AigFOB+HjXFRh7mPBgD6K9h49+jRPWOnoGBzF7+//LT37Rh0zqCeYLSXwGHzmEjiLwF0zj47+6gZfE9mGwa+QT0aFoBqXChKDAk1t0gDeBcsaAOgO2y29Ww+WXERS3k7gGejT2Uw8z8A5D+3bNlRneKmLV58C4Bfa1LmR//wh6XUAfSNlB1BGZHL4Ieb790FYAOIBx0vJxOdx8xH98tgrgDQE4w8APPg9cqSkhIbs3iUhLj2RLdzjibNp0kaS/609gC6oVYc+zZO01MIwIVDx7g4lqTQwwA64Psdp20cCpstNECa45g0SKWsrABwgIgHxjDWSROEqnqvezqDKEpLIgTPtTpDU9QqIaEvgKoHhgzZNHH48P88lJt71kPDhw97KDf3YOe3B4cNWwpgZ62UeYduO23p0hEgeomZb7l/xIiDVyUmnX/+RgA/JCUmZgJAZKKwfghr36BOvBLmZfTjGQqio24dSCEqAJxFhCtA/AEAbNuWLqXkT5h52NSvvjq58U9IWwsg7bQP7nT5k+fh8qmPoca4FMBuzHt4+2ndX2Ni+jryPye6LQLM8e4HxG1gfizyhEnMGYb4HuCvG7p9cXFxLYjfAWjseRlZdY7L4enr6fr1N19XgLBHIDqvjUkwnQ9g56o1q7YcuV1DtqkP1edCUWLE5XL80eoMTZEhZRqIviM6dsc7IuJpS5f+k5lvBDAbAKYtWzYKUr4HokkTc3PfP2wDcxAlnQzDDWAZakV/ACG07nuMqcTpOxD6RF95mUXikiUXE9GvmPmdGrt9PsLhc6iOJ0qElJtAlJycZOtSyfYvAOCCCygM4M/Tliy5L0HKVACb6v2BJNR+h2qbDaFvHTjVqc+Ph+QQAL8DoxVAhadtP1YQKAADIHHixgUAzH34S+RNKYcMXQTg/ROuf5IiQ3+fUp8ODfYHDITPNVj7evDZg59i5hXQsIdA6WB5O4E+BfBHgJ5i4j8MSR8UAIslEPICZvyGmI81Xgw3YJsTUlcuFCVGdD1w54nXUo5ERGmE4zxZEV2P+U0CLnlyxYrOTy9ZciukfI+Jxj80bNhzR6+t3bxl2/4fGHADAKQ2EEAJ5lxnHKP0AJgd0VfJy5a9SUSzAFQS0UuJhnE1mLc8lJt71B+ricOH7zYkh87s2mo55txbBQCzZ7P2ZcG3vwdwlkHU58htjssc3GkjpDj5/honhfqBaRZqw2eC6Xend1+NLFErBMCArF/jwjQPwKWnI47PF3DoemDUqZTxVfFXu6ptNUOY8BwgbyQN84ixHFI+yEQLUCtmAsDK4pXPgulJBj3GJEsYeAhMj61YU/D8scpuyDYnoq5cKEqMMIsbEBmjQTkpaahH4+LB3Nxvpy1Z4tdCoQ8ZGAghrpk4dOj8Olcm6rds1aYLr7w4LfIvf3kpcLye9hQAhDP6ipnTAdzzUG7u7GmLF79GwEsg+vBYW+/dV8M553QPlkZeZ2SUaGVVuClSWEMaCRvA8jQ3LrgfCP+O9Dk54RgfTcqch/Ygb8o6JLauf+NC0qcQ/LfTEYdI9GTmEQDq/r3WU1FR0QEAkyP/HYtcuWblVBxnXJiVa74ee7LbfF3y9bUnEVVduVCU2JGPWZ2gKSIgjZnr1ZmQiN5kwAHmEQ8dq2EBAIy0Td/vSwTgsl85+TcAXQzwcU7IIgBwd+Q/F+0wmkpAaWSfvwGwua5bIgCAMVNGzF9UamSdc8bPnlq6dBBgTrleVrs/eqvh5BsJjNJDb9OcJv0gmvXYLPOiV5Lq5UDoSwCdccUTMe80GQ7b1wohWtTEhqpxoSgx4vE4F1qdoSlioC8JUa/70Vpt7Vtks5370PDh/hOsmrbzh+p7QSQ6dWw9DQJXmY8dHkNS6iYAIVRXpzy5aFFXAG3tQpQCwIO5ufuklDdL5sXHOIBf62u2vwYhniDmj59evrwnEck9MtSZgG9EQxoXRBvAdPquXJh9UnpC2ptz4+K9k1p7obcawP/AIua3RnJyeuxwuXofozNx86QaF4oSI7oerOPev3I8kblEzjAMo15XLu674IIdD557bsVxVzKfskitCcsva0PGhtzsXq/iw0nHHyDK7ItRDrATRKkAdt87dOiu6OKHR4xYOnH48KOH477K2w3A1WDjrw8NG/YMAYUyHL5jwQK22UA/YWAOowFXIIhL0ZBGyTFMXbTo8PENyN4XQBXmPnjiRzWbquxwQwYFmweOfb8Lv7/8HF0P3hbrcuOZalwoSowwU7bVGZoaqq5OA7Dv4eHDv49ZoZUbUgDYUNtmQ3KCtniwp0edcx/UIQCwk8w/6qUnXBsADPsvAV6OuX8oBgDJ/BoBN3zXqejMMLitlPJfALpFx9t4uaCgfgM1GbIUDWmU1GHasmVDhRCHT54mZT8A3x1/aOwmriGTsEntMwC5uOrJzrGMwswdmE/7ba64ohoXihIjzNTgQXJaKibyEFB0vMdQT55MA1COeffUMPAFM1/jZa7PuS4AwCmESCWi+jUumG8EiVeiL2vC4bkAuuzcv/9OIgpOHD58DYCq1pqWCgA/VFefcJhxAIBdbgDQDnneLvVa/xie/uqrsyHlXAKyDvsMiPqBqDnfEmmYTyaWAliPEI+OZbHt28uChATtT7EsM96pxoWixEhWVu8GT0zUgp3LsX5SQch+ANYBQE04/D6A9onLlo088YZUClAq1/fKxaVPdoU56dUX0be8F1xQDeBfYL6XmVdGGk2l4R8fR/3F00uWnHhQrQ+8PwDYCdjqHDCpPp5durSbNIx5ZI4LktR60aKUgwuJ+5tzmCh1eB+Cr4xlgU6nszojo9euE6/ZfKjGhaLEiM9X9qXVGZoc5nOZaPmJVzwZ1BeRAYsif+zfIuZfHH8bAMxBgB1gTpVSnrhxYefBAIL46JGthxfDbwJolZrQNjq3SSmA1KmLFnVn4DxpPuZan+MoBeA84WrHYEh5CQE/VA0bNg5AYF+VkYWR3iQzJNJwioM6NVsCn4BxES79S2KsitT1slyfL3jMxzybo2YzzsX4W8dPB/EVAHrVJoS6zpw5c0d9lt099m63AM1ioD2B1rHkG2a8MWOnFcegNGF5U84l4n1Wx2hK/m/Bgg41wABR13wdpyYNxAcfU2UhXiUpl0wrKBj/UE7OnuNsF4D5x3wf6nPlQsphICw98u2a3NxFycuWVbQVCdsAAESlIErVgCvBLEiIswH858SHwaVAw58YYaJBIFrqJZJPLVlSsmNf9UVoa7sCwC0A9YMU6rZIXTzh5Vhlq4R9zwXwej/HKrsbcx85pRFMiWQYoPr2/WkWms2VCyKabQuHhgA4cDLLBOhVlnh8xqwZTpDUSdATjZFXaUbyJjtBfJfb7bjc6ihNSU1i4hAAFQ/m5sb6dlIa5I+Dck0cOtQH4FtUV19/nG0AQwRsGnUE0BP1aVwQhoJw1BMJXiLJzG/qVTvyzNVQKphTwXw1gH1U3ysXzKUAN7gTIAE5AKLzWRQLEh4ANyNv8jQAnWGHalzUxeuVYHwCiF+iwDYf4GUYMyWnweVd8WS6y+Vc7nY7jjfwVbPTbBoX02dNX/znN2fWOcHKsZbdddtdqQB6znhjxgcAgLB4KTJNr6LUH9MoMF3o95c23kyWzQAbxnnHHJjqZOVNvRR5Ux+JTJvtwBEjfjLzCwDuO+7TGvMe3t6pQ/IBMHNNOHz8kR3veNkO0CBAHHXlAgBEQsLzl7Tp0QUAGNgQGYb8fCJ6kc1+GidG2AA0aHTP6FMpbgkUAAARlSQnaX0AfArQeAA7I1OTK3UR/CGYrwVhD4j/AsZsXOntcNLljHnCAynvLy7e1kbXN551GpLGrWbTuGgIG6MXgAoADABbq7eWA+g8YcKEmN1rU1oAwiUAziqu+OFNq6M0JURU5yyjxzXSa8Popzpi9FMdMdJr3tYdM2UEwHMAfgSbd/wcAKNHt+Chm9Xk5s4CcGB3VdXdxyv+jK6tt9eEjO3eCy4IHzfH5u0eACFkheocGGl069a7hNBeBABJtAHAmSBazUQfAcio17GSaPBtkT2VlQMB1IaGDi0BAAF8075NYifNbn8HwK1gfNuQclsMNv4D5tswd9K1yDIeAmEdpP3khwZnMRHAoFCoys1sHPe319w0mz4Xp5vPF7iVSJxJlPhCZuYZVX5/+f2A/MHtdr68evV3vQzDfgMRSlyulLl+f2AIsxgpBP6TmZmySteDVwHULxzmN3JyHFt8vuA4gFp7PCnPFBRsaG+z2X7NzBUej+Ofq1YFz9Y0GgPwSrfbscDvL7uQGTlExgcuV+q3ul52M4AeSUlVLw4YMGCfrpc9SCT3ulzOv5otY3kTs1zr8Tg/9PnKBxHxT5jpfx5P7699vsAVRGKAlPSPrKzem32+4N1E1NbtTnl67dq1baurk+8GsNntTvmH31/an1m7kggFLlfKf3U9eAFAg4WQH2ZmOtfqetlNAM6qrq7967nnpu31+coeAPiAx+OYUVAQ7G6z0S0Ar3O7He8XFZVlS4mLiORCl8u5wu8vH8PMZxNp/3S5elboeuDXgGjvcvV+tqhoazJzzXhm+b3H43zd59uQRmS7mhmFHk/KF4WFgfOFEOdKiblZWSklPl/wBiLqxSxf9nicP/j9wfuYqcbtTpm+enXpGYahjSXi71wux3u6HvQAdLGUvCgry/GVrpddDiAjHA6/nZPTp1zXy+4A0HH37t5/SkyssLdqJe8B5Da32/n31avL+xgGXwtI3e12zvf7y4cz89DNe/Z/ftkf3/9Jgk3sXbp+c8fi4o2dMjJ67dL14L1EZLhcKc8XFq7vKkTCbcwo9XhS5hQWlrqE0C5hxhKPJ2Wpzxe8jIgGMst3PR5n0O8P3s5Mne32/f+XkJBABw4k/JaId7hcjlf9/qCTma4TgosyMx3zdL0sF8AwTTPmDRyYWqTrZdcBcIbD9ldzcnrs8PkCvwUAj8f554KCzV1sttAvAQTc7pTZq1eXZhqGdimApW53yhK/P3AJs3AJgTmZmSml5qA/1LV9e/n8zp07DZut671EvNPlcrzi8wUcROJnzLza43F86vMFhxLRcGY53+Nx6n5/2bXM6EMU+rvL1Xeb3192DzPbF+wOvEpJSXe6E7u0X1G1bZgh5aN+f/k5zDxaCOOrzMzURbpeejGgeQxDvJed3es7ny8wlkicEQ7bpw9+fNbdEsazAIC2tn3JV0/7Oix52JC+Z85a8u3mjST4lXbJiXsWjRs10DUThboevBqgNHtJ8PWPgSeE0P6+wlfaZogndarPF+hAJO5k5o0ej+OtwsKy9CmLViRVVRphACgsLLtICGQD4ffd7j7r/P6yW5jR3W5PnjFw4szc3l3abf3gyrw73F7vS35/RU9m40YiWuNy9f6opqZ1tqbBXlhYnvPRng3fJNntfIaWvLOr3b77m6o9nRetWvdAOy2R3O6Up5cvX98uKSnhLgCb3O6UN4uKAgOkFFd8UVxWdv87i87667+WX3Ne3+59D6l7R50DmHnf4i0lr6JDp7tGtOqe6Kve0fv7cJV/jG9j1pV62YXbKiuXr9J2iEfyc/pcfXbfqt+9/d8nFnwM+P2Bu5hFO5er9zMlJdtbh0JV44iwxeVKeUPXN/QDbFdJiVVZWSn/8fkCI4nEEMPgj7KzHWt8vuCNRNQzHA6/lJPTZ4/PF7yfCFVut+OF4uLAmaGQuBXg9W63499+fzCLmX5KJL90uZzL/f6yPGaka1rorYED+240J/0THdat6/3H1NQtiTZbaAKz3OrxOGetWrWxr6bJawDD53anfl5UVDpCSu08AB+73SnFfn/g58yitxCYmZmZslvXg78nopDLlfIXv/+7bsz2XxBhg8uV8i+fL+AmEqOYebHH41jm8wVHE9E5UhrvZGWllvl8Zb8iQqdwePtznTt3fnvPlFseBHi7e8Ws22GzBd/7Qp/ct1v7pS6X87No3RNCfJqZ2Wu1rgd+BghHTY32ypAhPXdOn73kqd+8+eXVkhnrt+1u1e+Mjv10vey6uuqerm/o53b3aVa3qVr0lYswYSOAXgAIAM5IOqM3gJ3Tp0+vOXJdZrGJGaXt2lUZ5muUMtNGAAiFuJoZpYDcFln7B2aUhkJiT2TdrcwoTU7WagBACCoXwryna7e3DjOjlAibASAhIbyfGaWaJncCgJRyp1l2wgEAIMJmZpTu2tU6HM0hJZUDQE0NVTOjVAhsNdcN7THLDkVy0LZIrujxlZllA7t2RXNwZGrohANm2WYOTTNzEBmRfiu8iRmlNpuZQwiUElEZACQnazXm52PmMIzwXnM//IO5rbE1kqM6kqs8mqNduyrD3FZsMo8hoTKSawcA2Gy2XWau8P5Ijs3MKE1IaB39l2YgmoNZq418Pt+bxyD2RnJFc2xjRqndztXmMfBGZpRu3w7u2rVaRnJUmJ+tjOSg7ZH97GZG6ePvfdUfQG1q1w7vf+jbsEvTDoSiOaSUQfM7FLVrNu/cToQt5jFo+yI5dpuriu3mZ8lVZm4zx7Zt6XLPnj2RHHKjuS1XMaM0HBaH5ZBS7DM/L9piLj9QG1kejPyHcPhArfn7ML6P5NoX+dx3m9uaOTRNVpqbygpmlFZWVsp9+7I58h1WHJoDMHNIaebQNLE38rv83syl1UZ+x2V7jaqdNQkJ/62RcvyKyq0PALC12bdPN4xw5POw7Yrk2BH5ziM5zLq3oGQ1SRgTLnc5Z7xz9+jrIHBJkl2sHNq3x1sv3HT+a0hKm5Zks5W0SrBvDIe1SA7ayoxSwxA1Dwwb9r4G+n51zc4B5vedHIoc02YzY3h/186tDuz4oao28ns4rO4B2MSM0latDoQl6LyubVv5mM26FwqJyDnA2BapL7ukpBlEoT3eCy6oFsCOLrbkz5xJHbYC2LLNqBTR37zNdrDubTaP3zjAjNILz+65BuB/PTjny3trDSPAbN9vLjfr3v797QyMnjoq8rssr27XbnAlG94fjOpde43QWcT8dfQc8I+Fxa137anhlJQOB5hR+mz+JavMY/6x7u3ZU2NE/v+wcwCRjNQ93mV+T8Zh5yK7/ehzgGGI6Dnge/O3p+2NnOcidU9GzkXRumfmyM8Ht29/IHoOqIgcb6TuiR3mdxo9Bxj7zX2ZOTQt+WDdAyhS98xzQDRHtO5JebDubYv85qvMHHIjM0r37cvmyspKGTmvV2Cet8JuE8WvflnckejwumcY4X2R38sWc19VIQD4v898g3t1arMEwI7731oqpMRsItpSV9075DfWbJDVAWJt/Nhx+2sTQo5Dnwg53rLxv7i7kBhTps968d/jxo57RjDaTH99Rou6fKWcgrzJ0wBygMR0G2F+OKFv+6Om9R7j7QGpXYWPH51hScbTgJnp6WXLfhcOh+dMOv/8jd6CglZJ1dVZD+XmLqlr/amLFnXXhPgCwNrqjh1vSNq9+0wQjXho2LD630rKm3oDwFOxL5yGhd66b1tcPjkNRGMxd9IjdS2etnTpXcR844O5ubl1Lb9v7he+b77d3u6z+244dkfKkV4b2tq+B+FqfDRpUV2rMLPQ9bJLPR7HJwDw9JIlf3swN/dXADBtyZL/MjBnYm7uS8c/YAD509qjOuwDMBNzJ007bFnekwMAuQDZ4bPg9cppixdPAtETRPQOA/0BPPvQsGHvAADGTL3+9p9lvtQnpePUibm5z55wv8rRxkz2gikdcyddd8J1L5uSAg3rICkbgqd1a9dq5fz7rp33/+ydd3hUVfrHv++5dyaVXgVMoZsgmUBWgYQSGxKaqIllbav7W3cV105HR2nBtirYde2rJqJICAiWIJlE0EAmYKLSMgkISK8pM/ee9/fHTMKkh/SE+TzPeZ7Mqe/c3Jl57zlvCQ8P+LnGsfVg0rhJvwHcAYDrO4huW71h9YbGXLMq2szOxfS/3f/G9Lvu3wfA12g3bpt+1/R1tWkjXbmHQebpGoLWhgAAIABJREFUd96/lwAThPBktvRQe4jGA/Q1enb5SVWENwp3VAwBzoZxACr9MWutLE1PnwLmRaqi7FpqsVi8i4oOA/hhqcUyGwDM2dnG+PT08Ys2beoRb7GECiF+BLCp7/79N5lDQ+2zoqLyz0uxAADwowBeqlKxAIDV83fC23dhVc1Syu8YuKwkHHd5Ovgbe+btP9WptCLWbKzQqb1hNACG18BKjTkBICcnRxUCD5W81oUojc7IQA7V1qgzcdZJMG4G8AQmL5oL8LkHQuIFAHpiqzrM+ZrGEtELzDwJzCYmyijtyxx2psCRh9rae3ioiKQ1AMa7jIaBmMUDK+033twZCr4E+HMkz/0FxBlEFAXIBg3MVRU65F9Wb0ju4yzNo1gAbcjmYvm7r9xbl7ZlHyzLBDC0UYTy0La5ftFFcPBQkGM93rzX0fn2F7ft185eCeCnMv2Yx4FodPMI2fAwMy1NSzMDmK8SJWpAjACma1J6CaJv4tPSeuD48WsBdFak7ArAAeZnZ0ZFza9zmO8pC8eA0Q9keKfGvtWk2Z4zevSO+NTUP40GwxgAa9zb4jMyOqCoqMe+/acI15k7YqX5BIrUmzDenIx15nPRFZmvA5BcYYfKjezsEH3gQFtpWPA5o0aVRsMkohxIeYN7/4SEBCUuror5Vs/7CVMXXgXJKzB5URho6T2AYxCYJwH0M5iveSMjI+t4UdFIAh4HsI+B+bNGjtw9+9wsYQUFRdsJuDo+Le22Irv9c1eAMQ+1JULLwBa1AAcOjcaUhdFg+XdMWzykjNfNxCWdIPRvAByE1sGZqIyRceRM4e2KIqtUetsibWbnwoOHJkfjKAC/YpV5PwDsP3H6QzBfWaEfIRpAb0xeUOdoiy2J+PT06wH0LPL2fvWxyMi8WZGRr82IjLTOGT16MzNPAXMsAcuLHI5eClFPAFfOHj16Xr3yhzCNBOg7rJpZ/0BlRN8rRFeUrxZFRUMBHD591n4MLJxuxcRXwaBeXa7rVIBXVrdEXBzpJlPwZ5W1CV3PAVGZnYs9vXu/Wa2b7Ffz0iFwGYCLwY5MML0K4HWwfB/ga44WF0cAsBeMGrWt0OFYDua3y15vCtuSfeQTApYz80Ivg2FzdfJ7qARnIrS1AL0Cxv0A/w5NLivTR2iPAlyM09r1WPtvp22brmfougwe+sQH25pCTBViw6SxE3dPGhfz2pTIKe2aYs3K8CgXHjzUFeZLQbCWvHz+lrF9AERistm3tM8Ecx84c1XsAqjVH40wMwlmMxEtMUdEFJRvnz169Ia++/cHzIyKWm6OjtYej4w8VJUdxnmuPAgsG8R9koDvuRIlkIEwAFkA/w5dccUsEVe4XI2dTHk6HEB3QF9f3RopKayWeOqURwNyAFz0Qnp6ZwCIT029A8x3uxSEqvlq3l6c1kYD+BjgAVC1JZDKNwCN1IodVzOQaiaS5uhore+BA3NKx01Y3A3gi/7IO/bjzKioJcUOxxACAuMtllZ/PzYDyQACQWIydP1mANdg8kLnLpQz9sndAC3FBvO5XaE15oOKUP68OzLsgbouqmlaDGva38sU5u7l+5GkCUkbkgfovjKcmTpLg/ZMXdesL23mWMSDhyaHaAhApQZa0YMDIwAchzSMBuC061HVaBC2gbEBTruLD5tD1IYiPj09goCLi+z2N6vqU+X2fr3ggSBRqfHkeaOq30HT/vtcSkrXx6Kj3Q2/XcoFdQXxIExaMADMfQCMd9o6EAM0FUzfYLW5gmLlTvfuOULT/CYCeLF825wxYw7HWywZdilXPLNx46OSaBkDeQrzONQUVMxpb/IkpplfwZfmQwAOYfLC/cV2OcXoRf8r6Vbmf2DQh4Mpv+RoxxwdfWaJxfIhAfcCaADF7wJC076BqsRh1Rynvc3kRfcB/BZiFmbg4KHhAEmc1pLLD+vk67XzyOnCaAB1itK54rEFiwxeRpN7XeHRE/tR7mgvaWNSLgCsXbv21MSxE18H6IW6rNcQeHYuPHioK4whYLn9XAU9CuBbKHyNW59xYEoBcxragFEnMV9PRGua/ryeBoGpQXYuZo4YsQ/ALt1oHOdez8xDQZQF4HcAg0C4AkAmgA6YssAEs1kAdAsEf1HTGiEhIRqAmVW1E3AFmIulED8z0UdE9DIzj631m3AqFgAARdC3Pj6GS4Wub6i0L9M0OJ+4z1VJ+RqAGxdv3tyl1mt6ANaaTyFp/urS10lzEwCsgsIfg+k+AO9UZnAspbbCmne0zgn6fln7/THryq/hXnZaNp9w7zMlckq7CeMm9AGACRMmeIFwB+PczmpT41EuPHioC86jj35Q1NIIjcOGBWSAaD0Y587oCePAnAKpWwAMxmRz12aQtiGZJqX8sklXHG/uDKBrQ+bCYGA9mG8seZ2QkKCAaIii69tc0SsHARQNYC2AHwDlWmxRYsDoDC/fhJrmJyIZFhZUZbKrmVFRp4s0bRKAp7yIHhO6vgFEkdXaXVTB2BGBNl3TlaCDB7MqNDo9G26AFJ+6V88ZMyaHiTaT3X7X+a7noRxkeACgngDGQeDtyroc+2zGS/nvPzCnsrbaoBrFbkWhje4FCpdRYtiHOykQX08aO/EPpVDsIsCgeWmP1nXN+tIkxyK3TLmlh+7Q+yesTajSdcuDh1YFqSEd23kXzLx3xFWzVzq/UKxW2yemOe89DEV9H9cvughFbAQQCFVLxUrzCUxeuBtQIwF81bzC1414iyUUQGCxpq1t0oUNxkGAPNKQuTAUohclc/bSH3+8ZObIkb/u6tNngJBSbe/r+ysUoUHK/gC6g+ktEP8J5hsAugqE16vzRikhIyPDoKpd3zGZgu6oqo8rxPjTAJCQkJC1p1cv7URR0XAA5/WEe8WowF7bfz+kP5m0KwrAD2Ua9x+6GkIU4i/2NJTbrBdSvsNCPATgeXioO6tmnsbUp/8KFjPx1by9lXXZujU/QlHkuLCwoOfqsoSvr9oPwBj3OiG4zO930rdJ+QCG1GX+xqBRdy6mTJnSLjYmdoWuaQdBXHq2Fzcx7qO4mBs98SQ8tF6YhgwZ1O1PEli21GKJAABm6oU15oMAfoFdToLAEwAysdJcsn1pAXFks8lcTwi4nom+NUdHn2nahXkQuGEzeM6IjNwN5v+xpj0BAELKoQBy7o2IcMBo3wXng1cH+PikQxdfA4gEEAmVXq3N/D4+PkSEi2orj8tGIpWBcZW1m7OzK8bbAGBmFqpCU//YfzoZkA9X6EB0M8AJLk+HMjik3ADmsKUWS7N5FLQZvnpiM2C4s6pmIdhbSnSqqr0t0qjKhbdmXAggQLAcVqaB8SWYpjTm2h48NC5ySOiArgBwkIEVz6WkdPXxKXSlXOdvQPQqCOHQxV/PjaFvwRRXmnCrlcHADWjqIxEAYDkQ1PDpwYUQi0A0bUla2g0ApjLgPFZINNsB2ADehMRHCrFmzg4A+QA+xRdzK828XJ7Q0FC7qvpOOx95mPkHAirYXSy1WAZ5Hz/++1KLZUT5NmNq6kgAfrl/nJkFYAKmLOlf2hj7gg+AqZCo1CV23tixe+EM9V1hXg91oBo36ePHAzYVFip1jnPh0954zLe90eZefDp6VVAYWxKNbHNB1xHTQ5+uXZHpXqsrejYIVYfX9eChhUMKXdrnIv+eTHQPgCzNYEj67qgzZwWA9QBehdZ+pOuHyYm343MARrRXz+tHpyWw1GK5HkAQG41Nf6RDYhDQ8Fk8Z0RG7ibgXcH8HwB9iehrt+bfAfre7fVa6FTB86OB2cBAlLvdhTk728hE/wNwmIFvXYpQKUJRYgGs+uOt6TsAJIHlv0sbiwpvAvAnVs+tOuQ0c7rk1rubdqEgFOpMgoLcC+uiRdtMNvYTVE9Wncl4yizKqhdDetKae2i1BPRsH64qiiju2NGC06czvDXtmTOgTUsslkWzo6KegFPBKEui2Y7JC5eD+WEAiU0udB0xb9rUnjXtZQAz51x+eYPZPdQeHgjijxtj5plRUf+qtIHwO3SRcq5CXYo1s/JrO292drZR0wq+BFA+AFeV9DtwwLqnV6/DJ4qK7gDwDgB4Hz++iACjQYjLiqWcQsyfxFss/WdFReWbmQXS0m4Es/M9CLwAyesxccmLOFucD/BcgJY6XWirQIh0YvbsIjcynTrlj2DmCQAqzXlTI4R9BFHmIV1RZCO4fDccja357BCSL69QK+XNALZX7O7BQytg2uIufQM6ddOkTDWHhtrNI0acmhUV9U+TV+ckAmYsSkur2qhK0V4F6FJMXthq3FK9NG0RgN0zIyOrjG3RaDiPkAaClN9q7Nug0M/o3eWcYWVS7RULACgsLGQpsfN8xsTFxenE/CQDT5hTUryXpKbGAvinRnTLI6NGFc6OivqMgG+I6D4A8E5PnwDA2/f0aaci+9W8dIA+gNA/hr/6dxAkvAe8W92aQtfTAIwwp6S0yqO61gKzPAOgwoN2bfFr59XHp4Mh3L0Y2huUBhSxwWlU5YKB55np5diJsfcAQGxM7LU3TYh9g4EZRNxswT08eKgXOg8d1LeLw6Aqq92rx0cMvg7AewrzU1WOXWk+AcJHAO5pZCkbBDOzIOBeJnqsXuG7YxMUTF404bzH+XkFAFBw0r6nzmvXBXaswpv3OmruWDkRERGO8PCg886uXBgV9TGAkz5G40tE9A4R/W1uZGSpuzML8TIz/32pxdIOzEtBtPjfMTHFpRN4K7MB9AbhP5D8XHX5TwCgQNe3AYCvotQ6v5I5O9u4dOPGimHuPVRJeHiwNTw8qM1kRa4NjapcJK5JfI+IF5DEUgAgYC0TYon4oc+SP/+0pvEePLREfH2M1wf0aqcQc5mjj61b8yM0XV8EIGZJamrF7KglMDaC6NLGlrMhMKamdgFg8Lbbz+spvAIFvw8E+L+Ytrhs0KbYBAWTFl2JqQuuwqQFMZiy4EFMWTgDMeaeABNIvw5Afplwyk1BUvUROGuCmUVWlm1YzT3LYiaSYJ7LzP9g5hdmRkZ+7t4+c+TI9XDaX6wG4Ot78mTZH6zEWScB/juAg+jV/b0a14uO1sC8WSpKre0ufI4du4mJrqm5p4cSMjNzO27Zsrd/zT0rx+BnzPPyNW4uU/z8qs4O3AJodIOQz5I/X8b+6ME6BrDE4EMFh7t/lvz5sppHevDQEmEK7OV/ky7lsZlRUWWMDIn4+Xljx+5l4G0iqjpgDmM3mFuFQbNQ1Z4Aih6Ojj5RY+dqJxLhAHpC018uU1+042UQfw5Jb0DQf8A0HoxroKg2TF70O4geBaHqnaAWSk5Ojgo4H6rOl1mjRyeBaOasqKgK75uIGMzLAYwB0ZwyuxYlJM1fD+ZrarvzwkTpBNQ6ay8L8RAReTJJnwdEYogQ+t/qOl41KoGKQbncvRiFbNFHWU0iXGJiog5gV1Os5cFDozJ10chePYLaqYr4pnyTEJwEAGBeAaKPqpzDIHZDkx0xbXGXMoGhJi+YBClsSJ77S5VjmxjW9R4g+rMBZgoHYR2YYjB54VQkzfsKkxfOAXA9wMOQND+3TPcpCyMgEQEfn/drE7SqpXHoUIjs2NFWIcdEbZkVGfnMrCraijTtfW+DYerMUaM+q6oPVs+v9U4TCZHIUm5+ZuPGYTPGjKkyqigAxKeljQHzMHa6sHqoJbouDgqhVe21UzOnABxyr2BRj2PKJqBRlYu4mNhqtzIT1iR6N+b6Hjw0ODrFDQjqfFAIsaV8U0n0PVWIHJ25d3xGRodZEREnK8zx5ZyjmLzwBDStLwA37wtxDYQcBrN5TGVBj5oDEqInmA82wFThAFYC9CnAKzF5IQCcBmgckublVui9al4GgIwGWLdZiI4mDZUkLWsIzNHRZ55dt25avWxg3Jg1atT2JampL0gh3janpFzmihxaOcwPAUgAEPdCenrnR0aNOtYQMrR1hg+/eBfq8YDt3d67PUBlsqBKIajegjUijXssQvT3cuVeML8IxhkG5jfq2h48NDRmswDxjRd19zdWlhDIas29FwAej4w8BOAoFRVdUuVcRLtBSrmjEY4GaAS2Gv7esILXHZayBwMNsHMBEyAykTT3PUilH6TSD6rWH0lzq31Sbq0kJLCSlWVrtP/j4+PHn23I+fxOn14AwMtLVedV1efZH34IBjBJMs8H8GexrnuORmpJZmZukNWaO7655WhKGnXnIiE5odKt4Zsn3fi1LqnOue09eGgWMtQILy/V38so2oE5s3wzs7gVwBuul79K5hBUlSeC5W5AnFMuJizuBsgQAA+AOR5TFn2FVXMb4ke9XgiiHsxcPzkmxwcAWid42Z0RMJNnN63nRzMQGpqjaJrfTUDliaxaGv+OiSl+ZuPG26UQyfGpqYO8NO1f5e1sdEX5O4D1c0aP3hFvsWwjIS4FsKFZBG5lEIk+zDwGwLq6jFcNhl0MLuN6atTEhW3QWRmfrv58A7WB9NMeLjgGBPRq/weA47OioirEPRACpUmJiCiHiKreuWDsBtyMOg1yHIBfkTTvVQCbwfLxhhS8rkiinkxUz2MRLRzADiSamzYnSTMSEhKiSdk4xyKNxYwxY7bqqmoCUc9ig+GDSrrEgNmZEZZ5O6Qs4/EUn54+fkla2gfxFsuPSy2W/HiLpTDeYlnUFLK3dAwGuQsQK+s6XvUx9Df4GMe6F2pvbNEGnc2iXNww+YbBAFp0dDEPHipAFNQvoEMRmCsciQBAWFhgUukL5l8JCKlyLiF2gficaxrTlWD61vViDUChDSR1vSDmHlTfnQvwcBAq2Ki0ZYhIhocH1dmgs7mYO2LEnxAinoEyRx6LNm68CMBQoWnrAYCE+MXdnZqZCVK+RMx2JnqOiW4j4J8A/s+cknLB29aFhgYfDA8PqI9BZ6ujUTWfm2JiK2juTNQVOk8C6I3Kxnjw0GJhDgzo3cFARJXaCVitthdMpqBHXC+zGXiw6rmo7LEIcTSAGc6/xR6A+zaY3PWAgZ4Qop47FxQO0IYGEaiVkJLCaqdOtkUmU/DM5pblfNGAX1QgYKnF0m5mVNRpAFCFiGFg64zo6IMAQLqexUJcamYWZiL5rMUyEUQdijp1us8cGmp3TbUx3mJ51MtguA2VHA89k5LS02E0dnUPEtZWycrKH8IsLzOZgv5bl/Fe7X2LGCiz86ca0CKMvquisSN0msqVocSsEvhh9uOq4wB48NASIVzcrYtfx8qMOQGAmc4FzlLVXwEEmlNS/CudS8g9AF+E2Bd8cP2ii8DoD1VYnOtQLhiBMJubPTERAT1Z18sqFzGLB57nNGEgmdVwUrV8unfPEUR03kG0WgLzRo36A8BJCFF6rMfM18ItsVuBrucA8PL68ce+ACCJHmDmN9wUCydErwngQWau4NnARmOcQcqgxnofLQlm7shcj2SdTN4E8ncvuoOa/fuhOhrXoHNN4rjGnN+Dh6ZEVUWQv5+hB0pSc5eDmW4p+XvG5Zf/sTQt7YyvogwEUHGnI1z7A1vUYhSd6QsoYSBsK415YfTORVGBEZlqbwB76y14zMJAKMIHSXPOKz9HQkKCsgfoojKX8a+HkK8AfE21CbHGmb3RTpkHoi5g9IFQKhjAtmVCQkIcW7bk3dHcctSD31nXBwP4KSEhQdlDdKVgLg2AZo6OLoq3WHYLTRuyODVVABgriCoEiSpSlI+9NS1+aVraa/Gpqf0hxHuzIiOdhv7McZLowyZ7R81Ihw4yo6BAzanreKGouZL0dPc6korHoNODh7ZA9y4+gZDMRQ5Hpem/hw0LKE1M5IpB8Bu7Pf2VwRnHIhdMlwA8G6CE0rbERwoBOgAp6n80ct2SoKnXDsgaYep5Y1VdlqSmVrqOrVu3bgAUVpRzOxcTl3QC4SpMWlh9npB26myAbgJQAOCRMsHCLgCIiCMigg40txx1hjmHhAgBgD19+lwOQHTw9t5Urs92JppNROsBrJgZFVUhMZd5xIhTYH4WgA+Aw2C+FwCW/PhjEAOjmPniRn8vLYDg4OCi0NCL6xwTxODnFezl6zvKvaj+PlVuDkwaN2n5pHETefK4yV3rumZ9afCdi7iY2NU193KSsCZxUkOv78HD+RBvsQRU5vlRgcnmrr17tveRzD9VFWTIarWtNpmC3O/pX7k6o05gNwjPg3AMPbs+V7ZJ5oLRF8APNb+LKpi4pC90LSV0YNf2I0wXmaeOtxR7CbH8kVGjykS8JKLnnktJ+cdj0dFHykigqj0AFJScuwMAhB7qGvQIgDWVrjtlwSAwZoDFFUia82Od5W/FZGdnGx0Ov89MpqBpzS1LnSDKcblOgnU9hoBv7o2IKBtOXIiNAExC15cU+vqur2waAJg1evRCwGljIQ2G/GfS0vpJXb8JAIGoTyO+ixZDVlbuCGa62mQKWtDYa8VcETOGmTsTo2Jo+Cak4XcumI/Uunjw0IzEp6ePB/BbfGrq5Bo7SxEY2LuDXVFEeo19XTBzDoBq3FFpN0A9IeVdFfNA0B4Iqt/OhdA/6d7Fz9LOz0grv9m1joC77FIej7dYvl/644+XAIDLkn+8pqp/rTBeUXoCKGfMyaEAtgGIxKSnwyp7U2B6DcAHWH1hKhZthGy4FGMCrmfgi/IdZkVGLpsVGXnPzDFjVpojImpM9OYyBl2vS3k7AbcwkErABbFzUV8Mvr4HVF/fbPdCPl4VPC5jR8b6KJKeMRocDzWHnO40+M5FwtrP72roOT14aGjiLZYASPkxiD4B8L+lGzfePnPMmKr90BUKDOzdXjLzT1V1Kbdr4XQ3Zb6liu4Ayd0gsRBJT1S04SDeA5BbFkWmam0cyuMMXDXs9uvDlhfa9as3W/fT5gV3hy5OTR0ogFelrt8OYI63l9dYSOnLRHcDeKnMHLregyrkFRGhAH4AeAsEPQLgzjLNU5dcAomRkMoNtZa1DRLqNGxsnbsWAFSiHI05eElq6nAQBQtnFtZ6w8zvE9EbDHiD+U4QLWyIeVs6YWHBm1BVQL1aQIq4iIAy7une5YJqAUCh8exCAl7/cv36Q5PGTazrcg2Cx+bCwwWHOSVFBXMiAV/Oioy8B0Q3sxDvL0lNfcm8aVP7ysa081UHdO3k46UIUaVykZW1Z5D7a0XXcwEEVykI42ucciyptE2KPWCXO+qURT0wcfH5pbgmxzQAqV07GQcVnLX/CiAAAOaMHr0DQrxNgPPHn3kCgAQCBiy1WCLKiEfUgysoFxwKyGwQvQimmzFl4ZiyzTwMwC9Inn38vORtYzAzZWbuHtDcctSVR0eNygdQQERzGVhf5misHhRrWklyv2QiygFwQRyLZGcf8rda9/au6/g+YWM6BP5l/HH30mnA8B7ufWKiYy4HUWjShjXv1VvgBqDRlYubJt40JG7ijU/fFBP7wU0xsZ+6l8Ze24OHyvBS1atAdHGhw/EAAMyKjExWdN0kiAb6aNovZuYKn4sBQV2H2zVZ/PioUVWGrpZSedP9taqqNgDtF2/e3KXSAavn78QGc+UW386di5JjkX+A+C+1enMlMF0PwhdE9BeHpm8GEHhuak4GEBCfnn4pmCcw86cAVjBwd1kRuCdVTFoWClA2Vs3dBtATYCRj8uKxbguHozLvmAuMnJwcgxDKq80tR11xGST/CuA6Yl7RUPOao6OLCPiMiD4pUtW9AHyr/Hy0IRyOQhOzfl9dx584uMd+7I9fO7mXopOHyiRFVJhGEzB00riJtknjJtoAeDH0rVOvnFCd3Vej0ajKxU0xN05ilplgGstALDM6MnAZAzcwocKWjgcPTQLRbWD+xBwdXZq19/GxY3MLO3WaykB3n02bSncgSqIL9uzmd8mpU8W26jJREnGZKJSujJEnFYej6t2LKifT9gDojolLOoHxTxBfWuOYEqaZuwMY5aMaVgKIYND3APwx3twZAFxPod9AyhkAggTRt0z0LoBbFqanlz5dMVEP6R6dc7K5K4AekEo2ACBp7lKAnwBkMqYtdv5AMMLBuKDcTivj0KEQycytWsliIAeAw0vTVjXkvELK1wodjjXmESNOATilalqbt7sgohNE2F3X8UVnTxQWnT4G9+IoOlEm63jShuTnkjYk91q9ITlo9YbkIADFBGXYV9+trbMLbH1oVOVCgp4E+KmENYljAZxkwl3shwEEvAymnY25tgcPlWFOSfEn4DpWlApJ9VwBgLaxlMMBYGF6em8fg2GFOSVF7d7Nv/epAnu1kQTdonO6kwuioPMWdNWTBwAUgbTHAe4JUO0zUDqUqQD//MRjo70BtO8c0HUjgFPwEud2L4AVAP4KIG1mVNTpWaNGpQDYrUq5L95i+XOpxXI1MfeEe14RVoYAtL/MkUfS/P8AyIXG4512IQiHIi945SI6mrTWGJ3THdexxXflE5jVl8fHjNnmptjvg5Rt/mgkLCzgl7pG5wQA1ei1RxiNaWWKj9eFG+eCCIMJiivRDXRFKt6JiYl6hz87zQI4rjHX9uChMrxV9XoAttmjRlX6A0jAFgARACCkvIqBGG9VfbVnV9/2p04WVev9kJWVV9HrhMgmmc9/58JpvGkD0cOuUPkDEPuCT+2G0lQQrYSu/wXALy5L/nywCCjpYhAiCYAGlzspEfGsqKiIIlXtAOAJBlaAaCjK5hUJBTi7wnqMNYCcgInxwQD8YfTfdv7vt23BzCIz09a8FnX1REiZ41JCGw/mvVKINr9zkZ2d2zMzM//8jjbdEF6GvorBGOleBFefuGz1hmTvpA1JzeaV2bg2Fwy7pmjONQiHpJABAPDmljc1AH6NurYHD5VBdBszVxkVUAJbwDwcAM6eddyQveNIgabzjR3aeSv7Dp2pNl2ylHisQiVzLlVn1Fk9ewDosDvmAShAcUHNycycIcOjwDKFgAgwlyRLygO4VLlwHdmkAFhbZviIEadmRUW9wcCTALqRopxTLkiEwumiWA5eC9C1UPThAH5zBgG7sMnJyVGFQLO7A9YHIcR2xeH4qlEXIdqP+PH3AAAgAElEQVQH5ja/c+FwiP6AvK7OE0jYARS6F1Xl2nuPNQONbdC5XZVkAgAwpQL8ZNzEuOi4iXHPglEhmpsHD43JC+npnQFcQU7300pRiDIAmBISEhQvgxidsf1A4esfbfU7eOQsp0nbr9WvwBWT8RHlAgiqm8S0B4QPsc58DIztkLWwu8gQlwJQcVpmAogios2uufIBCnDvysz/mRUVVYmyAMyOivoPES0tm1eEncac5enVPQ2AAYx7AY+9BQBkZ4fozFwhWVdr4rHIyLzygdUaGiLaiwvAY4RIsSmKrPbhpDo0RTVqQvVxL0VkqJCvpSXR2InL4uFKra5JbQkYHcH8PZjvEIJbtVbvofVRrOvDCNhfXUTODl5e2QDU3b17X6eqov3eP06+se/QqREffbE9xRWyu0rCw4P+V6FSShvqunPhjIOxDAAgsA1UG7sLigKw6ZmnooNBZDr35Mn5cPMYAYDZo0d/XXH8OdZ+Y5/X78CBPAAlOyJDwJUoF84AYN8CuBJgj3IBIC6OdJMp+LPmlqPFw7wPF0AgrbCwPvuGDu27sbnlaEoaRbmIi4ldGzsxdgr88M1nyZ8nAsAX6744kLA2cTjr6BJyWWjPT5M/T22MtT14qAoSYhjX4CZ5b0SEA8zbSMoZ+QdOaWcKHd9h1ROZR/udubqm+bOybBWORXQhcgEEVZYVsmbEp/hqjtPSm7EdQKXKxdAZb/wbsWYjAIAoEsQWqap3gGiN25NnXvmdi5rYkJE+Ny4uzhkF8GfD1QAYZ+xVKA/sOl5RWrWHREORksJqZmau5wGqBiTR3gshBPiWLXv7Z2bm1v1YRNBuhtjoXnSoF6RBZzdifEVnYYudGPvEzVNu7lXSkLgu8Zi5hidADx4aBebhLoPN6rsR/QSiy3bmHlcA3RlVrxb3rJRUwaDTeOZMLgCvZ9LSLjpveVfNdTem3Aag0mMRU0iPhwb17lGSsyDKy6img/lvxPxuaScS+QCX2bnAdQv6YcqCQZiwuFul6d2JH8WURU6jRIF/AngXG8xFFfoBAOlrAUh4i0rT0V9odO+eI4SgVm3Q2RQIIfaC+eK6Kd+tB0WRPQGqs0Gnxko/ncQY98KgRs1qXl8aRblIWJMYwYQIEK8l4HGp6XmxMbErYmNirwbQpm8iDy0YonDiWmzbu/rk/3HqNySZa8yZcG4YPVq+7vHx488COMJCBNV2nufS0gLjLZaoMpXe6nYAXXH9ogpKipdB7RE2uNvDmLTwMgAXPXLPcBWAV2GnTueOPRz2PAA9MOFlLwDAeHNn6PQzmLZDlYewxTC+zKRTFvUA0A7MyxCzeCDAE6Hw61UKvcq8H8CXSJx1sso+FxAhISEagFbtitok6Po+AN7Pb9jQpgNpMctfpFTerbln26HRbC4SkxO3JCR//o8ipbgXQA8Q0JeA9XETY3fETYx7bNq0aW36ZvLQsjBv2tQezP3silKjcqEyZ2iadOTuPV6tTUJ5hg0LyKi0gTmXpKyV3cXi1NSBOnMqAXPLNDh/tPNQXO5oZIK5vY+36msK6aF26+rzJQBrh3a+dzPwqStuhxP/kAMANCgnnUcjXupcAFuRNM8I4G2Ay23ZUn8ARwAchSK/BfAdVs6vIQgQLa7Ne7wQICIZFhbkOSKqAVdAt5MOL682bXcRHh58Yvjwi3fVdbxOykmNlP3uRUrRok8AGj3896pVq04nrEl4PWFNYjgLXA7wRjA/ZShW/2jstT14KMHXbg8HcHjeqFE13ndndT1nh+24XdP4vNKdW622Sr1QiCiXaxHrYlFa2hBBtJGZv2Xgymd/+KHsGKZtoHLKhTCGdfA3SgZs0SMCe1x3zcBCAGOgKM+X6ZcYpwPYB6IIXLckCIx/ATTDJWACgKlljkYk9wOwC4R/AegNRs2hrJPmen5MXWRkZBisVtsHzS1HK2EfpHx0aVra/xZv3BjZ3MI0Blu35kdUZpNVW5ipA0C93IsuZIvODdakwinMXoDwAqCA4KhxgAcPDYQuxDDUMueF+YX0oSk/5vmAFcv5rMFMvSptILJBiBqVCwEsIeDLWaNH383AWl1R/lGuy1ZADnOv8PLCcD9fIymC7jeF9MDlYRddJqWcNnvkSFslcrwF4A3o+o8AryhVBnp23QDAiC3qqHN9ZX+Ad2HVvAyA5sBn4Jqa5PdwDh8fHyLC+dvZXIAw83eCSDDzECHElc0tT2MgBHtLiU51noCQT6CfyxblgjToLOXWibd2io2JfTAuJjZHMm1k5kuZ8bDzuMSDh6aBgGG1yvUw5elwgNftPXDy+fPN7OnjUzip0gbmnZBycHVjl27a1IeYxwtdf8Yl7+sA/mbOzjae6yV/BlGZzKUdO/iMYDAVORwpukTiydOFD80ZMyat0kVWzV0CqQSC6GXoNK+03ulKuhpUJkV4P5TkQkiau9S18+GhloSGhtpV1bfVplxvSmaPHv3gzMjIW0H0EVzRcdsax48HbCosVOqcXl4nJUAj8Rf30tINOhtNuJsn3jhKsrhXY0ccAQSizyHxf4lrEyr/4vPgoXEZJoi+rLbH5KdDweI7AMuwav6TDbWwLuWPQohXX0hP93lk1KjKo1dq2t8AbHh87NhcACiKjFznnZZW6HX8+DQAzngJBj0DmtoP482dsc58DAB8fQ1huuQz5ujoohfS0++eP+6a6qNjOhWmStK88xdgegGAyyhV9APzedmcePBQHxjIILTuqKYeztFYcS62S6Y0gCMZeEJR1D4JyQm3JXgUCw9NzOL09MFLUlNfAjBIKuViMFzzrB8mL3wD1y+6CBOXdALESjDeQtK8OikWhYU+qyurnz169K8AThbr+uWVtZuZhSvdeWlERzORJKL3CLiptOOX5kMA74WXYTgA4B9vGHy91H5gHASAKhWXWqGvB9ADMYucEXXB/cGizgZoFzrZ2dlGTSuoXpn1UAZvu30rgJ5LLZY2t6vdqVP+CB8ffV7NPStHOiOZbnEvZOAL71iEgd0gujZhTeKAxDWJz36S9EmzJU/xcOFizsjwFVJmE9CLma+qYIfgVTwPwI1wcA4U+Q0Iu+EzcE5d1yPiSkPau9K0pxLRmMravS2WiQD8ijp1WuleL6VcDeCql9es8TpXKzLA7PSXP3jkknbtvFhVlLy6ylyK0+U2BQom4jpzRwBdYLDXOUX0hU5hYSEz40Bzy9GacGVf3Yk2eDQiJRUJgfM6ZnWHmS+WwHD34nBcgMciiWsS6x6JzIOHBsK3oGCwFKJgZlRUnOsH/hxTFgwC4yEQRkNydwCPwa7dilV1ty0wmYJuqaqNgFRmLmOTkZCQoOzu1esRAE8x8/wyrqMAZkVFbV2alnb2bLt2o+EMrw2AfwbhMgCAhKlbJ5/DIG4YzyvC12C+CVJdB+CUc6fEQ12IiIhwALijueVohWRIp3KxqrkFaUhcbuqVu6rXAgKOA9jrXieFvLBdUT14aC5YiEsA/EZEjMkLyiq8TC8D+Air5mVg9fw1SJp3RYkdQ13ZujW/yicuknIjiEa8kZFhAIAlqal9c3v1+oGAe4WUE2aPHv18hTFEDOa1RBRTWik4A1z6ZDesW2ffU0TUQE/IytcARriywnp2LeoBM4usLNuwmnt6cMdld9Hmdi4yM3M7btmyt39dx+tEnXSii92LEKJF/363aOE8eKgPkvkSJvoVk+MDAPoCUxY8CACYvPAJAGHQRJ2PQCqDiCsoCCUEHTyYBUA7UVQ0PD4t7WYiymTAqpw9GzZjzJgq42mQEGsAnAsjralbAPTBlEUTQXxPjx7+p1jKhlEuVs3eBcAG0L0g8igX9SAnJ0cFsLS55WhtKM6n++EAEJ+WdvPizZvbRLBFIjFECP1vzS1HU+JRLjy0WYjoEsH8K6BdD8JOMD2NKYsSATwMna7F2jmHG3I9ITipqjZXArB0BpaB+S0w3zYrKmq6Kzx4lbCX1zcAgpekpzufepzeHrvA/AWInung72VAg+1cAGB8DSAczB5jznpw6FCIlJKTm1uO1kaBw5EJoEt8WtqXYP5YOBzvt4W8I7ouDgL8c13HM2M3wBvdi0YtO3FZizYIOR+m3zl9GYinArjYbnR0e/PNN0uNSO+76z6TAL3HQAcC7WDJt77ywStHAeD+u+7/jYAOcKWGB+i25e8t39AMb8FDQ8N8CZg/BPgxMJaDKAvMnwOYjDVzGzzBVlhY0HM1dNkI4EFmHjd79OgaE6gBwKyIiJPxFotFMMcAeNlVnQHmLUiauxAz0v4FoFJD0joh6GswTwc8Oxf1ITqaNAAvNrccrQ1zdPSZpRbLr8zsL4UIJSm/Xpqe/jiAZ5pbtvrgCv1dZ4WdifoxyhqEM1c06Jw0dtJ3IB4EBoGQo0L/v5UbvrbVdd360GZ2LogoQdUclwOo8CQoQO+wxFOvvPdKMEhaSdDTZcaq4i/L33ulj7N4FIu2wBsZGQYQ9c/8/c+jAF0O0ldg1byNIEM/JM07r8ibtSUz03Zrde1SiJUq0YjaKhYlMLCJmc+F/Rb8X/j43Z2QkCgAdBcNunPhSAFQVBpAy0OdSEhgxWrNvanmnh7KQ8B9RZGR4+eMGvUbS/lXMD+1KC1tSHPLVR+ysvb12bZtT6XeYg0JGehvqzck91n9Q3IfEP+sQcQ39ppV0WaUi2XvLUt98aM3K3zJ/uvuf/UF0OeVD15xuvlp4nWAY5taPg9NywmHoz8AXrFmRwSAdFfWTmDVzNONtyrdW13rnFGjfnssMvK83UYJyANwLl36V/O/ReIjhbm9evUAoBR4eTWccuF0Sd0Ah2Nng815ARIamqMQ0d+bW47WyIyoqFQzkQQAV7TZnxRgZDOLVS+Y9SBdF+Nr7lnFeCE0KYTDvTArXL5f0rdJ+QBgNpsJECoRNZvHV5tRLqpCZVwMYB8ABoA/i/7MB9DlgQceKI0dwJrcMP2u+3dPv+u+12bcfXe7ZhLVQwMipQwhYIdDl9MA/rwp1hQCNR2L1HViG4CgSlp6AThhjoiodVr4WkH0JdY+6UksWA9CQkI0KT3HIg0BATvAPLC55agPBoPcBYiVNfesHGaoYBjcC5FeqS3KpLGTvsvY8PMpMMdIBxos0vD50mZsLuoK6TRh+YfLbQ/89YF2MMq3CqT3MwD+Vb5fZqbtVSEwgIjijh4NON25c95aZhwwmYLu2LZt76XM+gsAfx8WFrzEas2LI+L/k5JfCQ8PXpmZmWsWgiIBOT0srO/vVmvuZ4DoaDIFjt++fU8PKcVHAP0SFhb4cGZm7jghaC4zJZpMgW9mZtruEwLTAPF0WFhAqtVqW0aEwQ6H8Zbhwy86um1b3noAh8LCgv66dWteiKLwS8z4wWQKWpiVZbsBwD8BvB4WFrTCarXNJ8IYXacHhw0LzMnMtP1PCHQbOjTwmi1bDnQxGOyfMONXkyno31lZ+aMB+QTAX4SFBb9mteb9g4hjpeRF4eHBGzIzc18UgkKFkLddemnfP63WvHUAjptMgTdnZe0ZBIjlAFnCwgKfyszMvU4Iup+Z3jKZAhOysmxzAEQTKY8MHXrxdqvV9iEReh47Fjihe/d97TVN/wzAjrCwoPszM22jhMBTzPjKZApanpVluwfAzQCWhIUFfW+12p4nwlBdF3cOGxawPzPTtgbA2XVn9mZJnQ4pENEf/nP81luT5iMrK28ywP8G+L9hYcGfWK15M4n4Kl2Xjw0b1jcrKyvvPYB7+/o6Jp08KbwNBuVzZtptMgX+MysrdwRACwBaHRYW+FJmZu5dQtBfpaRnwsMDv8nKsj0DcHhW1r7MsLA++6xWWxIAh8kUdP22bXl9mfkNKfFTeHjQ3MxM20Qh8BAzvW8yBX7kypY4HsDMsLCgrVar7R0iBJw9q0zp0MFLOVJ84slNBYeDzcxiqnXvcCHkYmas/fr03p1GRT2blWX7BuDnw8KCv7Za85YQcYSuy78PG9Y3Lysrb6WUksLDg6du3bonUFHE28y8xWQKnpWVlXstQI9KyR+Fhwe/b7XmPkxEMdl/nFp46yrirCzbmwCCVdV3mq/vWe3UKUpixl6TKehul5vlUimxPjw86NnMTNtfhcBdUuLF8PCg5Kws20IAlxPRvUOHBu6xWm0rAHiZTEGTsrL29QG0d6WENTw86PHMzLyrheAZzPjEZAr6b1ZW3r8Bngzw/LCw4E1Wa95rRNzf4dBvBI4XGAxd10jJ+8PDg+/cunVPmKKI55j5O5MpOD4rK/dmgO4BxLKwsIBVVmvuU0Q0Skr9vvDwfjuzsmwJzGhnMgVNyMiwXWQw4ANmbDeZgh7JyrJdAWC2lJQQHh74Vmam7X4hcJ2UZA4PD0yzWm3LiTBIVZWbQkL6nNi2LW8dM/40mYJuy8rKHwLI/0iJDeHhQYus1vwbhMA/rFab0WQK+tJqzXuCiEcT8QNDhwb/5sygy11MpuBrsrJ2dQfUj5k5x2QKfnDr1tyxikLzmHmFyRT8utWa+08iuoFILhg6tO9GqzX3JSIK0XXHrcOGDThsteauB+ioyRR0y5YttktUFS8zU6rJFPi01Wq7ngj/kpLeDA8PTMzMtM0VAuOY6SGTKTDbarV9RIQeQ4cGjv/ppz86eXtrnzLjd5MpaLrVmhdFxE9KiZXh4UGvZGbm/Z8QHMeMxSZTUIrVanuBCJeqKt8eGhp80Gq1rQX4lMkUfJPVunsgkfIKM6ebTMFPZmbmThWCpgP8TlhY8KdZWbmzAbpCCPnopZf23ZaZmfu+ENTL4TgSoyhd/ISgRCmxMzw86L72itGugO7MysrbGxYW+LLVarubCLfoOi0dNizwW6vV9hwRwpiVu0ymi/+wWm2rARSZTEE3bt+e309K+TozNplMQfOt1rxJRPyglHgvPDzo48zMvBlC8NXMmGEyBWVarXnvEnGf9u15cnFxsaG42PsLZt5jMgXfa7XuuYxILJKSk8PDg1/MzMy9Uwi6jZmfM5mC11mtuUuJaJjDod8TEdEv32rNXQWQbjIFTbPb4S2EXJyZmfdzeHjgnG3bbBOY8QhAH4aFBX6QmZkXGR4eWGUE65D+pu7eRu9T7nWHTh4MAJBevu/qH1ZfOXz4cEOvdj2XsILX4R7ltwlp88qFRtirOHcvCAD38O4RAPDRZcuWFQPA8g+X5wLAso+Xnfr3Hfe9zoJeqGye4mLHLF9fo3LppQEniUhu25YX53BoEgCOHu3za5cu+XHM3nYA6NBBrjp9Wnzj7+8oAACj0e85XS986ejR4NMAoGnyH0aj00d5yJDgw9u358cZjYWas29Buq77x509K4oAQNeN7ymK4xNFOX0WALy9i+bY7T7q8OEXnSQi3rYtL85ud8px8mTAji5d8uMALzsAtG/PyadPi+/btZOFAEDk/QJR8fKTJwNOO+fW/6UoqiAiZuZj27fnx3l5OeVQ1dObdd0/zm43FgNAQYH40N9fJhqNZ88CgI9P8Xy73UcdMiT4JAAIgZtL5Dh2LHh3ly75cYri4wAAf39tbWGh8Yf27aUrPLX3S0TFrx092sd1PfTpRqMqoqNJY+YT27fnxxUU2HWnjEd+VpRucQ6HoRgAzp5V/ufvL79QlDMl18Nst/uo4eEXnwQARaG/6rpkEL2Ss+ewLhSRFhYUMA8AfH3t6wsLjZZ27dh1PbyWExW/efKk8//icGgPGo2q6N+/vx2Affv2/LjCQqccDsfRLUZjtzi73SlHYaH6mb+//MpodMrh5VW0oLDQe+nOnb0PAAAz315y7/z2W0De4MH5cUZjyfVwfFtYaEx3ux6vERW/Y7cfPgMARUWOh319jcrIkX2KAGBV5rEbGbzPJy2tp+7tbS25Hgzc5pD6DiKK8/Fx3msGg88iXS807NoVfAoApJR3lcixa1fwvsGD8+NU1dfhvB5aSmGhcXNhoVLk/D94vWE0Ot4b2N1+xvkeHY/5+hqVkJBuZ4FuKHs9jmw3GrvFCeG81zp25BWnT4s1/v72Auf94xuv64WG334LOOW6HveUyPH7770PDB6cH+fjU3LPn/lB1/0zSu55h8PwttHo+NBuP+K6HvaZvr5GZfjwvqdK7nld1133fHC28573dt3zWHn6NK3z8Sl2XQ+/Z3W90LBzZ99Tzrn1/zMaVQEAw4cH/ln2nj9r0XX/uMLC0s/eu4ri+J+uO/8v3t5Fs+12HzUkpE+F74Bjxy7+rUuX/NLrYTT6rHU4zkb5+WlrXPfa80TFy44eDSy55/9ZIsfQof2OOOUo0pz3UsGPzu8A5/+loEB9399ffqYoha57vnie857v7/rsiZtKPnunTgXudP8O8PNzJBcWGlM6dnTea0J4v0hU/OqxYwElctxvNKqCiCQzH3e/Hpp2eLPR2C1O10vuefGRv7/8XFVLP3tPOq9HoEsOutVud/5fduzou9v9XvP3174uLDRuLPnsAT4vExW/fuRIsOu7SP5bUVQRERHhYOaT27fnxxUXO++1s9KRojGucDgMbzuvh/KJv7/80surVI6n7HYfdejQPidd99ptJffar79ebHPK4fzs+fnZvyksNKadux5erxAVv1VyPYqK7A/6+hqVoKDAYgDFznveoTuvx7FM5/UwlnwHJPj7y1Wq6vxONBj8Fuh6oWHPnr6uex53uDbMoapqe2b9K6PR5z0A8PFxfF9YaNx05kzJvXb4J1TD9l1ZhwCUszvh/Kr6b9myxdFr3OS3ieS31c3bmLR6F5/yTL/r/jN2oyPI3Vtk+t/u20qMhcvee/WL+++6/xnB8F/2/iv3zbj77naFwq/DsreX7XvggQe85Gn5OgC88t4rF5Q/clsk3mLJXLH29/Zbtu1/RibNf6Mp1szMzPshPDxwbGPMHW+x/CmJrpsTGfljSd2S1FQzEfWbFRV1e3VjPTQ9ztwifslhYUFXN7csrZ349PRLIeVPRZGRfiW2GK0NqzUvipknhIcHza3L+O9+Wv8dgCvK1nLklZeNL925mHbltC7FKO6y5rs1O2JjY5WiwwWLJDA4eUNys0TMbjM2F9P/dv8b0++6fx8AX6PduG36XdPXlbSRrtzDIPP0O+/fS4AJQjwJAMVau06sya+n33X/H3xK7gJgMCrGR5vrPXhoGMwpKSpLHrz/z9N9HthjqUcyr/NDCP0fjTh9PjEHuFcQUU+CJ39FSyQkJMQhpX5fc8vRFigyGncD8PLZvLnVJjQzGHysRMqrdR0vSRyWoJ3uRROGMqkKNNL8hEafTB43cX/h4QIbCH01XatwxN9UtJljkeXvvlKlpf6yD5ZlAhhavv6lD17KR4WtprZBQnaCsevZ9gOuuOza7OaWpanxNRhGFmsSBw8XftNBL7gvFrEfJyKxzjlDaktYWN/fG3H6PCIKLFfXC8BvjbimhzriymXj8bhpAMwREQXxFst+aNoAOI3zWx2hod3PADhT1/HE6MZEA9zrVMmK+2uXp8jwuq7R0LSZnQsPZelW0GEggZ5qbjlqwtwI96BknrTLdtzepfBEMhiXhfY/OKih16gMlyFZo0BENjAHudex0z21ynNXD81Hdna20Wq1eVKuNxw7GGi1HiNZWbkjrFbb/DpPQNgP8Hb3UqRrjf7AVB88ykUbhVkOZGDaDz9+c0lzy1ItgyIbPLmTXedp2TsOe93+x88nAJAUiGzoNZoaBvLIPdYFAAIC4FEuPFwAENFOAHVO/NXa0Zl6SYhL3YuqqErNI5sPj3LRViFlMAHEipzX3KJUh2Qx+oH+E7xq6jd/8JhbUQsD5IXp6b2Niuhv23tilZ/DPhwAg/jyhpC1JkymoEk196obxJzHbsqFedOm9gA6CiKPctECCQ0NtZtMQdOaW462AjPvBFGrVS7CwoI3mUxBC5pbjqbEo1y0UYj5EnbmU7k+5ed1LdmuJLij8VSNXxrEvHD+4DG3lLyePzDqvseGXuNXoZ9Dn3jgyFn9yMnit0A0hoG1IGqS6H5bt+Y3msEZM5eJ0mnQ9QAAhY+NGtWgydc8NAzMTBkZtouaW462Akm5C8wDau7ZMsnNzfXOzt7bua7jmcjGwI/uRTUaWnTiMo9y0QZISUmpxDCXBoHltwA+Y0kzmlyoWsKEi0mKwdX1MQ+OGgggmJifnTEost38gWNHE9FLPvaiqeX7njpdfOfOPUcLH/jTshlAOAjPgDHYHDSuY2O9hxKI+JNGm9zHxwbAvyQFtctzZK/LcNBDCyMnJ8dgMOCD5pajrcBC7ATQz8zcKn+zTp4UEXa7XmdPRCYRxCRGuhfN7mjRDhmt8h/l4RwpPyX3hJ99lXsdMxOBB7GC36DwQiK+MeWn9abmkrE6CLgYzNUqFzrjWoBTQdjrDfESkfwMjN+JcZt7v3iLJcDfz/CXg4fPrul0quBygP5c8FvqDwD2S2/9cgCYPzDqjkZ7L8TnlZDsfJgVEXESwCly7lhAOK/b3sZaz0P9OHQoRDLz1uaWo61gFGIPAGNrdUclohNUj2SABC4g4IR70aVo0TE/PMpFK8bMZgEoHwGY8N2m9deU1H//4/e9GGinGej36OHX7mLGcoCXM3NLDJp2MYGqVS4AGs9EXwuW0wHcCeAnKfWpAF81Z8jlPQBg8ebNXZixbttvh2n7jiPPk9THgHkjABA4HaCR8wdEXU5Eb5sHjuvaGG/k/9k77/iuqvPxv59zP58MNqjsvQJEDSMQCCQkioAMVwvV2jq+WqtV2+qvDhDoFVBBW9tqraPDLkfRutgIJCRhBwNIgLBVCohsyPqM8/z+CAkJScggQGrzfr3OC3LvOec+95N87n3Oc57Ru3fHRy/EvMX4wgQCHQBUtR11zpy1lsRECfTu3emJSy3Ht4VHY2NzFb5SayMvtSzVISqq/abevTv+pbrjg5h6QUyT4s0aU6vf37VauDrOzdC1g54GaavwnDFa5LhpvP6eqHw5ImpENkC243MF2iWv+fSe8me7+LgdE8KAK/QcyoXbMSFMIAd6VKwAACAASURBVMERFrhZy9NBp/hC9O7pO1bsBNZ6/KG3Ajh+/8cns/OP/HtB1mH/B0+mKxKHkAqgKqtQvU6MvA14IHBBrDgFtUsuHCryhRbmujCmvdYpF7UWVTUZGXtGX2o5vk2I6lKsHXmp5TgbNyGhwu2JzMzdLTMyvux/MeSpLdQpF7WAFStWhFd1zNI1CyKBX2DNXb6A/gqlz9L0hTEAqtJdjBYldBobPTYHdDpGL/TKumrUpy0goBGUEwliwzUO1ZPultQMgKlZac/M+DztKICqvgV6+4y0tEiFvr/7S3qqtZrsdo3vCcRYK8kAxrErgViFPQjzrDFRF+J2rOUXF2LeQozqFkSuAhDVdkakbluklrJ582aPMfz8UsvxbUKNmYtIrVLYXDD2gP1ZRf38ftMVbLXTcKuYHVZYVrypSJ1DZx1ls+SzuR2S1ix8Id9zct+y1Qs7VWWsQX4KvJ848LpVI2NHHhGjb4jyJABCD7Rk5sZAvmeZWu0+K3NWSM3dwflhA9oO+Aao73ZNaFNmp2BwhIh8SmEFoGI4eGYBvfXQsXsUPs3O88W2zzm2wTosQHXG9O0pWwAwxz4D9jrYH4pqhqheEMuFiH37Qszr9utXz+0eNyAIyZypL9DBFkSQ1FELyczsFQT+danl+DbhOXVqAartnk1J6XWpZSnEdh88AtXvV9RP1e4VKdimrQ5BpKvFDC3egh6tc+isozSLVy1uYQKeLUCkCF9akRsqGrNgxYJmxf79gWBfwnUN49wGPsf8WpThS9YsjBWlh4USqahvenGdYy1cnt2o1oRzqQbbAduALzGBsrdGRIYpsmBGaurY51JTmxY/5W5LPgSkINycmxdcKpaYH/xnzd0CC6duSyvKTupmZvosdpibtXyfiqxXuCCWi969O12QAmk2u15c0NAr3O9fAbSfkZbWHmhTZ7movYwfL8GoqI5/utRyfJt4bMSIbCBNRK6/1LIUomLuA64uKyy+OH36dNrTu3enhefq822jTrm4RHicwKMCKxMHjBil6JvAOU1mSavmtQ3zyJaktQuGhXnlHoWNCQOuX8taby/yPLuGT1lzqy+oLzvwAtBTz7JcnPIH+u89kkdAtdZo/SK0E+Erha1BU9rv4onOwxoDV4bc/Z3diPwDY64pNUm7lknSrEmH9+dnHeqac+ikR7WJeI48eHa36VnLswCM42wAelQmcVdV2bBhzwXZFhEYblS7PJKYeAyRDcB4wJsbFlanXNRSkpLUk5Gxu25bpIYRmCu1ZGvkqe6D2giMBvLq5ecPOFffdeu+6pqRsbva2yI+kVM+zKHiLc86ddEidZRkwYoFzVTlgaDyDICx8jHokMWrF19W7iDj3KqQLyofqzJRVF4qOM5AIBvhvlt+nTGOghS5bYNeKVnQyuigPd/kOjv25YyokZtIcD3cMO28anaImvaq8oUIW4xKqTTl4SF5cYSG7PEO6fc6oKJaqnx12H235ere/Xy9afeggUf2nAB9283M9JV3TTczeSeQc5lz4qrzkb0srJUL4tCpyvVF2QlVlyn8EDjkRkfnXIjr1XH+NG++2RhTO16C3yasMXOAIb9JSrrgeWsqwmM896mwTFUXgR1yrr6OY1uCnI9DZwOEy4s3py5apI6zCfOYnwl8vjEn5DOAoTEjdouw2RAo92EkcBsiz6g11wpsa+A0e7/gjMYAH9HqiqtO5QcbrNl54j2BE8P7Dt931hQD9x3Lz/Vbja2UkONeDGecW75/RgNPX9ScV+ZLK9pWRfeqsk0LnDrPwokN/emdBjipqvcBpZQL07r54OC2XQd7nDo4pn3u0dZqqSiRlQKbgsjVAI+0HVRlZ9pyJ1apdpKc8niq+6A2QA9VOgMgskwKKvzWRYrUYnr16hUA6kJRa5gJsbE7gC99Xm/8pZRjHOMcVe7C8mdEViMUlRhwu8aVsg6r2k3WOm9W93oW2aMqq4s3n1Dn0FnHGVRVFH3wBJ4/5nu9a6cvW9YOwKp+bMSUyjgJkJS+sAdwZdCa9xMHXrcquf/KQdHR0f7TpweirOKNH/uBd2e883nzk199nVkiPGqc2wDlKmPMB/VDnM6VEjQ/pz/53lvK7yBDwVY6rbjbJbb52S9ygXaifOWIbqWMcFTP7WN/YDq1beI3Zly+17sQaPf88uVdCs/PXLFiAHD9iS1fLBt8ZHcH4D/TtqetrkgWQTYYTNSkrrFdGjbwpD8eMbhhZe/jXPTt2z69JuYpjjGe64BcoAtAiEgqYKlTLmo1ImKjojrWJdG6MKxUuCgp/cujZ4/9o4CwY7bBh47qCpRBgLjd4uODhpln9+/Tp9Oxfv3a7aju9QKYjn5jYoo3o9Q5dNZxhpTVn3YFabTZF/I00NYxZjwAVj5WdERSUlLY2WPEym2gC4bFDDsM4IpbsNc27InGQC8sqwo68o82Jw6NXT/9H4Ps/uDWKT2GFNTiyHMGAAf7d2vwWqumYaEhNz9TsVJgJQbVB8o9LzoUkUorF9brfK9hw5CzTYftjOErHM9W0NZu15hGhSdmJCc/7MREtQusyLhrUmzsf9yBA08Aq4Ont0amr1jRRq39UFWf/+Sgx4ZZPw7610rJInaDooON48xG6RCGUyMrzIyMPX+siXmKI5bhoO8Al7kdE5o8Ght7BPicuoJltZr09HRvRsaeP1xqOb6NiOpKvUj1gspFZQLoiy/vmJ+Pz5MO1He7xvW0hl+LkOBGRpaw+mZk7O6dkbGnlC/Yt5k65eIiYx3tl6MoYhYrPCIFznkkxgz/TCA7v35+woy0tCXFV+iq+n0VOdvcL/cc2vw7YD/zJhWEJH4yKb3XyQN5uzV0kYq8hsqf3X796qESC6xo27p+RrhX6NS83p0VCmp0EBDP2GdKl0QfN8tpFMiLb55/ql+lb1y5DWuLtjVOWwua5Pv5ys1MPgAct56Q6yZHxI+f0DXuCrX6hP+dOScmT/5/s4vN8qnAdTPT0hp6gsEPgJXPvpj68tb6V9wQFDloVN+qjCiOlfVAP4WvjOpI0Eee6hLfrtL3Ui7S/fznOIMLBmGYsebvwCnCg50BVHWZWlvnzFmLCQ8PF2OoNZFZ3yas46wU1f5umTWVqk9l65ZM6R53LRCRh/4BwN2TnIdKRtDD74BWQG4w2KyE8iNiGgDVTl3uM/Ifn5gNxZs/KMHqzncxqFMuLjI+NYnZOJ4QkYfU630PkT7PpaZ2FhFVYVl20DsJiLaqK2ampUUvXru4M0InXwjFX7JMjoiLbZV7/AeX+7I/LzzmJiR4OmcfCU1r1qXptK0pvwYOkx1+DUIMKqtHRI3IzvPbI43reX7EmOkvM+bZc2j/0h/0S9ASWT3d7kM6P7rlTx89vDu14U0HNl7eYLjbvKJ7nhQR3wkYiDCs8Fi9oGkH5D63I/VQweXIQnlX0Jkhod408Xpa26/2r6RYfgtbkO8iUeFTRLKd7Ow7TwbsD0E2Osqj7ra0XRXJAkDDnE3AFn+I3upuS0sDZjsefaZSY89BeHhujZZcD/YY0gcI3dcoeyWw01rtAmBEllG3LVKriYyM9Hk89epKrl8A8vPzPwc01OOp0ZDysLS0SjngqjBJld89n7X8ZOExMbpClGEqOknQT0WlhH/Y0aPtV+XmOtOrK5sibRSJKt4CjuMU73Pz8OHNxyaMnjMmYfSBMQmj945JHPP3sWPH1qvuNc+XOuXiAuBGDC5XQ1XV2Dzr7H00NjZ3YkzMYYElIjIeIFudLV5jB6nIMBF5SSEpGAj2B3YVpvIuRNAfCpgRB7ee+eP5j431EMzbXu/yKEZNbw8616qMAgYiuhIgNMSsu7FP839jaIPYj7n+pdIhmWOmt0G1DcLDwA+4YWaBT0KC67Eiz+eLdH27Tb+19QL+4E3fbChzS2FytyExk7rGnn4Z6q3ARpSoCV3jrgCwHtoBezmtPFi1d+aEhjeZ2W3ocOncbp36A8KBQ4uLz+nz+dYCoiLfhBgz+rGVK3OBh0F+MzUrpVJWCwB33boc43GuKcz0aZEJwHg3Iu7qys5xUbDmOiDpjXXr/Kq6U9V0AXD8/hTjOHUJtOr4n8RNTAwAawUG1tScs2bNchB5pKJ+kyPiBgv09Yfqy8WPK6wANjhbU/9esAjS4eVMUS1UOYSws0QzpoTlIt/nMaCvnSK7bTDcdsFqY07ZJ2tSjqpQp1xcAKyYO8uLQvCiXfOV9DN95V/ArTOWL4/f5fOOboDVK0OPZD4xePAzqB7Ld5xrBN1SfI6CHA0yPrVZ55xOuUf6FZYTV6NjjTJXMQtw9EdGmGORG4HGhNVbB2Bgc2xEE//iyQOWPD2uazjek+NKCWk0BmE7n0z+BNiD+v/B2OkbG4f55wBjP2x19d7d9S+bnXpZp8z2eUfve/KqISWSWz3ReVhjMfKOcTzvupGRISi3KfoS6GaP4dqCG6c9xVbf07OWZ/1q46LsfEITvv7B+BRycr8O5vtSi8/rJiYGBH7eLDT0lkdjY3P5zBmDSAgn/R9U4ddTMFfBVszpa6fsBv2nRSada0xF5OaGzzmf8WdjxPZRYQ2AiOw0UmC5+EVi4qHc/Pw6Z8FaTGZmZkggkPPhpZbj24pCjfpdfNGyZSQQ5yYlNThXP4HHUP1j4cKkkICwwqj+wgXrBJzFQN8JPa4tSi3QtOmXA8PDg9V+vhzP9V9+NMfXpUTL9pWwXMxLnndgdvK8OcnJyYH58+fnY2SZVWpgu7d61CkXFwBVhjVu6CmVt2HJZ3M7GCOhJ9QsKDwW5vN9BPRAdVYeztcieqSBegvCRUXWofRVMWeUi9HPNV3bqt3cE56wesmXdwkF3RIMsfcDKDrGIrMRXgO5d33Ly9NUpEWHnKPLee/R3ALh2Ipwn0f18SHdm4Q3CXdK58W3EoNyOupCXgZCQV+5+uT+hGwTkrUvtHEfVFLWNWm/+Kg3/ERIvjxWfHioN/91VHcg6thAs1lANyff84Egi40UmAvF0FaU0n4DInEo0dK4YWpZkR9PDBnytx8XRsqo/BT4A8nueYdkGeVZ0BvLCiOrLCJ6dvjveaEi3UR1O4DCLkWL/HBOr97qqKXk5uaqKvsvtRzfVkR1pdRgxIg1pj/gCQsNHVxen0kRgyOAkcGg+d3Z557dkrrf3Za2GMDdkbwXIcuj/muhwL9sdfbBoVt8R0u9Ey4UCQkJYaJ6l6hUeeFVU9QpFzXM6SqesTaopUsD+70D8qwQMN60wkOPJCYeCzGm9ZNDhrR8fMiQ0SBLQRIABNZ5RTuptZuBgsRVJvivbqe+jjoS2mAeIoM8qjNFdMqU7nGbQDr7/CEL6edfCOR81DD6jT31mgW/8/XGlUUyqLNeUVezQyIQ2TKoW9OrSzltisagWvBin/3Un5g96XpmT35j4JE9p5Zc0b0jUJ+TvtVY3bSiSYcTCN8rHDqlR/ydQKLxeu6wam8DhiEy392TfEwtixUt8LuwtFcpQ7mAeK/X6alnpS8vxdipkUAs6q+RCA13W9ouUd62hmqvLnr37nhbTchyGkHpZqzdDiDG7ATpUtGgOmoH0dHR/t69O95xqeX4tmJVVwGdnlm1qkVNzKdQkODK2nLzZxjkEWDWMztTKnamVv1URH85JSJuVxhm/lGb1+VLf/a5n2nn4PruEc1vvzLqePF2Vau2Hcrqm5CQ4GlA/bctLJyzbM7ssvpcDOqUixrGhuogIAwxpZSLfJHrszH+3IEDS/yRnQ4vBECFpWjB1oGKfObFNhXM5nGMc0bk7Vx0y4ENAzrlHGnUPvfwE3wyKT0zq+WHRvUGIzIR4YaZuxYfx3Ut8AYwLoC82cCfF1c4f+LA61ZdM2Dk1MTExDwx8s4tA1p8DfpQkTDjZjkg0RgpYTVwI+ITw63fyWzUch/oapLdPIx8vrlhy9ZAC7dbbG9AUJ2oylNuZvKB6VnLsxT9KWrfATAhzjKg5S8j4maqcItRSpr2x85oD3QIDXE6SEHNkXPgPIzyDrPdQ+fuV3mCYmcgjC/0C6kqn332ZXRNyeJGDG4F1D8V3mA7gAkGdwJtL0Ta8jpqHlU1GzbsKR1pVUeNMDE+/htUt3oCgXItDVVCpD+QJDC0rNMFzwS5Q1V/XZnpDOYTLGtV1QX6Sr5vQAO8RyoaVx7/3LDp4Mtr0hsXb8t27S7ldzVu3DinAfX+qXBwbvLcx8qa62JRp1zUMELwGiAIlDKvCzIgX81uV6TcnPAipAD90tI+btiRU184YHYGnG9aXnXijYiTBxLa5h5/X5EfTt+Ssh3gPd4LutvSFrtZKZ9M3Zp6pjCOJ/AXRF7pnnPoFaDvOMY5pa+lH3RpEd6iQZjn+9zgFjih5m69EjC0vGJD8b5B9AGUf/jF/BQoqO6ngc1+42mQJ05qwOP57r1RN9wMtMgNCy8Km52WlfYX08rzIYCbmXwKYZXCd1TNGHdb6keMmTbqtBUCJBgP0LB+6BVqTAk/kxLc5DYB/SFWXi63TzU4XX8k0+totaI+RCr34KkMQTHdQPb9auOiAkfe1p4vgeBlJrdK1XPruDRs3rzZA6WTKdVRg4gspoysvVXFTU+vh+rVKjJDYcALCxeWKkLm8ejNqGyYti1tQ1lzlJozK2Xp1G2pd03blvZ3Y8xbakxE19BG1d8WESwFzu9FzaqeXSlacg9m/0WQvLnJc8vPUXSRqFMuahhFrlHVj6H0togX7ZxnZc25xidGj9iK8kUgNPSm5l5p4VMJHliw9v8a+XN/8EHrqKSXNi26d1pWyqwKBfnQPcgnEx92nMNZgCeyx/5SJvXE6BFbRdh+fe/LsrBOgfXCODeAfnY64ydQEH4qcIO1wd8xe/IiCBbUNZnt5gA7Nzdqvee4E/ZzKzwnyj+KXoiF45OTi/wDjNWnckLDo6ZtW5bK2GmPIPIJmHsLPjyNa1Av5EBIiAmR0NDyLRfWuRN0A/OeWl/h51BFRPhIqbhCbVkYozVngrR0Uwr8LeD0Z6h8AbZyGVbruKQcPNjLWqtzL7Uc32pEliiULmZYRcJ8vt7A0QmDBy8CDgbq1Svty6EyWoVq/T69sf3eVa/HY7/6emXFvcvmyCmfOZLtk+Lt+Kl8Kd5nzDVj+iNyBzB8TMLor8YkjN47NmH0P6p7zfOlTrmoQdzIhAahlzceMPiln1/RoH2LjsXL8H78r78OFrVhh/cdSa5oHhF5Gyu3itiefjiiOTlPzG0R+c3e8KZVzE0vWlDES7dZpOxCXcr74we2ykbkx9zwTCKqE9CSfgcq5mfA7Ok7VuwEKLkVIZ8vvqLbvY39efVa5x7rfjQ0/K/nksjdlpb2q40Lc7jhmd+D+UWzJmHPAbefrmMS37VT0yWnsn36ZHT08bJnUEHlx6h5rbKfQlUQ4WOB4dWpORIV1fFXNShHdxG2lzzITmu0yn4Xk3rG1yVzusgkJkqgT59Ov73UcnybUWtTgC7TV6xocz7ziGo0qp8BSEFJ97ji50/70V1LsHrKhefuWywns/NXTpjctOLe1WfO0jlr5iTPldnJc1vPSZ7bdk7y3Lazk+f+8EJe81zUKRc1xIoVK8Kjnvj+ywNn3u+ENmvYre3I/oEG+dk9AaZExE8/sn7HkuPWkbzZSyvMKidBeVeF60RNXN6pvG+kUztd36jN5YQ61VsZq3yO1TJTdRuVt65o6O3XvJF3P6oLUJnJnMnJheefvGpIU0X/T8X8GgpKvy9cvvBM4iyxn+eJ5wVRXXIgvHHuSx3jK85SOWb6M6jehGMG/+L+QUcb1Pfmk+/cA0QMiW6/5ZsjucIIt1mZY294NgG4glP+iq031cDdkpoBHGpc31tlc2tGxp7v15QcCt0UOdt6swarVa68aqx9sDBcuY6Lw6xZ6qxfv/t7Ffeso7pMiIs7Cqz3BoPnZb1Q1f4YsxZACxLUlXDqtCH+RJBj03akVM9SqtqzUQhZI599OrO6MvoCutNvNaV4y1et1RFjdcpFDfDBe38bk2uP7A+7osmYbX+dv1gtY5oPutIT3rH1QDdySHvQJ9qMjPnyuDrq37ClTA/f4gwddN0W0E2Kfif7i6+PS8e2jsfjLOW9J8tZzZ8bNWzScuqADB04fDuQ9v/GdM4ElhPerUQWOa9fbkdl07Sty1YCqOO5I9TDc2cmDz7PnMkTRfhgT1jTT4B7zynM2Ok/QeQ+sCP4aMIeUR0a27dtOirPAlntWjVoeORYjp9QT9nmf7X3I/omyW5eFT6CqqCCfKRQZhG5cyM/rikhRCkKQy3EqPMSIoMmdx8aV964cmbrHwyzo2pKtjoqJjJysyMi5/4u1HH+qC5RkWopFy/Nm1foHN1fVNcCWGuXAIOeTU09s0gyMhrReRTLFlwVrvCfGhKb/0WP+s1NtaOHTuQHuhzPDcSXaHmBusJl33Zy8vP/Fjx2tNGqCX+8fF/axrevGThiXf43xw+2Gxkzzgbke6GXNV7lqRfS5UhO8AS5vkp5kKuadwHn2KpNxjSs75n2aNyIGWlpG4t9ISqNo7JJoOxtEUDhjf6dGw6o11hu573xJbK+CVyNsKzoZ9U7rHBX0qpPC7LjFfhdYALBf++sd8UTwBBumla26b4gEuUp0HuZPSXTVTUCcQP7tlGgMZCiEHHsZP5BVMpQLlRARqL6XlU/g6qgqp8oWuWXsTFUuC3idk+4vMI+BTVFuphgyW0Rd1vyIRH9PWKnljFM3O4JPc62ULgF3/GrjdpqKEt1VJdevXoFrKVuW+RC4zhLqYbfxfRly9rlNGqUMyMtbSfQPWDtWoCJcXHbUP27kWLO4ipjjGVedcTbMP8PEb3z9n7ncEjDFG3Quca2Tf8bqFMuaoC5W7NfvVxyaPzsz1eHDh6QBHBo3bb5l0d1HWAcz62dbhy8M2Blr8/qLimIp5YKpsQRfQfQoxu3dfvztA99O3YdHQS0ym3UKLaq8gXgc6BreX4EuU2DH4lI/TkPDygr/XUE2CyApekLYwRaofwOx/7eVbfo78fdueLg7qW//gJhLpayV/C52xNAvbRqPhcgLC3tKqBpvTDPQBFJDQvxrkB18NeHsncilFZQbnymLdCA/PDNVfwIqoTxBjKAlsUz7FWGqKgO59y2mtw97l4rwaIXjtt9SOfTiXlK0iOhPeA9TIOdZ5/yEforgX6/7BH3zpSI+Iwp3eO2T4mIS58SEXfISnCLhtoSNVICEYO7AQ0UGXl2pcY6LhwiYvv06Vjn0HmByQsJSQVazkxLK/U9mpGWdnYV5iIcY64HMoKfb3/G//cPyf/RxF8WKuY2JGQC0Pe51NRxk7vG9wFa4nUWlzfXuRA1dx91wuxnoW2n9+nTfm115gA4kuM/ciTHv6d4O5Zny406rA3UKRc1wDtrj7+4Yb+Pjt6crp67b945Iy0tc/8puzaQnRcSPf2ePi3jo/qdVPMlIaGZQKNJXWNLrsrHuqWKywwdMOKrEyfyUu3RU82OmXo//fOdY9eIyKcKVc5ZPz0rZQ+QW1bWUIBR3UblA38TY59IT0/3ljhpNcKIyQIwljtQ3veHMVmUKxLWDryn1GRWXkHlRwx/oVQ4F6K3A+8VRaIYEw+kAU36Xtly8d3fiQQIbt7+zRpUS1suVCOBPSx6LLvUuRrEzVx5BDgaan1Vcp5cv37Pi+WdmxwRN1iEl4Fbnug8rDGAijxsMP9yOyaEQUHadDdyUDMr2g348uUd8/PPnue5rUsOqzARlYMqvGCMPAg606jeaLD9Ff0/t3tCj8L+Rp3eFCiXOTbYLLEq91NH9UlKUs/69bvrQlEvMG50dA6qSVb1puLHf5WUdDmQ9Fxq6nRVFYDXiz3bRGQU8En+b9/M9yev2QkSaUODWyZ3H3LHxJiYIyLyuIj8xmnZdLIgb7mZyaeqI5+1XPe1t0loVIOWun79nv+r7n0GrDYLWu1YvFm/rdXv71ot3H8NC90jH27N29A6+5vQhFPbn47N3tWm9TW9eq+Z+Ib5JmPbFnGcJt8Qkm28zg6ETWKc/iUn8JQu/nXDzIavvbkmItsJOXZo0TNvnD76KSLVKYijqGyyWk7ECOB4gs+LSouT9vA/Zs2a5QC4HROaINIiH2/WvO3zQoFb1dh/jIgakY3yK1VK7yHOmbgU+IrQ/JJl3RPcMOAWxLx9RiodiupCgWU3D+8WbN+h6bXAe4GA7gDK2BYxkcAFtVqcQXYGjXStyghVKbMEvds1oa2o/huRScC20BDfrY9HDG6ocDfQREPtr5/qEt8u1JO/3AY8O7D2CeWsSJFiTNua+vuns1J+Nm1rytvu1pRFU7PS3nO3paW5WcvTReXvVoIziu7C2N4onyHMRqvjR3JpSMpIarJkzcIqW+lqC82bbzYiUpdE62Ig8qGIlKhAG/R6bwR2isitM5cvnzsjLW3J0by8I8+lpnY+vbV8rYrMB9tfkKUmK3WoChNEZMaUiCHLcn86Y7aezE4PeeD7N/m7dvhNdcTa+vGfG4oQddgJP97ChFrVMqyxlURV91pLRvHm00BdyfX/BeZs879xKNc69YJ51xrs/m5O9nfUHziy619LZ35T/3iX40HTSK3dLVbWimFA0cCCEMxHuHF6yQIz6n+ZHbt99ayvqA6JX2QRqr1fWL68wjLnZyOim0TLjhgBiO876hufh+tQ+l3RsdGfXHVN0BuIAA49t3XJ4bCjMlpVTi6LXp0CEMBZiEjMvFXzGp11JQV5CfgptzzTirHTkxgz/VMaOi5wlE8mrAA4vZqIw5gUYKHXY8aI6k1W5B3E7KIs5cJqL9Bqe1xXBRHdIVq1sE9jgveVdVwd+xhG0qduTfm1wl+x3BUm5i5gh1G9RtHvOx7NEGElam8HaSyi5SoX58Ifkj8FuMbtPmQIgFXprcJ6gnwMjKUSW3K1AfXlDzbo7wsV3f82evXq5bc2+JNLLcf/Asbv/xiInrlqVdvCYwrfEfhb8MvDg+2mba197y3oHly/JU2/dQAAIABJREFUuZ4ePvaH7IYN44Cc/NjYdSDRFl3rgp22NfWvxuN0V5Xj9tSxxTmPzXTE4/m60ZP3/bI6cp0MZXhATF6OE5bp9YavF3H+UN17/Do70PbrHH+f4u1Qntbq70adclFD2IDvwxvfPRZy9SuH70wPbz/JEW3UPaHHAcf6PxofOd6nSicjslvRdJQzlouckBigIVZvovDBP2b694Cbok7s3y2WoqRbk2Jj/wNssapVDpNUZJOFc5YUH953+L6AY64FGTp07aC/EOLpyekaH4JcI6JzXXEtwLCYYdtQ2RfmmNKm9rDwt4DL8OtWRL8sKPcu96P6ToHyAc+lpvYEGuX5fGtwnIVaUITo8ITY2FUYuwtod1rxOoNIJMhFUS5UZadI1SwXUVGdswCe6j6ozeQeQ+4DcCMjQxS9DWtfAQgEeQvRvlh9SlVfcrel7UK4V0VmPJ2V+qOp25bPn5qVMiDg8U+rjtzPblr9NapvWJGHAES1jyO63vidJUATN2JwmdaV2oYYEwfSp3nHxmUqbLUdEdE+fbpUS0Gso2o8nph4QGAVgcBNAL9JSmoCXBtU/Xfe0y+MzvvNm03985Of8i9Z+aJp2ni45vsmAgtITDRAH9AiXwg3M/mU4z3yHVXdKX7/yOCaz8chcsvpbZZKMzMtLXq/0/CvRzz1TwWtvS8ysvmp3r3b/adGb7yWU6dc1BTz3ANBy0o8OsoXlOWbw1p7Iq+PanPLb+98IGPe60951LZQj2e30eBaoK+bkFAQRuQErwXyQG6ZHBH3UfyAH3ZCeA21Pw2xgUhT7A//NIsK/S6eS02tdFIWVZssMGRyj7iHyjhdtJq9Lvq6L60nkIhKQu+fffd+QU7XQZHeoCXjvMV+KlpG+t33Hs1F5ffABD6ZfCezJ0/BOp0wZ6oJSoG/xRo3MTHviUGDtlBQfv1dEVGOBb8AlFynWNiuCmivi6VcgN2pVbRcrF+/Zw6AI85jojJz4pUxLfA3GwUETGvvpwDP7Uj9BpG5AMdsw38BTN2a+u9pW1OKe5Lrs5tWf11dydWjbwIFFV5Fmud52eDuSc4T9BOLGV/deS8qqvHAHGB6UvqZB/vs9Nn1lq5eUGP5RC4UmZmZIevX76kruX6RUJEPFG4GyPd4bgCyvrnt8a8EeVrhqWnb0v7ufvjmY3b7ni0mLDRR8vMXB/cFIgGc1p4SzxQ3M9PntPZ8D+SuSb9201DNCoaEJFRJHni+uf9kdsvAiYkT4+M3b9iwe+D69XsmV/f+DuT7vziQ619TvO3L89XlufgfYj4qIx5PTDzwtafR3uyweoswph+q9/TM229zY2L20SZkE6B6IDjZBYPKtQi/aubPiRO4oe+pA8ub+nO2/HLH4muB/FNh9TKKX0BVFwG3zEhL2ysieyurYEzblrbBiI4W5dkp3eMeKTzuRg5qNqVHfAmz37V9R3+hxv6sQadWV1o06/QWxtVnKxeiZpGUl9t/zlNPM3vSGTPg3AlH+eSpohemgQREUormgkWovgtwuoT6l6g5szUydmY7oD74t1bmfs8XVWcHqlX1uWg48cqYFiA/Atnj8YXMDAp3Av8skQJd+asYeb0sh82aYNrm5ZkIG4IOLwBfzPg87SiAivwduL2sOjO1idnps+sJ9FOxv1BYjfqKfEga2JBnRPjFpZSvsojQ4FLL8L+CWvsRED8jNfVniNwlIv9uUM/7M+CIk5Va5OcVbNHyJgJBzZ76+5YiJhpYX/y7WYibnByYmpXyFoAak2Sh0s7Qz6ekDPVqsH899V1mA54kAFXjUSWsuvd33G87HA/aAcXbCb+ty3PxP4O1C4FruO91r8La1Prd1l896v7xGfXbTWvlOya3LHh9pJucHFCr16pyRyAi/lOvDcYQdN7skn34i2xvyN4D4Y0ue2hParSiV5mgE3N2nY788PAUVf2dqt4LfC7G3F1Z8dytaclGZCTCs26P+FgAG/T+CdVSq1mPY1d4G9Wv36Rnu4NL183vDISHBBpvKt4ngFlqka5JK+d3rMrH5KoahWtFdWnhMVX9/ZNxcWeKAqmuwWixTHnBSGB3YV6NC40jgZ2ItHAjEyr9gujTp8NQjz/k/wGpRszNCOMExqhj/1a8374G2fN9AX5f40KXQN4UGKVQpBBu2dpyMSCREfvPu9jThaReMGSgwtHE6JHbjPKgKDcvXbvw/047eN4PclVV/+YuNpGRkb6oqI61+nMGKFCG//uZEBe3S0RcRG4D4vNf+WcjEZ2IZaILRSGbk8cO3x5cs/F1Dhz6CdhBlLYMl8VSsbaUcqGq8tzy5f2fS029rfhxa4zbxnd0PrA36oYf7Qbo3btDWp8+HZ86j1s8AXxdogXKL4BZG6hTLmqS/jYDyGX/4VhVXXO6jC8HnUb1doRdsQWrf8r48DdNpm1PW+0L0b5W5KqI7INHmDthV8+TB77ZXL9ly1mtozKxMsU4Try7I3nv2Zdwo6NzJsTFTZoQF7dAVF9B9QFXtdK/R3drygpFnrFW/za5R/wvUI0DeriRg0qk236575tH8r45pl1vvqaBqOktyLbY2Njc4n2GxQw7LMg6caRKD9HQlSujgHrhJ06sKDxWQrEAEDObAgfE02gkerG2RMDNWr4fyAn6A5XeGnnXffVK4AEjMtXdmrxHlZkg66dtXl5C7jfWrfM/tyP1m5qWuTj5vpB3gVzRM9am93gviOrbKnLnOYZecgzEI6SIiA6NGbE7aOU2o7xsVN5W9DmBFPGYmyue6dKhqpKevqfVpZbjXDzc9fpQxxda6cVJIbXVyfaJwYOfOfSTqdfmPPz0scC6TUOMyF1Tt6eWyjWy/vGUh4AgyB1gKlQu1ONJRiTimZSUot/nc6mp/WYuX75XVFNE5A+zVswK3zDvtbHPp6XFAf26+b4+CCQX9t+9e3dYZuZXZZc0qAwnfI046WtRouX6avX7u1YL91+H61rQRWBHYsxaVPsDiDGddoU2TwMOOyGhowBmfJ529It6zfZdfXL/UYC2+ccbfRXexGNVnp22LWVGZeKqw0+enAU0Dk1Lq1J4qtPKzMBwWFRnYsz3gS+s38QU7xPZfX+HE9v30iiidQeUqFL+FqdR7AKgSiXKxdprBVJ+OmpU+dsCPv8CoCejphf6XUSCvWjKBQWpfndKFcJRjUf/DWxxt6asAHB8zvPlZNO84Mzctfg48AEiJX5vRuTvqtxYmGujVmKIF0tq4Y/XDhy+SOGXiD3SyFz+nIp+qFZvuZQiVsTmzZu9Xi9/v9RynIvLPCcHIVq6AmgFRNQ/Gp254E9FL8rt814KXT/39xXXFLoIhOfnfI+cvENTs1IHultTPiirz3u8F1TR5wGvEVuhcjExJuYwsNExxZzXC7ZeljnZ2ZcboPPx4wtF9SULtwm85bU2RkWSCrsfP26ifb7g/zv/O/zvoU65qGnELARGSGjoOqDV9GXL2qlqJ1XdDXwKZlhh1/UN2zTqkHO4+eMRgxt6bLD7wZBGC4gOlvmFKIvTL+c/Y8yDVRHRTU4OWLV3ijB96pZln6KsREyJh4xFI05+8fVBjBMjSG+rsqGsuay174KMXLBiQeW1ctVhVvXcGe8WukdAl2N0TIEzJ30x5iLluChAYWdVYtOPZm0/iZzZhnD3JOdN3ZpWc2XYq4hB/hI0wRLKhZuVuhHYHuLJH3eJxDonszJnhYgSY9GU4scTB4z4lWMYHR0d7SdoP0Jk4OJVi2utSf/gwV5WT1farK0okigQVdVxIrarDQQSCn/OxTPQyNm5ey4Ngtyj8BcqqANyLNDwbwib3a1plYvoUV0qp/0u3KQkTwh2fNTJPTtGBncMjjm1M9eKdAeaNwnmfKeezV0M9PEEJblILpFjIpTKuFtpAoEd+IPLSrQcW+fQ+T+F418EXP3klDnhwBKP46QDcSKyGyOLQa8F4IZnrtvW4IpmXmvrham5Fzh40An9XoH1o/KYYPAvojpyZlpaw6qMm561POvprakFjpyGlSoUKRduZEIDNebRk7v3fS7QD+irSpmWi2EDR21WNDPEK9+tzHVfmjcvFJE4gYrT6YqZjZGxjHnmEZDL8cvCSt1cDSGqO0WotOVi7+r0/Vi2XEiZqkRWSvIzW1Z8cfZhVXkH4bayhlxqmp9q2E+F/JQBqz4/+1x89Mj9AIkDR+1FWWecYK1NCpaYKIHevTuVTo5Xi1DVRKDDk1cNqVopcCtdFC3ug3CNFmTPvaS4XeN6Af2DXt/fKur78o75+YreQWWLkRmzVFVHvrBwYf3QkJBr2vqOhrW2J36ian4Xpv4TK8K77PMbz9oW/pON47J3W+CLyLE//rJweFRU+029e3f8S3XvjVx/V3L9Q0u0YH6dQ+f/FB+6B4FUHOehJwYPHqGq9wMHVWS3ExZMAVq9//Zvr0b1Vb9xJoIkgT6ByCrmuyeqernHhw7dLrDfqg6urshG7UpRBoxjnON2iW1uA8FlonhPHD9xm0IQaKOYMi0Xp3lLlBLhgW5SUlhh2t3iZDdsOAg4+cSQIRsrlszOQUlEmAb6PeZPvKB+CmejIjuqYrnwhIX2NaK1RrlwizmyFccx5l2BeDdicOuLLFKFWGOuEiWjMJ9KuQgfiXLT2YeXrlkQmZSRdMnLy6uq2bhxV3zFPQv8MzbOe3VyUpJ70V4Wbr9+9UBigPwwfxWtF0Y7I2eKhYnlGgPlJuirBDWS2M16uBeROZUN4562NW1dZefu/J//LFBjdgbr1/+dqN7WKf8bv1h54urRD/T8tF636/Icb9QXIc1o5TuWK8HgYEWTio9PT993+YYNX57PZ/RfR51ycSEQ+yjIIzL6uW4T4uI+zBs8+OpmoaHrIxMfPAWsWvuVPg8cpl/gNRWdh0gLVFdW93IWUhCp1IOsLPY1yNsAeHp0339l0OP8Q5V9R4MNRrjJsw+BrgH2Dxs4rNwvrN9j3gEGL1uzsCjLaHhIyG0vpKaWkkmMuRZYIiIVrxg+mZyFsAd4itmT0qpxa+eFGLNTIGpKj7jvFDyMy8ftmBCmfl8rxHNRQmXPB3dr8h5gTbAW5rwwaIQ9nbjt3MgCICEpKalEeJ8g1+Pz/fECiVdpNm/e7FE1lcprsGne60+iTL0sp/mT5+qXlOR6Ns59rUaijGxOg8HAESA5qNK7KmPFahegZ+bcV1pmJr3SQEUG6HkoF5Mj4h6b0DXuiuqOL0K5naD++bznKYPx48cHg4HAD4FbmgZybg+1/nBTP/gvgElDh34FbN0TctmQ+uprJMJ4o2ecOQE8Hn8Pa231rYWn8vM4mX+qRDserIsW+Z/jkykZwF8x9hVueOY+98Zn1/z46QUxALuOBje3amCGgTyA61rH6jwAcx7KhYgsE9Wh1R3/xrp1fmCtYF4TJNLxBu48k4NBVgLnslowvO/wfaDLLHyv8JhVvduK3F+837MpKVegep9YW/mS6VZ+wuxJl6R0tTG+dShvo/zGnqr3pRsRX35p59BgdxHjY2vyl+X2qUWo8I5Q+7ZGFBNxJnFb+ST0v24DcELr+8+22EUjfDd5zcIHKnO9pLULhl0IS0dmZq8g8K+K+m2Y+9pIRScjPAwy4fP5fyg3i+7lp1qMBX1w47xXf3TeAgZtIkoSyHqjVbNcqJHOQDCgJiGQ4wwB8kE6Zia9Uq28HgL3eh2tVkbaQtzuCZcDzf1OyKrzmedcTBo69CsRua+9/0ieiPzz9GKxANUFPvGoFVkNtLPGm1x8rKrdK1LSj6hKWAkDbVCiib/U+3tMwuiXxySM+nJMwmgdmzC2SllFa5o65eJCYZ1JCFHAfahuAt7npmldZizPGR7bLsQ/64fdNgC429J2ARuP5wQrbaI7G1FNQSTaTU8/5+r6nHOIrkQ0xqi963RVUABUZCWU7W9RcrwsRBkC8PyyZd0EBiJyc/E6KMaYV4G0J+LjP6q0YHOeWlKlG6lB3MyVR6ZuS/3p1KzUDopOtejsyRFx95fVN4j0CAaDmW45WxG1jaDH9x7Q1+0xpFZ4+Reh2kNVKrT+nLZ8LRYplcQtWkRfVHhh8ar550x3D6DW3CEB3+8q6ldVxo+XYFRUxz+Vd37WrFnO53Nee1jQWaLy8NWjHvi9CL9RlTczZ80KKXOQw49BF2B5cePs13uU2afSSCKQhNgNKpW3XKTPfr0eSitgrsA1Bq5R+AjkuP+U6VVVKSZ3HxIFtAe58/T/q0UQ7QSceG7rksNVHfv57FcrHdZ8y/F1i1r7jnpEKWEdU2MWAinG8oHA9qhRPyqRRqBPn057evfuVH2fMRvcTdCuKNHyA6UcOlWZ5Q8GY4ALWjm6MtQpFxeKuROOEjCRfPJUNLOfuhtIJijr1+33Hw9zsL3Cj5wxI6o8+5u9K3PLn+zcPDFkSBZwJDQ/f2DRlKrybEpKpb/somYlwm/dbWklHC19fruKSigXVuUzhH4A1nHuAhYAKwLW3g1wOtFMvCNSqRVlLUOnZaW9hDE3Cbz4SNtB4Wd3ELU9m3Xu+F9RFAwKa5DwnkXKLRN/sTldebej2EAltkUA5VPQouir1NQ5TYHOqsEXRPQVR8w5w4BVVUR0mCq3L127oEadQ5OS1JORsfvn5Z3vUf/wShV9DNE7rhpz/58BzKnLpqKEBeodKlXwbOOcP3RWJTEQCN4D8ieMfffzj/9YrWiZxyMGN0Q02nidJBs060F7uZGRZSs0Z+Hx+jsBPoV/AImKXoPqEkUzHafqWyNG+K7CQhH+IEKZ1UfdyISKnapFOwG7q3Lt9E9fb/z53FffV8P76bNfr9QqP8+GDBP44qrR96cXP57v86Wo6r8Cysd61pYIwLp1X3XNyNhdykeo0mTndyI7P7ZE8/lL+ejMXTY3dWHqwv3Vvk4NUqdcXEiKHBBFyQ+9B9jsV7kd2K5GIwq7mW0pld8mKJ+U4lsjM9LSbjLGJD+/fHnlHBKD+ckmz5l49uGRsSOPeH158yoa7s33fQa0WZCyoBWqdwj8FXhNRO57Ni1tlIi8geo9jw0efLDyt1RzzMosZzVYBaZuWfYpcLBxPW+pbH1ipEeznj2r5nV/iTHB4M9RYqb0GFLm9kjS2oW/LCvEePHqxRfE2hF21HQFfMsGrq7U1pLfK5+q0qew9kggzNMP+E/igNEHgvBvhKHnSviUsm7xlQKNBX1AVF4vXsNk6eoFdyStXljtl0Hz5puNMTK68Of1s19tU/j/0zki+gcCgYFXj/pJkRUvcvx4n6g+LiKTi+eRAFDhXpB5fW98eF/D+qETBP1SPYG1G2a/XuWy7mEFFsb9bmbyjqztLbYBwaC/ac/KjJWA6QLs9jjeJITOQB/j1aUCm6oTMaLwXVF9P88XOhUk0o0YMvLsPjYQ/NVT3Qe1KWt8kVzYTojsqux1t37854YhPrtO0frA9lBjy9/yLCGv9lYolRvDTUzMyw8E/tJn7P3bVc1rZ593HNsSpNrhuhFtmoX1bHc5xVuXFk1DqzvfxaBOubhYLHosm1ZXDOHjiZtRtls5U7fCrQFTuqguA+KhcEUmv0TkmFWd++KKFc2eTU2NmZmWdk95490dq0+4e5Lzyjo3ZMiNJyu6flzcmKMCu486zj2IhOU2bTonr2nTj4D6Bj5UuPfJuLhLlvOheU7jPxaPXlm8evFl1ZlHYL6i1xf+7J7+DqlKj7yjR988b0EvIu7OFQdV5Geo/PbsDK0LVixopsqUUI+sX7JmYZFjrqqKI4F3V6xYUcp6c94IPYBtFUaKnGZ43+H7BDZjfQXh3SrRCOkA5lToZwLmig5N+pQ3PhjU6xRSEgaM/KMgy7C+pctWLeqWvGbBjxB5E+Ta6t5Kr169AiK2yI/AONxe+H/V/C7Aib43Przv7HFXjfnJXJSMYNA/qfDY7qQ3wwT5P4XXATol3p135dqDNwFvibFJ2+e9VOZLZtPs16I2zH3tZ6VOGKcXFCRXe4/3ghSUEajs1khnlF2RI+89grBeYOdVIx78CmETmEpZLtzIhK5uv3713J4JV4J0yg+EfTJz1+LjovKRIiOK93246/WhwDCPOGVuRxajk6CVtlz4nPzuwBVXjXpgFDBPlWEVjQFQoY8gZVpy3cTEAEDU2B+Xym8SCHi3GmPeqax8Z/PvCd9NmffLWz8q3v7+87EXNXquqtQpFxeTN37sB1DR7aKmSkWxKsI6ziKg38y0tBtmrFhxC9CS0ND+wBc+a780IkkKv31p3rwLpu2q8hliblXVt93ISJ8bGelD5I+q+oMJQ4ZU6Nx2oVi8anELVe5IXrPwxwBLVixp40gwLT093VvVuQSZr8L1AJO7DYmhR/yCxyMGNwSN+Gr1in/XtOwXmmlbU94GtgcDzg+KHw/xaILANlRfMbAoafWiaIBl6YuGgfTJ8xy/vswJz4vKOXMWRwu2RgpXu9HYAuUiMTExoJAiRktZmQoRscNV5VMAzfberspiK/qZIi8IvIRoQnXvRETs1Vd3PlOYz+rYjA9/0wQgGDRdoPyESo7YXwAPbJj36jUAJ7PzXgC+unrtgUVF87muvWrU/ROBvHzrxBYf/9nHL7feOOfVxdboakFnnu1oKZbuInomeZSwAbSUv4NbxvtBDJ0xuhNA0aUWXQJgrM1E7dVTesTfOaVH3JzJ3Yc8Wta9uZGRITYQnGtP1fvC2uBrCItPZ5PFiqYqxBXvf5mTPRgIVeS+04pGmSjSyVZhW0SM6QrsFBHFyGJEK6VcCPRRKTtb8bmIjm59KCqq/aaKe5bNlR2aT+jUosnNxdvgXtWf72LwrVEuHrrzoZcfuuvBLx+660G97777Suyf/eSun/R+6K4H1z9414O7H7rroYUP3vHgZZU5d6EwIjtEbbeanHNCbOwORH6o8LaovqiqLzwZHX2csLDxiNyb5/c3B7JzmjRJqMnrFscnZkeo0Z7G4ykyC+bFxv5yQlxcTWz7VBsxwQggF+SFpFWfDjSewHygx4nA4Qod/kqZnT1mKdB2Urf4nk3aNP1z92t7DQrDpAHem958s8wH6n8BbwnyveIHBLkGdElizMiZAn/D6OMAqjwAHJcLEMZaEIZqq6RcOI55E+R7SesWdAX6IVrkGK0qSaplV7NMSkoKEyTOcQqUi8TExMA1MSMexfAjNYwIWmeGQq+Uz+ZVK0QyPT3dm5Gx5w8FcqioyNVOSHjh31sXtHzlInL0g+sRHhPlw41zX30SuMsSvF3OSrAnIirCUi2W9RfA8XiHitBeAp4OwF6b7ZQoD6Biuymyrehnq+tVKW3h6RE/sJTDr5UuqmYngMBSUZYC+ExwEyItwxqETMRySER+Wlh9d3JE3ONTegwZC2CDlz2MYozIj1FxFN4vmtoEU4HebteYRkWyoSMoiLo52sScLPE3WuKzUDpLsPLKhcUW/Q4K8g9J241z/tD5XGM+m/fSFUBrj/FWWbnIyNjdOyNjT5UyKf+3861RLkRklifgL9NL1iB/VsvTr/z1lU6IXS9Gplbm3IVCVXaoVL5mRWV5cvDgj0XkYSAkPzz8VYAno6OPPzl48LtuYuIpROaqtVWqA1IV9ge9bRsazX9i0KCiRFKuXPrKfSL0EFgpRt/A2DTgP8ByYxhQ2OfzOa+U2nPOnPtKbzH2491JbxblUnAzk0+pkGocfevyLs2bXzkqKqzNVW1z4f+zd+aBUZVn2//dz5lJQgKyCYgigiwJhLCGnQBhJ4DWjVbrWhfErW/71tYVp7jW9qvWhUVrXWqt4lYFAiFAAmELBJIJIDsExB1EIIFkMvPc3x8zCVkmIUGoy+v1V3Ke5TzPmZlz7nMv18UuExF52j/T/waMP/Au0NcTP6Rt+UGREUpQtVas/EWUizPWLRguMEHRW4CJc3PmRkPwQX2q587YnNGwfLwSh1IvnpBhiaM3IryBlReACzCR5Yl2jpEMYEhGRka1xDeNKR2scHhon1GV3v6S+459c0Ti2OxRA0Z9IcI2f8CclD/m/s4Dz3soLunf0+KS7r03bmRzT+chF8674e4bSguPdgHIn/v3dsBZEir5FKEjws7a5uyeMvU5RGYCj6vob3pOuGN72I5WFmu1ihmbYGFNwsU3f4HKXBWdVLldOhml3HPhWMls2CxmYFUul4DVrtZyS+WhXIiwG8BpoFk+dTIAeqfc9ZXvWIm/3YCOrxn317cAkV1iP5/oiR18rsA0VOZMix36a1QfxOhvPVuXvzd9+/KBW7ee88+yqUNssp9YV0Q5W7AiYxQWqvCciNwR7hJcwRUOQluj9fBcWOmAkV0AZfxDUHtoxI3TS2Ff/Libvq6tX9jziWkInHHSuknDJsyeOHzCfiAabP7EYSn/VVbjivjRGBfPvvJs1tOvv1AtS3bqr6ZeCLR5/rXng4lTfjML9IqTtZ1JuBzZAZyz9YOX6kXZXRf8YfDgl1V1sCcxsZo0uVo7T+opMlZXzM7JcX9tndEubNSp5jOcMVjigK3Hmtj7EHnRF8nlIrpS0X4QzBpXMe9WZUgMYO4G2hw5VjKl8ny6AKVXxyGxuQJ7BtyQ1L75BWf/vUGD42fMcDuTCOZesCwQCHoj/pxy5d0onX3+oDbCsAFjdqjwAWreVzRjRL9xc4DPG2pEysJVC5sR48s45YTZo/5uNPSlpq5JPUshFq1fWATAEX0QS19gb3Ji8oGy4xmJK70CpRJd3BcgbWVay4y1aY9nrk1bIujLqrK4djI3WSbWDK/t3NPihlzpiGuTVaKBcW71fWFFdlif/7EFU3/9MQCmNAHAii0LPXRQ9KQ6Ewnjp9wrKjf1mHBbjSWtjvgXA70rJ4BKglHJB1CHecCEssTWkAFxXqk/aFzkz5vR9NJnrnpk0K+Gij0aVYkrR9A4RK73tBseBaAejwHau0Ihnfjk2wsTJ005AOBpN7zJ4U8PO+36dbCezZt9wIuo3q5qHlVYguhk0CcUVlfU2wnlfFRElthg7lhQDl6AIiYtAAAgAElEQVQTAm5feonaV4FYT9yQ4WUdy+Ti4+M/Ow9wHy72171aROhAhc9AYAnG1GpcqJVeguTW+RwVcOhQ2zXHjzuPnMrY+mDusvlT5mXObzMvc76Zmzn/3HnLUseefNSZwY/GuKgJLuV8YD8hDvkvir/YBzS/8847I2trO5Nr6jL2ls9RCovdvjPypntvUlLYrOkSvz8daP3oypWnhYbWk5HheiIr6x9PrFix7tDx42/4VI4LfOwygXpnsJ9JGIi1sC2lU0pJct8xU8f2GFtkYW1Z9rbbZ0cBXZoda3l92ZjcBTPbAZcD9wp6rzfttZiyNlWzQFXfa9SyYTtF7hYkNfnXY37OtpX/5Z2dRljeEtUrp8UOeTrmnKZP+guP7R03aNwJvpMAfwKaoFIW8nob5cYol6QDA1oUNjlpiCkc1NGWKMnRxrUaOCvCXxz+Db0WDE0c95mK/hmlUnmgRzxWheWKPJmZnTY/0s0eIElF3xeVP1hM7Td71cza8i6u4AoHlWeB+x7elnXx9K1Zw1Skl1GnVcAvvQKlpRd5Og9NESM9gOOCBI0LoYOjJzcuRETLylRrQtcJd+wV2F1cWlLuvRDoHkA3ApS2kOVARNeGB4Nl6oXRHYHjj+5avj9v/nOdEdmASkzDFmdJ2z7tK8mvq0gXoLmN8F8BsGlgi/OAiMOFx6o9xG0D7Xvki8NFjZo1PB8goP7ZiAxX4UrF/n761hVzjeh4xdZYnhs8py5X0SQApzRiNOB9bFP2F09uW3lURR62KrN+02ZgA0/s4HNdpRErH+w4tFcgIO2Bz+tZzt9BK+S9iLAY1Yvz5888mD9/5tcb054/v+oAMdJTalCHPhmSk8U/aND5p0w38EPEj964OF3IzS2Y4fUWpOfn722akaEur7cgPS+v4DWA/PyPE7zegnSvd8+9AHl5eyd7vQXpZXXNubl7PMH23bEAXm/Bm+qKUUfptHHj7lbBtr1PhfoOD86995bQeW8Ltu9LCs5d8KzXW5Cek/Pp2aoqwbaCfwFs2LC3a2hdD4TOc1mo/TKAnzVt/5smTkRhI8xtf1qx4sbXs3M3eb0F6aoqQe77gvS8vIJngmP3JYX2NDW0p1tCexoOsH7D7mfPa9DoExFJAv7e0h09qIP7rAMqbHAkclxoTw+F9vSz0J4mh9Z1X/BafpwQ2tM/vd6C9IwMdW3e/HGz0JqfD+1/UGhdd4TG3hhqHxEa+/+83oL0DRv2nRvqn5qbW/B28O9dnbzegnQxzkC1stXr3TsptKcrHZW1IF3z8nYtte6oOwKOCzXuF1asy/ps+frF3R2ce4hs/g3np7RD+MQY82RoT79+ZMfyLaP/8sB6xHTyN+/nLiw6fpu6GpxbEtPooDd7a/vQuubm5RW8F/x+7L0weO0KHg2tcULoelwd2tPvQnvqHRr7ktdbkL5q1ccNNm/+smFo7IvBsfv6hq7Hb4Nj914b2tO40Of0ePB67L4g1P6f3Nw9HwS/H7svCI7d80Swbc+40Gd6nd9EvG/E9GjQrPktrQYlfHbQu6vU6y14westSN+8+cuG7Vt13hzhNPy0SUTnnwFEu1rkA+NEIhsIrIowMbeF1jkhtKdHQr+XC0N7ejcvr2BesG1/m1DfPxu1rQRns0uim4vIN0OGXHzU6917V2hPA0J7mhn8zu9qnJOT4w6t+dXQnnp4vQXpTSI6IEY/9Hr3/CL0e7kIINqc7Yt0zmonxrVRrRnZLDL206buuAnD+4/5dxOn49HQtfxraM0jgnPvvRmgkbvthSDx63K3pYT28FzwenzcTFXNTf+4ao0rMqqRae286PXu6+b1FqRf+u/XLvJszzxw2duvDul10/UuiYz4Z9HBwrEB03APSu+/jLj0fZTWhwKx9+Xl7VkUPO/OlqHP5W/BPe0ZFvr/1uB599wavJZBrZK8vD1/C37GO1oAaINzGhw7xDMAeavW9QPayjlDRgG4XGMnEdW8OOBuejdA58svvSfmnFY2L29vV4NzKxFNHW0zzhz58vDi8/u0Hxe6Hs8BuCIjejbtcOHXDc5u5gEIRHX9Ncbti+58aehzKfhr8HrsOQdrB/gDEQF1R/8c4Io5r8e06BZ/qGX37t5Htq3clpu75+JL3nr9/ivmvN4r9N271+stSN+4cXf30D3iVa+3IN0dc9ZqkL45a7Ysbd6p4x9FdNGGDQUDvd6C9Ev/9ZIfKGyb0GlBVMtW241jWhujv4r92UX3nNW2TXRe3sfnhdY1Ly+v4B2AjRv3dQjt6eHQd2miN2/nEkTOc2tgV27u3t97vQXppa1H+ETlSm3WK1sjm/sIOK/tyslpHPocZgefAs7AQJOES8r4S3Jz91wXah8b+lz+FPqetg39/2FeXsH7od/h5Xl5Bbtzc/c+FrwnFIwP3U+uDc6195S1ob6v+MGQ/tQVd1x/e6EvorTdCy+8cACCoQ/HmjXPvfJ8K0DvuOaO9jia/dwrz7esre1MrzN/3sy31Whuj5TbHjvT56qIJ7KybkfkOWA7cL5Aqz8MGVKp1PSx5ctb3Dd0aK1lTo+vWDFdYJKrtHT075JPuKIzs9PuVHRycv9xSbWN/28hIyMjSmN8RQFj2o9OHF2JPyFjbdqnRrm6ycGCuUUNm6+KKTwQVxzV6IuAK6J7zNEDcrxhs3tLGjR5K/roV9dGlhz1qOqHRnR2QsrtizbOm3Wpij7SfcLUrgBb3nuueWl0zG78xW91nzj1lvCr+X7jwc5D73HcpS8MffHBzRuffrtxwaqtzSu+Dc7ZPCdicvxkX9n/GesWPfFV9DfTWhQ1fhShaXLfsTeFm7fquIrIWJv2ANBtWd/VVw1bN/DK5H5j/3XaN/YtkLE2bYuKPjCi77hqlUAPxQ15XK1cMH171lVV23JyctzGNHvpg6uu+2rcfZPu2jg3z+l39WA2L9i4JH58txH/+cMcsdZ+ifCRxdz4yLbl9SKAqojVLz95vYl0ZvW/6n+j8hbMHmKsfa/7hKnl97CN82deo/C77hOm9niw89B7wPadvi3r8vzUWXtE9H+6p9z2n7S/3dOnVfs2Obsytw287K/PrvlNm4ENGsW4CjUgieLoSgMDLnvqqkRVru8+YWq1PJQHOyfNbd3lvK1Dbhl2h6+VOSsxcUrpg52G9Pc7kTvryZop02KTvgBcQJGK/qyiwJin06Ce1jjrFFJFmIHyhsDfFc6bvi3r6pqnPYHNqbO6BlQ3bC1qHjN58uSqYRly0mc3dvusV5Bnuk+49a8AmzOebxg4Zg471rSvqHZaV2zYsC/RcezwHj3a/aW+Y3+o+NF7Lmb+Y+ZuRPffef1tlwCoo1NFgxnKtbWdaZyJctS6wPj97yIy7J4hQ2KBvcBFFdsfXbOmlYj86qQTifRS1dcrGhYAgYDrPUQGLtqw6HuhuBloUNxZ4PioPqM+rtaorHVKjl2LarTfFXm/Uf3fBseP9GlYeOBASVSjdcUNmky1sK+wUYtbDzdpYwVnr6r5wLtgRqyKHSxQHgfpcukdBx1bMhDhulNlTvyukLk2bVJGRkbUw9uXPzH05Ydai8tp/M2WfV81inYqERpVNRCS+465Z3L8ZJ+i61ASw82dk5PjblnYeGZN51ahpcAXHvHY74thcUufPidKlIWVBgaF66fKRIyG5W5JTEws7d37wmsn/fnqB2OaN5LGrZuMFJfkJUzq8bVxOdtK/NrKwOWC7DLognvjRp5yntLKf2R9424QEbn4uUdHS0C7A5Xk6v1W1gBd92S8HGWETsawfVPq7D6iNC8sLE4DGPvrJ9Yf2H3g63N7tJm1cd6sO0dOHXYNcPzhncvzUOZY5Sa1jAcJq2YsQv+D2z6fD5S6vrTdAB7esSL7FOi4FeFhI/ILsy3rgqrKpZ4dq/IQvdYpcX5utmalA0cUbqwLx4U39cU2AH7oABSEMywAEkdPOYzwK9CH8+fNaAoQKJIBAl+fimEB0Lt325z/S4YF/IiMiztuuH32Hdffvh+IjvBF5N9x/R3lWbIScG5UxHPHdbd/LNATYx6qS9uZxJkoR60Lfp+c/Pk9gwcvB1DVt7SC2BiAKS2dICInddGJalcR+ajq8ZGDRn4ikO0OUGe+/jMJlzixoNvDJe6pkbUu6/tlICLq66GDJq3ttu6Ld1AdnbD2izb9Rl49aHi/sR0KjS9meN8xbf2uiMMHWrT/AHhVrHkGxzVeKxgXACXnpESL6lrc/jq9QX0fsHTdgliFf9HQ9zMAI5ICZNpS3zuIXFaXOay4coD4cMRah/1fJ6vwq4yc9CHhxhqVVqrUyNrqiY+PeLDr4HozP54qPJ2HDDm3KKZCdYWsU63OrOiJG94OJM7nZmG4eVTVeL0FvV3YbkDh5L89nymYPJQUhV2P78z6yrN9xQrZljUF2ORW33/qSsFdFYe/+qbrfu8+IiLk94hNQCsbAD3Xf74LtORo0fF4RTtbZYeilyGkDpr823LP1J7VO98pPFDYRI1e3+LClv9DUJ1WjTCvTY/zL0IY43Lk0arnf6DjoA5A08MREeuADaLa51T2UYbpW7Oe9WxdvshTA7ng9K0r/u0pyCz2gEX1FaC5Qq3snKoqooFg/oq1tZYCA/RImboU2IzI9QAqTFWV1+u9mRByc/c0Wb/+4x9kNdmpolqJ1g8Vz738/JSa2p597dlcIGzCWW1tZxLW6g45A+Wo9YHCGwL3PZad3fy+/v2DbxgiFwODQyyfYTPpPRkZDYH24nJtDNduVd4V0cuA58/U2usMIU5rKG8U7NoI3zGXOhEfQJCYCKikrTIpcdIxgMy1i7IEhvql9EGHiAIJBKILm7Y6p9J8ov9PRV5CuRv4f2dmQ6cPc3PmRos1bwt8BdwAvKkqKYh912LWC3bBnR3HR55QyA2PkYkj9yxbt+iIzzncE6ik7mscLhHla7X2z6o6qOp3StFWIF/UNLff3/w8AwOAzae+07rBA8aK/E2tfgC8B7D91dTGna8d33vOnDlOxTdda+0EhJVPbFxxKNxcH330kQti/iRG3xJlo4iod/4srwg3mAqJhB6wvynyX9MoxvVZoPTsHoShlj4prPbZt3ZPcdub2w4VpLkYrSTLLh6PzZ8/cyOi3VHtBM4O0D8IUkkS/pP8PS9/nLf355c8ftnNLrfzDjAXoGmn870JF/W6wFdYck/3n/9PtYo8cbn6o7r5L/mLiq7lZ+sFSQRqrHA5nTDG9arVwDQjtZehbkl9vi04Y/JTZ4zHSocyIrCTYAbovbkLZr4vlolipN7CbGUQMd2MCYwH7j/VOX5o+NF4Ln5ocLucnZyhctS64r6kpO3AVvH7JwF4MjKiBEYAzR5fsaJGr0qkyxULFP6+f/9PwrWru/RdlKRTJSA6vdA4MeHLGxscO7jXKS3GBI4+ftJZYLmiSb1T7vqqpEGTXSqmxOeKuTtzbdrfyt7YRWymumLeBs73ps4YcJIpTxnpOemNT8c8Da37bwKHRBmlSvKynPQE0MFW7IKHty5bAxxq7hROOtk8IqJB2m2TCCd0XDzqMahejMpNwPkZ69Kql3kLLUW0RuNCVNog2r/s/z9cOKrxA7FD23uGD3fd32XQBQ/FDv3bQ7FJL9Y0vj4IxA256ewLW/Q2Lieh7Nhnmd5Ea6271YVNyx8sHjCIXqki88qOZaxe0K7iXF9+2dWqslyE7kjQk2CsegFQqfRgC+a1aL6IntJLjoj0ObDnq5nHC4sN0Kuq5wLAWvtRwOfvi0irwTcOc4Gcb6JtZc2gLSvXolqc82bO2e4GEY3cDSJ3Agy/dcgEvy9QuuDRud6w57c6AHQNgGJygG/luagPPFszC1RYWiq2VuPCjytIb64yDaGcCKw2FBYdfwuR5o7yBsLChJQpdTFIwsIYe8AY/V4zap5u/GRcfEfoMvaWzwUO+Nwl323ZpuocUf0lQJTbnQwcRmSDIzKwpiEC8cBHNXk2RvaesBck1/rNqasAnj7USMwUU3jkKjWubb3G3LojXHtFWGOzUAZmZc1rWhTTtKM1zmtiZYAKg0tcR3Mz1qQP6Nmz/UM9xl5bJPCW2DrkrZwiXNb+bkl2Wp2ElmrCkpyFvUF+WWrMNcP6j90jQoZa+4qge0YmpuwCFJFXLXXch9UcDIlL1qYNalHUeNPynIWth+YMGgg0aOg0m6fCNEH+tnRd2jOZ2YvKhdJEaWVNzWERsOehJ8jOIl2+qw26234WOOZYZ5ui8QqXlLFB1heeuCETp3Uecoknfvg5ovJI7IguOy8c2KE8x8KW+nsW7T/gswFbvgaNG/Io0MIpNifezl3OrRXJupKTxd+zZ7uHUemuEOSckKBxoU4Yl7yQj1an4D7p+jsPPxtoiwk8XZC9W1G1R4uOVfLyPBg75FcbP8y98siBwsuBI+fGn5uEkB4ijzoxF1hEUvfn7xtgA5bW3c49BGCEXl/vPbCjtLikP+ExQjFLART/eiChRtn4MwBHmb19y3n7a+sjaE+Q+QidgBGmDjwjgyb/9riiL6MMVJFnvs0au3dvv7VHj/anrC3yQ8RPxsV3BBFRi36AlcurtnnnzQhbC34mvBwaDF30enzlyjHAxcCHau0KVa0t7yIeqNUKl6BL9TshlfKox2SuTVuZuTZtmUK8qlYzLnakPhOpcKtRe09d5jy4+4gXIVAa4X5Q0I93HDlr6rABY3ZQGDFARD/A2DdycwuuArDWzES42ps28wxVHclYIzwfkig/JRgrj4C+UFZBo/CyQm+FBWV9rPIq6KiTKVIGx8s6VcYaWAgUB6y8htXLgHmJiYmlB/YcflVUfiuqjRB9Zc6cOU5OTo5boakTqMW4MNIG6Pa77mNiAMTQT+Bp43K6BtTfwbR2xgEmLu7LfjXOUQusyu8Qed36A/uBj1p1Pk9jh3dp/fxttzUM0VB3PLxtb4Pirw5NAngwNulqVZlq1LnYU5D5zYkLoIPKyLoA5sxRZ8O6j64BeguyHqD7xNsOAfus9Vdj51TIR+ofnrUm0Af42LN5xb6P1xesLC7yfVUxj+L+DkPPF+SvpSX+fzc6u9FZQD5GLxYrH4adUHWuqk489nURF3Rv6wuuTbr4jpVuIMwLx31dklojxPnFvQSgR8rtO4DiQPSBhKp9zxi2Zb0XhoyLStw00At0hVqeAiJRW6txsTh7ceel2YteMzizgPzu46Ys/TZL9Hr3tykrJf6/gp+Mi+8U5h0Ml4aY7wDIT53xMxF5Km/uzGo3yxKn9JrTvYJ7k5IOIfKkwOPAeKOaCqxRkZreUkCki6puqbEdCIhNUyT5dEidV0RW1ryTypoPzenfCUi08BaqD8mxyGphkWNE/BylMGHtZ+FvslUQirevMsLtFnm3LP6enJzsN479C9DOqv8OCKkiKqskoKddSyAoC669BTUNDjl3n8ocmdkLk4ChEHii/GBhxH8QDqk65cbFI9uW71HIMrhP/r3TQI5CC0H/129MksCFItyp2PcheP2G9x/zb4oip1pwtbqgcdvDvsMtATni+GoJi9g2gNPweHEfAFXtLyJZns2ZOx/dvvoTT2amH1hkNJASbryn06CeVRVfy/CHC0c1BgYZ0V5gRreJP/du45IOxu0ivtu5dwdcEb2Ar/xHj6erZZinc9LPBF4wKld5tmdWMljPOvzpgMaH9r+Znzpr9sa058+Pj//IcXxf3Y3yRbeUKRUqHmSDu6hlQdW1OKL5QL0fyAp9kKDxUniw8MNtSz+qWJ0hjktfBBYm/aL3b1wRrohLH//FvSg9CDjzws1n3K504NzCg0dpGXduZEhJOI7S0nSgvwfM/R2Gnv9g3LCBAK6AjgLyyqpCREQV2SBiTllevL7w1JD4KaVF5d9vhZ5WyY02pc8iHGwYEx02jOJRj8lcl3a3SwK5iP7yaJOET60TuKqil3bJuoX1NmRVA+0CAfOdsWV+F/jJuPgOUdpKlqA02Nj3nCEAHy2c3VpUXgR2G0Mld7R6PEZETyY7fEoobtLkaaAR0DTq6NF0EVkp0O2JnJyaYvvdxHFq9Vwc3HNkPeA7u6hJjeGVU4E/MuK9xdmLy8WUVqz4oJo3R9QkAptG9Bs7I7n/uD8lJycXA+TMnR2dP3/mRxvnzZwhqvcI8kxVMaiTYLlChBqtVK48tHfKVwJ7SuzX5cmgKvIXUbktZ+7s6OrTfAuobxSwRa1zHXDP4nWLaxVbWr4htUVGTvqQsuu0cNXCZmrkKUSeS+434fOyfsnJycUoL8kx17IqU7wsojdQgROnorBU+fgBKfsRuWR4v3Evjk4cfTggeiVQVBppKmkbJCcnFxvYr4aOLrdtCRwtS5oNu13kPABrtL+n3fAmQOdSW5pdqZPIAkXCqrQGxDVOA+GNsAYRvpEoez1bV2yfvm1ZRr9fDW8GfLo1fVNBo9aNb4+IcvVT2OBq3PBPkS3OaiIRrtcRrvFsX14pV2HFijmxbl+x2xfRsFSs7aqlxtO1a1e/HNlVAvLPig8mUebFTw7D+WHcm4Am93cYWo0ZslZY7aPKBgAr8p9dy7aePy1u6HUAD8UleYCEUom4vVPKXUdAC0ykuQ/ITrj45rAGnWdzZqFCZvGR4sPGkXabFs1oA8QUSsSHQINA52F9HBcfitq/ASLGjAKplAQtov9W1LN54fPfWcJ6/rwZTRFuzUud2St/3oymAm2dgCuvU8pdR1C9u33yDcXhxg3LGXipKr8JiCYLlJS4j3boOe6O8jDT3Jy50Q5S75cGt9vuBPOfb7OnHxp+Mi6+QyQmTikFPkDs5avm/LWBP6CvKLIC5AbgFxUfTPmJrboCCTlzZ59d44SnCE98vA/VB4DMu1JSSu4ZMmQf8IUeP169BC8nJxq4AGtr9VyE3uzTCaoanhZkrksbDzrckcA0gIyMDFdpRNSiqg9YVfpAZSpoADfEgbZVCACHTUzg5fqcX0WyBHaPTBy3oVobrC22J/SMuqdMSVP4NMIEbqja91tBdayILkoeMHqNwEuOBt7LyM1oEq5r5rq0tIDf+VKs/aA0ImpH5tq0eyNdkoPy2fGAvxp5my8ST5khVgan4bH3gNaeLoPLPVkBJ+Kf4XIcRvQdU+4FGtl33ForOmZsj7HVhASBnSgdrQZaQW35FqGETtgC9LcNtC/Ip49uX10pkdjvKlkI9PTEDz+n+gw6WFXuLNOhqNSiOl44UUpqjA5CZPXuVTuXW1+A2JHdrjDKhqvvuWeZDVjfeaMTn5i+NasamVZUSfEV1rj0WMNmbQKRMXch/HLTvFlDsSU9wFYqXyxR+SDcPj2bMwtRdjumfkmdItJHNLAegp4m1E5GdcZDsUPeUuUWE2D0Ca4J4wXGo1q7t051bnFh8X7QCwnQBSi44emnv0ElV8R+CFoInD+t89DJqjrKqK1kXHRPmfqiov8IBGRR3tyZJw2pnQmIyGjA5SjXGbQn8HmZQZWQMvWVGgcqfwD9fyP7jlsL7FS1lVRhowMRA1SpN0FgfHz7z3v1alv/SqAfMH4yLr5jCLwrKlc2jInaDNrKL75bElKmZKF8FWlsOc+AIRimiHT8dUoA9aa+2CZ/3swX6rqOPwwe/LaKPFzh0CoTJsYaefx4F6DoD4MHVyelqgZJE2HMyfudHKoqqvqowAzgsmWr07toTMl9QH+jgUp5EyIkglYzLsSxXUA+6j5x6p3dJ0wdWDWh7WQ4EP3NOghf6y7CWreJvOrE/6LAU6j8T8i1/K2hqiLIGGudRQBfFhz+LcIeKfXNT/OmxVTvTw9FRg3vN7a5ik4BuRrh1WV9V1+cMiDlSNX+4QwBz/r1xwRdoNZcAvBg5yE9BC6Ki/3ipBwYoRt0OOxEtKNqkECr1klE24C8B/TDBvqp2uyqXR7blP0FSG4gEKhE+uUBI8Ig4JC7NKJabo3CONUKPBUqA9XaVVbtxi2LN+9t3+/CXlFNojaJiDouJ73DlaNuW7o27bFqVVBWRwTcEZ8CB74+69yWKP9SI++LE/1p94m3VeJfKBP6CgdF83HC512UCY9V3Nu0uKSxwAUmcEJm3rNtxUJUb1VkkMUO9+zMOsFFIzZYRaJOWAOnDI6beaVFJdsU6WDV6QISfJEwuhooMf7AZcB0RJ8Fmh0+FqgmqtM9Zer9IpJtDE/Wdq4zBRVSgFzglxbpB5RrgtSUiB5Kku7o9pWU3Te3C6aScWEMSUD7tJVp9cqnys/fE+f17rny5D1/PPjJuPiOESWl6QqFiPz1YPQXib1T7voqGLfkFZUToRElVI6nTrUyr5DIVjny589OEPWvRrh2R+ozdUr6ExG9d/DgcstaYaXCb5/IyvrTI8uWlbtqDXSllkqRiih1sUiVXvX9IYZDsIxRWh81vrsRecU69iVBfg9cI3DNsrVp50PoJqz0EnFyADalzixPTBXoItSeK1IbJsdP9h2z/rD8FQEl22/9F1Q0JIKlbDTblDq7RrXFjQtm1PlNdfn6xd0UmkUFYpZDyDtUGHGlKk5kify+Yt9QbkorMW4vwIi+4z4Y3m9MfHLfsX/0SL1CQViV95UgKZoRuRo4KnBK+R4ASNBzYYy0UqnZcxHyjpyjYt8HzgO5BJFqxkVwSrvQQGUvWZfhXYEYI3qNwq2ejsPblDU9GDc0ATj7WIMGmVCu+NkfcVaDbtqdta21r8jnDL9jTDzA8v7ZF6maGwyM9ZdWDrM4fl+C34nYCCwWsaMcNX8EbaAx59UY7qnhwngJybJXRct2Te4r+9sTOzjRxg7dh/K2wN89u1ZVuobTt6/4ZzG26yPbVlbKNRJrvKDbu0+aUqusvWfzin3umMg3gfYidFUJeSkDLDE28DPPrlVfft7w2N+Bb1RYEU4wTETUH5BpwGWb585uW9crcDqgHo9BGWeVexWOIfJrrYPgmGP4g8LMIUMuPgqgsF2RSsaFaFCxNdJNzTlpYWCtOdtaOS2CkT8U/GRcfMfolHJXSQMpjalyCj0AACAASURBVOueMvW55GSPv7zBuF5FGVKuzif0VyQPKrPf5c2bOdaxbPamzrpWVcU7b8Z1oMslSGJz7JhG9jyVdd0zePDTKnIZIgkux/mw7KGpIiOAamGBcBjTe8ynRtgU4ZZv5b2YM2eOI8h0UR6blDjpmFF9DOit6JMhyuj5VoMP12ZtG8YiuGKk6ab8ubMGWmXRR/OfuwDAqnbRsrewU0S4N36ABv5GuWDJyFlYfjMKZu3rK6BhCd6882Yk2YBcW9dzWxsYA2QNGjSo/GaenJxcjMhzilbyJPgi3V1AD1SUID9VONaXCrT1xCZ1V+RKRO4E7TgtdljyKU1oZSeYjqrSCluz56Jz5/3nAE5hYeAjgmyRfRDCGhdqZY1q5Rt+wAaGAOs8W1dkqrLYOoGPp8Um6bTYpF2i+jKqWX/JX1QEsLFv63ggwlXUNNf4nc1WtfXmRRuLYpo3vHlzxvMNPeKxI/qPTgtYuVdEbyir1Ml9/6kmLg0090dELQ7mHujI+ElT9iHydCmR9UrAdoIlq9WMzYyctDhFpy1es7jVA52GdrGYBah98WiRv9Uft2XdHG6uJ7etPFr1mHEF8lWoUwJz7Ji+C4AorI4wod/M9B1Z8z07VuUBvLB+fakiD4jq4prm6DXp1h0IaQET+HVdznm6sLl/iz4oMTGmNBPlVaC1QWo1LpZmL5ygSpLgLy85FWS7oOW/51By+gAR8lXqZ1y43Q3yRJwZ9d3LDxk/GRffA3RKuasaA2KPlJv3I6ywpXLZ5oznGwLxonamouVhkTlz5jhG+Iuic0X528b5s7aLyBMq3JwwYeofRVgLekpkTiFPxtLi0tJLgZZPrFjxs8eysjoDVxqROrNPqvI2fLtE1BbtG18BNNRjES8CDOs39mNU7jjLnP04gDX6GKI3Llubdr7LMX0E8t2fr4vF6Dyg1I8ZDCDICRfvacagQYOOC+SboAu2HBY7W2HShg+eraa1IiL/KyLlFQIZ6xaOWrpuQWzNZ5HLQeZXO+x2zxPolJGTFndi7pr5PeoLz87sIwiLA/AUaPQhf8ybIjpLsb87lfnEkZ2KXgh6jkjN7JxGnTbAwaf2rz4uSjYQcBxnfbi+/khfDtCuokaHgcEiugLAwblBRRNVNBHV3wlkYaiQc2MHKayPnzzZ59mZuR/45hPvx2uAz/xFUi7INqL/6HSQQw0Oua4AMJENkgLiaKk7arlj7BJFemTkZJy9tbDZ/X2SksKutWZoPtDpN20GVqJRl4BeA7goLvqVMboI5KXp21f8sZ4S43Rd89VuRd6oS98eY68tAr5A6KiB8L+Zh7ctf9u4XK/WPpP+FeSmnPTZp4X4rS5Qa1IQWdwp5a4SMeZVQAMEajQulq1Z1ElEXge5rWKSs0W3A+XGRcvCRn2AYlX5B1o/4yI+vmVhz57nhyUd/LHiJ+Pi+wzVd0TkCi2iL/Cl3/jfB2m35b3nmgN0ifn6ZqBBtPivQ20fMbwV8BV36ZFy6zsAimYLWq8fQVV4ggl+T4nINAP3qMic3w8eXGemuoA6M4GeS9amDYJgtnXV+HE4pOekt83IyHCpqqDcD/LnismGyf3H/D0xMbEUYGTiuA2KvKnwuir9UV0vwgLQpxReFWRwTs5sN9DR4j8jxgWA22nUvOrbc88Jd2wHlrtc7qkVj+fNf64zMAm0QvmhuUzUrFmanV4tCTZkdPTxlWo1Ip7kXsnfKCwlwAnvhSVO5TQaUirvC4wQlbef3bmgpFTkGYHkabFD102LGxrWM+OJH37OtNihv5zWeUglwaYjFO8CIoE+tYVFxJE2wCfB07MW2OzZnBk2TyaYd8H+SErLPXsKQzQgKwA82zMPPLx1xfqHt65YP337ivf/uC3rN9O3rii/loIOMsiqClNuwtoNwEwJ6UtAqNRSZRZqpwBYmORzNzAaE7VlaOK4zwS2S6A0KT4+3imT264rPNtX7AGONo4+Efr0qMeoyDWCfqhwE1Ayfdvye+szb/naPR7bM2Vqbj2G7AYI+I/X9D1Sz+bMz2toA6B7ym3LgB3uEvtgbf1OJxQdj9oFAAkpU3ahLOix7kA1bhEIqiZbo++j8npyvzGvVGwzJmI70KKs/N3iJKmSpUbXAH096qnz89Pr3TMgL6/gv3YNvg/4ybj4HsNB3wX6WXEuA8nunXLXV8DH/khX75z02Y0V/aNY7u6UcldJ94m37U5ImfpAr0t+802FKdacqueiIopdrheACxC5RlT/VJ+xo/qPOijwkoHfLV6zuFVDG5l5druzahSHU1VZujbtNpe1WyXGl525btH9wNmR/oa1JqeWRuqdKrQAucVVemwfcE4D8f/ZBHNHhkR+7u8I2EPRB2oVOPo2cBFdDFJNoEuNPIHq/+TPn/lWWfa8YH4DZAKtyyuA1PYHFgr2nYzstBsrzmGsXAssHDt4bPiHscq7yInQSNBzIafFcwFQGtAPgYANJbQ+tiXrM1+Enofwd1T/9GBsUiXSNU/HpK7WH/gE9G5E7nqgy9ByOvlQ6emnQCzUTP2NShuE/QDGkF1TSKQcIjkBNDF4/uFtgLa+KF1V6xiCMXpFxgDp5VPBJlXZEPAVvwXEbpo7qzwXwhewryDSJ2Ptop4GGeF3R36VHJ9cGBq3wYrtFVwODU927qpLUci2xpQbqEPXDUoGbaAm8kYT6W7bNL7dRuCk+U6nAxrUQPmsyj2l3hCjvzLCdRvnzzyjopBb3nuuef78mW8g0tEfCJTzeDhG7q6p5FxiihOANo2cZr+t2pacmHxA4OvSBu7OAGIYqsjy4saBPCBqSHa/uKpjaoKqcakSVf9d/XDxk3HxPUb8hNs/B1aC3iIQyryXDYr2cfvsdCA/YdLUGt+O3MV2LUi7bysB7hkw4IiqPiMi798zZEi9BaQCLv9fgRSXCawFPSjIb5esWRQ2DyNjXfpLAvepyOUqkg48BPqXinkG4TC2x9giI+bngD/q+NEiYGenlLtKApaVQDeMGQjsqJTXcppxtPTAMKDbkpzUDhWP9xh/6xJx264gEUbYmj9v5nRBrlPMfcBnUeJPmJszNxokwZrAA6J6EcKzZd6esrdXFa3RBe24/R+AJFQoy43DnJ6wCMDjO7O+Av37w9uXZZUde2LjikPTty6fLfCyQCXPjLq4UYQ507dl9QRWGdVxlWeUHYDYWhRRBW0jyscAm7ec48XKktrWqJa1EqIKD7jsUGBjTcJiFZHft3VfIMYUNSvn+LCqG63154QerB9aY68F2Jg6u8PZB/caVZ5zrP91o7a9LzK63OWukCtIr/j4eF+PHu1Gn+zc1TfBalQHVvj/OuCt5MTkA4fydx9ud8mwU2ZlPQXsJlgG/K2QMP62fIMdrXBXfurM9fnzZ87KW/hcnZVu61ptVRrpbAA5y2VMQu+L7/y07Hh8yq3V1JvLIRIHbCnzglY7N2w3qp1DOjmDjQSyUjqllAh4HeOqM5lWz54XrOjVq93/GdEy+Mm4+P5DeAdwiwbWBA/Y9cBVAjer0TtqG9rl0jsOCuy0Tum3Co0ARDrOM6r6x1MZG9Qa4R2rvLWs7+oJgt5pjL6+ZNWSSjXwGbkZTQS9GsOoEX3HpCb3HXOPYAf5ImVWXc4zLHH0RhGdEuk73lDRjwB6Tpr6CbDPKr/idIYJwqBZRGcHYbkJmGqU7gljb/+4+4RbL7FwOcIVQE6PCVOyQTaqmISGRPUG/WZEn/G7hw8Yl4HqHw3MWbxu8YXD1w2cIBBT3MSGZVWEIJEXQpajgcmhZMMLHVtzZcycOXMcb+qsSeUJw3WAKXGFpUoXeBm4NERyhWf4cJcqV4qVfwIosliVKhUzdieAiK3Rc6HKeRr0cPA2bwcO2ZhaSYjEkfVA79DgS6gl2bDy+nUiSlolcitrVj+yc9VuAFF9DeSqjamzfq5q10eKXn+W0/x+t68wyu+KQB13eYKzIrlAT1WVnJyC1lXPFTQia1mLIRuCBlKaNy1GRC+1wmu/6z4m5pMlGxo37timT31Km+vjuq++GNl9unKU4ifcnodqX6zOBhIcv1NnIqpN82adVKMo5BE8X13RP+86bko15dYaYYmD6vIAZRBhu6p0TsoeNApwtCgqF8AK2dQjqXPPnj1Rmzd/HJYp9seKn4yL7zlcxrwLlLoCUUHeBmE9kKDo0z3G3xZW7bMiFMlG+Nahkd8OGvT1qXgtyuCLZMqI/mN/7xGPHd5v3MtAtnH7b6rYR/wlk4CtyYljy3/sw/uNX1cDERNQWT8AYHjfcf8EGyeYCm8rskJgMNRO/PVtIaL/VuUdJKgXs2TVkvMysxddUtY+Z/OciMMtL/zoSONz+wUMoSoRu0mVbthAf1FZW1biO7zf2CeBDY4Gdil8CLyZ0imlVulzlNmo3Br1tYkDfBn9Vu8N1y0/deYdcTEHC0T1Qy2VOn83KmlpVDy+LSsfyA1EBq4H4DObAvjZvjzIISF2gcDIOzuOP/HWrewEcBcHaibREs4HLRekOpn0e0mJey3QZlpc0liBFON2/aW2/ieWwkRFKxluD+9cnkso/HAg5ss0QNTq31HmqehNffr08ccUHdrqi4guEWz578KqyQParPYuPdft5rWq52pkI/8ZjpOkfA++yDXAefd3GHq+2ycjga9G9h23tqGvePA3H+35TBxpujw7/aTMl6oqS9el/Wr4uoHpJ+tbExx01+n8zXSfeNvu7hNve0GRh9VwcZ2NJKM35M6dVaNKM4AR7aKwL5SIWneIqTXxWS3bgSRj9BWFB5KTk/0AomSHwph1wuHDJtHnC/xvvdb2A8dPxsX3HF3HTflM4MW4i288CiCl7g3APlwNH63TBKLZBrk8P3XWE/mpM8N6OnakPnNW/rwZTas+qE8nqhoICukCgyofk0sRqjEg1gYJFL1RNeyjSFeFcuNCYCWA2jPruRDR9dY67wK9Fq9J7Wrc/g9U9N8Z6xYMT92RGtmysPH7FvaVRkQd+ab5hQuWZi+8Voz5CCFBMP2saPaJuUQbmeaXuUpKm7lKSpsdaxqoFhOuhqKIdxF1jMjvgW3h+Cy882Z2Q/kLwj0C74Lpcjr2rsrLotzk6Ti8TQC9BuQNT0jzwdm6Ihc43lyKym/GatgJlAwZMqG2eP65RkydM+z/tHvxYWA3ymyBN06WbAiwMe358wVNCBh/ak19kpM9flWZLth+6o6ZArTOXzArGauDUXlI1Wws6xvKMdp3/DjdVbVSyXZ6TnpjRS+OKKk5bym4B93udtNXrKYIpAJY1SG2tDQL2BwwwZyOmrA4e3HzzHWL0kR5FBgSrgJp6dqFJw1LGGN2n9ak4BCixZeB0tA7b9ZJ9Udycma7FRnuMoysrZ+IdJUKv/l6IE5rCR8Ksh0YpqqZI/qNLS9TtS7/CpDuqWtSq1Hh17C+b0TCqOH+iPGTcfEDgHVRHo5IuPjmL6wxv6yrhS7WLlGRPKx2QOXhsreFvLkz++XPn7ksP3XmgePqPozI1xIoqtHtfrohKqtQBpRVjqR502JEGWPEvFfXOfJTZ/4S5SJcgXLvQHB/2sWYE2+TiqwEcPTMGhc9e7b77agBo74AyXIZJwOrxxH5NWreb3DIzFdDK18prazf1UaFpwR58JuzzrkFpZsq/U/k1QSRmJhYmpQ08VBS0sRDJ/VaEBRRE5ihcCWEv2GK4VFFX+6eMvVfiuaJ0dNiXDhu501Ev7ZOYI/AJUbNK2VtHrAiLLamAlurZSfwZS1kbAKch19rldIOgxygjbicOiUe24CZCJQlS9eIHhNvnZEw8fYtPcZeW6ToG6I8j2hg7wHz1+R+YyqVOaqSa0xp95492/+h4nEnwADgG0FuCLFBhoWorEFkAMIEGxQSRCHJIlmibBAxtbL0OgReAgio001F0gXzi4rtGWsXXS3Ii7XNAdBl7C2fu4z7pORT9UWnlLtKFF0gRk8a7nB9RX+gkQo1Xi8Ai3ahhu98TcjIyHCBdqwtLGKx24FNpVFSiU9kZO8Je1HZH+04talHl6NHj7abevZs94/6rO+Hjp+Mix8AeoydWsl13HP8lBV1HZsw8fYt3VNunazumOtBG22cP7M9gBEZB/iN2PHqopVYklF6nS6q6pOhkdPMC7jOvuCsbgBun44D3T8scfTGkwwFYEPqMy1EeRpYrugVZcfzFs66ACSqYVSD7WXHEtZ9thnh4JHjx7aHnew0ITd3z3AARd8Gin1+uSy575jZij4L0thVXDp67OCxX44cNPKTEX3HvnBcA30CrqjWGIlxrK9tiZ+a6LLrDDURLwLFGoaJdFPqzMGojnQ7zvTgOmWLKqfFuPBsziycvm3FUF+EtkTtpKqqoRbSQMuNC2kYuYsw1N/3JAxpOi126C89HQa1ACLBVy/jQkVygDc9mzPDlh6GSpLLIcokYG59ziHK34E4lEVl6riVYMhFpFc1iW0JDFbVRVblQSO8lLE5o7yaZOmatBMltEbWNOpw3kigeVTgrKV3dhwfKdDfCbBcjWxAtUbjInNt2lSEPgF1rhzVf9RBlDdRyo2LpWvS+gg6G+h7srduEdH4cTd9XVufU4bKfwS5+GTdxNpRCntFNblMPXpH6jPV1i1Il7I8q7oiEB24UEHOkhY1VpAVOaU7jJVLw4VmFZZriLHzZMjJ+fRsr3ffTwydP+HHh5CnY7tgegKoaF9RWdBt/O3reoyd+mWUU7oaiM6bN/u/omSYmJhYqrDOiAwCMGomW6TOIRGXdT9lYY2LwLXAUG/azJYADtIVdFdF1UPxeCyWfwcZM88kzB8BBP97ilxcVjaa3HfsQ8REJCclTaxUuZAyIOUIRm60xiWOv+SzcYPGfesbeZCRU/9FmLc4a/mjiDxdlvDmCrq8Y+vCO1JXPLFxxaHp21cuqHo84PItALo/EDs4FiA5PrkQwVulm0T45GXQ163beRs46tmZHZYRtSY4AdaqYx+vqT3y88DPvQtmxEL5Q2oEtn5qld0n3rZekTyBavuEYFKnIL1UzYNL1y4aWcbmaZDBYszK5f1WPS3CESnyXQPBpEsxvFSmXKvWrmnStV2CWM0cNGjQ8aauo2OAA56dWVvEBjZQlrRaBUs2zL9AlScRe82o/qMOArh9xz8ALli2Lr1XxuoF7cTwPvAIKp80EKfGB2PViqfTjdJIswDoGOJ7qQ2jJEgU2OCjvi26AxxX998+Wji7arJsF6eeIRxjbBzCzpoqRSBYNj1swJgd4doEXSbUzbhwuUrjrLU/aYv8hB8tclUI1uBDvxAxEVDOErrJiFbTLjlTUFilMGjZmkWdFL3YsVInldJVc/7aAGGyS+QPXSfcsVdgg/iD2hcSoCuVkjmDEEdP6gb+thCxbwAk95vweUVXuYhoGQ9CVQzvOzbdGmeP23e8Vrd8fWCM84xjnEo32g0fPHsuwjCL60TlTWGznYDTpeGhdqfr3DXhsU3ZXwi87WD+p+yYQiUOimlxQ38L9FbRRKxEAPUNieDZsTzr4Y9W1px4LDJQVO4FOGbdKcCek2lthJ9HX7Au0sI1Oaq5Fu14xPexgi5q8LXrmoyMDJdCf5SVHvFYC88r3AYwbN3AK4AefndEN4Ct21tvOrtXRz2QtyNYTqlyhQhvA3rU8XuBJks2zL+g2nn9zgiEjcl9x2eWHQvpZKRa1b/imDyBucP6jnlC0CVK+FDD0nWLLhLrqlY2mbF+Yceq/CunisTRUw4rLBKcq2rqsyP1mbME+glmAZAVwBmxef7zPYFrS/2Bci9YiFSwpVMcqN/naL8di61RWQ4knqwCCEDV7hfR5ad6rh8ifjIu/g9BVHKBXiGtjeZOdKBSwpmiGzD/PeNClFUCg6yx9wFv1/SGUBXRjWL6CBzuOn5K8AGq8jbKFcE/6Sqi1R4uCeNvyz+daw+Hnj3bzz6Vcaa05F+RvuOnLRw1LHH0xqF9Rm2qeMztuC9TyO6RcnP5AztUerkLtaclNHIyWNGnFa69N25kc0/s4HPz//RG1zLpdk/c0DGoTjfGTn5464r1nzcqGgp6KqRLtRJMKfRD+WX+vBkXIvozoF5eizKUtjR/rxquLMOwfmM/FvRrvx5rKchTiP6vbVjSWyDwVcE3GwEkOuIN4PzMNQuTAY+AzxqTAHBLzi0NG3c417Xr7czOnnbDo4CLRezbUE5AtsUpdVfzXqhKf9DqoTXhTdCeit4yvN/Y20VELbrEhEmSzMnJcYvqk4JOrOjRysxeMJAAq0X0olO5XuEgRmYK3LJ5zpyIcO3HiBgGuj8hZcouhaWojgxgngS+EZFyFltfhOkKfNHl0jsO1m8BxGk98zQqYtiAMTsUDkYHIk5acdWrV/uCnj3bhzVGf6z4ybj4PwRrdAOivfxq+gFbqkmOi6wXlTpJup8OBHBWK7QX5CoV+0hdx4kNDFQkuywZ0O/oOwjD8ufPuEGhl2r9Yq+nC15vwSlpbWB1llh/bOit7LSgaqKkil4O8nb1jmwJJcOdcTy8dcV6hBy3+p6yOGu/2bTn+i5xn3/wYOzQyVb1PRW52bNl5RoICmNN37ai+nq/BfZkvBxFUBjMK8JDgqQo9QuJlCExcUqNrnQA1PW7Ru4Or0f6Gz4INHdUHld0dVmORnJ8ciEq/8TI60CkhVeBbsD/b+/O46Oszj2A/57zzkwWCMgugkAQEAhZCQQQlCAQSEDcJvZ2sdSq7NZar7X12uZqb+2tt7ZWCeB+e9uqwaoICSBbFESWkJWEKErCIi6AC5CETN73PPePdwazL5BMInm+nw+fDzPvOed9ZjLnnTPv2aAsPdaycLLs2BdxlstcDOCrlAPvVZtJhGymesZdEOKIVZ1VTAOqQtJh6ehp42elfVuGtVUzxtTePv60PrWIwATA2Tv0sgkAsHXP29eD1GYwvcdMo5v9JjUhfPdnG8AoM7t8eUt9xwl6BpjstUq0sQWEmQCNA+gOAmb4xmAQMArU8sW+CDwS3PBgzmZ6VzWja2TfvqPDcnJKmhzAeimRxkUn4lDOXDD6E2EOuJ7Bg6yyAYrx16BOb7/wBwBemzZudpNrdlQzgZnf9z2Inr2olAgPgtUvCBxltHBgV2vRmuZeSL6ouYs+AeMfFqsLa5w0wds/PQlk1BnTQhoHqJWmozaL5r8A+D6Y/4RzahgYgQT+JwMLHy1+t1mbal2o0xUVUQCVG9B3MuhHIJyJSLz7ogfR1qdv1/4vO5UjYdKkSRUMfpqBabW7gSw2VzBwBYEfJeZsYnsTOwLFKoN2gyidiB4j2F0ivnzMlE1cc9yF99b8GMsw67yeSZMmVcRPnF1a/bn48UmfEVBkmur8zrbbt6/rQcBvALqfmdcr6BsAQIF/z8Bj0PpeEEJ37twZhFZAKSkahFRCA4sBMs0gwmYAiNj3aS6A0yB+zNOPMhhw5o3tF2snVKO4GY2Ed97fVPNzTo1PQ20OBt4F8Q2+cTUNMQx9ud0w6jykcdGJeEd+H2aQm4j21j5eVlaWD3DXoo2pbTqYqybeYWqreWt2eBFoIgzaVf258MRFf4qYs3AMoCJcZLXplNOG6QvfO4HV4yC4C9euGtSKAQEATMu6uXaXSLUTH4Cf7lwAwIEP+7+liKc/8uH2P6eUZn6tHF8mMuH6Rz/Y/ve2PrdiGg/w3rCkJbkA3iKNNY1Mhb0oo0ePNon0owCg2bEcQBkz1ZjlNX1CYhEDz3JZwP+xUgW+TexIcSyDsxSwEoBLs0qrno9YZ4MwOXPPhjXb9mx8LS0tzQixnGN9K7w2P0reokDnu0bMQOfjAHKmjk9Yq6DWMtMN27I2TWZgFJyup6dOmHUYwLlKx9lGdu5tGctz7kWAI/PXpdboji1Yt3wUgNBAqtoAeBsiTH8LCQr8a2zsgioQtnpnvIEUj1Jcd5xVde9mbeivDb1t8+7NvQBg897NQ5nRXZPRkh81dZBypQHkDP7SeH3btm0N7h3ytedIj7NVn8iuqOISRsgBEMSs6zQuvLMpirTV+Dz61qRAj0yfkNjsOw0561cMAdA3wOOs9xdnRNKCgvq2sPeH6OjQzAvNGzF3QTEI6ZbiBy42jrx1K77nW1jMnkVDS+rtEgGg2SgCWmc6anOsxmorpXhHpu9xSmGh59Hi7e80kqXVMGM8QLsBgEC/g9IX1CXSHESkIyKGvgvYd+iY8YwZWHfjtZOl3yyKj483LaL9AHq+m7WhPzHGKqK9KcXvbgIh/dEP36lRVysDKZuZfw/QBgDj+4R2dzNRjRVem0UZrwH4Xubu9RO37N44jRj/ZrG9LDe7nOsBXEVaPwnwC/HR8V97yz7ArFuta8Teu4VWE9GPqj+voW4GY8vwxHvOzxbyXE4PnJ8FxtgI4oTsNU9dwYwobmIlUa3VXwD0M0j/EAAUmz8kYOuM2BnfXEz88bHxJw2HNQ0KA9HF0+CAdEZZgsll/rtD2AFI46KzsVcNPOe53GhggCPtY8BvgzqvG59wtCXplb0QUaFvxdKOJCen9KJmpGhlPQzwT/PTV4U3nbphRLifHVZxwbqV9ysTOwDkBpOn/v1ZXEEfAAjJXvPUFRdzzu8Com9nSIUnLcwaM3vxBS+N3ZSsrCxnTk5p6vlzd3X9pr61EnxjMGbEzvgGTEe0paYyEFrpwT4AbDo8dWZnJEQmlMXHzfrvqeMTVoD4CTAeBCOOVcvWSYmPnbGDGfeB1DoFeoHBv5keN/1DAIiPjv8a4HcZiFRMT55/HYQiUq037gIAmPkNDdxYvTuWFG4mUI0F9aqPc7EUNgIY73A4igC8Y3ThGncyq9u69+1EZk5k8KMA/5SZiUDzmblZs9Oacm1M4gnW9FMASQ3t5UIwxgYY3S5qA8nvGmlcdDLEyAGQ2/CANL0PQKw/Y2oRwkQQNXghaV/U1Jz9RkXNWlpIwCpAP8XMlJ++cl5e+op6B7s1xDvCfzTAjzDpuzTxmvDEhT9o6G6Od/2TI4bLeUn/SqmlRAAAIABJREFUqirc8FxPBoapKuP8F3BbdYkAQFBQECmF8/thNDQVuQbiAiieD6YjvjVSfr9/d8Nb0gNAcMBzBFwJwjwwN74lfT3i4xKeZ+BxEH96ovT0X2oeVWvBeOO6uIQS3zOsuQiMVm1clJWf20Tg3vnrnokGgLy3ng0FI6KSaU1DeaJnLyoFsJOY7ohIWnRbncHpXmlpaQYxL4fih12eysfBCM3cs/EBAD0CrW4N7ijdUie6fp0PwBW/65qGuoyGKAqsu+DaJUwaF51MlWXlMBr+haOJdgIct21bisOfcTUXARNRbTBnRxIUVDHnYsswPedSAIwuyFj5EcCvE5Dckvyjgk+MAGAYZb2WF5f1Hh2ZuPjfm/4S5WJi/427aGv1DUiuMqvGATgcPu+uxr+sW0lYWJjH4Qi+qemU32KgQDOmgziruXniw+LPavByAA6LHXW6OptVxviEP1SanFR7tVHF/BZY/almaioEWta4eCdrU6N34iYl31cBoreJ9I0AQIZ1E4O2x85dcLKxfOF7P48Pn7Ow0e0Ceg4KCQPQL4R6L588ed4ZAtJA9DsQvTJp0qRWW1QvOSzZA1A+O6w6P8x27twZpKH7VlR+dUG7Sn9XSeOik4mZt+w4MTe43PGHZ3vlA2T1Oden0c2R2kPxmudDAEQRqe3tHUt9Ro4cedFdNdE3/fxrEH4O4FlicsO7/XazkQoHUByWnOypd2nq+jMdANPIlsbaER3M+GtAwYZVs2s/rxTGo5FGdVsIC+vb9N2K6pj3k31NbnbjAgAcDv0UEQp8q3JeiPpWh70uLqEkfsKMGncJLWUUAbiqqdkR1WmtEzbvymi0QcKgN0G4KXftigEEXkjETe4xtHHmhMuaSmOQGgcg27cKp0V4HoBDQ7dKl0h1DM5irtulXOUqG0aA552J77Tp9gMdjTQuOqHwpEVbGjqWnJxsEeF9rdVkf8bUHB5X1RQGjocnLuiQuwvm5BxulYGJEYmL/hGRtOgPyuHIBDC49q6vjSJEANSyBcOYi/05Y6QtnWPnDGYdX/t5Zg4DU8Mrd7aywsJCV15eaYvGdBiGYe+r04I7F4C3z5/UkpbkuVA7YneUEuBxnaKWzBgZo5QxvbEErnNmOoCRSiGbgayzZyue37YrY2BjS9MHOOitzXs3D22sXCKMB3D+js714xN2grD6+nGzWr+hScgCqM6dC4utEQR1fF7u/Edb/ZwdmDQuOqGmbpMz8B6DO1zjgi2eRsC29o6jIUR8vDXLC5t155dgfAyH2fz58cwRDN2ixgUDB+DHGSNtiQm3glWdX49ENJwJzVoBtjVUVFQwMz5tSZ7Pg776AECl45y5r6Xni4+d0ezNDC9GCqVoAMWGoZrfNUIYQ8CMxpKMunnpKTDeYeInT10x5NeVoWOeIGV83Ce0e71dCVuzNsYBuMZgM7W+4z4MHkdMNRoSzspzrbKEeR2a9wGIqt0gUkwjiNRhpfBVAzkvSdK4EHWQhe0EmuyvxbSaiwjTCNja3nE0JCpqSOtvTETYY0+hbB4NimBu2Z0LS5nFAPrnvPHnJm8zd2SFaWkuMG4g1Nzdl5kJjOHE2m+3pWNjY6uioobc3pI8dr89MmpvcNfRMFDEzM1qXKSlpRneAaDXZWVlORtLezYo+Menel/VFVXqADF6gul7YNy7dfemhNppSfNCMF4jUPTW3Rvq3Z/EXuyLxrCj5rR7734rrY7KAwoBqD6h3Ws01Bk8QrO5OzJyyP+0xXk7KmlciDoqofYAuCwvY/nwJhP7SeGG53oCiLR0x21c5OUdarXFhXwYtIdU8xoXOW/8+TICBrkcqkWNi5jEe04QcFIFBIwEgLyMlbdWP16wcfmVLSmvKVlrV/VuzfJ8rK4nrwdQCXCX6gvBHdj4zOUAQoKU6bc7F8xMOTkft7j+ENDqYwHaQJ5iatZ09Z6De14FwAGCedY62eAeHJt3be5XGXL5FgVcT6ynTR0/87apcTPfAPP9RPr/MvdsXJW5e2P6tqxNk7dvX9cDoNu0wY9p5p8roj9v2LmhZ+0yKxxnogk4MzUmwS/dqPHx8SaAXLDdNeJbyZRAIwzlOJybe3SAP+LoKKRxIeqInbugHEC2QUaH6RrRpjkV4I+i5i7qsKvcaW0809plKrb2MmNcc+4iKWdAOIATvi3VW4S5mJhGMjMR6z8WZqwcbT/NpE3jreaM+9iZ9kSTy0JzSooKUNafmkp3QTTdCuLVAIq0Ns5/+ZkWDwfwWfUFmdpaUVGRUymj0Vv29eEyV73buHcoWu1gwjWNjYfwUVQ1BsCHADaDVL3jLrZvX9fDUNZGAhVymeuaqXGzz88Gi4+btZKIX2Qmj1b4GJZebwY4UwkouD52Vva0uFn/ZCAv0EGP1Tk3aByD97bllOM6mPYBfNu2PRs2eBxndqSlpRkMHuFU3YnZWuy3ODoAaVyIejHxDs20LD8j9T9z162oc1vyostvYZcLE6ZxB+4SAQAindnaZZ4pr8wBEJK7btWwplOrcAAXtPsrgw4AGFWYnjoVoFALfAsA7M9YNZbAUWyYTQ5G69Il+O6m0uSPvzyJQbe29lTnrKxVTijMA6vXwNjH/O3GXgw9AvDfeAsA+OKL0ZoZLd5i2/vrt0MLcfTYB8DRZ8hl56eYNtzlQWMA7GdgM4PrHXdhupwvAjj+RZev/62+1z913KxfxsfNXDZtXMI9IFoGwA3w+UXhLDaWMvCjLXs3jN+atTFu256N+7fuffsGgMc1Nu2+bXAWgClEKGSgZ+8h3X4LUG8FV65SvL/J7JcQaVyIehEbfwN4DTP6KqJX8tNXvpC1aVX31io/f/3KhXkb/9alOWntLyKeDVINznLpCKKiQi98b5EG2GsAoMAwuMmuESKOAPjCtpYnKibwKE3GHQCOgXELADDYDfBuEH60f+3KyIayH8z4awCBf9nUr1liXgYguG95nzH1Hc9PX3ltfvqK3Px1K57KW7fiofz0FW/np6/4OD99RX5eeupzDZUb8BnPBcMTvvezHSDORrUpgQQazmC/TgOMjyczKmrIJTk7IDY2toqA3cQ8BQC27to49rR10l1fWiK7cWFobAIwblPWphrXkIyDGQEgzFRK/dI75qRR8eNnvkRMbpfZ7RXfc9Pjpn8IwhNKqzTS2AbGDmL+O4AbFeruodSWLBjroFxDpo6b9QsmWgLQQwR8GRcT8X5kZOjL/oylvUnjQtQrImlBQWTSopTIpMWLmIxwAANcHr3T3qvi4hHjJrLK7mtO2l7l/X4Khnac7flWa5y7reTklNY7sOxiEWMXGFOakXQSQ7VoGuO3J9EHGBQD8M0EugPAqJy1K4cD7GbQ42BaqRU/0VD2SjhjAfQfEXSqwb5472ZU1wI4YDHV31givo6ASihygTiGmd5kRXdrxr8TKDE/PbXGe3zg9ad7FaSveJaJ/w+E31NKimbCPhCq7e5LI4j9e+ciLY2N3NyS2/x5Tn9iwrus7M8kKTxE1MBsEEY4GPuvi0soAaPUYdWcJhz0NU0EcPbasdOb/at+atzMN2ovgBVQFfJfUHySCPPi4xIWWlpPBnCCYfq1cTE9bvqp+Nj4kwAwbdzMDCL8i4EP8/KODczPP9Tk1uyXEmlciCZFJt51rLisZyIYRWRi84UMyCtMS3P5+uQ5JUUBGA/G/dkZf+3TaL5ty7sCSCHCQ2HJTf+yaV+0oI0KXg8gyfdlmZ++4ud56St25KevOJCfseIuAMhdu2IAgNFVmi5ovww2ncUABgD4ODxp4SYAWwzi34OpT1lZRQagHwEQvX/d8jprSACA1vbUZUPZu2xu25biyF+34pEa3V+klno3UNtA1MD200yTNeifEYkLF0QmLb4lcs7C1MjZC7dEzVm0kYFlBHqy+mfGDDBWMTDYUgiLSFz0NABUWUY+gJCC9BWhdpkYTkx+vXMRFlZkENGd/jynP2mN7WBM2bZ34xgANwJUp3Hh3SV0GBx2dwAB70JRjUGdzDQNhMyLHRcxadKkindi3x8/dVzCJgCYPmF2Ppyu6PjxSZ9dTLkXyyD+GRP2MltDLEu1evdyRyaNC9EsycnJllHe6wcAjgUY+qmW5jeDTy4OCQqaBQD5sf1GAwgAsMdg5380mq9c3Q/w4TGJC+vd1bNj4VVtUeqZsootAHrmrV8ZVZiW5gLwIIG2gXgTGHcBgGEgAUB2U0smNyQi+5PDAMqZ+QUAIKZ/gXArCGsnJd9XETFn8VcEek6TcU+9BZCaAuAQg6cDQO+yvgkgPFywftVjAJC3PvVqZtzOoKeZsYfrWXnU7lLhicS63jUbIpMW/UuD33Ww839Ltr0YmLtuRQID09iBH3r3mgBwfkDyAQBjOSVFgfgq7cc1LgCgsHC0xcwNduN815Ubnl0AeoHxDAEvE9Bn654NYTUSdakaSYDnnZhdhwCAFReQ5hpLgRNoGjS3ylgq7xoc59mbr7Wva2NnfeqqPPcQkVFqGHpje8fjT9K4EM0WlpzsAfPDzEgq2fZiYHPzFW54ricRPQzFNwIAiCcwsE9pup+Au/PXpda7yt7+9cvHEfDviugXfh3xfYGio4f8sy3K9Y672Kw0zdXBX85hoCJ872e/NWE+CiAqN/3pEcxIAOiCL16UkqIJ2G8p8x8A4N00ygRxmi+NqTgV4MS8t54NrZ7XeyfqGiL8F4BJO9OeCGLQfIDeBPNd+Rkr00hjH4CXIpMW7FZK7QUQVnvMzdVBX0UCwKkuX+Q1FGeVNhYA6HG6/Nxmg/AUM/1HZMKiL+q+IGQTqXG5cf0GAXB16xL40QW+NRckOZmsqKjQV/15Tn+aGzu3nIC9BIwl4EEGbydgVvU0zDoCwH7flz5ZyGPC+XE7GbsyugGIU9yxx1JdrMmT552JjBx4LCJiaIsH+H6XSeNCtEh40qJsBr48XVHZ6Ip71Vmm+TCA00yUtG1bioOYJoL4/TFzF+aB8DYIdcYqZK1d1Vtr9RqAR8ckLnqvNV9DW8nNLWmzjYlI01sgnsOEOwC8RCkpOibxnhMMbDTIuB3AdEW84WLOoYE/xiTecwIAYucuOMngt0KCgs6XGT17USkI6VBmjaWmC8deHg5opzrb6+8AvgrpEjQXhLnaMP+DoRLBPJKVmhcxZ9EyABgz++5DBHyFqrMxNQJQPAXArvj4lAZnTMTOXXDybFnFNAV8xoQzH5T3rPduEWlezeAlhsYCBo6Gxv/k3AW/MRdg2zZ25OaWPuzPc/qbZrzH4H9eNz7hKIG2ENO06seVQpjGt0uuV1pUCGCAvU4FEKTUJACfXzdhpl/vKrWH/PySkXl5Ja2/yF4HJo0L0SJExMT0BjGateNjztqVw0F8NymeBwB9yvpMAWEi2LttOiMTwDW187mUfo7BWeGJC/+7FcNvU8xqaluVrchKBxAD8EwnrG8XWmL8g5nvBUidCPq8xVtuVxeRWHOHSdZ0T+0vZbLwVyL6adbaVcG+57TBU8C0yx4TQ1sYeAJAftSspYWRSQt2RyQtioicvfD8r1MiYgb2KlVzUCcxTwZTk8tYT0q+r2LM3s+TGY55DW3OFj5ncToT7gfwINnrLPhV375FigiX9gA+RZkWOx4DAK3xNhOu821otq1wW1cw/VCRPr9cv3cb+c89Ac5wwDveogMv59+atFa9taZ6Z0hdqqRxIVqO8AaB5za2VkHxmudD8tJX/kwp3kTAS+GzF+cTczoTzQcw0jLN9wFAKb0DoInVpzAWrl01CEAia7rnu9Ad4qOU1eQ6DxcqLGnJZ9459Jmjk5Ye9j1fxeotgDSYNzf2i785ar/X9S1YFj53USaIy52G/nZgHmMKEbYDALPeDGAAM73U+Ml4LzPGMzOdb6gQJrPiZu2RQSkpOjLxrmONpYlMXLQC4IfJz2tcAMDo0aOrtL60F02Kj52xfnrc9A8B4N2493MArgg+pSYBAJd5fs3A8czYXf+olS1fEYUDABESAbqku0R8nM6gXKKWL6r2XSaNC9FixWU932NA96zo1+Avsyqn5xkC3w3Qr04Gf/4zAACrNQz6AYCjMfOWHQeAE4EncgB2hHU5cX6gl0n6R0TY2pFX46xPZOTQD9qyfGZay4wXqj8XO3dBOYHfYGK/DRZj5l3QmFjtqSnE2u5PVs4tACodDscr9Wb2Io09AOYVZKw441L6m4J1qdsB9ILR5aLuvtQWkbT4d8zcNiuCNoKIODr6qkv6dn/1xqg9roK2MNFjW/duvIOAe6HVstqDLIm4AMCYd97fNArAiEpTd+jp5a0lLKzv2aioK79T17OLJY0L0WLJyckWGGuI8Zf89BU/z09PXZKfviIjLyP11740zJhCoHsjkxa+7PtFrZ3BGwF4GPzt8r7xKSaYdllkb/HOzKQIP9ZM/+v3F3aRcnNL23SRHKXUK926BL5Zz5G/K4f/GheK1fsgTACA/PRV4QB6nGPHbsCetgzQ42Gz7vyysTIqA4wdBNxOCpM0rDBArWHw85EJt5e1drwRcxYfau0ym5KVleXMzS39m7/P256qHHQfgbcoxmMAvxo/YcauOokY+4k5gg2+FcCWWZNmNfo5uVRkZx+Jzcsrvb+94/CnVl2CV3QehsP5oGV6bgWRG6AABp8gppsB/N47+6OfCrber54nMuH2soL01M0MVeN5KH6PQNcAeHp/eupEJtW3rKy8ni/Rjo2ZrmjL8sMTF9S7AdOYxAWb/dl9ZBm0y9D8S2amgoyVSWBs9U7/BAAEked3TZURO2PBNwDSqj11Se0YGRQURKaJ/u0dhz/NjJl5HMBDGQczHun2eZWrvjTMqoCIxzA4hAl/8XOI7UYpDtQaPdo7Dn+SxoW4IN5fps94/yF7zVNXOByOowVrnu2nUTWFgJyw+CVn62RktQZENVbjI/B7zHSH/YAWELB6UvJ9FXXydnDR0YOva4/z+ntcSvmZsn1duwR1z8tYPpxgzIFCjX714Yn3VPozno4oLCzMAzSwauUlLnF4YiWA+j8D5c793MUTDGAEOVyv15vmEhQVNXgHgGaNJ7pUSLeIaBXeMRQF2qiaBcKUhjZtqlKetxxlPXKqP+esCnwfQP/8jBWvM2i2Zjzpj5hbW3b2kTa9c9FReBt+uQqOOQTEOSyV3t4xdTTMTFlZpZ3qzkVzxMfHnwPwEYg2d4RFrvylpKQksLDwaJ1t4S9l0rgQrWk9CLMJmEJE2+tLEJN4z4nay3iPnPfTMyDkEWMAOfTYyDmLvpO7BxJx59mYiHgXwA8AKAqbu+BIe4fT0RQVFTmdTnSqMRfNxtjP4E5z1wIAvvlGxXo81i/aOw5/6hTdIst+vPgHTPRr2K+3QAfz/NTU1LMAsGT+kmICugPwzpenHz790tOZ7RXrdxutJ0Y6CMHOSrNFtwAJ+leBZL0zPOG7fEvdvztvtidm9T6BlxHj+faOpSOqqKhgw+hySc8WuVAM2ksOZ6dqXDDrswAdb+84/OmSb1zcO3/hEBP0pCaOTn0x9eiy+Uv+oMrVQwB+5UtDDjXuqeeeanTOvGjaqeDPdvYq72eB6cCom5eeakne8MQlb7dVXP4SHT3krvaOwW8sYxcME8y0rr1D6YhiY2OrAFzS61xcKIfTfPHa6JmdpksEAKKjQ3MB5LZ3HP50yXeLmNoxioEPUl9MPQoAmpEBcKdahtVf7Gml2ETgTrWGvk9OTsnU9o7BXyJvuKsEQH74vs9adV2KSwUzq862xXZzXRuTeKK9Y/C3rKzjvfPyjnSqFTqp6STfbYt/svhKxZRrKD3pyRdWfLhs/pKnmLGgd2ifgJSUFO3tFnEAIIDfDlbnHvjjCy+cqV3Ovn2lo5xOCvZ4TuSPHTvWLCg4EsNMlZGRg/YXFn7R1bIqrmbmLyMjh5QUFpZcbllqAHPV0cjIYV8UFBy5ipkvYw4ojoy8vKyg4FCE1soRGTkku7Cw0GVZXcOZrbORkUM/KCw82tOydCiz8Xlk5MBjBQUfXcns7AvgUETE4K/y80tGAqqLx3MiPzY2tio///BYQHkiIq4s8MUB4KuIiMGHCgoO9WM2BhJZx8LDh36en394KIAevjjy84+GA9oVETF4ny8OQJdFRIQW5+cf7gFgKFHVF+Hhw47m5R0bSGT188WRl3foaiKjq2GcLQgLC/Pk5ZXGKKVNPrIxRhlBWl8RX0hEX4eHD/o4L++jvkTOKw1DfxIWFvpZXl5pKBH1NIygD8LC+p7NyzsyhogDwsMHZe/bt8/hcvWJqKri8rFjhxzIySm5zDDUVb44cnOPDlBKX24YqiQs7Movc3M/HqGUIyQoyLN/+PDhlXl5pTGWpa2YmKF5WVnHg12uqlG+OLKzD/ZxOFyDfHHk5JQMMQzVy+Wq+HDkyJFnqsWRk5kJ1avXkUhfHFlZH3d3uRzDPB7zRGzsVUeys49c4XBw/4oKozQubuCp3NyPRwCOl7t319eEhoaey80tjdZa65iYoXk7dx4N6tpVj66qUt+MHXvlR1lZx3u7XFWDPR4+Hhs75FNfHOXlnoMTJgw/nZt7OEwpBBYXD8oFgJEjj0SZJipiYgYX7dp1sFtwsGu4aVonY2KGHvbF4fE4D8fGXnEyJ+fj4Ybh6Hb2rCqaNOnKipyckijA/uVUUlISeOaMCrMs83R09FUHfXGYJn0aEzPoeHb2ocEOh9Hb4zE/io296pvs7MOjHQ4EFRcPynW7wQUFR6K1xrmoqMGFu3Yd7NalYv9PzMui1kRHh5ZmZZX2d7noCtP0HImJGX5i376jw5xO3d0XR3b2oUillIqKGpLji0Nr80xU1FUf7t59rFdQkDVEa/VZVNSVn2RlfTzI5XL08cXhq3unTg3KmzoVVvW6V1xcHOLxBI2oXfd8cfjqnsfjPBAbe0V59bp38ODBgIoK15jadc8Xh6/uWZb+ODo69Ovqdc93Dahd93xxHDx4bGBZWdW/iKy5kZHDvqhd9woKDkUwG87qdc8Xh6/u+a4BteueLw5f3at+DcjL+6wLUeVI3zXAV/dqXwN8dc93Dahe93zXgKbqnu8aUL3uKaXN8PCh+bXrXkPXgHrqXnZmJozqdc8Xh6/u+eKoXveqXwOq1z1fHL6657sG1K57vjh8da/6NcBX93zXgNp1zxeHr+6FhOjC0NDQc9XrXnb24euVou8zV/2hvrqXk1NyWXR06CV1N+eSv3OR+mLqUda409Lqf5fOX7KLwSdAOL8fAVk0++mXlg+nKhVNRD3LdeAf6yvHMGi61todFDQoYPVqKK21W2tOBADTLO+jtXYDHAcAlZW42j7uGAYAlsWT7ONmDzu9mqs13Wof69pFa+1mpng7b9WVdl4zAgC0dkZ5jw+w09P1Wmu3aXYPYmbypk2y857tpbV2WxZPsPM6RtiPjeHeOCZqrd1VVWW9AIDZnGOXzVRRERhkp/VtPqQG2mU7o+yyzAittZvIutL7zk3TWrs9nuBg+zjdqrWaY5rm22bw5cXeOCZ64ximtXZXVuJqOy9PsPOW9baPc6LW2r16NVTXrl0DtdZuw8D1AECkBtiv14ixH5vhdl5zkDfOeK21+8svg7p6/1Q3K6XmAoDDYfWw81qT7b+h4yr79dMouyzE2Y+D+9pZ9SyttXvfvn1Gz56fB2it3Q4HzQQAl0v1tx8bYwFAKXOM1todGGgOtssyrgX0ia++MkO8cdyklDEPALp3N7vbr8mcYsd1bqjW2u100mi7LBWrtXYHBKh+3vcnQWvtjo7+yDFw4DGX1tqtlE4AgMBAdbldlor1ph3tLTvUG8cUrbU7JKSqmzeOG4nsfWBOn7a62WUZ13pfwxD7b8ph3jjGeuO63C5Lz9RauwcOPOYqKipyeD/jswDA6Qzsy71i+gNqnP0Yo+w4HEO9ZU/WWrtdLusy+7ExD8DNAHDqVEBX+3PnuM5+TeZgb/0YY/+dVIwdl3GF/X7RDK21u2fPzwMyM2HYn0s9GwA8nqA+3s/wePsxRtplOYd5P1vX2H83q4ddB9QNWuMWO22gr+5NtR+bg+z3x/LWPVe0HYca4P2MT9dau7t27RoIwFv3dKKdt6y39/2ZAABnz1YNA/Cl1s7hdl5Msss+29N+rOZojVvtvMHBdl677hFZvmtAJAAwW1H2cTXQfg123auoCAzyln0rszkHAKqqynzXgIl2XucI+zXadc+y7LpXWXm2l53XTLLLBplmd9814Hrv38x7DXBF24+tCDtv1ZV22RRv18XALt44bjFNu+45nbqn9xp5jX1eu+55PBjp/dzG2WUFeq8BerbW2p2ZCaNv3xPeawBN977v/b2fee9Gd3bdCwiwrwHMjuu01u5vvuniq3s3K6Vu8H4OL7Pfd9N3DfDWPXivAWq81tpdVtbFV/dmaa3dRUVFjpCQT13231/PtF8TXW6XpcbaeTnMLkuHet+va7XW7tOnrW72cdwE4EY7r/kNYHUlMqbYcZih3s/LaG8cAyC+25bevnT20vlL8us7ds/ti+OXzl+SU98xIYQQQjTPJX/nAgCW/XjZVQCw7CfL+oD4EYK9MtwDd9wRsuzOZQMBYNmyZQGWotu5kw26Ea0nN7dkQXvHIDqGtDQ28vJK72zvOETHkJNTMiQ3tyShvePwp07RuGDSjy2dv/Q4M+cxsPapl5a/CACVZkgPNvWGpfOXfMKn9UcAnC7D1anmIovWw6y+394xiI4hLKzIAHBbe8chOgYiNZCZZICvEKLlOtNsEdE4mS0iquuMs0WEEEIIIYQQHVFOTumz7R2D6BiysrKcOTmlqe0dh+gYcnJKonJySpe0dxz+1CnGXAjhD0Sosz6K6JzOnBnLRCyfBwEAUMowifCd2+lZCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBCik0hOdL92W6L7lfYDH35gAAAEKklEQVSOQwjRehztHYAQwn9uS3T/hYGfMZC1OmP1uOrH3AnuYWTgQwBErCa+uv7VXa157uSk5L8zc9fVGatvbM1yhRAdj2rvAIQQfvc5AeHfm31LdPUnlYG7CTjSXkEJIS4dcudCiM7naxBt1jAWAFgIAG6328VlmA/wXwF6tHrilJQUVbi38FfEuBPAAADHwLwybf1rjwNgwO7aAEgT8wEm/ARANwA7lMO4+5W3Xjl+W6L7OWb+Adlp2S6ZFqVlpK30nSc5MfkegO8HcBmAd315AcA9yz2ZFP4AIAKAYkKpAv/m1fTXXm/LN0oIcWHkzoUQnZCCXgXw991T3V0BQJXzzQDOMdH62mkL9xQ+QIxfg+lRS+kwJvwBRP+ZnJh8b82UPE8reILLu4zwuKqGMNDDMq2nAODVjNV3gugfDKxJy1hN9r9vGxYMzCRwnIK+GaA5BIzw5b177N1OUlgH5vct0lFKG2PIogfIwjdt+BYJIS6C3LkQohN6Jf217cmJ7qPogu8DeEZrWgCF58CwaiUlAh4E8Z/SMla/4H3uYPLsW4cCeAjAn6ul/XB1+ur/8v7/nDvRvZyAlWierz8vP/HjzMxMEwDcSe7/JrbL/qrvV5cR0J1B6/+V/tohb/rSlr5mIYT/yJ0LITotWkWMu29LvG0EESaD8HztFN+b+b2BALoD6t0aOYF3QOh1c8LN/as9WVwjDdEXAELmzp0b3GQojFxfw8L7+Igv7+r1q08Q8BIRNiQnut92J7kfcie6w1v6aoUQ/iONCyE6KY/L8zcAozXpVDAyVq9b/cnFlEd173oAAALPBDZ5nSGCp+Zj4up5X81Y/RMGxoLobWJMJiAnefatD1xMvEKItiONCyE6qTfffPNrMKcR43pWeKa+NK+8/coxAN8A+trqzzNwHRinXt/4+qfNPiHDQxfRFbs6Y3VBWnra/6RlrJ4N0B+JaMGFliWEaFsy5kKITiy4ouvCypDK+19e+/KpBpIwiB4D4ze3Jd5aYireoVjFg/EzIv5VS87FxB8TY/ptSbeNUkqdCDgTcPalzJfONZXPPct9tVKYrxXeAnDEsHRfzTyVgf0tOb8Qwn+kcSFEJ+b9cm/0C370uNGPF+4tdBDTbw1NAwAcBfNvX8147cmWnMuhHKssy5zMrHdZlu5WHmwtQjMGfFpklQHGKNL4EYA+mtQpML9tOJz3t+T8QgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCNG2/h/fqVulYpDjggAAAABJRU5ErkJggg==",
- "image/svg+xml": [
- "\n",
- "\n"
- ],
- "text/html": [
- "\n",
- "\n"
- ],
- "text/plain": [
- "Plot(...)"
- ]
- },
- "execution_count": 4,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "initial = ones(5) * S0\n",
- "# Using μ=0, T=.25 for now, we'll use the proper values later\n",
- "motion = simulate_gbm(initial, 0, σ, .25, 200) \n",
- "\n",
- "display_motion(motion, .25)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Computing the term structure\n",
- "\n",
- "Now that we've got the basic motion set up, let's start making things a bit more sophisticated for the model. We're going to assume that the drift of the stock is the difference between the implied forward rate and the quarterly dividend rate.\n",
- "\n",
- "We're given the yearly term structure, and need to calculate the quarterly forward rate to match this structure. The term structure is assumed to follow:\n",
- "\n",
- "$d(0, t) = d(0,t-1)\\cdot f_{i-1, i}$\n",
- "\n",
- "Where $f_{i-1, i}$ is the quarterly forward rate."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "forward_term = function(yearly_term)\n",
- " # It is assumed that we have a yearly term structure passed in, and starts at year 0\n",
- " # This implies a nominal rate above 0 for the first year!\n",
- " years = length(term)-1 # because we start at 0\n",
- " structure = [(term[i+1] / term[i]) for i=1:years]\n",
- "end;"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Illustrating the term structure\n",
- "\n",
- "Now that we've got our term structure, let's validate that we're getting the correct results! If we've done this correctly, then:\n",
- "\n",
- "```\n",
- "term[2] == term[1] * structure[1]\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Actual term[2]: 1.0049; Calculated term[2]: 1.0049\n"
- ]
- }
- ],
- "source": [
- "# Example term structure taken from:\n",
- "# http://www.treasury.gov/resource-center/data-chart-center/interest-rates/Pages/TextView.aspx?data=yield\n",
- "# Linear interpolation used years in-between periods, assuming real-dollar\n",
- "# interest rates\n",
- "forward_yield = forward_term(term)\n",
- "calculated_term2 = term[1] * forward_yield[1]\n",
- "\n",
- "println(\"Actual term[2]: $(term[2]); Calculated term[2]: $(calculated_term2)\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### The full underlying simulation\n",
- "\n",
- "Now that we have the term structure set up, we can actually start doing some real simulation! Let's construct some paths through the full 5-year time frame. In order to do this, we will simulate 1 year at a time, and use the forward rates at those times to compute the drift. Thus, there will be 5 total simulations batched together."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "image/svg+xml": [
- "\n",
- "\n"
- ],
- "text/html": [
- "\n",
- "\n"
- ],
- "text/plain": [
- "Plot(...)"
- ]
- },
- "execution_count": 7,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "full_motion = ones(5) * S0\n",
- "full_term = vcat(term[1], forward_yield)\n",
- "for i=1:T\n",
- " μ = (full_term[i] - 1 - q)\n",
- " year_motion = simulate_gbm(full_motion[:,end], μ, σ, 1, n)\n",
- " full_motion = hcat(full_motion, year_motion)\n",
- "end\n",
- "\n",
- "display_motion(full_motion, T)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Final simulation\n",
- "\n",
- "We're now going to actually build out the full motion that we'll use for computing the pricing of our autocallable products. It will be largely the same, but we will use far more sample paths for the simulation."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Time to run simulation: 5.34s"
- ]
- }
- ],
- "source": [
- "full_simulation = function(S0, T, n, m, term)\n",
- " forward = vcat(term[1], forward_term(term))\n",
- "\n",
- " # And an S0 to kick things off.\n",
- " final_motion = ones(m) * S0\n",
- " for i=1:T\n",
- " μ = (forward[i] - 1 - q)\n",
- " year_motion = simulate_gbm(final_motion[:,end], μ, σ, 1, n)\n",
- " final_motion = hcat(final_motion, year_motion)\n",
- " end\n",
- " return final_motion\n",
- "end\n",
- "\n",
- "tic()\n",
- "full_simulation(S0, T, n, m, term)\n",
- "time = toq()\n",
- "@printf(\"Time to run simulation: %.2fs\", time)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Athena Simulation\n",
- "\n",
- "Now that we've defined our underlying simulation, let's actually try and price an Athena note. Athena has the following characteristics:\n",
- "\n",
- "- Automatically called if the underlying is above the **call barrier** at observation\n",
- "- Accelerated coupon paid if the underlying is above the **call barrier** at observation\n",
- " - The coupon paid is $c \\cdot i$ with $i$ as the current year, and $c$ the coupon rate\n",
- "- Principle protection up until a **protection barrier** at observation; All principle at risk if this barrier not met\n",
- "- Observed yearly"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Mean of simulation 1: $103.2805; Simulation time: 5.59s\n",
- "Mean of simulation 2: $103.3796; Simulation time: 5.05s\n",
- "Mean of simulation 3: $103.4752; Simulation time: 5.18s\n",
- "Mean of simulation 4: $103.4099; Simulation time: 5.37s\n",
- "Mean of simulation 5: $103.3260; Simulation time: 5.32s\n",
- "Mean over 5 simulations: 103.37421610015554\n",
- "Present value of Athena note: $95.00, notional: $100.00"
- ]
- }
- ],
- "source": [
- "call_barrier = S0\n",
- "strike = S0\n",
- "protection_barrier = S0 * .6\n",
- "coupon = nominal * .07\n",
- "\n",
- "price_athena = function(initial_price, year_prices, call_barrier,\n",
- " protection_barrier, coupon, forward_structure)\n",
- "\n",
- " total_coupons = 0\n",
- " \n",
- " t = length(year_prices)\n",
- "\n",
- " for i=1:t\n",
- " price = year_prices[i]\n",
- " if price ≥ call_barrier\n",
- " return (nominal + coupon*i) * exp((prod(forward_structure[i:end])-1)*(t-i))\n",
- " end\n",
- " end\n",
- "\n",
- " # We've reached maturity, time to check capital protection\n",
- " if year_prices[end] > protection_barrier\n",
- " return nominal\n",
- " else\n",
- " put = (strike - year_prices[end]) / strike\n",
- " return nominal*(1-put)\n",
- " end\n",
- "end\n",
- "\n",
- "forward_structure = forward_term(term)\n",
- "price_function = (year_prices) -> price_athena(S0, year_prices,\n",
- " call_barrier, protection_barrier, coupon, forward_structure)\n",
- "\n",
- "athena = function()\n",
- " year_indexes = [n*i for i=1:T]\n",
- " motion = full_simulation(S0, T, n, m, term)\n",
- " payoffs = [price_function(motion[i, year_indexes]) for i=1:m]\n",
- " return mean(payoffs)\n",
- "end\n",
- "\n",
- "mean_payoffs = zeros(num_simulations)\n",
- "for i=1:num_simulations\n",
- " tic()\n",
- " mean_payoffs[i] = athena()\n",
- " time = toq()\n",
- " @printf(\"Mean of simulation %i: \\$%.4f; Simulation time: %.2fs\\n\", i, mean_payoffs[i], time)\n",
- "end\n",
- "\n",
- "final_mean = mean(mean_payoffs)\n",
- "println(\"Mean over $num_simulations simulations: $(mean(mean_payoffs))\")\n",
- "pv = final_mean * (exp(-(prod(forward_structure)-1)*T))\n",
- "@printf(\"Present value of Athena note: \\$%.2f, notional: \\$%.2f\", pv, nominal)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Phoenix without Memory Simulation\n",
- "\n",
- "Let's move into pricing a Phoenix without memory. It's very similar to the Athena production, with the exception that we introduce a coupon barrier so coupons are paid even when the underlying is below the initial price.\n",
- "\n",
- "The Phoenix product has the following characteristics (example [here](https://www.rbccm.com/usstructurednotes/file-780079.pdf)):\n",
- "\n",
- "- Automatically called if the underlying is above the **call barrier** at observation\n",
- "- Coupon paid if the underlying is above a **coupon barrier** at observation\n",
- "- Principle protection up until a **protection barrier** at observation; All principle at risk if this barrier not met\n",
- "- Observed yearly\n",
- "\n",
- "Some example paths (all assume that a call barrier of the current price, and coupon barrier some level below that):\n",
- "\n",
- "- At the end of year 1, the stock is above the call barrier; the note is called and you receive the value of the stock plus the coupon being paid.\n",
- "- At the end of year 1, the stock is above the coupon barrier, but not the call barrier; you receive the coupon. At the end of year 2, the stock is below the coupon barrier; you receive nothing. At the end of year 3, the stock is above the call barrier; the note is called and you receive the value of the stock plus a coupon for year 3.\n",
- "\n",
- "We're going to re-use the same simulation, with the following parameters:\n",
- "\n",
- "- Call barrier: 100%\n",
- "- Coupon barrier: 70%\n",
- "- Coupon: 6%\n",
- "- Capital protection until 70% (at maturity)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Mean of simulation 1: $106.0562; Simulation time: 5.72s\n",
- "Mean of simulation 2: $106.0071; Simulation time: 5.85s\n",
- "Mean of simulation 3: $105.9959; Simulation time: 5.87s\n",
- "Mean of simulation 4: $106.0665; Simulation time: 5.93s\n",
- "Mean of simulation 5: $106.0168; Simulation time: 5.81s\n",
- "Mean over 5 simulations: 106.02850857209883\n",
- "Present value of Phoenix without memory note: $97.44"
- ]
- }
- ],
- "source": [
- "call_barrier = S0\n",
- "coupon_barrier = S0 * .8\n",
- "protection_barrier = S0 * .6\n",
- "coupon = nominal * .06\n",
- "\n",
- "price_phoenix_no_memory = function(initial_price, year_prices, call_barrier, coupon_barrier,\n",
- " protection_barrier, coupon, forward_structure)\n",
- "\n",
- " total_coupons = 0\n",
- " t = length(year_prices)\n",
- "\n",
- " for i=1:t\n",
- " price = year_prices[i]\n",
- " if price ≥ call_barrier\n",
- " return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))\n",
- " elseif price ≥ coupon_barrier\n",
- " total_coupons = total_coupons * exp(forward_structure[i]-1) + coupon\n",
- " else\n",
- " total_coupons *= exp(forward_structure[i]-1)\n",
- " end\n",
- " end\n",
- "\n",
- " # We've reached maturity, time to check capital protection\n",
- " if year_prices[end] > protection_barrier\n",
- " return nominal + total_coupons\n",
- " else\n",
- " put = (strike - year_prices[end]) / strike\n",
- " return nominal*(1-put)\n",
- " end\n",
- "end\n",
- "\n",
- "forward_structure = forward_term(term)\n",
- "price_function = (year_prices) -> price_phoenix_no_memory(S0, year_prices,\n",
- " call_barrier, coupon_barrier, protection_barrier, coupon, forward_structure)\n",
- "\n",
- "phoenix_no_memory = function()\n",
- " year_indexes = [n*i for i=1:T]\n",
- " motion = full_simulation(S0, T, n, m, term)\n",
- " payoffs = [price_function(motion[i, year_indexes]) for i=1:m]\n",
- " return mean(payoffs)\n",
- "end\n",
- "\n",
- "mean_payoffs = zeros(num_simulations)\n",
- "for i=1:num_simulations\n",
- " tic()\n",
- " mean_payoffs[i] = phoenix_no_memory()\n",
- " time = toq()\n",
- " @printf(\"Mean of simulation %i: \\$%.4f; Simulation time: %.2fs\\n\", i, mean_payoffs[i], time)\n",
- "end\n",
- "\n",
- "final_mean = mean(mean_payoffs)\n",
- "println(\"Mean over $num_simulations simulations: $(mean(mean_payoffs))\")\n",
- "pv = final_mean * exp(-(prod(forward_structure)-1)*(T))\n",
- "@printf(\"Present value of Phoenix without memory note: \\$%.2f\", pv)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Phoenix with Memory Simulation\n",
- "\n",
- "The Phoenix with Memory structure is very similar to the Phoenix, but as the name implies, has a special \"memory\" property: **It remembers any coupons that haven't been paid at prior observation times, and pays them all if the underlying crosses the coupon barrier**. For example:\n",
- "- Note issued with 100% call barrier, 70% coupon barrier. At year 1, the underlying is at 50%, so no coupons are paid. At year 2, the underlying is at 80%, so coupons for both year 1 and 2 are paid, resulting in a double coupon.\n",
- "\n",
- "You can also find an example [here](https://www.rbccm.com/usstructurednotes/file-781232.pdf).\n",
- "\n",
- "Let's go ahead and set up the simulation! The parameters will be the same, but we can expect that the value will go up because of the memory attribute"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Mean of simulation 1: $108.8612; Simulation time: 5.89s\n",
- "Mean of simulation 2: $109.0226; Simulation time: 5.90s\n",
- "Mean of simulation 3: $108.9175; Simulation time: 5.92s\n",
- "Mean of simulation 4: $108.9426; Simulation time: 5.94s\n",
- "Mean of simulation 5: $108.8087; Simulation time: 6.06s\n",
- "Mean over 5 simulations: 108.91052564051816\n",
- "Present value of Phoenix with memory note: $100.09"
- ]
- }
- ],
- "source": [
- "call_barrier = S0\n",
- "coupon_barrier = S0 * .8\n",
- "protection_barrier = S0 * .6\n",
- "coupon = nominal * .07\n",
- "\n",
- "price_phoenix_with_memory = function(initial_price, year_prices, call_barrier,\n",
- " coupon_barrier, protection_barrier, coupon, forward_structure)\n",
- "\n",
- " last_coupon = 0\n",
- " total_coupons = 0\n",
- " \n",
- " t = length(year_prices)\n",
- "\n",
- " for i=1:t\n",
- " price = year_prices[i]\n",
- " if price > call_barrier\n",
- " return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))\n",
- " elseif price > coupon_barrier\n",
- " ####################################################################\n",
- " # The only difference between with/without memory is the below lines\n",
- " memory_coupons = (i - last_coupon) * coupon\n",
- " last_coupon = i\n",
- " total_coupons = total_coupons * exp(forward_structure[i]-1) + memory_coupons\n",
- " ####################################################################\n",
- " else\n",
- " total_coupons *= exp(forward_structure[i]-1)\n",
- " end\n",
- " end\n",
- "\n",
- " # We've reached maturity, time to check capital protection\n",
- " if year_prices[end] > protection_barrier\n",
- " return nominal + total_coupons\n",
- " else\n",
- " put = (strike - year_prices[end]) / strike\n",
- " return nominal*(1-put)\n",
- " end\n",
- "end\n",
- "\n",
- "forward_structure = forward_term(term)\n",
- "price_function = (year_prices) -> price_phoenix_with_memory(S0, year_prices,\n",
- " call_barrier, coupon_barrier, protection_barrier, coupon, forward_structure)\n",
- "\n",
- "phoenix_with_memory = function()\n",
- " year_indexes = [n*i for i=1:T]\n",
- " motion = full_simulation(S0, T, n, m, term)\n",
- " payoffs = [price_function(motion[i, year_indexes]) for i=1:m]\n",
- " return mean(payoffs)\n",
- "end\n",
- "\n",
- "mean_payoffs = zeros(num_simulations)\n",
- "for i=1:num_simulations\n",
- " tic()\n",
- " mean_payoffs[i] = phoenix_with_memory()\n",
- " time = toq()\n",
- " @printf(\"Mean of simulation %i: \\$%.4f; Simulation time: %.2fs\\n\",\n",
- " i, mean_payoffs[i], time)\n",
- "end\n",
- "\n",
- "final_mean = mean(mean_payoffs)\n",
- "println(\"Mean over $num_simulations simulations: $(mean(mean_payoffs))\")\n",
- "pv = final_mean * exp(-(prod(forward_structure)-1)*(T))\n",
- "@printf(\"Present value of Phoenix with memory note: \\$%.2f\", pv)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Julia 0.4.0",
- "language": "julia",
- "name": "julia-0.4"
- },
- "language_info": {
- "file_extension": ".jl",
- "mimetype": "application/julia",
- "name": "julia",
- "version": "0.4.1"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/content/notebooks/2015-12-26-testing_cramer.ipynb b/content/notebooks/2015-12-26-testing_cramer.ipynb
deleted file mode 100644
index 02a7b5b..0000000
--- a/content/notebooks/2015-12-26-testing_cramer.ipynb
+++ /dev/null
@@ -1,428 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "import requests\n",
- "import pandas as pd\n",
- "import numpy as np\n",
- "from dateutil import parser as dtparser\n",
- "from dateutil.relativedelta import relativedelta\n",
- "from datetime import datetime\n",
- "from html.parser import HTMLParser\n",
- "from copy import copy\n",
- "import Quandl"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Testing Cramer\n",
- "\n",
- "Pursuant to attending a graduate school studying Financial Engineering, I've been a fan of the [Mad Money][3] TV show featuring the bombastic Jim Cramer. One of the things that he's said is that you shouldn't use the futures to predict where the stock market is going to go. But he says it often enough, I've begun to wonder - who is he trying to convince?\n",
- "\n",
- "It makes sense that because futures on things like the S&P 500 are traded continuously, they would price in market information before the stock market opens. So is Cramer right to be convinced that strategies based on the futures are a poor idea? I wanted to test it out.\n",
- "\n",
- "The first question is where to get the future's data. I've been part of [Seeking Alpha][2] for a bit, and they publish the [Wall Street Breakfast][3] newsletter which contains daily future's returns as of 6:20 AM EST. I'd be interested in using that data to see if we can actually make some money.\n",
- "\n",
- "First though, let's get the data:\n",
- "\n",
- "# Downloading Futures data from Seeking Alpha\n",
- "\n",
- "We're going to define two HTML parsing classes - one to get the article URL's from a page, and one to get the actual data from each article.\n",
- "\n",
- "[1]: http://www.cnbc.com/mad-money/\n",
- "[2]: http://seekingalpha.com/\n",
- "[3]: http://seekingalpha.com/author/wall-street-breakfast?s=wall-street-breakfast"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "class ArticleListParser(HTMLParser):\n",
- " \"\"\"Given a web page with articles on it, parse out the article links\"\"\"\n",
- " \n",
- " articles = []\n",
- " \n",
- " def handle_starttag(self, tag, attrs):\n",
- " #if tag == 'div' and (\"id\", \"author_articles_wrapper\") in attrs:\n",
- " # self.fetch_links = True\n",
- " if tag == 'a' and ('class', 'dashboard_article_link') in attrs:\n",
- " href = list(filter(lambda x: x[0] == 'href', attrs))[0][1]\n",
- " self.articles.append(href)\n",
- " \n",
- "base_url = \"http://seekingalpha.com/author/wall-street-breakfast/articles\"\n",
- "article_page_urls = [base_url] + [base_url + '/{}'.format(i) for i in range(2, 20)]\n",
- "\n",
- "global_articles = []\n",
- "for page in article_page_urls:\n",
- " # We need to switch the user agent, as SA blocks the standard requests agent\n",
- " articles_html = requests.get(page,\n",
- " headers={\"User-Agent\": \"Wget/1.13.4\"})\n",
- " parser = ArticleListParser()\n",
- " parser.feed(articles_html.text)\n",
- " global_articles += (parser.articles)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false,
- "scrolled": true
- },
- "outputs": [],
- "source": [
- "class ArticleReturnParser(HTMLParser):\n",
- " \"Given an article, parse out the futures returns in it\"\n",
- " \n",
- " record_font_tags = False\n",
- " in_font_tag = False\n",
- " counter = 0\n",
- " # data = {} # See __init__\n",
- " \n",
- " def __init__(self, *args, **kwargs):\n",
- " super().__init__(*args, **kwargs)\n",
- " self.data = {}\n",
- " \n",
- " def handle_starttag(self, tag, attrs):\n",
- " if tag == 'span' and ('itemprop', 'datePublished') in attrs:\n",
- " date_string = list(filter(lambda x: x[0] == 'content', attrs))[0][1]\n",
- " date = dtparser.parse(date_string)\n",
- " self.data['date'] = date\n",
- " \n",
- " self.in_font_tag = tag == 'font'\n",
- " \n",
- " def safe_float(self, string):\n",
- " try:\n",
- " return float(string[:-1]) / 100\n",
- " except ValueError:\n",
- " return np.NaN\n",
- " \n",
- " def handle_data(self, content):\n",
- " if not self.record_font_tags and \"Futures at 6\" in content:\n",
- " self.record_font_tags = True\n",
- " \n",
- " if self.record_font_tags and self.in_font_tag:\n",
- " if self.counter == 0:\n",
- " self.data['DOW'] = self.safe_float(content)\n",
- " elif self.counter == 1:\n",
- " self.data['S&P'] = self.safe_float(content)\n",
- " elif self.counter == 2:\n",
- " self.data['NASDAQ'] = self.safe_float(content)\n",
- " elif self.counter == 3:\n",
- " self.data['Crude'] = self.safe_float(content)\n",
- " elif self.counter == 4:\n",
- " self.data['Gold'] = self.safe_float(content)\n",
- " \n",
- " self.counter += 1\n",
- " \n",
- " def handle_endtag(self, tag):\n",
- " self.in_font_tag = False\n",
- "\n",
- "def retrieve_data(url):\n",
- " sa = \"http://seekingalpha.com\"\n",
- " article_html = requests.get(sa + url,\n",
- " headers={\"User-Agent\": \"Wget/1.13.4\"})\n",
- " parser = ArticleReturnParser()\n",
- " parser.feed(article_html.text)\n",
- " parser.data.update({\"url\": url})\n",
- " parser.data.update({\"text\": article_html.text})\n",
- " return parser.data\n",
- "\n",
- "# This copy **MUST** be in place. I'm not sure why,\n",
- "# as you'd think that the data being returned would already\n",
- "# represent a different memory location. Even so, it blows up\n",
- "# if you don't do this.\n",
- "article_list = list(set(global_articles))\n",
- "article_data = [copy(retrieve_data(url)) for url in article_list]\n",
- "# If there's an issue downloading the article, drop it.\n",
- "article_df = pd.DataFrame.from_dict(article_data).dropna()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Fetching the Returns data\n",
- "\n",
- "Now that we have the futures data, we're going to compare across 4 different indices - the S&P 500 index, Dow Jones Industrial, Russell 2000, and NASDAQ 100. Let's get the data off of Quandl to make things easier!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false
- },
- "outputs": [],
- "source": [
- "# article_df is sorted by date, so we get the first row.\n",
- "start_date = article_df.sort_values(by='date').iloc[0]['date'] - relativedelta(days=1)\n",
- "SPY = Quandl.get(\"GOOG/NYSE_SPY\", trim_start=start_date)\n",
- "DJIA = Quandl.get(\"GOOG/AMS_DIA\", trim_start=start_date)\n",
- "RUSS = Quandl.get(\"GOOG/AMEX_IWM\", trim_start=start_date)\n",
- "NASDAQ = Quandl.get(\"GOOG/EPA_QQQ\", trim_start=start_date)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Running the Comparison\n",
- "\n",
- "There are two types of tests I want to determine: How accurate each futures category is at predicting the index's opening change over the close before, and predicting the index's daily return.\n",
- "\n",
- "Let's first calculate how good each future is at predicting the opening return over the previous day. I expect that the futures will be more than 50% accurate, since the information is recorded 3 hours before the markets open."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Articles Checked: \n",
- " DJIA NASDAQ RUSS SPY\n",
- "Crude 268 268 271 271\n",
- "DOW 268 268 271 271\n",
- "Gold 268 268 271 271\n",
- "NASDAQ 268 268 271 271\n",
- "S&P 268 268 271 271\n",
- "\n",
- "Prediction Accuracy:\n",
- " DJIA NASDAQ RUSS SPY\n",
- "Crude 0.544776 0.522388 0.601476 0.590406\n",
- "DOW 0.611940 0.604478 0.804428 0.841328\n",
- "Gold 0.462687 0.455224 0.464945 0.476015\n",
- "NASDAQ 0.615672 0.608209 0.797048 0.830258\n",
- "S&P 0.604478 0.597015 0.811808 0.848708\n"
- ]
- }
- ],
- "source": [
- "def calculate_opening_ret(frame):\n",
- " # I'm not a huge fan of the appending for loop,\n",
- " # but it's a bit verbose for a comprehension\n",
- " data = {}\n",
- " for i in range(1, len(frame)):\n",
- " date = frame.iloc[i].name\n",
- " prior_close = frame.iloc[i-1]['Close']\n",
- " open_val = frame.iloc[i]['Open']\n",
- " data[date] = (open_val - prior_close) / prior_close\n",
- " \n",
- " return data\n",
- "\n",
- "SPY_open_ret = calculate_opening_ret(SPY)\n",
- "DJIA_open_ret = calculate_opening_ret(DJIA)\n",
- "RUSS_open_ret = calculate_opening_ret(RUSS)\n",
- "NASDAQ_open_ret = calculate_opening_ret(NASDAQ)\n",
- "\n",
- "def signs_match(list_1, list_2):\n",
- " # This is a surprisingly difficult task - we have to match\n",
- " # up the dates in order to check if opening returns actually match\n",
- " index_dict_dt = {key.to_datetime(): list_2[key] for key in list_2.keys()}\n",
- " \n",
- " matches = []\n",
- " for row in list_1.iterrows():\n",
- " row_dt = row[1][1]\n",
- " row_value = row[1][0]\n",
- " index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)\n",
- " if index_dt in list_2:\n",
- " index_value = list_2[index_dt]\n",
- " if (row_value > 0 and index_value > 0) or \\\n",
- " (row_value < 0 and index_value < 0) or \\\n",
- " (row_value == 0 and index_value == 0):\n",
- " matches += [1]\n",
- " else:\n",
- " matches += [0]\n",
- " #print(\"{}\".format(list_2[index_dt]))\n",
- " return matches\n",
- " \n",
- " \n",
- "prediction_dict = {}\n",
- "matches_dict = {}\n",
- "count_dict = {}\n",
- "index_dict = {\"SPY\": SPY_open_ret, \"DJIA\": DJIA_open_ret, \"RUSS\": RUSS_open_ret, \"NASDAQ\": NASDAQ_open_ret}\n",
- "indices = [\"SPY\", \"DJIA\", \"RUSS\", \"NASDAQ\"]\n",
- "futures = [\"Crude\", \"Gold\", \"DOW\", \"NASDAQ\", \"S&P\"]\n",
- "for index in indices:\n",
- " matches_dict[index] = {future: signs_match(article_df[[future, 'date']],\n",
- " index_dict[index]) for future in futures}\n",
- " count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}\n",
- " prediction_dict[index] = {future: np.mean(matches_dict[index][future])\n",
- " for future in futures}\n",
- "print(\"Articles Checked: \")\n",
- "print(pd.DataFrame.from_dict(count_dict))\n",
- "print()\n",
- "print(\"Prediction Accuracy:\")\n",
- "print(pd.DataFrame.from_dict(prediction_dict))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "This data is very interesting. Some insights:\n",
- "\n",
- "- Both DOW and NASDAQ futures are pretty bad at predicting their actual market openings\n",
- "- NASDAQ and Dow are fairly unpredictable; Russell 2000 and S&P are very predictable\n",
- "- Gold is a poor predictor in general - intuitively Gold should move inverse to the market, but it appears to be about as accurate as a coin flip.\n",
- "\n",
- "All said though it appears that futures data is important for determining market direction for both the S&P 500 and Russell 2000. Cramer is half-right: futures data isn't very helpful for the Dow and NASDAQ indices, but is great for the S&P and Russell indices.\n",
- "\n",
- "# The next step - Predicting the close\n",
- "\n",
- "Given the code we currently have, I'd like to predict the close of the market as well. We can re-use most of the code, so let's see what happens:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Articles Checked:\n",
- " DJIA NASDAQ RUSS SPY\n",
- "Crude 268 268 271 271\n",
- "DOW 268 268 271 271\n",
- "Gold 268 268 271 271\n",
- "NASDAQ 268 268 271 271\n",
- "S&P 268 268 271 271\n",
- "\n",
- "Prediction Accuracy:\n",
- " DJIA NASDAQ RUSS SPY\n",
- "Crude 0.533582 0.529851 0.501845 0.542435\n",
- "DOW 0.589552 0.608209 0.535055 0.535055\n",
- "Gold 0.455224 0.451493 0.483395 0.512915\n",
- "NASDAQ 0.582090 0.626866 0.531365 0.538745\n",
- "S&P 0.585821 0.608209 0.535055 0.535055\n"
- ]
- }
- ],
- "source": [
- "def calculate_closing_ret(frame):\n",
- " # I'm not a huge fan of the appending for loop,\n",
- " # but it's a bit verbose for a comprehension\n",
- " data = {}\n",
- " for i in range(0, len(frame)):\n",
- " date = frame.iloc[i].name\n",
- " open_val = frame.iloc[i]['Open']\n",
- " close_val = frame.iloc[i]['Close']\n",
- " data[date] = (close_val - open_val) / open_val\n",
- " \n",
- " return data\n",
- "\n",
- "SPY_close_ret = calculate_closing_ret(SPY)\n",
- "DJIA_close_ret = calculate_closing_ret(DJIA)\n",
- "RUSS_close_ret = calculate_closing_ret(RUSS)\n",
- "NASDAQ_close_ret = calculate_closing_ret(NASDAQ)\n",
- "\n",
- "def signs_match(list_1, list_2):\n",
- " # This is a surprisingly difficult task - we have to match\n",
- " # up the dates in order to check if opening returns actually match\n",
- " index_dict_dt = {key.to_datetime(): list_2[key] for key in list_2.keys()}\n",
- " \n",
- " matches = []\n",
- " for row in list_1.iterrows():\n",
- " row_dt = row[1][1]\n",
- " row_value = row[1][0]\n",
- " index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)\n",
- " if index_dt in list_2:\n",
- " index_value = list_2[index_dt]\n",
- " if (row_value > 0 and index_value > 0) or \\\n",
- " (row_value < 0 and index_value < 0) or \\\n",
- " (row_value == 0 and index_value == 0):\n",
- " matches += [1]\n",
- " else:\n",
- " matches += [0]\n",
- " #print(\"{}\".format(list_2[index_dt]))\n",
- " return matches\n",
- " \n",
- " \n",
- "matches_dict = {}\n",
- "count_dict = {}\n",
- "prediction_dict = {}\n",
- "index_dict = {\"SPY\": SPY_close_ret, \"DJIA\": DJIA_close_ret,\n",
- " \"RUSS\": RUSS_close_ret, \"NASDAQ\": NASDAQ_close_ret}\n",
- "indices = [\"SPY\", \"DJIA\", \"RUSS\", \"NASDAQ\"]\n",
- "futures = [\"Crude\", \"Gold\", \"DOW\", \"NASDAQ\", \"S&P\"]\n",
- "for index in indices:\n",
- " matches_dict[index] = {future: signs_match(article_df[[future, 'date']],\n",
- " index_dict[index]) for future in futures}\n",
- " count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}\n",
- " prediction_dict[index] = {future: np.mean(matches_dict[index][future])\n",
- " for future in futures}\n",
- " \n",
- "print(\"Articles Checked:\")\n",
- "print(pd.DataFrame.from_dict(count_dict))\n",
- "print()\n",
- "print(\"Prediction Accuracy:\")\n",
- "print(pd.DataFrame.from_dict(prediction_dict))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Well, it appears that the futures data is terrible at predicting market close. NASDAQ predicting NASDAQ is the most interesting data point, but 63% accuracy isn't accurate enough to make money consistently.\n",
- "\n",
- "# Final sentiments\n",
- "\n",
- "The data bears out very close to what I expected would happen:\n",
- "\n",
- "- Futures data is more accurate than a coin flip for predicting openings, which makes sense since it is recorded only 3 hours before the actual opening\n",
- "- Futures data is about as acccurate as a coin flip for predicting closings, which means there is no money to be made in trying to predict the market direction for the day given the futures data.\n",
- "\n",
- "In summary:\n",
- "\n",
- "- Cramer is half right: Futures data is not good for predicting the market open of the Dow and NASDAQ indices. Contrary to Cramer though, it is very good for predicting the S&P and Russell indices - we can achieve an accuracy slightly over 80% for each. \n",
- "- Making money in the market is hard. We can't just go to the futures and treat them as an oracle for where the market will close.\n",
- "\n",
- "I hope you've enjoyed this, I quite enjoyed taking a deep dive in the analytics this way. I'll be posting more soon!"
- ]
- }
- ],
- "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.5.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/content/notebooks/2016-1-1-complaining-about-weather.ipynb b/content/notebooks/2016-1-1-complaining-about-weather.ipynb
deleted file mode 100644
index daa035d..0000000
--- a/content/notebooks/2016-1-1-complaining-about-weather.ipynb
+++ /dev/null
@@ -1,734 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/html": [
- " \n",
- "\n",
- "\n",
- " \n",
- "\n",
- "
"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "from bokeh.plotting import figure, output_notebook, show\n",
- "from bokeh.palettes import PuBuGn9 as Palette\n",
- "import pandas as pd\n",
- "import numpy as np\n",
- "from datetime import datetime\n",
- "import pickle\n",
- "\n",
- "output_notebook()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "I'm originally from North Carolina, and I've been hearing a lot of people talking about how often it's been raining recently. They're excited for any day that has sun.\n",
- "\n",
- "So I got a bit curious: Has North Carolina over the past few months actually had more cloudy and rainy days recently than in previous years? This shouldn't be a particularly challenging task, but I'm interested to know if people's perceptions actually reflect reality.\n",
- "\n",
- "The data we'll use comes from [forecast.io][1], since they can give us a cloud cover percentage. I've gone ahead and retrieved the data to a pickle file, and included the [code that was used to generate it](#Generating-the-Forecast-file). First up: What was the average cloud cover in North Carolina during August - November, and how many days were cloudy? We're going to assume that a \"cloudy\" day is defined as any day in which the cloud cover is above 50%.\n",
- "\n",
- "[1]: http://forecast.io/"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {
- "collapsed": true
- },
- "outputs": [],
- "source": [
- "city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))\n",
- "forecast_df = pd.DataFrame.from_dict(city_forecasts)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "\n"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "cary_forecast = forecast_df['cary']\n",
- "years = range(1990, 2016)\n",
- "months = range(7, 12)\n",
- "months_str = ['July', 'August', 'September', 'October', 'November']\n",
- "\n",
- "def safe_cover(frame):\n",
- " if frame and 'cloudCover' in frame:\n",
- " return frame['cloudCover']\n",
- " else:\n",
- " return np.NaN\n",
- "\n",
- "def monthly_avg_cloudcover(year, month):\n",
- " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n",
- " end=datetime(year, month + 1, 1, 12),\n",
- " freq='D', closed='left')\n",
- " cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))\n",
- " cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))\n",
- " return np.nanmean(cloud_cover_vals), cloud_cover_samples\n",
- "\n",
- "\n",
- "monthly_cover_vals = [[monthly_avg_cloudcover(y, m)[0] for y in years] for m in months]\n",
- "\n",
- "f = figure(title='Monthly Average Cloud Cover',\n",
- " x_range=(1990, 2015),\n",
- " x_axis_label='Year')\n",
- "for x in range(0, len(months)):\n",
- " f.line(years, monthly_cover_vals[x], legend=months_str[x], color=Palette[x])\n",
- "show(f)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "As we can see from the chart above, on the whole the monthly average cloud cover has been generally trending down over time. The average cloud cover is also lower than it was last year - it seems people are mostly just complaining. There are some data issues that start in 2012 that we need to be aware of - the cloud cover percentage doesn't exist for all days. Even so, the data that we have seems to reflect the wider trend, so we'll assume for now that the missing data doesn't skew our results.\n",
- "\n",
- "There's one more metric we want to check though - how many cloudy days were there? This is probably a better gauge of sentiment than the average monthly cover."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "\n"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "\n"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "def monthly_cloudy_days(year, month):\n",
- " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n",
- " end=datetime(year, month + 1, 1, 12),\n",
- " freq='D', closed='left')\n",
- " cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))\n",
- " cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))\n",
- " cloudy_days = [cover > .5 for cover in cloud_cover_vals]\n",
- " return np.count_nonzero(cloudy_days), cloud_cover_samples\n",
- "\n",
- "monthly_days_vals = [[monthly_cloudy_days(y, m)[0] for y in years] for m in months]\n",
- "monthly_cover_samples = [[monthly_cloudy_days(y, m)[1] for y in years] for m in months]\n",
- "\n",
- "f = figure(title='Monthly Cloudy Days',\n",
- " x_range=(1990, 2015),\n",
- " x_axis_label='Year')\n",
- "for x in range(0, len(months)):\n",
- " f.line(years, monthly_days_vals[x], legend=months_str[x], color=Palette[x])\n",
- "show(f)\n",
- "\n",
- "f = figure(title='Monthly Cloud Cover Samples',\n",
- " x_range=(1990, 2015),\n",
- " x_axis_label='Year',\n",
- " height=300)\n",
- "for x in range(0, len(months)):\n",
- " f.line(years, monthly_cover_samples[x], legend=months_str[x], color=Palette[x])\n",
- "show(f)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "On the whole, the number of cloudy days seems to reflect the trend with average cloud cover - it's actually becoming more sunny as time progresses. That said, we need to be careful in how we view this number - because there weren't as many samples in 2015 as previous years, the number of days can get thrown off. In context though, even if most days not recorded were in fact cloudy, the overall count for 2015 would still be lower than previous years.\n",
- "\n",
- "# Tracking Precipitation Chances\n",
- "\n",
- "In addition to checking cloud cover, I wanted to check precipitation data as well - what is the average precipitation chance over a month, and how many days during a month is rain likely? The thinking is that days with a high-precipitation chance will also be days in which it is cloudy or depressing."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "\n"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "def safe_precip(frame):\n",
- " if frame and 'precipProbability' in frame:\n",
- " return frame['precipProbability']\n",
- " else:\n",
- " return np.NaN\n",
- "\n",
- "def monthly_avg_precip(year, month):\n",
- " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n",
- " end=datetime(year, month + 1, 1, 12),\n",
- " freq='D', closed='left')\n",
- " precip_vals = list(map(lambda x: safe_precip(cary_forecast[x]['currently']), dates))\n",
- " precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))\n",
- " return np.nanmean(precip_vals), precip_samples\n",
- "\n",
- "monthly_avg_precip_vals = [[monthly_avg_precip(y, m)[0] for y in years] for m in months]\n",
- "\n",
- "f = figure(title='Monthly Average Precipitation Chance',\n",
- " x_range=(1990, 2015),\n",
- " x_axis_label='Year')\n",
- "for x in range(0, len(months)):\n",
- " f.line(years, monthly_avg_precip_vals[x], legend=months_str[x], color=Palette[x])\n",
- "show(f)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "As we can see from the chart, the average chance of precipitation over a month more or less stays within a band of 0 - .1 for all months over all years. This is further evidence that the past few months are no more cloudy or rainy than previous years. Like the cloud cover though, we still want to get a count of all the rainy days, in addition to the average chance. We'll define a \"rainy day\" as any day in which the chance of rain is greater than 25%."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "\n"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "\n"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- }
- ],
- "source": [
- "def monthly_rainy_days(year, month):\n",
- " dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),\n",
- " end=datetime(year, month + 1, 1, 12),\n",
- " freq='D', closed='left')\n",
- " precip_prob_vals = list(map(lambda x: safe_precip(cary_forecast[x]['currently']), dates))\n",
- " precip_prob_samples = len(list(filter(lambda x: x is not np.NaN, precip_prob_vals)))\n",
- " precip_days = [prob > .25 for prob in precip_prob_vals]\n",
- " return np.count_nonzero(precip_days), precip_prob_samples\n",
- "\n",
- "monthly_precip_days_vals = [[monthly_rainy_days(y, m)[0] for y in years] for m in months]\n",
- "monthly_precip_samples = [[monthly_rainy_days(y, m)[1] for y in years] for m in months]\n",
- "\n",
- "f = figure(title='Monthly Rainy Days',\n",
- " x_range=(1990, 2015),\n",
- " x_axis_label='Year')\n",
- "for x in range(0, len(months)):\n",
- " f.line(years, monthly_precip_days_vals[x], legend=months_str[x], color=Palette[x])\n",
- "show(f)\n",
- "\n",
- "f = figure(title='Monthly Rainy Days Samples',\n",
- " x_range=(1990, 2015),\n",
- " x_axis_label='Year',\n",
- " height=300)\n",
- "for x in range(0, len(months)):\n",
- " f.line(years, monthly_precip_samples[x], legend=months_str[x], color=Palette[x])\n",
- "show(f)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "After trying to find the number of days that are rainy, we can see that November hit its max value for rainy days in 2015. However, that value is 6, as compared to a previous maximum of 5. While it is a new record, the value isn't actually all that different. And for other months, the values are mostly in-line with the averages.\n",
- "\n",
- "# Summary and Conclusions\n",
- "\n",
- "After having looked at forecast data for Cary, it appears that the months of July - November this year in terms of weather were at worst on par with prior years, if not slightly more sunny. This seems to be a case of confirmation bias: someone complains about a string of cloudy or rainy days, and suddenly you start noticing them more.\n",
- "\n",
- "While this analysis doesn't take into account other areas of North Carolina, my initial guess would be to assume that other areas also will show similar results: nothing interesting is happening. Maybe that will be for another blog post later!\n",
- "\n",
- "Coming soon: I'll compare rain/cloud conditions in North Carolina to some other places in the U.S.!"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Generating the Forecast file\n",
- "\n",
- "The following code was generates the file that was used throughout the blog post. Please note that I'm retrieving data for other cities to use in a future blog post, only Cary data was used for this post.\n",
- "\n",
- "```python\n",
- "import pandas as pd\n",
- "from functools import reduce\n",
- "import requests\n",
- "from datetime import datetime\n",
- "\n",
- "# Coordinate data from http://itouchmap.com/latlong.html\n",
- "cary_loc = (35.79154,-78.781117)\n",
- "nyc_loc = (40.78306,-73.971249)\n",
- "seattle_loc = (47.60621,-122.332071)\n",
- "binghamton_loc = (42.098687,-75.917974)\n",
- "cities = {\n",
- " 'cary': cary_loc,\n",
- " 'nyc': nyc_loc,\n",
- " 'seattle': seattle_loc,\n",
- " 'binghamton': binghamton_loc\n",
- "}\n",
- "\n",
- "apikey = '' # My super-secret API Key\n",
- "\n",
- "def get_forecast(lat, long, date=None):\n",
- " forecast_base = \"https://api.forecast.io/forecast/\"\n",
- " if date is None:\n",
- " url = forecast_base + apikey + '/{},{}'.format(lat, long)\n",
- " else:\n",
- " epoch = int(date.timestamp())\n",
- " url = forecast_base + apikey + '/{},{},{}'.format(lat, long, epoch)\n",
- " \n",
- " return requests.get(url).json()\n",
- " \n",
- "years = range(1990,2016)\n",
- "# For datetimes, the 12 is for getting the weather at noon.\n",
- "# We're doing this over midnight because we're more concerned\n",
- "# with what people see, and people don't typically see the weather\n",
- "# at midnight.\n",
- "dt_indices = [pd.date_range(start=datetime(year, 7, 1, 12),\n",
- " end=datetime(year, 11, 30, 12))\n",
- " for year in years]\n",
- "dt_merge = reduce(lambda x, y: x.union(y), dt_indices)\n",
- "\n",
- "# Because we have to pay a little bit to use the API, we use for loops here\n",
- "# instead of a comprehension - if something breaks, we want to preserve the\n",
- "# data already retrieved\n",
- "city_forecasts = {}\n",
- "for city, loc in cities.items():\n",
- " print(\"Retrieving data for {} starting at {}\".format(city,\n",
- " datetime.now().strftime(\"%I:%M:%S %p\")))\n",
- " for dt in dt_merge:\n",
- " try:\n",
- " city_forecasts[(city, dt)] = get_forecast(*loc, dt)\n",
- " except Exception as e:\n",
- " print(e)\n",
- " city_forecasts[(city, dt)] = None\n",
- "print(\"End forecast retrieval: {}\".format(datetime.now().strftime(\"%I:%M:%S %p\")))\n",
- "\n",
- "import pickle\n",
- "pickle.dump(city_forecasts, open('city_forecasts.p', 'wb'))\n",
- "\n",
- "### Output:\n",
- "# Retrieving data for binghamton starting at 05:13:42 PM\n",
- "# Retrieving data for seattle starting at 05:30:51 PM\n",
- "# Retrieving data for nyc starting at 05:48:30 PM\n",
- "# Retrieving data for cary starting at 06:08:32 PM\n",
- "# End forecast retrieval: 06:25:21 PM\n",
- "```"
- ]
- }
- ],
- "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.5.0"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}
diff --git a/content/notebooks/2016-1-23-cloudy-in-seattle.ipynb b/content/notebooks/2016-1-23-cloudy-in-seattle.ipynb
deleted file mode 100644
index b7e2d62..0000000
--- a/content/notebooks/2016-1-23-cloudy-in-seattle.ipynb
+++ /dev/null
@@ -1,721 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {
- "collapsed": false
- },
- "outputs": [
- {
- "data": {
- "text/html": [
- " \n",
- "\n",
- "\n",
- " \n",
- "\n",
- "
My previous class in Stochastic Calculus covered a lot of interesting topics, and the important one for today
+is the Gambler's Ruin problem. If you're interested in some of the theory behind it, also make sure to check out
+random walks. The important bit is that we studied the Martingale Betting Strategy, which describes for us
+a guaranteed way to eventually make money.
+
The strategy goes like this: You are going to toss a fair coin with a friend. If you guess heads or tails correctly, you get back double the money you bet. If you guess incorrectly, you lose money. How should you bet?
+
The correct answer is that you should double your bet each time you lose. Then when you finally win, you'll be guaranteed to make back everything you lost and then $1 extra! Consider the scenario:
+
+
You bet $1, and guess incorrectly. You're 1 dollar in the hole.
+
You bet $2, and guess incorrectly. You're 3 dollars in the hole now.
+
You bet $4, and guess incorrectly. You're 7 dollars in the hole.
+
You bet $8, and guess correctly! You now get back those 8 dollars you bet, plus 8 extra for winning, for a total profit of one dollar!
+
+
Mathematically, we can prove that as long as you have unlimited money to bet, you are guaranteed to make money.
But we're all realistic people, and once you start talking about "unlimited money" eyebrows should be raised. Even still, this is an interesting strategy to investigate, and I want to apply it to the stock market. As long as we can guarantee there's a single day in which the stock goes up, we should be able to make money right? The question is just how much we have to invest to guarantee this.
+
Now it's time for the math. We'll use the following definitions:
+
+
$o_i$ = the share price at the opening of day $i$
+
$c_i$ = the share price at the close of day $i$
+
$d_i$ = the amount of money we want to invest at the beginning of day $i$
+
+
With those definitions in place, I'd like to present the formula that is guaranteed to make you money. I call it Bradlee's Investment Formula:
It might not look like much, but if you can manage to make it so that this formula holds true, you will be guaranteed to make money. The intuition behind the formula is this: The closing share price times the number of shares you have purchased ends up greater than the amount of money you invested.
+
That is, on day $n$, if you know what the closing price will be you can set up the amount of money you invest that day to guarantee you make money. I'll even teach you to figure out how much money that is! Take a look:
If you invest exactly $d_n$ that day, you'll break even. But if you can make sure the money you invest is greater than that quantity on the right (which requires that you have a crystal ball tell you the stock's closing price) you are guaranteed to make money!
On a more serious note though, the formula above tells us a couple of interesting things:
+
+
It's impossible to make money without the closing price at some point being greater than the opening price (or vice-versa if you are short selling) - there is no amount of money you can invest that will turn things in your favor.
+
Close prices of the past aren't important if you're concerned about the bottom line. While chart technicians use price history to make judgment calls, in the end, the closing price on anything other than the last day is irrelevant.
+
It's possible to make money as long as there is a single day where the closing price is greater than the opening price! You might have to invest a lot to do so, but it's possible.
+
You must make a prediction about where the stock will close at if you want to know how much to invest. That is, we can set up our investment for the day to make money if the stock goes up 1%, but if it only goes up .5% we'll still lose money.
+
It's possible the winning move is to scale back your position. Consider the scenario:
+
You invest money and the stock closes down the day .5%
+
You invest tomorrow expecting the stock to go up 1%
+
The winning investment to break even (assuming a 1% increase) is to scale back the position, since the shares you purchased at the beginning would then be profitable
So now that we've defined our investment formula,we need to tweak a couple things in order to make an investment strategy we can actually work with. There are two issues we need to address:
+
+
The formula only tells us how much to invest if we want to break even ($d_n$). If we actually want to turn a profit, we need to invest more than that, which we will refer to as the bias.
+
The formula assumes we know what the closing price will be on any given day. If we don't know this, we can still invest assuming the stock price will close at a level we choose. If the price doesn't meet this objective, we try again tomorrow! This predetermined closing price will be referred to as the expectation.
+
+
Now that we've defined our bias and expectation, we can actually build a strategy we can simulate. Much like the martingale strategy told you to bet twice your previous bet in order to make money, we've designed a system that tells us how much to bet in order to make money as well.
+
Now, let's get to the code!
+
+
+
+
+
+
+
In [1]:
+
+
+
usingQuandl
+api_key=""
+daily_investment=function(current_open,current_close,purchase_history,open_history)
+ # We're not going to safeguard against divide by 0 - that's the user's responsibility
+ t1=current_close/current_open-1
+ t2=sum(purchase_history-purchase_history*current_close./open_history)
+ returnt2/t1
+end;
+
Now, let's get some data and run a simulation! Our first test:
+
+
We'll invest 100 dollars in LMT, and expect that the stock will close up 1% every day. We'll invest $d_n$ + 10 dollars every day that we haven't turned a profit, and end the simulation once we've made a profit.
We've defined an investment strategy that can tell us how much to invest when we know what the closing position of a stock will be. We can tweak the strategy to actually make money, but plenty of work needs to be done so that we can optimize the money invested.
+
In the next post I'm going to post more information about some backtests and strategy tests on this strategy (unless of course this experiment actually produces a significant profit potential, and then I'm keeping it for myself).
The claims made in this presentation about being able to guarantee making money are intended as a joke and do not constitute investment advice of any sort.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/content/images/logo.svg b/images/logo.svg
similarity index 100%
rename from content/images/logo.svg
rename to images/logo.svg
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..2a924b1
--- /dev/null
+++ b/index.html
@@ -0,0 +1,123 @@
+
+
+
+
+
+
+
+
+
+
+ - Bradlee Speice
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
I've previously talked about crafting an Investment Formula that would guarantee making money if you could predict which direction the stock market was going to go. This is going to be the first in a series of posts trying to flesh out what an actual investment strategy based on this formula would look like.
+
But first, the formula doesn't take into account two very important things: leverage, and the number of days invested. That's why I want to set up what I'm going to call the Profitability Score.
+
The definition is going to be very simple:
+
+
$p$: Profit made once you exit the investment
+
$i$: Initial investment into the asset
+
$m$: Maximum investment in the asset
+
$l = m / i$: The maximum leverage of an investment, as the ratio of maximum invested to initial investment
Crazy, right? The score is simply the (normalized) profit you made divided by the leverage plus days invested. The $\cdot 1000$ is just to turn the number into something more reasonable - people don't like hearing something with a profitability score of .001 for example.
The formula itself is designed to be simple in principle: I like making a profit, and I want to penalize the leverage you incur and days you have to invest. Ideally, we want to have a stock that goes up all the time. However, the investment formula takes advantage of a different case: trying to profit from highly volatile assets. If we can make money when the investment only has one day up, let's do it!
+
Even so, there are two potential issues: First, stocks that trend upward will have a higher profitability score - both leverage and days invested will be 1. To protect against only investing in this trend, I can do things like taking $\log(d)$. I don't want to start biasing the scoring function until I have a practical reason to do so, so right now I'll leave it standing.
+
The second issue is how to penalize leverage and days invested relative to each other. As it currently stands, a leverage of 6x with only 1 day invested is the same as leveraging 2x with 3 days invested. In the future, I'd again want to look at making the impact of days invested smaller - I can get over an extra 3 days in the market if it means that I don't have to incur a highly leveraged position.
+
So there could be things about the scoring function we change in the future, but I want to run some actual tests before we start worrying about things like that!
This won't be an incredibly rigorous backtest, I just want to see some results from the work so far. Let's set up the simulation code again, and start looking into some random stocks. If you've read the last blog post, you can skip over the code. The only difference is that it's been ported to python to make the data-wrangling easier. Julia doesn't yet support some of the multi-index things I'm trying to do.
+
+
+
+
+
+
+
In [19]:
+
+
+
importnumpyasnp
+importpandasaspd
+importmatplotlib.pyplotasplt
+fromQuandlimportgetasqget
+%matplotlib inline
+api_key='QUJUp-dAKyo2y8DGsCv-'
+
+profitability=lambdap,i,m,d:1000*p/(m+i*d)
+
+defis_profitable(current_price,purchase_history,open_history):
+ shares=(purchase_history/open_history).sum()
+ returncurrent_price*shares>sum(purchase_history)
+
+defdaily_investment(current_open,current_close,purchase_history,open_history):
+ t1=current_close/current_open-1
+ t2=(purchase_history-purchase_history*current_close/open_history).sum()
+ returnt2/t1
+
+defsimulate_day(open_vals,close_vals,init,expected,bias):
+ invested=np.array([init])
+
+ day=1
+ profitable=is_profitable(close_vals[day-1],invested,open_vals[0:len(invested)]) \
+ oris_profitable(open_vals[day],invested,open_vals[0:len(invested)])
+
+ whilenotprofitable:
+ expected_close=open_vals[day]*expected
+ todays_purchase=daily_investment(open_vals[day],expected_close,invested,open_vals[0:day])
+ invested=np.append(invested,todays_purchase+bias)
+ # expected_profit = expected_close * (invested / open_vals[0:len(invested)]).sum() - invested.sum()
+ day+=1
+ profitable=is_profitable(close_vals[day-1],invested,open_vals[0:len(invested)]) \
+ oris_profitable(open_vals[day],invested,open_vals[0:len(invested)])
+
+ shares=(invested/open_vals[0:len(invested)]).sum()
+
+ # Make sure we can't see into the future - we know either today's close or tomorrow's open
+ # will be profitable, but we need to check which one.
+ ifis_profitable(close_vals[day-1],invested,open_vals[0:len(invested)]):
+ ending_price=close_vals[day-1]
+ else:
+ ending_price=open_vals[day]
+
+ profit=shares*ending_price-sum(invested)
+ returninvested,profit
+
+defsimulate_ts(name,start,end,initial,expected,bias):
+ ticker_info=qget(name,trim_start=start,api_key=api_key)
+ evaluation_times=ticker_info[:end].index
+
+ # Handle Google vs. YFinance data
+ if"Adjusted Close"inticker_info.columns:
+ close_column="Adjusted Close"
+ else:
+ close_column="Close"
+
+ sim={d:simulate_day(ticker_info[d:]["Open"],ticker_info[d:][close_column],
+ 100,1.02,10)fordinevaluation_times}
+ sim_series=pd.Series(sim)
+ result=pd.DataFrame()
+ result["profit"]=sim_series.apply(lambdax:x[1])
+ result["max"]=sim_series.apply(lambdax:max(x[0]))
+ result["days"]=sim_series.apply(lambdax:len(x[0]))
+ result["score"]=sim_series.apply(lambdax:profitability(x[1],x[0][0],max(x[0]),len(x[0])))
+ result["investments"]=sim_series.apply(lambdax:x[0])
+
+ returnresult
+
+defsimulate_tickers(tickers):
+ fromdatetimeimportdatetime
+ results={}
+ fortickerintickers:
+ start=datetime(2015,1,1)
+ results_df=simulate_ts(ticker,start,datetime(2016,1,1),100,1.01,10)
+ results[ticker]=results_df
+
+ returnpd.concat(list(results.values()),keys=list(results.keys()),axis=1)
+
fang_df.xs('days',axis=1,level=1).hist()
+plt.gcf().set_size_inches(18,8);
+plt.gcf().suptitle("Distribution of Days Until Profitability",fontsize=18);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
In [10]:
+
+
+
fang_df.xs('score',axis=1,level=1).plot()
+plt.gcf().set_size_inches(18,6)
+plt.gcf().suptitle("Profitability score over time",fontsize=18);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Let's think about these graphs. First, the histogram. What we like seeing is a lot of 1's - that means there were a lot of days that the stock went up and we didn't have to worry about actually implementing the strategy - we were able to close the trade at a profit.
+
Looking at the profitability score over time though is a bit more interesting. First off, stocks that are more volatile will tend to have a higher profitability score, no two ways about that. However, Netflix consistently outperformed on this metric. We know that 2015 was a good year for Netflix, so that's a (small) sign the strategy is performing as expected.
+
The final interesting note happens around the end of August 2015. Around this period, the markets were selling off in a big way due to issues in China (not unlike what's happening now). Even so, all of the FANG stocks saw an uptick in profitability around this time. This is another sign that the strategy being developed performs better during periods of volatility, rather than from riding markets up or down.
cyclic_df.xs('days',axis=1,level=1).hist()
+plt.gcf().set_size_inches(18,8);
+plt.gcf().suptitle("Distribution of Days Until Profitability",fontsize=18);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
In [15]:
+
+
+
cyclic_df.xs('score',axis=1,level=1).plot()
+plt.gcf().set_size_inches(18,6)
+plt.gcf().suptitle("Profitability score over time",fontsize=18);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Some more interesting results come from this as well. First off, US Steel (X) has a much smoother distribution of days until profitability - it doesn't have a huge number of values at 1 and then drop off. Intuitively, we're not terribly large fans of this, we want a stock to go up! However, on the profitability score it is the only serious contender to Netflix.
+
Second, we see the same trend around August - the algorithm performs well in volatile markets.
+
For a final test, let's try some biotech and ETFs!
biotech_df.xs('days',axis=1,level=1).hist()
+plt.gcf().set_size_inches(18,8);
+plt.gcf().suptitle("Distribution of Days Until Profitability",fontsize=18);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
In [23]:
+
+
+
biotech_df.xs('score',axis=1,level=1).plot()
+plt.gcf().set_size_inches(18,6)
+plt.gcf().suptitle("Profitability score over time",fontsize=18);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
In this example, we don't see a whole lot of interesting things: the scores are all fairly close together with notable exceptions in late August, and mid-October.
+
What is interesting is that during the volatile period, the ETF's performed significantly better than the stocks did in terms of profitability. The leveraged ETF (BIB) performed far above anyone else, and it appears that indeed, it is most profitable during volatile periods. Even so, it was far more likely to take multiple days to give a return. Its count of 1-day investments trails the other ETF and both stocks by a decent margin.
+
And consider me an OCD freak, but I just really like Celgene's distribution - it looks nice and smooth.
So far I'm really enjoying playing with this strategy - there's a lot of depth here to understand, though the preliminary results seem to indicate that it profits mostly from taking the other side of a volatile trade. I'd be interested to run results later on data from January - It's been a particularly volatile start to the year so it would be neat to see whether this strategy would work then.
+
For the next post, I want to start playing with some of the parameters: How do the bias and expected close influence the process? The values have been fairly conservative so far, it will be interesting to see how the simulations respond afterward.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/publishconf.py b/publishconf.py
deleted file mode 100644
index 3fa05f0..0000000
--- a/publishconf.py
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*- #
-from __future__ import unicode_literals
-
-# This file is only used if you use `make publish` or
-# explicitly specify it as your config file.
-
-import os
-import sys
-sys.path.append(os.curdir)
-from pelicanconf import *
-
-SITEURL = 'https://bspeice.github.io'
-RELATIVE_URLS = False
-
-FEED_ALL_ATOM = 'feeds/all.atom.xml'
-CATEGORY_FEED_ATOM = 'feeds/%s.atom.xml'
-
-DELETE_OUTPUT_DIRECTORY = True
-
-# Following items are often useful when publishing
-
-#DISQUS_SITENAME = ""
-#GOOGLE_ANALYTICS = ""
diff --git a/tag/algorithmic-trading.html b/tag/algorithmic-trading.html
new file mode 100644
index 0000000..35718a5
--- /dev/null
+++ b/tag/algorithmic-trading.html
@@ -0,0 +1,110 @@
+
+
+
+
+
+
+
+
+
+
+ algorithmic-trading - Bradlee Speice
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Pursuant to attending a graduate school studying Financial Engineering, I've been a fan of the Mad Money TV show featuring the bombastic Jim Cramer. One of the things that he's said is that you shouldn't use the futures to predict where the stock market is going to go. But he says it often enough, I've begun to wonder - who is he trying to convince?
+
It makes sense that because futures on things like the S&P 500 are traded continuously, they would price in market information before the stock market opens. So is Cramer right to be convinced that strategies based on the futures are a poor idea? I wanted to test it out.
+
The first question is where to get the future's data. I've been part of Seeking Alpha for a bit, and they publish the Wall Street Breakfast newsletter which contains daily future's returns as of 6:20 AM EST. I'd be interested in using that data to see if we can actually make some money.
We're going to define two HTML parsing classes - one to get the article URL's from a page, and one to get the actual data from each article.
+
+
+
+
+
+
+
In [2]:
+
+
+
classArticleListParser(HTMLParser):
+ """Given a web page with articles on it, parse out the article links"""
+
+ articles=[]
+
+ defhandle_starttag(self,tag,attrs):
+ #if tag == 'div' and ("id", "author_articles_wrapper") in attrs:
+ # self.fetch_links = True
+ iftag=='a'and('class','dashboard_article_link')inattrs:
+ href=list(filter(lambdax:x[0]=='href',attrs))[0][1]
+ self.articles.append(href)
+
+base_url="http://seekingalpha.com/author/wall-street-breakfast/articles"
+article_page_urls=[base_url]+[base_url+'/{}'.format(i)foriinrange(2,20)]
+
+global_articles=[]
+forpageinarticle_page_urls:
+ # We need to switch the user agent, as SA blocks the standard requests agent
+ articles_html=requests.get(page,
+ headers={"User-Agent":"Wget/1.13.4"})
+ parser=ArticleListParser()
+ parser.feed(articles_html.text)
+ global_articles+=(parser.articles)
+
+
+
+
+
+
+
+
+
+
In [3]:
+
+
+
classArticleReturnParser(HTMLParser):
+ "Given an article, parse out the futures returns in it"
+
+ record_font_tags=False
+ in_font_tag=False
+ counter=0
+ # data = {} # See __init__
+
+ def__init__(self,*args,**kwargs):
+ super().__init__(*args,**kwargs)
+ self.data={}
+
+ defhandle_starttag(self,tag,attrs):
+ iftag=='span'and('itemprop','datePublished')inattrs:
+ date_string=list(filter(lambdax:x[0]=='content',attrs))[0][1]
+ date=dtparser.parse(date_string)
+ self.data['date']=date
+
+ self.in_font_tag=tag=='font'
+
+ defsafe_float(self,string):
+ try:
+ returnfloat(string[:-1])/100
+ exceptValueError:
+ returnnp.NaN
+
+ defhandle_data(self,content):
+ ifnotself.record_font_tagsand"Futures at 6"incontent:
+ self.record_font_tags=True
+
+ ifself.record_font_tagsandself.in_font_tag:
+ ifself.counter==0:
+ self.data['DOW']=self.safe_float(content)
+ elifself.counter==1:
+ self.data['S&P']=self.safe_float(content)
+ elifself.counter==2:
+ self.data['NASDAQ']=self.safe_float(content)
+ elifself.counter==3:
+ self.data['Crude']=self.safe_float(content)
+ elifself.counter==4:
+ self.data['Gold']=self.safe_float(content)
+
+ self.counter+=1
+
+ defhandle_endtag(self,tag):
+ self.in_font_tag=False
+
+defretrieve_data(url):
+ sa="http://seekingalpha.com"
+ article_html=requests.get(sa+url,
+ headers={"User-Agent":"Wget/1.13.4"})
+ parser=ArticleReturnParser()
+ parser.feed(article_html.text)
+ parser.data.update({"url":url})
+ parser.data.update({"text":article_html.text})
+ returnparser.data
+
+# This copy **MUST** be in place. I'm not sure why,
+# as you'd think that the data being returned would already
+# represent a different memory location. Even so, it blows up
+# if you don't do this.
+article_list=list(set(global_articles))
+article_data=[copy(retrieve_data(url))forurlinarticle_list]
+# If there's an issue downloading the article, drop it.
+article_df=pd.DataFrame.from_dict(article_data).dropna()
+
Now that we have the futures data, we're going to compare across 4 different indices - the S&P 500 index, Dow Jones Industrial, Russell 2000, and NASDAQ 100. Let's get the data off of Quandl to make things easier!
+
+
+
+
+
+
+
In [4]:
+
+
+
# article_df is sorted by date, so we get the first row.
+start_date=article_df.sort_values(by='date').iloc[0]['date']-relativedelta(days=1)
+SPY=Quandl.get("GOOG/NYSE_SPY",trim_start=start_date)
+DJIA=Quandl.get("GOOG/AMS_DIA",trim_start=start_date)
+RUSS=Quandl.get("GOOG/AMEX_IWM",trim_start=start_date)
+NASDAQ=Quandl.get("GOOG/EPA_QQQ",trim_start=start_date)
+
There are two types of tests I want to determine: How accurate each futures category is at predicting the index's opening change over the close before, and predicting the index's daily return.
+
Let's first calculate how good each future is at predicting the opening return over the previous day. I expect that the futures will be more than 50% accurate, since the information is recorded 3 hours before the markets open.
+
+
+
+
+
+
+
In [5]:
+
+
+
defcalculate_opening_ret(frame):
+ # I'm not a huge fan of the appending for loop,
+ # but it's a bit verbose for a comprehension
+ data={}
+ foriinrange(1,len(frame)):
+ date=frame.iloc[i].name
+ prior_close=frame.iloc[i-1]['Close']
+ open_val=frame.iloc[i]['Open']
+ data[date]=(open_val-prior_close)/prior_close
+
+ returndata
+
+SPY_open_ret=calculate_opening_ret(SPY)
+DJIA_open_ret=calculate_opening_ret(DJIA)
+RUSS_open_ret=calculate_opening_ret(RUSS)
+NASDAQ_open_ret=calculate_opening_ret(NASDAQ)
+
+defsigns_match(list_1,list_2):
+ # This is a surprisingly difficult task - we have to match
+ # up the dates in order to check if opening returns actually match
+ index_dict_dt={key.to_datetime():list_2[key]forkeyinlist_2.keys()}
+
+ matches=[]
+ forrowinlist_1.iterrows():
+ row_dt=row[1][1]
+ row_value=row[1][0]
+ index_dt=datetime(row_dt.year,row_dt.month,row_dt.day)
+ ifindex_dtinlist_2:
+ index_value=list_2[index_dt]
+ if(row_value>0andindex_value>0)or \
+ (row_value<0andindex_value<0)or \
+ (row_value==0andindex_value==0):
+ matches+=[1]
+ else:
+ matches+=[0]
+ #print("{}".format(list_2[index_dt]))
+ returnmatches
+
+
+prediction_dict={}
+matches_dict={}
+count_dict={}
+index_dict={"SPY":SPY_open_ret,"DJIA":DJIA_open_ret,"RUSS":RUSS_open_ret,"NASDAQ":NASDAQ_open_ret}
+indices=["SPY","DJIA","RUSS","NASDAQ"]
+futures=["Crude","Gold","DOW","NASDAQ","S&P"]
+forindexinindices:
+ matches_dict[index]={future:signs_match(article_df[[future,'date']],
+ index_dict[index])forfutureinfutures}
+ count_dict[index]={future:len(matches_dict[index][future])forfutureinfutures}
+ prediction_dict[index]={future:np.mean(matches_dict[index][future])
+ forfutureinfutures}
+print("Articles Checked: ")
+print(pd.DataFrame.from_dict(count_dict))
+print()
+print("Prediction Accuracy:")
+print(pd.DataFrame.from_dict(prediction_dict))
+
Both DOW and NASDAQ futures are pretty bad at predicting their actual market openings
+
NASDAQ and Dow are fairly unpredictable; Russell 2000 and S&P are very predictable
+
Gold is a poor predictor in general - intuitively Gold should move inverse to the market, but it appears to be about as accurate as a coin flip.
+
+
All said though it appears that futures data is important for determining market direction for both the S&P 500 and Russell 2000. Cramer is half-right: futures data isn't very helpful for the Dow and NASDAQ indices, but is great for the S&P and Russell indices.
Well, it appears that the futures data is terrible at predicting market close. NASDAQ predicting NASDAQ is the most interesting data point, but 63% accuracy isn't accurate enough to make money consistently.
The data bears out very close to what I expected would happen:
+
+
Futures data is more accurate than a coin flip for predicting openings, which makes sense since it is recorded only 3 hours before the actual opening
+
Futures data is about as acccurate as a coin flip for predicting closings, which means there is no money to be made in trying to predict the market direction for the day given the futures data.
+
+
In summary:
+
+
Cramer is half right: Futures data is not good for predicting the market open of the Dow and NASDAQ indices. Contrary to Cramer though, it is very good for predicting the S&P and Russell indices - we can achieve an accuracy slightly over 80% for each.
+
Making money in the market is hard. We can't just go to the futures and treat them as an oracle for where the market will close.
+
+
I hope you've enjoyed this, I quite enjoyed taking a deep dive in the analytics this way. I'll be posting more soon!