diff --git a/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001OFFLINE_FES_task-Default_run-001_eeg.xdf b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001OFFLINE_FES_task-Default_run-001_eeg.xdf new file mode 100644 index 0000000..af0ef4e --- /dev/null +++ b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001OFFLINE_FES_task-Default_run-001_eeg.xdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd4e2b8cfc2bcc5573f9701bc55e9d261fb6d901c817ec3fa5bf933f7b6fcc9e +size 232861017 diff --git a/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001ONLINE_FES_task-Default_run-001_eeg.xdf b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001ONLINE_FES_task-Default_run-001_eeg.xdf new file mode 100644 index 0000000..883a562 --- /dev/null +++ b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001ONLINE_FES_task-Default_run-001_eeg.xdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e7b1d390ca2b05199031f4120e63c840c4e89339c60611d4c4b3cd937e00596 +size 115438391 diff --git a/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001ONLINE_NOFES_task-Default_run-001_eeg.xdf b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001ONLINE_NOFES_task-Default_run-001_eeg.xdf new file mode 100644 index 0000000..6bbd231 --- /dev/null +++ b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S001ONLINE_NOFES_task-Default_run-001_eeg.xdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7d3a3c250379e365ec14f3fdf1ac2757d6aa94edbd0e3b7edccdd8891e0100e +size 108298062 diff --git a/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S004OFFLINE_NOFES_task-Default_run-001_eeg.xdf b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S004OFFLINE_NOFES_task-Default_run-001_eeg.xdf new file mode 100644 index 0000000..41d170a --- /dev/null +++ b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S004OFFLINE_NOFES_task-Default_run-001_eeg.xdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f76d5490e57f0a1e2926cdd8dfffbf47ef209819b9f6b58163a346f67014492d +size 219577540 diff --git a/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S005ONLINE_NOFES_task-Default_run-001_eeg.xdf b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S005ONLINE_NOFES_task-Default_run-001_eeg.xdf new file mode 100644 index 0000000..f462241 --- /dev/null +++ b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S005ONLINE_NOFES_task-Default_run-001_eeg.xdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0164cf8cf8dde46515778d51bf09953d89e5227036b390b8d9c9c418c176231 +size 109754262 diff --git a/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S006ONLINE_FES_task-Default_run-001_eeg.xdf b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S006ONLINE_FES_task-Default_run-001_eeg.xdf new file mode 100644 index 0000000..580f28f --- /dev/null +++ b/Final Project/Group 2 - Glove/sub-S26CLASS_SUBJ_002_ses-S006ONLINE_FES_task-Default_run-001_eeg.xdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da4016ba269156ab02e657185a6d8dd6aec788dab25b07455c3ac95e265602dc +size 111705054 diff --git a/Final Project/decision_margin_distributions.png b/Final Project/decision_margin_distributions.png index 7d7efae..6057521 100644 Binary files a/Final Project/decision_margin_distributions.png and b/Final Project/decision_margin_distributions.png differ diff --git a/Final Project/fes_minus_nofes_delta.png b/Final Project/fes_minus_nofes_delta.png index d6116d3..dc5fd86 100644 Binary files a/Final Project/fes_minus_nofes_delta.png and b/Final Project/fes_minus_nofes_delta.png differ diff --git a/Final Project/fes_vs_nofes_metrics.png b/Final Project/fes_vs_nofes_metrics.png index 9fc7d78..7a3a9f8 100644 Binary files a/Final Project/fes_vs_nofes_metrics.png and b/Final Project/fes_vs_nofes_metrics.png differ diff --git a/Final Project/overall_analysis.ipynb b/Final Project/overall_analysis.ipynb index c40b372..f6524a2 100755 --- a/Final Project/overall_analysis.ipynb +++ b/Final Project/overall_analysis.ipynb @@ -2,14 +2,34 @@ "cells": [ { "cell_type": "markdown", + "id": "d8960e56", "metadata": {}, - "source": "# Motor Imagery Decoder — Train OFFLINE, Evaluate ONLINE (FES vs NOFES)\n\nFor each subject × offline-session, train a CSP + LDA classifier on the OFFLINE recording, then apply it to the two matched ONLINE sessions.\n\n**Pair 1:** train on `S001 OFFLINE_FES` → test on `S002 ONLINE_FES` and `S003 ONLINE_NOFES`\n**Pair 2:** train on `S004 OFFLINE_NOFES` → test on `S006 ONLINE_FES` and `S005 ONLINE_NOFES`\n\n**Metrics reported per (subject × pair × condition):**\n1. **Classification accuracy** — fraction of cued trials correctly classified\n2. **Classification amplitude** — mean |LDA decision-function value|\n3. **SNR** — (a) Fisher ratio of the LDA projection on online data, and (b) mu-band power ratio REST / MI over motor channels C3/Cz/C4" + "source": [ + "# Motor Imagery Decoder — Train OFFLINE, Evaluate ONLINE (FES vs NOFES)\n", + "\n", + "For each subject × offline-session, train a CSP + LDA classifier on the OFFLINE recording, then apply it to the two matched ONLINE sessions.\n", + "\n", + "**Pair 1:** train on `S001 OFFLINE_FES` → test on `S002 ONLINE_FES` and `S003 ONLINE_NOFES`\n", + "**Pair 2:** train on `S004 OFFLINE_NOFES` → test on `S006 ONLINE_FES` and `S005 ONLINE_NOFES`\n", + "\n", + "**Metrics reported per (subject × pair × condition):**\n", + "1. **Classification accuracy** — fraction of cued trials correctly classified\n", + "2. **Classification amplitude** — mean |LDA decision-function value|\n", + "3. **SNR** — (a) Fisher ratio of the LDA projection on online data, and (b) mu-band power ratio REST / MI over motor channels C3/Cz/C4" + ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 1, "id": "578c9128", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:51:36.337947Z", + "iopub.status.busy": "2026-04-22T00:51:36.337765Z", + "iopub.status.idle": "2026-04-22T00:51:36.341891Z", + "shell.execute_reply": "2026-04-22T00:51:36.341238Z" + } + }, "outputs": [], "source": [ "# Install dependencies if needed\n", @@ -18,11 +38,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "857b22c0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:51:36.344380Z", + "iopub.status.busy": "2026-04-22T00:51:36.344206Z", + "iopub.status.idle": "2026-04-22T00:51:37.587307Z", + "shell.execute_reply": "2026-04-22T00:51:37.586902Z" + } + }, "outputs": [], - "source": "import os\nimport re\nimport glob\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Patch\nimport pyxdf\nfrom scipy.signal import welch, butter, filtfilt\nfrom scipy.linalg import eigh\n\nplt.rcParams.update({'font.size': 11, 'figure.dpi': 120})" + "source": [ + "import os\n", + "import re\n", + "import glob\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import Patch\n", + "import pyxdf\n", + "from scipy.signal import welch, butter, filtfilt, iirnotch\n", + "from scipy.linalg import eigh\n", + "\n", + "plt.rcParams.update({'font.size': 11, 'figure.dpi': 120})" + ] }, { "cell_type": "markdown", @@ -34,11 +73,54 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "dc4b2c55", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:51:37.589045Z", + "iopub.status.busy": "2026-04-22T00:51:37.588919Z", + "iopub.status.idle": "2026-04-22T00:51:37.591774Z", + "shell.execute_reply": "2026-04-22T00:51:37.591458Z" + } + }, "outputs": [], - "source": "DATA_DIR = os.path.join(os.path.dirname(os.path.abspath('__file__')), 'Group 2 - Glove')\n\n# Marker codes (same cue-encoding in offline and online)\nMI_BEGIN, MI_END = 200, 220\nREST_BEGIN, REST_END = 100, 120\nTARGET_MARKERS = [100, 120, 200, 220]\n\n# Epoch window (t=0 at cue marker)\nT_PRE = -1.0 # baseline start\nT_POST = 5.0 # epoch end\n\n# Bandpass for MI decoding (mu + beta)\nBP_LO, BP_HI = 8.0, 30.0\n\n# CSP spatial filters (top N/2 + bottom N/2)\nN_CSP = 4\n\nNON_EEG = {'AUX1', 'AUX2', 'AUX3', 'AUX7', 'AUX8', 'AUX9', 'TRIGGER'}\nRENAME = {'FP1':'Fp1','FPZ':'Fpz','FP2':'Fp2','FZ':'Fz','CZ':'Cz',\n 'PZ':'Pz','POZ':'POz','OZ':'Oz'}\n\nMOTOR_CH = ['C3', 'Cz', 'C4']\nMU_BAND = (8, 13)\n\n# Design: per subject, each OFFLINE session trains a model tested on two ONLINE sessions\nPAIRS = [\n {'name': 'Pair1 (train=OFFLINE_FES)',\n 'train': 'S001', 'online_fes': 'S002', 'online_nofes': 'S003'},\n {'name': 'Pair2 (train=OFFLINE_NOFES)',\n 'train': 'S004', 'online_fes': 'S006', 'online_nofes': 'S005'},\n]" + "source": [ + "DATA_DIR = os.path.join(os.path.dirname(os.path.abspath('__file__')), 'Group 2 - Glove')\n", + "\n", + "# Marker codes (same cue-encoding in offline and online)\n", + "MI_BEGIN, MI_END = 200, 220\n", + "REST_BEGIN, REST_END = 100, 120\n", + "TARGET_MARKERS = [100, 120, 200, 220]\n", + "\n", + "# Epoch window (t=0 at cue marker)\n", + "T_PRE = -1.0 # baseline start\n", + "T_POST = 5.0 # epoch end\n", + "\n", + "# ── Preprocessing ────────────────────────────────────────────────────────────\n", + "NOTCH_FREQ = 60.0 # US powerline; EU would be 50\n", + "NOTCH_Q = 30 # quality factor for narrow notch\n", + "BP_LO, BP_HI = 8.0, 30.0 # mu + beta (MI band)\n", + "USE_CAR = True # Common Average Reference spatial filter (Blankertz 2008; McFarland 1997)\n", + "PTP_REJECT_UV = 100.0 # epoch-wise peak-to-peak threshold on BP data (µV) — reject blinks/movement\n", + "\n", + "# CSP spatial filters (top N/2 + bottom N/2)\n", + "N_CSP = 4\n", + "\n", + "NON_EEG = {'AUX1', 'AUX2', 'AUX3', 'AUX7', 'AUX8', 'AUX9', 'TRIGGER'}\n", + "RENAME = {'FP1':'Fp1','FPZ':'Fpz','FP2':'Fp2','FZ':'Fz','CZ':'Cz',\n", + " 'PZ':'Pz','POZ':'POz','OZ':'Oz'}\n", + "\n", + "MOTOR_CH = ['C3', 'Cz', 'C4']\n", + "MU_BAND = (8, 13)\n", + "\n", + "# Design: per subject, each OFFLINE session trains a model tested on two ONLINE sessions\n", + "PAIRS = [\n", + " {'name': 'Pair1 (train=OFFLINE_FES)',\n", + " 'train': 'S001', 'online_fes': 'S002', 'online_nofes': 'S003'},\n", + " {'name': 'Pair2 (train=OFFLINE_NOFES)',\n", + " 'train': 'S004', 'online_fes': 'S006', 'online_nofes': 'S005'},\n", + "]" + ] }, { "cell_type": "markdown", @@ -50,11 +132,239 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "e798b039", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:51:37.592974Z", + "iopub.status.busy": "2026-04-22T00:51:37.592890Z", + "iopub.status.idle": "2026-04-22T00:51:37.605863Z", + "shell.execute_reply": "2026-04-22T00:51:37.605402Z" + } + }, "outputs": [], - "source": "# ── XDF loading + session parsing ─────────────────────────────────────────────\n\ndef get_channel_names_from_xdf(eeg_stream):\n ch_desc = eeg_stream['info']['desc'][0]\n channels = ch_desc.get('channels', [{}])[0].get('channel', [])\n return [ch['label'][0] for ch in channels]\n\n\n# Tolerates the 'ONOLINE' typo in subj 003 / S005\n_SESSION_RE = re.compile(r'ses-(S\\d+)(O[A-Z]*LINE)_(FES|NOFES)')\n_SUBJ_RE = re.compile(r'SUBJ_(\\d+)')\n\ndef parse_session(path):\n \"\"\"Return (subject, session_id, kind, stim) or None.\"\"\"\n base = os.path.basename(path)\n m_subj = _SUBJ_RE.search(base)\n m_ses = _SESSION_RE.search(base)\n if not (m_subj and m_ses):\n return None\n ses_id, raw_kind, stim = m_ses.group(1), m_ses.group(2), m_ses.group(3)\n kind = 'OFFLINE' if 'OFF' in raw_kind else 'ONLINE'\n return m_subj.group(1), ses_id, kind, stim\n\n\ndef load_xdf_file(filepath):\n streams, _ = pyxdf.load_xdf(filepath)\n\n eeg_stream = marker_stream = None\n for s in streams:\n stype = s['info']['type'][0].lower()\n if stype == 'eeg': eeg_stream = s\n elif stype == 'markers': marker_stream = s\n if eeg_stream is None or marker_stream is None:\n eeg_stream = streams[0]\n marker_stream = streams[1] if len(streams) > 1 else None\n\n eeg_timestamps = np.array(eeg_stream['time_stamps'])\n eeg_data = np.array(eeg_stream['time_series']).T\n channel_names = get_channel_names_from_xdf(eeg_stream)\n sfreq = float(eeg_stream['info']['nominal_srate'][0])\n\n valid_idx = [i for i, ch in enumerate(channel_names) if ch not in NON_EEG]\n channel_names = [channel_names[i] for i in valid_idx]\n eeg_data = eeg_data[valid_idx, :]\n channel_names = [RENAME.get(ch, ch) for ch in channel_names]\n\n ts_arr = np.asarray(marker_stream['time_series'], dtype=float)\n marker_data = ts_arr[:, 0].astype(int)\n marker_ts = ts_arr[:, 1]\n keep = np.isin(marker_data, TARGET_MARKERS)\n return eeg_data, eeg_timestamps, marker_data[keep], marker_ts[keep], channel_names, sfreq\n\n\ndef bandpass(data, lo, hi, sfreq, order=4):\n nyq = sfreq / 2.0\n b, a = butter(order, [max(lo, 0.5) / nyq, min(hi, nyq - 0.1) / nyq], btype='band')\n return filtfilt(b, a, data, axis=-1)\n\n\ndef extract_epochs(eeg_data, eeg_ts, marker_data, marker_ts, sfreq, begin_code,\n t_pre=T_PRE, t_post=T_POST):\n \"\"\"Returns (n_epochs, n_ch, n_samp) — all epochs trimmed to the same length.\"\"\"\n epochs = []\n n_pre = int(abs(t_pre) * sfreq)\n\n for bi in np.where(marker_data == begin_code)[0]:\n t_start = marker_ts[bi]\n i0 = np.searchsorted(eeg_ts, t_start + t_pre)\n i1 = np.searchsorted(eeg_ts, t_start + t_post)\n if i0 < 0 or i1 > eeg_data.shape[1]:\n continue\n ep = eeg_data[:, i0:i1].copy()\n if ep.shape[1] > n_pre:\n ep -= ep[:, :n_pre].mean(axis=1, keepdims=True)\n epochs.append(ep)\n\n if not epochs:\n return np.empty((0, eeg_data.shape[0], 0))\n min_len = min(e.shape[-1] for e in epochs)\n return np.stack([e[:, :min_len] for e in epochs])\n\n\ndef load_session_epochs(filepath):\n \"\"\"Bandpass continuous EEG, epoch on MI/REST cues, keep ACTIVE window [0, T_POST].\n Returns X (n_trials, n_ch, n_samp), y (1=MI, 0=REST), ch_names, sfreq.\n \"\"\"\n eeg, eeg_ts, mk, mk_ts, ch_names, sfreq = load_xdf_file(filepath)\n eeg_bp = bandpass(eeg, BP_LO, BP_HI, sfreq)\n\n mi = extract_epochs(eeg_bp, eeg_ts, mk, mk_ts, sfreq, MI_BEGIN)\n rest = extract_epochs(eeg_bp, eeg_ts, mk, mk_ts, sfreq, REST_BEGIN)\n\n n_pre = int(abs(T_PRE) * sfreq)\n if mi.shape[-1] > n_pre: mi = mi[..., n_pre:]\n if rest.shape[-1] > n_pre: rest = rest[..., n_pre:]\n\n n = min(mi.shape[-1], rest.shape[-1]) if (mi.size and rest.size) else 0\n mi, rest = mi[..., :n], rest[..., :n]\n\n X = np.concatenate([mi, rest], axis=0)\n y = np.concatenate([np.ones(len(mi), int), np.zeros(len(rest), int)])\n return X, y, ch_names, sfreq\n\n\n# ── CSP + LDA (2-class, numpy/scipy only) ────────────────────────────────────\n\ndef _mean_cov(X):\n \"\"\"Average trace-normalized trial covariance. X: (n_trials, n_ch, n_samp).\"\"\"\n covs = np.einsum('ijk,ilk->ijl', X, X)\n covs /= np.trace(covs, axis1=1, axis2=2)[:, None, None]\n return covs.mean(axis=0)\n\n\nclass CSPLDA:\n \"\"\"Common Spatial Patterns (log-var features) + Linear Discriminant Analysis.\"\"\"\n\n def __init__(self, n_csp=N_CSP, reg=1e-6):\n self.n_csp = n_csp\n self.reg = reg\n\n def fit(self, X, y):\n assert set(np.unique(y)) == {0, 1}, 'CSPLDA requires both classes in training set'\n C1 = _mean_cov(X[y == 1])\n C0 = _mean_cov(X[y == 0])\n # Generalized eigenproblem: C1 w = λ (C0 + C1) w\n evals, evecs = eigh(C1, C0 + C1)\n order = np.argsort(evals)\n k = self.n_csp // 2\n # Stack bottom-k (max class-0 variance) and top-k (max class-1 variance) filters\n self.filters_ = np.concatenate([evecs[:, order[:k]],\n evecs[:, order[-k:]]], axis=1).T # (n_csp, n_ch)\n\n F = self._features(X)\n mu1, mu0 = F[y == 1].mean(0), F[y == 0].mean(0)\n Sw = np.cov(F[y == 1].T, ddof=1) + np.cov(F[y == 0].T, ddof=1)\n Sw += self.reg * np.eye(Sw.shape[0])\n self.coef_ = np.linalg.solve(Sw, mu1 - mu0)\n self.intercept_ = -self.coef_ @ ((mu1 + mu0) / 2)\n return self\n\n def _features(self, X):\n Z = np.einsum('fc,ncs->nfs', self.filters_, X) # spatial filter\n var = Z.var(axis=-1, ddof=1)\n return np.log(var / var.sum(axis=1, keepdims=True)) # normalized log-var\n\n def decision_function(self, X):\n return self._features(X) @ self.coef_ + self.intercept_\n\n def predict(self, X):\n return (self.decision_function(X) > 0).astype(int)\n\n\n# ── Evaluation metrics ───────────────────────────────────────────────────────\n\ndef evaluate(clf, X, y):\n margin = clf.decision_function(X)\n pred = (margin > 0).astype(int)\n acc = (pred == y).mean()\n amp = np.abs(margin).mean()\n m1, m0 = margin[y == 1], margin[y == 0]\n fisher = (m1.mean() - m0.mean()) ** 2 / (m1.var(ddof=1) + m0.var(ddof=1) + 1e-30)\n return dict(acc=acc, amp=amp, fisher=fisher, margin=margin, y=y, pred=pred)\n\n\ndef spectral_snr(X, y, ch_idx, sfreq, band=MU_BAND):\n \"\"\"Ratio of REST mu-power to MI mu-power averaged over selected channels.\"\"\"\n def band_pwr(sig):\n f, p = welch(sig, fs=sfreq,\n nperseg=min(int(sfreq * 2), sig.shape[-1]),\n noverlap=int(sfreq), axis=-1)\n m = (f >= band[0]) & (f < band[1])\n return np.trapezoid(p[..., m], f[m], axis=-1).mean()\n\n return band_pwr(X[y == 0][:, ch_idx, :]) / (band_pwr(X[y == 1][:, ch_idx, :]) + 1e-30)" + "source": [ + "# ── XDF loading + session parsing ─────────────────────────────────────────────\n", + "\n", + "def get_channel_names_from_xdf(eeg_stream):\n", + " ch_desc = eeg_stream['info']['desc'][0]\n", + " channels = ch_desc.get('channels', [{}])[0].get('channel', [])\n", + " return [ch['label'][0] for ch in channels]\n", + "\n", + "\n", + "# Tolerates the 'ONOLINE' typo in subj 003 / S005\n", + "_SESSION_RE = re.compile(r'ses-(S\\d+)(O[A-Z]*LINE)_(FES|NOFES)')\n", + "_SUBJ_RE = re.compile(r'SUBJ_(\\d+)')\n", + "\n", + "def parse_session(path):\n", + " \"\"\"Return (subject, session_id, kind, stim) or None.\"\"\"\n", + " base = os.path.basename(path)\n", + " m_subj = _SUBJ_RE.search(base)\n", + " m_ses = _SESSION_RE.search(base)\n", + " if not (m_subj and m_ses):\n", + " return None\n", + " ses_id, raw_kind, stim = m_ses.group(1), m_ses.group(2), m_ses.group(3)\n", + " kind = 'OFFLINE' if 'OFF' in raw_kind else 'ONLINE'\n", + " return m_subj.group(1), ses_id, kind, stim\n", + "\n", + "\n", + "def load_xdf_file(filepath):\n", + " streams, _ = pyxdf.load_xdf(filepath)\n", + "\n", + " eeg_stream = marker_stream = None\n", + " for s in streams:\n", + " stype = s['info']['type'][0].lower()\n", + " if stype == 'eeg': eeg_stream = s\n", + " elif stype == 'markers': marker_stream = s\n", + " if eeg_stream is None or marker_stream is None:\n", + " eeg_stream = streams[0]\n", + " marker_stream = streams[1] if len(streams) > 1 else None\n", + "\n", + " eeg_timestamps = np.array(eeg_stream['time_stamps'])\n", + " eeg_data = np.array(eeg_stream['time_series']).T\n", + " channel_names = get_channel_names_from_xdf(eeg_stream)\n", + " sfreq = float(eeg_stream['info']['nominal_srate'][0])\n", + "\n", + " valid_idx = [i for i, ch in enumerate(channel_names) if ch not in NON_EEG]\n", + " channel_names = [channel_names[i] for i in valid_idx]\n", + " eeg_data = eeg_data[valid_idx, :]\n", + " channel_names = [RENAME.get(ch, ch) for ch in channel_names]\n", + "\n", + " ts_arr = np.asarray(marker_stream['time_series'], dtype=float)\n", + " marker_data = ts_arr[:, 0].astype(int)\n", + " marker_ts = ts_arr[:, 1]\n", + " keep = np.isin(marker_data, TARGET_MARKERS)\n", + " return eeg_data, eeg_timestamps, marker_data[keep], marker_ts[keep], channel_names, sfreq\n", + "\n", + "\n", + "# ── Preprocessing primitives ─────────────────────────────────────────────────\n", + "\n", + "def notch_filter(data, freq, sfreq, Q=NOTCH_Q):\n", + " \"\"\"IIR notch at `freq` Hz — removes powerline interference.\"\"\"\n", + " b, a = iirnotch(freq, Q, fs=sfreq)\n", + " return filtfilt(b, a, data, axis=-1)\n", + "\n", + "\n", + "def car(data):\n", + " \"\"\"Common Average Reference: subtract the across-channel mean at each sample.\n", + " Standard spatial preprocessing for MI-BCI (McFarland 1997; Blankertz 2008).\n", + " \"\"\"\n", + " return data - data.mean(axis=0, keepdims=True)\n", + "\n", + "\n", + "def bandpass(data, lo, hi, sfreq, order=4):\n", + " nyq = sfreq / 2.0\n", + " b, a = butter(order, [max(lo, 0.5) / nyq, min(hi, nyq - 0.1) / nyq], btype='band')\n", + " return filtfilt(b, a, data, axis=-1)\n", + "\n", + "\n", + "def reject_by_ptp(X, thresh_uv=PTP_REJECT_UV):\n", + " \"\"\"Boolean mask: True = keep (max-across-channels peak-to-peak < threshold).\n", + " Amplitude criterion for blink / movement artifact rejection (Nolan 2010).\n", + " \"\"\"\n", + " if X.size == 0:\n", + " return np.zeros(0, dtype=bool)\n", + " ptp = X.max(axis=-1) - X.min(axis=-1) # (n_trials, n_ch)\n", + " return ptp.max(axis=-1) < thresh_uv\n", + "\n", + "\n", + "def extract_epochs(eeg_data, eeg_ts, marker_data, marker_ts, sfreq, begin_code,\n", + " t_pre=T_PRE, t_post=T_POST):\n", + " \"\"\"Returns (n_epochs, n_ch, n_samp) — all epochs trimmed to the same length.\"\"\"\n", + " epochs = []\n", + " n_pre = int(abs(t_pre) * sfreq)\n", + "\n", + " for bi in np.where(marker_data == begin_code)[0]:\n", + " t_start = marker_ts[bi]\n", + " i0 = np.searchsorted(eeg_ts, t_start + t_pre)\n", + " i1 = np.searchsorted(eeg_ts, t_start + t_post)\n", + " if i0 < 0 or i1 > eeg_data.shape[1]:\n", + " continue\n", + " ep = eeg_data[:, i0:i1].copy()\n", + " if ep.shape[1] > n_pre:\n", + " ep -= ep[:, :n_pre].mean(axis=1, keepdims=True)\n", + " epochs.append(ep)\n", + "\n", + " if not epochs:\n", + " return np.empty((0, eeg_data.shape[0], 0))\n", + " min_len = min(e.shape[-1] for e in epochs)\n", + " return np.stack([e[:, :min_len] for e in epochs])\n", + "\n", + "\n", + "def load_session_epochs(filepath):\n", + " \"\"\"Full per-session preprocessing pipeline:\n", + " 1. Load XDF, drop non-EEG channels\n", + " 2. Notch at 60 Hz (powerline)\n", + " 3. Common Average Reference\n", + " 4. Bandpass 8–30 Hz (mu + beta — the MI band)\n", + " 5. Epoch on cues, baseline-correct to [-1, 0] s\n", + " 6. Reject epochs with any-channel peak-to-peak > PTP_REJECT_UV (blinks / movement)\n", + " Returns X (n_trials, n_ch, n_samp), y (1=MI, 0=REST), ch_names, sfreq, n_rejected.\n", + " \"\"\"\n", + " eeg, eeg_ts, mk, mk_ts, ch_names, sfreq = load_xdf_file(filepath)\n", + "\n", + " eeg = notch_filter(eeg, NOTCH_FREQ, sfreq)\n", + " if USE_CAR:\n", + " eeg = car(eeg)\n", + " eeg_bp = bandpass(eeg, BP_LO, BP_HI, sfreq)\n", + "\n", + " mi = extract_epochs(eeg_bp, eeg_ts, mk, mk_ts, sfreq, MI_BEGIN)\n", + " rest = extract_epochs(eeg_bp, eeg_ts, mk, mk_ts, sfreq, REST_BEGIN)\n", + "\n", + " n_pre = int(abs(T_PRE) * sfreq)\n", + " if mi.shape[-1] > n_pre: mi = mi[..., n_pre:]\n", + " if rest.shape[-1] > n_pre: rest = rest[..., n_pre:]\n", + "\n", + " n = min(mi.shape[-1], rest.shape[-1]) if (mi.size and rest.size) else 0\n", + " mi, rest = mi[..., :n], rest[..., :n]\n", + "\n", + " n0_mi, n0_rest = len(mi), len(rest)\n", + " mi = mi[reject_by_ptp(mi)]\n", + " rest = rest[reject_by_ptp(rest)]\n", + " n_rejected = (n0_mi - len(mi)) + (n0_rest - len(rest))\n", + "\n", + " X = np.concatenate([mi, rest], axis=0) if (len(mi) or len(rest)) else np.empty((0, len(ch_names), 0))\n", + " y = np.concatenate([np.ones(len(mi), int), np.zeros(len(rest), int)])\n", + " return X, y, ch_names, sfreq, n_rejected\n", + "\n", + "\n", + "# ── CSP + LDA (2-class, numpy/scipy only) ────────────────────────────────────\n", + "\n", + "def _mean_cov(X):\n", + " \"\"\"Average trace-normalized trial covariance. X: (n_trials, n_ch, n_samp).\"\"\"\n", + " covs = np.einsum('ijk,ilk->ijl', X, X)\n", + " covs /= np.trace(covs, axis1=1, axis2=2)[:, None, None]\n", + " return covs.mean(axis=0)\n", + "\n", + "\n", + "class CSPLDA:\n", + " \"\"\"Common Spatial Patterns (log-var features) + Linear Discriminant Analysis.\n", + " Ramoser 2000; Blankertz 2008. Ledoit-Wolf style cov shrinkage so CAR\n", + " (which drops rank by 1) does not break the generalized eigenproblem.\n", + " \"\"\"\n", + "\n", + " def __init__(self, n_csp=N_CSP, cov_shrink=0.05, lda_reg=1e-4):\n", + " self.n_csp = n_csp\n", + " self.cov_shrink = cov_shrink\n", + " self.lda_reg = lda_reg\n", + "\n", + " def fit(self, X, y):\n", + " assert set(np.unique(y)) == {0, 1}, 'CSPLDA requires both classes in training set'\n", + " C1 = _mean_cov(X[y == 1])\n", + " C0 = _mean_cov(X[y == 0])\n", + " n_ch = C1.shape[0]\n", + " s = self.cov_shrink\n", + " C1 = (1 - s) * C1 + s * (np.trace(C1) / n_ch) * np.eye(n_ch)\n", + " C0 = (1 - s) * C0 + s * (np.trace(C0) / n_ch) * np.eye(n_ch)\n", + " evals, evecs = eigh(C1, C0 + C1)\n", + " order = np.argsort(evals)\n", + " k = self.n_csp // 2\n", + " self.filters_ = np.concatenate([evecs[:, order[:k]],\n", + " evecs[:, order[-k:]]], axis=1).T\n", + "\n", + " F = self._features(X)\n", + " mu1, mu0 = F[y == 1].mean(0), F[y == 0].mean(0)\n", + " Sw = np.cov(F[y == 1].T, ddof=1) + np.cov(F[y == 0].T, ddof=1)\n", + " Sw += self.lda_reg * np.eye(Sw.shape[0])\n", + " self.coef_ = np.linalg.solve(Sw, mu1 - mu0)\n", + " self.intercept_ = -self.coef_ @ ((mu1 + mu0) / 2)\n", + " return self\n", + "\n", + " def _features(self, X):\n", + " Z = np.einsum('fc,ncs->nfs', self.filters_, X)\n", + " var = Z.var(axis=-1, ddof=1)\n", + " return np.log(var / var.sum(axis=1, keepdims=True))\n", + "\n", + " def decision_function(self, X):\n", + " return self._features(X) @ self.coef_ + self.intercept_\n", + "\n", + " def predict(self, X):\n", + " return (self.decision_function(X) > 0).astype(int)\n", + "\n", + "\n", + "# ── Evaluation metrics ───────────────────────────────────────────────────────\n", + "\n", + "def evaluate(clf, X, y):\n", + " margin = clf.decision_function(X)\n", + " pred = (margin > 0).astype(int)\n", + " acc = (pred == y).mean()\n", + " amp = np.abs(margin).mean()\n", + " m1, m0 = margin[y == 1], margin[y == 0]\n", + " fisher = (m1.mean() - m0.mean()) ** 2 / (m1.var(ddof=1) + m0.var(ddof=1) + 1e-30)\n", + " return dict(acc=acc, amp=amp, fisher=fisher, margin=margin, y=y, pred=pred)\n", + "\n", + "\n", + "def spectral_snr(X, y, ch_idx, sfreq, band=MU_BAND):\n", + " \"\"\"Ratio of REST mu-power to MI mu-power averaged over selected channels.\"\"\"\n", + " def band_pwr(sig):\n", + " f, p = welch(sig, fs=sfreq,\n", + " nperseg=min(int(sfreq * 2), sig.shape[-1]),\n", + " noverlap=int(sfreq), axis=-1)\n", + " m = (f >= band[0]) & (f < band[1])\n", + " return np.trapezoid(p[..., m], f[m], axis=-1).mean()\n", + "\n", + " return band_pwr(X[y == 0][:, ch_idx, :]) / (band_pwr(X[y == 1][:, ch_idx, :]) + 1e-30)" + ] }, { "cell_type": "markdown", @@ -66,81 +376,571 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "d266216b", - "metadata": {}, - "outputs": [], - "source": "xdf_files = sorted(glob.glob(os.path.join(DATA_DIR, '*.xdf')))\nprint(f'Found {len(xdf_files)} XDF file(s).\\n')\n\n# sessions[subject][session_id] = dict(X, y, kind, stim, ch_names, sfreq, file)\nsessions = {}\n\nfor fp in xdf_files:\n meta = parse_session(fp)\n if meta is None:\n print(f' SKIP (unparsed): {os.path.basename(fp)}')\n continue\n subj, ses_id, kind, stim = meta\n try:\n X, y, ch_names, sfreq = load_session_epochs(fp)\n except Exception as e:\n print(f' ERROR {os.path.basename(fp)}: {e}')\n continue\n\n sessions.setdefault(subj, {})[ses_id] = dict(\n X=X, y=y, kind=kind, stim=stim,\n ch_names=ch_names, sfreq=sfreq, file=os.path.basename(fp))\n\n print(f' {subj}/{ses_id} {kind:<7} {stim:<5} '\n f'n={len(y):3d} (MI={int(y.sum())}, REST={int((1-y).sum())})')\n\nsubjects = sorted(sessions.keys())\nprint(f'\\nLoaded {len(subjects)} subject(s): {subjects}')" + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:51:37.607052Z", + "iopub.status.busy": "2026-04-22T00:51:37.606969Z", + "iopub.status.idle": "2026-04-22T00:52:02.122083Z", + "shell.execute_reply": "2026-04-22T00:52:02.121262Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 18 XDF file(s).\n", + "Preprocessing: notch 60 Hz → CAR → bandpass 8–30 Hz → baseline-correct → PTP-reject @ 100 µV\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 003/S001 OFFLINE FES n= 89 (MI=44, REST=45) rejected=1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 003/S002 ONLINE FES n= 59 (MI=29, REST=30) rejected=1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 003/S003 ONLINE NOFES n= 38 (MI=17, REST=21) rejected=0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 003/S004 OFFLINE NOFES n= 86 (MI=42, REST=44) rejected=4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 003/S005 ONLINE NOFES n= 43 (MI=19, REST=24) rejected=17\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 003/S006 ONLINE FES n= 52 (MI=23, REST=29) rejected=8\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 005/S001 OFFLINE FES n= 90 (MI=45, REST=45) rejected=0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 005/S002 ONLINE FES n= 60 (MI=30, REST=30) rejected=0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 005/S003 ONLINE NOFES n= 59 (MI=29, REST=30) rejected=1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 005/S004 OFFLINE NOFES n= 89 (MI=44, REST=45) rejected=1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 005/S005 ONLINE NOFES n= 58 (MI=28, REST=30) rejected=2\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 005/S006 ONLINE FES n= 59 (MI=30, REST=29) rejected=1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 009/S001 OFFLINE FES n= 57 (MI=33, REST=24) rejected=33\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 009/S002 ONLINE FES n= 42 (MI=21, REST=21) rejected=18\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 009/S003 ONLINE NOFES n= 1 (MI=1, REST=0) rejected=59\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 009/S004 OFFLINE NOFES n= 86 (MI=42, REST=44) rejected=4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 009/S005 ONLINE NOFES n= 60 (MI=30, REST=30) rejected=0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 009/S006 ONLINE FES n= 50 (MI=26, REST=24) rejected=10\n", + "\n", + "Loaded 3 subject(s): ['003', '005', '009'] | total artifact-rejected epochs: 160\n" + ] + } + ], + "source": [ + "xdf_files = sorted(glob.glob(os.path.join(DATA_DIR, '*.xdf')))\n", + "print(f'Found {len(xdf_files)} XDF file(s).')\n", + "print(f'Preprocessing: notch {NOTCH_FREQ:.0f} Hz → '\n", + " f'{\"CAR → \" if USE_CAR else \"\"}bandpass {BP_LO:.0f}–{BP_HI:.0f} Hz → '\n", + " f'baseline-correct → PTP-reject @ {PTP_REJECT_UV:.0f} µV\\n')\n", + "\n", + "# sessions[subject][session_id] = dict(X, y, kind, stim, ch_names, sfreq, file)\n", + "sessions = {}\n", + "total_rej = 0\n", + "\n", + "for fp in xdf_files:\n", + " meta = parse_session(fp)\n", + " if meta is None:\n", + " print(f' SKIP (unparsed): {os.path.basename(fp)}')\n", + " continue\n", + " subj, ses_id, kind, stim = meta\n", + " try:\n", + " X, y, ch_names, sfreq, n_rej = load_session_epochs(fp)\n", + " except Exception as e:\n", + " print(f' ERROR {os.path.basename(fp)}: {e}')\n", + " continue\n", + "\n", + " sessions.setdefault(subj, {})[ses_id] = dict(\n", + " X=X, y=y, kind=kind, stim=stim,\n", + " ch_names=ch_names, sfreq=sfreq, file=os.path.basename(fp))\n", + " total_rej += n_rej\n", + "\n", + " print(f' {subj}/{ses_id} {kind:<7} {stim:<5} '\n", + " f'n={len(y):3d} (MI={int(y.sum())}, REST={int((1-y).sum())}) '\n", + " f'rejected={n_rej}')\n", + "\n", + "subjects = sorted(sessions.keys())\n", + "print(f'\\nLoaded {len(subjects)} subject(s): {subjects} | '\n", + " f'total artifact-rejected epochs: {total_rej}')" + ] }, { "cell_type": "markdown", "id": "7b8c8bea", "metadata": {}, - "source": "## Verify Session Layout" + "source": [ + "## Verify Session Layout" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "611baf23", - "metadata": {}, - "outputs": [], - "source": "# Verify channel layout is consistent across sessions, locate motor channels\nref_subj = subjects[0]\nref_ses = next(iter(sessions[ref_subj].values()))\nchannel_names_global = ref_ses['ch_names']\nsfreq_global = ref_ses['sfreq']\n\nmismatches = [f'{subj}/{sid}' for subj in subjects for sid, s in sessions[subj].items()\n if s['ch_names'] != channel_names_global]\nif mismatches:\n print('!! channel mismatch in:', mismatches)\n\nmotor_idx_global = [channel_names_global.index(c) for c in MOTOR_CH\n if c in channel_names_global]\n\nprint(f'Channels ({len(channel_names_global)}): {channel_names_global}')\nprint(f'Sampling rate: {sfreq_global} Hz')\nprint(f'Motor channels {MOTOR_CH} → indices {motor_idx_global}')" + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:52:02.124753Z", + "iopub.status.busy": "2026-04-22T00:52:02.124540Z", + "iopub.status.idle": "2026-04-22T00:52:02.130065Z", + "shell.execute_reply": "2026-04-22T00:52:02.129699Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channels (32): ['Fp1', 'Fpz', 'Fp2', 'F7', 'F3', 'Fz', 'F4', 'F8', 'FC5', 'FC1', 'FC2', 'FC6', 'M1', 'T7', 'C3', 'Cz', 'C4', 'T8', 'M2', 'CP5', 'CP1', 'CP2', 'CP6', 'P7', 'P3', 'Pz', 'P4', 'P8', 'POz', 'O1', 'Oz', 'O2']\n", + "Sampling rate: 512.0 Hz\n", + "Motor channels ['C3', 'Cz', 'C4'] → indices [14, 15, 16]\n" + ] + } + ], + "source": [ + "# Verify channel layout is consistent across sessions, locate motor channels\n", + "ref_subj = subjects[0]\n", + "ref_ses = next(iter(sessions[ref_subj].values()))\n", + "channel_names_global = ref_ses['ch_names']\n", + "sfreq_global = ref_ses['sfreq']\n", + "\n", + "mismatches = [f'{subj}/{sid}' for subj in subjects for sid, s in sessions[subj].items()\n", + " if s['ch_names'] != channel_names_global]\n", + "if mismatches:\n", + " print('!! channel mismatch in:', mismatches)\n", + "\n", + "motor_idx_global = [channel_names_global.index(c) for c in MOTOR_CH\n", + " if c in channel_names_global]\n", + "\n", + "print(f'Channels ({len(channel_names_global)}): {channel_names_global}')\n", + "print(f'Sampling rate: {sfreq_global} Hz')\n", + "print(f'Motor channels {MOTOR_CH} → indices {motor_idx_global}')" + ] }, { "cell_type": "markdown", "id": "70922abb", "metadata": {}, - "source": "## Train CSP + LDA on OFFLINE, Evaluate on ONLINE" + "source": [ + "## Train CSP + LDA on OFFLINE, Evaluate on ONLINE" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "f5e80da3", - "metadata": {}, - "outputs": [], - "source": "results = [] # one row per (subject, pair, condition)\n\nfor subj in subjects:\n subj_ses = sessions[subj]\n\n for pair in PAIRS:\n needed = (pair['train'], pair['online_fes'], pair['online_nofes'])\n missing = [k for k in needed if k not in subj_ses]\n if missing:\n print(f'[{subj}] {pair[\"name\"]}: missing {missing} — skipping')\n continue\n\n train = subj_ses[pair['train']]\n clf = CSPLDA(n_csp=N_CSP).fit(train['X'], train['y'])\n train_acc = (clf.predict(train['X']) == train['y']).mean()\n\n for cond_key, cond_label in [('online_fes', 'FES'), ('online_nofes', 'NOFES')]:\n te = subj_ses[pair[cond_key]]\n res = evaluate(clf, te['X'], te['y'])\n snr_s = spectral_snr(te['X'], te['y'], motor_idx_global, te['sfreq'])\n\n results.append(dict(\n subject=subj, pair=pair['name'], condition=cond_label,\n train_file=train['file'], test_file=te['file'],\n train_acc=train_acc, n_test=len(te['y']),\n acc=res['acc'], amp=res['amp'], fisher=res['fisher'], mu_snr=snr_s,\n margin=res['margin'], y_test=res['y'], pred=res['pred'],\n ))\n\n# Results table\nhdr = f'{\"Subj\":<5} {\"Pair\":<28} {\"Cond\":<6} {\"n\":>4} {\"trainAcc\":>9} {\"acc\":>7} {\"|marg|\":>8} {\"Fisher\":>8} {\"muSNR\":>8}'\nprint('\\n' + hdr)\nprint('-' * len(hdr))\nfor r in results:\n print(f'{r[\"subject\"]:<5} {r[\"pair\"]:<28} {r[\"condition\"]:<6} {r[\"n_test\"]:>4} '\n f'{r[\"train_acc\"]:>9.3f} {r[\"acc\"]:>7.3f} {r[\"amp\"]:>8.3f} '\n f'{r[\"fisher\"]:>8.3f} {r[\"mu_snr\"]:>8.3f}')" + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:52:02.135245Z", + "iopub.status.busy": "2026-04-22T00:52:02.135163Z", + "iopub.status.idle": "2026-04-22T00:52:03.802461Z", + "shell.execute_reply": "2026-04-22T00:52:03.802016Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[009] Pair1 (train=OFFLINE_FES) / NOFES: only 1 surviving epochs — dropping (likely electrode/noise issue)\n", + "\n", + "Subj Pair Cond n trainAcc acc |marg| Fisher muSNR\n", + "-------------------------------------------------------------------------------------------\n", + "003 Pair1 (train=OFFLINE_FES) FES 59 0.843 0.542 0.879 0.017 1.347\n", + "003 Pair1 (train=OFFLINE_FES) NOFES 38 0.843 0.737 0.910 0.683 1.219\n", + "003 Pair2 (train=OFFLINE_NOFES) FES 52 0.907 0.538 1.166 0.000 1.273\n", + "003 Pair2 (train=OFFLINE_NOFES) NOFES 43 0.907 0.605 1.071 0.029 1.296\n", + "005 Pair1 (train=OFFLINE_FES) FES 60 0.978 0.817 3.346 2.498 2.695\n", + "005 Pair1 (train=OFFLINE_FES) NOFES 59 0.978 0.932 3.620 3.029 2.399\n", + "005 Pair2 (train=OFFLINE_NOFES) FES 59 1.000 0.949 5.740 6.291 2.911\n", + "005 Pair2 (train=OFFLINE_NOFES) NOFES 58 1.000 0.897 5.261 4.325 2.287\n", + "009 Pair1 (train=OFFLINE_FES) FES 42 0.667 0.571 0.304 0.040 1.326\n", + "009 Pair2 (train=OFFLINE_NOFES) FES 50 1.000 0.520 4.673 6.192 1.594\n", + "009 Pair2 (train=OFFLINE_NOFES) NOFES 60 1.000 0.917 3.754 8.959 2.000\n" + ] + } + ], + "source": [ + "MIN_TEST_TRIALS = 10 # skip test sessions too badly corrupted to evaluate\n", + "\n", + "results = [] # one row per (subject, pair, condition)\n", + "\n", + "for subj in subjects:\n", + " subj_ses = sessions[subj]\n", + "\n", + " for pair in PAIRS:\n", + " needed = (pair['train'], pair['online_fes'], pair['online_nofes'])\n", + " missing = [k for k in needed if k not in subj_ses]\n", + " if missing:\n", + " print(f'[{subj}] {pair[\"name\"]}: missing {missing} — skipping')\n", + " continue\n", + "\n", + " train = subj_ses[pair['train']]\n", + " if set(np.unique(train['y'])) != {0, 1}:\n", + " print(f'[{subj}] {pair[\"name\"]}: training set lacks both classes — skipping')\n", + " continue\n", + " clf = CSPLDA(n_csp=N_CSP).fit(train['X'], train['y'])\n", + " train_acc = (clf.predict(train['X']) == train['y']).mean()\n", + "\n", + " for cond_key, cond_label in [('online_fes', 'FES'), ('online_nofes', 'NOFES')]:\n", + " te = subj_ses[pair[cond_key]]\n", + " if len(te['y']) < MIN_TEST_TRIALS or set(np.unique(te['y'])) != {0, 1}:\n", + " print(f'[{subj}] {pair[\"name\"]} / {cond_label}: only {len(te[\"y\"])} '\n", + " f'surviving epochs — dropping (likely electrode/noise issue)')\n", + " continue\n", + " res = evaluate(clf, te['X'], te['y'])\n", + " snr_s = spectral_snr(te['X'], te['y'], motor_idx_global, te['sfreq'])\n", + "\n", + " results.append(dict(\n", + " subject=subj, pair=pair['name'], condition=cond_label,\n", + " train_file=train['file'], test_file=te['file'],\n", + " train_acc=train_acc, n_test=len(te['y']),\n", + " acc=res['acc'], amp=res['amp'], fisher=res['fisher'], mu_snr=snr_s,\n", + " margin=res['margin'], y_test=res['y'], pred=res['pred'],\n", + " ))\n", + "\n", + "# Results table\n", + "hdr = f'{\"Subj\":<5} {\"Pair\":<28} {\"Cond\":<6} {\"n\":>4} {\"trainAcc\":>9} {\"acc\":>7} {\"|marg|\":>8} {\"Fisher\":>8} {\"muSNR\":>8}'\n", + "print('\\n' + hdr)\n", + "print('-' * len(hdr))\n", + "for r in results:\n", + " print(f'{r[\"subject\"]:<5} {r[\"pair\"]:<28} {r[\"condition\"]:<6} {r[\"n_test\"]:>4} '\n", + " f'{r[\"train_acc\"]:>9.3f} {r[\"acc\"]:>7.3f} {r[\"amp\"]:>8.3f} '\n", + " f'{r[\"fisher\"]:>8.3f} {r[\"mu_snr\"]:>8.3f}')" + ] }, { "cell_type": "markdown", "id": "2ab81600", "metadata": {}, - "source": "---\n## Figure 1 — Per-metric comparison (FES vs NOFES)" + "source": [ + "---\n", + "## Figure 1 — Per-metric comparison (FES vs NOFES)" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "d53e63b9", - "metadata": {}, - "outputs": [], - "source": "METRICS = [\n ('acc', 'Classification accuracy', '0–1'),\n ('amp', 'Classification amplitude (mean |decision fn|)', 'a.u.'),\n ('fisher', 'Fisher ratio on LDA projection (test-set SNR)', 'a.u.'),\n ('mu_snr', 'μ-band power ratio REST / MI @ C3/Cz/C4', 'ratio'),\n]\n\ncond_color = {'FES': '#E05C2A', 'NOFES': '#2A7BE0'}\n\nfig, axes = plt.subplots(2, 2, figsize=(14, 9))\nfig.suptitle('Online decoding: FES vs NOFES feedback (per subject × offline-trained model)',\n fontsize=13, fontweight='bold', y=1.00)\n\nfor ax, (key, title, unit) in zip(axes.ravel(), METRICS):\n labels, vals, colors = [], [], []\n for subj in subjects:\n for pair in PAIRS:\n tag = pair['name'].split()[0] # \"Pair1\" / \"Pair2\"\n for cond in ('FES', 'NOFES'):\n row = next((r for r in results\n if r['subject']==subj and r['pair']==pair['name']\n and r['condition']==cond), None)\n if row is None: continue\n labels.append(f'{subj}\\n{tag}\\n{cond}')\n vals.append(row[key])\n colors.append(cond_color[cond])\n x = np.arange(len(vals))\n ax.bar(x, vals, color=colors, edgecolor='white', zorder=2)\n ax.set_xticks(x); ax.set_xticklabels(labels, fontsize=7.5)\n ax.set_title(f'{title} ({unit})', fontsize=11, fontweight='bold')\n ax.grid(axis='y', alpha=0.3)\n ax.spines[['top','right']].set_visible(False)\n if key == 'acc':\n ax.axhline(0.5, color='gray', linestyle='--', lw=0.8, alpha=0.6)\n\nfig.legend(handles=[Patch(color=cond_color['FES'], label='ONLINE_FES'),\n Patch(color=cond_color['NOFES'], label='ONLINE_NOFES')],\n loc='upper right', ncol=2, bbox_to_anchor=(0.98, 1.0))\nplt.tight_layout()\nplt.savefig('fes_vs_nofes_metrics.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('Saved: fes_vs_nofes_metrics.png')" + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:52:03.805180Z", + "iopub.status.busy": "2026-04-22T00:52:03.805014Z", + "iopub.status.idle": "2026-04-22T00:52:04.240793Z", + "shell.execute_reply": "2026-04-22T00:52:04.240314Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABoAAAAQ8CAYAAACyzFyVAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAASdAAAEnQB3mYfeAABAABJREFUeJzs3Qn8ZWP9OPDnOyuDGWOYhZmxNHaSQiI1yhKJKUuLLdtPJqKUktAUCSllaRFR/EqipkU7bRLabBEKY5kMgxmD2e//9Tn9z/d3vvd773dfz32/X6879zv33OWc5zznOec8n2dpqlQqlQQAAAAAAEBpDOnvFQAAAAAAAKBnCQABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAAEAAAAAAJSMABAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAAH0sxtvvDG9973vTZtuumkaM2ZMGjlyZJo0aVKaPn16Ouuss9K8efN65XcfeeSR1NTU1PyIdSiK/xeXx/sHu09+8pMttuk3v/lNKqMNNtigeRvj76Irr7yyRRrE/8uiOs+29aje7jjeOvrZWvnmySefTB/72MfSq1/96uw4Hj58eFp77bXTJptsknbfffd08sknp2uvvTaV5diJxw033NDqfZE2bZUrRQsXLkwXXnhhestb3pImT56cVl111bTGGmukV7ziFeld73pX+s53vpNWrFjRoXze3qO6/Oro5+JRy1/+8pd05JFHZvt3tdVWS6usskpWbm+11Vbp7W9/ezrzzDPTLbfckjqrUqmkSy65JL32ta9No0ePTkOGDGlejx/84AdpoKo+ftrKE5GXBqr+Lh8jn0Zeit+Oa4HHH3+8T3+/bLq7P9s6l9J7HnjggXTIIYekKVOmpBEjRjTvg1e96lXN71myZEn6zGc+k70WZXBxP//9739vyGvc/jBYr6sb7djurfze1v5/6aWX0jrrrNO87NZbb+2R3wSga4Z18XMAdNNjjz2WVXL+8Y9/bLXsP//5T/b47W9/m93gnnfeeen444+X5jAA/e53v0tve9vbsoBG0fz587PHgw8+mH71q1+lCRMmpHe+852pLM4444w0Y8aMLEjRWd/73vfS//zP/6Tnnnuu1bJFixalf//731nA7FOf+lT67ne/mwVWBorPf/7z6SMf+UhauXJlzXL73nvvzYI1//znP9POO+/c6TSNwD+N6ZRTTskqtsPhhx+eBUYhD7LGNWExWFxG0ejpda97XXr22WfbfN/RRx+drr766tSIImDx6KOPZn+vv/76glcMSKNGjUof+tCH0sc//vHs/x/84AezIFC9hjUA9C4BIIB+8MQTT2QtvOfOnft/BfKwYdlra665ZrrzzjubW/6+/PLL6YQTTkjPPPNMn7ac3n777bOK2Fy0sKQcFQf7779/i/+X1eabb5622GKLmsva2+7tttsuq1ipJVo05l588cUsqFMM/my88cZp2rRpWWAkjuN//OMfadmyZalsItDx7W9/Ox188MGd+twVV1yRjjrqqBavRW+pKHMWL16cVRDEc7jvvvuyysAIlG+99dZtfu8b3vCGFvumqL3ya6+99soqK9rz5z//OX34wx9urnyNfRy9vqL3T1Tc/+tf/8qCV12tnL3sssta/P+Nb3xjljZhvfXW69J3Mjjcfvvt6brrrsv+jgqyCAbRv/bee+/mXtjjx4+3O/pA9CwtBn+ibN1hhx2ya+QNN9yw+bwb555cLNt1112zXpMhrqPb4xq3Z8Q1VvGast45mMYUjRfPPvvs7Ji97bbbssY/Bx54YH+vFkBDEgAC6AeHHnpoi+DPZpttln70ox9llcYhWpZ/9rOfTaeddlrze6IlfNzgRoVgX3j/+9+fPShfK+J4NIKDDjqoy0HTyPttDV+W+9nPfpb1+sh97nOfy4Z7K4ob31/84hfpxz/+cSqbSN8IgEUFXEdEb6jjjjuuVVpHr5oY6ic89dRTWYVSPoRaBKIPOOCALODU1u/MmjWry3n70ksv7VAw9KqrrmoO7kQlfVRoRLCwKPLD7Nmzs95fnRXbnttxxx0HzXA6dN8Xv/jF5r932mmn5usB+k+UC2V0xx13ZK3yI+BYL1gyZ86cdNhhh2UB+4022qjP1q1YBoZvfOMbac8992zxWjSIKg4PGueHYkAotDfElWvcnrvOigfUEsP6Rk/xa665pvk8JwAE0D/MAQTQx37/+9+nm2++ufn/Q4cOTddff32Lyp5oVR435+9+97ubX4tKxwgCtTem809/+tNszpG4qY8W7dFy8vvf/36Pjhdda2z1GMopWizH/B35PEYxxFNblaA///nPs8rjqHiN+T9WX331bKin+J6YU6UrohV+tDaLOZViLoVoNX/ssce2qlSo54UXXsgqo/OW91EpPW7cuPTmN785q4hYvnx53c9G6//oHfCa17wmjR07NvvsxIkTs2GgYminWr1AIvAXld1Tp07N1jfSINb9mGOOSX/729/arEiP/BGtLSPtttlmm6yyqr2eB+3NiVA9Lnpsb8xJEr0cIj9Fvtpnn33SXXfdVfP7I3j5la98JRuXP9Yr0vAd73hHuvvuu9v97erlA3mukOJ+KHrTm95Us/dJzAtz+eWXd/h7Y+jHYlrEcV0t8kfxPTNnzmxeFr1QoudgHE9xAx5zEkVe2XLLLbOhJ7/whS+k559/PnXXQw891Kl5NSKwvXTp0hYV3RdddFFz8CfEUHlRZuWtufM5Iaor+Pp7f8dcT3GsV4tjPsqcfNiTjsiPu6I//elPdefV6U45FT3SovIz8kLkjSiv4/djyLG//vWvdT8XjRaiTF933XWzsioaLkRZW9yfHRVBskijGOIsfj/OfzFvUswZUC2G04ugYfQEi155eX6O7X7961+fHStt5eVYFoHZaEARvTgirdZaa630yle+MjtGOjoXQvRK22OPPVrsk1ivnhiK6+mnn85aRufe8573tHpPrfNu9JSIYXVi/0U6xnnkxBNPbHP4rK6cd4u/G0HW6PEYwyDG+T7Ss6OB18i3kWciuBn7IPZjnFNi/7/1rW/NgrgxdGJbv93duTziGI70jXIm8nFse5SHtY6Zjnx3V4+nyDfRKCD2RQRY4jwR59i8l24EkYvXYsXh36rTpTM9ee+///7sGjGGJd1tt91qDsMZw4tF2RK/Gc+RP7uiM9c3+fm/+rwfc8QVrwlqbW/MF9fZtBiM17j5XGv58G8h/q53jFTn3/z6OHrtxPrkaRXl7jnnnJMFcmL94hwW25jnx7iGq3cf0d4cQNXrFqMa5OsQeSLK8biWbascjnNh7IPoXR3HSax7zL8X1zzV12A9cZ3cnuptivI2ziVxvxG/E9e/3/rWt5rf/5Of/CTtsssu2f6P8i6GDL7nnnvqfn/MYRV5K86x8ZlIp5gPK/ZDXi7UsmDBgqxczs8H8Rz/j3K3I+I4jzI4yuf8HibKybjmrzXnY0cVz2fRsKfe/QMAvawCQJ/64Ac/GHcezY8999yz7nv/+Mc/tnjv0KFDK88//3zz8sMPP7zF8ve85z0t/l98fPvb327x3Q8//HCL5fFdRdXfHe+v99nXv/71lalTp9b83W222aayZMmSFt8d/z/ooIPqrms81lxzzcqvfvWrTqXt4sWLK2984xtrft/EiRNbpc/NN9/c4vN/+9vfKuuvv36b67XLLrtUnnvuuVa//aUvfakyYsSINj9b/NxLL71Uedvb3tbm+4cMGVKZNWtWq9+6/fbbK6NHj675mQMPPLAyefLk5v/H9hR94xvfaPH++H9RcfsnTJhQefOb31zzd9ZYY43Kgw8+2GrdDj300JrvHzlyZOWQQw5p87er1+3MM8/sxN5vnWc78/nqfFO9bvVccMEFLT736le/uvK9732v8swzz1S644knnsiO9/x7I+2qnXzyyS1++y9/+Uv2+j/+8Y/KmDFj2sxb8bjjjjs6vD6RltXHQf73lClTsmMvxDFVr1xZuXJlZdy4cW2WS0X/8z//0+K9+++/f4vl1cdq9fHcluq0KJZvbak+ZuN4u+mmm7LjuTvaK3fi0RPl1Pnnn98iX9Uqc84777xWn/vXv/5VWXfddWt+Jsr/7bffvua61soTUQ5HeVzru3bcccfKokWLWny+XhlUfEQefOSRR1qt929/+9usHGvrs9///vfbLR8jf8e5urjswx/+cKWnVP/uP//5z1bvqT7v7rrrrnXzwcYbb1z5z3/+02Pn3epz+pZbbtnitSg/2/Pyyy9XXvnKV7a7LyOP1vvtWr9TTIP2zndRpqy++uo1f3fGjBmVFStWdPi7u3M8LViwoFV+qn7st99+Nc9rtR611q2eZcuWZeVW8Zw1f/78FvmsuN1xnumsrlzfVO+rWo/q81BbaVHGa9x617f1jpHifpw0aVJWZtRKq8cee6zd743HYYcdlp3Hi6r3SfV5uLgsyo1Ir1rfvd5667XIhyF+66STTmpznVZZZZXKNddc06PXye0pftcWW2xRecUrXlHzd+L6sPoaMX/EusV5tVocE3FstLXNcWxVX3NE2lWXy/ljs802q+y9995183uIvFh9fVb9iGuw6rze3v4PcU4vlpOf/OQnO5XeAPQMASCAPvaGN7yhxcVyrQr+3NKlSyvDhw+ve3Fdq2Igbiqiwqz6ZnWjjTZq8d09eXNcvLmLm89hw4a1eP2b3/xmi+8++uijWywfP358Za+99soqLYs3CRFk+Pe//93htP3EJz7R4nvjJuq1r31tZeedd261TtVpGRX21ZWSUVm1zz77ZJVpxdfjtaKoxK7+7nXWWSfbD3vssUdl7bXXzl4rVshWB0NWXXXVLO222267SlNTU4tll19+efPn4uYr9mVx+VprrVXZfffda96EdicAVLwxj++vDioceeSRLT57xRVXtPps3OzHdsVNevWy3g4Abb755tkNa/UjKjHaq1iJ/VDrs9WVvrfddlvdm+VIy3e9613Z/osKv85661vf2vxdUWn54osvNi+LisrYL/nyV73qVc3LjjnmmFbH5b777psdXxtuuGFz/upOAOjrX/96ZZNNNmn+/xe/+MV2A0BxLFen0aOPPlr3N6+88so283J1Xo2ytdY+O/fcc1t9d/V6RPlT67PVeTS+q9a+jnJrq622qhx77LGVH/3oR1kla2ccd9xx2e8VvzPKjeK6dLecuvrqq1uVOW9605uyiujqirIIYhZFBWhxeeTH+Gxsc630KKrOE3l6RbBnp512alU2R4VfUZSjEUCOPB6/GRXju+22W1bGVleKFT3wwAPZOaT4nlGjRmW/G2mTl6PtBYAi+BP5o/h6T1dgFcuusWPHtqpkbeu8GxX406dPb1XGRkCjp867tX43zjuxH+LzcZ5rT1TSFj8fAcUo4+I7ooIyb0DRmwGgeEReirIiyvjqZRdeeGGHv7s7x1Ot4E+cryI94polrvvyANDFF1+cHf/5dUT+KJYNUX50xvLlyyvvfOc7m79r2223zSqQY78Xt/mUU06pdEVXrm+inIhtiXSoV65fe+212XP18RjrXJ0WZbzGPeOMM7JtjHKsWKYV80K8p63rufjN2IbIqxG8KAaAYj0j/73lLW/Jrhni7+qGTddff32XA0D5I65Vo1yPfFF8/VOf+lSLz5511lktlsc1aJQ1+Tkhfz32x5/+9Kceu05uT71yOM5n1WVN3IdE2RzBt+I1WzyOOuqoFt8b11XF5XGsxDET5Xt1WkVjq7aOuWI5V33MVef3+++/v7Laaqu1+N0ddtghK4+icUXxc8cff3yn9n+uGPiL7QGg7wkAAfSx6pvbr371q22+v7qyL26A693ARuVu3MiFqCyubg3W1g1ud2+O40atXsVt8bvvu+++FjcjcZNZbFF26623tlgeldkdEZV00aKy+Ls/+MEPWrRuq74JKt6onHrqqS2Wfec732leFpVxUalQXH7LLbc0V8QXWxLGY+bMmVlr51xUBkeQKK/Av+eee1q8Pyr8otdGLn67uDzyQFTY1FoWlfDz5s1rXpfq/dbdAFBUlOa9O6JCtVgZUP3d1Xm72PL5r3/9a6sKyt4OANV7RCVCV1rWxiNuYqsVK9LqPSJvxs19Z9xwww11e8tEr5Pisosuuqh5WVRy5K9H5Wq1uXPnZsG6vKzoiOqb/NhXxcBn9LKI/N1WAKhWsKy6NWnRz372sxbvjQqQzvaaiUdekVrUkc/F48QTT2zxuQjkFQNf9R4RjImyrLPaq+zuTjlVrHyKyrEnn3yy+bNRhhQremL9c1GxVvzOqIh+6KGHmpeffvrprba/qDpPRDkc+zb3y1/+skXZHPu52NM1ysZieVpsIBHB/fxzUbH6wgsvNC+v7vEZQaziNue9bO+66666ZVCcn4uB2HhEi+6eVgykRSViLbXOu8XrhzvvvLNFJV6xJ1F3z7vVvxsVxAsXLmxe3tZxnDv77LNbVEJXt2CPVuKzZ8+u/OEPf+i1AFBUlkcPulwEH4rL4xgpBt/qfXd3jqdf/OIXrdapeDzkn4/yv61zVHfFNcW73/3uFoHkYsOhj3/841363u5c33S0Qrm969eOvGewXeN2pmdarffF4zWveU12/s/l6xXla3EfFcXrxe+Ink3dCQBFL7y8p91vfvObusf3s88+2yLQFQGJYpkTPdCLAf647sl19zq5PdXb9OlPf7p5WTT6KS6LAFCcZ8JTTz3V4jp4gw02aP5cHAPV93vFa77IV8V7nMhDcazV6jEe1+nRA6peOVed34vlQATTimVw3L/EfUBxebHhTkcDQMXzcTQgAaDvdWzGXgD6TWfGqv7oRz+azakQYuzumI8kJk4vzuHQmbHiOyp+M347F+NbF8Xv5mLM++I2xZjT1fMdxLjTMVZ5PnZ2R/zlL39pMQ/Ea1/72rTffvs1/z/mxojx7n/5y1/W/PwPf/jD5r9jXoKYHDkexTkrimK9Yv6SGOP/8ccfb349xoePSU6Lk9XH3zHvSvGzRUcffXTafPPNm/8fY8bHnBV//vOfm387fmf77bdPv/71r1t8NuZ/iPHN87mjYj6MmKi+p8R6xFjiIcZfj/H7Yz6f6v0a49nfd999zf+PMeRj3XLbbrtttp9jQul6Yoz3eAw2V199dTb/Q8wjUWs+hRB5M/Zz7Kt99923Q98b467HnCXz5s3L/h+T6Ob5KJ9QN8T48Iccckjz/2O+heJk32eddVY29n3sv8ifsW+OOOKI1F2RTyO/RX6IObZiLp847npKT8yt0tNiXqIYw/7kk0/O5iSqNa9XPvdATFwe5W9eJveE7pRTTzzxRPPrUVbEnAX10jvWPx6RZ6rLnKOOOirLR7mY6yjKvJgXpiOiHC5O6h7/L5bNMUfEH//4x7TXXntl/99www2z+bNiLqCYbyXm3MjPD0UxKXysc5Q1MRdZzD9S9M1vfjObt6Mo5hVqy2mnnZZNOJ+n2Ze//OVsboaeVtxvMZdTR8S+Ka5LzGkUZexll13W/Frsu5groyfPu3E+++pXv5rNd1P8bHuK5VLMSRFzU8S8GLF+8Yi5PTpaNnbVwQcfnM3PkTvyyCPTueeem80xFuIYiTlyiufjWrpzPFXP4RHpUDweQpwnYt643hTzT8Y8JfEc57DivBynn356qzknO6o71zcDVV9d48Y8aMVr9lxcB8TcNd31pS99KTv/F9cjv4aIv+OaLeZ9evjhh7NjNMrUanF8dFXMjxPHWxwvIeaXinIkn6OmmI5RdhXnhIv0qr5uKV5nx9xD8f649+mJ6+SYEyyu5xYtWtTqWiTmSyqeh6PcinkXQ8z9FddbuZhDJx758gsvvLD5OjHWJX89zmsxf1su5kiLOVzz5bF/4vq5OEdazP8UaRrPcZ2Xi/mC4jySfzbmKbr44otbzAUUf8fy2LaYyzDOH/n2xP6PR/FaNOYyzUV5mc+ZFp8tpkfkpfx3i6I823rrrVt8R3H/AZRJU1NTNodbzKc2kMq6gbMmAA0iJjwtqq6wK4rKxerJnPObmFq22267Fv+PScqLalWa9YSoUCme3Nr63eJNRbj11lvb/O4ILMQk4+1VMD322GMt/h8TzFaLyW3rBYCK6xXpfv3117f5e/mEtdXbExWK7Z3oqye7jfWqta55BUn+maggaW87Y4L2uNioF4jojLgxj4BPUXHfFid/r16vqPCpTofizV9fiMqU6gmlO+ob3/hGh4NRsZ1RYRYVeVEJERUoESSIiYurAwQRJOpoJWfciB922GFZZVk+oXRUEsQFZTF/xsTAMbFwsbIjggJRIR+TAse6FW/OIyAQk3AXg5Jdvbj99Kc/nWbMmJH9/7zzzsvSraNlX17+FSuGiyKo1NGyL9x8880dnoy+WhzHHQ2Ox3ZE5dEFF1yQTaT++9//PnvkgdFcpH8ELiIf9pSeKqceeuih7NHeZ6PCur0yJ/JUBISqJ3Wvp155Vyyb89988cUXsyBBR787D0LFcVKs7IoK3AgkdVYe/AlxzPRG8CcUGy9EkLE76ViUp2NPnnfjOKl3zLZl//33zyp/88nPL7nkkuyRV4RGBWRM2B6BlKjU7A210iyC93kAKE+z9gJA3Tmeqj8b+bu/RPAnArjf/e53m8/nEWyoDmZ1RneubwaqvrrGjWuHeFRbf/31U3fF99cLeN90001ZJX8E39vT0UB/LXGeKF6r5GmZl9VtpeOdd96ZPeqJ82EEZTtyzmrvOjmCItGwK9IjjpHqa9losJCL5fEo7qvitU6cH4t23HHHmg1H4nq7+L15w6uizTbbLAvuVL8njtniZ2uVn1HOFK/Z8/WKbY1AXGcUv3+jjTZq0bCi2DCgKMrU4jVWHgQEKKNly5Zl9xDRMCGumeOeeSAQAALoYxGkicrCXLR0ridukIs3CnGTEa2b66luOVy8KelNnfndrrTqj5NnR1oYF3X2RNvZ9YqKya58rqf15gVFtECs1tE8VWu9yn7DFzfUb3nLW7JHXlFyxhlnZL0jutp6Nnpb5AGgKAsisBOtSYsVxvGe6grNaM0dLT4jaBQ9s/LWmosXL84qe+IRlR/HHXdct7Y5etlFxV30NIpgdQRF6okK+CgronK+WP7Vq0yuLhurA9z9LSp5IoiWB9KiEjN6FEQgqidaS/d3OZV/tlpf3sREgKAY/ImgaPQyiwqvWI84R0br51y+nb1RLkcwL3pq9EbPjKgUzYNN3alg7YvzbnUvqs5UGkZQPHpRRW+uv//97815LHpsxf/jEb15r7322prfkZdjRdHDoq9153jq72uGojg3RE/xYsVw9DiNQHqcI+Jcw8C8xu2s2Jf1yu7jjz++RfAn3hv3GtErLxQbGnQn/9bq3VgvLfvznBUBqUiPCE5FeVf9+WLDvOhxFEGQXJTjxfWI6+gIOOWiB0/xvi7/bHxn9DYqBlKqG6VUf3c0FoiAU/ScKvZIjOBW8TdDBKiLx3lcd0UAKdaleD3ZEbFu+XVbBDCLeSd+t1YQaM6cOS3eF9eDfXWPCtDXKpVKVjZHQ8w4p3S0cVdvK3dNDMAAVByWLMRQBfUqCaMCt+gNb3hDq9Zzg031DU0MPfL/56Sr++jINhdbxYUYKqharaE1aq1X9LCIivK21ikqsEJ1q/Jo7Vmrkqqt1px5i+i21jX/THvbGRcbPdH7p7OqK/HjJjcq9YqKQ8yURdyQ19vfcbEXPWSKogK7M6LFZ/TYycXQb8Xh36LyYNddd231ucgv559/fpbmcdMdrWmjEme99dZrMRxMTzj77LOb//7d735X931RiVI9dE7eA6BWulZXAleXnf2hOERNrTKkOOxhV/Z3e7paTlWXuzEsU3vlbt6zq70yJ9bhX//6V4e3oVY5XP1a/pt/+MMfWrwePeuiAUXk5e9973vZ8VEvOFeshIrW3NUtyjsiAqSRziGO8wj2/exnP0s9rVjRXgyQtqUj57g8HXvyvNudQH5UKH/4wx/O9mvcEEcPwAg0xLVNLnqjFHv/FY+h6rSJocOKw0R1Je9Vp2N1fq+lO8dT9TVDsUFQW3o68BppEYGevBd6nKvyHm6RJrGsrfKuN65vyqA7x1r0IK61vLpXVVfyQr3jNgIPxeF7I/ATlfU//elPszK2+j6kv9IxhjhrLx3z4R27e52cB+HzhgZ9oToAWKs3Vpxri/IeQNWfrX5fvddC9G4q5o34zmhs09ajKz1Ai9fJ8XuCP0CZNTU1ZeeQ3mrY1VUCQAB9LLraFys74qI4hkYpjpkcNzIxVMr//u//tvhs9CYY7N761re2uKGKIbpqVczFDWkMnfSVr3ylQ98b41AXh+WIlsYxFnsuWuXXG/4txPAXuWiF96EPfajVkHnRei56VEQlYD7vT/xusVI9KkJPOumkFjdbEQiJnht5RdXee+/dqmV5cVzveG/0qChWDsbvhGitWxTjiectx+N3PvGJT6T+EK0ki8NsRGvE4pj10Yq/GLio5corr8zyRv7o6vBtfSkqg6dNm5YFW4pzQeWqh+hqb2ihWoo9fKICvDi3SfQ4qa6g+P73v5898vwWN/hRmRI9F4otVasrlbpq9913b1GmteVjH/tYiwrdqAiOce+LLWKjBXoMaxetpnKRxtXzKPSHGE4vAnIxd0ZxiLH8+MsDLt3Z323pTjlVnPshjsVf/OIXrb4/Kt6jzP3ABz7Q/Fp1mRPlVbHMjnNVZ25uohwulsURACj+Px+mMFQHV/MW6fncGTEEXy1RwRTnmqIYTrG6Qjt6EFUP3VcUczDEsZRXsEXaRt4s9vLqCXn5nldWdqT1e5wzYl8UK9qry9h83/XWebczondPzE+Uz2kW6xPntghgVw+DViybij2OYqi2PGAS5733v//9nVqHSJ9iQ4Q45xTPvdF6vV5Qsag7x1P1EKBx7ojjtbpSvrosqR7Wqdjiv7Miz0e65/si5vCIa4dY1/e9733Za9EwKYJAnf2d7lzflEFfHGvFvFBvTrSOqi5jo6zLhzyL8q4491Ffink7i8OnxbVuraFAo6yIXtLFOau6e50c1yORBn05b0Oc24rXRtHTp9jTKO4pikOShvyep7rHTQS3ij2F4nP1AkCRV4v3TpGX4jxZfQ6K+aDie2Mus64oBrSK53GAshr2/88j9eaL7Q+GgAPoB9EiMIZNylu5RoVPzLUSY0NHS8AY57p6DOuYjLqr81sMJDE81aGHHppNyJ0PSxBjdkersqgIiErVuDHOW6V2dP6MaLUWlUExuWsuWtxGBV60NLvtttvarFSLVslRGZQPJxPBi2iJHJO5xhAPsT5RwZbfxHz2s59trmiMv2Obir0a4rMxp0Hc0EXFV3w+bp7iu2IunKic/c53vpO9P27yotVlDG0UN23FsfHzlrl5a7mofIwWxHmFQlTSRN6J9IsgYnvzEPSmmAOnOElvzCMQc8JET5gIyNW7AR2IYh8WA4hFsY3FyuUYguqUU07JHrFvIlgRFRcRDKxueVo9iXFHHHTQQVmQJJ+MOB/GI/JErXmKYg6BGHYu1iGCclGBGvk01qXYUyMmXu8p0QuoI3NZRF6NtC3OpRI9kb797W9nZWLkkehFV11ZEJWGvVkZM3PmzOzYrCUql4qtkWP94hHpH+VZzC8TlUpRsRzDoRTLpJjTpCd1tZyKdY2yMQKGIZbHcGaRPyIoGDcnkTfiUT0nQJyXIiCTD8kXvx1lW5RXUYHcVgCllvj+vfbaK/t8VD5Vl80x105eIRXld7REL67L61//+qxCKyqR22qdHRWvESzNK8Ii2BjHZqRV9BCKYEJUTEeAp635yWJuhajgj8nrYz9H2kUlflT415tTo7OiMj4/J8ZwPLFu1fOv1RI9T2JItbyMLR430dsu/47eOu92RlTUxnEfAYYoe6LXR5RREaSMnjy5yKsxV0gxbfIJ2yP9I29GC/841trrbVst8kLku3hEgLz6XHvyySd3qMV/d46neF/kqTx4GesRw4bmn43rhFiveC3vNRQizYrHQhyTcd0Q5WLkxwhwdkTkraggzyuTY+62OHeH2PYoU+J8Ec/x3lj3yFu15nCrpTvXN2XQF8da5IW8105cF0SZFvkn9luUCfkwtB0RLZTj/JYHXaM8jiBorHOc07oTaOyOGC4urqnywE7k1wgURl6Kc24cN5E/o7dSOPzww5s/293r5Dhm+3rI4jj2IgBdHNI01jXuE2Nd4tgp9qqPoeXyQGAE7eL/ecAo1j+2Oa6d4u96Q+Pl4nejwU3+/bHP49we3x/rFeVZlHFdHf4vgkfFc1O9eYIAymbIkCEDauhfASCAfhCVF3GTFRVK8RyiIqN6uJsQFSTROjN6lZTFV7/61eyGJO8dETcHeTpU60ylb7TOzydkz783n4A3AmvRS+GHP/xh3Zvg6M0RvSTyG8q44Ywh+mopVlgccsghWaVotJTMW3nE/+t9Nnz961/PbrjyCp24OYrhP4rixitaKkaFaC5u9KKyPHpd5D0Q4qYvb30cr0cFcFeGbumuCEZEa/7oHZHLK/aicjqCHxEQKm7LQBWVVNUVVbmogM5VVxZGhUO9oaZiOKl8vpjOiCGooqwotvYPUclT7H1WLYIpxYrVoghORMvznhJpEuvTkeGxIj9HBUBUBOe9fOJ4ufHGG2tWdOUBjt5UrFitVmwtXNzfUb5EBVmtoQ0jb0dvh+phbLqrO+VUHH9RmRTbE+seIihYayix6nI3KjMjwJeXK1HpmP9mvm/amqC7eii/GCqw1vx3EfApBvGj50QEvPJKsSjz8n316le/Oqswj2GKaokKvwgAxTGX93SISsP2JmWv5YADDsgCLccee2zz9kcQK8q7WI/uioByHJN5S/4IDrQXAIrfj7Im5sypFgGUOM/2xXm3s6KSMSon6w19G+fxYrDh4x//eLbO+fwYcSOd5/3ISxEILAZe2xIB2RtuuCELkleLgFkE2juqO8dT5NnIU8UebPU+m4sATwzHlf9WpEGeDp0pZyLwFsGY6EEXwe0IehVFGRdB+ig7LrrooixYVWvulrZ09fqmLHr7WIu8N3v27Ob/RyA772XVlYZicS0QDU3ySqro5ZH39Ij7j1NPPTX1hwjix/VtPgxdrF9c09S6rimmY09cJ/fHhN3rrLNO1sCnuF61gjfRQKJ62MS4r4zzW97QKtIqLzMjPeL8Ut1rOReBnjhnxPkkD6rHvUxPtVqv/t3BPpQ5QEf1x7mkLYaAA+gncfEeFVHRyyBu7KO1XVSKRo+RaCUYwYpZs2ZlF+RlCv7kQa2oAIlhT2JYp6jEixuQuIGLip9o5R0VMTEsUFT+dOZ74wYvWgxGesZNT6RltMaMoSOi5WBboiIvbgpjuIhoIRs3Y7FO8b1RwRJDm8RwR9Gqt3qM8Zj7Iz4bQzLFOOTRIjs+GxW20VI3KjqKwx7E31EBE63PozI3KvJjfSMdYt2jZXFUbBWHtchF5U0sixv2aPUXN3bR+jPWLb6zPwMrUVkbFaXRQyDWKyqOoqIrginRarMnJhMfSKJCMYZli4qKqJCNHgYRsInKswh6xf8PPvjgrKKvOCRed4aBa+u1EJXU0fMjKjQjL8WEwLE+sV7ROjkCUXE87LHHHqknxRj9HRWV8lGpf8EFF2TrEXkh8kscF3GsHXjggVmvi6gQ7e3gT2dEz6oIIsfxHmV0lANxzEYLrzjmY12j7IqgULFXYE/qTjkVQ/DFukXvvDhG45wTeSPWPVruRxA30r1YuRiiciiO4WhdHmVqlDHxWlQMRv7vTIVOlI+R/6LFdgyjFd8V54AoIyOgks+5E6J8i/NkrFeUpfHeaNkdPRYiiNTeUDLReyRaykd6xP6K8ijSKtY3tjd6jebzRrQneq8U57uKCu7Iu7XmOOms2IdRTuaqh3+tJdIjKpWjV1js90ibOI/Evo3Xq8vX3jrvdiZIHOeGKA+32mqrbP2L+TbOZ7Fu1T0iIggcjToiSBb5NN4f+yzK0wjmdGaerdhfce6MYXdjmyPN4twZgZD4ruqeKMVJ02v9TlePp6jAjWuVeD3Kurw3VOyP+DuuCap7i8ZxHwHNCMR2pwV9lLOxrXHtUR38KYqemdHzMvZZZyswunN9Uwa9faxF4DOC8tFrtl7P1c6IsicaYMQxGusZZXCsYzS+iDzeXyLfRRAyeqDF9U70TIq8FcdYXNdEj6C43onhEquvrwbydXJb4liJoWMjn0Q+imuLSIcof+K8FefduK6sLqtieaRPfn6Oz8RzlLPxfe1tb5RJcX0Yvx/7Pw+oxe9H2sVvx/VElHOdVRzKLr67J/IsAJ3XVBlI/ZEAgEEtKvVrTegcLRpj+I28pXbcxEevj+p5DQAaUVRWRg+oEJV3MbxRVPTlYoimCH7lIoAWAXd6R1RaRuVp3uMmAoi1eg4B5ZLPyVqcMzE37/PvT8vntRyieyAYNn5KGv+hS9JAE+Vn9A7Oh5eLAFYE7yif9189Lz32bOeGZe0LU9Yali45ZHx/rwYN6t9tnE/6gyHgAIAeEy2ro+Js5513zsYVj9aDUXEZvSZieIpc9BwQ/AH4r2jNH63Vo9V9tM+LuVm+9rWvSZ4+FsNLRQ+B6G2TB3/yYaOAxhbBn2VP/N9cirQthl/Ngz/R8Evwp7wi+POveQNnsnugNUPAAQA9KoYtvPrqq7MKzBiKLCaDzoM/0bI9hjTsjSGGAAazGJ4ohtsJV111VXr88cf7e5UaTgwteMYZZ2Q9snLRcvP444/v1/UC6E1xnR7zQcXweTHkWwxBF2VfDP0aQ6nWEsN3xnV9DLGdB3pyEUCPoYGjcUPMVZcPSRvzgcVn2hs2OBqPxfvi9zv6myG+N5YX5x3Lf7OtR7156eqJoZ/b+r5Y/1x7v/2Vr3ylxXfffffd2fyyMWRmNJaLYQxjiL4YVvTmm2/u1HoyMI+P9vJqWY6PaAhaa67KuL6N5ZGna4khVGMI2RjOOIawjKGS99xzz6xOodYgZo7HjtEDCADoMTFefMxrEPOFxATZCxcuzMb8jgvS6BUUY//HuO0AtBTlZD6JN/0rKi1ijqqYe+jTn/60icuBUg9TFPNYxtCjMY9gzF0VPXbuvffebKjRmHPqq1/9aqu5yXJ///vfs4ZfMadtLuYpyuei23TTTVvM79cTav1mR+a7ijm0aolRC7ri9NNPz+aqqxYV1kURwKk3p1YEFXLRA3XGjBlZ+se2xedefvnl9OCDD2Zzx0U6xvyGDO7jo7cNlOMjgjUxb2fM8dkREbR63/vely677LJsyMiYfzOGlo86hZiXMObejXkyr7322pojiTge2yYABAD0mLh4LE5mDkDPBIdM3dr7oodqPAAaQTQ6eNvb3pYeeuihrFI1hiItOuWUU9Kb3/zmrKdBzEM3ffr0mhXDn/jEJ7LPRs+I3tbV39xmm22ynjU9aY899kivf/3r231fNCjoyG9HkGj58uXZnHOxvtX+85//dHld6TzHR/dED8DotRaBzWhQ057ooRTBn3e84x1ZoCfvFZ8fGx/+8IfT5z//+axX9uWXX97q847HthkCDgAAAAAayBVXXJH+8Y9/pBNOOKFV8CdEL56oiI2W+REMqhat8D/1qU+lxx57LH3xi1/sk3Xuj9/sK9HTZ9y4cTWDP3kgib7j+Oie0047LY0ZMyZ99KMfbTGvYi3PPPNMNnT8euutl/WqKgZ/QgwZF8PwxUgi3/jGN7IeWL3twZIdjwJAAAAAANBAYlilcNxxx9V9z6te9ar0ute9Lpsbbc6cOa2WxzweMVTZOeeck+bPn9+r69ud34x5XKKSufrx3HPPdXk9FixY0Or78nlPi5YtW1bzt+NRnKslhr2K7bnhhhu6vE70HMdH946PCJ6ceuqpWbAmgjZtiV5CMdzhoYcemg2xV2943hgWLnrEX3/99a2WOx7bJgAEAAAAAA3k7rvvTmussUY2T09b8vk777rrrlbLYr6f8847L6t8jTnT+kJXfjOCRTE3T/Vj22237fJ67LPPPq2+74wzzmj1vt/97nc1fzsexaDarFmzsp4O+++/fza3UMyd+uUvfzndd999XV5Hus7x0b3jI5x44olp6tSp6cwzz6wZHC2mdT5sXFfLIsdj28wBBAAAAAANJAIoHRnGKIZxyt9fy95775123XXXLFjxgQ98IG200UY9vq7d/c3oNXTwwQe3er3WZPId9YUvfCFttdVWLV6LSeurRSV6BKxqKaZ/zKP6hz/8IX3pS19Kv/rVr7JeE3nPiV122SVdeeWVfZK2/Jfjo3vHR4g5uiJIe/jhh6cLLrggnX766TXfl5cteVnTlbLI8dg2ASAAAAAAaCCjR49OCxcubPd9Hamcjfk5ovV+DPl07bXX9uh69sRvxvBqu+22W4/+/nbbbZde//rXt/u+tdZaq8O/vdNOO2WP8O9//zvrPXTZZZel3//+92m//fZLf/nLX9KIESO6ve60z/HRMw455JAsOBPH67HHHls3rdsKMnekLHI8ts0QcAAAAADQQLbeeussAPTAAw+0+b4IOoRXvvKVbQ7N9O53vzt997vfTbfffnuPr+tA+c2+FL19oudSBH8iKHTPPfeUcjsHKsdHz4i5e6IH3AsvvJA++clP1k3r8Oc//7nbZVFv2WiQH48CQAAAAADQQGLIsfCVr3yl7ntiro1bb70162kTc3m05eyzz04jR45MH/7wh3t8XQfSb/ZHBfqOO+6Y/f3EE0/09+o0DMdHz9l9993TnnvumfVmqxVwfutb35oNN/fNb36z7lxBK1euzD6fz5PVX4YM0uNRAAgAAAAAGshRRx2VNttss2zOmeuvv77V8qeeeiq95z3vySo8zz333Ha/b4MNNkjHH3981kL+hz/8YS+tdf//Zm/56U9/miqVSqvXo0L85z//efb3Flts0Q9r1pgcHz0regFFEOdjH/tYq2XrrLNO+shHPpIFVI444oi0dOnSFsvjuIjPRQ+hWL7lllum3vbTkh2P5gACAAAAgAYSLe5/9KMfpb322ivr7bDPPvukPfbYI40aNSrde++96corr8yGbYpW97vuumuHvvO0005LV1xxRbrjjjvqvue3v/1tm5/vrI785p133pmuvvrqmsumT5+eJk+enHrLf/7zn7q/vfnmm2dD2YUYzi7mNon9EBXc0bPpscceS//7v/+bHnzwwWz4qXyoLHqf46Nnj48Ytu2www7LypVazjzzzPT4449nx/Jf//rXdPDBB6f1118/zZs3L1133XXZ8G9xbFx88cXdWo//NOjxKAAEAAAAAPUqz8ZPKeV6TZs2Lf3tb39Ll1xySdYL6BOf+ERavHhxWnfdddPb3/72dPLJJ3eqlfvYsWOz74jP1fOrX/0qe9RSq3dAT/zm9773vexRy/e///1eDQBFMO3QQw+tuezEE09srnCOiu/odRABsm9/+9tZ8C0qoLfZZpv08Y9/PKs8H4imrDWstOvl+OjZ4+PTn/50uvbaa9PLL7/caln0NLz88suz4d2+9rWvZUNTPvvss2n06NHp1a9+dRZ4ede73pUNAdcd95b8eKynqVKrPxMAAAAANIh///vfzZN9A0BZzifmAAIAAAAAACiZgdlPDwAAAACgly1YsKDmsFRFQ4cOzSarh0bj+Bj8BIAAAAAAgIYUc39cddVVbb4nJqR/5JFH+mydYKBwfAx+5gACAAAAoKENtDkb6Dv/+Mc/0pNPPtnme1ZdddW0884799k6wUDh+Bj85xMBIAAAAAAa2kCrsANgcPr3ADufDOnvFQAAAACA/lapVPp7FQAY5CoD7FwiAAQAAABAQ2tqakorV67s79UAYJBbuXJldk4ZKASAAAAAAGhow4cPT8uXL88eANAV+XkkzikDhQAQAAAAAA1t9OjR2fO8efMG3PA9AAx8lUolO4cUzykDwbD+XgEAAAAA6E9rrLFGGjVqVFqwYEFatGhRGjp06IAawgeAgR38WbFiRfaIc0mcUwaKpopmDQAAAAA0uBi257nnnssCQKrLAOiMaDSw+uqrp7Fjx6ZhwwZOvxsBIAAAAAAAgJIxBxAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAAEAAAAAAJSMABAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAAEAAAAAAJSMABAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEDDoPPLII6mpqan5Ef8faD75yU82r9/06dNbLf/Wt76Vtttuu7Tmmms2v+/CCy9Mv/nNb1ps20BSXK9YT+iMX//6183556KLLhqQiRfrla/jTTfd1N+rAwCd5jq5f7hO7v38u8EGGzS/fuWVV6ZG2d9f//rXm3/rRz/6Ua/+1mDMK5EvOiryTZ6Wnflcd0V9QP67UU/QG/UL/WnlypVZXcbWW2+dVl999eb1/MEPftDl78y3tzq9evN+7Zlnnkljx47Nvnv//fdPg8XJJ5+crfPw4cPTP//5z/5eHQYoASBgQKhUKulnP/tZOvjgg9O0adOyC4fVVlstbbzxxmm//fZLV199dXr55ZdTGcSF+2GHHZb+8pe/pAULFqSB4O9//3t2cRWPuHiDnr4piAvTMHHixHTMMce0es+f//zndOCBB6ZJkyalESNGZM8HHXRQdpx01VVXXZUOOeSQtOmmm6YhQ4a0e+MV6xXrF2J9Y70BoL+5Tu5frpMHfiAgv4/pauX6QLVo0aJ0+umnZ3+/6lWvSm9729v6e5WglUsuuSR98IMfTPfcc0968cUXezWFevN+bdasWen555/P/v7EJz6RBouPfOQjaZVVVknLly9Pp5xySn+vDgPUsP5eAYBoafGe97wn/fKXv2yVGA899FD2+OEPf5gmT5484Fq71HPkkUem3XbbLft7zJgxLZZ973vfa/57hx12SJ/5zGfSyJEj00YbbZQFvX7/+9/3y41tXPCE9ddfP5100kmt3lNcr2jdAx0Vrb/uvPPO7O+jjz46u0Atuuaaa9Lhhx+eVqxY0fzaf/7zn3Tdddel73//+1mPuXe9612dTvAvfOELzb/bEbFecVPx6U9/OjsmotyZMWNGp38XAHqK62TXyfzfPdTixYuzvzfZZJMWAaD8PiaUKQj0ta99LbsmDscff3x/rw5dFL1W8oafU6dO7fH6hf5WrN/YZ599ssDMsGHD0hZbbNHjv9Vb92txnH31q1/N/n7961+ftt122zRYREAsGlLGPXOkR6RLBIyhSAAI6FdxEf+Wt7ylRSv/t7/97VnL/wkTJqR58+alm2++Of3v//5vGkziwq7exd1jjz3W/Hds+5vf/OYWy+OCYyAaqOtVVtHiL3rClcGll17a/Hf0yCl6+OGHs4v4PPgTvePiAjaCP9/85jezlkxHHXVUet3rXpcFJzsjehButdVW2XCLl19+edYqrT3RCzFuKMJXvvIVASAA+o3rZNfJ/J+4nmu0nn9f/vKXmyu9DzjggP5eJbqoJxpPtlW/0N+K9RvveMc7er3Rbm/cr8VQi8uWLat5vzoYRJpEAChPk3hACxWAfvTZz362EkVR/jjrrLNqvm/evHmVuXPnZn8//PDDLT4T/8995Stfqbz1rW+tbLTRRpUxY8ZUhg0bVhk7dmxlp512qlx00UWVZcuWtfjeJUuWVD7zmc9UXv3qV1fWWGON7P1rr712ZZtttqkcccQRlVtvvbVL7z3zzDOb1++Nb3xj9to3vvGNFutd/YjtuPnmm1u8Vu2ee+6pHHPMMZWNN964suqqq1ZGjRqV/R2///zzzze/78QTT8x+d/LkyZXVVlutMnz48MrEiROztPnxj3/c4jvbWqdi+hZfi/UsevTRRysf+MAHKptuumm2Xqusskplk002qZxwwgnZsqLqbZw/f37l+OOPr6y77rqVESNGVLbYYovKd77znUpHdXafh6VLl2afmz59emXcuHFZ+owfPz5Ls+9+97st3rto0aLKueeeW3nd615XWXPNNbP3Tpo0qfKWt7yl8utf/7r5feuvv37zNsW+rpfGxbSL38tfjzzzrW99q/KqV72qMnLkyMp+++2Xvee6666rvP3tb8/SM7Yrtm/06NGV17zmNdnx8uKLL7bavpUrV1b+93//N1vH2K5Y59jOHXfcsXLppZdm7/n4xz/e/NsHHnhgq+/YZ599mpfPmjWr0lVx7DY1NWXfM23atFbLP/KRjzT/TmxjrHtYsWJFlrfzZR/96Ecr3VGd1m2J9Yz3DRkyJMufANAfXCe7Tu7r6+Tqe5g77rgju16O6/sJEyZUPvjBD1ZefvnlygsvvFA56aSTsvuLuG7dfvvtW1wX17rmf/bZZyszZ85s/kzcQ11zzTUtPtPWfV6ta+3ia7Ue+XV3vWvxtn4v/PCHP6xst9122frGese+iHuutu6L4p41rm+33HLL7F4t7os233zzymmnndbifq09kfb5b+y2226tlvfkvsp9//vfr+y9997Z/UPklbh/iPzzq1/9qtV7O3uPUrwXjv02Z86cymGHHZbdT8d6RTrX+p168n0X31UttvtjH/tYdi8c3/3KV76yctVVV7Vah2qxL/fff//Keuutl90/xb3frrvu2ur+sLP3ifXuQ7pbv1AU936777579vl83735zW9udYzVWp8f/ehH2TZE3ol9+Z73vKfy9NNPt7sPiutU69Gd/Z5/d737tp6+X4vjNV/Pxx9/vNXyztSvtKcr9QbtifqN2H/xudiHcS8NRQJAQL/abLPNmk9wr3jFKzp0omrrQr14MVPrccABB7T4rriwauv955xzTpfe2xsBoCuvvDK70Gjr87m2ficeF198cY8FgG655ZbshrLe52NZvCdXvY3FSv7i409/+lMHclDn9/lzzz1X2WGHHeq+//DDD29+bwSv8ovLWo/iBWl3A0DV6ZAHgGJ92tq+COosX768xY1EMXhT/cjz42OPPZbdHMRrUaEQgZpc3JzGa/lFdXUQrzO+973vNf/2oYce2mr5tttu27z8ve99b4tlxW2Pm8m+CgAdcsghze+94YYbuvW7ANBVrpNdJ/f1dXLxHiYqOiOAUf2Zgw46qPLa17621esR6CheM1Zf8xcrWIuPL33pSwMyAHT11Vc3N2IqPqKyvt73RRAmKt7rrU/c7z7xxBMd2nef+9znmj93+umnt1rek/sqGmC1d68bAemizt6jFO+FI1AUQar21qsrAaDYlgjA1Fqn4r6r/twZZ5zR5vYcd9xxLd7fmfvEevch3a1fCFF/8s53vrPN74nlxXqWtu5B88dee+3V4wGgzuz39gJAPXm/FsGu/FifMmVKzfe0tZ3V9Sv9EQAKr3/965s/+9e//rVTn6X8hrTsDwTQd1566aV0//33N/9/9913zyZq746YS+iyyy7Lxj6NoeN+/etfZ0M/rb322s3j0xaHm/vud7+bPccYtTE270033ZSuv/769LnPfS7tscceLeYq6cx7a9l7772zeXSK47EeccQR2WvxiEnv64l0irlT8m7JMe51bOfPf/7zbGzoXXbZJZvcPheTFl599dXpxhtvTL/5zW+y98VcQ7mYTDSG1grx2x//+MdbjCGbr1N767VkyZJsbpZ8TOMYbivSKYbv2nLLLbPXYlm8J95by3PPPZd1uY7Prbfees2vf/GLX0y9sc9POOGEdPvtt2d/Dx06NM2cOTP7bOzLmEBx7NixLbpSxxxUIfbvqaeemqXptddem4477rg0atSo1FMefPDBtPPOO2ff/ZOf/KR5zpu99torm1hz9uzZWZ6LR8yZM23atGz5n/70p2yOnVx0h//xj3/c/P93v/vd2bb96Ec/ysZEz/dnzKmVd5dfunRpuuqqq5o/E98Xr+XHZXeGG7j77rub/950001bLf/Xv/7V/Hc+oWet/+f7oS8U1/Ouu+7qs98FgJzrZNfJ/XGdXPT4449nQ/DGNWRc9+ZiXWKOxQsvvDC7xhw/fnzzkIVtDTsU2/KNb3wju84sDi0d19/5PDedFev/pS99qcVrxfuYrs7jERPZx5w7/62PTdn9W2xrDLEUQ5TXEtfOMYzx/Pnzm6+hY1sj/fIhv+O6N4Y27olr6J7cV5FHYt+EGII67m9jft6YT3PVVVfNXo/7oLjvyHX2HqVo4cKF2dy33/72t7Pfzee0aS8PdUQMHf+zn/2s+f/vf//7s/u3WP+YG6WWX/ziF+lTn/pU873+GWeckb0W99nrrLNO9noMxxf3aT15n9jd+oUQ6ZWvV9SlfOxjH0s//elPs+e8biWW10vXuAeN+8W4fyzmnfiOBx54oN15ieI4K96zRb1Cfvz15n7vyfu1GCY8P9brHWudqV/pL+5haVN/R6CAxhVda4stHKJbfEe01VIrejXEUGTRzb5WK6h4xHAHuejeHa9Fd9mf/exn2dAE9XTmvW110W6rJ0K9HkDFYbKiVVl7XbKjVWC09InWJdG1ulY63H333c3vb687fL3WKNFdPH8tWs08+OCDze//5z//2aLVXN41unobi13qi0OdRAutjujMPo+eLXmvl3hES6967r333hbfccUVV7S5Ht3tART5K4YrqBb5LIZri6EAVl999ZotEU8++eTmFm8xZEP+enSvb8tvf/vb5vfG8H25GPohf/3aa6+tdEcM9ZF/15e//OVWy4cOHVp3f0Rrx3xZvC8sXry48vvf/77uI5Z3twdQDJOXvzfWHwD6mutk18l9fZ1cfQ8TrfLzoZWip3jxM6ecckrzZ97//vc3v/6Od7yj+fXqa/6f/OQnzcviXiYfrqh4jdjZHkC1fqeWetfi9X4vehQU73H+9a9/NX/mxhtvrPl9ca+TvxZDRN10003N16cxlFzxMx3p5VK8Hv/pT3/aanlP7qsYhit//dhjj21xbT1jxozmZdFjpSv3KLVGw7j99tubl73vfe+ruV5d6QG077771r0Pjx5Rte55oydc/np8vrj9xXWL4eC6cp9Y7z6kJ+oXYpSEeqMtxFBu+bLYx7XWJ3rmFYfgLpYTkW87oq374K7u9/Z6APXk/VqUs/l3RR1KT9Sv9EcPoDjW88+ed955nfos5Tes7fAQQO8p9rQIeWuprnrqqaeyyUHjuS3PPvts89/Rsita67z88svpLW95S/ZatIh75Stfmfbdd9907LHHNre86cx7e9q9997b/HdMqpi32qvlV7/6VdYiq70WKMV06Kp//OMfzX9Hy5+8xVfeS2nChAnNLfrivW9961tbfUfeIi6MGzeuU+vX2X0erZiK6RKt9DqS5qG3J16NHmLV+SfyWvQKuu+++zq0fc8880yLVoltbV94wxvekLbZZpusZeA///nP9Lvf/S7Lz9HiL98fPTGpZi5vWVUUrcCiNVio7iVW/H+0Rgxz587NerzV8/DDD6cNNtigx9cTAPqS6+SOc53cc/dGRZtttllaa621Wl2jh+htkivel7R1/V7s9ROfidbqeY+M9noa9LXi+sQ9zkYbbdT8/7g2by8fRg+iN73pTW327ulMD/v2rk27u6+K6/7Vr341e9Rb767co1RbY4010vbbb9/le8CO7ruddtqpxbJY57zXTVFx+6O3XDza2v6euk/sifqF4v148RjL7/WiR1T1+4oin+YjiUSPoTj3RA/Unqov6K393lv3a7W+ty/rV7rDPSxtMQQc0G+iW/Tmm2/e4sTanZNWDGeQ3+BEpXIMBxBDHUT346233rr5fStXrmz+O7pGRxfxY445Ju2www7ZhXNUokf365NOOikdeuihXXpvfzrvvPOaL0423njjrCt+VOxHV+WiYjr0p/xmJe/+nutIXujKPu8txSH4iheHTz/9dIc+X2uove9///vNN1YxXF0M7xZDd8T2xbASPbF9MSRecfiH+M18qMFDDjkkjRgxInVHPmxCvYviV7ziFc1/Vw//EcGeXDG42NuKweh8qAwA6Euuk3uH6+SOXyfnwzOF6mG611xzzUFbAdmV6/TO3gu0Z9GiRd2+hu7JfdXRdc/Xu7v3KMX7v67cA/a0zm5/TxkI9Qt9uS968rd68n6tvWOtp88b3a03qMc9LG0RAAL61Xvf+97mv2MM3XPPPbfm++JCqL2xoefMmdP8d7SgiYrt6C0TLWhiXORa4kJjzz33zMb3ve2227KTZvSEyHsb3HDDDVmLnM6+t6dtscUWzX/HhUat3lL5RVMxHT7wgQ9kY39Hj4m4OK+neKPQmWBCMYAX+6c4n0uMJ1xscVh8b0/p7D6PXknFC80YY7leOhbTPN+/9d5b3VK3+NsxFndXbzyK2xdjj8fYw9FKa8cdd2yxLBctxooXwG1tXy7yR34xHuOoxzjzxXGdu6tYwRDHS7Xddtut+e8//vGPzfkvnm+55ZZWPcWid09sQ71Hd3v/hOLcZMX1B4C+5Dq5Y1wn99y9UW8qXtfl91G5qFTtquqAR617mc5epxfXJ+5xood58Xq1luK9Tvxe9AKqda0aQYR3vvOd3b6G7knFdT/nnHNqrveKFSvS3/72ty7do/Sl4r679dZbWyzryL6LXjf17jOiTqIr94n19ET9QnHdi8dYKM7D0xv34v2pJ+/XYh7j/F681rHWlfqVtnS33qAe97C0xRBwQL+KE2h0w84nH40u0H/+85/TQQcdlFVkRyuI3/72t9mEezGJZPUk8UXFrvnRAikm6YzWUDGJYkw6Wkt0A48eCNFdet111816kcS65N2e4wYiJiWMyS87896eFhXxMXlntBCJC8O44Dj55JOzoQPigiS29corr8wqvyMd8guXqMyP16IlS1yY11Psfv3kk0+mb37zm9n3xLa85jWvqfu5aOE1efLk7MIlLmDf8Y53ZBMghphIM7/wnTJlSovWYD2ls/s8lkXeyrvCR2u1uJCPC+9I29tvvz3bn5HWW265ZbbP8wvpmBQzglrxWtzQRaufmIz3ox/9aLY8hrHIb4piwtTo4h5Dm8W69MT2xeSWl156adpwww2zm4RaF6dx4Xr00Uc3T0gZeSK2K/ZL9OSJYTZiksuYeDMX+zg+Ey2bIv/mN0YxZEhUEHRXDD0Q6xV5IdK32vve975s0tP47UjfqOyKffSd73wn/fvf/25uBV2clLSj/vCHPzTfqOXP+cVxPiltHEOvfvWrW3wubsBCrHesPwD0B9fJHeM6uefujXpT9HI4++yzs8rPCy64oLlie+TIkd0acrh6yLO4Do/eFBEYyodri+v0P/3pT9nfcU/0wgsvZEGdGD2glj322CPrOfP8889n17AxxFd8Lu4TYpL7WuJeJ783i/SNxkvvf//7s/vGGKI5fi9GKoh7xhj5oj0RrMvVuobuSXEvkN+Pn3nmmdm9Tj582mOPPZYNFx3DokUeivXq7D1KX4r7iLwiPRpOnnjiidnwXXFfcN1119Xd/rzhXGxD3DdFHojn2P4YPi2+M/Z93Kt09j6xnp6oX4jy769//Wv2d/RMiXvzuH+JdSje8/VEw76BpCfv16IRZezTuE+O/R1B32K9U1fqV+I+/Igjjsj+Xn/99dMjjzzSvKwr9QZtfV+IETzyfBDlfARmoYX+noQIICaq3H333WtOpFdrErx6k3X+5z//qay11lqtPjdp0qTKZpttVnPixZj4vq3ffPvb396l99abpLG9yejbmsT08ssvrwwbNqzu7+fp8Itf/KLm8je96U11JxV87rnnsslKqz/zile8ovk99T77hz/8oTJmzJi66xXLbrnllg5tY3GSyOoJPWvpyj6PyTWLk2VWPw4//PDm9z7yyCOVjTbaqO57i99766231nzP1ltvXTft2soL4aWXXqpMmzat1XfGRKvbb799zXVevHhxZa+99qq7ztX5McREtEOHDm3xvnwy3p6w2267NX/vAw880Gr5VVdd1er380e8fvXVV3fpd4vp25H9He67777mZVEuAUB/cp38f1wn9/51clv3MPWuZ+t9pnp/vfrVr655LfaFL3yh+TP17vPamjh9+fLllalTp9a8hsx95zvf6dB1evH34vq01meq7wmLaRETxY8dO7bNa89a1+K1rFy5srLJJptkn1l11VUrCxYsaLG8J/fVihUrKocccki71835d3XlHqWt+7y2tqWePK9Uf1dsS726heK+q/7cxz/+8Xa3v5jvOnOfWO+eryfqF2J7DzrooDa/553vfGf2vvbWp63jrC1tfaar+z1fVuseuTfu184666zm7/za177WYllX6lfa2u6u1Bu0V09y4403Ni8/5phjeiRNKBdDwAH9LsZc/fnPf55uvPHGrDtttLCIFv/R0iVaxMQEiNEj5bWvfW2b3zNhwoSspUv05ogWW/GIng/RMieW1RI9jt71rndlrTDi/dFSLJ+cMLq/F1vNdOa9vSFv3XPUUUdl6RITQkY6RTf3aImUdyWO1mezZ8/OejVEGkZrohhDuN5kliG2J3pERBq3N9FkrZZL0fIrhpWIIdbi89GSL9YrJraMFmPVE3D2lK7s80in6OVy8cUXZ62F4v8xLFzkwze+8Y3prW99a/N7o3VN9JqJ/RtpM3r06DR8+PCsRVD8ZrG1UQx5EK2uYkiAeE+e7sWu950V+y/GgI5Wh9EyKYYDiP0b31k99EAu0v4nP/lJ1msuWq7FdsX2xTBvsY7RKq5atFaM46z4u+9+97tTTyn23on1qnbYYYdl+2T//ffPev7F+sb+i//H0A0HH3xw6iuxD2utNwD0B9fJHeM6uWeuk3tT9H6J+4WY9zJ6VsSwTdGjJK6XuyOGYYr7mF133bV56KxqMeRatLSP+8y4To8W/J/85Cfr9gjJr09jrpsYDSHWN47FuA9r69o+7heiF8FHPvKRbPviXi2uzeOeIu4zopf+V77ylQ5tV/RsiOHIQvSWqjW0c0+J+9rYF/EbcS8U+SO/f4ieEYcffng2VHTcS3T1HqWvxLbEvXDsg7gfi30X6xS9lGLOnXqid1q+TdF7J/JJ9KTYbLPNsvunSJ84frpyn1hPT9QvxGeuvfba7B4mhtaOfRbHRDxHL7S494qRFaqHShzMeuN+LXqBxf6rdb/alfqVtvRGvUE+wklwD0stTREFqrkEAGgYcVMTN7rhkEMOyf7fU2L4grhgjmBg3BTFEBidDTT2hbi5juErYu6q6DYfQzCU6WYJAKCvxPBbEZTJqXrqvBhOLBrVzZ07N2277bbNQzyRsiGw4rq91nBYDH4RoJ01a1Y2JGH83Rf3azHsagxNHmKItsEyjFqUDxHcjuECo1FnBKugmloNAGhQ+US0EZD56le/2muthuKiPMZ6DzGm8mWXXZYGolivuJkIMQaz4A8AAP0l5oSJOUvzCunuThIPg11v3q9FsCl6YoX8uBsMzj///Cz4E732Yl5fqEUPIABo8JZzRTEJbwx3AQAAXaUHEL1JD6DG7AEEdI0eQADQ4GKM8RiP/f3vf3+PDv0GAAAAQP/RAwgAAAAAAKBk9AACAADoAwsXLkyf+MQn0uabb55WXXXVtNZaa6XXvva16eqrr5b+AABAjxvW818JAABA0RNPPJF23XXX9Mwzz6T3vve9acstt0wvvvhieuCBB9Kjjz4qsQAAgB4nAAQAANDLDjvssPTCCy+kO++8M02ZMkV6AwAAva50Q8AtXrw43XvvvdkzAABAf7vlllvSTTfdlD760Y9mwZ8VK1akRYsWdes73fcAAAANFwD617/+lbbaaqvsGQAAoL/95Cc/yZ5f8YpXpP333z+b/2eNNdZI6667bjrrrLOygFBnue8BAADaYwg4AACAXnTfffdlz0cddVTacMMN09e//vXU1NSULr300nT66aenOXPmpK997Wt1Pz9v3rz09NNPt3jtoYceyp6XLVuWPQAAgPIbPnx4p94vAAQAANCLYu6fsNpqq6Xf/e53aeTIkdn/3/nOd6YtttgiCwidfPLJadNNN635+QgUzZo1q+ayBQsWpPnz5/fi2gMAAAPFxIkTO/V+ASAAAIBeFEO+hfe85z3NwZ8wYsSIdPDBB6dPfepT6eabb64bAJo5c2Y68MADW/UAmjFjRhozZkwaN26c/QcAALQiAAQAANCLpkyZkj1PmjSp1bL8tWeffbbu58ePH5896g0B0dlhIAAAgMYwpL9XAAAAoMx23HHH7Pmxxx5rtSx/bcKECX2+XgAAQLkJAAEAAPSi/fbbL6255prpW9/6VvN8QGHRokXpqquuynrw7LHHHvYBAADQowwBBwAA0Itinp4vfvGL6fDDD0/bb799Ouqoo1JTU1O64oor0hNPPJHOPvvs5mHiAAAAeooAEAAAQC877LDD0jrrrJM++9nPplmzZqWVK1emrbfeOn37299O73rXu6Q/AADQ4wSAAAAA+sBee+2VPQAAAPqCOYAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGSG9fcKAECjqCxbmpY9NScNdsMnTE1Nw0f092oAAAADkPsegIFDAAgA+kgEf+aeut+gT+9J58xOIyZP6+/VAAAABiD3PQADhyHgAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKZlh/rwAAjWHp8kqaM39ZKoOp44anEcOa+ns1AAAAAKAuASAA+kQEf/a7aG4pUnv2CZPStAkj+ns1AAAAAKAuQ8ABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkM6+8VAACARrJ0eSXNmb8sDXZTxw1PI4Y19fdqAAAAUIcAEAAA9KEI/ux30dxBn+azT5iUpk0Y0d+rAQAAQB2GgAMAAAAAACgZASAAAAAAAICSEQACAAAAAAAoGQEgAAAAAACAkhEAAgAAAAAAKBkBIAAAAAAAgJIRAAIAAAAAACiZYf29AgBAY1i6vJLmzF+WymDquOFpxLCm/l4NAAAAgLoEgACAPhHBn/0umluK1J59wqQ0bcKI/l4NAAAAgLoMAQcAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMgJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMsP6ewUAAAAAAMpg6fJKmjN/WSqDqeOGpxHDmvp7NYBuEAACAAAAAOgBEfzZ76K5pUjL2SdMStMmjOjv1QC6wRBwAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMgJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAAAAAAFAyAkAAAAC9rKmpqe7jnnvukf4AAECPG9bzXwkAAEC1XXbZJf3P//xPq9enTJkisQAAgB4nAAQAANAHNtpoo3TIIYdIawAAoE8YAg4AAKCPLFu2LL3wwgvSGwAA6HUCQAAAAH3ge9/7Xlp11VXT6NGj05prrpn1BnrkkUekPQAA0CsMAQcAANDLtttuu7T//vunTTbZJC1ZsiT94Q9/SJdddln66U9/mm655Za02Wab1f3svHnz0tNPP93itYceeqi5R1E8AGAgGDasXFWNlUolLV++vGG3vytpAPSu4cOHd+r95SuVAAAABpg77rijxf/f/e53p3322Sftvffe6aSTTko/+9nP6n720ksvTbNmzaq5bMGCBWn+/Pk9vr4A0BXjxo0rVcJF4KMz59mybX9X0gDoXRMnTuzU+wWAAAAA+sFee+2VXvva16Zf//rXafHixWmVVVap+b6ZM2emAw88sFUPoBkzZqQxY8aUsrIJgMEpesAsK9n2dOY8+98eQGVKgc6nATCwCAABAAD0kw033DDddttt6dlnn03rrrtuzfeMHz8+e9QbAqKzw0AAAB3T1NTU8OdZaQCD25D+XgEAAIBG9cADD2QVS1rWAgAAPU0PIIA+UFm2NC17ak4p0nr4hKmpafiI/l4NABg0Ytz8WgGeb3/72+mvf/1retvb3pZGjhzZL+sGAACUV7cCQDfccEM677zz0t13351GjBiRdtlll/SZz3wmbbXVVh36/F133ZW9/09/+lP6z3/+kw1r8JrXvCZ95CMfSTvttFN3Vg1gQIngz9xT90tlMOmc2WnE5Gn9vRoAMGicddZZ6ZZbbklvetOb0tSpU9PSpUuz/19//fVp0qRJ6cILL+zvVQQAAEqoywGgyy+/PB199NFZsOfcc8/NJi296KKLssBN3MxsvfXWbX7+9ttvT294wxuylnDHHHNMmjJlSnr00UfT1772tSyQ9NOf/jTtscceXV09AACAAWHXXXdN999/f7rmmmvSM888kyqVStpggw3SBz/4wfTRj3607vw+AAAAfR4Aeu6559KHPvShNHny5CzYM3r06Oz1gw46KG2xxRbpxBNPTDfddFOb3/GlL30pLVmyJP385z9v0WNoxowZWS+gyy67TAAIAAAY9Pbdd9/sAQAA0JeGdOVDs2fPTgsXLsx6AOXBnxDDGRxwwAHp5ptvTo899lib37FgwYLsed11123x+nrrrZc9jxo1qiurBgAAAAAA0PC6FAC67bbbsuda8/Tkr91xxx1tfseee+6ZPb/nPe/Jvu/JJ59Mt956azr44IPT2LFj04c//OGG3zkAAAAAAAB9NgTc448/nj3HEHDV8tfy99Rz3HHHpSeeeCJdfPHFaccdd2x+PYaDi4DQxhtv3O56zJs3Lz399NMtXnvooYey52XLlmUPgP42bFiXp1sbsGLuguXLl3f4/dKgfGkgD3Q+DSA0elnQm4YPH97fqwAAADCgdOkO9KWXXsqeR44c2WrZKqus0uI99QwZMiQb7m2bbbbJ5v3ZZJNN0gMPPJDOP//89Ja3vCWbQ2j99ddv8zsuvfTSNGvWrLpDzM2fP78TWwXQO8aNG1e6pI3Kvs6UsdKgfGkgD3Q+DSA0elnQmyZOnNjfqwAAADD4A0D5/DxLlixptWzx4sUt3lPPqaeemi644IL0t7/9Lev1Uxwa7tWvfnX6yEc+kr773e+2+R0zZ85MBx54YKseQBFQGjNmTOlusIHB29p7WQm3qTNl7H9bvJcrFbqSBmVKAXmg82kAZSwPHQcAAAAlCwAVh3nbfPPNOzw8XC6GZvvCF76QNttssxbBn7D11ltnr998883trsf48eOzR70hIAwDAdA7mpqaGr6MbfQ0aPTtD9IAHAcAAAAD2ZCufGiHHXbInm+99dZWy/LXtt9++7qff+aZZ9LSpUvTihUr6g4lMVDGEgcAAAAAAGiIAFAMsbbGGmukyy67LC1cuLD59Tlz5qTrrrsuTZ8+PU2ZMqV5LqD7778/zZ07t/l9EyZMSGuvvXb65z//mf70pz+1CiDFXECvfe1ru75VAAAAAAAADaxLAaCxY8em888/Pxvubeedd04XX3xxNp/PG97whmw4lAsvvLD5vbfffns2TFzM+dP8o0OGpFmzZqWVK1em3XffPZvv52tf+1r2HP8fMWJE+tSnPtUzWwgAAAAAANBgujQHUDj22GOziY8jEHTKKadkQZtddtklnX322emVr3xlu5+fOXNmWnfdddNFF12Uvv71r6cXXngh+7699torfeITn0jbbLNNV1cNAAAAAACgoXU5ABQOOOCA7NGWGA6uUqnUHUouHgAAAAAAAPTzEHAAAAAAAAAMXAJAAAAAAAAAJSMABAAAAAAAUDLdmgMIAAAAAAD4P5VlS9Oyp+aUIkmGT5iamoaP6O/VoIsEgAAAAAAAoIdE8GfuqfuVIj0nnTM7jZg8rb9Xgy4yBBwAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAAEAAAAAAJSMABAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAAEAAAAAAJSMABAAAAAAAEDJDOvvFaD8li6vpDnzl6UymDpueBoxrKm/VwMAAAAAANokAESvi+DPfhfNLUVKzz5hUpo2YUR/rwYAAAAAALTJEHAAAAAAAAAlIwAEAAAAAABQMgJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMgJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMgJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMgJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAANDHVq5cmXbcccfU1NSUdtttN+kPAAD0OAEgAACAPnbhhReme++9V7oDAAC9RgAIAACgD/373/9Op59+ejrrrLOkOwAA0GsEgAAAAPrQMccck7bccst0wgknSHcAAKDXDOu9rwYAAKDosssuS7/73e/Sn//85zRkiPZ4AABA7xEAAgAA6ANPPvlk+shHPpJOPvnktM0223T4c/PmzUtPP/10i9ceeuih7HnZsmXZAwAGgmHDylXVWKlU0vLlyxt2+7uSBsgH9K7hw4d36v3lK5UAAAAGoOOOOy6tvfba6cwzz+zU5y699NI0a9asmssWLFiQ5s+f30NrCADdM27cuFIlYQQ+OnOeLdv2dyUNkA/oXRMnTuzU+wWAAAAAetl3vvOd9MMf/jD98pe/TKuuumqnPjtz5sx04IEHtuoBNGPGjDRmzJhSVjYBMDhFD5hlJduezpxn/9sDqEwp0Pk0oHzHQZAPBi8BIAAAgF60ZMmS9IEPfCDtscceaYMNNmgevi338ssvZ6+tscYaacKECa0+P378+OxRbwiIzg4DAQB0TFNTU8OfZ6UBjoXBTQAIAACgF0WAJ+bw+cUvfpE23njjVsv/+Mc/Zq+/853vzHoKAQAA9AQBIAAAgF602mqrpeuuu67mshjabeutt05nnHFGmjJliv0AAAD0GAEgAACAXhRDtB1wwAF1l8fwbm0tBwAA6IohXfoUAAAAAAAAA5YeQAAAAP2kUqlIewAAoFfoAQQAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMgJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUjAAQAAAAAAFAyAkAAAAAAAAAlIwAEAAAAAABQMsP6ewUAAAAAAIDyWLq8kubMX5YGu6njhqcRw5rSYCUABAAAAAAA9JgI/ux30dxBn6KzT5iUpk0YkRpyCLgbbrgh7bjjjmm11VZLY8eOTfvuu2+65557OvUdf/3rX9OBBx6YJk6cmEaOHJnWW2+97HseeeSR7qwaAAAAAABAw+pyAOjyyy9P+++/f3rxxRfTueeem0477bR05513pp122indfffdHfqOb3/722mHHXZIDz/8cPrgBz+YvvzlL6cTTjghDR8+PD377LNdXTUAAAAAAICG1qUh4J577rn0oQ99KE2ePDndcsstafTo0dnrBx10UNpiiy3SiSeemG666aY2v+OBBx5IRx55ZHrPe96TrrzyyjRkSLc6IwEAAAAAAPD/dSnqMnv27LRw4cJ09NFHNwd/wtSpU9MBBxyQbr755vTYY4+1+R3nn39+Wr58efr85z+fBX9eeumltHTp0q6sDgAAAAAAAN3tAXTbbbdlzzHcW7V47aqrrkp33HFHmjJlSt3v+MlPfpI222yz9Kc//Smdcsop6b777ssCQTEk3DnnnJOmT5/elVUDBqClyyvZxG9lMHXc8DRiWFN/rwYAAAAAQM8HgB5//PHsOYaAq5a/lr+nlgULFqS5c+emJUuWpLe//e3p2GOPTWeffXZ68MEHs+fdd989/epXv0pvfOMb21yPefPmpaeffrrFaw899FD2vGzZsuxB/xo2rEtZbECrVCpZ7zU6ngci+LPfRXNLkWSzT5iUXjF+eKfygONAGpQxHzT69gfnA7qibMfCQDoOYh5RAAAA/k+X7kBjuLYwcuTIVstWWWWVFu+p5YUXXsien3322XTqqaemz3zmM83LXvOa16Tddtste/2Pf/xjm+tx6aWXplmzZtUNMs2fP7+DW0RvGTduXOkSNyo55K2OkwekgXxQzmOh0bc/OB/QFWU7FgbScTBx4sT+XgUAAIDBHwAaNWpU9hw9eKotXry4xXtqWXXVVZv/PuKII1ose/Ob35zNJRTDzEUQqa3vmTlzZjrwwANb9QCaMWNGGjNmTOlusAdvK9dlpdsmeatz6dXoeSDeX64U6FoayAflygfygPMBXT92ylQeui4CgJYMgQ7AoA8AFYd523zzzTs8PFxurbXWSquttlp68cUX06RJk1otj9fmzJmTnn/++TYDQOPHj88e9YaAMAwEvaGpqUneanDygDSQD+QBeQCcEwGglrINgT5twoj+Xg0AumFIVz60ww47ZM+33nprq2X5a9tvv32blaf5dzz22GOtlsdr0ZowAkUAAAAAAAD0QQAohlhbY4010mWXXZYWLlzY/Hr02rnuuuvS9OnT05QpU7LXYhi3+++/P82d27L1w+GHH549X3LJJS1e/8EPfpCefPLJbB6gfD4hAAAAAAAAenkIuLFjx6bzzz8/ve9970s777xzOvbYY7P5gC666KKsd8+FF17Y/N7bb7897brrrlnA58orr2x+/dBDD03XXHNNFgCaN29e9p5//etf6eKLL87m77ngggu6smoAAAAAAAANr0sBoBBBn5gAPAJBp5xyShoxYkTaZZdd0tlnn51e+cpXtvv5IUOGpB/+8Ifp3HPPTVdffXXW82f06NFZ76JPfepTaZNNNmn4nQMAAAAAANCnAaBwwAEHZI+2xHBwlUql5rIY4u3MM8/MHgAAAAAAAPTjHEAAAAAAAAAMXAJAAAAAAAAAJSMABAAAAAAAUDICQAAAAAAAACUzrL9XAACgUVSWLU3LnpqTymD4hKmpafiI/l4NAAAAoA4BIACAPhLBn7mn7leK9J50zuw0YvK0/l4NAAAAoA5DwAEAAAAAAJSMABAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkM6+8VAAAAAGDwqyxbmpY9NSeVwfAJU1PT8BH9vRoA0C0CQAAAAAB0WwR/5p66XylSctI5s9OIydP6ezUAoFsMAQcAAAAAAFAyAkAAAAAAAAAlYwi4Xmb8WwAAAAAAoK8JAPUy498CAAAAAAB9TQAI+kBZeoINnzA1NQ0f0d+rAQAAAABAOwSAoA+UpSfYpHNmpxGTp/X3agAAAAAA0I4h7b0BAAAAAACAwUUACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKZlh/rwAAAI2jsmxpWvbUnFQGwydMTU3DR/T3agAAAEBNAkAAAPSZCP7MPXW/UqT4pHNmpxGTp/X3agAAAEBNhoADAAAAAAAoGQEgAAAAAACAkhEAAgAA6EXPPPNMOvLII9M222yTxo0bl1ZZZZW04YYbpne9613pr3/9q7QHAAB6hTmAAAAAetHzzz+f7r///rTbbrul9ddfP6222mrpkUceSVdeeWV67Wtfm3784x+nPffc0z4AAAB6lAAQAABAL5o2bVr64x//2Or14447Lk2dOjWde+65AkAAAECPMwQcAABAP5gwYUJaddVVsx5CAAAAPa20PYBefPHF9MILLzT/f+TIkWnEiBFp6dKlacmSJS3eG6/H8mXLlqXFixe3WDZ8+PBsjO7ly5enl19+ucWyYcOGZTdstZYNHTo0jRo1Kq1YuTK9NHSVFsuGVFamVVYuTStTU1o8dGSLZU2pklZdsSRVUkovV30uXxaqvzOMWvHfdX956MhUSU0tlq26YnH2Sq1lq6xYkoakSlo8ZERa2TSk7rIXXnwpjSikaWx7pEFse6RBi9/7/8siPV968cW0SnqpedmyNCKtSMPSsLQsexQtS8PTijQ8Dc3+arlseRqePYZm/y5tsSy+L753SFqeRrRaFt82Mg1JK9KI1HLfr0xD0tK0SmpKK9PItLjdZS+9+EJ64YURaciQIdnQHZVKJS1atKjF55qamtLqq6+e/Z3nwaUvvtS8z3p7P1UvG7liaRqaVqYlQ4anFU1DWywbsXJpGlZZmZYOGZ6Wt1q2LA2rrEjLmoalZUP+W1TkeaCzx9NLL0ZKvtRn+ykXabgkrZr9tUp6uc6y1CJ/5hanUf9Nv/RyduzlIg9UKmtl+znKmZUrV7b4XOSLyB8vvfRSWrFiRfPrkQfimO+L/ZQbvnJZGp4tG5qWDRletWx5Gl5Znn1ffG9RfF987/KmIWnpkBEtlg2t/Heb2iz3VqzItr96WZxy+mo//XdZfK6p5rIlaZVUSUPSiLQ4DUkrO7xsaRqZVqahacmSl9MLLyypW+5F/i+K80icT5YsXdaq/O6t/TRy5bK0Ig1JS4aO6PA5qKPnp+rzQa1yr2iNNdbInl9+qeX5oLf30/C0JA1NK6qWjUgr07DsPBLnk6LOnJ/y80FnryOK54Pe3k+9fR2R54N65V72naNGZcd/cVmeBoOp3Ku3n15avCTFK/XKvdj+OE/E+aJo8ct53hs85V6t42lFdv03ou1yb8mS7HqhqDevywe62K4FCxZk2zBnzpx0wQUXZNeS++yzT3+vGgAAUEKlDQDdcccd6amnnmr+/5Zbbpk22mij9Pjjj6d77723xXs32WSTtOmmm2bv/9vf/tZiWUzOutVWW6X58+en22+/vcWyyZMnp2233TYtXLgw3XLLLa1a8+2www7ppZcXp7+vtWWLZWssW5S2fv6fWaVF9bKoYNn22Xuzm//qZVExsd38u7K/7xq7eYsK5KgM2vGZ/677vWtu2qpiY8en/5pVBNw/ZlqrCqHXzL8rq9h4cPSG6YXh/63Ay73q2XuzCqGH15ia7v/b3WnIA482L9t5553TWmutlY1nHulaFNseafDQQw+lu//xr7TlkP+rwHi4Mi09Wxmf1mn6T1q36bEWn3usskGaV1k3jWt6Ok1peqTFsicrU9LcypQ0punZtGHTQy2WzatMSo9VNkxrpIVp2pD7WyybX1knPVLZOI1KL6ZNh9zTYtmCNDY9tHLzrEJ6yyF/b7FsUVoj/XPl1lklYL7s7j+PSo+uOiSrzJw+fXpWqfOb3/ymxeeiYmL33XfP/v7973+fVQqtfHFhemmtLftkPz03YkyLZVs9/880etmiNGe19dLTq4xrsWyzBQ+ltZYuSE+Mmpjmrjq+xbJpCx9O45c8m/6z6jrpsdXWzV4b9f/zQGePp4Uvr8zyQF/tp2JF2L0rt83StHpZVPTetXK77O/Nh9zVosIrgkp/W7lj9vemQ+5tEXCMPLDl+vtkFXtRzlRXdse+jzwQ2/7ss8/+33e+uDBtMnRkn+yn3AaLHkvrvjwv+75HVp/SYtmUF59MU16am54dMSY9NHrDFssmvTwvbbjosbRw+BpZXixaZ/H8tEHs07bKvZdeanVcRFkxYdr2fbafwl9X7piVpZHXqitY71r5mizguOGQB9PqqeU+vHflq7IK1qlDHk5j0nMtlv1z5VZpURqdHn/4wfTvO+fWLfcefvjhFsviXBHnjDn/eSrdVVW299Z+2viFR9KLw0ele9bctMWysUsXpM0XPJQFDrp6fvpD1fmgVrmXi2Nl7733zv6+787b0pZDnuuz/bRe05zsfFL00MrN0oK0VprY9EQa39RyH3bm/JSfDzp7HZGfD/piP/X2dUR+TqhX7oU4V8Y585577mm+LsvTYDCVe/X20/P/fiS9btqWdcu9uFaKIEf1smVNEcSZNqjKvVrH08IFa6S03qg2y72Y5+aBBx5osaw3r8sHujh37rrrrs3/HzNmTProRz+azjjjjDY/N2/evPT001Xl2UMPNQeVqgNwAP0hgvFlE40+qxu8tkUalC8N5IHOpwHlOw5Cox8LlQF0HETDuM5oqsTal0jcRMaN4W233ZY233zzfu8B9PKcB9IjZ7x7QLbc7WzPkrU/flUase6Gne4B9MCTL6YjrphXih5A3zhyfNpwnS70AHry4TTvnCMGfQ+g8ad+I8sDnT2eHn56aZYHytADKPLA1ht2oQfQkw+nhWe9pxQ9gDY4+3tpyMQNOt0D6MkXhqUZFz1Rih5A3/2fNdPUsUM63QPohX/flx7/1CGDvgfQGp/4dovzQUd7AN398HPpvZf/pxQ9gPLzQad7ABXOB4O9B1B+Tuh0D6D/nwaDqdyrt58mfeKbac1pW3a6B9Cj85end3594aAq92odT/973Ppp0/VG6QHUCc8991z6y1/+kl0/RWDsW9/6Vnrd616XzjvvvOxYqueTn/xkmjVrVs1lEWCMoBlAfxs3blyqPPVomnvqfqkMJp0zOzVNWD9reNCZNHj02Ura76KWDY0Gq9knTErrr9XU6TQoSz6QB7qWByjXcRAa/ViYPcCOg4kTJ3bq/eUKxRXEDVRe4VQUlTTxqCUqaepF0KJSr9b3tbds6JAhzRUq1aIiuN6yqFqptyy1syyv3OnssqhMamvZGquNSiNqbGdbw21Epdeo1YakxallkKQY0KklKtlW1F02LHvUEpV6i+suG9pcaVItKj06smzUamukNdYY0aLSs96+D/mypauNSouq9llv7ad6ovIqqjBriUqvEXWWRWXZ8BX/rSStzgMdPZ5GvbS0RR7o7f3UWlMby/6vMq2WvBIuF3kg9ntoq6ImKv2Ksjzw/yvjens/tV62Ig2vqpQtVnoOq7tsZRpWp6xps9wbOrT2sheW9tl+6uiyCB52ZdnIkau2KAuqy7141PzciOF1y+/e2E9Rud6Vc1B756d654PQVpm46qjV6u7H3thPEVSu1yb+v0dT7X3YkfNT9fmgo9cRtc4HvbWfevs6ojofVJd7LX6vsKw6DQZLuVdrP41aZWTb5V7spyH/7TlctMpLcR5YOKjKvVrH09D/36qvzXJv5MjsUUtvXJcPdGPHjk277bZb9vdb3/rW9N73vjdts8026d///nf66U9/WvdzM2fOTAceeGCrHkAzZszIehHFDTZAf4vyeVkJt6kzZex/W7yXKxW6kgZlSgF5oPNpQPmOg9Dox8KwQXwclDYABAAAMNADQvvuu2+65JJLsuHyNtggBlptbfz48dmjs8EyALonGv81ehnb6GnQ6NsfpAHyQRrUx0HL8WsAAADoM/mQqjE8HAAAQE8SAAIAAOhFTz31VM3Xo9fPD37wg2wYt+L8pQAAAD3BEHAAAAC96Jxzzkm//OUv0957750N8xZDSNx3333pm9/8Zlq0aFG66qqr6s6jBAAA0FUCQAAAAL1on332SU888UT63ve+l+bNm5eWL1+eJk2alL1+4oknph122EH6AwAAPU4ACAAAoBfttttu2QMAAKAvmQMIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASqZbAaAbbrgh7bjjjmm11VZLY8eOTfvuu2+65557uvRdf//739Pw4cNTU1NTuvrqq7uzWgAAAAAAAA2tywGgyy+/PO2///7pxRdfTOeee2467bTT0p133pl22mmndPfdd3fqu5YvX56OOuqotMoqq3R1dQAAAAAAAOhOAOi5555LH/rQh9LkyZPTLbfcko4//vj04Q9/OP3+979PK1euTCeeeGKnvu9zn/tcevDBB9NHP/rRrqwOAAAAAAAA3Q0AzZ49Oy1cuDAdffTRafTo0c2vT506NR1wwAHp5ptvTo899liHvuuBBx5Is2bNSmeffXYWUAIAAAAAAKAfAkC33XZb9hzDvVXLX7vjjjva/Z5KpZIN/bbNNtuk97///V1ZFQAAAAAAAKoMS13w+OOPZ8+1euzkr+Xvacull16aBZP+8pe/pCFDOh+LmjdvXnr66adbvPbQQw9lz8uWLcse/WnYsC4l74AWQbuYs6mjpEH50kAekAbygWNBHpAHnBOcF7uaB3rT8OHD+3sVAAAABpQu1Uy/9NJL2fPIkSNbLVtllVVavKeeOXPmpFNPPTWbO2jrrbfuympkAaQYPq6WBQsWpPnz56f+NG7cuFQ2cYPfmXSVBuVLA3lAGsgHjgV5QB5wTnBe7Goe6E0TJ07s71UAAAAY/AGgUaNGZc9LlixptWzx4sUt3lPPsccemyZMmJDOOOOM1FUzZ85MBx54YKseQDNmzEhjxozp94r36PnRv32QemebOpOu/+39Uq5U6EoalCkF5AF5QD7o+rGgLChTCsgD0qDr+aBM10ad3X4AAAAGeACoOMzb5ptv3uHh4XLf//73089+9rP01a9+tcVQcTGkW3jqqaeyQM66667bZiBp/Pjx2aPeEBCGgeh5TU1NDZ+ujZ4Gjb79QRpIA/lAHpAHlIfOCfIAAADAQNf5iXdSSjvssEP2fOutt7Zalr+2/fbb1/38o48+2twLaOONN25+fPSjH81ej2Hh4v+/+93vurJ6AAAAAAAADa1LPYBiiLUTTzwxXXbZZemkk05Ko0ePbp7X57rrrkvTp09PU6ZMaZ4LKF6PIdkmTZqUvbbPPvvU7CH0m9/8Jl1yySXpAx/4QNpll13Stttu272tAwAAAAAAaEBdCgCNHTs2nX/++el973tf2nnnnbOePDEf0EUXXZQNjXThhRc2v/f2229Pu+66azr88MPTlVdemb02bdq07FFt0aJFzb2HDjjggK5vFQAAAAAAQAPr0hBwIYI+0dsn5ug55ZRT0qc//em09dZbp1tuuSVts802PbuWAAAAAAAA9G4PoFz00mmvp04MB1epVDr0fe9973uzBwAAAAAAAP3QAwgAAAAAAICBSQAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAoBc9+OCD6ZOf/GTaeeed08SJE9Nqq62Wtthii/SBD3wgzZ07V9oDAAC9QgAIAACgF11++eXpc5/7XJo6dWo69dRT0xe+8IW04447pksvvTRtueWW6f7775f+AABAjxvW818JAABA7oADDkgf+9jH0pprrtn82v/8z/9kQaBjjz02nXHGGem73/2uBAMAAHqUHkAAAAC9aLvttmsR/Mm9613vyp7vuusu6Q8AAPQ4ASAAAIB+8MQTT2TPEyZMkP4AAECPMwQcAABAPzj99NOz5yOOOKLN982bNy89/fTTLV576KGHsudly5ZlD4D+NmxY+aqYKpVKWr58eYffLw3KlwbyQOfTgPIdB6HRj4XKADoOhg8f3qn3l2tPAAAADAKf+cxn0vXXX59mzJiRDj/88Dbfe+mll6ZZs2bVXLZgwYI0f/78XlpLgI4bN25c6ZIrKvs6U8ZKg/KlgTzQ+TSgfMdBaPRjYfkAOg4mTpzYqfcLAAEAAPShL37xi+m0005L06dPT9dcc01qampq8/0zZ85MBx54YKseQBE8GjNmTOlusIHBKVp7LyvhNnWmjP1vi/dypUJX0qBMKSAPdD4NKN9xEBr9WBg2iI8DASAAAIA+8vnPfz6dfPLJ6c1vfnP64Q9/mEaNGtXuZ8aPH5896g0B0dlhIADomAjQN3oZ2+hp0OjbH6QB8kEa1MfBkP5eAQAAgEZw7rnnZsGft7zlLenHP/5xh4I/AAAAXSUABAAA0Adz/nzsYx9L++yzT/rBD36QVlllFWkOAAD0KkPAAQAA9KJLLrkkm/NnwoQJ6R3veEe67rrrWixfffXVs/l8AAAAepIAEAAAQC+64447suennnoqHXnkka2Wr7/++gJAAABAjzMEHAAAQC+68sorU6VSqft45JFHpD8AANDjBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGS6FQC64YYb0o477phWW221NHbs2LTvvvume+65p0Of/dGPfpSOPvrotOWWW6Y11lgjrbPOOul1r3tduuKKK9Ly5cu7s1oAAAAAAAANbVhXP3j55ZdnAZytttoqnXvuuWnx4sXpoosuSjvttFO65ZZb0tZbb93m54855pgscDRjxoy0+eabpwULFqTvfOc76aijjkrXX399+vGPf5yampq6unoAAAAAAAANq0sBoOeeey596EMfSpMnT86CPaNHj85eP+igg9IWW2yRTjzxxHTTTTe1+R3XXHNNetOb3tQiyHPSSSel6dOnpxtvvDH99Kc/TXvvvXdXVg8AAAAAAKChdWkIuNmzZ6eFCxdmPYDy4E+YOnVqOuCAA9LNN9+cHnvssTa/481vfnOrHj5Dhw5NBx54YPb3XXfd1ZVVAwAAAAAAaHhdCgDddttt2XMM91Ytf+2OO+7oUuI+8cQT2fOECRMafucAAAAAAAD02RBwjz/+ePYcQ8BVy1/L39PZ7/3qV7+axo4dm/bbb7923z9v3rz09NNPt3jtoYceyp6XLVuWPfrTsGFdnmJpwKpUKmn58uUdfr80KF8ayAPSQD5wLMgD8oBzgvNiV/NAbxo+fHh/rwIAAMCA0qWa6Zdeeil7HjlyZKtlq6yySov3dNSiRYuyoE8MLXf99dentdZaq93PXHrppWnWrFk1ly1YsCDNnz8/9adx48alsokb/M6kqzQoXxrIA9JAPnAsyAPygHOC82JX80BvmjhxYn+vAgAAwOAPAI0aNSp7XrJkSatlixcvbvGejgZ/9t577/S3v/0tXXzxxentb397hz43c+bM5jmDij2AZsyYkcaMGdPvFe/R86N/+yD1zjZ1Jl3/2/ulXKnQlTQoUwrIA/KAfND1Y0FZUKYUkAekQdfzQZmujTq7/QAAAAzwAFBxmLfNN9+8w8PD1fLCCy+kvfbaK/3xj39MX/7yl9Oxxx7b4fUYP3589qg3BIRhIHpeU1NTw6dro6dBo29/kAbSQD6QB+QB5aFzgjwAAABQygDQDjvskL7yla+kW2+9Ne2+++4tlsVrYfvtt2/3e2KYtre85S3p9ttvT1//+tfTkUce2ZXVAQAAAPpZZdnStOypOWmwGz5hamoaPqK/VwMAoH8CQDHE2oknnpguu+yydNJJJ6XRo0dnr8+ZMyddd911afr06WnKlCnNcwHF6zEk26RJk1oEf/bYY4/0l7/8JV155ZXp0EMP7f7WAAAAAP0igj9zT91v0Kf+pHNmpxGTp/X3agAA9E8AaOzYsen8889P73vf+9LOO++cDdsW8wFddNFF2dBIF154YfN7o3fPrrvumg4//PAs0JPbbbfd0p///Oe03377ZZ+5+uqrW/zGK1/5yuwBAAAAAABAHwSAQgR9YsLXCASdcsopacSIEWmXXXZJZ599docCNxH8CbNnz84e1c4880wBIAAAAAAAgL4MAIUDDjgge7QlhoOrVCqtXq/1GgAAAAAAAN03pAe+AwAAgDZ89rOfTe985zvTxhtvnIYMGZKGDetWWzwAAIB2uesAAADoZaeeempac80107bbbpsWLVqUnn76aWkOJbN0eSXNmb8slcHUccPTiGFN/b0aAEA3CQABAAD0soceeii94hWvaB4mWwAIyieCP/tdNDeVwewTJqVpE0b092oAAN1kCDgAAIBelgd/AAAA+ooAEAAAAAAAQMkYAg4AAGAAmzdvXqsh42JIubBs2bLsAf1t2LByVS9UKpW0fPnyht3+IA2kgXwgD3QlD+CcUMbzYmUAHQfDhw/v1PvLtScAAABK5tJLL02zZs2quWzBggVp/vz5fb5OUG3cuHGlSpSo5OnMsVW27Q/SQBrIB/JAV/IAzgllPC8uH0DHwcSJEzv1fgEgAACAAWzmzJnpwAMPbNUDaMaMGWnMmDGlu8FmcIqWvstKtj2dObb+29K5TCnQtTQoVwrIB11NgzLlA2VB59OA8h0HodGPhWGD+DgQAAIAABjAxo8fnz3qDQHR2WEggPY1NTU1/LElDeQDx4I8IA/gvDj4z4lD+nsFAAAAAAAA6FkCQAAAAAAAACVjCDgAAIBe9q1vfSs9+uij2d/xXKlU0llnndW8/BOf+IR9AAAA9CgBIAAAgF52+eWXp9/+9rctXjv99NOb/xYAGvyWLq+kOfPLMdnx1HHD04hhTf29GgAAdJMAEAAAQC/7zW9+I41LLoI/+100N5XB7BMmpWkTRvT3agAA0E0CQAAAAHRLZdnStOypOaVIxeETpqam4YIfAAAMfgJAAAAAdEsEf+aeul8pUnHSObPTiMnT+ns1AACg24Z0/ysAAAAAAAAYSASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgAIAAAAAACgZIb19woAAAAAAFAOlWVL07Kn5qQyGD5hamoaPqK/VwO6TAAIAAAAAIAeEcGfuafuV4rUnHTO7DRi8rT+Xg3oMkPAAQAAAAAAlIwAEAAAAAAAQMkIAAEAAAAAAJSMABAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAAEAAAAAAJSMABAAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlEy3AkA33HBD2nHHHdNqq62Wxo4dm/bdd990zz33dPjzL730UvrYxz6WNthggzRy5Mjs+dRTT81eBwAAKJPu3j8BAAD0SQDo8ssvT/vvv3968cUX07nnnptOO+20dOedd6addtop3X333e1+fsWKFWnvvffOPvuGN7whXXLJJeltb3tbOv/887PnlStXdnXVAAAABpTu3j8BAAB01rBOfyKl9Nxzz6UPfehDafLkyemWW25Jo0ePzl4/6KCD0hZbbJFOPPHEdNNNN7X5HVdddVX67W9/m0444YT0pS99qfn16AX04Q9/OF199dXpsMMO68rqAQAADBg9cf8EAADQJz2AZs+enRYuXJiOPvro5puXMHXq1HTAAQekm2++OT322GNtfsc3v/nN7Pnkk09u8frMmTPTqquu2rwcAABgMOuJ+ycAAIA+CQDddttt2XMMV1Atf+2OO+6o+/lKpZItX3fdddP666/fYlkEf171qle1+XkAAIDBorv3TwAAAF3RVIloTCfFHD0//vGP0z/+8Y+0+eabt1h24403pre+9a3pi1/8YvrABz5Q8/Pz589Pa6+9dtphhx2ab4aKYiiE6667Li1YsKBFC7lq8+bNS08//XSL12Kd4vPf+9730ite8YrUn4YNG5bS8uVp+fy5qQyGjZsUG5WWL1/e8c/E+1ekNPf5jn9mIJu05rA0bGjqdBqUJR/IA/KAfPBfygLng0bPA905J0iD8lwbdeU46E3Dhw/Prv9XWWWVNNB09/7JfU/fcs3rWkcekAeUBf/V6Ne8ygJ5oDv5oCzHQWj0Y2Gw3/d0aQ6gl156KXseOXJkq2X5D+fv6eznq7+jrQDQpZdemmbNmlVzWQylAAAANI577rknbbnllmmg6e79k/seAACgK/c9XQoAjRo1KntesmRJq2WLFy9u8Z7Ofr6j35HPF3TggQe2eC3G1n7ggQfS1ltvXTfAVDYPPfRQmjFjRvrBD36Qpk2blhpRo6dBo29/kAbSQD6QB+QB5aFzgjzQ3yMA9Nb9k/ue/3K9Jw3kA3lAHlAe5hr9nNDo2x+kgTRo5Hzwik7c93QpADR58uTs+fHHH281hEG8VnxPLWuttVZ2g5O/t1q8Hj1/2ur9E8aPH589qr3uda9LjSgy+UBs8diXGj0NGn37gzSQBvKBPCAPKA+dE+SBgaa790/ue1pyvScN5AN5QB5QHjonyAPygGsj14cdMyR1QczdE2699dZWy/LXtt9++7qfb2pqStttt1168skn06OPPtpi2csvv5z+/ve/t/l5AACAwaK7908AAAB9FgCKblVrrLFGuuyyy7Ih13Jz5sxJ1113XZo+fXqaMmVK81jW999/f5o7t+WkV4ceemj2fMEFF7R4/ctf/nIWBMqXAwAADGaduX8CAADoKV0aAm7s2LHp/PPPT+973/vSzjvvnI499thsPOuLLroo691z4YUXNr/39ttvT7vuums6/PDD05VXXtn8+hFHHJG++c1vZp9ZsGBBesMb3pDuvPPObILTuAE65JBDemYLAQAA+lFn7p8AAAD6tQdQiJuWaK0Wc/mccsop6dOf/nTaeuut0y233JK22Wabdj8/dOjQdOONN6aPfOQj6Te/+U067rjj0uzZs9PJJ5+cfvzjH2fL6Zh11lknnXnmmdlzo2r0NGj07Q/SQBrIB/KAPKA8dE6QBway7t4/4TwXXPNKA3lAHlAW/FejHwuNvv1BGkgD+aBjmiqVSqWD7wUAAAAAAKDMPYAAAAAAAAAYmASAAAAAAAAASkYACAAAAAAAoGQEgAAAAAAAAEpGAAgAAAAAAKBkBIAGuGXLlqXjjz8+jR07Nq211lrphBNOSMuXL293WYj/T5kyJY0ePTqtt9566aSTTkpLly5Ng02jp0Gjb3+QBt1Lg/e+971pxIgRafXVV29+3HrrrWmwafQ0aPTtD9Kge2nwr3/9K+21117Z8jgnnHfeeWkwavQ0aPTtp7xc70kDeUAe6G5Z4Jq3HGkgD0iD7uaDslzzNnoaNPr296gKA9oZZ5xR2WabbSpPPvlk9oi/Z82a1e6y8I9//KOyaNGi7O+nn366Mn369MqnP/3pymDT6GnQ6NsfpEH30uDwww+vnHjiiZXBrtHToNG3P0iDrqfB8uXLK1tssUXl4x//eGXp0qWV+++/vzJlypTKNddcUxlsGj0NGn37KS/Xe9JAHpAHulsWuOYtRxrIA9KgO/mgTNe8jZ4Gjb79PUkAaICbPHly5brrrmv+/3e/+93K1KlT211Wbd68eZU3velNlcMOO6wy2DR6GjT69gdp0L00KMNNQGj0NGj07Q/SoOtpcO+991aGDh1aWbJkSfPyT37yk5U3vvGNlcGm0dOg0bef8nK9Jw3kAXmgu2WBa95ypIE8IA26kw/KdM3b6GnQ6NvfkwSABrBnn322Ep20HnzwwebXHnjggey1Rx55pO6y559/vvm1c845p7Laaqtlr48bN65yxx13VAaTRk+DRt/+IA26nwZxEzB27NjsEa0gPve5z1VWrFhRGUwaPQ0affuDNOheGtx9993ZRfDixYubl0erqcgTg0mjp0Gjbz/l5XpPGsgD8kBPlAWueQd/GsgD0qC7+aAs17yNngaNvv09zRxAA9iiRYuy5zXXXLP5tfzvIUOG1F32wgsvNL/2sY99LPuef/zjH+l973tfmjhxYhpMGj0NGn37gzTofhp84AMfSP/85z/T008/nS6//PL0xS9+MXsMJo2eBo2+/UEadC8NNt1007TBBhukM844Iy1ZsiTde++96YorrkgLFy5Mg0mjp0Gjbz/l5XpPGsgD8kBPlAWueQd/GsgD0qC7+aAs17yNngaNvv09TQBoAIvJ+sKCBQuaX8v/XrlyZd1la6yxRqvv2nzzzdM222yTTQg4mDR6GjT69gdp0P00ePWrX53WWWedNHTo0LTjjjtmQcFrr702DSaNngaNvv1BGnQvDYYPH55mz56d/va3v2WTYB588MHpiCOOSOPGjUuDSaOnQaNvP+Xlek8ayAPyQE+UBa55B38ayAPSoLv5oCzXvI2eBo2+/T1NAGgAGzt2bJo8eXL6+9//3vxa/D1lypS0/vrr1102ZsyYmt+3bNmy9OCDD6bBpNHToNG3P0iDnk+DvLXEYNLoadDo2x+kQffTYMstt0y/+MUv0jPPPJMti9ZQb3zjG9Ng0uhp0OjbT3m53pMG8oA80BtlgWvewZcG8oA06Il8UIZr3kZPg0bf/h7X44PK0aNOP/30yrbbbluZO3du9oi/Z82a1e6yF154oXLFFVdUnnvuucrKlSsrd911V2XzzTevHHPMMYNuDzV6GjT69gdp0PU0CNdee21lwYIFWT6IOaDWX3/9ynnnnVcZbBo9DRp9+4M06F4a3HnnnZVFixZlk2Fef/31lbXXXjt7bbBp9DRo9O2nvFzvSQN5QB7oTlkQXPOWIw3kAWnQ3XxQlmveRk+DRt/+niQANMAtXbq0MnPmzMqaa66ZPY4//vjKsmXL2l0WmXy33XarrLXWWpXVVlutsuGGG1Y+/OEPV1588cXKYNPoadDo2x+kQdfTIOyyyy6VMWPGZPlgk002qZx77rmDaiLQXKOnQaNvf5AG3UuD0047LTsnjBo1qvK6172u8oc//KEyGDV6GjT69lNervekgTwgD3SnLAiuecuRBvKANOhuPijLNW+jp0Gjb39Paop/er5fEQAAAAAAAP1lcA0GCgAAAAAAQLsEgAAAAAAAAEpGAAgAAAAAAKBkBIAAAAAAAABKRgCoBObMmZNWX331tGDBgtSIGn37gzSQBvKBPCAPKA+dE+QBeYCya/Rr3kbf/iANpIF8IA/IA8pD5wR5QB7oHAGgAWb69Olp5MiR2YX9Wmutlf3/L3/5S5ufmTp1alq0aFEaM2ZM3ffcc889ac8990xrr712ampqSs8//3waiBp9+3szDa666qq0ww47ZO+ZNGlSOuqoowZsOkgDx4KywHGgLOjd8nCwnBedD6QB5aV8a+zyPSjjpUFv5oPBciw0+vYHZYE06M18MFiOBceBNOhNAkAD0LnnnpsVYE8++WTadttt03777det71u2bFkaPnx4Ouigg9KVV16ZBrpG3/7eSoOXXnopnXfeeempp55K9957b5o7d26aOXNmGqikgWNBWeA4UBb0Xnk4mM6LzgfSgPJSvjV2+R6U8dKgt/LBYDoWGn37g7JAGvRWPhhMx4LjQBr0mgoDyhvf+MbKF77wheb/33333ZXYTZ/73Ocq06ZNq6y++uqVjTbaqHLRRRc1v+fhhx/O3vPcc89l/z/88MMrRx55ZOXAAw+srLHGGpUvfelLdd870DT69vdFGuRmz55dmTJlSmUgkgaOBWWB40BZ0Dfl4UA/LzofSAPKS/nW2OV7UMZLg77IBwP9WGj07Q/KAmnQF/lgoB8LjgNp0JuG9V5oie6KHhtf//rX0/rrr5822GCDdNNNN6XJkyen3/zmN2nvvffOouE777xzzc9++9vfTt///vfTd77znbR48eJBuTMafft7Ow1++9vfple+8pVpoJMGjgVlgeNAWdD75eFg4HwgDSgv5Vtjl+9BGS8NejsfDAaNvv1BWSANejsfDAaOA2nQ43o1vESXIr6rrLJKZcyYMZUJEyZU9txzz8qdd97Z6n377bdf5ayzzqob8Y7ltQyGiHcjb39fpEG48cYbK6NHj67cddddlYFIGjgWlAWOA2VB35SHA/286HwgDSgv5Vtjl+9BGS8N+iIfDPRjodG3PygLpEFf5IOBfiw4DqRBb9IDaAA655xz0kknndTitWuuuSZdcMEF6ZFHHkkrV67MosEbbrhhmxOhDVaNvv29nQbRcuKQQw5JN9xwQ9p6663TQCUNHAvKAseBsqD3y8PBwPlAGlBeyrfGLt+DMl4a9HY+GAwaffuDskAa9HY+GAwcB9KgtwgADQJz5sxJhx9+ePrZz36Wpk+fnoYNG5ZmzJgRvbfqfmbIkCGpLBp9+3syDSL4c8ABB2RdYt/85jenwUQaOBaUBY4DZUHPloeDlfOBNKC8lG+NXb4HZbw06Ml8MFg1+vYHZYE06Ml8MFg5DqRBTynPUVFiixYtygq38ePHZwXZjTfemH7xi1906jvi8zH25ZIlS7L/x3P8v61Cc6Bo9O3vqTSIsVL333//9K1vfSvtueeeabCRBo4FZYHjQFnQc+XhYD4vOh9IA8pL+dbY5XtQxkuDnsoHg/lYaPTtD8oCadBT+WAwHwuOA2nQU/QAGgS22GKLdNppp6U3velNacWKFWnffffNHp3x6KOPtugiOXHixOz54YcfziZUG8gafft7Kg1mzZqVFi5cmN75zne2OqEMBtLAsaAscBwoC3quPBzM50XnA2lAeSnfGrt8D8p4adBT+WAwHwuNvv1BWSANeiofDOZjwXEgDXpKU0wE1GPfBgAAAAAAQL8zBBwAAAAAAEDJCAABAAAAAACUjAAQAAAAAABAyQgAAQAAAAAAlIwAEAAAAAAAQMkIAA1w06dPTyNHjkyrr7568+PSSy9N733ve9OIESNavB6PefPmZZ/75z//md72treltddeO40ePTptttlm6dxzz00DbduGDh2a7rrrrubXnn/++dTU1JQeeeSR7P9PPfVUOvLII9OECRPSqFGj0pZbbpkuvvjiFt/zyU9+Mg0bNqxFOrz73e/Oll155ZXZb1Sn0/XXX58tf+GFF9LMmTPTeuutl70+ZcqU9K53vSsNJPKAPCAfKAvkAXmgEc4JHVH27XdtRCMr8/Ht2O54OskDjX3vG+QD97/ygDxQ9rKgo8qcBq6N+pYA0CAQB+miRYuaH3HRFuL5/7X3J/B2TXfj+L9CJgmSSJtBI6GoMdUBVZQoqlVttARVxNBSaQ2VtoQaQlHzVPG0pWKqqVpRHdBHaWtodDAUqaGIIV+JIKQhbji/12c//3P/59577r3nTjn37PN+v14n52bvM+y9ztprr7U/a61dujweI0aMyNZ9/vOfT5tsskmaO3dueu2117JK3wc/+MHU2wwbNixNmzat7LoIBm211VZZRXX27Nlp0aJFWQX4rLPOSt/97nebvHaXXXZpkg7XXntt47rx48e3SKfddtstW/ftb387Czb94x//yJbfd999WSHU28gD8oB8oCyQB+SBejgnVCLv+69uRD3L8/Ht2K6MPKDdIx+o88oD8kA9nBMqlec0UDdafgSAcuiVV15JTz/9dDrkkEOynkPRCyh6D02aNCn1NlFg3XPPPelPf/pTi3Xnn39+1rvpuuuuS+PGjUv9+vVL2223Xbr66qvTueeem/7zn/90+fvvv//+rMdU9LIKY8aMSd/4xjdSrZMHKpfXPBDkg8rlNR/IA5XLax6otXzQE2pt/9WNIJ/Ht2O7Z8gDlVPX6R2UBT1DWVA5ZUG+ORYqd3+OrwE0JwCUQ8OHD0/rrbdeOuCAA9INN9yQnnvuudRbrbbaaunoo49OxxxzTIt1t912W9pjjz2yhlypT33qU2n11VdPf/jDH7r8/THC6OSTT04/+clPsqnoCoVCygN5oHJ5zQNBPqhcXvOBPFC5vOaBWssHPaHW9l/dCPJ5fDu2e4Y8UDl1nd5BWdAzlAWVUxbkm2Ohclvl+BpAcwJANSCmSBs6dGjj47///W+2/JJLLmmyPBo/Ie6hc9ddd2XD/aZPn54N89twww3THXfckXqjI488Mmus3XzzzS2i1hHoKSeWL1iwoPH/v/nNb5qkRQSPih555JEm6+Lx5JNPZusuvPDCLLob8yVvvvnmWdQ3Rhf1NvJAS/WWB4J80FK95QN5oKV6ywP1kA/aUw/7r25Evcr78e3Ybp880JK6jrKgHvOBsqClessD9ZAPKpH3NFA3Wk4K9Grbbrtt4bzzzmuxfPLkyYUjjjiios9YuHBh4aijjioMHjw4+7s37tuPf/zjwgYbbFB45ZVXItxaeOaZZwpbbLFF4fjjjy/73jFjxmTvCSeeeGJh4sSJZV93+eWXFzbZZJOKtuftt98uXHXVVYV+/foVbrvttkJvIQ/IA/KBskAekAfq4ZxQibzvv7oR9SzPx7dju+PpVEoeqJ+2b5APtH/lAXkg72VBpfKcBupGy5cRQHUghhifdNJJWZT4mWeeSb3RQQcdlN577710xRVXNC7bcccd04033pjefffdJq/9y1/+kl566aW0/fbbd+s2DBgwIO2zzz5p/PjxWW+JPJEHKpPnPBDkg8rkOR/IA5XJcx6olXzQk2pl/9WNIJ/Ht2O7Z8kDlVHXqT5lQc9SFlRGWZB/joXK5P1YEADKoddeey19//vfT3PmzMmCJ0uWLMmGc8ZBv/7666feKO7zc+qpp6bTTjutcdm3v/3ttHTp0vTVr341Pf/886mhoSHdfffd2QF5+OGHp7XXXrvL3xvDIe+999701ltvZWl1yy23pMceeyx98pOfTLVMHqhcXvNAkA8ql9d8IA9ULq95oFbzQXeq1f1XN4J8Ht+O7e4lD1ROXad3URZ0L2VB5ZQF+eZYqNz0HF8DaE4AqIbNmDEjrbzyyk0e//znP1P//v3Tiy++mHbeeec0ZMiQNHbs2HTPPfek3/3ud2nw4MGpt9ptt93SOuus0/j/YcOGZdu90korpY9//ONp1VVXzeYpPeqoozo0P2lEbpunU8x5Gvr27ZsOPfTQbM7TuFFa9Bi89NJL05ZbbplqgTxQmTzngSAfVCbP+UAeqEye80Ae80FH5XH/1Y0gn8e3Y7vj5IHKqOsoC/KeD5QFlclzHshjPuiMvKWBulHP6hPzwPXwdwAAAAAAALAcGQEEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAERd6NOnT+Pjrrvu6tRnTJgwofEzTjrppG7fxlombajU/vvv33gcxd+9RZQLpeVEb7TPPvtk2zZo0KD08ssvV3tz6GUuuuiixvx75513dutnv/LKK2nYsGHZZ++2226pVkydOjXb5n79+qV///vf1d4cgJoxc+bMxnPKmmuumeqpzUd1aVcCnXHppZc2lv+//vWvc3Ue7cl2HvVDAIiaU1qQtvYYOnRotTczN15//fUs4FV8xP/rPXBRyQm8eZ6MC5CrrrpqWnvttdNOO+2UzjnnnLRw4cJ2P+e4445r8jlDhgxJS5Ys6aa9qh8333xzYx6Ov2vN3/72t/Tzn/88+/vggw9OI0eObFz34IMPNu7b+eefv9y3rbeXEc8++2yT7euopUuXpnPPPTd94hOfyI6/OJbf9773pfXWWy9NnDgxHX/88emtt95q8p7SY3aFFVbIfqNS1113XasBx9KypvQxePDg7Dvj9y8XzPj617+eRo0a1Rj4eO+991J3mT59euPv+v3vfz/Viu9+97tp4MCBadmyZel73/tetTcHAOpaLdQZy9XBou43YsSItN1226Uf//jH6d13323x3vauT8SjeRvkjTfeSCeeeGL6yEc+klZeeeXUv3//7Hs22mijNGnSpHTaaae1Wz9s7RGBtEr94x//yN7zsY99rN3XNv+e2M5ydtlllyava95+Lg30dWRbKxH1viuvvDKrp48ZMyYNGDAgqyN/8pOfTKeffnp68cUXO/3ZhUIh/f73v09f/epX0zrrrJP9blFHX3fddbPvu/rqq5u0C84888ys7T9u3LjstcV2xNZbb53OOuusNtv1v/zlL7P0+fKXv9xi/2644YasU1Z87korrZRdZ1h//fXTV77ylfSrX/0qe01XRNsnvvuoo45qsvztt9/OAi3x+37gAx/I6tnRSSzy7EEHHZRuu+22Vj9z7ty52XW60nwRx1x3WLx4cdYmC3E8feELX0jL47pksSzr6Q4HPdnOo44UoMZcfvnlhci6bT2GDBnS5D1//vOfGx+vv/56p7532223bfz8E088sVAvnnnmmSZpG/9v7uGHH25M3+eee66QR5MnT25Mg3HjxrX7+vbyaDGf3njjja1+xrvvvlsYM2ZMi/ddccUVhVr1xBNPNOaV+Lsav1/83VyUC6XlRG/zhS98oXH7n3rqqVbLxEryZjXKiGr64x//2GT7OqKhoaGw9dZbt3ssz5s3r8n7mq//7Gc/22T9tdde2+o2lebV1h4rr7xy4V//+leL7T3++OMbX/OrX/2q0B1i3/r165d9ZqRFrdl3330b0+Sf//xntTcHoCZUu27RWaXnyjj/07v09nZl8+1r7bH//vu3eG8l7yutm7322muF9ddfv83XDxgwoEP1w9JHXLuo1LHHHpu959RTT233tc2/Z8UVV2zxO0Ubr0+fPk1e17wcKb220pFtbc+9995bWHvttdtMm8GDBxfOO++8Dn/2ggULCjvuuGO7aV9a9rS3LZ/4xCey9kY5e++9d/aaa665pnHZ008/Xfj4xz/e7jZ0tT225ZZbZp9zzz33NC77+9//3u7+tNbWiusa22yzTbdvZ9E555zT+JmXXnppYXlo7/rgyy+/3FiWPfDAA13+vp5o51Ff+lY7AAVddeONNzZGw4v69m2ataOHRa1raGjIepxEz6DO9oqIXic9Yfz48T3yuXlxwAEHpAMPPDDr5Xb//fdnPcdiSqVFixalPfbYI910003pS1/6Uov33X777emFF15osfzyyy9P++23X6qW6HESoyKit1FHRe+oePQ2MbKjt5YTzz33XPrNb36T/b3FFltko8hYPq655pr0l7/8Jfs7eqxFD6/o4RZl8dNPP53+8Ic/pN/97nftfk70FPzTn/6Uttlmmw59f5zb4hwXx9sdd9yRzjjjjMby/MILL8zKklLRG/GUU07J/v6f//mftOuuu6auil5+cf4pTkNYayJNrrrqqsY0iQcA1DPtysoce+yx6XOf+1x66aWXsjrg448/3tjz/9RTT02rr756m22/5jbccMPGvy+44II0Z86c7O811lgjG2EdI0reeeed9MQTT2R1x3vuuafJrBBf+9rXGv//z3/+Mx1++OGN/4964Uc/+tEmbZtKRVs07L777qmjYjTUj370o2ykS+m2/F+saPmKab9iHyINY//33nvvtO2222ajqqLuHCPoYxRWpOu3v/3tbErtGBFUiRj58tnPfjb9/e9/b1wW7fdoy8fMDPPnz09//OMfG2dsKNpyyy2z0VsxOme11VZL8+bNS+edd17j5/z1r3/N3rfjjjs2eV/sw6233pqNXiqOZlmwYEHafvvtG0fNxCwDcU0g1sconBjZFCNwou3QFZHf77vvvix/x6ipEHlyhx12SK+99lr2/9iuQw45JFsWI6CeeeaZbHtbm3rthz/8YdYWihFDkZbdKfLaJZdckv0dn9+RfNyT18gi38Wju/REO486U+0IFHR1BFAlvQZa65ERPZu/+c1vFtZdd93CwIEDC/379y+MHj066/Fw+OGHN+nV3TzCf9tttxW22mqrwqBBgwrDhg3LemhEr5Dm4jO++93vFjbaaKPstfE9G2ywQeG4445rMRqpeU/1l156Kevt8/73vz/rRdNe7+XoWVN8789+9rOsZ0v0LIre20cccUT2mv/5n/8pfP7zny988IMfzEag9O3bN9v+2OeLLrqoSQ+U0n0u94jfolzalPrvf/9b+OEPf1jYbLPNCqusskq2LTGqZY899sh66HTEK6+8kqXbhz/84aznTvSKWmuttQoHHHBA4dFHH22zB9djjz1W+P73v19Yc801s22I/b/wwguXywig5mnywgsvFMaOHdu4ftSoUVk6NTdp0qTG1+y3337ZbxV/R16I3j+Vap6vXn311cKUKVOy74003GSTTZr0LCqXfg899FB2TKy++uqFFVZYoUmvk9/97neFL37xi9nnRdoOHTo0OzZmzJjRokdTWyNxomdQ5KlPf/rThdVWWy37rPjMSIe//e1vZfft2WefLRx55JHZ8RV5Io6vyBNf+cpXsnXN9735o/hbtjdK5L777ivstddeWd6N7Yq8vOmmmxZOP/30wuLFi5u8Nn7v0h5tkTd33XXXLF1i+yZMmFD4xz/+UfHvd9ZZZzV+3g9+8IMm6zrS+yu+M/JR7HP87rEPn/zkJws//vGPs7QvtXTp0sJpp51W+NjHPpa9LvLe+973viyvxPEW6dGRMqI9d9xxR2HnnXcujBw5Mvuu+M74HWPkU7njNH6v3XbbrfCBD3ygMc9tt912hRtuuKHVMrG9HnrlHHrooY2vjXxWThy7zfN5ue+KtO7oCKDmZU3k8+K6nXbaqez2rLPOOtn6OE4XLlxY6KrS74yyq7k4t0Q+iGMjjsHicRvnmVtvvbVD31X6ezXPOx353Uq98847hZVWWil7X5zrmud1gFrXvN7RkRHQlY4AivZMvD/qAlGX2WKLLQq33357k/dEuybOm3G+i/pilL3Rtorzw+67796kJ3lr5X48PvKRj2T1lGj/RH11yZIlLd53yy23ZPWweF2cc771rW9l39/Rc0Xz/Zw7d27hq1/9amH48OGt7mfRz3/+82w0QKRJ1F3iPdtvv32LOnWMqih+xz777NO4POpSxeW77LJL4/LHH3+8cfmqq67apI6hXdl97cpymrd/SusiMWtD6bpiXbiStl85n/vc5xpff/7555d9zRtvvNHq+5u3XTo74u2RRx7J3r/xxhtX9PrS74z8WaxfFdtDcRzGSPXS9ctjBFCMOip+71FHHVW2bV30+9//Pjtu47XXX399RZ8f+a5035u3yYrmz5/fYmaA5mIkTeln3XTTTS1e8+tf/7pF2fCNb3yjyfuuuuqqVvNxMe9UMnKs+fW0uCYUy6NcLYrZDIqvj/KutfwWI/iai9EvxdkEip/d2nd3Rnx+8fN22GGHds+Rs2fPzl4XZUi0IUNcZ4tZA+I604gRI7LtjWt36623XnZeKx3l1t6MRMX83N5I2o5cQ+mpdh71RQCIug0ARaH6oQ99qM3Cu7RiV1pJiQtizYc1xyMqcs1PRtEYaO3zYwjtiy++2GpFLgJTpf/vSACo+XuLAaD2LthGA63cPncmABQVoA033LDV98eJq9IgTFTqojHZ2mdFA7C08tS8At88PYqPSit93RkAClFhK31N86ng4oQe+1RcH5WpuEBe/H8MAa5U83xVekG39FH6W7SXfsUA0He+850280gM9S5tuLd2IeLtt9/OLmi39jlR0bz66qub7FcEYaPi1tp7Yr+7IwAU6RJ5tbXPiDweeb1cJTMCysXGSOkjKpZvvvlmRb9fVPyL7/vf//3fJuva2rfS8vGnP/1pYwCx3CMCLaUVzQjytPW5EfjqrgBQpH258rT4iIp3qRNOOKHN74xKencFgI455pgmv2Wk43/+859296n0O+JCWPHvm2++udsCQF//+tfLfndcXCq+5pe//GWhK6JTQ/G3WWONNdrd13KPH/3oR1UNAIXSafw6EnwFqAU9HQCKTjnRgarc1E+lHYLamz4r6lIRuKm07VLuvB6iPliu3hCdVjp6rijdz7j4Vq6t0Xw/oyPBnnvu2ea+xvpih4O//vWvjcujA1i5C8rx3cXXX3LJJU3qZ0Xald3XruyOAFDzTjEdDQBFx7LSum4EFMt1tOnpANBJJ52UvT+eK1H6ndE5qvj3xRdfnK0/++yzG5d9+9vfXm4BoOgYFp8VHdhCHE/RZoiL6xGIiv2Ljr/FtIqplIsX+N977712P790ur64htOZDkXR1oo8VtrOinbi//t//6/Fa2OawVg/c+bMxg5NpQG16PhWic4EgKKzYiy/6667sv9HQKu0zI3tr1QEBovX3CKg3xNTh5fmuXLXSErPkdF5sNgxrPTWEe0FdSJgGJ1LuysA1NFrKD3RzqP+CACRy3sANW/glKsclfYUiAtb1113XXZxNSpfceKIXmVRYS9qfqEzRhhE7+bSHuLx+Pe//93Yg760sRQ9xOLiX/TmiN5h5e4N0bwiFwGAk08+ObvQ/ZOf/KTw/PPPt5k2zS92Ro+CaLDE9xZ7Ykdv/7iIGQ2w+L7Y58suu6yxF0w8iqMtIujQvLIb/y/OZRrzmjZPm9IKb+kIlugZFBXD2I4vfelLTSrr0fOoPZtvvnmT3yvugxP79alPfapJBaq4Tc0rF1HBixFRs2bNyno4leuVvzwDQFHRK33N9773vSbrowFTXBejLkLk0dIGZKUVz+b5Khq3cRxF+pVeGI38Vuyx1Dz94neaOnVq1lMlgleRN37zm980ec3BBx9c+O1vf5s1aEuDVzECrlw6lh6n06ZNa1weFfVo/MaokKisF4Mv8ZnF3jcxGiway6X7dMEFF2THSlSUI2hy9913N97bp7SXXfzdfD7e1gJAsZ+lwZ8vf/nLWR6Onjml3x95vVwlMx4xT3NU0KJ3X7H3UzziWKxE6XHdvGEY+1Cct7uYdqX3MorAWox+i4sXxdccdthhWc+3uIASI+GKy+N3K4qRHLEsgkbRU+vOO+/MAqxRwf7MZz7TOG92pWVEW4qNsWI6xrZFPov5mw888MBsRFhR/L7F18a2RcMueuZG+Rg9hYvr4lgJ8fuWHkvx6Mg94eI15S4yxW8fZXcEN5qPAAulr42yqvgbRgAnjttKA0DF3/MPf/hDk985eiU/+OCDZbf5lFNOaXxdpY351pQeF+V61IUYWRl5KY79aCjGbxSN79Kyv7VebMsrAHTQQQc1vrfYkAbIi54OAMUjLn5Gp6kYaVt6ET5G7r711luNnZemT5+enePiPB7nhDg3lF4Ebj7KoHnbJeooUb+MDmml5/viuTaeS+tfMVoo6idRN21+38yOBoAq3c9oz5TWj6OzSOxvPJfWGYsXxOO8X7rNxQuepXXT0g4KpcGlqNsG7crubVe2pnn7J+peUQ+L/FDaCSdm/miueV2x3KNUjBQr95roJBYzB0T9MS7693QAaPz48dn7K0230u+MYz1GycXfEUiJ+l7x+kcEKNq6AN6dAaDoiBe/fdxPpxjMKR15V3zENpamVbFsKndfzVIxmqj0c2IkTkc8+eSTZX/rGMn2l7/8pcXrIx2Ls2HEzB0hZpQofW9pu63S++/GI9pZ0amt+Dnx+xXLtmJaRrsx8mHxWkPzNn+xnVWJ6LAW74nyNAIaPREAKj3PNe8wWq5tHkGguB4WbchiGRvX/WLWjTifxPI4f8V1tNKRT8URUcV7+8T5pzQoVkzj4iio1vJ/Z66h9EQ7j/ojAETdBoBKT8RR8YmhuOWi7K2NACpWLuLEGMGF4rpiz7aokBaXxcXUuIBaPCnEa0q3qXhRu3lFrqO9mEobUXHRuZwIIsVUXjENXel2lz7igm9RJSfpcgGguLFl6UXnCDKVVmpKtzV6QFQyNL3cKIioFJWOsCj2Nm++3WeeeWbje0oDKVG5qkYAKNKg9DXNe/N/9KMfbVwXF91DVM6il0pxeWtTUjTXPF9FpaO0h39pL5gIvJRLvxhK31pPq3hEIK5U6cXquDBfPF7KXYiIdVHJLE2v0opqVOaL6+LCQvPGd0wvMmfOnDbToL0LIK0FgCLoVVwWDZply5Y1rougQ3Fd5PViMKG0khkV99KgTWklslyallN6nJZW0IvaG15e2sMoAqmlaRvpWVwXU64VRcU4lkXeiIZCsfFRTntlRDEI1/xRDA7FtI7F90Z6R++q1oKbpReEIsBd+nml0yKU9oprb3q/9kRjIPJYa+ebCEgXe4QVNW8cRyO++P/4u9IAULlHceqC1kRwsvja6GnXFXHBo/hZcUGqnPvvvz9bV5xasNw2V3pRoacCQBFgL3cuAKjXAFC0Pcqdm6PjSLn2VukF0vi7dF0EP5pPaRMdc0o7vZQ+Sqe1Ki33Y6R7ax2lihfUokNNcVnzKZHjAlpHzxWd2c/SG7DHlEHlbtoej+hMWFQapIiOCFGfLI5iL15EPPfcc7PXRueP4muLU1xrV3Zfu7It7Y1ii98s6s7lAjNtva+1OmjM0NHWLANxjaK1zkrdEQCK4EC50fZtaV7HLW1XFy/2xyM6XS6vAFBxG4qdfCJgWjy+oi4cbZlDDjmkRVoVr8k0n4mjuWjLle53tF26IwAU7bK4RtRcscNb6XTPESgqfW8EMDoq2pGlHZGjk2nzNl50UIx1kV5FEVQp/e7opFmJ6Gwar492VLHjWk8EgEpnSSk9H5U7R8Z5I6a2by7K5GhDxcibmMGntLxp7fpaW7dBCK3l/85cQ+mJdh71Z4Vq34MIuipucvfnP/+5ySNuktieuJF63NQxPPLII+njH/94dgO7cePGpd122y398pe/bPW9n/70p1OfPn0ab74XN90revXVV7PnRx99tHHZf//73+w9n/rUp7LHF7/4xSafF99fTmxHZ335y19usSxudLjppptmN2aMm1guWbKk7HuL+9AVcaPAuClk0dZbb934d9++fRtvKBgee+yxNj+rdH2k+1ZbbdX4/0j7jTfeuN3PihsmFg0fPrxb97Uz4iaOpUrz0EMPPZTd2DOsuOKK2Q0sizc1nDRpUuPrfvazn3Xqu0t/i/e9731pvfXWa/K7VZoXS9O69DND6c3uY19feeWVVrcn1seNM4umT5/eeKzEI26O2fxYKT2+xo8f32QfulPpPkaejd+j3D5GXi+XdnHDzw984APdlvc6c0PV0rSaPXt2k7Q98cQTG9fFzTujrArf+ta3sue33noru+Fp3LT0/e9/f3YcxU1rO3LzzsjLpd9ZfPz2t7/N1sfNS1dZZZXs73POOSetueaaWVn8kY98JLu5bWm6lu7LLbfc0uTz4maY7ZWpnfGd73wnS5vzzz8/K1dLf8/w/PPPZzeSbcs+++zTWE5FmseNXTvrwQcfzG4g25qeuuluuc/9wx/+kB37119/fXruuefS0qVLy763WuVsUTVuRAzQm0Udsty5udz5JeqoG220UeP/4++hQ4c2/r94np45c2bWtorzc9xEvKGhoex3F28iXmldvfQ8UlonGDVqVPrgBz/Y+P/S9kFnVLqfldZ/S18XN0ovihuh/+Mf/0hvvvlmdpP1Aw88MFt+9913pzlz5qT/9//+X/b/WLfhhhtmf2tXdl+7siviN4t2ybJly9p83QEHHNDi+kQ8mou65b///e90+umnp89//vNZXbtU1GejXdRTfvGLX2TPu+++e6c/I9qIY8aMyf7+6U9/2nidZZdddknLS9TFwyabbJI9P/3009lvFeXDxRdfnHbaaad0ySWXpLXWWqvJ+4pl1Hvvvdfm55e208PChQs7tH2RPvH7R7350ksvTR/72Mca22Wf+cxnmhzf4aabbmrxu3R1G2Jf4zrC//7v/2b/j7bz7bff3uJzu+u7o03wta99Lfv7tNNOa/xtql3nX2edddKHP/zhFssPOuigNGXKlKx8jv0rLW+6uz3TlWso2jR0hQAQNS8CGlFwlj7WXXfddt8XgYSbb745awDtueee2UXklVZaKc2dOzcL/kRlJioM5cTF0FJR8WxeKBcDRJVYvHhx2eWjR4+u+DMqee9ll12WBYFCXGCNQNAf//jHrEIS+1/UXiWoFpX+ZqW/V7VEhavUZpttVjawE5WPaABGfopHVBqLIv++/vrry2V7u5IX29Mdx0pvVUlZ0Z7SxmBnKp6dSd9jjjkm/f73v09f//rX0+abb57tR1RA77zzznTkkUemfffdN3WXD33oQ1kD94QTTkg77rhjFgCKAEkEQi+66KK0xRZbpBdeeKFD+9Ld+SSOwSOOOCJrFMW2/Otf/2pyseG+++5r8/3RUeDUU0/N/n722WfTj3/844q+NzokRD6Jhm2xIb1o0aK01157ZY3bckobZSNGjEhd0V7eO/PMMxsvgsR595prrskaTnfddVeT11V6Tin9fUsvrjQPmHdUd6YJQC1ZnheL4iJfUdQd4uJytDGuvfbais4JbdXVa/2iV2kAKAI98Qjbbrtt9giRVtEuKxcQ066sjssvvzy7kB31v+iIF6IDU9SF2zJ27NgW1yeaX+gtvSAd9e5bb701a6dHnTLqxpXWMbuieLG/K51O41j95je/2WTZYYcdltV9l7diR71iR7VVV121yTFU7HBW9Otf/zp7Lg0klzNo0KC0wQYbNP4/AjkdKZMi78TvH8d0BBqinjxgwIDG+u7Pf/7zJuVjtPFjX3bdddfG5VHPLt2f5tcS2hLXE6IzWuSxYvsi9qF5nTiC81EGRQB+woQJjcsjYFVaBlXy3dGJsBi8iM50xWsZzYNw8f9Y3pVrGh1pK5e7phEdFq644orG/3/1q19Nv/vd77Iy+Xvf+16vukamTUNXCABRt+Kk3b9//6yHznXXXZcefvjh7KJhaSPl6quv7vTnl1YSotdE9Kz//0272OQR3xkBqHI6Utmv5L0R3CqKXv1ROYuTe/SCKF5gba555a3SE19UXEtHS9xzzz2Nf0dFp7QyW5pW5ZSujzS79957G/8flYW4GFvpZ/UGkdbf//73m/Rg3HnnnbO/48J3XEStRFRuSyuMlSr9LaISET3PiloLnpbLT6VpXfqZobSXW1TKYqRRa2JdacUtjsFyx0o0wKJXaSj2iAwRPCg3+qa0Yl6ajztSeSvdx/vvv79Jb6DSfYy8XtpY606lwdnS36rSfSvdh+gBVy5ti2XRyJEjs9fF/+O1P/nJT7KejsV8svLKK2frI0geFfvm319uG6KMKfd9+++/f+N3RUMkejhGgyJG27zxxhvpS1/6UmNj5De/+U2LfTnkkENa3ZfS3lKdLcNC7Hu5sjF6Be+xxx4d+swY+bnllltmf5eWYZX2HLzyyisbe0RH2sfFgnKi93C5vNMZMWqpeOyXy3ul55QYrRWjFaMHeWnZ3xGlPQxL073YQO+s7kwTgN6s2BO+XDldWi866aSTyp4/oxNGc3EejpkDSnsvl16sK9YdS7/r+OOPzy4qx0XP9kZLdERpPTVGykSdoaij59bO7mel9d/S10UdcY011sj+jg4cxfp7BH/ivBTn97hwWdr5sDRopF3Zfe3KjorrBTEC/Nhjj21cFh3yujraPIIAzS9WR50rOj4VZynpyYvO0SHp73//exb8+OhHP9qlzzr44IOzIEmIIEVxVNvyUhydH9dzikG1qP9HZ7K4zhPXYaIeXVwfHYtiRH5c9I/RSsUROW0ptlvCU089lc4444yyr4s2SHEUX2uzrRSDIUWl5Ux0pIqZMaJsKG0/9+vXLwtMFEWnvNi3cmJUfoyAClGuR4e+G264oTEAEqOAiqO2Ss2aNSsbKTRx4sQmQfi4VhHXjoquuuqqsiPaQul1meWlvbZyR66RhZhVIvY3zl9tjXbqjusLHb2Gok1DV1S/GzxUSfSwiR7c0bMihqTGyTBOCLfddlvja4oXODsjerJH7584oUSDInp8RO+Y6EkeJ/VosEQPizhZRA+M5aG0d0uc+OPkPWTIkHT22We3Oh1D9MaLdCk2GuOEGD3R44QXvfuiUlxOTJkQF3CLQ8uj50dcwI80iREuUTEJ8TmTJ09u96QeI2QeeOCB7P8RtDvllFOybT/33HMbe/vHxenSi7I9JdKq3MXXuHh59NFHt1geeeAvf/lL1nM/GiiRhsXKRKTtjBkzGivNEeAoroveQuedd16Lz4uL5L/61a8ae6bFcOWOiEpgjEaI7Y0pt4r5PHoilfY0ak9U7otTJUZl9dBDD80qjNEgis8trTC3FcyMdfFZxYp0fE7kj2iMRJ6Jixl/+9vfsrSJ57g4EUHTmOox0jSCZnF8RdrHcPaodEePtpiWq9irsnQqkahYRUAh8k9UaKOR0JrY9pieIY7TOGZj5EUsi20qbQhGwzA+rydEAKXYYyumCojpJEuV7lv0YIoGThzrMaIxpraM4yXyUexDlG/ReIgpAOJ4efHFF7OKcvRyit++OCVcTKMSDaKo+EaZFSMGo5FYbMjEZ0UAMr6js2VEUeSVuMAfQdDoBRaV3Wg8lQ6PL+bRmEqg2FsxglPx2TF1QjzHbxLvic+K36bYUGs+jUykRWxXbF9708VEusSxEvkryvSosMdx+eSTT2ajX4qKgZ32/PCHP2wytL8j4ng96qijGqc4jXSIhm3zKRWKUybGb9LZ7yqKRkcEu6IxF+kbx1YcM0WRz4oNrbgYEsdmXMwoDXA3F1MERZ4MEfiLCxBFcfwWp7+M3yl6akYwMM5Rnfm8EA3ZmGonxDEaUwsC5NV//vOfbHRCTCcVHVdKR2TGFKLR5igNLFQqpgOKoFGcW+K5KHqQb7fddo3nhGIAJcrwuGAZwY62zgkdFef8aGPEBdOod8R2xedH/aS0XtZZlexn1FmL55XotBUXUuN8G3Xh0o6EzS+CR7pHvT0Uz3VRT43vis4T0eu/dCqo0t9Ju7L72pWdFcdVtAminhP14KgztzZlfLHt11xsbzyK9ZeYQjeCPVG3j/ZIHDNRtyudDaLSOmY1Rv8URVsgpn+LDnlRb2w+0qanRVspjqPYhmjnxPfHFNORxl/5yleabGf8fsXrBdF+iPZEJaOVoqNTBFGiPRSmTZuWtUvjs6J8iKBSjOyLDsRxLEd9OT47fst4TQSBo00S9elo+5dOp106q0Bbv0t0lou2SbGuG/t6xx13ZO2uKBdjCs/4fwSGoiyOdIi2Q7HciSBq5Nt4Xel0n3GdJa4DtPXdkffjnBLXQaJuHWXxN77xjaycKs6iE+3ruEYRQdlYVu46RqR/XMcp7SwQv0u8vrNKRytFW7mjmo8Ai3PJF77whSzIVky7ckrbmDEyMNrNcU0n2iPFgH93X0PpznYedajaNyGCjmp+s85KbhxX7gaJ8+bNa/dGjRdccEFFN3lr7cbVcXPsYcOGtfkdpTc97OrNytu6gXbxhqqrrbZai20YPXp0Yf311291/7baaquy2/7888+3mTbz588vbLjhhq3ue9z08sILL6xo3/79739nN5Rt7bPi5uM33XRT4+vbusFgZ9K5vRuzN7+5X3uvjceQIUNa3HTyc5/7XOP6uGFsOXED+I7cYL35/n7sYx8ruz3nnXdeRelXaurUqW3uY9xIccmSJe3ejLj5TSlbe5RuR9zsd/Dgwa2+tvRmqHGzynKvOeigg8qmUakoB9q6QWvk8cjrXbkZc1viRs3F799yyy1brH/ttdfKpsPaa6/d+JpLLrmk7M0sSx+lx27cDLat1zbPm+2VEW05/fTT2z1O5s6dW/bmmK09Ssu/uKnn2LFjW7wm0qM9pb9la4+hQ4c2uWl0aH6D3NZuVFouv5XmkeY3zF20aFGTc8rEiRObrH/88ccb1+24446F7vCDH/yg8TN/8pOfNFl3++23l02TT3/6060ei23dEPi+++5r9SbInfm85jcFj5sTA+RNW+equPn2oEGD2iwnyyktW+M8PGrUqBafHXWT0rp3nCMqOSeU1uXaaru0Vu5fccUVZb+ned2l9D2V7Ge0kdZcc8129/Pdd98t7LHHHm3WDfbcc8/sdaWuueaaJq8ZOXJk47rzzz+/yboNNtigxbZqV3Zfu7I1zds/zfPkySef3ORm8v/85z8b17VXX2xe166kbRn117hmUU7ztksl+b3UJz/5yex9f/3rXzv0vrbquM21VUcrvX7QvL3UGcX69UUXXZT9f+HChU2+Y7vttsvqgcW8Ev+PNnVHRHsv6tft/W7F3yLa1u29NtpUxbLivffeK3zgAx/Itq+13/3pp59utS1frpwtLWPbeu0bb7yRXU+Jds3SpUvLfvff//73rH3Z3ue1pdJrDB0R6fahD30o+7yVVlopay+VaqttXrT33nuX3ZfIJ63l4Z/+9Kdl33PKKae0m/87eg2lp9p51BdTwFG3opfED37wg6zXefRajt7w0Ssiep9HT4boORE9PbriE5/4RNZz+rvf/W42iiV6BETviugVED2+Yq7s0huX97SY3il6GcTUTrH/8YiRCzH0tDj1UzkxUih6QXR0hEOkZfTCiBtbxr2aIo1jOHGMKIieMNEzKqahq0T0molh29Ejo5iW0Wsn0jJ6f0dvnNiX3ip6FsX+xwiHSP8YuRS9NEtvsBijN0rn1G3thpzRS6fYe6x4b6eOiJFnke4x6i3SMNIzfuP25rMuJ3rmR4+XyB/R+yl+38gn0VstprGIkWat9egp7dESoypi36OXVPSCix418VmRh2KEQ/Qwiu8p7U0TPeaip0wcpzEyI/JEfE4czzFSp3SO4TimL7jggiwfdfQeUPH5kVdj1FFMMRC98+K3jOkC4hiOPN78pq3dKX7r6MlbnN6kdLqTEMdx9DSL8qY4P3lzkX7RYyh6w0W6RDkU+xDTmcRvF/ekKZ2/O3q1RRrGiIz4/Mi/0Yss8l4cz83n8+9sGVH8HSONY1RO9JaLPBnbF72x4tiO9C393WNETvTIiuOj+HvE966//vpZuRLbUloWRLke6RM9d4tT2HVkSotib8KYKjPKycg/kddiGsI4jqKnZulNo9sT6dfZedFjWo24F1HpVA3FnoihdPrI6E3WHWLUVaRxuWlRo0dybEMcC3GcR9ke5UhxqsaOimlPYh8ibeM7i5/X2jQTlSidJrO70gSgt4qpO2PUapTJUeeJHt1RT4w6X5y7Su85WamoB0TP76gHRU/tOEdHnSN6e5eeb2OEeZwz45xYrI+dfPLJFd/3rlJRl4le5jHKOeoMUQeL+2p05VwRop4T9az4/KiHtrafcQ6PkRtxvor6ZaRJ1DXiOdI+zpXRjmx+ro91pXXfGPVTVByxXlRulJZ2Zfe1Kzsr6qtxPISIhcT9KzsrRj7EvS6jPhv1nhh1Hfko8mGMVo66eIw0Kx153V1iBoA4pqONEfXvPIiR+VHuRT05RspE/ogRkDEqKerq0SaNGTxi9F2Mhoy2REfLwyhrYjaFaJPGtMfRVolyNb43Zk6I6Z5jJoY4VkO0PaINFrNaFNvJxbIxRtnEiLYoo4tlRcwUEr9NzFDQ2u8e3xltuihjolyKNlJ8ZuxvlPlRTsdnlpvirS0xg0KMqov2XGuzN0R9P65tRTkf19CK1xKiHRZt8Wi3xT1kl7coV2Nq8OKsEcWRTB0R+xQjC+PaUqRnHINRzsf5oK2RPDECNY6jjk5/3ZlrKD3RzqO+9IkoULU3AoCeE5Xf4rQVoZrFflR2i0Oe46aKrc2fTFMxxUA00OK3iwvi5YbUU9+iwRPBvZjeNBotERjqrhvwxgWPuEgRouFcK9OoxfQW0VCOaTaiUR7BKoC8ianK4oJnMZBQOu0bbWtvGlHIo6jTRd0ub22KCKjElG8xBVl0EosgTQRjIqAbU8bHtGgRwIngT1yAj+nRepOpU6dmnURjurXSDl/Ls40eneZiOrJaE/d5io6NUfePgFtxms686Ml2HvVDjgFguVRa4sJxzI1cFL3dqEz0dCze+DN60sZ9xKB5z7VoFIRo1HZnoyDmCy/2eC2dt7u3O+uss7LgT/SqK71nEwBAvYrRJVG3K46ayIsYTRX3wIlRMTGSJuqBsSw6QsZIi+h8GCMrolNQjBrsbWI2g/hdYhTP8haj8KMzQcxUUovifrXFNkpcc4gRTXnSk+086ocRQAA51xtGAMXNGUuDP9GDJXphxfQaAAB0jhFAnWcEEORPTGUWx3aMZonp3hYuXJiNAorptWJ651oNcgB0RcduhAAAXRD3MIlg0DnnnCP4AwAAQLeJDoYxuilvI5wAusIIIAAAAAAAgJwxcSAAAAAAAEDOCAABAAAAAADkjAAQAAAAAABAzggAAQAAAAAA5EzuAkBvv/12evTRR7NnAACAPNLuAQAA6i4A9PTTT6eNN944ewYAAMgj7R4AAKDuAkAAAADd5ZVXXkkHHnhg2mSTTdLw4cPTwIED01prrZX22muv9I9//KPiz1myZEk65phj0pprrpkGDBiQPU+bNi1bDgAA0BP69sinAgAA5MDrr7+e5syZk3bYYYc0bty4NHjw4PTss8+mmTNnpk984hPp1ltvTTvttFObn/Huu++mnXfeOd19991p3333Tdtss0166KGH0llnnZVmz56d7rjjjrTCCvrmAQAA3UsACAAAoBXrrLNOuvfee1ssP/TQQ9PYsWPTGWec0W4A6IorrsiCP4cddli68MILG5fHKKDvfOc76eqrr0777bef3wAAAOhWupkBAAB00MiRI9NKK62UjRBqz5VXXpk9T506tcnyKVOmZJ9RXA8AANCdjAACAABoR0NDQ1q0aFFatmxZmjt3bjrnnHPS4sWL0y677NLm+wqFQnrggQfS6quvnk0hVyqCPx/5yEey9QAAAN1NAAgAAKAd99xzT9puu+0a/z9kyJB09NFHpxNOOKHN97366qtpyZIlaeONNy67fsyYMem+++5Lb7zxRlp11VXLvmb+/PlpwYIFTZY99dRTjYGpeAAAAPnXr1+/Dr1eAAgAAKAdm2yySbrjjjvS0qVL0xNPPJGuuuqq9Oabb2b/79u39WZVBH/CgAEDyq4fOHBg4+taCwDNmDEjTZ8+vey6GJW0cOFCvx8AANSBUaNGdej1AkAAAADtGDZsWNphhx2yvz//+c+n/fffPwsK/ec//0m/+93vWn3foEGDsucIFJXz9ttvN3ldOXGvoEmTJrUYAbTrrrtmI5GGDx/u9wMAAFoQAAIAAOhEQOiLX/xiuvjii9Ozzz6b1lxzzbKvW2211bLgzgsvvFB2fSyPkT+tjf4JI0aMyB6tTQHR0WkgAACA+rBCtTcAAACgFr311lvZ82uvvdbqa/r06ZM23XTT9NJLL6XnnnuuxfsffPDBtNlmm/X4tgIAAPVHAAgAAKAVL7/8ctnlMern5ptvzqZg22CDDRrv4zNnzpw0b968Jq/dd999s+dzzjmnyfJLLrkkCwIV1wMAAHQnU8ABAAC04vTTT0933HFH2nnnnbNp3mJEz+OPP56uvPLKtHjx4nTFFVekgQMHZq+dPXt22m677dLkyZPTzJkzGz/jgAMOyF5/0UUXpUWLFqVtttkmPfTQQ2nGjBlpwoQJaZ999pH+AABAtxMAAgAAaMUuu+ySXnzxxfSLX/wizZ8/Py1btiyNHj06W37EEUekzTffvN20W3HFFdNvf/vbdPLJJ6frr78+XXvttdlnTJ06NZ1wwgnZegAAgO7Wp1AoFFKOPProo2njjTdO//rXv9JGG21U7c0BAADodto9AABAe9wDCAAAAAAAIGcEgAAAAAAAAHJGAAgAAAAAACBnBIAAAAAAAABypm+1NwAAAOrJO8sKae7ChlTrxg7vl/r37VPtzQAAeplCwzup4eW5qdb1Gzk29enXv9qbAdAlAkAAALAcRfBn4kXzaj7NZx02Oq0z0kURAKCpCP7Mmzax5pNl9OmzUv8x61R7MwC6xBRwAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADnTt9obAAAAAEDtKzS8kxpenpvyoN/IsalPv/7V3gwA6BIBIAAAAAC6LII/86ZNzEVKjj59Vuo/Zp1qbwYAdIkp4AAAAAAAAHJGAAgAAAAAACBnBIAAAAAAAAByRgAIAAAAAAAgZwSAAAAAAAAAcqbqAaA33ngjnXLKKWn8+PFplVVWScOHD0+bbbZZuvjii1NDQ0O1Nw8AAAAAAKDm9K3mly9btixtv/326R//+EeaPHly+ta3vpWWLl2abrrppuzv++67L1199dXV3EQAAAAAAICaU9UA0F133ZX+9re/palTp6azzz67cfk3v/nNtOmmm6Zrr702XXLJJdnIIAAAAAAAAGpgCrhFixZlz6uvvnqT5SuuuGIaNWpU9ty/f/8qbR0AAAAAAEBtquoIoK222ioNHjw4/fCHP0xjxoxJW2yxRXr77bfTDTfckG677bZ08sknpwEDBlRzEwEAAAAAAGpOVQNAMcpn1qxZ6dBDD0177rln4/KBAwemyy67LB1wwAFtvn/+/PlpwYIFTZY99dRT2XNDQ0P2AACA3qJv36pWv7tdoVDI7uvZG/Tr16/amwAAANCrVL0FOmTIkLTeeuulCRMmpM985jNpyZIl6Yorrkhf//rXU58+fdL+++/f6ntnzJiRpk+f3ur0cgsXLuzBLQcAgI4ZPnx4rpIsgj+9pc4dncsAAADoJQGghx56KG299dbpyCOPzKaBK9pnn32y6eG++c1vps9//vPp/e9/f9n3T5kyJU2aNKnFCKBdd901CyzlrYENAEAeRgA15Gp/1LkBAAB6p6oGgC644IK0dOnSFkGcFVZYIe2+++7p/vvvT7Nnz86CQOWMGDEie7Q2BYRpIAAAoOfEiH11bgAAgN5phWp++Ysvvpg9v/vuuy3WFecS7y1zigMAAAAAANSKqgaANtpoo+x55syZTZY3NDSkn//852nFFVdMm266aZW2DgAAAAAAoDZVdQq4uPfPVVddlS655JL0wgsvpJ122iktWbIkXX311enhhx9ORx11VPrABz5QzU0EAAAAAACoOVUNAI0dOzY98MAD6ZRTTkl33HFH+t3vfpf69++fNt5443TppZemAw88sJqbBwAAAAAAUJOqGgAKa665ZrrsssuqvRkAAAAAAAC5UdV7AAEAAPRWTz75ZDrppJPSVlttlUaNGpUGDx6cNtxww3T44YenefPmVfQZcb/TPn36lH243ykAAJDrEUAAAAC9UcxU8KMf/Sh94QtfSHvssUdaaaWV0v33359mzJiR3bf03nvvTeuvv35Fn3XsscemDTbYoMmy4cOH99CWAwAACAABAACUtfvuu6djjjkmDR06tHHZwQcfnLbYYot0yCGHpBNOOCHdcMMNFaXejjvumCZMmCClAQCA5cYUcAAAAGXEFG2lwZ+ivfbaK3t++OGHO5RuixcvTkuXLpXWAADAciEABAAA0AEvvvhi9jxy5MiK3zNx4sS0yiqrpIEDB6Z11103nXnmmWnZsmXSHQAA6DHuAQQAANABxx9/fPZ8wAEHtPvaQYMGZfcP2mGHHdLo0aOz4NFVV12Vjj766PTnP/85zZo1K62wQtv98ubPn58WLFjQZNlTTz2VPTc0NGQPgGrr2zd/l5gKhYJgfZ3nA3kA6G369evXodfnq1QGAADoQaeddlq66aab0q677pomT57c7usj+BOPUnEfob333jtdd9112T2EilPKtWbGjBlp+vTpZdctWrQoLVy4sIN7AdD9hg8fnrtkjZGaytj6zgfyANDbjBo1qkOvFwACAACowAUXXJCOO+64NGHChHTNNdekPn36dCrd4n0nnnhiFgC69dZb2w0ATZkyJU2aNKnFCKAIQg0ZMiR3F9uA2h350ZDDfVLG1nc+kAeAWicABAAA0I5zzz03TZ06NW2//fbplltuyaZ264q11lqrcXq39owYMSJ7tDYFREengQCg8oC9Mra+yQNArWt7smkAAIA6d8YZZ2TBn89+9rPZiJ2uBn/CE0880akpHAAAAColAAQAANDGPX+OOeaYtMsuu6Sbb745DRw4sOzrlixZkubMmZPmzZvXZHm5e0fE/QSmTZuW/R3TuAEAAPQEU8ABAACUcfHFF2f3/Bk5cmT68pe/nG688cYm61deeeXGAM7s2bPTdtttlyZPnpxmzpzZ+Jrx48enrbfeOnsePXp0eumll7J7/zz++OPZvX++9KUvSXsAAKBHCAABAACU8cADD2TPL7/8cjrwwANbrB83bly7I3j23nvvdPfdd6c777wzLVq0KA0ePDh9+MMfTpdffnkWLIp7CwAAAPQEASAAAIAyYiRP6WietkyYMCEVCoUWy88++2xpCwAAVIV7AAEAAAAAAOSMABAAAAAAAEDOCAABAAAAAADkjAAQAAAAAABAzggAAQAAAAAA5Ezfam8AAAAAAOTBO8sKae7ChpQHY4f3S/379qn2ZgDQBQJAAAAAANANIvgz8aJ5uUjLWYeNTuuM7F/tzQCgC0wBBwAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDN9q70BAAAAAAB58M6yQpq7sCHlwdjh/VL/vn2qvRlAFwgAAQAAAAB0gwj+TLxoXi7SctZho9M6I/tXezOALjAFHAAAAAAAQM4IAAEAAAAAAOSMABAAAAAAAEDOCAABAAAAAADkjAAQAAAAAABAzggAAQAAAAAA5IwAEAAAAAAAQM4IAAEAAAAAAOSMABAAAAAAAEDOCAABAAAAAADkjAAQAAAAAABAzggAAQAAAAAA5IwAEAAAAAAAQM4IAAEAAAAAAOSMABAAAAAAAEDOCAABAAAAAADkjAAQAAAAAABAzggAAQAAAAAA5IwAEAAAAAAAQM4IAAEAAAAAAOSMABAAAAAAAEDOCAABAAAAAADkjAAQAAAAAABAzggAAQAAAAAA5IwAEAAAAAAAQM4IAAEAAAAAAOSMABAAAAAAAEDOCAABAAAAAADkjAAQAAAAAABAzggAAQAAAAAA5IwAEAAAAAAAQM70rfYGAEC9KDS8kxpenptqXb+RY1Offv2rvRkAPe7JJ59M11xzTbrjjjvS008/nd588800bty4tMMOO6Rp06al0aNHV/Q5S5YsSSeffHK67rrr0rx587L3feUrX0nHH398GjRoUI/vBwAAUJ8EgABgOYngz7xpE2s+vUefPiv1H7NOtTcDoMdddtll6Uc/+lH6whe+kPbYY4+00korpfvvvz/NmDEjXX311enee+9N66+/fpuf8e6776add9453X333WnfffdN22yzTXrooYfSWWedlWbPnp0Fl1ZYwcQMAABA9xMAAgAAKGP33XdPxxxzTBo6dGjjsoMPPjhtscUW6ZBDDkknnHBCuuGGG9pMuyuuuCIL/hx22GHpwgsvbFy+5pprpu985ztZIGm//faT/gAAQLfT1QwAAKCMTTfdtEnwp2ivvfbKnh9++OF20+3KK6/MnqdOndpk+ZQpU7IRRcX1AAAA3c0IIAAAlpu83AsruB9W/XrxxRez55EjR7b5ukKhkB544IG0+uqrZ/cOKhXBn4985CPZegAAgJ4gAAQAwHKTl3thBffDql/HH3989nzAAQe0+bpXX301LVmyJG288cZl148ZMybdd9996Y033kirrrpqq58zf/78tGDBgibLnnrqqey5oaEhewBUW9+++bvEFIH8ZcuWVfx6aZC/NJAHOp4GEFZcccXUp0+fXB0H7777buoN+vXr16HX56tUBgAA6EGnnXZauummm9Kuu+6aJk+e3OZrI/gTBgwYUHb9wIEDG1/XVgBoxowZafr06WXXLVq0KC1cuLADewDQM4YPH567pI2L3h0pY6VB/tJAHuh4GkCxLCj06ZvmLqz9jkpjh/dLfQrv9prjYNSoUbUXAIoeb2eeeWbWkHr22Wez6RDWXXfd7Eap++yzT7U3DwAAIF1wwQXpuOOOSxMmTEjXXHNNu70aBw0alD0vXbq07Pq33367yetaE/cLmjRpUosRQBGEGjJkSO4utgG1KUZ+1P5lvpb71JEy9v9Gv+QrFTqTBnlKAXmg42kAxWPn6fkNaeJF82o+QWYdNjqtPaJfzR4HfXvD/NnbbbddeuWVV9L++++fNtpoo/Tf//43PfHEE+m5556r9uYBAACkc889N02dOjVtv/326ZZbbmk3aBNWW2217HUvvPBC2fWxPEb+tDX6J4wYMSJ7tDYFREengQCgMhHor/cytt7ToN73P0gDSDV9HFQ9ALTffvulN998Mz300ENpjTXWqPbmAAAANHHGGWekY445Jn32s59Nv/rVrxqnbqukobjpppumP/3pT1nntnHjxjWue+utt9KDDz6YttxyS6kNAAD0iBVSFd1zzz3pzjvvTEcffXQW/IkbKS1evLiamwQAANDknj8R/Nlll13SzTff3GrwJ+7jM2fOnDRvXtNpLvbdd9/s+Zxzzmmy/JJLLsmCQMX1AAAAuRoB9Jvf/CZ7XnvttdNuu+2Wfv3rX6eGhoY0evTobJ7radOmpRVXXLGamwgAANSpiy++OLvnz8iRI9OXv/zldOONNzZZv/LKK2f34QmzZ8/OpraePHlymjlzZuNrDjjggHTllVemiy66KC1atChts8022ewHM2bMyO4l5J6nAABALgNAjz/+ePZ80EEHpbXWWitdeuml2TQJ0Rg6/vjj09y5c9NPfvKTVt8/f/78tGDBghY3Qw0RSIoHAPQG/3dD2PwoFApp2bJl1d4MakzejoPOHAt5S4PeVBb0xJzcDzzwQPb88ssvpwMPPLDF+pjSrRgAak10aPvtb3+bTj755HT99dena6+9NuvwFvcTOuGEE3R4AwAAekxVW6Bx758wePDgbF7sAQMGZP/fc88904YbbpgFhKJhtN5665V9fwSKpk+fXnZd9K5buHBhD249AFRu+PDhuUquuODrPEu9HwedORbylga9qSwYNWpUt39mjOQpHc3TlhjNEwGxcmKk0Jlnnpk9AAAA6iIAtNJKK2XPe++9d2PwJ/Tv3z999atfzXrJ/fGPf2w1ABTTxE2aNKnFCKDohTdkyJDcNbABqF3R678hZ/vjPEu9HwedORb+bwRQflJBWQAAANB7VTUAtMYaa2TPMQVCc8Vlr776aqvvHzFiRPZobQqInpgGAgBI2ZStzrPgWFAWAAAA9F4rVPPLt9hii+z5+eefb7GuuCxuuAoAAAAAAECNBIAmTpyYhg4dmq666qrG+wGFxYsXpyuuuCLrWfyZz3ymmpsIAAAAAABQc6o6BVzcp+eCCy5IkydPTptttlk66KCDsmkkfvazn6UXX3wxnXrqqY3TxAEAAAAAAFADAaCw3377pfe///3phz/8YZo+fXp677330vjx49O1116b9tprr2pvHgAAAAAAQM2pegAofO5zn8seAAAAAAAA1Pg9gAAAAAAAAOh+AkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOdO32hsAAAAAAAB5UWh4JzW8PDflQb+RY1Offv2rvRl0kgAQAAAAAAB0kwj+zJs2MRfpOfr0Wan/mHWqvRl0kingAAAAAAAAckYACAAAAAAAIGcEgAAAAAAAAHJGAAgAAAAAACBnBIAAAABa8cMf/jDtueeead11100rrLBC6tu3b4fTaubMmalPnz5lH5tuuqm0BwAAekTHWy8AAAB1Ytq0aWno0KHpox/9aFq8eHFasGBBpz/r2GOPTRtssEGTZcOHD++GrQQAAGhJAAgAAKAVTz31VFp77bWzvydMmNClANCOO+6YfQYAAMDyYAo4AACAVhSDP90lRhEtXbpUegMAAD1OAAgAAGA5mDhxYlpllVXSwIEDs3sKnXnmmWnZsmXSHgAA6BGmgAMAAOhBgwYNSnvssUfaYYcd0ujRo9OLL76YrrrqqnT00UenP//5z2nWrFlphRVa75s3f/78FlPPxdR0oaGhIXsAVFvfvvm7xFQoFDoUqJcG+UsDeaDjaUD+joNQ78dCoRcdB/369evQ6/P1SwAAAPQyEfyJR6mDDz447b333um6665LN9xwQ9prr71aff+MGTPS9OnTy65btGhRWrhwYbdvM0BHDR8+PHeJFhf7OlLGSoP8pYE80PE0IH/HQaj3Y2FZLzoORo0a1aHXCwABAAAsZ3369EknnnhiFgC69dZb2wwATZkyJU2aNKnFCKBdd901DRkyJHcNbKA2RW/vhhzuU0fK2P/r8Z6vVOhMGuQpBeSBjqcB+TsOQr0fC31r+DgQAAIAAKiCtdZaq3GKt7aMGDEie7Q2BURHp4EAoPJgfb2XsfWeBvW+/0EaIB+kmj4OWp9oGgAAgB7zxBNPdGoaBwAAgEoIAAEAAHSDJUuWpDlz5qR58+Y1WV5uvvCYR3zatGnZ3zGVGwAAQHczBRwAAEArrrrqqvTcc89lf8dzoVBIP/jBDxrXf//732/8e/bs2Wm77bZLkydPTjNnzmxcPn78+LT11ltnz6NHj04vvfRSdu+fxx9/PLv3z5e+9CXpDwAAdDsBIAAAgFZcdtll6e67726y7Pjjjy8bAGrN3nvvnX3GnXfemRYtWpQGDx6cPvzhD6fLL788CxbFnOIAAADdTQAIAACgFXfddVfFaTNhwoRshFBzZ599tvQFAACWO/cAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADImb7V3gAAoD68s6yQ5i5sSHkwdni/1L9vn2pvBgAAAECrBIAAgOUigj8TL5qXi9SeddjotM7I/tXeDAAAAIBWmQIOAAAAAAAgZwSAAAAAAAAAckYACAAAAAAAIGcEgAAAAAAAAHJGAAgAAAAAACBnBIAAAAAAAABypm/qZd5777205ZZbpr/+9a9p++23T3/4wx+qvUkAAAC0odDwTmp4eW4u0qjfyLGpT7/+1d4MAADIXwDo/PPPT48++mi1NwMAAIAKRfBn3rSJuUiv0afPSv3HrFPtzQAAgHxNAfef//wnHX/88ekHP/hBtTcFAAAAAACgZvWqEUBf//rX00YbbZQOO+ywdOSRR1Z7cwAAAAAA6ABTw0Lv0WsCQD/96U/Tn/70p/S3v/0trbBCrxqYBAAAAABABUwNC71HrwgAvfTSS+m73/1umjp1atpkk00qft/8+fPTggULmix76qmnsueGhobsAQC9Qd++veKU220KhUJatmxZ3e5/Z9IA+SCPx0JvOg769etX7U0AAADoVXpFC/TQQw9N73vf+9KJJ57YoffNmDEjTZ8+vey6RYsWpYULF3bTFgJA1wwfPjxXSRgXfDtyns3b/ncmDZAP8ngs9KbjYNSoUdXeBAAAgF6l6gGg6667Lt1yyy3pjjvuSCuttFKH3jtlypQ0adKkFiOAdt111zRkyJDcNbABqF3R678hZ/vTkfPs/416yFMKdDwNyN9xEOr9WHAcAPz/vbOskOYuzEcZP3Z4v9S/b59qbwYAUMsBoKVLl6bDDz88feYzn0lrrrlm4/RtRW+99Va2bJVVVkkjR45s8f4RI0Zkj9amgDANBAD0jD59+tT9eVYa4FhQFgCUiuDPxIvm5SJRZh02Oq0zsn+1NwMAqOUAUAR44h4+t99+e1p33XVbrL/33nuz5XvuuWc2UggAAAAAAIBeHgAaPHhwuvHGG8uui6ndxo8fn0444YS0xhprLPdtAwAAACpXaHgnNbw8t+aTrN/IsalPP6NfAIDaV9UAUEzRtvvuu7e6PqZ3a2s9AAAA0DtE8GfetImp1o0+fVbqP2adam8GAECXrdD1jwAAAAAAAKA3qeoIoLYUCoVqbwIAAAAAAEBNMgIIAAAAAAAgZwSAAAAAAAAAckYACAAAAAAAIGd67T2AAAAAoFa8s6yQ5i5sSHkwdni/1L9vn2pvBgAAXSQABAAAAF0UwZ+JF83LRTrOOmx0Wmdk/2pvBgAAXWQKOAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAACAVvzwhz9Me+65Z1p33XXTCiuskPr27duptFqyZEk65phj0pprrpkGDBiQPU+bNi1bDgAA0BM613oBAACoAxGkGTp0aProRz+aFi9enBYsWNDhz3j33XfTzjvvnO6+++607777pm222SY99NBD6ayzzkqzZ89Od9xxRxZcAgAA6E4CQAAAAK146qmn0tprr539PWHChE4FgK644oos+HPYYYelCy+8sHF5jAL6zne+k66++uq03377+Q0AAIBupZsZAABAK4rBn6648sors+epU6c2WT5lypS00korNa4HAADoTgJAAAAAPaRQKKQHHnggrb766mncuHFN1kXw5yMf+Ui2HgAAoLuZAg4AAKCHvPrqq2nJkiVp4403Lrt+zJgx6b777ktvvPFGWnXVVcu+Zv78+S2mnoup6UJDQ0P2qKa+ffvmMnC3bNmyil8vDfKXBvKANJAPHAvygDzgnOC82Nl6QU/q169fh16frxoaAABALxLBnzBgwICy6wcOHNj4utYCQDNmzEjTp08vu27RokVp4cKFqZqGDx+e8iYa+B1JV2mQvzSQB6SBfOBYkAfkAecE58XO1gt60qhRozr0egEgAACAHjJo0KDseenSpWXXv/32201eV07cK2jSpEktRgDtuuuuaciQIVW/8B4jP6o7Bqln9qkj6fp/o1/ylQqdSYM8pYA8IA/IB50/FpQFeUoBeUAadD4f5Klu1LeD+9+bCAABsFy8s6yQ5i7Mx8l/7PB+qX/fPtXeDABqwGqrrZYFd1544YWy62N5jPxpbfRPGDFiRPZobQqIjk4DQfv69OlT9+la72lQ7/sfpIE0kA/kAXlAeeicUPvnRAEgAJaLCP5MvGheLlJ71mGj0zoj+1d7MwCokcbipptumv70pz+l5557Lo0bN65x3VtvvZUefPDBtOWWW1Z1GwEAgHxaodobAAAAkAdxH585c+akefOadnjYd999s+dzzjmnyfJLLrkkCwIV1wMAAHQnI4AAAABacdVVV2Ujd0I8FwqF9IMf/KBx/fe///3Gv2fPnp222267NHny5DRz5szG5QcccEC68sor00UXXZQWLVqUttlmm/TQQw+lGTNmpAkTJqR99tlH+gMAAN1OAAgAAKAVl112Wbr77rubLDv++OPLBoBas+KKK6bf/va36eSTT07XX399uvbaa9Po0aPT1KlT0wknnJCtBwAA6G4CQAAAAK246667Kk6bGM0TI4TKWXnlldOZZ56ZPQAAAJYH9wACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMiZvtXeAIB6UGh4JzW8PDflQb+RY1Offv2rvRkAAAAAQBsEgACWgwj+zJs2MRdpPfr0Wan/mHWqvRkAAAAAQBtMAQcAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5U9UA0JNPPplOOumktNVWW6VRo0alwYMHpw033DAdfvjhad68edXcNAAAAAAAgJpV1QDQZZddls4+++w0duzYNG3atHTeeeelLbbYIs2YMSNttNFGac6cOdXcPAAAAAAAgJrUt5pfvvvuu6djjjkmDR06tHHZwQcfnAWBDjnkkHTCCSekG264oZqbCAAAAAAAUHOqOgJo0003bRL8Kdprr72y54cffrgKWwUAAAAAAFDbqhoAas2LL76YPY8cObLamwIAAAAAAFBzqjoFXGuOP/747PmAAw5o83Xz589PCxYsaLLsqaeeyp4bGhqyB0C19e3bK4vaLikUCmnZsmUVv14a5C8N5IGOpwH5Ow5CvR8Lvek46NevX7U3AQAAoFfpdS3Q0047Ld10001p1113TZMnT27ztTNmzEjTp08vu27RokVp4cKFPbSVAJUbPnx47pIrLvZ1pIyVBvlLA3mg42lA/o6DUO/HQm86DkaNGlXtTQAAAOhVelUA6IILLkjHHXdcmjBhQrrmmmtSnz592nz9lClT0qRJk1qMAIrg0ZAhQ3LXwAZqU/T2bsjhPnWkjP2/Hu/5SoXOpEGeUkAe6HgakL/jINT7seA4AAAA6L16TQDo3HPPTVOnTk3bb799uuWWW9KgQYPafc+IESOyR2tTQJgGAqBnRIC+3svYek+Det//IA2QDxwHAAAAvdkKqRc444wzsuDPZz/72XTrrbdWFPwBAAAAAACglwaA4p4/xxxzTNpll13SzTffnAYOHFjtTQIAAAAAAKhpVZ0C7uKLL87u+TNy5Mj05S9/Od14441N1q+88srZ/XwAAAAAAACokQDQAw88kD2//PLL6cADD2yxfty4cQJAAAAAAAAAtTQF3MyZM1OhUGj18eyzz1Zz8wAAAAAAAGpS1e8BBAAAAAAAQPcSAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAgDb88pe/TFtssUUaPHhwGjZsWPriF7+Y/vWvf1WUZjNnzkx9+vQp+9h0002lOwAA0GP69txHAwAA1LbLLrssfe1rX0sbb7xxOuOMM9Lbb7+dLrroorTlllume+65J40fP76izzn22GPTBhts0GTZ8OHDe2irAQAABIAAAADKeu2119JRRx2VxowZkwV7Vl111Wz5HnvskTbccMN0xBFHpDvvvLOi1Ntxxx3ThAkTpDQAALDcmAIOAACgjFmzZqU33ngjGwFUDP6EsWPHpt133z398Y9/TM8//3zFabd48eK0dOlSaQ0AACwXAkAAAABl/PWvf82eY7q35orLHnjggYrSbuLEiWmVVVZJAwcOTOuuu24688wz07Jly6Q7AADQY9wDCAAAoIwXXnghe44p4JorLiu+pjWDBg3KpozbYYcd0ujRo9OLL76YrrrqqnT00UenP//5z9kooxVWaLtf3vz589OCBQuaLHvqqaey54aGhuxRTX375q9ZWSgUOhSgkwb5SwN5QBrIB44FeUAecE5wXizqaL2gJ/Xr169Dr89XDQ0AAKCbLFmyJHseMGBAi3Uxkqf0Na2J4E88Sh188MFp7733Ttddd1264YYb0l577dXmZ8yYMSNNnz697LpFixalhQsXpmoaPnx4ypto4HckXaVB/tJAHpAG8oFjQR6QB5wTnBc7Wy/oSaNGjerQ6wWAAAAAWhm9E8rdt+ftt99u8pqO6NOnTzrxxBOzANCtt97abgBoypQpadKkSS1GAO26665pyJAhVb/wHiM/qjsGqWf2qSPp+n+jX/KVCp1JgzylgDwgD8gHnT8WlAV5SgF5QBp0Ph/kqW7Ut4P735sIAAEAAJRROs3bBhtsUPH0cJVYa621Gqd3a8+IESOyR2tTQHR0GggqC9LVe7rWexrU+/4HaSAN5AN5QB5QHjon1P45se3JpgEAAOrU5ptvnj3fd999LdYVl2222Wad+uwnnniiU1M4AAAAVEoACAAAoIyYYm2VVVZJP/3pT9Mbb7zRuHzu3LnpxhtvTBMmTEhrrLFG472A5syZk+bNm9fkM8rNFR5ziE+bNq3xOwAAAHqCKeAAAADKGDZsWDrrrLPSN77xjbTVVlulQw45JLsf0EUXXZRNA3H++ec3vnb27Nlpu+22S5MnT04zZ85sXD5+/Pi09dZbZ8+jR49OL730Unbvn8cffzy798+XvvQlaQ8AAPQIASAAAIBWRNAnbvgagaDvfe97qX///ulTn/pUOvXUU9OHP/zhdtNt7733TnfffXe6884706JFi9LgwYOz911++eVZsCgCSQAAAD1BAAgAAKANu+++e/ZoS0wHVygUWiw/++yzpS0AAFAV7gEEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzfau9AeTfO8sKae7ChpQHY4f3S/379qn2ZgAAAAAAQJsEgOhxEfyZeNG8XKT0rMNGp3VG9q/2ZgAAAAAAQJtMAQcAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDMCQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMABAAAAAAAkDO9IgD0y1/+Mm2xxRZp8ODBadiwYemLX/xi+te//lXtzQIAAOhye2XJkiXpmGOOSWuuuWYaMGBA9jxt2rRsOQAAQG4DQJdddlnabbfd0n//+990xhlnpOOOOy499NBDacstt0yPPPJItTcPAACoY11tr7z77rtp5513zt67zTbbpIsvvjh94QtfSGeddVb2/N577y2X/QAAAOpP32p++WuvvZaOOuqoNGbMmHTPPfekVVddNVu+xx57pA033DAdccQR6c4776zmJgIAAHWqO9orV1xxRbr77rvTYYcdli688MLG5TEK6Dvf+U66+uqr03777dfj+wIAANSfqo4AmjVrVnrjjTfS1772tcbGVBg7dmzafffd0x//+Mf0/PPPV3MTAQCAOtUd7ZUrr7wye546dWqT5VOmTEkrrbRS43oAAIDu1qdQKBRSlRx66KHpf/7nf9Ltt9+edtxxxybrfvKTn6RDDjkk3XTTTenLX/5y2ffPnz8/LViwoMmyxx57LOuR94tf/CKtvfbaqdr69q3qIKtut2zZsg7v/7J3U5r3esfe11uNHto39V2xc+mQF53Z9z59+qQ8iWKzI+mQ/f7LlqVlC+elPOg7fHTsVIfToN7LgjzlA3mg83lAeZif4yDU+7HQ2XpRT+nXr19W/x84cGCvaa9EnWHllVdOQ4cOTS+++GKL9TGN3KOPPpoWLVrU5nb09nZPns5xod6P7aCuIw/Uex4IygJlgTwgD3SlLFAe5qduNLrG2z1VvSr9wgsvZM8xpUJzxWXF15QzY8aMNH369LLrokceAABQP/71r3+ljTbaqNe0V1599dW0ZMmStPHGG5ddH59x3333ZaOMSkcYNafdAwAAdKbdU9UAUDSGwoABA1qsK0awiq8pJ6ZNmDRpUpNl0Xh64okn0vjx48t+bh499dRTadddd00333xzWmeddVI9qvc0qPf9D9JAGsgH8oA8oDx0TpAHunskTFfbK229v/lntBUA0u75P+p70kA+kAfkAeVhUb2fE+p9/4M0kAb1nA/W7kC7p6oBoEGDBmXPS5cubbHu7bffbvKackaMGJE9mvvkJz+Z6lFk8u7s8ViL6j0N6n3/gzSQBvKBPCAPKA+dE+SB3tJeaev9lX5G0O5pSn1PGsgH8oA8oDx0TpAH5AF1I/XDyqyQqqitaRPamm4BAACgt7dXVltttSy409o0cbE8Rv60NfoHAACgJgNAm2++efYc8143V1y22WabLfftAgAA6Gp7pU+fPmnTTTdNL730UnruueearHvrrbfSgw8+qL0DAADkMwAU8/Otssoq6ac//Wl2756iuXPnphtvvDFNmDAhrbHGGtXcRAAAoE51pL0S9/GZM2dOmjdvXpPP2HfffbPnc845p8nySy65JAsCFdcDAAB0t6reA2jYsGHprLPOSt/4xjfSVlttlQ455JBsfuyLLroo6y13/vnnV3Pzasb73//+dOKJJ2bP9are06De9z9IA2kgH8gD8oDy0DlBHqhme2X27Nlpu+22S5MnT04zZ85sXH7AAQekK6+8MnvPokWL0jbbbJMeeuihNGPGjCyAtM8++3T7dueV+p40kA/kAXlAeeicIA/IA+pG6ocd06dQKBRSlf3iF7/IGlaPPPJI6t+/f/rUpz6VTj311PThD3+42psGAADUuUraK3fddVfZAFBYvHhxOvnkk9P111+fjRAaPXp02muvvdIJJ5yQBg8eXIU9AgAA6kGvCAABAAAAAACQk3sAAQAAAAAA0P0EgAAAAAAAAHJGAAgAAAAAACBnBIAAAAAAAAByRgCol2toaEjf+ta30rBhw9Jqq62WDjvssLRs2bJ214X4/xprrJFWXXXV9IEPfCAdeeSR6Z133km1pt7ToN73P0iDrqXB/vvvn/r3759WXnnlxsd9992Xak29p0G973+QBl1Lg6effjp97nOfy9bHOeHMM89Mtaje06De95/8Ut+TBvKAPNDVskCdNx9pIA9Ig67mg7zUees9Dep9/7tVgV7thBNOKGyyySaFl156KXvE39OnT293XXjssccKixcvzv5esGBBYcKECYVTTjmlUGvqPQ3qff+DNOhaGkyePLlwxBFHFGpdvadBve9/kAadT4Nly5YVNtxww8Kxxx5beOeddwpz5swprLHGGoVrrrmmUGvqPQ3qff/JL/U9aSAPyANdLQvUefORBvKANOhKPshTnbfe06De9787CQD1cmPGjCnceOONjf+/4YYbCmPHjm13XXPz588vfPrTny7st99+hVpT72lQ7/sfpEHX0iAPjYBQ72lQ7/sfpEHn0+DRRx8trLjiioWlS5c2rj/ppJMK2267baHW1Hsa1Pv+k1/qe9JAHpAHuloWqPPmIw3kAWnQlXyQpzpvvadBve9/dxIA6sVeffXVQgzSevLJJxuXPfHEE9myZ599ttV1r7/+euOy008/vTB48OBs+fDhwwsPPPBAoZbUexrU+/4HadD1NIhGwLBhw7JH9II4++yzC++++26hltR7GtT7/gdp0LU0eOSRR7JK8Ntvv924PnpNRZ6oJfWeBvW+/+SX+p40kAfkge4oC9R5az8N5AFp0NV8kJc6b72nQb3vf3dzD6BebPHixdnz0KFDG5cV/15hhRVaXffmm282LjvmmGOyz3nsscfSN77xjTRq1KhUS+o9Dep9/4M06HoaHH744enf//53WrBgQbrsssvSBRdckD1qSb2nQb3vf5AGXUuD9dZbL6255prphBNOSEuXLk2PPvpo+tnPfpbeeOONVEvqPQ3qff/JL/U9aSAPyAPdURao89Z+GsgD0qCr+SAvdd56T4N63//uJgDUi8XN+sKiRYsalxX/fu+991pdt8oqq7T4rA022CBtsskm2Q0Ba0m9p0G973+QBl1Pg4997GPp/e9/f1pxxRXTFltskQUFr7/++lRL6j0N6n3/gzToWhr069cvzZo1K/3zn//MboL51a9+NR1wwAFp+PDhqZbUexrU+/6TX+p70kAekAe6oyxQ5639NJAHpEFX80Fe6rz1ngb1vv/dTQCoFxs2bFgaM2ZMevDBBxuXxd9rrLFGGjduXKvrhgwZUvbzGhoa0pNPPplqSb2nQb3vf5AG3Z8Gxd4StaTe06De9z9Ig66nwUYbbZRuv8vNHFcAAA22SURBVP329Morr2TrojfUtttum2pJvadBve8/+aW+Jw3kAXmgJ8oCdd7aSwN5QBp0Rz7IQ5233tOg3ve/23X7pHJ0q+OPP77w0Y9+tDBv3rzsEX9Pnz693XVvvvlm4Wc/+1nhtddeK7z33nuFhx9+uLDBBhsUvv71r9fcL1TvaVDv+x+kQefTIFx//fWFRYsWZfkg7gE1bty4wplnnlmoNfWeBvW+/0EadC0NHnroocLixYuzm2HedNNNhfe9733ZslpT72lQ7/tPfqnvSQN5QB7oSlkQ1HnzkQbygDToaj7IS5233tOg3ve/OwkA9XLvvPNOYcqUKYWhQ4dmj29961uFhoaGdtdFJt9hhx0Kq622WmHw4MGFtdZaq/Cd73yn8N///rdQa+o9Dep9/4M06HwahE996lOFIUOGZPngQx/6UOGMM86oqRuBFtV7GtT7/gdp0LU0OO6447JzwqBBgwqf/OQnC3/5y18Ktaje06De95/8Ut+TBvKAPNCVsiCo8+YjDeQBadDVfJCXOm+9p0G973936hP/dP+4IgAAAAAAAKqltiYDBQAAAAAAoF0CQAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwCUA3Pnzk0rr7xyWrRoUapH9b7/QRpIA/lAHpAHlIfOCfKAPEDe1Xudt973P0gDaSAfyAPygPLQOUEekAc6RgCol5kwYUIaMGBAVrFfbbXVsv///e9/b/M9Y8eOTYsXL05Dhgxp9TX/+te/0k477ZTe9773pT59+qTXX3899Ub1vv89mQZXXHFF2nzzzbPXjB49Oh100EG9Nh2kgWNBWeA4UBb0bHlYK+dF5wNpQH4p3+q7fA/KeGnQk/mgVo6Fet//oCyQBj2ZD2rlWHAcSIOeJADUC51xxhlZAfbSSy+lj370o2nixIld+ryGhobUr1+/tMcee6SZM2em3q7e97+n0mDJkiXpzDPPTC+//HJ69NFH07x589KUKVNSbyUNHAvKAseBsqDnysNaOi86H0gD8kv5Vt/le1DGS4Oeyge1dCzU+/4HZYE06Kl8UEvHguNAGvSYAr3KtttuWzjvvPMa///II48U4mc6++yzC+uss05h5ZVXLnzwgx8sXHTRRY2veeaZZ7LXvPbaa9n/J0+eXDjwwAMLkyZNKqyyyiqFCy+8sNXX9jb1vv/LIw2KZs2aVVhjjTUKvZE0cCwoCxwHyoLlUx729vOi84E0IL+Ub/VdvgdlvDRYHvmgtx8L9b7/QVkgDZZHPujtx4LjQBr0pL49F1qiq2LExqWXXprGjRuX1lxzzXTnnXemMWPGpLvuuivtvPPOWTR8q622Kvvea6+9Nv3qV79K1113XXr77bdr8seo9/3v6TS4++6704c//OHU20kDx4KywHGgLOj58rAWOB9IA/JL+Vbf5XtQxkuDns4HtaDe9z8oC6RBT+eDWuA4kAbdrkfDS3Qq4jtw4MDCkCFDCiNHjizstNNOhYceeqjF6yZOnFj4wQ9+0GrEO9aXUwsR73re/+WRBuG3v/1tYdVVVy08/PDDhd5IGjgWlAWOA2XB8ikPe/t50flAGpBfyrf6Lt+DMl4aLI980NuPhXrf/6AskAbLIx/09mPBcSANepIRQL3Q6aefno488sgmy6655pp0zjnnpGeffTa99957WTR4rbXWavNGaLWq3ve/p9Mgek7ss88+6Ze//GUaP3586q2kgWNBWeA4UBb0fHlYC5wPpAH5pXyr7/I9KOOlQU/ng1pQ7/sflAXSoKfzQS1wHEiDniIAVAPmzp2bJk+enH7/+9+nCRMmpL59+6Zdd901Rm+1+p4VVlgh5UW97393pkEEf3bfffdsSOz222+faok0cCwoCxwHyoLuLQ9rlfOBNCC/lG/1Xb4HZbw06M58UKvqff+DskAadGc+qFWOA2nQXfJzVOTY4sWLs8JtxIgRWUH229/+Nt1+++0d+ox4f8x9uXTp0uz/8Rz/b6vQ7C3qff+7Kw1irtTddtstXXXVVWmnnXZKtUYaOBaUBY4DZUH3lYe1fF50PpAG5Jfyrb7L96CMlwbdlQ9q+Vio9/0PygJp0F35oJaPBceBNOguRgDVgA033DAdd9xx6dOf/nR699130xe/+MXs0RHPPfdckyGSo0aNyp6feeaZ7IZqvVm97393pcH06dPTG2+8kfbcc88WJ5RaIA0cC8oCx4GyoPvKw1o+LzofSAPyS/lW3+V7UMZLg+7KB7V8LNT7/gdlgTTornxQy8eC40AadJc+cSOgbvs0AAAAAAAAqs4UcAAAAAAAADkjAAQAAAAAAJAzAkAAAAAAAAA5IwAEAAAAAACQMwJAAAAAAAAAOSMA1MtNmDAhDRgwIK288sqNjxkzZqT9998/9e/fv8nyeMyfPz9737///e/0hS98Ib3vfe9Lq666alp//fXTGWeckXrbvq244orp4Ycfblz2+uuvpz59+qRnn302+//LL7+cDjzwwDRy5Mg0aNCgtNFGG6Uf/ehHTT7npJNOSn379m2SDl/5yleydTNnzsy+o3k63XTTTdn6N998M02ZMiV94AMfyJavscYaaa+99kq9iTwgD8gHygJ5QB6oh3NCJfK+/+pG1LM8H9+O7crTSR6o77ZvkA+0f+UBeSDvZUGl8pwG6kbLlwBQDYiDdPHixY2PqLSFeC5dHo8RI0Zk6z7/+c+nTTbZJM2dOze99tprWaXvgx/8YOpthg0blqZNm1Z2XQSDttpqq6yiOnv27LRo0aKsAnzWWWel7373u01eu8suuzRJh2uvvbZx3fjx41uk02677Zat+/a3v50Fm/7xj39ky++7776sEOpt5AF5QD5QFsgD8kA9nBMqkff9VzeinuX5+HZsV0Ye0O6RD9R55QF5oB7OCZXKcxqoGy0/AkA59Morr6Snn346HXLIIVnPoegFFL2HJk2alHqbKLDuueee9Kc//anFuvPPPz/r3XTdddelcePGpX79+qXtttsuXX311encc89N//nPf7r8/ffff3/WYyp6WYUxY8akb3zjG6nWyQOVy2seCPJB5fKaD+SByuU1D9RaPugJtbb/6kaQz+Pbsd0z5IHKqev0DsqCnqEsqJyyIN8cC5W7P8fXAJoTAMqh4cOHp/XWWy8dcMAB6YYbbkjPPfdc6q1WW221dPTRR6djjjmmxbrbbrst7bHHHllDrtSnPvWptPrqq6c//OEPXf7+GGF08sknp5/85CfZVHSFQiHlgTxQubzmgSAfVC6v+UAeqFxe80Ct5YOeUGv7r24E+Ty+Hds9Qx6onLpO76As6BnKgsopC/LNsVC5rXJ8DaA5AaAaEFOkDR06tPHx3//+N1t+ySWXNFkejZ8Q99C56667suF+06dPz4b5bbjhhumOO+5IvdGRRx6ZNdZuvvnmFlHrCPSUE8sXLFjQ+P/f/OY3TdIigkdFjzzySJN18XjyySezdRdeeGEW3Y35kjfffPMs6huji3obeaClessDQT5oqd7ygTzQUr3lgXrIB+2ph/1XN6Je5f34dmy3Tx5oSV1HWVCP+UBZ0FK95YF6yAeVyHsaqBstJwV6tW233bZw3nnntVg+efLkwhFHHFHRZyxcuLBw1FFHFQYPHpz93Rv37cc//nFhgw02KLzyyisRbi0888wzhS222KJw/PHHl33vmDFjsveEE088sTBx4sSyr7v88ssLm2yySUXb8/bbbxeuuuqqQr9+/Qq33XZbobeQB+QB+UBZIA/IA/VwTqhE3vdf3Yh6lufj27Hd8XQqJQ/UT9s3yAfav/KAPJD3sqBSeU4DdaPlywigOhBDjE866aQsSvzMM8+k3uiggw5K7733Xrriiisal+24447pxhtvTO+++26T1/7lL39JL730Utp+++27dRsGDBiQ9tlnnzR+/Pist0SeyAOVyXMeCPJBZfKcD+SByuQ5D9RKPuhJtbL/6kaQz+Pbsd2z5IHKqOtUn7KgZykLKqMsyD/HQmXyfiwIAOXQa6+9lr7//e+nOXPmZMGTJUuWZMM546Bff/31U28U9/k59dRT02mnnda47Nvf/nZaunRp+upXv5qef/751NDQkO6+++7sgDz88MPT2muv3eXvjeGQ9957b3rrrbeytLrlllvSY489lj75yU+mWiYPVC6veSDIB5XLaz6QByqX1zxQq/mgO9Xq/qsbQT6Pb8d295IHKqeu07soC7qXsqByyoJ8cyxUbnqOrwE0JwBUw2bMmJFWXnnlJo9//vOfqX///unFF19MO++8cxoyZEgaO3Zsuueee9Lvfve7NHjw4NRb7bbbbmmdddZp/P+wYcOy7V5ppZXSxz/+8bTqqqtm85QeddRRHZqfNCK3zdMp5jwNffv2TYceemg252ncKC16DF566aVpyy23TLVAHqhMnvNAkA8qk+d8IA9UJs95II/5oKPyuP/qRpDP49ux3XHyQGXUdZQFec8HyoLK5DkP5DEfdEbe0kDdqGf1iXngevg7AAAAAAAAWI6MAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICcEQACAAAAAADIGQEgAAAAAACAnBEAAgAAAAAAyBkBIAAAAAAAgJwRAAIAAAAAAMgZASAAAAAAAICUL/8frRyj0CGL6KIAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved: fes_vs_nofes_metrics.png\n" + ] + } + ], + "source": [ + "METRICS = [\n", + " ('acc', 'Classification accuracy', '0–1'),\n", + " ('amp', 'Classification amplitude (mean |decision fn|)', 'a.u.'),\n", + " ('fisher', 'Fisher ratio on LDA projection (test-set SNR)', 'a.u.'),\n", + " ('mu_snr', 'μ-band power ratio REST / MI @ C3/Cz/C4', 'ratio'),\n", + "]\n", + "\n", + "cond_color = {'FES': '#E05C2A', 'NOFES': '#2A7BE0'}\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 9))\n", + "fig.suptitle('Online decoding: FES vs NOFES feedback (per subject × offline-trained model)',\n", + " fontsize=13, fontweight='bold', y=1.00)\n", + "\n", + "for ax, (key, title, unit) in zip(axes.ravel(), METRICS):\n", + " labels, vals, colors = [], [], []\n", + " for subj in subjects:\n", + " for pair in PAIRS:\n", + " tag = pair['name'].split()[0] # \"Pair1\" / \"Pair2\"\n", + " for cond in ('FES', 'NOFES'):\n", + " row = next((r for r in results\n", + " if r['subject']==subj and r['pair']==pair['name']\n", + " and r['condition']==cond), None)\n", + " if row is None: continue\n", + " labels.append(f'{subj}\\n{tag}\\n{cond}')\n", + " vals.append(row[key])\n", + " colors.append(cond_color[cond])\n", + " x = np.arange(len(vals))\n", + " ax.bar(x, vals, color=colors, edgecolor='white', zorder=2)\n", + " ax.set_xticks(x); ax.set_xticklabels(labels, fontsize=7.5)\n", + " ax.set_title(f'{title} ({unit})', fontsize=11, fontweight='bold')\n", + " ax.grid(axis='y', alpha=0.3)\n", + " ax.spines[['top','right']].set_visible(False)\n", + " if key == 'acc':\n", + " ax.axhline(0.5, color='gray', linestyle='--', lw=0.8, alpha=0.6)\n", + "\n", + "fig.legend(handles=[Patch(color=cond_color['FES'], label='ONLINE_FES'),\n", + " Patch(color=cond_color['NOFES'], label='ONLINE_NOFES')],\n", + " loc='upper right', ncol=2, bbox_to_anchor=(0.98, 1.0))\n", + "plt.tight_layout()\n", + "plt.savefig('fes_vs_nofes_metrics.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print('Saved: fes_vs_nofes_metrics.png')" + ] }, { "cell_type": "markdown", "id": "248740bd", "metadata": {}, - "source": "---\n## Figure 2 — LDA decision-function distributions\n\nVisualizes classification amplitude and separability directly: wider FES vs NOFES spread between MI and REST curves = higher Fisher ratio and larger mean |margin|." + "source": [ + "---\n", + "## Figure 2 — LDA decision-function distributions\n", + "\n", + "Visualizes classification amplitude and separability directly: wider FES vs NOFES spread between MI and REST curves = higher Fisher ratio and larger mean |margin|." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "393042a0", - "metadata": {}, - "outputs": [], - "source": "fig, axes = plt.subplots(len(subjects), len(PAIRS),\n figsize=(6 * len(PAIRS), 3.2 * len(subjects)),\n sharex=True, squeeze=False)\nfig.suptitle('LDA decision-function distributions on ONLINE sessions\\n'\n '(class separation ↔ classification amplitude & SNR)',\n fontsize=12, fontweight='bold', y=1.01)\n\nfor i, subj in enumerate(subjects):\n for j, pair in enumerate(PAIRS):\n ax = axes[i][j]\n for cond, color in cond_color.items():\n row = next((r for r in results\n if r['subject']==subj and r['pair']==pair['name']\n and r['condition']==cond), None)\n if row is None: continue\n m_mi = row['margin'][row['y_test'] == 1]\n m_rest = row['margin'][row['y_test'] == 0]\n ax.hist(m_mi, bins=15, alpha=0.5, color=color,\n label=f'{cond} MI', density=True)\n ax.hist(m_rest, bins=15, alpha=0.25, color=color, hatch='///',\n edgecolor=color, label=f'{cond} REST', density=True)\n ax.axvline(0, color='k', lw=0.8)\n ax.set_title(f'{subj} | {pair[\"name\"]}', fontsize=10, fontweight='bold')\n if j == 0: ax.set_ylabel('Density')\n if i == len(subjects) - 1: ax.set_xlabel('LDA decision function')\n ax.spines[['top','right']].set_visible(False)\n if i == 0 and j == 0:\n ax.legend(fontsize=6.5, loc='upper left', ncol=2)\n\nplt.tight_layout()\nplt.savefig('decision_margin_distributions.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('Saved: decision_margin_distributions.png')" + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:52:04.242359Z", + "iopub.status.busy": "2026-04-22T00:52:04.242277Z", + "iopub.status.idle": "2026-04-22T00:52:04.931529Z", + "shell.execute_reply": "2026-04-22T00:52:04.930993Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved: decision_margin_distributions.png\n" + ] + } + ], + "source": [ + "fig, axes = plt.subplots(len(subjects), len(PAIRS),\n", + " figsize=(6 * len(PAIRS), 3.2 * len(subjects)),\n", + " sharex=True, squeeze=False)\n", + "fig.suptitle('LDA decision-function distributions on ONLINE sessions\\n'\n", + " '(class separation ↔ classification amplitude & SNR)',\n", + " fontsize=12, fontweight='bold', y=1.01)\n", + "\n", + "for i, subj in enumerate(subjects):\n", + " for j, pair in enumerate(PAIRS):\n", + " ax = axes[i][j]\n", + " for cond, color in cond_color.items():\n", + " row = next((r for r in results\n", + " if r['subject']==subj and r['pair']==pair['name']\n", + " and r['condition']==cond), None)\n", + " if row is None: continue\n", + " m_mi = row['margin'][row['y_test'] == 1]\n", + " m_rest = row['margin'][row['y_test'] == 0]\n", + " ax.hist(m_mi, bins=15, alpha=0.5, color=color,\n", + " label=f'{cond} MI', density=True)\n", + " ax.hist(m_rest, bins=15, alpha=0.25, color=color, hatch='///',\n", + " edgecolor=color, label=f'{cond} REST', density=True)\n", + " ax.axvline(0, color='k', lw=0.8)\n", + " ax.set_title(f'{subj} | {pair[\"name\"]}', fontsize=10, fontweight='bold')\n", + " if j == 0: ax.set_ylabel('Density')\n", + " if i == len(subjects) - 1: ax.set_xlabel('LDA decision function')\n", + " ax.spines[['top','right']].set_visible(False)\n", + " if i == 0 and j == 0:\n", + " ax.legend(fontsize=6.5, loc='upper left', ncol=2)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('decision_margin_distributions.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print('Saved: decision_margin_distributions.png')" + ] }, { "cell_type": "markdown", "id": "fcb6d19d", "metadata": {}, - "source": "---\n## Figure 3 — Paired Δ (FES − NOFES) per metric\n\nWithin each (subject × pair), FES and NOFES sessions use the same offline-trained model. Positive bars mean FES > NOFES; negative means NOFES > FES. This removes the offline-model-quality confound and isolates the effect of feedback type." + "source": [ + "---\n", + "## Figure 3 — Paired Δ (FES − NOFES) per metric\n", + "\n", + "Within each (subject × pair), FES and NOFES sessions use the same offline-trained model. Positive bars mean FES > NOFES; negative means NOFES > FES. This removes the offline-model-quality confound and isolates the effect of feedback type." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "75df404b", - "metadata": {}, - "outputs": [], - "source": "fig, axes = plt.subplots(1, 4, figsize=(16, 4.5))\nfig.suptitle('Within-pair Δ = FES − NOFES (positive → FES better)',\n fontsize=12, fontweight='bold', y=1.03)\n\nfor ax, (key, title, _) in zip(axes, METRICS):\n labels, deltas = [], []\n for subj in subjects:\n for pair in PAIRS:\n fes = next((r for r in results if r['subject']==subj and r['pair']==pair['name']\n and r['condition']=='FES'), None)\n nof = next((r for r in results if r['subject']==subj and r['pair']==pair['name']\n and r['condition']=='NOFES'), None)\n if fes is None or nof is None: continue\n deltas.append(fes[key] - nof[key])\n labels.append(f'{subj}\\n{pair[\"name\"].split()[0]}')\n\n colors = ['#E05C2A' if d > 0 else '#2A7BE0' for d in deltas]\n ax.bar(np.arange(len(deltas)), deltas, color=colors, edgecolor='white', zorder=2)\n ax.axhline(0, color='k', lw=0.8)\n ax.set_xticks(np.arange(len(deltas)))\n ax.set_xticklabels(labels, fontsize=8)\n ax.set_title(f'Δ {title.split(\"(\")[0].strip()}', fontsize=10, fontweight='bold')\n ax.grid(axis='y', alpha=0.3)\n ax.spines[['top','right']].set_visible(False)\n\nplt.tight_layout()\nplt.savefig('fes_minus_nofes_delta.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('Saved: fes_minus_nofes_delta.png')" + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:52:04.933405Z", + "iopub.status.busy": "2026-04-22T00:52:04.933304Z", + "iopub.status.idle": "2026-04-22T00:52:05.178252Z", + "shell.execute_reply": "2026-04-22T00:52:05.177815Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved: fes_minus_nofes_delta.png\n" + ] + } + ], + "source": [ + "fig, axes = plt.subplots(1, 4, figsize=(16, 4.5))\n", + "fig.suptitle('Within-pair Δ = FES − NOFES (positive → FES better)',\n", + " fontsize=12, fontweight='bold', y=1.03)\n", + "\n", + "for ax, (key, title, _) in zip(axes, METRICS):\n", + " labels, deltas = [], []\n", + " for subj in subjects:\n", + " for pair in PAIRS:\n", + " fes = next((r for r in results if r['subject']==subj and r['pair']==pair['name']\n", + " and r['condition']=='FES'), None)\n", + " nof = next((r for r in results if r['subject']==subj and r['pair']==pair['name']\n", + " and r['condition']=='NOFES'), None)\n", + " if fes is None or nof is None: continue\n", + " deltas.append(fes[key] - nof[key])\n", + " labels.append(f'{subj}\\n{pair[\"name\"].split()[0]}')\n", + "\n", + " colors = ['#E05C2A' if d > 0 else '#2A7BE0' for d in deltas]\n", + " ax.bar(np.arange(len(deltas)), deltas, color=colors, edgecolor='white', zorder=2)\n", + " ax.axhline(0, color='k', lw=0.8)\n", + " ax.set_xticks(np.arange(len(deltas)))\n", + " ax.set_xticklabels(labels, fontsize=8)\n", + " ax.set_title(f'Δ {title.split(\"(\")[0].strip()}', fontsize=10, fontweight='bold')\n", + " ax.grid(axis='y', alpha=0.3)\n", + " ax.spines[['top','right']].set_visible(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig('fes_minus_nofes_delta.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "print('Saved: fes_minus_nofes_delta.png')" + ] }, { "cell_type": "markdown", @@ -153,11 +953,71 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "cf55268e", - "metadata": {}, - "outputs": [], - "source": "agg = {c: {k: [] for k in ('acc','amp','fisher','mu_snr')} for c in ('FES','NOFES')}\nfor r in results:\n for k in agg[r['condition']]:\n agg[r['condition']][k].append(r[k])\n\nn_pairs = len(agg['FES']['acc'])\nprint(f'=== Aggregate across {n_pairs} (subject × pair) comparisons ===\\n')\n\nhdr = f'{\"Metric\":<28} {\"FES (mean ± sd)\":>22} {\"NOFES (mean ± sd)\":>22} {\"paired Δ\":>12}'\nprint(hdr); print('-' * len(hdr))\nfor k, label in [('acc', 'Classification accuracy'),\n ('amp', 'Classification amplitude'),\n ('fisher', 'Fisher ratio (test SNR)'),\n ('mu_snr', 'μ-band SNR (REST/MI)')]:\n fes, nof = np.array(agg['FES'][k]), np.array(agg['NOFES'][k])\n delta = fes - nof\n print(f'{label:<28} {fes.mean():>10.3f} ± {fes.std(ddof=1):>6.3f} '\n f'{nof.mean():>10.3f} ± {nof.std(ddof=1):>6.3f} {delta.mean():>+12.3f}')\n\n# Sign test (simple)\nprint()\nfor k, label in [('acc','acc'), ('amp','|margin|'), ('fisher','Fisher'), ('mu_snr','μ-SNR')]:\n d = np.array(agg['FES'][k]) - np.array(agg['NOFES'][k])\n n_pos = int((d > 0).sum()); n_neg = int((d < 0).sum())\n print(f' {label:<10} FES > NOFES in {n_pos}/{len(d)} comparisons (NOFES > FES in {n_neg})')" + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-22T00:52:05.179587Z", + "iopub.status.busy": "2026-04-22T00:52:05.179489Z", + "iopub.status.idle": "2026-04-22T00:52:05.183657Z", + "shell.execute_reply": "2026-04-22T00:52:05.183209Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Aggregate across 5 complete (subject × pair) comparisons ===\n", + "\n", + "Metric FES (mean ± sd) NOFES (mean ± sd) paired Δ\n", + "---------------------------------------------------------------------------------------\n", + "Classification accuracy 0.673 ± 0.197 0.817 ± 0.142 -0.144\n", + "Classification amplitude 3.161 ± 2.131 2.923 ± 1.879 +0.237\n", + "Fisher ratio (test SNR) 3.000 ± 3.129 3.405 ± 3.558 -0.405\n", + "μ-band SNR (REST/MI) 1.964 ± 0.779 1.840 ± 0.552 +0.124\n", + "\n", + " acc FES > NOFES in 1/5 comparisons (NOFES > FES in 4)\n", + " |margin| FES > NOFES in 3/5 comparisons (NOFES > FES in 2)\n", + " Fisher FES > NOFES in 1/5 comparisons (NOFES > FES in 4)\n", + " μ-SNR FES > NOFES in 3/5 comparisons (NOFES > FES in 2)\n" + ] + } + ], + "source": [ + "# Build only pairs where BOTH FES and NOFES survived evaluation\n", + "paired = []\n", + "for subj in subjects:\n", + " for pair in PAIRS:\n", + " fes = next((r for r in results if r['subject']==subj and r['pair']==pair['name']\n", + " and r['condition']=='FES'), None)\n", + " nof = next((r for r in results if r['subject']==subj and r['pair']==pair['name']\n", + " and r['condition']=='NOFES'), None)\n", + " if fes and nof:\n", + " paired.append((fes, nof))\n", + "\n", + "print(f'=== Aggregate across {len(paired)} complete (subject × pair) comparisons ===\\n')\n", + "\n", + "hdr = f'{\"Metric\":<28} {\"FES (mean ± sd)\":>22} {\"NOFES (mean ± sd)\":>22} {\"paired Δ\":>12}'\n", + "print(hdr); print('-' * len(hdr))\n", + "for k, label in [('acc', 'Classification accuracy'),\n", + " ('amp', 'Classification amplitude'),\n", + " ('fisher', 'Fisher ratio (test SNR)'),\n", + " ('mu_snr', 'μ-band SNR (REST/MI)')]:\n", + " fes_v = np.array([f[k] for f,_ in paired])\n", + " nof_v = np.array([n[k] for _,n in paired])\n", + " delta = fes_v - nof_v\n", + " sd = lambda a: a.std(ddof=1) if len(a) > 1 else 0.0\n", + " print(f'{label:<28} {fes_v.mean():>10.3f} ± {sd(fes_v):>6.3f} '\n", + " f'{nof_v.mean():>10.3f} ± {sd(nof_v):>6.3f} {delta.mean():>+12.3f}')\n", + "\n", + "# Sign test (simple)\n", + "print()\n", + "for k, label in [('acc','acc'), ('amp','|margin|'), ('fisher','Fisher'), ('mu_snr','μ-SNR')]:\n", + " d = np.array([f[k] - n[k] for f,n in paired])\n", + " n_pos = int((d > 0).sum()); n_neg = int((d < 0).sum())\n", + " print(f' {label:<10} FES > NOFES in {n_pos}/{len(d)} comparisons (NOFES > FES in {n_neg})')" + ] } ], "metadata": { @@ -181,4 +1041,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +}