diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
deleted file mode 100644
index 7159a0b..0000000
--- a/.devcontainer/Dockerfile
+++ /dev/null
@@ -1,6 +0,0 @@
-FROM mcr.microsoft.com/vscode/devcontainers/ruby:0-2.7-bullseye
-
-RUN wget https://github.com/errata-ai/vale/releases/download/v2.21.0/vale_2.21.0_Linux_64-bit.tar.gz -O /tmp/vale.tar.gz \
- && cd /usr/local/bin \
- && tar xf /tmp/vale.tar.gz \
- && rm /tmp/vale.tar.gz
\ No newline at end of file
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 1d206de..45f0ca2 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,13 +1,19 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.245.0/containers/ruby
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/typescript-node
{
- "name": "Ruby",
- "build": {
- "dockerfile": "Dockerfile"
- },
+ "name": "Node.js & TypeScript",
+ "image": "mcr.microsoft.com/devcontainers/typescript-node:1-22-bookworm",
"runArgs": ["--userns=keep-id"],
-
- "remoteUser": "vscode",
- "containerUser": "vscode",
- "workspaceMount": "source=${localWorkspaceFolder},target=/workspaces/${localWorkspaceFolderBasename},type=bind,Z"
+ "containerUser": "node",
+ "containerEnv": {
+ "HOME": "/home/node"
+ },
+ "customizations": {
+ "vscode": {
+ "extensions": [
+ "ChrisChinchilla.vale-vscode"
+ ]
+ }
+ },
+ "onCreateCommand": "bash -c 'mkdir -p ~/.local/bin && wget -qO- https://github.com/errata-ai/vale/releases/download/v2.21.0/vale_2.21.0_Linux_64-bit.tar.gz | tar xz -C ~/.local/bin'"
}
diff --git a/.gitignore b/.gitignore
index 508b6b2..deef8ab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,21 @@
-_site/
-.swp
-.sass-cache/
-.jekyll-metadata
-.bundle/
-vendor/
-.styles/
-.vscode/
+# Dependencies
+/node_modules
+
+# Production
+/build
+
+# Generated files
+.docusaurus
+.cache-loader
+
+# Misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+.styles
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
diff --git a/.vale.ini b/.vale.ini
index 777f626..13dfdfe 100644
--- a/.vale.ini
+++ b/.vale.ini
@@ -2,6 +2,6 @@ StylesPath = .styles
MinAlertLevel = suggestion
Packages = Microsoft, write-good
-[*]
+[*.{md,mdx}]
BasedOnStyles = Vale, Microsoft, write-good
write-good.E-Prime = NO
\ No newline at end of file
diff --git a/404.html b/404.html
deleted file mode 100644
index 3969180..0000000
--- a/404.html
+++ /dev/null
@@ -1,24 +0,0 @@
----
-layout: page
----
-
-
-
-
-
404
-
-
Page not found :(
-
The requested page could not be found.
-
diff --git a/CNAME b/CNAME
deleted file mode 100644
index 8875e7a..0000000
--- a/CNAME
+++ /dev/null
@@ -1 +0,0 @@
-speice.io
diff --git a/Gemfile b/Gemfile
deleted file mode 100644
index 3031ef3..0000000
--- a/Gemfile
+++ /dev/null
@@ -1,29 +0,0 @@
-source "https://rubygems.org"
-
-# Hello! This is where you manage which Jekyll version is used to run.
-# When you want to use a different version, change it below, save the
-# file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
-#
-# bundle exec jekyll serve
-#
-# This will help ensure the proper Jekyll version is running.
-# Happy Jekylling!
-gem "jekyll", "~> 3.8.3"
-
-gem "texture"
-
-# If you want to use GitHub Pages, remove the "gem "jekyll"" above and
-# uncomment the line below. To upgrade, run `bundle update github-pages`.
-# gem "github-pages", group: :jekyll_plugins
-
-# If you have any plugins, put them here!
-group :jekyll_plugins do
- gem "jekyll-feed", "~> 0.6"
- gem "jekyll-remote-theme"
-end
-
-# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
-gem "tzinfo-data", platforms: [:mingw, :mswin, :x64_mingw, :jruby]
-
-# Performance-booster for watching directories on Windows
-gem "wdm", "~> 0.1.0" if Gem.win_platform?
diff --git a/Gemfile.lock b/Gemfile.lock
deleted file mode 100644
index 310c738..0000000
--- a/Gemfile.lock
+++ /dev/null
@@ -1,78 +0,0 @@
-GEM
- remote: https://rubygems.org/
- specs:
- addressable (2.7.0)
- public_suffix (>= 2.0.2, < 5.0)
- colorator (1.1.0)
- concurrent-ruby (1.1.6)
- em-websocket (0.5.1)
- eventmachine (>= 0.12.9)
- http_parser.rb (~> 0.6.0)
- eventmachine (1.2.7)
- ffi (1.12.2)
- forwardable-extended (2.6.0)
- http_parser.rb (0.6.0)
- i18n (0.9.5)
- concurrent-ruby (~> 1.0)
- jekyll (3.8.6)
- addressable (~> 2.4)
- colorator (~> 1.0)
- em-websocket (~> 0.5)
- i18n (~> 0.7)
- jekyll-sass-converter (~> 1.0)
- jekyll-watch (~> 2.0)
- kramdown (~> 1.14)
- liquid (~> 4.0)
- mercenary (~> 0.3.3)
- pathutil (~> 0.9)
- rouge (>= 1.7, < 4)
- safe_yaml (~> 1.0)
- jekyll-feed (0.13.0)
- jekyll (>= 3.7, < 5.0)
- jekyll-remote-theme (0.4.2)
- addressable (~> 2.0)
- jekyll (>= 3.5, < 5.0)
- jekyll-sass-converter (>= 1.0, <= 3.0.0, != 2.0.0)
- rubyzip (>= 1.3.0, < 3.0)
- jekyll-sass-converter (1.5.2)
- sass (~> 3.4)
- jekyll-seo-tag (2.6.1)
- jekyll (>= 3.3, < 5.0)
- jekyll-watch (2.2.1)
- listen (~> 3.0)
- kramdown (1.17.0)
- liquid (4.0.3)
- listen (3.2.1)
- rb-fsevent (~> 0.10, >= 0.10.3)
- rb-inotify (~> 0.9, >= 0.9.10)
- mercenary (0.3.6)
- pathutil (0.16.2)
- forwardable-extended (~> 2.6)
- public_suffix (4.0.4)
- rb-fsevent (0.10.3)
- rb-inotify (0.10.1)
- ffi (~> 1.0)
- rouge (3.17.0)
- rubyzip (2.3.0)
- safe_yaml (1.0.5)
- sass (3.7.4)
- sass-listen (~> 4.0.0)
- sass-listen (4.0.0)
- rb-fsevent (~> 0.9, >= 0.9.4)
- rb-inotify (~> 0.9, >= 0.9.7)
- texture (0.3)
- jekyll (~> 3.7)
- jekyll-seo-tag (~> 2.1)
-
-PLATFORMS
- ruby
-
-DEPENDENCIES
- jekyll (~> 3.8.3)
- jekyll-feed (~> 0.6)
- jekyll-remote-theme
- texture
- tzinfo-data
-
-BUNDLED WITH
- 2.1.4
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..0c6c2c2
--- /dev/null
+++ b/README.md
@@ -0,0 +1,41 @@
+# Website
+
+This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
+
+### Installation
+
+```
+$ yarn
+```
+
+### Local Development
+
+```
+$ yarn start
+```
+
+This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
+
+### Build
+
+```
+$ yarn build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.
+
+### Deployment
+
+Using SSH:
+
+```
+$ USE_SSH=true yarn deploy
+```
+
+Not using SSH:
+
+```
+$ GIT_USER= yarn deploy
+```
+
+If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.
diff --git a/_config.yml b/_config.yml
deleted file mode 100644
index 9f9c8cd..0000000
--- a/_config.yml
+++ /dev/null
@@ -1,44 +0,0 @@
-# Welcome to Jekyll!
-#
-# This config file is meant for settings that affect your whole blog, values
-# which you are expected to set up once and rarely edit after that. If you find
-# yourself editing this file very often, consider using Jekyll's data files
-# feature for the data you need to update frequently.
-#
-# For technical reasons, this file is *NOT* reloaded automatically when you use
-# 'bundle exec jekyll serve'. If you change this file, please restart the server process.
-
-# Site settings
-# These are used to personalize your new site. If you look in the HTML files,
-# you will see them accessed via {{ site.title }}, {{ site.email }}, and so on.
-# You can create any custom variable you would like, and they will be accessible
-# in the templates via {{ site.myvariable }}.
-title: speice.io
-description: The Old Speice Guy
-email: bradlee@speice.io
-baseurl: "" # the subpath of your site, e.g. /blog
-url: "https://speice.io/" # the base hostname & protocol for your site, e.g. http://example.com
-github_username: bspeice
-
-# Build settings
-markdown: kramdown
-# theme: texture
-remote_theme: thelehhman/texture
-plugins:
- - jekyll-feed
- - jekyll-remote-theme
-
-include: [_pages]
-permalink: /:year/:month/:title.html
-
-# Exclude from processing.
-# The following items will not be processed, by default. Create a custom list
-# to override the default setting.
-# exclude:
-# - Gemfile
-# - Gemfile.lock
-# - node_modules
-# - vendor/bundle/
-# - vendor/cache/
-# - vendor/gems/
-# - vendor/ruby/
diff --git a/_includes/footer.html b/_includes/footer.html
deleted file mode 100644
index 4d3c143..0000000
--- a/_includes/footer.html
+++ /dev/null
@@ -1,23 +0,0 @@
-{% if page.layout == 'post' %}
-{% comment %}Thanks to https://www.bytedude.com/jekyll-previous-and-next-posts/{% endcomment %}
-
\ No newline at end of file
diff --git a/_includes/page_header.html b/_includes/page_header.html
deleted file mode 100644
index e486090..0000000
--- a/_includes/page_header.html
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
{{ site.title }}
-
{{ site.description }}
-
- {%- if site.texture.social_links.github -%}
-
- {%- endif -%}
- {%- if site.texture.social_links.linkedIn -%}
-
- {%- endif -%}
- {%- if site.texture.social_links.twitter -%}
-
- {%- endif -%}
-
-
\ No newline at end of file
diff --git a/_pages/about.md b/_pages/about.md
deleted file mode 100644
index 3f45159..0000000
--- a/_pages/about.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-layout: page
-title: About
-permalink: /about/
----
-
-Developer currently living in New York City.
-
-Best ways to get in contact:
-
-- Email: [bradlee@speice.io](mailto:bradlee@speice.io)
-- Github: [bspeice](https://github.com/bspeice)
-- LinkedIn: [bradleespeice](https://www.linkedin.com/in/bradleespeice/)
diff --git a/assets/css/fonts.css b/assets/css/fonts.css
deleted file mode 100644
index e07ecfc..0000000
--- a/assets/css/fonts.css
+++ /dev/null
@@ -1,15 +0,0 @@
-@font-face {
- font-family: 'JetBrains Mono';
- src: url('/assets/font/JetBrainsMono-Regular.woff2') format('woff2'),
- url('/assets/font/JetBrainsMono-Regular.woff') format('woff');
- font-weight: normal;
- font-style: normal;
-}
-
-@font-face {
- font-family: 'Lato';
- src: url('/assets/font/lato-regular-webfont.woff2') format('woff2'),
- url('/assets/font/lato-regular-webfont.woff') format('woff');
- font-weight: normal;
- font-style: normal;
-}
\ No newline at end of file
diff --git a/assets/css/style.scss b/assets/css/style.scss
deleted file mode 100644
index ea280e2..0000000
--- a/assets/css/style.scss
+++ /dev/null
@@ -1,119 +0,0 @@
----
----
-
-// Import the theme rules
-@import "theme";
-
-body {
- max-width: 100%;
- overflow-x: hidden;
- font-family: 'Lato', sans-serif;
-}
-
-.navbar {
- color: $gray;
-}
-
-.separator {
- margin-right: .45rem;
- margin-left: .25rem;
- color: #000;
- &:after {
- content: '\00a0/';
- }
-}
-
-header {
- padding-top: 80px;
- padding-bottom: 0;
-};
-
-header h1,h2 {
- color: #000;
-}
-
-.post-description {
- color: #555;
-}
-
-.post-container a {
- color: #555;
- border-bottom-color: $gray;
- border-bottom-style: dotted;
- border-bottom-width: 1px;
-
- position: relative;
- display: inline-block;
- padding: 1px 1px;
- transition: color ease 0.3s;
-
- &::after {
- content: '';
- position: absolute;
- z-index: -1;
- width: 100%;
- height: 0%;
- left: 0;
- bottom: 0;
- background-color: $gray;
- transition: all ease 0.3s;
- }
-
- &:hover {
- color: #fff;
- border-bottom-style: solid;
- &::after {
- height: 100%;
- }
- }
-}
-
-body pre {
- font-size: 15px;
-}
-
-pre.highlight, code {
- font-family: 'JetBrains Mono', monospace;
-}
-
-div.highlighter-rouge {
- // Default theme uses `width: 100vw`, which while cool, does cause the page
- // to exceed screen width and trigger horizontal scrolling. No bueno.
- width: 99vw;
-}
-
-.post-date {
- // On the front page, make sure titles don't force wrapping the date box content
- text-align: right;
- white-space: nowrap;
-}
-
-blockquote {
- color: #555;
- right: 100px;
- margin-left: 0;
- padding-left: 1.8rem;
- border-left: 5px solid $gray;
-}
-
-.post-nav {
- /* Insert your custom styling here. Example:
-
- font-size: 14px;
- */
- display: flex;
- margin-top: 1em;
- margin-bottom: 1em;
-}
-.post-nav div {
- /* flex-grow, flex-shrink, flex-basis */
- flex: 1 1 0;
-}
-.post-nav-next {
- text-align: right;
-}
-
-th, td {
- border-bottom: 1px solid $gray;
- padding: 0.75em;
-}
diff --git a/assets/font/JetBrainsMono-Regular.woff b/assets/font/JetBrainsMono-Regular.woff
deleted file mode 100644
index dc1d85f..0000000
Binary files a/assets/font/JetBrainsMono-Regular.woff and /dev/null differ
diff --git a/assets/font/JetBrainsMono-Regular.woff2 b/assets/font/JetBrainsMono-Regular.woff2
deleted file mode 100644
index fdf95dd..0000000
Binary files a/assets/font/JetBrainsMono-Regular.woff2 and /dev/null differ
diff --git a/assets/font/lato-regular-webfont.woff b/assets/font/lato-regular-webfont.woff
deleted file mode 100644
index 4fe6d31..0000000
Binary files a/assets/font/lato-regular-webfont.woff and /dev/null differ
diff --git a/assets/font/lato-regular-webfont.woff2 b/assets/font/lato-regular-webfont.woff2
deleted file mode 100644
index f7c4d26..0000000
Binary files a/assets/font/lato-regular-webfont.woff2 and /dev/null differ
diff --git a/babel.config.js b/babel.config.js
new file mode 100644
index 0000000..e00595d
--- /dev/null
+++ b/babel.config.js
@@ -0,0 +1,3 @@
+module.exports = {
+ presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
+};
diff --git a/blog/2015-11-14-welcome/_article.md b/blog/2015-11-14-welcome/_article.md
new file mode 100644
index 0000000..29157af
--- /dev/null
+++ b/blog/2015-11-14-welcome/_article.md
@@ -0,0 +1,59 @@
+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/blog/2015-11-14-welcome/_notebook.ipynb b/blog/2015-11-14-welcome/_notebook.ipynb
new file mode 100644
index 0000000..2fab0a3
--- /dev/null
+++ b/blog/2015-11-14-welcome/_notebook.ipynb
@@ -0,0 +1,293 @@
+{
+ "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/blog/2015-11-14-welcome/_notebook.md b/blog/2015-11-14-welcome/_notebook.md
new file mode 100644
index 0000000..53262c7
--- /dev/null
+++ b/blog/2015-11-14-welcome/_notebook.md
@@ -0,0 +1,173 @@
+# Trading Competition Optimization
+
+### Goal: Max return given maximum Sharpe and Drawdown
+
+
+```python
+from IPython.display import display
+import Quandl
+from datetime import datetime, timedelta
+
+tickers = ['XOM', 'CVX', 'CLB', 'OXY', 'SLB']
+market_ticker = 'GOOG/NYSE_VOO'
+lookback = 30
+d_col = 'Close'
+
+data = {tick: Quandl.get('YAHOO/{}'.format(tick))[-lookback:] for tick in tickers}
+market = Quandl.get(market_ticker)
+```
+
+# Calculating the Return
+We first want to know how much each ticker returned over the prior period.
+
+
+```python
+returns = {tick: data[tick][d_col].pct_change() for tick in tickers}
+
+display({tick: returns[tick].mean() for tick in tickers})
+```
+
+
+ {'CLB': -0.0016320202164526894,
+ 'CVX': 0.0010319531629488911,
+ 'OXY': 0.00093418904454400551,
+ 'SLB': 0.00098431254720448159,
+ 'XOM': 0.00044165797556096868}
+
+
+# Calculating the Sharpe ratio
+Sharpe: ${R - R_M \over \sigma}$
+
+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.
+
+
+```python
+market_returns = market.pct_change()
+
+sharpe = lambda ret: (ret.mean() - market_returns[d_col].mean()) / ret.std()
+sharpes = {tick: sharpe(returns[tick]) for tick in tickers}
+
+display(sharpes)
+```
+
+
+ {'CLB': -0.10578734457846127,
+ 'CVX': 0.027303529817677398,
+ 'OXY': 0.022622210057414487,
+ 'SLB': 0.026950946344858676,
+ 'XOM': -0.0053519259698605499}
+
+
+# Calculating the drawdown
+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?
+
+
+```python
+drawdown = lambda ret: ret.abs().max()
+drawdowns = {tick: drawdown(returns[tick]) for tick in tickers}
+
+display(drawdowns)
+```
+
+
+ {'CLB': 0.043551495607375035,
+ 'CVX': 0.044894389686214398,
+ 'OXY': 0.051424517867144637,
+ 'SLB': 0.034774627850375328,
+ 'XOM': 0.035851524605672758}
+
+
+# Performing the optimization
+
+$\begin{align}
+max\ \ & \mu \cdot \omega\\
+s.t.\ \ & \vec{1} \omega = 1\\
+& \vec{S} \omega \ge s\\
+& \vec{D} \cdot | \omega | \le d\\
+& \left|\omega\right| \le l\\
+\end{align}$
+
+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.
+
+
+```python
+import numpy as np
+from scipy.optimize import minimize
+
+#sharpe_limit = .1
+drawdown_limit = .05
+leverage = 250
+
+# Use the map so we can guarantee we maintain the correct order
+# sharpe_a = np.array(list(map(lambda tick: sharpes[tick], tickers))) * -1 # So we can write as upper-bound
+dd_a = np.array(list(map(lambda tick: drawdowns[tick], tickers)))
+returns_a = np.array(list(map(lambda tick: returns[tick].mean(), tickers))) # Because minimizing
+
+meets_sharpe = lambda x: sum(abs(x) * sharpe_a) - sharpe_limit
+def meets_dd(x):
+ portfolio = sum(abs(x))
+ if portfolio < .1:
+ # If there are no stocks in the portfolio,
+ # we can accidentally induce division by 0,
+ # or division by something small enough to cause infinity
+ return 0
+
+ return drawdown_limit - sum(abs(x) * dd_a) / sum(abs(x))
+
+is_portfolio = lambda x: sum(x) - 1
+
+def within_leverage(x):
+ return leverage - sum(abs(x))
+
+objective = lambda x: sum(x * returns_a) * -1 # Because we're minimizing
+bounds = ((None, None),) * len(tickers)
+x = np.zeros(len(tickers))
+
+constraints = [
+ {
+ 'type': 'eq',
+ 'fun': is_portfolio
+ }, {
+ 'type': 'ineq',
+ 'fun': within_leverage
+ #}, {
+ # 'type': 'ineq',
+ # 'fun': meets_sharpe
+ }, {
+ 'type': 'ineq',
+ 'fun': meets_dd
+ }
+]
+
+optimal = minimize(objective, x, bounds=bounds, constraints=constraints,
+ options={'maxiter': 500})
+
+# Optimization time!
+display(optimal.message)
+
+display("Holdings: {}".format(list(zip(tickers, optimal.x))))
+
+expected_return = optimal.fun * -100 # multiply by -100 to scale, and compensate for minimizing
+display("Expected Return: {:.3f}%".format(expected_return))
+
+expected_drawdown = sum(abs(optimal.x) * dd_a) / sum(abs(optimal.x)) * 100
+display("Expected Max Drawdown: {0:.2f}%".format(expected_drawdown))
+
+# TODO: Calculate expected Sharpe
+```
+
+
+ 'Optimization terminated successfully.'
+
+
+
+ "Holdings: [('XOM', 5.8337945679814904), ('CVX', 42.935064321851307), ('CLB', -124.5), ('OXY', 36.790387773552119), ('SLB', 39.940753336615096)]"
+
+
+
+ 'Expected Return: 32.375%'
+
+
+
+ 'Expected Max Drawdown: 4.34%'
+
diff --git a/blog/2015-11-14-welcome/index.mdx b/blog/2015-11-14-welcome/index.mdx
new file mode 100644
index 0000000..041b910
--- /dev/null
+++ b/blog/2015-11-14-welcome/index.mdx
@@ -0,0 +1,222 @@
+---
+slug: 2015/11/welcome
+title: Welcome, and an algorithm
+date: 2015-11-19 12:00:00
+last_update:
+ date: 2015-12-05 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+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](https://en.wikipedia.org/wiki/Sharpe_ratio)
+- 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:
+
+| Statistic | Value |
+|--------------------|--------|
+| Max Return | 74.1% |
+| Min Return | -97.4% |
+| Average Return | -.1% |
+| Std Dev of Returns | 19.6% |
+
+---
+
+## Trading Competition Optimization
+
+**Goal: Max return given maximum Sharpe and Drawdown**
+
+
+```python
+from IPython.display import display
+import Quandl
+from datetime import datetime, timedelta
+
+tickers = ['XOM', 'CVX', 'CLB', 'OXY', 'SLB']
+market_ticker = 'GOOG/NYSE_VOO'
+lookback = 30
+d_col = 'Close'
+
+data = {tick: Quandl.get('YAHOO/{}'.format(tick))[-lookback:] for tick in tickers}
+market = Quandl.get(market_ticker)
+```
+
+## Calculating the Return
+
+We first want to know how much each ticker returned over the prior period.
+
+```python
+returns = {tick: data[tick][d_col].pct_change() for tick in tickers}
+
+display({tick: returns[tick].mean() for tick in tickers})
+```
+
+```
+ {'CLB': -0.0016320202164526894,
+ 'CVX': 0.0010319531629488911,
+ 'OXY': 0.00093418904454400551,
+ 'SLB': 0.00098431254720448159,
+ 'XOM': 0.00044165797556096868}
+```
+
+## Calculating the Sharpe ratio
+
+Sharpe: ${R - R_M \over \sigma}$
+
+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.
+
+
+```python
+market_returns = market.pct_change()
+
+sharpe = lambda ret: (ret.mean() - market_returns[d_col].mean()) / ret.std()
+sharpes = {tick: sharpe(returns[tick]) for tick in tickers}
+
+display(sharpes)
+```
+
+```
+ {'CLB': -0.10578734457846127,
+ 'CVX': 0.027303529817677398,
+ 'OXY': 0.022622210057414487,
+ 'SLB': 0.026950946344858676,
+ 'XOM': -0.0053519259698605499}
+```
+
+## Calculating the drawdown
+
+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?
+
+
+```python
+drawdown = lambda ret: ret.abs().max()
+drawdowns = {tick: drawdown(returns[tick]) for tick in tickers}
+
+display(drawdowns)
+```
+
+```
+ {'CLB': 0.043551495607375035,
+ 'CVX': 0.044894389686214398,
+ 'OXY': 0.051424517867144637,
+ 'SLB': 0.034774627850375328,
+ 'XOM': 0.035851524605672758}
+```
+
+# Performing the optimization
+
+$$
+\begin{align*}
+max\ \ & \mu \cdot \omega\\
+s.t.\ \ & \vec{1} \omega = 1\\
+& \vec{S} \omega \ge s\\
+& \vec{D} \cdot | \omega | \le d\\
+& \left|\omega\right| \le l\\
+\end{align*}
+$$
+
+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.
+
+```python
+import numpy as np
+from scipy.optimize import minimize
+
+#sharpe_limit = .1
+drawdown_limit = .05
+leverage = 250
+
+# Use the map so we can guarantee we maintain the correct order
+
+# So we can write as upper-bound
+# sharpe_a = np.array(list(map(lambda tick: sharpes[tick], tickers))) * -1
+dd_a = np.array(list(map(lambda tick: drawdowns[tick], tickers)))
+
+# Because minimizing
+returns_a = np.array(list(map(lambda tick: returns[tick].mean(), tickers)))
+
+meets_sharpe = lambda x: sum(abs(x) * sharpe_a) - sharpe_limit
+def meets_dd(x):
+ portfolio = sum(abs(x))
+ if portfolio < .1:
+ # If there are no stocks in the portfolio,
+ # we can accidentally induce division by 0,
+ # or division by something small enough to cause infinity
+ return 0
+
+ return drawdown_limit - sum(abs(x) * dd_a) / sum(abs(x))
+
+is_portfolio = lambda x: sum(x) - 1
+
+def within_leverage(x):
+ return leverage - sum(abs(x))
+
+objective = lambda x: sum(x * returns_a) * -1 # Because we're minimizing
+bounds = ((None, None),) * len(tickers)
+x = np.zeros(len(tickers))
+
+constraints = [
+ {
+ 'type': 'eq',
+ 'fun': is_portfolio
+ }, {
+ 'type': 'ineq',
+ 'fun': within_leverage
+ #}, {
+ # 'type': 'ineq',
+ # 'fun': meets_sharpe
+ }, {
+ 'type': 'ineq',
+ 'fun': meets_dd
+ }
+]
+
+optimal = minimize(objective, x, bounds=bounds, constraints=constraints,
+ options={'maxiter': 500})
+
+# Optimization time!
+display(optimal.message)
+
+display("Holdings: {}".format(list(zip(tickers, optimal.x))))
+
+# multiply by -100 to scale, and compensate for minimizing
+expected_return = optimal.fun * -100
+display("Expected Return: {:.3f}%".format(expected_return))
+
+expected_drawdown = sum(abs(optimal.x) * dd_a) / sum(abs(optimal.x)) * 100
+display("Expected Max Drawdown: {0:.2f}%".format(expected_drawdown))
+
+# TODO: Calculate expected Sharpe
+```
+
+```
+ 'Optimization terminated successfully.'
+ "Holdings: [('XOM', 5.8337945679814904),
+ ('CVX', 42.935064321851307),
+ ('CLB', -124.5),
+ ('OXY', 36.790387773552119),
+ ('SLB', 39.940753336615096)]"
+ 'Expected Return: 32.375%'
+ 'Expected Max Drawdown: 4.34%'
+```
+
\ No newline at end of file
diff --git a/blog/2015-11-27-autocallable/_article.md b/blog/2015-11-27-autocallable/_article.md
new file mode 100644
index 0000000..53e1337
--- /dev/null
+++ b/blog/2015-11-27-autocallable/_article.md
@@ -0,0 +1,21 @@
+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/blog/2015-11-27-autocallable/_notebook.ipynb b/blog/2015-11-27-autocallable/_notebook.ipynb
new file mode 100644
index 0000000..8e4038b
--- /dev/null
+++ b/blog/2015-11-27-autocallable/_notebook.ipynb
@@ -0,0 +1,3974 @@
+{
+ "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": "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",
+ "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/blog/2015-11-27-autocallable/_notebook.md b/blog/2015-11-27-autocallable/_notebook.md
new file mode 100644
index 0000000..3beb3ab
--- /dev/null
+++ b/blog/2015-11-27-autocallable/_notebook.md
@@ -0,0 +1,3543 @@
+```julia
+using Gadfly
+```
+
+# Athena/Phoenix Simulation
+
+## Underlying simulation
+
+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:
+
+- $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)
+- $\sigma$ = $\sigma_{imp}$ = 15.62% (from VIX implied volatility)
+
+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
+
+
+```julia
+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
+```
+
+
+
+
+ 5
+
+
+
+### Defining the simulation
+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.
+
+
+```julia
+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
+ for i=1:(n-1)
+ motion[:,i+1] = motion[:,i] .* exp((μ - σ^2/2)*t) .* exp(sqrt(t) * σ .* randn(m))
+ end
+
+ return motion
+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 = []
+ for i=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 = []
+ for i = 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;
+```
+
+### Example simulation
+
+Let's go ahead and run a sample simulation to see what the functions got us!
+
+
+```julia
+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)
+```
+
+
+
+
+
+
+
+
+
+
+### Computing the term structure
+
+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.
+
+
+```julia
+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]) for i=1:years]
+end;
+```
+
+### Illustrating the term structure
+
+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]
+```
+
+
+```julia
+# 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
+
+
+### The full underlying simulation
+
+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.
+
+
+```julia
+full_motion = ones(5) * S0
+full_term = vcat(term[1], forward_yield)
+for i=1:T
+ μ = (full_term[i] - 1 - q)
+ year_motion = simulate_gbm(full_motion[:,end], μ, σ, 1, n)
+ full_motion = hcat(full_motion, year_motion)
+end
+
+display_motion(full_motion, T)
+```
+
+
+
+
+
+
+
+
+
+
+### Final simulation
+
+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.
+
+
+```julia
+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
+ for i=1:T
+ μ = (forward[i] - 1 - q)
+ year_motion = simulate_gbm(final_motion[:,end], μ, σ, 1, n)
+ final_motion = hcat(final_motion, year_motion)
+ end
+ return final_motion
+end
+
+tic()
+full_simulation(S0, T, n, m, term)
+time = toq()
+@printf("Time to run simulation: %.2fs", time)
+```
+
+ Time to run simulation: 5.34s
+
+## Athena Simulation
+
+Now that we've defined our underlying simulation, let's actually try and price an Athena note. Athena has the following characteristics:
+
+- Automatically called if the underlying is above the **call barrier** at observation
+- Accelerated coupon paid if the underlying is above the **call barrier** at observation
+ - The coupon paid is $c \cdot i$ with $i$ as the current year, and $c$ the coupon rate
+- Principle protection up until a **protection barrier** at observation; All principle at risk if this barrier not met
+- Observed yearly
+
+
+```julia
+call_barrier = S0
+strike = S0
+protection_barrier = S0 * .6
+coupon = nominal * .07
+
+price_athena = function(initial_price, year_prices, call_barrier,
+ protection_barrier, coupon, forward_structure)
+
+ total_coupons = 0
+
+ t = length(year_prices)
+
+ for i=1:t
+ price = year_prices[i]
+ if price ≥ call_barrier
+ return (nominal + coupon*i) * exp((prod(forward_structure[i:end])-1)*(t-i))
+ end
+ end
+
+ # We've reached maturity, time to check capital protection
+ if year_prices[end] > protection_barrier
+ return nominal
+ else
+ put = (strike - year_prices[end]) / strike
+ return nominal*(1-put)
+ end
+end
+
+forward_structure = forward_term(term)
+price_function = (year_prices) -> price_athena(S0, year_prices,
+ call_barrier, protection_barrier, coupon, forward_structure)
+
+athena = function()
+ year_indexes = [n*i for i=1:T]
+ motion = full_simulation(S0, T, n, m, term)
+ payoffs = [price_function(motion[i, year_indexes]) for i=1:m]
+ return mean(payoffs)
+end
+
+mean_payoffs = zeros(num_simulations)
+for i=1:num_simulations
+ tic()
+ mean_payoffs[i] = athena()
+ 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 Athena note: \$%.2f, notional: \$%.2f", pv, nominal)
+```
+
+ Mean of simulation 1: $103.2805; Simulation time: 5.59s
+ Mean of simulation 2: $103.3796; Simulation time: 5.05s
+ Mean of simulation 3: $103.4752; Simulation time: 5.18s
+ Mean of simulation 4: $103.4099; Simulation time: 5.37s
+ Mean of simulation 5: $103.3260; Simulation time: 5.32s
+ Mean over 5 simulations: 103.37421610015554
+ Present value of Athena note: $95.00, notional: $100.00
+
+## Phoenix without Memory Simulation
+
+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](https://www.rbccm.com/usstructurednotes/file-780079.pdf)):
+
+- 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)
+
+
+```julia
+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)
+
+ for i=1:t
+ price = year_prices[i]
+ if price ≥ call_barrier
+ return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))
+ elseif price ≥ 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
+ if year_prices[end] > protection_barrier
+ return nominal + total_coupons
+ else
+ put = (strike - year_prices[end]) / strike
+ return nominal*(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*i for i=1:T]
+ motion = full_simulation(S0, T, n, m, term)
+ payoffs = [price_function(motion[i, year_indexes]) for i=1:m]
+ return mean(payoffs)
+end
+
+mean_payoffs = zeros(num_simulations)
+for i=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
+
+## Phoenix with Memory Simulation
+
+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.
+
+You can also find an example [here](https://www.rbccm.com/usstructurednotes/file-781232.pdf).
+
+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
+
+
+```julia
+call_barrier = S0
+coupon_barrier = S0 * .8
+protection_barrier = S0 * .6
+coupon = nominal * .07
+
+price_phoenix_with_memory = function(initial_price, year_prices, call_barrier,
+ coupon_barrier, protection_barrier, coupon, forward_structure)
+
+ last_coupon = 0
+ total_coupons = 0
+
+ t = length(year_prices)
+
+ for i=1:t
+ price = year_prices[i]
+ if price > call_barrier
+ return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))
+ elseif price > coupon_barrier
+ ####################################################################
+ # The only difference between with/without memory is the below lines
+ memory_coupons = (i - last_coupon) * coupon
+ last_coupon = i
+ total_coupons = total_coupons * exp(forward_structure[i]-1) + memory_coupons
+ ####################################################################
+ else
+ total_coupons *= exp(forward_structure[i]-1)
+ end
+ end
+
+ # We've reached maturity, time to check capital protection
+ if year_prices[end] > protection_barrier
+ return nominal + total_coupons
+ else
+ put = (strike - year_prices[end]) / strike
+ return nominal*(1-put)
+ end
+end
+
+forward_structure = forward_term(term)
+price_function = (year_prices) -> price_phoenix_with_memory(S0, year_prices,
+ call_barrier, coupon_barrier, protection_barrier, coupon, forward_structure)
+
+phoenix_with_memory = function()
+ year_indexes = [n*i for i=1:T]
+ motion = full_simulation(S0, T, n, m, term)
+ payoffs = [price_function(motion[i, year_indexes]) for i=1:m]
+ return mean(payoffs)
+end
+
+mean_payoffs = zeros(num_simulations)
+for i=1:num_simulations
+ tic()
+ mean_payoffs[i] = phoenix_with_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 with memory note: \$%.2f", pv)
+```
+
+ Mean of simulation 1: $108.8612; Simulation time: 5.89s
+ Mean of simulation 2: $109.0226; Simulation time: 5.90s
+ Mean of simulation 3: $108.9175; Simulation time: 5.92s
+ Mean of simulation 4: $108.9426; Simulation time: 5.94s
+ Mean of simulation 5: $108.8087; Simulation time: 6.06s
+ Mean over 5 simulations: 108.91052564051816
+ Present value of Phoenix with memory note: $100.09
diff --git a/blog/2015-11-27-autocallable/_notebook_files/_notebook_12_0.png b/blog/2015-11-27-autocallable/_notebook_files/_notebook_12_0.png
new file mode 100644
index 0000000..ae800fb
Binary files /dev/null and b/blog/2015-11-27-autocallable/_notebook_files/_notebook_12_0.png differ
diff --git a/blog/2015-11-27-autocallable/_notebook_files/_notebook_12_0.svg b/blog/2015-11-27-autocallable/_notebook_files/_notebook_12_0.svg
new file mode 100644
index 0000000..fab9413
--- /dev/null
+++ b/blog/2015-11-27-autocallable/_notebook_files/_notebook_12_0.svg
@@ -0,0 +1,121 @@
+
+
diff --git a/blog/2015-11-27-autocallable/_notebook_files/_notebook_6_0.png b/blog/2015-11-27-autocallable/_notebook_files/_notebook_6_0.png
new file mode 100644
index 0000000..a77f46e
Binary files /dev/null and b/blog/2015-11-27-autocallable/_notebook_files/_notebook_6_0.png differ
diff --git a/blog/2015-11-27-autocallable/_notebook_files/_notebook_6_0.svg b/blog/2015-11-27-autocallable/_notebook_files/_notebook_6_0.svg
new file mode 100644
index 0000000..918535a
--- /dev/null
+++ b/blog/2015-11-27-autocallable/_notebook_files/_notebook_6_0.svg
@@ -0,0 +1,121 @@
+
+
diff --git a/blog/2015-11-27-autocallable/index.mdx b/blog/2015-11-27-autocallable/index.mdx
new file mode 100644
index 0000000..ec8cac1
--- /dev/null
+++ b/blog/2015-11-27-autocallable/index.mdx
@@ -0,0 +1,473 @@
+---
+slug: 2015/11/autocallable
+title: Autocallable Bonds
+date: 2015-11-27 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+For a final project, my group was tasked with understanding three exotic derivatives: The Athena, Phoenix without memory, and Phoenix with memory autocallable products.
+
+
+
+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.
+
+---
+
+```julia
+using Gadfly
+```
+
+# Athena/Phoenix Simulation
+
+## Underlying simulation
+
+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:
+
+- $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)
+- $\sigma$ = $\sigma_{imp}$ = 15.62% (from VIX implied volatility)
+
+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
+
+
+```julia
+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
+```
+
+### Defining the simulation
+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.
+
+
+```julia
+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
+ for i=1:(n-1)
+ motion[:,i+1] = motion[:,i] .* exp((μ - σ^2/2)*t) .* exp(sqrt(t) * σ .* randn(m))
+ end
+
+ return motion
+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 = []
+ for i=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 = []
+ for i = 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;
+```
+
+### Example simulation
+
+Let's go ahead and run a sample simulation to see what the functions got us!
+
+
+```julia
+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)
+```
+
+![](./_notebook_files/_notebook_6_0.svg)
+
+### Computing the term structure
+
+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.
+
+```julia
+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]) for i=1:years]
+end;
+```
+
+### Illustrating the term structure
+
+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]
+```
+
+```julia
+# 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
+```
+
+### The full underlying simulation
+
+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.
+
+
+```julia
+full_motion = ones(5) * S0
+full_term = vcat(term[1], forward_yield)
+for i=1:T
+ μ = (full_term[i] - 1 - q)
+ year_motion = simulate_gbm(full_motion[:,end], μ, σ, 1, n)
+ full_motion = hcat(full_motion, year_motion)
+end
+
+display_motion(full_motion, T)
+```
+
+![](./_notebook_files/_notebook_12_0.svg)
+
+### Final simulation
+
+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.
+
+
+```julia
+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
+ for i=1:T
+ μ = (forward[i] - 1 - q)
+ year_motion = simulate_gbm(final_motion[:,end], μ, σ, 1, n)
+ final_motion = hcat(final_motion, year_motion)
+ end
+ return final_motion
+end
+
+tic()
+full_simulation(S0, T, n, m, term)
+time = toq()
+@printf("Time to run simulation: %.2fs", time)
+```
+
+```
+ Time to run simulation: 5.34s
+```
+
+## Athena Simulation
+
+Now that we've defined our underlying simulation, let's actually try and price an Athena note. Athena has the following characteristics:
+
+- Automatically called if the underlying is above the **call barrier** at observation
+- Accelerated coupon paid if the underlying is above the **call barrier** at observation
+ - The coupon paid is $c \cdot i$ with $i$ as the current year, and $c$ the coupon rate
+- Principle protection up until a **protection barrier** at observation; All principle at risk if this barrier not met
+- Observed yearly
+
+```julia
+call_barrier = S0
+strike = S0
+protection_barrier = S0 * .6
+coupon = nominal * .07
+
+price_athena = function(initial_price, year_prices, call_barrier,
+ protection_barrier, coupon, forward_structure)
+
+ total_coupons = 0
+
+ t = length(year_prices)
+
+ for i=1:t
+ price = year_prices[i]
+ if price ≥ call_barrier
+ return (nominal + coupon*i) * exp((prod(forward_structure[i:end])-1)*(t-i))
+ end
+ end
+
+ # We've reached maturity, time to check capital protection
+ if year_prices[end] > protection_barrier
+ return nominal
+ else
+ put = (strike - year_prices[end]) / strike
+ return nominal*(1-put)
+ end
+end
+
+forward_structure = forward_term(term)
+price_function = (year_prices) -> price_athena(S0, year_prices,
+ call_barrier, protection_barrier, coupon, forward_structure)
+
+athena = function()
+ year_indexes = [n*i for i=1:T]
+ motion = full_simulation(S0, T, n, m, term)
+ payoffs = [price_function(motion[i, year_indexes]) for i=1:m]
+ return mean(payoffs)
+end
+
+mean_payoffs = zeros(num_simulations)
+for i=1:num_simulations
+ tic()
+ mean_payoffs[i] = athena()
+ 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 Athena note: \$%.2f, notional: \$%.2f", pv, nominal)
+```
+
+```
+ Mean of simulation 1: $103.2805; Simulation time: 5.59s
+ Mean of simulation 2: $103.3796; Simulation time: 5.05s
+ Mean of simulation 3: $103.4752; Simulation time: 5.18s
+ Mean of simulation 4: $103.4099; Simulation time: 5.37s
+ Mean of simulation 5: $103.3260; Simulation time: 5.32s
+ Mean over 5 simulations: 103.37421610015554
+ Present value of Athena note: $95.00, notional: $100.00
+```
+
+## Phoenix without Memory Simulation
+
+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](https://www.rbccm.com/usstructurednotes/file-780079.pdf)):
+
+- 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)
+
+
+```julia
+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)
+
+ for i=1:t
+ price = year_prices[i]
+ if price ≥ call_barrier
+ return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))
+ elseif price ≥ 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
+ if year_prices[end] > protection_barrier
+ return nominal + total_coupons
+ else
+ put = (strike - year_prices[end]) / strike
+ return nominal*(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*i for i=1:T]
+ motion = full_simulation(S0, T, n, m, term)
+ payoffs = [price_function(motion[i, year_indexes]) for i=1:m]
+ return mean(payoffs)
+end
+
+mean_payoffs = zeros(num_simulations)
+for i=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
+```
+
+## Phoenix with Memory Simulation
+
+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.
+
+You can also find an example [here](https://www.rbccm.com/usstructurednotes/file-781232.pdf).
+
+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
+
+
+```julia
+call_barrier = S0
+coupon_barrier = S0 * .8
+protection_barrier = S0 * .6
+coupon = nominal * .07
+
+price_phoenix_with_memory = function(initial_price, year_prices, call_barrier,
+ coupon_barrier, protection_barrier, coupon, forward_structure)
+
+ last_coupon = 0
+ total_coupons = 0
+
+ t = length(year_prices)
+
+ for i=1:t
+ price = year_prices[i]
+ if price > call_barrier
+ return (nominal + coupon + total_coupons)*exp((prod(forward_structure[i:end])-1)*(t-i))
+ elseif price > coupon_barrier
+ ####################################################################
+ # The only difference between with/without memory is the below lines
+ memory_coupons = (i - last_coupon) * coupon
+ last_coupon = i
+ total_coupons = total_coupons * exp(forward_structure[i]-1) + memory_coupons
+ ####################################################################
+ else
+ total_coupons *= exp(forward_structure[i]-1)
+ end
+ end
+
+ # We've reached maturity, time to check capital protection
+ if year_prices[end] > protection_barrier
+ return nominal + total_coupons
+ else
+ put = (strike - year_prices[end]) / strike
+ return nominal*(1-put)
+ end
+end
+
+forward_structure = forward_term(term)
+price_function = (year_prices) -> price_phoenix_with_memory(S0, year_prices,
+ call_barrier, coupon_barrier, protection_barrier, coupon, forward_structure)
+
+phoenix_with_memory = function()
+ year_indexes = [n*i for i=1:T]
+ motion = full_simulation(S0, T, n, m, term)
+ payoffs = [price_function(motion[i, year_indexes]) for i=1:m]
+ return mean(payoffs)
+end
+
+mean_payoffs = zeros(num_simulations)
+for i=1:num_simulations
+ tic()
+ mean_payoffs[i] = phoenix_with_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 with memory note: \$%.2f", pv)
+```
+
+```
+ Mean of simulation 1: $108.8612; Simulation time: 5.89s
+ Mean of simulation 2: $109.0226; Simulation time: 5.90s
+ Mean of simulation 3: $108.9175; Simulation time: 5.92s
+ Mean of simulation 4: $108.9426; Simulation time: 5.94s
+ Mean of simulation 5: $108.8087; Simulation time: 6.06s
+ Mean over 5 simulations: 108.91052564051816
+ Present value of Phoenix with memory note: $100.09
+```
\ No newline at end of file
diff --git a/blog/2015-12-26-testing-cramer/_article.md b/blog/2015-12-26-testing-cramer/_article.md
new file mode 100644
index 0000000..6320112
--- /dev/null
+++ b/blog/2015-12-26-testing-cramer/_article.md
@@ -0,0 +1,16 @@
+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/blog/2015-12-26-testing-cramer/_notebook.ipynb b/blog/2015-12-26-testing-cramer/_notebook.ipynb
new file mode 100644
index 0000000..02a7b5b
--- /dev/null
+++ b/blog/2015-12-26-testing-cramer/_notebook.ipynb
@@ -0,0 +1,428 @@
+{
+ "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/blog/2015-12-26-testing-cramer/_notebook.md b/blog/2015-12-26-testing-cramer/_notebook.md
new file mode 100644
index 0000000..d8e0ffa
--- /dev/null
+++ b/blog/2015-12-26-testing-cramer/_notebook.md
@@ -0,0 +1,329 @@
+```python
+import requests
+import pandas as pd
+import numpy as np
+from dateutil import parser as dtparser
+from dateutil.relativedelta import relativedelta
+from datetime import datetime
+from html.parser import HTMLParser
+from copy import copy
+import Quandl
+```
+
+# Testing Cramer
+
+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?
+
+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][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.
+
+First though, let's get the data:
+
+# Downloading Futures data from Seeking Alpha
+
+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.
+
+[1]: http://www.cnbc.com/mad-money/
+[2]: http://seekingalpha.com/
+[3]: http://seekingalpha.com/author/wall-street-breakfast?s=wall-street-breakfast
+
+
+```python
+class ArticleListParser(HTMLParser):
+ """Given a web page with articles on it, parse out the article links"""
+
+ articles = []
+
+ def handle_starttag(self, tag, attrs):
+ #if tag == 'div' and ("id", "author_articles_wrapper") in attrs:
+ # self.fetch_links = True
+ if tag == 'a' and ('class', 'dashboard_article_link') in attrs:
+ href = list(filter(lambda x: 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) for i in range(2, 20)]
+
+global_articles = []
+for page in article_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)
+```
+
+
+```python
+class ArticleReturnParser(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 = {}
+
+ def handle_starttag(self, tag, attrs):
+ if tag == 'span' and ('itemprop', 'datePublished') in attrs:
+ date_string = list(filter(lambda x: x[0] == 'content', attrs))[0][1]
+ date = dtparser.parse(date_string)
+ self.data['date'] = date
+
+ self.in_font_tag = tag == 'font'
+
+ def safe_float(self, string):
+ try:
+ return float(string[:-1]) / 100
+ except ValueError:
+ return np.NaN
+
+ def handle_data(self, content):
+ if not self.record_font_tags and "Futures at 6" in content:
+ self.record_font_tags = True
+
+ if self.record_font_tags and self.in_font_tag:
+ if self.counter == 0:
+ self.data['DOW'] = self.safe_float(content)
+ elif self.counter == 1:
+ self.data['S&P'] = self.safe_float(content)
+ elif self.counter == 2:
+ self.data['NASDAQ'] = self.safe_float(content)
+ elif self.counter == 3:
+ self.data['Crude'] = self.safe_float(content)
+ elif self.counter == 4:
+ self.data['Gold'] = self.safe_float(content)
+
+ self.counter += 1
+
+ def handle_endtag(self, tag):
+ self.in_font_tag = False
+
+def retrieve_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})
+ return parser.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)) for url in article_list]
+# If there's an issue downloading the article, drop it.
+article_df = pd.DataFrame.from_dict(article_data).dropna()
+```
+
+# Fetching the Returns data
+
+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!
+
+
+```python
+# 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)
+```
+
+# Running the Comparison
+
+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.
+
+
+```python
+def calculate_opening_ret(frame):
+ # I'm not a huge fan of the appending for loop,
+ # but it's a bit verbose for a comprehension
+ data = {}
+ for i in range(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
+
+ return data
+
+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)
+
+def signs_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] for key in list_2.keys()}
+
+ matches = []
+ for row in list_1.iterrows():
+ row_dt = row[1][1]
+ row_value = row[1][0]
+ index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)
+ if index_dt in list_2:
+ index_value = list_2[index_dt]
+ if (row_value > 0 and index_value > 0) or \
+ (row_value < 0 and index_value < 0) or \
+ (row_value == 0 and index_value == 0):
+ matches += [1]
+ else:
+ matches += [0]
+ #print("{}".format(list_2[index_dt]))
+ return matches
+
+
+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"]
+for index in indices:
+ matches_dict[index] = {future: signs_match(article_df[[future, 'date']],
+ index_dict[index]) for future in futures}
+ count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}
+ prediction_dict[index] = {future: np.mean(matches_dict[index][future])
+ for future in futures}
+print("Articles Checked: ")
+print(pd.DataFrame.from_dict(count_dict))
+print()
+print("Prediction Accuracy:")
+print(pd.DataFrame.from_dict(prediction_dict))
+```
+
+ Articles Checked:
+ DJIA NASDAQ RUSS SPY
+ Crude 268 268 271 271
+ DOW 268 268 271 271
+ Gold 268 268 271 271
+ NASDAQ 268 268 271 271
+ S&P 268 268 271 271
+
+ Prediction Accuracy:
+ DJIA NASDAQ RUSS SPY
+ Crude 0.544776 0.522388 0.601476 0.590406
+ DOW 0.611940 0.604478 0.804428 0.841328
+ Gold 0.462687 0.455224 0.464945 0.476015
+ NASDAQ 0.615672 0.608209 0.797048 0.830258
+ S&P 0.604478 0.597015 0.811808 0.848708
+
+
+This data is very interesting. Some insights:
+
+- 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.
+
+# The next step - Predicting the close
+
+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:
+
+
+```python
+def calculate_closing_ret(frame):
+ # I'm not a huge fan of the appending for loop,
+ # but it's a bit verbose for a comprehension
+ data = {}
+ for i in range(0, len(frame)):
+ date = frame.iloc[i].name
+ open_val = frame.iloc[i]['Open']
+ close_val = frame.iloc[i]['Close']
+ data[date] = (close_val - open_val) / open_val
+
+ return data
+
+SPY_close_ret = calculate_closing_ret(SPY)
+DJIA_close_ret = calculate_closing_ret(DJIA)
+RUSS_close_ret = calculate_closing_ret(RUSS)
+NASDAQ_close_ret = calculate_closing_ret(NASDAQ)
+
+def signs_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] for key in list_2.keys()}
+
+ matches = []
+ for row in list_1.iterrows():
+ row_dt = row[1][1]
+ row_value = row[1][0]
+ index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)
+ if index_dt in list_2:
+ index_value = list_2[index_dt]
+ if (row_value > 0 and index_value > 0) or \
+ (row_value < 0 and index_value < 0) or \
+ (row_value == 0 and index_value == 0):
+ matches += [1]
+ else:
+ matches += [0]
+ #print("{}".format(list_2[index_dt]))
+ return matches
+
+
+matches_dict = {}
+count_dict = {}
+prediction_dict = {}
+index_dict = {"SPY": SPY_close_ret, "DJIA": DJIA_close_ret,
+ "RUSS": RUSS_close_ret, "NASDAQ": NASDAQ_close_ret}
+indices = ["SPY", "DJIA", "RUSS", "NASDAQ"]
+futures = ["Crude", "Gold", "DOW", "NASDAQ", "S&P"]
+for index in indices:
+ matches_dict[index] = {future: signs_match(article_df[[future, 'date']],
+ index_dict[index]) for future in futures}
+ count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}
+ prediction_dict[index] = {future: np.mean(matches_dict[index][future])
+ for future in futures}
+
+print("Articles Checked:")
+print(pd.DataFrame.from_dict(count_dict))
+print()
+print("Prediction Accuracy:")
+print(pd.DataFrame.from_dict(prediction_dict))
+```
+
+ Articles Checked:
+ DJIA NASDAQ RUSS SPY
+ Crude 268 268 271 271
+ DOW 268 268 271 271
+ Gold 268 268 271 271
+ NASDAQ 268 268 271 271
+ S&P 268 268 271 271
+
+ Prediction Accuracy:
+ DJIA NASDAQ RUSS SPY
+ Crude 0.533582 0.529851 0.501845 0.542435
+ DOW 0.589552 0.608209 0.535055 0.535055
+ Gold 0.455224 0.451493 0.483395 0.512915
+ NASDAQ 0.582090 0.626866 0.531365 0.538745
+ S&P 0.585821 0.608209 0.535055 0.535055
+
+
+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.
+
+# Final sentiments
+
+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!
diff --git a/blog/2015-12-26-testing-cramer/index.mdx b/blog/2015-12-26-testing-cramer/index.mdx
new file mode 100644
index 0000000..ccd6461
--- /dev/null
+++ b/blog/2015-12-26-testing-cramer/index.mdx
@@ -0,0 +1,327 @@
+---
+slug: 2015/12/testing-cramer
+title: Testing Cramer
+date: 2015-12-26 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+Pursuant to attending a graduate school studying Financial Engineering, I've been a fan of the [Mad Money][1] 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][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.
+
+First though, let's get the data:
+
+## Downloading Futures data from Seeking Alpha
+
+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.
+
+[1]: http://www.cnbc.com/mad-money/
+[2]: http://seekingalpha.com/
+[3]: http://seekingalpha.com/author/wall-street-breakfast?s=wall-street-breakfast
+
+
+```python
+class ArticleListParser(HTMLParser):
+ """Given a web page with articles on it, parse out the article links"""
+
+ articles = []
+
+ def handle_starttag(self, tag, attrs):
+ #if tag == 'div' and ("id", "author_articles_wrapper") in attrs:
+ # self.fetch_links = True
+ if tag == 'a' and ('class', 'dashboard_article_link') in attrs:
+ href = list(filter(lambda x: 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) for i in range(2, 20)]
+
+global_articles = []
+for page in article_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)
+```
+
+
+```python
+class ArticleReturnParser(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 = {}
+
+ def handle_starttag(self, tag, attrs):
+ if tag == 'span' and ('itemprop', 'datePublished') in attrs:
+ date_string = list(filter(lambda x: x[0] == 'content', attrs))[0][1]
+ date = dtparser.parse(date_string)
+ self.data['date'] = date
+
+ self.in_font_tag = tag == 'font'
+
+ def safe_float(self, string):
+ try:
+ return float(string[:-1]) / 100
+ except ValueError:
+ return np.NaN
+
+ def handle_data(self, content):
+ if not self.record_font_tags and "Futures at 6" in content:
+ self.record_font_tags = True
+
+ if self.record_font_tags and self.in_font_tag:
+ if self.counter == 0:
+ self.data['DOW'] = self.safe_float(content)
+ elif self.counter == 1:
+ self.data['S&P'] = self.safe_float(content)
+ elif self.counter == 2:
+ self.data['NASDAQ'] = self.safe_float(content)
+ elif self.counter == 3:
+ self.data['Crude'] = self.safe_float(content)
+ elif self.counter == 4:
+ self.data['Gold'] = self.safe_float(content)
+
+ self.counter += 1
+
+ def handle_endtag(self, tag):
+ self.in_font_tag = False
+
+def retrieve_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})
+ return parser.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)) for url in article_list]
+# If there's an issue downloading the article, drop it.
+article_df = pd.DataFrame.from_dict(article_data).dropna()
+```
+
+## Fetching the Returns data
+
+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!
+
+
+```python
+# 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)
+```
+
+## Running the Comparison
+
+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.
+
+
+```python
+def calculate_opening_ret(frame):
+ # I'm not a huge fan of the appending for loop,
+ # but it's a bit verbose for a comprehension
+ data = {}
+ for i in range(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
+
+ return data
+
+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)
+
+def signs_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] for key in list_2.keys()}
+
+ matches = []
+ for row in list_1.iterrows():
+ row_dt = row[1][1]
+ row_value = row[1][0]
+ index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)
+ if index_dt in list_2:
+ index_value = list_2[index_dt]
+ if (row_value > 0 and index_value > 0) or \
+ (row_value < 0 and index_value < 0) or \
+ (row_value == 0 and index_value == 0):
+ matches += [1]
+ else:
+ matches += [0]
+ #print("{}".format(list_2[index_dt]))
+ return matches
+
+
+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"]
+for index in indices:
+ matches_dict[index] = {future: signs_match(article_df[[future, 'date']],
+ index_dict[index]) for future in futures}
+ count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}
+ prediction_dict[index] = {future: np.mean(matches_dict[index][future])
+ for future in futures}
+print("Articles Checked: ")
+print(pd.DataFrame.from_dict(count_dict))
+print()
+print("Prediction Accuracy:")
+print(pd.DataFrame.from_dict(prediction_dict))
+```
+
+```
+ Articles Checked:
+ DJIA NASDAQ RUSS SPY
+ Crude 268 268 271 271
+ DOW 268 268 271 271
+ Gold 268 268 271 271
+ NASDAQ 268 268 271 271
+ S&P 268 268 271 271
+
+ Prediction Accuracy:
+ DJIA NASDAQ RUSS SPY
+ Crude 0.544776 0.522388 0.601476 0.590406
+ DOW 0.611940 0.604478 0.804428 0.841328
+ Gold 0.462687 0.455224 0.464945 0.476015
+ NASDAQ 0.615672 0.608209 0.797048 0.830258
+ S&P 0.604478 0.597015 0.811808 0.848708
+```
+
+This data is very interesting. Some insights:
+
+- 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.
+
+## The next step - Predicting the close
+
+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:
+
+
+```python
+def calculate_closing_ret(frame):
+ # I'm not a huge fan of the appending for loop,
+ # but it's a bit verbose for a comprehension
+ data = {}
+ for i in range(0, len(frame)):
+ date = frame.iloc[i].name
+ open_val = frame.iloc[i]['Open']
+ close_val = frame.iloc[i]['Close']
+ data[date] = (close_val - open_val) / open_val
+
+ return data
+
+SPY_close_ret = calculate_closing_ret(SPY)
+DJIA_close_ret = calculate_closing_ret(DJIA)
+RUSS_close_ret = calculate_closing_ret(RUSS)
+NASDAQ_close_ret = calculate_closing_ret(NASDAQ)
+
+def signs_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] for key in list_2.keys()}
+
+ matches = []
+ for row in list_1.iterrows():
+ row_dt = row[1][1]
+ row_value = row[1][0]
+ index_dt = datetime(row_dt.year, row_dt.month, row_dt.day)
+ if index_dt in list_2:
+ index_value = list_2[index_dt]
+ if (row_value > 0 and index_value > 0) or \
+ (row_value < 0 and index_value < 0) or \
+ (row_value == 0 and index_value == 0):
+ matches += [1]
+ else:
+ matches += [0]
+ #print("{}".format(list_2[index_dt]))
+ return matches
+
+
+matches_dict = {}
+count_dict = {}
+prediction_dict = {}
+index_dict = {"SPY": SPY_close_ret, "DJIA": DJIA_close_ret,
+ "RUSS": RUSS_close_ret, "NASDAQ": NASDAQ_close_ret}
+indices = ["SPY", "DJIA", "RUSS", "NASDAQ"]
+futures = ["Crude", "Gold", "DOW", "NASDAQ", "S&P"]
+for index in indices:
+ matches_dict[index] = {future: signs_match(article_df[[future, 'date']],
+ index_dict[index]) for future in futures}
+ count_dict[index] = {future: len(matches_dict[index][future]) for future in futures}
+ prediction_dict[index] = {future: np.mean(matches_dict[index][future])
+ for future in futures}
+
+print("Articles Checked:")
+print(pd.DataFrame.from_dict(count_dict))
+print()
+print("Prediction Accuracy:")
+print(pd.DataFrame.from_dict(prediction_dict))
+```
+
+```
+ Articles Checked:
+ DJIA NASDAQ RUSS SPY
+ Crude 268 268 271 271
+ DOW 268 268 271 271
+ Gold 268 268 271 271
+ NASDAQ 268 268 271 271
+ S&P 268 268 271 271
+
+ Prediction Accuracy:
+ DJIA NASDAQ RUSS SPY
+ Crude 0.533582 0.529851 0.501845 0.542435
+ DOW 0.589552 0.608209 0.535055 0.535055
+ Gold 0.455224 0.451493 0.483395 0.512915
+ NASDAQ 0.582090 0.626866 0.531365 0.538745
+ S&P 0.585821 0.608209 0.535055 0.535055
+```
+
+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.
+
+## Final sentiments
+
+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!
diff --git a/blog/2016-01-01-complaining-about-the-weather/1.png b/blog/2016-01-01-complaining-about-the-weather/1.png
new file mode 100644
index 0000000..012aadb
Binary files /dev/null and b/blog/2016-01-01-complaining-about-the-weather/1.png differ
diff --git a/blog/2016-01-01-complaining-about-the-weather/2.png b/blog/2016-01-01-complaining-about-the-weather/2.png
new file mode 100644
index 0000000..d3a25db
Binary files /dev/null and b/blog/2016-01-01-complaining-about-the-weather/2.png differ
diff --git a/blog/2016-01-01-complaining-about-the-weather/3.png b/blog/2016-01-01-complaining-about-the-weather/3.png
new file mode 100644
index 0000000..3c98570
Binary files /dev/null and b/blog/2016-01-01-complaining-about-the-weather/3.png differ
diff --git a/blog/2016-01-01-complaining-about-the-weather/4.png b/blog/2016-01-01-complaining-about-the-weather/4.png
new file mode 100644
index 0000000..0107d47
Binary files /dev/null and b/blog/2016-01-01-complaining-about-the-weather/4.png differ
diff --git a/blog/2016-01-01-complaining-about-the-weather/5.png b/blog/2016-01-01-complaining-about-the-weather/5.png
new file mode 100644
index 0000000..4cc4983
Binary files /dev/null and b/blog/2016-01-01-complaining-about-the-weather/5.png differ
diff --git a/blog/2016-01-01-complaining-about-the-weather/6.png b/blog/2016-01-01-complaining-about-the-weather/6.png
new file mode 100644
index 0000000..f414900
Binary files /dev/null and b/blog/2016-01-01-complaining-about-the-weather/6.png differ
diff --git a/blog/2016-01-01-complaining-about-the-weather/_article.md b/blog/2016-01-01-complaining-about-the-weather/_article.md
new file mode 100644
index 0000000..5581137
--- /dev/null
+++ b/blog/2016-01-01-complaining-about-the-weather/_article.md
@@ -0,0 +1,16 @@
+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/blog/2016-01-01-complaining-about-the-weather/_notebook.ipynb b/blog/2016-01-01-complaining-about-the-weather/_notebook.ipynb
new file mode 100644
index 0000000..b852070
--- /dev/null
+++ b/blog/2016-01-01-complaining-about-the-weather/_notebook.ipynb
@@ -0,0 +1,734 @@
+{
+ "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/blog/2016-01-01-complaining-about-the-weather/_notebook.md b/blog/2016-01-01-complaining-about-the-weather/_notebook.md
new file mode 100644
index 0000000..563709c
--- /dev/null
+++ b/blog/2016-01-01-complaining-about-the-weather/_notebook.md
@@ -0,0 +1,607 @@
+```python
+from bokeh.plotting import figure, output_notebook, show
+from bokeh.palettes import PuBuGn9 as Palette
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import pickle
+
+output_notebook()
+```
+
+
+
+
+
+
+
+
+
+ BokehJS successfully loaded.
+
+
+
+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][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%.
+
+[1]: http://forecast.io/
+
+
+```python
+city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))
+forecast_df = pd.DataFrame.from_dict(city_forecasts)
+```
+
+
+```python
+cary_forecast = forecast_df['cary']
+years = range(1990, 2016)
+months = range(7, 12)
+months_str = ['July', 'August', 'September', 'October', 'November']
+
+def safe_cover(frame):
+ if frame and 'cloudCover' in frame:
+ return frame['cloudCover']
+ else:
+ return np.NaN
+
+def monthly_avg_cloudcover(year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))
+ cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))
+ return np.nanmean(cloud_cover_vals), cloud_cover_samples
+
+
+monthly_cover_vals = [[monthly_avg_cloudcover(y, m)[0] for y in years] for m in months]
+
+f = figure(title='Monthly Average Cloud Cover',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_cover_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+
+
+
+
+
+
+
+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.
+
+
+```python
+def monthly_cloudy_days(year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))
+ cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))
+ cloudy_days = [cover > .5 for cover in cloud_cover_vals]
+ return np.count_nonzero(cloudy_days), cloud_cover_samples
+
+monthly_days_vals = [[monthly_cloudy_days(y, m)[0] for y in years] for m in months]
+monthly_cover_samples = [[monthly_cloudy_days(y, m)[1] for y in years] for m in months]
+
+f = figure(title='Monthly Cloudy Days',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_days_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+
+f = figure(title='Monthly Cloud Cover Samples',
+ x_range=(1990, 2015),
+ x_axis_label='Year',
+ height=300)
+for x in range(0, len(months)):
+ f.line(years, monthly_cover_samples[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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.
+
+# Tracking Precipitation Chances
+
+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.
+
+
+```python
+def safe_precip(frame):
+ if frame and 'precipProbability' in frame:
+ return frame['precipProbability']
+ else:
+ return np.NaN
+
+def monthly_avg_precip(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(lambda x: safe_precip(cary_forecast[x]['currently']), dates))
+ precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))
+ return np.nanmean(precip_vals), precip_samples
+
+monthly_avg_precip_vals = [[monthly_avg_precip(y, m)[0] for y in years] for m in months]
+
+f = figure(title='Monthly Average Precipitation Chance',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_avg_precip_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+
+
+
+
+
+
+
+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%.
+
+
+```python
+def monthly_rainy_days(year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ precip_prob_vals = list(map(lambda x: safe_precip(cary_forecast[x]['currently']), dates))
+ precip_prob_samples = len(list(filter(lambda x: x is not np.NaN, precip_prob_vals)))
+ precip_days = [prob > .25 for prob in precip_prob_vals]
+ return np.count_nonzero(precip_days), precip_prob_samples
+
+monthly_precip_days_vals = [[monthly_rainy_days(y, m)[0] for y in years] for m in months]
+monthly_precip_samples = [[monthly_rainy_days(y, m)[1] for y in years] for m in months]
+
+f = figure(title='Monthly Rainy Days',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_precip_days_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+
+f = figure(title='Monthly Rainy Days Samples',
+ x_range=(1990, 2015),
+ x_axis_label='Year',
+ height=300)
+for x in range(0, len(months)):
+ f.line(years, monthly_precip_samples[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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.
+
+# Summary and Conclusions
+
+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.!
+
+# Generating the Forecast file
+
+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.
+
+```python
+import pandas as pd
+from functools import reduce
+import requests
+from datetime import datetime
+
+# 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
+
+def get_forecast(lat, long, date=None):
+ forecast_base = "https://api.forecast.io/forecast/"
+ if date is None:
+ url = forecast_base + apikey + '/{},{}'.format(lat, long)
+ else:
+ epoch = int(date.timestamp())
+ url = forecast_base + apikey + '/{},{},{}'.format(lat, long, epoch)
+
+ return requests.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))
+ for year in years]
+dt_merge = reduce(lambda x, 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 = {}
+for city, loc in cities.items():
+ print("Retrieving data for {} starting at {}".format(city,
+ datetime.now().strftime("%I:%M:%S %p")))
+ for dt in dt_merge:
+ try:
+ city_forecasts[(city, dt)] = get_forecast(*loc, dt)
+ except Exception as e:
+ print(e)
+ city_forecasts[(city, dt)] = None
+print("End forecast retrieval: {}".format(datetime.now().strftime("%I:%M:%S %p")))
+
+import pickle
+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
+```
diff --git a/blog/2016-01-01-complaining-about-the-weather/index.mdx b/blog/2016-01-01-complaining-about-the-weather/index.mdx
new file mode 100644
index 0000000..0f1f322
--- /dev/null
+++ b/blog/2016-01-01-complaining-about-the-weather/index.mdx
@@ -0,0 +1,258 @@
+---
+slug: 2016/01/complaining-about-the-weather
+title: Complaining about the weather
+date: 2016-01-01 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+Figuring out whether people should be complaining about the recent weather in North Carolina.
+
+
+
+```python
+from bokeh.plotting import figure, output_notebook, show
+from bokeh.palettes import PuBuGn9 as Palette
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import pickle
+
+output_notebook()
+```
+
+```
+BokehJS successfully loaded.
+```
+
+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](https://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](#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%.
+
+```python
+city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))
+forecast_df = pd.DataFrame.from_dict(city_forecasts)
+```
+
+```python
+cary_forecast = forecast_df['cary']
+years = range(1990, 2016)
+months = range(7, 12)
+months_str = ['July', 'August', 'September', 'October', 'November']
+
+def safe_cover(frame):
+ if frame and 'cloudCover' in frame:
+ return frame['cloudCover']
+ else:
+ return np.NaN
+
+def monthly_avg_cloudcover(year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))
+ cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))
+ return np.nanmean(cloud_cover_vals), cloud_cover_samples
+
+
+monthly_cover_vals = [[monthly_avg_cloudcover(y, m)[0] for y in years] for m in months]
+
+f = figure(title='Monthly Average Cloud Cover',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_cover_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+![Monthly average cloud cover chart](./1.png)
+
+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.
+
+
+```python
+def monthly_cloudy_days(year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ cloud_cover_vals = list(map(lambda x: safe_cover(cary_forecast[x]['currently']), dates))
+ cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))
+ cloudy_days = [cover > .5 for cover in cloud_cover_vals]
+ return np.count_nonzero(cloudy_days), cloud_cover_samples
+
+monthly_days_vals = [[monthly_cloudy_days(y, m)[0] for y in years] for m in months]
+monthly_cover_samples = [[monthly_cloudy_days(y, m)[1] for y in years] for m in months]
+
+f = figure(title='Monthly Cloudy Days',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_days_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+
+f = figure(title='Monthly Cloud Cover Samples',
+ x_range=(1990, 2015),
+ x_axis_label='Year',
+ height=300)
+for x in range(0, len(months)):
+ f.line(years, monthly_cover_samples[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+![Monthly cloudy days chart](./2.png)
+
+![Monthly cloud cover samples chart](./3.png)
+
+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.
+
+# Tracking Precipitation Chances
+
+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.
+
+
+```python
+def safe_precip(frame):
+ if frame and 'precipProbability' in frame:
+ return frame['precipProbability']
+ else:
+ return np.NaN
+
+def monthly_avg_precip(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(lambda x: safe_precip(cary_forecast[x]['currently']), dates))
+ precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))
+ return np.nanmean(precip_vals), precip_samples
+
+monthly_avg_precip_vals = [[monthly_avg_precip(y, m)[0] for y in years] for m in months]
+
+f = figure(title='Monthly Average Precipitation Chance',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_avg_precip_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+![Monthly average precipitation chance chart](./4.png)
+
+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%.
+
+
+```python
+def monthly_rainy_days(year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ precip_prob_vals = list(map(lambda x: safe_precip(cary_forecast[x]['currently']), dates))
+ precip_prob_samples = len(list(filter(lambda x: x is not np.NaN, precip_prob_vals)))
+ precip_days = [prob > .25 for prob in precip_prob_vals]
+ return np.count_nonzero(precip_days), precip_prob_samples
+
+monthly_precip_days_vals = [[monthly_rainy_days(y, m)[0] for y in years] for m in months]
+monthly_precip_samples = [[monthly_rainy_days(y, m)[1] for y in years] for m in months]
+
+f = figure(title='Monthly Rainy Days',
+ x_range=(1990, 2015),
+ x_axis_label='Year')
+for x in range(0, len(months)):
+ f.line(years, monthly_precip_days_vals[x], legend=months_str[x], color=Palette[x])
+show(f)
+
+f = figure(title='Monthly Rainy Days Samples',
+ x_range=(1990, 2015),
+ x_axis_label='Year',
+ height=300)
+for x in range(0, len(months)):
+ f.line(years, monthly_precip_samples[x], legend=months_str[x], color=Palette[x])
+show(f)
+```
+
+![Monthly rainy days chart](./5.png)
+
+![Monthly rainy days samples chart](./6.png)
+
+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.
+
+# Summary and Conclusions
+
+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.!
+
+# Generating the Forecast file
+
+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.
+
+```python
+import pandas as pd
+from functools import reduce
+import requests
+from datetime import datetime
+
+# 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
+
+def get_forecast(lat, long, date=None):
+ forecast_base = "https://api.forecast.io/forecast/"
+ if date is None:
+ url = forecast_base + apikey + '/{},{}'.format(lat, long)
+ else:
+ epoch = int(date.timestamp())
+ url = forecast_base + apikey + '/{},{},{}'.format(lat, long, epoch)
+
+ return requests.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))
+ for year in years]
+dt_merge = reduce(lambda x, 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 = {}
+for city, loc in cities.items():
+ print("Retrieving data for {} starting at {}".format(city,
+ datetime.now().strftime("%I:%M:%S %p")))
+ for dt in dt_merge:
+ try:
+ city_forecasts[(city, dt)] = get_forecast(*loc, dt)
+ except Exception as e:
+ print(e)
+ city_forecasts[(city, dt)] = None
+print("End forecast retrieval: {}".format(datetime.now().strftime("%I:%M:%S %p")))
+
+import pickle
+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
+```
diff --git a/blog/2016-01-23-cloudy-in-seattle/1.png b/blog/2016-01-23-cloudy-in-seattle/1.png
new file mode 100644
index 0000000..6702a9f
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/1.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/10.png b/blog/2016-01-23-cloudy-in-seattle/10.png
new file mode 100644
index 0000000..c6270e4
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/10.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/2.png b/blog/2016-01-23-cloudy-in-seattle/2.png
new file mode 100644
index 0000000..51b3375
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/2.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/3.png b/blog/2016-01-23-cloudy-in-seattle/3.png
new file mode 100644
index 0000000..c461680
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/3.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/4.png b/blog/2016-01-23-cloudy-in-seattle/4.png
new file mode 100644
index 0000000..c030210
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/4.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/5.png b/blog/2016-01-23-cloudy-in-seattle/5.png
new file mode 100644
index 0000000..4a58b6e
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/5.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/6.png b/blog/2016-01-23-cloudy-in-seattle/6.png
new file mode 100644
index 0000000..70d426a
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/6.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/7.png b/blog/2016-01-23-cloudy-in-seattle/7.png
new file mode 100644
index 0000000..b9e785f
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/7.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/8.png b/blog/2016-01-23-cloudy-in-seattle/8.png
new file mode 100644
index 0000000..d05599c
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/8.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/9.png b/blog/2016-01-23-cloudy-in-seattle/9.png
new file mode 100644
index 0000000..2a85bfa
Binary files /dev/null and b/blog/2016-01-23-cloudy-in-seattle/9.png differ
diff --git a/blog/2016-01-23-cloudy-in-seattle/_article.md b/blog/2016-01-23-cloudy-in-seattle/_article.md
new file mode 100644
index 0000000..0139426
--- /dev/null
+++ b/blog/2016-01-23-cloudy-in-seattle/_article.md
@@ -0,0 +1,15 @@
+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/blog/2016-01-23-cloudy-in-seattle/_notebook.ipynb b/blog/2016-01-23-cloudy-in-seattle/_notebook.ipynb
new file mode 100644
index 0000000..b7e2d62
--- /dev/null
+++ b/blog/2016-01-23-cloudy-in-seattle/_notebook.ipynb
@@ -0,0 +1,721 @@
+{
+ "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": [
+ "import pickle\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "from bokeh.plotting import output_notebook, figure, show\n",
+ "from bokeh.palettes import RdBu4 as Palette\n",
+ "from datetime import datetime\n",
+ "import warnings\n",
+ "\n",
+ "output_notebook()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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:\n",
+ "- Binghamton, NY\n",
+ "- Cary, NC\n",
+ "- Seattle, WA\n",
+ "- New York City, NY\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))\n",
+ "forecasts_df = pd.DataFrame.from_dict(city_forecasts)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "cities = ['binghamton', 'cary', 'nyc', 'seattle']\n",
+ "city_colors = {cities[i]: Palette[i] for i in range(0, 4)}\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(city, 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(forecasts_df[city][x]['currently']), dates))\n",
+ " cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))\n",
+ " # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.\n",
+ " with warnings.catch_warnings():\n",
+ " warnings.simplefilter('ignore')\n",
+ " return np.nanmean(cloud_cover_vals), cloud_cover_samples"
+ ]
+ },
+ {
+ "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"
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "years = range(1990, 2016)\n",
+ "def city_avg_cc(city, month):\n",
+ " return [monthly_avg_cloudcover(city, y, month) for y in years]\n",
+ "\n",
+ "months = [\n",
+ " ('July', 7),\n",
+ " ('August', 8),\n",
+ " ('September', 9),\n",
+ " ('October', 10),\n",
+ " ('November', 11)\n",
+ "]\n",
+ "\n",
+ "for month, month_id in months:\n",
+ " month_averages = {city: city_avg_cc(city, month_id) for city in cities}\n",
+ " f = figure(title=\"{} Average Cloud Cover\".format(month),\n",
+ " x_axis_label='Year',\n",
+ " y_axis_label='Cloud Cover Percentage')\n",
+ " for city in cities:\n",
+ " f.line(years, [x[0] for x in month_averages[city]],\n",
+ " legend=city, color=city_colors[city])\n",
+ " show(f)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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:\n",
+ "- Seattle, specifically for the months of October and November, is in fact significantly more cloudy on average than are other cities\n",
+ "- All cities surveyed have seen average cloud cover decline over the months studied. There are data issues, but the trend seems clear.\n",
+ "\n",
+ "Let's now move from cloud cover data to looking at average rainfall chance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "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"
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "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(city, 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(forecasts_df[city][x]['currently']), dates))\n",
+ " precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))\n",
+ " # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.\n",
+ " with warnings.catch_warnings():\n",
+ " warnings.simplefilter('ignore')\n",
+ " return np.nanmean(precip_vals), precip_samples\n",
+ "\n",
+ "def city_avg_precip(city, month):\n",
+ " return [monthly_avg_precip(city, y, month) for y in years]\n",
+ "\n",
+ "for month, month_id in months:\n",
+ " month_averages = {city: city_avg_cc(city, month_id) for city in cities}\n",
+ " f = figure(title=\"{} Average Precipitation Chance\".format(month),\n",
+ " x_axis_label='Year',\n",
+ " y_axis_label='Precipitation Chance Percentage')\n",
+ " for city in cities:\n",
+ " f.line(years, [x[0] for x in month_averages[city]],\n",
+ " legend=city, color=city_colors[city])\n",
+ " show(f)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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:\n",
+ "- Seattle, specifically for the months of August, October, and November has had a consistently higher chance of rain than other cities surveyed.\n",
+ "- Average precipitation chance, just like average cloud cover, has been trending down over time.\n",
+ "\n",
+ "# Conclusion\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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!"
+ ]
+ }
+ ],
+ "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.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-01-23-cloudy-in-seattle/_notebook.md b/blog/2016-01-23-cloudy-in-seattle/_notebook.md
new file mode 100644
index 0000000..c091dc2
--- /dev/null
+++ b/blog/2016-01-23-cloudy-in-seattle/_notebook.md
@@ -0,0 +1,601 @@
+```python
+import pickle
+import pandas as pd
+import numpy as np
+from bokeh.plotting import output_notebook, figure, show
+from bokeh.palettes import RdBu4 as Palette
+from datetime import datetime
+import warnings
+
+output_notebook()
+```
+
+
+
+
+
+
+
+
+
+ BokehJS successfully loaded.
+
+
+
+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.
+
+
+```python
+city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))
+forecasts_df = pd.DataFrame.from_dict(city_forecasts)
+```
+
+
+```python
+cities = ['binghamton', 'cary', 'nyc', 'seattle']
+city_colors = {cities[i]: Palette[i] for i in range(0, 4)}
+
+def safe_cover(frame):
+ if frame and 'cloudCover' in frame:
+ return frame['cloudCover']
+ else:
+ return np.NaN
+
+def monthly_avg_cloudcover(city, year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ cloud_cover_vals = list(map(lambda x: safe_cover(forecasts_df[city][x]['currently']), dates))
+ cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))
+ # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore')
+ return np.nanmean(cloud_cover_vals), cloud_cover_samples
+```
+
+
+```python
+years = range(1990, 2016)
+def city_avg_cc(city, month):
+ return [monthly_avg_cloudcover(city, y, month) for y in years]
+
+months = [
+ ('July', 7),
+ ('August', 8),
+ ('September', 9),
+ ('October', 10),
+ ('November', 11)
+]
+
+for month, month_id in months:
+ month_averages = {city: city_avg_cc(city, month_id) for city in cities}
+ f = figure(title="{} Average Cloud Cover".format(month),
+ x_axis_label='Year',
+ y_axis_label='Cloud Cover Percentage')
+ for city in cities:
+ f.line(years, [x[0] for x in month_averages[city]],
+ legend=city, color=city_colors[city])
+ show(f)
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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.
+
+
+```python
+def safe_precip(frame):
+ if frame and 'precipProbability' in frame:
+ return frame['precipProbability']
+ else:
+ return np.NaN
+
+def monthly_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(lambda x: safe_precip(forecasts_df[city][x]['currently']), dates))
+ precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))
+ # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore')
+ return np.nanmean(precip_vals), precip_samples
+
+def city_avg_precip(city, month):
+ return [monthly_avg_precip(city, y, month) for y in years]
+
+for month, month_id in months:
+ month_averages = {city: city_avg_cc(city, month_id) for city in cities}
+ f = figure(title="{} Average Precipitation Chance".format(month),
+ x_axis_label='Year',
+ y_axis_label='Precipitation Chance Percentage')
+ for city in cities:
+ f.line(years, [x[0] for x in month_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.
+
+# Conclusion
+
+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!
diff --git a/blog/2016-01-23-cloudy-in-seattle/index.mdx b/blog/2016-01-23-cloudy-in-seattle/index.mdx
new file mode 100644
index 0000000..9116d24
--- /dev/null
+++ b/blog/2016-01-23-cloudy-in-seattle/index.mdx
@@ -0,0 +1,154 @@
+---
+slug: 2016/01/cloudy-in-seattle
+title: Cloudy in Seattle
+date: 2016-01-23 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+Building on prior analysis, is Seattle's reputation as a depressing city actually well-earned?
+
+
+
+```python
+import pickle
+import pandas as pd
+import numpy as np
+from bokeh.plotting import output_notebook, figure, show
+from bokeh.palettes import RdBu4 as Palette
+from datetime import datetime
+import warnings
+
+output_notebook()
+```
+
+```
+BokehJS successfully loaded.
+```
+
+## Examining other cities
+
+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.
+
+
+```python
+city_forecasts = pickle.load(open('city_forecasts.p', 'rb'))
+forecasts_df = pd.DataFrame.from_dict(city_forecasts)
+```
+
+
+```python
+cities = ['binghamton', 'cary', 'nyc', 'seattle']
+city_colors = {cities[i]: Palette[i] for i in range(0, 4)}
+
+def safe_cover(frame):
+ if frame and 'cloudCover' in frame:
+ return frame['cloudCover']
+ else:
+ return np.NaN
+
+def monthly_avg_cloudcover(city, year, month):
+ dates = pd.DatetimeIndex(start=datetime(year, month, 1, 12),
+ end=datetime(year, month + 1, 1, 12),
+ freq='D', closed='left')
+ cloud_cover_vals = list(map(lambda x: safe_cover(forecasts_df[city][x]['currently']), dates))
+ cloud_cover_samples = len(list(filter(lambda x: x is not np.NaN, cloud_cover_vals)))
+ # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore')
+ return np.nanmean(cloud_cover_vals), cloud_cover_samples
+```
+
+
+```python
+years = range(1990, 2016)
+def city_avg_cc(city, month):
+ return [monthly_avg_cloudcover(city, y, month) for y in years]
+
+months = [
+ ('July', 7),
+ ('August', 8),
+ ('September', 9),
+ ('October', 10),
+ ('November', 11)
+]
+
+for month, month_id in months:
+ month_averages = {city: city_avg_cc(city, month_id) for city in cities}
+ f = figure(title="{} Average Cloud Cover".format(month),
+ x_axis_label='Year',
+ y_axis_label='Cloud Cover Percentage')
+ for city in cities:
+ f.line(years, [x[0] for x in month_averages[city]],
+ legend=city, color=city_colors[city])
+ show(f)
+```
+
+![July average cloud cover chart](./1.png)
+![August average cloud cover chart](./2.png)
+![September average cloud cover chart](./3.png)
+![October average cloud cover chart](./4.png)
+![November average cloud cover chart](./5.png)
+
+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.
+
+
+```python
+def safe_precip(frame):
+ if frame and 'precipProbability' in frame:
+ return frame['precipProbability']
+ else:
+ return np.NaN
+
+def monthly_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(lambda x: safe_precip(forecasts_df[city][x]['currently']), dates))
+ precip_samples = len(list(filter(lambda x: x is not np.NaN, precip_vals)))
+ # Ignore an issue with nanmean having all NaN values. We'll discuss the data issues below.
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore')
+ return np.nanmean(precip_vals), precip_samples
+
+def city_avg_precip(city, month):
+ return [monthly_avg_precip(city, y, month) for y in years]
+
+for month, month_id in months:
+ month_averages = {city: city_avg_cc(city, month_id) for city in cities}
+ f = figure(title="{} Average Precipitation Chance".format(month),
+ x_axis_label='Year',
+ y_axis_label='Precipitation Chance Percentage')
+ for city in cities:
+ f.line(years, [x[0] for x in month_averages[city]],
+ legend=city, color=city_colors[city])
+ show(f)
+```
+
+![July average precipitation chance chart](./6.png)
+![August average precipitation chance chart](./7.png)
+![September average precipitation chance chart](./8.png)
+![October average precipitation chance chart](./9.png)
+![November average precipitation chance chart](./10.png)
+
+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.
+
+## Conclusion
+
+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/blog/2016-02-03-guaranteed-money-maker/_article.md b/blog/2016-02-03-guaranteed-money-maker/_article.md
new file mode 100644
index 0000000..eec4719
--- /dev/null
+++ b/blog/2016-02-03-guaranteed-money-maker/_article.md
@@ -0,0 +1,15 @@
+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/blog/2016-02-03-guaranteed-money-maker/_notebook.ipynb b/blog/2016-02-03-guaranteed-money-maker/_notebook.ipynb
new file mode 100644
index 0000000..8b99ee9
--- /dev/null
+++ b/blog/2016-02-03-guaranteed-money-maker/_notebook.ipynb
@@ -0,0 +1,260 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### If you can see into the future, that is.\n",
+ "\n",
+ "My previous class in Stochastic Calculus covered a lot of interesting topics, and the important one for today\n",
+ "is the [Gambler's Ruin][1] problem. If you're interested in some of the theory behind it, also make sure to check out\n",
+ "[random walks][2]. The important bit is that we studied the [Martingale Betting Strategy][3], which describes for us\n",
+ "a **guaranteed way** to eventually make money.\n",
+ "\n",
+ "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?\n",
+ "\n",
+ "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:\n",
+ "\n",
+ "1. You bet $1, and guess incorrectly. You're 1 dollar in the hole.\n",
+ "2. You bet $2, and guess incorrectly. You're 3 dollars in the hole now.\n",
+ "3. You bet $4, and guess incorrectly. You're 7 dollars in the hole.\n",
+ "4. 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**!\n",
+ "\n",
+ "Mathematically, we can prove that as long as you have unlimited money to bet, you are guaranteed to make money.\n",
+ "\n",
+ "# Applying the Martingale Strategy\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "Now it's time for the math. We'll use the following definitions:\n",
+ "\n",
+ "- $o_i$ = the share price at the opening of day $i$\n",
+ "- $c_i$ = the share price at the close of day $i$\n",
+ "- $d_i$ = the amount of money we want to invest at the beginning of day $i$\n",
+ "\n",
+ "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*:\n",
+ "\n",
+ "$c_n \\sum_{i=1}^n \\frac{d_i}{o_i} > \\sum_{i=1}^{n} d_i$\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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:\n",
+ "\n",
+ "$\n",
+ "\\begin{align}\n",
+ "c_n \\sum_{i=1}^{n-1} \\frac{d_i}{o_i} + \\frac{c_nd_n}{o_n} &> \\sum_{i=1}^{n-1}d_i + d_n\\\\\n",
+ "\\frac{c_nd_n}{o_n} - d_n &> \\sum_{i=1}^{n-1}(d_i - \\frac{c_nd_i}{o_i})\\\\\n",
+ "d_n (\\frac{c_n - o_n}{o_n}) &> \\sum_{i=1}^{n-1} d_i(1 - \\frac{c_n}{o_i})\\\\\n",
+ "d_n &> \\frac{o_n}{c_n - o_n} \\sum_{i=1}^{n-1} d_i(1 - \\frac{1}{o_i})\n",
+ "\\end{align}$\n",
+ "\n",
+ "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!**\n",
+ "\n",
+ "# Interesting Implications\n",
+ "\n",
+ "On a more serious note though, the formula above tells us a couple of interesting things:\n",
+ "\n",
+ "1. 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.\n",
+ "2. 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.\n",
+ "3. 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.\n",
+ "4. 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.\n",
+ "5. It's possible the winning move is to scale back your position. Consider the scenario:\n",
+ " - You invest money and the stock closes down the day .5%\n",
+ " - You invest tomorrow expecting the stock to go up 1%\n",
+ " - 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\n",
+ "\n",
+ "# Running the simulation\n",
+ "\n",
+ "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:\n",
+ "\n",
+ "1. 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**.\n",
+ "2. 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**.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "Now, let's get to the code!\n",
+ "\n",
+ "[1]: https://en.wikipedia.org/wiki/Gambler's_ruin\n",
+ "[2]: https://en.wikipedia.org/wiki/Random_walk\n",
+ "[3]: https://en.wikipedia.org/wiki/Martingale_%28betting_system%29"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "using Quandl\n",
+ "api_key = \"\"\n",
+ "daily_investment = function(current_open, current_close, purchase_history, open_history)\n",
+ " # We're not going to safeguard against divide by 0 - that's the user's responsibility\n",
+ " t1 = current_close / current_open - 1\n",
+ " t2 = sum(purchase_history - purchase_history*current_close ./ open_history)\n",
+ " return t2 / t1\n",
+ "end;"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And let's code a way to run simulations quickly:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "is_profitable = function(current_price, purchase_history, open_history)\n",
+ " shares = sum(purchase_history ./ open_history)\n",
+ " return current_price*shares > sum(purchase_history)\n",
+ "end\n",
+ "\n",
+ "simulate = function(name, start, init, expected, bias)\n",
+ " ticker_info = quandlget(name, from=start, api_key=api_key)\n",
+ " open_vals = ticker_info[\"Open\"].values\n",
+ " close_vals = ticker_info[\"Close\"].values\n",
+ " invested = [init]\n",
+ " \n",
+ " # The simulation stops once we've made a profit\n",
+ " day = 1\n",
+ " profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||\n",
+ " is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])\n",
+ " while !profitable\n",
+ " expected_close = open_vals[day+1] * expected\n",
+ " todays_purchase = daily_investment(open_vals[day+1], expected_close, invested, open_vals[1:day])\n",
+ " invested = [invested; todays_purchase + bias]\n",
+ " # expected_profit = expected_close * sum(invested ./ open_vals[1:length(invested)]) - sum(invested)\n",
+ " day += 1\n",
+ " profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||\n",
+ " is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])\n",
+ " end\n",
+ " \n",
+ " shares = sum(invested ./ open_vals[1:length(invested)])\n",
+ " max_profit = max(close_vals[day], open_vals[day+1])\n",
+ " profit = shares * max_profit - sum(invested)\n",
+ " return (invested, profit)\n",
+ "end\n",
+ "\n",
+ "sim_summary = function(investments, profit)\n",
+ " leverages = [sum(investments[1:i]) for i=1:length(investments)]\n",
+ " max_leverage = maximum(leverages) / investments[1]\n",
+ " println(\"Max leverage: $(max_leverage)\")\n",
+ " println(\"Days invested: $(length(investments))\")\n",
+ " println(\"Profit: $profit\")\n",
+ "end;"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, let's get some data and run a simulation! Our first test:\n",
+ "\n",
+ "- 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."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Max leverage: 5.590373200042106\n",
+ "Days invested: 5\n",
+ "Profit: 0.6894803101560001\n"
+ ]
+ }
+ ],
+ "source": [
+ "investments, profit = simulate(\"YAHOO/LMT\", Date(2015, 11, 29), 100, 1.01, 10)\n",
+ "sim_summary(investments, profit)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The result: We need to invest 5.6x our initial position over a period of 5 days to make approximately .69¢\n",
+ "\n",
+ "- Now let's try the same thing, but we'll assume the stock closes up 2% instead."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Max leverage: 1.854949900247809\n",
+ "Days invested: 25\n",
+ "Profit: 0.08304813163696423\n"
+ ]
+ }
+ ],
+ "source": [
+ "investments, profit = simulate(\"YAHOO/LMT\", Date(2015, 11, 29), 100, 1.02, 10)\n",
+ "sim_summary(investments, profit)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In this example, we only get up to a 1.85x leveraged position, but it takes 25 days to turn a profit of 8¢"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Summary\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Side note and disclaimer\n",
+ "\n",
+ "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."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Julia 0.4.2",
+ "language": "julia",
+ "name": "julia-0.4"
+ },
+ "language_info": {
+ "file_extension": ".jl",
+ "mimetype": "application/julia",
+ "name": "julia",
+ "version": "0.4.2"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-02-03-guaranteed-money-maker/_notebook.md b/blog/2016-02-03-guaranteed-money-maker/_notebook.md
new file mode 100644
index 0000000..67ca64b
--- /dev/null
+++ b/blog/2016-02-03-guaranteed-money-maker/_notebook.md
@@ -0,0 +1,171 @@
+### If you can see into the future, that is.
+
+My previous class in Stochastic Calculus covered a lot of interesting topics, and the important one for today
+is the [Gambler's Ruin][1] problem. If you're interested in some of the theory behind it, also make sure to check out
+[random walks][2]. The important bit is that we studied the [Martingale Betting Strategy][3], 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:
+
+1. You bet $1, and guess incorrectly. You're 1 dollar in the hole.
+2. You bet $2, and guess incorrectly. You're 3 dollars in the hole now.
+3. You bet $4, and guess incorrectly. You're 7 dollars in the hole.
+4. 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.
+
+# Applying the Martingale Strategy
+
+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*:
+
+$c_n \sum_{i=1}^n \frac{d_i}{o_i} > \sum_{i=1}^{n} d_i$
+
+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:
+
+$
+\begin{align}
+c_n \sum_{i=1}^{n-1} \frac{d_i}{o_i} + \frac{c_nd_n}{o_n} &> \sum_{i=1}^{n-1}d_i + d_n\\
+\frac{c_nd_n}{o_n} - d_n &> \sum_{i=1}^{n-1}(d_i - \frac{c_nd_i}{o_i})\\
+d_n (\frac{c_n - o_n}{o_n}) &> \sum_{i=1}^{n-1} d_i(1 - \frac{c_n}{o_i})\\
+d_n &> \frac{o_n}{c_n - o_n} \sum_{i=1}^{n-1} d_i(1 - \frac{1}{o_i})
+\end{align}$
+
+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!**
+
+# Interesting Implications
+
+On a more serious note though, the formula above tells us a couple of interesting things:
+
+1. 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.
+2. 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.
+3. 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.
+4. 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.
+5. 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
+
+# Running the simulation
+
+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:
+
+1. 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**.
+2. 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!
+
+[1]: https://en.wikipedia.org/wiki/Gambler's_ruin
+[2]: https://en.wikipedia.org/wiki/Random_walk
+[3]: https://en.wikipedia.org/wiki/Martingale_%28betting_system%29
+
+
+```julia
+using Quandl
+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)
+ return t2 / t1
+end;
+```
+
+And let's code a way to run simulations quickly:
+
+
+```julia
+is_profitable = function(current_price, purchase_history, open_history)
+ shares = sum(purchase_history ./ open_history)
+ return current_price*shares > sum(purchase_history)
+end
+
+simulate = function(name, start, init, expected, bias)
+ ticker_info = quandlget(name, from=start, api_key=api_key)
+ open_vals = ticker_info["Open"].values
+ close_vals = ticker_info["Close"].values
+ invested = [init]
+
+ # The simulation stops once we've made a profit
+ day = 1
+ profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||
+ is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])
+ while !profitable
+ expected_close = open_vals[day+1] * expected
+ todays_purchase = daily_investment(open_vals[day+1], expected_close, invested, open_vals[1:day])
+ invested = [invested; todays_purchase + bias]
+ # expected_profit = expected_close * sum(invested ./ open_vals[1:length(invested)]) - sum(invested)
+ day += 1
+ profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||
+ is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])
+ end
+
+ shares = sum(invested ./ open_vals[1:length(invested)])
+ max_profit = max(close_vals[day], open_vals[day+1])
+ profit = shares * max_profit - sum(invested)
+ return (invested, profit)
+end
+
+sim_summary = function(investments, profit)
+ leverages = [sum(investments[1:i]) for i=1:length(investments)]
+ max_leverage = maximum(leverages) / investments[1]
+ println("Max leverage: $(max_leverage)")
+ println("Days invested: $(length(investments))")
+ println("Profit: $profit")
+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.
+
+
+```julia
+investments, profit = simulate("YAHOO/LMT", Date(2015, 11, 29), 100, 1.01, 10)
+sim_summary(investments, profit)
+```
+
+ Max leverage: 5.590373200042106
+ Days invested: 5
+ Profit: 0.6894803101560001
+
+
+The result: We need to invest 5.6x our initial position over a period of 5 days to make approximately .69¢
+
+- Now let's try the same thing, but we'll assume the stock closes up 2% instead.
+
+
+```julia
+investments, profit = simulate("YAHOO/LMT", Date(2015, 11, 29), 100, 1.02, 10)
+sim_summary(investments, profit)
+```
+
+ Max leverage: 1.854949900247809
+ Days invested: 25
+ Profit: 0.08304813163696423
+
+
+In this example, we only get up to a 1.85x leveraged position, but it takes 25 days to turn a profit of 8¢
+
+# Summary
+
+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).
+
+# Side note and disclaimer
+
+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.
diff --git a/blog/2016-02-03-guaranteed-money-maker/index.mdx b/blog/2016-02-03-guaranteed-money-maker/index.mdx
new file mode 100644
index 0000000..3c2eded
--- /dev/null
+++ b/blog/2016-02-03-guaranteed-money-maker/index.mdx
@@ -0,0 +1,183 @@
+---
+slug: 2016/02/guaranteed-money-maker
+title: Guaranteed money maker
+date: 2016-02-03 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+Developing an investment strategy based on the Martingale betting strategy
+
+If you can see into the future, that is.
+
+
+
+My previous class in Stochastic Calculus covered a lot of interesting topics, and the important one for today is the [Gambler's Ruin][1] problem. If you're interested in some of the theory behind it, also make sure to check out [random walks][2]. The important bit is that we studied the [Martingale Betting Strategy][3], 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:
+
+1. You bet $1, and guess incorrectly. You're 1 dollar in the hole.
+2. You bet $2, and guess incorrectly. You're 3 dollars in the hole now.
+3. You bet $4, and guess incorrectly. You're 7 dollars in the hole.
+4. 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.
+
+## Applying the Martingale Strategy
+
+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*:
+
+$c_n \sum_{i=1}^n \frac{d_i}{o_i} > \sum_{i=1}^{n} d_i$
+
+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:
+
+$$
+\begin{align*}
+c_n \sum_{i=1}^{n-1} \frac{d_i}{o_i} + \frac{c_nd_n}{o_n} &> \sum_{i=1}^{n-1}d_i + d_n\\
+\frac{c_nd_n}{o_n} - d_n &> \sum_{i=1}^{n-1}(d_i - \frac{c_nd_i}{o_i})\\
+d_n (\frac{c_n - o_n}{o_n}) &> \sum_{i=1}^{n-1} d_i(1 - \frac{c_n}{o_i})\\
+d_n &> \frac{o_n}{c_n - o_n} \sum_{i=1}^{n-1} d_i(1 - \frac{1}{o_i})
+\end{align*}
+$$
+
+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!**
+
+## Interesting Implications
+
+On a more serious note though, the formula above tells us a couple of interesting things:
+
+1. 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.
+2. 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.
+3. 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.
+4. 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.
+5. 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
+
+## Running the simulation
+
+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:
+
+1. 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**.
+2. 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!
+
+[1]: https://en.wikipedia.org/wiki/Gambler's_ruin
+[2]: https://en.wikipedia.org/wiki/Random_walk
+[3]: https://en.wikipedia.org/wiki/Martingale_%28betting_system%29
+
+
+```julia
+using Quandl
+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)
+ return t2 / t1
+end;
+```
+
+And let's code a way to run simulations quickly:
+
+
+```julia
+is_profitable = function(current_price, purchase_history, open_history)
+ shares = sum(purchase_history ./ open_history)
+ return current_price*shares > sum(purchase_history)
+end
+
+simulate = function(name, start, init, expected, bias)
+ ticker_info = quandlget(name, from=start, api_key=api_key)
+ open_vals = ticker_info["Open"].values
+ close_vals = ticker_info["Close"].values
+ invested = [init]
+
+ # The simulation stops once we've made a profit
+ day = 1
+ profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||
+ is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])
+ while !profitable
+ expected_close = open_vals[day+1] * expected
+ todays_purchase = daily_investment(open_vals[day+1], expected_close, invested, open_vals[1:day])
+ invested = [invested; todays_purchase + bias]
+ # expected_profit = expected_close * sum(invested ./ open_vals[1:length(invested)]) - sum(invested)
+ day += 1
+ profitable = is_profitable(close_vals[day], invested, open_vals[1:length(invested)]) ||
+ is_profitable(open_vals[day+1], invested, open_vals[1:length(invested)])
+ end
+
+ shares = sum(invested ./ open_vals[1:length(invested)])
+ max_profit = max(close_vals[day], open_vals[day+1])
+ profit = shares * max_profit - sum(invested)
+ return (invested, profit)
+end
+
+sim_summary = function(investments, profit)
+ leverages = [sum(investments[1:i]) for i=1:length(investments)]
+ max_leverage = maximum(leverages) / investments[1]
+ println("Max leverage: $(max_leverage)")
+ println("Days invested: $(length(investments))")
+ println("Profit: $profit")
+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.
+
+
+```julia
+investments, profit = simulate("YAHOO/LMT", Date(2015, 11, 29), 100, 1.01, 10)
+sim_summary(investments, profit)
+```
+
+```
+ Max leverage: 5.590373200042106
+ Days invested: 5
+ Profit: 0.6894803101560001
+```
+
+The result: We need to invest 5.6x our initial position over a period of 5 days to make approximately .69¢
+
+- Now let's try the same thing, but we'll assume the stock closes up 2% instead.
+
+
+```julia
+investments, profit = simulate("YAHOO/LMT", Date(2015, 11, 29), 100, 1.02, 10)
+sim_summary(investments, profit)
+```
+
+```
+ Max leverage: 1.854949900247809
+ Days invested: 25
+ Profit: 0.08304813163696423
+```
+
+In this example, we only get up to a 1.85x leveraged position, but it takes 25 days to turn a profit of 8¢
+
+## Summary
+
+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).
+
+### Side note and disclaimer
+
+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/blog/2016-02-26-profitability-using-the-investment-formula/_article.md b/blog/2016-02-26-profitability-using-the-investment-formula/_article.md
new file mode 100644
index 0000000..e66b059
--- /dev/null
+++ b/blog/2016-02-26-profitability-using-the-investment-formula/_article.md
@@ -0,0 +1,15 @@
+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/blog/2016-02-26-profitability-using-the-investment-formula/_notebook.ipynb b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook.ipynb
new file mode 100644
index 0000000..3716140
--- /dev/null
+++ b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook.ipynb
@@ -0,0 +1,383 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Profitability using the Investment Formula\n",
+ "\n",
+ "I've previously talked about crafting an [Investment Formula][1] 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.\n",
+ "\n",
+ "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**.\n",
+ "\n",
+ "The definition is going to be very simple:\n",
+ "\n",
+ "- $p$: Profit made once you exit the investment\n",
+ "- $i$: Initial investment into the asset\n",
+ "- $m$: Maximum investment in the asset\n",
+ "- $l = m / i$: The maximum leverage of an investment, as the ratio of maximum invested to initial investment\n",
+ "- $d$: The number of days it takes to turn a profit\n",
+ "\n",
+ "$s = \\frac{1000 p}{i(l + d)} = \\frac{1000 p}{m + i\\cdot d}$\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "# Theoretical Justification\n",
+ "\n",
+ "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!\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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!\n",
+ "\n",
+ "# Running a simulation\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "[1]: https://bspeice.github.io/guaranteed-money-maker.html"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "from Quandl import get as qget\n",
+ "%matplotlib inline\n",
+ "api_key = ''\n",
+ "\n",
+ "profitability = lambda p, i, m, d: 1000*p / (m + i*d)\n",
+ "\n",
+ "def is_profitable(current_price, purchase_history, open_history):\n",
+ " shares = (purchase_history / open_history).sum()\n",
+ " return current_price * shares > sum(purchase_history)\n",
+ "\n",
+ "def daily_investment(current_open, current_close, purchase_history, open_history):\n",
+ " t1 = current_close / current_open - 1\n",
+ " t2 = (purchase_history - purchase_history * current_close / open_history).sum()\n",
+ " return t2 / t1\n",
+ "\n",
+ "def simulate_day(open_vals, close_vals, init, expected, bias):\n",
+ " invested = np.array([init])\n",
+ " \n",
+ " day = 1\n",
+ " profitable = is_profitable(close_vals[day-1], invested, open_vals[0:len(invested)]) \\\n",
+ " or is_profitable(open_vals[day], invested, open_vals[0:len(invested)])\n",
+ "\n",
+ " while not profitable:\n",
+ " expected_close = open_vals[day] * expected\n",
+ " todays_purchase = daily_investment(open_vals[day], expected_close, invested, open_vals[0:day])\n",
+ " invested = np.append(invested, todays_purchase + bias)\n",
+ " # expected_profit = expected_close * (invested / open_vals[0:len(invested)]).sum() - invested.sum()\n",
+ " day += 1\n",
+ " profitable = is_profitable(close_vals[day-1], invested, open_vals[0:len(invested)]) \\\n",
+ " or is_profitable(open_vals[day], invested, open_vals[0:len(invested)])\n",
+ " \n",
+ " shares = (invested / open_vals[0:len(invested)]).sum()\n",
+ " \n",
+ " # Make sure we can't see into the future - we know either today's close or tomorrow's open\n",
+ " # will be profitable, but we need to check which one.\n",
+ " if is_profitable(close_vals[day-1], invested, open_vals[0:len(invested)]):\n",
+ " ending_price = close_vals[day-1]\n",
+ " else:\n",
+ " ending_price = open_vals[day]\n",
+ " \n",
+ " profit = shares * ending_price - sum(invested)\n",
+ " return invested, profit\n",
+ "\n",
+ "def simulate_ts(name, start, end, initial, expected, bias):\n",
+ " ticker_info = qget(name, trim_start=start, api_key=api_key)\n",
+ " evaluation_times = ticker_info[:end].index\n",
+ " \n",
+ " # Handle Google vs. YFinance data\n",
+ " if \"Adjusted Close\" in ticker_info.columns:\n",
+ " close_column = \"Adjusted Close\"\n",
+ " else:\n",
+ " close_column = \"Close\"\n",
+ " \n",
+ " sim = {d: simulate_day(ticker_info[d:][\"Open\"], ticker_info[d:][close_column],\n",
+ " 100, 1.02, 10) for d in evaluation_times}\n",
+ " sim_series = pd.Series(sim)\n",
+ " result = pd.DataFrame()\n",
+ " result[\"profit\"] = sim_series.apply(lambda x: x[1])\n",
+ " result[\"max\"] = sim_series.apply(lambda x: max(x[0]))\n",
+ " result[\"days\"] = sim_series.apply(lambda x: len(x[0]))\n",
+ " result[\"score\"] = sim_series.apply(lambda x: profitability(x[1], x[0][0], max(x[0]), len(x[0])))\n",
+ " result[\"investments\"] = sim_series.apply(lambda x: x[0])\n",
+ " \n",
+ " return result\n",
+ "\n",
+ "def simulate_tickers(tickers):\n",
+ " from datetime import datetime\n",
+ " results = {}\n",
+ " for ticker in tickers:\n",
+ " start = datetime(2015, 1, 1)\n",
+ " results_df = simulate_ts(ticker, start, datetime(2016, 1, 1), 100, 1.01, 10)\n",
+ " results[ticker] = results_df\n",
+ " \n",
+ " return pd.concat(list(results.values()), keys=list(results.keys()), axis=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# And now the interesting part\n",
+ "\n",
+ "Let's start looking into the data! FANG stocks have been big over the past year, let's see how they look:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "fang_df = simulate_tickers([\"YAHOO/FB\", \"YAHOO/AAPL\", \"YAHOO/NFLX\", \"YAHOO/GOOG\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAIICAYAAADE513IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fang_df.xs('days', axis=1, level=1).hist()\n",
+ "plt.gcf().set_size_inches(18, 8);\n",
+ "plt.gcf().suptitle(\"Distribution of Days Until Profitability\", fontsize=18);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAGECAYAAABgaLg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fang_df.xs('score', axis=1, level=1).plot()\n",
+ "plt.gcf().set_size_inches(18, 6)\n",
+ "plt.gcf().suptitle(\"Profitability score over time\", fontsize=18);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "What about FANG vs. some cyclicals?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "cyclic_df = simulate_tickers([\"YAHOO/X\", \"YAHOO/CAT\", \"YAHOO/NFLX\", \"YAHOO/GOOG\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAIICAYAAADE513IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "cyclic_df.xs('days', axis=1, level=1).hist()\n",
+ "plt.gcf().set_size_inches(18, 8);\n",
+ "plt.gcf().suptitle(\"Distribution of Days Until Profitability\", fontsize=18);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAGECAYAAABgaLg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhUKhUCgUpor/A9AnO0PoIItTAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "cyclic_df.xs('score', axis=1, level=1).plot()\n",
+ "plt.gcf().set_size_inches(18, 6)\n",
+ "plt.gcf().suptitle(\"Profitability score over time\", fontsize=18);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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.\n",
+ "\n",
+ "Second, we see the same trend around August - the algorithm performs well in volatile markets.\n",
+ "\n",
+ "For a final test, let's try some biotech and ETFs!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "biotech_df = simulate_tickers(['YAHOO/REGN', 'YAHOO/CELG', 'GOOG/NASDAQ_BIB', 'GOOG/NASDAQ_IBB'])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBgAAAIICAYAAADE513IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWKBTQVcCAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "biotech_df.xs('days', axis=1, level=1).hist()\n",
+ "plt.gcf().set_size_inches(18, 8);\n",
+ "plt.gcf().suptitle(\"Distribution of Days Until Profitability\", fontsize=18);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAGECAYAAABgaLg8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xl81NW9//HXmWwIWQgJS5BFLXUBCrYPlwDaIgQR8EoV\nI4JyBex1K9aLoiLK9tBfqViuSrF61VoSRGVx7S1LDUqpEFBcUFwoAgGUiIYlAQJJZub8/pjJOJnM\nJJOZhCy8n4/H90FyvmfOOd/vjMj3M+d8jrHWIiIiIiIiIiJSG0djD0BEREREREREmgcFEURERERE\nREQkLAoiiIiIiIiIiEhYFEQQERERERERkbAoiCAiIiIiIiIiYVEQQURERERERETCoiCCiIg0KcZj\nljFmhzGmwhjj8pYvNMa4G6jPWcYYtzGmW5j1C4wx7wSUrTXG7Awoa7AxS/NX18+diIhIU6AggoiI\nBGWM+ZX3Acf/OGKM2WyM+Z0xpqH+HzIemAGsASYCN3rLLVDlgdwYM9IYM7Me+rTeI1zuIPWDvb4h\nxyzNQC3vd7XPh4iISFNnrK3Lv5lERORUYYz5FfAu8BKwAjBAZzwP+ecBz1prb2uAfhcDw6y17QLK\nY4AYa225X9lfgf+01sZE2edMPIGLM621e8KoHwdYa63Tr+xdoLu19qyTMWZpHmp6v72BuFj/z4eI\niEhTF9vYAxARkSbvI2vtS5W/GGOeAb4EfmOMmW6t/SHYi4wxsXgeoMvq2F8n4HBgobXWBbgCu6lj\n2/XCWlsRZr0mM+bGYIxJtNYebexxNKQwrjHk+22tdQMKIIiISLOi5QwiIlIn1tojQD6eh6OzoMra\n7p7GmP8xxuwFjgMXV77OGPMbY8yHxphSY8xhY8xqY8wAv/O/8uYPGAic4beE4gXv+Sr5Bbzf/P+n\n9+fKui5jTGXZOcaYPxtjthpjSowxx7xLMW6u4fISjTHzjTGF3nFuNMYMCqwULCdCMHUZszHmCe/v\nPwnSTidjjNMY83wt/RljzH8bY7Z4r7nYGPOVMeZ576wI/7rnG2OWGWO+M8acMMbsMca8ZIw5M6Be\nje+bXz23MeYFY8wgY8y/jDFHgLf8zicbYx41xmz39vd9sP5qub6fGWNeN8YUGWOOG2M+N8bc67+0\nxhjzB+9Yegd5fbL3da8FlGd5r+uQ9/wWY8ytQV5fYIx5x3vvVhljDgNbahhvbZ/RajkR/MrO834m\n9nk/u3nGmLO9da7xe092GWP+K0T/YV2XiIhIXWgmgoiIROKn3j+LvH9W5hRYDJQCf/T+XghgjHkU\nuBfYBDwAJAG3AO8aY66y1q4CvsCT/+AhIA34bzyBih0BfVR6BE8w/BLgBn78xneD98+B3nN/A3YB\nbYBs4DljTLq19tGAazJALuAE/uAd463AKmPMFdZa/6BBuGsB6zLmD4Hf4ckD8WBAO+O9dZ+rpb+H\ngNnAm8DTeGZBnAlcBSTgeW8wxlwJLAeOetvcgWcGyFCgN577Fe775u9CYJS3zYWVhcaYZDyBpy7A\nC8DnQAZwB7DRGHOBtXZvTRdmjLkA+CdQBiwA9gP/ATwK9AHGeavmAPfheXi/L6CZ0UB8wNhu8d6r\nfDzvzzFgCPC0MeYsa+39fq+3QHfgHWCp9x4m1jDs2j6jwXJxVJblAEeA/we0B6bg+SzO8F7zn4FD\nwM3AM8aYz621le3W9bpERETCZ63VoUOHDh06qh3Ar/Akfat8qE/H87D2nLf8Pb+6M71lawBHQDtn\n43mY/See9d+V5Rl4HoJ24s3R4y1/F9gZZDx/BVy1lfmdOy1E+bvefmOCjH9DwBhPx/Mg93lAG7uA\nd4K0uzPKMa8HvvG/H97ybcDWMN6zD2urB5wG/IAnwNOphnp1fd/c3vqXBWnrSTwPsb0DyrsCxcAL\nYVzbejxT/3sFlC8J7Bd4P8R9/BfwfeX14AmcHAcWBenvCaACOCPgfXcBE+rw31FN7/dMb3vdgnwW\n3wioe6e3/DDQ2a883XsNi/3K6nRdOnTo0KFDR10OLWcQEZHazMbz0Pk98Ameb8XfAK4OqGeBJ6xn\nnbe/kd4/51q/RITW2kI8D1jdgZ/X96CttccrfzbGJBhj2hlj0oB/AMnAuUHG/3jAGL/FM7viXGPM\nOfU9xiCexfOQPryywBjzSzwzP2pcyuBVDJwebLmBn6F4gkLzrLXf1VAvkvdti7X23SBtjQXWAYXG\nmLTKA8+D7kbg8pouyhjTHugHvGmt/Tzg9P/D8w2//+cxB899HOLXxhlAf+Alv+vJxjMz4QX/cXnH\n9n9ADJAV0N9B/GYyNBALzA8o+5f3zzettft8Fa0twhNk+qlf3UiuS0REJCxaziAiIrV5FliG58Hm\nGPBva221xIde24OUVa55/yLIucoHwrOAj6IZZCBjTBs8AZBsPN94+7NAapCXfRWkrHLcZ+F5WGtI\nS/B8U3wz8Hdv2c14pvAvCuP104DXgXXGmEJgrbed5fbHZJA/xXP9n9TSViTv278DK3oDAGl4AgXB\nknBaqiefrMtYvsTzDf1ZfmUvA/PwLGn4h7fsJu+f/vfxXDwBiDUh+rVAx4CyHdbak7G11a6A3w95\n/ywIUvcQ0M3v90iuS0REJCwKIoiISG2226r5AGpS2qAjqZuX8Xyj/794vsU9gOdhdQSefAtNbjae\ntfaEMeZF4Bbvw/cJPDkG3rTWHgjj9RuNJzHjUOAy7zEWeMgYM6CG4E99Cfb+V+YByMOTa6LBd6ew\n1h40xqwAfm2MaWOtPYYn38aX1toPA8Zm8eRTCDUrY2fA7yfrMx4qsBKq3AT8XNfrEhERCYuCCCIi\n0tAqH1Z6Uf3b1V4Bdeoq6DfCxpgUPMGCHGvtbwPO1TR1/jzgs3oeY6DavsV+Fvgtnm/OS/DkMPhL\n2I1bW4pnNsLrAMaY24Gn8MxomIdntoABzsfzYB9Kfb1vP+BZx58cYqlDOCr77xXk3Hl4AkKBY8kB\nfg1kG2P+DfyE6okWK2fOHKhDoKyuTsashUAn47pEROQU1eS+hRERkRancpu/e40xvuC1MSYDT36F\nAuDjCNs+6m2rbUB55be1Vf4/5+0z1BaPBphsjInzq98FGAN8Za2tr6UMocYMgLX2MzyJAW/2Hnus\ntW+H07B3zXugynvbzvvnP/DsqnGPMaZTDc3Vy/vmnfq/GLjIGDMqxLjb19LGD3iSXv6HMaZnwOkH\n8DyovxZQ/nc81/mf3sPlHYe/pXiSNc42xrQKMq5kY0x8TWMLQ43vdwM5GdclIiKnKM1EEBGRBmWt\n/bcx5jE8WwWuM8YswZPY8L/wbLs4Joo15hvxfGv/tDHm73iyzm+01u42xvwDuNEYcwL4ADgDz/aE\nO/nxgTpQLPAvY8zL3jHeCrTCs/VifQk25k3W2gK/Os/iSaRogVl1aPtLY8xGPFsy7sOTXPAWPDkV\nXgFPwkljzM148lxsNcY8D3wNdMCTt2CetfZv9fy+PYgnqeESY8wy7z0ox5OccTiwGc/WljW5C0+O\nh/eMMU/hmab/H3iSJy621q71r2ytdXrfx0nABUCeNymkf51vvTM1nvPeu0XAbjxbKvbBszVmT2BP\nmNcZTDjvd706SdclIiKnKAURRESkJsH2sa97I9ZONcZsB+4A5uB5gNwIXG/99rYP6DfUePy9jGda\n/vXAtXhmHkwAcoEb8KzBvxLPN9Hb8Xxr7QJeCNH2fwK3AfcDbYEtwH+GmBIebIzhlIUac4FfnVeA\n/8HzsL4wSJuh/BHPQ/mdQAqeHTXygT94Zzh4BmTt34wxl+BJxDgRSAL249lBwb9eXd63kJ8Va22J\nd8eIe4Dr8DzEOvFsw/geYew8Ya390BjTH0+yzNvx3JudeJYo/E+Il+XgCSK09v4crN2FxphtwBQ8\nAZe2eGYwbMOzvWlgToG6/vcQzvsdrpr+e6xSHsF1iYiIhMWcnATDIiIiEi7vVPNCPN9YD6+tvoiI\niMjJopwIIiIiTc+NeL45fraxByIiIiLiTzMRREREmghjzJV4cjfMxDMToW8U+SJERERE6p2CCCIi\nIk2EMWYXnmSIm4H/stZ+2chDEhEREalCQQQRERERERERCYtyIoiIiIiIiIhIWBREEBEREREREZGw\nKIggIiIiIiIiImFREEFEREREREREwqIggoiIiIiIiIiERUEEEREREREREQmLgggiIiIiIiIiEhYF\nEUREREREREQkLAoiiIiIiIiIiEhYFEQQERERERERkbAoiCAiIiIiIiIiYak1iGCM+YsxZr8x5lO/\nsrnGmC+NMZ8YY141xiT7nXvAGLPde/7yhhq4iIiIiIiIiJxc4cxE+CswNKDsH0Ava+35wHbgAQBj\nTE/gOuA8YBjwZ2OMqb/hioiIiIiIiEhjqTWIYK19DzgUUJZnrXV7f90IdPH+fBXwirXWaa0twBNg\nuKj+hisiIiIiIiIijaU+ciJMBFZ4fz4d2Ot37ltvmYiIiIiIiIg0c7HRvNgY8yBQYa19OYLX2mj6\nFhEREREREZGGY62tlp4g4pkIxpjxwHBgrF/xt0BXv9+7eMtCDUhHPRwzZ85s9DE0x0P3Tfe1qR+6\nl7qnTfnQvdR9bU6H7qvuZVM/dF91L5viEUq4QQTjPSoDCFcA9wJXWWvL/Oq9BVxvjIk3xpwJ9ADe\nD7MPEREREREREWnCal3OYIx5CRgIpBlj9gAzgWlAPPC2d/OFjdbaO6y1XxhjlgJfABXAHbamEIaI\niIiIiIiINBu1BhGstWODFP+1hvpzgDnRDErqZuDAgY09hGZJ961h6L7WH93L+qd7Wn90LxuG7mvD\n0H2tP7qXDUP3tf7oXjY801gTBYwxmqQgIiIiIiIi0gQZY7BBEitGtTuDiIiIiIiIROaMM85g9+7d\njT0MOcV1796dgoKCsOtrJoKIiIiIiEgj8H7T29jDkFNcqM9hqJkIEW/xKCIiIiIiIiKnFgURRERE\nRERERCQsCiKIiIiIiIiISFgURBARERGRqKw7fJhrtm5t7GGIiMhJoCCCiIiIiETl+/JyXi8qYlNJ\nSWMPRUREGpiCCCIiIiISFRcQbwy/11Z1Ii3CuHHjmDhxYpWyf/7zn6Snp7N//34AFi5ciMPhYNmy\nZdXqde3atVqbl112GS+88ILv9+LiYm6//XYyMjJITEykb9++LFy4sNrrFi5cSJ8+fWjTpg2dO3fm\njjvuoLi4uFq9K664gry8PAD+/e9/c91119G+fXtSU1M5//zzefzxx7HWsnv3bhwOB8nJySQnJ5OU\nlERycrLvOiZMmMCMGTNC3psFCxbQt29f33gGDRrEkiVLQtZviRREEBEREZGoOK1leFoa7x85wmdH\njzb2cEQkSk8++SSrVq1izZo1AJSVlXHLLbfw+OOP07FjRwByc3NJS0sjNze32uuNqbYrYBUVFRUM\nHjyYvXv3smnTJoqLi5k7dy5Tp07liSee8NWbN28eDzzwAPPmzaOkpISNGzeye/duhgwZgtPp9NUr\nLS3lww8/5Fe/+hU7duwgMzOT7t27s3XrVg4dOsSyZcv46KOPOHLkiG98xcXFlJSUcOTIEUpKSsjO\nzq71vtx5553Mnz+fxx9/nIMHD/Ltt9/yyCOPsHr16tpvaguiIIKIiIiIRMVlLYkxMfx3ly7M2bOn\nsYcjIlFq164d8+fP55ZbbqG0tJRZs2bRo0cPxo0bB8Du3btZt24dzz77LKtWreL777+vU/u5ubl8\n8803LF++nG7duhETE8PQoUOZP38+06dP5+jRoxw5coRZs2axYMEChgwZQkxMDN26dWPp0qUUFBTw\n4osv+tpbs2YNAwYMIC4ujpkzZzJgwAAee+wxX8Djpz/9KYsWLSI5Odn3Gmttnca8fft2nn76aZYs\nWcKgQYNISEjAGEP//v2rzLA4FSiIICIiIiJRcVlLDHB75868fegQ20tLG3tIIhKla6+9ll/84heM\nGTOG559/nueee853Ljc3lwsuuICrr76a8847j8WLF9ep7by8PIYNG0arVq2qlI8aNYoTJ06Qn5/P\nhg0bKCsr4+qrr65Sp02bNgwfPpy3337bV7ZixQpGjBgBeAIK1157ba1jqGsQ4Z133qFbt278/Oc/\nr9PrWiIFEUREREQkKi5riTWG5NhY7uvalezPP+eH8vLGHpZIs2dM/RyReuqpp3jnnXeYOXMmnTt3\n9pUvWrSIG264AYCxY8dWW9Lw7bff0q5dO9+RmprK+vXrfeeLiorIyMio1l9MTAzp6ekUFRVRVFRE\neno6Dkf1R9aMjAyKiop8v/sHEQ4cOBC0bX/WWtq3b+8bW7t27di2bVuNrykqKqJTp05Vyrp27Upq\naiqnnXYae/furfH1LUlsYw9ARERERJo3p7XEeJ9UpnTtSonLxa8++YQ1ffuSkZDQyKMTab7q+GV5\nvevQoQPp6en07NnTV7Z+/Xp27drF6NGjARgzZgwPPvggn376KX369AHg9NNPZ0/A0qbLLrvM93N6\nejqFhYXV+nO5XL7ggdvtpqioCLfbXS2QUFhYSHp6OgBbt26lbdu2viBHWlpa0Lb9GWM4cOBArbkb\n/AVrd+/evbhcLuLj4+s8s6E500wEEREREYmKC3xBBGMMD595JuM6duSXn3zCwYqKxh2ciNSrnJwc\nAM4//3wyMjLIzMzEGOMrD0dWVhYrV67k+PHjVcqXL19Oq1atyMzMpF+/fiQkJPDaa69VqXP06FFW\nrlxJVlYW4JmFMHz48Cptv/rqq7WOoa4P/YMGDeKbb77ho48+irqt5k5BBBERERGJistvJkKlB7p3\np0tCApu92dBFpPkrKytj2bJlPPfcc3zyySds2bKFLVu2MH/+fBYvXozb7Q6rnXHjxtGlSxeys7PZ\nvXs3TqeT1atXc9dddzF79mzftoszZszgzjvvZPXq1TidTgoKChg9ejTdunXjxhtvBKouZQCYPXs2\nGzZs4P777/dtR/n1118zbtw4SkpKAM9Df00P/k6nk7KyMt9RUVHB2Wefza233sr1119PXl4eJ06c\nwO12s379+jrNaGgJFEQQERERkahU5kQI1CUhgf3KjSDSrPk/IL/xxhu0bt2acePG0aFDB98xceJE\nXC4Xq1atCqud+Ph48vLy6Nq1KxdffDEpKSlMmTKFOXPmcPfdd/vq3Xvvvfz+979nypQppKSk0K9f\nP7p3705eXh5xcXEUFxfz5Zdf0r9/f99rzjrrLPLz89m1axe9evUiNTWV7OxsLrzwQpKSknxjSU1N\nJTk52Rew8N9a8tFHH6V169a+Y/DgwQAsWLCA3/3ud9x9992kpaXRtWtXZs6cydKlS+nWrVv0N7uZ\nMI019cIYY0+1aR8iIiIiLdFje/awv7ycP/boUaV8ytdf0zE+nntPoX9ci9SFMeaUmwpfn5YtW8ar\nr77KK6+80thDadZCfQ695dUixJqJICIiIiJRCbacAaBTfDzfaSaCiDSQ1NRUJk+e3NjDOOVodwYR\nERERiYp/YkV/HePj+eTo0ZM/IBE5JVQmV5STSzMRRERERCQqoXIiaCaCiEjLoyCCiIiIiETFqeUM\nIiKnDAURRERERCQqLmuJCVLeMT6e/RUVJ308IiLScBREEBEREZGohEqsmBYXx2Gnk4ow944XEZGm\nT0EEEREREYmKC4LmRIgxhvZxcXyv2QgiIi2GgggiIiIiEpVQORHAu6RBeRFERFoMBRFEREREJCqh\nljOAkiuKiLQ0CiKIiIiISFRCJVYEBRFEmqNx48YxceLEKmX//Oc/SU9PZ//+/QAsXLgQh8PBsmXL\nqtXr2rVrtTYvu+wyXnjhBd/vxcXF3H777WRkZJCYmEjfvn1ZuHBhtdctXLiQPn360KZNGzp37swd\nd9xBcXFxtXpXXHEFeXl5zJ49m/j4eJKTk2nXrh2XXHIJGzdurDK+mJgYkpOTSU5OJikpieTkZDZt\n2uSr8/bbbzNo0CCSk5Np3749v/jFL3jsscco9/5dNmvWLBwOB8uXL/e9xuVy4XA42LNnT023tkVQ\nEEFEREREouKyNmhOBICOcXFaziDSzDz55JOsWrWKNWvWAFBWVsYtt9zC448/TseOHQHIzc0lLS2N\n3Nzcaq83If4+qFRRUcHgwYPZu3cvmzZtori4mLlz5zJ16lSeeOIJX7158+bxwAMPMG/ePEpKSti4\ncSO7d+9myJAhOJ1OX73S0lI+/PBDfvWrXwFw/fXXU1JSQlFREQMHDiQ7O7tK/6effjolJSWUlJRw\n5MgRSkpKuPjiiwFYtmwZ2dnZ3HjjjezZs4cffviBJUuW8M0337B3717f9aWlpTFz5kystWFfd0uh\nIIKIiIiIRKWmnAiaiSDS/LRr14758+dzyy23UFpayqxZs+jRowfjxo0DYPfu3axbt45nn32WVatW\n8f3339ep/dzcXL755huWL19Ot27diImJYejQocyfP5/p06dz9OhRjhw5wqxZs1iwYAFDhgwhJiaG\nbt26sXTpUgoKCnjxxRd97a1Zs4YBAwYQFxdXpR+Hw8ENN9zAvn37OHDgQFhju+eee5g1axYTJ06k\nbdu2APz0pz/lySef5Cc/+Ymv3tChQ4mPj2fRokW+Mv+AQkumIIKIiIiIRMUFCiKItDDXXnstv/jF\nLxgzZgzPP/88zz33nO9cbm4uF1xwAVdffTXnnXceixcvrlPbeXl5DBs2jFatWlUpHzVqFCdOnCA/\nP58NGzZQVlbG1VdfXaVOmzZtGD58OG+//bavbMWKFYwYMaJaP+Xl5eTk5JCWlkZqamqt49q2bRvf\nfvst11xzTa11HQ4HDz/8MLNnz8blctVavyWJbewBiIiIiEjzVlNiRe3OIBI5M7t+psfbmZF9Q/7U\nU0/xk5/8hDlz5tC5c2df+aJFi7jzzjsBGDt2LLm5uUyePNl3/ttvv6Vdu3Y/9m8tx44d881kKCoq\n4sILL6zWX0xMDOnp6RQVFeF2u0lPT8fhqP69d0ZGBh999JHv9xUrVvDQQw/5fl+yZAn/93//R0lJ\nCampqbz66qtV2vEfn7UWYwzffvstRUVFAHTq1MlXd8yYMaxatYry8nKeffZZbrjhBt+5K6+8kkce\neYTnn3+e3/zmN7XdzhZDQQQRERERiUpNORE0E0EkcpE+/NeXDh06kJ6eTs+ePX1l69evZ9euXYwe\nPRrwPGQ/+OCDfPrpp/Tp0wfw5BwITDB42WWX+X5OT0+nsLCwWn8ul4uioiLS09Nxu92+YEJgIKGw\nsJD09HQAtm7dStu2bTn99NN950ePHk1ubi4HDx5k1KhRbN68mV/+8pe+88HGB5CWluZrv3v37gC8\n/PLLAFx66aVBZxw88sgjTJw4kRtvvLHauZZKyxlEREREJCpO7c4gcsrIyckB4PzzzycjI4PMzEyM\nMb7ycGRlZbFy5UqOHz9epXz58uW0atWKzMxM+vXrR0JCAq+99lqVOkePHmXlypVkZWUBnlkIw4cP\nD9pPu3bt+N///V9mzZrl21WiJueccw6nn356tT5ru5YePXrw5z//WYkVRURERETCUdNyhraxsRx3\nuzlxiq0ZFmmJysrKWLZsGc899xyffPIJW7ZsYcuWLcyfP5/FixfjdrvDamfcuHF06dKF7Oxsdu/e\njdPpZPXq1dx1113Mnj3bt+3ijBkzuPPOO1m9ejVOp5OCggJGjx5Nt27dfN/8h8qHUOnss8/miiuu\n4NFHH/WVhUqAaIzhj3/8I7Nnz+Yvf/kLhw8fBmD79u01BiEeeeQR5s6dG9a1twQKIoiIiIhIVGpK\nrGiM8eRFqKg4uYMSkXrh/+36G2+8QevWrRk3bhwdOnTwHRMnTsTlcrFq1aqw2omPjycvL4+uXbty\n8cUXk5KSwpQpU5gzZw533323r969997L73//e6ZMmUJKSgr9+vWje/fu5OXlERcXR3FxMV9++SX9\n+/ev8RqmTJnCc88958t5UFhYSHJyMsnJyb6Axeuvvw7Addddx9KlS1m0aBHdunWjffv2XH/99dx6\n663Vtoqs1L9/fy666KJTZiaCaaxtKIwx9lTZAkNERESkJfuPzz7jvzIyuMq7RjnQhR9+yIKf/pSL\nk5NP8shEmjZjzCmzLWBDWLZsGa+++iqvvPJKYw+lWQv1OfSWV4uMaCaCiIiIiESlpuUM4MmLoB0a\nRKS+paamVtkVQk4O7c4gIiIiIlFx1ZBYEZRcUUQaRmVyRTm5NBNBRERERKJS20yEjnFxCiKIiLQQ\nCiKIiIiISFSc1hKr5QwiIqeEWoMIxpi/GGP2G2M+9StLNcb8wxizzRiz2hiT4nfuAWPMdmPMl8aY\nyxtq4CIiIiLSNNS0OwNoOYOISEsSzkyEvwJDA8qmAnnW2nOAd4AHAIwxPYHrgPOAYcCfzamyz4WI\niIjIKarW5QwKIoiItBi1BhGste8BhwKKRwI53p9zgF97f74KeMVa67TWFgDbgYvqZ6giIiIi0hS5\ntJxBROSUEWlOhA7W2v0A1trvgA7e8tOBvX71vvWWiYiIiEgL5Qxjd4ZCBRFERFqE+kqsaOupHRER\nERFpZmpbzpAY4wkxHHU6T9aQRESkgcRG+Lr9xpiO1tr9xphOwPfe8m+Brn71unjLgpo1a5bv54ED\nBzJw4MAIhyMiIiIijaW2xIrGGF9yxR6xkf7zU0REGtLatWtZu3ZtrfXCnYlgvEelt4Dx3p9vAt70\nK7/eGBNvjDkT6AG8H6rRWbNm+Q4FEERERESap9pyIoCWNIg0V6+88gqZmZkkJibSqVMn+vXrx9NP\nP+07v2HDBgYPHkxycjKpqamMHDmSL7/8skobxcXF3H777WRkZJCYmEjfvn1ZuHBhnfuqdO655/L1\n118zfvx4HA4Hmzdv9p3bsWMHDkf1x9zx48cTFxfH/v37q43t5ptvJiMjg5SUFM4991zmzp3rO+9w\nOEhKSiI5OZn27dszZMgQli5dGvReheoD4IsvvmDkyJG0bduWlJQUsrKy2LRpU9B2/O3evRuHw4Hb\n7QZgwoQJJCQkkJycTEpKChdeeCHr1q3z1c/JySE2Npbk5GSSk5Pp0aMHzzzzTK39gOeLff9n9FDC\n2eLxJWBAy1aHAAAgAElEQVQDcLYxZo8xZgLwB2CIMWYbMNj7O9baL4ClwBfACuAOa62WOoiIiIi0\nYM5aljOAtnkUaY7mzZvH5MmTuf/++9m/fz/fffcdzzzzDBs2bKCiooL8/HyGDh3K1VdfTWFhIbt2\n7aJPnz4MGDCAgoICACoqKhg8eDB79+5l06ZNFBcXM3fuXKZOncoTTzwRdl+Vdu7cidvtpkePHhhj\nSEtL46GHHqoy7sANAktLS3nttddo27YtL774YpVzkydP5tixY2zbto3i4mLeeustevToUaWtTz/9\nlJKSErZt28ZNN93EpEmTePjhh8PuY8eOHVxyySX07duXgoIC9u3bx8iRIxkyZEiVAEgogddz//33\nU1JSQnFxMbfddhvXXHMN/o/d/fv3p6SkhJKSEpYvX859993Hli1bau0nbNbaRjk8XYuIiIhIc3dW\nfr7dfuxYjXV+u22bnb9370kakUjz0JSfiYqLi22bNm3s66+/HrLOpZdeaidNmlStfNiwYfamm26y\n1lr7/PPP244dO9rjx49XqbNkyRKbmJhojxw5ElZflebPn2/vuusua62148ePt/fcc4/NyMiw69at\ns9Za+/XXX1uHw1HlNTk5ObZbt252/vz5tnfv3lXO9e7d27755psh+zPG2B07dlQpW758uW3VqpU9\nePBgWH3ceOONdsSIEdXavv322+2gQYNqvN6CggLrcDisy+XyXfP06dN950tLS60xxhYWFlprrV24\ncKG99NJLq7Rx0UUX2ZdffjlkH6E+h97yas/y9ZVYUUREREROUbUlVgTNRBCJiDH1c0QgPz+f8vJy\nrrrqqqDnjx8/zoYNG7j22murnbvuuut4++23AcjLy2PYsGG0atWqSp1Ro0Zx4sQJ8vPza+3L34oV\nKxgxYoTv99atWzNt2jSmTZsW8jW5ubmMHTuW0aNH89VXX/Hxxx/7zmVmZjJt2jQWLlzI119/XWv/\nACNHjsTpdPL++z+u3K+pj7y8PLKzs6u1c9111/Gvf/2L8gj/bnS5XOTk5HDWWWfRsWPHoHU++OAD\ntm/fzgUXXBBRH8EoiCAiIiIiUXGBciKINARr6+eIQFFREenp6VXyCwwYMIDU1FTatGnD5s2bcbvd\nZGRkVHttRkYGRUVFvnaC1YmJiSE9PZ2ioqIa+2rdujXvvfce4AlcbN68uVo+vVtuuYU9e/awevXq\nav3s2bOHd999l7Fjx9KhQweysrLIzc31nV+wYAE33ngjTz31FL169eLss89m1apVNd6b2NhY0tPT\nOXjwYFh9hLoHGRkZuFwuXzvheuyxx2jXrh1JSUncfffdPPzww1WWPOTn59OuXTuSk5PJzMxk3Lhx\nVZZoREtBBBERERGJinIiiLQ8aWlpFBUV+RL6Aaxfv55Dhw6RlpbGkSNHcDgcFBYWVnttYWEh6enp\nAKSnpwet43K5fMGDmvpKT0/3la9Zs4b+/fsTFxdXpa34+HimT5/O9OnTq/WzaNEievbsyc9+9jMA\nxowZw0svvYTL5QIgISGBqVOn8sEHH3DgwAGys7PJzs7m8OHDIe+N0+nkhx9+oF27diH7WLx4sa+P\nUPegsLDQl9ehLu69914OHjxIaWkpmzdvZsqUKVUCKP369ePgwYOUlJTw3XffsXXrVh588ME69VET\nBRFEREREJCrhLGfISEhQEEGkGenXrx8JCQm8+eab1c5Za0lMTKR///4sW7as2vmlS5eSlZUFQFZW\nFitXruT48eNV6ixfvpxWrVqRmZlZa1+VVqxYwfDhw4OOd8KECRw+fJjXXnutSvmiRYvYuXMnGRkZ\nZGRkcM8991BUVMSKFSuqtZGYmMi0adM4duwYu3btCtoPwBtvvEFcXBwXXXRRyD4OHDjg6yMrKyvo\nfVqyZAmZmZnVgiJ10bNnTwYMGMDf//73oOfbt2/PqFGj+Nvf/hZxH4EURBARERGRqLisJaaWOpqJ\nINK8pKSkMGPGDO644w5effVVjh49irWWTz75hNLSUgDmzJlDTk4OCxYs4OjRoxw6dIiHHnqIjRs3\nMmPGDADGjRtHly5dyM7OZvfu3TidTlavXs1dd93F7NmzSUpKCqsvgJUrV1bJh+AvJiaGWbNm8eij\nj/rK8vPz2blzJx988AFbtmxhy5YtfP7554wZM8a33OCRRx5h8+bNVFRUUFZWxhNPPEFqairnnHNO\ntT4OHTrE4sWLmTRpElOnTiU1NbXGPnJycgCYOXMmGzZsYPr06Rw6dIijR4/ypz/9iZycnGq7PARj\na1iS8tVXX/Hee+/Ru3fvoPUPHDjA66+/XuV81IJlWzwZB004E6mIiIiIhC9l3Tp7qLy8xjrlLpeN\nXbvWOt3ukzQqkaavOTwTvfTSS/aiiy6ybdq0sR06dLCZmZn2+eeftxUVFdZaa9evX28HDhxoExMT\nbUpKir3yyivtF198UaWNQ4cO2dtuu8127NjRtm7d2vbu3du+8MILderrs88+sz/72c+q1J8wYUKV\nnQrcbrft3bu3jYmJsdZae9ttt9ns7Oxq/bz//vu2VatW9tChQ/aRRx6xvXv3tikpKTYtLc1edtll\nNj8/31fX4XDYxMREm5SUZNPS0uygQYPsK6+84jsfTh/WWvv555/bK6+80iYnJ9uYmBibmppqV69e\nXev9D7Y7Q0JCgk1KSrKJiYm2e/fu9qGHHvLVX7hwoY2NjbVJSUk2KSnJduzY0d5www32hx9+CNlH\nqM8hIXZnMDbCRBvRMsbYxupbREREROpP4rp1FPbvT1JsbI312q9fz9YLL6RjfPxJGplI02aMqfFb\nZvnRY489xoEDB/jDH/7Q2EOJ2r59+8jMzGT27NlMmDChsYcT8nPoLa+2Vk3LGUREREQkKi6oNScC\naEmDiETuzDPPbBIP3PWhc+fOrFy5ksLCwirLNZqLmsPFIiIiIiK1CCexIkCGN4jQ9ySMSURalmuv\nvbaxh1CvevXqRa9evQB46aWXuPXWW6ts02it5YwzzuCzzz5rrCGGpCCCiIiIiETFZS2xmokgIhKR\nsWPHMnbs2MYeRti0nEFEREREImatxU14/6jsFB9PYVlZQw9JREQakIIIIiIiIhIxl7U4oMo03FA0\nE0FEpPlTEEFEREREIhZuUkX4MSeCiIg0XwoiiIiIiEjEws2HAJqJICLSEiiIICIiIiIRc4a5MwN4\ncyIoiCAi0qwpiCAiIiIiEXNZS0yYdTUTQUSk+VMQQUREREQi5qrDTIS2sbGUud2UulwNPCoRqS+v\nvPIKmZmZJCYm0qlTJ/r168fTTz/tO79hwwYGDx5McnIyqampjBw5ki+//LJKG8XFxdx+++1kZGSQ\nmJhI3759WbhwYZ37qnTuuefy9ddfM378eBwOB5s3b/ad27FjBw5H9cfc8ePHExcXx/79+6uN7eab\nbyYjI4OUlBTOPfdc5s6d6zvvcDhISkoiOTmZ9u3bM2TIEJYuXRr0XoXqA+CLL75g5MiRtG3blpSU\nFLKysti0aVPQdvzt3r0bh8NBcnIyycnJZGRk8Nvf/haX39+jZ555Ju+88w4AOTk5xMbG+ur36NGD\nZ555ptZ+6kJBBBERERGJmAvCzolgjKFTfDz7NRtBpFmYN28ekydP5v7772f//v189913PPPMM2zY\nsIGKigry8/MZOnQoV199NYWFhezatYs+ffowYMAACgoKAKioqGDw4MHs3buXTZs2UVxczNy5c5k6\ndSpPPPFE2H1V2rlzJ263mx49emCMIS0tjYceeqjKuAN3iyktLeW1116jbdu2vPjii1XOTZ48mWPH\njrFt2zaKi4t566236NGjR5W2Pv30U0pKSti2bRs33XQTkyZN4uGHHw67jx07dnDJJZfQt29fCgoK\n2LdvHyNHjmTIkCFVAiChGGMoLi6mpKSEzz77jPz8fJ566qmQ9fv3709JSQklJSUsX76c++67jy1b\nttTaT9istY1yeLoWERERkebsmxMnbMb69WHXv3jzZrv+8OEGHJFI89GUn4mKi4ttmzZt7Ouvvx6y\nzqWXXmonTZpUrXzYsGH2pptustZa+/zzz9uOHTva48ePV6mzZMkSm5iYaI8cORJWX5Xmz59v77rr\nLmuttePHj7f33HOPzcjIsOvWrbPWWvv1119bh8NR5TU5OTm2W7dudv78+bZ3795VzvXu3du++eab\nIfszxtgdO3ZUKVu+fLlt1aqVPXjwYFh93HjjjXbEiBHV2r799tvtoEGDarzegoIC63A4rMvl8pXd\nd9999tZbb/X9fsYZZ9g1a9ZYa61duHChvfTSS6u0cdFFF9mXX345ZB+hPofe8mrP8rH1F44QERER\nkVNNXZYzgPIiiNSFWbu2XtqxAwfW+TX5+fmUl5dz1VVXBT1//PhxNmzYUO0beYDrrruOBx98EIC8\nvDyGDRtGq1atqtQZNWoUN9xwA/n5+bjd7hr78rdixQruvvtu3++tW7dm2rRpTJs2jX/9619BX5Ob\nm8vYsWMZPXo0d999Nx9//DE///nPAcjMzGTatGkcPHiQSy65pMoshFBGjhyJ0+nk/fffZ+jQobX2\nkZeXxx/+8Ieg9+nyyy+nvLyc+Pj4Gvv0PNPDvn37WL16NZMnT651nAAffPAB27dv54ILLgirfjgU\nRBARERGRiNUlsSIoiCBSF5E8/NeXoqIi0tPTq+QXGDBgAF988QXl5eWsWrUKt9tNRkZGtddmZGRQ\nVFTka+fCCy+sVicmJob09HSKiopwu90h+yorK+Mf//gHl1xyCcePH2fz5s0MDLgvt9xyC4899hir\nV6+uFgTYs2cP7777Lo8//jgdOnQgKyuL3Nxc3wP+ggULePzxx3nqqae49dZb6d69O/Pnz+eKK64I\neW9iY2NJT0/n4MGDYfVRVFQU8j65XC4OHjxIp06dQvZnraV9+/ZYaykpKaFfv36MGjUqZP38/Hza\ntWuH0+nk2LFjTJo0KazgSLiUE0FEREREIuayNuycCAAZCQkKIog0A2lpab4H/Err16/n0KFDpKWl\nceTIERwOB4WFhdVeW1hYSHp6OgDp6elB67hcLl+goqa+0tPTfeVr1qyhf//+xMXFVWkrPj6e6dOn\nM3369Gr9LFq0iJ49e/Kzn/0MgDFjxvDSSy/5EhMmJCQwdepUPvjgAw4cOEB2djbZ2dkcPnw45L1x\nOp388MMPtGvXLmQfixcv9vUR6h4UFhb68jrUxBjDgQMHOHToEKWlpfTv35/LL788ZP1+/fpx8OBB\nSkpK+O6779i6datvZkh9UBBBRERERCLmjGA5Q6GCCCJNXr9+/UhISODNN9+sds5aS2JiIv3792fZ\nsmXVzi9dupSsrCwAsrKyWLlyJcePH69SZ/ny5bRq1YrMzMxa+6q0YsUKhg8fHnS8EyZM4PDhw7z2\n2mtVyhctWsTOnTvJyMggIyODe+65h6KiIlasWFGtjcTERKZNm8axY8fYtWtX0H4A3njjDeLi4rjo\nootC9nHgwAFfH1lZWUHv05IlS8jMzKwWFAmm8j4kJCQwfvx4Nm7c6JsJUZP27dszatQo/va3v9Va\nN1wKIoiIiIhIxFygnAgiLVBKSgozZszgjjvu4NVXX+Xo0aNYa/nkk08oLS0FYM6cOeTk5LBgwQKO\nHj3KoUOHeOihh9i4cSMzZswAYNy4cXTp0oXs7Gx2796N0+lk9erV3HXXXcyePZukpKSw+gJYuXIl\nI0aMCDremJgYZs2axaOPPuory8/PZ+fOnXzwwQds2bKFLVu28PnnnzNmzBhyc3MBeOSRR9i8eTMV\nFRWUlZXxxBNPkJqayjnnnFOtj0OHDrF48WImTZrE1KlTSU1NrbGPnJwcAGbOnMmGDRuYPn06hw4d\n4ujRo/zpT38iJycnaE6JQPbHzQkoKysjNzeXjIwM30yIYPUrHThwgNdff53evXvX2k+4lBNBRERE\nRCKmxIoiLde9995Lly5dmDt3LjfddBNt2rThrLPOYu7cufTv35/Y2FhWr17Ngw8+yAMPPEBMTAyX\nXnop69ev5yc/+QngWWqQl5fHAw88wMUXX8yRI0c466yzmDNnDhMmTAi7r61bt5KUlESXLl18rwnc\nynHMmDHMmTPHtxQhNzeXX//61/Ts2bNKvbvuuotf/vKXHD58GGMMEyZMYO/evcTGxtKnTx/+/ve/\n07p1a18fffv2xRhDfHw8ffv25cknn2T06NFh99GjRw/ee+897r//fs444wyOHTtGcnIyb7zxBpdd\ndlmt74MxhtTUVMCTj6Fv37689dZbIe/Dxo0bSU5OBjyJJ7Oysqpspxkt4x+lOJmMMbax+hYRERGR\n+vHxkSNM3LaNj8PM/L3nxAkGfPwxe/v1a+CRiTR9xhj0TBSexx57jAMHDgTd5aC52bdvH5mZmcye\nPbtKIKWxhPocesurRYm1nEFEREREIuas4+4MHePj2V9ejlsPTiJSB2eeeWaTeOCuD507d2blypUU\nFhZWWa7RXGg5g4iIiIhErK7LGRIcDhJjYjhYUUF6Lfuii4hUuvbaaxt7CPWqV69e9OrVC4CXXnqJ\nW2+9tcqyBGstZ5xxBp999lljDTEkBRFEREREJGJ1TawIP+ZFUBBBRATGjh3L2LFjG3sYYdNyBhER\nERGJmMtaYusYRMhQckWpgxMuF8/t29fYwxARLwURRERERCRizjouZwDt0CB1U3DiBLMKChp7GCLi\npeUMIiIiIhIxVx0TK4IniFCoIIKEqdTt5rjb3djDaBDdu3evtj2fyMnWvXv3OtVXEEFEREREIlbX\nxIqgmQhSN6UuV4sNIhRohoU0Q1rOICIiIiIRcyongjSwUrebE2530H3sReTkUxBBRERERCIWze4M\nIuEodbkAONFCZyOINDcKIoiIiIhIxCJdzqCcCBKuUm/woFRBBJEmQUEEEREREYlYpIkVNRNBwlU5\nE+G4908RaVwKIoiIiIhIxCLJidAuLo6jLhdl+mZZwlA5A6GlJlcUaW4URBARERGRiEWynMFhDB3j\n49mv2QgSBt9MBAURRJoEBRFEREREJGKRJFYE5UWQ8GkmgkjToiCCiIiIiEQskpkIoLwIEr7KmQil\nyokg0iQoiCAiIiIiEYskJwIoiCDh00wEkaYlqiCCMWayMWarMeZTY8xiY0y8MSbVGPMPY8w2Y8xq\nY0xKfQ1WRERERJqWSHZnAMhQEEHCpJwIIk1LxEEEY0xn4E7gF9baPkAsMAaYCuRZa88B3gEeqI+B\nioiIiEjTo+UM0tBK3W5ijdEWjyJNRLTLGWKANsaYWOA04FtgJJDjPZ8D/DrKPkRERESkiYoqsWJZ\nWf0PSFqcUpeLtNhYzUQQaSIiDiJYa/cB84A9eIIHxdbaPKCjtXa/t853QIf6GKiIiIiIND3KiSAN\nrdTtJj0uzpcbQUQaV2ykLzTGtMUz66A7UAwsM8bcANiAqoG/+8yaNcv388CBAxk4cGCkwxERERGR\nRhDpcgblRJBwHXO5SIuL03IGkQa2du1a1q5dW2u9iIMIQBaw01p7EMAY8zrQH9hvjOlord1vjOkE\nfB+qAf8ggoiIiIg0P5EmVuzoDSJYazERBCHk1FHqdtMlIUHLGUQaWOAX+7Nnzw5aL5qcCHuATGNM\nK+P5m38w8AXwFjDeW+cm4M0o+hARERGRJswV4XKG1jExJDgcHHY6G2BU0pKUVs5EUBBBpEmIeCaC\ntfZ9Y8xy4GOgwvvns0ASsNQYMxHYDVxXHwMVERERkabHGeFyBvgxL0JqXFw9j0paklK3m7S4OI5q\nOYNIkxDNcgastbOBwDkOB/EsdRARERGRFs4FxEUYRKjMi3Bemzb1OyhpUSp3Z/heOTREmoRot3gU\nERERkVNYpIkVQTs0SHgqZyJoOYNI06AggoiIiIhELNKcCOAJIhQqiCA1qPAGDlJiYxVEEGkiFEQQ\nERERkYg5I9ydATQTQWpX6nbT2uHgNIdDWzyKNBEKIoiIiIhIxLScQRpSqctF65gYTxBBMxFEmgQF\nEUREREQkYi6IOIiQkZCgIILUyDcTISaGUgURRJoEBRFEREREJGLKiSANqcpMBC1nEGkSFEQQERER\nkYg5tZxBGlDlTITWWs4g0mQoiCAiIiIiEXNFkVgxPS6Ow06nLwO/SCDfTISYGAURRJoIBRFERERE\nJGLRJFaMMYb2cXF8X1FRz6OSlqLK7gwKIog0CQoiiIiIiEjEXBBxTgTQkgapmX9OhFLlRBBpEhRE\nEBEREZGIRZMTAbzJFcvK6nFE0pJUzkRo5XBQbi0uaxt7SCKnPAURRERERCRi0SxnAM1EkJpVzkQw\nxnCaw8EJLWkQaXQKIoiIiIhIxKJJrAiQoSCC1KByJgKgbR5FmggFEUREREQkYi5rlRNBGswx70wE\nQMkVRZoIBRFEREREJGL1khNBQQQJodTlok3lTISYGEoVRBBpdAoiiIiIiEjEXKCcCNJgSt3uqjMR\ntJxBpNEpiCAiIiIiEYs2saJyIkhNSl0uX06E1lrOINIkKIggIiIiIhGrr5wIVlv3SRBVZiLExCiI\nINIEKIggIiIiIhFzRrk7Q2JsLAY4omnqEoT/TAQlVhRpGhREEBEREZGIRbucAZQXQUILzIlQqmCT\nSKNTEEFEREREIhZtYkVQEEFC00wEkaZHQQQRERERiVi0OREAMhISFESQoPxnIrRWTgSRJkFBBBER\nERGJmLOeljMUKoggQVSbiaDlDCKNTkEEEREREYmYK8rEiqDlDBJaYE4EzUQQaXwKIoiIiIhIxJRY\nURpSlZkIMTGUKogg0ugURBARERGRiDnrIyeCgggSQrWZCFrOINLoFEQQERERkYhpdwZpKG5rOeF2\n08o7E6G1ljOINAkKIoiIiIhIxOprOUNhWVk9jUhaisoAgsP7+TpNuzOINAkKIoiIiIhIxOojsWKH\nuDgOOJ24rK2XMUnL4J8PAZRYUaSpUBBBRERERCJWHzkRYh0O2sXG8oOWNIgf/3wI4AkilCongkij\nUxBBRERERCJWH8sZQHkRpDrNRBBpmhREEBEREZGIuQAHhoqK6NrpEB/P/mgbkRblWMBMhNbKiSDS\nJCiIICIiIiIRc1nLurWGESOia+c0h4MTekAUP0FnImg5g0ijUxBBRERERCLmtJajxYa8PCgsjLyd\nOGOoUBBB/JS63bQJyImgmQgijU9BBBERERGJmMtaXBVgLSxbFnk78Q4H5dqdQfyUulxVEyvGxFCq\nIIJIo1MQQUREREQi5gkiGDp1giVLIm8nzhgqFEQQP6Vut5YziDRBCiKIiIiISMRcgKvccPnl8NVX\nsHdvZO1oOYMECpyJ0FrLGUSaBAURRERERCRiTu9MhDZt4Ne/hqVLI2tHyxkkULWZCNqdQaRJUBBB\nRERERCLi9j70uyoM8fEwenTkSxq0nEECBc5EiDcGp7U4FUgQaVSxjT0AEREREWmeXNYSA1RUQFwc\nDBoEBQWwcSPs3w8ffwyTJkF6eu1taTmDBAqciWCM8e3QkOTQd6EijUVBBBERERGJiMtaYozxBRFi\nY+H662HYMMjMhO+/h7Q0uPPO2tvScgYJVOpy0TYhoUqZL4jQSGMSkSiXMxhjUowxy4wxXxpjPjfG\nXGyMSTXG/MMYs80Ys9oYk1JfgxURERGRpsNpLbHGUF7uCSIAPPkkHDgAK1fCjBnw2mvhtaXlDBIo\ncCYCQGvlRRBpdNHOA3oSWGGtPQ/oC3wFTAXyrLXnAO8AD0TZh4iIiIg0QS6oMhMBwBiofO67/HL4\n6CMoKqq9LS1nkECBORFA2zyKNAURBxGMMcnApdbavwJYa53W2mJgJJDjrZYD/DrqUYqIiIhIkxO4\nnCHQaafBkCHw1lu1t6XlDBIo2EyE07TNo0iji2YmwplAkTHmr8aYj4wxzxpjWgMdrbX7Aay13wEd\n6mOgIiIiItK0BCZWDOaaa+D112tvS8sZJFDQmQgxMZQqiCDSqKJJrBgL/AL4rbV2szHmcTxLGQL/\n9g/5f4NZs2b5fh44cCADBw6MYjgiIiIicjJV5kSoKYgwYgTcdhscOQJJNWTD03IGCRRyJoKWM4g0\niLVr17J27dpa60UTRPgG2Gut3ez9/VU8QYT9xpiO1tr9xphOwPehGvAPIoiIiIhI81LbcgaAlBQY\nMMCTaPG660K3peUMEijYTITWWs4g0mACv9ifPXt20HoRL2fwLlnYa4w521s0GPgceAsY7y27CXgz\n0j5EREREpOnyT6wYHx+63jXX1L5Lg5YzSKCgMxG0O4NIo4tmJgLA74DFxpg4YCcwAYgBlhpjJgK7\ngRpiziIiIiLSXIUzEwFg5EiYMqXm3AlaziCBQu7OoM+JSKOKKohgrd0CXBjkVFY07YqIiIhI0xdO\nTgSADh2gSxfYuhV+/vPgdbScoXk54nSSFBvt95E1O+ZyBc2JUKqcCCKNKprdGURERETkFFa5O0N5\nec1BBIDMTNi4MfR5LWdoXi7/9FO2HD3aoH2Uut2aiSDSBCmIICIiIiIRCXc5A4QZRNDDYbNxxOnk\n+/LyBmvfWutZzhAwE6G1ciKINDoFEUREREQkIi4IazkD1B5E0HKG5qXcWg47nQ3WfoW1OIwhTls8\nijQ5CiKIiIiISEScdZiJ0LMnFBbCgQPBz2s5Q/NS7nY3aBAh2CwE0HIGkaZAQQQRERERiUhdljPE\nxMCFF8L77wc/r+UMzUu5tRQ3ZBAhSD4E8GzxWBrkc/JmUREnNENB5KRQEEFEREREIlKZWDGcIALU\nvKRByxmal4oGXs4QaiZC6xC7M/xm2za2HT/eYOMRkR8piCAiIiIiEXH5bfEYH197/ZqCCFrO0LyU\nu90UN+A3/6FmInRJSGBPWVmVsqLycooqKjSTReQkURBBRERERCJSl5wIABdfDJs2QbBnPS1naF4a\nOrFiqJkIPdu04fNjx6qUfVVaCqAglMhJoiCCiIiIiETEBXUKInToAGlpsG1b9XNaztC8VDR0YsUQ\nM7fv//YAACAASURBVBE6x8dT7nbzg9/2kl96gwj6/IicHAoiiIiIiEhEKhMrlpeHF0SA0EsatJyh\n+XBZiwsaNrFiiJkIxhh6tWnDF97AAfwYRNBMFpGTQ0EEEREREYmIf06Eegki6CGwWah8nxpjJgJA\nr4AlDV+VluJAyxlEThYFEUREREQkIs467s4AoYMIWs7QfFS+T42REwGgZ+vWVYIIX5aWcvb/Z+/N\nw+O863PvzzOrZkbSSJYl2Y7tJF7i2M4O2UggKQ0Q9paWrUBLOQfa054WWpYCbd+G99AWKKWsPaeU\nNzRtaMIWCvSELdA4C0kITpzEjmM73rUvo9lnnvX3/jEz0kiakUaaZ6QZ6/u5rlyxx5pnnpFmRs/v\n/t33/Q2H5fUjCCuEiAiCIAiCIAjCsrCXWKwIcPnl8PzzkErNvl3iDK2DWRSPGhpnqNGJkLVtRgyD\ni0IhcbIIwgohIoIgCIIgCIKwLJZarAiFUZBXXAG//OXs2yXO0DoYjkOP30/atrEbJPws5EQo70Q4\nms2yva2NsNcrIpQgrBAiIgiCIAiCIAjLYjmdCFA50iBxhtbBUIo2j4d2r5dUg9wICzkRNgYCmEox\nbhgczma5OBzGr2ny+hGEFcK32icgCIIgCIIgtCbWMuIMUBAR7rxz9m2lOINSCk3T3D1RwVUMxyHg\n8dDl8xG3LLqW8sOvkaxt0+WrvFTRNI29xV6E57JZdkciDOm6OFkEoU6+OjzM5wYGCHm9hKo4gUCc\nCIIgCIIgCMIysZdRrAgzToTyjWOPpuEpHlNobkyl8GvatIjQCBZyIgDsiUQ4lM1yOJtldzhMwOOR\nOIMg1MmT6TS3dHfzme3b+Yvzz6/6dSIiCIIgCIIgCMvCVgoNDa8XFti0msfmzeDzwalTs2+XSENr\nYDgOAU0j6vORsO2GPEZmgU4EmClXfE7iDILgGrrjsD0U4vpolJd2d1f9OhERBEEQBEEQhGVhKYXH\n0ZbkQgDQtMq9CDKhoTUwlJoVZ2gEizkR9obDPJPJcCyXY1dRRJA4gyDUh+44BGtQhEVEEARBEARB\nEJaFDWhq6SICLCAiyEKw6TEcB3/RidAwEaEGJ8IjiQT9fj8Rr1fiDILgArpSIiIIgiAIgiAIjcNW\nylURQeIMrYFZ5kRINNCJEFnAibAhEKDT5+PicBhA4gyC4AK64xCsodhWRARBEARBEARhWdhKgbO0\nUsUSL3gBHDwI+fzMbRJnaA0MpQg0uljRtheMM2iaxp5wmN2RCCAuFkFwA4kzCIIgCIIgCA1luZ0I\nAOEwXHwxPPnkzG2yEGwNSiMeo15vQ50IC8UZAG7p7uaGzk4AiTMIgguIiCAIgiAIgiA0lIITYXki\nAsyPNEicoTUwVmLE4yJOBIDbLryQ3+zrAyTOIAhuIJ0IgiAIgiAIQkOxAZbZiQDzRQSJM7QGZnHE\nY8OnMyxhbqi4WAShfqQTQRAEQRAEQWgotlJotkYgsLz7VxQRZCHY9JRGPEYbWaxYgxOhHIkzCEL9\nSJxBEARBEARBaChWnXGGHTsgnYahocLfJc7QGhhN6kSQ144g1IeICIIgCIIgCEJDsZUCe3nTGQA0\nreBGeOyxwt8lztAamErhL454bISI4CiF7ji0SZxBEFYUXama3nciIgiCIAiCIAjLot5iRZgdaZCF\nYGtQGvEY9flI2Lbrx885DiGPB62GbHYJiTMIQv2IE0EQBEEQBEFoKDagbPdEBIkztAbTIx6LTgTl\n8s9sqX0IIHEGQXADKVYUBEEQBEEQGoqlFFqdToRrroH9+8GyJM7QKpScCEGPB5+mkXPZPbLUPgQQ\nF4sguIE4EQRBEARBEISGYitVtxMhGoXzz4dnnpGFYKtgOg7+4m5lI3oRluNEkDiDINSPrpSICIIg\nCIIgCELjKIgIyy9WLFGKNEicoTUojXiEBokIy3QiyGtHEJaPoxS2UtMC4UKIiCAIgiAIgiAsCzec\nCDAjIkicoTUojXgEiHq9JJrBiSAuFkGoC734vq6l0FREBEEQBEEQBGFZWEqBrREI1HecWSKCLASb\nnqZ0IkicQRDqotY+BBARQRAEQRAEQVgmNuBY9TsR9uyB4WFwDIkztAJmmeW5WToRJM4gCPVRax8C\niIggCIIgCIIgLBNbKZQLIoLXC1deCfEJiTO0AqURjwBRn8/1OEPGtpfsRJA4gyDUhzgRBEEQBEEQ\nhIbjVrEiQFcXOIYsBFuB0ohHaGCcYalOBIkzCEJd6I5DsIY+BBARQRAEQRAEQVgmlktOBIBgEDRb\n4gytgLESIx5lOoMgrCjiRBAEQRAEQRAajq2UK50IQKGc0ZI4QytglhUrRn0+Erbt6vGzjkNEpjMI\nwoqSFxFBEARBEARBaDQ2uOpEwJKFYCtQPuKxaZwIHnGxCEI9rGixoqZpHk3TntA07XvFv3drmvZj\nTdOOaJr2I03TovU+hiAIgiAIgtB8uOlEKIgIshBsBYy5ToRm6ETQxMUiCPWw0p0I7wWeLfv7h4H7\nlFK7gJ8BH3HhMQRBEARBEIQmw3JZRFCmLARbgWbsRJA4gyDUx4p1Imiathl4FfCVsptfD9xR/PMd\nwK/V8xiCIAiCIAhCc2IrhWO6M50hEADHlIVgK1DeidBM0xnExSIIy2clixX/AfggUP6O7VdKjQIo\npUaAvjofQxAEQRAEQWhCbKWwTa1QilgnwSBgykKwFSgf8Rj1et2PMyxzOoOpFEpeP4KwLFakE0HT\ntFcDo0qpA8BC4Ql5JwuCIAiCIJyD2OBqnMExJM7QChiO03ROBI+m4aUgbAnCuc4DD8DYmLvHXEon\ngq+Ox7kBeJ2maa8CQkCHpmn/BoxomtavlBrVNG0DUPXp3XbbbdN/vvnmm7n55pvrOB1BEARBEARh\nJbGUwjFdFBEkztASmEpNdyJEvF50x8F0HPxLdA9UYzlOBJiJNNSzwBGEVuDTn4a3vx3e9Cb3jqk7\nDrFf/pLbvvGNRb922e8xpdRHgY8CaJp2E/B+pdQ7NE37FPBO4JPA7wDfrXaMchFBEARBEARBaC1s\nF0WEQABUTuIMrUD5iEdN06YnNKx3I9fC8pwIIBMahLWDrkMu5/IxHYcLrruO2377t6dv+9jHPlbx\na92RC2fzCeBlmqYdAX61+HdBEARBEAThHKPQieBOsWIwCLYui8BWoHzEI7gfaViuE0EmNAhrhYaI\nCEvoRHDF7aOU2gfsK/45BtzixnEFQRAEQRCE5qVUrOiaiGDIIrAVKHciQEFESNi2a8dfthNBJjQI\na4RGORFq7URohBNBEARBEARBWANYSmEb7sUZ7LwsAlsBU6lZ/QfRJnEiSJxBWCvoOuTzLh9zBUc8\nCoIgCIIgCGsUG1x1Ish0htagfMQjNCDOsEwngsQZhLVCPt8gJ8JKxhkEQRAEQRCEtYftohMhGAQr\nr6FkEdj0lI94hGKcwSURQSlF1rYJ1TGdQRDOdVa7E0GcCMCwrvPh48dX+zQEQRAEQRBaClspLKMQ\nRaiXgoggi8BmRymFUTbiEdyNM5hK4dG0ZY2LlDiDsFaQToQm4GguxyfPnuVgOr3apyIIgiAIgtAy\nuN6JINMZmh5bKbyAp0Fxhswy+xBA4gzC2kE6EZqAZPFD73ODg6t8JoIgCIIgCK1DwYngXpzBzMsi\nsNmZO94RIOr1uhZnWG4fAkicQVg7NMyJICJC7SRtm1u6u/nW+DjjhrHapyMIgiAIgtAS2OBqJ4KZ\nk0VgszN3vCO460RY7mQGaP04g+k4/P6RI6t9GkIL0JBiRelEWBpJy2JHKMQb1q/ny8PDq306giAI\ngiAILYGbToRAAMxcay8C1wKVnAhuFitmHYfIMp0IrR5nOJTJ8E/DwzjyHhAWwHHANKUTYdVJ2jad\nXi/v27yZLw0OYrTwh48gCIIgCMJKYSmFpbs4nSHX2ovAtYA5p1QR3C1WzNr2mo0z7C/2s+XlPSAs\nQMk4L50Iq0zSsuj0+bi0vZ094TDfGBtb7VMSBEEQBEFoekrTGdwSEYxsay8C1wJzxzuCy3EGx1mz\ncYb9qRRQEFIEoRq6Xvi/dCKsMiUnAsBv9ffzw1hslc9IEARBEASh+XG7WNGQOEPTYyhVsRMh4dLC\ntx4nQqvHGUoiQq6Fn4PQeBomIkgnwtIoOREALolEOJTNrvIZCYIgCIIgND82YOXd60Qwsq29CFwL\nmI7T2DhDPU6EFo4zmI7DwUyGDYEAWXkPCAtQijGsZieCz92Hbk3KnQh7wmGOZLOFGbg1fhMFQRAE\nQRDWIpZSGLpGIFD/sUpxBtWii8C1QqVixU6vl6Rl4SiFp87r57qdCC36+nk2m2VLMEjQ4yEncQZh\nAXS9ILo2ohOhTZwItVPuRGj3+ejz+znptrQjCIIgCIJwjmG7XKxoZAuLQBESmpdKIx59Hg8Rr5e0\nC4vfujsRWnQX/4lUihd0dBDyeCTOICyIrkNXl3QirDrlTgSAvRJpEARBEARBWBRbKUzdnWJFjwd8\nHg1P8bhCc1LJiQDuRRrW6nSG/UURIez1SpxBWJCGiQjSibA0yp0IUBQRMplVPCNBEARBEITmx1IK\n06VOBChYdANa6y4E1wKVRjyCexMa6nEitHKcYX86PeNEkDiDsAD5PESjBRHBzZe7OBGWSNK26ShT\nPPeEwyIiCIIgCIIgLIBSCgdcizNAIdLga+GF4Fqg0ohHgKjXS2K1nQgtGmewHIen02mubG+XOIOw\nKLoOkUjBvWWaLh53CcWKIiIAKcuaH2cQEUEQBEEQBKEqDqABHo/GMjeO5xEMgo/WXAiuFSqNeITm\ncCK0apzhcDbL5mCQTp9P4gzCouh64bMyFHK3XFGcCEvAVoqc4xApExF2h8MczeUkjycIgiAIglCF\n0iQrt1wIUIgz+CXO0NRMOxFuvx2mpqZv7/L5Vt2J0Kpxhv2pFFd1dABInEFYFF2HtraCiOBWL4JS\nCkM6EWonZVl0eL1oZYpqu89HfyDACZnQIAiCIAiCUBFLKXy4KyIEg+BTrbkQXCtMdyJ85jPwyCPT\nt7tWrLgGpzM8kU7zgvZ2AIkzCItSciK0tbknIphFUbjWEa1rXkRI2vasUsUSe6UXQRAEQRAEoSoF\nJ4I7kxlKBIPglThDUzM94jGbhePHp293Lc6wBqczlCYzABJnEBYln5+JM7glIiylDwFERChMZqjw\nQbVHxjwKgiAIgiBUxVYKT0OcCK25EFwrTI94zGbh+eenb+/y+Ui4YMNfa9MZbKV4Kp2WOINQM43o\nRFhKHwKIiFDdiSDlioIgCIIgCFWxAQ8agYB7xwwEwCtxhqZmlhOhTERwK86QaeHpDA/G45xe4qru\nuWyWjcEg0eJ6ROIMwmKUiwiuORGW0IcAIiJUdSLsDYd5VkQEQRAEQRCEipzI5ej3Bl13IniUxBma\nmelOhEbGGVp0OsMXBwf5weTkku6zP5Wa7kMAiTMIi1MqVnSzE0GcCEukmhNhdyQiExoEQRAEQVhT\nnMrluG7//pq+dl88zgv9Ufc7ESTO0NQYShFQCpSCU6egaL13bTqD47TsdIa4ZTG1xO9B+WQGkDiD\nsDgNcSJIJ8LSqOZEiHi9bAgEOC4TGgRBEARBWCMczmY5XGMn1L5Egqs8Xa6PePQ4EmdoZgzHIWDb\n0N4Ovb0wMAC4OJ1huU6E97wHfzK5qi6WxDJEhCfS6elSRSiICOJEaA4cpZpS0CkvVpROhFWimhMB\nYI9MaBAEQRAEYQ1xMp8nadvkF7lwtpXioUSCS3HfieBxJM7QzBhKEbAsCIdh+/bpXgQ3nQiR5TgR\nfvAD/LHYqrpYlupEsJXiQDrNVXPiDNKJ0Bz8tyNH+OjJk6t9GvOQToQmoJoTAaRcURAEQRCEtcXJ\n4rbWuGku+HXPpNP0+/1E7QZ0ItjNG2dQSjGaHl3t01hVTMfBb5oFEWHHjulehFXvREgkCBjGqrpY\nErbN1CLvnXKOZrP0+f10l72JJM7QHPw4FuNfRkYYN4zVPpV5lEQE6URYRRZyIuyNRHhWxjwKgiAI\ngrBGOFUUEcYWWQjtSyS4qasL08R1EUFr4jjD9458j9fd/brVPo1VxVCKQElEKHMiRL3eukUEWymM\nJe6IAmBZkErhz+cxVnEXf6lOhP2p1KwoA0icoRlIWxa/d/Qo7964kUwT/ixKxYpuOhHy0omwNMSJ\nIAiCIDQ7tlJ8d2JitU9DWAOczOXo8vkW3X3bF483REQIBECzGxdn+LVnnuFEHVfddx28i0Q+4eIZ\ntR6G4xAwTVIqgnnBjmkRoc3rRYNFozALkSu6ELQlLGYASCYB8Ov6qglQuuOQd5yliQhz+hBA4gyN\nxHQc/uz4cW544gnefOgQH3j+eT43MMA94+M8nkwyous4SvGXp05xYzTKb/b2km5CV0h5nEE6EVaJ\nhZwIu8NhjuZyWPJGFgRBEFaRAV3nd597brVPQ1gDnMrnuaajY0EngqMUD8TjvCQaxTAKIkIsF+PR\ngUfrfvxgELQGxhmezWYZ0PVl3TdtpPneke+RNde2S9VUCr9h8OzJML+Y3DFrzGO95YrLnswQjwMQ\nyOdXTUQo9UEs1YlQ3ocAEmdoFGfzeW46cIBDmQwfv/BCXrd+Pev9fo5ls9wxMsLvHT3Kpb/8JaEH\nHuDrY2P8w/btRLzephQRyosVVyvOUHn1vIZIWhYdVT6swl4vGwMBjufz7AqHV/jMBEEQBKFAxrZJ\n2TZKqaXv0AlCjaQsi5zjsDcSYWwBJ8LhbJaoz8fmtjYOmAX3wH0n7uNfDvwL977t3rrOIRgErMbF\nGUrvpeXw/SPf55K+SzgxdcLls2otDKUI6DpJO8xTY9u54fjxwrhHTZvuRdgQDC7r2MvuQyiKCKsZ\nZ0hYFuv9/po7EZxSqWIFJ4LEGdzldD7Ptfv3877Nm/nQ1q14Fvg9mrNtHAqT+gYNg0yDRYQvfrHw\nGfqe99R+n/JOhKkpd85DihWXyEJOBJBIgyCsFneNjvLjWGy1T0MQmoKMbWMphS4XlkIDOZnPc0Fb\nG/2BwIJOhFKUAZiOM6SNNBmz/uulaRGhQa/1jG2TXOZO+d2H7uZdV77LlefZyhiOg183SJhhHn22\ns9CNMFoom+zy+UjUseiq14ngz+VWzYkQtyy2BoOkbRu7hnM4lsvR4/fTMycPFPJ4JM7gMo8lk9wQ\njfLh889fUEAACHm909NB2lfAiXDkyHQiqGYaMp1BOhGWRsq2q3YiAOwNh3lWRARBWHF+Fo/zWDHj\nKAhrndJFzHJ3UIXWxrBXph38VD7PhW1t9Pr9CzoRKokIGSNDxqj/eikQAKzGxRmyjrOs99FUbor7\nT93PWy95K7ql46i1u8gzlEJL50k7YZ58ktnlivXGGeqYzAAQWEURIWFZdPt8dNQ46nJ/KsUL5kQZ\noPXiDPfFYqRcmMrRSM7k85zf1rbk+0U8noaLCPE4pFJLu095saJ0IqwSScta3IkgExoEYcWJmaYs\nmAShSEZEhDXNtV+5liMTRxr+OCUnQp/fX3XEo1KKfcU+BJjtREgb6brPoZFxBtNxMJVa1vvoO899\nh1u23UK0LUrIH2poL0LSsjiw1FXFCmI6Dk5Sh3CYsTEwts6UK3bVuICuRt1OhGx21eIMccuiy+ej\n2+erqReh0mQGmJnOoJp0QslcPnLyJI82+abPGV1n6zIiNu1eb8PjDIkEpJf40dkwJ4KICLWTXMyJ\nIHEGQVgVYpbVlGU2grAalEZMiYiw9rAci0NjhxjPjjf8sU7mclwYCtG3QJzhWC5HwOPhguKu3mJx\nhu8+913i+XjN5xAMgjIbE2coLQaWE2e46+BdvGXvWwCI+CMNFRHunZzkz040b++CoRQqkUcLh7ns\nMhgKbZ8uV+yqwYnwju+8A9Ou/PqqqxNB01Y9zhAtiQg19CJUExF8Hg8+TWuYG8dtpkyz4QvtejmT\nz7N1GU6E0qSMWuIpy2U5ToRSsWJbm4signQi1I5SitQCxYoAF4fDHJMJDYKw4kyJE0EQppmOMzS5\nZVRwnzOJM5iO6UpUYDFOlTkRqsUZSlGGUsHndJzBrBxn+Ni+j3Hn03fWfA6NjDNklynGjaZHeXzw\ncV590asBCPvDDf15jJnmkhr+VxrDcdASObRImCuvhMPmjprjDIZtcOfTdzKZm6z473U5Efr7CWQy\nqxdnsO2qToTROe8nRymeTKfnTWYo0UqRhqkW2PRZrhPBo2kFZ0gDn18isbw4w4p0IizgMFnTIkK2\naNvwLaC6hL1eNgUCPO/WT0gQhJqIWZYsmAShiMQZ1i5HJ48CuBIVWIyTpU6EohOhkp26PMoAi8cZ\nUkaKbz77zZrPIRgEx2hMnGG576NvPfstXnPRawj7C5O6woHOeU6EH05OMrLM0ZFzGTOMunoFGo2h\nFCRzeDrCXHUVPFY25nGxOEMiX+guiOUqFyfX5UTYtAl/JrOqcYaoz0e33z9LRBjUdXY+9tis8zqe\ny9Hl87E+EKh4rFaZ0OAoxZRlTbvlmpXlOhGg8ZGGekWEhnUi3HMPXHxx1a9f0yLCYn0IJaQXQRBW\nHulEEIQZRERYuxybPAbQ8IkASqnpYsWI14sH5u0uKqXYl0hMlyoCGMaME8F0zHklkGkjzaMDjzKc\nGq7pPIJBcMriDOOGwV+4ZO1fbpzhroN38ZZLClGG709McHznbUzqM4LJlGny5mef5Z6JCVfOc7TJ\nnQimUmipHIO9P8Vz/iP89NT2WZ0ICwkgCb0gIkxmG+BEKIoIq1msWMmJcDafJ2Xb7C9bKVaLMpRo\nlQkNSctCMf+zopnI2jYZx6F3zhSMWmn0hIZ6ixVd70SYmIA3vxk+8hH4xjeqfn1LiQg/nZrig0Wl\n0w0W60MosTcSkQkNgrCCGI5DxnGa+peSIKwkMp1h7XJ08igaWsOdCKVFT1dxc6VSL8KpfB5LKXaG\nQtO3lTsRgHk2/5Se4lU7X8W3D3+7pvMIBkEZM3GGpzMZvjY2trwnNYflxBnOJM5weOIwL9/+cgD+\n7uxZNM3L12IzV+6fHRhAAc+5tOE0ZhhMVXGCNAOG4+BJZhmIPMmHnng9j8eTKNuGWIyo17ugiFDq\nx2iUEyGQSjVdJ8JQMcrwQHGCBMD+dHpREaGRFnq3KH1uNPP12lldZ3MwOB3BWiqNFBEcp5AYaKpO\nhE99qnDDgQNw441Vv76lRITnsllXF/M1OxHCYSlXbDCPnH2Ezz/2+dU+DaFJKP1SkgWTIBTI2DYa\n0omwFjkWO8au9bsa3olQijKULrT7/H7G5+S498Xj3BSNzroYN81Cj8G0iFDmmHCUQ87K8c7L31lz\npCEQmB1nGND1utr+y8nYNgFNW9Lvlq8f/DpvuPgNBLwBHk8mOZ3Pc/Xkt7g7oYiZJlOmyZcGB/nr\nCy/kiEsiwqhhYNO8CzNDKXypLIlAmvdf/354+2tI9V8Ax48vGmdYTETILNeJkEisepyhmhNhSNfZ\nGAiwLz5TMFptvGOJUqFfsxMrPs9mLlY8k88vqw+hRMTrbVhcoyQeNFUnwtgY3Hpr4eAL0FIiwqTL\n9ualOBEkztBYnhp9ivtP3b/apyE0CTHTJOzxiIggCEUyjsN6v1/eE2uQo5NHuXLDlQ13IpRKFUtU\nciLsSyR4SVmUAcqKFYsiR/l5ZowMIV+IV+x4BU+PPl1TpCEYBNuYiTMczyRJWO7symdsmw2BwJLi\nDHcfupu3XvpWAD4zMMB7N2+mX8txTSDP35w+zWcHBnjd+vW8qqfHNRFhzDTRoKZehJO5HH99+rQr\nj1srhuPgyyTJ+G0+dMOH2KFu5eHgMNbR5xYtVmx0J8KqOxG83nmdCEOGwRt7e3k4kcAqjm584hyJ\nM5QcF80qeEGxVHGZfQjQWCdCIgH9/YURj0t52Ta0E2FqCuZ8zldi2SKCpmmbNU37maZphzRNe0bT\ntD8u3t6tadqPNU07omnajzRNiy52rFpxXUSo0YmwKxzm+VyuIeOGhAJJPUnKaN6ZyMLKErMstra1\nNfUvJUFYSdK2zcZAQESENYZhGwylhrik75KGdyKUxjuWqDSh4YHiZIZyyuMMAW9glmMibaTpCHbQ\n5mvjNRe9pqZIQzAIjj4TZziYGMFBc2WnM+s4bFjC++jo5FGGUkPcdP5NnMnn+XEsxn/buJFIIMJr\nApN8dWSELw4O8ufnn88FbW2MmqYrFvQxw2BrMFhTL8J/Tk7y7fHGj/8sx1QKbzaBFipM6fi9Cz/N\nyfYo37v3H2qOMzRkOsOmTfiLIsJqREEWciJc3t7O5mCQA+k0J/J5On0+equUKkLrxRnOZSdCo0WE\n9esLDqylOAoa5kQoiQjd3Yt+fT1OBAv4U6XUXuB64A81TbsY+DBwn1JqF/Az4CN1PMYsJkzTVStn\nrU6EsNfLeTKhoaEk9SQpXUQEoUDMNNkaDJKyrKbNhAqrh1KKXY89hr6GhN3SDqqICGuLE1Mn2BLd\nQldb14o4ES5cwIkwkM+TtG32hMOz7lc+4nFD+4ZZ55k20rQHCpbtN+15U02RhkAAbH12nAFq25Vf\njKW+j+4+eDdv3PNGvB4vnx8Y4J0bNhD1+Qj7wvjtJB/YsoW39vWxPRTCq2lsb2vjWJ3Xihnbxga2\ntLXVJCI8nEgsuSiyXgzHoS0XxxcpLDRecJWX8dH34T95mq89+WUSC3x/4/k4bb62hjkRtGwWL2Ct\nwrVD3LLI6zFCWPM6ETYFAtzU1cUDiQT7U6mqox1LtEqcYcqy6Pb5mnrTp14nQqSB0xnicYhGob29\n9kiDZYGmgc/XoE6ERosISqkRpdSB4p/TwGFgM/B64I7il90B/NpyH2Muk6bp6ou0VicCFMsVJdLQ\nMFJ6akXGVwmtwZRl0R8I4NM08i3wS1RYWaYsi6O5nGs56VZgevGzhp6zUNgJv6jnItoD7Y13IsyJ\nM/TOcSLsSyR4yZw+BJjtROiP9M86z5SRoiNQsGy/fPvLeWL4iemd6GrMjTOMmYX/uyUi9NcYt3MH\nOwAAIABJREFUZ1BKcdfBu3jrJW8laVl8dWSEP968GYBIIELWzPKR88/nCzt3Tt9nVzhcd6RhzDDo\n9/vpXiQWUDrHhxIJkjVeG48ZBu84fLjuzgBDKUL5JG2dPQBcdhn8fOgSXuZs52tP/hMTRvVVTTwf\n58KuC6uLCMtxIjhOwQ++YQNkswQ8nlWJNCRsm08/8Fc8euq+eU6ETcEgN3V1sS8eX3QyA7ROnCFm\nmmwOBsWJsEwSiYKI0NFRu4hQKlWEBnUixOMNdyJMo2naBcAVwKNAv1JqFApCA9DnxmMATFrWqnQi\nQLEXQcoVG0bSkDiDMEPMNFnn8zV8rI7QmowUFzZraVde4gxrk2OTx9i5bicRf2TFihVL9Pn9s5wI\n++LxeX0IMFtE6Iv0zYszlJwIQV+QqzddzSNnH6l8AoYBf/iHdAwdwc7PxBkmHQ/kRxjN17/RkHUc\nevx+HFh0If3M2DPkzBzXbb6O/294mJd1d3N+8fsT9oenn2e5qLIrHK57QsOoYdAXCMxr+K/EGV0n\n5zg1OxGO5XLcOTrKR+ocmWk4Du16ko7uXqCwi6pv3o73+Fm+/6ZvkHcUD1X5OSf0BNvXbV/QiRBZ\nqoiQTEIkUjiRbBa/pq24iOAoRdKyiKUHyGZHZ4kIwyUnQjTKg4kEj9coIrRKnGFrMNjU12rN3IkQ\njxfqB5YiIpSiDFD47HWcgjuhXlYyzgCApmntwLeA9xYdCXPftVXfxbfddtv0f/fff/+ijzVpmmQd\nB9ulD4alOhFERGgcEmdYmP979P9yx4E7Fv/Cc4SYZdHt99Ph88miSZhHSURYaQvvapI0be75SqCp\nL9QE9yl3IjTarTdsGGwq263rCwQYL1vEPlCczDAX0wSPz6Q7ZfGik9as80zpKTqCM4ulG7feyENn\nHpr/4LoOv/Eb8H/+D+0nn8bKFxaBuuOQVV7InmU4X/81Qsa2iXg8dHi9i/5uueuZu3jLJW/BVorP\nDQzwp1u2TP9bxF9wIszlYjecCKZJX9GJsFic4aFEgpu7unCgpnhXzDS5vrOTb46P84PJyp0E5VhV\njmkqRbueoat3Zp/wvKs3oSUTXNmxg3aPh9/89m9zcurkvPvG83G2dW1buBOhWpwhXsXFUlqJhULT\nIsJKT2hIF8WP8cwoqezQ9M8ub9ukbZsev58NwSC9fj/74vFFRYRWijMcfqCN8XRz/m5ylOJsPs+W\nZToR/uu/4NgznoY5LZbjRCgXETTNvXJF3XEIOg7353Lc9ulPT6/Rq1GXiKBpmo+CgPBvSqnvFm8e\n1TStv/jvG4Cqw33LRYSbb7550cebNE08uNcAmrRtOmpUO/fImMeGktJTpIyU5N8r4CiHD/7kg/zw\n+A9X+1RWjJIToZYLPWHtMbwCTgRHOXz94NcbdvylkjIdTh8QJ8Ja41is6EQIRBoaZ1BKkSo2y5+K\nn+INX3/DrGLFEV1n1DS5tEKO2zDA8WV423MBfu2eZ2edZ9pI81v3noWThcXkDVtu4KGzc0SEfB5+\n/dcLV8VvexuBbAJLL8QZhnWdkMqClXbFiZApLvQ6vN4Fo0FKKe4+dDdvueQt3DMxwZa2Nq7p7Jz+\n97A/XFFEcC3OEAjQVUOc4eFEghujUTorPJ/fPnx41khBKAj0O0Ih7ty9m3cdOcJwsW+iEs9lMmx/\n7LGKQoKhFFEzw7r1G6Zvu+IqD+PtF8KJE6wPhvj96z7Aq/79VfPiK/F8nAu7F4gz2HblOMNzz8EV\nV1Q+2UQCurpQXh/4/QRWwYkQtyyiPh/jmXHimUFSloWjFMOGwcZAYNqx8pKuLjYGAvQvUKoIrRVn\nSJ8MkjKb81zHTZN2r3fWa0q3dHSr+mu/nH374OzRxsYZ6nEigHu9CLpStGUy3LxuHbd97GONFRGA\n24FnlVKfK7vte8A7i3/+HeC7c++0HAzHIes49LmYCU1aVs1xhovDYY7n8zKhoUEk9SSWY6Hbtb2p\n1xLfP/J9TsVPMZoeXe1TWTGmLIt1fr/EGYSKrEScYSA5wFu//daKC4XVIGPbGMNBUpa8HyqRsCw+\nfurUap+G6xydPMrOnp0NdyKkbZs2jwefx8P3j3yfh848NKtY8YHiYtU7pw8BCk4Ex5vhhSMeIjl7\nthPBSHHTgwPwqU8BcP2W69k/tB/DLnYt5HLwutdBZyfcdRf09BDIJ7FyhTjDgK4TtJJgZRjN1y+i\nlPL2nT7fgj0Cjw0+RtAb5LK+y/j7s2f502IXQomwP1xR1NkVCnEkl6trQ2TUNAtxhjljAivxUCLB\nDdFoxedzPJfj5JyVRUmgf0lXF7+3cSPvOHwYp8q5fmt8nDO6zqPJ5KzblVJYStFp5Olat2n69quu\nguPsgOefp8vn4/V7f4trzruGzz/2+Vn3T+gJtnVvW7gToZIT4Ze/hNOnCyuouRSdCNdeC3ZbGD+s\nuIhQmMzgZSI7wVh6hHavl4RlFUoVy1Z8t65bxw0VHD1zCbdQnEEfCJKlOc/1bD4/L8rw94/8PX/x\ns7+o6f7Dw2ClGhtnKDkR0jV+xOt6QTgo4VYvgu44BFOpmqIMUN+IxxuAtwEv1TTtSU3TntA07Vbg\nk8DLNE07Avwq8InlPkY5MdOk2+ej08VFRdK2a44zhLxeNgeDMqGhQST1wi8piTTMRinF3z70t3zw\nRR9kNLN2RISYZc04EdaQZV2ojZWIM4ykR1AoDo8fbthjLIWcsiEWWFNlkkvh2UyGLw4OrvZpuErG\nyDCZm2RL55aGdyIkiruoAD88/kOm8lP0+HxMmCaOUuyrEmWAgohgedNcPmgTzprzOhEiORP+9V9h\nbIzOYCc7e3byxPATkM3Ca14DfX1w552FcG80ij+bwMwVdpIHdB2PEcPr5BYs66uVWuMMdx+8m7de\n8lYeSaWYNE1et379rH8vFSvOpcvvJ+zxMDRnNOZSKC9WXEhEiJsmJ/N5rmxvp9Prnfd5GLcsJuZ0\nKsSKAj3AX5x/PoZSfPLMmYrH/87EBDd0dnJvbPZi31QKHxpBx2Zd94yIcOWVcCC9Hef549MuiuvO\nu47B5Oz3ZTwf55c/3Ureys+ISWVUdSI89VTh/5XOtyginDwJVqAgIqx0nCFuWUQ0sJXNaGZ0WgQa\n0nU2lrkO3rB+PXfv2bPo8UItFGfIngySb1IR4YyuzytVHEgO8POBn9d0/6EhMBKNm85Qb7EiuBxn\nSCbJdbRVjCLNpZ7pDA8rpbxKqSuUUlcqpa5SSv1QKRVTSt2ilNqllHq5UmrhGt4ambQsevx+V+3N\nqSU4EQD2SqShYST1JH6PX8oV57Dv9D6m8lP8/gt/f005EUqiocQZhEoM6zptHk9DXxsj6RGgUK62\n2jhKYeDAlJ+0OBEqMmIY0wvec4XnY8+zrXsbXo93USfCPePj/OfExLIfq7Spols6D55+EA0N087R\n7vUyZVk8kEhwU4VSRSiICDgxdo4YhDL6vBGPoYxREAv+8R+BQqThsed+Cq9+NWzeDHfcUZhVBtDZ\niTeTLIgIjsOgYeDkR1kXCBIzl78wL1FLnMF2bL5x6Bu85ZK38Pdnz/K+zZvnOTCqORGg/l6EsZIT\nYZFixUeTSV7Y0YHf46HT55s3VjFuWUzOeY4lJwKAz+Pha7t389mBAR5JJGZ93alcjjO6zl9v28YP\n5ogIhuPgUxo5n4fe9plOhHXrYKR9B6knnifq9RK3LPoifYxlZ6eap3Jx/tefdxENdDOVm5r3vKo6\nEQ4cKMz/rOQ4isdxol3EYmAFIgSUWhUnQptm0xPqYTQ9Oi0CzXUiaJo2b8JJJVolzjBpmJhDQQyP\n3ZSR5DMVnAijmVGeHH4Sy1lclB8ehny8eYsVwWUnQjLJSTXFnU/fuejXuzKdYSWYNE3WF+3Nbl04\nLsWJAMVyRRnz2BBSRoqNHRvFiTCHTzz0CT70og/RF+kjoScw7YWbms8VYhJnEBZgxDDYEQo13IkA\ncHDsYMMeo1aytk1AeSDrJaOa80JttRkxDGxY1P7dShyLHeOinosAFu1E2BeP87NqpXM1kCj2ITx0\n5iH29u2lv72fWC5Gn9/P4UyGM8Ud70qYJnQPHWKyK0Awo8/uRMgmCORNuO02+N//G7JZbu55Abf8\n0T/Atm1w++1QvpnT2Yk3k8AsizMYuSH6g+3ErfpFhFriDA+cfoAN7RvwRbbyYCLB727cOO9rqhUr\nQv0TGkYNgz6/f9FOhIeKEROgqhNhcgEnAsCWtja+vGsXv3X4MPGyr/3OxASv7+nhhs5OTufzDJVF\nCAyl8DmQ80NvuHfW8X0X7yB/qBBnSJREhMxsESGeS0C+iw7fuorlihWdCEoVRISXvrSqiKC3RXEc\nMPxh/I7jqohw+/Awzy6yiRi3LPyOwa71u8iaWaJeD1OmWRjvuEj/QSVaKc5A3I/HaU7Ro5ITYSwz\nRs7KcWjs0KL3HxqC3GRjOxE2Zp5ni3WyKToRgvE4k20OCT2x6Ne3lIjQ4/O52ta+lE4EgD0yoaEh\nOMohbaTZ2L6x4e3TrcTh8cM8M/YMb7/s7Xg9XnpCPYxnx1f7tFaE6WJFmc7QkvwoFnNtik4lRgyD\ni0Khhr42hlPDXLnhyiU7EUYNgy8PDbl6Lmnbxm97wfHgx0O2CS/UVptSxGW8Dht5s3F08ig71+0E\nmI4zVBOQ4pY1/T1YDqU4ww+f/yGv2P4KutsKu8R9gQDfnpjg+s5OfFUa800Tek8/w7O71uHVDbK5\nmQy9lZjCDAVh9264/nr4whd47Xv/kf2dadSXvzxbQACIRvGkkngcDcNRDOTzZNOn2RSKknDBhVNL\nnOHug4VCxc8ODPDujRsrjhssH/E4l3rLFUvFiovFGR5OJrmhWPY4VxQp9YjNizOUORFKvH79el69\nbh3vOXp0+vV1z8QEb+jtxefx8PLubn5Y5kYwHAevDZmAojcyW0TouXo7gTMzcYa5IoKjHDJmGvRO\nwvRU7EWo6EQYGirU0F9/fVURIeMrOGV0bxi/Uq7GGf5tdJQPLzIWM2HbeJ0cfZE++iJ9hDS7ohOh\nJg4ebIk4g60UWceGrA+/2TjLfz1UdCKkR7l609U8PvT4gve1bRgdhWzMS6ZBP4t4HHb+5Etc/+xX\nmsOJEI8zFjBJ5M8hEWHCNKfjDA3tRDDNqsESiTM0hoyRIewPE22LNmWc4acnfsrx2PEVf9x7j93L\n6y56HUFf4ZOiv71/TUQaHKWKBUUSZ2hFLMfh1w8e5GgDXVvDhsFF4XDD4wwv2/ayJTsRHksm+YLL\n2fyM4+AzCwuZkJKekEqUFtBjC9i/W41yJ4LX4yXoC5KzKl8p1i0iFK+HfnT8R9y641a6Q91M5afo\n8/v51vh41SgDFC6b+k8/x+mdfdiRECo5c/HpxGOYHeHCXz7wAfjwhwledTV/9eZ+jk49P/9gnZ2Q\nTBLwaBi2w+l8ljY7xfpgiLRTvzC5WJzBsA2+ffjb3LrrN/na6Cj/87zzKh6nWicC1B9nqKVY0XQc\nHk8mub6KE6HUnbKYE6HEp7dv50g2y1eGhxnRdQ5mMvxqsVztlT09syINplJoliLrV0SDs3sytv3K\n+URSw0Q1jYRt0xfpYzwzs/mR1JMEtXZQHvz2unkiglKKrG0TmisiPPVUYTLDhRdWFhESCZKewms0\n7wkTsG1XnQiTpsmPYjGeXGCVF7cssNL0hnvpi/QRcHSmLIvhpToRzpyBK64gBE3vRIhbFmF8oDQ8\nhqcpnaPVnAiv3vlqHh9cWEQYGyv0FWQmGutEiCSG6LATSxIRGlasGIsx7MsT1xd3trWMiDBZJiK4\ncQFVWqjMcyJ88Yvw7ndXvM/F4TAnZEKD66SMFB2BDjoCHU0ZZ/jS41/iR8d/tOKP+5+nH2Wk73XT\nf++P9K+JcsWkZRHxevF5PBJnaEEOZbPkHGfR0WTLRXccUrbNBW1tjY0zZEa45rxrSBvpqi3ilRjU\nddd3wzO2jcco/K4K2iKsVWLEMPBrGuPnkIhQ7kQAFuxFcMOJ4HN0BlODXL3p6llOhAFdX1RE2HDq\nOMM7N2B1tKMlytr8EwnsjmIM4oYb4P774Utf4kUX3MjDZx+ef7BoFBIJ/Jqn4ETQddZ5HHoDbWRc\nuPRaLM5w34n72LV+F/dmvLy2p6fqDnK1EY8wM6FhOVjFz871i8QZnkyn2R4KTZdhzn0+8WoigmkS\ncOZPN2jzerl7zx4+evIkf3vmDK9ct45gcSF/67p13Dc1NX3tayiFZtnofv+8bP8VL/QxqG0hmkgQ\ntyy62rrImtnpcXrxfJyAKggPHn2+iGAohU/T5rteDhwoiAgXXFDViRCn8BrN4X6cYdI0+ePNm/l/\nT5+u+jUJy8Ixk/RF+uhv78drZ5fnRHjwQbBtwsXfpc1MzDSJ2D4iEdDyq+tE+OHkJI8m5u+en8nn\n2VK24tYtnayZ5WXbX7aoE2F4GLZuBb/tJWU2TkRoiw3Rbk41RbFiIBbjrDdzbjkRJosfqm51IpzM\n59kQCNA2V0Q4ehS+/e2K7RZtXi9bgkGOyYQGV0nqSTqDnXQEO5rSiTCaGV3SIsINdEvn0YzJw0bH\n9G1rxYlQvlMi0xlaj18Ux4E1KpteygtHG+xSGUmPsLFjI5f0XbIkN8JQAwr+0raNpnsJhyFgScSn\nEiOGwe5wmLFzKM5wbHLGiQAsOKGhXhEhaVnEUme5ZdsteD3eWU6EkMfDCzs6qt7XNmw2nDlLbNdW\nnM6OWSKClkjiRIv31TS46SbQNG7cciMPnXlo/sFKTgSvRs5xGDdt+v0+egNhcqr2+Gk1Fosz3H3w\nbn5zz1v5wuAgf7plS9XjRPzVOyouaGtjWNeXtYs8aVl0+3x4NY2wx4OlFHqFheTDxdGOJaI+3yxR\nNW5ZbAwE5sUZxow8L/ryJdx77N55x9wdifCJbdv4/OAgv142jaI/EGB7WxuPFD/bDcfBY1oYFXbX\nN22Ck94deE9NELcsNE2jN9I7HcVM5BN4zS527ACVXcdkdnYnQtXJDAcOwOWXF0SEkxVa4+NxYk5B\nRMgQxm/brsUZlFJMmiYf3rqVx5JJnqoyhy9uWZhGnN5wL/2RfrDSy+tEePBBAEKpVNOLCFOWRZvp\n58ILgdzqbvp8ZmCAb4zPjvzm7EKkZEPZ938sM0ZvpJcrN1zJcxPPkbeqr76Hhgqv6c6Au8/NUYof\nTE7y3YkJ4nHwjw8RMuJLGvHodieCrRQOYI0PMRk8FzsRXJzOcCiTYW8kMv8fTp0q/GTuuafi/fZK\nL4LrTIsITepEGE2PVmwQbiQ/P/tzOnuvZdyypi9E1ooToTyzuZbjDO89dqwlBZTHiwJso5wII4bB\nxmCw4X0ZI+kRNrRv4JLeS3hmtPZehCFdd73gL2PbaDkvW7aAz1y774mFGDEMLo1EzhknQjwfJ2fl\n2NC+Yfq2xZwIU5ZVccFZCwnbZmjqKK/Y/gqAWU6E6zs7CVTpQwDYmDxCoqsDX9c6iHbiS81cI3mS\nKeicPxryxq1VRISiEyHo1RizDNo9it5wF31tEXRqL8KuRtZxqsYZcmaO7x/9Pr6NL2N3OMzlVYok\nYWEngs/jYXckwtO1rgjKKImkUGjxrzahobxU0XEgaHlnORESlsX2UIiYZU33HNhKkbEdXnnBS3jX\nd9/Fvz71r/OO+64NG/jqrl28pqdn1u2v7Onh3snCgt9QCs00sSrsrmsaZDZsRx0ano5UlPcixPNx\nyHVx9dVgJed3Iiw4meGKKworusnJ+duu8TjjZhcbN0LGCROwLNecCDnHQdM0evx+PrBlC/+rkhOC\nwvdcz08WnAiRfmwjzqBhoCtF1xJK3HnwQejsJJRINH2cYcqy8Os+tm0DJ7t6IoLhODycSMyLER3J\nZtkRCs2arjKWGaM/0k/IH2LX+l0cGDlQ9bjDw7BxI3QF3HNZ/MvwMHsff5x3HznCp8+cxTQU2sgw\nbfn4qnYi6I5D0OPBGB8lHfEV3quL0FoigotFa4cyGS6pJCKcPAnvfW9hZnEF9rR4L8LxJnRRJPUk\nHcEO2gPtzetEyK+sE+EnJ36Cp3MvHuB08Zdlf2RtOBGmijsxgKvTWFYbWyle8dRTNV3kW47DFwcH\neaiCNa/ZeTyV4qr29oaKCBsCgYpt5G6hlGIkPUJ/pH/JToTBYou5m5GGjG3jZD1s3QpeXdw5c1FK\nFUSE9vZzxolwbPIYO9ftnGUXX2hCQ9yyaPd6Ga3h+Scsa97rM2FZnJp8llu23QIURYT8FG/s7eWz\nO3YseLydqSc4fUEfEX8Eol340jPn6Eul0SpEIfb27WUsMzb/d1rRiRD0eLBQRDWTnlAPm0KdGJ6l\nN9zPJVPc6a4UZ7j32L1ctfEF3D6eWtCFADPFitWKLq/t6OCxWlcEZZRKFUtUijQopaadCE8/DS9+\nMXzl8/OdCH1+P8GyUbhx00Szs/zVTX/Jf/3Of/GX//WX/N3DfzfrOWiaxjs3biQ0xw1wUzTKo0Un\nguk4aJaBEw5XfA7azh34j5ydPu/ecO8sEcFMR7nmGshPzY8zVHQipNMwMAC7dhWKOLdsKfQGlBOP\nM5zrYvt2SNkFJ4JbIkJp/QHw+5s28VAiwTMVBKK4ZZHJFXa5+9v7MfRJDmUybAwEahrpWHiwycJz\nffGLCU9NNb0TIWaa+LIFEcFON658cDEeT6Vo83jmTUV5Lptl95zX6VhmjL5IYTTp1ZuuXrAXYXgY\nLvU/x83WQ+g4dRdGD+s673v+ef5x507uvewyJnSTLZ0JtFyOQLYJRARNw45N0N6/5dyKM7hdrHiw\nkhNBKTh9Gv7oj2D/fqhQjtXKYx5P5XJc/8QTq30a80jpqaZ1ImTNLGkjveJOhB+d3Efc08kN0eiM\niNC+ck6En05NrdpCZVacwec7ZzoRDmUy/HhqqiYhb8gwcIAHWkxEyNo2R7JZburqalicYbgoIjTS\npZLUk/g9fiKBCJf2X7qkCQ1DhkGH1+tqwV/atrEzXrZuLeROzxVhzS3ilkXI42FrMHjOOBGOTh5l\nZ8/OWbdF/JGKTgRHKdK2zc5QqKZIw0dPnODjc7Ldk0aevD7Jls7C4rk7NONEuHSBHXmAizJPcPyC\ndbQH2vF0dRNIzXzG+VNZPN3r5t3Ho3l40ZYX8fOzP5/9D+3tkMsR8hRe4+0qy/rwejaGothaoK6Y\nkOk4OErx+Uc+g7Iy895Hdx28iysu/l10x+HWdfPPuRy/149H82A6lV9v13Z2Tke7lkKpVLFEpQkN\nx3M5fHj47EeD3HIL3HwzxIe88zoRunw+1vv905GGR0YP4bEzXNp3Kbt7d/Pwux7mjqfu4P0/fj+O\nWnjxtzcS4dnita+hFB7LQAtX2IgDul64g+iJE9MiQrkTIaEnyMcLToT0xLp5GzQZ257vRHjmGdi7\nF0q7+ZV6EeJxhrPRGRHBslyLM5Sc0ABhr5f3b9ky7/0DBSEunR3h8r+5nRf+/DS5/BiHs9mlRRke\negiuuw42bCAUizW9iDBlWZD2c8EFYKa8pFyYoLIc7o/HeVt/P4O6Tr7sfXA4m2X3nLXeaGZ0toiw\nQC/C0BBcP/hN3hi/naCqf+TmsVyOvZEIv9LdzTqfj5hpsTMyBB0d+DO1iwj5/PxixXo7EUpOBKam\n6DlvxznoRHCxWPFQJsPeuSrqyEhBBe/pgTe8Af793+fdb28ksuis2GZlQNeZdDmr6wbN3IlQ2iVZ\nyU6EWC7G4bzFpZF2doXDnCp3IqyAiHAok+GVTz/NN8dXZ5zkuRpneKx4QVlLa/eZfJ6ApvFAHXPf\nV4MD6TR7wmE2BAKNjTMEAgvOea+X4fQwG9o3cCCVmnYiVNtxnMugrnN5e7uri9mM42ClCiICWelE\nmEvJndIXCJwzIsKx2DEuWnfRrNvaA+0VOxGSRRfCecHgoiJC3ra5a2xs3vdpLJ9mfaBtese05ESo\nhYtzT/L8+R1EAhF8XesIZmauZoOZPL7unor3qxhp0DTo6KBbKzzPoJWiJ9TDulAXmqPX9dovlSp+\n4RefZ2BqdlwsqSf5yYmfcDBwMX+yeTOeGnaOFxrzeG1n5/Rn/lIYMwz6y6YnzJ3QoBT8w31JYg90\nEp/SOHSoMPQiNeKbjg/AjIjQ4/NNlyt+//j99PhndsU3d27mwd99kF8M/oJ3fOcdGHb1186GQABT\nKcYNozDi0dTxVenJ2HLzdjYNHq0YZxhNxHGyXezZA8mRCp0IxZ/RLEp9CCWqiAhnU4WuhYQZJmCa\n7jkR5ky0+IPzzuP+eHzeWiBuWSQyg3QeP8uW42Oks8PkHWfppYovfjGsX09ocrIl4gxO0sfGjeDR\nvcTzqycivKy7mwva2ni+bKPmcBUnQn+kH4Crz1tYRBgehv7cabqJEXQqb2KbjlO1J2Mux3I5doZC\nAKzz+0k4FhcGh2DPHrzJ2osVG+JEUIqgx4MvkaRnw3Yc5SzYFwGtJCK4WKxoK8XRXG6eOsWpU4UP\nJ4B3vAP+7d/m3XdXKMSJfN7V+bMrRWl3M9FkVtiknpyZzmCkUErVfMHeaEbSI4R8oZovptzgZyd/\nxtYtt3JdNMoFbW0zIkKFYsXXPvPMvPblenCU4t1HjnBNRwc/nVpZ90WJcidC+zlUrPhYMkmXz1eT\niHBW13lZdzdPpdPkmvwiopzHUymu7uysmuN1g5FyJ0KjhIr0CD1dO7lq/37ihAn5QwwkBxa9X962\nSdu26wV/GdvGSBZEBCfT2sLavZOT/PfnnnP1mKXXRK/ff87EGSo6EQKVnQilBeOGQGBREeF7k5OY\nSs0r3Bs3cmxom1kUlooVF8Vx2JN/ksOb22gPtOPr7iGcNad3ttsyOv516yve9YYtN/DQ2cq9CD0U\nnqfXnGJ9eD1dbV1gZeq6fimNdxxODxNPD84SIfed2sfe81/JgUyet/f313S8hcY87gqHGTdNJpb4\nehyb40ToKnMiHDsGt94Kdz2T4D0vivLVr0JvL3R1gR7zkjAriAh+//Q1wk8HHmdruHvCmDAUAAAg\nAElEQVTW43WHuvnxO35MSk/x2rteW7VzQ9M09obDPJvNojsKn5Wnrauz4tduuWkbuxJHmTLniwhn\nxuNEg110dYGZ7GEiUyHOUG0yQ4m5IoJSkExyJlFwIkwZEfxuighlcQaAiNfLn1ZwIyRsm3h6kMDY\nJN1nJoinCr8zllyqeOONsH494fHxpncixEwTO+Zj3ToIOl7GMyv/u8lwHB5NJnlxNMqucHjWZJRK\nIsJoesaJsLd3L2cTZ0nqlQW/oSHoTp6my54kYM8XEU7lctx04ABX79/PiRpW8ceyWXYWzyfk8eAo\nxabIMOzYgWaZ6Mn5k1Mq0YhixZITIZDMEt14AdG26KKRhpYQERylmDJN2pXPlQuo47kcGwIBInPV\nzpMnZ0SEF7+4MHfj6adnfUmb18vWFp3QMFTM6rq56HSDlJGadiKkjTT/4+hRvjw8vNqnBRRsT7vW\n71pRJ8J9J+6jrfsKru3s5IK2Nk4Xf25znQg52+Y/Jyc56KIz5p+GhtCAO3bv5mfx+KqIOVOmOd2J\n4FZ8qRl4LJXizb29NY3+OqPr7I5EuCQSWdZu1mrxi2SSqzs6FhxNVi/Dus7GBscZRtIjdLSfjwL+\nfmCg5l6EoaJLot/lHfGkaWOmvGzaBE6qtYW1vzt7lqdddvNNOxH8/nPLidAzx4ngb6/YiVAuIizW\nifAvIyO8e+PGeSLClGmyOTKzwCwVKy7K4cPEPd2Mtdu0B9rRurroMf1kzSyGbRDNKXxdlZ0IV593\nNQfHDs5fiHd2sk4VLl6VPkpPuIeOQAfKSs0SJ783McFzS3gtZWybNk1hORZjydOzPj+OxY6R6n0F\n/2PTpnl9ANUI+8NVOyq8msYLOzr4xRJ7EcqLFaEQZxjPWdx2G1x/Pbz85dB/S4LfuWqmrFLToDvo\nY8qoHmc4kzjDqJ5je0dvxedxz5vvYUvnFl56x0sZz1R2Ie4pFosnc4qAo9PWWXnspyfcBmaEZLHU\nsS/SNz2dYXgywbpwFE2D3vZ180WEak6EhUSEdBpCIUYmfGzfDrF8GH/RMeEG5XGGEn+waRP3TU1N\nv/5uvx0mcibtXtCGR4icHiKWKogMNTsRMhk4eBCuvbbgRBgba3oRYcqy0Cf9PJq9k6AvTyy78tdr\nj6dSXBQK0eX3c3E4PN2LYDkOz+dy7JrrRMiOMXGmj299qxBLunzD5ewf2l/x2MPDEJ44TacZw2fN\nLlf87sQE1zzxBG9Yv54PVYm4zOVYLseOohNB0zTalZ9oZKxQGNrVhS+ToJbL7kZ2IgR0i54NF9LV\n1rXohIaWEBFKhUH/8W0PX/hk/RnphSYzHNLP408++RQpMwNve1tFN8KeFp3QMFi8uJhssgvQudMZ\nfjI1xY9iK1tkWI3R9Ci71+9e0U6En5z4CSOeHq7r7OT8YHDaidAb6SWWi2E7hdd/ybJ11KWOjkFd\n5/85dYov79rF9lCINo+Hw6vQ/zHtRDh7lo54vKV3XUukLIsTuRxv7OubV/xTiTP5PFuCQV7S1dVS\nvQiPp1Jc09FRMcfrFqUFY9DjQcGy2+gXfIz0COHweVweifD1sTG2972gpl6EIV1nUzBIr8uL2VjO\npk156cufwUy2rhPhmXSax5LJeQvYeim9Jkq7rs0W2VsqSqmCE2Gdu06EIV3n0WSS/75x47zNhJRt\nc35kxjHQHequTTz/wQ/4mf9Wcla6WKwYpcfwkjbSZIwM60wfWnd3xbuG/WEu67+MXwz+YvY/dHbS\nraXwKDBzw6wPr8fr8eKx8wzmZj4P/3FwkE/MLdhbgKzj4FOF985I8sQsMe6Z2FmO+7byB+edV/Px\nIv7qTgRYXqRhbrFit8/Ht39s8vDD8OST8M4/Nhk0dC6dcw27PuydV6w47USwLL773HfZu+m6eYvh\nEj6Pj39+7T/z8u0v58av3lixn6oU540lnaKIUL03IttzIT5LkbHt2XGGZJzeoviwqXsdU/lFnAi2\nDYcOwWWXzdw2V0SIx6Gri4kJ2LZtRkRwy4kQs6x537cOn4/3bd7Mx0+fJp+HP7/NwUax2VcoBvWd\nOEUiXehVq9mJ8OijhdhGKES+Yz2BsTEspbCaWEiYsiyyE/Cpg3+I1n6MqVWIM9wfj3Nzsbx1Vzg8\n7fY8mc+zIRCYJ0qNZcbY9k+Pcua3/oxTp6r3Itg2jI86+IbOEDFieI3Zm1rvPnKEb+3dywe2buX9\nW7bwvYkJji1yfVceZwAIWT5C4SnYtAmtq4u+QJxaLrsriQiudCI4Dpk2Dxs7zyMaPEecCCUVcGAA\nxs/UfwFVsQ8B4ORJfpg/xefiv0L/p/t5ifXPjH/l87zrnt/hbx78G75x6Bs8OfwkO4K+lhQRmtWJ\nUN6JMGkXLggfiMeb4kJwNDPK9u7tWI61aDbIDU5MnSBFEFvzsq2tbVacwefx0dXWxUR2AmDaDeOW\nK+ZLg4O8o79/WmD71a6uVYk0THci/PVf03777S27YCrnl6kUl7e3c2kkwpFsdlGHx1ldZ2swyEui\nUR5sEREhbpoMGwa7I5GGOhFKC0ZN0xoWaRhJj+Bv6+OSSIQ39fYy1HltTU6EQcPgvKKI4KatPp63\n2aCSXPrbV2LEW7cT4YuDg/zheee57hYovSb8Hg9Rn49Yk/2OO5HL8cQSdqTHs+N4NS894dk7+NU6\nEWoVEe4cHeU3envZGgzOE3JySmNbx8w4yZo7Ee69lx95X0XWStMeaIdolG7DS8bIkDJSrNO9hbGN\nVbhxS4VehGiULi2BDw+59Bl6QoXvQ0DpjORmvo+ndZ1vjo/XPKUlY9t4lUl/pJ+B2NFZ76P9OYfL\n25gVJViMhcY8QrFccalOhArFimdiFn/yJ4WhBD9PJLiusxPfHMt/f7uPtDPfiVAS1v7jyH9wYe9l\ndGp+9u2r/NiapvHxl36c/kg/jww8Mu/f94TDHMpmmUopgnaeULSywwRAbdtOOGMVpkSUiQiTmTib\nugsLvvPWd6LbuVldDKURnNMcOwb9/YW+shIVRAQn2kU+X6g0M/1hfHn3RIRKTgSA/3neefz/3J15\nmFtlof8/2fd99r3TlrYUWqBQoFCKIEvZVUDAe70Ceq87P9y9gIree72LC4iiKCgXkYKIWEFQ2ZdS\n2kL3ffZkJpPJTPb1JCc5vz9OkklmMls77UW/z9Pn6SSZTJZz3vO+3/e7/CUU4ruPJllwsoiUhCUZ\nm7wgtFhYnrViVipnr0Qo5CGMjMCVH6uB0TGMSuV7Wo0QzGaJ5vYQy0aRdAOEhfcOiXAgmWRplbXe\nSHyE5n4vn8r9hC/eHOT0pjMmE5nA2BgssvpRGAzoUyEU6XESIZXLERHFUs2qQ6PhtpYWvj2NGkGS\nJHomkAi6jAaVNiorERwOmoyzC1esFqw4L5kI+Twhg4JGSyN2vX3GcMW/GRKhRqPBP5QlPZA86klj\n1WYGgP5+9upEFK9/k18vi7Phzp3oWzu4zuciko7wxL4n+NjGj/GjV77Af+14gnN/eS6/3jVZqfBe\nRVc0BkL4PTfBKs9EGFU38H6HA7taPecAyyf9/nl/byPxEerN9aWk6mONF3peYFnnBznTYkGhUNCo\n0xHMZktps+WWhsPJJB16/byRCAeSSdaUXagvcDh4+f8g2K+kRHC70Q0NIcHfZAZJObZEo5xptVKr\n0SDBjDux7nSaVr2ecwq1Wtm/gff/TizGqWYzKoViUhjYfKFY5ddQmGQfq3BFX9yHQueiXqvli62t\nvCk62Dl6aMbf8woCTccg4C+czlEvBVFFghDMzolE2BOPc/K2bSx8+22a33qLHw1OznY4mJi6qm6+\nEMpm+e3oKF9saSGTz1ckaB8tyo+JWo1mXpsx5gN39PVV/dynwuHA4UlWBpi6nWE2JIIkSTzs8/Gx\nhgZMKhU5SarIWxEUGpbYx3fhHQYH4fQMlrZoFLZt4yXpAlK5BCatCex2HIKCeCZOPBPHITAtiXBO\n2zls8myqvNFqxUqUUwQn0UhXiUzRITIixEvvx51Os8Zm43G/f+rXWIZELgf5NE//To360D7S+Xxp\nl9eTzXGyZerXWY6uLvjRjwqVm1MEK4Jc87g1Gp3TuTUxWNGuVjOWFlm+XP65WO04EfV2JVnypWtF\nuZ1hNJPhLc9bOC3t9O9R8/73Q3f31K/hrJazxhdVZarQ5QUVbjieRyumMdkmWyOKsJ66CEMsTWSC\nEiGSDtNSK7/+xgYFBkXl3GqSEmGilQGgsVGuQixuvYbDZI02XC7Z2qEwGVGlhHm1MzjLMhFK71Gt\n5jMNzXzfN8Dtd4qoMjmaIyb59S1ezOkxK04VtM2RRPjLX6AvXoPoG8OgUr3HSQSRrPMl1i9aT1bb\nSyx7fEmE8jwEoGRnkCSpah4CyEoE59gYqsY6zj/0AJ63qysRvF441TlArnMBOa0eVTJfqrAcFASa\ndbqKANbbWlr4SzDIgSnWLsXmJkvZsaRNq8lrkyU7Q6N+duGKxywTQRQZ0+VoNDfKmQh/D3aGQEFK\n1P7OU9zR+/+OXomQTHKSycQ770y4o6+PfcYUF57RzMO/UtJsbcZyy6dYvyXAf130Xzx1/VPs+uQu\ntt74BG1N53H1kqt5cv+TR/w6krkcd/X14RNmF6RxtHAn05Dsxicc+x31uaA8EyGsb+Ncm411djuv\nznEBe3d//7zv2o4kRqg31eM0OI9LuOKLfS9idq3mzMJiXqVQ0KrT4S7mIpSFK3alUlzudM6bnaE8\n8AXgArud18Lho+7FnStCoihnIrjdKIaH/2YaGiQJplq7bInFSsTQEoNhxnDFohLBodHQqdezfZbJ\nv1MhmApOGRw0X9hasDJA9W7z+UBYFNErlSXP8rE6Nobjw+TUFuq1WhYbjay1OTioakfMT/+evMdI\niRDN5tFbnwbAHAzOiUh/LhjkdIuFv6xYwb2LFvGbkcpwVp8gsGzbtnnPKZiIX/p8XO500qDTyQub\neVzoj5SRCO+1hgZ/JsNTo6NzIja6Al2TQhWhoESo4sGP5HLY1WrqNZopSYRtsRhZSWKN1YpCoagI\n3EvnckgSLLS1lh6vVWnRqXRTBu0B8OKLsGYN4ayJRHZciWATIJFNyPXNaaYnEVrPYbNnc8mmB/Lj\nrVKEz44uJ5j0lZQIBkUOvyCPnYFsFq1Sye0tLTw0ywylZD5PPptk1S4/Fx3OYVIpiedyCKJAVGnh\nNNvMgYqCANdfD/fdN7MSoUGnw6xSVaTFTwdJkvBns9RqtaSyKXpDvWgzGgStKDezAJuiUc6xTg40\nrK9ToM+Nq5QiuRy2QjvDYCqK0+Akllew/VUNq1fDt7419etY3bxaJhHcbli8WNZ1A41aLZl8noFk\nEq2YnVaJUHPWIqyRGN6oSK2xFn/CjyRJxMUICxrlXePGRtDlnRW2mUmZCNVIBJVKlmUUrSzhMILe\nTm2B01CYjGhSwjFXIgA4X2smc1qAXGcMLRlcI7oSiXBSVMcP69IsqqZ8nohsFrZuhXPO4fnnIUAN\nBGQlwnu5oSGQyULLs3z7fd8mpTxE9DiTCFujUZYU8hAAXBoNGoWCkUyGA4nEJBIhL+UZTY7SkPTC\n97/PJ7P38eM7WgmnIiWiq4jhYVhmGqDPmiNoVKCOZ0tKhEFBoGUCOWRVq/lCSwt3T2wOKaArmWSR\nwVBSEwMoExoETaZEItRpZ6dEOFaZCKpMmqhRhUFjwK77O1IiuDQadL4BFqZ6SeXzc1rY5MvS/rOF\noI2mnJEzzoBSi10uBx4P+y1hbr2+mU2bZBaKG2+EP/5RDjwpYKnJhCcjclbbufjiviN6TwcTCc7c\nvp17BgfnvFg+UgTJQ6KP7tB7Sx5dnomQMi5mbYFEeG2OhIBHEHAfrSloAkYSI/Qp6zCYFxzzcMVc\nPsfLfS8T1NRzVtkkob28oaFMidCVSrHe5aI3nT5q60dekuhJp0uBLyBPgJq0WnbMUY55tCjZGTwe\n8Hr/ZhoaXngB1qxhUiiOJEklJQIwKT14IhK5HMl8nprCRfE8u503jnKMuPvVu7n71buP6jlmQrGZ\nAcCmkv25821JKt9xBo6pnUFQGkve5K+3dyC1XsfBQNe0vzdUVCLM8yK5PzmAObcfAFfcS3QOXdxv\nRSKsdzpZZDRyVU0NB5PJCoLj2UAAFbBh5NjVx+YkifuHhvhcSwsgqwXmMxdhkhLhPdTQ8LDPxwkG\nw5xeU7V6R5g+E8FWpkSotvNdVCEU6/1qyr6DsChCLkGbva3id2ZsaHjuOaT1l5HNQjKbKJEIlrRU\nUiJY0nm5PmAK1JpqaTA3VNqFrFbMUpRoOo5aqUbKGvjd78CkgLGMfC10F4jWS5xOhgSBPbMgWhO5\nHMpEGG06y8VDOgwKiVguR3+4H61pAUtM5hmf4+tfh5oaGBmZPlixiNVzyEXwZjKoFQpMKhXPHH6G\nTz77ScIeNcZ6EYVCnuTviMVK15Jy1NaCJjuei1BuZxhKJ1joWIgnnMXXpeaZZ+Tr1d4pHFpFEkE6\nfFhWIhw4ABQaGkwm9udCGDJ5lNN8XuolC6lLhdjVI2LSmlAqlMQzcVJSmM4mG6ds24azMYcqM4FE\nmKhE2LVrMokAlZaGcJiE1k5NIdJDZTGimscWtUCVTAQAUYR7/13DR0zN3NnXh06RxjKslEmEE05g\ncUBBIjnLcXX7dliwgJzVwV//CudcZkOZSmA4znaGtyIRfjk8TNcsbJcAQTGDJqHn9D0B7Gktofzx\nDYIutzIUUVQjHKyiRAilQlgUJpolL9prLkOzagX3nfU4usDpbB2sVCMMD8MizQAeu5KwUYkmlimR\nCB5BoLWKwuSzhfrPauNRVypFm1ZF572dpc9WGVOTVOfkY8Zup1Zz5CTC0S5/Erkc6nQCwSKvA/5u\n2hnGCvUq+pCXJmkYA5UJmTPhrr4+bti/H0mS6E6laNHp6N4nM50lSZfXi+R0kbAMc+ayZq69Fh55\nBNmLdfbZ8Ic/lJ5Pp1TSrtORVLsYjs+9ReCxkRHW7tzJbc3N3NbcfFzC62LFCX1qmL7o0e1qzjei\nQhSLzoKo1JPX1XOq2cw6u53X59AOEBVForkcnnlWdfRSw7+OSAj204+5nWH78HbqzU3sTWU4o6x/\nuUOvZ6CcRIiP2xnu+OMNOFXKo37fHkHAqVZPaiy5wOHgpeNsaQiKIs5USpbKFpQIfwsNDbt3wzvv\nwKYJytxBQUCUJDoKBrZyz141eAqhiitWKHC74Tyb7ajDFQciAzzf/fxRPcdM2FZoZgBQK5UYj4FK\nYDiTobHsynks7QxxtCVZ8Vk2GzYEHvJMTyJ4CxLH+Qz42z68HU+2n1P8awDoUPQSyczuPUuSxFvR\naMmmpFUqucDhqAiu/WMgwJfb2tjg9x+zHJrnAwGcGk1JqVI7S7WAJEmzGnd9x1CJIEkSDx9hW1Be\nkvi518tdHR1zek3V6h1haiVCccFoVqtRwKTxMp3L8YTfz0fLqgvLSYT+uB9lLolRUznhnrahQZLg\n+efJXbwehQLimfFgRXMqV8pEMKdy0yoRoFD1WJ6LYLNhyUUIpgPUGGt4910559qAglBWJmPc6TTt\nej0qhYKPNTTMSo2QyOXQhYMkOpo4vTuFRsoSzeXoDnYjGRorvMrV8Pzz8OST8PjjhUm8YvpgRZAt\nDVtmsSqQJInPHD7MZwvBjkPRIdwRN/4+NRq7TAy8G4uxxGiskEMXUVsLqrSaSOG7r2hnyAh0Ojrp\nGhG5dI0GpxO++lW4667qr6XVKitSggcKifWbx/MRTjSZ8GgTGLN5mG6HfeFCGmKj7O2Vj7GipUFU\nh6lpMbMrkUBqTEHKRSAVKP3arJQIAAsWyI1qAJEIcdU4iaCxGdGk0/MXrDih4rGIxx6TBRE/WNPC\naDaLTpXEPJwvKRE6/EJFo9a0ePNNWLuWrVuhuRnWna8goXdhyOdJHkcS4d7BQX7u9XLBrl00bd7M\nh/ft48eDg+yOx8lLErt3w3e/Kz82k8+TlfLU+i+H22/n3GErMen4bjpVIxGWFEiEA8kkyyZY1/0J\nP0sSLqLaWnkV/qUvcU3P98i5T+d/X6wkEbxeaJcG6LGKBIwS2mi6tPYcnIJEMKvVfLmtjW9WUSN0\np1I4SRLLxErkrDqUJWh3yCyAw4FTOXsSYb4zEYYzGRzREKJVvk7bdLa/LyWCNe6lSTGMXpr95FSS\nJDb4/bwTi/E9j6cUqrhrl3x/iUTo7yfV2AEmP83WRm69Va5skSTgH/9xUkvDiSYTfoyMxEdKfcgz\nIZ3L8S+HDnF3fz8vrVzJx5uaWGYyTZvW/kooxLNjY1PeP1t4MxnUqTSIUXyp45+4Px1igmxneCee\nRBE/TC4v0K7XY1SpZpVkD/IJDcyrEmF3PM5wyz9xmdOGpKs95kqEF3pf4NSFH6BFpytJs4CKcMV6\ns6xEiIoiETHLLvdLNKrzR21p6Eomq06gLnQ4ePk4hiumcjkkScIwOChPEny+vxk7w6FDcNJJsle2\nHEUVQnEHcCYSwS0ItGh07N0ri6DW2my8GYnMeYG3cyf8x3/I//dEPRwYO8BAeOYKoiOBVxBI5/Ms\nKLuq2dXqijq2+UBVJcI8HxtiXiSYChLOUZGSfqE6wBNRxbTE5lAmQ5NON68Bf7dsvAW7ejHtySwR\no4rOXO+slQhdqRRGpZKWsu/lMqeT5wskQiKX49VwmK+0tmJWqdh8jOpE7xsa4nPNzRW74NMtqn/n\nl6XPb7jf4JQHTiGbm/qxOUkiKIrUHiMlwkgmw82HDh2RpPilUAizSsUVLhf+bHbWpHi1ekeYORMB\nqJqLsDEQYJXFQmvZcVBM7Qc4HPGiY/L7m1aJsHs3GAxkOxaj0Ylk81n0aj3YbJiSotzOkAijyeah\nWgZVGc5tO7cyF8FqxZSLEhLGcBlcDA5CJgOZoIqwKB8LAwUlAsAtjY38xu+fsaklmc9jCoVInbcG\n0WxAm4wRE0X2BXrJKQ3TBuD5fHDLLfJU0DV2iK8Z7kUhGqfNRIDZNzQ8MjJCXzrNtwo1496Yl8Ho\nIIMHVUhm+T2/GYmUgtwmorYWSMlKBDGfJ5nLYVapcGk0hHMSC+wLGUlmuelK+Tj51Kdg2zb530Qo\nFApWN69mdM8WeUVbRiIsNxoJGXIzkwhWK7a0gGdAHmvqTHX0+keQtBFyVvlcFVxpxNg0SgSfT14t\nFRRMFZigRIgoKkkEbWr+SIRqdoZcDv7932UixqHRcHtLCzpFCNNItkQiNAzHS5s+M6KQh/Dcc7B+\nPSxaBCFVDcZcriK75FhjIJ3m+4sW4T7rLDafeiqXu1zsSiS4bt8+ajZt4up9e7h/l7wmCWazIMZZ\nlLoKenpYkjSTVB79HDwnSbNSkQj5PFtisUnnxFKjkVfDYXRK5aTvbSQxQueYibC9Q77hwgtRajXc\nv0TNM+9uIzDOZzE8DPXCAPuNCUYNWXTRVIUSYaKdoYhPNTXxdjQ6KUy3K5XCkJXH0+GYTHoax+KM\n1RbIXbsdp3J2mQjp9PxnIngzGZwhPxSCT/9uKh4D2Sw2NNSKw+gkAW2GWUtY9xRsCC+fcgrf93j4\nxfAwy00mdu+WJWklEqGvj1FbA5qcE41K9oxpNPJ5zdVXw5Yt8oBWwHKTie50FpPWNKudku5kkrN3\n7CAiimxbtYoVZlkGtsxonFaJsHFsjKfmg0QQBKRkHDIxguJ7xy8K43aGNyIR9InuUrXQOptt1laP\nQUHAqFSWsgOOFj5B4Io9u1H1/JQb65vIqmeZVH0UeLH3RRx151RYGaC6naErlcIhJQEJJ8mjDlfs\nSqUq8hCKWGezsTkaPSY1etUQEkUcGg2KwUHZi2mxYM7n/2ZIhH/7N9km7PGM3/52NFrxnS6diURI\np3Hm5Mn+H/9IyUM+10aYrVth40b5/56IhwsXXHjM1AhFK4OiLGTIcQxyEYYzGRrLFvZWlWrWyeyz\nxWhiFJfBNSkl/ZraBuJillemGJMkSSoFK8L8BPxlchkOjh1EobBSnxyhp9PBAqGPWG527/mtSIQ1\nEyZY651O/hIMkpMkXgyFOMNiwaHRcGNd3TGxNBxKJtkZj/PhurrSbdPZGaKiyHX79xMRRfaP7scd\ncfP0waenfP7RTAanWo2qcOzNt5VkoHBNGT4CYuIBr5d/aWrCpFKhYrJCoBryUp7uYPekekeYuZ0B\nqpMIRStDOcqVCL3REUyKyQuuaZUIzz0Hl11GVlSgMSYwaUzy+W82o8vkSKZjZENjpI1aOe1uGpzb\ndu4kJYIxFyWSkZUIHo+8Zgx6NCUCzZ1O01YgRToNBlaYTGycYa6UyOWwByPol6/Ef/oyTKEAsVyO\n7WEfNcpsRUhaOfJ5+Kd/go9/HM4/IwEf/CCfSN2LJMysRFhlsbAvkZj2GupOp/lSTw+/XrYMXWEB\nLfR1sX5ngu59SQStfL5PFaoIMokgxWRlVjEPQYECp1pDEjXJwYVgFTnrRHlRZTDIC+A77qj+ms5o\nOoN01wHZ0jtBiYBCgTErTk8iABaNjsiY7BmuM9Wxo68fhaRluOCbj5lTCOFpMhGKVoZq38tZZ8H9\n98N118FrrxHMj5MIOocRbTo1L3aGvCQRLuY0leHJJ+UmiAsukH++q6ODjuBGaqIJkrZGWLQIuy/E\naGwWlud8vqREeP55mURYuBBGcjUYstnjamcYEAQ69HoUCgUdBgMfbWjgF0uWcOjMM9l7+hlEfl/H\n4E0HCQoiW0cOoMgmOC3ngkyGpQk1WfX4tckdcfOVF75StS50Ojw4PMw/HTw44+O2TchDKGKJ0chz\nweCUoYqtfh3pxgXyDQoFfOlLXP36Kyhbt/H/bh8fB71ecEYH2K4NMKwTMEbjFZkI5aRsOYwqFV+v\nokboSqVQpOXaz6IV3uSPEHQVskXsduyEmU0E1rHIRBgSBJyjwyid8olk0/+9KBFEEVVCQ4vSS1at\nR5ua/aLi6bExrqmpoV2v59fLlvFCKMRyk4ldu2RuoKen8MD+fvr0diySLCVTKBiSkHcAACAASURB\nVCipETAa5Qdv2FB63uVGI/sSCRrMDTPmIjzp97Nmxw4+0djIhhNPxFo2GC0xGulKpabMeBgQhJKU\n/WjgzWTIJUPo4naivLeSXovtDG9EItjS/aWdlnWFYL/ZwCMInGm1zpsS4YnRUVYbNTSmDtCm15NW\nW46pEiGZTbLNu42Itokzy6wMMMHOUAhW7EomEZMDtNnaMImheSERvFsN/PjHlbfbNRqWGo1z7ro+\nUpTyENxuWSfY2Iglk3nP2hniosjSLVuQJIlDh+D002Xh0k9/Ov6YYqhiEYsMBvrT6SkbFzyCgDmh\nY+VKuTY6Gj0yS8PgoExmpMU04XSYj53yMf7c/ecjep8AD+98uDL8rAzlVoYi7Gr1vDc0TFIiqOe/\n7tAX91FvbmQsm6WubHKysuFkjL5n+J9yhqgMEVFEpVCUpMbzIavvC/XRYm1BUORoiA0zvKSJzlg/\nCWl277ncylBEi15Ps07H1miUP46NcXVh5n1DXR1Pjo7Oeyf5T4aG+ERjY2lxBDKJMDrForyoKvNm\nMhwaO8TZLWfzw7d/OOXzTzwmarXaeW1n6EvJY693jgS1TxB4KRzmIwULQd0sX5c35i0FDU/EdJkI\nU5EIQ4LAlmiUa4orrALKSQR3IoBFXWllgxmUCAUSIZMBtbEQqgigVCIYtGRDAbLBMdLm6hPtcixy\nLiItpnFHCkF5ViumbIRINoDL6MLrFvnG+m1EBnVEsvJcyS3IisUibm1snNHSEM4K1IcSmE5exejy\nNVh8Qb72nRwHE3E6dNWD8wB++EOIxeCb35DkLfzly6kTvYgpw4wkglGl4gSjkZ3TrAw+09XFF1pa\nSptLAC3bDnHb23Co10takUPM52ckEcSoTKoWj4frroNTT1SSy0v85ekF5E2Vi+FbbpHnwK++Ovn5\nVjevRusegiuvhKGhUktDsdnMlM3NSCLUWE2ImRCZDNQZ69gz1IU2Z8ctCOiVSvyaFKmgk0CyoIzK\nJAhnUuNKhAl5CIcOyVNxSQIuvBB6e+GSS0Ct5rBhZSlYUec0oUsn50WJEBZFzCpVRaVmPi9vGNx1\n1zi/oVIoCKZ8tCuidMUbwWhEtFuRiuGP0+HgQbBaGVE3090N55wjkwhD6Rr0mcxxszOkczmC2WwF\nUV+OgR06GvfXY9rj4rv7h9jY+zLGnI7FkrwbuziRI6ceV+v9z6b/4emDT7Pq56vY6ds569exKRLh\nT4HAjCRQNSsDyBs1sVxuShKhcUSBYkHH+I0f/jC6Xjdrwjle3eHmuefkm4eHwRQYoMucIWHWYkwF\nx5UI6fSUSgSATzQ2sjMeZ2th7pwv1DsKMXnRWbTC20fHCDkK57TdjjX/f5eJMCQIOH1DaGtkwv/v\nSokghdU05L0EmlagLUvInAl/GBvjA4WL50VOJ386+WQuc7jYswc++MFKJcIhjQGXdrzi6B/+QY5C\niEaZZGlYbjKxL5mkwdwwZS6CJEnc1tXF13p7eX7FCj5dJucswqRSUafRlHaaJ2IgnZ4XEmEoLZBL\n+WmhnbRy+l2B4wkxLyLkBJQqPTtiMVziCLGMfAadXwhXnI0EdLBAIviz2Xmpw3On0zQpBerN9bTq\ndMQVhmOaifD6wOuc2nAq7yZSk5QIHVWUCPviUcLBPdx00k2o0sNHb2dIpYgfNExuLEFuaXjpOFka\nSvWOHg+v5fsYNOWxpNNHvVDs6YFLL52nF1mG/nSaQ6kUAwGRZKGl57OfhQcflFnhbCEI64yy71Sn\nVNKs09E3xXntFgS0YT1Ll8qTib/8BdYWMkLmgqEhWTzVHxyiydLEpYsu5ZX+Vyo6uWcLQRS4ZeMt\nDEar19SVNzMUcSyUCMfDzuCL+6ixLcCqUqEpmzgudi4m4n6KnbEYu6ssCLyZTEmFANMvlKshk89P\nsj8Uq/4yyjx1oSHCJy2iMzpIRppduHA1JQLIloZnAwGeDQS4srALsshopF2vn9cMlJgo8ujICJ9s\naqq4fTo7Q4lEEAQOBw/zpTVfYiQ+wtuDb1d9fOmYGByEG26QlQhln/tXv1oRaTRn7PTJ5+m+kbmd\nN4/7/VzlcpU2DWZrszgcOFxVhQAzZyLAZBLh0ZERrq2trfSZQ0U7gzcZxqmZvHCYUokQCskLvHXr\n2LQJFp2YGCcRAMGkRwwHyIUCZMzT5wyALJ8/t+1cNrkLlgarFUM2SlQco8ZQg37PNm54/BoW1RkI\npeX5y0A6XVGd94GaGt6NxaadL42mo7SFBb76y6Xc9sRltATCDAZE+lI5lpmqL87ffRf+8z9l/7v6\n4QflALxf/QpRpUMbUM4YrAiw2mKZloh/KxLh442NFbfph0dZEFMRVwxiVavZGothUatpnmLhUlsL\nQkhWIhSPh9274TvfVoAYRWduwahSVoxpGg3cfbesRpg4nJzRfAY1I3FynQtkdnzLFgB5jBNETJns\njDYVp8OG1Rln3z5ZidAV7EKvsDGQTnOO1cpAJo1BcjEUCiCIApc8egkvDryJumitmZCHcOed8Oyz\n8NZbhRtcLlke8vzzvGm4qKREMLiM6ITUrEmEnlSKM999l597vZPG1ZKVoaenFLD+9NPyom3inMKf\n8NOYC7DTL4932UULMPbPotq1rNrxggvk78Vkgpi+Bk1MOG52BndBoj+VIuepp+BDH4IV+1t5KDTE\ns/2bsQm1dGQOQ309zeExUBnoDfUSTAV5dM+jvPax1/jW+d/iol9fxP3b7p/VfH5LNIpeqZyxbe3V\ncJj3ORyTbl+g16NWKCblIYBc297gz2Jc3jF+o0aD4rbbuPMdPTffsY1PflJe98UHwyCJWBrayDls\nuLKjRITpMxGK0KtU3NHWxjcKuR1DgoBNrcYX7avYfHaN+olYCmOn3Y4l93/XzuDNZKj3ejDWyutg\nm+7vKFhRGkyRVRsQWjrRRWe3qOhLpRgShIpJ1HqXi9EBNS6XPC6WZyLsVSpoMo+TCHV1Mtn5xBPA\n+eeD3w/79gFwgtFIXypFnbl5SiWCWxDY4Pfz7qpVrLJM3lUoYpnROGWv6EA6jUcQjjrw6nBIQJEf\nZKlxCdkpqmqmwuvhMFfu2XNUf38qlPIQYjGWmUzYNbqS9KlDr0ejUMxql92TTrNAr6deq8U7R9lp\noMpktj8loExHaTA30KjVEpM0jB1DO8OLvS+ydsGleASBkyYMfE2FHU0hny8pETaNDdCp13GC6wSy\nif6jVyIkk8QPGcaVOWW40OE4biTCQDpNrUYDbjfbpCC9uizmROKoE/j375d39Y8Ge0b2cDhwuOK2\nYqDlpi6BE06QdyUWL5bHlscfh72JBG16PbYJUsjpchE86TR5n46WFrjqKnjmmXElwlz6xoeG5Inh\nzl4PLdYWaow1LK1ZWikbniX6wn1ISFVJBEmSeGcCUQLzX/MoSRL7E4nxC3dPzzGxMwzHh7GY2yvy\nEAA0Kg0nOBdwnU3J96qoEYYKoYpFzNXO8J2BAa4tXF+K6Ap2sdi5mKw6R+2YG2HlSTQlIuikmcNG\nQ9ksA4LAyioTqfUuFz8ZGqJeq2VBWRbKTfNsafhfn48LHY6KTAaY3s7gKVMiHA4c5sTaE/n8mZ/n\nnrfvqfr4EomweTP86U+TPvdt22T7/pFitz8NGQXv9s9NibDB7+emsiDD2SoRugLV8xBg7pkIkiRV\ntTJApRLBJ8Sp0U7etXPop1Ai/PWvsHYtGAxs2AAXXxHHpB0/zjIWA1I4TD4cQrRMv9AsosLSYLOh\nz0SI52UlgnLQjSHk5bwOBcm8TIYUgxWLMKhU3FBXx6+mUSME4hFqo2l+9lwbz729BlMqzpkrBomp\nTZxmn1zvGI/Lav777oOO0A74139FrokwEbc0YfJmKpQIfzr1TpJ17XIgd3u7TGwxfS5CIpcjkk2T\nz1R+zlZ/lIZIjqaFAzjUap4NBKpWOxbhdEI2rCIkyEoEm0otB/NeEkIpRvnq9/Q4NZPDAW+8EcJh\nOTSy4vnyOqwZOKgOy+HiBUtDOq2A0BjGTHZGJYKtpgadNc3mzTKJ4EkexqKxM5BO8z6Hg55UCofe\nyXA4wK1/vJVGSyMGnZ0Nux6Wn2DnTli5EpDJnE2bZMLjkUcm/62xMdmifM3j15C1e9GKWTKzWCeE\nslku372bixwOfjMywmnvvMNbZYvXEonw8Y/DV76CJMkqhDvvrHRZ5KU8kXgAsxBmS5+8k6tcvASH\nZxZ25AKJULQyjCXHuP3PtyO5XKjCqeNmZxhIp0sB0BMhSfKhf+21sMppxhoViNddiiHhoinZBeed\nh2vUA0od73q38/N3f85VS66iydLETSffxFu3vMWD2x/kuievm1YiH8pm8WYyfKa5mWfLAwomYKo8\nBACNUskig2FqJUIwgeu0jso7PvEJVu8NYci9xMUXw1e+Agb/AMmmWtrs7UhOJ3Win7CQI5nLEc/l\n5LnqNLilsZGDySSbIhG6UykWGQy4I27ObD6T4dgwkgSNgSHCxsI12OHAlD2yYMX5yEQYEgSahgYx\nN8jBqnb931HFo7p7jKipCVVLI/poclYkwsaxMa5yuUpeySJ275bHpdpaOawnFAL6+tilEelwNlc8\n9pZb4KGHkHtpb7qppEbQKZV06PXoLAunJBE8hcq8iX6diSjWkUxEXBRJ5fM41Ooj8mOWozeSQZL6\nOcVxMpJSNSev2NvRKG/NcQEzWxStDPd7vXygpgaLzlJSIigUCtbZ7bPKRSh2trbpdHOyNEREkfbN\nm/FNkKpuH0rz8p8C1Jvq5ZA0pYQvc+yyJF7ofYH6xnWcajaPy+YSCXjhBdRKJU06HZ50mjpTHaPJ\nUfbHI5xfv5BmazOx8CHc08jjZ4KYz9OfTuPfaRgn1cpwjs3Gznic+DGuWZQkifu9Xm6qqwOPh02Z\nCHvySSyx2FHbGQYGIBKR/x0pvvP6dzjrwbMqdkSLGRw7PAJLlow/9vOflwMW3y6rdizHkinO+eJz\npt06apvjXHGFrBpuUcvMes8crhJDQ2A2w/7BQVpsreQlifWL1vN819xzEXqCMrtUjUToSaUwq1QV\ni+43vnkzI4HDHIp4Zx08OxNeDIVI5vOcZ7fLA/eyZVgymWOiRDAYmyaRCAAn1Z3E0kwXfwoE8EwY\nZ7yFUMUi5mJnkCSJB9zdvBEaq1AVHQ4cptMpH1iGVBzjoqVkVQp0omJGYu3tgsWkXIZbxBqrFQm4\nylXZ8359XR0bAwHS8/CZ5iWJHxcCFSdiunaGQUFAAXjSSTwRD52OTm459RZe6H0BT2QyeVMiEXbt\ngnicumSy4rnd7vE6+SNBbzwNh6wcGJ39NbgnlaI/nebCMqlt3XwpEapkIkSmIBG2xmLkJImzq4xB\n5STCmJCiQW+RO2rLcgUcBkd1G9/zz8NllxGPy/89a128Qokgmk1IkTBEIuSsM9cmQqGhwVMgEaxW\n9EKUeF4OVtSPyl/gRcYgObWaw/05QqJYoUoC2dLwK59vSpVOPBwkowVHjYrGOgNRfRaX/l3QLmCZ\nefJGz+c+B+eeCzesj8je+/vug6VLAUg7mzCPpCuUCK1dL/Hg8nvkSeb73iczyUxPIrjTafLpEXaP\njDNdMSFGcySHSoJFzgPYCyTCVKGKAEolGCQ1I3FZiaDLqqmpgeFUL0aycjJ8lbmoSiUviu+4Q5bp\nl9DXR6DOwtbhdypIhIEBCUVmH7ZEakYSwV5fj2QWuftueOqROvy5w9j1MomwziYrElxmJ694N9IV\n7OKRax6h3bmEN/tf5IW9f5TbF5YtA+RF+513wj//s5xHMPFSODYGLpfES30vETXsR5lXkp1h/M3m\n81y7bx/rXS7+rbOTV085hdtaWvjEoUOlxwSL9Y7d3fDII7x6/z7yeZngL0coFWJhxoxor2HXXpno\n0i07iYbh2MzXwDfeILdmLX/9K1x0iciHf/dh7tlyD4omE6pI4rjZGfonEHPlePdd0Grh5JNhyRLI\nHfgTSeNCiGmoDXfBunWY/IOQk3hzaCv3bb2PL5z1hdLvL3YtZvOtm2myNHHaA6exdWhr1b/zTizG\naWYzV7tcPDM2NuW6Y1s0ylKjcdIGTRG/X76cC6pYHYbCftpTYawrF1TeYbPhu3Y9C3/9J773PXnz\nZqlhgFC9hXZbO+qaOmozY0QzudKGwURl+URolUru6ujgG319cu5YgURY3bwaX8JHMgmLYm6CRXLP\nbseYnluwYjafZ088ztNxH/EP9B/xOiAmiuQkCZd/DHuD/NnY9La/fTuDJEkEslm0XSOkHE3oOxox\nRuKz2pks5iGIopykWsSuXTKJoFDICag9h0TwetmrjXFCY+WE55JLZF/xvn3Ilobf/KY00i43mRAN\nrdMqEdqmkbsUscxkqhquWEwfLvfEHyncqSSqTJTljZ2Qjc8pNXx3PE5QFI+ayKiGqBBFYzuJ18Jh\nbmtpAcHC574U4/775fvX2WyzykUoSotadbo5hSs+NTpKIp+ne8IVaRSBwPAw9SZ5d6JBo8IvHpv6\ns5H4CO6Im7C2scLKEPvBL8hcfS3kcvIxIAhoVVqsOit+Scd1HWfTbGlmOOamSaeb0hIzE9yCQJ1W\ny4hbRThcUuyVYFSpON1imVFadrTYFIkwls3ygdpaJI+Hg3YfvaYQ5lDoqBeKxUXEFHb2WWFn0M1t\na77GVRuu4sXeF+XnLXzmB8YqSYSLL4ZkEp7pjk3KuABYYjBUVSJIkoRHEIh26/nP5GICmp20tcHb\nbytYO8dchMFBOOMMODziodd+Ed/u72f9ovX8uWfuuQg9oalJhIlWBu+uTaz99sPE+nfxs52PctL9\nJx01kSBJEt/s7+cb7e0yKTw4CNks1mDwmJAIGn1dqd6xHCfXnUzf2B4+1tDAPYOVn4VXEGjWauXr\nw9DQnFoCtsZiRIUQzuBr/NzrLd3eFeyixbkIlaBAdNRRb27Aa9WgF2bOBaqWh1CERqnk3xYs4OYJ\nEuomnY5TzWaeCx59/stLoRA6pZK1VRY+09kZPOm0TKxHx2ixtpTGvI+u+Cg/3vrjSY8vkQg7Zc+t\na2iIUDZLTpLI5+Vz/mjOex9pFiStDMRnf1153O/n2traCgJn1kqEKZoZYDwToXxinZckoqKItWBX\nKCcRiiqEapNdl1pdUuGFxCytGpO8UNw57l2uqkTI5ylumW7cKC+yNQY5WLGInNWMIhpFEY2Sn2b3\nvBynNp5KT7BHls/abOjSERJSALu2BlfCjaRUstDjR6HT8cDT8iR+ouz6VIuFGo1mSuVcKp4gpdez\nYoX8c9KuQYq4kfRNmCOVtosNG2TZ/I/uleDmm+XJ4A03lO4X65sw+1MVSoTalJuH955OvrYePvpR\n2QOBvFE0ms1WVT3uj44hpX30hnpLtw3Hh+mIqUloDbQqu3Go1exJJKbMQyjColTTGw6wP+RGkVDT\n2SmP3TaVrOh0TrHguuYaUKtluXoJfX1k25rlxd5ZZ8lJvbkcWw8PoO56hFs3bpQ11NPA3tpKXK2g\n67BEZ0MtojpCndXGgCCw1GjEpdFQ29BKnXoxG2/YiEFjICMp+Ld1d/HDB28le8Ii0Gp5/XU5NuDj\nH5eLGlatkhd55RgbA7UlKLeCqAeQciqyM6wTbuvuxqBU8r2FCwF54+qmujp60+nSRlsgm8WlVMLo\nKNLd38bwr1/gzjukSVmP/oSfpaINVUsje/bIp4l6yTKWhlTT52m53ZBOszV8Ak1NcN+Br6JWqllW\ns4x8C2jD8eNmZxiYhkQoWhkUCmhZGMGXfJDVZiO5iBr7aBesXYsy4AdBwS92/pplNctY2bCy4jl0\nah0/Wv8jvnfx97jisSv4weYfTCIJtsZinGm1stJsJp3PT6nYfGWKPIQilplMVQn0oVEfjdkwitbJ\njR/2r36D978+iFUK8rOfwVmNAww7NbTb29HWNlKfGiMmylXy01kZyvHR+noG0ml+OTxMp17LaGKU\npbbTGI4NEw7DCel+4kqlTHza7ejSc7MzfOLQIa7eu5e/RgPkLveyIzaLVMYqGBIEmnQ6zIksruZF\n8ufx96BESObzKBUK1ANesnVNmE9oxBqNzDiBGs1k2BmP836Hg9tukxnlInbtonQRWbQIhrd6kBoa\nCGt9nNxeSSKo1XIq7y9/iUzBuVzw2muATCIkNbVTZiJ4pknvLMdUDQ1FaVH7PJAIo1KahriCi392\nN4iRKaWk1bArkaBGo6nqAz5aRIUoYw0f4hvtHWz4lYpX/myhY0mMe+6RB+HzC+GKM6kginUrbXr9\npB3C6fDrkRFqNBp6y35HyOdJabKEgh7qzTKJ0KLTEspXvwAfLV7sfZHzO85nWzwxvmudz5P6wf2k\nUxLith0VuQguayeg4PzmU2iyNOGNeTnBYDhiS0NXKkWr0kBtLfKkowfZEFb2mV/ocPDyPHqlq+G/\nPB6+1NqKSpJgcBC3UceQSYV+zD9vJMKR7kgGhCTdbZ9H3XotT13/FDc+dSO9oV7chYtJXyxTQSIo\nlfKY82aguhJhqdFYao4px1g2i1GpZHAwRlj08dNtP+XKK+WWhvNstlnnIiSTMlO9ciW4w4OMqut5\nyOfj1MZVDMeGq+7oToeeYA9NlqaqJMK2CVaG3h/K5ePXO1bxj6s+jUKhmHLXYbb4ayhEWBS5vpjw\nX0g9toyOzrudwRf3odA6p1Qi7PHv4f+1tPCwz0e4bBwtXoR5+WW48so5KRF+MnAQ9ehrRPof45ER\nX0kJcDhwmCZbJ+q0RL6unnpzPR67AkMqOzOJME0IG8DnWlpYWGURcGNdHY/Ng6XhvqEhPlslBwim\nz4sohuT2JCMsqRk/qT535ud4aMdDk3bifZmM/F3t2gXLlqHyeHAU/P4jI7Jo5UjPe0mSiBnTXLPY\nyqg0O0JIkiQeGxnhxrI2CmBSVsNUOBw4zGJXdSWCVqVFqVBW5JrEczkMZcFvRRIhncvxW7+ff6yf\nLNOHcSWCIAqkJSXNqcLxVOy/phCsODETYft2WTvf2cmGDbIcPp6pVCJIVgvKaAx1NA4zLHzL39sZ\nzWeweXAzWK1o0lFSjCElXSzWulGcfTbNXW4klYaHnkvTqKw+t5ouYDGTzhBR2Tj5ZPnnXLODlCCh\n0JvY+cL4oqCvT1aTbdgA5gfvkVmoH/yg4rmUTY2YA/HS8ZiKZHDlR0naGuWPcN06OZTm4EFUCgWn\nWyylkLVy7Ar7QPBXkAjemJemcI7djhOpTblxqNXYVKpSqOFUsGtU7A4d5LeHniMXKZAIwR5qNFoO\nJ5NVlQggLwyLdYWl4bSvD/3iZWwZ2iL7BOrrYf9+XuvbxILkaRgkSZ4gTwOb00nEaMQqBvnCv8jn\nQ3tbDZl8HpdGQ6fBgLO5gc+r99Jgli03yXyeda1ncqtyFa/ZI+TzEnfcIWc3FIfkj3600tIgSTA6\nCjF1PwBRRT9SXk1mmmvDnwMB/vdQgLsUJ1aolfUqFe06XUkRFshmcSUS0NbGC0s+S116gA8ZJ6v5\nRpOjLEqbULc0YrfL6kdOOIElQSVD0aGpP6Q33oBzz+X5Pytov+Ix/nDoD2z40AYWOBYgtmTQR2LH\nz85QaGaYiHIrA8BB9ROo3e/n0RNPwvZqDQb/gCxPcDhQJdSkJfji2V+c8u98cNkH2fqJrfx232+5\n+vGrEfPj39PWaJTVFgsKhYIrXK4pLQ3VQhW/+Jcv8tD2h6Z9j+phL2FDzfjBVAbnCSt5bbmRsXu/\ny5VXwmeuGKDPJtFma8PY0EJ9XA5WLCqfZwONUsk3OzrYEovhkJLUGRv58PoW9vb7CIehOT+EVamU\nrZ92O9pkmFh05g3LIomwIx7nd8uX8/jy5ah2Ong3PLcWryK8mQz1ahX2lISpXiZYrDorUSE67SbQ\ne5pEGEynueXgQU4ymVCNeFE0yUqEmlSIscT0E6hnAwEudjpJx1Q89pisKiteV4p2BpBJhJZH/oPU\n2ReitA3RWTNZennLLfDoo/JkpDxg8USjkaDCMrUSYULwz1Qo2hkmLpSLrODRkgiSJBHXilzWm8K5\n8TcoMjEGU7NL2xcKu/QfqqmpuuiZK3KSxAvBYGky9Uo0gaixs/VbDdx7L1x3tYXLPxDDYJDn4gsN\nBiSoWORPRLQgw7Gr1bKdYZZKBHc6ze54nFsbGipk4kOCgDqqJaUYwa6RJ2AdehMRZjdozBUv9r3I\n+xdcVFEF6N/wIiMxI3+wfpShR1+hXaejq3BRM9uW4iSJSqnCrreTzWXp0GmOnERIJqkVDLS1yedD\n/944nHhixVX6gmOci7AvkWBbNMpH6+thdBTRZCAVXYQvtwD9yHDFgulI5FoDA/JbOtLFxD8f2IVS\nbaInnWFt+1re1/E+3h58G086zdlWK75cpRIB4Jp/EIkZ0tiCkyd+a2w2BgWBPROIObcgyERYrI/r\nB538fs8TXLA+KpMIdvus1SBDQ3LIY2srDKeGGJaMWFUqXotEuXjhxXNuaegN97KufR2DsSokQlkz\ngySKLNz4BpE1p2H3+wmLItcsuYaNBzfO6e+VQ5IkvtnXxzc7OsYne0USwec7JkoEUW2R6x3LFlQg\nkwh7/Xtp1eu53OXiZ2WqgVKw4uHDcOAAtSrVrJQIOUni92Mhrq+tYYnJzAJ1nt+PjZHMJhlLjmE1\n1qNJ5lA01FNnqmPAlsWYmD4XyCcIbIvFJoW0zgYfqq3lhVDoqMiZ3lSKtyKRUjPBRLg0GsKFcXsi\nBgWB1RYLXkHgBOf4jnyno5Pz2s/jf3f9b8XjfZkMDYIge5XWrQO3u6QCGSjMbT2eycFxs8FIOks+\no+Qja41kLALTWHRL2JNIEMvlJgVazkaJIOZF+sP9LHQsnPIxExsayvMQQCYRRjIZ/jA2xiqLZcqN\njCKJMBgdRK93YQ8WxveyAImqSoRCK0MgIK9/rr4aEtnKYEXJZkMdTaCOJVFOs1s4Eee2FnIR9HoU\nUp5cbpRMpIYOpRvWr8dyuB9FLsUpH0jg21X9enxTXR1/CQar7vpnczAiCGOTDgAAIABJREFUNpY2\nkUwNDexZ0IkrmeT5P8ljSzYrO1e/9jU4Lf2WnKr4299WppgBmvYmbKFoSYnge3eIUXUjl1yu5s9/\nRvYJfPjDpVavqSwNh+JBFMIoveFxEmHU240KBdvFFTjCIzg0GtbYbFMG3hXh0KmJ5AUORYZIjilY\nuBB6Q700603TKhEALrpI5gkefbRwQ18fNcvPoD/cLy+CC5aGHYE3WaE+fUYrA8jtTmGbDXp6qDPJ\nJIJC30C7Todi9WoWajRIDWnKOZ9ELodRqeSadAc76yU+/+sHCATgIx8Zf8wHPiDnIxS5znhcDiP0\npfpRKpQE8wPks1MrEaKiyM37DpO8ewmHd07+TE4ymdhbmO8GRBFnOIy0cCHf/q6Ggc99H+WXviAf\nKGUYTYzSkdJBo3x87dgBdHbSFBLp9R+a9DdKKOQhPLVpJ29abuPpDz+N0+Ck3dZOsjGJMRY5vnaG\nKmuW3btlcum00+Sf/zDwS/Lv3kJDzojjkI9cfTPodCiamtAJ8J11D3DpoumTrDvsHbxx8xvs8e+h\nK9AFyNf6LdEoqwvXrStraqqSCEI+z9YJeQjuiJv7tt7HX3v/Ou3ftY/6iTk7prx/8/VrMP30Ichk\nULgHOGhM0m5rx9q4gIaYbKmc7QZxETfV1/N+hwOHOIZJbGP18gaC2WE+cmOemtwITo1GVofr9aBQ\nIERmXu8JAmi1En2FPDgArcfMu5EjVyI4FFmsAiXiV6VQo1ca+efPTv2c71kS4d7BQU555x1OMBp5\n9ZRT0AW9aNqboKGBxvQoI7HpJ45FK8Mjj8gJqh/5CNx7rzzPGB2V61MA1g//kvruN9n7zz9CsgzR\nbJ1MIixaJNvgnn0WmXZ/+mlIJllsNOLPa6bORJhJ8pJMwjnnULtrFwqYNMEYSKdxKDII8QG6k0eu\nAgiJIogSl/THUUgSxqjAoeAswl6Ag8kknXo9q63WoyIRJEni96OjnLxtG1/s6WHxli18cO9e7g8o\n0by7hRGvks2bob3RjHPbHr76wS5+9rPZ5SIUWUGFQkGbXj/rTIQNBcnpMpOpgqRwp9MwokdlGyEX\nkSfBC01WUirLvOdCSJLECz0vsLT1fHQKRSmYbfiOn3D4/Z9BPPd9iC++ytU1NfzK5+PxkRFqXady\nolk+yRUDAzRZmqhRpI+4oaErlcIcNtLWJp8XdQ/+h7zT9N//XbLurLZY6E6lqk7M5gPf83j4XEsL\nBpUK3G5CNXa0yU6GUkux+HylTIRgNkvjW28xOEdSze2WZbdHQiL8YXSUN6MJzkpuKhE1K+pXsHtk\nN25B4EyLlYhGDlYsx8F8lKaEhV/8bPIwq1Uq+VRTE/dOkMR70mmaNToiUjePPhzmG8NL2KP8NfE4\nKD1GIqI4q/c+OCjLPltbYcyQpUmr5NPNzfzK55NzEbrnlovQE+yRSYQJSgQxn2dnPF4Kjj34+I8Z\ns6iwXvsPOIaHCWWzXLP0Gv5w6Mjj8Z8Pyuz/dcX+LpBJBIsF69DQvCoRxLzIwbGDiCoL9dGonAx+\n4EDp/nZbO1EhSigV4sutrfxoaKgkNS0FK3Z3QzpN3djYrJQIL4WCZFNeblvxQVY1rmKl5OEBr5fu\nYDedjk5SedClMqib63EanAxYRUyxqS19/akU5+7Ywdfb2nDMMUQXwKnRsM5u5w9js7tGVMP9Q0Pc\n3Ng4qRGgCJVCgV2trmqrKyoRAjkmyfpvP+t27nn7noqdEV8mQ0NPj6wU7OgAt1ve9c9mcbvhpJPk\nDdMj4UDf7BLQhvQsduhQ1mbkhcEM2OD3c0Nd3aQF32wyEQbCA9Sb6zFoppaJT2xomEgiFMmKX/p8\n3FwlULEIk0qFKEl0hdzodE5sPp98vJeTCNWUCM89B+vX87vfyXMri0VWIpTbGZQ2O+p4Am0sicpR\nmbsxHc5pO0cmERQKRKMVXXaM5JiLRlEmEbSHukCM07w2zth+PS+/PPk57BoNV7hcPFpFTSOioivY\nWVIitJlrOdTWwcmjPl5+WVZv3X23PIe+/R/HZPvCgw/CggWTnsu0uAlnLFz6LkK73ARMbVx6KTKJ\nADIb8dhjIElyQ0MVnXJfKskCg6lCiZDoPUi4xkpv8kTso2E6dDourpJCPxE1RhVJcqAyMRIcKNkZ\n2kwOhjOZKZUIMK5G+Na35AUKfX2oF53AVUuu4sn9T8okwltv0Su+ydmuU2ZFItjUasJGI3R3U2OU\nqxPy2hraMxl45x0WRiIIrhS+sil0Mp/HqFKh2rWH6278dx44dBefvPMA5UOJ2SyTVwW3SClUcSAy\nwGmNpzGaGUAU1WSnIFq/3NODs9uJtuk7vNPTO+n+YvsaFJQIo6MM6RYyMgJrv3uZHJpZ6HEOpoJ8\n943v8vk/f56T8i5obOTSS+XcBnQ6IrUWQrunUeK98QZ9i07mwMoP8JPLfsyKepnharO1EXRFsCXC\nJP+P7QxPPSWrEBQK2OffhyfqYYn6Yg4fBleoC2lxQTnV2Igxk2WZ7X0z5gWAHFa8rGYZ3UE5jKsY\nqltcN11gt7M9Hic04TqxtUoewn9v+m8uXXQp73irVIwVkMwmaQtlEZurK70A6s65GE+TWd55Hhhg\nlz5Mu70dZ2Mn9ZEYKXJ40ulZ2xlAvt69sHIluaSHk3cbeDDyBU4LxLn4zCEErQWnVkuwcD3PWR0o\nojMrTgUBkmoRJZSu8515M1vGjpxEsAhRUnoVklLFAw/IBHwmZsPROPXm1XuSRHglFOL7Hg9bVq3i\nOwsWYFSpsES9mBY3QWMjjQk//vjUJ1VcFHk1HOYyp5P774dPfxq++EX4xS9k0m/5cpkkZscOznz6\nq3y58/fs90solHlsuurSu1tvLVgamppko/Ezz7DIYMCTlRieTokwHVv1hS/A3r0onn6aZVWC1vrT\nafa6X+I3237Awwef54xfnDGnrtUivIIAcYHVvSGoqcEZFTgYmN2Manc8zgqzmZNNpiO2M7wcCnHW\n9u18u7+f7y9cyK7TT2fg7LO50Owk/k6MumCAjRvlC4Mzp+ND33qC6zffzssvg9cL6wqWhqkwWMYK\ntup0pYFoOkiSxK99Pv6hvp5OvZ7esl38voSA6NWhc/lIjcokwgKDEaW+vhT6OBsEs9kZSYeDYwdR\nKVX4FM7SrqH79X5a3W9y/s9vou66dTT0vMmpBgMvrlzJl3t78TrWckH9YpmEWr6cc6N2LLnIUdkZ\nVMOyEuE0Ww8nbf657HnVakuzIY1Sybk226xCLueKg4k4T4+O8OliDZzHw5BZj0vZiaA5FYc/UFow\nvRGJEBBF7h2aRh44AZmMPMk488y5kwjDgsAnDx/m0ux2VtscJTXIivoV7BrZw5Ag0JG0oqoXJrVd\nbYnFWN9hKdU9TsS/NDXx1NhYhcTZLQjU5HQsde5AmZe4+a9+Hth6P1dcKfHsswrWzlKNMDQEzc0y\nkZC0WzjdYuGGujqeCwQ4q+P9vNz3Mtnc7AihvJSnL9zHee3nTSIR9iWTtJa1TyR/dh+D117CU+8u\nwNLvISyKrGpaRVSIcmhsmt2YKVDMQvhmR0floqy/H845B4vbPa9KhJd6X2KBYwFxNNQXZ7bf/37p\nfoVCwfK65ez17+Vks5nLXS6WbN3KjwcH8RTtDN3doFZT29MzKxLh3t49OGM7WdmwktMaTyM/+jqH\nUyleGellsXMxgWQOY0pA1dSAUqFkzGHBEq+eE7I/kWDtzp3c3trK19vbj/hzuLGujg1+/6TbJUli\n7Y4d01rGkrkcD/t84+fzFKiWixAVRfKSxIlGIwmFnsXOShLh3LZzsegspXDQsUyG4UyGlj17ZHlh\nWxsMDJSCG91u+abW1iMjEDf3pXFmdVhUKpQqic27piesJEnicb9fDoedgNkoEYptHNPBpDGVJPQx\nIcZrg9srSAStUolFpWJrNMo1xc67KlAoFNRoNByMelFprNiGhuDyy+HQodIuq9PgrFQi/H/qzjs8\nyjJt+78pmckkM5lJ771RQ+9FEZBiQ7CCq66u3dW1srjuWtaCZdW1sVZcRbAigg3EAiK9BAikkd6T\nSZmZTC/P98c9mSRMEnDf/Y7jfa9/OJiZPPPMzPPc93Wd13meV1ubGHUza1ZAygDBcga5IRJVtwO1\n1YnyN4AI01KmcbDxIGXtZRhVDnROcNaEE+q1wdixyGx2FO5uTjq6+d35am67zV/wnhY3JibydlNT\n//3X58OtUHGiYVQA8M2MiMOnCKGg6CQTRjp47DGR5/17rQ/5tdeID3jRRQOeqzYviVh7BzaX2BO6\ni2vpjkzjnHOE4sNkQozpkSQ4dIgpERHsN5uDcoJmt5dUd0Y/EMFVU0mnIQaS80gzwe3xev6UmnrG\n7y9Oq8Qll5EVW0Cr4xjZ2QJEyNGJ63EoJgIIoH3ECIGbUFkJmZlcPepqPir6CGbOxPvLTiyKaqYm\nZJwViKCRy/HK5ThLSlApVESGRuII0ZPuB3iy6usxa+39mAg2r5cwmQyOH+dw50Uklz7JWstynJ7+\nP/Qtt4jGYM/+HhMD1V3VnJN+Do32ajyukAGnM/zQ2ck37R3UvtKFa8JLHGwNnlbUl4nQ4XYT3dDA\nd6dyWLkSlCEyeOEFPH9/jAc23ED2y9mUtpfy9fKvmRWSA4mJrFghUiejEYxj81HtOzDwF9TejlRX\nxyXHnyTbcTkrxl4ZeCpdn06luo1oRwed1v//TAS3z0ezyzUgTf+zz4QfAsCLe1/klgm3MCxPSXEx\nJFvLUQ73r1lJSeicTlrP0OTtG9HRYylvFyDCfj8LoQeA0CgUnGMwsPU0j57TpQxNlibWH1/PGxe+\nQZu1bVAPijZrG1ntYYTkZgx6PpOSJrHmnDB4/nmk6mqOqDpI1iWTEJkCPgdOmec3yRkCYbOR+9Qb\nvPr5bmLHpfH1Oh+PtNyMLi+JqD6AuqQ3oDANXZ/5fOK6b/DZ+01XumiEljJv9380za/R5cLbXoU9\nXMOCBf518N+Qn27gupv/D4EITp+P28rKeDknJ6DXlCSIdDQSMSwJIiMx2Mx02gYvFLd2djI1IoLD\nO0NQqcTCmJEhRqfce69fyiBJcMUVdD/9Kj80DqeotgGdNLB+EwQKt3u3SM57JA16pZJwhQKLFBK0\nwMEZmAgbN8L33wuq23ffMWyAMY81TifGzhP8bcot5CXP4prR13DLV7f8ZpOyOocLhclCbEc3XHwx\n8V12qs1nVwwfs1opCA9nZHg4ZXb7b6KSHzCbmX/0KDeXlvKnlBQOT5zIouhoZDIZeqWS7JIkog9V\ns+g8XUBaN/2LA1Tkx6E8eoh75hfx9tu9vgiDfr4+N3RaaOhZyRmOdndj9fmYodeTpdH0YyIUtTnR\n2UPxqFvoaujxRFCjCE0YeGb2IDHjyJEzSgC2V25nftb8gJkMwPE7/kXp5GuJTgtnygUxVPvS8e4/\nxGitlt3jxqEAxut0Ypey2ZjeIEfjbGG/2czrDQ2/afIGQJnNhqtKgAjnf3cvHyffJyrQ+++H554L\nvG5uZCQ//pclDT5J4sJDO+gue40wmf+86+qoCJOREp5FrG4MoU47Fv9vuqOri5sTE3m3qQnTWXag\n6+shMVH4PfyWQkKSJG4oLeXmpCS62n5lWmweFq8Xs8dDQXwBhR01GJRK3NUapJjga26f2cyCtAim\nTOntmPSNWJWKpTExvNkng6pzOgmzhjI8tIiGcTmEh0cys8hM9pxdgVGPvwVEiEm04zOkMTMyluiQ\nEOZHRfGTVSI3OpfddbvPeBwQ+lxDqIGcqBxaulv66Rf7ShkczfXkHKqiLvdJnvgwg9CTlXR6PMhl\nci7Jv4QvS3+7pOHr9nacPh/L+rIQQIAI55xDREXFfxVEWF+0nuWjltPichFfVycyp88/p2+WOzpu\nNMdbxcjbt/Lz+XzkSLb7PRsSVSp8ZWWYpowhuriYzkEo+z3h9PnYbnZyY7LodE5InMCRpoNcFhvL\nd50m8qLzaDF7iXDZBdcYsMTEYLAEG0oeNJs5r7CQpzIzuWOAiQi/JS6OiWG3yRSk4S+x2dhlMrFx\nCJbChy0tTNfr+yU3feOjoo944Jt7iFWpgrx5etbyUIUCvHbiInP6PS+Tybhn6j28uPdFAF5taOCK\nuDh0R470ggh+JkKPnCE9XTz8n5grHm9zkBoSikwmI0pSs7d8aCbBXv988zHa0yYSrF1L3JtvBjMR\nTruXy9rLBjVV7Im+coYvSr7g3h//hsLbH6VMUKm4Mi5OMLuGiJiQEMrNrUiKMPS1taKCTE0VQAJC\nztDl6ONJtG0bnHce9W1qjh0TORWA1WXtN+JRGRlNqNWBxupEFRV7+tsOGvpQPTlROUx6axKeMB2z\njn6Cq7QNS1QayOXIRowgwu6g2Gbj4imhzMs4xcN3BucG5xgM2L1eDvTp/Eu1tVg0oSRGZdHTkM/V\ni/skRxnCXRmbWb1aJM/x7zwlQPonnxz0XJVpSSRLbXQ7BYjgqajFnZRGWJgYcvHjj4jWrZ+NkKhW\nE65QBJk4d0ghHNiQhdvtC+QXsrp6jOGJhA9PI9OioM58dhevQWtFUmiI02fRHbKPlHQXzd3N5OvF\n2jEUE6EnnngCnnxCQqqqgsxMzss8j8rOSioTQ/F2GEmrHENGzJnHO4K4Xw0yGSb/ZIe48Disci1p\n5eVQUEB2SQmdGkfPYBU8Ph9uSUJdVYUUFcWfn4nkzVtuIsOQwV9/+mu/Y0+bJgY3vP22wLZ6QIRp\nKdPocnbgdCmC8tVuj4c/lJZyaVUe2nNXE6dOpdbaf2wz+JkIVitrDqzh25rdKEqPs60ym0svlfix\n6kcuOvZn3s+1sfTTIk7efpL3lrzH2ISxYp9ITCQyUmBPH3wAnpnTSDgc/B4A7NpFeW4UbZ1K7hvz\ndL+n0vRplDsbCXc5aOv8z03NfZLE49XV3FJayr8aGigcxLWv3ukkQaUi5DQzwpMnwWKByZOhwdzA\nxuKN3DHpDvLzhdfmyJAy5Pn+NSsxEb3LTvsZ5OY9UWaz8WHofD7uFtdl3zy4Jy6MjmbLaZKGn7u6\nmNMHRHh+9/NcO+ZaEnWJjEscx6HGQwO+X4u1hTRjCNrRGYOe0/jE8bwdWyvqLJMJKSGeEEUICdoE\n7HInHrlE9W9kIgiDt3Px1TUzbdIjRK95guWPFWANVcD48USGhNDssGJz25AZDCi7h27WuVyix1fd\nR8oAcOncECSL8j8yWW9wOqkv2U+TNY7Zs4VcaNo0sSYPZa74vw5EeL6ujtywMC7pg6CbTJBEI44k\nDYUtR1FKoVhtg3ddN/mlDK+9JlgIPbjAypVQXu4HEerrobubyFuvxGKBY1UNxKgGT7zCwsSEn/ff\nRwiydu2C1lZyNRoMkSNpsfanzlm9Xmw+HzEDLdp1dXDbbWLSw/nnQ3U1w73eIHPFGoeDutaDnJMw\njFqHkzsn34kMGe8fHWBI7hBxssVJsrmJtnH5kJdHislGk+PsutY9TIQwhYIUtZqys+h2l1itXFZU\nxJKiIi6LjaV48mSujo8Ponfu3AnpuWb0av+i0d7O2I9+5oNrCuCuu7jD9ixvvQVZIRqcPh/Vg7x3\nz2QGSkqIkiRcPt8ZKc7rWlpY4aecJqpUdHk8AcpYWZeDGOR45TaaqwWFMFWtxqeKGdplt080OZ2U\n2GxsO0PR/X3l98zLmhcYBVh+3MHkE+8y8rXbATGG9LB+Ds0bfhLnERrKHYWT+PCOGPY8uJHm2FGM\nqnLgsNWyfcwYtrS3k79/P+81NeE5CzDB7dd3mUo0TOj4nsjGEzzrvkc8ecUVohtxUNDDzjMY/uu+\nCI+XH6XGVEe8aU/viKvaWso1TrKjshgeOwyHzE53HxDh2oQEzo+K4q0+evShoqcb+VsLidcbG2l3\nu/lrejpFrUUUxI8iW6PhlN0uaO0yDUkqJU2lIUhqbz8H5R5t35SIiMC4x4FqybtTUnihpoJ/HXqb\nfWYz37S3E9oRSranEm9OFrKVK/nrnhAOydZQWAgFMsNZmSv2gAiesHoIH8k4jbjHfp+QwHtnkDS0\nuVw09QHiKjoqyI7MJkQRQkxYDC3dvWvdgT6TGYpfepj9Y+N5/MlRpM3KILaqTJgFgZA0lPw2SYMk\nSTw6EAsBoLqa9w01aMvL/2tyBrvbzubSzVw56kpa3G7iT50SruQrVogf0B89vgg9MSkigk2jR9M+\nYwYqSUKqquT12BqUJSXoFYohJ+Fsam3C113GbQWXAzAmYQzFbcWMC9dQ4pQEE6Hbi95pDYAIzoRE\nYizGfiDCjq4uFh8/zhv5+fxuCAr72Ua4QsHi6Gg+bWvr9/j2zk7S1Gq+OO3xnpAkiVcGGesIsKt2\nF8Urb2Du/a8Lc8XTvpseVpnZaQZnO76QYAr3FSOv4GTbSfY1HeP1xkYeSE2Fo0c5FT6G3z2cHvBE\n+G8wESqtDoZF+lluGhXHGoYGqDe0tnJ1XFz/ZoTTCQ8/TMyWLbT7mRaAWBCGDQsU7ADl7WdmIvSV\nMxS3FRMbkcnxxj39wL1FUVHcdgYmCAhvimprBx65mojKSoG4jBkTkDSEKEJQK9S9Hgx+P4SPPxZp\nUE8efToTISQqBo3VRbjNTWj0wL4Yg8UHl35A6Z2l6CPzUFvdeKtqcSekiSdHjSLaZscpSaSp1fyz\n6XIu3LCCf63pv7jKZTJuOM1g0XL0ANbQUAoyes8z02+cnDdxIova/s1778FC1Y/w+uuCzjxU5z4x\nkQRvG91O8d0oGmqRZ4jz7CdpuPpqcSyvV7AR+gIbkoRNHo7tRCqRsqwAG0HV1EKTPIO4iWkkd3kH\nNLQdKFThDcgUOjyE45M1cdK6g5SIFOJU4ho+ExMBhO594aR2nF4lGAyEKEK4bMRlfHzyU8qHJzD1\nWAJxWttZgQgAeo0GU20tdHSQoE3AjIb0Q4fgttvIPniQWo+dGTNEX83u8xEmlyM7epTayDEkJcH8\n+TLeuugt1h9fzw+VP/Q79hNPCJynrk7kSjWmGrIis0iJSMGDhMvbPwf6c2Ul5+j1fP9mC46Y3dw/\n6W8YpeACP1ejoc7pZHv1TpTqKFQnjlCz5FnmfjqOO7+5k4vyLuLqz8uY9ksVifV99uPGRtGxQEyS\neOstCJ+7mBEn2wZMAIo3vsVX8SacH37EBYv7A35p+jRqzXXIfSq6zkIjP1B4JYlbysrY2tHB6PBw\nDlgszDt6lIMDeHP0GLmfHj1TGeRywUK4fuz1RIdFk5cHe/dCvqIccnuZCAZnN+22swMRHq2u5qJw\nL8fkqWxoaQmYKvaNC6Ki+K6jI5DPnu6H0GZtY23hWh6Y/gAAExMnDippONZ0krQOBdHjMwY9J51a\nR0ZkJrV/uBxHUixpkeK1UZooOjQSIW7B3k1Rq8Vc1LMZpbBxIwC3XJRD2rARyGSgSUzl18duhPfe\nI0qpZF3xZp765SnkUQa6ssxD5g09popVp4EIEyYAlVp+qPntrPGTRhuuhqMk56fw8MO9S59erRcT\ncwaJ/1UgQoXdzgt1dbySk9NvE25u9BEvNbO26Vvu3XovKkUYNs/AN5Xb5+Pr9nYmuWP4+We/GcvJ\nk1BWxujR8MADwkCG48dh9GhkMqEDP1TWQJJu6O5Nj6RBCtfChRfCRx+Rq9EQHpEf5IvQo5kJYjZ4\nvYLJcPfdIkFVKmHuXIYXFfWTMzh9PtrdbjpNpyiIySZELqfL6+PlRS/z0A8PiSTrLKPE6GJYWx3W\nGZMgK4uMDhMdAzAnBoqj3d0U+HnaBeHhQUZwfaPW4eDGkhJmFRYyOSKC8ilTuCUpKQjZxH+MX36B\nmBQzET0gwurVNJ0/nVPRwG23EfXrV0yMq+Wbb4b2RahzOMQNfdllyNatE8Z0Q7ARvJLE+tZWrvEn\n5XKZjMw+koYau5O4UDuGkDiqKsXvl6hW41VqaT1LJsKOri6SVKohi263182Omh3MTJ9DkdXKBJ2O\n7Td/gjl7HBETehNJ6+Q5uLf/DIjicOVKuOh8J+Obvma19klSTxhpMDcwMSKCbwsKeH/YMNY2NzPq\nwAE+bm0dktpU5XCQrFbTUCVn2N61yP78INXNoTidknAq+tOfAmyEMVotRrebht8wQnOoqLBZebKu\ngfuifCzOWdjr4F9XR4nWxOjkLEanpmNWWDG73Zg8HsrsdibpdNyfmso/z5J10VNIJCeLPf5sGtfF\nViuPVlezbvhwXB47TZYmsqOyyfVPwZDJZKTGjkcn2SkrlWHwqPt9LzUOB3KZjFS1mvnzBXL8yy/B\n71Og1aJytvBARwSXnzjBH5OTSaqMIb27CfWwkbBsGfHdYP5pCzPOb6X+53DqnM4zelP0eCLUdteD\nNpE4k0icz4+MpNrhYHjagkFBhDt/rWPFL73U2orOCrIiswBIiUjpl9Du75nMIEkY1m/kp6zfM2cO\n3HifAa3ZFtAynptxLsXG4kH9YwaKLe3tuCWJS0+nZLtcSC0t/KHhX6jb2vD4gcP/aXxV9hWTkiYR\nHx5Pq8tF/IkTwhDn3ntFNuhPFvoyEfqGRqGA+nrMWg1b9Ua8J08QewYK+0uVx8nx1AW8eMJCwsiO\nykbvaqRJFkFedB5Gq5cohzkAIpCcTry5A4v/uF8ZjVx+4gQfjRjRD3z/n8byASQN2zs7eTQjgyPd\n3QNOGthpMuGWJOYNoN+u6Kjg0Rcv4eFdCibUeQjx2oKO0bOWl7eXEy45aHYFf3cqhYo7Jt3B3YVb\nmaXXkxcSAiUlvPD9aNb/nIhkNBKvUFDndP7HAGJPNONgQrJI0nIi1bT6XAyQfwOii/qJH0ToF++/\nD8nJhBQWousLKtXXC/f+X38NvLSs4yyYCCG9TISTxpMsGraMcJnE6l2rA695PieHsQOMlj09JHcX\nvzQdw0UI+vJyQdksKAj2RXB0ioVz61ZYtIj163ulDBBsrKiOiiPM5ibc7kUd89tAhNHxo0nQJuCL\n0KOym1A01CJL94MII0cSbxJ5UlpZGV3N5STH7aPioZeD/BGuS0ixaZs9AAAgAElEQVTg07Y2rP4F\n31J0ELs6lHHDe4s1vb/JkzN3LqGHdnNdwRG45hrRQj4TCKPR4FSEobGI8wkz1hKW3x9EkCREuzw+\nHnbuZIpO189c0eh2I3md0JqBytoLImhbOjllzSV7YiRKH7Q0DNLJ7onNm0Veqa5BUmpos3vRtY3l\n1QOvkB2ZTbT/c54NEwHgr9dUUebODBBlrhp1FR+d+IjvEz3Mb3OhdJ09iGAICaFr1iz4/nvWLV2H\nwxNKekcHXHQRMfv24ZYkLvu9m/fe6/VD8Bws5IvKsTz5pGgCxoTFsPaStVy36Trabb1d6QkThEzx\n2WchOkaiuquaDEMG6fp0JJULh7c399nR1cUXRiPXWHKoT1/N/bPu5pz8sTi1ZUFjrUPkcnI0GvZ3\nNqNWxzKioZvkjCtZPW81RbcXcfOEm9EkpsJDDwnGZk/4mQgAs2aJBnSN8xzkHi/uylP93uNo81Fs\nP21l1JznSIqM4nS1SpIuCaPNiFIZimUI5vVg4fH5+H1JCafsdrYWFHBnSgrvDBvGH1NS+GAAv5Dq\nQfwQeqQMHfYO1hau5d5p9wJCL3/kCGR5+4AIiYlEOsx02M+cZB3v7ubHzk4eS08luuIf3H3qFPst\nFibqdCLR3bsXgJTQUNJCQ9njv2/2m80MDwsjwl/lvrj3Ra4ceWVgD52YNJGDTQODCN+X7Cbb4kGR\nE+xx0jcmJU1i29Q4tr1wJ2l6cU/LZXLMYSpUTi8yIMbrFaarBwf3YADERfDYY/DII9RZ6pgzXhwv\nUZsYyIeiQkKo7G7jaMtR5NEGCu9U8ucBvDp6YjAQQaGAXJmWLcW/DUQ4fhxKuyycawojenR/GeSZ\nxjz+rwERJEnizvJyHkxLI+M0GmR7qRFbiJ6fmndzrOUYoRodDgZOzHZ0dZGr0bDlXTUrVoBO7YKl\nS+H55wGx2OTlAUVFwnEJkSd2eBrIiB4aRJg0SfxwO3ciFux168jRaFCGpwclx7WDSRmeflqsiitX\n9j62cCHDfvihHxOhzuEgWiGRETaM3b/KSVerqXE4mJw8mYU5C3li5xNDnmvfqDI7GV9bC+fOgexs\nctuMWDjzTd7icuGUpIBUYLRWy7EBzBUlSWJVZSXjDh4kXqWibPJkHkxLCzbV8vnEDxAVhfPzrzhy\nBHQxFnQqncjw3n2X+rt/j8VpAYMBbriBp2JeYM0avy/CIDTueqeTVBAGaB9+SJpaPaRm98fOTpLV\naob1EbFnhYYGJA3NkoNUVQvTzXoqK8QmpJDJCPXZqLCenSfADpOJu1JSKLfbB0UU9zXsIzsymwZJ\nQ15YGNUlCqYcfI3EJ+/s97rYZbOJO7Ub3G6eflpMC7km6UfU40aS98cFxDR30G7sbbPNMhj4eexY\nXsnN5R91dYw7eJDNRuOA/gzrWloYHR5ObY2E4fBPKBfMIzUV5r23kHePvCvg9B9+gMpK5DIZ5xoM\n/xVJgyRJLD7wAymm3Tw1/VYmJ09mf6MAEXw1NZwymBifk0pOtgIbCsw+D7+aTEzS6ZB8bibodORq\nNHwygG779KitFQ02tVpMaG0+Qx3r8vlYUVzMk5mZ5IWFUWwsJi86D6VcKUAE/30aZRiO3NlGaSkk\nhqip7wMi7LNYmOIfUySTiXGPfZrZ/SK09j0UjV9SPmUKtyYn01gvI62zC8PoSaBUonjgQZ4+GEnY\njHf5erOcaRER7DqDpKGHifBrZwsKs5m2RnEvKuVyromPp5B46s31NFqC2Ry7mrrZ7ewMXC89TATo\nDyLYvV5KbTbGhIdj3LkVrFbe3L6KZ58ViV2rLQG3JOH0+VApVCzMWciW0i1B7zdQ9LAQHh2IhVBf\nT3dkJG4lmCIjiZDJ/iuShvVF61k+ejkmj4dQuZzQkhKRHGVlwdy5fqFwLxNhQL+TU6co06kpjgXv\niRNDjvWzeDwcdMj4Y2ZBv8fHJ46nzViISxZKtD6LTruXSLspACLExiQR4nJhsVhY39LCH0pL+Wr0\naM47C+O13xILoqI4abUGjGo9Ph87urq4IDqa86OigiimIOQFA4117LR3svS9RXzypYqQ19agkZS4\nO6qD5Aw9rLLS9lJilEKnOVDcMP5m9svTuSlWByUleJNTWfdLLbqr78IZlcgip5PNRiPVLZ6AnOFM\nTASnx8mSj5aw5oAwTLPbwaZzMDVNBatWkaxWET/SefrAjkD81NVFilpNbt/iyuOBZ57B9Ld/4FWq\niZPJekGlQr+/0Z49NDidPFNbS1n7qUHHO/aEVqUNeCIUtxUTronn0pz5vLzvZY42D3Jyp0VtLazb\n/QN7q7Zy7cS7cUqg7eming4ihPrNFffvh6QkyuypNDbCnDm9xzvdWFEdHUe43UukU/abPBH6hS4C\ntdNMmLGW0LxeECGpsxu9XMLz1qu8N9rLO/fN4s/u+1h58xeUl/f+ebJazfSICD7zs2Zcx47hkysY\nO6r32tQrFITL5aRFRsKSJTB7Ntx6q7jfzyK6wpKIMTnwST4iLbU4cuR02DsYNgw0GoG5AAFJw+kT\nGk6a25E520iJjsbdIkAESZKIMlo51jySESNlWOINdFcUD3wCIDa0m2+GTZtwcgrkYrxphnM6X5V9\nRXZkdoARezZMBIBMqnAmZwWmWs5Mm0m7rZ2PY+qY3V0ppB5nCyIolXTNmAHffUdKRAq1djvpmZmQ\nlITM4yFbqST/XIcoZKq9hCsU1H11FGvuWKZP7z3O/Oz5XDnySu745o5+x3/8cTGSUxstcjNDqIF0\nQzq+ECcun1ijbV4vN5aU8HpeHm++3YAv+2vumHw7w2LzILqcispgEDovNIRWmRazV0LereL+C+9k\nYc5C5LI+ZdMddwh683ffify2tRX8TDCZTKRP772r5lBOGB1be5l4HfYOlr9/CWOMCvZ1rgjIgvqG\nQq4gUZuIRgFmX/A6OJRHq9ufwzS7XHw9ejTaPr/7Qp2Sj1tbg5iqNU6nmMywerVgSM2YQffci1lV\n/ntmfHE/R++6kheq80nZthdOnSI/H+QeJ7GeJgE+AiQlEWnrwuQ88378SHU1D6alMSI6k7a2fbyd\nl8M5BoMwCfzLXwQS51+0+4567OuH0GHv4I1Db7ByZm89NTFpcCbCLyW7iHN1iw7LEDEpaRL7Ww5R\nFO0lXd9bVFu1YaicwjdCVlwsfFYOHRviSAgWQmgovoWLMMtqWXKuWMsStAk0dQumVKRSSZPdyvGW\n49jiYrHHyfnCaOTEIGb2DocY5FBltwfJBuekajnYdXYgQnOzsHw6f6EEEXB9g7P/wo6fieD8P8BE\n+KytjTqHg3sH+HEtpY2YwhL5tfZXHB4HKp0Kp2Lgi3ST0cjFkTG89ZZQDPDaa+JuO3SaRuY0EAFd\nA8OShr6wZLI+Botz50JdHbldXXhDE4OZCP5Rbf1izx549VUxQ6dvgb1wIRlffIHV6w0UvzVOJzrJ\nhqt+JP/8J/3GPD419ynWFq6lrP0M6LQ/mq0W8htb0E89B7KyyGluxK44s3PqcT8LoSchLAgPH3BC\nw5b2djYbjRRNmsRTWVkDO4I3NcGCBQIxf/dduPVWpg/rwO41Y5BpRFvj3ntRp2X2mhfecw/DDrxP\n5YF2Mi2D+yLUOZ2k1NSIhe/IEVK93iF9Eda1tARYCD2RpdFQabcjSRKdKieXFn7Apy+U8E1JJtIf\n74KWFnSSg2rb2U2o2NnVxbzISGbq9fw0yHlvq9jG/Kze0Y4f3HWAbF0LYcsW93vd1MVRnJKyad5y\ngA0b/PjT55/D0qVcdJmaopBsdMfL+/2NTCZjflQU+8aP5++Zmfy1qoqphw/zfUdHoPhZXVPDx62t\nPJuYR4azFFmoCjIzycxxcaB1Fyu3r6TS0wY33QQvCg3y3P/SqMcny49Q0d3Gd+f8HrlMzuTkyRxo\nEOZDvtpqGpTJZGeKOdcWtw6rTM6Ori5GqbzEPhfL0eajPJCaynN1dWc0r6ypEUUEnF0x8Wh1NSlq\nNTf5OwpFrUWMihNrRV5YWMDAMlSbhstUxe17fkeWVk1Dn129R8rQE9deCz/9FPzeFqeF1pZdSE1f\nYXEIqUxFUyu5HRA2wj+H9vrrGVFro6vhFbZ+72WGbnBJg1eS+KKtjfoGieRkONxtQ2uyUV/lDkza\nuD4hgXUtrczNGnjUY6vWigtfwFiqsquS7KhsPD5fPxChsLubEWFhhCoU1L/0GJ/ljmXl/ToSE0Ue\n1azOQO/xBSQNy4Yv48PjHw795fvjS6MRCQY2hquupk4XDj45NeEadD7foJMKzjY67Z38WPUjlw67\nVEgZQkLEhdMzxueBB8Q94HYTGx6LWqGmwTKAueepU5yIcGF2jcPl8hArSYMyEd5vqATTMa4duaTf\n4xMSJ7Cj5idk1nLqfGF0OnxE2ToDIEJqZDxOj49NJhMPVlSwfcyYwEis/2ao5HKWxsbykR+oO2Cx\nkBEaSpxKxaUxMXzc1MZ99/WyOescDn7o7BRjWvuEy+ti2SfLeGVnOFGTZsOKFXTlpSJVnQiSM9Q5\nnaSqVKSufp3kEJUwBR4gfuj2kqCQ2F/y74CUQXP5bZjz3sAYnkJGQwMztQasM5uJjhZyhqGYCC6v\ni8s/vZyy9jI+K/4MgJISkCU6yG2qhdWrSbJaMWQPPqFhQ2srV58+0vLTTyExkUe2z6JIUUCcw9Hr\ni1BYCPPmcaKqiumHD/N2YyO1sReToc8Y/ETp9URweBzUmmpRqPSkaaN4aNZDPLv72SH/FgQWMHrp\n1/zh26u5PHcBIeFp6GQy5Ckp/ONFOc78gn6jTQNMBP9Uhg0bhNKtbwpzupxBGRmNwSlD7yAwLuy3\nhhShR2kzE2OrRTuiF0RIbTMRI/Mg2/ARrmuu5uk7vqDq7mtZ47iC2ff+g87O3v3g2oQEATRLEup9\nx5G5PYwp6M19tEolVVOnopTLBdJ75ZXw8MNnfY42fRJpFjU2p414Vy1/b3+SvFfyeOfI2zz7nI+7\n7/YXe1ddBRs3Ml6loshqxelfi490NaC0W7n8MhmdlQJEMDvNpJgkTnXnk5YGzqR43NUVg3xJktif\nb7wRYmMJaSwEl48uuYvJWuGQnxWZRYRCgVImE0yE4mIBjt5/v2hBDhSVleSen8mrrwq/AblMzpUj\nr6QldRTJrlrBojlbOYNCgWniRPjuO5weD0aZjKRx40RCPXo0WXY7dV47V10FH3/pIxQ5quJClj4+\nNuhYj895nC1lW3D0YSKPGiUwFH16Den6dGQyGRn6DDwqO24/iPCXqiomR0RwjjKGL43PceO4mzGE\nGohQR6DyRXCgJBhMN3i7iI6bisvno9maxOTJA3w4lUpUYffeKyoyna7fKNDrroNNm6BsRArun3ul\nGB8VfcTVtiyUY8ezZbtmQBABhKQh19VBUwxB0ozZs/tZVgXC6fNxxcmTWL1eNo8a1a+Z55N8LH5n\nDPFKwSrrGwE5w5dfCobF6tVsTboBz5SZeOIiKarYzcWWZGHwNG0a+uO7mBJdgTE8vZf7nphItKUd\nk2toEOGQxcI+s5nbkpJQKVSkRKQwTG7i24ICaGtD+vJLbNevgOuvB5+vH4jwUx8Q4eV9L3NJ/iVk\nGDICx86OysbkMNFq7d9gWr+xE01HDfKkpKFlSsCk5EkcaDxAjamGdEMviOCMiEDtcJAaGop133Fc\nhGD8cQgQwecTKNejj3LwhBmQM2aYWA8Tdb11o+Q2IwvRYbQZOZQQR3ydjTsj03iwYuD7fjAmAsDV\nk8Np0XYPyrh1OODjj4WH7vDhohT+18dO8HYz7HBlEID6f4KJYPZ4uOfUKdbk5QVT3wF7RSNdBh0x\nYTFMTZmKJ8KFSxV8HJ8kscloRHM4huHDYURMKzz1FB3r3kIqLu5v43saiCA3NJCXcGYzqmuuEfeY\nyaqE5cvJ3bYNmzKSJktTv9cFjQDp6hJo9BtviBahP94/+j4dURrkiYlcIkl87kfNaxwOFC4jw3eF\nov35q34gQoI2gZUzVnLP1nvOeL4A3Z52WlXtxEYkgMGAwWZHUpwZkT5mtVKg1fLDD6L7PXoAOYPH\n5+PPlZU8m51N4mBGI19/LYR2M2bAzz/DNddQmLOMp+13Y3aYmP7k+6LqWLUKnUonmAgAycnIlizh\n5WGv89PaMLq93gHHN9Y7naQeOyZcQJYsIa2kZNAxj1avl83t7Vx1GuW0h4lg8niQfDChaAdrHprP\n7wxf4SythjffJFLmPqvJD20uFw1OJ2O12iGL7s2lm7ko/yL2mc0kduoYt+c1NPfc1j87E18DB7Vz\n2PnHT7nlZonYSI+4CJcuJTUVyiInklA08LQCmUzGxTExHJk4kXtTU7mzvJxzCwu599Qp3m1u5qex\nY3E3q1mi/wnZnDkgk2HIP0a0LJtVM1dx3abr8N5xuwC+2ts5LzKSH7u6zli4DxW1diuP1TayMkZG\nfrQwThsZN5JaUy0mcxvy9g7q7bmkpYnJWk3WJNwyOT90dlJa+QnDY4dz4+YbmWeIwCtJQZth0PvV\nnj2I8EtXF+81N/N2fn4APOsLIvTIGQC8qmhCSwtZZl9HrszWn4lwGoig1Qog4fXX+7/f4abDFMQX\nBEZGAtR1nCLNJIkOOEBoKKo/3cc9u5wkztxKeKWenYMwEX7u6mLpiRO0jG8mMRHKXTISrAry19wt\ngDpJYkR4OClqNanpS4IkDfXdLjwKF4qjdj6tFt9rRUcFcRFZpO7dS7guKwAi9EgZJKuVjK0H+NS3\nirvv7j2WJzWDsG5XAETITJnHcUV6r2xlkPD1YSEMaHRbXU2pRkZY61zKwnxEuFz/YybCxuKNzM+a\njz5UT4vLRZwkiaK9Z4OeOFEACp98AgT7IvRE56ESSmOtXFVwBcXaCOLM5kEnNLxWU8KUEEu/4gsE\niLC5dDMxnnYOWixY7E70NjP4mQYpkfFItm6Ubg87x41j1Okmfv/F6DulYXtnZ0CmcEF0NDs7Tby7\nwcOcOaIB96/GRq6Jj0fXJ0GTJInbv76dmaV2Zh0yirFoMhkhY8YTeurkgJ4IKUYjs9b/SoHZMyAT\nQZIknq2r45GsPNYcXIP78GE2dksY4s0kh4yiXBYOtbUsIwUua0BCGvK+9/g8rNi4AplMxq4bdrGv\nfh9Wl5V9J9zIFRB5+DAASTU1qJOc+P/bL5w+H5uMRq7sawDq88FTT+H780N8+inssxcQ19XV+5kL\nC9l5002cd8cdPJmQwIcZOpSRE3i5cWiqlDZEeCKUt5eTFZmF2etDr1CwfPRyvi77OsBSGCi++grO\nW/k6XPwHwjZvZnxMDpV2OxE+H87EDO6/H/Y0pgvJod88MzI0UngBffst0qLFQVIGEHKGvsaK6PUY\nnDIiHJJgFf4HIdNH4O0wka3q9RogMRFDt5XEpgZOGFxceclfAJj4xDuMyJ/GPeYXyXvsQppMIo+a\nqdez12xGOnaMjrBQfG6ph20eiFiVP5kcP16wjQbIQQcLZ3QSSZYQGssb8SHn1+6jfHr5p7xz5B2e\nbp1B2vA2XnoJgWKNHEn49u3kajQU+vOoE2YjCouby+N3Im9Po6S1kkZzAykm0A5PFX5eaWnI6wbx\nRHjnHUE7e+QRGD8efckJsMmQgLFpMcxKm8Xw2OHIZDJeyskhQaUSe/n06aIAXrxYfO5//lOgBT1R\nVYVhbCZXXQXPPCMeumvKXUz3PE1DylRhsHn6OKJBwqBU0hUdDVot9UePktTVhWLmTPHk6NFkt7VR\nabdz/fWw6Vsv3S0SkQozwxdlBB0rXBVOXnRe0JSyf/0LcidVB4rJdEM6bnU3LuBXk4mPWlt5OSeH\nV99rhlEb+Mt5fxIAzOOPM8qSzsHq4MlBvu4KPLoR6BxeXCnZg9edF14opC+PPsrpF1dsrMCPdoUV\noN3bu3DsrtvN4mYdtgmzKC0V5u8DRbohHXWkh6hWF+v39d7XJ08K9sWzz/YjDeHwellaVIQM2Dhq\nlDCo7RNlpXu4eVsHY9wNfHgai7Pa4SA9JEQccMkSmDWLp4uXkPTXG3nzPD0/3bKAyA8+FZ319eth\n6VJu1fyb9r4eLgkJGCztdHuG3o//WlXFX9LTA8avOVE5gTGPvP02x2fkMD5zG16XE158kUk6HUa3\nm2Krlf1mMzP1esxOM6/uf5VVM1f1O7ZcJmdC0oR+5oqVlXDbU3u5zJ6JcvjQcjGAMfFjKG8vp9hY\nHJAzAHgNUagdNlLVapq3HuNbFsHxIUCEL74Q1f7ixXy5oxY9aQGPvr5yhk5LDbrwZIbHDmeXQUNG\nTSfLlMmU2mxs7wj2YXM6QRUq9fexKCrCmZnGVFpB52H7/t69VZLEYIBbbhH1xNtvi+uyvh7WroWu\nhCNE2E0oDJG9ybI/9KH/BzwR/lZVxYKoKGYNstl46xppi/YxO302Y+LHYA7rwhkafOqHLBZ0SiWb\nXg7n9tuBhx/GuGwRY/ZdT6nBQ92ub/wH9Io2w4gRgAARVNENpEScGUSIjYV58wSSw5Il5GzZQpcs\nPDDmUZIEmH2y3UlaT1EtSYIit3ixGG7rj/XH13Pdpuv47KQYuHzFkSN80gdEsHRWc115KStMr2Fw\nhlLTp0i5a8pdnOo4xTfl3wx4nu1uN6/U1zPt8GHM4R4aNR0o5WIVDAszICmHGD3pj2Pd3YwJD+eR\nR4QvUIpCg9GvTe+Jf7e0EBcSwuKoqOADOBzC++H220Xy/eijAQTwybCnGNaxh5Uv7ieyrFbMEpHL\n0al1/ccoPvAA80pf5eN37czU6YPYCGa/+7n+0CEYNw5WrCBtx45BmQhfGo1Mi4ggXtUfhcr2MxHq\nnE6UxhCSaqrJueQG3PmjqDrvRvj1V2KVYhzTmWKnycR0vR6FTMbcQcwIq7uqabA0MC1lGnvNZg68\n7GWJtAnVbTcOeMzSeXcwovkHHj22VLAQ0tICFDLN9HMZWWMacmqHXCbjyrg4TkyaxPUJCdQ6HPw0\ndixJajW1tTCHnwI0Jm/iPgzWyfxp6p9QyBS8UPORcNFas4Y8jQafJAU5TJ9tSJLEgn1bSbUe4YnJ\nvw88rpQrGZswlhNHv8cSqSPUnY1KJfLPds8wNC4HRdZujpz4gD9+cDmRkp4X9rzA/X42wlDRF0QY\nymDN5PHwu+Ji3srPJ67n+vjhB85/YgNzC81gt/cDEcxoxGg5ILW+LuCJ4Pb5KOzuFtq+PnHnnSLn\n63s5HGg8wKSkSRTE9YIIIZ376YjU9OtocNttzC12kJz7D8q36Ci2Wgfsvn/a2soVugR8f6ikwmWl\nkQhGeLXkHvlUsLH+/W9AsBEqVDlsr9zez5DtmxIrGlMdCb41bG70MyM6Kzjsi6LZ5aJelUm9RSS0\nPZMZyt98gT0JKh57fCl9b6vwERmEmXp9ET47XIgUcwVP/zp0t3ST0YhCJuPi6EFo0NXVFIdbuSht\nBWU6Czq7HfP/EET4svRLLhtxGSBkXPE2W6/OsyceeEBkbZIkfBFagrt4TfuO0KRP4qrZEymKhLBa\nY7AjPwJoLHOH8EDejKDnxiaMxe62kx3i5oDFgt3ejdKrDBQ3Cdp44muOUrj/OFmDTEAoLhYYud/P\n6T+OcwwGWlwuSqzWfiCCXqlEUxXBH97q4IILYNo5Xt6ob+LO0wwVn9v9HOWn9vHo+7XI1q4F/z4R\nPXUOKdX1NDn7ryN1TiepJ04AMK6iZUAmwrcdHciAmzPHUhBfQPm2b9g7bjv/vnwNExMnUySXoLaW\n6CY9Go+SNZVHCDG00tQU7Ifi9Xm5ftP1WJwWPrnsE6I0UUxImsDOmp3sqXIQ7Q5FdvAgxMaSVFKC\nFO3im2+CvbS+bW+nIDyclL5doTVrQKNhl3YhUVFwxFNAVENzgJniO3qUZQkJrNu8mWtOnaKp6xQz\nTFt4uaGBjwbQLPdEDxPhZNtJhscOp8vjwaBUEhcex9SUqWwpG1gy9OZbXq58915iLniFw3f+irZz\nKp72ECrsdvQuF3Vy0XH7eYdMSBr8a1ukJhJHXTVUVHBEMx23W8iV+sbpTAT0eqKtPgECDjXmeoiQ\nR+oJ95lJp88CLpOR19nAVR9+xP75I8iOyg48HvbBRzxQ4mZGVTS5L4zjx6ofSVKr0SoU7P7qYzZn\nKQjxKhkIl/xPQ0pIJNmkpPnQKZrD4kjSJTEncw6/3vArM1JnYFl4Bc887xZTvfpIGvb7JQ2VNgs0\nK5jyxIX8Xl7PKWMlrXUluBQKMkeL71OVmUNo4wBGppWVsGqV8G9QqWD8eOLK6pDbVSjsSnKzZWyz\nLmWxS/yudyQnowCRvN51Fzz1lJhy8+yzQtedmyvy040boawMMjP5y1/EntXWJgrakJqFdBXMFhLH\n3yJn8Hhg0SJqtm0jvakJRo8WT44eTXZVFRUOB+PHg1rvw1pjQzZmDIP9UFOSp7Cvfl/Q4z1+CCDG\nIzpDTNgUcm4oKeGVnByiQ1S8tPclFqcuJ14bLxD9Rx5hRaWM4pZgVm9H+2GMcgPhnXZ0Y3OCng+E\nTIx85N13g0AEEHL4rdUTCOmwCFMmBIiQf7KVfapZzJkDqgGaogBpEWm0hnqZaOxg7b5eGcy6daIp\n8dxzorHpdArJxkVFRUQolXw8YgSqvmCYJMEHH5A2czH374bhv3zGFqMx4BcCouZIb2gQSVJEBFVV\nIleaNsPN87ufZ+WMPhLs+fNh3Toub/onlvg++6RKhcYDTufgdPpfTSZOWq3c2Oe7yon0gwgeD6xZ\nw5vTVDjxsPqm4bB6NfLjx1kcHc3fqqsZER5OhFLJa/tfY0HOggHlX33NFb1eYYo/9fLd3LG/S9BW\nzhBqpZoRsSPYXbe7n5xBER1LmMNKilqN5/AxdqUuJ7Lp5MBGWz0shEceAZmMn4/Ukt4HkOgrZ2ju\nLEcVGs2ouFHsjwhjWE0zzm45q7OyuL+iImjCk9MJ8lgXBqVSME0qK/EtXEC5rY6yN54k0RbO+n3d\n1NQI89H8fNEIzsgQBLjvvxeK/B4c8Nu6/eRaHHDeeUEf40PMtRoAACAASURBVH89E+GwxcKG1lae\n6em6DRCyliZqDSZmp8+mIL6AGmULLrUSk7n/F7vJaGSGL4aKCrgk7QiuLz5jatI3PDf/OWQTJ/Hq\nv24Q3aOKCtH59ndwZs8GXXJDwJjjTHHDDWJhZfJkIgoL0SBRbRdZxXffiXr5aKNwmQbgvffgxImA\nLwPAsZZj3P3d3dw37T6+r/weFi1i7kcfUWqzUedwUONwYGw/wbmOUqb7duGoUAaYCCDMpV5c8CL3\nbL0Hl7d/kuqVJM4/epRfTCb+kpLOzhV3UZvTu8FHxiThVWvxeIemAB+zWvFVaGlqEk3RwiMyRvaZ\nn2vzenmkqopnsrODO4bFxcI4srFRXLWzZgWecrvh5wPheN99j9RGKzX/fjlwNfdjIgAMH45y5jTu\nj1mLrjJY0tDj5i07ckSACOeeS1plJXUDoHcQLGVoqJd4cNz3RDvUVDgcVNudGFraOZQq5/yCJWRl\nwXHddNizh0SlnNazqFV2dHVxjh8QK9Bq6fB4gjwatpRu4cK8C2n3eGlzuJn8zXqUyy4Rc4oGiIvv\nyabwzQOoxgwXycjSpYHnCm6YyaR6GW3Wwceu9YRSLuf3iYl8NmoUyf4itbZGYqzp5wCI0BW+H0XT\nFOQyOe8teY9ndz9L2fUXw6uvInM6xajHs5gQMFA8W36Qcls322ZfG3TNTE6eTOWxHTRFaIhV9q4H\nPl0B4TYbBncLT5RM5rKdD/PIwxL/3PksExQmTlitHB3E8FOSzp6J8MfychZHR3NBT/FaXg5XX82x\nsG5GffIzJCYSv307Dp+PTrebBpebc0s6aUgeSXJxcYCJcMxqJUujCRj/9ER2tgAY+/owBUAEPxPB\n54NY21FMaaeZsxkMKG68icv37mbL9nom6HQBo6Ge8Ph8bDQaudqdTuq2TC4/eRKbQsulzU00h6YL\nXuUDD8CpU1wVF8fPZhupUSPYW783cIwfaixMP3WYFz7bxQl5B822DpxeF+vbLdybkkKhVx9gIvRM\nZrC8/Abf5VzIooX9t5P4KenoOswBJsIOoxGnTMHP7e2UGoM7P3AWLATAW1lJWUw7jy9fQmV0N+EW\ny/9IzuDxedhZs5PzMsUG2uJyEd/VFQwiLFokEoPvvxdMhLZgJoKq9hTyrFGMSyqgNM1E9K7KfmPm\neuKVqiJCTIe5IKcPdfCbb+CvfyXcbGdYzDAmaLUctFhwOq2EyHoBpXhtPA1RbnyVA4NnFotYHi66\nSPzct9xCkHHY2YbCDz6+1dTEIYtFAP3vvEP9KQfO72M5kNiI57pKvC8UYt6vY+3fw+hZGjYWb+SV\nfS/z7S8ZyC+7XKDv/lCOGce0Bht1tt5rWJIk6pxOkvfsYWu+ghH7jw3IRHimtpYH09KQyWTcG7aU\nxIpSlPkXMjV1CvNGTKQ43IK3qpa6Whnjq1J4uKyQP267Fe3CNuYdOsZ3flqsT/Jxy1e30GhpZOOV\nG1ErxXd8ftb5bKvYRlGbk1SVWhRYN9xA0sGDdMqdzJsnVIl9I0jKsG+fqB7Wr+fjT2RcdRXICkYT\nXVEjQCWTiWMaDTFqNfPj4mDPHso7yikwJPLV6NHcderUoPK9Hk+EYmMxI2JGBEAEgOWjl7OhaEO/\n10sSPPSolXv2LqPg/EKO3LGb7KgszjkHaouUVDoc6G02jlkyuPBC2LGDfr4IkaGRRO7YB/PmseGz\nEK6+Ori+s7r6Gyui06HyglUz9IjJoUJmiCCSTuLc9f00zFmSmd9/s5VRtz/W/w+SkpC9+iqfn9hL\n0o+vs2zd73joh4dIlDrZevIIrXnXEsF/V/YjT0kiwSzDfLKKlqhQpiQLdEUuk/PMvGeI0mnIuvU+\nHngAMSf8u++YolYHfBFq7S6SK53Iuy0scR6g1VFPV/lxWnThjBwp3kOXMxJDq6k/+8/rFVXkqlX0\nvNA7dgzZ1SZUjlC8JiVZGT5Uj/4d+d8e6f27HhrN+PHiX4VC3JcffCD0PkuWCPOeHTsgL4+kJHHa\nPQy6mhpELtfdfdYgwmitlg9bW+leuJCavXtJ73lfEHKG48cpsdmQyeCSK71kasxopgVLGXpiSvIU\n9jUEgwg1XTWBgi/DkIFN1UlnmIoCrZbL4uL45scuOrPe4oXL7heA+qOPwuOPc06DhZruYBChvGEH\nKpkMXbuZzHnZQ3/IggJhgJCeHvRUfDwsOTeXXfEG+OUXmrub6bZ2EnakiPW1MwaVMoAAburVThZY\nG9lvMeP2qxI//FCAB9ddJ/KKlY95WHTsGMkqFeuGD+/P6PZ6Rdv5hRd4cdUcfrpoFEk7fmG6Xs+X\nfraRV5KodzpJKyz0W/yLXtWSJfB56cdkRmYyJeU05PD886lZ+xMJf72p38MqpQavZ/AN569VVfwt\nIwO1XC4obPPns/CoVYAImzcjpaXygaKIb1d8y2vGbyhfdTOsWMFFfn+Tcw0GrC4rL+17ib/M+suA\n7zExaSKHmgQTYft2sV7lW74hutsnGmJnEZOSJuGTfP2YCKHxCWjt3aSq1UQ3HWfa/TNoJV7UlKfH\npk3CnPyCC9i2DYpqaxmb1XusvnKG2vYiJKWO0XGjKdLqGVtXx9atsCw2ljCFgnWngcpOJ0jxfj+E\npiaYP5+Sm5eyaqES6fPPmGjQsuFANxMmiBLsgw9ESbZqFUEGngC7W8sZ3tI1oBfM/2pPBK8kcWtZ\nGauzsogZDIoDVMYGToY3MCttFmMSxnBQqiXU6aKisX9F94XRSOdXMdx8k0TX7ctZNdvNW7/7lKtG\nXUX+guXc5BvLvPfn0bhnW0DKAIDcQ5fLSIL27EZjLVggGGRF5WqYPJlsh41al+gC/+Mfwsm03u0Q\nTISyMnjwQdiwQTjtAF2OLpZ9soyXFrzEPVPv4ceqH/FOm0rIyZMs0Wr5rK2NU7ZuolobCFP6sMRk\nIv1c3Q9EAFicu5jcqFxe3tffsW1tUxNhCgUfjxiBb4OZJJ8R66heN9KInEwUXh91QxSdTbt2UdLe\njv2u91l5v5c5c4S7fIFWy5qGBl5vaOCP5eVMjYjoP9dVkoST+ezZovX6yScBGm5PHDkiELGIRTOZ\n++dENFm99KJwVThWt7X/hrlyJTd0PE/R+7ogc8V6p5OUkBA4eZIPpKM02lpImzqV2gHo3i0uF3vM\n5oCDucXkY9e4O3m28Hy6X9tJtcNBkdFBjrmIrpkTUSlUZGVBsTEWEhLI77DQJZ3Z3XhnVxez9XqW\nL4eSYhlzBmAjfFn6JRfnXcw+sxl1lY67FWtQ3HXHIEcUSpBrblSL7sGxY6KT4I/sBTnonDJ2fXsG\ng5dBwnn4BF6NLlBpV7v3YS4RAsAMQwbPzHuGK04+im/CeHj/fc77D30R6u3dPFzbxKpYBTmRwZvt\nbHUe05//mJ8y9aTpekEEXcJktHYb1qadLP3sEJtu3UqIOpINbyZx16Yb+WNyMv8YhI3Q3i4a+j2k\ngMFAhI9bW9lvNvN8jwbeYoElS7D9bRWPzvai3rELXnwR2dq15Go0HLdaMXs8zD3RydHl55Fy4ECA\nibDPbGbKIM7oTz8tNrXt28X/DzQcYGLCeMbEjORYyzFaW2G4ohRXdlrQ34bc9wC/Oy6hynyJfKc+\nyBfh564u0kNDkZo0jKlLJE+jQW6tYnbJfraGLxNr3t/+BsuXE4kwzkvKvoZvy3slDQesdSw8VsHF\nxSYUXfVsbCgnMfE8bB4fX16cSY1TTrWtmy63m0aXi7CDtaS2NrLsqb8HnW/muRlEdXXSbBXjU4/q\ndNy/cSMFict5bvcAYk5gY1sbarmcCwdjIQCmkyXUhcaSl66nWZ1OqLH9f8REONx0mDR9GnHhArhp\ncbuJb20NBhFkMoEAPfcco+ODmQgOm48kcwu5s6cQFx5HdZKaMV//yC6TCcdp57e2sYaFOmWAHcYX\nXwh0urERhg3jxb0GFkbm45YkWkMdqBW93dz48HjK42xoN7wpgNMFC0RBcf/9SM8+xwfz/s0t6d/x\n9B8qOHJEXMpX/D/m3js8qvKL/v1MMpNMkknvvZMGISGQ0Am919CLdBUVKaKgogKKYgMUC71Jl947\noUoLLRDSE9J772Xm/vGmJyD4+957f+t55hEnZ2bOOXPmPXuvvfbaY//z6WGCmRm/JifTXlcXnZgY\nmDWLe99eYISJCTpSNdQkErZ0dCJsrBeZmcK4eN7393j35Ltcl72DdmSsuPAbonVrvGMzG5lO1n6H\nsivn2TvABrt790lpcs/7Jz+f6MIyEneaMt8nGN/RX/Jt54Gsnf8LAB3t/Ei2T6XoeQIvXkBHpRb5\navqc1BtF6cRn+GWrMz0igt+Skph7ei7hWeEcn3AcbVl9QtTPuR9no88TllOGt4mGWG9nz8by2jVS\nysuxHPMj39z8gg9PLuJg2EEKKis5m5PD6NpWhqwsccI3bqTKwYWDBwV5aNHTA6vEWDLKyuDxY4L7\n9yfQ0FCQ7bdvE5UdRSvjVngrFOz19GTss2eEtcD+6Ei1MXgc3UyJAGKUanB8sDBCRBT2Jr2Tyi/5\nPRja15Crs89iqCXuxz16QNR9GaVKJXqFhVyLt+err+DePaj0qPdFMJQbYnPjCcoBg9i3r3krAzQ3\nVkRNjRJNdUq0Xx7X/RukRvq4EkWZ3KAudgLIae3Mmfb69Gw7vPmLxoxBvVMAd+3OId3ykEvPHpIQ\neYRMc0/23ZuNqe5/JzVagtzJCot8FRUxL0gxqaojEUAY4+0J2kO+yTnOZWzl6jMT6NKFgDt3uFND\nLGZUqdMzVSRS7VPPIK8yJznsNsmaRnUkgpazG7b5CF+KWvz4Y/30pBqkulrgmwryahkUSXHIfSj8\nKG7eFBkECBXCuHEtV/l1dWH6dNFympdX5wfz0UeCRCgpEcIFg37+onT+miTCW+bm+CkUTLCyItbc\nHPuG8WLr1nQ6d46Migo2pKTQtbcSB1ku+LyCRLBpmUSIz69XItjo2VBGBm1fZPB7zTr+2ZHf8VMM\nwVHNUPw+//gDZs/GMzqe7KrGpHZxRTHxubHYo4NFYQ4mAf9CIoBgFmudKJtg7mRnLlpB8t5r3I65\nxicJolfzyBXDV5IIdvp2vJAW0TMlBjwKuHhRxOH6+mISq0QCf65Xsd4+lIiL2vQKcaeyvMl3+8kn\nIlm/c4d92jG4jn6H1k/TGWtixMaUFMqqq0ktL8dIJkN+/34jEmHkKCWrbqxiSZclLe6fy5ROOA3x\nbPSclqYW1ZS0uP3l3FwSy8uFb05pqVC+2NnRc+N5hn17GFavJm7SYKx1rXE3cef3Qb8zRPY31S7O\n9F27FplExNMbQjbQ3b47nqY1nx0XJzT6EybA8eONzBW3bYOp06vod/gxLFjQrF34Zehg3QFDuSG6\nmvWxnJ6tDUFnTtA5S4V6VQVD37UmVM2bvGtNYu/aiQzLlhEeIWHKFBg6OQE38/q4zlzHnPSidJQq\nJZHpDyiXaOBh2poEhTGjpbFs3w4rV0r4ycmZpXFxdSPoQYi8leY1fggzZ8Jbb7Gzsw5txs3DIjmf\nDopUAmcVkZwsLvOAgOY/+crqSk5EnCDoQBD51eo4hUc3M1UEoUT4v5ZE2JCSglxNjalN51pnZYkL\nv4Z90S6OJstAhoOBAx4mHoSoUtAtKSE2rf6kRpSUkFdZxaU/dPGqmEZ6WgxT112jp2PNSWnfHpe4\nfBZ1XsTlE+sakQhpRWmYaJvUB3T/AnV1wQBu3QoEBuKelkF6tZRHj0SXxMaNKkoU5egVIC7q5cvr\nPk+pUjLlyBQGugxkkvckrPWssVBY8DDnGfTty5iICA5kZhJTUkzHx0qqO3WjrFNPTC/fakYiAKzp\nv4ZVN1bVMVr5VVV8ER/PLzVjMiPWniHKzwtzvXrpkJanE4qiIp7npTZ7P4DkBw8ITEjgg+RCOjw7\nyKxN/ozTOk76sX+YVVyMkZoaocXFyCQSfnZpIPPKzRW6od9/FyMsZs1q8WZ1/brgGAAKyhuMeETI\n2jXVNSmpbLAIdeqEditb/INPk1nWeMRgYnk5tmVlVFlbMfPyPL69/i02I0aQLJNR0aQ6uS8jg2HG\nxuioq1NVWsk9j7fwlT3l6uh1WO1Yi4FUyrXMAtqnPMdl/HuAUGDExABdu9I6KpFCXi3NfFGcQ0xp\nKXl3dbm1N5492yvoY2jIpQYJX15ZHneT79LPuR8HwwqwDclA4WhKy849LcDLqz4rBiRqEkJtDIn+\n+9rrvb4JDB5dIatNz7p9yyhLIu2JV51Ca7rPdOz07djS2wh+/pleenpcyct75ejIltD/9insysJZ\n0X5i8z/GxDB4+nccdlOyvJOMVqb1JIKhmyMWOXksjSrnXkU7Oi3pQdvn+6DQmcWrw5EmHudkdnaL\nEzkaqhBA/PuRchefXfqs7rmksjI+jIpil4eHkIYpleIH3qULD4f542XmJRyZBw2CS5dw1dTkcm4u\n5iopOhVwr5cC6wcPSKr5/NtN/BAaQldX2KLMng3xGVlklWThtv4gfl9vISwzjPiEKlpVJ6Heyr35\ni62sqBwxlJmFmyi9r+B6E6Ls78xMxpiakpwMtjYS/nSxR+35KmxunWVPeZDY6IMPRE/WsmVMt7Ag\nQcujkS9ClmYWXknJKHv3xz3iBnuSI6k070f7NHM+jPwY0whdUuXO3C0swFeh4PqCrzjubUX39m7N\ndlejlQM2Rek8ia3in9hY2sbFMdXAgOfa9hx6frTZZIjXUSEASF7EU6gr5LAVRm1Q5OTUeSKEZYa9\n9gSIWlyOu1ynQoAaJUJiYo3jbhNMmADPn9M6uZLwrHCqlfX3oH8OpVAgV8PXo704/jZetMl6gJNE\nh5sNVCPxpSWkVEv5rHU/8cSRI8IF+MwZIXG7e5f+GboM3n2bDrq6xFmpodmg39xY25jDXsXc2R4q\ntp8/X1QQzMx4eDYdu+hLzK1eA+3aoVeQxJYtcONGXYv7G6ODri72mpqilWHnTiqM9FGeOM7MIA1O\neXvztaMjvQ0NcbFTZ/Nm2HM6gY0FI7De/y0Wn/1K9c7djZJAABQKDDTUKVKp1xHGiWVl2MpkaETH\ncSF1FNkqd9LLKygoUnHypOiK670pkdIdtpif28v38WPRO7GHHy+dxtZEtEm0NmtNnEUa1XFxJCRA\nuckNWuee5svcTE4vGc4PQ324cegQX0U+5GClFccmnGzmSdHOsh1JuemYtsvEvSJfVBedndHR0EBS\nXcGtgvM4O8qIemTGl1e+pM/pr/BXaIkxetXVYq70+PEwYgRXr4oiuosLtOssR71YTkZODjx6RLCv\nrzAIqyURsiJwrekv7m1oyI/Ozgx68oTUJi0dNhfj+PijAxQ9foSnqSf5DUgEPU09+jn349DzQxQX\nQ8/xoRwx6ciiwSPZO24rGur1SX2PHvDoqiDFFVm5JEkd8PMTXZ5P1byFE2xICMYyPRxDYriq3x1D\nw8b1l1o0a2cAirWllOq8xCfpNSA10qMNoRQbNyZUWy3+AZsDZ1++Rqxbh8GNk1x4J4T4b08z/WY/\nLrt34OOvpVgZ/W9DXh1XK8yLqpEmJxFrnIu/deN7uIHcgOMTj1EVuIQZX96metxE3P/6i/SKCrIr\nKylWkzMoORxmz0aiq6BdjBk5kY+Jx7y22xbs7HAoUKsfrfvokahWbd/eyL8hWlZIhVyGUXU5mlVS\nZJfOin79uXMF6aBSiaLOuHH/fmAN7l/u7uIS3bZNFM9sXLXEqLLXJBEkEgl/tmpFKbBmzBjsG5Kz\nenroKhSc0tPjq7g4jmVloZ2ZKTLkl8DdxJ2skiwyixu3eDRsZ5Cpy5BItNjy027MNDSITy4hVPtX\nfhnziSBrBw4UsaqFBSpLC9yKQhsp0p+kP8HT1BN5igLbgrR6g91XQSptdN4awtPCmZueeeid2EW/\nrm8x/noOUZNXYG7erAW9Eez07Xgmy8UzJASVUQVbD1aya5dQIdQiXCMPF98q1jm1YvdfEmxsRK4c\nHo4wizh1Cg4dIl9ZSlxuHJ5DpuOeJcE1JxwjmQz3u3f5NTlZTGYICQE/PxITRf2z3O40MnUZ/Zz7\n/fvx10BboUu1WsteNkvj4ljm4IAUhGmigwNs3kxS8AkyVEWQmMgJLxk97HsAMNJjJO2s/Fg+0Qrd\n3bvZU1VFJ10ttl74gR9zOwiZnbOz8EO7ckWYaH3+OQ769pRWlfIsIYWzZ8Hf6Tgdk0Dn7ZcX6poi\n0CGQQa6NTc71re0IfHqflJ3hJBu1QaYhIdfGm4yLTUiEY8dAJiOn02CGDRMculI3AVv9ehmAplQT\nXU1d4vPiyciPoaBahY5+K2TluVjkpXHtmvi5Hv5Gn056eqxJqvdFKS+HSpMyHCsqhOpt8WKuxF+h\nv+dQ4rp4IT26gaeauRzLz2hWwHic9piF5xZis8aGVTdXMcB5AMOshmOjpiZiwybQl+v/39vOsOBJ\nPNNyWyGhwc3g/HnBQl67JqorSiWGlTGYufghkUjQlGqiZ+uCfkkxien1F+rRrCyc04yxH7OAzuv3\nYLJhF95WvvXv6+0N4eHM9Z6NUUwyTxuohY9HHP/X2cxNMWOG6Euq7BKIR1gE+WoKfvpZxYcfglJR\niUyphnL0TBE9zJlT97qV11aSW5rLT/3qWxv6OPbhYuxFGDqU3n//TVRJCRlVKvqFFqIY2A2ToEDa\nPrtIiVJJUZPE2NXYlRm+M/j0kjAX+To+niHGxrTT1eXOHWiXfobkPraNVBbSVk4YFRTyNL15VJn4\n/DmBkZFM19cn9cporq+4gtqC+XT451fG316Af1AQv377LX+2asV6N7f6ubLXr4vvzcZGzHf18Gj2\n3qmFqfx862e+T+mPdYf7qFQqCstrRjw2QDNfBECyZDFfaXyPUWJjX4SY0lJsMjKIsNNmoOtA9oTu\nocDNBv/ERE7XzVcSqG1lUJWW8cw9CEVVLlr3t3J1ciUmGaE4KZXcLkvBNSUdjz6i3OLkJFoP6dKF\nNiHPKFVvucKsVCnZFLKJNnsmUZUfyopfLvJU3p7xv3SiV1YWZ7Kz+T05mQP3i+g95wxtdHugo6HD\niegC5mcdQ+2D11/cWkKKpw3qd0O4d+/NX+sYd4XKroJEuJd8j3aW7TA1llK7ZkkkEjYN3cQX1Rco\nkqthe/48hlJpi5M6XoafIm8TUV7N+W4TGwd/paWCKu3aFeknS1jVS4NMyXN87OtJBBt3BUc//4oF\naw+zw3Ul9vYg15XhFXoA9TQf3GZ/xEg9Ob8mNzeXfPGiscLQzg6S7X/m1zu/kl+Wj1KlYmp4OPNs\nbGhfGwB8+y2kpfHg0+lMOzaNUe41rSPm5uDkRKvsbC7l5WGQXkKkpQcP88KwsLYms7KSKqWymali\nUwwYIEi0ed/fx8+yHWo7diA7eBgnTQvuxUbhVJSNrle7Fl9r8MVK5jyoIOTSWUIKC+tuELWtDGNM\nTUlKEuY5uUUpDE+pRM3MmHv5rYRLuEQi2M9t2+j79Cn5Kg2iyytJK0qjolpJqaEW5naWaL01kWnn\n4rlVIiFN3gqX72/wYfUaWh8MQ2ISyNXsNCxzFfSJPInu3HdaPlBDQwxLioiMLeJqWBg9iotx6t4d\nu6wsevrM47e7QhN++bIITv/OzERHXb1lf5VaVFSgk5+Hro0I1k2dAzDJy6Wwps98WfAyJh6eyNSj\nUykoL3j5+zTA+fgbJBgPZHl8PPlVVYJEiI5urkQAUYGbNw/tX/7AUteSmNx6GeOTw9HEmAi/BABz\nL39MlXkoQhWcb9BetSryLvqFj2lv4VNHIFQeP8OOJ74cP45YdGq+ow5qalTJ1NBS1K87UjUpGkpj\nYqSaQpY8cCBMncqtrp8w8NlPeN3fifqFcyKZ3bIFLS3RwnrizbiVOkgkEv7y8OAdCwsqd2xjcu98\nOhUcokf35iRiQXkBC+8N4buBCwmu/ottJotoO9WH48dFDtMQCs82qFVXUlAlvruk8nJsysp4aqaB\nSekIsr36ol1QjolLBT/9BDoeJWh1yCfB+S+mR32G5o3LyAc3ll9qSjWpMvZEOyuBhBcqEmUX2Lbv\nKUuXr+eotyFzPv0TtYsH+WP5HLzs+jEp8kUjjx8QFWSd9D6ou6bgEBcnTDUBVXs/5AXpzOv2Nfvf\n+5KQXz/h6sQHZOv6cPfhd/z97G/4+msR4a1cCdQXfkFwxFlZZmQUFqJ89IhrFhb00NcXfdR6elRF\nPG8Uh7xlYcFsKysGh4bWt+uoVPhtOMV9QwMGXIzFzditkRIBYELrCex4sJd2Y89y37M3G8euYnmf\nz5sl3S4uoMwTJIJuZhYOPeyRSAS5cCIjQCSfI0cya/afpJlqMSDUD+mYqVyMvdiIPIMWjBWBUm0N\nyhX/zQ8BQGqsjylZVFk21t86GDgQYNvx5S80MIAdO/D5bRY/Lc6m08VzJDmbYe1Ric5rViFfFwae\nVlgWVaKV+YJIg1zaWjRPft1N3Nk1ZivJXUbzY6o/6tev014u51Z+PtUyHfpE3oTu3VENGkLvJ0rU\nk1N5obSrTy6trTHLryIxJ16UIKdMESRCE+l8XG4cyS5mWJTnoCuRivmSAwYI9u3oUVFa1tKq9yN4\nAyxaJGphxsY1Fhdz5jQ3xngFZGpqHPTyorWREd61EotatGmDy/PnHPDyYl9GhiARmm7TAGoSNTGC\nr4lB74u8xk76UrkZ1aWidWnejs3YSrrQ6cwlERT8/HPddhp9+xKYlUpcQn0+8SD1Ab4W7cg9pY5X\nclIzNe2bQldTlxgnBT/5/0qnWd5EnNjOnpIRr1QhgCARjhtlovbiBf4yKafjCjh0SHS01mJLWhqz\nLC0YEyTh3DkxfUUuh2WdzpH94TKOv3OKch0j7qXcw9fSF5mWDvGeluSdOcDh1q3Z6eFBcF4eHlpa\nQnXl68vhwzBsGPx853uWdFnySlK/2bHq66OUNjcTPpOTQ35VlTA1/+KLelc/iQQHGy+mDyilKjqS\n4NRb9HDoUfe6dQPXsSnhCGHfL2L05MlUertxd1U29BIy1AAAIABJREFUDseviTzj2DEh6d+9W6y7\nKhWSK1cY7zWe8bveod+AShQbfubWYO/XJr4AnAyd2DVqV6PnDK1dMKooI+lMKJWeYjSzuq831Q8b\nkAg1KoSqz79i7DgJQ4fCuMnFhGaENmqNAOGLcD7mPK1NWiGTSIis1ECzMI6q3GwsLIQo6OZNkGx2\nYnViIuk1yr3ycqgwKsPx7l0YP558ygnLDKOjTUdsp8+ny76/WWlvzYaUFGz++YeZYY9ZeGsDbdf7\nMHTvULRl2lyffp2bM24y2282mbn5WDs60hIM5Ab/9xorBpZYsPpD0fu1fm0ZFXPmCWnGzp0iKS0s\npPrHnzGvSsfLN7DudV5WbdEuL+Ph7fok+EhmBg9CtvL2i8MY9xqCxeAm+k0tLXB1RfN5JF0LDFiW\nfYhqZTVX46+yLHgZG4dufKN9d3YW69yRZH9cQ0ORadhw8kI+s2er+DP0MPYFOZRFJQi2uOYHeCbq\nDOtD1nNgzAE01DW4eVO059gr+whfhEGDkF24wHBDQ6SVpfTLyETSvRs6A7vTRXUTc5UmL8rLUalU\nFFVVkVRWxtOiIvr4zOdYRjqfh91iR3o6Xzs4sP/pfr777T5dlVe546XXuFXDyQnz/Hwishv7BryI\niaFHaChvS2VUPRzMxYvw7hwJTJmC5vWLTHC8zbPdj4XxQ608DsS/R44UyeDatY2MlEoqS9gbupeB\nuwfi/psnm44/pfjRQFanD+Z6wvU6YqghmvkiAAwahLFBNbpn0rmYKUiEwqoqtqamEnT/Hse0XrCs\nxzLGeY3j17vreMvUlL/i4uoi1/DiYpLLy+kllZLQehDJxUo2rbOk7V8d+KfoPH92LMf0cSh5GuqU\nqWsjqQk2GpIITtfvUKWmRX5VFdElJVzOzWV7airvP7uL5YnVfJyuQu6xhF5SZwLKRhPrZ8xO01HY\n9+jN+qgoHhQWMjPpGU9GaRJ2dRQdAlQUWOQz6N7Z16sOvALVndwZKH3GqKGVvPsuvMQSojmUStrk\nXkVniCAR7ibfJcA6gO7dBbk7aZLoTilINeePIev5rF0u1T98T29DQ35JSiK8uPhfJzWklhXx6Ys0\nPjPTwFm/prc1L08k646OItg5ehTJnDl0sO6AWpUCT6d6k1VHRyirNiPEchjt3qovg5lYaeB46wzq\nOc70njuVrampzRKCpkqExMqHVGvk0tuhP7ue7GZ5fDzlSiWLazc6dQrV+vVs+WwgAw4OZ2WvlY1m\nEDNwIK6hodwuKMAoJp3qdt14mPYQaYcOmFRU8LykhJSKCrz+xbl6zRq4GnWfgKfW4vfSsSMzEk0I\nSX6IU14pZj7NDfcAaNWKoo7t6J+2AhcNnbopDcF5eTjI5ThqaZGcLEiEuLw4Rj+XIAkKwty8ztNJ\nkCGbN6P+1ltM0dfH0mU656LPcT6yAPOcDFyCxsGQIUy/ewdkBrgqS5h+bzlVH3/KL5FrqdJ25mR2\nDtmbnpFiWMmgoPkt76tEggIZaak5XC0tpYepKQQGMvbcOTRMerH14VZeJFUwahS08VHx3p14PjJ+\ntQqBpCTStDXwdxEEcefWvkgryijIzSW3NJdzMed4/v5z5Opy2q5vy42EG6/8Ho5npBFs+hba2pbE\nlZbicucOt/LzMY+Kqp+O0RRvvw1nz9JT4lTX0qBSQcrtB8SaSLDRE9d4GysfUi11KNuRx9Hk+h/k\n31k5jDExRnL0KKo5czg06wxu433ZuFG8dWkp4gucNIn2Z4RKRKcJKaVVbU5SXn2fZEaGWEK2bhW/\nF0BUaTZvhqoqRowQecR/RSd9fUxv3yZTVsktzwBKFMWoPW48pqBKWcX4g+PpYtuFebeq0ddV8W7U\nIlatEmO/u3UTAVEt5L7t0Ssu4HaGkBInlpdjnprEdcsq5gd1pvf3/XAqyODqswqCgyG3dzwfPg5B\ncfBvMS65pZI44GrvT7lEQn5cDoWxp/C+EYXk3j2qum9jm/p8Rk/XZqRGK85/9wPOmpp0fvCAuAZG\nsSkpkB8zkFRtCZ4PH9bJe+OcjDHPzcVI3xUPD0HMdBugTkKlJR0fLOLAyoWkr/6e9QN/4/BxKVev\nCo6otpXEzAzyK+xILa/iSUYG5lIpFjW+NBX+frhF5TSqVAF8ZmdHe11dxoaFUalUwunTVBYomTPD\nkEmPVVRkVpNfXY1+wznwzoP4J+4hyR2mcX7mYab4tNB/gAhLAgPUkSolGOZk4TtEeEIFBsLV62pi\nbF1MDBpfLsdh3X4U2yIY3M6XxRcXY7/WnsUXFvM04ynVymoqqivQkjZWm5TpaFKpaNn483Wgbiiu\neXWHV5RqX4bAQJgwgSnX32ZI6Um8tORcy8//n5MI2k4WWJaWY1AQQ7WlcyOlR0MMdRvCO35z+CJ+\nCsWB/QhISGB/eiqy0jyURpZgbo7OuCEMSszANh/KjZzrRZyamhTraZEUcU8kX61aCSKhCWJzY8n3\ndMaqKB0TdaXoG+3eXZiZTp8uHi9rZfgXdO0qlsM63mLSJME2vQEMZDJu+/k1H0fbpg08eUJ3AwP2\nyuX0T0n5VzPOpr4I+WX5VFRXYKxV3wanqW2JpCKPssoKTuX9yO/Ww4TL3IEDjUyL1Xv3pU+sBree\nx9U99yD1AYrCdvS4k8Oi8LA3Os6XwcnEhXYb7AjVCSPjoT9nzvCvJIJCQ4GGXIfSMSPpGhuBZe8C\nfH3rLULyq6o4kZXVyOfLyQm+mxjKXtkUnnxxkHWnnbGxge0Xb9PJphMAxV0DqDxzHTc3+G6CAX2P\ntGP+w8o6U8VDh8Cj/w1SC1MJ8gx6o+PUNzOiSrOxyXetCmGFoyPq27cLp/ajR+u+Z7lUjoXCgriC\nBK6/uE53++51rzXRNuG3gb8xKm8DJRt+451+FTwLuypGzcyfL+4DEgllZbBsuYQbfvPgl19YO2At\nCUnVGDqPxu7SfYpmT32j42gJxjauGJdXoRHxBJOegkQw690Gg8QGJMKxY6CuzrwLQ5BpqOg04zCe\nf3jibe7dqN0JxISGs9Fn8bHwwUgmIzgvDzOKUeaKeMHISJggZj3RwiTEgi9i4gFBIpQZlOJ47BhM\nn871hOsEWAegKdXEbOQkfNMlVD7awfuasfimrGd3yO9sKrWioM0a5gXdYG7XLxsR1skVFVh5e7d4\nzPqa/xcrEQ6PcCA0FHZ89IRBX7Xn9JZUFg94TLhVL5DJSF+zh9IVP2JWUUoHv3pZSVvztsirKnh6\nP5OICIgszOZ+biZ2L57w3v0SNFf/0vIHtm8PN2+im5JNlq0xK66uYNzBcewetfuNlQggesXenqtJ\nYZwRMjVbhk9K44/Qb7m25w8ckiMYpjyGUlPcRONy45h2bBr7gvaRGmnFoEFiHba0hM1LA7mTdIcS\nfW1o25bJSUnIcpOxKC8SCgpjY3L0HTFJL6fjgwfIrl7F4tYtAh48YFxYGMsT07D1+ID1MXf4xcmW\nRadmsuTCUsrK+lLW2pk4SV5jEsHWFsvcfBIbVPRjExMJfPiQmbkVHFkdxJUrojey4Yjn7t3hx3+O\n8c/ojqhWrBBP1k6eWLZMDB5FVOWvxl9l5rGZWK+2ZsOdHVSFTEF9bTIj2Eb8vvlsH7GV4fuGN2pl\nqEVLSgQkEmSff8LnkVs5nSL2e3ViEnrRhmjuOkpaKyt8LX1Z1HkR6++vp1+PTlx0dib36lVAqBAm\n6umR4dOFi+oJvLXwHyxMLYn4IIIzk84Q6f0Tbg8Fs61jHlj3sVZWIiEvsWmFRmkZGiVpmN68Sb8n\nT1gWF8tPzy+z7fFf9DGxZrf/SK74tkf6Wy+WP9DnyDAX1s/cgPdbZfgt/YDhPy1E7TMJ0uwjaM93\nxf+jTGwqizAdPfo/O1jXoqKTP1rqpbwoM+Pti2NZ7ridPavTUL58YAMA1SGPyFSaYNHOCoA7yXfw\nt/Zn1y7B4/XqJURBPXvC3D4jOaPfl/SIMCY+yUQNCf2fPMH+9m2uvMIjod+to9hVvmC5b5CI0D/5\nRLBwERHC5fnYsbqqhr+VP2r5TjQkRZ2cYI38M+bkrCSoyf3MxVMDvX330H+RRMeQe2xqIPmCehLh\nfkEB4549Y2noOQwTpxNo9R6fZqg4k5PDXk9P1CUSiIxEOX0aS952Yn3qcW7Pus1YryZk5MCBuF66\nRJVKhX1sNB7jBmKvb89O7ShscnI4kpWFn0Ih3u8VMDIC7wH3cNqVTfbASTB5MkPu5vE46xRWhaDp\n0rw9oBZWX69hYVgcztHVTAgLY2hoKN8nJjLW1BRSU3nn7Ai8nq1n0Ym5DAwtg6AgbG2Fb1YdaibF\nTPv1V9J1vDkVfZbdj0NoHxWL3sDhoFCQ4d6HbndDCToYR7WFNdJV32Any8MkJponZdVMilpH6JD2\njXoGm8JYV5uc8kJCDAzo4u8PCgVj8vO5XFCBm6knH/x2lKlT4ZvrGcjKpcxpb8SKFc3d7+sQH0+s\nvpJBfqKaNjSgDRWUkJedx99hf9PPuR82ejZsGLqBXwb8wugDo1l6eSmV1Y0rI9mVlbz1/DnvRIbj\nmnWMXV7ebPfw4IavL5PlcrxqBzG3BH19mDmTGcH5dWMeT5wAR827lDpY1pEg3ubehJsq+cEnipii\ncpJKynmQn01utYqlMVKKp85hEGfYdN+XnTtFgh0QUNMmB7B4MR3WrwdAz7hxJUwhMSe1QIzoqqoS\n6vlp0+qWYIG2bUW0eeYMgwcLted/NVgEqNq2hfWexUgO7+FqGz2id65t9PeF5xZSrarmV6uZSH78\nEXbuRCJVZ8gQocCePVtU0IYNq5HaentjXljMlSRBRiSVl2MQ/ozb0nYEjZSClxdW2dlkp8STkp3N\n4Rcv+CA4WJi+WVm9dD/7eLbnhbYcjYIQZp6JR33BQtDTo7dTTzySfuDkzMtonDyDtKqK3xcu5F1T\nUzo/fMitGkJu+/4q5LNdUU8+hOfly3VKhL+1YvHIKSa1RvWyeTMM/TGTAIkRM+ys2Haigi9GjGBh\ncV9WHTvM0qXiZ+bgAOFZ4QTHB6Nt6USWTJ1gXV26GJjSpQscuvGYH1U3mFrSSrRNNYBEIuEPV1fU\ngDmRkRR9/jWrzN7ivm4c961NubJoH5oSSSMjtbMn5dg93szDuTfoZv+S2XE1COwhQV6ihqRESq9+\ngojo2lUoZMvLEX3348ZxXm0AbjbmfD14PiFvh3Bu8jkkEgkDdg3AZ4MPOjKdZuRfhUJOle7/wfjR\nmmRTy+0/kAggEsaoKDA0pKOpKZdzc9F+g/GNrwW5nCKpDM+8DMzdX12ZXzvqM5yM7VioloP/uXOc\nyM7BNDuHqs4iGZd064pLaR7tU0DDrnGfuZq9Pdkb15K39Q9y1nzXIhEQmxeL0tcHl4pEAvRSRRWg\ntvK6YIFYKP5jsUIiEUqEvn3/08tfjTZtRBzw228EffMNo16D5Gjqi/Ai/wUOBo0JaB09G9QqC/l8\n326ssp0ZvGa5mJjSlBzu0YPOyRU8iH5W99TDtIc8v9yOyR2jkbxOK8NrwNnQmfOJB3ExcmHeHF3C\nw18+2rEh7PTtiBvWjY5Hj2Leo6ChPzt709Ppa2TU2FMuLQ2GDkWydi09v+jKhQvi/nTgn9uYlgsF\njzIgCOcnsSxbJsJ3NYmE7e8/4LFUtDKEhsLVqu/5uPPHr93mXQsjK2OqNFQsXVrfTbEmJIvqKhgR\n+hSWLBFPNpHOuxq5cjziOIZahljpNl7fgzyDaGvRlo7Jyyn296GDQ+dGf795UwihnzyBd29MpujS\nbWJOx2N1chNLN5/jvf6V+HkPeKPjaAkKMxt0y6GdWgjWA0QM4jnMBb3SdFT5BXVjQ093+Ipz92Kp\nHjeYL4OXsn34dnaP2t2sYGqhsOBS3CXamrfFUCrlSl4ernqaqBcU1RVAFQpxupxu2rMjLpMH2cVC\niaDIx7GkBPz8uBx3mZ4ONa37cjlFfXvw8M+v+PXOr0x07U3m2J/J7zmY7bbOhCYn43bzJsNPn+bo\nxo1Uzp9PsrY21h1bVnfpy/9/MlaUSCQDJBJJuEQiiZRIJItb2kZHIkGyZjUdlvTGbt0ntI/Zj4aF\nEYGB4r7tPsCB9YHzSDJQx8OyniXxNvdGWlVC3545fPxpGf3PLEcrNYNj4XpIPvjg5U1Gfn6wezcS\nJye+H7SGFddWsLT7Uvo6/7eVccgQYQMwdIwX5fpmVHf+jjvH/2BIui2hxtlUuCVz7x6UVpYy6sAo\npjt/xpoF3Rg2TLw2IkLYBzjb6GJc6SOqZkOHEnjkCP0OLKCsXUCdCUi+TyAfrr1DXEAApd27U9S9\nO8mdO/PM35+b7drxsMsAXNL3MW+XH1pSLYYmPebd6M78ZhbF/ZT7jUkEqRR5WTnFeYLtik5Pp+e9\ne4x7ksPapZMZM0awXw0MkQEwan+BA3kfM88lisKzx6gOfSKUFiUlMGcOkdmRfHH5C5x+cWLumblY\nangwIvkZoYvP0k42kYin2qxaJdaOwa0Gszdob6Ne5Fq0qEQAGD+egQk3yKkuZMW9v/g+OgnpDnss\nkyPw6DIXAGcjZ/o69+XA0+30r6riwLlzKFUqtiXG03PWRP4yjePpytnEfhTH172+xlRHLGRThsyk\nvEgsXFb+9YZN6uqCfY9/IUHSpQsjds2kqGtn/jDJI+n6GFrnnCBm6Gfs7jyBwSamVEXrYHvzAIo2\nLnz1ySkuD02g4nIccbv/oOP+awxtPRJ/Evje2YVN5s/p8jhErOL/hzC1dGHuV+1Rex5Gu88HsqzD\nKYZ+4k6EXntS3/5KRIVNzedUKio/Wsx+3Vloagq2+G7yXQJsApBIRJ4/c2a9cfO1a/Ch1zp+bq9O\n/tufkLzAjTDvjvzm6sq08PBmKgCA1RE3CKvU5LKVP5J33hGscXm5cInesaOZbLGf4yCqw4Y1uvbs\n7GBt7lQkNtYttiZ27akg8qsLDDi6mTVPQqmoNWu7cIHJuwfQKvYXhj55gqtckwuVhpRM6cXXKi2k\nJfH8ZFompqgUFFAyuD+f9lRSGdCe4Ck3Cf/HiUmTRFHr229FIqTyD8D14UMAOqSHYjIggGPjj7Fb\nJwbzF3Eczsx8ZStDQ8QX3WVS8X2mnZ1AdveR2D5JRj/pOKkGchG8vwTSjp3ItbDDYdvnJHTqxEgT\nE9RAyATnzSOvXJPqE59xZ1kSugojaN0aW1towq/ADz/gfusWriXlnMnOIjb1CVYZGXXBu2rMOH5c\ndYEZm9dR/cVyUFNDbc67zLrzD5LiSkY9u4rTnE+b7V9DmBvpku9XTauEZHTdBDHiGBCAfV4eXi7z\nOJv5J5+77WddUig7vbS4e1vE/S4uwqOq6STR1PthxBtW09lDBIIOxhaUU0pCajY7H+9katv6asMw\nt2E8evcRD1If0HlrZyKzI1GpVPydkUGbe/cwlEqZXnWdkeb11V83bW3WZGai33Txa4p58/C7GEZs\nbAhKpfCr7GD0HHXXevLHw8SDu4Yl9Mg4iHGCPov25rL82W28nz9CPnMpS31Ps+KEL2fP1geTn34q\n2pcrKwFra/JcBuMZH4+bS2OjST01czKKhRLhyy/FOrVsWQv7+c47sGEDtf59Z8/W/6nhaM9/RXEx\n1UcOc9GtC35OTthNfpvqE8cAsW4sC17GpbhLHBiyE9lb04RcuGYELdT7CEVECEVC796Qa9MG25wC\ntj47RGF5IYnl5Tg9fU6x3VhxCUokWOnokHL9OmvXrmVKQgLGBw408oNpCV2d/Eg0qmSo8Wb6xUpQ\n+3AeIIps6g/ew1LXUhBENaa/c2fMYKudHSOePmVnWhrfy57TydAI1/zb4h7n40NuaS4buI9LfHKd\n2aOWFtzTTWdRGyPG/T0axbJP2LhzLxdnHyKv/RJs5k/gnW9uMeHQBLpv686Ccws41PptijVknOoU\nQMjVUJ4ar2DC2T74Dn+Pro9yxDiNNWtEH8T16xATg7SsjP2enrxITsb2my+4uKIPmPbi8ahuKK7s\nQl+9PshXKsVEsXVzRuFq/IqxdDXo0QPIqIIKrbrpdPr6og++YWvcnj2NDRW9zLxY1WcVL+a/YG3/\ntazqs6rZe1cotKnWf/V39UrUVDD02/xHEkEuFxL+1avpqKdHRGnp/1yJAJCuo0BercK7Q+Art5NI\nJAQv2MYuqwy8z56mQKnCKSULvWE1r5PJCLXvhHs2WHg1rgrqubbm03Ml7PuwFx4HurEpZFOzkc6x\nubEoOnZnxtEDfBxySbQy1MLGRiSXLbSZvi769xcT6/7n6NpVkB1Pn4qFoakJawsIsA7gbvLdunPQ\ntJUBwNjIDo2qIjY++45T9yqRDBtGsyoEgLExqUZGVD+4DEB5VTnhWeE8OeJIr7B1r5fpvwacDZ3Z\n/2w/fdw689VXwpLhZTx1Q9jr2xNhIycgM5Owqlza+tQrP7empTGzoadcSYlgaWfMaNTzEBCgQu58\nm9ULOxIVBXNXj8KmuILBnaMYPlx0YX0zKoTblX74+UHnkaE8TA9hqs+bV+/1Lc1R6qqjoSHCvHW/\nq/gsMo6SJVKye49nqsZe+nzgzvTp4t61dSsUFICLkQtbHm6hu133Ft/3t4G/kVeWx5fdv6x7rrBQ\ndF2NGSM6GQ4fhuA7WhwynMWtcb9wSOt9TEdOxuqdj/9TobgZ1NTI11TDszoMNW+hhLO0USdK5knK\n+adw7Bj5RTA2MYScoAD6uATy6N1H9d58TWCpsKSookgoEaRSUioq6GRiSaVMTUxAqYFcDsd3y2j9\nxI6+B2NJzVRSol2N7fDhIJFwJf5Ko1zKfOp7/PbckeATxkx/fxO6bm1Q09amh7c322fMIPGHHxh+\n/z6rjY2xGTyYEl1djA0MWtpFdGQ6lFc1H7VcizejmF4TEolEDfgN6A2kAPckEskxlUoV3mjDfv1E\nlHj3Ljg6YoO4mJcuFb0gjq0z6XNgA+6r9uPYgGFsa96W6srbeNqlsi73GySK7rTaYopL5m34ZNvL\nd6x9e3j/fRg7lgCbAMLeC8PdpAUDszc6VjDv3x39rEyuRt8i5rCUL9ZNpItRGbf7zOHEyZt8HzGH\nnEh3tn75IUsWi9adhj5Tf/4Jbm/3ZV+ri/QaNJPyboF0d1ZiMKK+31MxNBD7LzZiovFxs30IDg4m\nMDCQHSN2EJ4VTsrlEfx0BFarItH9cgXLni6uk9jWQqNSRV5xHMP3zuCu5mAGnrvBnoQO/HDgGt3b\nWlNebYWWWv1ORmZHsq1gMtqnD3D+hg/777an3eQ+uCeWsubLfhzdEkBSQRKT2kxiU69jHN/Ulj8+\nF0no8+dCytkUA1wGMMClOTvYVIlQUF7AyciTHHp+CNcOGbSNeMTXSgeqMy7y4fRLFIQoubh/OnNq\nWtcXd1lM7529ae08ja32ztxcPgKF0wjuZDrh//sdPhmg1ei8gUgUP/pyNIa5Kdi0axy0ODmJ4Nez\nS1f6HD1H0IFRhGWG8efgP+nv0p/KShGc798Px46qiNL5AfVPfwAEb6UsMkGuMZUJ6q05f3kgamM+\nQHLqFNahoSiKiuAlvUhvAitdK6Kyo7hTnYD5yJ6YTx6PplJK7NKbxP1xmlGHZmKhloHa9m0weDAq\nlYro71aiFhvO1oG9WFBRRE6pIJVs9ZrPgKklFeY6G3Cl007adBrONdl1ZvW0YsvKNAaYKfgoOprN\n7u515zWttJClMWn8dfwE9ofOiN7MyMiXjrEEsFQGYBMTQMPpiJqaIgYaPfrlx79guj+DEodilhjP\n7i+XMz0qnPL7d1jT2YhL/e1ZuXYtfYpTwa2Q52pX8PDRwNDlHzaHbKCrdQBRQzpx2yQN44kHeHF8\nKI5TRCI7aVJ9x4UQjEg5btER3ZIKDEvVQF8fQ2D7h5f5YsWPnCwuplXRbRZExVJQXkBBRYH4b82j\ntLIUR0NHXAxd6BxejHab1ijsnbBqBceNevPpPyfItbXEoea4Gl6jDaH75TfMmDeV8MTnFKVfRiP2\nAocOlPLW7ceM79uTHiO7cbzt11BaBhJJ3WCGuDiRDDg6Iu5Me/cya+VKlo8aQJGqCnN5fcXb7t1B\nWC+dRqh2AAHv1EhXp01jicsyUM/jQmtNRnkPffmXAhgYGZGjr0XnS6VcviIRY4j79WPFd98xdvYC\n3H378EfkLYwMAug7eTIS4C9/f9LH+vPnIX86/NyBD78yZPp0wavE3blPmsIc9ZqKokQioQoZqfkZ\nRJdE0d+5f6PPt1BYcGriKZbf3YzP2bXo2IxA73ksBydMoLO+Pj1uXmw+JioqqmU/hIawtqZkYB98\njtzksJ7YN9OsRAxaD6nbRFOqyemBLiw4lsrS2P0s0RmHxLCUY5tPkbv7DGvGN/e96NhRrDd79wpV\nwph7i3kS7Iz6o4eNz6vMnKyydI4fF948ISEvMZ0eO1ZI5hISGDHCjuMHKwgarORpQTQDdg2gp213\nNjMMzT37xUGYmDR/GBujunmTf2zUCQtexMETYGr0OSUffseGDd9yzzKWR2mPuPzWZfS//F4kKi3I\nrUFcch9/LARJ769xwcI1Cw8HfyYEryNcpxt9MlMYPXdS3fZWVlaEnT3LX8OH86BrV5D+e8jiZebF\nP8ZlLHp0mMfvDKVTDelgZ9dEjSOTidbJd99l4JgxXD50iP6RcZRLtDjSzYsU5QqiDSdw+skGNNQ1\nCPAZjPW5cqIzM8HBgaSyMp4UFzNw5Urx5gsXAtDZtjOP3n3E0stLGX9wPO93eJ+NQzaiq6nLX2ee\n8XF+BMGerVHbdZixk5T88/MtKtu7wO9tIDoaXrwg+NgxAquqxIlKSUEhl3NBpeJt262o1pizWW8c\nf3tb4XnhF9RzK0Ucdf8+527po6PjzaBBLZyYFuDhAQYXytDRaqwY6NFDxGBdu4q85OTJRm3kdVBX\nU6e3U296OzUfDeZo3xYazIJ/Y9SQmRL7/0gigJD+t2pFxxo2Muvu3X//bb8hshS6KKpz6Ozykha0\nBrA01uHr9scJvumFUWEOvgnJyKbNrPt7jn9U3pUaAAAgAElEQVQQRF/EqXOTffT2RmJuzrtfraNj\n2iPeP/0+mx9u5vdBv9PeSihl4nLjsPEIwCotTchkrl9v/B4NZaX/A7zs3vTGsLUVN9g3gLnCHH1N\nfaKyo3AzcROmivoOjbYxM3FApsrl7WsKPGWVgp19CWI9vXGMFKOOT0aexLzKiSMaU5D5tBY5w/8A\nzkbOZJdm08mmE1MGv3y7pufVTt+OF/kJjBo1CoPCQqJKS3HT1ia0qIjUigr6GhmRXpSOoaY+Gm+9\nJRjAL75o9J7ROdEYKnT4YLYVbdpAUJCcp0ojDI7toM2H3wCgE3af2RvGogqHE9IfmOc+D7n0zRWy\nCgsLSnJz+bIm19+bnkF+vIpbSaMp+30ViwN7kZgoihqJiaLKvmQJdJjnwvOqDSzp2vIkCFMdU+Ln\nx9eptc6dExx5z56Cf6q1UjIxgbFX3kPm4cxllTOevx7g+1dM/3tT5GlpoFIYo6+lSVZhKuYKc7Ks\nvKk8+wTNaz8yy7MEv37P+Gvyg2YeCE1RW9z1NvfGqOAFBlIpPczdKZBLkOflNSLMZTK4scga87PJ\nfLMxDkvrbGSTJpFdkk1MTkzdOgDA4MGoZ2SIk2JpWf+oUSbpAjNqHtElJTwtLn5pG6lEIkFfrk8O\nLfdI/79CIgD+QJRKpXpRsxP7gOFAIxJB2aMHap9+2iww0NSE3n2r6L9rPFO8pzCkTWP20EJhQaJB\nBQtNjJH10aZof2sOPp6M2i8/vNo4w9tbfFZNL6WH6X9nZRuhQwdabd7EkuguaPSTk+DoyAgjQyIN\nJXz/aAiq/ESWmt/mo2hJi0UUGxt4b2Af1t6bzr4jhTyUZDIjTIpkdbe6bWwndsd44VTyMisxMG1c\npaxddNxN3Ll90p1Vq+Dm9iikU0roPWIBKf2m1FXca6GnMkVDz5s7WloMPXCeRw4a+Pc6yua4ZJY/\nTia1KBU9TT28zb3xtfDleMRxvuuzkmW/9iArGaZtvEe5vTV3erhi1KU3q81a46DemZ9+kDJulyBC\nnz8X7ddvCl0N4Vi67eE2Dj0/xLUX1+hu350gjyCGbV2N/kfLCHHvwHe2HYnYN5vuni6E3JETHCzI\nAB8LH05OOElsXgJzdXTRK+qGzTU5Dp8fZUgDzqLhYq2tDdZm3oT/Yo39ocb7M3my8BGyXNyVwGQN\n4szasGfkfu7d0uadH+HwIRW+DrlM7pXC6o+CMTyoJmh7RPI9erR4D9/efqhP3yrofHd3evr4/B97\nIdTCzcQNT1NPPjjzAelF6aQXp6OhroG5rTnGq835Oc4Vh7vO7BsTxJJutlxwyeXBtlwmDRmGbedQ\nWq1rRR+nPjUqhFfLCXu2HsLxcZ1ZsbMHuVomxI504Ft5Ar4b1rNh73USr/9N4JkzLNSVMapcyUQ3\nX4j7Q+iyXoLqaggLE8XBljiVd99t7EjcEg5/uhyrXyewwnMs8tR8Zn3WixKTCSiKjpM73Z1jf4cx\n94YSvWeu3LKfgOlvs/g64mu2jGiFT1wWy3WfIv/UmUmThDdoQ9XjoEHC7uPCBTg4fyCzjh/D3aC+\nAmClZ42dngjSbCSF2Ojboq+pj56mXqOHhroGMbkxPMt4xog0LySTJrHnPSHO0Lj0NmpDTnBrVD3h\n97JAzXHiRB4v+IDLkzpwoP0obCpHM37nAt7uHkilVIf9Y7ei3sAt/fPPxW+jNjl1chJkwtixrRnX\ntSuf6DhQqllFd8t6U0O5sQ6/Wn+FflAfOtZeEsbGZHbzYeWWM2xZPbmZ/LopDGvYwz425rz9tpAb\navv60j/4Kusu6BM5UY2fRo/iRLuOSCZMEFHF3buY373LMtm3fJEXQup8S05/5I/NKH+0Ht+h2LNx\nhVWqrU+RKp8BBmO4PXEDmvHhlNh7ktPak2u+llzWLyYFT4a5e/Po6bdUnn9GaT9XirU6EpISQhfb\nJsF/A1NFlerlLcSKT79ifNd2rH20hb1d4zF7nI+Nb+M+YRfHdhz7uRdDtj9gUd80bNNLCdi4FkWn\nlo0zAT77TFRXNDTgg++sUe/xCNwat7cYy815FpfOrFlw/HiLpsoC2tp1C9iMMphy+TrVxyopN63i\nQkA3DH86SZTGUcw+Xo6ZiZ0Y4ZCVJc7B7dt1/1+ensIv/nr8NKRPTSeBNmldfNi09gvMlvYneFow\niut3xA/48eN/7bteuRJ8fdXp76DODf0uSAsjGBt1CY2kOIKG1R+Mlbc3PyoUBJmbY990wsNLoKGu\nQZ6BBcUaSZh9sqzueVNTUbmKjhYKQpGfq5NqsZFu/yzAyX0wJuZnmDzeFE2pGo4x2RT1GsGmB5tI\nLkjmyLgj5Nw9z67cXD6LjeVSbi6j8vLQPH9elO0bHLO2TJvV/Vezun/jkW9BPbxYvjcUyiv51PcP\n5o2DcwYiTxnwbFRdZTJ42TICa6UlKhXk5hJ5N48zs5246hfP5t8+wGzwJaZ99wlO0c+p0B+Eehsv\nvJ9kcMFGF8n3kwQD4OYmouqXBogwIjaBzgaNS6KBgYLsSUyEZ8/EmvGm93LjMW+91K3+tSCTiXtG\nEwPB/wJHuRxTmYzUe/cEM/w/RK6eAeqqZDoZvp7sfcE0R2Zu+ppuj55gkpsPDSrJBkFjOLXnBK19\nm1zrn39e9x36WPhwffp1/nr8F0P3DmWE2wg+6/YZ+eX5WOhaCrPVp0+pH+/w/w7+ZyTCf0RtS4Oa\nRI1zMeca9dED2Fg5Y5evYunjfNSfXRUL6ktQ2bUnflt/Yt+Dv1h1eAHrtvhi6SgXo5T+g4dES3Cu\nuT4623Z+5XYtkQgJ+Qkw8RM6bt7Mb87OeOnrczw7m6nm5qy89jU/3vqRZWdKCUyTs/7bUbS+8ys+\nFj60tWiLgdyA20m36WjTkUVBgu8cOhTOf+SN4uJ5+PAbVJWVEBqKmp8vA3zi+Xzjafa0/+0/HaeO\npSVFsbEcuHoVU29vvoqL48/ff0cydixa703Hk+aX5vPnMPtnF7AFSUJ3eMlwDjWJGjk5gq8NDoaN\nG0Utuim0XG1g22ZuPXxIv/8hgQBQbazNbY0MRn2rg75cn8rqShZ5WDDpyD4SZVXY9TrK0ff/xeyi\nBpa6ljgbOqOrqYuRVEpbHR1amzuSolGNSW4OapaW4kaVkAAvXqCVkMAmpYqZc/ywSq4AU1OuPj9M\nV7uuyNQb5IUaGoJheQ24aGvj8i+GkwZyg//PSQRroCHnn4QgFhpBztcY//IHZjpmmGqbNvpvRHYE\nahI1VvRsrp+SSCRYy1+Q+fgKzzYlElXphaWN1r8Pw5bLRf/Vf3CnfSU0NelQVMzcAUM55ObG3YIC\n5lhZsWPsn/QrGsa5SRfxc3y10do37/oTvNabwB4OmJtNQ2/TX2KMTg2k5sZk6jgS5jSVfLk5lVI5\nlepaVKhr8U/BXX7ct4UKdS1iU+Tc+kELm1MXhWuLRNKMQADQlRvw2NmcBWsuMXTer2zq0/hSUKqU\npBWl8TjtMQ/THrKw00Jm+83icndB6HbrZoDZN4/I0rKl/Iac3eHw99/Cu+e/kge1MNYy5pMLnzDI\ndRCT2kxiT9CeRt4J05ydcN/0OyOTEyCmDNW8d/h/2jvvMKuqqw+/vyn0Kr2JNAVBVARFVBBBsEaJ\nvUc0xljQWLArBo29m2hiwYpKYvvs0djRqKhYUFCwIsVR6Z2Z9f2x9mEOlxlAAnNnuPt9nnnm3nPO\nvezZnLPLWr+11rWd4bTTXNL7/vswadKONGu2I912nshLPWtx6uLeDB26+n93793zefvCpmQmhz/i\nCDeWH3ZoDyb+VMLgP83ltS+Ook3BdK6uNo3bF8xAU2rCwmDtu+GGlSaegw6Ca691pxc77+OxLOuZ\nOtXq8MShpZnTzIy5S+Yyc8FMflzwIzPnz2RC3yKenLwzt468Br5sSK0z/siLl40EYNy0cZz70rkc\nuOVq3P0p9r3jdZ4b/iwjX7+MydN+od5Pvdj81fs5e9BR5I0v5OademGUcOaUnbh8YSvmXeYL+Hnz\nXLqWvE5+Zs3yPt5+e4+9zOT881c9lkmNwuo8ecBZ9Pv0Cw4/YhCb/ViXISVbcca+3Tnwnwfweecf\nOO6O6Ux64Rd+OvVWegweyD2Nm9Jz7gzu/N0EHvtDmxW1l8tC8glr0Mt7QItjsX/csdL5Dq02pdX8\n+VzfdKAP4tWr++/067w8OimPPZbXgrdGwj0HIYWUGIMGM6tuwdp5yiRqj36L/S6+klPvfIo5jb9k\nfq8hnDL8Lm7sCHUy5s28PJeR77IL3HSTh6A+9JA/Lz22PYmd97yZ17fsSN/BKy9w+j83fBWjzi+/\nP4LpH71Jv6MuXGMzG7RsiebP55jDevPOeFertmqVx+81mL4FH9H/7Dv4x792Z1bLf/B/PxZQmFdI\nwbb1KdhuTwpO3pcCE3WnTKXeE58z5fE32XRREXQfstK/0aRlK/IK6nLKn1/hx8azeavPbrzeqZDx\nHRcz+N0xnPfSWFqPX8ZnS7vQmIG81GQGl438A/Pqzma3gs25Y9/XmT5uKtVqFdKhX2uGfDqeN5cN\n4oaB7sxr0sTvzVV/tuWDrRuz3U/n8PrCWjx+WD4Pdlw5rnC3zXbjTy+dw5BB+9No0Rxa5H1HnR3L\n9tInDBjgDoj27T3RIlpVLdesdjOezr+f/mcu5+HZxsPPsyLBqRF+h/ebbD2HAZO/5YvtW3F1i/2Z\n2+45/lbnXHpMNeaOHMGjLT7m2vHnU3NBbawESqqBNYOSpvh7g8XFC+j4zTU8NrTUaNT2iJPpe97Z\nXN3gJApeGetJD+6+21O4r4FatTwSbsK+M/j0+zF8t0MTfrhnJNNaDV5J4tuyVi0WAcPbrKqOWh1z\nhvRjWLsXGd2mVBael+dxs337ekqFli19uG7ZUnwz7AY2e/li3nmnP4U73wITW8PYsdTp0483jv0b\nt757K/3b9efb5h/TfuZMqjdowPnTpjHg1FPh2WfX2stbqxYsXtKUwqn1OTkIYAYPdufhVVf5/FlQ\n4LkrfvnFXxcUiPzam3D/2E04+GCoW7022DIe3HIr7p85m6+owQlDfuLx52uy9Q4lvPaXsfDwQ24F\nmDjRB67Ond2gkPx07uzHJ0zglndGrbLgHDDA82w0berq6B13/FXd76yPee7DD/+3xURAEr3r1WPJ\netoQppnXoCHFxY3XOoO9BMNuOZ2C3dsxrcPKUvnOOzVi62bPMD3TgZnx3XnK45htjmG/zvtx0csX\n0e22brRr0M6Nuj17+gC1Af7WykTvVr056ZmTqFu9LvtvsT9HdV95XO3Yrgu1lsOMa0bRMBVaVRZt\nhgxh879cSGGvo9m9ehP+a/Vp/OL9a6V8Wls6N+7Mdi22o33DchL2lkPb+m0Z/clorq/fhsFffsAj\nYxsys3kz2jVqzKQ3z0fzZzK14BzqTr+X8Y//jV5Lvmb8jPE8MuERPp75MU1qN0GIU7c/FanUb1V9\nj33ocMS5vHNwH57RZA6vtZAeNzejML+QU3qdQv0a66ZcKahRg+FLljDm/fcpmjqV/rNmsduSJZ6j\npBy6dIFRV3Vltzs357w/bsZHr/k6cNEimDPHf2bP9nLrl1zijrlPP12tX8rVcFOmrOaCdWOz9j1o\nus2WLDj/WgrzCylaUMQLi+6g3fMXcPveY7j5tLUzIAD0bt2b03bwcLtNCgvZOj+fBjUa8HndApb1\n70vhvIUUN96E5a1bUbJpG9h0U/ZtuxndCvNpu01Hnv7iaW4bdxuD2q99Cc51oX718u8FrSmz+rog\n6QBgsJmdEN4fCWxvZsNS19iS5UsoWlBE0cIiflzwI0ULwu+FRSxYuoAL+15Y5gYY4I7376BafjWO\naTbIFy+XXeYrhDXx1Vc+wK4m5nhdKB4/nk9r1+btWrX4eMECrmjfnvoFBZjZryqPAsC4cb7rfPjh\nlQ7PfvE95r/2vj9Z4UeLF3H9h69xZrvuaMkiGlRbRE0WeSmgkSN911AG79z7BuPHPMYhd19Jg2Zr\nX8v57bc9lH3+fP+pXdsX2S1bekXOdHjWurJgqUtrahWWYx1btMh3QY0a+QKjbVssL5/jjoOZMz2E\noEsXKCqC94oW8GXnabx9eKdV5tQRI0YwIhVIPGWKlzJ6/PGy/9np0+Gpg+6jbf3ZdB/cghbbtSyV\nCa3GS2bmuQND+FL2+fpruPpqd62vTVDeajAzxn4/lqIFRdSvUZ+vS+rw5A330rPXRXz1ZmPq1iig\nbl3K/KlXr/R1w4ZrmBB+BX/7YBTbt9iGni1KS7wuXr6Yyb9MplvTVEb3n39m6c23U7DPHuT12u7X\n/SOHHOKJElJJGiZ//DFPjh7NmS+/DEuXhjo8S1d+vXy5r8xbtHAj34Urb8Qn/fXPNO63J426uQEx\n8x4tk++/d037iSf+6lJUixa5nPDOl77lu+2m8NnvV81RkknRgiIuf+NybtzjxjVeu3TePO4eNYoT\nhw1j3jyXIJpB4aK57Lp7IQ1a1OSKN67g3Wnvsrxk+Rp/5s83Hjl4NNu3Ld0cvvTRqxw5ZSbVGzVH\n1arRvmZNjmzWjAOaNKF+fr5b8idMgM8+o/jjCVz87xc5vaAxi2cXUVySj1p2on7X1ixdsIy5n03F\nioq4Zc/n6H9UawYM8MXL99+v+vPddzB96RcMv+wHttumgE1qbkLXpquWJvt61tc89vljPPDteP7S\n+w/s2W7NMbazZvnYWp4T5dX3ivjzEw+wzz4gWDHHJOWSy3v/wQfirQd3pe7iruTnpxZpS2ZTq94i\n6taDenVZ5Xf9+uLUY5uvPL7Pns2InXZiROvWLiUaNMiTpv4K/nH6ZxTefTsdF39Kh7xxfH79Aww4\n6Tcrzk9dvJjbpk3j8vIqZZTDExOfYNy0cVy2W/kL1zK55Ra3hs+Y4SqMV15ZuWb92LEwcKC78zp0\n8GfuN78p//vK4ICnv2a3pvU5eftSa/UXX8D++7uBtbgY5swZQfXqIygu9iGjuNiXLGPHQretivnr\ne39l2A7DVvred9919WrHtFDHzCfCiRM9Jm/SpNLXJSXuUOnWzQ0O61nuXtkYN3cu9191FTeF8pvr\ni8cvuYUFU7/lyLuuXfPFKZ494C5aDNiSbU9a2UKzupyu5TF+xnim/DLFM+nPn+83zAb+/1yruWkD\nMnfJXCb+NJGeLXuWqYgrKYHnb/ycvc5Ys+K4uKSEnc49nh1rXsB2nTqw007rJcp0ncjs1xnzZ3DF\nG1eQpzxafzebrZ98h7rfTKP59Hk0yKtJvTqNUcOGrgLLcEAUlxQz+ZfJfPLjJ/TfrD+NapUaeKfO\nncpxf+7JSTM3ZbeJi6mzy0AWXjmSXxb9Qqt6rdaoMlwjCxd6YqNx49xjsRZKsuUly5n9SwEnnOAK\nu/r1V/5p1MhVCDutOXII2ED36HXXedxhqhELZ85j/IGXsf3LV1JQuG6L/B+WLEFAy+rVue5fZ/Lf\nKa/xfd0S5rOUJcVLWLx8MUuW++9F+Q2oW7MRvRo2pUfzHpzV56yV/m/XN2MmjOGQbodgZqv8cRvK\niNAbGGFme4T35wJmZlelrln//3AkEolEIpFIJBKJRCKR9UJFGhHygUl4YsXpwLvAYWb2+Xr/xyKR\nSCQSiUQikUgkEolUCBskJ4KZFUs6Bfg3XkbyrmhAiEQikUgkEolEIpFIpGqzQZQIkUgkEolEIpFI\nJBKJRDY+/sfMGZGKQtI2ksor5BWJRKogkraS9D/UQYusDul/zQ4VkdRA0oaq5BSJrDckNZK0YWsb\n5hDxud8wSFq/md1zmNiX2SUusCo5krpJegK4jPj/9auQdLCkYWu+MvJrkHSspP7ZbkdVRlITSbcC\n9wBrUdMxsrZI2l/SfZJqmFlJtttTVZFUR9JfgWuAjTt1fwUiqbGk2yT9Nttt2ZiQ9CfgFaDPmq6N\nrJ5g3L4NWIuSZ5G1JcxNjwA9s92Wqk7sy8pB3JRWYiTtAzwPvGdm+5jZzHC8MhQKrLRI2kLSY8Ap\nwGfZbs/GgqTfSnoDGAx8mu32VFUkdQNmAtOAHczs/Sw3aaNAUmdJzwLHAw+Z2eI4Vq4bkvbGn/HF\nwGlm9nOWm7RRIOlS4Elgbvgd+R+RVFPSN8BuwAAzuzPLTaqySKom6SbgPuAzMxuX7TZtDEhqJulV\n4CQ8R9zbWW5SlSX2ZeUiSpUqN4vwhcbTAJIGAx/hC5CFWWxXpSVsGm4E5phZ33As38yKs9uyqo2k\nbYERwGNmNiK7ranamNmnkr7GjYPLJe0C/GBmX2W7bVWcvYHBZpYPLsU1s+VZblNVZQvcq3uemS2V\ntJmZfZPlNlVpgjT8IuBIMxsdjsW56X/EzBaFTUWxmRVJ6goI+MbM5me3dVWOAUAP4GIzeyrbjdmI\naA00BP5oZm9JqmVmcQ2/bsS+rETExIqVCEl7AM3N7J7wXsAZwA5AV+A7YBaw0MyOz1Y7KyOSqpnZ\n0vD6AOC3eN8dDDQHXgc+MLOi7LWyaiEpL5GDS2oEHAUUAvcDxwJTgK/N7L30tZGVkbQ10Bl4zszm\nhmO748bBZ4AGuCrsbeBWM/shW22takiqb2ZzUu8nAecCdYBdgG+AW8xsXnZaWDWQ1BYwM/suvO8E\n/C6c7gLUAj4H3jSzR+PzvnZIqg/MTwwFkk4HhuBj6RXAZLxPX8xeK6sWkuoCBwL/Sd2v1YAfgbFA\nU+AroB7wJzObmK22VgUkNUnWReF+HQb8DMzDVYcfA1+Y2RPZa2XVQ1JzM5sRXtcGDgd2Bj4A9gEm\nAO+Y2UOSZHEzVi6xLysvMZyhEiCpUNI1wN3A5ZI6g6/ogBeA6cDZZrYnvkDuKOmgrDW4EiFpb0kv\nAScmx8zsUSAfX1Dsgvff74EzYqK1tUPSecDLyfsgZ34HjzedgFuDuwKPSWpjZiVROr4qko4CPgRO\nA7ZNjodNw8O4YWs3/P5tA3TPRjurGpJ2lzQZ+GNGYspzgUdxVcI9wK7AcEktK7yRVQA5lwKTgFHJ\ncTP7Ejca7AS8hoeIfARcLKlBNCCsHkk1JD0A/B+wdXLczG4EOgDv4kqPn4CzgsowsgYk9cDDbK4G\n+kqqARAcCMPxjW8fMzsEN9Dsm622VnYkbSrpBeB1SbUAgkH2LWA/3AnzFLAEuEjSTllrbBVCUm9J\nM/AS9wCY2QL8eW+Hb3rPBd7D1/vN4qa3bGJfVn6iEqGSIOlI4E3cwr6DmR2UOtfQzGal3t+AW+Gf\nrviWZp/E0iipHfAg8CUwH/i7mX0crukEdA8GBSTtinvPR5jZ19lpeeUnGAJOA3bHN7R/M7Mrwrnq\nwB64+iDp51uB2mZ2bJaaXGmRZw3ugy9s9w6H706UBplSZkl34nGo11d4Y6sQkloA5wCtgBnAw2Y2\nNnV+kJn9O7zuiBtrDjCzb7PR3spM8OpeCvwTl9o/ZGb3h3O1gcZJv0nKBx4Cbkr3d2RlQtjCEFwF\ntxR4A3gkmcPD3GRmNjm8vxmYZ2YXRC/a6pG0FS5l3gzohY+nH5Zz7QF46MiQimth1UHSZbhiqwEw\n08zOCceFG1/fNLNl4difgTwzuzBLza0SSKoJnIwrhocCd5rZqHCuAGgXDLTJ9U8BY83symy0tzIT\n+7JqEL2yWULSiZKOl9QrHPpXiDm9H2gjT2yVbDTSBoQj8Y3JlIpuc2Ug9IcBBGPAUcAluEfngOQ6\nM/syMSAEfsYnzO8qsLlVBnlCpWQB+xq+AB4InBM2GpjZElyS/3Hqo5NwhUIEz1si6VxJncIC7C0z\n+wB4Ao8z3y5sxsgwIOwazr+XhWZXeiTlB+MB+LN8XTC0Lgf6SWqeXJsYEMLrybgSKb8i21uZkbS9\npI6S6oQwj2vMk1PdBQxL3Z8LMgwvu+Nj6CcV3+rKj6RNAUIejjeBQ3B1x46kFEZhbpqc+ugPwC/h\nXDQgpJC0uaTzJfUP89MnZvY6bhisAewsqWEZn+sAHIF7LCMBSc2T5xu4HV87XQnsmaGAfS0xIARa\n4cawSAaSCsJ9WtPMFuF5o+7CK6qdlVo/LcfVMcnnquHP/atZaHalJPZl1SMaESoYeSbh24HDgLrA\naEnbmdliAPMKDH8Hzgvvk1jKrpL+jU+MJ5rZ51n5A7KIpN8D4yRdqVAey8ymBOPL20Bzeaz5igoW\nYXN8Ap5t+D3Aouy+lDBo3wE8gCdOxMw+DBuIScCzwG3JtVaad6JO8E4cT6yAAYCkS4Cb8ZjcKySd\nlCzEzOwTYDzu4ekcrs8Pi7p78YXcdWYWF2oZSPojMA64U9KBQB0z+z6cfhCP2e8RlB9JeFi+pJMl\nvQ9MBHJehSCX2N8KjMHnlwcBzGx6uOQJ3Dg9IuNzW0q6DxgJ3GEhr0fEkdRGLgt/QNLVkrYys+lm\nVmJmL+FqmX6SWofr88LPlvISZQfhVZgiKcJc/jquPDgHOE9SY1gRvvAYsB2eCDD5TD15qcfngbfN\n7OYKb3glRFIPSR8BdwB3ycvfTjWzOeY5I54A/hyuVQhPLAxG8ReATYgVmVYhrEOn4eE1D8pDvb4C\nMLPngC+A88O1eUFBW1/SccB/8eTp47PT+spF7MuqSTQiVDzFQFvgCDO7ATcYnC+pTeqaMcDPQXWA\npC744u4KM9uzPPnexkxQbJwA/AE3BgyXJ6JMGIcPMvvCSh6do/AkLMeZ2ZVhYRe9PfhAjMeTFQJn\nAbtKujDl8QWP1d8nGLqWh881A/6BJ6zcNXiGchp5qEdLYHczOwP38vSRS2oTRuOLsXbBe9bRPFnQ\nKDPrbSFxVTRylRL6aR/gSOBWPEb/nOS8eQmyiUB/XJZLMNzsGI6dYGZnW8yAD57HpIuZbWZmxwH1\nJf1JpXHlxcD1wP7Bs5Pc1/Xw3B29zOzxbDW+EnMQnnxuMB4/foak7VLnR+Mqo20BzPNJVMcNsOPN\nrKeZTajYJlcJugLDzexs4EJCosTkZNhY/Ah0D8aDXsHANRbY3syugRXzXM6RcqQkIYp/M7N98Xvv\nerlcPOGvQFt5KJgFg+wmuIx8lJkNsZB3F2kAABvRSURBVJjwdyXk4V6/AfY1s/1x2f3p8uogCecA\nh0pqEQwzNfH7uD0+N52YOBBzmdiXVZecHFwrGkkHyJPYFOID+Hf4jY+ZXYvHTe6VXG+eOOQG4D5J\nPwKdzWyxmeWUNC8luwP37r5sZu+GMIVbwg8AZvYTLl2cJ+ksSVcEr8U9ZrZrkJRHUoTF7BbAG+ZZ\nrk8ENse9ZtXCNXNxD+S1kraSdEpQy5xmZieY2ayM/6ecIXhpOsKKUI+uwKBw+m3gOeCI1CZtGqUe\nn68J2e/N7NXwfYmMPKeNXImiILAVUD9ssl4A7sUTy+6TuuYfQE28r5+RtKOZvWlmB5rZ+3Jycq6T\nx98nGPBj6thwPESha7hWZvYunpjyQ0lv4Unq/mueEDBzTI44/fFY3EX4ZuxT4JTkpJl9hM9NO0q6\nRtI/wrVnW2m+mZzvV3mYzTYqDU9oAewZXo8HHge2ltQz9bHr8EpME/A5qkZYI8wKaiRZjiYBTeaR\n8HsZMDOcOhHoCOyRjIthTr8cT6A4EjjFzGaa2SFm9nDFt75yolQS37BO7wI0Doeuw+ehAam5/Avg\nTmCUpPtxo9j3ZnZBMIDnLLEvNw5ycmFVUUg6SNIneEK/G/EwhKTUWJdgfQOvyjA0GdAl7YhvkMcA\n2+ai90fSCFwSnmwWlgJ9k/Nm9iDwk6SzUh/7HM8XcSFQ08x+ih7IUiS1lHStpKHyBFXgJXJqSapt\nHiLzBu7FbZ366CigH74p/h7ASktC5eVaH0vqI68Ici7wV0mJMetm4EB52McC3CM2Dc8tgaRN8BjU\nhcAAMzsv/b251o9lIa8UcH/4TVC5FEraN2wGvsBDbA5OLYCLgJ54YsDPzOP7k+/LMyenNhKSesrD\n3+6SS+y3xxN8AmySMhhMxEPkCB7ILXHlxwLgwrThOnwmp+9RSbtIel7SX1Jz03+A4wCCsugZoIak\nvVIfnQ+cCWyPz/eYWXEwcOV0v0pqIg+XuRNXGiTlLm8FWkvaNqjgvsDz9SQhi4XABbjh+2wz65f2\nRJpZcS4aZCUdGYypf5a0Qzg8H6gmjzWfAzyCq7vSe4AmuNKrO66eiaSQdBHwsjyc9tBw+AmgW3iG\nP8MVSW2AtPG2ITAA+N7MLq3QRldSYl9uPEQjwgZCXjngWNxwsA+e1bpz8PA+hme57xQ2HC+yshqh\nCBhqZofmmoQseCPeBzbFB5GRkgaGPqoh6dTU5cOBvRKvOR5LtQyX7J5eoQ2v5Eg6EU86swzYErhE\nUlPcKNAeX4iBLy464V4gJG2NJ7G6ysxam9mT6e/Nwc1ZYzw85iEz649vHg6R1AqPw52G19kGl9rW\nwvscQHjd8p2DhzwvVz3kmcgT/b2NP/d/AfaWdFU4fTe+4MXMFuKlBhcCm4Y92BDcy7ZVkD6vkPLm\n2v0JIKkfHiZ3F+6lXQjsb2Y/4rkhhuDKLnDj9hBJjcL7XrjseXszeznpR8hthUzwap+Pb2zvw40v\n98mzhD8AlEjaL1xehCefbBY+2wzv8z+Gje5/U/en5Xi/VsOf7Rlm1t3MjgFqSjrCPO/Jc7gUH0sl\nmA4UAI+aWbPEW57Lig5JdeX5dY4DrsVVr0ODsuN9vEJQMwDzZHWd8A0ZkvrgZR37m9l+QZkQwZ9f\nSQ/j/XUs/myfJilJMtsMd7KAG7l64GHLyVhseCWB8yu67ZWN2JcbH3EBu4EwrxxwoZWWwnof9/DW\nMLMX8Myih+PS8UJ8w/Fp+OxkM8vVLO0CbjWzoWb2AL4xOzCcOx1PrlQ/vC/C+yyRP59lZoOsNFFY\nhBUem+bAb4P3+wZ809UJ9/oU4vH7rczDFz4neHvw/j0o8ZqHRXMuMxcvNXSXvFLIVFxm3wb39N4J\n/F5S97DhbQQkoSE/Wyp0wTw/R85tcsuhGnC1mR1rXv3jeFxuWw14Gt+knR2u/QKX484OG7Cnw8J3\nmkolzDm7McPnmhFm9oh5mNfnlBoJb8Of+z0lFZqHMb1OWAuY2b1mdjesSKSay/2YphpeSniQmY02\ns/vwZF5HhT5+FPhT6LOf8ee+evhskbksPOnX/NivjnmCxP/gKqKEu3GvOHj4UltJSXhIHaB2+Owi\nM3sNSuelXFZ0BJXrh8CQoCC6BzcW1jQv21odf+43DR95EvfsYmZvmdlvkv6MrMRC4P/M7GjzBMkv\n4nNQC+BdvDLYXpIahfXALErH2zfMc/JMzUbDKyGxLzcyohFhA2IhDj94HfJxL1CNcPoa3PJ2Hu5Z\n+4GYQRw8tvGhlIf2DaA4LM5ew+Mib5B0MJ6ptbG5dDyJS4+kCBuqZbhnchJAULck5Zzm4IuJ9nj4\nyLZAb0JprCAJnRO85gqy0pwh7YmFFYvej8LrYnlc3w7A1OBUfAs3JJwj6Svc6PBq5vfm8mK3HKbg\nm4kkEVot4BMzWxru16uBkyQdDdyEy+2TWMmklnme5aCEWakEaeEZnY+HfCT8gBthapiXbPw7ntX+\nX/JwuxJCicE0ufasrw7zHAavmdlMeUWbArzU6Phw/j68CsOdQfW1G+4YWKGGUWn4TXz2V+bTjLl7\nAN6XyVx1PrC7pLG4WnMVqX2u36upeeofZjY7rJc+x41ZSfnbm3AD4jWSLsAVIB+v+m2RNME481Tq\nUAmeq2d2UHc9iq/rRwclSHtK1wjRSZAi9uXGR657FdcLwaOzrJxzeeaZRLcECsKDAv7Q3C9PXrUw\nF73nSd+kj4UFcJo98Q1askg4G5c7HYNL8aOsKYN0vyYbquT+CouNWvjmdlY492IIITkfr8f7r0yP\nRK4O4En/ldWnYVPQCvgybR03s+uCPK+N5WAp1jVRllIgbCKWhNclwThTklxrZh9KGorLG+fg2ZiX\nZXxHzt2jks4DCiRdbWZLUs97caqf+wA/WGkZ4X9LegVXeE23oI6JlFLO3JTM3cVmZvKSjenN6/H4\nJndv4Ewzeznj8zl3f6YJCoxVDCgpI0s+7tiqBrwUjhWa2duSDgE6Be9lziOpnqVKraae+4Xh93JJ\nm+NjaqJwfVvSBDwHSidgsHmyukg5pOafeanDjfHxtAjAvBT2sBBW1xb4fXA25DSred5jX25ERCXC\nOiKpkUJ8vpktkyetq586nxmTuznwT0mNJY3C488wsyk5akBQavEwSCtnZE/HNrbFE1UhTwZYYF7a\n6aggbSrTeJPLpPp163T4QWpT0Qrf4H4Wjm9uZr/gqph9zEuP5mypwfTfLedsPHHfSudCP7cA3pO0\niaR7Fcqymtl8M/s8fD6Os4GwOVsbpcAhwIths7Zr8Ky9YmbXmdnpYczN5fjn5Ll+Ezeqds68JtXP\nzYHHgwf9T5J6mNkyM3vIMiqD5DoqzQReIqlWWdeEe3ILvGrIJ+HZ3zY882PM7BgL+SRydQxNk6nA\nkCdSTMoPrrjvwvkktHORPAfF1eHc4sSAkOv3qjx/yTnhdYdgLCiLdvgGbamkLpJ2NrO5ZnabmZ0R\nDQjlI6+8VDc86+lSmQCbAYlTZl9JfQHM7HEzuzFueldOwiupW+YzG/ty4yEubtedtsBvJf1G0iWE\n8mPhQVgR85h6WDYHRgD/xmtu/zMbja4shMG5maQbcQ/4ZhkLrmTwnoUnoPwXnom5MHw+Gg/KQVJv\nSXcBh5F6xlObis2BdyTtIOl1PLGagOXh/yUv4/qcIv13h9dbUmr0y+yTA4GjgP/Dc3SsVA4reDFy\n2gMJK20kSsKi4lKVVghJ1zRP7td8YJmk0cD1lEpyV1xflpcjV7CgzDKzN4BxwLGS6mZeF/q1HfBH\n4B08cdWnZXxfzvZlmtTCtz8wRtL+4X3mWqkT8Iakk4H38Kz2K1BpVZCcHEPTpIzaO0uaiIfT3BfO\nZd53A/DqIM8A3fCSmZnfl5P3asrA9TPQTtIXuPx7y4zrknXUpkC+PHThfjyfRM46B34lJ1Ka0DNd\nKhNgFzzJ9124MnZxmd+Qw4R1ZCdJz+Dr+zaZ58PL2JdVnGhE+BUoxIWHtxPxifBM3COxFS7B2wP3\nomXKdnvhmYZ3NrNbyDHKsEQ2A84A9jCzXc3sy4zNWwlev/wovArDf8yrVfxcke2u7JTRr12Bt3CJ\n/bnlWHK74JuKy4HLzeyq9II31za9aY9heNld0ghJSWmhx/C8HIXpz4SXS/FN3JFmdpa5jDQu0gIZ\nxoMakvbES2G2x/NG/DG5NLkuvN8DuBJ4xcx6WEYypVzenIV7tKmkS+Ql3K4BtsbDFjJphhvASnD1\nVnljQk6S+axK6iVpEj7vbAIcJKlauH+Vur4rcCquUBpoZremvyfXxtBMknlJnui0jqRr8Gzsw3Dj\ndnu50iDTQFMPzzMx0swON7PJcTx1UgaujrghsBEwzMyeyLguGRt/gxu5awG7mtnzGedzGpWWVJek\n6pJ+kzr9LDAr03gY7sVuuNHwPTPra14qN6cpYx3aAHeaPh2e42/K+Ezsy42AaERYS4JnoSRY2DYx\njz17EU8CkiS2Go1nbN5KUq1wbSI73cnMTg6fyylC3yUT4N6SGpqXEHoBmCtpYHJdxkdn4+qDAWZ2\nW4U2upKT2pwVS6olV8Q0MrMJuHeiT7iuejlfcbqZDTSvFFJW3+cECqqhRBkTFljf416bkZJ64uqX\nFuYS+kyVxhXmmde/UWnyybhIC2Rspq7Fk3sNN7Oj8PHyIEktwiYtWdQ1x+W6Xc3sjnAsZyXMkq6X\ndGF43STcX7NxA8FuwbD6CHCMvGxr8rk8M5sB9DazI8zsswxDeM6TPKupcXIgcJ2ZDcXDuxbhBteV\nrsczivc1rybydexXJ2Neqm6e6HQ+Xm2hKzDJPP/J7/EqNvXTzz7wfNhMrEiymsvjaXpeljRAnkNr\nf9zAegVwVjiXDltMxsq7gD5mdoGtmmsqZ0kbtsNvw1Ubd0g6SFINPJfE9hn3ZnLt3UB3M7u94ltf\nOUmt7zcJhwrwUIUkFLmwjM/EvtwIyMmNw9oiqXkYUBJP2qaSngb+KuliPMHX1UAHSc3N48qX4huO\nhWFDkchOF2Tr78gGkvollt3Qd/0lvYYnn7pU0h/ME089CQySJ1AqSS/EzGyqmV0RJ8BVsVKJ6AF4\nPd1hwKhgkPkDMFBSBzNbkvIKJd7ea8zs5nAsP/19uYCkmgpxpCkjzA3AM5Iuwye1s3Aj1/l4Gaze\nwUiTmWxtZvjOpGRjzi54M8nwmPcERuKKgzrhkrHAB7iaC7wGNGY2w8xGmdmC1P2ZkxLmwON4+cAt\n8LlnYFATjMHnnsFhEVYL2Du1oUj6812I92hCyliV/D4QOCmc7oqrZMDvzdfwsngt0k4B85jdN5Pv\nyfV+Ta+TwvtT8XCPiyT9FpcqLwMayZUdn+HVqXZLfy4YxHJyXkoI68zB8uSyiZGrJ3AhcKmZXRvu\nt2vxMNDfmivg6qe/x8yeMLMPK/4vqJwohHul7tEBkh6V9AfcaLAHXob9Ktwo2yMxcIfrk/XTk7m2\nni+L9Fo99OV/8QpfiYrrfUIYg5VWUKoffifPd+zLKk40IpSBXIJ3KZ60aotwrDFu/b0bGIpPiofj\n8ZCTcYkueHm8pbnskZTUBC8ReImk1mGw6YeHJZyAx5OeJQ9peArfVByQrfZWBYIRpl3qfQ1JxwE3\nAEPNbCAel384Xg/6cjz2FFzKvIqMMdyjObU5k9QSmIZvxmoEC/lNeD6DAUBL4PKwMRiFP+99cbVR\nw/K+N9f6sSzW4DHfPRhcHqQ01nROeL+7pG3KGi9zvV/DffgGnkvnClxldDSAeVLE74H9JFXDPY+/\nwxdwqzzvud6XCamNaZJDojrQVdKOwO1AN0mtzLOIL8aNM78Ln12llGAubnQTwubhZdxoXS0cOwLo\njs/py/D7djZukDkPGCCpH9AUDwVbhVy8V+VqlqvwfvoDcC/ed+DP9EwrVQ4mypnL8bXUbcCz8qoN\nOdd35REM2fmSDgPOTt2jR+NhYE/jKpnn8DCas4BtwrlvCGMpxDAQ8PWTPGF3uqzwTrgR9jB8DXod\nnsNoIZ5va1dJDSXdARwEufl8b6xEI0IGkgbj2UILgH5m9lE4VYgbC5riD8o/gQfM7DvgAXwSfRkv\nT3ROrg04YbBOLJM/AXcAM4HTQl9cC9QHXgaewENBLjOzj4GvgJ0VQkAqvvWVG7lE7EE8cefx4fAS\n3JNTDegYjr2AZ7bua2aXA7tJ6l9en+ZiX5vZNOBtPPb2uGAhvxTPb/IgHp60BC91iZk9jefuWIrf\nvzExVfmszmPeUdIgvK/bSdovfOZz4HgzG5+dJld6kmf0ZNxrWwLMCYtg8Dw8+wLHmNlTwNFWWoow\nQpkG2OrBU35TODQan7P64ol8P8HH2n1w2f37QItMT28uEwywf8U3sfcQSjIGeuEy5pPxuPwzwzh7\nDW6IHYpvOq43s+8rst2VnOOBDkBHM/stvqE9Qq7obA5MD+oEgsKwlpk9gv8ffAPsb6myj5EViY2L\n8XG0Ph6uBB6+cFVQvF2G5zi7JRgEj8bXAIMpHX9zmmCIuRx/zv+Mz/UXhNOFuGrrAOAS/Ll+HbgV\n3zOdDbwKfGVmd1Zw0yMbmGhEWJXZQGPzOLIfJPWV1Ad/UPoCQ4BLzGxokNtuiT9AJwInmuc9mJW9\n5lc8kvbCB+FjwqE6+L01GmgVNhPzgR2Aa83s7/jm4XeSeuMGh+GWg/ki1pJi/B57CDhO0rGAgkz5\nWkqtu9/jyZYSj/k2ZvZKFtpbaQhKmBvCM4y8PNZE3MszWFIn86R9R+NVUw7HDYRDJbWFFRLblwjG\nmlw0vqyJtfCYf4fH8gLcGK5JSre9V+ENriIECX2eeajcDXiuiEeB4ZK2xvv0FbzyAmb2bTRylVKO\nAXYpriCsJ2lAeJ6fArYDWuMhTE/h4+pZwOt45Zo5Fd3+SkwrYDMz621m9wFLrDRh50zgX8B3ZtbH\nzJ6W1B1XddyJV145zczGZKXllRB5mMxg4A7zELvaZjYFD2E4Br9fO+Jrpgbh2b8pKLieMU+OXJS9\nv6ByIWkfSf8N0npwo9Z0YJegRmiJr0cTrga2kJd1/Ba4GGgUwm5ymuBYnRbe7gIcihsShkvaFV/v\nH46rtvc0syvDuCvzMLvj8YTyV6zy5ZEqTzQiZGBm7+A1tf8pj5O+DqgTFAdf4AuKGcESPwZfcBSb\n14fO1bq7RXiIwsnBe7Mc76s+uFzs2HDdFkCTMCh1Bv4C/GJmc6IBoWxCyMEc3ENWB88IvhNwblh4\njAbaSrpN0r54TF+SyT6pq53Lm4pdcPn8SElbBYNAPtACV26cGq7rAkwK4Q3NgY+ArQAk7YZ71HJ+\nQbEa1tZjfryZ3UOpQSGyBqw0XvxSXHrbgNIklUvN7Oig6Equj0auUsoywAK8i8/liaFrLK4yHAp0\nMLOb8Ht5Z9zT+34Ft7uysxioGaTKg4CT5BVt9sI3bM/j3nEkDQVuAbqZ2cO4RPwAlZFsLVcJYTJL\n8XUUeEJPzOxevCRzO+AiXKnwMF6y8ZWo4CqXH4HtgQsknYYbBx/H11B74ErDYyV1C9dviVcImAdg\nZouS1xFmA02CY/VnfIp5C6++cAUe9v01XhVsXjBwPUsIUTaz6bEvN16iEaFsjgP2AmqaWS8z+3c4\nfjW+WL4Ff2AmmtmRQaqXswRP4t/w2NEawG24R/J7vBRRfjAcXIYvgm8E3jSzS3LY8PJreQwoNLNx\n+Ab3HDxHxyw8H0cffKN7eJDgl1XfOOcws4fwCa0RsIOkM/G451rAh3hiqi54gs/BuMe8Di4NfTp8\nzURc1fFJRbe/qrAOHvMvcty49atQaYbwc4C/BEPMIDO7ION8JLAaA+x5+NrnEaCxpAvC5nchvvn9\nLnzFzrhBcVcze7Ci21/JKcI3s/fiieja4wbbo3HJ+NX4s/8Svpk4x8wSQ8xw4N+5vm5KE8bC14BO\n8nwyJQqJAPH5q5uZjTez0/DwkO5mNjprDa7kBJXm7cDP+PP8ENAWD53tjSdFHwlcLOlZvALL69lp\nbeUmOFYflTQqHEqSxV+PK5K2xQ1c2+DrqFHAzWZ2YxaaG6lglMP7i9UiaQQuwRkYLObLk82YpDbA\nwmCVi7CiLuy3uPV3KLAn8JmZHSrpUNyrs0+UhK4bko7EjQSG19a9Bt+Y/Yxb2HcAFpnZX+SZb3M6\nW3gaSdsB/wG2xg2Ay4Ev8Zi+U4AdzeyQcA+3MLPPw+fyLSYAWickfYsrQBrgSenGJhveyLoRjDQl\nYWN2u5n9Kz7r5ROMCCZpCNAljI2n4sbsO/FY3c64NLcucJ6ZfZD6fJ7lcNLEtUFSZ3zer2Fms0LI\nSBczO1Oe/K+dmU0M18b+XA3yXDKnAFPSGzBJDwO3mdlrWWtcFURSQ/ze3BzoAeyHb3g/A143s7vD\nnN/PzJ7MXksrPyE84Wu8ZOiEEG6zQNJ9wNsWSrBL2jw6BnOLgjVfkpuY2QhJ30g6MCzWCvFMw0ns\neSSFmc2WdCtwg5ntJekzoEuQ3L+Be35LkoVdVhtbNXkaVxw8aGZdAeQ1o1vg/bsMGCYvNToje82s\nfJjZ+5JewZN5HYpLwdvjUufngc0ltTOzr4HZwSuUc5Ur1gepjULiMd9S0mgL8dJxI7HupLyTC3CP\nWsxyvRpS80xtYBtJj+AG2NNwA+w9uCT3CDNbAiuVcbN4n66ZxEBAkN/jeaPGhXNLcBVXNMiuBWY2\nKXjFR8gTKI7H5yzDw0Mjv4Jg1LoZeMTM+kl6FQ+hHYqPB/8xz38QDQhrwMx+kXQTnr+sj5WWZWyI\nJ6pOrov3aY4RlQirIXjQ7zWz6mu8OAKApO+AYWb2hKQGZjY7223aGAiL2+uA58zsxcxFmaQ6+PMc\nY8/KIFjSvwF6hcVaBzObIqnAyijbFll3osd8wyGpP9AfrxcfN2VrQfA2foUbYE8NxzoBbczs5dR1\ncaP7KwlOgjbA3sBReMLksy0m+Vtn5EmA++LqwufNE1FH1hFJ3+CJu8eEsK+dcTvhG9ltWdUjKAyP\nASbhRtgiXGU8N87tuUlUIqwGM3tYUtO4AP5VDMdjTatHA8J6pwNQI6g5Vlrsmle/iJRDsKRfj2cN\n38o88/WKuu/RQ77+iB7zDcqrluMVV9aBOfiC9zlYYSz4Eg9pWkG8R389ZrY8POvd8bwHr0JpKElW\nG1dFMU9a91bsw/XGuXgZ9jFhjo+5D9ad4XiZ9neBOy2WbMx5ohFhDZjZzdluQ1UiGl42DCG291jz\nxHWRdSCEKPWWl3n8JX1vRgPCeqcnngD0o2w3ZGMijqfrTLkG2Mj/hnllkBNghWJOcTz934nP+voh\nrknXH2b2SDAaPmBmi7Pdnkj2ieEMkUgVI3ooIpWdeI9GKhOSNokG2A1LVHNFIpFIbhGNCJFIJKeI\nsc+RSG4SjVuRSCQSiawfohEhEolEIpFIJBKJRCKRyFqRl+0GRCKRSCQSiUQikUgkEqkaRCNCJBKJ\nRCKRSCQSiUQikbUiGhEikUgkEolEIpFIJBKJrBXRiBCJRCKRSCQSiUQikUhkrYhGhEgkEolEIpFI\nJBKJRCJrRTQiRCKRSCQSiUQikUgkElkr/h9yZ17EmpnoFwAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "biotech_df.xs('score', axis=1, level=1).plot()\n",
+ "plt.gcf().set_size_inches(18, 6)\n",
+ "plt.gcf().suptitle(\"Profitability score over time\", fontsize=18);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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.\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "And consider me an OCD freak, but I just really like Celgene's distribution - it looks nice and smooth."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Summary and plans for the next post\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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."
+ ]
+ }
+ ],
+ "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.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/_notebook.md b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook.md
new file mode 100644
index 0000000..1d555c3
--- /dev/null
+++ b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook.md
@@ -0,0 +1,237 @@
+# Profitability using the Investment Formula
+
+I've previously talked about crafting an [Investment Formula][1] 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
+- $d$: The number of days it takes to turn a profit
+
+$s = \frac{1000 p}{i(l + d)} = \frac{1000 p}{m + i\cdot d}$
+
+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.
+
+# Theoretical Justification
+
+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!
+
+# Running a simulation
+
+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.
+
+[1]: https://bspeice.github.io/guaranteed-money-maker.html
+
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from Quandl import get as qget
+%matplotlib inline
+api_key = ''
+
+profitability = lambda p, i, m, d: 1000*p / (m + i*d)
+
+def is_profitable(current_price, purchase_history, open_history):
+ shares = (purchase_history / open_history).sum()
+ return current_price * shares > sum(purchase_history)
+
+def daily_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()
+ return t2 / t1
+
+def simulate_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)]) \
+ or is_profitable(open_vals[day], invested, open_vals[0:len(invested)])
+
+ while not profitable:
+ 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)]) \
+ or is_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.
+ if is_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)
+ return invested, profit
+
+def simulate_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" in ticker_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) for d in evaluation_times}
+ sim_series = pd.Series(sim)
+ result = pd.DataFrame()
+ result["profit"] = sim_series.apply(lambda x: x[1])
+ result["max"] = sim_series.apply(lambda x: max(x[0]))
+ result["days"] = sim_series.apply(lambda x: len(x[0]))
+ result["score"] = sim_series.apply(lambda x: profitability(x[1], x[0][0], max(x[0]), len(x[0])))
+ result["investments"] = sim_series.apply(lambda x: x[0])
+
+ return result
+
+def simulate_tickers(tickers):
+ from datetime import datetime
+ results = {}
+ for ticker in tickers:
+ start = datetime(2015, 1, 1)
+ results_df = simulate_ts(ticker, start, datetime(2016, 1, 1), 100, 1.01, 10)
+ results[ticker] = results_df
+
+ return pd.concat(list(results.values()), keys=list(results.keys()), axis=1)
+```
+
+# And now the interesting part
+
+Let's start looking into the data! FANG stocks have been big over the past year, let's see how they look:
+
+
+```python
+fang_df = simulate_tickers(["YAHOO/FB", "YAHOO/AAPL", "YAHOO/NFLX", "YAHOO/GOOG"])
+```
+
+
+```python
+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);
+```
+
+
+
+![png](_notebook_files/_notebook_4_0.png)
+
+
+
+
+```python
+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);
+```
+
+
+
+![png](_notebook_files/_notebook_5_0.png)
+
+
+
+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.
+
+What about FANG vs. some cyclicals?
+
+
+```python
+cyclic_df = simulate_tickers(["YAHOO/X", "YAHOO/CAT", "YAHOO/NFLX", "YAHOO/GOOG"])
+```
+
+
+```python
+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);
+```
+
+
+
+![png](_notebook_files/_notebook_8_0.png)
+
+
+
+
+```python
+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);
+```
+
+
+
+![png](_notebook_files/_notebook_9_0.png)
+
+
+
+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!
+
+
+```python
+biotech_df = simulate_tickers(['YAHOO/REGN', 'YAHOO/CELG', 'GOOG/NASDAQ_BIB', 'GOOG/NASDAQ_IBB'])
+```
+
+
+```python
+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);
+```
+
+
+
+![png](_notebook_files/_notebook_12_0.png)
+
+
+
+
+```python
+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);
+```
+
+
+
+![png](_notebook_files/_notebook_13_0.png)
+
+
+
+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.
+
+# Summary and plans for the next post
+
+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.
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_12_0.png b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_12_0.png
new file mode 100644
index 0000000..9a36597
Binary files /dev/null and b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_12_0.png differ
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_13_0.png b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_13_0.png
new file mode 100644
index 0000000..28d2423
Binary files /dev/null and b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_13_0.png differ
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_4_0.png b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_4_0.png
new file mode 100644
index 0000000..f9c5c81
Binary files /dev/null and b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_4_0.png differ
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_5_0.png b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_5_0.png
new file mode 100644
index 0000000..feef3bc
Binary files /dev/null and b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_5_0.png differ
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_8_0.png b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_8_0.png
new file mode 100644
index 0000000..8210cb3
Binary files /dev/null and b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_8_0.png differ
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_9_0.png b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_9_0.png
new file mode 100644
index 0000000..70f5140
Binary files /dev/null and b/blog/2016-02-26-profitability-using-the-investment-formula/_notebook_files/_notebook_9_0.png differ
diff --git a/blog/2016-02-26-profitability-using-the-investment-formula/index.mdx b/blog/2016-02-26-profitability-using-the-investment-formula/index.mdx
new file mode 100644
index 0000000..f658c74
--- /dev/null
+++ b/blog/2016-02-26-profitability-using-the-investment-formula/index.mdx
@@ -0,0 +1,214 @@
+---
+slug: 2016/02/profitability-using-the-investment-formula
+title: Profitability using the investment formula
+date: 2016-02-26 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+After developing a formula to guide our investing, how do we actually evaluate its performance in the real world?
+
+
+
+I've previously talked about crafting an [Investment Formula](../2016-02-03-guaranteed-money-maker/index.mdx) 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
+- $d$: The number of days it takes to turn a profit
+
+$s = \frac{1000 p}{i(l + d)} = \frac{1000 p}{m + i\cdot d}$
+
+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.
+
+## Theoretical Justification
+
+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!
+
+## Running a simulation
+
+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.
+
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from Quandl import get as qget
+%matplotlib inline
+api_key = ''
+
+profitability = lambda p, i, m, d: 1000*p / (m + i*d)
+
+def is_profitable(current_price, purchase_history, open_history):
+ shares = (purchase_history / open_history).sum()
+ return current_price * shares > sum(purchase_history)
+
+def daily_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()
+ return t2 / t1
+
+def simulate_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)]) \
+ or is_profitable(open_vals[day], invested, open_vals[0:len(invested)])
+
+ while not profitable:
+ 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)]) \
+ or is_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.
+ if is_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)
+ return invested, profit
+
+def simulate_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" in ticker_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) for d in evaluation_times}
+ sim_series = pd.Series(sim)
+ result = pd.DataFrame()
+ result["profit"] = sim_series.apply(lambda x: x[1])
+ result["max"] = sim_series.apply(lambda x: max(x[0]))
+ result["days"] = sim_series.apply(lambda x: len(x[0]))
+ result["score"] = sim_series.apply(lambda x: profitability(x[1], x[0][0], max(x[0]), len(x[0])))
+ result["investments"] = sim_series.apply(lambda x: x[0])
+
+ return result
+
+def simulate_tickers(tickers):
+ from datetime import datetime
+ results = {}
+ for ticker in tickers:
+ start = datetime(2015, 1, 1)
+ results_df = simulate_ts(ticker, start, datetime(2016, 1, 1), 100, 1.01, 10)
+ results[ticker] = results_df
+
+ return pd.concat(list(results.values()), keys=list(results.keys()), axis=1)
+```
+
+## And now the interesting part
+
+Let's start looking into the data! FANG stocks have been big over the past year, let's see how they look:
+
+
+```python
+fang_df = simulate_tickers(["YAHOO/FB", "YAHOO/AAPL", "YAHOO/NFLX", "YAHOO/GOOG"])
+```
+
+```python
+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);
+```
+
+![png](_notebook_files/_notebook_4_0.png)
+
+```python
+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);
+```
+
+![png](_notebook_files/_notebook_5_0.png)
+
+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.
+
+What about FANG vs. some cyclicals?
+
+```python
+cyclic_df = simulate_tickers(["YAHOO/X", "YAHOO/CAT", "YAHOO/NFLX", "YAHOO/GOOG"])
+```
+
+```python
+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);
+```
+
+![png](_notebook_files/_notebook_8_0.png)
+
+
+```python
+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);
+```
+
+![png](_notebook_files/_notebook_9_0.png)
+
+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!
+
+```python
+biotech_df = simulate_tickers(['YAHOO/REGN', 'YAHOO/CELG', 'GOOG/NASDAQ_BIB', 'GOOG/NASDAQ_IBB'])
+```
+
+```python
+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);
+```
+
+![png](_notebook_files/_notebook_12_0.png)
+
+```python
+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);
+```
+
+![png](_notebook_files/_notebook_13_0.png)
+
+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.
+
+## Summary and plans for the next post
+
+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/blog/2016-03-05-predicting-santander-customer-happiness/_article.md b/blog/2016-03-05-predicting-santander-customer-happiness/_article.md
new file mode 100644
index 0000000..af9c95f
--- /dev/null
+++ b/blog/2016-03-05-predicting-santander-customer-happiness/_article.md
@@ -0,0 +1,16 @@
+Title: Predicting Santander Customer Happiness
+Date: 2016-03-05
+Category: Blog
+Tags: machine learning, data science, kaggle
+Authors: Bradlee Speice
+Summary: My first real-world data challenge: predicting whether a bank's customers will be happy.
+[//]: <> "Modified: "
+
+{% notebook 2016-3-5-predicting-santander-customer-happiness.ipynb %}
+
+
+
+
diff --git a/blog/2016-03-05-predicting-santander-customer-happiness/_notebook.ipynb b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook.ipynb
new file mode 100644
index 0000000..8ba9f81
--- /dev/null
+++ b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook.ipynb
@@ -0,0 +1,436 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### My first Kaggle competition\n",
+ "\n",
+ "It's time! After embarking on a Machine Learning class this semester, and with a Saturday in which I don't have much planned, I wanted to put this class and training to work. It's my first competition submission. I want to walk you guys through how I'm approaching this problem, because I thought it would be really neat. The competition is Banco Santander's [Santander Customer Satisfaction][1] competition. It seemed like an easy enough problem I could actually make decent progress on it.\n",
+ "\n",
+ "# Data Exploration\n",
+ "\n",
+ "First up: we need to load our data and do some exploratory work. Because we're going to be using this data for model selection prior to testing, we need to make a further split. I've already gone ahead and done this work, please see the code in the [appendix below](#Appendix).\n",
+ "\n",
+ "[1]: https://www.kaggle.com/c/santander-customer-satisfaction"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline\n",
+ "\n",
+ "# Record how long it takes to run the notebook - I'm curious.\n",
+ "from datetime import datetime\n",
+ "start = datetime.now()\n",
+ "\n",
+ "dataset = pd.read_csv('split_train.csv')\n",
+ "dataset.index = dataset.ID\n",
+ "X = dataset.drop(['TARGET', 'ID', 'ID.1'], 1)\n",
+ "y = dataset.TARGET"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([0, 1], dtype=int64)"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y.unique()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "369"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(X.columns)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Okay, so there are only [two classes we're predicting][2]: 1 for unsatisfied customers, 0 for satisfied customers. I would have preferred this to be something more like a regression, or predicting multiple classes: maybe the customer isn't the most happy, but is nowhere near closing their accounts. For now though, that's just the data we're working with.\n",
+ "\n",
+ "Now, I'd like to make a scatter matrix of everything going on. Unfortunately as noted above, we have 369 different features. There's no way I can graphically make sense of that much data to start with.\n",
+ "\n",
+ "We're also not told what the data actually represents: Are these survey results? Average time between contact with a customer care person? Frequency of contacting a customer care person? The idea is that I need to reduce the number of dimensions we're predicting across.\n",
+ "\n",
+ "## Dimensionality Reduction pt. 1 - Binary Classifiers\n",
+ "\n",
+ "My first attempt to reduce the data dimensionality is to find all the binary classifiers in the dataset \\(i.e. 0 or 1 values\\) and see if any of those are good \\(or anti-good\\) predictors of the final data.\n",
+ "\n",
+ "[2]: https://www.kaggle.com/c/santander-customer-satisfaction/data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "111"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "cols = X.columns\n",
+ "b_class = []\n",
+ "for c in cols:\n",
+ " if len(X[c].unique()) == 2:\n",
+ " b_class.append(c)\n",
+ " \n",
+ "len(b_class)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "So there are 111 features in the dataset that are a binary label. Let's see if any of them are good at predicting the users satisfaction!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Accuracy
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
count
\n",
+ "
111.000000
\n",
+ "
\n",
+ "
\n",
+ "
mean
\n",
+ "
0.905159
\n",
+ "
\n",
+ "
\n",
+ "
std
\n",
+ "
0.180602
\n",
+ "
\n",
+ "
\n",
+ "
min
\n",
+ "
0.043598
\n",
+ "
\n",
+ "
\n",
+ "
25%
\n",
+ "
0.937329
\n",
+ "
\n",
+ "
\n",
+ "
50%
\n",
+ "
0.959372
\n",
+ "
\n",
+ "
\n",
+ "
75%
\n",
+ "
0.960837
\n",
+ "
\n",
+ "
\n",
+ "
max
\n",
+ "
0.960837
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Accuracy\n",
+ "count 111.000000\n",
+ "mean 0.905159\n",
+ "std 0.180602\n",
+ "min 0.043598\n",
+ "25% 0.937329\n",
+ "50% 0.959372\n",
+ "75% 0.960837\n",
+ "max 0.960837"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# First we need to `binarize` the data to 0-1; some of the labels are {0, 1},\n",
+ "# some are {0, 3}, etc.\n",
+ "from sklearn.preprocessing import binarize\n",
+ "X_bin = binarize(X[b_class])\n",
+ "\n",
+ "accuracy = [np.mean(X_bin[:,i] == y) for i in range(0, len(b_class))]\n",
+ "acc_df = pd.DataFrame({\"Accuracy\": accuracy}, index=b_class)\n",
+ "acc_df.describe()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Wow! Looks like we've got some incredibly predictive features! So much so that we should be a bit concerned. My initial guess for what's happening is that we have a sparsity issue: so many of the values are 0, and these likely happen to line up with satisfied customers.\n",
+ "\n",
+ "So the question we must now answer, which I likely should have asked long before now: What exactly is the distribution of un/satisfied customers?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Satisfied customers: 51131; Unsatisfied customers: 2083\n",
+ "Naive guess accuracy: 0.9608561656706882\n"
+ ]
+ }
+ ],
+ "source": [
+ "unsat = y[y == 1].count()\n",
+ "print(\"Satisfied customers: {}; Unsatisfied customers: {}\".format(len(y) - unsat, unsat))\n",
+ "naive_guess = np.mean(y == np.zeros(len(y)))\n",
+ "print(\"Naive guess accuracy: {}\".format(naive_guess))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This is a bit discouraging. A naive guess of \"always satisfied\" performs as well as our best individual binary classifier. What this tells me then, is that these data columns aren't incredibly helpful in prediction. I'd be interested in a polynomial expansion of this data-set, but for now, that's more computation than I want to take on.\n",
+ "\n",
+ "# Dimensionality Reduction pt. 2 - LDA\n",
+ "\n",
+ "Knowing that our naive guess performs so well is a blessing and a curse:\n",
+ "\n",
+ "- Curse: The threshold for performance is incredibly high: We can only \"improve\" over the naive guess by 4%\n",
+ "- Blessing: All the binary classification features we just discovered are worthless on their own. We can throw them out and reduce the data dimensionality from 369 to 111.\n",
+ "\n",
+ "Now, in removing these features from the dataset, I'm not saying that there is no \"information\" contained within them. There might be. But the only way we'd know is through a polynomial expansion, and I'm not going to take that on within this post.\n",
+ "\n",
+ "My initial thought for a \"next guess\" is to use the [LDA][3] model for dimensionality reduction. However, it can only reduce dimensions to $1 - p$, with $p$ being the number of classes. Since this is a binary classification, every LDA model that I try will have dimensionality one; when I actually try this, the predictor ends up being slightly less accurate than the naive guess.\n",
+ "\n",
+ "Instead, let's take a different approach to dimensionality reduction: [principle components analysis][4]. This allows us to perform the dimensionality reduction without worrying about the number of classes. Then, we'll use a [Gaussian Naive Bayes][5] model to actually do the prediction. This model is chosen simply because it doesn't take a long time to fit and compute; because PCA will take so long, I just want a prediction at the end of this. We can worry about using a more sophisticated LDA/QDA/SVM model later.\n",
+ "\n",
+ "Now into the actual process: We're going to test out PCA dimensionality reduction from 1 - 20 dimensions, and then predict using a Gaussian Naive Bayes model. The 20 dimensions upper limit was selected because the accuracy never improves after you get beyond that \\(I found out by running it myself\\). Hopefully, we'll find that we can create a model better than the naive guess.\n",
+ "\n",
+ "[3]:http://scikit-learn.org/stable/modules/lda_qda.html\n",
+ "[4]:http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html\n",
+ "[5]:http://scikit-learn.org/stable/modules/naive_bayes.html#gaussian-naive-bayes"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAFwCAYAAAC7E71AAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xl8VfWd//HXNxDWQAiJbElYpK503KZgrdpiGUH9iVor\nCCi2OFXb2hmxdWHsaEOXcURt1dZldKw74tJ26r4UjdW2bq3ISJXNDkgKsgUjsoTl+/vjhmsIWclN\n7k3yej4e55F7zvnecz73cI1vvnzP+YYYI5IkSVJHl5XuAiRJkqRMYDCWJEmSMBhLkiRJgMFYkiRJ\nAgzGkiRJEmAwliRJkoBGBOMQwp0hhA9DCPPraXNTCGFxCGFeCOGw1JYoSZIktbzG9BjfBYyra2cI\n4URgeIxxP+AC4LYU1SZJkiS1mgaDcYzxFaC8nianAvdWtX0NyA0h9E9NeZIkSVLrSMUY40Lgg2rr\nZVXbJEmSpDbDm+8kSZIkoHMKjlEGFFdbL6ratocQQkzB+SRJkqQGxRhDU9o3NhiHqqU2jwEXAg+F\nED4PbIgxflhPgU2pT2o1JSUllJSUpLsMaQ9+N5Wp/G4qk4XQpEwMNCIYhxBmA6OB/BDCcuAHQBcg\nxhhvjzE+FUI4KYSwBPgEmNbkKiRJkqQ0azAYxxinNKLNd1JTjiRJkpQe3nwnVRk9enS6S5Bq5XdT\nmcrvptqb0JpjfkMI0THGkiRJamkhhBa7+U6SJLUjQ4cOZdmyZekuQ2q2IUOG8H//938pOZY9xpIk\ndUBVvWnpLkNqtrq+y3vTY+wYY0mSJAmDsSRJkgQYjCVJkiTAYCxJktSgk046ifvuuy/dZaiFdbib\n7371K1i/Pq0l7CaE+pesrIbbNHcRdOsGRx+d7iokqfVk+s13c+bM4YYbbuCdd94hJyeHYcOGcc45\n5/Ctb30r3aWl1D333MO0adOYNWsWl1xySXJ7cXExDzzwAF/84heZOXMmP/nJT+jWrVty349+9CNO\nP/30eo9dWlrKl7/8Za655houvfTSFv0c6ZTKm++IMbbaAkQXFxcXFxeXzFgy1XXXXRcHDBgQf/3r\nX8eNGzfGGGOcN29ePPvss2NlZWWaq0utu+++O+bn58d99tkn+VljjLGoqCi+9NJLMcYYS0pK4tSp\nU5P7nn322di9e/e4evXqeo89bdq0WFBQED/72c+2TPH12L59e6udq4HveJOyaqsPpWhqgS4urbEc\nfXTk979Pfx0uLi4urbVkqoqKCn7wgx9w66238pWvfIWePXsCcOihh3LfffeRnZ0NwFNPPcURRxxB\nbm4uQ4YMYebMmcljvPTSSxQXF+923GHDhvHCCy8A8MYbbzBy5Ehyc3MZOHBgsqd269atTJ06lYKC\nAvLy8jjyyCNZs2YNAMcddxy//OUvAXj//fcZM2YMBQUF9OvXj7PPPpuKiordznX99ddz6KGHkpeX\nx+TJk6msrKzzMx900EEcddRRXH/99Y26RmPHjqVXr14sXbq0zjabNm3i0Ucf5eabb2bx4sX85S9/\n2W3/K6+8wtFHH01eXh5Dhgzh3nvvBWDLli1873vfY+jQoeTl5fHFL36RrVu3NnhNZ86cyYQJE5g6\ndSp9+vThnnvu4Y033uALX/gCeXl5FBYW8i//8i9s3749+f4FCxYwduxY8vPzGThwIP/5n//Jhx9+\nSM+ePSkvL0+2+8tf/kK/fv3YsWNHnZ83Vd9xxxhLQFERrFiR7iokSX/605+orKzklFNOqbddTk4O\n9913Hx999BFPPvkkt912G4899lhyf6hnrOBFF13E9OnT+eijj1i6dCkTJ04EEsMaKioqKCsrY/36\n9dx222107959j/fHGLniiitYtWoV7777LitWrKCkpGS3No888gjPPfccf/vb33j77be5++6766wn\nhMCPfvQjbrjhBjZs2FDv5wZ48skn2bZtGwcffHCdbX71q1/Rq1cvJkyYwNixY7nnnnuS+5YvX85J\nJ53ERRddxNq1a5k3bx6HHXYYAN/73vd46623ePXVV1m/fj2zZs0iKysrWWd9HnvsMSZOnMiGDRs4\n66yz6Ny5MzfccAPr16/nT3/6Ey+88AK33HILABs3buT444/npJNOYuXKlSxZsoQxY8bQv39/jjvu\nOB5++OHkce+//34mT55Mp06dGrw2zWUwljAYS1KmWLt2LQUFBckwBiR7Nnv06MErr7wCwBe/+EVG\njBgBwGc/+1kmTZrESy+91KhzdOnShSVLlrBu3Tp69OjBqFGjAMjOzmbdunUsWrSIEAKHH344OTk5\ne7x/+PDhjBkzhs6dO5Ofn8/FF1+8x7kvuugi+vfvT58+fRg/fjzz5s2rt6ZDDjmE448/nmuuuabW\n/Q899BB9+/YlJyeH0047jSuuuILevXvXebx7772XSZMmEUJgypQpzJkzJ9njOnv2bI4//ngmTpxI\np06dyMvL45BDDiHGyF133cVNN93EgAEDCCHw+c9/PtlL35CjjjqK8ePHA9C1a1cOP/xwRo0aRQiB\nwYMHc/755yev0xNPPMHAgQOZPn06Xbp0oWfPnowcORKAc845J3mj486dO3nwwQeZOnVqo2poLoOx\nhMFYkmqTjhu88/PzWbt2LTt37kxu+8Mf/kB5eTkFBQXJ7a+99hpf/vKX6devH3369OG//uu/WLt2\nbaPOceedd7Jw4UIOPPBAjjzySJ588kkApk6dyrhx45g0aRJFRUVcfvnltf7z/erVq5k8eTJFRUX0\n6dOHs88+e49z9+/fP/m6R48ebNy4scG6fvjDH3LrrbeyevXqPfadeeaZrF+/no0bN7J06VLuuece\n7rjjjlqPs2LFCl588UWmTJkCwCmnnMLmzZuTn/ODDz5g+PDhe7xv7dq1bN26lX333bfBWmtTc6jF\n4sWLGT9+PAMHDqRPnz58//vfT16numoAOPXUU3n33XdZtmwZzz33HH369OFzn/vcXtXUVAZjCYOx\nJNUmxuYvTXXUUUfRtWtXfvvb39ZSz6cHPOusszjttNMoKytjw4YNXHDBBcn9PXv2ZNOmTcm2O3bs\nSI4VhkSP7+zZs1mzZg2XXXYZZ5xxBps3b6Zz585ceeWVLFiwgD/+8Y888cQTybG31V1xxRVkZWWx\nYMECNmzYwP3335+ScdsHHHAAp59+Oj/5yU/qHbYwePBgTjzxRB5//PFa9997773EGJOhdPjw4Wzd\nujU5nKK4uJglS5bs8b6CggK6detW69jlhq4p7DnU4lvf+hYHHXQQS5cuZcOGDfzkJz9JXqfi4uI6\nx0h37dqViRMnct9993H//fe3Wm8xGIwlwGAsSZkiNzeXq666im9/+9v86le/YuPGjcQYmTdv3m7B\nbOPGjeTl5ZGdnc3rr7/O7Nmzk/v2339/tmzZwtNPP8327dv58Y9/vNvNbw888ECy5zI3N5cQAllZ\nWZSWlvLOO++wc+dOcnJyyM7OrnVc68cff0xOTg69evWirKyMa6+9NmWf/6qrruKuu+7aY6xx9eC9\nYsUKnnnmGT772c/Weox7772XkpIS5s2bx9tvv83bb7/No48+ypNPPkl5eTlnnXUWc+fO5dFHH2XH\njh2sX7+et99+mxAC06ZN47vf/S4rV65k586dvPrqq2zbtq3Ba1qbjz/+mN69e9OjRw/ee+89br31\n1uS+k08+mVWrVnHTTTdRWVnJxo0bef3115P7p06dyt13383jjz9uMJZam8FYkjLHpZdeyk9/+lNm\nzZrFgAEDGDBgAN/61reYNWsWX/jCFwC45ZZbuPLKK8nNzeXHP/4xZ555ZvL9vXv35pZbbuGf//mf\nKSoqolevXhQVFSX3P/PMM4wYMYLevXtz8cUX89BDD9G1a1dWrVrFGWecQW5uLiNGjOC4447j7LPP\nBnbvDf3BD37An//85+T44a9+9au71d/QTWr1GTp0KFOnTuWTTz7ZbfvDDz9M79696d27N0ceeSTH\nHnssV1111R7vf+2111i+fDnf/va36devX3IZP348++23Hw8++CDFxcU89dRTXHfddfTt25fDDz+c\n+fPnA3DdddfxD//wD4wcOZL8/HxmzJjBzp07G7ymtbnuuut44IEH6N27NxdccAGTJk1K7svJyeH5\n55/nscceY8CAAey///6UlpYm93/hC18gKyuLI444Yo8hGi2pw03wIdVm+3bo0QM++QQaeY+BJLVp\nmT7BhzRmzBjOOusszj333HrbpXKCD3uMJaBzZ9hnH1i1Kt2VSJKkN954g7feemu3fwloDQZjqYrD\nKSRJSr+vf/3rjB07lhtvvDE5wUtr6dyqZ5MymMFYkqT0q28ylJZmj7FUxWAsSVLHZjCWqhiMJUnq\n2AzGUhWDsSRJHZvBWKpiMJYkqWMzGEtVDMaSJHVsBmOpyqBBsHIl7NiR7kokSc1x9dVXc/7556e7\nDLVBBmOpSteukJcHq1enuxJJ6tiGDh1K//792bx5c3LbnXfeyXHHHdeo9//bv/0bt99+e4vU9vzz\nz/PlL3+Z3r17s88++3DEEUdw7bXXUllZ2SLnU+syGEvVOJxCktIvhMDOnTu54YYb9tieTo888ggT\nJkzg7LPPZvny5axZs4aHHnqIFStW8MEHH6S1NqWGwViqpqgIysrSXYUk6dJLL+X666+noqKi1v3T\np09n8ODB5ObmMnLkSF555ZXkvpkzZ3LOOecAcNJJJ3HLLbfs9t7DDjuM//mf/wHgvffeY+zYseTn\n53PQQQfxyCOP1FnT9773PUpKSjj33HPp06cPAPvttx833ngjw4cPB2DatGlcddVVyfe89NJLFBcX\nJ9dXrlzJGWecQb9+/Rg+fDg///nPk/veeOMNRo4cSW5uLgMHDuSSSy4BYOvWrUydOpWCggLy8vI4\n8sgjWbNmTcMXUU1mMJaqscdYkjLD5z73OUaPHs21115b6/5Ro0Yxf/58ysvLmTJlChMmTKh1OMPk\nyZOZPXt2cv2vf/0ry5cv5+STT2bTpk2MHTuWs88+m7Vr1zJnzhwuvPBC3nvvvT2Os3DhQsrKyjj9\n9NOb/Fl29XTHGBk/fjyHH344K1euZO7cudx44408//zzAFx00UVMnz6djz76iKVLlzJx4kQA7rnn\nHioqKigrK2P9+vXcdtttdO/evcl1qGEGY6kag7EkZY6ZM2fyi1/8gnXr1u2xb8qUKfTp04esrCwu\nvvhitm7dysKFC/do95WvfIW33347OdRh9uzZnH766XTu3JknnniCYcOGcc455xBC4NBDD+X000+v\ntdd47dq1AAwYMCC5bfLkyeTl5dGzZ08eeOCBBj/P66+/ztq1a/n+979Pp06dGDp0KN/4xjeYM2cO\nANnZ2SxZsoR169bRo0cPRo0aldy+bt06Fi1aRAiBww8/nJycnEZcQTWVwViqxmAsSZ8KITR7aY4R\nI0Zw8sknc/XVV++x77rrruPggw8mLy+PvLw8KioqkuG1upycHE466aRk+HzwwQc5++yzAVi2bBmv\nvvoqffv2pW/fvuTl5TF79mxWrVq1x3Hy8/OBxFCIXR588EHKy8s54ogj2NGIRxotX76csrKy3c53\n9dVXs7rqru9f/vKXLFy4kAMPPJAjjzySJ598EoCpU6cybtw4Jk2aRFFRETNmzGjU+dR0BmOpGoOx\nJH0qxtjspblKSkq44447KKt2A8jLL7/Mtddey6OPPkp5eTnl5eX07t27zvPtGk7x6quvsnXrVkaP\nHg1AcXExo0ePZv369axfv57y8nIqKiq4+eab9zjGAQccQGFhIb/+9a/rrbdnz55s2rQpuV49SBcX\nF7Pvvvvudr6PPvqIxx9/HIDhw4cze/Zs1qxZw2WXXcYZZ5zB5s2b6dy5M1deeSULFizgj3/8I48/\n/jj33ntvo6+hGs9gLFVjMJakzDJ8+HDOPPNMbrrppuS2jRs3kp2dTX5+PpWVlfzwhz/k448/rvMY\nJ510EsuWLeOqq67izDPPTG4/+eSTWbRoEffffz/bt29n27ZtvPnmm7WOMQ4hcN111zFz5kzuvPNO\nNmzYAMDixYv58MMPk+0OO+wwnnrqKcrLy1m1ahU33nhjct+oUaPo1asXs2bNYsuWLezYsYMFCxbw\n5ptvAvDAAw8ke71zc3MJIZCVlUVpaSnvvPMOO3fuJCcnh+zsbLKyjHAtwasqVVNYmHgqRQo6OSRJ\ne6nmEIyrrrqKTZs2JbePGzeOcePGsf/++zNs2DB69Oix25MfaurSpQunn346c+fOZcqUKcntOTk5\nPPfcc8yZM4dBgwYxaNAgZsyYUecziSdOnMjDDz/Mfffdx+DBg9lnn32YNGkS3/zmN5kwYQKQGPZw\nyCGHMHToUE444QQmTZqUfH9WVhZPPPEE8+bNY9iwYfTr14/zzjsv+eSNZ555hhEjRtC7d28uvvhi\nHnroIbp27cqqVas444wzyM3NZcSIERx33HFMnTp17y6u6hVS8c8cjT5ZCLE1zyftjfx8WLgQCgrS\nXYkktZwQQkqGOkjpVtd3uWp7kwa622Ms1eBwCkmSOiaDsVSDwViSpI7JYCzVUFhoMJYkqSMyGEs1\n2GMsSVLHZDCWajAYS5LUMRmMpRoMxpIkdUwGY6kGg7EkSR2TwViqYVcw9vGekiR1LAZjqYbevSEr\nCz76KN2VSJI6oldeeYWDDjoo3WV0SAZjqRYOp5Ck9Bk2bBgvvPBCusvYa1//+tfJysrizTffTG5b\nunQpWVmNi13HHHMM7777bovUtmTJEiZPnky/fv3o06cPBxxwABdddBF///vfW+R8bY3BWKqFwViS\nOpYdO3ak7FghBPLz8/n3f//3Pban05IlSzjyyCMpKipi3rx5bNiwgT/84Q8MHz6cV155Ja21ZQqD\nsVQLg7EkZYZ77rmHY489lksvvZS+ffsyfPhwnn32WQAefvhhRo4cuVv7n/3sZ5x22mkAVFZWcskl\nlzBkyBAGDhzIt7/9bbZu3QrASy+9RHFxMbNmzWLgwIGce+65rFu3jvHjx5OXl0d+fj5f+tKXksdd\nuXIlZ5xxBv369WP48OH8/Oc/r7fur33ta8yfP5+XX3651v133303Bx98ML179+Yzn/kMt99+e3Lf\nrtoAZs2axYQJE3Z770UXXcT06dMBqKio4Bvf+AaDBg2iuLiYK6+8kljHTTIzZ87kmGOO4dprr2XQ\noEEAFBQU8K//+q9MnDhxt+tdXVZWFu+//36D17S+63fNNddQVFRE7969Oeigg3jxxRfrvX7pYjCW\namEwlqTM8frrr3PQQQexbt06Lr30Us4991wAxo8fz6JFi1i6dGmy7YMPPshZZ50FwOWXX86SJUuY\nP38+S5YsoaysjB/+8IfJtqtWrWLDhg0sX76c22+/neuvv57i4mLWrVvH6tWr+Y//+A8AYoyMHz+e\nww8/nJUrVzJ37lxuvPFGnn/++Tpr7tGjB1dccQVXXHFFrfv79+/PU089RUVFBXfddRcXX3wx8+bN\nS+7f1bs8adIknn76aT755BMAdu7cySOPPJL8jF/72tfo0qUL77//Pm+99RbPP/88//3f/13rOX/3\nu9/x1a9+tf6LzZ4929XX67umdV2/RYsWcfPNN/PnP/+ZiooKnn32WYYOHdpgHelgMJZqYTCWpMwx\nZMgQzj33XEIIfO1rX2PlypWsXr2a7t27c8opp/Dggw8CsHjxYhYuXMgpp5wCwB133MHPfvYzcnNz\n6dmzJzNmzEi2BejUqRMzZ84kOzubrl27kp2dzcqVK/nb3/5Gp06dOProowF44403WLt2Ld///vfp\n1KkTQ4cO5Rvf+AZz5sypt+7zzz+f5cuXJ3u4qzvxxBOT4fDYY49l7NixtfYuDx48mCOOOILf/OY3\nAMydO5eePXsycuRIPvzwQ55++ml+9rOf0a1bNwoKCpg+ffpun7G6tWvXMmDAgOT6zTffTF5eHr16\n9eKCCy6o83NU74Gu75rWdf06depEZWUl77zzDtu3b2fw4MEMGzas3muXLgZjqRZFRVBWlu4qJCm9\nQgjNXlKhepjr3r07ABs3bgRgypQpyWA2e/ZsTjvtNLp27cqaNWvYtGkT//iP/0jfvn3p27cvJ554\nIuvWrUsea5999iE7Ozu5ftlllzF8+HDGjh3LZz7zGa655hoAli1bRllZWfI4eXl5XH311axevbre\nurt06cKVV17JlVdeuce+p59+mqOOOor8/Hzy8vJ4+umnWbt2ba3HmTx5cvIzPvjgg0yZMgWA5cuX\ns23bNgYOHJis65vf/Gadx8nPz2flypXJ9QsvvJDy8nKmT5/Otm3b6v0sQIPX9NJLL631+g0fPpwb\nbriBkpIS+vfvz5QpU3arI5MYjKVa2GMsSYmewuYuLe34449nzZo1vP3228yZMycZGgsKCujRowcL\nFixg/fr1rF+/ng0bNvBRtWdx1gzuPXv25LrrrmPp0qU89thj/PSnP+XFF1+kuLiYfffdN3mc8vJy\nPvroIx5//PEG65s2bRobNmzg17/+dXJbZWUlZ5xxBpdddhlr1qyhvLycE088sc7rNWHCBEpLSykr\nK+M3v/lN8jMWFxfTrVs31q1bl6xrw4YNzJ8/v9bjjBkzZrc6atOzZ082bdqUXF+1alXydUPXNCcn\np9brB4khIS+//DLLli0DYMaMGQ1durQwGEu1MBhLUtvQuXNnJkyYwKWXXkp5eTnHH388kAi95513\nHtOnT2fNmjUAlJWV8dxzz9V5rCeffDI5XrlXr1507tyZrKwsRo0aRa9evZg1axZbtmxhx44dLFiw\nYLfHsdWlU6dOlJSUJHtPIRGMKysrKSgoICsri6effrreugoKCvjSl77EtGnT2HfffTnggAOARE/6\n2LFjufjii/n444+JMfL+++/z+9//vtbjlJSU8PLLL3PJJZckH8+2du3a3R4Nd+ihh7JgwQLmz5/P\n1q1bmTlzZvIvEA1d07qu36JFi3jxxReprKykS5cudO/evdGPrmttmVmVlGZ5ebB1K1T9S50kqRU1\nNASj5v7Jkyczd+5cJk6cuFvguuaaa/jMZz7D5z//efr06cPYsWNZtGhRncddvHgx//RP/0SvXr04\n+uijufDCC/nSl75EVlYWTzzxBPPmzWPYsGH069eP8847j4qKikbXN3DgwOT2nJwcbrrpJiZMmEDf\nvn2ZM2cOp556ar2fecqUKcydOzd5090u9957L5WVlRx88MH07duXCRMm7NbLW91+++3Ha6+9xgcf\nfMChhx5Kbm4uxx57LIWFhfzoRz9KtrnqqqsYM2YM+++//x5PqKjvmtZ1/bZu3cqMGTPYZ599GDRo\nEGvWrOHqq6+u9/OmS2iNf+ZIniyE2Jrnk5pj//3h8ceh6i/mktSuhBBaZaiD1NLq+i5XbW/SQHd7\njKU6OJxCkqSOxWAs1cFgLElSx9KoYBxCOCGE8F4IYVEI4fJa9vcOITwWQpgXQvjfEMLXU16p1MoM\nxpIkdSwNBuMQQhbwC2AcMAKYHEI4sEazC4EFMcbDgOOA60MInVNdrNSaDMaSJHUsjekxHgUsjjEu\nizFuA+YANW+djECvqte9gHUxxu2pK1NqfQZjSZI6lsYE40Lgg2rrK6q2VfcL4OAQwt+Bt4GLUlOe\nlD6FhQZjSZI6klTdfDcOeCvGOAg4HLg5hJCTomNLaWGPsSRJHUtjxgGXAYOrrRdVbatuGnA1QIxx\naQjhb8CBwB5TwpSUlCRfjx49mtGjRzepYKm17LMPVFTAli3QrVu6q5Gk1BoyZEiDE2lIbcGQIUMA\nKC0tpbS0tFnHanCCjxBCJ2AhMAZYCbwOTI4xvlutzc3A6hjjzBBCfxKB+NAY4/oax3KCD7Upw4bB\n734Hw4enuxJJktQULTLBR4xxB/Ad4DlgATAnxvhuCOGCEML5Vc1+DHwhhDAfeB64rGYoltoih1NI\nktRxNOqRajHGZ4ADamz7r2qvV5IYZyy1KwZjSZI6Dme+k+phMJYkqeMwGEv1MBhLktRxGIylehiM\nJUnqOAzGUj0MxpIkdRwGY6keBmNJkjqOBp9jnNKT+RxjtTE7dkD37vDJJ5Cdne5qJElSY7XIc4yl\njqxTJ+jfH1auTHclkiSppRmMpQY4nEKSpI7BYCw1wGAsSVLHYDCWGmAwliSpYzAYSw0wGEuS1DEY\njKUGGIwlSeoYDMZSAwzGkiR1DAZjqQEGY0mSOgYn+JAaUFkJOTmweXPiucaSJCnzOcGH1AK6dIH8\nfPjww3RXIkmSWpLBWGqEwkKHU0iS1N4ZjKVGcJyxJEntn8FYagSDsSRJ7Z/BWGoEg7EkSe2fwVhq\nBIOxJEntn8FYagSDsSRJ7Z/BWGoEg7EkSe2fE3xIjbB5M/Tpk/iZ5V8nJUnKeE7wIbWQ7t2hVy9Y\nuzbdlUiSpJZiMJYayeEUkiS1bwZjqZEMxpIktW8GY6mRDMaSJLVvBmOpkYqKoKws3VVIkqSWYjCW\nGskeY0mS2jeDsdRIBmNJkto3g7HUSAZjSZLaN4Ox1EiFhYlg7Bw1kiS1TwZjqZF69YLsbNiwId2V\nSJKklmAwlprA4RSSJLVfBmOpCQzGkiS1XwZjqQkMxpIktV8GY6kJDMaSJLVfBmOpCXY9mUKSJLU/\nBmOpCewxliSp/TIYS01gMJYkqf0yGEtNYDCWJKn9MhhLTdCnD2zfDhUV6a5EkiSlmsFYaoIQEr3G\nZWXprkSSJKWawVhqIodTSJLUPhmMpSYyGEuS1D4ZjKUmMhhLktQ+GYylJjIYS5LUPhmMpSYyGEuS\n1D4ZjKUmMhhLktQ+GYylJvJxbZIktU8GY6mJCgpg40bYvDndlUiSpFQyGEtNFAIUFtprLElSe2Mw\nlvaC44wlSWp/DMbSXjAYS5LU/hiMpb1gMJYkqf0xGEt7wWAsSVL7YzCW9oLBWJKk9qdRwTiEcEII\n4b0QwqIQwuV1tBkdQngrhPBOCOHF1JYpZRaDsSRJ7U/nhhqEELKAXwBjgL8Db4QQfhtjfK9am1zg\nZmBsjLEshFDQUgVLmcBgLElS+9OYHuNRwOIY47IY4zZgDnBqjTZTgF/FGMsAYoxrU1umlFn69YP1\n66GyMt3G3FU+AAATCUlEQVSVSJKkVGlMMC4EPqi2vqJqW3X7A31DCC+GEN4IIUxNVYFSJurUCQYM\ngL//Pd2VSJKkVGlwKEUTjnME8GWgJ/CnEMKfYoxLUnR8KePsGk4xdGi6K5EkSanQmGBcBgyutl5U\nta26FcDaGOMWYEsI4ffAocAewbikpCT5evTo0YwePbppFUsZwnHGkiRljtLSUkpLS5t1jBBjrL9B\nCJ2AhSRuvlsJvA5MjjG+W63NgcDPgROArsBrwJkxxr/WOFZs6HxSW/Hd78KgQXDJJemuRJIk1RRC\nIMYYmvKeBnuMY4w7QgjfAZ4jMSb5zhjjuyGECxK74+0xxvdCCM8C84EdwO01Q7HU3hQVwfLl6a5C\nkiSlSoM9xik9mT3GakcefjixPPpouiuRJEk17U2PsTPfSXvJMcaSJLUvBmNpLxmMJUlqXxxKIe2l\nbdugZ0/YtAk6p+rBh5IkKSUcSiG1ouxsKCiAVavSXYkkSUoFg7HUDA6nkCSp/TAYS81QVARlNae7\nkSRJbZLBWGoGe4wlSWo/DMZSMxiMJUlqPwzGUjMYjCVJaj8MxlIzGIwlSWo/DMZSMxiMJUlqP5zg\nQ2qGLVsgNxc2b4Ys/5opSVLGcIIPqZV165YIxmvWpLsSSZLUXAZjqZkcTiFJUvtgMJaayWAsSVL7\nYDCWmqmw0GAsSVJ7YDCWmskeY0mS2geDsdRMBmNJktoHg7HUTAZjSZLaB4Ox1EwGY0mS2gcn+JCa\naeNG2Gcf2LQJQpMeIy5JklqKE3xIaZCTk5joY/36dFciSZKaw2AspYDDKSRJavsMxlIKGIwlSWr7\nDMZSChiMJUlq+wzGUgoYjCVJavsMxlIKGIwlSWr7DMZSChiMJUlq+wzGUgoUFUFZWbqrkCRJzWEw\nllLAHmNJkto+g7GUAr17Q4xQUZHuSiRJ0t4yGEspEIK9xpIktXUGYylFDMaSJLVtBmMpRQzGkiS1\nbQZjKUUMxpIktW0GYylFDMaSJLVtBmMpRQzGkiS1bQZjKUUKCw3GkiS1ZQZjKUXsMZYkqW0zGEsp\nkp8PmzbBJ5+kuxJJkrQ3DMZSiuya5KOsLN2VSJKkvWEwllLI4RSSJLVdBmMphQzGkiS1XQZjKYUM\nxpIktV0GYymFDMaSJLVdBmMphQzGkiS1XQZjKYUMxpIktV0GYymFDMaSJLVdIcbYeicLIbbm+aTW\ntnMndOsGFRWJn5IkKT1CCMQYQ1PeY4+xlEJZWTBoEPz97+muRJIkNZXBWEoxZ7+TJKltMhhLKeY4\nY0mS2iaDsZRiBmNJktomg7GUYgZjSZLaJoOxlGIGY0mS2iaDsZRiBmNJktomg7GUYgZjSZLaJif4\nkFJs+3bo0QM++QSys9NdjSRJHVOLTfARQjghhPBeCGFRCOHyetqNDCFsCyGc3pQipPakc2fo1w9W\nrUp3JZIkqSkaDMYhhCzgF8A4YAQwOYRwYB3t/hN4NtVFSm2NwykkSWp7GtNjPApYHGNcFmPcBswB\nTq2l3b8AjwKrU1if1CYVFhqMJUlqaxoTjAuBD6qtr6jalhRCGAScFmO8FWjSWA6pPbLHWJKktidV\nT6W4Aag+9thwrA7NYCxJUtvTuRFtyoDB1daLqrZV9zlgTgghAAXAiSGEbTHGx2oerKSkJPl69OjR\njB49uoklS5mvqAjefDPdVUiS1HGUlpZSWlrarGM0+Li2EEInYCEwBlgJvA5MjjG+W0f7u4DHY4y/\nrmWfj2tTh/DyyzBjBvzhD+muRJKkjmlvHtfWYI9xjHFHCOE7wHMkhl7cGWN8N4RwQWJ3vL3mW5pS\ngNQeOZRCkqS2xwk+pBawdSv06gWbN0OnTumuRpKkjqfFJviQ1DRdu0JeHqz24YWSJLUZBmOphTic\nQpKktsVgLLUQg7EkSW2LwVhqIQZjSZLaFoOx1EIMxpIktS0GY6mFFBVBWc2pcCRJUsYyGEstxB5j\nSZLaFoOx1EIMxpIktS1O8CG1kE2bID8/8TM06fHikiSpuZzgQ8ogPXoklnXr0l2JJElqDIOx1IIc\nTiFJUtthMJZakMFYkqS2w2AstSCDsSRJbYfBWGpBBmNJktoOg7HUggzGkiS1HQZjqQUVFhqMJUlq\nKwzGUguyx1iSpLbDYCy1oF3B2HltJEnKfAZjqQX17g1ZWfDRR+muRJIkNcRgLLUwh1NIktQ2GIyl\nFmYwliSpbTAYSy3MYCxJUttgMJZamMFYkqS2wWAstTCDsSRJbYPBWGphBmNJktoGg7HUwgzGkiS1\nDQZjqYUZjCVJahsMxlILy8uDykrYuDHdlUiSpPoYjKUWFkKi17isLN2VSJKk+hiMpVbgcApJkjKf\nwVhqBQZjSZIyn8FYagUGY0mSMp/BWGoFBmNJkjKfwVhqBQZjSZIyn8FYagUGY0mSMp/BWGoFBmNJ\nkjKfwVhqBQUF8PHHsGVLuiuRJEl1MRhLrSArCwYOdJIPSZIymcFYaiUOp5AkKbMZjKVWYjCWJCmz\nGYylVmIwliQpsxmMpVZiMJYkKbMZjKVWYjCWJCmzGYylVmIwliQpsxmMpVZiMJYkKbOFGGPrnSyE\n2JrnkzLJjh3QvTts3AhduqS7GkmS2rcQAjHG0JT32GMstZJOnaB/f1i5Mt2VSJKk2hiMpVbkcApJ\nkjKXwVhqRQZjSZIyl8FYakVFRVBWlu4qJElSbQzGUiuyx1iSpMxlMJZakcFYkqTMZTCWWpHBWJKk\nzGUwllqRwViSpMzlBB9SK6qshJwc2Lw58VxjSZLUMpzgQ8pwXbpAfj58+GG6K5EkSTUZjKVW5nAK\nSZIyk8FYamUGY0mSMlOjgnEI4YQQwnshhEUhhMtr2T8lhPB21fJKCOEfUl+q1D4YjCVJykwNBuMQ\nQhbwC2AcMAKYHEI4sEaz94EvxhgPBX4M3JHqQqX2orDQYCxJUiZqTI/xKGBxjHFZjHEbMAc4tXqD\nGOOrMcaPqlZfBQpTW6bUfthjLElSZmpMMC4EPqi2voL6g+83gKebU5TUnhmMJUnKTJ1TebAQwnHA\nNOCYVB5Xak8MxpIkZabGBOMyYHC19aKqbbsJIRwC3A6cEGMsr+tgJSUlydejR49m9OjRjSxVah8K\nC6GsDHbuhCyfCyNJUkqUlpZSWlrarGM0OPNdCKETsBAYA6wEXgcmxxjfrdZmMDAXmBpjfLWeYznz\nnQQUFMBf/wr9+qW7EkmS2qe9mfmuwR7jGOOOEMJ3gOdIjEm+M8b4bgjhgsTueDtwJdAXuCWEEIBt\nMcZRTf8IUsewaziFwViSpMzRYI9xSk9mj7EEwMknw/nnwymnpLsSSZLap73pMXaEo5QG3oAnSVLm\nMRhLaWAwliQp8xiMpTQwGEuSlHkMxlIaGIwlSco8BmMpDYqKEs8yliRJmcNgLKVBYWGix9iHtEiS\nlDkMxlIa9OoF2dmwYUO6K5EkSbsYjKU0cZyxJEmZxWAspYnBWJKkzGIwltLEYCxJUmYxGEtpYjCW\nJCmzGIylNDEYS5KUWQzGUpoYjCVJyiwGYylNDMaSJGUWg7GUJrsm+ZAkSZnBYCylSZ8+sH07VFSk\nuxJJkgQGYyltQkgMpygrS3clkiQJDMZSWjnOWJKkzGEwltLIYCxJUuYwGEtpZDCWJClzGIylNDIY\nS5KUOQzGUhoZjCVJyhwGYymNDMaSJGUOg7GURgZjSZIyh8FYSqOCAvjkE9i0Kd2VSJIkg7GURiEk\npoZ2kg9JktLPYCylmbPfSZKUGQzGUpo5zliSpMxgMJbSzGAsSVJmMBhLaWYwliQpM3ROdwFSR1dU\nBHPnprsKZaqtW2HDBujUac8lK+vTnyGku9LmixF27EgsO3d++rrmsm1bYtm+/dPXNdcb83pv3rN9\ne2KJ8dOaq9ef7tfpOB8kvn+7voO7XqdiW2PbVq+r+s/atjVm3968vyF1/Tda33+7e7Mv04+X6QzG\nUprZYyxIBOCFC2HBgsTy178mfi5fDr167R4Ma4bGGHcPyXUF6L3ZVn17Y0JrXfsas73656irns6d\nE0t2dmKp63V9++p63aNH49rtqm2X6gEgE1639vlqhsTqS2O3Nff91cNyzZ97u29v3l+XusJzfaF6\nb/Zl+vFa23PPNf09BmMpzQzGHUtlZSIA7wq+u5Zly2DYMDj4YBgxAiZNSvzcbz/o0qX+Y+7qaa0t\nfDZnW/XtO3c2HFobG7Dbe8+3pLYrxFaM9SGE2Jrnk9qCHTuge3fYuLHhAKS2o7ISFi/ePfwuWAB/\n+xsMHZoIvdWX/ff3z1+SUimEQIyxSX/dNhhLGWDIEHjppURgUtuybVvtAfj99xN/rtXD78EHwwEH\nQNeu6a5aktq/vQnGDqWQMsCu4RQG48y1bRssWVJ7AC4u/nQIxFe+Av/+74kA3K1buquWJDWFwVjK\nAIWFjjPOJNu3wxtvwAsvwP/+byIAL1mS+HPa1ft76qlwxRWJANy9e7orliSlgsFYygDegJd+H3wA\nzz6bWObOTfyZHH88/L//B5ddBgcemHhqgSSp/TIYSxmgqCjxWC61ns2b4fe//zQMf/gh/NM/JYLw\njTfCoEHprlCS1NoMxlIGKCqCP/4x3VW0bzHCu+8mQvAzzySu96GHwrhxcNdd8I//mHhkmCSp4zIY\nSxnAoRQto7wcfve7T3uFs7ISQfiCC+Chh6BPn3RXKEnKJAZjKQMYjFNjx47ETXPPPJMIwgsWwDHH\nJMLwJZckbpRzAglJUl18jrGUAbZtg549YdOmxNSzarwVK3a/aW7QIDjhhEQYPuYYH5kmSR2VE3xI\nbdigQfD664neY9Vt82Z4+eVPe4VXrUo8PWLcOBg7NvFINUmSnOBDasN2DacwGO+u+k1zzz4Lf/gD\nHHKIN81JklLPYCxliI48zjhG2LIlMZTkk08Sy4IFn4bhEBJB+LzzYM4cb5qTJLUMg7GUITI5GMcI\nlZWJwFo9vDZ3fdfrTZsgOzsxzrpHj8TPYcMSYfi7301MruFNc5KklmYwljJEcTHceiuUlibWY0ws\n1V83tJ6Ktjt3Jsbx1gyvWVm7B9ddS13rubmJcdONad+jhzcdSpLSz5vvpAyxfn0iFIfw6QK1v07V\nvtraZmVB9+57Btns7Bb9+JIkpZRPpZAkSZJoI0+lCA4UlCRJUgZq9WBsj7EkSZJa2t50xma1QB2S\nJElSm2MwliRJkjAYS5IkSYDBWJIkSQIMxpIkSRJgMJYkSZKARgbjEMIJIYT3QgiLQgiX19HmphDC\n4hDCvBDCYaktU5IkSWpZDQbjEEIW8AtgHDACmBxCOLBGmxOB4THG/YALgNtaoFapRZWWlqa7BKlW\nfjeVqfxuqr1pTI/xKGBxjHFZjHEbMAc4tUabU4F7AWKMrwG5IYT+Ka1UamH+glem8rupTOV3U+1N\nY4JxIfBBtfUVVdvqa1NWSxtJkiQpY3nznSRJkgSEGGP9DUL4PFASYzyhan0GEGOM11RrcxvwYozx\noar194AvxRg/rHGs+k8mSZIkpUiMMTSlfedGtHkD+EwIYQiwEpgETK7R5jHgQuChqiC9oWYo3pvi\nJEmSpNbSYDCOMe4IIXwHeI7E0Is7Y4zvhhAuSOyOt8cYnwohnBRCWAJ8Akxr2bIlSZKk1GpwKIUk\nSZLUEbTazXeNmSRESocQwv+FEN4OIbwVQng93fWoYwsh3BlC+DCEML/atrwQwnMhhIUhhGdDCLnp\nrFEdUx3fzR+EEFaEEP5StZyQzhrVMYUQikIIL4QQFoQQ/jeE8K9V25v8u7NVgnFjJgmR0mgnMDrG\neHiMcVS6i1GHdxeJ35XVzQB+F2M8AHgB+LdWr0qq/bsJ8NMY4xFVyzOtXZQEbAe+G2McARwFXFiV\nM5v8u7O1eowbM0mIlC4BH12oDBFjfAUor7H5VOCeqtf3AKe1alESdX43IfE7VEqbGOOqGOO8qtcb\ngXeBIvbid2drhYHGTBIipUsEng8hvBFCOC/dxUi16LfrST8xxlVAvzTXI1X3nRDCvBDCfzvMR+kW\nQhgKHAa8CvRv6u9Oe8kkODrGeARwEol/fjkm3QVJDfCuaWWKW4B9Y4yHAauAn6a5HnVgIYQc4FHg\noqqe45q/Kxv83dlawbgMGFxtvahqm5R2McaVVT/XAL8hMfRHyiQfhhD6A4QQBgCr01yPBCR+b8ZP\nH291BzAynfWo4wohdCYRiu+LMf62anOTf3e2VjBOThISQuhCYpKQx1rp3FKdQgg9qv6GSQihJzAW\neCe9VUkEdh+3+Rjw9arXXwN+W/MNUivZ7btZFTZ2OR1/fyp9fgn8NcZ4Y7VtTf7d2WrPMa56hMuN\nfDpJyH+2yomleoQQhpHoJY4kJrx5wO+m0imEMBsYDeQDHwI/AP4HeAQoBpYBE2OMG9JVozqmOr6b\nx5EYz7kT+D/ggtpmvpVaUgjhaOD3wP+S+P95BK4AXgcepgm/O53gQ5IkScKb7yRJkiTAYCxJkiQB\nBmNJkiQJMBhLkiRJgMFYkiRJAgzGkiRJEmAwliRJkgCDsSRJkgTA/wdTBj79QR260QAAAABJRU5E\nrkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from sklearn.naive_bayes import GaussianNB\n",
+ "from sklearn.decomposition import PCA\n",
+ "\n",
+ "X_no_bin = X.drop(b_class, 1)\n",
+ "\n",
+ "def evaluate_gnb(dims):\n",
+ " pca = PCA(n_components=dims)\n",
+ " X_xform = pca.fit_transform(X_no_bin)\n",
+ " \n",
+ " gnb = GaussianNB()\n",
+ " gnb.fit(X_xform, y)\n",
+ " return gnb.score(X_xform, y)\n",
+ "\n",
+ "dim_range = np.arange(1, 21)\n",
+ "plt.plot(dim_range, [evaluate_gnb(dim) for dim in dim_range], label=\"Gaussian NB Accuracy\")\n",
+ "plt.axhline(naive_guess, label=\"Naive Guess\", c='k')\n",
+ "plt.axhline(1 - naive_guess, label=\"Inverse Naive Guess\", c='k')\n",
+ "plt.gcf().set_size_inches(12, 6)\n",
+ "plt.legend();"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\\*\\*sigh...\\*\\* After all the effort and computational power, we're still at square one: we have yet to beat out the naive guess threshold. With PCA in play we end up performing terribly, but not terribly enough that we can guess against ourselves.\n",
+ "\n",
+ "Let's try one last-ditch attempt using the entire data set:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAFwCAYAAAC7E71AAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def evaluate_gnb_full(dims):\n",
+ " pca = PCA(n_components=dims)\n",
+ " X_xform = pca.fit_transform(X)\n",
+ " \n",
+ " gnb = GaussianNB()\n",
+ " gnb.fit(X_xform, y)\n",
+ " return gnb.score(X_xform, y)\n",
+ "\n",
+ "dim_range = np.arange(1, 21)\n",
+ "plt.plot(dim_range, [evaluate_gnb(dim) for dim in dim_range], label=\"Gaussian NB Accuracy\")\n",
+ "plt.axhline(naive_guess, label=\"Naive Guess\", c='k')\n",
+ "plt.axhline(1 - naive_guess, label=\"Inverse Naive Guess\", c='k')\n",
+ "plt.gcf().set_size_inches(12, 6)\n",
+ "plt.legend();"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Nothing. It is interesting to note that the graphs are almost exactly the same: This would imply again that the variables we removed earlier (all the binary classifiers) indeed have almost no predictive power. It seems this problem is high-dimensional, but with almost no data that can actually inform our decisions.\n",
+ "\n",
+ "# Summary for Day 1\n",
+ "\n",
+ "After spending a couple hours with this dataset, there seems to be a fundamental issue in play: We have very high-dimensional data, and it has no bearing on our ability to actually predict customer satisfaction. This can be a huge issue: it implies that **no matter what model we use, we fundamentally can't perform well.** I'm sure most of this is because I'm not an experienced data scientist. Even so, we have yet to develop a strategy that can actually beat out the village idiot; **so far, the bank is best off just assuming all its customers are satisfied.** Hopefully more to come soon."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Running time: 0:00:58.715714\n"
+ ]
+ }
+ ],
+ "source": [
+ "end = datetime.now()\n",
+ "print(\"Running time: {}\".format(end - start))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Appendix\n",
+ "\n",
+ "Code used to split the initial training data:\n",
+ "\n",
+ "```python\n",
+ "from sklearn.cross_validation import train_test_split\n",
+ "data = pd.read_csv('train.csv')\n",
+ "data.index = data.ID\n",
+ "\n",
+ "data_train, data_validate = train_test_split(\n",
+ " data, train_size=.7)\n",
+ "\n",
+ "data_train.to_csv('split_train.csv')\n",
+ "data_validate.to_csv('split_validate.csv')\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.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-03-05-predicting-santander-customer-happiness/_notebook.md b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook.md
new file mode 100644
index 0000000..2afcdd9
--- /dev/null
+++ b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook.md
@@ -0,0 +1,269 @@
+### My first Kaggle competition
+
+It's time! After embarking on a Machine Learning class this semester, and with a Saturday in which I don't have much planned, I wanted to put this class and training to work. It's my first competition submission. I want to walk you guys through how I'm approaching this problem, because I thought it would be really neat. The competition is Banco Santander's [Santander Customer Satisfaction][1] competition. It seemed like an easy enough problem I could actually make decent progress on it.
+
+# Data Exploration
+
+First up: we need to load our data and do some exploratory work. Because we're going to be using this data for model selection prior to testing, we need to make a further split. I've already gone ahead and done this work, please see the code in the [appendix below](#Appendix).
+
+[1]: https://www.kaggle.com/c/santander-customer-satisfaction
+
+
+```python
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+# Record how long it takes to run the notebook - I'm curious.
+from datetime import datetime
+start = datetime.now()
+
+dataset = pd.read_csv('split_train.csv')
+dataset.index = dataset.ID
+X = dataset.drop(['TARGET', 'ID', 'ID.1'], 1)
+y = dataset.TARGET
+```
+
+
+```python
+y.unique()
+```
+
+
+
+
+ array([0, 1], dtype=int64)
+
+
+
+
+```python
+len(X.columns)
+```
+
+
+
+
+ 369
+
+
+
+Okay, so there are only [two classes we're predicting][2]: 1 for unsatisfied customers, 0 for satisfied customers. I would have preferred this to be something more like a regression, or predicting multiple classes: maybe the customer isn't the most happy, but is nowhere near closing their accounts. For now though, that's just the data we're working with.
+
+Now, I'd like to make a scatter matrix of everything going on. Unfortunately as noted above, we have 369 different features. There's no way I can graphically make sense of that much data to start with.
+
+We're also not told what the data actually represents: Are these survey results? Average time between contact with a customer care person? Frequency of contacting a customer care person? The idea is that I need to reduce the number of dimensions we're predicting across.
+
+## Dimensionality Reduction pt. 1 - Binary Classifiers
+
+My first attempt to reduce the data dimensionality is to find all the binary classifiers in the dataset \(i.e. 0 or 1 values\) and see if any of those are good \(or anti-good\) predictors of the final data.
+
+[2]: https://www.kaggle.com/c/santander-customer-satisfaction/data
+
+
+```python
+cols = X.columns
+b_class = []
+for c in cols:
+ if len(X[c].unique()) == 2:
+ b_class.append(c)
+
+len(b_class)
+```
+
+
+
+
+ 111
+
+
+
+So there are 111 features in the dataset that are a binary label. Let's see if any of them are good at predicting the users satisfaction!
+
+
+```python
+# First we need to `binarize` the data to 0-1; some of the labels are {0, 1},
+# some are {0, 3}, etc.
+from sklearn.preprocessing import binarize
+X_bin = binarize(X[b_class])
+
+accuracy = [np.mean(X_bin[:,i] == y) for i in range(0, len(b_class))]
+acc_df = pd.DataFrame({"Accuracy": accuracy}, index=b_class)
+acc_df.describe()
+```
+
+
+
+
+
+
+
+
+
+
Accuracy
+
+
+
+
+
count
+
111.000000
+
+
+
mean
+
0.905159
+
+
+
std
+
0.180602
+
+
+
min
+
0.043598
+
+
+
25%
+
0.937329
+
+
+
50%
+
0.959372
+
+
+
75%
+
0.960837
+
+
+
max
+
0.960837
+
+
+
+
+
+
+
+Wow! Looks like we've got some incredibly predictive features! So much so that we should be a bit concerned. My initial guess for what's happening is that we have a sparsity issue: so many of the values are 0, and these likely happen to line up with satisfied customers.
+
+So the question we must now answer, which I likely should have asked long before now: What exactly is the distribution of un/satisfied customers?
+
+
+```python
+unsat = y[y == 1].count()
+print("Satisfied customers: {}; Unsatisfied customers: {}".format(len(y) - unsat, unsat))
+naive_guess = np.mean(y == np.zeros(len(y)))
+print("Naive guess accuracy: {}".format(naive_guess))
+```
+
+ Satisfied customers: 51131; Unsatisfied customers: 2083
+ Naive guess accuracy: 0.9608561656706882
+
+
+This is a bit discouraging. A naive guess of "always satisfied" performs as well as our best individual binary classifier. What this tells me then, is that these data columns aren't incredibly helpful in prediction. I'd be interested in a polynomial expansion of this data-set, but for now, that's more computation than I want to take on.
+
+# Dimensionality Reduction pt. 2 - LDA
+
+Knowing that our naive guess performs so well is a blessing and a curse:
+
+- Curse: The threshold for performance is incredibly high: We can only "improve" over the naive guess by 4%
+- Blessing: All the binary classification features we just discovered are worthless on their own. We can throw them out and reduce the data dimensionality from 369 to 111.
+
+Now, in removing these features from the dataset, I'm not saying that there is no "information" contained within them. There might be. But the only way we'd know is through a polynomial expansion, and I'm not going to take that on within this post.
+
+My initial thought for a "next guess" is to use the [LDA][3] model for dimensionality reduction. However, it can only reduce dimensions to $1 - p$, with $p$ being the number of classes. Since this is a binary classification, every LDA model that I try will have dimensionality one; when I actually try this, the predictor ends up being slightly less accurate than the naive guess.
+
+Instead, let's take a different approach to dimensionality reduction: [principle components analysis][4]. This allows us to perform the dimensionality reduction without worrying about the number of classes. Then, we'll use a [Gaussian Naive Bayes][5] model to actually do the prediction. This model is chosen simply because it doesn't take a long time to fit and compute; because PCA will take so long, I just want a prediction at the end of this. We can worry about using a more sophisticated LDA/QDA/SVM model later.
+
+Now into the actual process: We're going to test out PCA dimensionality reduction from 1 - 20 dimensions, and then predict using a Gaussian Naive Bayes model. The 20 dimensions upper limit was selected because the accuracy never improves after you get beyond that \(I found out by running it myself\). Hopefully, we'll find that we can create a model better than the naive guess.
+
+[3]:http://scikit-learn.org/stable/modules/lda_qda.html
+[4]:http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html
+[5]:http://scikit-learn.org/stable/modules/naive_bayes.html#gaussian-naive-bayes
+
+
+```python
+from sklearn.naive_bayes import GaussianNB
+from sklearn.decomposition import PCA
+
+X_no_bin = X.drop(b_class, 1)
+
+def evaluate_gnb(dims):
+ pca = PCA(n_components=dims)
+ X_xform = pca.fit_transform(X_no_bin)
+
+ gnb = GaussianNB()
+ gnb.fit(X_xform, y)
+ return gnb.score(X_xform, y)
+
+dim_range = np.arange(1, 21)
+plt.plot(dim_range, [evaluate_gnb(dim) for dim in dim_range], label="Gaussian NB Accuracy")
+plt.axhline(naive_guess, label="Naive Guess", c='k')
+plt.axhline(1 - naive_guess, label="Inverse Naive Guess", c='k')
+plt.gcf().set_size_inches(12, 6)
+plt.legend();
+```
+
+
+
+![png](_notebook_files/_notebook_11_0.png)
+
+
+
+\*\*sigh...\*\* After all the effort and computational power, we're still at square one: we have yet to beat out the naive guess threshold. With PCA in play we end up performing terribly, but not terribly enough that we can guess against ourselves.
+
+Let's try one last-ditch attempt using the entire data set:
+
+
+```python
+def evaluate_gnb_full(dims):
+ pca = PCA(n_components=dims)
+ X_xform = pca.fit_transform(X)
+
+ gnb = GaussianNB()
+ gnb.fit(X_xform, y)
+ return gnb.score(X_xform, y)
+
+dim_range = np.arange(1, 21)
+plt.plot(dim_range, [evaluate_gnb(dim) for dim in dim_range], label="Gaussian NB Accuracy")
+plt.axhline(naive_guess, label="Naive Guess", c='k')
+plt.axhline(1 - naive_guess, label="Inverse Naive Guess", c='k')
+plt.gcf().set_size_inches(12, 6)
+plt.legend();
+```
+
+
+
+![png](_notebook_files/_notebook_13_0.png)
+
+
+
+Nothing. It is interesting to note that the graphs are almost exactly the same: This would imply again that the variables we removed earlier (all the binary classifiers) indeed have almost no predictive power. It seems this problem is high-dimensional, but with almost no data that can actually inform our decisions.
+
+# Summary for Day 1
+
+After spending a couple hours with this dataset, there seems to be a fundamental issue in play: We have very high-dimensional data, and it has no bearing on our ability to actually predict customer satisfaction. This can be a huge issue: it implies that **no matter what model we use, we fundamentally can't perform well.** I'm sure most of this is because I'm not an experienced data scientist. Even so, we have yet to develop a strategy that can actually beat out the village idiot; **so far, the bank is best off just assuming all its customers are satisfied.** Hopefully more to come soon.
+
+
+```python
+end = datetime.now()
+print("Running time: {}".format(end - start))
+```
+
+ Running time: 0:00:58.715714
+
+
+# Appendix
+
+Code used to split the initial training data:
+
+```python
+from sklearn.cross_validation import train_test_split
+data = pd.read_csv('train.csv')
+data.index = data.ID
+
+data_train, data_validate = train_test_split(
+ data, train_size=.7)
+
+data_train.to_csv('split_train.csv')
+data_validate.to_csv('split_validate.csv')
+```
diff --git a/blog/2016-03-05-predicting-santander-customer-happiness/_notebook_files/_notebook_11_0.png b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook_files/_notebook_11_0.png
new file mode 100644
index 0000000..6843a02
Binary files /dev/null and b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook_files/_notebook_11_0.png differ
diff --git a/blog/2016-03-05-predicting-santander-customer-happiness/_notebook_files/_notebook_13_0.png b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook_files/_notebook_13_0.png
new file mode 100644
index 0000000..6843a02
Binary files /dev/null and b/blog/2016-03-05-predicting-santander-customer-happiness/_notebook_files/_notebook_13_0.png differ
diff --git a/blog/2016-03-05-predicting-santander-customer-happiness/index.mdx b/blog/2016-03-05-predicting-santander-customer-happiness/index.mdx
new file mode 100644
index 0000000..10db523
--- /dev/null
+++ b/blog/2016-03-05-predicting-santander-customer-happiness/index.mdx
@@ -0,0 +1,256 @@
+---
+slug: 2016/03/predicting-santander-customer-happiness
+title: Predicting Santander customer happiness
+date: 2016-03-05 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+My first Kaggle competition.
+
+
+
+It's time! After embarking on a Machine Learning class this semester, and with a Saturday in which I don't have much planned, I wanted to put this class and training to work. It's my first competition submission. I want to walk you guys through how I'm approaching this problem, because I thought it would be really neat. The competition is Banco Santander's [Santander Customer Satisfaction][1] competition. It seemed like an easy enough problem I could actually make decent progress on it.
+
+## Data Exploration
+
+First up: we need to load our data and do some exploratory work. Because we're going to be using this data for model selection prior to testing, we need to make a further split. I've already gone ahead and done this work, please see the code in the [appendix below](#appendix).
+
+[1]: https://www.kaggle.com/c/santander-customer-satisfaction
+
+
+```python
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+# Record how long it takes to run the notebook - I'm curious.
+from datetime import datetime
+start = datetime.now()
+
+dataset = pd.read_csv('split_train.csv')
+dataset.index = dataset.ID
+X = dataset.drop(['TARGET', 'ID', 'ID.1'], 1)
+y = dataset.TARGET
+```
+
+
+```python
+y.unique()
+```
+
+```
+ array([0, 1], dtype=int64)
+```
+
+```python
+len(X.columns)
+```
+
+```
+ 369
+```
+
+Okay, so there are only [two classes we're predicting][2]: 1 for unsatisfied customers, 0 for satisfied customers. I would have preferred this to be something more like a regression, or predicting multiple classes: maybe the customer isn't the most happy, but is nowhere near closing their accounts. For now though, that's just the data we're working with.
+
+Now, I'd like to make a scatter matrix of everything going on. Unfortunately as noted above, we have 369 different features. There's no way I can graphically make sense of that much data to start with.
+
+We're also not told what the data actually represents: Are these survey results? Average time between contact with a customer care person? Frequency of contacting a customer care person? The idea is that I need to reduce the number of dimensions we're predicting across.
+
+### Dimensionality Reduction pt. 1 - Binary Classifiers
+
+My first attempt to reduce the data dimensionality is to find all the binary classifiers in the dataset \(i.e. 0 or 1 values\) and see if any of those are good \(or anti-good\) predictors of the final data.
+
+[2]: https://www.kaggle.com/c/santander-customer-satisfaction/data
+
+
+```python
+cols = X.columns
+b_class = []
+for c in cols:
+ if len(X[c].unique()) == 2:
+ b_class.append(c)
+
+len(b_class)
+```
+
+```
+ 111
+```
+
+So there are 111 features in the dataset that are a binary label. Let's see if any of them are good at predicting the users satisfaction!
+
+```python
+# First we need to `binarize` the data to 0-1; some of the labels are {0, 1},
+# some are {0, 3}, etc.
+from sklearn.preprocessing import binarize
+X_bin = binarize(X[b_class])
+
+accuracy = [np.mean(X_bin[:,i] == y) for i in range(0, len(b_class))]
+acc_df = pd.DataFrame({"Accuracy": accuracy}, index=b_class)
+acc_df.describe()
+```
+
+
+
+
+
+
+
Accuracy
+
+
+
+
+
count
+
111.000000
+
+
+
mean
+
0.905159
+
+
+
std
+
0.180602
+
+
+
min
+
0.043598
+
+
+
25%
+
0.937329
+
+
+
50%
+
0.959372
+
+
+
75%
+
0.960837
+
+
+
max
+
0.960837
+
+
+
+
+
+Wow! Looks like we've got some incredibly predictive features! So much so that we should be a bit concerned. My initial guess for what's happening is that we have a sparsity issue: so many of the values are 0, and these likely happen to line up with satisfied customers.
+
+So the question we must now answer, which I likely should have asked long before now: What exactly is the distribution of un/satisfied customers?
+
+```python
+unsat = y[y == 1].count()
+print("Satisfied customers: {}; Unsatisfied customers: {}".format(len(y) - unsat, unsat))
+naive_guess = np.mean(y == np.zeros(len(y)))
+print("Naive guess accuracy: {}".format(naive_guess))
+```
+
+```
+ Satisfied customers: 51131; Unsatisfied customers: 2083
+ Naive guess accuracy: 0.9608561656706882
+```
+
+This is a bit discouraging. A naive guess of "always satisfied" performs as well as our best individual binary classifier. What this tells me then, is that these data columns aren't incredibly helpful in prediction. I'd be interested in a polynomial expansion of this data-set, but for now, that's more computation than I want to take on.
+
+### Dimensionality Reduction pt. 2 - LDA
+
+Knowing that our naive guess performs so well is a blessing and a curse:
+
+- Curse: The threshold for performance is incredibly high: We can only "improve" over the naive guess by 4%
+- Blessing: All the binary classification features we just discovered are worthless on their own. We can throw them out and reduce the data dimensionality from 369 to 111.
+
+Now, in removing these features from the dataset, I'm not saying that there is no "information" contained within them. There might be. But the only way we'd know is through a polynomial expansion, and I'm not going to take that on within this post.
+
+My initial thought for a "next guess" is to use the [LDA][3] model for dimensionality reduction. However, it can only reduce dimensions to $1 - p$, with $p$ being the number of classes. Since this is a binary classification, every LDA model that I try will have dimensionality one; when I actually try this, the predictor ends up being slightly less accurate than the naive guess.
+
+Instead, let's take a different approach to dimensionality reduction: [principle components analysis][4]. This allows us to perform the dimensionality reduction without worrying about the number of classes. Then, we'll use a [Gaussian Naive Bayes][5] model to actually do the prediction. This model is chosen simply because it doesn't take a long time to fit and compute; because PCA will take so long, I just want a prediction at the end of this. We can worry about using a more sophisticated LDA/QDA/SVM model later.
+
+Now into the actual process: We're going to test out PCA dimensionality reduction from 1 - 20 dimensions, and then predict using a Gaussian Naive Bayes model. The 20 dimensions upper limit was selected because the accuracy never improves after you get beyond that \(I found out by running it myself\). Hopefully, we'll find that we can create a model better than the naive guess.
+
+[3]:http://scikit-learn.org/stable/modules/lda_qda.html
+[4]:http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html
+[5]:http://scikit-learn.org/stable/modules/naive_bayes.html#gaussian-naive-bayes
+
+
+```python
+from sklearn.naive_bayes import GaussianNB
+from sklearn.decomposition import PCA
+
+X_no_bin = X.drop(b_class, 1)
+
+def evaluate_gnb(dims):
+ pca = PCA(n_components=dims)
+ X_xform = pca.fit_transform(X_no_bin)
+
+ gnb = GaussianNB()
+ gnb.fit(X_xform, y)
+ return gnb.score(X_xform, y)
+
+dim_range = np.arange(1, 21)
+plt.plot(dim_range, [evaluate_gnb(dim) for dim in dim_range], label="Gaussian NB Accuracy")
+plt.axhline(naive_guess, label="Naive Guess", c='k')
+plt.axhline(1 - naive_guess, label="Inverse Naive Guess", c='k')
+plt.gcf().set_size_inches(12, 6)
+plt.legend();
+```
+
+![png](_notebook_files/_notebook_11_0.png)
+
+**sigh...** After all the effort and computational power, we're still at square one: we have yet to beat out the naive guess threshold. With PCA in play we end up performing terribly, but not terribly enough that we can guess against ourselves.
+
+Let's try one last-ditch attempt using the entire data set:
+
+
+```python
+def evaluate_gnb_full(dims):
+ pca = PCA(n_components=dims)
+ X_xform = pca.fit_transform(X)
+
+ gnb = GaussianNB()
+ gnb.fit(X_xform, y)
+ return gnb.score(X_xform, y)
+
+dim_range = np.arange(1, 21)
+plt.plot(dim_range, [evaluate_gnb(dim) for dim in dim_range], label="Gaussian NB Accuracy")
+plt.axhline(naive_guess, label="Naive Guess", c='k')
+plt.axhline(1 - naive_guess, label="Inverse Naive Guess", c='k')
+plt.gcf().set_size_inches(12, 6)
+plt.legend();
+```
+
+![png](_notebook_files/_notebook_13_0.png)
+
+Nothing. It is interesting to note that the graphs are almost exactly the same: This would imply again that the variables we removed earlier (all the binary classifiers) indeed have almost no predictive power. It seems this problem is high-dimensional, but with almost no data that can actually inform our decisions.
+
+## Summary for Day 1
+
+After spending a couple hours with this dataset, there seems to be a fundamental issue in play: We have very high-dimensional data, and it has no bearing on our ability to actually predict customer satisfaction. This can be a huge issue: it implies that **no matter what model we use, we fundamentally can't perform well.** I'm sure most of this is because I'm not an experienced data scientist. Even so, we have yet to develop a strategy that can actually beat out the village idiot; **so far, the bank is best off just assuming all its customers are satisfied.** Hopefully more to come soon.
+
+
+```python
+end = datetime.now()
+print("Running time: {}".format(end - start))
+```
+
+```
+ Running time: 0:00:58.715714
+```
+
+## Appendix
+
+Code used to split the initial training data:
+
+```python
+from sklearn.cross_validation import train_test_split
+data = pd.read_csv('train.csv')
+data.index = data.ID
+
+data_train, data_validate = train_test_split(
+ data, train_size=.7)
+
+data_train.to_csv('split_train.csv')
+data_validate.to_csv('split_validate.csv')
+```
\ No newline at end of file
diff --git a/blog/2016-03-28-tweet-like-me/_article.md b/blog/2016-03-28-tweet-like-me/_article.md
new file mode 100644
index 0000000..0438b5c
--- /dev/null
+++ b/blog/2016-03-28-tweet-like-me/_article.md
@@ -0,0 +1,14 @@
+Title: Tweet Like Me
+Date: 2016-03-28
+Category: Blog
+Tags: twitter, MCMC
+Authors: Bradlee Speice
+Summary: In which I try to create a robot that will tweet like I tweet.
+[//]: <> "Modified: "
+
+{% notebook 2016-3-28-tweet-like-me.ipynb %}
+
+
+
\ No newline at end of file
diff --git a/blog/2016-03-28-tweet-like-me/_notebook.ipynb b/blog/2016-03-28-tweet-like-me/_notebook.ipynb
new file mode 100644
index 0000000..734c4ab
--- /dev/null
+++ b/blog/2016-03-28-tweet-like-me/_notebook.ipynb
@@ -0,0 +1,461 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "An experiment in creating a robot that will imitate me on Twitter.\n",
+ "\n",
+ "---\n",
+ "\n",
+ "So, I'm taking a Machine Learning course this semester in school, and one of the topics we keep coming back to is natural language processing and the 'bag of words' data structure. That is, given a sentence:\n",
+ "\n",
+ "`How much wood would a woodchuck chuck if a woodchuck could chuck wood?`\n",
+ "\n",
+ "We can represent that sentence as the following list:\n",
+ "\n",
+ "`{\n",
+ " How: 1\n",
+ " much: 1\n",
+ " wood: 2\n",
+ " would: 2\n",
+ " a: 2\n",
+ " woodchuck: 2\n",
+ " chuck: 2\n",
+ " if: 1\n",
+ "}`\n",
+ "\n",
+ "Ignoring *where* the words happened, we're just interested in how *often* the words occurred. That got me thinking: I wonder what would happen if I built a robot that just imitated how often I said things? It's dangerous territory when computer scientists ask \"what if,\" but I got curious enough I wanted to follow through.\n",
+ "\n",
+ "## The Objective\n",
+ "\n",
+ "Given an input list of Tweets, build up the following things:\n",
+ "\n",
+ "1. The distribution of starting words; since there are no \"prior\" words to go from, we need to treat this as a special case.\n",
+ "2. The distribution of words given a previous word; for example, every time I use the word `woodchuck` in the example sentence, there is a 50% chance it is followed by `chuck` and a 50% chance it is followed by `could`. I need this distribution for all words.\n",
+ "3. The distribution of quantity of hashtags; Do I most often use just one? Two? Do they follow something like a Poisson distribution?\n",
+ "4. Distribution of hashtags; Given a number of hashtags, what is the actual content? I'll treat hashtags as separate from the content of a tweet.\n",
+ "\n",
+ "## The Data\n",
+ "\n",
+ "I'm using as input my tweet history. I don't really use Twitter anymore, but it seems like a fun use of the dataset. I'd like to eventually build this to a point where I can imitate anyone on Twitter using their last 100 tweets or so, but I'll start with this as example code.\n",
+ "\n",
+ "## The Algorithm\n",
+ "\n",
+ "I'll be using the [NLTK](http://www.nltk.org/) library for doing a lot of the heavy lifting. First, let's import the data:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "\n",
+ "tweets = pd.read_csv('tweets.csv')\n",
+ "text = tweets.text\n",
+ "\n",
+ "# Don't include tweets in reply to or mentioning people\n",
+ "replies = text.str.contains('@')\n",
+ "text_norep = text.loc[~replies]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And now that we've got data, let's start crunching. First, tokenize and build out the distribution of first word:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "from nltk.tokenize import TweetTokenizer\n",
+ "tknzr = TweetTokenizer()\n",
+ "tokens = text_norep.map(tknzr.tokenize)\n",
+ "\n",
+ "first_words = tokens.map(lambda x: x[0])\n",
+ "first_words_alpha = first_words[first_words.str.isalpha()]\n",
+ "first_word_dist = first_words_alpha.value_counts() / len(first_words_alpha)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Next, we need to build out the conditional distributions. That is, what is the probability of the next word given the current word is $X$? This one is a bit more involved. First, find all unique words, and then find what words proceed them. This can probably be done in a more efficient manner than I'm currently doing here, but we'll ignore that for the moment."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "from functools import reduce\n",
+ "\n",
+ "# Get all possible words\n",
+ "all_words = reduce(lambda x, y: x+y, tokens, [])\n",
+ "unique_words = set(all_words)\n",
+ "actual_words = set([x if x[0] != '.' else None for x in unique_words])\n",
+ "\n",
+ "word_dist = {}\n",
+ "for word in iter(actual_words):\n",
+ " indices = [i for i, j in enumerate(all_words) if j == word]\n",
+ " proceeding = [all_words[i+1] for i in indices]\n",
+ " word_dist[word] = proceeding"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that we've got the tweet analysis done, it's time for the fun part: hashtags! Let's count how many hashtags are in each tweet, I want to get a sense of the distribution."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEACAYAAABGYoqtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline\n",
+ "\n",
+ "hashtags = text_norep.str.count('#')\n",
+ "bins = hashtags.unique().max()\n",
+ "hashtags.plot(kind='hist', bins=bins)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "That looks like a Poisson distribution, kind of as I expected. I'm guessing my number of hashtags per tweet is $\\sim Poi(1)$, but let's actually find the [most likely estimator](https://en.wikipedia.org/wiki/Poisson_distribution#Maximum_likelihood) which in this case is just $\\bar{\\lambda}$:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.870236869207003"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "mle = hashtags.mean()\n",
+ "mle"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Pretty close! So we can now simulate how many hashtags are in a tweet. Let's also find what hashtags are actually used:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "603"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "hashtags = [x for x in all_words if x[0] == '#']\n",
+ "n_hashtags = len(hashtags)\n",
+ "\n",
+ "unique_hashtags = list(set([x for x in unique_words if x[0] == '#']))\n",
+ "hashtag_dist = pd.DataFrame({'hashtags': unique_hashtags,\n",
+ " 'prob': [all_words.count(h) / n_hashtags\n",
+ " for h in unique_hashtags]})\n",
+ "len(hashtag_dist)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Turns out I have used 603 different hashtags during my time on Twitter. That means I was using a unique hashtag for about every third tweet.\n",
+ "\n",
+ "In better news though, we now have all the data we need to go about actually constructing tweets! The process will happen in a few steps:\n",
+ "\n",
+ "1. Randomly select what the first word will be.\n",
+ "2. Randomly select the number of hashtags for this tweet, and then select the actual hashtags.\n",
+ "3. Fill in the remaining space of 140 characters with random words taken from my tweets.\n",
+ "\n",
+ "And hopefully, we won't have anything too crazy come out the other end. The way we do the selection follows a [Multinomial Distribution](https://en.wikipedia.org/wiki/Multinomial_distribution): given a lot of different values with specific probability, pick one. Let's give a quick example:\n",
+ "\n",
+ "```\n",
+ "x: .33\n",
+ "y: .5\n",
+ "z: .17\n",
+ "```\n",
+ "\n",
+ "That is, I pick `x` with probability 33%, `y` with probability 50%, and so on. In context of our sentence construction, I've built out the probabilities of specific words already - now I just need to simulate that distribution. Time for the engine to actually be developed!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "\n",
+ "def multinom_sim(n, vals, probs):\n",
+ " occurrences = np.random.multinomial(n, probs)\n",
+ " results = occurrences * vals\n",
+ " return ' '.join(results[results != ''])\n",
+ "\n",
+ "def sim_n_hashtags(hashtag_freq):\n",
+ " return np.random.poisson(hashtag_freq)\n",
+ "\n",
+ "def sim_hashtags(n, hashtag_dist):\n",
+ " return multinom_sim(n, hashtag_dist.hashtags, hashtag_dist.prob)\n",
+ "\n",
+ "def sim_first_word(first_word_dist):\n",
+ " probs = np.float64(first_word_dist.values)\n",
+ " return multinom_sim(1, first_word_dist.reset_index()['index'], probs)\n",
+ "\n",
+ "def sim_next_word(current, word_dist):\n",
+ " dist = pd.Series(word_dist[current])\n",
+ " probs = np.ones(len(dist)) / len(dist)\n",
+ " return multinom_sim(1, dist, probs)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Pulling it all together\n",
+ "\n",
+ "I've now built out all the code I need to actually simulate a sentence written by me. Let's try doing an example with five words and a single hashtag:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'My first all-nighter of friends #oldschool'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "first = sim_first_word(first_word_dist)\n",
+ "second = sim_next_word(first, word_dist)\n",
+ "third = sim_next_word(second, word_dist)\n",
+ "fourth = sim_next_word(third, word_dist)\n",
+ "fifth = sim_next_word(fourth, word_dist)\n",
+ "hashtag = sim_hashtags(1, hashtag_dist)\n",
+ "\n",
+ "' '.join((first, second, third, fourth, fifth, hashtag))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's go ahead and put everything together! We're going to simulate a first word, simulate the hashtags, and then simulate to fill the gap until we've either taken up all the space or reached a period."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "def simulate_tweet():\n",
+ " chars_remaining = 140\n",
+ " first = sim_first_word(first_word_dist)\n",
+ " n_hash = sim_n_hashtags(mle)\n",
+ " hashtags = sim_hashtags(n_hash, hashtag_dist)\n",
+ " \n",
+ " chars_remaining -= len(first) + len(hashtags)\n",
+ " \n",
+ " tweet = first\n",
+ " current = first\n",
+ " while chars_remaining > len(tweet) + len(hashtags) and current[0] != '.' and current[0] != '!':\n",
+ " current = sim_next_word(current, word_dist)\n",
+ " tweet += ' ' + current\n",
+ " \n",
+ " tweet = tweet[:-2] + tweet[-1]\n",
+ " \n",
+ " return ' '.join((tweet, hashtags)).strip()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## The results\n",
+ "\n",
+ "And now for something completely different: twenty random tweets dreamed up by my computer and my Twitter data. Here you go:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Also , I'm at 8 this morning. #thursdaysgohard #ornot\n",
+ "\n",
+ "Turns out of us breathe the code will want to my undergraduate career is becoming more night trying ? Religion is now as a chane #HYPE\n",
+ "\n",
+ "You know what recursion is to review the UNCC. #ornot\n",
+ "\n",
+ "There are really sore 3 bonfires in my first writing the library ground floor if awesome. #realtalk #impressed\n",
+ "\n",
+ "So we can make it out there's nothing but I'm not let us so hot I could think I may be good. #SwingDance\n",
+ "\n",
+ "Happy Christmas , at Harris Teeter to be be godly or Roman Catholic ). #4b392b#4b392b #Isaiah26\n",
+ "\n",
+ "For context , I in the most decisive factor of the same for homework. #accomplishment\n",
+ "\n",
+ "Freaking done. #loveyouall\n",
+ "\n",
+ "New blog post : Don't jump in a quiz in with a knife fight. #haskell #earlybirthday\n",
+ "\n",
+ "God shows me legitimately want to get some food and one day.\n",
+ "\n",
+ "Stormed the queen city. #mindblown\n",
+ "\n",
+ "The day of a cold at least outside right before the semester ..\n",
+ "\n",
+ "Finished with the way back. #winners\n",
+ "\n",
+ "Waking up , OJ , I feel like Nick Jonas today.\n",
+ "\n",
+ "First draft of so hard drive. #humansvszombies\n",
+ "\n",
+ "Eric Whitacre is the wise creation.\n",
+ "\n",
+ "Ethics paper first , music in close to everyone who just be posting up with my sin , and Jerry Springr #TheLittleThings\n",
+ "\n",
+ "Love that you know enough time I've eaten at 8 PM. #deepthoughts #stillblownaway\n",
+ "\n",
+ "Lead. #ThinkingTooMuch #Christmas\n",
+ "\n",
+ "Aamazing conference when you married #DepartmentOfRedundancyDepartment Yep , but there's a legitimate challenge.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(0, 20):\n",
+ " print(simulate_tweet())\n",
+ " print()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "...Which all ended up being a whole lot more nonsensical than I had hoped for. There are some good ones, so I'll call that an accomplishment! I was banking on grammar not being an issue: since my tweets use impeccable grammar, the program modeled off them should have pretty good grammar as well. There are going to be some hilarious edge cases (I'm looking at you, `Ethics paper first, music in close to everyone`) that make no sense, and some hilarious edge cases (`Waking up, OJ, I feel like Nick Jonas today`) that make me feel like I should have a Twitter rap career. On the whole though, the structure came out alright.\n",
+ "\n",
+ "## Moving on from here\n",
+ "\n",
+ "During class we also talked about an interesting idea: trying to analyze corporate documents and corporate speech. I'd be interested to know what this analysis applied to something like a couple of bank press releases could do. By any means, the code needs some work to clean it up before I get that far.\n",
+ "\n",
+ "## For further reading\n",
+ "\n",
+ "I'm pretty confident I re-invented a couple wheels along the way - what I'm doing feels a lot like what [Markov Chain Monte Carlo](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo) is intended to do. But I've never worked explicitly with that before, so more research is needed."
+ ]
+ }
+ ],
+ "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.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-03-28-tweet-like-me/_notebook.md b/blog/2016-03-28-tweet-like-me/_notebook.md
new file mode 100644
index 0000000..0b58372
--- /dev/null
+++ b/blog/2016-03-28-tweet-like-me/_notebook.md
@@ -0,0 +1,295 @@
+An experiment in creating a robot that will imitate me on Twitter.
+
+---
+
+So, I'm taking a Machine Learning course this semester in school, and one of the topics we keep coming back to is natural language processing and the 'bag of words' data structure. That is, given a sentence:
+
+`How much wood would a woodchuck chuck if a woodchuck could chuck wood?`
+
+We can represent that sentence as the following list:
+
+`{
+ How: 1
+ much: 1
+ wood: 2
+ would: 2
+ a: 2
+ woodchuck: 2
+ chuck: 2
+ if: 1
+}`
+
+Ignoring *where* the words happened, we're just interested in how *often* the words occurred. That got me thinking: I wonder what would happen if I built a robot that just imitated how often I said things? It's dangerous territory when computer scientists ask "what if," but I got curious enough I wanted to follow through.
+
+## The Objective
+
+Given an input list of Tweets, build up the following things:
+
+1. The distribution of starting words; since there are no "prior" words to go from, we need to treat this as a special case.
+2. The distribution of words given a previous word; for example, every time I use the word `woodchuck` in the example sentence, there is a 50% chance it is followed by `chuck` and a 50% chance it is followed by `could`. I need this distribution for all words.
+3. The distribution of quantity of hashtags; Do I most often use just one? Two? Do they follow something like a Poisson distribution?
+4. Distribution of hashtags; Given a number of hashtags, what is the actual content? I'll treat hashtags as separate from the content of a tweet.
+
+## The Data
+
+I'm using as input my tweet history. I don't really use Twitter anymore, but it seems like a fun use of the dataset. I'd like to eventually build this to a point where I can imitate anyone on Twitter using their last 100 tweets or so, but I'll start with this as example code.
+
+## The Algorithm
+
+I'll be using the [NLTK](http://www.nltk.org/) library for doing a lot of the heavy lifting. First, let's import the data:
+
+
+```python
+import pandas as pd
+
+tweets = pd.read_csv('tweets.csv')
+text = tweets.text
+
+# Don't include tweets in reply to or mentioning people
+replies = text.str.contains('@')
+text_norep = text.loc[~replies]
+```
+
+And now that we've got data, let's start crunching. First, tokenize and build out the distribution of first word:
+
+
+```python
+from nltk.tokenize import TweetTokenizer
+tknzr = TweetTokenizer()
+tokens = text_norep.map(tknzr.tokenize)
+
+first_words = tokens.map(lambda x: x[0])
+first_words_alpha = first_words[first_words.str.isalpha()]
+first_word_dist = first_words_alpha.value_counts() / len(first_words_alpha)
+```
+
+Next, we need to build out the conditional distributions. That is, what is the probability of the next word given the current word is $X$? This one is a bit more involved. First, find all unique words, and then find what words proceed them. This can probably be done in a more efficient manner than I'm currently doing here, but we'll ignore that for the moment.
+
+
+```python
+from functools import reduce
+
+# Get all possible words
+all_words = reduce(lambda x, y: x+y, tokens, [])
+unique_words = set(all_words)
+actual_words = set([x if x[0] != '.' else None for x in unique_words])
+
+word_dist = {}
+for word in iter(actual_words):
+ indices = [i for i, j in enumerate(all_words) if j == word]
+ proceeding = [all_words[i+1] for i in indices]
+ word_dist[word] = proceeding
+```
+
+Now that we've got the tweet analysis done, it's time for the fun part: hashtags! Let's count how many hashtags are in each tweet, I want to get a sense of the distribution.
+
+
+```python
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+hashtags = text_norep.str.count('#')
+bins = hashtags.unique().max()
+hashtags.plot(kind='hist', bins=bins)
+```
+
+
+
+
+
+
+
+
+
+
+![png](_notebook_files/_notebook_7_1.png)
+
+
+
+That looks like a Poisson distribution, kind of as I expected. I'm guessing my number of hashtags per tweet is $\sim Poi(1)$, but let's actually find the [most likely estimator](https://en.wikipedia.org/wiki/Poisson_distribution#Maximum_likelihood) which in this case is just $\bar{\lambda}$:
+
+
+```python
+mle = hashtags.mean()
+mle
+```
+
+
+
+
+ 0.870236869207003
+
+
+
+Pretty close! So we can now simulate how many hashtags are in a tweet. Let's also find what hashtags are actually used:
+
+
+```python
+hashtags = [x for x in all_words if x[0] == '#']
+n_hashtags = len(hashtags)
+
+unique_hashtags = list(set([x for x in unique_words if x[0] == '#']))
+hashtag_dist = pd.DataFrame({'hashtags': unique_hashtags,
+ 'prob': [all_words.count(h) / n_hashtags
+ for h in unique_hashtags]})
+len(hashtag_dist)
+```
+
+
+
+
+ 603
+
+
+
+Turns out I have used 603 different hashtags during my time on Twitter. That means I was using a unique hashtag for about every third tweet.
+
+In better news though, we now have all the data we need to go about actually constructing tweets! The process will happen in a few steps:
+
+1. Randomly select what the first word will be.
+2. Randomly select the number of hashtags for this tweet, and then select the actual hashtags.
+3. Fill in the remaining space of 140 characters with random words taken from my tweets.
+
+And hopefully, we won't have anything too crazy come out the other end. The way we do the selection follows a [Multinomial Distribution](https://en.wikipedia.org/wiki/Multinomial_distribution): given a lot of different values with specific probability, pick one. Let's give a quick example:
+
+```
+x: .33
+y: .5
+z: .17
+```
+
+That is, I pick `x` with probability 33%, `y` with probability 50%, and so on. In context of our sentence construction, I've built out the probabilities of specific words already - now I just need to simulate that distribution. Time for the engine to actually be developed!
+
+
+```python
+import numpy as np
+
+def multinom_sim(n, vals, probs):
+ occurrences = np.random.multinomial(n, probs)
+ results = occurrences * vals
+ return ' '.join(results[results != ''])
+
+def sim_n_hashtags(hashtag_freq):
+ return np.random.poisson(hashtag_freq)
+
+def sim_hashtags(n, hashtag_dist):
+ return multinom_sim(n, hashtag_dist.hashtags, hashtag_dist.prob)
+
+def sim_first_word(first_word_dist):
+ probs = np.float64(first_word_dist.values)
+ return multinom_sim(1, first_word_dist.reset_index()['index'], probs)
+
+def sim_next_word(current, word_dist):
+ dist = pd.Series(word_dist[current])
+ probs = np.ones(len(dist)) / len(dist)
+ return multinom_sim(1, dist, probs)
+```
+
+## Pulling it all together
+
+I've now built out all the code I need to actually simulate a sentence written by me. Let's try doing an example with five words and a single hashtag:
+
+
+```python
+first = sim_first_word(first_word_dist)
+second = sim_next_word(first, word_dist)
+third = sim_next_word(second, word_dist)
+fourth = sim_next_word(third, word_dist)
+fifth = sim_next_word(fourth, word_dist)
+hashtag = sim_hashtags(1, hashtag_dist)
+
+' '.join((first, second, third, fourth, fifth, hashtag))
+```
+
+
+
+
+ 'My first all-nighter of friends #oldschool'
+
+
+
+Let's go ahead and put everything together! We're going to simulate a first word, simulate the hashtags, and then simulate to fill the gap until we've either taken up all the space or reached a period.
+
+
+```python
+def simulate_tweet():
+ chars_remaining = 140
+ first = sim_first_word(first_word_dist)
+ n_hash = sim_n_hashtags(mle)
+ hashtags = sim_hashtags(n_hash, hashtag_dist)
+
+ chars_remaining -= len(first) + len(hashtags)
+
+ tweet = first
+ current = first
+ while chars_remaining > len(tweet) + len(hashtags) and current[0] != '.' and current[0] != '!':
+ current = sim_next_word(current, word_dist)
+ tweet += ' ' + current
+
+ tweet = tweet[:-2] + tweet[-1]
+
+ return ' '.join((tweet, hashtags)).strip()
+```
+
+## The results
+
+And now for something completely different: twenty random tweets dreamed up by my computer and my Twitter data. Here you go:
+
+
+```python
+for i in range(0, 20):
+ print(simulate_tweet())
+ print()
+```
+
+ Also , I'm at 8 this morning. #thursdaysgohard #ornot
+
+ Turns out of us breathe the code will want to my undergraduate career is becoming more night trying ? Religion is now as a chane #HYPE
+
+ You know what recursion is to review the UNCC. #ornot
+
+ There are really sore 3 bonfires in my first writing the library ground floor if awesome. #realtalk #impressed
+
+ So we can make it out there's nothing but I'm not let us so hot I could think I may be good. #SwingDance
+
+ Happy Christmas , at Harris Teeter to be be godly or Roman Catholic ). #4b392b#4b392b #Isaiah26
+
+ For context , I in the most decisive factor of the same for homework. #accomplishment
+
+ Freaking done. #loveyouall
+
+ New blog post : Don't jump in a quiz in with a knife fight. #haskell #earlybirthday
+
+ God shows me legitimately want to get some food and one day.
+
+ Stormed the queen city. #mindblown
+
+ The day of a cold at least outside right before the semester ..
+
+ Finished with the way back. #winners
+
+ Waking up , OJ , I feel like Nick Jonas today.
+
+ First draft of so hard drive. #humansvszombies
+
+ Eric Whitacre is the wise creation.
+
+ Ethics paper first , music in close to everyone who just be posting up with my sin , and Jerry Springr #TheLittleThings
+
+ Love that you know enough time I've eaten at 8 PM. #deepthoughts #stillblownaway
+
+ Lead. #ThinkingTooMuch #Christmas
+
+ Aamazing conference when you married #DepartmentOfRedundancyDepartment Yep , but there's a legitimate challenge.
+
+
+
+...Which all ended up being a whole lot more nonsensical than I had hoped for. There are some good ones, so I'll call that an accomplishment! I was banking on grammar not being an issue: since my tweets use impeccable grammar, the program modeled off them should have pretty good grammar as well. There are going to be some hilarious edge cases (I'm looking at you, `Ethics paper first, music in close to everyone`) that make no sense, and some hilarious edge cases (`Waking up, OJ, I feel like Nick Jonas today`) that make me feel like I should have a Twitter rap career. On the whole though, the structure came out alright.
+
+## Moving on from here
+
+During class we also talked about an interesting idea: trying to analyze corporate documents and corporate speech. I'd be interested to know what this analysis applied to something like a couple of bank press releases could do. By any means, the code needs some work to clean it up before I get that far.
+
+## For further reading
+
+I'm pretty confident I re-invented a couple wheels along the way - what I'm doing feels a lot like what [Markov Chain Monte Carlo](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo) is intended to do. But I've never worked explicitly with that before, so more research is needed.
diff --git a/blog/2016-03-28-tweet-like-me/_notebook_files/_notebook_7_1.png b/blog/2016-03-28-tweet-like-me/_notebook_files/_notebook_7_1.png
new file mode 100644
index 0000000..7315d4d
Binary files /dev/null and b/blog/2016-03-28-tweet-like-me/_notebook_files/_notebook_7_1.png differ
diff --git a/blog/2016-03-28-tweet-like-me/index.mdx b/blog/2016-03-28-tweet-like-me/index.mdx
new file mode 100644
index 0000000..7c549ce
--- /dev/null
+++ b/blog/2016-03-28-tweet-like-me/index.mdx
@@ -0,0 +1,291 @@
+---
+slug: 2016/03/tweet-like-me
+title: Tweet like me
+date: 2016-03-28 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+In which I try to create a robot that will tweet like I tweet.
+
+
+
+So, I'm taking a Machine Learning course this semester in school, and one of the topics we keep coming back to is natural language processing and the 'bag of words' data structure. That is, given a sentence:
+
+`How much wood would a woodchuck chuck if a woodchuck could chuck wood?`
+
+We can represent that sentence as the following list:
+
+`{
+ How: 1
+ much: 1
+ wood: 2
+ would: 2
+ a: 2
+ woodchuck: 2
+ chuck: 2
+ if: 1
+}`
+
+Ignoring *where* the words happened, we're just interested in how *often* the words occurred. That got me thinking: I wonder what would happen if I built a robot that just imitated how often I said things? It's dangerous territory when computer scientists ask "what if," but I got curious enough I wanted to follow through.
+
+## The Objective
+
+Given an input list of Tweets, build up the following things:
+
+1. The distribution of starting words; since there are no "prior" words to go from, we need to treat this as a special case.
+2. The distribution of words given a previous word; for example, every time I use the word `woodchuck` in the example sentence, there is a 50% chance it is followed by `chuck` and a 50% chance it is followed by `could`. I need this distribution for all words.
+3. The distribution of quantity of hashtags; Do I most often use just one? Two? Do they follow something like a Poisson distribution?
+4. Distribution of hashtags; Given a number of hashtags, what is the actual content? I'll treat hashtags as separate from the content of a tweet.
+
+## The Data
+
+I'm using as input my tweet history. I don't really use Twitter anymore, but it seems like a fun use of the dataset. I'd like to eventually build this to a point where I can imitate anyone on Twitter using their last 100 tweets or so, but I'll start with this as example code.
+
+## The Algorithm
+
+I'll be using the [NLTK](http://www.nltk.org/) library for doing a lot of the heavy lifting. First, let's import the data:
+
+
+```python
+import pandas as pd
+
+tweets = pd.read_csv('tweets.csv')
+text = tweets.text
+
+# Don't include tweets in reply to or mentioning people
+replies = text.str.contains('@')
+text_norep = text.loc[~replies]
+```
+
+And now that we've got data, let's start crunching. First, tokenize and build out the distribution of first word:
+
+
+```python
+from nltk.tokenize import TweetTokenizer
+tknzr = TweetTokenizer()
+tokens = text_norep.map(tknzr.tokenize)
+
+first_words = tokens.map(lambda x: x[0])
+first_words_alpha = first_words[first_words.str.isalpha()]
+first_word_dist = first_words_alpha.value_counts() / len(first_words_alpha)
+```
+
+Next, we need to build out the conditional distributions. That is, what is the probability of the next word given the current word is $X$? This one is a bit more involved. First, find all unique words, and then find what words proceed them. This can probably be done in a more efficient manner than I'm currently doing here, but we'll ignore that for the moment.
+
+
+```python
+from functools import reduce
+
+# Get all possible words
+all_words = reduce(lambda x, y: x+y, tokens, [])
+unique_words = set(all_words)
+actual_words = set([x if x[0] != '.' else None for x in unique_words])
+
+word_dist = {}
+for word in iter(actual_words):
+ indices = [i for i, j in enumerate(all_words) if j == word]
+ proceeding = [all_words[i+1] for i in indices]
+ word_dist[word] = proceeding
+```
+
+Now that we've got the tweet analysis done, it's time for the fun part: hashtags! Let's count how many hashtags are in each tweet, I want to get a sense of the distribution.
+
+
+```python
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+hashtags = text_norep.str.count('#')
+bins = hashtags.unique().max()
+hashtags.plot(kind='hist', bins=bins)
+```
+
+```
+
+```
+
+
+![png](_notebook_files/_notebook_7_1.png)
+
+
+That looks like a Poisson distribution, kind of as I expected. I'm guessing my number of hashtags per tweet is $\sim Poi(1)$, but let's actually find the [most likely estimator](https://en.wikipedia.org/wiki/Poisson_distribution#Maximum_likelihood) which in this case is just $\bar{\lambda}$:
+
+
+```python
+mle = hashtags.mean()
+mle
+```
+
+```
+ 0.870236869207003
+```
+
+
+Pretty close! So we can now simulate how many hashtags are in a tweet. Let's also find what hashtags are actually used:
+
+
+```python
+hashtags = [x for x in all_words if x[0] == '#']
+n_hashtags = len(hashtags)
+
+unique_hashtags = list(set([x for x in unique_words if x[0] == '#']))
+hashtag_dist = pd.DataFrame({'hashtags': unique_hashtags,
+ 'prob': [all_words.count(h) / n_hashtags
+ for h in unique_hashtags]})
+len(hashtag_dist)
+```
+
+```
+ 603
+```
+
+Turns out I have used 603 different hashtags during my time on Twitter. That means I was using a unique hashtag for about every third tweet.
+
+In better news though, we now have all the data we need to go about actually constructing tweets! The process will happen in a few steps:
+
+1. Randomly select what the first word will be.
+2. Randomly select the number of hashtags for this tweet, and then select the actual hashtags.
+3. Fill in the remaining space of 140 characters with random words taken from my tweets.
+
+And hopefully, we won't have anything too crazy come out the other end. The way we do the selection follows a [Multinomial Distribution](https://en.wikipedia.org/wiki/Multinomial_distribution): given a lot of different values with specific probability, pick one. Let's give a quick example:
+
+```
+x: .33
+y: .5
+z: .17
+```
+
+That is, I pick `x` with probability 33%, `y` with probability 50%, and so on. In context of our sentence construction, I've built out the probabilities of specific words already - now I just need to simulate that distribution. Time for the engine to actually be developed!
+
+
+```python
+import numpy as np
+
+def multinom_sim(n, vals, probs):
+ occurrences = np.random.multinomial(n, probs)
+ results = occurrences * vals
+ return ' '.join(results[results != ''])
+
+def sim_n_hashtags(hashtag_freq):
+ return np.random.poisson(hashtag_freq)
+
+def sim_hashtags(n, hashtag_dist):
+ return multinom_sim(n, hashtag_dist.hashtags, hashtag_dist.prob)
+
+def sim_first_word(first_word_dist):
+ probs = np.float64(first_word_dist.values)
+ return multinom_sim(1, first_word_dist.reset_index()['index'], probs)
+
+def sim_next_word(current, word_dist):
+ dist = pd.Series(word_dist[current])
+ probs = np.ones(len(dist)) / len(dist)
+ return multinom_sim(1, dist, probs)
+```
+
+## Pulling it all together
+
+I've now built out all the code I need to actually simulate a sentence written by me. Let's try doing an example with five words and a single hashtag:
+
+
+```python
+first = sim_first_word(first_word_dist)
+second = sim_next_word(first, word_dist)
+third = sim_next_word(second, word_dist)
+fourth = sim_next_word(third, word_dist)
+fifth = sim_next_word(fourth, word_dist)
+hashtag = sim_hashtags(1, hashtag_dist)
+
+' '.join((first, second, third, fourth, fifth, hashtag))
+```
+
+```
+ 'My first all-nighter of friends #oldschool'
+```
+
+Let's go ahead and put everything together! We're going to simulate a first word, simulate the hashtags, and then simulate to fill the gap until we've either taken up all the space or reached a period.
+
+
+```python
+def simulate_tweet():
+ chars_remaining = 140
+ first = sim_first_word(first_word_dist)
+ n_hash = sim_n_hashtags(mle)
+ hashtags = sim_hashtags(n_hash, hashtag_dist)
+
+ chars_remaining -= len(first) + len(hashtags)
+
+ tweet = first
+ current = first
+ while chars_remaining > len(tweet) + len(hashtags) and current[0] != '.' and current[0] != '!':
+ current = sim_next_word(current, word_dist)
+ tweet += ' ' + current
+
+ tweet = tweet[:-2] + tweet[-1]
+
+ return ' '.join((tweet, hashtags)).strip()
+```
+
+## The results
+
+And now for something completely different: twenty random tweets dreamed up by my computer and my Twitter data. Here you go:
+
+
+```python
+for i in range(0, 20):
+ print(simulate_tweet())
+ print()
+```
+
+```
+ Also , I'm at 8 this morning. #thursdaysgohard #ornot
+
+ Turns out of us breathe the code will want to my undergraduate career is becoming more night trying ? Religion is now as a chane #HYPE
+
+ You know what recursion is to review the UNCC. #ornot
+
+ There are really sore 3 bonfires in my first writing the library ground floor if awesome. #realtalk #impressed
+
+ So we can make it out there's nothing but I'm not let us so hot I could think I may be good. #SwingDance
+
+ Happy Christmas , at Harris Teeter to be be godly or Roman Catholic ). #4b392b#4b392b #Isaiah26
+
+ For context , I in the most decisive factor of the same for homework. #accomplishment
+
+ Freaking done. #loveyouall
+
+ New blog post : Don't jump in a quiz in with a knife fight. #haskell #earlybirthday
+
+ God shows me legitimately want to get some food and one day.
+
+ Stormed the queen city. #mindblown
+
+ The day of a cold at least outside right before the semester ..
+
+ Finished with the way back. #winners
+
+ Waking up , OJ , I feel like Nick Jonas today.
+
+ First draft of so hard drive. #humansvszombies
+
+ Eric Whitacre is the wise creation.
+
+ Ethics paper first , music in close to everyone who just be posting up with my sin , and Jerry Springr #TheLittleThings
+
+ Love that you know enough time I've eaten at 8 PM. #deepthoughts #stillblownaway
+
+ Lead. #ThinkingTooMuch #Christmas
+
+ Aamazing conference when you married #DepartmentOfRedundancyDepartment Yep , but there's a legitimate challenge.
+```
+
+
+...Which all ended up being a whole lot more nonsensical than I had hoped for. There are some good ones, so I'll call that an accomplishment! I was banking on grammar not being an issue: since my tweets use impeccable grammar, the program modeled off them should have pretty good grammar as well. There are going to be some hilarious edge cases (I'm looking at you, `Ethics paper first, music in close to everyone`) that make no sense, and some hilarious edge cases (`Waking up, OJ, I feel like Nick Jonas today`) that make me feel like I should have a Twitter rap career. On the whole though, the structure came out alright.
+
+## Moving on from here
+
+During class we also talked about an interesting idea: trying to analyze corporate documents and corporate speech. I'd be interested to know what this analysis applied to something like a couple of bank press releases could do. By any means, the code needs some work to clean it up before I get that far.
+
+## For further reading
+
+I'm pretty confident I re-invented a couple wheels along the way - what I'm doing feels a lot like what [Markov Chain Monte Carlo](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo) is intended to do. But I've never worked explicitly with that before, so more research is needed.
\ No newline at end of file
diff --git a/blog/2016-04-06-tick-tock/_article.md b/blog/2016-04-06-tick-tock/_article.md
new file mode 100644
index 0000000..223ba3e
--- /dev/null
+++ b/blog/2016-04-06-tick-tock/_article.md
@@ -0,0 +1,15 @@
+Title: Tick Tock...
+Date: 2016-04-06
+Category: Blog
+Tags: fitbit, heartrate
+Authors: Bradlee Speice
+Summary: In which I try to predict the rest of my life using 3 months' worth of data.
+[//]: <> "Modified: "
+
+{% notebook 2016-4-6-tick-tock....ipynb %}
+
+
+
diff --git a/blog/2016-04-06-tick-tock/_notebook.ipynb b/blog/2016-04-06-tick-tock/_notebook.ipynb
new file mode 100644
index 0000000..1c29ed8
--- /dev/null
+++ b/blog/2016-04-06-tick-tock/_notebook.ipynb
@@ -0,0 +1,490 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If all we have is a finite number of heartbeats left, what about me?\n",
+ "\n",
+ "---\n",
+ "\n",
+ "Warning: this one is a bit creepier. But that's what you get when you come up with data science ideas as you're drifting off to sleep.\n",
+ "\n",
+ "# 2.5 Billion\n",
+ "\n",
+ "If [PBS][1] is right, that's the total number of heartbeats we get. Approximately once every second that number goes down, and down, and down again...\n",
+ "[1]: http://www.pbs.org/wgbh/nova/heart/heartfacts.html\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "total_heartbeats = 2500000000"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "I got a Fitbit this past Christmas season, mostly because I was interested in the data and trying to work on some data science projects with it. This is going to be the first project, but there will likely be more (and not nearly as morbid). My idea was: If this is the final number that I'm running up against, how far have I come, and how far am I likely to go? I've currently had about 3 months' time to estimate what my data will look like, so let's go ahead and see: given a lifetime 2.5 billion heart beats, how much time do I have left?\n",
+ "\n",
+ "# Statistical Considerations\n",
+ "\n",
+ "Since I'm starting to work with health data, there are a few considerations I think are important before I start digging through my data.\n",
+ "\n",
+ "1. The concept of 2.5 billion as an agreed-upon number is tenuous at best. I've seen anywhere from [2.21 billion][2] to [3.4 billion][3] so even if I knew exactly how many times my heart had beaten so far, the ending result is suspect at best. I'm using 2.5 billion because that seems to be about the midpoint of the estimates I've seen so far.\n",
+ "2. Most of the numbers I've seen so far are based on extrapolating number of heart beats from life expectancy. As life expectancy goes up, the number of expected heart beats goes up too.\n",
+ "3. My estimation of the number of heartbeats in my life so far is based on 3 months worth of data, and I'm extrapolating an entire lifetime based on this.\n",
+ "\n",
+ "So while the ending number is **not useful in any medical context**, it is still an interesting project to work with the data I have on hand.\n",
+ "\n",
+ "# Getting the data\n",
+ "\n",
+ "[Fitbit](https://www.fitbit.com/) has an [API available](https://dev.fitbit.com/) for people to pull their personal data off the system. It requires registering an application, authentication with OAuth, and some other complicated things. **If you're not interested in how I fetch the data, skip [here](#Wild-Extrapolations-from-Small-Data)**.\n",
+ "\n",
+ "## Registering an application\n",
+ "\n",
+ "I've already [registered a personal application](https://dev.fitbit.com/apps/new) with Fitbit, so I can go ahead and retrieve things like the client secret from a file.\n",
+ "\n",
+ "[1]: http://www.pbs.org/wgbh/nova/heart/heartfacts.html\n",
+ "[2]: http://gizmodo.com/5982977/how-many-heartbeats-does-each-species-get-in-a-lifetime\n",
+ "[3]: http://wonderopolis.org/wonder/how-many-times-does-your-heart-beat-in-a-lifetime/"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "# Import all the OAuth secret information from a local file\n",
+ "from secrets import CLIENT_SECRET, CLIENT_ID, CALLBACK_URL"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Handling OAuth 2\n",
+ "\n",
+ "So, all the people that know what OAuth 2 is know what's coming next. For those who don't: OAuth is how people allow applications to access other data without having to know your password. Essentially the dialog goes like this:\n",
+ "\n",
+ "```\n",
+ "Application: I've got a user here who wants to use my application, but I need their data.\n",
+ "Fitbit: OK, what data do you need access to, and for how long?\n",
+ "Application: I need all of these scopes, and for this amount of time.\n",
+ "Fitbit: OK, let me check with the user to make sure they really want to do this.\n",
+ "\n",
+ "Fitbit: User, do you really want to let this application have your data?\n",
+ "User: I do! And to prove it, here's my password.\n",
+ "Fitbit: OK, everything checks out. I'll let the application access your data.\n",
+ "\n",
+ "Fitbit: Application, you can access the user's data. Use this special value whenever you need to request data from me.\n",
+ "Application: Thank you, now give me all the data.\n",
+ "```\n",
+ "\n",
+ "Effectively, this allows an application to gain access to a user's data without ever needing to know the user's password. That way, even if the other application is hacked, the user's original data remains safe. Plus, the user can let the data service know to stop providing the application access any time they want. All in all, very secure.\n",
+ "\n",
+ "It does make handling small requests a bit challenging, but I'll go through the steps here. We'll be using the [Implicit Grant](https://dev.fitbit.com/docs/oauth2/) workflow, as it requires fewer steps in processing.\n",
+ "\n",
+ "First, we need to set up the URL the user would visit to authenticate:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "import urllib\n",
+ "\n",
+ "FITBIT_URI = 'https://www.fitbit.com/oauth2/authorize'\n",
+ "params = {\n",
+ " # If we need more than one scope, must be a CSV string\n",
+ " 'scope': 'heartrate',\n",
+ " 'response_type': 'token',\n",
+ " 'expires_in': 86400, # 1 day\n",
+ " 'redirect_uri': CALLBACK_URL,\n",
+ " 'client_id': CLIENT_ID\n",
+ "}\n",
+ "\n",
+ "request_url = FITBIT_URI + '?' + urllib.parse.urlencode(params)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, here you would print out the request URL, go visit it, and get the full URL that it sends you back to. Because that is very sensitive information (specifically containing my `CLIENT_ID` that I'd really rather not share on the internet), I've skipped that step in the code here, but it happens in the background."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "# The `response_url` variable contains the full URL that\n",
+ "# FitBit sent back to us, but most importantly,\n",
+ "# contains the token we need for authorization.\n",
+ "access_token = dict(urllib.parse.parse_qsl(response_url))['access_token']"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Requesting the data\n",
+ "\n",
+ "Now that we've actually set up our access via the `access_token`, it's time to get the actual [heart rate data](https://dev.fitbit.com/docs/heart-rate/). I'll be using data from January 1, 2016 through March 31, 2016, and extrapolating wildly from that.\n",
+ "\n",
+ "Fitbit only lets us fetch intraday data one day at a time, so I'll create a date range using pandas and iterate through that to pull down all the data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Heartbeats from 2016-01-01 00:00:00 to 2016-03-31 23:59:00: 8139060\n"
+ ]
+ }
+ ],
+ "source": [
+ "from requests_oauthlib import OAuth2Session\n",
+ "import pandas as pd\n",
+ "from datetime import datetime\n",
+ "\n",
+ "session = OAuth2Session(token={\n",
+ " 'access_token': access_token,\n",
+ " 'token_type': 'Bearer'\n",
+ " })\n",
+ "\n",
+ "format_str = '%Y-%m-%d'\n",
+ "start_date = datetime(2016, 1, 1)\n",
+ "end_date = datetime(2016, 3, 31)\n",
+ "dr = pd.date_range(start_date, end_date)\n",
+ "\n",
+ "url = 'https://api.fitbit.com/1/user/-/activities/heart/date/{0}/1d/1min.json'\n",
+ "hr_responses = [session.get(url.format(d.strftime(format_str))) for d in dr]\n",
+ "\n",
+ "def record_to_df(record):\n",
+ " if 'activities-heart' not in record:\n",
+ " return None\n",
+ " date_str = record['activities-heart'][0]['dateTime']\n",
+ " df = pd.DataFrame(record['activities-heart-intraday']['dataset'])\n",
+ " \n",
+ " df.index = df['time'].apply(\n",
+ " lambda x: datetime.strptime(date_str + ' ' + x, '%Y-%m-%d %H:%M:%S'))\n",
+ " return df\n",
+ "\n",
+ "hr_dataframes = [record_to_df(record.json()) for record in hr_responses]\n",
+ "hr_df_concat = pd.concat(hr_dataframes)\n",
+ "\n",
+ "\n",
+ "# There are some minutes with missing data, so we need to correct that\n",
+ "full_daterange = pd.date_range(hr_df_concat.index[0],\n",
+ " hr_df_concat.index[-1],\n",
+ " freq='min')\n",
+ "hr_df_full = hr_df_concat.reindex(full_daterange, method='nearest')\n",
+ "\n",
+ "print(\"Heartbeats from {} to {}: {}\".format(hr_df_full.index[0],\n",
+ " hr_df_full.index[-1],\n",
+ " hr_df_full['value'].sum()))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And now we've retrieved all the available heart rate data for January 1st through March 31st! Let's get to the actual analysis.\n",
+ "\n",
+ "# Wild Extrapolations from Small Data\n",
+ "\n",
+ "A fundamental issue of this data is that it's pretty small. I'm using 3 months of data to make predictions about my entire life. But, purely as an exercise, I'll move forward.\n",
+ "\n",
+ "## How many heartbeats so far?\n",
+ "\n",
+ "The first step is figuring out how many of the 2.5 billion heartbeats I've used so far. We're going to try and work backward from the present day to when I was born to get that number. The easy part comes first: going back to January 1st, 1992. That's because I can generalize how many 3-month increments there were between now and then, account for leap years, and call that section done.\n",
+ "\n",
+ "Between January 1992 and January 2016 there were 96 quarters, and 6 leap days. The number we're looking for is:\n",
+ "\n",
+ "\\begin{equation}\n",
+ "hr_q \\cdot n - hr_d \\cdot (n-m)\n",
+ "\\end{equation}\n",
+ "\n",
+ "- $hr_q$: Number of heartbeats per quarter\n",
+ "- $hr_d$: Number of heartbeats on leap day\n",
+ "- $n$: Number of quarters, in this case 96\n",
+ "- $m$: Number of leap days, in this case 6"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "773609400"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "quarterly_count = hr_df_full['value'].sum()\n",
+ "leap_day_count = hr_df_full[(hr_df_full.index.month == 2) &\n",
+ " (hr_df_full.index.day == 29)]['value'].sum()\n",
+ "num_quarters = 96\n",
+ "leap_days = 6\n",
+ "\n",
+ "jan_92_jan_16 = quarterly_count * num_quarters - leap_day_count * (num_quarters - leap_days)\n",
+ "jan_92_jan_16"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "So between January 1992 and January 2016 I've used $\\approx$ 774 million heartbeats. Now, I need to go back to my exact birthday. I'm going to first find on average how many heartbeats I use in a minute, and multiply that by the number of minutes between my birthday and January 1992.\n",
+ "\n",
+ "For privacy purposes I'll put the code here that I'm using, but without any identifying information:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Heartbeats so far: 775804660\n",
+ "Remaining heartbeats: 1724195340\n"
+ ]
+ }
+ ],
+ "source": [
+ "minute_mean = hr_df_full['value'].mean()\n",
+ "# Don't you wish you knew?\n",
+ "# birthday_minutes = ???\n",
+ "\n",
+ "birthday_heartbeats = birthday_minutes * minute_mean\n",
+ "\n",
+ "heartbeats_until_2016 = int(birthday_heartbeats + jan_92_jan_16)\n",
+ "remaining_2016 = total_heartbeats - heartbeats_until_2016\n",
+ "\n",
+ "print(\"Heartbeats so far: {}\".format(heartbeats_until_2016))\n",
+ "print(\"Remaining heartbeats: {}\".format(remaining_2016))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "It would appear that my heart has beaten 775,804,660 times between my moment of birth and January 1st 2016, and that I have 1.72 billion left.\n",
+ "\n",
+ "## How many heartbeats longer?\n",
+ "\n",
+ "Now comes the tricky bit. I know how many heart beats I've used so far, and how many I have remaining, so I'd like to come up with a (relatively) accurate estimate of when exactly my heart should give out. We'll do this in a few steps, increasing in granularity.\n",
+ "\n",
+ "First step, how many heartbeats do I use in a 4-year period? I have data for a single quarter including leap day, so I want to know:\n",
+ "\n",
+ "\\begin{equation}\n",
+ "hr_q \\cdot n - hr_d \\cdot (n - m)\n",
+ "\\end{equation}\n",
+ "\n",
+ "- $hr_q$: Heartbeats per quarter\n",
+ "- $hr_d$: Heartbeats per leap day\n",
+ "- $n$: Number of quarters = 16\n",
+ "- $m$: Number of leap days = 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "128934900"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "heartbeats_4year = quarterly_count * 16 - leap_day_count * (16 - 1)\n",
+ "heartbeats_4year"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now, I can fast forward from 2016 the number of periods of 4 years I have left."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Four year periods remaining: 13\n",
+ "Remaining heartbeats after 4 year periods: 48041640\n"
+ ]
+ }
+ ],
+ "source": [
+ "four_year_periods = remaining_2016 // heartbeats_4year\n",
+ "remaining_4y = remaining_2016 - four_year_periods * heartbeats_4year\n",
+ "\n",
+ "print(\"Four year periods remaining: {}\".format(four_year_periods))\n",
+ "print(\"Remaining heartbeats after 4 year periods: {}\".format(remaining_4y))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Given that there are 13 four-year periods left, I can move from 2016 all the way to 2068, and find that I will have 48 million heart beats left. Let's drop down to figuring out how many quarters that is. I know that 2068 will have a leap day (unless someone finally decides to get rid of them), so I'll subtract that out first. Then, I'm left to figure out how many quarters exactly are left."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Quarters left starting 2068: 8\n",
+ "Remaining heartbeats after that: 4760716\n"
+ ]
+ }
+ ],
+ "source": [
+ "remaining_leap = remaining_4y - leap_day_count\n",
+ "# Ignore leap day in the data set\n",
+ "heartbeats_quarter = hr_df_full[(hr_df_full.index.month != 2) &\n",
+ " (hr_df_full.index.day != 29)]['value'].sum()\n",
+ "quarters_left = remaining_leap // heartbeats_quarter\n",
+ "remaining_year = remaining_leap - quarters_left * heartbeats_quarter\n",
+ "\n",
+ "print(\"Quarters left starting 2068: {}\".format(quarters_left))\n",
+ "print(\"Remaining heartbeats after that: {}\".format(remaining_year))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "So, that analysis gets me through until January 1st 2070. Final step, using that minute estimate to figure out how many minutes past that I'm predicted to have:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "datetime.datetime(2070, 2, 23, 5, 28)"
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from datetime import timedelta\n",
+ "\n",
+ "base = datetime(2070, 1, 1)\n",
+ "minutes_left = remaining_year // minute_mean\n",
+ "\n",
+ "kaput = timedelta(minutes=minutes_left)\n",
+ "base + kaput"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "According to this, I've got until February 23rd, 2070 at 5:28 PM in the evening before my heart gives out.\n",
+ "\n",
+ "# Summary\n",
+ "\n",
+ "Well, that's kind of a creepy date to know. As I said at the top though, **this number is totally useless in any medical context**. It ignores the rate at which we continue to get better at making people live longer, and is extrapolating from 3 months' worth of data the rest of my life. Additionally, throughout my time developing this post I made many minor mistakes. I think they're all fixed now, but it's easy to mix a number up here or there and the analysis gets thrown off by a couple years.\n",
+ "\n",
+ "Even still, I think philosophically humans have a desire to know how much time we have left in the world. [Man is but a breath](https://www.biblegateway.com/passage/?search=psalm+144&version=ESV), and it's scary to think just how quickly that date may be coming up. This analysis asks an important question though: what are you going to do with the time you have left?\n",
+ "\n",
+ "Thanks for sticking with me on this one, I promise it will be much less depressing next time!"
+ ]
+ }
+ ],
+ "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.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-04-06-tick-tock/_notebook.md b/blog/2016-04-06-tick-tock/_notebook.md
new file mode 100644
index 0000000..d8a030a
--- /dev/null
+++ b/blog/2016-04-06-tick-tock/_notebook.md
@@ -0,0 +1,307 @@
+If all we have is a finite number of heartbeats left, what about me?
+
+---
+
+Warning: this one is a bit creepier. But that's what you get when you come up with data science ideas as you're drifting off to sleep.
+
+# 2.5 Billion
+
+If [PBS][1] is right, that's the total number of heartbeats we get. Approximately once every second that number goes down, and down, and down again...
+[1]: http://www.pbs.org/wgbh/nova/heart/heartfacts.html
+
+
+
+```python
+total_heartbeats = 2500000000
+```
+
+I got a Fitbit this past Christmas season, mostly because I was interested in the data and trying to work on some data science projects with it. This is going to be the first project, but there will likely be more (and not nearly as morbid). My idea was: If this is the final number that I'm running up against, how far have I come, and how far am I likely to go? I've currently had about 3 months' time to estimate what my data will look like, so let's go ahead and see: given a lifetime 2.5 billion heart beats, how much time do I have left?
+
+# Statistical Considerations
+
+Since I'm starting to work with health data, there are a few considerations I think are important before I start digging through my data.
+
+1. The concept of 2.5 billion as an agreed-upon number is tenuous at best. I've seen anywhere from [2.21 billion][2] to [3.4 billion][3] so even if I knew exactly how many times my heart had beaten so far, the ending result is suspect at best. I'm using 2.5 billion because that seems to be about the midpoint of the estimates I've seen so far.
+2. Most of the numbers I've seen so far are based on extrapolating number of heart beats from life expectancy. As life expectancy goes up, the number of expected heart beats goes up too.
+3. My estimation of the number of heartbeats in my life so far is based on 3 months worth of data, and I'm extrapolating an entire lifetime based on this.
+
+So while the ending number is **not useful in any medical context**, it is still an interesting project to work with the data I have on hand.
+
+# Getting the data
+
+[Fitbit](https://www.fitbit.com/) has an [API available](https://dev.fitbit.com/) for people to pull their personal data off the system. It requires registering an application, authentication with OAuth, and some other complicated things. **If you're not interested in how I fetch the data, skip [here](#Wild-Extrapolations-from-Small-Data)**.
+
+## Registering an application
+
+I've already [registered a personal application](https://dev.fitbit.com/apps/new) with Fitbit, so I can go ahead and retrieve things like the client secret from a file.
+
+[1]: http://www.pbs.org/wgbh/nova/heart/heartfacts.html
+[2]: http://gizmodo.com/5982977/how-many-heartbeats-does-each-species-get-in-a-lifetime
+[3]: http://wonderopolis.org/wonder/how-many-times-does-your-heart-beat-in-a-lifetime/
+
+
+```python
+# Import all the OAuth secret information from a local file
+from secrets import CLIENT_SECRET, CLIENT_ID, CALLBACK_URL
+```
+
+## Handling OAuth 2
+
+So, all the people that know what OAuth 2 is know what's coming next. For those who don't: OAuth is how people allow applications to access other data without having to know your password. Essentially the dialog goes like this:
+
+```
+Application: I've got a user here who wants to use my application, but I need their data.
+Fitbit: OK, what data do you need access to, and for how long?
+Application: I need all of these scopes, and for this amount of time.
+Fitbit: OK, let me check with the user to make sure they really want to do this.
+
+Fitbit: User, do you really want to let this application have your data?
+User: I do! And to prove it, here's my password.
+Fitbit: OK, everything checks out. I'll let the application access your data.
+
+Fitbit: Application, you can access the user's data. Use this special value whenever you need to request data from me.
+Application: Thank you, now give me all the data.
+```
+
+Effectively, this allows an application to gain access to a user's data without ever needing to know the user's password. That way, even if the other application is hacked, the user's original data remains safe. Plus, the user can let the data service know to stop providing the application access any time they want. All in all, very secure.
+
+It does make handling small requests a bit challenging, but I'll go through the steps here. We'll be using the [Implicit Grant](https://dev.fitbit.com/docs/oauth2/) workflow, as it requires fewer steps in processing.
+
+First, we need to set up the URL the user would visit to authenticate:
+
+
+```python
+import urllib
+
+FITBIT_URI = 'https://www.fitbit.com/oauth2/authorize'
+params = {
+ # If we need more than one scope, must be a CSV string
+ 'scope': 'heartrate',
+ 'response_type': 'token',
+ 'expires_in': 86400, # 1 day
+ 'redirect_uri': CALLBACK_URL,
+ 'client_id': CLIENT_ID
+}
+
+request_url = FITBIT_URI + '?' + urllib.parse.urlencode(params)
+```
+
+Now, here you would print out the request URL, go visit it, and get the full URL that it sends you back to. Because that is very sensitive information (specifically containing my `CLIENT_ID` that I'd really rather not share on the internet), I've skipped that step in the code here, but it happens in the background.
+
+
+```python
+# The `response_url` variable contains the full URL that
+# FitBit sent back to us, but most importantly,
+# contains the token we need for authorization.
+access_token = dict(urllib.parse.parse_qsl(response_url))['access_token']
+```
+
+## Requesting the data
+
+Now that we've actually set up our access via the `access_token`, it's time to get the actual [heart rate data](https://dev.fitbit.com/docs/heart-rate/). I'll be using data from January 1, 2016 through March 31, 2016, and extrapolating wildly from that.
+
+Fitbit only lets us fetch intraday data one day at a time, so I'll create a date range using pandas and iterate through that to pull down all the data.
+
+
+```python
+from requests_oauthlib import OAuth2Session
+import pandas as pd
+from datetime import datetime
+
+session = OAuth2Session(token={
+ 'access_token': access_token,
+ 'token_type': 'Bearer'
+ })
+
+format_str = '%Y-%m-%d'
+start_date = datetime(2016, 1, 1)
+end_date = datetime(2016, 3, 31)
+dr = pd.date_range(start_date, end_date)
+
+url = 'https://api.fitbit.com/1/user/-/activities/heart/date/{0}/1d/1min.json'
+hr_responses = [session.get(url.format(d.strftime(format_str))) for d in dr]
+
+def record_to_df(record):
+ if 'activities-heart' not in record:
+ return None
+ date_str = record['activities-heart'][0]['dateTime']
+ df = pd.DataFrame(record['activities-heart-intraday']['dataset'])
+
+ df.index = df['time'].apply(
+ lambda x: datetime.strptime(date_str + ' ' + x, '%Y-%m-%d %H:%M:%S'))
+ return df
+
+hr_dataframes = [record_to_df(record.json()) for record in hr_responses]
+hr_df_concat = pd.concat(hr_dataframes)
+
+
+# There are some minutes with missing data, so we need to correct that
+full_daterange = pd.date_range(hr_df_concat.index[0],
+ hr_df_concat.index[-1],
+ freq='min')
+hr_df_full = hr_df_concat.reindex(full_daterange, method='nearest')
+
+print("Heartbeats from {} to {}: {}".format(hr_df_full.index[0],
+ hr_df_full.index[-1],
+ hr_df_full['value'].sum()))
+```
+
+ Heartbeats from 2016-01-01 00:00:00 to 2016-03-31 23:59:00: 8139060
+
+
+And now we've retrieved all the available heart rate data for January 1st through March 31st! Let's get to the actual analysis.
+
+# Wild Extrapolations from Small Data
+
+A fundamental issue of this data is that it's pretty small. I'm using 3 months of data to make predictions about my entire life. But, purely as an exercise, I'll move forward.
+
+## How many heartbeats so far?
+
+The first step is figuring out how many of the 2.5 billion heartbeats I've used so far. We're going to try and work backward from the present day to when I was born to get that number. The easy part comes first: going back to January 1st, 1992. That's because I can generalize how many 3-month increments there were between now and then, account for leap years, and call that section done.
+
+Between January 1992 and January 2016 there were 96 quarters, and 6 leap days. The number we're looking for is:
+
+\begin{equation}
+hr_q \cdot n - hr_d \cdot (n-m)
+\end{equation}
+
+- $hr_q$: Number of heartbeats per quarter
+- $hr_d$: Number of heartbeats on leap day
+- $n$: Number of quarters, in this case 96
+- $m$: Number of leap days, in this case 6
+
+
+```python
+quarterly_count = hr_df_full['value'].sum()
+leap_day_count = hr_df_full[(hr_df_full.index.month == 2) &
+ (hr_df_full.index.day == 29)]['value'].sum()
+num_quarters = 96
+leap_days = 6
+
+jan_92_jan_16 = quarterly_count * num_quarters - leap_day_count * (num_quarters - leap_days)
+jan_92_jan_16
+```
+
+
+
+
+ 773609400
+
+
+
+So between January 1992 and January 2016 I've used $\approx$ 774 million heartbeats. Now, I need to go back to my exact birthday. I'm going to first find on average how many heartbeats I use in a minute, and multiply that by the number of minutes between my birthday and January 1992.
+
+For privacy purposes I'll put the code here that I'm using, but without any identifying information:
+
+
+```python
+minute_mean = hr_df_full['value'].mean()
+# Don't you wish you knew?
+# birthday_minutes = ???
+
+birthday_heartbeats = birthday_minutes * minute_mean
+
+heartbeats_until_2016 = int(birthday_heartbeats + jan_92_jan_16)
+remaining_2016 = total_heartbeats - heartbeats_until_2016
+
+print("Heartbeats so far: {}".format(heartbeats_until_2016))
+print("Remaining heartbeats: {}".format(remaining_2016))
+```
+
+ Heartbeats so far: 775804660
+ Remaining heartbeats: 1724195340
+
+
+It would appear that my heart has beaten 775,804,660 times between my moment of birth and January 1st 2016, and that I have 1.72 billion left.
+
+## How many heartbeats longer?
+
+Now comes the tricky bit. I know how many heart beats I've used so far, and how many I have remaining, so I'd like to come up with a (relatively) accurate estimate of when exactly my heart should give out. We'll do this in a few steps, increasing in granularity.
+
+First step, how many heartbeats do I use in a 4-year period? I have data for a single quarter including leap day, so I want to know:
+
+\begin{equation}
+hr_q \cdot n - hr_d \cdot (n - m)
+\end{equation}
+
+- $hr_q$: Heartbeats per quarter
+- $hr_d$: Heartbeats per leap day
+- $n$: Number of quarters = 16
+- $m$: Number of leap days = 1
+
+
+```python
+heartbeats_4year = quarterly_count * 16 - leap_day_count * (16 - 1)
+heartbeats_4year
+```
+
+
+
+
+ 128934900
+
+
+
+Now, I can fast forward from 2016 the number of periods of 4 years I have left.
+
+
+```python
+four_year_periods = remaining_2016 // heartbeats_4year
+remaining_4y = remaining_2016 - four_year_periods * heartbeats_4year
+
+print("Four year periods remaining: {}".format(four_year_periods))
+print("Remaining heartbeats after 4 year periods: {}".format(remaining_4y))
+```
+
+ Four year periods remaining: 13
+ Remaining heartbeats after 4 year periods: 48041640
+
+
+Given that there are 13 four-year periods left, I can move from 2016 all the way to 2068, and find that I will have 48 million heart beats left. Let's drop down to figuring out how many quarters that is. I know that 2068 will have a leap day (unless someone finally decides to get rid of them), so I'll subtract that out first. Then, I'm left to figure out how many quarters exactly are left.
+
+
+```python
+remaining_leap = remaining_4y - leap_day_count
+# Ignore leap day in the data set
+heartbeats_quarter = hr_df_full[(hr_df_full.index.month != 2) &
+ (hr_df_full.index.day != 29)]['value'].sum()
+quarters_left = remaining_leap // heartbeats_quarter
+remaining_year = remaining_leap - quarters_left * heartbeats_quarter
+
+print("Quarters left starting 2068: {}".format(quarters_left))
+print("Remaining heartbeats after that: {}".format(remaining_year))
+```
+
+ Quarters left starting 2068: 8
+ Remaining heartbeats after that: 4760716
+
+
+So, that analysis gets me through until January 1st 2070. Final step, using that minute estimate to figure out how many minutes past that I'm predicted to have:
+
+
+```python
+from datetime import timedelta
+
+base = datetime(2070, 1, 1)
+minutes_left = remaining_year // minute_mean
+
+kaput = timedelta(minutes=minutes_left)
+base + kaput
+```
+
+
+
+
+ datetime.datetime(2070, 2, 23, 5, 28)
+
+
+
+According to this, I've got until February 23rd, 2070 at 5:28 PM in the evening before my heart gives out.
+
+# Summary
+
+Well, that's kind of a creepy date to know. As I said at the top though, **this number is totally useless in any medical context**. It ignores the rate at which we continue to get better at making people live longer, and is extrapolating from 3 months' worth of data the rest of my life. Additionally, throughout my time developing this post I made many minor mistakes. I think they're all fixed now, but it's easy to mix a number up here or there and the analysis gets thrown off by a couple years.
+
+Even still, I think philosophically humans have a desire to know how much time we have left in the world. [Man is but a breath](https://www.biblegateway.com/passage/?search=psalm+144&version=ESV), and it's scary to think just how quickly that date may be coming up. This analysis asks an important question though: what are you going to do with the time you have left?
+
+Thanks for sticking with me on this one, I promise it will be much less depressing next time!
diff --git a/blog/2016-04-06-tick-tock/index.mdx b/blog/2016-04-06-tick-tock/index.mdx
new file mode 100644
index 0000000..4311879
--- /dev/null
+++ b/blog/2016-04-06-tick-tock/index.mdx
@@ -0,0 +1,311 @@
+---
+slug: 2016/04/tick-tock
+title: Tick tock...
+date: 2016-04-06 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+If all we have is a finite number of heartbeats left, what about me?
+
+
+
+Warning: this one is a bit creepier. But that's what you get when you come up with data science ideas as you're drifting off to sleep.
+
+## 2.5 Billion
+
+If [PBS][1] is right, that's the total number of heartbeats we get. Approximately once every second that number goes down, and down, and down again...
+
+[1]: http://www.pbs.org/wgbh/nova/heart/heartfacts.html
+
+```python
+total_heartbeats = 2500000000
+```
+
+I got a Fitbit this past Christmas season, mostly because I was interested in the data and trying to work on some data science projects with it. This is going to be the first project, but there will likely be more (and not nearly as morbid). My idea was: If this is the final number that I'm running up against, how far have I come, and how far am I likely to go? I've currently had about 3 months' time to estimate what my data will look like, so let's go ahead and see: given a lifetime 2.5 billion heart beats, how much time do I have left?
+
+## Statistical Considerations
+
+Since I'm starting to work with health data, there are a few considerations I think are important before I start digging through my data.
+
+1. The concept of 2.5 billion as an agreed-upon number is tenuous at best. I've seen anywhere from [2.21 billion][2] to [3.4 billion][3] so even if I knew exactly how many times my heart had beaten so far, the ending result is suspect at best. I'm using 2.5 billion because that seems to be about the midpoint of the estimates I've seen so far.
+2. Most of the numbers I've seen so far are based on extrapolating number of heart beats from life expectancy. As life expectancy goes up, the number of expected heart beats goes up too.
+3. My estimation of the number of heartbeats in my life so far is based on 3 months worth of data, and I'm extrapolating an entire lifetime based on this.
+
+So while the ending number is **not useful in any medical context**, it is still an interesting project to work with the data I have on hand.
+
+## Getting the data
+
+[Fitbit](https://www.fitbit.com/) has an [API available](https://dev.fitbit.com/) for people to pull their personal data off the system. It requires registering an application, authentication with OAuth, and some other complicated things. **If you're not interested in how I fetch the data, skip [here](#Wild-Extrapolations-from-Small-Data)**.
+
+## Registering an application
+
+I've already [registered a personal application](https://dev.fitbit.com/apps/new) with Fitbit, so I can go ahead and retrieve things like the client secret from a file.
+
+[1]: http://www.pbs.org/wgbh/nova/heart/heartfacts.html
+[2]: http://gizmodo.com/5982977/how-many-heartbeats-does-each-species-get-in-a-lifetime
+[3]: http://wonderopolis.org/wonder/how-many-times-does-your-heart-beat-in-a-lifetime/
+
+
+```python
+# Import all the OAuth secret information from a local file
+from secrets import CLIENT_SECRET, CLIENT_ID, CALLBACK_URL
+```
+
+### Handling OAuth 2
+
+So, all the people that know what OAuth 2 is know what's coming next. For those who don't: OAuth is how people allow applications to access other data without having to know your password. Essentially the dialog goes like this:
+
+```
+Application: I've got a user here who wants to use my application, but I need their data.
+Fitbit: OK, what data do you need access to, and for how long?
+Application: I need all of these scopes, and for this amount of time.
+Fitbit: OK, let me check with the user to make sure they really want to do this.
+
+Fitbit: User, do you really want to let this application have your data?
+User: I do! And to prove it, here's my password.
+Fitbit: OK, everything checks out. I'll let the application access your data.
+
+Fitbit: Application, you can access the user's data. Use this special value whenever you need to request data from me.
+Application: Thank you, now give me all the data.
+```
+
+Effectively, this allows an application to gain access to a user's data without ever needing to know the user's password. That way, even if the other application is hacked, the user's original data remains safe. Plus, the user can let the data service know to stop providing the application access any time they want. All in all, very secure.
+
+It does make handling small requests a bit challenging, but I'll go through the steps here. We'll be using the [Implicit Grant](https://dev.fitbit.com/docs/oauth2/) workflow, as it requires fewer steps in processing.
+
+First, we need to set up the URL the user would visit to authenticate:
+
+
+```python
+import urllib
+
+FITBIT_URI = 'https://www.fitbit.com/oauth2/authorize'
+params = {
+ # If we need more than one scope, must be a CSV string
+ 'scope': 'heartrate',
+ 'response_type': 'token',
+ 'expires_in': 86400, # 1 day
+ 'redirect_uri': CALLBACK_URL,
+ 'client_id': CLIENT_ID
+}
+
+request_url = FITBIT_URI + '?' + urllib.parse.urlencode(params)
+```
+
+Now, here you would print out the request URL, go visit it, and get the full URL that it sends you back to. Because that is very sensitive information (specifically containing my `CLIENT_ID` that I'd really rather not share on the internet), I've skipped that step in the code here, but it happens in the background.
+
+
+```python
+# The `response_url` variable contains the full URL that
+# FitBit sent back to us, but most importantly,
+# contains the token we need for authorization.
+access_token = dict(urllib.parse.parse_qsl(response_url))['access_token']
+```
+
+### Requesting the data
+
+Now that we've actually set up our access via the `access_token`, it's time to get the actual [heart rate data](https://dev.fitbit.com/docs/heart-rate/). I'll be using data from January 1, 2016 through March 31, 2016, and extrapolating wildly from that.
+
+Fitbit only lets us fetch intraday data one day at a time, so I'll create a date range using pandas and iterate through that to pull down all the data.
+
+
+```python
+from requests_oauthlib import OAuth2Session
+import pandas as pd
+from datetime import datetime
+
+session = OAuth2Session(token={
+ 'access_token': access_token,
+ 'token_type': 'Bearer'
+ })
+
+format_str = '%Y-%m-%d'
+start_date = datetime(2016, 1, 1)
+end_date = datetime(2016, 3, 31)
+dr = pd.date_range(start_date, end_date)
+
+url = 'https://api.fitbit.com/1/user/-/activities/heart/date/{0}/1d/1min.json'
+hr_responses = [session.get(url.format(d.strftime(format_str))) for d in dr]
+
+def record_to_df(record):
+ if 'activities-heart' not in record:
+ return None
+ date_str = record['activities-heart'][0]['dateTime']
+ df = pd.DataFrame(record['activities-heart-intraday']['dataset'])
+
+ df.index = df['time'].apply(
+ lambda x: datetime.strptime(date_str + ' ' + x, '%Y-%m-%d %H:%M:%S'))
+ return df
+
+hr_dataframes = [record_to_df(record.json()) for record in hr_responses]
+hr_df_concat = pd.concat(hr_dataframes)
+
+
+# There are some minutes with missing data, so we need to correct that
+full_daterange = pd.date_range(hr_df_concat.index[0],
+ hr_df_concat.index[-1],
+ freq='min')
+hr_df_full = hr_df_concat.reindex(full_daterange, method='nearest')
+
+print("Heartbeats from {} to {}: {}".format(hr_df_full.index[0],
+ hr_df_full.index[-1],
+ hr_df_full['value'].sum()))
+```
+
+```
+ Heartbeats from 2016-01-01 00:00:00 to 2016-03-31 23:59:00: 8139060
+```
+
+And now we've retrieved all the available heart rate data for January 1st through March 31st! Let's get to the actual analysis.
+
+## Wild Extrapolations from Small Data
+
+A fundamental issue of this data is that it's pretty small. I'm using 3 months of data to make predictions about my entire life. But, purely as an exercise, I'll move forward.
+
+### How many heartbeats so far?
+
+The first step is figuring out how many of the 2.5 billion heartbeats I've used so far. We're going to try and work backward from the present day to when I was born to get that number. The easy part comes first: going back to January 1st, 1992. That's because I can generalize how many 3-month increments there were between now and then, account for leap years, and call that section done.
+
+Between January 1992 and January 2016 there were 96 quarters, and 6 leap days. The number we're looking for is:
+
+$$
+\begin{equation*}
+hr_q \cdot n - hr_d \cdot (n-m)
+\end{equation*}
+$$
+
+- $hr_q$: Number of heartbeats per quarter
+- $hr_d$: Number of heartbeats on leap day
+- $n$: Number of quarters, in this case 96
+- $m$: Number of leap days, in this case 6
+
+
+```python
+quarterly_count = hr_df_full['value'].sum()
+leap_day_count = hr_df_full[(hr_df_full.index.month == 2) &
+ (hr_df_full.index.day == 29)]['value'].sum()
+num_quarters = 96
+leap_days = 6
+
+jan_92_jan_16 = quarterly_count * num_quarters - leap_day_count * (num_quarters - leap_days)
+jan_92_jan_16
+```
+
+```
+ 773609400
+```
+
+So between January 1992 and January 2016 I've used $\approx$ 774 million heartbeats. Now, I need to go back to my exact birthday. I'm going to first find on average how many heartbeats I use in a minute, and multiply that by the number of minutes between my birthday and January 1992.
+
+For privacy purposes I'll put the code here that I'm using, but without any identifying information:
+
+
+```python
+minute_mean = hr_df_full['value'].mean()
+# Don't you wish you knew?
+# birthday_minutes = ???
+
+birthday_heartbeats = birthday_minutes * minute_mean
+
+heartbeats_until_2016 = int(birthday_heartbeats + jan_92_jan_16)
+remaining_2016 = total_heartbeats - heartbeats_until_2016
+
+print("Heartbeats so far: {}".format(heartbeats_until_2016))
+print("Remaining heartbeats: {}".format(remaining_2016))
+```
+
+```
+ Heartbeats so far: 775804660
+ Remaining heartbeats: 1724195340
+```
+
+It would appear that my heart has beaten 775,804,660 times between my moment of birth and January 1st 2016, and that I have 1.72 billion left.
+
+### How many heartbeats longer?
+
+Now comes the tricky bit. I know how many heart beats I've used so far, and how many I have remaining, so I'd like to come up with a (relatively) accurate estimate of when exactly my heart should give out. We'll do this in a few steps, increasing in granularity.
+
+First step, how many heartbeats do I use in a 4-year period? I have data for a single quarter including leap day, so I want to know:
+
+$$
+\begin{equation*}
+hr_q \cdot n - hr_d \cdot (n - m)
+\end{equation*}
+$$
+
+- $hr_q$: Heartbeats per quarter
+- $hr_d$: Heartbeats per leap day
+- $n$: Number of quarters = 16
+- $m$: Number of leap days = 1
+
+
+```python
+heartbeats_4year = quarterly_count * 16 - leap_day_count * (16 - 1)
+heartbeats_4year
+```
+
+```
+ 128934900
+```
+
+Now, I can fast forward from 2016 the number of periods of 4 years I have left.
+
+```python
+four_year_periods = remaining_2016 // heartbeats_4year
+remaining_4y = remaining_2016 - four_year_periods * heartbeats_4year
+
+print("Four year periods remaining: {}".format(four_year_periods))
+print("Remaining heartbeats after 4 year periods: {}".format(remaining_4y))
+```
+
+```
+ Four year periods remaining: 13
+ Remaining heartbeats after 4 year periods: 48041640
+```
+
+Given that there are 13 four-year periods left, I can move from 2016 all the way to 2068, and find that I will have 48 million heart beats left. Let's drop down to figuring out how many quarters that is. I know that 2068 will have a leap day (unless someone finally decides to get rid of them), so I'll subtract that out first. Then, I'm left to figure out how many quarters exactly are left.
+
+```python
+remaining_leap = remaining_4y - leap_day_count
+# Ignore leap day in the data set
+heartbeats_quarter = hr_df_full[(hr_df_full.index.month != 2) &
+ (hr_df_full.index.day != 29)]['value'].sum()
+quarters_left = remaining_leap // heartbeats_quarter
+remaining_year = remaining_leap - quarters_left * heartbeats_quarter
+
+print("Quarters left starting 2068: {}".format(quarters_left))
+print("Remaining heartbeats after that: {}".format(remaining_year))
+```
+
+```
+ Quarters left starting 2068: 8
+ Remaining heartbeats after that: 4760716
+```
+
+So, that analysis gets me through until January 1st 2070. Final step, using that minute estimate to figure out how many minutes past that I'm predicted to have:
+
+
+```python
+from datetime import timedelta
+
+base = datetime(2070, 1, 1)
+minutes_left = remaining_year // minute_mean
+
+kaput = timedelta(minutes=minutes_left)
+base + kaput
+```
+
+```
+ datetime.datetime(2070, 2, 23, 5, 28)
+```
+
+According to this, I've got until February 23rd, 2070 at 5:28 PM in the evening before my heart gives out.
+
+## Summary
+
+Well, that's kind of a creepy date to know. As I said at the top though, **this number is totally useless in any medical context**. It ignores the rate at which we continue to get better at making people live longer, and is extrapolating from 3 months' worth of data the rest of my life. Additionally, throughout my time developing this post I made many minor mistakes. I think they're all fixed now, but it's easy to mix a number up here or there and the analysis gets thrown off by a couple years.
+
+Even still, I think philosophically humans have a desire to know how much time we have left in the world. [Man is but a breath](https://www.biblegateway.com/passage/?search=psalm+144&version=ESV), and it's scary to think just how quickly that date may be coming up. This analysis asks an important question though: what are you going to do with the time you have left?
+
+Thanks for sticking with me on this one, I promise it will be much less depressing next time!
\ No newline at end of file
diff --git a/blog/2016-05-15-the-unfair-casino/_article.md b/blog/2016-05-15-the-unfair-casino/_article.md
new file mode 100644
index 0000000..d4362bd
--- /dev/null
+++ b/blog/2016-05-15-the-unfair-casino/_article.md
@@ -0,0 +1,15 @@
+Title: The Unfair Casino
+Date: 2016-05-15
+Category: Blog
+Tags: casino, probability, em, machine learning, simulated annealing
+Authors: Bradlee Speice
+Summary: Trying to figure out how exactly two dice are loaded in a cheating casino
+[//]: <> "Modified: "
+
+{% notebook 2016-5-15-the-unfair-casino.ipynb %}
+
+
+
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook.ipynb b/blog/2016-05-15-the-unfair-casino/_notebook.ipynb
new file mode 100644
index 0000000..ed00df1
--- /dev/null
+++ b/blog/2016-05-15-the-unfair-casino/_notebook.ipynb
@@ -0,0 +1,719 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Or, how to get thrown out of a casino because you're a mathematician.\n",
+ "\n",
+ "---\n",
+ "\n",
+ "In the ongoing eternal cycle of mathematicians asking generally useless questions about probability, I dreamt up another one. The scenario is as follows:\n",
+ "\n",
+ "**You're playing a game with two die, and you do not get to see what the outcome of the die are on each roll. All you get to see is their sum. Given an arbitrarily long list of the sum of two rolls, can you determine if one or both die are loaded, and what those loadings are?**\n",
+ "\n",
+ "# Proving we can detect cheating\n",
+ "\n",
+ "My first question is simply, is this possible? There's a lot of trivial cases that make it obvious that there's cheating going on. But there are some edge cases that might give us more difficulty. First though, let's get a picture of what the fair distribution looks like. In principle, we can only detect cheating if the distribution of the fair die differs from the distribution of the loaded die."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEKCAYAAAA8QgPpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nP71BWn/o4C2PAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline\n",
+ "\n",
+ "fair_1 = np.random.randint(1, 7, 10000)\n",
+ "fair_2 = np.random.randint(1, 7, 10000)\n",
+ "\n",
+ "pd.Series(fair_1 + fair_2).plot(kind='hist', bins=11);\n",
+ "plt.title('Fair Distribution');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This distribution makes sense: there are many ways to make a 7 (the most frequent observed value) and very few ways to make a 12 or 2; an important symmetry. As a special note, you can notice that the sum of two fair dice is a discrete case of the [Triangle Distribution][1], which is itself a special case of the [Irwin-Hall Distribution][2].\n",
+ "\n",
+ "# The Edge Cases\n",
+ "\n",
+ "Given that we understand how the results of two fair dice are distributed, let's see some of the interesting edge cases that come up. This will give us assurance that when a casino is cheating, it is detectable (given sufficient data). To make this as hard as possible, we will think of scenarios where the expected value of the sum of loaded dice is the same as the expected value of the sum of fair dice.\n",
+ "\n",
+ "### Edge Case 1\n",
+ "What happens when one die is biased low, and one die is biased high? That is, where:\n",
+ "\n",
+ "\\begin{align}\n",
+ "\\begin{array}{cc}\n",
+ "D_1 = \\left\\{\n",
+ "\\begin{array}{lr}\n",
+ "1 & w.p. 1/3\\\\\n",
+ "2 & w.p. 1/3\\\\\n",
+ "3 & w.p. 1/12\\\\\n",
+ "4 & w.p. 1/12\\\\\n",
+ "5 & w.p. 1/12\\\\\n",
+ "6 & w.p. 1/12\n",
+ "\\end{array}\n",
+ "\\right. &\n",
+ "D_2 = \\left\\{\n",
+ "\\begin{array}{lr}\n",
+ "1 & w.p. 1/12\\\\\n",
+ "2 & w.p. 1/12\\\\\n",
+ "3 & w.p. 1/12\\\\\n",
+ "4 & w.p. 1/12\\\\\n",
+ "5 & w.p. 1/3\\\\\n",
+ "6 & w.p. 1/3\n",
+ "\\end{array}\n",
+ "\\right. \\\\\n",
+ "\\mathbb{E}[D_1] = 2.5 & \\mathbb{E}[D_2] = 4.5\n",
+ "\\end{array}\\\\\n",
+ "\\mathbb{E}[D_1 + D_2] = 7 = \\mathbb{E}[D_{fair} + D_{fair}]\n",
+ "\\end{align}\n",
+ "\n",
+ "[1]: https://en.wikipedia.org/wiki/Triangular_distribution\n",
+ "[2]: https://en.wikipedia.org/wiki/Irwin%E2%80%93Hall_distribution"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEMCAYAAADqG+D0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIBERUUsSSERE1JIEEhERtfx/t8CCaUQXJ5cAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def unfair_die(p_vals, n):\n",
+ " x = np.random.multinomial(1, p_vals, n)\n",
+ " return x.nonzero()[1] + 1\n",
+ "\n",
+ "d1 = [1/3, 1/3, 1/12, 1/12, 1/12, 1/12]\n",
+ "d2 = [1/12, 1/12, 1/12, 1/12, 1/3, 1/3]\n",
+ "\n",
+ "x1 = unfair_die(d1, 10000)\n",
+ "x2 = unfair_die(d2, 10000)\n",
+ "\n",
+ "pd.Series(x1 + x2).plot(kind='hist', bins=11);\n",
+ "plt.title('$D_1$ biased low, $D_2$ biased high');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can see that while the 7 value remains the most likely (as expected), the distribution is not so nicely shaped any more. \n",
+ "\n",
+ "**Edge Case 2:** When one die is loaded low, and one is loaded high, we've seen how we can detect them. How about when two die are loaded both low and high? That is, we have the following distribution:\n",
+ "\n",
+ "\\begin{align}\n",
+ "\\begin{array}{cc}\n",
+ "D_1 = \\left\\{\n",
+ "\\begin{array}{lr}\n",
+ "1 & w.p. 1/3\\\\\n",
+ "2 & w.p. 1/12\\\\\n",
+ "3 & w.p. 1/12\\\\\n",
+ "4 & w.p. 1/12\\\\\n",
+ "5 & w.p. 1/12\\\\\n",
+ "6 & w.p. 1/3\n",
+ "\\end{array}\n",
+ "\\right. &\n",
+ "D_2 = \\left\\{\n",
+ "\\begin{array}{lr}\n",
+ "1 & w.p. 1/3\\\\\n",
+ "2 & w.p. 1/12\\\\\n",
+ "3 & w.p. 1/12\\\\\n",
+ "4 & w.p. 1/12\\\\\n",
+ "5 & w.p. 1/12\\\\\n",
+ "6 & w.p. 1/3\n",
+ "\\end{array}\n",
+ "\\right. \\\\\n",
+ "\\mathbb{E}[D_1] = 3.5 & \\mathbb{E}[D_2] = 3.5\n",
+ "\\end{array}\\\\\n",
+ "\\mathbb{E}[D_1 + D_2] = 7 = \\mathbb{E}[D_{fair} + D_{fair}]\n",
+ "\\end{align}\n",
+ "\n",
+ "We can see even that the expected value of each individual die is the same as the fair die! However, the distribution (if we are doing this correctly) should still be skewed:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEMCAYAAADqG+D0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSwIkIiJq+f8KwJfCiHKoPQAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "d1 = [1/3, 1/12, 1/12, 1/12, 1/12, 1/3]\n",
+ "d2 = d1\n",
+ "\n",
+ "x1 = unfair_die(d1, 10000)\n",
+ "x2 = unfair_die(d2, 10000)\n",
+ "\n",
+ "pd.Series(x1 + x2).plot(kind='hist', bins=11)\n",
+ "plt.title(\"$D_1$ and $D_2$ biased to 1 and 6\");"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In a very un-subtle way, we have of course made the values 2 and 12 far more likely.\n",
+ "\n",
+ "# Detection Conclusion\n",
+ "\n",
+ "There are some trivial examples of cheating that are easy to detect: whenever the expected value of the sum of two fair dice deviates from the expected value for the sum of two fair dice, we can immediately conclude that there is cheating at stake.\n",
+ "\n",
+ "The interesting edge cases occur when the expected value of the sum of loaded dice matches the expected value of the sum of fair dice. Considering the above examples (and a couple more I ran through in developing this), we have seen that in every circumstance having two unfair dice leads to a distribution of results different from the fair results.\n",
+ "\n",
+ "We can thus finally state: **just by looking at the distribution of results from this game, we can immediately conclude whether there is cheating.**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Simulated Annealing\n",
+ "\n",
+ "What we really would like to do though, is see if there is any way to determine how exactly the dice are loaded. This is significantly more complicated, but we can borrow some algorithms from Machine Learning to figure out exactly how to perform this process. I'm using the Simulated Annealing algorithm, and I discuss why this works and why I chose it over some of the alternatives in the [justification](#Justification-of-Simulated-Annealing). If you don't care about how I set up the model and just want to see the code, check out [the actual code](#The-actual-code).\n",
+ "\n",
+ "[Simulated Annealing][3] is a variation of the [Metropolis-Hastings Algorithm][4], but the important thing for us is: Simulated Annealing allows us to quickly optimize high-dimensional problems. But what exactly are we trying to optimize? Ideally, we want a function that can tell us whether one distribution for the dice better explains the results than another distribution. This is known as the **likelihood** function.\n",
+ "\n",
+ "## Deriving the Likelihood function\n",
+ "\n",
+ "To derive our likelihood function, we want to know: **what is the probability of seeing a specific result given those hidden parameters?** This is actually a surprisingly difficult problem. While we can do a lot of calculations by hand, we need a more general solution since we will be working with very some interesting die distributions.\n",
+ "\n",
+ "We first note that the sum of two dice can take on 11 different values - 2 through 12. This implies that each individual sum follows a [Categorical distribution](https://en.wikipedia.org/wiki/Categorical_distribution). That is:\n",
+ "\n",
+ "\\begin{align}\n",
+ "\\mathcal{L(x)} = \\left\\{\n",
+ "\\begin{array}{lr}\n",
+ "p_2 & x = 2\\\\\n",
+ "p_3 & x = 3\\\\\n",
+ "\\ldots & \\\\\n",
+ "p_{11} & x = 11\\\\\n",
+ "p_{12} & x = 12\n",
+ "\\end{array}\n",
+ "\\right.\n",
+ "\\end{align}\n",
+ "\n",
+ "Where each $p_i$ is the probability of seeing that specific result. However, we need to calculate what each probability is! I'll save you the details, but [this author](http://math.stackexchange.com/a/1646360/320784) explains how to do it.\n",
+ "\n",
+ "Now, we would like to know the likelihood of our entire data-set. This is trivial:\n",
+ "\n",
+ "\\begin{align}\n",
+ "\\mathcal{L(\\mathbf{X})} &= \\prod_{i=1}^n L(x)\n",
+ "\\end{align}\n",
+ "\n",
+ "However, it's typically much easier to work with the $\\log(\\mathcal{L})$ function instead. This is critically important from a computational perspective: when you multiply so many small numbers together (i.e. the product of $L(x)$ terms) the computer suffers from rounding error; if we don't control for this, we will find that no matter the distributions we choose for each die, the \"likelihood\" will be close to zero because the computer is not precise enough.\n",
+ "\n",
+ "\\begin{align}\n",
+ "\\log(\\mathcal{L}) &= \\sum_{i=1}^n \\log(L)\n",
+ "\\end{align}\n",
+ "\n",
+ "## The process of Simulated Annealing\n",
+ "\n",
+ "The means by which we optimize our likelihood function is the simulated annealing algorithm. The way it works is as follows:\n",
+ "\n",
+ "1. Start with a random guess for the parameters we are trying to optimize. In our case we are trying to guess the distribution of two dice, and so we \"optimize\" until we have a distribution that matches the data.\n",
+ "\n",
+ "2. For each iteration of the algorithm:\n",
+ "\n",
+ " 1. Generate a new \"proposed\" set of parameters based on the current parameters -\n",
+ " i.e. slightly modify the current parameters to get a new set of parameters.\n",
+ " 2. Calculate the value of $\\log(\\mathcal{L})$ for each set of parameters. If the function value for the\n",
+ " proposed parameter set is higher than for the current, automatically switch to the new parameter set\n",
+ " and continue the next iteration.\n",
+ " 3. Given the new parameter set performs worse, determine a probability of switching to the new parameter set anyways: $\\mathcal{P}(p_{current}, p_{proposed})$\n",
+ " 4. Switch to the new parameter set with probability $\\mathcal{P}$. If you fail to switch, begin the next iteration.\n",
+ " \n",
+ "3. The algorithm is complete after we fail to make a transition $n$ times in a row.\n",
+ "\n",
+ "If everything goes according to plan, we will have a value that is close to the true distribution of each die.\n",
+ "\n",
+ "# The actual code\n",
+ "\n",
+ "We start by defining the score function. This will tell us how well the proposed die densities actually explain the results.\n",
+ "\n",
+ "[3]:https://en.wikipedia.org/wiki/Simulated_annealing\n",
+ "[4]:https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "from numpy import polynomial\n",
+ "\n",
+ "def density_coef(d1_density, d2_density):\n",
+ " # Calculating the probabilities of each outcome was taken\n",
+ " # from this author: http://math.stackexchange.com/a/1710392/320784\n",
+ " d1_p = polynomial.Polynomial(d1_density)\n",
+ " d2_p = polynomial.Polynomial(d2_density)\n",
+ " coefs = (d1_p * d2_p).coef\n",
+ " return coefs\n",
+ "\n",
+ "def score(x, d1_density, d2_density):\n",
+ " # We've now got the probabilities of each event, but we need\n",
+ " # to shift the array a bit so we can use the x values to actually\n",
+ " # index into it. This will allow us to do all the calculations\n",
+ " # incredibly quickly\n",
+ " coefs = density_coef(d1_density, d2_density)\n",
+ " coefs = np.hstack((0, 0, coefs))\n",
+ " return np.log(coefs[x]).sum()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Afterward, we need to write something to permute the proposal densities. We make random modifications, and eventually the best one survives."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "def permute(d1_density, d2_density):\n",
+ " # To ensure we have legitimate densities, we will randomly\n",
+ " # increase one die face probability by `change`,\n",
+ " # and decrease one by `change`.\n",
+ " # This means there are something less than (1/`change`)^12 possibilities\n",
+ " # we are trying to search over.\n",
+ " change = .01\n",
+ " \n",
+ " d1_index1, d1_index2 = np.random.randint(0, 6, 2)\n",
+ " d2_index1, d2_index2 = np.random.randint(0, 6, 2)\n",
+ " \n",
+ " # Also make sure to copy. I've had some weird aliasing issues\n",
+ " # in the past that made everything blow up.\n",
+ " new_d1 = np.float64(np.copy(d1_density))\n",
+ " new_d2 = np.float64(np.copy(d2_density))\n",
+ " \n",
+ " # While this doesn't account for the possibility that some\n",
+ " # values go negative, in practice this never happens\n",
+ " new_d1[d1_index1] += change\n",
+ " new_d1[d1_index2] -= change\n",
+ " new_d2[d2_index1] += change\n",
+ " new_d2[d2_index2] -= change\n",
+ " \n",
+ " return new_d1, new_d2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we've got the main algorithm code to do. This is what brings all the pieces together."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "def optimize(data, conv_count=10, max_iter=1e4):\n",
+ " switch_failures = 0\n",
+ " iter_count = 0\n",
+ " \n",
+ " # Start with guessing fair dice\n",
+ " cur_d1 = np.repeat(1/6, 6)\n",
+ " cur_d2 = np.repeat(1/6, 6)\n",
+ " cur_score = score(data, cur_d1, cur_d2)\n",
+ " \n",
+ " # Keep track of our best guesses - may not be\n",
+ " # what we end with\n",
+ " max_score = cur_score\n",
+ " max_d1 = cur_d1\n",
+ " max_d2 = cur_d2\n",
+ " \n",
+ " # Optimization stops when we have failed to switch `conv_count`\n",
+ " # times (presumably because we have a great guess), or we reach\n",
+ " # the maximum number of iterations.\n",
+ " while switch_failures < conv_count and iter_count < max_iter:\n",
+ " iter_count += 1\n",
+ " if iter_count % (max_iter / 10) == 0:\n",
+ " print('Iteration: {}; Current score (higher is better): {}'.format(\n",
+ " iter_count, cur_score))\n",
+ " \n",
+ " new_d1, new_d2 = permute(cur_d1, cur_d2)\n",
+ " new_score = score(data, new_d1, new_d2)\n",
+ " \n",
+ " if new_score > max_score:\n",
+ " max_score = new_score\n",
+ " max_d1 = new_d1\n",
+ " max_d2 = new_d2\n",
+ " \n",
+ " if new_score > cur_score:\n",
+ " # If the new permutation beats the old one,\n",
+ " # automatically select it.\n",
+ " cur_score = new_score\n",
+ " cur_d1 = new_d1\n",
+ " cur_d2 = new_d2\n",
+ " switch_failures = 0\n",
+ " else:\n",
+ " # We didn't beat the current score, but allow\n",
+ " # for possibly switching anyways.\n",
+ " accept_prob = np.exp(new_score - cur_score)\n",
+ " coin_toss = np.random.rand()\n",
+ " if coin_toss < accept_prob:\n",
+ " # We randomly switch to the new distribution\n",
+ " cur_score = new_score\n",
+ " cur_d1 = new_d1\n",
+ " cur_d2 = new_d2\n",
+ " switch_failures = 0\n",
+ " else:\n",
+ " switch_failures += 1\n",
+ " \n",
+ " # Return both our best guess, and the ending guess\n",
+ " return max_d1, max_d2, cur_d1, cur_d2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And now we have finished the hard work!\n",
+ "\n",
+ "# Catching the Casino\n",
+ "\n",
+ "Let's go through a couple of scenarios and see if we can catch the casino cheating with some loaded dice. **In every scenario we start with an assumption of fair dice**, and then try our hand to figure out what the *actual* distribution was.\n",
+ "\n",
+ "## Attempt 1\n",
+ "\n",
+ "\n",
+ "The casino is using two dice that are both biased low. How well can we recover the distribution?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Iteration: 1000; Current score (higher is better): -22147.004400281654\n",
+ "Simulated Annealing time: 0.30s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAAJZCAYAAACTE4A9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import time\n",
+ "def simulate_casino(d1_dist, d2_dist, n=10000):\n",
+ " d1_vals = unfair_die(d1_dist, n)\n",
+ " d2_vals = unfair_die(d2_dist, n)\n",
+ " \n",
+ " start = time.perf_counter()\n",
+ " max_d1, max_d2, final_d1, final_d2 = optimize(d1_vals + d2_vals)\n",
+ " end = time.perf_counter()\n",
+ " print(\"Simulated Annealing time: {:.02f}s\".format(end - start))\n",
+ " \n",
+ " coef_range = np.arange(2, 13) - .5\n",
+ " plt.subplot(221)\n",
+ " plt.bar(coef_range, density_coef(d1_dist, d2_dist), width=1)\n",
+ " plt.title('True Distribution')\n",
+ " \n",
+ " plt.subplot(222)\n",
+ " plt.hist(d1_vals + d2_vals, bins=11)\n",
+ " plt.title('Empirical Distribution')\n",
+ " \n",
+ " plt.subplot(223)\n",
+ " plt.bar(coef_range, density_coef(max_d1, max_d2), width=1)\n",
+ " plt.title('Recovered Distribution')\n",
+ " \n",
+ " plt.gcf().set_size_inches(10, 10)\n",
+ "\n",
+ "\n",
+ "simulate_casino([2/9, 2/9, 2/9, 1/9, 1/9, 1/9],\n",
+ " [2/9, 2/9, 2/9, 1/9, 1/9, 1/9])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Attempt 2\n",
+ "\n",
+ "The casino now uses dice that are both biased towards 1 and 6."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Simulated Annealing time: 0.08s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAAJZCAYAAACTE4A9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "simulate_casino([1/3, 1/12, 1/12, 1/12, 1/12, 1/3],\n",
+ " [1/3, 1/12, 1/12, 1/12, 1/12, 1/3])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Attempt 3\n",
+ "\n",
+ "The casino will now use one die biased towards 1 and 6, and one die towards 3 and 4."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Simulated Annealing time: 0.09s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAAJZCAYAAACTE4A9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "simulate_casino([1/3, 1/12, 1/12, 1/12, 1/12, 1/3],\n",
+ " [1/12, 1/12, 1/3, 1/3, 1/12, 1/12])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Attempt 4\n",
+ "\n",
+ "We'll now finally go to a fair casino to make sure that we can still recognize a positive result."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Simulated Annealing time: 0.02s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAAJZCAYAAACTE4A9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhoSz1PA0AAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "simulate_casino(np.repeat(1/6, 6), np.repeat(1/6, 6))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Attempt 5\n",
+ "\n",
+ "We've so far been working with a large amount of data - 10,000 data points. Can we now scale things back to only 250 throws? We'll start with two dice biased high."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Iteration: 1000; Current score (higher is better): -551.6995384525453\n",
+ "Iteration: 2000; Current score (higher is better): -547.7803673440676\n",
+ "Iteration: 3000; Current score (higher is better): -547.9805613193807\n",
+ "Iteration: 4000; Current score (higher is better): -546.7574874775273\n",
+ "Iteration: 5000; Current score (higher is better): -549.5798007672656\n",
+ "Iteration: 6000; Current score (higher is better): -545.0354060154496\n",
+ "Iteration: 7000; Current score (higher is better): -550.1134504086606\n",
+ "Iteration: 8000; Current score (higher is better): -549.9306537114975\n",
+ "Iteration: 9000; Current score (higher is better): -550.7075182119111\n",
+ "Iteration: 10000; Current score (higher is better): -549.400679551826\n",
+ "Simulated Annealing time: 1.94s\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl0AAAJZCAYAAACTE4A9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "simulate_casino([1/9, 1/9, 1/9, 2/9, 2/9, 2/9],\n",
+ " [1/9, 1/9, 1/9, 2/9, 2/9, 2/9],\n",
+ " n=250)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The results are surprisingly good. While the actual optimization process took much longer to finish than in the other examples, we still have a very good guess. As a caveat though: the recovered distribution tends to overfit the data. That is, if the data doesn't fit the underlying distribution well, the model will also fail.\n",
+ "\n",
+ "# Conclusion\n",
+ "\n",
+ "Given the results above, we can see that we have indeed come up with a very good algorithm to determine the distribution of two dice given their results. As a benefit, we have even seen that results come back very quickly; it's not uncommon for the optimization to converge within a tenth of a second.\n",
+ "\n",
+ "Additionally, we have seen that the algorithm can intuit the distribution even when there is not much data. While the final example shows that we can 'overfit' on the dataset, we can still get valuable information from a relatively small dataset.\n",
+ "\n",
+ "We can declare at long last: **the mathematicians have again triumphed over the casino**.\n",
+ "\n",
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Justification of Simulated Annealing\n",
+ "\n",
+ "## Why Simulated Annealing?\n",
+ "\n",
+ "So why even use an algorithm with a fancy title like Simulated Annealing? First of all, because the title is sexy. Second of all, because this is a reasonably complicated problem to try and solve. We have a parameter space where each value $p_{ij} \\in (0, 1); i, j \\in \\{1, \\ldots, 6\\}$, for a total of 12 different variables we are trying to optimize over. Additionally, given a 12-dimensional function we are trying to optimize, simulated annealing makes sure that we don't fall into a local minimum.\n",
+ "\n",
+ "## Why not something else?\n",
+ "\n",
+ "This is a fair question. There are two classes of algorithms that can also be used to solve this problem: [Non-linear optimization](https://en.wikipedia.org/wiki/Nonlinear_programming) methods, and the [EM algorithm](https://en.wikipedia.org/wiki/Expectation%E2%80%93maximization_algorithm).\n",
+ "\n",
+ "1. I chose not to use non-linear optimization simply because I'm a bit concerned that it will trap me in a local maximum. Instead of running multiple different optimizations from different starting points, I can just use simulated annealing to take that into account. In addition, throughout the course of testing the simulated annealing code converged *incredibly* quickly - far more quickly than any non-linear solver would be able to accomplish. \n",
+ "\n",
+ "2. The EM Algorithm was originally what I intended to write this blog post with. Indeed, the post was inspired by the [crooked casino](http://web.stanford.edu/class/stats366/hmmR2.html) example which uses the EM algorithm to solve it. However, after modeling the likelihood function I realized that the algebra would very quickly get out of hand. Trying to compute all the polynomial terms would not be fun, which would be needed to actually optimize for each parameter. So while the EM algorithm would likely be much faster in raw speed terms, the amount of time needed to program and verify it meant that I was far better off using a different method for optimization."
+ ]
+ }
+ ],
+ "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.1"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook.md b/blog/2016-05-15-the-unfair-casino/_notebook.md
new file mode 100644
index 0000000..2c2029a
--- /dev/null
+++ b/blog/2016-05-15-the-unfair-casino/_notebook.md
@@ -0,0 +1,497 @@
+Or, how to get thrown out of a casino because you're a mathematician.
+
+---
+
+In the ongoing eternal cycle of mathematicians asking generally useless questions about probability, I dreamt up another one. The scenario is as follows:
+
+**You're playing a game with two die, and you do not get to see what the outcome of the die are on each roll. All you get to see is their sum. Given an arbitrarily long list of the sum of two rolls, can you determine if one or both die are loaded, and what those loadings are?**
+
+# Proving we can detect cheating
+
+My first question is simply, is this possible? There's a lot of trivial cases that make it obvious that there's cheating going on. But there are some edge cases that might give us more difficulty. First though, let's get a picture of what the fair distribution looks like. In principle, we can only detect cheating if the distribution of the fair die differs from the distribution of the loaded die.
+
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+fair_1 = np.random.randint(1, 7, 10000)
+fair_2 = np.random.randint(1, 7, 10000)
+
+pd.Series(fair_1 + fair_2).plot(kind='hist', bins=11);
+plt.title('Fair Distribution');
+```
+
+
+
+![png](_notebook_files/_notebook_1_0.png)
+
+
+
+This distribution makes sense: there are many ways to make a 7 (the most frequent observed value) and very few ways to make a 12 or 2; an important symmetry. As a special note, you can notice that the sum of two fair dice is a discrete case of the [Triangle Distribution][1], which is itself a special case of the [Irwin-Hall Distribution][2].
+
+# The Edge Cases
+
+Given that we understand how the results of two fair dice are distributed, let's see some of the interesting edge cases that come up. This will give us assurance that when a casino is cheating, it is detectable (given sufficient data). To make this as hard as possible, we will think of scenarios where the expected value of the sum of loaded dice is the same as the expected value of the sum of fair dice.
+
+### Edge Case 1
+What happens when one die is biased low, and one die is biased high? That is, where:
+
+\begin{align}
+\begin{array}{cc}
+D_1 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/3\\
+2 & w.p. 1/3\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/12\\
+6 & w.p. 1/12
+\end{array}
+\right. &
+D_2 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/12\\
+2 & w.p. 1/12\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/3\\
+6 & w.p. 1/3
+\end{array}
+\right. \\
+\mathbb{E}[D_1] = 2.5 & \mathbb{E}[D_2] = 4.5
+\end{array}\\
+\mathbb{E}[D_1 + D_2] = 7 = \mathbb{E}[D_{fair} + D_{fair}]
+\end{align}
+
+[1]: https://en.wikipedia.org/wiki/Triangular_distribution
+[2]: https://en.wikipedia.org/wiki/Irwin%E2%80%93Hall_distribution
+
+
+```python
+def unfair_die(p_vals, n):
+ x = np.random.multinomial(1, p_vals, n)
+ return x.nonzero()[1] + 1
+
+d1 = [1/3, 1/3, 1/12, 1/12, 1/12, 1/12]
+d2 = [1/12, 1/12, 1/12, 1/12, 1/3, 1/3]
+
+x1 = unfair_die(d1, 10000)
+x2 = unfair_die(d2, 10000)
+
+pd.Series(x1 + x2).plot(kind='hist', bins=11);
+plt.title('$D_1$ biased low, $D_2$ biased high');
+```
+
+
+
+![png](_notebook_files/_notebook_3_0.png)
+
+
+
+We can see that while the 7 value remains the most likely (as expected), the distribution is not so nicely shaped any more.
+
+**Edge Case 2:** When one die is loaded low, and one is loaded high, we've seen how we can detect them. How about when two die are loaded both low and high? That is, we have the following distribution:
+
+\begin{align}
+\begin{array}{cc}
+D_1 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/3\\
+2 & w.p. 1/12\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/12\\
+6 & w.p. 1/3
+\end{array}
+\right. &
+D_2 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/3\\
+2 & w.p. 1/12\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/12\\
+6 & w.p. 1/3
+\end{array}
+\right. \\
+\mathbb{E}[D_1] = 3.5 & \mathbb{E}[D_2] = 3.5
+\end{array}\\
+\mathbb{E}[D_1 + D_2] = 7 = \mathbb{E}[D_{fair} + D_{fair}]
+\end{align}
+
+We can see even that the expected value of each individual die is the same as the fair die! However, the distribution (if we are doing this correctly) should still be skewed:
+
+
+```python
+d1 = [1/3, 1/12, 1/12, 1/12, 1/12, 1/3]
+d2 = d1
+
+x1 = unfair_die(d1, 10000)
+x2 = unfair_die(d2, 10000)
+
+pd.Series(x1 + x2).plot(kind='hist', bins=11)
+plt.title("$D_1$ and $D_2$ biased to 1 and 6");
+```
+
+
+
+![png](_notebook_files/_notebook_5_0.png)
+
+
+
+In a very un-subtle way, we have of course made the values 2 and 12 far more likely.
+
+# Detection Conclusion
+
+There are some trivial examples of cheating that are easy to detect: whenever the expected value of the sum of two fair dice deviates from the expected value for the sum of two fair dice, we can immediately conclude that there is cheating at stake.
+
+The interesting edge cases occur when the expected value of the sum of loaded dice matches the expected value of the sum of fair dice. Considering the above examples (and a couple more I ran through in developing this), we have seen that in every circumstance having two unfair dice leads to a distribution of results different from the fair results.
+
+We can thus finally state: **just by looking at the distribution of results from this game, we can immediately conclude whether there is cheating.**
+
+# Simulated Annealing
+
+What we really would like to do though, is see if there is any way to determine how exactly the dice are loaded. This is significantly more complicated, but we can borrow some algorithms from Machine Learning to figure out exactly how to perform this process. I'm using the Simulated Annealing algorithm, and I discuss why this works and why I chose it over some of the alternatives in the [justification](#Justification-of-Simulated-Annealing). If you don't care about how I set up the model and just want to see the code, check out [the actual code](#The-actual-code).
+
+[Simulated Annealing][3] is a variation of the [Metropolis-Hastings Algorithm][4], but the important thing for us is: Simulated Annealing allows us to quickly optimize high-dimensional problems. But what exactly are we trying to optimize? Ideally, we want a function that can tell us whether one distribution for the dice better explains the results than another distribution. This is known as the **likelihood** function.
+
+## Deriving the Likelihood function
+
+To derive our likelihood function, we want to know: **what is the probability of seeing a specific result given those hidden parameters?** This is actually a surprisingly difficult problem. While we can do a lot of calculations by hand, we need a more general solution since we will be working with very some interesting die distributions.
+
+We first note that the sum of two dice can take on 11 different values - 2 through 12. This implies that each individual sum follows a [Categorical distribution](https://en.wikipedia.org/wiki/Categorical_distribution). That is:
+
+\begin{align}
+\mathcal{L(x)} = \left\{
+\begin{array}{lr}
+p_2 & x = 2\\
+p_3 & x = 3\\
+\ldots & \\
+p_{11} & x = 11\\
+p_{12} & x = 12
+\end{array}
+\right.
+\end{align}
+
+Where each $p_i$ is the probability of seeing that specific result. However, we need to calculate what each probability is! I'll save you the details, but [this author](http://math.stackexchange.com/a/1646360/320784) explains how to do it.
+
+Now, we would like to know the likelihood of our entire data-set. This is trivial:
+
+\begin{align}
+\mathcal{L(\mathbf{X})} &= \prod_{i=1}^n L(x)
+\end{align}
+
+However, it's typically much easier to work with the $\log(\mathcal{L})$ function instead. This is critically important from a computational perspective: when you multiply so many small numbers together (i.e. the product of $L(x)$ terms) the computer suffers from rounding error; if we don't control for this, we will find that no matter the distributions we choose for each die, the "likelihood" will be close to zero because the computer is not precise enough.
+
+\begin{align}
+\log(\mathcal{L}) &= \sum_{i=1}^n \log(L)
+\end{align}
+
+## The process of Simulated Annealing
+
+The means by which we optimize our likelihood function is the simulated annealing algorithm. The way it works is as follows:
+
+1. Start with a random guess for the parameters we are trying to optimize. In our case we are trying to guess the distribution of two dice, and so we "optimize" until we have a distribution that matches the data.
+
+2. For each iteration of the algorithm:
+
+ 1. Generate a new "proposed" set of parameters based on the current parameters -
+ i.e. slightly modify the current parameters to get a new set of parameters.
+ 2. Calculate the value of $\log(\mathcal{L})$ for each set of parameters. If the function value for the
+ proposed parameter set is higher than for the current, automatically switch to the new parameter set
+ and continue the next iteration.
+ 3. Given the new parameter set performs worse, determine a probability of switching to the new parameter set anyways: $\mathcal{P}(p_{current}, p_{proposed})$
+ 4. Switch to the new parameter set with probability $\mathcal{P}$. If you fail to switch, begin the next iteration.
+
+3. The algorithm is complete after we fail to make a transition $n$ times in a row.
+
+If everything goes according to plan, we will have a value that is close to the true distribution of each die.
+
+# The actual code
+
+We start by defining the score function. This will tell us how well the proposed die densities actually explain the results.
+
+[3]:https://en.wikipedia.org/wiki/Simulated_annealing
+[4]:https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm
+
+
+```python
+import numpy as np
+from numpy import polynomial
+
+def density_coef(d1_density, d2_density):
+ # Calculating the probabilities of each outcome was taken
+ # from this author: http://math.stackexchange.com/a/1710392/320784
+ d1_p = polynomial.Polynomial(d1_density)
+ d2_p = polynomial.Polynomial(d2_density)
+ coefs = (d1_p * d2_p).coef
+ return coefs
+
+def score(x, d1_density, d2_density):
+ # We've now got the probabilities of each event, but we need
+ # to shift the array a bit so we can use the x values to actually
+ # index into it. This will allow us to do all the calculations
+ # incredibly quickly
+ coefs = density_coef(d1_density, d2_density)
+ coefs = np.hstack((0, 0, coefs))
+ return np.log(coefs[x]).sum()
+```
+
+Afterward, we need to write something to permute the proposal densities. We make random modifications, and eventually the best one survives.
+
+
+```python
+def permute(d1_density, d2_density):
+ # To ensure we have legitimate densities, we will randomly
+ # increase one die face probability by `change`,
+ # and decrease one by `change`.
+ # This means there are something less than (1/`change`)^12 possibilities
+ # we are trying to search over.
+ change = .01
+
+ d1_index1, d1_index2 = np.random.randint(0, 6, 2)
+ d2_index1, d2_index2 = np.random.randint(0, 6, 2)
+
+ # Also make sure to copy. I've had some weird aliasing issues
+ # in the past that made everything blow up.
+ new_d1 = np.float64(np.copy(d1_density))
+ new_d2 = np.float64(np.copy(d2_density))
+
+ # While this doesn't account for the possibility that some
+ # values go negative, in practice this never happens
+ new_d1[d1_index1] += change
+ new_d1[d1_index2] -= change
+ new_d2[d2_index1] += change
+ new_d2[d2_index2] -= change
+
+ return new_d1, new_d2
+```
+
+Now we've got the main algorithm code to do. This is what brings all the pieces together.
+
+
+```python
+def optimize(data, conv_count=10, max_iter=1e4):
+ switch_failures = 0
+ iter_count = 0
+
+ # Start with guessing fair dice
+ cur_d1 = np.repeat(1/6, 6)
+ cur_d2 = np.repeat(1/6, 6)
+ cur_score = score(data, cur_d1, cur_d2)
+
+ # Keep track of our best guesses - may not be
+ # what we end with
+ max_score = cur_score
+ max_d1 = cur_d1
+ max_d2 = cur_d2
+
+ # Optimization stops when we have failed to switch `conv_count`
+ # times (presumably because we have a great guess), or we reach
+ # the maximum number of iterations.
+ while switch_failures < conv_count and iter_count < max_iter:
+ iter_count += 1
+ if iter_count % (max_iter / 10) == 0:
+ print('Iteration: {}; Current score (higher is better): {}'.format(
+ iter_count, cur_score))
+
+ new_d1, new_d2 = permute(cur_d1, cur_d2)
+ new_score = score(data, new_d1, new_d2)
+
+ if new_score > max_score:
+ max_score = new_score
+ max_d1 = new_d1
+ max_d2 = new_d2
+
+ if new_score > cur_score:
+ # If the new permutation beats the old one,
+ # automatically select it.
+ cur_score = new_score
+ cur_d1 = new_d1
+ cur_d2 = new_d2
+ switch_failures = 0
+ else:
+ # We didn't beat the current score, but allow
+ # for possibly switching anyways.
+ accept_prob = np.exp(new_score - cur_score)
+ coin_toss = np.random.rand()
+ if coin_toss < accept_prob:
+ # We randomly switch to the new distribution
+ cur_score = new_score
+ cur_d1 = new_d1
+ cur_d2 = new_d2
+ switch_failures = 0
+ else:
+ switch_failures += 1
+
+ # Return both our best guess, and the ending guess
+ return max_d1, max_d2, cur_d1, cur_d2
+```
+
+And now we have finished the hard work!
+
+# Catching the Casino
+
+Let's go through a couple of scenarios and see if we can catch the casino cheating with some loaded dice. **In every scenario we start with an assumption of fair dice**, and then try our hand to figure out what the *actual* distribution was.
+
+## Attempt 1
+
+
+The casino is using two dice that are both biased low. How well can we recover the distribution?
+
+
+```python
+import time
+def simulate_casino(d1_dist, d2_dist, n=10000):
+ d1_vals = unfair_die(d1_dist, n)
+ d2_vals = unfair_die(d2_dist, n)
+
+ start = time.perf_counter()
+ max_d1, max_d2, final_d1, final_d2 = optimize(d1_vals + d2_vals)
+ end = time.perf_counter()
+ print("Simulated Annealing time: {:.02f}s".format(end - start))
+
+ coef_range = np.arange(2, 13) - .5
+ plt.subplot(221)
+ plt.bar(coef_range, density_coef(d1_dist, d2_dist), width=1)
+ plt.title('True Distribution')
+
+ plt.subplot(222)
+ plt.hist(d1_vals + d2_vals, bins=11)
+ plt.title('Empirical Distribution')
+
+ plt.subplot(223)
+ plt.bar(coef_range, density_coef(max_d1, max_d2), width=1)
+ plt.title('Recovered Distribution')
+
+ plt.gcf().set_size_inches(10, 10)
+
+
+simulate_casino([2/9, 2/9, 2/9, 1/9, 1/9, 1/9],
+ [2/9, 2/9, 2/9, 1/9, 1/9, 1/9])
+```
+
+ Iteration: 1000; Current score (higher is better): -22147.004400281654
+ Simulated Annealing time: 0.30s
+
+
+
+
+![png](_notebook_files/_notebook_14_1.png)
+
+
+
+## Attempt 2
+
+The casino now uses dice that are both biased towards 1 and 6.
+
+
+```python
+simulate_casino([1/3, 1/12, 1/12, 1/12, 1/12, 1/3],
+ [1/3, 1/12, 1/12, 1/12, 1/12, 1/3])
+```
+
+ Simulated Annealing time: 0.08s
+
+
+
+
+![png](_notebook_files/_notebook_16_1.png)
+
+
+
+## Attempt 3
+
+The casino will now use one die biased towards 1 and 6, and one die towards 3 and 4.
+
+
+```python
+simulate_casino([1/3, 1/12, 1/12, 1/12, 1/12, 1/3],
+ [1/12, 1/12, 1/3, 1/3, 1/12, 1/12])
+```
+
+ Simulated Annealing time: 0.09s
+
+
+
+
+![png](_notebook_files/_notebook_18_1.png)
+
+
+
+## Attempt 4
+
+We'll now finally go to a fair casino to make sure that we can still recognize a positive result.
+
+
+```python
+simulate_casino(np.repeat(1/6, 6), np.repeat(1/6, 6))
+```
+
+ Simulated Annealing time: 0.02s
+
+
+
+
+![png](_notebook_files/_notebook_20_1.png)
+
+
+
+## Attempt 5
+
+We've so far been working with a large amount of data - 10,000 data points. Can we now scale things back to only 250 throws? We'll start with two dice biased high.
+
+
+```python
+simulate_casino([1/9, 1/9, 1/9, 2/9, 2/9, 2/9],
+ [1/9, 1/9, 1/9, 2/9, 2/9, 2/9],
+ n=250)
+```
+
+ Iteration: 1000; Current score (higher is better): -551.6995384525453
+ Iteration: 2000; Current score (higher is better): -547.7803673440676
+ Iteration: 3000; Current score (higher is better): -547.9805613193807
+ Iteration: 4000; Current score (higher is better): -546.7574874775273
+ Iteration: 5000; Current score (higher is better): -549.5798007672656
+ Iteration: 6000; Current score (higher is better): -545.0354060154496
+ Iteration: 7000; Current score (higher is better): -550.1134504086606
+ Iteration: 8000; Current score (higher is better): -549.9306537114975
+ Iteration: 9000; Current score (higher is better): -550.7075182119111
+ Iteration: 10000; Current score (higher is better): -549.400679551826
+ Simulated Annealing time: 1.94s
+
+
+
+
+![png](_notebook_files/_notebook_22_1.png)
+
+
+
+The results are surprisingly good. While the actual optimization process took much longer to finish than in the other examples, we still have a very good guess. As a caveat though: the recovered distribution tends to overfit the data. That is, if the data doesn't fit the underlying distribution well, the model will also fail.
+
+# Conclusion
+
+Given the results above, we can see that we have indeed come up with a very good algorithm to determine the distribution of two dice given their results. As a benefit, we have even seen that results come back very quickly; it's not uncommon for the optimization to converge within a tenth of a second.
+
+Additionally, we have seen that the algorithm can intuit the distribution even when there is not much data. While the final example shows that we can 'overfit' on the dataset, we can still get valuable information from a relatively small dataset.
+
+We can declare at long last: **the mathematicians have again triumphed over the casino**.
+
+---
+
+# Justification of Simulated Annealing
+
+## Why Simulated Annealing?
+
+So why even use an algorithm with a fancy title like Simulated Annealing? First of all, because the title is sexy. Second of all, because this is a reasonably complicated problem to try and solve. We have a parameter space where each value $p_{ij} \in (0, 1); i, j \in \{1, \ldots, 6\}$, for a total of 12 different variables we are trying to optimize over. Additionally, given a 12-dimensional function we are trying to optimize, simulated annealing makes sure that we don't fall into a local minimum.
+
+## Why not something else?
+
+This is a fair question. There are two classes of algorithms that can also be used to solve this problem: [Non-linear optimization](https://en.wikipedia.org/wiki/Nonlinear_programming) methods, and the [EM algorithm](https://en.wikipedia.org/wiki/Expectation%E2%80%93maximization_algorithm).
+
+1. I chose not to use non-linear optimization simply because I'm a bit concerned that it will trap me in a local maximum. Instead of running multiple different optimizations from different starting points, I can just use simulated annealing to take that into account. In addition, throughout the course of testing the simulated annealing code converged *incredibly* quickly - far more quickly than any non-linear solver would be able to accomplish.
+
+2. The EM Algorithm was originally what I intended to write this blog post with. Indeed, the post was inspired by the [crooked casino](http://web.stanford.edu/class/stats366/hmmR2.html) example which uses the EM algorithm to solve it. However, after modeling the likelihood function I realized that the algebra would very quickly get out of hand. Trying to compute all the polynomial terms would not be fun, which would be needed to actually optimize for each parameter. So while the EM algorithm would likely be much faster in raw speed terms, the amount of time needed to program and verify it meant that I was far better off using a different method for optimization.
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_14_1.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_14_1.png
new file mode 100644
index 0000000..d47c41f
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_14_1.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_16_1.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_16_1.png
new file mode 100644
index 0000000..d37f05b
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_16_1.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_18_1.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_18_1.png
new file mode 100644
index 0000000..f27e668
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_18_1.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_1_0.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_1_0.png
new file mode 100644
index 0000000..2206d3f
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_1_0.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_20_1.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_20_1.png
new file mode 100644
index 0000000..3ad1f11
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_20_1.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_22_1.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_22_1.png
new file mode 100644
index 0000000..8566bf7
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_22_1.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_3_0.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_3_0.png
new file mode 100644
index 0000000..0f20b92
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_3_0.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_5_0.png b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_5_0.png
new file mode 100644
index 0000000..9ebd3e1
Binary files /dev/null and b/blog/2016-05-15-the-unfair-casino/_notebook_files/_notebook_5_0.png differ
diff --git a/blog/2016-05-15-the-unfair-casino/index.mdx b/blog/2016-05-15-the-unfair-casino/index.mdx
new file mode 100644
index 0000000..a9cf07e
--- /dev/null
+++ b/blog/2016-05-15-the-unfair-casino/index.mdx
@@ -0,0 +1,487 @@
+---
+slug: 2016/05/the-unfair-casino
+title: The unfair casino
+date: 2016-05-15 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+Trying to figure out how exactly two dice are loaded in a cheating casino.
+
+
+
+In the ongoing eternal cycle of mathematicians asking generally useless questions about probability, I dreamt up another one. The scenario is as follows:
+
+**You're playing a game with two die, and you do not get to see what the outcome of the die are on each roll. All you get to see is their sum. Given an arbitrarily long list of the sum of two rolls, can you determine if one or both die are loaded, and what those loadings are?**
+
+## Proving we can detect cheating
+
+My first question is simply, is this possible? There's a lot of trivial cases that make it obvious that there's cheating going on. But there are some edge cases that might give us more difficulty. First though, let's get a picture of what the fair distribution looks like. In principle, we can only detect cheating if the distribution of the fair die differs from the distribution of the loaded die.
+
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+%matplotlib inline
+
+fair_1 = np.random.randint(1, 7, 10000)
+fair_2 = np.random.randint(1, 7, 10000)
+
+pd.Series(fair_1 + fair_2).plot(kind='hist', bins=11);
+plt.title('Fair Distribution');
+```
+
+![png](_notebook_files/_notebook_1_0.png)
+
+This distribution makes sense: there are many ways to make a 7 (the most frequent observed value) and very few ways to make a 12 or 2; an important symmetry. As a special note, you can notice that the sum of two fair dice is a discrete case of the [Triangle Distribution][1], which is itself a special case of the [Irwin-Hall Distribution][2].
+
+## The Edge Cases
+
+Given that we understand how the results of two fair dice are distributed, let's see some of the interesting edge cases that come up. This will give us assurance that when a casino is cheating, it is detectable (given sufficient data). To make this as hard as possible, we will think of scenarios where the expected value of the sum of loaded dice is the same as the expected value of the sum of fair dice.
+
+### Edge Case 1
+What happens when one die is biased low, and one die is biased high? That is, where:
+
+$$
+\begin{align*}
+\begin{array}{cc}
+D_1 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/3\\
+2 & w.p. 1/3\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/12\\
+6 & w.p. 1/12
+\end{array}
+\right. &
+D_2 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/12\\
+2 & w.p. 1/12\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/3\\
+6 & w.p. 1/3
+\end{array}
+\right. \\
+\mathbb{E}[D_1] = 2.5 & \mathbb{E}[D_2] = 4.5
+\end{array}\\
+\mathbb{E}[D_1 + D_2] = 7 = \mathbb{E}[D_{fair} + D_{fair}]
+\end{align*}
+$$
+
+[1]: https://en.wikipedia.org/wiki/Triangular_distribution
+[2]: https://en.wikipedia.org/wiki/Irwin%E2%80%93Hall_distribution
+
+
+```python
+def unfair_die(p_vals, n):
+ x = np.random.multinomial(1, p_vals, n)
+ return x.nonzero()[1] + 1
+
+d1 = [1/3, 1/3, 1/12, 1/12, 1/12, 1/12]
+d2 = [1/12, 1/12, 1/12, 1/12, 1/3, 1/3]
+
+x1 = unfair_die(d1, 10000)
+x2 = unfair_die(d2, 10000)
+
+pd.Series(x1 + x2).plot(kind='hist', bins=11);
+plt.title('$D_1$ biased low, $D_2$ biased high');
+```
+
+![png](_notebook_files/_notebook_3_0.png)
+
+We can see that while the 7 value remains the most likely (as expected), the distribution is not so nicely shaped any more.
+
+### Edge Case 2
+
+When one die is loaded low, and one is loaded high, we've seen how we can detect them. How about when two die are loaded both low and high? That is, we have the following distribution:
+
+$$
+\begin{align*}
+\begin{array}{cc}
+D_1 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/3\\
+2 & w.p. 1/12\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/12\\
+6 & w.p. 1/3
+\end{array}
+\right. &
+D_2 = \left\{
+\begin{array}{lr}
+1 & w.p. 1/3\\
+2 & w.p. 1/12\\
+3 & w.p. 1/12\\
+4 & w.p. 1/12\\
+5 & w.p. 1/12\\
+6 & w.p. 1/3
+\end{array}
+\right. \\
+\mathbb{E}[D_1] = 3.5 & \mathbb{E}[D_2] = 3.5
+\end{array}\\
+\mathbb{E}[D_1 + D_2] = 7 = \mathbb{E}[D_{fair} + D_{fair}]
+\end{align*}
+$$
+
+We can see even that the expected value of each individual die is the same as the fair die! However, the distribution (if we are doing this correctly) should still be skewed:
+
+```python
+d1 = [1/3, 1/12, 1/12, 1/12, 1/12, 1/3]
+d2 = d1
+
+x1 = unfair_die(d1, 10000)
+x2 = unfair_die(d2, 10000)
+
+pd.Series(x1 + x2).plot(kind='hist', bins=11)
+plt.title("$D_1$ and $D_2$ biased to 1 and 6");
+```
+
+![png](_notebook_files/_notebook_5_0.png)
+
+In a very un-subtle way, we have of course made the values 2 and 12 far more likely.
+
+## Detection Conclusion
+
+There are some trivial examples of cheating that are easy to detect: whenever the expected value of the sum of two fair dice deviates from the expected value for the sum of two fair dice, we can immediately conclude that there is cheating at stake.
+
+The interesting edge cases occur when the expected value of the sum of loaded dice matches the expected value of the sum of fair dice. Considering the above examples (and a couple more I ran through in developing this), we have seen that in every circumstance having two unfair dice leads to a distribution of results different from the fair results.
+
+We can thus finally state: **just by looking at the distribution of results from this game, we can immediately conclude whether there is cheating.**
+
+## Simulated Annealing
+
+What we really would like to do though, is see if there is any way to determine how exactly the dice are loaded. This is significantly more complicated, but we can borrow some algorithms from Machine Learning to figure out exactly how to perform this process. I'm using the Simulated Annealing algorithm, and I discuss why this works and why I chose it over some of the alternatives in the [justification](#Justification-of-Simulated-Annealing). If you don't care about how I set up the model and just want to see the code, check out [the actual code](#The-actual-code).
+
+[Simulated Annealing][3] is a variation of the [Metropolis-Hastings Algorithm][4], but the important thing for us is: Simulated Annealing allows us to quickly optimize high-dimensional problems. But what exactly are we trying to optimize? Ideally, we want a function that can tell us whether one distribution for the dice better explains the results than another distribution. This is known as the **likelihood** function.
+
+### Deriving the Likelihood function
+
+To derive our likelihood function, we want to know: **what is the probability of seeing a specific result given those hidden parameters?** This is actually a surprisingly difficult problem. While we can do a lot of calculations by hand, we need a more general solution since we will be working with very some interesting die distributions.
+
+We first note that the sum of two dice can take on 11 different values - 2 through 12. This implies that each individual sum follows a [Categorical distribution](https://en.wikipedia.org/wiki/Categorical_distribution). That is:
+
+$$
+\begin{align*}
+\mathcal{L(x)} = \left\{
+\begin{array}{lr}
+p_2 & x = 2\\
+p_3 & x = 3\\
+\ldots & \\
+p_{11} & x = 11\\
+p_{12} & x = 12
+\end{array}
+\right.
+\end{align*}
+$$
+
+Where each $p_i$ is the probability of seeing that specific result. However, we need to calculate what each probability is! I'll save you the details, but [this author](http://math.stackexchange.com/a/1646360/320784) explains how to do it.
+
+Now, we would like to know the likelihood of our entire data-set. This is trivial:
+
+$$
+\begin{align*}
+\mathcal{L(\mathbf{X})} &= \prod_{i=1}^n L(x)
+\end{align*}
+$$
+
+However, it's typically much easier to work with the $\log(\mathcal{L})$ function instead. This is critically important from a computational perspective: when you multiply so many small numbers together (i.e. the product of $L(x)$ terms) the computer suffers from rounding error; if we don't control for this, we will find that no matter the distributions we choose for each die, the "likelihood" will be close to zero because the computer is not precise enough.
+
+$$
+\begin{align*}
+\log(\mathcal{L}) &= \sum_{i=1}^n \log(L)
+\end{align*}
+$$
+
+### The process of Simulated Annealing
+
+The means by which we optimize our likelihood function is the simulated annealing algorithm. The way it works is as follows:
+
+1. Start with a random guess for the parameters we are trying to optimize. In our case we are trying to guess the distribution of two dice, and so we "optimize" until we have a distribution that matches the data.
+
+2. For each iteration of the algorithm:
+
+ 1. Generate a new "proposed" set of parameters based on the current parameters -
+ i.e. slightly modify the current parameters to get a new set of parameters.
+ 2. Calculate the value of $\log(\mathcal{L})$ for each set of parameters. If the function value for the
+ proposed parameter set is higher than for the current, automatically switch to the new parameter set
+ and continue the next iteration.
+ 3. Given the new parameter set performs worse, determine a probability of switching to the new parameter set anyways: $\mathcal{P}(p_{current}, p_{proposed})$
+ 4. Switch to the new parameter set with probability $\mathcal{P}$. If you fail to switch, begin the next iteration.
+
+3. The algorithm is complete after we fail to make a transition $n$ times in a row.
+
+If everything goes according to plan, we will have a value that is close to the true distribution of each die.
+
+## The actual code
+
+We start by defining the score function. This will tell us how well the proposed die densities actually explain the results.
+
+[3]:https://en.wikipedia.org/wiki/Simulated_annealing
+[4]:https://en.wikipedia.org/wiki/Metropolis%E2%80%93Hastings_algorithm
+
+
+```python
+import numpy as np
+from numpy import polynomial
+
+def density_coef(d1_density, d2_density):
+ # Calculating the probabilities of each outcome was taken
+ # from this author: http://math.stackexchange.com/a/1710392/320784
+ d1_p = polynomial.Polynomial(d1_density)
+ d2_p = polynomial.Polynomial(d2_density)
+ coefs = (d1_p * d2_p).coef
+ return coefs
+
+def score(x, d1_density, d2_density):
+ # We've now got the probabilities of each event, but we need
+ # to shift the array a bit so we can use the x values to actually
+ # index into it. This will allow us to do all the calculations
+ # incredibly quickly
+ coefs = density_coef(d1_density, d2_density)
+ coefs = np.hstack((0, 0, coefs))
+ return np.log(coefs[x]).sum()
+```
+
+Afterward, we need to write something to permute the proposal densities. We make random modifications, and eventually the best one survives.
+
+
+```python
+def permute(d1_density, d2_density):
+ # To ensure we have legitimate densities, we will randomly
+ # increase one die face probability by `change`,
+ # and decrease one by `change`.
+ # This means there are something less than (1/`change`)^12 possibilities
+ # we are trying to search over.
+ change = .01
+
+ d1_index1, d1_index2 = np.random.randint(0, 6, 2)
+ d2_index1, d2_index2 = np.random.randint(0, 6, 2)
+
+ # Also make sure to copy. I've had some weird aliasing issues
+ # in the past that made everything blow up.
+ new_d1 = np.float64(np.copy(d1_density))
+ new_d2 = np.float64(np.copy(d2_density))
+
+ # While this doesn't account for the possibility that some
+ # values go negative, in practice this never happens
+ new_d1[d1_index1] += change
+ new_d1[d1_index2] -= change
+ new_d2[d2_index1] += change
+ new_d2[d2_index2] -= change
+
+ return new_d1, new_d2
+```
+
+Now we've got the main algorithm code to do. This is what brings all the pieces together.
+
+
+```python
+def optimize(data, conv_count=10, max_iter=1e4):
+ switch_failures = 0
+ iter_count = 0
+
+ # Start with guessing fair dice
+ cur_d1 = np.repeat(1/6, 6)
+ cur_d2 = np.repeat(1/6, 6)
+ cur_score = score(data, cur_d1, cur_d2)
+
+ # Keep track of our best guesses - may not be
+ # what we end with
+ max_score = cur_score
+ max_d1 = cur_d1
+ max_d2 = cur_d2
+
+ # Optimization stops when we have failed to switch `conv_count`
+ # times (presumably because we have a great guess), or we reach
+ # the maximum number of iterations.
+ while switch_failures < conv_count and iter_count < max_iter:
+ iter_count += 1
+ if iter_count % (max_iter / 10) == 0:
+ print('Iteration: {}; Current score (higher is better): {}'.format(
+ iter_count, cur_score))
+
+ new_d1, new_d2 = permute(cur_d1, cur_d2)
+ new_score = score(data, new_d1, new_d2)
+
+ if new_score > max_score:
+ max_score = new_score
+ max_d1 = new_d1
+ max_d2 = new_d2
+
+ if new_score > cur_score:
+ # If the new permutation beats the old one,
+ # automatically select it.
+ cur_score = new_score
+ cur_d1 = new_d1
+ cur_d2 = new_d2
+ switch_failures = 0
+ else:
+ # We didn't beat the current score, but allow
+ # for possibly switching anyways.
+ accept_prob = np.exp(new_score - cur_score)
+ coin_toss = np.random.rand()
+ if coin_toss < accept_prob:
+ # We randomly switch to the new distribution
+ cur_score = new_score
+ cur_d1 = new_d1
+ cur_d2 = new_d2
+ switch_failures = 0
+ else:
+ switch_failures += 1
+
+ # Return both our best guess, and the ending guess
+ return max_d1, max_d2, cur_d1, cur_d2
+```
+
+And now we have finished the hard work!
+
+## Catching the Casino
+
+Let's go through a couple of scenarios and see if we can catch the casino cheating with some loaded dice. **In every scenario we start with an assumption of fair dice**, and then try our hand to figure out what the *actual* distribution was.
+
+### Attempt 1
+
+
+The casino is using two dice that are both biased low. How well can we recover the distribution?
+
+
+```python
+import time
+def simulate_casino(d1_dist, d2_dist, n=10000):
+ d1_vals = unfair_die(d1_dist, n)
+ d2_vals = unfair_die(d2_dist, n)
+
+ start = time.perf_counter()
+ max_d1, max_d2, final_d1, final_d2 = optimize(d1_vals + d2_vals)
+ end = time.perf_counter()
+ print("Simulated Annealing time: {:.02f}s".format(end - start))
+
+ coef_range = np.arange(2, 13) - .5
+ plt.subplot(221)
+ plt.bar(coef_range, density_coef(d1_dist, d2_dist), width=1)
+ plt.title('True Distribution')
+
+ plt.subplot(222)
+ plt.hist(d1_vals + d2_vals, bins=11)
+ plt.title('Empirical Distribution')
+
+ plt.subplot(223)
+ plt.bar(coef_range, density_coef(max_d1, max_d2), width=1)
+ plt.title('Recovered Distribution')
+
+ plt.gcf().set_size_inches(10, 10)
+
+
+simulate_casino([2/9, 2/9, 2/9, 1/9, 1/9, 1/9],
+ [2/9, 2/9, 2/9, 1/9, 1/9, 1/9])
+```
+
+```
+ Iteration: 1000; Current score (higher is better): -22147.004400281654
+ Simulated Annealing time: 0.30s
+```
+
+![png](_notebook_files/_notebook_14_1.png)
+
+### Attempt 2
+
+The casino now uses dice that are both biased towards 1 and 6.
+
+```python
+simulate_casino([1/3, 1/12, 1/12, 1/12, 1/12, 1/3],
+ [1/3, 1/12, 1/12, 1/12, 1/12, 1/3])
+```
+
+```
+ Simulated Annealing time: 0.08s
+```
+
+![png](_notebook_files/_notebook_16_1.png)
+
+### Attempt 3
+
+The casino will now use one die biased towards 1 and 6, and one die towards 3 and 4.
+
+
+```python
+simulate_casino([1/3, 1/12, 1/12, 1/12, 1/12, 1/3],
+ [1/12, 1/12, 1/3, 1/3, 1/12, 1/12])
+```
+
+```
+ Simulated Annealing time: 0.09s
+```
+
+![png](_notebook_files/_notebook_18_1.png)
+
+### Attempt 4
+
+We'll now finally go to a fair casino to make sure that we can still recognize a positive result.
+
+```python
+simulate_casino(np.repeat(1/6, 6), np.repeat(1/6, 6))
+```
+
+```
+ Simulated Annealing time: 0.02s
+```
+
+![png](_notebook_files/_notebook_20_1.png)
+
+### Attempt 5
+
+We've so far been working with a large amount of data - 10,000 data points. Can we now scale things back to only 250 throws? We'll start with two dice biased high.
+
+
+```python
+simulate_casino([1/9, 1/9, 1/9, 2/9, 2/9, 2/9],
+ [1/9, 1/9, 1/9, 2/9, 2/9, 2/9],
+ n=250)
+```
+
+```
+ Iteration: 1000; Current score (higher is better): -551.6995384525453
+ Iteration: 2000; Current score (higher is better): -547.7803673440676
+ Iteration: 3000; Current score (higher is better): -547.9805613193807
+ Iteration: 4000; Current score (higher is better): -546.7574874775273
+ Iteration: 5000; Current score (higher is better): -549.5798007672656
+ Iteration: 6000; Current score (higher is better): -545.0354060154496
+ Iteration: 7000; Current score (higher is better): -550.1134504086606
+ Iteration: 8000; Current score (higher is better): -549.9306537114975
+ Iteration: 9000; Current score (higher is better): -550.7075182119111
+ Iteration: 10000; Current score (higher is better): -549.400679551826
+ Simulated Annealing time: 1.94s
+```
+
+![png](_notebook_files/_notebook_22_1.png)
+
+The results are surprisingly good. While the actual optimization process took much longer to finish than in the other examples, we still have a very good guess. As a caveat though: the recovered distribution tends to overfit the data. That is, if the data doesn't fit the underlying distribution well, the model will also fail.
+
+## Conclusion
+
+Given the results above, we can see that we have indeed come up with a very good algorithm to determine the distribution of two dice given their results. As a benefit, we have even seen that results come back very quickly; it's not uncommon for the optimization to converge within a tenth of a second.
+
+Additionally, we have seen that the algorithm can intuit the distribution even when there is not much data. While the final example shows that we can 'overfit' on the dataset, we can still get valuable information from a relatively small dataset.
+
+We can declare at long last: **the mathematicians have again triumphed over the casino**.
+
+---
+
+## Justification of Simulated Annealing
+
+### Why Simulated Annealing?
+
+So why even use an algorithm with a fancy title like Simulated Annealing? First of all, because the title is sexy. Second of all, because this is a reasonably complicated problem to try and solve. We have a parameter space where each value $p_{ij} \in (0, 1); i, j \in \{1, \ldots, 6\}$, for a total of 12 different variables we are trying to optimize over. Additionally, given a 12-dimensional function we are trying to optimize, simulated annealing makes sure that we don't fall into a local minimum.
+
+### Why not something else?
+
+This is a fair question. There are two classes of algorithms that can also be used to solve this problem: [Non-linear optimization](https://en.wikipedia.org/wiki/Nonlinear_programming) methods, and the [EM algorithm](https://en.wikipedia.org/wiki/Expectation%E2%80%93maximization_algorithm).
+
+1. I chose not to use non-linear optimization simply because I'm a bit concerned that it will trap me in a local maximum. Instead of running multiple different optimizations from different starting points, I can just use simulated annealing to take that into account. In addition, throughout the course of testing the simulated annealing code converged *incredibly* quickly - far more quickly than any non-linear solver would be able to accomplish.
+
+2. The EM Algorithm was originally what I intended to write this blog post with. Indeed, the post was inspired by the [crooked casino](http://web.stanford.edu/class/stats366/hmmR2.html) example which uses the EM algorithm to solve it. However, after modeling the likelihood function I realized that the algebra would very quickly get out of hand. Trying to compute all the polynomial terms would not be fun, which would be needed to actually optimize for each parameter. So while the EM algorithm would likely be much faster in raw speed terms, the amount of time needed to program and verify it meant that I was far better off using a different method for optimization.
\ No newline at end of file
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_article.md b/blog/2016-06-08-event-studies-and-earnings-releases/_article.md
new file mode 100644
index 0000000..e5ad4bf
--- /dev/null
+++ b/blog/2016-06-08-event-studies-and-earnings-releases/_article.md
@@ -0,0 +1,17 @@
+Title: Event Studies and Earnings Releases
+Date: 2016-06-08
+Category: Blog
+Tags: event study, earnings
+Authors: Bradlee Speice
+Summary: Looking at earnings releases to see how good people are at actually predicting earnings.
+[//]: <> "Modified: "
+
+
+
+{% notebook 2016-6-8-event-studies-and-earnings-releases.ipynb %}
+
+
+
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook.ipynb b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook.ipynb
new file mode 100644
index 0000000..87f3b58
--- /dev/null
+++ b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook.ipynb
@@ -0,0 +1,994 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Or, being suspicious of market insiders.\n",
+ "\n",
+ "---\n",
+ "\n",
+ "Use the button below to show the code I've used to generate this article. Because there is a significant amount more code involved than most other posts I've written, it's hidden by default to allow people to concentrate on the important bits."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ ""
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import HTML\n",
+ "\n",
+ "HTML('''\n",
+ "''')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# The Market Just Knew\n",
+ "\n",
+ "I recently saw two examples of stock charts that have kept me thinking for a while. And now that the semester is complete, I finally have enough time to really look at them and give them the treatment they deserve. The first is good old Apple:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false,
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEKCAYAAAACS67iAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrgAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from secrets import QUANDL_KEY\n",
+ "import matplotlib.pyplot as plt\n",
+ "from matplotlib.dates import date2num\n",
+ "from matplotlib.finance import candlestick_ohlc\n",
+ "from matplotlib.dates import DateFormatter, WeekdayLocator,\\\n",
+ " DayLocator, MONDAY\n",
+ "import quandl\n",
+ "from datetime import datetime\n",
+ "import pandas as pd\n",
+ "%matplotlib inline\n",
+ "\n",
+ "def fetch_ticker(ticker, start, end):\n",
+ " # Quandl is currently giving me issues with returning\n",
+ " # the entire dataset and not slicing server-side.\n",
+ " # So instead, we'll do it client-side!\n",
+ " q_format = '%Y-%m-%d'\n",
+ " ticker_data = quandl.get('YAHOO/' + ticker,\n",
+ " start_date=start.strftime(q_format),\n",
+ " end_date=end.strftime(q_format),\n",
+ " authtoken=QUANDL_KEY)\n",
+ " return ticker_data\n",
+ "\n",
+ "def ohlc_dataframe(data, ax=None):\n",
+ " # Much of this code re-used from:\n",
+ " # http://matplotlib.org/examples/pylab_examples/finance_demo.html\n",
+ " if ax is None:\n",
+ " f, ax = plt.subplots()\n",
+ " \n",
+ " vals = [(date2num(date), *(data.loc[date]))\n",
+ " for date in data.index]\n",
+ " candlestick_ohlc(ax, vals)\n",
+ " \n",
+ " mondays = WeekdayLocator(MONDAY)\n",
+ " alldays = DayLocator()\n",
+ " weekFormatter = DateFormatter('%b %d')\n",
+ " ax.xaxis.set_major_locator(mondays)\n",
+ " ax.xaxis.set_minor_locator(alldays)\n",
+ " ax.xaxis.set_major_formatter(weekFormatter)\n",
+ " return ax\n",
+ "\n",
+ "AAPL = fetch_ticker('AAPL', datetime(2016, 3, 1), datetime(2016, 5, 1))\n",
+ "ax = ohlc_dataframe(AAPL)\n",
+ "plt.vlines(date2num(datetime(2016, 4, 26, 12)),\n",
+ " ax.get_ylim()[0], ax.get_ylim()[1],\n",
+ " color='b',\n",
+ " label='Earnings Release')\n",
+ "plt.legend(loc=3)\n",
+ "plt.title(\"Apple Price 3/1/2016 - 5/1/2016\");"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The second chart is from Facebook:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAEKCAYAAAAGvn7fAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nczHjid0552LGE7tzzsXM/wfgLII59KYqMQAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "FB = fetch_ticker('FB', datetime(2016, 3, 1), datetime(2016, 5, 5))\n",
+ "ax = ohlc_dataframe(FB)\n",
+ "plt.vlines(date2num(datetime(2016, 4, 27, 12)),\n",
+ " ax.get_ylim()[0], ax.get_ylim()[1],\n",
+ " color='b', label='Earnings Release')\n",
+ "plt.title('Facebook Price 3/5/2016 - 5/5/2016')\n",
+ "plt.legend(loc=2);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "These two charts demonstrate two very specific phonomena: how the market prepares for earnings releases. Let's look at those charts again, but with some extra information. As we're about the see, the market \"knew\" in advance that Apple was going to perform poorly. The market expected that Facebook was going to perform poorly, and instead shot the lights out. Let's see that trend in action:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAF6CAYAAABP8MBVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ncAw4PwAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def plot_hilo(ax, start, end, data):\n",
+ " ax.plot([date2num(start), date2num(end)],\n",
+ " [data.loc[start]['High'], data.loc[end]['High']],\n",
+ " color='b')\n",
+ " ax.plot([date2num(start), date2num(end)],\n",
+ " [data.loc[start]['Low'], data.loc[end]['Low']],\n",
+ " color='b')\n",
+ "\n",
+ "f, axarr = plt.subplots(1, 2)\n",
+ "\n",
+ "ax_aapl = axarr[0]\n",
+ "ax_fb = axarr[1]\n",
+ "\n",
+ "# Plot the AAPL trend up and down\n",
+ "ohlc_dataframe(AAPL, ax=ax_aapl)\n",
+ "plot_hilo(ax_aapl, datetime(2016, 3, 1), datetime(2016, 4, 15), AAPL)\n",
+ "plot_hilo(ax_aapl, datetime(2016, 4, 18), datetime(2016, 4, 26), AAPL)\n",
+ "ax_aapl.vlines(date2num(datetime(2016, 4, 26, 12)),\n",
+ " ax_aapl.get_ylim()[0], ax_aapl.get_ylim()[1],\n",
+ " color='g', label='Earnings Release')\n",
+ "ax_aapl.legend(loc=2)\n",
+ "ax_aapl.set_title('AAPL Price History')\n",
+ "\n",
+ "# Plot the FB trend down and up\n",
+ "ohlc_dataframe(FB, ax=ax_fb)\n",
+ "plot_hilo(ax_fb, datetime(2016, 3, 30), datetime(2016, 4, 27), FB)\n",
+ "plot_hilo(ax_fb, datetime(2016, 4, 28), datetime(2016, 5, 5), FB)\n",
+ "ax_fb.vlines(date2num(datetime(2016, 4, 27, 12)),\n",
+ " ax_fb.get_ylim()[0], ax_fb.get_ylim()[1],\n",
+ " color='g', label='Earnings Release')\n",
+ "ax_fb.legend(loc=2)\n",
+ "ax_fb.set_title('FB Price History')\n",
+ "\n",
+ "f.set_size_inches(18, 6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "As we can see above, the market broke a prevailing trend on Apple in order to go down, and ultimately predict the earnings release. For Facebook, the opposite happened. While the trend was down, the earnings were fantastic and the market corrected itself much higher."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Formulating the Question\n",
+ "\n",
+ "While these are two specific examples, there are plenty of other examples you could cite one way or another. Even if the preponderance of evidence shows that the market correctly predicts earnings releases, we need not accuse people of collusion; for a company like Apple with many suppliers we can generally forecast how Apple has done based on those same suppliers.\n",
+ "\n",
+ "The question then, is this: **how well does the market predict the earnings releases?** It's an incredibly broad question that I want to disect in a couple of different ways:\n",
+ "\n",
+ "1. Given a stock that has been trending down over the past N days before an earnings release, how likely does it continue downward after the release?\n",
+ "2. Given a stock trending up, how likely does it continue up?\n",
+ "3. Is there a difference in accuracy between large- and small-cap stocks?\n",
+ "4. How often, and for how long, do markets trend before an earnings release?\n",
+ "\n",
+ "**I want to especially thank Alejandro Saltiel for helping me retrieve the data.** He's great. And now for all of the interesting bits."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Event Studies\n",
+ "\n",
+ "Before we go too much further, I want to introduce the actual event study. Each chart intends to capture a lot of information and present an easy-to-understand pattern:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtEAAAFwCAYAAAB+YSfRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "from pandas.tseries.holiday import USFederalHolidayCalendar\n",
+ "from pandas.tseries.offsets import CustomBusinessDay\n",
+ "from datetime import datetime, timedelta\n",
+ "\n",
+ "# If you remove rules, it removes them from *all* calendars\n",
+ "# To ensure we don't pop rules we don't want to, first make\n",
+ "# sure to fully copy the object\n",
+ "trade_calendar = USFederalHolidayCalendar()\n",
+ "trade_calendar.rules.pop(6) # Remove Columbus day\n",
+ "trade_calendar.rules.pop(7) # Remove Veteran's day\n",
+ "TradeDay = lambda days: CustomBusinessDay(days, calendar=trade_calendar)\n",
+ "\n",
+ "def plot_study(array):\n",
+ " # Given a 2-d array, we assume the event happens at index `lookback`,\n",
+ " # and create all of our summary statistics from there.\n",
+ " lookback = int((array.shape[1] - 1) / 2)\n",
+ " norm_factor = np.repeat(array[:,lookback].reshape(-1, 1), array.shape[1], axis=1)\n",
+ " centered_data = array / norm_factor - 1\n",
+ " lookforward = centered_data.shape[1] - lookback\n",
+ " means = centered_data.mean(axis=0)\n",
+ " lookforward_data = centered_data[:,lookforward:]\n",
+ " std_dev = np.hstack([0, lookforward_data.std(axis=0)])\n",
+ " maxes = lookforward_data.max(axis=0)\n",
+ " mins = lookforward_data.min(axis=0)\n",
+ " \n",
+ " f, axarr = plt.subplots(1, 2)\n",
+ " range_begin = -lookback\n",
+ " range_end = lookforward\n",
+ " axarr[0].plot(range(range_begin, range_end), means)\n",
+ " axarr[1].plot(range(range_begin, range_end), means)\n",
+ " axarr[0].fill_between(range(0, range_end),\n",
+ " means[-lookforward:] + std_dev,\n",
+ " means[-lookforward:] - std_dev,\n",
+ " alpha=.5, label=\"$\\pm$ 1 s.d.\")\n",
+ " axarr[1].fill_between(range(0, range_end),\n",
+ " means[-lookforward:] + std_dev,\n",
+ " means[-lookforward:] - std_dev,\n",
+ " alpha=.5, label=\"$\\pm$ 1 s.d.\")\n",
+ " \n",
+ " max_err = maxes - means[-lookforward+1:]\n",
+ " min_err = means[-lookforward+1:] - mins\n",
+ " axarr[0].errorbar(range(1, range_end),\n",
+ " means[-lookforward+1:],\n",
+ " yerr=[min_err, max_err], label='Max & Min')\n",
+ " axarr[0].legend(loc=2)\n",
+ " axarr[1].legend(loc=2)\n",
+ " \n",
+ " axarr[0].set_xlim((-lookback-1, lookback+1))\n",
+ " axarr[1].set_xlim((-lookback-1, lookback+1))\n",
+ " \n",
+ "def plot_study_small(array):\n",
+ " # Given a 2-d array, we assume the event happens at index `lookback`,\n",
+ " # and create all of our summary statistics from there.\n",
+ " lookback = int((array.shape[1] - 1) / 2)\n",
+ " norm_factor = np.repeat(array[:,lookback].reshape(-1, 1), array.shape[1], axis=1)\n",
+ " centered_data = array / norm_factor - 1\n",
+ " lookforward = centered_data.shape[1] - lookback\n",
+ " means = centered_data.mean(axis=0)\n",
+ " lookforward_data = centered_data[:,lookforward:]\n",
+ " std_dev = np.hstack([0, lookforward_data.std(axis=0)])\n",
+ " maxes = lookforward_data.max(axis=0)\n",
+ " mins = lookforward_data.min(axis=0)\n",
+ " \n",
+ " range_begin = -lookback\n",
+ " range_end = lookforward\n",
+ " plt.plot(range(range_begin, range_end), means)\n",
+ " plt.fill_between(range(0, range_end),\n",
+ " means[-lookforward:] + std_dev,\n",
+ " means[-lookforward:] - std_dev,\n",
+ " alpha=.5, label=\"$\\pm$ 1 s.d.\")\n",
+ " \n",
+ " max_err = maxes - means[-lookforward+1:]\n",
+ " min_err = means[-lookforward+1:] - mins\n",
+ " plt.errorbar(range(1, range_end),\n",
+ " means[-lookforward+1:],\n",
+ " yerr=[min_err, max_err], label='Max & Min')\n",
+ " plt.legend(loc=2)\n",
+ " plt.xlim((-lookback-1, lookback+1))\n",
+ " \n",
+ "def fetch_event_data(ticker, events, horizon=5):\n",
+ " # Use horizon+1 to account for including the day of the event,\n",
+ " # and half-open interval - that is, for a horizon of 5,\n",
+ " # we should be including 11 events. Additionally, using the\n",
+ " # CustomBusinessDay means we automatically handle issues if\n",
+ " # for example a company reports Friday afternoon - the date\n",
+ " # calculator will turn this into a \"Saturday\" release, but\n",
+ " # we effectively shift that to Monday with the logic below.\n",
+ " td_back = TradeDay(horizon+1)\n",
+ " td_forward = TradeDay(horizon+1)\n",
+ " \n",
+ " start_date = min(events) - td_back\n",
+ " end_date = max(events) + td_forward\n",
+ " total_data = fetch_ticker(ticker, start_date, end_date)\n",
+ " event_data = [total_data.ix[event-td_back:event+td_forward]\\\n",
+ " [0:horizon*2+1]\\\n",
+ " ['Adjusted Close']\n",
+ " for event in events]\n",
+ " return np.array(event_data)\n",
+ "\n",
+ "# Generate a couple of random events\n",
+ "\n",
+ "event_dates = [datetime(2016, 5, 27) - timedelta(days=1) - TradeDay(x*20) for x in range(1, 40)]\n",
+ "data = fetch_event_data('CELG', event_dates)\n",
+ "plot_study_small(data)\n",
+ "plt.legend(loc=3)\n",
+ "plt.gcf().set_size_inches(12, 6);\n",
+ "\n",
+ "\n",
+ "plt.annotate('Mean price for days leading up to each event',\n",
+ " (-5, -.01), (-4.5, .025),\n",
+ " arrowprops=dict(facecolor='black', shrink=0.05))\n",
+ "plt.annotate('', (-.1, .005), (-.5, .02),\n",
+ " arrowprops={'facecolor': 'black', 'shrink': .05})\n",
+ "plt.annotate('$\\pm$ 1 std. dev. each day', (5, .055), (2.5, .085),\n",
+ " arrowprops={'facecolor': 'black', 'shrink': .05})\n",
+ "plt.annotate('Min/Max each day', (.9, -.07), (-1, -.1),\n",
+ " arrowprops={'facecolor': 'black', 'shrink': .05});"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And as a quick textual explanation as well:\n",
+ "\n",
+ "- The blue line represents the mean price for each day, represented as a percentage of the price on the '0-day'. For example, if we defined an 'event' as whenever the stock price dropped for three days, we would see a decreasing blue line to the left of the 0-day.\n",
+ "\n",
+ "- The blue shaded area represents one standard deviation above and below the mean price for each day following an event. This is intended to give us an idea of what the stock price does in general following an event.\n",
+ "\n",
+ "- The green bars are the minimum and maximum price for each day following an event. This instructs us as to how much it's possible for the stock to move."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Event Type 1: Trending down over the past N days\n",
+ "\n",
+ "The first type of event I want to study is how stocks perform when they've been trending down over the past couple of days prior to a release. However, we need to clarify what exactly is meant by \"trending down.\" To do so, we'll use the following metric: **the midpoint between each day's opening and closing price goes down over a period of N days**.\n",
+ "\n",
+ "It's probably helpful to have an example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBEAAAF6CAYAAABP8MBVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xl4VNX5wPHvi6AVZbcQEARcUNSKWBdcG6RV625VqtQF\nrLbaxa3uVUlatS7UWrX0pxbEui+1WjfUWrEiWre6o4IaUTDRsghK6wLn98cdYggJCTDJZPl+nmee\nzJx75p53htG5895z3xMpJSRJkiRJkurSptABSJIkSZKk5sEkgiRJkiRJqheTCJIkSZIkqV5MIkiS\nJEmSpHoxiSBJkiRJkurFJIIkSZIkSaoXkwhSMxYR90fE4bVs6xsRiyNilf87j4hXImKXVd1PPcbJ\nW8ySJKnwIuLMiLh6OdvfiYhd8zDOHyPil6u6n3qOlZeYpebKA3UpTyKiLCIWRsT8iFiQ+1tU5Yfx\n/Nztg4j4Q0Sstpx9LY6I8qo/piOibUR8GBGLlrSllPZMKV2/nLBSPl5bSmnzlNI/69O3ri/WiPhW\nRCzKvRcfR8TUiBhZdbh6jjM6Iv5cn76SJLU0ETEpIuZERLtatpfkjie2qdZ+ZER8mfsenhcRz0fE\nXrlt34qI91Zg/MUR8Y1q7X/Nte8CkFL6TUrpRyv3KusvpXRcSun8+vSNiGsj4ld19Flc5XjuvYj4\nbUTEisS0Iu+n1JyYRJDyJwF7pZQ6ppQ65P6WV9nWKaXUEfgGsD3w0zr2Nxf4bpXH3wXm5DvoApmZ\ne386AWcA10TEJoUOSpKk5iAi+gI7AYuBfWvpdjgwGziihm1Tct/DnYHxwG0R0Sm3rb4nIBLwRtX9\nR0RXYAjwYT330ZQlYIvcsdswYARwzAruI8jTCR2pKTGJIOXX8jLUAZBS+g/wMLBpHfu6HjiyyuMj\ngOuW2mHEoxFxVO5+m4gYExEfRcR0YK8a+l4QEf/KzQD4a0R0rrJ939xlC3Mi4h9Vf9RXnV2QmwFw\na0Rcl8vOvxwRW+W2/RlYD7gnt+2UOl4jKaW7yRImy7wfEdEzIu6OiNkR8WZEHJ1r3x04C/h+7izB\nv+saR5KkFuQI4ElgAjCy+sbcLIAi4Hjg0Ihou5x9jQfWBDZYiThuJPsuXnL8cyhwJ/B5lVhGR8T1\nVR4fnpu9+VFEnFUt7tERcXtE3JI7jng2Iraosn2T3PHM3Nzxxz5VtlXOLlgyAyAiTo6IioiYuWTW\nY0QcA/wAOC03xt21vLbgq2O3N4HHgc2X6RSxekRclhvj/Yj4XUS0i4j2wP1AryozGorq+b5KTZpJ\nBKnxBEBE9AJ2J/vyr00C7gJ2iYiOuR/7OwG1fdEB/AjYExgEbA0cVEOfw8kONoqARcAVuZgGADeR\nHWx8HXiALBFQ20HHPrn+nYB7gD8ApJSOAGYAe+fOcIxZTrxE5oDcfl6qocutuf0VAQcDF0REcUrp\nQeAC4NbcrI/ByxtHkqQW5gjgBrLv4t0j4us1bL8HuD33eB9qkPuePwZYAExbiThmAa8Bu1UZ988s\ne1Il5cbbFBhL9iO+F9ANWLda333Jvv+7ADcDd0XEarlY7wEmkh2rHA/cGBEb1RJbEdAhN87RwB8i\nolNK6Rqy5MfFuWOV/ep6kbm4dwaer2Hz2cC2wBZkx2DbAmenlBaSzSKdVcMMValZM4kg5ddduTP5\ncyLizirtAXwUEXOB94BPgL/Usa//AX8DDgG+n7v/2XL6HwxcllKalVKaB/ymhj7Xp5SmppT+C5wD\nHJw7ezAcuDel9I+U0iJgDNlZiR1qGWtySunBlFIimzGxRbXtdV0zuG5EzAE+ysVxWEpp+lI7iOhD\ndtnH6SmlL1JKLwJ/ouZpmZIktQoRsRPZrL/bUkrPA9PJptov2b4m2THBjSmlL4E7WPa7c/vc9/As\nsmOM/VNKC1YypD8DR0bExmSXbv5rOX0PBO5JKT2RUvqC7Big+nT/51JKf80dj1wKrEF2icQQYK2U\n0kUppS9TSo8C95LNfqjJ58CvU0qLUkoPkB17bbyCr+35iJhNdhLn6pTShBr6jABKU0qzU0qzgVKy\nkzZSi7W8qU2SVtx+uS+16hLQLaWUImIN4NfAQ9T+I33Jj/Dr+SoZcHodY/ciS1As8W4Nfapvbwes\nk3tuZf9cnO+x7NmBJapm0hcCX4uINimlxXXEuMTMlNJ6dfTpCczJZfKrxvzNeo4hSVJLdATwUEpp\nbu7xzWSXP/4+9/h7wBdkswohm63wcER0y/3IBXgypZSvVZf+SvZjfzbZccvyLHWsklJamPuRXlXV\n7SkiZuaeFyx9HAPZcUFtxyqzqx2XLATWriO+6ganlN6po08vslmTVWPqtYLjSM2KSQQpv+qqiZBS\nSp9FxATglIjomlKqtVhiSunxiOgJLEopPRERy7te8QOgT5XHfWvoU337F8B/yM5EVL/Orw/w/nLG\nq02+CgjNArpGxFoppU9zbesBM/M8jiRJzUJEfI1s9mCbiPgg17w60DkivpFSepksybA2MCM32zDI\njvlHkLuMMZ9SSv+NiAeAY4H16+j+AVC15lJ7sksaqupTZXsAvcmOCYLsOKCq9ciKO65w2PXsV5/V\nGGaRHVNNzT3um2tbkXGkZsXLGaTGUVmcJzcT4Qjgg+UlEKrYG6h6vV5tX2i3AcdHxLoR0YWaZy4c\nlitK1J5sut3tuUsSbgP2ioihkS0leQrZ5RTLq9tQVdWYyqn7IKLOfaWU3gemAL+JiDVyhZV+yFdn\nOSqAflWKOUmS1NIdAHwJDCS7/n5Q7v7jwBG5ukvDyIorb5nbvgVwMUsXa16eyH3vVt7q8ZwzgW+l\nlOpazvAOYO+I2CGypSl/xbLHNd+MiP0jWwr7JLLjkaeAfwGfRsRpuWOVYrJjpJvr+bqqqmDVjlWq\nuhk4OyLWiYh1yC7RqHqs0i0iOuZpLKlJMIkg5c/yss0JmBsR88my8NtR+5JMS+0rV8Ngak3bqt2/\nBngQeBF4lpprLlxPtsLDLLIzFyfkxngTOAy4kqxOwV7APrlrKet6bdW3Xwick6sLcXIdz6trX4cC\n/XPx/gU4p8rlIreTHXjMjohnV2IcSZKamyOA8SmlmSmlD5fcyAoc/4CsePK/U0qPVNt+OfCNXIHA\nuvQim/q/EPgvsDAiavrBXfVYpTylNKWmbUs9IaXXyJa4vpnsu302y856vJusTsPc3Gs6IFfX4Auy\nApF7ks2ivBI4PKVU34KQVWMaB2xWQw2r2vovb9t5ZMddL/HVMdj5ACmlN8he69u5sVydQS1CZCch\nl9MhYhxZlq8ipbRFru1isv+IPwPeAkallOZHxLfJfkC0Iytmclot14dLamQR8ShZYcXxhY5FklZU\nLccjBwElZGdit8kVmSMilkwtfj339KdSSj9p9KAlrZCIGA1skFvtSVITVZ+ZCNeSLUdX1UPAZiml\nLcmWgzkz1/4R2dJug8gyoXUVV5EkSaqPmo5HXiab3v1YDf2np5S2yt1MIEiSlCd1JhFSSpPJphNV\nbft7lWqnT5EVPCGl9OKS9U9TSq+SVWxvl9+QJa0ki/tIarZqOR55IzeVuabaKNZLkSSpAeRjdYaj\ngFuqN+amGD6fu35JUoGllHYtdAyS1Ij6RcTzwMdk9VQmFzogScuXUiotdAyS6rZKSYSI+CXwRUrp\npmrtm5Gtbf+dVdm/JEnSSpgFrJdSmhsRWwF3RcSmKaVPCh2YJEnN3UonESJiJFl11F2rtfcG7iSr\nllq2nOc7tVqSpFqklJyOv5JysyDn5u4/HxFvAQOA56v39XhEkqTa1XQ8Ut8lHivXuAeIiD2AU4F9\nU0qfVWnvBNwLnJ5SeqoeAZFS4lvf+lbl/Ya+jR49ukWN42tqHuOk1Hif86b+70QJjTJOU3//WuJr\nSsnPeb7GUa2WOh6pYVt2J1uvvU3u/vrAhsDbte20MT+/jfF5cozWN4af3aY3jmPU/9ZUP78resza\nUv496nM8UmcSISJuAqYAAyJiRkSMAq4A1gYejojnI2JsrvvPgA2AcyPi37lt69Q1Rr9+/erqkjfF\nxcUtapzGHMvXtGoa63Puv1PzGKslvibwc94cxmmuajoeiYj9I+I9YAhwb0Q8kOu+C/BSribCbcCP\nU0rz6hqjMT6/jfHv7Bitbww/u01vHMeoPz+/zW+MWF6GoSFFRFoydklJCSUlJQWJQ2osfs4zURqk\n0Z5pban8nOdHRJC8nKFReDyilsDPrpqzpvr59Zi19uOR+l7O0KA8+6LWwM+5WgM/52rO/PyqufKz\nq+bMz2/z0yRmIkhqPczqSnVzJkLj8XhEklQTj1lrPx5ZpSUeG0K/fv149913Cx2GWoi+fftSVlZW\n6DAkSZIkqUVockmEd999d7mVIKUVEeGJPEmSJEnKlyZRE0GSJEmSJDV9JhEkSZIkSVK9mESQJEmS\nJEn1YhKhARx33HGcf/75tW5v06YNb7/99iqPs+eee3L99dev8n4kSZIkSaqPJldYsanr168f5eXl\nzJo1i65du1a2Dx48mBdffJGysjL++Mc/Lncf+Sr2d//999e779ChQzn88MM56qij8jK2JEmSJKn1\ncSbCCooI+vfvz80331zZ9sorr/Df//633skBV5+QJEmSJDVHJhFWwuGHH851111X+fi6667jyCOP\nrHw8atQozj333MrHl1xyCb169aJ3795ce+21SyUbRo0axXHHHcduu+1Gx44dGTp0KDNmzKjcPmXK\nFLbddlu6dOnCdtttx5NPPlm5bejQoYwfP74yhp133plTTz2Vrl27ssEGG/Dggw8CcPbZZ/P444/z\ns5/9jI4dO3L88cfn/02RJEmSJLV4JhFWwpAhQ1iwYAFvvPEGixcv5tZbb+Wwww6rse/EiRO59NJL\neeSRR5g2bRp///vfl+lz0003MXr0aGbPns2gQYP4wQ9+AMDcuXPZe++9OfHEE5k9ezYnnXQSe+21\nF3Pnzq1xrKeffpqBAwcye/ZsTj311MpLF8477zx23nlnrrzySubPn8/ll1+ep3dCkiRJktSamERY\nSUtmIzz88MMMHDiQXr161XiZwu23386oUaMYOHAga665JiUlJcv02Wuvvdhxxx1p164d559/Pk89\n9RQzZ87kvvvuY8CAAYwYMYI2bdpwyCGHsMkmm3DPPffUGFPfvn056qijiAiOPPJIPvjgAz788MN8\nv3RJkiRJUivVLAsr5qkuIatSmuCwww5jl1124Z133uGII47IxbVsYLNmzWLrrbeufNy3b99lkg19\n+vSpvL/WWmvRpUsXZs2axaxZs+jbt+9Sffv27cvMmTNrjKmoqKjy/pprrgnAJ598Qvfu3Vfw1UmS\nJEmStKxmORMhpfzcVsV6661H//79eeCBB/je975Xa7+ePXvy3nvvVT5+9913l0k2VN3+ySefMHfu\nXHr16kWvXr0oKytbqu+MGTNYd911VzjefK0IIUmSJElqvZplEqGpGD9+PP/4xz8qz/rXdDnD8OHD\nmTBhAlOnTmXhwoX86le/WqbP/fffz5QpU/j8888555xzGDJkCOuuuy577rkn06ZN45ZbbmHRokXc\neuutTJ06lX322WeFY+3Rowdvv/32ir9ISZIkSZJyTCKsoKpn9Pv3789WW21V47Yl9thjD0488UR2\n3XVXBgwYwLBhw5bpM2LECEpKSujWrRv//ve/ueGGGwDo2rUr9957L2PGjGGdddZhzJgx3HfffXTp\n0qXW8WqL9YQTTuD222+nW7dunHjiiSv2oiVJkiRJAqKms+eNMnBEqmnsiKjxjH5LNWrUKPr06VPj\nDAWtutb2eWoOojRIo/03kZYn9/8ur0NrBLUdj0iSWjePWWs/HnEmgiRJkiRJqheTCAVmwUOpHiZM\nKHQEkiRJkmimSzy2JOPHjy90CFLTV22VEkmSJEmF4UwESZIkSZJULyYRJEmSJElSvZhEkCRJkiRJ\n9WISQZIkSZIk1YtJBEmSJEmSVC8mEZqwyZMnM3DgwEKHsUKGDh3qihOSJEmS1EKZRFhB/fr1o337\n9nTs2JEOHTrQsWNHjj/++AYZa6eddmLq1KkNsu/aXHfddbRt25aOHTvSuXNnBg8ezH333deoMUiS\nJEmSmqY6kwgRMS4iKiLipSptF0fE1Ih4ISL+EhEdq2w7MyKm5bbv1lCBF0pEcN999zF//nwWLFjA\n/Pnzufzyy1d4P4sWLWqA6PJjhx12YP78+cybN4/jjjuOQw45hPnz5xc6LEmSJElSgdVnJsK1wO7V\n2h4CNkspbQlMA84EiIhNgeHAQOC7wNiIiPyF2zSklGpsf/vttxk2bBjrrLMO3bt357DDDlvqx3f/\n/v25+OKLGTRoEGuvvTaLFi2if//+/Pa3v2XQoEF06dKFQw89lM8//xyAxx57jD59+iz1/Nr6Alx8\n8cX06tWL3r17M27cONq0acPbb78NwP33389mm21Gx44d6dOnD5deemm9Xuvhhx/Op59+yrRp0yrb\nnnrqKXbccUe6dOnC4MGDeeyxx2p9/vjx49l0003p1q0b3/3ud5kxY0blthNPPJH11luPTp06sc02\n2zB58uTKbc888wzbbLMNnTp1omfPnpxyyikrNb4kSZIkKX/qTCKklCYDc6u1/T2ltDj38Cmgd+7+\nvsAtKaUvU0plZAmGbfMXbtOWUuKss86ivLycqVOn8v7771NSUrJUn1tuuYUHHniAefPmsdpqqwFw\n++2389BDD/HOO+/w4osvMmHChMr+1XMwtfWdOHEil112Gf/4xz+YPn06kyZNWuq5Rx99NNdccw3z\n58/nlVdeYdddd63z9SxatIjx48ez+uqr07dvXwBmzZrF3nvvzbnnnsvcuXMZM2YMBx54ILNnz17m\n+XfffTcXXnghd911Fx999BE777wzhx56aOX2bbfdlpdeeom5c+cyYsQIDj744MqkyAknnMCJJ57I\nxx9/zFtvvcXw4cNXeHxJkiRJUn7loybCUcD9ufvrAu9V2TYz19ai7L///nTt2pUuXbrQtWtXxo0b\nB8AGG2zAsGHDaNu2Ld26deOkk05a5iz5CSecQK9evVhjjTWWauvRowedO3dmn3324YUXXqh17Nr6\n3n777YwaNYpNNtmEr33ta5SUlCw1Y2L11Vfn1VdfZcGCBXTq1Iktt9yy1jGefPJJunbtypprrslp\np53GDTfcwDrrrAPADTfcwF577cXuu2eTU4YNG8bWW2/N/fffv8x+rrrqKs4880wGDBhAmzZtOOOM\nM3jhhRd4773sIzJixAg6d+5MmzZtOOmkk/jss8944403KuOdPn06s2fPpn379my77bYrPL4kSWoY\nVU94SJJal1VKIkTEL4EvUko35yme+o1bGnm5ray7776bOXPmMHfuXObMmcMPf/hDAD788EMOPfRQ\nevfuTefOnTnssMP4z3/+s9Rze/fuvcz+evToUXm/ffv2fPLJJ7WOXVvfWbNmLXXpQ9X7AH/5y1+4\n77776Nu3L0OHDuWpp56qdYztt9+eOXPmMG/ePPbdd1/++c9/Vm579913ue222+jatWtlIuWJJ56g\nvLx8mf28++67nHDCCZV9u3XrRkQwc+ZMAMaMGcOmm25Kly5d6NKlC/Pnz698v8aNG8cbb7zBJpts\nwnbbbVdZ3LG28T/44INaX48kSa1JY/zALysra/AxMFEhSU1S25V9YkSMBPYEqs6LnwlU/fXaO9dW\no6pT/YuLiykuLq7X2Gl0zTUJGkttNRHOOuss2rRpw6uvvkqnTp24++67+fnPf75Un4YqEdGzZ0/e\nf//9ysczZsxYaqxvfvOb3HXXXSxatIgrrriC4cOHL1WfoCbt27dn7NixrL/++vzwhz9k0KBB9OnT\nhyOOOIKrrrqqzpj69OnD2WefvdQlDEtMnjyZSy65hEcffZRNN90UgK5du1a+txtssAE33XQTkCVA\nDjroIObMmbNC40tSczFp0iQmTZpU6DDUQjTKD/zG0FJehyS1MPWdiRC5W/YgYg/gVGDflNJnVfr9\nDTgkIlaPiP7AhsDTte20pKSk8lbfBEJTtmDBAtZee206dOjAzJkzueSSSxpt7OHDh3Pttdfy+uuv\ns3DhQs4777zKbV988QU33XQT8+fPZ7XVVqNDhw6V9Rjq0qVLF4455hhKS0sBOOyww7jnnnt46KGH\nWLx4Mf/73/947LHHmDVr1jLPPfbYY7ngggt47bXXAPj444+54447gOy9ateuHd26dePzzz/nV7/6\nFQsWLKh87o033lg5K6FTp05EBG3atFmh8SWpuSguLl7qO1GSJKmpqs8SjzcBU4ABETEjIkYBVwBr\nAw9HxPMRMRYgpfQacBvwGlmdhJ+k2k7bN2P77LMPHTt2rLwdeOCBAIwePZrnnnuusl7BkvYlapqF\nsCIzE5bXd4899uD4449n6NChDBgwgO233x6gsvbC9ddfT//+/encuTNXX3115Vn++jjhhBN44IEH\neOWVV+jduzd33303F1xwAV//+tfp27cvY8aMYfHixcvEuP/++3PGGWdwyCGH0LlzZ7bYYgsmTpwI\nwO67787uu+/OgAED6N+/P+3bt1/qEoyJEydWriZx0kknceutt7LGGmvUOb4kSWoYRUVFRAQRQWlp\nKRFBUVFRQwwEEVBamv2NyNokSU1CFOo3fkTUmF+IiFovF1D9vf7663zjG9/gs88+o02bfNTPbJ78\nPDU9URorfklSSUl2k1qJ3P+7WtwSyU1RbccjzU1RUREVFRVLtfXo0aPGmkUrq7aTGXl//2o7adIC\n/p0kNR8rdczawtR2PNJ6f122QHfddReff/45c+fO5fTTT2ffffdt1QkESZJai+oJhNraVl0/4AfA\nTg2wb0lSc+AvzBbkqquuonv37my00Ua0a9eOsWPHFjokSZLUTC1aBC+8AFdeCYccAvA+2RWuBwDj\ngSeAffCKQklqXVZ6dQY1PQ888EChQ5AkSc3UwoXw9NMweXJ2e/JJ6NULdtoJvvtduPXWXYC3c73b\nAAcCJWyxBZx+epZoaNeucPFLkhqHMxEkSZJaof/8B+6+G049FbbfHr7+dTjjDJg3D449FqZPh6lT\n4Zpr4Mgj4asEAsBi4Hbgm/z2tzB+PGy0UTZrYeHCgrwcSVIjsbCiWjQ/T03PChWpKSqC6tf09ugB\neSwUJjVFFlZsPC2lsGJdRQ9TgnfeyWYYPP549nfWrCx5sNNO2W3bbaF9+9rHqKt441NPwUUXwZQp\n8POfw09/Cl26rNSLqbm9Bfw7SWo+LKxoYUVJzVFNRcEapFCYJLU0qwGDufxyGD4c1l03SxTcdx9s\nsQXcfDPMmQMTJ8LZZ0Nx8fITCADl5eWklEgpMXr0aFJKS63+MGQI/PWv8Oij2SyGDTbIZjnMmtWg\nL1SS1MhMIkiSJLUYRwATgdnA9bz6KuyzDzzxBMycCbfems0S2HJLWG21holg001hwoSsKOMXX8Dm\nm8Mxx8C0aQ0zniSpcTW5wop9+/atdUqetKL69u1b6BAkSWoE7YArgB2BXwIjgDlcdVXhpuKutx5c\ndlk20+GKK2CHHWDo0KzuwlZbFSwsSdIqanJJhLKyskKHIEmS1Gx8+CHA34G5wPbAJw0+Zr9+/erd\nd511oLQ0u7Thmmtg331hs82yZEJxce0lECRJTZOXM0iSJDVTL7yQFUSEx4ADaIwEAsDIkSNX+Dlr\nrw0nnQRvvQXf/362AsSQIXDXXbB4cf5jlCQ1DJMIkiRJzdBtt8F3vgOXXAJwLtA8qoivsQYcdRS8\n9hqcfjqcf342M2HCBPj880JHJ0mqi0kESZKkZmTx4qzOwKmnwkMPwcEHFzqilbPaavC978HTT8OV\nV8KNN8KGG8LvOZ5PqWOpCElSwZhEkCRJaiYWLMh+eD/2GDzzDAweXOiIVl0EDBsGDz8Md94Jj7Mz\n/XmHX3M2H9Ox0OFJkqoxiSBJktQMvPUWbL899OgBjzwC3bsXOqL823pruIODeZydmc6GbMh0SjmX\neXQqdGiSpByTCJIkSU3cI49kSyT+5Cfwf/8Hq69e6Iga1sa8yXWMZAo78A792ZDplJTAvHmFjkyS\nZBJBkqSmYMKEQkegJigluPxy+MEP4NZbsyRCTUsi9ujRo15tzc1GTGcCo3iKIcyYkdVMGD0a5s4t\ndGSS1HqZRJAkqSkoKyt0BGpiPvsMjj4a/vQnePJJKC6uvW95eTkppaVu5eXljRZrQ9uQtxg/Hv71\nL3j/fdhoIzjnHJgzp9CRSVLrYxJBkiSpiSkvh113zc64T5kC/fsXOqKmYYMNYNy4bEWHDz7Ikgln\nnw2zZxc6MklqPUwiSJIkAROayCUlzz0H224Lu+0Gd9wBa69d6IianvXXz2ZoPPssfPghDBgAv/yl\nyQRJagwmESRJkoCyRrikpK5Exc03wx57wO9+l13738YjteXq3x+uvjpLvPznP1ky4cwzs/uSpIbh\nV5MkKW+ayplcqSkpKioiIogIRo0aRURQVFS0VJ9Fi7Ifv2edla3EcOCBBQq2merXD666Cp5/PrsE\nZOON4Ywz4KOPCh2ZJLU8JhEkSXnTGGdy1TpFxLiIqIiIl6q0HRQRr0TEoojYqlr/MyNiWkRMjYjd\nGj/ir1RUVCy37eOPYb/9suKJzzwDW2zRmNG1LH37Zktg/vvfMH9+lkw4/XSTCZKUTyYRJElSc3At\nsHu1tpeBA4DHqjZGxEBgODAQ+C4wNqKmhRELb9o0GDIk+/H78MOwzjqFjqhlWG89GDsWXnwRPvkk\nSyacempWP0GStGpMIkiSVknVqdqlpaU1TtWWVlVKaTIwt1rbGymlaUD1BMF+wC0ppS9TSmXANGDb\nRgl0BTz0EOy0E5x0EvzhD9CuXaEjann69Mne25degv/+FzbZBE45BWqYHCJJqieTCJKkVVLXVG2p\nANYF3qvyeGaurQk5iSOPzFZf+NGPCh1Ly9e7N1x5ZZZM+OwzGDgQTj45W0pTkrRiTCJIkiQ1mjXI\nrsw4nKeegp13LnQ8rUvv3nDFFfDKK1kxy003zWaCfPBBoSOTpOajbaEDkCRJyrOZQJ8qj3vn2mpU\nUlICwKQWRYSFAAAgAElEQVRJk5g0aRLFxcUNFFZP4E5gBrATfft+2kDjqC69esHvf58VXbz4Yths\nMzjiiOxxz56Fjk6SCmPJ92BdnIkgSZKai2DZ+gdVty3xN+CQiFg9IvoDGwJP17bTkpISSkpKKC4u\nbqAEwjrAr4GXgHuB7wMLG2AcraheveCyy+DVVyEiSyYcfzzMrDXlJEktV3FxceV34pIEe01MIkiS\ntBwTJkwodAgCIuImYAowICJmRMSoiNg/It4DhgD3RsQDACml14DbgNeA+4GfpJRSY8f8/vvZVHl4\ngyyRsC1wfmOH0fz06FG/tjzq2RN+9zt47bWswOU3vgE//7nJBEmqSZ1JhBVZlzki2kbEhIh4KSJe\njYgzGipwSZIaQ1lZWaFDEJBSGpFS6pVSWiOltF5K6dqU0l0ppT4ppTVTSj1TSt+t0v83KaUNU0oD\nU0oPNWas06fDMcfAFlvAaqsBbA4cB7zTmGE0X+XlkBKMHp39TanRKiAWFcFvfwtTp8Iaa2TJhJ/9\nLEsISZIy9ZmJUO91mYGDgdVTSlsAWwM/joj1VjlKSZKqcnaAmqCXX4YRI2D77bNp8tOmwZgxAFbt\nWyn9+hVs6B49sn+7qVNhzTWzhNBPfgLvvVf3cyWppaszibCC6zInYK2IWA1oD3wGzM9TrJIkZZwd\noCbkX/+CffeF3XaDLbeEt96C0lLo1q3QkTVzI0cWOgJ69IBLLoHXX4cOHWDQIDjuOJgxo9CRSVLh\n5Lsmwh1klYI+AMqAMSmleXkeQ5KkBlVUVEREEBGUlpYSERQVFRU6LDUhKcEjj8CwYfD978Mee8Db\nb8Npp0HHjoWOTvnWvTtcdBG88QZ06gSDB8Oxx8K77xY6MklqfPle4nFb4EugCOgGPB4Rf08pldXU\nuWrFx4ariCxJ0oqpqKioV1teFBUxqaKCSZCdvlaTtngx3HsvXHABzJsHZ56ZXcLQrl2hI1Nj+PrX\n4cIL4ZRTstoJW20FBx2UfQ4KePWFJDWqfCcRRgATU0qLgY8i4gmy2ghlNXVe3rIRkiS1ChUVFAPF\nVZpMJTQ9X34Jt9+eJQ/atYOzzoIDDlhSOFGtzTrrwG9+kyUTLr0UvvlN+N73ss9F//6Fjk6SGlZ9\nL2eo77rMM4BdASJiLbIll15f6egkSZIK6LPP4JprYJNNYOzY7Pr4557Lzj7XN4HQo4blCWtqU/PT\nrRucfz68+WZWP2HrreHoo7NLWySpparPEo/1XpcZ+APQISJeAf4FjEspvdJQwUtSvk2w6r8k4NNP\n4bLLYIMN4M474dpr4fHHs9oHUdtplVqUl5eTUiKlxOjRo0kpUd5ISxaqcXTrBuedl63I0bMnbLMN\n/PCHJhMktUz1WZ2h3usyp5Q+TSkNTyltnrtd2vAvQZLyp8yq/yvMs6yryPeqSZk3LzuzvP76MHky\n3H03PPAA7LxzoSNTc9C1K/z61zB9OvTuDdtuC6NGZY8lqaXI9+oMkqRWxrOsq6i8PCv1P3p09jel\nQkfUKlVUwN//PowNNsimpk+aBHfckV3rLq2oLl2yOqnTpkHfvjBkSLZipckESS2BSQRJktSqZUt4\nPsYTT7zMnDn9ePDBIgYOLHRUagm6dIGSkix50L9/lkw48sgsuSBJzZVJBEmSJHYFfgq8W+hA1AJ1\n7pxNNnrrLdhwQ9hhBzj8cHjjjTwNYD0fSY3IJIKkVq+oqIiIICIoLS2tvF9UVFTo0CQ1guxynEVe\njqMG16kTnHNONjNh441hp53gsMPg9ZVdy6yoKKv0OWpU9jcia5OkBmQSQVKrV1FRsULtKpAlB8sR\n2cXGHjArz/r161foENRKdOoEZ5+dzUwYOBB22QV+8AOYOnUFd1TT95TfXZIamEkESVLzUNuBsQfM\nypORI0cWOgS1Mh07wi9/mSUTNt8cvvUtOPRQeO21QkcmSbUziSBJah5qWwrRJRLVjDjbQTXp0AHO\nPDNLJgwaBEOHwiGHwKuvFjoySVqWSQRJUvOwZCnE6sshev26mhFnO2h5OnSAM87IkgmDB8Ouu8Lw\n4fDKK4WOTJK+YhJBkiRJakLWXhtOPz1LJmyzDXz723DwwfDyy4WOTJJMIkiS1DQ4zV1SNWuvDaee\nmiUTttsOvvMdOOggeOmlQkcmqTUziSBJUlPgNHdJtVhrLTjllCyZsP32sPvu8L3vwQsMKnRokloh\nkwiSJElSM7DWWvCLX2TJhJ13hj25nwO4k+cZXOjQJLUiJhEkSZKkZqR9ezjpJJjOhnyLx9iPu9mZ\nf3Irw/mcdoUOT1ILZxJBkiRJaoba819O5Pe8Q39O5DL+j2PpRxklJTBrVqGjk9RSmUSQJDU/FiGU\npEptWcSB3Mmj7MpD7EZFBWy2GRxyCEyenK2G2xxMmDCh0CFIqgeTCJKk5scihJJUo815lT/+EcrK\nYIcd4KijYPBg+NOfYOHCVdhxI/zALysra/AxJK06kwiSJElSC9OpExx/PLz+Olx8Mfztb7Deel+t\n8lBvRUUQAaNGZX8jsjZJrZZJBEmtXo8ePVaoXZKk5qJNG9httyyJ8Mwz2eMhQ2DvvWHiRFi8uI4d\nVFTUr01Sq2ESQVKrV15eTkqJlBKjR4+uvF9eXl7o0CRJypv+/bNZCe++C9/7Hpx5Jmy8MVx2Gcyb\nV+joJDUXJhEkNV01zQRwdoAkSaukffusVsLzz2elDv71ryzBcOyx8PLLhY5OUlNnEkFS01VenpWU\nHj06+5tS1iZJklZZBOy4I9x8M7z2GvTqBbvvDsXFcMcd8MUXhY5QUlNkEkGSpGpqqodhjQxJLVnP\nnnDuudmlDj/5CVx+eTY74decTTn+/0/SV0wiSJLypl+/foUOIS+q1sm49tprrZEhqWlqgMv+2rWD\n4cPhn/+E++6D9+jDQKbyfW7hzxzOB7gyg9TamUSQJOXNyJEjCx1C3rXE1ySphWjgy/4GDYKr+TFv\nsz7DeIS/sS+b8Srf4CV+8Qt48EFYuDBvw0lqJkwiSJIkSapVF+bxI67hDg7mQ7rzJ46mc2c477xs\n4sO3v52t+vDCC/VYMlJSs2cSQZIkSVK9tGUR2/E055wDjz8OM2fC8cfDjBnZZRBFRfCDH8B118Gs\nWYWOVlJDMIkgSZIkaaV07Aj77gtXXglvvglPP52t7nDvvfCNb8Dmm8PJJ8PEibVf+lBUVEREUFpa\nSkQQERQVWXtBaqpMIkiSJEnKi3794Jhj4Pbb4cMPYfx46NoVLrggu/Rh2DC46CL497+/uvShoqJi\nmf3U1CapaagziRAR4yKiIiJeqtJ2UES8EhGLImKrav23iIgpue0vRsTqDRG4pFakhVT8lySpNVlt\nNdh2Wzj77Gy1h1mz4MQT4f334dBDs0sfRowAOBLoVeBoJdVXfWYiXAvsXq3tZeAA4LGqjRGxGnA9\n8KOU0uZAMfDFqocpqVWzOr4kSbVryGR7HpeR7NAB9tkHrrgCXn8dnnkGdt0V4LvAS8CrwP8BhwH9\nSWllg65BURFELH3zkglppdSZREgpTQbmVmt7I6U0DYhq3XcDXkwpvZLrNzelvP7nL0mSJKmqhky2\nN+Aykn37wtFHAxwCdAcOJ0sk7ANMZt114eCD4fe/h2efhS+/XIXBaro8wksmpJXSNs/7GwAQEROB\ndYBbU0qX5HkMSZIkSS3KYuD53O0KAJ54IvHEEzB5MvzpT/Duu7DNNrDTTrDjjjBkSFbYUVLjyncS\noS2wI7A18D/gkYh4NqX0aJ7HkSRJktSC9e+f3Q47LHs8dy48+WSWVDj/fHjuOdhooyyhsCSx0KdP\nYWOWWoN8JxHeB/6ZUpoLEBH3A1sBNSYRSkpKKu8XFxdTXFyc53AkSWr6Jk2axKRJkwodhiQVRI8e\nPZZZjaFHDXUXunSBPffMbgCffw7PP58lFW69FX7+c2jffumkwuabZwUeJeVPfZMIwbL1D6puW+JB\n4NSI+BrwJfAt4NLadlo1iSBJUmtVPZFeWlpauGAkqZGV52oslJSUrNDvg9VXzy5pGDIETjklK9cw\nbVqWVHjiiayWQkVFtn0nfsmOPMG2PM1aLGygVyK1DvVZ4vEmYAowICJmRMSoiNg/It4DhgD3RsQD\nACmleWRJg2fJLmh6NqX0QMOFL0mSJEnZggsDBsBRR8G4cfDGG1lS4bjj4GM68UvOpycfcDa/5lPa\nN2gsEyZMaND9S4VU50yElNKIWjbdVUv/m4CbViUoSSqUfg25TJYkSWpUX/867Lcf7MdpALxHb07l\nEgYylTGcwsEpSz7kW1lZWf53KjURdc5EkKTWZGRDLpMlSZIKqg/vcwuH8meO4DzOZtgweOWVQkcl\nNS8mESRJkiQtXwubqVfMYzzPVhxwAAwdCieeCPPmFToqqXkwiSBJkiRp+VrgTL22LOLnP4fXXoNP\nP4WBA2H8eFi8uNCRSU2bSQRJkiRJrdbXvw7XXAP33ANXXw3bbw9PP13oqKSmyySCJEmSpIIrdHHj\nrbeGKVOy1Rz22w9++EP48MOChiQ1SSYRJEmSJBVcgxY37tGjXm1t2mRXbrz+OnTqBJttBr//PXzx\nRcOFJjU3JhEkSZIktWzl5ZBSdhs9OvtbXl5r906d4NJL4bHHssscBg+GRx9txHilJswkgiRJkiTV\nYNNN4eGHobQURo2C4cNhxoxCRyUVlkkESZIkSapFBBx4YLaKw8CB2ayE886D//2v0JFJhWESQZIk\nSZLq0L59NiPh2Wfhueeyegl/+1t2ZQRAUVEREUFEUFpaSkRQVFRU2KCbgQkTJhQ6BK0gkwiSJEmS\nVE/9+8Nf/wp//COcdhrsuSe8+SZUVFQs07emNi2trKys0CFoBZlEkCRJktR65Gkpyd12g5degmHD\nYIcdAC4E1s7LvqWmzCSCJEmSpNYjj0tJrr46nHIKvPwyQE9gKnA4MAAoAtaqvNxBainaFjoASZKk\nukTEOGBvoCKltEWurQtwK9AXKAOGp5Q+joi+ZEfyr+ee/lRK6SeNH7Wk1qJnT4Ajge2BXwG/BDoC\nHWnbFjp0gI4da74tb1v1fm399aYmwI+hJElqDq4FrgD+XKXtDODvKaWLI+J04MxcG8D0lNJWjRyj\npFbvSeA7S7V89lliwQKYPz+7Vb1f9TZzJkyduvw+a6xRd6KhPgmJr30tW3WitZgwYQIj8zgDpbUz\niSBJkpq8lNLk3AyDqvYDvpW7fx0wia+SCK3o8FhSU9a2LXTpkt1WRUqwcGHdyYiPP4b33lt+ny++\nqP/sh+VtX3ttWG21/LxPDcnijfllEkGSJDVX3VNKFQAppfKI6F5lW7+IeB74GDgnpTS5IBFKUp5E\nwFprZbfs8omV9/nnXyUYaks0zJ8P7767/KTFJ5/AmmuuWkJi8WLL9DU3JhEkSVJLsaR82QfAeiml\nuRGxFXBXRGyaUvqkgLFJUpOx+urQrVt2WxWLF8Onn9Y9O+I//4G33/6qz4MPPskXX3wN6Aocyq9/\nfRTduz9MRcV7+Xh5amAmESRJUnNVERE9UkoVEVEEfAiQUvoc+Dx3//mIeIusVPrzNe2kpKSk8n5x\ncTHFxcUNHLaklqhHjx5UVFQs09aStWmTzTDo0AHWXbf+zysqOqDKe7UzcA7/+c+vGDsWjjoqq9mg\nxjdp0iQmTZpUZz+TCJIkqbkIlq518DdgJHARWVn0uwEiYh1gTkppcUSsD2wIvF3bTqsmESRpZZWX\nl1feLykp8f8ty7Hse/UdnnoKzj8/u51yCvzoR9mlG2o81RPppaWlNfbzAhRJktTkRcRNwBRgQETM\niIhRwIXAdyLiDWBY7jHALsBLuZoItwE/TinNK0TckqT6GTIE7rkH7r0XnngCNtgALrwwuwRCTYsz\nESRJUpOXUhpRy6Zv19D3TuDOho1IktQQBg+GO+6AV1+FCy7Ikgk/+xkcf/yqr3Ch/HAmgiRJkiSp\nSdlsM7jxRpgyJVslYsMN4cwz4aOPCh2ZTCJIkiRJUh7169ev0CG0GBttBOPHw3PPwccfw8Ybw8kn\nw6xZhY6s9TKJIEmSJEl5NHLkyEKH0GzUN+HSrx+MHQsvvwwpweabw09/ms1SUOMyiSBJkiRJKogV\nTbisuy787nfw+uvZ0pJbbQU//CFMn94w8WlZJhEkSZIkSc1K9+7Z6g3TpkGfPtnqDocdBq+9VujI\nWj6TCJIkSZKkZqlrVygpgbfeyooxDh0KBx8M3boNIyKICEpLS4kIioqKCh1ui1BnEiEixkVERUS8\nVKXtoIh4JSIWRcRWNTxnvYhYEBEn5ztgSZIkSZKq6tQpW73h7bdh++1hzpzrgbuBbSr7VFRUFCy+\nlqQ+MxGuBXav1vYycADwWC3P+S1w/yrEJUmSJEnSCllrrWz1BlgfeBC4A/hxQWNqadrW1SGlNDki\n+lZrewMgIqJ6/4jYD3gb+DRfQUqSJEmSVH+fAWOBa4A1ChxLy5LXmggRsRZwGlAKLJNgkCRJkiSp\n8XwBfFLoIFqUfBdWLAF+l1JamHtsIqERTJgwodAhSJIkSZJagTovZ1hB2wEHRsTFQBdgUUT8N6U0\ntqbOJSUllfeLi4spLi7OczitQ1lZWaFDkCStgkmTJjFp0qRChyFJUovRo0ePZQop9ujRo0DRtCz1\nTSIEtc8qqGxPKe1S2RgxGlhQWwIBlk4iSJLUWlVPpJeWlhYuGEmSWoDy8vJCh9Bi1WeJx5uAKcCA\niJgREaMiYv+IeA8YAtwbEQ80dKCSJEmSJKmw6rM6w4haNt1Vx/M8jSJJkiRJUguS78KKkiRJkiSp\nhTKJIEmSJEmS6sUkgiRJkiRJqheTCJIkSZIkqV5MIkiSJEmSpHoxiSBJkiRJkurFJEIzVVRUREQQ\nEZSWlhIRFBUVFTosSZIkSVILZhKhmaqoqKhXmyRJkiRJ+WISQZIkSZIk1YtJhIYyYUKhI5AkSZIk\nKa9MIjSUsrJCRyBJkiRJUl6ZRJAkSZIkSfViEkGSJEmSJNWLSQRJkiRJklQvJhGaoZQAtgauBj4C\ndihoPJIkSZKk1sEkQjMyfz783//BVlsB3Aq8DZwBTADaFzAySZIkSVJrYBKhiUsJnn4ajj4a+vaF\nRx6Biy8G2BC4EBgH/Av4TSHDlCRJkiS1Am0LHYBq9vHHcNNNcPXV2QyEY46BqVOhqGhJj1Sl98+B\nl4G/NnqckiRJkqTWwyRCE7Jk1sHVV8Odd8K3v53NOhg2DNosd87IPOAYYDwLFkCHDo0TryRJkiSp\ndfFyhibg449h7FgYPBhGjIABA+D11+H22+E736krgbDEROARfvGLBg5WkiRJktRqmUQokJTgX/+C\no47Kah1MmgRjxsC0aXD66dCjx8rs9WQeeggmTsxzsJIkSZIk4eUMjW7ePLjxxuyShU8/zWodvPHG\nyiYNqlvAuHEwciS8/DJ07pyPfUqSJEmSlHEmQiNICZ56Kpt10L8//POfcOml8OabqzLroGbDhsG+\n+8IJJ+Rvn5IkSZIkgTMRGtS8eXDDDdmsg4UL4Uc/ymYddO++6vvu0aMHFRUVy7QBXHQRbLkl/O1v\nWUJBkiRJkqR8cCZCA3jxRRh193706wePPw6XXZbNOjjttPwkEADKy8tJKZFSYvTo0aSUKC8vB2Dt\nteHaa+HYY2H27PyMJ0mSJElSq0siTJgwocH2/epP/sBBcQd7bPkBm7xwC29+3J1bbwt2/WdJPVdY\nyJ+dd4ZDD4Wf/rRxx5UkSZIktVytLolQVlaW932++Wa2NOOuf/kp2118ENM/6cnpo9eke/owK4hQ\nUpL3MevjvPOyWRG33VaQ4SVJkiRJLUyrSyLk09tvZysh7LgjbLYZTJ8Op54Ka63VuHH069evxvY1\n14QJE+D446Fa+QRJkiRJklZYnUmEiBgXERUR8VKVtoMi4pWIWBQRW1Vp/3ZEPBsRL0bEMxExtKEC\nXxFFRUVEBBFBaWkpEUFRUdFK72/GjKxI4jbbQN++MG0a/PKX0KFDHoNeASNHjqx123bbZatC/PjH\n2aQISZIkSZJWVn1mIlwL7F6t7WXgAOCxau0fAXunlAYBI4HrVzXAfKi+ikFtbXWZNQt+9jMYPBjW\nWSdLHpSWQufO+Yiy4Ywenc2auOGGQkciSZIkSWrO6kwipJQmA3Ortb2RUpoGRLX2F1NK5bn7rwJf\ni4h2eYy3ID78EE4+GTbfHL72NZg6FS64ALp2LXRk9bPGGnDddfCLX8DMmYWORpIkSZLUXDVYTYSI\nOAh4PqX0RUON0dBmz4YzzoCBA+HLL+HVV2HMmPwt09iYBg/OVmo4+mgva5AkSZIkrZwGSSJExGbA\nb4AfNcT+G9q8eXDuubDxxtn9F16Ayy+Hnj0LHdmqOeusbFbFuHGFjkSSJEmS1By1zfcOI6I3cCdw\neEqpbHl9S6osfVhcXExxcXG+w1khCxbA73+f3fbZB555Bvr3L2hIedWuXXZZw9Ch8J3vZEUhJUmF\nN2nSJCZNmlToMCRJkupU3yRCUK3+QbVt2Z2ITsC9wOkppafq2mnVJEIhffop/OEP8NvfZj+up0yB\njTYqdFQNY/PN4ZRTshUbHn4Y2rjIpyQVXPVEemlpaeGCkSRJWo76LPF4EzAFGBARMyJiVETsHxHv\nAUOAeyPigVz3nwEbAOdGxL8j4vmIWKfBol9F//0v/O53sOGG8Oyz8Oij2QoGLTWBsMQpp8DChTB2\nbKEjkSRJkiQ1J3XOREgpjahl01019D0fOH9Vg2p4qwNHs9FGsPXWMHEiDBpU6Jgaz2qrwYQJsOOO\nsMceWRJFkiRJkqS6tLLJ7G2Bo4E3gT25+264667WlUBYYuON4eyzYeRIWLSo0NFIkiRJkpqDVpRE\n6A28AgwHDgH25pvfLGxEhXb88dmshMsuq+cTJkxoyHAkSZIkSU1cK0kidAYeAP4E7AbUWfOxVWjT\nBq69Fi68EKZOrccTysoaOiRJkiRJUhPW4pMI//sfZOUbHgbGFDaYJmj99eFXv4Ijj4Qvvyx0NJIk\nSZKkpqxFJxEWL4bDDwcoB37RuIP369e4462CY4+Fzp3h4osLHYkkSZIkqSlrsUmElOCkk+CjjwCO\nBFLjBjByZOOOtwoiYNy4rDbCSy8VOhpJkiRJUlPVYpMIY8bAP/6Rrb4AnxU6nCavTx+46CI44gj4\n/PNCRyNJ0tIiYlxEVETES1XaukTEQxHxRkQ8GBGdqmw7MyKmRcTUiNitMFFLktTytMgkwo03wpVX\nwgMPZNP0VT8jR2bJhPPOK3QkkiQt41pg92ptZwB/TyltDPwDOBMgIjYlW45pIPBdYGxERCPGKklS\ni9Xikgh//zucfDLcfz/07l3oaJqXCLj6arjqKnj22UJHI0nSV1JKk4G51Zr3A67L3b8O2D93f1/g\nlpTSlymlMmAasG1jxClJUkvXopIIL7wAI0bAHXfAZpsVOprmqWdP+N3vstUaspUtJElqsrqnlCoA\nUkrlQPdc+7rAe1X6zcy1SZKkVdRikghlZbDXXjB2LOy8c6Gjad4OPRQ22QRGjy50JJIkrZBGrqIs\nSVLr07bQAeTD7Nmwxx5wxhlw0EGFjqb5i4A//hEGDYL9r9mL7efe/9XG0tLsb48eUF5emAAlScpU\nRESPlFJFRBQBH+baZwJ9qvTrnWurUUlJSeX94uJiiouL8x+pJElN3KRJk5g0aVKd/SKlwiTtIyLl\nY+yFC+Hb34ZddoELL6x1rBrbC/Xam4s774QzDnyTF9iS9vx32Q6+f1oJURqk0X52pOWJCFJKFgKs\nJiL6AfeklL6Re3wRMCeldFFE/H979x5nZVUvfvzzHRATFRhAZkRwQJNEj5IoqMfUQSrvlyw5iqig\nnUpPCXa01DwCHjVTtE6WHStuqaSSJSqX1HTIO94VRX6aAgZBBiiYHlRYvz/2nnEGZpg9sGf2XD7v\n1+t5sfd61rPXdw/PzKz57nX5PlCcUro4u7DibcCBZKYxPADsUVvHI1/9EUlS62Kfte7+SIuezvDJ\nJ5mh97vvDldfXXe9kpKSnMpU08knwyCe5lI288WVJKkJRMQ04HGgX0QsiYhRwDXAlyJiITA0+5yU\n0qvAncCrwCzgPDMFkiTlR4sdiZASnHsu/OUvMHMmdOiQ23Xjxo2rMWxRm7cqurIPL3Mbp1PO3Jon\n7Y9pC5jVlernSISm40gESVJt7LO2wpEIV10FTz0Fd92VewJBDdeV1fySbzCKyaxlh0KHI0mSJEkq\noBa5sOLkyTBpEjz+OHTqVOhoWr9jmcVdPMyXeIBjmclg5jGIp+la6MAkSZIkSU2qxSURZs+GSy6B\nuXOhtLTQ0bQdN3EesziGeQzmWr7HMxzATp+FwYM/PfbbD7bbrtCRSpIkSZIaS7NIIkyZMoWRI0fW\nW+/pp+Gss2DGDPjc5xo/Ln3qM6zjZP7AyfwBgA0EC+/dwLx5MG8e3HYbvPoq9OtXM7Gw117Qrl2B\ng5ckSZIk5UWzSCIsWrSo3jpvvAEnnAC//jUcfHDjx6TNKyLRvz/0759J7ACsWwcvvphJKsydC9dd\nB0uXZkYoVE8slJVBHbtuSpIkSZKasWaRRKjP3/8ORx0F48ZlEglqnrbd9tNEQaV334Vnn80kFn77\nW7jgAvj4Yxg06NO6gwZB9+6Fi1uSJEmSlJtmn0R4/3049lgYPhy++c1CR6OG6tIFhg7NHJWWLs1M\nTZk3D66/Hp55Brp1+zShMHgwDBwIHTsWLu7GkOu0HUmSJElqrpp1EuHjj2HYMNh3Xxg/vtDRKF92\n2SVznHRS5vmGDfD//l8mqfD003DHHTB/PuyxR83Ewt57Q/tmfcduXi7TdiRJkiSpOWu2f5KllBl5\nEAH/+7/OoS+YkhJYsaL28jwpKoI998wcZ56ZKVu3Dl56KZNYeOwx+PGPYcmSmusrDBoEfft6b0iS\nJElSU2m2SYTLL898Gv3ww7DNNoWOpg1bvvzTx+PGZY4msO22mSTBoEGflr333qfrK9x5J1x4IXz4\nYTayfeAAACAASURBVM1FGwcNgp12apIQm5/S0k0TPiUlNf8PJUmSJGkrFDSJENU+Qh6fna9QUlLC\nuHHLuf32zCfQ229fqOjU3HTuDEcckTkqLVv26foKP/5xZn2FLl1qJhYGDmwj91FtI0ZqK5MkSZKk\nLdTsRiKsWHEgV1wBjzwCPXoUOho1dz17woknZg7IrK/wxhuZpMK8eTB9Orz8Muy+e83Ewt57O8JF\nkiRJkhqqmSURDgZ+zT33ZP7okxqqqAj69cscI0Zkyj76KJNImDcPnngC/ud/YPFiGDCgZmJht91c\nX0GSJEmSNqeovgoRMTEiVkTES9XKvhYR8yNifUQM3Kj+JRHxekQsiIgv5x7K54DfA2dywAG5XyXV\np0MH2H9/OPdcmDwZXnklMw3iqqtg553hrrtgyBDo3h2OOiqzHsd99zkTQJIkSVJupkyZUugQmkwu\nIxEmAzcCv6lW9jLwFeDm6hUjoj8wDOgP9AIejIg9Ukpp802UArOBi4E5OYYubblOnaC8PHNUWr78\n0/UVbrwx87hTp0+3mBw8OJOM2GGHQkUtSZIkqTlqS9u515tESCk9GhFlG5UtBIjYZPD3icDtKaVP\ngEUR8TowGHiq7hZ2JJNA+DUwtSGxS3lVWgrHH585ILPNaOX6Ck8/DZdcAi++mJn2ULkTxODBsM8+\nrq8gSZIkqW3I95oIuwBPVHu+NFu2Gd/OXnJ1nkORtk4E7LFH5jj99EzZxx9/ur7C00/Dz38Ob70F\n++5bM7Hw2c9mri8tLWVFtXkR48ePp6SkhOVuuyhJkiSpBWoGCyv+qNABSDnbZpvMlpEDB8K3vpUp\nW7sWnnsuk1iYMQN+8ANYsyaTUFix4j+Ap4F5QCaZsMLFFiRJkiS1UPlOIiwFeld73itbthkb8hyC\n1LR23BEOPzxzVFqxIjNS4f77E3AemaVFVgEVwMMsW5bZnlKSACoqKqioqCh0GJIkSfXKNYkQ2aOu\nc5XuAW6LiB+TmcbwWTIfwUptSkkJHHccwNhsSQB7A+XA19hnn8xuEOXlmZ0hysszazJIapvKy8sp\nr7bS6/jx4wsXjCRJ0mbUm0SIiGlk/vLpFhFLyPxVtJrMjg3dgfsi4oWU0tEppVcj4k7gVeBj4Lz6\nd2aQ2oIEzM8eP+OddxIvvwwPPwy33w7nnZdJPFQmFMrLoUePggYsSZIkSZvIZXeG4XWcuruO+j8E\nfrg1QUmtRUlJySZrIJSUlFBUBAMGZI4xY2D9enjppUxS4ZZb4BvfgF12ySQVhgzJTJXo3r1Ab0KS\nJEmSsooKHYDUmi1fvpyUEiklxo4dS0qp1p0Z2rWD/faD734X7r0XVq6EqVOhTx+YNAl23z2zA8T5\n58Mf/gCrVjX9e5EkSZKkZrA7Q00lJSWFDkEquHbt4IADMseFF8Inn2R2gHj4Ybj5ZjjrLNhtt0+n\nPxx2GBQXOmhJkiRJrV5BRyJs/AltXZ/SSm1d+/YweDB8//swZ05mpMIvfpFZN+HnP4ddd4WBPMt/\nMoE/c2ihw5UkSZKUb1OmFDoCwOkMUou0zTZw8MFwySVw//2ZpMKNfIdiVjOCW/lvLsMVTSVJkqTG\nVVpaSkQwfvx4IoKIoLSxtl1btKhxXreBTCJIrUCHDnAIj3MZV/EUB3IPJ3Amv2EdHQodmiRJktRq\nbbyIel1lrYlJBKmV2ZnlzOVwPqAjQ/kT77xT6IgkSZIktRYmEaRWqCMfMp1TOJRHOOggWLCg0BFJ\nkiRJ2iKlpRAB48dn/o3IlBWISQSplSoi8UMu5bLL4PDD4cEHCx2RJEmSpAarbXpEAadMmESQWrlR\no2D6dDj99Mz2kJIkSZK0pUwiSG3A4YfDo4/C9dfDd78L69cXOiJJkiRJLZFJBKmN2GMPePJJeP55\n+MpX4P33Cx2RJEmSpJamWSQR+vTpU+gQpDaha1f44x9hp53gC1+At98udESSJEmSWpJmkUQYOXJk\nk7VlwkJtXYcO8Otfw/DhcPDB8MwzhY5IkiRJUkvRLJIITakpExZSdc0pgRUB3/se3HgjHH00/P73\nhY5IkiRJUkvQvtABSG1Fc0xgfeUrsOuucOKJ8PrrmcRCRKGjkiRJktRctbmRCNoKzeiTdOXP/vtn\nFly8/Xb4+tfho48KHZEkSZKk5sokgnLXDD9JV3706gWPPALvvANHHgmrVuV23ZQpUxo1LkmSJEnN\ni0kESQDssAP84Q8wcCAcdFBmekNtSktLiQgiglGjRlU9Li0tbdqAJUmSJDU5kwiSqrRrB9dfDxde\nmNkCsqJi0zorVqyo9dq6yiVJkiS1HiYRpNaipCS3shx84xtw220wbBhMnryVcUmSJElqNUwiSK3F\n8uWQEowdm/k3pUzZFvriF2HuXLjySrj4YtiwIY+xSpIkSWqRTCJIqlP//vDUU/DYY3DKKfDBB4WO\nSJIkSVIhmUSQtFndu8ODD0LHjnDYYQA7FzokSZIkSQViEkFSvbbdFn7zGzjpJIAngQEFjkiSJElS\nIZhEkJSTCLjsMoALgQeA4wobkCRJkqQmZxJBUgNNJ5NAuBk4tsCxSJIkSWpK7QsdgKSWaB5wEPCP\nQgciSZIkqQk5EkHSFnob+LDQQUiSJEkFU1JSklNZa2ISQZIkSZKkLbB8+XJSSowdO5aUEiklli9f\nXuiwGlW9SYSImBgRKyLipWplxRFxf0QsjIg/RkTnbHn7iJgSES9FxCsRcXFjBi9JkiRJkppOLiMR\nJgNHblR2MfBgSulzwEPAJdnyU4AOKaV9gQOAb0bErvkKVpIkSZIkFU69SYSU0qPA6o2KTwSmZh9P\nBU6qrA5sHxHtgI7AOmBNfkKVlJM+fQodgSRJkqRWakvXROiRUloBkFJaDlSuHPE74APgb8AiYEJK\n6d2tDVJSA4wcWegIJEmSpDalTxv6IC9fWzxuyP57IPAJUAp0Ax6JiAdTSotqu2jcuHFVj8vLyykv\nL89TOJIktRwVFRVUVFQUOgxJkrSFRrahD/IipVR/pYgy4N7sWgdExAKgPKW0IiJKgYdTSv0j4mfA\nEyml27L1JgKzU0q/q+U1Uy5tS2peIqLOczn9PBkfpLF+70ubExGklOr+ZlPe2B+RJNWmWfVZ6+p/\nN/Lvr7r6I7lOZ4jsUekeYGT28UhgRvbxEuCIbIPbAwcBrzU8XEnNVV373rb2/XAlSZIk5bbF4zTg\ncaBfRCyJiFHANcCXImIhmaTBNdnqPwd2jIj5wFPAxJTS/MYJXVIhVO6F29b2w5XUfEXE6Ih4OXuc\nny0bGxF/jYjnssdRhY5TkqTWoN41EVJKw+s49cVa6v4TGLa1QUmSJOUiIvYGziGztfQnwOyImJk9\nfUNK6YaCBSdJUiuUr4UVJUmSCqE/8FRKaR1ARPwZODl7znUlJEnKsy3d4lGSJKk5mA8cGhHFEdER\nOAboBSTg2xHxQkT8OiI6FzRKSZJaCZMIkiSpxUopvQb8CHgAmAU8D6wHfgHsllL6PLAccFqDJEl5\n4HQGSZLUoqWUJgOTASLiKuDtlNI71ar8Cri3ruvHjRtX9bi8vJzy8vJGiVOSpOasoqKCioqKeuuZ\nRJAkSS1aROyUUnonInYFvgIcFBGlKaXKbWNOJjPtoVbVkwiSJLVVGyfSx48fX2s9kwiSJKmluysi\nugIfA+ellNZExM8i4vPABmAR8M1CBihJ0hYrKYEVKzYtKxCTCJIkqUVLKR1WS9mZhYhFkqS8W54d\nWDduXOYoMBdWlCRJkiRJMGVKvVVMIkiSJEmSJFi0qN4qJhEkSZIkSVJOTCJIkiRJkqScmESQJEmS\nJEk5MYkgSZIkSZJyYhJBkiRJkqTmrk+fQkcAmESQJEmSJKn5Gzmy0BEAJhEkSZIkSVKOTCJIkiRJ\nktSWlZZCBIwfn/k3os6qJhEkSZIkSWrLVqzIuapJBEmSJEmSlBOTCJIkSZIkKScmESRJkiRJastK\nSnKuahJBkiRJkqS2bPlySAnGjs38m1KdVds3YViSJEktQp8+fVi8eHGhw1ArUVZWxqJFiwodhiTl\nhUkESZKkjSxevJi0mU9hpIaIzWyVJkktjdMZJEmSJElSTkwiSJIkSZKknJhEkCRJkiRJOTGJIGmL\n9enTp9AhSJLqcO6553LVVVfVeb6oqIg333xzq9s55phjuOWWW7b6dSRJLUO9SYSImBgRKyLipWpl\nxRFxf0QsjIg/RkTnauf2jYjHI2J+RLwYER0aK3hJhTVy5MhChyBJbVKfPn34zGc+w6pVq2qU77ff\nfhQVFbFkyRJ+8Ytf8IMf/KDO18jXYn+zZs3ijDPOyKnukCFDmDRpUl7alSQVRi4jESYDR25UdjHw\nYErpc8BDwCUAEdEOuAX4RkrpX4By4OO8RStJkiQigr59+/Lb3/62qmz+/Pl8+OGHOScH3H1CkrQl\n6k0ipJQeBVZvVHwiMDX7eCpwUvbxl4EXU0rzs9euTv6GkiRJyrszzjiDqVOnVj2fOnUqZ511VtXz\nUaNGcfnll1c9v+666+jZsye9evVi8uTJNZINo0aN4txzz+XLX/4ynTp1YsiQISxZsqTq/OOPP87g\nwYMpLi7mwAMP5Iknnqg6V310wdSpUzn00EO56KKL6Nq1K7vvvjt//OMfAbjssst45JFH+Pa3v02n\nTp04//zz8/9FkSQ1ui1dE6FHSmkFQEppOdAjW94PICLmRMQzEXFRHmKUJEnSRg466CDWrl3LwoUL\n2bBhA3fccQcjRoyote6cOXO44YYb+NOf/sTrr7/Ogw8+uEmdadOmMXbsWFauXMmAAQM4/fTTAVi9\nejXHHXccY8aMYeXKlVxwwQUce+yxrF698WdMGfPmzaN///6sXLmSiy66iLPPPhuAK6+8kkMPPZSf\n/exnrFmzhp/+9Kd5+kpIkppSvhZWrBxt0B44BDgNOBT4SkQMyVMbkiRJqqZyNMIDDzxA//796dmz\nZ63TFKZPn86oUaPo378/2223HePGjdukzrHHHsshhxzCNttsw1VXXcWTTz7J0qVLmTlzJv369WP4\n8OEUFRVx6qmnsueee3LvvffWGlNZWRlnn302EcFZZ53F3/72N/7+97/n+61Lkgqk/RZetyIiSlJK\nKyKiFKj8zfBX4M8ppdUAETELGAg8XNuLVP8FVl5eTnl5+RaGI0lSy1VRUUFFRUWhw1AD5WNdwq2d\n9DlixAgOO+ww3nrrLc4888xsXJsGtmzZMg444ICq52VlZZskG3r37l31ePvtt6e4uJhly5axbNky\nysrKatQtKytj6dKltcZUWlpa9Xi77bYD4P3336dHjx611pcktSy5JhEie1S6BxgJ/Ag4C5iRLf8j\ncFFEfAb4BDgcuKGuF60tCy5JUluzcSJ9/PjxhQtGOWsOqz7tuuuu9O3bl9mzZ29214Odd96Zt99+\nu+r54sWLN0k2VD///vvvs3r1anr27EnPnj256667atRdsmQJRx99dIPjzdeOEJKkwslli8dpwONA\nv4hYEhGjgGuAL0XEQmBo9jkppXfJJA2eAZ4DnkkpzW6s4CVJktq6SZMm8dBDD1V96l/bdIZhw4Yx\nZcoUFixYwAcffMAVV1yxSZ1Zs2bx+OOP89FHH/Ff//VfHHTQQeyyyy4cc8wxvP7669x+++2sX7+e\nO+64gwULFnD88cc3ONaSkhLefPPNhr9JSVKzkcvuDMNTSj1TStumlHZNKU3O7rrwxZTS51JKX84m\nDyrrT0sp/UtKad+U0iWNG74kSVLbU/0T/b59+zJw4MBaz1U66qijGDNmDEcccQT9+vVj6NChm9QZ\nPnw448aNo1u3bjz//PPceuutAHTt2pX77ruPCRMm0L17dyZMmMDMmTMpLi6us726Yh09ejTTp0+n\nW7dujBkzpmFvWpLU+Pr0qbdKFGoHxohw90epDYrxQRrr9760ORFBSslx302grv5I9v+gABEVxqhR\no+jdu3etIxS09dra/SS1BvZZ6+6P5Gt3BkmSJEmS1MqZRJAkSWrjXPBQkpSrLd3iUZIkSa3E5nZ2\nkCSpOkciSJIkSZKknJhEkCRJkiRJOTGJIEmSJEmScmISQZIkSZIk5cQkgiRJkiRJyolJBEmSJNXp\n0UcfpX///oUOo0GGDBnijhOS1EhMIkiSJLUwffr0oWPHjnTq1Ikdd9yRTp06cf755zdKW1/4whdY\nsGBBo7x2XaZOnUr79u3p1KkTXbp0Yb/99mPmzJlNGoMkqXbtCx2AJEmSGiYimDlzJkOGDNmq11m/\nfj3t2rXLU1T59a//+q/8+c9/BuCXv/wlp556KkuXLqVTp04FjkyS2jZHIkiSJLVAKaVay998802G\nDh1K9+7d6dGjByNGjGDNmjVV5/v27cu1117LgAED2GGHHVi/fj19+/bl+uuvZ8CAARQXF3Paaafx\n0UcfATB37lx69+5d4/q66gJce+219OzZk169ejFx4kSKiop48803AZg1axZ77703nTp1onfv3txw\nww05vdczzjiDf/7zn7z++utVZU8++SSHHHIIxcXF7LfffsydO7fO6ydNmsRee+1Ft27dOProo1my\nZEnVuTFjxrDrrrvSuXNnBg0axKOPPlp17umnn2bQoEF07tyZnXfemQsvvHCL2pek1sQkgiRJUiuS\nUuLSSy9l+fLlLFiwgL/+9a+MGzeuRp3bb7+d2bNn8+6771aNRJg+fTr3338/b731Fi+++CJTpkyp\nqh8RNa6vq+6cOXP4yU9+wkMPPcQbb7xBRUVFjWu//vWv86tf/Yo1a9Ywf/58jjjiiHrfz/r165k0\naRIdOnSgrKwMgGXLlnHcccdx+eWXs3r1aiZMmMBXv/pVVq5cucn1M2bM4JprruHuu+/mnXfe4dBD\nD+W0006rOj948GBeeuklVq9ezfDhwznllFOqkiKjR49mzJgxvPfee/zlL39h2LBhDW5fklobkwiS\nJEkt0EknnUTXrl0pLi6ma9euTJw4EYDdd9+doUOH0r59e7p168YFF1ywyafko0ePpmfPnmy77bY1\nykpKSujSpQvHH388L7zwQp1t11V3+vTpjBo1ij333JPPfOYzjBs3rsaIiQ4dOvDKK6+wdu1aOnfu\nzOc///k623jiiSfo2rUr2223Hd/73ve49dZb6d69OwC33norxx57LEceeSQAQ4cO5YADDmDWrFmb\nvM7NN9/MJZdcQr9+/SgqKuLiiy/mhRde4O233wZg+PDhdOnShaKiIi644ALWrVvHwoULq+J94403\nWLlyJR07dmTw4MENbl+SWhuTCJIkSVsgxsdWH1tjxowZrFq1itWrV7Nq1SrOOeccAP7+979z2mmn\n0atXL7p06cKIESP4xz/+UePaXr16bfJ6JSUlVY87duzI+++/X2fbddVdtmxZjakP1R8D3HXXXcyc\nOZOysjKGDBnCk08+WWcbBx98MKtWreLdd9/lhBNOqFofAWDx4sXceeeddO3atSqR8thjj7F8+fJN\nXmfx4sWMHj26qm63bt2ICJYuXQrAhAkT2GuvvSguLqa4uJg1a9ZUfb0mTpzIwoUL2XPPPTnwwAOr\nFnesq/2//e1vdb4fSWotXFhRkiRpC6Sxta9J0GTt17EmwqWXXkpRURGvvPIKnTt3ZsaMGXznO9+p\nUWfj6Qn5svPOO/PXv/616vmSJUtqtLX//vtz9913s379em688UaGDRtWY32C2nTs2JGbbrqJ3Xbb\njXPOOYcBAwbQu3dvzjzzTG6++eZ6Y+rduzeXXXZZjSkMlR599FGuu+46Hn74Yfbaay8AunbtWvW1\n3X333Zk2bRqQSYB87WtfY9WqVQ1qX5JaG0ciSJIktSJr165lhx12YMcdd2Tp0qVcd911Tdb2sGHD\nmDx5Mq+99hoffPABV155ZdW5jz/+mGnTprFmzRratWvHjjvumPPOEMXFxfz7v/8748ePB2DEiBHc\ne++93H///WzYsIH/+7//Y+7cuSxbtmyTa7/1rW9x9dVX8+qrrwLw3nvv8bvf/Q7IfK222WYbunXr\nxkcffcQVV1zB2rVrq6697bbbqkYldO7cmYigqKioQe1LUmtjEkGSJKkFOv744+nUqVPV8dWvfhWA\nsWPH8uyzz1atV1BZXqm2UQgNGZmwubpHHXUU559/PkOGDKFfv34cfPDBAFVrL9xyyy307duXLl26\n8Mtf/rLqU/5cjB49mtmzZzN//nx69erFjBkzuPrqq9lpp50oKytjwoQJbNiwYZMYTzrpJC6++GJO\nPfVUunTpwr777sucOXMAOPLIIznyyCPp168fffv2pWPHjjWmYMyZM6dqN4kLLriAO+64g2233bbe\n9iWpNYu6hsI1esMRqVBtSyqcGB8FHwIsNXcRQUqpccabq4a6+iPZ/4MCRNS6vPbaa+yzzz6sW7eO\noqK2+9mV95PU8thnrbs/0nZ/mkuSJCnv7r77bj766CNWr17N97//fU444YQ2nUCQpNbGn+iSJEnK\nm5tvvpkePXqwxx57sM0223DTTTcVOiRJUh65O4MkSZLyZvbs2YUOQZLUiByJIEmSJEmScmISQZIk\nSZIk5cQkgiRJkiRJyolJBEmSJEmSlBMXVpQkSdpIWVkZEZtsjS1tkbKyskKHIEl5U28SISImAscB\nK1JK+2bLioE7gDJgETAspfRetWt2BV4BxqaUbmiEuCVJkgCIiNHA17NPf5VS+ml9fZX6LFq0KN9h\nSpLUKuQynWEycORGZRcDD6aUPgc8BFyy0fnrgVm5BlFRUZFrVanF8j5XW+B9rqYWEXsD5wAHAJ8H\njouI3am/r7IJ71+1VN67asm8f1ueepMIKaVHgdUbFZ8ITM0+ngqcVHkiIk4E3iQzEiEn3jhqC7zP\n1RZ4n6sA+gNPpZTWpZTWA38GTgZOoI6+Sl28f9VSee+qJfP+bXm2dGHFHimlFQAppeVACUBE7AB8\nDxgP5DyRsCmHDDbVTdqU3wy+p+bfDjTdfe7/U8toqzW+J/A+bwnttELzgUMjojgiOgLHAL2Bko36\nKj3qe6GmuH+b4v/ZNtpeG967za8d28id92/LayNfuzNsyP47FvhxSumD7POcEgkmEVpGW76nreMf\nV82/naZsqzW+J/A+bwnttDYppdeAHwEPkJlK+Tywvraq9b2WHVnbaKlteO82v3ZsI3fevy2vjUip\n3t+pREQZcG+1hRUXAOUppRURUQo8nFLqHxF/BnplLysm80v88pTSTbW8Zv0NS5LURqWU3BpgC0TE\nVcDbwGhq6avUUt/+iCRJdaitP5LrFo9BzVEF9wAjyWT+zwJmZBs4rOqCiLHA2toSCHUFI0mS1FAR\nsVNK6Z3s7lBfAQ4C+lJLX2Vj9kckSWqYXLZ4nAaUA90iYgmZKQvXANMj4mxgMTCsMYOUJEnajLsi\noivwMXBeSmlNRPwIuNO+iiRJ+ZXTdAZJkiRJkqR8LaxIRJwUERsiol8eXutrETE/ItZHxMBq5e0j\nYkpEvBQRr0TExVvbltQQeb7Pr42IBRHxQkTcFRGdsuVlEfFBRDyXPWqdEiTlU/a+/k215+0i4p2I\nuCdPr39JRLyevee/nC3bLiLuy5a9HBFX56MttW1N1B/pGhEPRcTaiPjp1rYjVbI/rZbKPnLbkrck\nAnAq8AhwWkMvjIiN43iZzJzGuRuVnwJ0yC7weADwzez8R6mp5PM+vx/YO6X0eeB14JJq595IKQ3M\nHudtcbRS7v4J/EtEbJt9/iUyi9NttYjoT2YoeX/gaOCmiKich35ddrG7/YAvRMSR+WhTbVpT9Ef+\nD7gM+M8tCVDaDPvTaqnsI7cheUkiRMT2wCHAOVS7cSLi8IiYm/2k6bXq2aJs9n5CRDxPZgGkKiml\nhSml19l0i8gEbB8R7YCOwDpgTT7eg1SfRrjPH0wpVW6P+iSf7mwCOW6PKuXZLODY7OPTgN9WnoiI\nQRHxeEQ8GxGPRsQe2fK5EbFvtXqPRMQ+G73uicDtKaVPUkqLyHQIBqeUPkwpzQVIKX0CPEfN7wOp\nQZqqP5JS+iCl9DiZfoiUF/an1VLZR2578jUS4URgTkrpDeAfEbFftXODgP8g8wnUZyPi5Gz59sAT\nKaX9sr+Ic/E74APgb8AiYEJK6d18vAEpB415n58NzK72vE92mNbDEfGFPL4HqS4JuB04LTsaYV/g\nqWrnFwBfSCntT2aB3R9my38NjALIJha2TSm9vNFr70LNUQ1Ls2VVIqILcDzwp7y8G7VVTdUfkRqD\n/Wm1VPaR25h8JRFOI9P5BLgDGF7t3LyU0uKUWcHxt0Dlf/Z64PcNbGcw8AlQCuwGXBgRfbYwZqmh\nGuU+j4gfAB+nlKZli5YBu6aUBpIZKjstInbI03uQ6pRSmg/0IXOvz6Rmtr8L8LuIeBn4MbBXtvx3\nwLHZT7TOBqY0tN3stdOAn2RHKkhbqqn6I1JjsD+tlso+chtT7xaP9YmIYuAIMnNpE9COzCdaF2Wr\nbLz9Q+XzD1PDt4YYTibLtQF4JyIeIzOXa9GWxC7lqrHu84gYCRyTfe3MhSl9DKzOPn4uIv4C9CMz\n1FtqbPcA15HZ2rd7tfL/Bh5KKZ0cEWXAwwAppQ8j4gHgJDLzbPev5TWXAr2rPe+VLav0S2BhSunG\nfL0JtT1N3B+R8sr+tFoq+8htUz5GIpwC/Cal1DeltFtKqQx4q9rwksHZlTSLgH8js+AG5D6fpXq9\nJWRvpOzcm4OA17b6HUj1y/t9HhFHkfkBe0JKaV218u6VC8xExG7AZ4E38/+WpBoq79VJwPiU0isb\nne/Mp3/4j9ro3ETgp2Q+bXivlte+Bzg1IjpERF8y9/Q8gIi4EuiUUrogD+9BbVtT9kdyKZcawv60\nWir7yG1QPpII/wb8YaOyu/h0UY1ngJ8BrwB/SSndnS3fXObppIh4m8wPtfsionIezM+BHSNiPpm5\nuhOzw2+lxpb3+xy4EdgBeCBqblNzGPBSRDwH3Al807mKagIJIKW0NKX0s1rOXwtcExHPstHvpMnR\nhwAAANFJREFUjpTSc2QW5Zpc6wun9CqZe/lVMos3npdSShGxC3ApsFdEPJ/9Pjg7b+9IbU1T9keI\niLeA64GzImJJROyZn7ehNsr+tFoq+8htUDTmCL6IOBz4z5TSCY3WiFRg3udq6yKiJ5mpDv4RpWbJ\nn9Nqybx/1VJ577Ze+VpYUZLUBkXEGcATZEYUSJIkqZVr1JEIkiRJkiSp9XAkgiRJkiRJyolJBEmS\nJEmSlBOTCJIkSZIkKScmESRJkiRJUk5MIkiSJEmSpJyYRJAkSZIkSTn5/wNfq10SmMMcAAAAAElF\nTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, axarr = plt.subplots(1, 2)\n",
+ "f.set_size_inches(18, 6)\n",
+ "\n",
+ "FB_plot = axarr[0]\n",
+ "ohlc_dataframe(FB[datetime(2016, 4, 18):], FB_plot)\n",
+ "\n",
+ "FB_truncated = FB[datetime(2016, 4, 18):datetime(2016, 4, 27)]\n",
+ "midpoint = FB_truncated['Open']/2 + FB_truncated['Close']/2\n",
+ "FB_plot.plot(FB_truncated.index, midpoint, label='Midpoint')\n",
+ "FB_plot.vlines(date2num(datetime(2016, 4, 27, 12)),\n",
+ " ax_fb.get_ylim()[0], ax_fb.get_ylim()[1],\n",
+ " color='g', label='Earnings Release')\n",
+ "FB_plot.legend(loc=2)\n",
+ "FB_plot.set_title('FB Midpoint Plot')\n",
+ "\n",
+ "AAPL_plot = axarr[1]\n",
+ "ohlc_dataframe(AAPL[datetime(2016, 4, 10):], AAPL_plot)\n",
+ "AAPL_truncated = AAPL[datetime(2016, 4, 10):datetime(2016, 4, 26)]\n",
+ "midpoint = AAPL_truncated['Open']/2 + AAPL_truncated['Close']/2\n",
+ "AAPL_plot.plot(AAPL_truncated.index, midpoint, label='Midpoint')\n",
+ "AAPL_plot.vlines(date2num(datetime(2016, 4, 26, 12)),\n",
+ " ax_aapl.get_ylim()[0], ax_aapl.get_ylim()[1],\n",
+ " color='g', label='Earnings Release')\n",
+ "AAPL_plot.legend(loc=3)\n",
+ "AAPL_plot.set_title('AAPL Midpoint Plot');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Given these charts, we can see that FB was trending down for the four days preceding the earnings release, and AAPL was trending down for a whopping 8 days (we don't count the peak day). This will define the methodology that we will use for the study.\n",
+ "\n",
+ "So what are the results? For a given horizon, how well does the market actually perform?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100% (47578 of 47578) |###########################################################| Elapsed Time: 0:21:38 Time: 0:21:38\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBoAAAGNCAYAAAC/hxIDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nADBuCBoAAAAAAMC4+f+DLBbJVWQG2gAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Read in the events for each stock;\n",
+ "# The file was created using the first code block in the Appendix\n",
+ "import yaml\n",
+ "from dateutil.parser import parse\n",
+ "from progressbar import ProgressBar\n",
+ "\n",
+ "data_str = open('earnings_dates.yaml', 'r').read()\n",
+ "# Need to remove invalid lines\n",
+ "filtered = filter(lambda x: '{' not in x, data_str.split('\\n'))\n",
+ "earnings_data = yaml.load('\\n'.join(filtered))\n",
+ "\n",
+ "# Convert our earnings data into a list of (ticker, date) pairs\n",
+ "# to make it easy to work with.\n",
+ "# This is horribly inefficient, but should get us what we need\n",
+ "ticker_dates = []\n",
+ "for ticker, date_list in earnings_data.items():\n",
+ " for iso_str in date_list:\n",
+ " ticker_dates.append((ticker, parse(iso_str)))\n",
+ "\n",
+ "def does_trend_down(ticker, event, horizon):\n",
+ " # Figure out if the `event` has a downtrend for\n",
+ " # the `horizon` days preceding it\n",
+ " # As an interpretation note: it is assumed that\n",
+ " # the closing price of day `event` is the reference\n",
+ " # point, and we want `horizon` days before that.\n",
+ " # The price_data.hdf was created in the second appendix code block\n",
+ " try:\n",
+ " ticker_data = pd.read_hdf('price_data.hdf', ticker)\n",
+ " data = ticker_data[event-TradeDay(horizon):event]\n",
+ " midpoints = data['Open']/2 + data['Close']/2\n",
+ "\n",
+ " # Shift dates one forward into the future and subtract\n",
+ " # Effectively: do we trend down over all days?\n",
+ " elems = midpoints - midpoints.shift(1)\n",
+ " return len(elems)-1 == len(elems.dropna()[elems <= 0])\n",
+ " except KeyError:\n",
+ " # If the stock doesn't exist, it doesn't qualify as trending down\n",
+ " # Mostly this is here to make sure the entire analysis doesn't \n",
+ " # blow up if there were issues in data retrieval\n",
+ " return False\n",
+ "\n",
+ "def study_trend(horizon, trend_function):\n",
+ " five_day_events = np.zeros((1, horizon*2 + 1))\n",
+ " invalid_events = []\n",
+ " for ticker, event in ProgressBar()(ticker_dates):\n",
+ " if trend_function(ticker, event, horizon):\n",
+ " ticker_data = pd.read_hdf('price_data.hdf', ticker)\n",
+ " event_data = ticker_data[event-TradeDay(horizon):event+TradeDay(horizon)]['Close']\n",
+ "\n",
+ " try:\n",
+ " five_day_events = np.vstack([five_day_events, event_data])\n",
+ " except ValueError:\n",
+ " # Sometimes we don't get exactly the right number of values due to calendar\n",
+ " # issues. I've fixed most everything I can, and the few issues that are left\n",
+ " # I assume don't systemically bias the results (i.e. data could be missing\n",
+ " # because it doesn't exist, etc.). After running through, ~1% of events get\n",
+ " # discarded this way\n",
+ " invalid_events.append((ticker, event))\n",
+ " \n",
+ "\n",
+ " # Remove our initial zero row\n",
+ " five_day_events = five_day_events[1:,:]\n",
+ " plot_study(five_day_events)\n",
+ " plt.gcf().suptitle('Action over {} days: {} events'\n",
+ " .format(horizon,five_day_events.shape[0]))\n",
+ " plt.gcf().set_size_inches(18, 6)\n",
+ " \n",
+ "# Start with a 5 day study\n",
+ "study_trend(5, does_trend_down)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "When a stock has been trending down for 5 days, once the earnings are announced it really doesn't move on average. However, the variability is *incredible*. This implies two important things:\n",
+ "\n",
+ "1. The market is just as often wrong about an earnings announcement before it happens as it is correct\n",
+ "2. The incredible width of the min/max bars and standard deviation area tell us that the market reacts *violently* after the earnings are released.\n",
+ "\n",
+ "Let's repeat the same study, but over a time horizon of 8 days and 3 days. Presumably if a stock has been going down for 8 days at a time before the earnings, the market should be more accurate."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100% (47578 of 47578) |###########################################################| Elapsed Time: 0:20:29 Time: 0:20:29\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBcAAAGNCAYAAABKeZmzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAKMr/B9pAH9lY/+K6AAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# 8 day study next\n",
+ "study_trend(8, does_trend_down)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "However, looking only at stocks that trended down for 8 days prior to a release, the same pattern emerges: on average, the stock doesn't move, but the market reaction is often incredibly violent."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100% (47578 of 47578) |###########################################################| Elapsed Time: 0:26:26 Time: 0:26:26\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBAAAAGNCAYAAACopYLKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSTfmKmb+uQ4AAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# 3 day study after that\n",
+ "study_trend(3, does_trend_down)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Finally, when we look at a 3-day horizon, we start getting some incredible outliers. Stocks have a potential to move over ~300% up, and the standard deviation width is again, incredible. The results for a 3-day horizon follow the same pattern we've seen in the 5- and 8-day horizons."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Event Type 2: Trending up for N days\n",
+ "\n",
+ "We're now going to repeat the analysis, but do it for uptrends instead. That is, instead of looking at stocks that have been trending down over the past number of days, we focus only on stocks that have been trending up."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100% (47578 of 47578) |###########################################################| Elapsed Time: 0:22:51 Time: 0:22:51\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBAAAAGNCAYAAACopYLKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def does_trend_up(ticker, event, horizon):\n",
+ " # Figure out if the `event` has an uptrend for\n",
+ " # the `horizon` days preceding it\n",
+ " # As an interpretation note: it is assumed that\n",
+ " # the closing price of day `event` is the reference\n",
+ " # point, and we want `horizon` days before that.\n",
+ " # The price_data.hdf was created in the second appendix code block\n",
+ " try:\n",
+ " ticker_data = pd.read_hdf('price_data.hdf', ticker)\n",
+ " data = ticker_data[event-TradeDay(horizon):event]\n",
+ " midpoints = data['Open']/2 + data['Close']/2\n",
+ "\n",
+ " # Shift dates one forward into the future and subtract\n",
+ " # Effectively: do we trend down over all days?\n",
+ " elems = midpoints - midpoints.shift(1)\n",
+ " return len(elems)-1 == len(elems.dropna()[elems >= 0])\n",
+ " except KeyError:\n",
+ " # If the stock doesn't exist, it doesn't qualify as trending down\n",
+ " # Mostly this is here to make sure the entire analysis doesn't \n",
+ " # blow up if there were issues in data retrieval\n",
+ " return False\n",
+ "\n",
+ "study_trend(5, does_trend_up)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The patterns here are very similar. With the exception of noting that stocks can go to nearly 400% after an earnings announcement (most likely this included a takeover announcement, etc.), we still see large min/max bars and wide standard deviation of returns.\n",
+ "\n",
+ "We'll repeat the pattern for stocks going up for both 8 and 3 days straight, but at this point, the results should be very predictable:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100% (47578 of 47578) |###########################################################| Elapsed Time: 0:20:51 Time: 0:20:51\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBcAAAGNCAYAAABKeZmzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSIQHpzdOAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "study_trend(8, does_trend_up)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100% (47578 of 47578) |###########################################################| Elapsed Time: 0:26:56 Time: 0:26:56\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAABBAAAAGNCAYAAACopYLKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "study_trend(3, does_trend_up)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Conclusion and Summary\n",
+ "\n",
+ "I guess the most important thing to summarize with is this: **looking at the entire market, stock performance prior to an earnings release has no bearing on the stock's performance.** Honestly: given the huge variability of returns after an earnings release, even when the stock has been trending for a long time, you're best off divesting before an earnings release and letting the market sort itself out.\n",
+ "\n",
+ "*However*, there is a big caveat. These results are taken when we look at the entire market. So while we can say that the market as a whole knows nothing and just reacts violently, I want to take a closer look into this data. Does the market typically perform poorly on large-cap/high liquidity stocks? Do smaller companies have investors that know them better and can thus predict performance better? Are specific market sectors better at prediction? Presumably technology stocks are more volatile than the industrials.\n",
+ "\n",
+ "So there are some more interesting questions I still want to ask with this data. Knowing that the hard work of data processing is largely already done, it should be fairly simple to continue this analysis and get much more refined with it. Until next time."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Appendix\n",
+ "\n",
+ "Export event data for Russell 3000 companies:\n",
+ "\n",
+ "```python\n",
+ "import pandas as pd\n",
+ "from html.parser import HTMLParser\n",
+ "from datetime import datetime, timedelta\n",
+ "import requests\n",
+ "import re\n",
+ "from dateutil import parser\n",
+ "import progressbar\n",
+ "from concurrent import futures\n",
+ "import yaml\n",
+ "\n",
+ "class EarningsParser(HTMLParser):\n",
+ " store_dates = False\n",
+ " earnings_offset = None\n",
+ " dates = []\n",
+ " \n",
+ " def __init__(self, *args, **kwargs):\n",
+ " super().__init__(*args, **kwargs)\n",
+ " self.dates = []\n",
+ " \n",
+ " def handle_starttag(self, tag, attrs):\n",
+ " if tag == 'table':\n",
+ " self.store_dates = True\n",
+ " \n",
+ " def handle_data(self, data):\n",
+ " if self.store_dates:\n",
+ " match = re.match(r'\\d+/\\d+/\\d+', data)\n",
+ " if match:\n",
+ " self.dates.append(match.group(0))\n",
+ " \n",
+ " # If a company reports before the bell, record the earnings date\n",
+ " # being at midnight the day before. Ex: WMT reports 5/19/2016,\n",
+ " # but we want the reference point to be the closing price on 5/18/2016\n",
+ " if 'After Close' in data:\n",
+ " self.earnings_offset = timedelta(days=0)\n",
+ " elif 'Before Open' in data:\n",
+ " self.earnings_offset = timedelta(days=-1)\n",
+ " \n",
+ " def handle_endtag(self, tag):\n",
+ " if tag == 'table':\n",
+ " self.store_dates = False\n",
+ " \n",
+ "def earnings_releases(ticker):\n",
+ " #print(\"Looking up ticker {}\".format(ticker))\n",
+ " user_agent = 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) '\\\n",
+ " 'Gecko/20100101 Firefox/46.0'\n",
+ " headers = {'user-agent': user_agent}\n",
+ " base_url = 'http://www.streetinsider.com/ec_earnings.php?q={}'\\\n",
+ " .format(ticker)\n",
+ " e = EarningsParser()\n",
+ " s = requests.Session()\n",
+ " a = requests.adapters.HTTPAdapter(max_retries=0)\n",
+ " s.mount('http://', a)\n",
+ " e.feed(str(s.get(base_url, headers=headers).content))\n",
+ " \n",
+ " if e.earnings_offset is not None:\n",
+ " dates = map(lambda x: parser.parse(x) + e.earnings_offset, e.dates)\n",
+ " past = filter(lambda x: x < datetime.now(), dates)\n",
+ " return list(map(lambda d: d.isoformat(), past))\n",
+ "\n",
+ "# Use a Russell-3000 ETF tracker (ticker IWV) to get a list of holdings\n",
+ "r3000 = pd.read_csv('https://www.ishares.com/us/products/239714/'\n",
+ " 'ishares-russell-3000-etf/1449138789749.ajax?'\n",
+ " 'fileType=csv&fileName=IWV_holdings&dataType=fund',\n",
+ " header=10)\n",
+ "r3000_equities = r3000[(r3000['Exchange'] == 'NASDAQ') |\n",
+ " (r3000['Exchange'] == 'New York Stock Exchange Inc.')]\n",
+ "\n",
+ "dates_file = open('earnings_dates.yaml', 'w')\n",
+ "\n",
+ "with futures.ThreadPoolExecutor(max_workers=8) as pool:\n",
+ " fs = {pool.submit(earnings_releases, r3000_equities.ix[t]['Ticker']): t\n",
+ " for t in r3000_equities.index}\n",
+ " pbar = progressbar.ProgressBar(term_width=80,\n",
+ " max_value=r3000_equities.index.max())\n",
+ " \n",
+ " for future in futures.as_completed(fs):\n",
+ " i = fs[future]\n",
+ " pbar.update(i)\n",
+ " dates_file.write(yaml.dump({r3000_equities.ix[i]['Ticker']:\n",
+ " future.result()}))\n",
+ "```\n",
+ "\n",
+ "Downloading stock price data needed for the event studies:\n",
+ "\n",
+ "```python\n",
+ "from secrets import QUANDL_KEY\n",
+ "import pandas as pd\n",
+ "import yaml\n",
+ "from dateutil.parser import parse\n",
+ "from datetime import timedelta\n",
+ "import quandl\n",
+ "from progressbar import ProgressBar\n",
+ "\n",
+ "def fetch_ticker(ticker, start, end):\n",
+ " # Quandl is currently giving me issues with returning\n",
+ " # the entire dataset and not slicing server-side.\n",
+ " # So instead, we'll do it client-side!\n",
+ " q_format = '%Y-%m-%d'\n",
+ " ticker_data = quandl.get('YAHOO/' + ticker,\n",
+ " start_date=start.strftime(q_format),\n",
+ " end_date=end.strftime(q_format),\n",
+ " authtoken=QUANDL_KEY)\n",
+ " return ticker_data\n",
+ " \n",
+ "data_str = open('earnings_dates.yaml', 'r').read()\n",
+ "# Need to remove invalid lines\n",
+ "filtered = filter(lambda x: '{' not in x, data_str.split('\\n'))\n",
+ "earnings_data = yaml.load('\\n'.join(filtered))\n",
+ "\n",
+ "# Get the first 1500 keys - split up into two statements\n",
+ "# because of Quandl rate limits\n",
+ "tickers = list(earnings_data.keys())\n",
+ "\n",
+ "price_dict = {}\n",
+ "invalid_tickers = []\n",
+ "for ticker in ProgressBar()(tickers[0:1500]):\n",
+ " try:\n",
+ " # Replace '.' with '-' in name for some tickers\n",
+ " fixed = ticker.replace('.', '-')\n",
+ " event_strs = earnings_data[ticker]\n",
+ " events = [parse(event) for event in event_strs]\n",
+ " td = timedelta(days=20)\n",
+ " price_dict[ticker] = fetch_ticker(fixed,\n",
+ " min(events)-td, max(events)+td)\n",
+ " except quandl.NotFoundError:\n",
+ " invalid_tickers.append(ticker)\n",
+ " \n",
+ "# Execute this after 10 minutes have passed\n",
+ "for ticker in ProgressBar()(tickers[1500:]):\n",
+ " try:\n",
+ " # Replace '.' with '-' in name for some tickers\n",
+ " fixed = ticker.replace('.', '-')\n",
+ " event_strs = earnings_data[ticker]\n",
+ " events = [parse(event) for event in event_strs]\n",
+ " td = timedelta(days=20)\n",
+ " price_dict[ticker] = fetch_ticker(fixed,\n",
+ " min(events)-td, max(events)+td)\n",
+ " except quandl.NotFoundError:\n",
+ " invalid_tickers.append(ticker)\n",
+ " \n",
+ "prices_store = pd.HDFStore('price_data.hdf')\n",
+ "for ticker, prices in price_dict.items():\n",
+ " prices_store[ticker] = prices\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.4.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook.md b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook.md
new file mode 100644
index 0000000..74ae63a
--- /dev/null
+++ b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook.md
@@ -0,0 +1,724 @@
+Or, being suspicious of market insiders.
+
+---
+
+Use the button below to show the code I've used to generate this article. Because there is a significant amount more code involved than most other posts I've written, it's hidden by default to allow people to concentrate on the important bits.
+
+
+```python
+from IPython.display import HTML
+
+HTML('''
+''')
+```
+
+
+
+
+
+
+
+
+
+# The Market Just Knew
+
+I recently saw two examples of stock charts that have kept me thinking for a while. And now that the semester is complete, I finally have enough time to really look at them and give them the treatment they deserve. The first is good old Apple:
+
+
+```python
+from secrets import QUANDL_KEY
+import matplotlib.pyplot as plt
+from matplotlib.dates import date2num
+from matplotlib.finance import candlestick_ohlc
+from matplotlib.dates import DateFormatter, WeekdayLocator,\
+ DayLocator, MONDAY
+import quandl
+from datetime import datetime
+import pandas as pd
+%matplotlib inline
+
+def fetch_ticker(ticker, start, end):
+ # Quandl is currently giving me issues with returning
+ # the entire dataset and not slicing server-side.
+ # So instead, we'll do it client-side!
+ q_format = '%Y-%m-%d'
+ ticker_data = quandl.get('YAHOO/' + ticker,
+ start_date=start.strftime(q_format),
+ end_date=end.strftime(q_format),
+ authtoken=QUANDL_KEY)
+ return ticker_data
+
+def ohlc_dataframe(data, ax=None):
+ # Much of this code re-used from:
+ # http://matplotlib.org/examples/pylab_examples/finance_demo.html
+ if ax is None:
+ f, ax = plt.subplots()
+
+ vals = [(date2num(date), *(data.loc[date]))
+ for date in data.index]
+ candlestick_ohlc(ax, vals)
+
+ mondays = WeekdayLocator(MONDAY)
+ alldays = DayLocator()
+ weekFormatter = DateFormatter('%b %d')
+ ax.xaxis.set_major_locator(mondays)
+ ax.xaxis.set_minor_locator(alldays)
+ ax.xaxis.set_major_formatter(weekFormatter)
+ return ax
+
+AAPL = fetch_ticker('AAPL', datetime(2016, 3, 1), datetime(2016, 5, 1))
+ax = ohlc_dataframe(AAPL)
+plt.vlines(date2num(datetime(2016, 4, 26, 12)),
+ ax.get_ylim()[0], ax.get_ylim()[1],
+ color='b',
+ label='Earnings Release')
+plt.legend(loc=3)
+plt.title("Apple Price 3/1/2016 - 5/1/2016");
+```
+
+
+
+![png](_notebook_files/_notebook_3_0.png)
+
+
+
+The second chart is from Facebook:
+
+
+```python
+FB = fetch_ticker('FB', datetime(2016, 3, 1), datetime(2016, 5, 5))
+ax = ohlc_dataframe(FB)
+plt.vlines(date2num(datetime(2016, 4, 27, 12)),
+ ax.get_ylim()[0], ax.get_ylim()[1],
+ color='b', label='Earnings Release')
+plt.title('Facebook Price 3/5/2016 - 5/5/2016')
+plt.legend(loc=2);
+```
+
+
+
+![png](_notebook_files/_notebook_5_0.png)
+
+
+
+These two charts demonstrate two very specific phonomena: how the market prepares for earnings releases. Let's look at those charts again, but with some extra information. As we're about the see, the market "knew" in advance that Apple was going to perform poorly. The market expected that Facebook was going to perform poorly, and instead shot the lights out. Let's see that trend in action:
+
+
+```python
+def plot_hilo(ax, start, end, data):
+ ax.plot([date2num(start), date2num(end)],
+ [data.loc[start]['High'], data.loc[end]['High']],
+ color='b')
+ ax.plot([date2num(start), date2num(end)],
+ [data.loc[start]['Low'], data.loc[end]['Low']],
+ color='b')
+
+f, axarr = plt.subplots(1, 2)
+
+ax_aapl = axarr[0]
+ax_fb = axarr[1]
+
+# Plot the AAPL trend up and down
+ohlc_dataframe(AAPL, ax=ax_aapl)
+plot_hilo(ax_aapl, datetime(2016, 3, 1), datetime(2016, 4, 15), AAPL)
+plot_hilo(ax_aapl, datetime(2016, 4, 18), datetime(2016, 4, 26), AAPL)
+ax_aapl.vlines(date2num(datetime(2016, 4, 26, 12)),
+ ax_aapl.get_ylim()[0], ax_aapl.get_ylim()[1],
+ color='g', label='Earnings Release')
+ax_aapl.legend(loc=2)
+ax_aapl.set_title('AAPL Price History')
+
+# Plot the FB trend down and up
+ohlc_dataframe(FB, ax=ax_fb)
+plot_hilo(ax_fb, datetime(2016, 3, 30), datetime(2016, 4, 27), FB)
+plot_hilo(ax_fb, datetime(2016, 4, 28), datetime(2016, 5, 5), FB)
+ax_fb.vlines(date2num(datetime(2016, 4, 27, 12)),
+ ax_fb.get_ylim()[0], ax_fb.get_ylim()[1],
+ color='g', label='Earnings Release')
+ax_fb.legend(loc=2)
+ax_fb.set_title('FB Price History')
+
+f.set_size_inches(18, 6)
+```
+
+
+
+![png](_notebook_files/_notebook_7_0.png)
+
+
+
+As we can see above, the market broke a prevailing trend on Apple in order to go down, and ultimately predict the earnings release. For Facebook, the opposite happened. While the trend was down, the earnings were fantastic and the market corrected itself much higher.
+
+# Formulating the Question
+
+While these are two specific examples, there are plenty of other examples you could cite one way or another. Even if the preponderance of evidence shows that the market correctly predicts earnings releases, we need not accuse people of collusion; for a company like Apple with many suppliers we can generally forecast how Apple has done based on those same suppliers.
+
+The question then, is this: **how well does the market predict the earnings releases?** It's an incredibly broad question that I want to disect in a couple of different ways:
+
+1. Given a stock that has been trending down over the past N days before an earnings release, how likely does it continue downward after the release?
+2. Given a stock trending up, how likely does it continue up?
+3. Is there a difference in accuracy between large- and small-cap stocks?
+4. How often, and for how long, do markets trend before an earnings release?
+
+**I want to especially thank Alejandro Saltiel for helping me retrieve the data.** He's great. And now for all of the interesting bits.
+
+# Event Studies
+
+Before we go too much further, I want to introduce the actual event study. Each chart intends to capture a lot of information and present an easy-to-understand pattern:
+
+
+```python
+import numpy as np
+import pandas as pd
+from pandas.tseries.holiday import USFederalHolidayCalendar
+from pandas.tseries.offsets import CustomBusinessDay
+from datetime import datetime, timedelta
+
+# If you remove rules, it removes them from *all* calendars
+# To ensure we don't pop rules we don't want to, first make
+# sure to fully copy the object
+trade_calendar = USFederalHolidayCalendar()
+trade_calendar.rules.pop(6) # Remove Columbus day
+trade_calendar.rules.pop(7) # Remove Veteran's day
+TradeDay = lambda days: CustomBusinessDay(days, calendar=trade_calendar)
+
+def plot_study(array):
+ # Given a 2-d array, we assume the event happens at index `lookback`,
+ # and create all of our summary statistics from there.
+ lookback = int((array.shape[1] - 1) / 2)
+ norm_factor = np.repeat(array[:,lookback].reshape(-1, 1), array.shape[1], axis=1)
+ centered_data = array / norm_factor - 1
+ lookforward = centered_data.shape[1] - lookback
+ means = centered_data.mean(axis=0)
+ lookforward_data = centered_data[:,lookforward:]
+ std_dev = np.hstack([0, lookforward_data.std(axis=0)])
+ maxes = lookforward_data.max(axis=0)
+ mins = lookforward_data.min(axis=0)
+
+ f, axarr = plt.subplots(1, 2)
+ range_begin = -lookback
+ range_end = lookforward
+ axarr[0].plot(range(range_begin, range_end), means)
+ axarr[1].plot(range(range_begin, range_end), means)
+ axarr[0].fill_between(range(0, range_end),
+ means[-lookforward:] + std_dev,
+ means[-lookforward:] - std_dev,
+ alpha=.5, label="$\pm$ 1 s.d.")
+ axarr[1].fill_between(range(0, range_end),
+ means[-lookforward:] + std_dev,
+ means[-lookforward:] - std_dev,
+ alpha=.5, label="$\pm$ 1 s.d.")
+
+ max_err = maxes - means[-lookforward+1:]
+ min_err = means[-lookforward+1:] - mins
+ axarr[0].errorbar(range(1, range_end),
+ means[-lookforward+1:],
+ yerr=[min_err, max_err], label='Max & Min')
+ axarr[0].legend(loc=2)
+ axarr[1].legend(loc=2)
+
+ axarr[0].set_xlim((-lookback-1, lookback+1))
+ axarr[1].set_xlim((-lookback-1, lookback+1))
+
+def plot_study_small(array):
+ # Given a 2-d array, we assume the event happens at index `lookback`,
+ # and create all of our summary statistics from there.
+ lookback = int((array.shape[1] - 1) / 2)
+ norm_factor = np.repeat(array[:,lookback].reshape(-1, 1), array.shape[1], axis=1)
+ centered_data = array / norm_factor - 1
+ lookforward = centered_data.shape[1] - lookback
+ means = centered_data.mean(axis=0)
+ lookforward_data = centered_data[:,lookforward:]
+ std_dev = np.hstack([0, lookforward_data.std(axis=0)])
+ maxes = lookforward_data.max(axis=0)
+ mins = lookforward_data.min(axis=0)
+
+ range_begin = -lookback
+ range_end = lookforward
+ plt.plot(range(range_begin, range_end), means)
+ plt.fill_between(range(0, range_end),
+ means[-lookforward:] + std_dev,
+ means[-lookforward:] - std_dev,
+ alpha=.5, label="$\pm$ 1 s.d.")
+
+ max_err = maxes - means[-lookforward+1:]
+ min_err = means[-lookforward+1:] - mins
+ plt.errorbar(range(1, range_end),
+ means[-lookforward+1:],
+ yerr=[min_err, max_err], label='Max & Min')
+ plt.legend(loc=2)
+ plt.xlim((-lookback-1, lookback+1))
+
+def fetch_event_data(ticker, events, horizon=5):
+ # Use horizon+1 to account for including the day of the event,
+ # and half-open interval - that is, for a horizon of 5,
+ # we should be including 11 events. Additionally, using the
+ # CustomBusinessDay means we automatically handle issues if
+ # for example a company reports Friday afternoon - the date
+ # calculator will turn this into a "Saturday" release, but
+ # we effectively shift that to Monday with the logic below.
+ td_back = TradeDay(horizon+1)
+ td_forward = TradeDay(horizon+1)
+
+ start_date = min(events) - td_back
+ end_date = max(events) + td_forward
+ total_data = fetch_ticker(ticker, start_date, end_date)
+ event_data = [total_data.ix[event-td_back:event+td_forward]\
+ [0:horizon*2+1]\
+ ['Adjusted Close']
+ for event in events]
+ return np.array(event_data)
+
+# Generate a couple of random events
+
+event_dates = [datetime(2016, 5, 27) - timedelta(days=1) - TradeDay(x*20) for x in range(1, 40)]
+data = fetch_event_data('CELG', event_dates)
+plot_study_small(data)
+plt.legend(loc=3)
+plt.gcf().set_size_inches(12, 6);
+
+
+plt.annotate('Mean price for days leading up to each event',
+ (-5, -.01), (-4.5, .025),
+ arrowprops=dict(facecolor='black', shrink=0.05))
+plt.annotate('', (-.1, .005), (-.5, .02),
+ arrowprops={'facecolor': 'black', 'shrink': .05})
+plt.annotate('$\pm$ 1 std. dev. each day', (5, .055), (2.5, .085),
+ arrowprops={'facecolor': 'black', 'shrink': .05})
+plt.annotate('Min/Max each day', (.9, -.07), (-1, -.1),
+ arrowprops={'facecolor': 'black', 'shrink': .05});
+```
+
+
+
+![png](_notebook_files/_notebook_11_0.png)
+
+
+
+And as a quick textual explanation as well:
+
+- The blue line represents the mean price for each day, represented as a percentage of the price on the '0-day'. For example, if we defined an 'event' as whenever the stock price dropped for three days, we would see a decreasing blue line to the left of the 0-day.
+
+- The blue shaded area represents one standard deviation above and below the mean price for each day following an event. This is intended to give us an idea of what the stock price does in general following an event.
+
+- The green bars are the minimum and maximum price for each day following an event. This instructs us as to how much it's possible for the stock to move.
+
+# Event Type 1: Trending down over the past N days
+
+The first type of event I want to study is how stocks perform when they've been trending down over the past couple of days prior to a release. However, we need to clarify what exactly is meant by "trending down." To do so, we'll use the following metric: **the midpoint between each day's opening and closing price goes down over a period of N days**.
+
+It's probably helpful to have an example:
+
+
+```python
+f, axarr = plt.subplots(1, 2)
+f.set_size_inches(18, 6)
+
+FB_plot = axarr[0]
+ohlc_dataframe(FB[datetime(2016, 4, 18):], FB_plot)
+
+FB_truncated = FB[datetime(2016, 4, 18):datetime(2016, 4, 27)]
+midpoint = FB_truncated['Open']/2 + FB_truncated['Close']/2
+FB_plot.plot(FB_truncated.index, midpoint, label='Midpoint')
+FB_plot.vlines(date2num(datetime(2016, 4, 27, 12)),
+ ax_fb.get_ylim()[0], ax_fb.get_ylim()[1],
+ color='g', label='Earnings Release')
+FB_plot.legend(loc=2)
+FB_plot.set_title('FB Midpoint Plot')
+
+AAPL_plot = axarr[1]
+ohlc_dataframe(AAPL[datetime(2016, 4, 10):], AAPL_plot)
+AAPL_truncated = AAPL[datetime(2016, 4, 10):datetime(2016, 4, 26)]
+midpoint = AAPL_truncated['Open']/2 + AAPL_truncated['Close']/2
+AAPL_plot.plot(AAPL_truncated.index, midpoint, label='Midpoint')
+AAPL_plot.vlines(date2num(datetime(2016, 4, 26, 12)),
+ ax_aapl.get_ylim()[0], ax_aapl.get_ylim()[1],
+ color='g', label='Earnings Release')
+AAPL_plot.legend(loc=3)
+AAPL_plot.set_title('AAPL Midpoint Plot');
+```
+
+
+
+![png](_notebook_files/_notebook_14_0.png)
+
+
+
+Given these charts, we can see that FB was trending down for the four days preceding the earnings release, and AAPL was trending down for a whopping 8 days (we don't count the peak day). This will define the methodology that we will use for the study.
+
+So what are the results? For a given horizon, how well does the market actually perform?
+
+
+```python
+# Read in the events for each stock;
+# The file was created using the first code block in the Appendix
+import yaml
+from dateutil.parser import parse
+from progressbar import ProgressBar
+
+data_str = open('earnings_dates.yaml', 'r').read()
+# Need to remove invalid lines
+filtered = filter(lambda x: '{' not in x, data_str.split('\n'))
+earnings_data = yaml.load('\n'.join(filtered))
+
+# Convert our earnings data into a list of (ticker, date) pairs
+# to make it easy to work with.
+# This is horribly inefficient, but should get us what we need
+ticker_dates = []
+for ticker, date_list in earnings_data.items():
+ for iso_str in date_list:
+ ticker_dates.append((ticker, parse(iso_str)))
+
+def does_trend_down(ticker, event, horizon):
+ # Figure out if the `event` has a downtrend for
+ # the `horizon` days preceding it
+ # As an interpretation note: it is assumed that
+ # the closing price of day `event` is the reference
+ # point, and we want `horizon` days before that.
+ # The price_data.hdf was created in the second appendix code block
+ try:
+ ticker_data = pd.read_hdf('price_data.hdf', ticker)
+ data = ticker_data[event-TradeDay(horizon):event]
+ midpoints = data['Open']/2 + data['Close']/2
+
+ # Shift dates one forward into the future and subtract
+ # Effectively: do we trend down over all days?
+ elems = midpoints - midpoints.shift(1)
+ return len(elems)-1 == len(elems.dropna()[elems <= 0])
+ except KeyError:
+ # If the stock doesn't exist, it doesn't qualify as trending down
+ # Mostly this is here to make sure the entire analysis doesn't
+ # blow up if there were issues in data retrieval
+ return False
+
+def study_trend(horizon, trend_function):
+ five_day_events = np.zeros((1, horizon*2 + 1))
+ invalid_events = []
+ for ticker, event in ProgressBar()(ticker_dates):
+ if trend_function(ticker, event, horizon):
+ ticker_data = pd.read_hdf('price_data.hdf', ticker)
+ event_data = ticker_data[event-TradeDay(horizon):event+TradeDay(horizon)]['Close']
+
+ try:
+ five_day_events = np.vstack([five_day_events, event_data])
+ except ValueError:
+ # Sometimes we don't get exactly the right number of values due to calendar
+ # issues. I've fixed most everything I can, and the few issues that are left
+ # I assume don't systemically bias the results (i.e. data could be missing
+ # because it doesn't exist, etc.). After running through, ~1% of events get
+ # discarded this way
+ invalid_events.append((ticker, event))
+
+
+ # Remove our initial zero row
+ five_day_events = five_day_events[1:,:]
+ plot_study(five_day_events)
+ plt.gcf().suptitle('Action over {} days: {} events'
+ .format(horizon,five_day_events.shape[0]))
+ plt.gcf().set_size_inches(18, 6)
+
+# Start with a 5 day study
+study_trend(5, does_trend_down)
+```
+
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:21:38 Time: 0:21:38
+
+
+
+
+![png](_notebook_files/_notebook_16_1.png)
+
+
+
+When a stock has been trending down for 5 days, once the earnings are announced it really doesn't move on average. However, the variability is *incredible*. This implies two important things:
+
+1. The market is just as often wrong about an earnings announcement before it happens as it is correct
+2. The incredible width of the min/max bars and standard deviation area tell us that the market reacts *violently* after the earnings are released.
+
+Let's repeat the same study, but over a time horizon of 8 days and 3 days. Presumably if a stock has been going down for 8 days at a time before the earnings, the market should be more accurate.
+
+
+```python
+# 8 day study next
+study_trend(8, does_trend_down)
+```
+
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:20:29 Time: 0:20:29
+
+
+
+
+![png](_notebook_files/_notebook_18_1.png)
+
+
+
+However, looking only at stocks that trended down for 8 days prior to a release, the same pattern emerges: on average, the stock doesn't move, but the market reaction is often incredibly violent.
+
+
+```python
+# 3 day study after that
+study_trend(3, does_trend_down)
+```
+
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:26:26 Time: 0:26:26
+
+
+
+
+![png](_notebook_files/_notebook_20_1.png)
+
+
+
+Finally, when we look at a 3-day horizon, we start getting some incredible outliers. Stocks have a potential to move over ~300% up, and the standard deviation width is again, incredible. The results for a 3-day horizon follow the same pattern we've seen in the 5- and 8-day horizons.
+
+# Event Type 2: Trending up for N days
+
+We're now going to repeat the analysis, but do it for uptrends instead. That is, instead of looking at stocks that have been trending down over the past number of days, we focus only on stocks that have been trending up.
+
+
+```python
+def does_trend_up(ticker, event, horizon):
+ # Figure out if the `event` has an uptrend for
+ # the `horizon` days preceding it
+ # As an interpretation note: it is assumed that
+ # the closing price of day `event` is the reference
+ # point, and we want `horizon` days before that.
+ # The price_data.hdf was created in the second appendix code block
+ try:
+ ticker_data = pd.read_hdf('price_data.hdf', ticker)
+ data = ticker_data[event-TradeDay(horizon):event]
+ midpoints = data['Open']/2 + data['Close']/2
+
+ # Shift dates one forward into the future and subtract
+ # Effectively: do we trend down over all days?
+ elems = midpoints - midpoints.shift(1)
+ return len(elems)-1 == len(elems.dropna()[elems >= 0])
+ except KeyError:
+ # If the stock doesn't exist, it doesn't qualify as trending down
+ # Mostly this is here to make sure the entire analysis doesn't
+ # blow up if there were issues in data retrieval
+ return False
+
+study_trend(5, does_trend_up)
+```
+
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:22:51 Time: 0:22:51
+
+
+
+
+![png](_notebook_files/_notebook_23_1.png)
+
+
+
+The patterns here are very similar. With the exception of noting that stocks can go to nearly 400% after an earnings announcement (most likely this included a takeover announcement, etc.), we still see large min/max bars and wide standard deviation of returns.
+
+We'll repeat the pattern for stocks going up for both 8 and 3 days straight, but at this point, the results should be very predictable:
+
+
+```python
+study_trend(8, does_trend_up)
+```
+
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:20:51 Time: 0:20:51
+
+
+
+
+![png](_notebook_files/_notebook_25_1.png)
+
+
+
+
+```python
+study_trend(3, does_trend_up)
+```
+
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:26:56 Time: 0:26:56
+
+
+
+
+![png](_notebook_files/_notebook_26_1.png)
+
+
+
+# Conclusion and Summary
+
+I guess the most important thing to summarize with is this: **looking at the entire market, stock performance prior to an earnings release has no bearing on the stock's performance.** Honestly: given the huge variability of returns after an earnings release, even when the stock has been trending for a long time, you're best off divesting before an earnings release and letting the market sort itself out.
+
+*However*, there is a big caveat. These results are taken when we look at the entire market. So while we can say that the market as a whole knows nothing and just reacts violently, I want to take a closer look into this data. Does the market typically perform poorly on large-cap/high liquidity stocks? Do smaller companies have investors that know them better and can thus predict performance better? Are specific market sectors better at prediction? Presumably technology stocks are more volatile than the industrials.
+
+So there are some more interesting questions I still want to ask with this data. Knowing that the hard work of data processing is largely already done, it should be fairly simple to continue this analysis and get much more refined with it. Until next time.
+
+# Appendix
+
+Export event data for Russell 3000 companies:
+
+```python
+import pandas as pd
+from html.parser import HTMLParser
+from datetime import datetime, timedelta
+import requests
+import re
+from dateutil import parser
+import progressbar
+from concurrent import futures
+import yaml
+
+class EarningsParser(HTMLParser):
+ store_dates = False
+ earnings_offset = None
+ dates = []
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.dates = []
+
+ def handle_starttag(self, tag, attrs):
+ if tag == 'table':
+ self.store_dates = True
+
+ def handle_data(self, data):
+ if self.store_dates:
+ match = re.match(r'\d+/\d+/\d+', data)
+ if match:
+ self.dates.append(match.group(0))
+
+ # If a company reports before the bell, record the earnings date
+ # being at midnight the day before. Ex: WMT reports 5/19/2016,
+ # but we want the reference point to be the closing price on 5/18/2016
+ if 'After Close' in data:
+ self.earnings_offset = timedelta(days=0)
+ elif 'Before Open' in data:
+ self.earnings_offset = timedelta(days=-1)
+
+ def handle_endtag(self, tag):
+ if tag == 'table':
+ self.store_dates = False
+
+def earnings_releases(ticker):
+ #print("Looking up ticker {}".format(ticker))
+ user_agent = 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) '\
+ 'Gecko/20100101 Firefox/46.0'
+ headers = {'user-agent': user_agent}
+ base_url = 'http://www.streetinsider.com/ec_earnings.php?q={}'\
+ .format(ticker)
+ e = EarningsParser()
+ s = requests.Session()
+ a = requests.adapters.HTTPAdapter(max_retries=0)
+ s.mount('http://', a)
+ e.feed(str(s.get(base_url, headers=headers).content))
+
+ if e.earnings_offset is not None:
+ dates = map(lambda x: parser.parse(x) + e.earnings_offset, e.dates)
+ past = filter(lambda x: x < datetime.now(), dates)
+ return list(map(lambda d: d.isoformat(), past))
+
+# Use a Russell-3000 ETF tracker (ticker IWV) to get a list of holdings
+r3000 = pd.read_csv('https://www.ishares.com/us/products/239714/'
+ 'ishares-russell-3000-etf/1449138789749.ajax?'
+ 'fileType=csv&fileName=IWV_holdings&dataType=fund',
+ header=10)
+r3000_equities = r3000[(r3000['Exchange'] == 'NASDAQ') |
+ (r3000['Exchange'] == 'New York Stock Exchange Inc.')]
+
+dates_file = open('earnings_dates.yaml', 'w')
+
+with futures.ThreadPoolExecutor(max_workers=8) as pool:
+ fs = {pool.submit(earnings_releases, r3000_equities.ix[t]['Ticker']): t
+ for t in r3000_equities.index}
+ pbar = progressbar.ProgressBar(term_width=80,
+ max_value=r3000_equities.index.max())
+
+ for future in futures.as_completed(fs):
+ i = fs[future]
+ pbar.update(i)
+ dates_file.write(yaml.dump({r3000_equities.ix[i]['Ticker']:
+ future.result()}))
+```
+
+Downloading stock price data needed for the event studies:
+
+```python
+from secrets import QUANDL_KEY
+import pandas as pd
+import yaml
+from dateutil.parser import parse
+from datetime import timedelta
+import quandl
+from progressbar import ProgressBar
+
+def fetch_ticker(ticker, start, end):
+ # Quandl is currently giving me issues with returning
+ # the entire dataset and not slicing server-side.
+ # So instead, we'll do it client-side!
+ q_format = '%Y-%m-%d'
+ ticker_data = quandl.get('YAHOO/' + ticker,
+ start_date=start.strftime(q_format),
+ end_date=end.strftime(q_format),
+ authtoken=QUANDL_KEY)
+ return ticker_data
+
+data_str = open('earnings_dates.yaml', 'r').read()
+# Need to remove invalid lines
+filtered = filter(lambda x: '{' not in x, data_str.split('\n'))
+earnings_data = yaml.load('\n'.join(filtered))
+
+# Get the first 1500 keys - split up into two statements
+# because of Quandl rate limits
+tickers = list(earnings_data.keys())
+
+price_dict = {}
+invalid_tickers = []
+for ticker in ProgressBar()(tickers[0:1500]):
+ try:
+ # Replace '.' with '-' in name for some tickers
+ fixed = ticker.replace('.', '-')
+ event_strs = earnings_data[ticker]
+ events = [parse(event) for event in event_strs]
+ td = timedelta(days=20)
+ price_dict[ticker] = fetch_ticker(fixed,
+ min(events)-td, max(events)+td)
+ except quandl.NotFoundError:
+ invalid_tickers.append(ticker)
+
+# Execute this after 10 minutes have passed
+for ticker in ProgressBar()(tickers[1500:]):
+ try:
+ # Replace '.' with '-' in name for some tickers
+ fixed = ticker.replace('.', '-')
+ event_strs = earnings_data[ticker]
+ events = [parse(event) for event in event_strs]
+ td = timedelta(days=20)
+ price_dict[ticker] = fetch_ticker(fixed,
+ min(events)-td, max(events)+td)
+ except quandl.NotFoundError:
+ invalid_tickers.append(ticker)
+
+prices_store = pd.HDFStore('price_data.hdf')
+for ticker, prices in price_dict.items():
+ prices_store[ticker] = prices
+```
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_11_0.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_11_0.png
new file mode 100644
index 0000000..a57bfcc
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_11_0.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_14_0.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_14_0.png
new file mode 100644
index 0000000..9cb3892
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_14_0.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_16_1.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_16_1.png
new file mode 100644
index 0000000..2a5f796
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_16_1.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_18_1.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_18_1.png
new file mode 100644
index 0000000..7ab528a
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_18_1.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_20_1.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_20_1.png
new file mode 100644
index 0000000..10ba689
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_20_1.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_23_1.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_23_1.png
new file mode 100644
index 0000000..4432ff1
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_23_1.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_25_1.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_25_1.png
new file mode 100644
index 0000000..943f619
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_25_1.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_26_1.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_26_1.png
new file mode 100644
index 0000000..5ec4434
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_26_1.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_3_0.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_3_0.png
new file mode 100644
index 0000000..d860f2f
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_3_0.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_5_0.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_5_0.png
new file mode 100644
index 0000000..eef8ebc
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_5_0.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_7_0.png b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_7_0.png
new file mode 100644
index 0000000..1d00856
Binary files /dev/null and b/blog/2016-06-08-event-studies-and-earnings-releases/_notebook_files/_notebook_7_0.png differ
diff --git a/blog/2016-06-08-event-studies-and-earnings-releases/index.mdx b/blog/2016-06-08-event-studies-and-earnings-releases/index.mdx
new file mode 100644
index 0000000..42417ee
--- /dev/null
+++ b/blog/2016-06-08-event-studies-and-earnings-releases/index.mdx
@@ -0,0 +1,692 @@
+---
+slug: 2016/06/event-studies-and-earnings-releases
+title: Event studies and earnings releases
+date: 2016-06-08 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+Or, being suspicious of market insiders.
+
+
+
+## The Market Just Knew
+
+I recently saw two examples of stock charts that have kept me thinking for a while. And now that the semester is complete, I finally have enough time to really look at them and give them the treatment they deserve. The first is good old Apple:
+
+
+
+Code
+
+```python
+from secrets import QUANDL_KEY
+import matplotlib.pyplot as plt
+from matplotlib.dates import date2num
+from matplotlib.finance import candlestick_ohlc
+from matplotlib.dates import DateFormatter, WeekdayLocator,\
+ DayLocator, MONDAY
+import quandl
+from datetime import datetime
+import pandas as pd
+%matplotlib inline
+
+def fetch_ticker(ticker, start, end):
+ # Quandl is currently giving me issues with returning
+ # the entire dataset and not slicing server-side.
+ # So instead, we'll do it client-side!
+ q_format = '%Y-%m-%d'
+ ticker_data = quandl.get('YAHOO/' + ticker,
+ start_date=start.strftime(q_format),
+ end_date=end.strftime(q_format),
+ authtoken=QUANDL_KEY)
+ return ticker_data
+
+def ohlc_dataframe(data, ax=None):
+ # Much of this code re-used from:
+ # http://matplotlib.org/examples/pylab_examples/finance_demo.html
+ if ax is None:
+ f, ax = plt.subplots()
+
+ vals = [(date2num(date), *(data.loc[date]))
+ for date in data.index]
+ candlestick_ohlc(ax, vals)
+
+ mondays = WeekdayLocator(MONDAY)
+ alldays = DayLocator()
+ weekFormatter = DateFormatter('%b %d')
+ ax.xaxis.set_major_locator(mondays)
+ ax.xaxis.set_minor_locator(alldays)
+ ax.xaxis.set_major_formatter(weekFormatter)
+ return ax
+```
+
+
+```python
+AAPL = fetch_ticker('AAPL', datetime(2016, 3, 1), datetime(2016, 5, 1))
+ax = ohlc_dataframe(AAPL)
+plt.vlines(date2num(datetime(2016, 4, 26, 12)),
+ ax.get_ylim()[0], ax.get_ylim()[1],
+ color='b',
+ label='Earnings Release')
+plt.legend(loc=3)
+plt.title("Apple Price 3/1/2016 - 5/1/2016");
+```
+
+![png](_notebook_files/_notebook_3_0.png)
+
+The second chart is from Facebook:
+
+```python
+FB = fetch_ticker('FB', datetime(2016, 3, 1), datetime(2016, 5, 5))
+ax = ohlc_dataframe(FB)
+plt.vlines(date2num(datetime(2016, 4, 27, 12)),
+ ax.get_ylim()[0], ax.get_ylim()[1],
+ color='b', label='Earnings Release')
+plt.title('Facebook Price 3/5/2016 - 5/5/2016')
+plt.legend(loc=2);
+```
+
+![png](_notebook_files/_notebook_5_0.png)
+
+These two charts demonstrate two very specific phonomena: how the market prepares for earnings releases. Let's look at those charts again, but with some extra information. As we're about the see, the market "knew" in advance that Apple was going to perform poorly. The market expected that Facebook was going to perform poorly, and instead shot the lights out. Let's see that trend in action:
+
+
+Code
+
+```python
+def plot_hilo(ax, start, end, data):
+ ax.plot([date2num(start), date2num(end)],
+ [data.loc[start]['High'], data.loc[end]['High']],
+ color='b')
+ ax.plot([date2num(start), date2num(end)],
+ [data.loc[start]['Low'], data.loc[end]['Low']],
+ color='b')
+
+f, axarr = plt.subplots(1, 2)
+
+ax_aapl = axarr[0]
+ax_fb = axarr[1]
+
+# Plot the AAPL trend up and down
+ohlc_dataframe(AAPL, ax=ax_aapl)
+plot_hilo(ax_aapl, datetime(2016, 3, 1), datetime(2016, 4, 15), AAPL)
+plot_hilo(ax_aapl, datetime(2016, 4, 18), datetime(2016, 4, 26), AAPL)
+ax_aapl.vlines(date2num(datetime(2016, 4, 26, 12)),
+ ax_aapl.get_ylim()[0], ax_aapl.get_ylim()[1],
+ color='g', label='Earnings Release')
+ax_aapl.legend(loc=2)
+ax_aapl.set_title('AAPL Price History')
+
+# Plot the FB trend down and up
+ohlc_dataframe(FB, ax=ax_fb)
+plot_hilo(ax_fb, datetime(2016, 3, 30), datetime(2016, 4, 27), FB)
+plot_hilo(ax_fb, datetime(2016, 4, 28), datetime(2016, 5, 5), FB)
+ax_fb.vlines(date2num(datetime(2016, 4, 27, 12)),
+ ax_fb.get_ylim()[0], ax_fb.get_ylim()[1],
+ color='g', label='Earnings Release')
+ax_fb.legend(loc=2)
+ax_fb.set_title('FB Price History')
+
+f.set_size_inches(18, 6)
+```
+
+
+![png](_notebook_files/_notebook_7_0.png)
+
+As we can see above, the market broke a prevailing trend on Apple in order to go down, and ultimately predict the earnings release. For Facebook, the opposite happened. While the trend was down, the earnings were fantastic and the market corrected itself much higher.
+
+## Formulating the Question
+
+While these are two specific examples, there are plenty of other examples you could cite one way or another. Even if the preponderance of evidence shows that the market correctly predicts earnings releases, we need not accuse people of collusion; for a company like Apple with many suppliers we can generally forecast how Apple has done based on those same suppliers.
+
+The question then, is this: **how well does the market predict the earnings releases?** It's an incredibly broad question that I want to disect in a couple of different ways:
+
+1. Given a stock that has been trending down over the past N days before an earnings release, how likely does it continue downward after the release?
+2. Given a stock trending up, how likely does it continue up?
+3. Is there a difference in accuracy between large- and small-cap stocks?
+4. How often, and for how long, do markets trend before an earnings release?
+
+**I want to especially thank Alejandro Saltiel for helping me retrieve the data.** He's great. And now for all of the interesting bits.
+
+## Event Studies
+
+Before we go too much further, I want to introduce the actual event study. Each chart intends to capture a lot of information and present an easy-to-understand pattern:
+
+
+Code
+
+```python
+import numpy as np
+import pandas as pd
+from pandas.tseries.holiday import USFederalHolidayCalendar
+from pandas.tseries.offsets import CustomBusinessDay
+from datetime import datetime, timedelta
+
+# If you remove rules, it removes them from *all* calendars
+# To ensure we don't pop rules we don't want to, first make
+# sure to fully copy the object
+trade_calendar = USFederalHolidayCalendar()
+trade_calendar.rules.pop(6) # Remove Columbus day
+trade_calendar.rules.pop(7) # Remove Veteran's day
+TradeDay = lambda days: CustomBusinessDay(days, calendar=trade_calendar)
+
+def plot_study(array):
+ # Given a 2-d array, we assume the event happens at index `lookback`,
+ # and create all of our summary statistics from there.
+ lookback = int((array.shape[1] - 1) / 2)
+ norm_factor = np.repeat(array[:,lookback].reshape(-1, 1), array.shape[1], axis=1)
+ centered_data = array / norm_factor - 1
+ lookforward = centered_data.shape[1] - lookback
+ means = centered_data.mean(axis=0)
+ lookforward_data = centered_data[:,lookforward:]
+ std_dev = np.hstack([0, lookforward_data.std(axis=0)])
+ maxes = lookforward_data.max(axis=0)
+ mins = lookforward_data.min(axis=0)
+
+ f, axarr = plt.subplots(1, 2)
+ range_begin = -lookback
+ range_end = lookforward
+ axarr[0].plot(range(range_begin, range_end), means)
+ axarr[1].plot(range(range_begin, range_end), means)
+ axarr[0].fill_between(range(0, range_end),
+ means[-lookforward:] + std_dev,
+ means[-lookforward:] - std_dev,
+ alpha=.5, label="$\pm$ 1 s.d.")
+ axarr[1].fill_between(range(0, range_end),
+ means[-lookforward:] + std_dev,
+ means[-lookforward:] - std_dev,
+ alpha=.5, label="$\pm$ 1 s.d.")
+
+ max_err = maxes - means[-lookforward+1:]
+ min_err = means[-lookforward+1:] - mins
+ axarr[0].errorbar(range(1, range_end),
+ means[-lookforward+1:],
+ yerr=[min_err, max_err], label='Max & Min')
+ axarr[0].legend(loc=2)
+ axarr[1].legend(loc=2)
+
+ axarr[0].set_xlim((-lookback-1, lookback+1))
+ axarr[1].set_xlim((-lookback-1, lookback+1))
+
+def plot_study_small(array):
+ # Given a 2-d array, we assume the event happens at index `lookback`,
+ # and create all of our summary statistics from there.
+ lookback = int((array.shape[1] - 1) / 2)
+ norm_factor = np.repeat(array[:,lookback].reshape(-1, 1), array.shape[1], axis=1)
+ centered_data = array / norm_factor - 1
+ lookforward = centered_data.shape[1] - lookback
+ means = centered_data.mean(axis=0)
+ lookforward_data = centered_data[:,lookforward:]
+ std_dev = np.hstack([0, lookforward_data.std(axis=0)])
+ maxes = lookforward_data.max(axis=0)
+ mins = lookforward_data.min(axis=0)
+
+ range_begin = -lookback
+ range_end = lookforward
+ plt.plot(range(range_begin, range_end), means)
+ plt.fill_between(range(0, range_end),
+ means[-lookforward:] + std_dev,
+ means[-lookforward:] - std_dev,
+ alpha=.5, label="$\pm$ 1 s.d.")
+
+ max_err = maxes - means[-lookforward+1:]
+ min_err = means[-lookforward+1:] - mins
+ plt.errorbar(range(1, range_end),
+ means[-lookforward+1:],
+ yerr=[min_err, max_err], label='Max & Min')
+ plt.legend(loc=2)
+ plt.xlim((-lookback-1, lookback+1))
+
+def fetch_event_data(ticker, events, horizon=5):
+ # Use horizon+1 to account for including the day of the event,
+ # and half-open interval - that is, for a horizon of 5,
+ # we should be including 11 events. Additionally, using the
+ # CustomBusinessDay means we automatically handle issues if
+ # for example a company reports Friday afternoon - the date
+ # calculator will turn this into a "Saturday" release, but
+ # we effectively shift that to Monday with the logic below.
+ td_back = TradeDay(horizon+1)
+ td_forward = TradeDay(horizon+1)
+
+ start_date = min(events) - td_back
+ end_date = max(events) + td_forward
+ total_data = fetch_ticker(ticker, start_date, end_date)
+ event_data = [total_data.ix[event-td_back:event+td_forward]\
+ [0:horizon*2+1]\
+ ['Adjusted Close']
+ for event in events]
+ return np.array(event_data)
+```
+
+
+```python
+# Generate a couple of random events
+
+event_dates = [datetime(2016, 5, 27) - timedelta(days=1) - TradeDay(x*20) for x in range(1, 40)]
+data = fetch_event_data('CELG', event_dates)
+plot_study_small(data)
+plt.legend(loc=3)
+plt.gcf().set_size_inches(12, 6);
+
+
+plt.annotate('Mean price for days leading up to each event',
+ (-5, -.01), (-4.5, .025),
+ arrowprops=dict(facecolor='black', shrink=0.05))
+plt.annotate('', (-.1, .005), (-.5, .02),
+ arrowprops={'facecolor': 'black', 'shrink': .05})
+plt.annotate('$\pm$ 1 std. dev. each day', (5, .055), (2.5, .085),
+ arrowprops={'facecolor': 'black', 'shrink': .05})
+plt.annotate('Min/Max each day', (.9, -.07), (-1, -.1),
+ arrowprops={'facecolor': 'black', 'shrink': .05});
+```
+
+
+
+![png](_notebook_files/_notebook_11_0.png)
+
+
+
+And as a quick textual explanation as well:
+
+- The blue line represents the mean price for each day, represented as a percentage of the price on the '0-day'. For example, if we defined an 'event' as whenever the stock price dropped for three days, we would see a decreasing blue line to the left of the 0-day.
+- The blue shaded area represents one standard deviation above and below the mean price for each day following an event. This is intended to give us an idea of what the stock price does in general following an event.
+- The green bars are the minimum and maximum price for each day following an event. This instructs us as to how much it's possible for the stock to move.
+
+## Event Type 1: Trending down over the past N days
+
+The first type of event I want to study is how stocks perform when they've been trending down over the past couple of days prior to a release. However, we need to clarify what exactly is meant by "trending down." To do so, we'll use the following metric: **the midpoint between each day's opening and closing price goes down over a period of N days**.
+
+It's probably helpful to have an example:
+
+
+Code
+```python
+f, axarr = plt.subplots(1, 2)
+f.set_size_inches(18, 6)
+
+FB_plot = axarr[0]
+ohlc_dataframe(FB[datetime(2016, 4, 18):], FB_plot)
+
+FB_truncated = FB[datetime(2016, 4, 18):datetime(2016, 4, 27)]
+midpoint = FB_truncated['Open']/2 + FB_truncated['Close']/2
+FB_plot.plot(FB_truncated.index, midpoint, label='Midpoint')
+FB_plot.vlines(date2num(datetime(2016, 4, 27, 12)),
+ ax_fb.get_ylim()[0], ax_fb.get_ylim()[1],
+ color='g', label='Earnings Release')
+FB_plot.legend(loc=2)
+FB_plot.set_title('FB Midpoint Plot')
+
+AAPL_plot = axarr[1]
+ohlc_dataframe(AAPL[datetime(2016, 4, 10):], AAPL_plot)
+AAPL_truncated = AAPL[datetime(2016, 4, 10):datetime(2016, 4, 26)]
+midpoint = AAPL_truncated['Open']/2 + AAPL_truncated['Close']/2
+AAPL_plot.plot(AAPL_truncated.index, midpoint, label='Midpoint')
+AAPL_plot.vlines(date2num(datetime(2016, 4, 26, 12)),
+ ax_aapl.get_ylim()[0], ax_aapl.get_ylim()[1],
+ color='g', label='Earnings Release')
+AAPL_plot.legend(loc=3)
+AAPL_plot.set_title('AAPL Midpoint Plot');
+```
+
+
+![png](_notebook_files/_notebook_14_0.png)
+
+Given these charts, we can see that FB was trending down for the four days preceding the earnings release, and AAPL was trending down for a whopping 8 days (we don't count the peak day). This will define the methodology that we will use for the study.
+
+So what are the results? For a given horizon, how well does the market actually perform?
+
+
+Code
+
+```python
+# Read in the events for each stock;
+# The file was created using the first code block in the Appendix
+import yaml
+from dateutil.parser import parse
+from progressbar import ProgressBar
+
+data_str = open('earnings_dates.yaml', 'r').read()
+# Need to remove invalid lines
+filtered = filter(lambda x: '{' not in x, data_str.split('\n'))
+earnings_data = yaml.load('\n'.join(filtered))
+
+# Convert our earnings data into a list of (ticker, date) pairs
+# to make it easy to work with.
+# This is horribly inefficient, but should get us what we need
+ticker_dates = []
+for ticker, date_list in earnings_data.items():
+ for iso_str in date_list:
+ ticker_dates.append((ticker, parse(iso_str)))
+
+def does_trend_down(ticker, event, horizon):
+ # Figure out if the `event` has a downtrend for
+ # the `horizon` days preceding it
+ # As an interpretation note: it is assumed that
+ # the closing price of day `event` is the reference
+ # point, and we want `horizon` days before that.
+ # The price_data.hdf was created in the second appendix code block
+ try:
+ ticker_data = pd.read_hdf('price_data.hdf', ticker)
+ data = ticker_data[event-TradeDay(horizon):event]
+ midpoints = data['Open']/2 + data['Close']/2
+
+ # Shift dates one forward into the future and subtract
+ # Effectively: do we trend down over all days?
+ elems = midpoints - midpoints.shift(1)
+ return len(elems)-1 == len(elems.dropna()[elems <= 0])
+ except KeyError:
+ # If the stock doesn't exist, it doesn't qualify as trending down
+ # Mostly this is here to make sure the entire analysis doesn't
+ # blow up if there were issues in data retrieval
+ return False
+
+def study_trend(horizon, trend_function):
+ five_day_events = np.zeros((1, horizon*2 + 1))
+ invalid_events = []
+ for ticker, event in ProgressBar()(ticker_dates):
+ if trend_function(ticker, event, horizon):
+ ticker_data = pd.read_hdf('price_data.hdf', ticker)
+ event_data = ticker_data[event-TradeDay(horizon):event+TradeDay(horizon)]['Close']
+
+ try:
+ five_day_events = np.vstack([five_day_events, event_data])
+ except ValueError:
+ # Sometimes we don't get exactly the right number of values due to calendar
+ # issues. I've fixed most everything I can, and the few issues that are left
+ # I assume don't systemically bias the results (i.e. data could be missing
+ # because it doesn't exist, etc.). After running through, ~1% of events get
+ # discarded this way
+ invalid_events.append((ticker, event))
+
+
+ # Remove our initial zero row
+ five_day_events = five_day_events[1:,:]
+ plot_study(five_day_events)
+ plt.gcf().suptitle('Action over {} days: {} events'
+ .format(horizon,five_day_events.shape[0]))
+ plt.gcf().set_size_inches(18, 6)
+
+# Start with a 5 day study
+study_trend(5, does_trend_down)
+```
+
+```
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:21:38 Time: 0:21:38
+```
+
+
+![png](_notebook_files/_notebook_16_1.png)
+
+When a stock has been trending down for 5 days, once the earnings are announced it really doesn't move on average. However, the variability is *incredible*. This implies two important things:
+
+1. The market is just as often wrong about an earnings announcement before it happens as it is correct
+2. The incredible width of the min/max bars and standard deviation area tell us that the market reacts *violently* after the earnings are released.
+
+Let's repeat the same study, but over a time horizon of 8 days and 3 days. Presumably if a stock has been going down for 8 days at a time before the earnings, the market should be more accurate.
+
+
+Code
+
+```python
+# 8 day study next
+study_trend(8, does_trend_down)
+```
+
+```
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:20:29 Time: 0:20:29
+```
+
+
+![png](_notebook_files/_notebook_18_1.png)
+
+However, looking only at stocks that trended down for 8 days prior to a release, the same pattern emerges: on average, the stock doesn't move, but the market reaction is often incredibly violent.
+
+
+
+Code
+```python
+# 3 day study after that
+study_trend(3, does_trend_down)
+```
+
+```
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:26:26 Time: 0:26:26
+```
+
+
+![png](_notebook_files/_notebook_20_1.png)
+
+Finally, when we look at a 3-day horizon, we start getting some incredible outliers. Stocks have a potential to move over ~300% up, and the standard deviation width is again, incredible. The results for a 3-day horizon follow the same pattern we've seen in the 5- and 8-day horizons.
+
+## Event Type 2: Trending up for N days
+
+We're now going to repeat the analysis, but do it for uptrends instead. That is, instead of looking at stocks that have been trending down over the past number of days, we focus only on stocks that have been trending up.
+
+
+Code
+```python
+def does_trend_up(ticker, event, horizon):
+ # Figure out if the `event` has an uptrend for
+ # the `horizon` days preceding it
+ # As an interpretation note: it is assumed that
+ # the closing price of day `event` is the reference
+ # point, and we want `horizon` days before that.
+ # The price_data.hdf was created in the second appendix code block
+ try:
+ ticker_data = pd.read_hdf('price_data.hdf', ticker)
+ data = ticker_data[event-TradeDay(horizon):event]
+ midpoints = data['Open']/2 + data['Close']/2
+
+ # Shift dates one forward into the future and subtract
+ # Effectively: do we trend down over all days?
+ elems = midpoints - midpoints.shift(1)
+ return len(elems)-1 == len(elems.dropna()[elems >= 0])
+ except KeyError:
+ # If the stock doesn't exist, it doesn't qualify as trending down
+ # Mostly this is here to make sure the entire analysis doesn't
+ # blow up if there were issues in data retrieval
+ return False
+
+study_trend(5, does_trend_up)
+```
+
+```
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:22:51 Time: 0:22:51
+```
+
+
+![png](_notebook_files/_notebook_23_1.png)
+
+The patterns here are very similar. With the exception of noting that stocks can go to nearly 400% after an earnings announcement (most likely this included a takeover announcement, etc.), we still see large min/max bars and wide standard deviation of returns.
+
+We'll repeat the pattern for stocks going up for both 8 and 3 days straight, but at this point, the results should be very predictable:
+
+
+Code
+```python
+study_trend(8, does_trend_up)
+```
+
+```
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:20:51 Time: 0:20:51
+```
+
+
+![png](_notebook_files/_notebook_25_1.png)
+
+
+Code
+```python
+study_trend(3, does_trend_up)
+```
+
+```
+ 100% (47578 of 47578) |###########################################################| Elapsed Time: 0:26:56 Time: 0:26:56
+```
+
+
+![png](_notebook_files/_notebook_26_1.png)
+
+## Conclusion and Summary
+
+I guess the most important thing to summarize with is this: **looking at the entire market, stock performance prior to an earnings release has no bearing on the stock's performance.** Honestly: given the huge variability of returns after an earnings release, even when the stock has been trending for a long time, you're best off divesting before an earnings release and letting the market sort itself out.
+
+*However*, there is a big caveat. These results are taken when we look at the entire market. So while we can say that the market as a whole knows nothing and just reacts violently, I want to take a closer look into this data. Does the market typically perform poorly on large-cap/high liquidity stocks? Do smaller companies have investors that know them better and can thus predict performance better? Are specific market sectors better at prediction? Presumably technology stocks are more volatile than the industrials.
+
+So there are some more interesting questions I still want to ask with this data. Knowing that the hard work of data processing is largely already done, it should be fairly simple to continue this analysis and get much more refined with it. Until next time.
+
+# Appendix
+
+Export event data for Russell 3000 companies:
+
+
+Code
+```python
+import pandas as pd
+from html.parser import HTMLParser
+from datetime import datetime, timedelta
+import requests
+import re
+from dateutil import parser
+import progressbar
+from concurrent import futures
+import yaml
+
+class EarningsParser(HTMLParser):
+ store_dates = False
+ earnings_offset = None
+ dates = []
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.dates = []
+
+ def handle_starttag(self, tag, attrs):
+ if tag == 'table':
+ self.store_dates = True
+
+ def handle_data(self, data):
+ if self.store_dates:
+ match = re.match(r'\d+/\d+/\d+', data)
+ if match:
+ self.dates.append(match.group(0))
+
+ # If a company reports before the bell, record the earnings date
+ # being at midnight the day before. Ex: WMT reports 5/19/2016,
+ # but we want the reference point to be the closing price on 5/18/2016
+ if 'After Close' in data:
+ self.earnings_offset = timedelta(days=0)
+ elif 'Before Open' in data:
+ self.earnings_offset = timedelta(days=-1)
+
+ def handle_endtag(self, tag):
+ if tag == 'table':
+ self.store_dates = False
+
+def earnings_releases(ticker):
+ #print("Looking up ticker {}".format(ticker))
+ user_agent = 'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:46.0) '\
+ 'Gecko/20100101 Firefox/46.0'
+ headers = {'user-agent': user_agent}
+ base_url = 'http://www.streetinsider.com/ec_earnings.php?q={}'\
+ .format(ticker)
+ e = EarningsParser()
+ s = requests.Session()
+ a = requests.adapters.HTTPAdapter(max_retries=0)
+ s.mount('http://', a)
+ e.feed(str(s.get(base_url, headers=headers).content))
+
+ if e.earnings_offset is not None:
+ dates = map(lambda x: parser.parse(x) + e.earnings_offset, e.dates)
+ past = filter(lambda x: x < datetime.now(), dates)
+ return list(map(lambda d: d.isoformat(), past))
+
+# Use a Russell-3000 ETF tracker (ticker IWV) to get a list of holdings
+r3000 = pd.read_csv('https://www.ishares.com/us/products/239714/'
+ 'ishares-russell-3000-etf/1449138789749.ajax?'
+ 'fileType=csv&fileName=IWV_holdings&dataType=fund',
+ header=10)
+r3000_equities = r3000[(r3000['Exchange'] == 'NASDAQ') |
+ (r3000['Exchange'] == 'New York Stock Exchange Inc.')]
+
+dates_file = open('earnings_dates.yaml', 'w')
+
+with futures.ThreadPoolExecutor(max_workers=8) as pool:
+ fs = {pool.submit(earnings_releases, r3000_equities.ix[t]['Ticker']): t
+ for t in r3000_equities.index}
+ pbar = progressbar.ProgressBar(term_width=80,
+ max_value=r3000_equities.index.max())
+
+ for future in futures.as_completed(fs):
+ i = fs[future]
+ pbar.update(i)
+ dates_file.write(yaml.dump({r3000_equities.ix[i]['Ticker']:
+ future.result()}))
+```
+
+
+Downloading stock price data needed for the event studies:
+
+
+Code
+```python
+from secrets import QUANDL_KEY
+import pandas as pd
+import yaml
+from dateutil.parser import parse
+from datetime import timedelta
+import quandl
+from progressbar import ProgressBar
+
+def fetch_ticker(ticker, start, end):
+ # Quandl is currently giving me issues with returning
+ # the entire dataset and not slicing server-side.
+ # So instead, we'll do it client-side!
+ q_format = '%Y-%m-%d'
+ ticker_data = quandl.get('YAHOO/' + ticker,
+ start_date=start.strftime(q_format),
+ end_date=end.strftime(q_format),
+ authtoken=QUANDL_KEY)
+ return ticker_data
+
+data_str = open('earnings_dates.yaml', 'r').read()
+# Need to remove invalid lines
+filtered = filter(lambda x: '{' not in x, data_str.split('\n'))
+earnings_data = yaml.load('\n'.join(filtered))
+
+# Get the first 1500 keys - split up into two statements
+# because of Quandl rate limits
+tickers = list(earnings_data.keys())
+
+price_dict = {}
+invalid_tickers = []
+for ticker in ProgressBar()(tickers[0:1500]):
+ try:
+ # Replace '.' with '-' in name for some tickers
+ fixed = ticker.replace('.', '-')
+ event_strs = earnings_data[ticker]
+ events = [parse(event) for event in event_strs]
+ td = timedelta(days=20)
+ price_dict[ticker] = fetch_ticker(fixed,
+ min(events)-td, max(events)+td)
+ except quandl.NotFoundError:
+ invalid_tickers.append(ticker)
+
+# Execute this after 10 minutes have passed
+for ticker in ProgressBar()(tickers[1500:]):
+ try:
+ # Replace '.' with '-' in name for some tickers
+ fixed = ticker.replace('.', '-')
+ event_strs = earnings_data[ticker]
+ events = [parse(event) for event in event_strs]
+ td = timedelta(days=20)
+ price_dict[ticker] = fetch_ticker(fixed,
+ min(events)-td, max(events)+td)
+ except quandl.NotFoundError:
+ invalid_tickers.append(ticker)
+
+prices_store = pd.HDFStore('price_data.hdf')
+for ticker, prices in price_dict.items():
+ prices_store[ticker] = prices
+```
+
\ No newline at end of file
diff --git a/blog/2016-10-22-rustic-repodcasting/_article.md b/blog/2016-10-22-rustic-repodcasting/_article.md
new file mode 100644
index 0000000..4f7b467
--- /dev/null
+++ b/blog/2016-10-22-rustic-repodcasting/_article.md
@@ -0,0 +1,309 @@
+Title: A Rustic Re-Podcasting Server (Part 1)
+Date: 2016-10-22
+Category: Blog
+Tags: Rust, nutone
+Authors: Bradlee Speice
+Summary: Learning Rust by fire (it sounds better than learning by corrosion)
+[//]: <> "Modified: "
+
+I listen to a lot of Drum and Bass music, because it's beautiful music. And
+there's a particular site, [Bassdrive.com](http://bassdrive.com/) that hosts
+a lot of great content. Specifically, the
+[archives](http://archives.bassdrivearchive.com/) section of the site has a
+list of the past shows that you can download and listen to. The issue is, it's
+just a [giant list of links to download](http://archives.bassdrivearchive.com/6%20-%20Saturday/Electronic%20Warfare%20-%20The%20Overfiend/). I'd really like
+this in a podcast format to take with me on the road, etc.
+
+So I wrote the [elektricity](https://github.com/bspeice/elektricity) web
+application to actually accomplish all that. Whenever you request a feed, it
+goes out to Bassdrive, processes all the links on a page, and serves up some
+fresh, tasty RSS to satisfy your ears. I hosted it on Heroku using the free
+tier because it's really not resource-intensive at all.
+
+**The issue so far** is that I keep running out of free tier hours during a
+month because my podcasting application likes to have a server scan for new
+episodes constantly. Not sure why it's doing that, but I don't have a whole
+lot of control over it. It's a phenomenal application otherwise.
+
+**My (over-engineered) solution**: Re-write the application using the
+[Rust](https://www.rust-lang.org/en-US/) programming language. I'd like to run
+this on a small hacker board I own, and doing this in Rust would allow me to
+easily cross-compile it. Plus, I've been very interested in the Rust language
+for a while and this would be a great opportunity to really learn it well.
+The code is available [here](https://github.com/bspeice/nutone) as development
+progresses.
+
+# The Setup
+
+We'll be using the [iron](http://ironframework.io/) library to handle the
+server, and [hyper](http://hyper.rs/) to fetch the data we need from elsewhere
+on the interwebs. [HTML5Ever](http://doc.servo.org/html5ever/index.html) allows
+us to ingest the content that will be coming from Bassdrive, and finally,
+output is done with [handlebars-rust](http://sunng87.github.io/handlebars-rust/handlebars/index.html).
+
+It will ultimately be interesting to see how much more work must be done to
+actually get this working over another language like Python. Coming from a
+dynamic state of mind it's super easy to just chain stuff together, ship it out,
+and call it a day. I think I'm going to end up getting much dirtier trying to
+write all of this out.
+
+# Issue 1: Strings
+
+Strings in Rust are hard. I acknowledge Python can get away with some things
+that make strings super easy (and Python 3 has gotten better at cracking down
+on some bad cases, `str <-> bytes` specifically), but Rust is hard.
+
+Let's take for example the `404` error handler I'm trying to write. The result
+should be incredibly simple: All I want is to echo back
+`Didn't find URL: `. Shouldn't be that hard right? In Python I'd just do
+something like:
+
+```python
+def echo_handler(request):
+ return "You're visiting: {}".format(request.uri)
+```
+
+And we'd call it a day. Rust isn't so simple. Let's start with the trivial
+examples people post online:
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, "You found the server!")))
+}
+```
+
+Doesn't look too bad right? In fact, it's essentially the same as the Python
+version! All we need to do is just send back a string of some form. So, we
+look up the documentation for [`Request`](http://ironframework.io/doc/iron/request/struct.Request.html) and see a `url` field that will contain
+what we want. Let's try the first iteration:
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, "You found the URL: " + req.url)))
+}
+```
+
+Which yields the error:
+
+ error[E0369]: binary operation `+` cannot be applied to type `&'static str`
+
+OK, what's going on here? Time to start Googling for ["concatenate strings in Rust"](https://www.google.com/#q=concatenate+strings+in+rust). That's what we
+want to do right? Concatenate a static string and the URL.
+
+After Googling, we come across a helpful [`concat!`](https://doc.rust-lang.org/std/macro.concat!.html) macro that looks really nice! Let's try that one:
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, concat!("You found the URL: ", req.url))))
+}
+```
+
+And the error:
+
+`error: expected a literal`
+
+Turns out Rust actually blows up because the `concat!` macro expects us to know
+at compile time what `req.url` is. Which, in my outsider opinion, is a bit
+strange. `println!` and `format!`, etc., all handle values they don't know at
+compile time. Why can't `concat!`? By any means, we need a new plan of attack.
+How about we try formatting strings?
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, format!("You found the URL: {}", req.url))))
+}
+```
+
+And at long last, it works. Onwards!
+
+# Issue 2: Fighting with the borrow checker
+
+Rust's single coolest feature is how the compiler can guarantee safety in your
+program. As long as you don't use `unsafe` pointers in Rust, you're guaranteed
+safety. And not having truly manual memory management is really cool; I'm
+totally OK with never having to write `malloc()` again.
+
+That said, even [the Rust documentation](https://doc.rust-lang.org/book/ownership.html) makes a specific note:
+
+> Many new users to Rust experience something we like to call
+> ‘fighting with the borrow checker’, where the Rust compiler refuses to
+> compile a program that the author thinks is valid.
+
+If you have to put it in the documentation, it's not a helpful note:
+it's hazing.
+
+So now that we have a handler which works with information from the request, we
+want to start making something that looks like an actual web application.
+The router provided by `iron` isn't terribly difficult so I won't cover it.
+Instead, the thing that had me stumped for a couple hours was trying to
+dynamically create routes.
+
+The unfortunate thing with Rust (in my limited experience at the moment) is that
+there is a severe lack of non-trivial examples. Using the router is easy when
+you want to give an example of a static function. But how do you you start
+working on things that are a bit more complex?
+
+We're going to cover that here. Our first try: creating a function which returns
+other functions. This is a principle called [currying](http://stackoverflow.com/a/36321/1454178). We set up a function that allows us to keep some data in scope
+for another function to come later.
+
+```rust
+fn build_handler(message: String) -> Fn(&mut Request) -> IronResult {
+ move |_: &mut Request| {
+ Ok(Response::with((status::Ok, message)))
+ }
+}
+```
+
+We've simply set up a function that returns another anonymous function with the
+`message` parameter scoped in. If you compile this, you get not 1, not 2, but 5
+new errors. 4 of them are the same though:
+
+ error[E0277]: the trait bound `for<'r, 'r, 'r> std::ops::Fn(&'r mut iron::Request<'r, 'r>) -> std::result::Result + 'static: std::marker::Sized` is not satisfied
+
+...oookay. I for one, am not going to spend time trying to figure out what's
+going on there.
+
+And it is here that I will save the audience many hours of frustrated effort.
+At this point, I decided to switch from `iron` to pure `hyper` since using
+`hyper` would give me a much simpler API. All I would have to do is build a
+function that took two parameters as input, and we're done. That said, it
+ultimately posed many more issues because I started getting into a weird fight
+with the `'static` [lifetime](https://doc.rust-lang.org/book/lifetimes.html)
+and being a Rust newbie I just gave up on trying to understand it.
+
+Instead, we will abandon (mostly) the curried function attempt, and instead
+take advantage of something Rust actually intends us to use: `struct` and
+`trait`.
+
+Remember when I talked about a lack of non-trivial examples on the Internet?
+This is what I was talking about. I could only find *one* example of this
+available online, and it was incredibly complex and contained code we honestly
+don't need or care about. There was no documentation of how to build routes that
+didn't use static functions, etc. But, I'm assuming you don't really care about
+my whining, so let's get to it.
+
+The `iron` documentation mentions the [`Handler`](http://ironframework.io/doc/iron/middleware/trait.Handler.html) trait as being something we can implement.
+Does the function signature for that `handle()` method look familiar? It's what
+we've been working with so far.
+
+The principle is that we need to define a new `struct` to hold our data, then
+implement that `handle()` method to return the result. Something that looks
+like this might do:
+
+```rust
+struct EchoHandler {
+ message: String
+}
+
+impl Handler for EchoHandler {
+ fn handle(&self, _: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, self.message)))
+ }
+}
+
+// Later in the code when we set up the router...
+let echo = EchoHandler {
+ message: "Is it working yet?"
+}
+router.get("/", echo.handle, "index");
+```
+
+We attempt to build a struct, and give its `handle` method off to the router
+so the router knows what to do.
+
+You guessed it, more errors:
+
+ error: attempted to take value of method `handle` on type `EchoHandler`
+
+Now, the Rust compiler is actually a really nice fellow, and offers us help:
+
+ help: maybe a `()` to call it is missing? If not, try an anonymous function
+
+We definitely don't want to call that function, so maybe try an anonymous
+function as it recommends?
+
+```rust
+router.get("/", |req: &mut Request| echo.handle(req), "index");
+```
+
+Another error:
+
+ error[E0373]: closure may outlive the current function, but it borrows `echo`, which is owned by the current function
+
+Another helpful message:
+
+ help: to force the closure to take ownership of `echo` (and any other referenced variables), use the `move` keyword
+
+We're getting closer though! Let's implement this change:
+
+```rust
+router.get("/", move |req: &mut Request| echo.handle(req), "index");
+```
+
+And here's where things get strange:
+
+ error[E0507]: cannot move out of borrowed content
+ --> src/main.rs:18:40
+ |
+ 18 | Ok(Response::with((status::Ok, self.message)))
+ | ^^^^ cannot move out of borrowed content
+
+Now, this took me another couple hours to figure out. I'm going to explain it,
+but **keep this in mind: Rust only allows one reference at a time** (exceptions
+apply of course).
+
+When we attempt to use `self.message` as it has been created in the earlier
+`struct`, we essentially are trying to give it away to another piece of code.
+Rust's semantics then state that *we may no longer access it* unless it is
+returned to us (which `iron`'s code does not do). There are two ways to fix
+this:
+
+1. Only give away references (i.e. `&self.message` instead of `self.message`)
+instead of transferring ownership
+2. Make a copy of the underlying value which will be safe to give away
+
+I didn't know these were the two options originally, so I hope this helps the
+audience out. Because `iron` won't accept a reference, we are forced into the
+second option: making a copy. To do so, we just need to change the function
+to look like this:
+
+```rust
+Ok(Response::with((status::Ok, self.message.clone())))
+```
+
+Not so bad, huh? My only complaint is that it took so long to figure out exactly
+what was going on.
+
+And now we have a small server that we can configure dynamically. At long last.
+
+> Final sidenote: You can actually do this without anonymous functions. Just
+> change the router line to:
+> `router.get("/", echo, "index");`
+>
+> Rust's type system seems to figure out that we want to use the `handle()` method.
+
+# Conclusion
+
+After a good long days' work, we now have the routing functionality set up on
+our application. We should be able to scale this pretty well in the future:
+the RSS content we need to deliver in the future can be treated as a string, so
+the building blocks are in place.
+
+There are two important things I learned starting with Rust today:
+
+1. Rust is a new language, and while the code is high-quality, the mindshare is coming.
+2. I'm a terrible programmer.
+
+Number 1 is pretty obvious and not surprising to anyone. Number two caught me
+off guard. I've gotten used to having either a garbage collector (Java, Python,
+etc.) or playing a little fast and loose with scoping rules (C, C++). You don't
+have to worry about object lifetime there. With Rust, it's forcing me to fully
+understand and use well the memory in my applications. In the final mistake I
+fixed (using `.clone()`) I would have been fine in C++ to just give away that
+reference and never use it again. I wouldn't have run into a "use-after-free"
+error, but I would have potentially been leaking memory. Rust forced me to be
+incredibly precise about how I use it.
+
+All said I'm excited for using Rust more. I think it's super cool, it's just
+going to take me a lot longer to do this than I originally thought.
diff --git a/blog/2016-10-22-rustic-repodcasting/index.mdx b/blog/2016-10-22-rustic-repodcasting/index.mdx
new file mode 100644
index 0000000..71ebdf0
--- /dev/null
+++ b/blog/2016-10-22-rustic-repodcasting/index.mdx
@@ -0,0 +1,329 @@
+---
+slug: 2016/10/rustic-repodcasting
+title: A Rustic re-podcasting server
+date: 2016-10-22 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+Learning Rust by fire (it sounds better than learning by corrosion)
+
+
+
+I listen to a lot of Drum and Bass music, because it's beautiful music. And
+there's a particular site, [Bassdrive.com](http://bassdrive.com/) that hosts
+a lot of great content. Specifically, the
+[archives](http://archives.bassdrivearchive.com/) section of the site has a
+list of the past shows that you can download and listen to. The issue is, it's
+just a [giant list of links to download](http://archives.bassdrivearchive.com/6%20-%20Saturday/Electronic%20Warfare%20-%20The%20Overfiend/). I'd really like
+this in a podcast format to take with me on the road, etc.
+
+So I wrote the [elektricity](https://github.com/bspeice/elektricity) web
+application to actually accomplish all that. Whenever you request a feed, it
+goes out to Bassdrive, processes all the links on a page, and serves up some
+fresh, tasty RSS to satisfy your ears. I hosted it on Heroku using the free
+tier because it's really not resource-intensive at all.
+
+**The issue so far** is that I keep running out of free tier hours during a
+month because my podcasting application likes to have a server scan for new
+episodes constantly. Not sure why it's doing that, but I don't have a whole
+lot of control over it. It's a phenomenal application otherwise.
+
+**My (over-engineered) solution**: Re-write the application using the
+[Rust](https://www.rust-lang.org/en-US/) programming language. I'd like to run
+this on a small hacker board I own, and doing this in Rust would allow me to
+easily cross-compile it. Plus, I've been very interested in the Rust language
+for a while and this would be a great opportunity to really learn it well.
+The code is available [here](https://github.com/bspeice/nutone) as development
+progresses.
+
+## The Setup
+
+We'll be using the [iron](http://ironframework.io/) library to handle the
+server, and [hyper](http://hyper.rs/) to fetch the data we need from elsewhere
+on the interwebs. [HTML5Ever](http://doc.servo.org/html5ever/index.html) allows
+us to ingest the content that will be coming from Bassdrive, and finally,
+output is done with [handlebars-rust](http://sunng87.github.io/handlebars-rust/handlebars/index.html).
+
+It will ultimately be interesting to see how much more work must be done to
+actually get this working over another language like Python. Coming from a
+dynamic state of mind it's super easy to just chain stuff together, ship it out,
+and call it a day. I think I'm going to end up getting much dirtier trying to
+write all of this out.
+
+## Issue 1: Strings
+
+Strings in Rust are hard. I acknowledge Python can get away with some things
+that make strings super easy (and Python 3 has gotten better at cracking down
+on some bad cases, `str <-> bytes` specifically), but Rust is hard.
+
+Let's take for example the `404` error handler I'm trying to write. The result
+should be incredibly simple: All I want is to echo back
+`Didn't find URL: `. Shouldn't be that hard right? In Python I'd just do
+something like:
+
+```python
+def echo_handler(request):
+ return "You're visiting: {}".format(request.uri)
+```
+
+And we'd call it a day. Rust isn't so simple. Let's start with the trivial
+examples people post online:
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, "You found the server!")))
+}
+```
+
+Doesn't look too bad right? In fact, it's essentially the same as the Python
+version! All we need to do is just send back a string of some form. So, we
+look up the documentation for [`Request`](http://ironframework.io/doc/iron/request/struct.Request.html) and see a `url` field that will contain
+what we want. Let's try the first iteration:
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, "You found the URL: " + req.url)))
+}
+```
+
+Which yields the error:
+
+```
+ error[E0369]: binary operation `+` cannot be applied to type `&'static str`
+```
+
+OK, what's going on here? Time to start Googling for ["concatenate strings in Rust"](https://www.google.com/#q=concatenate+strings+in+rust). That's what we
+want to do right? Concatenate a static string and the URL.
+
+After Googling, we come across a helpful [`concat!`](https://doc.rust-lang.org/std/macro.concat!.html) macro that looks really nice! Let's try that one:
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, concat!("You found the URL: ", req.url))))
+}
+```
+
+And the error:
+
+```
+ error: expected a literal
+```
+
+Turns out Rust actually blows up because the `concat!` macro expects us to know
+at compile time what `req.url` is. Which, in my outsider opinion, is a bit
+strange. `println!` and `format!`, etc., all handle values they don't know at
+compile time. Why can't `concat!`? By any means, we need a new plan of attack.
+How about we try formatting strings?
+
+```rust
+fn hello_world(req: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, format!("You found the URL: {}", req.url))))
+}
+```
+
+And at long last, it works. Onwards!
+
+## Issue 2: Fighting with the borrow checker
+
+Rust's single coolest feature is how the compiler can guarantee safety in your
+program. As long as you don't use `unsafe` pointers in Rust, you're guaranteed
+safety. And not having truly manual memory management is really cool; I'm
+totally OK with never having to write `malloc()` again.
+
+That said, even [the Rust documentation](https://doc.rust-lang.org/book/ownership.html) makes a specific note:
+
+> Many new users to Rust experience something we like to call
+> ‘fighting with the borrow checker’, where the Rust compiler refuses to
+> compile a program that the author thinks is valid.
+
+If you have to put it in the documentation, it's not a helpful note:
+it's hazing.
+
+So now that we have a handler which works with information from the request, we
+want to start making something that looks like an actual web application.
+The router provided by `iron` isn't terribly difficult so I won't cover it.
+Instead, the thing that had me stumped for a couple hours was trying to
+dynamically create routes.
+
+The unfortunate thing with Rust (in my limited experience at the moment) is that
+there is a severe lack of non-trivial examples. Using the router is easy when
+you want to give an example of a static function. But how do you you start
+working on things that are a bit more complex?
+
+We're going to cover that here. Our first try: creating a function which returns
+other functions. This is a principle called [currying](http://stackoverflow.com/a/36321/1454178). We set up a function that allows us to keep some data in scope
+for another function to come later.
+
+```rust
+fn build_handler(message: String) -> Fn(&mut Request) -> IronResult {
+ move |_: &mut Request| {
+ Ok(Response::with((status::Ok, message)))
+ }
+}
+```
+
+We've simply set up a function that returns another anonymous function with the
+`message` parameter scoped in. If you compile this, you get not 1, not 2, but 5
+new errors. 4 of them are the same though:
+
+```
+ error[E0277]: the trait bound `for<'r, 'r, 'r> std::ops::Fn(&'r mut iron::Request<'r, 'r>) -> std::result::Result + 'static: std::marker::Sized` is not satisfied
+```
+
+...oookay. I for one, am not going to spend time trying to figure out what's
+going on there.
+
+And it is here that I will save the audience many hours of frustrated effort.
+At this point, I decided to switch from `iron` to pure `hyper` since using
+`hyper` would give me a much simpler API. All I would have to do is build a
+function that took two parameters as input, and we're done. That said, it
+ultimately posed many more issues because I started getting into a weird fight
+with the `'static` [lifetime](https://doc.rust-lang.org/book/lifetimes.html)
+and being a Rust newbie I just gave up on trying to understand it.
+
+Instead, we will abandon (mostly) the curried function attempt, and instead
+take advantage of something Rust actually intends us to use: `struct` and
+`trait`.
+
+Remember when I talked about a lack of non-trivial examples on the Internet?
+This is what I was talking about. I could only find *one* example of this
+available online, and it was incredibly complex and contained code we honestly
+don't need or care about. There was no documentation of how to build routes that
+didn't use static functions, etc. But, I'm assuming you don't really care about
+my whining, so let's get to it.
+
+The `iron` documentation mentions the [`Handler`](http://ironframework.io/doc/iron/middleware/trait.Handler.html) trait as being something we can implement.
+Does the function signature for that `handle()` method look familiar? It's what
+we've been working with so far.
+
+The principle is that we need to define a new `struct` to hold our data, then
+implement that `handle()` method to return the result. Something that looks
+like this might do:
+
+```rust
+struct EchoHandler {
+ message: String
+}
+
+impl Handler for EchoHandler {
+ fn handle(&self, _: &mut Request) -> IronResult {
+ Ok(Response::with((status::Ok, self.message)))
+ }
+}
+
+// Later in the code when we set up the router...
+let echo = EchoHandler {
+ message: "Is it working yet?"
+}
+router.get("/", echo.handle, "index");
+```
+
+We attempt to build a struct, and give its `handle` method off to the router
+so the router knows what to do.
+
+You guessed it, more errors:
+
+```
+ error: attempted to take value of method `handle` on type `EchoHandler`
+```
+
+Now, the Rust compiler is actually a really nice fellow, and offers us help:
+
+```
+ help: maybe a `()` to call it is missing? If not, try an anonymous function
+```
+
+We definitely don't want to call that function, so maybe try an anonymous
+function as it recommends?
+
+```rust
+router.get("/", |req: &mut Request| echo.handle(req), "index");
+```
+
+Another error:
+
+```
+ error[E0373]: closure may outlive the current function, but it borrows `echo`, which is owned by the current function
+```
+
+Another helpful message:
+
+```
+ help: to force the closure to take ownership of `echo` (and any other referenced variables), use the `move` keyword
+```
+
+We're getting closer though! Let's implement this change:
+
+```rust
+router.get("/", move |req: &mut Request| echo.handle(req), "index");
+```
+
+And here's where things get strange:
+
+```
+ error[E0507]: cannot move out of borrowed content
+ --> src/main.rs:18:40
+ |
+ 18 | Ok(Response::with((status::Ok, self.message)))
+ | ^^^^ cannot move out of borrowed content
+```
+
+Now, this took me another couple hours to figure out. I'm going to explain it,
+but **keep this in mind: Rust only allows one reference at a time** (exceptions
+apply of course).
+
+When we attempt to use `self.message` as it has been created in the earlier
+`struct`, we essentially are trying to give it away to another piece of code.
+Rust's semantics then state that *we may no longer access it* unless it is
+returned to us (which `iron`'s code does not do). There are two ways to fix
+this:
+
+1. Only give away references (i.e. `&self.message` instead of `self.message`)
+instead of transferring ownership
+2. Make a copy of the underlying value which will be safe to give away
+
+I didn't know these were the two options originally, so I hope this helps the
+audience out. Because `iron` won't accept a reference, we are forced into the
+second option: making a copy. To do so, we just need to change the function
+to look like this:
+
+```rust
+Ok(Response::with((status::Ok, self.message.clone())))
+```
+
+Not so bad, huh? My only complaint is that it took so long to figure out exactly
+what was going on.
+
+And now we have a small server that we can configure dynamically. At long last.
+
+> Final sidenote: You can actually do this without anonymous functions. Just
+> change the router line to:
+> `router.get("/", echo, "index");`
+>
+> Rust's type system seems to figure out that we want to use the `handle()` method.
+
+## Conclusion
+
+After a good long days' work, we now have the routing functionality set up on
+our application. We should be able to scale this pretty well in the future:
+the RSS content we need to deliver in the future can be treated as a string, so
+the building blocks are in place.
+
+There are two important things I learned starting with Rust today:
+
+1. Rust is a new language, and while the code is high-quality, the mindshare is coming.
+2. I'm a terrible programmer.
+
+Number 1 is pretty obvious and not surprising to anyone. Number two caught me
+off guard. I've gotten used to having either a garbage collector (Java, Python,
+etc.) or playing a little fast and loose with scoping rules (C, C++). You don't
+have to worry about object lifetime there. With Rust, it's forcing me to fully
+understand and use well the memory in my applications. In the final mistake I
+fixed (using `.clone()`) I would have been fine in C++ to just give away that
+reference and never use it again. I wouldn't have run into a "use-after-free"
+error, but I would have potentially been leaking memory. Rust forced me to be
+incredibly precise about how I use it.
+
+All said I'm excited for using Rust more. I think it's super cool, it's just
+going to take me a lot longer to do this than I originally thought.
\ No newline at end of file
diff --git a/blog/2016-11-01-PCA-audio-compression/1.wav b/blog/2016-11-01-PCA-audio-compression/1.wav
new file mode 100644
index 0000000..e85ba39
Binary files /dev/null and b/blog/2016-11-01-PCA-audio-compression/1.wav differ
diff --git a/blog/2016-11-01-PCA-audio-compression/2.wav b/blog/2016-11-01-PCA-audio-compression/2.wav
new file mode 100644
index 0000000..e85ba39
Binary files /dev/null and b/blog/2016-11-01-PCA-audio-compression/2.wav differ
diff --git a/blog/2016-11-01-PCA-audio-compression/3.wav b/blog/2016-11-01-PCA-audio-compression/3.wav
new file mode 100644
index 0000000..52ac8c8
Binary files /dev/null and b/blog/2016-11-01-PCA-audio-compression/3.wav differ
diff --git a/blog/2016-11-01-PCA-audio-compression/4.wav b/blog/2016-11-01-PCA-audio-compression/4.wav
new file mode 100644
index 0000000..0aa398c
Binary files /dev/null and b/blog/2016-11-01-PCA-audio-compression/4.wav differ
diff --git a/blog/2016-11-01-PCA-audio-compression/5.wav b/blog/2016-11-01-PCA-audio-compression/5.wav
new file mode 100644
index 0000000..d708c5d
Binary files /dev/null and b/blog/2016-11-01-PCA-audio-compression/5.wav differ
diff --git a/blog/2016-11-01-PCA-audio-compression/6.wav b/blog/2016-11-01-PCA-audio-compression/6.wav
new file mode 100644
index 0000000..28967e4
Binary files /dev/null and b/blog/2016-11-01-PCA-audio-compression/6.wav differ
diff --git a/blog/2016-11-01-PCA-audio-compression/_article.md b/blog/2016-11-01-PCA-audio-compression/_article.md
new file mode 100644
index 0000000..df95b1c
--- /dev/null
+++ b/blog/2016-11-01-PCA-audio-compression/_article.md
@@ -0,0 +1,9 @@
+Title: Audio Compression using PCA
+Date: 2016-11-01
+Category: Blog
+Tags: PCA, Machine Learning, Digital Signal Processing
+Authors: Bradlee Speice
+Summary: In which I apply Machine Learning techniques to Digital Signal Processing to astounding failure.
+[//]: <> "Modified: "
+
+{% notebook 2016-11-01-PCA-audio-compression.ipynb %}
diff --git a/blog/2016-11-01-PCA-audio-compression/_notebook.ipynb b/blog/2016-11-01-PCA-audio-compression/_notebook.ipynb
new file mode 100644
index 0000000..3d8e6a1
--- /dev/null
+++ b/blog/2016-11-01-PCA-audio-compression/_notebook.ipynb
@@ -0,0 +1,599 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Towards a new (and pretty poor) compression scheme\n",
+ "--------------------------------------------------\n",
+ "\n",
+ "I'm going to be working with some audio data for a while as I get prepared for a term project this semester. I'll be working (with a partner) to design a system for separating voices from music. Given my total lack of experience with [Digital Signal Processing][1] I figured that now was as good a time as ever to work on a couple of fun projects that would get me back up to speed.\n",
+ "\n",
+ "The first project I want to work on: Designing a new compression scheme for audio data.\n",
+ "\n",
+ "A Brief Introduction to Audio Compression\n",
+ "-----------------------------------------\n",
+ "\n",
+ "Audio files when uncompressed (files ending with `.wav`) are huge. Like, 10.5 Megabytes per minute huge. Storage is cheap these days, but that's still an incredible amount of data that we don't really need. Instead, we'd like to compress that data so that it's not taking up so much space. There are broadly two ways to accomplish this:\n",
+ "\n",
+ "1. Lossless compression - Formats like [FLAC][2], [ALAC][3], and [Monkey's Audio (.ape)][4] all go down this route. The idea is that when you compress and uncompress a file, you get exactly the same as what you started with.\n",
+ "\n",
+ "2. Lossy compression - Formats like [MP3][5], [Ogg][6], and [AAC (`.m4a`)][7] are far more popular, but make a crucial tradeoff: We can reduce the file size even more during compression, but the decompressed file won't be the same.\n",
+ "\n",
+ "There is a fundamental tradeoff at stake: Using lossy compression sacrifices some of the integrity of the resulting file to save on storage space. Most people (I personally believe it's everybody) can't hear the difference, so this is an acceptable tradeoff. You have files that take up a 10th of the space, and nobody can tell there's a difference in audio quality.\n",
+ "\n",
+ "A PCA-based Compression Scheme\n",
+ "------------------------------\n",
+ "\n",
+ "What I want to try out is a [PCA][8] approach to encoding audio. The PCA technique comes from Machine Learning, where it is used for a process called [Dimensionality Reduction][9]. Put simply, the idea is the same as lossy compression: if we can find a way that represents the data well enough, we can save on space. There are a lot of theoretical concerns that lead me to believe this compression style will not end well, but I'm interested to try it nonetheless.\n",
+ "\n",
+ "PCA works as follows: Given a dataset with a number of features, I find a way to approximate those original features using some \"new features\" that are statistically as close as possible to the original ones. This is comparable to a scheme like MP3: Given an original signal, I want to find a way of representing it that gets approximately close to what the original was. The difference is that PCA is designed for statistical data, and not signal data. But we won't let that stop us.\n",
+ "\n",
+ "The idea is as follows: Given a signal, reshape it into 1024 columns by however many rows are needed (zero-padded if necessary). Run the PCA algorithm, and do dimensionality reduction with a couple different settings. The number of components I choose determines the quality: If I use 1024 components, I will essentially be using the original signal. If I use a smaller number of components, I start losing some of the data that was in the original file. This will give me an idea of whether it's possible to actually build an encoding scheme off of this, or whether I'm wasting my time.\n",
+ "\n",
+ "Running the Algorithm\n",
+ "---------------------\n",
+ "\n",
+ "The audio I will be using comes from the song [Tabulasa][10], by [Broke for Free][11]. I'll be loading in the audio signal to Python and using [Scikit-Learn][12] to actually run the PCA algorithm.\n",
+ "\n",
+ "We first need to convert the FLAC file I have to a WAV:\n",
+ "\n",
+ "[1]: https://en.wikipedia.org/wiki/Digital_signal_processing\n",
+ "[2]: https://en.wikipedia.org/wiki/FLAC\n",
+ "[3]: https://en.wikipedia.org/wiki/Apple_Lossless\n",
+ "[4]: https://en.wikipedia.org/wiki/Monkey%27s_Audio\n",
+ "[5]: https://en.wikipedia.org/wiki/MP3\n",
+ "[6]: https://en.wikipedia.org/wiki/Vorbis\n",
+ "[7]: https://en.wikipedia.org/wiki/Advanced_Audio_Coding\n",
+ "[8]: https://en.wikipedia.org/wiki/Principal_component_analysis\n",
+ "[9]: https://en.wikipedia.org/wiki/Dimensionality_reduction\n",
+ "[10]: https://brokeforfree.bandcamp.com/track/tabulasa\n",
+ "[11]: https://brokeforfree.bandcamp.com/album/xxvii\n",
+ "[12]: http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html#sklearn.decomposition.PCA"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "!ffmpeg -hide_banner -loglevel panic -i \"Broke For Free/XXVII/01 Tabulasa.flac\" \"Tabulasa.wav\" -c wav"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Then, let's go ahead and load a small sample so you can hear what is going on."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from IPython.display import Audio\n",
+ "from scipy.io import wavfile\n",
+ "\n",
+ "samplerate, tabulasa = wavfile.read('Tabulasa.wav')\n",
+ "\n",
+ "start = samplerate * 14 # 10 seconds in\n",
+ "end = start + samplerate * 10 # 5 second duration\n",
+ "Audio(data=tabulasa[start:end, 0], rate=samplerate)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Next, we'll define the code we will be using to do PCA. It's very short, as the PCA algorithm is very simple."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [],
+ "source": [
+ "from sklearn.decomposition import PCA\n",
+ "import numpy as np\n",
+ "\n",
+ "def pca_reduce(signal, n_components, block_size=1024):\n",
+ " \n",
+ " # First, zero-pad the signal so that it is divisible by the block_size\n",
+ " samples = len(signal)\n",
+ " hanging = block_size - np.mod(samples, block_size)\n",
+ " padded = np.lib.pad(signal, (0, hanging), 'constant', constant_values=0)\n",
+ " \n",
+ " # Reshape the signal to have 1024 dimensions\n",
+ " reshaped = padded.reshape((len(padded) // block_size, block_size))\n",
+ " \n",
+ " # Second, do the actual PCA process\n",
+ " pca = PCA(n_components=n_components)\n",
+ " pca.fit(reshaped)\n",
+ " \n",
+ " transformed = pca.transform(reshaped)\n",
+ " reconstructed = pca.inverse_transform(transformed).reshape((len(padded)))\n",
+ " return pca, transformed, reconstructed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that we've got our functions set up, let's try actually running something. First, we'll use `n_components == block_size`, which implies that we should end up with the same signal we started with."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tabulasa_left = tabulasa[:,0]\n",
+ "\n",
+ "_, _, reconstructed = pca_reduce(tabulasa_left, 1024, 1024)\n",
+ "\n",
+ "Audio(data=reconstructed[start:end], rate=samplerate)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "OK, that does indeed sound like what we originally had. Let's drastically cut down the number of components we're doing this with as a sanity check: the audio quality should become incredibly poor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "_, _, reconstructed = pca_reduce(tabulasa_left, 32, 1024)\n",
+ "\n",
+ "Audio(data=reconstructed[start:end], rate=samplerate)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "As expected, our reconstructed audio does sound incredibly poor! But there's something else very interesting going on here under the hood. Did you notice that the bassline comes across very well, but that there's no midrange or treble? The drums are almost entirely gone.\n",
+ "\n",
+ "[Drop the (Treble)][13]\n",
+ "-----------------------\n",
+ "\n",
+ "It will help to understand PCA more fully when trying to read this part, but I'll do my best to break it down. PCA tries to find a way to best represent the dataset using \"components.\" Think of each \"component\" as containing some of the information you need in order to reconstruct the full audio. For example, you might have a \"low frequency\" component that contains all the information you need in order to hear the bassline. There might be other components that explain the high frequency things like singers, or melodies, that you also need.\n",
+ "\n",
+ "What makes PCA interesting is that it attempts to find the \"most important\" components in explaining the signal. In a signal processing world, this means that PCA is trying to find the signal amongst the noise in your data. In our case, this means that PCA, when forced to work with small numbers of components, will chuck out the noisy components first. It's doing it's best job to reconstruct the signal, but it has to make sacrifices somewhere.\n",
+ "\n",
+ "So I've mentioned that PCA identifies the \"noisy\" components in our dataset. This is equivalent to saying that PCA removes the \"high frequency\" components in this case: it's very easy to represent a low-frequency signal like a bassline. It's far more difficult to represent a high-frequency signal because it's changing all the time. When you force PCA to make a tradeoff by using a small number of components, the best it can hope to do is replicate the low-frequency sections and skip the high-frequency things.\n",
+ "\n",
+ "This is a very interesting insight, and it also has echos (pardon the pun) of how humans understand music in general. Other encoding schemes (like MP3, etc.) typically chop off a lot of the high-frequency range as well. There is typically a lot of high-frequency noise in audio that is nearly impossible to hear, so it's easy to remove it without anyone noticing. PCA ends up doing something similar, and while that certainly wasn't the intention, it is an interesting effect.\n",
+ "\n",
+ "## A More Realistic Example\n",
+ "\n",
+ "So we've seen the edge cases so far: Using a large number of components results in audio very close to the original, and using a small number of components acts as a low-pass filter. How about we develop something that sounds \"good enough\" in practice, that we can use as a benchmark for size? We'll use ourselves as judges of audio quality, and build another function to help us estimate how much space we need to store everything in.\n",
+ "\n",
+ "[13]: https://youtu.be/Ua0KpfJsxKo?t=1m17s"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "
Raw
\n",
+ "
PCA
\n",
+ "
PCA w/ BZ2
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
(1, 1)
\n",
+ "
69.054298
\n",
+ "
138.108597
\n",
+ "
16.431797
\n",
+ "
\n",
+ "
\n",
+ "
(1, 2)
\n",
+ "
69.054306
\n",
+ "
69.054306
\n",
+ "
32.981380
\n",
+ "
\n",
+ "
\n",
+ "
(1, 4)
\n",
+ "
69.054321
\n",
+ "
34.527161
\n",
+ "
16.715032
\n",
+ "
\n",
+ "
\n",
+ "
(4, 32)
\n",
+ "
69.054443
\n",
+ "
17.263611
\n",
+ "
8.481735
\n",
+ "
\n",
+ "
\n",
+ "
(16, 256)
\n",
+ "
69.054688
\n",
+ "
8.631836
\n",
+ "
4.274846
\n",
+ "
\n",
+ "
\n",
+ "
(32, 256)
\n",
+ "
69.054688
\n",
+ "
17.263672
\n",
+ "
8.542909
\n",
+ "
\n",
+ "
\n",
+ "
(64, 256)
\n",
+ "
69.054688
\n",
+ "
34.527344
\n",
+ "
17.097543
\n",
+ "
\n",
+ "
\n",
+ "
(128, 1024)
\n",
+ "
69.054688
\n",
+ "
17.263672
\n",
+ "
9.430644
\n",
+ "
\n",
+ "
\n",
+ "
(256, 1024)
\n",
+ "
69.054688
\n",
+ "
34.527344
\n",
+ "
18.870387
\n",
+ "
\n",
+ "
\n",
+ "
(512, 1024)
\n",
+ "
69.054688
\n",
+ "
69.054688
\n",
+ "
37.800940
\n",
+ "
\n",
+ "
\n",
+ "
(128, 2048)
\n",
+ "
69.062500
\n",
+ "
8.632812
\n",
+ "
6.185015
\n",
+ "
\n",
+ "
\n",
+ "
(256, 2048)
\n",
+ "
69.062500
\n",
+ "
17.265625
\n",
+ "
12.366942
\n",
+ "
\n",
+ "
\n",
+ "
(512, 2048)
\n",
+ "
69.062500
\n",
+ "
34.531250
\n",
+ "
24.736506
\n",
+ "
\n",
+ "
\n",
+ "
(1024, 2048)
\n",
+ "
69.062500
\n",
+ "
69.062500
\n",
+ "
49.517493
\n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Raw PCA PCA w/ BZ2\n",
+ "(1, 1) 69.054298 138.108597 16.431797\n",
+ "(1, 2) 69.054306 69.054306 32.981380\n",
+ "(1, 4) 69.054321 34.527161 16.715032\n",
+ "(4, 32) 69.054443 17.263611 8.481735\n",
+ "(16, 256) 69.054688 8.631836 4.274846\n",
+ "(32, 256) 69.054688 17.263672 8.542909\n",
+ "(64, 256) 69.054688 34.527344 17.097543\n",
+ "(128, 1024) 69.054688 17.263672 9.430644\n",
+ "(256, 1024) 69.054688 34.527344 18.870387\n",
+ "(512, 1024) 69.054688 69.054688 37.800940\n",
+ "(128, 2048) 69.062500 8.632812 6.185015\n",
+ "(256, 2048) 69.062500 17.265625 12.366942\n",
+ "(512, 2048) 69.062500 34.531250 24.736506\n",
+ "(1024, 2048) 69.062500 69.062500 49.517493"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from bz2 import compress\n",
+ "import pandas as pd\n",
+ "\n",
+ "def raw_estimate(transformed, pca):\n",
+ " # We assume that we'll be storing things as 16-bit WAV,\n",
+ " # meaning two bytes per sample\n",
+ " signal_bytes = transformed.tobytes()\n",
+ " # PCA stores the components as floating point, we'll assume\n",
+ " # that means 32-bit floats, so 4 bytes per element\n",
+ " component_bytes = transformed.tobytes()\n",
+ " \n",
+ " # Return a result in megabytes\n",
+ " return (len(signal_bytes) + len(component_bytes)) / (2**20)\n",
+ "\n",
+ "# Do an estimate for lossless compression applied on top of our\n",
+ "# PCA reduction\n",
+ "def bz2_estimate(transformed, pca):\n",
+ " bytestring = transformed.tobytes() + b';' + pca.components_.tobytes()\n",
+ " compressed = compress(bytestring)\n",
+ " return len(compressed) / (2**20)\n",
+ "\n",
+ "compression_attempts = [\n",
+ " (1, 1),\n",
+ " (1, 2),\n",
+ " (1, 4),\n",
+ " (4, 32),\n",
+ " (16, 256),\n",
+ " (32, 256),\n",
+ " (64, 256),\n",
+ " (128, 1024),\n",
+ " (256, 1024),\n",
+ " (512, 1024),\n",
+ " (128, 2048),\n",
+ " (256, 2048),\n",
+ " (512, 2048),\n",
+ " (1024, 2048)\n",
+ "]\n",
+ "\n",
+ "def build_estimates(signal, n_components, block_size):\n",
+ " pca, transformed, recon = pca_reduce(tabulasa_left, n_components, block_size)\n",
+ " raw_pca_estimate = raw_estimate(transformed, pca)\n",
+ " bz2_pca_estimate = bz2_estimate(transformed, pca)\n",
+ " raw_size = len(recon.tobytes()) / (2**20)\n",
+ " return raw_size, raw_pca_estimate, bz2_pca_estimate\n",
+ "\n",
+ "pca_compression_results = pd.DataFrame([\n",
+ " build_estimates(tabulasa_left, n, bs)\n",
+ " for n, bs in compression_attempts\n",
+ " ])\n",
+ "\n",
+ "pca_compression_results.columns = [\"Raw\", \"PCA\", \"PCA w/ BZ2\"]\n",
+ "pca_compression_results.index = compression_attempts\n",
+ "pca_compression_results"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "As we can see, there are a couple of instances where we do nearly 20 times better on storage space than the uncompressed file. Let's here what that sounds like:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "_, _, reconstructed = pca_reduce(tabulasa_left, 16, 256)\n",
+ "Audio(data=reconstructed[start:end], rate=samplerate)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "It sounds incredibly poor though. Let's try something that's a bit more realistic:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "_, _, reconstructed = pca_reduce(tabulasa_left, 1, 4)\n",
+ "Audio(data=reconstructed[start:end], rate=samplerate)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And just out of curiosity, we can try something that has the same ratio of components to block size. This should be close to an apples-to-apples comparison."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "collapsed": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "_, _, reconstructed = pca_reduce(tabulasa_left, 64, 256)\n",
+ "Audio(data=reconstructed[start:end], rate=samplerate)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The smaller block size definitely has better high-end response, but I personally think the larger block size sounds better overall."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Conclusions\n",
+ "\n",
+ "So, what do I think about audio compression using PCA?\n",
+ "\n",
+ "Strangely enough, it actually works pretty well relative to what I expected. That said, it's a terrible idea in general.\n",
+ "\n",
+ "First off, you don't really save any space. The component matrix needed to actually run the PCA algorithm takes up a lot of space on its own, so it's very difficult to save space without sacrificing a huge amount of audio quality. And even then, codecs like AAC sound very nice even at bitrates that this PCA method could only dream of.\n",
+ "\n",
+ "Second, there's the issue of audio streaming. PCA relies on two components: the datastream, and a matrix used to reconstruct the original signal. While it is easy to stream the data, you can't stream that matrix. And even if you divided the stream up into small blocks to give you a small matrix, you must guarantee that the matrix arrives; if you don't have that matrix, the data stream will make no sense whatsoever.\n",
+ "\n",
+ "All said, this was an interesting experiment. It's really cool seeing PCA used for signal analysis where I haven't seen it applied before, but I don't think it will lead to any practical results. Look forward to more signal processing stuff in the future!"
+ ]
+ }
+ ],
+ "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.2"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/blog/2016-11-01-PCA-audio-compression/_notebook.md b/blog/2016-11-01-PCA-audio-compression/_notebook.md
new file mode 100644
index 0000000..4e1ec14
--- /dev/null
+++ b/blog/2016-11-01-PCA-audio-compression/_notebook.md
@@ -0,0 +1,401 @@
+Towards a new (and pretty poor) compression scheme
+--------------------------------------------------
+
+I'm going to be working with some audio data for a while as I get prepared for a term project this semester. I'll be working (with a partner) to design a system for separating voices from music. Given my total lack of experience with [Digital Signal Processing][1] I figured that now was as good a time as ever to work on a couple of fun projects that would get me back up to speed.
+
+The first project I want to work on: Designing a new compression scheme for audio data.
+
+A Brief Introduction to Audio Compression
+-----------------------------------------
+
+Audio files when uncompressed (files ending with `.wav`) are huge. Like, 10.5 Megabytes per minute huge. Storage is cheap these days, but that's still an incredible amount of data that we don't really need. Instead, we'd like to compress that data so that it's not taking up so much space. There are broadly two ways to accomplish this:
+
+1. Lossless compression - Formats like [FLAC][2], [ALAC][3], and [Monkey's Audio (.ape)][4] all go down this route. The idea is that when you compress and uncompress a file, you get exactly the same as what you started with.
+
+2. Lossy compression - Formats like [MP3][5], [Ogg][6], and [AAC (`.m4a`)][7] are far more popular, but make a crucial tradeoff: We can reduce the file size even more during compression, but the decompressed file won't be the same.
+
+There is a fundamental tradeoff at stake: Using lossy compression sacrifices some of the integrity of the resulting file to save on storage space. Most people (I personally believe it's everybody) can't hear the difference, so this is an acceptable tradeoff. You have files that take up a 10th of the space, and nobody can tell there's a difference in audio quality.
+
+A PCA-based Compression Scheme
+------------------------------
+
+What I want to try out is a [PCA][8] approach to encoding audio. The PCA technique comes from Machine Learning, where it is used for a process called [Dimensionality Reduction][9]. Put simply, the idea is the same as lossy compression: if we can find a way that represents the data well enough, we can save on space. There are a lot of theoretical concerns that lead me to believe this compression style will not end well, but I'm interested to try it nonetheless.
+
+PCA works as follows: Given a dataset with a number of features, I find a way to approximate those original features using some "new features" that are statistically as close as possible to the original ones. This is comparable to a scheme like MP3: Given an original signal, I want to find a way of representing it that gets approximately close to what the original was. The difference is that PCA is designed for statistical data, and not signal data. But we won't let that stop us.
+
+The idea is as follows: Given a signal, reshape it into 1024 columns by however many rows are needed (zero-padded if necessary). Run the PCA algorithm, and do dimensionality reduction with a couple different settings. The number of components I choose determines the quality: If I use 1024 components, I will essentially be using the original signal. If I use a smaller number of components, I start losing some of the data that was in the original file. This will give me an idea of whether it's possible to actually build an encoding scheme off of this, or whether I'm wasting my time.
+
+Running the Algorithm
+---------------------
+
+The audio I will be using comes from the song [Tabulasa][10], by [Broke for Free][11]. I'll be loading in the audio signal to Python and using [Scikit-Learn][12] to actually run the PCA algorithm.
+
+We first need to convert the FLAC file I have to a WAV:
+
+[1]: https://en.wikipedia.org/wiki/Digital_signal_processing
+[2]: https://en.wikipedia.org/wiki/FLAC
+[3]: https://en.wikipedia.org/wiki/Apple_Lossless
+[4]: https://en.wikipedia.org/wiki/Monkey%27s_Audio
+[5]: https://en.wikipedia.org/wiki/MP3
+[6]: https://en.wikipedia.org/wiki/Vorbis
+[7]: https://en.wikipedia.org/wiki/Advanced_Audio_Coding
+[8]: https://en.wikipedia.org/wiki/Principal_component_analysis
+[9]: https://en.wikipedia.org/wiki/Dimensionality_reduction
+[10]: https://brokeforfree.bandcamp.com/track/tabulasa
+[11]: https://brokeforfree.bandcamp.com/album/xxvii
+[12]: http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html#sklearn.decomposition.PCA
+
+
+```python
+!ffmpeg -hide_banner -loglevel panic -i "Broke For Free/XXVII/01 Tabulasa.flac" "Tabulasa.wav" -c wav
+```
+
+Then, let's go ahead and load a small sample so you can hear what is going on.
+
+
+```python
+from IPython.display import Audio
+from scipy.io import wavfile
+
+samplerate, tabulasa = wavfile.read('Tabulasa.wav')
+
+start = samplerate * 14 # 10 seconds in
+end = start + samplerate * 10 # 5 second duration
+Audio(data=tabulasa[start:end, 0], rate=samplerate)
+```
+
+
+
+
+
+
+
+
+
+
+Next, we'll define the code we will be using to do PCA. It's very short, as the PCA algorithm is very simple.
+
+
+```python
+from sklearn.decomposition import PCA
+import numpy as np
+
+def pca_reduce(signal, n_components, block_size=1024):
+
+ # First, zero-pad the signal so that it is divisible by the block_size
+ samples = len(signal)
+ hanging = block_size - np.mod(samples, block_size)
+ padded = np.lib.pad(signal, (0, hanging), 'constant', constant_values=0)
+
+ # Reshape the signal to have 1024 dimensions
+ reshaped = padded.reshape((len(padded) // block_size, block_size))
+
+ # Second, do the actual PCA process
+ pca = PCA(n_components=n_components)
+ pca.fit(reshaped)
+
+ transformed = pca.transform(reshaped)
+ reconstructed = pca.inverse_transform(transformed).reshape((len(padded)))
+ return pca, transformed, reconstructed
+```
+
+Now that we've got our functions set up, let's try actually running something. First, we'll use `n_components == block_size`, which implies that we should end up with the same signal we started with.
+
+
+```python
+tabulasa_left = tabulasa[:,0]
+
+_, _, reconstructed = pca_reduce(tabulasa_left, 1024, 1024)
+
+Audio(data=reconstructed[start:end], rate=samplerate)
+```
+
+
+
+
+
+
+
+
+
+
+OK, that does indeed sound like what we originally had. Let's drastically cut down the number of components we're doing this with as a sanity check: the audio quality should become incredibly poor.
+
+
+```python
+_, _, reconstructed = pca_reduce(tabulasa_left, 32, 1024)
+
+Audio(data=reconstructed[start:end], rate=samplerate)
+```
+
+
+
+
+
+
+
+
+
+
+As expected, our reconstructed audio does sound incredibly poor! But there's something else very interesting going on here under the hood. Did you notice that the bassline comes across very well, but that there's no midrange or treble? The drums are almost entirely gone.
+
+[Drop the (Treble)][13]
+-----------------------
+
+It will help to understand PCA more fully when trying to read this part, but I'll do my best to break it down. PCA tries to find a way to best represent the dataset using "components." Think of each "component" as containing some of the information you need in order to reconstruct the full audio. For example, you might have a "low frequency" component that contains all the information you need in order to hear the bassline. There might be other components that explain the high frequency things like singers, or melodies, that you also need.
+
+What makes PCA interesting is that it attempts to find the "most important" components in explaining the signal. In a signal processing world, this means that PCA is trying to find the signal amongst the noise in your data. In our case, this means that PCA, when forced to work with small numbers of components, will chuck out the noisy components first. It's doing it's best job to reconstruct the signal, but it has to make sacrifices somewhere.
+
+So I've mentioned that PCA identifies the "noisy" components in our dataset. This is equivalent to saying that PCA removes the "high frequency" components in this case: it's very easy to represent a low-frequency signal like a bassline. It's far more difficult to represent a high-frequency signal because it's changing all the time. When you force PCA to make a tradeoff by using a small number of components, the best it can hope to do is replicate the low-frequency sections and skip the high-frequency things.
+
+This is a very interesting insight, and it also has echos (pardon the pun) of how humans understand music in general. Other encoding schemes (like MP3, etc.) typically chop off a lot of the high-frequency range as well. There is typically a lot of high-frequency noise in audio that is nearly impossible to hear, so it's easy to remove it without anyone noticing. PCA ends up doing something similar, and while that certainly wasn't the intention, it is an interesting effect.
+
+## A More Realistic Example
+
+So we've seen the edge cases so far: Using a large number of components results in audio very close to the original, and using a small number of components acts as a low-pass filter. How about we develop something that sounds "good enough" in practice, that we can use as a benchmark for size? We'll use ourselves as judges of audio quality, and build another function to help us estimate how much space we need to store everything in.
+
+[13]: https://youtu.be/Ua0KpfJsxKo?t=1m17s
+
+
+```python
+from bz2 import compress
+import pandas as pd
+
+def raw_estimate(transformed, pca):
+ # We assume that we'll be storing things as 16-bit WAV,
+ # meaning two bytes per sample
+ signal_bytes = transformed.tobytes()
+ # PCA stores the components as floating point, we'll assume
+ # that means 32-bit floats, so 4 bytes per element
+ component_bytes = transformed.tobytes()
+
+ # Return a result in megabytes
+ return (len(signal_bytes) + len(component_bytes)) / (2**20)
+
+# Do an estimate for lossless compression applied on top of our
+# PCA reduction
+def bz2_estimate(transformed, pca):
+ bytestring = transformed.tobytes() + b';' + pca.components_.tobytes()
+ compressed = compress(bytestring)
+ return len(compressed) / (2**20)
+
+compression_attempts = [
+ (1, 1),
+ (1, 2),
+ (1, 4),
+ (4, 32),
+ (16, 256),
+ (32, 256),
+ (64, 256),
+ (128, 1024),
+ (256, 1024),
+ (512, 1024),
+ (128, 2048),
+ (256, 2048),
+ (512, 2048),
+ (1024, 2048)
+]
+
+def build_estimates(signal, n_components, block_size):
+ pca, transformed, recon = pca_reduce(tabulasa_left, n_components, block_size)
+ raw_pca_estimate = raw_estimate(transformed, pca)
+ bz2_pca_estimate = bz2_estimate(transformed, pca)
+ raw_size = len(recon.tobytes()) / (2**20)
+ return raw_size, raw_pca_estimate, bz2_pca_estimate
+
+pca_compression_results = pd.DataFrame([
+ build_estimates(tabulasa_left, n, bs)
+ for n, bs in compression_attempts
+ ])
+
+pca_compression_results.columns = ["Raw", "PCA", "PCA w/ BZ2"]
+pca_compression_results.index = compression_attempts
+pca_compression_results
+```
+
+
+
+
+
+
+
+
+
+
Raw
+
PCA
+
PCA w/ BZ2
+
+
+
+
+
(1, 1)
+
69.054298
+
138.108597
+
16.431797
+
+
+
(1, 2)
+
69.054306
+
69.054306
+
32.981380
+
+
+
(1, 4)
+
69.054321
+
34.527161
+
16.715032
+
+
+
(4, 32)
+
69.054443
+
17.263611
+
8.481735
+
+
+
(16, 256)
+
69.054688
+
8.631836
+
4.274846
+
+
+
(32, 256)
+
69.054688
+
17.263672
+
8.542909
+
+
+
(64, 256)
+
69.054688
+
34.527344
+
17.097543
+
+
+
(128, 1024)
+
69.054688
+
17.263672
+
9.430644
+
+
+
(256, 1024)
+
69.054688
+
34.527344
+
18.870387
+
+
+
(512, 1024)
+
69.054688
+
69.054688
+
37.800940
+
+
+
(128, 2048)
+
69.062500
+
8.632812
+
6.185015
+
+
+
(256, 2048)
+
69.062500
+
17.265625
+
12.366942
+
+
+
(512, 2048)
+
69.062500
+
34.531250
+
24.736506
+
+
+
(1024, 2048)
+
69.062500
+
69.062500
+
49.517493
+
+
+
+
+
+
+
+As we can see, there are a couple of instances where we do nearly 20 times better on storage space than the uncompressed file. Let's here what that sounds like:
+
+
+```python
+_, _, reconstructed = pca_reduce(tabulasa_left, 16, 256)
+Audio(data=reconstructed[start:end], rate=samplerate)
+```
+
+
+
+
+
+
+
+
+
+
+It sounds incredibly poor though. Let's try something that's a bit more realistic:
+
+
+```python
+_, _, reconstructed = pca_reduce(tabulasa_left, 1, 4)
+Audio(data=reconstructed[start:end], rate=samplerate)
+```
+
+
+
+
+
+
+
+
+
+
+And just out of curiosity, we can try something that has the same ratio of components to block size. This should be close to an apples-to-apples comparison.
+
+
+```python
+_, _, reconstructed = pca_reduce(tabulasa_left, 64, 256)
+Audio(data=reconstructed[start:end], rate=samplerate)
+```
+
+
+
+
+
+
+
+
+
+
+The smaller block size definitely has better high-end response, but I personally think the larger block size sounds better overall.
+
+## Conclusions
+
+So, what do I think about audio compression using PCA?
+
+Strangely enough, it actually works pretty well relative to what I expected. That said, it's a terrible idea in general.
+
+First off, you don't really save any space. The component matrix needed to actually run the PCA algorithm takes up a lot of space on its own, so it's very difficult to save space without sacrificing a huge amount of audio quality. And even then, codecs like AAC sound very nice even at bitrates that this PCA method could only dream of.
+
+Second, there's the issue of audio streaming. PCA relies on two components: the datastream, and a matrix used to reconstruct the original signal. While it is easy to stream the data, you can't stream that matrix. And even if you divided the stream up into small blocks to give you a small matrix, you must guarantee that the matrix arrives; if you don't have that matrix, the data stream will make no sense whatsoever.
+
+All said, this was an interesting experiment. It's really cool seeing PCA used for signal analysis where I haven't seen it applied before, but I don't think it will lead to any practical results. Look forward to more signal processing stuff in the future!
diff --git a/blog/2016-11-01-PCA-audio-compression/index.mdx b/blog/2016-11-01-PCA-audio-compression/index.mdx
new file mode 100644
index 0000000..3c3cdc8
--- /dev/null
+++ b/blog/2016-11-01-PCA-audio-compression/index.mdx
@@ -0,0 +1,362 @@
+---
+slug: 2016/11/pca-audio-compression
+title: PCA audio compression
+date: 2016-11-01 12:00:00
+authors: [bspeice]
+tags: []
+---
+
+In which I apply Machine Learning techniques to Digital Signal Processing to astounding failure.
+
+
+
+Towards a new (and pretty poor) compression scheme
+--------------------------------------------------
+
+I'm going to be working with some audio data for a while as I get prepared for a term project this semester. I'll be working (with a partner) to design a system for separating voices from music. Given my total lack of experience with [Digital Signal Processing][1] I figured that now was as good a time as ever to work on a couple of fun projects that would get me back up to speed.
+
+The first project I want to work on: Designing a new compression scheme for audio data.
+
+A Brief Introduction to Audio Compression
+-----------------------------------------
+
+Audio files when uncompressed (files ending with `.wav`) are huge. Like, 10.5 Megabytes per minute huge. Storage is cheap these days, but that's still an incredible amount of data that we don't really need. Instead, we'd like to compress that data so that it's not taking up so much space. There are broadly two ways to accomplish this:
+
+1. Lossless compression - Formats like [FLAC][2], [ALAC][3], and [Monkey's Audio (.ape)][4] all go down this route. The idea is that when you compress and uncompress a file, you get exactly the same as what you started with.
+
+2. Lossy compression - Formats like [MP3][5], [Ogg][6], and [AAC (`.m4a`)][7] are far more popular, but make a crucial tradeoff: We can reduce the file size even more during compression, but the decompressed file won't be the same.
+
+There is a fundamental tradeoff at stake: Using lossy compression sacrifices some of the integrity of the resulting file to save on storage space. Most people (I personally believe it's everybody) can't hear the difference, so this is an acceptable tradeoff. You have files that take up a 10th of the space, and nobody can tell there's a difference in audio quality.
+
+A PCA-based Compression Scheme
+------------------------------
+
+What I want to try out is a [PCA][8] approach to encoding audio. The PCA technique comes from Machine Learning, where it is used for a process called [Dimensionality Reduction][9]. Put simply, the idea is the same as lossy compression: if we can find a way that represents the data well enough, we can save on space. There are a lot of theoretical concerns that lead me to believe this compression style will not end well, but I'm interested to try it nonetheless.
+
+PCA works as follows: Given a dataset with a number of features, I find a way to approximate those original features using some "new features" that are statistically as close as possible to the original ones. This is comparable to a scheme like MP3: Given an original signal, I want to find a way of representing it that gets approximately close to what the original was. The difference is that PCA is designed for statistical data, and not signal data. But we won't let that stop us.
+
+The idea is as follows: Given a signal, reshape it into 1024 columns by however many rows are needed (zero-padded if necessary). Run the PCA algorithm, and do dimensionality reduction with a couple different settings. The number of components I choose determines the quality: If I use 1024 components, I will essentially be using the original signal. If I use a smaller number of components, I start losing some of the data that was in the original file. This will give me an idea of whether it's possible to actually build an encoding scheme off of this, or whether I'm wasting my time.
+
+Running the Algorithm
+---------------------
+
+The audio I will be using comes from the song [Tabulasa][10], by [Broke for Free][11]. I'll be loading in the audio signal to Python and using [Scikit-Learn][12] to actually run the PCA algorithm.
+
+We first need to convert the FLAC file I have to a WAV:
+
+[1]: https://en.wikipedia.org/wiki/Digital_signal_processing
+[2]: https://en.wikipedia.org/wiki/FLAC
+[3]: https://en.wikipedia.org/wiki/Apple_Lossless
+[4]: https://en.wikipedia.org/wiki/Monkey%27s_Audio
+[5]: https://en.wikipedia.org/wiki/MP3
+[6]: https://en.wikipedia.org/wiki/Vorbis
+[7]: https://en.wikipedia.org/wiki/Advanced_Audio_Coding
+[8]: https://en.wikipedia.org/wiki/Principal_component_analysis
+[9]: https://en.wikipedia.org/wiki/Dimensionality_reduction
+[10]: https://brokeforfree.bandcamp.com/track/tabulasa
+[11]: https://brokeforfree.bandcamp.com/album/xxvii
+[12]: http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html#sklearn.decomposition.PCA
+
+
+```python
+!ffmpeg -hide_banner -loglevel panic -i "Broke For Free/XXVII/01 Tabulasa.flac" "Tabulasa.wav" -c wav
+```
+
+Then, let's go ahead and load a small sample so you can hear what is going on.
+
+
+```python
+from IPython.display import Audio
+from scipy.io import wavfile
+
+samplerate, tabulasa = wavfile.read('Tabulasa.wav')
+
+start = samplerate * 14 # 10 seconds in
+end = start + samplerate * 10 # 5 second duration
+Audio(data=tabulasa[start:end, 0], rate=samplerate)
+```
+
+import wav1 from "./1.wav";
+
+