diff --git a/notebooks/test_exgauss_wald.ipynb b/notebooks/test_exgauss_wald.ipynb
new file mode 100644
index 00000000..219143e1
--- /dev/null
+++ b/notebooks/test_exgauss_wald.ipynb
@@ -0,0 +1,666 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import ssms\n",
+    "# import pytensor \n",
+    "# import pytensor.tensor as pt\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['ddm',\n",
+       " 'ddm_st',\n",
+       " 'ddm_truncnormt',\n",
+       " 'ddm_rayleight',\n",
+       " 'ddm_sdv',\n",
+       " 'ddm_par2',\n",
+       " 'ddm_par2_no_bias',\n",
+       " 'ddm_par2_conflict_gamma_no_bias',\n",
+       " 'ddm_par2_angle_no_bias',\n",
+       " 'ddm_par2_weibull_no_bias',\n",
+       " 'ddm_seq2',\n",
+       " 'ddm_seq2_no_bias',\n",
+       " 'ddm_seq2_conflict_gamma_no_bias',\n",
+       " 'ddm_seq2_angle_no_bias',\n",
+       " 'ddm_seq2_weibull_no_bias',\n",
+       " 'ddm_mic2_adj',\n",
+       " 'ddm_mic2_adj_no_bias',\n",
+       " 'ddm_mic2_adj_conflict_gamma_no_bias',\n",
+       " 'ddm_mic2_adj_angle_no_bias',\n",
+       " 'ddm_mic2_adj_weibull_no_bias',\n",
+       " 'ddm_mic2_ornstein',\n",
+       " 'ddm_mic2_ornstein_no_bias',\n",
+       " 'ddm_mic2_ornstein_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_ornstein_conflict_gamma_no_bias',\n",
+       " 'ddm_mic2_ornstein_conflict_gamma_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_ornstein_angle_no_bias',\n",
+       " 'ddm_mic2_ornstein_angle_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_ornstein_weibull_no_bias',\n",
+       " 'ddm_mic2_ornstein_weibull_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_leak',\n",
+       " 'ddm_mic2_leak_no_bias',\n",
+       " 'ddm_mic2_leak_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_leak_conflict_gamma_no_bias',\n",
+       " 'ddm_mic2_leak_conflict_gamma_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_leak_angle_no_bias',\n",
+       " 'ddm_mic2_leak_angle_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_leak_weibull_no_bias',\n",
+       " 'ddm_mic2_leak_weibull_no_bias_no_lowdim_noise',\n",
+       " 'ddm_mic2_multinoise_no_bias',\n",
+       " 'ddm_mic2_multinoise_conflict_gamma_no_bias',\n",
+       " 'ddm_mic2_multinoise_angle_no_bias',\n",
+       " 'ddm_mic2_multinoise_weibull_no_bias',\n",
+       " 'full_ddm',\n",
+       " 'full_ddm_rv',\n",
+       " 'levy',\n",
+       " 'levy_angle',\n",
+       " 'angle',\n",
+       " 'weibull',\n",
+       " 'gamma_drift',\n",
+       " 'shrink_spot',\n",
+       " 'shrink_spot_extended',\n",
+       " 'shrink_spot_simple',\n",
+       " 'shrink_spot_simple_extended',\n",
+       " 'gamma_drift_angle',\n",
+       " 'ds_conflict_drift',\n",
+       " 'ds_conflict_drift_angle',\n",
+       " 'ds_conflict_stimflexons_drift',\n",
+       " 'ds_conflict_stimflexons_drift_angle',\n",
+       " 'ornstein',\n",
+       " 'ornstein_angle',\n",
+       " 'race_2',\n",
+       " 'race_no_bias_2',\n",
+       " 'race_no_z_2',\n",
+       " 'race_no_bias_angle_2',\n",
+       " 'race_no_z_angle_2',\n",
+       " 'race_3',\n",
+       " 'race_no_bias_3',\n",
+       " 'race_no_z_3',\n",
+       " 'race_no_bias_angle_3',\n",
+       " 'race_no_z_angle_3',\n",
+       " 'race_4',\n",
+       " 'race_no_bias_4',\n",
+       " 'race_no_z_4',\n",
+       " 'race_no_bias_angle_4',\n",
+       " 'race_no_z_angle_4',\n",
+       " 'dev_rlwm_lba_pw_v1',\n",
+       " 'dev_rlwm_lba_race_v1',\n",
+       " 'dev_rlwm_lba_race_v2',\n",
+       " 'lba2',\n",
+       " 'lba3',\n",
+       " 'lba_3_vs_constraint',\n",
+       " 'lba_angle_3_vs_constraint',\n",
+       " 'lba_angle_3',\n",
+       " 'lca_3',\n",
+       " 'lca_no_bias_3',\n",
+       " 'lca_no_z_3',\n",
+       " 'lca_no_bias_angle_3',\n",
+       " 'lca_no_z_angle_3',\n",
+       " 'lca_4',\n",
+       " 'lca_no_bias_4',\n",
+       " 'lca_no_z_4',\n",
+       " 'lca_no_bias_angle_4',\n",
+       " 'lca_no_z_angle_4',\n",
+       " 'tradeoff_no_bias',\n",
+       " 'tradeoff_angle_no_bias',\n",
+       " 'tradeoff_weibull_no_bias',\n",
+       " 'tradeoff_conflict_gamma_no_bias',\n",
+       " 'weibull_cdf',\n",
+       " 'full_ddm2',\n",
+       " 'ddm_legacy',\n",
+       " 'exgauss',\n",
+       " 'exgauss_race',\n",
+       " 'shifted_wald',\n",
+       " 'shifted_wald_race']"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list(ssms.config.model_config.keys())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from ssms.basic_simulators.simulator import simulator\n",
+    "mu0 = 5.0 # mu of ex-gaussian for choice 1\n",
+    "mu1 = 3 # mu of ex-gaussian for choice -1 \n",
+    "sigma0 = 0.5\n",
+    "sigma1 = 1\n",
+    "tau0 = 0.1\n",
+    "tau1 = 0.2\n",
+    "p_exgauss = 0.5\n",
+    "\n",
+    "v0 = 2.0 \n",
+    "v1 = 3.0\n",
+    "a0 = 2.5 \n",
+    "a1 = 1\n",
+    "t = 0\n",
+    "\n",
+    "sim_out_race = simulator(\n",
+    "    model=\"exgauss_race\", theta={\"mu0\": mu0, \"mu1\": mu1, \n",
+    "                            \"sigma0\": sigma0, \"sigma1\": sigma1, \n",
+    "                            \"tau0\": tau0,\n",
+    "                             \"tau1\":tau1, \"p\": p_exgauss}, n_samples=10000, random_state = 100,\n",
+    "    )\n",
+    "sim_out = simulator(\n",
+    "    model=\"exgauss\", theta={\"mu0\": mu0, \"mu1\": mu1, \n",
+    "                            \"sigma0\": sigma0, \"sigma1\": sigma1, \n",
+    "                            \"tau0\": tau0,\n",
+    "                             \"tau1\":tau1, \"p\": p_exgauss}, n_samples=10000, random_state = 100,\n",
+    "    )\n",
+    "\n",
+    "sim_out_2 = simulator(\n",
+    "    model=\"shifted_wald\", theta={\"v0\": v0, \"v1\": v1,\n",
+    "                                  \"a0\":a0, \"a1\":a1,\n",
+    "                                  \"t\": t, \"p\": 0.8}, n_samples=10000, random_state = 100,\n",
+    "    )\n",
+    "sim_out_2_race = simulator(\n",
+    "    model=\"shifted_wald_race\", theta={\"v0\": v0, \"v1\": v1,\n",
+    "                                  \"a0\":a0, \"a1\":a1,\n",
+    "                                  \"t\": t, \"p\": 0.8}, n_samples=10000, random_state = 100\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1.4411364 ]\n",
+      " [4.5396304 ]\n",
+      " [1.9898669 ]\n",
+      " [6.16694   ]\n",
+      " [2.6007307 ]\n",
+      " [1.695057  ]\n",
+      " [0.32515216]\n",
+      " [6.1096787 ]\n",
+      " [1.4635196 ]\n",
+      " [5.0182223 ]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(sim_out['rts'][:10])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1],\n",
+       "       [ 1],\n",
+       "       [-1],\n",
+       "       ...,\n",
+       "       [ 1],\n",
+       "       [-1],\n",
+       "       [-1]], shape=(10000, 1), dtype=int32)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sim_out['choices']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1],\n",
+       "       [-1],\n",
+       "       [-1],\n",
+       "       ...,\n",
+       "       [-1],\n",
+       "       [-1],\n",
+       "       [-1]], shape=(1100, 1), dtype=int32)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sim_out_race['choices'][:1100]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[1.7596234 ]\n",
+      " [0.1787014 ]\n",
+      " [0.67438966]\n",
+      " ...\n",
+      " [0.9025264 ]\n",
+      " [0.73628825]\n",
+      " [0.17353109]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(sim_out_2['rts'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[ 1]\n",
+      " [-1]\n",
+      " [ 1]\n",
+      " ...\n",
+      " [ 1]\n",
+      " [ 1]\n",
+      " [-1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(sim_out_2['choices'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[-1]\n",
+      " [-1]\n",
+      " [-1]\n",
+      " ...\n",
+      " [-1]\n",
+      " [-1]\n",
+      " [-1]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(sim_out_2_race['choices'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define exgauss analytical likelihoods\n",
+    "import numpy as np \n",
+    "from scipy.stats import norm \n",
+    "\n",
+    "\n",
+    "def exgauss_likelihood_bernoulli(x, choice, mu0, mu1, sigma0, sigma1, tau0, tau1, p):\n",
+    "    x = np.asarray(x, dtype=float)\n",
+    "    y = (np.asarray(choice, dtype=int) > 0) # 1 choice \n",
+    "    mu = np.where(y, (float(mu0)), float(mu1))\n",
+    "    sigma = np.where(y, float(sigma0), float(sigma1))\n",
+    "    tau = np.where(y, float(tau0), float(tau1))\n",
+    "\n",
+    "    tau_inv = 1.0 / tau \n",
+    "    sig2 = sigma ** 2 \n",
+    "    z = (x - mu - sig2 * tau_inv) / sigma \n",
+    "    cdf_gauss = norm.cdf(z)\n",
+    "    pdf_rt = tau_inv * np.exp(mu*tau_inv + (sig2 * tau_inv**2) / 2 - x*tau_inv) * cdf_gauss \n",
+    "    \n",
+    "    # Bernoulli part \n",
+    "    p = float(p)\n",
+    "    pdf_choice = np.where(y, p, 1 - p)\n",
+    "\n",
+    "    return pdf_rt*pdf_choice \n",
+    "\n",
+    "\n",
+    "x = np.linspace(0, 9, 1100)\n",
+    "choice = np.where(np.random.rand(len(x)) < p_exgauss, 1, -1)\n",
+    "pdf_vals = exgauss_likelihood_bernoulli(x, choice, mu0=mu0, mu1=mu1, sigma0=sigma0,\n",
+    "                                        sigma1=sigma1, tau0=tau0, tau1=tau1, p=p_exgauss)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define exgauss race likelihoods \n",
+    "\n",
+    "def exgauss_race_likelihoods(x, choice, mu0, mu1, sigma0, sigma1, tau0, tau1):\n",
+    "    x = np.asarray(x, dtype=float)\n",
+    "    y = (np.asarray(choice, dtype=int) > 0) # 1 choice \n",
+    "    mu_winner = np.where(y, float(mu0), float(mu1))\n",
+    "    sigma_winner = np.where(y, float(sigma0), float(sigma1))\n",
+    "    tau_winner = np.where(y, float(tau0), float(tau1))\n",
+    "\n",
+    "    mu_loser = np.where(y, float(mu1), float(mu0))\n",
+    "    sigma_loser = np.where(y, float(sigma1), float(sigma0))\n",
+    "    tau_loser = np.where(y, float(tau1), float(tau0))\n",
+    "\n",
+    "    # Winner density \n",
+    "    tau_inv_winner = 1.0 / tau_winner \n",
+    "    sig2_winner = sigma_winner ** 2 \n",
+    "    z_winner = (x - mu_winner - sig2_winner * tau_inv_winner) / sigma_winner \n",
+    "    cdf_gauss_winner = norm.cdf(z_winner)\n",
+    "    pdf_rt_winner = tau_inv_winner * np.exp(mu_winner*tau_inv_winner + (sig2_winner * tau_inv_winner**2) / 2 - x*tau_inv_winner) * cdf_gauss_winner \n",
+    "\n",
+    "    # Loser survival \n",
+    "    z0_loser = (x -mu_loser) / sigma_loser \n",
+    "    z1_loser = z0_loser - (sigma_loser / tau_loser)\n",
+    "    exp_factor = np.exp(- (x - mu_loser) / tau_loser + 0.5*(sigma_loser ** 2) / (tau_loser ** 2))\n",
+    "    F_loser = norm.cdf(z0_loser) - exp_factor * norm.cdf(z1_loser)\n",
+    "    surv_rt_loser = 1.0 - F_loser\n",
+    "    return pdf_rt_winner * surv_rt_loser\n",
+    "\n",
+    "x_race = np.linspace(0, 9, 1000)\n",
+    "choice_race = (np.asarray(sim_out_race[\"choices\"][:len(x_race)])).reshape(-1)\n",
+    "# choice_race = np.where(np.random.rand(len(x_race)) < p_race, 1, -1)\n",
+    "pdf_race_vals = exgauss_race_likelihoods(x_race, choice_race, mu0=mu0, mu1=mu1, sigma0=sigma0,\n",
+    "                                        sigma1=sigma1, tau0=tau0, tau1=tau1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define shifted wald analytical likelihoods\n",
+    "\n",
+    "def shifted_wald_likelihood(x, choice, v0, v1, a0, a1, t, p):\n",
+    "    x = np.asarray(x, dtype=float)\n",
+    "    y = (np.asarray(choice, dtype=int) > 0) # 1 choice\n",
+    "    v = np.where(y, float(v0), float(v1))\n",
+    "    a = np.where(y, float(a0), float(a1))\n",
+    "    t = float(t)\n",
+    "    p = float(p)\n",
+    "\n",
+    "    term_1 = (a / np.sqrt(2*np.pi*(x - t)**3))\n",
+    "    term_2 = np.exp((-(a-v*(x - t))**2) / (2*(x - t)))\n",
+    "    pdf_rt = term_1 * term_2\n",
+    "\n",
+    "    # Bernoulli part\n",
+    "    pdf_choice = np.where(y, p, 1 - p)\n",
+    "\n",
+    "    return pdf_rt*pdf_choice\n",
+    "\n",
+    "x_sw = np.linspace(0.001, 9, 1100)\n",
+    "p_sw = 0.8\n",
+    "choice_sw = np.where(np.random.rand(len(x_sw)) < p_sw, 1, -1)\n",
+    "pdf_vals_sw = shifted_wald_likelihood(x_sw, choice_sw, v0=v0, v1=v1, a0=a0, a1=a1, t=0.0, p=0.8)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define shifted_wald race likelihoods \n",
+    "\n",
+    "def shifted_wald_race_likelihoods(x, choice, v0, v1, a0, a1, t):\n",
+    "    x = np.asarray(x, dtype=float)\n",
+    "    y = (np.asarray(choice, dtype=int) > 0) # 1 choice\n",
+    "    v_winner = np.where(y, float(v0), float(v1))\n",
+    "    a_winner = np.where(y, float(a0), float(a1))\n",
+    "\n",
+    "    v_loser = np.where(y, float(v1), float(v0))\n",
+    "    a_loser = np.where(y, float(a1), float(a0))\n",
+    "\n",
+    "    # Winner density \n",
+    "    term_1_winner = (a_winner / np.sqrt(2*np.pi*(x - t)**3))\n",
+    "    term_2_winner = np.exp((-(a_winner-v_winner*(x - t))**2) / (2*(x - t)))\n",
+    "    pdf_rt_winner = term_1_winner * term_2_winner \n",
+    "\n",
+    "    # Loser survival \n",
+    "    z_loser = (a_loser - v_loser * (x - t)) / np.sqrt(x - t)\n",
+    "    F_loser = norm.cdf(z_loser)\n",
+    "    surv_rt_loser = 1.0 - F_loser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ex-Gaussian')"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAeTZJREFUeJzt3XlcVPX+x/HXDAMz7Kgoi6KIu6biSmqpKYm2aVYudXO5ttzM20LbtVIz69KiZnUty1za1cqsXwtqGGVKrrkvqbkrICrgoMM25/fHLDEKCjhwZvk8H495OHPmzJnPYRDefL/f8/1qFEVREEIIIYTwIlq1CxBCCCGEqG0SgIQQQgjhdSQACSGEEMLrSAASQgghhNeRACSEEEIIryMBSAghhBBeRwKQEEIIIbyOBCAhhBBCeB0JQEIIIYTwOhKAhBCiBo0ZM4bY2Fi1yxBCXEQCkBCi0hYuXIhGo6nw9vvvvzv1/VavXs2wYcNo2LAhfn5+hIaGkpCQwIsvvkhWVpZT30sI4V10ahcghHA/L774Ik2bNr1ke/PmzZ32HpMnT2batGnExcUxZswY4uLiMJlMbNq0iRkzZvDhhx9y4MABp71fTZk7dy5ms1ntMoQQF5EAJISoskGDBtG1a9caO/7ixYuZNm0aw4YN4+OPP8bPz8/h+TfeeIM33nijxt7fmXx9fdUuQQhRDukCE0I41ZQpU9BqtaSlpTlsf+CBB/Dz82Pr1q1XPMbkyZMJDw9n3rx5l4QfgNDQUF544QWHbd988w0333wz0dHR6PV6mjVrxrRp0ygtLXXYLzY2ljFjxlxyzL59+9K3b1+HbW+//Tbt2rUjICCAOnXq0LVrVz777DP78+fOneOxxx4jNjYWvV5PgwYNuPHGG9m8ebN9n/LGAE2fPp2ePXtSr149/P396dKlC19++eUlNWk0GiZMmMCyZcu45ppr0Ov1tGvXjtTU1Aq+ckKIypIWICFEleXl5ZGTk+OwTaPRUK9ePZ5//nn+7//+j3HjxrF9+3aCg4NZvnw5c+fOZdq0aXTs2PGyx/7zzz/5888/ue+++wgKCqp0TQsXLiQoKIjk5GSCgoJYtWoVkydPJj8/n9dff73K5zh37lweeeQR7rzzTh599FFMJhPbtm1j3bp13H333QD861//4ssvv2TChAm0bduW06dP89tvv7F79246d+5c4bHffPNNbrvtNu655x6KiopYtGgRd911F9999x0333yzw76//fYbS5cuZfz48QQHB/PWW29xxx13cOTIEerVq1fl8xJCWClCCFFJCxYsUIByb3q93r7f9u3bFT8/P+W+++5Tzp49qzRs2FDp2rWrUlxcfMX3+OabbxRAmTVrlsN2s9msnDp1yuFW9njnz5+/5FgPPvigEhAQoJhMJvu2Jk2aKKNHj75k3z59+ih9+vSxPx48eLDSrl27y9YaGhqqPPzww5fdZ/To0UqTJk0ctl1ca1FRkXLNNdco/fr1c9gOKH5+fsr+/fvt27Zu3aoAyttvv33Z9xVCXJ60AAkhqmz27Nm0bNnSYZuPj4/9/jXXXMPUqVOZOHEi27ZtIycnhxUrVqDTXflHTn5+PsAlrT95eXnUr1/fYduGDRvsY5H8/f3t28+dO0dhYSHXX3897733Hnv27Lliy9PFwsLCOHbsGBs2bKBbt24V7rNu3TpOnDhBdHR0pY9dttazZ89SWlrK9ddfz+eff37JvomJiTRr1sz+uEOHDoSEhPDXX39V4WyEEBeTACSEqLLu3btfcRD0U089xaJFi1i/fj3//e9/adu2rcPzmZmZDo9DQ0Px9/cnODgYAKPR6PB8UFAQK1euBGDFihWXdGvt3LmT559/nlWrVtlDlE1eXl7lT87qmWee4aeffqJ79+40b96cAQMGcPfdd9OrVy/7Pq+99hqjR48mJiaGLl26cNNNNzFq1Cji4uIue+zvvvuOl156iS1btlBYWGjfrtFoLtm3cePGl2yrU6cOZ8+erfI5CSH+JoOghRA14q+//mLfvn0AbN++/ZLno6KiHG6LFy8GoHXr1gDs2LHDYX+dTkdiYiKJiYmXhKnc3Fz69OnD1q1befHFF/m///s/Vq5cyauvvgrgcBl6eSEDuGSwdJs2bdi7dy+LFi3iuuuu46uvvuK6665jypQp9n2GDRvGX3/9xdtvv010dDSvv/467dq148cff6zw67J69Wpuu+02DAYD77zzDj/88AMrV67k7rvvRlGUS/Yv27JWVnn7CiEqT1qAhBBOZzabGTNmDCEhITz22GP897//5c4772To0KH2fWytOTbt2rUDoFWrVrRo0YJly5Yxa9YsAgMDr/h+6enpnD59mqVLl9K7d2/79oMHD16yb506dcjNzb1k++HDhy9puQkMDGT48OEMHz6coqIihg4dyssvv8zEiRMxGAyAJciNHz+e8ePHk52dTefOnXn55ZcZNGhQubV+9dVXGAwGli9fjl6vt29fsGDBFc9TCOE80gIkhHC6mTNnsnbtWt5//32mTZtGz549eeihhxyuHLO15thuUVFR9udeeOEFcnJyuP/++ykuLr7k+Be3fthaScpuLyoq4p133rnktc2aNeP333+nqKjIvu27777j6NGjDvudPn3a4bGfnx9t27ZFURSKi4spLS29pGutQYMGREdHO3RrXczHxweNRuPQ4nTo0CGWLVtW4WuEEM4nLUBCiCr78ccf2bNnzyXbe/bsSWFhIZMmTWLMmDHceuutgOUS9fj4eMaPH8+SJUuuePy7776bHTt2kJKSwvr16xkxYgRNmzaloKCAHTt28PnnnxMcHEydOnXs71unTh1Gjx7NI488gkaj4eOPPy63m+i+++7jyy+/ZODAgQwbNowDBw7wySefOAw0BhgwYACRkZH06tWLiIgIdu/ezf/+9z9uvvlmgoODyc3NpVGjRtx555107NiRoKAgfvrpJzZs2MCMGTMqPLebb76ZmTNnMnDgQO6++26ys7OZPXs2zZs3Z9u2bVf82gghnETNS9CEEO7lcpfBA8oHH3ygdOvWTWnUqJGSm5vr8No333xTAZTFixdX+v3S09OVO++8U4mKilJ8fX2VkJAQpWvXrsqUKVOUkydPOuy7Zs0a5dprr1X8/f2V6Oho5emnn1aWL1+uAMrPP//ssO+MGTOUhg0bKnq9XunVq5eycePGSy6Df++995TevXsr9erVU/R6vdKsWTPlqaeeUvLy8hRFUZTCwkLlqaeeUjp27KgEBwcrgYGBSseOHZV33nnH4b3Kuwx+3rx5SosWLRS9Xq+0bt1aWbBggTJlyhTl4h/JQLmX2Vd0Kb8QovI0iiIj6YQQQgjhXWQMkBBCCCG8jgQgIYQQQngdCUBCCCGE8DoSgIQQQgjhdSQACSGEEMLrSAASQgghhNeRiRDLYTabOXHiBMHBwRWuGySEEEII16IoCufOnSM6Ohqt9vJtPBKAynHixAliYmLULkMIIYQQ1XD06FEaNWp02X0kAJUjODgYsHwBQ0JCVK5GCCGEEJWRn59PTEyM/ff45UgAKoet2yskJEQCkBBCCOFmKjN8RQZBCyGEEMLrSAASQgghhNeRACSEEEIIryMBSAghhBBeRwKQEEIIIbyOBCAhhBBCeB0JQEIIIYTwOhKAhBBCCOF1JAAJIYQQwutIABJCCCGE15EAJIQQQgivIwFICCGEEF7HJQLQ7NmziY2NxWAwkJCQwPr16yv1ukWLFqHRaBgyZIjDdkVRmDx5MlFRUfj7+5OYmMi+fftqoHIhhBBCuCPVA9DixYtJTk5mypQpbN68mY4dO5KUlER2dvZlX3fo0CGefPJJrr/++kuee+2113jrrbeYM2cO69atIzAwkKSkJEwmU02dhhBCCCHciEZRFEXNAhISEujWrRv/+9//ADCbzcTExPDvf/+b//znP+W+prS0lN69e/PPf/6T1atXk5uby7JlywBL6090dDRPPPEETz75JAB5eXlERESwcOFCRowYccWa8vPzCQ0NJS8vj5CQEOecqBBCCFUZjUaHP4QNBgNBQUEqViScrSq/v3W1VFO5ioqK2LRpExMnTrRv02q1JCYmkpGRUeHrXnzxRRo0aMC4ceNYvXq1w3MHDx4kMzOTxMRE+7bQ0FASEhLIyMgoNwAVFhZSWFhof5yfn381pyWEEMLFGI1GlixZQklJiX2bTqdj2LBhEoK8lKoBKCcnh9LSUiIiIhy2R0REsGfPnnJf89tvvzFv3jy2bNlS7vOZmZn2Y1x8TNtzF0tJSWHq1KlVrF4IIYS7MJlMlJSU0K9fP8LCwsjNzWXVqlWYTCYJQF5K9TFAVXHu3Dnuvfde5s6dS3h4uNOOO3HiRPLy8uy3o0ePOu3YQgghXEdYWBjh4eGEhYWpXYpQmaotQOHh4fj4+JCVleWwPSsri8jIyEv2P3DgAIcOHeLWW2+1bzObzYClKXPv3r3212VlZREVFeVwzPj4+HLr0Ov16PX6qz0dIYQQQrgJVVuA/Pz86NKlC2lpafZtZrOZtLQ0evToccn+rVu3Zvv27WzZssV+u+2227jhhhvYsmULMTExNG3alMjISIdj5ufns27dunKPKYQQQgjvo2oLEEBycjKjR4+ma9eudO/enVmzZlFQUMDYsWMBGDVqFA0bNiQlJQWDwcA111zj8HpbM2bZ7Y899hgvvfQSLVq0oGnTpkyaNIno6OhL5gsSQgghhHdSPQANHz6cU6dOMXnyZDIzM4mPjyc1NdU+iPnIkSNotVVrqHr66acpKCjggQceIDc3l+uuu47U1FQMBkNNnIIQQggh3Izq8wC5IpkHSAghPEtOTg4r33uPob//jj4wkJxXX2Xp8uUMHTrUqRfVCHW5zTxAQgghRK0wmxn01lvorasMBNapA506qVyUUJNbXQYvhBBCVIdvejphZZZYMrz/Pv55eSpWJNQmAUgIIYTHM3z8MQAX7rsPevRAYzYTt3mzylUJNUkAEkII4dmKivCzTo1iGjkSbrkFgMh9+9SsSqhMxgAJIYTwbJs3o7lwAVNgIKXt24OPDwCRBw5wQa4D8lrSAiSEEMKz/fYbAJnNm4NGA926oeh0BObmopWlj7yWBCAhhBCezbp4dnZsrOVxQAAlHToA4Lt+vTo1CdVJABJCCOHZtm0D4EyjRvZNJV27AqCzhiPhfSQACSGE8FjGM2dQ9uwB4EzDhvbtJW3bAuBjfU54HwlAQgghPJLRaGTl//6HpriYIoMBU4MG9iWRStu0AUC3e7eaJQoVSQASQgjhkUwmE8HWQc6a9u0ZNnw4QUFBAJQ2bw6ANjsbzp1TrUahHglAQgghPFboqVMA+LZtaw8/AEpICBeCgy0P9u9XozShMglAQgghPFZwTo7lTlzcJc/lNWhguSMTInolCUBCCCE8Voi1BYhmzS55TgKQd5MAJIQQwmPZA1A5LUD5EoC8mgQgIYQQnqmwkMDcXMv9clqA8uvXt9z566/aq0m4DAlAQgghPJLP0aNoFAUlIABsYacMY926AJQePozRaKzt8oTKJAAJIYTwSNpDhwAobdrUsgZYGQaDAVN4uOXB8eMsWbRIQpCXkQAkhBDCI/kcOwZAaZklMGyCgoK4+b77ULRafEpL8c3NxWQy1XaJQkUSgIQQQngk7YkTAJijo8t9PqhOHTSRkQAEnjlTa3UJ1yABSAghhEfSnjwJgNkacsoVEwPw92Bp4TUkAAkhhPBI2sxMAMxRURXvZO0eC5IWIK8jAUgIIYRHsrcAVdAFBvzdAnT2bG2UJFyIBCAhhBAeyR6AKtMCJAHI60gAEkII4XkKCtDm5wNXCEDSAuS1JAAJIYTwPMePA1Ck16PYVn0vj7UFSAKQ95EAJIQQwvNY5wA6HxZ2+f3KXgVmNtdsTcKlSAASQgjheawtQMY6dS6/X1SUfTJEjW3hVOEVJAAJIYTwPNYAdMUWIJ0Os3VVeNtl88I7SAASQgjheayzQBdcKQABinWhVG12dk1WJFyMBCAhhBCeJysLgAshIVfc1d4CJAHIq0gAEkII4XlycgC4cLkrwKzsAUjGAHkVlwhAs2fPJjY2FoPBQEJCAuvXr69w36VLl9K1a1fCwsIIDAwkPj6ejz/+2GGfMWPGoNFoHG4DBw6s6dMQQgjhKqxhxhQUdMVdzdIF5pV0ahewePFikpOTmTNnDgkJCcyaNYukpCT27t1LA2sqL6tu3bo899xztG7dGj8/P7777jvGjh1LgwYNSEpKsu83cOBAFixYYH+s1+tr5XyEEEK4gKoEIOkC80qqtwDNnDmT+++/n7Fjx9K2bVvmzJlDQEAA8+fPL3f/vn37cvvtt9OmTRuaNWvGo48+SocOHfjtt98c9tPr9URGRtpvda50KaQQQgjPoCj2LjCTdIGJCqgagIqKiti0aROJiYn2bVqtlsTERDIyMq74ekVRSEtLY+/evfTu3dvhufT0dBo0aECrVq146KGHOH36tNPrF0II4YLy8qCkBKhcC5BiDUAaaQHyKqp2geXk5FBaWkpERITD9oiICPbs2VPh6/Ly8mjYsCGFhYX4+PjwzjvvcOONN9qfHzhwIEOHDqVp06YcOHCAZ599lkGDBpGRkYGPj88lxyssLKSwsND+ON+6fowQQgg3ZG3JMQcGUurre8XdZQyQd1J9DFB1BAcHs2XLFoxGI2lpaSQnJxMXF0ffvn0BGDFihH3f9u3b06FDB5o1a0Z6ejr9+/e/5HgpKSlMnTq1tsoXQghRk6wBSAkPr9Tu9gCUnw9FReDnV2OlCdehahdYeHg4Pj4+ZFnna7DJysoiMjKywtdptVqaN29OfHw8TzzxBHfeeScpKSkV7h8XF0d4eDj79+8v9/mJEyeSl5dnvx09erR6JySEEEJ91vE/5nr1KrW7EhqKWaOxPJDhEl5D1QDk5+dHly5dSEtLs28zm82kpaXRo0ePSh/HbDY7dGFd7NixY5w+fZqoqKhyn9fr9YSEhDjchBBCuClbC1DdupXbX6ulKCDAcl8CkNdQvQssOTmZ0aNH07VrV7p3786sWbMoKChg7NixAIwaNYqGDRvaW3hSUlLo2rUrzZo1o7CwkB9++IGPP/6Yd999FwCj0cjUqVO54447iIyM5MCBAzz99NM0b97c4TJ5IYQQHso2BqiSLUBgGSxtKCiwtx4Jz6d6ABo+fDinTp1i8uTJZGZmEh8fT2pqqn1g9JEjR9Bq/26oKigoYPz48Rw7dgx/f39at27NJ598wvDhwwHw8fFh27ZtfPjhh+Tm5hIdHc2AAQOYNm2azAUkhBDewNYFVskxQGC9WiwrS1qAvIjqAQhgwoQJTJgwodzn0tPTHR6/9NJLvPTSSxUey9/fn+XLlzuzPCGEEG7CaDSiO3oUA3De37/SrysMDLTckQDkNVSfCFEIIYRwBqPRyJIlS8jetQuAndnZ6HQ6DAbDFV9rny9IusC8hku0AAkhhBBXy2QyUVJSQgPrFV2dBgygy+DBBFViMkSTtAB5HQlAQgghPIpvXh4AIXFxUInwA2VagCQAeQ3pAhNCCOFRtLZuLOsEh5VhC0BFJ05gNBproizhYiQACSGE8Bg+RUVozp+3PKhkADIYDJRY5387u38/S5YskRDkBSQACSGE8BgGW3Dx9YVKTmobFBREj1tvBaCOolBSUoLJZKqpEoWLkAAkhBDCY9gDUHg42Ja3qISAmBgAdLm5NVCVcEUSgIQQQngM/3PnLHeqMP4HAOus0Zq8PDSlpU6uSrgiCUBCCCE8hqG6Aci6bphGUdDbxhAJjyYBSAghhMdw6AKrCl9fCA0FQF9Q4OSqhCuSACSEEMJj+NsCUFVbgMAemgxyBZhXkAAkhBDCY1S7Cwzs44AkAHkHCUBCCCE8huFqWoBsAUi6wLyCBCAhhBAeo9pjgMq8Ri8tQF5BApAQQgiPUe3L4EG6wLyMBCAhhBAeQ7rARGVJABJCCOEZSkr+nsPnarrAJAB5BQlAQgghPILm7Fk0imJ5YG3NqRLpAvMqEoCEEEJ4BO3p0wCY69QBna7qB5AuMK8iAUgIIYRH0NgCkHVZiyqTq8C8igQgIYQQHkFrXcldqW4AKtsCZOtKEx5LApAQQgiPoDl7FgAlLKx6B7AGIK3ZjCY/30lVCVclAUgIIYRH0OblAWCubgAyGFACAoC/u9OE55IAJIQQwiNcdQsQf48f0lqPJTyXBCAhhBAeQWMbA3QVAcg2fkhz5owTKhKuTAKQEEIIj2AbBF3tLjDKtABJAPJ4EoCEEEJ4BKe0ANWpYzmWdIF5PAlAQgghPIJGWoBEFUgAEkII4RHs8wBZW3GqQ8YAeQ8JQEIIITyCU68CkwDk8SQACSGEcH+lpWitkxc6owtMxgB5PglAQggh3J+1+wucMwhaWoA8nwQgIYQQ7s/aYlOk14Ovb7UPIy1A3sMlAtDs2bOJjY3FYDCQkJDA+vXrK9x36dKldO3albCwMAIDA4mPj+fjjz922EdRFCZPnkxUVBT+/v4kJiayb9++mj4NIYQQarG22BRZl7KoLiUkBPh7WQ3huVQPQIsXLyY5OZkpU6awefNmOnbsSFJSEtnZ2eXuX7duXZ577jkyMjLYtm0bY8eOZezYsSxfvty+z2uvvcZbb73FnDlzWLduHYGBgSQlJWEymWrrtIQQQtQmawAyBQZe1WFs3Wea8+ehuPhqqxIuTPUANHPmTO6//37Gjh1L27ZtmTNnDgEBAcyfP7/c/fv27cvtt99OmzZtaNasGY8++igdOnTgt99+AyytP7NmzeL5559n8ODBdOjQgY8++ogTJ06wbNmyWjwzIYQQtcbWBeakFiDAYVyR8DyqBqCioiI2bdpEYmKifZtWqyUxMZGMjIwrvl5RFNLS0ti7dy+9e/cG4ODBg2RmZjocMzQ0lISEhEodUwghhBuytgAVXmULED4+FBkMlvsyDsij6dR885ycHEpLS4mIiHDYHhERwZ49eyp8XV5eHg0bNqSwsBAfHx/eeecdbrzxRgAyMzPtx7j4mLbnLlZYWEhhYaH9cb71UkohhBBuwhpWCgMCCL7KQxUGBuJnMkkA8nCqBqDqCg4OZsuWLRiNRtLS0khOTiYuLo6+fftW63gpKSlMnTrVuUUKIYSoPdbuqsKr7AIDKPT3t4Qo6QLzaKp2gYWHh+Pj40NWVpbD9qysLCIjIyt8nVarpXnz5sTHx/PEE09w5513kpKSAmB/XVWOOXHiRPLy8uy3o0ePXs1pCSGEqG3WsHK1Y4AcjiEtQB5N1QDk5+dHly5dSEtLs28zm82kpaXRo0ePSh/HbDbbu7CaNm1KZGSkwzHz8/NZt25dhcfU6/WEhIQ43IQQQrgRWxeYv/9VH8reiiQtQB5N9S6w5ORkRo8eTdeuXenevTuzZs2ioKCAsWPHAjBq1CgaNmxob+FJSUmha9euNGvWjMLCQn744Qc+/vhj3n33XQA0Gg2PPfYYL730Ei1atKBp06ZMmjSJ6OhohgwZotZpCiGEqEnSAiSqSPUANHz4cE6dOsXkyZPJzMwkPj6e1NRU+yDmI0eOoNX+3VBVUFDA+PHjOXbsGP7+/rRu3ZpPPvmE4cOH2/d5+umnKSgo4IEHHiA3N5frrruO1NRUDLaR/UIIITyLk8cAlT2m8EwaRVEUtYtwNfn5+YSGhpKXlyfdYUII4Q6aNYO//uKbp5+m11NPER4eXq3D5OTkcHDcOLp9+y3cfz+8/76TCxU1qSq/v1WfCFEIIYS4arYWICeMASqSMUBeQQKQEEII96YoTh0DZA9RMgbIo0kAEkII4d6MRjCbASeNAbLNJi0ByKNJABJCCOHerK0/iq8vpb6+V324IhkE7RUkAAkhhHBvtgAUGgoazVUfrlAug/cKEoCEEEK4N1sActJVuw6DoOVCaY8lAUgIIYR7s7bUmMPCnHI4ewuQ2QznzjnlmML1SAASQgjh3pzcAlTq64vi5+dwbOF5JAAJIYRwa4XWxa+dcQUYABqNZTwRyDggDyYBSAghhNsyGo3sXLMGgGPnzqHT6Zyy7JG9O01agDyW6muBCSGEENVlMpnQGY0ANImPJ2bYMIKCgq76uNIC5PkkAAkhhHBr+gsXAAiIigInhB8oE4CkBchjSReYEEIIt+Z3/rzljpOuAoO/l8MwHjuG0drCJDyLBCAhhBBuzc/aAuSMAGQwGNDpdByxXv6+9/ffWbJkiYQgDyQBSAghhFvT21qA6tS56mMFBQUxbNgwmnbqBECzunUpKSnBZDJd9bGFa5ExQEIIIdyaM1uAwBKCaNgQAIMEH48lLUBCCCHcmr4GxgDZjqXNy3PeMYVLkQAkhBDCfZnNTm8BAuzdaRq5CsxjSQASQgjhtjRGIxrbgqU1EYDy8513TOFSJAAJIYRwWxprF5Wi14MTZoC2s4YpaQHyXBKAhBBCuC17AHLSQqh21hYgrbQAeSwJQEIIIdyWLQCZbTM3O4utBej8ebQlJc49tnAJEoCEEEK4LVsLjeLM8T8AoaGg0QBlrjITHkUCkBBCCLdVY11gWi1Yj+knAcgjSQASQgjhtuwByNldYGAfB2S/zF54FAlAQggh3JbtMnWnjwEC+zgg6QLzTBKAhBBCuC2t9TJ1p3eBgT0ASReYZ5IAJIQQwm3VaBeYrQVIusA8kgQgIYQQbsvWBVaTAUhagDyTBCAhhBBuy7ZYqbkGu8BkDJBnkgAkhBDCbclVYKK6JAAJIYRwW5qamggRpAXIw0kAEkII4bZqbCkMkDFAHs4lAtDs2bOJjY3FYDCQkJDA+vXrK9x37ty5XH/99dSpU4c6deqQmJh4yf5jxoxBo9E43AYOHFjTpyGEEKI2mc1ozp0DavgyeOkC80iqB6DFixeTnJzMlClT2Lx5Mx07diQpKYns7Oxy909PT2fkyJH8/PPPZGRkEBMTw4ABAzh+/LjDfgMHDuTkyZP22+eff14bpyOEEKK25OejURSgZgOQdIF5JtUD0MyZM7n//vsZO3Ysbdu2Zc6cOQQEBDB//vxy9//0008ZP3488fHxtG7dmg8++ACz2UxaWprDfnq9nsjISPutjnUwmxBCCA9hnQSxxNcX9HrnH1+6wDyaqgGoqKiITZs2kZiYaN+m1WpJTEwkIyOjUsc4f/48xcXF1K1b12F7eno6DRo0oFWrVjz00EOcPn26wmMUFhaSn5/vcBNCCOHizp4FoDAgoGaOX3YiRGtLk/AcqgagnJwcSktLiYiIcNgeERFBZmZmpY7xzDPPEB0d7RCiBg4cyEcffURaWhqvvvoqv/zyC4MGDaK0tLTcY6SkpBAaGmq/xcTEVP+khBBC1A5rC1BRTQUga8+BT0kJmEw18x5CNTq1C7gar7zyCosWLSI9PR2DwWDfPmLECPv99u3b06FDB5o1a0Z6ejr9+/e/5DgTJ04kOTnZ/jg/P19CkBBCuDprACr096+ZX2ZBQShaLRqz2XK1mfxe8CiqtgCFh4fj4+NDVlaWw/asrCwiIyMv+9rp06fzyiuvsGLFCjp06HDZfePi4ggPD2f//v3lPq/X6wkJCXG4CSGEcHE13QKk0dgnWNTK0AiPo2oA8vPzo0uXLg4DmG0Dmnv06FHh61577TWmTZtGamoqXbt2veL7HDt2jNOnTxMVFeWUuoUQQrgAWwDy96+xt7AFINt8Q8JzqH4VWHJyMnPnzuXDDz9k9+7dPPTQQxQUFDB27FgARo0axcSJE+37v/rqq0yaNIn58+cTGxtLZmYmmZmZGI1GAIxGI0899RS///47hw4dIi0tjcGDB9O8eXOSkpJUOUchhBA1wNYFVlMtQPx9eb3G+l7Cc6g+Bmj48OGcOnWKyZMnk5mZSXx8PKmpqfaB0UeOHEGr/TunvfvuuxQVFXHnnXc6HGfKlCm88MIL+Pj4sG3bNj788ENyc3OJjo5mwIABTJs2DX1NXCYphBBCHdZWmZpsATJLF5jHUj0AAUyYMIEJEyaU+1x6errD40OHDl32WP7+/ixfvtxJlQkhhHBZNT0GCOkC82Sqd4EJIYQQ1VLmKrCaIgHIc0kAEkII4Z5qoQXI1gWmkS4wjyMBSAghhHuqxUHQWmkB8jgSgIQQQrin2rwMXq4C8zgSgIQQQrin2gxA0gXmcaoVgP766y9n1yGEEEJUntkM1lBSK2OApAvM41QrADVv3pwbbriBTz75BJMsECeEEKK2nTtnX6G9NlqAZAyQ56lWANq8eTMdOnQgOTmZyMhIHnzwQdavX+/s2oQQQojyWbu/FIOBUl/fGnsb6QLzXNUKQPHx8bz55pucOHGC+fPnc/LkSa677jquueYaZs6cyalTp5xdpxBCCPE3WwCq4cWrHeYBsrY4Cc9wVYOgdTodQ4cO5YsvvuDVV19l//79PPnkk8TExDBq1ChOnjzprDqFEEKIv1kDkG2MTk0x29YCKymBgoIafS9Ru64qAG3cuJHx48cTFRXFzJkzefLJJzlw4AArV67kxIkTDB482Fl1CiGEEH+ztQDVcAAiIACzdT3KM3/9ZV94W7i/aq0FNnPmTBYsWMDevXu56aab+Oijj7jpppvsi5Y2bdqUhQsXEhsb68xahRBCCIta6gIz+PtTGBiI/7lzpH31FeeaNGHYsGEEBQXV6PuKmletAPTuu+/yz3/+kzFjxhAVFVXuPg0aNGDevHlXVZwQQghRrloKQEFBQZgbNIBz5+jRpg0/5OdjMpkkAHmAagWglStX0rhxY3uLj42iKBw9epTGjRvj5+fH6NGjnVKkEEII4aCWxgABaOvWhQMHCDaba/y9RO2p1higZs2akZOTc8n2M2fO0LRp06suSgghhLgs67w8Nd0CBEBYGCBzAXmaagUgpYJLAY1GIwaD4aoKEkIIIa6otgZBgz0AyWzQnqVKXWDJyckAaDQaJk+eTECZ6cdLS0tZt24d8fHxTi1QCCGEuIRaAahu3Zp/P1ErqhSA/vjjD8DSArR9+3b8/Pzsz/n5+dGxY0eefPJJ51YohBBCXKzsGKCanqBQusA8UpUC0M8//wzA2LFjefPNNwmpjb5XIYQQ4mJlrwKr6WBSpw4gXWCeplpXgS1YsMDZdQghhBCVV7YLrKaDiYwB8kiVDkBDhw5l4cKFhISEMHTo0Mvuu3Tp0qsuTAghhKhQLc0DBPwdgGRBVI9S6QAUGhqKRqOx3xdCCCFUoSj2Vh+zXAYvqqnSAahst5d0gQkhhFCN0QjWSQnlMnhRXdWaB+jChQucP3/e/vjw4cPMmjWLFStWOK0wIYQQolzW7i/8/KA25p6TAOSRqhWABg8ezEcffQRAbm4u3bt3Z8aMGQwePJh3333XqQUKIYQQDmwBKCwMrEMzapTtKrD8fHvLk3B/1QpAmzdv5vrrrwfgyy+/JDIyksOHD/PRRx/x1ltvObVAIYQQwkHZAFQbbC1AZjO+hYW1856ixlUrAJ0/f57g4GAAVqxYwdChQ9FqtVx77bUcPnzYqQUKIYQQDmo7ABkMoNcD4HfhQu28p6hx1QpAzZs3Z9myZRw9epTly5czYMAAALKzs2VyRCFqgNFoJCcnx34zGo1qlySEemo7AJV5L32Z8a/CvVVrIsTJkydz99138/jjj9O/f3969OgBWFqDOnXq5NQChfB2RqORJUuWUFJSYt+m0+kYNmwYQUFBKlYmhEpsAag2p2QJC4OsLAlAHqRaAejOO+/kuuuu4+TJk3Ts2NG+vX///tx+++1OK04IASaTiZKSEvr160dYWBi5ubmsWrUKk8kkAUh4JxVbgPwkAHmMagUggMjISCIjIx22de/e/aoLEkKULywsjPDwcPvjXOsvAYPBIEFIeBfb5ei1GYCsV4LJGCDPUa0AVFBQwCuvvEJaWhrZ2dmYL7os8K+//nJKcUKISxkMBnQ6HatWrQKkO0x4IRkDJJygWgHovvvu45dffuHee+8lKirKvkSGEKLmBQUFMWzYMEwmk3SHCe8kXWDCCaoVgH788Ue+//57evXq5ZQiZs+ezeuvv05mZiYdO3bk7bffrrA7be7cuXz00Ufs2LEDgC5duvDf//7XYX9FUZgyZQpz584lNzeXXr168e6779KiRQun1CuE2oKCgiTwCO+lZguQdIF5jGpdBl+nTh3q1q3rlAIWL15McnIyU6ZMYfPmzXTs2JGkpCSys7PL3T89PZ2RI0fy888/k5GRQUxMDAMGDOD48eP2fV577TXeeust5syZw7p16wgMDCQpKQmTyeSUmoUQQqhIWoCEE1QrAE2bNo3Jkyc7rAdWXTNnzuT+++9n7NixtG3bljlz5hAQEMD8+fPL3f/TTz9l/PjxxMfH07p1az744APMZjNpaWmApfVn1qxZPP/88wwePJgOHTrw0UcfceLECZYtW3bV9QohhFCZjAESTlCtLrAZM2Zw4MABIiIiiI2NxdfX1+H5zZs3V+o4RUVFbNq0iYkTJ9q3abVaEhMTycjIqNQxzp8/T3Fxsb1F6uDBg2RmZpKYmGjfJzQ0lISEBDIyMhgxYsQlxygsLKSwzPTm+fn5lXpvIVyFXBEmvIoa8wDJVWAep1oBaMiQIU5585ycHEpLS4mIiHDYHhERwZ49eyp1jGeeeYbo6Gh74MnMzLQf4+Jj2p67WEpKClOnTq1q+UKoTq4IE15HUdS5DF66wDxOtQLQlClTnF1HtbzyyissWrSI9PR0DAZDtY8zceJEkpOT7Y/z8/OJiYlxRolC1Ci5Ikx4nfPnwTYrelgY1FaLTJlB0LIcqmeo1hggsDS5f/DBB0ycOJEzZ84Alq6vsoORryQ8PBwfHx+ysrIctmdlZV0yyeLFpk+fziuvvMKKFSvo0KGDfbvtdVU5pl6vJyQkxOEmhMsymeDcOfvDoKAgwsPDCavNv4aFUIut+0ung4CA2ntfaQHyONUKQNu2baNly5a8+uqrTJ8+3T7+YOnSpQ7jea7Ez8+PLl262AcwA/YBzbb1xcrz2muvMW3aNFJTU+natavDc02bNiUyMtLhmPn5+axbt+6yxxTCpSkKfl9/Db16QXAwhIRAixbwyiu19xewEK6g7ADo2pyDzhaATCa4aPJf4Z6qFYCSk5MZM2YM+/btc+h6uummm/j111+rfKy5c+fy4Ycfsnv3bh566CEKCgoYO3YsAKNGjXIIVa+++iqTJk1i/vz5xMbGkpmZSWZmpn11bI1Gw2OPPcZLL73Et99+y/bt2xk1ahTR0dFOG7skRK0qKqLfvHmEPPAArF37d/P//v0wcSL07g1lWl5zc3Nl1XjhudS4AgzsA641ioJGLpTxCNUaA7Rhwwbee++9S7Y3bNiwwoHGFRk+fDinTp1i8uTJZGZmEh8fT2pqqn0Q85EjR9Bq/85p7777LkVFRdx5550Ox5kyZQovvPACAE8//TQFBQU88MAD5Obmct1115GamnpV44SEqG1GoxHT2bP4jxpF+IYNKL6+aJ5/Hu6913JFyrJl8OSTsHEj9OiB/08/OQyIBhkULTyQWgFIr0fx90dz4QIa2yBs4daqFYD0en25l4r/+eef1K9fv8rHmzBhAhMmTCj3ufT0dIfHhw4duuLxNBoNL774Ii+++GKVaxHCFRiNRpYsWUKvefNotXYtJb6+FC9ahP/QoX/vNGaMpfVn0CD4808CR4xgWGoqJusfDDIoWngktQIQYA4NxUcCkMeoVhfYbbfdxosvvkhxcTFgCRxHjhzhmWee4Y477nBqgUJ4I5PJROyaNbRauxZFq6X4yy8dw49NXBykpkL9+vDHHwS98grh4eEyKFp4LjXmALJSrO+plS4wj1CtADRjxgyMRiP169fnwoUL9OnTh+bNmxMcHMzLL7/s7BqF8DqaU6fo9fnnlvuTJuF/220V79y0KXz4oeX+rFnw2281X6AQalFjDiArxXqFsLQAeYZqdYGFhoaycuVK1qxZw9atWzEajXTu3Nlh9mUhRPUFvvwy+gsXKOnQAd2kSVd+waBBMHYsLFgA48fDH3/UfJFCqEHFLjBbC5AEIM9Q5QBkNptZuHAhS5cu5dChQ2g0Gvul54qioKnNyxKF8ESbN6P/7DMAjCkphPn4VO51M2ZYBkZv324JQnLVo/BE1gBU4OvLhZwc+zQstcEsAcijVKkLTFEUbrvtNu677z6OHz9O+/btadeuHYcPH2bMmDHcfvvtNVWnEN5j6lQ0isL+bt0o6d698q+rUwcmT7bcnzYNiopqpj4hVFSckwPAlkOHWLp0KatWrUKn09XKVb62LjCtBCCPUKUWoIULF/Lrr7+SlpbGDTfc4PDcqlWrGDJkCB999BGjRo1yapFCeI0//oBvv0XRaNh0yy30r+rr//UvePVVOHIE/RdfgL9/TVQphGqUs2cBaNa1K62sFwbU1iLAirXbTVqAPEOVWoA+//xznn322UvCD0C/fv34z3/+w6effuq04oTwOv/9LwCFt99O3hWWgymXwQBPPAFAwJtvopEZa4WHsYUP/6go+xWPtTXNg30MkFwF5hGqFIC2bdvGwIEDK3x+0KBBbN269aqLEsIrHT4MS5cCcOHRR6t/nH/9C+rWxefgQRpv3+6k4oRwDbbuJyU4uNbf2yxXgXmUKgWgM2fO2GdoLk9ERARnrc2TQogqevddyxpD/fpR2rZt9Y8TFAT33QdA24smEhXC3dlaXxQ15wGSAOQRqhSASktL0ekqHjbk4+NDiW2dIiFE5V24gPL++wDkjx599Ve2PPggikZDzK5dFGzdKuuCCc9QZh0uNQOQtAB5hioNglYUhTFjxqDX68t9vrCw0ClFCeFtTJ9/juHsWc7Vrcvi8+dRrvbKlrg4Sm+8Ed2KFeS98grL77pL1gUT7s9kQmO9utF2RVZtkgDkWaoUgEaPHn3FfeQKMCGqTmu9eKD47ru53brQ79Ve2aL7979hxQqu+eMPAt56i1WrV8u6YMK9WYdYmLVaFBW+j2UeIM9SpQC0YMGCmqpDCO918iS+trE6995LeHi4c447cCBERKDNyqLB5s3OOaYQajpzBoAif39QYdJd+xigggIoKYHLDAkRrq9aa4EJIZzos8/QmM1kxsVhjotz3nF1OrjnHgD0ixc777hCqMXaAmQKDFTl7R263aQVyO1JABJCbR9/DMC+a691/rGtXdJ+y5fjV1Dg/OMLUZusAagoIECd99fpKLKNga3FJThEzZAAJISatm2DrVtR/Pz4q2tX5x+/Y0do3x5NURGxW7Y4//hC1CZrACpUKwBRJnzJlC9uTwKQEGqytv4U3XgjhTXVrH/XXQA0lRXihbuzBSCVusDAOv4IpAXIA0gAEkItigJffAFAofXKrxpxxx0ANNq1S6bwF+7NBVqA7O8tAcjtSQASQi1btsDhwyj+/pzq0qXm3qdtW0patMCntBS/FStq7n2EqGm2q8BcoQtMApDbkwAkhEqKrFdmHWrVirSMjKub+PBK73XrrQD4ffddjRxfiFqh8lVgIC1AnkQCkBAq0X7zDQD+//gHQ4cOrdFZmgtvuQUAv7Q0kCUxhLtS+yowZAyQJ5EAJIQa9u1Dt2cPZq0W38GDCQ8Pr9EZmkuvuYb88HA0JhP8+GONvY8QNUrGAAknkgAkhBq+/hqAE61aoYSF1fz7aTT81bmz5f5XX9X8+wlRE1wgANlbgOQyeLcnAUgINSxdCsDBTp1q7S0Pxcdb7ixfDiUlGI1GcnJyZKV44T5cIQBJC5DHkIVMhKhtWVmwbh0Ahzt2pE0tve2ppk0x162L9swZzv/0E0tOnKCkpARAVooXrk9R7FeBqTkPkHSBeQ5pARKitqWmAlDSoQPna6P7y0rRainq18/y4IcfKCkpoV+/fvTr14+SkhJMJlOt1SJElZ0/D8XFgLqDoAtlJmiPIQFIiNr2/feAZfbn2lacmAiA308/ARAWFkZYLYYwIarNGjgUnY5i23pcKpAuMM8hAUiI2lRcDNbJCNUIQEX9+oFWi273bgKt3QlCuAVbAAoLA41GtTLscxCdOWPplhNuSwKQELVp7VrIy4PwcEpsg5JrkVKnDvToAUDj7dtr/f2FqDZrADKHhqpahr0LrLDQ0i0n3JYEICFq0w8/WP4dNAh8fNSp4aabAGi8Y4c67y9EdZRtAVJRiV6P4utreSCtqG5NApAQtcm2FtfAgerVcPPNAETv2WP5K1YId2ANG4rKLUBoNH+HMAlAbk0CkBC1JTvbsgAqgHUwcm3Lzc0lJzqakvBwfIuK8N24UZU6hKgyWxeYCwzaN9epY7kjAcitSQASorakpVn+7dgRGjSo1bc2GAzodDpWrVrF0q+/5mBcHAD+a9bUah1CVJutC0ztFiCQFiAPoXoAmj17NrGxsRgMBhISEli/fn2F++7cuZM77riD2NhYNBoNs2bNumSfF154AY1G43Br3bp1DZ6BEJVk6/5S4eqvoKAghg0bxtChQxk6dCiR//gHAH6//FLrtQhRLbYAZGt9UZG0AHkGVQPQ4sWLSU5OZsqUKWzevJmOHTuSlJREdnZ2ufufP3+euLg4XnnlFSIjIys8brt27Th58qT99ttvv9XUKQhROYoCK1da7g8YoEoJQUFBhIeHEx4eTvDtt1s2btyIRuYzEe7AhbrApAXIM6gagGbOnMn999/P2LFjadu2LXPmzCEgIID58+eXu3+3bt14/fXXGTFiBPrLTISl0+mIjIy038LDw2vqFISonD174Phx0OvhuuvUrgYaNYLWrcFsxlf+QBDuwJW6wOrWtdyRAOTWVAtARUVFbNq0icQyg0G1Wi2JiYlkZGRc1bH37dtHdHQ0cXFx3HPPPRw5cuSy+xcWFpKfn+9wE8KpbK0/118PttWk1WbtivP99VeVCxGiElzkMngo0wolAcitqRaAcnJyKC0tJSIiwmF7REQEmZmZ1T5uQkICCxcuJDU1lXfffZeDBw9y/fXXc+7cuQpfk5KSQmhoqP0WExNT7fcXolwqjv+pkG1ZjPR0wHqFmKwOL1yVNWyoPREilBmHJAHIrXncavCDBg2y3+/QoQMJCQk0adKEJUuWMG7cuHJfM3HiRJKTk+2P8/PzJQQJpzGeOUPgzz+jAc736oV6yzhepG9f8PHB5+BBwnJzWbVqlf0pWR1euJyyLUBZWaqWYm8BOn1a1TrE1VEtAIWHh+Pj40PWRd/IWVlZlx3gXFVhYWG0bNmS/fv3V7iPXq+/7JgiIarLaDTyy6uvcvP581wIDmbR7t0MaNIEg8FArtqDj0NCICEB1q7ltsBAjEOHApaWoFWrVmEymSQACdegKH9PhGgbf6MiaQHyDKp1gfn5+dGlSxfSbHOjAGazmbS0NHpY1ypyBqPRyIEDB4iKinLaMYWoLJPJRJR1yQnlhhtAq+WHH35g6dKlrFq1Cp1Oh8FgUK9Aa5ecYfVq+xVisjq8cDl5eVBaCpS5BF1F+TpL20GpdBe7NVW7wJKTkxk9ejRdu3ale/fuzJo1i4KCAsaOHQvAqFGjaNiwISkpKYBl4PSuXbvs948fP86WLVsICgqiefPmADz55JPceuutNGnShBMnTjBlyhR8fHwYOXKkOicpvF703r0ABNx2G8OGDcNkMtmfMxgM6rayJCbC1KmwapXlr2wVV9kWokK2rqaAAFDxDwbbhKK/7drFSEDJyWHJkiXSXeymVA1Aw4cP59SpU0yePJnMzEzi4+NJTU21D4w+cuQIWu3fjVQnTpygU6dO9sfTp09n+vTp9OnTh3TrQM5jx44xcuRITp8+Tf369bnuuuv4/fffqV+/fq2emxAAFBTQ4OBBy/1+/QgKCnKtH5Tdu1uuSjt1CnbvhrZt1a5IiEvZAlC9eqqWYZtQtDA7G557Dl1xMcr589Jd7KZUHwQ9YcIEJkyYUO5ztlBjExsbi6Iolz3eokWLnFWaEFfNd8MGtGYzpY0a4RMbq3Y5l/Lzg1694KefID1dApBwTbaxNioHILCEoKDAQPDxgdJS9OfPq12SqCbVl8IQwpP5WtfaKu7Z03W7l/r2tfx70R8cQrgMF2kBstNowDoWSV9QoHIxorokAAlRg+wBqFcvlSu5jLIB6AotrEKowtUCEID1ajQJQO5LApAQNaWgAN0ffwAuHoC6dXMcBySEq3HFAGStRbrA3JcEICGczGg0kpOTQ96PP6IpKeFc3bqYGzdWu6yK2cYBgXSDCddkC0AuMAeQnbUWg1wG77YkAAnhREajkSVLlrB06VL+si7qm9m6NQZXWf+rIjIOSLgyawAyusIEojbSBeb2JAAJ4UQmk4mSkhL69evHNTk5AMT84x+uf4msjAMSLqwkOxuADQcOuMYEovB3C5AEILel+mXwQniiMF9ffK3jfwwDB6pcTSWUGQfk8+efalcjhCPrHxOtevak/e23qz+BKIB1bjnpAnNf0gIkRA3w3bABSkqgcWNwxfl/LlZmHJDtyjUhXIXG2u0VEBNDeHi4+uEHIDwckADkziQACVED7CGib1/Xnf/nYtZuMAlAwtVorBMhusI6YHYSgNyeBCAhaoBDAHIXtgC0dq2MAxKuo6gIrTVkuMJK8HbSBeb2JAAJ4WS6wkL7/D9uFYCs44C0OTmEnTypdjVCWNhafzQalNBQlYspw9YCdO6cyoWI6pIAJISTRRw4gMadxv/YlBkHFC0DoYWrsF4CXxQQAFoX+pVlawE6f94y3k+4HRf6bhLCM9jDgzuN/7GxtlhFSQASrsIagEyuMPC5rDp1UKz/v21jlIR7kQAkhJNFlQ1A7sZac/Sff5J79iw5OTkYZYyDUJMtAAUGqlzIRXQ6lLAwALQSgNySzAMkhDMVFNDg4EHLfXcMQN26ofj743/uHH98+ilno6PR6XQMGzbMNS49Ft7HGoAKAwNd7heWuV49tGfPorUt1SHcirQACeFEvhs2oDWbKW3UyL3G/9j4+aHp2ROAQQEB9OvXj5KSEkwmk8qFCa9lbV0pdLUWIP6+Kk0jAcgtSQASwolsl78X9+zpfuN/bKwtV0GbNhFmbeIXQjWu2gUGmK1XgkkXmHuSACSEE9kDkG11dXfUp4/lX1kXTLgCWxeYC3bBSguQe5MAJISzFBTY5/9x6wDUvTsYDJCdjc/+/WpXI7ydK7cA1asHIGOA3JQEICGcZe1aNCUlnKtbF3PjxmpXU316PfToAciyGMIFuOpl8PwdgKQFyD1JABLCWdLTATjZsqX7jv+xKbsshhBqOnUKcM0AZOsCkzFA7kkCkBDOYg1AJ1q2VLcOZ7COA/Jds0bGAQl1ZWcDYAoOVrmQS9m7wHJyVK5EVIcEICGcoaAA1q8H4GSrVioX4wQJCaDXo83OJtT6C0iIWldSYr8M/oILBiDF1gUmLUBuSQKQEM6wZg2UlFDasCHnrD8U3ZrBANdeC0DU3r0qFyO8lnVsjaLRuOQ8QA6DoKWl1O1IABLCCYpWrACgoHt39x//Y2PtBovat0/lQoTXsrY+KnXrorjSQqhWZttl8IWFllZg4VZc7ztKCDdjNBo5u2wZAJuDg9HpdBgMBnWLcoYy64LJX7dCFdYB0LYJB11OYCAlOusCHTIOyO1IABLiKplycqhvXf+rwyOPeM66Wddei+LnR2BuLlrb+mZC1CZrAFJctVtZo/l7cLa1VuE+JAAJcZXKrv9Vt3Nnzwg/AP7+lHTuDMh8QEIl1i4ws6sGIMpcni8tQG5HApAQV8kj1v+qQLF1YVTfjAyVKxFeydW7wCgTgKQFyO1IABLiKtkmCyy+7jqVK3E+25IeMh+QUIWtC8wdApC0ALkdCUBCXA2j0TPW/6pAcdeulPr44HPiBMg4IFHb3KkLTFqA3I4EICGuhm39r3r13Hv9r4oEBHAqNtZy3zrTtRC1xtYF5sIByD5Bo7QAuR0JQEJcDU9a/qICJ23n9ssv6hYivI+tC6x+fZULqZh0gbkv1QPQ7NmziY2NxWAwkJCQwHrrcgLl2blzJ3fccQexsbFoNBpmzZp11ccU4qr8/DNQJiR4IHu4kxYgUdvcqQtMloxxO6oGoMWLF5OcnMyUKVPYvHkzHTt2JCkpiewKvpHOnz9PXFwcr7zyCpGRkU45phDVZjTChg2AZ7cAZcXFoeh0cOQIHDqkdjnCW5RZB8yVA9CFkBDLnawsdQsRVaZqAJo5cyb3338/Y8eOpW3btsyZM4eAgADmz59f7v7dunXj9ddfZ8SIEej1eqccU4hqW7MGSkspjYnB6MJXqVytEoOBkvh4ywNpBRK1xboOGBoNinXJCVd0XgKQ21ItABUVFbFp0yYSExP/LkarJTExkYxqzjlS3WMWFhaSn5/vcBPiiqxhwDZXjiezn6OMAxK1xXZVVb164OOjbi2XcSE01HLHaLTchNtQLQDl5ORQWlpKRESEw/aIiAgyMzNr9ZgpKSmEhobabzExMdV6f+FlbAHIAy9/v1hux44AlK5ahVF+yIvaYBu24MIDoAGK9XqUgADLA2kFciuqD4J2BRMnTiQvL89+O3r0qNolCVdXZvyPJwcgg8GATqdjudGIWavF58gRvn/3XY4dO0ZOTo6EIVFzbC1ADRqoW8eVaDSYbSGtmn+8C3Xo1Hrj8PBwfHx8yLooMWdlZVU4wLmmjqnX6yscUyREuWzjfxo35oxtDIAHCgoKYtiwYZhMJko//BDt5s1E7t3LDz/8AIBOp/OcxV+Fa3GTFiAAc4MG+Bw+LAHIzajWAuTn50eXLl1IS0uzbzObzaSlpdGjRw+XOaYQ5SlasQKA/Q0bsmrVKnQ6HQaDQeWqakZQUBDh4eH4WsfW9SwqYujQofTr14+SkhJMJpPKFQqPdPKk5d+oKHXrqASzrZVKusDcimotQADJycmMHj2arl270r17d2bNmkVBQQFjx44FYNSoUTRs2JCUlBTAMsh5165d9vvHjx9ny5YtBAUF0bx580odUwhn0Pz6KwBhQ4YwdOhQDAaD57eC9OkDr72G79q1hHvwVW/CRdhaU6rZI1Cb7AFIWoDciqoBaPjw4Zw6dYrJkyeTmZlJfHw8qamp9kHMR44cQav9u5HqxIkTdOrUyf54+vTpTJ8+nT59+pBuHZB6pWMKcdXy8+3rf/neeCN1vSUMXHcdaLVw4AAcOwYe2uIlXIQ7BSAZA+SWVA1AABMmTGDChAnlPpd+0ZwjsbGxKJVYkfpyxxTiqv3yC5rSUvLq18fsTVcMhoRA586wcaPlcvikJLUrEp7MjbrACoKCCARKjh1T/5eqqDS5CkyIqvrpJwCOt2mjciEq6NPH8q9MiChqmhu0ANmukvzDGtbO7tkjV0a6EQlAQlSVdZD98datVS5EBX37Wv6VACRqUmnp31eBuXAAsl0lmTB4MACGvDy5KMCNSAASoipOnoSdO1E0Gk60aqV2NbXv+ust44D270d77Jja1QhPlZMDZjNoNC5/GXxQUBBh1j+GAvLzoRLDNIRrkAAkRFVYW39KOnSg0NOv+ipPaCh07w6Ar/VKOCGczjb+p0ED0LnBqBrrRTY+JSVo8vJULkZUlgQgIarCGoCKe/dWuRAVWecD8pV1wURNsY7/KQkPJycnh9zcXHXruRKDAbN1QlStbQZr4fIkAAlRWYpiHwAtAQj8fv3V0k0hhJOZDh0C4KSisHTpUreYbNQ2F5DWNnZJuDw3aFsUwkX8+adl/hu9nuKEBPjxR7UrUse110JAANqcHOqeOKF2NcIDlR4/DkBoq1YMHToUwOUnG1UaNID9+9FIAHIb0gIkRGVZW3/o1Qv8/dWtRU16vf1y+Ia7d6tcjPBEWuuSErqYGMLDwwkPD3fp8ANlWoBkMkS3IQFIiMqyrTFn7QLyatavQcM9e1QuRHgiWzeS2dVXgi+jNDoaAB/bAG7h8qQLTIjKKC2FVass9/v3V7cWV2ANQFF//slh6y8rV++iEO7DHQOQ2TpjtVa6hd2GBCAhKmPjRsjLs1wG3qULnD2rdkXquuYazPXr43vqFLvmzyezZUt0Oh3Dhg2TECSumq0bya0CkLUFSAKQ+5AuMCEqwzbgOTERfHzUrcUVaLVora1AiYpCv379KCkpkVlwxdVTlL8DkDVUuAN7AJIuMLchAUiIyrAFoJtuUrcOV2INQAFr1xIWFqZuLcJznD2L5sIF4O9uJXdgD0CZmZYuc+HyJAAJcSWnTsGGDZb7AweqW4srsQ0GX78ejatPVCfch3WJlQtBQeDC8/5czNygAWaNBk1JCad37yYnJ0cWRnVxMgZIiCtZscIyCWLHjuBGTfI1rnFjaNsWdu3CVxZHFc5iDUAFdeqoXEjVGIKCuBAWRuDZs/z62Wecio2VcXEuTlqAhLgSW/fXoEHq1uGKrF2CfrY5koS4WtZJEAvcrFs1KCgIQ7NmAPRv1UrGxbkBCUBCXE5pKSxfbrkvAehStgC0apUsiyGcw01bgAB8mjQBICQ/X8bFuQEJQEJczsaNkJMDISHQo4fa1bieXr0gOBjtqVOEHzmidjXCE7hxAKJRI8u/1lYs4dokAAlxObburxtvBF9fdWtxRX5+9sHQjXfsULkY4RFsAcgdW1BsAch6DsK1SQAS4jJKv/8egHPXXy9XdFTE2g0WIwFIOIMntABJAHILEoCEKMNoNJKTk0NOTg4ntm5Fu2kTAN8UFrJkyRIJQeWxjo1qcOgQmtOnVS5GuD1r95FRApCoYXIZvBBWRqORJUuWUFJSAkDzdeuIVhSK2rbl2qFDWbVqFSaTSS5pvVjDhpS0a4du5078fv4ZWrVSuyLhrs6dsyw5A5x39y4wRVG3FnFF0gIkhJXJZKKkpIR+/foxdOhQep05A4Df4MH2Kzpyc3PJyckhVyb+c1BkHQfkK5fDi6thbf0xh4RQ7EaTINrZ5gkrLERj/fkhXJe0AAlxkbCwMMKDgyEtzbJh8GAMBgM6nY5VthXhAZ1Oh8Edf0jXgKLERALefNNyOXxpqayXJqrn6FHAvZbAcODnBxERkJUli6K6AQlAQpTn558tzfFRUdCtG0FaLcOGDXOY1MxgMEh3mFVJ164UBgSgP3sW1q2Dnj3VLkm4o8OHATDHxKhcyFWIiYGsLHysYU64LukCE6I8y5ZZ/h08GLSW/yZBQUGEh4fbbxJ+ytDpONquneW+7WsnRBUV7d0LwPnISJUruQpxcQBoZV4slycBSIiLmc3wzTeW+0OGqFqKOznYqZPlztKlMgBUVJnRaOTo6tUA7LlwwX27mJs2BcDH2polXJcEICEuotu8GTIzLbM/33CD2uW4jaPt2qEYDHDgAGzfrnY5ws2YTCYCT50CoO1NN7nvIqLWFiAJQK5PApAQF/Gzzf58002WQY2iUkoMBopsgXHpUnWLEW4p2DqPVEjHju4ZfuDvLjAJQC5PApAQZSkKfj/8YLk/eLC6tbihXGsAKvniC5k0UlTNhQsEWucAIjZW1VKuiq0L7MgR6Qp2cRKAhCijzokT6Pbvt7T8yOrvlWabJiBVp8Os1aLbtYvUt9+WECQqzcc2B1BQENStq3I1V6FxY9Bq0ZhM+Ofnq12NuAwJQEKU0XzDBsudQYMgNFTdYtxIUFAQw4YN4+Z776Xk+usBiNm40WHaACEux9ZlZG7cGDQalau5Cr6+lhAEhFjHNAnXJAFICBtFIW7jRsv9ESPUrcUN2aYJ8Bs+HIDYP/5QuSLhTmzz5pS68xxANtZusOCcHJULEZfjEgFo9uzZxMbGYjAYSEhIYP369Zfd/4svvqB169YYDAbat2/PD7YxG1ZjxoxBo9E43AYOHFiTpyA8gG7rVkJPnULx94dbblG7HPc1ZAiKRkPEwYOc272bnJwc6QoTV2SbN8dsbT1xa9aB0CESgFya6gFo8eLFJCcnM2XKFDZv3kzHjh1JSkoiOzu73P3Xrl3LyJEjGTduHH/88QdDhgxhyJAh7Nixw2G/gQMHcvLkSfvt888/r43TEW7MzzqBX9GAAeCuV6C4gqgozN27A3Dyf/9j6dKlLFmyREKQuCwfawAq9YQAJC1AbkH1ADRz5kzuv/9+xo4dS9u2bZkzZw4BAQHMnz+/3P3ffPNNBg4cyFNPPUWbNm2YNm0anTt35n//+5/Dfnq9nsjISPutTp06tXE6wl2ZzeitAahQJj+8aj533w1At3376NevHyUlJTIeSFyWz8GDAJibNFG5EiewtgBJAHJtqgagoqIiNm3aRKJ1JWkArVZLYmIiGRkZ5b4mIyPDYX+ApKSkS/ZPT0+nQYMGtGrVioceeojT1vklylNYWEh+fr7DTXgPo9FIbmoqPsePU2QwUNS/v9olub/hw8HHB98//qDuZf7vCQGAoqA9cACA0ubNVS7GCWxdYDII2qWpGoBycnIoLS0lIiLCYXtERASZmZnlviYzM/OK+w8cOJCPPvqItLQ0Xn31VX755RcGDRpEaWlpucdMSUkhNDTUfovxhEF4olKMRiNLlizh2OuvA3AkPh6DtBZevYgIuPFGAAxffaVyMcLlnTyJtqAAs0ZDqSe0ALVsCUBQbi4a6fp1Wap3gdWEESNGcNttt9G+fXuGDBnCd999x4YNG0hPTy93/4kTJ5KXl2e/HZVVfL2GyWTCbDLRZutWABo+9ZT7zkDrau65BwD9l1/KhHDi8v78E4Bz4eGeMft6nTqY69cHwGf/fpWLERVRNQCFh4fj4+NDVlaWw/asrCwiK1gNODIyskr7A8TFxREeHs7+Cr4R9Xo9ISEhDjfhPRpv24bP2bMQHY2/zP7sPEOGQEAAPgcPUv/QIbWrEa7MGoDyLmrdd2elLVoA4LNvn8qViIqoGoD8/Pzo0qULaWlp9m1ms5m0tDR69OhR7mt69OjhsD/AypUrK9wf4NixY5w+fZqoqCjnFC48Squ1ay137r0XfHzULcaTBAVZQhDQYt06dWsRrs0WgBo0ULkQ5ymxBSDruQnXo3oXWHJyMnPnzuXDDz9k9+7dPPTQQxQUFDB27FgARo0axcSJE+37P/roo6SmpjJjxgz27NnDCy+8wMaNG5kwYQJgGdPx1FNP8fvvv3Po0CHS0tIYPHgwzZs3JykpSZVzFK5Lk5VFzM6dlgfW7znhRP/4BwDNNmyAwkKVixEuS1qAhAp0ahcwfPhwTp06xeTJk8nMzCQ+Pp7U1FT7QOcjR46g1f6d03r27Mlnn33G888/z7PPPkuLFi1YtmwZ11xzDQA+Pj5s27aNDz/8kNzcXKKjoxkwYADTpk1Dr9erco7CdRm+/BKt2Uxxt274tmqldjme58YbKY2MxD8zk+LUVBg3Tu2KhCvy5AAkY4BclkZRZHTixfLz8wkNDSUvL0/GA3kys5mSli3RHTjAuRkzCE5OVrsij3T+iScImDmTor598fv5Z7XLEa6msNDSXVpSwqcpKSTddx/h4eFqV3XVzmzZQt1OnVB8fTl95AiGoCC5wKIWVOX3t+pdYEKoJi0N3YEDFBkMFA4dqnY1HstknRTRLz0drJPdCWG3Zw+UlGAOCaHAg6ag8IuLo9jPD01xMWlz58ps6C5IApDwXtbZw//s0UOWvqhB5iZNONamjeXBvHnqFiNcz/btAJS2aePeq8BfJCgkBK31+753eLjMhu6CJAAJ73T4MHz3HQA7+/ZVtxYvsPv66y135s6VwdDCkTUAlbRtq3IhzucTHw9AiEwD4ZIkAAnvNGcOmM0U9e5N3mXmkBLOcSg+ntLoaMjOhkWL1C5HuJKyLUCeplMnAHTbtqlciCiPBCDhFYxGIzk5OZbbsWOY584F4PTw4SpX5h0UHx9M//yn5cGsWTIztPibrQXIEwNQ584A6KznKFyL6pfBC1HTbOt9lZSUANDm11+5/vRpjHXq8J1Gg06nw2AwqFyl5zPdey+BM2bAli2wejX07q12SUJtZ8/CsWOAtQXoxAmVC3Kyjh0B8Dl+HL0MgHY50gIkPJ7JZKKkpIR+/fox9Lbb6LlmjeWJJ57g9rvuYtiwYXJ5ai04q9Vy4a67ACiZPl3laoRL2LHD8m9MDEpoqLq11ISQELCubh9+5IjKxYiLSQASXiMsLIzw9HR8Dh2CevUIeuwxwsPDJfzUMIPBgE6nY9WqVfxf06YAaL/7jgLrArTCi/3xh+XfDh3UraMmWbvBwmWRbZcjXWDCeygKvPKK5f4jj0BgoLr1eImgoCCGDRtmvwS4ID2dwF9+wee11+DTT1WuTqjKtkZc9+7q1lGTOnWCJUukBcgFSQuQ8Bq+K1fC1q2WOX+sa8eJ2hEUFER4eDjh4eEUP/MMAPolS0AuD/Zu1gCU17o1ubm56tZSU6xXgtWTFiCXIwFIeAezmUBb689DD0HduurW48VKunXjWJs2aEpK/m6RE94nJwcOHADg6+PHWbVqlWdekGDtAgvLykLjqSHPTUkAEl6h6R9/WC5FDQ6Gp59Wuxyvt+mWWwBQ5s+nYNculasRqli/HoDciAiuu/VWhg4d6pkXJNSvT6l17Jtu0yaVixFlSQASnq+4mG7ffGO5/8QT4AELLbozg8HA6datOd6qFZriYk7ed5+skeSNrN1f2U2bWi5Q8OALEoq7dQOgdPVqcnJy5PvdRUgAEh7Pf+5cwrKyMIeHw+OPq12O17MNig6YPRuAZr//TrG1NUB4kd9/BywByONZl4IpSk1l6dKlsjCqi5AAJDzbiRP4v/YaAAXPP2+Zl0OoLigoiDr9+2O64w40ioJ+0iRyTp2Sv469RUkJZGQAkBUXp3IxNc9w660ARBw6RP9u3WRhVBchAUh4tqeeQltQQFbTphSOHKl2NeIipVOnUqrTEbB2LX88/7z8dewt1q+Hc+cwh4VxplEjtaupeU2aQIsWaEpLqW+b/FGoTgKQ8EhGo5G8b76Bzz5D0WhYM3IkaOXb3dUEtmtH6VNPAdB/2TIS5a9j77B8OQDFvXujeMv/yxtvBMA3PV3dOoSdl3znCW9iNBr56tNPKX3oIQB2X389uc2aed7ltR7Cb/JkaNkSbXY2Uf/7n9rliNqwYgUARTfcoHIhtWjAAAB8f/lF5UKEjQQg4XFMJhOdv/iCuidPYq5fn4gPPvDMy2s9hcEAc+ZY7i5YQMT+/SoXJGrU2bP2S+CLvSkA9e0LPj7oDhwg6PRptasRSAASHsg3PZ32aWkAaBcupF6LFhJ+XN0NN8DYsWgUhX7z5qHJy1O7IlFT0tLAbIY2bTA3bKh2NbUnNBQSEgCI2blT5WIESAASniY7m6B//xuAC2PHwk03qVyQqLQ336Q0NpbgM2cIeuIJy9ptwvN89ZXl30GD1K1DDbfdBkCzDRtULkSABCDhSYqL4a678MnM5GxkJAUvvKB2RaIqgoM59957mLVa9N98A++/r3ZFwtkKCuDbby33hw9XtxY1WK9Ejf7zT7THj6tcjJAAJDyDosBjj8Gvv2IOCmLFQw9BQIDaVYkqKuncmQ2DB1seTJgAcsWMZ/n+ezh/Hpo2BevsyF6lcWOKe/QAwPzpp+Tk5MjcVyrSqV2AEE6RkgLvvAMaDcY5c8grKFC7IlFNW5OSaFtURPD332MeOpTc1FTM1snyDAaDjOdyZx9/bPl3+HDQaNStRSWlI0bgm5GB5vPP+ap5cwB0Op1cqKECaQES7m/OHHjuOcv9mTMpSkpStx5RbQaDAZ2vL0sGDiQ7Nhbt2bP4DhrEivffl0kS3ZjRaOTMpk0o339v2TB6tLoFqcjwj3+g+PlR79gxhjVqRL9+/WTuK5VIABLu7c03wTrfT9Ezz5Dzj3+Qm5urbk2i2mzrhA0eMQKf776jpFkzgs+cYfj77zOgdWv5ReGGjEYjS5Ys4eizz6JRFI63bcuxoCBycnK88/9q3bpo7r0XgLC5cwkLC1O3Hi8mXWDCrRiNRssvQEUhICWFgDfeAODc/ffzRYsWlCxdClialGXiQ/cUFBRk6QoID4dffoG+ffHZv5+Ye+6hzj//qXZ5oopMJhPavDyusS5+uqt/fw7+8IP9ea/8v/rkkzBvHnzzDT5PP612NV5LApBwG7a/JDVGI30+/JDwzZsBWD94MFu6dEGn0XDTTTdhMBhkrIinaNgQfv4Z+vfH588/Gfzaa1xo1w6GDVO7MlEF8amp+OTnwzXX0GPaNDoVF9uf88r/q61bw+DB8M03BLz8sv3yeFG7JAAJt2EymQg7cIBbFi3C76+/UHx9Mb76KnH33kscXvqD1Bs0agQZGRTfeit+a9fiO3Ik7NgBkyeDTn6EuTrt8eNc8/PPlgevvEJQaCjyvxR46SX47jv0339Pw+bNYehQtSvyOjIGSLiHCxcIePFFhqSk4PfXX9CoEZpffyX48ccJDw8nPDxcwo8nq1uXvC++YE+vXmjMZpg2jdIePeCPP9SuTFyO2UzQv/+NrriY4muvlYlJy7rmGrBO2nrd55+DDO6vdRKAhGsrKbH0lbdoQcDbb6NVFApvvx02b4Zrr1W7OlGLDCEhrP3nP0m77z6KDAZ8Nm5E6dqVC+PGcXrXLvucKjKvigt5/XX8Vq+m2M+Pc7Nmee2l7xV64QVKo6IIzc4m+OGHLT/vRK3RKIrMN3+x/Px8QkNDycvLIyQkRO1yvI7RaKQwKwv955/jP28ePocOAVDaqBE/3XYbXaZOJTw8XN0ihSpsg+CLDh7E9PDDxFmXFCjx9WV3797s7NOH/IgImVfFFXz1lWWsltnML/feS7uZM+X/bTlyv/uO4Ntvx6ekBNM991Dy7rsEBQerXZbbqsrvb5doAZo9ezaxsbEYDAYSEhJYb10puCJffPEFrVu3xmAw0L59e34oc0UBgKIoTJ48maioKPz9/UlMTGTfvn01eQrCGYqKuPDVV5wYOJCQdu0ImjQJn0OHMAUGkjtpEodSUzncsaPaVQoVBQUFER4eTnS3bjRYtYq8pUsp7twZXXEx7dPSGDF5Mv/48EOarF1LYXa22uV6J0WhcOZMlOHDwWwm76672Nurl9pVuSxd376kP/ggZo0Gw6efcqpfP4wnT6pdlldQPQAtXryY5ORkpkyZwubNm+nYsSNJSUlkV/DDa+3atYwcOZJx48bxxx9/MGTIEIYMGcKOHTvs+7z22mu89dZbzJkzh3Xr1hEYGEhSUpLMH+JqCgth40aYMYOSQYMwh4fjf+edtFyzBt/CQkpat+bsK6+w5PXXWdKoEWlr1njnJbOiXEFBQYTefju+GzfCjz/CzTeDRkPA2rX0nzePuq1awY03wquvwpo1lu83LK1I0lXmfEajkbO//MKF/v3RP/EEmtJS9vbowZIbbkDn6yv/bysQFBREwiuvUPD22yg6HU03bsS/e3f47DMoLVW7PI+mehdYQkIC3bp143//+x8AZrOZmJgY/v3vf/Of//znkv2HDx9OQUEB3333nX3btddeS3x8PHPmzEFRFKKjo3niiSd48sknAcjLyyMiIoKFCxcyYsSIK9YkXWBOdP48HD8OR478fduzh9KtW9Hu24fmoj7v8yEhHOraldinnyZgwADL0ha2uX+QK73EFRw6xPm336bw88+pc9Ff0YqvL8XNmnE0NJSjrVvzZ8+e0lV2tRQF/voL0/Ll5Lz7Lo2sf4iW6HQYJ06k5N//Bo1G/t9WUu6PP+Lzj38QfOYMAKXR0RTeeSfF/fpR3KkThrp15et4BVX5/a3qNaRFRUVs2rSJiRMn2rdptVoSExPJyMgo9zUZGRkkJyc7bEtKSmLZsmUAHDx4kMzMTBITE+3Ph4aGkpCQQEZGRqUCUI3Zuxd27rT80LDlzrL/VnS/sttq+jXFxWAyWf6Stv1b9r7RSGlODsrZs2hzc9Hk5aGx/tV9MR/rv4UBAWQ2a0ZWmzY0GTMGn86daRwYSECZ/+T2ifGEuJLYWMxTp/J1u3YEHD9O4+3bidq/n8j9+/E/dw6/PXtoBjRbt472YWFsNpkwA9h+UJb9e/Divw0req6q993xWKWllquU8vMtt1OnKP3rLzR//YX27FkMQCNA0WgoGjyYkueeI6xrV0TV6K6/nq9eeom2qam0T0vDcOIEAW+9BW+9haLRYKxXj5JrrkEXHQ0NGli+bw2Gv296vWVqCI2maje1tGoF7dqp9vaqBqCcnBxKS0uJiIhw2B4REcGePXvKfU1mZma5+2dmZtqft22raJ+LFRYWUljmF3VeXh5gSZJO9dln8OKLzj2mGyj29cVYty4FYWEU1KnDufBw8ho1ot1dd+EbGwsaDY30evytIcdsNjv/ay+8ysCBAx3+T2cqCprjx/HZu5fQ++8HwPfNN0kAeO895Lut+kq1Wk7HxHD8mmtoOXEige3bAzXw89NL3Dh4MIUDB3KysBDfn35Cv3w5unXr8Dl1CnJyOJ+ernaJzpOcDFOmOPWQtu+7ynRuySxiQEpKClOnTr1ke0xMjArVeKDiYsjKstzKmjNHnXqEEM5jNsPhw5abbbFTISpj5kzLrQacO3eO0NDQy+6jagAKDw/Hx8eHrIt+MWZlZREZGVnuayIjIy+7v+3frKwsoqKiHPaJj48v95gTJ0506FYzm82cOXOGevXqofGCeSvy8/OJiYnh6NGjXjfmyVvP3VvPG+TcvfHcvfW8wfvOXVEUzp07R3R09BX3VTUA+fn50aVLF9LS0hgyZAhgCR9paWlMmDCh3Nf06NGDtLQ0HnvsMfu2lStX0qNHDwCaNm1KZGQkaWlp9sCTn5/PunXreMi6avjF9Ho9er3eYZs3rtAbEhLiFf9ByuOt5+6t5w1y7t547t563uBd536llh8b1bvAkpOTGT16NF27dqV79+7MmjWLgoICxo4dC8CoUaNo2LAhKSkpADz66KP06dOHGTNmcPPNN7No0SI2btzI+++/D4BGo+Gxxx7jpZdeokWLFjRt2pRJkyYRHR1tD1lCCCGE8G6qB6Dhw4dz6tQpJk+eTGZmJvHx8aSmptoHMR85cgSt9u/pinr27Mlnn33G888/z7PPPkuLFi1YtmwZ11xzjX2fp59+moKCAh544AFyc3O57rrrSE1NlXkohBBCCAG4QAACmDBhQoVdXunljHi/6667uOuuuyo8nkaj4cUXX+RFL7ziqjr0ej1Tpky5pBvQG3jruXvreYOcuzeeu7eeN3j3uV+J6hMhCiGEEELUNtWXwhBCCCGEqG0SgIQQQgjhdSQACSGEEMLrSAASQgghhNeRAOSF0tPT0Wg05d42bNhQ4ev69u17yf7/+te/arFy54iNjb3kPF555ZXLvsZkMvHwww9Tr149goKCuOOOOy6ZkdyVHTp0iHHjxtG0aVP8/f1p1qwZU6ZMoaio6LKvc9fPfPbs2cTGxmIwGEhISGD9+vWX3f+LL76gdevWGAwG2rdvzw8//FBLlTpPSkoK3bp1Izg4mAYNGjBkyBD27t172dcsXLjwks/XHacLeeGFFy45j9atW1/2NZ7wmZf3s0yj0fDwww+Xu7+nfN7O4hKXwYva1bNnT06ePOmwbdKkSaSlpdH1Cis433///Q7TCwQEBNRIjTXtxRdf5H7ropgAwcHBl93/8ccf5/vvv+eLL74gNDSUCRMmMHToUNasWVPTpTrFnj17MJvNvPfeezRv3pwdO3Zw//33U1BQwPTp0y/7Wnf7zBcvXkxycjJz5swhISGBWbNmkZSUxN69e2nQoMEl+69du5aRI0eSkpLCLbfcwmeffcaQIUPYvHmzw/xiru6XX37h4Ycfplu3bpSUlPDss88yYMAAdu3aRWBgYIWvCwkJcQhK7rr8T7t27fjpp5/sj3W6in+9ecpnvmHDBkpLS+2Pd+zYwY033njZaWI85fN2CkV4vaKiIqV+/frKiy++eNn9+vTpozz66KO1U1QNatKkifLGG29Uev/c3FzF19dX+eKLL+zbdu/erQBKRkZGDVRYO1577TWladOml93HHT/z7t27Kw8//LD9cWlpqRIdHa2kpKSUu/+wYcOUm2++2WFbQkKC8uCDD9ZonTUtOztbAZRffvmlwn0WLFighIaG1l5RNWTKlClKx44dK72/p37mjz76qNKsWTPFbDaX+7ynfN7OIl1ggm+//ZbTp0/blx+5nE8//ZTw8HCuueYaJk6cyPnz52uhQud75ZVXqFevHp06deL111+npKSkwn03bdpEcXExiYmJ9m2tW7emcePGZGRk1Ea5NSIvL4+6detecT93+syLiorYtGmTw2el1WpJTEys8LPKyMhw2B8gKSnJrT9bsHy+wBU/Y6PRSJMmTYiJiWHw4MHs3LmzNspzun379hEdHU1cXBz33HMPR44cqXBfT/zMi4qK+OSTT/jnP/952VYdT/m8nUG6wATz5s0jKSmJRo0aXXa/u+++myZNmhAdHc22bdt45pln2Lt3L0uXLq2lSp3jkUceoXPnztStW5e1a9cyceJETp48ycyZM8vdPzMzEz8/v0sWyI2IiCAzM7MWKna+/fv38/bbb1+x+8vdPvOcnBxKS0vtS+nYREREsGfPnnJfk5mZWe7+7vrZgmVR6ccee4xevXpdtkunVatWzJ8/nw4dOpCXl8f06dPp2bMnO3fuvOLPA1eSkJDAwoULadWqFSdPnmTq1Klcf/317Nixo9zubU/8zJctW0Zubi5jxoypcB9P+bydRu0mKOE8zzzzjAJc9rZ7926H1xw9elTRarXKl19+WeX3S0tLUwBl//79zjqFaqvOudvMmzdP0el0islkKvf5Tz/9VPHz87tke7du3ZSnn37aqedRVdU572PHjinNmjVTxo0bV+X3c6XPvDzHjx9XAGXt2rUO25966imle/fu5b7G19dX+eyzzxy2zZ49W2nQoEGN1VnT/vWvfylNmjRRjh49WqXXFRUVKc2aNVOef/75Gqqsdpw9e1YJCQlRPvjgg3Kf98TPfMCAAcott9xSpdd4yuddXdIC5EGeeOKJy6Z/gLi4OIfHCxYsoF69etx2221Vfr+EhATA0prQrFmzKr/emapz7jYJCQmUlJRw6NAhWrVqdcnzkZGRFBUVkZub69AKlJWVRWRk5NWUfdWqet4nTpzghhtuoGfPnrz//vtVfj9X+szLEx4ejo+PzyVX6F3us4qMjKzS/q5uwoQJfPfdd/z6669V/qve19eXTp06sX///hqqrnaEhYXRsmXLCs/D0z7zw4cP89NPP1W5ZdZTPu/qkgDkQerXr0/9+vUrvb+iKCxYsIBRo0bh6+tb5ffbsmULAFFRUVV+rbNV9dzL2rJlC1qtttwrhAC6dOmCr68vaWlp3HHHHQDs3buXI0eO0KNHj2rX7AxVOe/jx49zww030KVLFxYsWIBWW/UhgK70mZfHz8+PLl26kJaWxpAhQwBLd1BaWlqFCy736NGDtLQ0HnvsMfu2lStXqv7ZVpWiKPz73//m66+/Jj09naZNm1b5GKWlpWzfvp2bbrqpBiqsPUajkQMHDnDvvfeW+7ynfOY2CxYsoEGDBtx8881Vep2nfN7VpnYTlFDPTz/9VGHX0LFjx5RWrVop69atUxRFUfbv36+8+OKLysaNG5WDBw8q33zzjRIXF6f07t27tsu+KmvXrlXeeOMNZcuWLcqBAweUTz75RKlfv74yatQo+z4Xn7uiWLoUGjdurKxatUrZuHGj0qNHD6VHjx5qnEK1HDt2TGnevLnSv39/5dixY8rJkyftt7L7eMJnvmjRIkWv1ysLFy5Udu3apTzwwANKWFiYkpmZqSiKotx7773Kf/7zH/v+a9asUXQ6nTJ9+nRl9+7dypQpUxRfX19l+/btap1CtTz00ENKaGiokp6e7vD5nj9/3r7Pxec+depUZfny5cqBAweUTZs2KSNGjFAMBoOyc+dONU6h2p544gklPT1dOXjwoLJmzRolMTFRCQ8PV7KzsxVF8dzPXFEsVzk2btxYeeaZZy55zlM/b2eRAOTFRo4cqfTs2bPc5w4ePKgAys8//6woiqIcOXJE6d27t1K3bl1Fr9crzZs3V5566iklLy+vFiu+eps2bVISEhKU0NBQxWAwKG3atFH++9//Ooz/ufjcFUVRLly4oIwfP16pU6eOEhAQoNx+++0O4cHVLViwoMIxQjae9Jm//fbbSuPGjRU/Pz+le/fuyu+//25/rk+fPsro0aMd9l+yZInSsmVLxc/PT2nXrp3y/fff13LFV6+iz3fBggX2fS4+98cee8z+dYqIiFBuuukmZfPmzbVf/FUaPny4EhUVpfj5+SkNGzZUhg8f7jBOzVM/c0VRlOXLlyuAsnfv3kue89TP21k0iqIotd7sJIQQQgihIpkHSAghhBBeRwKQEEIIIbyOBCAhhBBCeB0JQEIIIYTwOhKAhBBCCOF1JAAJIYQQwutIABJCCCGE15EAJISbeOGFF4iPj1e7DGJjY5k1a5baZZSrd+/efPbZZ2qXIVSya9cuGjVqREFBgdqlCDcgAUiIMsaMGYNGo0Gj0eDr60vTpk15+umnMZlMtVqHRqNh2bJlDtuefPJJ0tLSauw909PT7ede0S09PZ0NGzbwwAMP1Fgd1fXtt9+SlZXFiBEj1C6FhQsX2r9mWq2WqKgohg8fzpEjRzh06NAVv84LFy5U+xTcUtu2bbn22muZOXOm2qUINyCLoQpxkYEDB7JgwQKKi4vZtGkTo0ePRqPR8Oqrr6paV1BQEEFBQTV2/J49e3Ly5En740cffZT8/HwWLFhg31a3bl38/PxqrIar8dZbbzF27NhqLfJaE0JCQti7dy+KonDw4EHGjx/PXXfdxdq1ax2+ztOnTyc1NZWffvrJvi00NLTG6ioqKqq1z7Ci9youLq7WAsyVed3YsWO5//77mThxIjqd/IoTFXONnxRCuBC9Xk9kZCQxMTEMGTKExMREVq5caX/ebDaTkpJC06ZN8ff3p2PHjnz55Zf250tLSxk3bpz9+VatWvHmm29e8j7z58+nXbt26PV6oqKi7KuVx8bGAnD77bej0Wjsjy/uAjObzbz44os0atQIvV5PfHw8qamp9udtLQ1Lly7lhhtuICAggI4dO5KRkVHuefv5+REZGWm/+fv7278Wtpufn98lXWAajYb33nuPW265hYCAANq0aUNGRgb79++nb9++BAYG0rNnTw4cOODwft988w2dO3fGYDAQFxfH1KlTKSkpASwrm7/wwgs0btwYvV5PdHQ0jzzySIWf2alTp1i1ahW33nqrw3aNRsMHH3zA7bffTkBAAC1atODbb7912GfHjh0MGjSIoKAgIiIiuPfee8nJybE/f+7cOe655x4CAwOJiorijTfeoG/fvg4riZdHo9EQGRlJVFQUPXv2ZNy4caxfv56CggKHr2lQUBA6nc7+eM+ePfTp04fAwEDCwsLo1asXhw8frvB9nnnmGVq2bElAQABxcXFMmjSJ4uJi+/O275sPPviApk2bYjAYAMjNzeW+++6jfv36hISE0K9fP7Zu3XrZczp69CjDhg0jLCyMunXrMnjwYA4dOmR/fsyYMQwZMoSXX36Z6OhoWrVqZf8+XLx4MX369MFgMPDpp59W+vv34tcdPnyYW2+9lTp16hAYGEi7du344Ycf7K+78cYbOXPmDL/88stlz0UICUBCXMaOHTtYu3atw1+xKSkpfPTRR8yZM4edO3fy+OOP849//MP+A9dsNtOoUSO++OILdu3axeTJk3n22WdZsmSJ/RjvvvsuDz/8MA888ADbt2/n22+/pXnz5gBs2LABgAULFnDy5En744u9+eabzJgxg+nTp7Nt2zaSkpK47bbb2Ldvn8N+zz33HE8++SRbtmyhZcuWjBw50h40nGXatGmMGjWKLVu20Lp1a+6++24efPBBJk6cyMaNG1EUxR7wAFavXs2oUaN49NFH2bVrF++99x4LFy7k5ZdfBuCrr77ijTfe4L333mPfvn0sW7aM9u3bV/j+v/32mz18XWzq1KkMGzaMbdu2cdNNN3HPPfdw5swZwBIC+vXrR6dOndi4cSOpqalkZWUxbNgw++uTk5NZs2YN3377LStXrmT16tVs3ry5Sl+f7Oxsvv76a3x8fPDx8alwv5KSEoYMGUKfPn3Ytm0bGRkZPPDAA2g0mgpfExwczMKFC9m1axdvvvkmc+fO5Y033nDYZ//+/Xz11VcsXbqULVu2AHDXXXeRnZ3Njz/+yKZNm+jcuTP9+/e3f20uVlxcTFJSEsHBwaxevZo1a9YQFBTEwIEDKSoqsu+XlpbG3r17WblyJd999519+3/+8x8effRRdu/eTVJSUqW/fy9+3cMPP0xhYSG//vor27dv59VXX3VoGfXz8yM+Pp7Vq1dX+DUTAkBWgxeijNGjRys+Pj5KYGCgotfrFUDRarXKl19+qSiKophMJiUgIEBZu3atw+vGjRunjBw5ssLjPvzww8odd9xhfxwdHa0899xzFe4PKF9//bXDtilTpigdO3Z0OMbLL7/ssE+3bt2U8ePHK4ry9+ruH3zwgf35nTt3KoCye/fuCt/bZvTo0crgwYMv2d6kSRPljTfecKj1+eeftz/OyMhQAGXevHn2bZ9//rliMBjsj/v376/897//dTjuxx9/rERFRSmKoigzZsxQWrZsqRQVFV2xTkVRlDfeeEOJi4u7ZPvFtRmNRgVQfvzxR0VRFGXatGnKgAEDHF5z9OhR++ra+fn5iq+vr/LFF1/Yn8/NzVUCAgKURx99tMJ6FixYoABKYGCgEhAQYF+Z/ZFHHrlk37Kf6+nTpxVASU9Pr9R5l+f1119XunTp4nB8X19fJTs7275t9erVSkhIiGIymRxe26xZM+W9994r97gff/yx0qpVK8VsNtu3FRYWKv7+/sry5csVRbF8z0RERCiFhYX2fWzfh7NmzXI4XmW/fy9+Xfv27ZUXXnjhsl+D22+/XRkzZsxl9xFCOkiFuMgNN9zAu+++S0FBAW+88QY6nY477rgDsPwlff78eW688UaH1xQVFdGpUyf749mzZzN//nyOHDnChQsXKCoqsndfZWdnc+LECfr371/tGvPz8zlx4gS9evVy2N6rV69LujE6dOhgvx8VFWWvoXXr1tV+/4uVfY+IiAgAhxabiIgITCYT+fn5hISEsHXrVtasWWNv8QFL16HJZOL8+fPcddddzJo1i7i4OAYOHMhNN93ErbfeWuGYjgsXLti7di5XW2BgICEhIWRnZwOwdetWfv7553LHVh04cIALFy5QXFxM9+7d7dtDQ0Np1arVFb8mwcHBbN68meLiYn788Uc+/fRTh/MtT926dRkzZgxJSUnceOONJCYmMmzYMPvnVp7Fixfz1ltvceDAAYxGIyUlJYSEhDjs06RJE+rXr29/vHXrVoxGI/Xq1XPY78KFC5d0VZZ9zf79+wkODnbYbjKZHF7Tvn37csf9dO3a1X6/Kt+/ZV8H8Mgjj/DQQw+xYsUKEhMTueOOOxw+YwB/f3/Onz9f7nkIYSMBSIiLBAYG2ruj5s+fT8eOHZk3bx7jxo3DaDQC8P3339OwYUOH1+n1egAWLVrEk08+yYwZM+jRowfBwcG8/vrrrFu3DrD8cK5NZQeN2rpSzGZzjb/H5d7XaDQydepUhg4desmxDAYDMTEx7N27l59++omVK1cyfvx4Xn/9dX755ZdyB8GGh4dz9uzZK9Zmq6VsHbfeemu5A9yjoqLYv3//Zc/7crRarf37qE2bNhw4cICHHnqIjz/++LKvW7BgAY888gipqaksXryY559/npUrV3Lttddesm9GRgb33HMPU6dOJSkpidDQUBYtWsSMGTMc9gsMDHR4bDQaiYqKIj09/ZJjhoWFlVuX0WikS5cufPrpp5c8VzZcXfxeV9p+JRe/7r777iMpKYnvv/+eFStWkJKSwowZM/j3v/9t3+fMmTM0a9asWu8nvIcEICEuQ6vV8uyzz5KcnMzdd99N27Zt0ev1HDlyhD59+pT7mjVr1tCzZ0/Gjx9v31b2L+Tg4GBiY2NJS0vjhhtuKPcYvr6+lJaWVlhXSEgI0dHRrFmzxqGONWvWOLRWuKrOnTuzd+9ee0Aoj7+/P7feeiu33norDz/8MK1bt2b79u107tz5kn07depEZmYmZ8+epU6dOlWq46uvviI2Nrbc1qW4uDh8fX3ZsGEDjRs3BiAvL48///yT3r17V/p9wDKWpVmzZjz++OPlnsPF59OpUycmTpxIjx49+Oyzz8oNQGvXrqVJkyY899xz9m2XGzBt07lzZzIzM9HpdPZB9pV5zeLFi2nQoMElLUxVdbXfvzExMfzrX//iX//6FxMnTmTu3LkOAWjHjh3ceeedV1Wj8HwyCFqIK7jrrrvw8fFh9uzZBAcH8+STT/L444/z4YcfcuDAATZv3szbb7/Nhx9+CECLFi3YuHEjy5cv588//2TSpEmXDGR+4YUXmDFjBm+99Rb79u2zH8PGFpBsv9TL89RTT/Hqq6+yePFi9u7dy3/+8x+2bNnCo48+WnNfDCeZPHkyH330EVOnTmXnzp3s3r2bRYsW8fzzzwOWeXTmzZvHjh07+Ouvv/jkk0/w9/enSZMm5R6vU6dOhIeHs2bNmirV8fDDD3PmzBlGjhzJhg0bOHDgAMuXL2fs2LGUlpYSHBzM6NGjeeqpp/j555/ZuXMn48aNQ6vVXnZgcnliYmK4/fbbmTx5coX7HDx4kIkTJ5KRkcHhw4dZsWIF+/btK3dwN1i+144cOcKiRYs4cOAAb731Fl9//fUVa0lMTKRHjx4MGTKEFStWcOjQIdauXctzzz3Hxo0by33NPffcQ3h4OIMHD2b16tUcPHiQ9PR0HnnkEY4dO1a5L0IZ1f3+feyxx1i+fDkHDx5k8+bN/Pzzzw5fn0OHDnH8+HESExOrXJPwLhKAhLgCnU7HhAkTeO211ygoKGDatGlMmjSJlJQU2rRpw8CBA/n+++9p2rQpAA8++CBDhw5l+PDhJCQkcPr0aYfWIIDRo0cza9Ys3nnnHdq1a8ctt9zicPXLjBkzWLlyJTExMQ5ji8p65JFHSE5O5oknnqB9+/akpqby7bff0qJFi5r7YjhJUlIS3333HStWrKBbt25ce+21vPHGG/aAExYWxty5c+nVqxcdOnTgp59+4v/+7/8uGbNi4+Pjw9ixY8vtnrkcWytEaWkpAwYMoH379jz22GOEhYXZ5xOaOXMmPXr04JZbbiExMZFevXrRpk2bCsccXc7jjz/O999/z/r168t9PiAggD179nDHHXfQsmVLHnjgAR5++GEefPDBcve/7bbbePzxx5kwYQLx8fGsXbuWSZMmXbEOjUbDDz/8QO/evRk7diwtW7ZkxIgRHD582D6Gq7zafv31Vxo3bszQoUNp06YN48aNw2QyVatFqLrfv6WlpTz88MP2/3stW7bknXfesT//+eefM2DAgArDshA2GkVRFLWLEEKIq5WZmUm7du3YvHlzjf7yKygooGHDhsyYMYNx48bV2PuIqisqKqJFixZ89tlnlwywFuJi0gIkhPAIkZGRzJs3jyNHjjj1uH/88Qeff/65vbvznnvuAWDw4MFOfR9x9Y4cOcKzzz4r4UdUirQACSHEZfzxxx/cd9997N27Fz8/P7p06cLMmTMvOzGjEML1SQASQgghhNeRLjAhhBBCeB0JQEIIIYTwOhKAhBBCCOF1JAAJIYQQwutIABJCCCGE15EAJIQQQgivIwFICCGEEF5HApAQQgghvI4EICGEEEJ4nf8HARwpGhDmoWMAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt \n",
+    "plt.hist(\n",
+    "    sim_out[\"rts\"] * sim_out[\"choices\"],\n",
+    "    bins=100,\n",
+    "    histtype=\"step\",\n",
+    "    color=\"black\",\n",
+    "    label=\"Weibull Deadline\",\n",
+    "    density=True,\n",
+    "    alpha=0.4,\n",
+    ")\n",
+    "s = choice*x\n",
+    "idx = np.argsort(s) # sort the values so theyre not zig zaggy \n",
+    "plt.plot(s[idx], pdf_vals[idx], color=\"red\", label=\"Ex-Gaussian Likelihood\")\n",
+    "plt.xlabel(\"Reaction Times (neg RTs are errors)\")\n",
+    "plt.ylabel(\"Density\")\n",
+    "plt.title(\"Ex-Gaussian\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ex-Gaussian Race')"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(\n",
+    "    sim_out_race[\"rts\"] * sim_out_race[\"choices\"],\n",
+    "    bins=100,\n",
+    "    histtype=\"step\",\n",
+    "    color=\"black\",\n",
+    "    label=\"Weibull Deadline\",\n",
+    "    density=True,\n",
+    "    alpha=0.4,\n",
+    ")\n",
+    "s_race = choice_race*x_race\n",
+    "idx_race = np.argsort(s_race) # sort the values so theyre not zig zaggy \n",
+    "plt.plot(s_race[idx_race], pdf_race_vals[idx_race], color=\"red\", label=\"Ex-Gaussian Likelihood\")\n",
+    "plt.xlabel(\"Reaction Times (neg RTs are errors)\")\n",
+    "plt.ylabel(\"Density\")\n",
+    "plt.title(\"Ex-Gaussian Race\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Density')"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(\n",
+    "    sim_out_2[\"rts\"][sim_out_2[\"rts\"] != -999] * sim_out_2[\"choices\"][sim_out_2[\"rts\"] != -999],\n",
+    "    bins=100,\n",
+    "    histtype=\"step\",\n",
+    "    color=\"black\",\n",
+    "    label=\"Weibull Deadline\",\n",
+    "    density=True,\n",
+    "    alpha=0.4,\n",
+    ")\n",
+    "s_sw = choice_sw*x_sw\n",
+    "idx_sw = np.argsort(s_sw) # sort the values so theyre not zig zaggy\n",
+    "plt.plot(s_sw[idx_sw], pdf_vals_sw[idx_sw], color=\"blue\", label=\"Shifted Wald Likelihood\")\n",
+    "plt.xlabel(\"Reaction Times (neg RTs are errors)\")\n",
+    "plt.ylabel(\"Density\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Density')"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.hist(\n",
+    "    sim_out_2_race[\"rts\"][sim_out_2_race[\"rts\"] != -999] * sim_out_2_race[\"choices\"][sim_out_2_race[\"rts\"] != -999],\n",
+    "    bins=100,\n",
+    "    histtype=\"step\",\n",
+    "    color=\"black\",\n",
+    "    label=\"Weibull Deadline\",\n",
+    "    density=True,\n",
+    "    alpha=0.4,\n",
+    ")\n",
+    "# s_sw = choice_sw*x_sw\n",
+    "# idx_sw = np.argsort(s_sw) # sort the values so theyre not zig zaggy\n",
+    "# plt.plot(s_sw[idx_sw], pdf_vals_sw[idx_sw], color=\"blue\", label=\"Shifted Wald Likelihood\")\n",
+    "plt.xlabel(\"Reaction Times (neg RTs are errors)\")\n",
+    "plt.ylabel(\"Density\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ssms-venv",
+   "language": "python",
+   "name": "ssms-venv"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/src/cssm.pyx b/src/cssm.pyx
index 36a1b3dd..6517d4de 100755
--- a/src/cssm.pyx
+++ b/src/cssm.pyx
@@ -4870,4 +4870,349 @@ def ddm_flexbound_tradeoff(np.ndarray[float, ndim = 1] vh,
                                                              }}
     else:
         raise ValueError('return_option must be either "full" or "minimal"')
-# -----------------------------------------------------------------------------------------------
\ No newline at end of file
+# -----------------------------------------------------------------------------------------------
+
+
+
+# Simulate (rt, choice) tuples from: EX GAUSSIAN ------------------------------------
+# @cythonboundscheck(False)
+# @cythonwraparound(False)
+def exgauss(np.ndarray[float, ndim = 2] mu,
+                           np.ndarray[float, ndim = 2] sigma, 
+                           np.ndarray[float, ndim = 2] tau, 
+                           np.ndarray[float, ndim = 1] p, # choice probability
+                           float delta_t = 0.001,
+                           int n_samples = 20000,
+                           int n_trials = 1,
+                           random_state = None,
+                           return_option = 'full',
+                           float max_t = -1,
+                           race = False,
+                           **kwargs):
+    """ Fit reaction times and choices from an ex-Gaussian distribution 
+    
+    Args: 
+        mu (np.ndarray[float, ndim = 1]): mean of the gaussian component
+        sigma (np.ndarray[float, ndim = 1]): standard deviation of the gaussian component
+        tau (np.ndarray[float, ndim = 1]): mean of the exponential component
+        p (np.ndarray[float, ndim = 1]): probability of choice 1
+        delta_t (float, optional): time step for simulation. Defaults to 0.001.
+        n_samples (int, optional): number of samples per trial. Defaults to 20000.
+        n_trials (int, optional): number of trials to simulate. Defaults to 1.
+        random_state (int, optional): random seed. Defaults to None.
+        return_option (str, optional): 'full' or 'minimal' return data. Defaults to 'full'.
+    
+    Returns: 
+        dict: simulated reaction times, choices, and metadata
+    """ 
+
+    rng = np.random.default_rng(random_state)
+    
+    mu = np.asarray(mu, dtype=DTYPE)
+    sigma = np.asarray(sigma, dtype=DTYPE)
+    tau = np.asarray(tau, dtype=DTYPE)
+    p = np.asarray(p, dtype=DTYPE)
+    n_choices = mu.shape[1]
+
+    if mu.size == 1:
+        mu = np.repeat(mu, n_trials)
+    if sigma.size == 1:
+        sigma = np.repeat(sigma, n_trials)
+    if tau.size == 1:
+        tau = np.repeat(tau, n_trials)
+
+
+    rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE)
+    choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc)
+
+    for k in range(n_trials):
+        for n in range(n_samples):
+            # decide choice
+            if race:
+                # choose 'choice' from race  
+                rt_candidates = np.empty(n_choices, dtype=DTYPE)
+                for c in range(n_choices): 
+                    mu_val = mu[k, c]
+                    sigma_val = sigma[k, c]
+                    tau_val = tau[k, c]
+
+                    # draw components and compose RT
+                    norm_sample = rng.normal(mu_val, sigma_val)
+                    exp_sample = rng.exponential(tau_val)
+                    rt_val = norm_sample + exp_sample
+
+                    if rt_val < 0.0:  # ensure no negative rts
+                        rt_val = 0.0
+                    rt_candidates[c] = rt_val
+                choice_idx = np.argmin(rt_candidates)
+                choices[n, k, 0] = 1 if choice_idx == 0 else -1
+                rts[n, k, 0] = rt_candidates[choice_idx]
+            
+            else: 
+                # choose 'choice' from Bernoulli
+                random_val = rng.random()
+                if random_val <= p[k]:
+                    choice_idx = 0
+                    choices[n, k, 0] = 1
+                    
+                else:
+                    choice_idx = 1
+                    choices[n, k, 0] = -1
+                    
+                mu_val = mu[k, choice_idx]
+                sigma_val = sigma[k, choice_idx]
+                tau_val = tau[k, choice_idx]
+
+                # draw components and compose RT
+                norm_sample = rng.normal(mu_val, sigma_val)
+                exp_sample = rng.exponential(tau_val)
+                rt_val = norm_sample + exp_sample
+
+                if rt_val < 0.0:  # ensure no negative rts
+                    rt_val = 0.0
+                rts[n, k, 0] = rt_val
+    
+    if race: 
+        if return_option == 'full': 
+            return {
+                'rts': rts,
+                'choices': choices,
+                'metadata': {
+                    'mu': mu, 'sigma': sigma, 'tau': tau,
+                    'n_samples': n_samples,
+                    'n_trials': n_trials,
+                    'simulator': 'exgauss_race',
+                    'possible_choices': [-1, 1],
+                    'delta_t': delta_t, 
+                    'max_t': max_t
+                }
+            }
+        elif return_option == 'minimal':
+            return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss_race', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}}
+        else:
+            raise ValueError("return_option must be 'full' or 'minimal'") 
+    else: 
+        if return_option == 'full': 
+            return {
+                'rts': rts,
+                'choices': choices,
+                'metadata': {
+                    'mu': mu, 'sigma': sigma, 'tau': tau,
+                    'n_samples': n_samples,
+                    'n_trials': n_trials,
+                    'simulator': 'exgauss',
+                    'possible_choices': [-1, 1],
+                    'delta_t': delta_t, 
+                    'max_t': max_t
+                }
+            }
+        elif return_option == 'minimal':
+            return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}}
+        else:
+            raise ValueError("return_option must be 'full' or 'minimal'") 
+# -----------------------------------------------------------------------------------------------
+
+
+
+
+
+# Simulate (rt, choice) tuples from: SHIFTED WALD ------------------------------------
+# @cythonboundscheck(False)
+# @cythonwraparound(False)
+def shifted_wald(np.ndarray[float, ndim = 2] v, # drift rate 
+                           np.ndarray[float, ndim = 2] a, # boundary separation 
+                           np.ndarray[float, ndim = 2] t, # nondecision time
+                           np.ndarray[float, ndim = 1] p, # choice probability 
+                           np.ndarray[float, ndim = 1] s, # noise sigma 
+                           float delta_t = 0.001,
+                           float max_t = 20,
+                           int n_samples = 20000,
+                           int n_trials = 1,
+                           random_state = None,
+                           return_option = 'full', 
+                           smooth_unif = False,
+                           race = False,
+                           **kwargs):
+    """ Fit reaction times and choices from a shifted Wald distribution 
+    
+    Args: 
+        v (np.ndarray[float, ndim = 1]): drift rate
+        a (np.ndarray[float, ndim = 1]): boundary separation
+        t (np.ndarray[float, ndim = 1]): non-decision time
+        p (np.ndarray[float, ndim = 1]): probability of choice 1
+        s (np.ndarray[float, ndim = 1]): noise standard deviation
+        delta_t (float, optional): time step for simulation. Defaults to 0.001.
+        max_t (float, optional): maximum time for simulation. Defaults to 20.
+        n_samples (int, optional): number of samples per trial. Defaults to 20000.
+        n_trials (int, optional): number of trials to simulate. Defaults to 1.
+        random_state (int, optional): random seed. Defaults to None.
+        return_option (str, optional): 'full' or 'minimal' return data. Defaults to 'full'.
+        smooth_unif (bool, optional): whether to use smooth uniform distribution for small time increments. Defaults to False.
+    
+    Returns: 
+        dict: simulated reaction times, choices, and metadata
+    """ 
+
+    set_seed(random_state)
+    
+    cdef float[:, :] v_view = v
+    cdef float[:, :] a_view = a 
+    cdef float[:, :] t_view = t 
+    cdef float[:] p_view = p
+    cdef float[:] s_view = s
+
+    traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype=DTYPE)
+    traj[:, :] = -999
+    cdef float[:, :] traj_view = traj
+
+    rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE)
+    choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc)
+    cdef float[:, :, :] rts_view = rts
+    cdef int[:, :, :] choices_view = choices
+
+    cdef float delta_t_sqrt = sqrt(delta_t)
+    cdef float y, t_particle, smooth_u, sqrt_st
+
+    cdef Py_ssize_t n, ix, k
+    cdef int m = 0 
+    cdef int num_draws = int(max_t / delta_t) + 1
+    cdef float[:] gaussian_values = draw_gaussian(num_draws)
+    n_choices = v.shape[1]
+
+    for k in range(n_trials): 
+        sqrt_st = delta_t_sqrt * s_view[k]
+
+        for n in range(n_samples): 
+            # Random choice depending on p 
+            if race: 
+                rt_candidates = np.empty(n_choices, dtype=DTYPE)
+                for c in range(n_choices): 
+                    y = 0.0 
+                    t_particle = 0.0 
+                    ix = 0 
+
+                    if n == 0:
+                        if k == 0:
+                            traj_view[0, 0] = y
+                    while (y < a_view[k, c]) and (t_particle <= max_t):
+                        y += (v_view[k, c] * delta_t) + (sqrt_st * gaussian_values[m])
+                        t_particle += delta_t
+                        ix += 1
+                        m += 1
+                        if m == num_draws:
+                            gaussian_values = draw_gaussian(num_draws)
+                            m = 0
+
+                        if n == 0:
+                            if k == 0:
+                                traj_view[ix, 0] = y
+
+                        if smooth_unif:
+                            if t_particle == 0.0:
+                                smooth_u = random_uniform() * 0.5 * delta_t
+                            elif t_particle < max_t:
+                                smooth_u = (0.5 - random_uniform()) * delta_t
+                            else:
+                                smooth_u = 0.0
+                        else:
+                            smooth_u = 0.0
+                    rt_candidates[c] = t_particle + t_view[k, c] + smooth_u
+
+                choices_idx = np.argmin(rt_candidates)    
+                choices_view[n, k, 0] = 1 if choices_idx == 0 else -1
+                rts_view[n, k, 0] = rt_candidates[choices_idx]
+                            
+            else: 
+                y = 0.0 
+                t_particle = 0.0 
+                ix = 0 
+
+                if n == 0:
+                    if k == 0:
+                        traj_view[0, 0] = y
+                
+                random_val = rand() / float(RAND_MAX) 
+                if random_val <= p_view[k]: 
+                    choices_view[n, k, 0] = 1
+                    choice_idx = 0 
+                else:
+                    choices_view[n, k, 0] = -1
+                    choice_idx = 1 
+
+                # Random walk 
+                while (y < a_view[k, choice_idx]) and (t_particle <= max_t):
+                    y += (v_view[k, choice_idx] * delta_t) + (sqrt_st * gaussian_values[m])
+                    t_particle += delta_t
+                    ix += 1
+                    m += 1
+                    if m == num_draws:
+                        gaussian_values = draw_gaussian(num_draws)
+                        m = 0
+
+                    if n == 0:
+                        if k == 0:
+                            traj_view[ix, 0] = y
+
+                if smooth_unif:
+                    if t_particle == 0.0:
+                        smooth_u = random_uniform() * 0.5 * delta_t
+                    elif t_particle < max_t:
+                        smooth_u = (0.5 - random_uniform()) * delta_t
+                    else:
+                        smooth_u = 0.0
+                else:
+                    smooth_u = 0.0
+
+                rts_view[n, k, 0] = t_particle + t_view[k, choice_idx] + smooth_u
+    if race:       
+        if return_option == 'full': 
+            return { 
+                'rts': rts,
+                'choices': choices,
+                'metadata': {
+                    'v': v, 'a': a, 't': t, 's': s,
+                    'n_samples': n_samples,
+                    'n_trials': n_trials,
+                    'simulator': 'shifted_wald_race',
+                    'possible_choices': [-1, 1],
+                    'delta_t': delta_t, 
+                    'max_t': max_t,
+                    'trajectory': traj,
+                }
+            }
+        elif return_option == 'minimal':
+            return {'rts': rts, 'choices': choices, 'metadata': 
+                                                {'simulator': 'shifted_wald_race', 
+                                                'n_samples': n_samples, 
+                                                'n_trials': n_trials, 
+                                                'possible_choices': [-1, 1]}}
+        else:
+            raise ValueError("return_option must be 'full' or 'minimal'") 
+    else: 
+        if return_option == 'full': 
+            return { 
+                'rts': rts,
+                'choices': choices,
+                'metadata': {
+                    'v': v, 'a': a, 't': t, 's': s,
+                    'n_samples': n_samples,
+                    'n_trials': n_trials,
+                    'simulator': 'shifted_wald',
+                    'possible_choices': [-1, 1],
+                    'delta_t': delta_t, 
+                    'max_t': max_t,
+                    'trajectory': traj,
+                }
+            }
+        elif return_option == 'minimal':
+            return {'rts': rts, 'choices': choices, 'metadata': 
+                                                {'simulator': 'shifted_wald', 
+                                                'n_samples': n_samples, 
+                                                'n_trials': n_trials, 
+                                                'possible_choices': [-1, 1]}}
+        else:
+            raise ValueError("return_option must be 'full' or 'minimal'") 
+# -----------------------------------------------------------------------------------------------
+            
+
+
diff --git a/ssms/basic_simulators/simulator.py b/ssms/basic_simulators/simulator.py
index f2f60aa2..df4a9ab8 100755
--- a/ssms/basic_simulators/simulator.py
+++ b/ssms/basic_simulators/simulator.py
@@ -504,6 +504,8 @@ def check_if_z_gt_a(z: np.ndarray, a: np.ndarray) -> None:
             check_if_z_gt_a(theta["z"], theta["a"])
 
 
