Repository: incubator-systemml Updated Branches: refs/heads/master 9f095ef67 -> 0ed123d10
http://git-wip-us.apache.org/repos/asf/incubator-systemml/blob/0ed123d1/samples/jupyter-notebooks/ALS_python_demo.ipynb ---------------------------------------------------------------------- diff --git a/samples/jupyter-notebooks/ALS_python_demo.ipynb b/samples/jupyter-notebooks/ALS_python_demo.ipynb new file mode 100644 index 0000000..4e1cb7e --- /dev/null +++ b/samples/jupyter-notebooks/ALS_python_demo.ipynb @@ -0,0 +1,700 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scaling Alternating Least Squares Using Apache SystemML" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recommendation systems based on Alternating Least Squares (ALS) algorithm have gained popularity in recent years because, in general, they perform better as compared to content based approaches.\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ALS is a matrix factorization algorithm, where a user-item matrix is factorized into two low-rank non-orthogonal matrices:\n", + "\n", + "$$R = U M$$\n", + "\n", + "The elements, $r_{ij}$, of matrix $R$ can represent, for example, ratings assigned to the $j$th movie by the $i$th user.\n", + "\n", + "This matrix factorization assumes that each user can be described by $k$ latent features. Similarly, each item/movie can also be represented by $k$ latent features. The user rating of a particular movie can thus be approximated by the product of two $k$-dimensional vectors:\n", + "\n", + "$$r_{ij} = {\\bf u}_i^T {\\bf m}_j$$\n", + "\n", + "The vectors ${\\bf u}_i$ are rows of $U$ and ${\\bf m}_j$'s are columns of $M$. These can be learned by minimizing the cost function:\n", + "\n", + "$$f(U, M) = \\sum_{i,j} \\left( r_{ij} - {\\bf u}_i^T {\\bf m}_j \\right)^2 = \\| R - UM \\|^2$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Regularized ALS\n", + "\n", + "In this notebook, we'll implement ALS algorithm with _weighted-$\\lambda$-regularization_ formulated by [Zhou _et_. _al_](https://liuxiaofei.com.cn/blog/wp-content/uploads/2014/01/netflix_aaim08submitted.pdf). The cost function with such regularization is:\n", + "\n", + "$$f(U, M) = \\sum_{i,j} I_{ij}\\left( r_{ij} - {\\bf u}_i^T {\\bf m}_j \\right)^2 + \\lambda \\left( \\sum_i n_{u_i} \\| {\\bf u}\\|_i^2 + \\sum_j n_{m_j} \\|{\\bf m}\\|_j^2 \\right)$$\n", + "\n", + "\n", + "Here, $\\lambda$ is the usual regularization parameter. $n_{u_i}$ and $n_{m_j}$ represent the number of ratings of user $i$ and movie $j$ respectively. $I_{ij}$ is an indicator variable such that $I_{ij} = 1$ if $r_{ij}$ exists and $I_{ij} = 0$ otherwise." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we fix ${\\bf m}_j$, we can determine ${\\bf u}_i$ by solving a regularized least squares problem:\n", + "\n", + "$$ \\frac{1}{2} \\frac{\\partial f}{\\partial {\\bf u}_i} = 0$$\n", + "\n", + "This gives the following matrix equation:\n", + "\n", + "$$\\left(M \\text{diag}({\\bf I}_i^T) M^{T} + \\lambda n_{u_i} E\\right) {\\bf u}_i = M {\\bf r}_i^T$$\n", + "\n", + "Here ${\\bf r}_i^T$ is the $i$th row of $R$. Similarly, ${\\bf I}_i$ the $i$th row of the matrix $I = [I_{ij}]$. Please see [Zhou _et_. _al_](https://liuxiaofei.com.cn/blog/wp-content/uploads/2014/01/netflix_aaim08submitted.pdf) for details." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Reading Netflix Movie Ratings Data\n", + "\n", + "In this example, we'll use Netflix movie ratings. This data set can be downloaded from [here](http://academictorrents.com/details/9b13183dc4d60676b773c9e2cd6de5e5542cee9a). We'll use spark to read movie ratings data into a dataframe. The csv files have four columns: MovieID, UserID, Rating, Date." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from pyspark.sql import SparkSession\n", + "from pyspark.sql.types import *\n", + "from systemml import MLContext, dml\n", + "\n", + "spark = SparkSession\\\n", + " .builder\\\n", + " .appName(\"als-example\")\\\n", + " .getOrCreate()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "schema = StructType([StructField(\"movieId\", IntegerType(), True),\n", + " StructField(\"userId\", IntegerType(), True),\n", + " StructField(\"rating\", IntegerType(), True),\n", + " StructField(\"date\", StringType(), True)])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------+-------+------+\n", + "|userId|movieId|rating|\n", + "+------+-------+------+\n", + "| 53679| 5317| 4|\n", + "| 29545| 5317| 3|\n", + "| 41412| 5317| 3|\n", + "| 28213| 5317| 3|\n", + "| 30878| 5317| 3|\n", + "| 56069| 5317| 3|\n", + "| 49479| 5317| 4|\n", + "| 42362| 5317| 2|\n", + "| 43601| 5317| 4|\n", + "| 45276| 5317| 3|\n", + "+------+-------+------+\n", + "only showing top 10 rows\n", + "\n" + ] + } + ], + "source": [ + "ratings = spark.read.csv(\"./netflix/training_set_normalized/mv_0*.txt\", schema = schema)\n", + "ratings = ratings.select('userId', 'movieId', 'rating')\n", + "ratings.show(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------+------------------+------------------+------------------+\n", + "|summary| userId| movieId| rating|\n", + "+-------+------------------+------------------+------------------+\n", + "| count| 2268082| 2268082| 2268082|\n", + "| mean|30028.841485008037| 9068.777048625227|3.6134694424628386|\n", + "| stddev| 17290.49124532639|5131.8304910232055|1.0810520483121464|\n", + "| min| 6| 1| 1|\n", + "| max| 59999| 17770| 5|\n", + "+-------+------------------+------------------+------------------+\n", + "\n" + ] + } + ], + "source": [ + "ratings.describe().show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ALS implementation using DML\n", + "\n", + "The following script implements the regularized ALS algorithm as described above. One thing to note here is that we remove empty rows/columns from the rating matrix before running the algorithm. We'll add back the zero rows and columns to matrices $U$ and $M$ after the algorithm converges." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "#-----------------------------------------------------------------\n", + "# Create kernel in SystemML's DSL using the R-like syntax for ALS\n", + "# Algorithms available at : https://systemml.apache.org/algorithms\n";, + "# Below algorithm based on ALS-CG.dml\n", + "#-----------------------------------------------------------------\n", + "als_dml = \\\n", + "\"\"\"\n", + "# Default values of some parameters\n", + "r = rank\n", + "max_iter = 50\n", + "check = TRUE\n", + "thr = 0.01\n", + "\n", + "R = table(X[,1], X[,2], X[,3])\n", + "\n", + "# check the input matrix R, if some rows or columns contain only zeros remove them from R\n", + "R_nonzero_ind = R != 0;\n", + "row_nonzeros = rowSums(R_nonzero_ind);\n", + "col_nonzeros = t(colSums (R_nonzero_ind));\n", + "orig_nonzero_rows_ind = row_nonzeros != 0;\n", + "orig_nonzero_cols_ind = col_nonzeros != 0;\n", + "num_zero_rows = nrow(R) - sum(orig_nonzero_rows_ind);\n", + "num_zero_cols = ncol(R) - sum(orig_nonzero_cols_ind);\n", + "if (num_zero_rows > 0) {\n", + " print(\"Matrix R contains empty rows! These rows will be removed.\");\n", + " R = removeEmpty(target = R, margin = \"rows\");\n", + "}\n", + "if (num_zero_cols > 0) {\n", + " print (\"Matrix R contains empty columns! These columns will be removed.\");\n", + " R = removeEmpty(target = R, margin = \"cols\");\n", + "}\n", + "if (num_zero_rows > 0 | num_zero_cols > 0) {\n", + " print(\"Recomputing nonzero rows and columns!\");\n", + " R_nonzero_ind = R != 0;\n", + " row_nonzeros = rowSums(R_nonzero_ind);\n", + " col_nonzeros = t(colSums (R_nonzero_ind));\n", + "}\n", + "\n", + "###### MAIN PART ######\n", + "\n", + "m = nrow(R);\n", + "n = ncol(R);\n", + "\n", + "# initializing factor matrices\n", + "U = rand(rows = m, cols = r, min = -0.5, max = 0.5);\n", + "M = rand(rows = n, cols = r, min = -0.5, max = 0.5);\n", + "\n", + "# initializing transformed matrices\n", + "Rt = t(R);\n", + "\n", + "\n", + "loss = matrix(0, rows=max_iter+1, cols=1)\n", + "if (check) {\n", + " loss[1,] = sum(R_nonzero_ind * (R - (U %*% t(M)))^2) + lambda * (sum((U^2) * row_nonzeros) +\n", + " sum((M^2) * col_nonzeros));\n", + " print(\"----- Initial train loss: \" + toString(loss[1,1]) + \" -----\");\n", + "}\n", + "\n", + "lambda_I = diag (matrix (lambda, rows = r, cols = 1));\n", + "it = 0;\n", + "converged = FALSE;\n", + "while ((it < max_iter) & (!converged)) {\n", + " it = it + 1;\n", + " # keep M fixed and update U\n", + " parfor (i in 1:m) {\n", + " M_nonzero_ind = t(R[i,] != 0);\n", + " M_nonzero = removeEmpty(target=M * M_nonzero_ind, margin=\"rows\");\n", + " A1 = (t(M_nonzero) %*% M_nonzero) + (as.scalar(row_nonzeros[i,1]) * lambda_I); # coefficient matrix\n", + " U[i,] = t(solve(A1, t(R[i,] %*% M)));\n", + " }\n", + "\n", + " # keep U fixed and update M\n", + " parfor (j in 1:n) {\n", + " U_nonzero_ind = t(Rt[j,] != 0)\n", + " U_nonzero = removeEmpty(target=U * U_nonzero_ind, margin=\"rows\");\n", + " A2 = (t(U_nonzero) %*% U_nonzero) + (as.scalar(col_nonzeros[j,1]) * lambda_I); # coefficient matrix\n", + " M[j,] = t(solve(A2, t(Rt[j,] %*% U)));\n", + " }\n", + "\n", + " # check for convergence\n", + " if (check) {\n", + " loss_init = as.scalar(loss[it,1])\n", + " loss_cur = sum(R_nonzero_ind * (R - (U %*% t(M)))^2) + lambda * (sum((U^2) * row_nonzeros) +\n", + " sum((M^2) * col_nonzeros));\n", + " loss_dec = (loss_init - loss_cur) / loss_init;\n", + " print(\"Train loss at iteration (M) \" + it + \": \" + loss_cur + \" loss-dec \" + loss_dec);\n", + " if (loss_dec >= 0 & loss_dec < thr | loss_init == 0) {\n", + " print(\"----- ALS converged after \" + it + \" iterations!\");\n", + " converged = TRUE;\n", + " }\n", + " loss[it+1,1] = loss_cur\n", + " }\n", + "} # end of while loop\n", + "\n", + "loss = loss[1:it+1,1]\n", + "if (check) {\n", + " print(\"----- Final train loss: \" + toString(loss[it+1,1]) + \" -----\");\n", + "}\n", + "\n", + "if (!converged) {\n", + " print(\"Max iteration achieved but not converged!\");\n", + "}\n", + "\n", + "# inject 0s in U if original R had empty rows\n", + "if (num_zero_rows > 0) {\n", + " U = removeEmpty(target = diag(orig_nonzero_rows_ind), margin = \"cols\") %*% U;\n", + "}\n", + "# inject 0s in R if original V had empty rows\n", + "if (num_zero_cols > 0) {\n", + " M = removeEmpty(target = diag(orig_nonzero_cols_ind), margin = \"cols\") %*% M;\n", + "}\n", + "M = t(M);\n", + "\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Running the Algorithm\n", + "\n", + "We'll first create an MLContext object which the entry point for SystemML. Inputs and outputs are defined through a dml function." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "ml = MLContext(sc)\n", + "\n", + "# Define input/output variables for DML script\n", + "alsScript = dml(als_dml).input(\"X\", ratings) \\\n", + " .input(\"lambda\", 0.01) \\\n", + " .input(\"rank\", 100) \\\n", + " .output(\"U\", \"M\", \"loss\")\n", + "\n", + "# Execute script\n", + "res = ml.execute(alsScript)\n", + "U, M, loss = res.get('U','M', \"loss\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgUAAAFsCAYAAABcj8oCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAHwVJREFUeJzt3XuQnVWZ7/Hv00MkgqG1xgMJmcxpcbxEnYLpVjQiIhVA\nvCSIcNQWaxCUERFDtVpeChRnRkBAiBlFnSqPI4xjTzljOSYcuYpIAQHKbpEzGmDOIYwIGFBOdTIg\nVrSf88e7Ip2mb+/uy77k+6nahXvttfb7rOq492+v9xaZiSRJUlezC5AkSa3BUCBJkgBDgSRJKgwF\nkiQJMBRIkqTCUCBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJkoAWDwURcXhEbIyIByNiNCLW1hx/bhn3\n+/LfXY8d81WzJEntqqVDAbAvcCdwBtDITRouBpYCy8p/lwI/A741VwVKktQp9mp2AVPJzKuBqwEi\nIsa/HhHPAM4H3gE8G/jfwMcz84dl/BPAE2P6Hwy8BPireS9ekqQ20+orBdO5DHgl8Dbgz4F/Aa6K\niOdP0v+9wD2ZeesC1SdJUtto21AQESuAdwP/IzNvzcytmXkpcAtwygT99wbeCXx1QQuVJKlNtPTu\ng2n8OfBHwL3jdi08A/jVBP3fCjwLuGIBapMkqe20cyh4FvA7oBcYHffaf03Q/z3AlZn56HwXJklS\nO2rnUPBjqpWCAzLzlqk6RkQPcCTw5vkvS5Kk9lTrmIKIOD0ifhIRI+Vxa0QcO0X/I8ZdH2DXNQP2\nn+H29o2IgyPikNJ0UHm+IjP/A/gmcEVEHB8RPRFxaER8PCLeMO6t3gM8RDmTQZIkPV3dlYIHgI8B\n/wEE1YF+342IQzJzyyRjEngh8IcLBmXmIzPc3suBH5T3SOCS0n45cGrZ/jnA54DlVMcS3AZs2vUG\n5XiDk4F/yMxGrnUgSdIeIWb7PRkRvwY+kpn/MMFrR wA3AM/JzO2z2pAkSZpXDZ+SGBFdEfEOYB9g\n81RdgTsj4qGIuDYiXt3oNiVJ0vypfaBhRLyMKgQsptolcHxm3j1J94eB9wE/AvYGTgNujIhDM/PO\nKbbxx8DrgfuBJ+vWKEnSHmwx0ANck5m/rjOw9u6DiNgL+FOgGziR6ov+tVMEg/HjbwT+MzNPnqLP\nO4F/qlWYJEka66TM/GadAbVXCjLzd8B95emPI+JQ4Czg/TN8izuAw6bpcz/AN77xDVauXFm3xJYz\nMDDA+vXrm13GnHE+rauT5gLOp5V10lygs+azZcsW3vWud0H5Lq1jLq5T0EW1a2CmDqHarTCVJwFW\nrlxJb29vo3W1jO7u7o6Yxy7Op3V10lzA+bSyTpoLdN58itq73+tep+D8iDg8Iv57RLwsIi4AjgC+\nUV6/ICIuH9P/rIhYGxHPj4iXRsTnqS4i9MWZbO/Nbz6ddevOZceOHdN3liRJs1L37IP9qa4RcDdw\nPdAHHJOZN5TXlwIrxvR/BtW1Be4CbqS6X8HqzLxxJht7+OEvc9llq1i16gSDgSRJ86zW7oPMfO80\nr58y7vnFwMUN1FUEo6PHsmVLcs45l7Bhw6cbfytJkjSltrh18ujosWzcOOXtDVpaf39/s0uYU86n\ndXXSXMD5tLJOmgt03nwaNesrGs6HiOgFhmCI6iaIsHz5cTzwwL+x+12SJUnSWMPDw/T19QH0ZeZw\nnbFtsVIAyaJFjxsIJEmaR20RCrq6rmbt2tc0uwxJkjraXFynYB4lXV1XsXLlej7zmW83uxhJkjpa\nS68ULFt2BmeeeTubN3+bJUuWNLscSZI6WkuvFFx55Zc78QpTkiS1pJZeKZAkSQvHUCBJkgBDgSRJ\nKgwFkiQJMBRIkqTCUCBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJ\nkgBDgSRJKgwFkiQJMBRIkqTC UCBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJkgBDgSRJKgwFkiQJMBRI\nkqTCUCBJkoCaoSAiTo+In0TESHncGhHHTjPmdRExFBFPRsS9EXHy7EqWJEnzoe5KwQPAx4BeoA+4\nAfhuRKycqHNE9ABXAt8HDgY2AF+NiKMbrFeSJM2Tvep0zsz/Na7pnIh4P/AqYMsEQ94P3JeZHy3P\n74mI1wADwHV1i5UkSfOn4WMKIqIrIt4B7ANsnqTbq4Drx7VdA6xqdLuSJGl+1FopAIiIl1GFgMXA\nDuD4zLx7ku5LgW3j2rYB+0XE3pn527rblyRJ86ORlYK7qY4POBT4MnBFRLx4TquSJEkLrvZKQWb+\nDrivPP1xRBwKnEV1/MB4vwQOGNd2ALB9JqsEAwMDdHd379bW399Pf39/3bIlSeo4g4ODDA4O7tY2\nMjLS8PtFZs6qoIj4PvCfmXnqBK99FnhDZh48pu2bwLMz841TvGcvMDQ0NERvb++s6pMkaU8yPDxM\nX18fQF9mDtcZW2ulICLOB64Cfg4sAU4CjgCOKa9fAByYmbuuRfAV4AMRcSHwNWA1cCIwaSCQJEnN\nUXf3wf7A5cAyYAS4CzgmM28ory8FVuzqnJn3R8SbgPXAOuAXwHsyc/wZCZIkqcnqXqfgvdO8fsoE\nbTdRXehIkiS1MO99IEmSAEOBJEkqDAWSJAkwFEiSpMJQIEmSAEOBJEkqDAWSJAkwFEiSpMJQIEmS\nAEOBJEkqDAWSJAkwFEiSpMJQIEmSAEOBJEkqDAWSJAkwFEiSpMJQIEmSAEOBJEkqDAWSJAkwFEiS\npMJQIEmSAEOBJEkqDAWSJAkwFEiSpMJQIEmSAEOBJEkqDAWSJAkwFEiSpMJQIEmSAEOBJEkqDAWS\nJAkwFEiSpMJQIEmSAEOBJEkqaoWCiPhERNwREdsjYltEfCciXjjNmCMiYnTc4/cRsf/sSpckSXOp\n7krB4cA XgFcCRwGLgGsj4pnTjEvgBcDS8liWmY/U3LYkSZpHe9XpnJlvHPs8It4NPAL0ATdPM/zR\nzNxeqzpJkrRgZntMwbOpVgEem6ZfAHdGxEMRcW1EvHqW25UkSXOs4VAQEQF8Hrg5M382RdeHgfcB\nJwBvBR4AboyIQxrdtiRJmnu1dh+M8yXgJcBhU3XKzHuBe8c03RYRzwcGgJOnGjswMEB3d/dubf39\n/fT39zdUsCRJnWRwcJDBwcHd2kZGRhp+v8jM+oMivgisAQ7PzJ83MP4i4LDMnDBQREQvMDQ0NERv\nb2/t+iRJ2lMNDw/T19cH0JeZw3XG1l4pKIHgOOCIRgJBcQjVbgVJktQiaoWCiPgS0A+sBR6PiAPK\nSyOZ+WTpcz6wPDNPLs/PArYCPwUWA6cBRwJHz8kMJEnSnKi7UnA61dkGN45rPwW4ovzvZcCKMa89\nA7gEOBB4ArgLWJ2ZN9UtVpIkzZ+61ymY9myFzDxl3POLgYtr1iVJkhaY9z6QJEmAoUCSJBWGAkmS\nBBgKJElSYSiQJEmAoUCSJBWGAkmSBBgKJElSYSiQJEmAoUCSJBWGAkmSBBgKJElSYSiQJEmAoUCS\nJBWGAkmSBBgKJElSYSiQJEmAoUCSJBWGAkmSBBgKJElSYSiQJEmAoUCSJBWGAkmSBBgKJElSYSiQ\nJEmAoUCSJBWGAkmSBBgKJElSYSiQJEmAoUCSJBWGAkmSBBgKJElSYSiQJElAzVAQEZ+IiDsiYntE\nbIuI70TEC2cw7nURMRQRT0bEvRFxcuMlS5Kk+VB3peBw4AvAK4GjgEXAtRHxzMkGREQPcCXwfeBg\nYAPw1Yg4uoF6JUnSPNmrTufMfOPY5xHxbuARoA+4eZJh7wfuy8yPluf3RMRrgAHgulrVSpKkeTPb\nYwqeDSTw2BR9XgVcP67tGmDVLLctSZLmUMOhICIC+Dxwc2b+bIquS4Ft49q2AftFxN6N bl+SJM2t\nWrsPxvkS8BLgsDmq5WkGBgbo7u7era2/v5/+/v752qQkSW1jcHCQwcHB3dpGRkYafr/IzPqDIr4I\nrAEOz8yfT9P3h8BQZn5oTNu7gfWZ+ZxJxvQCQ0NDQ/T29tauT5KkPdXw8DB9fX0AfZk5XGds7d0H\nJRAcBxw5XSAoNgOrx7UdU9olSVKLqHudgi8BJwHvBB6PiAPKY/GYPudHxOVjhn0FOCgiLoyIF0XE\nGcCJwKVzUL8kSZojdVcKTgf2A24EHhrzeNuYPsuAFbueZOb9wJuormtwJ9WpiO/JzPFnJEiSpCaq\ne52CaUNEZp4yQdtNVNcykCRJLcp7H0iSJMBQIEmSCkOBJEkCDAWSJKkwFEiSJMBQIEmSCkOBJEkC\nDAWSJKkwFEiSJMBQIEmSCkOBJEkCDAWSJKkwFEiSJMBQIEmSCkOBJEkCDAWSJKkwFEiSJMBQIEmS\nCkOBJEkCDAWSJKkwFEiSJMBQIEmSCkOBJEkCDAWSJKkwFEiSJMBQIEmSCkOBJEkCDAWSJKkwFEiS\nJMBQIEmSCkOBJEkCDAWSJKkwFEiSJKCBUBARh0fExoh4MCJGI2LtNP2PKP3GPn4fEfs3XrYkSZpr\njawU7AvcCZwB5AzHJPACYGl5LMvMRxrYtiRJmid71R2QmVcDVwNERNQY+mhmbq+7PUmStDAW6piC\nAO6MiIci4tqIePUCbVeSJM3QQoSCh4H3AScAbwUeAG6MiEMWYNuSJGmGau8+qCsz7wXuHdN0W0Q8\nHxgATp7v7UuSpJmZ91AwiTuAw6brNDAwQHd3925t/f399Pf3z1ddkiS1jcHBQQYHB3drGxkZafj9\nInOmJxBMMDhiFHhLZm6sOe5aYHtmnjjJ673A0NDQEL29vQ3XJ0nSnmZ4eJi+vj6AvswcrjO29kpB\nROwL/BnVwYMAB0XEwcBjmflARFwAHJiZJ5f+ZwFbgZ8Ci4HTgCO Bo+tuW5IkzZ9Gdh+8HPgB1bUH\nEriktF8OnEp1HYIVY/o/o/Q5EHgCuAtYnZk3NVizJEmaB41cp+CHTHHWQmaeMu75xcDF9UuTJEkL\nyXsfSJIkwFAgSZIKQ4EkSQIMBZIkqTAUSJIkwFAgSZIKQ4EkSQIMBZIkqTAUSJIkwFAgSZIKQ4Ek\nSQIMBZIkqTAUSJIkwFAgSZIKQ4EkSQIMBZIkqTAUSJIkwFAgSZIKQ4EkSQIMBZIkqTAUSJIkwFAg\nSZIKQ4EkSQIMBZIkqTAUSJIkwFAgSZIKQ4EkSQIMBZIkqTAUSJIkwFAgSZIKQ4EkSQIMBZIkqTAU\nSJIkwFAgSZKK2qEgIg6PiI0R8WBEjEbE2hmMeV1EDEXEkxFxb0Sc3Fi5kiRpvjSyUrAvcCdwBpDT\ndY6IHuBK4PvAwcAG4KsRcXQD25YkSfNkr7oDMvNq4GqAiIgZDHk/cF9mfrQ8vyciXgMMANfV3b4k\nSZofC3FMwauA68e1XQOsWoBtS5KkGVqIULAU2DaubRuwX0TsvQDblyRJM1B798FCGhgYoLu7e7e2\n/v5++vv7m1SRJEmtY3BwkMHBwd3aRkZGGn6/hQgFvwQOGNd2ALA9M3871cD169fT29s7b4VJktTO\nJvqhPDw8TF9fX0PvtxC7DzYDq8e1HVPaJUlSi2jkOgX7RsTBEXFIaTqoPF9RXr8gIi4fM+Qrpc+F\nEfGiiDgDOBG4dNbVS5KkOdPISsHLgR8DQ1TXKbgEGAb+ury+FFixq3Nm3g+8CTiK6voGA8B7MnP8\nGQmSJKmJGrlOwQ+ZIkxk5ikTtN0ENLaDQ5IkLQjvfSBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJkgBD\ngSRJKgwFkiQJMBRIkqTCUCBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJkgBDgSRJKgwFkiQJMBRIkqTC\nUCBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJkg BDgSRJKgwFkiQJMBRIkqTCUCBJkgBDgSRJKgwFkiQJ\nMBRIkqTCUCBJkgBDgSRJKgwFkiQJMBRIkqTCUCBJkoAGQ0FEfCAitkbEbyLitoh4xRR9j4iI0XGP\n30fE/o2XLUmS5lrtUBARbwcuAc4F/gL4CXBNRDx3imEJvABYWh7LMvOR+uVKkqT50shKwQDw95l5\nRWbeDZwOPAGcOs24RzPzkV2PBrYrSZLmUa1QEBGLgD7g+7vaMjOB64FVUw0F7oyIhyLi2oh4dSPF\nSpKk+VN3peC5wB8B28a1b6PaLTCRh4H3AScAbwUeAG6MiENqbluSJM2jveZ7A5l5L3DvmKbbIuL5\nVLshTp5q7MDAAN3d3bu19ff309/fP+d1SpLUbgYHBxkcHNytbWRkpOH3i2r1f4adq90HTwAnZObG\nMe1fB7oz8/gZvs9FwGGZedgkr/cCQ0NDQ/T29s64PkmS9nTDw8P09fUB9GXmcJ2xtXYfZOZOYAhY\nvastIqI8v7XGWx1CtVtBkiS1iEZ2H1wKfD0ihoA7qHYD7AN8HSAiLgAOzMyTy/OzgK3AT4HFwGnA\nkcDRsy2+XWQmVXaSJKl11Q4Fmfmtck2CvwEOAO4EXp+Zj5YuS4EVY4Y8g+q6BgdS7Xq4C1idmTfN\npvBWt2PHDs4++3Ns2nQLO3fuy6JFj7NmzWGcd95HWLJkSbPLkyTpaWodU7BQ2v2Ygh07drBq1Qls\n2fIhRkdfT3VGZtLVdQ0rV17K5s3fNhhIkubFgh1ToJk5++zPlUBwLFUgAAhGR49ly5YBzjnnkmaW\nJ0nShAwF82DTplvKCsHTjY4ey8aNtyxwRZIkTc9QMMcyk5079+WpFYLxgp0796EVd9tIkvZshoI5\nFhEsWvQ41T2gJpIsWvS4ZyNIklqOoWAerFlzGF1d10z4WlfX1axd+5oFrkiSpOkZCubBeed9hJUr\nL6Wr6yqeWjFIurquY uXK9XzmMx9uZnmSJE3IUDAPlixZwubN3+bMM2+np+cYli8/jp6eYzjzzNs9\nHVGS1LLm/YZIe6olS5awYcOn2bDBKxpKktqDKwULwEAgSWoHhgJJkgQYCiRJUmEokCRJgKFAkiQV\nhgJJkgQYCiRJUmEokCRJgKFAkiQVhgJJkgQYCiRJUmEokCRJgKFAkiQVhgJJkgQYCtSAzGx2CZKk\neWAo0Izs2LGDdevO5XnPO4oVK97C8553FOvWncuOHTuaXdqsGXIkqbJXswtQ69uxYwerVp3Ali0f\nYnT000AAyWWXXcMNN5zA5s3fZsmSJU2usp4dO3Zw9tmfY9OmW9i5c18WLXqcNWsO47zzPtJ2cxkr\nM4mIZpcxZzptPlKrc6VA0zr77M+VQHAsVSAACEZHj2XLlgHOOeeSZpZX266Qc9llq7j//ut48MHv\ncv/913HZZatYteqEtlv96LRVnE6bz1idtCrVSXOBzptPwzKz5R5AL5BDQ0Op5uvpWZ0wmpATPEaz\np+eoZpdYywc/+Kns6rpqwvl0dX0v1607t9klztj27dvzpS89usxn9A9/k66uq/KlLz06t2/f3uwS\na+m0+WRWc/rgBz+VPT2rc/nytdnTszo/+MFPOZcW0KnzWbbsFQkk0Jt1v3/rDliIh6GgdYyOjuby\n5WsnCQTVY/nytTk6OtrsUmesk0JOJwWczM6bTyeFnE6aS2anz+dHDYcCdx9oShHBokWPU/37mkiy\naNHjbbPfNzPZuXNfntoNMl6wc+c+u8Jpy9u06RZGR18/4Wujo8eyceMtC1zR7HTafDpp11snzQX2\nlPnUZyjQtNasOYyurmsmfK2r62rWrn3NAlfUuE4KOZ0WcDptPtBZIaeT5gJ71nzqMBRoWued9xFW\nrryUrq6reOrLNOnquoqVK9fzmc98uJnl1dYpIaeTAg503nw6KeR00lxgT5zPzBkKNK0lS5awefO3\n OfPM2+npOYbly4+jp+cYzjzz9rY8HbGTQk6nBJxdOmk+nRRyOmkusCfOZ+YMBQtgcHCw2SXM2pIl\nS9iw4dNs3XodF130drZuvY4NGz7ddoEAnh5ynvOcvrYNOU8POIO0a8CBzpvP00POU58F7RZyOmku\nsCfMp0F1j0wsyykfALYCvwFuA14xTf/XAUPAk8C9wMnT9O+osw/WrFnT7BLmlPNpLdu3b891687N\nnp6jcvHiA7Kn56hct+7ctjt6epdOms9TR4R/rxzhvqYc4f69tjvCvZPmktnp82n87INGAsHby5f7\nXwIvBv4eeAx47iT9e4D/Ai4CXlQCxU7g6Cm2YShoYc6ndXXSXDI7Yz6dFnI6ZS6ZnTufZcsOXdBQ\ncBuwYczzAH4BfHSS/hcCd41rGwS+N8U2DAUtzPm0rk6aS6bzaWWdNJfMzprP0NDQwlynICIWAX3A\n98fsfkjgemDVJMNeVV4f65op+kuSpCaoe0Ok5wJ/BGwb176NatfARJZO0n+/iNg7M387wZjFAFu2\nbKlZXmsaGRlheHi42WXMGefTujppLuB8WlknzQU6az5jvjsX1x0bWeM8zIhYBjwIrMrM28e0Xwi8\nNjOf9us/Iu4BvpaZF45pewNwJbDPRKEgIt4J/FOdiUiSpN2clJnfrDOg7krBr4DfAweMaz8A+OUk\nY345Sf/tk6wSQLV74STgfqqDGiVJ0swspjrIv/Y5irVCQWbujIghYDWwESCqqzusBv5ukmGbgTeM\nazumtE+2nV8DtdKNJEn6g1sbGdTIxYsuBU6LiL+MiBcDXwH2Ab4OEBEXRMTlY/p/BTgoIi6MiBdF\nxBnAieV9JElSi6i7+4DM/FZEPBf4G6rdAHcCr8/MR0uXpcCKMf3vj4g3AeuBdVSnL74nM8efkSBJ\nkpqo1oGGkiSpc3nvA0mSBBgKJElS0XKhICI+EBFbI+I3EXFbRLyi2TU1IiIOj 4iNEfFgRIxGxNpm\n1zQbEfGJiLgjIrZHxLaI+E5EvLDZdTUiIk6PiJ9ExEh53BoRxza7rrkSER8v/+ba8mDeiDi31D/2\n8bNm19WoiDgwIv4xIn4VEU+Uf3u9za6rEeWzefzfZjQivtDs2hoREV0R8bcRcV/52/yfiDin2XU1\nKiKeFRGfj4j7y3xujoiX13mPlgoFEfF24BLgXOAvgJ8A15QDG9vNvlQHYZ7BXNzkuvkOB74AvBI4\nClgEXBsRz2xqVY15APgY1T02+oAbgO9GxMqmVjUHSoj+K6r/77Szf6c6kHlpebTXfWyLiHg2cAvw\nW+D1wErgw8D/a2Zds/BynvqbLAWOpvp8+1Yzi5qFjwPvo/qcfjHwUeCjEXFmU6tq3P+kukTAScDL\ngOuA68uFB2ekpQ40jIjbgNsz86zyPKg+wP8uMy9qanGzEBGjwFsyc2Oza5krJag9QnUly5ubXc9s\nRcSvgY9k5j80u5ZGRcSzqG5R/n7gk8CPM/NDza2qvog4FzguM9vy1/RYEfFZqivAHtHsWuZDRHwe\neGNmtuuq4Sbgl5l52pi2fwWeyMy/bF5l9UXEYmAHsCYzrx7T/iOqGxB+aibv0zIrBQ3ebEnN82yq\nXwiPNbuQ2SjLh++gutbGpBfUahOXAZsy84ZmFzIHXlB2vf3fiPhGRKyYfkhLWgP8KCK+VXa7DUfE\ne5td1Fwon9knUf06bVe3Aqsj4gUAEXEwcBjwvaZW1Zi9qO5NNP5Kwb+hxkpb7esUzKNGbrakJigr\nOJ8Hbs7MttzXGxEvowoBu9L18Zl5d3OralwJNodQLe+2u9uAdwP3AMuATwM3RcTLMvPxJtbViIOo\nVm4uAc4DDgX+LiJ+m5n/2NTKZu94oBu4fLqOLeyzwH7A3RHxe6ofymdn5j83t6z6MvO/ImIz8MmI\nuJvqu/OdVD+q/2Om79NKoUDt40vAS6gSdbu6GziY6kPt ROCKiHhtOwaDiPgTqpB2VGbubHY9s5WZ\nY6/X/u8RcQfwn8DbgHbbvdMF3JGZnyzPf1IC6elAu4eCU4GrMnOy+960g7dTfXG+A/gZVbDeEBEP\ntWloexfwNaobF/4OGKa6ZUDfTN+glUJBIzdb0gKLiC8CbwQOz8yHm11PozLzd8B95emPI+JQ4Cyq\nX3Xtpg/4b8BwWcWBatXtteWAqb2zlQ4eqikzRyLiXuDPml1LAx4Gxt8Dfgvw1ibUMmci4k+pDjh+\nS7NrmaWLgAsy81/K859GRA/wCdowtGXmVuDIcgD4fpm5LSL+mac+66bVMscUlF84u262BOx2s6WG\nbuyguVUCwXHAkZn582bXM8e6gL2bXUSDrgf+nOpXzsHl8SPgG8DB7RwI4A8HUP4Z1Rdsu7mFp+/+\nfBHVykc7O5Vqebod972PtQ/Vj9GxRmmh78ZGZOZvSiB4DtVZL/8207GttFIA1U2Svh7VnRjvAAYY\nc7OldhIR+1J9kO365XZQOYjlscx8oHmVNSYivgT0A2uBxyNi14rOSGa21e2tI+J84Crg58ASqoOl\njqC6e2fbKfvZdzu2IyIeB36dmeN/pba8iLgY2ET1xbkc+GtgJzDYzLoatB64JSI+QXXa3iuB9wKn\nTTmqhZUfa+8Gvp6Zo00uZ7Y2AedExC+An1KdpjwAfLWpVTUoIo6h+s65B3gB1UrIz6jxHdpSoWAG\nN1tqJy8HfkB1hH5SHWgE1UE5pzarqFk4nWoeN45rPwW4YsGrmZ39qf4Oy4AR4C7gmA45an+Xdl4d\n+BOq/aB/DDwK3Ay8qtxSva1k5o8i4niqA9o+CWwFzmrHA9nGOIrqpnftdnzHRM4E/pbqzJ39gYeA\nL5e2dtQNXEAVph8D/hU4JzPHr4ZMqqWuUyBJkpqnrfebSJKkuWMokCRJgKFAkiQVhgJJkgQYCiRJ\nUmEokCRJgKFAkiQVhgJJkgQYCiR JUmEokCRJgKFAkiQV/x9tCk7io5hOrQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x7f75adcc9908>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "plt.plot(loss.toNumPy(), 'o');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Predictions\n", + "\n", + "\n", + "Once $U$ and $M$ are learned from the data, we can recommend movies for any users. If $U'$ represent the users for which we seek recommendations, we first obtain the predicted ratings for all the movies by users in $U'$:\n", + "\n", + "$$R' = U' M$$\n", + "\n", + "Finally, we sort the ratings for each user and present the top 5 movies with highest predicted ratings. The following dml script implements this. Since we're using very low rank in this example, these recommendations are not meaningful." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "predict_dml = \\\n", + "\"\"\"\n", + "R = table(R[,1], R[,2], R[,3])\n", + "K = 5\n", + "Rrows = nrow(R);\n", + "Rcols = ncol(R);\n", + "\n", + "zero_cols_ind = (colSums(M != 0)) == 0;\n", + "K = min(Rcols - sum(zero_cols_ind), K);\n", + "\n", + "n = nrow(X);\n", + "\n", + "Urows = nrow(U);\n", + "Mcols = ncol(M);\n", + "\n", + "X_user_max = max(X[,1]);\n", + "\n", + "if (X_user_max > Rrows) {\n", + "\tstop(\"Predictions cannot be provided. Maximum user-id exceeds the number of rows of R.\");\n", + "}\n", + "if (Urows != Rrows | Mcols != Rcols) {\n", + "\tstop(\"Number of rows of U (columns of M) does not match the number of rows (column) of R.\");\n", + "}\n", + "\n", + "# creats projection matrix to select users\n", + "s = seq(1, n);\n", + "ones = matrix(1, rows = n, cols = 1);\n", + "P = table(s, X[,1], ones, n, Urows);\n", + "\n", + "\n", + "# selects users from factor U\n", + "U_prime = P %*% U;\n", + "\n", + "# calculate rating matrix for selected users\n", + "R_prime = U_prime %*% M;\n", + "\n", + "# selects users from original R\n", + "R_users = P %*% R;\n", + "\n", + "# create indictor matrix to remove existing ratings for given users\n", + "I = R_users == 0;\n", + "\n", + "# removes already recommended items and creating user2item matrix\n", + "R_prime = R_prime * I;\n", + "\n", + "# stores sorted movies for selected users \n", + "R_top_indices = matrix(0, rows = nrow (R_prime), cols = K);\n", + "R_top_values = matrix(0, rows = nrow (R_prime), cols = K);\n", + "\n", + "# a large number to mask the max ratings\n", + "range = max(R_prime) - min(R_prime) + 1;\n", + "\n", + "# uses rowIndexMax/rowMaxs to update kth ratings\n", + "for (i in 1:K){\n", + "\trowIndexMax = rowIndexMax(R_prime);\n", + "\trowMaxs = rowMaxs(R_prime);\n", + "\tR_top_indices[,i] = rowIndexMax;\n", + "\tR_top_values[,i] = rowMaxs;\n", + "\tR_prime = R_prime - range * table(seq (1, nrow(R_prime), 1), rowIndexMax, nrow(R_prime), ncol(R_prime));\n", + "}\n", + "\n", + "R_top_indices = R_top_indices * (R_top_values > 0);\n", + "\n", + "# cbind users as a first column\n", + "R_top_indices = cbind(X[,1], R_top_indices);\n", + "R_top_values = cbind(X[,1], R_top_values);\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# user for which we want to recommend movies\n", + "ids = [116,126,130,131,133,142,149,158,164,168,169,177,178,183,188,189,192,195,199,201,215,231,242,247,248,\n", + " 250,261,265,266,267,268,283,291,296,298,299,301,302,304,305,307,308,310,312,314,330,331,333,352,358,363,\n", + " 368,369,379,383,384,385,392,413,416,424,437,439,440,442,453,462,466,470,471,477,478,479,481,485,490,491]\n", + "\n", + "users = spark.createDataFrame([[i] for i in ids])\n", + "\n", + "predScript = dml(predict_dml).input(\"R\", ratings) \\\n", + " .input(\"X\", users) \\\n", + " .input(\"U\", U) \\\n", + " .input(\"M\", M) \\\n", + " .output(\"R_top_indices\")\n", + "\n", + "pred = ml.execute(predScript).get(\"R_top_indices\")\n", + "\n", + "pred = pred.toNumPy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Just for Fun!\n", + "\n", + "Once we have the movie recommendations, we can show the movie posters for those recommendations. We'll fetch these movie poster from wikipedia. If movie page doesn't exist on wikipedia, we'll just list the movie title." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "titles = pd.read_csv(\"./netflix/movie_titles.csv\", header=None, sep=';', names=['movieID', 'year', 'title'])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import re\n", + "import wikipedia as wiki\n", + "from bs4 import BeautifulSoup as bs\n", + "import requests as rq\n", + "from IPython.core.display import Image, display" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def get_poster(title):\n", + " if title.endswith('Bonus Material'):\n", + " title = title.strip('Bonus Material')\n", + " \n", + " title = re.sub(r'[^\\w\\s]','',title)\n", + " matches = wiki.search(title)\n", + " if matches is None:\n", + " return\n", + " film = [s for s in matches if 'film)' in s]\n", + " film = film[0] if len(film) > 0 else matches[0]\n", + "\n", + " try:\n", + " url = wiki.page(film).url\n", + " except:\n", + " return\n", + "\n", + " html = rq.get(url)\n", + " if html.status_code == 200:\n", + " soup = bs(html.content, 'html.parser')\n", + " infobox = soup.find('table', class_=\"infobox\")\n", + " if (infobox):\n", + " img = infobox.find('img')\n", + " if img:\n", + " display(Image('http:' + img['src']))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def show_recommendations(userId, preds):\n", + " for row in preds:\n", + " if int(row[0]) == userId:\n", + " print(\"\\nrecommendations for userId\", int(row[0]) )\n", + " for title in titles.title[row[1:]].values:\n", + " print(title)\n", + " get_poster(title)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "recommendations for userId 192\n", + "Vampire in Brooklyn\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAZABkAAD//gBJRmlsZSBzb3VyY2U6IGh0dHBzOi8vZW4ud2lraXBlZGlh\nLm9yZy93aWtpL0ZpbGU6VmFtcGlyZV9pbl9icm9va2x5bi5qcGf/2wBDAAYEBQYFBAYGBQYHBwYI\nChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcH\nBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo\nKCgoKCj/wAARCAFHANwDASIAAhEBAxEB/8QAHQAAAQQDAQEAAAAAAAAAAAAABQMEBgcAAQIICf/E\nAEcQAAIBAgQEBAQDBQUFBwUBAAECAwQRAAUSIQYTMUEHIlFhFDJxgSORoRUzQrHBCCRS0fAWJWJy\ngjdDRFOSsuEXVGNkdML/xAAbAQABBQEBAAAAAAAAAAAAAAACAAEDBAUGB//EADQRAAEEAQIDBQgB\nBAMBAAAAAAEAAgMRIQQxEhNBBVFhcaEigZGxwdHh8DIVI0LxFCQzUv/aAAwDAQACEQMRAD8A84nq\nfrjWNt8x+uNYZJZ6+2MwZ4MyunzzjLIcorJJo6fMK6GlkeFgHUO1rqSCL7+hwTn4Pqq+vzOPI8vr\nqMZesSy0GcTIlbznjeQoi6V1krG7AWBsLbm2EkonjYJB64k0HA2dzjKDAlFIuZ6BEy1SkRM8RlRZ\nf/LLICwB62PocDcyyOpy7L8tq6qeitXwieOGKcPMiEEqXQfLcA2wkkygkAdWJPWxwXg1tTNIvydO\nuJnwV4Z0fEWXcJ17VtalNWz1UGbhCl6cqX+H5dxcCUoUu1/Ne2AWS5DmklBl0BFEP2ktPyGeoAH4\n5l0ajby/uJL+m3rhJIQ4ubXJBwhIhHQ9sSdeE82h p8yqZ0o9OXbyRiqQySKIRPzIh/3icoiS4/h3\ntjuq4NzZKuenUUTzRmpUpHVBiWgaMSqABuRzVNh1AY9sMkoW6m+EWQnBGqgMNTNEWjdopGjLRtqU\nlSRdT3BsbHvhsy4a0SaaThxSUslRMkUKF5HNlUHc46SO56YlGXZC8VBRZhm9If2NVBql5CxRmhiY\njQvoJH0rqBvYbd8RyShgtSxR8ZUfzaCGjeEUk6VkbwqzzKjCItfzBdW7WJAvYAlTYEb4YJUSxSpJ\nHZHQllkUC973vfpf09LYWzTMpswaEycsJDqEQjjCBFJ1aR3tck7364Zex3wTGmsoXv8Aa9lLSyyT\nvqlkZ3ta5NrfT8zhdS7MxJ1E9SwuThvrZyLm98OofvcdLeuDpBaWjHZiVHcYcI4O51KyjysGNwex\nxuIOwZNKsQbajub/AFwnUKUksOh3FjhqSukeomE9KqwxxrVPqd4jIRzgoGkxCx/EJuNF/NtYXwDr\nGszSJfzX09trkb+/tjVTmMsYT4d2QoVuyNpa6kEEN2YEXB7HBbMFXOKFc5Rakz1E0grCQrRiTbS9\n1HkaTzMVOxa5U72EJbwO8CrDXcYrqotNJIdmYn74b4JVNGwQsvmA62wNYWJHpiYKu7BWsZ98ZjMO\nhWffG741jBhJLZ+Y/XGYw/MfqcYMJJSDgOpOVcVZdn81PUzZfkdVBmFaYFVmSISqosGIBJZlXr3w\na4V4pyDhusqqiGozrMJYamkzCkaphjRpp4IahNMv4jctNUy9C50qRtcYM+EmVLXZDnOXszmp4mSq\nyyjhMGpJXp6YzAF9Q0ESvCQbG9rbbnBbJYclrqDgw5lHRRVEE+X0tTDLGix1N6SaWkkc7XBkcxvc\n2IRb4SSCZRxzkVCvD7cvMHMRomrGKRixpaWaBVhGvz3admJOmwAFib4j3EGeUea5JwxT081W8mW0\nK0jwzQIsaG5LNG4Ys+o22IF rHEtzejzek4T43asXMKnNpafKZq146KKMw8ykmeVJlt5VUBQSArFg\npO5w+zDhV6jjPxKSuo1geshnhyuOaHSXlKmoRorDSLrSkA+UWYi+9ikqQ3wwzOqm4i4Up8siraim\nyyJ6vNaVHhhWQRTzSIytJIqtp+JHzFTcnY2GG+X59T5XPwxBX0uZU+ZZNUU0ddCYVPL+EkqLaLt5\nmJnAKsAF0Hdr4b+DkHxee5woy2XNUfIK0/AxsytUAhDywy+YE+2/bviYcR5bAx45qYWgzbMjnwzG\nnDqQ1RTxTxxSqGA06NdSUNiLlLgEC4a09IDnPExrclzqCheopanOalZp9apbSaURyxKwJKpzL2C2\n/DspsNsEM249pKrjLJs3FVXGKhqsxZDpjWRYp4wsaLZtyDfVc/c4N53T1bx8UllqIleajrDNNSxo\nyi6f7vmAHkkTUCrL82g3+bCfFtVmdLnfiLF/e4YfhVaNKqCENoNZHECtl2Qo0gUjfSfXcCSnDVTM\nCIKdI0dHKKFJVgdwLf0xwyeuJnx9WVlc3D3xsmsjJaWUfhonmcHUfKBcnSvXpbEQcWNsJFS3DHqI\nVbamIAJ2G/riR+JJbLFmyM1UdYsJp+VPTzyPEIQrHksjeVWDNr23ANsNeDKVqviXKYYzGJJKlERp\nNlDk2Ut7XtfAriwGr4xrqOCskrolq2hSVr+drjWwv2LBvsBiqfanAOwF+oVr+MONzhD6XJc0rKV6\nmly+eaBRdnRb2/zwgaGpU2eCRfTUpFz6YvvKItEEKRgIiKFW3pbBuOkimKo8SMLgm63ue2Mx/bZY\n4gsx5rU/ojC2w/PkvPFHl6yxQqEk50g1EnYAXtt/rviV/sM0+gCASpcSBl66b3CgfffFv1fBtPVO\nj0lOikwkbDZTqBtbEpynhmmo4zzo1k0gIikdAAP64jf20HAFgQjs5jMOKoKk4SzGrqZEip5I4ixI\n1bAL99 /88J53wNnVNC0yUokSMHdCDt7Drj0ZUUsYTWsaqw6EDAmvDJ50H26HEbe2pbGBSf8ApsTh\nubXk2WKRHZHRlZTZlI6YKcIZs+UZty2ZTQ1yNRVcT/K8cgKgkeqsQwPUEbYN+KlF8HxA1RGjLHUr\nqv0GobEfbEMpn5ctPOV1hJlNr2uQQQL9sdEx4niDh1CxZIzDIWnojNWQjFZEaOQHSw6MGGxBH1vg\nXmHLEa6ANze9rfbBbP0lOY1LzJJG7tzNDrpZb72IuemAs6+QnrbvgozYBSmFOITU41jO+NHEigW7\n42OmOcbwklsjc/XHSqWOMjsXNz3+tsPFRE+ZrAd8K6TgJFKdX+ZL3+uHa0YsbgaTsb7g4lPA/C1V\nxJI7Q/gU0Zs8zjb7epxePC3AnDuVFWOXR19UoF5q0cz8lPlH5YzNX2pFp3cBye5XodE+RvH0XmuG\nkWZvw0aTe50gtf62/rhzyIyOUui/YXN/y649q5fmEkCLDTRQQQqPlhjCAfliE+KmaT5q6cP8P5LQ\nZnnBUS1NTV0ySR0sfYb/AMR/QYqs7X4z/H1/CM6Mg0vL/wAGDYMgb1F+mHtLRAPcRgINrdLfbFlZ\nn4eVMlI8tDTwrmMP7yjgdmSYW3MQbcN/wEm/b0xFKWineY08NPUSTatBiSFi1/Qra4OLkWujlFtK\nZ+kcw0UnTQD4dQo+U298NamCz20AbXHXE7ybgHimqJK5NPTxsRZ6xlgF/ox1fphlxZwlm/DjIcyg\nh5T+QTQS8xNVr6SbCx9j1wQ1TC7h4haj5JVfTx6SdsMHHmwarUsSN/fAWXZtsWmm1G5tFSTghETN\n4JZSojiJlJb2H+ZGI7wLQyVHEkKiJlMJZ2WS4K7HY++JFwo8sMOZVkCwvLR0MtWiS9HZSnlA7nTq\nP2wW8KsskzPxA4gaISsj0bVgZl+QPKpUt72Y29cUJpTGJXeH781fjY1xiB7/AN+SmOX t+ErCxtY7\nYkmWuLr/ADxFMq1Rc6nZiTG5Q39QbYkdCjoVCkdMcvqRldK021TrK5lCA3GodbDvglNKskYIJXbv\niN5YzgebcEdzgwwLJYi49cV2OIFLPkZ7VpvNJ5iLg4DZjubX6nbBKqCrv033OI3ntWElFiRY4dlk\ngKaMKsPFyAnKtlW8c2sX62tY4qaipTVyiFY3kZpIlCJuWJcC1u5Ivi4ePan42gelgVi0qnzDof8A\nVsVHl9R8JzwHMTy6YmlVQWjQOCxW52bYWPt1GOy7OJEFdVgdotHPsqf+IctNW5rJXUFTDWUVWmuO\noj1ecq7oS2rfUSu5Nu2K9qFK6hv9cTs5TTxZRGlJLNPHEWiMkg0klWP8N7rsRt74iNdFpZr9fT3x\nPpyA3hB2UOpYf5d6D9DjnCjizHHGLSorWN3xrGYSS2ev3x0u58xJGNHqRjBYYdJelPDelSh4XoUj\nN9S6zbsT1xYWXuG++PO/h/x0uXxJQ5gVMCEBH/wi3Q4vLhzMoatFenlVlbcb44ftDTSwzFz9id11\ncMkc0QMZ2CnFLGvL6bn9cbyjJ0SkzepTaaarZibbkKAoH88ayuTWQT0/liRUoVYDGuwYkn6k4eBj\nX7qjPI6PAVFccHP6XMNPDcdRU5pJYU8Mfyhr21t2AUb74sTw3yvPMvyAR8SVzVeZzSvNNIhCqGc3\nIAFth+uJMtJDTs5jRRKwsX72x0sRt1NsExhY0MI+/wAU804l2wuaiFlUxO3L1kDmL3HcXxAuLuEZ\n8+rs75eYGNKj4eGBZlZo4I4vMSqg7szHdvQAYmtdE6xkhjYDCFHI0kZuL264F0ha6hhNG2hxLzv4\nkcGUWQJCKWuqJqjSOalQiqHJNiUA7D0NzirqumZWsQbj1x6n46zKBcyq8siyvK81zGvEEUcFbY8i\nNVJaYr1IuQBpINwT23rnjTw4gybJFqo6meaqQapToHLfpsq2uA PUk9Mamm14jAbK6yfvQSdpxKAQ\nK+uP0Kq8uiiPJWsRXo2kHPRn0BkB+XV2ubDbFi/2cJZcjm41zPNqaYyUVHTRtHYljqkZlUX7+UAD\n0GIDxBUTZblskNKuqWde46KpBLX+tsWpkucZhDwHm1W7rJV1EWW1iLyeWzB42YL7i4Nj9cT6udzY\njWzseo+6TIGOeGE5bXwO/wC+KrPKOO80R2qKzKlejkdnYxq2pbm5Or1xbHCXEOUZ5CZqKoGsEB4j\nsy/UemK0yHLOL5qeuNGtDTpHD8QkdVKtqhS1tAHTUBckMQdumN1fA/EGWI/EFLBSxctrhaWddUia\nQWfQv8FyRcemK+q02mnJaHBpG1G/j+FYi1M0YHFbgd7FH3fZeg4WhW3LlGw6YfQ1FGsf4svT1xUX\nB+YZpmsOmojMMwFgp2LD6YziyTO1iemomILXDMnzW/p9cYzdIWy8ouFq2Q1zOMWpTxfxzkGTStDN\nK0sv/lJa4+vpis874+rKqTmUeTS8ltlEiElve47YzJ/DfOWy9s4o6eGpmSWIsk06tKYy1mkVTu2n\n1aw36G2HOdZbxdR01LU1sNHy6qZ1+GgnYtFHeytIrEizb9CDt6Y1otNpYiKIcfE18AqnOkNtFt8h\nfr+FPuA6LL+IPDaCrSBJKirlYlJVDNDOh+T1FwLj1DYqThHgObO81jqpSEiMhlEUo/eMNypNtt9h\n623xY/h/z8mrKbLnsIa2phmMam6pKGtcfUbH7YTzDiX/AGcoc0njNLFKauqemVkDOYFcgH2uRYX9\ncRtmkjc9un/yIr1Tvha6ufmsqM/sy0+dGJoDSNmlSo0gbsNOwNv4b2t0uDbED4lopKWfS1ij+ZT3\nxIfDjO2mqqyjrJA0laslSrSNb8cEuQB6sC31tgfxODLUG9zc6gfTGtCHRSmN3gqL+GaIPaFCZk3O\nGrDfBWaM3IHbDGWKxO2NJptZj20m2Mx0R jW3pglEu5V0zSKouqsR6456HBGPLKhqc1AAPcoBdh13\nPphvBSNLNpa+nqdJvh0rSCMVe43xZ/g3nZpMzME0+gObojb3PQ2/yxA5cqmpRDPOlomIZTfqL9cd\nsvwzao7CcNqDp1Qg+uINRCNRGYz1VjTzGCQPXtjh+oWdNxY9MSWMkDbHm3w08RisSUuZOCw0qkl7\navr6HbF40HEMMsCOGUqR2OOScDpXcEuFsSR84cyPIKkem+5P2x3dQABgH+2FY2QXB6Ww9pZJJvNa\ny4duoY401V3QuaLcl5/OpUdxhvSR8pjfocPClrE9cNpWAPvhPFHiKTDjhCbVlHTHMY63kQNUopRZ\nWQF1B6gHqL4Z5nTR10TRTqHjbZgd7jBIjX0wyrJkplJYjb1OK8tbnZTxWCK3VH+M3h5SxZbJmXD8\nbU89PGT8Mx1xSre7Cx6HbbttiC+EeaPWZNxNRVkrStDRU0lMXJ1KkbOoUew5m2LJ8YuPKWhy16VD\nrqZFKrGPfa5xSHhXUR0+fVkUxsJ8vlAsbXZCsn8lbGtpRJNoX8ewII76BBKdxEerizTjv9LVpcM0\nEFfGskchhmlUGQHox98Td4jl1IryySSFBYHWQB2xDKHM6Nc9qTQsDTS8upivb5XUHYD3uMSDMc1n\nr1jpIFVRIbMxOwF+vvjG1LZHyZ23W03YcOyc8GxR1GfLy0Ci1gO22HWaJEucOtQqSQNIEZT064U4\nEg5NU05UnSSNj2vjriWnIzVlZGQyNe3piGRw4rCFp/u14J2mTIzmohkmiDG673sfY9cBs1ygQOsk\n0jSaN1Vm2B9bYJ0mfrFCYKkct1Nr3uPr9MC8+zWKWJtVrAXucDHx2AEm8YPtbIPlD6+LcrlVvkn1\n79LJ5j+gxTnE+dU+ZcP5e9CZ1atnqJqtZiCx0uCljf5PO33Htiw4KxIaLiHN+at6XK52QA/I7oUT\n77j88UkuorGNRYIg QE9gO3+vXHV9mQDiLj/jXyP3Cw+1NQR7I6j6/hHOD7NxdlKx6Y0E6hi+4Isb\n9fy++J9nNAjtIgAXzFWB6rbtirIGCAsSyspDKV6gjuMXdDFUV2Xw1dTEiytGhcar8w6R5ifU9cWN\ncCyRr/coNA8Fjoz5qrsyo+W7aLaQdx3+uBE0JF9jiws7oVmnXlqN2+4wMq8ge2hwb/Mrg7HEscwo\nWhkisqByRHCOk+mJRDkk00gQA7mwsL2w3zHh6tpKkxqscosDqVsWRK3vVJ0RtSThmqkvUUkUZalk\nFpCg69x0/rgVNFFTZmaYBY9chgEjCwX1OJjRUn7BojKY0llmlKqoJKqANyfU9d+mAlfSx1AlnKWR\nGjVQSQDe92+oFr/XCY8OJLVE5tboHmBkldkjc8pW8qE7G2xI9MLR5cZqR5lOqUEDbp0/K52wP4ho\neTXO8QaOC/lVm3XYenr+uHWR5gY5T8WJJCqbspswHS5v8wH5jDvsCwnZRNFIUEMz5xHR0iSS86RY\n40QEs5PQY9T8P8O1VFlVLDVX5iIofTuAfTHnfI84fhrOBmUKrzo20JOBrMaHZvKLagw+mL/4Zo8x\n4tyOWsyXiylSnmZZKaro4AZIDqsYp4ySD79Mc/2xHJMWtA9nv8fgtjQytiY72sqd5ZlkcSqzHV9c\nFzLHCAL9BiB0WacT5NJUzcZV/DsWXxkwJ8Gki6nt+8Z3NlG3ygHfvth7W5ojTGGOTWvLSVZEIZZF\ncXBUjYjGS57dM2mhSiN07rJUinzJALawPbAmozNdW7C3ffEdqKxgLk2He4wAznOxCAkJ51TJ5UjQ\n7k4qGeSU0Fdj0bQppW8TU1FCzyOoA3vcYr3PeLK3OAy0EbJTG9p3FlP/ACjqfrjKfh+qnK1Obzaz\n8yxX8oOG2fyx0OU1lZIdEFLC7lrdSBsB97YNpaXBt8R9PyrUcUcduHRUZx7WJPnlRAkju0B0u7b8\ nx++/t0wDymubLc0p6yPcxPcj1Ugqw+6k4QiSerkBVJJZ5SXawvfuThK2O9ZEGMEfguPkmc+QyjBt\nTTJmekzCk5dVoijFgT0Edyw/XV+eDmaca1EUsFTkUkMhhJSSOYXEgPcd8V7T1LGmkp3GoaSFB9Ov\n+eF6XKKyRKSSmiaojnUlRF81wbFfrirJpY3u4pfwrrNZI1nBEPuFanB/jBFTtMmb0/wWo3SSIl0P\nsdrj64e574zmpzhXyrLpMzYA/iSHlre3UCxJt6nEJyjg2F5g+b1tVlCLYq1dl0rKNj3QFetjcnth\ntHwlU0sskn7QjrYSpWOooaSokBbrteMW97euM86PQF5IB8s1++9WRPrKANeeLr5eitbJ8xq66glr\ns7ipqWWUroggk1aU9WPqcMc/s1HrikKxsLi/sL/0xXtNwrxHm+iN5JqenYsqtUqYg30UnVbYdQMM\nMrrDlNXmVLXVDzxR+Q2bUL3Aax9xsPr7YCPQM4y6N4JHQdFZfr3Boa9hAPUozxZULlXCSZVGxFRm\nDRPP66F85v8A9RUfbEEB2IUkYeZpVzZpUTZlUSxcySYxiEN5kFrjb/D2v64aovUgXvjb08XKbR3O\nT5/uFhamXmvsbbDyTjLTAlZA1ZE8tMJF5qK1iy97H17j3xcPh7XCtyw0M8zvUQDdyP3g1Egn/it1\nxU9FTDRrkHcC2Jok1DkzZVW0Ess1W89ipAA02UHYe7MN98Q6yMSt4evRHpZCx1jbqpFnlHyam6uE\nF7WvY/lhK6QZZJJUOLxb2JuGUnoMJcVQzzVDHew6m+4GOchy4tzPiy0kbAlAT6dzigzLAbWi8Uco\nxkkFK1LJKiBZAPL/ADwDqoJJqh2Gld7EEd8SvK4eaooxE4kAspYWFvr3wtNkKxSssqprvc+bDh1F\nQ4UYzB6l8kyauiClkjfUbWF1a3T6dsAJpWqaBaVSRGJNxb5t9v1IvgvLV0xy 2hhSukFM1VKGj2uP\nKL/a9sMg3Nklip4gYzca2tqK+m3T/wCMasdAe8/MrKfd34D5IJmUMZmqwyMpZVjBO6hR833uLX7D\nEdqwqV8h0MH1bb3xOxGVpwDGkpvZTpt/Lb88RyaP4mukdxGrMSD3wbfFMlstjp6iB1rVcuRdSCPI\nbbHfvthfhvMsz4WzM1mV1dRTnSBIsJJ1jsCOjD2OOYljhJ5crXI0G63I9xjTzrCI2q2Uw2UiVN7j\nuAPt0xDIwOBacgqWN5aQR0Uz438WDxNw7S5S2TBY2lSWWqkfTEGjuQQBci59enuMG/7N1XLmUGc5\nbXSxu9JokggAKtCCSGQA7BPlIHYsRbFPrMldXShFRQ92Md7LOB/CRbZrdDi3f7PGb0FLmGa5W7Tr\nWuhnikmF+YgYalv11KTex9TjJ1unjj0zmNb3H8rRgkc94ddK3cyy+N4zzCb36YjMWT01NVNNHGDL\n/ixN6mMuhINgQOuAdXT6Zd7aSbf6+uOVlaWnGy2IZTVWg7RTPLZixB7DoBiuPHBpKbg8wqpEbzRK\n+/UE3t+gxeOU00LKW0/iDb12xWP9oOkWTgfMHC2MXLlXbuJF/oTizoG8Goic7biHzTTy8ccjB3H5\nLzOKqZWmZXIaVDGxXaynsPTCAHT0xvpt6Y1jvwFydk7qZZF4dcS5nw9BxDT09LDlsjkU8lTOF55U\nkHSoB2uCN7XtjmOnrsgzP9lZlDLl8jMJ6R23VX2vpa5BUm4O+JD4ZeI8mX02VcK8QSovDsdQeVU/\nK1GXYksezAFj16Bji1M64Zo+JEqqavj+Lo45TyCPK6225iN2v19COuMLWa+XTTcM7fYOx6/NbOi0\n0csXFG72xv3KP8JeLpyBlhznK6sSINN4VEiE+o3B+2D+d+M1PnyrFRUOZBlWwDxiIE/UnFR8S5vm\n3DVXPkeb0lHmaRJ/daueKzSR9A1/UdCPXrhHLuPIqCE Cn4ey5ajSFMtrXP64i/p7ZI7jZYdnDsHx\nzlSHUsbLcjsjvGfTClPFud1NFk01dKSlZPaKEKTZL9r/AM8VCsZZFj1Im5Y6zYdL/wCvcjFo8AZB\nmHi3xiq5mzQZPQxh6t47rZbkiMf8R33HYD2wn/aA4eyHhzjmky/hqkSkhGXxyTxISw1ljY7k7264\nv6INgIhr2jvWwxdfD5qlrZTO7mDYbfdVszNMIAyovKiEQ0qBcAk3Pqd+vXpjuJbD3BwqihUv+mEx\nfUSOmNJUCiFK4C6WOxO4wuatqGYT0hSTSwfRItxcdD9cDA5Q2xwZWJtfbphi290gayFaeWcVZPnU\nGmrc0dYy6WWU+Un1DYL00BjEyizq8Y0uhuvvim4oQ/8AC5BO1sG8tq6qgdWp5JYwO2rZvtjPdog3\n/wAz7lfGsL//AEHvVu09QY6SHWAagAWNreX0OCbZqjW5lM2oC3rfEJoeLopgvx9CSNBBeIizH+mC\na8Q5fMobRLEBsFIvb7g4hdFI3ojbIw9VU9bWSQWhUsI1ZmsD01G/3OwwR4crzHVD8QKLjU297E9B\n/ngFm1vi5H2ax6e2H+Q0pknZ5B+HELsobc+nTGs6miys9rXONBSvNa16OqhpaURxCUEsXu1hf6+m\nBlTTx8zl05imYnsSgbATMq8T1L6QXVWNm1ar/f8ArhOhrDFqtpK9ri/2GE0YQltFSCeg5P4zWCqo\n8t912/nf0wHqItSukR8jWY3tvYf/ADh1U5kZo5YnGovpQEGyjtuPcnr7YVSubMg6zUdOJlAXXCmm\nygAb+vTr7YjshFXW6UbrJNnie76T5Q3v39Rgjw7mU9JnVHmEc0iTwTiQTE32GxuO9xsfbCWaUkKR\nhkkd5AbE6fKfv1wNomaNpeWRcITueoFicJ7Q9hB6o4nljwV7ZyaqXMcpgqVsVdQR3B2vscNq+MWN\nrAexx5KHGvEWW6oMtzWtp4OUqJ y6h0Yd73v17WPQbYnOR+NOYpPBDmDfGQFSGNVGquLfKA6Wuzbi\n5G23rfHMT9izhltytePWxmTuV4Us8lHOsqnY9bntiMeLUKVnCedhDdZKGWRL77gX/phfJeI8uzuN\nzQ1AYL88TbSR37MvUdD+WGXGEnM4MztWO8NHOQfVeW2MeIPjla0iiCFqlgILvBeVBuAfUDG/p1xy\nptEpPZR/LEt4c4KqM1quVWVsWXo1IKtJeU9SukgMA5juIyQT17i2PQ5HtjHE40Fx8cbpDTRafcL+\nGuYZ5kMOcVNVHQ5bUBvh2aMyNKqsVLWuAFuCBvc2PbFg+G2c5hkNavDWfNzDHHropxcpPD08p63X\npbtgZwBUZ7lVMvCuYo1TlU39+oapAXhCkXOlj8oIOqx/riz/APZqlzeUz03LrMognVqZ5wNSsAPM\npG43uPfvfHL9o6pz3OimyzpXTur62uj0WnZFG14w7rd52x9qTDj3hDL+K8uMeplnj88U6AEwse/u\np7j/ACx5yzjKqrJcynoMxi5dTB81t1Zezqe6nscex8rpzQTyuqhtaaVuLgG3piuvEzg3/anI/wC6\nmODMISxiZh5W63jbvpN7j0O+Iuyu0DpiI5T7B9P3qg12lGoBcz+Q9fD7I/4P5fFwx4TQMdcFVmP4\n0xK+Ziwuftaw+2PO3H9XPW8b5vLUyySukohVnNyEVQFH5fzx6ep5dPB+UpUxFZY4FjZCLlHAAIPo\nceaOP6IUvG+bKhuryLKL9tSi4+1ji72XKZNU8u3r5mz81BrYuDTih/l8gQPko8kYNv1w+paPmwtY\nb+uOIIgRqbexwVppLqBYD6Y3yselGqhDG7A3BBxkSLKbl7DBLO4bVRItuL4bJTnlXjjJB2JO1sPa\nak9pZliUKgUgdcKVcxkAIAQjfra+BlOj6zoBwpNI5gZHUbd+uGpP0S1HOWnWM/Mem+JdRZc9TTJL\nE91PcDFfR m8gv1PT64meSU060AD1DRnUTpucOQhUak+GWXmMrzgknSz6f5C+2FWzGaOB6dFKtItg\nsYuAvoPfrc4RRF0XmJRg19IHX064dyUbyRo6sF28xUWIGEWg7ow4jZLrRXpXWks2hP7wykAC9tlu\ndzbrhGKFSiOUYWG+3b6YkPDlFSwU5RCj1GoWLgWHr9MPuI4EiZqeCGFhILCQKALj0I7+/fA7Gk99\nVFIkUtPKSoYC3Jbo6+mGxcU7H4e7i1msTYg++FZ4XphqljYk7XU/1wymnVGuoYCxG4DWvgqQXadc\nQin0UslMhXmoSdR3axsCF7Daw9euBmXRLNULrGoLud7WA63+2HCSagNfnCrsD9OmDXCFBSVOZwQ1\n0kwjc3KUy6pZFAB0Ko7ki1ziOR3KjJPRTRt5sgAVg8DeF+ScR8MUlTm8dfBXSqzvJT1GlgCx0eUg\nr8tu2BfFvgVm+XxPUcM1q5xCouaWVRDUgf8ADvpf8wfQHF+cMFJMqp2FE9FtYQPbUo97YLMoUk6R\n/njlmdpahji8OwTscjy/0teXSRH2QKpePMqz34WnJqUqabiDKUdYmAEL1EQdC8Eptq1quuxPtbcC\n87zLiafN+FpKLmQGWup3pnnqJUhETaBfYbyN1HlAFzic+NPhzHxnlzZpkkSDiKmXdCAvxkYH7snu\n4/hJ+h6i3mGsqHniijqFImgLKQVsegBBHZgV3PvjXhbDrwJKyD8PLwvKqGaTS2w9fXz8VrLqWbMK\n+lo6RVaoqJFijDNpAJ9Seg9/bFv8P0+Z+H1OZBHUVkIQxVM2XO5HKa7bLa6uj6GBIsQWv6YphWZH\nV4mKujBlYbaSOlseiPDvOY+LKameQiOViIqpE8oDjr+fW/vgu15JI2h1WzqEXZMcchcHGndPLyUr\n4Wo/9pzJmFdVEA6XWxOmRrD8x74keW5c2VVT0670bMWUD+Ane2ClNQw0iiCiCrApv03w7q EMWkv5\nw21+x9Mco4FxLlsOns8I27kjLqjswYqbWH098DkVQZoX3BYlWw6nfmQHsLdhgVVTCGdW30uNwfXA\nOKaNpOElXJBAweRDy32axsAegNsUn42ZUKPOqOtR7tOnKkUixuoup/n+WLfzCqZ13PkDfY48/wDi\nbxA+c8Sk85ZIYE0qF3C9t/ewv98avYrHu1Ft2F2oe0SG6ch3X7oLA4ZCB1vh5SoxNybW/XAmllI6\nEEHc+2DdBIAQxIsO+OsK50ZXGYhWlsyAsNr3wxd2ViC+lemlemDjSxmXUANPc264aVcqiRtESf8A\nMBhkqQ6nkVptBFz6k9MMKttJYXN74c1kp1MYTp9j1wPnLFb339MEAhK6y11WrRpflBvbFhU9dTyK\nzgkKxuoHpYYruKM7G1mxJMqn5dMUYg6WIBt2w5TBDJ444qpwPNGhsGts1trj2wpJWr8OUDsHYiyg\n7EdNxhosxAsJHO/U9R9TjflY3kbVcjYd8IdxTHfCf5XPVxzB0Z0QEXJ6W+h64kVNXmSeQSJqgZTZ\nrDYdNx6fTEZkqXBSIsWWMDSrG4GOZG0kEnXY3Cn/AFthZKWLR6tylpKWeeGRDSwC589up2AB31H0\nGI2abSpYsqgi+5vbfph6tfVLFKiy6mkFyRYgbdvTrYY1Sn4eaOo0pPJGAqROpYMSLfKNzgQXC7T0\nCQAt0+VxLQVddmbvHTwp+GqEAyudlFz03/li0vBLh+alyd8zFIBX5hvC5G8cA6Hfcajc/QLhrwb4\ne5rxZWU+Z8Z6qfKIrNDl4HLab6qPkX1v5j7DF80UEUSBYI1jjUAAILCw7WxzXauv428hhu962HgO\n/wAVs6KERu5pG21/M/QLnK6VoIQjvrc7sxPU+mDKQKV3AthGBLkemCMSjp9sZsLMKWaQ3aYvTLcF\nRZge2Kw8S/Bij4uqZc2yioGV563md2W8FQw6FwN1bYeYfcHFzxwhh YgY1NTmM7dMXImvhdzIzRVR\n8gkHC5fP7irh7NeGM5ly3P6SSlr185U2KSKb2dGGzKfUd7jqMSXwerI6fiSWnepMEs6KYFJssjg7\nr9bHb6Y9G+N3BMXGXDoji0Jm1KS9FM+w1HrGT2VrAexse2PHksNTR1bxyJLTVdPKVZWGl4ZFPQ+j\nAjG3DM3tCB8Rw7Y/Qqu29JK2UZH7a9nZZmZReUZWZhazON/ocFYKosoDEMG3KgdD7Yq3w54rTizI\nkWomVM0phpniK21H/F9Did0RkjYA3ZgN7G17Y4uVsmnkMb8ELoiGStEjNii5BcWFgOht/EPXAHPK\nfSihbAo23uMGEcEAxA6dzYbacBuJc2y7JcsavzqrFNTRmwYi7O1tlRerE+gwzeJxAaLKZruA2dkD\n4qrIcn4Urq+UF4oomYrfqeg37dRjy6ZHkd3kP4j7nE28QuNqvi10p44fgsnibWlODd5G7NIelx10\njYX74iMcLabOt07svVcdl2To3aWI8z+RWH2hqhqXgN2CSgext0ucEIJulzYXwxeBkXWPPHfZx/XC\ng3UG+NRZ+2EVhmLu5ZwIwfXCsjq24by6cB1kKE9L4WedmUDUfphqT2k2PnbvvjdPTmplAHQdSdrY\nS0O9yMLUcpib5gPU+uHQpZqblzst72F/rhCKchTZEsTfvh7VOs0YZvmGwYbXwO0g4cJliNEpcpLq\nHo0Yv9DvhNZismtdiDtt0wl36Y32t+mHTkp7C4fYC57dzhdTKv7xSLjYsLYRoXaEllAK9WDC4wXe\nASMshJ3vvgbNp6wsp11I4TTfSTv2xbfg/wAMGmyuKuqYk+ImcyBiLkL0A/L+eKrymibMM+y6gi1D\n4mVYmIF/Kfm/S+PUNEi0NEkcKBVQAKqjoMYHbupLGCEH+W/ktXsuIWZe7Ce6QkIF/N0Pth3SeQLc\n9sDVqA3zWJ9MOqaUMbLjmBJRwtRzTWUWge22 HcTi+5GBsLX3I/PBagpnqD5BpQdWI/TGjBxyENaL\nKozU0WU+p2BIFyT6Yfcostm2xzCkUA0xjfuepx2Tqx0EUAY328lZTnWcJnUZVRVSlKhGlU9QWIH6\nYifEXhlwbnFfJmFdwzQVtbKFWWRy4ZrCwOx3Nh164l8sojJ7H2wPqKuUTRrFFqRzYSXsAfqOmCjM\ncbxwtAJ7k5D3NycKHUHg9wVT1iV2V5KcvqUWwko62aMn1UgsQR9RgvLwrolAo66RJV+VKlQ1x/zL\nb+WJeoRUUlQpAt5cDsxzDRHLMmrRFGxJC3ue2D1Gjh1WZW349UUOpkhww4VY+I/EP+wmSGozHK6m\naoZtEHJB5BPS7yjZB7Hc9h3x5j4mzzMeJM0bMc3mLynyxRqLRwr/AIUHYfqe+PU2YcbVNO/w9dRw\n1NEy6Z0tqVw3qpuD6G+K78TPCBDAc74GpXELJzZsqvugtcmG+/8A0fl6YHR6OHTElmT3lFNqHyin\nbKh1jvtfC1KdD2PrhTSLbXB+lvzxqx1A23H640LUAFJ2tNqF4ns56i3lb6jDZqF3f92UYfw7afsc\nLxyFbWOHCVzKNJUEX6HpgbI2RUDug7wlXIubg77dMat5sEpSJiwC7/XDEIbAnubXwQN7oS2ktEul\nfNY++NSqurpY42j6VOoYQmlvYWwsoU5UgRaSbnthpcKSBbrjXObTjgMfQYdMkNO+NgXw4MV2O2Nr\nFva3XD2m4U4pBaAXtZ13HphWOoMdon1hbWutr/XHCoyxqyj+LY9cLGmknA0CwNgT2GBwjFqzPA/J\nVqs2mzmqDGOkBigubgsR5m+w2+5xaWdV8qxcukGqZzojHuf6YHcLZfFkXC1LTRabhASR/ET1P64k\nGUUPMAqJBcn5fYY4LX6o6jUF/Tp5BdRpoW6eMX+lc5VSSJEnMJZu7Hv74K08ZDk27YcRwgKfU47j\nTQ1zvimGGwSmfLxJ1ld K1VUcsbIBqd/QYlI0rHoiUpEvQDvhvQ04paULsGPmkPqfT7YRkqQ8xC7A\nY6rTRN0kQ4v5H9r7+KxZnmd+Ngn8ckewGOi6hWI7C+BwlCm3fGSG5AVgrNta+LLdThQ8rKF5rmp5\nZACi/p1AxCc9z7NctqaaPL51WJy0jRNuXAsLD3wZzPmHMfhgu67n6HEe4ioamvrBPTRFEpoxHzpF\nsgYC5F/XptjN0sj5J7JyLV2djY4aHVTpuJpJ8hpq+mYBJUBFxuSNmFvthrkvG+WztUpUJT0siMxK\nO9gU9QT1ue2IvkdJBmnB0FMJW5Y1lJgCjB9RNwPqfyxBTlNbS5nyasFai5s7eZSD3F+oxpwa0PcW\nHcFU5IC0B3Qq3M34eybPX+Loa4QGXbSoBB+g9MOno58vyuCCimVBTgKNW5IHX/PENSv+IyyqlkCm\nRAsYKqbqCLC2BFDJXLXw82rm5aXGl2uguOu+LfGBmlBSCeNfAEdRlkvFuRIpnjYtmNPEP3kf/nKB\n/EP4vUb9sUUpBsRj2llcUzZdHKsCIjgruLqw77ehGPLniPwp/snxfVUVOP8Ad8w+Jo79o2Jun/Sw\nI+lsTNdhIKJqpHXHa+/TCpj29cclBv8AXD2ipJXuSSMJFrAgb73w7WMXOODT8yMvFuL2P16YVhKi\nmRJZvTCLg67D0/rh88TRqQV3w0dlFUIi/wCJp+W33wQNoCFyflG2MUG2FdG2O0j8vTD2lwpzyLsb\nevrjqOIo4Zeqm4+uJrV5RHMG8hLJcjbf8xv/ADwJrMvWCZkQuyi3mcf69Rio3Uh+ysv07mZQ2i0J\nIeYPwiSSnbD9gqRARgFe2NR0tu2HC07EaY0LEsFCj+InoB9cIvCj4SVMvCGDNcwzmWnjqZBksCa6\niJ91JPyqt/lJ67dhi+qaEBVUAegGI1wBw8nD3D8FIVBqWPNqX/xSHr9hsPtiY0yedR1BIB98clqp\nW6 mcyNGPn4+9azeKOMNJXCR226Y6o0V62IG2x1H7Y81cbeM3EuV8SZzQZVmcZWkrpacLLlUQCqrs\nDZtZLWAFiQCe9sDKvxr4lhrsyNBxBWSQBFFC75RSRs77auau+lR5gNNydsacfY8pLXEit+v2VF2s\nGQvYkzr8KQCSW3vgax0C5N8eVqHxw4nEVHJPxTzp20iemrsji5EZLgErJEQxUKS3QHy274keXf2j\nTHTK2fZDSzOT5nyyqZSBa/7uRft83UHF7U6OZ1Fouv3qoopmNwV6EMiqOY52B3AOGLZ9SrxVlGVr\nEjtWrNZ2cAoyLqWy9TcK+/bT743EDVpG0eoB41kAPWzAHf8APAziOSlyqA1s1OsksTxtEV1F2muV\niCLcXOqQgD1bfFCBzgbIsfVWpGgtwcqO5pxqaec109LB8AzzSEhm5nJhqVpmHoZC76gRsFFrXN8C\nMn4mrM3glgly6OM1ssdMFlmkIWeQqhII/wC6DnY9WUdd8EqKh4fzagr83zCgnkNHeqmdEPLEmkO6\nKmvc92FgupSdyL4PxtwjTNWRy0M9S8cbUl0Rr+TUixL5/mIjZlI7Le4Nsaum04b7RG6pzSF2AcBC\nMykr+D8oiR4qKaGHLqiqkDs8ZMkZTyKxNlBMo+YX298LtmUc+cZZBPSwSUk1TUhX5MkjNFEY7EEb\nLqEm5bbYW3wflz/haZ6dmhqJDRIopSYmOuMqsjlLt5gojBbVv5O/fjK8k4dzWcfsKllgfLpiAHkl\nAAYABlBYhkYICPXSCRiBvZoa/mdcozqiW8KLVGUQVEM0FPTRJCw1FB5VIvcHEMzfh+poa+kiMT3q\nJSsekDSCLndidhYe/bExzNKnLaRUjlOoGwsuxH1x5a/tK53VZ9x5S5PIxanymijAWWRVV5ZfOzi5\nABsUW3Xy40eFrzRwqxJbkL0zR1FRSRvS1SMDEQRHb1/+MVv47ZMldwlBmaxlZ8u qQCbdYpDpa/tf\nQcFf7NeYVue+HFPPmLSVMlLNLl4llfW7KpDKb+gVgv0XEu48yM1fDObUZAZZaWU/Qqupf1AwiC0e\nSdu9ryJJFpUXtfHHLuO2DHw2uJG7EA4wUtzuBiPmhWOWUISOx1NYBdyT2GG+QSipy5mU9JpLjp1O\nofoRh9xLHJTZNO0R0lyqEgXsD1/TAXgbU+Y1FOCeW8RcrbYEEWP5E4kBuMuUZw8NRqeNWsGAAGIr\nJVxGfnfhawt+3+K1uvW2J1NTWLbdAcVkystIxYGwAA3Gx/n3wUBDgUMoLaUqeEhHYHYKSPyxHI6u\np0D+8SG+/XE5lpvwJdtuSf8A24hqwJFHG80DSiZRIj6NOpenQdNwcPE4G00rSCEV4j4qqM6pY6f4\nVKSNJOYTDK12sNgegt3wNyrNZ8uqXmUmZiukpIxK7283W99sDz1OOl0l/NdV723OJGxMa3hAwonS\nOe7iJyp/w1nsucZj8KaSGFUiMjspI6EDYEn1xanhtkXxedfHTreGj3UEbGU9PyG/1tih+Gc0TJKq\nuqlkikmFGUgV1JV3LqdJt3sDiZ5H42ZxktGlNFk+TPGrEk/iqzEncnzWvjK1+kmkaW6cb+PxV3Tz\nsaQZCvVEOwAw/pyBInrqGIFw54kcIZ/WUtJlWdxSVlU2iKmkikSQtvtYiw6euJvE/mTfuMcty3w+\nzI0g+IpaDnNkFtNrw5x9pHiBxWpF/wDe9V0Nv+9bbANtLbRoR7k98H/ESaSXj3ilWdmQZrUgXN7W\ndgB9BgCGkbyJr0k/IGsL7D+mO/i/g3yCwXD2ik9u/wCuOaj9xJ/ynHe6s63IN7EX9DhOpI5ElgF8\nvS/tg0K+i9BBFFlsTvpTRTxkkn/gGIdxUEzajmo2nWCUNHPHMSp5bxyKytpJFwHUAi/t1xLDGxgp\ngyloxFGbep0jFazcFZrU62MVOtSs09QjhxpljqdLTwkEmx DjUG6XUEWBxltj9mgKVwn3pzkHC0ac\nM5rTRZlTCDNV5TVRCeYsui+q9mBYsQL9WIwTg4Pyerinpjm1E1LPrqJKeIRaASZE1ABtkCyvHa25\nsbjod0PD+Y0+RIkNIlNmH7UWuhiWSNo6cctY2Eg+VlYK5YLuOYCPML4YPwjm89JQxCj5bUdHThnn\nnhLSGJJlMIKdm5iWJ2sgJN8WI28I3UTsoxUcK5XSzSO/EEMFXMFBd+UpZRG1Ou2oXIjMiA9NVjY6\nbGQcK5Zl3D7VdPQV0LxVbrVcrUgIZiUD3BudQCLfoSm25IwGhyCr1VgnyynY1OZU2YrK0kZMSCWI\nvCe91CMdvKb7G5wKi4JzGri5NdCkMbu85mSVNUZYRiNR3vE8ayjtstrm9pd0FKzJo6etp11aJYmG\npSpuCPY48Q/2hKaJPGviOGSVIUSOmOplLA/3dDaw7nHsjLaifJ+D/ic5g/GoKMvULSgNzDGl2Ma+\nhIaynfpjw14l8QT8Z+IGc53JlxyyWqWO9JUSjVGI41QXLBfMQAbW79+uHjAslJy9L/2RIxF4Y5go\ndZAM4n8ynY/hxYs3ieoMccqC4jeCUMR38h2xWn9kxHh8Lq1GCh1zaoFlIIvpj7i98NM28X8rzHi/\nN+FUy2vWvpvi6X4iRo+UXjVgTYG9jbbvvgJiaJHRFGMgKnc3rKfJcugnqoppEd1iVYQCxYi4629M\nKZDWU+c0slTTxTRCOUwssoAa4APb64H+J9OxyjK44h/4ljubdIyf88d+FUJGTZlr/wDvB3vvoF8Z\n1N/4/N6/mlet3O4OiS8SIVj4cRjYf3pB+jYj3h1TyvnwYwEw8iQc3SbAjtf+ntiXeKI0cMREPy71\nSi+m9/I3l++I34Vwhs+kkJGpYXCqTvYjcjt2t9xieJ96RzvNQyN/7AHkprU08aa2fSo0ndmAHT3x\nSKj8AWFyUt0xcHH9ZFlWXU0ssHO5k rRr8vlOg7+YEd8VLywJuQ8sAYAgsZAU6X6i9/bEnZ4JYXd/\n0Q6sjiDQrETNaSpgqEXQh+HJDGVbbqR6DuOmIBRwUskCtNOFb/DoJIFu+2O1q4wViqXiMVlBeKOI\nlQQNxdbkj6jcdcJc2NgAeY6qNKksOn5bfTFmKLl3Shkk46tJ98bsdJa42sPffGv64VSMtE8m+kGw\nIGwNu+JlCuFNivT6EbYkmRTxItLzszSBY6ZvIwaTpIW02KgC9+gJFx1xGcGMtmqpRSRyLFLTopjj\nVkhay8wk31dwzXF+vfbASttqOM0VLqbN0yj9kZzKxqzRzLXQQzU/JMhS7abqTY72vv06Y9ScO5p+\n2cjyrMxFyRXU8VUIterRrAbTewva9r48b18U5STVQ01PTGZ3ifkRxSDR0R9FrX1DzD3tfHrHw4kE\nnA/CzABVNBT2AJIAsNr97dL45bt5jWRMeN7I9y09GS5xC8lcdyM/HHETs62OZ1RWz30jmt+XTAdX\nGq0kRk3A8hsfmBPY7kbX7YJ8QMTxNnUqyhZf2jUEKVFjd3uQT9ALe+BsMaFCWZwRbZWC9xtc+2+2\nOojFRgeAWY7+RSTsS7Egjc/NuQOwPuMI1P7iT/lOFXA5jWuRc2ubnr640dwb73xIEC+kVA8VTl9M\n8bxyKY03RgR8o9MQzxT4yy7gHh+aurHIq545UoIuU0iy1CoWVWt0W9rk22vjy74J+JFdw3xhltHX\n1lXWZRUaMvFM1SRHS63UCUJY30+noTvi1/7ZLp+zOFKZ35ZeoqpQSpIIWNRbb1LDEXLzlSB+MKRc\nAeOnDOe6KXPa2LL8wKUsa64nVJpnjXmKmxsqy6l3NrWN7YAeOviTxpwnxTVUPD/wMOXwpAwlajM0\nxZxuLny2v98eY5KKEzU8aZhTtFM1jNodRHYjdgRf7gYsnxW4tPFFJUzyvE1RpgikNO7mIvGQraGf\ndht1774F1NI4 RuiaCbvop54V+MvGvEHH3D+TZzTZf8BXysjSLQNEzKEZrq2q3YdsX0/GvDsdOjjM\no2Vs2GRWRGLCtLaeSRa97736W36Y8IcN8S1vDmeZdm2V8kVmXyGSAzRaxuhUhrEE7E+mCeQcWzJk\n0OQ18dNPTnPIM5V5SylpghjcMVNzqBU9rFTc74kLe9BfivdPGbRw8HZ+0rtHEmXVDO6sVKgRtcg2\nNvrY4+d07R/FStSl5IS3MVixdrWvcnSLnrckDH0G47mo6zw/4qPx0cdL+zKpZaiL8TkgxNdrA7kD\ne3fHgfNhy84qxSy0aoqquulaTlONAuPxDq83Vgbi9x0wLKDqTnIXof8As18eZDkHAy5FV1ijOamu\nrKiOnKkKqJDzQztsFUiPbe5vsOtvO1LntavEa8QSsslfLUtWym1hIzsWcfQ6iPuMJVtXPUwl5uQy\nTkKdESoToVQFIA2AAFrD1w2g1GdOVGGe+ylA1/Yg9cHVg8XVDdEUVN+JuK6Piiiy+mpqaqo6tKiR\n2XZwF0EKQw63vYi2JP4SxCTIMxIqPiR8aPPZrj8MbG4G+KhiuY0RX16zp5Rv7WN+nW35emJFkOd5\njkbPSw1n7PirlDVEpUySRlHbdbE2Y2C3sNvzxR1Gk/smKLH+781ai1H9zjejnipn1PUVMWUURWT4\nWST4osmyy20hVPcqCxv6nDHwkQNxfKwt5KCocL7gLtiMSTUk00tRVPXyzTapGJVDrkLE+Y7bHbp7\n4I8K5lUZLn8VRlpjrGenljdI7qNDodS3cCxWwN/bBnT8GmMLO7qhEvFMJHd6Lx59V8UV8MOdUlK0\nC08jIkETHQfKS58172Fgb7Xwfiy9DVVEBoKPTO7ltNOCQrX/AIeoO17DpYjES4Mn/ZmeD9oMI+TS\nuj3YExkkLva+lr2FiCRfpg/mGaZfVyRVtfJHG0JlSl5hYgsmoNp0j5SSoN73sp/xYhmYWu4Ix 7Pg\nponW3iec/wCkstCvxcs70dJCIJgg0qmmoFl2CldtXl3B67YYNk8JVXaj5zuWZuUh0p5msAQN9rG/\nvgrQZkJ1p56qmMNTz9LCSYnRIwbSEAJBF1J3NzoOw8t3VPTz6ZFp5i2iR0canUKwYggC/Tp19cQO\nkczdGWtIsKpO/wCmFYGGmRNIJKMwYWB6et9x7Y1HEXcaiI1NzqPb7dz7DfGJEziTSjuEBuUXYWPf\n0H642is0LhSAbkYKUWaQU8CxT0rSKIzGwAjF/Pq6lb9LDff0OBqjzWsOvcAYkNBClTDl8cVHTc2O\nid3ZYYpC9ppLMQQSWN1Wx7D0tiOUgDIRsBJwmbZ0ORFCaVJtD6z8QAwfrYNa116be2J/wf4y59lc\nNHlzUeS/BU0YjidoJV5YX5R5GJO/l6dxfa+IdmmWcjLZKjkqEmYujGKKMC1wLW3AN9xtvbAKllbT\nHHelF1IUywhiDqv1I6m/XsMV5NNBqmU9thSB8kZwaScrpO8s76hLJIzlWOoC5JsT16nCbldd0Hlv\nsLbD6Ye5Xl1Xm1XFRZXl81dXvqC09MGklfSCWYKOoHt6YXrcnzDK8oynMq/LxDS5mZTTNI4LTCJg\nrEp1UBjbe17emLih80J67i2/p0xxLcxPpvcqbYd0kBrajkqVSR9Tau2wva32w7GVlpWRJydiVIS4\nJHW++2BMjWminDHOyFafEub8Gy8KKtHNQR5hDSx1FJyHs8Lx6LAsovruxOk3+Uk3tiveJ87zvPlg\npc3zKozOPLUkNIW1TkiZuYzGQgHUbjdheygWFsDzlBUi84JuFI02IJJA79Li33GGlHzBSTTRVEkK\nIULKkoVmvte2oE2uBt6nFXSwthaQxxOevippnueQXCk5yyOF85p4p5ClNIhiM0cI8oZCocqQehYE\n97A23thDMYHpp5IJCnlc/JGyKPoCLD3GCHC+Xpn+dJllRGGkq0lCzb3h kCFla3Qi4AIPr64Senmr\nJoqed2+KippnZOcz8sRxarb7KSVNwD9QMTcwCQtJ2GfLOfQoOEltjqfshg/dmztqJsVA29t8Pkam\nXKGXkVklW6O5JcCGOMMAHtpuw+cdRY264f8ADdEmY0Oc1c1NDLTUFKKplEekuyjSiBhuFNyz2tfT\nh7wzwzxbxNRo+TZbm9bSHVRRS08QeIE2HKLEgRr5t2Jso3364fjDyWjpv8EPCWgE9VHaTLWlSQRS\nJEL6SpEgDm4ABsLb6judgAcI1dO1NV1FOWSV4XZC0VyrFb3IuAbbHtg9WGsyw1EUtHqngM1PVtEA\nRE6S6SRKAdugt06N3wyFTT0Od5i8lNPBG8c6RxztzJY2ZTpBawubnc23Bw4e4klItbhNVy6qlmkh\ngj55jPmMZ8o8uo9bdv5YawyGNw6g6gCFIJBBt1Fu4xMuFclreIq0U8ZyWnihlL1TZg6LT0UICqGK\n3uAWktt1ew9bNc94WXJOCMjzWpZpK3Na+shjKt5Ehp7IdrfM0hY37BR6nBNJNgpiKyFFtFlQsYwr\ntpF2A6W6jt1GH+S1IoqqeT4ZqhuUd43IKDuxIBupvYja42vhvFVTR0xij0aA5bUR5twVI+hucOMp\nqaOnlhNdFUVFOkiyPAmkLIR2JuGsR2uMJ+Wmwk3BFIrULUwcPx8isrqdoZFkWlarYKI5CdJSMDyk\n3B7bDa+ACGOGOnnhnJqVe5iEZGgDcEN0N/Tth7W1iVdWvwyJQw6GUgltJALMLi7b9ALbA26dcDqh\n4efLyndo73HMUK9upuF2H2wMTSBnzTvcCcI2udJT5pVVYpo5nlpzHBFsFpbtfQdrkBbqehOrqcEM\nw4kSanrZaKhlpoWPJjHxCHQWDEXXqQDv0sLdb2wAzQz/ABQNTGEFvJEwPkQMSBuASNzv0Prhkx1O\nWsBcnYC1t+gwPIY6iQi5rhYUmj4pzdaTmQUuXrB FLJMNIYBSxUNZeZc9fT+NsGzW1MaqJJIqzUDI\ntUlesHPDkuHKM2pT5rWO+2IVQrQrEstRMVqlnUqrU5kQRgXJYfxXJtbsFPrjefQU1JmkqUcOuJws\noVSAI9YDaem9gR9L27YDksL+ECt+n5/e7ZGJXVZz701jRnJCb9e4A/M43CAVkYslwp8pex6jcdj1\n6e2HUdFMIBUCekWLysSahfISdgwsbNsTY72B64U/ZWYBqstTSBolDtdCCQ41AqCNwVIa+2xBxOXj\nvUIae5D1sSCwBX0viR5fGyU+WSRQ0cdqaRubHKnNciU3LDc3HYWvbr2xGxpJFvrg7l9HTVpy2JJI\ny60+thCnRy7nTISdyQo9NiMBPXDnb8FFFk4/cp5msT1FJJeOV5mB8qwMC2gXYE2C2B82wG3riLDz\nxqLCwB3/AMVzg7m/ItJTTyUw5IZdIBuH38uy9Ae3t7YAi1jqNrj/AA33woBTUpDlTfwQ/wC17hIj\nb+/D/wBjYmHFtJktZwn4fxcS5lU5dRrTZ3KssESyO8iVJYJpYgXaxA33Ygd8Q/wQ/wC17hL/APuH\n/sbFqZRKsI4GbRGKyiybP6+EyICYm5sjRyC/QgrcHDvNEHzQt2PuQam8HshqONOMMhbMs1pkymqy\nqlpqhQkrM1VGdWtTYW12Nx0FxvhjH4aZIOI5KSfPM8egl4XXP0mESLNGfiFQIU1aW8pba/U7HFp5\nadXi94ite9824bJP/TiOuQvEMBYgD/6ZR7nb/wAUuEXH0+icAKE5j4X0FE8tOub5nLNHxjT8PCU6\nVVYZY1Z5NPd9THvaw6b4kNF4KcL1PEstEud5q1HRCiimdI49c801TUQON7coBodO17DffB7Pj/vW\nqPp4pUXf/wDEmGfBmdyZbxP4xVLU02ZVFHntIKGiE3LMkhr51jXVY2Xmygnbvh7dQr92SoKluA6u\nXLeOYoKKNZEnnekYMAzCLW fMGtsRpBJ72xJkp/2Rx5nIp8lq88o6pQ7QUdOZWgmlRmKH01IspIG5\nX6bQWhqqzKeKTKKhKSqjq3jmYNdFBkIkBPdev2xZkOcrk2bZrXU9FW5plWc1sdTT1lCvMRAKapgZ\nW7hg04NrdFPrjOmha7Uf3DTXNrusg9/y67q3HI4RexuHfRDMlaqyPw/zvNxGsmazzv8AEQyREfDk\nNyyjoQDdQWJW1txiX/2e6evn4TpY6A1Jih4upJ5+SW0pCtOWcvbYJst77Xt7Yh3GGaS0eV8QSLO1\nBmOeZvNmPwMxtUR0szHysBsGO1xe9sTDwAr6ih4SpUp5nSOq4upKSdF3WWJ6YhkYW3U7dfQYk0TM\nyP34nYPgKr3Dog1Dv4N2oJnlnAGR8QZPS8Tvm9emZZzmpFJBGicuFTmiRNILjz2EyHSbbknewwtU\n+G+R5VxZHTwZpm3LnyvNqmqqGgjZmaCVkYJGdgLKxG9ybdL2HTQjKYPBzL6WR0hj4oraNlB2aNcx\niIU/dFP2xKeInU8WI2oEfsPiXe//AOzNiy7u6V9AoR3phw/wbl+X5n4lcMwSVT5csmRQ1FXNoMiU\nzDnTyObaVFtZLHYde2BVLkGU8ZQeEGUNGYMlrMxz6RYadyAIUmMgQMd9JVQt+tj1vid5PKy+LvHJ\nilddWacOA6GIupgO23UH0xGvDkBcw8EgAABUcSbAWA/eYk2JpAMgKI8NeFeU5lm1ZSZtX1UTyUWW\nV8MlBEoWBqyXRydLk6kXmJ5iQbLe3bEB4hyGqyriCryoUUs1LR5hNSQ1Ry4l6hUkI1Np+a9unpi/\nuF7NxVtuDkvDFvp8VDiqeMavMI/EfOpZajMpMlOa1KVDU0cRYFZ5BoTWB0uvfubHEEsjxVeP6PFS\nNaDdqJCnZ4S8eVU0saxl3PwZpyAGUDSWJ1E+gF+uBNRNM9N8PprRSkh4IWB0ob9fl32J6YO5dxFJ\nmNdTw S/A0pVWKzVE8iolhcFgAw7dhv8Arh6eIpKGCsqKeYRVoZNMU6iLQN1BjTcMLkMSbE7DfEYd\nKw0W58/H4e/uRkNcLDlCpCzBTI5YkbFm1ben89saYl2Zjpve5sLfkMFswy/4LIMhqzVJK9cKif4Y\nJbkIsnLuT31FWNu1h64GRxiSRQHiQMTvI9gthff69vU4uMeHCx4+hI+irlpBSZHY2xskk3LG/rfB\nNMsmbQZjR00ahUEs5McbONAaPobyLzAXHUWPphrXxDL5hHWXiZ1EieS4dD8rqdrqRuD6HDteCaBS\n4SEdy7KxJRtR11fFRIuY6Kyk1SvNLoFtQVAY7LqspJvdm3Aw3rpJMsloaTMJ6TPKGikmelh55enN\n5NLlgNMi6tF7Eg/KemANrDStwt+gO2Mt198RiI3bjY/Rg7j7YT8eKAR+jpcrrshp46rPYqTMo6gx\nQ0py6ylZGF5JKi48o/4rlRsL4ziPk5Yhy2loaeJmlNS0wroqx2TokfNjsAuxJXrex2wIpaOerDmn\nVCFZVbUwFr9PtscKJlVXpJWFVWxIuwAPU7e9gT9sDTWvtz8ZNf6r1s+KLJGB++v0Tg1lHz2p5xU1\nuXGeJhUN+HUrEoOpEXUyLqv31fKD6jDegNGUr1qbKzxaaZ5TITE+sHV5BYnSCtm281x0x0uVVbOE\nCR8yxOjmb2Fv56hbGkyuokUNG0DqRq1LKLWvb09bYK4wP5eqbhd3JfJc5qMkzeLMsuKRV9KoFLPC\noAjkG3MKsCHOnUN7XuD2wUPiDxYeJYOIHzuaTOIKUUUdTLFHIRDYjSVZSpvckki5JJ64AGhqx/4e\nUi5GoC4NjvbCUlPOhs0MgbRrtp/h9fpg/ZKE8Sko4/4sbOMxzVc9kTMq6WGqqJhDGObJAhEV1CWs\noJsLAXsT0GJzw74iNTxZ9xFC8tNW5Zw3Dw9lwmMT6iWiEZII87llnkbYgCwxVi5TWE gKsRvt+8H+\nvTCcWWVUoRljUal1qWYC423H5jAFzDniRAO7lMaXO+Js9y/MK2HOK+szKmrhxDJDS0ahIJo9Kmpl\nNgPlAKqmobG4GOaWfjDgniXOc0izqChz8rE8upkqJa/4h9alUKsGNxrJIGnbuReKfB5lR61h5yGa\nJo5BBKbvHtqVrdVO2xw3+CqQT/d5b9TcYBodxEh44fLPTxGMEbdd8IiMUWm0rmUSxSRMaszVc6tJ\nWRtA0Rp5tbXjN9m6BrjYXtg/wdnlRl8sscFfUrCuV1REILKkcoRmBG+7XF72HXEYFNPzDGIZOYLE\noRuO++FqWnqy55ML3dXjuRa4KHUPrbDzRNkjLHm/gmjc5j+IBI1FTUVciyVc8k8ukLrlYsxAGwJ6\nnEqyTifiPg3KqI8O8Uw08VXIa16WgkDyRSKAgE6sltwPkuV2ucRxstqRIUIj1BS1tdr7E7euwONT\nZfVQxGSRF0AgEhgbEmw/U4PibgA+7CHhdkkItLxTnlXWZbNLmjtNl1VLXUjPoRIJnl5zuq2tcuL2\nN/Tpg7mniHxvFxPTZpmGewtmdPSskMsUNK6cqcBypVFKEm4JuCQeuIgcoqwDdYrC97SXtYb7Y5hy\nmrkKhY0UsAwDOF2J64XGz/6FJ+F/cphk3iTxLTcTV2eVlb8bW1DConDrHGkk0ULRwSMqqLiPWGCi\nwJUX6YY8K8RcZGsyHLOGKyWpr8oFVU5XHFAjyIzxs84W6kuSNXlN7npfbEbfLapJkiMQMrKXChgd\ngbYXp4sxy6UVlFPJTVEOsCWmmKSR+U6hqFiPKSDY9DbD8TLwU1O7lZvHvH2Y5N4t1FTTVMdUlIlB\nBWRxMqR1E9MquVLKNlWfqFsDpI6YiFBFxJWVxLSZxU1NS8k1qOZiY5nZryOoBChvNYG197HbEdGU\n1Sal5aIqm19W23uPvjSUNUszrCwaRNJvFKe9yLHb0OI3hrxTS P33o28QOQVIpTmxyillmFRHTALI\nklPWR3kqi40yyAk381hfa1rE4Rknz80yJMkZVU1SK8QuwALMWufNcgksN7+mArZZWJTszKFiC3Km\nXsN7W+u9vvjqehzCclagtLyVBAlmuFBufLcm17E7YiEbB1bv3flES7uKLcS1Mv8Aslwnl82XzU4p\nYZZIqpmHLnWRgzabCxIJ8xvcbAgWw1osiNXk4qJZJKad5NUeuMlGgEcjM9hvsYm/L82sGVSLNEay\nEy0oazRx1ARmFrkKSCFO4N7HrjioqJ1z1avMudPVxyRvMXmPMcrb+O1x8ose22Da2m8EZ7zjxJPU\nnqf3oLrvicPD0S2a5VUwV3LmrIampanNZOWnsyAuR5ix3YgK1h5rMLi4thhU00tFUzU1QgWeF2jk\nUODpYGxF7kHp1BIwbTPr0kJkzDNoq1SWZoI4FUsA2jzbMeqXJ6+b2wKqVoRITST1zISxJniQN8xt\n0Y/w6b+9+1sHE54w/wDfl++ovDeiaHqfrjR2GwufTGz1ONdcTqNSGDLpqF5OTUOhG4kMY0sbbb+9\n7flhxHHUTLEDXMVa1kaFNjYah9bXA9RtiN06QuzCpmaJNOxC67n0tghHT0qIR+JNchgWp2v1BsPq\nMVHx5yc+SssdjAx5p5RwVFRHFUGpcFSygqikrpYAbHsLKfocKpSzxlBHUqsTlkKGAdLX6W6Hb74R\nEeWtUG1K7RBGO0LjzFxYkelr4dolAYGb4NLiK/MMLL2se242JxE4m9vQKQV3+pXKUcyqifFsNdmB\nMSlbk2Nj263w0aKcVcYWpkYzQOWYIupNxcMPqdzhrT09MJyQksictBpaF3BbYNv23G3bGTNQxqwd\nUW4BGqBlZh33+l8GG0fwhJx+SiXw1UlRDEtQsbE/M0S6bBTv73tbr6YTliqqahMyVLFIYGKq8S3F\nrjR06dCfqMIhMpkVhBC7x6y1jE7bX23/ ACv9McactLw2p5REZPOOU2ojS1v6XHtfA0et/AJ78fUp\naGnqLROJZdYUKNMaGwKi/ffYY29POdDfEgaZNALwr5QTpv8Arc+2HNPSZe9KpNKzpcH9w+r+Xrc/\nQjDKWGhliskTltSqZIYmIO6k2267MPvhA2fwEiKH5S3w0ySyO9RNrIG4RW1Bb2tbtv8AlhAySGvN\nPJWy85JgsbRRKb+XSCD9Da2OIoqOGRgkMjJZVHMiZjc37EbbW6emFWShQ0oFN5WccwNTNc7HYG2/\nTpgh4/IJr/bK6phKWkZpXDKFKhIl76gxBIIBt+eFJaWWZXR6mYoVR2/DS5Bcj720q354byLRNBIo\ngPMZGVPwW62a1vKO+nCFMI5EDVFCE8y78lzqHQ3Pbt+eGrr9AlfT6lFJqadWkX4nUPMCqwqCRtf6\n3BB+xwxmqTBNNBPWu4RRGrJCra00i35fpjJBRPG6RU6mUWBMcLg31ebt6A2+/THchyuESE0wEeoB\nRJCym1rHcjY9DhNxuCfcE7s7H1KVWncTmV6mUSJeMjQgOggG/p1OFKiGq8yNNI5uFLGFLkMHv9/L\nv/zDA6JqCSqLpEGDnSsaxMQNl3/PVf7YchcsLm1LIRvqCwP6bFfS3f1sMIgj/QSBB2+ZTpIJ53Ak\nqWIchG/CUEXNrdOm5wxy+KoIaoaWSJpLKCqKQwFwLi+x6/njlFpREI2gtU8sFWMLkX76hbp9uoxz\nJDl5aaQRVIXV5UVGACi3t164cCrH0CYm6P1TuWOqMExkklPMQiQNEm/lt19bjrhwaathSolFWZGE\nZNkjQggKzabehucM0iy8g82BecE3IgfT1PmtbYWt+Rwky5eFld4SLoBG3KbQDvcnYdrHA0Tj6BFf\n7ZRA08xRUNbs+nZ4UNjYWb22AH5YCV1PPo+IqG1lrLsvUW29ugGHk7ZfNFUiipVeTSdJSJtu++3W\n9hgKPY7Ylhad/oo pSF1jMcjG74tKusPU4wYwjr9cbUb4SSd5ZQSZjVCnhKCVtlDNbUfT69cEjRV8\ndQaeSuaJkAZi7EIoKgrdhe1wVsDgdl9ZNQVCz0rhJh0bTcj3Hvh22bVbT89nRpdIUsQSWAFhfex2\n2ubnEEgkLsVX1UzCwDN2icMMsQjkaWlkaNBY81yWNiO46kHph6zzPQoBBExnQpZQ/kv3YEbdcAf2\nxVhSoMdj1BTb+eOqjO6yWJVdksrBgNJAuPWx3HscQHTvJFgKfnMG1rqLMK+qQzwUDuthHzIybAra\n339cJtU18cjVEuWvYKAWf+AAk3Btt1wJ50qSM8bmIkk2jOkC/oMY9TO6MjzysjdVLEg4m5NHAHr9\n1DzbGSfT7J5FmzLTQwmCMiIgqwaxuG1C4t0v+mOpc2MjRlqcXQ32ksDsR6e/6YGY2MHyWb0g5r+9\nSvKM0bkPelW7nVqJJPyhfT0Aw/iy2pkyyPMcughkaTMYsoipuY3MeV4w69rWNgL3vc+mItQy6Ba9\ntulv0wfp+JHocnioqSMJVU+bxZxFUk/LJFHoVNHcXsb39rd8R8hgJwpec4t3TviPKMx4eziGmCQZ\niKqOSSOSkLlXMMjxSjzKDdHjcX6EWPQ4HSUsmY8Pw5nDW0FKozOGjlVpZA9M0iyFJXOmxjIVybEk\nBb97Yd8VcXy53mVLUUdO+WRUqTrDEk5kKmeWSWY67DYtIQBbZQASTc4HV2bUU/BVFksGUtBWwVDz\ntmBrWKyF7jeHTZSF0LqubKmwuTchE0OukBkcRVrjOsur8lzUwmvgziKOnjrWmomlaExONmOpQw6j\ne3cYLPkmYUeX5ROJKN5K2WjgeIyODTNUoZKcyHTYh4wzeW9rAHe2BvFtfFLxRnBymoY5c1qCJ4ms\ns9LEqRp9VIiVsFqvicy8E5FQrLQjOo8wgnFTHGFeOGljaKm+IY3UkcxrbbIgJvcYLltcchDzHDYo \nJmlX+yq+SgiqMvzOGnclauikcwyarkhSygm2oi9huDa+GL5rI7RmSFZBGSQrtcHYjfbfr+mCXiBW\n0OZcTTVOW/DMvIgjnqKWEQxVVQsSrNOiAKFV3BI2F+tgTbEbw/JZ3Jc1/ei0ecvGGHw8ZDPr3bcb\nAdbew/LHBzZg8rpBoaQ3a0l+wBHTvbf6nA3GYXJZvSXNf3p7UVtRU1JmgSSJtNiIiTYaievpc4Up\n6utpiHaCaRxIsgMmrt226g4HAkdCR9DbGXb/ABN/6jh+WKqkhIbu8oqtdOsqu1DIxXYbkb2I7DpZ\njhOrzComppkelKq62J3sOm/TrceuGMdRNFcRyEX633/njpquoZCjSXU9tI/ywHKF7D1Rc2xVn0U3\no+KKPI8oyilyWcrUSKr1z6mAUkk2IA3Owub7AiwOAHG1Xl+YZrDW5WGCz06tMp6iXcHsL/XvgN8T\nN/jH/pH+WOZJpJBZ2BF7/KB/LEMWjZHJzBvm87334+COTUF7OA7Y6bUuMaxmMxcVZdEHUdu5xljj\nMZhXhJOi9OT5aadfrUA//wCcJMDqJRWVT0BIJH32xmMwISJtctqxydVsZjMPaS1pONaT6YzGYVp6\nWaT6Y2BtjMZhJHC7S47HCgfbocZjMMmWiTjNR97YzGYSdcEtfGEttufbGYzDplognr1xzbGYzCtJ\nZY4yxxmMwrSWEG3TGrH0xmMwrSWWOMINumMxmFaS2CQrD1xq2xxmMwklmMtjMZh0l//Z\n", + "text/plain": [ + "<IPython.core.display.Image object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jack and Sarah\n" + ] + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQEBLAEsAAD//gBFRmlsZSBzb3VyY2U6IGh0dHBzOi8vZW4ud2lraXBlZGlh\nLm9yZy93aWtpL0ZpbGU6SmFja19hbmRfc2FyYWguanBlZ//bAEMABgQFBgUEBgYFBgcHBggKEAoK\nCQkKFA4PDBAXFBgYFxQWFhodJR8aGyMcFhYgLCAjJicpKikZHy0wLSgwJSgpKP/bAEMBBwcHCggK\nEwoKEygaFhooKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo\nKP/AABEIAUEA3AMBIgACEQEDEQH/xAAdAAAABwEBAQAAAAAAAAAAAAAAAgMEBQYHAQgJ/8QAUhAA\nAgECBAMFBQQGBgQMBgMAAQIDBBEABRIhBjFBBxMiUWEUMnGBkRUjQqEIFlJiscEkM3LR4fAXotLx\nJjZDU2NzgpKTsrPCJTREVVZkdJTT/8QAGQEAAwEBAQAAAAAAAAAAAAAAAAECAwQF/8QAKhEAAgIC\nAgEDBAICAwAAAAAAAAECEQMhEjFBBBMiMlFhcSOBkbHB0eH/2gAMAwEAAhEDEQA/AMNyGnerzdjE\nD4QzAX3PQDGrZPeOOJJLFkUXN8ZdwWzDPvDbeMk26Y0qndlCISQzbEYzy9nX6fXyLhSt3x2uQVFv\nFiTpYiGUXG35YqVVxJQZXphVxPKB4kh3t6fHHRxjKwUxZVVjzaRdNh8TjglBtnqxyquzQFYKh8W/\nIYAJXxH8sVmg4iWtYK1PLEx5BwOeJaWaQ0+tEuOu2/0xDTWhpWL1tZDHHrkYIg2LE2xXanjLKoZN\nAlZwNropPz254r+f0uYZlWP4Y6iVVLpDUuywgAgW8O7N132wrlmU8RinZYqrK6LRp7pYMuTTp3vq\nBJYHl9Ti1FVdg7i+NEvnIoeMeDM4poHV5O6Lx7EF ZF8Sm2Nd7N8rhjyxc77vTWZhR08beYSNOXxL\nE4oWSUtTT0+qqigWUjxtGmnUeV7eWNXo6iLKeEBVSozwUlI87LGPEVUFiADt/jjfBtnB63USZbZb\nE72xzrbEBT55O+YT0bZa7TwsHmiE8aCCIhebXs7XJ8gLW22JZ5ZxPUy0tEKvLiKyeKOSILMFWXUx\nUlQAWW1gdIB2I8jjs4s80tdj5YHTFZy3in7TeJKHKqh+9UNGJZFQH7tJHvcbaRIg394k+WD/AKxv\nBkGSVc9JLU1mYUoqDDGCLaYw7nwht9wAOROxIGCgLHfAOwudsMMwzKOjyhswaKZ4zGjqhsjsXKhV\nN9huwuTyxEvxQyVNTBJljxy01xKfakKBgyqoUgEklnAAtceV7DBVgWW4tzwMVql4neeWxyyRER0i\nqGecKVZp2hAUEBnAYXubbN+1tiT4frKjMMiy+srIY4aieBZJI4n1KpPQHy/ngqgJEsNgDuccPOx2\nwAove2ARc4QzzH+lw8zcR8MowYU6UMzxnkC5lGq3qAB9cYEkbSyLFCrSSN4VRBcnHt3tuyPLc57N\nc5OaaU9hgasppyt2imXlpPk3uEeTfDHmLgqjhp807tI71CRCWRzz3NrX+R2wpT4qzbFj9x0xhk/Z\nln+ZRq7+x0KnkKmUlvogP54k5uxnP1UtHmOUSMPw95Kv5lcat7YtCq6xTz2PijRiHXpcdGxNQ1cE\nkQljfw+TCxHxxz+/M636aK8HnDO+zziPJkaSooFqIV310k4mt62vf8sVgFSAdRA9cenK7Mop6hoa\nSLvGF9c7voiW2/P8XyxkXH2R+05gaqggBqNZjmjhBYykmwK25nl6nGmPM26Zlk9PxjyRpX6JuTZm\ntfnOeMJI8mkpvYwGFhPMHDal8wguCfNrdMeloxsduuM37BuF854S4EOX8QhY53q5KmGnEmtoI2Vb\nqxG1y2prchfzxpEYup3PPGz Wzi7PC2X5HNlPEMcgOullRjG3Vf3Ti8tQy1cTezlkLCzMOdj5Hpho\nKOelpfZ6o6xSMEgkY3Lx2uLnzGJPIZj7S6MSVtcb455vyeljgvpGJyeWGWCiydYqWIkGadvFJa4J\nsx2BPn0w+yXhKOKujnz6SozKKNu8tNMX1+FlAFhsu9yPTpi40emoTTZSo57c8PfZdtkFh0xg8z6S\nOpengqKdUZR7JQtNSSOndS3jW9/B+yb/AAG+LXlcoqaDUQGYpqPphPO0ZMvZQAb81Att54bcNVA9\noICjumGjnjCzp7VolYKaOeMG4HLlsdtsPYaVQ9zdt974io5jSyuJFYoCTZRc4e0ubRyj7plPmDsR\n8sKL8Gc4ybtEgFUkDmDsbDGiUNNFLkkFPOgkhenEbowuHUixBxmkdYBY2Fr9cabk795lVG3nEMdn\npn2ed6xNJWEq8py+snE1TRU8kgcyBiu+qwG/mLKuxuNhttjk2T5dKkatRU/3QAjIXSUAJNgRYgXJ\n2B3ub7G2H554F8dSPPI58jys0SUi5fSpTRv3iRqmlVNtNxY7bbW5W25YUqcqoKihjo5aOBqSIaYo\ntFljAUrYAEWGk2IG1iRa22HvxxwnbDsNDOpy6mloa2jSMQRVYbve6VbksACbMCDsALEEWAGGlBw9\nl1NST07U8c61Ds8pkiQaiSDYBQLAFQQByO974mOgP+eWBqGABnTZXl9KrLTUVNCHZXfRGBqZTqDH\nzOre56788L01NDSwJDTRpFCl9MaCwW5JNvqcK3wDyNjfAFoL1x23XBSbC/PmdgcGvzHXBYFM7YI2\nqOz3MKZAT38kEbAdR3gJH+qMYRwdlwpsxSepTxVUABuOZDE2/MnHoPj2WD7Op6aoPgkm79wOfdx+\n8fqwGMWzGCJMippKF29ohncEH3gFcr/MDHNmbWkeh6NJ7YWfgmkkzhKwT1cgEnegGoIBFvdtysDv\ntidShW OGogU6i0Q3J3vffDTKM1laJUkU32G/TBqmqzikqZmo8rjr4XFkZJtD382U8gORxhaOxwlb\nRD5nwRRZtVJPIspGgpvUMoBJvqCg2BHLbAqYFyziSkXL9QkgRapLHcsjLck+ZA/LE2K2rpqeNZ44\nlqmXW8aNqCnqATzGG3D1M9fJX1swKyWEUIYee303N/lhxdMicfi7N/o6hKqmiqobGKdBKAB5i+/w\nvhzEPD8/TFd4OrBVZNALWAQEX8uWJ4Lt0x3J2jx5KmePqXP8rzHKvaKnMYqatij0zQSnSxcD3gOR\nBGFeHa1J1p6qE3SeMOvpfmD6jGS1sZEx1AEjlti39nNegd8ul2KEyw+qn3h8jvhSxo6o5W6Nqyx+\n8UMpAA5j1xORzd3EWYjl/m+KFQ5i9JMsQs8TKWuf8+uH1bmMyK5rIXjoF0mRx4rA3sSBuF8zvjgn\nCno9TFJNUx1nWYU8k9F38pSGR21G9gFA8/jg3DC9zELDUdRINx4hfntiHzajhzvL4nynMKNnS5jK\nzKyN5i1/44hKCiz7LptFLBJ3w2sZFCH5k2w4wTVPsqU2n8do0usqRvJbSznkN/Q4gc3y9Xiapp6l\n6KpiG0qrdW8gR1ucOMnpZ1iQVc4rcxkFzFB4o4wfwg8rebYLlU9TmNRUz18C08MMrCngL6iVBt3j\nH9o77dBjndpm66FeHBmdTGi5qESQMF+7PvXAI+GN5y6HuMvpYre5Eo/LGW8G0ftueU8LoTFHeZyf\nyxrPqeuO/wBMrTZ4/r5fJRA2K7nedyZdmqw6oe4EIfT3JkkYkSHkCCR4VsU1fi1W2OLFgb32Nvlv\n9cdDVnBF07KUvEWZSU9cYHopHooJZy3cahLpWMqtkZgLl3F1JtpHUEYc1nEFXQVvs1Q9Ozw1IjY9\nxoE0ZkiUkEtsQJGvpBsVBJAxbCSRzNuVuWACy8iRhUac19infamaMuXNU1VNAlQkFQ7 RUxUASLKp\njuT+0qEHne3S2EZM+zGgyuFaiaN6k0kc6O1PbWxgZu7JYgXLIN92OogAcxeNR/ab54Gpujm3PDoX\nNfYr2dZpWxUcVRlwhscvlrT3kDSBmXuysYsRa+tr9fDthjmGe1lBVtTSvEzwT6btTaROmuMXG/QM\n1wgJ2DGw2Nvueeo3588c1MBsW+RwUJSS8FMo6zM44ZZ3rfae57uORWhsWJqJY2sRbQVUruOdgTth\n5w9mk9RXLSTNGQKcERpGbxlVSwck6wTcixBDbaT0xZWY3uS5I9cAksLMWNvM4minNPwZx2lDNHqa\n2KgpJ3phTQM0gi1BSHZmsemw3+GMhnGZ1WWTTZVSz1U0ZiCpBGX0oZQ8juOgspX88eo2JC7EqOX+\nGGkaUmXtU1Qjgpw/3lRIFCagBa7fLpiZxT2VjyOKpHnqiqKWvi8KAo6k6dRVlJ+B6YbfqxUy3MZj\nmjY7NUVT3X4i++EM1yZrGsyu5RiW0E2NiSdvI4jY8/zOFO7762nnqG4OOOUVej2oOaRPvDTcO5c0\nKCE1E2zMu5Y/E72wOHc2VI/ZvaB30rNpuCFUE7n/AD5YruWibMa41VU5aKIhmZuXPcD5dMemMvrc\ni4lp1novYavUoOjSveJ6FTuLY2xwTs5fVTlGhl2fSB8rIHJRYXBBBO9sW2LdBfDeOFIQwjhWNSbk\nKlvywvFp0/PHVFUqPLm7do8bdrnZxnHDuZZrmPshfJvaGkjqV2Qh2OkW8xe1hjN8oqGpc3oqhCRo\nmW9uoJsR+eN1/Si4wSvr4OHaKUPTUTd5UFfxT+R/sj+JxgrL3dHBUg3USkG3SxBxe6BPezYGc95o\nP9YjHSb8/wDO2LRk+YxZhRrFIF9oi2ZWOzj1HXFQgcVUCSBh4rOrjyIvhSOdqaeOQBUqIyGVujjH\nFkhy0elhycdkhmXA2Vy1hzDKmqMvrLG7U7ixPwP8MWnJKiOGoV q2jgqpRKzliBGGVhYgra3MA/XD\nCkmWpAmhNtfvC9vF54l4GMigShNSjc254wba7O2EYNdEtW1+miWnpzT0cagqYabxuwO9tQFhiGpY\nXQOCNLPuy3vYf34eLC1xpA0bX8ycFkZaeGaSSyqqszN6Dck/K+MpXI1TjFUid4Cz2ky7Mq32hWYP\nIItaEXS38jjT6Sqp6pFME8clxfY7nHlPhviEPnGXzTFVjzWi9oFiQAyzyR/wC40DLs/NFP3JZlUc\n1v7vqMenjXGNHhZ17k3JG5kgGxNj5Y41idiPrjPqfPswEKPBWGSO1wGAYH0v0w5peLHkJTvwJl96\nKQAH/HFckYe2y7n446efniqLxQyMNSqR1BFvzw5g4pgJtNEV9VbByFxZYhjuI2lzmiqT4JwG8m2x\nIB7rqU3X9objDTFxYbHDyxwMCL46x23wxCZU6ieg5nBZJEj/AKyRV67tbFaz3PTHLJBSt3YQ6WZe\nZbrY9MVZsweWchtTHmSbkn4nDcdWVFW6LTnfGdDQyVNPSq9VWQrfSfAm63Hi5kYoudZ5mecQj2sK\nKYorJHALRKCOdurb23xEZwzfrZC8almkp1LrqF7AsASCRsQefpjlCaiTh6KHWiT92YUaQBiCLgGw\nNjyuPO2M8y/itHR6XWWpDBZHiQxMNQG6+mEJIaOdPv4UdjzJG/5YlYaUlVjmRlZbXJGxPUjyvztg\n32dCS0pNgp5DHnbPX5pkVHTRin9np4gkZ3NhbbDnJ+FYKcioSrqonJ1KBbb4eWJRaVZItMSHxi2v\n9nbcj1AN8OqSMQU0cZmkl7tQuqQ3Y26k+eNYWtmOVpqiYyyuq8tp2EeYVjsAWvJKX/I4uXB2aVGZ\n5U81XJHK4lKBu73I0qd7dbk4yfNap44JZFdliWNwSq3uTsPXmDi5dneYv9gFiWUvMWPdDY+Fd/nj\n1Yr47PEn9To8b5pWSVtVNNM7M8khZmLXJ J5k4NlempoqqkJGs/eR78j5/wCfPBZ6aPviQxXe+G/j\noaiOpjYMFY3BPMeWJjJFOJauCs7EK/ZVcwjdDphY8gP2D8OmLrIgN1kFx5N0xmWbUsdbTR19CdRY\nAsAbFgOu3UYkeHeMO5jjps2tJCNlnGzKP3h5YyyYqdo3w5lVMvNDUVFBOShaSEncdR6jzxd8qroq\npFbXfbflcfEYpFPPFOqy08iyId1ZTcfXCwUCQsA3rpJBPzGOWcOXZ348zj0aS1eIx/WIqgXJYdMU\njtGzhv1dqYqMjTLG4eQctOnfSevMC+G+VUBqaozzl2p47WDMSGbyxDdqNaTlVXISAiyx0KbbX3mk\nI9AqRg+rWxjGCU0jaeT+NyK1ncr0GS8B1C3XXRVO56r7U9sXlczFZlsM8hAZRZiB9Div9qOTTJw3\nwrFErCTKeHKaomW29pZTqP8A2S639L4Q4PrEqKKNJDdSND+nkcd92eVDWi7ZFxLJTBoJCTEw/a8O\nJrMaqKrUOk4jqVF0ttf0PmMZ3NEaaVoiFFjsSemJ3J61JqdaWpKB13jcj8sBbRKpxFOhZZWs6W1q\nOS/4euHsHEpDONRC7W3uLYrmYozoFUD2mK4QHkw6r6jEPDKhimaIlU8II/YN91wikkzT6XPS8YOs\nH+OJui4gnpZA0FQ0e9/Q+lsY1T1skNr3W++5vfE1S51IAoDNbqD09RhozlE9BcPcTxZjOlNVhY6t\ntkYe7J/cfTDzizM/svJ2lU2mlPdRjqCRuR8BjDKfOiUSSEFWB1pb8LDyxbuIeIzngo6k+6KdQVJ/\nH+I29TjSCtmE41sZTVpUkXNxz3vhJJnuDqvY3GImonEZeRkfnq1DkR5YkIZvdkFgLbC3MeeNnEzU\niF43Zkhpqij1LIZGDsWY6Syg+HewB7ve2G079/m+XstihqYKsBGIUiSN2LWBt/WBvTe3XEjxTDry\nozNoYI6PpYkcnW5F v3S3PFfyycU09NBMqrOYTGoDAaQhEgWwubAo3/fwnDljaHGdTTLoYCKtal2l\nL9z3OnWdFr3vp5X9cGKSiWKnELtDKjlp9tMRHJWHmfTD5bMgJBII/I4VGkLa2+/P1x5HHZ7Dy30M\nEo4gad3VjLAGCMWItcWIthadtMfl8cKySWDHm/QHDdzcMd7E8j0x14sXlnFmz3qJXOJ5dNPGgYEh\njLyv7qNb82GLDwHNo4dpgq2HdxHr/wAzHir8VTA1ARG0aqeQA22JLKLH46bYsHAYD5VOgBtFKsQs\nxOwij9cd9fFHA3TPN1ZMxksNthywmbyI66mAPrgOoYi2+FkUBiARytv5Y5Dr7GOX1slBPdtXdNs4\nB90+Yw/r6P2pFqKM2lcaioPgk9R5HEfWRjvL8hIefkcCgqZKRtG7R3s0Y8RU/tKOvw641jJPTMpR\nro5Q5lW5dMfZ5ZojfxIdx8xi25PxXUySxwzwM/eHT3sW4HxxOUnZtFneVQ10edUrxTx6oKiBS41D\nmrjnseY5riqUc+ddnfE7Copk77SRJFIdUNVDf3kYDcH9ocuuMpuL0ns2jyhTfRqBzT2ehjWIawNI\njjU7ySsQFB+JIxVe0qjds74X4UWYyTWDVDj/AJSeplAZj8gbelsTcGfcNPmmUZpRGqSneOU9w0Op\nqOcEDW4Xmuhmsy7XJNuWGfDEkHEn6QlFXRuk9B7a7UrqS4ZIYTo358wDuMcuOLjJt+LO31OVSglH\n8F94ghSu7WMzyyVA1K2Sw0Z9VcW/gRjC+D5ZKKskpaolZIHaFt+RViD/AAxt2cnu+1/OwHVHahp+\n7Ybk6Y0J/K+Me40ojl/aVn0ITQJ5fa4wTsRKof8AiTi4PdfhGDWlL8tFmry0gUl7sDbfDWOR42U7\nWPnjlBP7TTC7ePTb4+eBKAHIBF/2f8caglqiZFX38UaFiJAbfHEPmx9laSqFnicqJ16MN/ELcjg8\ nbMNJB+Ityw8IWppZkezhgNreuAPwQomEWpo5Wmpwf+3H5X8x64cpWhdJZgR+E3O+O0eXNG70bsiT\ntdqSRuW+3dv5qfyNsQc5SJ2iQGPTyVjujXsV+Rwg6LOaghUYbq4urDcXxZeFc17/AC2SmkJ1xXYD\na1jjPsgqzJNUUDWto7+Enex6j54ksir/AGPMqUu2iGVu4kPo2wP1xeN8ZGeRcol/qJCaaZEYgkdf\n8+mHeW1SyLHeTxsoNvPEKZ5KOCRKi7qjbsRe1788V6taop82oWgnDwlxrPkLbY7eJxWaDnSJPl8k\nUjypDIrRu6C7rcW2HxtilJmVDHPQy09DUSVEq6JJZ3AAWQ6Wby/Gu3qMXCOdpaLXYWBBBXc8/LFI\nakr5IqyCGKCOOM94hlkZpIl8RUqgHPSu99vD1xEWkvkDi30X7KKl2y6mkfULxgHry2/kcPlqtdtN\nrWNz154h8lmlNCPamgaZmLMIWutzvYDpz5euFmm0uQx0hbAITY7/AO7GTim7NVJrSJIyDlqv4tge\nfLHF02uQ1x/HDZHRlLAksNxbph0o1KSQBp57738sAim54kNbnVMntxhqhDq7uYaYyBIdw/n722NA\n7J8odshrXm7ti1Y2kqRYqI4wP4YzPiI15zycDKDPSwQMmpXUuqXN3IP4bt7uxNsXvskmWm4XlSmp\nfZ1NSzNG7sCCVXp8LY35fEyrbPNkdg+1viRzweQAtdSBgijxcxfzwrF94tyNr2xxs60ITRak0m3i\n5H1w0pYEqqiKGSeOmZzoEsg8Cm/N/JQbeLpfElOtkBH4TiPnTTMGsNMlyR0JwIUlRZ+FOI804Kzy\npppaezCTTXZY7BRKV/HG2+l7EEMNmBHPG2IOHO0XhUIUWsoy/L3J6SXfYcyj7fA/PGBVqvnmQCZ2\nZ8xyaJQX5vNRXsrHzaJiFP7jDoMSfZVTZxWcVxPk1XPQTRqfaqxV1RrHYgFx ybewA8zccsZZMace\nXTLhJp8e0RlRVQ5HxBmVDTVLVVHBUtAaiIiIzhCAOhsLg8udr4l8uzmbhPOMt4no6Jmq433gmFop\nIyum1x7psbg9PXFMr8uqcnzOegzKEpV08hjlRzzPnfyI3B6/PEzPTO/CdSitJLonUM8cxKuwFwmj\ne9gD8xjRx1Y4ybuL8F/z/jOhzLtWyvOKBnjpZ5qWJklFnjVoDGysPQsN+vMYR7c6f2firIMxHOoo\nzTvf9uKQgf6rjEH2t5RS5d+rmbZJJry6uy2MRS67t3sAGzH9qzKbbcsWrtlP2rwJkWdw2dlqY5NV\n76RNGb/mq4y1yjJfopfS4vxsruWyFWV0sAy6ipHI9Th/VMpswVbE8vL1xD8N1STwRB/cFlPnY88G\nkqZKOeWKok8MLspKi5A8v4b40a3Q4y8kjFIrdfH+0dr4dx0hqdYp52WTbZRc88VNs7iEjGgy+WVu\neqa4W3w9cJHiTPniqIoZVogAthClrbjrgoUpouxy2uMVq6OIRruHllVByF+fpipZ4UkqpJYpI5zF\nJ3MzpuHFrq9+vLSfMqPPEDNBVVcqPmFTU1YNiQzm2H0Q0sI9tEi6DtyB3/IgH6+eChW2cpKgU2e0\nUwIIY6T6i+JXMYwizXIUpPpNjuNj/vxWam4mgLXDLMyEW3GLVxBIrUk85UHvBBKSPMhlP8cMX3Rf\n45/a6Cjqgo1VEKvYX961jf5g4qwp6mbPStFH3qU0b1kqg7JGgBZvlfD7hSrep4XhsSz0sskdgPM3\nH5E40LsiyBK7KuJ6+oUFqiGTLYgR+Huy7n5nSPljs5VGzka3SGGV1cfsrsGRrrfbb4/3YqdXLJNm\ndRUQGqgldBGxgqiveq2oFGt+7YW636dY1K6RqCKM3VX0hlvsQbX/AJ4LKzOZmhlISZNF3FlRQ/S3\nXYEH904tQT7It+B2lUlRH3sbzQa1+8tANTb7i/Q3ABt vYDffDOTOcyiSYUmZRlUi0qofV4lQLazg\n9QTtvg5Y0s6apO7Ey6gdX4vLfkSPzxyTL6eRZFWRInLsQ/eC1/XzBJ6dMXSJ5MmMszDNazMK+M1k\nUcyQB6eIaUDMR+I22v59MI03FWeRyS0udcM5iSvhfu07/wCe1ifiL4Zw089TUQ3Z4amMkrNTOJNB\nYb2uPEhFrqdvhzwo+dZlb2atoaOsQEnvI5zHf10nxL8NRxw5U70dWNrjska2uyHPKaoonrTQSuDr\niMoTxXJu0Ulrnc7E9BjQ+z6oj+zK0JmNIyrU6RZF2tFGPXyxkE0y1dKsldT0sjOCFVgJCg6KC18a\nV2U5dSw8P1Sx0lLEDVElRGvPu48Skym19jz3zOwwtE5QgICLdMNFO5B+vT4DCii7AnCexofOdaEH\n/diPnUyQMACWXxD4dcPFawAI+IPlhs/gnAO6X5Wve+BaG9ncmzF8tzCnrYI++aJiGgOwnRl0yRn0\nZCy/LE5lGYngDjmKekmeXJZljk57VNDLupI/aUW+DIcVQq0U7q+xUkD164nZE+2eD5YtN6zJNcyD\n8UlG7feLb/o3Or0DEYH9mJOnZfO2ylpJ+J8lqdEZdaKdakyGyvDGwCEkepIB+GM0hilgmr4Ennjv\nH7RDIv3bagbISvQsCRboN8P3zyozuuyFEgL5lSUJot90n0tdG0+eggNfa63wQUyqs9RS3khICzJO\n2kEXOoqTvYC5v0+uJxrikmXJqdyQUaczyYQU9RIvcMkrQSrptKVCkDzJN7ctgPLF+pA2b/o/VsYF\n5aOA79QYJgQfQ6ScULK4zLVpGAktLVMSxckNZFIvcb7gEgdLYvXZbWQV0WfcMMpj9ujqHiR2vctG\nVZN+otG2JybSrwVBU2n5RQOFqgrNo1W8r+XPFi4njCZjDVopK1UKS+RuPC3z2JxQsmmMc8R5gqB0\n540nNbVXC1HUizPR1BhJHRJFuv 5hvrip9k43cSGEUEq645pyjHcE3sfLB/ZysEvje5AuC/qLYjhJ\n3FQSRseZH8RiXic+zVJup0IGBXa9zgLTEIZFSaCEo8jO1roL6QPPDTNYglY6hbKyg7HDymhkR6uY\nsHJ3QLtZBy/nhDOgGKyjwnkd+Y+GGJEHmjH2incm/eMDf1HP88WSsbveG5mK3ZIgNvJZL/zxWcyS\n9NG62+7mB+R2J/71vricLh+H8zS4PdpqAvzBIw2QvJK9n9SWoa6BZRHKNEgDtpDbFSL+e4x6R7Jo\nvZuAcvlmADT97Uy7jkSdifRRbHmXsuMUmYVkEpY6qdmVF/EysD/PGr0GbV2V5NXZZRunc1iMuhRv\nGWtdgemwtjpS5QVHNJ1KzPqt7d2Il0prJAt+HcjEfDNURNG6ylA+kiyoqgKSB4+f4ibW6Yk82yjM\nNRNLTs+1hosbXFv4YTOQ5rHSQMsS6YowmkyXe4HljoMg9LVVQz+ib7iqELhtFTIWWwO+9jcHrcWB\nIt1wo1XKZGEGWUURdgAC5eOPxm+nYX976AeWEI6ephqoddLIig+Lwe8bHmcJ0cqTGSJyDIupyGBD\ngXO/w5YniltDTukS0Mgic1PdhFBOgoLAdALc+mGBlk0TsCChFvFbzxypmVYWd3AQv7zHSBhrHUqV\nUw0081n1FkjIt8+WOKWRJ7OuOKUukSMUZeWOEvEVWw28rY0zgDv1y2tVIX0iq2Pn93HjPeHg888j\ntHDEL6WafVcfIDGt8GTzpQVKxz0ZQT2Gksth3abW3woZYS7ZpkwZIpOjymxs3M8rYVhJDAm1vrhv\nERLGkm2/MC2HESgNdjywjOxxNst1U78t8JTkyKjW57G2HKrfz54RdT3MigG4a4wDGdfdpIpd9xpO\nHfD2anKc3p6xo++hhNpoW5SRMLSJ81OE5oTJSeH3lN8MY9yAblf54bVojpkhmWWfYnF60cD97TM4\nFLOW8MsMo vE3wswv/ZIxPZnHoRKdJSjUzLFDOFA9olB8RN/W9/kOuIKvnM+RURd71uUzrHGx5yU7\nsWUX66XB+AbEjXtT9zIyRLNlqExJH+JHY6iw325222tp6jEsuL+LG8QknoRM8BQ6hSoYWJIJZWKt\n025XHPCzV82RcUZfmNHKamooZ1ZXJ095pPijNuhGrf4YVyp2ijM0k9pYlapSZraJzYBDp6WvyPPb\nEXXhhXGLuUWYLp0avDOoF1v0HvdMJLdD5UkyKre6XMqlqO3soqH7o7j7tmJX8rYvfDsxrMgzKjUB\njNT94gPR4jrX8tQxn8i2lnVb+IXF+YIOLVwXWimr4JGYFQ4Yg9V5Efni5rRON0xtOe8RWXkdwL8u\ntsSeXNroalWtqC/zGGldSmlq6mkvcwSFB6gHY/THcvbQtYCTYoAPmcSakplisG3/AGdNsJZhHqgI\nK3uoOF6Gw/EQeXxxysR0YagCCDe+AEVtU75WgAsZVKC/IG/hw5oGMuU5kq7PJSNt5jwnDeYGnqAw\nuCpDD5b4kKKJBm1REWCo4ksegVgT9NxiqszYTs7qTBxDTkbGQvGCDy1Kbfwxpz1JS1rszKAvSw5D\nGM8LyNT5lSP+zKtyTbzH9+NJrp7CO12C2Ft9h035dcdWHpnNk0WX2gxxyP8AjjUKDsdzztfywosh\nWWGPUALFnI/jiErZbUCst7B/vLcv8cdinR5roo0lRc/5tjRomy3QOJnRSV0e9YnY/wCOIjinSyxK\nsaFASZJAnM9Bdd8NGr3EdXoUhiugMDuOm58t8LSyZwKcLGKRGVQAHLIreuoAnHD6rNLG+KO/0Xpo\n5U5PwVzMHnoJo2oEldwNBdYDIqhuZJbYD88doauKog1VvEGb05I3EUEca+XPSdvnh7WLnpYSVNTl\nNJCCC06yyTsPgp0/mcVmHPI6Kvmp/batY1bSKuliVQ2344SdJF+oN/jjjuWR2j0koYlTZM 00uTQP\nd84zStYEWVqhQlzz8KKCcaPwTmOXyZdUmOkq7e0W2iIB8CeuMpps7kkDd1mlMoJF2gpGLH+FsaPw\nHPWy5ZVMK2tYe0bGUpGf6tOS72GCOKbfQZMuPjVnnbL38TRbaTyxIw3D2JAseeIMM8coZTfSeWnn\nicgtJEJI7k7X25Y7no8RMMsh2It5Yc03iYgkC4PNrYZvNBTKO+ddXILte+CpW1M9zSwpDEdtTjc/\nLEvZopDr3LmI7Dcg9RiNqY+7q2CGyX1pv0xMREgOHdpbpbUw3GI/MRcJIB7vhPwOFYSpjKpXVCwb\n3xe58gefy64nEd6mKkkgApqh4FgpRcIs+wVmJPr4QfPEJfxhW28/UYkKHvpMppDK5ZYJzBEUsWQh\nizXXnazA9OWG1omI5y+pX71KdEVZJdc9JINrc7qxOxO5sPLDCRlkZXQFqfVcx/ijP7ovc8ueHVSR\nFTo8krSRatFPWA3ZFGwJUHnfofLnjkAkFWumYQ1bCyygkJLyHia+3qPTCsGRVYjJOrM/eKBu55kH\nqbdfMYcZRL3LnSPdYi3mMJVuptbiNYT7zoPdBIPiU33v1GCxN3dUWKgBrHYYrwJdlsz0F6mKpP8A\n9TApJHPUvhP8BhjTm0FZe+yL/HDguZ8mjNgXp5Rc+SnY/mBhFARDXabEd3/PEI2bH2VzCRAhNxy+\nGH1clobajZRYE/IjFfoJShAG388Tssnf5e8kYKyKrHf0H+GALILMo+7kXSBc7W6YSnI7iCRSS0qL\nCTy902/hbD2sZZ4QQOZ1beuGE9xlDqCP6PUox33AYEH87YpEMjaCo9jzB53VH9mqO8KHk2mS5U+h\nFx88enO2XgzhvI+Fs2zvLqeShmhZBHHFKe6lLsNK6D7vX3fLHl57vPma7bmQ9PM49H/pH55FNwfw\nplikiTNRFXaRvdUiUC4+LN9MWrsyntbMgoOINMMimPvI25ox/nhxl ObxLOFVSqMLgsb29MQ4y0xx\nBUniK3K+IaeQ3/nhKppTRLAXe2pDceRx12+2Y2i0x1jv7Sk5ZlYsTocgcxbCcuZ0bB71MkH/AFte\nzf6oGKzTVEkZQiVgbMSfXHJnSRizaNW2+OfNiWWmdXpvUTwJxSHeZVsksTezVGpOra+Y9AcRTOB3\nYJDX3FxhVLGAjQGCyAFrX03vcYkTl8csQjUO8wtawNt/8+eDHi4KkRmzPJK5EakxjiKxMVax5Y0n\nstq5TktbqllB9rPI3v8AdR4zzuDGxUwsFseYxoHZrCv2RW62APtXn/0UeLpozMgqImjmddLbE9Oe\nFqRq7QY4CwTr4Bt+WPaZ7Euzctc8KwX63qqj/wD0wp/oW7OQthwrSj09on/28c9lXs8aQU1mBcd5\nL+0U2H5YeLGQ5Ux36k2O2PYC9jPZ0ttPCtJ/48x/9+DDse7Pgf8AitR/+NN/t4ktTSPIio3d+JW1\nA3vbCckXeqUKsdY03F+ePYI7IuAAfDwvQ/OSU/8AuwX/AEP9n9z/AMFaAC/7cv8At4VD5o8Ud1IS\nbI5/DsOeJDJzULJVRUxVKuQKIA6gBg3he5tuenwvj2Iexzs8JuOFKC53/rJf9vBo+yDs/hctHwtl\n4fSR78vLr+PFeCU/J5Hn1vUOtGO5a5TumiURzKBe5PrubeuE071e+EEAYFbSUboBovcDQLbi3Xnv\n88ewn7J+AnjSNuFsuZI7qgZpG0j/AL2OHsn4D1K36rZdrX3WvJcf62EPkjxdmDSGNjF4lt4WkjUO\npIN1O2wwyKPpgkCvY3W1se3G7JOAXJZuFMrJPXx/7WAOyPgAW/4J5WQPR7/+bFCs8i5OHlSSnKsF\nlQgbdbeH8wMIo8j01QQHB0+IW6X3H1Jx7GTsq4DjYMnCeUqwNwTGdv8AWxwdlnAp7w/qnk/iFz92\nf78SVz0eNYbpIpW4v54m6Ms9I0bISG3tp3J3 /LHq4dlfAYuP1Tyb/wAIn+eDxdmfBMLApwtkykeU\nJvt88IakePIH1U8akG1iD5+mEwjiGrjA1LLERawJuNweXpj2MOzHgYnV+qOSXO5/o/X64MvZrwOp\n24RyMH/+PgsTZ4fpmkmqqpRYd5qGyLte9uny+eNd7TMwgzdeDJJqcP7Jw9Rlm0g2dkvsPpj0EOzL\ngUXI4QyO/kaa+/1w6m4C4PlMZk4YyRzFGsSlqcHSi7KPgMXGaTtkNao8ku0LDZyjKNHjQDex5Aj1\n/PCNRD3oDiZTqu19A8/THrv9QuD7/wDFXIiQdiaQGxwT/R1wUdzwlkHzo1xt76Zn7Z4/npZyg7pg\nb+QU+X9+HNNDMmpWRO8AI8Sp5W+u+PXadn3ByG68K5EPhSLhT9RuEr3/AFXyL/8AqLfC95fYfts8\njr7R7PVBWXRGsd2WMC6XtqNuu+ADVs8hedNSC58ZA8jtj1m/AHBrc+FMha/P+hrg68B8Hf8A4pw/\nt/8AophrOl4F7Z5CkVFkJlmpywte+je9vPF44BijkyuqdDEdVRc2YDfu09Meik4J4SiN4uFuH1J3\nuKCMfyw4pOFuHKeMrBkGTxKTchaZQCfPB76YcCdwMdwOmMCgukX644F54NgYACWHW/LpgrqosbNf\nCt8A8rYVAIkKbWBxywvbfC3TAt6YKHYjYXwawFtjg9t9xjp8wNsLiFiO17DlgxXnscHIHzwLnyw6\nsLE3G3I35knHF5Pe/LCx36YKAQG5csJodiQF788cPrfDgX1bj6Y4w9BhOI7EcCw6YVF7+JVxw31D\nwpa/I4niFlW7QOMso4G4ffNM7kksx7uCnhAM078yqg7Cw3LHYD1Ixm3Efak+eZHlMWSS1OTZjMzS\nVUcb95oAS6okqixW5F7ANyw1/S6y6STh3hjMl1aKWsmpXAA0/eoCGPreO3rfGScCQz5qmTZbkYWL\nMJatUglnkAEU2oPqHku 19NrncYU060dHplCUrl4NtyLtUzOkpqGnzSkir5FLrNNqMM7qptci2nXv\nfyONXyTNqHOsvjrcrqFnpnsBYWZDbky81P8AkYz3j7g2Gk4Yr89zOUVnEMNUlXJVyKY0SNpEWSJR\ne4iCE8zfkegGGf6PtZkkq5nBl3EMOY1hWy0oVo2ECNfvCrAavE9tW/ht1woxlewyvFKNx0zXfhjl\nvrhU38hgHbmFxdHPYkMA4V1W/Yxzb93BQ7YS/THQ1hz/AIYMNR5BfjgEG/IH5YFFisVwOuAdh1GI\nyszaOmz/ACvKWhmaevinlSRdOiPugtw297nULWxolZBJ4GOX2vgX+OADuBjm9xzxw+l8AHee2Cn5\n4MRt1wUgm2+AA21h0wCdrXxFV2bJR59lGVPDK8mYxzyJKpGiPugCQ3Xe/TEnY+Z+Hlh0Bxrcy1h8\nMRWc8RZHkJiTPs7yzK3kTWiVlWkTOoNrhWIJHwGGHaJnFdknDDy5O0X2xV1EGXUBm9xZ55BGrtsR\nZbluW+nBuF+Csp4cDNT0yVWZu2qpzOrUTVVS9gC7yNc8xcAWUXtbnhDH+S8Q5HnwkORZ1lmZmNdT\nrR1aSsgva7KCSPmBiQt7xBuLeeK9xNwTlPEJEzwpRZ0h1Uub0kaxVVPJYgMHWxZd91NwRjvAGb1e\nfcJ0lZmcccWZIZaSsjjI0rUQytFJp8lLLqA6asIFssagev1wCAWHO+O2N+owLNvueWBh0EKbjny+\nmA6i43PxIx0hvNvrgeLldicKh9FT7VMlbiDs24iy2BYpJ5aN3i76LWNaeMWHRvCQD0JBx4UdUkVT\np1K4Dm+97788fRhS6te5v5E7H0x4i7ZuD/1O7QK+hhUjL6k+20IGw7qRidA/svqX4WxSDdWRkHEn\nF+d5QvDEOZ53mdHIgRcvVnn1ItjYKoLlV0g2vYWGNy/Ru4A4l4bzvMc74hy85dTVVD7LBFO6idiZ\nFe 5QX0ABTfVY3ttjz9wlxDV8J8S5fxBQH7+glEhQttInJ0J8mXUv59Bj31SyR1NPDUU+ruZkWWO+\n10YahcfA/lgf4BhmG5Fzb4YKRY87/EYUN9raj5npiB44z/8AVTherzl6VqsQSQp3IkEZPeSrHe9j\ny1Xt1xDTKjFt0ibsD/uwBbl/LB2RkdlBJ0ki43BwArX64ai+xACgAeI/TBWJBsG/LB7HzbHCpvzb\nFOxCvTn+WIyt+yjxJlAq+6OcmOo9gJDau78Pe2PK3uXvv5YkyTp5DFTz5j/pM4M5702Y7Dr4IsVB\nb/ozl0WWuq6XL6GasrqiGmpIU7yWeZgqRqBuxJNsU1e07huZO/oUzyuo+ZqqTJKqSEDzD6Nx1uL4\nccZ8P1XEnEXC9PUwxT8M0ks1dXQu62mmRQKdGXmVuWYjcXG/TFwDSkaVMmwA2vb6D+WEqqx0yJ4Z\n4kyXiiges4fzGCupo37uQpqVom/ZdGAZD8RiVkMcaO8jKiICzsxAVQOZJ6DGeVUdNQdu+WPQd3FX\n5lklX9oxr/yojkjMLun7XvANa5AtiyZkv2tnseXSEtQUkK1VRHyEzMfu1bzG1yPTFcdjT0OP1hy5\nyTTisqowd5aakkdB/wBq1j8sPcuzGizFHaiqElKHxr7rJ/aU7jDpZXC2BIsLBRsB6C2IrN6SZ62i\nr6FF9tglVXLEKZYDs6MevQj4YXxYqZE8SeHtG4I6Hucx/wDTXFsIF9tvhio8RNbtF4IP/R5lb4d2\nv+fng/EPEdSuZjIeG1gquIGTvJe8P3NBH/zs1jc8xaMbnrYYGm6oSdWNO1JY67KoMry6aD9au+iz\nPKaYxtIZJqZxIuoDZUbSU1sQAX57WxYuGc8pOJcho84oNa09Upbu5BpeFwbPE46MralPrhpw5w/B\nkffymeWtzWqN6vMKg3lqGHIfuoOQQbDbrjP+LeKKTgLjHMKzh6M5k9XGajPcmpm YilcL4K12VWWC\n/hWW9iVKvpJU4T/BST8mjcW8Q0fC2TSZpmBdlR1jhgiGqapmPuQxLzZ2NhbyuTYC+K7w7V03AnBe\nXR8Y1kMObVc09TURRIZGmqZ5WlkjjRbl9JcLdbjb1w64d4ckevpOI+JK2nzXPRCRSvTC1HQo4BYU\nqm/vbXla7sAOQNsRiT09B2y1T5uyRzVeU08WUSynSvhZu/jRjsHJKnzxEmzbHj53ZItx/l8MRmrM\nl4npaMC7VM2SzCMDzNrsPjYYs+V5hRZtQQV+WVVPV0U4vHLC2pWHXccj6HlhfVNH4ryAj8Zv5898\nV3hvI5slz/iOamMEeUZlLDVU9PGTeOfSRMdI2CsQjbczfCTYNQlFtaaHXE3FGTcMxU7ZvViOapYp\nTU8MTTTzsOkcaXLeptYeeIGbtIy+kQzZpkHFWW0S+JqyqyaQRIPNipJA+Iw+yPIaiPjjiLiHMxFJ\nVVLR0mWsj63go0QXUfslnLEgc9sWk98qsxWRRbclSNvW+312xRNJaaEMrraTNcup67LamCro6ldc\nU8J1K49P7sedP0oKukz7M+GaLJkmq81gesieKKI6gA6Dcf2wTflZTjUeyGSiFRxtT5LJG2UxcQSG\nmERDIoaJGcR22C69VgNsYf25NVUFbmNZTHukzHMKqjmlja0hEWlxGDzCHvCTbmRiW3aSOjFgg1Nz\nfRlub5NVZOkRrhSgy6k0RVCSsthuGCk6dvPHrXs44ypIeBOG8vhps3zvMKbLaZaoUFG0wibRfSzs\nVAYAja98eQcmgSTN6KJYQzPUIoVQBrJYBRvtbURe/THv7I8rjybKabLqKILFToEOhTZnA8TH1LX3\nOB8ukZv2n8ku9V/yQ1FxplVTmcOW10OYZRmFQdMMOaUrQd6fJXF1J25XviK7d9K9lWck2FpqMm/P\n/wCaiuD8MLds7U0XZ1mwr2jSZUV6IORq79WBRowd78+XS+ GnbnPIOyDO5xZmAo5QDuGbvoiP9a31\nxKk7aZpCC+E1q3X+v+ye4l40yvKM5myuKHMM2zhbO+X5VSmpmjVtwzkWWMEEHxMDY3wzpO0DKvtK\nmoM5y7OuHqmqfuqY5xR9zFO/7KyqWTV5AkfXErwxkq8O5QlEjCSrkYz19Tps1VUvvLK3ncmwvyAA\nGwwlxplVPn3B+dZXXRq9PUUkoAIvoZVLI4HRlYAg87jF2YLi9fosdrMQVAINiLYK2m+9sVzs+zOf\nN+AOGswqpGepqcugkmdtyz6LMx+JGJ5iSdzb4DDM3Hi6HF8VPPlv2l8E+ZgzEbf2I8XASqDso+mK\nnxE6/wCknglrC/c5j/6cf92Lhd/0RLr+yOz3M85zjjD9WeHq1cpgpaKOvzPM1hWWVVdiI4YVa6hi\nEYl2Bt0wunZ9QsGXMc84szEn3hUZ7PGCeo0xFFHyGGnEUGccO8eNxVkeUy5zltdRR0eZUNKyipTu\nnYxzxBiBILMVK3HTDodoT1GmLK+DOMairYWjimys0iBumqWYqijpe55ki+D9BZXYeHck4Z7XuF6b\nIqCKk73K8ynmIdnklN4wrO7Eu217XO29sXmjAj4wzeNiAZqWnmj9VUsp+hxQq3JuJcs42yXjWtyq\nXOq14qqlr6PK5VY0MLhe4ihEhUOFIcs212diLCwxo+Z081SaTMKJRT5lTrqVJ7AOrC7xSEXA9DuA\nRirBEhbbcnfffDauqoKGET1UhSPvEiBAvdmNgAPjhsM9aO61GS5tFMOaR03eqfgymxGCKlVmldTV\nFdS+yUVK3eQU7sGkkk6O4GwAubC53xCjXZSkVnj+lr6njDg6nyqtFBVyLXIKoxhzCuhdTKDsW03t\nfYHng+bcDQ0WUUk3B6Ckz/LXaopqh2LPVOw+8Sdj7/eDa55Ei1hiZz2jqanjfhKuggeSlpPbfaJb\ni0WuMBb/ABO22JvMqz2GgqqpY9b08 MkqoQfEVRmt/qgYpy6ozUbtGfR53mnHSigyEV2Q0Ucarm9f\npKzwyEHVS05It3gHvSi+gWt4uVvyPh3KshytstyWhgpaJiS8S+IzMRYmQneQkWBLEk+eM+4ByjMM\ni4d4R4jyRanMpM0oIJc7pNY7yoaa83tKlju6PI3XcbbY1ssvK11Ppa4xMvwWm/JnOUk8C59T8P1M\nn/BfMpe7yaZzY0czeI0TMeatu0JO/NDfbD7i/OOE58gz88SJBXZdk8scWYRPSvIYZHKhdK7b+NTd\ndue+2LPxBlVBn+TVuU5tTrU0NZGY5o26i9wQejA2YHowBFsYLxNQZxBnrcO1iT1+ZZtJSxShB4c7\npqaRZVqVkYhY51SIxSq5tcqwuGGIa8m2NW3Tp+DUf9HlFQuRkGdcRZI6k6VpcweWEH/q5dQI9MK8\nIZjm8XEtbwxxJUQVtbDTJW0mYQw917TTsxQ95GNgyvztsfTC368VLsRHwTxe1SbkRvSRKt/IuZNN\nvng3CuW5nJxJW8T8RRU9JXz08dHTUEUveCkp1cuQ8gsGdmNzbYWA3xNK9Grc5Rfu7+3RAcPR5l2g\nwT5zXZ1mWX8OyVU0WX5flk3szSxxuyGWeVfGSxVjpUgCw54lJOzLhGc3qsplriN/6bXVNTc+bB5L\nH6YjMi+3Oz5qvK04frc94Z9plqKGfKzG9RTLI5cwSxOyk2ZmIYE/DEpNxDxJn0Jp+HuGa7JTILNm\nmfCONab99IFZmkcdAdIva5tjRmcrvXQy7L0po884+hy+OCKmgz4QxpAgREC08alQo2FiCNut8ZL2\n+QKeC2nNtUfF1TGCfJoCT/5RjWOBcjzHgvirNsuosmkq+HMxqoqhM0FdHqhIgCOZkYhi7SKSSoNy\n55WxnX6RNDU0XZ8z1UXdibix5ogWB1xvA4Dbcuu2JfdmqkuGRN91/wCmEcG5ZNnHE+W0cLhZmmRk\nNr+LWoX6tpv6 A49p/qTR1DM+fZjnGbVLMS8ktdLDECTvpiiZVVfT6nHkbsdoK7NO0TKaTKZkpqtk\nklSWUakjMaGQEj+0qjbzx66puKs4hjCZpwRnArQPEaB4J4JD5q5dTb4gYUtSYb4L2+72VrtE4U4d\nyLs94jrKDKaKlrDRNHHUEF5QzMBYO5J62288Oe3DbsazcgW8FCQPL7+HDniTJM740yeuizSnp8pi\nFO/sWXPKJXeoK2SWodfCAvRFvuSxJsAEONKPiDijslzXKXyMUuct7NHFB7ZFIs4jkiZnDg2UWVrA\n2O2JX1PRopfGKbtqTvfjX+TQqhSamU2/EcNMzQ/ZtYOX9Hl/9NsSMsiGRj4TvzvhvWjvKOojjVSz\nxOii9rkqbY0o4k9/4Kh2Rb9lfCJH/wBsh/ni2kHqMQfZrl1VknZ7w7lmaQrFXUlDHFNGHVgjAG4u\nDY/LFjZwDtb6YBye3+wsziKGSRg5VFLEINRIAvsOp9MUyiqJuJuNMozSny7MKXKsppaj+kV1M9M0\n80wVQiI41EAKSSetsXQMb7D88cJJN2BPqd8Wm1tGbjYci/vbm9/gcBrt7xv8d8F1HfbHO89DiRgK\n736+eCsNJUgWNrA+WD68Ed74aKQMAGxvjgO2AMMpg6g9RyPljoIv4l1DqLXFvUfDHCcC+ARQOEqy\nPgp4eEs8lEFFFI0WSV9S5EVVAzFkp2c7LNGDo0m2oBSAdxjQCjgm8cgPXwm3+/52w1zKipMyoJ6H\nMqWnrKKdQstPURiRHANwCD5HceR5YqKdm+UQqkWWZpxTlVNGAFpaDPaiOJR5BSx0j0BthBssfEee\n5Xw3lxr8+rYaKmDaVMpOqQ9FRANTt5BQTijNwxmvGZm4mzRqnIM6jVf1dheQmTK0U6u8nX3dcx/r\nEsbR2U7g2s+ScDcOZJm32rS0D1OcWt9oZhUSVlQOnheQnTtflbmcWYEG/W+5vvvgtAV3g3iJe IKC\npSph9hzugl9nzTLGJ1Us3Sw/FG/vI+6sCN9jawhVsLAW8sMmy2gbOEzRqOD7TWA0i1QW0ndEg92x\nHNbi4B5b2tc4e3Hng0Or7BoXqqm3K4Bt8MAqCbkb3vgXHngXHng0MBUH+/Hn/wDS6lZcr4SpbkQy\nVVTIyje7LGgU/LUfrj0AWt5csYH+l3TGTIeFqob91WTxbfvxA/8AswWnol77Kh+inQmo7QsyrSl1\npMsfSQPdklkRR8Nlb5Y9WEDnYeeMB/RHoYkyPiXMxHKKiaripe9ZboI1j1gL5tqbcf2cb8TY7fS9\n7YNLsaOAjYDYcwB0OOgAC1sdwMMYUjla222O2NjYD5bYKSOuBfE2hHQpC7AX/jguhzuBcfHBh6AY\nKDYcjhOhVY4vte+2CA3Oxxw7defTAO3wwxUKCx5HbHGt54TBG/P6YHPzxVBxD38I3OCkjVa+2OHb\ne+CsbEYT0CiKGw3uTbe3niHqftxsymFO0K0Kj7stoJcjRYediNRJPUADEoTtjlx5HE8h8SNqznj1\nE3sjUyRL3hiMmkiUk3QEc1XTfV1J5YaluI1aMMIGRiAdCxawbMbtfw6fdG2/vea4nQRe+ASL4OQU\nQOniN43WWanRjYq0GhRcNuDcE6SNh1AJ1WwrQrnZrKdq+SLuVZmdYSoUjQwAI5nxFSoBsAN98S+o\nXwLjfc4OQUQscOfnQklXCoC3dwkZu5sCFFthu178zaxtfHBFxG/tIaqp4gIyImTQTq3APu7bWbl7\n23IDE2N+WBzVt+mDkJoiqaPOEhqlklQyd2RAWdWUEtdb7X1Wvc+7ytyOCCLPHkt7UkUYJOphEzWu\nCo2W1/e1dC2nTYYlVNmIN8DUAT1wuQiEaDiF+8SSshVGNkeHSGXlZtxvtfUBYluRA2xM5e9Q9HFJ\nWAJUOC7oBYJcmwHyIv8A4YOhJIUnfCun1w7b8DQNid2OMv8A0iuHMw4l 7PEp8moqivrqXMIalYac\nXcrZ0ew67NjUAvrfHGS4seXPlfAouyjxXwNm/GXAOfGOnGZ5DHOwWqWryyWWKw5M0encjoVsfiMe\nwuFzVtw5l8mZ1sVbWSRCRqiGlalVw3iX7o+JbLpBBsb9ByxK6pLbSyD4Of78Akk3JufPFUIGONyx\n3AwVYBdO22C23354UwRxcHe2E40MHpgA+pwle/MsfnbBth0xAm7FRaw2wDa/TAW1h4hiDz2eeGri\naGqaGFY1LgN1Zjb/AMpxoInNv8nHNQA5+vPFRnzCqhaUCulZgNzqFveB2/7IOHH2hUAJK1W4ujMR\n3mxsbkW+GALLO23p6k4TY/PFXSuqDTOTWMZNGq/e/ivJvbz2G2OvWTA3WskHMn787bX5fH/O2E1Y\nJlnYqOt97bdfhjjWtsfzxUI80qncK1XJZtNh3liAWBO/TkQT0w+pq6aGnd3k71zMIfvWYhd5Nx6b\nDfrieINlgU+uOs1rdcQhzWQsqpFDd42dQS3MG1sJfbMpsVjpiG3Ckte2/wDdhUJSaLDcEX/ngCxN\nvz6b8sQlHm0k1XHEY4QpmjQldXInc/S2IxaqcyzhquUhden70kXDH+F8PiPkW4EBb4B5N8MVT2tz\nTjXXzhO9Khw5uV0rc8uV7/UYPltXNrgf2gyFWOtTMxJsH2I6C4H1wcQ5Flv4jbmOdhe2ACCQD164\nrdRmTz06uZDCysyosV/EfDe/wGo3wplFTUSzvG0neyaTZZHNj4gCR8BvgcSbLDqGoWwcORYFTfED\nPms8c8693CQjkILG7rv6+hwnmFfJJQqHcKxvdoiyWOsqBc36WvgSaGmWMuPI/THDLYcj6Yp3tlQL\na55tFz+I2AFrm/wwtDUStDTlppVtMRdna9iyW5fHFWwstneL/nywO8X0+ZxW6fMZoaKnZgHDrKzM\n4YkWZQPlzwDnE4kI/o5F7XWN/r8MK2Flk7xf78D vFttc+lsVtM4qzGjmKEE6iQVfe1rdcMJqiqaS\nVUmmvcgaSbXJBH8CMO2Fl0LC17Nbrtywk7G3I+XzxUBI3eRyLLKb3LFmfxHSbWH0+mOvPUNQSEyz\n96PAgu1ye7be9vPAwstimxIx3VgoKONaPdWFxa+O29RiKEh0mpinOxt9MVqbNq3VKXkiIVygUwqW\nN9Vj8rD64sSEgDfphE0dKGJNLAGPM92DfGi2VRF5ZmNTU1qI5XuzIi6ViUGxJB/LbDOTOatC+p4n\n0na8S2sASR+WLAlNSo+paaENcG4UDccv54ZVT0MVOzU0VLJIDewW/nc2HlgEI1tbUwU1JIs8euRS\nzXjUl2Elr7bCwvhmc3q5GsJEUNtqCAkbPv8AXThylQ886QSUtK5Vu7C92bgO4HU+E8yfjhimZoUd\nhR0a2UEaU294L9OWAQt9s1RpXMkiag4Rh3YI8SE/D3h+eBBmlY9ZSrJKoikAaQGNR1AKDC8c6HL6\nt5IKRXSTQgMekOxUHkficJxVAeeANT0ILMoJ0gFTcbg+fXCbA5mOY1NPVVEUVSl4kLBmRd2FyV2+\nQxyXNKlM0SBZU7sPGPcFzcKSOXIksMcevElaiPTU0neVDDU0fP7zSDfrfa5x2GqkaZQ9PSjSyX+6\nPXcb9OdrfvYAEvtarje3tAfQQGbul57X+IHi5YcVOYVUOU0koqNE07MxuqXAsRYfMA/PDb22VNA7\nihtdVA7jxjUL303574d0dWaqrSCaCB4VVwPuOQAU2ufU8sFgNpM1rljRhPe0PeEaVts9r2t1HQYW\ngzKr+zq+b2gSvEsQRwgvdgSV+RsL9bYcTVlGZIvZRROoV9R0XsQCVHLz6YZpmLLTJIIKUJIFJXur\nC+xvfrzOAZxM3qx3VpVYMX2ICiw1AfkUPywaCvrJKdS05LsP3Lg23tttvhGkzCSorKeFqel0SSCM\ngQA23A/ljtNVvULHKaam0u zG/sy+YHn+8MAiUizNUy6inq3k1TJfZbkkX/PbDTM81fuEkoqlojqK\nkMgGvkbW+Zxx8wZqCjlaOmDsGJR0vYq1tsJyVcwiRkWkBLva0Ckk3XkDyNjv0wUAj9rVzmo1VRsY\n2dbhfCQ3w8jjn2nXEge2u2tmuNK+EXHW3rhWWtkihkPcUt+9aH+oUDZdrjqbg3w3jzOoZnHd0gFy\nWb2cC+/O3ntgAlHqKx8r9ohrO7eJmLnwm40rYHbzJwzGY1RWX/4gV0qNTFRsb9Nvl88O8qr42y8y\nVYpoQZjFpSOyna/IfLAq6uL2UmgSGSYspCiHULXtexA8ueFYEdBmlc5s9dIjg7KCt7k+drWwRs0z\nEIdVVJpaJpEIkUddum+F6SvqW/rIqVA0JkjYwAC/gt8dmOOU1fUTTxIRRhAVXeFf2je1sMB1meZT\nxvE8FWyoamUHSR7qldrEdDf64j1zet0KTWSa+QjNhYgG99vhieramhpHiSqkgiMzlIgybyEnewAJ\n8rn64JT1VNJHC0opqd5mZY0corPY2JA <TRUNCATED>
