DL_eqcct_comp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e1a28737-d045-4b6e-a723-154458d02c88",
   "metadata": {},
   "source": [
    "# Here is a small-scale example for comparing deep-learning models (EQCCT architecture) for P/S wave arrival picking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e6628b03-11e1-4ae5-820c-d9360626946f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# References:\n",
    "# Saad, O.M., Chen, Y.F., Siervo, D., Zhang, F., Savvaidis, A., Huang, G., Igonin, N., Fomel, S., and Chen, Y., (2023), as a highly accurate and generalizable machine-learning seismic event detection algorithm, IEEE TGRS.\n",
    "# Chen et al., 2024, Near Real‐Time Earthquake Monitoring in Texas Using the Highly Precise Deep Learning Phase Picker, Earth and Space Science, 11, e2024EA003890.\n",
    "# Cui, Y., M. Bai, J. Wu, and Y. Chen, 2025, Earthquake signal detection using a multiscale feature fusion network with hybrid attention mechanism, GJI, 988-1008\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "64d6d1e7-0c7e-4890-b529-1b74a8dee8f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#conda activate eqp (eqpolarity or eqpicking environment)\n",
    "\n",
    "# First set up the environment and install the dependency packages (tested on CPU machine)\n",
    "# \n",
    "# conda create -n eqp python=3.11.7\n",
    "# conda activate eqp\n",
    "# conda install ipython notebook\n",
    "# pip install matplotlib==3.8.0 tensorflow==2.14.0 scikit-learn==1.2.2 seaborn==0.13.2 \n",
    "# \n",
    "# Or, on machine with a GPU setup, use the following commands\n",
    "# conda create -n eqp python=3.10.14\n",
    "# conda activate eqp\n",
    "# conda install ipython notebook\n",
    "# pip install matplotlib==3.8.0 tensorflow==2.11.0 scikit-learn==1.2.2 seaborn==0.13.2 \n",
    "# conda install -c anaconda cudnn==8.2.1\n",
    "# Make sure LD_LIBRARY_PATH includes ~/anaconda3/envs/eqp/lib (libcudnn.so.8)\n",
    "\n",
    "\n",
    "# import library\n",
    "import numpy as np\n",
    "import h5py\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e25fc895-c20c-451e-87d4-476140f4bb40",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['texnet2023gbrs_PB07_EV' 'texnet2021dnwp_MB08_EV'\n",
      " 'texnet2022digx_PB09_EV' 'texnet2017mwov_SN02_EV'\n",
      " 'texnet2022rmkb_PB01_EV' 'texnet2019itit_735B_EV'\n",
      " 'texnet2017enjo_FW16_EV' 'texnet2022mqlw_PB18_EV'\n",
      " 'texnet2023mhma_CV01_EV' 'texnet2021sxqr_PB16_EV']\n"
     ]
    }
   ],
   "source": [
    "# Load the TXED dataset\n",
    "# please down load the TXED from: https://drive.google.com/drive/folders/1WXVB8ytNB4bOaZ97oq6OmMRyAEg95trp?usp=sharing\n",
    "f_txed = h5py.File(\"/Users/chenyk/DATALIB/TXED/TXED_20231111.h5\", 'r')\n",
    "txed_signal_id = np.load(\"/Users/chenyk/DATALIB/TXED/ID_20231111.npy\", 'r')[0:100000].copy()\n",
    "np.random.seed(20232425)\n",
    "np.random.shuffle(txed_signal_id)\n",
    "# txed_signal_id=txed_signal_id[0:50000].  # this is used for training\n",
    "txed_signal_id=txed_signal_id[50000:55000] # this is completely independent testing\n",
    "print(txed_signal_id[0:10]) #see if the random IDs are the same\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "167f0c57-4789-475b-9b2b-f93bc511baf4",
   "metadata": {},
   "source": [
    "# Design a DL architecture for P/S arrival picking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d8c3a297",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Define a band-pass filter\n",
    "\n",
    "from scipy.signal import butter, lfilter, lfilter_zi\n",
    "\n",
    "def butter_bandpass(lowcut, highcut, fs, order=5):\n",
    "    nyq = 0.5 * fs\n",
    "    low = lowcut / nyq\n",
    "    high = highcut / nyq\n",
    "    b, a = butter(order, [low, high], btype='band')\n",
    "    return b, a\n",
    "    \n",
    "def bandpass_filter(data, lowcut, highcut, fs, order=5):\n",
    "    b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n",
    "    zi = lfilter_zi(b, a)\n",
    "    y,zo = lfilter(b, a, data, zi=zi*data[0])\n",
    "    return y\n",
    "\n",
    "def generate_first_arrival_labels(p_indx, s_indx, sample_num):\n",
    "    \"\"\"\n",
    "    Generate labels for P-wave and S-wave first arrival picking.\n",
    "\n",
    "    Parameters:\n",
    "        p_indx (float): Arrival time of P-wave.\n",
    "        s_indx (float): Arrival time of S-wave.\n",
    "        sample_num (float): Total duration of the seismic signal.\n",
    "\n",
    "    Returns:\n",
    "        np.array: Array of labels indicating P-wave, S-wave, or neither.\n",
    "    \"\"\"\n",
    "    all_time = np.linspace(0, sample_num, sample_num)\n",
    "    #print(sample_num, all_time.shape)\n",
    "    p_wave_arrival_time = p_indx  # P-wave arrival time (in seconds)\n",
    "    s_wave_arrival_time = s_indx  # S-wave arrival time (in seconds)\n",
    "    \n",
    "    # Create Gaussian-shaped labels for P-wave and S-wave arrivals\n",
    "    sigma = 10 # Standard deviation of the Gaussian\n",
    "    p_wave_label = np.exp(-(all_time - p_wave_arrival_time)**2 / (2 * sigma**2))  # Gaussian label for P-wave\n",
    "    s_wave_label = np.exp(-(all_time - s_wave_arrival_time)**2 / (2 * sigma**2))  # Gaussian label for S-wave\n",
    "\n",
    "    return p_wave_label, s_wave_label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bede1813",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------arrival time calculation begin-------------------\n",
      "-----------arrival time calculation end-------------------\n",
      "shape of arrivals: (5000,)\n",
      "-----------signal format convert begin-------------------\n",
      "-----------signal format convert finish-------------------\n",
      "(5000, 6000, 3)\n",
      "Processed_num: 0\t P_arrival_time: 142\t S_arrival_time: 759\t sample_num: 6000\n"
     ]
    }
   ],
   "source": [
    "# obtain the P- and S-wave arrivals\n",
    "P_arrival_list = []\n",
    "S_arrival_list = []\n",
    "print('-----------arrival time calculation begin-------------------')\n",
    "for key in txed_signal_id:\n",
    "    if key in f_txed:   \n",
    "        dataset = f_txed.get(key)\n",
    "        P_arrival_list.append(int(dataset.attrs['p_arrival_sample']))\n",
    "        S_arrival_list.append(int(dataset.attrs['s_arrival_sample']))\n",
    "P_arrival_list = np.array(P_arrival_list)\n",
    "S_arrival_list = np.array(S_arrival_list)\n",
    "P_phase_label_indx = P_arrival_list\n",
    "S_phase_label_indx = S_arrival_list\n",
    "P_phase_label_indx = np.reshape(P_phase_label_indx, [P_phase_label_indx.shape[0], 1])\n",
    "S_phase_label_indx = np.reshape(S_phase_label_indx, [S_phase_label_indx.shape[0], 1])\n",
    "phase_label_indx = np.concatenate([P_phase_label_indx, S_phase_label_indx], axis=-1)\n",
    "print('-----------arrival time calculation end-------------------')\n",
    "print(f'shape of arrivals: {P_arrival_list.shape}')\n",
    "\n",
    "\n",
    "# apply the bandpass and normalize to each waveform\n",
    "signal_list = []\n",
    "print('-----------signal format convert begin-------------------')\n",
    "for key in txed_signal_id:\n",
    "    if key in f_txed:   \n",
    "        dataset = f_txed.get(key)\n",
    "        datas = dataset['data']\n",
    "        datas = np.array(datas)\n",
    "        datas_0 = bandpass_filter(datas[:,0], 1, 45, 100, order=3)\n",
    "        datas_1 = bandpass_filter(datas[:,1], 1, 45, 100, order=3)\n",
    "        datas_2 = bandpass_filter(datas[:,2], 1, 45, 100, order=3)\n",
    "        datas = np.vstack([datas_0, datas_1, datas_2])\n",
    "        signal_list.append(datas) \n",
    "signal_values = np.array(signal_list)\n",
    "bp_signal= np.transpose(signal_values, [0, 2, 1])\n",
    "\n",
    "\n",
    "#Normalized trace-by-trace\n",
    "max_values_per_event = np.max(bp_signal, axis=1)\n",
    "# Normalize each component of each event by dividing by its maximum value\n",
    "normalized_phase_data = bp_signal / max_values_per_event[:, np.newaxis, :]\n",
    "print('-----------signal format convert finish-------------------')\n",
    "print(bp_signal.shape)\n",
    "\n",
    "p_wave_label = []\n",
    "s_wave_label = []\n",
    "for i in range (normalized_phase_data.shape[0]):\n",
    "    # Example usage:\n",
    "    p_indx = P_arrival_list[i]  # Arrival time of P-wave (in seconds)\n",
    "    s_indx = S_arrival_list[i]  # Arrival time of S-wave (in seconds)    \n",
    "    sample_num = 6000  # Sampling rate of seismic signal (in Hz)\n",
    "    #print(f'Processed_num:{i}\\t P_arrival_time: {p_indx}\\t S_arrival_time: {s_indx}\\t sample_num: {sample_num}')\n",
    "    if i % 5000 == 0:\n",
    "        print(f'Processed_num: {i}\\t P_arrival_time: {p_indx}\\t S_arrival_time: {s_indx}\\t sample_num: {sample_num}')\n",
    "    \n",
    "    # Generate labels for P-wave and S-wave first arrival picking\n",
    "    p_labels, s_labels = generate_first_arrival_labels(p_indx, s_indx, sample_num)\n",
    "    p_wave_label.append(p_labels)  \n",
    "    s_wave_label.append(s_labels)\n",
    "p_wave_label = np.array(p_wave_label)\n",
    "s_wave_label = np.array(s_wave_label)\n",
    "phase_label = np.concatenate([np.reshape(p_wave_label, [p_wave_label.shape[0], p_wave_label.shape[1], 1]), \\\n",
    "                              np.reshape(s_wave_label, [s_wave_label.shape[0], s_wave_label.shape[1], 1])], axis=-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f5995de3-128e-4184-becc-18943d7961eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_test_phase shape (5000, 6000, 3) y_test_phase shape (5000, 6000, 2)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Data splitting for EQ detection\n",
    "# X_train_phase, X_test_phase, y_train_phase, y_test_phase = train_test_split(normalized_phase_data, phase_label, test_size=0.15, random_state=202404)\n",
    "\n",
    "X_test_phase=normalized_phase_data\n",
    "y_test_phase=phase_label\n",
    "\n",
    "print('X_test_phase shape', X_test_phase.shape,'y_test_phase shape', y_test_phase.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8cf5c1f6-3eeb-4e4a-a4ed-e7ef678aa573",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below example is from \n",
    "# Cui, Y., M. Bai, J. Wu, and Y. Chen, 2025, Earthquake signal detection using a multiscale feature fusion network with hybrid attention mechanism, GJI, 988-1008\n",
    "#\n",
    "\n",
    "from keras.layers import Input, Dense, Conv1D, Dropout, Activation, Flatten, RepeatVector\n",
    "from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau,LearningRateScheduler, CSVLogger\n",
    "from keras.layers import concatenate,LeakyReLU,GlobalAveragePooling1D,Multiply,Reshape,Lambda,Add,GRU\n",
    "from keras.layers import BatchNormalization,UpSampling1D,Layer,Embedding,MultiHeadAttention,LayerNormalization\n",
    "from keras.models import Model\n",
    "# from keras.optimizers import Adam\n",
    "from keras.optimizers.legacy import Adam\n",
    "from keras import backend as K\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "image_size = 6000  \n",
    "patch_size = 40  # Size of the patches to be extract from the input images\n",
    "num_patches = (image_size // patch_size)\n",
    "projection_dim = 40\n",
    "stochastic_depth_rate = 0.1\n",
    "transformer_layers = 4\n",
    "num_heads = 4\n",
    "transformer_units = [\n",
    "    projection_dim,\n",
    "    projection_dim,\n",
    "]  # Size of the transformer layers\n",
    "\n",
    "class Patches(Layer):\n",
    "    def __init__(self, patch_size, **kwargs):\n",
    "        super(Patches, self).__init__()\n",
    "        self.patch_size = patch_size\n",
    "\n",
    "    def get_config(self):\n",
    "        config = super().get_config().copy()\n",
    "        config.update({\n",
    "            'patch_size' : self.patch_size, \n",
    "            \n",
    "        })\n",
    "        \n",
    "        return config\n",
    "        \n",
    "    def call(self, images):\n",
    "        batch_size = tf.shape(images)[0]\n",
    "        patches = tf.image.extract_patches(\n",
    "            images=images,\n",
    "            sizes=[1, self.patch_size, 1, 1],\n",
    "            strides=[1, self.patch_size, 1, 1],\n",
    "            rates=[1, 1, 1, 1],\n",
    "            padding=\"VALID\",\n",
    "        )\n",
    "        patch_dims = patches.shape[-1]\n",
    "        patches = tf.reshape(patches, [batch_size, -1, patch_dims])\n",
    "        return patches\n",
    "\n",
    "\n",
    "class PatchEncoder(Layer):\n",
    "    def __init__(self, num_patches, projection_dim, **kwargs):\n",
    "        super(PatchEncoder, self).__init__()\n",
    "        self.num_patches = num_patches\n",
    "        self.projection = Dense(units=projection_dim)\n",
    "        self.position_embedding = Embedding(\n",
    "            input_dim=num_patches, output_dim=projection_dim\n",
    "        )\n",
    "\n",
    "    def get_config(self):\n",
    "        config = super().get_config().copy()\n",
    "        config.update({\n",
    "            'num_patches' : self.num_patches, \n",
    "            'projection_dim' : projection_dim, \n",
    "            \n",
    "        })\n",
    "        \n",
    "        return config\n",
    "    \n",
    "    def call(self, patch):\n",
    "        positions = tf.range(start=0, limit=self.num_patches, delta=1)\n",
    "        encoded = self.projection(patch) + self.position_embedding(positions)\n",
    "        \n",
    "        #print(patch,positions)\n",
    "        #temp = self.position_embedding(positions)\n",
    "        #temp = tf.reshape(temp,(1,int(temp.shape[0]),int(temp.shape[1])))\n",
    "        #encoded = Add()([self.projection(patch), temp])\n",
    "        #print(temp,encoded)\n",
    "        \n",
    "        return encoded\n",
    "\n",
    "# Referred from: github.com:rwightman/pytorch-image-models.\n",
    "class StochasticDepth(Layer):\n",
    "    def __init__(self, drop_prop, **kwargs):\n",
    "        super(StochasticDepth, self).__init__(**kwargs)\n",
    "        self.drop_prob = drop_prop\n",
    "\n",
    "    def call(self, x, training=None):\n",
    "        if training:\n",
    "            keep_prob = 1 - self.drop_prob\n",
    "            shape = (tf.shape(x)[0],) + (1,) * (len(tf.shape(x)) - 1)\n",
    "            random_tensor = keep_prob + tf.random.uniform(shape, 0, 1)\n",
    "            random_tensor = tf.floor(random_tensor)\n",
    "            return (x / keep_prob) * random_tensor\n",
    "        return x\n",
    "\n",
    "def convF1(inpt, D1, fil_ord, Dr):\n",
    "\n",
    "    channel_axis = 1 if K.image_data_format() == \"channels_first\" else -1\n",
    "    #filters = inpt._keras_shape[channel_axis]\n",
    "    filters = int(inpt.shape[-1])\n",
    "    \n",
    "    #infx = Activation(tf.nn.gelu')(inpt)\n",
    "    pre = Conv1D(filters,  fil_ord, strides =(1), padding='same',kernel_initializer='he_normal')(inpt)\n",
    "    pre = BatchNormalization()(pre)    \n",
    "    pre = Activation(tf.nn.gelu)(pre)\n",
    "    \n",
    "    #shared_conv = Conv1D(D1,  fil_ord, strides =(1), padding='same')\n",
    "    \n",
    "    inf  = Conv1D(filters,  fil_ord, strides =(1), padding='same',kernel_initializer='he_normal')(pre)\n",
    "    inf = BatchNormalization()(inf)    \n",
    "    inf = Activation(tf.nn.gelu)(inf)\n",
    "    inf = Add()([inf,inpt])\n",
    "    \n",
    "    inf1  = Conv1D(D1,  fil_ord, strides =(1), padding='same',kernel_initializer='he_normal')(inf)\n",
    "    inf1 = BatchNormalization()(inf1)  \n",
    "    inf1 = Activation(tf.nn.gelu)(inf1)    \n",
    "    encode = Dropout(Dr)(inf1)\n",
    "\n",
    "    return encode\n",
    "\n",
    "def mlp(x, hidden_units, dropout_rate):\n",
    "    for units in hidden_units:\n",
    "        x = Dense(units, activation=tf.nn.gelu)(x)\n",
    "        #x = Dense(units, activation='relu')(x)\n",
    "        x = Dropout(dropout_rate)(x)\n",
    "    return x\n",
    "    \n",
    "def create_cct_modelP(inputs):\n",
    "\n",
    "    inputs1 = convF1(inputs,   10, 11, 0.1)\n",
    "    inputs1 = convF1(inputs1, 20, 11, 0.1)\n",
    "    inputs1 = convF1(inputs1, 40, 11, 0.1)\n",
    "    \n",
    "    inputreshaped = Reshape((6000,1,40))(inputs1)\n",
    "    # Create patches.\n",
    "    patches = Patches(patch_size)(inputreshaped)\n",
    "    # Encode patches.\n",
    "    encoded_patches = PatchEncoder(num_patches, projection_dim)(patches)\n",
    "    #print('done')\n",
    "        \n",
    "    # Calculate Stochastic Depth probabilities.\n",
    "    dpr = [x for x in np.linspace(0, stochastic_depth_rate, transformer_layers)]\n",
    "\n",
    "    # Create multiple layers of the Transformer block.\n",
    "    for i in range(transformer_layers):\n",
    "\n",
    "        # Layer normalization 1.\n",
    "        x1 = LayerNormalization(epsilon=1e-6)(encoded_patches)\n",
    "\n",
    "        # Create a multi-head attention layer.\n",
    "        attention_output = MultiHeadAttention(\n",
    "            num_heads=num_heads, key_dim=projection_dim, dropout=0.1\n",
    "        )(x1, x1)\n",
    "    \n",
    "\n",
    "        # Skip connection 1.\n",
    "        attention_output = StochasticDepth(dpr[i])(attention_output)\n",
    "        x2 = Add()([attention_output, encoded_patches])\n",
    "\n",
    "        # Layer normalization 2.\n",
    "        x3 = LayerNormalization(epsilon=1e-6)(x2)\n",
    "\n",
    "        # MLP.\n",
    "        x3 = mlp(x3, hidden_units=transformer_units, dropout_rate=0.1)\n",
    "\n",
    "        # Skip connection 2.\n",
    "        x3 = StochasticDepth(dpr[i])(x3)\n",
    "        encoded_patches = Add()([x3, x2])\n",
    "\n",
    "    # Apply sequence pooling.\n",
    "    representation = LayerNormalization(epsilon=1e-6)(encoded_patches)\n",
    "    #print(representation)\n",
    "\n",
    "    return representation\n",
    "\n",
    "\n",
    "#The S Model\n",
    "def create_cct_modelS(inputs):\n",
    "\n",
    "    inputs1 = convF1(inputs,   10, 11, 0.1)\n",
    "    inputs1 = convF1(inputs1, 20, 11, 0.1)\n",
    "    inputs1 = convF1(inputs1, 40, 11, 0.1)\n",
    "    \n",
    "    inputreshaped = Reshape((6000,1,40))(inputs1)\n",
    "\n",
    "    # Create patches.\n",
    "    patches = Patches(patch_size)(inputreshaped)\n",
    "    # Encode patches.\n",
    "    encoded_patches = PatchEncoder(num_patches, projection_dim)(patches)\n",
    "    #print('done')\n",
    "        \n",
    "    # Calculate Stochastic Depth probabilities.\n",
    "    dpr = [x for x in np.linspace(0, stochastic_depth_rate, transformer_layers)]\n",
    "\n",
    "    # Create multiple layers of the Transformer block.\n",
    "    for i in range(transformer_layers):\n",
    "        encoded_patches = convF1(encoded_patches, 40,11, 0.1)\n",
    "        # Layer normalization 1.\n",
    "        x1 = LayerNormalization(epsilon=1e-6)(encoded_patches)\n",
    "\n",
    "        # Create a multi-head attention layer.\n",
    "        attention_output = MultiHeadAttention(\n",
    "            num_heads=num_heads, key_dim=projection_dim, dropout=0.1\n",
    "        )(x1, x1)\n",
    "        attention_output = convF1(attention_output, 40,11, 0.1)\n",
    "    \n",
    "\n",
    "        # Skip connection 1.\n",
    "        attention_output = StochasticDepth(dpr[i])(attention_output)\n",
    "        x2 = Add()([attention_output, encoded_patches])\n",
    "\n",
    "        # Layer normalization 2.\n",
    "        x3 = LayerNormalization(epsilon=1e-6)(x2)\n",
    "\n",
    "        # MLP.\n",
    "        x3 = mlp(x3, hidden_units=transformer_units, dropout_rate=0.1)\n",
    "\n",
    "        # Skip connection 2.\n",
    "        x3 = StochasticDepth(dpr[i])(x3)\n",
    "        encoded_patches = Add()([x3, x2])\n",
    "\n",
    "    # Apply sequence pooling.\n",
    "    representation = LayerNormalization(epsilon=1e-6)(encoded_patches)\n",
    "    #print(representation)\n",
    "\n",
    "    return representation\n",
    "    \n",
    "# Model CCT\n",
    "inputs = Input(shape=(6000, 3))\n",
    "\n",
    "#featuresP = create_cct_model(inputs)\n",
    "#featuresS = create_cct_model(inputs)\n",
    "\n",
    "\n",
    "#logitp  = Dense(6000 ,activation='sigmoid', kernel_initializer='he_normal',name='picker_P1')(featuresP)\n",
    "#logits  = Dense(6000 ,activation='sigmoid', kernel_initializer='he_normal',name='picker_S1')(featuresS)\n",
    "#logitp = Reshape((6000,1), name='picker_P')(logitp)\n",
    "#logits = Reshape((6000,1), name='picker_S')(logits)\n",
    "\n",
    "\n",
    "featuresP = create_cct_modelP(inputs)\n",
    "featuresP = Reshape((6000,1))(featuresP)\n",
    "\n",
    "featuresS = create_cct_modelS(inputs)\n",
    "featuresS = Reshape((6000,1))(featuresS)\n",
    "\n",
    "logitp  = Conv1D(1,  15, strides =(1), padding='same',activation='sigmoid', kernel_initializer='he_normal',name='picker_P')(featuresP)\n",
    "logits  = Conv1D(1,  15, strides =(1), padding='same',activation='sigmoid', kernel_initializer='he_normal',name='picker_S')(featuresS)\n",
    "\n",
    "\n",
    "\n",
    "modelP = Model(inputs=[inputs], outputs=[logitp])\n",
    "modelS = Model(inputs=[inputs], outputs=[logits])\n",
    "\n",
    "picking_model = Model(inputs=[inputs], outputs=[logitp,logits])\n",
    "# picking_model.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0d7c004-a00e-4287-8d4d-10fb58ff8b9f",
   "metadata": {},
   "source": [
    "# Loading different models (of the same architecture) trained in different scenarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3aae6808-3961-4776-a62c-9b4ac6a4f4fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "157/157 [==============================] - 21s 129ms/step\n",
      "157/157 [==============================] - 22s 138ms/step\n"
     ]
    }
   ],
   "source": [
    "from keras import backend as K\n",
    "from keras.models import load_model\n",
    "\n",
    "# In the current stage, two models are the same, compare your own two EQCCT models\n",
    "model1='smalldata/EQCCT_best_model_50000_20epochs_20250221.h5'\n",
    "model2='smalldata/EQCCT_best_model_50000_20epochs_20250221.h5'\n",
    "\n",
    "\n",
    "picking_model1=picking_model;\n",
    "picking_model2=picking_model;\n",
    "picking_model1.load_weights(model1)\n",
    "picking_model2.load_weights(model2)\n",
    "\n",
    "# Different from below\n",
    "# picking_model1=load_model(model1) \n",
    "# picking_model2=load_model(model2)\n",
    "\n",
    "test_phase_out1 = picking_model1.predict(X_test_phase)\n",
    "test_phase_out2 = picking_model2.predict(X_test_phase)\n",
    "\n",
    "test_phase_out1=np.concatenate(test_phase_out1,axis=2); #this is an additional step compared with many other pickers\n",
    "test_phase_out2=np.concatenate(test_phase_out2,axis=2); #this is an additional step compared with many other pickers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "75bcc62d-2ef9-400a-8c9d-0679b7de0fb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model1: MAE and $sigma$ of p: 0.3813s\t1.2281s\n",
      "MAE and $sigma$ of s: 0.5696s\t2.7817s\n"
     ]
    }
   ],
   "source": [
    "def to_numpy(array):\n",
    "    array = np.array(array)\n",
    "    return array\n",
    "\n",
    "def cal_mae_and_sigma(test_phase_out):\n",
    "    pre_indx_p = []\n",
    "    pre_indx_s = []\n",
    "    lab_indx_p = []\n",
    "    lab_indx_s = []\n",
    "    for i in range (test_phase_out.shape[0]):\n",
    "        # print(y_test_phase[i, :, :0].shape)\n",
    "        pre_ind_p = np.argmax(test_phase_out[i, :, 0])\n",
    "        pre_ind_s = np.argmax(test_phase_out[i, :, 1])\n",
    "        lab_ind_p = np.argmax(y_test_phase[i, :, 0])\n",
    "        lab_ind_s = np.argmax(y_test_phase[i, :, 1])\n",
    "        pre_indx_p.append(pre_ind_p)\n",
    "        pre_indx_s.append(pre_ind_s)\n",
    "        lab_indx_p.append(lab_ind_p)\n",
    "        lab_indx_s.append(lab_ind_s) \n",
    "    \n",
    "    pre_indx_p = to_numpy(pre_indx_p)\n",
    "    pre_indx_s = to_numpy(pre_indx_s)\n",
    "    lab_indx_p = to_numpy(lab_indx_p)\n",
    "    lab_indx_s = to_numpy(lab_indx_s)\n",
    "\n",
    "    err_indx_p = lab_indx_p - pre_indx_p\n",
    "    err_indx_p = err_indx_p/100\n",
    "    err_indx_s = lab_indx_s - pre_indx_s\n",
    "    err_indx_s = err_indx_s/100\n",
    "\n",
    "    # xx = 2\n",
    "    # err_indx_p[(err_indx_p > xx) | (err_indx_p < -xx)] = 0\n",
    "    # err_indx_s[(err_indx_s > xx) | (err_indx_s < -xx)] = 0\n",
    "\n",
    "    mae_p = np.mean(np.abs(err_indx_p - np.mean(err_indx_p)))\n",
    "    sigma_p = np.std(err_indx_p)\n",
    "    mae_s = np.mean(np.abs(err_indx_s - np.mean(err_indx_s)))\n",
    "    sigma_s = np.std(err_indx_s)\n",
    "\n",
    "    return mae_p,mae_s,sigma_p,sigma_s,err_indx_p,err_indx_s\n",
    "\n",
    "mae_p,mae_s,sigma_p,sigma_s,err_indx_p,err_indx_s=cal_mae_and_sigma(test_phase_out1)\n",
    "print(f'Model1: MAE and $sigma$ of p: {mae_p:.4f}s\\t{sigma_p:.4f}s\\nMAE and $sigma$ of s: {mae_s:.4f}s\\t{sigma_s:.4f}s')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d41e5af6-8fab-402c-a8f1-e323ffa9de6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig_path = './figs/'\n",
    "import os\n",
    "os.makedirs(fig_path , exist_ok=True)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(10, 3))  # Set figure size\n",
    "ax = plt.subplot(121)\n",
    "plt.hist(err_indx_p, bins=30, color='palegoldenrod', edgecolor='black', alpha=0.7)  # Adjust bins, color, edgecolor, and transparency\n",
    "plt.xlabel('Picking error (s)', fontsize=12, fontweight='bold')  # Add x-axis label with custom font size\n",
    "plt.ylabel('Count', fontsize=12, fontweight='bold')  # Add y-axis label with custom font size\n",
    "plt.xticks(fontsize=10, fontweight='bold')  # Set font size for x-axis ticks\n",
    "plt.yticks(fontsize=10, fontweight='bold')  # Set font size for y-axis ticks\n",
    "plt.text(0.2, 0.8, f'MAE={mae_p:.2f} s\\n$\\sigma$={sigma_p:.2f} s', fontsize=10, fontweight='bold', ha='center', va='center', transform=ax.transAxes)\n",
    "plt.grid(axis='y', linestyle='--', alpha=0.5)  # Add grid lines with custom style and transparency\n",
    "plt.legend(['Pwave'], prop={'weight': 'bold'})\n",
    "plt.title('Model 1');\n",
    "ax = plt.subplot(122)\n",
    "plt.hist(err_indx_s, bins=30, color='skyblue', edgecolor='black', alpha=0.7)  # Adjust bins, color, edgecolor, and transparency\n",
    "plt.xlabel('Picking error (s)', fontsize=12, fontweight='bold')  # Add x-axis label with custom font size\n",
    "plt.ylabel('Count', fontsize=12, fontweight='bold')  # Add y-axis label with custom font size\n",
    "plt.xticks(fontsize=10, fontweight='bold')  # Set font size for x-axis ticks\n",
    "plt.yticks(fontsize=10, fontweight='bold')  # Set font size for y-axis ticks\n",
    "plt.text(0.2, 0.8, f'MAE={mae_s:.2f} s\\n$\\sigma$={sigma_s:.2f} s', fontsize=10, fontweight='bold', ha='center', va='center', transform=ax.transAxes)\n",
    "plt.grid(axis='y', linestyle='--', alpha=0.5)  # Add grid lines with custom style and transparency\n",
    "plt.legend(['Swave'], prop={'weight': 'bold'})\n",
    "plt.title('Model 1');\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(f'{fig_path}Arrival_picking_testing_data_model1.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b519f61e-320a-4e75-a76d-fd77b4cb6b5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model2: MAE and $sigma$ of p: 0.3813s\t1.2281s\n",
      "MAE and $sigma$ of s: 0.5696s\t2.7817s\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mae_p,mae_s,sigma_p,sigma_s,err_indx_p,err_indx_s=cal_mae_and_sigma(test_phase_out2)\n",
    "print(f'Model2: MAE and $sigma$ of p: {mae_p:.4f}s\\t{sigma_p:.4f}s\\nMAE and $sigma$ of s: {mae_s:.4f}s\\t{sigma_s:.4f}s')\n",
    "\n",
    "plt.figure(figsize=(10, 3))  # Set figure size\n",
    "ax = plt.subplot(121)\n",
    "plt.hist(err_indx_p, bins=30, color='palegoldenrod', edgecolor='black', alpha=0.7)  # Adjust bins, color, edgecolor, and transparency\n",
    "plt.xlabel('Picking error (s)', fontsize=12, fontweight='bold')  # Add x-axis label with custom font size\n",
    "plt.ylabel('Count', fontsize=12, fontweight='bold')  # Add y-axis label with custom font size\n",
    "plt.xticks(fontsize=10, fontweight='bold')  # Set font size for x-axis ticks\n",
    "plt.yticks(fontsize=10, fontweight='bold')  # Set font size for y-axis ticks\n",
    "plt.text(0.2, 0.8, f'MAE={mae_p:.2f} s\\n$\\sigma$={sigma_p:.2f} s', fontsize=10, fontweight='bold', ha='center', va='center', transform=ax.transAxes)\n",
    "plt.grid(axis='y', linestyle='--', alpha=0.5)  # Add grid lines with custom style and transparency\n",
    "plt.legend(['Pwave'], prop={'weight': 'bold'},loc='lower left')\n",
    "plt.title('Model 2');\n",
    "\n",
    "ax = plt.subplot(122)\n",
    "plt.hist(err_indx_s, bins=30, color='skyblue', edgecolor='black', alpha=0.7)  # Adjust bins, color, edgecolor, and transparency\n",
    "plt.xlabel('Picking error (s)', fontsize=12, fontweight='bold')  # Add x-axis label with custom font size\n",
    "plt.ylabel('Count', fontsize=12, fontweight='bold')  # Add y-axis label with custom font size\n",
    "plt.xticks(fontsize=10, fontweight='bold')  # Set font size for x-axis ticks\n",
    "plt.yticks(fontsize=10, fontweight='bold')  # Set font size for y-axis ticks\n",
    "plt.text(0.2, 0.8, f'MAE={mae_s:.2f} s\\n$\\sigma$={sigma_s:.2f} s', fontsize=10, fontweight='bold', ha='center', va='center', transform=ax.transAxes)\n",
    "plt.grid(axis='y', linestyle='--', alpha=0.5)  # Add grid lines with custom style and transparency\n",
    "plt.legend(['Swave'], prop={'weight': 'bold'})\n",
    "plt.title('Model 2');\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(f'{fig_path}Arrival_picking_testing_data_model2.png')\n",
    "plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "857cd431-3371-4967-ac25-d4e0ccf22ff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Define fancy visualization functions\n",
    "\n",
    "def plot_labels_signals(signal, p_predict, s_predict, p_labels, s_labels, sample_num):\n",
    "    data = signal\n",
    "    p_predict_indx = np.argmax(p_predict)\n",
    "    s_predict_indx = np.argmax(s_predict)\n",
    "    s_labels_indx = np.argmax(s_labels)\n",
    "    p_labels_indx = np.argmax(p_labels)\n",
    "    \n",
    "    time = np.linspace(0, sample_num, sample_num)\n",
    "    fig = plt.figure(figsize=(6, 6))\n",
    "    ax1 = fig.add_subplot(511)\n",
    "    plt.plot(time, data[:,0], 'k',label='Z')\n",
    "    ymin,ymax = ax1.get_ylim()\n",
    "    # plt.vlines(spt,ymin,yma,color='r',linewidth=2)\n",
    "    # plt.vlines(sst,ymin,yma,color='b',linewidth=2)\n",
    "    legend_properties = {'weight':'bold'}\n",
    "    # ymin, ymax = ax1.get_ylim()\n",
    "    print('ymin, ymax:', ymin, ymax)\n",
    "    plt.vlines(p_labels_indx,ymin+0.2,ymax-0.2,color='deepskyblue',linewidth=2)\n",
    "    plt.vlines(s_labels_indx,ymin+0.2,ymax-0.2,color='tomato',linewidth=2)\n",
    "    plt.vlines(p_predict_indx,ymin,ymax,color='tomato',linewidth=2, linestyle='--')\n",
    "    plt.vlines(s_predict_indx,ymin,ymax,color='deepskyblue',linewidth=2, linestyle='--')\n",
    "    plt.legend(loc = 'upper right', borderaxespad=0., prop=legend_properties)\n",
    "    plt.ylabel('Amplitude', fontsize=12)\n",
    "    plt.xlim([0, 6000])\n",
    "    ax1.set_xticklabels([])\n",
    "    # ax1.set_xticks([])\n",
    "    \n",
    "    ax = fig.add_subplot(512) \n",
    "    plt.plot(time, data[:,1], 'k',label='N')\n",
    "    # ymin,ymax = ax1.get_ylim()\n",
    "    plt.vlines(p_labels_indx,ymin+0.2,ymax-0.2,color='deepskyblue',linewidth=2)\n",
    "    plt.vlines(s_labels_indx,ymin+0.2,ymax-0.2,color='tomato',linewidth=2)\n",
    "    plt.vlines(p_predict_indx,ymin,ymax,color='tomato',linewidth=2, linestyle='--')\n",
    "    plt.vlines(s_predict_indx,ymin,ymax,color='deepskyblue',linewidth=2, linestyle='--')\n",
    "    legend_properties = {'weight':'bold'}\n",
    "    plt.legend(loc = 'upper right', borderaxespad=0., prop=legend_properties)\n",
    "    plt.ylabel('Amplitude', fontsize=12) \n",
    "    plt.xlim([0, 6000])\n",
    "    ax.set_xticklabels([])\n",
    "    \n",
    "    ax = fig.add_subplot(513) \n",
    "    plt.plot(time, data[:,2], 'k',label='E')\n",
    "    # ymin,yma = ax1.get_ylim()\n",
    "    # plt.vlines(spt,ymin,yma,color='r',linewidth=2)\n",
    "    # plt.vlines(sst,ymin,yma,color='b',linewidth=2)\n",
    "    legend_properties = {'weight':'bold'}\n",
    "    # ymin, ymax = ax.get_ylim()\n",
    "    plt.vlines(p_labels_indx,ymin+0.2,ymax-0.2,color='deepskyblue',linewidth=2)\n",
    "    plt.vlines(s_labels_indx,ymin+0.2,ymax-0.2,color='tomato',linewidth=2)\n",
    "    plt.vlines(p_predict_indx,ymin,ymax,color='tomato',linewidth=2, linestyle='--')\n",
    "    plt.vlines(s_predict_indx,ymin,ymax,color='deepskyblue',linewidth=2, linestyle='--')\n",
    "    plt.legend(loc = 'upper right', borderaxespad=0., prop=legend_properties)\n",
    "    plt.ylabel('Amplitude', fontsize=12) \n",
    "    plt.xlim([0, 6000])\n",
    "    # plt.ylim([-1, 1])\n",
    "    ymin,yma = ax.get_ylim()\n",
    "    ax.set_xticklabels([])\n",
    "    # ax.set_xticks([])\n",
    "    \n",
    "    ax = fig.add_subplot(514) \n",
    "    plt.plot(time, p_predict, label='P-wave predicted', linestyle='--')\n",
    "    plt.plot(time, s_predict, label='S-wave predicted', linestyle='--')\n",
    "    plt.legend(loc = 'upper right', borderaxespad=0., prop=legend_properties)\n",
    "    plt.ylabel('Probability', fontsize=12) \n",
    "    # plt.xlabel('Sample', fontsize=12) \n",
    "    plt.xlim([0, 6000])\n",
    "    # plt.ylim([-1, 1])\n",
    "    ax.set_xticklabels([])\n",
    "    \n",
    "    ax = fig.add_subplot(515) \n",
    "    plt.plot(time, p_labels, label='P-wave label', linestyle='--')\n",
    "    plt.plot(time, s_labels, label='S-wave label', linestyle='--')\n",
    "    plt.legend(loc = 'upper right', borderaxespad=0., prop=legend_properties)\n",
    "    plt.ylabel('Probability', fontsize=12) \n",
    "    plt.xlabel('Sample', fontsize=12) \n",
    "    plt.xlim([0, 6000])\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3b670cae-7554-475e-a25c-120b8adfb6a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ymin, ymax: -1.232801602705484 1.1063238858431184\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAJOCAYAAABBWYj1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAADvV0lEQVR4nOydB5gURROG63LkjjtyzhnJWRBQEFGJgkSJBhRQRJSgREWMqGBAQTGAv6BIEpCcBZQkIJJzzsflOP/z9dHj7N6G2du8V+/z9O3ubM9M79zuzDdV1VV+iqIoxDAMwzAMw1jF33oXhmEYhmEYBrBwYhiGYRiG0QkLJ4ZhGIZhGJ2wcGIYhmEYhtEJCyeGYRiGYRidsHBiGIZhGIbRCQsnhmEYhmEYnbBwYhiGYRiG0Ukg5XGysrLo0qVLlC9fPvLz83P3cBiGYRjGYde3jIwM8mUCAwPFtTs+Pp6KFy9O/v7OtwfleeEE0VSqVCl3D4NhGIZhHAKExMCBA6ljx44UHBzss0YBRVEoLS2Nli1bRnPnzqVz585RyZIlnb7fPC+cYGkC58+fp6ioKHcPh2EYhmHs4tatW5SYmEiFCxemsLAwnxZOycnJVKFCBYPrubPJ88JJfqEgmlg4MQzDMN5MZmYmXbx4kYoWLUoFChQgXycyMlI8wrrmqtK7DnMGXr58mf7++2+hcl3Jli1bqEOHDsK3CRG0ZMkSl+6fYRiGYTyF9PR08RgeHk55hbCwMOGSdFU8l93CaenSpVS1alXhV6xXrx7t2rVLLL9x4wbVrVvX6UIGQq127dr02WefOXU/XsGaRURLf8h+9DGmnyeadDr7kWEYhrGMr7rnzH1WV35eu4TT8uXLqWvXrlSwYEGaOHGigZkMy0qUKCECtpxJ+/bt6a233qIuXbo4dT9ewdrFRMvnZz/6GBBMk8+ycGIYhmHci13CacqUKfTAAw/Qtm3baOjQoTneb9q0Ke3bt8+eXTCMVSDYjx49Knz7uWHz5s20YcMGh4+LYRiG8T3sEk6HDh2iJ5980uz7RYoUoWvXrpEnkZqaSnfv3jVojHcza9Ys4S7u379/rr4PrVq1ooceekjkAWEYhmHcw6ZNm1S3m7mGPu7Grll1CD6zFAx+6tQpj4vqnzZtGk2ePNndw2AcxLFjx+iFF14Qz+fPn0/z5s2zaf1vv/1WfQ4R7arprAzDMIwhmNneuHFjg2UI+N6zZ494HhISIkKAvNri1Lp1a/ruu+9MRrJfuXKFZs+eTQ8//DB5EmPHjqW4uDi1IX+TzxAVQxRTMPvRxygaTFQiOPtRS5UqVeza7pAhQ/JcMCVmwObWrckwDOMsMMFs586dBg3hQBJMAqtUqRJ5tcVp6tSp1KRJE2rYsCF1795dXHhWr14t4kW+/PJLEXuCoHFPAooVzScZP5N8ld0NnL8Pa8Jp8eLFtG7dOvr4448pKCiIvJGNGzfSgw8+SI899hj99ttv7h4OwzAuANfipKQkt+w7PDw81zel//vf/+ijjz5Sb3IHDx5MnoBdwgl3+wgMf+mll2j8+PHin/P++++L9xA3AnVYtmxZciYJCQl04sQJ9fXp06dp//79FBsbS6VLl6a8BGac3c0gigokGulrVWSQYiE5iSgsnOjhJ5yyC2s1jjCDFCD9xbPPPkveiDwJrVixwt1DYRjGRUA0yUSRriYhIYEiIiJsXu/AgQP09NNPi+fNmjWjGTNmkKdgd+bwGjVqiLvw27dvCwGDooLly5enQoUKkSvYvXu3cBlKRo4cKR4RKKyNX8krwuliWrZLy+eEE1Is3L6R7Yp0knDSe1cEV5c2MB3fM1hvkIKDYRiGsQ/oCaQYguArVqwY/fLLLx5l5XdYyZWYmBjhsnM1sGy5Ks0649voFU7afs8//7yamsOdd0TSFG/tzo5/KwyT94C7DJYfd+3bFmB86d27t5hchmzgixYtEuLJk7BJOH3//fe52km/fv1ytR5jG+9s/4RCkuMpNSwfUbOXyJd4ruYgukVBFEvp9OW9ZfhxWQMniwULFog6RtasoPYEh9uayuDrr78WyWHhzq5YsWKuTNla+vTpI+IB/v33X5GawVs5c+aM+J/VrFnT3UNhGJ8B5zZ7zzGuYvz48fT777+L5zNnzhT5ID0Nm4TTgAEDzF5sjO9ktRchFk6u4aHzf1GxpBt0Odz3XEYrCtehi2GxVCL5lngN6wqEgjUmTZpEH374obgQHzx40KHWGHN1kbAdJNWEG9ucWJO++zp16lB0dDTduXOH7EEeC5xovLn8ULly5cTj1atXRWV3e8D/B4lRq1evnmdmTDKMN7N582aRMggEBgbSN998I5rxuVOeP71COCHwWgtO9oglwol/+PDh6tTwI0eOiBM47sKRroBhnFXIUq+gQLJWa2iFE7aPeoumTMS4CL/22mv06aefmlwX9RkRSI6cJEh5YQ1tH8QJQjBg3dxgTfy5y1WXkpIiZrPqFTDyONgDZvrif/HFF18YpJ1gGMYzOX36tHqOwo2PrH2r5ZFHHiGvyuNUpkwZg4Zp2bijRibPbt260X333ScaTlhYhuSXchYPwziSp556yuHbxA/2+PHj9Mwzz4is98WLFzdbMgizR5OTk3Msf+edd9TZd0ioCevPo48+Sn///bfV/eOGAzlKLPnzkX8JNyu4MQGYQWpLrjRnCCdr27x06ZJILGqpyoAzkAXGYXFkGMbzGTBggDifWGrwInh1AkycmBD5buouElO7cQFZunSpPbtgmBykpaWJAtN6sMVFgx8lRMicOXPErA5gKhO5qW1K8YAEq1qGDRtGq1atEi45iDJLrFmzRjxayreCbSHW8MUXXxSvW7ZsSWvXrs3R7+bNm2ImCkrKTJ8+nV5//XWT24P4Q8utoMJ4YBmylBMKpnbcPWI8DMMw3o5dwgknW9wlm+Pw4cM8i4dxOJh1oRcICFvcewhO1hO8aIye7zlyntkDRFmHDh0MlpmrtYgUHbD8jhkzhl555RV6++236eTJkwZ9/vrrLzHjBQ21+nIDrGlwaRqPy55ZNY5G/m/wXUDogLtmFzEM4xvYJZw6d+4s4gdwR6u9S8ZzmMeRPbxTp06OGCfD6AIXca0wQGyNBHFDEBHmMGURwncbGcMdgT2ZexGrBTegXmQgPNzp2v1rBd64ceMMMoobjxVxRohjhGCzFlhvCb35V0yJT/z/IFT//PNPshdkS4crQNY2ZBiGcblw+uSTT0RGz1GjRok8TsgSjobnr776qijHoj1xM4wjsGTdQcyddK9pg7flRRhCyBxt2rQxuVzGLOV2THotZZa2YSr1AlyKtqLdB9x45sCMQMRbNW/eXAi2WrVq2bwve8amjSV76623chT+tASKPf/88885lstA059++knXdlA6ikMNGIZxqHDCbDpMH8Qd+cCBA6latWqi4Tnin7Zs2UL58+e3ZxcMY7MAQeA43MQoNG1r7JQ5LAku4AiXtHYb2ufm4rkQxG7LOIzf27p1q8FrbdCldFn+888/5AwQQ4ZcLdpiw6Y+v9bSVbduXWEBgzXM3P8KQfN9+/a1GIiud0Ym3Jewqj/++OPiub0pIxjGleSlMBnlXuC4VwgnCdxxKD2BQFE0PEfCQc6dwlgDQcuo/Qahozd2Sc8PBBYTGWxtrlQPUmjoxZKLTy+4mUCKDnOWHu3nwuQK5J6CSMBvSS/GYsjSPoyZPHmyxXVtjQ2ytK/777+f2rdvb5Bt3dr/HzMIEaOERH6Y1WsKGTRvDVjE9YK6frA+eVrBcoax5Bp3V1Ffd4AJLriZQu4nV+CavTAuYWn5lhSYnEAZYZHkrqw1uFjaIpgRtCyFDpKazZ4922S/Xpd20G0lgGL8Mikrq4Xd43R0eSA9Yg4XX8xC1dZWtOR6g7Vn4cKFNo3DWRYi0KNHD93FgWGdqVevnripQu1KY5DhXMZuvfzyy7qPofx+wJqItAw4YSIGC9YoW/jggw/UguSmMDUWbY1CU2AsuGmEhQpuToZxBwEBAcLTc+3aNXVyhq8aMZR7pabwWZctW2b23OpRwglZfq39Q/C+8Wwexjm81egZUeQ3NjPJLcIJMUUQQuvXrxcuW1uBcDAnnN4/8j9R5PdGJtGgVXPtGqczTiKwlui58OPYaAPWtcDqllu3kh5g2bOHlStX6u6LiSFIZocYR61V6fr163T27Fn1tfaYmbI4Gf+vtMJQloBCPNPq1avN5rPKjQnflpmbElikIMZgnczN+q7i/PnzVLJkSZ+9mDJERYsWFY9SPPk6ERERooSVq/JG2iWckEPG+MeHmAWcGLdv3y5cDbbeCTL2c+vWLTp27AJVrlzZpfuVrq9nn33Wqssot0B0LFq0mjwNXCghCvSA34ZetDFAetEKE3dhbtzG2cDNxXXZKnbatWtHO3fuNPu+rULGVH9rY0K8p+yH/zHckea2nZiYKJKCuhqITVjqBg8eLALuUY7G3DgZ7wXXZSTSxe/NkTdfnuqaTExMdGmMk13C6dtvvzX7HjIl42SG4qOM67lwwbJwwo8J8WgtWrQQsyAx9RwndON1kLjQlN8YwggnYGTGRqyKFnvy5Kxbt04UdfSWgpQSuNRsdavpITcByZjZ6g7efPNNNceV3pOYcZkbLbae8Pfu3Wv2ImKuXia+q6h6gJmT+D4jBq1gwYK5Ek7a9zEbEXmjYmNjTd5wIqfXuXPnqFSpUha3iZQaU6ZMEZYsW4o3Qzwj/QZ+21rk/wdFptH0fC5ngJsMHBu4lRjngePLx9gJKE5kwoQJSr169RRPJi4uDmcN8ejtlNiuKLRRUWjheWX9+vXK7du3lTlz5iiXLl0y6JeVlSX+L/jcjRo1UtLS0sRztMTERLXf//73PyUgIED59ddfc+wrMDBQXSczM1Msk69r1KhhcZw3b95UKlWqpLzxxhvqOtr20EMPqX1TU1OzxzSqj6IMbqec79nS5Dre3rTHz51t1qxZSmxsrNn38d05evSo+J//+++/Od7//fffxWd588031WX58uUzu726deuKbV69elUpW7asujw0NNTmsX/22Wcml5cvX97svqtXr66+9vPzE4+dO3dWnn766Rz9ixUrpn4v9+zZI5aNHDlSXdagQQOD/kWLFlVWr16tjB07VsnIyFD7yfc/+OADg9/FkiVLlMOHDxssk31xbPRy8eJFg++VltKlS+f4XH369FFu3Lih5IZdu3YpJUuWVBYsWKCrP74333//vdhvixYtLPbdt2+fcv78+VyNi8lbxLn4Ou5U4YQTGU6AnowvCafjIwcrcUO6KP++2F9ZtWqVemIsXLiwQb8NGzYYnDjlMUDTnqiML+xatO/VqlVLiY+PV1/jYmQKCLRPPvlE6d69uy4hAYoXLy5eV1xyTsm3OkGp8OtZt4sLZzSIB3ePQU+Tguill14y22fHjh1KeHi428dqTTjlpuGGBEAsaJcfOXJEqV+/vtn1Zs+eneO38+GHH6rLNm/erC439zvTy7Jly8yuU6ZMGZPj69+/v3gf43zmmWfUmyFrQEzaMr7Ro0cb7BfnIgmO7aJFi8TzkydP2vy5mbxLnIuv406bVQczNUzBCEJkXENEejJFpSfRXf8QgxlAMkAQsw9Qod7YpYFEpdZiQTCFHvmRUJl60KBBBu8dOHCARowYoSthqt5p4Aj2RW0zFIgFCQGhFB8cQRFpvjnFFgG73oB09eB/aY7XXnvNZ6dCIyHmgw8+aFDKByAb+Z49e8yud+zYsRzLtPGh2nVRWBoJR3PrQsuNa+bUqVMGucGQZR2uUsSpwkX47rvvinxiCxYsENuHCxDnEm1qDUwGwIQhS2A7WnAs5eeUZX+QQ8xccW2G8QTsEk740puLy0ANO+RV+OGHH+zZBZNLjMUR/ic42WFmlXG8h5waDsydrCGCMXsJTVadt2WqNr4LtuTOgUDLS3hCxW9H4ayJAblFigJHALEzZMgQkXrAOKbQEihBVb9+fYPvtTaGSyuikMbBHCiNA5FtLmbLWDhhH9qSN+Zm0uEGBfGFElSDQNwjwE2RrAAhb4SDg4NFQK4WpJ0IDQ0VotKW+oSYCSVTUgDEmslAe4D3MDMbiZbx2S5evChEGuJoEUuGcxr+xwi2R+UAZ6ZP0QPSjmD8EyZM8On4IkVRhMhFTGWem6Fpj7mqZcuWSqtWrQxa69atla5duyqvvvqqiIHwdHzJVXdpeO/sOKAXeuYwxS9cuFCXK+L06dPq9ky5aMy1Rx55xOA1YkRkXAfcUObimfS2osuvifgt8egB7h9HN8SZuHsM3Ky3mjVr2rV+qVKlciyDm/ujjz6yuq72NwmXF1zfpli7dq2B2zwlJUXEniFWsEiRIg47Fnv37jUZD/f222+LceD3j30izgu/f7y2x1W9YsWKHOcltCtXrqjPjx07pgwZMkS4G6VbVXL27FllxIgRwg0o4ycRj/nEE08Y9Bs8eLDy+OOPC5cn4jxtRY5l7ty5iieBmGOESeh1w1pj/Pjx4nNOmTJFcTc+FePkDeQV4aS3TZ06VcQVIehTuzwoKMjmbc2bN0+clBCAbu9J2teFU48ePdw+Bm7ua7Vr17ba588//zR4LS9Yy5cvF6ICNzcIsjeOYXzhhRfEI250XfFZXnnlFeXUqVM5ljds2NDsOjNmzLC63V9++UV8XlvGAvHUqVMn5cKFCwbnIbBu3TqD18CUgLvvvvuUnTt35jjfIkatQ4cOQoBpketBLFoDYhKiFhNmJBDEmFCAOFVjML7cCh85rh9//NFq36SkJBHvhuNmbXtkZxwajl/jxo3FTQluIsyxadMmZdSoUeJGwKuF0+TJk5WDBw+aff/QoUOijyfjS8LpogOEkyPboEGDHLYtXxdO3Lg56jdWoEABt44JwkmPELS1RUREiPOcI7aFiUsPP/ywgYUcFpn09HSz6xw4cECI0oEDBypnzpxRl2OWoAR95HJYZCzx3nvvqX0rV65sMFtTNoAxwWqHa1SXLl1EX4gHiChjMDMT68HqaIx2u3/88Ye4ScYkj2vXruXoC4GCfriJNgcZjVMv06dPN7Dkffnll+p2YC00xngGb3BwcA6x6lXCCdN358+fb/b9n376SfH391c8Gb0HHF9STI9NTk62eR9YF/94rWnd+K7B1I/AViCYPEk4ObKxcOLGzTsahJOztg0riDPH/u6779q8TpUqVYSlTyuapBUZM0xxrpfnezziuijTwWgbMJ6Z2b59e6Vjx445LHZypuiDDz6o/Pzzz8JAgfQz2nW1ViwpqMw1uCalJQdjRCoN+d6JEyeEleqHH34QFrKbN2/msMyZc2nC69C2bVt1LP/884+6zrhx48S2tdvB55LAaglL5FNPPZVjvBBfW7duVR544AGRfsOnhNPnn3/uM+kIkA8J/dq0aSNeQ/FCteNuwBr48sh/OHz++OFgujZyJOEu5/jx40qJEiVEnAPAHYApc6Q1WDhx48aNm2c1xJVFRUUpu3fvtpimA9dSU3m27GkyzktPX2ldatKkidW+48aNM5nSQsaZSbQpa/SIUuQrw3HYtm2bEhkZabafcW44iDqPFk7INwJ1iwbhhBgW+VrbXn75ZfGPgEp2BZ9++qnIURISEiJ82YjRsUU44cDfuXNHqHcIl8WLF4u7CEmdOnXUfxLUM74IeA7BI5dDVGF9BCHeunVLee6552w2WcNnjseKFSuqqhsJKKVF6u+//1beeecdIUoRaArxhsBv+IZZOHHjxo0bN21DvJTevgMGDHDIPo/dE0+u/qweK5wmTZokBBMa3HDyuamGGQumguocDSw48Ht+8803whSIGRX58+c3ED7m0CZ/NNVgUerZ0z1CBCJMPn/22WeVjRs3WuzPwokbN27cuOXVFuci4eSHP7akL0D+EiS3w2ooIDhr1ix64oknDPogpwPyeCCnhytAscqGDRvSp59+qiZxRA0oFJ0dM2aMxXXv3r1L0dHR5As89ulvFBaZj5IT4mnFsMfJl5j72hiKiIikxMQEGvjeO+4eDsMwDONhxMXFiRqNHpcAMywsTDSAJGRIOGZLsjNHg8SKyLo7duxYdZm/vz+1adOGduzYkaM/Mt1qs91COPkKKwrXJipUkui65WR83kibczuoZEQoXUhMcfdQGIZhmDyMvz0rlylTxq2iCdy4cYMyMzOpSJEiBsvx+sqVKzn6T5s2TViYZLNWnZxhGIZhGCZXFifUIYI1B+VUkMYfr62lWsf7SJfvKcAyNXLkSAOLE4snhmEYhmEcLpxatmwphBDEk/a1OylYsKCoB3T16lWD5XhdtGjRHP1RmBLNF6kXd4aC6S6lxd0iw0p13s+BgpXpfEQE3Q5Dfaz/6lgxDMMwjEtRfACkHxg2bJj6Ggm8kCZg2rRpds2qQwoCiZ6I/uHDhxsk6LJ3hgCSg2HmIp6/9dZbouSCcW4L7T55Vh03bty4ccurLc5T0xF4IkhHgPxN3377rXL48GExdR/pCFD8Ua9wQkp75EpCCgAUgUQeJm2mb23m1evXr6t1oyCQ8B4yimN9ZHJFNlOkMRg6dKjIqIrt6P3HI5cU0s6vXLlS7Bfb0aZVwH6QZwr5nL777juDjOMXhrJw4saNGzdutreEhAS71m/cuLHBaz2JNC21/fv3KwsWLPB+4YTkl7lprmDmzJki6yryOcECpTd/lC0lV1DfSJtY01SZFCwztXzNmjXCgoVChdgX8k1J7t69qzRo0ECINnu4MLQXCydu3Ljl+aatf2ZrGzx4sNvHb6l169ZNXC/0FEWWz7UlXmS5FuMGTC1H2RNUypg4caJIat3STLHor776yqAwMq5z8JRo+yBhs/a18fuyaUu1eb1wkkkv9TbZ35PxpSK/niqcUJjS3m2wcOLGjZveZqlYb7FixQwK7GobRAFA/bOqVauaLSuibQULFjS7L3g+UKtNW7wXxgRtJQpLDR4N3Fh/8skn6jLUi0P5FvkaN+WoJoH9aD0XADfq8MSA06dPCy/M77//nmM/EmwbBYKTkpKUr7/+Wlh9rJURo3sNRgVUvDCuXYeQExgypAcHY8LngYEB3htzn11i6j18ZniXwsLCPF844QPnpnkyLJycf+dnrcCknsbCiRu33DXc/Ttz+0FBQTmW/fXXX0rdunXd8nllPVHj5UeOHFFri+JRW5lBWkPgrpI8/fTT6nuoRvHGG2+I5bjgQ1jI91BeTD6Ha6ly5crqaxR3l0CQoLoFQEmShx9+2OQNJsQHrkc3btwwOL9jnxKMAcWUUWpMC863EDXWMLY65YaTJ08KAfjqq6+KsmAAhYZRZ86WovUQVBUqVBBN1sCDsJLIMfbr1099fujQIfEe/meIZ0bYiscKJ1/El4TTxeG97RZOwJEnMfyAjh49avd2WDh5Z7v//vvdPgZ3N21Ve3v6yGaqWry2oaCsoy2+ltqPP/6YY5kWWC7s3QfiZ9atWycm/FjqFxsbq1y4cMHkeUwrPCRyso2piUTaQramQJwp3FcQWxBliHvViort27dbPWdLFxp+J4irhSXs/PnzirPB9W7Lli1C8KC2qqeQlZWlnDt3zmCZVjgtX75cmTVrltuv4w4TTghghqkOTU+NOE/Bl4TTpeF9hHC6OKy3+mV7/vnnhbkVdwV6TlBA+3r8+PG61uvVq5fZ7QHU2TNnHpetVatWZt9j4eSdzVwMQ15q1oJk5d253u09+eSTBq9fe+015f3331dfa7eFYuB6hBNiZlBbVL5GrOhHH31kdT2Mff369QbLUHzcHLYct2rVqol4o99++81gG5h0o+2Hi+mYMWOEAICryXhfmHlsbL2RYB1YK7QTgSRwd0Gkrlq1SnEWly5dUqZOnaprIlNehe79HwcOHGi2j9cJJ9wF1K9fP0d8E5bBNOnp+KJwwiNOIFrljrsi4xOOqQaMX+POy9oFcOvWrepzWRS5Zs2aBuNbvHix2mfkyJE5tvHuu++a3T4LJ+9sb775ptvH4OlWN4ne7X3//fcGFhZcdJcuXWqwPbhM5MVYK5xg1TC1Tbh8zpw5o75GXA2QLhBLYz916pT6GjEnsGSYw9pnK1SokHAjde3a1ew2tOcauASt7Qs3f4z38vbbb4uJX5Ysca6+jttVcmXx4sXUrl07unz5Mr322ms0Z84c0V599VWxrH379qIP43qQFFSbET0iIkItgiwpXbo0bdq0Kce6qPMHJk6cKB6nTp1Kr7/+ukEfrIcko61btxZlbLRJRZEYFeetgwcPGqyD0jiSt956SxSI1oLEqt27d8/lJ2bspWrVqjRq1CjavXu3w7aZP39+8iXmzp1LgwYNsmkdmTAYvPPOO7R+/Xr1dfXq1dXnGzZsoIEDB4ramziPfvnll+p7+L/gNzxhwgTq06cPrV69mq5fvy7KSqG8VIcOHcTvcN26depxNy5DBWJiYkSR9sjISIPlSGRcokQJsR4SB2NfoF+/fhQfH08zZsyg5s2bG6zzyCOPiEdUkMB+//77b9G3RYsWlFtKlixJx48fp19++cVsn4oVK6rPGzRoYHWb7k7SzNhf7ePs2bPiu+Ex2KO6qlevrtSuXVu9O9EC5YegRPTxZHzV4mQOOVMEpniY2ePj43PcQcI6tWHDBjWQUmLqLlmCbcn35CwOY3AHjPdjYmLUZUjLINf78MMPxXYQUGl8J8oWJ+c3pPEw9b+2p2mDaD2tDRgwwKb++M0AY9eUbBERESa3q52+feDAAYPjiwBkc8BqJPvBgmz8e9SL1uIkwf9FO1NLBhmnpKSYdFuBOXPmqP0RAGwqZsgaCxcuFNZmbeLhESNGiLx1TZs2NQimtgTCD2DpskSRIkXE9jGjjfFt4rzJVRcaGqp8/PHHZt/HezDdejK+JJwqb0pU8q1OEI/mwNRQxCPJaabGSc8s8cEHH4g+MN+bAjERHTp0EDk/zIH4N+MTrty3jGWA318uQwAmZor8+9QjStyQLuLR3RdcZza9sWjOaAjANf6fWGuYCWPpfYDp35b6YOatOz4vpmXPnTtXd3/5vYW4N47/QawMvvcyMBmv5XutW7dWnx88eFC836xZM/F6x44dFn9ze/fuFdOu7aFz584G/w9Tvz3j2VmmgHiDyx6iyRHIfTsrpAM39AjaZnyfOG9y1cG0f+3aNbPvw5VTuXJle3bB2EBiUDjFB0eIR3NUqFCBfvzxR6pdu7Z4nX3+0scrr7xCcXFxwnxvihEjRtCyZcsoODjY7DYKFy5MYWFhBsu2b98u3IiPPvqoeA1XQefOnenJJ5+kWrVqUWxsLEWmJ1NUepJ49GXcWUdR61IaMGCArnWWLFlCN2/eNPke3EsABcEljRo1oqeeekp9DZcTXLv58uVTl7399ttkDwgPgBsL29YCt1hKSoqBCwefc+3ateoyhBxoQbiBRH5vsR6+68Zub3zv4e6Sr7Vuc+0+pav7/Pnz1KRJE4ufpW7dulStWjWyh4cfflg8Wvpd6gGfAy77+++/nxyJs1xp+E5VqVLFKdtm8jY2Ffk15r333qOePXuKk2GnTp1ynLzgo1+wYIG9Y2ScSGCgbV+BqKgoh4+hWbNmomlPpNrYOGecWBFj9cYbb5CnoRUv7tz3119/LWJhFi5caPX7A2FrDAQvzg+yj+Tdd98VsTJpaWlCNMiLuilxYY0VK1bQY489lmM51kfxb7ltgJuFXr16GfSTNw0PPfQQPfvss+KmAsIJ4+vYsaN4D9tYtWoV2YOpzwYx6aqYDXy2AgUKUNOmTXO8V758eTp16pTJ4+gqOAaJyVPCaebMmVSoUCHq2rUrFS9eXA3aO3HiBF26dElYmxBUiKb9kSxdutT+kTMOITQ0VARzbt26lTwV4xMrAsh//vlnu7Zpi6UtrwgnrbUL4/j222+FNWjo0KEG/fBbx+9b9jNFsWLF1P9bw4YNxcVZAiH1008/GfQfM2aMaD169NA9XnPWGq1QkWgnShh/BzBObSC2XmA5++GHH6yOWXuM3CEScDxgvTXFv//+K6zIOI8zDOMC4XTgwAFxIpBm6TNnzmRvNDBQLINZ3HhmFd9dOI9nDi0iJTmJ/MLCiZo9oXs9XDS0s3s8ka/u607+kdGUlRBHyr6cMwFtJSsrizwR49lOeklISMj1uhJjFyxcUy+88AJ98cUXdOjQIXU5bozCw8N1/57hhpWWZ3P9MRMX1p2aNWuK8wpm0hgDy9atW7fU19ptTZkyRcw4M3ZJ/f7773T06NEcM8IsiWdYq0ztw9TvBqIJM0s9WThZAsfK3aJJfpcYxmtQ8jh5bVadORCE7amJSxctWmQwq06b0de41ILe4p7I+GvpfcwWReCuI4KQUbPRWp9BgwaJApqm8ux07NjRICmguSBs7WtZnsC4rIO57YwePdpsmYTMzExRcwv9UEYjOTlZXe/48eM59o3Wrl07kzMu9Sb6w0yoa9cMZ1D+8MMPBq+1s860szORbNUSsh9mcpkC450wYYLYnzYI3Fa0/1v5HKU2mGyQ+BHHxpbyHAzj9cHhjO+AmBQEbnsiWkuKv78fjRs3Lkef2bNniyBfxHNYs6r89ddfVl11cDU1btzYIDg4t+g5rogpOnfunMizY0zbtm3V54cPH7YYqK2NJUJszqJFi0z2hSVG675BfiFz1hBYTHbs2EHPP/98Dje7tKYgj8/8+fNNro/tYtz79u0zmVvIFPXq1cthCYFbGRMUtNs19VxvMLW57wC2NXnyZOrbt69B7jFbgTsZuY7wv3jmmWeEi1mbgyivg98xvveeZoVjGKe66iTp6el08eJFun37tsmTEU6CDJNbkJDTb1W2i8bPz19NzmdOXFgCbie4BjD7zxL4HuOEvnLlSnHRQ0LC3KL3wmAcm1OpUiURZwShZ7w9U78zTNLQumBkgsJff/2VnnvuOZEkEUHZuFjhfSSvtRb8rZ1B+/nnn4vnCBo3Fk4IsAZIzgiMx2fvzDC5TXNuLzzHLDW4LPWKMwSDW8Me4dStWzfRwFdffZXr7TAM40PC6c6dO2LKMe40cUI2d/Gx5+TDMLhYWgua1itO5HasxThpL/yY3AARIi+CuQGpFiDCbOGbb74Rsw23bdtmdmx6jkGXLl1EegdH3dlDeGIWbWJiIpUpU4ZcCdIHvP/++yJmSft5IDr1zlKD5QuVDfRMVedzF8MwDhVOOIktX75cpCSAWyM6OtqezTGM02ej6RVOxkHSTzzxhCiJ8eCDD9o8Nlzg8TtBzjO4AI2RuX+MkX31Bs9acj862h2idQu6Yn8STGK4ceOGKA2SnJxscSadOerUqSOaHlg4MQzjUOG0Zs0aevHFF+mjjz6yZzMMYzd6L9Syn7UYJ1PvW5s9ZU2wIbGnMZ999lmOHGiyDpl0JQ0ePFjEK8lcO+ZcdbYeD2emZHDGtuU2kZPIGFuEky14VH0shmG8XzjhBMbBjoy3Cye4m1BEEsIGRVON39eCjOsoZirZtWuXsLbmdmyY7m+MNnGjtHgh2aMpkMVZ5hHSJic1zs7uTbmstEA0IibLmjXIWcIJAeIIbG/VqpVTts8wjPdh16w6zGBCIjtPzYnD5B1sddUhqSOeI4khZuP179+fNm7caFVUwBr08ccfi2BozERDALcxcOmNHj3aqnDCTDV7QfzT8OHDxXMEzaN8DbaLGWi+gKWgfO1nNDUb0REgJx0yoMtyQAzDMHZZnMaPH0+pqanUoEEDcQGCWdvUnR8yizOMM9GKEyRCREJELSg3AZeyFE7IJI0YGZS+wLqYvabFnHDCjK2XXnpJNKCNs9G69NAwDd0YBCQjISNKvlirU5YbS5G2dI070SaRdGamc8w4xI2bqZmWDMMwHieckIIAd9f79+8XzRQ8q851HCxQgc6EF6T4sGjKGYLs3dS7e4ZKJVylQlkQKrEWhRNy8BgLpwceeCCHS81S0VOUGtEDXGKI9UMeKXNlYLRjg0UIViJftWAgb9SsWbPoww8/dPi2TQlG3LQxDMN4jXAaNGgQ7d27V5RH4Fl17mdQ28l0MY2oRDDRBfItlu2eTnT7BlFMQaIe82x21emN50E5EbjjEFujF+SQwmw7xMGYKu2hFU6ICzQOBncXeuKgbAXWZWdZmGVpJ4ZhGK8VTrhzRiwH7vAZxpODwyHy9YCZbKYCtq0BF7W59Tw1MzIyhyMHG4o8ezKIQYOghbuVYRjGq4UTZiGh8KY7mTp1qphxBFchXC9IysnkPcyJE1gpUDSWraE5QXyXrUk53ZU5Ho1hGMbrZ9WhbhRmvaDMgbtAxnLUgEIdLSbvoK1fZ0k4Ybm7RZOnWpwYhmEYF1ucUlJSxF0rcjnB7I+ZSsaz6nDRePnll8lZSDeh8ayovMg3aydSvuQ4ERxOzXzLfdqxwUi67h8mgsNRZW737t1iZtq8efOsBnr7GjVr1qRDhw65ZOYawzAM40DhhDp1kk8//dRkH2cLJ1tB+gQ0yd27d8lXuO/mSSqWdIMuh/veBXVvVFm6GBZLJZJvqdP6YfGUwglT0z0tySNyPa1fv97h1lCUb0EOKU/6XTEMw+QV7BJOp0+fttrn1q3sC52nMG3aNA5m9xG0YgmJCj2NZcuWiVmnjg5qLlu2rJjyzzAMw7geu6425iqjw6KDiwZm7GBqt6kkgZYYM2aMyeSBWv7991+qWrUq2QpSJ4wcOdLA4gQXoy8QGWD46FPILNGabNHVqlUTszpN1YDzBIsTivOaSk/AMAzDeC8Ou03HBQpuCYilxYsXC0FSqFAh6tWrl83bggtmwIABFvuUL18+11YKc24dbydfoOGjTxESTpR271EDXFbeXo+NYRiG8R7svsTu2bNHiCXUrEOBVMQ09ezZk4YNGyZKSuRmRhEEFxrDMAzDMIzXC6dTp04JsYR2/PhxKlGiBPXp04caNWokKrU/8cQTLktWd+7cORFHhUeUdpGlXzDTz3jKOpN3gFURLmNPqd3GMAzD5FHhBEH0559/iqnQ3bp1E3mcZBzHyZMnydWgoOt3332nvq5bt654RKV7lMBg8iZIeokZdzzzjGEYhnGrcNq1axeVK1eOpk+fTo899pjbZzMhfxPncGKMqVy5co5CvwzDMAzj8szhyNdUrFgx6tKli5jN9NxzzwnrDgfhMgzDMAzj69hsLkIhUzTkcEKM048//kizZ88WIqp169YiGJxLTLiJtl2IkpOIwgxnnvkCI0sR3c0givLFGYMMwzCM1+CnOMBUJGfWLViwgC5fvkxFihShDh06UMeOHUVxzlBN7h1PA2kTUMssLi6OoqKi3D0chmEYhmE8+DruEOEkycrKog0bNoigXORyio+PF0kA3VkE2BosnBiGYRjGe7nrzcLJuADw0qVLhSsPj54KDnT+/Pnp/PnzLJwYhmEYxsu4e68CyJ07d4SA8lrh5C0gJ1WFChXcPQyGYRiGYewAKZFyW1XEFvJ8qG1sbKx4RAJNVyjVvKD62XpnP3wsHQcfS8fBx9Jx8LF0rOeodOnS6vXc2eR54eTvn52RAaKJv7yOAceRj6Vj4GPpOPhYOg4+lo6Dj6Xjr+fOxjV7YRiGYRiG8QFYODEMwzAMw+gkzwsnFIOdOHGieGTsg4+l4+Bj6Tj4WDoOPpaOg4+l9x7LPD+rjmEYhmEYRi953uLEMAzDMAyjFxZODMMwDMMwOmHhxDAMwzAMoxMWTgzDMAzDMDph4cQwDMMwDKMTFk4MwzAMwzA6YeHEMAzDMAyjExZODMMwDMMwOmHhxDAMwzAMoxMWTgzDMAzDMDph4cQwDMMwDKMTFk4MwzAMwzA6YeHEMAzDMAyjExZODMMwDMMwOgmkPE5WVhZdunSJ8uXLR35+fu4eDsMwDMM45NqWkZFBvk5gYKC4dsfHx1Px4sXJ39/59qA8L5wgmkqVKuXuYTAMwzCM3UBEDBw4kDp27EjBwcE+bRBQFIXS0tJo2bJlNHfuXDp37hyVLFnS6fvN88IJliZw/vx5ioqKcvdwGIZhGCbX3Lp1ixITE6lw4cIUFhbm88IpOTmZKlSoYHA9dzZ5XjjJLxVEEwsnhmEYxlvJzMykixcvUtGiRalAgQKUF4iMjBSPsLBBSLkChzkDL1++TH///bdQuq5ky5Yt1KFDB+HbhAhasmSJS/fPMAzDMJ5Aenq6eAwPD6e8RFhYmHBLuiqmy27htHTpUqpatarwK9arV4927dollt+4cYPq1q3rdCEDoVa7dm367LPPnLofr2DNIqKlP2Q/+hjTzxNNOp39yDAMw5jHl91z5j6vKz+zXcJp+fLl1LVrVypYsCBNnDjRwEyGZSVKlBABW86kffv29NZbb1GXLl2cuh+vYO1iouXzsx99DAimyWdZODEMwzDuxS7hNGXKFHrggQdo27ZtNHTo0BzvN23alPbt20eeRGpqKt29e9egMd4Jvlvvvfeeap5mGIZhvJNWrVqplqOpU6eqy48cOaIu//bbb8nrhdOhQ4foySefNPt+kSJF6Nq1a+RJTJs2jaKjo9XGqQi8F7iGR48eTTNnztS9DqyiV69edeq4GIZhmNzz/vvvi9mBnopdwgkBaJaCwU+dOuVxkf1jx46luLg4tSENAePd2GLVnDRpkphxMmvWLKeOiWEYhskduDa/++675JPCqXXr1vTdd9+ZjGS/cuUKzZ49mx5++GHyJEJCQtTUAz6XgiAqhiimYPajj1E0mKhEcPajMbZMQYV7GTz//POOHB7DMAzjACpWrCjyMcGTgATVnohdeZzgh2zSpAk1bNiQunfvLnyQq1evpg0bNtCXX34pLmgIGmdcxHj9LitvY3cDw9f//POPQWkBhmEYxhBcg5OSktyy7/Dw8FzNdIOXqk+fPjR58mRxoztixAjyKeFUpUoVERj+0ksv0fjx48U/Cb5JGeiFFAFly5YlZ5KQkEAnTpxQX58+fZr2799PsbGxVLp0acpLYMbZ3QyiqECikb4WuoUUC8lJRGHhRA8/QfXr11ffclXSM4ZhGG8CokkmiHQ1CQkJFBERkat1X3nlFaEfvv76a3r88cfJ07A7c3iNGjVo3bp1dPv2bSFgcPdfvnx5KlSoELmC3bt3C5ehZOTIkeKxf//+HhOB70rhdDEt26Xlc8IJKRZu38h2RT78hJgdaa/FCYIrr+U7YRiG8XTy5csn4pEhoDzRa+WwkisxMTHCZedqYNlii0PeJrf/f+QhQ5r+3PDvv/+KbLXOtqi6GliQp0+fTh999BGVKVPG3cNhGMZOdxksP+7atz0gxdHHH39Me/fuJa8WTt9//32udtKvX79crcfYxjvbP6GQ5HhKDctH1Owl8iWeqzmIblEQxVI6fWn0Xm4tTpjYkBvhdPPmTapevbp47gzRjnQJSCAbEBBArqZFixbiEWlEVqxYIVJ2MAzjncCinlt3mSdM5Jo4cSI9/fTT5NXCacCAATmWSVeH8QVE6wJh4eQaHjr/FxVLukGXwwuSr7GicB26GBZLJZIdl9vj7NmzdOzYMapcubLB8oMHD9KOHTvED9bfP+fEU8TR2QJ+G9jmnDlzqE2bNhbF2l9//UWNGjUSltSNGzeSu9i+fTvlz59fWKDuv/9+t42DYZi8y4ABA0Tc9NGjR8lrhZPxBePOnTsilgh3pcOHDxfB4jLTJ6YSxsfHi7t6hvFE9uzZI76zFy5cEOWBJLVq1RKPcMU99dRTdsdJvfPOOzRu3DjxHL8LS1aqr776Sjxu2rSJPIG3335bWJ4kf/75pzDB16xZ063jYhjGt9hk4pwHqzv0hFfncULMg7bB/4ggcHzgbt260X333ScaUhNgGaYVIlaCYVwNik23bNlSl38cszBNsXLlShGcCKtUcnKyyEsGkaUVPpZEEGKosO6ECRMMllvKTeLJ8Xoo3N24cWPxG/cEMjMz3T0EhmHyIHYlwFyyZIkormvqjhsuDhQAXrp0qT27YBiTgdnWQH6xLVu2CPFkDXNi5aeffhKB0rBKwcry7LPPijIveuKrNm/eLFxyWNc4VgnWLUsZ93MLxgKR9ttvv4nXKFlw+fLlHP0gAvUcQ+Nj8/fff5OrgchEPULElWlBjUmUS0K+F4D/E9KieLLwZBjGN7BLOOEkZcmMdvjwYT6RMQ5HBmZrQSbwBx98MIcVwtEzSq5fv27wnTYnnOAGlJgK8r548aL6HO7swYMHiwz8ixYtyvXYcJPy5ptvUocOHcRrWHyLFy8uyhdowexXHEMkq7UFxGe5GlQeQD3C3r17Gyz/+eefhSj88ccfxWtYBmfMmGHWesgwDOMRwqlz5870xRdfiLs9bXZSPP/www9F9vBOnTo5YpwMYxHUnkMwNSw9zkYrnBAPNXfu3Bx9AgMDLQonbdA5AiC/+eYbIXoQN5hbtGIM+c0kcBeayro+b968XO/LVTdEcqxr1qzRtX9HWPJgkXvxxRdFBQSGYRiH5nH65JNPRMD4qFGjRLKqYsWKieW4E0xPTxezcRAHxTDOROsqxvfO1mBCeRHOzUUXsz0GDRpEAwcOtEk4mXJv67WWYLywdBlvVyvGtDnVpFUMwgxTfC2NwZOTh8pgfmdmQsbnkvlnrAXyMwyTN7HL4oTZdLjDX7x4sbhwVKtWTTQ8R/wTYkwwpZlhXMUPP/wgvoNaUlJSROoBS8BNhguyoy7KWhFjSjjh94H4HcRRmQOB6MYgvxK2DWEGyy4u7Pv27RNFtU2lTgBwXyJGCPFPcHtpj5W1AOtVq1aZXA4x5mpR0aBBA1UQmtu3Vsxhwkrz5s1tCiJHGgaG8XbymuBXFMWln9khmcPhjmOXHOMutGky5s+fn+P9ChUqCJFiaYYdSgbpxdIPFDFVmH2GmCtLwglWWhSx1CaYRO4oLch/ZuwuGjJkiPocsUza92UqA1MiR1uiRgvWb9u2LVlzXSE1gxZY9iBiMLsWItD4WOKmqX379hQcHEyOBNZETDqpVKmSVeEk48WQQgHHGjOAIRYtgaBzbwX/YwhozviedwkKChKPuKky/s36MsnJyZSWlmZg6XcmrtkL4xKWlm9JgckJlBEWSf9dXn2DjifWUVpYFOX3y6APLQRim0JO/zeeEafFlruVpk2b5lgGQYO4GNRuNGUlMgXynKFpA8+1aItXS5BIU2IsqsxZnCxZh6SgQh9zxTRNrYtEnXAtGrsXsR0EkUOkwn2PPFDa7SxYsECILhRplkH+mESC2lSYJafti8BwU8DCbbxPS8cAwkkGwlsTTt4Mvt84lvi87ih/ZQsI7j9//rxaW5RxDLhJg5dHnnPgdvblepyKogiRiM+7bNkyg7q1HiucypUrZ/WfgvdPnjxpz24YnbzV6BlR5LdAVrLPCadxf3xOJSNCKS0iKodw8gQzLyZCoDkS+duC8EP8oLXfmrnSBHBVmZv9B2uRnIVnDgg0Y1Fl6ngdOnRIpH9AGgRp/dMKp61bt1KvXr0MRBusU1JsYixwT547d07EjaF4uB60n00eoxEjRhi4YbV9zQlM7fqOwpZYMJz8Me5nnnkmVxcAiCYA96+nCSekyEBYB5LB4uL+5JNPiuUPPfQQ1a5d293D8ymKFi1q8YbNF4mIiBCTdFyVN9Iu4YSTpPFJASdpxJMgVgDZhevWrWvvGBkbQTzLiRMpVLFiRZftExMC4CrCSR9T4B2J9iItL8p5ISYAAiI2NlaIC8Qm4aKTGyAWzAmnr7/+2ur6EFZIKKrFOJAex89cYkykCoiKihJNC6xt2kB+zNLVmt71Yko4YeKKub7mhBO+W9ZEzvr164VLFZngLQkw6SrE7wFWNmvuUACLJfr+73//U7+Pp06dEtuB6ze38XfHjx8XRdhR/9BdSHGOWajabPzGVlbGfvAdxo1W4cKFhXU3L7gnExMTXXsOV5zE/v37lSJFiihr165VPJm4uDgcbfHo7ZTYrii0UVFo4Xll+fLlLt1348aNxXGsXbu2w7edmZmpnO/ZUlEGtxOP2I8j2yeffKJcvnzZ4dt1dAMVK1a0eb3Vq1crp06dctq4srKylMWLF+dYXqZMGYP9vv/++wbvX716Vdm0aZPJbTZs2FD3/pOTk9Xnu3btEsfJXN+ff/7Z5Hds+vTp4v3HHnvMoP9LL72knD9/Xu0nly9YsMDq99b4f2eNBg0aqP3xnd+wYYP6+oUXXtC9v5EjR6rLzpw5Y9MY9JCSkiL+57Ygx/D2228bvP7hhx8cNi4m7xLn4uu4XbPqLAHz63PPPWcwi4dxHZhJ5kqkRUJmlz5z5ozI+GycfNEYuFGs3RU5+04CGaeRadxXsWRxcgTIQ2Wq8DEsz9pcUcYB+HhtzsKDGCq9aD8b3IPaHFbGoByUqe+TjLXR1uWTlitt7JVEfl7sG5YquMnkOPB9btasme7xm/occGchoavk888/F+PG5ANbfg87d+5UnyP2SRtTlxvwP0XcjHH6Db0Y/7+t1YLMDbDYGU9YYBiH4kxV9tlnnymhoaGKJ+NLFqfjIwcrcUO6KP++2F9ZuHChrnVSU1PFHaS9GN9dFyhQQDzv16+f2XVw1wqrROHChZX09HSz/fBehV/PKvlWJ4hHd1t+3NVAhQoVbF5vxYoVyrFjx9w+flMNFgd7t9GmTRub+qelpVn8/ppqsPgsXbpUfR0TE6Pcf//9Sv369dVlo0ePVk6fPq2MGzfO5P/OGtb+t6+++qp4HDJkiMXf4CuvvKKcPXtWWbVqlbCMabdRtWpVg3WOHz+u3LlzJ8e2EhISlD179uSwLGHbtnwmWM7i4+PVdaZNm6Z8/fXXNh8bc+B/2b17d3GtAbBiyu1aOqcwvkWci6/jThNON27cUOrVqydcC56MLwmnS8N7Z7uzXuip/PTTTwbvQUgtW7ZMnAjXrFmjXLt2TZzUChUqpERERJi8mEh+++03pVmzZuLiaw7jE6F8XrJkSbPrzJ49W+2HC445MLaiy68JN6R49IALvjtaboUT/u9Hjhxx+/g9pd26dUu4EEFiYmKOC7kz2s6dO9V9mgK/V1u/CxA3EA3/+9//DH5zuFmx5PIEGRkZyjvvvCNeG9/caoXOL7/8YvCeFG9yO8Zcv35dOXz4sPr6kUceMdi33KfxeEyRlJQkxmmJb7/91mA72hsE3BT6EvJ/hu8S48XCqXXr1iZb3bp1lbCwMCUgIED58ccfFU/GV4WTPJkCiCR5Mvnuu+/EY2BgoLjTlMuNT+q4oCAm5ejRozlOcjg59ejRQ8Sx4a7u5s2bBn20d31o5cqVU5YsWaJUqlRJ3JUD3BFr++DihXg4nCwxdghvCSxiLJxyH+OE+KMJEya4ffye1hBf9fzzz7v8f4gbFmNys50333xTff3BBx/oXvfKlSvKlClTcmxPMnbsWHV5x44dDd7D79d4HdyMQWD17NlTfU/eZOn9LHI7Bw8eFALh9u3bir+/vxB+lpg5c6bBdmBB08a+acF2cQOIc9eWLVuUwYMHCxHtKnADiPMv4s5yg/ZGUy8nT560WWjh2CAWzdT31FOJ8ybh1LJlS6VVq1YGDcKpa9eu4s7k33//VTwdXxVO+Ew4EeHHunHjRqsnL9wlQizhpPr4448rNWrUMHuSq1y5sngeFBQkrIrGfUqXLm31RPnnn3+afO/BBx8Uj7Vq1RKCbN26dUJMsXAiYTXKjcUpMjLS7WP31Fa0aFG37FfeqPzxxx/KV199ZfP6YNiwYQ4bj5bevXury3EukOCCDxel8Tq//vprju0ZB9nr2bfWGgU3qKmxGQMXnTnh1LdvX3HTKK1oWuEh28CBAxVHAQugJbTiFm5UgIkHGMO+ffusbh8TFfQcEy2y/4kTJ6z2xQ2rVhhjsoK3EOdNwskX8CXhdNFIOGnvSPU0WAi7dOlisQ+Elb0nacz409OvWLFi4hEnHBZO3JzRMPPXHfuFOAHujA0z1S5evGjwun379ur5xViAy3CAZ555xq59btu2TewXLkNT72vBzdQXX3yhnDt3TrzWxpgBCATtutbOZ7JpQxVg7ZJxn7C6SAvR66+/rsyYMUNY2rUWffR56KGH1Fmdpiw17733Xo594kbV3OfUI5xg1TMVnwYx1qFDB2HBl/1h8beGtWOfW3bt2qX8888/ijPxKuE0efJkYVo1x6FDh0QfT8aXhBMEk1Y4edOFxFpj4cTNl9oTTzwh3CHuHoeeNnz4cKVTp04m39OmUHBWQ0A6hA0uvpZEHqxNcC3mdj8QRbAEhoSEKA888IAQUNICjuuYcf/169eLeFGtcETMaFRUlPLWW2+JSQtNmzY1e07t06ePwWt4cMzFkSKNhrYvvDl4RHyqFnM3tmPGjFG2bt0q4lUl8EhoLVGm1jPHuHHjhGtWKxLv3r0rrKBw9UrhqQ0T0QO8C6ZSXeBz4T0A0YzPI8Wz1wknPz8/Zf78+Wbfxx0J/NSejDzgMJlbC0TMC8LJUxsLJ27c8m6TAkbbtC5FZzRcuyy9//DDDzt8n/nz51cuXbqkntNXrlwpJvZYWgfHAXGMH3/8sa59QJzBqKFdhqB+U30lCK0YNGiQUrx4cWXevHkGcYJAm0sNDQJ20aJFBsukIJKPCN5HDBbE94ABA8TnhtcDfSHMZB8Z1wkPxJw5cwy2+fnnnwvx5lPCCR/KW9IRoMEUaiu2JoLDPxlfUmPgg5fgzgBfbO06/fv3t2q9Y+HEjRs3bt7fYL3Bjbwzto24UVv6wwJn7r0WLVqIseqZnIBgfHiozL2PVBXa1xBV0BfWtot4XDlGVwknP/yxJe8Tqp5v2rRJPJ80aZKoVI40+sbcuXNHlA8oUaKESLzmbD777DN6//33RXVwJN+cOXMmNWrUyOp6qIaurVAvDwcekZxRVptGSZGXX35ZJMqT2124cCH16NFDTTSH8jJIYnf06FFxTJBsburUqaLcAApaIi38999/L2p2gd69e4sEgX369BFJ23755Rd64IEHRKp80LFjR/HYuHFjev3113OUsUCCvCJFiohEk9OmTaPgD1+nkqm36UJIDJX6/CfyJYouv0ZXIgtR0YTrdKVD9vFhGIZhfJMmTZoYJHDVAxIuG5d2cgq2Kq1JkyYJSxMaTJnyuakGJeiKnBNwCQYHByvffPON8IPD5wyTJ6bF22JxMs6BgobPAUVtrHKRtNEZdwMyIDo3jS1O3Lhx48Ytr7Y4T7U4ofhmUlKSsMjAMjJr1ix64okncqTVR1r+0NBQcgWwyKAa+Keffipew+qDMgnDhw+nMWPG2GRx8mYe+/Q3CovMR8kJ8bRimGE1e29n7mtjKCIikhITE2jge7krdsswDMP4LnEusjgF2rpCWFiYaLJeU6FChYRIchdpaWm0Z88eGjt2rLoMVcvbtGkjqpgbk5qaKppWOPkKKwrXJipUkuj6BfI12pzbQSUjQulComtr8DEMwzCMFruK/JYpU8atogncuHGDMjMzRayPFrxGvJMxiAWChUk2UwU8GYZhGIZh7LY4lStXTlhzjhw5IoKm8dpcdXMJ3j958iR5CrBMyUro0uLE4olhGIZhGIcLp5YtWwohBPGkfe1OChYsSAEBAXT16lWD5XhdtGjRHP1DQkJE80XqxZ2hYLpLaXG3aC/5FgcKVqbzERF0OyyRiDa7ezgMwzBMXkXxARo1aiQylmrzHpUoUULkhbBlVh3qo6H4rXxdsmRJNTvpX3/9JQpKymrfyBiLyuSmIvujo6OVpUuXGiyzVC8OGGeRtdbq1KmTYxnPquPGjRs3bnm1xXlDAkxPAekIkADr22+/FcVqn332WZGOAGnarWFrxlEkJUOqf7lubGysqAv04osviu0g6adMiom0+Ch4jOKsEmRI1f6jMW6AdTBebB8lBubOnSuymRt/McqUKSNEmQSpEj788EOlbNmyLJy4cePGzYUN2bpxvnb3OGxpwN1jIBOtatWquV53x44dniucNm/enKvmCmANKl26tMjnBAuU3vxR9qZqRw0liB6006dP6+qPsSHfVI8ePSzW+gOweCGd/ffff2+xwjWsbOeHsnDixo0bN1c1gHInevqiODFEFjwZpt6/7777ciyrVq2aqJ+H65r0dphqxjfk1sZsvAx19Uz1RUbw6dOnq6+/++475dVXX1WKFi2qLrNWTL5v376izIvx8mbNmqnPg4KCxLhwHTXu98Ybb1jcPgwZHl1yRSa91Ntkf0/Gl4r8XhjWy27hhBT67j4ZoWkLY+KujoUTN26uacZhBnm1RUZGqrXTZLt8+bLSunVr9TUwPl6VK1cWy3HDK2vs/e9//zM4V2vr7ElMlVh59NFHDerFad+DlwFCQ9ZY/eSTT3IkUYZYW7BggTAsaMcGT0WFChXUfq1atTIrSvA5nnrqKVEzT7J3714h6qT3A8LO3HGUxoEzZ86IpNTaIsnt27cXz2fPnq1uW1qemjRpIrwu+IwrVqxQlixZYlCy5ddffxWFnYFHCycU9MtN82RYOBm2Tz/91Ox7v//+e45ltlR4N67wbak1b95cfb5//34WTtx8ruHG0t1jMG6IxUS4g3bZyy+/rOzbt09555133D4+S61t27YW34+KihI3htasMzhPobgsSEpKUr7++muxHJYiGRqC1/fff794vXz5cnVdbNvYMwBvgDE3btxQ6tevL24KJVprC6w8TzzxhHLhwgX1fXgq5PsQEBA/psD+SpUqJT6vFFXY9pYtW5Q7d+6o/aTQQoMwks9ff/118QjrmF7q16+vrn/z5k0hquRr43EiXhiWKzlW4+N1/vx5cV0xVdMVoAAw4ou1x9WjhZMvwsIpO9DdlHDSnmAQcwUQ06VdF3ceeveTkJBg9j0E5mtfP/DAAyJGbPXq1WK/LJy4eVsbMWKEiLs09Z68U4e73h1jGzp0aI5lM2bMUM8lYWFh6nItWqsISls5c4z58uWz+D6sMQ0aNFBfY4KQpb4IkwAQEFpXFEQhLBrDhw9XBZMWXKBRGBdiR4qQAwcOCEsM2LNnj8ljlRvk5CScK42BdcVR+wH4rBMnTlS2b98u4msxQSm3oTX79+9XChQoICxb8hjBWgUrkyvwWuEEE9yuXbtE01MjzlPwdeGEL688Cd2+fVtYAHF30KlTJ7UPvuTjx48Xvnpp0pU/TmPhFBMToy6DnzslJUW41XCHY8ndhpaenm72xIb3evbsaVAzUAsLJ27OaNqLkaObBBYb7XJ5cZFCBPEfBQsWdElQLWbjQgTAkmH8npzUIs4lFy4Iq4FWTEm01e4xGcZ4O7iZ0rqi9LY5c+aozxHPA8GifX/37t3q83bt2omxwOojl61cudLsthFTKoFQMv4f2ctHH32kLFq0yO7tQDDhPG0OuN4csR9nkKX5/rgarxNO+BHiQmwc34Rla9euVTwdXxJOF4f3ziGczGHKxw7MCSfcVQGkWpDLtm3bJpZBPOEC8Pzzz4sZjW+99ZZ6V407bgTr40RsfCI0vsjghAG/O1JJXLt2zWBcxX5j4cTN8Q1s3bpVmTBhghIeHm62H1wqiA+B0IKbAXfosiA4YmHMbRsYf+9N8cILLxj00d5EmGqYySufw1Ki57NOmTJFdd1of9uWxmUK6WKUcTsnT55Ul+H8AGBpMBcEba7dunVLWJq1FjkZtCxjc+BGa9q0qWrJkIHZuKEDsJ6YitOEy017gR85cqQQO4xvEOdNwgnBWQieK168uDJmzBjlm2++EW306NFiGcyO6OPJ+JJwujS8j27hhBOMPAFrwR2mdl3cqcGMLSlXrpyuE60pU7PWh298R2oNTxZOllwE3tQgCFy1LwSsamfmuKtpgWDX00/7fZZCZNWqVWpfxF8gkFeLtW3hpkO+P2rUKBGLYmnccLNY+v7BTWjtMxi76/SCGJRly5YZWBgQt/LQQw8Ja472+CDexRbhhM+lTd+CGyjM2sI+zQERpRWExjd4liw4jG8Q503CqXr16krt2rVNBqnhA2B6Jfp4Mr4onOCyw2wOaSUy2//SpRwnnKNHj4rjgTxYpoAZHrMdEESaGxBDNXXqVPHclpO2M111iH/I7bq4OdB7x+/pDdZjR20Ld/QITjX3vrywwgXs7M+FmzhL49Be/DFTSb6ndZ9ZQxsnaAr5HiyqpnjuuedyrG/pM2nd3hBA2vUhSDEDSb6GRQyBwKbA/wC/aT0573JLYmKi1f8RzimOdPUgkBouTAhaxveJ8ybhFBoaajArwBi8hyBDT8aXhFPlTYlKvtUJ4tEekI8qPj5ecTbS3dCyZUurff996hElbkgX8ejoCyvI7brIReIIixMsts4WEMbTqo2XwWXlyGOK/DMIGDX3vkQu087M0dO0VhpLDfF75qxqxiCAWL6HWU3m+hkDy6ylvhCICASHW9sUcHEbr49YFsQkIR4R7m7tuLXWW7j5tMcRQlErnIxvjtyBDKCeP3++SPqr/Sz4n7gzPobxfuJcfB3PLjqXS6pWrUrXrl0z+z7qxVWuXNmeXTA2kBgUTvHBEeLRHsqWLUuRkZHkbH744Qf66quvaNGiRVb7xlAGRaUnUWR6MnkSuF7VrVvXrm20aNGC3n77bXIWgwYNMnh9+fJlUcfx+++/pwYNGqjLZQ1Kc1SoUMGm/aIIuKXzgzGBgfpLZxYqVIg+//xzGjx4sNW+Q4cOpejoaHrmmWfE/0svQ4YMoXbt2tHMmTOt9q1evTp9/fXX9Pvvv5t8f8CAAfTTTz+ZrZNpalxdu3alffv20ZIlS2jXrl30559/qu9pa4Qar4v3tMcStTzdTb169cQ4e/fuLZ5rrxH9+vVze81ThrEJe1QXzNOYno67G2MQ24T3PD1A3JcsTiW2K8KdhUdf4+ag9tnxWz1bOtz6AnK7buPGjU0mrkMzV8vQuGEmqi1jQOCwNgmfpTxb8vNp3VVatLE0smyBcUOSOsS5wT2EmU3vvvuuCAi2dkwlet/XZhK21mQNSe0MKW3TWjUAxg4Qm2NuHLKf8eQHV4AYnsKFC4ssyebQJkAE8vmQIUMMXiNWC5YzBFpjRp+nIWfH2ZIniGE86Tqu/xbPBLgTw50f7oyKFy9OFStWFMtPnDhBly5dEtamGTNmiCbBncXSpUvt2S2Tx4Gl88iRIy7dZ4ECBejmzZs5luN6hTt6WGNOnjxp8B4sUT///LPVbTdq1Ej3OGCda9++vfjNadm8eTM98MADZtcbOXIkjRo1iho3bmy2j7m7/lq1atGjjz4qntevX180ZxAVFaWr3yeffEKlSpUSz+vUqUPbtm2jEiVKCAuXJDw8nFJTU9XX0gLz2GOPUevWrWnjxo305ptv5ti2uywfJUuWpCtXrljcf5UqVUwuN7Y44ZgEBQWJ74Qngu9PSkqKWesbw3g6drnqDhw4IE5OpUuXFiemM2fOiIbnWIYfx8GDB3M0xjk8c2gRTfz7B/Hoa3xWtTNNqtWXvrqvO/3777+53s6sWbNsXqd8+fJ08eJF9fU777yTo8+WLVuoR48e6msIDT1uIa37RQ8QTGFhYTmWWxJNYMSIEbRhwwZau3atwXLtGK256iwdH2NXoC189913QpzB9aZ1XxYrVoz+/vtv6tmzp0H/YcOGGby+//77hXt5zZo1Qjzhc65cuVKIWeObNHxGvJ+RkUFvvPGGxXG5WkRZ2x+EJcTV7du3TQoqHCu4Jb/55hvydFg0MV6NksfxxVl14tHHKL7iujqrDphz4cBtYWo5ZglOmzZNJJCz1VVXvnx5g6BhbUmKhg0bGuTrQaA7ZmPBBYbZg9ZcTtqgWEv94GLC7CcJEgCacjlZc4sZgyngsh9mlcnnsswEGtKLmAKlJ5C5GUHgcN117txZpLnI8b8zMavNHPJ9TEk3d2yciTbnkqnP4klgfAh8N5XtmmHyEnHe5KpjGFfh55dtDQkIsGwV0bprtMi7dK1VwxT58+enO3fuGCzDdVtrjdFaabKystTn6LNp0yayBb1WjQ4dOhi87tWrF61evTpHP+wfLsXQ0FDhlsrtWDp37mw18BoWNq2VbfHixSb7rVq1SliJHnnkETEZwNL/YP78+SJg2JxbypV4esBys2bNRGMYxrU4RDilp6cLVwYuTqbcE9pZFAxjH352Xey0Qsfc+mlpacIdWLt2bZPbtWVmlrPATCTM1DKmZcuW4hGuqAcffFC4wCwRExND3bp1E/0x084ZYAxwZYJx48ZZ7ItZV+7E08USwzBeLpxwZ46AU9wl4mJjDC4wOBFlZmbasxuG0Y3WMtSwYUP666+/bBJOAIG1xoID32Pc3d+6dcvAGlKpUiWbL8JvvfWW1fga/Kb69OmjBvua2na1atWEwMPEDGMQZ7h+/XrSgwxg18ZxgeDgYPG7hqXI3SA1AOLTOnXq5NT9sHBiGMapwgl3vMuXLxfBm5itg1wpDOMKEABrnJ/IERYnc2C7mL0l3XZ4jrw97777rs3bwsXfmnCCKw5uN7itkO/KFCtWrKD33nuPXnnlFXI0+LwXLlwQMwWbNGlC7ubjjz+mjh07Wg2CdyQsohiGcbhwwiyWF198kT766CN7NsMwNpMvXz6nueosvSffx0wutNxQo0YNcdNhyTWG/SAeyFo81xdffEHOAqlG0DxlFhbSMDAMw3i1cEJuG5m7iWFciTZHj3RZgSJFiliMRcpNfFJuY5rMrQdRNHfuXJPiAJ/LE6Zqe0Icl7thixPDMA7P4/Tss8+KMgK5dX8wTG6Rs4lwcdN+/zDLC/Ew8+bNM7meue+qnEE2efJkp4xXxuY899xzZvts3bpVBHfDDeju+DAWDQzDME6wOI0fP17cIaPe1VNPPSWy35qqi2Sc5Zhh7AVuKmSoj42NFUHgEnz/pPsKcTF6hRPcYmPGjLG5HpsltOIDwd6IWXrooYfM9sfnsDWdgSOB6xBpDxBYjrQMDMMwjIOFE2bhIAvv/v37RTMFz6pzHQcLVKAz4QUpPiyaipFvUe/uGSqVcJUKZaHIb6xYJkWOue8XZmE1b96cpkyZYlY4oVSHtLY40+0cERFhc14lV4Pf6rJly9w9DI+BrW4MwzhcOGFW0969e2ns2LE8q84DGNR2Ml1MIyoRTHSBfItlu6cT3b5BFFOQqIehGw45iMzVxEpISDCwgmqFE8qPoJ4cwzAMw7hEOCEWY/To0U6LC2EYPSAvEmapIebOGGPXsTbouU2bNi4ZH+OdsMWJYRiHB4cjJgIxJu5k6tSpIlAY1dA5LiNv0r9/fzp37pyuAr62TGSQuZZmzJiRq3FJ1xyyczPeR26LHjMM49vYdWZA4r05c+YId4i7QGbj7t270/PPP++2MTDup1SpUrosBLYIpzfffJPu3r2bo06cXpB9/Pjx43T27Nlcrc+4B1gvUa6G3bgMwzjcVZeSkiLKUyCo9sknnxQXL2PXCC5mL7/8MjkL6Sb89ttvKa/zzdqJlC85TgSHUzPfcp92bDCSrvuHieBwe8KXbU2dYS7Rpl44z5n3YSrHFsMwjEOEE+rUST799FOTfZwtnGwF6RO0yRNhUfAV7rt5kool3aDL4QXJ19gbVZYuhsVSieRbdm2Hc44xDMMwbhNOp0+fttoHRVE9iWnTpnEwex6mRYsW7h4CwzAMk1djnMqUKWOyIWj8zz//pJdeeknN8GwLSEQo64KZa0eOHMnVmJE6IS4uTm3nz58nXyEywPDRpwgNNXzMJQ8//LAojqtH9DMMwzCMQy1OxtO8169fLzIkL168WLjAUCAUVd5zE3SOAE1LlC9fPlfjRB0wT6gF5gzyBRo++hQh4URp9x7tAKL70UcfddiwGIZhmLyF3ZfYPXv2CLGEmnVXrlwRF6aePXvSsGHDqEmTJrnKheJJVdkZhmEYhmHsEk6nTp0SYgkN061RtqJPnz7UqFEjUWT1iSeeoKZNm5IrQP4exFHhEaU3ZOkXzGaKjIx0yRgYhmEYhskb2CycIIgQv1SwYEHq1q2byOOEemDg5MmT5GomTJhA3333nfpa5l7ZuHEjtWrVyuXjYRiGYRjGd7FZOO3atUtUpp8+fbrIjIxK6u4E+Zs4hxPDMAzDMB45qw75mooVK0ZdunQRs+eee+45Yd3R1gBjGIZhGIbxRWw2F73wwguiYTo3Ypx+/PFHmj17thBRrVu3VtMFMG6gbRei5CSiMPtmnnkiI0sR3c0givLFGYMMwzCM1+CnOMBUJGfWLViwgC5fvkxFihQR9b06duwoKtCH2pl7x5kgbUJ0dLTI6RQVFeXu4TAMwzAM48HXcYcIJ205iw0bNtC8efNELqf4+HgKDw93axFga7BwYhiGYRjv5a43CyfjAsBLly4Vrjw8eio40Pnz5xcZxFk4MQzDMIz3CadSpUrRnTt3hIDyWuHkLSAnVYUKFdw9DIZhGIZh7AApkXJbVcQW8nyobWxsrHhEAk1XKNW8oPrZemc/fCwdBx9Lx8HH0nHwsXSs56h06dLq9dzZ5Hnh5O+fnZEBoom/vI4Bx5GPpWPgY+k4+Fg6Dj6WjoOPpeOv587GNXthGIZhGIbxAVg4MQzDMAzD6CTPC6eQkBCaOHGieGTsg4+l4+Bj6Tj4WDoOPpaOg4+l9x7LPD+rjmEYhmEYRi953uLEMAzDMAyjFxZODMMwDMMwOmHhxDAMwzAMoxMWTgzDMAzDMDph4cQwDMMwDKMTFk4MwzAMwzA6YeHEMAzDMAyjExZODMMwDMMwOmHhxDAMwzAMoxMWTgzDMAzDMDph4cQwDMMwDKMTFk4MwzAMwzA6YeHEMAzDMAyjExZODMMwDMMwOgmkPE5WVhZdunSJ8uXLR35+fu4eDsMwDMM49BqXkZFBvkpgYKC4dsfHx1Px4sXJ39/59qA8L5wgmkqVKuXuYTAMwzCMw4CYGDhwIHXs2JGCg4N90jCgKAqlpaXRsmXLaO7cuXTu3DkqWbKk0/eb54UTLE3g/PnzFBUV5e7hMAzDMIzd3Lp1ixITE6lw4cIUFhbms8IpOTmZKlSoYHA9dzZ5XjjJLxNEEwsnhmEYxtvJzMykixcvUtGiRalAgQLky0RGRopHWNYgpFyBw5yBly9fpr///lsoXFeyZcsW6tChg/BtQgQtWbLEpftnGIZhGE8iPT1dPIaHh1NeICwsTLgjXRXLZbdwWrp0KVWtWlX4FevVq0e7du0Sy2/cuEF169Z1upCBUKtduzZ99tlnTt2PV7BmEdHSH7IffYzp54kmnc5+ZBiGYazji+45c5/TlZ/VLuG0fPly6tq1KxUsWJAmTpxoYCbDshIlSoiALWfSvn17euutt6hLly5O3Y9XsHYx0fL52Y8+BgTT5LMsnBiGYRj3YpdwmjJlCj3wwAO0bds2Gjp0aI73mzZtSvv27SNPIjU1le7evWvQGN9nzpw59N5777l7GAzDMIwFWrVqpVqQjJunhOLYFRx+6NAhmj59utn3ixQpQteuXSNPYtq0aTR58mR3D4NxMc8884x4fPLJJ6ls2bLuHg7DMAxjAcQsIdxHS2xsLHm9cELgmaVg8FOnTnlcRP/YsWNp5MiR6mtYnDiPk3cRFxcnpp3mJtEZkqQxDMMwnk2xYsVo586d5InYJZxat25N3333HY0YMSLHe1euXKHZs2fT448/Tp5ESEiIaD5JVIzhow9RNDj7MUZJofz584vv3oYNG3St66opqgzDMJ4KzoNJSUku3294eLjPBanbJZymTp1KTZo0oYYNG1L37t3FwVm9erW4oH355ZfiH4WgccZFjJ9JvsruBtmP48dPpUNEtHHjRt3rOko4IUPt559/Tm3btqUaNWo4ZJsMwzCuAKJJ5jxyJQkJCRQREWHzemfPns0huDzlJtgu4VSlShURGP7SSy/R+PHjxYd6//331QAvpAhwdjwJ/iknTpxQX58+fZr2798vfKGlS5emvARmnN3NIIoKJBrpa95HpFhITqL7E6/YvKr2x2bPnc9HH31EY8aMybHNvAomWhw7doxq1qzpc3eUDMN4XoyTp2B35nDcea9bt45u374tBAwKCpYvX54KFSpErmD37t3CbSOR8Uv9+/enb7/9lvKacLqYRlQi2AeFE1Is3L5BTf2DDCxAjz32GDVv3tyiZVOPyIEIsFbP6c8//8zFwH2XRx99VFiX4a7v16+fu4fDMIwVlxkMDe7Yb27w2RgnLTExMcJl52pg2eK7/7yDVtgsWLBAiHY0rXDCTE4Id9nX2vcDkxhQ6whie9CgQbR27VqaMGECBQX9J9LyGsePHxcliDAz1hwyxgzuSxZODOPZ4HyYG5cZY6dw+v777yk38EnVNbyz/RMKSY6n1LB8RM1eIl/iuZqD6BYFUVgK8m4tN/u9+uGHH8TyV199Vc3bZE04ffLJJ+IRlhM0AOH14osvGvTzNncUPjdKL8CSZguocVW5cmV1G3r2wzAM40hQxg0x1Fpefvll6tGjB3mVcBowYECOZebu6rUXGRZOruGh839RsaQbdDm8IPkaKwrXoYthsVQ04brJ9xFnAzctBBNArJ0p4aRX/Bw9etSjBML58+eFO7FixYq61xk4cKAQkoj7syXeDzGCtgD3vKMCSL1NnDIM4xwQiiFLuGnFlCdgUyIcnIC1DVnB77vvPhFjsnDhQlHkFw0ulPvvv59q1arlcZnDGd/kn3/+ocGDB+fIK3bgwAEqXLiwzduD+0lvugNXAOFTqVIlkcNKL7CeQdR8+umnTh2bvcLp33//FXm5unXr5rAxMQzjnWzatEncpJpqplIfebzFqUyZMgavJ02aJFwaa9asMbhThJh64okn6OGHHxYzkZxdr45hJLDKaEHMkrasTq9evUTQ4e+//27VuvHQQw85bEbewYMHxT4xA9VW15l2DLA8RUdHmxUvppKCOsIipHd8uUEKu19//dVBI2IYhvHQWnWoG4PiuqYuKDiBowDw0qVL7dkFw9hFZmZmDgEDoa91xVkTRMbbyI2ogPX1tddeow8//NBsH2vbMGetSUlJofr164upuzBvX7161abtG2N8PGbMmEErVqzI1fhysz+GYRifFU44YR45csTs+4cPH+bAUcYjgRUGgsja9xPWECSN2759u8V+169fF8JI+3s4d+4cFS9enN588011mfF2ENuD9B2ylp65sZoCFprq1asLUYa4JLglq1atSkWLFjVwkdtjcUKMAaxklioAsHBiGCYvYZdw6ty5M33xxRei0K82lTue484a2cM7derkiHEyjEOB+65kyZLUu3dvi/2GDx8uLDqY4LBo0SKz/Z5++mkRkK5N2IaUBig9hEdt6gNYYfEbgaD56aef6MyZMzRnzhybhcmsWbPU1AESxB4CbQ4ze4QTZthZw9muQGsgh9yzzz5LW7duzdX6EK+4yWMYhnG6cMI07mbNmtGoUaNEHidkCUfDc8xuwlTCjz/+2J5dMIxTrBk///yzEDUQLrkFFqsHHniA+vbtSzt27BDLILIkKD9kyrWGGw7MIMO6poK9b926RcnJySaFiV7rjvZz6xE2yH31wQcfiEdbLUDG28f4//rrL93rW9ofJpvIY2sOnGtQFxPHMyMjg2wFFjsk8kVQKsMwjFMTYCJIdfPmzeIOetWqVaK2DHjkkUdEVuEOHTqwGZ5xG5amrsJKKtHzHYWlSMuhQ4eEpUhaOQoWzJkCAsLMEnDbGbvuIKQKFCggbj4gQIzFUm7cYnqEE2IV//jjD1q8eDG98cYbJo8N3HZIcmscgG48Jtw8xcfHi5JLCMSHULR0jI3fgzUQsWi4KatTp45BUlNjsG+UfZFgBiXcirbknJNWOohpJNRlGF8hr4TKKPdm3XmFxUkCdxzcBhBPaHjesWNHFk2MWzGeBepIMHMUNwaSGzduqM/Xr19vU9oAY0Em3U/YBlx69p4Q9AgniCbto0T7G4YFGWkajDEeH0QTGDp0qJgg8ttvv6nvIVUJyuSgfI1cT7uPr7/+WogtpDiZN2+euhzWIBQVl9uW24dIu3PnjroMxw25q3KDqfMVrIqvv/66mFBgK4g7e+uttwyskAzjCmTVA20IjS+TnJwsJsYEBjqsGIpFXLMXxiUsLd+SApMTKCMskoaQb9Hr0g66rQRQYOId+lLnOsiajQupq2nTpk2u1w0NDVWf58+fX6QuuHnzpsm+rrjDMhYTEE7Dhg2zaRzIJ9W4cWNhDerZs6dYtnLlSpGwFLGQ2n0gVkwyf/589fmTTz6pBtwjdlKOxdlAvL399tuiGX9OvDY+PhDQKDAOq5yMd4Nw1ca5OQNTY2HyLgEBAeL8AUutrBfni98PRVGEOMTnXLZsmUHdWo8VTuXKlbP6z8D7J0+etGc3jE7eavSMWuTX14TT+0f+J4r8XkhM0S2cANxp1tAGV7sb44sz7qKMk3raG+OEfYwePVpc2JHXyhLIx2Yco4UTFCzKEswkhIh57rnnxAnbGATVoxl/NrhLjYWTNUvZV199Jf5fqE/oaDAOuAiXL18uSjuEhYWZLTKK2DjMNsTMRiT7BXv27KEGDRpQu3btRM4ubZyWNWBRw/5btmyZ4z1cFDCz01yxVHxH6tWrJ2ZYIhGxJ4HAe4ydcT2YXQukePJlIiIiRL5I5I30eOGEH7nxSQ+mbcQ6IXYDZTC0s4wYRg979+4V3ytXfXcs5ShyJeZmdsFyJoH4QJ4mW5JoGgsQBK1jBiDo3r27RYuRqRxWcM3D8qMFbjO4Bx588EGz29q4cWOOZd98841Z4WQufxa2AwGnB3w2iD/EbiEWUyv4zAWKS9M/RKCcuWiMFJxw18pYNGkBM54UYCopqbG4kHfKuHuGYNPG6SGlBYC1buzYsWKMWkGCOFNkzkfTghgzpLpo3749uQMUy0YS5DFjxtC0adPM/o8Rk1alShWeSORg8LuC2xuWXu05xNcICgoSN5cujedSnMT+/fuVIkWKKGvXrlU8mbi4OBxt8ejtlNiuKLQx+9GTycjIUA4ePKhkZWXleC8xMVH8P9BSUlKU9PR0ZePGjUrWK70VZXA75XzPlur7vtaeffZZ5a+//sqx/OTJkyb7t2nTxuy2Xn75ZfX54MGDDY7xDz/8oL5XpkwZpVixYgbrrlq1yupYy5Ytm2PZAw88kKvPnS9fPpPLW7Y0/7/etWuXxW02bdpUuXPnjnLs2DGD5cZo3x8+fLj6PCYmJsc2tchlkZGR6rJBgwYZ9JXPn3zySYu/h8uXL6t9b968afDeTz/9ZDCGsLAw5Z133hHPFyxYIPqsXr06xxi13yN3Ub16dbNjuHTpkvLcc88pM2fOdPs4Ge8nzsXXcYcEh5uidu3awnQPlwDjWrKycp/p2lwuI9y1O0rRP//88yK4GsG+WnC3rXXr4q4fgbm4GzcX5+NLwA1livHjx9u1XVicUB4Jd/aYrq+1gMA6bDz70DhAXK8LdMuWLbkanzbgWwssKbkNeEcKA7gCja1WmLyiLctjbhadqdg43MGjaWdC6vlNWLM4abG2PfwmYMGRRZzNrXPp0iXd+8P/GzFo5tySEli5UCtMz/fDUkJZuDn79+8vYtVwbjHFiRMnhLv0woULud4XwzgNZ6qyzz77TAkNDVU8GV+yOB0fOViJG9JF+ffF/sqFCxdM9pkwYYIybNgwm7Yr7wj37dtnts/WrVtFn0aNGimpqakG77399ttKx44dhfVIu72AgACDfhEREQZ317AYBAcHi+cVfj2r5FudIB7ttex4citQoIDuvg899JDZ90aOHKk+HzBggNs/l6NbjRo1dPUbMmSI2fW/+eYbg2Uvvvhirsby5Zdf5rA4wVoqn/fu3Vv9jp8+fVqZNGmSsLbA6gquXLmi9r1+/bpFi5O2hYSEiD5aC6FkxYoVOZYZc/HiRYPtBQUFWTwPaL9TloAlGRYlY4vT8ePH1deFCxfO8Xm0SCsozifeCo5BgwYNlDlz5rh7KD5PnIuv404TTjdu3FDq1aunVKxYUfFkfEk4XRreJ9ud9UJPccI1dUKTJ6kTJ07o2mZmZqa6Dsz/5tC6W95//32D9+TyX375xeC1v7+/eA2R99tvv+U4kX788cfq86LLrwk3pHj0gAu3p7dWrVqpz/v16+f28XhDe/TRR3O9LtypWvfl66+/rj7v27ev2ZsDcO3af9/pq1evqudPiL5Ro0ZZ3G/z5s2V+fPnG2wP/P777+oyrUt82rRpwj2L35zWNWm8vim0x0cKrx9//FFJS0sTr+fOnausWbNGmTJlSo7tfvTRRwbuVWvCSe+YXA0+88CBAy2eCyX9+/e3+TMgjIHxceHUunVrk61u3brCFw+LAn5YnoyvCid8prt37yo///yz0rZtW3FXixOc/CH/888/yp49e5R///1XrCutRGfOnBHxMXgEhw4dUteZOnWqiEkwhfZEZxxTI5cjtsZYOEGY4dHahYmFU+4b/v/uHkNea3Xq1DEQTlK8GPfD71ArnHC+RJwfrFS52a8EAkYukxdjWHy1fR955BGz6wNYxDAWyWOPPab2w+cpWLCg+nrTpk1Wx6aNu0L8q6V9m1suwWfRCkKc6xDrJa3aso8ekpKShHVbD9q4Qmt07dpVd1+AmLXw8HBl2bJluvozXiqcELyJO1ttg3DCF+bVV19VL8qejC8LJ2PXw6xZs0ye0Pbu3SseX3vtNSF68bxy5cpimwh+Ne4/btw45ZVXXlGeeeYZdd/GfaQbwlg4GQc6Q2DruSCwcOLmTa127doGr3FB3LJli0nXrNZVZ259vU2C4Hi5TAoIravNXMMNFG62pKusVq1a6jYff/xxtV/p0qVtHtvu3bstWpxwzlm6dGmOwP8jR46IgPj4+Hgh0Lp16ybclM2aNVPH9vDDD4u+eMTN2M6dO0WYyPTp04U4hSjRCq2EhAThQsOxj46OFutCfJkDY4LALVq0aI5jbY4uXbqofT///HMRJjF69Giz/U39H10Njh2skjjOnmj92rlzp7JkyRJhUd2wYYN6nfEq4eQL+JZw6m0gnOxtX331ldU+OKFp4ym0Td7FydeffvqpUqFChVyNhYUTN29qxYsX193XlOUnt8Lp6aefFrE12mUQBO+++66u9bdt25ZjGW7AJk+ebPcx+fbbb+1aH7GZxssk2mUffPCBUrNmzRx9EQtmHNtVpUoVg89uis2bN6viV2spk0CQIc4NF3Utfn5+Jj8H/j+mMPW5LAEhBzFpDVj6Zs+eLcYJr4NxDKqW//3vfwY3tcafydFkZWXp+gyIl37jjTdMHk/EE3qVcMKPSWtZMAZuHvTxZFg4ObfhLssR22HhxC2vuvpsbeYuML44IQCTTh588EGDZeXKlTMpnBAvZsnytn37dnERhtUFwOLSp08fETRvqr9k5cqVOZYBc5/j7NmzBoIgf/78yvLly01uGyDuDWl9IDLk2CC+YHXD58RyxIjCMieBixVCUTtJAda8kiVLCvFnzo1p/N2RngdTZGRkiDg5U/G0epFeEYR3wBUMS6DcNmJiz58/L8JGLH0vbt++7V3CCYoagYnmwAGVAcCeii8Jp4seKJwc1Vg4ceOWt5vWOpTbBhcPBIep9+TsU7g59dzwSd577z2DZRA6ltY7d+6c6IdZyub6QCBhpjKEhHRrVqpUScSVQUggFk72ve+++9TnMjymc+fO6jryPa0ARM44WCExVsS6wmWJCQmmxiKD/435QZMPDs/hzsS40UwJM3xeCD70Q+C8qZx1cBMCWPDksu7du1s8nnArygkSPiGc4Nf19XQE+JJgxsiff/5psR/uCjANGWZkZwHBxMKJGzduvthkLJKnNIB4G+2yL774wup6SLFgbaarjDU11ZBQFW5DU+/BAgT0fgZYu6z1GTNmjBAvcPFh4lCVKlVE2gxTfRFThhQMiIFr3769EKGwHFlLWCtb/fr17fqfuEo4+d07yLpBkjvUVQJIqofq57JMgRZULEcl9BIlSohK6M4G5QVQRuLKlSsi+ebMmTOpUaNGVte7e/cuRUdHi0r0KGVRqFAhURMK9X1KlixpMikfEsGhvEHfvn1pw4YN9NRTT4n3jh07JkpBoJL6Bx98IAq2rl+/PkfRVxT8rFGjhuiHMgMoA1GwYEEqUqSIKHyKCvFI1IdEe9qirxL8y1Ce49SpUzRlyhTavXu3SBCZNH4olUy9TRdCYqjU5z+RL1F0+TW6ElmIiiZcpysdCrt7OAzD5HG6detGv/zyi7uHwWjAdTwqKoqcjq1KC1YTWJrQ4IaTz001+KSdHVwmXYJIlIiEdphBgdleUNIyJ4oei5Op9sILL7j9rgYzFOVdAYKrTc3MkY0tTty4cePGLa+2OE+1OCHlP0pjYDUUD0QRTOMK6ihLAKuNKWuJM0C5gIYNG4p0/rIcQ6lSpUQ6f1mewJrFyRd47NPfKCwyHyUnxNOKYY+TLzH3tTEUERFJiYkJNPC9d9w9HIZhGCaPWpwCbV0Blbtl9e7Tp0+rri13kZaWRnv27BFVw7W1oeAeQ70qY1CnSlurCsLJV1hRuDZRoZJE132vvlObczuoZEQoXUhMcfdQGIZhmDyMXUV+y5Qp41bRBG7cuCEKeSI+SAteI97JmGnTpgkLk2ywTDEMwzAMwzjc4lSuXDlhzTly5AgFBQWJ13DLWQLvayveuxtYphCArbU4sXhiGIZhGMbhwqlly5ZCCEE8aV+7E8xGCwgIEDPitOB10aJFc/QPCQkRzRepF3eGgukupcXdor3kWxwoWJnOR0TQ7bBEzG1093AYhmGYvIriAyAvBtLxa3MrlShRQk2mpWdW3cKFC8V62A6SeSGBF0qG4PHWrVsiP4WpwpSoTm6ujALyV1iaAdCjRw+RITUwMNBgOYqCyudHjx4V40QSMplVFVlhUUA5X758Im+ILIfAs+q4cePGjVtebXHekADTU0A6AmSDRS2kw4cPi6yomMKPbKiOTICJ9PWoywZBhTT7MtU7BJoUOBBf6CdBhlRUp//777+Vmzdvikrcf/zxR47MqlgP20b9IZkwU291bwDxxMKJGzdu3Dy7IXWOLKxuqk2dOtXkclwbIiIi3J4MdOfOnW4/hl4lnFDsMDfNFcycOVNkK8WXEhYovfmjfKXkCixXLJy4cePG7b+Gm1pb+qMKxMaNG8VNq7PGhMLo4P777xevDxw4YFASBuAmW7sOMpRLcGOOG2tr+2nYsKHy4Ycfim1qy7Joj0316tXV12XLllUmTpxocZswSgB4O+Syjz/+WORMRImYHTt2qMtRx/brr79WmjVrJrwvqIMHA4J8//nnnxfHAt4hU/u6fPmysnv3blGg+LvvvvNe4SSTXuptsr8n4yvCCVwY2ssjhNOrr77q8G2ycOLGzfUNRVj1FupGHTJL76PIrj1jeeihh5Tjx4+bfR/hFGFhYQbL/ve//+kqZ4J6Z7hAyyK6AOIJN+AoJKwVCrIhvCM5OVk5duyYgQAx1VB6RD5HbTtjUOQXliYIIol2fVNAmOA9bfmVdu3aCXEDQ4IWFBbWbu/kyZNiObwm+Oy48ca+UevOmmgC+/fvF0V58WgMxCeKDpsDlrNly5aJfUpOnDihPP3008Lwge+bKYyLOcv26KOPKhUqVPBc4YQDnJvmybBwyn0bP368yeWvvPKK+nzWrFnqc/yYtEUnbWksnLhxoxzxkHra448/LiwYsKRY62tsmRg9erQ4t7Ro0cLqusDU8po1a4qL8ptvvpnrz12+fHk1dAFxqOb2j/AMWCdgTUGsKOJC5fsIm8AyiCPtegid0MMnn3ySY3+mWLp0qUE/WFa0xwaCSw+ykC/GbQ7E3+LzzJs3TwgWSyxYsECEg1iqqHHkyJEcxxU1Z4cOHeqSa2SmRrgaA+GsHdf58+dVoenq67hPxDjZQ14RTiNHjhQmVVtOVjDxSp+6uRMVfrjGyw8dOiQe8UUH2rsokJsTJwsnx7eqVau6fQzc9Df8jsqUKWPzerio6v3toaQT4jW1BV6le8jSeiNGjDB5cUNDQVggJ7GYa5GRkepzAAvW3LlzxWQYbbwnCtkarwtRZgpMqpF9ZByq9jjExsbadI6F+6h48eLqcTHXR25/z5496vJVq1YJa4olcWCM8bnT2WBsWstOVFSU4iksXLhQHZexpctrhRNULCogo+mpEecp+Kpwwl1P48aN1S8a6vgBPSfadevWKevXrxf94SeXy+F61faTmDqB4U7P3AkiNxcNFk6Ob7AEuHsMvtpMxW3ImJbcNBkrijhOZwkn1MI07qcVCJbWlWhnBMPScu7cOfU9a/EzuEgbb8+c5UT269KlixAkloCrrWXLlgbno1q1aon1n3vuOcVW9IgZfG5vvqacOXNG1HzFZCtPISsrS7gn4R41xuuEEy6y9evXzxHfhGVr165VPB2fEk7D/hNO8m6rQIECqlkT6DnRaoHPXC7v16+fyX4wdcMdgPgDPVjaN+4u4ec29t2zcHJ8Y+Fk2KylD9HTEPwKjN1BaHC9INUJgmTlMsSiwJqC+BHMCoYFBMuHDBlisK6kV69eVseA8+7DDz9ss3DSTuSRy8aOHWtyXcSozJkzRzyHC0uCIutYhouuMdrPbarFxMTk+LzmLqCIXdJ7vjEXZwOXHs43jPcT503C6ddffxX5hKTpElYNNPjFsQz+ePTxZHxJOF0a3lsIp4vDeqvLoM61FkDEJSHQ0VIAt/GdB3JVLV682CBewNrJzRLG+2vTpo0w42NWBkA8Bu50kOdK9mHh9F+TQaF6W+XKla0KJ8RRVKlSxe2fzZ0NLiVb1ylUqJDBa0vfc5keRRsDY8rNg98aAmdlTBCCqiWmXOPa70OHDh1y7F+vcIqPj7conFavXi2EHcYnQXCxMUi5YsoqM27cOIv7L1mypNnjwjA+I5wwk6B27drK3bt3c7yHD4BAQ/TxZHxLOPURwkk8WkDOoMAJFXeIQUFB6gnr559/triuuYuELWi38frrr6u5q4yB4OvUqZOYJlt8xQ0WTveapZkvppo5QaQVTsAeV5InNlhcrcX1ad3Z+B7aug/EDmpfm/ueyzgfaY1CTJBW0JgDn8EYxM28++674iZIzkAyFehsi3CCJcvU2LXCyd6YG9xQy+3CRfbAAw8YjAEuNVPHkWF8SjiFhoaKE5M58B6mh3oyviScKm9KVPKtThCPtiATmiGw01rgol5zuiXMXWgscXf0YCVuSBfl36cecfsF2d0N1jhL7xvnPDE3hbtGjRoG/wfkW3H3Z3Nkk99lWL0Rq9e1a1eT1k75HJYSW/fx0ksvqVPRcRNp7/c8twwaNEhp1aqVwRRvue/58+ebHJN2BpVxrI92Vqyj0Fq5jfeD3HtaYcUwnnwdzy46l0uqVq1K165dM/s+6sVVrlzZnl0wNpAYFE7xwRHi0RYaN26MMxWtW7dOrUNojjVr1lDdunVp/fr15EryZaZQVHoSRaYnU17C1O8n+3pjmk8++YT69eunvn7llVeoYsWKJvsab2fYsGHkCXTr1o1u3rxp93ZkHc0uXbrQn3/+SYsWLRKFySVr166lsLAw9bX2OWpg6iErK4t+//13Gj16NC1fvpzcxddff00bN24UdTstgc8sCQ8PF0XPCxUqRG+88YZBP3ymUaNG0eDBgx02xqefflo8PvLII+qyLVu20Pjx42nbtm00btw4evLJJ8X/iWE8GntU15o1a4TPW5vVVIK7PLzn6QHivmRxKrFdEe4sPHoyMrssAkx1MyrbDXm+Z0u3WzJc2bTJ+hDw26BBA2FVMNd/xowZ4nBpc2ppX2PiBrIJw8pYrVq1HHf4sGblZsq7o5rMiizj6y5cuCAejftpJw4Yz/a0ZLWA21f7PmKCtK8R6IzYOsTuIMbIlFsUEyHkc22NTGOsjcXZmLI4IaxCLpcz3myZHm8vOM+6eoo94/vEeZPFaebMmeJupWvXrlSqVClq3bq1aHiOu8bChQvTjBkzqGPHjmrr1KmT41Qf45U0adJEWDs6dOjg7qF4NLDYaq1CsALAcqK1Kjz11FM2b3fkyJGqldGYatWqUb169XI13tdee42OHz9u83pNmzZVLT4hISGqpahMmTJUokQJ8WjMkCFDDKxseunZs6d4rFGjhng0PgYvvvgi/fTTT5Q/f35hhYFVXVKnTh3av3+/gUUkMzOTPJ18+fJZfN+aldmRREVFqf9fhvFW7PrFHDhwgFJTU6l06dIUGBhIZ86cEQ3PsSwlJYUOHjyYozHO4ZlDi2ji3z+IR19jern2NKlWX/rqvu42rdeuXTuD19HR0epzuG0WL15scf0vv/zS5HK4GPTw1ltv6eq3b98+OnHiBDVr1kxdhhsP7YUdFxzji0737t3pxo0bBn1MiRKJdnvmXH4QD6aw5CIEDz/8sHALQlxo0brHTAGh8vbbb9Phw4fJ2UyaNIl+/vln2rx5s+pq0wvccbVr16bg4GB1mS3ru5oPP/yQevXqRY8++qi6TDv2yMhIN42MYbybQHtWhkhiPIdnDy2mYkk36HI44jOeIF8TThfDYqlownVE4+heD3E7q1evVl8PHTpUXKSlEGjVqpXF9du0aWNyeYsWLXTt39rdNYRZbGyssGYAWDlwoevbty/ppUCBAjmWwfKzd+9eYQ0Gzz33nNgXhIM1IWTtmJj7nLBiAYgLXJQTEhJUiwbi4iAOTYGbLMTa2IJWsISGhupeDxYtWMNNbccc27dvp507d4r4G2M82eIEy6Kpz4+bhbS0NIqJiXHLuBjG23GdjZZhXAzcPNasJNaETdGiRc2+9+mnn9o8Jm1grBRg2gt5+/bthYvu+++/17U9Of5nnnmGSpYsqbruYPnBhV6+/9lnnwlrLwJxHW0t+eCDDygxMdHAgnH9+nWDMcLNiDEEBQUZrNu8efNc7bNz585qEDdEJrYDUbhixQqbtqPnGMAKCBFiyqWlDSg3J661/19PAMfOlAhkGMYFFidJeno6Xbx4kW7fvm3yQpXbmAmGcTR64isgiCBgcKHEzCNzwHplaSYaZsQZ/x7gJsLMJmkJMnUxhotOYk34Sb766ishAszFqyAuqmbNmgbL9Gwbrs24uDiLfbBtYwFhbAXCZ3rhhRdo0KBBQmTB6jF16lQx7tzQsmVLYcGCGxD73rp1q1h+5coVm7aTW/H4+eef09y5c2nChAlm+yxZskQ0uFMZhvEd7LI43blzR0wxRcBfhQoVqEGDBtSwYUO1ydcM44kgFs8c5cuXp7Jly+Z624ihgavMGFhltDEn1qaPQ8ABuPNMUb9+/VwH+eoRTrDiwELxyy+/iNcyUHvhwoU2bUcrqOBaxHnj9OnTIhg9t8C9qY1ZkxZChBDoTWeQW+H0/PPPi0B9S2kL8D+DULQWnM0wTB6yOA0YMEDkLsFMFcQ3GJ/EGMbdGF/UtXEdxm4jCWaGakHOqo8++oh+++03i/v6+OOPacSIEeJ59erVKSIiQgRMG+fI0Yola/mCIFwqVaqUI8j91q1bFB8fT8WKFaPcokfwIN5JfiY5IeTo0aPipkjPLLv33nuPpk+fTq7E1Cw8cyD2asOGDU4dD8MwPoY9uQyQFRylA7yZvFhyxRspsfKm2ZIryAptKo8P6iUix5h2mTY7dNu2bUVJC23BVeTtsSUvj3aZto6YtgyRqfWQy0pbVNUdGOc00nLs2DFRwNsSct1NmzaZ7XPnzh2HjFV7DJG93lGg/iLKluzfv99h22QYxrev43ZZnGByN5eVmGE8EcTDrFy5UliQ5syZI6xOZ8+eFS4be1xz0pqF3GaIo9K6Z7APxAHC/afNZeVuLFmcYOVCs8SRI0dEQ7yRORxthYZle+nSpQ7bHqyCkydPdtj2GIbxfewSTs8++6zIwQJ/vyuTqDGMFltibGTckIwdktPhHYWpYHHEwiAQGs2bj5sxVapUEc2VPPbYY1SkSBGX7pNhGMZhwglTm5EAE/EOmAaN6dCmgl3lDCKGcTXGM8ncAYKYMZvO07BXOLkDbSZvhmEYrxNOSEGAwEpkCjbOFiyB28KTk8T5EgcLVKAz4QUpPiyach8y7JnUu3uGSiVcpcjEW2Rpwjlmcf7111/qa8z2xCw2uOeciaV8Pp4KbnxgNc5N2RZXs2PHDtq1a5fH5URiGCbvYZdwwlRbTLlG1l+eVed+BrWdTBfTiEoEE10g32LZ7ulEt2/QhcQUKmWhH0QApujPmjVLdY2h7IgjhBNmmG3atMlkLJS5GXqeDJJmPvjgg1ZLongCiAnzhLgwhmEYu4TTtm3bRP0mDq5k3Amm5CP2BeKoR48eovD066+/LlzHjgTxfEh8iBsGCYpYo7bbjz/+SN4ILHIMwzCMi4QTks2ZS8znKmBVQJkFuApRwBJJORnfxTiTN9xwX3zxBRUvXlzU30ItLqAVTY6K5UFQsvFNwvDhw0UdOG3xVIZhGMZ3sWsq3CuvvCKmdMtinu4AF0uUNMDMPsb3wZT/Cxcu0KFDh+jkyZNCNKMmHWLppGgypkuXLuKxVClLTr7cw6KJYRgm72CXxSklJUXEdsiCorgwGc+qwwXt5ZdfJmchLQDffvst5XW+WTuR8iXHieBwauZb7tOODUbSdf8wKpSVTMtKlBBiyZaZdcjVBBcewzAMw7hNOI0aNcpqpXhnCydbQfoENMndu3fJV7jv5kkqlnSDLodbLuPhjeyNKksXw2KpRPKtXK3vyFxNDMMwTN7FLuGEIp3WQE0tT2LatGkczM4wDMMwjOtjnFBM01RD0DiyJb/00kvUrFkzm7c7ZswYYamy1FDqITcgdUJcXJzazp8/T75CZIDho08RGmr4yDAMwzDeZnHSgplLqCI/f/58Wrx4sXCBIaakV69euQo6HzBggMU+2rpftoAAYnNBxN5OvkDDR58iJJwo7d4jwzAMw7gJuy+xe/bsEWIJOW6uXLkirEE9e/YUNbuQsA6vbQWCiwN5GYZhGIbxCeF06tQpIZbQjh8/LmY49enThxo1aiQSED7xxBMiW7MrOHfunIijwiNKu8jSL5jpFxkZ6ZIxMAzDMAyTN7BZOEEQIX6pYMGCom4U8jg1b95cvIe8Oq5mwoQJ9N1336mv69atKx43btwoSmQwDMMwDMO4TTih0CZqW02fPl2UuQgMdG9ADfI3cQ4nhmEYhmE8clYd8jWhNhiyMWP2HMpNwLrjqLIWDMMwDMMwnorN5qIXXnhBNORwQowTipvOnj1biKjWrVur6QIYN9C2C1FyElGY7808G1mK6G4GUZQvzhhkGIZhvAY/xQGmIjmzbsGCBXT58mVRDLVDhw7UsWNHatOmDYV6cO4dpE2Ijo4WOZ2ioqLcPRyGYRiGYTz4Ou4Q4STJysqiDRs20Lx580Qup/j4eFHN3p1FgK3BwolhGIZhvJe73iycjAsAL126VLjy8Oip4EDnz59fZBBn4cQwDMMw3iecSpUqRXfu3BECymuFk7eAnFQVKlRw9zAYhmEYhrEDpETKbVURW8jzobaxsbHiEQk0XaFU84LqZ+ud/fCxdBx8LB0HH0vHwcfSsZ6j0qVLq9dzZ5PnhZO/f3ZGBogm/vI6BhxHPpaOgY+l4+Bj6Tj4WDoOPpaOv547G9fshWEYhmEYxgdg4cQwDMMwDKOTPC+cQkJCaOLEieKRsQ8+lo6Dj6Xj4GPpOPhYOg4+lt57LPP8rDqGYRiGYRi95HmLE8MwDMMwjF5YODEMwzAMw+iEhRPDMAzDMIxOWDgxDMMwDMPohIUTwzAMwzCMTlg4MQzDMAzD6ISFE8MwDMMwjE5YODEMwzAMw+iEhRPDMAzDMIxOWDgxDMMwDMPohIUTwzAMwzCMTlg4MQzDMAzD6ISFE8MwDMMwjE5YODEMwzAMw+gkkPI4WVlZdOnSJcqXLx/5+fm5ezgMwzAORVEUyszMFOc6hvE1/P39RUtISKDixYuL584mzwsniKZSpUq5exgMwzAOp1ChQvT8889TgwYNKDAwkG8OGZ+7KcjIyKC//vqLZs2aRXv37qWSJUs6fb95XjjB0gTOnz9PUVFR7h4OwzCMwy4qFy9eFIIJAiooKIiFE+Nz3/H09HSqXLkyVapUiSIjI12yX7uE065du6hx48bkzcgTCUSTNwun9Mws2nbiBjUoE0P5QoPcPRyGYdxMSkqKOL/hDjw8PNzdw2EYp4Gbg4IFCwrrkyuwyxnYtGlTofTefPNNOnXqlONGxdjMyoOXafC3f9FHa4+7eygMw3gQroj5YBh3f8ddaU216xc1b948YR6DcMLj/fffL/yMt27dctwIGV3cSEijLAWPqe4eCsMwDMP4LHYJp969e9OKFStEgPUnn3wi/I0vvPCCiGzv3Lkz/fLLL5SWlua40TJmCfTPVtuZiuLuoTAMwzBeBiw2aJMmTRKvN23apC47c+aM28Z15swZdRzffvsteQIOseHCtzhs2DD6448/6Pjx4/T666/TkSNHqEePHlS0aFF69tlnadu2bY7YFWMGiFaQmcnCiWEY76ZVq1bqxRItICCASpQoQR06dBDXGcb5IOYXMcxoISEhNoucTZs2ka/icOd3WFiYCEQMDQ0VF3McwKVLl1LLli2pYcOGdPjwYUfvkiGiScuzj+vv/1whn+TAz0RzHyNKuO7ukTAM4yKCg4PFhbtWrVp07do1+u2338S15M8//3T30DwK5OlCcyT16tWjnTt3ilasWDGHbtvbcYhwio+Pp7lz51KbNm2oTJkyNG7cOCpbtqxw1V25ckW48hYsWCC++AMHDnTELhkLXL2bQj7Hr08Tnd1GtC7bjMwwjO+DCzYu3Pv27aMlS5aIZZg59eOPP5pdp2/fvuKG/bHHHhOvIShgPcGylStXimXffPONeI10NNhecnKyCC8pV64cRURECAsL4nYnTJighpu88847Yh2kdtDO3nrqqafE8iZNmhjE/8JQACMC9vHII4/Q/v37LX5WuKG01pq6desKAwRE4+bNm9V+cKWhD66x33//PVWoUEEITKTUAatWrRLiEvuFIaNFixa0ceNGg30dOHBAjBfbr127tkmPkDlX3dq1a8W1Pjo6WqxftWpV8Xkxfhw/SevWrcW6sB7aclww1po1a4ptN2/e3CONLXYJJ1iSnnzySSpSpAgNHjxYCKiPP/5YCCV8ybt27Spyh8DM2q1bN3rjjTfED4BxLklpjr3z8Ciy0t09AobxepLSMsy2lPRMh/Z1NfJCvWPHDuH1gEjAtQlIgbB161bxiAlNmMqempoqrmcQUJgpXrhwYTpx4oSY+ITQEynIMHvrxo0btH79ejXlA9YDAwYMEI/vvfeeEFO7d+8WyZUh2lavXi1EwL///qvrM0D0YUzY38GDB8VrXFe14DX2ifHjGgxgoEDfLVu2UIECBYTwxGdu27atKp7wGR999FGRTgjZ5JEHSYpMa/z888/Url078fmxHsTl5cuXxWeFoKxTp47at1q1asJaWL16dd3HBYYWuGP/+ecfoRtu3rwpNIbHodiBn5+fUrp0aWXcuHHKkSNHrPbftWuXMmDAAMWTiIuLQ1CQePRmnvnuL6XM6N9EO371ruJzfH6/okyMUpR/lrp7JAzjFSQnJyuHDx8Wj8bIc4WpNuCbXQZ9q76xymzfJ2f9YdC37pQ1OfrkhpYtW4rzcnBwsNK4cWOlTp06SmBgoFiGx507d5pd9/jx46If2sGDB5UZM2aI51FRUUqLFi1En4oVK4pl06ZNE6/T0tKUf/75x2A7ffv2FX1KliypLmvbtq1YNnDgQPH6119/Fa9DQkKU27dvK4mJiUp4eLhYNnnyZNEnPT1dadCggViGbZpj7ty56rhnzZollh06dEj93KNHjxbLJk6cqPb74osvxLKsrCwlMzNTKVu2rFg+aNAgsQytS5cuYlnz5s1F3zlz5qjrr1q1KscybB9s3LhRXXb69GmxrFy5cuJ1hQoVlMuXL4tlqampYpwA/eQ6WF+i97i88cYb4nVAQIC6TbkMDcfIFAkJCeKzXL9+XXEFdlmcNmzYQGfPnqWpU6dSlSpVrPZv1KiRcOkxjmfN4avq80xfK0mVkUZ09aC7R8EwjIuBmwyWEViNYNGAZQRuK1gyUF4D7iZtAxUrVlTLbmzfvl00TGCC1wOlOeDSgjVJa52CZQduJFib4KaDiwmvgdbS079/f/G4ePFiMTZYeECnTp0of/78wlKSlJQklk2cOFFsB14XWFkA3I566NWrl3isUaMG3XfffeI5LE9a4IbDxCuA/cA6I11qcEXKGm4YK8BxBBgjgLsMrjKgx6pz/fp1On36tHiOkBtM/AJwE2KcltB7XOTYoCfkNj3R4mRX5nD4V/HPM5c9HAF8yOuEfyLjOjKR0MmXyNTkpkpLcOdIGMYnODylndn3/I0SCe4Z30Z3322jW5MjQcysuanwd+/eVcWAMYjxmT9/vnBTQTg1a9ZMuIRwLUI4CUB5DtTwk/FL06ZNU/cJUXDhwgVRskZbHLlLly4iNufOnTtCkCBYXSuotMBVZVyNAu4zRwEhaS65afny5cX7xmjTA7mr/E41Jx8XV2CXxQnBYCdPnjT7PtTpd999Z88umFyQ5Wu5nEKy6wkK9psPCmUYRh/hwYFmW2hQgEP7OgtYixDDpG3a98Dy5cuFAEIsE4QT+Oqrrwzim7QWD1icINQgthA0bQysNN27dxfPR4wYQYmJiUJkIe4HwEoCYwKANQdxVnJm2hdffKHGS1lDWrIQ+yMtTdLyZE74QChB9MkZcRCNct8wciBeS2sdwtjXrFkjnmMilzWwfRn8/e2334rJXgCxTjKAW1vaB9uX6D0ucmxHjx5V4570jM3VODUXP0yc8mAxzkN7wvBJi5OWaOdXvmYYxruRwikuLk4VSQhkRtB3QkK21Vo72wsz18CxY8eEOIAAMedWk9YlBDLLoHEEMkvhMH78ePH8o48+Ei5DBEzDogIxI4WKNUaNGiVEBCximMGH7Q4fPtzqem+//bYqNpCIGjPzIOzg+oIFTiauxnsAgdjYj55tg3fffVcINrg6cZxw3CCopBjFc2k9QiA4vFEzZ87UfVyQQBt9MRMSnx3WKQSVe71wwgyCQYMGiQZwwORrbcOMOvgyMfWQcS7GQsnnLE43NVZNP8M7XIZhGGO0cU6wskiXHASURCuckEIHgghxSnAB9uzZU1zETYHp/dpp93I2nWTs2LHC04Jr3+3bt4XIgGAbMmSIuC7qASkFMB0foglT82E5QwJQa0AUyVxXmD0Hyw1ci/369aOnn35a9IExAxU/tNdmGQdlDVjbVq9eTQ8++KCw1kFoYkafPL4QVbNnzxbHH8cR4TqIg9Z7XDALcNmyZWImHj47xi4FnyfhhwhxW1aAH1iqWgR74UspzZ3qRv38RC6M+vXr0/Tp04X501PBPxf5KHBnYux39RaS0zKp2oTfxfN/JrejiBDnmcfdwqTo/57X6ELU3TPS7jOMJ4Op8giXwEUeF2HGs4H7S+Y5tPGynOdJTEwUKSYg4DARwNnYfIWFakQDCEz7+uuvhcpl3EeaZhpdUICPV0K/dsTdI2AYhmHyMHaZJrSzDRj3ERLoT2PbV6X0zCwKCnDPTAmXcV1fAjmGYRiGcQY+bp7IG2Bmy3MtK9CdpHR69oc99M+l7IBIhmEYxjtArJTx7EDGB4QTXHOIZ5K5IPAaswksNeP4J8Z57Dh1k9YevkrX4zV5j3yN/KXdPQKGYRgmD2OTqkHBQwR+SzEkXzPuBfWijlyJp+PXEnxzVp2WkjxLk2EYhvES4YSqzJZeM+7h3K0k6vzZdt8tuaIly/VFQxmGYRhGwjFOPgCCwvNMAswsw2rsDMMwDOOxFiekbc8NSL7FOI/0zDyUOZyFE8MwDOMtwsk4Q6oeEAPFwsm5ZBhZnG4m+nBwOLvqGIZhGG8RTshCy3h2AkwwYek/1K9pWfIJ7pz/7/kj7xKVa+HO0TAMw/gkcqIXSqUhfnnTpk3UunVr9dpftqx7rilnzpxRS9zMnTs3VwYctwonWXmZ8WxX3Yg2lchnyMxOfSGAaCqSXT2bYRjfBSlvPvjgA5o3b56odYbUNqhrdt9994mLeu3atd09RJ8HJchQpBeEhITYLHI2btxoUA/Ql+AkSz7oqsvypRgnRfPZfDnNAsMwKq+++irNmDFDPK9UqZKotYeL8pIlS6hPnz4snIzIzMyO/YTAdBT16tWjnTt3Omx7eXZWHcx2Dz30kKhaDFAh2VpDf8a5lC0YQS89VInCgrJ/NGlGFiivRiuWjq4kOrzMnaNhGMYFLFiwQM0VeOzYMTpw4IAoxL5t2zaroqlv377C7fTYY4+pogLWEyxbuXKlWPbNN9+I1/ny5RPXs+TkZOrcubOwlqBAPSwsEGzYv0z4/M4774h1ChUqpF4DwVNPPSWWN2nSRF0GS1nDhg0pPDxc7OORRx6h/fv3Wy3yi+2gwU1Wt25dIRhr1apFmzdvVvvB4oY+cJ1hwlaFChUoODiYzp/PDmtYtWoVtWzZUuw3LCyMWrRoIaw/WnA8MV5sH8cTx9UYjEGOB6JVsnbtWmrTpg1FR0eL9atWrSo+L8YvrU1SL2BdrdVJz3HBWGvWrCm23bx5czp8+DB5tXBCKnhtfTo8lynizTWuZ+d8KhSKpJfbVqZ+zcqYtEB5NVHFiLp/S1SrB9HGqUQ7PnP3iBjG+0lLNN/SU2zom2y9by6Q1401a9bQb7/9RlevXhUX4fvvv18IGkvIC/WOHTvENQgiIT4+XiyTAmHr1q3iEdtDQufU1FRaunSpEFCVK1cWbsETJ07Qm2++Sa+//roqyFAt48aNG7R+/XqxLCUlRawHZOzNe++9J8TU7t27qVSpUkK0rV69WoiAf//VV2sTog9jwv4OHjwoXl+6dMmgD15jnxh/kSJFVMGJvlu2bKECBQpQsWLFxGdu27atKp7wGR999FHatWuXOM7p6emqyLTGzz//TO3atROfH+vhf3H58mXxWSEo69Spo/atVq2acPVVr15d93G5cuUKdejQgf755x9hPbt58yY9+eST5HEoeZy4uDiYNMSjt/PB6iNKmdG/KROXHlJ8jn9/U5SJUYoyu427R8IwXkFycrJy+PBh8ZgD/JbMtXndDPu+VdR8328eNez7brmcfXLBxIkTxXlZ26pUqaJMmTLF9OfRcPz4cXWdgwcPKjNmzBDPo6KilBYtWog+FStWFMumTZsmXqelpSn//POPwXb69u0r+pQsWVJd1rZtW7Fs4MCB4vWvv/4qXoeEhCi3b99WEhMTlfDwcLFs8uTJok96errSoEEDsQzbNMfcuXPVcc+aNUssO3TokBIYGCiWjR49Osex+eKLL8SyrKwsJTMzUylbtqxYPmjQILEMrUuXLmJZ8+bNRd85c+ao669atSrHMmwfbNy4UV12+vRpsaxcuXLidYUKFZTLly+LZampqWKcAP3kOlhfove4vPHGG+J1QECAuk25DA3HyBQJCQnis1y/fl1xBZwA0we4k5RGx67G083ENJOz7HwCP/+cMU8Mw/gkcEf9+uuvwvoAywQ4evSocJ0NGTJEvN67d69wN2kbqFixIpUsWVI83759u2gFCxakbt260V9//SVcWrAmaa1TsOzAjQRrE9x0sG7hNdBaevr37y8eFy9eLFx40qXYqVMnyp8/v7CUJCUlqbPTsJ2goCBhZQF6Y4Z69eolHmvUqCEC4gEsT1rghnv22WfFc+wH1hnpUoMrEp8JDWMFsDABjBHAXQZXGdBj1bl+/bo6s37gwIFUtGhR8RxuQozTEnqPixxblSpV1G16osXJIcHhMKXCdyz/afC9whT4+OOP52p7n332Gb3//vvCbAf/68yZM6lRo0Ym+8Kvin+iFnzxYULNK/x24DK9seQQBQf4U69Gpahh2RjyGZJvE53cSHQm27ROF7N/aAzD2ME4Q7ePAX5GAcavnrDQ1+jee4Thxd0eunTpIhrcSXv27KHBgwcL8YAAcXD37l1VDBiDGJ/58+cLNxWEU7NmzYRLCILi448/Fn0iIyOpQYMGavzStGnT1NnjEAUXLlygixcvGoSbYDyIzblz544QJLj2aQWVFriqpOiTwH3mKOAagzAyRfny5cX7xsh4LeCuOrPVnHxcPF444cuDLxL8qfBHwp8K1q1bR19++aUISsOXHEpcL1DwI0eOpFmzZgn/KL7k8KnibgN+Z1Pgn4D3JXmt8LCMaWpbowhN61qLfIo754h+MRTGDMPYSXCE+/ta4I033hAWIsTMQBwgoBjWIAgnBCVLaxFimEyB9yCcli9fLoLKhw8fLoQT+Oqrrwzim7QWD+wD1xIElHfs2FEIJy2w0nTv3l0IsBEjRlBiYqIQWbhGAVhJYAlCHBGsOR9++KF6Pdq3b59Yrvc6+Mwzz4jYH2lpkpYnc9c5CCWIPqRvwIy4//3vf+rnQ4A9lmutQxg7Ysgefvhh+uWXX6yOCdtH8Pfp06eFwQLjwzUZsU7Hjx8XsUw4PhJsX6L3uKAfBCn+B/jsEFl6xuZy7PHz9evXT/gi33//feFjlOD5e++9J95DH1to1KiRMnToUPU1/LbFixdXfdHGwOcZHR2dp2Ocvtp8UsQ2jfhpn+JzXNzrkJgJhslrWIxx8nCKFCkizssFCxZU6tWrJ+KMZJzLmDFjrK6vjXNC27Ztm1heuHBhdZn2mjJu3Dh1OeKESpQoocTGxqrLtGzevNlg26NGjTJ4/+2331bfw7Wrdu3a6rZk/JC1GCfEY1WvXl2NC8LjhQsXDGKcypQpk2Mb8+fPV7dRqFAhpU6dOuqx7N+/v+iTlJQkxoVlwcHBYj8RERG6YpwWLlyo+Pn5qWO67777xPX3pZdeEu8jpqpAgQLi/ZiYGHE9R4yZ3uNy6dIlg89ctWpVJTQ01LdinGBNeuGFF2jUqFFiCqcEz5GH4/nnn1fNqnqAGREmWUx1lOBuA68xQ8IcCQkJQmkjUh++ZuknNQVmKsDEq23eTrrGlIx4p7sp6eQzcEwTw+Q53nrrLXEuh1vsyJEjdO3aNRH3gvgYzHSzhjbOCVYW6ZKDlUminSY/btw44W6DdwTXhJ49e4prmyngSdFOuzfOZD127Fj67rvvhJXs9u3bIp4KlhnEZnXt2lXX50dKAUzHR9oDTM2H5axEiRJW1+vdu7dwH8JVCSsOLDc4hih79vTTT4s+sPysWLFCjE8i46CsAWvb6tWrRaohWLNgycKMPnl8YUWaPXu2OP44jn/++aewdOk9LvBaLVu2TFiv8NkxdlgOPQ0/qKfcroyAu8mTJ9PQoUPNxirhi47pm3pAEB6+HH/88Qc1bdpUXf7aa6+JPBam/NkQVDATItcFTLLINgvXIcST/OEYBx1izMZgXWO/q7fwybrj9NG6YxQU4CeyiD9UtTB9PeC/H4VXc/4voq//E9KCSXHuGg3DeA2I84RbBRd5XIQZz0Ybr2vHZTlPkpiYKFJMQMBBlzgbuyxOTzzxhMjrILOWaoFaXLhwoVCozgQCC2oavnCobMzEgC8WMVamgOqFSJJNJg3zZjLuWZxkAsx0n8wc7kdU4UGimk+4eUAMwzBMXsam4HBM/9SChGDDhg0TMxYwLRLmOQALEALw4HpDeny9QCkiyBzJzrTgtZz6aA1McUTGVTnd1BjMuNNbd8dbkOkHwoMD6W5KBqVnZPmecIotT/SUPnMywzAMw3iEcIIZzDiSX5oUkR9Dvqc1M8IKZMoiZQr4ouvXry+ykiL9PcBUULyGQNMD9oVZCEiHkFdoXC5W1Ke7nZROv+y5oFqgfEo4GU97ZhiG8SEQK2UcL8X4gHCaO3cuORukIkCQHkQacjchHQH8l9L3C7cc4qBkzo0pU6aIxGewdiE9AvI/IRhNBsLlBR6sWkS0dYevCuHkU7XqClQk6vQ5UXA40dYPieIuEj0yjSjQt6yGDMMwjA8KJ1NJvhxNjx49RIZSZIhFAkzELv3+++9qLZ5z584ZJP1CdD7ySaBvTEyMsFghuFzWx8lLBAb4+V6tunxFiOr2IcrMIHrzXpK06h2Jyv83I4ZhGIZhvCpzuKOBW86caw4Vm7V89NFHouVlrsenUmpGpphRB9J9SThJ/DXZjK8fY+HEMDrhGVpMXviOKy78ngc6YsrrokWLROA4Zqlp09MDxD19/fXX9u6GscBbKw7T0v2XqFej0tSpTnEqFh1GPkPCdaJLe4lCs7MFCzL0Zd9lmLwMJsoA1AhD7h6G8VWSk5PFZDSZKd3Z2LUXxBK1bt1a1KhD4jAIp9jYWBFrhCBtzJJDPSDGuUgLU7Vi+ahf07LkU1zeT/Tjk0TFav+3LCPVnSNiGK8AM5RxXkbySIByGHmtHBXj2yiKIm4M8B1H4kzoEY8XTsgODrGEOj8oKogsoKixg+ysM2bMoE8//VRkGWWci3TRBZop+Ohzs+quH3HbcBjGm5BpXKR4YhhfJCIiQkxec1XYjl3CacOGDSItPWa/3bp1S1WAyJMEUYUifSiEiPTujPMtTggOT8vIEukIkNPJJ0i+nf145dB/y9jixDC6gIUJZSxkMVaG8UWXdGJiovfEOMFEVrZstmsI5UrwI4UFSpvVG3XsGOeScc/idOF2MlV+YxVFhQbSgUnZ1bq9njVvZD9maU76yCDOMIxNbjs0hmHsxy7fTunSpenChQviOYKykF8JbjvJ4cOHuUaSCzOHy5IrGb5UciUt6b/n1Trce+JDn49hGIbxKuyyOKFC8tKlS0UhX4Csp0hMidxKmF33ww8/iISVjHOReZvCgwN8Lx3B6DNEG6cSVWhNFBRBVKsHUdH73D0qhmEYJo9il3AaM2aMKLWSmpoq4prGjRtHly5dol9++UWYhXv37k3Tp0933GgZk7SvWYyqFYui8oUi1GBx+Ht9YgZNYDBR28nuHgXDMAzDCPyUPJ4d7e7duxQdHS1isxCn5c3EJaVT7SlrxPPjU9tTUIAPzrJjGIZhGDdexx029Qr6C6VSQKFChXzD2uGlJVdkwPi9kCfvZt4TRCfWET3+EVHRWkS3TmW76gpXc/fIGIZhmDyI3SYJBIB369ZNqDxMe0XDcyw7dEgzhZxxGqdvJFJiaoaBhSndKIO71wLRBI7+TrRnLtGvzxAdXenuUTEMwzB5FLssTlu3bqX27duLQPBOnTpR5cqVxfKjR4+KLJ6rVq0SBXpbtGjhqPEyJnh8xlZKTMukTaNaUdvqRSgowI98zt53fidR8Xo5czoxDMMwjLcIp5dfflkkVtu8eTOVKlXK4L3z58/TAw88QCNHjhQB5IzzSL+XfgCuutn9GpBv4kd0amP2039+Jeo+190DYhiGYfIgdrnq/vnnH5E53Fg0ASx7/vnnRR/GNekIfDoYvEZnoopts5/H+Fg9PoZhGMZrsOtKW6ZMGZGKwByoVmxKVDGOIytLIZnvMtDfTw3U95nJksH3ikTX6UtUpX32c87jxDAMw3ijcJowYYIo5rt///4c7+3bt49mzpxJkyZNsmcXjBW0QeCBAf7UaOo6Kjd2JR2/lkA+QWj+7Ef/gOwGsjLdOiSGYRgm72JTjNOLL76YY1mRIkWofv361KxZM6pYsaJYdvz4cdqxYwfVrFlTlGDp1auX40bMmKxTBxAULvGZ7OF3s0v60J1zRJUfIRqwkii8gLtHxTAMw+RRbBJOn376qdn3tm/fLpqWgwcPipQEn3zySe5HyOgWToH+/mqck3a5T1CgAlG+otmNYRiGYbxBOCHtAONZBAT40ZMNSt5LeOmnWp18wuKk/b5FlXDnSBiGYRjGsZnDGfcQGRJI73Wrrb6WFifUq/N6FCPxh6zhx9cSRRYmqtHFXaNiGIZh8jAOEU6nT58WyS7Pnj2rzrZDYsxy5co5YvOMDSBA3GcsTlrhhMDwq/8QrXqNqFQTFk4MwzCMdwqnV155RcQwGbvx/P39acSIEfTBBx/YuwvGAplZCiWmZVBwgD+FBgWorrqMLB8TTn7+/71OzK6JyDAMwzBelY7gww8/pI8++oi6du0qZtHduXNHNDxHrTq8h8Y4j1PXE6jWpDXUdNp68bp+mRhqVaUQ5Q8PJp8TTtePZj+/ddJtQ2IYhmHyNnZZnGbPnk0dO3akhQsXGixv3Lgx/fTTT5SSkkJffvmlKM3COAcZyyRddBM71CCfwVg4Zaa5czQMwzAMY5/F6cyZM9SuXTuz7+M99GGch3TJyazhPoWxcAqJ0rznA8HvDMMwTN4STijw+/fff5t9H+8VKlTInl0wVsjQFPj1OSCWyj1AVLxe9vO6ff97LyvDnSNjGIZh8ih2ueq6d+8uAsPLli1Lw4cPp4iICLE8MTFRJMucM2eOCBBnnMfsLafE4/lbyeLx4Y8207GrCfRUkzL0Zuea5NWERBL1X/7f68DQ/55npBIFBLllWAzDMEzexS6L05tvvkktW7akcePGUUxMjBBQaHg+duxY8d6UKVMcN1omB2sOXzV4DdEEftiZnRrCpwjQBLxzvBPDMAzjbRan8PBwWr9+PS1dutQgj9MjjzxCjz76KHXo0IH8/HzQheRBtK5SmNb9ayiefIaMNCL/QOS2yH4dEPhfWoLMdHePjmEYhsmD5Fo4JSUlUd++femJJ56gPn36UKdOnRw7MkYXNUtECeHUuU5x8bpi4Ug6cS2B7isRTV7Pp/Wzi/uCSXGGAeNxF4jyFXHf2BiGYZg8SaA91qZ169aJDOGM+0hOzxSPBSJDxOOsvvXoxLVEKh0bTl6PFE2mOLuNqGR9V46GYRiGYeyLcWrevLlIdsm4j7ikbJdVdFh2oHT5gpHUolJBKhkbRj5N8m13j4BhGIbJg9glnDBzbuvWrfTGG2/QhQsXHDcqRjfxKdnT8qNCA9Vg8RoTV9PAuX+RT7ONM9IzDMMwXiacateuLQTTtGnTRGHfkJAQioqKMmjR0T4Qa+PBVCgUQY3KxlLJmGzXXGhQ9r805Z4Lj2EYhmEYD5lVh3p0zuCzzz6j999/n65cuSLE2cyZM6lRo0Zm+//88880fvx4kaW8UqVK9O6774pZfXmBkQ9XMXiNQr8+IZxSs9MqCCo8+N/zdtOIVo8lqtjWLcNiGIZh8ja5Ek6oQYcUBFWqVKECBQrQ448/TsWKFXPIgBYsWEAjR46kWbNmiZp3H3/8sSjdcvToUZGp3Jg//viDevXqJaxeGMePP/5InTt3pr1791LNml6eANIKiqLQkSvxYiZd0L1adf8JJ025Em/k/Qr/Pe/y5X/Po0sSBUVw8kuGYRjGLfgpuPrawLVr16hZs2Z0+vRpceFGnibMsFu8eDG1adPG7gFBLDVs2FDET4GsrCwqVaqUyEw+ZsyYHP179OghMpX/9ttv6rImTZpQnTp1hPiyxt27d4U7MS4uTrgWvYk+c3bS9hM3KTYimPaOz7bAHLlylx75eKt4fuadx8hrmaRx8Y4+SxSWP/s5vq7zniA6uZ7o6Q08s45hGCaPc9fF1/HA3GQLh0vs5ZdfpgcffJBOnDghlj333HN08uRJuwaTlpZGe/bsEVnHJf7+/kKQmZu9h+WwUGmBhWrJkiU27fvkvi0UGR1Dxvk6lYBgqlSzofr6wrH9lJyUqO1x79GPlIAgqnzffy7FSycPUWJCPJEi3WYK+d1bw88/kMrVbEIB94rzXj55kBIT7hpsL0tRxBoQp+grrUoXTx2m0xcv052T/1JNP4X8kxSiC7FYhfLHpco90Ilr8VQx6CbdvnmDrsQnU2Ym0ehFB9TxvfhQRWrT6iEKCMz+Gpw7fZSS7lynLFH/TiE/jE0Rn0y8X/m+JuQflJ29++Lpo5R8+yJlZmWRkqVkj/VewWEcw4p1HqDg0Oy4q8unD1PS9dPZ70mdLh6zn5e47wEKicgWRne2fU351xn+Pw9eTSEl8E72GIrko1CIJjDnQTrf8iPKCCtICSUeyN4xKrXcOkoB6fFUIiaMQoPw2fzoVlIq3U5CIL0fJReqlZ1Ik4iC7p6jgNQ7VDwmnMJhrfPzozvJ6XQjHseRKDmmGpF/gNh0YPxFCki5TcXyh1BkcLZlLy45g67Fp4jnqTFVxfcF/7XA+EsUmHKTikWHUr7QbOtYfEo6XbmLvn6Umr8SUVCoOAyBiVcoKOU6Fc4Xogb5x6dm0JW47O0mR1ckJTB7lmRA0jUKvtc3f1j2/yIpPZMu3UkW20qJKkt+wdmljwKSb1BQ4hWRqiImPHsMyWmZdOF2svg8aVFlKCs4X/YYUm9RcOJFigkPptjw7O2mZGTRhdtJ2Z8tsjRlhUSLzxaQcodCEi+IvgUisvumZWbRuVtJYlsZ+UpRZmh+8dw/NY5CEs5TVFiQGDPIzFLo1PVEceOVGlmcKKyAWO6fFk/Bd89SVFggFYkKVfuevpH9e0uPKEqZYQWzv0dpiRQSf4YiggPFMcZ3SVGy6OS1BPE/zAgvQhnh2RZqv4xkCrlzkiKC/e/1zf59nbievd2M8EKif3bfFAq5fYzCggOpRP7/+mIMmYpC6aEFKCOiePZXLSONgu8co5DAACqjSf9x+mYiZWZmUmZoAUqPLC6Og5KVTmG3jlJIoD+VLmDYNz09izJCoikzqrT85VPIzX8pJMifSt+LXcTnO3cziVIyMikzKIrSokqLMfiRH4XeOEQBAX5UvmD2/x2cv51MqemZlBUUSWnRZdXl2K4/KSI2UoLvDr5DWYHhlBZd7r++t46Sv5JBFQpFqssuxyVTYmoGZQWGUlr+iury4FtHyS8zlSoWisxOeuznJ76/cSkZ5BcQQikxFbO/D35+FBJ3gvwzUqhcwQj1/Hf1bjLdTU4n8guilALV/ttu3CnyT0+isgUjKOhePc5r8al0JymNyC+A0gpWV+t9B8edIf/0BCodGyaOM7iRkEa30Re/uUI1xXlK9L17jgIzEqh0TCgF3zv/3UpKo1uJ2RUJEvNXE9cecY6IP08BqXFipnIYzhGKQreT0ulGQqr4H6TEVhfnCNE34d45IjqUIu6dI3A+uR6fIs7lqTGVKcs/+zcTlCDPEWGU796s6LjkdHGMxe8vfyXKCsj+zQQlXaXA5OtUPDpMnUGN43Xhzr2+0RUoKyD7+xqUdI2Ckq+J7crfPSYRnbv3W06JKkeZgdn/f2wzOOkqFY0KpYKR2eNKSMsQv0+Qmq8MZQTly+6bcotCEi9RkegQKpIve1/43hy/Ep+93XylKSM4W7QEpt6hkIQLVCQqRIwDJGdk0r+XcY0jSo0oSenB2ef8gLS7FJZwjgpFhVKp/Nl9UzOy6ODF7Nx9qRHFKC0kNrtvejyFxZ+lQpEhVPbe7+jk9QQ6cpNcis3Cac2aNdSvXz/64IMP1GVFihSh3r17C3ca3He55caNG+KEg+1pwesjR46YXAdxUKb6Y7kpUlNTRdMqVVDh994UFZIzy/lJpThRzX//W/Bzf6qUfsbkti8qBYjuy64dB9IWDqZKqabHfUuJpNSqZyk8OPtfkLhoOFVM2meyb4oSRHcrXFRzNcUveYWa3/2DVmS/zGZO9kNRcYqYR8Xzh1N+XABXTaKYfxZTzL1uButsI8psfoEoMPuHcf7XCXR//O8mxyDGUe4IhcZku2RPLZtGLW4vNtv3dsk/Kbhk9nfh+MqZ9MD1H832vVpwIxWpWE88P7tvPd2zLQmmp3ejGbP2qK/XjXyAKhasTHTjmHhdavPLlK4EUKXUH9Q+3wa9S60CDItP42eX/dMjqpjyPWXc++rPCJpJHQMMRTn2L8dwX8ociqfsH+g7gV9Rz8BNBn1hF5O2sUYpn9G1e0d6YuB3NDBwtUFfHOXsI03UKvVDOqNkH8tXA3+ioYHLzPZtnzqN/lXKiOdDA5bQq0ELDfpidPIS1jV1Eu1VKovngwNW0vigeQZ9cVqqdO9537SxtC3rPvG8V8B6mhb0tUHfUM12n0kbSWuzGojnnfy30SfBnxv0Ddb0fTFtKC3Lul88b+f/F30ZbDgDMkAzhjHpT9NPmdkxbC38D9APwe/k6Cu3Ozn9KZqbmZ03rr7fUVoUMtmgr5+m7/vpT9JnmZ3F8xp+Z2hFyDgyRvadmdGZPsx4Ujwv53eZNoa8kqOvlBNfZ7SnNzOeEs+L0k3aGTrcbN8fM1rTuIxnxPMoSqADoc+a7bsksxmNSB8mngdRBh0P7Zejb7asIlqd2YCeS//v5uJ4yFMU5GcY01jq3uOWzPuoX/p/N6IHQgZTlF/2xVaSnTqXaHdWZeqWNkldvivkBSril33DIpEBGf9klaHH06apyzcGv0zl/A0rGBS9105lFaWOadPV5auCx1Blf8McbUXutStKDLVN/Uxdvih4ItX3P27Qt/C9FqeEU+3Ueyc+lJkKeptaBBwy6FvwXktTAqiy5hwxO+gDahuw1+w5okLKD5Qpvn1EnwR9Sp0C/jDoi195jM5zhPZ8Yu0coT2ftEydTmeVombPEZAo1U2cI4YFLKZRQT8b9MW5pIbOcwRkcq17z/ukjaXtFs4R4ZgkZuIc0dl/G31sdI7AuaeeznMELlPZWyIanf4MLchsbfYcgaCO3xMfIo8WTufOnaPRo0fnyOeEu8erV6/aJZxcAWKhJk82POGCm5SfUihAnHy1xAfIn0c2yUExdD09W2xpfZxY765/fiqhWZYaHEM3UvNTlrjHw71htgVJbNc/kkpqzFupIQXoelKM+n72NrMtR2l+QRSu6ZsVGkPX42PFnVa+sGAKCw7KtrYII04WfdmtAbWoXJjCcMcTFkPJoUXEHQe6wEKkpagsZwJCo+lGfAwpfn7/jVfxI0Xs2o/ya/pmhsbQRZzqxG7RIXsdScw9y5ToG16ITvuVyh7evX7avvk1xXujsrJP1FnkR4OC3qdjIeXVEzsIwBiG/km0aDDRoUWUSGF00z8/FVctCURXMkrR+axrVCRfMAXfu0uFtSced7T4zFFhlOmXfVJMS89PV7MKUExEMAWLu1+FktIyKTE1XYyxUL5QivTPtgxlZUbR9cxYcccXLCxZ2QlIxZ0ykbhjCvTLHoeSEU1XMwuIvjLuTNs3JjKcUvxCs60GGVF0LTNWWGVCA7OtXqkZmXTnXo6u2HwRVPzedoMyI+l6RgxFhgRm3/36+QlrD/J54fjmjwynIn4h4r8XkBkptou+UqCnZ2XR7Xt31RHhYVTYL0RYAYIzI+nqvb4R9/pmZGWpd+Dh4RFULCBU/NfCsd2MWLFN9Bd9FYVuJWTfkISFR1BR/+zPFp4ZIfrCgpPvXl9Ybm7e6xsank+MF2PIlxVB19JjxfGKumelyyJFtf4FhuajogGh4lcUnRUujkOI7AuLp58fXb/X1/9eXxCdFSbGEBwYkH0zIb60WXQNY1AU8g+JpKLh2X1jlDC6ml6AggP9hUVNmjOuJ6SKc5wSko+KRYQKy0VBJYyup8cKS0j+e1YAcCsxlTIUP8oKjqIi4dn/i3yUSdfSYikwwF+16IGbiWnCqpYZHE3F7o3BPytNbNff30+16GEct5IzKCMzi1KDoqlERJhqPbmRGktB/llUMOK/uyJYWdIzsygl6L/tiuVpsZRGyVTw3k2YtIikZWRRUkC0sBCoy9NjKEDxM+gLCxKsAQkB+YWVQl2eHktXlQwqHBVCfmJYCt1NTqPUDIXiA7J/n7BEYczxafnpmpIgLBzijOLnR3dTMig5PYtu+sca/JaT0vPTtaxYcdMYcO8cCGtscloGJfqHizFkW96IUtOj6HpWDMVEhIrjDBJSMygpNZ3S/YLEZ8P3DH3T0qPpRlZ+ig4PoSD87v38KBHbTM0WoCWiQyn9nnBKT48SY4D1Rlj9/fxF3wScU0lRzxHiu50RneMcgfNJQkr2b7lwdDgF+WVbVbJw7sksQPnDAoXVEsCieDc5O8VM4ahwyvQPE58vAGPIKCAs0uIcIawymeL/Ic49+SMpyT9cfLbg9Gi6nl7gv3PEPYswrFliu/kjqXxAhDho4WnRdC0NfYMoPPi/vvLcUyh/FFUMjBTbjUqPpmspBSkiJEA9R6Qb9I2mKkH5xHgLpEXT9eSCYpsR8hyRpajnnoIx+alacJTYbuH0/HQ9saC4XsnzCX4TsACCAvmjqUZIlNhuCXy2hILiGOS7Z50Xv8WwQuTRMU4wX86bN09YmCQ3b96kQoUKiUzicN/Z46pDvNQvv/wiArwl/fv3pzt37oiAdGNKly4tXHUjRoxQl02cOFG46v7+29DqYM7ihBgqb4xxYhiGYZi8zl1Pj3ECiHHCrDUJBguOHz9O+fNrHS3Z1KsnDXSWCQ4Opvr164vCwVI4ITgcr4cNyzZjG9O0aVPxvlY4rV27Viw3BXJNoTEMwzAMw7jE4iSC/4yQM+xMLUPcki3pCGBh+vLLL0XuJqQjWLhwoYhxQuwS4qtKlCghXG4yHUHLli3pnXfeoccee4x++uknevvtt3WnI4Dog9g7f/48W5wYhmEYxsu4e89zBM+UK5Ju22xxmjt3LjkTpBe4fv06TZgwQQR4I63A77//rgaAI8ZKznYASI2A3E0o+zJu3DiRABNuOr05nOBmBDjoDMMwDMN4Jzdv3nSJcLLZ4uRrQKHGxMQIQcblYRyj+tl6Zz98LB0HH0vHwcfScfCxdBzwHCHe+fbt2ybDhTyq5IovIK1XEE385XUMsk4hYz98LB0HH0vHwcfScfCxdBxab5Qzcc1eGIZhGIZhfAAWTgzDMAzDMDrJ88IJqQmQ94lTFNgPH0vHwcfScfCxdBx8LB0HH0vvPZZ5PjicYRiGYRhGL3ne4sQwDMMwDKMXFk4MwzAMwzA6YeHEMAzDMAyjExZODMMwDMMwOmHhxDAMwzAMoxMWTgzDMAzDMDph4cQwDMMwDKMTFk4MwzAMwzA6YeHEMAzDMAyjExZODMMwDMMwOmHhxDAMwzAMoxMWTgzDMAzDMDph4cQwDMMwDKMTFk4MwzAMwzA6CSQPYsuWLfT+++/Tnj176PLly7R48WLq3LmzxXU2bdpEI0eOpH/++YdKlSpFb7zxBg0YMED3PrOysujSpUuUL18+8vPzc8CnYBiGYSyhKAplZmaK8y/D2IO/v79oCQkJVLx4cfE8TwmnxMREql27Ng0aNIi6du1qtf/p06fpscceoyFDhtD8+fNp/fr19PTTT1OxYsWoXbt2uvYJ0QTBxTAMwzifQoUK0fPPP08NGjSgwMBAvmFl7BLgGRkZ9Ndff9GsWbNo7969VLJkSXI2fgr27IHgx2TN4jR69GhasWIFHTp0SF3Ws2dPunPnDv3++++69hMXF0f58+en8+fPU1RUlEPGzjAMw+QEl5uLFy8KwQQBFRQUxMKJsev7lJ6eTteuXaM///yTOnToIK7nHm1x2rVrFzVu3JjcxY4dO6hNmzYGy2BpGjFihO5tyB8tRJM3C6fktExasv8iPVS1MBWOCiWf4/YZorN/ENXqQeQf4O7RMAyTC1JSUsQ5F1aB8PBwdw+H8RECAwOpYMGCwvrkkv3Zs3LTpk2pYsWK9NRTT1GfPn2ofPny5EquXLlCRYoUMViG13fv3qXk5GQKCwvLsU5qaqpoEvT1BWZuOE6fbzpJFQtH0rqRLcnnmNOGKPE6UWoCUeNn3T0ahmHswBVxKEze+j75udByade3d968eVSpUiV68803xeP9998v/Iy3bt0iT2XatGkUHR2tNl+Jb1r29yXxeOJaAvkkEE3g+Bp3j4RhGIbJw9glnHr37i1ijBBg/cknnwh/4wsvvCAi2xGb9Msvv1BaWho5i6JFi9LVq1cNluE1XG6mrE1g7NixIq5JNsQ2+QLpmXlkdkq5B9w9AoZhGJ/n22+/FVYcWy05mzZtUtc7c+aM3eMoW7as2NakSZPIU3CIvRS+xWHDhtEff/xBx48fp9dff52OHDlCPXr0EOLm2WefpW3btpGjgasQM+m0rF27Viw3R0hIiBrP5O1xTVpqFI8WjxM7VCefxO9eXFPNJ9w9EoZh8hitWrVSxQBaQEAAlShRQgQj47rH5C0c7miGpQdBf6GhocIChS/Z0qVLqWXLltSwYUM6fPiw2XWRh2H//v2iyXQDeH7u3DnVWtSvXz+1P9IQnDp1il577TUh1D7//HNauHAhvfzyy5TXyMzKnhyZLzSIfI6sTCIlM/t5kGlLIsMwjLMJDg4WE6Jq1aolZnL99ttv4tqGGV1M3sEhwik+Pp7mzp0rZriVKVOGxo0bJ8xrcNUhgBuuvAULFogv2sCBA81uZ/fu3VS3bl3RABJb4vmECRPEayTFlCIKlCtXTrgKYWVC/qcPP/yQ5syZozuHky9RrVgUNS1fgIpEhZDPkalx96YnuXMkDMPkYZAjcOfOnbRv3z5asmSJWIaZXD/++KPZdfr27SsMCMg5CJD4E54OLFu5cqVY9s0334jXSMSM7WFyE8JdcI2LiIgQnhLEEeNaKMNf3nnnHbEO0jpoZ5NhshaWN2nSxCAeGYYLGDWwj0ceeUQ1UNgC8iU2atRIeJmQSiImJkZcb80JRxg0YK2DIQUTyaAJjN/v3r27+AwQpdWqVaMvvviCPB7FDpYsWaJ0795dCQsLU/z8/JRGjRopn376qXLjxg2T/b/66islKChI8STi4uJgqhGP3sz1+BTl1Z/3K2MWHVB8jswMRVnQT1EmRinKL4PdPRqGYXJJcnKycvjwYfGoJTE13WxLTstweF9badmypbhOlClTRl3222+/iWVoL730ktl1Z8+eLfrExMQoWVlZyt69e9X1xo4dK/oMGDBAvG7Xrp14ffv2bfG6SJEiSp06dZSSJUuq64waNUr0OX/+vOLv7y+W/f777+rxzZcvn1j2xRdfiGXvvvuuum7lypWV4sWLi+cRERHif2GOuXPnqutJ8DlDQ0PFdmrXrq2EhISI97HPy5cviz4bN25U18M+0DcqKkq8xnjx+cGxY8eU6OhosTw2NlapWbOm0BF4PXnyZHWfOOZYNnHiRLNjTUhIUFatWqVcv35dcQV2pSPo0qWLmJUG1xhcaFWqVLHYH1YhpC1gnJPHaeHuCxQa5E/Tut5HPgXyNpVpRnR4SbbbjmEYn6L6hNVm32tdpRDNHdhIfV3/zXWUnG76PNC4XCwteO6/GNfm726kW4k5JyideSfb+mMr8HrAkoOUNjLxMnII9erVy+w6sLiA27dvi9JgMt4XVif5XD7KvrAyoW/16tUNLEmwHP3000+iNBlyYT300EPC4wKPDiw/q1atEh4gWKiQDDopKYkmT54s1scjLFawTiEOGB6et99+m3744Qfdn3/o0KFiHZmD68SJE8IShn3C+zN48GCD/sOHDxcz2eF5gjUJyanfffdd8RmwHUzQqlmzpsgJiW1ikhnyMMKaBl0B65jPueo2bNhAZ8+epalTp1oVTQAmPrj0GMcTHJj9r0zP9MhE8PYTEJTTbccwDONC4CbDRf7AgQPCvQT32+bNm0XcE8p9QFRpG4CLSpYB2b59u2hwdXXr1k2UCsHMbggQrXBCXiKIpMqVKwsRBNcbXgOEvkj69+8vHlFlA2ODgAKdOnUSGbQhviCewMSJE8V24GKDaAJwO9oCxF+nTp0oNjZWjBGiSaIdl0QKSkwSa926tXh+8OBB8SjdexCgEIoYm0xeDVcljrGnYpfF6fvvvxfB4Oayh+PAIK8T/LeMc+nx5Q41SBwtwN+Hyhgk3yHa9WX2cxZODONzHJ5iPi7V32g6/J7xbXT33TY6+2LtKBDDa26KPZIpQ1SZAgHkiA+CZQnCqVmzZtS8eXNxbfz4449Fn8jISFG/D8DiAkuN3CeEx4ULF0S5Gm1hZHh9YJWBJQfiCcHqWkGlBRYf41nkBQoU0P3ZMXkLVq07d+6ImCXEH0OEyc+M2K3cABFZoUKFHMsxc9FT8bc3z8PJkyfNvo9Zcd999509u2B0kpSW6bs5nRJvEF0/kv2chRPD+BzhwYFmW2hQgMP7OgNYizCTXNu074Hly5cLAYRk0RBO4KuvvhKPWAa3n9YSBIsThBrEFkJdjIF7C8HVANaaxMREIbLkBKkaNWqoOQ0REI4yZdg2GoKwkTpIL0ePHhWiCUDw7dmzRxV95pAWMEwMQ34ncN992aEkCFYHSESNIHk5Log/uOm0we2ehlPz3sN0Zy4RJeNYtDdaPiectGIpM92dI2EYhrEZKZwQ0yNFEtxchQsXFpYcbR+AdAfg2LFj/2/vPMCjqrY2vNJ7Qk+AQALSDL0XQRRQEARUVC7lCohcRUHFK6IoolhARYqAiiLof/FeBAQEkS4gvYduIHRCSAKkENKT8z/fnpzJJJkJE9In3/s8hzllz5k9m5Nzvllr7bXUzDpYnSy51XTrEuKI9Fl8urUGwmrSpElqfebMmcpl2KJFC2VpatWqlWzcaH0lBpRUg0sNIJYJfcTMv7xAzFKjRo2UAISbD+49pA/S0wvBAgbjC2KlYcHSrWsTJkyQ0ky+pTdyMmHRgVrevHlzrnZQptivq0pStJj8uLG9OKcME7FEixMhpIyhxznB2oRp97pLDgIKLracwgkpfeCWw7MWLkCk8YER4uOPP8517i5duihxBQ8PGD58eLbjEChI1jl37lwVTwTxBqHy7LPPylNPPWX1d0DqgWXLlsmbb76pxA6+ByxoiF22BNIPwOUIqxmEF9Yh2ADiomEBQ0bwrVu3qngs1JqFZQzJs0szdphal5834IsjGh4g6AyDp5sXjSe1s1PKtHXr1jJjxgylNksruChhKsTFVJaziLf+aJPczJw9sm9id/H1dhWb4epBkQXdDesPTRR5qHT/GiGEmCcpKUk94PGgR5wMIYUBXJQ7duxQghQxU6XO4gT1igXA7PbDDz+omnWkZNHdc7+O7ihVPW0sCabunqt0H0UTIYSQEqVAUXKm0f2kZNHdc9W8XMXelmbUmbrnHJxLuieEEELKOUUzvYAUO838fSQpNT3XrBKbsjihXl1yvIiLZ0n3iBBCSDklX7Pq4JpDPJNeKwfbiN7Pa8kZ/0SKBmTLfahhNZm1+YxcuWVj9dxqthJ59GORG2dE5hqCKgkhhJCSIF+qBunaEfitiyF9m5QOVh4Jk8u3EuSpVv5Sq5IhJb5N4F5JpF4PkY3vcVYdIYSQsiOcMG0wr21Ssjg6GERsmq3lcQL2esmVrCrghBBCSHFDP5oNEJuYKj1mbJeo28lqOy3DxvI4RYWIBP+cO6cTIYQQUpqFE2rT3QvPPffcPb2PWEdKWoZRNKltW7M4Xd4rsmu2YZ2uOkIIIWVFOOXMSGoNiIGicCpa0nKkhUiztczhpmIpI82QJp2xdYQQQkq7cNJTupPSRWpadqFkczFOOevTQTw5ZMY8EUIIKXR+/PFHVeoF5KfAyLZt2+Thhx82aobAwMAC9QPvv3TpkkyePLnUxFXnSzihAB8pfaTmsDjZnKvONK6p8VPZC/MRQkgRgxQ806dPl8WLF6uHOFLtoEBv06ZN1cO8efPmJd1FUlrzOJHSXW4F7JzwsDwa5Cc26apr9ZzIM4tEHJlBnBBSfIwfP17effddOX36tCqYCytIZGSkrFq1Ss6ePVvS3SOlWTjB/Na9e3dJSzNMCe/WrdtdF7QnRYse0+Tn7Sr+Fd3FzdnBNl11LLlCCCkBfvnlF2PuwjNnzsixY8dUYfidO3fe1do0dOhQFevbp08ftZ2enq4KymPfH3/8ofYtXLhQbXt5eanna2JiojzxxBOqGLKHh4e4uLhI/fr11efrCainTZum3lO1alXjMxn885//VPs7dOhg3AdLWdu2bcXd3V19Rq9evSQ4ODjf4/Dzzz9Lu3btVCFdJycnqVixovTs2VP2799vtv3ff/8tDz30kCroXK9ePVm+fHmu488884z6Ds7OznL//ffLN998IzYlnODnNK1Ph3Xsy2thPbuix8nBXoKqe0t9XxstRYKYJmDvaMjjRFcdIbZFyh3LS2pSPtomWtc2n+jPsY0bN8rvv/8uERERSpw88MADStDkBYQD2LNnj3omQnTdvn1b7YPwAjt27FCvOB8STCcnJ8tvv/2mBFSDBg2UWzA0NFQ++ugjZfnSBRmqd9y4cUO2bNmi9iUlJan3mU7m+vzzz5WYOnjwoNSqVUuJtg0bNkjnzp2VBS0/HDhwQI4fPy6VK1eWxo0bq/5hTHr06CHXr1/P1f7pp5+W8PBwJfzOnTsnAwcOlCNHjqhjsNRB3EFMYXwbNmwoISEh8vLLL8uUKVOkVKOVc2JjY/EUVq9lnVVHrmof/35S23vuhmZTRIZo2um1mjbZ27DculjSPSKE3AOJiYnaqVOn1Gs29L9tc8vip7O3/djPctuFvbO3/ayO+Xb5ZPLkyeo5Ybo0bNhQmzJlSu7vkoOzZ88a33P8+HHtq6++Uuve3t5aly5dVJt69eqpfVOnTlXbKSkp2smTJ7OdZ+jQoaqNv7+/cd8jjzyi9o0YMUJtr1ixQm27uLho0dHR2p07dzR3d3e178MPP1RtUlNTtTZt2qh9OKclFi1aZOy3zpkzZ9Q5zX23BQsWqH1bt2417nv77bfVvvDwcK1ChQpq38CBA9W+4cOHq+0mTZoYzzlr1iy1z83NTYuLi1P7AgIC1D78H1giPj5eW7dunRYVFaUVB4xxsiG2/h0p3++4IMfDYsWmqNpApFFvERfv7BYoQggpBhAAvmLFCunbt6+y2ABYR+A6e+mll9T24cOHlQXFdAFwUfn7+6v1Xbt2qQWuLlhjYMG5cuWKsiaZWqdgSYJ7DdYmWGtg3cI2uHbtmrFfw4YNU68rV65ULjzdpdi/f3+pUKGCnDx5UhISDLVLMSsN54GLDdYnsHfv3nyNQ3R0tDp3pUqVVB9NrW2m/dIZNGiQevXz8zPOtIPFCujuvRMnTih3JPr2+uuvq32wZMEyZ9OZw2G6hK/24sWLahuBc71795bHH3+8ME5P8uGys8lZdTpw1ZlLT0AIKdtMzP3QNWKXI2ZzfGgebXPYAl43PKQLgyeffFItcCsdOnRIRo4cqUQAAsRBXFyc7Nu3z+x7u3btquKD4JqDcOrUqZNylSG2adasWaqNp6entGnTxhi/NHXqVONsdgiPq1evSlhYWLbwF/QHMUsxMTFKPOFZbCqoTEH8kC76dOBys5b4+HgVzxQTE6Nillq2bKlEmP6dEbt1L0BE3nfffbn2Y+aiTQonDCD+4/766y/1JatXr672b968WebPny9dunRRFxWULyk6dp+7IRNXHJeLNxNsMwHm5X0it86LJN4ybLPsCiG2hbNHybfNg/fee09ZiFq0aKEsLQi0hjUIwsnHx8doLbKU7wjHIJzWrFmjgsrHjh2rhBP47rvvssU3mVqC8BmwbEGU9OvXTwknUxDsjeBqCDBYa+7cuaNEFgQOQBySm5ubsuAgIPzLL79Ulh2AWCPstxb0A898gM+DNQn97Nixo1gCFrBmzZqpGYjI7wSQwgFgDE+dOqXGD4YXWLGAHrNlGtxe2iiQq+61115TQW2fffaZMuEhvwUWrEMxQ12jDSla4pPSjKLJJhNgHvk/kVUGc7iCFidCSDGyYMECZWHB7K/WrVurIOtff/1VHRs8ePBd36+74CCagB5UjqBvWHJM2wCIDYAZfJhZB6uTJbeabl3Sg7MRNK5bayCsJk2apNZnzpypXIYQf7A0tWrVSgV2W0vdunWVSw3A2oY+YuZfXsyePVsaNWqkBCB0AUTnW2+9pY698847ygKGoHGMJ8ZXt65NmDBBSjMFEk6wJiEC/s033zQOKMA68l6MHj3aaMYkRUfOor6ptlbkFzPpsm1TOBFCio+PP/5YxfbALYYp9LCgYBYY4oYw0+1umMY5Ydq97pKDgNIxFU4TJ05UggjeGrgA//GPf6hnrTng2YG4slQaDQLlp59+UhYeiBfEU0GwITbrqaeesnoMkHpg2bJlEhQUpNyF+B6woOUFZsz5+vqq2X4QXv/73/+UYAMYP8w0hMUMAg/xWDgvLGPWjGlJYocI8Xt9M3yTH374obzyyitmj8+bN09dWDC9lVZwUcJUiF8COf2/ZYXfgsPktSVZOTlGdakj7/YJEpth+fMiJwy/7hTD14oEGszchJCyAx6gKMOBBz3iZAgpDOCihPcLghS6pFRbnAYMGKAUqLmgMCTkWrp0qVKTpGjJGdOUamsxTqYWpga9RFwZM0cIIaRkyJdwwnRL0wW+VJj+MEPghx9+kO3bt6sF/mDsgxVnyJAh+e4ULFWYmYdfJO3bt7eYlVQvRIhgN9OlvP2SScucZdHM30c2jntQXnm4ntgUGZnC/PFZIoN/EfFrUtI9IoQQUk7J16w6mMH0iHwd3dOHfBT6MVPvH6Zh5meaIqLw33jjDfn222+VaMJUTcwQQEQ//LLmgIsNx3Vy9rG8xDih5EoDXy+xOfRZdA5OJd0TQggh5Zx8CadFixZJUTNjxgwZNWqUjBgxQm1DQK1du1ZNf3z77bfNvgdCCZH45RUPZ0cJrOwuvt42amnTXXX2FE6EEELKkHAyl1SrMEHmUyQWwywAHUxfRB0cRN9bAtM5MY0REfmI2P/0009V/gpzoAYQFtPg8LLOEy1rqiX4SozM2HRG6lfzlL7Na4jN8OCbIi2Hiuz4UmT1WJEnvhZp+nRJ94oQQkg5pFSVXMHsO7j1MH3RFGybKyCoT2mENQqFDZGSHuIJ8VXIsmoOZGPFLDp9Qf4IW+HY1Rj5astZ+eN4uNgUmEEHoeRVXSQ9WSTdUB2cEFI2KcBkbkLMXk/FeU05Fsb0UiQCQ7A4gsFN08HrbjQEjhcVyFpqmrkUogmp5ZG53FwuCFizEENlanGyFfGkl1yxuVl1OnqME/M4EVImQYkOgPppyGhNSGGADOjwWOmZ14uaAn0KsoSjcB9q1CFRF4QT0qYjLTssR8ingPo71oL2yHgaERGRbT+2rY1hwh8mMpDqRRNzgoKJWGyJ/+y9JP/dd1lS0gxB+Km2ljk8dItISrxIoiHdP0uuEFI2wf0dzwokkARIfFjeJvOQwgNWJohwXE+rV682FhIu1cIJ2cEhlpAKHllBMesNs+KQDfWrr76SuXPnyoYNG6w+HzKRIp096tToqdxhwcL2mDFjrDoHBBvqB6HIcHkhIjZJTofHSUV3p2zpCWyGjZNEIk+KuFUyn0mcEFJm0H8E6+KJkIKCaiWYvIayMqVeOP35558qDXy7du3k1q1bRgUIiw5E1enTp1XhQcyKsxa40RCEjtQHOC/SESArqD7L7rnnnpOaNWsaK0dPmTJFFQNESntYur744gtlCXvhhRekvJCaKZTcnBwkWlJtz1WnW5hQsBOFfmlxIqTMAgsTCsLjh3ZqKv+WScGAlwkaoczEOMFEhkSVei4l/EHoRQwBYo9Qxy4/DBw4UKKiouT9999XAeEoSLh+/XpjwPjly5fVTDsdJOBE+gK0RS0dWKx2796t6umUt8zhbs4OtlnkV49pcsxMt8DgcEJswm2nF6MlpCxRIOFUu3Zt4+w1BGXBEgS3nV448NSpU/eUxRtuOUuuuW3btmXbhmmuuMxzpRVdKLk6ZQonWyvyq2cO920s4uUn4mMbwfyEEELKmXDq1q2bSgOAQr56VWa40GAFQmzSf/7zH+VaI0WLLpTa16ksnzzZVDxdimdmQbGhu+a6vCFSvXlJ94YQQkg5pkBPWGTyRqkVJJREXNPEiRPl2rVrsnz5cmWCHTx4sMoETorHVVfZ01la1LLBArjMHE4IIcRWXHVYdOCWQ4FfLKT48HR1lGpeLuLlamOWJh3WqiOEEFJKsNMKKRQdp0FQN6hatWqZyc2BBJjIII6gdgS4l2UibyfJisNhanbdsE6GoH2b4NgykdQEkZhLIgcXGcqvPJo7uSkhhJDyR1wxP8cLXHIFAeBPP/206iymmGLBOvadOHGicHpJrCIyLlmmrftbvt5mPvlnmaXZMyKth4k4uBjSESTfLukeEUIIKacUyLezY8cOeeyxx1QgeP/+/aVBgwZqf0hIiMriuW7dOpVKoEuXLoXVX2JFyRU95snmcMi8XFlyhRBCSFkUTuPGjVNJzLZv356r3tuVK1fkwQcfVAktEUBOio6Pfz8lR67ESO+m1W2v5Ao8yWc3itib5HthAkxCCCElRIFcdSdPnlSZw80VycW+0aNHqzakaAmJuC2HLkVLfJKhFIlNZQ6Hdem/z4osHpBVaoUWJ0IIIWVROAUEBKhUBJZAtWJzoooULrprzl3PHG5LtepMrUvO7rn3EUIIIWVFOKEsCor5BgcH5zp25MgRmTNnjnzwwQcF+QhiBbpQcs0UTrA4FWfdniLF1LpkLLnCIr+EEELKQIzTq6++mmsfasihPlynTp1UoV1w9uxZ2bNnjzRp0kSVYBk0aFDh9ZjkQnfNuTpm6eD0DE0cHcpGSgirhZOPv0iNViKV6pZkjwghhJRj8pXHybS4rtUfYGcn6emZtcZKIbaQx6n37B1yKjxOFg5vo+rVYXZd69oVxd7eBoRT7FWRmY1FHJxFJhnyhBFCCCEl9RzPl8UJaQdI6SM5zSBM3ZwcpeN9lcWmSEvO7qYjhBBCSpACJ8AkJY+Hi6Mq7OvqZIP/nbpwgsWJEEIIsYWSKxcuXFDJLi9dumScbYfEmHXq1JHSji246kxZvPeSJKdlyMC2tZSYKvPcuSlycoWhTl2l+0RWjRap2lBk6K8l3TNCCCGlgFLtqjPHv//9b5k9e3YuNx7ioV5//XWZPn16QT+C5IOPfj+lhFPPxr62IZw8Kou0G2VYP/enSOwVEVefku4VIYSQckqBfDtffvmlzJw5U5566ik1iy4mJkYtWEetOhzDQooPmy67Yu9keE1PKemeEEIIKacUyCTx/fffS79+/WTp0qXZ9rdv316WLFkiSUlJMn/+fFWahRQdg7/fKw72djJnUEtjCgKbSYJ554ZI5CkRt0pZcU7MHE4IIaQsWpwuXrwoPXv2tHgcx9CGFB1p6Rmy+9xN2XH2hirr5piZMsJmyq5c3iPyU1+R38exyC8hhJCyLZxQ4Pfo0aMWj+NY1apVC/IR5C6kmBT0dXGyF6dMi5PNFPo1piNwyXLVseQKIYSQsiicnnnmGVmwYIFMmzZN7ty5Y9yP9c8++0wdGzhwYGH0k1ggJS1LIDk72KsEmCAp1UaEkx7PBOGEBaQllWiXCCGElF8KFOP00UcfqTp1EydOVHXratSoofZfu3ZN0tLS5OGHH5YpU6YUVl+JGTCDDiBJuKODvXi4GITTnWQbqeemiyQHF8Nsusr1RdwqlnSvCCGElFMKJJzc3d1ly5Yt8ttvv2XL49SrVy/p3bu39O3bV5VcIUVHQooha7iHs+G/clKfIOW+a1zDRqbsJ8cbXl08Rbz8RMYeLOkeEUIIKcfcs3BKSEiQoUOHyoABA2TIkCHSv3//wu0ZsQrdsoTs4aB9XRsruZKSKZycPUu6J4QQQsi9xzjB2rR582YloEjJ1qlzc3IQT1cbSHZ5N4sTIYQQUsIU6GnbuXNnlexy1KjMzM6k2GkdUElOf9RLMjIM6QeCr8TI6fA4aeTnJS1r20AsUKPeIp7VRGq2Nmz/+LhIzGWRwUtFqjUq6d4RQggpZxRoVt3cuXNlx44d8t5778nVq1cLr1ck39gjOlxE1hy9Ju+sOC4bTkaITRDYWaTz6yJ1uhi2Y6+KxFwSSYop6Z4RQggphxRIODVv3lwJpqlTp6rCvi4uLqrAnumCwnuk+PBwNsyqS0ixkVl1OdFddroLjxBCCCkrrjrUoysK5s2bJ1988YVcv35dibM5c+ZIu3btLLZftmyZTJo0SWUpr1+/vsohhVl95YGlB67I2uPh0qdZdXm2TS3xcjUkiYxNtJEkkZf3iji6ilRtKOLkJuKSWfmaFidCCCFlRTihBh1SEDRs2FAqV64sjz/+uFSvXr1QOvTLL7/IG2+8Id9++62qeTdr1ixVuiUkJERlKs/J7t27ZdCgQcrqhX7897//lSeeeEIOHz4sTZo0EVvnxLVY2X4mSprUNAgKPx9X9RoeYyNJIpePFIm7KvLCFhH/NiJemddZXFhJ94wQQkg5JN+uusjISCVIBg8erBJfvvTSS9KgQQM1w64wmDFjhgo2HzFihAQFBSkBhRl8CxcuNNt+9uzZKm/U+PHj5f7771dJOVu1aqXir8oD12IS1auvt0Ew1ajgpl7DMveXaVCTLj4zVgs5nECFWobXmCsl1y9CCCHllnxbnCBM4BIbN26cdOvWTUJDQ9W+F198Uc6dO1egzqSkpMihQ4fknXfeMe6zt7eXHj16qNl75sB+WKhMgYVq1apV+frs43+tFE93d+O2JoZZanZ29tL84SyX5JkjO+TOzbDMo2iomb5Ii27PiIOjo7Ht7cjLxrZ6G5wd4LzOLgbBExK8S2LDz4mW2cgux3uaPTRA3DwM8T0hR/fIrcun1VncQy9LL3tNOiRFi5w6Kg2S0sRDNAmLEbl0844EpF0SuREiV6MTM9132Yv/Rvs9IGnOPtLpvirifOuMSMQJCY9NkuiEzFInpm19O0qqa2XpULeyuMaeF7kWLNfjkuTWneRc542p1kFS3H2lbWAl8Yi/JHL1gETdTpYb8Zm157K1bSfJHjWkVUBF8U4ME7m0W27Gp0j8tdMSkJEqaU5esjPcSeR6pPilVhPMpUu/tFscMDh2dhJ++axEnbNcM9E/qL1U8jUIroiwCxJx5pDFtjUatZEq1QPVelT4ZQn/e7/Ftn71W0o1//vU+s3IaxJ2crfFttXqNhW/gIaG73szUi4f+8ti2yoBQVKjbpBaj425JZeO/GmxbSX/BuJfv5laj78dK+cPbrLYtkKN+6R2w5ZqPTHhjpzdt85iWx/fAAkIaqvWk5OTJGT37xbbelX1lzpNOqh1VAw4tcPy355HZT+5r1lntY5r/dj2FWKX9YeRDfcK1aReyweN28f+WiWSbj52z9W7kjRo3c24fWLnGslIzX2tAWcPH2nU7pGstrvXSUZyVskoU5zcPOT+Do8Zt0/t2yhpCXFm2zq6uEpQp8eN238f2CIp8dFm2zo4OknjLlm570IObZPkuBtm29rZ20nTrgOM22eDd0hitOXJH826PoUbp1oPPbZHEm5ats427txPHJyc1fr5k/slPvKyxbaNOvYWZ1fDPfLi34clLvy8xbYN2j0qrh4GK/ilM0clNuysxbb3te4mHt6V1PqVcycl+vJpi20DW3YV7wqG+qdhF0Lk5sXjFtsGNH1AfKoYLNS8R5SPe0SpFU4bN26U5557TqZPn27c5+vrqyxQcKfBfXev3LhxQ9LT09X5TMH233//bfY9iIMy1x77zZGcnKwWnbg4w02w6a6x4u2SO8t5mmYvYiKc4jdNk1YJOy1+h+QH+xuFU9zWWdImzrIlLq7to0bhFPPXt9L+1mqLbSOadzYKp+hdP0rHyCVqvRNiwbFsN7TzEpEe/t/Lb1czk2IG/yqyY7r44+Zg5rx9kj+Rk1odOTLpEXEOWSuyZYrgVmPO8fp08vtyUGsku97uJjVDt4isnyCwA2XagrLxXMoE+SujuWx+40Gpd2WnyJpXBbc7cyWfX0x5XTZktJM1YzpL0+iDIqtGC9J46qk81yY1ldd+NGQMryo+stPFUcIDBkhgZlb683t+kwdOf2Rx7I5nfC2VfIeo9QsH1kuH4Lcttj2a8IVU6fMvtX4xeJu03TfWYttD0R9INf9xav3Sib3S6q+RFtseiBgvfgHvqfUrIYel2fY82tZ9RWrU/VSth184lWfb/f4jxL/+LLUeEXYx7/P6DZTaDb9T67eirufZ9lDlvhIQtFit346Ly7PtYZ8eUqfJr2o9KSU1z7ZHPR4QafaHWse9MGjrKHGyM2S/z8lJ11YiLbcatwO3jBZvO/N540KcgkRaZ/24qrZ5rFQT86LlvENdkXZHjNs+m8ZJLS3cbNsw++oiJsLJecNbEpRxwWzbKLtKIibCKWPDu9IszbwIuC3uIibCKXnDB9IsJatPpqRqDiImwiluw6fSOtHyA1gexHkNwunWxi+kXfwWi02T2lwQByeDaIncNEs6xKy12Dbm/mPi7Beg1sM2fy0P3Fhmse31wN3iV6exWr/y5w/S+fpPFtte9t0gHkGGh+ql7f8nnS9/a7HtOa9fxbtND7V+cecv8sC5Ly22Pe30k/h0fkKt8x5RPu4RpVY4Xb58WSZMmJArnxOUYURERIGEU3GAWKgPP/ww1/5z9nXEy8EwIw1omQ9lTeylgUm7FJ9AOZsSme29pjaiQLss72d6hTpyJtFyrqHqmQJLvbtioITEB2W3NhnXRKo6ZRa4hU6qHCghsYb4LWQh8PN2FS9Xw69G8ObDzcUzOEWqeLqIVAwQCegsV6ITTKxIWeet4VNFxMHbkM7Ap5ZIYBe5GpOoLD5Z381ANe9q0tjRW5xU25oidR9SLsHIuORc/a3o7afaujg6iHjXELmvm1yLSZLw2EwXokkpHi+vGtLYyVtcnexFPH1F6j2irF5XYxLkpn1lWeI2TBrbZwaFi7eMSZ8nr7UweZh5VZFQB8OvOnM4u1fIWveslGdbJ8+s3FfOnhXybuuVlaXdxcM7z7aOyEVl7I9Xnm3tvbJ+CDi7eeTd1jtLtjq5uObZVvOqkdUfZ6c826Z7Zcls/BDIq22qV6b7NPN6zKttslftbNvnHeuKg5gvSJ3gaXhI61xxriMuGeZj9257GiwAOuEudSQurZL5th7ZzxvlGijJKe7m++DqKzVNtqPdAyQ00XyEQ5JThWw/DPA5oZl/RzlJc3BTllOdO561JTTWvCVLs3OQ+ibbyZ61JDTF8hjXM1lP9fKX0ETLbf1N71doe9ty22qOhoknCu8aEhptuW0Fk/sVrtHQKMttPVyyxt4BbfP6m3PLSoTr6FX1Ln/3WTO6eY8oH/eI4sJO031DVgLX2eLFi5WFSefmzZtStWpVFecE911BXHWIZ1q+fLkK8NYZNmyYxMTEqID0nNSuXVu56l5//XXjvsmTJytX3dGjR62yONWqVUtiY2NV+gRCCCGElB3i4uJU6qPieo7f06w6xDhh1poOOgvOnj0rFSpkKXcdBGtbg7Ozs7Ru3VoVDtaFU0ZGhtoeM2aM2fd07NhRHTcVTps2bVL7zYFcU1gIIYQQQorF4mRn4mbRwWly7tf3IW4pP+kIYGGaP3++yt2EdARLly5VMU6IXUJ8Vc2aNZXLTU9H0LVrV5k2bZr06dNHlixZIp9++qnV6Qgg+iD2rly5QosTIYQQUsaIy/QcwTNVHEm3821xWrRokRQlAwcOlKioKHn//fdVgHeLFi1k/fr1xgBwxFhBvOl06tRJ5W5C2RekR0ACTLjprM3hBDcjwKATQgghpGxy8+bNYhFO+bY42RpQqBUrVlSCjOVhCkf103pXcDiWhQfHsvDgWBYeHMvCA54jxDtHR0ebDRcqVSVXbAHdegXRxIu3cNDrFJKCw7EsPDiWhQfHsvDgWBYept6ooqR4PoUQQgghxAagcCKEEEIIsZJyL5yQmgB5n5iioOBwLAsPjmXhwbEsPDiWhQfHsuyOZbkPDieEEEIIsZZyb3EihBBCCLEWCidCCCGEECuhcCKEEEIIsZJyL5zmzZsngYGB4urqKu3bt5f9+/dLeeavv/6Svn37So0aNVS5HGRhNwUhccjqXr16dXFzc5MePXqoGoWm3Lp1S4YMGaJykyAZ2ciRIyU+Pj5bm2PHjkmXLl3UuCMJ3Oeffy62BsoCtW3bVry8vKRatWqq/mJISEi2NklJSfLKK69I5cqVxdPTUwYMGCARERHZ2iA5K8oJoQA2zjN+/HhJS0vL1mbbtm2qJiSCI+vVqyc//vij2ArffPONNGvWzJjvBnUo161bZzzOMbx3UKoKf+emtT45ntbxwQcfqLEzXRo1amQ8znHMH2FhYTJ06FA1Xni2NG3aVA4ePFg6nz1aOWbJkiWas7OztnDhQu3kyZPaqFGjtAoVKmgRERFaeeWPP/7Q3n33XW3FihWYNKCtXLky2/Fp06ZpPj4+2qpVq7SjR49q/fr10+rUqaMlJiYa2/Tq1Utr3ry5tnfvXm3Hjh1avXr1tEGDBhmPx8bGar6+vtqQIUO0EydOaP/73/80Nzc3bf78+Zot0bNnT23RokXqOwYHB2u9e/fWateurcXHxxvbvPTSS1qtWrW0LVu2aAcPHtQ6dOigderUyXg8LS1Na9KkidajRw/tyJEj6v+nSpUq2jvvvGNsc/78ec3d3V174403tFOnTmlz5szRHBwctPXr12u2wOrVq7W1a9dqZ86c0UJCQrSJEydqTk5OalwBx/De2L9/vxYYGKg1a9ZMe+2114z7OZ7WMXnyZK1x48ZaeHi4cYmKijIe5zhaz61bt7SAgABt+PDh2r59+9T33rBhgxYaGloqnz3lWji1a9dOe+WVV4zb6enpWo0aNbSpU6eWaL9KCzmFU0ZGhubn56d98cUXxn0xMTGai4uLugAB/rjxvgMHDhjbrFu3TrOzs9PCwsLU9tdff61VrFhRS05ONraZMGGC1rBhQ82WiYyMVGOzfft249hBACxbtszY5vTp06rNnj171DZupvb29tr169eNbb755hvN29vbOH5vvfWWuoGbMnDgQCXcbBVcPwsWLOAY3iO3b9/W6tevr23atEnr2rWrUThxPPMnnPCQNgfHMX/g/t+5c2eLx0vbs6fcuupSUlLk0KFDytxnmq4d23v27CnRvpVWLly4oAovm44ZStXAxamPGV5hIm3Tpo2xDdpjbPft22ds8+CDD4qzs7OxTc+ePZUbC7WGbLmeEqhUqZJ6xfWXmpqabTxh6kfNJdPxhMlaL3KtjxXqXJ08edLYxvQcehtbvI7T09NlyZIlcufOHeWy4xjeG3AhwUWU8ztzPPMHXEUIa6hbt65yEcH1BjiO+WP16tXqmfHMM88ol2XLli3l+++/L7XPnnIrnG7cuKFuwqYXLcA2/oNIbvRxyWvM8IoL3xRHR0clFkzbmDuH6WfYGhkZGSqO5IEHHpAmTZoYvyv+gHMWpcw5nncbK0ttcANOTEwUW+D48eMqTgRxHi+99JKsXLlSgoKCOIb3AITn4cOHVQxeTjie1oOHNuKN1q9fr+Lw8HBH7Mzt27c5jvnk/Pnzagzr168vGzZskNGjR8urr74qP/30U6l89pT7Ir+EFNcv/BMnTsjOnTtLuitlkoYNG0pwcLCy2i1fvlyGDRsm27dvL+lulTmuXLkir732mmzatEkFx5J757HHHjOuY/IChFRAQIAsXbpUBS+T/P2whKXo008/VduwOOF++e2336q/9dJGubU4ValSRRwcHHLNcsC2n59fifWrNKOPS15jhtfIyMhsxzFLBLMdTNuYO4fpZ9gSY8aMkd9//122bt0q/v7+xv34rnAZx8TE5DmedxsrS20ws8RWbuD49Y4ZRa1bt1aWkubNm8vs2bM5hvkELiT8fWKWFn6NY4EA/eqrr9Q6fn1zPO8NWJcaNGggoaGhvC7zCWbKwYJsyv333290fZa2Z0+5FU64EeMmvGXLlmyqF9uInSC5qVOnjrq4TMcMJmP4j/UxwytuFrhB6/z5559qbPGLTG+DtAeIAdDBL2BYFSpWrCi2AuLrIZrgVsIYYPxMwfXn5OSUbTzha8fNwnQ84aYyvSFgrHDj1G80aGN6Dr2NLV/HuJ6Sk5M5hvmke/fuaixgvdMX/NJHfI6+zvG8NzDt/dy5c0oE8LrMHwhhyJmq5cyZM8qCVyqfPVo5T0eAqPwff/xRReT/61//UukITGc5lDcw2wZTY7Hg8pgxY4Zav3TpknFKKMbot99+044dO6b179/f7JTQli1bqmmlO3fuVLN3TKeEYjYEpoT+85//VFNC8f+AKbe2lo5g9OjRavrstm3bsk1ZTkhIyDZlGSkK/vzzTzVluWPHjmrJOWX50UcfVSkNMA25atWqZqcsjx8/Xs3cmTdvnk1NWX777bfVTMQLFy6oaw7bmCmzceNGdZxjWDBMZ9UBjqd1/Pvf/1Z/27gud+3apdIKIJ0AZs8CjmP+UmM4Ojpqn3zyiXb27Fnt559/Vt978eLFxjal6dlTroUTQF4MXNzI54T0BMj/UJ7ZunWrEkw5l2HDhhmnhU6aNEldfBCd3bt3V7l1TLl586a6WD09PdXU2hEjRihBZgrycGD6Kc5Rs2ZN9Udha5gbRyzI7aSDP/qXX35ZTZHFH/CTTz6pxJUpFy9e1B577DGVbwQ3ZtywU1NTc/2/tWjRQl3HdevWzfYZZZ3nn39e5XjBd8ODBdecLpoAx7BwhRPH0zqQFqB69erq++Eehm3TvEMcx/yxZs0aJSTxTGjUqJH23XffZTtemp49dvgnn1Y1QgghhJBySbmNcSKEEEIIyS8UToQQQgghVkLhRAghhBBiJRROhBBCCCFWQuFECCGEEGIlFE6EEEIIIVZC4UQIIYQQYiUUToQQQgghVkLhRAghVmBnZycffPBBSXeDEFLCUDgRQooVFDZ9+umnVQFPV1dXqVmzpjzyyCMyZ86cku4aIYTcFQonQkixsXv3bmnTpo0cPXpURo0aJXPnzpUXXnhB7O3tZfbs2SXdPUIIuSuOd29CCCGFwyeffCI+Pj5y4MABqVChQrZjkZGRJdYvQgixFlqcCCHFxrlz56Rx48a5RBOoVq2acX3RokXSrVs3tc/FxUWCgoLkm2++yfWewMBAefzxx2Xbtm3KkuXm5iZNmzZV22DFihVqGy7B1q1by5EjR7K9f/jw4eLp6Snnz5+Xnj17ioeHh9SoUUOmTJki1tQ/DwsLk+eff158fX1VP/HdFi5ceI+jQwgpC1A4EUKKDcQ1HTp0SE6cOJFnO4gktJ04caJ8+eWXUqtWLXn55Zdl3rx5udqGhobK4MGDpW/fvjJ16lSJjo5W6z///LOMGzdOhg4dKh9++KESbc8++6xkZGRke396err06tVLiZ/PP/9cCazJkyerJS8iIiKkQ4cOsnnzZhkzZoxyNdarV09Gjhwps2bNuscRIoSUejRCCCkmNm7cqDk4OKilY8eO2ltvvaVt2LBBS0lJydYuISEh13t79uyp1a1bN9u+gIAAmIW03bt3G/fhfNjn5uamXbp0ybh//vz5av/WrVuN+4YNG6b2jR071rgvIyND69Onj+bs7KxFRUUZ96Pd5MmTjdsjR47Uqlevrt24cSNbn/7xj39oPj4+Zr8DIaTsQ4sTIaTYwOy5PXv2SL9+/VSAOCw8cJFhZt3q1auN7eBy04mNjZUbN25I165dlUsN26bAjdexY0fjdvv27dUrXH21a9fOtR/nyAksRqZpB7CdkpKirEnmgI769ddflWUL6+ifvuD7oI+HDx++x1EihJRmGBxOCClW2rZtq2KPIEwgnlauXCkzZ85UKQqCg4OVENq1a5dylUFkJSQkZHs/RAkCzHVMxRHQj8G9Z24/XHmmYEZf3bp1s+1r0KCBer148aLZ7xAVFSUxMTHy3XffqcUcDHYnxDahcCKElAjOzs5KRGGBUBkxYoQsW7ZMxSR1795dGjVqJDNmzFACCG3/+OMPJbByxig5ODiYPb+l/dYEfd8NvQ/o67Bhw8y2adasWYE/hxBS+qBwIoSUOJgRB8LDw2XNmjWSnJysXHem1qStW7cWyWdDBMF9p1uZwJkzZ4yz9sxRtWpV8fLyUoHlPXr0KJJ+EUJKJ4xxIoQUGxA/5iw+sCaBhg0bGi1Fpu3gnkOKgqICiTh18LnYdnJyUpYvc6CPAwYMUHFO5mYIwpVHCLFNaHEihBQbY8eOVTFLTz75pHLFIc4J2cR/+eUXZd2Buw7T/OGaQ+D1iy++KPHx8fL999+rnE6wSBU2yPG0fv165XJDAPm6detk7dq1KhUCLEuWmDZtmhKCeA+yoCM269atWyooHEHlWCeE2B4UToSQYmP69OkqjgkWJgRVQzjBHYccTe+9955KjIll+fLlavvNN98UPz8/GT16tBIxSDZZ2MB6BOGEzxg/frxywSEw/f3338/zfcj7tH//fpUsE8HuX3/9tVSuXFklwfzss88KvZ+EkNKBHXISlHQnCCGkJEDmcIg0WLUIIcQaGONECCGEEGIlFE6EEEIIIVZC4UQIIYQQYiWMcSKEEEIIsRJanAghhBBCrITCiRBCCCHESiicCCGEEEKshMKJEEIIIcRKKJwIIYQQQqyEwokQQgghxEoonAghhBBCrITCiRBCCCHESiicCCGEEELEOv4f0BtX/g9swBoAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 600x600 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ymin, ymax: -1.232801602705484 1.1063238858431184\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "ind = 10\n",
    "\n",
    "## Model 1\n",
    "plot_labels_signals(X_test_phase[ind, :, :], p_predict=test_phase_out1[ind, :, 0], s_predict=test_phase_out1[ind, :, 1], p_labels=y_test_phase[ind, :, 0], s_labels=y_test_phase[ind, :, 1], sample_num=6000)\n",
    "plt.show()\n",
    "\n",
    "## Model 2\n",
    "plot_labels_signals(X_test_phase[ind, :, :], p_predict=test_phase_out2[ind, :, 0], s_predict=test_phase_out2[ind, :, 1], p_labels=y_test_phase[ind, :, 0], s_labels=y_test_phase[ind, :, 1], sample_num=6000)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3519d7fa-f563-419a-9268-ff9ae76562a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ind=20\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(y_test_phase[ind, :, 0])\n",
    "plt.title('Ground truth');\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(test_phase_out1[ind, :, 0]);\n",
    "plt.title('Model 1');\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(test_phase_out2[ind, :, 0]);\n",
    "plt.title('Model 2');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "551c42d2-4b08-4c41-80c8-d29c1a9d801d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGzCAYAAAD9pBdvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA2iklEQVR4nO3dC3gU5b3H8X8SciECQYwmGFOiYkGKJDRIjJdST6NRqVarFq/kUMV6wVrTYxUviVo1tCqHtkapF7RP1UL14KWKUZuKlpoaJVLFC4o3IpqbSIIBEpKd8/zfZCY7yW4kmN3ZsN+Pz7g7k5nddyfL5rfvbWIsy7IEAADAI7FePTEAAIAijAAAAE8RRgAAgKcIIwAAwFOEEQAA4CnCCAAA8BRhBAAAeIowAgAAPEUYAQAAniKMAPBUTEyMXH/99QM+7uOPPzbHPvDAAyEpF4DwIYwAMH/Q9Q+7LqtWrerzc71qRGZmpvn5D3/4QxlK3n33XfnVr34lOTk5MnLkSBk7dqzMnDlTXnvtNa+LBqAbYQSAIykpSR5++OE+21988UX59NNPJTExUYaae++9V+655x6ZNm2a3H777VJcXCzr1q2Tww47TP7+9797XTwAhBEA/k444QR55JFHpKOjw7VdA0pubq6kp6fLUHPmmWdKbW2tCSUXXHCBXHHFFfLKK6/ImDFjdql5CMDgI4wAcP3h/uKLL+T55593trW3t8ujjz4qZ511VsBjWltb5Ze//KVpxtGakwkTJshtt91mmnb8tbW1yeWXXy577723aS456aSTTG1LIBs3bpSf/vSnkpaWZh7zO9/5jixZsmSXXpOGqBEjRri27bXXXnLUUUfJO++8s0uPCWBwEUYAOLKysiQ/P1/+8pe/ONueeeYZaW5uljPOOKPP/ho4NFT87//+rxx33HGycOFCE0a09kGbQ/ydf/75smjRIjn22GNlwYIFEh8fb/pu9FZfX+80ocybN09+97vfyfjx4+W8884zxw+Wuro6SU1NHbTHA/ANWACi3v3336/VGNarr75q3XHHHdbIkSOtrVu3mp+dfvrp1tFHH23ujxs3zpo5c6Zz3OOPP26Ou+mmm1yPd9ppp1kxMTHW+vXrzfqaNWvMfhdffLFrv7POOstsLy0tdbadd9551tixY62mpibXvmeccYaVkpLilOujjz4yx2rZB+qll14y5bvuuusGfCyAwUfNCACXn/zkJ7Jt2zZ56qmnZMuWLeY2WBPNihUrJC4uTn7+85+7tmuzjdaaaK2KvZ/qvd8vfvEL17oe83//939y4oknmvtNTU3OUlhYaGpoampqvtHra2hoMK9n//33N6NsAHhvmNcFABBZtE9HQUGB6bS6detW6ezslNNOOy3gvp988onsu+++pg+Iv4MPPtj5uX0bGxsrBx54oGs/bdLx19jYKJs3b5a7777bLMHCxK7S/i06NFlDlg5h7t2XBIA3CCMA+tCag7lz55p+Fccff7yMHj06LM/r8/nM7TnnnCNFRUUB95kyZcouPbZ2xP3xj38sb7zxhjz77LMyefLkb1RWAIOHMAKgj1NOOUV+9rOfyb///W9ZtmxZ0P3GjRtnOppqTYN/7YhONGb/3L7VoPHBBx+4akN0vg9/9kgbrY3R2pnBos89e/ZsqayslL/+9a8yY8aMQXtsAN8cfUYA9KHNF3fddZeZh0P7b/Q3L4kGhzvuuMO1XUfX6GytWqui7Nvf//73rv16j47R/iennnqq6Teydu3aPs+nzTi74tJLLzWh6s477zS1IwAiCzUjAAIK1kziT4PK0UcfLddcc425Vkx2drY899xz8sQTT5jOqXYfEZ2KXecw0TCgnVAPP/xwU0uxfv36Po+pw35feOEFycvLM01FkyZNkk2bNpmOq1oLo/cHQgOPPq8OWU5OTpYHH3ywTy3QHnvsMaDHBDC4CCMAdpl2Sn3yySelpKTE1Dzcf//9Zq6SW2+91Yyo8aeTlmkzzEMPPSSPP/64/Nd//Zc8/fTTZrI0fzrRWXV1tdx4442yfPlyEyR0kjKd+Ow3v/nNgMu4Zs0ac1tVVWWW3j766CPCCOCxGB3f63UhAABA9KLPCAAA8BRhBAAAeIowAgAAPEUYAQAAniKMAAAATxFGAACAp4bEPCM6lfNnn31mponWWR0BAEDk09lD9HIRekFNnZdoSIcRDSK9J0YCAABDQ21trey3335DO4zYF+DSFzNq1CiviwMAAHZCS0uLqUzwv5DmkA0jdtOMBhHCCAAAQ8vXdbGgAysAAPAUYQQAAHiKMAIAADxFGAEAAJ4ijAAAAE8RRgAAgKcIIwAAwFOEEQAA4CnCCAAA8BRhBAAADL0wUl5eLllZWZKUlCR5eXlSXV3d7/6LFi2SCRMmyPDhw80c9Zdffrls3759V8sMAACiOYwsW7ZMiouLpbS0VGpqaiQ7O1sKCwuloaEh4P4PP/ywXHXVVWb/d955R+677z7zGFdfffVglB8AAERbGFm4cKHMnTtX5syZI5MmTZLFixdLcnKyLFmyJOD+L7/8shxxxBFy1llnmdqUY489Vs4888yvrU2BNz79cqssfvEDad62w+uiAACixIDCSHt7u6xevVoKCgp6HiA21qxXVVUFPObwww83x9jh48MPP5QVK1bICSecEPR52trazGWH/ReEx8nlL8uCZ96Vax9f63VRAABRYthAdm5qapLOzk5JS0tzbdf1d999N+AxWiOixx155JFiWZZ0dHTIhRde2G8zTVlZmdxwww0DKRoGSdNXbeb2X+ubvC4KACBKhHw0zcqVK+WWW26RO++80/QxWb58uTz99NPy61//Ougx8+fPl+bmZmepra0NdTEBAMBQqBlJTU2VuLg4qa+vd23X9fT09IDHXHfddXLuuefK+eefb9YPOeQQaW1tlQsuuECuueYa08zTW2JiolkAAMDub0A1IwkJCZKbmyuVlZXONp/PZ9bz8/MDHrN169Y+gUMDjdJmGwAAEN0GVDOidFhvUVGRTJs2TaZPn27mENGaDh1do2bPni0ZGRmm34c68cQTzQicqVOnmjlJ1q9fb2pLdLsdSgAAQPQacBiZNWuWNDY2SklJidTV1UlOTo5UVFQ4nVo3bNjgqgm59tprJSYmxtxu3LhR9t57bxNEbr755sF9JQAAYEiKsYZAW4kO7U1JSTGdWUeNGuV1cXZrWVc9bW7H7JEgNdcd43VxAABD2M7+/ebaNAhoCGRUAMBugjACAAA8RRhBQNrPBwCAcCCMIKCt7R1eFwEAECUIIwho+w6f10UAAEQJwggAAPAUYQQAAHiKMAIAADxFGAEAAJ4ijAAAAE8RRgAAgKcIIwAAwFOEEQAA4CnCCAAA8BRhBAAAeIowAgAAPEUYgUtSPG8JAEB48ZcHLvFxvCUAAOHFXx64xHhdAABA1CGMwCU2ljgCAAgvwghcYmMIIwCA8CKMwIUoAgAIN8IIXGKoGQEAhBlhBC7+WcSyLC+LAgCIEoQRuPj3X33u7XoviwIAiBKEEQTtwFrXvN3TsgAAogNhBC70GAEAhBthBEE7sNJnBAAQDoQRBO/A6mVBAABRgzACFyY9AwCEG2EELswGDwAYEmGkvLxcsrKyJCkpSfLy8qS6ujrovt///vdNP4Tey8yZM79JuRGWPiOeFgUAECUGHEaWLVsmxcXFUlpaKjU1NZKdnS2FhYXS0NAQcP/ly5fL559/7ixr166VuLg4Of300wej/Bhk/hUjZBEAQESGkYULF8rcuXNlzpw5MmnSJFm8eLEkJyfLkiVLAu4/ZswYSU9Pd5bnn3/e7E8YiUzMwAoAiOgw0t7eLqtXr5aCgoKeB4iNNetVVVU79Rj33XefnHHGGbLHHnsE3aetrU1aWlpcC8LfgZUsAgCIuDDS1NQknZ2dkpaW5tqu63V1dV97vPYt0Waa888/v9/9ysrKJCUlxVkyMzMHUkwMUs1IJ2kEALC7jabRWpFDDjlEpk+f3u9+8+fPl+bmZmepra0NWxmjXYevJ4B0+t0HACBUhg1k59TUVNP5tL7efQE1Xdf+IP1pbW2VpUuXyo033vi1z5OYmGgWhN+Hja3OfR9hBAAQaTUjCQkJkpubK5WVlc42n89n1vPz8/s99pFHHjF9Qc4555xdLy3CimYaAEDE1YwoHdZbVFQk06ZNM80tixYtMrUeOrpGzZ49WzIyMky/j95NNCeffLLstddeg1d6hBQVIwCAiAwjs2bNksbGRikpKTGdVnNycqSiosLp1LphwwYzwsbfunXrZNWqVfLcc88NXskRcjTTAAAiMoyoefPmmSWQlStX9tk2YcIE5qwYgmimAQCEA9emQVDUjAAAwoEwApeRiT2VZQztBQCEA2EEQZFFAADhQBiBi3/+8NFnBAAQBoQRBEUzDQAgHAgjcPEf9cRoGgBAOBBG4OIfP1rbOjwsCQAgWhBGENQTaz7zuggAgChAGIELLTMAgHAjjMDFcjXUAAAQeoQRAADgKcIIXGimAQCEG2EELmQRAEC4EUYAAICnCCNwo2oEABBmhBG4MJoGABBuhBEAAOApwghcGE0DAAg3wghcyCIAgHAjjAAAAE8RRuBi0U4DAAgzwghciCIAgHAjjAAAAE8RRuBCKw0AINwIIwAAwFOEEQAA4CnCCIKOpCn8TppnZQEARA/CCIL2F9lnZJJXRQEARBHCCBy+XmmEi+YBAMKBMAKHr1f2YGQNACAcCCPop2YEAIAIDSPl5eWSlZUlSUlJkpeXJ9XV1f3uv3nzZrnkkktk7NixkpiYKN/+9rdlxYoVu1pmAACwGxk20AOWLVsmxcXFsnjxYhNEFi1aJIWFhbJu3TrZZ599+uzf3t4uxxxzjPnZo48+KhkZGfLJJ5/I6NGjB+s1IFQ1I1SNAAAiMYwsXLhQ5s6dK3PmzDHrGkqefvppWbJkiVx11VV99tftmzZtkpdfflni4+PNNq1VQeT3GaGhBgAQcc00WsuxevVqKSgo6HmA2FizXlVVFfCYJ598UvLz800zTVpamkyePFluueUW6ezsDPo8bW1t0tLS4loQetSMAAAiPow0NTWZEKGhwp+u19XVBTzmww8/NM0zepz2E7nuuuvk9ttvl5tuuino85SVlUlKSoqzZGZmDqSY2EXbd7gDImEEALBbjKbx+Xymv8jdd98tubm5MmvWLLnmmmtM804w8+fPl+bmZmepra0NdTEhIv/+cJNrnXlGAAAR12ckNTVV4uLipL6+3rVd19PT0wMeoyNotK+IHmc7+OCDTU2KNvskJCT0OUZH3OiC8MoYPdy1Ts0IACDiakY0OGjtRmVlpavmQ9e1X0ggRxxxhKxfv97sZ3vvvfdMSAkUROCdlOHubEoWAQBEZDONDuu955575E9/+pO88847ctFFF0lra6szumb27NmmmcWmP9fRNJdddpkJITryRjuwaodWRBZqQgAAQ2Jor/b5aGxslJKSEtPUkpOTIxUVFU6n1g0bNpgRNjbtfPrss8/K5ZdfLlOmTDHzjGgwufLKKwf3leAb651FCCcAgHCIsXpfNz4C6dBeHVWjnVlHjRrldXF2W+vqtkjhopec9R9/N0MW/iTH0zIBAIaunf37zbVpEFzEx1QAwO6AMIKgQ3nJIgCAcCCMwNG7wW4ItOABAHYDhBEEDyNeFQQAEFUIIwjeTEMaAQCEAWEEDmpGAABeIIwAAABPEUYQFB1YAQDhQBiBg2YaAIAXCCMI2oGVNAIACAfCCPqpGSGNAABCjzACBxfKAwB4gTCCoAgjAIBwIIwg6OgZmmkAAOFAGIGD6AEA8AJhBP1cKM+rkgAAoglhBH56N9MAABB6hBE4qBkBAHiBMIJ+kEYAAKFHGIGDeUYAAF4gjMDBtWkAAF4gjCD4PCNUjQAAwoAwguDNNB6VAwAQXQgjcFARAgDwAmEEQRFOAADhQBhB0GvRkEUAAOFAGEGPPpOeEUcAAKFHGIGD6AEA8AJhBA6mgwcAeIEwgn76jJBGAAChRxhBUNSMAAAiNoyUl5dLVlaWJCUlSV5enlRXVwfd94EHHpCYmBjXosch8tBMAwAYEmFk2bJlUlxcLKWlpVJTUyPZ2dlSWFgoDQ0NQY8ZNWqUfP75587yySeffNNyIywzsJJGAAARGEYWLlwoc+fOlTlz5sikSZNk8eLFkpycLEuWLAl6jNaGpKenO0taWto3LTdCoPdQXh9ZBAAQaWGkvb1dVq9eLQUFBT0PEBtr1quqqoIe99VXX8m4ceMkMzNTfvSjH8lbb73V7/O0tbVJS0uLa0Ho9ckehBEAQKSFkaamJuns7OxTs6HrdXV1AY+ZMGGCqTV54okn5MEHHxSfzyeHH364fPrpp0Gfp6ysTFJSUpxFQwzCoFf48NFpBACwO4ymyc/Pl9mzZ0tOTo7MmDFDli9fLnvvvbf88Y9/DHrM/Pnzpbm52Vlqa2tDXUwEQBQBAITDsIHsnJqaKnFxcVJfX+/aruvaF2RnxMfHy9SpU2X9+vVB90lMTDQLwqt3h1VqRgAAEVczkpCQILm5uVJZWels02YXXdcakJ2hzTxvvvmmjB07duClRUgxtBcAEPE1I0qH9RYVFcm0adNk+vTpsmjRImltbTWja5Q2yWRkZJh+H+rGG2+Uww47TMaPHy+bN2+WW2+91QztPf/88wf/1WCQwwhpBAAQgWFk1qxZ0tjYKCUlJabTqvYFqaiocDq1btiwwYywsX355ZdmKLDuu+eee5qalZdfftkMC0akzzMCAEDoxVhD4OuvDu3VUTXamVUnUENoPPdWnVzw59XO+uSMUfLUpUd5WiYAwNC1s3+/uTYNgor8mAoA2B0QRuDonT2YgRUAEA6EETioCQEAeIEwAj/uNDIEuhMBAHYDhBE4yB4AAC8QRuAgiwAAvEAYAQAAniKMwMF08AAALxBGEPRCeQAAhANhBMFrRggnAIAwIIwg+LVpyCIAgDAgjKDPvCKxMV6XBAAQTQgj6CMmpiuNUDECAAgHwgj6oGIEABBOhBH06SPSXTHCdPAAgLAgjKDP6Bm7mQYAgHAgjKBvzYi97mVhAABRgzCCPmEklpoRAEAYEUbQh5NFqBoBAIQBYQQOO3tQLwIACCfCCAJMesY8IwCA8CGMwOGED6pGAABhRBhBj14dWJlnBAAQDoQROHzd4SOOi9MAAMKIMAJHZ6+aEOpFAADhQBiB4/bn3jO3m1rbzS2tNACAcCCMwGGHEAAAwokwgq+9Vg0AAKFEGAEAAJ4ijCAo+owAAMKBMAIAAIZeGCkvL5esrCxJSkqSvLw8qa6u3qnjli5dKjExMXLyySfvytMixDJGD3etUzMCAIjIMLJs2TIpLi6W0tJSqampkezsbCksLJSGhoZ+j/v444/lf/7nf+Soo476JuVFCP1wylhzO33/MV4XBQAQRQYcRhYuXChz586VOXPmyKRJk2Tx4sWSnJwsS5YsCXpMZ2ennH322XLDDTfIAQcc8E3LjBDhqr0AgIgPI+3t7bJ69WopKCjoeYDYWLNeVVUV9Lgbb7xR9tlnHznvvPN26nna2tqkpaXFtSB8ui9NAwBA5IWRpqYmU8uRlpbm2q7rdXV1AY9ZtWqV3HfffXLPPffs9POUlZVJSkqKs2RmZg6kmNhF9oXxYrrrRrhQHgBgyI+m2bJli5x77rkmiKSmpu70cfPnz5fm5mZnqa2tDWUx0Qs1IwCAcBo2kJ01UMTFxUl9fb1ru66np6f32f+DDz4wHVdPPPFEZ5vP5+t64mHDZN26dXLggQf2OS4xMdEsCC+7IsQOI9SLAAAirmYkISFBcnNzpbKy0hUudD0/P7/P/hMnTpQ333xT1qxZ4ywnnXSSHH300eY+zS+RyW6mAQAg4mpGlA7rLSoqkmnTpsn06dNl0aJF0traakbXqNmzZ0tGRobp96HzkEyePNl1/OjRo81t7+2IoNE0ds0IVSMAgEgMI7NmzZLGxkYpKSkxnVZzcnKkoqLC6dS6YcMGM8IGQx8XygMARGQYUfPmzTNLICtXruz32AceeGBXnhJhYNeExNKDFQAQRlRhwPHl1nZz2+nrSiU00wAAwoEwAsdjr280t6vWN3ldFABAFCGMICgqRgAA4UAYAQAAniKMICj6jAAAwoEwAgAAPEUYQT+oGgEAhB5hBAAAeIowgqC+auvwuggAgChAGEFQ23f4pJVAAgAIMcII+vVu3RaviwAA2M0RRgAAgKcII+gX18wDAIQaYQT9IosAAEKNMAIAADxFGEG/YminAQCEGGEEAAB4ijACAAA8RRgBAACeIoygX5bFxfIAAKFFGEG/6MAKAAg1wgj6RRQBAIQaYQR9TEwf6dynYgQAEGqEETim7Jdibo+dlOZsi6FuBAAQYoQROHx2Z1WqQwAAYUQYgYOBMwAALxBG4HAqRrwuCAAgqhBG0KeZxr+VxhKqSwAAoUUYAQAAniKMoN8+I/QjAQCEGmEEfZtp6DUCAIj0MFJeXi5ZWVmSlJQkeXl5Ul1dHXTf5cuXy7Rp02T06NGyxx57SE5Ojvz5z3/+JmVGiASqBKFiBAAQcWFk2bJlUlxcLKWlpVJTUyPZ2dlSWFgoDQ0NAfcfM2aMXHPNNVJVVSVvvPGGzJkzxyzPPvvsYJQfIbgoXsrwYV4XBQAQRQYcRhYuXChz5841gWLSpEmyePFiSU5OliVLlgTc//vf/76ccsopcvDBB8uBBx4ol112mUyZMkVWrVo1GOXHILL7h0zaN8VvG3UjAIAICiPt7e2yevVqKSgo6HmA2FizrjUfX0f/sFVWVsq6devke9/7XtD92trapKWlxbUg9OzYERsjkjlmuMelAQBEiwGFkaamJuns7JS0tJ5rlyhdr6urC3pcc3OzjBgxQhISEmTmzJnyhz/8QY455pig+5eVlUlKSoqzZGZmDqSYGNR5RgAA2A1G04wcOVLWrFkjr776qtx8882mz8nKlSuD7j9//nwTYOyltrY2HMWMej0tMoymAQCEz4B6KqampkpcXJzU19e7tut6enp60OO0KWf8+PHmvo6meeedd0zth/YnCSQxMdEsCC97tlVtprGH99JlBAAQUTUj2sySm5tr+n3YfD6fWc/Pz9/px9FjtF8IIovP13Ubw1V7AQBhNOAxnNrEUlRUZOYOmT59uixatEhaW1vN6Bo1e/ZsycjIMDUfSm91Xx1JowFkxYoVZp6Ru+66a/BfDQaFRpGePELVCAAgwsLIrFmzpLGxUUpKSkynVW12qaiocDq1btiwwTTL2DSoXHzxxfLpp5/K8OHDZeLEifLggw+ax0FksYfxxlIzAgAIoxhrCEwkoUN7dVSNdmYdNWqU18XZbR12S6XUtWyXpy49UuY9XCMff7FVHr0wX6ZljfG6aACAIWhn/35zbRr06cAKAEA4EUbgsOvItJlGa0XUl1t3eFsoAMBujzACh687jPh3GbnjH+97Vh4AQHQgjMBP3xlY39zY7F1xAABRgTCCgM00AACEC2EEfa9N47eNLq0AgFAjjKBP8KBiBAAQToQR9Gmm8Z8OPvJnoQEADHWEEfTbTAMAQKgRRtAjQM0IAAChRhiBw26RiSWLAADCiDCCAM00pBEAQPgQRhCgA6vXJQEARBPCCPrWjBBGAABhRBhBgHlGSCMAgPAhjKCHMx281wUBAEQTwggcdGAFAHiBMIJ+p4OfechYr4oDAIgShBH0oVnk1O/uZ+5PTB/pdXEAALs5wggclt+FaBKGdb01uDQNACDUCCNwOMEjpqephgvlAQBCjTCCvpOe+XVhtagbAQCEGGEEfWitCDUjAIBwIYwgoNjuNOLfjwQAgFAgjKBP6NAY0tNMAwBAaBFGYPhXgOh08PaU8FSMAABCjTACwz9z+M+/SgdWAECoEUbQBx1YAQDhRBhBwI6q9uBesggAINQIIwjQTKN9Rrq3k0YAACFGGEHf0KHNNPZ26kYAAJEYRsrLyyUrK0uSkpIkLy9Pqqurg+57zz33yFFHHSV77rmnWQoKCvrdH97TWpHYWLtqxOvSAAB2dwMOI8uWLZPi4mIpLS2Vmpoayc7OlsLCQmloaAi4/8qVK+XMM8+UF154QaqqqiQzM1OOPfZY2bhx42CUH4Okdw2IXTPio50GABBpYWThwoUyd+5cmTNnjkyaNEkWL14sycnJsmTJkoD7P/TQQ3LxxRdLTk6OTJw4Ue69917x+XxSWVk5GOVHKOYZcf5HnxEAQISFkfb2dlm9erVpanEeIDbWrGutx87YunWr7NixQ8aMGRN0n7a2NmlpaXEtCB8z6RmjaQAAkRhGmpqapLOzU9LS0lzbdb2urm6nHuPKK6+Ufffd1xVoeisrK5OUlBRn0aYdhLdmhNE0AIDdcjTNggULZOnSpfLYY4+Zzq/BzJ8/X5qbm52ltrY2nMWMembSs+77jKYBAITasIHsnJqaKnFxcVJfX+/aruvp6en9HnvbbbeZMPL3v/9dpkyZ0u++iYmJZoGHHVipGQEARGLNSEJCguTm5ro6n9qdUfPz84Me99vf/lZ+/etfS0VFhUybNu2blRhhaKbp6TMCAEBE1YwoHdZbVFRkQsX06dNl0aJF0traakbXqNmzZ0tGRobp96F+85vfSElJiTz88MNmbhK7b8mIESPMgshgBb02DVUjAIAICyOzZs2SxsZGEzA0WOiQXa3xsDu1btiwwYywsd11111mFM5pp53mehydp+T6668fjNeAEI2oUUQRAEDEhRE1b948swSb5Mzfxx9/vGslg8cXyuvCpGcAgFDj2jT4mmYar0oEAIgWhBH024GVLAIACDXCCLr4hxFqRgAAYUQYQR9mBlZnjTQCAAgtwggMJj0DAHiFMIK+fUb0Qnn20F7CCAAgxAgjMFyjaVzbSSMAgNAijKAPrRSJ7a4Z8ZFFAAAhRhhB4EnP6DMCAAgTwggCTHrWc5k8mmkAAKFGGEHAGhC7ZoQsAgAINcIIXDUgdghhBlYAQLgQRuAS06fPCHEEABBahBF0CZI5iCIAgFAjjMDY0T2G1x7Ky6RnAIBwIYzA+Nt/PnOtx9rNNN4UBwAQRQgjMFq27QjYd8RH1QgAIMQIIzB6Rw67mYaqEQBAqBFG0O88I0x6BgAINcIIAoYOZ84zsggAIMQIIzDadvjcGxhNAwAIE8IIjAde/ti1zrVpAADhQhhBQFy1FwAQLoQRGEX541zrXJsGABAuhBEY39prD3M7MX2ke9Iz0ggAIMQII3BdEG9CdxjhQnkAgHAhjCDwVXtppgEAhAlhBIFRMwIACBPCCAw7c9jTwPcM7QUAILQII3DNJ2KHkNjuUOIjjQAAQowwAsNpjelOI3RgBQBEdBgpLy+XrKwsSUpKkry8PKmurg6671tvvSWnnnqq2V+bABYtWvRNyoswsWtGAACIuDCybNkyKS4ultLSUqmpqZHs7GwpLCyUhoaGgPtv3bpVDjjgAFmwYIGkp6cPRpkRAj0VI919RrqziI+aEQBApIWRhQsXyty5c2XOnDkyadIkWbx4sSQnJ8uSJUsC7n/ooYfKrbfeKmeccYYkJiYORpkR0g6s9m13n5Fe188DAMDTMNLe3i6rV6+WgoKCngeIjTXrVVVVg1aotrY2aWlpcS0IdwfWrltqRgAAERVGmpqapLOzU9LS0lzbdb2urm7QClVWViYpKSnOkpmZOWiPjcB6Zw67zwhRBAAQlaNp5s+fL83Nzc5SW1vrdZGihtNM073OaBoAQKgNG8jOqampEhcXJ/X19a7tuj6YnVO1bwn9S7zR04GVeUYAABFYM5KQkCC5ublSWVnpbPP5fGY9Pz8/FOVDmPSuAem5ai9pBAAQQTUjSof1FhUVybRp02T69Olm3pDW1lYzukbNnj1bMjIyTL8Pu9Pr22+/7dzfuHGjrFmzRkaMGCHjx48f7NeDXfT6hs3m9v2GLeaWGVgBABEbRmbNmiWNjY1SUlJiOq3m5ORIRUWF06l1w4YNZoSN7bPPPpOpU6c667fddptZZsyYIStXrhys14FvqPLdrnliarpDCTOwAgAiNoyoefPmmSWQ3gFDZ17lD9rQQ80IACCqR9PAe07NCIN7AQAhRhhBQMzACgAIF8IIAmIGVgBAuBBGEJAzAytZBAAQYoQRBESfEQBAuBBG0O9MrIymAQCEGmEELqfn7ufqM9JJGgEAhBhhBEbe/mPM7YwJe5tbO4J81NTKPDEAgJAijMCwejXPfLZ5m/Oztg7G9wIAQocwAlcasZtn7NE0AACEGmEErvlE7AwSa6cS+o0AAEKMMAJ3M013Gonzqxm5a+UHHpUKABANCCNw14x0r/tVjMgdL6z3plAAgKhAGIFhD5ixa0b8m2kAAAglwghczTR0YAUAhBthBMZ/ajebWzuDEEUAAOFCGIHLh42t5ta/YiQpnrcJACB0+CsDl7rm7X22MQErACCUCCMQn988ImNGJPSpGSGLAABCiTAC2baj07l/em5m3x1IIwCAECKMQB565RPn/sikYd238c629k6uTQMACB3CCOTjL7Y69+Pjut4S08bt6WGJAADRhDACadvRU/MR1z3RiD35GQAAoUYYgbR19PQZAQAg3AgjkLYO+oQAALxDGAFhBADgKcIIZI+EOK+LAACIYoQRyDNr67wuAgAgihFGotx79Vuc+z+YuI/rZwUHpzn3361rCWu5AADRgzAS5d6v/8q5P2nfUa6fpackOvf/XNUzMRoAAIOJMBLlOnw9nVef/M9nrp/tmdx1nRrVvG1HWMsFAIgeuxRGysvLJSsrS5KSkiQvL0+qq6v73f+RRx6RiRMnmv0POeQQWbFihUQKK8ovSbuptT3ozxKH9bw9nnrjc9mynUACAIiAMLJs2TIpLi6W0tJSqampkezsbCksLJSGhoaA+7/88sty5plnynnnnSevv/66nHzyyWZZu3ateO2+VR/J/vNXyDufR2d/iOMWvSQ3/O1tZz11RE+zjErwCyPqkOufkw6uUwMAGGQx1gCrBrQm5NBDD5U77rjDrPt8PsnMzJRLL71Urrrqqj77z5o1S1pbW+Wpp55yth122GGSk5MjixcvDvgcbW1tZrG1tLSY52hubpZRo9z9Gr6JrKuednXe1IvE7ei0pNNnSfywWBkWG2OmR/dZlvh8lvisrtoCPWH6RzkuNlZ01vT2Dp/Zpqfyq7YOSYiLlWFxMZIyPF7aO3pO7/CErj/u+jhdZ90yc3zExsSY5+z6Wdfz6GNYYpky6L5dj6+3XSu6nxoWFytb2zskcViceZztHZ3m1jy6ZZlj9EJ3Ozp9Ute8Xd6t6+mw2tsL//N92T91D2ddX8vk0mf7PYepIxKk6at2OTF7X4nvnkreFhsbY55Xt2ppY3r9rLWtQ/ZIGGamntfXpdPSJ8bHSsu2DklO0Ncj5rUkxsdJp09fg+U8hp5f+1z6ul+n2RIjZj/9sT5uUnyctNlXJY4RiYvR36c+bvfvodclifVx7POnz6nlVHp+7TLo8+k1fPRWf2/6mHqOt7V3mt+5/g70tWgZh8cP3WHT+v7W82N/QuiZ6LQs829C/9PXr6fKvC8ty5w3Pef2703Z70f9eWevTxr/94P/1Qfc2+3fc9fz6q+rw9f170LpQ+p2/R1s3dEp8XExEh8ba65E3VXOrve/Po5d06e/M1MmsZz7+j7V/e1/i/rw+vr1d67H6r9HfS36eLpuP/b2jq73t72+o7tsur89s7G+d7QMeg70vv92va+vIamffXS7vn4tmz6PfknY0eEz5dTfh11mPVV6HsxrjXfvk+T3OP739X2s++h9fa9u3+EuT+/99RzqvwG7nP776Dk07w8tT/ebJsnvNfbersfqc+vz+p8HvW8+A4e5y6aflfb+9rH6b6xDPxdixClDR/c+Tnm6P0P991f6ezKfHeI+1ny2WCJJCXHms10/++3HMee5+3PX/lwz78PuO87nifvG9X6VXp/l9naruyy6Z2z3c3V9HnW95/yfz37PaXn1NQzTf6vdhdBzY587fR/qPr3/zOvjxXefi01b22Xlukazfd1Nx5nf62DSv98pKSlf+/e76xKtO6m9vV1Wr14t8+fPd7bFxsZKQUGBVFVVBTxGt2tNij+tSXn88ceDPk9ZWZnccMMNEmojE4fJlrYOc7/y3cA1O9Fi1ZVHy357Jru2jUgcJquvLZDcm/4e9DgNIupvvfqbAACGlpfea5JjJvWMogynAYWRpqYm6ezslLQ0d2F1/d133w14TF1dXcD9dXswGnb8A4xdMzLY3rj+WPnbG59LQ8t2s96VnLu+DWlrhF7AVm81dZtvEbGxJnV2fYPq+gYe250w7fRdv2W7JMcPM+laE7VJ0DFdNSnt3d/sdd18t4zpukquPp9+E9D7psYlruebp/Ta3/94peWxv+Xp7lqj0FXb0vXtVB+za4mR+pbt8umX22Tpq7VyxqGZpr/IH86a2m8S3mtEony8YKY5N/f+80N58JVPpHbTNsnaK1l+euT+5jE/+WKrTEgbaWohbFp2+xusffE9U7PR/e2t6xtdzzZ9PXoe9NuollXL3lVLZElrW6fTZGTXVPkHfX0O8+1WazLMt/Ce351+y9JvSXp+9b79TdCuxNHns8+zPq/+p+W2y6nHmBqeDv1m1PWNyK7FMrUBsV3fxPX3bb5FdX+T0W/m+q1jdHK8DFV2LZCpDew+3/rN2a4tsmtF9H2uv3t9D9q1fl2/o651+/1nvw+U/+/P/ztbsIpafV79Nmf/m7JrK803QMsyvx+9b8rQ/fvR/fQp7d+5/V4zNTrd/5706bRs9izECXaNV3eNg9Yu6Ou1y2U/Znv3drvmUt8z+jhK33f6Xu46Rz3H2vfNt93Yvve/bh99fH0N+r7S95t/+XW7CrZP78dX+pj6GvUzR+/rMfa38ED77+x9PSd6PrrORc9j6nY9r73LY9c22LUB9n27JsJ+X9i1ZP73u2o3et5vwfaxy+O/v54r/V31PtbeR3/H+p5yaqH9jrXf/+a2+7O4Z737Vj/3tebCfJ7Yn989+/rvF9O9Zn9u6vtxVFJ3rbF9zkxNXtdnm/3v07z/7L9d3TXRXbW2Xfvrcf6fwTZ9HvPv22fJmxub5bm36+WUqRlyaJZ3V2sfUBgJl8TERLOEmv6iT8reV6LNglOnDPgYfTP/bMaBZgEAwLMOrKmpqRIXFyf19fWu7bqenp4e8BjdPpD9AQBAdBlQGElISJDc3FyprKx0tmkHVl3Pz88PeIxu999fPf/880H3BwAA0WXAzTTal6OoqEimTZsm06dPl0WLFpnRMnPmzDE/nz17tmRkZJhOqOqyyy6TGTNmyO233y4zZ86UpUuXymuvvSZ333334L8aAACw+4cRHarb2NgoJSUlphOqDtGtqKhwOqlu2LDBjLCxHX744fLwww/LtddeK1dffbUcdNBBZiTN5MmTB/eVAACA6JhnxAs7O04ZAAAMvb/fXJsGAAB4ijACAAA8RRgBAACeIowAAABPEUYAAICnCCMAAMBThBEAAOApwggAAPBURF61tzd7XjadPAUAAAwN9t/tr5tfdUiEkS1btpjbzMxMr4sCAAB24e+4zsQ6pKeD1ysDf/bZZzJy5EiJiYkZ1MSmAae2tpZp5r8G52pgOF87j3O18zhXO49zFRnnSiOGBpF9993Xdd26IVkzoi9gv/32C9nj68nnzbpzOFcDw/naeZyrnce52nmcK+/PVX81IjY6sAIAAE8RRgAAgKeiOowkJiZKaWmpuUX/OFcDw/naeZyrnce52nmcq6F1roZEB1YAALD7iuqaEQAA4D3CCAAA8BRhBAAAeIowAgAAPEUYAQAAnorqMFJeXi5ZWVmSlJQkeXl5Ul1dLbuzl156SU488UQzLa9Oq//444+7fq4Dq0pKSmTs2LEyfPhwKSgokPfff9+1z6ZNm+Tss882s/SNHj1azjvvPPnqq69c+7zxxhty1FFHmfOqUwz/9re/laGmrKxMDj30UHMJgn322UdOPvlkWbdunWuf7du3yyWXXCJ77bWXjBgxQk499VSpr6937bNhwwaZOXOmJCcnm8e54oorpKOjw7XPypUr5bvf/a4ZVjd+/Hh54IEHZCi56667ZMqUKc7sjfn5+fLMM884P+c8BbdgwQLzb/EXv/iFs43z1eP6668358d/mThxovNzzpXbxo0b5ZxzzjHnQz/DDznkEHnttdeGxme8FaWWLl1qJSQkWEuWLLHeeusta+7cudbo0aOt+vp6a3e1YsUK65prrrGWL1+uw7mtxx57zPXzBQsWWCkpKdbjjz9u/ec//7FOOukka//997e2bdvm7HPcccdZ2dnZ1r///W/rn//8pzV+/HjrzDPPdH7e3NxspaWlWWeffba1du1a6y9/+Ys1fPhw649//KM1lBQWFlr333+/eQ1r1qyxTjjhBOtb3/qW9dVXXzn7XHjhhVZmZqZVWVlpvfbaa9Zhhx1mHX744c7POzo6rMmTJ1sFBQXW66+/bs5/amqqNX/+fGefDz/80EpOTraKi4utt99+2/rDH/5gxcXFWRUVFdZQ8eSTT1pPP/209d5771nr1q2zrr76ais+Pt6cO8V5Cqy6utrKysqypkyZYl122WXOds5Xj9LSUus73/mO9fnnnztLY2Oj83POVY9NmzZZ48aNs/77v//beuWVV8zrevbZZ63169cPic/4qA0j06dPty655BJnvbOz09p3332tsrIyKxr0DiM+n89KT0+3br31Vmfb5s2brcTERPNmU/oPVY979dVXnX2eeeYZKyYmxtq4caNZv/POO60999zTamtrc/a58sorrQkTJlhDWUNDg3ntL774onNu9A/uI4884uzzzjvvmH2qqqrMun7wxcbGWnV1dc4+d911lzVq1Cjn/PzqV78yH7b+Zs2aZcLQUKbvgXvvvZfzFMSWLVusgw46yHr++eetGTNmOGGE89U3jOgfxkA4V276OXvkkUdawUT6Z3xUNtO0t7fL6tWrTRWV/8X4dL2qqkqi0UcffSR1dXWuc6IXN9LmK/uc6K1W202bNs3ZR/fXc/fKK684+3zve9+ThIQEZ5/CwkLTxPHll1/KUNXc3Gxux4wZY271/bNjxw7X+dLq429961uu86XVpGlpaa5zoVfIfOutt5x9/B/D3meovg87Oztl6dKl0traapprOE+BadOCNh30fk2cr760GUGblg844ADTfKDNLopz5fbkk0+az+bTTz/dNEdNnTpV7rnnniHzGR+VYaSpqcl8aPq/QZWu6y8rGtmvu79zorf6Jvc3bNgw8wfaf59Aj+H/HEONz+czbfpHHHGETJ482Xkt+o9R/+H2d76+7lwE20c/LLdt2yZDxZtvvmna7LXN/cILL5THHntMJk2axHkKQMNaTU2N6ZfUG+fLTf9Qav+NiooK0zdJ/6BqXwW9JD3nyu3DDz805+iggw6SZ599Vi666CL5+c9/Ln/605+GxGf8sF0+EogS+i127dq1smrVKq+LErEmTJgga9asMTVIjz76qBQVFcmLL77odbEiTm1trVx22WXy/PPPm85/6N/xxx/v3NdO0hpOxo0bJ3/9619NB0y4vzRpjcYtt9xi1rVmRD+3Fi9ebP49RrqorBlJTU2VuLi4Pr2udT09PV2ikf26+zsnetvQ0OD6ufZK197X/vsEegz/5xhK5s2bJ0899ZS88MILst9++znb9bVoc9/mzZv7PV9fdy6C7aM92YfSh61+Q9VRCLm5ueYbf3Z2tvzud7/jPPWiTQv6b0hHbug3Tl00tP3+97839/UbJucrOK0F+fa3vy3r16/nvdWLjpDR2kh/Bx98sNOsFemf8VEZRvSDUz80KysrXalS17WdOxrtv//+5o3kf060mlLbCe1zorf6D18/UG3/+Mc/zLnTbyz2PjqEWNtybfotUL8577nnnjJUaB9fDSLa3KCvUc+PP33/xMfHu86XtpnqP3z/86XNF/7/uPVc6Iec/aGh+/g/hr3PUH8f6nuira2N89TLD37wA/NatRbJXvTbrPaFsO9zvoLTIaYffPCB+cPLe8tNm5F7Tz/w3nvvmZqkIfEZb0Xx0F7tRfzAAw+YHsQXXHCBGdrr3+t6d6M9+HV4my76q1+4cKG5/8knnzjDvvQcPPHEE9Ybb7xh/ehHPwo47Gvq1Klm6NiqVavMiAD/YV/aO1uHfZ177rlm2JeeZx02N9SG9l500UVmCNzKlStdwwq3bt3qGlaow33/8Y9/mGGF+fn5Zuk9rPDYY481w4N1qODee+8dcFjhFVdcYUYClJeXD7lhhVdddZUZZfTRRx+Z942ua+/75557zvyc89Q//9E0ivPV45e//KX5N6jvrX/9619miK4OzdXRbYpz5R4qPmzYMOvmm2+23n//feuhhx4yr+vBBx909onkz/ioDSNKx5PrG1nnG9Ghvjquenf2wgsvmBDSeykqKnKGfl133XXmjaZB7Qc/+IGZN8LfF198Yd6YI0aMMMPj5syZY0KOPx2/rkPM9DEyMjLMP4ChJtB50kXnHrHpP+CLL77YDHPTf4ynnHKKCSz+Pv74Y+v444834/D1Q1Q/XHfs2NHn95KTk2PehwcccIDrOYaCn/70p2Z+Ay2/ftDr+8YOIorzNLAwwvlyD7EdO3aseQ36WaLr/vNmcK7c/va3v5nwpZ+9EydOtO6++27XzyP5Mz5G/7fr9SoAAADfTFT2GQEAAJGDMAIAADxFGAEAAJ4ijAAAAE8RRgAAgKcIIwAAwFOEEQAA4CnCCAAA8BRhBAAAeIowAgAAPEUYAQAA4qX/B78yuPS+y2inAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ind=20\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(y_test_phase[ind, :, 1])\n",
    "plt.title('Ground truth');\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(test_phase_out1[ind, :, 1]);\n",
    "plt.title('Model 1');\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(test_phase_out2[ind, :, 1]);\n",
    "plt.title('Model 2');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ca995fb-f793-49dd-8563-e5635d9587d3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}