{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import array\n",
    "import gzip\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import tensorflow as tf\n",
    "from collections import defaultdict\n",
    "from scipy.spatial import distance\n",
    "from sklearn.manifold import TSNE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data is available at http://cseweb.ucsd.edu/~jmcauley/pml/data/. Download and save to your own directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataDir = \"/home/jmcauley/pml_data/\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visual compatibility model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code reads image data in a specific binary format, described here: http://jmcauley.ucsd.edu/data/amazon/links.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readImageFeatures(path):\n",
    "    f = open(path, 'rb')\n",
    "    while True:\n",
    "        asin = f.read(10).decode('utf-8') \n",
    "        if len(asin) < 10: break\n",
    "        a = array.array('f')\n",
    "        a.fromfile(f, 4096)\n",
    "        yield str(asin), a.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse(path):\n",
    "    g = gzip.open(path, 'r')\n",
    "    for l in g:\n",
    "        yield eval(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = []\n",
    "asinPos = {}\n",
    "\n",
    "for asin, f in readImageFeatures(dataDir + 'image_features_Baby.b'):\n",
    "    asinPos[asin] = len(X)\n",
    "    X.append(tf.constant(f, shape=[1,len(f)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract metadata describing ground-truth compatibility relationships among items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "compat = []\n",
    "asinList = list(asinPos.keys())\n",
    "for l in parse(dataDir + 'meta_Baby.json.gz'):\n",
    "    a1 = l['asin']\n",
    "    if 'related' in l and 'also_bought' in l['related']:\n",
    "        for a2 in l['related']['also_bought']:\n",
    "            if a1 in asinPos and a2 in asinPos:\n",
    "                compat.append((asinPos[a1],asinPos[a2],1))\n",
    "                compat.append((random.randint(0, len(X)-1),random.randint(0, len(X)-1), 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Number of compatible pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1698622"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(compat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "featDim = X[0].shape[1] # Image feature dimensionality\n",
    "styleDim = 5 # Dimensionality of compressed (projected) representations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "featDim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the compatibility model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.Adam(0.00001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CompatibilityModel(tf.keras.Model):\n",
    "    def __init__(self, featDim, styleDim):\n",
    "        super(CompatibilityModel, self).__init__()\n",
    "        self.E1 = tf.Variable(tf.random.normal([featDim,styleDim],stddev=0.001))\n",
    "        self.E2 = tf.Variable(tf.random.normal([featDim,styleDim],stddev=0.001))\n",
    "        self.c = tf.Variable(0.0)\n",
    "        \n",
    "    def predict(self, x1, x2):\n",
    "        s1 = tf.matmul(x1, self.E1)\n",
    "        s2 = tf.matmul(x2, self.E2)\n",
    "        return tf.math.sigmoid(self.c - tf.reduce_sum(tf.math.squared_difference(s1,s2)))\n",
    "\n",
    "    def call(self, x1, x2, y):\n",
    "        return -tf.math.log(self.predict(x1,x2)*(2*y - 1) - y + 1)\n",
    "\n",
    "model = CompatibilityModel(featDim, styleDim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainingStep(compat):\n",
    "    with tf.GradientTape() as tape:\n",
    "        (i1,i2,y) = random.choice(compat)\n",
    "        x1,x2 = X[i1],X[i2]\n",
    "        objective = model(x1,x2,y)\n",
    "    gradients = tape.gradient(objective, model.trainable_variables)\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "    return objective.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 5000, objective = 0.51231325\n",
      "iteration 10000, objective = 0.6379045\n",
      "iteration 15000, objective = 0.7741432\n",
      "iteration 20000, objective = 0.7855767\n",
      "iteration 25000, objective = 0.46546566\n",
      "iteration 30000, objective = 0.4155722\n",
      "iteration 35000, objective = 0.7017366\n",
      "iteration 40000, objective = 0.83796984\n",
      "iteration 45000, objective = 0.66832584\n",
      "iteration 50000, objective = 0.41149664\n"
     ]
    }
   ],
   "source": [
    "for i in range(50000):\n",
    "    obj = trainingStep(compat)\n",
    "    if (i % 5000 == 4999): print(\"iteration \" + str(i+1) + \", objective = \" + str(obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For these exercises we use musical instrument data; we do so because (a) it has fine-grained subcategories (e.g. \"accessories\", \"guitars\", etc.) which can be used for these exercises; and (b) because it is small. These exercises might ideally be run with a large category of (e.g.) clothing images, though such datasets are larger and more difficult to work with."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First collect the subcategories associated with each item (for use in Exercise 9.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "categories = dict()\n",
    "itemsPerCategory = defaultdict(set)\n",
    "for l in parse(dataDir + 'meta_Musical_Instruments.json.gz'):\n",
    "    cats = l['categories'][0]\n",
    "    if len(cats) < 2:\n",
    "        continue\n",
    "    cat = cats[1] # Extract the \"second level\" (or sub-) category, for products that have them (ignore others)\n",
    "    categories[l['asin']] = cat\n",
    "    itemsPerCategory[cat].add(l['asin'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read image data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = []\n",
    "asinPos = {}\n",
    "posPerCategory = defaultdict(set)\n",
    "\n",
    "for asin, f in readImageFeatures(dataDir + 'image_features_Musical_Instruments.b'):\n",
    "    if not asin in categories: # Skip items for which we don't have a category\n",
    "        continue\n",
    "    asinPos[asin] = len(X)\n",
    "    posPerCategory[categories[asin]].add(asinPos[asin])\n",
    "    X.append(tf.constant(f, shape=[1,len(f)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract compatibility relationships. Build our collection of \"difficult\" negatives consisting of items from the same category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "compat = []\n",
    "asinList = list(asinPos.keys())\n",
    "for l in parse(dataDir + 'meta_Musical_Instruments.json.gz'):\n",
    "    a1 = l['asin']\n",
    "    if not a1 in categories:\n",
    "        continue\n",
    "    cat = categories[a1]\n",
    "    if 'related' in l and 'also_bought' in l['related']:\n",
    "        for a2 in l['related']['also_bought']:\n",
    "            if not a2 in categories or categories[a2] != cat:\n",
    "                continue # Only consider positive relations of the same category\n",
    "            if a1 in asinPos and a2 in asinPos:\n",
    "                compat.append((asinPos[a1],asinPos[a2],1))\n",
    "                negSameCat = random.sample(posPerCategory[cat],1)[0]\n",
    "                compat.append((asinPos[a1],negSameCat, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "809528"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(compat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "featDim = X[0].shape[1] # Image feature dimensionality\n",
    "styleDim = 5 # Dimensionality of compressed (projected) representations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = tf.keras.optimizers.Adam(0.00001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CompatibilityModel(tf.keras.Model):\n",
    "    def __init__(self, featDim, styleDim):\n",
    "        super(CompatibilityModel, self).__init__()\n",
    "        self.E1 = tf.Variable(tf.random.normal([featDim,styleDim],stddev=0.001))\n",
    "        self.E2 = tf.Variable(tf.random.normal([featDim,styleDim],stddev=0.001))\n",
    "        self.c = tf.Variable(0.0)\n",
    "        \n",
    "    def predict(self, x1, x2):\n",
    "        s1 = tf.matmul(x1, self.E1)\n",
    "        s2 = tf.matmul(x2, self.E2)\n",
    "        return tf.math.sigmoid(self.c - tf.reduce_sum(tf.math.squared_difference(s1,s2)))\n",
    "\n",
    "    def call(self, x1, x2, y):\n",
    "        return -tf.math.log(self.predict(x1, x2)*(2*y - 1) - y + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.2 / 9.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify the model to compute similarity based on the inner product rather than Euclidean distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CompatibilityModelInner(tf.keras.Model):\n",
    "    def __init__(self, featDim, styleDim):\n",
    "        super(CompatibilityModel, self).__init__()\n",
    "        self.E1 = tf.Variable(tf.random.normal([featDim,styleDim],stddev=0.001))\n",
    "        self.E2 = tf.Variable(tf.random.normal([featDim,styleDim],stddev=0.001))\n",
    "        self.c = tf.Variable(0.0)\n",
    "        \n",
    "    def predict(self, x1, x2):\n",
    "        s1 = tf.matmul(x1, self.E1)\n",
    "        s2 = tf.matmul(x2, self.E2)\n",
    "        return tf.math.sigmoid(self.c + tf.tensordot(s1, s2, 1))\n",
    "\n",
    "    def call(self, x1, x2, y):\n",
    "        return -tf.math.log(self.predict(x1, x2)*(2*y - 1) - y + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare models based on the inner product and Euclidean distance. Both make use of \"difficult\" negatives (Exercise 9.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1 = CompatibilityModel(featDim, styleDim)\n",
    "model2 = CompatibilityModel(featDim, styleDim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainingStep(model, compat):\n",
    "    with tf.GradientTape() as tape:\n",
    "        (i1,i2,y) = random.choice(compat)\n",
    "        x1,x2 = X[i1],X[i2]\n",
    "        objective = model(x1,x2,y)\n",
    "    gradients = tape.gradient(objective, model.trainable_variables)\n",
    "    optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n",
    "    return objective.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.shuffle(compat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "compatTrain = compat[:700000]\n",
    "compatTest = compat[700000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 5000, objective = 0.83570564\n",
      "iteration 10000, objective = 0.84522265\n",
      "iteration 15000, objective = 0.6948385\n",
      "iteration 20000, objective = 0.55048937\n",
      "iteration 25000, objective = 0.53180134\n",
      "iteration 30000, objective = 0.7649663\n",
      "iteration 35000, objective = 0.30317622\n",
      "iteration 40000, objective = 0.52734387\n",
      "iteration 45000, objective = 1.1975294\n",
      "iteration 50000, objective = 0.3939314\n"
     ]
    }
   ],
   "source": [
    "for i in range(50000):\n",
    "    obj = trainingStep(model1, compat)\n",
    "    if (i % 5000 == 4999): print(\"iteration \" + str(i+1) + \", objective = \" + str(obj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 5000, objective = 0.71674216\n",
      "iteration 10000, objective = 1.2483406\n",
      "iteration 15000, objective = 0.6968014\n",
      "iteration 20000, objective = 0.3971393\n",
      "iteration 25000, objective = 0.5065777\n",
      "iteration 30000, objective = 0.75319344\n",
      "iteration 35000, objective = 0.77804667\n",
      "iteration 40000, objective = 0.4195373\n",
      "iteration 45000, objective = 0.39572006\n",
      "iteration 50000, objective = 0.7114118\n"
     ]
    }
   ],
   "source": [
    "for i in range(50000):\n",
    "    obj = trainingStep(model2, compat)\n",
    "    if (i % 5000 == 4999): print(\"iteration \" + str(i+1) + \", objective = \" + str(obj))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute accuracy (what fraction of positive relationships were predicted as positive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8074738879555913"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acc = 0\n",
    "\n",
    "for (i1,i2,y) in compatTest:\n",
    "    x1,x2 = X[i1],X[i2]\n",
    "    p = model1(x1,x2,y)\n",
    "    if (p.numpy() > 0.5) == (y == 1):\n",
    "        acc += 1\n",
    "\n",
    "acc / len(compatTest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8218994229785991"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "acc = 0\n",
    "\n",
    "for (i1,i2,y) in compatTest:\n",
    "    x1,x2 = X[i1],X[i2]\n",
    "    p = model2(x1,x2,y)\n",
    "    if (p.numpy() > 0.5) == (y == 1):\n",
    "        acc += 1\n",
    "\n",
    "acc / len(compatTest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "t-SNE embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xembed = []\n",
    "\n",
    "for asin in asinList:\n",
    "    i = asinPos[asin]\n",
    "    x = X[i]\n",
    "    embedded = list(tf.matmul(x, model1.E1).numpy()[0])\n",
    "    Xembed.append(embedded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "Xembed2 = TSNE(n_components=2).fit_transform(Xembed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatterPlotsX = defaultdict(list)\n",
    "scatterPlotsY = defaultdict(list)\n",
    "for xy, asin in zip(Xembed2, asinList):\n",
    "    if asin in categories:\n",
    "        cat = categories[asin]\n",
    "        try:\n",
    "            scatterPlotsX[cat].append(xy[0])\n",
    "            scatterPlotsY[cat].append(xy[1])\n",
    "        except Exception as e:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scatterplots by subcategory aren't particularly interesting in this case. Try e.g. price or brand for more compelling examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f796dcf06a0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7ae367d940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWwAAAELCAYAAAD9brxbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJztvXmcJFd15/s7mZW1ZXfXmlWtrat6qW51S6zGWBtIYvMwYDAwgmHVAAPzkIdNw2JgjIw8DxvJ+NnwxmLYhBAYD8JiEUZstoSwxICEWKTeW91VhbbKrO6q6qqsPfPOHxk3O/LmjYgbmRGZEVnn+/n0pyszI27c2M4999yzkBACDMMwTPRJNLsDDMMwjBkssBmGYWICC2yGYZiYwAKbYRgmJrDAZhiGiQkssBmGYWICC+wIQ0QjRFQkIs/7RES3ENFJIvpUI/rmBRGdRUSnieggEV1hsP3VRPTTBnTNrQ+XE9HvXH6fJ6LRxvUoHIjoLiJ6S0BtXUdEt7r8foKInmf9/SEi+mwQx92osMD2gIiOENHOJnbB01GeiC4EcBWAPUKId1nfPWwJzNNEtE5ES5bAOU1Ef0pEKSL6JBH9zvruOBH9ja3NcSKaIqIu23dvJaK7bJ+Ltjbl/+8DACHEE0KILQC+C+BdQZ1rA3DsgxBisxBiHACI6GYiur5hvYo2RvdNCPGXQoi3h92ZVoYFtjf/DODfN7sTHvQDmBZCTMsvhBAXCiG2WELzpwCusQTOFiHEXwH4MIBnAniWtc0VAB60tSlQej7eoxxLKH8/1WpTtv3XyvYPAxgI4BwZZsPDAtubOwG8xP6FNd3/BhFliegRInqn7bfriOjrRHSrpXH+hojGLK12iogmiOiFtu3vIqKPE9HPiWiOiL5JRL32wwF4g7Vflog+rOljG4Cix3mQ8vlZAL4phJgCACHEpBDiK8o2NwL4b0S0xaVNtV2VotU/ExJE9GkimiWiA3IqDQBE9J+s704T0TEiervttwEiuoOIZiyz0E9sv7ndq04i+hIRnSKihwH8vlvnrBnFDiJ6G4DXA/iA1Z9vGxzL5Ll4gcuxA3vmLHY5PXNEdBER3Wtdz18R0eW230aJ6G5rvx8AGFT6+UZrdpZTn1WymU/ojLnvTbpn27o3t1j3Zj8RvZ9s5ioi+iARPUpnzG5Xut27lkEIwf9c/gFoB5AD0GV9JgAPAPgIgCSAUQDHALzQ+v06AIsAXoDSgHgLgOMAPmRt/58BHLe1fxeA3wHYC6ALwDcA3Gr9NoKSwPtfVj+eCmAZJdOH3D8B4OMA7nE5h7sAvEX57iMAJgC8A8CFmn1OAHie1Z+/sL57K4B/tW1TBLDD4/pdAeAkgPM8trsawBpK5pMkgFcDmAXQa/3+YgCj1t/PAZAH8HTr88cB/L11LZIALjW8V38F4CcAegCcA+AhAJMufSzI8wVwM4Drbb8F+lwox23kM3cOgGkAf2h9fr71ecD6fB9KA3nKug+nAXzZ+m0fgHkAl1q/fxLAKoDn2fopt3V9tq17cxeALQDOBvAbeW8A7AYwCWDY+rwNwPZmy4qGyKNmdyAO/wB8C8BLrb+fDWBc+f1PAXzB+vs6AD+w/fZS66Em6/Mm60HdYn2+C8DHbdvvBbBivaQjlpA4y/b7zwG82vq7z3rI5wD8gUv/dQKbUBLWPwWwBOBRAG+y/S4F9gUAZlAya+gE9iyAU9Y2p2AJEeVYX7fO429c+ng1gEeV734O4PUO238TwDutvz9mfd6pbON1rx6x9xfA2+AusMsDFKoFdhDPRUE+Fz7PI4hnbtl6Jj4A4BblWN8H8EYA56EkgLtsv30VZ4TwnwH4B9tv3Sg9y04C2+3ZfgTAC2y/vRVnBPZOAE+iNJi0NVIWNPsfm0TMuBNn7NgjAM6xpmqniGgGJU1myLb9lO3vJZTsy8L2GSi9RBK7Z8IEStqJfappb29R7iuEmEHppfgygP/u54REiZuEEM8B0IuSlvpFItqjbLcfpYXDDzk09QwhRL8Qos/6/0f2H4noGShduz1CiGut7y6jM4uUD9k2f0xpewIl7QpE9GIi+pll8phBSeOW1+hGlF7wH1rmkg9a33vdq7NRGqjsx6uVIJ4LQuVzEWTbgNkzNwLg1cqxLgVwFkrXa0YIsaTsKznb3q4QYhGl2ZUb2mcb1ffG3u4jKK2t/DmAKSL6ByI6y+M4LQELbDPsC4+/Q2l62W8TVD1CiD+qo/3zbH+PoKTFTDtsW4EQogjgDpS0pJoQQqwIIf4eJS15n2aTP0dJ+zxH85uXDXsvgP1CiGO24/2bOLNI+RTbtmr72wA8TkTtKE3bbwCQEUL0oTSIktXeghDifUKInQBeBuBay6bpda8eR/W1N0X1jAjjuQizbfW811B65n6HkhZsP9ZmIcQNAJ4A0Ec2zyGU7pHkCXu7RNSN2hecnwBwrsNxIIT4R0vZkPfsr2o8TqxggW2AEOJRAHNEdAGAXwCYJ6IPWAsjSSK6gIieVcch3kBE51sP+McA3GbTjrwEIlCadrb7OSARvZtKfsfyHK5GSbt5UN3W0mj+N8zd8+ykrP6ZMExE7ySiNiK6CsD5KA2W7da/aSFEkYheDOBFtnN5CZ1xvZwHsI6SCcDrXt0G4ENE1EtE5wL4rz7OawrADtvnMJ6LMNt2eua+AuCPiOhFRJSwjnc5EZ0thJhEyZb+MSq5hV4GwD5ofAPAS4noEiJKAbge7s+v229fx5l7cw6APynvRLSbiK60BvJVlGYQXovuLQELbHPuBPDvLY32pQCejpKdNwvgcygtjpiiame3orRQ9DhKgundLtuqn4HSw+p2L3X7LKK0KPQESouq7wDwSiHEhMM+16NkfrF/LwD8hir9sP9G2S8J85fp/wAYQ0nT+wsArxJCzAohFlAaLG4jolMA/iOAb9v2GwPwYyKaB3AvgP8phPiJwb36GEqLVydQstN+2aN/9nP/AoALLLPB7SE9F6Uvg29bwOGZs5STl6Pk9plDyeTxPpx5vl4P4CKUTB1/ZrUh+3kAJcH6Navdk6g0a7j1Sf18PUomshMAfojS4CoH/g6UNOqcdZwMnE12LQWdUeQYN4jouQA+JoQI1H2ISoEotwohvlhHG2Mo+TvvEVZgRxSgUoTm36FkxviPze4PE1+I6P8B8Jqg37+4wRq2OfcC+EGzO6FDCHEUwP8EcA8R/W2z+wOU/IZR0gT/ACVNnmGMIaKtlmmFrIXw/wbg9mb3q9mwht1kiOhfAXylHg2bYVoNItqG0vrFKEquo18D8GEhxHoz+9VsWGAzDMPEBDaJMAzDxATTHA++ISJW3RmGYWpACKF1eQxNYFsHDbN5hmGYloPI2T2dTSIMwzAxgQU2wzBMTGCBzTAMExNYYDMMw8QEFtgMwzAxgQU2wzBMTGCBzTAMExNYYDMMw8QEFtgMwzAxgQU2wzBMTGCBzTAMExNYYDMMw8QEFtgMwzAxIdRsfQyzkRFCIJfLYWlpCV1dXchkMq6Z2BjGCxbYDBMSuVwO2WwWADA/Pw8AGBoaamaXmJjDJhGGCYmlpSXXzwzjFxbYDBMSXV1drp8Zxi9sEmGYkMhkMgBQYcNmmHoIrWo6EQkuEcZsBHhxkQkSImpOTUeG2Qjw4iLTKNiGzTB1wouLTKNgDZtpeYIyWTi109XVVdasAV5cZMKDBTbTshSLRUxMTGBxcRFyPaUek4WT6YMXF5lGwQKbaVnGx8exuLhY9X2tJgsn0wcRsc2aaQhsw2ZaFifBXKvJgv2qmWbDGjbTsiQSCRQKhYrv7CYMv7Dpg2k27IfNtCxTU1PI5XLlz5lMBsPDw03sUWvB/ufhwH7YTEviJTAymQwWFxexvLyMzs5O1ogDhv3PGw8LbCa2eAmM6elp5PN5AEA+n8f09DQLlABh//PGwwKbqYtmTou9BAYLlHBh//PGwwKbqQtVy52enkaxWEQqlcKuXbuQTCZDO7aXwGCBcoYwBlZehG08LLCZulD9nIvFIgBgbW0Nx44dw549e0I7tpvAEEJACIH29nYAQG9vr6NA2QiLZ2HYm9n/vPGwwGbqws0TaG1tLdRjuwmMXC5X4SEit3fattUXz9g81Bpw4AxTF26aaCqVamBPKvEjoDaCMOOgn9aABTZTF93d3RWfE4nSIyVt2M3Cj4DaCMIsk8lgaGgImzdvrit4iGkuHDjD1EVU7b9++hXVc4gSfI0ah1vgDAtsJpawAGks2Wy2bOcHSjb+VrPzR4W6Ix2J6BwAI/bthRD3BNM9Jq40U2huhIXCKLER7PxxwFNgE9EnALwGwAEAMpOOAMACe4PTTKHJAqSxsE97NDDRsP8YwB4hxErYnWHixezsbNXnRglsFiCNhYNkooGJwD4OIAWABTZTwfr6esXntbU1CCEaYhaJiwBpFVs7B8lEAxOBvQjg10T0L7AJbSHEu0LrFRNLhBDIZrMNSWEaFwHCtnYmSEwE9nesfwxTQVtbG1ZXVyu+m5ubq0tgyzqMMiXqyMhI2bdbR9Q1WLa1M0HiKbCFELcQUTuA3dZXh4UQ4cYcM7Ggt7e3wtUrCCYmJipSok5MTGD79u2O20ddg2VbOxMkJl4iVwC4BcA4AAJwHhFdzW59zMDAAHK5XEU+kZ6enrraXF5edv2sEnUNNi62diYemJhEPgngRUKIwwBARLsBfA3A74XZMSb6TE5OViV/mpubAxHVbJro7Owsa9jysxtOGmxUTCXS1i77Mzk5GUnTDRMPTAR2SgprABBCHCGi5mX1YSKDTvtdXV0tmyhqMU2MjIxU2bDdhK+TBhs1U0nU+sPEExOB/QARfR7AV6zPrwfwQHhdYuKCqg3bmZ2drUmLTCQSVTZre1i0KuxUbxHpqXLy5MmKNpptKgnadBOVGQTTWEwE9jsA/AkA6cb3UwB/H1qPmDJRfylHRkYwPj5eFj5288jq6iqOHj2KVCoFIkJ3d3fN/VeLJKif7dg1WTvNXuwLevGRNfaNCSd/ijBxSrgjhMDRo0er3PxUkskk+vv7MTQ0ZCy8Dx8+XFEMIZFIIJ1OawexiYmJCsEIAOl0GqOjo57HC3OADLpt9Tw3b96MkZGRILrKNJmakj8R0deFEK8moodQyh1SgRDiqQH2kdEQdQ8IO0Rk5OZXKBSQy+V8Bb4UCoWKz8ViEfPz81rNUtVkgZKANxGOYWqtXufrV6A3210w6rO/VsXNJPJu6/+XNqIjTDXNfilN0L24c3Nznpq2m1lDpaury9FWrg5imUwG+Xy+Ynuv6ybPoZl2b6/BQr3Og4OD5T42w12QTTLNwVFgCyGesP6cBrAkhChaLn3nA7izEZ3b6MTBh1d9cYeGhjA2NoZcLofZ2VlHwe3HXGb3HEkkEhXmEVUYExFGR0fLwk26BU5MTDhqglGwe3vNpqImIOM0+2slTBYd7wHwHCLqA/BDAPejlG719WF2jPGXL6NZU1Tdiyv9sNVsfnb89M3uOaI7T13b8rq5eZg4nQMRletRNiqZlddsKmoCMg6zv1bERGCTEGKRiN4K4O+FEDcQ0a/D7hjjjzA1MLfBwOnFzeVyrmYRtRakKX6TPpkIOvUchBB1+5P7xWs2FZSALBQKOHbsGNbW1pBKpdDT04OVlRXfg3wcZn+tiJHAJqKLUdKo32p9lwyvS0wt1KOBeWnnboOB04ur01q7urqQSCTKLn6NQBV0KysryGazjsE3KysrFQNNozRZr4EoKAEphTVQSoc7PT0NwP8gH5dsia2GicB+N4APAfimEGI/Ee0AcFe43WL8UqsGJoTA+Ph4eZFO9+K6DQZOL67an+7ubiPXuqCRgk3a03Was5MJBWjuVN9pIK3H/GW3/6s028zCeGOSre8e2MqBCSGO40wQDRMRatXAcrlclQeG+uLWMhio3hr5fB65XC5UrcxJkA0NDWFpaclIcza5jo1aL3Ca2dRj/kqlUo5C2ytvC9N8TLL17QbwPgCjqCzC+7zwusX4pdYpqpNN104tgwERVeWx1h0rSOGnCrKZmRmMjY0hkUgYDzom/tLqjGRmZgbFYtEof7dsw+mc7b+trFQWeZLXrx7z165duyrMIky8MDGJ3AbgMwA+jzNFeJkY4WfRMJ1OVwnkWgcDEyEZ5GKpKrjW1tbK+bSDsAELIXDixIkqH3Ip/EzydwPu5+zkYgicuX71LEAmk0ns2bNHGxFab/EJJnxMBPa6EOKm0HsSAYrFIo4fP16RhS6ZTGL37t1IJuO7zup30TCo6b2JkHTTFuuN/gPOZBQMYpEsm816Bvzk83mcOHHCNX+K7pydgncAoL29Hb29veXrF8Tgo7tW9RKWqYijKs9gIrDvIKJrAHwTlTUdT4XWqyYhgzPsSDeoPXv2NKlXZrg91LUsGgaBSdtu2qJf7TuTyWBmZqZiuh+kXXZubs5oO2kuWVhYAFDdZ905u2nWHR0dFW0Ecc8ymQwWFhYqBqB6i0+E5VoataChZmIisK+2/n+/7TsBYEfw3WkuTtVN4mDvc3uooxzk4KYtetlqdYPU2NhYVT7tsJGeGzp09mXdOU9OTjq2H8b9IiJs377dMwjJD2EF90QtaKiZmHiJuBvkWgD54jsho96ijNtDbXdtA0rn26gIPi/ctEWvgUY3SGUyGaTT6fJCY5Dn6JTcKpFIVCWoUvvsNa3XrSXIcwjLZz3o2VVYikGUFY5GY+Il0g3gWgDbhBBvJ6IxAHuEEN8NvXcNwm06SkTYtWtXg3vkH7eHWgoG6damy5YXRTuhl61WHaROnjxZ4UoY9PRZHn9xcbE84HV3d2N2drZCYBMR0ul0RYCQ17Q+zLUElaDvtWxvcXER3d3dWF9fr/it3vPgqMozmJhEbgbwSwCXWJ8fQ8lzpGUEtvrit7e3o6OjIzKCS4f9pZN22vb2dgCoWKCS+E0uNDs7W27H7fzDEPSyaoy0Gdv7YT9esVis2K9QKFT5lMvKN/Ic6+mnm0ZqH/AzmYxnvhJdJGij7LJB24SdFJ6gQvt11yaKCkYjMBHYO4UQryGi1wKAlVekpa6Mqp329vZGflFD99LZUW+R3+RCprk0wlgQyuVyFSYqez/cZkM65HnMzs6W1yLm5+fLml8QL7yJySlK0/qgbcJu+4dlb96oC5EmAnuViLpgFTEgop2weYu0AnGccrm5l5kudNlxcvNyeuHCzCGtOzepKc/MzPhub3p6umpR0D4gzM/PI5/PV9iM/QhvE5NTlJ6xoAcPNxfBsAamjboQaSKwrwPwfQDnEdFXAVwK4D+F2alGE8dENm75pHUviWlyITWHtdML55ZDOpvN1qS52qe5TsesxWPHJPd2vXbvKJk8vAh68LC319nZWTVzCQOTpF6tiImXyI+I6EEAFwEgAO8WQkyH3jPGFfWhVO3uTjjZ/qRAyWQyRq5eqkBKJpMYGBio8LjxK/zczB09PT0N06L8VMORRMnk4YXT4OFmFy4Wi1XukjIEvxmDUSaTgRCiPHtqdDrcZmGiYQPAOSilVG0D8Fxr8ef28LrFOCFfKjXXtLS715MqFTB/+VQBNTAwgKGhIUxMTFRs50fIOm2bTqcxNDSEbDYbeHSejlqKR0fJ5FErbs/GxMRERSIvkxD8WjFZUBRC4OTJk1X3qtVNIyZufV8E8FQA+wHIZXkBgAV2E1C1UOlaJmv8eQnkoGx/TgKqHk1T3VcWz11bW9NmFQyLWqbUUTJ51Irbs6HOOmqZhZhisqA4MTFR5SUERHtmEwQmGvZFQoh9ofeEAeCtXeii/fL5PKanp8tpRO0EkSpVh5OAchLkplqTHflCFgoFZLPZhtkma62GE1V0BXynp6er7oXbs6EGBxFRzWsVXpgoFbqo5FQqFcuZjR9MBPbPiGifEOJA6L1hPLULL28OL4Ec9tTdSZCbaE1OqQEkbhGFtUJESCaTIKJyilQ5W2kVstlsxbqCPYeI/V7ong0p7NVr39HREZpbnYlS0dnZWTHjSiQSGBsba+kFR8BMYH8ZJaH9JErufARACCGeGmrPNhD2BR0VWX28p6en4qVy8ubwEsjNmrqbaE1eGeSCFNabNm0qz07skXlytiL72ApBGWrSKqd7oXs21Ao8RIS2traqNZQgbccmSsXIyIjjImgrYyKwvwDgjQAewhkbNhMg9gUdFbkCnsvlcOrUKSSTSfT09GDXrl1V01ogurZUE63JaTBywy3xkhtCCEeN3n78KAdl1Brtp2rLbmYxnQlO51rZ1dUVWPShyTOcSCRCW/SMMiYCOyeE+E7oPdnAeJkCJIVCAYVCQRuYEWVk5J9b6Dxw5kVVy3npSCaTKBQKNQlrAL4WMKPmeSAFo+nAoiat6u/vN/aV9pr1SHfOTCZTZXoRQnBBhIAxEdi/IqJ/AHAHKvNhs5dIQKj2OBOiJkTcUEPNAXdPjDCS65tARBV2W3t/ooSTv7ppncqBgQFMTk5ieXkZxWIRg4ODjvfDa9Yj3TmBatOLnwo2GzU3iF9MBHYXSoL6Rbbv2K1PoZ4Hzm6PSyQSFVNOWelGtd9GTYi44deVUAbvuGnPtQxyXgghyr7sRFTOyre4uFiOogPqTyJVL07Xz7RO5YkTJ4x9qtWAKjVTYVCL1hs1N4hfTCId39yIjsQd9YHL5/MYHR01tinKF8Y+3QVKEX6ZTAbT09NV30UJP3UjvQYbp2tmj+aUrml+7N2mSCFlX3CT1WMABC5Y6i2FppYQ80I1wZmY5ExMcKrppbe3t+J3exrWYrFYXuzVRbHGaQbZSBwFNhF9QAhxAxF9GlbiJztCiHeF2rOYoT5g+Xy+PK32q43l83ltIqEoaxxu6Vm9Vv11Yc867VrNomjX/Kanp7WBFH4ZHx8va44mQiQIwVJLKTR57Fq0fHV2ElQZNTe3QJkOVzcrkm6DduI0g2wkbhr2Qev/BxrRkbijs7vW4m2gi+iLg7bhlp7VS/PThT2n0+mK66ALirDPRnTCWvpX2932vFhYWMDCwgLy+Ty6u7u1M4Ogc4b41S7rXXDWucQFgYlboBPy/km3wShVRYoSjgJbCHGH9f8tjetOfMlkMhXVTnSYCF4n/+So4xbQ46VB6qboe/bsqRIq6svrlRt7YGAAhUJBW4nci3w+X85h4lRvMqjAo0YnjmqkS5zfEHbpNpjL5VAsFnH69Onymk5XVxe2b99e1saFEHjyyScr7m8ikcDg4GDLLlq6mUTugMYUIhFCvCyUHsUUIsLo6GiFLbIWbwNdbT91ahmFVXRduDOgD+jx0iB1U3QToeI2ALa3t3sWt/VicXERo6OjVd8HbZpqhcRROoQQWFmpPXX+qVOnKkxjS0tLFQukunzsxWLRUauXuWniHGjjZhL5a+v/VwLYCuAr1ufXApgKs1PNJEjBKPe1CzWv/Avqyzs4OOjL57ZROGnNuvSsuVzOVYOsdYru5v7X29urzY/hh1p9vP0SJ596P9Sav1yiu/722ZhfU6E0u+TzeRw4cADJZDJ2wtvNJPITACCiTwohnmX76Q4ialm7dj3uRV772kd+p7bVl9dJW2i2XdtPeLNJuHw6nS5HLU5OTpYX/twGS7fE+XJwnJ2dLQfZ+KUVp9RuBD2LC+MZFUJgYmICXV1ddfvryxqgBw6U0iTt2bMHqVQqqK6GgokfdpqIdgghjgMAEW0HkA63W83DKY2kWwJ3idfUvxbXJb8+t43Cj93VS4PU2aIXFhbK37W1tWFsbKzsk+7WrhQ6x44d83T3SyQSrp4lrZa1T0UV0PUUn9ChS5dbrydPsVjE/Pw85ufnkclkMDAwUNMahY7Dhw9j3759kda2TQT2ewHcTUTHUUr8NALg7aH2qomo0zD5eXx8vCy88/k8xsfHsWPHjoptvYRYLYtL9frcOuGkTZlqWUHaXb0GrvX1dRw6dAj79u3z1PjcFiLb29tRKBRQLBaRTCYdvUeIqLxw1Wo4udnNz8+XUwdIZB3NeosTqxGW9tlYPQm95ubm0NHRUfaZD4IwCzMEgUngzPeJaAzA+dZXh4QQLVWE1476cK6trWFiYqJK866l0K0fIWcPMpDmAhMzgSlO5htTk1CQdleTqa28Hl7HdBP+bW1t5cCbxcXFimAYO5lMpiVtyoD7gKbOSGTSMd0sJpvNlkPRpQKhPpe6Z0QVhvv37/dcK+ju7sb6+no5l469f6urq4GmMTDN69MsjEqEWQL6NyH3JRJ0d3dXvMjyoVDRTZu8hJgfIae+WEEHzjiZZ5oRcSYHLhn2vLq6ql2sMumLm/C354BWzR3JZLKcCTFqmnWQtmW/91O3vT3Jk/wM1GY+SaVSrqYr2WZQGrQXhUIB6+vraGszrZ7YWKLZqyZi14JXVlYcH6b+/v5Q+xG24HQyz/gx24SVTlMIgRMnTlTNakxMSPL+nTx50nW6vba2VuVjHdVFxiCz4OncRt1iB3TX/NSpU1Xf+Xk+hRCYmprCqVOnqmza0iyXSqWwa9cuJJPJqjqhYXPkyBHs2xfNIlsssBXswkP10Ein00gkEg3xlQ07mMLJPOPHbBNWwh4iwvbt27U5VVR0g4YQwtM2WiwWK4oWT05ONlVwuw1+9WTBU9Hd3/Hx8SqhLddKdK6ouoVDuSjvdQ2FENrjSaTAXltbw8GDB7XbhE0QKQ7Cwi1w5pluOwohHgy+O9Gi3pwNQR87SJzMM37MNmHOAkzzp+gGDVXAEVG5BJhEepxEJUtcEP0wmfHo7u/IyAjGx8extLSERCKB/v5+DA0Nles2qv2SawB27IuXp06dwu7du8teISdOnDB+NqIiLB955BFs3rw5cjMvNw37k9b/nQCehZINm1CqoP4AgIvD7VrzaWZAQxyCKUxmAWFHaJoMGqlUyjGTXJiDjp9zd+uH2vfV1VUcP34co6OjFWsptQr9RCJR5fEk0bm5jo6OulZJWl9fL3tbyIEgbiwtLWFpaQnZbBaDg4MYHh6OhOB2C5y5EgCI6HYAzxRCPGR9vhDAnzekd0ykMZkFhK3B6gaNrq6uKuHs1Nd6TE9eAtnPubv1Q5enZnFxsZwkSwYOSfORfRs/SO8PmUwrmUxWabyyze3bt+Phhx92bCufz7v+3mz8+IRPT09jbm4OY2NjTffRNrFh75HCGgCEEA9QbQgoAAAgAElEQVQT0d4Q+8TEBJNZgJPmGJTm7TZoqG2rC5tTU1NVQRcyP4X0GJGmAft+Tn7MQKVAdgrC0uHk/w+cMemoLC4uVh3frU21/9I3emJiAktLS1Xb69YBpK16+/btSKVSdYWeNxNZaWd4eBhHjhzxPA/p3ttsH20Tgf1bIvo8zuQSeT2A34bXJaaVcNIcg9K8nQYNE9u3WrYMQHnB0ql2ppsfs65grdtnO15FBXT7qsV0VdRAKJlky+7eODMz41voyv137dqFI0eOBFrNvpHIAhg7d+7E4cOHPbePgo+2icB+M4B3AHi39fkeADeF1qMWJAw7btSy9znhpAE3u8KI6fH89FM1p+gW/IDqqkJtbW1VQtOrrUQigb6+PkxPTzv2p7u7Wzsw2qlFQ5ZmgWQyif7+fu3AFxfW19fx6KOPlisYuRFUoYd6MIl0XCaizwD4nhDCexhiqgjDjqtrU5cpL0whXk94e6NyQNsjRu21CE0TB9nrOeqy/6XT6bLQU5Puq0FYKysrGB8fhxCiwh5t9/V3Sj2gtjU4OIiBgQHMzc1hbW0NqVQKPT09OH36NICSG6QQwlMI1UJfX1/ZpBRG+41Grg+kUimsr6+X/cB37NiBRx99NPBCD/VAXmGhRPQyADcCaBdCbCeipwO43isfNhGJRqWnjDoTExMVL/nmzZvrvvm6NtXFtrDLiukyCba1taG9vb3KXptOp8tFCJyKudYzuDgNEk7ZDtva2rS5RBKJRFnw2pHX0i1hkn072Sc3n2MdTs+G7vzUttPpdNnGalrpxek66Ni0aVP5XnkVj4grUSjFZyk92pfBxCRyHYBnA7gbAIQQv7Yy9jGGhKFN6toMy8ygK1YwPT2tnQqvr69rBYC99JfJoOKkGatavN2sYLfNyradroG9j3ZBB1QPhoBz+lg1Cs9+PCLy7VVgWvkc0Nu95XUxzWDnx/5sL+YQR1c9E6J+XiYCe00IMadoP6w6+yCMIBhdm2qhgM7OTs+CCSao5pdaFqqAkkBRBZgULG4ucRJpElCTVAHViYtku52dnZ6mj+XlZWSz2fLgoDs3J0HqN0OjG7K6kCm6Sj1qng8vapkFCyF81cmME81OW+yFicDeT0SvA5C0sva9C8B94XartfATBGO6mGhSKABAhaDN5/MYHR11DRvWHVvVOmp15ers7KwSYIVCoSp5kBCiyqdYks1my253bsh2pQYvhbF0x7MjTSduzMzMAKgeWEwzNKozBdmXesxCaqWejo4OY2GdTCaRSCSM76VM7C/zvERdE62FOJRnMxHY7wTwEQArAL4G4AcA/iLMTm1kTBYoFxYWMD4+Xv48OjqKTZs2eU7X8/m8a4pSp2P7reyRyWRw8uTJCsFIRBWFdNXkTHb/7PHxcdcMbmqaTUk6ncby8nJVu9ImnM1mq+zJss6fF2tra9qsdEFmaPSLve7l1NSUL826UCgYm2uIqLyIOTU15TsgJ+okk0kMDAxE1tPKjomXyCJKAvsj4XeHMbFD24W1/HzhhRdWbacTtG6BK+qxpIeEPSe36uHQ1dWFRCJRVYnH7u9r3w7Qp8y0zwhUoSqPqyIT7kvhk06nq2zkKysrZS8P3bXs6uryNWOIkmZpv4e1CFHT85beJjMzM4Hn+nC6t42ko6MDg4ODGB8fx/LyMorFYlXGwKjAVdMjhipkTbOg6dCFNLsFrqjHlqHKEunWlslksLy87NonVXtTPzuZEnSpO6W7lSosZD6QbDZbNoHI4gOyaPHq6mp5ENAJKKk96rTTtrY2EFHFflGycTbaU8NvgIwcQOU9VvtKRLjgggtw4MCBpiZ9WlpawsGDB6sGDpkxcO/evZER2lw1PWLYBZlX6LMXRITR0dEqTVq2b2dpaQnbtm0r/63LyCaEwOLiItbW1rB7927XwUP1G1YLBkhTgZreVPfibtmyBXNzcxW/pVIpZDIZTE5OVmy7vLyMkZERLC0tVZhVnFzr3Oo2rq+vI5PJYHFxsTyDGBwcdNweaFxAk5udPyqk0+mKe6wiFYKxsTEcOXKkaZq213EPHz6MvXv3RsJcwlXTI4bd5unkMjY6OlplwzZpz47Ou0HddmpqSltGa21tzbNcl6lnjKrpq/kpUqmUdnGsUCjg0KFDVZq7UyEGFXu+52PHjjluNzs7Wz62XANwy0XdqHStuVzOs8hwWJgkTkqlUjh58mR5sdbJ/GIvtBzVvCTFYhFTU1PYunVrs7vCVdOjjJPL2KZNm7Q2az+YCFQ3jcIriZOTBq1qnKqm397ejvb29gqb+O9+97uq40uBoU7TFxYWkMlkyueTy+W0GtTq6iry+TyKxaKr4FMFk4zsk94z6jkF7QuvC9RZXl7Gykrzyqp2dHSAiBzt5nYzkokZJQ4BONPT08hkMk03jdRaNf2/hNorBkC4RQxqybRnZ3l5GQcPHqzQflWNUo30m5+fx+zsbEXRVnVQWl1dRW9vb7myj24bN+RCqYlWq9r3VdSiB/Kc7NN79ZyDDpLyygXSDJaWlnD++efj8OHDjhkBgyJKGQEPHjyIgYEBbN26tWnmEc/QdAAgog74rJrOoenxxym82W1KLEOrneoySuyh3m7pLYeGhqpypHgJWmnuaJTmZg8nD9qGfeTIkaaZPtxIpVLYuXMnDh065Hu/qAjgIDj//PMDL9hbU2g6Eb3S4aedVoO3B9I7xpFaXn6nKXStXiZAddCHW9iz3QvFzdXMHurtZg9dWlqqMq8ApRe/WCyis7Oz3D9d+7WQSqVARBWC0s39zJ5TRF73bdu2lfepJ9o0qqlL19bW0NbWhn379rlWn1FptQjJQ4cOYefOnQ3zHnIbGv7I+n8IwCUA/gUlk8iVKEU6ssAOmVoWsJym0Ko5Qm7rt/4fUIr6swsS6QNtL4Lr5cFgf8DVEGun7XRubCsrK1UeLdLdr1YTAhFVaeh281RnZ2fZhlssFjE7O4vp6enywDM/P4+FhYVyxRY3k5AXXjmvg8KvP7TseyKRKC+CmwjtoGbdu3fvxpEjR4y3D9Pf+5FHHql7TckUNy+RNwMAEf0QwD4hxBPW57MAfKkhvdvg+FnAMkn6I32SgUr7rV9vhvb29irfZHuGuWw2q53GO1Wdt4dYd3R0lCMWdRVkVGSyKV3bXqaTZDKJZDKp9fGW5wmcqdiuVp5xM/k4fW+/B27XW97PRthKk8kk2tvbfc1K7MIvl8v5ykgYBH6ENRCsXV3H+vp64KYRHSZHOE8Ka4spANtC6g9jw88Clp8gChlUYsf0ZdU9+Ol0pdOQ2hYRlT03nIJsTEovuS0+JhKJqrSko6OjOHr0aFW+6Y6ODtcUrKlUqipgSO23l8nHC6/r3cigmEKh4NuEJPOh+MkM2MocOXIE+/btC/04JgL7X4joByjlEQGA1wD4cXhdYiR+vETUF07mRxBCYG5uznPhytQGp2pTugxzqmCV0Yf14qYl6ezImUymyrTR1tZWTkWby+UqXACdAoZ0wsyPgJNFDuz3wOt6RykEXsfi4iL279/f7G5EhkZFaprkEvmvRPQKAM+1vvqsEOKb4XaLAfwlDlKF5MDAQHlfmY7UKem+n7SeqiDRJU8Kyx3RqaZeMpksL+7J87JX4bGbRhYXF7V5s+3XOZvNVgQM6YSrTttXvWfU6jG6iFMdxWIxEvUDGXMaVU3d1OjyIIB5IcSPiaibiDYLIaLhFMoAcBeSquCXHh+1eC6YmGnCylDnZBKRBXOlzVkiPUzcXiadJmsy4MjF1bm5OQClhc7FxcUKQd/R0VFxHdRrYi/SIAN4wvSiMIlQjBvt7e2OaxCNZPfu3Q05jqfAJqK3AXg7gH4AOwGcA+AzAJ4fbtcYP/gRkvUI1DCDefwce2VlxdjM42b7tmfzk4OWyfUhIgwPD1eEqZto5nYanbyp2UItaIgIu3fv9p1aNmg6OzsbsuAImGnYf4JSibCfA4AQ4igRNbfoGdM0wszv7OfYuqAe6c6nDiY6lzw1mx9Qf84Pv4NZlO3UyWQysj7gkp07dwJAeZbTLHbs2NGwY5kI7BUhxKpN+2gDlwhjasAkEMg0WEgKQ+nvbXe9U/OX6IKH1Gx+QQhPnenJLWjGb2GIqLJly5ZytfZG4pa0q1HUUrezHkwE9k+I6MMAuojohQCuAXBHuN1iWhGTQCDTYCEpHHW/uQUPSdTkSdJ8EWRoude56PKVS9xKeKXTac8cKJ2dnXUNQn6062YI66jQ6PzoJgL7TwG8FcBDKCV9+h6Az4fZKaY1MQkECiLbnds+qg+6zpMjiPSociHUrV9u+cqd/JvT6TRGRkZw6NAhR5u0dFWUC5orKytYW1tDMplEX18fhoeHIYTA0aNHXfN6yAApzgnkjFtq4zAwcesrEtEtKNmwBYDDnNXJm0Ylsm/0serBxMMkiGx3fkwNqidHLQOGev0HBwe1mexMPWqckm7ZZxQyNFsntO35V+wLoYVCAadPn0YikcDCwoJnEiZZeDeKyaeawaZNm8rmNXs5vEZi4iXyEpS8Qh5BKZfIdiL6L0KIO8PuXJwx1dSCELaNSppfL6bucl7b+D2O3Yat+qCrQrSWAUO9/jLPtlO/vHAKghocHKywie/duxcAqkLkC4VCheumHfsiqxtE1PBw86jT3d3d9PfKxCTySQBXCiGOAQAR7QTwzwBYYLtgqqkFIWyDTpofFqbucvW+FGp2PzUvieqDbqeWAUO93rqgF5kB0ASnICi75m1/VjZt2lQhsBcXF3H06FH09vais7OzpoVNnkSfCQpLJBLo6+trqAurEyYCe14Ka4vjAOK/tB0ypppaEMLWj1YYF/NJEDgNhm4DQi0Dhnr91Qx7iUQCu3btMm7PadBQQ+blTEGX00Rq0vJ8dfljGHfkekGUMMmH/QARfQ/A11GyYV8F4P4G9C3WuGlqdqGpTp1rsdn60QqjbD7R2YKnp6drHlwaNfNwKpwMlF760dFRX/2WybLktZA5T1StV7oNSluzjtnZWXR0dKC3txdCCJw6darKAySdTqO7u7upwSdRpNEeICaY5MMGShn6Lrf+zgGI3plEDDdNTY1wc0o7GsSxVKJsPtHZguupGh90uS4n3Aon63KtqBSLRYyPj2NxcRFEhLa2NhQKhYr82tls1rEd6QGic8WTwUHz8/PIZDIYGBioevZGRkbK7bMppER3d3ckTCAqnvmwmeDRJVBq1NQrKCHm17Risr2XLXh2dta4+ALQ+DB6XdImk+s7MTFRNmsIIRy9N9yEqUlkYi6XQzqdxsDAQPkZSKfTyOVy5eLCTIl0Oh1JU6GJl8h2AO8EMGrfXgjxsvC61boIIQIxg9RKUELMr2nFZHt1MFEr0ayurpan7X6Ca9TIx3pNLU5MTExUCNtUKmV0ff1k5pMa+Pr6eoUA7+npwfT0tKeGnM/nsbq6Wu5nNputSpplPxbgPlC0qlYe1WyJJouO3wLwBZSiG1sre0wTUPNJy0TwExMTnsIjiAXDoHKB+DWtmGyvDiaDg4M4duyYZwi5n2IAQZhanFBf8mKxaHR/3EqkqXR3d2P79u0Vz0JnZ6cv+7NJEdx0Oo1t27bh2LFjrtu3orAGomm/BswE9rIQ4lOh92SDoAqX9fV1bQ5nnWCO0oKhX9NKrWlZ1QIEcj+3ttSBTfWiUAVrUHZ8VfB2dnZq+6UWNTYV2N3d3WXTmf1aHT58uK5+9/T0IJ/PY2lpCYlEAv39/RgaGsL4+HhLVTj3QxTt14CZwP47IroOwA8BlBMwCCEeDK1XLYxXFJ70CtAJ5igtGPo1rdRqinHbz6kt9fqpJcxUAVmLNqWb7dhrU8pIOKd+SezpWN3YvHmz4zqHiVBVTRf2UmlCiPKgVigUyiXRomoWaARHjx5FT08PhoaGImXLNhHYTwHwRgDPwxmTiLA+Mz5RBRCAKg3SSTCH5fVQi6nFr2mlVlOM035ubelydsgBz8mGbcfkeugG1UwmU+HxY7cB11v70KkEGhEhlUp5Cm3VdNHb2+vo2SKvnx9TTathXy+x5zxvNiYC+yoAO4QQ7HUfALoUnECltpjL5bSCWWfjdUvfaUqUTC1BoA5sakixl93V5HroBlWn/eopVCDD0uVzoWt/165dnrZmFfs1cFIERkZGMD4+jqWlpZa1VXsxOzsbO4H9MIBeAI0rjbGB0GmQaq5nIUTZ5qnWHgxC0NZqalE1Pl3e6WbgFbQ0Pj7uuuhocj10Qs5pvyDSnOrygsjPyWQSe/bsQbFYLLsIeglYe1tO14uIsGnTJiSTybK2XU+l+DgSNRu+icDuBXCIiO5HpQ2b3fpCQgo66R2Ry+W0gj0om3atphavvNNRqEyjonrpAGf8u+V1N7keutmOalro7OxENputyr3tFyeTmGzfLmi3b98OwDnjn8Qu0O3XS43CtQ9smUwm9LqTjDsmAvu60HuxgTC1F6vC1y5UZBtOSfj9UuuCoNsAEaUISvs11wnP1dVVHDlyBGNjY0gkElphPDU1VVFwN5PJVM121JD0oDRSJ5OYPC5QOWDa7+Pc3Jw2h4jumVNnHyocut58TPJh/4SIRgCMyarpAJLhd601MbUXq9qUTOYzPDxcZRNVk/D7pdYFQTePlyj5sZrYkNfW1nDgwAGkUins2rWr4nqoRV51NSDVAWptba3mZEvS3U/+bzdR2DXho0ePVuxnT/A0Pz+PoaEhjI2NYWpqqiqSUWcy0c0+NjoDAwPN7kIFXDW9wZiYMaTNWmVubg7Dw8NV+6hJ+BuFW97pWjwvwsKPlru2toaDBw8imUwimUyip6dH692hCrYg6zPK65hMJh0Hvlwu5zkgyNwkW7duxfLycoUL4fLyMsbHx8sDgs5GzgBbt25tdhcq4KrpDcbEPprL5bTTT5mYvlFJjbzwo5k30xOlFg+HQqGgLfMlUYWlbvCqx4RgP77uOssFaTtqygP7eXd3d1cI7EKhgIWFhfJ3Q0NDVc+VibtgXEgkEo4l1ZyQs5wowVXTG4yJvdhJ05EvcKOTGqnUoi03M+hH17daXmA76r46d03Vfixzdvg1lZheK3Ux0H7emUzGMSe2XB/R2e5PnDjREpp3LcK60fUaTeCq6Q3GRCt1m17b6/U1i1q05WbOClTtUlZ/qSehvxp2rkJEVWH1cp0hl8tphadTIiX7tZKDpcmsQc1Ro/ZHIoNEdMUdduzYgWw2u6EWHLu7u7Fjx45md0MLV02PIG4J8aOwmFeLttyoWYEQAlNTU5iZmUGxWERXVxfS6XRZu5XhxuqCnQ4Zom3XzuRCoEk6XN05y8E2k8lUeWSoQjiZTKK/v79cvEAn6HVpVdvb25FKpap8ze2Va5aWlir2k3Z6XRSoXDcxDaOPO5s2bWp2FxwxqpoO4HPWP6YBOPnFNsP8oaMWbblRswI1t/Pi4mLFoqMUwj09Pa5ao9R2pRCVnjgDAwOYnJzE4cOHPStnu52z7IcOKXDt2zh5unR1dZWLFEg6OjqqTAD5fL5Cg1b9tAuFQtk1URdUtJEiHaPwjjlhomEzTaQWQRe2R0azbeh2vDLzqcjZgLymc3Nz5QU+N6QnzokTJ8oCLZ/PY2JiohysUkvfdRQKhbIAllqt0yymu7sb3d3dVfloZmZmKrZbWlrC4cOHUSwWkUwmsWXLFnR3dxtlMnQrqtBqJJPJyC002mGB3YKE7ZHRbBu6Ha/MfCpyNkBEGB4eLueJUDVOVfjL/VSBVk9GOyfBoA4ecjCyz2p0vvf2AVR1RSwWi2Wtu1AoOFaY6ejoqDhvmWt7IxTwJSLs3r272d1whQV2BAhaI45SGtaw0WXmGxwcrLJhO/mHA2f83qWdu7e31zGjn1fOaz+oi6FOXiT24zs9I+oAqlZu90JeN6DSb92kik0rMDg4iOHh4Uhr14B71fQ74OK+x7lEgiNojTgqftqNwCkzn5+AB9XvXfo46wZOr5zXftAJYV2BZvtipSnt7e2+s/fl8/mqfTaCsN67dy+SyXgEb5PTDSEiWSX9lQC2AviK9fm1AKaEEO91bZhIbISbHQQTExNV012ZXL4WbbuZUYWmBNXHWttR84vopvxqNftGXMOgrotX8iemxL59+xwXjZuFteCtvemOAtu28wNCiGd5fafZjwW2IW4vl843thVQz9nPeco0onYt1+9L51egNeM+1HOeQgicOHFiw6VD9cuFF17Y7C5U4SawTe5+mojKXuRWFXX3lR3GFzLz2+bNm6sqWMfJ/iyEQDabxcTEBLLZrOt0uh47+8TEBPL5PAqFQtlTwy/q8drb2x2rh/vtX1DUc55EVHdaVyZ6mCw6vhfA3UR0HAABGEEpgIYJCLt9UuetEEV0U3c/tnjV9ryysoJsNmtkAgjCU0M9vj0KMSoBS/WeZz2h9xuBVCrV7C74xiRw5vtENAbgfOurQ0IIHrpDIko+zm7ohLMfrdleVUcGfujSlqoIIao8IGrx1HCLQpTHaXbAUr0eKSZ+6aY4hc3Hmb6+vmZ3wTembn2/B2DU2v5p1s37cmi92sBEycfZDZ1w9uOdYi+Ma1/w8zI95HK5Ck+GVCpVk6eG13WOwn2o1yNldHQU4+PjjkI7lUphbGwM09PTnvb8VhPY9mRXccIkH/atKOXB/jUAqdYIACywNzA64VzL7MCvC6Iq0Ds7OyO3yh8UiUTCOIpSNyNIJBLYsWOHdgEykUigt7cXRIRMJoOFhQVXbbyVzCtR9AwxxcRL5CCAfX5dPthLpLVplltePd4lUaKW6+e2j9d1KRQK2srqcjvZtizgKzVqmdXQb6SjjMSsNy940OzZsyfytms3LxHTqulbATwRaK+YWBOUycBvO3Gx8XtRS7CUus/MzAza29u1qWLtMxEhhFZYyzZnZ2fLWQx1g4Y6GOgyBKp0dHQgk8lEwhdchpxHXVCbYCKwBwEcIKJfgKumM00mCrZloP4ZRi1ujbq6kU7RjF1dXeWK6sVi0XE7IUQ5H7bTtXUr/gvoBXhXV5dj5aSwkSlhWxETgf3nYXdioxKHiERGT73pBGpJH+BVN1L6kgshHKvLuOFkw9ZV0wGcy6HJcPrJyUlte4lEAn19feV8L/WSSCTQ1lYSZfUUo44DplXThwH8vvXVL4QQzZ/ntADNrHPYijRyAKw3wZaJaUc9n2KxiPb2dsd0sL29vQBQsxnCdM1JJ8BlEV/7dXfLMCiLA9vt5kB1cWMvWlmb1mHiJfJqADcCuBulwJlPE9H7hRDfCLlvTSdsAbCRsuo1gkYOgPUm2DIx7ejOR5JOpysWBmX1cyetVmYsdLM91/psm5pS1PfHab/19XUcOXKkrH3L8zv33HNx/PhxrK2tgYgwMDCw4RQcE5PIRwD8vtSqiSgD4McAWl5ghy0ANlJWvUagDniLi4tlO27QA66uYG3Qx3IbwBOJhNYv28lssri4iI6ODleB3d3dXVtHHah1vaGtrQ379u3T/rZnz556uxVrTAR2QjGBnIRZDpLYE7YG3CoeD1FBFVYytwlQGnDz+TxGR0cDEdqqMLJ7UgQ1uLvZrNWoR3uiqFQqhVQqVWGTFkJoQ9vVzJBMtDER2N8noh8A+Jr1+TUA7gyvS9EhbA04Kh4PzSAMc5M6AKqLaPl8HkePHq2wowZFGIN7JpPB9PS0dmFO7btMFAXAqOSZpKenp2x/zuVyvPAdcUwWHd9PRK8EcJn11WeFEN8Mt1vRIA4asF/BFxXPlDDMTTJqT56fbhHNNGeJX8IY3N0K9aoDgqo9O3lfDA4O4vTp0wCqFyl54Tv6mCw6bgfwPSHE7dbnLiIaFUKMh925ZuOlAUdB+PkVfFHxTDHVSO0ReqlUCrt27XKtDqJWbEmlUlof5Eabt2p9VtQEUBJ1QHDaTkWtW6imbOWF72hjYou+DYB9uC5Y3214pHCYn59HNpttSpCA36l4VDxTVIHjpJHaI/TW1tZw7Ngx13bV8+no6NDmudYdz08+bxU5uI+MjGgjBmt9VkZGRpBOp5FMJpFKpZBOpzE0NFQ1IKjbOTE3N1fx2fQ+MNHAxIbdJoQoe+ALIVaJyDnT+wYiCsLP71Q8Kp4ppuYmVTv2qlOoq/HY3d2trZOoEubso1YPFtMEUPbthBAYHx830rjjYPZjzmAisHNE9DIhxHcAgIheDmA63G7FgygIP78vXD0vaJAmINMFV9Wk4ZUPwu381O+y2WxFsiO3fBx+0JX2MvFg0dWPrOWaExFGR0fLeULs5yXt1vZt2WYdH0yy9e0E8FUA56CUVvVRAG8SQrjOTTdCtr4o2LAbSTMy5fm1Yevwqo7jRK3nd+LEiQrtNp1OlwWo3YNlYWHB87j1XvON9oy2AnVl6xNCPALgIiLaZH3WP2UbkI2mnahuco0o8JpMJusOljCpjiMJwi9ZV9pL57ftJLDtfavX7LbRntFWx8RLZBjAxwGcLYR4MRHtA3CxEOILofeOiRTqjCkuMyiT6jiS3t7eugWcSWkvu+lGrR/Z2dlZkWnPTj1mN9a244+JDftLAG5GKUQdAI4A+N8AWGBvMNSXOy4vu26tYXBwEPl8HktLS0gmk+jo6Cjn46gXk9JebvUjAVQtktrt27USFZdOpnaM8mELIb5ORB8CACHEOhGZhVExLUV3d3fFND7o3BNhoS5EyoT+cjGuWCyir6+vSnjVqpH6Ke0FVJstVN9oNW+IU7+8+hsFryamPkwEdp6IBlBacAQRXQRgzn0XphWJqwuYXSA6+UDrhFezNFIv7yO1XzJHiq6/surLqVOntEUGmHhhIrCvBfAdADuJ6F4AGQD/IdReMZHEbRofF3uok1Zpr9Aiz6dZGqnXwKj2I5/Pl++FnZMnT2JmZqbKd12G8MdlwGXOYOIl8iARXQ5gD0r5sA8LIdyjF5iWJ672UKek+vaqKfL3ZvnZe3l26BZMdQupTkmghBCxuFdMNSZeIlcB+L4QYj8R/XcAzySi/yGEeDD87ry+UX4AAAyRSURBVDFRJa72UKek+rqcGtu2bavaNgozi0wmg3w+X+FZYtfET548aZytj4kXJiaRPxNC3EZElwF4PoC/BnATgD8ItWdMpIlClGctOGmvuvPRbRtG3mu/2CMZ1YHDbqt3ohWqh29UTAS2HKpfAuBzQoh/JqL/EWKfmBgQ1wVIJ0zPJyozCzeziey7DLsvFotYWVlBsVgsR4sy8cQkNP27AB4D8EIAzwSwhFIh3qd57NfyoenMxqMZ4fm1EAXTDVMbbqHpJgK7G8C/A/CQEOIoEZ0F4ClCiB967McCewOw0QRDXM43LgMLU029uUQWAdxu+/wEgCeC6x4TZ+LqLVIrUczNoRtEomK6YYLFxIbNMI6wYGg+ukEzrovCjDsssJm6iKJgiIvZIih0g6bOJZGJPyywmbqIorfIRjPTmLokMvGHBTZTF1EUDBvNTBPFQZMJBxbYTMvh10wThgmlkWaZKA6aTDiwwGZaDr8aZxgmlI1mlmEaAwtspuUw1TilFnzy5MmK74MwoejMMhttMZQJnoYL7NHR0apEO0wwjIyMYHx8vNndiA1OhXiD8HTRmWVY62bqpeECe2JiIja1AOMGa2tnMKnKsrKyUrVfOp0OZNFOZ5aZnJys2KbVF0OZ4GGTCNOSOGmzTlq1JJFIBDLw6cwyUfRZZ+IFC2ymJXFy7VO/TyaTFbmjwxSi7H7H1AsLbKYlcdJm1e8HBgYANEaIsvsdUy8ssJmWxEmbdao4wzBxwDO9as0NO6RXlQs/rcrmzZvx0EMPYXR0tOHHbvVrGxbsbsdECbf0qolGdyYO/OM//iMuuugibNq0CVu3bsXFF1+Mm266yWjf+fn5srB+85vfjI9+9KMh9pQJArkQOT8/j2w2Wy7GyzBRI1YCu1gsYmZmBjMzMygWi6Ec45Of/CTe+9734oMf/CCmpqbw5JNP4jOf+Qzuu+8+rK01tlg8F1JtDBst9wgTXyIlsFdXVzE7O6t9YYQQGB8fx2OPPYbHHnsM4+PjgU//T58+jeuuuw433XQTXvGKVyCdTgMAnva0p+HWW29FKpXClVdeiS9+8YvlfW655RY85znPKX9OJBI4fvw4Pve5z+GrX/0qbrjhBmzZsgUvf/nLAQCf+MQnsGvXLmzZsgUXXnghvvWtb1W0ddlll+Haa6/F4OAgPvaxj+GRRx7BFVdcgd7eXgwNDeG1r31toOfMVHuGsLsdE1Uis+i4tLSEEydOlDXnc889F729veXfl5eXsbi4WP68uLiI5eXliperUCjg8ccfx/Lyctmc4ccW+bOf/Qyrq6t42cte5qvv9mPIv9/2trfhvvvuw3nnnYfrr7++/PuuXbtw7733Ynh4GLfddhve8IY34JFHHsHw8DAA4Oc//zle97rXIZvNYnV1FW95y1vwh3/4h7j77ruxurqKBx54wFffGG/Y3Y6JC5HRsFUzh5rfIZlMVu2jfvf4449jbm4OKysrOHnyZFUbXkxPT2NwcBCJxJnLcumll6Kvrw/pdBo//elPPdvw0vpf9apXlYXzVVddhbGxMfziF78o/37OOefgmmuuQSKRQGdnJ1KpFCYmJvDYY4+hvb0dl1xyia9zYryR7nYjIyMYGhriBUcmskRGYNuFJFAtjNvb23H22WeDiEBEOPvss9He3l6xjRpqrAs9dmNgYADT09MVA8e9996LmZkZDAwMBGKC+fKXv4xnPOMZ6OvrQ19fH/bv34/p6eny7+edd17F9jfeeCOKxSKe/exn4ylPeQpuvvnmuvvAMEw8iYxJJJPJIJ/PY2lpCalUCmeddVbVNv39/ejr6wOgz5uxefNmLC8vV3z2w8UXX4yOjg58+9vfxite8YqK36SwTqfTFaaZJ5980rE9tY+Tk5N4+9vfjrvuugsXX3wxAOAZz3hGxUCg7jM0NITPfvazAEqDxwte8AJcfvnl2LFjh69zYxgm/kRGw04mk9i5cyf27t2LPXv2oKOjQ7ud1LB1DA0N4eyzz0Z/fz+2bduGLVu2+OpDT08PPvrRj+Kaa67BP/3TP2FhYQFCCPz6178uC+mnP/3puP3227G0tIRjx47hC1/4gmN7w8PDOH78ePlzPp9HIpHA4OAgisUibr75Zjz88MOuffrGN76Bxx57DADQ29uLRCJRNRthGGZjEBkNW6KzVZtCROjv76/r+O9///tx7rnn4oYbbsDVV1+NdDqNHTt24IYbbsAll1yCCy64APfffz+2bt2Kpz71qXjDG96AH//4xxV9kLz1rW/FVVddhf7+flxxxRW4/fbbce211+Kiiy5CMpnEm970Jlx22WWu/bn//vvxnve8B6dPn8bw8DA+9alPNSUoh2GY5sORji0EX1uGiT8c6cgwDNMCsMBmGIaJCSywGYZhYgILbIZhmJjAApthGCYmsMBmGIaJCQ33wx4ZGeFcDSExMjLS7C4wDBMiDffDZhiGYZxhP2yGYZgWgAU2wzBMTGCBzTAMExNYYDMMw8SEUL1E2BuEYRgmOELzEmEYhmGChU0iDMMwMYEFNsMwTExggc0wDBMTWGBvIIjoXUR0gIhuJaKXEtEHfOw7QkSvDalf1xHRtUHvb/X5IZ9t3UxEr/TYptwuEf0eEf2tvx4HAxH9WzOOyzSPyNV0ZELlHQCeL4R43Pr8XXUDIkoKIQqafbcDeB2Ar4XYvzAIa1VdAIAQ4pcAfhnSMdw7IIR7QVCm5WANe4NARDcB2AHgTiJ6NxFdTUSftn67mYhuIqL/A+ATRPRcIvoVET1IRL8kojSAvwRwmfXduzXtv4+IfkFEvyai66zvRojooNX+YSL6ChE9n4j+zfr8LFsTTyei+6zv/7Nbu9b3H7G2vQfAHtv3v2dt+ysAf2L7PkFENxDRz63f32b77f+3+vlDAEMO18+p3cuJ6A7r7+uI6EtEdA8RnSCiVxDRJ4jot0T0PSJKWts9k4juJqL7iehOIhq2vr+LiP7K6uMhIrrU+n6f9d2DVh92Wt/P2/pxIxE9RES/IaJX2/p2FxHdZp3frfqng4kNQgj+t0H+ATgOoM/6+2oAn7L+vhnAd2zbfQfAxdbf3SgN7Jfbt1HafSGA/2X9TQDuAHAZgBEAqwD2Wb89AODz1t8vA/BN6+/rAPwKQDuAAQCTALa6tPtMAL8B0AFgM4CjAK61tvsNgEutv28A8Fvr77cB+LD1dzuA+63+vQLAD6zvzwIwA+CVmnN0ard8XazzuMe6Xk8FkAfwIuu3261zbgNwL4AB6/tXA/iC9fddAG60/n4xgB9Zf38KwGutv9sAdFh/n7b+f5XtHIYATAAYtvo2Y50XAbgPwCXNfg75X+3/2CSysSDrn47bbH/fC+D/I6KvArhdCPGYRxDUiwC8kIgetNpPAxgD8DsAJ4QQB6zt9gP4F+vvh1ASmJJvCyFWAZwkon8F8GwAz3FodwtKwn4FwAoRfQcAiKgHQI8Q4l6rzVsB/DtbH59CRFdZn7dYbT0XlplHCPGEdewKPNpVuVMIUbRs3AkhxA9t5zuK0mzgQgA/otJFTQB43Lb/7db/v7Rdn58B+AgRnWud9zHlmJfaziFLRHcD+H0A8wB+IYR4wjqPX1t9uM+h70zEYYHNSPLyDyHEJ4jouwBeAuBeInqRx74E4C+FEJ+r+JJoBMCK7aui7XMRlc+f3dZMts+6dqtMMsq+Tt+/UwjxI6Wtl7i0VQsrACCEEES0Zvteni8BeFgIcanb/gAK1vYQQnzNMle9FMD3iOjtQoi7Xfpgvwb2619uk4knbMNmqiCiHUKI/UKIG1AyHZyPkra2xWGXHwB4i2XrBhGdTUQZ2ZzhYV9ORO1ENIDSVP5+AD90aPceAH9MRB1EtBnAHwGAEGIOwAwRXWK1+Qalj9cQUZvV1hgRdVttvcaycZ8F4Eq1Y1a7sw7tuqE798MAMkR0kdWPNiLa57Y/EW0XQpwQQnwawLdRMrfY2/+p7RwyKM1MfmHYRyZG8Gi7sXDymFC/fw8RXYmSRrYfwJ3WNgVr0e1LQoi/K+8sxI+I6HwAP7NMJ/MoCbWi0rabx8ZvAdyNkg37eiHEkwCe1LUrhPgVEX3d2mcKlcLpLQC+SERFlAS+5PMomQMetEwRWQB/LIT4JhE9zzrPSTibC5zadaPqfIUQa0T0HwB82jK1JAH8LYADmu3l51cT0RsBrAF4AsD/a//dOoeLULKzFwG83zKN7PXqDxMvOJcIwzBMTGCTCMMwTExggc0wDBMTWGAzDMPEBBbYDMMwMYEFNsMwTExggc0wDBMTWGAzDMPEBBbYDMMwMeH/AtMMvw3l1ajFAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f796dc7c160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for cat in ['Instrument Accessories', 'Stringed Instruments', 'Guitars']:\n",
    "    plt.scatter(scatterPlotsX[cat],\n",
    "            scatterPlotsY[cat], color='lightgrey', lw = 0, label = cat)\n",
    "    plt.legend(loc='lower left')\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.xlabel(\"first embedded dimension \")\n",
    "    plt.ylabel(\"second embedded dimension\")\n",
    "    plt.title(\"\\emph{TSNE}-based item embeddings\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}