drug_discovery.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collaborative Active Learning for Drug Discovery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from zipfile import ZipFile\n",
    "from copy import deepcopy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading drug/target interaction (DTI) data\n",
    "- `X_drug`: Simplified Molecular-Input Line-Entry System (SMILES) string that describes molecule structures of drugs.\n",
    "- `X_target`: Target amino acid sequence (Target sites for drugs).\n",
    "- `y`: Affinity score between the drug and target; when binary, set $y=0$ for $\\text{affinity}<\\text{threshold}$ and $y=1$ otherwise.\n",
    "\n",
    "**Our task: for a specific amino acid site we want to target, find a suitable drug that binds (thus acts) well on the target site.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_y_unit(y, from_, to_):\n",
    "\tarray_flag = False\n",
    "\tif isinstance(y, (int, float)):\n",
    "\t\ty = np.array([y])\n",
    "\t\tarray_flag = True\n",
    "\ty = y.astype(float)    \n",
    "\t# basis as nM\n",
    "\tif from_ == 'nM':\n",
    "\t\ty = y\n",
    "\telif from_ == 'p':\n",
    "\t\ty = 10**(-y) / 1e-9\n",
    "\n",
    "\tif to_ == 'p':\n",
    "\t\tzero_idxs = np.where(y == 0.)[0]\n",
    "\t\ty[zero_idxs] = 1e-10\n",
    "\t\ty = -np.log10(y*1e-9)\n",
    "\telif to_ == 'nM':\n",
    "\t\ty = y\n",
    "        \n",
    "\tif array_flag:\n",
    "\t\treturn y[0]\n",
    "\treturn y\n",
    "\n",
    "def load_process_DAVIS(path = './data', binary = False, convert_to_log = True, threshold = 30):\n",
    "    print('Beginning Processing...')\n",
    "\n",
    "    if not os.path.exists(path):\n",
    "        os.makedirs(path)\n",
    "\n",
    "    saved_path = './data/DAVIS_raw.zip'\n",
    "\n",
    "    ## IMPORTANT: Download the DAVIS dataset file from 'https://github.com/futianfan/DeepPurpose_Data/blob/main/DAVIS.zip?raw=true'\n",
    "    ## and place the dataset file in the './data/' folder. Extract the zip file using the code below\n",
    "    # print('Beginning to extract zip file...')\n",
    "    # with ZipFile(saved_path, 'r') as zip:\n",
    "    #     zip.extractall(path = path)\n",
    "\n",
    "    affinity = pd.read_csv(path + '/DAVIS/affinity.txt', header=None, sep = ' ')\n",
    "\n",
    "    with open(path + '/DAVIS/target_seq.txt') as f:\n",
    "        target = json.load(f)\n",
    "\n",
    "    with open(path + '/DAVIS/SMILES.txt') as f:\n",
    "        drug = json.load(f)\n",
    "\n",
    "    target = list(target.values())\n",
    "    drug = list(drug.values())\n",
    "\n",
    "    SMILES = []\n",
    "    Target_seq = []\n",
    "    y = []\n",
    "\n",
    "    for i in range(len(drug)):\n",
    "        for j in range(len(target)):\n",
    "            SMILES.append(drug[i])\n",
    "            Target_seq.append(target[j])\n",
    "            y.append(affinity.values[i, j])\n",
    "\n",
    "    if binary:\n",
    "        print('Default binary threshold for the binding affinity scores are 30, you can adjust it by using the \"threshold\" parameter')\n",
    "        y = [1 if i else 0 for i in np.array(y) < threshold]\n",
    "    else:\n",
    "        if convert_to_log:\n",
    "            print('Default set to logspace (nM -> p) for easier regression')\n",
    "            y = convert_y_unit(np.array(y), 'nM', 'p')\n",
    "        else:\n",
    "            y = y\n",
    "    print('Done!')\n",
    "    return np.array(SMILES), np.array(Target_seq), np.array(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Beginning Processing...\n",
      "Default binary threshold for the binding affinity scores are 30, you can adjust it by using the \"threshold\" parameter\n",
      "Done!\n",
      "Setting the target site to be the amino acid with sequence \"PFWKILNPLLERGTYYYFMGQQPGKVLGDQRRPSLPALHFIKGAGKKESSRHGGPHCNVFVEHEALQRPVASDFEPQGLSEAARWNSKENLLAGPSENDPNLFVALYDFVASGDNTLSITKGEKLRVLGYNHNGEWCEAQTKNGQGWVPSNYITPVNSLEKHSWYHGPVSRNAAEYLLSSGINGSFLVRESESSPGQRSISLRYEGRVYHYRINTASDGKLYVSSESRFNTLAELVHHHSTVADGLITTLHYPAPKRNKPTVYGVSPNYDKWEMERTDITMKHKLGGGQYGEVYEGVWKKYSLTVAVKTLKEDTMEVEEFLKEAAVMKEIKHPNLVQLLGVCTREPPFYIITEFMTYGNLLDYLRECNRQEVNAVVLLYMATQISSAMEYLEKKNFIHRDLAARNCLVGENHLVKVADFGLSRLMTGDTYTAHAGAKFPIKWTAPESLAYNKFSIKSDVWAFGVLLWEIATYGMSPYPGIDLSQVYELLEKDYRMERPEGCPEKVYELMRACWQWNPSDRPSFAEIHQAFETMFQESSISDEVEKELGKQGVRGAVSTLLQAPELPTKTRTSRRAAEHRDTTDVPEMPHSKGQGESDPLDHEPAVSPLLPRKERGPPEGGLNEDERLLPKDKKTNLFSALIKKKKKTAPTPPKRSSSFREMDGQPERRGAGEEEGRDISNGALAFTPLDTADPAKSPKPSNGAGVPNGALRESGGSGFRSPHLWKKSSTLTSSRLATGEEEGGGSSSKRFLRSCSASCVPHGAKDTEWRSVTLPRDLQSTGRQFDSSTFGGHKSEKPALPRKRAGENRSDQVTRGTVTPPPRLVKKNEEAADEVFKDIMESSPGSSPPNLTPKPLRRQVTVAPASGLPHKEEAGKGSALGTPAAAEPVTPTSKAGSGAPGGTSKGPAEESRVRRHKHSSESPGRDKGKLSRLKPAPPPPPAASAGKAGGKPSQSPSQEAAGEAVLGAKTKATSLVDAVNSDAAKPSQPGEGLKKPVLPATPKPQSAKPSGTPISPAPVPSTLPSASSALAGDQPSSTAFIPLISTRVSLRKTRQPPERIASGAITKGVVLDSTEALCLAISRNSEQMASHSAVLEAGKNLYTFCVSYVDSIQQMRNKFAFREAINKLENNLRELQICPATAGSGPAATQDFSKLLSSVKEISDIVQR\"\n"
     ]
    }
   ],
   "source": [
    "X_drug, X_target, y = load_process_DAVIS('./data/', binary=True)\n",
    "print('Setting the target site to be the amino acid with sequence \"{}\"'.format(X_target[1]))\n",
    "idx = X_target==X_target[1]\n",
    "X_drug, X_target, y = X_drug[idx], X_target[idx], y[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Unique X_drug to a specific X_target, y is binary\n",
    "idx = np.unique(X_drug, return_index=True)[1]\n",
    "X_drug, X_target, y = X_drug[idx], X_target[idx], y[idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define the kernel for DTI\n",
    "Since the `X_drug` is in the form of strings, we need to use string kernels here.\n",
    "- Mismatch: $(k,m)$-mismatch kernel ($k$ for length of compared substrings, $m$ for # of mismatches allowed)\n",
    "- Subsequence: Gap-weighted subsequences kernels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import re\n",
    "\n",
    "class Kernel():\n",
    "    def __init__(self, kernel = None, y_true = None):\n",
    "        self.check_size(kernel)\n",
    "        self.kernel = kernel\n",
    "        self.y_true = y_true\n",
    "    \n",
    "    @classmethod    \n",
    "    def get_kernel(cls, path):\n",
    "        kernel = []\n",
    "        with open (path) as input:\n",
    "            for line in input:\n",
    "                # delete blank lines or lines of all 0's\n",
    "                if re.match(r'^\\s*$', line) or float(line.split(' ')[0]) - 0 < 0.00001:\n",
    "                    continue\n",
    "                kernel.append(list(map(float,line.strip().split(' '))))\n",
    "        kernel = np.array(kernel)\n",
    "        return (kernel)\n",
    "\n",
    "    @classmethod\n",
    "    def subseq_helper(cls, smiles, **kwargs):\n",
    "        lamda = kwargs['lamda'] if 'lamda' in kwargs else None            \n",
    "        p = kwargs['p'] if 'p' in kwargs else None\n",
    "        tune = kwargs['p'] if 'tune' in kwargs else None\n",
    "\n",
    "        if not tune:\n",
    "            if lamda and p:\n",
    "                K= gws(smiles, p, lamda)\n",
    "            elif lamda:\n",
    "                K = gws(smiles, 4, lamda)\n",
    "            elif p:\n",
    "                K = gws(smiles, p, 0.8)\n",
    "            else:\n",
    "                K = gws(smiles)\n",
    "        else:   # tune both parameters\n",
    "            K = gws(smiles, None, None, True)\n",
    "            \n",
    "        return (K)\n",
    "\n",
    "    @classmethod\n",
    "    def mismatch_helper(cls, smiles, **kwargs):\n",
    "        k = kwargs['k'] if 'k' in kwargs else None\n",
    "        m = kwargs['m'] if 'm' in kwargs else None\n",
    "\n",
    "        if k and m:\n",
    "            K = mismatch(smiles, k, m)\n",
    "        elif k:\n",
    "            K = mismatch(smiles, k, 1)\n",
    "        elif m:\n",
    "            K = mismatch(smiles, 4, m)\n",
    "        else:\n",
    "            K = mismatch(smiles)\n",
    "\n",
    "        return (K)\n",
    "    \n",
    "    def check_size(self, K):\n",
    "        if K.shape[0] != K.shape[1]:\n",
    "            raise Exception(\"The Gram matrix doesn't have correct size.\")\n",
    "\n",
    "    @classmethod\n",
    "    def from_file(cls, path, y_true):\n",
    "        K = cls.get_kernel(path)\n",
    "        return cls(K, y_true)\n",
    "    \n",
    "    @classmethod\n",
    "    def from_smi(cls, smiles, y_true, kern_type, **kwargs):\n",
    "\n",
    "        # string kernel\n",
    "        if kern_type == 'subsequence':\n",
    "            K = cls.subseq_helper(smiles, **kwargs)    \n",
    "            return (cls(K, y_true))            \n",
    "            \n",
    "        # mismatch kernel\n",
    "        if kern_type == 'mismatch':\n",
    "            K = cls.mismatch_helper(smiles, **kwargs)\n",
    "            return (cls(K, y_true))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "# mismatch kernel\n",
    "# k for length of compared substrings, m for # of mismatches allowed\n",
    "def mismatch(smiles, k = 4, m = 1):\n",
    "    N = len(smiles)\n",
    "    count_tree = mismatch_count(smiles, k, m)\n",
    "    gram = mismatch_matrix(count_tree, N)\n",
    "    return (gram)\n",
    "\n",
    "def mismatch_count(smiles, k = 5, m = 1):\n",
    "    # construct the alphabet for smiles representation of mols\n",
    "    alphabet = set()\n",
    "    for smile in smiles:\n",
    "        for c in smile:\n",
    "            alphabet.add(c)\n",
    "\n",
    "    # compute the dict for counting characters (l=1)\n",
    "    N = len(smiles)\n",
    "    t1 = {i:{} for i in alphabet}\n",
    "    for x in alphabet:\n",
    "        for i in range(N):\n",
    "            for j in range(len(smiles[i])):\n",
    "                t1[x][(i,j)] = 0 if smiles[i][j] == x else 1\n",
    "    \n",
    "    prev = t1\n",
    "    \n",
    "    for i in range(1, k - 1):\n",
    "        cur = {}\n",
    "        for key in prev:\n",
    "            for c in alphabet:                \n",
    "                temp = tuple(list(key) + [c])  # potential substrings\n",
    "                for key2 in prev[key]:\n",
    "                    i, j = key2\n",
    "                    if prev[key][key2] <= m and j <= len(smiles[i]) - 2:                \n",
    "                        if temp not in cur:\n",
    "                            cur[temp] = {}\n",
    "                        count = prev[key][key2] if smiles[i][j+1] == c else prev[key][key2] + 1  # count mismatches\n",
    "                        if count <= m:\n",
    "                            cur[temp][(i,j+1)] = count\n",
    "        prev = cur\n",
    "                            \n",
    "    count_tree = {}\n",
    "    for key in prev:\n",
    "        for c in alphabet:\n",
    "            temp = tuple(list(key) + [c])\n",
    "            for key2 in prev[key]:\n",
    "                i, j = key2\n",
    "                if prev[key][key2] <= m and j <= len(smiles[i]) - 2:                \n",
    "                    if temp not in count_tree:\n",
    "                        count_tree[temp] = {}\n",
    "                    if i not in count_tree[temp]:\n",
    "                        count_tree[temp][i] = {}\n",
    "                    count = prev[key][key2] if smiles[i][j+1] == c else prev[key][key2] + 1\n",
    "                    if count <= m:\n",
    "                        count_tree[temp][i][j+1] = count\n",
    "    return (count_tree) \n",
    "\n",
    "def mismatch_matrix(count_tree, N):\n",
    "    # compute gram matrix                    \n",
    "    K = np.zeros((N,N))\n",
    "    for key1 in count_tree:\n",
    "        l = count_tree[key1].keys()\n",
    "        for i in l:\n",
    "            for j in l:\n",
    "                K[i, j] += len(count_tree[key1][i].keys()) * len(count_tree[key1][j].keys())\n",
    "                \n",
    "    # normalize\n",
    "    gram = np.zeros((N,N))\n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            gram[i,j] = K[i,j] / math.sqrt(K[i,i] * K[j,j])\n",
    "            \n",
    "    return (gram)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gap-weighted subsequences kernels\n",
    "# Input: strings s and t of lengths n and m, length p, weight λ\n",
    "def gws_kern(mol1, mol2, p, lamda):\n",
    "    n = len(mol1)\n",
    "    m = len(mol2)\n",
    "    DPS = np.zeros((n, m))\n",
    "    kern = [0]*p\n",
    "    \n",
    "    for i in range(n):\n",
    "        for j in range(m):\n",
    "            if mol1[i] == mol2[j]:\n",
    "                DPS[i,j] = lamda**2\n",
    "        \n",
    "    kern[0] = np.sum(DPS)\n",
    "    DP = np.zeros((n-1, m-1))\n",
    "    for l in range(1,p):\n",
    "        DP[0,0] = DPS[0,0]\n",
    "        # boundary values\n",
    "        for i in range(1,n-1):\n",
    "            DP[i,0] = DPS[i,0] + lamda * DP[i-1,0]\n",
    "        for j in range(1,m-1):\n",
    "            DP[0,j] = DPS[0,j] + lamda * DP[0,j-1]\n",
    "            \n",
    "        # update DP\n",
    "        for i in range(1,n-1):\n",
    "            for j in range(1,m-1):\n",
    "                DP[i,j] = DPS[i,j] + lamda * DP[i-1,j] + lamda * DP[i,j-1] + (lamda**2) * DP[i-1,j-1]\n",
    "            \n",
    "        # update DPS and kernel value\n",
    "        for i in range(1,n):\n",
    "            for j in range(1,m):\n",
    "                if mol1[i] == mol2[j]:\n",
    "                    DPS[i,j] = (lamda**2) * DP[i-1,j-1]\n",
    "                    kern[l] = kern[l] + DPS[i,j]\n",
    "                    \n",
    "    return (kern)\n",
    "\n",
    "\n",
    "def gws_matrix(smiles, p, lamda):\n",
    "    kern = [[] for _ in range(p)]\n",
    "    for i in range(len(smiles)):\n",
    "        temp = gws_kern(smiles[i],smiles[i],p,lamda)\n",
    "        for l in range(p):\n",
    "            # compute square root here\n",
    "            kern[l].append(math.sqrt(temp[l]))\n",
    "    \n",
    "    sim = [[] for _ in range(p)]\n",
    "    for i in range(len(smiles)):\n",
    "        for l in range(p):\n",
    "            sim[l].append([])\n",
    "        for j in range(len(smiles)):\n",
    "            temp = gws_kern(smiles[i],smiles[j],p,lamda)\n",
    "            for l in range(p):\n",
    "                # normalize\n",
    "                sim[l][i].append(temp[l]/(kern[l][i]*kern[l][j]))\n",
    "                \n",
    "    str_kern = np.array(sim)\n",
    "    return (str_kern)\n",
    "\n",
    "\n",
    "def gws(smiles, p = 4, lamda = 0.8, tune = False):\n",
    "    if not tune:\n",
    "        gram = gws_matrix(smiles, p, lamda)[p-1]\n",
    "        return (gram)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel_name = 'subsequence' ## or 'mismatch'\n",
    "\n",
    "if kernel_name == 'subsequence':\n",
    "    subsequence = Kernel.from_smi(X_drug, y, 'subsequence')\n",
    "    kernel_matrix = subsequence.kernel\n",
    "elif kernel_name == 'mismatch':\n",
    "    mismatch = Kernel.from_smi(X_drug, y, 'mismatch')\n",
    "    kernel_matrix = mismatch.kernel\n",
    "else:\n",
    "    raise NotImplementedError()\n",
    "\n",
    "inputs = X_drug\n",
    "\n",
    "kernel_dict = dict()\n",
    "for i in range(len(inputs)):\n",
    "    kernel_dict[inputs[i]] = i\n",
    "\n",
    "def kernel_func(x1, x2):\n",
    "    matrix = np.zeros((len(x1), len(x2)))\n",
    "\n",
    "    for i in range(len(x1)):\n",
    "        for j in range(len(x2)):\n",
    "            matrix[i, j] = kernel_matrix[kernel_dict[x1[i]], kernel_dict[x2[j]]]\n",
    "\n",
    "    return matrix\n",
    "\n",
    "kernel = kernel_func"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CAL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.utils import cwd, set_up_plotting\n",
    "from itertools import product\n",
    "\n",
    "plt = set_up_plotting()\n",
    "\n",
    "def posterior_predictive(X, X_train, Y_train, sigma_y=1e-8):\n",
    "    K = kernel(X_train, X_train) + np.square(sigma_y) * np.eye(len(X_train))\n",
    "    K_s = kernel(X_train, X)\n",
    "    K_ss = kernel(X, X)\n",
    "    \n",
    "    K_inv = np.linalg.inv(K + 1e-6 * np.eye(len(K)))\n",
    "\n",
    "    mu_s = K_s.T @ K_inv @ Y_train\n",
    "    cov_s = K_ss - K_s.T @ K_inv @ K_s\n",
    "\n",
    "    return mu_s, cov_s\n",
    "\n",
    "\n",
    "def posterior_covariance(X, X_train, sigma_y=1e-8):\n",
    "    K = kernel(X_train, X_train) + np.square(sigma_y) * np.eye(len(X_train))\n",
    "    K_s = kernel(X_train, X)\n",
    "    K_ss = kernel(X, X)\n",
    "    K_inv = np.linalg.inv(K + 1e-6 * np.eye(len(K)))\n",
    "\n",
    "    cov_s = K_ss - K_s.T @ K_inv @ K_s\n",
    "\n",
    "    return cov_s\n",
    "\n",
    "def IG_sum(acquired_obs, Ts, prior_logdets, alphas):\n",
    "    \n",
    "    return sum(_IG(acquired_obs, T, prior_logdet) *1.0 / alpha for T, prior_logdet, alpha in zip(Ts, prior_logdets, alphas) )\n",
    "\n",
    "def _IG(acquired_obs, T, prior_logdet):\n",
    "    post_cov = posterior_covariance(X=T, X_train=acquired_obs)\n",
    "    _ , post_logdet = np.linalg.slogdet(post_cov)\n",
    "    return 0.5 * (prior_logdet - post_logdet)\n",
    "\n",
    "def coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[], d=1):\n",
    "    if len(alphas) == 0:\n",
    "        alphas = np.ones(len(Ts)) / len(Ts)\n",
    "    else:\n",
    "        assert len(alphas) == len(Ts)\n",
    "        alphas = np.asarray(alphas) / sum(alphas)\n",
    "        \n",
    "    acquired_obs = np.asarray([])\n",
    "    # supports is a copy of Ss so we do not need to repeatedly initialize Ss\n",
    "    Supports = deepcopy(Ss)\n",
    "\n",
    "    for _ in range(budget):\n",
    "        delta_IG_max = -float('inf')\n",
    "        obs_ = None\n",
    "        prev_IG = 0\n",
    "\n",
    "        full_cartesian = np.asarray(list(product(*Supports)))\n",
    "        subset_size = min(subset_size, len(full_cartesian))\n",
    "\n",
    "        subset_cartesian = full_cartesian[np.random.choice(len(full_cartesian), size=subset_size, replace=False)]\n",
    "        for obs in subset_cartesian:\n",
    "            temp_obs = np.append(acquired_obs, [obs])\n",
    "\n",
    "            delta_IG = IG_sum(temp_obs, Ts, prior_logdets, alphas) - prev_IG\n",
    "            # the weighted sum of difference in IG_k - IG_{k-1} in Equation (2)\n",
    "            \n",
    "            if delta_IG > delta_IG_max:\n",
    "                delta_IG_max = delta_IG\n",
    "                obs_ = obs\n",
    "\n",
    "#         print(\"budget: {}\".format(_), IG_max, obs_)\n",
    "        acquired_obs = np.append(acquired_obs, [obs_])\n",
    "        \n",
    "        prev_IG = IG_sum(acquired_obs, Ts, prior_logdets, alphas)\n",
    "        \n",
    "        for i, (S, ob) in enumerate(zip(Supports, obs_)):\n",
    "            remove_idx = np.argwhere((S == ob).all(-1))\n",
    "            keep_idx = np.setdiff1d(np.arange(len(S)), remove_idx)\n",
    "            Supports[i] = S[keep_idx]\n",
    "\n",
    "    return acquired_obs\n",
    "\n",
    "def coordinated_joint(Ss, joint_target, budget, prior_logdet_joint, subset_size=1000, d=1):\n",
    "    acquired_obs = np.asarray([])\n",
    "    # supports is a copy of Ss so we do not need to repeatedly initialize Ss\n",
    "    Supports = deepcopy(Ss)\n",
    "    \n",
    "    for _ in range(budget):\n",
    "        delta_IG_max = -float('inf')\n",
    "        obs_ = None\n",
    "        prev_IG = 0\n",
    "\n",
    "        full_cartesian = np.asarray(list(product(*Supports)))\n",
    "        subset_size = min(subset_size, len(full_cartesian))\n",
    "\n",
    "        subset_cartesian = full_cartesian[np.random.choice(len(full_cartesian), size=subset_size, replace=False)]\n",
    "              \n",
    "        for obs in subset_cartesian:\n",
    "            temp_obs = np.append(acquired_obs, [obs])\n",
    "            \n",
    "            delta_IG = _IG(temp_obs, joint_target, prior_logdet_joint) - prev_IG\n",
    "            \n",
    "            if delta_IG > delta_IG_max:\n",
    "                delta_IG_max = delta_IG\n",
    "                obs_ = obs\n",
    "        \n",
    "        acquired_obs = np.append(acquired_obs, [obs_])               \n",
    "        \n",
    "        prev_IG = _IG(acquired_obs, joint_target, prior_logdet_joint)\n",
    "\n",
    "        for i, (S, ob) in enumerate(zip(Supports, obs_)):\n",
    "            remove_idx = np.argwhere((S == ob).all(-1))\n",
    "            keep_idx = np.setdiff1d(np.arange(len(S)), remove_idx)\n",
    "            Supports[i] = S[keep_idx]\n",
    "\n",
    "    return acquired_obs\n",
    "\n",
    "\n",
    "def coordinated_random(Ss, Ts, budget, prior_logdets, d=1):\n",
    "    acquired_obs = np.asarray([])\n",
    "    # supports is a copy of Ss so we do not need to repeatedly initialize Ss\n",
    "    Supports = deepcopy(Ss)\n",
    "    \n",
    "    for _ in range(budget):\n",
    "\n",
    "        full_cartesian = np.asarray(list(product(*Supports)))\n",
    "        \n",
    "        obs_ = full_cartesian[np.random.choice(len(full_cartesian), size=1, replace=False)].squeeze()\n",
    "        acquired_obs = np.append(acquired_obs, [obs_])\n",
    "\n",
    "        for i, (S, ob) in enumerate(zip(Supports, obs_)):\n",
    "            remove_idx = np.argwhere((S == ob).all(-1))\n",
    "            keep_idx = np.setdiff1d(np.arange(len(S)), remove_idx)\n",
    "            Supports[i] = S[keep_idx]\n",
    "\n",
    "    return acquired_obs\n",
    "\n",
    "def entropy_sum(acquired_obs, Ts, alphas=[]):\n",
    "    if len(alphas) == 0:\n",
    "        alphas = np.ones(len(Ts)) / len(Ts)\n",
    "    else:\n",
    "        alphas = np.asarray(alphas)\n",
    "    \n",
    "    return sum(_entropy(acquired_obs, T) *1.0 / alpha for T, alpha in zip(Ts, alphas) )\n",
    "\n",
    "def _entropy(acquired_obs, T):\n",
    "    '''\n",
    "    Note this is not the exact differential entropy formula, \n",
    "    instead it ignores some constant terms including the dimension d of data.\n",
    "    \n",
    "    For the purpose of maximum entropy search, it is sufficient since we only need the rank and not the \n",
    "    absolute value of entropy.\n",
    "    '''\n",
    "    post_cov = posterior_covariance(T, acquired_obs)\n",
    "    _ , post_logdet = np.linalg.slogdet(post_cov)\n",
    "    \n",
    "    return post_logdet\n",
    "\n",
    "\n",
    "def coordinated_entropy(Ss, Ts, budget, subset_size=1000, d=1):\n",
    "    acquired_obs = np.asarray([])\n",
    "    \n",
    "    # supports is a copy of Ss so we do not need to repeatedly initialize Ss\n",
    "    Supports = deepcopy(Ss)\n",
    "\n",
    "    for _ in range(budget):\n",
    "        obs_ = None\n",
    "        \n",
    "        entropy_max = -float('inf')\n",
    "\n",
    "        full_cartesian = np.asarray(list(product(*Supports)))\n",
    "        subset_size = min(subset_size, len(full_cartesian))\n",
    "\n",
    "        subset_cartesian = full_cartesian[np.random.choice(len(full_cartesian), size=subset_size, replace=False)]\n",
    "\n",
    "        for obs in subset_cartesian:\n",
    "            temp_obs = np.append(acquired_obs, [obs])\n",
    "\n",
    "            curr_entropy = entropy_sum(temp_obs, Ts)\n",
    "            \n",
    "            if curr_entropy > entropy_max:\n",
    "                entropy_max = curr_entropy\n",
    "                obs_ = obs\n",
    "\n",
    "#         print(\"budget: {}\".format(_), IG_max, obs_)\n",
    "        acquired_obs = np.append(acquired_obs, [obs_])\n",
    "        \n",
    "        for i, (S, ob) in enumerate(zip(Supports, obs_)):\n",
    "            remove_idx = np.argwhere((S == ob).all(-1))\n",
    "            keep_idx = np.setdiff1d(np.arange(len(S)), remove_idx)\n",
    "            Supports[i] = S[keep_idx]\n",
    "\n",
    "    return acquired_obs\n",
    "\n",
    "def individual_greedy(S, T, prior_logdet, budget, d=1, subset_size=1000):\n",
    "        \n",
    "    acquired_obs = np.asarray([])\n",
    "    # supports is a copy of Ss so we do not need to repeatedly initialize Ss\n",
    "    Support = (S)\n",
    "    IG_trail = []\n",
    "    for _ in range(budget):\n",
    "        delta_IG_max = -float('inf')\n",
    "        obs_ = None\n",
    "        prev_IG = 0\n",
    "        \n",
    "        subset_size = min(subset_size, len(Support))\n",
    "        sub_support = Support[np.random.choice(len(Support), size=subset_size, replace=False)]\n",
    "        for obs in sub_support:        \n",
    "            temp_obs = np.append(acquired_obs, [obs])\n",
    "\n",
    "            delta_IG = _IG(temp_obs, T, prior_logdet) - prev_IG\n",
    "\n",
    "            if delta_IG > delta_IG_max:\n",
    "                delta_IG_max = delta_IG\n",
    "                obs_ = obs\n",
    "\n",
    "        IG_trail.append(delta_IG_max)\n",
    "        acquired_obs = np.append(acquired_obs, [obs_])\n",
    "        prev_IG = _IG(acquired_obs, T, prior_logdet)\n",
    "\n",
    "        # Support = S[S!= obs_].reshape(-1,d)\n",
    "        remove_idx = np.argwhere((S == obs_).all(-1))\n",
    "        keep_idx = np.setdiff1d(np.arange(len(S)), remove_idx)\n",
    "        Support = S[keep_idx]\n",
    "\n",
    "    return acquired_obs, IG_trail\n",
    "\n",
    "def get_IG_trails(obs, Ts, prior_logdets, alphas=[]):\n",
    "    if len(alphas) == 0:\n",
    "        alphas = np.ones(len(Ts)) / len(Ts)\n",
    "    else:\n",
    "        assert len(alphas) == len(Ts)\n",
    "        alphas = np.asarray(alphas) / sum(alphas)\n",
    "        \n",
    "    IG_sep_trail, IG_sum_trail = [], []\n",
    "\n",
    "    acquired_obs = np.asarray([])\n",
    "    \n",
    "    for ob in obs:\n",
    "        curr_IG_sep = []\n",
    "\n",
    "        acquired_obs = np.append(acquired_obs, [ob])\n",
    "        for i, (T, prior_logdet) in enumerate(zip(Ts, prior_logdets)):\n",
    "\n",
    "            IG_i = _IG(acquired_obs, T, prior_logdet)\n",
    "            curr_IG_sep.append(IG_i)\n",
    "        IG_sep_trail.append(curr_IG_sep)\n",
    "        \n",
    "        IG_sum_trail.append(sum(IG*1.0/alpha for alpha, IG in zip(alphas, curr_IG_sep)) )\n",
    "\n",
    "    return IG_sep_trail, IG_sum_trail\n",
    "\n",
    "def coordinated_greedy_IG_sum(Ss, Ts, budget, prior_logdets, subset_size=1000, betas=[], d=1):\n",
    "    '''\n",
    "    Greedily maximizing the total sum of IGs in coordination instead of the marginal to the total sum of IGs \n",
    "    as in coordinated_greedy().\n",
    "    \n",
    "    This method does NOT satisfy near-optimality guarantee but may help with \"cumulative\" fairness of overall\n",
    "    IGs.\n",
    "    \n",
    "    '''\n",
    "    betas = _check_betas(n=len(Ts), betas=betas)\n",
    "\n",
    "    acquired_obs = np.asarray([])\n",
    "    # supports is a copy of Ss so we do not need to repeatedly initialize Ss\n",
    "    Supports = deepcopy(Ss)\n",
    "\n",
    "    for _ in range(budget):\n",
    "        IG_sum_max = -float('inf')\n",
    "        obs_ = None\n",
    "\n",
    "        full_cartesian = np.asarray(list(product(*Supports)))\n",
    "        subset_size = min(subset_size, len(full_cartesian))\n",
    "\n",
    "        subset_cartesian = full_cartesian[np.random.choice(len(full_cartesian), size=subset_size, replace=False)]\n",
    "        for obs in subset_cartesian:\n",
    "            temp_obs = np.append(acquired_obs, [obs])\n",
    "\n",
    "            IG_sum_curr = IG_sum(temp_obs, Ts, prior_logdets, betas)\n",
    "            # Directly try to maximize the total sum of IGs\n",
    "            \n",
    "            if IG_sum_curr > IG_sum_max:\n",
    "                IG_sum_max = IG_sum_curr\n",
    "                obs_ = obs\n",
    "\n",
    "#         print(\"budget: {}\".format(_), IG_max, obs_)\n",
    "        acquired_obs = np.append(acquired_obs, [obs_])\n",
    "                \n",
    "        for i, (S, ob) in enumerate(zip(Supports, obs_)):\n",
    "            Supports[i] = S[S != ob]\n",
    "\n",
    "    return acquired_obs\n",
    "\n",
    "from scipy.special import softmax\n",
    "def coordinated_dynamic_beta(Ss, Ts, budget, prior_logdets, subset_size=1000, betas=[], beta_coef=0.5, d=1):\n",
    "    '''\n",
    "    The beta values are dynamically updated according to the latest IGs of the agents to help improve\n",
    "    \"cumulative\" fairness.\n",
    "\n",
    "    \n",
    "    '''\n",
    "    betas = _check_betas(n=len(Ts), betas=betas)\n",
    "\n",
    "    acquired_obs = np.asarray([])\n",
    "    # supports is a copy of Ss so we do not need to repeatedly initialize Ss\n",
    "    Supports = deepcopy(Ss)\n",
    "\n",
    "    for _ in range(budget):\n",
    "        IG_sum_max = -float('inf')\n",
    "        obs_ = None\n",
    "\n",
    "        full_cartesian = np.asarray(list(product(*Supports)))\n",
    "        subset_size = min(subset_size, len(full_cartesian))\n",
    "\n",
    "        subset_cartesian = full_cartesian[np.random.choice(len(full_cartesian), size=subset_size, replace=False)]\n",
    "        for obs in subset_cartesian:\n",
    "            temp_obs = np.append(acquired_obs, [obs])\n",
    "\n",
    "            IG_sum_curr = IG_sum(temp_obs, Ts, prior_logdets, betas)\n",
    "            # Directly try to maximize the total sum of IGs\n",
    "            \n",
    "            if IG_sum_curr > IG_sum_max:\n",
    "                IG_sum_max = IG_sum_curr\n",
    "                obs_ = obs\n",
    "\n",
    "        acquired_obs = np.append(acquired_obs, [obs_])\n",
    "\n",
    "        individual_IGs = [_IG(acquired_obs, T, prior_logdet) for T, prior_logdet in zip(Ts, prior_logdets) ]\n",
    "        \n",
    "        updated_betas = softmax(individual_IGs)\n",
    "        betas = beta_coef * betas + (1-beta_coef) * updated_betas\n",
    "    \n",
    "        for i, (S, ob) in enumerate(zip(Supports, obs_)):\n",
    "            Supports[i] = S[S != ob]\n",
    "\n",
    "    return acquired_obs\n",
    "\n",
    "def _check_betas(n, betas=[]):\n",
    "    if len(betas) == 0:\n",
    "        betas = np.ones(n) / n\n",
    "    else:\n",
    "        assert len(betas) == n\n",
    "        betas = np.asarray(betas) / sum(betas)\n",
    "    return betas\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define supports and targets of agents\n",
    "Supports:\n",
    "- 1: Cannot synthesize Cl\n",
    "- 2: Cannot synthesize F\n",
    "- 3: Cannot synthesize CS\n",
    "\n",
    "*The agents cannot synthesize certain types of drugs due to the lack of resources or access to specialized machines.*\n",
    "\n",
    "Target:\n",
    "- What they cannot synthesize respectively\n",
    "\n",
    "*The agents are particularly interested in the properties of drugs they cannot currently produce. The agents would like to join a collaborative active learning effort for drug discovery.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 3\n",
    "exclude = ['Cl', 'F', 'CS']\n",
    "Ts, Ss = [], []\n",
    "\n",
    "for i_agent in range(n):\n",
    "    rows_contain_exclude = []\n",
    "    for i in range(len(X_drug)):\n",
    "        if exclude[i_agent] in X_drug[i]:\n",
    "            rows_contain_exclude.append(i)\n",
    "    rows_idx = np.setdiff1d(np.arange(len(X_drug)), rows_contain_exclude)\n",
    "    Ss.append(X_drug[rows_idx])\n",
    "    Ts.append(X_drug[rows_contain_exclude])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "prior_logdets, prior_covs = [], []\n",
    "\n",
    "for T in Ts:\n",
    "    prior_cov = kernel(T, T)\n",
    "    _, logdet = np.linalg.slogdet(prior_cov)\n",
    "    prior_covs.append(prior_cov)\n",
    "    prior_logdets.append(logdet)\n",
    "\n",
    "prior_logdet_joint, prior_cov_joint = None, None\n",
    "joint_target = np.unique(np.concatenate(Ts), axis=0)\n",
    "    \n",
    "prior_cov_joint = kernel(joint_target, joint_target)\n",
    "_, prior_logdet_joint = np.linalg.slogdet(prior_cov)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Might take 10 minutes for budget == 10\n",
    "budget = 7\n",
    "\n",
    "# Agent 1 from being altruistic to more increasingly greedy \n",
    "# greedy_obs_1 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[10,1,1], d=0)\n",
    "# greedy_obs_2 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[10,2,1], d=0)\n",
    "# greedy_obs_3 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[10,5,1], d=0)\n",
    "# greedy_obs_4 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[10,10,1], d=0)\n",
    "greedy_obs_1 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[19,1,10], d=0)\n",
    "greedy_obs_2 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[18,2,10], d=0)\n",
    "greedy_obs_3 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[16,5,10], d=0)\n",
    "greedy_obs_4 = coordinated_greedy(Ss, Ts, budget, prior_logdets, subset_size=1000, alphas=[10,10,10], d=0)\n",
    "\n",
    "greedy_IG_sep_trail_1, greedy_IG_sum_trail_1 = get_IG_trails(greedy_obs_1, Ts, prior_logdets)\n",
    "greedy_IG_sep_trail_2, greedy_IG_sum_trail_2 = get_IG_trails(greedy_obs_2, Ts, prior_logdets)\n",
    "greedy_IG_sep_trail_3, greedy_IG_sum_trail_3 = get_IG_trails(greedy_obs_3, Ts, prior_logdets)\n",
    "greedy_IG_sep_trail_4, greedy_IG_sum_trail_4 = get_IG_trails(greedy_obs_4, Ts, prior_logdets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand_obs = coordinated_random(Ss, Ts, budget, prior_logdets, d=0)\n",
    "joint_obs = coordinated_joint(Ss, joint_target, budget, prior_logdet_joint, subset_size=1000, d=0)\n",
    "entropy_obs = coordinated_entropy(Ss, Ts, budget, d=0)\n",
    "\n",
    "entropy_IG_sep_trail, entropy_IG_sum_trail = get_IG_trails(entropy_obs, Ts, prior_logdets)\n",
    "joint_IG_sep_trail, joint_IG_sum_trail = get_IG_trails(joint_obs, Ts, prior_logdets)\n",
    "rand_IG_sep_trail, rand_IG_sum_trail = get_IG_trails(rand_obs, Ts, prior_logdets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "greedy_sum_obs = coordinated_greedy_IG_sum(Ss, Ts, budget, prior_logdets, subset_size=1000, d=0)\n",
    "dynamic_beta_obs = coordinated_dynamic_beta(Ss, Ts, budget, prior_logdets, subset_size=1000, beta_coef=0.2, d=0)\n",
    "\n",
    "greedy_IGsum_sep_trail, greedy_IGsum_sum_trail = get_IG_trails(greedy_sum_obs, Ts, prior_logdets)\n",
    "dynamic_beta_sep_trail, dynamic_beta_sum_trail = get_IG_trails(dynamic_beta_obs, Ts, prior_logdets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "indiv_greedy_obs,  ind_greedy_IG_trails = [], []\n",
    "for i in range(n):\n",
    "    ind_greedy_ob, ind_greedy_IG_trail= individual_greedy(Ss[i], Ts[i], prior_logdets[i], budget, d=0, subset_size=1000)\n",
    "    indiv_greedy_obs.append(ind_greedy_ob)\n",
    "    ind_greedy_IG_trails.append(ind_greedy_IG_trail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "\n",
    "plt.plot(greedy_IG_sum_trail_1, label='greedy1')\n",
    "plt.plot(greedy_IG_sum_trail_2, label='greedy2')\n",
    "plt.plot(greedy_IG_sum_trail_3, label='greedy3')\n",
    "plt.plot(greedy_IG_sum_trail_4, label='greedy4')\n",
    "plt.plot(greedy_IGsum_sum_trail, label='greedySum')\n",
    "plt.plot(dynamic_beta_sum_trail, label='dynamicBeta')\n",
    "\n",
    "plt.plot(joint_IG_sum_trail, label='joint')\n",
    "plt.plot(entropy_IG_sum_trail, label='entropy')\n",
    "plt.plot(rand_IG_sum_trail, label='random')\n",
    "\n",
    "plt.legend(loc='upper left', ncol=2)\n",
    "plt.legend(ncol=2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg0AAAF7CAYAAABRi7jVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACJ4ElEQVR4nO3deVwU5R8H8M8eLOxyg6AgN5pXKoL3kQoognijppWmVpameeZt5JFHaWZ2Wj+txLxvMRNRFDQV8DYVQQXkkmOB5Vp22d8fxMDsLLCcK/p9v1698nnmeWaeWWZmvzvzzPPwVCqVCoQQQggh1eDrugGEEEIIaRooaCCEEEKIVihoIIQQQohWKGgghBBCiFYoaCCEEEKIVihoIIQQQohWKGgghBBCiFaEtalUUFCA77//Hjt27EBxcTGT/+DBg2rrPn36FEFBQbh06RKSk5OhUCjQrFkzeHh4ICAgAN27d692HVeuXMHBgwcRFRWF9PR0CIVC2NjYoHfv3nj77bfh4OBQm90ihBBCSBV4NR3c6ezZs1i7di2ePXvGWVZd0LB7926sW7cOcrkcVlZWmDJlCoyMjLBnzx7cu3cPABAQEIBVq1ZBIBBw6isUCqxYsQKHDh0CAHTo0AHjx4+HTCbDr7/+ioyMDIhEIixfvhzjx4+vyW4RQgghpBpaBw35+fmYP38+QkND4ejoCAcHB1y8eJFVpqqg4dixY1i4cCGT3rVrF7p16wYAyM7OhqenJ2QyGQBgwoQJCAwM5KxjxYoV2LdvHwDAxMQEoaGhMDY2BgBcvnwZ7777LlP266+/hp+fnza7RgghhBAtaN2nITMzE5cuXcLs2bNx4sQJdO7cWeuN5OTkYO3atUza1NQUXbt2ZaXLAggA2LNnD6Kjo1nriIyMZAIGAOjevTsTMABAz549WenVq1czQQghhBBC6k7roMHMzAwnT57EzJkzIRKJarSR48ePQyqVMmk7OzvweDxWGUdHR+bfKpUKu3btYi3/448/WGn1fgs8Hg/29vZMOjMzEydOnKhROwkhhBBSOa07QhoZGcHIyKhWGwkNDWWlzc3NOWXU80JDQ6FUKiEQCKBUKhEWFlbjdZw5cwZvvvlmjdqalZWHkpKGncPL0tIIGRl0F4RoRscHqQodH6QqNTk++HwezM0Na7T+Wr09UVN37txhpTUFH+p5BQUFiIuLQ+vWrREbG4uCggLWckND7o6qr6Osc2VNlJSoGjxoKNsOIZWh44NUhY4PUpWGPD4afJyG/Px81qMJANDT0+OU05SXlJTE+n9Fmh6RqK8jMzMThYWFNWkuIYQQQirR4HcaNHVG1PQ6paa8srqa1sHnc+MdTevIzc2FgYGBVm0FSm/tNAYrK+PqC5FXFh0fpCp0fJCqNOTx0SiPJ5qSjAxZg9/6s7IyxvPnuQ26DdJ00fFBqkLHB6lKTY4PPp9X4x/KDf54QlP/BaVSqVVeWV1N6ygpKdFqHRVfwySEEEJI7TV40CCRSGBmZsbKqzj0dFV5tra2rP9XJJfLq12Hubl5jR5NEEIIIaRyjTJhVYcOHVhpTX0U8vLyWGmxWAwXFxcAgKurK+fLX728pjz17RJCCCGk9holaPDy8mKls7KyOGXU8wYOHMh0bBQIBOjfv3+N1+Ht7V2r9hJCCCGEq1GCBn9/f5iamjLpxMREqE95ER8fz0q/9dZbVabVy6tUKiQkJDBpMzMz+Pv716ndhBBCCCnXKEGDqakpli5dyqSzs7MRGRnJpHNzc3Ht2jUmPX78eNbcFADQo0cPjBkzhklfvXqV9ZgjMjISOTk5THr58uXUCZIQQgipRzWaGvvy5cvIzMwEAJw+fRqnT59mlhkaGmLTps0wNJSAzxdAX18EPp89bkJengzZ2TkAVODzBTAyMgKPx0N+fj6Ki0s7NpZ3nGTPTVFKhawsKQoK8gEAenoiSCQSqFQqyGQylJQoAfBgamqqccRIbWh6K6O+8fn8RtkOaZro+CBVoeODqOPzBRCLjWBoaIzmzc0a9JXLGo3T8P333+Pq1aucfIFAgI8+mgGBQA9yuQoqlQItWthr/OIuKpIjMzMDMpkMxcXFUKkAAwMTWFhIYG5uDiOjqr/sbW0BmSwPWVlZyM/Ph1yuAI/Hg7GxBYyMjGBhYQl9/ZpNqFWRQtHwJ6NQyG+U7ZCmiY4PUhU6PkhFKpUKSmUx8vJykZmZBisrkwbdXo3uNFQmPT0dUmkuLCysOLNXNjUUNBBdo+ODVIWOD6KJSqWCVPocFhamUKn0taqjs8GdZDIZJBKjJh8wEEIIIU0Rj8eDWGykcUiD+lQvw0gXFBTC2NiiPlZFmgiBgKd1kFh6+6zxZ+XjC3jga9HGEpUKJTpoX1Mg4PPA42v5dy5RQUmzLxKiMyKRPjIzs1DLLn1aqZegoaSkBDxeo7yIQV4QPB4PRcmxWpXVt3EFoIOggcdDbGZ8teVcLRxQooP2VfWFLBSyzyddfSHz+DwkJWRrVdbW3hSgoIEQneHxGr6TbL1NWEWPJgipGR6fB9kj7QIvo1au9IVMCKlSY3wP0+0BQgghhGiFggZCCCGEaIWCBkIIIYRopd76NJDayc/Px9q1n+Hatavo2rU7li//HBKJpNG2v3z5pzh/PpSTv3Xrj3B3Zw/lffv2Taxbtwo5Odl4//2P4N/bvbGaSQhpABERF7Fo0VxOvq+vP5YtC2z8BpEXHgUNOhYU9BvCws4BAC5cOIegIBe8//5Hjbb9ceMmYsAAL2zZ8iWkUmml5VQqFT77bCnS0lIBAJs3b0Rnx82wb2nbSC0lhNS3Nm3aIjBwLc6fP6vxx0N9io6ORHDwcdy5cxsZGc+hUChgYmIKMzMzWFhYwtnZBW3btoebmzusrZs3aFtI7TVa0CCW6MNAv+nGKIVFCuTmFNT7eh8+vM9Kx8Q8qPdtVKVTJzcAwI8/bgMgrbScVCplAgYAUCqViH36lIKGJsDURASRvnYjxGlibt6AL31rQV5UhOwcuU7b8LJq1swK3t4+ePr0SYMFDQqFAuvXr8Zff50EAHTp4oHhw0fC3NwCOTnZiI9/ijNnTuPatSsAACsraxw+HNwgbSF112jf4gb6Qgybf7SxNlfvjm8aAe2mAKmZVq1ew+XLEaz0i8jMzAxWVtZ4/jwNQOmkOS6ODjpuFdGGSF8f25ZM0XUzau3jdTsAUNDQVP344zYmYJgw4R3MnPkJp8yHH87CvHkz8e+/9xq7eaSGqCOkjr3zzrvo128AxGIJ+vZ9A2+/PVnXTdKIx+MhMPAL2Ns7wNTUFPPmLYRDy5a6bhYh5AWWm5uLAwf2MOnBg301ljM2Nsa6dZsgEAg0Licvjqb7vOAlIZEYYt26r3TdDK107uyGP/88BKB0xEJtR4QkhLya7ty5BYVCwaSl0sxKyzZrZgVfX3/WY1Dy4qGgQUeSk5MwduxwTr6bmzu2bfsZABAQMAwpKcmcMqGhl7B//58ICTmNxMREKJVKODg4Yty4CfDzG1bpNm/evIG9e4Nw+/ZN5ObmwNjYBJ06dcaUKR9U2dZff/0JO3Zs5+QvnjUDvp4DsWPPPuzcu19j3SED+yNw3dcAgMTEBLz55ijW8ilT3se0adOr3D4hDSE5OQm7du3E1atXkJ6eBn19fbRu3QYTJ05CaOgZnDp1glNn69YfkZKSjC+++JyzzNfXH0uWrMT+/X/i5MljSExMhFxehBYtbHDgwHGmXGpqCg4e3IfIyCtISnqGwsJCmJqaoV279vDzG4433hhQaZsLCgpw8uQRhIWdx+PHsZDJZDA0NISTkwsGDPDCiBGjIRKJNNbNysrC7t2/IyLiAlJSUiAQCODk5IThw0dXur3o6EjMnv2hxmUV90vT9WzSpKlwcnJm5W3btgWffbYGLi6tNK5z8eIVnLzhw32QmZnByQ8PjwQAXLt2BXPnzuQsX7r0M+Z6WNX1dsuW77F79+/466+TSElJhqGhETp16oxp0z6Ei4srAODs2TPYv/9PxMXFQqUqQatWrfHWW++ib983NO7Hy4yCBh0xMzNHYOBa3LgRjSNHDmosM2fOQqSkJGHLFvadiE8/nQNnZ1eMGTMOoaFncfXqZTx69BBffPE5ZDIZxo2bwFnXn3/uwnffbWHSbm7uGDJkKFJTUzB37kwUFhZW2taBA73g6OiEnTt/wZMnjznL+/fqCdsWzbHxux+gUCiZ/Eljx6BXVw8mbWFhicDAtTh0aD8ePPgXixatQKtWmi8ehDSk69ejsGjRPOTn5wEAbGxaYvz40vNm8+YNnPH7BwzwxIABXnB2dkFaWipEIhGUSiWUSiWr3Nq1gTh9Ohg8Hg8qFXfY75CQ01i/fjVzvgUEvAkXF1fs27cb4eEXEB5+AQMHemPlytXQ09Nj1X30KAZLlsxHcnISAKBHj97w8hqE8+dDcenSRdy8eR3Hjh3CV19tRfPmLVh14+JiMXfuTGRkpAMo7aM0ceJkSCQS7N//J7KzNc8v4uzsgsDAtZxzv1evPhgxYgyTLrueHT16CHFxjzB37qdwdnZFWloKa32xsY8wadKbaNu2PXr16gN3965o3/516FfRUXfhwiVITU3hXAfLuLq20tjGing8nsa/WUlJCRYvnod//rnE/M3k8kyEhZ1DZORV/PLLHzh+/DB27/6D9Te9ffsWliyZj1Wr1mHgQO9K2/4yoj4NOiIWi+Ht7YP27V+vtEzfvm+gTx9uJPvaa23xySfz4e8/EuvXb4JEUt67/X//+xlFRUWs8tHRkfj++2+YdLNmVti06Vv4+4/AtGnT8c4776KgIL/Sdri4tIK3tw/MzMw1L3d0gM+A/ujRpQsrPy8/H+1fa82kJRIJ3nhjIJ48eYwBAzwxePCQSn9xENJQpFIpVqxYzAQMALB+/SYEBLyJgIA38cUXXyI1lf1l5+zsCm9vH5ibW2DIkKEIDb2ESZOmsspERV1DZORVbN36I8LCrmDnzj9hbl4++++NG9FYvXolEzD06tUHc+YswPDhoxAY+AVT7ty5kP/eZiqXlZWFBQtmMwGDqakpvvhiI/z8hmHt2o2wtLQEADx+HIflyxexvhjlcjmWL/+UCRgAYPHilZg48R2MHDkGX3/9HXJzNXfzNje3gLe3D8aMGc/Kj419hF69+jBpsViM/v098fhxHAYP9oO3tw9cXVuhQ4eOGu983L9/Dzt2bMesWdPh6zsQs2ZNx759f2qc1rlfvwEar4NlLCwsq7w+AaV3RUJDL2HRouWs/Nu3b0KpVOLQoZM4fToMnp6DmGV5eXmYN+9jhIaGYPv23xAaegmzZ89jlqtUKvz00/eVbvNlRUFDEzRokA/zb5FIBHv78rcYZLJc3L//L6v8b7/9yvrV06NHL1Zk7+3tg/rg6zWQlQ65EI7i4mJW3sWL55GTk42hQ0fUyzYJqakjRw5AKs1i0ra2LeHqWh68tm7dBo6OTjVeb1paKhYuXAJ3967g8/lo1ao1Bg3yYTr3fffdFtaXebduPZl/t2rVmvWld/DgXtaX/J9//o709OdMulOnLtDXNwAA6OnpoVOn8oD933/v4uLF80w6NPQM4uOfMmmRSISePXszaUvLZujSpfyOoCY+Pn4wrDDfclpaKsLDw1hlLl4Mg1SaBX//8nPbxMQUb775dpXrlsvluH49Clu3bsL48SMQEXGxyvL1SSAQYNmyQFhbN4dEIsHIkWNYy5OTkzBjxido164D9PT0MHr0OFZnzcTE+FeuDwYFDU1Qy5b2rLRYLGalnz8vP4gLCgpw40a0Wn07VtrCwpJ1QaitXh7uMDMxYdLZubkIvxrJKnPy5DHY2LSs9iJFSEO5dCmclVY/HwCwAnFtWVo2Q+/e/Vh5s2fPx969R5CSksx5nVD9EYK1tTXzb4VCgQsXzjPpc+fOal0XAEJDQ5h/X74crla2BYRC9pPp6vZXIpFgyJChrLxDh9j9mI4fP4x27TqwAjAA+OCDGZg1ay6MjIyr3AYAZGdnY9myhZzxaxpKy5Z2aNbMiklbWjbjlHFzKw/IhEIhTE3NWMvT0tIarH0vIgoamiD1IEGdXF7+TntiYgLnuauxsYl6FRgaGtW5XUKhEN5v9GXlBZ8tHzAmLS0VkZFX4efnT1OpE52p+KsbqOx8qHkQ7eTkDD5f8yU1NvYRJ6+kRAmpVMr8JxSy+zA8eFB6xzA/P595LFGGz+ex6gI8jXUBTfvL/fLWZn9HjRrLSkdFXcPjx3EASn+RR0ZexbBhIzXWHT/+LRw+HIyVK9dg8GDfKkd8VCgU2LXrt2rbUx8qPj4CwOlHok0ZuZz9OPhlRx0hm6CafOHm53P7Kmh6F7qyi11N+XoOxIET5aO5Rd68ibS0VFhYWCE4+DhUKhV8ff3rZVuE1IZ6/x3N50PNxwvQ9Cu1TF4e91n9ihWLq1xfZmZmpXX37fsT+/b9WW1dgHsNEAprd/47OTnDw6MboqKuMXmHD+/HvHmLcPz4ERgYGMDbe3Cl9cViMQYPHoLBg4cAKA80QkPPMKNBlrl583q17WkImq6t6nmv+g8eChpecpomv1K/8wCA01u8tlo5O6GVsxMePX7y33pVOHHiON55ZwpOnToBD49uaNHCpl62RUhtiMUSyGTlHf80nw/cvOpUNTBRxc7KZT788GO0adOu0jomJqYANN8F8Pb2wdCh3FcIy1T8YlO/BlR8w6mMtuf/6NFjWUHDX38F4/33ZyA4+DgGDvTm7GdxcTFu3IiGvb0jWrRgP1KxsbHFsGEjMWzYSJw/fxbLly9ilmVnS7VqD2l8FDS85Ozs7CEQCFgXxtzcHE45Tb9masvXcyC+/XUHkw4OPobXX++EZ88SMW2a5ne+CWksDg6OuHfvDpPWfD7kcfLqQn28AqD0eXq3bj2qrSuRGMLaujmrw52JiYlWdYHS/Y2JecikNb0poe3+9u3bnzWcfH5+HlatWo709OcaH03k5GRj7tyZ8PIahM8/X1fpesteZy173KH+yEhPj/sGhlKpZAVqFd+GIQ2H+jS85MRiMdzc2FNYJyYmsNJZWZn1epEc9EY/6FXoaJWYmIjNmzfCyMgI/fsPrKImIQ2vd292vxv186GyvLqws7NnBgoqExeneUTVTZs2wNOzN86dK+/M2K9ff63qnj37Nzw9e2PLli+ZvF692PubmprMGqURKH0LQBsCgQAjRrAHg7p8OQJOTs7o2LFzpfUuXQqv9i2Diq+Kq6/LzMyM8+pmxWtWSUkJkpKeVdt+UncUNLwCJk+exrpdeeXKJRQVlQ/mFBLyd71uz9TEmDWoEwA8eRIHb2+fKgdxIaQ2BHwehEK+Vv8J+DyMHBkAMzMzpn5ychKrt35MzMNKBwmqiw8/nMU6D//66yRycth3OZ4+fYLTp4NhYWHJGpvgrbcmM48rgNLxBe7fZ7+NUVhYiD/+2AmlUonhw8tHXvX0HAQHB0cmXVxczHqtMTMzA9HRUVrvx7BhIzlvX1T3CnVBQQEWLZrL3KFQd+HCeeZLXyAQYNIk9gRrQqEQnTuzx4EpuysBlAYlmsZ4IPWPHk/oSEFBASIiLrBukwKAVJqFkJDTsLFpiaysTKSkJHHqli23tbVFVNQ11jvnAHDv3h2IRCJ4eHSDubkF3N27YsaMT5gRITMyMjB//mz4+vojNTUFhw8fgFgsYXUQi46ORGZmBry9fRAX9whxcbHc7TyMgUhPBPeOr8PczJS1bIjnAFz4h925qapnsITUFo/PQ1riE63KWts5wczMDKtWrcfixfOZW9pLly7EhAml4wns2RMECwtLjUMXA6V35krfHGD/2k9OTkJIyGkYGIg1Di/cu3dfzJu3CN988xUUCgWSk5Mwbdo78PPzh5WVNZ4+fYJjxw5BJNLD6tXrWb+sra2bY8OGzVi27FNkZmZAqVRi1qzpGDFiDJycnJGZmYGTJ48hJSUZCxYsYQ2aJhKJsGbNRsydOwMZGaX7tHHjGjx7lgBDQyMcOrQPxsbGyMgo/6Vfti/t278OW1v2xHSWls3Qv78nzp4t/bEhFAo5r2OW4fMFzOPRmJiHGD9+JAYO9IKzsyssLZshO1uKW7duMmM+GBkZYcmSlWjbtj1nXdOmTcf161HMXZKNG9dg7Ng3IZPJ8Pffp2BnZ8+6Q1R2HSwLvqq63np4dENSUhL+/Ze9HCi93rq4uMLAQIx79+6gsLCAtbzitfJVwFNpGuu0hu7evQdbW8cqy5ibGzb5qbGfP6+fybGFQj4SEhI1joVextfXH9evR2mce6Jsua+vf6XjwgOl4+S7u3dl0jdvXseePey5Jzp3dsOUKR9g8eJ5GrcVHh5Z6dwTZbasDkSX1zuw8hRKJca+Nx2Z0tLhaZ2dXfDHH/sqXUdDEAr5iM2s/rarq4UDFIr66QhaE0IhH7JH2k36ZdTKtdZttLIybvJTY1d17gmF/BoFDWWfY1LSs//mnvgHGRnpEIlEaNXqNYwbNxHh4WGsuSfef/8jTJ48DUDV8zEA4Mw1oS4hIR4HD+7D9euRSE5ORlFRIcRiCeztHdCjRy+MGTOO85pfmZycbBw/fhjh4Rfw9OlT5OXJIBKJ0Ly5DTp3dsOoUWPRqlVrjXWzsrIQFPQbIiIuIDW1dO4JR0dnjBgxGmlpqRrP8YrzN1R08+YNzJz5HoDSIbbXrNlY6f7KZDJERV3FnTu3ERPzAElJzyCVSlFUVAiBQAgTExM4O7ugW7ee8PX1h7l55SM73rx5A//738+4d+8OlEoFLC2boUePXnj33fcRGLiUMyYNAOzffwwAqrzebt36I06dOqFxvhGgdI4cGxtbjXOOlCmbC0PX0tISYG1tX31BlL66a2lZs9ftGy1oEEv0YaDfdG9sFBYpkJtTUH1BLQiFfJ18SdWnmsxyqW9T+y+8uqCgoZSpiQiiJvxYSF5UhOwceaXLaxs0VGXlyiUIDT3DpBcvXsEa6VCXXpTrx+TJExAbG4OvvtrKGmGS6FZDBw2N9i1ekF+EgvwXfxCMF+FkJKQ+lX7hyiEU8pGUoHliInW29qZQKEpqVacpWL16JRwdnTjzR5Sp2DGQz+eja1ft3lR4WT1/ngahUMi6A2Jvb4/c3Bx0796ziprkZUMdIQkhr5yHD+9j794gzsRUAHDnzi08fPiASY8aFcAZY+BV8/nny7F69UomHR//BBcvhmH48FH1NjAcaRqa7vMCQgipg+zsbLz33iT4+Q2Dg4MjVCoVYmIeIDi4vD/C8OGjMGvWvCrW8uqIirqG7dt/gJWVFdNZdNy4CbpuFmlkFDQQQl45c+YsRGTkVdy7dwfnzoUgJycbBQUFTIfEjh07w9d3GNq2rXzExlfJG28MRH5+Pvbv3wMA6NDhdXzyyQKNI12SlxsFDYSQV46HRzd4eHTTdTOajHHjJtBdBQKA+jQQQgghREsUNBBCCCFEKxQ0EEIIIUQrFDQQQgghRCsUNBBCCCFEKxQ0EEIIIUQrFDQQQgghRCsUNBBCCCFEKxQ0EEIIIUQrFDQQQgghRCsUNBBCCCFEKzT3BNG5iIiLWLRoLiff19cfy5YFNn6DyCvr4MG9+PrrLzn5U6a8j2nTpuugRU3bkSMH8MsvP8HIyBjLln2Gjh0767pJpI4oaCA616ZNWwQGrsX582dx/nxog2+vqLAIh//ch+DDR6FUKJj88PDIBt82ebF1794LgYFrceTIQdy4Ea3r5jRp8fFPsXnzRpSUlEAqzcJnny3FwYMnwOPx6rzutWsDcerUCa3KGhgYwMzMHK1bv4YBA7zg7e0DgUBQ5za8qhotaDAxFEIg0m+szdU7hbwIWdlyXTfjpdSsmRW8vX3w9OmTBg8aov65it9/3I70tOcNup0XibmpGEJR6alubl7zqYxrU6c+KeVK5OQVsvJUJSooS1T1vi17ewfY2zvgypXLFDTU0aNHMSgpKWHSaWmpyM7OhpmZWZ3XPXJkAHr06IUbN6Jx5MhB1rI5cxbAzMwc+fn5iI2Nwd9//4WUlGSkpCTj4sUwHDq0H19++Q1MTEzq3I6K1AOZl/XuVKMFDQKRPuLWjmmszdU7l2UHAVDQ0FQVFhbiu42bEf3PVTS3tUEnD3fcino1vhSEIiFivgrXdTNqrfWCvkh78ISVZ23nBDRA0EDqj6trK/D5fCZwsLZuDlNT03pZd4cOr6NDh9chl8s5QUOfPm/AxsaWSY8f/xamTn0LMpkMAHD37m1s2/Y1li79rF7a8qqhjpDklZCbnY07128g4O0J2PDDVrRq01rXTSLkpebo6IQ5cxbCzMwcdnb2+OyzNfXyaKKmbG1bYujQ4ay80NAzUFR4NEm0R30ayCvByNgEG3/8FlbNm+u6KYS8MkaPHovRo8fquhmwtbVjpQsLCyGVStGsWTMdtajpapSgQaWi24iVSU5Owq5dO3H16hWkp6dBX18frVu3wcSJkxAaekZjZ5+tW39ESkoyvvjic84yX19/LFmyEvv3/4mTJ48hMTERcnkRWrSwwYEDx5lyqakpOHhwHyIjryAp6RkKCwthamqGdu3aw89vON54Y0ClbS4oKMDJk0dwPuQvPI6PR15+PgzFEjja26F/r54Y7jMIIj09jXWzsrKwe/fviIi4gJSUFAgEAjg5OWH48NGVbi86OhKzZ3+ocVnF/UpOTsLYsexfFCPGj8W4yW9BLBFDLBFXug3y6tF07rVq9RrGjZtYaZ3g4OMazzsAcHNzx7ZtPwPQfMwuWrQcGzas4dTz9fXHu+++h99++xWRkVeRlZUJAwMx3Ny64IMPZsLZ2YVTJy4uFuHhYYiOjkRKSgqysjJQVFQEQ0ND2Nk5wN29K0aOHIPmzVuw6lV2Lvn6+mPevEXYseNnnDt3FhkZ6TA2NkH37j3x3nsfonnzFlCpVDh69CCOHj2EhIR4CAQCtGvXAVOnfoBOndxY6/v44w809gnZv/8Y69FBmfT0dBw+vB9Xr/6DxMQEFBTkw8zMHBYWlmjVqjW6d++Jbt16wNTUjFNXG8+fp7HSQqEQxsZGGsvW9Nr4668/YceO7Zz17NixncmveJ1SqVS4eDEMUVFXcffuHWRmZkAqzQKPx4OpqRlatWqN/v094ePjB6Hwxftd3ygtUiqVjbGZJuf69SgsWjQP+fl5AAAbm5YYP34CAGDz5g2sTkQAMGCAJwYM8IKzswvS0lIhEomgVCo5n+/atYE4fToYPB5PY8AWEnIa69evRmFhaeeygIA34eLiin37diM8/ALCwy9g4EBvrFy5GnpqX/6PHsVgyZL5SE5OAgB07+IGz769EXb5Ci5HRuHWvX9x4u8QbFy5FNZqUXxcXCzmzp2JjIx0AICZmRkmTpwMiUSC/fv/RHZ2tsbPydnZBYGBa7Fz5y948uQxk9+rVx+MGFHeT8bMzByBgWtx9OghxMU9woIFiyG0oECBcFV17m3dugnFxcUa67m5uSMwcC22bPkSUqmUyff19ceQIUOZdNkx+9tvv6KkpARTprwPW9uWGt8Sio19hKVLF2Do0BFo3boN/vhjBzIzM3DxYhiuX4/Gzp270aKFDasdv/32C86ePQMrK2sMHz4KzZu3QEZGOk6cOIq7d2/j7t3bOHBgD1atWo9evfow9fh8vsbrRkFBAWbOfA8PHz5g8jIy0nHq1AlERl7Fzp27sXnzBpw9e4Z1XYmMvIqbN6/j229/wuuvd2LqTpnyPrKyMhEYuKzav0VYWCjWrv2c+VtYWzfHhAlvo1kzK8TFxeLw4f0IDj7OCspqIi9PhrNn/2bleXoOgr6+Aadsba6NAwd6wdHRifPGTdn1GgAMDMqvQ3K5HEuXLgAAeHh0h6+vP0QiEWJiHuDEiaO4dCkcly6F4/DhA9i8eVu9d9isq0YJGgSCFy9a0jWpVIoVKxYzJwoArF+/Ca6urQAAnTt3wZQpb7HqODu7wtvbBwAwZMhQDBkylBPlRkVdg1KpxNatP8LNzZ35oi5z40Y0Vq9eyVwwevXqgzlzSg/g9u1fx7vvll44z50LgbV1c8yaVT5+QlZWFhYsmI309NI3D0yNjbFm0QLo6+vDu19fjJs+A5lZUjxOSMDKjZvw3bo1zKtNcrkcy5d/ygQMALB48Ur07fsGAKBfv/4YO3aExs/K3NwC3t4+yM3NxaZN65n82NhHrAuiWCxG//6e2LLlKwwe7IdBg3wQmxlfxV+BvIpqc+6VsbVtCVvblnj48AF27/6dyY+PfwoPj25M2tzcAh4e3bBmzWeYMWM2c962b/865y2hmJgH+O23PXBxcQUAmJqaYdWq5QAAmSwXf/yxAwsXLuW0RV9fHz/88CsroBgzZhzeemssnj9PQ0FBAT7/fBn27TsKE5PSDohubu4IDb3EuW6EhYXCx8cPmzd/Bz6fhyVLFuDmzesASn+lv/feJBgbG2P37gNo3twG27f/gD17dgEAiouL8euvP+Hrr79j1lf2WVQXNNy6dQOffbaU6V9gbGyCn3/+jfXYoE+ffpXeadQkNzcHYrEEeXkyPHx4H0FBvzM/coDSgGHBgiWcerW9Nrq4tIKLSyvOGzcVr9ea9OrVBxs3bmH18/Dw6I5lyxYCAO7fv4dvvvkKK1as0nrfG0OjdITUQd+XF96RIwcglWYxaVvblsxFCwBat24DR0enGq83LS0VCxcugbt7V/D5fLRq1RqDBpW/l/zdd1tYvzC6devJ/LtVq9YwMzNn0gcP7mV9yf/55+9MwAAAHdu3hb5+6Wu0enp66NSuHbPs35hHCL96jUmHhp5BfPxTJi0SidCzZ28mbWnZDF26eFS5bz4+fjA0LH/9Ly0tFeHhYawyFy+GQSrNgr+/5gCEkPo490aNCgCfX375vHv3Nh48uM8qc+pU6ZgEPj5+Va7L1bU1EzAAQKtWrVjLIyOvcuoMHuyHpUsDOXcgJBJD9OxZHkjLZDKEhZ2rcvsAYGJigoULl8DMzAwmJqbw8xvGWp6cnISFC5fCwcEJ+vr6nH4KN29er1XHwm3btrDqeXkN4vQz6NLFA+3addB6nVOnvg1/f2+MHz8SK1Ysxv3798Dj8dCxY2ds2PA1Vq1aB4lEwqlXl2tjTQiFQsyY8QlmzPiE0zH0jTcGQFRhaILQ0DMoKCio1XYaCr09oSOXLrFfgWvZ0o5Txt7eocbrtbRsht69+7HyZs+ej717jyAlJRn//nuPtUz9mae1tTXzb4VCgQsXzjPpc+fOsuuqndxWlhas9LmIS8y/L19m76+1dQvO87rq9lcikbBuAQPAoUP7Wenjxw+jXbsOrC8BQiqqj3PPxsaW9eUMAIcO7WOljx8/gn79BlT7HN7Ojr19sZj9hab+PB4o/fXt5TWISRcWFiI7WwqpVMp5Vh8XF1vl9gGgbdsOrNv1lpbsc1tfX5/1xa2+XC6XIztbWu12KkpJScG9e3dYeW3atNNY9qOPZuHNNzXf/VG3cuVqfP31d1i/fhNmzPgEr73WFiqVCrdv38SiRXMxefIE/PPPJVadul4ba0IgEGDixHeYviolJSXIy5NBKpVyxrEoLi5GYuKLdbeUnhvUgFBYfzFWQsJTVtrExISzfiMj9snP5/M4Zfh8dqTq7OwMkUjzn/XJE+7Fg8dTQSYr70ug3ofh4cP7EAr5yM/PZ93iK902H9KcnArrYrflYWwc8++EBPaBr2l/1S92PB53fwMCxuHgwfKLc1TUNSQkPIGzswuSkpIQGXkVixYtq9Xfqj7/vg3hRW9fY6vt51Ff597YseNw6dJFJh0S8jdmz54LU1NTREdHISEhvrRfTTXnrEQiYZURCNjl5XI5Zx08ngonTx7HX38F48GD+8jLk1W6v/n5smrbYGlpwSojFrMH4jM3N1drI7c/gFKpqPZvIhDwmTJPnjziLLeyaqZxHd26dePkAdz9AAA3ty6wtS3vbPnOO5OwceM6HD58AAAQGxuDhQs/wWefrcaQIX7/taX218by8uy2aDpmyjx//hx//rkLly6FIyEhAUpl5XdpCgrya3ysW1kZ16h8TVDQUAMKRUn1hbRQ9iVcEZ8v4Kyfx2MfKCUlKk6ZErUBbiwsmlXazpycXE7e0qWfVtnWjIwMKBQlyM7O4Szbf/wk9h8/WWndTGn5CZeXl8daJhDwNbSTfdKpVNz9tbd3godHN0RFlT/62L9/L+bNW4QjRw7BwMAAnp6DoFCU1PhEq6+/r7Ze9Pa96Mo+j5p+jvV17nXt2hN2dvZITEwAABQVFeLo0SOYOPEdHDlyCC1a2KBLl67VnrMqFftvq1Ry/84VlwsEPCxcOJd1x6R7914YOnQ4TExM8NdfJ3H6dHCVba++DeodqHnVHn9KZUmNymi6HvH5whod5+r7UVk7Zsz4BKdOnWA6OKpUKmzatBH9+3tBT0+vTtfGMuqdzjV97gDw+HEcZs36gOlIq6enh7femoqOHTtBKNTD6tUrkZmZwZRXKJQ1PvefP+fujyZ8Pg+WlprfIqlMowQNCgW9PaFOLJZAJiv/w2p6w6SkpOafW1Vjqksk3OGAP/zw40pvCQJgOlBV7EtQxqtfH/h5eVZat2Lkrf4MUdMxof62SGVGjx7LChr++isY778/A8HBxzFwoLfG/SSkTH2dezweDyNHjsG2bVuYvCNHDmDo0GE4fz4U77zzLqvfQ305d+4sK2BwcnLBl19uYc79W7du1Ps2G4KhIffLqrK3VupKLBbD2dmF9QgiNzcHsbGP0LZtuzpdG2vqhx+2st68mTp1Ot55510mLRKJarXextIoQUNWViasrF6s10Z0zcHBkfU8LzeX+0te/dd5XTk5OXPyWra0Q7duPaqtK5EYwtq6OdLSUpk8EyMjdO3cqYpa5RwcHBET85BJ5+ZyI2Ft97dv3/6wsrJmnvXm5+dh1arlSE9/jmHDRmq1DvLqqs9zz89vOLZv/wFFRUUAgKSkZ1iz5jMoFMWczoT15fp19vgHXbt2b5ITMLm6ckdlraxz4ePHcSgqKoSra2vOYwJtaRouqOyHTV2ujTV148Z1VrpHj56VlHwxNcpDUvXbgQTo3bsvK112i7O6vLqws7Nn9dIGKu8ktWnTBnh69sa5cyFMXr9+/dl1n2ruoBMaHoFB4ybim1/+x+T16sXe39TUZE5va207/AgEAowYwR4M6vLlCDg5OdPUu6Ra9XnumZiYcF6ru3w5At269eR0pKsvCgX717j6l2hV/RteJC1atED79q+z8u7fv8cpp1QqMX36FMyZM6PWw1Dn5+fj8WP2tU5fX5/p8FrXayOAKgdiOnLkAE6cOAKA+/cTCtl/v7I5Ml5UjRI00ICQXCNHBrB6ySYnJ+Hhw/JXtmJiHrIGMqovH344i3Xi/fXXSeTksH9pPX36BKdPB8PCwhJ9+rzB5L/11mTWLbk79x/g/iP2iVVYVISgg4ehVCoxbJA3k+/pOQgODo5Muri4GBER5Z3IMjMzEB0dpfV+DBs2knOSDh1Kr1mS6tX3uTd69DhO3rBhDXcsqn+5/fvvXebfSqUSV6/+02Dbrm+zZs1lncehoSGcuw1HjhxEfn4ehg8fXasREkvHrdnE3A0qM3JkAOuxaV2ujUDpbL0Vld3BKioqxNatm3Hs2BEApeM3VFQxULp9+ybr0dmLqFEeTxgYNN0psRuKmZkZVq1aj8WL5zODzCxduhATJrwNANizJwgWFpasDjEVZWVlIirqGid6Tk5OQkjIaRgYiJmBkyrq3bsv5s1bhG+++QoKhQLJyUmYNu0d+Pn5w8rKGk+fPsGxY4cgEulh9er1rOdr1tbNsWHDZixb9ikyMzOgLCnBnBWfYbjPYDja2SFTKsWps6FISXuOeR9+ABfH8tfWRCIR1qzZiLlzZyAjo3SfNm5cg2fPEmBoaIRDh/bB2NgYGRnlJ3bZvrRv/zpsbVuy9sPSshn69/dkRnoTCoWc1zHV3b1xCzn/jTqZoOEuSUjIaebfHh7dYG5uwSlDmj5tzj1LS0vmOAWAx49jERJyWuNx0aZNW3To0BF3797+b/3m6NuXfVcOqP6c9fDohqSkJPz77x1O3Yrn9JAhQ/H77zuZx3M3bkRjw4a1aNeuPc6dC+F0yKt4HonF4irb0KfPG7h37w6uX2cH8IWFBcw6CgsLNP4Kj4i4gBYtbNG37xuIirqGrKxMjWXMzMyZuzMdO3bG6tXrsXZtIGQyGWSyXHz44VSMGhUAExMT3Lp1E3/9dRKvv94JU6d+wKzn7t07SE5+xnlls+I2ioqK8OxZIsLCQvH06RNmOY/Hw4gRo/HRR7NY9epybQRKx1goGwEUKO174uLSClev/gO5XM7cqX3rrclYuXIxU++777YgJycbJSUqhISchqGhIevxWHR0JDIzM6ocKKox8VT1MDHE3bv3YGvrWOlyuVyO5s3Nm/zU2Nr2SK2OUFj+5kBS0rP/xr//BxkZ6RCJRMz49+HhYay5J95//yNMnjwNQNXzMQDgzDWhLiEhHgcP7sP165FITk5GUVEhxGIJ7O0d0KNHL4wZM67SL82cnGwcP34YF8+dQXziM+Tl50Mk0kNzKyt0atcOI3194OpUfjzo27gy+5uVlYWgoN8QEXEBqamlc084OjpjxIjRSEtL1TiG+9Kln2l8Pnzz5g3MnPkegNIhW9es2chaLhTyWSNCrlm0DP/evgttbN36I9zdu2pVtraEQj5kj6p/hx4AjFq51vrtCSsr4yY/NfYDtb+btZ0T6+2JtMQnWq2rYr3Kzr3x49/CxYvnK533RdNxcfp0MFavXgkAePPNt/Hxx3M4Zao7Z7du/RGnTp3QuF2g/JwWCvlISEjEjz9+i8jIq5DJZDAzM0enTm5488238c8/EZWeRy1a2FTZhv37j2Ht2kCN80aUrSM5OUnj+iu2sbK5J8qEh0ey0llZmThy5CCuXr2Mp0+fIi9PBn19Azg7u8DLaxBGjRrLegyzdm1gpZ9TRQKBACKR/n8zbdqhY8fO8PIaXOXgXXW5Nl68eB779v2J2NhHyMuTQSAQwta2Jby9B+Odd6YwfU/Onz+LoKDfEBsbCx6vdBjzfv36Y8KEtzF16ttISUmu9jOrTFpaAqyt7bUqW5u3JxolaAAAY4kAQg1jfTcVCnkRsrLl9bKuikFDVVauXILQ0DNMevHiFS/MSIdCIR9Fydp94VUMGurb5MkTEBsbg6++2soaYRLgBg2VcbVw0MnrjI0VNJibiiGsZOyOpqC4UI64mBhWXn0EDfVJLpdj9OihkEqzsGvXfo0d6+qLttcP8mpq6KCh0a4kuflKKHNzIZVmITdXhqKiQigUSqhUKvD5fOjp6UEsFsPU1LTS2ccAoKhIjszMDMhkMhQXF0OlKr01LZFIYG5uDiOjur1u15gn4+rVK+Ho6IRJk6ZqXF6xYyCfz0fXrvXfk7cpef48DUKhkBXl29vbIzc3B927N60eyI0pK7t0GFqhkI+kBM2TgqmztTdlxrqoaZ26qEkAoEspKcmQSCRMHx+RSITmzVvA3t6+QQMGQnStUX9+CAR8WFpawtLSstbr0NcXwcbGpvqCTcDDh/fxzz8R8PHx4/S0vnPnFmvGuVGjAtCiRcP0xm4qPv98OUQiETZv3gYAiI9/gosXwzBlyvsN8j48IZX5+OMP0L17T3z6aemETJGRV/Hgwb8v3ORChNS3pnvP8iWRnZ2N996bBD+/YXBwcIRKpUJMzAMEB5f3Rxg+fBRmzZqnw1a+OKKirmH79h9gZWXFdBYdN26CrptFXkFnzvyFli3toKcnwq5dO9G69WsvTGc1QhoKBQ06NGfOQkRGXsW9e3dw7lwIcnKyUVBQwHS66dixM3x9h6Ft28pHJXuVvPHGQOTn52P//j0AgA4dXscnnyygESBJoxs0aAjCw8OwY8d26OmJ4O7ugblzP22SgywRUhMUNOiQh0c3Zt55Ur1x4ybQXQXyQpg+fSamT5+p62YQ0ujoQTAhhBBCtEJ3GgipBwI+DzwN0/RqoipRQalhdj5CCHnRUdBASD3g8Xk1GnMBFDQQQpogejxBCCGEEK1Q0EAIIYQQrVDQQAghhBCtUNBACCGEEK1Q0EAIIYQQrVDQQAghhBCtUNBACCGEEK1Q0EAIIYQQrVDQQHQuIuIi+vbtyvlv7dpAXTeNvMTS09Mxe/aH8PHpjw0b1kCpVNbr+p8+fYJp097BkCEDsX37D/W6bkJ0hUaEJDrXpk1bBAauxfnzZ3H+fGi9r7+osAi3o68j5v4DxD6MgTQjE7k5uSjIz4e+gT5sbVqiffvXMWTIUHTq5Fbv2ycvph9++AbR0ZEAgOPHj6BDh9fh7z+y3ta/YcMaPHjwLwDgt99+RZcuHujatXu9rZ8QXWi0oEFipAd9PVFjba7eFRbLkSst0nUzXkrNmlnB29sHT58+aZCgIf7JE3y9Zj0AwNDICN5Dh6C5rQ2ep6bhzIlgPHoUg0ePYnDs2GF4eQ3C0qWfQV/foN7boSumpgYQifQAAObmNZ9GvDZ16sLcvAMrXVhYiKcx2g3RXRMPHjxgpR8+fFBJydp5+PA+Z/0NFTT07duVld6//xhsbGwbZFvk1dZoQYO+ngjj9n7UWJurd/vG/4BcUNDQlEkMJVj77WZYNbdm8vp6DsCSGZ9ALpcDAM6ePQOlsgRr1mzQVTPrnUikh02bNum6GbU2f/78Bllvq1at8eRJHJNu3bpNPa//Ndy5c6vC+l+r1/UTogvUp4G8MnxGDGMFDADQwtYGQ4cOY+WdP38Wjx7FNGbTiA58/PEcdOniAYnEEEOHDoevr3+9rn/RouV47bU2MDIyxjvvTEG3bj3qdf2E6AL1aSAvPSMjI3j07I6uvTRftDt06IjDhw+y8m7ejEarVq0bo3lER5o1s8K33/7UYOt3dnbB//4X1GDrJ0QXKGjQseTkJOzatRNXr15Benoa9PX10bp1G0ycOAmhoWdw6tQJTp2tW39ESkoyvvjic84yX19/LFmyEvv3/4mTJ48hMTERcnkRWrSwwYEDx5lyqakpOHhwHyIjryAp6RkKCwthamqGdu3aw89vON54Y0ClbS4oKMDJk0dwPuQvPI6PR15+PgzFEjja26F/r54Y7jMIIj09jXWzsrKwe/fviIi4gJSUFAgEAjg5OWH48NGVbi86OhKzZ3+ocVnF/UpOTsLYscNZy0eMH4txk9/CvJVLK12/lZUVJy8/P7/S8qRpS0xMwJtvjuLku7m5Y9u2n1l5hYWFCA4+jvDwMDx6FIOcnGyIRPqwtrZGx45uGDFiFNq2bc+qExx8XOO5OWXK+5g2bToAzcdqWRs+//wL/P77//DPP5fw/PlzCIVCtG/fAdOmTUfHjp1Z5QMChiElJZmznorrrrhdQuqKggYdun49CosWzUN+fh4AwMamJcaPnwAA2Lx5A0pKSljlBwzwxIABXnB2dkFaWipEIhGUSiXnVbG1awNx+nQweDweVCoVZ7shIaexfv1qFBYWAgACAt6Ei4sr9u3bjfDwCwgPv4CBA72xcuVq6Kl9+T96FIMlS+YjOTkJANC9ixs8+/ZG2OUruBwZhVv3/sWJv0OwceVSWDdrxqobFxeLuXNnIiMjHQBgZmaGiRMnQyKRYP/+P5Gdna3xc3J2dkFg4Frs3PkLnjx5zOT36tUHI0aMYdJmZuYIDFyLo0cPIS7uERYsWAyhhbiST7+cpgCBOpG9vCwsLBEYuBY3bkTjyJGDlZa7f/9frFixiDnW3dzcMWTIUKSnP0dQ0G948uQwjh8/jDFjxmH27PkQCARMucDAtThy5CBu3IjWuO6yY1W9Denp6Zg3bxYGDfLBm2++jX37diMhIR6RkVdx8+Z1fPfddnTq1IkpP2fOQhQWFiAwcBlr/XPmLICZmTkAwMXFtXYfFCEaUNCgI1KpFCtWLGYCBgBYv34TXF1bAQA6d+6CKVPeYtVxdnaFt7cPAGDIkKEYMmQofv31J+zYsZ0pExV1DUqlElu3/gg3N3fmi7rMjRvRWL16JRNo9OrVB3PmLAAAtG//Ot59tzRoOXcuBNbWzTFr1lymblZWFhYsmI309OcAAFNjY6xZtAD6+vrw7tcX46bPQGaWFI8TErBy4yZ8t24NcyGVy+VYvvxTJmAAgMWLV6Jv3zcAAP369cfYsSM0flbm5hbw9vZBbm4uNm1az+THxj5Cr159mLRYLEb//p7YsuUrDB7sh0GDfBCbGV/FX6GUeq95Q0ND1nrJy0UikcDb2wdyubzSoCElJRnz53/MBLKWls2wadNW5q0aY2MTfP31RgDAwYP7IBQKMWvWPACArW1L2Nq2xJUrlysNGsRiscY2JCbG48svv2GOv1atWuOjj6YBAIqLi/HLLz9h69bvmPJl54960NCnzxsU+JIGQR0hdeTIkQOQSrOYtK1tSyZgAEp7cjs6OtV4vWlpqVi4cAnc3buCz+ejVavWGDTIh/ny/u67Law7E9269WT+3apVa+bXCQAcPLiX9SX/55+/MwEDAHRs3xb6+voAAD09PXRq145Z9m/MI4RfvcakQ0PPID7+KZMWiUTo2bM3k7a0bIYuXTyq3DcfHz8YGpa//peWlorw8DBWmYsXwyCVZsHfX3MAoq5EqcSZM6dZeR9/PBeGhkZa1Scvp+3bf2Dd+erRoxfrNVz1x3f79+9h3QWrLWNjE9Z54erK7ldz40Y0FApFnbdDSG1R0KAjly6Fs9ItW9pxytjbO9R4vZaWzdC7dz9W3uzZ87F37xGkpCTj33/vsZbZ2LSAUMhn/rO2bs4sUygUCA8PY5adO3eWVbe52uMHK0sLVvpcxCXm35cvs/fX2roFhEL2ja7K9pcv4EEo5MPExIjTw/3w4f2s9h8/cRjt2nVgBWBVOXXkOBITE5j09OkzMWzYSK3qkpeTXC5HWBh7vBA7O3tW2srKGiKRPpMuKSlBaOiZOm/b1rYleDwek5ZIJGptK0J2trTa9QgEfNZ5Udl/AgGv2nURUhE9ntCRir+6gdJfGOoq/qrWlpOTM/h8zbFgbOwjTp5KpULqg+tMWgh2/4h716/Av7c78gsKmGe7Zfh8PqQ5OUy64sUOAB7Glr8Dz91fY05bKttfPo/HPGbo7t0XBw7sZZZFRl5D2I0I2DnY43lqKiKvXcXChZV3eqwo6p+r2LvzDwCAWCzBkiUr4enprVVd8vJKTExg+vuU0XR+GhsbISOjfOyW+nhNVyyuvg9OUZG82jLPn6eDzxdUW65Fi+YAuP2eCKkMBQ06UlDA7nxX9vigIm1OenWWls0qXZaXJ+PkLV36aZXry5SW3qLN09BZcP/xk9h//GS1dQFuZ0OhUNP+Vn/jq6WDPTp07oi7N28zeSEnTuHdGR/g3F8hMDAwgLf34GrXE3bmLH799gcolUp06uSGZcsCNd7tIa8emSyXk6fp/BQI2JdPTfUIedlQ0KAjYrGEdZHRNFlOSUnNJ9DRdHErI5Fwf8nPmDEbrtamldYxMSp9tm+odpsUALz69YGfl2eldau6zapQaNrfEk6eJoP8/VhBw8Wz5zB20kRcCDkLL69BGveT2W5xMYJ+3Ym/j52ESF+E8e++i4+nfoyKm05LS4WBgRgmJtxfl+TlZ2TEvQum6fxUKtl9CzTVI+RlQ0GDjjg4OOLevTtMOjc3h1MmLy+Pk1cXTk7OnDw7Ozt0bcfNVycRi2Ft3RxpaalMnomREbp27lRFrXIODo6IiXnIpHNzub/KtN1fj57dYW5piayMDABAYUEBvv/ya2RlZGL4cO7792WSEhLx3cbNeBIbh9bt2mL63FmwsWsJPp/PClhGjx4KX19/LFsWqFV7yMvF3t4BYrEYBQUFTJ6m8zM3l33njoaJJq8C6gipI71792WlK3bGqyqvLuzs7DnvbMfGan4O+/VPv2DQuIk4f+kyk6feYzzuqebXGUPDIzBo3ER888v/mLxevdj7m5qazOkFnphY/euRAMAXCODly34EceNaFGzt7dCpU2eNdUJOnsKy2fOQlJiIie+9i5VffgEbu5ZabY+8WvT09DBggBcrT/1cTE9/Drm8vD+DQCCAl9egRmmfJtw7jKX9FNLSUnHkyAFmtk1C6oqCBh0ZOTIAZmZmTDo5OYk1K15MzMN6eYVL3YcfzmI9NggOPolcGfsX09PEZ/g77AIszMzQu1v57HmTJr0LE5PyRxl37j/A/Ufs2QcLi4oQdPAwlEolhg0q71To6TkIDg6OTLq4uBgREReZdGZmBqKjo7Tej4FDBkOg9vbFAB/NnRgvh13Eju9+grxIDnmRHLt/2Yl3/EfjLb+ReMtvJHr2dEffvl2Z/wiZNu1D1uvHV65cRlFReZBw4cJ5Vvlx4ybCwcGpkVrHZWXFnlNF9t85fevWDezc+SseP47TVI2QGqPHEzpiZmaGVavWY/Hi+cwAT0uXLsSECW8DAPbsCYKFhSUyMzM01s/KykRU1DU8fsz+0k5OTkJIyGkYGIiZgV8q6t27L+bNW4RvvvkKCoUCyclJeH/BIgwZOABWlpaIT0zE8TMh0NMTInDhPNZw0NbWzbFhw2YsW/YpMjMzoCwpwZwVn2G4z2A42tkhUyrFqbOhSEl7jnkffgAXx/JXKEUiEdas2Yi5c2cg47/HChs3rsGzZwkwNDTCoUP7YGxszOqNXrYvnTp1AtRmqjazMEf3Pr1wOaw08BAIhejnNVDjZ1U2gyUh2mrRogU2b/4Wy5YtQnLyM2RkpGP+/Fnw9fXH8+dpCAr6jSkbEPAmPvpoFpNOSnqGe/fucN42evw4FiEhp9G+/eswN7dARMQF1iNKAJBKs5gyhYUFiIvjTgkeHn4BJiamzEBvANC/vyf27i2f52Lv3t3w8OiKAwf2QigUoksXCoZJ/aCgQYfc3bti587d/8098Q8yMtLx88/fo1Wr1/Dxx3MRHh7Gmnui4rgGjx/HcUaBA0oHf7lxIxotWthoDBoAYNSoAHTt2h0HD+7D9euRSE56ht/3HYBYLIa9rQ3GDPXDaD9fmJtxO0h27NgZu3btw/Hjh3Hx3BnEJz7DgeMnIRLpobmVFTw6dcJIXx+4Ojly6rq4uGLnzj0ICvoNEREXkJqagh07tsPR0RkBAW8iLS2VNbpl2b4sXx6Idr3dOOsb5O/LBA3uPbrBxLTyDp2E1NRrr7XFH3/sRXDwcVy8eB6PHsXgyy+/gJ6eCNbWzdGpUxeMGDEabdu2Y9W7cSNa49wT58+H4vz5UCxd+hm6dPHQeP4+efIYgYHLsHTpZ0hOTmKdD2U2by4dibJi0PDBBzMgEolw8WIYUlKSEBl5Bffu3Yazsys+/ngOmjdvzlkPIbXBU2manKCG7t69B1tb7pdERRIjPejrieq6KZ0pLJYjV1pUfUEtCIV8KBTVvymwcuUS1oAxixev0Hqkw5q0pSiZ+2tGE30bV6bdta1X2zZWNhz0kplzEP/4CT5dtRKdu7rD1cKB1UZthpGuWKcubZQ90u7zMGpV+nnUpk5tmJoaQCTSPIFYU1BYWIinMezPydrOifV3Tkt8otW6KtZTn1hK04RVL6Lqrh9CIR8pKamVLq+oRYvmdT72yYslLS0B1tb21RcEwOfzYGlZs9FvG+1OQ76sGPkobqzN1VpjnkCrV6+Eo6MTJk2aqnF5xY6BfD4fXbtqntr5VZGZngGBUADTCn1BmtvaIE8mQ0d3N52160WXnV0IoBBCIR9JCZonBVNna2/KBDY1rVMXNQkAaiojIwNCiQlMTMwAcB9baTOwEiGvOuoIqUMPH97H3r1BSE1N4Sy7c+cWayKlUaMC0KJFi8Zs3gvn+y8344evtjDppMRniLp8BQOHDNZqYCjyatv0zRasWRPIpJOSnrGWt2//eiO3iJCmh/o06Fh2djbee28S/PyGwcHBESqVCjExDxAcfJwpM3z4KGYGvVfd3Ru3sP/3IJhbWiL48FGYmptjyIhhum4WaSKuXv0Hv/32K8RiCY4dO8zkOzm5YNy4CTpsGSFNAwUNOjRnzkJERl7FvXt3cO5cCHJyslFQUACxWAJ7ewd07NgZvr7DOB2tXlVde/VEQUEB/jpa2jm0VdvXMGn6exBL6LYyqV5XDw+UoPTNgrw8GcRiMdq164B+/fojIOBNzqilhBAuChp0yMOjGzw8uum6GU3GkJHDMGQk3VUgtTN6xEh8OHMOdfwjpA7oQTAhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0Qm9PEEKIlgQCHmuW2KqoVCoolXUepb/RvMz7RuqPToKG4uJiZGZmIS9PBrlcDqVSCT6fD4FAAH19fRgYiGFqagIDAwNO3aIiOTIzMyCT5aG4uBgqlQpCoRCGhhKYm5vD0NBQB3tECHkV8Hg8FKbIqi8IwKCFEYCm88XK4/FqNGdFU9o3Un8aPWhIT89AamoqVKoSCAQCmJubQ1/fACUlSuTmypCbm4vc3FzweDxO0JCZmYnk5GQmULC2tgKfL0BmZiakUimkUinMzc1ha9sSWgbMhBDS4OhXPHlZNGrQ8Pz5c6SmlkayQqEeXF1doKdXPvuepaUlUlJSkZ7+nFNXKpUiKal8fnp7e3vmroKpqQkePHiIkhIlsrKywOPxYGtr28B7Qwgh2nmZ71CQV0ujdYQsLCxEWloak7a2tmIFDGWsrKxgZmYGAwN9Jk+pVCI5OZlJCwQC1mOI0nT5ELCZmZnIz8+v710ghBBCXmmNFjSkp6dDpSqPno2NjTWWEwj4sLOzg4mJCZMnlWZDqVQyaZFIxKknEumz0hkZGXVtMiGEEEIqaJTHEyqVCtnZOUyaz+ez7jIolSXg8/mV9kPIzc1hpQUCAaeMUMjOy83NhUoF6tvQBEREXMSiRXM5+b6+/li2LLDxG0RIE7N8+ac4fz6Uk7969QZ07NhJBy0iL6tGCRoKCgqhUpVPEiMQCJCTk4uMjAzk5+czywwMDGBmZg5LSwtWp6GCggLW+vh8btCgnldSUoKioiLWYw7yYmrTpi0CA9fi/PmzGi989eH61Ug8fhSLx49ikZacAllOLmT/dbg1NTWFnZ0DunXrgWHDRsLCwrJB2kBIQxk3biIGDPDCli1fQiqV6ro55CXWKEFDUVERunV5HQZG7NchHR1baFW/d++u1ZYxNzdEq1b2tWqfNhSFRcjKlTfY+l9lzZpZwdvbB0+fPmmwoGHzqi9QUlICE1NTDBwyGM1tWiAnOxuXzl9A/OMnSE9Px40b0di16zd89tka9O37RoO0QxfMzfQh1Ct9pGduXvNXkmtTpy7MzTuw0vKiAjx+GNeobWhqOnVyAwD8+OM2AFJdNoW85BolaFAqlTAwMkTEiDGNsbkG0efoQQgLFPW2PqGwaQ7GWdt2a1OPz2c/S+LxeLXaXmV1jE1MsObbTbBs1ozJGzpmJL5e+QWioyMBAAUF+fj882U4cuQkTE3NarzturaxvusAgFBPhKi/F9aq7ovAY/CXGvMb8lisLw3Vxvrch6bwOZKasbLS3GewPjRK0FBS8nLMX69Q1M9+CIX8eltXXdX0xC9rd23rVaWkhP2amUqlgkJRUi9tFAgE6DPwDVbAAJT2rxk+fCQTNAClj8OuXr2KgQO9td5mbdrYEJ/hq6Qhj8XKvAjnS31fP3TxOZKG9fx5rlbl+HweLC2NarTuRgka1H9BEtLYdh7dX+ky9TdvAEBfnzsaKSGEvOoaJWgQCmmKi8okJydh166duHr1CtLT06Cvr4/Wrdtg4sRJCA09g1OnTnDqbN36I1JSkvHFF59zlvn6+mPJkpXYv/9PnDx5DImJiZDLi9CihQ0OHDjOlEtNTcHBg/sQGXkVSYnxKJQXwdTYBG1bucLXayD69eheaZsLCgpw8uQRnA/5C4/j45GXnw9DsQSO9nbo36snhvsMgkjDGBwAkJWVhd27f0dExAWkpKRAIBDAyckJw4ePrnR7UVGRmDnzA43Lmllb4Zud2wEAz1NT8ZbfSNbyEePHYtzktypdNwCEh19gpc3NLdCxY+cq65CmKzo6ErNnf8jJd3Nzx7ZtP+PUqRM4eHAfnj59zHTC/uuv8wgLC0V09DXE3H+ArGwpcmU5EOmJYGnRDG1btYWP5xB07cztfxUQMAwpKcmc/L/3h+Dg8QM4e/EsniUnQlmihL2tAya8/TaGDPGvtP03blzH7t27cPv2TeTm5sDY2ASdOnXGlCmazxFC6lOjfJvTrzbNrl+PwqJF85CfnwcAsLFpifHjJwAANm/ewHmsM2CAJwYM8IKzswvS0lIhEomgVCpZY1gAwNq1gTh9Ohg8Ho81NkaZkJDTWL9+NQoLCwEAY4b6wtnBAfuPn0DEtUhEXIvEgN69sHzOLM4AXI8exWDJkvlITi4dnbN7Fzd49u2NsMtXcDkyCrfu/YsTf4dg48qlsFZ7FBAXF4u5c2ciIyMdAGBmZoaJEydDIpFg//4/kZ2drfFzcnZ2wceL5uPQ7r1ISkhk8t26ecDLz4dJG5uaYvXqdTh06ADi4h5hwYLFEFqIOetTFBcjJzsHGc+fI+zMWZz76wyzzMbGFitWrKp0HBHS9PH5/ErPnV9++RE7d/7COXfu3LmFdetWQSAQYPAAH3Ro+zrk8iJE34pG+JWLSHgWjzNhf8PPeygWzvyU9fbXnDkLkZaWgs2bN7K2tWTNYjjZO2GU3yicv3Qe165fReyTR1izJhA5ObkYN24Cp+1//rkL3323hUm7ubljyJChSE1Nwdy5M5lzmpCG0ihBg6aJp151UqkUK1YsZgIGAFi/fhNcXVsBADp37oIpU9i/kJ2dXeHtXfolOWTIUAwZMhS//voTduzYzpSJiroGpVKJrVt/hJubO/NFXebGjWisXr2SuVj27t0Xs9+bCgBo/1prTJ27AABw/tJlWDezxMwpk5m6WVlZWLBgNjPMt6mxMdYsWgB9fX149+uLcdNnIDNLiscJCVi5cRO+W7eGGVNDLpdj+fJPmYABABYvXsm8pdCvX3+MHTtC42dlYWGBXv37IU8mw47vfmLy4x8/gVtXDyZtYGCAAQM8sWnTRgwe7IdBg3wQmxnPWd+Na1H4es16Vp6+vj7GjBmPqVM/oOP1Jefm5o7Q0EsIDj7OuluXkBCPR49isGbNBvTrNwCpqSn49NM5ePLkMVPmww9nYuygACY9eugYfPvLNzh44iAAIDjkJF5v+zr8vIcyZfr2fUNj0PCaS2tMn/wRAGDQgMEYOWk48gtKR7L93/9+xogRo6GvX/7oLDo6Et9//w2TbtbMCps2fcuUMTY2xtatm+v8+RBSlUbp/koDLHEdOXIAUmkWk7a1bckEDADQunUbODo61Xi9aWmpWLhwCdzdu4LP56NVq9YYNMiH+fL+7rstrF9XPXr0ZP7t6uQIswojcR4KPoWMrPI27tr1G2tekI7t2zIXLD09PXRq145Z9m/MI4RfvcakQ0PPID7+KZMWiUTo2bM3k7a0bIYuXcoDAE36eg6AWFJhuPD0DET9c5VV5sKF85BKs+DvrzkAAYDXOrTDotWf4b3ZM9H29dLX+4qKirB79+94553xuHbtSpXtIC+njIx0TJs2HQMGeEEgEMDWtiWGDx8FgUAAR0cnzJjxCUaPHsupN7CvJysdfDZYq+159ivvaCvSE8HOtvyVcZksF/fv/8sq/9tvv7LufvTo0YsVVJT9oCCkIdE7Mzpy6VI4K92ypR2njL29Q43Xa2nZDL1792PlzZ49H3v3HkFKSjL+/fcea1nz5uyxMqyalQ9spFAocfFK+ZdyaGgIu67a4wcrSwtW+lzEJebfly+z99faugWnr0t1+2sgFqOf1wBW3pkT7Av00aOH0a5dB1YAps7E1BSdPLpg4JBBWL5hDUaMGMUsS05+hoULP8GtWzeqbAt5+ejp6cHXl92XYNy4iQgLuwIbG1tMnPgOM+eNQqFAriwX0hwpRHrsYe0fP30MbbS0aclKiw3Yj9KePy+fprqgoAA3bkSz66tdMywsLFlz8hDSEKiHoo5U/NUNAMbGJpwytbkAODk5g8/XHAvGxj7i5JWUlECaUz5Mt57aF/nD2NJBdfILCph+DGX4fD6rrvrUv2V1AU37y+0zoM3+eg/1xd/HywOFuzdvIzE+AXYO9niemopr165g4cKl1a6nYps/+WQ+zpz5m3lUpFAo8PPP32Pbtp+1Xg9p+qysrGFkVPnrZ/fv/4uDB/cg6to1pKWnVVouL1+72SzVgwR1cnn5YHKJiQmc/hearxlGyMvL4+QTUl8oaNCRggL2LJya5tPQNFx2dSwtm1W6LC+PezFbuvTTKteXKS3tnJinYdbQ/cdPYv/xk9XWBcCZdVR9rhAAlQY7FbV0sEeHzh1x9+ZtJi/kxCm8O+MDnPsrBAYGBvD2HlzteiqSSCR4/fWOuHr1Hybv9u2bKCoqYt3+JS+3qs6dM2f+wpo1nzFf3BbmFng74B3Y29pDmiPF2q/X1Hh76kF2VTTN2qv5mkE3j0nDoqBBR8RiCWSy8gE41H9FAEBJCTevOpouJGUkEu4v+RkzZsPV2rTSOib//fIyrNCXoIxXvz7w8/Lk5JepeFGUqNVXKDTtr3aDxQzy92MFDRfPnsPYSRNxIeQsvLwGcfZTqVSiWC6HgbjyX3YmJuzPQKlUIjc3B/r6Vlq1iTR9lZ07xcXF2Lx5I+scXb14LTq0Ke0Pk5zKfZ2yvqmfP0Bl1wwacIk0LAoadMTBwRH37t1h0uozeQKo99uMTk7OnDw7Ozt0bcfNVycRi2Ft3RxpaeXPWU2MjNC1s3Yz6Dk4OCIm5iGTzs3ljlim7f569OwOc0tLZP03/XlhQQG+//JrZGVkYvjwUZzy4aHn8fPX3+LLn7bB1p7bdwQAa7/K0GuXBCh9Vbji+WkoMWQChsZiZ2cPgUDAChQ0XzO0ezRCSG3RvSwd6d27LyudmJjAKaMpry7s7Ozh4uLKyouNjdFY9uuffsGgcRNx/tJlJu+NNwawysQ95b7OCACh4REYNG4ivvnlf0xer17s/U1NTYZCwZ7LIzFR8/rU8QUCePmyH0HcuBYFW3s7dOpU+aBM927d0Zifm5vL+RzatetA44sQAKV3GipS78Cbl9/wfQjEYjHc3NxZeerXh6ysTOrPQBocBQ06MnJkAMzMzJh0cnISHj68z6RjYh6y3g+vLx9+OIv12CA4+CRyZexfJ08Tn+HvsAuwMDND727lI9xNmvQu6zb+nfsPcP9RLKtuYVERgg4ehlKpxLBB5a+UeXoOgoODI5MuLi5GRMRFJp2ZmYHo6Cit92PgkMEQqF28B/hUPVfE4d17kZWRycnftm0L62LL4/HwwQcfad0W8nJzdHRiPbrIzslGcmp5p+B/Ii9rqlbvJk+exjp3r1y5hKKi8sGcQkL+bpR2kFcbPZ7QETMzM6xatR6LF89neu0vXboQEya8DQDYsycIFhaWyMzM0Fg/KysTUVHX8Pgx+0s7OTkJISGnYWAg1ji9c+/efTFv3iJ8881XUCgUSE5OwvsLFmHIwAGwsrREfGIijp8JgZ6eEIEL57GGg7a2bo4NGzZj2bJPkZmZAWVJCeas+AzDfQbD0c4OmVIpTp0NRUrac8z78AO4OJa/QikSibBmzUbMnTsDGf89Vti4cQ2ePUuAoaERDh3aB2NjY2RkFHH2pVOnToDaj34zC3N079MLl8NKAw+BUIh+XgOr/MylWVlY9NFsDBwyCLZ2dijIz8fViEt4cLf8fXgjI2MsXLgE3br1rGJNpCkrKChARMQF1uNBAJBKsxASchoAe8wDY2NjjBgxGocOlc9fsnLDCgz3GYHE5ERE3eQGu2cvnkVzZxu4uXVFePgFpKWlaCxj09wGNtY2iL4dDWl2Fmv5vXt3IBKJ4OHRDebmFnB374oZMz5hRoTMyMjA/Pmz4evrj9TUFBw+fABisYTVyfr27RuQSjPRr9+AGn9OhGjCU2kaZ7iG7t69B1tbxyrLmJs3/amxtZ05rDoVZ6lLSnr239wT/yAjIx0ikQitWr2GceMmIjw8jDX3xPvvf4TJk6cBqHz8/DLqc02oS0iIx8GD+3D9eiSSk56hqKgIYrEY9rY26ObWGaP9fGFuxu4cqG/jCoWiBDk52Th+/DAunjuD+MRnyMvPh0ikh+ZWVujUrh1G+vrA1cmRUw8oHVUyKOg3RERcQGpqyn8D5zhjxIjRSEtLZY1uWWb58kC06+3GyX9w9x5W/fd6Zbc+vTBn2SK4WjiwZu2LzYxHYWEhHt79Fw/v/YuY+w+Q8Twdspxc5OflQainB3Mzczg7u6B7917w8fHldIrUhlDIh0ztrktljFq5MrNc1rRObVhZGTf5qbEf3L7LyrO2c2L9ndMSn2i1Lms7JyQkJGLs2OFVlgsPj2SllUolgoJ+Q3DwcSQnJ0FfpA8nB2f4DPCBh1tXvP3RRM46unTxwLff/lTp3BMA4DNwCIZ4+mLuik8qbcvWrT/C3b38jt+dOzcQFMSee6JzZzdMmfIBFi+ep3FbR46c0rjuFi2asz7HlBRu357q6pEXS1paAqyt7asviNrNctloQYOxWAihQdN9fU1RWISsXHn1BbWg7dS2K1cuQWho+bwIixevqHKkw9q2pShZuy+uil/+ta1X2zZqGg4aAJbMnIP4x0/w6aqV6NzVXWPQUJ2KderSxhc1aDA304dQbQCipkReVIDHD+NYeXUJGup6LBamaNfZ0KCFEauNtalXWRuqW16bL38KGl4ODR00NNrjidwCBVCgqL6gjjXmibB69Uo4Ojph0qSpGpdX7BjI5/PRtWuPxmraCykzPQMCoQCmFfqCNLe1QZ5Mho7ubjpr14suS1oEoAhCIR9JCZonBVNna2/KBDY1rVMXNQkACCGNjzpC6tDDh/exd28QUlO5zzvv3LmFhw8fMOlRowLQokULTrlXyfdfbsYPX21h0kmJzxB1+QoGDhlMg9oQQkgjoI6QOpadnY333psEP79hcHBwhEqlQkzMAwQHl/dHGD58FGbNmqfDVr447t64hf2/B8Hc0hLBh4/C1NwcQ0YM03WzCCHklUBBgw7NmbMQkZFXce/eHZw7F4KcnGwUFBRALJbA3t4BHTt2hq/vMLRt2676lb0CuvbqiYKCAvx1tLRzaKu2r2HS9PcgllQ9hj8hhJD6QUGDDnl4dIOHRzddN6PJGDJyGIaMpLsKhBCiK/QgmBBCCCFaoaCBEEIIIVqhoIEQQgghWqGggRBCCCFaoaCBEEIIIVqhoIEQQgghWqGggRBCCCFaoaCBEEIIIVqhoIEQQgghWqGggRBCCCFaoaCBEEIIIVqhuSeIzkVEXMSiRXM5+b6+/li2LLDxG0QIIUQjChqIzrVp0xaBgWtx/vxZnD8f2mjblRcVYdFHs5GWksrkubm5Y9u2nxutDYQQ0pQ0WtBgKNGHSL/pxijyIgWycwp03YyXUrNmVvD29sHTp08aNWg4sucAK2B4WZmYSaCvJwAAmJsb1rh+berUhbl5B1a6oEiO+IcxjdqGxvDJstm4efcGk140awl8vXx11yBCtNBo3+IifSFWzT/RWJurdys3+eu6CaQeJSU+w8mDh3XdjEahryfA+8HRum5GrW33c9d1Ewgh/6GOkOSVtPO7H6FUKmFrb6frphBCSJPRdJ8XEFJLEefCcPfmbbzh7QkVVEhKSNR1kwghpEmgoEHHkpOTsGvXTly9egXp6WnQ19dH69ZtMHHiJISGnsGpU9xHOlu3/oiUlGR88cXnnGW+vv5YsmQl9u//EydPHkNiYiLk8iK0aGGDAweOM+VSU1Nw8OA+REZeRVJiPArlRTA1NkHbVq7w9RqIfj26V9rmgoICnDx5BOdD/sLj+Hjk5efDUCyBo70d+vfqieE+gyDS09NYNysrC7t3/46IiAtISUmBQCCAk5MThg8fXen2oqIiMXPmBxqXNbO2wjc7twMAnqem4i2/kazlI8aPxbjJbzHpPJkMQb/sgKGRESZMm4zdv+6sdLvk5VZcXIzTp4Nx7txZxMQ8QE5ONgwMxLC3t0efPm9g7Ng3YWhoxKozcuRQpKQkc9b19/4QHDx+AGcvnsWz5EQoS5RwdHTC2LET4Oc3jFV23Tdf4PS5vzjr2PDtOmz4dh2A8g65wcHHa3yeHzlykiknk+Xi779PISoqEgkJT5Gfnw+RSB/W1s3x+usd8c47k9GypQNr3e+/PxnPn6dxtvnTTzvx559/4NatG8jJyYahoSHatu2AUaMC0LfvG0y5gIBhGj8joPTa5e7eFQDw8ccf4MaN8sdmVlbWOHw4WGM98uKgoEGHrl+PwqJF85CfnwcAsLFpifHjJwAANm/egJKSElb5AQM8MWCAF5ydXZCWlgqRSASlUgmlUskqt3ZtIE6fDgaPx4NKpeJsNyTkNNavX43CwkIAwJihvnB2cMD+4ycQcS0SEdciMaB3LyyfMwt6al/+jx7FYMmS+UhOTgIAdO/iBs++vRF2+QouR0bh1r1/ceLvEGxcuRTWzZqx6sbFxWLu3JnIyEgHAJiZmWHixMmQSCTYv/9PZGdna/ycnJ1d8PGi+Ti0ey/rroBbNw94+fkwaWNTU6xevQ6HDh1AXNwjLFiwGEILMWtd+37bhewsKabM/BAmpqYat0defikpKViyZB5iYh4CANq164Dp02fixo1onDp1Av/+ew/Hjh3Gl19+A1fXVky9+fM/RcKDJ9j6yzes9S1ZsxhO9k4Y5TcK5y+dx7XrVxET8xBffPE5ZDIZJk4sD1xH+I5Ed/ce+H3vTjxNfMrkDx8yAp07uEFkZgATEzMAAJ/Pr/V5fv16FL7+eiNycnIAAN2790KPHr2QkBCP48cP48mTOJw6dQLTpk3HpElTmXrvv/8R0tJS8csvP7LWt3TpAvTp8wbefnsybtyIxoUL53HlyiVcuXIJAQFvYs6cBQCAOXMW4p9/InDkyEGmrlgswaefLoWzswuTN2XK+7hxIxo7dmzH5MnT0K5d+yr+YuRFQX0adEQqlWLFisVMwAAA69dvQkDAmwgIeBNffPElUlNTWHWcnV3h7e0Dc3MLDBkyFKGhl1gnOwBERV1DZORVbN36I8LCrmDnzj9hbm7BLL9xIxqrV69kAobevfti9ntTMWywNz6bXz5WwvlLl/Hzrt2sdWdlZWHBgtlMwGBqbIw1ixbA13MgVn86HxbmZgCAxwkJWLlxE+siJ5fLsXz5p0zAAACLF6/ExInvYOTIMfj66++Qm5ur8bOysLBAr/794DN8KCs//vETuHX1YNIGBgYYMMATjx/HYfBgPwwa5AMHZydmeezDGJw99TdcXmsNT9/BGrdFXn5yuRyffvoJEzAIBAKsW7cJQ4cOx7JlgXjttTYAgLS0VCxePI91jvbr1x+9uvXmrPM1l9aY9d5sDB3kj7VLv4BELGGW/e9/P6OoqIhJt3+tPbz6ecHM1Jy1jnatS/MHDfKBh0c3AKj1ef7o0UOsW7eKCRhcXFyxZMkKeHkNwrvvTsOwYSMBAEqlEj///D3279/D1O3evSe6devJ2ce+fd/A1Knvw9NzEDZs2ITWrV9jlh04sIe5K9q37xv44IMZ0NfXZ5YXFOTDxMSU1UYPj27Izc2FmZk5pkx5H3379udsk7x4KGjQkSNHDkAqzWLStrYtWb9oWrduA0dHpxqvNy0tFQsXLoG7e1fw+Xy0atUagwb5QCAofeXuu++2sL7Me/Qovzi4OjnCzMSESR8KPoWMrPI27tr1G9LTnzPpju3bMhcGPT09dGrXjln2b8wjhF+9xqRDQ88gPr78V5VIJELPnuUXX0vLZujSpTwA0KSv5wCIJeUX48z0DET9c5VV5sKF85BKs+DvP4KVX1JSgv9t+wEAMHXmdPD5dOi/qk6cOIq4uFgm7eLiimYV7op17Vr+aC45OQlHj1b/lo1nP2/m3yI9Eexs7Zm0TJaLf/+9V9dms1R3nv/vf9shl8uZ8j169AKPx2OlK9q+/QdkZ0ur3GbFRxA8Ho/zJf/bb78y/zYxMYWXFzswP3RoHystl8vx99+n4OPjB6GQbno3FXTl1JFLl8JZ6ZYtub347e0dOHnVsbRsht69+7HyZs+ej717jyAlJZlz8WrevAUrbdXMkvm3QqHExSvlX8qhoSHsumqPH6wsLVjpcxGXmH9fvszeX2vrFpwLRXX7ayAWo5/XAFbemRPsZ6BHjx5Gu3YdWAFYWbknj+Lg5esD59bsZeTVEhp6hpXmnANWzassr0lLm5astNiA/VhMUx+BuqjqPE9LS8W9e3dYy1q0sGWlbWzY6fz8PISHX6xym7a27GuU+vmamJjA+mEwevQ41vLLlyOYu5QAcP58KHJyspm7HqRpoKBBRyqeXABgbGzCKWNoWPNBdZycnCv9FR0b+4iTV1JSAmlODvOfntoX+cPYOABAfkEB64QHSp+3Vqxb8ZdMxbqApv015rRFm/31Hsoe/ObuzdtIjE8AUNoR8tq1K5yLUFZmJvb/vhsmZqasTpHk1fT4cSwrLRAIIJVKmf/U+wc8evSQ059AnXqQoK7i44n6UNV5XvbYpSIjI3aHTk3nmqZ6FYnF7H00MuKew/HxT5h/t23bDu3bv86kS0pKcPjwASZ9/PhhdOzYCU5OzlVul7xY6J6QjhQU5LPSZbcVK+LzuXnVsbRsVumyvDwZJ2/p0k+rXF+mtLRzYl5+PmfZ/uMnsf/4SU6+el0AyFerLxRq2t/qY9iWDvbo0Lkj7t68zeSFnDiFd2d8gHN/hcDAwADe3uzbort+/h8K8vMR8PY0lChLkJudwyxTFCtYZZVKBaRS6X9tFHIutqTpk8nY50FY2DmEhZ2rtHxxcTFkslyYmppVWkY9YG5oVZ3nmvoGqV9fBALupV8m09ynqIz6+anpkYL6eT569FjWXY+TJ49i2rTpSEtLxY0b0Vi0aHmV2yQvHgoadEQslrBOUk2/ZEpKqv51o4mm4KOMRML9dTFjxmy4Wlf+FoHJf1+ahhX6EpTx6tcHfl6eldateCGVqNVXKDTtbwknT5NB/n6soOHi2XMYO2kiLoSchZfXIM5+/nOh9NHIHz//ij9+/hVVuX37Fvz9S59P0zwULydDQyPk5JQHtO7uXfHOO1OqrCMWc49/XarqPNd0F0/9+qJUKjhlNN05qKikpIQVOCgU3HWon+eenoOwbdvXTCCenZ2N0NAzePw4DmKxhNPvgbz4KGjQEQcHR1YEnpubwymTl5fHyasLTbcB7ezs0LVd9bcHJWIxrK2bIy2tfK4GEyMjdO3cSattOzg4sm5/avo1pO3+evTsDnNLS2RlZAAACgsK8P2XXyMrIxPDh4/ilF+ylvuee5kTBw/jdvQNJu3q2hoffzwHgOZHRqTpc3R0wu3bN5m0gYEBunXrocMW1a/Wrdtw8tTvrmg618reGqlMQUEB67GGpjsTDg5OrLRIJMLQoSMQFPQbk7d//x6kpz+Hl9dgziMP8uKjPg060rt3X1Y6MTGBU0ZTXl3Y2dnDxcWVlRcbq3kioK9/+gWDxk3E+UuXmbw33hjAKhP3NF5j3dDwCAwaNxHf/PI/Jq9XL/b+pqYmc36pJCZqXp86vkAAL7VXJm9ci4KtvR06derMKf96l86V/mdmwX7tzdjYGN269UC3bj3Qtm07zrpI0/fGGwNZaU19fQDgzp3b8PTsjcWL5zVIO7i390v7UpSUlGD37j84HY+1ZW1tjQ4dOrLyUlKS1NLswZcMDQ3Rpw+7Y6W65ORnrHRCAvt8tbOzh4ODI6feqFEBrDsUDx/eR2ZmBucNJ9I0UNCgIyNHBsDMzIxJJycn4eHD+0w6JuYhnjx5XO/b/fDDWazHBsHBJ5Gr9ivkaeIz/B12ARZmZujdrSuTP2nSuzAxKX+Ucef+A9x/xO5UVlhUhKCDh6FUKjFsUPlraJ6eg1gXlOLiYkRElPfWzszMQHR0lNb7MXDIYAjULroDfLwrKU1IuREjRsPWtvxth9TUFE6fhpKSEvzvfz9DLpdj5MiABmlHMwt2v4Tc/365Jycn4fvvv0FY2Nlar3vq1A8gEpWPk3Dlyj+sDp7//HOZVf6DD2bCtJrBziq+XaFSqRAeHsZaPnnyNI31WrSwQa9efVh5Li6u6NDhdY3lyYuNHk/oiJmZGVatWo/Fi+czg8csXboQEya8DQDYsycIFhaWyMzM0Fg/KysTUVHXOD3Bk5OTEBJyGgYGYtZ71WV69+6LefMW4ZtvvoJCoUBychLeX7AIQwYOgJWlJeITE3H8TAj09IQIXDiPNRy0tXVzbNiwGcuWfYrMzAwoS0owZ8VnGO4zGI52dsiUSnHqbChS0p5j3ocfwMWx/JUskUiENWs2Yu7cGcj477HCxo1r8OxZAgwNjXDo0D4YGxsjI6O8l3nZvnTq1AkwUPv8LMzRvU8vXA4rvZAJhEL082L/gqxMtlSKe//1iXiewn4VTirNQkjIaQBA+/avs75cyMtBIpHgyy+/waJFc5m7eStXLsawYaPQpk1b5Obm4syZU4iJeYgpU95njSdy8WIYEh484azz7MWzsGluAxtrG0TfjoY0O4u1/O7dO+AVqODe0R3mZqV3t/r36s8aTjo45CQkEkOc+6d0evi+ffvX+jx3dW2FZcs+w6ZN65GTk4O4uEdYv341a0RIoLRvxPvvf4QxY8Zx1qEuPDwMKlUJHB2dcPPmddbjxoCAN+HrW/lMwKNHj2P9SKC7DE0XT6Vp/NEaunv3HmxtubelKjI3N2zyU2M/f15172JtCYV8KBSlnf6Skp79N/fEP8jISIdIJEKrVq9h3LiJCA8PY8098f77HzHRfHR0JGbP/rDSbajPNaEuISEeBw/uw/XrkUhOeoaioiKIxWLY29qgm1tnjPbzhbkZ+5eHvo0rFIoS5ORk4/jxw7h47gziE58hLz8fIpEemltZoVO7dhjp6wNXJ0dOPaB0VMmgoN8QEXEBqamlc084OjpjxIjRSEtLxY4d2zltXb48EO16u3HyH9y9h1ULlwIAuvXphTnLFsHVwoHZllDIR2wm95HHvVu3sXbxiko/mzJLl37GmTegMkIhHzK1uy6VMWpV+nnUpk5tWFkZN/mpsR/cvsvKs7ZzYv2d0xKfaLWuivUKCwtx8uRRXLhwHrGxj5CbmwOhUAgrK2u8/nonDBs2Cp07u7HqVzWvgs/AIRji6Yu5Kz6pdPtfr/4GXTp2YdLBISdx4swJPE14ioLCfIj0RHBwdMLQocMxZsy4Wp3nQiEfKSmlfY9K5574C1FRVxEfH4/8/Dzo65fNPdEJkya9C9v/BqKqWC81NRXTp7/LWu9PP+3An3/uws2b15GbmwOJxBBt27bD6NFjqx3NUaVSYcKEMUhMjIdIJMLhw8FVvo1Cai8tLQHW1vbVFwTA5/NgaVmzN8QaLWgwlOhDpN90b2zIixTIzimol3VVDBqqsnLlEtbAMosXr6j3CF0o5KMoWbsvropf/rWtV9s2avryB4AlM+cg/vETfLpqJTp3ddcqaFBXsU5d2viiBg0mZhLo69X89d0XRUGRHPEP2X1v6iNoqA2hkI/CFO6ry5oYtDBitbE29SprQ3XLy778q9OiRXNWG6sKGo4cOaWxnrb27NmFbdu2wMtrED7/fF2N6hLtNXTQ0Gjf4nn5RcjLr98BThpCXb88amL16pVwdHTijCtfpmLHQD6fj65dX54e3rWRmZ4BgVAA0wp9QZrb2iBPJkNHdzedtetFlyMtfXdeKOQjKUHzpGDqbO1NmcCmpnXqoiYBAHlx5efnITMzE3Z25V9e9valPyzp0UTTRh0hdejhw/vYuzeIMzEVANy5cwsPHz5g0qNGBaBFixaccq+S77/cjB++2sKkkxKfIeryFQwcMpjmkiDkBXL+fCjefHMU0tNLJ6hTqVTYvft32Nk5vPI/fpq6pvu84CWRnZ2N996bBD+/YXBwcIRKpUJMzAMEB5c/pxw+fBRmzWqY176amrs3bmH/70Ewt7RE8OGjMDU3x5AR2vU7IIRU7+rVf1jjsZS5ePE8AKBfvwFar+uLLwLh6TkI165dwc2b17FmzYZGHz2T1C+dBg0lJSo8ehTDmo3N0NAQzs5VDzZUVCRHZmYGZLI8FBcXQ6VSQSgUwtBQAnNz81rN2aALc+YsRGTkVdy7dwfnzoUgJycbBQUFEIslsLd3QMeOneHrO4zGC/hP1149UVBQgL+OlnYObdX2NUya/h7EEhoghpD6sn37Dxon2Nq0aQMA7YIGF5dW6NmzNx4+fIAbN6LRooUNFi9egQEDvOq7uaSR6TRoeP48jRUwaCMzMxPJyclMoGBtbQU+X4DMzExmwhlzc3PY2rbEix7Qenh0g4dHN103o8kYMnIYhoykuwqENKTt23+rvlA12rZth6++2loPrSEvGp0FDUVFRczzLm1JpVIkJZWPbGZvb8/cVTA1NcGDBw9RUqJEVlYWeDwebG1tK1sVIYQQQmpIZ73HkpJK7xbo6+tXXxilE64kJ5e/Hy0QCFiPIUrT5ZOlZGZmcmZcI4QQQkjt6SRokEqlyMuTwczMXOvZ46TSbNZMbSKRiFOm4rCpAJiRBwkhhBBSd40eNCiVSqSklI4E2KJFc63rqc8CqWlqWKGQnZebm4u6D11FCCGEEKAegwZtB5ZMTU2FQqFA8+bNNczyVrmCAvZojHw+N2hQzyspKUFR0Ys/oBQhhBBSV/UwwHO16iVoEAgEUCoV1ZbLzy9AZmYWxGIxzM0ttF5/SUkJ69EEAI3v+mrKKy6u2dsZhBBCSFOkVCo13oWvT/USNJiYGDMzNVZGpSqdmQ0AbG1ta/Q6pFLJHZpWU31NeSUljTcsNCGEEKIrhYV5MDExbtBt1Msrl5aWlnjy5AkAQCIxhEAg5Pzqz8zMQEFBASwsLCAWv7iD8QiFjdPNo7G2U99q2+7G3N/abKux/x7Uxrp7WY9FberV5z40hc+RVE6lUkGpVCA/Pw9yeR5sbZ20fiuxNuolaNDX14eTkxMyMjKQkZHKeZSgVCqRlpYGHo+HkhJDJCU9ZZZlZ2ehsLD81ciSkiIkJbEPRpWqBIWF7I6Q2dkK8Pns7eTl5XHKZWSkIC9PqvW+NMadCT6f/8LcAeHz+VBkZ2lVVqh6yrS7tvVq20ZZnnZvwiQVqlht1KZexTp1aWNRnnafR05S6edRmzp1wefztZ+pNUnKtLGmdeqCz+cjN6f6v5kiicf6O2tTR71ebdunyCnUqqywxIB9vtSiXmVtqG55Tk5OpcsrKikpZLWxNvWI7vH5Aujri2FiYgV9fX08f56rZT0dznKpr68PW1tbaBpPae7cuQgODsbSpUvRpYsba9mvv/6CkydPMukuXbrg+++/BwDo6enB2Lj0Vsu0adMglUqZckOGDME333zDWteuXbuwevVqVt6JEyfQunVrrfcjI0OGkpKG7UxiZWWs9R+1oVlZGSNu7RityrosO8i0u7b1atvGcXs/0qrsvvE/sNqoTb2KderSxogR2n0e7kdLP4/a1KkLKytjrJp/QquyKzf5M22saZ26sLIyxrYlU6ot9/G6Hay/szZ11OvVtn0xX4VrVbb1AndWG2tTr7I2VLd806ZNWm1r/vz5rDbWph55tTTKiJDBwcEAgC+++AJffPFFlWWvX7+OXr16AQC6d++OP/74AwDQoUMHREREMOVkMu7c9Hl57H4VYrEYLi4udWo7IYQQQko1StCwY8eOSpf9+uuvCA8vj8DbtGmDxYsXAwBMTEyYfC8vL1bQkJXFva2rnjdw4MAG70lKCCGEvCoaJWjo3bt3pcuOHTvGSpuammos7+/vj2+++QbZ2dkAgMTERKhUKlaHy/j4eFadt956qy7NJoQQQkgFTab7q6mpKZYuXcqks7OzERkZyaRzc3Nx7do1Jj1+/Hh07dq1UdtICCGEvMx0MstlRkYG/vnnHwCldwzUl5V1jOzUqRPs7e2ZZSNHjoRMJsP69etRXFyMuXPnYurUqTAyMsKePXuYnr+jR4/GypUrG2lvCCGEkFeDToKGR48eYd68eRqXxcbGMsvWrVvHChoA4O2330bfvn2xa9cuXL58Gdu2bYNCoUCzZs0wbNgwBAQEoGfPng2+D4QQQsirRidBQ48ePfDgwYNa13dycsLy5cvrsUWEEEIIqU6T6dNACCGEEN2ioIEQQgghWqGggRBCCCFaoaCBEEIIIVrRSUdIQggh5GVkYiaBvl71IxEXFSuRI82vttyLhoIGQgghpJ7o6wnwfnB0teW2+7k3QmvqHz2eIIQQQohWKGgghBBCiFYoaCCEEEKIVihoIIQQQohWKGgghBBCiFYoaCCEEEKIVihoIIQQQohWKGgghBBCiFYoaCCEEEKIVihoIIQQQohWKGgghBBCiFYoaCCEEEKIVihoIIQQQohWKGgghBBCiFYoaCCEEEKIVihoIIQQQohWKGgghBBCiFYoaCCEEEKIVihoIIQQQohWKGgghBBCiFaEum4AIYQQzcxNxRCKuJdpKytjVlohVyAru6CxmkVeYRQ0EELIC0ooEiLmq/Bqy7Ve0LcRWvNqMTGTQF9PoFXZomIlcqT5DdyiFwMFDYQQQogafT0B3g+O1qrsdj/3Bm7Ni4OCBtJozE1FEIr0tSqrkBchK1vewC3iMjbTh4GeSKuyhcVy5EqLGrhFXObGIggNtPwcC4uQldv4nyN5NZiaGkAk0tOqrFxejOzswgZuEWloFDSQRiMU6SNu7RityrosOwig8b/sDPREGLf3I63K7hv/A3LR+EGD0EAfESO0+xz7HD0IUNBAGohIpIdNmzZpVXb+/PkAKGho6ujtCUIIIYRohYIGQgghhGiFggZCCCGEaIWCBkIIIYRohYIGQgghhGiFggZCCCGEaIWCBkIIIYRohYIGQgghhGiFggZCCCGEaIWCBkIIIYRohYIGQgghhGiFggZCCCGEaIWCBkIIIYRohYIGQgghhGiFggZCCCGEaEXYWBsqKChAREQErl+/jlu3biEtLQ1SqRQymQxisRi2trZwc3PDiBEj4OHhUeW6nj59iqCgIFy6dAnJyclQKBRo1qwZPDw8EBAQgO7duzfSXhFCCCGvjkYLGh48eICZM2cCAExNTTFhwgQ4OjoiMTERQUFBePDgAR48eIC9e/fCz88P69atg4GBAWc9u3fvxrp16yCXy2FlZYUZM2bAyMgIe/bswdGjR3H06FEEBARg1apVEAgEjbV7hBBCyEuv0YKGMsbGxjh8+DBatmzJ5I0YMQL+/v6Qy+UAgODgYCiVSmzdupVV99ixY/j888+Z9Ndff41u3boBAIYMGQJPT0/IZDIcOHAAenp6CAwMbPgdIoQQQl4Rjd6nYdKkSayAAQAcHR0xatQoVt7p06dx//59Jp2Tk4O1a9cyaVNTU3Tt2pWVLgsgAGDPnj2Ijo6u7+YTQgghr6xGCxpMTU3h5eWFQYMGaVzu5ubGyYuMjGT+ffz4cUilUiZtZ2cHHo/HKu/o6Mj8W6VSYdeuXXVrNCGEEEIYjfZ4wtnZGd9//32ly62trTl5eXl5zL9DQ0NZy8zNzTnl1fNCQ0OhVCqpbwMhhMPURASRvr5WZeVFRcjOkTdwiwh58TV6n4bK5Ofnc/Ls7OyYf9+5c4e1zMjIiFNePa+goABxcXFo3bp1PbWSEPKyEOnrY9uSKVqV/XjdDgAUNBDywozTcO/ePVbayMgI/fv3B1AaUFR8NAEAenp6nHVoyktKSqq/RhJCCCGvsBfiToNSqURwcDArb/HixcydA5lMxqmj6ZGDpjxNdatiacm9g9EQrKyMG2U79a227a5NvZd1W7Wt9zK3sTZe5s/jRd9Wbes11eueNl6kz6MhP+cXImjYuXMnnj59yqTnzZuHsWPH6qQtGRkylJSoGnQbVlbGeP48t0G3oa2aHlxl7a5NvcbcVk3rNea2yuq9yJ9HWb3abqu26G9W+3pN6fNoChrzb1afavL9wufzavxDWedBw9mzZ7F582YAgEQiwRdffAFfX19WGU39F5RKpVZ5muoSQgghpOZ02qfh0KFD+OSTT6BQKODu7o5jx45xAgagNJgwMzNj5RUXF3PKacqztbWtt/YSQgghrzKdBA1yuRxr1qzBkiVLIBAIsGjRIgQFBcHe3p4pk5KSguzsbCbdoUMH1jo09VWo+IomAIjFYri4uNRz6wkhhJBXU6MHDbGxsRg/fjz++OMPdOnSBUeOHMHUqVPB57Ob0r9/f6xbt45Je3l5sZZnZWVx1q2eN3DgQBqjgRBCCKknjRo07N69G6NHj0ZcXBwWLVqE3bt3w9nZWau6/v7+MDU1ZdKJiYlQqdgdFuPj41npt956q+6NJoQQQgiARgwaTp48ic8//xyFhYUoLCzEhg0b0K5dO7Rp00bjf+pMTU2xdOlSJp2dnc0aZjo3NxfXrl1j0uPHj2fNTUEIIYSQumm0tyeKiorqvI6RI0dCJpNh/fr1KC4uxty5czF16lRmauycnBwAwOjRo7Fy5co6b48QQggh5XT+ymVNvf322+jbty927dqFy5cvY9u2bVAoFGjWrBmGDRuGgIAA9OzZU9fNJIQQQl46jRY0jB49GqNHj66XdTk5OWH58uX1si5CCCGEaOeFmXuCEEIIIS82ChoIIYQQohUKGgghhBCiFQoaCCGEEKIVChoIIYQQohUKGgghhBCiFQoaCCGEEKKVJje4EyGEEPIyMTGTQF9Pu8kVi4qVyJHmN3CLKkdBAyGk3pmaiCHS1+7yIi9SIDunoIFbRMiLS19PgPeDo7Uqu93PvYFbUzUKGggh9U6kL8Sq+Se0Krtyk38Dt4YQUl+oTwMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0QkEDIYQQQrRCQQMhhBBCtEJBAyGEEEK0ItR1A2pDJpMhKCgI586dw5MnTyCTyWBubo527drBz88Pw4cPB59P8RAhhBBSn5pc0BAdHY1Zs2YhPT0denp6mDx5MlxdXXH+/HmcPn0aYWFhCAoKwk8//QQLCwtdN5cQQgh5aTSpoCEuLg7Tpk1Dfn4+AODDDz/Exx9/DAAYPXo03n77bVy7dg23bt3ClClTsH//fohEIp2119hEDAN9zR+xlZUxK11YpEBuTkG19dRVrEcIIYQ0pCYVNKxatYoJGADA29ubtdzLywvXrl0DANy/fx87duzA9OnTG7WNFRnoCzFs/lGtyh7fNAK5dahHgQYhhJCG1mSChtjYWFy+fJmVZ29vz0o7ODiw0kFBQXjvvfcgEAgavH26VtsAhRBCCNFWk+ktGBISwkqLRCIYGhqy8szNzVnp1NRU3L59u8HbRgghhLwKmkzQcPfuXVbayMiIU0ZTnno9QgghhNROk3k88ezZM1ZaT0+PU0ZTXlJSUo22w+fzatawalibi2u17drUq+22hKZWjVavttuykmj/Jkxt6tXHtvSta75vtalTl3qmtThGalOnLvWMzSwbrE591BOa6NdqWw1dr2IdExOTWm2rNvVqu62mwFKsfUf6ivumbb3a1FGvV5vlNS1XEU+lUqlqXEsHfHx88OTJEyZta2uLc+fOscokJCRwOkeOHz8eq1ataowmEkIIIS+1JvN4ghBCCCG61WSCBvX+CkqlklNGoVBw8oyNjTl5hBBCCKm5JhM0tGzZkpUuLi7mlNGUZ2tr22BtIoQQQl4lTSZoaN++PSstk8k4ZfLy8jh5HTp0aLA2EUIIIa+SJhM0eHl5sdJyuZwTJGRlZbHS1tbW6NixY4O3jRBCCHkVNJmgoXXr1ujevTsrLyEhgZWOj49npSdOnPhKjAZJCCGENIYmEzQAQGBgICQSCZNWHyUyNDSU+fdrr72GadOmNVrbCCGEkJddkxmnoUxkZCRmzZqFzMxM6Onp4d1334WrqyvCwsJw6tQpAKX9GH7++Wc0a9ZMx60lhBBCXh5NLmgAgNzcXOzatQvnzp3D06dPkZeXBzMzM7Rt2xZ+fn4YOXIk+PwmdROFEEIIeeE1yaCBEEIIIY2vycw90VTJZDIEBQXh3LlzePLkCWQyGczNzdGuXTv4+flh+PDhdFfkFVBQUIDvv/8eO3bsYI0n8uDBg2rrPn36FEFBQbh06RKSk5OhUCjQrFkzeHh4ICAggNNBmLz4CgoKEBERgevXr+PWrVtIS0uDVCqFTCaDWCyGra0t3NzcMGLECHh4eFS5Ljo+Xk7nz5/HnTt3cPfuXSQkJEAqlUIqlYLH48HU1BTOzs7o3bs3xo4dW+Wj+Po+PuhOQwOKjo7GrFmzkJ6eDj09PUyePBmurq44f/48Tp8+DQDo1KkTfvrpJ1hYaD9JEmlazp49i7Vr13ImXQOqDxp2796NdevWQS6Xw8rKClOmTIGRkRH27NmDe/fuAQACAgKwatUqelOoCblx4wbGjx8PADA1NcWECRPg6OiIxMREBAUFQSqVMmX9/Pywbt06GBgYcNZDx8fLq3379lAqlbCwsMC4cePg4OCAjIwMnDhxgnXdkEgk2LRpEzw9PTnraIjjg4KGBhIXF4cxY8YgPz8fADBr1ix8/PHHzPK3334b165dAwC0bdsW+/fvh0ik/Sxn5MWXn5+P+fPnIzQ0FI6OjnBwcMDFixdZZaoKGo4dO4aFCxcy6V27dqFbt24AgOzsbHh6ejKDnE2YMAGBgYH1vxOkQZQFDcbGxjh69ChrxNunT5/C398fcrmcyfPx8cHWrVtZ66Dj4+XWvn17mJiY4MiRI2jRogWTX1JSgsmTJ+Pq1atMnkQiQWhoKMzNzZm8hjo+6L54A1m1ahUTMADgzL5ZcbCq+/fvY8eOHY3WNtI4MjMzcenSJcyePRsnTpxA586dta6bk5ODtWvXMmlTU1N07dqVlS67AADAnj17EB0dXT8NJ41m0qRJnCHyHR0dMWrUKFbe6dOncf/+fSZNx8fLTyAQYNiwYayAAQD4fD7Gjh3LysvPz8eVK1eYdEMeHxQ0NIDY2FhcvnyZlWdvb89KOzg4sNJBQUEaJ+EiTZeZmRlOnjyJmTNn1vgu0vHjx1m3qO3s7MDj8VhlHB0dmX+rVCrs2rWrTu0ljcfU1BReXl4YNGiQxuVubm6cvMjISObfdHy8/G7fvo1ly5ZpXKavr8/Jq/j4qiGPDwoaGoD6oFMikQiGhoasvIq3kQAgNTUVt2/fbvC2kcZjZGQEOzu7WtWtOFAZwD1eNOWFhoZS4NlEODs74/vvv0e7du00Lre2tubkVRw2n46PV9u5c+dYaUtLS7i7uzPphjw+KGhoAHfv3mWl1af1rixPvR55dd25c4eV1uYYKigoQFxcXIO2izSOio82y1QMQOn4eLXI5XKkpqbi+vXrWLFiBQ4fPswsa9myJb799luYmJgweQ15fNArlw1AvZe8np4ep4ymvKSkpAZrE2k68vPzWbcWgZodQ61bt26oppFGUtazvYyRkRH69+8PgI6PV9GFCxcwc+ZMVp6BgQHefvttfPzxxxCLxUx+Qx8fdKehAahP263pVRahkBuv5ebmNlibSNOhadp3TceQpjxNdUnTolQqERwczMpbvHgx88uQjo9Xj7u7O3755ResWbOG6cBYWFiIX375Bf7+/rh06RJTtqGPDwoaCCHkBbJz5048ffqUSc+bN4/TW568WiwsLNCvXz+MHTsWf/zxB8aNG8csS0xMxAcffICoqKhGaQsFDQ1A/VmRps4lCoWCk2dsbNxgbSJNh6bnj5qOIU15muqSpuPs2bPYvHkzgNJ377ds2YLp06ezytDx8Wrj8XhYvHgxq3N9cXExtmzZAqDhjw8KGhqA+nvXFYcNrirP1ta2wdpEmg6JRAIzMzNWHh1DL79Dhw7hk08+gUKhgLu7O44dOwZfX19OOTo+iKGhIbp06cLKi46ORlFRUYMfHxQ0NID27duz0pqeE1V8fapMhw4dGqxNpGlRPxa0OYbEYjFcXFwatF2k/snlcqxZswZLliyBQCDAokWLEBQUxBrbJSUlBdnZ2Uyajo+Xm0Kh0PgdUZF6YKBQKJgOkA15fFDQ0AAqjvYIlF4U1P9AWVlZrLS1tTU6duzY4G0jTYP6MaR+vGjKGzhwIM0v0MTExsZi/Pjx+OOPP9ClSxccOXIEU6dO5Uxi179/f6xbt45J0/Hxcjt27Bjc3d0RGxtbaZnk5GROnqmpKYCGPT4oaGgArVu35swclpCQwErHx8ez0hMnTqQTmjD8/f2ZCwBQ2tlJfZoY9WPorbfeapS2kfqxe/dujB49GnFxcVi0aBF2794NZ2dnrerS8fFqqDi/REU5OTmceWs6derEjArZkMcHBQ0NJDAwEBKJhEmrjxJZccSu1157DdOmTWu0tpEXn6mpKZYuXcqks7OzWcMI5+bmMhOeAcD48eNZY8uTF9vJkyfx+eefo7CwEIWFhdiwYQPatWuHNm3aaPxPHR0fr4bvvvsOqampnPwvv/yS9ciBx+Nhzpw5TLohjw8a3KmBuLq6Yvv27Zg1axYyMzPx448/orCwEK6urggLC2MmF+nQoQN+/vlnmuHyJXX58mVkZmYCAGJiYjjLT548yfy7Z8+esLS0ZNIjR46ETCbD+vXrUVxcjLlz52Lq1KnM1LY5OTkAgNGjR2PlypUNvCekPhUVFdV5HXR8vPyeP3+OYcOGYezYsXBxcYFMJsPp06dZr1eamJjg888/R58+fVh1G+r4oKmxG1hubi527dqFc+fO4enTp8jLy4OZmRnatm0LPz8/jBw5kvP8krw83nnnnUpvMar7/fff0aNHD07+kydPsGvXLly+fBnJyclQKBRo1qwZ3N3dERAQgJ49e9Z3s0kDO3ToEJYsWVKjOqNGjcL69es5+XR8vHzy8/MRFRWF6Oho3Lx5E0lJSZBKpcjNzYVIJIK5uTlatWqFvn37Yvjw4ZxOkRXV9/FBQQMhhBBCtEI/cQkhhBCiFQoaCCGEEKIVChoIIYQQohUKGgghhBCiFQoaCCGEEKIVChoIIYQQohUKGgghhBCiFQoaCCGEEKIVChoIIYQQohUKGgghhBCiFQoaCCGEEKKV/wOAS00ZpY9mcQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "\n",
    "pos = 0\n",
    "\n",
    "ind_IG_sep_last = [ind_greedy_IG_trails[i][-1] for i in range(n)]\n",
    "plt.bar(np.arange(n) + pos*n, ind_IG_sep_last, label='indiv')\n",
    "pos += 1\n",
    "\n",
    "for i, IG_sep_trail in enumerate([greedy_IG_sep_trail_1, greedy_IG_sep_trail_2, greedy_IG_sep_trail_3, greedy_IG_sep_trail_4]):\n",
    "    plt.bar(np.arange(n)+pos*n, IG_sep_trail[-1], label='greedy'+str(i+1))\n",
    "    pos += 1\n",
    "\n",
    "for IG_sep_trail, name in zip([greedy_IGsum_sep_trail, dynamic_beta_sep_trail, joint_IG_sep_trail, entropy_IG_sep_trail, rand_IG_sep_trail], \n",
    "                              ['greedySum', 'dynamicBeta', 'joint','rand','entropy']):\n",
    "    plt.bar(np.arange(n)+pos*n, IG_sep_trail[-1], label=name)\n",
    "    pos+=1\n",
    "    \n",
    "\n",
    "plt.legend(ncol=2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "97c7b3d785e3165328378232188d40ba48f1e1876754d322a4fc788ba956612f"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}