project_8_starter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 8: Backtesting\n",
    "\n",
    "In this project, you will build a fairly realistic backtester that uses the Barra data. The backtester will perform portfolio optimization that includes transaction costs, and you'll implement it with computational efficiency in mind, to allow for a reasonably fast backtest. You'll also use performance attribution to identify the major drivers of your portfolio's profit-and-loss (PnL). You will have the option to modify and customize the backtest as well.\n",
    "\n",
    "\n",
    "## Instructions\n",
    "\n",
    "Each problem consists of a function to implement and instructions on how to implement the function.  The parts of the function that need to be implemented are marked with a `# TODO` comment. Your code will be checked for the correct solution when you submit it to Udacity.\n",
    "\n",
    "\n",
    "## Packages\n",
    "\n",
    "When you implement the functions, you'll only need to you use the packages you've used in the classroom, like [Pandas](https://pandas.pydata.org/) and [Numpy](http://www.numpy.org/). These packages will be imported for you. We recommend you don't add any import statements, otherwise the grader might not be able to run your code.\n",
    "\n",
    "### Install Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting cmake\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/19/34/b1e6d50ffd6f737521e85a35080004c072dfe7ddd11c9cdd491274cef2b8/cmake-3.20.2-py2.py3-none-manylinux1_x86_64.whl (19.4MB)\n",
      "\u001b[K    100% |████████████████████████████████| 19.5MB 1.2MB/s eta 0:00:01  4% |█▌                              | 890kB 10.6MB/s eta 0:00:02    11% |███▊                            | 2.2MB 15.0MB/s eta 0:00:02    20% |██████▋                         | 4.0MB 19.8MB/s eta 0:00:01    30% |█████████▉                      | 6.0MB 24.9MB/s eta 0:00:01    36% |███████████▋                    | 7.1MB 20.0MB/s eta 0:00:01    41% |█████████████▎                  | 8.1MB 20.5MB/s eta 0:00:01    47% |███████████████▏                | 9.2MB 19.1MB/s eta 0:00:01    61% |███████████████████▊            | 12.0MB 17.8MB/s eta 0:00:01    71% |██████████████████████▊         | 13.8MB 19.8MB/s eta 0:00:01��██████████████▋    | 16.8MB 37.3MB/s eta 0:00:01\n",
      "\u001b[?25hInstalling collected packages: cmake\n",
      "Successfully installed cmake-3.20.2\n"
     ]
    }
   ],
   "source": [
    "! pip3 install cmake"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting xgboost\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/cb/15/5a0e2977c2dca5dc374e6ba490674d7807d75e220b9bf2028d83a296d50f/xgboost-1.4.2.tar.gz (716kB)\n",
      "\u001b[K    100% |████████████████████████████████| 727kB 14.0MB/s ta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: numpy in /opt/conda/lib/python3.6/site-packages (from xgboost) (1.16.1)\n",
      "Requirement already satisfied: scipy in /opt/conda/lib/python3.6/site-packages (from xgboost) (0.19.1)\n",
      "Building wheels for collected packages: xgboost\n",
      "  Running setup.py bdist_wheel for xgboost ... \u001b[?25l\\^C\n",
      "\u001b[?25canceled\n"
     ]
    }
   ],
   "source": [
    "! pip3 install xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: matplotlib==2.1.0 in /opt/conda/lib/python3.6/site-packages (from -r requirements.txt (line 1)) (2.1.0)\n",
      "Collecting numpy==1.16.1 (from -r requirements.txt (line 2))\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/f5/bf/4981bcbee43934f0adb8f764a1e70ab0ee5a448f6505bd04a87a2fda2a8b/numpy-1.16.1-cp36-cp36m-manylinux1_x86_64.whl (17.3MB)\n",
      "\u001b[K    100% |████████████████████████████████| 17.3MB 2.3MB/s eta 0:00:01  8% |██▋                             | 1.4MB 20.9MB/s eta 0:00:01    21% |██████▊                         | 3.6MB 23.3MB/s eta 0:00:01    40% |█████████████                   | 7.0MB 22.1MB/s eta 0:00:01    52% |█████████████████               | 9.2MB 22.6MB/s eta 0:00:01    59% |███████████████████             | 10.3MB 23.1MB/s eta 0:00:01    65% |█████████████████████           | 11.4MB 23.6MB/s eta 0:00:01    71% |███████████████████████         | 12.5MB 22.0MB/s eta 0:00:01    78% |█████████████████████████       | 13.5MB 21.8MB/s eta 0:00:01    84% |███████████████████████████     | 14.6MB 22.5MB/s eta 0:00:01    90% |█████████████████████████████   | 15.7MB 21.9MB/s eta 0:00:01    96% |███████████████████████████████ | 16.7MB 23.3MB/s eta 0:00:01\n",
      "\u001b[?25hCollecting pandas==0.24.1 (from -r requirements.txt (line 3))\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/e6/de/a0d3defd8f338eaf53ef716e40ef6d6c277c35d50e09b586e170169cdf0d/pandas-0.24.1-cp36-cp36m-manylinux1_x86_64.whl (10.1MB)\n",
      "\u001b[K    100% |████████████████████████████████| 10.1MB 5.4MB/s eta 0:00:01   44% |██████████████▍                 | 4.5MB 24.4MB/s eta 0:00:01    87% |████████████████████████████    | 8.8MB 23.6MB/s eta 0:00:01\n",
      "\u001b[?25hCollecting patsy==0.5.1 (from -r requirements.txt (line 4))\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/ea/0c/5f61f1a3d4385d6bf83b83ea495068857ff8dfb89e74824c6e9eb63286d8/patsy-0.5.1-py2.py3-none-any.whl (231kB)\n",
      "\u001b[K    100% |████████████████████████████████| 235kB 17.6MB/s ta 0:00:01\n",
      "\u001b[?25hCollecting scipy==0.19.1 (from -r requirements.txt (line 5))\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/0e/46/da8d7166102d29695330f7c0b912955498542988542c0d2ae3ea0389c68d/scipy-0.19.1-cp36-cp36m-manylinux1_x86_64.whl (48.2MB)\n",
      "\u001b[K    100% |████████████████████████████████| 48.2MB 886kB/s eta 0:00:01  0% |▏                               | 174kB 19.9MB/s eta 0:00:03    4% |█▌                              | 2.2MB 20.9MB/s eta 0:00:03    26% |████████▎                       | 12.5MB 22.7MB/s eta 0:00:02    32% |██████████▍                     | 15.6MB 20.3MB/s eta 0:00:02    34% |███████████                     | 16.6MB 22.2MB/s eta 0:00:02    36% |███████████▊                    | 17.7MB 21.6MB/s eta 0:00:02    46% |███████████████                 | 22.6MB 21.2MB/s eta 0:00:02    48% |███████████████▋                | 23.6MB 20.7MB/s eta 0:00:02    50% |████████████████▎               | 24.5MB 19.4MB/s eta 0:00:02    56% |██████████████████▏             | 27.4MB 20.8MB/s eta 0:00:02    58% |██████████████████▉             | 28.3MB 19.8MB/s eta 0:00:02    67% |█████████████████████▊          | 32.7MB 20.2MB/s eta 0:00:01    75% |████████████████████████▏       | 36.4MB 20.3MB/s eta 0:00:01    79% |█████████████████████████▎      | 38.1MB 18.8MB/s eta 0:00:01    81% |██████████████████████████      | 39.1MB 18.1MB/s eta 0:00:01    83% |██████████████████████████▋     | 40.1MB 19.6MB/s eta 0:00:01    84% |███████████████████████████▏    | 40.9MB 19.6MB/s eta 0:00:01    86% |███████████████████████████▉    | 41.9MB 16.8MB/s eta 0:00:01    88% |████████████████████████████▍   | 42.8MB 19.0MB/s eta 0:00:01    90% |█████████████████████████████   | 43.7MB 19.7MB/s eta 0:00:01    94% |██████████████████████████████▏ | 45.5MB 19.0MB/s eta 0:00:01    96% |██████████████████████████████▉ | 46.5MB 20.2MB/s eta 0:00:01    98% |███████████████████████████████▌| 47.5MB 18.8MB/s eta 0:00:01\n",
      "\u001b[?25hCollecting statsmodels==0.9.0 (from -r requirements.txt (line 6))\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/85/d1/69ee7e757f657e7f527cbf500ec2d295396e5bcec873cf4eb68962c41024/statsmodels-0.9.0-cp36-cp36m-manylinux1_x86_64.whl (7.4MB)\n",
      "\u001b[K    100% |████████████████████████████████| 7.4MB 7.1MB/s eta 0:00:01   6% |██                              | 450kB 18.6MB/s eta 0:00:01    31% |██████████▏                     | 2.3MB 21.0MB/s eta 0:00:01    56% |██████████████████▏             | 4.2MB 20.2MB/s eta 0:00:01    69% |██████████████████████▎         | 5.2MB 17.4MB/s eta 0:00:01    82% |██████████████████████████▎     | 6.1MB 21.3MB/s eta 0:00:01    95% |██████████████████████████████▋ | 7.1MB 20.0MB/s eta 0:00:01\n",
      "\u001b[?25hCollecting tqdm==4.19.5 (from -r requirements.txt (line 7))\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/71/3c/341b4fa23cb3abc335207dba057c790f3bb329f6757e1fcd5d347bcf8308/tqdm-4.19.5-py2.py3-none-any.whl (51kB)\n",
      "\u001b[K    100% |████████████████████████████████| 61kB 7.6MB/s ta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: six>=1.10 in /opt/conda/lib/python3.6/site-packages (from matplotlib==2.1.0->-r requirements.txt (line 1)) (1.11.0)\n",
      "Requirement already satisfied: python-dateutil>=2.0 in /opt/conda/lib/python3.6/site-packages (from matplotlib==2.1.0->-r requirements.txt (line 1)) (2.6.1)\n",
      "Requirement already satisfied: pytz in /opt/conda/lib/python3.6/site-packages (from matplotlib==2.1.0->-r requirements.txt (line 1)) (2017.3)\n",
      "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.6/site-packages/cycler-0.10.0-py3.6.egg (from matplotlib==2.1.0->-r requirements.txt (line 1)) (0.10.0)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /opt/conda/lib/python3.6/site-packages (from matplotlib==2.1.0->-r requirements.txt (line 1)) (2.2.0)\n",
      "\u001b[31mtensorflow 1.3.0 requires tensorflow-tensorboard<0.2.0,>=0.1.0, which is not installed.\u001b[0m\n",
      "\u001b[31mmoviepy 0.2.3.2 has requirement tqdm==4.11.2, but you'll have tqdm 4.19.5 which is incompatible.\u001b[0m\n",
      "Installing collected packages: numpy, pandas, patsy, scipy, statsmodels, tqdm\n",
      "  Found existing installation: numpy 1.12.1\n",
      "    Uninstalling numpy-1.12.1:\n",
      "      Successfully uninstalled numpy-1.12.1\n",
      "  Found existing installation: pandas 0.23.3\n",
      "    Uninstalling pandas-0.23.3:\n",
      "      Successfully uninstalled pandas-0.23.3\n",
      "  Found existing installation: patsy 0.4.1\n",
      "    Uninstalling patsy-0.4.1:\n",
      "      Successfully uninstalled patsy-0.4.1\n",
      "  Found existing installation: scipy 1.2.1\n",
      "    Uninstalling scipy-1.2.1:\n",
      "      Successfully uninstalled scipy-1.2.1\n",
      "  Found existing installation: statsmodels 0.8.0\n",
      "    Uninstalling statsmodels-0.8.0:\n",
      "      Successfully uninstalled statsmodels-0.8.0\n",
      "  Found existing installation: tqdm 4.11.2\n",
      "    Uninstalling tqdm-4.11.2:\n",
      "      Successfully uninstalled tqdm-4.11.2\n",
      "Successfully installed numpy-1.16.1 pandas-0.24.1 patsy-0.5.1 scipy-0.19.1 statsmodels-0.9.0 tqdm-4.19.5\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "!{sys.executable} -m pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy\n",
    "import patsy\n",
    "import pickle\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import scipy.sparse\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from statistics import median\n",
    "from scipy.stats import gaussian_kde\n",
    "from statsmodels.formula.api import ols\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data\n",
    "\n",
    "We’ll be using the Barra dataset to get factors that can be used to predict risk. Loading and parsing the raw Barra data can be a very slow process that can significantly slow down your backtesting. For this reason, it's important to pre-process the data beforehand. For your convenience, the Barra data has already been pre-processed for you and saved into pickle files. You will load the Barra data from these pickle files.\n",
    "\n",
    "In the code below, we start by loading `2004` factor data from the `pandas-frames.2004.pickle` file. We also load the `2003` and `2004` covariance data from the `covaraince.2003.pickle`  and `covaraince.2004.pickle` files. You are encouraged  to customize the data range for your backtest. For example, we recommend starting with two or three years of factor data. Remember that the covariance data should include all the years that you choose for the factor data,   and also one year earlier. For example, in the code below we are using  `2004` factor data, therefore, we must include `2004` in our covariance data, but also the previous year, `2003`. If you don't remember why must include this previous year, feel free to review the lessons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "barra_dir = '../../data/project_8_barra/'\n",
    "\n",
    "data = {}\n",
    "for year in [2004]:\n",
    "    fil = barra_dir + \"pandas-frames.\" + str(year) + \".pickle\"\n",
    "    data.update(pickle.load( open( fil, \"rb\" ) ))\n",
    "    \n",
    "covariance = {}\n",
    "for year in [2003, 2004]:\n",
    "    fil = barra_dir + \"covariance.\" + str(year) + \".pickle\"\n",
    "    covariance.update(pickle.load( open(fil, \"rb\" ) ))\n",
    "    \n",
    "daily_return = {}\n",
    "for year in [2004, 2005]:\n",
    "    fil = barra_dir + \"price.\" + str(year) + \".pickle\"\n",
    "    daily_return.update(pickle.load( open(fil, \"rb\" ) ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shift Daily Returns Data (TODO)\n",
    "\n",
    "In the cell below, we want to incorporate a realistic time delay that exists in live trading, we’ll use a two day delay for the `daily_return` data. That means the `daily_return` should be two days after the data in `data` and `cov_data`. Combine `daily_return` and `data` together in a dict called `frames`.\n",
    "\n",
    "Since reporting of PnL is usually for the date of the returns, make sure to use the two day delay dates (dates that match the `daily_return`) when building `frames`. This means calling `frames['20040108']` will get you the prices from \"20040108\" and the data from `data` at \"20040106\".\n",
    "\n",
    "Note: We're not shifting `covariance`, since we'll use the \"DataDate\" field in `frames` to lookup the covariance data. The \"DataDate\" field contains the date when the `data` in `frames` was recorded. For example, `frames['20040108']` will give you a value of \"20040106\" for the field \"DataDate\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames ={}\n",
    "dlyreturn_n_days_delay = 2\n",
    "\n",
    "# TODO: Implement\n",
    "date_shifts = zip(\n",
    "        sorted(data.keys()),\n",
    "        sorted(daily_return.keys())[dlyreturn_n_days_delay:len(data) + dlyreturn_n_days_delay])\n",
    "for data_date, price_date in date_shifts:\n",
    "    frames[price_date] = data[data_date].merge(daily_return[price_date], on='Barrid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add Daily Returns date column (Optional)\n",
    "Name the column `DlyReturnDate`.\n",
    "**Hint**: create a list containing copies of the date, then create a pandas series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optional\n",
    "#Daily returns date col\n",
    "for DlyReturnDate, df in frames.items():\n",
    "    n_rows = df.shape[0]\n",
    "    df['DlyReturnDate'] = pd.Series([DlyReturnDate] * n_rows)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Barrid</th>\n",
       "      <th>USFASTD_1DREVRSL</th>\n",
       "      <th>USFASTD_AERODEF</th>\n",
       "      <th>USFASTD_AIRLINES</th>\n",
       "      <th>USFASTD_ALUMSTEL</th>\n",
       "      <th>USFASTD_APPAREL</th>\n",
       "      <th>USFASTD_AUTO</th>\n",
       "      <th>USFASTD_BANKS</th>\n",
       "      <th>USFASTD_BETA</th>\n",
       "      <th>USFASTD_BEVTOB</th>\n",
       "      <th>...</th>\n",
       "      <th>ADTCA_30</th>\n",
       "      <th>IssuerMarketCap</th>\n",
       "      <th>Yield</th>\n",
       "      <th>TotalRisk</th>\n",
       "      <th>SpecRisk</th>\n",
       "      <th>HistBeta</th>\n",
       "      <th>PredBeta</th>\n",
       "      <th>DataDate</th>\n",
       "      <th>DlyReturn</th>\n",
       "      <th>DlyReturnDate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>USA0001</td>\n",
       "      <td>-0.481</td>\n",
       "      <td>0.000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-2.158</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>5.592728e+10</td>\n",
       "      <td>0.188679</td>\n",
       "      <td>15.692850</td>\n",
       "      <td>10.050981</td>\n",
       "      <td>-0.000188</td>\n",
       "      <td>0.159701</td>\n",
       "      <td>20040106</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20040108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>USA0011</td>\n",
       "      <td>-0.595</td>\n",
       "      <td>0.000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-2.158</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>6.029930e+09</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>19.050196</td>\n",
       "      <td>12.874902</td>\n",
       "      <td>0.000017</td>\n",
       "      <td>0.133397</td>\n",
       "      <td>20040106</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20040108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>USA0031</td>\n",
       "      <td>-0.109</td>\n",
       "      <td>0.000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-2.049</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7.251836e+10</td>\n",
       "      <td>2.103004</td>\n",
       "      <td>24.037181</td>\n",
       "      <td>19.772275</td>\n",
       "      <td>0.050603</td>\n",
       "      <td>0.210419</td>\n",
       "      <td>20040106</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20040108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>USA0062</td>\n",
       "      <td>0.163</td>\n",
       "      <td>0.431</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-1.997</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.918165e+10</td>\n",
       "      <td>2.243494</td>\n",
       "      <td>25.280406</td>\n",
       "      <td>22.709825</td>\n",
       "      <td>0.074781</td>\n",
       "      <td>0.372498</td>\n",
       "      <td>20040106</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20040108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>USA00E2</td>\n",
       "      <td>0.064</td>\n",
       "      <td>0.000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-1.955</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>5.784320e+10</td>\n",
       "      <td>2.167256</td>\n",
       "      <td>27.885397</td>\n",
       "      <td>23.513232</td>\n",
       "      <td>0.094615</td>\n",
       "      <td>0.410219</td>\n",
       "      <td>20040106</td>\n",
       "      <td>0.0</td>\n",
       "      <td>20040108</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 94 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    Barrid  USFASTD_1DREVRSL  USFASTD_AERODEF  USFASTD_AIRLINES  \\\n",
       "0  USA0001            -0.481            0.000               0.0   \n",
       "1  USA0011            -0.595            0.000               0.0   \n",
       "2  USA0031            -0.109            0.000               0.0   \n",
       "3  USA0062             0.163            0.431               0.0   \n",
       "4  USA00E2             0.064            0.000               0.0   \n",
       "\n",
       "   USFASTD_ALUMSTEL  USFASTD_APPAREL  USFASTD_AUTO  USFASTD_BANKS  \\\n",
       "0               0.0              0.0           0.0            0.0   \n",
       "1               0.0              0.0           0.0            0.0   \n",
       "2               0.0              0.0           0.0            0.0   \n",
       "3               0.0              0.0           0.0            0.0   \n",
       "4               0.0              0.0           0.0            0.0   \n",
       "\n",
       "   USFASTD_BETA  USFASTD_BEVTOB  ...  ADTCA_30  IssuerMarketCap     Yield  \\\n",
       "0        -2.158             0.0  ...       NaN     5.592728e+10  0.188679   \n",
       "1        -2.158             0.0  ...       NaN     6.029930e+09  0.000000   \n",
       "2        -2.049             0.0  ...       NaN     7.251836e+10  2.103004   \n",
       "3        -1.997             0.0  ...       NaN     2.918165e+10  2.243494   \n",
       "4        -1.955             0.0  ...       NaN     5.784320e+10  2.167256   \n",
       "\n",
       "   TotalRisk   SpecRisk  HistBeta  PredBeta  DataDate  DlyReturn  \\\n",
       "0  15.692850  10.050981 -0.000188  0.159701  20040106        0.0   \n",
       "1  19.050196  12.874902  0.000017  0.133397  20040106        0.0   \n",
       "2  24.037181  19.772275  0.050603  0.210419  20040106        0.0   \n",
       "3  25.280406  22.709825  0.074781  0.372498  20040106        0.0   \n",
       "4  27.885397  23.513232  0.094615  0.410219  20040106        0.0   \n",
       "\n",
       "   DlyReturnDate  \n",
       "0       20040108  \n",
       "1       20040108  \n",
       "2       20040108  \n",
       "3       20040108  \n",
       "4       20040108  \n",
       "\n",
       "[5 rows x 94 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " #For example, frames['20040108'] \n",
    "df = frames['20040108']\n",
    "df.head()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Winsorize\n",
    "\n",
    "As we have done in other projects, we'll want to avoid extremely positive or negative values in our data. Will therefore create a function, `wins`, that will clip our values to a minimum and maximum range. This process is called **Winsorizing**. Remember that this helps us handle noise, which may otherwise cause unusually large positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wins(x,a,b):\n",
    "    return np.where(x <= a,a, np.where(x >= b, b, x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Density Plot\n",
    "\n",
    "Let's check our `wins` function by taking a look at the distribution of returns for a single day `20040102`. We will clip our data from `-0.1` to `0.1` and plot it using our `density_plot` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0f138ef5c0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def density_plot(data): \n",
    "    density = gaussian_kde(data)\n",
    "    xs = np.linspace(np.min(data),np.max(data),200)\n",
    "    density.covariance_factor = lambda : .25\n",
    "    density._compute_covariance()\n",
    "    plt.plot(xs,density(xs))\n",
    "    plt.xlabel('Daily Returns')\n",
    "    plt.ylabel('Density')\n",
    "    plt.show()\n",
    "    \n",
    "test = frames['20040108']\n",
    "test['DlyReturn'] = wins(test['DlyReturn'],-0.1,0.1)\n",
    "density_plot(test['DlyReturn'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Factor Exposures and Factor Returns\n",
    "\n",
    "Recall that:\n",
    "\n",
    "$r_{i,t} = \\sum_{j=1}^{k} (\\beta_{i,j,t-2} \\times f_{j,t})$  \n",
    "where $i=1...N$ (N assets),   \n",
    "and $j=1...k$ (k factors).\n",
    "\n",
    "where $r_{i,t}$ is the return, $\\beta_{i,j,t-2}$ is the factor exposure, and $f_{j,t}$ is the factor return. Since we get the factor exposures from the Barra data, and we know the returns, it is possible to estimate the factor returns. In this notebook, we will use the Ordinary Least Squares (OLS) method to estimate the factor exposures, $f_{j,t}$, by using $\\beta_{i,j,t-2}$ as the independent variable, and $r_{i,t}$ as the dependent variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_formula(factors, Y):\n",
    "    L = [\"0\"]\n",
    "    L.extend(factors)\n",
    "    return Y + \" ~ \" + \" + \".join(L)\n",
    "\n",
    "def factors_from_names(n):\n",
    "    return list(filter(lambda x: \"USFASTD_\" in x, n))\n",
    "\n",
    "def estimate_factor_returns(df): \n",
    "    ## build universe based on filters \n",
    "    estu = df.loc[df.IssuerMarketCap > 1e9].copy(deep=True)\n",
    "  \n",
    "    ## winsorize returns for fitting \n",
    "    estu['DlyReturn'] = wins(estu['DlyReturn'], -0.25, 0.25)\n",
    "  \n",
    "    all_factors = factors_from_names(list(df))\n",
    "    form = get_formula(all_factors, \"DlyReturn\")\n",
    "    model = ols(form, data=estu)\n",
    "    results = model.fit()\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "facret = {}\n",
    "\n",
    "for date in frames:\n",
    "    facret[date] = estimate_factor_returns(frames[date]).params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dates = sorted(list(map(lambda date: pd.to_datetime(date, format='%Y%m%d'), frames.keys())))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choose Alpha Factors\n",
    "\n",
    "We will now choose our alpha factors. Barra's factors include some alpha factors that we have seen before, such as:\n",
    "\n",
    "* **USFASTD_1DREVRSL** : Reversal\n",
    "\n",
    "* **USFASTD_EARNYILD** : Earnings Yield\n",
    "\n",
    "* **USFASTD_VALUE** : Value\n",
    "\n",
    "* **USFASTD_SENTMT** : Sentiment\n",
    "\n",
    "We will choose these alpha factors for now, but you are encouraged to come back to this later and try other factors as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/pandas/plotting/_converter.py:129: FutureWarning: Using an implicitly registered datetime converter for a matplotlib plotting method. The converter was registered by pandas on import. Future versions of pandas will require you to explicitly register matplotlib converters.\n",
      "\n",
      "To register the converters:\n",
      "\t>>> from pandas.plotting import register_matplotlib_converters\n",
      "\t>>> register_matplotlib_converters()\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0f138ab8d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "alpha_factors = [\"USFASTD_1DREVRSL\", \"USFASTD_EARNYILD\", \"USFASTD_VALUE\", \"USFASTD_SENTMT\"]\n",
    "\n",
    "facret_df = pd.DataFrame(index = my_dates)\n",
    "\n",
    "for dt in my_dates: \n",
    "    for alp in alpha_factors: \n",
    "        facret_df.at[dt, alp] = facret[dt.strftime('%Y%m%d')][alp]\n",
    "\n",
    "for column in facret_df.columns:\n",
    "        plt.plot(facret_df[column].cumsum(), label=column)\n",
    "plt.legend(loc='upper left')\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('Cumulative Factor Returns')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merge Previous Portfolio Holdings \n",
    "\n",
    "In order to optimize our portfolio we will use the previous day's holdings to estimate the trade size and transaction costs. In order to keep track of the holdings from the previous day we will include a column to hold the portfolio holdings of the previous day. These holdings of all our assets will be initialized to zero when the backtest first starts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_nas(df): \n",
    "    numeric_columns = df.select_dtypes(include=[np.number]).columns.tolist()\n",
    "    \n",
    "    for numeric_column in numeric_columns: \n",
    "        df[numeric_column] = np.nan_to_num(df[numeric_column])\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "previous_holdings = pd.DataFrame(data = {\"Barrid\" : [\"USA02P1\"], \"h.opt.previous\" : np.array(0)})\n",
    "df = frames[my_dates[0].strftime('%Y%m%d')]\n",
    "\n",
    "df = df.merge(previous_holdings, how = 'left', on = 'Barrid')\n",
    "df = clean_nas(df)\n",
    "df.loc[df['SpecRisk'] == 0]['SpecRisk'] = median(df['SpecRisk'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build Universe Based on Filters (TODO)\n",
    "\n",
    "In the cell below, implement the function `get_universe` that creates a stock universe by selecting only those companies that have a market capitalization of at least 1 billion dollars **OR** that are in the previous day's holdings, even if on the current day, the company no longer meets the 1 billion dollar criteria.\n",
    "\n",
    "When creating the universe, make sure you use the `.copy()` attribute to create a copy of the data. Also, it is very important to make sure that we are not looking at returns when forming the portfolio! to make this impossible, make sure to drop the column containing the daily return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_universe(df):\n",
    "    \"\"\"\n",
    "    Create a stock universe based on filters\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    df : DataFrame\n",
    "        All stocks\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    universe : DataFrame\n",
    "        Selected stocks based on filters\n",
    "    \"\"\"\n",
    "    \n",
    "    # TODO: Implement\n",
    "    universe = df.loc[(df['IssuerMarketCap'] >= 1e+9) | (df['h.opt.previous'] != 0.0)].copy()\n",
    "    return universe.drop(['DlyReturn'], axis=1)\n",
    "\n",
    "universe = get_universe(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "date = str(int(universe['DataDate'][1])) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Factors\n",
    "\n",
    "We will now extract both the risk factors and alpha factors. We begin by first getting all the factors using the `factors_from_names` function defined previously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_factors = factors_from_names(list(universe))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now create the function `setdiff` to just select the factors that we have not defined as alpha factors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setdiff(temp1, temp2): \n",
    "    s = set(temp2)\n",
    "    temp3 = [x for x in temp1 if x not in s]\n",
    "    return temp3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "risk_factors = setdiff(all_factors, alpha_factors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also save the column that contains the previous holdings in a separate variable because we are going to use it later when we perform our portfolio optimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "h0 = universe['h.opt.previous']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix of Risk Factor Exposures\n",
    "\n",
    "Our dataframe contains several columns that we'll use as risk factors exposures.  Extract these and put them into a matrix.\n",
    "\n",
    "The data, such as industry category, are already one-hot encoded, but if this were not the case, then using `patsy.dmatrices` would help, as this function extracts categories and performs the one-hot encoding.  We'll practice using this package, as you may find it useful with future data sets.  You could also store the factors in a dataframe if you prefer.\n",
    "\n",
    "#### How to use patsy.dmatrices\n",
    "\n",
    "`patsy.dmatrices` takes in a formula and the dataframe.  The formula tells the function which columns to take.  The formula will look something like this:  \n",
    "`SpecRisk ~ 0 + USFASTD_AERODEF + USFASTD_AIRLINES + ...`  \n",
    "where the variable to the left of the ~ is the \"dependent variable\" and the others to the right are the independent variables (as if we were preparing data to be fit to a model).\n",
    "\n",
    "This just means that the `pasty.dmatrices` function will return two matrix variables, one that contains the single column for the dependent variable `outcome`, and the independent variable columns are stored in a matrix `predictors`.\n",
    "\n",
    "The `predictors` matrix will contain the matrix of risk factors, which is what we want.  We don't actually need the `outcome` matrix; it's just created because that's the way patsy.dmatrices works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "formula = get_formula(risk_factors, \"SpecRisk\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_matrix(formula, data): \n",
    "    outcome, predictors = patsy.dmatrices(formula, data)\n",
    "    return predictors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = model_matrix(formula, universe)\n",
    "BT = B.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate Specific Variance\n",
    "\n",
    "Notice that the specific risk data is in percent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     9.014505\n",
       "1    11.726327\n",
       "Name: SpecRisk, dtype: float64"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "universe['SpecRisk'][0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, in order to get the specific variance for each stock in the universe we first need to multiply these values by `0.01`  and then square them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "specVar = (0.01 * universe['SpecRisk']) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Factor covariance matrix (TODO)\n",
    "\n",
    "Note that we already have factor covariances from Barra data, which is stored in the variable `covariance`.  `covariance` is a dictionary, where the key is each day's date, and the value is a dataframe containing the factor covariances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Factor1</th>\n",
       "      <th>Factor2</th>\n",
       "      <th>VarCovar</th>\n",
       "      <th>DataDate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>USFASTD_1DREVRSL</td>\n",
       "      <td>USFASTD_1DREVRSL</td>\n",
       "      <td>1.958869</td>\n",
       "      <td>20040102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>USFASTD_1DREVRSL</td>\n",
       "      <td>USFASTD_BETA</td>\n",
       "      <td>1.602458</td>\n",
       "      <td>20040102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>USFASTD_1DREVRSL</td>\n",
       "      <td>USFASTD_DIVYILD</td>\n",
       "      <td>-0.012642</td>\n",
       "      <td>20040102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>USFASTD_1DREVRSL</td>\n",
       "      <td>USFASTD_DWNRISK</td>\n",
       "      <td>-0.064387</td>\n",
       "      <td>20040102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>USFASTD_1DREVRSL</td>\n",
       "      <td>USFASTD_EARNQLTY</td>\n",
       "      <td>0.046573</td>\n",
       "      <td>20040102</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Factor1           Factor2  VarCovar  DataDate\n",
       "0  USFASTD_1DREVRSL  USFASTD_1DREVRSL  1.958869  20040102\n",
       "1  USFASTD_1DREVRSL      USFASTD_BETA  1.602458  20040102\n",
       "2  USFASTD_1DREVRSL   USFASTD_DIVYILD -0.012642  20040102\n",
       "3  USFASTD_1DREVRSL   USFASTD_DWNRISK -0.064387  20040102\n",
       "4  USFASTD_1DREVRSL  USFASTD_EARNQLTY  0.046573  20040102"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "covariance['20040102'].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the code below, implement the function `diagonal_factor_cov` to create the factor covariance matrix. Note that the covariances are given in percentage units squared.  Therefore you must re-scale them appropriately so that they're in decimals squared. Use the given `colnames` function to get the column names from `B`. \n",
    "\n",
    "When creating factor covariance matrix, you can store the factor variances and covariances, or just store the factor variances.  Try both, and see if you notice any differences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def colnames(B):\n",
    "    if type(B) == patsy.design_info.DesignMatrix: \n",
    "        return B.design_info.column_names\n",
    "    if type(B) == pandas.core.frame.DataFrame: \n",
    "        return B.columns.tolist()\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def diagonal_factor_cov(date, B):\n",
    "    \"\"\"\n",
    "    Create the factor covariance matrix\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    date : string\n",
    "           date. For example 20040102\n",
    "        \n",
    "    B : patsy.design_info.DesignMatrix OR pandas.core.frame.DataFrame\n",
    "        Matrix of Risk Factors\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    Fm : Numpy ndarray\n",
    "        factor covariance matrix\n",
    "    \"\"\"\n",
    "    \n",
    "    # TODO: Implement\n",
    "    cv = covariance[date]\n",
    "    k = B.shape[1]\n",
    "\n",
    "    Fm = np.zeros([k, k])\n",
    "    for j in range(0, k):\n",
    "        factor = colnames(B)[j]\n",
    "        # converting from percentage units squared to decimal\n",
    "        Fm[j, j] = (0.01**2) * cv.loc[(cv.Factor1 == factor) & (cv.Factor2 == factor), \"VarCovar\"].iloc[0]\n",
    "    \n",
    "    return Fm\n",
    "\n",
    "Fvar = diagonal_factor_cov(date, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transaction Costs\n",
    "\n",
    "To get the transaction cost, or slippage, we have to multiply the price change due to market impact by the amount of dollars traded:\n",
    "\n",
    "$$\n",
    "\\mbox{tcost_{i,t}} = \\% \\Delta \\mbox{price}_{i,t} \\times \\mbox{trade}_{i,t}\n",
    "$$\n",
    "\n",
    "In summation notation it looks like this:  \n",
    "$$\n",
    "\\mbox{tcost}_{i,t} = \\sum_i^{N} \\lambda_{i,t} (h_{i,t} - h_{i,t-1})^2\n",
    "$$  \n",
    "where\n",
    "$$\n",
    "\\lambda_{i,t} = \\frac{1}{10\\times \\mbox{ADV}_{i,t}}\n",
    "$$\n",
    "\n",
    "Note that since we're dividing by ADV, we'll want to handle cases when ADV is missing or zero.  In those instances, we can set ADV to a small positive number, such as 10,000, which, in practice assumes that the stock is illiquid. In the code below if there is no volume information we assume the asset is illiquid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_lambda(universe, composite_volume_column = 'ADTCA_30'):\n",
    "    universe.loc[np.isnan(universe[composite_volume_column]), composite_volume_column] = 1.0e4\n",
    "    universe.loc[universe[composite_volume_column] == 0, composite_volume_column] = 1.0e4 \n",
    "\n",
    "    adv = universe[composite_volume_column]\n",
    "    \n",
    "    return 0.1 / adv\n",
    "\n",
    "Lambda = get_lambda(universe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Alpha Combination (TODO)\n",
    "\n",
    "In the code below create a matrix of alpha factors and return it from the function `get_B_alpha`. Create this matrix in the same way you created the matrix of risk factors, i.e. using the `get_formula` and `model_matrix` functions we have defined above. Feel free to go back and look at the previous code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_B_alpha(alpha_factors, universe):\n",
    "    # TODO: Implement\n",
    "    \n",
    "    return model_matrix(get_formula(alpha_factors, \"SpecRisk\"), universe)\n",
    "\n",
    "B_alpha = get_B_alpha(alpha_factors, universe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have the matrix containing the alpha factors we will combine them by adding its rows. By doing this we will collapse the `B_alpha` matrix into a single alpha vector. We'll multiply by `1e-4` so that the expression of expected portfolio return, $\\alpha^T \\mathbf{h}$, is in dollar units. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_alpha_vec(B_alpha):\n",
    "    \"\"\"\n",
    "    Create an alpha vecrtor\n",
    "\n",
    "    Parameters\n",
    "    ----------        \n",
    "    B_alpha : patsy.design_info.DesignMatrix \n",
    "        Matrix of Alpha Factors\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    alpha_vec : patsy.design_info.DesignMatrix \n",
    "        alpha vecrtor\n",
    "    \"\"\"\n",
    "    \n",
    "    # TODO: Implement\n",
    "    \n",
    "    return 1e-4 * np.sum(B_alpha, axis=1)\n",
    "\n",
    "alpha_vec = get_alpha_vec(B_alpha)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Optional Challenge\n",
    "\n",
    "You can also try to a more sophisticated method of alpha combination, by choosing the holding for each alpha based on the same metric of its performance, such as the factor returns, or sharpe ratio.  To make this more realistic, you can calculate a rolling average of the sharpe ratio, which is updated for each day.  Remember to only use data that occurs prior to the date of each optimization, and not data that occurs in the future.  Also, since factor returns and sharpe ratios may be negative, consider using a `max` function to give the holdings a lower bound of zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objective function (TODO)\n",
    "\n",
    "The objective function is given by:\n",
    "\n",
    "$$\n",
    "f(\\mathbf{h}) = \\frac{1}{2}\\kappa \\mathbf{h}_t^T\\mathbf{Q}^T\\mathbf{Q}\\mathbf{h}_t + \\frac{1}{2} \\kappa \\mathbf{h}_t^T \\mathbf{S} \\mathbf{h}_t - \\mathbf{\\alpha}^T \\mathbf{h}_t + (\\mathbf{h}_{t} - \\mathbf{h}_{t-1})^T \\mathbf{\\Lambda} (\\mathbf{h}_{t} - \\mathbf{h}_{t-1})\n",
    "$$\n",
    "\n",
    "Where the terms correspond to: factor risk + idiosyncratic risk - expected portfolio return + transaction costs, respectively. We should also note that $\\textbf{Q}^T\\textbf{Q}$ is defined to be the same as $\\textbf{BFB}^T$.  Review the lessons if you need a refresher of how we get $\\textbf{Q}$.\n",
    "\n",
    "Our objective is to minimize this objective function. To do this, we will use Scipy's optimization function:\n",
    "\n",
    "`scipy.optimize.fmin_l_bfgs_b(func, initial_guess, func_gradient)`\n",
    "\n",
    "where:\n",
    "\n",
    "* **func** : is the function we want to minimize\n",
    "\n",
    "* **initial_guess** : is out initial guess\n",
    "\n",
    "* **func_gradient** : is the gradient of the function we want to minimize\n",
    "\n",
    "So, in order to use the `scipy.optimize.fmin_l_bfgs_b` function we first need to define its parameters.\n",
    "\n",
    "In the code below implement the function `obj_func(h)` that corresponds to the objective function above that we want to minimize. We will set the risk aversion to be `1.0e-6`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "risk_aversion = 1.0e-6\n",
    "\n",
    "def get_obj_func(h0, risk_aversion, Q, specVar, alpha_vec, Lambda): \n",
    "    def obj_func(h):\n",
    "        # TODO: Implement\n",
    "        \n",
    "        return \\\n",
    "            0.5 * risk_aversion * np.sum(np.matmul(Q, h)**2) + \\\n",
    "            0.5 * risk_aversion * np.dot(h**2, specVar) - \\\n",
    "            np.dot(h, alpha_vec) + \\\n",
    "            np.dot((h - h0)**2, Lambda) \n",
    "    return obj_func"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gradient (TODO)\n",
    "\n",
    "Now that we can generate the objective function using `get_obj_func`, we can now create a similar function with its gradient. The reason we're interested in calculating the gradient is so that we can tell the optimizer in which direction, and how much, it should shift the portfolio holdings in order to improve the objective function (minimize variance, minimize transaction cost, and maximize expected portfolio return).\n",
    "\n",
    "Before we implement the function we first need to know what the gradient looks like. The gradient, or derivative of the objective function, with respect to the portfolio holdings h, is given by:  \n",
    "\n",
    "$$\n",
    "f'(\\mathbf{h}) = \\frac{1}{2}\\kappa (2\\mathbf{Q}^T\\mathbf{Qh}) + \\frac{1}{2}\\kappa (2\\mathbf{Sh}) - \\mathbf{\\alpha} + 2(\\mathbf{h}_{t} - \\mathbf{h}_{t-1}) \\mathbf{\\Lambda}\n",
    "$$\n",
    "\n",
    "In the code below, implement the function `grad(h)` that corresponds to the function of the gradient given above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_grad_func(h0, risk_aversion, Q, QT, specVar, alpha_vec, Lambda):\n",
    "    def grad_func(h):\n",
    "        # TODO: Implement\n",
    "        \n",
    "        return np.asarray( \\\n",
    "            risk_aversion * np.matmul(QT, np.matmul(Q, h)) + \\\n",
    "            risk_aversion * specVar * h - \\\n",
    "            alpha_vec + \\\n",
    "            2 * (h - h0) * Lambda \\\n",
    "             )\n",
    "    return grad_func"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimize (TODO)\n",
    "\n",
    "Now that we can generate the objective function using `get_obj_func`, and its corresponding gradient using `get_grad_func` we are ready to minimize the objective function using Scipy's optimization function. For this, we will use out initial holdings as our `initial_guess` parameter.\n",
    "\n",
    "In the cell below, implement the function `get_h_star` that optimizes the objective function. Use the objective function (`obj_func`) and gradient function (`grad_func`) provided within `get_h_star` to optimize the objective function using the `scipy.optimize.fmin_l_bfgs_b` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "risk_aversion = 1.0e-6\n",
    "\n",
    "Q = np.matmul(scipy.linalg.sqrtm(Fvar), BT)\n",
    "QT = Q.transpose()\n",
    "\n",
    "def get_h_star(risk_aversion, Q, QT, specVar, alpha_vec, h0, Lambda):\n",
    "    \"\"\"\n",
    "    Optimize the objective function\n",
    "\n",
    "    Parameters\n",
    "    ----------        \n",
    "    risk_aversion : int or float \n",
    "        Trader's risk aversion\n",
    "        \n",
    "    Q : patsy.design_info.DesignMatrix \n",
    "        Q Matrix\n",
    "        \n",
    "    QT : patsy.design_info.DesignMatrix \n",
    "        Transpose of the Q Matrix\n",
    "        \n",
    "    specVar: Pandas Series \n",
    "        Specific Variance\n",
    "        \n",
    "    alpha_vec: patsy.design_info.DesignMatrix \n",
    "        alpha vector\n",
    "        \n",
    "    h0 : Pandas Series  \n",
    "        initial holdings\n",
    "        \n",
    "    Lambda : Pandas Series  \n",
    "        Lambda\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    optimizer_result[0]: Numpy ndarray \n",
    "        optimized holdings\n",
    "    \"\"\"\n",
    "    obj_func = get_obj_func(h0, risk_aversion, Q, specVar, alpha_vec, Lambda)\n",
    "    grad_func = get_grad_func(h0, risk_aversion, Q, QT, specVar, alpha_vec, Lambda)\n",
    "    \n",
    "    # TODO: Implement \n",
    "    \n",
    "    optimizer_result = scipy.optimize.fmin_l_bfgs_b(obj_func, h0, fprime=grad_func)\n",
    "    return optimizer_result[0]\n",
    "\n",
    "h_star = get_h_star(risk_aversion, Q, QT, specVar, alpha_vec, h0, Lambda)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we have optimized our objective function we can now use, `h_star` to create our optimal portfolio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt_portfolio = pd.DataFrame(data = {\"Barrid\" : universe['Barrid'], \"h.opt\" : h_star})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Risk Exposures (TODO)\n",
    "\n",
    "We can also use `h_star` to calculate our portfolio's risk and alpha exposures.\n",
    "\n",
    "In the cells below implement the functions `get_risk_exposures` and `get_portfolio_alpha_exposure` that calculate the portfolio's risk and alpha exposures, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def get_risk_exposures(B, BT, h_star):\n",
    "    \"\"\"\n",
    "    Calculate portfolio's Risk Exposure\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    B : patsy.design_info.DesignMatrix \n",
    "        Matrix of Risk Factors\n",
    "        \n",
    "    BT : patsy.design_info.DesignMatrix \n",
    "        Transpose of Matrix of Risk Factors\n",
    "        \n",
    "    h_star: Numpy ndarray \n",
    "        optimized holdings\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    risk_exposures : Pandas Series\n",
    "        Risk Exposures\n",
    "    \"\"\"\n",
    "    \n",
    "    # TODO: Implement\n",
    "\n",
    "    return pd.Series(np.matmul(BT, h_star), index=colnames(B))\n",
    "\n",
    "risk_exposures = get_risk_exposures(B, BT, h_star)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_portfolio_alpha_exposure(B_alpha, h_star):\n",
    "    \"\"\"\n",
    "    Calculate portfolio's Alpha Exposure\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    B_alpha : patsy.design_info.DesignMatrix \n",
    "        Matrix of Alpha Factors\n",
    "        \n",
    "    h_star: Numpy ndarray \n",
    "        optimized holdings\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    alpha_exposures : Pandas Series\n",
    "        Alpha Exposures\n",
    "    \"\"\"\n",
    "    \n",
    "    # TODO: Implement\n",
    "    \n",
    "    return pd.Series(np.matmul(B_alpha.transpose(), h_star), index = colnames(B_alpha))\n",
    "\n",
    "portfolio_alpha_exposure = get_portfolio_alpha_exposure(B_alpha, h_star)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transaction Costs (TODO)\n",
    "\n",
    "We can also use `h_star` to calculate our total transaction costs:\n",
    "$$\n",
    "\\mbox{tcost} = \\sum_i^{N} \\lambda_{i} (h_{i,t} - h_{i,t-1})^2\n",
    "$$\n",
    "\n",
    "In the cell below, implement the function `get_total_transaction_costs` that calculates the total transaction costs according to the equation above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_total_transaction_costs(h0, h_star, Lambda):\n",
    "    \"\"\"\n",
    "    Calculate Total Transaction Costs\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    h0 : Pandas Series\n",
    "        initial holdings (before optimization)\n",
    "        \n",
    "    h_star: Numpy ndarray \n",
    "        optimized holdings\n",
    "        \n",
    "    Lambda : Pandas Series  \n",
    "        Lambda\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    total_transaction_costs : float\n",
    "        Total Transaction Costs\n",
    "    \"\"\"\n",
    "    \n",
    "    # TODO: Implement\n",
    "    \n",
    "    return np.dot((h_star - h0)**2, Lambda)\n",
    "\n",
    "total_transaction_costs = get_total_transaction_costs(h0, h_star, Lambda)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Putting It All Together\n",
    "\n",
    "We can now take all the above functions we created above and use them to create a single function, `form_optimal_portfolio` that returns the optimal portfolio, the risk and alpha exposures, and the total transactions costs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def form_optimal_portfolio(df, previous, risk_aversion):\n",
    "    df = df.merge(previous, how = 'left', on = 'Barrid')\n",
    "    df = clean_nas(df)\n",
    "    df.loc[df['SpecRisk'] == 0]['SpecRisk'] = median(df['SpecRisk'])\n",
    "  \n",
    "    universe = get_universe(df)\n",
    "    date = str(int(universe['DataDate'][1]))\n",
    "  \n",
    "    all_factors = factors_from_names(list(universe))\n",
    "    risk_factors = setdiff(all_factors, alpha_factors)\n",
    "  \n",
    "    h0 = universe['h.opt.previous']\n",
    "  \n",
    "    B = model_matrix(get_formula(risk_factors, \"SpecRisk\"), universe)\n",
    "    BT = B.transpose()\n",
    "  \n",
    "    specVar = (0.01 * universe['SpecRisk']) ** 2\n",
    "    Fvar = diagonal_factor_cov(date, B)\n",
    "    \n",
    "    Lambda = get_lambda(universe)\n",
    "    B_alpha = get_B_alpha(alpha_factors, universe)\n",
    "    alpha_vec = get_alpha_vec(B_alpha)\n",
    "  \n",
    "    Q = np.matmul(scipy.linalg.sqrtm(Fvar), BT)\n",
    "    QT = Q.transpose()\n",
    "    \n",
    "    h_star = get_h_star(risk_aversion, Q, QT, specVar, alpha_vec, h0, Lambda)\n",
    "    opt_portfolio = pd.DataFrame(data = {\"Barrid\" : universe['Barrid'], \"h.opt\" : h_star})\n",
    "    \n",
    "    risk_exposures = get_risk_exposures(B, BT, h_star)\n",
    "    portfolio_alpha_exposure = get_portfolio_alpha_exposure(B_alpha, h_star)\n",
    "    total_transaction_costs = get_total_transaction_costs(h0, h_star, Lambda)\n",
    "  \n",
    "    return {\n",
    "        \"opt.portfolio\" : opt_portfolio, \n",
    "        \"risk.exposures\" : risk_exposures, \n",
    "        \"alpha.exposures\" : portfolio_alpha_exposure,\n",
    "        \"total.cost\" : total_transaction_costs}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build tradelist\n",
    "\n",
    "The trade list is the most recent optimal asset holdings minus the previous day's optimal holdings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_tradelist(prev_holdings, opt_result):\n",
    "    tmp = prev_holdings.merge(opt_result['opt.portfolio'], how='outer', on = 'Barrid')\n",
    "    tmp['h.opt.previous'] = np.nan_to_num(tmp['h.opt.previous'])\n",
    "    tmp['h.opt'] = np.nan_to_num(tmp['h.opt'])\n",
    "    return tmp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save optimal holdings as previous optimal holdings.\n",
    "\n",
    "As we walk through each day, we'll re-use the column for previous holdings by storing the \"current\" optimal holdings as the \"previous\" optimal holdings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_previous(result): \n",
    "    prev = result['opt.portfolio']\n",
    "    prev = prev.rename(index=str, columns={\"h.opt\": \"h.opt.previous\"}, copy=True, inplace=False)\n",
    "    return prev"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the backtest\n",
    "\n",
    "Walk through each day, calculating the optimal portfolio holdings and trade list.  This may take some time, but should finish sooner if you've chosen all the optimizations you learned in the lessons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Optimizing Portfolio: 100%|██████████| 252/252 [23:17<00:00,  5.54s/day]\n"
     ]
    }
   ],
   "source": [
    "trades = {}\n",
    "port = {}\n",
    "\n",
    "for dt in tqdm(my_dates, desc='Optimizing Portfolio', unit='day'):\n",
    "    date = dt.strftime('%Y%m%d')\n",
    "\n",
    "    result = form_optimal_portfolio(frames[date], previous_holdings, risk_aversion)\n",
    "    trades[date] = build_tradelist(previous_holdings, result)\n",
    "    port[date] = result\n",
    "    previous_holdings = convert_to_previous(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Profit-and-Loss (PnL) attribution (TODO)\n",
    "\n",
    "Profit and Loss is the aggregate realized daily returns of the assets, weighted by the optimal portfolio holdings chosen, and summed up to get the portfolio's profit and loss.\n",
    "\n",
    "The PnL attributed to the alpha factors equals the factor returns times factor exposures for the alpha factors.  \n",
    "\n",
    "$$\n",
    "\\mbox{PnL}_{alpha}= f \\times b_{alpha}\n",
    "$$\n",
    "\n",
    "Similarly, the PnL attributed to the risk factors equals the factor returns times factor exposures of the risk factors.\n",
    "\n",
    "$$\n",
    "\\mbox{PnL}_{risk} = f \\times b_{risk}\n",
    "$$\n",
    "\n",
    "In the code below, in the function `build_pnl_attribution` calculate the PnL attributed to the alpha factors, the PnL attributed to the risk factors, and attribution to cost. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "## assumes v, w are pandas Series \n",
    "def partial_dot_product(v, w):\n",
    "    common = v.index.intersection(w.index)\n",
    "    return np.sum(v[common] * w[common])\n",
    "\n",
    "def build_pnl_attribution(): \n",
    "\n",
    "    df = pd.DataFrame(index = my_dates)\n",
    "    \n",
    "    for dt in my_dates:\n",
    "        date = dt.strftime('%Y%m%d')\n",
    "\n",
    "        p = port[date]\n",
    "        fr = facret[date]\n",
    "\n",
    "        mf = p['opt.portfolio'].merge(frames[date], how = 'left', on = \"Barrid\")\n",
    "        \n",
    "        mf['DlyReturn'] = wins(mf['DlyReturn'], -0.5, 0.5)\n",
    "        df.at[dt,\"daily.pnl\"] = np.sum(mf['h.opt'] * mf['DlyReturn'])\n",
    "        \n",
    "        # TODO: Implement\n",
    "    \n",
    "        df.at[dt,\"attribution.alpha.pnl\"] = partial_dot_product(fr,p['alpha.exposures'])\n",
    "        df.at[dt,\"attribution.risk.pnl\"] = partial_dot_product(fr,p['risk.exposures'])\n",
    "        df.at[dt,\"attribution.cost\"] = p['total.cost']\n",
    "        \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEKCAYAAADEovgeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzsnXd8jlf7wL8nO5FEJIgRxJ6JkJi1aY0a1fKWao1Sr9d4O7106/y1pUu1vK1SWkrrpZSqnaJmYosVYoQQSWTJkHF+f5w7AxlPIk/m+X4+z+e+7+us6454rpxzrnNdQkqJRqPRaDTmxKKkFdBoNBpN+UcbG41Go9GYHW1sNBqNRmN2tLHRaDQajdnRxkaj0Wg0ZkcbG41Go9GYHW1sNBqNRmN2tLHRaDQajdnRxkaj0Wg0ZseqpBUoLVStWlV6enqWtBoajUZTpggMDIyQUlbLr542Ngaenp4EBASUtBoajUZTphBCXDKlnl5G02g0Go3Z0cZGo9FoNGZHGxuNRqPRmB29Z5MHKSkphIaGkpSUVNKqaEopdnZ2eHh4YG1tXdKqaDSlGm1s8iA0NBQnJyc8PT0RQpS0OppShpSSyMhIQkNDqV+/fkmro9GUavQyWh4kJSXh5uamDY0mR4QQuLm56ZmvRmMC2tjkgzY0mrzQvx8ajWloY6PRaDQVleR42DgTIs+bfShtbMoQs2bNYs6cObmWL1iwgKVLlwIwduxYVq1aZTZdUlNTcXFxMVv/Go2mGDj1O+yfD/HhZh9KOwiUIyZNmlTSKmg0mrJAQhTcvgmHlkCV+lC3o9mHNNvMRghhJ4Q4IIQ4KoQ4KYR4x5D/IIQIEUIcMT4+hlwIIeYKIYKFEMeEEG2z9TVGCHHO+IzJJvcVQhw32swVxgK6EMJVCLHFqL9FCFHFXO9pbj744AOaNm1Knz59OHPmDADfffcd7dq1o3Xr1jzxxBMkJCQAOc98tm3bxtChQzOft2zZwuOPP37fOF26dOGFF16gU6dOeHl5ZYbueeONNxg/fjzdu3enQYMGfP311+Z6VY1GUxz4fwyf1Iev28PlvdBmFBTD3qM5ZzbJQC8pZbwQwhrYLYTYaJRNl1Leu8bTH2hsfDoA84EOQghX4G3AD5BAoBBinZTyllFnIrAP+APoB2wEZgLbpJQfCSFmGs8zHuRl3vn9JEHXYh+ki/toUcuZtwe1zLU8MDCQFStWcPjwYVJTU2nbti2+vr48/vjjPPfcc4AyBt9//z3Tpk3LsY9evXoxZcoUbt68SbVq1Vi8eDHjxo3LsW5ycjJ79+5l+/btTJgwgSNHjgBw9uxZtm3bRnR0NM2bN9czKI2mrJKeBoE/gEc76DAJHKtDHfPPasCMMxupiDcerY2PzKPJEGCp0W4f4CKEqAn0BbZIKaMMA7MF6GeUOUsp90opJbAUeCxbX0uM+yXZ5GWKXbt2MXToUBwcHHB2dmbw4MEAnDhxgq5du+Ll5cWyZcs4efJkrn0IIXjmmWf46aefiI6OZu/evfTv3z/HuiNHjgSUgQoPDyc+Xv3zDRw4EBsbG6pXr46rqys3b94s4jfVaDTFwsXdEHcNOk4Gr2FQvxtY2RTL0GbdsxFCWAKBQCPgaynlfiHEv4APhBBvAduAmVLKZKA2cCVb81BDlpc8NAc5gLuUMgxAShkmhKj+oO+S1wzEnOTkWjt27Fh+++03WrduzQ8//IC/v3+efYwbN45BgwZhZ2fH8OHDsbLK+Z/93rEynm1tbTNllpaWpKamFvAtNBpNqeDCDrCwgiZ9i31os3qjSSnTpJQ+gAfQXgjRCngVaAa0A1zJWt7KadFQFkJuMkKIiUKIACFEQGn8a71bt26sWbOGxMRE4uLi+P333wGIi4ujZs2apKSksGzZsnz7qVWrFrVq1eL9999n7NixudZbuXIlAP7+/ri7u1OpUqUieQ+NRlNKCA2AGl5gU/z/t4vFG01KGS2E8Af6SSkzdrCThRCLgVeM51CgTrZmHsA1Q97jHrm/IffIoT7ADSFETWNWUxPI0a9PSvkt8C2An59fgQxVcdC2bVuefPJJfHx8qFevHl27dgXgvffeo0OHDtSrVw8vLy/i4uLy7WvUqFHcvHmTFi1aZMrGjRvH888/j4+PDwDOzs507tyZuLg4Fi9ebJ6X0mg05udOAhz+Sd1XcoNK1dQ+zdVAaPNMiagk1HaHGToWohqQYhgae2Az8DEQaBgBAXwOJEkpZwohHgWmAgNQDgJzpZTtDQeBQCDDO+0Q4CuljBJCHASmAftRDgJfSSn/EELMBiKzOQi4Sin/k5e+fn5+8t7kaadOnaJ58+ZF8vMoaaZOnUqbNm0YP358juVdunRh3rx5mYZHYzrl6fdEUwZJSwFLIxBs+GmwtoNt78GJe3ywqreA8CB44nu1X1NECCECpZR++dUz58ymJrDE2LexAH6RUq4XQmw3DJEAjgAZrk1/oAxNMJAAjAMwjMp7wEGj3rtSyijj/l/AD4A9ygstw9vtI+AXIcR44DIw3GxvWQbw9fWlUqVKfPrppyWtikajKUo2zoCDC8FvPNwKgXObwcoOUpOg5xvgOxYSIuDIctgzFyrXgcaPlIiqZpvZlDXK+8xGYz7074mmRLhzGz6slfXs4KaMS8BiqNsJnvwJLIxt+ZQk2PwG+IyE2r5FqkZpmNloNBqNxlxEBqvrE9+DvQvU7Qw2DtDlJbB2yDI0oJbWHs091FVxoI2NRqPRlEUizqlr9RbgnuX4g61jyeiTDzoQp0aj0ZRFIs4BAlwblLQmJqGNjUaj0ZRFIs5AlXpqiawMoI1NGeXDDz/MvI+Ojuabb77Js37nzp0BdWBz4MCBBRrrt99+IygoKPP5rbfeYuvWrQXqo6A4Oua/FGBKnaIkvxQPGk2xcWq9Sg9QO999+VKDNjZlFFONTVpaGgB79uwp9Fj3Gpt3332XPn36FLo/jUZTABJvQfTlrOc7t2HDS+DeCgZ+VnJ6FRBtbMoAjz32GL6+vrRs2ZJvv/2WmTNnkpiYiI+PD6NGjWLmzJmcP38eHx8fpk+fjr+/Pz179uSpp57Cy8sLuHsWEBsby9ChQ2nRogWTJk0iPT39vjqrVq1i7Nix7Nmzh3Xr1jF9+nR8fHw4f/78XYnZtm3bRps2bfDy8uLZZ58lOTkZAE9PT95++23atm2Ll5cXp0+fvu+94uPj6d27d2adtWvX3lfH39+fbt265agvwOuvv07r1q3p2LEjN27cAOD333+nQ4cOtGnThj59+mTKTe3X0dExx341mhLhtymw8GEVsRlg33yIvwH9PwG7yiWrWwHQ3mimsnEmXD9etH3W8IL+H+VbbdGiRbi6upKYmEi7du3466+/mDdvXmYKgIsXL3LixInMZ39/fw4cOMCJEyeoX7/+ff0dOHCAoKAg6tWrR79+/Vi9ejXDhuV8orhz584MHjyYgQMH3lcnKSmJsWPHsm3bNpo0acLo0aOZP38+L7zwAgBVq1bl0KFDfPPNN8yZM4eFCxfe1d7Ozo41a9bg7OxMREQEHTt2ZPDgwfcFBM1N39u3b9OxY0c++OAD/vOf//Ddd9/xxhtv0KVLF/bt24cQgoULF/LJJ5/keKC1oP1qNMVO/E04twnSU+HS32o28/eX0HQA1O1Q0toVCD2zKQPMnTs386/sK1eucO7cuXzbtG/fPkdDk1HWoEEDLC0tGTlyJLt37y6UXmfOnKF+/fo0adIEgDFjxrBz587M8owkbb6+vly8ePG+9lJKXnvtNby9venTpw9Xr17NcRaRm742NjaZ+0/ZxwgNDaVv3754eXkxe/bsXFMwFLRfjabYSEmEoyvh5yeVobGwhuOrYNencCceer9V0hoWGD2zMRUTZiDmwN/fn61bt7J3714cHBzo0aMHSUlJ+bbLK2JzbqkEsstNGSO/6BMZqQlyS0uwbNkybt68SWBgINbW1nh6euY4bm76WltbZ95nH2PatGm89NJLDB48GH9/f2bNmpWjfgXtV6MpFtJSYEFXiDyn3JoHfgFhR1TSMwCfUVC97EWs0DObUk5MTAxVqlTBwcGB06dPs2/fPkB9IaakpADg5ORkUuTnDA4cOEBISAjp6emsXLmSLl26AODu7s6pU6dIT09nzZo1mfVz679Zs2ZcvHiR4GB1kvnHH3+ke/fuBXq36tWrY21tzY4dO7h06VKB9M2r39q1VWqjJUuW5FqvoP1qNGYl5iqc3QwhfylD8+hnMDUQ/MZBr7fAsYaKEtDnnZLWtFBoY1PK6devH6mpqXh7e/Pmm2/SsaNK4Tpx4kS8vb0ZNWoUbm5uPPTQQ7Rq1Yrp06fn22enTp2YOXMmrVq1on79+gwdOhSAjz76iIEDB9KrVy9q1qyZWX/EiBHMnj2bNm3acP78+Uy5nZ0dixcvZvjw4Xh5eWFhYZFvyuiAgAAmTJgAqLQHAQEB+Pn5sWzZMpo1a1YgfXNj1qxZDB8+nK5du1K1atUcxy5MvxqNWUiMhn0LYG4bWD4cVowCW2do83RWyJlKbvDCcRj3BzhWK1l9C4kOxGmgA3GWTvz9/ZkzZw7r168vtf3q3xNNoUhPh+3vwv7/QkoC1GoL0ZcgIRK6TYdeZcMpRQfi1Gg0mtJKejqsfwEOLQGv4dBpKtTyUY4ByXHg+MCZ7Esd2thoSjU9evSgR48eZaZfjcYktrypDE3Xl6HXm5DhrGJtrz7lEG1sNBqNprg4sxF+fwHir0O75+42NOUc7SCg0Wg05iI0AOY0hdhr4P8R/DxCLZH1nw39/q/CGBrQMxuNRqMxH/sXqFnMZ4YDSeuRMPDzcrtUlhdmm9kIIeyEEAeEEEeFECeFEO8Y8vpCiP1CiHNCiJVCCBtDbms8Bxvlntn6etWQnxFC9M0m72fIgoUQM7PJcxxDo9FoipdsMxe/Z+Gx+RXS0IB5l9GSgV5SytaAD9BPCNER+Bj4XErZGLgFjDfqjwduSSkbAZ8b9RBCtABGAC2BfsA3QghLIYQl8DXQH2gBjDTqkscY5YbymmIgQ8/cMEdagcL8TDQak4g4k3Xf47UKtWx2L2YzNlIRbzxaGx8J9AJWGfIlwGPG/RDjGaO8t1AxQ4YAK6SUyVLKECAYaG98gqWUF6SUd4AVwBCjTW5jlBvKW4qBotBToylREqLUNSUJwo7Byd8g7Ci0nwgzLpXZw5hFhVkdBIwZyBEgHNgCnAeipZQZwaZCgdrGfW3gCoBRHgO4ZZff0yY3uVseY5RJymuKgbz0DAsLo1u3bvj4+NCqVSt27dp1V9uIiAg6derEhg0b7uvX0dGRl19+mbZt29K7d29u3rwJKHfnGTNm0L59e5o0aXJfnxpNvlw/DvHh98sv+MMn9eGX0fBhTfhvV/h1jCqr1gzsXYpVTVNJSUsn6FosaenmP9xvVgcBKWUa4COEcAHWADkds854y5zmlzIPeU6GMq/69yGEmAhMBKhbt25OVTL5+MDHnI66/wvzQWjm2owZ7WfkW6+8phjI0CUnPZcvX07fvn15/fXXSUtLIyEhIbPsxo0bDB48mPfff5+HH374vj5v375N27Zt+fTTT3n33Xd55513mDdvHgCpqakcOHCAP/74g3feecfsGUc15QgpYUEXsHaA18PuLtv9hboGrQXXhur0v60zHPkJmvYvfl1N5PjVGB7/Zg/zR7Wlv1fN/Bs8AMXi+iyljAb8gY6AixAiw8h5ANeM+1CgDoBRXhmIyi6/p01u8og8xrhXr2+llH5SSr9q1UrvFLe8phjIS8927dqxePFiZs2axfHjx3FycgIgJSWF3r1788knn+RoaAAsLCx48sknAXj66afvej9TdNJo7iLxlrrGXlXXlASICskqDw2ECzuynls9Aa0eh8Z9YPgP4Fyr2FQtKAdD1NKfn6er2ccy28xGCFENSJFSRgsh7IE+qI37HcAw1B7LGCAjPeM643mvUb5dSimFEOuA5UKIz4BaQGPgAGoG01gIUR+4inIieMpok9sYhcaUGYg5KM8pBvLSs1u3buzcuZMNGzbwzDPPMH36dEaPHo2VlRW+vr5s2rTJ5AjT2d/LFJ00mkwu/AVLh6iT/h7tsuR75oLP03D2Tzi6AhzdwXcs/PUxNM75j6DSyIGQKBpUrUQ1J1uzj2XOmU1NYIcQ4hhwENgipVwPzABeEkIEo/ZXvjfqfw+4GfKXgJkAUsqTwC9AEPAnMEVKmWbsyUwFNgGngF+MuuQxRpmjPKcYyItLly5RvXp1nnvuOcaPH8+hQ4cAZTgWLVrE6dOn+eijnHMMpaenZ+4pLV++XKcO0BSevfOUB9muOfCncbrCewQELIKFvZTcuSY8/h10/jcMW3S3USrFhMUkcvBiFO2KYVYDZpzZSCmPAW1ykF9AeZLdK08ChufS1wfABznI/wD+MHWMski/fv1YsGAB3t7eNG3a9L4UA23btmXZsmWZKQb69+/Po48+mmefGaH1jx8/Trdu3e5LMVCnTh1atWpFfLxyJhwxYgTPPfccc+fOzfwSh7tTDKSmptKuXTuTUgwsWLAgx/2b7Pj7+zN79mysra1xdHRk6dKlmWWWlpasWLGCQYMG4ezszOTJk/Hx8cncs6pUqRInT57E19eXypUrs3LlyjzH0mhyJOYqnNsM3WeoSMwHF4JLPej7AQgL8HxIpWd2yPZl3eqJktPXRFLS0lm0O4Qvt50jLV0ytG3x+E/pFAMGOsVA+cHR0THTUBYH+veklBJ+Sl2zZ7UMPwVb3wEndzUTcakLqclgm8P5rcAf4PfnYfI+5VH295fKq8x3bHFobxauRCUwfslBzt6Ip0/z6rw9qCV1XB0eqE+dYkCj0VRcpIRl/1Cb+l1eULMTKeGnJ9QG/50EOLQUrOzUBv7UgPsPXJ7bApXrKEMjhOqnjPON/3kuRyXw3Wg/Hm7hXqxja2OjKXcU56xGU0q5fgxiLkMNb9j1qYq2XKe9Mj6j10G1prDvGzVbiQyGm6fvngFd3A1nN6mUzGXo1H/GeRlLiyydb8Yl8+eJMJrVdGb90WsMaFWz2A0NaGOj0WjKG9dPwO7P1b7KM2vgaiCs+7daFvP6BzQwnFgefhfaTYAvvCBwCZxaBxaW6pzMlf3gWh96vl6ir2Iq6emS345cZc6mMzjbW/PB0FZci05izeGr/HX25l2HNp/qkPeZQnOhjY1GoykfpKfBxv+ojXyEChNTqSo06QtT9kN4ENTtdHcbl7rg1gj2zwcbJ1U36gLUewiGfF1qT/5nEHX7Dk/+dy9JqWlciUqkZS1nrkQl8MT8vQDUcLZjYrcG9GxancV/hzCoda1iOVOTE9rYaDSass+dBPjfBDizATpOgU6TobJHVrm9C9TLJcjr49/B3q+h5WPQfFDx6FtE/Lj3EufC42lU3ZEvnvRhcOtaxCSmsCs4glqV7WhTt0rmklr7+iVjZDLQxkaj0ZRtbkfA8ifVctmAOdD+uYK1r90WhpXNo3jLD1yiR9Nq/DAu66RHlUo2DG5d+qIW6EydZZTymmKgoPj7++tI0RWdrbNUgMwnfyq4oSnD3Lp9hxuxyXRpVLWkVTEJbWzKKOUtxUBh0cZGw62LanbSvGLlJLoQcRuABtVyD01VmtDGpgxQXlMMAHzyySd4eXnRunVrZs5U4UCOHDlCx44d8fb2ZujQody6pQIhzp07lxYtWuDt7c2IESO4ePEiCxYs4PPPP8fHx0enDKio3L6pHAEqGCGGsalftegTCpoDvWdjItc//JDkU0WbYsC2eTNqvPZavvXKa4qBjRs38ttvv7F//34cHByIilIRaEePHs1XX31F9+7deeutt3jnnXf44osv+OijjwgJCcHW1pbo6GhcXFyYNGkSjo6OvPLKK/n+HDXllPhw5T1WwQiJiMfKQuBRpWykmdYzmzJAeU0xsHXrVsaNG4eDgwqX4erqSkxMDNHR0ZkBPbP36e3tzahRo/jpp5+wstJ/J2mAtFRIjIJKpTdFiLkIibhNXVcHrC3Lxte4/h9rIqbMQMxBeU4xIKW8T5e82LBhAzt37mTdunW89957nDx5Mv9GmvJNQoS6VrCUy9EJd9h9LoJuTcrOe5cNk1iBKc8pBh555BEWLVqUmYUzKiqKypUrU6VKlcz9l4w+09PTuXLlCj179uSTTz4hOjqa+Pj4Ar+7ppyRkaK5HM9som7fITg8KwRTUkoaM/93nPjkVKb2alSCmhUMbWxKOf369SM1NRVvb2/efPPN+1IMjBo1Cjc3t8wUA9OnT8+3z4wUA61ataJ+/fr3pRjo1asXNWtmpYgdMWIEs2fPpk2bNpw/fz5Tnj3FgJeXFxYWFialGJgwYULmuw0ePBg/Pz98fHyYM2cOAEuWLGH69Ol4e3tz5MgR3nrrLdLS0nj66afx8vKiTZs2vPjii7i4uDBo0CDWrFmjHQQqKrdvqmul6iWrh5mQUjJu8QEGfbWbq9GJXI1OZNiCPWwKus7M/s1oVsO5pFU0GZ1iwECnGNAUFv17UoIcXQFr/glTA6Fq2fkrPz/iklLYez6SzUE3WBUYCkA7zyqERNwmKSWdL570oU8JBNPMCZ1iQKPRlB9SkgAJ1vaQlgL+H0GTfnDlgCovB3s2p6/H8tbak1R3suXw5WiuRifiYGPJ0Da18a1XhTd+O0FVR1t+m9KZRtWdSlrdAqONjUajKd1EX4GvfCE9FaYehJ2z4ejPKiUzQNNHwbbsLCdlZ+2Rq9y6fYeHW9bgvfVBHAiJyiybPcybIT61sbFSux2ulWxoXtOZ+lXLxiHOezHbno0Qoo4QYocQ4pQQ4qQQ4nlDPksIcVUIccT4DMjW5lUhRLAQ4owQom82eT9DFiyEmJlNXl8IsV8IcU4IsVIIYWPIbY3nYKPcs7DvoZcZNXmhfz+KgdCDkJYMMk0lPzv6M7R5WiU2e/g9GLGsTOWcyeDPE9d5fsURZv0exEMfbefv4Egm92iInbUFdVzteaKtR6ahARjgVbPMGhow78wmFXhZSnlICOEEBAohthhln0sp52SvLIRoAYwAWgK1gK1CiCZG8dfAw0AocFAIsU5KGQR8bPS1QgixABgPzDeut6SUjYQQI4x6Txb0Bezs7IiMjMTNza1ALrqaioGUksjISOzs7EpalfJNeBAIS/B8CEJ2QtsxMOjLMmlgMjh9PZaXfjmCTx0XPn7Cmx1nwjl7PY5/9WhIq9qVcbG3xsKi7L5fTpjN2Egpw4Aw4z5OCHEKqJ1HkyHACillMhAihAgGMkKZBkspLwAIIVYAQ4z+egFPGXWWALNQxmaIcQ+wCpgnhBCygH+Genh4EBoays2bNwvSTFOBsLOzw8PDI/+KmsJzI0jlnOn3MZzeAF1eLLOGJi1dsvpQKJ9uPoujrRX/fcYXd2c7mtbI2oMZ4FUzjx7KLsWyZ2MsY7UB9gMPAVOFEKOBANTs5xbKEO3L1iyULON05R55B8ANiJZSpuZQv3ZGGyllqhAixqgfURC9ra2tcz2Fr9FoiokbJ1SgTfcW6lNGSUpJ4/kVh9l08ga1XexZPKYd7s4VZ1Zs9nM2QghH4H/AC1LKWNTMoyHgg5r5fJpRNYfmshDyvPq6V7eJQogAIUSAnr1oNKWQ+JsQfQncW5W0Jg9EdMIdnl64n81BN3hrYAt2z+hJ85pl06mhsJh1ZiOEsEYZmmVSytUAUsob2cq/A9Ybj6FAnWzNPYBrxn1O8gjARQhhZcxustfP6CtUCGEFVAaiuAcp5bfAt6DO2RT+TTUajVk484e6Numbd71SyomrMby25jj21pYcC43hq5FtGOhd+hKbFQfm9EYTwPfAKSnlZ9nk2RckhwInjPt1wAjDk6w+0Bg4ABwEGhueZzYoJ4J1xv7LDiAjFPEYYG22vsYY98OA7QXdr9FoNLlw7QicXJN/vQclLRWO/woudcvszOaXgCscC41hf0gUozvVq7CGBsw7s3kIeAY4LoQ4YsheA0YKIXxQy1oXgX8CSClPCiF+AYJQnmxTpJRpAEKIqcAmwBJYJKXMiMA4A1ghhHgfOIwybhjXHw0ngyiUgdJoNA9CcjzsXwDb31PP9buDg5ny2ifeglXPwsVd8MgHZdYhIPufuIN9Kq6hAROMjRDCFngC8MxeX0r5bl7tpJS7yXnv5I882nwAfJCD/I+c2hkeau1zkCcBw/PST6PRFJAjy7IMDUDQb+D3rLo/9CMEb4Vhi8HiARdMYq/BDwMh+jIMmgu+Y/JvU0q5HKWCzI7pVA+v2pVLWJuSxZSZzVogBggEks2rjkajKbWc+l1dB8yBgwthyyxIT1MGZ91Uo85j0HLog41z4DuV6nnsBqjX6cH6KmGuRCUwwKsG7wwpm8uARYkpxsZDStnP7JpoNJrSx9nNsPcriA2DyGDoNh3aPwcNe8H6F+GPVyBgUVb9/d8+mLGREk6uhgbdy7yhSUuXhN5K5OGWpSNgZkljynx3jxDCy+yaaDSa0sfeeRB2TJ1v6TQF2j2n5G4NYfRaGLZI7a8IC2jSH8KOqtlOQZASbpyExY/C1x3UrKbVE0X+KsWJlJLAS7e4k5ZOXVeHklanVGDKzKYLMFYIEYJaRhOAlFJ6m1UzjUZTsqSnK8+zVo/DoC/uLxdCGYXGj6hgmWFH4OxGNQO6tAdC/oKh34KVTc79H14G57fBxb8h/jrYVgb3lmr25F22fHoi45N5dfVxRnaoy+pDV9l/IZLwuGScbK3o3LBqSatXKjDF2PQ3uxYajab0kBClZhtJ0ZAcA7Xa5F3f1sk42W+4Xi1/Em6FqPvO06C27/1t4q7D2snqvtUw8OyiUgY4l81QLcv3X2Zz0A02B93AydaKns2q06GBKwNa1aRKpVyMbQUjX2MjpbwkhGgNdDVEu6SUR82rlkajKXakVBv/m16DtDvQ8nElr93WtPZVm4K1A8Rehc7/hj1zYc2/oO0zyuhkJ/yUuo5ep/ZnyjBxSSn8fOAyQqgf4ZuDWvAPvzr5N6xg5LtnY6QGWAZUNz4/CSGm5d1Ko9GUKZJiYOXTasPfs6vagzm5GhzcoJqJWUgtreDp1TBpN/R5ByysIeIMbH7j/ro3z6hrtWZF9w4lQNC1WEZ8u4/wuGTmjWzLmwNb8HjEq9yQAAAgAElEQVSbvOINV1xMWUYbD3SQUt4GEEJ8DOwFvjKnYhqNphjZN19FVO77IXT4lzIQ+75W4fwtC3D2O7sHWXpK1n3sNXCupTJrbn4TruwD+yrgWL3o3qEYOHE1hmpOtjjbWfPFtrMs3BWCi701/33Gl97NtddZXpjyWySA7O4laeR8WFOj0ZRVrgZC9ebK4wzAbxxcO6zcnAtLuwlqWQ7UGZ3QADj+C1jZK1nirTIVGSAtXTLwq90AVHOy5WZcMiPa1WFm/2a4OOh9mfwwxdgsBvYLITKCIT1GVlgYjUZTHgg7Bg17Zj1XbQzPbnywPvvPhl5vwsf1YON/wNIWur6iDNqXraHd+AfrvxhITUtn66kbPNSoKhcjEjLl7s62zBvZhg4N3EpQu7KFKQ4Cnwkh/FEu0AIYJ6U8bG7FNBpNMZB4CxYPUK7HNYr4NIOFBdi7QP9PID5cOQpU8VRlMy6ChWXRjncPn24+g6WF4PnejQudaXfJ3ku8tz4It0o2eHuocDM7p/ekjqu9zt5bQHI1NkIIZyllrBDCFRUw82K2Mlcp5X0h+zUaTRnjzJ8q7TJAzdbmGaPDP++XmdnQXItO5OsdwaRLcLS1YkLXBgXu43ZyKvO2n6NtXResLCzYceYmnm4O1HXThzQLQ14zm+XAQFRMtOzh+YXxXPB/PY1GU7oI3qL2UB6dA3XLdniY7CzZcxEJPNTIjQ/+OMWthDuERNxmuG8dujSuirVl/sFT1h65xq2EFL4b0BzfelXYcSacyvZ6b6aw5GpspJQDjavOi6zRlEfS0yF4m4oQ0ObpktamyNh59ibf7rrA4208eP+xVoz4bh9f7ziPtaVga1A4bo42eLpV4osRPrmmZZZS8uO+SzSr4YRvvSoIIejVTHubPQimnLPZZopMo9GUMSKDVZSAep1LWpMiI+FOKq//dpyG1Rx5/7FW2NtYsnC0Hy8/3IT//aszqenp3IhN4siVaAZ8uYudZ3NOB78l6AanwmJ5tkt9vTdTROS1Z2MHOABVhRBVyHJ3dgYqdhYgjaY8cO2QuuYUTqaMkZyaxqaTN/hmRzBXohL5+bmO2NuofaFqTrZM690YgGm9GmNnbUmf5tWZuvwwoxcdYHrfpkzp2Sizr/R0yedbz+Hp5qAPaBYhee3Z/BN4AWVYDmWTxwJfm1MpjUZjRhJvgZWdOltjXQmqNilpjR6ILUE3+M+qo9xKSMGjij3fj/GjU8OcXZJffDjrXX+b8hAvrjzCZ1vO0q9VDWasOoZEORScCovl8ydbY2XC3o7GNPLas/kS+FIIMU1KqaMFaDRlnaRY+PExZWQyqPeQ2T3DzM1P+y5hZ23J0mfb0KVRVSwsTFv2srex5JW+Tfnz5HX6fbGTlDRJe09XLkTE07GBK4Nb61lNUWLKoc4YIcToe4VSyqV5NRJC1AGWAjWAdOBbKeWXhiv1SlSa6YvAP6SUt4RaGP0SGAAkAGOllIeMvsYAGQGW3pdSLjHkvsAPgD0qbfTzUkqZ2xgmvKtGU34J2akMTedpYO8KyXHQtOwHdb8WnYi3R2W6NalW4LaNqjvSsYEr+y5E0aNpNX4Yd1+WeU0RYYqxaZft3g7ojVpWy9PYAKnAy1LKQ0IIJyBQCLEFGAtsk1J+JISYCcwEZqBSGTQ2Ph2A+UAHw3C8DfihXK4DhRDrDOMxH5gI7EMZm37ARqPPnMbQaMo/q8ZDSqJyAPAZCZ2mgqW1MjQWVtDzdbC2L2ktiwQpJdeiE+nSuPA5Y74f0459FyLxMg5tasyDKREE7orwLISoDPxoQrswIMy4jxNCnAJqA0OAHka1JYA/yhAMAZZKKSWwTwjhIoSoadTdknGI1DBY/YyoBs5Syr2GfCkqlM7GPMbQaMofGcnHLG3BwRVOrFJyBzfYOguOr4JHP4OrASo5WTkxNACxiancvpNGbZfCv1MlWysdRLMYKEA410wSULMPkxFCeAJtgP2Au2GIkFKGCSEywr7WBq5kaxZqyPKSh+YgJ48xNJryRXw4LBkIMv1u+eCvwOsf6tDmH9Nh0SNK7lf645EVhGsxiQDUegBjoyke8jU2QojfyYogYAk0B34xdQAhhCPwP+AFI/xNrlVzkMlCyE1GCDERtQxH3bp1C9JUoykdXNqjDM3wH1TI/qVDlNxrOFjbQfNB0KCHSsF8K6T8GZtoZWxqVs75cKam9GDKzGZOtvtU4JKUMjS3ytkRQlijDM0yKeVqQ3xDCFHTmHHUBMINeSiQPb2dB3DNkPe4R+5vyD1yqJ/XGHchpfwW+BbAz8+vQIZKoykVXPpbZcdsNlDty/g9qzb+sy+V2TpBx0klp6MZyTA2D7KMpike8nUil1L+BZwBKgOuKIOTL4Z32ffAKSnlZ9mK1gFjjPsxwNps8tFC0RGIMZbCNgGPCCGqGIdLHwE2GWVxQoiOxlij7+krpzE0mvLBuS0q5fKZP6FOe2VoAAZ+Dk8sLFndioHEO2lIKTl8ORonOyuqOtqWtEqafDBlGW0C8BawHbV09ZUQ4l0p5aJ8mj4EPAMcF0IcMWSvAR8BvwghxgOXgeFG2R8ot+dg1L7QOAApZZQQ4j3goFHv3WwRp/9FluvzRuNDHmNoNGWf9HTY8DJEX1KzmiHzSlqjYmX/hUjG/XCQyT0asunkdQZ61zL5bI2m5BDK+SuPCkKcATpLKSONZzdgj5SyaTHoV2z4+fnJgICAklZDUxaRsvgyTibegp1zYO886P02tBwKrhUjVm5kfDJXbiUy6rt93L6TlTx42YQOPNSo8K7PmgdDCBEopfTLr54pezahQFy25zju9g7TaCouf/wHruyD8VvAysxLOYFLYPObkBwD3iPU4cyM5bNyzmebzzB3ezD21pZUc7JlQH1Xfg0MpbK9NZ10tswyQV6BOF8ybq+i0kKvRXl7DQEOFINuGk3pJiEKDvxX3W99B2p6q416W8fC9XcjCPbPhwGfgtU9eVPS0+HPV6F6cxj0JdRo9WC6lyHm+59n7vZgmro7AbBwjB+XoxL4NTCUAV419BJaGSGvmY2TcT1vfDLQm+0aDcCR5epapwPsM2LTdnkR+swqXH/b34czG6BBT5VjJjsxVyDltkqtXIEMzY3YJD7+8zQDvGrw5Yg2mUnPPKrYM3dkGx7WhzHLDHkF4nynOBXRaMoU6ekQsEgZmrF/wK5PYffnEPgDdPsP2BQidXBGQMwT/7vf2Nw8ra7Vmj2Q2mWNv86ofDPTejW+K7umEILBrXWmk7JErq7PQogvjOvvQoh1936KT0WNphQS8hdEnVeHJC2toMcMePp/agP/2MrC9XkrRF3P/glx1+8uyzQ25covJ1/8z4bj7mxLsxpO+VfWlGryWkbLiH82J486Gk3FJOB7FTm5xZAsWb3OUMMb9s0H37F5e6id36HCyLQcCvU6Qa22EHkeGveFc5tVHw9nW1y4fgIca6goARWEHWfC+fPEdZ7pWE9nyywH5LWMFiiEsASek1KWnwTlGs2DEn0FTv8BnaaokDAZCAEdJ8Nvk+D8dmjUO/c+grdC5DnY+cnd8sYPqyW4v79Qs5v+H8OpdXD8F2j9lHnepxQSHB7Hv5cfpmkNZ/7Tr2ItHZZX8owgIKVMA6oJIWzyqqfRVCh2fKBC9befeH9Zq8ehUnXYvyBLFp9DnvuoC1CtOcy4BM+sAc+uSu7eEh7/DrrPhOO/wvzOsOVtleRs0BfmeZ9SRnTCHcYvCcDW2pKFY/yoZFuYeMGa0oYp/4oXgb+NfZrbGcJ7QtBoNOWPk2vAqSbU7ZglizwPR1dA56ngUuf+Nla20G4C+H8I14+r2cmyYfDUL9Ck7939VG0M9i7QsBfU7wHXj0HN1mqG1PNVaPIIrP4nxF5VHm7mPsdTSpiz+QxXbyWy8p+ddMyzcoQpxuaa8bEgyx1aB63UlG+khF/HqvtZMVnyfd+og5SdpuXYDFDBMP0/hAVdsmTrX1KG5PZNtZ9zK+Ru42NhAbV87u6nti9M2gVRIeDe4kHfqExwJSqBnw9cYVSHuvjWqzj7UxUBU4xNkJTy1+wCIYSONaYp32R4hoGKomzrBKnJcOwXaPk4OOVxvsOxmjp4+fvzWbL0FLh1EdLuwNrJSubWMH89rO0rjKEB+PPEddLSJc91bVDSqmiKmHyjPgOvmijTaMoP145k3R9cCGFHIWgtJMeC17D82/uOhWc3q/s+s+CVszB5D0z0Bzcj92D1lkWqsrm5HpPEq6uPEZOQYrYxtgTdoFkNJ+q4FuKckqZUk1e4mv6oKMy1hRBzsxU5Y2KaAY2m1JOSqMLOVK6dJZMSwgxjY11JpVbeOks921WG+t1N67tuB/jXHqia7WyMrSNM3gc3jkOtNkXxBsXC7eRU/v3zYQ5cjMKjigNTejYq0v6llMzZfIYDF6N4sU+TIu1bUzrIaxntGhAADAYCs8njgBfNqZRGU2xseAWO/AQzLytDcnwVbHkLhAV4tIdRv6rDmzFX1UZ9tab3xy3LC/ccZi+WVqXW0KSmpbMy4ArbToXz2oBmJNxJ47MtZ9lzPpI7qSr19IqDlxn3kCcONkXjJZacmsb//XGaH/Zc5Em/Ovyzu15CK4/kdc7mKHBUCOEupVySvUwI8TzwpbmV02jMzqW/1fXkGhWT7PcX4I4R5LzXG8pbrLav+pRzTlyN4dXVxzl+VTlENKhaib/PR3IjNomnO9Tj4Rbu3ElLZ9ziA0xdfphFY9sVeqyUtHSmLDtEq9qVWX/sGmdvxDO2sydvD2qhD3CWU0z502QEcM/JM8aijY2mPOBcSzkDBCxSm/8AXV+GkJ3KEaCCsCXoBpN+CqSKgw1fP9WWFQcvs3C3cpJ477FWPNOxXmbdyT0a8bV/MNEJd3BxKNwRvDPX49gcdIPNQTdwd7Zl8dh29GxWvUjeRVM6yWvPZiTwFFD/nlhozkCkuRXTaIqF2GvqGnZUXR+bDz4V56R+Bj/tu0TNynZsmNaVyg7WXI9NYte5CGytLBjic3fAy+5NqzFvRzD7Q6Lo27JGocY7YcyepvVqxIQuDajsUDHy8lRk8prZ7AHCgKrAp9nkccBRcyql0RQLUqpDlx0mweW9KqJy65ElrVWxE5uUwp7zEYx7qH7ml/4wXw9iEu7wj3Z1cLa72xB4e1TG1sqClQevYCkETdydqOtmuvfY2RtxrAy4gpOtFS/2aaLz0VQQcnV9llJeklL6Syk7SSn/yvgA9sDc3NplIIRYJIQIF0KcyCabJYS4KoQ4YnwGZCt7VQgRLIQ4I4Tom03ez5AFCyFmZpPXF0LsF0KcE0KszAipI4SwNZ6DjXLPgv5QNGWAG0GwZhKEHcuSpd6BpUNgTlPY8DIELM4qS0uBa4fv7iMpGlIToXIdeG4HPP5t8aV3LiXEJaXwzML9pKTJu2Yple2teemRpnhUud+I2FpZ0qeFO9tPhzNhaQA95uxg17kcQvLkwL4LkTz29d8cvhxNjcp22tBUIEw5Z4MQwkcI8YkQ4iLwPnDahGY/AP1ykH8upfQxPn8Y/bdA7Q21NNp8I4SwNAKBfg30B1oAI426AB8bfTUGbgHjDfl44JaUshHwuVFPU9rZOQd+GAi3I/Kve+c2LO4PR39WBiclUcmvH4cL/uoA5cGFsP4FFRYGVGDLb3uo6MkZxIapq3PNrFwyBWTx3yG8vfZE/hVLKb8GhHI0NIbZw7wLdGJ/3sg2BLzRh9WTO1Ozsj0z/3ecAV/u4rU1x++rezMumaSUNPaej2Tc4oPUcrHnMZ9aTO1VtO7TmtJNXns2TVAGYCRqj2YlIKSUPU3pWEq5swCziiHACillMhAihAgG2htlwVLKC4ZOK4AhQohTQC/UnhLAEmAWMN/oa5YhXwXME0IIKaUOsVNaSU2G7e+p+43/gWGLssqSYkBYqsCXgYvBzgUig9Ws5KHn4e8vVbDKET/DtUOqzcS/lPH4wksZnT7vwIGFqmzvPBgwR513iTP2a5wKl4QrOuEOszedITEljX/3boybY9mKXSal5Md9l2hb14XhfjnEecsDIQRVHW2p6mjLjP7NeGvtCZzsrFi+/zJXbyUiAWc7K2YPa0332TtwtLUiNimFOlUcWP5cR6o5la2flebByWvP5jSwCxgkpQwGEEIUxfmaqUKI0agzPC9LKW8BtYF92eqEGjKAK/fIOwBuQLSUMjWH+rUz2kgpU4UQMUZ9E/5k1hQ76Wkq3hiAjSOEBqiMl95PKk+xpUPgxkl49FP4c2ZWO/dWyog07A2rn4PvH4GqjcChKlT2UMthLR6Dw8tUnpn46yoa89GfVXKygV+o8zOQc0BNE1iy5xIJd9IA2H46vMBf2EVJWrok4GIUiSlp9GhqmlfX4SvRhETcZvIw7wcae3DrWgxuXYvUtHRe/vUop8JisRCCnWfjcHGwJuFOGgl30mji7siyCdrQVFTyMjZPoGY2O4QQfwIrgAddYJ0PvIcK5PkeyvHg2Vz6leS8zCfzqE8+ZXchhJgITASoW7duXnprihop4ewm2PYOhAdB3U4qjP6uOeq0/pk/YfRvWfss66aBpQ38c5c6XFm1iTIoDbrDhK2w7B9wNRAaPZy179J+IpxYBZvfUIc0n14Fl/YoF+dfx6j+6ndXxqmA3E5OZfGeEHo3q05QWCzrjl7D3dmOjg3csLEyaXX6gfjt8FXWH7vGf5/x44utZ1l58ArhcckIAV886YNHFXu2BIXjVbsyD7dwv0+n2KQUlu27jI2VBX1bFc6j7F6sLC34coQ6rJqWLun80TZ+2ncZBxtLPvuHDx0buBbaVVpT9snrUOcaYI0QohLwGCpqgLsQYj6wRkq5uaCDSSlvZNwLIb4D1huPoUD2Pws9UBEMyEUeAbgIIayM2U32+hl9hQohrIDKQFQu+nwLfAvg5+enl9mKi/R0+HU0nPodXBuoZbMWQ+HU2qw6V/bB/ybc3a56C6jeTH2y41IXnv1TGZVmj2bJ67RXkZbDjqqZUM3W6tNugtoj2vMVdJteqFf4+cBlohNSmNKrEXvPRzJ70xl2nYtgUveGzOxv/mRfL6xU4XSmrzrK6kNX6dG0GjO8a/HKqqM8v+LIXXWrOtowuUcjHvWuyfAFe7G0EFyMvI2U8Hib2vd5mxUFlhaCcQ/VZ77/eSZ2a0C/IjJomrJLvoc6pZS3gWXAMiGEKzAcmAkU2NgIIWpKKY1dWYYCGTur64DlQojPgFpAY+AAapbSWAhRH7iKmmk9JaWUQogdwDDUjGsMsDZbX2OAvUb5dr1fU8o4+J0yND1eVQcoLY0vu2rZvqS9R8CxFeq+/T/hwH/zTols7wJD5t0tE0LNbtZOUYYnA0trlS+mx8xCeZ8lpaSxcFcIHRu40rZuFZq6O7EqMJSQiNss23+JyT0bmuULPIOr0YmZ96sPXaVxdUe+H9MOSwuBg40lweHx2FhZ0LVxNW7EJfH9rhDeXR/E6sOhXI5KwNujMs/3bkx7T1f8PF3Npuek7g2Z1N2EyNaaCkGBghtJKaOA/xqfPBFC/Az0AKoKIUKBt4EeQggf1LLWReCfRr8nhRC/AEGoIJ9TjCyhCCGmApsAS2CRlPKkMcQMYIUQ4n3gMPC9If8e+NFwMohCGShNaeF2JGz/QO21dJ9x95e9q/HF5O4FA2ar2U1yHPiNU8amXueCj9fqCTi9Abz+cX9ZId2cP9hwiuuxSXz+pMo/U8nWiu0vd+fE1VgGzdvNT/suMblH0XtaSSlZfyyMj/88jaWF4P+GenE1OpHH29bG0nAh7u9V8642LXCmS6OqjFq4nwMhUbhWsmHd1C45da/RmBWh/+hX+Pn5yYCAgJJWo/yz61PY9p6KfHzvchioPRqXeuDgCrcuqWRjHn5w8wy4NSq0i3JRERGfjN/7WxnTqR7vDGl1X/mYRQc4cTWG3TN6YW9TtLpOWX6IDcfCaFbDibcGtqBzo6omt70anUivOf5M79uUCTpXjKYIEUIESin98qtn/p1MjSY7109AlXo5GxpQ0ZAdjKWdKvWUoQEVbbmEDQ3A38HKqfHxtjk7FUzp2YjI23dYefBygfuWUhKblHOumNvJqWw8HsbI9nXY8O+uBTI0ALVd7Dk26xHGd6lfYL00mqKgUMZGCPF3USuiqSBEnL07v0spZuryQ3y2+cxdsl3nIqhsb02r2pVzbNO+vivtPV35784LmSH5TWXlwSt4z9pMcHj8fWVBYbGkS+jT3D1zyayg2FpZ6ojKmhKjsDMb7SesKTjpaRBxDqqV/uRYN+OSWX8sjLnbgzlxNYaAi1GsPhTKhmNh9GhaLc8v/Cm9GhEWk0STNzay5nCoyWNuOK58Z+ZsOkN6+t3L28dCVeBKr1yMnEZT2ils9iO90aMpOLcuQlpyqZ7ZhN5KYO2Ra7hVyjoPMvCr3Zn3HlXseePRFjk1zaRb46q093TlwMUo5vufZ2ib+5fcgsPjWfR3CF0aVcXO2gI7a0suRyUA8OfJ6/zjv3uZ2K0BvZu7Exwez1fbz+HubEt1Z7sielONpnjJK1xNbsk8BCoYp0ZTMM4Z3vLVzH8OxVT+FxjK0r0X+XVSZ9Kl5LmlgZwKiwWgqqMtHz/hRWxSCq6VbHGrZEPDao75bvwLIfh5YkeW7LnIu+uD8Jq1iZ+f63jX0tuqwFCW77/M8v137+288kgTqjra8tX2YCb+GEhdVwcSU9JIS5eM7uRZ1K+v0RQbec1sBuVRtj6PMo3mfs5thU2vq2yYtduWtDaZzN50huuxSaw+FErApVucvh6bWTbuIU96N3cvVL+WFoJBrWuxcNcFrsUkMXbxQX4Y1y7T4Jy5Hks9NwfmjWxLmpT8EnCF5fsv41vPlU4N3Rjm68HmoBss2h3CqbBYfpnUiZa19BKapuyiXZ8NtOuzmdi3AEL+ggt/gVsDGLcRbJ1KWqtMHp27i5PXYrG3tswMqNm8hhOrD1/l66faFknomeDweMYsOkDU7TvMHdmGh1u40+n/ttGxgVvmWR0pJWdvxNPE3fG+TfzUtHSsLLXjqKZ0Yqrrc757NkIIW1ScNM/s9aWU7z6IgpoKws7ZkBChcsaMWlWqDI2UkpCI2/RsWo3T1+PoWMOV53s3xtJC3Hc48kFoVN2RNVM689ySACb+GMCoDnUJi0miaY2sn4UQ4q7n7GhDoykPmOIgsBaIAQKBZPOqoylXpCarVAAthqiw/o6lK8f8jdhkEu6k0atZdRY844u1hYXZknlVd7JjxcROzFp3kp8PqEDmzWs6m2UsjaY0Yoqx8ZBS5pQETaO5m7QUSLsDNpXUc3gQpKdCy8cLbWiklOy9EElTdyci4u/QuLojFhaCjzaeJiUtnSk9G+FqeI6lpUs+2niKpJR0ElPS+GBoK2ytct/MvxChzrPUr+qYZ72iwt7Gko+HeTOtdyP2XYiiSwEPZmo0ZRlTjM0eIYSXlPL+FHwaTXbWToGTa6BhLxWT7I5xOLFm60J3+cZvJ1i2/zKulWyIun2HDvVdGd3JkwV/qVw052/G8+0zfthYWXA0NJrvdoVktu3T3D0z2vCO0+G8ufYEr/ZvTrcmVXGys2ZPcCRCQJMajoV/50LgUcWBYb73p1vWaMozphibLsA4IcQF1DKaAKSU8sEyLmnKNunpcGgJ+P8fdJwMnaeppGRV6quQNGf/BOtK4Fwbqnje1XTR7hACL93ixYcb06j63fsUkfHJDJ73Nz51XBjm58HPB5RrcNTtO9RzcyAoLJYpyw9ha2XBlJ6N+GzLWTr+3zYm92jIrYQ7CAEHX+9Dvy92svbI1Uxj88XWs4TeSmTK8kNYCHU4MiTiNr2buVPdSZ9d0WjMjSnGpr/ZtdCULW6ehbWTIfQgVKqmkp3tX6BSOA+YA17D4ecRyuD0fvOu6MoXbsbz7vogQJ2Y796kGmMf8mTH6XB2nr1JPbdKXI1OJPJ2MhuOhyEE/PHvrny6+QzTejemZmU7Pt54mobVHZncoyFeHpX5flcI7284BUDrOi5UdbRliE9tluy5yLkbcaSmS46GxjCjXzOa1XDi8JVo9p6PQEr4Vw8dlFKjKQ5ydX0WQtgBk4BGwHHg+2xpmMsd2vXZRCLPw8I+yoD0/RCaD4adn6hUzgAvnQbnmhB9GfZ+A73fApusJaN3fj/J8v2XWTv1ITafvMGP+y5xM+5uvxMbKwsOvNabn/ZdwtLCgn/1yD8nyq5zN/l6RzBPtPVguF8dIuOT6TnHHy+PyvRtWYO31p7k75m9qO2izyNrNEVJUbg+LwFSgF2o2U0L4PmiUU9TZjmxGhKjYNohcDOMQJ9Z0KSfyojpbLgMu9SF/h8RHB5PXNIt2tRVic92n4ugfX1XmtVwplkNZyZ1b8jGE2Fcikygd/PqPDp3Ny1rOePiYMPUXo1NVqtr42p0bVwt89nN0ZZX+jblrbUnuRiRQDUnW2pV1stlGk1JkZexaSGl9AIQQnyPypypqciEn4LQAyqvjNs9s426HdXnHt5ed4JLkQnsntGL6zFJnAuPZ5hvVqwwGysLhvjUznz+brQfLWoVjUvwU+3r8vOBK5wKi+XhFu464rFGU4LkdVosM7FGeV4+05hITCh801HFN6vVxqQm6emSo1diCL2VSFxSCj/uuwhAtybVcm3zcAv3IlvqsrK04N0hLQHwq5dHSmmNRmN28prZtBZCZASKEoC98ZzhjaZPpFUkTqzOunczbXnrQkQ88cnq75RfA0KZ73+e4b4exXqYsZ2nK+undaFR9eJ1b9ZoNHeT68xGSmkppXQ2Pk5SSqts9/l+WwghFgkhwoUQJ7LJXIUQW4QQ54xrFUMuhBBzhRDBQohjQoi22dqMMeqfE0KMySb3FUIcN9rMFcYaSW5jaB6AlEQ4/BNYOyjX5hZDcqx2PSaJ/RciSUpJA+Dw5ejMsvc3BFGzsj1vDso7PL85aFW7MnbWJZ/lU6OpyJgz6NIPwL2RB9Q6KVQAAB+zSURBVGYC26SUjYFtxjMoB4TGxmciMB+U4QDeBjoA7YG3sxmP+UbdjHb98hlDYyrp6XBpL+z6DBJvwa/jVIbNJxbC80dyTen8+prjPPntPrxnbWb4gj18tuUstV3scbCxJF3CJ8O8cbazLuaX0Wg0pYHCJk/LFynlTiGE5z3iIUAP434J4A/MMORLpfLD3ieEcBFC1DTqbpFSRgEIIbYA/YQQ/oCzlHKvIV8KPAZszGMMjSlICT8OgZCd6vnAtxAXps7PNHs0z6ZBYbG093SlTV0X9oVEkZKWzqKx7fg1IBTXSjY8pMOzaDQVFrMZm1xwl1KGAUgp/7+9O49vozwTOP57ZiRZvo84dk7HuQglITc0UI4AbUhptty0pRToAYVS2u5SWNh2C9suLT0XuuUoXVgoC5TSkpRSIE2AFAjkIiHkIuROHDtO7PiSbVnSzLt/zNg4iRNiJ7J8PN/PRx+NXr0z8z6yPM8cr96pEJHWAbOGArva1Svzy45UXtZB+ZHWoY7G3vVeojn9W9BUDe8+CWffDqded8TZ6qNxKuqiXDVjBDedM+aA9yYOy0tmi5VSvUB3J5vD6ahPqulCeedWKnI93qk4SkpKOjt737T+eUC84WfSsmHiFTDy7AOqxBIui7dUsWL7flZsr2Hz3kjbXSRPKO45txBQSvUc3Z1sKkVksH/EMRjY65eXAcPb1RsGlPvlMw8qX+SXD+ug/pHWcQhjzMPAw+CNINDVoPqMhkpY/jsYeeaHozSPmnlAlbjj8tXHl/PGpipsSxg/JIdw0Oa/Fn4AwAnF2utLKXWo7r4r0/NAa4+ya/DuldNafrXfK20GUOefCpsPzBKRfL9jwCxgvv9eg4jM8HuhXX3QsjpahzoSY7zxzmKN3vWZw3hq6U7e2FTFD+acxJq7ZvH8N8/gkWunU5AZojgnjeH5OpqxUupQSTuyEZGn8Y5KCkWkDK9X2T3AH0Xkq8BO4HK/+ovABcBmoAn4MoAxZr+I/AhY7tf7YWtnAeBGvB5v6XgdA17yyw+3DnUky34HmxfCBb9gaUMhQ+wmhhccmDhiCZdHF29j0rBcvnLGyLbyEwflsPx7nyTuuEm7+ZhSqnc77ECc/U2/HoizZgfcfyqMPIu6i57klJ+8wrSSfJ6+fgZxxyVoW+xvjDHrv16nKtLCTy45mS+cqte4lFLHZyBO1V98MB8SUZh9D/NWlxNLuLy9tZpfLfiA/351E6eUFpCdFqAq0sJts8cdMLaZUkodje6+ZqN6mvJ3YcPzkFvCyxUZ/Hz+RsYVZ5MWsPj1K5vIzwhR2xTjlff3cv74Yr4xcwxBW782SqnO0SOb/saYD29m9rfver3PgLUFn+KG/1vJpOF5PPjFqdy3cBPPrNjFZdOG8W8XfIyd1U0MyAqlsOFKqd5Mk01/EtkLv5nujdp8ytdgxaOYsbNoLH+fe/ZM56oZJfz7nJNIC9hcd9ZIFm+p4tKp3imzkgHay0wp1XWabPqT9X/xbt1csRqeuQqAr1RczGvVuYwqzOSJCye03fNlTFE2b/7rualsrVKqD9Fk05+smweF4+D612DF/7JmVxWvrcoF4KZzxujNxZRSSaPJpr/YsxZ2vAnnfB9CmbgzbuKWpa9z4iDhhZvPIKAX/ZVSSaRbmP7i9Z9DWg6c+jWMMfxl9W4+qIzw9bNHaaJRSiWdHtn0B/s2wvq/YM68hbkbGnnkzbWsK69n1MBM5kwckurWKaX6AU02/cEbv4RgBg9GZ/GzP65mXHE2d188gYsmD9XfzCiluoUmm76ueguseZaW6Tfwy8XVXDh5CPd+brJ2BlBKdSvdre3L4s3w3HUQCLOo8HM4ruHq00o10Silup0mm97MGPjDF+HpL0BzzYHvuS7MvQF2r4RLfsdft7gUZIaYPFzvmqmU6n6abHqzDX+F91+AjS/C786Dqk0fvvfa3bB+Hsz6ES8703nhvQounjIUW28BoJRKAU02vVXtTnjhO1A0Hq55AaK1XsJ581548VZ44xcw5Uvsm3Addzz3HpOG5XLb7HGpbrVSqp/SZNMbrP4D3D8Dlj4MVZshWu+dPnPicMXj3m2cr3sNcofBwjth2cMQzKDxnB9y3RPv0Bhz+MXlk0gL2KmORCnVT2lvtJ4u0QIL74KGCnjpVq/MCoJx4At/gMKxXln+CLjuFdi/DWp3EA8XcsOzm3ivrJYHr5rG2OLslIWglFKabHq6dXO9RHPVc5A3Ara/DpXrYOLnMMNO4X9e38qGPfWUFGRQUpCBJbnkpE/lL2+X88amcn522UTOHz8o1VEopfq5lCQbEdkONAAOkDDGTBeRAuAZoBTYDlxhjKkRr5/ufcAFQBNwrTFmpb+ca4Dv+4v9T2PM4375NOAxIB14Efi26a33v179NOSXwuhzvfvQFI5pe+u+hR9w78JNFGaFqG6McXCE//zJE7hi+vDuba9SSnUglUc25xhjqtq9vh14xRhzj4jc7r/+V+DTwFj/8XHgQeDjfnK6E5gOGOAdEXneGFPj17keWIKXbGYDL3VPWMdR9RbY+g84+zYQwRhDVSTGhop65q/bw5NLd7b9SDPmuOyuaaa8NsqNT75DXkaQG2aOSnUESikF9KzTaBcCM/3px4FFeMnmQuD3/pHJEhHJE5HBft0Fxpj9ACKyAJgtIouAHGPM237574GL6G3Jpq4M5n4d0rJpmfQlfjRvDfNWlRNpSbRVGZAZ4vufOQkRIS1gM2pgFqMGZjHvpk+QFrC0Q4BSqsdIVbIxwN9FxAC/NcY8DBQbYyoAjDEVIlLk1x0K7Go3b5lfdqTysg7Kez5jvOsxa/8ESx70Xl/8IPcta+T/luzkkqlDOXloLiMLMzl1ZAEh2+pwxObRA7NS0HillDq8VCWbTxhjyv2EskBE3j9C3Y5+hWi6UH7ogkWuxzvdRklJyZFbnGyuA89d7yUagImfh3O/R0vWUJ6Z+yrnjy/mV1dMTm0blVKqi1LyOxtjTLn/vBeYC5wKVPqnx/Cf9/rVy4D2V7mHAeUfUT6sg/KO2vGwMWa6MWb6wIEDjzWsY7Pp716iOeOf4eaVcMlvIa+Ev71XQXVjjCs/PiK17VNKqWPQ7clGRDJFJLt1GpgFrAWeB67xq10D/MWffh64WjwzgDr/dNt8YJaI5ItIvr+c+f57DSIyw+/JdnW7ZfVc65+HcC7M/DcYMBoAxzXc/9pmxhVnc+aYwhQ3UCmlui4Vp9GKgbn+yMMB4CljzMsishz4o4h8FdgJXO7XfxGv2/NmvK7PXwYwxuwXkR8By/16P2ztLADcyIddn1+iJ3YOcOJeT7Omamiq8sY5O/EzEAgBYIzhoX9sYcu+Ru6/ciqWjmmmlOrFuj3ZGGO2ApM6KK8Gzuug3AA3HWZZjwKPdlC+AphwzI1Npncegxe/2/Zyb3gk24ZdQ35lA4s3V/HM8l28v6eBC04exAUn648ylVK9W0/q+ty/rHmWlvxx3Fd4J3M31FNRmw3P1QCvAzBpWC4/vvhkLpk6VO8/o5Tq9TTZpELdbti1lPviV/BolcWl0yZw9WmlLNu+n5xwgPFDchhTpGOZKaX6Dk02KbBjxd8YASTGzuaty8+jINO7TjNukCYYpVTfpMkmBeo3LGK/yeamK+aQmxFKdXOUUirp9H423c0YBlYvZ1P6JHIz0lLdGqWU6haabLpZ5asPMMjsJTbyk6luilJKdRtNNt1p3TwK3/h3XncnMf4zN6a6NUop1W002XSXDS9g/vRV3nVH8/LHfkpBVjjVLVJKqW6jHQS6w8aXMM9eyzpGckfGnTzz2WmpbpFSSnUrTTbJ9MHfoaUeM+9GttgjuTZ6O49fdyb5mdoDTSnVv2iySZZ3n4Z5NwAQt8Jc1nAL//H5GYwfkpvihimlVPfTZJMMroOz4C7WuSNJJ8Z/xy7isjMmcuHk3nEPN6WUOt402STDltewG/dwf+I7TD3/ai4uzuasE1J8vxyllEohTTbHW91uePEW6ux81mWexkNnjdKBNJVS3arFaaGysRIRIWSFsC2b9/e/z5p9awjaQRJuguxQNlnBLGqiNcweOZtBmckdXV6TzfFUXwGPz8E0VfP1xB2cOWmIJhql1HFljKEx3sjKvSuZv30+exr3EE1EaUo0tT3XRGswmKNeZmluqSabXiMehd9/FiJ7WXPu/7JkXpwvjytKdauU6lUisQhPrH+CddXryAhmkBHI4M3dbzJn1BxunnIztmUfMk9TvIm1VWvZ1bCLyqZKskPZuMZlctFkBoQHUBOtIepEmTRwEiE7eT1BXeOyO7KbXQ27qG6upiZaQ0YwgxWVK0gPpDOteBpN8SYaYg00xBooj5Szet9qXFxGZI9gaPZQ9jfvpz5WT3ljOY2xRtICaYTtMOFAmOrmaiyxaIw3EnWiAOSEchidN5qsUBaF6YWkB9MJ22GKM4oZkjUEgJgbI+7EKckpYVrxNATBtmwisQiRWITccC45oZykfS6txLs3mZo+fbpZsWJF1xewbi48ey0bz36Qb68extZ9jaz6wafITNN8rlQrYwxbarewrX4bEwZMoD5Wz+LyxSwpX8Kuhl3UtdQRiUcYnTeamBOjIdZAXjiPbXXbyAnlMDx7OGcOO5OZw2cyIDyAjfs38uOlP6a8sfwj110QLuDuM+7mjKFnHHMcC3csZN7meQDYYlPZVMnWuq00J5oPqTsgPIDmRDNNiSbENQRcSHMDDAwVMDH/JMImSEXdLqoa95IpYfLsLPIC2QwKFRKPNROPt+DEomRZGViOIUNC5FiZFIUKGJ1ViuUaSCQwCQeTSGASce91PIFxHP+1/56TOKhuAtPcxMB/uYX0CeO79FmIyDvGmOkfVU+3hMeJu+pJ6gKFfHp+NoNy4/z6C1M00SgF7I7sZkvtFt4uf5tFuxZRFikDvI204yawXRibM5qpOSeRmR3i0yXnMyF3HCYex8TjuLEYy3a9xZqKlVRuLeft5Q+y1H2AgAuWC9NDhcwpuZJBaQPJtjOItkRw43F21+4kHouSLmkYJ8E75ctY9vJNjBh9CUFjextex2nbKOO02wg7CW8D7TjEY1Hi8ShOIo7jxGmI1hGP1nEJQQJYXgIxFiFsgmRgG8EyIK7BOAnEqcckvOXRtnPvABX+o+v2HenNYBAJBBDbRgIBOGDaRgJBxLaxMjIw8dgxteNo9NkjGxGZDdwH2MD/GGPuOVL9Lh/ZRPbB2j/By7fzq/hlxM+8lW+fN5Zw8NDD/WRzjUs0ESUcCCNIh9eL4m6cXQ272Fa3jZAVYlzBOBJugm1128gMZjIgfQCDMgcRtILd3v7+whjD/O3zeXXnqwTtIAPTB1KUUcSYvDFsrt1MU6yR2qZqStKHMCx9CLmBLDIkxLCMIZiEQ6S5llUVK4g013Pu0LMIuIJJtG4s/Q1m+z3Yg6ZbN3xte72O85HzfDjdbk/54GknAa170/60m0hQ2VCB5bjYBkImQNBYWK7BJBLeXnl3fe6BADESWIEgwVAaEghiBYJIuw2vBGywAzSbGFXxGhrdKE1uM44luAKugLGE4bkljCwYg2UHEMsC20ZsG2wLsdo/ext3Cdjexj4Q8NYVCCDBwEFl7ZJCIIgEW99rX6/d69Zk0kEdbLvbrhf36yMbEbGB+4FPAWXAchF53hiz/nivq+mlfydj3dNsTpvAH+1LeeNTJxC0DxxyznEdXOPi4rKncQ+3vX4bexr3MDRrKHlpeWSHsslLy+PisRdzYsGJh12XMYbmRDP1sXrqWurY2bCTmmgN9bF6Vu1dxbt736U+Vk/AChC2w+SH8wlaQfLS8phWPA1LLJ7a8BQN8YYjxlQQLuDmKTdz2QmXHfPnU91czep9q9lcu5nNNZvZVLuJhJvgwjEXUppTSmYwk8xgJkUZRYe9QGmM8TaIjuNt9JwPTwHQ4fSBG94jboTb9mw72MvtYLr9/M0tEXbUbKU5GmFQuIiACxmSRoiAX8ebx03EaGlpbttzbo42kBVr4lJjYblgOS6WC7YLk5yOByyMApvbvR7iP5fxwDH/jdpYlrfBDPobXtuGYACxD907br9nLLaNpIWIY1MTb4GATXpaDhIIsLlhO+VRw8nFUxheMIZgKPzhRj3gL/ugaQkGD3yEQm3TB2yIbfvD1+031Ae0v900cMPCG1i8e7H/iUbJT8vnrtO/T0VjBZtrN1PXUkd9rJ7le5aTG8rl5IGnMbVoKsOyh5Gb5l3bGJEzgsxg5vH73PuJPnlkIyKnAXcZY873X98BYIz5yeHm6eqRzT2PP8uisqVsCwqnjs5l+shsookoUSfKysqVlDWUEXMPPETNDmUza8QsyiPl1MXqaIg1UNVcheM6nDr4VIoyihC8vZKGWAOnDDqFxWVv8vbuxSScuLeBMt5DjHcqoTS7hEkDTqY4XES0pZForJGm5nrcRIKqyF521GzBcuDkgo9xRvHpDA4XUdO4j7qmGgKuMDBUgJOIEWmqZXXlKnbVbGd0VilN0QZOzBvLpPwJ1DXtZ2nZW+QHc5mQeyLZdqa/hxrHTSSoa9pPfVMNkeY6GppraYo2IO02pBkSIsNKw00kiLU0tZW3PsISJGyC4DiI62I5BnEM4jid/rscL8a2MLYFtoWxbFxbsAJBosSJuM04lkHsAC2SwLHAtYT0cBb5mYXUJSI0E6M20UBCDK4FCQtcC0YNGMuEQZOx7ADYFo3EqIzuoyh7MMFQmIxwNo1ulFqngaiJsaHuA7ZHyijIKmR4fiml+aOJicuftjzH3lg1jkXb+gflDuO7H7+NouxBH+7t2t5e9tbGnaytWU+jG6WZOMNySzi79Fyy0nO9PfSP4LgOZZEyIvEIFZEKaltqqWupY131Ol7d+SqOOfRvNa14Go/NfiwJf53OS7gJNtZsZE9kD/tb9vPQ6ofY27QXgNy0XAaEB5AVyuLE/BO5ZfotZAQzUtzinu9oj2z6arK5DJhtjPma//pLwMeNMd883DxdTTa/u/tKgsvexXa8DWbQEYJGCLpC2EojU8LYRhDXeBtQ1xCWNAJGvD1p1wXXxXUStMSjuK7j1TWmLZnYbpc/iqRI+Bs2x/Y2bo5lMLZNTBzvVINtEQiGSAtlIMEgWeEc0tOysIOhtvPFCXFpwSFhGRLiUu828UHdFppMFNe2SIjbtg7LDtKCtzEPhsLkZOQTx2HkgDGcXXoegWAIY1m4tuBaghUMEU7L8E9h+Hu9tnd6pG2P+AjT+xO1vLDjZZ764Gn2NFV2+BkErACXjr2Ua8ZfQ3FGMQ+tfojS3FLKI+X8dctf2dmwk7AdZnTeaKYVT2Nq0VRCdghbbIbnDGd49vDj8rdwjcv2uu3Ux+ppcVooayjjFyt+QdyN87lxn2NEzgjvonzdFv6x6x8dXkhPs9P41pRvcdVJV2GJhTGGDfs3UJheSFGG16MyEoswd/NcntzwJLsjuw9ZRm5aLhePuZiLxlxEyAq1JaRx+eMYlDkoqb3AjkVlYyXvVb3H+AHj23pvqc7p78nmcuD8g5LNqcaYmw+qdz1wPUBJScm0HTt2dHpda37+A8zCN0kPZ2OH0rDanUclYHvnbf1nCdhg2W17mWJb/msLxPJOY1j+s19mLKEu3kBWOIdgIOQtr937bfParfO2O0fcelqi9Rxu+/O5HUx/eFrCm66O1TIgq4idzeU8t3Ue4bRMvjj+S7Q4LbxV/hb7mvaxP7qfqBNl4/6NXH7C5UwfNJ3h2cOxpPN3r4g7cVqcFjKDmTjGoSHWwOp9q1mwYwGj80Zji83O+p3sbNhJi9PCqr2rCEiAhEkcsqxZI2Zx9xl3Ew507lYOVc1V3LDgBjbWbGR07mhuPeVWRuWOwjEOjnFIs9N4Y/cbTBo4iRPyT+hwGcYY1levpyBcwOCswZ3+HI7V7shu7l91Py9sfaHttxZhO8yMwTOYOXwmpw85nfxwPiE7xHv73uORNY+wqGwRgzMHMzTLG1JpReUKLLH41pRvUROt4c+b/kwkHmFK0RT+afQ/kRvKpSSnhLy0PHLTcgnbYf1NWT/V35NNt51GU6mzrGIZb5a/SdgOE7SC2JZNQALsa97HY+seY9aIWXzl5K9QlF7E4+sex8U7CghaQU4fcjqj8kbxdvnbuMalxWlh6Z6lbKrZhCDce869nDP8nF69Aa1rqSPmxBARskPZpNkd34bcNS4vb3uZhTsXUt1cTV1LHeeNOI+1VWt5q/wtbLGZVTqLq0+6mgmFE7o5CtXT9fdkEwA+AM4DdgPLgSuNMesON48mm77lgXcf4MHVDwJgiYUgWGJRmltKU7yp7VRQQAIgXjfcyQMnM2PIDM4adtZhj1r6E8d12FS7icL0QgrTC1PdHNVD9etkAyAiFwD34nV9ftQYc/eR6muy6Xuqmqt4u/xt1lStYc6oOUwcOBHwTnPtqN/Bhv0bOH3I6W09iwJWn+ycqVRS9ftk01mabJRSqvOONtl0/iquUkop1UmabJRSSiWdJhullFJJp8lGKaVU0mmyUUoplXSabJRSSiWdJhullFJJp8lGKaVU0umPOn0isg842pE4C4GqJDanu/SVOEBj6cn6Ujway6FGGGMGflQlTTZdICIrjuYXsz1dX4kDNJaerC/Fo7F0nZ5GU0oplXSabJRSSiWdJpuueTjVDThO+kocoLH0ZH0pHo2li/SajVJKqaTTIxullFJJ1y+SjYgMF5HXRGSDiKwTkW/75QUiskBENvnP+X65iMivRWSziLwnIlMPWl6OiOwWkd8cYZ13+PNvFJHz25U/KiJ7RWRtb41DRMIiskxEVvvt+I/eGotfvl1E1ojIuyLS6Zsa9ZRYRGScH0Pro15EvtNb4/HLvy0ia/129PhYRGSAv77IwXVE5G4R2SUikc7GcbxjERGn3ffk+SOs8xp/uZtE5JpjisUY0+cfwGBgqj+djXfL6JOAnwG3++W3Az/1py8AXgIEmAEsPWh59wFPAb85zPpOAlYDacBIYAtg+++dBUwF1vbWOPzlZfl1gsBSYEZvjMV/bztQ2Be+X+3q2MAevN9A9Mp4gAnAWiADCAALgbE9PJZM4AzghoPr+MsbDERS/T07mjYABcBW/znfn87vaiz94sjGGFNhjFnpTzcAG4ChwIXA4361x4GL/OkLgd8bzxIgT0QGA4jINKAY+PsRVnkh8AdjTIsxZhuwGTjVX//rwP7eHIe/vNY9mqD/6NTFv54SS2fa3MtiOQ/YYow52h8q98R4PgYsMcY0GWMSwD+Ai3tyLMaYRmPMm0C0g/eWGGMqOtP+ZMVylM4HFhhj9htjaoAFwOyuxtIvkk17IlIKTMHbGy9u/cD85yK/2lBgV7vZyoChImIBvwRu/YjVdDj/sba9vVTHISK2iLwL7MX7Qi7trbHgJcq/i8g7InJ9V+OAHhFLq88DT3c+ggOlOJ61wFn+qakMvD314T08lm5xLLH402ERWSEiS0TkIjp2XLdjga7O2BuJSBbwZ+A7xph6ETls1Q7KDPAN4EVjzK4jzHuk+Y+LnhCHMcYBJotIHjBXRCYYY7pyHSrlsQCfMMaUi0gRsEBE3vePQDulh8SCiISAzwJ3HE27D7uSFMdjjNkgIj/F26OO4J1qSxxt+w9YQffFknTHIRaAEv87Pwp4VUTWGGO2dGL+Tus3yUZEgnh/oCeNMc/5xZUiMtgYU+EfXu71y8s4cA9qGFAOnAacKSLfALKAkH+BbClwp1/3a0eYv8/FYYypFZFFeIfXnUo2PSUWY0zr814RmYt3CqdTyaanxOL7NLDSGFPZmRh6YjzGmEeAR/w2/div22NjMcZ0uoNJCmJp/53f6v//ThGRQuC3ft0f+PPPPGj+RV1uvOniRdHe9MDL0L8H7j2o/OcceGHtZ/70ZzjwwtqyDpZ5LYe/SDieAy94bqXdBVyglK51EOgRcQADgTy/TjrwBjCnl8aSCWT7dTKBt4DZvTGWdu//AfhyX/h/AYr85xLgffwL1D01lqOMt6sdBI5LLHgX+9P86UJgE3BSB+srALb59fP96YKuxtKlL2Nve+D1DjHAe8C7/uMCYADwiv9hv9L6Qfp/nPvxesWsAaZ39gsHfM+ffyPw6XblTwMVQBxvz+GrvS0OYCKwym/HWuAHvfVvAozC29CtBtYB3+utsfjlGUA1kNtH/l/eANb7f5/zekks2/E6AUXw/sdP8st/5r92/ee7UhELcLr/erX/fNhtEPAVvA4bm2m3A9OVWHQEAaWUUknX73qjKaWU6n6abJRSSiWdJhullFJJp8lGKaVU0mmyUUoplXSabJRKgXaj7q4Tb/Tsf/GHRDnSPKUicmV3tVGp40mTjVKp0WyMmWyMGQ98Cu/3End+xDylgCYb1Svp72yUSgERiRhjstq9HgUsx/tF9wjgCbwRDQC+aYx5S0SW4I2EvA1vdN9fA/fgDSmSBtxvjPktSvVAmmyUSoGDk41fVgOcCDQArjEmKiJjgaeNMdNFZCbwXWPMHL/+9XjDufyniKQBi4HLjTdMv1I9Sr8ZiFOpXqB1lN0g8BsRmQw4wAmHqT8LmCgil/mvc4GxeEc+SvUommyU6gH802gO3oi9dwKVwCS866qH3IirdTbgZmPM/G5ppFLHQDsIKJViIjIQeAhvcEeDd4RSYYxxgS/hjU4N3um17Hazzgdu9IedR0ROEJFMlOqB9MhGqdRI9+90GsS7IdgTwK/89x4A/iwilwOvAY1++XtAQkRWA48B9+H1UFsp3h209vHhLYGV6lG0g4BSSqmk09NoSimlkk6TjVJKqaTTZKOUUirpNNkopZRKOk02Simlkk6TjVJKqaTTZKOUUirpNNkopZRKuv8HDpPbXfykvg4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0f19ec5f28>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "attr = build_pnl_attribution()\n",
    "\n",
    "for column in attr.columns:\n",
    "        plt.plot(attr[column].cumsum(), label=column)\n",
    "plt.legend(loc='upper left')\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('PnL Attribution')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build portfolio characteristics (TODO)\n",
    "Calculate the sum of long positions, short positions, net positions, gross market value, and amount of dollars traded.\n",
    "\n",
    "In the code below, in the function `build_portfolio_characteristics` calculate the sum of long positions, short positions, net positions, gross market value, and amount of dollars traded.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_portfolio_characteristics(): \n",
    "    df = pd.DataFrame(index = my_dates)\n",
    "    \n",
    "    for dt in my_dates:\n",
    "        date = dt.strftime('%Y%m%d')\n",
    "  \n",
    "        p = port[date]\n",
    "        tradelist = trades[date]\n",
    "        h = p['opt.portfolio']['h.opt']\n",
    "        \n",
    "        # TODO: Implement\n",
    "        longs = np.sum(h[h > 0])\n",
    "        shorts = np.sum(h[h < 0])\n",
    "        df.at[dt,\"long\"] = longs\n",
    "        df.at[dt,\"short\"] = shorts\n",
    "        df.at[dt,\"net\"] = longs+shorts\n",
    "        df.at[dt,\"gmv\"] = np.abs(longs)+np.abs(shorts)\n",
    "        df.at[dt,\"traded\"] = np.sum(np.abs(tradelist['h.opt']-tradelist['h.opt.previous']))\n",
    "        \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0f00ffd748>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pchar = build_portfolio_characteristics()\n",
    "\n",
    "for column in pchar.columns:\n",
    "        plt.plot(pchar[column], label=column)\n",
    "plt.legend(loc='upper left')\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('Portfolio')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Optional\n",
    "Choose additional metrics to evaluate your portfolio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optional\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Submission\n",
    "Now that you're done with the project, it's time to submit it. Click the submit button in the bottom right. One of our reviewers will give you feedback on your project with a pass or not passed grade."
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}