6-Fig_11_13_S6.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "#from LogGabor import LogGaborFit\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision.utils import make_grid, save_image\n",
    "import torch\n",
    "from SDPC_PCB.Coding import ML_Lasso,ML_FISTA\n",
    "import pickle\n",
    "from SDPC_PCB.DataTools import LCN, whitening, z_score, mask, to_cuda, norm\n",
    "import torch.nn.functional as f\n",
    "\n",
    "from  SDPC_PCB.DataTools import DataBase, ssim\n",
    "from SDPC_PCB.Network import LayerPC, Network\n",
    "from SDPC_PCB.Coding import ML_Lasso,ML_FISTA\n",
    "from SDPC_PCB.DataTools import DataBase\n",
    "from SDPC_PCB.Monitor import Monitor\n",
    "from SDPC_PCB.Optimizers import mySGD, myAdam\n",
    "import torch.nn.functional as f\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "import time\n",
    "import tensorboardX\n",
    "from SDPC_PCB.DataTools import LCN, whitening, z_score, mask, to_cuda, norm\n",
    "from torchvision.utils import make_grid\n",
    "import numpy as np\n",
    "from tensorboardX import SummaryWriter\n",
    "import pickle\n",
    "from torchvision.transforms import ToTensor, Compose\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.optim as optim\n",
    "from SDPC_PCB.Monitor import Monitor\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.stats import wilcoxon\n",
    "from decimal import Decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "cmap1=plt.get_cmap('tab20c')\n",
    "cmap2=plt.get_cmap('tab20b')\n",
    "color_fb=['slategrey',cmap1(3),cmap1(2),cmap1(1),cmap1(0)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_param = grid_param = {'padding':1, 'normalize':True, \n",
    "                            'pad_value':1, \n",
    "                            'nrow':8}\n",
    "\n",
    "save = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "warning: Not all batches have the same size, the last one will be dropped...\n"
     ]
    }
   ],
   "source": [
    "data_path ='../DataSet/CF_DB_testing/'\n",
    "\n",
    "LCN_params = {'kernel_size':11,\n",
    "'sigma':0.5,\n",
    "'rgb':True}\n",
    "\n",
    "mask_params={'n': 10}# default is 10\n",
    "\n",
    "whitening_params={'f_0':0.5,\n",
    "'n':2}\n",
    "\n",
    "Data_load_param = {'batch_size': 40,\n",
    "'do_LCN': True,\n",
    "'LCN_params': LCN_params,\n",
    "'do_mask': True,\n",
    "'mask_params': mask_params,\n",
    "'do_whitening': True,\n",
    "'whitening_params': whitening_params,\n",
    "'do_z_score': True,\n",
    "'return_idx': False}\n",
    "\n",
    "Facedata = DataBase('from_ImageFolder', data_path, img_size=(100,124), reshaped_size=(120,171),**Data_load_param, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#def Entropy(histo_of_proba):\n",
    "#    return -(histo_of_proba*torch.log2(histo_of_proba)).sum()\n",
    "#def KL_uniform(histo_of_proba):\n",
    "#    equiproba = 1/histo_of_proba.size(0)\n",
    "#    return (histo_of_proba*torch.log2(histo_of_proba/equiproba)).sum()\n",
    "#def gamma_pdf(x,lbda_param):\n",
    "#    return lbda_param*np.exp(-lbda_param*x)\n",
    "\n",
    "#def halfnormal_pdf(x,sig):\n",
    "#    return (np.sqrt(2)/ (np.sqrt(np.pi) * sig))*np.exp(-(x**2)/(2*sig**2))\n",
    "\n",
    "def show(img):\n",
    "    npimg = img.numpy()\n",
    "    ax.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n",
    "    plt.axis('off')\n",
    "    return plt\n",
    "\n",
    "def show_ax(img,ax):\n",
    "    npimg = img.numpy()\n",
    "    ax.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n",
    "    #plt.axis('off')\n",
    "    return ax\n",
    "\n",
    "def reconstruction(Net,gamma):\n",
    "    reco = [None] * (Net.nb_layers)\n",
    "    for i in range(Net.nb_layers-1,-1,-1):\n",
    "        reco[i] = gamma[i]\n",
    "        for j in range(i, -1, -1):\n",
    "            reco[i] = Net.layers[j].backward(reco[i])\n",
    "    return reco"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference with different noise level and feedback strength"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Noise Robustness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n",
      "total Image 40\n",
      "total Image 80\n",
      "total Image 120\n",
      "total Image 160\n",
      "total Image 200\n",
      "total Image 240\n",
      "total Image 280\n",
      "total Image 320\n",
      "total Image 360\n",
      "total Image 400\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"\\n    with open(path_saving, 'wb') as file:\\n        pickle.dump(Exp, file, pickle.HIGHEST_PROTOCOL)\\nelse : \\n    with open(path_saving, 'rb') as file:\\n        Exp = pickle.load(file)\\n\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_name = 'CFD_[0.3,1.6]_b=1.pkl'\n",
    "feedback_list = [0,1,2,3,4]\n",
    "where = 'Savings/CFD/'\n",
    "\n",
    "std_list = [0,1,2,3,4,5]\n",
    "all_reco = torch.zeros(len(std_list),len(feedback_list),2,3,120,171)\n",
    "noisy_input = torch.zeros(len(std_list),3,120,171)\n",
    "nb_image = 400\n",
    "all_ssim = torch.zeros(nb_image,len(std_list),len(feedback_list),2)\n",
    "ssim_baseline = torch.zeros(nb_image,len(std_list))\n",
    "#if save_simulation == True:\n",
    "for k_FB in feedback_list:\n",
    "#for idx_model, model_name in enumerate(model_name_list) : \n",
    "    model_type = model_name[0:8]\n",
    "    name = model_name\n",
    "    print(name)\n",
    "\n",
    "    path = where + name\n",
    "    with open(path, 'rb') as file:\n",
    "        out = pickle.load(file)\n",
    "    Net = out['Net']\n",
    "\n",
    "    for i in range(Net.nb_layers):\n",
    "        Net.layers[i].b = k_FB\n",
    "    Loss = ML_Lasso(Net, [0.3,1.6])\n",
    "    Pursuit = ML_FISTA(Net, Loss, max_iter=1000, th=5e-3, mode='eigen', accell=True)\n",
    "\n",
    "    for noise_idx, std in enumerate(std_list):\n",
    "        k=0\n",
    "        for idx_batch, data in enumerate(Facedata.data):\n",
    "            image_ori = data[0].cuda()\n",
    "            batch = data[0].cuda() + std*torch.randn(data[0].size()).cuda()\n",
    "\n",
    "            gamma, it, Loss_G, delta = Pursuit.coding(batch)\n",
    "            rec = reconstruction(Net,gamma)\n",
    "\n",
    "            normalizer = image_ori.view(data[0].size(0),-1).max(dim=1)[0]\n",
    "            normalized_image = image_ori.div(normalizer.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1))\n",
    "\n",
    "            if k_FB == 0:\n",
    "                normalizer_noisy = batch.view(data[0].size(0),-1).max(dim=1)[0]\n",
    "                normalized_noisy = batch.div(normalizer_noisy.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1))\n",
    "\n",
    "                ssim_baseline[k:k+batch.size(0),noise_idx] += ssim(normalized_image,normalized_noisy)\n",
    "            for i in range(Net.nb_layers):\n",
    "                normalizer = rec[i].view(data[0].size(0),-1).max(dim=1)[0]\n",
    "                normalized_reco = rec[i].div(normalizer.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1))\n",
    "                all_ssim[k:k+batch.size(0),noise_idx,k_FB,i] += ssim(normalized_image,normalized_reco)                \n",
    "                all_reco[noise_idx,k_FB,i, :,:,:]=normalized_reco[9,:,:,:]\n",
    "            noisy_input[noise_idx, :,:,:]=batch[9,:,:,:]\n",
    "\n",
    "\n",
    "            print('total Image',k+batch.size(0)) \n",
    "            k+=batch.size(0)\n",
    "            if k >= nb_image:\n",
    "                break\n",
    "\n",
    "Exp = {'model_name': feedback_list,\n",
    "       'std_list':std_list,\n",
    "        'ssim' : all_ssim,\n",
    "        'reco':all_reco,\n",
    "        'noisy_input':noisy_input,\n",
    "        'ssim_baseline':ssim_baseline}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fig11b and c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "save_fig = False\n",
    "mean_ssim = Exp['ssim'].median(dim=0)[0]\n",
    "mean_ssim_baseline = Exp['ssim_baseline'].median(dim=0)[0]\n",
    "color=['slategrey',cmap1(3),cmap1(2),cmap1(1),cmap1(0)]\n",
    "std_list = Exp['std_list']\n",
    "b_list = np.arange(len(Exp['model_name']))\n",
    "\n",
    "fig = plt.figure()\n",
    "for idx_b, b in enumerate(b_list):\n",
    "    plt.plot(std_list ,mean_ssim[:,idx_b,0].numpy(),label='b={0}'.format(b),color=color[idx_b])\n",
    "\n",
    "plt.plot(std_list,mean_ssim_baseline.numpy(), label='baseline',color='black')\n",
    "\n",
    "plt.yscale(\"log\")\n",
    "plt.ylabel('SSIM', fontsize=15, labelpad=10)\n",
    "\n",
    "plt.xlabel('noise std ' + r'$(\\sigma)$', fontsize=15, labelpad=10)\n",
    "plt.xticks(std_list, fontsize=15)\n",
    "plt.yticks([0.01,0.05,0.1,0.5,1], \\\n",
    "           [r'$1.10^{-2}$',r'$5.10^{-2}$',r'$1.10^{-1}$',r'$5.10^{-1}$',r'$1$'], fontsize=15)\n",
    "\n",
    "if save_fig == True:\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/Fig11/Fig11b.png',\\\n",
    "                bbox_inches = 'tight', pad_inches = 0, dpi= 400)\n",
    "plt.show()\n",
    "\n",
    "fig = plt.figure()\n",
    "for idx_b, b in enumerate(b_list):\n",
    "    plt.plot(std_list, mean_ssim[:,idx_b,1].numpy(),label=r'$k_{FB}$'+ '={0}'.format(b), color=color[idx_b])\n",
    "    \n",
    "plt.plot(std_list,mean_ssim_baseline.numpy(), label='baseline',color='black')\n",
    "\n",
    "plt.ylabel('SSIM', fontsize=15, labelpad=10)\n",
    "plt.yscale(\"log\")\n",
    "plt.xlabel('noise std ' + r'$(\\sigma)$', fontsize=15, labelpad=10)\n",
    "plt.xticks(std_list, fontsize=15)\n",
    "plt.yticks([0.01,0.05,0.1,0.5,1], \\\n",
    "           [r'$1.10^{-2}$',r'$5.10^{-2}$',r'$1.10^{-1}$',r'$5.10^{-1}$',r'$1$'], fontsize=15)\n",
    "\n",
    "#plt.legend(loc='lower center',bbox_to_anchor=(0.5, -0.5),ncol=6,fontsize=15)\n",
    "if save_fig == True:\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/Fig11/Fig11c.png',\\\n",
    "                bbox_inches = 'tight', pad_inches = 0, dpi= 400)\n",
    "\n",
    "plt.show()    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fig S6a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHwAAABrCAYAAAC1zeadAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzsvHeQZNd15vl73qR3lVm2y3ZVe4OGtzSgRIoCQUkcUqRESaHZ0e7MyGysJmJGu7PSSjMxmuFqGCu3XEoiRYFLYSiRFAASBAlSJNAwDddob6q7y9vMSp/58vm3f1QDJCUCzY3Y3SkucSIqsqLq3Zv3ft8755577jlXiKKIt+RHR8T/2gN4S/6/lbcI/xGTtwj/EZO3CP8Rk7cI/xGTtwj/EZO3CP8Rk7cI/xGTtwj/EZO3CP8RE/m/9gCuy1vx3f9nRXijf+wUwnn44YeRJAkAQRBAECCKePIrX6BYGsL1Ayanxkllit/TLooiXM+DKEJRlNf7eK0fWVb49jceR9N0PM/n/nf/JJ1O+3vaB0HAhz70IT73uc+hKAqCIGyP4Xofe2em+PSffRLX86nXtnjgZ36WKIq239IoIooiPM/jwx/+MA8//DCyLH9Pe4AvPPxXDAwM4nkBH/r5n2d1dZPX3vMoigjCEM91AdA0DVEUv2cepmny6N/+NbpuYFkW7/3pD+I4DkTf6cP3fT70oQ+9Kc47xqQLgoAoikiSjCRJSKLI8a8/wmYzoFzZQiHkwunT7Ns7gyTL2z+ShChKCNfbS5KEJEnIsoysKKiqxtce+wJzC2uUN8q0Wk0e/+JnURRl+5nr/bwGriAISN/1d1mWufnmw/zWv/4typUatUqFeDzJ3/zlnyJJ8vf08Rqxoii9/ndZUVAUha/87f/J5lab5ZV1xMjnM//HnzA0NPCd567P5bUXTfru9qpKIpHgr/78E1y5usjG2jq1eoNHPvfnaKr6vXP5rpf9jWTHaPhrk93WbqhXlvEFhX/x4FE0zcD1bBqWze//7m/zUz/70dc1TPiHxus16wB8+pN/zEcfuI+kaSDLCm63wae/+hKHDu7h1JmLEEX/yPYJ1/sQBAFFVvgX/92/5Nd+5j40IwZhgNVp8qVne9e/QiASQPiuE8fXx3P9l/L6PPtnJvjoe4ooqk7g2jz54ll+97f+B37lN/716xoq/MMxcB0P4A/+w+/xqx+8n1QijiwrdJtVPvnlExzcP82ps5fe2H5/H9kxGv46ZNdH/9wzz3PPkSlERSMIQQx9YlJIJKm8BpHwj9j+DnCGYSIpBrqiIMkqAtva966bp/hXv/7r32O232hArzz3DXb19yGrOggSRBESIdVml6M3Hd1+6A2Ol1+zOk985QnGCklERSdEJAoDbp8ZRNXjPxAiZiyO60fEzBiCrBOxvUwdGS/yK7/0i4iCQBT94E7QjiH8dbkOoOMGGJpKs9HBjMexPAFBlLC7rdce/P7Nr3/6QYCmSCiayd99+eucPnOedGGAbEKnlNLfdAgCEBFx133v4O5bDyFrcU698gpf++YzJLJF/sk7j6Cq6g0msv1COY4HAlycXUSSJCotF1GU2D9W+q5ve+Nx+EFAwtTQ4mn+7tGv8urJ06SLwxydHqaUMr6PiXtz2Tkm/bVPQSCKIjQpRFc1RF2msbKEmc4ghA7vv238O47KG/UTQTKRQAIkIeKBn3g3veoa9XoDTVW5dnWOd7yJWkTX+/nGY18iZ8oUDuxn18gI+/buwfVD3OYWs1eufgfs76vl2/1rEiTjMdKpLN3KBtl0GrwuhyaHXh/wG+WgRBEkE3FUIcJ3evzke9+NtbVKvVZDEkXmZi8RhuFr/u0PJDtOw1/LwEnFTdwoQrC7OIJM0G1jdVr89ZOv3rgTAeyeRRBF+L6H16igawZy5BN4Lv/6Dz5x/QV7Y8YjQDESPHd2HpEIXZZol9dwOw3Ozq1Tr9VeG/AbzGP7M5/L4ocRbrOK7QvgdOl1mnz2i18mDAKiMHzTqfQsCzeEKHDx6mVkSUEKHFzP5T/+1SP/t9Zv2EGER9F3tjCapnHPO97B57/6HC27RyGZplbdRJRgcmr8+kshvPFko4g/+6OPMzxQIFcaQBAlTNWgXitzen4Tq3V9WXgjcyiAKIqsrZeRFBXftcilc6RTWZxem2sbbaLwjddvrjueqqJw1z138bt//Flsu0cxlWJrfQ1JUfn13/59BEF8Yz/ieh9//qd/RDymoRkGgiiSMExa9Qof/6tHaddrPyi8r8uOIXzbtG0D6Loun/+rT5MyFKwgpNnawldUjp+eJ2bqiKJIRMQ/zsfbXg4EUeSj/+yfc/TYUf7TH/0Ftiiy2dii2u1xbm4TUxO3276ZLY0iPvLL/wxDFQglmXKrQU+ASschGY/x+jb5+xF23ft3PY+vPvYIEyODWJHAVreFJ0t85fnzfOmhv0SUtsfx/SiPoghREPjoP/0V9u6Z5nNffBwLkc1GjUq7S65vkMjtXp/CD67nO2YNj8KQWDLN+vIiZjzO7e/+AIl4gj6hRtMLMUSYGHbxk1OsrS5z6OgxNtbW/gHpEeXyBo7jkc1mMWMF3nb/uxAUCU8LyRsGB8Ztzl64QiJukCuUsO3e9xh2UZSo1aqoqkqj0eBdD3yAIKxji+DbDul0hlvvm2R5aRHbtpmY3E34XWOIoohEKsX81avEEwluf9eDJBNJ0lEVy/UxkhkOjPt4+RmW5q9x4PBRatXq985DENhYW8V2PHK5LH27ZhgZGEBQJbwgIluIMTLQYnZumUTcJF/sJ3D876MA/1h2DOGu67C+soSiqriOQyaVIggCymIeXbUIZBOjVESQdXw/YGHuGq7johvG6xPt9XrE40l03UcURaxul3i2RCdwkQwDLwoo7R3AdR0QJOq1KqqmEfg+sE1Wu91CVVXCMESWZURJouKmEaIWWtykZdvoRhxRFEmlodVsoKga4fW12HFslhcX0Q0D3/dJpzM4tk1Vy6FqNihxYuMjIGn4vsfS4iJRFCLLyuvz6HbaJJIpDN9HkiQMwwQzRjNwUGIxnChk3x3347gugiRTq26havrr83gzEXZImvKOGMT/j2Tnx9I/9ZmHmBgdotVqUl5bI5HOEoYBL584jhpLYUQBkeBz8KY7MHP9BFaLrVodRRTwQ1AVCZEQWTMIw5CUptDsOWRzWf7y058hncnSF1N4x4MfYO7aVaLAJ5HJMXt1npFSjg988Gf53EOfwTB0tioVcn0lBCKKxT4unDnJwuoWzcoG1a0yP/2RX0TXFOq1OulsBj+IaNW2+Ogv/TKf/5u/QZNFLMcjlUzQbTVAUvjqY48xVMwjm0kScYXpPQexHRfX6qAl0rg9C0SRMAjQDRPXsQkCH1VVUTWd0aFBHnroIUTfwfF8PvCRn6fbs+l2u0SBjyQr+J7LT3/gg2+K845x2gxFolrewLU67B4fJyF5PP/Ut/C9gLTgMzqYJwhUdu/bR2g1sCyLsWIWy7JIxHTsngWCiCJEiEC13SGdSfPxP/rfmRgq0q902ahU+NYjD5ErFMnnsljdLrfedJBWuwNAIplENROk80UUVUMQJZ545L9w4vmXcToN3nZkCkWP8YW//GNs2yWVShL4AZIA4XWlsm0bUVbIZ1J4tkU8nuDbX/kCAtAor5BSPFauXmFiaopkOoOqG4iBQxCGiKJEGIb4dhfDNEkkU4RhRP/AIP/qN36V9sYCpZhEr17mLz7xJ7iOC4GHrKjouoERu1H0bgdpuBGPs7C4RCyRgVaXcy+9xJHbbiXW3cA0EuiyRDgi8rH/9Afc9+MPEJMlrEjE0DXa3R6ubVMcGETXNNbXN0iaBg996pM8ePM40/sOIoQ2na7FH372CczY1xndeytup0GlLJJMJQGQJIlOu01Mkwg8i2y+n+Onl/ntX7ifWN8Q9fVFfvGdB/jEV0NUMUSPpWl3LEQiYqYJgBx5RGFEu2uhKiqf+9Sf8uDb72BgZAyFkEZtnaCzxW/+t/8N/9N//AO67RZhBKoc4tg9IgSMRIp2s4EkSWQyWf633/u3/Jtffj+uaJBNxTk0OcgfPXqCpcuvMrb3JmqVTaJ0Ftfu3RDnHaPha4tXGSnlycRVTCnAjjT8yiJ6oo9cLoXgbDGWN0kqPlh1NCGgsrFBPB5HJCJX6KPZaLC2vk5SlxAUnXgyB0YSUQjotTs4Vof33nWQSxcuE0QCRixOGASE4fVwrm0jSiIBErF0geNf+zvu3LcLQVFprM+jaTo930XxW9z19vuJwgARn9D3keRt3RFVAyMWw/cDhDBAFmXEoEdtfZGNzVVSusnhyQF8xWCrskU8kSQKfRTdJBJEJHn7BDCeSG47jpqOH4GoxtAVCS8UsVyPOyaTPH38OVRNQ4+n0FSVSLgxnTuG8F1jk8R1FSMWI1LjzG002Dc5wejQCL4nUyFNo+uyutVBFCJ0TSGWTNNotYnFDHqOixT6+H5A2wnRdZVet83kUB+XL8wyu1SmlMuTjYdoUkgmlUAz4/jf5dkKApimSRQ4NCsbHLvjHvbv2U2xr59Wy2Nto0IiN8rb77oZQ9dw2tXrAaMIP9j20k3TRBMDAt8nkhRWy3VEI8la1UJSVGbXqtitBj9+bApFkWk3aniOQ6/bBbb35KFn03M8YqYBUUhCl/EllZOvvMrZc+cw+nYxPZhHFbePlMMwYGOzjCTc2PfdMYR73TaOoKIGNqIoMp4RqbU7vHzuNOsrl5BCF1mS+Mi7bwMEVrfaiHaLbK5As9VFliXcMKKvkCeViBN4PpYHhD5T03vpl2yaXZu4HqfV6rK2voGh6+TzeeK6BkCz3UWTRFRZRTZMFi+epbG5wvzVWaSgTS5pYCgCQq/J8WefRzJShEGIKKu41nb0zu716NoB+UIex+qwa9cQMV1j98QozWqb4b4UFiopXaBeKWOaxva5t6YiyzJBEOL4EboiEkQCQ8UckWYiuj2O3X4baVNGDByyg+N0m1V6loWuGwwP9CGINz4P3zGEW16A5/tcW97ADkCIpVmp1EkZCoaaImtqRN06n/r05xCikJjg4iomvtdDUWS8XgdNN7C7HTy7i2V1CAOPwAuxG1to/SNAQL3n8S//54+RTKaobqzTrNfo9rbXvmwuD6KAHUaoksjUvoM88+IriIpEJpnFrjeorC3xteMnqZfXt6NkUUDPdnD8be3SdBPH6VHfqlDoH2S4kEQ1DSK3QyKVQI1CvJ5NNYqRyORw/RBJVgh9H1EQEATo2T28SKRn21yavYrVbKFELrXVOXKmjOy1sZp1fuk3fosg8FHw6XR7eI5zQ5x3DOG+65IwNVTNYCgfZ6RU5GuvzOPJJoMDI6xv1vAFmVvvfw/ZTJqeoBO6PSw3RBa2105RFOhYFs1OjxNPPkExKZEZHiWeKyB3azRXrvD5x59mbWUZVVOwHAfFiL2eWuR0m7ieTxRG2F5IEEZ4ShJfFCDqEcuk8P0e8XwJ3YyhaSqqqiCL39n4hp5Nr2dj2TaR75EqDvPv/vOnqLYcZM9maX4WM2aSzhcJggAB0FQFz+ltH4e6Dn2FAqahEU8k+eYTTxBLJenpOcJIIghFmvU6H//0lxBFEd/16LoBiD+Y/71jCHdcBzNVQJYELl+4yIkzF9kzNsBg2mSxWiVu9PjWxQ1MIWJjs0wqGSOTztBsdXH8kDAI6LQ7GIZB0tR42wM/xcTEJB//k8+wsLrKltVlNYzTly9xdM8YjUYLzTCQNQNF2z4f90KwbYfA93Bsm/zgLlLJGL4d4AsG6+UqLU/D1GQyyTiW1aPV7aEoCplcDgA/jFBUlZgZw3MdFuauMTMzRbteI1JjtHyZZ169gCFBaLfwPJcoipAUFaIQWdGwbRu3Z+E7Pd73gQ8yPTrIM8eP03JDnDCgagUMjuxi11A/qmGiSCKSAIJ0Y9Kl3/md3/l/k8cfVH7n8uwVtioVRALWWh4J02SgVIROFV/RESSNvf0CWt8klZaFKkEoGxiqiCyBLET4osq1i2eJBAFRlskVBxkfG0TVYlRbLnsGM3hELJVbpDNpsokErWaDeCLO1NRuZi9fJm7qWD0XURSwej0S2TwZLaLhgamApMj0jcywvF6hulVmaHAAwpB2t8fBgweZvXyZIPBp1LaQVQ3L8Rnbc4CBtEy956NqCulsHrVvnK1anXQ2R+B7RIKI6/qIkohpmiwvLWL1bERRwszkMHWNfDrBwlqdmKnhINPq9ognE5ixOFa7ie16HDx0COB/eSOgd8w+PAxDVFkiCkMmh0vgpmhZFq7chxOJuLZH38BNiH5AX04lLnTpdFq02k1yiRguEqIQMLhrAqIAz+4RaQK1boBpqiSHJ9kE8uOZ7Th6vUmLCD2RpFarA+C5DjXfRxQibMejZ9skYzEakUmo9EDPIGsGsh+QT4CkaDQaTbwgxDBjwPYJmQzEEmmCEIZGRvF9j5Y5ghs0MLJDyI6LomnkMmnqW2UcL8SMmddxiKhUKhhmHEWR6fUsRElGThdpEDG4J4/Vs9mdn8LzXGq1OqLUJhGPE9ruDXHeMYSn4iaNZgtNU7eTFzwXVQBRUsC2SSYSOFYHUZTQZOh4KgIu6Zh5nWwBIh9d1wgDnyAMiVyHdGI7+TCKQgRBQJclkGQiQUQMPZyeRRRsb808P0CSIhAlNFUm9DzCcDuShqIjq8rrz/Z6DoYgbj8bBfSsLgBREOBGIbIk4jk9NEVEFGRkScDQtg9lTNPAtiw0WUTVY+hGhOc617NXRBRFQTEUXGc7EBN4DrpuEPrbJ2KSZqLIIpIQIasqgevQ7nRImG+eugU7aA2vN9rouo7v9pDSgwwODZPJ5Dh17hKCVaO1epWvPPZFRnbtohcIDBZLjEwfwHPs7eBJ4JNOpwjdLpquM1jqw0gkGcjFmZ+7xrmXnmN+eY2bjx5GwcdzOqi6ToBIJpUAIBuXScRMXNfFNE1y+RzT07t5/CuP8vw3v8rK4gJnXn2FhKEwUCpgmjpJUyMURAJn29Pv9bpEna3raVogiRBTJT738N8wt7bF4lqF5596ko3VZUbGJ5ncNcDGVgNVVUim0hCGGJqG4PdQNJ24LtPtdpkYzPHC8W8ye/Eca6trHDu4l4FCipgqY3sBo4P9WM0bJ0TsGMIzpSKWF1BMxsiWhpi7dJqXnnqS/ZMDVD2J7NAEI/vv5uzJFxgrmPQiger6Io6WRlMlJFFgfWGWri8RihqKomC5IX/4sY8hCBHvOHYQp9Pk8w/9OX1Jk92TUyR1jZVrl9CNbXNqZkpslDfJxFRCf/vo8d//m9/glukJjkyNMGQ4qIkczz71TZqVMql0lk6njW1ZmPp2UmMyHkNNFUhmsnQsm5mZGU488w3efcth+rw1xpMCgqzy4z/5kywuLVOzXG47OEGr1aJZryHJEhvlMoGkEzcNJEXl3rvu5Ld++z8w3l/g1n2j1NYW+OuH/wu+EmdldYWx3XtQdB0llrohzjuG8Ki+DkFAudlh4cTjLC4sc2TfJPnSCIeGcsiywK39CmcvLjC32WJldYXNps1ANoHvuQiiSCHXR7Evz97xAa5du8q3HvtbPviRD3NwapR8Ks7dIwqSpvPFRx6hZztgdzmwf//rWSvXzp0mnUqjGybpVIp0Ikbbk7n1tiMcuvkYuUI/773nGG6kEwoiK0uLhEFITBFwhG1zGskaURTSqDcYHRnmz/7X32O0f5CM5jIwtptsPOTemTy/+Wv/nELKQAx8ZhdWScQTBMH2shPYHRyrxVa5TKfd4RN/8ie8/+6j3HPrTfiCxnvu2MNzzzzD0197BASZzsY8lbVl6vX6DXHeMYT3ej6yEcNFJZZMk1Q05po+qgxSJkMplcLXFDRNRhVCRgeK7O032KrU0PUYUQRmJsv07inqrTZmrh/P7lIwRJQoJEjkkAenyXgVap7K3OwF0AxcP2R+bn57EIrGQC5FtVKl1epw4qlvMLN7inazg1BfxhEUGqefoLm1RnZwhLguEkukaAUymrwNpaaoiLLG9PRuGs0m9WaHjOQiyAJC6NFugZgoEUsXWV3fYH15gUw6Q0xXSCUTeEFIX6kfU1ORZIlEOkOtvMnMSAEn9Ejj0LJ8fvWDP8b8lasMDQ2hJnIsrm0yvXvqhjjvGMInDuwn9Bw8zyUe09lwYWpiiqePP0d5dYVvvnAOUVAwYiaiouEjcXGtTbq/iNOtossCDTvi2ZfOUFleImqVGRyexFdNvIWXaVfXOfX8CSIzh9orc/DorTQ9gcDuIsoKAG4Aa7UOFgrljTV2TR/gwz9xH+WOSydQ2LhygY1uwDtuP8qte8boWT1ESabXrFOuNgFISi6FfJbl1XUajTpiLEsj0jh/dZ31zSZdJUZzdYV33nGUYiHP2lada1evYLkBItv1cZHnke8fYnywiNW16B/qxxzex6WzZ1mvVTl9dYWFRsD0UJ5Gq0Wn1WBwcJhKpXJDnHcM4fOXLmIEPVLFEZBjqIJLc/Mqx2Ym8N2Qw1O7aLfaHJkcJm7GWJq9SCmmsrW6hi0maHZ6bK6ukBfapPtHmD50DNfpEGyVGbj3Z5i9fAFTitg9OkmzY7O5VSWlQcMTGBjazhHPZ5Nomkp1c42ZPdMsXrvEt599geFclnqko2gKan4Ia+Mij37zGXq2SyIRI1fIMVTKAuCqCVZXV0klE2iawS27+7ll7zg37x2jEI9Risn0FfJkrA1qrS4juQS5bA7DNLH9CE3TUXWTXrPK0uoGQ/0FRKfDwvwVpvYepFNvsH/PDPuLGt947hUUISKSFFRVRufGKU47hvA1x6Buh9jNCudefQnHFjm/2qbVcRBFBae1jCLD088+x8r6OiN79hDpOUZ29WPqKpqmMVzM0PBlNlcWuHjhHHanw3x5Af/Mt0gWhrj5tmPYls1Hfv3fUl5fx49EBtIxFq5cAsBBx3FddDxq9RYPfvAXeOz4qzi+TVHyiBkGpXSGZ0+u0D84TCLfz+raOlIYUr+eMmy5AfFEmo3leQRRwAoDLsyvkM+n6Dfa1MrzbK7OIe06QKnUT6iajE5Ns15tIysyPatLvq8AkkqiMMC1+SXOLFRI+A1ycRM/CKmsrFKud/nN3/l9dFlAFgW8IEIwkzfEeccQnjMjkukUK9UWI7v3cvtte8kZKqnBYQxVYmm5QsxIUhoaIQwFFN9Hcpq0eiFet4Wha3h+SC6hgNtlfKCP0b44Cw2Bzcwk/vo5nn76JE89/wzYbUJJwbLaJAr9mMa2w9Vr15B8l4HRcRRV5ezLzzK1/xCu43NlrcHc1SusL54nSqSYPfsKhiZT21yjONBPrbpNeNBtUF2+SP/gALphcOCWe3j4ieOookTbHMDrtKi6EV6vy9xaGcOM4dtdpkaHiMJwO4nTD6g22kSBSy6hMTNWQi5OcuXSKRLJOIkYPPTlb1Hq70c0UzjtOkIU0qys3hDnHUN4u+MQOW0ODmco5jNcnF8lGdOwGhusLFxm/5HDrMzPIoseaSOiFwh0nS6R1QZFJ0Cg123hRjKSmeTU2XPIg/tR/Ijm1gZO/jAz+/fiuD1u3zdGo7yOqumU621i2e06L10ScOUYoaAgRj6r62VKqkvGCKh7Pp6Zp9oVMeJp+oZGsdtN7rrlCGYyy+TIAAClUgktN0ZlfYNsMsHzJ15mvL9IpdVmfnWDllagUushihFm0MPEpuf52M0tXM8jigTwbHRVolPbIlvoZ/+hmzjxzFNIyQH0mIHnRdx89710Ww18p0dxYJh2o8bA4OgNcd45sfSn/44wN0atWkFye5SGx+k6HmN9Jj2ljyCM6PkB6f5Rup0GTiSRNg16nocY+niex8TYLhZX1wndHloigyKCLIak8zmUbode6LNc7eAqCQbHpzDwCVwLQYiY2bOflc0ye8aHuXrxHH4YISfyFEsl8tkkkmIQKQaSbpArloiLAX4EW5sb1JstIiL2HTzC+uYm1y6fI53vY6uyhSuo7D1yE4pmcGByGGtzg/7+FLPrbURFZb28hdvt0Tc4Qq/TxnZdZnZPcunyFQIEgjAkXyiQzuVAiaE6HbY8gaWlJQJRIZVOISsqgeviBgEze/fDD0Ms3U0OkvAt9EwORdWobCwjCiKbDYdYPA6ui55IUW/3GCkM0O7ZNBo2gSARhCGyorJe76HKMrF4BqvXI5NKoeAjaUnaeoAsaxy69W6iwKe+uUZTkpEJsb3tbJV2vcbT81dIJtO4oUDQqaMrMrMbPVQxIhaPEwopRM8jNBL0ul0kQUWMBEJhG8ozJ19G1Uw6nS6JRIJCBIokUukGtFYtvMwwQQiT0yqyJGAn07iOw8b6Gn4Igihx4uXTqKqCqpt0LRvH9YlQaLa76FqRREzh5r5RulYXy3JePwtXgjevU4MdZNKdnsXq2gamBM2tBtWuBxG0PAXdTFAcGkKVFYYHBkGUKCRjeI6NEtiIgkTgB3TbTTKpJJ7roEgSihgiGklsLyBXHETSTHzbhtBDllUUSSQUFRKx7TU8pimkNJEo8BjsL2JqKl4YIYkQSRqB66IbMVRVw1AE0skERjyBpusIUQCAaZj0pRPEE0lgu8TZ6zbRxRDV6yGLAvGYQRAE9LptNEUmHTMIPBc/CJBlhbihomk6pq4Sj8dxeh0MM4YpBtu1bo4FUbAdgnW7xE1z+5qR6IeI8Nvu/XGO3ftjNNyQWDrN1NgI/aU0Ua/Fcy+8xBe/8Ch1J2TxyhWa7Q5rjR679uxjev9RMnGNVEzbrrJ0uiRiMfKmTCLfT6+5xasvv8wrp87QtFyWF66hZoYY6i8wd+EMlhchXs8F88OAdL5Ipe1SqTWJKZCNqbzw7SexWjWWFueZv3SafGmA2YuX6PRs8rk8rpykXNveh8fDDpKqo4shsgQzM9PMHDjMCyde4MXnn2J57gqh3SGVSZBNp7Fdl2xxgJipE4/HUbw2ombiOhbZQpF8qcTBg/t59htP8NKp88wtr1NeukbUXmegVMCXNGRFppDPktRuXGO2Ywg//+yX2epFpHWFoLHOfNnmuQtljozE2T06xEghxpDhcuHqNaTAoU/zsNsdVj0V3w2QJJmgWWZqYgLZqVHvuZRySTYXr3Fg3yS3zoxy9dQLjOgBMcmj1Wxw5PbuKe0pAAAfl0lEQVQ7CK0GcytlAHTdYHllGcPQMMIeE3sP85VH/4ZSsUivXqbfCLg4e40z336cA7feyUguwValjNBc5h333QNAmOjbLooQoFVe59qVK3zyk3/OXYd2c2zfJPccnuHVM+cwZRFfkLEdj2vnXiaRTNHrdtGSeXYN9JGKx4nHTBJRj7XNTZqVDd59zxFmUgFbW1ucPX2Ola0mo6OjiILIwpXLlMtbN8R5xxDekXTchVdZK29h5PtQQ5tDE1kuLlXY1WdyYHIXnUDnrne8C1tPU/V1gtoKm5dfpeaHeL5PEAScPnOWWLoPwe/x13/5WY7edAuHJkfY2qqyf8TkfFvm5ZdeZKPaQhFF3CBidGD7ZqiOGzCya4ykLtMJRRZX15k6/HbuPDRILJXjgbffzq3jaezkEAOFHG3LRvRtCqO7ee7ppwDI5gtcuTYHRgotFufMs19n31iBtBJycP80nmRwYKzAC19/hHSuwEhGZ/eBIywvraCoCpVKmc1yhWbXZnNtjZrl8+RjX+bBn3of66vLNEOV/SUDJ5JZvnKeKxfPY3ebpPIF+sZnbojzjiG8JPnIQ7vZN1YksLo4vkNCjEhncnjVDSQUVmZfwVqdJT80yeJmC7K7aLsBA8U+LNvmyH3vJYhlEVQdNxTZ8gIq9QZXry4hej3yA+McHcsQBgHFbBIvhKSpoMW2kxd6ls3ZcxfYOz5MfzaN3a7RWjxNfved3HRgD4u2SZQc4My3H+XK2Vcwk2kKIxPUymXi8e0+5q9dZWRkiMBq4bk2RmmKmaJOti/HqdklauUVKpUqS5ZOrVqh6iqsLq8QTySQRIGiKSOIEjkdAiJM08BIJmlsVSkUhtg3OUYpm+Bd77yP9a0GM3v3IkcBpqoSOt0b4rxjCEeNcfn4k7y8ZEG6iNzZYG2ryalzV2mhkCrluLDm4Wsxsl6d+27bh+Z1iUU+jVoNURSoXXsRvB7nry4zNjaO4ju88tTX8d0O2f4hvvzMBYx4EmFznlqziVvdRBTF1x2ubrfLcH8f52ev0e22yaayvOfH7ufZp/+etXqHb3zzCa4ul7n/lv0UBnexODeLYHfIqOHrxQyR75HO9zO3ssHw2BQvPvttnPRulpfXKQ6Os+rovP3wbm49uoe4rhKPaUiKApIMYUDVBVXTwUhhd7tYjkdak7l86SwXXngau93k1U3wm5tMD+ZZWJjHFRQatTJbtcYNYd4xhJf6SwwP9CFKClIEvXabPlNh6PCtrLR1IrOfB/elKaZlNps9qlEGP1FkqdbCatToS8bIjx0gli4QuRYnX3iRpmWz75Z72H/Xu3BqK9x/7024XsQtd91BPJEiNzyKpGh40XY+98jIMPunxxnsL1EoDnLt0lm+/OJlfvr+e7n0wlPcd+wwE3GXVG6QZrtNsa+f9a7PUrWFmbx+Fh04bFWrDAwMcPryHEePHKN26QRTx+4lo4VMJgPOz62iEmLZDroYkoinWF+4hixLKLpJs9tjeWWFTCZBIury5a99k3fccw99xRx6c4mjYznSpk6oxekfHqfX7aCnCuRy+RvivGMIn+0odF2JveMDtCsrOI5NV9FItraYzITU58+jTexj/vIcPdsmYy3w6ulT3DIzSDybRxRFqmvLuK0y+8b6EXWTyVKCra11KtcuYIsiGT0kHk+wEcRwOk2uzF1jdLCEam5nvJx45ls8/vTLWLZNtWPx/p+4n5Ro8cLZK7zvg/+ERrXB9NgYX376BLOvPke92cBrV7Cqa7hbiwDIepxCXwHZqhHTVURCVFVj6fTf862XzrFZ3iSdL5KePEzke9iuj+d2iangoeD3utCtcc+dd7C+WWPLEbjz2AHcUGZy32G2Wg7VMMbpa0sMDAzjWS0SiTjVcpn+G9xOBTuI8JhdJVXIYvgtRsdGOXjzbcxdPU9YyNPpWMxuzBFXcxwezLFe72DVyxRKA8jJPhw/ot618YTt2xcvzS1hxAyuLixjNbv07C6q3UUT4Qtf+iJ7p6coFEvksnnOzC5AaxOAj/7SP2Xfrn6eOf4MQuDxyqVF5s9fxLKavPzUN6k5QGGUfeMDaNkRuu02khbnyC13kB/eDcDU1CRBdR4rUhhIKAxk4zz61Ms0xRz3lXqslJt0fdi49Cpeq0ZxeBeBrDO2/xi+Y6PpOsl0nhdPnefYsSPgu4SixBef+HtOnr/GmbUmA8UkPVdgYvduVpeXaFUr7N49xeLGD1GKU21jkXq7y9xqlZNnrtKTkuDKLF0+R0836CwucHL2Mo/PtoncNk05TyJssbywhi4GSLLGlfklJELSA2O4vS4/9b730/ECXriySUvOcXl+ma3NDRoetJau4gYRSVNjs7q99l25Nofl2Lz9J96HmshS3lhFUUVUzcByI7pbS8ydeQlBVNi/e4J73v0gxUKeSNQIlG3tOnX2Io6UIp1O4mtJ1usWsbCOZ+Q40S4xkVV58eQr+K6Nlyhy8cwpGrXGdjKkphAisLi0yMzBw3TKK3QcH1WPsXt8hHQ2za7xMZaXlnGCgFQqwfjEBHqmSKvTodNuvRnEwA6KpZ9ZsXDrG2QyCTw1RkntoRdHUHwJUxMYLpVo1OtM9iUQgx57do9jqiqVegtF0yAKmBwbIfB8NlYWyGVSFHYfQZA1SrILYkStUuf++9/JuRePM37kNlrrqxy5+RjVeoN9+w9y/OuPsVZpkM/n2NxYwwsipGQBzXVQ4yZGIsNGtc74He+mcvElet0WG+trNC2Ha5cvceddd7OxMk9za4PnTp5D1XVuuukw2eIujLCJ0mshZgY5MDPJaqXOlUsXyaTT7N67F03dTnmOwu1rPrqNGkEEgiiSSsZoNZqIkkypWCRul5FLe7h8/izJTIr1+Su0Wi30eIpDh4/Am8TSd8yVH5//7KfwAkBRsHsOauQi6kl00Wdjq0I6nkI1dNxQwNA17HYDQ9dpdWxUw0CQFFRFwndtQt8nFCQMVcXyfJKGSqdn4zk2sqIRERJFAp4fkIibSFHA+z/4c3z2sw+haSqB520X50cRYRAgEuJ5HqphYlkWuioTIiJKElIUomgGrXabX/jFX+Izn/4LRAECzyaTztLqbeeKG6qC49ggiISApqrXq04EgjAgoavYQUTkB0QCJHQZyw1xXRdF05EDl1BWIfSxbBdDldHMBLV6DV038F0bVdP58M99FN7kyo8dY9IjT6Q0tAtJT4Jnk5y5i3gmR9OFQM1QtWzKa2tsri4TiCpKup+eGKNQyG7nZgcBtcoWTijj+SF4Lno8cf2WYomEblBMm0RBcP2yXp/+/n4cL0SItklRVA1DltD0GIHroGsao+OTeCEkEklyqkcqkSBERlMkQtdFxadSKVO4XmoUU7erPrV4htW1dTzPR2S70EI24lheSD6bBQTazSaSEJFIpGh0LALfR5JFVFWj6wvYnRZmPIEiRMRzBWzbptRXIJtOEjNjVLcqiEA+l0H1LRRVuyHOO4bw4vRuNKeDKqokBycJNi7S7Lq0qhsMZ2M02wGbQYrR4QILa1XGx4cQBHjp7HkCzyEe04lkBS8IMZMJpkb6abcbNLY2WNqocPbqPOcvz5HQYKAvy0B/iUqrx0QpTaO+vfYpRpx8Sicp2OiSj6qKrK1cY315nvbGFSr1DlcunScTU5i7cpl0/zC9UMDpNLBr2+HZbDpFY3MNt9dlaNcYvWaVUi7BZrlMq7bF4pVLPHfiBOW1Je48NE2mUGLP+AiSqiMJYJox1leWaNcqJJMmu4aKDO0a4Yt//RD1Wp1Xnz3O337hEdaWrtGoVpiYGGN+cQUt209G/iGqHt1cusrppQqa0MWqV2hLKVYaDqnMAHZ7k77BAhkjYKXcIrIaPH3yPD10xqaP0LJcmuV1JkeHaGysIIoSHckgJgbcdnCGzvJF7hxSOHL4CM1mkyurVSrNLkenB1moWrTDbYdra32Vs5fnkWJJQiKuXlvk2W98len9h5D1FIYi4tVX+farsxw7tJ9zLz9L4PQYG59ETG3ntHmRxL6jR8FzqZbXmZjew5Nff5JbjhygpLvcNplgfXWNsFflyROnQJTZajYwdRXbC+h2u/QldbIJk2deOM3cwjJXZy/zgfe8jRHDoi8b46MP/hinTp7k9rvvobo4hywEhI11XC1zQ5x3DuHVNrValZdPnWZ9o8bW/CzT4jIp3cfPTaG5IcVgFS8zxuTUDLeUDAZNgcWzL5A2VCTN4PLsVd79wE/iui619RWunjvLpx99mj2Hb2exFZEUbGabEkUjRMHn6ePPk00YKNeLCOobK2hmHE9UCKwOR44cYnjmCBnRpZSJUQ9NxjNZNK9L2wkwEmni6SwWKqfPnAegtbWOohkURydIxxS+/djDTE9NsLRZxe75NMly380HePHcEmNjY9QWztFtVAkCn2QyCUQIRor+0Sl+9mceIK+LLJ4/jZQZYv+t93Lw4CGcZpVY3xB/+rF/R71j4fsh/RMzxHXlhjjvGML7EjH2TE4wWOinf2CEXrfNQDKPoms0Lr+CKjVJp4qUaGFVVmm2LRK5Anunp+hZNl4QISoGphSyf89ekskYz81X+IUH7qYXBuy6+R30DQzytpk+5hdXUeWQ4fHdVBodUto2DNWOgygpLF25yPD0AZ746uPk3DLza1UuL27QXZ0jP1ggpUGpr4+m5bOyUWNY3OKOu+7c7mOriijKdMuruILO6laT/fv301u9SqFQpNuoMzo2jCJCr9Wga3s0LZ+EoeD0LEBA8No0ystUa1UWyjViqSRCY5nLs1f40pPHiaSQd952kFvvvZ/ITNJtVllbXefq/PINcd4xhA+lQ+Y3G7xtKo3pzpOTHKRSP2FmnNum0tQbDQRFoLW5QFzoUOl0eeH5F2jKeaLIxzAMuo7D+TNnWV+6QqPe4CcODPDEt16AIMSfP8FTr5zl8oXLtGo19k5NsXjhJFanTWht78NH+1OMZHTMRBqn0+CD730X7Z7DSqVOJpdhaqyflXbIxK5d7B7K8sC738nuXf1ca0nMHv8KAP1Dw8iyzMLqGudeeZHUwCRr5S3a3R5yug/HD3AjlffcdzNCLMO+297G+twsna6Foml4jk0u30+yMEiuOIgeTyOLEnPrNa6eO8uBwRxr7YjK6hpOZZmBvhyTM3to17cYHRu7Ic47hvDjVztEvs3jr8xyxR+ka9VYdDQyjUWeveIxnZ8kUDOM9MUIkgNkDZ2+4RJJewE38NHEiIzssNbscm2tTs0WaPVCxgsGzQvPkx2eYXJynGxW58H338+TX3uSm++4m6nJCRLSdqaIqKfpOB71aoWtjs/pUyfpnznKkUGTpN8m7NQZzCTpoPLQo9/iwtnTGJqM3ayR2bUHgLYb8K2nn2F6apL3f+QXyMV1Fi6+yr133s7zz3yTo7fcTrtW49rCOrVajZhgc+fb3kY6lUGMQjRdZ21tjUvnz3Lx1Mvsmx7H0CXuOrQbQRbpBRHve9edxJMat/7YA9TaPQaGx9BiCYL2D9F5+NTkXg5OFNk7NkA6mSAT0/n4f/4EVvk0o+N9OCmT1YVlHG2EwWKettpHZX2VWLpEOpuj1umR7BshIQaM5OPkYgp9e49hJgukxvfz+Of+ghNfe5Shsb1YYYKR8Ulefu5pLNuix/Z2ZvdoiUagkkklEEOP+9/zXk6fv0RLzXHx9GlCI4XtODzxlUc4vG83xZTGwuIiTgCd6/fEGCJMjO1CNJJcuHCBmCrQcFWWVpZ4502HOXfyRYpZjQc/9LMcmyxhdbucuzjLZr1Nz3ERQp9UoY++kQkm9h/BbddY6wicWdxk36FjlDeW+Nj/+N9Tr3ZoNprs6s9x/uTzmIZOu/lDVFvmbJ4m9G0a9Q7KxhkyI9P82kd/iuLMPUhujMrSJYZzaTbXVnnl/Bn88gIJ3eDFOYuNzSqGGBDaLfoKfXidBptWyJVL51nswvzVq7ztA7+ImN3FiZdO8vAjXyOMAtr1Mqau0z88AkC91aWvNMCFuTX8IOD0q6fIxgx8q8H+2+6mXCkTl0QmD9+BLyr0QpUDR25ies8Muwb7ATh15jy9dpuxlIrfrpEYHGN1bYXiyG56WppiocTxF87wh7/7W6xsbDC/WqbVqFLKZ5ElCVQDy/ZZXlzEd3qcvLLB0X0T1Oodrjz/JP3jMxx818/x2Nf/HjV0qTU6jEwfpFZvULO8G+K8YwjvdR3qjSbdRI65LYu1lkCzssZjL15mdm2etNSmo6pMTpYYiRs4SoqpoTx3TyqksxkENUanUaOrpjHSBXJxjX3TU+wuJJgcTnHpxaepLl/l/2rvzJrjOtMC/Jw+ve97t3pVd6utlmXJlu0QZxJmEpx1QlIMDJPUUHMBxUBRRUFRXHDFHb+APwAUQxUXcJFJhoTEiZ3EsRJLiqVI1q7W0otave97n+ZCU1xi4AKU6X5+wan3qfOd73u/97xv/mibKxEfMknij//0L0gd7pOtnZ9fC+UKx5tf8535KFoZZBtDtGKPRHyXg0yZXLGMymHCIGtTLuRQDKqUy2UyexucpM4vYH7jhV/HYtJzVu8zu3CTSjZDrlRjc+0B+UoFcdCk1IEfvvU23+ydEvRNsHDtKp9+8QCZKEchV9Bp1lBKHVo9CYUcqh3IJvbwT8eo1VuUKmVu3XqOs0qd/b1dkntbvPjqK/BtatsV8cWodHXoLBO8+fqr+Ox63FNzhGxqWtIAlWMGyRwgwwR6txezWcde144nOA1DiXazhs0xQT25RVXQsXz3F+SKZZyBIP7wLD6vj1gkwO23f4rUqdHutLnz/rtU2j1211cBaNZqmC1Wyp0h1f4QhSjhnZzCGb7Cd2/ECAYi7OwnmZqewWx10hrqOT3a5eaN6xhtTgD2jtMMVXrS2QwPHy6hErr8/k9+THTmCkIjS18mw2MzMRAUhNxmmo06S6ubzEZDCDKBcqnAUFTQqRc5TqTwu6y0Wm1+5w/+DKvVhdw5icdlR5Ir0Gk1BBwmVHoj22uPqGXTT4zzhcml/38/wK8YF7999gfv3aHU6pFrVck3tSyEFIi5OPttJ5n4KTdvekgd7mGP3OTgrMK8sYqoM1EWLPRyCawmLaJSQ69eAqlHWxIR21VEpZxwbI7d7ce4J6dZ+moJQRjiVg1Q6C20ZBq0CoG3f+8n/PPP/p5CJslEIMTR/h7Rmcvkax0uT3o4SmUwaNQMkTEUYHN7j8mAF5lCRWsox6zo8cZv/S4/+4e/o17MYPWEYNBHqdWTTp5wdX6O9a9X6IsKXG4P3cIhBp2FfLmMYJqgmD3F7XIjDPvIFCpyhRJT4SA9QUn+ZI9AMEBXUPDl3Y+w2e3YPGEUUov+UCDocdPotNne2ubP//Kv/ss4X5glvdXrsLK5jurgK9zGNumCnLwqgJi6j8ks8cF778JwiL56iKayhqi3MOh1MHTLyAclquUCw24LqdPAHZxCpdPiCkaIp3K8+87PaeRT3L93B23tCL1Ojz8cJZk+Zdpj/c//qodSl+jsNUxWO+2hiNHhxUKVxNoie1ub1AqnHB9sIurMiFKLmdlZ9na2EPsddjfWAbDoVTgmfDRqFVxWI2KnjN2oJ34QR2fQY7E5SMa3sU8E6YtKjL4pjFKVSCSCQjofx3H58gyXIiEyiSMeffERQ0HGvfff4+HHH1Gt1s6rW/dXcfomiQQmKGZTCIMedvu3qMRp2Gwy0cvjvHEbj0WNrrRMdm+ZlsqDzurg9e+/QEc+QcPiY2FmAZ/DgkGpo57OoO8PUYgC6UKVrqhBZbbj1Mn57ON/Z2pqiheevYbDE0XVb2INX+X2y6/gnHDTbA+oouXll54HoNIcIHRrqEV45XtP84t/+ScElR61zYPHbkHWq+L1BsgfbzM9FWF5dYMXb11l9dHXOJ3n3/B0sc7J5jqhoJ9csYTZ6aXRatGr5OhLQ9rtDgoRNtZWUcoGdHJJRJMbl92CoDIwGAw4PdihnU9yKRrhB698D7lMIOo143QYeOXFFwnqh1SqdTZXvqRaa/DNVhypUcYf+RaVKbfSO5jCs2zdfZ96XSDXd3Ez6kZhtDFBnk42z/O3wpw8XkPp8LK+vMShZEDvsOOY9CFKPfQGHdDn3t17VCo1/H4vqdMsq0urXL9xlXBsDrPZwOOv7iKYvYSvLmC0mll8uAaARqUiWe6Qz+dpSkpuP3uTjz76mHqtQL+QoiPpUQyq0BuiM5qQdWv0tDZiMzGK1SYA/WYDdziKqFDS7A5YX1pErRAIBn24HTYGrQY+g4haqcQZjKK0ONGrRA73dxkKoFOrELV6yp0+u/txjs6qVGt1nO4ABqWMzOp9POFZrkxHaA2GZDJn3HjqOl2lgb3HT57pdmGE3/zRjxiqtNjmnkLjspM5ekgyPcCnGRC+PEtHkFN4vIhaCWcr97EpZMybGshsbmS9Ic0eRB06ZqZj3LjkZ6Ay0hmKXIkEePWHP+bseI/jh3fJVdsc7u/SLBdo5lKsr3xFZOo8JXmUTDMZnaHZ6rK5ukyh0UXU6JmKzaEOzTMf9VEulenUsrhdTjK5MuZOjnajzpWZKQAsdisqrZajgziCKNIWtRydlhBKKfTdPP6Al4akxGvRkUycoFWKpJMpzCbjuQxRgcdhRa018tSNG6jVajbWVik0O5i8URZu3eKLz+/Rrlbx2XR4rTpMJhPtZgu/1/fEOF8Y4etrcRR9gQmViLar5YUb10Gvwe6dwqwQeW42RMs+y9SlOSaCXk7NIbIHW+xuLNGu5VDpDMhEgZOjQzY2HtNMbSKTyalXCxztH9Jsdgg8+30M1NHYvKwsL/Pm669Bv8/h4XnFacBpQVPeJ3t2RjQcIhSbY8LpoFKqcP1KiKNSlcPDI9z+AINem6cXYtQlGVadQObsfB9QKZdQaoy0egNqZymOt7/h9du/xklXh9NugloeSakjUR8ylClRVFPY3W78oQidXp9Bv8832/tEYzFWlh+iUavxuc0UyjXquWPKfYmhQkdNlHP/3ue0dC4K+QKS1EejevJt2YXZpQt6Ew5alI+POOnoURRTaGRdTloZjgt5sqYoQWWOU02YtfgJVy5Zyalj6LrH1OR6jKKCbquFxeWj02jQVZmxlPdxOoPsb+0gDSW8kWk6HYGF+RmSmQKri/cIhqMUs+edE3ItiYCk4JnXfsDOyiK7dz9heu46pU6f008/RGF2oteqUCNR7oicpRN0hyLB6ByVX0471Jus6FUiskGHK7EozXqVfK5CrdVm6ziPyuxEUU2ikw8x2WwUEmVaZxkOj09wOl0M+n3kwpC7H3+C02Zi5+CQTK7CM7duYVPKSOyt8tu3n2c7fsgLf/03bC9+QqEnotcoUf83Zp5cmDf84Ou7xM9qHA98iIlNyqUOjVwbc+A6RpMLm3IAKAhZRcJWIyc1AZ00oK3yUq1WqbZ7TE56UWk1RGZmEKU2n8ZbJNJnuD1uwrEZTvb3WF15wMf3VwiHgqSKbfLpI4z680BNeWzs7MQ53VzG73URvRQlmc4g9XvYfDH8kTmCgSmSxTqfffY5qWwNo9UNgozKL6tmasVTEicJZEYXS493QW/jw8VlJm1Ktg8SpPb3MLgniczdZGN5CY11gtjsHBq9kWLuFK1Oi8OmR6eUyBcrzF+OoTG7SO8sky7VuLeVY39nk92jDKXsKeWeQNAgUCuXqJQLT4zzhRF+3WfHpWgg6+a5teAn4g3ivjRDLrGF0uPn9suvYdCo+fknu+DUYFEM6A9SDOsZ9AoNILC8nWL50w/ZWV/D5/Xx1m9+l3b+GFGrI1VqkcmdoZiYY3bSRuFwE8+EA5/Pz+qjrwFIpjLM33wKmSjSqNWxONwE/R4qlRrx4wTHiQQao5ZcsUgoFMQfjaHWaInH9xGG5x2UVBojaosDoZFjwuOjkUsRtJmRiUr+5I/+EIvNwoNH22w++pIr83OcbT0k5DTi8oewWm10220MWjPVRo/nnl5AQsaz1yKYnAHyhSpvvPwcG4kKuxublIolDo6S533iVGpSe1tPjPOFEd6qlzltCMjUNqpDLV2HB5XBgooh6abEv/7j37LRNvLm7Xm6kpK6KcTVUASHQURlNiKKIqgMyLptdHo9euWAB1+uoLFNYrLYUTULGJQyJv0eZForA5kKXyCAzaji8vxVACYjET678wGNbp/VpUXKjQ6HyQwGjYpILIZNp+AsXyEYuUQxvotF7KHRauk16yh15x2U5GYPhmETmVxOMZ8lfClGqdlCYfbwzr/dQWaw0TlYRG9xkstmMTm9fPLZIoX0CdVGG9lwwGk6ScDvZ++0SrdeJpXOUSuUaXW6xHNNfNNzfOfGNWT9FvOXo8xcXcDvdZGuDZ4Y5wsjvNYVebge59lJiQfHDS7JK7QycZKHe/h8bl5666f4tEPurTymlKthKO+Q3F5n2qIhkcwha9d4eOcd2qKaQqHAF8sb6HsldpNZWp0Bk+EoeosNucbA9qMl0vUBzVqFk7MSqeQJAKe5ElqjlcTxMRG/C5/Pz6TLSLvXpd9tYra7SZye0axWkDt9oNQS31rnWixMMZsBwKtqkWsO0Gq0DKQBfZURk8VOu5jC6fXQbDR55qU3aA8EmsUckZk5LE4HQ5mc86bNWr588Dm1eo3DjRVy5SqiIGEMxvD7JjC2Czz+6h5lQeQklWFtfZPc0S5qvQWf88k1beNc+q8mFz6X/j+dez7mf8mFWdLH/N8wFj5ijIWPGGPhI8ZY+IgxFj5ijIWPGGPhI8ZY+IgxFj5ijIWPGGPhI8ZY+IgxFj5ijIWPGGPhI8ZY+IgxFj5ijIWPGGPhI8ZY+IgxFj5ijIWPGP8BNsiAZON/ZTgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 83.7835x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 83.7835x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 17.3505x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "save_fig=False\n",
    "\n",
    "model_name_list = Exp['model_name']\n",
    "std_list = Exp['std_list']\n",
    "all_reco = Exp['reco']\n",
    "noisy_input = Exp['noisy_input']\n",
    "\n",
    "total_patch_nb = len(std_list)*len(model_name_list)\n",
    "to_plot_reorganized = torch.zeros(total_patch_nb,3,120,171).cuda()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "grid_param = grid_param = {'padding':8, 'normalize':True, \n",
    "                            'pad_value':1, \n",
    "                            'nrow':len(model_name_list)}\n",
    "\n",
    "\n",
    "### Plotting Layer 1 reconstruction\n",
    "for i in std_list:\n",
    "    to_plot_reorganized[i*len(model_name_list):(i+1)*len(model_name_list),:,:,:] = all_reco[i,:,0,:,:,:]\n",
    "    \n",
    "img2 = make_grid(to_plot_reorganized,**grid_param)\n",
    "\n",
    "fig = plt.figure()\n",
    "height = img2.size(-2)\n",
    "width = img2.size(-1)\n",
    "\n",
    "fig.set_size_inches(width/height, 1, forward=False)\n",
    "ax = plt.Axes(fig, [0., 0., 1., 1.])\n",
    "ax.set_axis_off()\n",
    "fig.add_axes(ax)\n",
    "plot_L2 = show_ax(img2.cpu(),ax)\n",
    "if save_fig :\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/FigS6/FigS6a_layer1.png', dpi= height)\n",
    "plt.show()\n",
    "\n",
    "\n",
    "    \n",
    "### Plotting Layer 2 reconstruction    \n",
    "to_plot_reorganized = torch.zeros(total_patch_nb,3,120,171).cuda()\n",
    "for i in std_list:\n",
    "    to_plot_reorganized[i*len(model_name_list):(i+1)*len(model_name_list),:,:,:] = all_reco[i,:,1,:,:,:]\n",
    "    \n",
    "img2 = make_grid(to_plot_reorganized,**grid_param)\n",
    "\n",
    "fig = plt.figure()\n",
    "height = img2.size(-2)\n",
    "width = img2.size(-1)\n",
    "\n",
    "fig.set_size_inches(width/height, 1, forward=False)\n",
    "ax = plt.Axes(fig, [0., 0., 1., 1.])\n",
    "ax.set_axis_off()\n",
    "fig.add_axes(ax)\n",
    "plot_L2 = show_ax(img2.cpu(),ax)\n",
    "if save_fig :\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/FigS6/FigS6a_layer2.png', dpi= height)\n",
    "plt.show()\n",
    "\n",
    "    \n",
    "### Plotting the input\n",
    "grid_param = grid_param = {'padding':8, 'normalize':True, \n",
    "                            'pad_value':1, \n",
    "                            'nrow':1, 'scale_each':True}\n",
    "\n",
    "img2 = make_grid(noisy_input,**grid_param)\n",
    "fig = plt.figure()\n",
    "height = img2.size(-2)\n",
    "width = img2.size(-1)\n",
    "\n",
    "fig.set_size_inches(width/height, 1, forward=False)\n",
    "ax = plt.Axes(fig, [0., 0., 1., 1.])\n",
    "ax.set_axis_off()\n",
    "fig.add_axes(ax)\n",
    "plot_L2 = show_ax(img2.cpu(),ax)\n",
    "if save_fig :\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/FigS6/FigS6a_input.png', dpi= height)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fig S6b and c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "save_fig = False\n",
    "color=['slategrey',cmap1(3),cmap1(2),cmap1(1),cmap1(0)]\n",
    "std_list = Exp['std_list']\n",
    "\n",
    "\n",
    "std_ssim = (Exp['ssim'] - Exp['ssim'].median(dim=0)[0].unsqueeze(0)).abs()\n",
    "std_ssim = std_ssim.mean(dim=0)\n",
    "\n",
    "\n",
    "std_ssim_baseline = (Exp['ssim_baseline'] - Exp['ssim_baseline'].median(dim=0)[0].unsqueeze(0)).abs()\n",
    "std_ssim_baseline = std_ssim_baseline.mean(dim=0)\n",
    "\n",
    "fig = plt.figure()\n",
    "for idx_b, b in enumerate(b_list):\n",
    "    std_0 = std_ssim[:,idx_b,0]\n",
    "    plt.plot(std_list ,std_0.numpy(),label='b={0}'.format(b),color=color[idx_b])\n",
    "plt.plot(std_list,std_ssim_baseline.numpy(), color='black')\n",
    "\n",
    "plt.ylabel('SSIM error ' + r'($10^{-3}$)' , fontsize=15, labelpad=10)\n",
    "\n",
    "plt.xlabel('noise std ' + r'$(\\sigma)$', fontsize=15, labelpad=10)\n",
    "plt.xticks(std_list, fontsize=15)\n",
    "plt.yticks([0,0.005,0.01,0.015,0.02], \\\n",
    "           [r'$0$',r'$5$',r'$10$',r'$15$',r'$20$'], fontsize=15)\n",
    "\n",
    "if save_fig == True:\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/FigS6/FigS6d.png',\\\n",
    "                bbox_inches = 'tight', pad_inches = 0.02, dpi= 400)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "fig = plt.figure()\n",
    "for idx_b, b in enumerate(b_list):\n",
    "    std_0 = std_ssim[:,idx_b,1]\n",
    "    plt.plot(std_list ,std_0.numpy(),label='b={0}'.format(b),color=color[idx_b])\n",
    "plt.plot(std_list,std_ssim_baseline.numpy(), color='black')\n",
    "\n",
    "plt.ylabel('SSIM error ' + r'($10^{-3}$)' , fontsize=15, labelpad=10)\n",
    "\n",
    "plt.xlabel('noise std ' + r'$(\\sigma)$', fontsize=15, labelpad=10)\n",
    "plt.xticks(std_list, fontsize=15)\n",
    "plt.yticks([0,0.005,0.01,0.015,0.02], \\\n",
    "           [r'$0$',r'$5$',r'$10$',r'$15$',r'$20$'], fontsize=15)\n",
    "\n",
    "if save_fig == True:\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/FigS6/FigS6e.png',\\\n",
    "                bbox_inches = 'tight', pad_inches = 0.02, dpi= 400)\n",
    "\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fig13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "warning: Not all batches have the same size, the last one will be dropped...\n"
     ]
    }
   ],
   "source": [
    "data_path ='../DataSet/CF_DB_testing/'\n",
    "\n",
    "LCN_params = {'kernel_size':11,\n",
    "'sigma':0.5,\n",
    "'rgb':True}\n",
    "\n",
    "mask_params={'n': 10}# default is 10\n",
    "\n",
    "whitening_params={'f_0':0.5,\n",
    "'n':2}\n",
    "\n",
    "Data_load_param = {'batch_size': 40,\n",
    "'do_LCN': True,\n",
    "'LCN_params': LCN_params,\n",
    "'do_mask': True,\n",
    "'mask_params': mask_params,\n",
    "'do_whitening': True,\n",
    "'whitening_params': whitening_params,\n",
    "'do_z_score': True,\n",
    "'return_idx': False}\n",
    "\n",
    "Facedata = DataBase('from_ImageFolder', data_path, img_size=(100,124), reshaped_size=(120,171),**Data_load_param, shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inference for different value of lbda1 and different noise level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "Exp [0.0,1.6]\n",
      "52\n",
      "50\n",
      "51\n",
      "52\n",
      "51\n",
      "53\n",
      "50\n",
      "48\n",
      "49\n",
      "51\n",
      "14\n",
      "14\n",
      "14\n",
      "14\n",
      "14\n",
      "14\n",
      "15\n",
      "15\n",
      "14\n",
      "14\n",
      "17\n",
      "17\n",
      "16\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "Exp [1.5,1.6]\n",
      "43\n",
      "42\n",
      "42\n",
      "42\n",
      "41\n",
      "44\n",
      "42\n",
      "40\n",
      "41\n",
      "43\n",
      "10\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "15\n",
      "15\n",
      "15\n",
      "15\n",
      "15\n",
      "15\n",
      "15\n",
      "15\n",
      "15\n",
      "15\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "CFD_[0.3,1.6]_b=1.pkl\n",
      "Exp [3.0,1.6]\n",
      "40\n",
      "40\n",
      "39\n",
      "40\n",
      "39\n",
      "41\n",
      "39\n",
      "38\n",
      "38\n",
      "40\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "11\n",
      "14\n",
      "15\n",
      "15\n",
      "15\n",
      "14\n",
      "14\n",
      "15\n",
      "15\n",
      "15\n",
      "14\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "model_name = 'CFD_[0.3,1.6]_b=1.pkl'\n",
    "where = 'Savings/CFD/'\n",
    "\n",
    "feedback_list = [4]\n",
    "\n",
    "lbda1_list = [0.0,1.5,3.0]\n",
    "std_list = [0,1,2,3,4,5]\n",
    "all_reco = torch.zeros(len(std_list),len(feedback_list),2,3,120,171)\n",
    "noisy_input = torch.zeros(len(std_list),3,120,171)\n",
    "nb_image = 40\n",
    "nb_batch = 10\n",
    "all_ssim = torch.zeros(nb_batch,len(std_list),len(lbda1_list),2)\n",
    "\n",
    "            \n",
    "ssim_baseline = torch.zeros(nb_batch,len(std_list))\n",
    "\n",
    "for idx_k, k_FB in enumerate(feedback_list):\n",
    "    for lbda1_idx, lbda1 in enumerate(lbda1_list) : \n",
    "        model_type = model_name[0:8]\n",
    "        name = model_name\n",
    "        print(name)\n",
    "\n",
    "        path = where + name\n",
    "        with open(path, 'rb') as file:\n",
    "            out = pickle.load(file)\n",
    "        Net = out['Net']\n",
    "\n",
    "        for i in range(Net.nb_layers):\n",
    "            Net.layers[i].b = k_FB\n",
    "        Loss = ML_Lasso(Net, [lbda1,1.6])\n",
    "        print('Exp [{0},1.6]'.format(lbda1))\n",
    "\n",
    "        Pursuit = ML_FISTA(Net, Loss, max_iter=1000, th=5e-3, mode='eigen', accell=True)\n",
    "        for noise_idx, std in enumerate(std_list):\n",
    "            k=0\n",
    "            for idx_batch, data in enumerate(Facedata.data):\n",
    "\n",
    "                image_ori = data[0].cuda()\n",
    "                batch = data[0].cuda() + std*torch.randn(data[0].size()).cuda()\n",
    "\n",
    "                gamma, it, Loss_G, delta = Pursuit.coding(batch)\n",
    "                print(it)\n",
    "                rec = reconstruction(Net,gamma)\n",
    "\n",
    "                normalizer = image_ori.view(data[0].size(0),-1).max(dim=1)[0]\n",
    "                normalized_image = image_ori.div(normalizer.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1))\n",
    "\n",
    "\n",
    "                normalizer_noisy = batch.view(data[0].size(0),-1).max(dim=1)[0]\n",
    "                normalized_noisy = batch.div(normalizer_noisy.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1))\n",
    "\n",
    "                ssim_baseline[idx_batch,noise_idx] = ssim(normalized_image,normalized_noisy)\n",
    "\n",
    "                for i in range(Net.nb_layers):\n",
    "                    normalizer = rec[i].view(data[0].size(0),-1).max(dim=1)[0]\n",
    "                    normalized_reco = rec[i].div(normalizer.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1))\n",
    "                    all_ssim[idx_batch,noise_idx,lbda1_idx,i] = ssim(normalized_image,normalized_reco)                \n",
    "                    all_reco[noise_idx,idx_k,i, :,:,:]=normalized_reco[9,:,:,:]\n",
    "                noisy_input[noise_idx, :,:,:]=batch[9,:,:,:]\n",
    "\n",
    "                k+=batch.size(0)\n",
    "                if idx_batch >= nb_batch-1:\n",
    "                    break\n",
    "\n",
    "Exp = {'model_name': feedback_list,\n",
    "       'std_list':std_list,\n",
    "        'ssim' : all_ssim,\n",
    "        'reco':all_reco,\n",
    "        'noisy_input':noisy_input,\n",
    "        'ssim_baseline':ssim_baseline}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1.0000, 0.1257, 0.0502, 0.0270, 0.0172, 0.0122])\n",
      "torch.Size([6, 3])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([6, 3])\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbIAAAEdCAYAAABpOeInAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4HOW59/HvvVr13lwk2bLljsFGxhQ3esCATRJwKIEAJ5RQTgjECYQETggcQiBvHAeI6QHCMSWUAKbGQByKweAO7pbcJLmpWL1sed4/ZrQqyFiStdpZ6f5cl67Vzs7M3iuMfnrKPCPGGJRSSqlw5Qp1AUoppdTh0CBTSikV1jTIlFJKhTUNMqWUUmFNg0wppVRY0yBTSikV1jTIlFJKhTUNMqWUUmFNg0wppVRYc4e6gL5MRGYDsxMTE68ePXp0qMtRSqmwsmLFilJjTOah9hNdoir4Jk+ebJYvXx7qMpRSKqyIyApjzORD7addi0oppcKaBplSSqmwpkGmlFIqrGmQKaWUCmsaZEoppcKaBplSSqmwpkGmlFIqrGmQKaWUCmsaZEoppcKaLlHlYHsWnx/qEtRhGvSdVwLff/jU1BBWojpy6n8tDXz/pxsnhbCSvm/uAyuDdm5tkSmllAprGmRKKaXCmi4a3At00WCllOo6XTRYKaVUv6BBppRSKqxpkCmllAprGmRKKaXCmgaZUkqpsKZBppRSKqxpkCmllAprGmRKKaXCmgZZJ4nISBF5VETWiohPRJaEuiallFK6aHBXjAfOBj4HIkNci1JKKZu2yDpvkTFmiDHmB8C6UBejlFLKokHWScYYf6hrUEop9U0aZA63bNmyUJeglFKOpkHmYC+88AInnHAC//znP0NdilJKOZYGWZCIyDUislxElu/fv79b5zjvvPOYPHkyV111FUVFRT1coVJK9Q0aZEFijHnMGDPZGDM5MzOzW+eIioriueeeo7GxkR/96Ef4fL4erlIppcKfBpnDjRo1ioceeoglS5Zw//33h7ocpZRyHA2yMHD55Zdz0UUXcccdd+jkD6WUakeDrJNEJE5E5ojIHCAbyGx+LiJxBzlmtog8VllZebjvzcMPP0xOTg4//OEPqaqqOqzzKaVUX6JB1nkDgJfsrxOAI1o9H9DRAcaYRcaYa5KTkw/7zVNSUli4cCHbt2/nv//7vw/7fEop1VdokHWSMWa7MUYO8rW9N2qYNm0av/3tb3n22WdZuHBhb7ylUko5ngZZmPn1r3/N9OnTue666ygsLAx1OUopFXIaZGHG7XazcOFCXC4XP/zhD/F4PKEuSSmlQkqDLIh6arJHe0OHDuXxxx9n2bJl/O53v+vRcyulVLjRIAuinpzs0d4PfvADrrzySn7/+9+zZMmSHj+/UkqFCw2yMDZ//nxGjRrFpZdeSnl5eajLUUqpkNAgC2MJCQk8//zz7Nu3j6uvvhpjTKhLUkqpXqdBFuYmTZrEvffey6uvvsrjjz8e6nKUUqrXaZAFUbAme7R38803c8YZZ3DTTTexYcOGoL6XUko5jQZZEAVzskdrLpeLZ555hoSEBC6++GIaGhqC+n5KKeUkGmR9xKBBg3jqqadYs2YNt912W6jLUUqpXqNB5mBdnbxxzjnncOONNzJ//nzeeeedIFWllFLOIjrTLfgmT55sli9f3uXjmiq3UPnVn4lKm0B0+gSiUo/CFZX4rcc0NDRw3HHHsXfvXtauXcvAgQO7W7ZSSoWUiKwwxkw+1H7u3ihGdY8guBOG0rD3U+qLFwOCOzGP6PSjiEqbSFTKWCQiqs0xMTExvPDCCxxzzDFcccUVvPXWW7hc2vBWSvVd2iILIhGZDcweOXLk1Vu2bOn2eYzfh6dqK03la2ksW4OncjMYH7iiiEoZR1T6BKLTJuBOHIaIFVqPPPII1113HfPmzePmm2/uoU+klFK9p7MtMg2yLhKRh4FzgSxjjHTmmO52LR6M31tPU8V6msrX0lS+Fm/NTqu2yESi044iKm0CkWkTuOCSa3nrrbdYtmwZ+fn5Pfb+SinVGzTIgkRETgQ2AXtCFWTt+Ror7NaaFWz+Rmu5qsqmFE758SskJiWz/MtlJKYMCloNSinV0zobZI4ZPBGRK0TEdPB17SGOGykij4rIWhHxiciSg+x3hIh8ICJ1IlIiIneJSERX6zTGfGSM2dvV44IpIjqV2MEnkXLkT8mc8RgZU/5C4pgfMyBrJA/eMpktBTu57odTKFt2K9VbFtJY/hXGr7d/UUr1DU6c7HEqUN/q+aHuHjkeOBv4HIjsaAcRSQXeB9YD3wVGAH/CCvLbD7NeRxER3Ak5uBNyiB96DudN/CW/KLqeP85/nNNO3MJZkwup3f6qNb6WOo7otIlEpU/AnZAbGF9TSqlw4piuRRG5AngKSDTG1HThOJcxxm9//zKQYYw5ud0+twG3ALnGmCp72y3AncCgVttWAkM7eJv3jDGXtDuncUrX4qF4PB6mTZvGli1bWL1yGQMTqmgqW2ONr9UWAeCKTCIq7Sh74shEImIzQ1avUkpBP5p+3xxih3AWVhhVtdr2AnAfcBKwyD7XpJ6vMPQiIyN5/vnnOfroo7nsiqv58MMPicm0/m34GspoKv+KxvK1NJWtpWHvpwBExA22r1+bSFTqkbgi40P5EZRS6qCcGGQFIpIOFADzjDGP9sA5xwIftt5gjNkpInX2a4t64D0cbcSIESxYsIDLLruMe++9l9tvt3pUI2LSic06mdiskzHG4K3dZc2GLFtLw+7/UF/0HuAiMnkEUWkTrK+UMYirw15cpZTqdU4Kst3AHcAXQARwEfCIiMQZY/58mOdOBQ50sL3Cfq3TROQJYKb9fRHwrjHmqg72uwb4JZCSmemMbrpLL72Ud999lzvvvJPTTjuNKVOmtHldRIhMGEpkwlDih87C+D14KrcEWmu12/9J7bZXEFc0kalHEJ02odX4Wqd6WZVSqsc5ZoysIyLyInA6kNmZLsRvGSPzAL80xsxvt70I+Lsx5tc9V/U3hXqMrLXKykry8/MxxrB69Wq6sjK/31MbuH6tsXwNvtpiAFxRyYHWWnT6BCJiMoJVvlKqH+krY2QvAxcAwzj07MVvUwF09Bs71X7Nkeqrd7N761skpOYRnzqCuMQcxNXlKwbaSE5OZuHChcyYMYPrrruOhQsXdro15YqMJ2bAscQMOBawxtcay9fQVPYVTeVradjzMQARcVnW2pBpE4lKHa/jayFmjMH4vfj9HuvR52n73H40Puv7wHN7X+u5D9P8ms+L33gxPk+rc3it1332Y/Pxfo+9n7fte/m9RETGk5QxlsT0MSSmjyUuJReXy+m/kpQTOf1fjWn32F0bscbCAkRkCBBnv+ZINRVb2b7mabAbo66IKOJT8ohPzSMhbSQJqSNISB1BVGxal847ZcoU7rzzTu644w5mzpzJZZdd1q36ImLSics6lbisU63xtZqdgdVG6kuWULfrXazxtZGB1lpk8mgdX7N5m2qoPbCd2srtNNbub/WL3goOv69dqDSHSLsA8vs8GONtFSL28XaIGOML2mcQiUBcblwRkYi4kQg3LlckLlck4opAXJHWa/Y+EZFxuFxuxOWmqaGC3VvepmjDywC4IqJJSBtlh9tYEjPGEJes4aYOzeldiy8ApwEDD7Nr8Tas8apcY0y1ve0XwF20mn4fLIfTtejzNlB7YBs1FQXUVhRQU15ATUUBnoaWhmRkTGog1OLT7MeU4US4Yw5+Xp+PU089lZUrV7Jq1SpGjhzZrfoOxhpf2xxYbcRTuRXwIxExRKUeYXVFpk/EHT+kT4+vGWNoqi+j9sB26ip32I/bqT2wg6b60nZ7S8svfZf12Px98/bWr7lcbiSiJTSsx0hcEW5E3N84xuWKRCLan6MlZALndEW2Oner54Htreo7zGsPjd9HXdUuqss2Ul26iaqyjdSUbcbntS4ldbljSEwbZbXaMsaRmD6G+OTcw+6ZUOEh7JaoEpFXsCZ6rMWa7HEhcClwozHmQXufy4C/ASOMMTvsbXFYF0QDzAWSgN/az982xtTZF0SvB77GmnKfB8wD5htjgn5BdDDGyJrqy6mpKKSmYqsVcBUF1FYU4vc1WTuIi7jEHKv1ljqChLSRxKeOIDYxK/DLZ9euXUycOJGRI0fy6aefEhkZvJaSNb72dWApLV9dCQCuqJSW29SkTSAiJj1oNQST8ftoqN1jBdWBHdRWbg+El7epOrBfRGQc8cnDiEsZRnxyrv04jJjEwdrysFnhtpOq0o1Ul22iunQj1eWb8XutO59b4TbaDrexJGWMJS5paK+EmzEGT2MdjfU1NDbU0FhfHfi+qb7G+r6+2n6thqYG+3V7n7jENHLy8skekU92Xj5xiV2aa9bvhGOQ/R44HxgCCFbwzDfGPNtqnyuwLpoebozZbm8bBmw7yGlb73cE8BAwBWsG4xPAnSaY/S623prsYfw+6quLqWkOtvICaiq2Ul9dQnPvrMsdQ0KKNeaWkDaCD5du54qrb+VXv/oV9957b9BrbOar309j+Vc0la+hqWwtfo/VKI6IzyEqebR9exoXiPUliP29BLZbgSytvne17NP6mNb7H+R4RJBW74f9mgS+t/Yxfh/1NXupq9lNXfVu6quKqasuob66pOWPCCAyJoW4pKHEJw8hLjmXuORc4lNyiY4b0HJOu5a+3CLtKW3CrTngWoVbhDuWhHQ73NLHkJQxjrikIW3CzRiDt6mhTQA1NdTQUF9thVBDS+A01lW3hFNDS0A1NdRyqM4hl8tNVGwC0TEJRMc2fyUSFRNPVflu9uz4Gq+nEYC0gcPJGZFPzohJZI/IJyltcPB+iGEo7IKsLwv1rEWfp97untwa6JqsrSjA01gJwLynC3j74308cu95nHLKyfb4Wx5xycOIcEcHvT5j/Nb4WtlaGsvX4q0utMZ1jLHHB431y8P4AX9gzDCYfH4/TV4vjR4vjfZjk9dLk7ft3z2RERFER7qJcruJjnQTbT9GdOkecIK4Y3HHZ+OOH4I7YUjg0RWdrkFn83oa27SAGuuqqCrbRmVpATUVO6mt3EN9TSlerxefD/x+F0ai8Ptd+Lx+PE2N+P3f/neriIvo2ASiYloCqDmQ2oZTq+2tt8Um4I6M+db/Zl5PE3t3raeoYBXFBasoLlxNU4O1mFFS2mCy8/LJGZFP9shJpA0Y1q//+2uQOUiog6wjzWM3NRUF7C9exzk/uJXqmloevyufxDjr34RIBLFJQ6wxt1YTTGISBoV8XUYTCDkr2Az2c3u7aQ689kFoP8f48Rs/noYD1FUVUV9VTG11MfXVJdRVl9BU3zIGKRJBTHwmsQmDiEsYQGzCAGLjM4lNyLS6A42x7g/XJnDtOgI1mnZ1+lvVaTCeGry1u/DW7Aq0TgHEHYc7Psf6CgTcUFzRaWH7C66psY7yvduprtjd0u3Wpjuug231Nfh8h1joWoSo6DiiomNxuyNwufxgmsBfi8tliIgAd2QUcUkDSUobSmJ6HikDxpCUnkdMbBLRcYlERsX2+s/V7/dRWrKVooKVFBesoqhgJXXV1h0sYhNSrVDLyydn5CQys0fj6kfjgxpkDtBTN9bsDatWreKEE05g5syZLHx6PrUHCu3JJVupqSikoaYksG+EO65l7K3VBJPI6KQQfoKDM8ZPQ81ee5KFNUuweRzL29gSGhHuWKsbMCWX+ORhxKdYY1mxidm9On7lb6rEW1MUCDZP7S58Bw245hZcjuMCrqmxjvI92yjbU0jpngLKdhdStqeQqvKSDvePjI5r2+Jp3dqJadkWHWO3jtq3jKLjkQ5awn6/l7oDO6gu22iPu22kpnxLoCs4IjLOGnNrPVsyaUjI/lgzxlCxf2cg1IoLVlFZZl2zGRUdT9bwCeSMtLoiBw0djzsy+L0moaJB5iBObJF15M9//jM///nPWbBgAdddd12b17yeWmorCgOTSqyAK2gzkSE6LpOE1JF2620ECakjrenTEb0z3d7v81BfXWSFVetZglU7A2MpAJHRKe3Cyvo+On5AyFua38bfVImnZhfe2l34aorw2EFnvhFwQ1pacHYrLpgB1xxYpXsKKNtTaAdWAVXluwP7REREkjZwGOmDR5A+KI/0QXkkpWURE5cYGD/qzZaGFW7bqbJnS3YYbvb1bYkZY0hKH0tsUk7I/n1UV+ylqHBVINzKdhdYdbqjGJQ7PjDOljV8IlExfee6TQ0yBwmXIPP7/ZxzzjksWbKE5cuXM378+G/d3xhDU12pNfbWaoJJbeV2jN8LWN1ycclDA7Mmm1tx0fEDu/2L1eepp7ZyR6CF1dy6qq8qanPNVHT8QOLtWYHNYRWXMoyomJRuva9TtQ44b80uvLVFBw+4QPdkTpcDrruBlT54BCnp2bginD0r0+/3UntgWyDYqks3UlOxtVW4xbeaTGK13mKTskMSbvW1ByguXBNose3dtQHj9yHiYkDOGLJH2ONseZPCemakBpmDhEuQAezdu5cJEyYwcOBAvvjiC2JiDn4t2sH4/V7qKnfalwZYrbia8q001rbcj9QdlUB8itVyswLOmmDijkoI7NPUcIC6dl2BtQe2tzmPNY6XTVxz6yo5N/Dojow7vB9GmPM1VeKt2RkINq8ddsbT0or+ZsANwe/O4EBFBWV7CynbXUDZnm3fDCx3lBVYrcIqfVBeWARWV7SE28ZA12RtRcE3wq3lIu6xxCZm93r3blNjHbu3f2UF29ZV7N7xVauZkcMCsyJzRuSTlJbVq7UdDg0yBwmnIAN49913Oeuss/jpT3/KAw880GPn9TbVtLv2zeqi9HlqA/tExw8kOi6T+qoiPI0t6zy7IqLbhFR8ihVcsYk5vdZ12RcYY/B7qvDW7KS+fCv7i76mbE8B5ftLqKyspbLaQ229N7B/REQEKWmZpA8aRkbWODJyxpMxeCTJ6Vl9KrC6wu/3UltR2PYi7vKtgbuuu6MSWnVLWktw9Xa4+bwe9uxcb8+KXElx4Woa662ZkYmpg9pM+U8bONwx46rtaZA5SLgFGcDNN9/M/PnzefPNNznnnHOC9j7GGBpr97Z0TVYU0FhXSmxiDvEpuYGWlhNmSoarpsY6uyvQ7hLc0zzpom0LKzVzCGkZA0hJjicpwUVSdCMxUob4Wv7QEHd8q8klrWZRRqU49pdhb/D7PNQeKGy5iLtsIzXlBa3CLZHE9NGkZR/P4FGzer172+/3Ubq7gKKtrWdGlgHWzMjsvKMD4ZaZPdoxf6RokDlIOAZZY2Mjxx9/PMXFxaxdu5bBg/VCTafrKLBKdxdQXbEnsE9Ll+AIMgbnkTYoj4xBI0jOyO5wsoUxxppF2Tz+1jwWV7sL42m5kbu4EwLjbm1mUfbjgPP7PNRWFNoTSjZSVbqBmvLNuCKiGDDsNLLHnUdSxhEh+fkYYziwf1erKf+rqCyz7hYfGR1H9vCJVlfkyEkhnRmpQeYg4RhkABs2bOCYY45h+vTpvPvuu7i6dJGvCpamhlrK9m6jbHcBpXsKKT9oYA0nfVAeGYPzSB9kjWEdLLC6ygq4A20mlzSHnfG2D7j2Lbgh/TbgaioKKd74T/ZsfQeft47E9LFkjz2PgXmnf+vaqL2h+sC+NlP+S3dvBawJPINyx1tT/vPyyRo+kejYhEOcrWdokDlIuAYZwGOPPcZPfvIT/vjHP/KLX/wi1OX0K50JLHdkNKkDhtlhZQfW4DyS03smsLqqbcC1m0XZLuAik0cRM+AEYgYcjysqsddrDSWvp5Y9W9+leOOr1B7YhjsqkcGjziF77HnEJeWEujwA6msrKS5cTXFgZuRG/H4vIi4ys0dbXZF2uMUldu0OHJ2lQeYg4RxkxhjmzJnDokWL+OyzzzjmmGNCXVKf42lqoLRki33hcEvX4MEDy57aHsLA6qqOAq6pfC2++r0gLqJSjyJm4BQ71Jx5YX0wGGM4sHc1xRteZf+OJRjjIy37eHLGnk96zhRHrfLvaaynZPvaQItt9/av8Xqs6zNTBwwjZ2Q+OfYKJD01M1KDzEHCOcgAysvLmTBhAnFxcaxcuZKEhN7pVuir6msrKSlcTXHhaooKVrF313r8PmumYLgHVlcYY/BWb6Nh71Ia9n6Gr36PHWpHtgq1zt/BPNw11u2nZPMiije9RlNdKTEJg8ga8z2yRs8mKsZ514L5vJ5vrBnZWG9d2tE8MzJ7RD5DRx9HaubQbr2HBpmDhHuQASxZsoRTTz2V//qv/+LJJ58MdTlhpap8d+B/9KLCVYFVGVwRbgYNHU/2iHwGDzuKjMEj+mRgdUZLqH1Gw96lVqjhIiptPDEDphA98AQi+kmo+f1eSnd+TNGGVziwZyXiimTA8FPJGXseSZlHOnZs0fj9lO621oxsDrfaqlImTv8Bp19wW7fOqUHmAIe71qLx+63bizjkH+7tt9/OPffcw4svvsgFF1wQ6nIcyfj9lO0ptP5HLlxNceGqQBdhVEyCtU7eiHyy845m4NDxREaFdoDfiay7jW9vaanV7QZcRKUeQczAKUQPOIGI6L61OsvB1B7YRvHGf7J769v4PHUkpI0mZ9z5DMz7TsgnhxyKMYYDpbsQcZGS0b1xPw0yB+lui2zXluW89tjNZGSPIjNrFAOyR5OZPZqMrJFERsUGodJv5/F4mDFjBhs3bmTNmjXk5ub2eg1OY92SYwPF9jp4JdvW0FBnLQ0Vn5TRaqmgfDKyRvbL1tbhsEJtR0tLra4EK9TGETNwKtEDjici2nndbj3N66llb8G/KNrwCrUHCu3JIWeTPeY84pKHhLq8oNEgc5DuBllpyVZWf/IS+0u2UFq8haZG+8JUEVIzh5KZNZrM7FFk2gGXmNL99Qs7q7CwkKOPPpoJEyawZMkS3G5nXDjZWxrrayjZtsaezbWKPTvXBZYCSh0wLNDayh6RT3J67y9V1JdZobbTaqnt+wxfbTEgRNottZgBJ/T5UDPGULl3DUUbX2H/dntySNZxZI89j4wh0xw1OaQnaJA5SE+MkRm/n8ryEvYXb7a+Srawv3hz4PYOADFxyWRmjbLCLWcMmVmjSR+Uhzsy6nA/QhsLFy7k0ksv5c477+S3v/1tj57baWoq97eMbxWsorRkC8b4EVcEA3PG2resP1pvW9/LjDF4a3e1dD/WFgFCZMo4K9QGTunzodZYV0rJ5kWUbHqNxrr9RMcPJHvs98kaNYuo2OBMh+9tGmQOEszJHo31NYFQ21+ymf3FWygt2RqYFutyuUkbOKyl5ZZltd7ik9IP630vu+wyFi5cyEcffcS0adN64qOEnDGGin07KCpYRYkdXM2rHbijYsgaNiEQXFnDJhAZ3fvdu6pjnpqdNOz9jMa9S/EGQm1sS0st5vD+vTuZNTnkE4o3vkLF7hXW5JBhp5Az9nySBjh3ckhnaJA5SG/PWvT7fRzYv6tVuG1mX/EWag60rBofl5geCLcBdrilDswlopML8FZVVZGfn4/P52P16tWkpITf4Lvf52Vf0SZ7YobV6qqvse4M3Xr9uey8fDJzRnf6Z6NCy1uzKzCm5q3dhRVqY+xQm9KnQ632wHaKN77K7q3v4PPUkpA2iuyx5zEo7wwiIsPvDy8NMgdxyvT7+toD7C9u23or210QuIV8REQk6YNHWAFnh1tm9mhi4zue9rxs2TKmT5/O+eefz/PPP+/4v/yaL+hsHt/avf0rPE31ACSn55AzIp8sO7xSB+Q6/vOoQ/PWFNGwzw61mp0ARCaPIWbgVKv7sY+GmtdTZ00O2fgKtRUFuKMSGDTybHLGnkdccveu6QoFDTIHcUqQdcTn81Cxd4fVarNbb/uLtwRWxgZISBnIgHZdkymZQ3C5Irj33nv59a9/zVNPPcUVV1wRug/SgbrqikBLq7hgFXuLNmL8PhAhM2t0m4kZCcmZoS5XBZm3trilpVazA2gONXtMLSYjxBX2PGMMlfvWUrThFWvlEL+X1KxjyRl7HulDpuFyOXuylgaZgzg5yA6mtqqsTdfk/uItlO3dZgUB4I6MISNrJGmDR/A/f/wH6zdvY9lnn3LkhPyQ1GuMobKsuM3EjIp92wFrAd3BuUe2jG8Nn0B0bP9a20+15a0tCUwU8dZsByAyeXRL92Ns3/vDprGujJLNb1Cy6XUa6/ZZk0PGfJes0ec6dnKIBpmDhGOQdcTraaJsT2GrcLMCbs++/cx7fiNpSVH85ppTGJw71p49abXektOykB5eOd/v91FasrVlfMteRQAgJi6JLPs2FNl5+QwcMq7HZ26qvsNbW2J3P36Gt3obAJFJo1paarEDQlxhz/L7vZTt+pSiDa9QsXs54nIzYNgpZI89n+QBRzmqS12DzEH6SpB1xBhDzYF9/N/fn+D6m27n+zOPY9a0bCr27wD731ZUdPw3L+oePLJLs/48TQ3s3bkusGJGyba1NDW03PE2Oy8/0FWYPiivx4NT9Q/eut0t3Y+BUBtprSgycCruPhZq1uSQ5pVDmieHfJ9BeWc6YnKIBpmD9OUga+3aa6/l0UcfZfHixZx04jRKdxe0arlZrbfOXtRdX1tpXXhsB9fenesDk1LSB48gJ69lfCspTW/6qXqet26PHWqf4a221sd0J40ITBRxxw4McYU9x+epZ0/hexRveJWaiq1ERMYzeOTZZI87j/jk0K3go0HmIP0lyOrq6pg8eTIHDhxgzZo1ZGa2HWcwxlBVXsK+duHWfK0WWN2CsQlpgfEtV4SbgUOOCLS2svKOPugsSqWCxVu3h4Z9n1sttSo71BJHBLof3XGDQlxhz7Amh3xF8cZX2bf9Q2tyyODJ5Iw7PySTQzTIHKS/BBnAmjVrOO644zjzzDN5/fXXO9Xf3lhfQ+nurYFwq60qY1DueLLz8hmUqwvrKmfx1u+l0W6peaqsuyi7E/PsUJvaZ0Ktqb6cks1vULzpdRpr9xIdN4Ase3JIdFzvXLagQeYg/SnIAB544AF+9rOf8dBDD3HDDTeEuhylgsZbv69VqFl3uHAnDg/MfnTH98wNJkMpMDlk46tUlHyJuNxk5p5MztjzSB44MaiTQzTIHKS/BZkxhlmzZvHBBx/w5ZdfctRRR4W6JKWCzle/z+6JIhdaAAAgAElEQVR+/AxP5WYA3AnDWlpqfSDUait3ULLxNXZvfQtvUw3xqSPIGXseA0eciTsyrsffT4PMAQ73fmThbN++fUyYMIGMjAy+/PJLYmNDPwNKqd7iq9/fKtQ2AeBOyCU64xgiU0YTlTw6rO9+bU0O+RfFG1+lpnyLPTnkLLLHnkd8yrAee58eCTIRKezKmxpj8rqyf3/R31pkzd577z1mzpzJ9ddfz1//+tdQl6NUSPgaSmnY+zkN+z7DU7kFjLWoQETsIDvUxhCZPBp3Qm7Y3YbFGEPVvq8p2vgK+7b/G+P3kDr4GOu2MkNnHPbkkJ4KMj9QDbwJlBzqZMaYX3alyP6ivwYZwNy5c5k3bx6vv/465557bqjLUSqkjK8RT1UBTZWb8VRuxnNgE/6mAwCIKxp38kiikkcRmTyGyJQxRIRRq62pvpySLW9SvPGf9uSQzFaTQ7q3/FdPBdntwIXAOOBj4HngZWNMebeq6qf6c5A1NjYyZcoUdu7cydq1a8nKCv9xAqV6ijEGX8P+QKh5Kjfjqd7WqtU2wAq1ZKs70p04DHH4+ojG76O0aCnFG16hvOQLBo86h3HTf9Otc/XoGJmIHAlcZH8NAT7ACrXXjDHV3aqwH+nPQQawadMmJk2axJQpU/jXv/6FS1fdUOqgjK8RT/U2PAc2BVpu/ka77eCKIjJpBFEpVrhFJo929A1E6yp3IS4XsYnZ3To+aJM9ROQ4rFbaBUA6cJ8x5nfdqrKf6O9BBvDkk09y1VVXcd9993HLLbeEuhylwoYxBn9DaUt3ZOUmPFXbwHgBiIgZQGTyKCJTxhCVPAZ3Yi7i6hv3zgtmkLmBM4FLsMLsZWPMRd2qsp/QILP+Z7zgggt47bXXWLp0Kccee2yoS1IqbBlfk9Vqq9xE04HmVpt96yVXFJFJeYHuyMjkMUTEOHN1+0Pp6a5FAU4BLga+D0QArwMvAIuNsTt0VYc0yCwVFRVMnDiR6OhoVq5cSWKi3kpFqZ7iayhrE2yeqoJAq80VkxEItciU0UQmDg+LVltPTfaYijUuNgdIBN7CCq+3jTFNPVRrn6dB1uLjjz/m5JNP5kc/+hFPP/10qMtRqs8yfo891mZ1RzZVbsbfYN3qCFckkYl2qy2ludXmvLtl9/T0+0XAG0DNt53MGPN2F+vsFzTI2vqf//kf7r77bp577jkuvvjiUJejVL9htdo2t4y3VRWA37qrhCs63Q41u+WWlBfyVltPBlkzA3zbolrGGBNeV/P1Eg2ytrxeLyeeeCLr1q1j9erVDB8+PNQlKdUvGb8Hb/UOmio3BWZJ+hv2Wy+Km8ik4W2m/7tiMnr1xps9FWRduhGNMWZHV/bvLzTIvmn79u1MnDiR8ePH89FHH+F2O/vaGKX6C19jReC6tqZAq80aSXJFp7VMIkkZQ2RiHhIRvLuvdzbIvvW3hwaTCpZhw4bx6KOPcvHFF3P33Xfzu9/pFRxKOUFEdCoRA44nZsDxABi/F2/19jbT/xv3fW7tLG4iE4dZ3ZH2tW0RMZm92moDXTS4V2iL7OCuuOIKnn32WZYsWcKMGTNCXY5SqhN8jQcCodZ0YLN1X7bmVltUSiDUopJHE5k0AomI7tb79FTX4n6ssbFOMcYM6Oy+/YkG2cFVV1czadIkGhsbWbNmDampzl2lQCnVMeP34q3ZaY21VW7Gc2Azvvo9AMRmnUry+O7dl7BHuhaBv9KFIFOqqxITE3nuueeYOnUq11xzDf/4xz96vVtCKXV4xOW2LsJOyoMhZwHga6rEU7mZiKjg/3F6qDGyO4Neger3jj32WP73f/+XX/3qV/ztb3/jyiuvDHVJSqnDFBGVTERm76zgc1irt4pIpogEb8qK6jd++ctfcuqpp3LjjTeycePGUJejlAoj3xpkIjJdRL5xjzERuUZESoE9wAERmS8iuqS56jaXy8Wzzz5LbGwsF154ITt37gx1SUqpMHGo8PkFcELrDSJyGvAwsAP4GfAEcANwVTAKVP1HVlYWzz77LFu3bmXcuHHcf//9eDyeUJellHK4QwXZJKylqVq7DqgDvmOMecgYcyMwH7g6CPWpfuass85i/fr1fOc73+HWW29l0qRJfPLJJ6EuSynlYIcKskxge/MTexX87wAftLtL9GJgRI9Xp/ql3NxcXnvtNd544w2qq6uZMWMGP/7xj9m/f3+oS1NKOdChgmwf0Pre9PlYq+B/1G4/D9atXfo8EXlYRIpFRC9LCLLZs2ezbt06br31Vp599lnGjh3LE088gd/vP/TBSql+41BB9hEwV0TS7ckcvwD8wGvt9psI7ApCfU70PFaXq+oF8fHx/OEPf2D16tUceeSRXH311UyfPp21a9eGujSllEMcKsh+A2QDe7Fu4XIRMN8YU9huv8uAfx9OISIyUkQeFZG1IuITkSU9eZyIHCEiH4hInYiUiMhdItLlVqQx5iNjzN6uHqcOz/jx41myZAnPPPMMW7ZsYdKkScydO5fq6upQl6aUCrFvDTJjzE5gHNYEj/8BTjfG/KL1PiKSASwEFhxmLeOBs4FNwOaePE5EUoH3sVYp+S5wFzAX0JVqw4iIcNlll7Fp0yauvPJK5s2bx7hx43jllVfQNUOV6r8cs2iwiLiMMX77+5eBDGPMyT1xnIjcBtwC5BpjquxttwB3AoNabVsJDO3gbd4zxlzS7pzGGNOptZR0rcXg+Pzzz7n22mtZs2YNZ599Ng8++CB5eXmhLksp1UM6u9Zity5iFpE4EfmpiPxVRO7o6n3LOtIcRkE67iysMKpqte0FIBY4qdW5JhljMjr4uqT9CVXonXDCCSxfvpw///nPfPTRR4wfP5577rmHxsbGUJemlOpFh1rZ408isrndtkRgJda1YxdidTmuEZHRQavy8I0F2qx7ZHeb1tmv9Th79ZPlIrJcp40Hj9vt5qabbmLjxo3MmjWL22+/nYkTJ/Lhhx+GujSlVC85VIvsFOD/2m37BTAauNoYk4E1PX87cEePV9dzUoEDHWyvsF/rNBF5QkSK7O+LROSJjvYzxjxmjJlsjJmcmZnZ5YJV12RnZ/PSSy/xzjvv4PF4OO2007j00kvZu1fn5SjV1x0qyIYBK9ptOx9Yb4z5G4AxZj/wJ2Baj1fnQMaYq4wxOcYYsR91aS4HmTlzJl9//TV33HEHL730EmPGjGHBggX4fL5Ql6aUCpJDBZkbaGh+IiJpWLMY2/fbbAcG9WhlPasCSO5ge6r9mupDYmNjueuuu/jqq6+YPHkyN9xwA1OmTGHFivZ/kyml+oJDBdlm4ORWz2fZj++1228AUI5zbaTdWJiIDAHiaDd2pvqO0aNHs3jxYp577jl27drFcccdx4033khlZWWoS1NK9aBDBdlDwK9E5AER+Q3wR2Ab8K92+50BfB2E+nrKO8CZ9kSVZhcC9cB/gvWmIjJbRB7TX5yhIyJcfPHFbNy4keuvv56HHnqIsWPH8sILL+i1Z0r1EYe6IPpprFmJ5wG3YV10/H1jTODeGiKSiXWR8euHU4g9pX+OiMzBWk0ks/m5iMTZ+1wmIt7W0/07cxzwCNAIvCoip4vINVjXkM1rNyW/RxljFhljrklO7qhXU/Wm5ORkHnzwQb744guys7O5+OKLOeOMM9i8uSvX3iulnMhJF0QPw2rtdWS4MWa7iFwBPNX8vLPH2fsdgdXCnII1g/EJ4E5jTNBnAegF0c7i8/l45JFH+PWvf01DQwO/+tWvuO2224iJiQl1aUqpVjp7QbRjgqwv0yBzpj179jB37lyee+45RowYwV//+lfOPPPMUJellLIFdWUP1Tk6RuZsgwYNYuHChbz//vtEREQwc+ZMLrjgAoqLi0NdmlKqCzTIgkjHyMLDaaedxtq1a7n77rtZtGgR48aN4y9/+QterzfUpSmlOkGDTCkgOjqa22+/nXXr1jF9+nRuuukmjj32WD7//PNQl6aUOgQNMqVaycvL46233uLll19m//79TJ06lZ/85CeUlzv5Mkml+jcNMqXaERHOP/98NmzYwE033cSTTz7J2LFj+fvf/67XninlQBpkSh1EYmIi8+bNY8WKFYwYMYLLL7+cU045hfXr14e6NKVUKxpkQaSzFvuGiRMn8umnn/LYY4+xdu1aJk6cyG233UZdXV2oS1NKoUEWVDprse9wuVxcffXVbNq0iUsvvZQ//OEPHHHEESxatCjUpSnV72mQKdUFmZmZPPXUU3z00UckJCRw7rnn8r3vfY+dO3eGujSl+i0NMqW6YcaMGaxatYr77ruPxYsXM27cOO6//348Hs+hD1ZK9SgNMqW6KTIykltuuYX169dz+umnc+uttzJp0iQ++eSTUJemVL+iQabUYcrNzeX111/n9ddfp6qqihkzZvDjH/+Y0tLSUJemVL+gQRZEOmuxfzn33HNZv349t956K88++yxjxozhiSeewO/3h7o0pfo0DbIuEJEhIvKBiGwQkXUicr+IyMH211mL/U98fDx/+MMfWL16NUceeSRXX301M2bMYO3ataEuTak+S4Osa7zArcaYcUA+cDzWTUeVamP8+PEsWbKEp59+ms2bNzNp0iTmzp1LdXV1qEtTqs9xTJCJyBUiYjr4uvYQx40UkUdFZK2I+ERkyUH2O8JuTdWJSImI3CUiEV2p0Riz2xiz3P6+CVgLDOnKOVT/ISJcfvnlbNq0iSuvvJJ58+Yxbtw4XnnlFV3qSqke5Jgga+VUrLs4N3+9eoj9xwNnA5uADu9bLyKpwPuAAb4L3AXMBX7X3SJFJB34HvBed8+h+oe0tDQeffRRli5dSkZGBnPmzGHWrFkUFhaGujSl+gQnBtmXxpjPW33tO8T+i4wxQ4wxPwDWHWSfa4FY4DxjzGJjzCNYIfZzEUlq3klEVopIaQdfC1ufTESigZeB+caYDd3+pKpfmTJlCsuXL2fevHl89NFHjB8/nnvuuYfGxsZQl6ZUWHNikHWJMaYzU8LOAt4zxlS12vYCVrid1Opck4wxGR18XdK8j90duRBYZYz5Uw99DNVPuN1ubr75ZjZs2MCsWbO4/fbbmThxIv/617+0u1GpbnJikBWIiFdENonIT3ronGOBja03GGN2AnX2a13xKFCN1TWpVLfk5OTw0ksv8fbbb+PxeDjzzDM56qijWLBggU4IUaqLnBRku4E7gB8Bs4HPgUdE5OYeOHcqcKCD7RX2a50iItOAK4HJwCoRWS0iNx5k32tEZIuI7Nd1+NTBnHXWWaxbt44nn3yS6OhobrjhBrKysrjhhhtYt+5gPeVKqdbEyd0ZIvIicDqQ2ZkuRBF5GcgwxpzcbrsH+KUxZn677UXA340xv+65qr9p8uTJZvny5cF8C9UHGGP44osvWLBgAS+++CKNjY2cdNJJ3HDDDXzve98jMjIy1CUq1atEZIUxZvKh9nNSi6wjLwNpwLDDPE8F0NFVyan2a0qFnIhw/PHH88wzz1BUVMR9993Hjh07uOCCC8jNzeW3v/0txcXFoS5TKcdxepCZdo/dtZF2Y2EiMgSIo93YmVJOkJGRwS233MLWrVt58803yc/P5+677yY3N5c5c+bw4Ycf6uQQpWxOD7I5QCmw4zDP8w5wpogkttp2IVAP/Ocwz61U0ERERHDOOefw1ltvsXXrVn7+85/z73//m9NOO40jjjiCBx98EF3LU/V3jgkyEXlFRG4VkbNEZJaIPIsVNnc1j4+JyGX2jMbcVsfFicgcEZkDZAOZzc9FJM7e7RGgEXhVRE4XkWuAO4F57abkK+VYeXl53H///RQVFfH000+TlJTEjTfeSHZ2Ntdee62u56j6LcdM9hCR3wPnYy35JMB6rAuOn221zxXAU8BwY8x2e9swYNtBTtt6vyOAh7BWCzkAPAHcaYzx9fiHaUcne6hgWb58OQsWLOD555+noaGB6dOnc/3113P++ecTFRUV6vKUOiydnezhmCDryzTIVLCVl5fz1FNP8fDDD1NQUMCAAQO4+uqrueaaaxg6dGioy1OqW/rKrEWlVCekpaUxd+5cNm/ezDvvvMPxxx/P73//e4YPH873v/99Fi9erPdFU32WBlkQ6Y01VW9zuVzMnDmTN954g8LCQm655RY++eQTzjjjDMaNG8f8+fM5cKCjtQGUCl/atdgLtGtRhVJjYyMvvfQSCxYs4LPPPiM2NpZLLrmEG264gaOPPjrU5Sl1UNq1qJQCIDo6mksvvZSlS5eycuVKLrnkEhYuXEh+fj5Tp07l//7v/3QFfhXWNMiU6kfy8/N5/PHHKSkpYf78+ZSVlfGjH/2InJwcbrvtNrZv3x7qEpXqMg0ypfqhlJQUfvazn7FhwwYWL17M9OnTuf/++8nLy+Pcc8/l3Xff1ckhKmxokCnVj7lcLk4//XT++c9/sn37dn7zm9/wxRdfcNZZZzF69Gj+9Kc/UV5eHuoylfpWGmRKKQCGDBnC3Xffzc6dO3n++ecZPHgwv/jFL8jOzubHP/4xOmFJOZUGmVKqjaioKC666CI+/vhj1qxZw+WXX84//vEPjj322MDq/PX19aEuU6kADTKl1EFNmDCBRx55hOLiYh544AGqqqq44ooryMnJ4ZZbbqGwsDDUJSqlQaaUOrTk5GR++tOfsn79ej788ENOOeUU5s2bx8iRIwOr8/t8QV+2VKkOaZAppTpNRDjllFN4+eWX2bFjB3fccQcrV65k1qxZjBo1ivvvv5/S0tJQl6n6GQ2yINIlqlRflp2dze9+9zt27tzJP/7xD4YOHcqtt95KTk4Ol19+OcuWLdObf6peoUtU9QJdokr1F+vWrePhhx/mmWeeoaamhmOOOYbrr7+eiy66iLi4uEOfQKlWdIkqpVSvGz9+PA899BAlJSUsWLCAhoYGrrzySnJycpg7dy5btmwJdYmqD9IgU0r1uMTERK677jq++uor/vOf/3DGGWfwwAMPMHr06MDq/Do5RPUUDTKlVNCICCeeeCIvvPACO3fu5K677uLrr7/mu9/9LtnZ2Vx11VW8/vrr1NbWhrpUFcZ0jKwX6BiZUi28Xi9vvPEGL774Iu+++y5VVVXExMRw2mmnMXv2bGbNmkV2dnaoy1QO0NkxMg2yXqBBplTHmpqa+Pjjj3njjTdYtGgR27ZtA2DSpEnMnj2b2bNnM2nSJEQkxJWqUNAgcxANMqUOzRjD+vXrWbRoEYsWLeKzzz7DGENWVhazZs1i9uzZnHbaacTGxoa6VNVLNMgcRINMqa7bv38/b7/9NosWLeK9996jpqaG2NhYTj/99EAX5ODBg0NdpgoiDTIH0SBT6vA0Njbyn//8J9Ba27FjBwCTJ08OdEEeffTR2gXZx2iQOYgGmVI9xxjD119/HRhX++KLLzDGMGTIkEAX5CmnnEJMTEyoS1WHSYPMQTTIlAqevXv38tZbb7Fo0SL+9a9/UVdXR3x8PN/5zneYPXs255xzDgMHDgx1maobNMgcRINMqd7R0NDAv//970AXZFFRESLCcccdF+iCPOqoo7QLMkxokDmIBplSvc8Yw5o1awKh9uWXXwKQm5sbCLWTTjqJ6OjoEFeqDkaDzEE0yJQKvd27d/Pmm2+yaNEi3n//ferr60lISODMM89k9uzZnH322WRmZoa6TNWKBpmDaJAp5Sz19fV88MEHLFq0iDfffJOSkhJEhClTpgRaa0cccYR2QYaYBpmDaJAp5VzGGFauXBnogly5ciUAw4cPD4TaiSeeSFRUVIgr7X80yBxARGYDs0eOHHm13r5CqfBQVFQU6IL84IMPaGxsJCkpiZkzZzJ79mzOOuss0tPTQ11mv6BB5iDaIlMqPNXW1vL+++8HuiD37t2Ly+Vi2rRpgdbamDFjtAsySDTIHESDTKnw5/f7Wb58eaALcs2aNQCMHDkyEGrTp08nMjIyxJX2HRpkDqJBplTfs3PnzkAX5IcffkhTUxMpKSnMnDmTc889l5kzZ5KamhrqMsOaBpmDaJAp1bdVV1ezePFiFi1axFtvvcX+/fuJiIhgxowZgdbaqFGjQl1m2NEgcxANMqX6D5/PxxdffBHogvz6668BGDNmDGeccQbTpk1j6tSpDBkyJMSVOp8GmYNokCnVf23bti3QBfnJJ59QX18PwJAhQwKhNm3aNCZMmIDb7Q5xtc6iQeYgGmRKKQCPx8OaNWv49NNPWbp0KZ9++inFxcUAxMfHc/zxxwfC7YQTTiAlJSXEFYeWBpmDaJAppTpijGHXrl1tgm3NmjX4/X5EhPHjx7dpteXl5fWrqf4aZA6iQaaU6qyamhqWLVsWCLfPPvuMqqoqAAYOHBgItalTpzJp0qQ+veixBpmDaJAppbrL5/Oxfv36Nq22wsJCAKKjo5k8eTLTpk1j2rRpTJkypU8tfKxB5iAaZEqpnrRnzx6WLl0aCLYVK1bg8XgAGD16dJtW29ixY3G5XCGuuHs0yBxEg0wpFUz19fWsWLGiTautrKwMgNTUVKZOnRoIt2OPPZa4uLgQV9w5GmQOokGmlOpNxhi2bNnCp59+Ggi3DRs2AOB2u8nPzw8E27Rp08jKygpxxR3TIHMQDTKlVKiVlZXx+eefB4Ltiy++CFzTlpub22Z25FFHHUVERESIK9YgcxQNMqWU0zQ1NbF69epAV+Snn37K7t27AUhISOCEE05oc01bUlJSr9eoQeYgGmRKKaczxrBjx442wfbVV18Frmk76qij2rTahg0bFvRr2jTIHESDTCkVjqqqqli2bFkg3D7//HOqq6sBGDx4cJvZkfn5+T1+F20NMgfRIFNK9QU+n4+vv/46EGxLly5l27ZtAMTExHDssccGgm3q1KmHfSdtDTIH0SBTSvVVJSUlba5pW7lyJV6vF4CxY8dy3XXXceONN3br3J0NMl1qWSmlVLdlZWUxZ84c5syZA1jXtH355ZeBYOuNtSE1yLpARIYATwNZgB94C7jVaLNWKaUAiI2N5cQTT+TEE0/stfcMz3VLQseLFVzjgHzgeOC80JaklFL9m2OCTERGisijIrJWRHwisqQnjxORI0TkAxGpE5ESEblLRLp0xZ8xZrcxZrn9fROwFtDbvCqlVAg5qWtxPHA28DkQ2ZPHiUgq8D6wHvguMAL4E1aQ396dYkUkHfgecEZ3jldKKdUznBRki4wxrwOIyMtARg8edy0QC5xnjKkCFotIEnCniNxvb0NEVgJDOzj+PWPMJc1PRCQaeBmYb4zZ0Mk6lVJKBYFjgswY4w/icWdhhVFVq20vAPcBJwGL7HNNOtSJ7O7IhcAqY8yful6xUkqpnuSYMbIgGwtsbL3BGLMTqLNf64pHgWpgbs+UppRS6nD0lyBLBQ50sL3Cfq1TRGQacCUwGVglIqtFpMMr/UTkGhFZLiLL9+/f352alVJKdYJjuhbDgTHmU6BTV/cZYx4DHgNrZY9g1qWUUv1ZfwmyCiC5g+2p9mtBtWLFilIR2dHNwzOA0p6sJwzoZ+4f9DP3D4fzmXM7s1N/CbKNtBsLs1fpiKPd2FkwGGMyu3usiCzvzFpjfYl+5v5BP3P/0Bufub+Mkb0DnCkiia22XQjUA/8JTUlKKaV6gmNaZCISh3VhM0A2kCQic+znbxtj6kTkMuBvwAhjzI7OHgc8AtwIvCoi9wF5wJ3AvHZT8pVSSoUZxwQZMAB4qd225ufDge1YLcgI2k64OORxxpgKETkNeAjrmrEDwJ+xwszpHgt1ASGgn7l/0M/cPwT9M+v9yJRSSoW1/jJGppRSqo/SIHOonlitP5x09+4H4UxEfiAib4hIsYjUiMgKEbk41HUFi4jMEZGlIlImIg0isklEbheRqFDX1ltEJNv+b21EJCHU9QSDiFxhf772X9cG6z2dNEambMFYrT8MdPfuB+Hs58A24Gas62zOBp4TkQxjzIMhrSw40oEPgT9ijVMfhzVOPQj479CV1av+CNQA8aEupBecijUzvFlhsN5Ix8gcSERuA24BclutzH8L9v/0fXGmpYi4mheAbr6LgTHm5NBWFVx2YJW22/YcMMUYMzxEZfUqEbkHuAFI7et3WheRE4HXgN9jBVqiMaYmtFX1PBG5AniKXvx82rXoTAdbrT8Wa7X+Pqe7dz8IZ+1DzLYKyOrtWkKoDOjzXYv2sMCDwF30v5U9gk6DzJl6crV+FV6mAJtDXUQwiUiEiMSJyHSs6zsf7uutMax7IkYDfw11Ib2oQES89ljoT4L5RjpG5kw9slq/Ci/2tY7fA34c6lqCrBbrlzrA34FfhrCWoLPvJn83cKkxxiPSqXXHw9lu4A7gC6zrfi8CHhGROGPMn4PxhhpkSjmAiAwDngNeN8Y8HdJigm8q1jqnxwH/g7VQwfUhrSi47gE+N8a8HepCeoMx5j3gvVab3hGRGOB2EflLMIYRNMicKaSr9aveJSJpWOuB7gAuCXE5QWeMWWl/+4mIlALPiMifjDEFoawrGERkPFYL+0QRSbE3x9mPySLiM8bUd3x0n/IycAEwjCDMXtQgc6aQrtaveo+9VuibWBMeZtlrg/YnzaE2HOhzQQaMwrqc5LMOXisCngSu6tWKQsO0e+xRGmTO9A7wSxFJNMZU29t0tf4+RkTcWOuCjgKmGmP2hbikUJhmP24LaRXB8wlwSrttM4Fbsa4bDNq1VQ4zB2u2Znfvy/itNMicqd+t1t/Juxj0NQuwPvPPgHR7UkCzVcaYxtCUFRwi8i7Whf7rAB9WiM0FXuyL3YoQuMRiSett9ngowMd99DqyV7AmeqzFmuxxof11Y7Aus9Egc6AwX62/uzpz94O+5gz78S8dvNYXP/OXwBVY4yRerNbIbVh/uKm+YxPWuOAQrDuVrAcuM8Y8G6w31JU9lFJKhTW9IFoppVRY0yBTSikV1jTIlFJKhTUNMqWUUmFNg0wppVRY0yBTSikV1jTIlFJKhTUNMqWUUmFNg0wppVRY0yBTSikV1lTjZJ0AAAVxSURBVDTIlFJKhTUNMqWUUmFNg0wppVRY0yBTSikV1jTIlHIYEXlaRJY7oI4LROSKTu57pIgYETn5EPuJiKwWkcu7Uc9DIvJkV49TfZ8GmVLOczfWDShD7QJ6vo4LgDTguW4c+/+AS0RkZM+WpMKdBplSDmOMKTDGfB3qOoLkRuBZY4ynqwcaY7YDnwDX9XRRKrxpkCnVQ5q7BEXkOyKyVkRqReQTERnfbr8LROQrEWkUkV0ico+IuNufp9Xz8SLyroiU2+fcICI3tDvnDBH5j4jUiUiZiDwuIomHqPeg5xWRp4HzgZPsLkMjIne2OvZ6u/ZaEVkEDO7Ez2ckMBV4uYPXBonIMyKyV0T8rd7TiMiKVru+gtUq099dKsB96F2UUl0wFPgjcA9Qj9Ud9qKIHGWMMSJyBvAi8Hfgl8AErK7EdODag5xzEbABuBRoBMYASc0visg04H3gNWCOfa4/AKn284P5tvPebX+WFOB6e1uR/X7fBf4KPGK/50nA3771p2I5DagF1rTeKCIxdv3xwC1AKXArMAN4DPh3q92XAgOBo9qfR/VfGmRK9aw0YJoxZguA3XL4J1ZIbATuApYYY5onO7wrIgD3isj/GmOKWp9MRDKA4cB3jTFf2Zs/aPeefwCWGmMubHVcMfCBiBzZUTfloc5rjCkQkXLAZYz5vN3hvwHeNcY0d/G9JyKZwFXf+pOBY4ANxhh/u+23A0OAI4wxxXZ9G4GtwCfGmBda7bsO8AHHoUGmbNo8V6pnbW8OMdt6+zFHRCKAScBL7Y55Eev/xSkdnK8c2AU8IiIXisiA1i+KSJx93D9ExN38hTWW5MEKj45863kPxj73JOD1di+92onDB2G1ttq7BHi8OcRshYDBahEGGGO8wAH7XEoBGmRK9bQD7Z432Y8xQAYQCextt0/z87T2J7NbL2cAe7C67/aIyMcikm/vkgpEAAuwgqv5q9F+ryEdFdmJ8x5Mhv1++9ptb/+8IzF2XQEiMhYYhtW12FomIMDuDs7TaJ9LKUC7FpXqTaVYIdO+9TPQfizv6CBjzEbgfBGJxBo3ug94S0RysILTAHcCb3dweMnBivm283bQ/df6M/g6+AydadGV882WVI792D4Iz8T6WS3u4DwpHORnpfonbZEp1UuMMT5gBfCDdi9dAPj/fzv37xpFGIRx/DvYWcXC/0BMFxAsUhnsAsFEBMHagFUEqyhEtBAEEQWrlBZaBAstLIQUoqBGUIiC4I8uEEQQEREbRR+LeS8c58VbQrjwss8Hrtnbd97d5obZmT1gZcD6X5IeAtfJKcERST+A58CopJd9Ppsmsv/FLV/9pKfyKY/2VoGZnjDHBu0DvCf7ct06Fexo50AZ/jgP3JH0rfvk0ovbDXxosJ+1hCsys+G6SA5H3ASWyOm7S2SPaL335IgYo0w+kn2jPeRE32tJnapknhzs+EOOtn8nJw6ngAVJ//zoN4z7DpiJiKPkxOLHkhgvA3cjYpEcZJkAJhvc+1PgQkTslfS5HHtV9r8SEb/JhH6WTKCn+8Q4SFagzxrsZy3hisxsiCQtAyfIH+T7wBngGjC3yZJPZA9tAXhA9sLeAtNdMZ8Ah8i+0q0Sd54c5ujtxzWOW44tkz20F8Cpst89MskcIcfvDwCzDW7/EflIcCPplQpvGlgjX0lYBN4A45K+9okxCTyW9KXBftYSIWmnr8HMWiIibgD7JE1tYe0uMuGdk3R72y/OquWKzMyG6SpwOCL2b2HtcfIl86VBJ1q7OJGZ2dCUPuBJGvylVR8BzJbHkWYb/GjRzMyq5orMzMyq5kRmZmZVcyIzM7OqOZGZmVnVnMjMzKxqTmRmZlY1JzIzM6vaX7cmAFIJLET2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "save_fig = False\n",
    "all_ssim = Exp['ssim']\n",
    "ssim_bl = Exp['ssim_baseline']\n",
    "mean_ssim_baseline = ssim_bl.mean(dim=0)\n",
    "mean_ssim = all_ssim.mean(dim=0)[:,:,0]\n",
    "print(mean_ssim_baseline)\n",
    "cmap2=plt.get_cmap('tab20b')\n",
    "#color_lbda=[cmap2(6),cmap2(5),cmap2(4)]\n",
    "color_lbda=[cmap2(10),cmap2(9),cmap2(8)]\n",
    "\n",
    "\n",
    "print(mean_ssim.size())\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "for idx_lbda, lbda1 in enumerate(lbda1_list):\n",
    "    plt.plot(std_list ,mean_ssim[:,idx_lbda].numpy(),label=r'$\\lambda_{1}=$'+'{0}'.format(lbda1),color=color_lbda[idx_lbda])\n",
    "\n",
    "plt.plot(std_list,mean_ssim_baseline.numpy(), label='baseline',color='black')\n",
    "\n",
    "\n",
    "plt.plot([0.0,0.2],[1.5,1.5], linewidth=3, color=color_lbda[0])\n",
    "plt.plot([0.3,1.2],[1.5,1.5], linewidth=3, color=color_lbda[1])\n",
    "plt.plot([1.3,5],[1.5,1.5], linewidth=3, color=color_lbda[2])\n",
    "\n",
    "\n",
    "\n",
    "plt.yscale(\"log\")\n",
    "plt.ylabel('SSIM', fontsize=15, labelpad=10)\n",
    "plt.ylim((0,2))\n",
    "plt.xlabel('noise std ' + r'$(\\sigma)$', fontsize=15, labelpad=10)\n",
    "plt.xticks(std_list, fontsize=15)\n",
    "plt.yticks([0.01,0.05,0.1,0.5,1], \\\n",
    "           [r'$1.10^{-2}$',r'$5.10^{-2}$',r'$1.10^{-1}$',r'$5.10^{-1}$',r'$1$'], fontsize=15)\n",
    "\n",
    "if save_fig == True:\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/Fig12/Fig12a.png',\\\n",
    "                bbox_inches = 'tight', pad_inches = 0, dpi= 400)\n",
    "#plt.legend(loc='lower center',bbox_to_anchor=(0.5, -0.5),ncol=6,fontsize=15)\n",
    "plt.show()\n",
    "\n",
    "all_ssim = Exp['ssim']\n",
    "mean_ssim = all_ssim.mean(dim=0)[:,:,1]\n",
    "print(mean_ssim.size())\n",
    "\n",
    "\n",
    "fig = plt.figure()\n",
    "for idx_lbda, lbda1 in enumerate(lbda1_list):\n",
    "    plt.plot(std_list ,mean_ssim[:,idx_lbda].numpy(),label=r'$\\lambda_{1}=$'+'{0}'.format(lbda1),color=color_lbda[idx_lbda])\n",
    "\n",
    "plt.plot(std_list,mean_ssim_baseline.numpy(), label='baseline',color='black')\n",
    "\n",
    "plt.plot([0.0,1.8],[1.5,1.5], linewidth=3, color=color_lbda[0])\n",
    "plt.plot([1.9,3.5],[1.5,1.5], linewidth=3, color=color_lbda[1])\n",
    "plt.plot([3.6,5],[1.5,1.5], linewidth=3, color=color_lbda[2])\n",
    "          \n",
    "plt.yscale(\"log\")\n",
    "plt.ylabel('SSIM', fontsize=15, labelpad=10)\n",
    "plt.ylim((0,2))\n",
    "plt.xlabel('noise std ' + r'$(\\sigma)$', fontsize=15, labelpad=10)\n",
    "plt.xticks(std_list, fontsize=15)\n",
    "plt.yticks([0.01,0.05,0.1,0.5,1], \\\n",
    "           [r'$1.10^{-2}$',r'$5.10^{-2}$',r'$1.10^{-1}$',r'$5.10^{-1}$',r'$1$'], fontsize=15)\n",
    "if save_fig == True:\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('Savings/Fig/Fig13/Fig13b.png',\\\n",
    "                bbox_inches = 'tight', pad_inches = 0, dpi= 400)\n",
    "\n",
    "#plt.legend(loc='lower center',bbox_to_anchor=(0.5, -0.5),ncol=6,fontsize=15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}