styler_patch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from PIL import Image\n",
    "\n",
    "from network.styler import Unet\n",
    "from loss.loss import CLIPLoss\n",
    "from utils.func import get_features,vgg_normalize\n",
    "\n",
    "import time\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "lr1 = 0.0001\n",
    "lr2 = 0.0003\n",
    "# model = Unet(device)\n",
    "model = Unet().to(device)\n",
    "cliploss = CLIPLoss(device)\n",
    "mseloss = torch.nn.MSELoss()\n",
    "vgg = torchvision.models.vgg19(pretrained=True).features.to(device)\n",
    "for x in vgg.parameters():\n",
    "    x.requires_grad = False\n",
    "\n",
    "\n",
    "topil = transforms.ToPILImage()\n",
    "topic = transforms.ToTensor()\n",
    "\n",
    "dir_lambda = 500\n",
    "content_lambda = 150\n",
    "patch_lambda = 9000\n",
    "norm_lambda = 0.002\n",
    "gol_lambda = 300"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "file_cmp_outer = open(\"styler.txt\", \"r\")\n",
    "loss_li = file_cmp_outer.readline()\n",
    "loss_li = [float(x) for x in loss_li.split()]\n",
    "if not loss_li:\n",
    "    loss_li = [0]*200\n",
    "\n",
    "cur_times = int(file_cmp_outer.readline())"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "def train(iteration1, iteration2, pic, source, target, path):\n",
    "    input = pic\n",
    "\n",
    "    opt = optim.Adam(model.parameters(), lr=lr1)\n",
    "    for i in range(iteration1):\n",
    "        opt.zero_grad()\n",
    "        neo_pic = model(input)\n",
    "        loss = mseloss(pic, neo_pic) * content_lambda\n",
    "        loss.backward()\n",
    "        opt.step()\n",
    "        # pil = topil(neo_pic.squeeze(0).cpu())\n",
    "        # print(\"iter:\", i + 1, \"loss:\", loss.item())\n",
    "        # if ((i + 1) % 50) == 0:\n",
    "        #     pil.save(f\"./pic1/{(i + 1) // 50}.jpg\")\n",
    "    #\n",
    "    #\n",
    "    # torch.save(model,'unet.pth')\n",
    "\n",
    "    with torch.no_grad():\n",
    "        neo_pic = model(input)\n",
    "        pil = topil(neo_pic.squeeze(0).cpu())\n",
    "        pil = transforms.Resize(size=ori_size, interpolation=Image.BICUBIC)(pil)\n",
    "        pil.save(f\"mid.jpg\")\n",
    "\n",
    "    # model = torch.load('unet.pth')\n",
    "\n",
    "    pic_f = get_features(vgg_normalize(pic),vgg)\n",
    "\n",
    "    opt = optim.Adam(model.parameters(), lr=lr2)\n",
    "    sch = torch.optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.5)\n",
    "    for i in range(iteration2):\n",
    "\n",
    "\n",
    "        opt.zero_grad()\n",
    "        neo_pic = model(input)\n",
    "\n",
    "        dir_loss = 0\n",
    "        dir_loss += cliploss.forward_dir(pic, source, neo_pic, target)\n",
    "\n",
    "        gol_loss = 0\n",
    "        # gol_loss += cliploss.forward_gol(pic, source, neo_pic, target)\n",
    "\n",
    "        content_loss = 0\n",
    "        neo_pic_f = get_features(vgg_normalize(neo_pic), vgg)\n",
    "        content_loss += torch.mean((pic_f['conv4_2'] - neo_pic_f['conv4_2']) ** 2)\n",
    "        content_loss += torch.mean((pic_f['conv5_2'] - neo_pic_f['conv5_2']) ** 2)\n",
    "\n",
    "        patch_loss = 0\n",
    "        patch_loss += cliploss.forward_patch(pic, source, neo_pic, target)\n",
    "        # f,s,_ = cliploss.forward_patch_sec(pic, source, neo_pic, target)\n",
    "        # patch_loss += f+s\n",
    "\n",
    "        norm_loss = 0\n",
    "        norm_loss += cliploss.forward_prior(pic, source, neo_pic, target)\n",
    "\n",
    "        loss = dir_loss * dir_lambda + \\\n",
    "               content_loss * content_lambda + \\\n",
    "               patch_loss * patch_lambda + \\\n",
    "               norm_loss * norm_lambda + \\\n",
    "               gol_loss * gol_lambda\n",
    "\n",
    "        loss.backward()\n",
    "        opt.step()\n",
    "        sch.step()\n",
    "\n",
    "        loss_li[i]+=(loss.item())\n",
    "\n",
    "        print(\"iter:\", i + 1, \"loss:\", loss.item())\n",
    "\n",
    "\n",
    "        if (i+1)%10==0  or i==0:\n",
    "            neo_pic = model(input)\n",
    "            pil = topil(neo_pic.squeeze(0).cpu())\n",
    "            pil = transforms.Resize(size=ori_size, interpolation=Image.BICUBIC)(pil)\n",
    "            pil.save(f\"mid/{i//10}.jpg\")\n",
    "\n",
    "    # neo_pic = model(input)\n",
    "    # pil = topil(neo_pic.squeeze(0).cpu())\n",
    "    # # pil.save(f\"{source}-{target}.jpg\")\n",
    "    # pil.save(path)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\win10\\AppData\\Local\\Temp\\ipykernel_3328\\3799126218.py:3: DeprecationWarning: BICUBIC is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.BICUBIC instead.\n",
      "  pil = transforms.Resize(size=(512, 512), interpolation=Image.BICUBIC)(pil)\n",
      "E:\\Anaconda\\envs\\sth\\lib\\site-packages\\torchvision\\transforms\\transforms.py:257: UserWarning: Argument interpolation should be of type InterpolationMode instead of int. Please, use InterpolationMode enum.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "pil = Image.open(f\"./source_pic/emma.jpg\")\n",
    "ori_size = pil.size[::-1]\n",
    "pil = transforms.Resize(size=(512, 512), interpolation=Image.BICUBIC)(pil)\n",
    "pic = topic(pil).unsqueeze(0).to(device)\n",
    "# pic = torch.ones(1, 3, 512, 512).to(device)\n",
    "pic.requires_grad = False"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "# source = \"photo\"\n",
    "# source = \"black swan\"\n",
    "source = \"woman\"\n",
    "\n",
    "# target = \"pixar\"\n",
    "# target = \"cubism\"\n",
    "target = \"Mark Elliot Zuckerberg\"\n",
    "# target = \"Metal\"\n",
    "# target = \"Neon Light\"\n",
    "# target = \"white swan\"\n",
    "# target = \"Pixar\"\n",
    "# target = \"pop art of night city\"\n",
    "# target = \"starry night by Van Gogh\"\n",
    "# target = \"the scream by Edvard Munch\"\n",
    "# target = \"Monet\"\n",
    "# target = \"cyberpunk 2077\"\n",
    "# target = \"Chinese Ink and wash painting\"\n",
    "# target = \"fire\"\n",
    "# target = \"woman\"\n",
    "# target = \"man with dark black skin and black hair\"\n",
    "# target = \"gold boat\"\n",
    "# target = \"The great wave off kanagawa by Hokusai\"\n",
    "# target = \"angry peppa pig\"\n",
    "\n",
    "path = \"result/result1.jpg\""
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\win10\\AppData\\Local\\Temp\\ipykernel_3328\\1604932916.py:22: DeprecationWarning: BICUBIC is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.BICUBIC instead.\n",
      "  pil = transforms.Resize(size=ori_size, interpolation=Image.BICUBIC)(pil)\n",
      "C:\\Users\\win10\\AppData\\Local\\Temp\\ipykernel_3328\\1604932916.py:74: DeprecationWarning: BICUBIC is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.BICUBIC instead.\n",
      "  pil = transforms.Resize(size=ori_size, interpolation=Image.BICUBIC)(pil)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 1 loss: 10275.0244140625\n",
      "iter: 2 loss: 10248.927734375\n",
      "iter: 3 loss: 10120.09375\n",
      "iter: 4 loss: 10027.1611328125\n",
      "iter: 5 loss: 9839.421875\n",
      "iter: 6 loss: 9760.21875\n",
      "iter: 7 loss: 9670.7109375\n",
      "iter: 8 loss: 9516.705078125\n",
      "iter: 9 loss: 9314.1142578125\n",
      "iter: 10 loss: 9323.27734375\n",
      "iter: 11 loss: 9110.296875\n",
      "iter: 12 loss: 8968.4736328125\n",
      "iter: 13 loss: 8843.4970703125\n",
      "iter: 14 loss: 8771.7265625\n",
      "iter: 15 loss: 8730.2001953125\n",
      "iter: 16 loss: 8174.3017578125\n",
      "iter: 17 loss: 8366.6064453125\n",
      "iter: 18 loss: 8125.93359375\n",
      "iter: 19 loss: 7682.9580078125\n",
      "iter: 20 loss: 7761.54541015625\n",
      "iter: 21 loss: 7110.607421875\n",
      "iter: 22 loss: 7328.0751953125\n",
      "iter: 23 loss: 6463.55810546875\n",
      "iter: 24 loss: 6847.74560546875\n",
      "iter: 25 loss: 7762.07958984375\n",
      "iter: 26 loss: 5951.7978515625\n",
      "iter: 27 loss: 7017.71240234375\n",
      "iter: 28 loss: 5606.15966796875\n",
      "iter: 29 loss: 6066.39501953125\n",
      "iter: 30 loss: 5602.75830078125\n",
      "iter: 31 loss: 6021.6279296875\n",
      "iter: 32 loss: 5621.32275390625\n",
      "iter: 33 loss: 5999.37353515625\n",
      "iter: 34 loss: 6057.45166015625\n",
      "iter: 35 loss: 5575.06640625\n",
      "iter: 36 loss: 5489.12353515625\n",
      "iter: 37 loss: 4197.80859375\n",
      "iter: 38 loss: 5776.94482421875\n",
      "iter: 39 loss: 4817.06591796875\n",
      "iter: 40 loss: 4944.31396484375\n",
      "iter: 41 loss: 4509.48388671875\n",
      "iter: 42 loss: 5076.69140625\n",
      "iter: 43 loss: 4955.92724609375\n",
      "iter: 44 loss: 5013.748046875\n",
      "iter: 45 loss: 4505.08251953125\n",
      "iter: 46 loss: 4454.0703125\n",
      "iter: 47 loss: 5098.65234375\n",
      "iter: 48 loss: 3810.19970703125\n",
      "iter: 49 loss: 4626.671875\n",
      "iter: 50 loss: 4780.900390625\n",
      "iter: 51 loss: 3496.385009765625\n",
      "iter: 52 loss: 3458.659423828125\n",
      "iter: 53 loss: 3353.771240234375\n",
      "iter: 54 loss: 4180.0009765625\n",
      "iter: 55 loss: 3338.60400390625\n",
      "iter: 56 loss: 3116.59912109375\n",
      "iter: 57 loss: 4037.29736328125\n",
      "iter: 58 loss: 3774.180419921875\n",
      "iter: 59 loss: 3382.86962890625\n",
      "iter: 60 loss: 3018.8935546875\n",
      "iter: 61 loss: 2587.437255859375\n",
      "iter: 62 loss: 3071.701904296875\n",
      "iter: 63 loss: 2761.434326171875\n",
      "iter: 64 loss: 3169.082275390625\n",
      "iter: 65 loss: 2645.4951171875\n",
      "iter: 66 loss: 2819.513916015625\n",
      "iter: 67 loss: 2426.356689453125\n",
      "iter: 68 loss: 2725.80126953125\n",
      "iter: 69 loss: 2307.149169921875\n",
      "iter: 70 loss: 2826.563232421875\n",
      "iter: 71 loss: 2608.674072265625\n",
      "iter: 72 loss: 1984.69482421875\n",
      "iter: 73 loss: 2782.57177734375\n",
      "iter: 74 loss: 2487.468994140625\n",
      "iter: 75 loss: 2257.229736328125\n",
      "iter: 76 loss: 1968.1668701171875\n",
      "iter: 77 loss: 2258.7001953125\n",
      "iter: 78 loss: 3283.882080078125\n",
      "iter: 79 loss: 1847.2012939453125\n",
      "iter: 80 loss: 2467.22607421875\n",
      "iter: 81 loss: 2355.8525390625\n",
      "iter: 82 loss: 2344.8291015625\n",
      "iter: 83 loss: 2546.603271484375\n",
      "iter: 84 loss: 1847.54248046875\n",
      "iter: 85 loss: 2245.85009765625\n",
      "iter: 86 loss: 1633.7039794921875\n",
      "iter: 87 loss: 1526.033203125\n",
      "iter: 88 loss: 2003.346435546875\n",
      "iter: 89 loss: 2513.55419921875\n",
      "iter: 90 loss: 2211.576416015625\n",
      "iter: 91 loss: 2094.048095703125\n",
      "iter: 92 loss: 2205.19873046875\n",
      "iter: 93 loss: 2410.534423828125\n",
      "iter: 94 loss: 1596.48974609375\n",
      "iter: 95 loss: 1918.9241943359375\n",
      "iter: 96 loss: 2085.23974609375\n",
      "iter: 97 loss: 1892.5511474609375\n",
      "iter: 98 loss: 1596.6278076171875\n",
      "iter: 99 loss: 1280.46630859375\n",
      "iter: 100 loss: 1880.322509765625\n",
      "iter: 101 loss: 1865.0926513671875\n",
      "iter: 102 loss: 1879.7603759765625\n",
      "iter: 103 loss: 1476.0496826171875\n",
      "iter: 104 loss: 1457.1563720703125\n",
      "iter: 105 loss: 1760.922119140625\n",
      "iter: 106 loss: 1757.744384765625\n",
      "iter: 107 loss: 952.452392578125\n",
      "iter: 108 loss: 1358.500732421875\n",
      "iter: 109 loss: 1343.71630859375\n",
      "iter: 110 loss: 1934.882568359375\n",
      "iter: 111 loss: 1737.486328125\n",
      "iter: 112 loss: 1336.3575439453125\n",
      "iter: 113 loss: 1849.647705078125\n",
      "iter: 114 loss: 1238.8033447265625\n",
      "iter: 115 loss: 1332.3145751953125\n",
      "iter: 116 loss: 1026.3819580078125\n",
      "iter: 117 loss: 1123.0469970703125\n",
      "iter: 118 loss: 1429.316650390625\n",
      "iter: 119 loss: 1844.77001953125\n",
      "iter: 120 loss: 1822.0992431640625\n",
      "iter: 121 loss: 1316.7572021484375\n",
      "iter: 122 loss: 810.1468505859375\n",
      "iter: 123 loss: 1518.48681640625\n",
      "iter: 124 loss: 1520.13232421875\n",
      "iter: 125 loss: 807.2008056640625\n",
      "iter: 126 loss: 1613.82080078125\n",
      "iter: 127 loss: 1316.6953125\n",
      "iter: 128 loss: 902.3818969726562\n",
      "iter: 129 loss: 1393.867431640625\n",
      "iter: 130 loss: 892.0301513671875\n",
      "iter: 131 loss: 1788.4127197265625\n",
      "iter: 132 loss: 1680.7906494140625\n",
      "iter: 133 loss: 996.6570434570312\n",
      "iter: 134 loss: 1605.63818359375\n",
      "iter: 135 loss: 1188.1998291015625\n",
      "iter: 136 loss: 1285.088623046875\n",
      "iter: 137 loss: 785.6587524414062\n",
      "iter: 138 loss: 1182.0125732421875\n",
      "iter: 139 loss: 980.6756591796875\n",
      "iter: 140 loss: 1078.4566650390625\n",
      "iter: 141 loss: 1384.3857421875\n",
      "iter: 142 loss: 1177.00341796875\n",
      "iter: 143 loss: 1175.0364990234375\n",
      "iter: 144 loss: 1075.9267578125\n",
      "iter: 145 loss: 1380.4766845703125\n",
      "iter: 146 loss: 967.55224609375\n",
      "iter: 147 loss: 973.2142944335938\n",
      "iter: 148 loss: 1171.100830078125\n",
      "iter: 149 loss: 1262.510986328125\n",
      "iter: 150 loss: 1070.4747314453125\n",
      "iter: 151 loss: 1271.8004150390625\n",
      "iter: 152 loss: 974.7362670898438\n",
      "iter: 153 loss: 964.1679077148438\n",
      "iter: 154 loss: 1156.0203857421875\n",
      "iter: 155 loss: 1257.5504150390625\n",
      "iter: 156 loss: 1266.447265625\n",
      "iter: 157 loss: 1477.001220703125\n",
      "iter: 158 loss: 860.0855102539062\n",
      "iter: 159 loss: 1464.7947998046875\n",
      "iter: 160 loss: 1256.3065185546875\n",
      "iter: 161 loss: 1156.4765625\n",
      "iter: 162 loss: 861.509033203125\n",
      "iter: 163 loss: 1152.145751953125\n",
      "iter: 164 loss: 1558.7037353515625\n",
      "iter: 165 loss: 1452.447265625\n",
      "iter: 166 loss: 945.1187133789062\n",
      "iter: 167 loss: 1453.4984130859375\n",
      "iter: 168 loss: 1248.607177734375\n",
      "iter: 169 loss: 1046.23291015625\n",
      "iter: 170 loss: 1046.31787109375\n",
      "iter: 171 loss: 1140.6729736328125\n",
      "iter: 172 loss: 1346.8341064453125\n",
      "iter: 173 loss: 1232.5028076171875\n",
      "iter: 174 loss: 1438.4149169921875\n",
      "iter: 175 loss: 745.7489624023438\n",
      "iter: 176 loss: 843.0776977539062\n",
      "iter: 177 loss: 839.2395629882812\n",
      "iter: 178 loss: 842.23095703125\n",
      "iter: 179 loss: 1644.6541748046875\n",
      "iter: 180 loss: 835.824951171875\n",
      "iter: 181 loss: 1141.398681640625\n",
      "iter: 182 loss: 1034.4371337890625\n",
      "iter: 183 loss: 832.4353637695312\n",
      "iter: 184 loss: 1123.57861328125\n",
      "iter: 185 loss: 931.4871826171875\n",
      "iter: 186 loss: 828.2890014648438\n",
      "iter: 187 loss: 825.29443359375\n",
      "iter: 188 loss: 1523.206298828125\n",
      "iter: 189 loss: 1028.9189453125\n",
      "iter: 190 loss: 930.6357421875\n",
      "iter: 191 loss: 918.4921264648438\n",
      "iter: 192 loss: 1322.316162109375\n",
      "iter: 193 loss: 718.7554321289062\n",
      "iter: 194 loss: 518.0184326171875\n",
      "iter: 195 loss: 1013.817138671875\n",
      "iter: 196 loss: 1020.3588256835938\n",
      "iter: 197 loss: 1410.7713623046875\n",
      "iter: 198 loss: 914.0454711914062\n",
      "iter: 199 loss: 1411.276123046875\n",
      "iter: 200 loss: 914.84716796875\n",
      "usetime: 97.09195828437805\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "train(0, 200, pic, source, target, path)\n",
    "end = time.time()\n",
    "usetime = end - start\n",
    "print(f\"usetime: {usetime}\")"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\win10\\AppData\\Local\\Temp\\ipykernel_3328\\1981065163.py:3: DeprecationWarning: BICUBIC is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.BICUBIC instead.\n",
      "  pil = transforms.Resize(size=ori_size, interpolation=Image.BICUBIC)(pil)\n"
     ]
    }
   ],
   "source": [
    "neo_pic = model(pic)\n",
    "pil = topil(neo_pic.squeeze(0).cpu())\n",
    "pil = transforms.Resize(size=ori_size, interpolation=Image.BICUBIC)(pil)\n",
    "pil.save(path)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "# with open(file = \"neo_cmp_outer.txt\", mode = \"w\") as file:\n",
    "#     for i in loss_li:\n",
    "#         file.write(str(i)+\" \")\n",
    "#     file.write(\"\\n\")\n",
    "#     file.write(str(cur_times+1))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "data": {
      "text/plain": "[<matplotlib.lines.Line2D at 0x246d50e1dc0>]"
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGdCAYAAAAbudkLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFTUlEQVR4nO3de3xU9Z3/8fcQkxgxTAkhGWLCpfzwUmFZi/vj0qJ4gcoaYRuFCpjqqvizLUgUWsujrUB3BYor0pZWbH9Wbb3EVYL2tlHoBgo/wuWBpsulom7DLSQEQzIBhSQk398fZ2eSSSbJmWTueT0fj3kMc853Zs7JSTwfv9/v5/N1GGOMAAAA4lC/SB8AAABAqBDoAACAuEWgAwAA4haBDgAAiFsEOgAAIG4R6AAAgLhFoAMAAOIWgQ4AAIhbl0T6ACKppaVFJ0+eVGpqqhwOR6QPBwAA2GCM0dmzZ5WVlaV+/brus+nTgc7JkyeVk5MT6cMAAAA9cPz4cWVnZ3fZpk8HOqmpqZKsH9SAAQMifDQAAMCO+vp65eTkeO/jXenTgY5nuGrAgAEEOgAAxBg7006YjAwAAOIWgQ4AAIhbBDoAACBuEegAAIC4RaADAADiFoEOAACIWwQ6AAAgbhHoAACAuNWnCwaGTHOztH27VFkpDRkiTZ4sJSRE+qgAAOhzAu7R+fOf/6w77rhDWVlZcjgceuutt3z2FxUV6Stf+YrS09PlcDhUVlbW4TMaGhq0cOFCpaenq3///poxY4ZOnDjh06a2tlb5+flyOp1yOp3Kz89XXV2dT5tjx47pjjvuUP/+/ZWenq5HHnlEjY2NgZ5ScBUVScOHSzfdJM2daz0PH25tBwAAYRVwoPPpp59q7NixWr9+faf7v/SlL2n16tWdfkZBQYE2bdqkwsJC7dixQ+fOnVNubq6am5u9bebOnauysjIVFxeruLhYZWVlys/P9+5vbm7W7bffrk8//VQ7duxQYWGhNm7cqMWLFwd6SsFTVCTddZfULmhTRYW1nWAHAIDwMr0gyWzatMnvvvLyciPJvP/++z7b6+rqTGJioiksLPRuq6ioMP369TPFxcXGGGMOHTpkJJldu3Z525SWlhpJ5oMPPjDGGPPHP/7R9OvXz1RUVHjbvPbaayY5Odm43W5bx+92u40k2+27dPGiMdnZxkj+Hw6HMTk5VjsAANBjgdy/wz4Zed++fWpqatK0adO827KysjR69Gjt3LlTklRaWiqn06nx48d720yYMEFOp9OnzejRo5WVleVt85WvfEUNDQ3at29fmM6mje3bO/bktGWMdPy41Q4AAIRF2CcjV1VVKSkpSQMHDvTZnpmZqaqqKm+bjIyMDu/NyMjwaZOZmemzf+DAgUpKSvK2aa+hoUENDQ3e1/X19b06Fx+VlcFtBwAAei1q0suNMT7Lrftber0nbdpatWqVd3Kz0+lUTk5OEI78fwwZEtx2AACg18Ie6LhcLjU2Nqq2ttZne3V1tbeHxuVy6dSpUx3ee/r0aZ827Xtuamtr1dTU1KGnx2Pp0qVyu93ex/Hjx4NxSpbJk6XsbKmTIEsOh5STY7UDAABhEfZAZ9y4cUpMTNTmzZu92yorK3XgwAFNmjRJkjRx4kS53W7t2bPH22b37t1yu90+bQ4cOKDKNkNB7777rpKTkzVu3Di/352cnKwBAwb4PIImIUH68Y+tf7cPdjyv162jng4AAGEU8Bydc+fO6eOPP/a+Li8vV1lZmdLS0jR06FCdOXNGx44d08mTJyVJhw8flmT1wLhcLjmdTj3wwANavHixBg0apLS0NC1ZskRjxozRrbfeKkm65pprdNttt2n+/Pl67rnnJEkPPfSQcnNzddVVV0mSpk2bpi984QvKz8/XU089pTNnzmjJkiWaP39+cAOYQOTlSW++KS1a5DsxeeBAa9vMmZE5LgAA+qpAU7pKSkqMpA6Pe++91xhjzAsvvOB3/7Jly7yfcf78ebNgwQKTlpZmUlJSTG5urjl27JjP99TU1Jh58+aZ1NRUk5qaaubNm2dqa2t92hw9etTcfvvtJiUlxaSlpZkFCxaYCxcu2D6XoKaXt3XxojGPPdYxxTw725iNG4P7XQAA9DGB3L8dxhgTmRAr8urr6+V0OuV2u4PbC+QpHNj+R+sZwnrzTav3BwAABCyQ+3fUZF3FjeZma5jKX/zo2VZQYLUDAAAhRaATbBQOBAAgahDoBBuFAwEAiBoEOsFG4UAAAKIGgU6wUTgQAICoQaATbBQOBAAgahDohIKncOAVV/hu/9znpOXLKRwIAECYEOiESl6edOSItGKF1O9/fsy1tdKyZdLw4VatHQAAEFIEOqH09ttWD05Li+/2igqroCDBDgAAIUWgEyoUDgQAIOIIdEKFwoEAAEQcgU6oUDgQAICII9AJFQoHAgAQcQQ6oULhQAAAIo5AJ1QoHAgAQMQR6IRSZ4UDL7+cwoEAAIQBgU6otS0cmJRkbTt7lsKBAACEAYFOOHgKBzY2+m6ncCAAACFFoBNqFA4EACBiCHRCjcKBAABEDIFOqFE4EACAiCHQCTUKBwIAEDEEOqHWXeFASRo8WJo0KXzHBABAH0GgE2pdFQ70OH1aGjmS7CsAAIKMQCccOisc2Bap5gAABB2BTrjk5Un//d/WMJU/pJoDABB0BDrhtHOnNUzVGVLNAQAIKgKdcCLVHACAsCLQCSdSzQEACCsCnXCyk2qenW21AwAAvUagE052Us3Pn7cWAQUAAL1GoBNunlTztDT/+8+cIc0cAIAgIdCJhJkzpZQU//tIMwcAIGgIdCKBFc0BAAgLAp1IIM0cAICwINCJBNLMAQAICwKdSLCTZp6QIH3ySfiOCQCAOESgEwlt08w709wszZ5N9hUAAL1AoBMpeXnS669bQU9XyL4CAKDHCHQiafDgroMYsq8AAOgVAp1IIvsKAICQItCJJLtZVRkZoT0OAADiFIFOJNnJvpKk++5jUjIAAD1AoBNJdhb5lKSKCta/AgCgBwh0Is2zyGdWVudtWP8KAIAeIdCJBnl50ksvdd2GDCwAAAJGoBMtqqvttSMDCwAA2wh0ogXrXwEAEHQEOtGiuwwsh0PKybHaAQAAWwh0okV3GVjGSE8/3f2SEQAAwCvgQOfPf/6z7rjjDmVlZcnhcOitt97y2W+M0fLly5WVlaWUlBRNmTJFBw8e9GnT0NCghQsXKj09Xf3799eMGTN04sQJnza1tbXKz8+X0+mU0+lUfn6+6urqfNocO3ZMd9xxh/r376/09HQ98sgjamxsDPSUoocnA+uKK/zvf+wxUswBAAhAwIHOp59+qrFjx2r9+vV+969Zs0Zr167V+vXrtXfvXrlcLk2dOlVnz571tikoKNCmTZtUWFioHTt26Ny5c8rNzVVzm9TpuXPnqqysTMXFxSouLlZZWZny8/O9+5ubm3X77bfr008/1Y4dO1RYWKiNGzdq8eLFgZ5SdMnLk555xv8+6ukAABAY0wuSzKZNm7yvW1pajMvlMqtXr/Zuu3DhgnE6nWbDhg3GGGPq6upMYmKiKSws9LapqKgw/fr1M8XFxcYYYw4dOmQkmV27dnnblJaWGknmgw8+MMYY88c//tH069fPVFRUeNu89tprJjk52bjdblvH73a7jSTb7cPi4kVjsrONsQarOj4cDmNycqx2AAD0QYHcv4M6R6e8vFxVVVWaNm2ad1tycrJuvPFG7dy5U5K0b98+NTU1+bTJysrS6NGjvW1KS0vldDo1fvx4b5sJEybI6XT6tBk9erSy2hTa+8pXvqKGhgbt27fP7/E1NDSovr7e5xF1tm+X2g3j+aCeDgAAtgU10KmqqpIkZWZm+mzPzMz07quqqlJSUpIGDhzYZZsMPwtZZmRk+LRp/z0DBw5UUlKSt017q1at8s75cTqdysnJ6cFZhpjdOjlvvx3a4wAAIA6EJOvK0S5ryBjTYVt77dv4a9+TNm0tXbpUbrfb+zh+/HiXxxQRduvkrFvHXB0AALoR1EDH5XJJUocelerqam/vi8vlUmNjo2pra7tsc+rUqQ6ff/r0aZ827b+ntrZWTU1NHXp6PJKTkzVgwACfR9Tx1NPpjsPB2lcAAHQjqIHOiBEj5HK5tHnzZu+2xsZGbdu2TZMmTZIkjRs3TomJiT5tKisrdeDAAW+biRMnyu12a8+ePd42u3fvltvt9mlz4MABVbYZ6nn33XeVnJyscePGBfO0wqttPZ2uMFcHAIBuXRLoG86dO6ePP/7Y+7q8vFxlZWVKS0vT0KFDVVBQoJUrV2rUqFEaNWqUVq5cqcsuu0xz586VJDmdTj3wwANavHixBg0apLS0NC1ZskRjxozRrbfeKkm65pprdNttt2n+/Pl67rnnJEkPPfSQcnNzddVVV0mSpk2bpi984QvKz8/XU089pTNnzmjJkiWaP39+dPbUBCIvz+qtWbeu+7asfQUAQOcCTekqKSkxkjo87r33XmOMlWK+bNky43K5THJysrnhhhvM/v37fT7j/PnzZsGCBSYtLc2kpKSY3Nxcc+zYMZ82NTU1Zt68eSY1NdWkpqaaefPmmdraWp82R48eNbfffrtJSUkxaWlpZsGCBebChQu2zyUq08s9Sko6TzFv+ygpifSRAgAQVoHcvx3GGBPBOCui6uvr5XQ65Xa7o68XqLlZGj7cKhLo7xI5HNZcnvJyloUAAPQpgdy/WesqWrH2FQAAvUagE81Y+woAgF4h0Il2rH0FAECPEehEu+Zm6dFH/e/zzN2hng4AAH4R6EQ71r4CAKDHCHSind06OdTTAQCgAwKdaGd37Ss/i6ACANDXEehEO8/aV90siqr77mNSMgAA7RDoRLvu6ul4kIEFAEAHBDqxwFNPJyur8zZkYAEA0AGBTqzIy5NeeqnrNmRgAQDgg0AnllRX22tHBhYAAJIIdGKL3Qwsu+0AAIhzBDqxxE4GVkKC9Mkn4TsmAACiGIFOLGmbgdWZ5mZp9myyrwAAEIFO7MnLk15/3Qp6ukL2FQAABDoxafDgroMYsq8AAJBEoBObWP8KAABbCHRiEdlXAADYQqATi8i+AgDAFgKdWGQ3+2rWLOmNN8JzTAAARCECnVhlN/tqzhxrnSwAAPogAp1Y1l32ldTas0NdHQBAH0SgE8sCyaqirg4AoA8i0IllgWRVUVcHANAHEejEMk/2lV3U1QEA9DEEOrHMTvZVW9TVAQD0MQQ6sS4vT/r3f+86+8rhkHJyrB4gAAD6kEsifQAIglmzrGBm1qyO+zxFBdet6z4VHQCAOEOPTry46y5p48aOc3YGDbLq6OTlRea4AACIIAKdeJKXJx05IpWUSDfcYG37P/+HIAcA0GcR6MSbhARpyhRp9mzr9ebN0muvSVu3UkcHANDnEOjEq3PnrOc9e6S5c6WbbpIyMqQf/pCABwDQZxDoxKOiImnp0o7bz5yRli2TMjNZEgIA0CcQ6MSb5mZp0SLJmM7b1NRYk5cJdgAAcY5AJ95s3y6dONF9O2NY/woAEPcIdOJNIMs8sP4VACDOEejEm0CXeWD9KwBAHCPQiTeBLvTJ+lcAgDhGoBNvAlnoMyFB+uST0B4PAAARRKATj/LyrOUgBg3qul1zs1VYkOwrAECcItCJV3l50qlTVt0cz8KenSH7CgAQpwh04plnOYiuauoYQ/YVACBuEejEO7tZVWRfAQDiEIFOvLObVUX2FQAgDhHoxDtPunln83QcDiknx2oHAECcIdCJd23Tzf0FO8ZITz9ttQMAIM4Q6PQFeXnSm29KV1zhf/9jj5FiDgCISwQ6fUVenvTMM/73nTgh3Xmn9MMfkmYOAIgrBDp9RXOz9OijXbdZtkwaPpzeHQBA3AhJoHP27FkVFBRo2LBhSklJ0aRJk7R3717vfmOMli9frqysLKWkpGjKlCk6ePCgz2c0NDRo4cKFSk9PV//+/TVjxgydOHHCp01tba3y8/PldDrldDqVn5+vurq6UJxS7Nu+3eq56c6JE9JddxHsAADiQkgCnQcffFCbN2/Wb37zG+3fv1/Tpk3TrbfeqoqKCknSmjVrtHbtWq1fv1579+6Vy+XS1KlTdfbsWe9nFBQUaNOmTSosLNSOHTt07tw55ebmqrnN0MrcuXNVVlam4uJiFRcXq6ysTPn5+aE4pdgXaJ0cqiUDAOKBCbLPPvvMJCQkmN///vc+28eOHWu+973vmZaWFuNyuczq1au9+y5cuGCcTqfZsGGDMcaYuro6k5iYaAoLC71tKioqTL9+/UxxcbExxphDhw4ZSWbXrl3eNqWlpUaS+eCDD2wdq9vtNpKM2+3u8fnGjJISY6wcK/uPkpJIHzUAAB0Ecv8Oeo/OxYsX1dzcrEsvvdRne0pKinbs2KHy8nJVVVVp2rRp3n3Jycm68cYbtXPnTknSvn371NTU5NMmKytLo0eP9rYpLS2V0+nU+PHjvW0mTJggp9PpbdNeQ0OD6uvrfR59Rnf1dPyhWjIAIMYFPdBJTU3VxIkT9S//8i86efKkmpub9fLLL2v37t2qrKxUVVWVJCkzM9PnfZmZmd59VVVVSkpK0sCBA7tsk5GR0eH7MzIyvG3aW7VqlXc+j9PpVE5OTq/PN2a0radjF9WSAQAxLiRzdH7zm9/IGKMrrrhCycnJ+slPfqK5c+cqoU1ROke7ngVjTIdt7bVv4699V5+zdOlSud1u7+P48eOBnFbs666ejgfVkgEAcSIkgc7IkSO1bds2nTt3TsePH9eePXvU1NSkESNGyOVySVKHXpfq6mpvL4/L5VJjY6Nqa2u7bHPq1KkO33369OkOvUUeycnJGjBggM+jz8nLk44elVas8L/fEySuW0e1ZABAzAtpHZ3+/ftryJAhqq2t1TvvvKOZM2d6g53Nmzd72zU2Nmrbtm2aNGmSJGncuHFKTEz0aVNZWakDBw5420ycOFFut1t79uzxttm9e7fcbre3DTqRkCA98YS0caM1b6et7Gyr1ycvLzLHBgBAEDmMMSbYH/rOO+/IGKOrrrpKH3/8sb797W8rOTlZO3bsUGJion70ox9p1apVeuGFFzRq1CitXLlSW7du1eHDh5WamipJ+sY3vqHf//73evHFF5WWlqYlS5aopqZG+/bt8w6BTZ8+XSdPntRzzz0nSXrooYc0bNgw/e53v7N1nPX19XI6nXK73X2zd0eyUsi//W2ravI//INUWkpPDgAgqgVy/74kFAfgdru1dOlSnThxQmlpabrzzjv15JNPKjExUZL0ne98R+fPn9c3v/lN1dbWavz48Xr33Xe9QY4kPfPMM7rkkks0e/ZsnT9/XrfccotefPFFn3k+r7zyih555BFvdtaMGTO0fv36UJxS/EpIkL72NSvQOXbM2rZ1q5VxNWSINU+HwAcAEKNC0qMTK+jR+R+ffSZdfrlVPedzn5PaVpfOzraytRjKAgBEiUDu36x1Bam4uHUScvslNCoqWBICABCzCHT6uqIia+Xylhb/+z0dfiwJAQCIQSGZo4MY0dwsLVrUfTtjpOPHrbk7CQnM3wEAxAwCnb7M7ormHrNnS2fOtL5m/g4AIMoxdNWXBbqWVdsgR2L+DgAg6hHo9GW9XcuK+TsAgChHoNOX9WRF8/Y883e2bw/ecQEAECQEOn1Z2xXNOwt2Lr/c3mcFOgwGAEAYEOj0dd2taP7CC/Y+p7fDYAAAhACBDqxg58gRqaREevVV63n4cGvfoEFdD285HFJOjjUMBgBAlCG9HJaEBGnKlNbXV11lBT///d/W8NZdd3V8jyf4WbeOejoAgKhEjw78u/JK6/nDD6WZM6UlSzq2yc62hr2oowMAiFL06MC/q66ynrdutYax2hcWHDdO2r2bnhwAQFSjRwf+jRxpPe/d67968r590ttvh/eYAAAIEIEOOioqkv75n7tvR6FAAECUI9CBr6Iia+JxVVX3bSkUCACIcgQ6aOVZzdyztIMdFAoEAEQxJiOjVaCrmUtSRoY1Ybmy0ioaOHkyE5QBAFGDQAetAu2dcTql++7zDY6ys626O6ScAwCiAENXaBXoMg5ud8ceoIoKa45PUVHwjgsAgB4i0EEru6uZX3pp5/s883vIyAIARAECHbSys5r5ihXSV77S9ecYQ0YWACAqEOjAV2ermefkSBs3Sk880XWPTltkZAEAIozJyOgoL89a32r7dv/ZVJ6VzbsT6JwfAACCjEAH/rVfzbytyZOlH/2o8/c6HNZcn8mTQ3JoAADYxdAVAlNUJD3wQOf7PXN71q2jng4AIOIIdGCfZ3mIU6c6b5Odbc3xoY4OACAKMHQFe+wsDzFwoPTxx1JSUviOCwCALtCjA3vsLA9RWyvt3Bme4wEAwAYCHdhjN1WclHIAQBQh0IE9dlPFSSkHAEQRAh3YY2d5iMsuI6UcABBVCHRgj53lIf7X/yKlHAAQVQh0YF9ny0MMHmw9X7wY/mMCAKALpJcjMP6Whxg8WBo92srKam7ufOkIAADCjEAHgWu/PMTZs9Zzfb00dKh08mTrvuxsa8iLAoIAgAhg6Aq9l5oqpaRY/24b5EhSRYVVTbmoKPzHBQDo8+jRQe81N0tNTf73eSopP/ywdP68Nb+H4SwAQJjQo4Pe2769+4nIp09L99wj3XSTNHw4PTwAgLAg0EHvvf12YO0ZzgIAhAmBDnqnqEhaty6w93iGswoKrGEvAABChEAHPedZ0bwnjJGOH7eGvQAACBECHfScnRXNu8MioACAECLQQc8FI0g5dUp67TVp61aGsQAAQUd6OXqutyuVOxzSo4+2vqa4IAAgyOjRQc/ZWdG8K55JyR5kYwEAgoxABz1nZ0XzQJCNBQAIMgId9E5nK5r3FNlYAIAgItBB7+XlSUeOSFu2SGlpwflMsrEAAEEQ9EDn4sWL+v73v68RI0YoJSVFn//85/XDH/5QLS0t3jbGGC1fvlxZWVlKSUnRlClTdPDgQZ/PaWho0MKFC5Wenq7+/ftrxowZOtEulbm2tlb5+flyOp1yOp3Kz89XXV1dsE8JdiQkSLfcIv3yl9YwVm+Hsno70RkAAIUg0PnRj36kDRs2aP369frrX/+qNWvW6KmnntJPf/pTb5s1a9Zo7dq1Wr9+vfbu3SuXy6WpU6fq7Nmz3jYFBQXatGmTCgsLtWPHDp07d065ublqbjN3Y+7cuSorK1NxcbGKi4tVVlam/Pz8YJ8SAhGMoaycHGuiMwAAvWWC7Pbbbzf333+/z7a8vDxzzz33GGOMaWlpMS6Xy6xevdq7/8KFC8bpdJoNGzYYY4ypq6sziYmJprCw0NumoqLC9OvXzxQXFxtjjDl06JCRZHbt2uVtU1paaiSZDz74wNaxut1uI8m43e6enSw6d/GiMSUlxnz/+8ZYM2/sPRwOYzZujPTRAwCiWCD376D36Hz5y1/Wn/70J3344YeSpL/85S/asWOH/vEf/1GSVF5erqqqKk2bNs37nuTkZN14443auXOnJGnfvn1qamryaZOVlaXRo0d725SWlsrpdGr8+PHeNhMmTJDT6fS2aa+hoUH19fU+D4RIQoI0ZYq0fLn9FPTERGtJibQ0sq4AAEER9EDn8ccf15w5c3T11VcrMTFR1113nQoKCjRnzhxJUlVVlSQpMzPT532ZmZnefVVVVUpKStLAgQO7bJORkdHh+zMyMrxt2lu1apV3Po/T6VROTk7vThbds5OCnphoPTc1WQuE3nSTlJEh/fCHBDwAgF4JeqDz+uuv6+WXX9arr76q9957Ty+99JL+7d/+TS+99JJPO0e7m54xpsO29tq38de+q89ZunSp3G6393H8+HG7p4Xe6GzeTlqa9LWvSRcvdnzPmTPSsmVSZiYFBAEAPRb0JSC+/e1v67vf/a7uvvtuSdKYMWN09OhRrVq1Svfee69cLpckq0dmSJvMmurqam8vj8vlUmNjo2pra316daqrqzVp0iRvm1OnTnX4/tOnT3foLfJITk5WcnJycE4UgcnLk2bOtOrjVFZaWVWTJkkjR3askNxWTY10551WEcGZM61JygkJYTtsAEBsC3qPzmeffaZ+/Xw/NiEhwZtePmLECLlcLm3evNm7v7GxUdu2bfMGMePGjVNiYqJPm8rKSh04cMDbZuLEiXK73dqzZ4+3ze7du+V2u71tEGU883bmzLGed+60v/q5Z0hr+HB6eAAAtgW9R+eOO+7Qk08+qaFDh+raa6/V+++/r7Vr1+r++++XZA03FRQUaOXKlRo1apRGjRqllStX6rLLLtPcuXMlSU6nUw888IAWL16sQYMGKS0tTUuWLNGYMWN06623SpKuueYa3XbbbZo/f76ee+45SdJDDz2k3NxcXXXVVcE+LYRCT4oCetbDevNNFv8EAHQv2Clf9fX1ZtGiRWbo0KHm0ksvNZ///OfN9773PdPQ0OBt09LSYpYtW2ZcLpdJTk42N9xwg9m/f7/P55w/f94sWLDApKWlmZSUFJObm2uOHTvm06ampsbMmzfPpKammtTUVDNv3jxTW1tr+1hJL4+wkpLAUs/bpqDn5Fgp7ACAPieQ+7fDmK4mSMS3+vp6OZ1Oud1uDRgwINKH0/c0N1tDUXaHr9orKbGGwAAAfUog92/WukLktE097wnWwwIAdINAB5GVlydt3CgNGhT4e1kPCwDQDQIdRF5ennTqlLRihb3Vzx0O1sMCANhCoIPokJAgPfGEVF0tzZ/fur198UfP63XrqKcDAOgWgQ6ii6fWjiRde61VGbmt9HRSywEAthHoIPp41iA7f156/nnffcuWEeQAAGwj0EH0GTrUej5xQjp61Hff4cPhPx4AQMwi0EH0ycqy5uI0NkqeJT6cTuv5gw8id1wAgJhDoIPok5jYmjq+bZv1PHWq9fzXv0bmmAAAMSnoa10BQTF0qHTypFRebr2ePt2ahHzihPR//6907pw0eLB0xRWtaeZtV0ZnlXMAgAh0EK1ycqRdu1pf19VJ/fpJLS2+6edSa7HBmprWbdnZVtVlJi4DQJ/G0BWikyfzymPJEivI8aemxjfIkVpXOS8qCs3xAQBiAoEOopMn80qyJiYHuvasZ63zRYusxUMBAH0SgQ6iU1ZW678DDXLaOnFCevLJ3h8PACAmEegg+hQVSQsWBO/zli2T3ngjeJ8HAIgZTEZGdCkqsubW9KYXx585c6whsLvuCu7nAgCiGj06iB7NzdacmmAHOZ7PnjWLyckA0McQ6CB6bN9uzakJpYICJicDQB/C0BWiR2Vl6L/j+HFp61armCDFBQEg7hHoIHp4ln3oTmqqdPZsz79n9mzpzJnW1xQXBIC4xdAVosfkyVbQ4XD43+9wWMs+9CbIkXyDHIniggAQxwh0ED0SEqyeFaljsON5PW9e8L/XM/mZ+TsAEHcIdBBd8vKsxTuvuMJ3e3a2tX3mzNB8rzHW/J3t20Pz+QCAiGCODqJPXp4V0Phbjby52Qp6Kir8p6E7HFJampSS0rMMrnBMiAYAhA2BDqJTQoI0ZYr/7T/+sTWnpv0aWJ7hrV/8wloAdNaswL/X7oRoAEBMYOgKscfO8Najjwb2mQ6HtWL6pElW+vlrr1nPzNkBgJhGjw5iU1fDW1u3Bj5sZYw0dqwVLJ0+3bqd1HMAiGkEOohdnQ1v9XSeze9/33GbJ/X8zTcJdgAgBjF0hfgTzHk2pJ4DQEwj0EH86a7wYKBIPQeAmEWgg/jTtvBgMJF6DgAxh0AH8amzzKzeIPUcAGIOgQ7iV16edPSotGJF7z7Hk3o+eXJwjgsAEDYEOohvCQnSE09IGzda83YC5Znns26d9VkAgJhCoIO+IS9POnJEKimRXn3Ver7llu7f5ylCSGo5AMQk6uig72hfd2fnTulPf+rYLilJamyUvvlN6Sc/oScHAGIYPTrom4qKpLVrfbcNHGjN53nssdZtBDkAENMIdND3FBVZ1Y5rany319VJy5dLZ89arz/+ONxHBgAIMoau0Lc0N0uLFvmueu5hjDX5+I03rNedBTrNzf7X2AIARB16dNC3bN/e9YKfxkjV1da/jxyx5uq0VVQkDR8u3XSTNHeu9Tx8uLUdABB1CHTQt9itbpyUJLW0WHV4PDxDXu0DJc/Cn0VFVm/P1q3Sa69Zz6yPBQARRaCDvsVudWNPRWXP8FV3Q16S9NBD9PYAQJRhjg76Fs+CnxUV/oMWh8Pa/3d/J5WXWz0zhw9Lp093P+TVfnKz1NrbQy0eAIgIhzH+/mvfN9TX18vpdMrtdmvAgAGRPhyEi2cISvINdjxVkJcskZ59Vjp3Ljjf5wmeysuZtAwAQRDI/ZuhK/Q9nS34mZ1tBTn/9m/BC3IkK5g6ftyaCA0ACCuGrtA35eVJM2f6polPmiSNHOl/SCsY7E6EBgAEDYEO+q72S0Js3dr1PJze+uij0H02AMAvhq4Aj572uGRnS4MGtc7x6czy5WRgAUCYEegAHnZTz9tbvFh65BF7Q14FBdTWAYAwIuuKrCt4NDdbdW96OnyVnCw1NHTfrqTEd8gMABCQiGZdDR8+XA6Ho8PjW9/6liTJGKPly5crKytLKSkpmjJlig4ePOjzGQ0NDVq4cKHS09PVv39/zZgxQyfa3Xxqa2uVn58vp9Mpp9Op/Px81dXVBft00JckJEg//nH3Q1CdsRPkSExKBoAwCnqgs3fvXlVWVnofmzdvliTNmjVLkrRmzRqtXbtW69ev1969e+VyuTR16lSd9awYLamgoECbNm1SYWGhduzYoXPnzik3N1fNbbr8586dq7KyMhUXF6u4uFhlZWXKz88P9umgr/Gknmdnh+47ejpEBgAInAmxRYsWmZEjR5qWlhbT0tJiXC6XWb16tXf/hQsXjNPpNBs2bDDGGFNXV2cSExNNYWGht01FRYXp16+fKS4uNsYYc+jQISPJ7Nq1y9umtLTUSDIffPCB7WNzu91GknG73b09TcSbixeN+f73jbFm3gTvkZBgzBtvRPrsACCmBXL/Dulk5MbGRr388su6//775XA4VF5erqqqKk2bNs3bJjk5WTfeeKN27twpSdq3b5+ampp82mRlZWn06NHeNqWlpXI6nRo/fry3zYQJE+R0Or1t/GloaFB9fb3PA/ArIUG65Zbgf25zszR7NtlXABAmIQ103nrrLdXV1em+++6TJFVVVUmSMjMzfdplZmZ691VVVSkpKUkDBw7ssk1GRkaH78vIyPC28WfVqlXeOT1Op1M5OTk9Pjf0AZ51sXo6Z6crZF8BQFiENNB5/vnnNX36dGVlZflsd7S7cRhjOmxrr30bf+27+5ylS5fK7XZ7H8ePH7dzGuirPJOTpeAGO54lIbZutR6vvWY9E/gAQNCFLNA5evSotmzZogcffNC7zeVySVKHXpfq6mpvL4/L5VJjY6Nqa2u7bHPq1KkO33n69OkOvUVtJScna8CAAT4PoEudrYsVDLNnSzfdJM2daz0PH86QFgAEWcgCnRdeeEEZGRm6/fbbvdtGjBghl8vlzcSSrHk827Zt06RJkyRJ48aNU2Jiok+byspKHThwwNtm4sSJcrvd2rNnj7fN7t275Xa7vW2AoMnLk44cserfvPqq9bx8ee8/98wZ39cnTkh33ik9+ig9PAAQJCEpGNjS0qIRI0Zozpw5Wr16tc++H/3oR1q1apVeeOEFjRo1SitXrtTWrVt1+PBhpaamSpK+8Y1v6Pe//71efPFFpaWlacmSJaqpqdG+ffuUkJAgSZo+fbpOnjyp5557TpL00EMPadiwYfrd735n+zgpGIge621xQTuys62hs7y80H0HAMSgQO7fIVnUc8uWLTp27Jjuv//+Dvu+853v6Pz58/rmN7+p2tpajR8/Xu+++643yJGkZ555Rpdccolmz56t8+fP65ZbbtGLL77oDXIk6ZVXXtEjjzzizc6aMWOG1q9fH4rTATryzN+56y7rddv/X3A4grMCekWF9flvvkmwAwA9xBIQ9OigN4qKpEWLfHt2cnKkdeukAwekZct69/kOh9WzU15uBVcAgMj36AB9Rl6eNHOmtH27tbTDkCFWWnpCgv0lIbriydDavp31sQCgBwh0gN5KSPAfhARzqYeNG61nTxAFALAlpHV0gD4tmAUH168nBR0AeoBABwiVtgUHg8UzQZlgBwBsIdABQslTcDA9PTif51kedP586U9/Cm6tneZmKjUDiDvM0QFCLS9POn9euuee4H3mmTPSrbdaQ2Nr10qDB3ecDB0If9lj1PEBEAcIdIBwCMUSEpIVmMye7bst0AClqMgaDmtfaYI6PgDiAENXQDiEciX09gKZx9PcbPXk+Cun5dnGSusAYhiBDhAOdlZCv+224HxXIAHK9u1dL2PRto4PAMQgAh0gXDpbCT0nx6qT8/jjwfsuuwFKZaW9z7PbDgCiDHN0gHDqqpJyc7M1vFVREZy1siTp7be7rqhst6hhMIsfAkAYsdYVa10hmngmBkvBC3ZWrJBGjfKfkeVZhb2z4Iq1tgBEoUDu3wxdAdGks+Gt3li2TJo716qsnJEh/fCHrXN3uipq6JlLtG4dQQ6AmEWgA0SbvDzpyBHp+98P/mefOWMFPpmZrVlZnuAqOdm3bXY2qeUAYh6BDhCNEhKkW24J3efX1PimoH/1q1JKSuv+K6+0hqs6C3KoogwgRhDoANEq1LV3jGlNQT92TKqra91XU9P5cFVRkTWv56abWofEWGwUQJQi6wqIVp75M3fdZQU7ocgbOH7c6pEpLbVeu1xSVZUV6Jw7Z/XytM0Q++QTqxIzVZQBxAiyrsi6QrTztw5VMF1+uRXUeHiCqmeekZ5+2vd7PWnw/pChBSBMArl/E+gQ6CAWNDd37Fl59FH7QUg4lZR0XbsHAHopkPs3Q1dALEhI6Bg8fPWrvsHPpEnSzp1W+nhJSUQOUxJVlAFEFQIdIFb5C37OnLHm3EQSVZQBRBECHSBedLUSeTh45uhMntx5m/ZDcO0rNQNAkBHoAPGiu5XIw6GrKsr+JlVnZ1uZZWRqAQgR6ugA8SLSc2OWL+88YPGs4dU+EPOkpVODB0CIEOgA8SLSc2NGjvRfLbmrITXPNk/hQgAIMoaugHjhqaTc2UrkUugKD0pWuvvp062vPcNSaWldD6kZYxUu3L7dmlzNPB4AQUSPDhAv2q5E3n7ZCIfDejzxROi+v22QI7UOS739tr33V1ayvASAoCPQAeKJZyXyK67w3e5ZifwHPwjt+llteXqOfvUre+3feku6886u5/GwmCiAAFEZmcrIiEddDf94JgZLgQ9jtV8uIlwcDmsILCWFrC0ALAFhF4EO+qyerp+1ZYsVMFVUdJyTEwmenikWEwX6FAIdmwh00Ke17fXJyJDuu6/zicztF+zcutWaPxMNWEwU6HNY6wpA99ovIfHjH1tDWu0zszy9Jm2LAUa6Zk9b7bO2AKANJiMDsHQ3kbnt0FCka/b4Yze7C0CfwtAVQ1eALzt1bJqbrbTvrmr2RMLGjdLMmdbxV1RYc4gGD7aCN+rxAHGDOTo2EegAvdCb7K1Q6Cwzy4MMLSBuBHL/ZugKQM90NtQVKcZINTWdZ5KdOGHV6XnjjfAeF4CIItAB0HN5edKRI1baeVpaYO/9538OySF1a84cK0AD0CcQ6ADonYQE6ZZbpF/+MrCKy1OnWnNqsrN9t19+eXCPr73mZmnWLJaVAPoIAh0AweEZykpPt9d+yJDWHqGSEunVV62eoc99LpRH2YoV04E+gcnITEYGgqux0eql6axqclcF/sJdiNBT6ZmV0oGYQsFAAJGTlCRt2OA/I8tf8cG2wl2IcPZs6cyZ1tfp6dI991gp6gQ9QFxg6ApA8AVSfLCtcBcibBvkSNInn1hB2E03WXWCmMcDxDyGrhi6AkLHTvHB9u27KkTocLQGT6EuVuhvwdBAzwdASFAw0CYCHSAKdVaIsG3gIVltQv2fr7bzid5+u+OK7xQhBCKCgoEAYpedYa9AM7x6yrNg6JNPWoFV+2KEFCEEoh49OvToANHJzjDRK69Yk4dDLS2t43yetvr1k554QrryysCGtBgKA3qErCsAsS8hQZoypes24Vp+oqsgR5JaWqTly1tf2xnSKipiKAwIA4auAMSuyZOt4KCziswOh7V6eW/07x/4eyoqrKGuzrK2PPOQGAoDQo5AB0DsSkiwekCkjsGO5/XPftZxmYlAfPpp4O/xzAjwV325udnqyelq1gDrcQFBE5JAp6KiQvfcc48GDRqkyy67TH//93+vffv2efcbY7R8+XJlZWUpJSVFU6ZM0cGDB30+o6GhQQsXLlR6err69++vGTNm6ES7//upra1Vfn6+nE6nnE6n8vPzVVdXF4pTAhCtupu8PGtWazAUTp6JzNu3+27fvr3zFdY9WI8LCJqgBzq1tbX60pe+pMTERP3Hf/yHDh06pKefflqfa7N+zZo1a7R27VqtX79ee/fulcvl0tSpU3X27Flvm4KCAm3atEmFhYXasWOHzp07p9zcXDW3+b+juXPnqqysTMXFxSouLlZZWZny8/ODfUoAol37NbNKSqyUcM9cl7w8awHRQYP8v9/T+/OP/xj8Y2tf7TmQ6s+sxwX0ngmyxx9/3Hz5y1/udH9LS4txuVxm9erV3m0XLlwwTqfTbNiwwRhjTF1dnUlMTDSFhYXeNhUVFaZfv36muLjYGGPMoUOHjCSza9cub5vS0lIjyXzwwQe2jtXtdhtJxu12B3SOAGLUxYvGrFhhTFqaMVafi/XIyTFm40Zjnn3Wd3swHt//vjElJdZ3G2P9O5D3b9livefVV30/B+jDArl/B71H57e//a2uv/56zZo1SxkZGbruuuv0y1/+0ru/vLxcVVVVmjZtmndbcnKybrzxRu3cuVOStG/fPjU1Nfm0ycrK0ujRo71tSktL5XQ6NX78eG+bCRMmyOl0etsAgI+EBCsNvLraf+/PoUPB/85//VffJSU8E6jtmj3bev/cub1bmqK52Vo09bXXrGd6itBHBD3Q+dvf/qZnn31Wo0aN0jvvvKOHH35YjzzyiH79619LkqqqqiRJmZmZPu/LzMz07quqqlJSUpIGDhzYZZuMjIwO35+RkeFt015DQ4Pq6+t9HgD6IE/q+pw51nNCghU8/PSnoftOTybW0qXS+fP239c+tb0nmVlFRVaAFIyACYgxQa+j09LSouuvv14rV66UJF133XU6ePCgnn32WX3961/3tnO0y5AwxnTY1l77Nv7ad/U5q1at0ooVK2yfC4A+wpMJFUqeLKunngrO582ZY9Xvycy0gqjTp61U+iuusHqNJGvi89tvWwuVtucJmP79362Jz0CcCnqgM2TIEH3hC1/w2XbNNddo48aNkiSXyyXJ6pEZ0mal4urqam8vj8vlUmNjo2pra316daqrqzVp0iRvm1OnTnX4/tOnT3foLfJYunSpHnvsMe/r+vp65eTk9OQ0AcQTO5lQ0aa5Wbr7bv/7PJOua2q6/5y2ARMVmhGHgj509aUvfUmHDx/22fbhhx9q2LBhkqQRI0bI5XJp8+bN3v2NjY3atm2bN4gZN26cEhMTfdpUVlbqwIED3jYTJ06U2+3Wnj17vG12794tt9vtbdNecnKyBgwY4PMAgIAyodLSQnccwVJTYy/IkVoDJoa1EK+CPRN6z5495pJLLjFPPvmk+eijj8wrr7xiLrvsMvPyyy9726xevdo4nU5TVFRk9u/fb+bMmWOGDBli6uvrvW0efvhhk52dbbZs2WLee+89c/PNN5uxY8eai20yDm677Tbzd3/3d6a0tNSUlpaaMWPGmNzcXNvHStYVAGOM/UyoZ56xsqCCnZkVbQ+Hw3ps3BjpKwP4Fcj9O+iBjjHG/O53vzOjR482ycnJ5uqrrza/+MUvfPa3tLSYZcuWGZfLZZKTk80NN9xg9u/f79Pm/PnzZsGCBSYtLc2kpKSY3Nxcc+zYMZ82NTU1Zt68eSY1NdWkpqaaefPmmdraWtvHSaADwBhjpWxnZ1s3985u/Dk5Vrvu2sbTIzubdHZEpUDu36xezurlAKTW9ack6zbv4UluePPN1gKEnbWNR3fdJX3rW13P22EVdoRZIPdv1roCAKn7pSTarijeWdtg6Cb7NOzefLPreTvxmLpOzaG4Qo8OPToA2gqkd6J9208+kR59NPAMruzs1vW4Fi2K7gywggJp5kzr57JpU9ep6W1T13va6xPu3qKioo7XwHN92ga7iKhA7t8EOgQ6AILJ0xswe3bHYn/+rFghfe97rTdvz0Kk0S4tTaqrs1LTO+NwSMuWSdde2zEAbBs8dBbMBDPosBMweYYk298W/Q1fIqIIdGwi0AEQMt3N4xk0SPrFL3xvnM3N1rBPKHt0EhKiYyjGEzwsWWINEbU957Q0aepUq0cokKDDE8y0L6Dor6etfcBk52efnW0tHsv8o4gj0LGJQAdASPnrkUhLs7a17cXx2LrVmuOCrjkcVtBRXt76M/T3s+7uM6TWgMnuz37FCmu9NERUIPfvoFdGBgD8j7w8az6L3TkmgRQu7MuMkY4ft36uU6b0bLjP8//4ixZZ18juz37ZMmn0aHtDWGSjRQUCHQAIJc8Cona0WRYHNjz/vNWT87Of9fwzTpyQHnxQuuce++95+GFrYVbPumL+gpfO5hetXWsNqRH8hA1DVwxdAYgWnnkiFRXxX58n2qSlWcNZdpfOaPu+9kORnU1q9qerydX0CHWKOjoAEIsSElrTzCNZT+fyy6X09Mh9fyScORN4kON537Jl1qKoRUVWcLJokf1AtaLCCora1x0KRX2iPlofiEAHAKJJZ8UIc3Kkb3/bCoDaB0Ge155Vy+3y9zkOh/TSS9Kzzwb2WX1dTY0VsDz5ZGBZc56AqKCgNfDw9Ai1/5zOgiI7wlXYMQqDKYauGLoCEI0CqS2TkyOtW+c78fmjj6Tly639/pa08JfW3fZzepLm3q9f13V1+oLUVOns2Z69t6TEus5d/ez9ZZx1J5T1gdr+nn70kfTLX4al2CLp5TYR6ACISXbnbnQVFHVVqK8nae4rVkjf/a60erV1Y7NTLBG+Xn3Vug52fvZbtljXynPtJk2Sdu7seC27qw/UPnAKZF6QnZT+EBVbJNCxiUAHQNzryYTW116zhjfsaBs4tf/Ot9+WXnnFKt6H7pWUWNfJzs/+8sulc+daX7cvBOnpSUlLsxc4lZRYwandStSBTLjuSS9UNwh0bCLQAQA/7PboPPOMtHBh1zevtkHPunXBOsL40jYQ2L49uEUj77rL6k3pTkGBFdDYGd7qaQXvkhL7pRa6QdYVAKDnJk+2brydZX45HFZPTndBjtRaR+iZZ6SNG63P9aerydbxzhjpq1+VfvpTqxBiMDPe7AQ5ktXz5q/fw99k6a1be7ZMSYQKYlIwEADgy5PmftddVtDhbzLzunWBD0O0rRTdfj0qz5DahAkdh0882WRdpX8PHizNmycNG2ataxUrPD/fn/wkcsfQv3/Xw4ueStRbt0r/7/9Ja9b07HsiVBCToSuGrgDAv+4mM4eKv3lFkm+ANGiQFfi0D5S6K7rocFg9JswbClz7eUGBGDzY+j1KSgrKoTBHxyYCHQDoRixW5+1s5XhPb9Trr0uPPdZ9BeorrpAuXLAm6fbdW2XwBDHVnDk6AIDg8MyxmTPHeo72IEfqvOhidnbrAqDdVaBesUI6elT6xS+6bgf7elPwsBcIdAAA8ScvTzpyxMr0efVV67m8vLU3oasK1Bs3Sk88YQV13VWq7mxytT933tmrU4p5/iY2hwFDVwxdAUDfZXdorrN2bbdnZFj//ulPfQsmeuY1NTTYr08U73qZah7I/ZusKwBA3+UZmutpu/bbb7lF+sEPOq84DUsYU80JdAAACKbOgiJPfaLuJkF3Jz3dmiTd0wyoaBDGVHPm6AAAEA6e+kRSYJObs7OtydGeuUZVVdYK812tZB+tPMUmPSUDwoAeHQAAwsUzubl9faKBA61iirfeKrlc1rbq6s7nDXX2OdnZ1nygAwekZctCfjoaMMBard3umldSz4pN9gKTkZmMDAAIt2DVJ+pqknR361ENHiw9/bRVeNFTgPH0aWnlSvvfv2KFtHy59e/uwokgFpukYKBNBDoAgLjVXeHEtgt1egS6YOerr0rJyf4raD/9tBVMhaDYJFlXAAD0dd0Nb/nrWfHMI7Jb82fIEGvitWcNsyisoE2PDj06AIB41pNhsjfesKphd1bYz+GwAqby8ogENPToAAAAi91aQW3NmmUFM7NmddwXoUnFPUV6OQAA6Oiuu6zlMNovc+FZMyyUK9gHET06AADAv7y8qJ5/YweBDgAA6FxPhr6iCENXAAAgbhHoAACAuEWgAwAA4haBDgAAiFsEOgAAIG4R6AAAgLhFoAMAAOIWgQ4AAIhbBDoAACBu9enKyJ6F2+vr6yN8JAAAwC7PfdtzH+9Knw50zp49K0nKycmJ8JEAAIBAnT17Vk6ns8s2DmMnHIpTLS0tOnnypFJTU+XwLDsfJPX19crJydHx48c1YMCAoH52NIj385M4x3gQ7+cncY7xIN7PTwr+ORpjdPbsWWVlZalfv65n4fTpHp1+/fopu/3y80E2YMCAuP3FleL//CTOMR7E+/lJnGM8iPfzk4J7jt315HgwGRkAAMQtAh0AABC3CHRCJDk5WcuWLVNycnKkDyUk4v38JM4xHsT7+UmcYzyI9/OTInuOfXoyMgAAiG/06AAAgLhFoAMAAOIWgQ4AAIhbBDoAACBuEeiEwM9//nONGDFCl156qcaNG6ft27dH+pB6ZNWqVfqHf/gHpaamKiMjQ//0T/+kw4cP+7S577775HA4fB4TJkyI0BEHbvny5R2O3+VyefcbY7R8+XJlZWUpJSVFU6ZM0cGDByN4xIEbPnx4h3N0OBz61re+JSn2ruGf//xn3XHHHcrKypLD4dBbb73ls9/ONWtoaNDChQuVnp6u/v37a8aMGTpx4kQYz6JrXZ1jU1OTHn/8cY0ZM0b9+/dXVlaWvv71r+vkyZM+nzFlypQO1/Xuu+8O85l0rrvraOf3MpqvY3fn5+9v0uFw6KmnnvK2ifZraOceEQ1/jwQ6Qfb666+roKBA3/ve9/T+++9r8uTJmj59uo4dOxbpQwvYtm3b9K1vfUu7du3S5s2bdfHiRU2bNk2ffvqpT7vbbrtNlZWV3scf//jHCB1xz1x77bU+x79//37vvjVr1mjt2rVav3699u7dK5fLpalTp3rXSYsFe/fu9Tm/zZs3S5JmzZrlbRNL1/DTTz/V2LFjtX79er/77VyzgoICbdq0SYWFhdqxY4fOnTun3NxcNTc3h+s0utTVOX722Wd677339IMf/EDvvfeeioqK9OGHH2rGjBkd2s6fP9/nuj733HPhOHxburuOUve/l9F8Hbs7v7bnVVlZqV/96ldyOBy68847fdpF8zW0c4+Iir9Hg6D63//7f5uHH37YZ9vVV19tvvvd70boiIKnurraSDLbtm3zbrv33nvNzJkzI3dQvbRs2TIzduxYv/taWlqMy+Uyq1ev9m67cOGCcTqdZsOGDWE6wuBbtGiRGTlypGlpaTHGxPY1lGQ2bdrkfW3nmtXV1ZnExERTWFjobVNRUWH69etniouLw3bsdrU/R3/27NljJJmjR496t914441m0aJFoT24IPF3jt39XsbSdbRzDWfOnGluvvlmn22xdA2N6XiPiJa/R3p0gqixsVH79u3TtGnTfLZPmzZNO3fujNBRBY/b7ZYkpaWl+WzfunWrMjIydOWVV2r+/Pmqrq6OxOH12EcffaSsrCyNGDFCd999t/72t79JksrLy1VVVeVzPZOTk3XjjTfG7PVsbGzUyy+/rPvvv99nIdtYv4Yedq7Zvn371NTU5NMmKytLo0ePjtnr6na75XA49LnPfc5n+yuvvKL09HRde+21WrJkSUz1REpd/17G03U8deqU/vCHP+iBBx7osC+WrmH7e0S0/D326UU9g+2TTz5Rc3OzMjMzfbZnZmaqqqoqQkcVHMYYPfbYY/ryl7+s0aNHe7dPnz5ds2bN0rBhw1ReXq4f/OAHuvnmm7Vv376YqPI5fvx4/frXv9aVV16pU6dO6V//9V81adIkHTx40HvN/F3Po0ePRuJwe+2tt95SXV2d7rvvPu+2WL+Gbdm5ZlVVVUpKStLAgQM7tInFv9MLFy7ou9/9rubOneuzWOK8efM0YsQIuVwuHThwQEuXLtVf/vIX79BltOvu9zKeruNLL72k1NRU5eXl+WyPpWvo7x4RLX+PBDoh0Pb/lCXrF6D9tlizYMEC/dd//Zd27Njhs/1rX/ua99+jR4/W9ddfr2HDhukPf/hDhz/aaDR9+nTvv8eMGaOJEydq5MiReumll7wTH+Ppej7//POaPn26srKyvNti/Rr605NrFovXtampSXfffbdaWlr085//3Gff/Pnzvf8ePXq0Ro0apeuvv17vvfeevvjFL4b7UAPW09/LWLyOv/rVrzRv3jxdeumlPttj6Rp2do+QIv/3yNBVEKWnpyshIaFDFFpdXd0hoo0lCxcu1G9/+1uVlJQoOzu7y7ZDhgzRsGHD9NFHH4Xp6IKrf//+GjNmjD766CNv9lW8XM+jR49qy5YtevDBB7tsF8vX0M41c7lcamxsVG1tbadtYkFTU5Nmz56t8vJybd682ac3x58vfvGLSkxMjMnrKnX8vYyX67h9+3YdPny4279LKXqvYWf3iGj5eyTQCaKkpCSNGzeuQ7fi5s2bNWnSpAgdVc8ZY7RgwQIVFRXpP//zPzVixIhu31NTU6Pjx49ryJAhYTjC4GtoaNBf//pXDRkyxNtl3PZ6NjY2atu2bTF5PV944QVlZGTo9ttv77JdLF9DO9ds3LhxSkxM9GlTWVmpAwcOxMx19QQ5H330kbZs2aJBgwZ1+56DBw+qqakpJq+r1PH3Mh6uo2T1so4bN05jx47ttm20XcPu7hFR8/cYlCnN8CosLDSJiYnm+eefN4cOHTIFBQWmf//+5siRI5E+tIB94xvfME6n02zdutVUVlZ6H5999pkxxpizZ8+axYsXm507d5ry8nJTUlJiJk6caK644gpTX18f4aO3Z/HixWbr1q3mb3/7m9m1a5fJzc01qamp3uu1evVq43Q6TVFRkdm/f7+ZM2eOGTJkSMycn0dzc7MZOnSoefzxx322x+I1PHv2rHn//ffN+++/bySZtWvXmvfff9+bcWTnmj388MMmOzvbbNmyxbz33nvm5ptvNmPHjjUXL16M1Gn56Oocm5qazIwZM0x2drYpKyvz+dtsaGgwxhjz8ccfmxUrVpi9e/ea8vJy84c//MFcffXV5rrrrouJc7T7exnN17G731NjjHG73eayyy4zzz77bIf3x8I17O4eYUx0/D0S6ITAz372MzNs2DCTlJRkvvjFL/qkY8cSSX4fL7zwgjHGmM8++8xMmzbNDB482CQmJpqhQ4eae++91xw7diyyBx6Ar33ta2bIkCEmMTHRZGVlmby8PHPw4EHv/paWFrNs2TLjcrlMcnKyueGGG8z+/fsjeMQ988477xhJ5vDhwz7bY/EalpSU+P29vPfee40x9q7Z+fPnzYIFC0xaWppJSUkxubm5UXXOXZ1jeXl5p3+bJSUlxhhjjh07Zm644QaTlpZmkpKSzMiRI80jjzxiampqIntibXR1jnZ/L6P5Onb3e2qMMc8995xJSUkxdXV1Hd4fC9ewu3uEMdHx9+j4n4MFAACIO8zRAQAAcYtABwAAxC0CHQAAELcIdAAAQNwi0AEAAHGLQAcAAMQtAh0AABC3CHQAAEDcItABAABxi0AHAADELQIdAAAQtwh0AABA3Pr/2mc0z+F3hSgAAAAASUVORK5CYII=\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = [i for i in range(200)]\n",
    "loss_li = [x/(cur_times+1) for x in loss_li]\n",
    "plt.plot(x,loss_li,color=\"red\",marker=\"o\")\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}