main.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[38;5;2m[i 0521 14:01:20.143902 56 log.cc:351] Load log_sync: 1\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.270857 56 compiler.py:955] Jittor(1.3.7.15) src: /home/wjxie/.local/lib/python3.8/site-packages/jittor\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.280705 56 compiler.py:956] g++ at /usr/bin/g++(9.4.0)\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.283161 56 compiler.py:957] cache_path: /home/wjxie/.cache/jittor/jt1.3.7/g++9.4.0/py3.8.16/Linux-5.4.0-91xca/IntelRCoreTMi7xa6/default\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.307850 56 install_cuda.py:93] cuda_driver_version: [11, 5]\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.321171 56 __init__.py:411] Found /home/wjxie/.cache/jittor/jtcuda/cuda11.2_cudnn8_linux/bin/nvcc(11.2.152) at /home/wjxie/.cache/jittor/jtcuda/cuda11.2_cudnn8_linux/bin/nvcc.\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.333638 56 __init__.py:411] Found addr2line(2.34) at /usr/bin/addr2line.\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.551329 56 compiler.py:1010] cuda key:cu11.2.152_sm_61\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:20.837779 56 __init__.py:227] Total mem: 62.72GB, using 16 procs for compiling.\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:21.021723 56 jit_compiler.cc:28] Load cc_path: /usr/bin/g++\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:21.229875 56 init.cc:62] Found cuda archs: [61,]\u001b[m\n",
      "\u001b[38;5;2m[i 0521 14:01:23.342071 56 cuda_flags.cc:39] CUDA enabled.\u001b[m\n"
     ]
    }
   ],
   "source": [
    "## Import packets\n",
    "\n",
    "import logging\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import jittor as jt\n",
    "from jittor import nn\n",
    "from jittor import transform\n",
    "import jittor.models as models\n",
    "import jittor.optim as optim\n",
    "import jittor.nn as F\n",
    "import pygmtools as pygm\n",
    "from pygmtools.linear_solvers import sinkhorn\n",
    "import os\n",
    "import time\n",
    "import sklearn.model_selection\n",
    "\n",
    "\n",
    "pygm.BACKEND = 'jittor'\n",
    "# jt.flags.lazy_execution=0\n",
    "if jt.has_cuda:\n",
    "    jt.flags.use_cuda = 1\n",
    "\n",
    "logging.basicConfig(filename='output2.log', level=logging.INFO)\n",
    "logging.info(f\"\\n\\n----------{time.asctime()}----------\")\n",
    "\n",
    "from split import *\n",
    "from model import *\n",
    "\n",
    "from jittorsummary import summary\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Set Config  \n",
    "\n",
    "# logging.info(f\"\\n Enable sinkhorn, Enable my_cel; Add BN layer\")\n",
    "config={\n",
    "    \"use_cuda\":jt.flags.use_cuda,\n",
    "    \"preprocess\": True,\n",
    "    \"val_ratio\": 0.05,\n",
    "    'data_dir': './cifar-10-batches-py',\n",
    "    \"save_dir\": \"./save\",\n",
    "\n",
    "    \"model\":\"realsmallcnn\",\n",
    "    \"method\":\"relate\",  # \"classic\"/\"relate\"\n",
    "    \"criterion\":\"jittor_cel\",   #\"jittor_cel\"/\"my_cel\"/ \"my_mse\"\n",
    "    \"enable_sinkhorn\":False,\n",
    "    \"n_input\": [3,16,16],   # Input  of CNN\n",
    "    \n",
    "    \"epoch\":10,\n",
    "    \"eval_epoch\":2,\n",
    "    \"batch_size\":512,\n",
    "    \"num_workers\":8,\n",
    "    \n",
    "    \"lr\":5e-8,\n",
    "    \"betas\":(0.9, 0.9),#(0.9, 0.999)\n",
    "    \"dropout\":0.1,\n",
    "\n",
    "    \"enable_scheduler\":True,\n",
    "    \"milestones\":[15, 30, 40, 60, 70, 80],\n",
    "    \"gamma\":0.3,\n",
    "\n",
    "}\n",
    "logging.info(f\"Config: {config}\")\n",
    "\n",
    "if config[\"method\"]==\"relate\":\n",
    "    assert config[\"criterion\"]==\"jittor_cel\", f\"criterion: { config['criterion'] }, method: {config['method']}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'jittor.jittor_core.Var'>\n",
      "[47500,4,3,16,16,] [2500,4,3,16,16,] [10000,4,3,16,16,]\n"
     ]
    }
   ],
   "source": [
    "## Data Preprocess\n",
    "\n",
    "if config[\"preprocess\"]:\n",
    "    old_train_data, old_test_data = load_data(config)\n",
    "\n",
    "    def transform_old(data):\n",
    "        data = jt.array(data)\n",
    "        # data = data/255-0.5\n",
    "        return data\n",
    "\n",
    "    # old_train_data, old_test_data = transform_old(old_train_data), transform_old(old_test_data)\n",
    "\n",
    "    new_train_data = split_data(old_train_data)\n",
    "    new_test_data = split_data(old_test_data)\n",
    "    new_train_data, new_test_data = transform_old(new_train_data), transform_old(new_test_data)\n",
    "    ## save\n",
    "    jt.save(new_train_data, './data/new_train_data.pkl')\n",
    "    jt.save(new_test_data, './data/new_test_data.pkl')\n",
    "\n",
    "    # np.save('./data/old_train_data.npy', old_train_data )\n",
    "    # np.save('./data/new_train_data.npy', new_train_data)\n",
    "    # np.save('./data/old_test_data.npy', old_test_data)\n",
    "    # np.save('./data/new_test_data.npy', new_test_data)\n",
    "else:\n",
    "    ## load\n",
    "    old_train_data, old_test_data = None,None\n",
    "    new_train_data = jt.array(jt.load('./data/new_train_data.pkl'))\n",
    "    new_test_data = jt.array(jt.load('./data/new_test_data.pkl'))\n",
    "\n",
    "    # old_train_data, old_test_data = load_data(config)\n",
    "    # new_train_data = np.load('./data/new_train_data.npy')\n",
    "    # new_test_data = np.load('./data/new_test_data.npy')\n",
    "\n",
    "# new_train_data = new_train_data[:20000] ##DEBU\n",
    "# new_test_data = jt.Var(new_test_data)\n",
    "\n",
    "new_train_data = new_train_data.astype('float32')\n",
    "new_test_data = new_test_data.astype('float32')\n",
    "\n",
    "new_train_data,new_val_data = sklearn.model_selection.train_test_split(\n",
    "    new_train_data,test_size=config[\"val_ratio\"],shuffle=False)\n",
    "\n",
    "train_loader = jt.dataset.DataLoader(\n",
    "        dataset=jt.dataset.TensorDataset(new_train_data),\n",
    "        batch_size=config[\"batch_size\"],\n",
    "        shuffle=True,\n",
    "        num_workers=config[\"num_workers\"]\n",
    "        )\n",
    "val_loader = jt.dataset.DataLoader(\n",
    "        dataset=jt.dataset.TensorDataset(new_val_data),\n",
    "        batch_size=config[\"batch_size\"],\n",
    "        shuffle=False,\n",
    "        num_workers=config[\"num_workers\"]\n",
    "        )\n",
    "test_loader = jt.dataset.DataLoader(\n",
    "        dataset=jt.dataset.TensorDataset(new_test_data),\n",
    "        batch_size=config[\"batch_size\"],\n",
    "        shuffle=False,\n",
    "        num_workers=config[\"num_workers\"]\n",
    "        )\n",
    "\n",
    "print(new_train_data.__class__)\n",
    "print(new_train_data.shape, new_val_data.shape, new_test_data.shape)\n",
    "# (50000, 4, 3, 16, 16) (10000, 4, 3, 16, 16)\n",
    "# batch, patch, channel, row, col\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAAGxCAYAAABGE04NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABANUlEQVR4nO3de3CT95U38K/ulm/CxhdZwTaEe8FxFygXdwmU1G48DS2QbAndtM5MmzZh9w9CM2lJJoub7kCaTigzJaTbbPdNsiFNeiF+24Q2cRZw+paSBWpaSkhigolF8AXbYPkqydLv/YPaRdjY5zES+ln+fmY0YOn4PL9Hl3P0yNKRSSmlQERERNoxx3sBRERENDw2aSIiIk2xSRMREWmKTZqIiEhTbNJERESaYpMmIiLSFJs0ERGRptikiYiINMUmTUREpCk2aRrRmTNnsG7dOkyaNAmpqakoLS3Fn/70p3gvi4g0dfLkSWzcuBHLli1DSkoKTCYTDh48GO9ljVts0nRNFy5cwPLly/HBBx/gv/7rv/Dzn/8cfX19WLlyJd5///14L4+INHT06FFUVVUhMzMTt912W7yXM+6ZOLubruXhhx/Gzp07UVdXh8LCQgCAz+fD9OnTsWrVKrzyyitxXiER6SYcDsNsvnz898tf/hL/9E//hAMHDmDlypXxXdg4xSNpzVRWVsJkMqG2thbr1q1Deno6XC4X7rnnHly4cCEiNhwO48knn8ScOXPgcDiQk5ODr371qzh37lxEXG1tLe644w7k5OTA4XDA4/Hg85///JC4q7366qtYtWrVYIMGgPT0dKxbtw6/+c1v0N/fH70dJ6Ix06luDDRoig5em5pau3YtZsyYgV/+8peorKxEVVUVPve5zyEYDA7GPPDAA/j2t7+N0tJS/PrXv8b3vvc9/O53v0NJSQlaW1sBAN3d3SgtLUVzczOefvppVFdXY+fOnSgoKEBnZ+c1t9/b24sPP/wQt9xyy5DLbrnlFvT29uLMmTPR33EiGrN41w2KAUVa2bp1qwKgHnzwwYjz9+zZowCoF198USml1KlTpxQAtXHjxoi4d955RwFQjzzyiFJKqaNHjyoAqqqqytA6Pv74YwVAbd++fchlL730kgKgDh06ZCgnEcWGLnXjar/4xS8UAHXgwIHryjOR8UhaU//8z/8c8fOXvvQlWK1WHDhwAAAG/7333nsj4hYvXoy5c+fif/7nfwAAM2bMQEZGBr797W/jxz/+Md59911D6zCZTGO6jIhuPF3qBkUPm7Sm3G53xM9WqxWTJ09GW1sbAAz+m5eXN+R3PR7P4OUulws1NTX45Cc/iUceeQTz5s2Dx+PB1q1bI14Cu1pGRgZMJtNgniu1t7cDADIzM8e2c0QUE/GuGxR9bNKaampqivi5v78fbW1tmDx5MgAM/tvY2Djkd8+fP4+srKzBn4uKivDyyy+jra0Nx48fx/r16/H444/jqaeeuub2nU4nZsyYgRMnTgy57MSJE3A6nbj55pvHtG9EFBvxrhsUfWzSmtqzZ0/Ezz//+c/R398/+DGGVatWAQBefPHFiLgjR47g1KlTw34+0WQyobi4GD/84Q8xadKkUYeSrF27Fvv374fX6x08r7OzE3v37sUXvvAFWK3WsewaEcWIDnWDootVVlN79+6F1WpFaWkpTp48icceewzFxcX40pe+BACYPXs2vvGNb+BHP/oRzGYzysvLcfbsWTz22GPIz8/Hgw8+CAB47bXXsHv3bqxZswY333wzlFLYu3cvLl26hNLS0hHX8NBDD+G///u/8fnPfx6PP/44HA4HnnjiCfT19aGysjLWVwERGaRD3ejp6cG+ffsAAIcPHwYA1NTUoLW1FSkpKSgvL4/hNZCA4v3ONYo08C7NY8eOqdWrV6vU1FSVlpamNmzYoJqbmyNiQ6GQ+v73v69mzZqlbDabysrKUvfcc4/yer2DMe+9957asGGDmj59unI6ncrlcqnFixer5557TrSe06dPqzVr1qj09HSVnJysbrvtNnXs2LGo7jMRXR+d6kZ9fb0CMOypsLAw2rue8DhxTDOVlZX47ne/iwsXLkT8fYiI6FpYNxIX/yZNRESkKTZpIiIiTfHlbiIiIk3xSJqIiEhTbNJERESaYpMmIiLSlHbDTMLhMM6fP4+0tDR+gQNpRymFzs5OeDwefm+uZlg7SGdjrR3aNenz588jPz8/3ssgGpHX68WUKVPivQy6AmsHjQdGa0fMmvTu3bvxgx/8AI2NjZg3bx527tyJ5cuXj/p7aWlpAIA7vrABNpt9xFibzSZez0De0WRnTRbnzC/wiOJumnKTOGd2jmwQQcYklzhnUpJTFGc2y+8OZrPsSMVisRjIKXt2aTLJP5BgEj5hlW670+fDzYUF4vsTGTPWugH8/TF+4J0apKamjhjbfqFDvKZAn+z+5u/tF+dMS0oSxbU3D/0WumsxQ/aYbG1vEef8bfVvRHGpabL9AYCly0pEcZ6bpolztl7yi+I+OHNOnNMhfDHmH0sWiuJ6erqxfv0dhmtHTJr0K6+8gk2bNmH37t349Kc/jf/4j/9AeXk53n33XRQUFIz4uwMvU9ls9lGbtN0ub9J2u0MU5xA+eADA6UwWxaWkpIhzjlZcBhi5oZOE67SwScvz8uXUqLueugH8/TZJTU1FatrIjyN/b0i8LptFdn+zmOVf4ZgifOLcl9wnzilt0s5e2bYB+YGQ3cABk9Mp235ysrxuOgOyOuMQXu+AvEmnpMhq9gCjtSMmf1TbsWMHvva1r+HrX/865s6di507dyI/Px/PPPNMLDZHRAmAdYNoqKg36UAggGPHjqGsrCzi/LKyMhw6dGhIvN/vh8/nizgR0cRitG4ArB00MUS9Sbe2tiIUCiE3Nzfi/Nzc3CFfSA4A27dvh8vlGjzxjR9EE4/RugGwdtDEELPPkFz9urtSatjX4rds2YKOjo7Bk9frjdWSiEhz0roBsHbQxBD1N45lZWXBYrEMefbb0tIy5FkyADgcDjgcsjd1EVFiMlo3ANYOmhiifiRtt9uxcOFCVFdXR5xfXV2NkhLZW++JaGJh3SAaXkw+grV582Z85StfwaJFi7Bs2TL85Cc/QUNDA+6///5YbI6IEgDrBtFQMWnS69evR1tbGx5//HE0NjZi/vz52LdvHwoLC8U5Ll3qgtU68mfvLAY+29rdJfuwu98fEOfsD4VFcQryzwr398ty+vvkn8lMTpZ9TtrIcBirVbZPtlFuwytZrLK7o9VqYKSeTbZOu33kz+QPCATkAyvImGjUDQDo9JmgwiN/FrXTJy993T5ZTbh0Uf6Z5ncv1ovi+ntldQsAMtNkA47aOzrFOb+w9p9EcbNmyN+0l5aWLooLhOSP837Ihr7MmTlVnLPAnSOKswjnNkjjrhaziWMbN27Exo0bY5WeiBIQ6wZRJH5DABERkabYpImIiDTFJk1ERKQpNmkiIiJNsUkTERFpik2aiIhIU2zSREREmmKTJiIi0hSbNBERkaZiNnHsevn9/QiFRh7tZ2TkZFjJxuuFIf/ieItFtn2zWX41B4KysZPd3fIRhKmpKaI4h0N+fUpHiI422vVK0tGcdrv8+kxKkuVMciaJ4jo75SMVKT7qP7iI5OSRR3mervtInK+pUTZyssMnv290Bi6I4pzCxwQAmIUjhefNny3OmZM/UxSnjHQSYT20W+RJ3TmTRXEqLB/re/TIH0VxjefPieL8fvmI1yvxSJqIiEhTbNJERESaYpMmIiLSFJs0ERGRptikiYiINMUmTUREpCk2aSIiIk2xSRMREWmKTZqIiEhT+k4cCwQx2gCdQH9InM9ul02+CptGnnJ2pYu+bmFO2XQhAOjpk02luXipQ5wzPTVVFJfsdIhzSieOSeMAwG6XbT85Rb5Op3CfkpOTRXFdXV3ibVN8vPfen+FIco4Yc+LEu+J8Fy60i+L8wmmBAGBPl00BzJqUKc5pEx5zNbXK9gcAfF2yyYYZ6WninN5zH4vi6uvrxTnff+99UVxra6s4p11Yu5YsXSyK6+3tFW/7SjySJiIi0hSbNBERkabYpImIiDTFJk1ERKQpNmkiIiJNsUkTERFpik2aiIhIU2zSREREmmKTJiIi0hSbNBERkaa0HQtqc9hhtY48ls3n84nz9fbJxn0mJSWJcwaDQVGc3y8b9QkAfX7Z6Liubvl4yhSnbJ+ShKNTAfkIT4fDyKhR2d3R4bCLc6amycZ9pgpHp/b09Ii3TfFx7vwp2O0j30fON38gztfWflEUZ3eMPIr0SnmF/yCKU0HZWE4A6O6RjSluDHWKc576s+wx+ddj8pynP3hPFBcOy8c+50/xiOLKPvsZcc4Zs6aL4tLSZCNRxzpSmEfSREREmmKTJiIi0hSbNBERkabYpImIiDTFJk1ERKQpNmkiIiJNsUkTERFpik2aiIhIU2zSREREmtJ24pjFaoHFahkxJmRgIo10OlggGJDn7JflDIVlcQAQ6JdNGOrtk00XAoBL5pGvxwH2USa8XclikeU0MsFttClRf4+TrzPJKcuZ7JRNJuvrk02Eo/jpuNgFm23k272vp1+cT0F2f7PaUsQ5J7smieKaGs6Kc7Y3eUVx/iTZYxcA3g22ieIysjLFORctXCCKKy6eL86Zkz1ZFGexyI9LLcIJiNZR+tSAsIE+cCUeSRMREWkq6k26srISJpMp4uR2u6O9GSJKIKwbRMOLycvd8+bNw1tvvTX4s/SlUSKauFg3iIaKSZO2Wq3iZ8F+vz/iW6KMfLMVESUOI3UDYO2giSEmf5Ouq6uDx+PBtGnTcPfdd+PMmTPXjN2+fTtcLtfgKT8/PxZLIiLNGakbAGsHTQxRb9JLlizBCy+8gDfeeAPPPvssmpqaUFJSgra24d8luGXLFnR0dAyevF7ZOxSJKHEYrRsAawdNDFF/ubu8vHzw/0VFRVi2bBmmT5+O559/Hps3bx4S73A44HA4or0MIhpHjNYNgLWDJoaYfwQrJSUFRUVFqKuri/WmiChBsG4QXRbzJu33+3Hq1Cnk5eXFelNElCBYN4gui3qTfuihh1BTU4P6+nq88847uOuuu+Dz+VBRURHtTRFRgmDdIBpe1P8mfe7cOWzYsAGtra3Izs7G0qVLcfjwYRQWFhrKE+wPQo0S0x+Sj1kzCZ+OBA3kNAsniAaFoz4BoKevSxTn65SPxrSbZbF2q2yEphHSUZ8AYLPJ1pmUJM/pcMhyjjZGckAg4B89iAyLVt0AgExXAez2kf9WbZ2RK87X6w+L4hzJstGyAJCaIhujOf1m+WfFTX0XRXH9gQ5xzt4u2VjQlStKxDnnF8nGfWZmyUZ9AgBMsjCbsB4AgN0hqwlms6y52ALybV8p6k365ZdfjnZKIkpwrBtEw+PsbiIiIk2xSRMREWmKTZqIiEhTbNJERESaYpMmIiLSFJs0ERGRptikiYiINMUmTUREpKmoDzOJFrPFArNl5Gk7ZrNwzAwAi00Wa+mX5wwG+2U5DawzEJSNMevtledMEk4Sc1jlE3EsVtnzu74++cQks0l2d5RuGwAyMtJFcXa7bNJcUHj7UPykpqbA4UgaMaa5VT51K9Avuw9npEwS5wzBKYqbNEn+LV+z5n1CFJc5Sf44/8TcWaK4mwuninOmpckekyabvD0ps+w2MlvlOXt7ZJMiW1paRHHd3d3ibV+JR9JERESaYpMmIiLSFJs0ERGRptikiYiINMUmTUREpCk2aSIiIk2xSRMREWmKTZqIiEhTbNJERESaYpMmIiLSlLZjQW1WG6yjjLMMK3k+U1g29lE6mhIAoIQLUAbGl5pk4+2s5uivU0E25hQATMJ19vfLc9rtspzKwA2fmZkpipOu08goWoqP9vbzsNtHHqd58WKTOF+gX3Ys48pIFee0JcnGfXZb5Pf12Z+4RRS3bLFsfCgApDiF9UhaCwGYTLLrM2QgZ1dXpyju9Jl6cc4zH54RxX109qwoLhAY20hhHkkTERFpik2aiIhIU2zSREREmmKTJiIi0hSbNBERkabYpImIiDTFJk1ERKQpNmkiIiJNsUkTERFpStuJY7mTJ8M2ytSgSWnJ4nzTbs4Xxc2ZO1ec8/333hfFHT12VJzT75dNpXG5XOKck9Jlk5AKC24S58x1Z4vi/H3yKTsX27tFcX19feKc8+bJpisdOXJEFGc283mt7lJS0kadOJaZLp+Ed/HiRVGc78I5cc5U4WOyzy9OCUeS7PHrTEoR5zQr2QJ6DDwmO3w+UVy78HoH5I/fsx99JM6ZnCqrsQsXfkoU19vbC+D/iLc/gBWHiIhIU2zSREREmmKTJiIi0hSbNBERkabYpImIiDTFJk1ERKQpNmkiIiJNsUkTERFpik2aiIhIU2zSREREmtJ2LOjiT/0DnM6Rx35aLDZxvqysDFFc0S2yMZIAsGjBLaK4+fNniXOqsBLF5eTmiHNmZkwSxSU55NdnsF82LjDgD4pzvv/+GVGc2SRf5wcf1Ini/vznP4viQiH5OEmKj6lTC5CU5BwxJhyyi/OpsOw2b7vYJM7pa5fFzp0zU5wzzy2rCV2dXeKc7cJRpy2tF8Q5606flm27vV2cMxCQjR9esGChOGfRLf8gisvJdYviurrk1/uVDB9Jv/3221i9ejU8Hg9MJhOqqqoiLldKobKyEh6PB06nEytXrsTJkyfHtDgiSgysG0RjY7hJd3d3o7i4GLt27Rr28ieffBI7duzArl27cOTIEbjdbpSWlqKzs/O6F0tE4xPrBtHYGH65u7y8HOXl5cNeppTCzp078eijj2LdunUAgOeffx65ubl46aWX8M1vfvP6VktE4xLrBtHYRPWNY/X19WhqakJZWdngeQ6HAytWrMChQ4eG/R2/3w+fzxdxIqKJYyx1A2DtoIkhqk26qenymyFyc3Mjzs/NzR287Grbt2+Hy+UaPOXny773mYgSw1jqBsDaQRNDTD6CZTKZIn5WSg05b8CWLVvQ0dExePJ6vbFYEhFpzkjdAFg7aGKI6kew3O7Lb0VvampCXl7e4PktLS1DniUPcDgccDgc0VwGEY0jY6kbAGsHTQxRPZKeNm0a3G43qqurB88LBAKoqalBSUlJNDdFRAmCdYPo2gwfSXd1deH0FR9Gr6+vx/Hjx5GZmYmCggJs2rQJ27Ztw8yZMzFz5kxs27YNycnJ+PKXvxzVhRPR+MG6QTQ2hpv00aNH8ZnPfGbw582bNwMAKioq8Nxzz+Hhhx9Gb28vNm7ciIsXL2LJkiV48803kZaWZmg72ZMzkJw88sSxrs4ecb7OSx2iuIYG2dQrACiYOkUU96lPfVKc85JwnampKeKc7W1torhQWP7CitUii01OTRLnnDd/jijuxF/eE+c8cOCAKK6vr08Ux4ljY3Oj6gYA3DQld9Ta0dMjm1AFAGElu2/Yk+T3jfzcdFHckgXzxDlDAVk9fOPNGnHOjkuySWJ5nrzRg/4mOUVWu6w2+WTBefNk11NRUZE4p90x8n1oQEuL7DqS1pirGW7SK1euhFLXHl1pMplQWVmJysrKMS2IiBIP6wbR2PALNoiIiDTFJk1ERKQpNmkiIiJNsUkTERFpik2aiIhIU2zSREREmmKTJiIi0hSbNBERkabYpImIiDQV1W/BiqZJrlSkjDI+7sRfjovzNTe3iOIWqU+Kc86ZO10UFwzIRxD2B2Wj4/x91/4Kv6tNnjxJFGe1yZ+zWSyyOCNTNE0qLIrzehvEOX0+n3wBAqFQKKr5KPpmzpqG1NTUEWNcrkxxvpumZIvilJI/zjPTZeNOe7taxTn/953DorjWdlktBICs7MnCuGt/W9nVZs+eLYoz8g1nkya5hJHyuhkeYULelSZnZYni7GP8xjYeSRMREWmKTZqIiEhTbNJERESaYpMmIiLSFJs0ERGRptikiYiINMUmTUREpCk2aSIiIk2xSRMREWlK24ljMIcvn0Zgd8ifY8ybP0cUN2umbIoYADR+fE4Ud+6cLA4Agv2yEV0zZ84U50wdZXLbgP5wUJwTkE0HcyTZxBlbWppEcYf/KJusBABWq+wuHg7L9kcpPq/VnUIYatT7p3w62KSMZFGc1Sp7nAGAr6VZFtcpn5inTLJpePPmzxfnnD5jhihuzmx5PcrMzBDFmc3yx5o01u/3i3Mq4XQyZ5Ls/mE2yaedRfzemH6LiIiIYo5NmoiISFNs0kRERJpikyYiItIUmzQREZGm2KSJiIg0xSZNRESkKTZpIiIiTbFJExERaYpNmoiISFPajgW12C2w2C0jxqy5a7U4n9MpG9325htviHMePHBAFFdUVCTOuXTpUlFcZoZstB4ABIKyUaN2h12cE8IRhEbGaH744RlRXEtLizinUrI46VhQaRzFT3paClLTUkeJEt4xAHR3O2VxXZ3inOFJaaK4EGSPMwBYfutyUVxGZqY4Z5Jw5KUjSXYdAYDdkSSKCwrrFgCEhTenxSofU5zklO2TSTiS1OKXb/tKPJImIiLSFJs0ERGRptikiYiINMUmTUREpCk2aSIiIk2xSRMREWmKTZqIiEhTbNJERESaYpMmIiLSlLYTx266yYPUtJGn8gT6u8X5Av29ojiTySTOmZ2dK4r7zMpV4pwFBYWiuLa2VnHOJuGErmk3TxXntDtkd53eHtn1DgCHDv1RFBeWjhcyEGuxjDzd7u/k26b4mDQpA2np6SPG2Gzy6U8pKbKpW13J8qlb/tQUUVzB1KninBmZWaI4p3CSFgAEA0FRnM0mffwAJpPs2NDIbWS1yuqRkfpusclySiuC1cD+XIlH0kRERJoy3KTffvttrF69Gh6PByaTCVVVVRGX33vvvTCZTBEn6TxqIkpMrBtEY2O4SXd3d6O4uBi7du26Zsztt9+OxsbGwdO+ffuua5FENL6xbhCNjeG/SZeXl6O8vHzEGIfDAbfbLcrn9/vh9/sHf/b5fEaXRESai3bdAFg7aGKIyd+kDx48iJycHMyaNQv33XffiF8tuH37drhcrsFTfn5+LJZERJozUjcA1g6aGKLepMvLy7Fnzx7s378fTz31FI4cOYJVq1ZFPOO90pYtW9DR0TF48nq90V4SEWnOaN0AWDtoYoj6R7DWr18/+P/58+dj0aJFKCwsxOuvv45169YNiXc4HHA4HNFeBhGNI0brBsDaQRNDzD+ClZeXh8LCQtTV1cV6U0SUIFg3iC6LeZNua2uD1+tFXl5erDdFRAmCdYPoMsMvd3d1deH06dODP9fX1+P48ePIzMxEZmYmKisrceeddyIvLw9nz57FI488gqysLKxdu1aUXyk1uJ3RBEI94nWbIZs009srn5AVCAREcd3d8slonZ2dojjJ9TOgR7j9rk55TltANmGor/faf1O8mvT6DIX6xTlDIdk8IKVkz1cHtj1wPyWZWNcN4O+3ieQx1NUtv6/7+/pEcV0GHueBXlntCgTkJdpqk730398vf/zEYuJYMCjLCQOPMcs4mDg2cL80XDuUQQcOHFB/W1fEqaKiQvX09KiysjKVnZ2tbDabKigoUBUVFaqhoUGc3+v1DpufJ550Onm9XqMPnQkt1nVDKdYOnsbHyWjtMCml1yFBOBzG+fPnkZaWFvGsx+fzIT8/H16vF+mjzOUdDxJtf4DE26fh9kcphc7OTng8HpjNnKqrk+FqR6LdJ4HE26dE2x8gurVDuy/YMJvNmDJlyjUvT09PT5gbEki8/QESb5+u3h+XyxXH1dC1jFQ7Eu0+CSTePiXa/gDRqR08FCAiItIUmzQREZGmxk2Tdjgc2Lp1a8IML0i0/QESb58SbX8mokS8DRNtnxJtf4Do7pN2bxwjIiKiy8bNkTQREdFEwyZNRESkKTZpIiIiTbFJExERaWpcNOndu3dj2rRpSEpKwsKFC/H73/8+3ksas8rKSphMpoiT2+2O97LE3n77baxevRoejwcmkwlVVVURlyulUFlZCY/HA6fTiZUrV+LkyZPxWazQaPt07733DrnNli5dGp/FkiGJUjvGe90AEq923Ki6oX2TfuWVV7Bp0yY8+uijqK2txfLly1FeXo6GhoZ4L23M5s2bh8bGxsHTiRMn4r0kse7ubhQXF2PXrl3DXv7kk09ix44d2LVrF44cOQK3243S0lLxF4fEw2j7BAC33357xG22b9++G7hCGotEqx3juW4AiVc7bljdMDTpOw4WL16s7r///ojz5syZo77zne/EaUXXZ+vWraq4uDjey4gKAOrVV18d/DkcDiu3262eeOKJwfP6+vqUy+VSP/7xj+OwQuOu3iellKqoqFBf/OIX47IeGrtEqh2JVDeUSrzaEcu6ofWRdCAQwLFjx1BWVhZxfllZGQ4dOhSnVV2/uro6eDweTJs2DXfffTfOnDkT7yUN6z//8z+xZs0aTJ06FU6nEzNmzMADDzyAxsbGYePr6+vR1NQUcXs5HA6sWLFiXN9eAHDw4EHk5ORg1qxZuO+++9DS0hLvJdEIErF2jJe68bOf/Qy33norcnNz4XA44PF4sHr16hGv90StHdGoG1o36dbWVoRCIeTm5kacn5ubi6ampjit6vosWbIEL7zwAt544w08++yzaGpqQklJCdra2uK9tCG2bt2K1NRUbNu2Db/73e/w8MMP47XXXsPChQvR3Nw8JH7gNkmk2wsAysvLsWfPHuzfvx9PPfUUjhw5glWrVsHvl39XNt1YiVY7xlPdaGtrw6c//Wns3r0bb775Jnbs2IHm5mbceuutqKmpGfZ3ErF2RKtuaPctWMO5+ou6lVKGvrxbJ+Xl5YP/LyoqwrJlyzB9+nQ8//zz2Lx5cxxXNlRtbS1ycnIGf16xYgUWLFiAT33qU3j22Wev+XuJdHsBwPr16wf/P3/+fCxatAiFhYV4/fXXsW7dujiujEaTKPfF8VQ3/vVf/3XIeeXl5cjOzsZPf/pTrFix4pq/myi3FxC9uqH1kXRWVhYsFsuQZ1ItLS1DnnGNVykpKSgqKkJdXR2Av7+Ls7a2FuvWrUN6ejpcLhfuueceXLhwIeJ3w+EwnnzyScyZMwcOhwM5OTn46le/inPnzkXE1dbW4o477kBOTs7gy0+f//znh8Rd7coGPWDhwoWwWCzwer1DLht4t2ki314AkJeXh8LCwsHbjPST6LVD57oxnLS0NCQlJcFqHf64cCLUjrHWDa2btN1ux8KFC1FdXR1xfnV1NUpKSuK0qujy+/04deoU8vLyIs5fu3YtZsyYgV/+8peorKxEVVUVPve5zyEYDA7GPPDAA/j2t7+N0tJS/PrXv8b3vvc9/O53v0NJSQlaW1sBXH4HYmlpKZqbm/H000+juroaO3fuREFBwZjeNVlTU4NQKIR58+YNuWzatGlwu90Rt1cgEEBNTU3C3F7A5ZfzvF7vkNuM9JHotWM81I1QKIRgMIizZ8/igQcegFIK//Iv/zJs7ESoHWOuG9f91rMYe/nll5XNZlM//elP1bvvvqs2bdqkUlJS1NmzZ+O9tDH51re+pQ4ePKjOnDmjDh8+rO644w6VlpY2uD9bt25VANSDDz4Y8Xt79uxRANSLL76olFLq1KlTCoDauHFjRNw777yjAKhHHnlEKaXU0aNHFQBVVVV13Wv3+Xxq9uzZyu12qz/84Q8KgNqxY4eqra1VH330kVJKqSeeeEK5XC61d+9edeLECbVhwwaVl5enfD7fdW8/Vjo7O1Vtba2qra0dsk+dnZ3qW9/6ljp06JCqr69XBw4cUMuWLVM33XST1vtEiVU7xmPdmD17tgKgAKi8vDz15ptvXvNxptT4qx03qm5o36SVUurpp59WhYWFym63qwULFqiampp4L2nM1q9fr/Ly8pTNZlMej0etW7dOnTx5cvDygQfb0aNHI34vGAwqq9Wqvva1rymllNq9e7cCoP73f/93yDbmzp2rlixZopRS6tKlSyojI0PNnj1bPfPMMxHbMqK3t1d99rOfVUlJSYMPvCtPFRUVSqnLH6XYunWrcrvdyuFwqFtvvVWdOHFiTNu8UQ4cOHDNferp6VFlZWUqOztb2Ww2VVBQoCoqKlRDQ0O8l00CiVI7xmPd+Otf/6reeecd9Ytf/ELddtttKjk5OaFqx42qG+OiSU8kAw+2c+fODbksNzdXrVmzRiml1Pe+9z0FQHm93iFxt912m5oxY8bgz3/5y1/U+vXrVUZGxuCz2n/7t39TgUBAtKa+vj51++23q6SkJPXWW2+Ncc+IKFZ0rBtXCgaDav78+eqWW24x/LsTndZ/k57Irn4DRX9/P9ra2jB58mQAGPx3uM8snz9/HllZWYM/FxUV4eWXX0ZbWxuOHz+O9evX4/HHH8dTTz016jr8fj/WrFmDAwcOoKqqCrfddtv17BYRxZAudeNqVqsVCxYswAcffGD4dyc6NmlN7dmzJ+Lnn//85+jv78fKlSsBAKtWrQIAvPjiixFxR44cwalTp4ZtpiaTCcXFxfjhD3+ISZMm4U9/+tOIa/D7/Vi7di3279+PX/3qV/jc5z53HXtERLGmQ90YTl9fHw4fPowZM2YY/t2Jblx8Tnoi2rt3L6xWK0pLS3Hy5Ek89thjKC4uxpe+9CUAwOzZs/GNb3wDP/rRj2A2m1FeXo6zZ8/iscceQ35+Ph588EEAwGuvvYbdu3djzZo1uPnmm6GUwt69e3Hp0iWUlpaOuIa77roLv/3tb/Hoo49i8uTJOHz48OBl6enp+MQnPhG7K4CIDNOhbpSUlOALX/gC5s6dC5fLhbNnz+KZZ57Bhx9+iFdffTXm10HCiffr7RRp4G9Lx44dU6tXr1apqakqLS1NbdiwQTU3N0fEhkIh9f3vf1/NmjVL2Ww2lZWVpe65556Ivze99957asOGDWr69OnK6XQql8ulFi9erJ577rlR14Jh3hQxcFqxYkW0d52IxkinuvGtb31LFRcXK5fLpaxWq3K73Wrt2rXqD3/4Q9T3eyIwKaVU3J4h0BCVlZX47ne/iwsXLkT8fYiI6FpYNxIX/yZNRESkKTZpIiIiTfHlbiIiIk3xSJqIiEhTbNJERESa0u5z0uFwGOfPn0daWtq4/R5RSlxKKXR2dsLj8cBs5nNcnbB2kM7GWju0a9Lnz59Hfn5+vJdBNCKv14spU6bEexl0BdYOGg+M1g7tmnRaWhoAoN7rRXp6+oix4bD8PW9KyZ5Zm408ARe+564/2C9O2d3dI4rruCT/LujW1nZRXHNzszhnU5Ms9sKFFnHO9nbZOkOhsDhnZ1e3KK5fmDMYDOD137w8eD8lfQzcJn88/CekpqaOGNvc7BXnVQiJ4iZPln8++cPTH4ricnJzxDknZ04WxfX5+8Q5LTaHKM5ut4lzBoK9orj/W/WaOGfV3t+K4kJhizingqy++wN+2bZDIZx5/0+Ga0fMmvTu3bvxgx/8AI2NjZg3bx527tyJ5cuXj/p7Ay9TpaenT8gmbTbLbpKwrG4AAHp7A6K45OQucU6n0ymKcziSxDntdllBMNKkbbbg6EEATGZ5TgB8OTVGxlo3gL/fJqmpqaMWwq7ukZv4lZSSPX7T0uQ5k1OSRXGjPdmI3L6s+Ftt8rJvtcsev8aatGz7SUny2mGxCPfJFP0mbbEYKMYwXjti8ke1V155BZs2bcKjjz6K2tpaLF++HOXl5WhoaIjF5ogoAbBuEA0Vkya9Y8cOfO1rX8PXv/51zJ07Fzt37kR+fj6eeeaZWGyOiBIA6wbRUFFv0oFAAMeOHUNZWVnE+WVlZTh06NCQeL/fD5/PF3EioonFaN0AWDtoYoh6k25tbUUoFEJubm7E+bm5uUO+kBwAtm/fDpfLNXjiuzOJJh6jdQNg7aCJIWYf9Lz6j+NKqWH/YL5lyxZ0dHQMnrxe+bsuiSixSOsGwNpBE0PU392dlZUFi8Uy5NlvS0vLkGfJAOBwOOBwyN7VS0SJyWjdAFg7aGKI+pG03W7HwoULUV1dHXF+dXU1SkpKor05IkoArBtEw4vJ56Q3b96Mr3zlK1i0aBGWLVuGn/zkJ2hoaMD9998vzhEOXz6NxMj3d0m/7EsZ+AybCslydnfLPrwPABfbL4rimptbxTm93o9FcefOyeIAoKmpURTXLtwfAOjslL3xx+mUfcYUANraO0RxoX7Z56T7+2WfuybjolE3AOCPhw4heZT7SE+P/E1mcz8xUxRnt9vlOefOEcdKhZXs87pWq/yzwlaLLNbIR39PnDghiqup+b04Z7Bftu8hA7M1LDbZvtuTpPMd5Nf7lWLSpNevX4+2tjY8/vjjaGxsxPz587Fv3z4UFhbGYnNElABYN4iGitnEsY0bN2Ljxo2xSk9ECYh1gygSv8aHiIhIU2zSREREmmKTJiIi0hSbNBERkabYpImIiDTFJk1ERKQpNmkiIiJNsUkTERFpKmbDTG4M+Sw6k0k2Di4Uko2HBAB/X58o7tKlS+KcLS0XRHHSUZ8A0NBwThT38XnZqE8AaG5uFsX5OjvFOQN+vyhOQT5er6dHljMkHPHKsaDjgOqHUv0jhkzJd4vTBYKyx3lXl/y+npKSKooLBuX3N5vNJoozMr5UCWusNA4A+noDorj2NvlIYenWrVb5calFOBJVOmY11D+2Y2IeSRMREWmKTZqIiEhTbNJERESaYpMmIiLSFJs0ERGRptikiYiINMUmTUREpCk2aSIiIk2xSRMREWlqnE8ckzOZZDNpAgHZhCoA6LjUIYprvdAmzimdJHbmTL2BnLKJYy2t7eKcHT7ZdKXenl5xTunYoNSwbDoYAPT6ZdONTCbh1CADE+koPj75D0VITR15oldjk+wxAQBJSQ5RnMUiP+bxC6frpaSkiHOGw7L7pjQOAPpDIWGgfN/r6s6I4oJB4bYhf/xKp7IBgNUma4/S+8dYpxXySJqIiEhTbNJERESaYpMmIiLSFJs0ERGRptikiYiINMUmTUREpCk2aSIiIk2xSRMREWmKTZqIiEhTbNJERESa0nYsaCgUjuoIxpBwvF1Hh2zUJwBcuNAqijt3Tj6CUDrus77+rDhnS8sFUVxHp3yEZ7BfOIJQCWd9Agj1y26jYFA+FrRfmNNqk40VlG+Z4iXY70ewf+Txj/n5U8T5nE6nKE46mhIALFbZeMq+vj5xTmmsdEQyAJgtwnUKx+8CwIenZTXOBPn1aXfIRnPahNc7ACSnJIviJk1KF8UFg/Lr6Eo8kiYiItIUmzQREZGm2KSJiIg0xSZNRESkKTZpIiIiTbFJExERaYpNmoiISFNs0kRERJpikyYiItKUthPHJMJh+USy3l7ZNK1Ll+QTx5qbmkVxZ882iHN+9JEstvF8ozinz9cliuvrF6eEPxAUxUknvQHySUhB4RQxAAj0y9YZFs4SC4UMXEkUF2lpqUhLSxsxxmqVlz6lZHWms7NTnDMQlN0v7Xa7OKfNJpumpZR8bp7JLHtMdnfLagwAXLzkE8U5HCninElJSaK4ZOH0OABITx/5PjQgOydLFOf3+8XbvhKPpImIiDQV9SZdWVkJk8kUcXK73dHeDBElENYNouHF5OXuefPm4a233hr82WKRD0onoomJdYNoqJg0aavVymfBRGQI6wbRUDH5m3RdXR08Hg+mTZuGu+++G2fOnLlmrN/vh8/nizgR0cRjpG4ArB00MUS9SS9ZsgQvvPAC3njjDTz77LNoampCSUkJ2traho3fvn07XC7X4Ck/Pz/aSyIizRmtGwBrB00MUW/S5eXluPPOO1FUVITPfvazeP311wEAzz///LDxW7ZsQUdHx+DJ6/VGe0lEpDmjdQNg7aCJIeafk05JSUFRURHq6uqGvdzhcMDhcMR6GUQ0joxWNwDWDpoYYv45ab/fj1OnTiEvLy/WmyKiBMG6QXRZ1Jv0Qw89hJqaGtTX1+Odd97BXXfdBZ/Ph4qKimhviogSBOsG0fCi/nL3uXPnsGHDBrS2tiI7OxtLly7F4cOHUVhYaCjPwECDkQSFo/UAoKNDNu7zwoUL4pxe7zlRXEOD/G9lTcJRo5eE+wMAXZ3dorh+k2ysIAAEQ8KRrAZGEJrNsueMZgOfn5WOdPQH+kRxHAsaG9GqGwAA9bfTCJqbW8Tp/nrir6I4v4F6lJKaKoqbctNN4pxTpkwRxUnH7wKA2SJ7TF5svyTOGQzIxvqmp7vEOVNTZSNEMybJc2ZNzhTF3XST7NUe6Wjqq0W9Sb/88svRTklECY51g2h4nN1NRESkKTZpIiIiTbFJExERaYpNmoiISFNs0kRERJpikyYiItIUmzQREZGm2KSJiIg0FfMv2BircDiMcHjkaVG9vbIpUQBwse2iKO78uUZxzvqPPhbFnTsvmyIGAG3CyT09vX5xzl5/QBQXDMtzwiS765gMTAezCSchZbrSxTlbLsjW2ReQTYsyKfm0JoqP/ftr4HQ6R4wxMgUwVTgdbP4t88Q54zmT3G6XTxa02GSxarQRb1eY5JJN8rJY5OvMyJBNEsvOlm0bANw5OaK4vLxcUVxPj2zy49V4JE1ERKQpNmkiIiJNsUkTERFpik2aiIhIU2zSREREmmKTJiIi0hSbNBERkabYpImIiDTFJk1ERKQpNmkiIiJNaTsW1B8MwB8ceZxlZ2eXOF9ba/THgn78cZMorr3dJ87Z1SMbder3y8ZYAoASjtu0WeQjL0Mm2fO7kHxaIJKTRx7lOGDRgiJxzsxs2QjR2r+8K4rr75df7xQfHR2doz4+pk69WZwvKSlJFGeCfARuinDUaFpqmjin2Sx7TJqE9QAATGbZPmVMyhDnLCicIoqzWuzinFnCcZ/ZWQbGgubKxoJOzposiuvqkverK/FImoiISFNs0kRERJpikyYiItIUmzQREZGm2KSJiIg0xSZNRESkKTZpIiIiTbFJExERaYpNmoiISFPaThwL+APw+0eeONbW1ibO9/HHH4viGhtlU8QA4OJF2fZ7e+WTZvpHmbI2GNcviwMA6YAhi4EJPxaLTRSnhFOQAMBml90d8wtkE4sA4NMr/lEUl/HaG6I4v78PR//f6+Lt0423cuVnkDrKRK9QKCTOFw6HRXHJwiliAGCzy6brmYSPMwAwW6TlXD4GsD/QL4qzW+XrnDd3piguHJJd7wCQkTlJFDcpQxYHAJOzs2TbzpBNW3N2yibXXY1H0kRERJpikyYiItIUmzQREZGm2KSJiIg0xSZNRESkKTZpIiIiTbFJExERaYpNmoiISFNs0kRERJpikyYiItKUtmNBu7q7YRplpGR7e7s4X1OTbNxnc3OzOGdXZ6cozt/XK87ZH/TLApV8rKHJbJFGinNKJwuG+oPilO3traK4o8f/JM6Zm5cjilvyqU+K4np6usXbpviwWq2wWkcubXa7fASu0ykd4Sl9nAE24fatBsZtjrbPY2GCbJ9sNvk6p04tFEbKx5empaXL4lxp4pzpLlnO5ORkUZx0PPPVeCRNRESkKcNN+u2338bq1avh8XhgMplQVVUVcblSCpWVlfB4PHA6nVi5ciVOnjwZrfUS0TjEukE0NoabdHd3N4qLi7Fr165hL3/yySexY8cO7Nq1C0eOHIHb7UZpaSk6hS8NE1HiYd0gGhvDf8QoLy9HeXn5sJcppbBz5048+uijWLduHQDg+eefR25uLl566SV885vfvL7VEtG4xLpBNDZR/Zt0fX09mpqaUFZWNniew+HAihUrcOjQoWF/x+/3w+fzRZyIaOIYS90AWDtoYohqkx54B3Vubm7E+bm5udd8d/X27dvhcrkGT/n5+dFcEhFpbix1A2DtoIkhJu/uNl31XnOl1JDzBmzZsgUdHR2DJ6/XG4slEZHmjNQNgLWDJoaofrDO7XYDuPzMOC8vb/D8lpaWIc+SBzgcDjgcjmgug4jGkbHUDYC1gyaGqB5JT5s2DW63G9XV1YPnBQIB1NTUoKSkJJqbIqIEwbpBdG2Gj6S7urpw+vTpwZ/r6+tx/PhxZGZmoqCgAJs2bcK2bdswc+ZMzJw5E9u2bUNycjK+/OUvG9pOp88HFQ6PGNPaKptQBcgnjrW3t4lzdly6KIoz8oYWpWRTdiwGphsF/bKpXyYDT9nMVtnEM5tDPokox+MRxR2rrRXn9AsnhJXedpsozmRg0hv93Y2qGwBgNpthHmVaoXSKmJFYZWCklM0hmzhmZJLXSH8auFIoJL8P9/XKpiX29fWJc6akpori0oRxgHzqV3KqLA4AHEmyV2mktXisE+EM/9bRo0fxmc98ZvDnzZs3AwAqKirw3HPP4eGHH0Zvby82btyIixcvYsmSJXjzzTeRliYfx0ZEiYV1g2hsDDfplStXjni0ZzKZUFlZicrKyutZFxElENYNorHh7G4iIiJNsUkTERFpik2aiIhIU2zSREREmmKTJiIi0hSbNBERkabYpImIiDTFJk1ERKSpqH7BRjR1+HzoH2V8XUtLizzfpQ5RnJHxdslO2di4m26aLc556dIlUdzSpUvFOaXjU48e+7M4pzM5RRS3cNECcc7M7CxR3LvvvS/Oee7ceVFca8sFUVxvb4942xQfGRkZo04qk47QBABHUpIozmRgVK/JLNt+eJTRyFdqb28XblycEsE+2UjhnJwccc4k4fUpjQMAu104ZtVuoOUJbyNANsrZLM531e+N6beIiIgo5tikiYiINMUmTUREpCk2aSIiIk2xSRMREWmKTZqIiEhTbNJERESaYpMmIiLSFJs0ERGRprSdONbb0zPqVCCn0ynOV1JSIoqbOnWqOGdmRoYobs4c+cSx8+cbRXE3T79ZnNMhnMbzq1erxDmP19aK4rp8l8Q5L7TJJiZ5pkwT5/zw3b+K4t586y1RXDAYEG+b4sPusMPuGHkaoNUqL31ms+xYxmyVTxzrFU429Pl84pzBoGw6mGOU6+ZKmZmZorgkh3w6mM1mE8YZmOAmnSBnYOiXEsfKAo1MubsSj6SJiIg0xSZNRESkKTZpIiIiTbFJExERaYpNmoiISFNs0kRERJpikyYiItIUmzQREZGm2KSJiIg0xSZNRESkKW3Hgk6bOhWpaWkjxmRPzhbnMyvZ85H5fUXynKawKM5mk1/N6empojgjI+YuXGgWxX145n1xTq/3jCju4kXZqE8AcGVPEcVNypXv++Kl/yiKy52cIorr7e3Fr371onj7dOOZrVZYRnnMmS3yx6R0jKWCEueUjhpNSZHdLwH5qFO7cEwwANgssn23CPcHkO/7GKdojkh+CxnIKUwqjbsaj6SJiIg0xSZNRESkKTZpIiIiTbFJExERaYpNmoiISFNs0kRERJpikyYiItIUmzQREZGm2KSJiIg0pe3EMVuSHfakUSbjdMjzhUIhUVx3T7c4Z1bmJOG2+8U5W5pbRHFGpvG89LOfieKOHz8qzpnhconiPJ5ccc7ZRQtFcb1hpzgnTLLpSjNnzxHFdXfL7x8UH3aHA3aHI3oJhY81i9kiTpmUlCSKczrl93XpFELpxC8AsEpjDUzTGuvkrRtNPklMFiiNuxqPpImIiDRluEm//fbbWL16NTweD0wmE6qqqiIuv/fee2EymSJOS5cujdZ6iWgcYt0gGhvDTbq7uxvFxcXYtWvXNWNuv/12NDY2Dp727dt3XYskovGNdYNobAz/Tbq8vBzl5eUjxjgcDrjd7jEviogSC+sG0djE5G/SBw8eRE5ODmbNmoX77rsPLS3XfjOU3++Hz+eLOBHRxGOkbgCsHTQxRL1Jl5eXY8+ePdi/fz+eeuopHDlyBKtWrYLf7x82fvv27XC5XIOn/Pz8aC+JiDRntG4ArB00MUT9I1jr168f/P/8+fOxaNEiFBYW4vXXX8e6deuGxG/ZsgWbN28e/Nnn8/HBRjTBGK0bAGsHTQwx/5x0Xl4eCgsLUVdXN+zlDocDjmh+ppGIxr3R6gbA2kETQ8w/J93W1gav14u8vLxYb4qIEgTrBtFlho+ku7q6cPr06cGf6+vrcfz4cWRmZiIzMxOVlZW48847kZeXh7Nnz+KRRx5BVlYW1q5dK8o/MJWlq6tr1NhuQcxg3pBs2ouRiVJJdtnVFwrLJ4719PSI4oxMHAsGg6K4cDgszimd4CbdNgD4/X2iuIB8mfCbo3u79/xtIt1YpwdNVLGuG8Dfb5POzs6orl06ocvIJK/+fllNkE4RMxI7XiaOGalx4m0byCndJWkt6PzbGxsN1w5l0IEDB9Tf1h9xqqioUD09PaqsrExlZ2crm82mCgoKVEVFhWpoaBDn93q9w+bniSedTl6v1+hDZ0KLdd1QirWDp/FxMlo7TErpdUgQDodx/vx5pKWlRTwzHHhTiNfrRXp6ehxXGB2Jtj9A4u3TcPujlEJnZyc8Ho+hIxKKveFqR6LdJ4HE26dE2x8gurVDuy/YMJvNmDJlyjUvT09PT5gbEki8/QESb5+u3h+X8MtF6MYaqXYk2n0SSLx9SrT9AaJTO3goQEREpCk2aSIiIk2NmybtcDiwdevWhPlcZKLtD5B4+5Ro+zMRJeJtmGj7lGj7A0R3n7R74xgRERFdNm6OpImIiCYaNmkiIiJNsUkTERFpik2aiIhIU2zSREREmhoXTXr37t2YNm0akpKSsHDhQvz+97+P95LGrLKyEiaTKeLkdrvjvSyxt99+G6tXr4bH44HJZEJVVVXE5UopVFZWwuPxwOl0YuXKlTh58mR8Fis02j7de++9Q26zpUuXxmexZEii1I7xXjeAxKsdN6puaN+kX3nlFWzatAmPPvooamtrsXz5cpSXl6OhoSHeSxuzefPmobGxcfB04sSJeC9JrLu7G8XFxdi1a9ewlz/55JPYsWMHdu3ahSNHjsDtdqO0tDTq30wUTaPtEwDcfvvtEbfZvn37buAKaSwSrXaM57oBJF7tuGF1w9DXccTB4sWL1f333x9x3pw5c9R3vvOdOK3o+mzdulUVFxfHexlRAUC9+uqrgz+Hw2HldrvVE088MXheX1+fcrlc6sc//nEcVmjc1fuklFIVFRXqi1/8YlzWQ2OXSLUjkeqGUolXO2JZN7Q+kg4EAjh27BjKysoizi8rK8OhQ4fitKrrV1dXB4/Hg2nTpuHuu+/GmTNn4r2kqKivr0dTU1PE7eVwOLBixYpxfXsBwMGDB5GTk4NZs2bhvvvuQ0tLS7yXRCNIxNqRqHUDSNzaEY26oXWTbm1tRSgUQm5ubsT5ubm5aGpqitOqrs+SJUvwwgsv4I033sCzzz6LpqYmlJSUoK2tLd5Lu24Dt0ki3V4AUF5ejj179mD//v146qmncOTIEaxatQp+vz/eS6NrSLTakch1A0jM2hGtuqHdV1UO58rvlQYuv8Hg6vPGi/Ly8sH/FxUVYdmyZZg+fTqef/55bN68OY4ri55Eur0AYP369YP/nz9/PhYtWoTCwkK8/vrrWLduXRxXRqNJlPviRKgbQOLcXkD06obWR9JZWVmwWCxDnkm1tLQMecY1XqWkpKCoqAh1dXXxXsp1G3i3aSLfXgCQl5eHwsLChLjNElWi145EqhvAxKgdY60bWjdpu92OhQsXorq6OuL86upqlJSUxGlV0eX3+3Hq1Cnk5eXFeynXbdq0aXC73RG3VyAQQE1NTcLcXgDQ1tYGr9ebELdZokr02pFIdQOYGLVjrHVD+5e7N2/ejK985StYtGgRli1bhp/85CdoaGjA/fffH++ljclDDz2E1atXo6CgAC0tLfj3f/93+Hw+VFRUxHtpIl1dXTh9+vTgz/X19Th+/DgyMzNRUFCATZs2Ydu2bZg5cyZmzpyJbdu2ITk5GV/+8pfjuOqRjbRPmZmZqKysxJ133om8vDycPXsWjzzyCLKysrB27do4rppGk0i1Y7zXDSDxascNqxvX/f7wG+Dpp59WhYWFym63qwULFqiampp4L2nM1q9fr/Ly8pTNZlMej0etW7dOnTx5Mt7LEjtw4IACMORUUVGhlLr8UYqtW7cqt9utHA6HuvXWW9WJEyfiu+hRjLRPPT09qqysTGVnZyubzaYKCgpURUWFamhoiPeySSBRasd4rxtKJV7tuFF1g98nTUREpCmt/yZNREQ0kbFJExERaYpNmoiISFNs0kRERJpikyYiItIUmzQREZGm2KSJiIg0xSZNRESkKTZpIiIiTbFJExERaYpNmoiISFP/H3nL2n9e/druAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Show some data\n",
    "def show():\n",
    "    def de_transform(data):\n",
    "        # data = data+0.5\n",
    "        # data = data*255\n",
    "        # jt.sync_all()\n",
    "\n",
    "        return data.numpy().astype(np.uint8)\n",
    "\n",
    "    ind = np.random.randint(0,new_train_data.shape[0])\n",
    "    new_data,labels = shuffle_permutation(new_train_data[ind][None],config)\n",
    "    if old_train_data is not None:\n",
    "\n",
    "        plt.imshow( de_transform(jt.Var(old_train_data[ind])).transpose(1,2,0))\n",
    "        plt.show()\n",
    "\n",
    "    for i in range(4):\n",
    "        plt.subplot(2,2,i+1,label=f\"pos {i}\")\n",
    "        plt.gca().set_title(f\"pos {i}\")\n",
    "        # plt.legend()\n",
    "        plt.imshow(de_transform(new_data[0][i]).transpose(1,2,0))\n",
    "    print(labels[0])\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------------------------------------\n",
      "        Layer (type)               Output Shape         Param #\n",
      "================================================================\n",
      "              Conv-1           [-1, 32, 16, 16]             896\n",
      "        MakeModule-2           [-1, 32, 16, 16]               0\n",
      "           Dropout-3           [-1, 32, 16, 16]               0\n",
      "              Pool-4             [-1, 32, 8, 8]               0\n",
      "              Conv-5             [-1, 64, 8, 8]          18,496\n",
      "        MakeModule-6             [-1, 64, 8, 8]               0\n",
      "           Dropout-7             [-1, 64, 8, 8]               0\n",
      "              Conv-8            [-1, 128, 8, 8]          73,856\n",
      "        MakeModule-9            [-1, 128, 8, 8]               0\n",
      "          Dropout-10            [-1, 128, 8, 8]               0\n",
      "             Pool-11            [-1, 128, 4, 4]               0\n",
      "             Conv-12            [-1, 256, 4, 4]         295,168\n",
      "       MakeModule-13            [-1, 256, 4, 4]               0\n",
      "          Dropout-14            [-1, 256, 4, 4]               0\n",
      "             Conv-15            [-1, 256, 4, 4]         590,080\n",
      "       MakeModule-16            [-1, 256, 4, 4]               0\n",
      "          Dropout-17            [-1, 256, 4, 4]               0\n",
      "AdaptiveAvgPool2d-18            [-1, 256, 2, 2]               0\n",
      "           Linear-19                 [-1, 2048]       2,099,200\n",
      "       MakeModule-20                 [-1, 2048]               0\n",
      "          Dropout-21                 [-1, 2048]               0\n",
      "           Linear-22                 [-1, 1024]       2,098,176\n",
      "           Linear-23                 [-1, 8192]      33,562,624\n",
      "       MakeModule-24                 [-1, 8192]               0\n",
      "          Dropout-25                 [-1, 8192]               0\n",
      "           Linear-26                 [-1, 4096]      33,558,528\n",
      "       MakeModule-27                 [-1, 4096]               0\n",
      "          Dropout-28                 [-1, 4096]               0\n",
      "           Linear-29                   [-1, 16]          65,552\n",
      "     RealSmallCNN-30                   [-1, 16]               0\n",
      "================================================================\n",
      "Total params: 72,362,576\n",
      "Trainable params: 72,362,576\n",
      "Non-trainable params: 0\n",
      "----------------------------------------------------------------\n",
      "Input size (MB): 0.01\n",
      "Forward/backward pass size (MB): 1.03\n",
      "Params size (MB): 276.04\n",
      "Estimated Total Size (MB): 277.08\n",
      "----------------------------------------------------------------\n",
      "\n",
      "[5,4,3,16,16,]\n",
      "[5,4,4,]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[38;5;2m[i 0521 14:01:28.655039 56 560613846.py:24] \n",
      "=== display_memory_info ===\n",
      " total_cpu_ram: 62.72GB total_device_ram: 10.91GB\n",
      " hold_vars: 67 lived_vars: 86 lived_ops: 18\n",
      " name: sfrl is_device: 1 used: 1.496GB(91.1%) unused: 150.1MB(8.92%) total: 1.643GB\n",
      " name: sfrl is_device: 1 used:     0 B(0%) unused:   179MB(100%) total:   179MB\n",
      " name: sfrl is_device: 0 used:     0 B(0%) unused:   179MB(100%) total:   179MB\n",
      " name: sfrl is_device: 0 used:   512 B(0.000273%) unused:   179MB(100%) total:   179MB\n",
      " name: temp is_device: 0 used:     0 B(-nan%) unused:     0 B(-nan%) total:     0 B\n",
      " name: temp is_device: 1 used:     0 B(0%) unused: 319.8MB(100%) total: 319.8MB\n",
      " cpu&gpu: 2.479GB gpu:  2.13GB cpu:   358MB\n",
      " free: cpu(3.167GB) gpu(8.435GB)\n",
      " swap: total(    0 B) last(    0 B)\n",
      "===========================\n",
      "\u001b[m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5,4,4,]\n",
      "[5,4,]\n",
      "1.3946195840835571\n",
      "<class 'jittor.jittor_core.Var'>\n",
      "(5, 4) [[1 3 0 2]\n",
      " [1 3 0 2]\n",
      " [1 3 0 2]\n",
      " [1 3 0 2]\n",
      " [1 3 0 2]]\n"
     ]
    }
   ],
   "source": [
    "## Model Define\n",
    "\n",
    "model = get_model(config)\n",
    "algo = DPN_Algo(config,model,train_loader,val_loader,test_loader)\n",
    "\n",
    "## Warm up\n",
    "summary(model, (4,3,16,16),device=\"cuda\")\n",
    "logging.info(f\"Model: {model.modules()[0]} , Params num: {sum([p.numel() for p in model.parameters()])}\")\n",
    "model.eval()\n",
    "n= 5\n",
    "input = new_train_data[0:n]\n",
    "print(input.shape)\n",
    "output = model( jt.Var(input)).reshape(-1,4,4)\n",
    "print(output.shape)\n",
    "output = sinkhorn(output)\n",
    "print(output.shape)\n",
    "target = jt.arange(0,4).repeat(n).reshape(n,4)\n",
    "print(target.shape)\n",
    "loss = jt.nn.cross_entropy_loss(output.reshape(-1,4),target.reshape(-1,1))\n",
    "print(loss.item())\n",
    "print(input.__class__)\n",
    "infer = algo.inference(input)\n",
    "print(infer.shape,infer)\n",
    "jt.display_memory_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAw4AAAFvCAYAAADjdZybAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABWBElEQVR4nO3deVxU9f7H8dcwyg4uKIhKgKkoKrhgXtxLpdRQK3MrlzaztHJJU3HPrbyaplfMX6hZuVTqzVtm0aJp7iRpSporShhqLoAKAvP7g5wcAUcRHMD38/E4j8v5nu/5zufM9Hjc8/G7GUwmkwkREREREZGbsLN1ACIiIiIiUvQpcRAREREREauUOIiIiIiIiFVKHERERERExKpStg5ARERERIq/zMxMrl69auswJJ9Kly6N0Wi8aR0lDiIiIiKSbyaTiVOnTnH+/HlbhyJ3qGzZslSqVAmDwZDrdSUOIiIiIpJv15IGT09PnJ2d83zplKLLZDJx6dIlkpKSAPD29s61nhIHEREREcmXzMxMc9Lg4eFh63DkDjg5OQGQlJSEp6dnrsOWNDlaRERERPLl2pwGZ2dnG0ciBeHa75jXXBUlDiIiIiJyRzQ8qWSw9jsqcRAREREREauUOIiIiIiIiFVKHERERERE7oCfnx+zZ88ukLY2bNiAwWAoksvbalUlEREREbnntG7dmvr16xfIC//OnTtxcXG586CKOCUOIiIiIiI3MJlMZGZmUqqU9dflihUr3oWIbE9DlURERESk4KWmZh8m0z9l6enZZWlpudfNyvqn7OrV7LIrV6zXvU39+vVj48aNzJkzB4PBgMFgYMmSJRgMBr7++mtCQkJwcHBg06ZNHD58mM6dO+Pl5YWrqyuNGzfm22+/tWjvxqFKBoOB999/n8ceewxnZ2dq1KjB2rVr8x3vqlWrqFOnDg4ODvj5+TFz5kyL6/Pnz6dGjRo4Ojri5eVF165dzdc+++wz6tWrh5OTEx4eHrRt25bU1NR8xaHEQUREREQKnqtr9nHmzD9lM2Zklw0aZFnX0zO7PD7+n7L//Ce77LnnLOv6+WWXx8XlO7Q5c+YQGhrKCy+8QGJiIomJifj4+AAwYsQIpk2bRlxcHEFBQaSkpNChQwe+/fZbdu/ezcMPP0x4eDjx18eai4kTJ9KtWzf27NlDhw4deOqpp/jrr79uO9aYmBi6detGjx492Lt3LxMmTGDs2LEsWbIEgF27dvHqq68yadIkDhw4wPr162nZsiUAiYmJ9OzZk2effZa4uDg2bNjA448/jun6ZO42aKiSiIiIiNxTypQpg729Pc7OzlSqVAmA3377DYBJkybRrl07c10PDw+Cg4PN55MnT2bNmjWsXbuWQTcmQNfp168fPXv2BGDq1KnMnTuXHTt28Mgjj9xWrLNmzaJNmzaMHTsWgJo1a7J//35mzJhBv379iI+Px8XFhUcffRQ3Nzd8fX1p0KABkJ04ZGRk8Pjjj+Pr6wtAvXr1buvzr6ceBxEREREpeCkp2UeFCv+UDR+eXTZvnmXdpKTs8vvu+6ds4MDssqgoy7rHjmWX165dKGGHhIRYnKempjJixAgCAwMpW7Ysrq6u/Pbbb1Z7HIKCgsx/u7i44ObmRlJS0m3HExcXR7NmzSzKmjVrxu+//05mZibt2rXD19eXatWq0bt3bz7++GMuXboEQHBwMG3atKFevXo8+eST/N///R/nzp277RiuUeIgIiIiIgXPxSX7uH43Ynv77DIHh9zr2l33alq6dHaZo6P1ugUatuXqSMOHD2fVqlVMmTKFTZs2ERsbS7169UhPT79pO6VLl7Y4NxgMZOVjXobJZMqxo/P1Q43c3Nz4+eefWb58Od7e3owbN47g4GDOnz+P0WgkOjqar776isDAQObOnUtAQABHjx697ThAiYOIiIiI3IPs7e3JzMy0Wm/Tpk3069ePxx57jHr16lGpUiWOHTtW+AH+LTAwkM2bN1uUbdmyhZo1a2I0GgEoVaoUbdu25e2332bPnj0cO3aM77//HshOWJo1a8bEiRPZvXs39vb2rFmzJl+xaI6DiIiIiNxz/Pz82L59O8eOHcPV1TXP3oDq1auzevVqwsPDMRgMjB07Nl89B/k1bNgwGjduzJtvvkn37t3ZunUr8+bNY/78+QB88cUXHDlyhJYtW1KuXDnWrVtHVlYWAQEBbN++ne+++46wsDA8PT3Zvn07p0+fpnY+h3mpx0FERERE7jmvv/46RqORwMBAKlasmOechXfeeYdy5crRtGlTwsPDefjhh2nYsOFdi7Nhw4Z88sknrFixgrp16zJu3DgmTZpEv379AChbtiyrV6/moYceonbt2ixYsIDly5dTp04d3N3d+fHHH+nQoQM1a9ZkzJgxzJw5k/bt2+crFoMpv+sxiYiIiMg97cqVKxw9ehR/f38cb5yLIMWOtd9TPQ4iIiIiImKVEgcRERERkbtkwIABuLq65noMGDDA1uHdlIYqiYiIiEi+aKjS7UtKSuLixYu5XnN3d8fT0/MuR/QPa7+nVlUSEREREblLPD09bZoc3AkNVRIREREREauUOIiIiIiIiFVKHERERERExColDiIiIiIiYpUSBxERERERsUqJg4iIiIgI0Lp1awYPHlzon3Ps2DEMBgOxsbGF/lkFSYmDiIiIiIhYpcRBRERERESsUuIgIiIiIgUuNTX7MJn+KUtPzy5LS8u9blbWP2VXr2aXXblivW7+4kulT58+uLq64u3tzcyZMy2up6enM2LECKpUqYKLiwtNmjRhw4YNAFy4cAEnJyfWr19vcc/q1atxcXEhJSXltuPZuHEjDzzwAA4ODnh7ezNy5EgyMjLM1z/77DPq1auHk5MTHh4etG3bltTUVAA2bNjAAw88gIuLC2XLlqVZs2YcP378tmOwRomDiIiIiBQ4V9fs48yZf8pmzMguGzTIsq6nZ3Z5fPw/Zf/5T3bZc89Z1vXzyy6Pi7uz+IYPH84PP/zAmjVr+Oabb9iwYQMxMTHm68888ww//fQTK1asYM+ePTz55JM88sgj/P7775QpU4aOHTvy8ccfW7S5bNkyOnfujKur623FkpCQQIcOHWjcuDG//PILkZGRREVFMXnyZAASExPp2bMnzz77LHFxcWzYsIHHH38ck8lERkYGXbp0oVWrVuzZs4etW7fSv39/DAbDnX1BuShV4C2KiIiIiBRhKSkpREVFsXTpUtq1awfABx98QNWqVQE4fPgwy5cv5+TJk1SuXBmA119/nfXr17N48WKmTp3KU089RZ8+fbh06RLOzs5cvHiRL7/8klWrVt12PPPnz8fHx4d58+ZhMBioVasWf/zxB2+88Qbjxo0jMTGRjIwMHn/8cXx9fQGoV68eAH/99RcXLlzg0Ucf5f777wegdu3ad/wd5UaJg4iIiIgUuGujdZyd/ykbPhwGD4ZSN7yBJiVl/6+T0z9lAwfCCy+A0WhZ99ixnHVv1+HDh0lPTyc0NNRcVr58eQICAgD4+eefMZlM1KxZ0+K+tLQ0PDw8AOjYsSOlSpVi7dq19OjRg1WrVuHm5kZYWNhtxxMXF0doaKhFL0GzZs1ISUnh5MmTBAcH06ZNG+rVq8fDDz9MWFgYXbt2pVy5cpQvX55+/frx8MMP065dO9q2bUu3bt3w9vbOz1dzUxqqJCIiIiIFzsUl+7h+xIy9fXaZg0Pude2uezMtXTq7zNHRet3bZbp+4sV1srKyOH/+PEePHsVoNPL9998TGxtrPuLi4pgzZ87fz2JP165dWbp0Kfv372fBggW0bduWv/76K1/x3Di06FqMBoMBo9FIdHQ0X331FYGBgcydO5eAgACOHj0KwOLFi9m6dStNmzZl5cqV1KxZk23btt12HNYocRARERGRe0r16tUpXbq0xcv1uXPnOHToEKVKleLBBx8kMzOTM2fOUL16dYujUqVK5nuefPJJoqOj+eOPP4iJiaF3796cOHGCc+fO3VY8gYGBbNmyxSKh2bJlC25ublSpUgXITiCaNWvGxIkT2b17N/b29qxZs8Zcv0GDBowaNYotW7ZQt25dli1blt+vJ08aqpRPGRkZ7N69Gy8vL+zuJOUVERERKaYyMjLIyMggPT29SL4PmUwm0tPTcXJysvgXfWdnZ5577jmGDx+Oh4cHXl5eREREYGdnh6urK40bN+aRRx7hpZde4p133qFBgwacOXOG77//nnr16tGhQwcgey6Bh4cHr7/+On5+frRv357jx49z6tQpypUrd8txvvzyy8yePZtXXnmFQYMGceDAAcaPH8/QoUOxs7Nj+/btfPfdd4SFheHp6cn27ds5ffo0tWvX5ujRoyxcuJBOnTpRuXJlDhw4wMGDB+nTp0+Bf59KHPJp9+7dPPDAA7YOQ0RERMRmfH19WbBgAWk3rq9axFWuXJkZM2aQkpJCp06dcHNzY9iwYVy4cMFcZ/z48axevZphw4aRkJCAh4cHoaGh5qQBspd07dKlC++99x7jxo0DwN3dnTNnzpCVlXXLyVSVKlVYt24dw4cPJzg4mPLly/Pcc88xZswYc5s//vgjs2fP5uLFi/j6+jJz5kzat2/Pn3/+yW+//cYHH3zA2bNn8fb2ZtCgQbz44osF+I1lM5jyGuQlNxUfH4+vry87duwolMknIiIiIkVdRkYGycnJ+Pr64njjZIQi4OrVq8TFxVGnTh3s7e3N5QaDwepL/a5du7j//vtv2nOwd+9eKlSoYPEumJKSwm+//UZQUJDFZxYHV65c4ejRo/j7++f6e6rHIZ+u/cfm7e1tXrpLRERE5F5y5coVLl++jL29fZF+STYajRhvXJ6pkBXGPgq2VvQGo4mIiIiIFAOlS5fm6tWrFmVXr15l8eLFlCtXDldX1xxH+/btbRTtnVOPg4iIiIhIPri6unL+/HmLsosXL/L0008zZMiQXO9xupMNKGxMiYOIiIiICJCZmWkx0Ts9PZ1Lly5hNBpxcHDg5MmTXL16FX9/fwAqVqxIUlISJ06coEKFCqSmpnLmzBlq1ap1W6sqFRdKHEREREREgEuXLnHgwAHz+YkTJwDw8PDA39+fq1evkp6ebr7u4OBAjRo1OHHiBElJSZQuXRofH58SmTSAEgcREREREQDc3NwICQnJ8/q1noYb7wkMDCzMsIoMTY4WERERERGrlDiIiIiIiIhVShxERERERMQqJQ4iIiIiInfAz8+P2bNn2zqMQqfE4U6tW2frCERERETkNrVu3ZrBgwcXSFs7d+6kf//+BdJWUabE4U69+y6YTLaOQkREREQKkMlkIiMj45bqVqxYEWdn50KOyPaUONypyEgwGGwdhYiIiEiRknHpUp5H5nWbrFmrm3HlitW6t6tfv35s3LiROXPmYDAYMBgMLFmyBIPBwNdff01ISAgODg5s2rSJw4cP07lzZ7y8vHB1daVx48Z8++23Fu3dOFTJYDDw/vvv89hjj+Hs7EyNGjVYu3btLcWWmZnJc889h7+/P05OTgQEBDBnzpwc9RYtWkSdOnVwcHDA29ubQYMGma+dP3+e/v374+XlhaOjI3Xr1uWLL7647e/pRtrH4U7lsp6viIiIyL3uk8aN87xWuWVLWkdGms9XtWxJ5uXLudb1bNyYtkuWmM8/Dwsj7dw5izq99u27rdjmzJnDwYMHqVu3LpMmTQJg399tjBgxgn//+99Uq1aNsmXLcvLkSTp06MDkyZNxdHTkgw8+IDw8nAMHDnDffffl+RkTJ07k7bffZsaMGcydO5ennnqK48ePU758+ZvGlpWVRdWqVfnkk0+oUKECW7ZsoX///nh7e9OtWzcAIiMjGTp0KNOnT6d9+/ZcuHCBn376yXx/+/btSU5O5qOPPuL+++9n//79GI3G2/qOcqPEoaCYTOp5EBERESkGypQpg729Pc7OzlSqVAmA3377DYBJkybRrl07c10PDw+Cg4PN55MnT2bNmjWsXbvW4l/5b9SvXz969uwJwNSpU5k7dy47duzgkUceuWlspUuXZuLEieZzf39/tmzZwieffGJOHCZPnsywYcN47bXXzPUa/52offvtt+zYsYO4uDhq1qwJQLVq1ax/KbdAicOdOn8e5s2DmBj45hslDyIiIiJAt50787xmuOFfv5/48ce8G7KzHFnf+Ztv7igua27cOTo1NZWJEyfyxRdf8Mcff5CRkcHly5eJj4+/aTtBQUHmv11cXHBzcyMpKemWYliwYAHvv/8+x48f5/Lly6Snp1O/fn0AkpKS+OOPP2jTpk2u98bGxlK1alVz0lCQlDjcqatXsydIX74MmzZBy5a2jkhERETE5krdxmThwqqbHy4uLhbnw4cP5+uvv+bf//431atXx8nJia5du5Kenn7TdkqXLm1xbjAYyMrKsvr5n3zyCUOGDGHmzJmEhobi5ubGjBkz2L59OwBOTk43vd/a9TuhxOFOVawIb78Nvr7QooWtoxERERGRW2Bvb09mZqbVeps2baJfv3489thjAKSkpHDs2LFCi2vTpk00bdqUl19+2Vx2+PBh899ubm74+fnx3Xff8eCDD+a4PygoiJMnT3Lw4MEC73VQ4lAQbjK+TURERESKHj8/P7Zv386xY8dwdXXNszegevXqrF69mvDwcAwGA2PHjr2lnoP8ql69OkuXLuXrr7/G39+fDz/8kJ07d+J/3YI8EyZMYMCAAXh6eponQv/000+88sortGrVipYtW/LEE08wa9Ysqlevzm+//YbBYLA6v8IaLcda0ArxPyQRERERKRivv/46RqORwMBAKlasmOechXfeeYdy5crRtGlTwsPDefjhh2nYsGGhxTVgwAAef/xxunfvTpMmTTh79qxF7wNA3759mT17NvPnz6dOnTo8+uij/P777+brq1atonHjxvTs2ZPAwEBGjBhxS70r1hhMJu1elh8nT57Ex8eHEydOULVq1ezC5cth4kT4v//TsCUREREp8a5cucLRo0fx9/fH0dHR1uHkkJ6ezp49ewgKCsLe3t7W4RR51n5P9TgUpI0b4cABuG4DEBERERGRkkCJQ0EaORKmTYPrNikREREREblmwIABuLq65noMGDDA1uHdlCZHFyQ/v+zkQUREREQkF5MmTeL111/P9Zq7u/tdjub2KHEoTFevwg1r+IqIiIjIvcvT0xNPT09bh5EvGqpUGA4ehC5d4MknbR2JiIiIiEiBUI9DYTCZ4H//y/47Ph7uu8+28YiIiIiI3CH1OBSGgACYNw/27VPSICIiIiIlgnocCstLL9k6AhERERGRAqMeh7vh8mVbRyAiIiIickeUOBQmkwnGjoXKleG332wdjYiIiIjcROvWrRk8eLCtwyiylDgUJoMBfv0Vzp/XpnAiIiIiUqxpjkNhmzQJ+vaFTp1sHYmIiIiISL6px6Gw1auXvaeDnb5qERERuXekpqbneVy5knHLdS9fvmq1bv7iS6VPnz64urri7e3NzJkzLa6np6czYsQIqlSpgouLC02aNGHDhg0AXLhwAScnJ9avX29xz+rVq3FxcSElJcXq57/xxhvUrFkTZ2dnqlWrxtixY7l61fJZ165dS0hICI6OjlSoUIHHH3/cfC0tLY0RI0bg4+ODg4MDNWrUICoqKl/fxa1Sj8PdlJkJly6Bm5utIxEREREpVK6u7+Z5rUMHf7788gnzuafnfC5dysi1bqtWVdmwoYf53M/v/zhzxnLhGZPp9duOb/jw4fzwww+sWbOGSpUqMXr0aGJiYqhfvz4AzzzzDMeOHWPFihVUrlyZNWvW8Mgjj7B3715q1KhBx44d+fjjj3nkkUfMbS5btozOnTvj6upq9fPd3NxYsmQJlStXZu/evbzwwgu4ubkxYsQIAL788ksef/xxIiIi+PDDD0lPT+fLL78039+nTx+2bt3Ku+++S3BwMEePHuXMmTO3/T3cDiUOd8sPP8DAgdC8OSxcaOtoRERERO5ZKSkpREVFsXTpUtq1awfABx98QNWqVQE4fPgwy5cv5+TJk1SuXBmA119/nfXr17N48WKmTp3KU089RZ8+fbh06RLOzs5cvHiRL7/8klWrVt1SDGPGjDH/7efnx7Bhw1i5cqU5cZgyZQo9evRg4sSJ5nrBwcEAHDx4kE8++YTo6Gjatm0LQLVq1e7wW7FOicPd4uAAcXFw9izMng3OzraOSERERKTQpKS8muc1o9FyCHdS0st51rWzM1icHzv2wp0FRnZikJ6eTmhoqLmsfPnyBAQEAPDzzz9jMpmoWbOmxX1paWl4eHgA0LFjR0qVKsXatWvp0aMHq1atws3NjbCwsFuK4bPPPmP27NkcOnSIlJQUMjIycHd3N1+PjY3lhRdyf9bY2FiMRiOtWrW6ree+UzYdeB8ZGUlQUBDu7u64u7sTGhrKV199lWf9xMREevXqRUBAAHZ2dnkulzV79mwCAgJwcnLCx8eHIUOGcOXKFfP1adOm0bhxY9zc3PD09KRLly4cOHCgoB/PUtOm8MEHcPCgkgYREREp8Vxc7PM8HB1L3XJdJ6fSVuveLpPJdNPrWVlZGI1GYmJiiI2NNR9xcXHMmTMHAHt7e7p27cqyZcuA7GFK3bt3p1Qp6/8uv23bNnr06EH79u354osv2L17NxEREaSn/zNfw8nJKc/7b3atMNk0cahatSrTp09n165d7Nq1i4ceeojOnTuzb9++XOunpaVRsWJFIiIizF01N/r4448ZOXIk48ePJy4ujqioKFauXMmoUaPMdTZu3MjAgQPZtm0b0dHRZGRkEBYWRmpqaqE8p1mfPlCmTOF+hoiIiIjcVPXq1SldujTbtm0zl507d46DBw8C0KBBAzIzM0lKSqJ69eoWR6VKlcz3PPXUU6xfv559+/bxww8/8NRTT93S5//000/4+voSERFBSEgINWrU4Pjx4xZ1goKC+O6773K9v169emRlZbFx48bbffQ7YtOhSuHh4RbnU6ZMITIykm3btlGnTp0c9f38/MxZ3qJFi3Jtc+vWrTRr1oxevXqZ7+nZsyc7duww17lxBvzixYvx9PQkJiaGli1b3tEz3bLTp6FixbvzWSIiIiJi5urqynPPPcfw4cPx8PDAy8uLiIgI7P5eBbNmzZrmOQwzZ86kQYMGnDlzhu+//5569erRoUMHAFq1aoWXlxdPPfUUfn5+/Otf/7qlz69evTrx8fGsWLGCxo0b8+WXX7JmzRqLOuPHj6dNmzbcf//99OjRg4yMDL766itGjBiBn58fffv25dlnnzVPjj5+/DhJSUl069atYL+s6xSZNUIzMzNZsWIFqampFuPNblfz5s2JiYkxJwpHjhxh3bp1dOzYMc97Lly4AGSPbctLWloaFy9eNB/Jycn5CzA1Fbp2BT8/OHUqf22IiIiIyB2ZMWMGLVu2pFOnTrRt25bmzZvTqFEj8/XFixfTp08fhg0bRkBAAJ06dWL79u34+PiY6xgMBnr27Mkvv/xyy70NAJ07d2bIkCEMGjSI+vXrs2XLFsaOHWtRp3Xr1nz66aesXbuW+vXr89BDD7F9+3bz9cjISLp27crLL79MrVq1eOGFFwp99IzBZG2QVyHbu3cvoaGhXLlyBVdXV5YtW2bO4m6mdevW1K9fn9mzZ+e4NnfuXIYNG4bJZCIjI4OXXnqJ+fPn59qOyWSic+fOnDt3jk2bNuX5eRMmTLCY1X7NiRMnzDPwb4nJBM2awbZtsHhx9uZwIiIiIsXQlStXOHr0KP7+/jg6Oto6nBzS09PZs2cPQUFB2Nvf/lyIe42139PmPQ4BAQHExsaybds2XnrpJfr27cv+/fvz3d6GDRuYMmUK8+fP5+eff2b16tV88cUXvPnmm7nWHzRoEHv27GH58uU3bXfUqFFcuHDBfOQ7RoMB5s2DvXuVNIiIiIhIsWHz5Vjt7e2pXr06ACEhIezcuZM5c+bw3nvv5au9sWPH0rt3b55//nkge/JIamoq/fv3txi7BvDKK6+wdu1afvzxR6u9Bg4ODjg4OJjPL168mK/4AGjYMP/3ioiIiEiRNnXqVKZOnZrrtRYtWtx0FdGizOaJw41MJhNpaWn5vv/SpUsWyQGA0WjEZDKZl94ymUy88sorrFmzhg0bNuDv739HMd+RCxeyeyGuW7dXRERERIqvAQMG5DlJ2VZLqRYEmyYOo0ePpn379vj4+JCcnMyKFSvYsGGDedWjUaNGkZCQwNKlS833xMbGAtk7/p0+fZrY2Fjs7e0JDAwEsldqmjVrFg0aNKBJkyYcOnSIsWPH0qlTJ4xGIwADBw5k2bJlfP7557i5uXHq70nKZcqUubs/ZlQUDBsGr7wCeQylEhEREZHipXz58jdddKe4smni8Oeff9K7d28SExMpU6YMQUFBrF+/3rz1d2JiIvHx8Rb3NGjQwPx3TEwMy5Ytw9fXl2PHjgHZ23cbDAbGjBlDQkICFStWJDw8nClTppjvi4yMBLInWF9v8eLF9OvXr+AfNC/ly2f3OHz/PUyalN3zICIiIlLM2HitHSkg1n5Hm6+qVFydPHkSHx+f219V6XpZWfDVV9C+PdjZfJ66iIiIyG3JzMzk4MGDeHp64uHhYetwctCqSrfn7NmzJCUlUbNmTfNInesVuTkO9xQ7O7jJ/hIiIiIiRZnRaKRs2bIkJSUB4OzsjKEIjaBIT08HspcZzcrKuuX7zp49y5kzZ8jIyMDBwQFvb29cXFzyrH/u3DnOnDlDeno6RqMRV1dXKlWqRKlSxeNV22QycenSJZKSkihbtmyuSQMocSg6srLg0CGoWdPWkYiIiIjcskqVKgGYk4eiJCMjgzNnzuDg4HDLL/GpqamcOXOG8uXL4+joyIULF0hISKBy5cq5tnHlyhX+/PNPypUrh7OzMxkZGRw/fpyEhAQ8PT0L+pEKVdmyZc2/Z26UOBQF8fHZPQ+JiXDsGLi62joiERERkVtiMBjw9vbG09OTq1ev2jocC6dOnWLAgAFs2LDhpi/E1+vWrRuBgYFMmDDBXNahQwfatm3L0KFDc9RftGgRy5cvJzo62lz20Ucf8f7777Nhw4Y7fYS7pnTp0nn2NFyjxKEoqFIF0tPh6lXYvRtatLB1RCIiIiK3xWg0Wn3xvNtKlSrF8ePHuXz5snnYEuTcn+ua9PR01q1bxzPPPGOxc3K9evX4+uuvGT16dI576tevz5AhQ/j+++9p3749SUlJfPjhh9SvX79I7qZ9JzQjtygwGmHlyuzeBiUNIiIiIgUqMDCQMmXKmI9p06blWu/MmTNkZmbi5eVlUe7l5WVevv9GTZs25eOPP6Z79+7Y29tTqVIlypYty9y5cwv8OWxNiUNRUb8+lCtn6yhERERESpz9+/dz4cIF8zFq1Kib1r9xgrfJZMpz0vf+/ft59dVXGTduHDExMaxfv56jR48yYMCAAou/qNBQpaIoLg78/KAY7ywoIiIiUlS4ubnh7u5utV6FChUwGo05eheSkpJy9EJcM23aNJo1a8bw4cMBCAoKwsXFhRYtWjB58mS8vb3v/AGKCPU4FDVDh0KdOtm7SouIiIjIXWNvb0+jRo0sJjoDREdH07Rp01zvuXTpEnY37Md1ba5HSdsuTYlDUVOzJphM2b0OIiIiInJXDR06lPfff59FixYRFxfHkCFDiI+PNw89GjVqFH369DHXDw8PZ/Xq1URGRnLkyBF++uknXn31VR544AEqV65sq8coFBqqVNQ88ww0bQpBQbaOREREROSe0717d86ePcukSZNITEykbt26rFu3Dl9fXwASExOJj4831+/Xrx/JycnMmzePYcOGUbZsWR566CHeeustWz1CoTGYSlofyl1y8uRJfHx8OHHiBFWrVrV1OCIiIiJyA72vFSwNVSrKLl6E2FhbRyEiIiIiosShyNq2LXtlpSeegIwMW0cjIiIiIvc4JQ5FVb16UKoU2NvDiRO2jkZERERE7nGaHF1UubjApk1QvXr2ztIiIiIiIjakxKEoCwiwdQQiIiIiIoCGKhUPJhN8/TVkZdk6EhERERG5RylxKOpMJmjTBh55BFatsnU0IiIiInKPUuJQ1BkM0LIluLrC6dO2jkZERERE7lGa41AcDB0Kr7wCHh62jkRERERE7lFKHIoDd3dbRyAiIiIi9zgNVSpuDh6EmBhbRyEiIiIi9xglDsXJ8uVQuza89FL2pGkRERERkbtEiUNx0qYNODpCpUqQnGzraERERETkHqI5DsWJpyccPpydOIiIiIiI3EXqcShulDSIiIiIiA0ocSiuUlLgo49sHYWIiIiI3CM0VKk4unIFatWChATw8YFWrWwdkYiIiIiUcOpxKI4cHSE8HGrUgLQ0W0cjIiIiIvcA9TgUV2+9Bc7OUEo/oYiIiIgUPr11FlfaTVpERERE7iINVSruTCZYtw5++cXWkYiIiIhICabEobibMAE6doQxY2wdiYiIiIiUYEocirunnsoetlS7NmRl2ToaERERESmhNMehuKtZE/74A1xcbB2JiIiIiJRg6nEoCZQ0iIiIiEghU+JQkhw+DAsW2DoKERERESmBNFSppPjjj+zdpDMzoWVLCAy0dUQiIiIiUoIocSgpKlfO3k36yhVbRyIiIiIiJZASh5Jk+XJwcLB1FCIiIiJSAmmOQ0mipEFERERECokSh5IoNRVmzcqeLC0iIiIiUgA0VKkkev55WLEC9u+H99+3dTQiIiIiUgLYtMchMjKSoKAg3N3dcXd3JzQ0lK+++irP+omJifTq1YuAgADs7OwYPHhwrvVmz55NQEAATk5O+Pj4MGTIEK5cN2n4xx9/JDw8nMqVK2MwGPjvf/9bwE9mY6++CtWqQYsWto5EREREREoImyYOVatWZfr06ezatYtdu3bx0EMP0blzZ/bt25dr/bS0NCpWrEhERATBwcG51vn4448ZOXIk48ePJy4ujqioKFauXMmoUaPMdVJTUwkODmbevHmF8lw2FxoKBw9C3762jkRERERESgibDlUKDw+3OJ8yZQqRkZFs27aNOnXq5Kjv5+fHnDlzAFi0aFGubW7dupVmzZrRq1cv8z09e/Zkx44d5jrt27enffv2BfUYRZPRaOsIRERERKQEKTKTozMzM1mxYgWpqamEhobmu53mzZsTExNjThSOHDnCunXr6Nix4x3Fl5aWxsWLF81HcnLyHbV3V5hM8PXXMHeurSMRERERkWLO5pOj9+7dS2hoKFeuXMHV1ZU1a9YQeAe7Hvfo0YPTp0/TvHlzTCYTGRkZvPTSS4wcOfKO4pw2bRoTJ068ozbuuu3b4ZFHspdp7doVvL1tHZGIiIiIFFM273EICAggNjaWbdu28dJLL9G3b1/279+f7/Y2bNjAlClTmD9/Pj///DOrV6/miy++4M0337yjOEeNGsWFCxfMx53EeNc0aQLt2sFLL0Epm+eIIiIiIlKM2fxt0t7enurVqwMQEhLCzp07mTNnDu+9916+2hs7diy9e/fm+eefB6BevXqkpqbSv39/IiIisLPLX67k4OCAw3UbrF28eDFf7dxVBkP2UCWDwdaRiIiIiEgxZ/MehxuZTCbS0tLyff+lS5dyJAdGoxGTyYTJZLrT8IofJQ0iIiIiUgBs2uMwevRo2rdvj4+PD8nJyaxYsYINGzawfv16IHt4UEJCAkuXLjXfExsbC0BKSgqnT58mNjYWe3t787yI8PBwZs2aRYMGDWjSpAmHDh1i7NixdOrUCePfKw2lpKRw6NAhc5tHjx4lNjaW8uXLc999992lp7/Ljh2DGTNg4kSoUMHW0YiIiIhIMWPTxOHPP/+kd+/eJCYmUqZMGYKCgli/fj3t2rUDsjd8i4+Pt7inQYMG5r9jYmJYtmwZvr6+HDt2DIAxY8ZgMBgYM2YMCQkJVKxYkfDwcKZMmWK+b9euXTz44IPm86FDhwLQt29flixZUkhPa2M9emRPli5bFq77LkREREREboXBdE+O37lzJ0+exMfHhxMnTlC1alVbh2Pd55/D/Pkwfjw0bWrraEREREQKXbF7XyviitwcBykknTtnT5RW0iAiIiJyU/Pnz8ff3x9HR0caNWrEpk2bblo/LS2NiIgIfH19cXBw4P77789zs+LizOarKomIiIiIFBUrV65k8ODBzJ8/n2bNmvHee+/Rvn179u/fn+dc2G7duvHnn38SFRVF9erVSUpKIiMj4y5HXvg0VCmfim3X1+XLsHAhlC4NL79s62hERERECk1+3teaNGlCw4YNiYyMNJfVrl2bLl26MG3atBz1169fT48ePThy5Ajly5cvsNiLIg1VutesXQuDB8OYMZCcbOtoRERERApdcnIyFy9eNB95Lf2fnp5OTEwMYWFhFuVhYWFs2bIl13vWrl1LSEgIb7/9NlWqVKFmzZq8/vrrXL58+ZZi8/PzY9KkSTkWBCqKlDjca7p2hbAwmDYNrtvQTkRERKSkCgwMpEyZMuYjt54DgDNnzpCZmYmXl5dFuZeXF6dOncr1niNHjrB582Z+/fVX1qxZw+zZs/nss88YOHDgLcU2bNgwPv/8c6pVq0a7du1YsWLFHe1pVpiUONxrjMbsSdIvvgj29raORkRERKTQ7d+/nwsXLpiPUaNG3bS+4YYNdE0mU46ya7KysjAYDHz88cc88MADdOjQgVmzZrFkyZJb6nV45ZVXiImJISYmhsDAQF599VW8vb0ZNGgQP//8860/5F2gxEFERERESjQ3Nzfc3d3Nh0Meoy4qVKiA0WjM0buQlJSUoxfiGm9vb6pUqUKZMmXMZbVr18ZkMnHy5MlbjjE4OJg5c+aQkJDA+PHjef/992ncuDHBwcEsWrSIojAtWYnDvcpkgu++gyeeyJ4wLSIiInKPs7e3p1GjRkRHR1uUR0dH0zSPJe2bNWvGH3/8QUpKirns4MGD2NnZ3dYCOlevXuWTTz6hU6dODBs2jJCQEN5//326detGREQETz31VP4eqgBpOdZ7VUYGPP88HDuWvcrSa6/ZOiIRERERmxs6dCi9e/cmJCSE0NBQFi5cSHx8PAMGDABg1KhRJCQksHTpUgB69erFm2++yTPPPMPEiRM5c+YMw4cP59lnn8XJycnq5/38888sXryY5cuXYzQa6d27N++88w61atUy1wkLC6Nly5aF88C3QYnDvap06exdpH/+ObvXQURERETo3r07Z8+eZdKkSSQmJlK3bl3WrVuHr68vAImJiRYrILm6uhIdHc0rr7xCSEgIHh4edOvWjcmTJ9/S5zVu3Jh27doRGRlJly5dKF26dI46gYGB9OjRo2Ae8A5oH4d8Krb7OIiIiIjcI4rD+9rx48fNSUlRpzkOIiIiIiI2kpSUxPbt23OUb9++nV27dtkgorwpcRCIj4eBA2HJEltHIiIiInJPGThwICdOnMhRnpCQcMt7QdwtmuMgsHo1zJ8Pfn7w9NNQSv9ZiIiIiNwN+/fvp2HDhjnKGzRowP79+20QUd7U4yDQv3/2jtJLlihpEBEREbmLHBwc+PPPP3OUJyYmUqqIvZcpcRBwdoZPP4VWrWwdiYiIiMg9pV27dowaNYoLFy6Yy86fP8/o0aNp166dDSPLqWilMSIiIiIi95CZM2fSsmVLfH19adCgAQCxsbF4eXnx4Ycf2jg6S0oc5B9paRAVBWvWwPr1YDTaOiIRERGREq1KlSrs2bOHjz/+mF9++QUnJyeeeeYZevbsmeueDrakxEH+kZYGY8bAuXOwahV062briERERERKPBcXF/r372/rMKxS4iD/cHeHyZPBZIJOnWwdjYiIiMg9Y//+/cTHx5Oenm5R3qkIvZPlK3E4ceIEBoPBvAPfjh07WLZsGYGBgcUiW5KbePllW0cgIiIics84cuQIjz32GHv37sVgMGAymQAwGAwAZGZm2jI8C/laValXr1788MMPAJw6dYp27dqxY8cORo8ezaRJkwo0QLGxv//jFREREZGC99prr+Hv78+ff/6Js7Mz+/bt48cffyQkJIQNGzbYOjwL+Uocfv31Vx544AEAPvnkE+rWrcuWLVtYtmwZS7T7cMmwaRO0aQP/+5+tIxEREREpsbZu3cqkSZOoWLEidnZ22NnZ0bx5c6ZNm8arr75q6/As5CtxuHr1Kg4ODgB8++235rFXtWrVIjExseCiE9tZtw6+/x6mTbN1JCIiIiIlVmZmJq6urgBUqFCBP/74AwBfX18OHDhgy9ByyNcchzp16rBgwQI6duxIdHQ0b775JgB//PEHHh4eBRqg2MjQoZCSAq+/butIREREREqsunXrsmfPHqpVq0aTJk14++23sbe3Z+HChVSrVs3W4VnIV+Lw1ltv8dhjjzFjxgz69u1LcHAwAGvXrjUPYZJirmJFmDvX1lGIiIiIlGhjxowhNTUVgMmTJ/Poo4/SokULPDw8WLlypY2js2QwmfI3+zUzM5OLFy9Srlw5c9mxY8dwdnbG09OzwAIsqk6ePImPjw8nTpwwry5VoplM8PfsfhEREZHioLi+r/3111+UK1fOvLJSUZGvOQ6XL18mLS3NnDQcP36c2bNnc+DAgXsiabinnD4Nr74KYWFaYUlERESkAGVkZFCqVCl+/fVXi/Ly5csXuaQB8pk4dO7cmaVLlwJw/vx5mjRpwsyZM+nSpQuRkZEFGqDY2NWrsHAhfPst7Nhh62hERERESoxSpUrh6+tbpPZquJl8JQ4///wzLVq0AOCzzz7Dy8uL48ePs3TpUt59990CDVBsrHJl+Pe/sxMHzV8RERERKVBjxoxh1KhR/PXXX7YOxap8TY6+dOkSbm5uAHzzzTc8/vjj2NnZ8a9//Yvjx48XaIBSBAwaZOsIREREREqkd999l0OHDlG5cmV8fX1xcXGxuP7zzz/bKLKc8pU4VK9enf/+97889thjfP311wwZMgSApKQk3N3dCzRAKWIyMqBUvv6zEREREZEbdOnSxdYh3LJ8vQGOGzeOXr16MWTIEB566CFCQ0OB7N6HBg0aFGiAUoQsWgRvvgnLl8O//mXraERERESKvfHjx9s6hFuWr8Sha9euNG/enMTERPMeDgBt2rThscceK7DgpIj56Sc4dix7fwclDiIiIiL3lHyPOalUqRKVKlXi5MmTGAwGqlSpos3fSrrRoyE4GF54wdaRiIiIiJQIdnZ2N116tSituJSvxCErK4vJkyczc+ZMUlJSAHBzc2PYsGFERERgZ5evxZqkqLv//uw9HURERESkQKxZs8bi/OrVq+zevZsPPviAiRMn2iiq3OUrcYiIiCAqKorp06fTrFkzTCYTP/30ExMmTODKlStMmTKloOMUERERESlxOnfunKOsa9eu1KlTh5UrV/Lcc8/ZIKrc5Stx+OCDD3j//ffp1KmTuSw4OJgqVarw8ssvK3EQEREREbkDTZo04YUiNjw8X2OK/vrrL2rVqpWjvFatWsVi8woRERERkaLq8uXLzJ07l6pVq9o6FAv56nEIDg5m3rx5OXaJnjdvHkFBQQUSmIiIiIhISVeuXDmLydEmk4nk5GScnZ356KOPbBhZTvlKHN5++206duzIt99+S2hoKAaDgS1btnDixAnWrVtX0DGKiIiIiJRI77zzjkXiYGdnR8WKFWnSpAnlypWzYWQ55StxaNWqFQcPHuQ///kPv/32GyaTiccff5z+/fszYcIEWrRoUdBxioiIiIiUOP369bN1CLfMYDKZTAXV2C+//ELDhg2L1HqzheXkyZP4+Phw4sSJIjf+TERERESKx/va4sWLcXV15cknn7Qo//TTT7l06RJ9+/a1UWQ52XTDhcjISIKCgnB3d8fd3Z3Q0FC++uqrPOsnJibSq1cvAgICsLOzY/DgwbnWmz17NgEBATg5OeHj48OQIUO4cuWKRZ358+fj7++Po6MjjRo1YtOmTQX5aCIiIiIiVk2fPp0KFSrkKPf09GTq1Kk2iChvNk0cqlatyvTp09m1axe7du3ioYceonPnzuzbty/X+mlpaVSsWJGIiAiCg4NzrfPxxx8zcuRIxo8fT1xcHFFRUaxcuZJRo0aZ66xcuZLBgwcTERHB7t27adGiBe3btyc+Pr5QnlNEREREJDfHjx/H398/R7mvr2+Reze1aeIQHh5Ohw4dqFmzJjVr1mTKlCm4urqybdu2XOv7+fkxZ84c+vTpQ5kyZXKts3XrVpo1a0avXr3w8/MjLCyMnj17smvXLnOdWbNm8dxzz/H8889Tu3ZtZs+ejY+PD5GRkYXynCIiIiIiufH09GTPnj05yn/55Rc8PDxsEFHebmty9OOPP37T6+fPn893IJmZmXz66aekpqYSGhqa73aaN2/ORx99xI4dO3jggQc4cuQI69atM48PS09PJyYmhpEjR1rcFxYWxpYtW/JsNy0tjbS0NPN5cnJyvmMUEREREQHo0aMHr776Km5ubrRs2RKAjRs38tprr9GjRw8bR2fpthKHvP6V//rrffr0ua0A9u7dS2hoKFeuXMHV1ZU1a9YQGBh4W21cr0ePHpw+fZrmzZtjMpnIyMjgpZdeMicKZ86cITMzEy8vL4v7vLy8OHXqVJ7tTps2jYkTJ+Y7LhERERGRG02ePJnjx4/Tpk0bSpXKfjXPysqiT58+RW6Ow20lDosXLy7wAAICAoiNjeX8+fOsWrWKvn37snHjxnwnDxs2bGDKlCnMnz+fJk2acOjQIV577TW8vb0ZO3asud716+VC9mYbN5Zdb9SoUQwdOtR8npCQcEcJjoiIiIiIvb09K1euZPLkycTGxuLk5ES9evXw9fW1dWg55Gsfh4Jkb29P9erVAQgJCWHnzp3MmTOH9957L1/tjR07lt69e/P8888DUK9ePVJTU+nfvz8RERFUqFABo9GYo3chKSkpRy/E9RwcHHBwcDCfX7x4MV/xiYiIiIjcqEaNGtSoUcPWYdyUTSdH58ZkMlnMJbhdly5dws7O8rGMRiMmkwmTyYS9vT2NGjUiOjraok50dDRNmzbN9+eKiIiIiNyurl27Mn369BzlM2bMyLG3g63ZtMdh9OjRtG/fHh8fH5KTk1mxYgUbNmxg/fr1QPbwoISEBJYuXWq+JzY2FoCUlBROnz5NbGws9vb25mFD4eHhzJo1iwYNGpiHKo0dO5ZOnTphNBoBGDp0KL179yYkJITQ0FAWLlxIfHw8AwYMuLtfgIiIiIjc0zZu3Mj48eNzlD/yyCP8+9//tkFEebNp4vDnn3/Su3dvEhMTKVOmDEFBQaxfv5527doB2Ru+3bh+bYMGDcx/x8TEsGzZMnx9fTl27BgAY8aMwWAwMGbMGBISEqhYsSLh4eFMmTLFfF/37t05e/YskyZNIjExkbp167Ju3boiOZZMREREREqulJQU7O3tc5SXLl26yA2NN5hMJpOtgyiOisMW5iIiIiL3suLwvta4cWPCw8MZN26cRfmECRP43//+R0xMjI0iy8nmk6NFRERERIqS+fPnM2PGDBITE6lTpw6zZ8+mRYsWVu/76aefaNWqFXXr1jUPr7dm7NixPPHEExw+fJiHHnoIgO+++45ly5bx2Wef3cljFLgiNzlaRERERMRWVq5cyeDBg4mIiGD37t20aNGC9u3b5xg+f6MLFy7Qp08f2rRpc1uf16lTJ/773/9y6NAhXn75ZYYNG0ZCQgLff/89fn5+d/AkBU9DlfKpOHR9iYiIiNzL8vO+1qRJExo2bEhkZKS5rHbt2nTp0oVp06bleV+PHj2oUaMGRqOR//73v7fc43Cj8+fP8/HHHxMVFcUvv/xCZmZmvtopDOpxEBEREZESLTk5mYsXL5qPvJb+T09PJyYmhrCwMIvysLAwtmzZkmf7ixcv5vDhw7mujnSrvv/+e55++mkqV67MvHnz6NChA7t27cp3e4VBcxxEREREpES7tmz/NePHj2fChAk56p05c4bMzMwcmwJ7eXnl2Dz4mt9//52RI0eyadMmSpW6vVfrkydPsmTJEhYtWkRqairdunXj6tWrrFq1KkfMRYESBxEREREp0fbv30+VKlXM5w4ODjetbzAYLM5NJlOOMoDMzEx69erFxIkTqVmz5m3F1KFDBzZv3syjjz7K3LlzeeSRRzAajSxYsOC22rmblDiIiIiISInm5uaGu7u71XoVKlTAaDTm6F1ISkrK0QsB2UOgdu3axe7duxk0aBAAWVlZmEwmSpUqxTfffGNeKelG33zzDa+++iovvfQSNWrUyMdT3X2a4yAiIiIiAtjb29OoUSOio6MtyqOjo2natGmO+u7u7uzdu5fY2FjzMWDAAAICAoiNjaVJkyZ5ftamTZtITk4mJCSEJk2aMG/ePE6fPl3gz1SQ1OMgIiIiIvK3oUOH0rt3b0JCQggNDWXhwoXEx8czYMAAAEaNGkVCQgJLly7Fzs6OunXrWtzv6emJo6NjjvIbhYaGEhoaypw5c1ixYgWLFi1i6NChZGVlER0djY+PD25uboX2nPmhHgcRERERkb91796d2bNnM2nSJOrXr8+PP/7IunXr8PX1BSAxMdHqng63w9nZmWeffZbNmzezd+9ehg0bxvTp0/H09KRTp04F9jkFQfs45JP2cRAREREp2orr+1pmZib/+9//WLRoEWvXrrV1OGbqcRARERERKUKMRiNdunQpUkkDKHEQEREREZFboMRBRERERESsUuIgIiIiIiJWKXEQERERERGrlDiIiIiIiIhVShxERERERMQqJQ4iIiIiImKVEgcREREREbFKiYOIiIiIiFilxEFERERERKxS4iAiIiIiIlYpcRAREREREauUOIiIiIiIiFVKHERERERExColDiIiIiIiYpUSBxERERERsUqJg4iIiIiIWKXEQURERERErFLiICIiIiIiVilxEBERERERq5Q4iIiIiIiIVUocRERERETEKiUOIiIiIiJilRIHERERERGxSomDiIiIiIhYpcRBRERERESsUuIgIiIiIiJWKXEQERERERGrlDiIiIiIiIhVShxERERERMQqJQ4iIiIiImKVTROHyMhIgoKCcHd3x93dndDQUL766qs86ycmJtKrVy8CAgKws7Nj8ODBOeq0bt0ag8GQ4+jYsaO5TnJyMoMHD8bX1xcnJyeaNm3Kzp07C+MRRURERERKBJsmDlWrVmX69Ons2rWLXbt28dBDD9G5c2f27duXa/20tDQqVqxIREQEwcHBudZZvXo1iYmJ5uPXX3/FaDTy5JNPmus8//zzREdH8+GHH7J3717CwsJo27YtCQkJhfKcIiIiIiLFncFkMplsHcT1ypcvz4wZM3juueduWq9169bUr1+f2bNn37Te7NmzGTduHImJibi4uHD58mXc3Nz4/PPPLXoh6tevz6OPPsrkyZNvKc6TJ0/i4+PDiRMnqFq16i3dIyIiIiJ3j97XClYpWwdwTWZmJp9++impqamEhoYWWLtRUVH06NEDFxcXADIyMsjMzMTR0dGinpOTE5s3b86znbS0NNLS0sznycnJBRajiIiIiEhRZ/PJ0Xv37sXV1RUHBwcGDBjAmjVrCAwMLJC2d+zYwa+//srzzz9vLnNzcyM0NJQ333yTP/74g8zMTD766CO2b99OYmJinm1NmzaNMmXKmI+CilFEREREpDiweeIQEBBAbGws27Zt46WXXqJv377s37+/QNqOioqibt26PPDAAxblH374ISaTiSpVquDg4MC7775Lr169MBqNebY1atQoLly4YD4KKkYRERERkeLA5omDvb091atXJyQkhGnTphEcHMycOXPuuN1Lly6xYsUKi96Ga+6//342btxISkoKJ06cYMeOHVy9ehV/f/8823NwcDCv/uTu7o6bm9sdxygiIiIiUlzYPHG4kclksphLkF+ffPIJaWlpPP3003nWcXFxwdvbm3PnzvH111/TuXPnO/5cEREREZGSyKaTo0ePHk379u3x8fEhOTmZFStWsGHDBtavXw9kDw9KSEhg6dKl5ntiY2MBSElJ4fTp08TGxmJvb59jzkFUVBRdunTBw8Mjx+d+/fXXmEwmAgICOHToEMOHDycgIIBnnnmm8B5WRERERKQYs2ni8Oeff9K7d28SExMpU6YMQUFBrF+/nnbt2gHZG77Fx8db3NOgQQPz3zExMSxbtgxfX1+OHTtmLj948CCbN2/mm2++yfVzL1y4wKhRozh58iTly5fniSeeYMqUKZQuXbrgH1JEREREpAQocvs4FBdaF1hERESkaNP7WsEqcnMcRERERERsaf78+fj7++Po6EijRo3YtGlTnnVXr15Nu3btqFixIu7u7oSGhvL111/fxWjvHiUOIiIiIiJ/W7lyJYMHDyYiIoLdu3fTokUL2rdvn2P4/DU//vgj7dq1Y926dcTExPDggw8SHh7O7t2773LkhU9DlfJJXV8iIiIiRVt+3teaNGlCw4YNiYyMNJfVrl2bLl26MG3atFtqo06dOnTv3p1x48blK+6iSj0OIiIiIlKiJScnc/HiRfOR19L/6enpxMTEEBYWZlEeFhbGli1bbumzsrKySE5Opnz58nccd1GjxEFERERESrTAwEDKlCljPvLqOThz5gyZmZl4eXlZlHt5eXHq1Klb+qyZM2eSmppKt27d7jjuosamy7GKiIiIiBS2/fv3U6VKFfO5g4PDTesbDAaLc5PJlKMsN8uXL2fChAl8/vnneHp65i/YIkyJg4iIiIiUaG5ubri7u1utV6FCBYxGY47ehaSkpBy9EDdauXIlzz33HJ9++ilt27a9o3iLKg1VEhEREREB7O3tadSoEdHR0Rbl0dHRNG3aNM/7li9fTr9+/Vi2bBkdO3Ys7DBtRj0OIiIiIiJ/Gzp0KL179yYkJITQ0FAWLlxIfHw8AwYMAGDUqFEkJCSwdOlSIDtp6NOnD3PmzOFf//qXubfCycmJMmXK2Ow5CoMSBxERERGRv3Xv3p2zZ88yadIkEhMTqVu3LuvWrcPX1xeAxMREiz0d3nvvPTIyMhg4cCADBw40l/ft25clS5bc7fALlfZxyCft4yAiIiJStOl9rWBpjoOIiIiIiFilxEFERERERKxS4iAiIiIiIlYpcRAREREREauUOIiIiIiIiFVKHERERERExColDiIiIiIiYpUSBxERERERsUqJg4iIiIiIWKXEQURERERErFLiICIiIiIiVilxEBERERERq5Q4iIiIiIiIVUocRERERETEKiUOIiIiIiJilRIHERERERGxSomDiIiIiIhYpcRBRERERESsUuIgIiIiIiJWKXEQERERERGrlDiIiIiIiIhVShxERERERMQqJQ4iIiIiImKVEgcREREREbFKiYOIiIiIiFilxEFERERERKxS4iAiIiIiIlYpcRAREREREauUOIiIiIiIiFVKHERERERExColDiIiIiIiYpUSBxERERERscqmiUNkZCRBQUG4u7vj7u5OaGgoX331VZ71ExMT6dWrFwEBAdjZ2TF48OAcdVq3bo3BYMhxdOzY0VwnIyODMWPG4O/vj5OTE9WqVWPSpElkZWUVxmOKiIiIiBR7pWz54VWrVmX69OlUr14dgA8++IDOnTuze/du6tSpk6N+WloaFStWJCIignfeeSfXNlevXk16err5/OzZswQHB/Pkk0+ay9566y0WLFjABx98QJ06ddi1axfPPPMMZcqU4bXXXivgpxQRERERKf5smjiEh4dbnE+ZMoXIyEi2bduWa+Lg5+fHnDlzAFi0aFGubZYvX97ifMWKFTg7O1skDlu3bqVz587mXgg/Pz+WL1/Orl27bvsZtrz4Im6OjmBnh8FgAIMBg50dzpUq0eK65Gb7uHEkx8djsLMz17lW375MGZq9/ba57i9z5nDxyJF/2rSzwwBgZ0cpR0eaTJpkrvvb0qVcOHTon3avi8FgZ0ejUaPMdY98/jkXfv89u+4N8WIwULd/f+xKlwbg5A8/WLZ7XX3/Tp1wKFv2tr8rERERESm+bJo4XC8zM5NPP/2U1NRUQkNDC6zdqKgoevTogYuLi7msefPmLFiwgIMHD1KzZk1++eUXNm/ezOzZs/NsJy0tjbS0NPN5cnIyABcPHybDaMxZ/9w5i/Ozv/7K+QMHcm3bqWJFi/OknTs5vXt3rnVLu7paJA5/bNrEqS1bcq1rMBotEoeT333Hye++y7UuQJ0XXjD/Hb9+Pce++CLXepVbtFDiICIiInKPsXnisHfvXkJDQ7ly5Qqurq6sWbOGwMDAAml7x44d/Prrr0RFRVmUv/HGG1y4cIFatWphNBrJzMxkypQp9OzZM8+2pk2bxsSJE3OUh0yfjmeFCmAyYcrKMv9vKScni3oNhg0j/eLFf+pcV9/o4GBRt9Yzz+D36KMWda79r6GU5U9WrUsXPENC/qkD5ro3qvrgg7hWrYrJZIKsLEyQ/b9/nxvs/pny4tmoUXbvw9/tmutmZVHa1TXP70lERERESiaDyZTLG+ZdlJ6eTnx8POfPn2fVqlW8//77bNy40Wry0Lp1a+rXr3/TXoIXX3yRLVu2sHfvXovyFStWMHz4cGbMmEGdOnWIjY1l8ODBzJo1i759++ba1o09DgkJCQQGBnLixAmqVq166w8sIiIiInfFyZMn8fHx0ftaAbF5j4O9vb15cnRISAg7d+5kzpw5vPfee3fU7qVLl1ixYgWTrhvWc83w4cMZOXIkPXr0AKBevXocP36cadOm5Zk4ODg44HBdz8DFixfvKD4RERERkeKkyO3jYDKZLP5lP78++eQT0tLSePrpp3Ncu3TpEnZ2lo9uNBq1HKuIiIiISB5s2uMwevRo2rdvj4+PD8nJyaxYsYINGzawfv16AEaNGkVCQgJLly413xMbGwtASkoKp0+fJjY2Fnt7+xxDm6KioujSpQseHh45Pjc8PJwpU6Zw3333UadOHXbv3s2sWbN49tlnC+9hRURERESKMZsmDn/++Se9e/cmMTGRMmXKEBQUxPr162nXrh2QveFbfHy8xT0NGjQw/x0TE8OyZcvw9fXl2LFj5vKDBw+yefNmvvnmm1w/d+7cuYwdO5aXX36ZpKQkKleuzIsvvsi4ceMK/iFFREREREoAm0+OLq402UZERESkaNP7WsEqcnMcRERERERsaf78+fj7++Po6EijRo3YtGnTTetv3LiRRo0a4ejoSLVq1ViwYMFdivTuUuIgIiIiIvK3lStXMnjwYCIiIti9ezctWrSgffv2OYbPX3P06FE6dOhAixYt2L17N6NHj+bVV19l1apVdznywqehSvmkri8RERGRoi0/72tNmjShYcOGREZGmstq165Nly5dmDZtWo76b7zxBmvXriUuLs5cNmDAAH755Re2bt165w9RhNh8H4fi6trSrYmJiTaORERERERyc+097cKFC7i7u5vLb9yf65r09HRiYmIYOXKkRXlYWBhbtmzJ9TO2bt1KWFiYRdnDDz9MVFQUV69epXTp0nf6GEWGEod8OnHiBAAPPPCAjSMRERERkZupW7euxfn48eOZMGFCjnpnzpwhMzMTLy8vi3IvLy9OnTqVa9unTp3KtX5GRgZnzpzB29v7zoIvQpQ45FPt2rUB+PXXXylTpoyNo5HClpycTGBgIPv378fNzc3W4Ugh0+99b9HvfW/R731vuXDhAnXr1uXo0aOUL1/eXJ5bb8P1DAaDxbnJZMpRZq1+buXFnRKHfCpVKvur8/Hxsej6kpLp4sWLAFSpUkW/9z1Av/e9Rb/3vUW/973l2m9cvnz5W/q9K1SogNFozNG7kJSUlKNX4ZpKlSrlWr9UqVK5bkRcnGlVJRERERERwN7enkaNGhEdHW1RHh0dTdOmTXO9JzQ0NEf9b775hpCQkBI1vwGUOIiIiIiImA0dOpT333+fRYsWERcXx5AhQ4iPj2fAgAEAjBo1ij59+pjrDxgwgOPHjzN06FDi4uJYtGgRUVFRvP7667Z6hEKjoUr55ODgwPjx462OkZOSQb/3vUW/971Fv/e9Rb/3vSU/v3f37t05e/YskyZNIjExkbp167Ju3Tp8fX2B7JWart/Twd/fn3Xr1jFkyBD+85//ULlyZd59912eeOKJAn8eW9M+DiIiIiIiYpWGKomIiIiIiFVKHERERERExColDiIiIiIiYpUSBxERERERsUqJQz7Nnz8ff39/HB0dadSoEZs2bbJ1SFIIpk2bRuPGjXFzc8PT05MuXbpw4MABW4cld8G0adMwGAwMHjzY1qFIIUpISODpp5/Gw8MDZ2dn6tevT0xMjK3DkkKQkZHBmDFj8Pf3x8nJiWrVqjFp0iSysrJsHZoUgB9//JHw8HAqV66MwWDgv//9r8V1k8nEhAkTqFy5Mk5OTrRu3Zp9+/bZJthiTIlDPqxcuZLBgwcTERHB7t27adGiBe3bt7dYmktKho0bNzJw4EC2bdtGdHQ0GRkZhIWFkZqaauvQpBDt3LmThQsXEhQUZOtQpBCdO3eOZs2aUbp0ab766iv279/PzJkzKVu2rK1Dk0Lw1ltvsWDBAubNm0dcXBxvv/02M2bMYO7cubYOTQpAamoqwcHBzJs3L9frb7/9NrNmzWLevHns3LmTSpUq0a5dO5KTk+9ypMWblmPNhyZNmtCwYUMiIyPNZbVr16ZLly5MmzbNhpFJYTt9+jSenp5s3LiRli1b2jocKQQpKSk0bNiQ+fPnM3nyZOrXr8/s2bNtHZYUgpEjR/LTTz+px/ge8eijj+Ll5UVUVJS57IknnsDZ2ZkPP/zQhpFJQTMYDKxZs4YuXboA2b0NlStXZvDgwbzxxhsApKWl4eXlxVtvvcWLL75ow2iLF/U43Kb09HRiYmIICwuzKA8LC2PLli02ikrulgsXLgBQvnx5G0cihWXgwIF07NiRtm3b2joUKWRr164lJCSEJ598Ek9PTxo0aMD//d//2TosKSTNmzfnu+++4+DBgwD88ssvbN68mQ4dOtg4MilsR48e5dSpUxbvbg4ODrRq1UrvbrdJO0ffpjNnzpCZmYmXl5dFuZeXF6dOnbJRVHI3mEwmhg4dSvPmzalbt66tw5FCsGLFCn7++Wd27txp61DkLjhy5AiRkZEMHTqU0aNHs2PHDl599VUcHBzo06ePrcOTAvbGG29w4cIFatWqhdFoJDMzkylTptCzZ09bhyaF7Nr7WW7vbsePH7dFSMWWEod8MhgMFucmkylHmZQsgwYNYs+ePWzevNnWoUghOHHiBK+99hrffPMNjo6Otg5H7oKsrCxCQkKYOnUqAA0aNGDfvn1ERkYqcSiBVq5cyUcffcSyZcuoU6cOsbGxDB48mMqVK9O3b19bhyd3gd7d7pwSh9tUoUIFjEZjjt6FpKSkHJmslByvvPIKa9eu5ccff6Rq1aq2DkcKQUxMDElJSTRq1MhclpmZyY8//si8efNIS0vDaDTaMEIpaN7e3gQGBlqU1a5dm1WrVtkoIilMw4cPZ+TIkfTo0QOAevXqcfz4caZNm6bEoYSrVKkSkN3z4O3tbS7Xu9vt0xyH22Rvb0+jRo2Ijo62KI+OjqZp06Y2ikoKi8lkYtCgQaxevZrvv/8ef39/W4ckhaRNmzbs3buX2NhY8xESEsJTTz1FbGyskoYSqFmzZjmWVz548CC+vr42ikgK06VLl7Czs3ztMRqNWo71HuDv70+lSpUs3t3S09PZuHGj3t1uk3oc8mHo0KH07t2bkJAQQkNDWbhwIfHx8QwYMMDWoUkBGzhwIMuWLePzzz/Hzc3N3NNUpkwZnJycbBydFCQ3N7ccc1dcXFzw8PDQnJYSasiQITRt2pSpU6fSrVs3duzYwcKFC1m4cKGtQ5NCEB4ezpQpU7jvvvuoU6cOu3fvZtasWTz77LO2Dk0KQEpKCocOHTKfHz16lNjYWMqXL899993H4MGDmTp1KjVq1KBGjRpMnToVZ2dnevXqZcOoiyGT5Mt//vMfk6+vr8ne3t7UsGFD08aNG20dkhQCINdj8eLFtg5N7oJWrVqZXnvtNVuHIYXof//7n6lu3bomBwcHU61atUwLFy60dUhSSC5evGh67bXXTPfdd5/J0dHRVK1aNVNERIQpLS3N1qFJAfjhhx9y/f/rvn37mkwmkykrK8s0fvx4U6VKlUwODg6mli1bmvbu3WvboIsh7eMgIiIiIiJWaY6DiIiIiIhYpcRBRERERESsUuIgIiIiIiJWKXEQERERERGrlDiIiIiIiIhVShxERERERMQqJQ4iIiIiImKVEgcREREREbFKiYOIiNyRDRs2YDAYOH/+vK1DERGRQqTEQURERERErFLiICIiIiIiVilxEBEp5kwmE2+//TbVqlXDycmJ4OBgPvvsM+CfYURffvklwcHBODo60qRJE/bu3WvRxqpVq6hTpw4ODg74+fkxc+ZMi+tpaWmMGDECHx8fHBwcqFGjBlFRURZ1YmJiCAkJwdnZmaZNm3LgwIHCfXAREbmrlDiIiBRzY8aMYfHixURGRrJv3z6GDBnC008/zcaNG811hg8fzr///W927tyJp6cnnTp14urVq0D2C3+3bt3o0aMHe/fuZcKECYwdO5YlS5aY7+/Tpw8rVqzg3XffJS4ujgULFuDq6moRR0REBDNnzmTXrl2UKlWKZ5999q48v4iI3B0Gk8lksnUQIiKSP6mpqVSoUIHvv/+e0NBQc/nzzz/PpUuX6N+/Pw8++CArVqyge/fuAPz1119UrVqVJUuW0K1bN5566ilOnz7NN998Y75/xIgRfPnll+zbt4+DBw8SEBBAdHQ0bdu2zRHDhg0bePDBB/n2229p06YNAOvWraNjx45cvnwZR0fHQv4WRETkblCPg4hIMbZ//36uXLlCu3btcHV1NR9Lly7l8OHD5nrXJxXly5cnICCAuLg4AOLi4mjWrJlFu82aNeP3338nMzOT2NhYjEYjrVq1umksQUFB5r+9vb0BSEpKuuNnFBGRoqGUrQMQEZH8y8rKAuDLL7+kSpUqFtccHBwskocbGQwGIHuOxLW/r7m+M9rJyemWYildunSOtq/FJyIixZ96HEREirHAwEAcHByIj4+nevXqFoePj4+53rZt28x/nzt3joMHD1KrVi1zG5s3b7Zod8uWLdSsWROj0Ui9evXIysqymDMhIiL3HvU4iIgUY25ubrz++usMGTKErKwsmjdvzsWLF9myZQuurq74+voCMGnSJDw8PPDy8iIiIoIKFSrQpUsXAIYNG0bjxo1588036d69O1u3bmXevHnMnz8fAD8/P/r27cuzzz7Lu+++S3BwMMePHycpKYlu3brZ6tFFROQuU+IgIlLMvfnmm3h6ejJt2jSOHDlC2bJladiwIaNHjzYPFZo+fTqvvfYav//+O8HBwaxduxZ7e3sAGjZsyCeffMK4ceN488038fb2ZtKkSfTr18/8GZGRkYwePZqXX36Zs2fPct999zF69GhbPK6IiNiIVlUSESnBrq14dO7cOcqWLWvrcEREpBjTHAcREREREbFKiYOIiIiIiFiloUoiIiIiImKVehxERERERMQqJQ4iIiIiImKVEgcREREREbFKiYOIiIiIiFilxEFERERERKxS4iAiIiIiIlYpcRAREREREauUOIiIiIiIiFX/D2kxZtIdwTApAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x350 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1: train_loss 3.180224, train_acc 0.041, dev_loss 3.178024, dev_acc 0.048, \n",
      "\t time 19.915 s/epoch, total time 39.829 s, time left 159.318 s\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39m# Train\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m algo\u001b[39m.\u001b[39;49mtrain()\n",
      "File \u001b[0;32m/NAS2020/Datasets/DRLGroup/wjxie/DL_homework/Project/model.py:344\u001b[0m, in \u001b[0;36mDPN_Algo.train\u001b[0;34m(self, start_epoch)\u001b[0m\n\u001b[1;32m    341\u001b[0m logging\u001b[39m.\u001b[39minfo(output_info)\n\u001b[1;32m    343\u001b[0m \u001b[39mfor\u001b[39;00m epoch \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(start_epoch,\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconfig[\u001b[39m\"\u001b[39m\u001b[39mepoch\u001b[39m\u001b[39m\"\u001b[39m]):\n\u001b[0;32m--> 344\u001b[0m     train_loss, train_acc \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtrain_epoch(epoch)\n\u001b[1;32m    345\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtrain_loss_list\u001b[39m.\u001b[39mappend(train_loss)\n\u001b[1;32m    346\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtrain_acc_list\u001b[39m.\u001b[39mappend(train_acc)\n",
      "File \u001b[0;32m/NAS2020/Datasets/DRLGroup/wjxie/DL_homework/Project/model.py:310\u001b[0m, in \u001b[0;36mDPN_Algo.train_epoch\u001b[0;34m(self, epoch)\u001b[0m\n\u001b[1;32m    308\u001b[0m output \u001b[39m=\u001b[39m relate(output) \u001b[39m#[N,24]\u001b[39;00m\n\u001b[1;32m    309\u001b[0m loss \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcriterion(output,jt\u001b[39m.\u001b[39mVar(label)\u001b[39m.\u001b[39mreshape(\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m,\u001b[39m1\u001b[39m))\n\u001b[0;32m--> 310\u001b[0m predict \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_inference(output,relate_return_ind\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)          \u001b[39m## predict ,label are numpy array, int\u001b[39;00m\n\u001b[1;32m    311\u001b[0m acc \u001b[39m=\u001b[39m (predict \u001b[39m==\u001b[39m label)\u001b[39m.\u001b[39msum()\u001b[39m.\u001b[39mitem() \u001b[39m/\u001b[39m \u001b[39mlen\u001b[39m(label)\n\u001b[1;32m    313\u001b[0m \u001b[39mpass\u001b[39;00m\n",
      "File \u001b[0;32m/NAS2020/Datasets/DRLGroup/wjxie/DL_homework/Project/model.py:435\u001b[0m, in \u001b[0;36mDPN_Algo._inference\u001b[0;34m(self, Q, type, relate_return_ind)\u001b[0m\n\u001b[1;32m    432\u001b[0m         \u001b[39m# TODO: \u001b[39;00m\n\u001b[1;32m    433\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconfig[\u001b[39m\"\u001b[39m\u001b[39mmethod\u001b[39m\u001b[39m\"\u001b[39m]\u001b[39m==\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mrelate\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m    434\u001b[0m     \u001b[39m## Q:[N,24]\u001b[39;00m\n\u001b[0;32m--> 435\u001b[0m     ress \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmax(Q\u001b[39m.\u001b[39;49mnumpy(),axis\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m) \u001b[39m#[N,],np\u001b[39;00m\n\u001b[1;32m    436\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m relate_return_ind:\n\u001b[1;32m    437\u001b[0m         ress \u001b[39m=\u001b[39m PERM_ARRAY[ress]\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Train\n",
    "algo.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 这个是用来阻塞进程流的, 该部分以上是训练代码, 该部分以下是测试代码.\n",
    "raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(algo.best_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10\n",
    "for batch_idx, (data) in enumerate(algo.train_dataloader):\n",
    "            # data  : [N,4,3,16,16]\n",
    "    data = data[0]\n",
    "    X_tilde, label = shuffle_permutation(data,algo.config)\n",
    "    output = algo.model(X_tilde).reshape(-1,4,4)   # [N,4,4]\n",
    "\n",
    "    if algo.config[\"method\"]==\"classic\":\n",
    "        if algo.config[\"enable_sinkhorn\"]:\n",
    "            output = sinkhorn(output)              \n",
    "        loss = algo.criterion(output.reshape(-1,4),jt.Var(label).reshape(-1,1))\n",
    "        predict = algo._inference(output)          ## predict ,label are numpy array, int\n",
    "        acc = (np.all(predict == label,axis=1)).sum().item() / len(label)\n",
    "    elif algo.config[\"method\"]==\"relate\":\n",
    "        output = relate(output) #[N,24]\n",
    "        loss = algo.criterion(output,jt.Var(label).reshape(-1,1))\n",
    "        predict = algo._inference(output,relate_return_ind=True)          ## predict ,label are numpy array, int\n",
    "        acc = (predict == label).sum().item() / len(label)\n",
    "\n",
    "    algo.optimizer.step(loss)\n",
    "    algo.optimizer.zero_grad()\n",
    "    print(batch_idx,loss,acc)\n",
    "    N -=1\n",
    "    if N==0:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(jt.sum(algo.optimizer.param_groups[0][\"grads\"][0]**2) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_model(algo):\n",
    "    def de_transform(data):\n",
    "        # data = data+0.5\n",
    "        # data = data*255\n",
    "        # jt.sync_all()\n",
    "        return data.numpy().astype(np.uint8)\n",
    "\n",
    "    ind = np.random.randint(0,new_val_data.shape[0])\n",
    "    new_data,labels = shuffle_permutation(new_val_data[ind][None],config)\n",
    "    pred = algo.inference(new_data)\n",
    "        # pred = algo.inference(new_data,relate_return_ind=True)\n",
    "    # if old_train_data is not None:\n",
    "\n",
    "    #     plt.imshow( de_transform(old_train_data[ind]).transpose(1,2,0))\n",
    "    #     plt.show()\n",
    "\n",
    "    for i in range(4):\n",
    "        plt.subplot(2,2,i+1,label=f\"pos {i}\")\n",
    "        plt.gca().set_title(f\"pos {i}\")\n",
    "        # plt.legend()\n",
    "        plt.imshow(de_transform(new_data[0][i]).transpose(1,2,0))\n",
    "    print(\"True label: \",labels[0])\n",
    "    if config[\"method\"]==\"relate\":\n",
    "        print(\"Label: \",PERMUTATIONS[labels[0]] )\n",
    "    print(\"Predict:    \",pred[0])\n",
    "    print(\"Model Output: \",algo.model(new_data).reshape(-1,4,4)[0])\n",
    "    if config[\"enable_sinkhorn\"]:\n",
    "        print(\"Sinkhorn Output: \", sinkhorn(algo.model(new_data).reshape(-1,4,4))[0])\n",
    "        print(\"Loss: \", algo.criterion(sinkhorn(algo.model(new_data).reshape(-1,4,4)),jt.Var(labels)))\n",
    "\n",
    "test_model(algo)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "651718_epoch49: 是baseline, 按照标准做法训练的模型, jittor_cel, no sinkhorn, acc 0.865108 \n",
    "\n",
    "652728_epoch44: jittor_cel, sinkhorn, acc 0.725264\n",
    "\n",
    "659722_epoch42: relate方法, no sinkhorn, acc 0.909197"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# algo.continue_train(2,config[\"save_dir\"]+\"/651718_epoch49\")\n",
    "algo.load(config[\"save_dir\"]+\"/675216_epoch6\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "algo.test()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jittor",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "cbb19862eb77684089cc5cc2e527ffc1e5e76bacc5741479136c873c2e13945f"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}