+
+
 def make_noise_vec(
     sigma_noise: float | np.ndarray, n_trials: int, n_particles: int
 ) -> np.ndarray:
@@ -603,7 +605,7 @@ def simulator(
         deadline = False
 
     model_config_local = deepcopy(model_config[model])
-
+    
     if deadline:
         model_config_local["params"] += ["deadline"]
 
@@ -667,7 +669,7 @@ def simulator(
         **drift_dict,
         **sim_param_dict,
     )
-
+    
     # Ensure x is a dictionary
     if not isinstance(x, dict):
         raise TypeError(
diff --git a/ssms/basic_simulators/theta_processor.py b/ssms/basic_simulators/theta_processor.py
index 36339463..6343024f 100644
--- a/ssms/basic_simulators/theta_processor.py
+++ b/ssms/basic_simulators/theta_processor.py
@@ -225,6 +225,31 @@ def process_theta(
             theta["v"] = np.column_stack([theta["v0"], theta["v1"]])
             theta["t"] = np.expand_dims(theta["t"], axis=1)
             theta["a"] = np.expand_dims(theta["a"], axis=1)
+        
+        if model in ["exgauss"]: 
+            theta["mu"] = np.column_stack([theta["mu0"], theta["mu1"]])
+            theta["sigma"] = np.column_stack([theta["sigma0"], theta["sigma1"]])
+            theta["tau"] = np.column_stack([theta["tau0"], theta["tau1"]])
+        
+        if model in ["exgauss_race"]: 
+            theta["mu"] = np.column_stack([theta["mu0"], theta["mu1"]])
+            theta["sigma"] = np.column_stack([theta["sigma0"], theta["sigma1"]])
+            theta["tau"] = np.column_stack([theta["tau0"], theta["tau1"]])
+            theta["race"] = True 
+        
+        if model in ["shifted_wald"]: 
+            theta["v"] = np.column_stack([theta["v0"], theta["v1"]])
+            theta["a"] = np.column_stack([theta["a0"], theta["a1"]])
+            theta["t"] = np.expand_dims(theta["t"], axis=1)
+    
+        if model in ["shifted_wald_race"]: 
+            theta["v"] = np.column_stack([theta["v0"], theta["v1"]])
+            theta["a"] = np.column_stack([theta["a0"], theta["a1"]])
+            theta["t"] = np.expand_dims(theta["t"], axis=1)
+            theta["race"] = True 
+        
+
+            
 
         # 3 Choice models
 
diff --git a/ssms/config/_modelconfig/__init__.py b/ssms/config/_modelconfig/__init__.py
index 0f531838..f2ca9299 100644
--- a/ssms/config/_modelconfig/__init__.py
+++ b/ssms/config/_modelconfig/__init__.py
@@ -123,6 +123,15 @@
     get_shrink_spot_simple_extended_config,
 )
 
+from .exgauss import (
+    get_exgauss_config,
+    get_exgauss_race_config
+)
+
+from .shifted_wald import (
+    get_shifted_wald_config,
+    get_shifted_wald_race_config
+)
 
 def get_model_config():
     """Accessor for model configurations.
@@ -234,6 +243,10 @@ def get_model_config():
         "weibull_cdf": get_weibull_config(),
         "full_ddm2": get_full_ddm_config(),
         "ddm_legacy": get_ddm_legacy_config(),
+        "exgauss": get_exgauss_config(),
+        "exgauss_race": get_exgauss_race_config(),
+        "shifted_wald": get_shifted_wald_config(),
+        "shifted_wald_race": get_shifted_wald_race_config(),
     }
 
 
diff --git a/ssms/config/_modelconfig/exgauss.py b/ssms/config/_modelconfig/exgauss.py
new file mode 100644
index 00000000..37d6ab2c
--- /dev/null
+++ b/ssms/config/_modelconfig/exgauss.py
@@ -0,0 +1,40 @@
+"""Ex Gauss model configuration."""
+
+import cssm
+from ssms.basic_simulators import boundary_functions as bf
+
+def get_exgauss_config(): 
+    """Get the configuration of the Ex-Gaussian model""" 
+    return { 
+        "name": "exgauss", 
+        "params": ["mu0", "mu1", "sigma0", "sigma1", "tau0", "tau1", "p"], 
+        "param_bounds": [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
+                         [50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 1.0]], 
+        "boundary_name": 'constant', 
+        "boundary": bf.constant, 
+        "boundary_params": [], 
+        "n_params": 7, 
+        "default_params": [0.5, 0.5, 0.05, 0.05, 0.3, 0.3, 0.5], 
+        "nchoices": 2, 
+        "choices": [-1, 1], 
+        "n_particles": 1, 
+        "simulator": cssm.exgauss, 
+    }
+
+def get_exgauss_race_config(): 
+    """Get the configuration of the race version of Ex-Gaussian model"""
+    return { 
+        "name": "exgauss_race",
+        "params": ["mu0", "mu1", "sigma0", "sigma1", "tau0", "tau1", "p"], 
+        "param_bounds": [[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
+                         [50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 1.0]],
+        "boundary_name": 'constant', 
+        "boundary": bf.constant, 
+        "boundary_params": [], 
+        "n_params": 7, 
+        "default_params": [0.5, 0.5, 0.05, 0.05, 0.3, 0.3, 0.5], 
+        "nchoices": 2, 
+        "choices": [-1, 1], 
+        "n_particles": 1, 
+        "simulator": cssm.exgauss,
+    } 
\ No newline at end of file
diff --git a/ssms/config/_modelconfig/shifted_wald.py b/ssms/config/_modelconfig/shifted_wald.py
new file mode 100644
index 00000000..5cc2dbe5
--- /dev/null
+++ b/ssms/config/_modelconfig/shifted_wald.py
@@ -0,0 +1,40 @@
+"""Shifted Wald model configuration."""
+
+import cssm
+from ssms.basic_simulators import boundary_functions as bf
+
+def get_shifted_wald_config(): 
+    """Get the configuration of the Shifted Wald model""" 
+    return { 
+        "name": "shifted_wald", 
+        "params": ["v0", "v1", "a0", "a1", "t", "p"], 
+        "param_bounds": [[0.0, 0.0, 0.3, 0.3, 0.0, 0.0], 
+                        [5, 5, 2.5, 2.5, 2.0, 1.0]], 
+        "boundary_name": 'constant', 
+        "boundary": bf.constant, 
+        "boundary_params": [], 
+        "n_params": 6, 
+        "default_params": [2.0, 2.0, 1, 1, 0.0, 0.5], 
+        "nchoices": 2, 
+        "choices": [-1, 1], 
+        "n_particles": 1, 
+        "simulator": cssm.shifted_wald, 
+    }
+
+def get_shifted_wald_race_config():
+    """Get the configuration of the race version of Shifted Wald model"""
+    return {
+        "name": "shifted_wald_race",
+        "params": ["v0", "v1", "a0", "a1", "t", "p"],
+        "param_bounds": [[0.0, 0.0, 0.3, 0.3, 0.0, 0.0],
+                        [5, 5, 2.5, 2.5, 2.0, 1.0]],
+        "boundary_name": 'constant',
+        "boundary": bf.constant,
+        "boundary_params": [],
+        "n_params": 6,
+        "default_params": [2.0, 2.0, 1, 1, 0.0, 0.5],
+        "nchoices": 2,
+        "choices": [-1, 1],
+        "n_particles": 1,
+        "simulator": cssm.shifted_wald,
+    }
\ No newline at end of file