NewQuant/data/analysis/Trend.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:02.157580Z",
     "start_time": "2025-12-08T15:18:02.151197Z"
    }
   },
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "import warnings\n",
    "\n",
    "# 忽略所有警告\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "# --- 0. Configure your file path ---\n",
    "# Please replace 'your_futures_data.csv' with the actual path to your CSV file\n",
    "file_path = 'D:/PyProject/NewQuant/data/data/KQ_m@SHFE_hc/KQ_m@SHFE_hc_min15.csv'\n",
    "\n",
    "sns.set(style='whitegrid')\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签\n",
    "plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号\n"
   ],
   "outputs": [],
   "execution_count": 42
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:02.203253Z",
     "start_time": "2025-12-08T15:18:02.157580Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "# --- 1. Data Loading and Preprocessing ---\n",
    "def load_and_preprocess_data(file_path):\n",
    "    \"\"\"\n",
    "    Loads historical futures data and performs basic preprocessing.\n",
    "    Assumes data contains 'datetime', 'open', 'high', 'low', 'close', 'volume' columns.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        df = pd.read_csv(file_path, parse_dates=['datetime'], index_col='datetime')\n",
    "        # Ensure data is sorted by time\n",
    "        df = df.sort_index()\n",
    "        # Check and handle missing values\n",
    "        initial_rows = len(df)\n",
    "        df.dropna(inplace=True)\n",
    "        if len(df) < initial_rows:\n",
    "            print(f\"Warning: Missing values found in data, deleted {initial_rows - len(df)} rows.\")\n",
    "\n",
    "        # Check if necessary columns exist\n",
    "        required_columns = ['open', 'high', 'low', 'close', 'volume']\n",
    "        if not all(col in df.columns for col in required_columns):\n",
    "            raise ValueError(f\"CSV file is missing required columns. Please ensure it contains: {required_columns}\")\n",
    "\n",
    "        print(f\"Successfully loaded {len(df)} rows of data.\")\n",
    "        print(\"First 5 rows of data:\")\n",
    "        print(df.head())\n",
    "        return df\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: File '{file_path}' not found. Please check the path.\")\n",
    "        return None\n",
    "    except Exception as e:\n",
    "        print(f\"Error during data loading or preprocessing: {e}\")\n",
    "        return None\n",
    "\n",
    "\n",
    "df_raw = load_and_preprocess_data(file_path)\n",
    "print(df_raw)\n",
    "# df_df_raw = df_df_raw[df_df_raw.index >= '2024-01-01']"
   ],
   "id": "1638e05ca7ef1ac8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully loaded 26087 rows of data.\n",
      "First 5 rows of data:\n",
      "                       open    high     low   close    volume   open_oi  \\\n",
      "datetime                                                                  \n",
      "2020-12-31 14:45:00  4534.0  4569.0  4528.0  4554.0   50433.0  526437.0   \n",
      "2021-01-04 09:00:00  4507.0  4510.0  4451.0  4468.0  149169.0  523892.0   \n",
      "2021-01-04 09:15:00  4468.0  4473.0  4423.0  4437.0   75329.0  513989.0   \n",
      "2021-01-04 09:30:00  4437.0  4460.0  4435.0  4447.0   47021.0  514326.0   \n",
      "2021-01-04 09:45:00  4447.0  4474.0  4446.0  4473.0   28511.0  509735.0   \n",
      "\n",
      "                     close_oi underlying_symbol  \n",
      "datetime                                         \n",
      "2020-12-31 14:45:00  523892.0       SHFE.hc2105  \n",
      "2021-01-04 09:00:00  513989.0       SHFE.hc2105  \n",
      "2021-01-04 09:15:00  514326.0       SHFE.hc2105  \n",
      "2021-01-04 09:30:00  509735.0       SHFE.hc2105  \n",
      "2021-01-04 09:45:00  509228.0       SHFE.hc2105  \n",
      "                       open    high     low   close    volume    open_oi  \\\n",
      "datetime                                                                   \n",
      "2020-12-31 14:45:00  4534.0  4569.0  4528.0  4554.0   50433.0   526437.0   \n",
      "2021-01-04 09:00:00  4507.0  4510.0  4451.0  4468.0  149169.0   523892.0   \n",
      "2021-01-04 09:15:00  4468.0  4473.0  4423.0  4437.0   75329.0   513989.0   \n",
      "2021-01-04 09:30:00  4437.0  4460.0  4435.0  4447.0   47021.0   514326.0   \n",
      "2021-01-04 09:45:00  4447.0  4474.0  4446.0  4473.0   28511.0   509735.0   \n",
      "...                     ...     ...     ...     ...       ...        ...   \n",
      "2025-09-19 21:30:00  3391.0  3393.0  3387.0  3389.0   15546.0  1406485.0   \n",
      "2025-09-19 21:45:00  3389.0  3392.0  3386.0  3388.0   11803.0  1406923.0   \n",
      "2025-09-19 22:00:00  3388.0  3391.0  3387.0  3387.0    7365.0  1406315.0   \n",
      "2025-09-19 22:15:00  3387.0  3390.0  3385.0  3389.0   10361.0  1405811.0   \n",
      "2025-09-19 22:30:00  3389.0  3390.0  3385.0  3387.0   10758.0  1404506.0   \n",
      "\n",
      "                      close_oi underlying_symbol  \n",
      "datetime                                          \n",
      "2020-12-31 14:45:00   523892.0       SHFE.hc2105  \n",
      "2021-01-04 09:00:00   513989.0       SHFE.hc2105  \n",
      "2021-01-04 09:15:00   514326.0       SHFE.hc2105  \n",
      "2021-01-04 09:30:00   509735.0       SHFE.hc2105  \n",
      "2021-01-04 09:45:00   509228.0       SHFE.hc2105  \n",
      "...                        ...               ...  \n",
      "2025-09-19 21:30:00  1406923.0       SHFE.hc2601  \n",
      "2025-09-19 21:45:00  1406315.0       SHFE.hc2601  \n",
      "2025-09-19 22:00:00  1405811.0       SHFE.hc2601  \n",
      "2025-09-19 22:15:00  1404506.0       SHFE.hc2601  \n",
      "2025-09-19 22:30:00  1402724.0       SHFE.hc2601  \n",
      "\n",
      "[26087 rows x 8 columns]\n"
     ]
    }
   ],
   "execution_count": 43
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:02.224837Z",
     "start_time": "2025-12-08T15:18:02.203253Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import talib\n",
    "from scipy.signal import stft\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm\n",
    "\n",
    "class UniversalAnalyzer:\n",
    "    def __init__(self, df: pd.DataFrame, bars_per_day: int = 23):\n",
    "        \"\"\"\n",
    "        :param df: 包含 ['high', 'low', 'close'] 的原始数据\n",
    "        :param bars_per_day: 每天的K线数 (如小时线=23, 15分钟=96)\n",
    "        \"\"\"\n",
    "        self.df = df.reset_index(drop=True)\n",
    "        self.bars_per_day = bars_per_day\n",
    "        self.high_freq_days = 1.0  # 固定物理常数：过滤日内噪音\n",
    "        print(f\"--- 分析器初始化: {len(df)} Bars, {bars_per_day} Bars/Day ---\")\n",
    "\n",
    "    # ================= 工具函数：STFT 计算核心 =================\n",
    "    def _calc_stft_signal(self, prices, window_days):\n",
    "        window_len = int(window_days * self.bars_per_day)\n",
    "        if window_len % 2 != 0: window_len += 1\n",
    "\n",
    "        # 极短数据保护\n",
    "        if len(prices) < window_len: return np.zeros(len(prices))\n",
    "\n",
    "        # 1. 滚动计算方差进行标准化 (简单起见，这里用全量标准化，严谨可用Rolling)\n",
    "        # 为了速度和形态分析，全量标准化是可以接受的近似\n",
    "        norm = (prices - np.mean(prices)) / (np.std(prices) + 1e-9)\n",
    "\n",
    "        try:\n",
    "            f, t, Zxx = stft(norm, fs=self.bars_per_day, nperseg=window_len,\n",
    "                             noverlap=max(0, window_len // 2), padded=False)\n",
    "        except:\n",
    "            return np.zeros(len(prices))\n",
    "\n",
    "        # 提取当前时间步的能量 (Zxx最后一维是时间，我们需要对齐)\n",
    "        # STFT 输出时间轴通常比原数据短，这里我们需要做对齐处理\n",
    "        # 为简化分析，我们使用逐点滑窗计算的模拟函数\n",
    "        return None # 占位，实际调用下面的 _generate_full_series\n",
    "\n",
    "    def _generate_full_series(self, window_days):\n",
    "        \"\"\"生成全历史 STFT 强度序列\"\"\"\n",
    "        window_len = int(window_days * self.bars_per_day)\n",
    "        if window_len % 2 != 0: window_len += 1\n",
    "\n",
    "        closes = self.df['close'].values\n",
    "        n = len(closes)\n",
    "        signals = np.zeros(n)\n",
    "\n",
    "        # 步长设为1保证精度，设为5-10可加速\n",
    "        step = 1\n",
    "\n",
    "        # 使用 stride_tricks 进行超高速计算 (替代循环)\n",
    "        # 注意：这里计算的是每一个窗口的“瞬时”状态\n",
    "\n",
    "        print(f\"正在计算 Window={window_days} 的信号序列...\")\n",
    "        for i in range(window_len, n, step):\n",
    "            segment = closes[i-window_len:i]\n",
    "            std_val = np.std(segment)\n",
    "            if std_val < 1e-9: continue\n",
    "\n",
    "            norm = (segment - np.mean(segment)) / std_val\n",
    "\n",
    "            try:\n",
    "                f, t, Zxx = stft(norm, fs=self.bars_per_day, nperseg=window_len,\n",
    "                                 noverlap=max(0, window_len // 2), padded=False)\n",
    "\n",
    "                # 只取最后一列频谱\n",
    "                spec = np.abs(Zxx[:, -1]) ** 2\n",
    "                freqs = f\n",
    "\n",
    "                # 频率绑定\n",
    "                low_limit = (1.0 / window_days) + 1e-5 # 加上偏移量防止丢失基频\n",
    "\n",
    "                low_mask = freqs <= low_limit\n",
    "                high_mask = freqs > self.high_freq_days\n",
    "\n",
    "                low_e = np.sum(spec[low_mask])\n",
    "                high_e = np.sum(spec[high_mask])\n",
    "\n",
    "                signals[i] = low_e / (low_e + high_e + 1e-9)\n",
    "            except:\n",
    "                continue\n",
    "\n",
    "        return signals\n",
    "\n",
    "    # ================= 模块 1: 确定止损 (物理常数) =================\n",
    "    def step1_analyze_stop_loss(self):\n",
    "        print(\"\\n=== [Step 1] 止损参数标定 ===\")\n",
    "        high = self.df['high'].values\n",
    "        low = self.df['low'].values\n",
    "        close = self.df['close'].values\n",
    "\n",
    "        atr = talib.ATR(high, low, close, timeperiod=14)\n",
    "        tr = talib.TRANGE(high, low, close)\n",
    "\n",
    "        # 过滤无效数据\n",
    "        mask = (atr > 0) & (~np.isnan(atr))\n",
    "        ratios = tr[mask] / atr[mask]\n",
    "\n",
    "        p99 = np.percentile(ratios, 99)\n",
    "        p99_7 = np.percentile(ratios, 99.7) # 3倍标准差，塔勒布极限\n",
    "\n",
    "        print(f\"建议止损倍数 (基于 P99.7): {p99_7:.2f}\")\n",
    "        suggested = np.ceil(p99_7 * 2) / 2 # 向上取整到0.5\n",
    "        print(f\"-> 最终推荐 Stop Loss ATR Multiplier: {suggested}\")\n",
    "        return suggested\n",
    "\n",
    "    # ================= 模块 2: 确定窗口 (信噪比) =================\n",
    "    def step2_select_window(self, windows=[2.0, 3.0, 4.0, 5.0, 6.0]):\n",
    "        print(\"\\n=== [Step 2] 最佳窗口扫描 ===\")\n",
    "        best_w = None\n",
    "        max_std = -1\n",
    "\n",
    "        stats = []\n",
    "        for w in windows:\n",
    "            sigs = self._generate_full_series(w)\n",
    "            # 去除0值(预热期)\n",
    "            sigs = sigs[sigs > 0]\n",
    "\n",
    "            if len(sigs) == 0: continue\n",
    "\n",
    "            std_val = np.std(sigs)\n",
    "            stats.append((w, std_val))\n",
    "            print(f\"Window {w}: StdDev = {std_val:.4f}\")\n",
    "\n",
    "            if std_val > max_std:\n",
    "                max_std = std_val\n",
    "                best_w = w\n",
    "\n",
    "        print(f\"-> 最终推荐 Spectral Window Days: {best_w} (区分度最高)\")\n",
    "        return best_w\n",
    "\n",
    "    # ================= 模块 3: 确定阈值 (分布+收益) =================\n",
    "    def step3_calibrate_thresholds(self, best_window):\n",
    "        print(\"\\n=== [Step 3] 阈值校准 (分布 & IC分析) ===\")\n",
    "        # 1. 生成信号\n",
    "        signals = self._generate_full_series(best_window)\n",
    "        closes = self.df['close'].values\n",
    "\n",
    "        # 2. 基础分布统计 (PDF) -> 确定 Exit\n",
    "        valid_sigs = signals[signals > 0]\n",
    "        p50 = np.median(valid_sigs)\n",
    "        print(f\"分布中位数 (建议 Exit Threshold): {p50:.2f}\")\n",
    "\n",
    "        # 3. 收益分组分析 (Bucketing) -> 确定 Entry\n",
    "        # 计算未来收益 (持有窗口长度)\n",
    "        hold_period = int(best_window * self.bars_per_day)\n",
    "        fwd_ret = pd.Series(closes).pct_change(hold_period).shift(-hold_period)\n",
    "\n",
    "        # 确定方向: 简单用过去 hold_period 的涨跌作为方向过滤器\n",
    "        # 假设: Signal强 且 过去在涨 -> 做多; Signal强 且 过去在跌 -> 做空\n",
    "        past_ret = pd.Series(closes).pct_change(hold_period).fillna(0)\n",
    "        direction = np.sign(past_ret)\n",
    "\n",
    "        # 策略收益 = 方向 * 未来收益 (假设做对方向)\n",
    "        # 我们只关心 Signal 强度是否能放大收益\n",
    "        df_anl = pd.DataFrame({\n",
    "            'signal': signals,\n",
    "            'fwd_ret': fwd_ret,\n",
    "            'direction': direction\n",
    "        }).dropna()\n",
    "\n",
    "        df_anl = df_anl[df_anl['signal'] > 0]\n",
    "\n",
    "        # 核心假设: 我们在信号强时顺势交易\n",
    "        df_anl['strat_ret'] = np.sign(df_anl['direction']) * df_anl['fwd_ret']\n",
    "\n",
    "        # 分桶\n",
    "        df_anl['bucket'] = pd.cut(df_anl['signal'], bins=np.linspace(0, 1, 21))\n",
    "        grouped = df_anl.groupby('bucket', observed=False)['strat_ret'].mean()\n",
    "        counts = df_anl.groupby('bucket', observed=False)['strat_ret'].count()\n",
    "\n",
    "        # 绘图\n",
    "        fig, ax1 = plt.subplots(figsize=(12, 5))\n",
    "        colors = ['red' if v > 0 else 'green' for v in grouped.values]\n",
    "        grouped.plot(kind='bar', ax=ax1, color=colors, alpha=0.7)\n",
    "        ax1.set_title(f\"Signal Strength vs Profitability (Window={best_window})\")\n",
    "        ax1.set_ylabel(\"Avg Future Return\")\n",
    "\n",
    "        ax2 = ax1.twinx()\n",
    "        counts.plot(kind='line', ax=ax2, color='blue', marker='o')\n",
    "        plt.show()\n",
    "\n",
    "        print(\"请观察图表:\")\n",
    "        print(\"1. 寻找红色柱子稳定出现且较高的区域起始点 -> Entry Threshold\")\n",
    "        print(\"2. 避开深绿色柱子区域 (陷阱区)\")\n",
    "\n",
    "        return grouped\n",
    "\n",
    "    # ================= 模块 4: 热力图验证 (鲁棒性) =================\n",
    "    def step4_heatmap_validation(self, center_window, center_entry, stop_loss_mult):\n",
    "        print(\"\\n=== [Step 4] 热力图鲁棒性验证 ===\")\n",
    "\n",
    "        # 构建搜索网格 (在中心点附近波动)\n",
    "        windows = [center_window - 1.0, center_window - 0.5, center_window, center_window + 0.5, center_window + 1.0]\n",
    "        # 过滤掉不合理的窗口\n",
    "        windows = [w for w in windows if w >= 2.0]\n",
    "\n",
    "        entries = np.arange(max(0.6, center_entry - 0.15), min(0.95, center_entry + 0.15), 0.05)\n",
    "\n",
    "        results = pd.DataFrame(index=np.round(entries, 2), columns=windows)\n",
    "\n",
    "        # 这里使用快速回测逻辑 (简化版)\n",
    "        for w in tqdm(windows):\n",
    "            signals = self._generate_full_series(w)\n",
    "            closes = self.df['close'].values\n",
    "            atr = talib.ATR(self.df['high'], self.df['low'], closes, timeperiod=14)\n",
    "            atr = np.nan_to_num(atr, nan=np.mean(closes)*0.01)\n",
    "\n",
    "            for e in entries:\n",
    "                # 固定 Exit 为 0.45 (或基于 P50 的动态值，这里简化固定)\n",
    "                calmar = self._fast_backtest_calmar(\n",
    "                    signals, closes, atr,\n",
    "                    entry=e, exit=0.45, sl=stop_loss_mult\n",
    "                )\n",
    "                results.loc[np.round(e, 2), w] = calmar\n",
    "\n",
    "        plt.figure(figsize=(10, 6))\n",
    "        sns.heatmap(results.astype(float), annot=True, cmap=\"RdYlGn\", fmt=\".2f\")\n",
    "        plt.title(f\"Robustness Heatmap (SL={stop_loss_mult})\")\n",
    "        plt.gca().invert_yaxis()\n",
    "        plt.show()\n",
    "\n",
    "    def _fast_backtest_calmar(self, signals, closes, atr, entry, exit, sl):\n",
    "        # 极简向量化回测计算 Calmar\n",
    "        # 仅供参数敏感度分析，非精确回测\n",
    "        pos = np.zeros(len(closes))\n",
    "        # 简单的状态机模拟\n",
    "        curr_pos = 0\n",
    "        entry_px = 0\n",
    "\n",
    "        # 预计算方向 (动量)\n",
    "        mom = np.sign(pd.Series(closes).pct_change(5).fillna(0).values)\n",
    "\n",
    "        equity = [1.0]\n",
    "        for i in range(1, len(closes)):\n",
    "            px = closes[i]\n",
    "            sig = signals[i-1]\n",
    "            my_atr = atr[i-1]\n",
    "\n",
    "            pnl = 0\n",
    "            if curr_pos == 0:\n",
    "                if sig > entry:\n",
    "                    curr_pos = mom[i-1] # 顺势\n",
    "                    entry_px = px\n",
    "            elif curr_pos != 0:\n",
    "                # 止损\n",
    "                if curr_pos == 1 and px < (entry_px - sl * my_atr): curr_pos = 0\n",
    "                elif curr_pos == -1 and px > (entry_px + sl * my_atr): curr_pos = 0\n",
    "                # 离场\n",
    "                elif sig < exit: curr_pos = 0\n",
    "\n",
    "                # 计算 PnL\n",
    "                if curr_pos == 1: pnl = (px - closes[i-1]) / closes[i-1]\n",
    "                elif curr_pos == -1: pnl = (closes[i-1] - px) / closes[i-1]\n",
    "\n",
    "            equity.append(equity[-1] * (1 + pnl))\n",
    "\n",
    "        eq_series = pd.Series(equity)\n",
    "        dd = (eq_series / eq_series.cummax() - 1).min()\n",
    "        if dd == 0: return 0\n",
    "        ann_ret = (eq_series.iloc[-1] ** (252*self.bars_per_day/len(eq_series))) - 1\n",
    "        return ann_ret / abs(dd)"
   ],
   "id": "b98755d3f0552e8b",
   "outputs": [],
   "execution_count": 44
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:02.237244Z",
     "start_time": "2025-12-08T15:18:02.227739Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 假设是15分钟线，一天有 4小时(夜盘)+5.5小时(日盘) = 9.5小时 ≈ 38根bar?\n",
    "# 或者按照实际交易所 bar 数填写\n",
    "analyzer = UniversalAnalyzer(df_raw, bars_per_day=23)"
   ],
   "id": "57962b7585161e57",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 分析器初始化: 26087 Bars, 23 Bars/Day ---\n"
     ]
    }
   ],
   "execution_count": 45
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:02.252250Z",
     "start_time": "2025-12-08T15:18:02.246891Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 这一步直接给你 StopLoss 参数\n",
    "sl_mult = analyzer.step1_analyze_stop_loss()\n",
    "# 记录这个值，例如 4.0"
   ],
   "id": "5a4888719bd6ccf",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== [Step 1] 止损参数标定 ===\n",
      "建议止损倍数 (基于 P99.7): 3.49\n",
      "-> 最终推荐 Stop Loss ATR Multiplier: 3.5\n"
     ]
    }
   ],
   "execution_count": 46
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:12.422635Z",
     "start_time": "2025-12-08T15:18:02.258765Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 这一步通过打印的 StdDev 帮你找最敏感的窗口\n",
    "best_window = analyzer.step2_select_window([2.0, 3.0, 4.0, 5.0, 6.0, 8.0])\n",
    "# 记录这个值，例如 5.0 (StdDev最大)"
   ],
   "id": "65c036e6236cff5",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== [Step 2] 最佳窗口扫描 ===\n",
      "正在计算 Window=2.0 的信号序列...\n",
      "Window 2.0: StdDev = 0.2481\n",
      "正在计算 Window=3.0 的信号序列...\n",
      "Window 3.0: StdDev = 0.2468\n",
      "正在计算 Window=4.0 的信号序列...\n",
      "Window 4.0: StdDev = 0.2326\n",
      "正在计算 Window=5.0 的信号序列...\n",
      "Window 5.0: StdDev = 0.2270\n",
      "正在计算 Window=6.0 的信号序列...\n",
      "Window 6.0: StdDev = 0.2172\n",
      "正在计算 Window=8.0 的信号序列...\n",
      "Window 8.0: StdDev = 0.2069\n",
      "-> 最终推荐 Spectral Window Days: 2.0 (区分度最高)\n"
     ]
    }
   ],
   "execution_count": 47
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:14.229745Z",
     "start_time": "2025-12-08T15:18:12.429188Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 这一步会画出柱状图\n",
    "# 1. 看控制台输出的 Median -> 这是你的 Exit Threshold (比如 0.42)\n",
    "# 2. 看弹出的图表 -> 找到红色柱子开始稳定且高的位置 -> 这是你的 Entry Threshold (比如 0.85)\n",
    "analyzer.step3_calibrate_thresholds(best_window)"
   ],
   "id": "dce8f46ee6f5c5dd",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== [Step 3] 阈值校准 (分布 & IC分析) ===\n",
      "正在计算 Window=2.0 的信号序列...\n",
      "分布中位数 (建议 Exit Threshold): 0.71\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "请观察图表:\n",
      "1. 寻找红色柱子稳定出现且较高的区域起始点 -> Entry Threshold\n",
      "2. 避开深绿色柱子区域 (陷阱区)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "bucket\n",
       "(0.0, 0.05]   -0.000708\n",
       "(0.05, 0.1]   -0.000032\n",
       "(0.1, 0.15]    0.001019\n",
       "(0.15, 0.2]   -0.000725\n",
       "(0.2, 0.25]    0.001073\n",
       "(0.25, 0.3]    0.000758\n",
       "(0.3, 0.35]    0.001053\n",
       "(0.35, 0.4]   -0.000009\n",
       "(0.4, 0.45]    0.000594\n",
       "(0.45, 0.5]    0.000253\n",
       "(0.5, 0.55]   -0.000740\n",
       "(0.55, 0.6]    0.001504\n",
       "(0.6, 0.65]   -0.000038\n",
       "(0.65, 0.7]   -0.000405\n",
       "(0.7, 0.75]   -0.000288\n",
       "(0.75, 0.8]   -0.000446\n",
       "(0.8, 0.85]    0.000360\n",
       "(0.85, 0.9]    0.000232\n",
       "(0.9, 0.95]    0.000909\n",
       "(0.95, 1.0]   -0.000822\n",
       "Name: strat_ret, dtype: float64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 48
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-12-08T15:18:19.894590Z",
     "start_time": "2025-12-08T15:18:14.240383Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 把上面找到的参数填进去，跑热力图\n",
    "# center_window = 5.0, center_entry = 0.85, sl = 4.0\n",
    "analyzer.step4_heatmap_validation(best_window, 0.85, 4.0)"
   ],
   "id": "1fd393d531324435",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "=== [Step 4] 热力图鲁棒性验证 ===\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/3 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在计算 Window=2.0 的信号序列...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|███▎      | 1/3 [00:01<00:03,  1.77s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在计算 Window=2.5 的信号序列...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|██████▋   | 2/3 [00:03<00:01,  1.81s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在计算 Window=3.0 的信号序列...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3/3 [00:05<00:00,  1.83s/it]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvsAAAIQCAYAAAAfAqEPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZdVJREFUeJzt3Qd0VNX2x/Ffeg+E3kPvIIgUQUFALPAERAT1iWKnib1gQ0AfD/VhR1QU7KhYEARBwC4g0qV3KQKBENJ7/usc/gkJE9LIkOTy/aw1i8yZuXfOTBKy77777OuRkZGRIQAAAACO41nSEwAAAADgHgT7AAAAgEMR7AMAAAAORbAPAAAAOBTBPgAAAOBQBPsAAACAQxHsAwAAAA5FsA8AAAA4FME+AKDAjh8/rkOHDjnqE9u2bVtJTwEA3IZgHwBQICkpKbr77rv11VdfOeYT+/vvvzVkyBBt2rSppKcCAG5BsA+UcsuXL1eTJk2ybh07dtTw4cO1Y8eOAu/j1Vdf1b/+9S+3ztMpzGf8zjvv5BgzweCIESN0rps8ebKCgoJ05513Zo39/vvvGjBggFq3bq3LL79c3333XY6fuwsuuKBY5zBjxgz16NGjUNukp6frpZdeUpcuXXTxxRfr/fffz3qsTp06evrppzVy5EglJCQU61wBoDQg2AfKiEmTJunzzz/X2LFjtXv3bv373/+2JRWlzZdffmkPUJA/Ewzv27evTHxU27dv1+zZs/Xss8/K0/PEn44tW7bYwP+SSy7R22+/rfPOO08PPPCA9uzZ47YsvAnai/I5mwO4YcOG6cknn9SUKVM0b968rMevuOIKnX/++XrzzTeLecYAUPII9oEyokGDBjZ72rt3b73yyis6duyYfvjhB5U2psTjjz/+KOlplAmvvfaa9u/fr7LAZNSHDh2qChUqZI19/fXXqlevnkaPHm3POD3zzDMKDg7WN998U+yvn5GRoccff1xeXl6F2i42NtYG+maO5gzNZZddpgcffFCvv/56juc99NBD+uSTT5ScnFzMMweAkkWwD5RBjRo1UkBAgA4ePFjSU8E5wJTBLF68WH369MkxHhUVpejoaFvLb/j6+urdd99V3759C7TfRx99NEeJWvabCcyz+/jjj7V161bdddddhZr7ypUrlZSUlGNOl156qT1TkX2hcdWqVdW4cWP99ttvhdo/AJR2BPtAGRQTE2Pri7NnWX/66SddddVVatmypQ1sfv75Z5ft3njjDXXo0EGdOnWyZwdMttQwpSQmwDq1pMSMZS/Jeeutt2y9tCnXMHXa2R/LDNJMVt9krDPvZ+4zc+1BRESELado06aNevXqlWOeJqg023br1k1t27bVbbfdpr1797qUCZnacHOW48orr8xRI26sWbNG1113nd3e1Geb91ncNm/ebLPc5nPo2bOnzXpnd+TIEd133302220+73vuuUeRkZE5PgdzM2666Sb7dWYdeub3Yvr06brwwgvtezTf2+7du+uiiy7SunXr7PPi4+P11FNPqXPnzmrXrp3LZ2X2Z0puTNBs5nnNNddo1apVRXq/hw8flo+Pj2rWrJlj3MzJHHDecccd9jMxWrRoofDw8ALt12TbzdmB3G7mLEEmc/bjhRdesCVslSpVKvTcy5cvb4P5TOZ+SEiILQvKzpTymNIkAHASgn2gjDFB47hx42zw1bVrVzu2dOlSG0CbANfUTptA2tzPHozv2rVLixYt0v/+9z/deuutmjp1qmbOnFng183c1gSnpra5adOmdlFjZtnDrFmz7M0Ee4MGDcq6X6VKlRz7MYGhKf0wBx41atTQI488YoN8w9RSmyDXBIHm67i4OBtUp6am2sc3bNigxx57zB4kmNIME2ibkox//vnHPm6eZzK/JpAzByZmP9OmTdO3335bqM/4ueeey5Flzl6WZMqnbr75ZrtQ1byG+do836ynyF4SYrq7mHHzmZnWjiZYNcznk/nZGOZ7ab42n0d2JpNu1mmYgNSUr5hANywsLKsTzn/+8x/7HLO9KUkxB39PPPFEjn188MEHNtA3+zbfB3NAYILfwjLbVK5c2WXclMSY75/Jnvfr189+3gcOHCjwfs33v1mzZrnesh8wmDp787NuStgKKzEx0f48nCowMDDrACyT+YyK8vkAQGnmXdITAFAwAwcOzPraZPRNEFmtWjV73wR7Jis5fvx4e99khHfu3Gmz5Ca7bKSlpdluKiaIMhlvk8F87733dP311xfo9U3G2RxgmEDeBEomaDVBt9mv0apVK/uvCYJN0JR5/1SmO4sJEDOfe+2119psv8m2muD5/vvvt1lowwS3Joj8888/7dkIE0iasxHmcXPAYA5qTFbbz8/PPt8cHJjSElOm0b59e3urW7euKlasWKgfM3OA0b9//6z7JtjO9NFHH9kFqi+++KItWzGfrzkYMItXzXsxTOcj8/mYAyLDrK1YtmyZ/drUtGf/bMz7yO2zMp+D+Z6az3Lw4MF2Eez8+fOzOsaYjL45u2KeY/z11192IWp2Zm7mYMgwZ0LM9/2LL76w3ZwKw7zfzLNApzIHjqa8xxwAfvbZZzbw//DDD+37yo85yMs80DuVh4eHrc83B1HmrMHcuXNVFOZ7lFudv9m/ORDIzvwsZy4+BgCnINgHygiTGTaLdE0LSBPgmlKWTCbQM1nb7EzAb7LamUwZQ/ZsqQn+FixYcNpg69Rxk8U1wbgJZE2gac4imDmYtQOFYboIZcosQzI136bDkKmtnjhxor1lZ7q7mGDfvCcTvN944422jaIJ9k0nlcz9lCtXzgaepnzFlL6YrLYJ/OvXr1+oOZoA22SXM5mDkkzmIMlkhE8N0LNnvs1nZYJq0zlm7dq19gCkevXqhZ5DZlCa/etM5n2ZLL8pITKlS+aA6dTvWeaBQOZBhgnATy1dKQjz3vLKeJufLVNSZA6QzJkOc0bCnDnKjzlLc7qe/ab8yfzMm32ZsxjZS9YKwxzo5XYRMNPJyhy0Zmc+w1PPRAFAWUewD5QRJsht3ry5LYMxway5uJEZM06Xdc0+fmrG0mQ7zeOnC/YzS2Oyl1yYg4NffvnFZm9NZtuU2piMtgkkC8r0Nc+LCezM+8wus97avI55vV9//dXOwZT8vPzyy7aOP7Oe3Jy9WLFihb39+OOPNuA2GW8THBcXc6CUeRYlU2b22HR/MUGvmav595ZbbrEHMsXZ1tFkoM0BjznoMGcTzM18H7P3v8/t58Lcz37AUFAmADbbmVKw7Bl7c2bBlHVlngUxn4sZ+/777wu0X1P2Yw4OcmMCcbNY1qxPMT/rpzLlVeag0LxeXszzzNkQUwJmzrYY5hoVZuzUwN6coTHrKwDASThfCZQxJrAzixSzB48my3xqb3tTNpI9+2wWUmavpzZnA0wA7+3tbW9G9rIGUzKSnSmnMK9h6qZNDbUp1TClPWa9wKllE5k19rk5XetEc9bBbGtKcTLrts2ZDJO5zlw0uXDhQlt/bwJ3UwpkFnKa52cGl6bcwxyEmPIdcwbEtFI02X2TZS/OTkjmQMjMLXOeJgjOXP9gPnfzuZgSKhPom1KaUxcZZzLvN7MMqjDMGgBzxsAsYjVrFEx5Tm618uaAJ5MJmk1pV+YBYmGYQN+crTAHWtmZA5tTf+7Mmgbzc1UcNftmkfGpC3dN4G/ONJivC3Jxrdq1a9sg35yVymTK18xZoMzgP/PskTnrYc4oAICTkNkHyhgTIN5+++128eeoUaNsRtsslDW10+ZKoKa0xmTgMzPfp9aBm2DJtDA0NdCZ9dwmw2nq401A//DDD9vs/amLd02HGRPAmgW5Zq1AZhecWrVq5XieCa7NY6bUxzzXlEsU5Oq9/v7+9n2Z1zDv0QTTZg6m3j0zs2sORkw21wSfJmg1tfymBChzDqbcxizcNQcv5vVN+YbJ4l599dUqLiajbg50TLcd8/XRo0c1YcIE2wnJMJ+jYcpTTOmROUAxdf65LXA1n9Wnn35q37s5GDNnMLJ3jTkdE6iaz8BcGMq8V3MVW7Mw2zAHWpkHb6a8x5TBmIMBE+CaszuZ6yEKyxy4mHUjZs1GZjBvuh6ZUhsTmJvSMtPtx3zvn3/++aztzMGMmV9u7z17eVRuzDoOc8vOLHw2Px/Zy6zWr19v53S6tRnmZ9qUuZnOROazNh2gxowZk/U5ZZ5RMmfNso8BgBPwvxpQBpkFmyZTaQI8E+CbWnZTI20CL9PZxZRamPuZi3MNEzybgMyUTpggy3TrMSUYhgkCzcGDKU0xAb/JeJrts/dVN4G4yaKb1zC1zSa4Mpnl7EFX5vNMltQsAjVlI6euJciLOXgxczHlQeYgwZTzmOA9M5g3LUVN7bg5q2Gy6ya4M0F3ZomOyeKagwVzM/3eTVBoOvaY91xcTO24Odvw3//+12bVTeBtguDM8g/zGZuvTYBv5p65INkE3SbDb+aYyRwkmMW/ppTFlP2YfRYk2Df1/2Zb8zmZgwrTbtX8HJgaeHOQl/l9N99fc7bDdOXJ7IBU2MXKmcz3wBxQmgNG8/5N0GwWMpuDDnNQZn5ezHszJWbZf25Mi1BzoHAqk5k/9WenqMznb4J3M5/cmIMuc4Bmfi7M+gnzc5u5mNowB0Lm5+nU3v4A4AQeGacr9gUAlFmmxMUshi7MwVZ+zJ8LczbInFXJrY6+LDKlO+YMjSn5OvU6AgDgBGT2AQAFYrL4powqrzUZZY1ZMP7NN9+4lAsBgFOQ2QcAAAAcim48AAAAgEMR7AMAAAAORbAPAAAAOBTBPgAAAOBQBPsAAACAQ5Wq1psZa8eW9BSAMunTgKMlPQWgTFqwJ6GkpwCUOdN7vaPSymN4J7ftO+ONZSqLyOwDAAAADlWqMvsAAABAUXl4evDhnYJgHwAAAI5AsO+KMh4AAADAocjsAwAAwBHI7Lsisw8AAAA4FJl9AAAAOAKZfVdk9gEAAACHIrMPAAAAR/DwoPXmqcjsAwAAAA5FZh8AAACOQM2+K4J9AAAAOALBvivKeAAAAACHIrMPAAAARyCz74rMPgAAAOBQZPYBAADgCGT2XZHZBwAAAByKzD4AAAAcgcy+KzL7AAAAgEOR2QcAAIAjkNl3RbAPAAAARyDYd0UZDwAAAOBQZPYBAADgCB4eHiU9hVKHzD4AAADgUGT2AQAA4AjU7Lsisw8AAAA4FJl9AAAAOAKZfVdk9gEAAAA3S09P1913361XX3210NvOmDFDQ4YMKdLrEuwDAADAMZl9d93ORFJSkh599FEtXLiw0Nt++OGHmjRpUpFfm2AfAAAAjlBag/2nn35aPj4+atu2baG2+/rrr/XNN9/o2muvLfJrU7MPAAAA5KNnz555Pr548eLTPjZs2DCFh4cXuhTnggsu0FVXXaUpU6Zo165dKgqCfQAAADhCaV2gGx4eXqTtatWqdcavTbAPAAAA5COvzH1pRrAPAAAARyitmf2SxAJdAAAAwKHI7AMAAMARylpmPz09XbGxsQoKCpKXl5dbXoPMPgAAAFACDhw4oPbt22vr1q0ln9lPSUnRhAkTNH/+fHl6eqpHjx669dZb1ahRI7dNDgAAAHBKZv+DDz5w6bazZcuWfLczV951e2Z/6tSp+vXXX3XvvffqgQce0M6dO9W/f3+NHTtWUVFRRZ4AAAAAgBLO7H/11VeaPHmy2rRpY++bQN80+TdtiBYsWGAPAM7k6l44O9LTM/TqZ+v1+eKd8vT00O39mumm3o0LvZ9f1vyjOyf+pE+f7aXWDStmje/+J0bjpv2p1VuOyNPDQz3b19TTd16gIH+fYn4nwNn9vfnh4x1atWC/zRpddE1ddepbp8Dbr1lyQL9/tUdH98erUu0gXTqkoRpdUCnr8ZTkNH03bas2/HpI/oHeuvTmhmp5cTU3vRvg7PGQh/o36KduNbsqPSNd83bP16K9BW9f2Ln6hbo8/HJVD6ymA3H/6IvtX2j90b+yHq8WWE0DG12j5hWaKzktSb8c+FVf75ittIw0N70jlHYeHqU7s1+qg/2EhATVrFkz676vr6+aNGmiESNGaP369Xr11Vf1xRdfaObMme6aK4rBa5//pXfmbNZDN7ZR1QoBGvvWn6pU3l+9Oxc8cElMTrUB/YBL6uUI9BOSUnXXf3+Wj5eHHr25raJikjTliw3y8/XSM8M68P1DmfXjxzv0+5d71OuWRgqt6Kc5r29ScJhvgQLyP7/bp3lvblbPmxqqdpPyWv/LQX00YbVuHHu+Gp5/4vdnzmubtOWPCF15ZxNlpEtfv7xB5Sr7q3bT8mfh3QHu069BX10ZfoU+3faZopKidHOzmxSdHK0/Dq3Id1tzgPDvpjfoi+1fakfUTnWs1kH3tr1Hk1e9pA2RG1TOt5webz9GW6K26uU1L6uSfyVd13iwKvpX0Ft/TePbeo4q7WU8pTrYN5frffHFF/X000/bQP+vv/7SihUrVLt2bTVt2lS9e/fWG2+84d7Z4ozExqfonW82a/SgVhpy5YlsfkxciqbM+qtQwf7rszboeGyy7r/hvBzj3/yyW8nJafr8hSsUGuRrx+ISUzVz4XaCfZRZifGp+u2rPer+7wbqdNWJ35PEuFT9+MnOfIP9jIwM/TRzpzr+q466XF3XjtVpXl4Hd8bo969222D/yL44rfvxHw18qFXW/o4djNdPn+7SjWPbnoV3CLiHv5e/DfS/2vG1Fu9dYscCvQPVt/5VBQr2zfMW/71EC/YstPe3H9+uOiG1dUXdy22wf2mdnkpOT9bUdW8qNSNVW7RVnh6eurXFLfps2yx7cAGgEDX7Dz30kJYtW6ZOnTrpsssu06BBgzR06FDbKsgw/z744IN8pqXYqi0RSkpJ01UXn7xkc88ONbV9X7QORSYUaB9b/47SjDlbdPeglqpYzj/HY7061NKMsd2zAn2jfLCf0tIzivFdAGfX3o1RSk1OV+tLTgb2TTtVUcTeOEUfTcxz25jIJEUfTVKDthVyjFeqFaSowye23bkuUt6+nmp2YZUc+9+9LlLpafzuoOxqVL6hfL18tfTgsqyxVYdXq2ZwTZX3y/uslXm8gn8FG9Rn90/cQVXyP3FGrG5oXW2N2mYD/eyPG5nPwbmZ2XfXzfGZ/Tp16thOPD///LMiIyPVsmVLtWjRwr2zQ7EyAX25YF9VrRCYIxgPCfTR3wdjbFlPfsa/s9L+u+3v43rktWXq3q6GrrjwRLazQqi/vWX3y5oDatvkZG0yUNaYgD4gxEehFU/+bAeG+Mg/yFuR/yTkGD+VWRdjxEen5Bg/vCdWIRX97NcxR5Ns8O/lfTL3ElYtQCnJ6fa1y1fJ//cSKI3C/MMUmxybI8Melxqn+JR4VQmokmfm3dT3G8E+wTnGzYHCsf/fzjzn1MdrBZ8oN858DoBC9tn38/NTr169NHjwYAL9MigxOU2hQa4LZQP9vRUZnZTv9kv+3K8/N0XIw1PaezhWG3ZG6t4Xf9fE91bn+vw/Nh7Wsr8Oa2ifJsUyf6AkmKDbBPan8vX3Uvzx5Dy3DQ7zs4G8KcnJPAvwx7y92rfluM3en9h/mvxP+b30DfDK9SABKEt8PH0UnxrvMp6YlqgQ35A8tzV1/QdiD+iqev/KOgvQvdYlali+gVYfPvE3Z8uxLWpeoZkuqHKBvV81sIquqv8v7Yn+W0cTj7rlPaH0I7PviivonkN8fTztNRJOZRauJyXn37ngs0U75O3loY/GX6pWDU6UJTz3wRq9O2ezrr+soepWD8mxWPfJN1fo4jbV7Q0oq7zt700up289ThwI5KfvqGb6aPwavXjbr/Lx81JSfKr8ArzUpkf1bPs/ddcnXi8liY4iKLtS01OzMvSn8vXMv0PbjE3v6d429+j5iyYpOS1ZgT6BSkhN0G///G4fN+sAWlVqpZHnDVdsSpwCvQNszb7pxgPgJIL9c0jFUH8djnTNspjFtgH++f8omLaaHVpUyQr0jcG9Gthgf9OuYzmCfZPtPx6bpGfGdi/GdwCcfUHlfHOtzU+ISbHZ/fyEtwjT/dMv1vaVR+xi3B8+3qlO/cIVEOyTbf85z6zFx5zI6Bdk/0BpFZ0cY0t5ThXkE6SktPzPJm+L2q4HfnlIrSu1UrWgarq6QX8t3PN91tkCs49Jfz6nJmGNVcm/sgY07K+U9JSsgwGcm3LJaZ7z+EjOIU3rlldCUpotv8m0Y99xO1YlLP+6YFPuU7tKzvpIf98TwYhPtnrjr3/apc8X79DEER1zrA8AyqJq9UKUkpSuA9ujs8Yi9sbasZAKJ+ru82N655tOO7HHkhUY6qPOV4fn2P/RA/GKjTpZEvTP/79WQfcPlEZ7Y/bKz8tP4SEnu71VD6puxwraKceU/JjOPabNZkxyjL7bs8DlOVuObdWBuAN2Qa/J6p/ubAJwriq2YD89PV2bN28urt3BDWpVCVbzemF6++tNWWPvz9uqckG+alHfNftyqpYNKmjznpz/QS//67C9eFarhiey/cs3HLLlO3f0a6bu7U5elwEoq8xi2eoNQvTrrN1ZY8u++VsBwd6q3jDvuuNTO/OsXnxAXQfXt8F/JtOK0yz4Na04M9t1Lp/7t6qEB9uaf6CsOpJ4RLujd6t33d5ZY73qXGpLbnbH7Cnwfkygf1GNLpqzc64N/nPzr3p97GstO7i8WOaOssvLw8NtN53rZTxxcXG6+uqrtWnTyUASpc/DQ9ro9md/1E3jltis/M+r/9GjN7WVt5en7dYTGZ2oZnVzD/zNlXaveWShxr61Qld2rmPLel78ZJ1t5Wky+FGxSbr/pd9Vu2qwLu1QS+t3nDyD0CS8nHy9KUlA2XT5rY31/lOrNP2xP+Xj66ltK4/q8tsay8vL05b4xB1PUfX6eQf+P87caS/I1aF3rRzjpgvPZbc00lcvbbDtPE0P/783Rum6x3JexwIoiz7d+pkeOP9+PdzuIaWkJ6t1pdb6ZMtMm303C29DfEK0N3Zvvv32jyUd05J9P+T6eP3Qejq/Sltb0gN4leEWmaU+sx8cHKxFixYV1+7gJp1aVtUH43rK19vTXuH2mWHtNfRfJ7rlfLZou256+sSFT3LTsFY5vTe2u+3EM+r5X/XSzHW6rEMtjb39RCeEFRsjdPR4knbuj9agx77XtWMWZt0OF7CPP1Aa1WtdQbf+9wK7mNbU0/e9u7k69z9RirNywX7NeOzPPLc3ZTqrFu5Xr5sb5Wixmem8HjV0w5NtlJxwYkHu9Y+fl6PvPlBWbT62Rf/98zmlpqcoyCdY726YroV/f591hdxHL3g4z+1Ni86uNS/W59u+UFpG7gvWBzYaqDURa+xrAXDlkWHOGRdQQkKCDejXrl2rQ4cOKT4+Xj4+PqpRo4Z69uypLl266ExkrB17RtsD56pPA2gzBxTFgj0kIoDCmt7rnVL7oTV6d6Db9r3t1llydBnPli1bNHz4cDVo0EBt2rRR3bp15e/vr9jYWK1fv17Dhg1T//79NWHCBPfOGAAAAEDxBvuPP/64Ro8ebQP63GzYsMFebMvczNV1AQAAgLPJiz6TLgr8kezcudNm9E+nefPmCgkJUWTkyUWZAAAAAMpAsN+pUyeNGTPGBv2nMqU848ePl6+vrzp06FDccwQAAADyRevNMyjjMbX4I0eOVJ8+fVS9enWFh4fLz89PERER2r59u+rXr6+pU6faOn4AAAAAZSjYr1ixombOnKmVK1faXvoxMTHy8vJSWFiY2rZtq4YNG7p3pgAAAEAeyvLFr0rNRbXatWtnbwAAAEBpwkW1XLFmGQAAAHCoQmf2AQAAgNLIiyoeF2T2AQAAAIcisw8AAABHoGbfFZl9AAAAwKHI7AMAAMARaL3pisw+AAAA4FBk9gEAAOAI1Oy7ItgHAACAI9B60xVlPAAAAIBDkdkHAACAI1DG44rMPgAAAOBQZPYBAADgCLTedEVmHwAAAHAoMvsAAABwBDL7rsjsAwAAAA5FZh8AAACO4EUa2wXBPgAAAByBMh5XHP8AAAAADkVmHwAAAI7ARbVckdkHAAAAHIrMPgAAAByBmn1XZPYBAAAAN0tPT9fdd9+tV199tcDbpKWladKkSerYsaO6d++uefPmFfp1yewDAADAEUpr682kpCQ9+eSTWrhwoRo3blzg7V566SXNnj3bHiD4+PjYg4Xw8HC1aNGiwPsopR8JAAAA4AxPP/20Ddbbtm1b4G2Sk5P14YcfatSoUerQoYPd9qabbtLHH39cqNcmsw8AAABHcGfNfs+ePfN8fPHixad9bNiwYTYjP2TIkAK/3q5duxQfH6+LL744a8wE/N98840Kg2AfAAAAjlBaW2+Gh4cXepuYmBh5eXmpdu3aWWOhoaE6dOhQofZDsA8AAADkI6/MvTt4e3vL19c3x1hAQIDN9hdqP8U8LwAAAKBEOKn1ZlhYmBISEhQbG6vg4OCsbP+pBwD5YYEuAAAAUMqY8p1KlSpp5cqVWWPr169X9erVC7Ufgn0AAAA4pvWmu27u6r0fHR1t++mfytPTU71799Yrr7xis/vHjh3TjBkz1KNHj0K9BsE+AAAAUAIOHDig9u3ba+vWrbk+Pnr0aNuys2vXrjbI9/f3t519CsMjIyMjQ6WEx/BOJT0FoEzq0LVuSU8BKJOWhp/scgGgYDw7P19qP6q7ltzutn2/2WOaSoLJ/ptSHtN33/TbN8F/YbBAFwAAACilTDmPyf4XFcE+AAAAHMHLOc14ig3BPgAAABzB00GtN4sLC3QBAAAAhyKzDwAAAEegjMcVmX0AAADAocjsAwAAwBE8Kdl3QWYfAAAAcCgy+wAAAHAEavZdkdkHAAAAHIrMPgAAABzBk6J9FwT7AAAAcATKeFxRxgMAAAA4FJl9AAAAOAJVPK7I7AMAAAAORWYfAAAAjkDNvisy+wAAAIBDkdkHAACAI3h6eJT0FEodMvsAAACAQ5HZBwAAgCNQs++KzD4AAADgUGT2AQAA4Aj02XdFsA8AAABH8GKBrgvKeAAAAACHIrMPAAAAR6CMxxWZfQAAAMChyOwDAADAEWi96YrMPgAAAOBQZPYBAADgCJ6ksV3wkQAAAAAORWYfAAAAjkCffVcE+wAAAHAEWm+6oowHAAAAcCgy+wAAAHAEWm+eQbC/ePFiXXLJJfLy8rL3t23bprlz52rfvn2qXr26Bg0apDp16hR0dwAAAABKSxnPqFGjlJCQYL+eN2+e+vXrp5UrVyojI0Pz58+3980BAAAAAFBSNfvuujk+s2+C+kxvvPGGHnzwQd166632flpamr0/adIkTZs2zT0zBQAAAOCezL6Hx8lDmj179qhv375Z901pzy233GIz/QAAAEBJtd50183xwb7J7H///fc6dOiQrc03AX920dHR8vf3d8ccAQAAALgz2B86dKg+/fRT9erVS3///beeffbZrMfmzJmjJ598UjfccENR5oCzrFezDto+flaRtvXy9NIP903RzZ36nPY5VUMrKPJ/C/XApfw8wFk6VmutL/71cqG3a1S+jt669GktGThdr3Z/XFUCK572ueaxJQPf1flVmp/hbIGSl56eoZe/3KyL71mgbvct1Aff7yzSfn5Zf1jNb/1G63YeyzGelJKmp99fq06j5qvXw4s0/4/9xTRzlFXU7J9Bzf6jjz5q/01OTtb69etzLMZdtmyZ7rzzTl1//fUF3R1KSLNqdfXxreMVm3RisXVhvTLofl3S+HzNWPrtaZ/z0rX36VB0pF5e8ukZzBQoXeqF1tT4zqMUn5JUqO3C/EL1avcntD3qb4359UVdFt5Zk7s9rJu/G6O0jHSX5z/W4Q4F+QQW48yBkvPa7C16d/52PTS4uaqU99fT761TxVA/9e5Ys8D7SExO0/gP1unqi+qodf2wHI89NWOtflxzSGNuaGkrEB5/Z42qVwxQmwYV3PBuUBbQerMY+uz7+vqqXbt29makp6dr/PjxWS05UXq1D2+u7+5+Udsj9qlKSOH/I/zwlnHqWLe5jsYeP+1zLmvWUddd0EuXvTJaqelpZzhjoHRoXqGBXrpkjPbFHlSYX7lCbXtdk97KUIYe/Pl5JaYlacWh9fbsQLda7bVk7/Icz/1XvW5qVbFxMc8eKBmxCSk20L/76ia68dL6diwmPlVTvtlaqGB/yuwtOh6brPsHNssxvuufWM1Zuk//G9ZOV3Y4sb+9EfF645utevO+TsX8boBzoIwnKSlJkydP1siRIzVr1okSkGeeeUatW7e2t9GjR+vYsZyn11C6dG3URg988Yqm/PRlkbavFlpBF/3vLsUkxef6uL+Pn6Zc/5C+WvOjvt/0xxnOFig92lZppldWf6Avtn1f6G0vqNpSP+/70wb6RnpGhn7Zv1IdqrXK8bxKAWG65/whemn1B8U2b6AkrdoWqaSUdF11Ya2ssZ7nV9OOAzE6fCyxQPvYui9aMxbs0Kj+Te0ZgeyWbYqQv4+XLj2/+sn9t62mPzYfVVr6yQ6COLd4eni47eb4YH/ixIlauHChXZz72muv6YEHHtCWLVv08ccf6+WXX9aaNWs0duxY984WZ2Ty4k/yLL/JT69XRtvynNN57Iqb1aByLRvMfDD0ad3f8wb5evsU+fWA0uLjzd9q7q6firRtlcAwW8KT3YG4w6odUi3H2CMX3Ka/jmzTnJ0/nNFcgdLi0LFElQvyUdWwgKyx8sG+Cgnw1p7DcQXahynfMbbtj9ajb6/SdysO5Nh/verB8vE+GcrUrhJky34OHStaqSrgLkeOHNGIESPUtm1bDRgwQJs3by7QdqYhjrnWVadOnezFbV955RVbUu+WMh4T6E+dOtVm8c0FtK6++mo7Vrt2bfv4gQMHbNCP0iv7tRKKe3tTFpS5ILdW+SpKSUvVDe0v08Dzu+uSF0coOTXljF4bKEmmDKeo/Lx8FZuS82xYfEqiyvuFZt2/PLyL2lRpqhvmPXRG8wRKE7N4NjTQNeET6O+tYzH5r31ZsvqgVm6NlK+3p/ZFxCvieJJm/75Pay6rr0evb5nr/gP9TpQUH4tJVo2KrH05F5XGmv2MjAwbsBumOmbdunU28DcNboKCgk67XWJiom2Q07FjR82ePVv79++3yfaIiAhNmDCh+DP75uq5NWueqIkLDw+3/1aocLLuu1KlSjl68ePccmOHKxTo6697P39RnZ67TRf/7y71feMhXVi/lW7q2LukpweUmOS0FJeFuBn/fxCQuYD3/nY3a/LK9xSRQCkknMME6Z65XHbUjJjse34+/2mPvL089NFjF2n6w50199nuuvWKBnpv4U7tPhgrX28vl/1nxiEF2T9wtqxatUqrV6+25e8NGjSwCfN69epp0aJFeW73yy+/KCoqSk8//bSqVq2q888/X7fffrvmzZvnnsx+kyZN7FGFaa9prpJrfqGmT59uj1RMPb954YYNGxbqxeEcjavWVkxinN74+eR6gG//+k37jh1W29osOMS561hStKoE5lwQX84vWImpJzKbD19wm9ZFbNX83b+U0AwB96gQ6pdrbf7xuBQF+OUffuw+FKsOTSupZb3yWWODLgnXu9/t0Ka/j6tCqK9LuU5U7InyhoLsH87kztr6nj175vn44sWLcx3fuHGjatSokSNONuU8a9eutdUyp3P06FFVrFgxx3WsvL29C90Up8CZfdNX//PPP1ebNm305ZdfasaMGfZfc2rBdOb56aefdM899xTqxeEccUmJ2h8V4VKuk5CSZDObwLlqW9QenVepSY6xpmH1s7L4Pep0VNdaF2j59TOzbsYbPZ/SlB5PlcicgeLQtHaoEpLTtGF3VNaYWZxrxkwbzvwE+HqrduWcpTj+vieCHFOn37R2Oe05FKej0SdLgjJfq0r5nIt5gZIUExNj17xmV65cOXuh2ry0bNlS+/btsy3vDVOr/8UXX9ja/cIo8KGvOe0wf/58RUZGqnz58vL09LTZ/KVLlyotLU3Nmze3Ry04N63Ys1HDul6t8oEhioqPsWPhFaqrbsXqWr5rQ0lPDygxS/5erv9edL8alQ+3gX/1oMrqWqudpq47cR2KG+c/4rLNh1dO0rPL39SqwxtLYMZA8ahVOUjNw8tp2rztenHEBXbMXFTLLNptUTf/Frat6pXX5r3ROcaWbzpiL5pkHqsQ4qfyQb5697vtemhQC1sX/eGiXWpUM0SVyuV/MAFncmdmf/FpMvf5Mdl4P7+cB6AmWx8fn3t3w+zBvkmkm9Kd9u3ba+vWrdq7d2+h6vXt6xd2wtnr9M1Eu3fvXthdoBSqXq6SqoSEae2+kxdLK4wv1/yocf+6Q1/fNUkTF7yvAB8/e3/30X/sY4BTmZaZpu7eBPK5+fXAKhu0v97jSdtys2O1VjqWGK3Z25fYx0+33b7YQ/YGlGUPD26h2/+3VDdP+k1+Pl72SriPXNdC3l6etsTnaEySmtXJPfAf0qu+Bo77SU+/t9b20Td1+i9+sUn/urBWVoefBwc315hpq7XzQKxi4lO0clukXhnV/iy/S5QmpbFFZlhYmO3Gk11sbKy9dlV+hg8friFDhtgg3wT9AwcOtKX1binjgbPdeVF//XjflCJvb8p3uk0erj2RB/XezU/pg6FjdTD6qK587T468cDR+jfoaUtu8vLAz8/pi20L1bB8Ha06vEl3LBqruFRaA8L5OjarpPcf7WIX6x6PS9aEW87T0Msb2Mc++2m3bv7vb6fdtmHNEM14pLO9UNaoV//QS19uVq921TX2ptZZz+nXubam3NNRcYmp9v5rd7e3zwFKkzZt2mjbtm2Kjj55psqU5lSvXrCf1eDgYP31119KTU3VfffdV+jX98g4036MxchjOFe8A4qiQ9e6fHBAESwNP9E+GkDBeXZ+vtR+XF/uuNdt+x7Q4KUib2sW4ppFuU899ZQ2bdqkwYMHa8qUKbroootslt+04Dzdwtu4uDhdccUV9sK21113XaFfm8w+AAAA4Ebm4rSm5r9z584aNGiQ+vbtq65du9rrVGXW45+OOSgwZwHMdkVRbL2p0tPT7USbNm1aXLsEAAAAynTNvmEa2SxYsEArVqywNfzmIrVGrVq1tGXLFuXloYfO7IKLxRbsm1MM5iIB5tQEAAAAgJMCAwPVrVs3nW3FFuybxQP5XQkMAAAAONcy+yWpUMF+QkKCDejNFb/MhQBMf1AfHx/bX99cVaxLly7umykAAAAA9wT7pp7I9Po0F9cyLYTq1q1r++ybFcSmfdCwYcPUv3//Qjf6BwAAAIoDmf0zCPYff/xxjR492gb0udmwYYNtI2Ru5opfAAAAwNnkSaPJorfe3Llzp83o57XKOCQkRJGRkQXdJQAAAIDSEOx36tRJY8aMsUH/qUwpz/jx4+1lfzt06FDccwQAAAAKVMbjrpvjy3hMLb65clefPn1sY//w8HD5+fkpIiJC27dvV/369TV16lRbxw8AAACgDAX7FStW1MyZM7Vy5UrbSz8mJsZe1tdcGMBc/rdhw4bunSkAAACQh7KcgS81ffbbtWtnbwAAAABKt2K7qBYAAABQkjw9Crwc9ZzBJwIAAAA4FJl9AAAAOAI1+64I9gEAAOAIBPuuKOMBAAAAHIrMPgAAAByBzL4rMvsAAACAQ5HZBwAAgCPQetMVmX0AAADAocjsAwAAwBE85VHSUyh1yOwDAAAADkVmHwAAAI5ANx5XBPsAAABwBBbouqKMBwAAAHAoMvsAAABwBMp4XJHZBwAAAByKzD4AAAAcgcy+KzL7AAAAgEOR2QcAAIAj0I3HFZl9AAAAwKHI7AMAAMARqNl3RbAPAAAAR/CUR0lPodShjAcAAABwKDL7AAAAcATKeFyR2QcAAAAcisw+AAAAHIHWm67I7AMAAAAORWYfAAAAjkDNfikP9g/+b1hJTwEokxKveqmkpwCUSce+7VfSUwDKnIolPQGU3WAfAAAAKCoPDyrUT0WwDwAAAEfwZDmqCw5/AAAAAIcisw8AAABHoIzHFZl9AAAAwI2OHDmiESNGqG3bthowYIA2b95coO127NihwYMHq02bNurUqZPGjh2rxMTEQr02wT4AAAAcc1Etd92KKiMjQ6NGjVJkZKRmzZqlIUOG2MA/Li4u321HjhypSy+9VN9//73efPNNLVu2TK+99lqhXp8yHgAAAMBNVq1apdWrV+vbb79VgwYN7G3u3LlatGiR+vU7fftfc3Cwa9cu/fvf/1ZgYKAqV66s7t2722x/YRDsAwAAwBE83Fi00rNnzzwfX7x4ca7jGzduVI0aNdSwYcOsMVPOs3bt2jyD/XLlyqlatWqaNm2abr/9dv3999+aP3++zfYXBmU8AAAAgJvExMSoTp06LoH8oUOH8tzOy8tLzz33nN544w17cGAODNq1a6drr722UK9PZh8AAACOcCa19fk5XeY+P97e3vLz88sx5u/vr/j4+Dy3S0hI0JgxYzR8+HDdeuutOnr0qJ544gk988wzevLJJwv8+mT2AQAAADcJCwuz3Xiyi42Nla+vb57bLV261D5v9OjRCg4OVnh4uB588EF9+umnSk1NLfDrE+wDAADAMTX77roVlWmbuW3bNkVHR2eNrV+/XtWrV89zu7S0NBvsmwx/poiICDtuOvwUFME+AAAAHKE0tt5s1KiR6tevr8mTJys9PV0bNmzQwoUL1aNHD3vfHASYAP5UzZs3l6enp83mz5s3T++//77GjRtnFwr7+PgU/DMp8swBAAAA5GvixIm25r9z584aNGiQ+vbtq65du+rAgQNq3769tm7d6rJNzZo1bW99k803tfovvviizjvvPI0fP16FwQJdAAAAOIKHGxfongmTpV+wYIFWrFhha/hbt25tx2vVqqUtW7acdrsuXbrY25kg2AcAAADczFwYq1u3bjrbCPYBAADgCJ5UqLsonec6AAAAAJwxMvsAAABwhNJas1+S+EQAAAAAhyKzDwAAAEc4k374TkWwDwAAAEfwkFdJT6HU4fAHAAAAcCgy+wAAAHAEynhckdkHAAAAHIrMPgAAABzBgzy2CzL7AAAAgEOR2QcAAIAjULPvisw+AAAA4FBk9gEAAOAIHlxUywXBPgAAABzBk6IVF5TxAAAAAA5FZh8AAACOQBmPKzL7AAAAgEOR2QcAAIAj0HrTFZl9AAAAwKHOOLOfnp6ujIwMeXl5Fc+MAAAAgCLwII9d9Mx+cnKyJk+erJEjR2rWrFl27JlnnlHr1q3tbfTo0Tp27FhBdwcAAACgtAT7//nPf7Rw4ULVqVNHr732mh544AFt2bJFH3/8sV5++WWtWbNGY8eOde9sAQAAgDxq9t11c3wZjwn0p06darP4/fr109VXX23HateubR8/cOCADfpReqWnZ+jdN37W3K/WytPTQzcM7aSBN7Qv0Lajb/9Ia1b+netjL799g9peEK5/DkTpuXHztWnDAfn6eqtz14a6+8FLFRTsV8zvBDjLPDxU7ubhCukzQBnp6YqeOV0xX31SpF0FdOmuKuNf1J6ebVweC+59tYJ69tGhB24vhkkDJc+U+k6b8qO++XKlPD09deMtXTTo350KtO3I26Zr9Z97cn3stWk32785zz41O9fHe/c9T09MuPqM5o6yiTKeMwj2ExISVLNmTft1eHi4/bdChQpZj1eqVEkeHh4F3R1KwPSpv2jm+8s1/N4eqlQlRC88M19hFYPU8/Lm+W774BNXKD4uOcfYqhV7NP3NX1SnbkW7bmPco7NVqXKIJr40UEciYjX15R/036e/1YQXBrjxXQHuV+7mYSo3+GYde/NFpR45rIr3PaG0Y0cV/+PCQu3HMzhEFe55LNfH/Fq3U4W7H1XSxvXFNGug5L3zxo/6+L3fNPK+y1S5Soiee2auKlQM1qVXtMx324efvErxcUk5xlb+sUvvTP1R4fUqqUGjqnrn4ztyPJ6akqYHRn2kxk2rF/t7ARwf7Ddp0kSzZ8/WDTfcoGnTptnAfvr06Ro1apSSkpI0b948NWzY0L2zRZHFxSbpk/eX69bhXXXN9RfYsdiYRL331m8FCvZNQH+qlyct1IDB7VSxUrD27z2mjesPaPbi0QqrEGQfT0pI0eSJC5SWli4vr7J7+gvnNo/AIIUOullRM95QzNcz7dix4BCVG3JXoYP9sJEPy9PP32U84MKuqvT4f5W8Z2exzRsoaXGxifrovd91+4juuvaGjll/d6a/+VOBgv3wupVcxib/d74GXtdBFSuF2PvlygfmePyrz1YoKMhP/a898XcO556yXG7jLgX+RJ599ll9/vnnatOmjb788kvNmDHD/tuxY0e1a9dOP/30k+655x63TRRnZv2afUpOSlWv3i2yxi7u3li7dx7RkcMxhd7fsl93aNfOI7YUyDgeFW//zcg4+ZyU1DT5+HoT6KNM82vZxgbocYvnZY0l/PaDfOs2kFfFygXej3+HixR0yWU69s6rrq/Rqp0ixj+shN9/KrZ5AyVt3Zq99u/O5b1bZ4117dFUu3ZGKOJwdKH3t/TXbdq147BuvOWiXB9PSUnV++/8opvv6GpLSQGcUODfhgYNGmj+/PmKjIxU+fLlbe2dyeYvXbpUaWlpat68uWrUqFHQ3eEsMwF9aDl/exo1U2i5AAUH+2nf3mO2rKcwzFmCK/u2zsqq1G9YReXDAvXGS0s0+qFLdTQiTp99uEKXZTu4AMoi70pVlBYdpbQjh7PG0mOilR4bI+8atZV2NKJAZwdM6U/Ue28oJZfsfdTbL9kjZb+m+Wc7gbLCBPTm70zlqqFZY6HlAhUcYv7uRKpylZPjBfHRjN/Up19bl2x+pkXf/aWkpFT17uu6HgbnDg8y+y4KfeibvU7f399f3bt3L+wuUALMf4DBIbmUDwT6KurYiax8Qe3aEaE1f+7Rg49fnjXmH+Cj8c9drXvv+lgL5v5lx1q3ra27H7q0GGYPlBwPXz8b2J8qPSFeXuXDCrSPsGEPKO3IIUV/9r78Wp3v+oTsp8QAh0hKPM3fnYDC/93Zuf2wVv+5Ww8/8a/TPmfWJ3+o7zXtyOoDp6Cw6Rzh4+tlO/C48JA9zVoYX322Su061FXt8JN1/KYOc9L4b9XpogYaO7Gfht/XQ7t3RujZJ+cWx/SBEpORkmJaiuTyQIY8/PLvNOV/fkcF9bxSRyY9lft+AAf/3fHK5e+OWfOXlJhSqH19+dkKXdCxvurkUsdvbPxrv7Zs+kdXU6t/zvPIkNtuZRVFbecIs2j2yOFYl/GY44k2K19Qqanp+mHhJt01OucZnW+/Xid/f1/958WBWQcVjZtU1X3DPtHgG9ureasTnZyAsiYtKlJeFau4jHuGlFN6QkKe23r4B6ji/U8pavrrSt2XewtBwMl/dyJyWRMWfTzBZvcLKjU1TUsWbtDw0ac/U7xw3jq1Oq+2qlYrV+T5Ak5FZv8c0aBxFSUmpmjLpoNZY2ZxrhmrVDm4wPtZ9cduxcYm6aJLGuUY37snUnXrV8xx9qBhkxMB0oF9UcXyHoCSkLJjizwDAuTbqGnWmHedenYsv3p93yYt5F29pioMf1Dhi9fYW7XJ0+xj5utyNw1z+/yBktKocbX//7tzIGvMnPE98Xen4OvE/ly+SzExibq4e5PT9vJfsnCjLrm0WbHMG2VcRrr7bud6sG9+2TZv3lxcu0Mxq1GzvBo3q6aPpy/NGpv18Z8KCfVX42YF70f805ItatGqhl2Mm125sABt23LIttnM3rHHKOziX6A0ST14QElbNyr0uluzxkIH3KC06ONK3ropz22Tt2zQgTsH57gd/d84+5j5OmbO526fP1BSatQKU5Nm1fXBu79mjX320TL7d6dJ80L83Vm8SS1b1VL5sBNtnU+1Yf1+HYmIUZduuR8M4BxDsO++Mp64uDh7Vd1Nm/L+44eSM+K+HnpgxEzdc8dH8vXz1vLfdmrUAz3l7e1pu/UcOxavRk2q5rmPlct3q3sv1+xJl64N9dG7SzXq1g/Vpl0d24Xhx0Vb7P5atanlxncFuN+xNyer6qQ3VPV/bysjKUkBHS9S5JQXpPQ0237Ts3wFewbgVBmJCS7j5sJaRm7PB5xm1P2X6d7hH2jUbTPk5++tpb9u1+gHL5e3t5f9O3EsMi7fC2CtWL5TPS87fWe3P5fttNd7qVX7ZAMRAG7I7AcHB2vRokXFtTu4wfntw/XqtH/bRVOmZvLhp3pr0I0d7GPffLlG99z+UZ7bHzxw3JbktDzPtf7e1OQ/99ogpaSk6fOP/tAvS7aqbbs6Gvdcf/rso8xLWvOnDt53mzKSk+UZWk5HX3haMV98aB8L7nNNVmkOgJzadainKe/eYv/uHI9K0JixfXXdkAvtY7O/WKlRt8/I8yP750CUDuw7ZuvxT8dcVTevx3GOIbPvwiMjo+A93xISEmxAv3btWh06dEjx8fHy8fGx/fV79uypLl266Ewcis/7lx5A7hKveomPBiiC4G8f4XMDCqmi//Wl9zNLXeC+fXufbDnuyDKeLVu2aPjw4fbiWuYqunXr1rV99mNjY7V+/XoNGzZM/fv314QJE9w7YwAAACA3ZXghbYkH+48//rhGjx5tA/rcbNiwQYMHD7a3li25CiQAAABQZoL9nTt32oz+6TRv3lwhISGKjIwsrrkBAAAABcfFC4u+QLdTp04aM2aMDfpPZUp5xo8fL19fX3XocGLBJwAAAIAyktk3tfgjR45Unz59VL16dYWHh8vPz08RERHavn276tevr6lTp9o6fgAAAOCso2a/6MF+xYoVNXPmTK1cudL20o+JiZGXl5fCwsLUtm1bNWzYsKC7AgAAAIofwf6ZX1SrXbt29gYAAAAgf0eOHNFTTz2lpUuXql69evrPf/6jpk2b5rnNvn37bGv73Lz//vvq2LHj2b2CLgAAAFCiSmFmPyMjQ6NGjbJfz5o1S+vWrdOIESM0Z84cBQUFnXY7cx2rFStW5Bj7448/7EFDixanv6r0qQj2AQAAgHycLsueafHixbmOr1q1SqtXr9a3335rr1dlbnPnzrUXqu3Xr99p9+fp6anQ0NAcBw1TpkzRvffeq+Dg4Pyme3I/BX4mAAAAUNpbb7rrVkQbN260Wfrs61vNete1a9cWaj/z589XfHy8Bg4cWKjtyOwDAAAA+Thd5j4/pqlNnTp1coyVK1fONrwpjLffflu33XabzfgXBsE+AAAAnKEU1ux7e3vbdvXZmVb1JktfUGZh78GDB/Ms+zkdyngAAAAANzFt6k03nlMvSGsuRltQZmGvudZVYbbJRLAPAAAA52T23XUrojZt2mjbtm2Kjo7OGlu/fr29SG1BmAMDs5j3qquuKtLrE+wDAADAGUphsN+oUSPVr19fkydPVnp6ujZs2KCFCxeqR48e9r45CEhLSzvt9r/++qstA2rVqlWRXp9gHwAAAHCjiRMn2gW+nTt31qBBg9S3b1917dpVBw4cUPv27bV169bTbvvLL7/oggsuKPTC3EweGaZpZylxKH5GSU8BKJMSr3qppKcAlEnB3z5S0lMAypyK/tertMqI+tBt+/Yof+MZbW8W5JqLZJka/tatW+tsoRsPAAAA4GaBgYHq1q2bzjaCfQAAADjDGVz8yqmo2QcAAAAcisw+AAAAnKEUXlSrpJHZBwAAAByKzD4AAACcgcy+C4J9AAAAOAPBvgvKeAAAAACHIrMPAAAAZyCz74LMPgAAAOBQZPYBAADgDFxUywWZfQAAAMChyOwDAADAGajZd0FmHwAAAHAoMvsAAABwBjL7LsjsAwAAAA5FZh8AAADOQGbfBcE+AAAAnIHWmy4o4wEAAAAcisw+AAAAnIEyHhdk9gEAAACHIrMPAAAAZyCzX7qD/cVBE0t6CkCZ9OnsjiU9BaBMWvbWJyU9BaDMOTT6+pKeAspqsA8AAAAUGd14XFCzDwAAADgUmX0AAAA4Q3pGSc+g1CHYBwAAgDNQxuOCMh4AAADAocjsAwAAwBnI7Lsgsw8AAAA4FJl9AAAAOAMLdF2Q2QcAAAAcisw+AAAAnIGafRdk9gEAAACHIrMPAAAAZyCz74JgHwAAAM7AAl0XlPEAAAAADkVmHwAAAM5AGY8LMvsAAACAQ5HZBwAAgDNQs++CzD4AAADgUGT2AQAA4AzU7Lsgsw8AAAA4FME+AAAAnJPZd9ftDBw5ckQjRoxQ27ZtNWDAAG3evLlQ2ycmJuryyy/XO++8U+jXpowHAAAAjpCRkeG2fXucwZxGjRplv541a5bWrVtnA/85c+YoKCioQPt44YUXFBISoqFDhxb69Qn2AQAAgHz07Nkzz8cXL16c6/iqVau0evVqffvtt2rQoIG9zZ07V4sWLVK/fv3ye1ktXbpUn376qT1Q8PLyUmFRxgMAAABnKIVlPBs3blSNGjXUsGHDrDFTzrN27dp8t42NjdVjjz2mjh07asOGDfbAobDI7AMAAAD5OF3mPj8xMTGqU6dOjrFy5cpp06ZN+W77+uuv6+DBg+rcubP27dunqVOnqlmzZnrxxRfl6VmwnD3BPgAAAJyhFLbe9Pb2lp+fX44xf39/xcfH57ldcnKyPvnkE1un/8gjj9ix66+/Xt27d7cHHr169SrQ61PGAwAAALhJWFiY7cZzanmOr69vntsdO3ZMCQkJ6tGjR9ZY5cqVVbNmTe3cubPAr0+wDwAAAGdIz3DfrYjatGmjbdu2KTo6Omts/fr1ql69ep7bVahQweUMQFJSkg4fPqyqVasW+PUJ9gEAAAA3adSokerXr6/JkycrPT3dLrRduHChzdib++YgIC0tzWU7Hx8f9e3b125nttm7d6+eeuopWxKUX2eg7Aj2AQAA4AylsBuPMXHiRFtnbxbaDho0yAbxXbt21YEDB9S+fXtt3bpVuXniiSfsNqYvf58+fbRjxw699dZbtud+QXlkuPPqA4X0sUeTkp4CUCZ9OrtjSU8BKJOW7Y4q6SkAZc6h0d+otEpfMtpt+/bs8coZbW/KcVasWGFr+Fu3bq2zhW48AAAAgJsFBgaqW7duOtsI9gEAAOAMZ7CQ1qkKHOybOqNLLrkk6zK9ZlWxudSvafBvVhOb+qNTLxgAAAAAoOQUeIHuqFGjbK9PY968eerXr59WrlwpU/I/f/58e98cAAAAAAAlopQu0C0Tmf3s63jfeOMNPfjgg7r11lvtfdMuyNyfNGmSpk2b5p6ZAgAAAHBPZt/DwyPr6z179tiWQZlMac8tt9xiM/0AAABAiSCzX/Rg32T2v//+ex06dMjW5puAPztzQQBzlS8AAAAAZSzYHzp0qD799FP16tVLf//9t5599tmsx+bMmaMnn3xSN9xwg7vmCQAAAOTfjcddN6fX7D/66KP23+TkZK1fvz7HYtxly5bpzjvv1PXXX++eWaL4eHio9bjRanDHtcpIS9fGSW9r66sfFHhz7+AgNRk9ROXPa6qkw0e17c1Pdfyvk1d9861QXu1ff0rVr+yq+H0H9efI8Tr80x98B+EIbSq31LDWN2vY4ocKtV3d0Nq6q9XNqleutrYe26lXVr+tI4mRLs/7d9NrVNG/gl5Z83Yxzhooed3qtNFz3Yer43t3FWq75pXq6r+XDFOLSnW16uBW3bPoFR2IPZL1eMvK9TXpkmH2edFJcfpy68969vf3lZqe5oZ3gTKhDC+kLfHMvrniV1xcnHx9fdWuXTtdd911WY+ZLD+BftnQ6um71eyh27Th2an68+4JavnkCNUZdGWBtvX09dGlP3+o2tdcppitu23Af/kfn6tc84ZZz7n4y1dVqXNbLRv6qHa++4W6zZmqoLq13PiOgLOjdnANPXD+cHl6FPi/Taucb4jGX/iIUtJTNGnFazqScFRPdrrfZT8X1+ykgY2uKuZZAyWvcYXaeuPyBwv9u1MpoJw+v3qCktNSdNu8Sdofe0Qf9X1KXv+/nwBvX03vPUZ/RezS9bPH6bnlH+vfLXrp8c43uemdAA7P7A8ZMkSVKlXSvffeq4EDB7p3VnAL75AgG+ive+oVbX3tQzvmWz5ULZ8aqb8/m5/v9o1H3SjvwADNb9NPaYlJ8vD0VJ+N81T/lgFa/dBzqtari6p266AFHQbq6Ir1dpuw85qq2YO36s9R4/muosxqVL6+xnZ6UP/EHVI5v9BCbXtV/ctlTv4++8eLSkpL1tqIvzS15wvqVK2dfv9nhX3O5eHddUuL67Q35oCb3gFQMtpWbaRP+j2t3VH/qGJguUJte2ebvmbBoG6a84ziU5P08961Wn7Tm+rd4ELN2f6bLqjWVGEBIXrspzeVlpGuZQc2qHZIFV3dpKvG/Trdbe8JpRyZfReFOsweN26cPvnkE/Xu3VtffPGFUlJSCrM5SljlLu3kHeCv3R99kzW27+tFKt+ikQKqV8l3+8hVG7Xs1sdsoG9kpKcr4WCEPP187f1qPS9UzLbdWYG+sffrRap2aWe3vB/gbGlRsYmmb/hE83cvLvS251VuoT8OrrKBvpGuDK04tNqOZ2oc1kBP/T5J26N2Feu8gZLWqUYLPf3Lu5q+fl6ht724dmt9t3O5DfSN9Ix0Ldz1h7rWPs/erxAQqpN9Ak/w8fJRYuqJ3zUARQj2O3bsaIN8c4Gtjz76yF5R15TwmBp+lH6BNaso6egxJRw4nDWWfOy4kqOiFdww/6sfH/5xuY78virrfuWL2qly57ba99Uiez+gZlUdW7clxzaxO/cqqF5NexYAKKtm7/hOi/f+UqRtK/iHaXf03hxjB+MjVCOoWtb919a8o61RO894nkBpM3X1bM3cVPiDZKNacEVtPLI7x9ie6EOqX76G/XrFP5vl5emlRzr9W0E+AWpXrYmua95Tn2/+oVjmjjKKBbpFL+PJzmT2zW3p0qWaNWuWLfHx8/NThw4d9OqrrxZllzgLvAL8lRwV4zKeGhsv/8oVCryfkEZ11X7KWFW5pIPWjpmsQz8s+//9+ynllP2bfXv5+sqnfKiSI6OK4V0AZ1+GLcQpGl8vX8WlxOUYS0xNVKhfSLHsHyjNzuRn29/LV8eTc/7uxKUkqGLAiVI6s1D3gcWva8rl9+ue9tfasa+3/qzXV351hrMGnMW7KBfVynThhRfaW2xsrH799Vd7Q+mVlpSsjLS0XK+hYA4ECsqcDTi4ZJmCG9RR/dsGateH3yjxYITSc9v//1952RwIAOei1PQUpWe7AnlmAOTndaL8DUDuzMLc9FPqr82vkr/3ib8ntUIqa0LX2/XJxkVavHulmlSso5HnD9ATXW7WhN9m8LGeq6jZP7OLap1OcHCwrrjiCj3zzDMF3R1KgGmVGVizqsu4X4VySo2LL/h+jhzTxolvat55feUd4KfW40fb8cTDkQqsVS3nviuWt/+mxiWc8fyBsigqKVoVA8JyjIX4Bivx/+uQAeTuSMJxVQ+ulGMszD9E8SmJ9uvhbftr5cHNunfRK3bB7gvLP9HjP72l4W37qUpgzt854FxW4GB/8eLFNqhH2XVs7RZ5BwUqrG3zrLHQpvXtWPY6/tPxqxQmn9CTPwOpMXE69OMfCm3WwN6PWrtZFTq0lof3yRNGYe1aKjU+QSlR0cX+foCywNTrN6/QOMdYw3L1FJl4rMTmBJQFG47sVscazXKMnVelgQ7GnbhGRf2wmtp89O8cj/8VsdPW8dcJzb/pBJwpIy3DbTfHB/s1a9Z070zgdnG79yly5V9q/uidWWNN7rlZSZFRily5Id/tu3z6ks6b+ECOsZBG4Yrbvd9+vX/OD/IJCVLDOwbZ+54+Pmo07DodWry02N8LUFb8fuAPta3SWvVCTyyCrxJQSR2qtdXaI/n/zgHnsrnbf1P38PPVolI9e9+01by8fkfbgtOITIhWmyonr/Ni9Kx7gf0384AA5yAW6BbPAl2UXasefE49Fr6jnkveV1pComr07qaV9/3H1tqb9pt+VSrYDH1utrz0nrp+/brN0v+z8DfVvKq7KrRrqVX3/9c+bjr9/DVhitq9/JhdvBvauK7KtWio5bc/cZbfJXD2VPArb3vv74rOmWHMtOLQGv11ZJMmdH5UfxxcrbZVWup4UowW7vmRbxPOaVWDKtgLZ204knvL2YW7Vuj3/X/piwHPaMHOP3RJnTa2tOfDDQvs46Yt57Tej+jjvmNtRr9+WA1dWb+TFuxcrn0xEWf53QClF/0QzzGmfeairjfaxbq+Fctr2W2P2yDeaHjnIF364wen3Xb/nCVaetMjqtX/Ul3y7Zuq3OV8/XDF7Tq6/ESWxdjw7Bs2uA+sVdXW9i/qNkSRf9KaFc51Wd3ueqbLmDyf88wfL9oe/XVDa2v9kc169NcJSkg9UXcMnKuGtLxcX13zbN7PmTNBM9bNU/NKdW3gf9Xnjyg2+cQaMFOnP/y7F1Q7tIqGn9/f9t//dsdS3beYroDnNFNu465bGeWRkdfK27PsY48mJT0FoEz6dHbHkp4CUCYt201LYKCwDo0+eXHO0ibt45vctm+vG97XOZ3ZN+2xNm/OvfwDAAAAcLeM9Ay33cqqYgv24+LidPXVVxfX7gAAAACUlgW6pi3nokWLimt3AAAAQOGU4dr6UhHsJyQk2IB+7dq1OnTokOLj4+Xj46MaNWqoZ8+e6tKli9smCgAAAMBNwf6WLVs0fPhwNWjQQG3atFHdunXl7++v2NhYrV+/XsOGDVP//v01YcKEQk4BAAAAKAZp6XyMRQ32H3/8cY0ePdoG9LnZsGGDBg8ebG8tW7Ys6G4BAACAYlGWF9KW+ALdnTt32oz+6TRv3lwhISGKjOSqdQAAAECZCvY7deqkMWPG2KD/VKaUZ/z48fL19VWHDh2Ke44AAABA/rioVtHLeEwt/siRI9WnTx9Vr15d4eHh8vPzU0REhLZv36769etr6tSpto4fAAAAQBkK9itWrKiZM2dq5cqV2rRpk2JiYuTl5aWwsDC1bdtWDRs2dO9MAQAAgLxQs3/mffbbtWtnbwAAAADOkYtqAQAAACUpg4tqFX2BLgAAAICyhcw+AAAAnCGdi2qdisw+AAAA4FBk9gEAAOAM1Oy7INgHAACAI2TQetMFZTwAAACAQ5HZBwAAgDNQxuOCzD4AAADgUGT2AQAA4Axk9l2Q2QcAAAAcimAfAAAAjunG467bmThy5IhGjBihtm3basCAAdq8eXOBttuyZYuaNGmS42b2UxiU8QAAAABukpGRoVGjRtmvZ82apXXr1tmAfc6cOQoKCspz29WrV+vCCy/UK6+8kjXm7V248J1gHwAAAM6Qlu62Xffs2TPPxxcvXpzr+KpVq2zQ/u2336pBgwb2NnfuXC1atEj9+vXLc59mu44dOyo0NLTI86aMBwAAAI5QGst4Nm7cqBo1aqhhw4ZZY6acZ+3atfluaw4UzIGBeX6nTp00btw4JSYmFur1yewDAAAA+Thd5j4/MTExqlOnTo6xcuXKadOmTXluFxUVpdjYWFsCdOmll2rv3r168MEHFRAQoIcffrjAr0+wDwAAAGcoha03vb295efnl2PM399f8fHxeW5Xvnx5LV26NOt+1apVbeD/0ksvFSrYp4wHAAAAcJOwsDDbjSc7k7H39fUt9L6qVKmiiIgIJSUlFXgbgn0AAAA4g6mtd9etiNq0aaNt27YpOjo6a2z9+vWqXr16ntv99NNPGjlyZI6xlStXqmLFii5nCvJCsA8AAAC4SaNGjVS/fn1NnjxZ6enp2rBhgxYuXKgePXrY++YgIC0tzWW7Fi1a2DKet956y/bl/+ijjzR9+nQNGTKkUK9PsA8AAABHyEjLcNvtTEycONEu8O3cubMGDRqkvn37qmvXrjpw4IDat2+vrVu3umxTqVIlTZ061XbjGThwoN5//3098cQTGjZsWKFemwW6AAAAgBs1b95cCxYs0IoVK2wNf+vWre14rVq17FVyT6dDhw765ptvzui1CfYBAADgDGdQW+9ugYGB6tatm842gn0AAAA4gxuvoFtWUbMPAAAAOBSZfQAAADhCRiku4ykpZPYBAAAAhyKzDwAAAGc4wxaZTlSqgv3rjz5e0lMAyqTL73mrpKcAlEkVRl1U0lMAgHMn2AcAAACKipp9V9TsAwAAAA5FZh8AAACOkEHNvguCfQAAADgCZTyuKOMBAAAAHIrMPgAAABwhnTIeF2T2AQAAAIcisw8AAABHoGbfFZl9AAAAwKHI7AMAAMARMtLTS3oKpQ6ZfQAAAMChyOwDAADAEbioliuCfQAAADgCC3RdUcYDAAAAOBSZfQAAADgCZTyuyOwDAAAADkVmHwAAAI5Azb4rMvsAAACAQ5HZBwAAgCOkp2eU9BRKHTL7AAAAgEOR2QcAAIAj0I3HFcE+AAAAHIEFuq4o4wEAAAAcisw+AAAAHIHMvisy+wAAAIBDkdkHAACAI7BA1xWZfQAAAMChyOwDAADAETLS00t6CqUOmX0AAADAocjsAwAAwBGo2XdFsA8AAABHoPWmK8p4AAAAAIcisw8AAABHSE/PKOkplDpk9gEAAACHIrMPAAAAR2CBrisy+wAAAIBDEewDAADAMd143HU7E0eOHNGIESPUtm1bDRgwQJs3by70Pnbt2qU2bdpo37597gn2V6xYobi4uEJPDAAAADhXZWRkaNSoUYqMjNSsWbM0ZMgQG/gXJq5OS0vTI488ooSEBPfV7JuJVapUSffee68GDhxY6BcCAAAAymrNfs+ePfN8fPHixbmOr1q1SqtXr9a3336rBg0a2NvcuXO1aNEi9evXr0CvPXXq1CIF+oUu4xk3bpw++eQT9e7dW1988YVSUlKK9KIAAADAuVDGs3HjRtWoUUMNGzbMGjPlPGvXri3Q9hs2bNC0adP0/PPPu78bT8eOHe1Rzbx58+yLTp482Qb+ffv2VatWrYo0AZzd3rOvvv2TPv9mjTw9PXT7kM66aVD7Qu/nl6U7dOcDM/Xp20PVukXNrPF9/0Tpyf98q3UbD8jPz1vduzTSmHt7KTjIr5jfCXCWeXgoYMBt8r/kKvOLpIRvP1LiwllF2pVPu4sVeu9EHR1yUdaY38W9FXznYzmelxZ5WFH3DDjjqQMl/nfny036/KfdJ/7u9Gmsmy5rUOj9/LLukO783+/69Kluat2ggsvjn/+4W9/8vlcfPHZxMc0cKHjmPj8xMTGqU6dOjrFy5cpp06ZN+W6bnJxsy3dGjx6tpk2bnr3WmybAN7elS5dm1R75+fmpQ4cOevXVV4s0Ebjfa9N+1jsfL9NDo3qqauUQjZ00X5UqBKn3pc0LvI/ExBSNe+E7DehzXo5A39SjPfDkV6pSOURTnh+kwxEx+t+UJXrs2bl65T/XuOkdAWdHwNW3KqD39YqfOUXpxyIUdMtDSj8eqeTlSwq1H4/AEAUPfcBl3LteEyWv/EXxs2ecHExNLY6pAyXqta826Z352/TQ4JaqGuavsTPWqFKon3p3qlXgfSQmp2nce2s04OLwXAP9PzYf0YQP1uq8XB7DuedMF9K6g7e3t42Ts/P391d8fHy+25rEeuXKlTV06NCiv35Bn+jh4eEyduGFF9pbbGysfv31V3tD6RQbl6R3Plqm0Xd005BrT2TzY2ISNeXdXwoV7L/+7q86Hp2g+4d3zzG+d3+U1m44oN++vVcVKwTZscSkFI1//julpaXLy4vGTyibPPwDFdDnBsV/+Y4Sv//ixFhgiAL631LoYD/wxtGSr7/LuFfdxkr+82el7dpSbPMGSlpsQorembdNowc005D/z+bHxKdoyuzNhQr2X/96s47Hpej+QS1cHluy+h89OGWFGtYIKda5A8UpLCzMduPJzsTOvr6++TbH+frrrzV79uxc4/CCKnAEZjK3pxMcHKwrrrhCzzzzTJEnAvdatW6vkpJTddVlJ/+z7Nm1ibbvOqJDETEF2sfWHYc145Nluvv2rlkBfaZjx08cnWbo5M9JSkqafHy9CfRRpnk3bi0PXz8l/74wayx55c/yrlVPHuUrFng/Pud1kl/HHor/7M2cD3h4yrtOQ6XuKnwbNqA0W7X1qJJS0nXVhbWzxnq2q6Ht+2N06FjBFhpu3RetGfO36e6rm6piqGtJ6J+bj+jFUR3UvW31Yp07yvYCXXfdisq0y9y2bZuio6OzxtavX6/q1fP+uf3yyy/tQUGfPn10wQUX2Jthyuffeuut4g/2TZ2SCepRNpmAvlxogKpWCc0aK18uQCHBfvp737EC7WP8C9/Zf7ftjNAj47/Rd4tP1po1blBFFcIC9fxrS2zmf/uuCL038w/1vbylG94NcPZ4hlVSesxxpR87mZXJiItRelyMvKrWKvDZAVP6E//lu0rbvzvHY141wuXhF6DAa+9ShbcXKuz1OQq66T7JP6DY3wtwNh06lqhyQT6qWuHkz3L5YF+FBPro70MFazk4/r019t9t+6L1yJt/6rs/9ud4/MHBLdXtvGrFPHOgeDVq1Ej169e3JTnp6el2we3ChQvVo0cPe98cBJjWmqd66KGH9N1339nsfubNMIH+ddddV/xlPDVrnqzPRtmTmJSq0BDXrEhggK8io/KvGVvyy1b9uWavfH29bMnOkchYzZ6/Xjf/1UFj7umlAH8fvfTMAA29+yM7blzQprYeu7eXW94PcLaYrH5GfKzLeEZSgjxDyhdoH4E3jFJ6ZIQS530i7ybn5XjMu34zZaSnKXXzaiV8MU2e1WorcPAweQQEKfZNzpai7DK19qFBrmUKgX5eioxJynf7Jav+0Z9bjsrXx1N7I+J15HiiZv+2Vzdf3kBj/t3aPscs+gVOXRReGk2cOFF33XWXDd7Ngl3TcrNr1672Almm+Y0J5Js1a5ZjmwoVKtjbqapVq6bQ0JPJW7cs0EXZ4+vjJU9P1xM5pgQsKSn/FqqfzV4tby9PfTT1JrVqVsOOPffqYr378TJdP6CdKoYF6on/fKtunRvqX5e10MHDMXrr/d/tGYAXn6GjCMqujNQU24HH9YEMyTf/TlM+LS6QX+fLFPXELWblmMvjyat/U+pjQ5W2f9eJgQ1/SqnJChr6oDw+fNmeRQDKIhOk5xaLm9rjpGTXLOapPvtxt7y9PPTR413Vqn6YHXvuk/V6d/52Xd+zvupWo9oAZUfz5s21YMECW4dvavhbtz5xwFqrVi1t2VLw9VqFeW4mgv1zRMWwINsh51THoxNtVj4/u/dGqkO78KxA3xjcv60N9jdtOaiDETEKCPDR65Ouzcq0NG9cVbeM/lhDr9+v87J17gHKkvToY/KsUMll3DM4VEpKzHtjvwAF3faw4me9rfSDe3N9SkbscaXFHs8xlrJ1vTy8feRVs55St647szcAlBBTY3/4mOvvyPHYZAX45R9+7D4Yqw7NKmcF+sbgHvVssL9pTxTBPnKVW26mtAgMDFS3bt3O+usS7J8jmjaqqoTEFG3Y8o9aNDmxIGTH7iN2zLTLzE+gv49q18hZsuD///9Z+/h4afffR9WgXqUcp1SbNq5q/zVlPwT7KKvS/t5ua+q9whsrbc/WHHX26VE5uyucyrteU3lVrqGgf99tb9lV/OBXW8Of/McP9uxB+qF9WY95Bpez/3rk06kBKM2a1imnhOQ0bdgdpRZ1T/z92LE/2o5VCXPtSpVbuU/tyoE5xvx9vOy/Pt50eEPZC/ZLSrH9tpgFBps3002itKpVo7yaN6mmt99fmjX2/qd/qFyIf1bwn5eWzWpo8/bDOcaWr9pjg/tWzaorrHygNm05ZNtsZvr59x32X9PTHyir0iP+UequLQq46sasMf/LrlV6bLQdz4vpsBP1+NAct9hp/7WPma8Tl3ytgP43K3DgHTm287v4SnsAkLr7xMEFUBbVqhyk5nXL6+25J3+O31+4wy7azQz+89Kyfpg2/53zrNfyTRG2NKhVvZPZfgBnKbMfFxenq6++ukBXA0PJePjunrr9nk9008gPbVb+56U79OjoS+Xt7Wm79UQei1Ozxrl3NbhpcHtdM/RdjZ00T1de2ly7/47Ui1N/1FWXtbQdfrpf1MjW6P972Ptq3zZchyKitWDJZjVrVFXnty54P2WgNIr75DWFPvyiQse8ooyUJPmed6HiPnpFSk+z7Tc9Q8PsGQAXSQku46ZHv5E5nvj9lwp97BUF3Xy/UndulneztvK/+Ep7ld6M2JNt2oCy6OHrWur253/TTRN/sVn5n9cd0qM3tLJrwEz7zcjoJDULzz3wN1faveapHzR2+mpd2bGWLet58fMNuqpz7RwdfoDsyOy7MbNv2nIuWrSouHYHN+jUrq4+eGOIXawbdTxBz4zpo6HXd8xagGsOAk6nYb3Keu/1G7X3QJRGPTJLL735oy67pInGPnyFfdyU6bw1+Tolp6TpvU+Xa9FPW9Th/Dp66dkB9NlHmZe6abWinx1ps+0eweUUO22iEr/7zD7m372fQh8r+pXDTU1+7JRxdiFv0NAH7NV0Y9+brPiZbxTjOwBKRqfmlfXBYxfL19tTUbHJeua2thp6RUP72Gc/7NZNE09/Mc6GNUP13piLbSeeUS8v00uzNuqyC2po7NA2Z/EdAGWfR0ZeV8s6RUJCgg3o165dq0OHDtnL/Pr4+KhGjRq2bVCXLl3OaDIZke+f0fbAuSrynoJfXAPASRVGXcTHARSSR8cT5Yil0epmTd2277abNju7jMe0+hk+fLgaNGhgrwRWt25d+fv72yt7mauADRs2TP3799eECRPcO2MAAAAAxRvsP/744xo9erQN6HNjrgY2ePBge2vZkqumAgAA4OyiZv8MavZ37txpM/p5XSwgJCREkZGRBd0lAAAAgNIQ7Hfq1EljxoyxQf+pTCnP+PHj5evrqw4dOhT3HAEAAIACZfbddXN8GY+pxR85cqT69Omj6tWrKzw8XH5+foqIiND27dtVv359TZ061dbxAwAAAChDwX7FihU1c+ZMrVy50vbSj4mJkZeXl8LCwtS2bVs1bHiilRYAAABQEspyBr7UXFSrXbt29gYAAACUJgT7bryoFgAAAIAyntkHAAAASiMy+67I7AMAAAAORWYfAAAAjkBm3xWZfQAAAMChyOwDAADAEcjsuyKzDwAAADgUmX0AAAA4Apl9VwT7AAAAcISMjIySnkKpQxkPAAAA4FBk9gEAAOAIlPG4IrMPAAAAOBSZfQAAADgCmX1XZPYBAAAAhyKzDwAAAEcgs++KzD4AAADgUGT2AQAA4Ahk9l0R7AMAAMARCPZdUcYDAAAAOBSZfQAAADgCmX1XZPYBAAAAhyKzDwAAAEcgs++KzD4AAADgUGT2AQAA4AjpGSU9g9KHzD4AAADgUGT2AQAA4AjU7Lsi2AcAAIAjEOy7oowHAAAAcCgy+wAAAHAEMvuuyOwDAAAADkVmHwAAAI5AZt8VmX0AAADAoTwyMjK4/AAAAADgQGT2AQAAAIci2AcAAAAcimAfAAAAcCiCfQAAAMChCPYBAAAAhyLYBwAAAByKYB8AAABwKIJ9AAAAwKEI9gEAAACHItgHAAAAHIpgHwAAAHAogn0AAADAoQj2AQAAAIci2AeAIti0aZMGDx6sli1bql27dpo0aZLS09Pz3W7Lli1q0qRJjtuIESP4HuCckpycrHXr1tnfh4yMjJKeDuBoBPsoctCSlpZmn9uxY0d1795d8+bN49PEOSE2NlZ33HGH/dlfsmSJXnrpJX388cf66quv8t129erVuvDCC7VixYqs2wsvvHBW5g2UBibIN38znnjiCd18880aOHCgoqOj892OvzlA0XgXcTs4LGgZMGCAXn31VZtlGTVqlBo2bKhrrrkmz21NgDN79my7nY+Pj+6++26Fh4erRYsWZ23+QEnYvn27rrrqKt1///32fpUqVeyB8tq1a/P9vTHBvjlICA0NPUuzBUoPE7Cb35sHHnjA/t2Ji4uzvzPmYHnYsGF5bsvfHKBoyOyf47IHLSZgufjii7OClvxOwX744Yf2wKBDhw5q27atbrrpJvsfNuB0bdq00SOPPJIjgNmxY4fq16+f77arVq3S3Llz7e9Mp06dNG7cOCUmJrp5xkDpEBMTY/9WmEDfCAoKsr83x48fz3M7/uYARUewf44ratCya9cuxcfH24ODTCZ4ye8gAXCimTNn2oA9M4A5naioKHs27YYbbtB3332n1157TT/88INeeeWVszZXoCSVL1/eBvuZli9frqVLl+rKK6/Mczv+5gBFRxkPihS0mOyMl5eXateunTVmyhIOHTrEJ4pzyrZt2/T8889r/Pjx+ZbmmEDHBDaZqlatas+OmfKEhx9++CzMFig9zFnlrVu36t5771Xr1q3zfC5/c4CiI7MPl6Dl8ccfzzdo8fb2lq+vb46xgIAAm+0HzhUmU2+CdVNz3Ldv3yLtw5TPRUREKCkpqdjnB5Rm06ZN06OPPqopU6bkOAjODX9zgKIj2EeRgpawsDAlJCTYkoTsmZdTDwAApzI//yNHjlStWrU0ZsyYAm3z008/2W2yW7lypSpWrCg/Pz83zRQoncyZrVtuucVm+D/55JM8n8vfHKDoCPZRpKDFlO9UqlTJBiqZ1q9fr+rVq/OJwvFMX/D77rtPx44d08SJE21W3nQVMSVwpm2taSNo1r+cynSqMhnMt956S5s3b9ZHH32k6dOna8iQISXyPoCzbcOGDbZzW/be+iZJZMpC88LfHKDoCPbPcUUNWjw9PdW7d2+7sNBk9832M2bMUI8ePUrkfQBnk2lRaxbWmsXsZpH6+eefb2+mje2BAwfUvn17W4t8KnOAPHXqVNuNx/QWf//9922v8fxaDgJOUa9ePdt+9umnn9b+/fv1888/a86cOTa7z98cwD08Mrh03TnNZBf79evnMm7aaZrgv2fPnvr666/VrFkzl+eYsh0T3JigxvwYmR77ph1ncHDwWZo9AKAs/t159tln9ddff9lSHnOw279/f+3bt4+/OYAbEOzjjJhMjCnlMT2QzQGCubgWAADuwN8coPAI9gEAAACHomYfAAAAcCiCfQAAAMChCPYBAAAAhyLYBwAAAByKYB8AAABwKIJ9AAAAwKEI9gEAAACHItgHAAAA5Ez/ByOATDnye767AAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    }
   ],
   "execution_count": 49
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}