neural_style_transfer_v8.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import os,datetime\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "from vgg import vgg_structure,file_vgg_read\n",
    "from sklearn.cluster import KMeans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Image_Preprocess(object):\n",
    "    '''Class for pre-processing content & style images and initialize target image.\n",
    "    \n",
    "    Attributes:\n",
    "        content_image : (H,W,C) np.float32 array\n",
    "        style_image : (H,W,C) np.float32 array\n",
    "        \n",
    "        target_mask_image : (H,W,C) np.float32 array\n",
    "        style_mask_image : (H,W,C) np.float32 array\n",
    "        target_masks_origin: (n_masks,H,W) np.float32 array\n",
    "        style_masks_origin: (n_masks,H,W) np.float32 array\n",
    "        \n",
    "    '''\n",
    "    \n",
    "    def __init__(self, content_path, style_path, \\\n",
    "                 target_width, target_height, \\\n",
    "                 #Parameters only related to guided style transfer\n",
    "                 Kmeans_or_NOT = False, \\\n",
    "                 content_mask_path = None, \\\n",
    "                 style_mask_path = None, \\\n",
    "                 mask_n_colors = None, \\\n",
    "                ):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            content_path (str) : file path to content image\n",
    "            style_path (str)   : file path to style image\n",
    "            target_width (int) : desired width of target image\n",
    "            target_height (int): desited height of target image\n",
    "            noise_ratio (float): in range [0,1], percentage of uniform noise to mix into \n",
    "                                    target image initialization.\n",
    "\n",
    "        \"\"\"\n",
    "        content_tensor = self.get_image(content_path)\n",
    "        style_tensor = self.get_image(style_path)\n",
    "        self.content_image = self.resized_image(content_tensor, target_width, target_height)\n",
    "        self.style_image = self.resized_image(style_tensor, target_width, target_height)\n",
    "        # deduct by the color intensity of each pixel by the mean-center given by vgg\n",
    "        self.content_image -= np.array([[[123.68 , 116.779, 103.939]]],dtype=np.float32)\n",
    "        self.style_image -= np.array([[[123.68 , 116.779, 103.939]]],dtype=np.float32)\n",
    "        \n",
    "        if Kmeans_or_NOT:\n",
    "            # read masks\n",
    "            content_mask_tensor = self.get_image(content_mask_path)\n",
    "            style_mask_tensor = self.get_image(style_mask_path)\n",
    "            content_mask = self.resized_image(content_mask_tensor, \\\n",
    "                                                target_width, target_height)\n",
    "            style_mask = self.resized_image(style_mask_tensor, \\\n",
    "                                              target_width, target_height)\n",
    "            # deduct by the color intensity of each pixel by the mean-center given by vgg\n",
    "            self.target_mask_image = content_mask - np.array([[[123.68 , 116.779, 103.939]]],dtype=np.float32)\n",
    "            self.style_mask_image =  style_mask -np.array([[[123.68 , 116.779, 103.939]]],dtype=np.float32)\n",
    "            \n",
    "            # turn into nparray of shape (H*W,3)\n",
    "            content_mask_resize = content_mask.reshape(content_mask.shape[0]*content_mask.shape[1], -1)\n",
    "            style_mask_resize = style_mask.reshape(style_mask.shape[0]*style_mask.shape[1], -1)\n",
    "            \n",
    "            # K-means for style image and target image\n",
    "            kmeans = KMeans(n_clusters=mask_n_colors, random_state=0).fit(style_mask_resize)\n",
    "            \n",
    "            target_labels = kmeans.predict(content_mask_resize.astype(np.float32))\n",
    "            target_labels = target_labels.reshape([content_mask.shape[0], content_mask.shape[1]])\n",
    "            style_labels = kmeans.predict(style_mask_resize.astype(np.float32))\n",
    "            style_labels = style_labels.reshape([style_mask.shape[0], style_mask.shape[1]])\n",
    "            #print(style_labels.shape)\n",
    "            target_masks = []\n",
    "            style_masks = []\n",
    "            \n",
    "            for i in range(mask_n_colors):\n",
    "                target_masks.append((target_labels == i).astype(np.float32))\n",
    "                style_masks.append((style_labels == i).astype(np.float32))\n",
    "                \n",
    "            self.target_masks_origin = np.stack(target_masks)\n",
    "            self.style_masks_origin = np.stack(style_masks)\n",
    "            \n",
    "            #print(self.target_masks_origin.shape,self.target_masks_origin.dtype)\n",
    "            #print(self.style_masks_origin.shape,self.style_masks_origin.dtype)\n",
    "\n",
    "        \n",
    "    def get_image(self, image_path):\n",
    "        '''get image TF tensor.\n",
    "        \n",
    "        Returns:\n",
    "            dtype = (H_origial,W_original,C) tf.float32 tensor\n",
    "            \n",
    "        '''\n",
    "        image_raw = tf.read_file(image_path)\n",
    "        image_tensor = tf.image.decode_image(image_raw)\n",
    "        return image_tensor\n",
    "    \n",
    "    def resized_image(self, image_tensor, target_width, target_height):\n",
    "        '''get the resized image nparray.\n",
    "        \n",
    "        Returns:\n",
    "            dtype= (H,W,C) np.float32 array\n",
    "            \n",
    "        '''\n",
    "        #TODO: TENSORFLOW HAS VAGUE RESHAPE BAHAVIOR, change to PIL and CROP?\n",
    "        with tf.Session() as sess:\n",
    "            image = sess.run(image_tensor)\n",
    "            resized_image = sess.run(tf.image.resize_images(image, (target_width, target_height)))\n",
    "        return resized_image\n",
    "    \n",
    "\n",
    "    def initialize_sythetic_image(self, noise_ratio):\n",
    "        '''Random uniform initialization mixed with content\n",
    "        \n",
    "        Returns:\n",
    "            dtype= (1,H,W,C) np.float32 array. Note the dimension padding.\n",
    "            \n",
    "        '''\n",
    "        noise_image = np.random.uniform(low=0,high= 256,size= self.content_image.shape).astype(np.float32)\n",
    "        noise_image -= np.array([[[123.68 , 116.779, 103.939]]],dtype=np.float32)\n",
    "        \n",
    "        return np.expand_dims(noise_image * noise_ratio + self.content_image * (1 - noise_ratio),axis=0)\n",
    "\n",
    "\n",
    "def save(path, image_unnormalized_nparray):\n",
    "    '''add back VGG-19 pixel avgs to a processed image represented by a \n",
    "    (H,W,C) np.float32 array and save it to path'''\n",
    "    \n",
    "    print('adding back pixel averages and saving image to',path)\n",
    "    image = image_unnormalized_nparray + np.array([[[123.68 , 116.779, 103.939]]],dtype=np.float32)\n",
    "    print('RGB avg of this image:',np.mean(image,axis=(0,1)))\n",
    "    #print(image.dtype)\n",
    "    #avoid overflow of colors, valid range [0,255] inclusive\n",
    "    image[image>255] = 255\n",
    "    image[image<0] = 0\n",
    "    im = Image.fromarray(np.rint(image).astype(np.uint8))\n",
    "    im.save(path)\n",
    "\n",
    "def make_dir(path):\n",
    "    '''create the dir to save data'''\n",
    "    if os.path.isdir(path):  \n",
    "        print('dir '+path+' exists, no need to create it.')\n",
    "        pass\n",
    "    else:\n",
    "        print('dir '+path+' did not exist, now created')\n",
    "        os.mkdir(path)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss Functions, without Kmeans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the content_loss\n",
    "def content_loss(content_image_l, process_image_l):\n",
    "    '''Content loss for one layer\n",
    "    Args:\n",
    "        c_tensor: (B,H,W,C) tf.float32 tensor from style image\n",
    "        p_tensor: (B,H,W,C) tf.float32 tensor from target image\n",
    "        \n",
    "    Returns:\n",
    "        tf.float32 scalar, content loss in one layer\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    diff = content_image_l - process_image_l;\n",
    "    denominator = tf.cast(tf.size(content_image_l), tf.float32)\n",
    "    \n",
    "    return tf.nn.l2_loss(diff)/denominator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the style loss\n",
    "def style_loss(s_tensor, p_tensor):\n",
    "    '''Style loss for one layer.\n",
    "    \n",
    "    Args:\n",
    "        s_tensor: (B,H,W,C) tf.float32 tensor from style image\n",
    "        p_tensor: (B,H,W,C) tf.float32 tensor from target image\n",
    "        \n",
    "    Returns:\n",
    "        tf.float32 scalar, style loss in one layer\n",
    "        \n",
    "    '''\n",
    "    \n",
    "    shape_list = tf.shape(s_tensor) #get shape as a list of 4 tf.int32 numbers\n",
    "    \n",
    "    M = shape_list[1] * shape_list[2]; N = shape_list[3]\n",
    "    denominator = tf.cast(2*M*N*N,dtype=tf.float32)\n",
    "    \n",
    "    s_tensor_2d = tf.reshape(s_tensor[0], (M, N))\n",
    "    s_gram = tf.matmul(tf.transpose(s_tensor_2d), s_tensor_2d)\n",
    "\n",
    "    p_tensor_2d = tf.reshape(p_tensor[0], (M, N))\n",
    "    p_gram = tf.matmul(tf.transpose(p_tensor_2d), p_tensor_2d)\n",
    "    \n",
    "    diff = (s_gram-p_gram)/denominator\n",
    "    #denominator = tf.cast(tf.size(content_image_l), tf.float32)\n",
    "\n",
    "    return tf.nn.l2_loss(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variation_loss(p_tensor):\n",
    "    '''Variational loss for smoothing\n",
    "    \n",
    "    Args:\n",
    "        p_tensor: (B,H,W,C) tf.float32 tensor from target image\n",
    "        \n",
    "    Returns:\n",
    "        tf.float32 scalar, variational loss of image tensor\n",
    "    \n",
    "    '''\n",
    "    shape_list = tf.shape(p_tensor) #get shape as a list of 4 tf.int32 numbers\n",
    "    \n",
    "    H = shape_list[1]; W = shape_list[2]; C = shape_list[3]\n",
    "    #difference between adjacent pixels along height, normalized\n",
    "    diff1 = (p_tensor[:,1:,:,:] - p_tensor[:,:H-1,:,:])/tf.cast(H*C,tf.float32)\n",
    "    #difference between adjacent pixels along width, normalized\n",
    "    diff2 = (p_tensor[:,:,1:,:] - p_tensor[:,:,:W-1,:])/tf.cast(W*C,tf.float32)\n",
    "    \n",
    "    #use l2 norm\n",
    "    return tf.reduce_sum(tf.abs(diff1)) + tf.reduce_sum(tf.abs(diff2))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_loss(content_vgg,style_vgg,\n",
    "             layer_list_content, layer_list_style, image_group, \n",
    "             process_image,w_c,w_s, \n",
    "             content_weight, style_weight, variation_weight):\n",
    "    '''Compute total loss.\n",
    "    \n",
    "    Args:\n",
    "        process_image:  (B,H,W,C) tf.float32 tensor that we want to optimize over\n",
    "    \n",
    "    Returns:\n",
    "        total loss = content_weight*(sum(w_c*content_loss))+style_weight*(sum(w_s*style_loss))\n",
    "    \n",
    "    '''\n",
    "    process_vgg = vgg_structure()\n",
    "    process_vgg.build(process_image,layers_info)\n",
    "\n",
    "    # calculating content loss for output of layers in layer_list_content\n",
    "    contentloss = 0\n",
    "    i = 0\n",
    "    for layer_name in layer_list_content:\n",
    "        output_content = getattr(content_vgg, layer_name) \n",
    "        output_process = getattr(process_vgg, layer_name) \n",
    "        contentloss += w_c[i] * content_loss(output_content,output_process)\n",
    "        i += 1\n",
    "    #contentloss /= float(sum(w_c))\n",
    "    \n",
    "    # calculating content loss for output of layers in layer_list_style    \n",
    "    styleloss = 0\n",
    "    i = 0\n",
    "    for layer_name in layer_list_style:\n",
    "        output_style   = getattr(style_vgg,   layer_name) \n",
    "        output_process = getattr(process_vgg, layer_name) \n",
    "        styleloss += w_s[i]*style_loss(output_style, output_process)\n",
    "        i += 1\n",
    "    #styleloss /= float(sum(w_s))\n",
    "    \n",
    "    varloss = variation_loss(process_image)\n",
    "    \n",
    "    return content_weight * contentloss + style_weight * styleloss + variation_weight*varloss\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss functions, with Kmeans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the loss based on K-means\n",
    "# Special cases for with k means\n",
    "def masked_gram(x, mx, mask_norm, N):\n",
    "    \"\"\"\n",
    "    x = style_features or target_net\n",
    "    mx = style_masks or target_masks\n",
    "    mask_norm = mask normalization type\n",
    "    \n",
    "    \"\"\"\n",
    "    R, a, b = mx.shape # [numberOfMasks, h, w]\n",
    "    M = a * b\n",
    "\n",
    "    # TODO: use local variable?\n",
    "    mx = tf.reshape(mx, [R, M])\n",
    "    x = tf.reshape(x, [M, N])\n",
    "    x = tf.transpose(x) # N * M\n",
    "    masked_gram = []\n",
    "    for i in range(R):\n",
    "        mask = mx[i]\n",
    "        #print(mask.shape)\n",
    "        masked_x = x * mask\n",
    "        if mask_norm == 'square_sum':\n",
    "            K = 1. / tf.cast(tf.math.reduce_sum(tf.math.square(mask)), tf.float32)\n",
    "        elif mask_norm == 'sum':\n",
    "            K = 1. / tf.cast(tf.math.reduce_sum(mask), tf.float32)\n",
    "        gram = K * tf.matmul(masked_x, tf.transpose(masked_x))\n",
    "        masked_gram.append(gram)\n",
    "    return tf.stack(masked_gram)\n",
    "\n",
    "#if k means\n",
    "def masked_style_layer_loss(a, ma, x, mx, mask_norm):\n",
    "    ma = tf.transpose(ma[0], perm=[2,0,1]) # [numberOfMasks, h, w]\n",
    "    mx = tf.transpose(mx[0], perm=[2,0,1]) # [numberOfMasks, h, w]\n",
    "    _, _, _, N = a.get_shape()\n",
    "    R, _, _ = ma.shape\n",
    "    #K = 1. / tf.cast(4 * N * N * R, tf.float32)\n",
    "    A = masked_gram(a, ma, mask_norm, N)\n",
    "    G = masked_gram(x, mx, mask_norm, N)\n",
    "    \n",
    "    denominator = tf.cast(R*N*N,dtype=tf.float32)\n",
    "    diff = (A-G)/denominator\n",
    "    \n",
    "    #loss = K * tf.reduce_sum( tf.pow((G - A), 2) )\n",
    "    return tf.nn.l2_loss(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the sum loss   \n",
    "def sum_loss_with_mask(content_vgg,style_vgg,style_mask_vgg, target_mask_vgg, mask_norm,\n",
    "                       layer_list_content, layer_list_style, \n",
    "                       image_group, target_image,\n",
    "                       w_c,w_s,\n",
    "                       content_weight, style_weight, variation_weight):\n",
    "    '''Compute total loss when using Kmeans.\n",
    "    \n",
    "    Args:\n",
    "        process_image:  (B,H,W,C) tf.float32 tensor that we want to optimize over\n",
    "    \n",
    "    Returns:\n",
    "        total loss = content_weight*(sum(w_c*content_loss))+style_weight*(sum(w_s*style_loss))\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    target_vgg = vgg_structure()\n",
    "    target_vgg.build(target_image,layers_info)\n",
    "\n",
    "    # calculating content loss for output of layers in layer_list_content\n",
    "    contentloss = 0\n",
    "    i = 0\n",
    "    for layer_name in layer_list_content:\n",
    "        output_content = getattr(content_vgg, layer_name) \n",
    "        output_process = getattr(target_vgg, layer_name) \n",
    "        contentloss += w_c[i] * content_loss(output_content,output_process)\n",
    "        i += 1\n",
    "    #contentloss /= float(sum(w_c))\n",
    "    \n",
    "    # calculating content loss for output of layers in layer_list_style    \n",
    "    styleloss = 0\n",
    "    i = 0\n",
    "    for layer_name in layer_list_style:\n",
    "        output_style   = getattr(style_vgg,   layer_name)\n",
    "        m_output_style = getattr(style_mask_vgg,   layer_name)\n",
    "        output_target  = getattr(target_vgg, layer_name) \n",
    "        m_output_target = getattr(target_mask_vgg, layer_name) \n",
    "        styleloss += w_s[i] * masked_style_layer_loss(output_style, m_output_style ,\n",
    "                                                      output_target, m_output_target,\n",
    "                                                      mask_norm)\n",
    "        i += 1\n",
    "    #styleloss /= float(sum(w_s))\n",
    "    \n",
    "    varloss = variation_loss(target_image)\n",
    "    \n",
    "    return content_weight * contentloss + style_weight * styleloss + variation_weight*varloss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'with tf. Session() as sess:\\n    sess.run(tf.global_variables_initializer())\\n    \\n    print(sess.run(sum_loss_with_mask(content_vgg,style_vgg,style_mask_vgg, target_mask_vgg, mask_normalization_type,\\n                       layer_list_content, layer_list_style, \\n                       image_group, process_image,\\n                       w_c,w_s,\\n                       content_weight, style_weight, variation_weight)))'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''with tf. Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    print(sess.run(sum_loss_with_mask(content_vgg,style_vgg,style_mask_vgg, target_mask_vgg, mask_normalization_type,\n",
    "                       layer_list_content, layer_list_style, \n",
    "                       image_group, process_image,\n",
    "                       w_c,w_s,\n",
    "                       content_weight, style_weight, variation_weight)))'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adjustable Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''Image settings.'''\n",
    "#save to a directory with today's date and run label\n",
    "output_dir_prefix = datetime.date.today().strftime('%m-%d-%Y') + \"_cat_restaurant_0\"\n",
    "\n",
    "content_path = \"image_with_mask/1000x800cat.jpg\"\n",
    "#style_path = \"image_with_mask/1880x1500-restaurant.jpg\"\n",
    "style_path = \"image_with_mask/1045x805-the-schelde-at-veere.jpg\"\n",
    "target_width = 400\n",
    "target_height = 500\n",
    "layers_info = file_vgg_read(\"imagenet-vgg-verydeep-19.mat\")\n",
    "\n",
    "# CNN layers info\n",
    "content_weight = 1e-2 # content weights for total content loss alpha kinda redundant\n",
    "style_weight = 1 # style weights for total style loss beta \n",
    "variation_weight= 1e-5 #variational weight for smoothing\n",
    "w_c = np.array([1],dtype=np.float32) # content weights for each layer\n",
    "w_s = np.array([1, 1, 1, 1, 1],dtype=np.float32) # style weights for each layer\n",
    "\n",
    "layer_list_content = [\"conv4_2\"]\n",
    "layer_list_style = [\"conv1_1\", \"conv2_1\", \"conv3_1\", \"conv4_1\", \"conv5_1\"]\n",
    "\n",
    "\n",
    "'''Optimization settings'''\n",
    "#How many iters of optimization?\n",
    "epoches = 401\n",
    "#Learning rate depends on optimizer choice\n",
    "lr = 10\n",
    "noise_ratio = 0.5 # initial noise #MIX content with uniform noise,noise_ratio*noise+(1-noise_ratio) * content\n",
    "\n",
    "# Record Image every 5 steps in the beginning of training, because it changes faster\n",
    "# in the initial phase than later.\n",
    "record_steps_early = 5\n",
    "record_steps_late = 20\n",
    "\n",
    "# Hyperparameters tuning\n",
    "lr_decay_or_NOT = True # True or False (Learning Rate Decay)\n",
    "optimizer_choice = \"adam\" #\"adam\", \"gradient_descent\", ####### NOT IMPLEMENTED\"momentum\"\n",
    "\n",
    "'''Guided Style trasfer settings'''\n",
    "Kmeans_or_NOT = False\n",
    "content_mask_path = \"image_with_mask/content_mask_6(2).png\"\n",
    "style_mask_path = \"image_with_mask/style_mask_6.png\"\n",
    "mask_n_colors = 2 # nbr of clusters for K-means\n",
    "mask_normalization_type = 'square_sum' #sum or square sum two options\n",
    "mask_downsample_type = 'simple' #what's options??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables set up for training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\kathe\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "dir 06-11-2019_cat_restaurant_0 did not exist, now created\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/reshaped_content.jpg\n",
      "RGB avg of this image: [122.6038  110.74236  94.96799]\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/reshaped_style.jpg\n",
      "RGB avg of this image: [158.81564 143.37299  98.30551]\n"
     ]
    }
   ],
   "source": [
    "# reset the tensorflow default graph\n",
    "tf.reset_default_graph()\n",
    "\n",
    "#global step (current training step, initialized as 0)\n",
    "global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name=\"global_step\")\n",
    "# global variables: preprocessed image_group\n",
    "image_group = Image_Preprocess(content_path = content_path, style_path = style_path, \\\n",
    "                               target_width = target_width, target_height = target_height, \\\n",
    "                               #parameters related to Kmeans only\n",
    "                               Kmeans_or_NOT = Kmeans_or_NOT, \\\n",
    "                               content_mask_path = content_mask_path, \\\n",
    "                               style_mask_path = style_mask_path, \\\n",
    "                               mask_n_colors = mask_n_colors)\n",
    "\n",
    "# global variable: this is what we want to optimize!\n",
    "process_image = tf.Variable(image_group.initialize_sythetic_image(noise_ratio), \\\n",
    "                            dtype=tf.float32, trainable = True, name = \"process_image\")\n",
    "\n",
    "# save source images before training occurs\n",
    "make_dir(output_dir_prefix)\n",
    "save(output_dir_prefix+'/reshaped_content.jpg',image_group.content_image)\n",
    "save(output_dir_prefix+'/reshaped_style.jpg',image_group.style_image)\n",
    "if Kmeans_or_NOT:\n",
    "    save(output_dir_prefix+'/reshaped_content_mask.jpg',image_group.target_mask_image)\n",
    "    save(output_dir_prefix+'/reshaped_style_mask.jpg',image_group.style_mask_image)\n",
    "\n",
    "# let content and style images go through the vgg net\n",
    "content_image = np.expand_dims(image_group.content_image.copy(),axis=0)\n",
    "style_image = np.expand_dims(image_group.style_image.copy(),axis=0)\n",
    "content_vgg = vgg_structure()\n",
    "content_vgg.build(content_image,layers_info)\n",
    "style_vgg = vgg_structure()\n",
    "style_vgg.build(style_image,layers_info)\n",
    "# extra stuff if Kmeans is applied\n",
    "if Kmeans_or_NOT:\n",
    "    target_masks_origin = image_group.target_masks_origin.copy()\n",
    "    target_masks_origin = target_masks_origin.transpose([1,2,0]) # [numberOfMasks, h, w] -> [h, w, masks]\n",
    "    target_masks_origin = target_masks_origin[np.newaxis, :]\n",
    "    \n",
    "    style_masks_origin = image_group.style_masks_origin.copy()\n",
    "    style_masks_origin = style_masks_origin.transpose([1,2,0]) # [numberOfMasks, h, w] -> [h, w, masks]\n",
    "    style_masks_origin = style_masks_origin[np.newaxis, :] \n",
    "    \n",
    "    target_mask_vgg = vgg_structure()\n",
    "    target_mask_vgg.buildmask(target_masks_origin, mask_downsample_type)\n",
    "\n",
    "    style_mask_vgg = vgg_structure()\n",
    "    style_mask_vgg.buildmask(style_masks_origin, mask_downsample_type)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parameters to record loss\n",
    "#\n",
    "loss_plot ={}\n",
    "\n",
    "def train(max_step = epoches, \n",
    "          record_steps_early = record_steps_early, \n",
    "          record_steps_late = record_steps_late,\n",
    "          learning_rate = lr, \n",
    "          lr_decay_or_NOT = lr_decay_or_NOT,\n",
    "          #layer_list_content = layer_list_content, \n",
    "          #layer_list_style = layer_list_style, \n",
    "          #w_c = w_c , w_s = w_s,\n",
    "          Kmeans_or_NOT = Kmeans_or_NOT,\n",
    "          optimizer_choice = optimizer_choice\n",
    "         ):\n",
    "    '''Minimize total loss function to obtain best syntheized image.\n",
    "    Args:\n",
    "        max_steps (int):          number of training epochs/iterations\n",
    "        record_steps_early(int):  interval for saving image in beginning of optimization\n",
    "        record_steps_late(int):   interval for saving image in end of optimization\n",
    "        learning_rate(float):     [initial] learning rate for optimizer\n",
    "        lr_decay_or_NOT(bool):    whether to use learning rate decay\n",
    "        Kmeans_or_NOT(bool):      whether to use Guided style transfer\n",
    "        optimizer_choice(string): 'adam' or 'gradient_descent'\n",
    "    '''\n",
    "    \n",
    "    if Kmeans_or_NOT:\n",
    "        print(\"Using masked loss...\")\n",
    "        #loss = sum_loss_with_mask(layer_list_content, layer_list_style,\n",
    "        #                          image_group, process_image,w_c, w_s,\n",
    "        #                          mask_normalization_type,content_weight,style_weight)\n",
    "        loss = sum_loss_with_mask(content_vgg,style_vgg,\n",
    "                                  style_mask_vgg, target_mask_vgg, mask_normalization_type,\n",
    "                                  layer_list_content, layer_list_style,\n",
    "                                  image_group, process_image,\n",
    "                                  w_c,w_s,\n",
    "                                  content_weight, style_weight, variation_weight)\n",
    "    else:\n",
    "        print(\"Using original loss...\")    \n",
    "        loss = sum_loss(content_vgg,style_vgg,\n",
    "                        layer_list_content, layer_list_style, \\\n",
    "                        image_group, process_image, \n",
    "                        w_c, w_s,content_weight,style_weight,variation_weight)\n",
    "        \n",
    "    if lr_decay_or_NOT:\n",
    "        print(\"Using learning rate decay...\")\n",
    "        starter_learning_rate = learning_rate\n",
    "        end_learning_rate = learning_rate/10\n",
    "        decay_steps = 500\n",
    "        learning_rate = tf.train.polynomial_decay(starter_learning_rate, global_step,\n",
    "                                          decay_steps, end_learning_rate,\n",
    "                                          power=1)\n",
    "        \n",
    "    # Optimizer\n",
    "    if optimizer_choice == \"gradient_descent\":\n",
    "        optimizer = tf.train.GradientDescentOptimizer(learning_rate)\n",
    "        print(\"Using GradientDescentOptimizer...\")\n",
    "    elif optimizer_choice == \"adam\":\n",
    "        optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "        print(\"Using AdamOptimizer...\")\n",
    "    ##elif optimizer_choice == \"momentum\":\n",
    "    #    optimizer = tf.train.MomentumOptimizer(learning_rate)\n",
    "    #    print(\"Using MomentumOptimizer...\")\n",
    "    else:\n",
    "        raise ValueError(\"Invalid optimizer.\")\n",
    "    \n",
    "    train_step = optimizer.minimize(loss, global_step = global_step,var_list = [process_image])\n",
    "\n",
    "    \n",
    "    with tf.Session() as sess:\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        \n",
    "        initial_step = global_step.eval()\n",
    "        print(\"training begin!\")\n",
    "        \n",
    "        for step in np.arange(initial_step, max_step):\n",
    "            #print('step',step)\n",
    "            \n",
    "            sess.run(train_step)\n",
    "            \n",
    "            if (step <= max_step//4 and step % record_steps_early == 0) or \\\n",
    "               (step > max_step//4 and step % record_steps_late == 0):\n",
    "                \n",
    "                if Kmeans_or_NOT:\n",
    "                    loss_val = sess.run(loss)\n",
    "                else:\n",
    "                    loss_val = sess.run(loss)\n",
    "                \n",
    "                loss_plot[step+1] = loss_val\n",
    "                print(\" \\n Step {}  Total loss: {:5.1f}\".format(step + 1, loss_val))\n",
    "                \n",
    "                result_image = sess.run(process_image)[0]\n",
    "                print(\"\\n Step {}   Sum of all pixels: {:5.1f}\".format(step + 1, np.sum(result_image)))\n",
    "                \n",
    "                # save the image during the training process\n",
    "                filename = output_dir_prefix+\"/step_%d.png\" % step\n",
    "                save(filename, result_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Go"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using original loss...\n",
      "Using learning rate decay...\n",
      "WARNING:tensorflow:From C:\\Users\\kathe\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\learning_rate_decay_v2.py:321: div (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Deprecated in favor of operator or tf.math.divide.\n",
      "Using AdamOptimizer...\n",
      "training begin!\n",
      " \n",
      " Step 1  Total loss: 1338.8\n",
      "\n",
      " Step 1   Sum of all pixels: 2372089.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_0.png\n",
      "RGB avg of this image: [125.66308 120.03325 110.56328]\n",
      " \n",
      " Step 6  Total loss: 650.8\n",
      "\n",
      " Step 6   Sum of all pixels: 2047100.4\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_5.png\n",
      "RGB avg of this image: [129.54169 123.49515 101.59804]\n",
      " \n",
      " Step 11  Total loss: 434.4\n",
      "\n",
      " Step 11   Sum of all pixels: 1737104.9\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_10.png\n",
      "RGB avg of this image: [134.67142 125.84694  92.56539]\n",
      " \n",
      " Step 16  Total loss: 333.9\n",
      "\n",
      " Step 16   Sum of all pixels: 1691804.4\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_15.png\n",
      "RGB avg of this image: [139.7409  127.08338  86.03218]\n",
      " \n",
      " Step 21  Total loss: 288.5\n",
      "\n",
      " Step 21   Sum of all pixels: 1878522.4\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_20.png\n",
      "RGB avg of this image: [144.04665 127.98681  81.75551]\n",
      " \n",
      " Step 26  Total loss: 262.0\n",
      "\n",
      " Step 26   Sum of all pixels: 2237660.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_25.png\n",
      "RGB avg of this image: [147.29588 128.7353   79.55705]\n",
      " \n",
      " Step 31  Total loss: 243.5\n",
      "\n",
      " Step 31   Sum of all pixels: 2690130.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_30.png\n",
      "RGB avg of this image: [149.51994 129.45927  78.86893]\n",
      " \n",
      " Step 36  Total loss: 232.8\n",
      "\n",
      " Step 36   Sum of all pixels: 3166536.8\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_35.png\n",
      "RGB avg of this image: [150.91132 130.2124   79.10554]\n",
      " \n",
      " Step 41  Total loss: 224.3\n",
      "\n",
      " Step 41   Sum of all pixels: 3632605.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_40.png\n",
      "RGB avg of this image: [151.725   130.96364  79.87556]\n",
      " \n",
      " Step 46  Total loss: 218.2\n",
      "\n",
      " Step 46   Sum of all pixels: 4073983.8\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_45.png\n",
      "RGB avg of this image: [152.19533 131.6903   80.88075]\n",
      " \n",
      " Step 51  Total loss: 213.4\n",
      "\n",
      " Step 51   Sum of all pixels: 4484386.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_50.png\n",
      "RGB avg of this image: [152.50813 132.3768   81.93551]\n",
      " \n",
      " Step 56  Total loss: 211.3\n",
      "\n",
      " Step 56   Sum of all pixels: 4861204.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_55.png\n",
      "RGB avg of this image: [152.77399  132.99277   82.936676]\n",
      " \n",
      " Step 61  Total loss: 210.4\n",
      "\n",
      " Step 61   Sum of all pixels: 5200051.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_60.png\n",
      "RGB avg of this image: [153.04721 133.52634  83.82751]\n",
      " \n",
      " Step 66  Total loss: 208.3\n",
      "\n",
      " Step 66   Sum of all pixels: 5502044.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_65.png\n",
      "RGB avg of this image: [153.29517 133.97916  84.63553]\n",
      " \n",
      " Step 71  Total loss: 206.4\n",
      "\n",
      " Step 71   Sum of all pixels: 5771422.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_70.png\n",
      "RGB avg of this image: [153.5712  134.40019  85.28254]\n",
      " \n",
      " Step 76  Total loss: 203.8\n",
      "\n",
      " Step 76   Sum of all pixels: 6023372.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_75.png\n",
      "RGB avg of this image: [153.88193 134.79208  85.83945]\n",
      " \n",
      " Step 81  Total loss: 202.0\n",
      "\n",
      " Step 81   Sum of all pixels: 6255492.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_80.png\n",
      "RGB avg of this image: [154.20052 135.16736  86.30828]\n",
      " \n",
      " Step 86  Total loss: 200.5\n",
      "\n",
      " Step 86   Sum of all pixels: 6473454.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_85.png\n",
      "RGB avg of this image: [154.50684 135.49985  86.76072]\n",
      " \n",
      " Step 91  Total loss: 199.5\n",
      "\n",
      " Step 91   Sum of all pixels: 6678123.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_90.png\n",
      "RGB avg of this image: [154.7867  135.81354  87.18844]\n",
      " \n",
      " Step 96  Total loss: 199.2\n",
      "\n",
      " Step 96   Sum of all pixels: 6870730.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_95.png\n",
      "RGB avg of this image: [155.04033 136.10233  87.60829]\n",
      " \n",
      " Step 101  Total loss: 201.0\n",
      "\n",
      " Step 101   Sum of all pixels: 7052524.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_100.png\n",
      "RGB avg of this image: [155.27165 136.37025  88.01977]\n",
      " \n",
      " Step 121  Total loss: 196.2\n",
      "\n",
      " Step 121   Sum of all pixels: 7668295.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_120.png\n",
      "RGB avg of this image: [155.96487 137.31026  89.4656 ]\n",
      " \n",
      " Step 141  Total loss: 195.7\n",
      "\n",
      " Step 141   Sum of all pixels: 8173356.5\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_140.png\n",
      "RGB avg of this image: [156.51799 138.0611   90.68677]\n",
      " \n",
      " Step 161  Total loss: 194.4\n",
      "\n",
      " Step 161   Sum of all pixels: 8586362.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_160.png\n",
      "RGB avg of this image: [156.95724 138.68181  91.69012]\n",
      " \n",
      " Step 181  Total loss: 197.7\n",
      "\n",
      " Step 181   Sum of all pixels: 8943363.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_180.png\n",
      "RGB avg of this image: [157.33792 139.20029  92.57628]\n",
      " \n",
      " Step 201  Total loss: 193.2\n",
      "\n",
      " Step 201   Sum of all pixels: 9229217.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_200.png\n",
      "RGB avg of this image: [157.5473  139.61205  93.38553]\n",
      " \n",
      " Step 221  Total loss: 193.1\n",
      "\n",
      " Step 221   Sum of all pixels: 9491649.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_220.png\n",
      "RGB avg of this image: [157.83421 139.99277  94.02796]\n",
      " \n",
      " Step 241  Total loss: 191.6\n",
      "\n",
      " Step 241   Sum of all pixels: 9703098.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_240.png\n",
      "RGB avg of this image: [158.01497 140.30533  94.59345]\n",
      " \n",
      " Step 261  Total loss: 196.1\n",
      "\n",
      " Step 261   Sum of all pixels: 9850210.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_260.png\n",
      "RGB avg of this image: [157.92323 140.46193  95.26662]\n",
      " \n",
      " Step 281  Total loss: 193.1\n",
      "\n",
      " Step 281   Sum of all pixels: 9967464.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_280.png\n",
      "RGB avg of this image: [158.12488 140.69617  95.41466]\n",
      " \n",
      " Step 301  Total loss: 194.3\n",
      "\n",
      " Step 301   Sum of all pixels: 10108022.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_300.png\n",
      "RGB avg of this image: [158.3399  140.9166   95.68095]\n",
      " \n",
      " Step 321  Total loss: 190.7\n",
      "\n",
      " Step 321   Sum of all pixels: 10212076.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_320.png\n",
      "RGB avg of this image: [158.42899 141.0622   95.96583]\n",
      " \n",
      " Step 341  Total loss: 191.6\n",
      "\n",
      " Step 341   Sum of all pixels: 10298251.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_340.png\n",
      "RGB avg of this image: [158.5083  141.1719   96.21023]\n",
      " \n",
      " Step 361  Total loss: 190.3\n",
      "\n",
      " Step 361   Sum of all pixels: 10360821.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_360.png\n",
      "RGB avg of this image: [158.60323 141.27269  96.3251 ]\n",
      " \n",
      " Step 381  Total loss: 192.8\n",
      "\n",
      " Step 381   Sum of all pixels: 10412073.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_380.png\n",
      "RGB avg of this image: [158.57382 141.31636  96.56873]\n",
      " \n",
      " Step 401  Total loss: 192.0\n",
      "\n",
      " Step 401   Sum of all pixels: 10401356.0\n",
      "adding back pixel averages and saving image to 06-11-2019_cat_restaurant_0/step_400.png\n",
      "RGB avg of this image: [158.50763 141.30098  96.59698]\n"
     ]
    }
   ],
   "source": [
    "train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Plot total loss vs. iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save total loss\n",
    "np.savetxt(output_dir_prefix+\"/total_loss.dat\", [list(loss_plot.keys()), list(loss_plot.values())], delimiter=',') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAx8AAAIxCAYAAAAsdQVXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XmYXGWdt/H7l+50J92dhGysCUQMICAqEDYREgUUR6IgMCoqLq+guI/7OIyi4jZuOG6jI4zjwoiionFDFgOiggQQWURBDEtYk0BId9Lp7Xn/OJXQNr1Vd9U51dX357pynapTzzn160r/Ud9+tkgpIUmSJEnVNqXoAiRJkiRNDoYPSZIkSbkwfEiSJEnKheFDkiRJUi4MH5IkSZJyYfiQJEmSlAvDhyRJkqRcGD4kSZIk5cLwIUmSJCkXhg9JkiRJuWgsugBVz7x589KiRYtyfc+Ojg5aW1tzfc+JzM+rPH5e5fHzKo+fV3n8vMrnZ1YeP6/yFP15XXfddWtTSvNHamf4qGOLFi1i1apVub7nypUrWbZsWa7vOZH5eZXHz6s8fl7l8fMqj59X+fzMyuPnVZ6iP6+IuGs07Rx2JUmSJCkXhg9JkiRJuTB8SJIkScqF4UOSJElSLgwfkiRJknJh+JAkSZKUC8OHJEmSpFwYPiRJkiTlwvAhSZIkKReGD0mSJEm5MHxIkiRJyoXhQ5IkSVIuDB+SJEmScmH4kCRJkpQLw4ckSZKkXBg+JEmSJOXC8CFJkiQpF41FF6D6sOTsS1jb3pU9+eXPtp2f19bEqjOPKagqSZIk1RJ7PlQR24LHKM9LkiRp8jF8SJIkScqF4UOSJElSLgwfkiRJknJh+JAkSZKUC8OHKmJeW1NZ5yVJkjT5uNSuKmLrcrorV65k2bJlxRYjSZKkmmTPhyRJkqRcGD4kSZIk5cJhV6qohzb1cfWd69jU1cNeO85kl+2mF12SJEmSaoThQxX10zu7ufLKqwH4+Iv342UH71pwRZIkSaoVDrtSRTU3PP64Y0tPcYVIkiSp5tjzoYrasXUKBy+aQ0tzAzs75EqSJEn9GD5UUUftOpWPLDus6DIkSZJUgxx2JUmSJCkXhg9JkiRJuTB8SJIkScqFcz5UUe1diV/f9hCbunqZMa2RI/ecX3RJkiRJqhGGD1XUmvY+Pv6NawFYsttsw4ckSZK2cdiVKmpavzjb0dVbXCGSJEmqOfZ8qKLapgZL95xPS1MDu85pKbocSZIk1RDDhypq7vQp/O9rDy66DEmSJNUgh11JkiRJyoXhQ5IkSVIuDB+SJEmScuGcD1XcZX9+kPUdXWzq6uWkAxfQ2uyvmSRJkgwfqoKzVtzCPes3A7Bsr/mGD0mSJAEOu1IVtEx9PGx0bHGvD0mSJGX8k7Qq7jl7b8++u8yktamRGdP8FZMkSVLGb4aquPce+5SiS5AkSVINctiVJEmSpFwYPiRJkiTlwvAhSZIkKRfO+VDF/eneR/njPY+yqauXA3ebzUGL5hRdkiRJkmqA4UMVd/ltD3HOpbcD8NbnLDZ8SJIkCXDYlaqgtanfPh9d7vMhSZKkjD0fqrh9d57JKw7dlZamRg6210OSJEklhg9V3DMXz+OZi+cVXYYkSZJqjMOuJEmSJOXC8CFJkiQpF4YPSZIkSblwzocq7tFNXVxw7T10dPXS0tTAG5Y+ueiSJEmSVAMMH6q4jZ09fPwXtwGwy3bTDR+SJEkCHHalKmhtfjzTburqKbASSZIk1RJ7PlRxbc2NnH7k7kyf2sDM6VOLLkeSJEk1wvChimtqnML7/2nvosuQJElSjXHYlSRJkqRcGD4kSZIk5cLwIUmSJCkXzvlQVXznmrtYvbaDjq5e3nDkk9l1bkvRJUmSJKlghg9VxY9vuI8/rF4PwAufvrPhQ5IkSQ67UnW0NDdse+xeH5IkSQJ7PlQlJx24gMN2n0tLcyN7bD+j6HIkSZJUAwwfqorjnrZz0SVIkiSpxjjsSpIkSVIuDB+SJEmScmH4kCRJkpQL53yoKq5dvZ6LbljD5q5eDtl9Di85aNeiS5IkSVLB7PmoYRHx4oi4KiLWRkRnRPwtIj4dEbOKrm0kdz7czneuuZsf3rCGVasfKbocSZIk1QB7PmrbHOBK4LPAemA/4IPA04DnFljXiFqaHv/V2tTVW2AlkiRJqhWGjxqWUvr6gFMrI6IT+FpE7JxSuq+IukbjaQtm8ZEX7cv0pkZ2c3dzSZIkYfiYiNaVjlMLrWIEu81t5ZWHtRZdhiRJkmqIcz7KFBF7RcTbIuLbEXFbRPRFRIqIk0Zx7SkR8ZuI2BAR7RGxKiLeFBHD/j9ERENETIuIA4EPACtSSndV6meSJEmS8mDPR/nOAN5W7kUR8SXgjUAncBnQDRwFfBE4KiJOTikNNTliHbB1kvkvgZeV+/6SJElS0ez5KN/NwKeAlwCLgStGuiAiTiQLHg8AT0spHZdSOgHYA/gzcALw5mFusQw4HHg9sC+wIiIaxvEzSJIkSbmz56NMAyeBR8RoLvvX0vG9KaXb+93rwYg4A1gJvC8ivpBS6hvkPf9Yevi7iLgOWEUWWC4s/yfIR2d3L+//0U1s2tJLX0p87dQlRZckSZKkghk+qiwiFgAHAl3A9we+nlK6IiLWALsAhwK/G+GWfwT6yHpdalbDlOCH16/Z9jilNNqgJkmSpDrlsKvq2790vCWltHmINtcOaDucw8n+3+4cb2HVNLVhCk2N2a9Xb19iS88TOnQkSZI0yURKqegaJrSIWAksBU5OKT1hGFREvBX4PHBRaZ7HYPf4PPBW4DMppXf1O38x2eT0W4AtZOHk3cD9wEEppa5B7nU6cDrADjvscOB3v/vdcf185Wpvb6etrQ2A39/XQ+MUaG6AfeY20DjFno+B+n9eGpmfV3n8vMrj51UeP6/y+ZmVx8+rPEV/Xs9+9rOvSymNOM7eYVfVt/W3oGOYNu2l44wB568BXgE8qfR8NfBl4LODBQ+AlNLXgK8BLFmyJC1btqz8isdh5cqVbH3PfN95Yur/eWlkfl7l8fMqj59Xefy8yudnVh4/r/JMlM/L8FF9W//cX3YXU0rpA2T7ekiSJEkTnnM+qm9j6ThcP9jW1zYO00aSJEma0Awf1be6dNxtmDYLB7SVJEmS6o7DrqrvhtJx34iYPsSKVwcNaFsXvrzyDq6+cz2bu3r4l2P25JlPnld0SZIkSSqQPR9VllK6B7geaAJOHvh6RCwFFpDtfv77fKurrtvu38iVf32Ya1c/woOPdRZdjiRJkgpm+MjHx0vHT0bEts0BI2J7stWrAD4x2O7mE1lrc8O2x5u6egusRJIkSbXAYVdliogDeDwwAOxTOn4sIrbt0ZFSOrTf4wsj4ivAGcBNEXEp0A0cBcwELgK+WO3a8/bKQxfx3H13pGVqA0+a31p0OZIkSSqY4aN8M4FDBjm/x3AXpZTeGBFXAW8i25SwAbgNOA/4Sr31egDss/NM9mFm0WVIkiSpRhg+ypRSWsnje3eUe+35wPkVLUiSJEmaIJzzIUmSJCkXhg9JkiRJuXDYlapm1er1/Mcv/0JHVw8H7jabD7/oqUWXJEmSpAIZPlQ1HV29/GH1egDmtDYVXI0kSZKK5rArVU1r0+P7fHRs6SmwEkmSJNUCez5UNXvuOIPvnn4orU2NbNcytehyJEmSVDDDh6pm5rSpHLr73KLLkCRJUo1w2JUkSZKkXBg+JEmSJOXC8CFJkiQpF875UFX983/9nrXtW9jU1cul71xKW7O/cpIkSZOV3wRVVXeu7WBt+xYANm3pMXxIkiRNYg67UlW1Nvfb66Ort8BKJEmSVDT/DF2HImI5sHzx4sVFl8LXXrmEhinQ0tTI9jOaiy5HkiRJBbLnow6llFaklE6fNWtW0aWw144zWLz9DHbebjqNDf66SZIkTWZ+G5QkSZKUC8OHJEmSpFwYPiRJkiTlwgnnqqrPX3o73732bjq29PDuY5/CKw/dreiSJEmSVBDDh6pqU3cP92/oBGBjZ3fB1UiSJKlIDrtSVbU2PZ5vN21xnw9JkqTJzJ4PVdWph+3GiQcuoLWpgVZ3N5ckSZrU/DaoqtqupYntWoquQpIkSbXAYVeSJEmScmH4kCRJkpQLw4dy09uXii5BkiRJBXLOh6rqlvs2cMp/X8Omrh723mkmP3nzs4ouSZIkSQUxfKiqmhqmsGFztr9Hx5aegquRJElSkRx2paqa3tSw7fGWnr4CK5EkSVLR7PlQVe00azo3/PsxtDQ30NRg1pUkSZrMDB+qqoYpwezWpqLLkCRJUg3wT9GSJEmScmH4kCRJkpQLw4dy0d3bx4bN3fT0OulckiRpsnLOh6ru2HOu5LYHNgJwyb8cyR47zCi4IkmSJBXBng9V3dR+q1xt6uotsBJJkiQVyZ4PVV1LUwNTAlqbGul22JUkSdKkZfhQ1X3r/x3C1IYgIoouRZIkSQUyfKjqmhod3SdJkiTnfEiSJEnKieGjDkXE8oj42oYNG4ouRZIkSdrG8FGHUkorUkqnz5o1q+hSAOjtSzzW2c0DGzp5dFNX0eVIkiSpIM75UNX91xV/41MX/wWANyx9Mu97/lMKrkiSJElFsOdDVdfa1LDt8aaungIrkSRJUpHs+VDVtU2bSltzIy1NDUyf2jDyBZIkSapLhg9V3UkHLuCkAxcUXYYkSZIK5rArSZIkSbkwfEiSJEnKheFDkiRJUi6c86Gq6+1LrG3fQseWHnr6EnvuMKPokiRJklQAw4eqbm37Fg752GUAzJ/RzLX/dnTBFUmSJKkIDrtS1bX03+dji/t8SJIkTVb2fKjqWpoamdfWTGtzA61NjaSUiIiiy5IkSVLODB+quoYpwaozHWolSZI02TnsSpIkSVIuDB+SJEmScmH4kCRJkpQL53woF/dv2Mz6ji42dfWy5/YzmNUyteiSJEmSlDPDh3Lx7u//iavuWAvAN197MEfuOb/giiRJkpQ3h10pF9P77/XR5V4fkiRJk5E9H8rFbnNaeMqOM2htbqS12V87SZKkychvgcrFmcftU3QJkiRJKpjDriRJkiTlwvAhSZIkKReGD0mSJEm5cM6HcrG+o4u/r22nY0svc1qbeOous4ouSZIkSTkzfCgXV/z1If7lghsBOP4ZO3POS/cvuCJJkiTlzWFXykVL0+M5t6Ort8BKJEmSVBR7PpSL+TOaOWDX7WhtbmTvnWYWXY4kSZIKYPhQLg7YdTY/fOPhRZchSZKkAjnsSpIkSVIuDB91KCKWR8TXNmzYUHQpkiRJ0jaGjzqUUlqRUjp91iyXs5UkSVLtcM6HctHXl/jt39bSsaWXzu5ejt9/l6JLkiRJUs4MH8pFBJx63h9IKXt+3NN2orHBjjdJkqTJxG9/ykVE0Npvr49N3e71IUmSNNnY86HcLN1zPl29fbQ2NWzrAZEkSdLkYfhQbr708gOKLkGSJEkFctiVJEmSpFwYPiRJkiTlwvAhSZIkKRfO+VBubrznUf6+toOOrh4O3X0uT57fVnRJkiRJypHhQ7n51tV3ceF19wLwHyc+zfAhSZI0yTjsSrlpbWrY9rijq6fASiRJklQEez6UiyVnX8La9q5tzz+04lY+tOJW5rU1serMYwqsTJIkSXmx50O56B88RnNekiRJ9cfwIUmSJCkXhg9JkiRJuTB8SJIkScpFWeEjIhoi4mURcUpEHDngtddHxF8iYkNEXBoR+1W2VEmSJEkTWbmrXS0DvgMk4ELgSoCIeDnwlX7tngP8OiKenlJaU4E6NcHNa2sadHL5vLamAqqRJElSEcoNHycBDwMnpJR+BxARAXyELJBcBXwe2Av4APBu4O0Vq1YT1qozj2FjZzf7nfUrAKZPbeDPHzm24KokSZKUp3LDx1Lgo1uDR8mzgUXAI8BxKaWNABHRDPxzJYpUfWhrbuTEAxawXctU5rQ20deXmDIlii5LkiRJOSk3fCwCrhlw7vjS8dtbg0fJ5cB7xliX6lBE8Jl/fnrRZUiSJKkg5a52tYUnBpbjyYZcXTDg/Cagd4x1SZIkSaoz5YaPu4DDtz6JiBcCC4A1A4ZiAewOONm8AiLi5Ii4KCLujYiOiLgxIl5Xmm8jSZIkTQjlDrv6GfDBiGgi69l4L1mvx7n9G0VEI/AW4M5KFCneAawG3kk24f8Y4KvAQuCDxZUlSZIkjV654eNzwGuBD5WeB3A32QpX2YmIs4ATgX3IvjRr/JanlNb2e355RMwF3h4RH0op9RVVWLmuu+sRfv+3tazr6OKIPebxnKfsUHRJkiRJyklZ4SOltDYiDibr8dgLuAP4WErp0X7NngE8CvyWbE8QjdOA4LHVDcBpwDSyXqgJ4eo71/HpX/0VgKaGKYYPSZKkSaTcng9SSvcAbx7m9eOHeq1cETGdbPjWycAeQBPwILAKOCel9NtKvdcYatsLOBY4CFgC7EnWE3RySunCUVx/CnAG8DSgAbgN+B/gK6PsyTgCWJ1SmjDBA2BO6+ObCq7reOKmg5IkSapfZYePvETEk4BfAYuBh4AryFbbWgS8CLiRrHelKGcAbxvLhRHxJeCNQCdwGdANHAV8ETgqIk5OKQ25UlhEPAt4CVkP1ISy3y6zeP3S3Znb2sS+O88quhxJkiTlqGLhIyJ2BF4D7EjWM/Gdsc5FiIhW4BLgyWS7p38kpdTd7/W5wNxxFz0+NwOfIvtZryObdL90pIsi4kSy4PEAcGRK6fbS+R2AXwMnkPUsfX6I6xeQLWt8BdkcnAnlqbvM4qm7GDokSZImo7LCR0Q8GbiVbHjRz1JKJ/Q7fw0wu1/zl0fEP40xgJxJFjy+mVL6wMAXU0rrgHWjrHlX4OUppY+P0G5/4KCU0tdGc9+U0tcHXD+aywD+tXR879bgUbrfgxFxBrASeF9EfGHgZxcR2wG/ANYDJwzXOyJJkiTVmnL3+TgJmAp8g+yv/lt9EZhDNozoZ8BfyJaDPa3cgkrL+G697hPlXj+Ic4GPRcQXhtoXozSJ/nLgvyLiqRV4z0GVei0OBLqA7w98PaV0BdneKDsChw64djrwU2AWcGxKaUO16pQkSZKqodxhVy8Azk0pnb71RETsDjwX6AOOTin9PiKmACuAl5PtR1GOA8mGVN2TUvpzRDwTOK507gHglyml35dxv9eQBYs3A80R8fqUUupX/+HAz4EZwBkppZvLrLcc+5eOt6SUNg/R5lpgl1Lb35VqbAS+B+wNHJFScvNGSZIkTTjlho99gQ8POHci2TCsbaEgpdQXEV8l6yEp136l4+0R8Q3gVQNe/0BE/AB45TBf4LdJKd0bEUvJAshpZAHktSml3ohYRtabMB14XUrpvDHUW44nlY53DdPm7gFtAb5MFsDeCcyMiP69IremlB6rXInV9/Xf3MnqdR2s7+jirBfuy/YzphVdkiRJknJQbvhoIZtv0N+LyHY5H7inx71A6xhqmlM6Hkm2BO2ngf8im+NxJNkX8ROBx8g2PBxRSun+UgC5DDgVaIqIbwI/IFu+99UppW+NodZytZWOHcO0aS8dZ/Q799zS8TODtH822TyRbSJiObB88eLFYyix+i687l5ue2AjAGcsXWz4kCRJmiTKnfOxhmy/DWDbkKvDyJbA/cmAtnPJlsgda02NZEO83p1S+ltK6dGU0k+A48nCzqtK7z8qKaWHyL6o3wi8lGyo1VTgFTkFD8h6iCCrf9RSSotSSjHEv5WDtF+RUjp91qzaXFVqblv/vT62FFiJJEmS8lRuz8cNZCsx/ZZsV+0vlc5flFJqH9D2BcA9Y6hpY7/H/z3wxZTSqoi4jmxjv2XAnaO9cWmH9nPINvMDuB744RhqHKutP1vbMG22vrZxmDYT2ikH78bRe+/AnNYm9tlpZtHlSJIkKSflho/Pkm3s13/OQi/9hgNFxN5ke1W8gcfDSTlW93v89yHa/J0sfOxYzo0j4mSyQLOFbEWug4GLIuLFKaXO8kst2+rScbdh2iwc0LbuvOBpOxVdgiRJkgpQ1rCr0oTyN5DNtwiyuQtnpJSu69fscuBssrkU/zeGmq7v93iojQTnlY4De1uGFBGnlOrpBl4IHA5cCTwf+GlEtJRfatluKB33LS2dO5iDBrSVJEmS6kK5cz4obcI3n+wv9LNTSucOaHIo2byQxSmlVWO4/xqyDQsBjhr4ekTMBg4oPR3V/SPi1cC3yPYheUFK6VelYWLPBy4tvc/PI2K44VDjllK6hyxcNQEnD1LnUmAB2ZLC5SwnLEmSJNW8ssMHQEqpJ6W0ZrAdtlNKd5UmiI96LsYgPlo6fiAinrH1ZERMA75CttHedYziC3pEnAacR9ZL87yU0q/71boJWE62a/hS4OKIqPYkhK07rX8yIrYtRxUR25Ot5AXwiTHuDC9JkiTVrHLnfPyDiJhK1ssxC9gA3J5S6h5vUSmlFRHxaeBdwDURcQ3ZUrsHAzuTrbr1sv6bBQ5j71Jtx6aUrhn4YkqpMyKOJ9vE7xnAdmTDyoYVEQfweFgA2Kd0/FhEvKvf/f9hp/KU0oUR8RXgDOCmiLiUbCjYUcBM4CKyHePr1r2PbOILl93Buo4u5s9o5uMv3m/kiyRJkjThjSl8lCaVfxj4J6D/Jg2dEfFT4KyU0p/HU1hK6d0R8TvgLWS7fbeQbcD3WbKegYdHeZ93RMQ5KaW7h2nTFREnAfNTSvePssSZwCGDnN9jkHMD3++NEXEV8CayHpcG4DayHpqv1HuvR2d3HxesyhZCWzQ3j6k2kiRJqgVlh4+IeBFwPlnoiAEvTyeby3BcRLw0pbRiPMWllH4E/Gg89yjdZ8jg0a9NDzDa4EFpf42BP385NZ1P9jlOOnNb++3z0d5VYCWSJEnKU1nho7Sp3/lAM9k8iUvJloTdRNYzsQg4GjgW+G5E7DfOuR+qQ7OmT+Xs45/K3NYm5vQLIpIkSapv5fZ8vIdsxahlKaVrh2hzTkQcAvwMeDfZ3AZpmylTglccOtxWJ5IkSapH5a52dQzwgWGCBwClid1nAc8dY12SJEmS6ky54WNnRr//xO9K7SVJkiSp7PCxGZgzyrZzSu0lSZIkqew5H38CXk820Xwkbyy1l57gh9ffy4//eB/rO7p45WG78c9LFhZdkiRJkqqs3J6PbwMnRsT3IuKpgzWIiKdFxA+BFwH/O94CVZ/uWb+ZK/76MDet2cBd6zqKLkeSJEk5KLfn4zzgFOAkshCyDvg72fCqrUvtzi21vRz4RkWqVN2Z0/b4ErvrO9zrQ5IkaTIoK3yklPoi4oXA14F/BuaV/g30XeD0lFIaf4mqR8v2nM/XT13C3LYmdtluetHlSJIkKQdl73CeUmoHXhoRnwBOBPYDZgKPATcBP0gp/bGiVaruLJzTwsI5LUWXIUmSpByVHT62KgUMQ4YkSZKkUSl3wvmoRcT0iHhmte4vSZIkaWKpWvgAdgd+U8X7S5IkSZpAhhx2VYFei93Heb3q3Ju+cz1/e7iddR1d/Oytz2L7GdOKLkmSJElVNNycj6sAV6tS1fzlwY3c8VA7AOvauwwfkiRJdW6kCecPAT3juPf2Y7xWk8CcVvf6kCRJmkyGCx8JOCqldOtYblzaAf3GMVWlSeGDy/chpSyEzJ/RXHQ5kiRJqrLhwkeM896pAvdQHdt351lFlyBJkqQcDRc+pqaUesd645TSLRExdazXS5IkSaovQy61O57gUcl7SJIkSaoP1dznQxq1lFxYTZIkqd6NtNqVVDU3r9nA2757A+s7uthzhxlc8PrDii5JkiRJVWT4UGEaG4K/PdwBwNr2LQVXI0mSpGpz2JUKM7f18eV1H9nUXWAlkiRJyoM9HyrMnNYmLn77kcxpbWJ2iwujSZIk1TvDhwrTMCXYa8cZRZchSZKknDjsSpIkSVIuqhY+ImJxRPy1WveXJEmSNLFUs+ejGXhyFe+vOtLZ3Utnt3tSSpIk1bMh53xUoNeiaZzXaxL41MW38Y3frqajq5cPv2hfTj1sUdElSZIkqUqGm3C+uAL3d9tqDSsIOrqyHo917V0FVyNJkqRqGmm1q9cBd43x3k8CvjrGazUOEbEcWL54cSXyY3XNbcs6yBqnBFt6+gquRpIkSdU0Uvi4OqV061huHBH7AjGWazU+KaUVwIolS5acVnQtIzl5yUJevP8CZk5vJMJfF0mSpHo2XPg4DVgzjnuvKd1DGlJbs1vNSJIkTRZDfvNLKZ07zntvAf48zntIkiRJqhPVXGp3d+A3Vby/JEmSpAlkzGNeIqKFbB+PNgaf27H7WO+tySWlRPuWHtZ3dLFwdgtTpjj3Q5IkqR6VHT4iYhfgP4HjxnK9NNBBH72Mte1bALj+349hTqtbxEiSJNWjsoZdRcRc4HfACWS9HfeVjg+VHt8H9JbOdTO+CeuaJGZMezzDru/YUmAlkiRJqqZy53y8G9iBbP+P1pTSQrKwcVRKaWHpeSvwZrLw8fxKFqv6NKe1iWlTp7DLdtPp7HavD0mSpHpV7rCp44D/TCmdN1SDlFI38OWIWAi8Fzh1HPVpEvi/0w6lqbGaax9IkiSpFpT7jW8RcPGAc4nBJ5z/HFhWfkmabAwekiRJk0O53/p6gMcGnOsEdhqk7VSyIVqSJEmSVHb4uAs4YMC5NcDzBmn7YmDTWIqSJEmSVH/KnfNxHXBmRPwmpXRr6dxVwFsiYj3wU7JA81Lg9cAVFatUdauvL7FhczfrOroAWLx9W8EVSZIkqRrK7fn4AbAL8KeIeHPp3OdL9zkb+CNwPfCe0rnPVKhO1bGr7ljL/h+5hKM/ewUf+PHNRZcjSZKkKik3fPyKbI+PE4FLAFJKNwOnABvIJp4H0AG8KaX0i8qVqnrVf1PB9aXeD0mSJNWfsoZdlZbR/fEg5y+MiBXA08kCzY0ppc2VKVH1bm5bEzOmNTK3tYkFs6cXXY4kSZKqpNw5H0NKKW0B/hARs4C5wL2Vurfq206zpnPTWYOtWSBJkqR6Utawq4h4f0TMHaHZ0cDdEXFtRCwaa2GSJEmS6ku5cz4+wsh7d1wPfAjYEfjUWIqSJEmSVH/KHXY12E7m/yCl9HfgQxFxLXDemKqSJEmSVHcqNudjEJ3AdlW8v+rIIx0yUuH5AAAgAElEQVRdPPBYJ+s7uth9fis7zXLiuSRJUr0ZNnxExPsHOX16RDw03GXAHLIlee8cR22aRD7+iz/zvVXZGgUfO2E/Tjlk14IrkiRJUqWN1PNxNpAGnHvLKO67dXjWG8quSJPSnNbmbY/XtW8psBJJkiRVy0jh43z+MXycAvyMbEPBofQADwI/TyldOb7yNFksnDOdPbZvY05rEzvMmlZ0OZIkSaqCYcNHSukV/Z9HxMuB96WUbq1qVZp0Xn7Ibrz8kN2KLkOSJElVVO5Su98BHq1GIZIkSZLqW1mrXaWUXlmtQiRJkiTVt3EttRsRC4H9gFlk80BuSindU4nCJEmSJNWXMYWPiHgO8EnggEFeW0U2L+TX46xNk8iSsy9hbXvXE87Pa2ti1ZnHFFCRJEmSKq3cOR9ExOuBXwEHki2pO/DfQcAlpXbSqAwWPIY7L0mSpImnrJ6PiHg68CVgM/C/wKXAamAT0AIsAo4GXgV8MSKuTindWMF6JUmSJE1Q5Q67ehewBjgypXTXIK//EbgoIj4NrATeCZw6rgolSZIk1YVyh10tBf59iOCxTUppNXAWsGxMVUmSJEmqO+WGj+2Bm0bZ9sZSe0mSJEkqO3xsBHYaZdtdgMfKvL8mqXltTWWdlyRJ0sRT7pyPVcC7IuLilFLvUI0iopFsfsh14ylOk4fL6UqSJNW/cns+vk42j+PKiHhBRLT2fzEiWiPihcBvgSOAr1WkSk0KXT19XPnXh/nONXfx5ZV3FF2OJEmSKqysno+U0g8i4rvAS4GfAETEWrKld1uAuaWmAfxfSulHFaxVda4vJU497w8ANEwJTj9idxobyt6KRpIkSTVqLN/sXgn8B9BNFjLmA7sC80rPu4BP4BK7KtO0qQ3Mn9EMQG9f4v4NnQVXJEmSpEoqd84Hpbke74uIzwHHAfsBM8kml98E/DSl9GBFq9Skcey+O7K5u5cFs6czbWpD0eVIkiSpgsoOH1uVAsa5FaxFQ4iIk4GXA0uA2cAdwBeAc1NKqcjaKu0jxz+16BIkSZJUJUOGj4i4s9/TBDw9pdRe/ZI0iHcAq8l2jH8YOAb4KrAQ+GBxZUmSJEmjN1zPxyLgx8Cjpec9Va9GQ1meUlrb7/nlETEXeHtEfCil1FdUYZIkSdJojTTs6t9SSrfmUomGNCB4bHUDcBowDdiUb0WSJElS+SbMOqYR8bGISKV/76qBevaKiLdFxLcj4raI6CvVdtIorz8lIn4TERsioj0iVkXEmyJitP8nRwCrU0p1FTw6u3u54Nq7+fTFf+GDP7656HIkSZJUQWOecD6SiJgPnJFS+nAF7nUQ8B6yuScx3vtVyBnA28ZyYUR8CXgj0AlcRrZs8VHAF4GjIuLkEXaQfxbwEuC9Y3n/WhYB7/vhTaSUPf63F+xDU+OEyciSJEkaRjW/1W1PBSZDR0Qz8A3gQbI5KLXiZuBTZCFgMXDFaC6KiBPJgscDwNNSSsellE4A9gD+DJwAvHmY6xcAF5Te73Pj+QFqUXNjAzvOnAZASnD/hs0FVyRJkqRKGannY0lEzBvjvXcf43UDfRjYB3ghcGK5F0fErsDLU0ofH6Hd/sBBKaWvjea+KaWvD7h+tCX9a+n43pTS7f3u92BEnAGsJNtH5QsDJ5JHxHbAL4D1wAnD9Y5MZC87eFe6e/tYOLuFWdOnFl2OJEmSKmSk8PE/uVQxhIg4hGx52fNTSitKvQblOhc4OiJ2Bt462L4YEXEwcDEwKyJ+l1KqymSDUq/FgWS7wH9/4OsppSsiYg2wC3Ao8Lt+104HfgrMAg5LKW2oRo214K1H7VF0CZIkSaqCkYZdxTj/jVlETAP+l+yv/GOaW1HyGuB2sqFMX40BXRQRcThwCdmX+jOqFTxK9i8db0kpDTWe6NoBbYmIRuB7wN7AsSmlNdUrUZIkSaqOkXo+nkv2xX0s9iIbIjRWHy3d46VDLDU7KimleyNiKXA52dK0zRHx2pRSb0QsI+tNmA68LqV03jjqHY0nlY53DdPm7gFtAb4MHEfWCzQzIg7t99qtKaXH+t8gIpYDyxcvXjzOciVJkqTKGSl83JdSGu6L8pAioo0x9n5ExDOBtwMXpZQuGMs9+ksp3V8KIJcBpwJNEfFN4AdAE/DqlNK3xvs+o9BWOnYM02brLvIz+p17bun4mUHaP5tsnsg2KaUVwIolS5acNoYaJUmSpKqo2lK7wL1kQ57KUprb8D/AY2SrQlVESumhiHg2cCnw0tK/HuAVKaXvVup9RrA1jD1h3slwUkqLKl9K7drc1ct/XfE37nlkE+2dPXzt1CVFlyRJkqQKqFr4KE2I/t8xXPoxYE/gtSml+ytc09qIOIfHJ9JfD/ywku8xgo2lY9swbba+tnGYNnVtakPwxV/fQW9fltE6u3uZNrWh4KokSZI0XiNNOC/rL/QVcgLQB7wqIlb2/wccW2pzRunc14e8yyAi4mTgv4EtwJ+Ag4GLSpPb87C6dNxtmDYLB7SddBobpmzb6wNgzaPu9SFJklQPRur5+EZEdJCFkOUppU051ARZKFo6zOu7l/5tN9obRsQpwDfJlrk9nmwZ258Bzwd+GhEvzOHnu6F03Dcipg+x4tVBA9pOSm9+zmJSgoVzpv9DEJEkSdLENVzPx5XAJrJ5CtXcCf0fpJQWpZRisH88Pozr3aVzzxjNPSPi1cC3gE7gBSmlX6WU2smCx6XAUcDPS5PkqyaldA/ZUK8m4ORB6lwKLCDb/fz31ayl1r3s4F055ZBdOWKP+bQ2V3NqkiRJkvIyZKhIKS1LKT2737+8ej0qKiJOA84jW2HqeSmlX299rfQzLSdbEngpcHFEzKxySVt3Wv9kRGxbCzcitidbUhfgEwN3N5ckSZImusnwJ+W9gQ1km/NdM/DFlFJnRBxPtonfM8iGcj02sN1AEXEAj4cFgH1Kx49FxLv63b//nhyklC6MiK8AZwA3RcSlQDdZ78tM4CLgi6P/8SRJkqSJoe7DR0rpHRFxTkrp7mHadEXEScD8MlbYmgkcMsj5PUZR0xsj4irgTWQ9Lg3AbWQ9NF+x10OSJEn1aEKFj5TSq4FXj+G6IYNHvzY9wKiX9k0prWSMmyiWrj8fOH+s19e7ji09fGjFLdyzfjMdXT385M3PKrokSZIkjdOECh+aPKZNbeBHN6yhuzdb7XlTVw8tTf66SpIkTWS5rWIllaNhSrDzdtO3PV/ziHt9SJIkTXT+KVk168wX7ENjQ7Bwdgu7zW0puhxJkiSNk+FDNeuYfXYougRJkiRVkMOuJEmSJOXC8CFJkiQpF4YPTQgppaJLkCRJ0jg550M1q31LD2d8+zruWb+Jjq5erv23o4suSZIkSeNg+FDNapnawDV/X09XT7bh+2Od3cycNrXgqiRJkjRWDrtSzZoyJVgw+/G9Pu571L0+JEmSJjJ7PlTTPnPy02lpamTB7Om0NvvrKkmSNJH5bU41bf9dZxddgiRJkirEYVeSJEmScmH4kCRJkpQLw4cmhJQSj3R0FV2GJEmSxsE5H6ppGzu7Of5Lv+XeRzbT1DCFP531XCKi6LIkSZI0BvZ8qKa1NTdy36OdbOnpY+OWHh7b3FN0SZIkSRojw4dqWkSwcE6218es6VN5uL2z4IokSZI0Vg67Us0791UHMatlqrubS5IkTXCGD9W8hXNaii5BkiRJFeCwK0mSJEm5MHxIkiRJyoXhQxNCSol17Vu47YHHii5FkiRJY+ScD9W8jZ3dHPKxy9jU1cv0qQ3c+uHnudeHJEnSBGTPh2peW3MjDaWwsbm7l3XudC5JkjQhGT5U8yKCBXNaaG1q4Ck7zuCxzd1FlyRJkqQxcNiVJoQfnHEY06c2ONxKkiRpAjN8qOYtOfsS1rY/cajVvLYmVp15TAEVSZIkaSwcdqWaN1jwGO68JEmSapPhQ5IkSVIuDB+SJEmScmH4kCRJkpQLw4ckSZKkXBg+VPPmtTWVdV6SJEm1yaV2VfO2Lqfb09tHY4N5WZIkaaLym5wmDIOHJEnSxOa3OUmSJEm5MHxIkiRJyoVzPjShbO7q5Q+r13Pd6vX0JXjX8/YquiRJkiSNkuFDE8oDj3XyqvP+AMDMaY2845g9mTIlCq5KkiRJo+GwK00oi+a2MLc1W2L3sc4e/vZwe8EVSZIkabTs+dCEEhGceOACtnT3cuCiOWw/c1rRJUmSJGmUDB+acN7/T3sXXYIkSZLGwGFXkiRJknJh+JgAIuLkiLgoIu6NiI6IuDEiXhcRzrSWJEnShOGwq4nhHcBq4J3Aw8AxwFeBhcAHiyurNqSUMIdJkiTVPsPHxLA8pbS23/PLI2Iu8PaI+FBKqa+owopy85oNXHDtPVx31yMs22s+7zn2KUWXJEmSpBEYPiaAAcFjqxuA04BpwKZ8KyrevY9s5ltX3wVAa3NDwdVIkiRpNGpyzkdEvCUivhcRf46IdRHRHREPR8SlEfGKWpjrEBF7RcTbIuLbEXFbRPRFRIqIk0Z5/SkR8ZuI2BAR7RGxKiLeFBGj/T85AlidUpp0wQPgwN1mb3t885rH6O6ddJ0/kiRJE06t9ny8F9geuBn4HdAB7AY8BzgKOCkiXlzwcKMzgLeN5cKI+BLwRqATuAzoJvu5vggcFREnp5R6h7n+WcBLyD6nSWn+jGbOfMHe7LXjDJ6xcDumNtRkjpYkSVI/tRo+XgrckFLq6H8yIvYl+7L+IuBVwP8UUNtWNwOfAlYB1wHnAktHuigiTiQLHg8AR6aUbi+d3wH4NXAC8Gbg80NcvwC4ALgC+Ny4f4oJ7HVH7F50CZIkSSpDTf65OKV01cDgUTp/C/Cl0tNjRnOviNg1Iv51FO32j4jTy6jx6yml96SUvpdS+ttorwO21vLercGjdL8HyXpTAN432PCriNgO+AWwHjhhuN4RSZIkqdbUas/HcHpKx85Rtj8XODoidgbemlJKAxtExMHAxcCsiPhdSunmypT6hPdZABwIdAHfH/h6SumKiFgD7AIcSjbkbOu104GfArOAw1JKG6pRoyRJklQtNdnzMZSIeBLwhtLTFaO87DXA7WRDmb46cLJ6RBwOXEL2pf6MagWPkv1Lx1tSSpuHaHPtgLZERCPwPWBv4NiU0prqlTgx3ffoZjZ2dhddhiRJkoZR0z0fEfEasnkUU4EFwDPJAtPHU0o/Gs09Ukr3RsRS4HKypWmbI+K1KaXeiFhG1pswHXhdSum8KvwY/T2pdLxrmDZ3D2gL8GXgOLJNBmdGxKH9Xrs1pfRY5UqcWL688g6+/fu7uG9DJ597ydM5Yf8FRZckSZKkIdR0+AAOJ5tYvlUP8O/AZ8u5SUrp/lIAuQw4FWiKiG8CPwCagFenlL5VmZKH1VY6PmE+Sz/tpeOMfueeWzp+ZpD2zwZW9j8REcuB5YsXLx5DiRNLd0/ivg3ZCLxVqx8xfEiSJNWwmh52lVJ6XUopgBZgX+Ac4Czg6tIcjnLu9RDZF/UbyVbT+jlZj8orcgoeAFuHfD1h3slwUkqLUkoxxL+Vg7RfkVI6fdasWZWouaYtWZTt99HS1EBfWZ+qJEmS8lbrPR8AlOZH3Aq8OyIeAD5NtifGi8u8z9qIOIfHl+i9HvhhJWsdwcbSsW2YNltf2zhMG5UcsOtsfvqWZ/GUHWfQ6F4fkiRJNW0iflvbGhyWR8TUci6MiJOB/wa2AH8CDgYuiohplS1xSKtLx92GabNwQFsNY3pTA0/dZZbBQ5IkaQKYiN/YHiWb+9EIzBntRRFxCvB/ZLuJv5BsPsmVwPOBn0ZES+VLfYIbSsd9S0vnDuagAW0lSZKkujARw8eRZMHjUWDtaC6IiFcD3yLbG+QFKaVfpZTayYLHpcBRwM8jYrjhUOOWUrqHbKhXE3DyIHUuJVvV6wHg99WsRZIkScpbzc35iIgjgF2BC1NKWwa8djjZpoEA545mh++IOA34KtkqUs9PKf1262sppU2llaF+SBZELo6I51d56dqPk20w+MnShoZ3lOrcnmxJXYBPpJT6qlhDXVly9iWsbe96wvl5bU2sOvOYAiqSJEnSYGoufABPJpvX8cWIuJ6sF2BG6fw+pTY/I1tydzT2BjaQbc53zcAXU0qdEXE82SZ+zwC2A0YMHxFxAI+HBfrV9rGIeFe/+/ffk4OU0oUR8RXgDOCmiLiUbCjYUcBM4CKyyfQapcGCx3DnJUmSVIxaDB9XAB8BjgD2JNtYMMhCyA+Ab6eULhrtzVJK74iIc1JKdw/TpisiTgLmp5TuH+WtZwKHDHJ+j1HU9MaIuAp4E9kmig3AbcB5wFfs9ZAkSVI9qrnwkVL6O/CBCt9zyODRr00PMNrgQWl/jRip3TDXnw+cP9brJUmSpIlmIk44lyRJkjQBGT4kSZIk5cLwoQlvXltTWeclSZJUjJqb8yGVa6jldLt7nbcvSZJUS+z5UF25f8NmvvTrO3je567k85feXnQ5kiRJ6sfwobryp3s38KmL/8JfHtzIT268j5RS0SVJkiSpxPChurJsr/nMmJaNJnxoYyd3r99UcEWSJEnayjkfqivNjQ2885g9md3axFF770Bbs7/ikiRJtcJvZqo7rz78SUWXIEmSpEE47EqSJElSLgwfkiRJknJh+FBdu3/DZs696u909bjnhyRJUtGc86G69db/u4Gf3HgfAE+a18JznrJDwRVJkiRNbvZ8qG7tOGvatsc/+eN9BVYiSZIkMHyojr3w6TszJeCIPebx7KdsX3Q5kiRJk57DrlS39t15Jn/4t6OZ19ZcdCmSJEnCng/VsYgweEiSJNUQw4ckSZKkXDjsSnVvydmXsLa96wnn57U1serMYwqoSJIkaXKy50N1b7DgMdx5SZIkVYfhQ5IkSVIuDB+SJEmScmH4kCRJkpQLw4ckSZKkXBg+VPfmtTWVdV6SJEnV4VK7qnsupytJklQb7PnQpNPZ3cu3rr6L//eNa+nrS0WXI0mSNGnY86FJpbcv8bxzruSudZsAuPy2hzh6nx0KrkqSJGlysOdDk0rDlOB5++647fn5f7i7wGokSZImF3s+NOm85vBF/OqWBzj1sEW85KCFRZcjSZI0aRg+NOnsNGs6v37XMiKi6FIkSZImFYddaVIyeEiSJOXP8CFJkiQpF4YPTXrr2rdwzqV/ZV37lqJLkSRJqmvO+dCktu8HfklHVy8A51x6+7bz89qa3JxQkiSpwuz50KS2NXgMtLa9K+dKJEmS6p/hQ5IkSVIuDB+SJEmScmH4kCRJkpQLw4ckSZKkXBg+NKnNa2sa9PyUgJ/ceF/O1UiSJNU3l9rVpDZwOd1f3/YQp31zFT19iff/8CaetsssFs1rLag6SZKk+mLPh9TPkkWz2WX2dAACuHv9pmILkiRJqiOGD6mfGdOm8sWXHcDBi+bw87cdwZF7zi+6JEmSpLrhsCtpgP0WzOKC1x9KRBRdiiRJUl0xfEiD2Bo8lpx9yaC7nc9ra3rCfBFJkiQNz2FX0jAGCx7DnZckSdLQDB+SJEmScmH4kCRJkpQLw4ckSZKkXBg+JEmSJOXC8CENY15bU1nnJUmSNDSX2pWGMdxyupu6enjHBTfyuiOexJJFc3KsSpIkaWIyfEhjsL6ji4M/eik9fYlf3vLAP7zmHiCSJEmDc9iVNAYbO7vp6UuDvuYeIJIkSYMzfEhjsNvc1qJLkCRJmnAMH5IkSZJyYfiQquD7q+4hpcGHZUmSJE1Whg+pCt594Z9463f/SGd3b9GlSJIk1QxXu5LGaF5b07CTy1fceB8rbrxv0OtcDUuSJE1Ghg9pjAYLEN29fZz1k1v4zjV3D3mdq2FJkqTJymFXUgVNbZjCR0/Yjy+8bP+iS5EkSao5hg+pCpY/feeiS5AkSao5hg+pAN+6+q6iS5AkScqdcz6kAjy4oZMlZ1+Szf/45c/+4TUnpEuSpHplz4dUJfPamgY93zAleMtRi4eceO6EdEmSVK/s+ZCqZLDeiy09vTy8cQvNjQ0FVCRJklQsw4eUo+bGBhbMbhmx3bYhWQM4JEuSJE1khg+pBg03JKuzu5dnffJyw4kkSZpwnPMhTTARw4cTSZKkWmXPh1SQeW1NQ/ZeDBciRpov4pAtSZJUqwwfUkFWnXkMK1euZNmyZU94bdH7fvbEC0bJXhFJklSrDB8TQEScDLwcWALMBu4AvgCcm1JKRdamieV7197Df1x8mz0jkiSpEM75mBjeAWwG3gksB34OfBU4q8CaVEVD7REy1PnRerh9iz0jkiSpMPZ8TAzLU0pr+z2/PCLmAm+PiA+llPqKKkzVMVIPxFjniyzdcz6fuvgvQ77e15eYMiVGX6gkSVIZDB8TwIDgsdUNwGnANGBTvhWpaMOFk+Hmi+yz08zh73vXI7zxO9c5LEuSJFVFzQ27ioipEXFURHwmIq6OiPsjoisi1kTEhRGxrOgaASJir4h4W0R8OyJui4i+iEgRcdIorz8lIn4TERsioj0iVkXEmyJitP8nRwCrU0oGD/2D4YZsjdSrsWS32Q7LkiRJVVOLPR9LgUtKjx8Arvv/7d13nFxV2cDx37N9N7vpnfQGEiD0UFOkSBEEIYrISxFQARFRBN+XIrwoiKiAooAK5FXJCyJFitRA6FV4kRBTCAkppJfNbrJ9n/ePcyZ7d+bO7Mzs7szO7vP9fO7nZm899+TMzH3uueccYDuwO3AKcIqIXK+q12QpfREXAJeks6OI/Ba4EKgF5gINwBHA7cARIjJLVZsS7H8Y8FXginTOb7q39tROtBmcWDe+xhhjjGmHrhh8NAMPAbep6ivBFSLyVeA+4GoReVFVX8xGAr35wM3Au7gA6W5c4JSQiJyCCzzWAtNUdYlfPgR4ETgZ+A5wW5z9RwAPAC8Bt7T7KkyPk6i9SFuyWSuyM/B5uvVrZRb4GGOMMbmjywUfqvoC8EKcdQ+IyFHAucAZuJv1hERkFPB1Vb2xje32AQ5Q1d8nmc4/Ru2fzG4A/+nnV0QCD3+8dSJyATAP+JGI/Ca6IbmI9AWeAjYDJyeqHTEmns66UZ/773Vc8dC/Oq1mxF4HM8YYY3Jflws+kvC+n49Icvu7gSNFZDjw3bBxMUTkQOAZoI+IvK6q8zsmqTHnGQHsB9QDD0avV9WXRGQ1sAtwEPB6YN9S4AmgD3CwqlZ2RhqNSVe/XvF72tpYXc9+1z/Hpu3xA5N4r3RVFBdw/7cOSnju+99ewWkHjkov4cYYY4zJmC7X4DwJE/18TZLbnwMswb3KdJdEVVGIyKG4NiZ9gAs6K/Dw9vHzj1S1Js4270Rti4gUAH8FPgcco6qrOy+JpqdLd4yRtnrSCgs8wAUmt7+wJG7gUlXXyMPvJS7yq7fGfpye+Wgttz6/mKfnr2V9VW3C/Y0xxhiTGTlV8yEiQ4Gz/Z8PJbOPqq4Skem4V7nOB4pF5Buq2uR7znoCKAXOU9V7Oj7VrYz1808TbLMialuA3wFfxA0y2FtEgo+BF6jqtuABROQE4IQJEya0M7mmJ0q3G9+Swvy0zznnrRUJ17/2cVhv0y12Gxob+PzjwzX8/f8+A+AnJ+3BGQeNbrV+xaYd9C4toG9Z+wZuNB3HOjQwxpjuL2dqPvzT/7/gaijmqurjye6rqmtwjcHnA2cCfxGRY3EjhZcAZ2cg8AAo9/PtCbap9vOKwLKj/fyXwBtR077RB1DVx1X1m3369Glfao2J0lkjr7cVuJwwZXjC9VPH9Y9Ztmht1c5/f25YRcz6Kx76F3v/93McfONc3luxJcmUms5k7XqMMab7y6Wajztx3dGuxDU2T4mqrheRmcDzwGl+agTOUNX7OzKhCURe+Yppd5KIqo7p+KQYk7rOevr8zWnj+NHDH8Zdf9HMCdz72rK4T8UHlhfHLP/29PHMX13Jv9duY9KQ1sGHqrJwraswXFNZy6CQ/c/7n3epKCng2Y/Wsr0+tm+HTDyN7441AfWNzdwxbykrt+xg8/Z67jn7gJSPcd9bnzJ2QC8mDqlgYHlRKh1+mC6gO5ZrY0zyciL4EJHbcD1crQWOUNW16RxHVTeKyK3AvX7Re8DDHZPKpEQexZYn2CayrirBNsZ0SYm68U309Pq0A0clDD7ABT7z5s1jxowZSaXlpH124aR9dgldV13XyPC+pWyvb6IoP48R/Upbra+pb2LuwnXEdk/RYmN1PYfcOJfxg8v587lTW637eH01Vz86n4J8YeLgCq45YfdW65duqGb2a8spzM9j/OBefH1q7CthLy5an7AmYN22WnoVF1BWmN/m+CyZdudLS/lkQzWrttTw+zP3p7y45aemMF/43byPqWt0nflV1jTQp7Qw6WNv3l7PlY+4pnklhXksuO4YgrFHY1MzVbWN9Otlr9N1NfWNzXyysTphuX5uwTqG9Slh3KBelBXlxC2KMSZFXf6TLSK/BL4LbMAFHkva2CXRsWYBfwDqgEXAgcCjIvJlVc1Ei9Tlfj46wTYjo7Y1JmckemqZ6GlnZJ7u+COpqigp5MnvHk5jUzNrKmtjnpwvXleVMPCI+KyyloqS2Bvnypp63vhkE+ACnWirt9Tw5zdd06/DJgyMCT4++qySHz/2UcJzT71hLgDH7zWM357e+u3LeYvWM+etFVRvrWNLn1WcvE/rzgE/3bSdlZtr6FWczy59Sxncu6TV+raeTN/31qfMX13Jqi01XP+lPRgzsFer7R54ZyXLNrq3S1dt2dGqTY6IMKJfKUs3tKzvU5r8K6KL17U8l5k4uCIm8Fq8rprjfv0KA8uLmT5pEL/8ypSkj206RlOz0tSsFBW0frP7lDte58PViTtqPP9P7wJw5xn7ccweQ1ute+T9VdQ2NDOsTwn7ju5H75DPXlfV6jMVGKvIantMT9Slgw8R+TnwfWATcJSqLmjHsU4H/oTr5vYkXDe2TwLHAk+IyImquqP9qU4o0k3wZBEpjdPj1QFR2xrTLbT1A5uNH5S8JgcAACAASURBVOCC/DxG9i+LWT5pSAUPfvtgFq6t4upHE3eAV5AfW+vQ0NQSuRTmxTata2xuGcIndP/m5N/MLA95Orx0w3aeXbAOgEkrK2OCjyf+tYabn1kEuNfTfnTsbq3Wt9X24sl/reH1pS64WrZxe0zwMaJfaUvwsbkmpkOAb00bT31TMyP6lTIqJP8TqSgpYNZ+I1i8vpo9d4ntaGDJ+iqf1joqaxpi1r+xdBN3vLSUSYPLOXTiQGbuOhjI3iCW3ekVpLtfXcYj769iybpqbp41hROj2mpNGFzeZvARMbxvScyyu176hIW+Lddj3zmUvUb0bbX+tueXkCcwrG8px+wxtFWNW0Rn5XfljgaWrK9ie30TfUoL2Xtk67RZeyZjWnTZ4ENEfgb8ENiCCzw+aMexzsaN91EDnBAZGd03Ov87cCTwDxH5oqpWxz1QO6nqShF5D9dIfBYuGAqmczpu/JK1uMbkxpgsKC3K54Ax/TlgTP+Ewccrl88kP+SVp88N7c1fzp1KQ3MzvUtiv2YnDq7guhMn09DUzC59S2PWjxlQxn8cNHpn7UiYgeXFbK9rpDzk+NW1LbUtYTdgwdqY8uLUeykb2a8M90zI1VxEO/3AURw9eSgj+pUyJeoGEeArB4yMWQbJ1X5NHt6Hm2fFr83YuqOBksI8ahuamTQk9g3Xf63aysuLN/Dy4g3UNDTtDD6SvTl8YeE6Vm+pARFmTBoUE7y+uGg9G6rqEGD6pEExtUovL97A1poGBDh84sCE561vbI6pPcimj9dX89rHG1m0roqDxw0guhuHDVV1zF/t2lItXlsFUf9Nuw2tYGT/UlZujtfTPEybNIg1W2sYHvK5+CzQpfawPrHr7371E7b5sj990qCYsv/d/30/YX7f+I9/s6O+if69irj0qEmt1r+3YgsX3fceO+qb2GtEn5hXLd9ZvpnzfK3N53cbnHJbpreXbeYXzy5izIAyDh4/IOaBgckN2XqYkGs1a10y+BCR64ErgK24wCPtWgAROR+4C9eL1LGq+lpknaru8N3SPoyrAXlGRI6N7rq2g92IG2DwJj+g4cc+nYNxXeoC/Cx6dHNjTNcTVmsC0KeskMMmDky431mHjIm7fq8RfdlrRN+Ewce7Vx0JuMbz0U6YMoxJQ8p594P5fGHy0Jj1I/uVccj4AVTXNbJLv9ibuLacMGU4uw/vzYh+peyxS+wrU8fuOSzlY0LH1H6ddcgYzjhoNCs376C4MPbGfVHgta1dh8b2gtaW+95cwdyF6wH4w5n7x5SBO+ct5a1lmwGYc/7UmODj5mcW7Xz6/9h3Dk14rkVrq9hzROv8/c6c96isaaCipIBrT5gcc/x5i9ZTlJ9HRUkhuw2roDA/fvAS70apb2kh955zAPuM6tdq+atLNnDt4+4FhIbGZo4f1Hq/XYe2BHufhYy9881p4/jW9PEJu+z+0zcODF3e3KycefAYPqusYUNVHQOi2vRsr2vcGXgU5eeFrn/sg8/inhfgrpc/AVwNTXTwIbjOKQC2hdSolRW1BPHbQ161bMuidVW8vWwzby/bTLMSE3y8sHAdj3+whtEDyjhswkD2HxPbw19X051q9RJ5ev4a3lm+hXXbahMGt0ff8hLfO3ISx0V9P/75zU/5aHUlxQV5nLrfyJjP/KtLNrKxuo7igjz2G9OPwRWtP/Ntnbcr6nLBh4icCFzl//wYuDhOTyYLVfVnSRzyc0AlbnC+t6JXqmqtiJyEG8Rvb6Av0GbwISL70hIsAERalN4gIpcFjt9qaGZV/ZuI3AFcAHwoIs8DDbievHoDjwK3J3FdxpgMyGRblHTOHfb9OG5QOeMGlVO6aVHMDxnA6VNHcfrU9EeEP2ziwITBVbbl50nMq2ARlx45iaM+N4TF66qZOnZAyscOhnphv0yt18duoYEtwtYHVYTUar21bDMbquoA+PEJk2PWXzznfar8ze8H1xxNn7KW4ENVOfqWlyktyqeipCDujcnWmgZ+9dzimKf7kwLB2uJ1VTHBx+ETB3H/Nw9i0pAK+oc0+I+U1XQ+U3l5wmVf2DXuehG47sTJfLa1hrrG5pi2QJHAIRk1Ib3bBRu/7whZ37+8iH1H9aWsqCC0a++2fLqxpQf+MQNiH2q8u3wLj7zvBlttbtaY4OOpD9cw/7NKRg/oxUFjBzDKH6OjA4DIw47g905zszL/s0pqG5ppaGrm0AnuuyHZG2JVpa6xmeKCvKz1XKeqVNU1okpMBxj/+/YKHnlvNeuravn29PGcdmDr784XF27ggXdXtnmOxeuqQwPT1z/eyFPzXT9KU8cNiPnO/v0rn/Dy4g0A3HvOAQzetXXwcdF977V9gV1Mlws+gOAnan8/hXkJaDP4UNXvi8itqhp3FDNVrReRU4FBfkyQZPQGpoYsnxiyLPp8F4rIq8BFuPFH8oGFwD3AHVbrYUzXkc0ndN3p6WBXMbJ/GSP7l3HsnuntP3O3wQzvW0KzElprNGPXQYzsV4aiDKqI7cL5sAmDGD2gF4Tc5ETrHbI++NQ9+rWi5maluj7wSl1U8FLX2MyS9e7N4qIENSLQepyciN2G9uaUfUew69ByJg/vQ8Oq1q8kDiwvDu32OlpnlOuyooKEtYmDKor57en7ctGc+Ddqlx+zK2WF+aE9pY0d2ItXr5hJWVFBq1qOiN2G9ubhCxPXZCVy/rRxTJs0iE83bY+pcQL4dFPL642jB8QG1s8uWLczOLnxy3syaoC7QU42ALjq0Q/ZWFVPbWMTt522T0zZPPjGuVTWNFDb0MRH1x1DaSAPmlU58Xb3UokIfHLDcSkFEdV1jex57bMU5AmDKop54z+PaLW+ckcD1z3+EWXF+QypKOHiI1rfZu2ob2T+6m30Ks6nb1kRX7r91dDr7lNayH3nTY2prZ392jJ+9vRCahuauWDGeK44pnUbuLWVtby93NVmrgx5zXRI77bLfERxyJhWkZ7/AIpDXrOsa2hKvL4x924Zu1zwoaqzgdkdfMzEwye7bRqBZAMPVHUe4Q++kt1/DjAn3f2NMaazZLO2p6v7j4MSdVYIF86YkHB9dOP+RMJqD+acP5VttY1U1TbG3ATXNzVzxG5DqKptoLFZY9ojbattCVwqSgrYtD3+KxkHju0f0+akf6+iVr2HzVuV9KVkXZ/SQo7faxgXJfjVTfR/V1SQx4h+qXWOENTWZ2pI7xKG9C4BBsVsA+6VtcMmDuTTTTuYMjK2NvPTTS01J6NT7MQB4PkF61m7zdUOVdc1xgQf2+sad9b41DY0tQo+CvLzKMgTGpsVVVcOiwuSb0u2vc4dt7FZaQzpbGPzjnoe9oHVqP5lMcHH8o07+MpdrpnsrkMq4gZclTUN/PGVT7j1tH1aLS8tyqe2wd3Ar9sWW0M2JPBq47ptdTHrp00aRFlxAUN6F3PpA/GbJz/9vcMZ1jv2gcU3Dh3LUbsPoa6hKWZMKnBtw4b2KaGuoZnBIQ80crFb8S4XfBhjjMmunljjkq2AK9Xz7jc6/rv+JYX5/PGseC8LQP+yIp7//nSqahtoaNKdN2xhbo/qvrm7yNb/c+QzlcpYRUFTRvZlysjYzhsizj1sHIeu3cbyTTsYPzjRUGLhSgLto2obYl8rKynM39mmprYxdv0+o/rSrO44TSn01gdQ0+DGW6pvag7tICP4qlKvkPU76oPrEwc966tig4dIG4rSkFoJgJm7DWLOeVMZ3Lu4VSASsf+Y/jtfg0sUfET3+hfR1ius3/l84hdq/vSNAxO2o+qKLPgwxhjT46U6iGVHnjdTCvLzmJDGjWl30l0D6+P3Gsbxe6XX0QPAlcfvTn1jMyWFeaE32M98bxqFBXmUFORREPLK3oPfPiTtc48d2IvFPz2W+sbm0MBmeN9SfjFrCtvrGkPbQRUV5LHvqL5sr2tizIBevLdia9xzTR4eGwAcMmEAH157NOXFBaGviw3rUxrau1qYXHmIkW0WfBhjjDE9UK7dsJjOc9TuQxKuT+fVnlTLV1FBXmjX0v17FXHqfvG7Ht5rRN9W7W0ir2iFufL43WOWFRfkp/SaWCLZCm7bW7OWaRZ8GGOMMT1Qd60FMC2yGWBa+TLxWPBhjDHGGNMN9cQAwGr0uj4LPowxxhhjTLfQEwOuXJO4o29jjDHGGGOM6SAWfBhjjDHGGGMywoIPY4wxxhhjTEZY8GGMMcYYY4zJCAs+jDHGGGOMMRlhwYcxxhhjjDEmIyz4MMYYY4wxxmSEBR/GGGOMMcaYjLDgwxhjjDHGGJMRFnwYY4wxxhhjMsKCD2OMMcYYY0xGWPBhjDHGGGOMyQgLPowxxhhjjDEZYcGHMcYYY4wxJiMs+DDGGGOMMcZkhAUfxhhjjDHGmIyw4MMYY4wxxhiTEaKq2U6D6SQisgH4NMOnHQhszPA5c5nlV2osv1Jj+ZUay6/UWH6lzvIsNZZfqcl2fo1W1UFtbWTBh+lQIvKuqu6f7XTkCsuv1Fh+pcbyKzWWX6mx/Eqd5VlqLL9Skyv5Za9dGWOMMcYYYzLCgg9jjDHGGGNMRljwYTra77OdgBxj+ZUay6/UWH6lxvIrNZZfqbM8S43lV2pyIr+szYcxxhhjjDEmI6zmwxhjjDHGGJMRFnyYdhOR00XkFRGpFJFqEXlXRC4SkR5ZvkRktohogmlhnP3yfL696/Ox0ufr1zJ9DR1JRHYVkUtE5C8islBEmn0+nJrEvmmVLRE5RkSeFZHNIrJDROaLyJUiUtxxV9Z50smzdMud3zdny56IFIrIESLySxF5U0TWiEi9iKwWkb+JyIw29u9RZSzd/Oqp5QtARC4Wkb+KyL9FZJOINIjIBhF5XkTOEBGJs1/a151uuewK0skvEZnXRvl6OsH5iv1nb77/LG4WkWdE5Aude6WdR0RuCFz7ZQm2y8nvr4JMnMR0XyLyW+BCoBaYCzQARwC3A0eIyCxVbcpiErPpNeDjkOVroheISD7wMHAisA14FijG5eUcETlYVb/biWntTBcAl6S6U7plS0QuB24CmoB5wBZgOvAT4IsicoSq7kjvUjImrTzzki530C3K3nTgOf/vtcA/ge3A7sApwCkicr2qXhO9Yw8tY2nnl9fTyhfAFcBgYD7wOi6/RgOfx13HqSLyZVVtjuzQnuvuBr+rKedXwDO4chntw7ATiUgv4AXgQGAD8CTQz5/naBH5gar+qn2Xk1kicgBwOaBAaGDrt8vd7y9VtcmmtCbcD5XifnQmBpYPARb4dZdkO51ZyJfZ/trPTmGfH/h9PgKGBJZPxH0RK/ClbF9bmvlxHvBz4CvAeP9lp8CpHV22gP2BZtyP3dTA8nLgJb/fLdnOk07Ks5TLXXcoe7gbmr8Bh4es+yrQ6K9hppWxduVXjyxfPq2HAb1Clk8OXMM5HXHd6ZbLrjSlmV+R77gZKZ7rN36/eUB5YPlU/xltBvbJdp6kcD3FvsysBh7x13ZZR5WTrvL9lfWMtil3J+BdX1DPDFk3PfDByMt2WjOcLyn9SAP5wDq/z7SQ9Wf5dW9n+9o6KH8iPzKJbqTTKlu4myoFrgnZbxzuSU8d0Dfb+dAJeZZSufP7dPuyB/zRX8PdVsbalV9WvsKv8Wp/DXM64rq7++9qWH755ZHvuBkpHKs/UO8/c+NC1v/YH/Ov2b7uFK7pJp/mEwKfubDgI6e/v7r8u4OmaxKREcB+uA/+g9HrVfUlXOQ+FDgos6nLOQfjqqhXqerLIesfxFWnHiAiu2Q0ZVmQbtkSkSLgWP/nfSH7fQK8ARQBx3V4wnNTTyh77/v5iMgCK2MJxeRXO/SE8tXo57WBZWlddw/5XQ3Lr3QdBxQCr/vPXrTIZ/Q4ESnsgPN1KhGZiqsxm6OqjyfYLue/vyz4MOnax88/UtWaONu8E7VtTzNTRH4lIr8XketF5AtxGoFF8uedkHWoe/fyI//n3p2R0C4m3bK1K1AGbFbVpSns190kW+6gZ5S9iX4ebJNgZSy+sPwKsvLlichY4Nv+z+DNYrrX3a1/VxPkV9DJInKbiNwpIteIyOEJDtlWPn+Ma8/QC5iUTpozRURKgP8BNtN2e7+c//6yBucmXWP9/NME26yI2ranOTNk2QIROU1Vg43nks3LvekZeZlu2RobtS7Z/bqbZMsddPOyJyJDgbP9nw8FVlkZC5Egv4J6bPkSkXNwr7QU4mqGDsE9xL1RVR8JbJrudXer39UU8isouhH+dSLyGvA1VV0ZtS6Z/FqJa4A+lpaAryv6KS44OE1VN7axbc5/f1nNh0lXuZ9vT7BNtZ9XdHJaupr/w32BTsbl03Dgi8AHuB5lno96xcDysrV086On52Oq5Q66cZ6JSAHwF6APMDfqNQYrY1HayC+w8gVwKK69xunANL/sauC/o7az8uUkm18ArwDn4mooynC9Y30NWOaP87zv2SqoW+SXiBwCfA94VFUfSGKXnC9fFnyYdEW6f9OspqILUtVbVfU3qrpAVber6hpVfRLXFeCbuHeB/zOwi+Vla+nmR4/OxzTKHXTvPLsT1+3kSuCMqHVWxmIlyi8rX4Cqnqeqgrs5ngzcClwLvCkiwwObWvkipfxCVa9W1XtUdYmq1qjqClW9H9gX+AQXlFwQdYqczy8RKQXuxXXHfGGyu/l5zpYvCz5Muqr8vDzBNpF1VQm26TFUtR640f8ZbMxledlauvlh+RgiQbmDbppnInIb7inqWuAIVY0eN8DKWEAS+RVXTyxf/uZ4gar+EBdwTcGNrRBh5SsgifxKtO9W4Db/Z3csXzfgAqvvq2q8dlbRcr58WfBh0rXcz0cn2GZk1LYGIqMAB19PWO7nlpfOcj9PNT8i/x6V4n49QVi5g25Y9kTkl7jXgzbgbqSXhGy23M97fBlLMr/a0mPKV4h7/fyEQI9Ky/083fLV0/KrLd25fJ2MG3fjLHGjvO+cgGP8Nhf4ZX/0fy/385z9/rIG5yZdke4YJ4tIaZweFw6I2tbAAD+vDix7z88PIISIlAF7+D97Ql6mW7YWAjVAfxEZH6c3jwND9usJwsoddLOyJyI/B74PbAKOUtUFcTa1MkZK+dWWHlG+4tiK6z62ADfuxDrSv+6e8Lsall9tSbd8TcA1Nt8BLE45pZmTh2uYH884P/X1f+f895fVfJi0+F4n3sP1Bz0rer2ITMf1brEW12+0cb7i58GuAd8A1gMjRGRa7C7MwvUW8o6qru7k9GVdumXLv/7xlP/z6yH7jcP1v18PPNnhCe/awsoddKOyJyI/A36I61rzKFX9IN62VsZSy68kdPvylcA03I30ViDSS1Fa191DflfD8qst8crXP3DjpRziu/GNFvmMPuk/u12Oqo5RVQmbcF3vAvzQL9vb75P731/pjk5ok03AqbSMojkhsHwwrks7BS7JdjoznCd743qAyY9aXoB7wtjk8+ULUesv88s/AgYHlk/0+avAl7J9fR2UR/Noe7TutMoW7mlPM643jwMDy8sD570l23nQ0XmWbrnrLmUPuN6ncwuwX5L79Ngylmp+9eTyBRyOu1ErDll3KLDUX8MvOuK60y2XXWVKJ7+AGbgn/xK1fRnwc799AzA55Ji3+/UvAuWB5VP9Z7QZ2Cfb+ZJmXs4m/gjnOf39lfXMtSm3J+B3vrDW4AYNehio9Mseif6x6u4TcJK/9k24Jw4PAk/jRhtV/yN9ech++cBjfptKn4+P+3xV4NfZvrZ25Mm+uN5wItM2f02Lg8s7qmwBl/ttGoFngb/iqvbVn6ss23nS0XmWbrnrDmUPONGnU3FPRmfHmX5kZSy9/Orh5etsWgK1ubiRoR+j5QZPgSeA0o667nTLZVeY0skvXDezintS/wrwAPA8rmZEcaOhfz3O+XoBb/vt1vnP4rP+s6nAD7KdJ+3Iy9nECT7aU07oAt9fWc9cm3J/wvXh/RruBmk78E/gIiAv22nLQl6MxXUn+Lr/Ya71XwxLgHtI8JQR9xrkd3z+bff5+Spweravq515MiPwoxN36siyhWuo95z/AazxP3xXEvI0ritOqeZZe8pdrpc9Wm522prmWRlLL796ePkaixuX4kVcN8Q1/vqXA38DTuqM6063XGZ7Sie/cKNp34ELhtfiXvvZ7j9TvwEmtXHOEuAqYIE/3xbcTXVMTVwuTbQRfLSnnGT7+0t8IowxxhhjjDGmU1mDc2OMMcYYY0xGWPBhjDHGGGOMyQgLPowxxhhjjDEZYcGHMcYYY4wxJiMs+DDGGGOMMcZkhAUfxhhjjDHGmIyw4MMYY4wxxhiTERZ8GGNMNyMiV4mIish1gWWT/bJ/ZzFdE0VkjoisEZEGEVknIvNE5Jwk9p0hIptE5DeZSGtXJs6jIrJaRHbPdnqMMSYVFnwYY0z3M83PXwlZ9lKG0wKAiAzFjZA9C/g5cChwPjASOCuJQ5wK9MeN0B12/Nk+uLq2I9KbLUlexwDgS8Bw4NiMJMwYYzpIQbYTYIwxpuOISAFwMNAIvBlYdbifZyX4wAUNA4EHVfWWyEIRaQAOSGL/u4B9gQc7JXU5RFU3isjNwP7A/dlOjzHGpMKCD2OM6V72A8qBd1S1OrA828HHeD//OLhQVZ8CnmprZ1X9EDikE9KVk1T18mynwRhj0mGvXRljTPcSeb3q1cgCERkLjAA+VtXPspIqKPTz+iyd3xhjTBdgwYcxxuQw32BbIxOuPQXApYFln/hlE4LbisjZaZyvREQuFZG3RKRSRGpEZKGI/EpEhsVLHy3tOn4cld62zjcmKs0qImMC62cnOn5Y2wkRmSAifxCR5SJSJyJbROQ1EblEREqitj0j6njLfYPvb4nIP0WkOrBuht+nr4ic5RuFL/Z5VCkib/pzFIakKanrCLQJiUyzE+TdySLylIhs8Ne5SkTuE5F9Q7a9Kuq480SkSESuFZGPA/vfJiK94pyvSETOE5HXRWStiNSLyAoR+ZuInC4iFfHSaozpOSz4MMaY3LYCWOSnJX5Zc2DZImCHX74yanllKicSkSHAG8CvgPm4Rs/TgT8B3wI+EpHDonY7B9gT+Lv/+w7/d2Rqy+o2tr2yjeP/LuoaTgI+BE4CfgHM8GncBNwKvCIi/QK7PO6P843AsjuBI4DLgaOAx6LSdBUwG1fbdDXulbczgFX+HM+ISFGa1xHZ7o44+YGI5IvIn4GHgV7AubhX1q7ENfR/R0QujtrtLn/cqyKH8fvnAafjGvyvBL4LzAk7J/A08AdgIfAf/pxXABOA+4Bfx0uzMabnsDYfxhiTw1T1zMi/RWQf4D1gvqpOCSxfCowDZqjqJ7FHaZuICK6x997Ar1X1ksDqt8V14fsw8KiI7BV5vUtVl/n9t/pt16vq/BSurwEX6OCSELN+NbA6meOLyGTgf3E31Ieq6uLA6kdF5CHgy8DtwNf98SuBShEZ6LcbAfRX1VmB414AnBh1ulXATFWtCix7XETuxTW+vxj4ZarXEdhufdg1etfhgp13gSNVNfKq2z9F5EVcft4mIktU9Wl/3A3ABhHZ3297KHClqt4UuM6Xgc+AE0VkN1VdGDjnCcBM4FVVDQZq74rIU8C/cQGNMaaHs5oPY4zpPg7289ciC0RkMC7wWJdu4OGdgHuC3wT8JHqlqj4CfIDrBvaKdpynM/03UAL8OSrwiLjZz08TkRFxjpEP3BBc4AOtsbT0LvYscHFU4BFxj59/LZWEJ8v/f//A/3ljIPCIpHUFcC8uEPhZgkM1E1W74gOxf/o/D47afjc/3x59IFXdCvwW+L8kLsEY081Z8GGMMd1H5Ibw9TaWpePLfj7fPyUPMzdq2y5DRIqB4/2fr8TZbJGf59HScD/aDkJuolV1uarW+n8/q6qPxtl/pZ/v2mai03McLsACeCHONs/7+RQRGR9nmyWqui1keaTDgqFRyyO9mB0tIpeLSFlwpar+RFVvTZBuY0wPYcGHMcZ0Hwf5+eshy95o57EjbS6WJdhmuZ+PEJG+7TxfR5sEFPt/3yMijdETEAyqRsY5zmZVTaah/DEi8pCIfCoiOwLniNykl6d9JYlF/p+2+hqHMMtDto+2Oc7yWj8vjlr+CK7GR4CbgLUicr9vaB7aQN0Y0zNZmw9jjMlBIrILLTUNERP8/B+B9hHD/fx7InJuZKGq7kZqevt5TYJtdgT+3QeId/ObDb0D/76QwKtpccRrU9HU1onEDQB4GbARdyP+Dq5BO7j/j2faOkY7pPP/FKbN6wxS1SYRORbXeP8C3HgzX/XTNhH5HfDj6NfAjDE9jwUfxhiTmwqJ/+pO2PLhIctSEXkFpyzBNsF1KfWklQHBV4g2pdLoPRUish8u8ACYparzotZXx+zUsbL2/6SqzcDdwN0iMgmYhWtcPwH4Ea726ZSOOp8xJjfZa1fGGJODfBsDiUy47l8BLg0sm+mXvRTc1q9L1Yd+PibBNpF1qxK88pMti2l5ZWhSvI1EZA8/VkW8BudtmeHn1dGBR4ZE/p/6RHUZHDQmZPsOpaqLVfWnuED4F37xl0VkdGeczxiTOyz4MMaY7iEyvsbLgWXTQ5al6yE/39OP9xHmyKhtM6nRz3cGVuIGKDxVRAaoah3whF91XILj/BQ3pkZtgm0S2fm7KmF9A8OoNvZPeB1JnP9JWtJ+RJxtIv9PH6jq0iSO2SYRucx349uKrw0J9o4W3VDdGNPDWPBhjDE5zj/hnox7hSbYE1Mk+HipA07zBC6IyQOuCUnDycBeuLYNN0Wvz4B1ft4/sOzruLFJIu0afoxrC3GoiESPy4GIfB7XI9Y9qroxzXS86uflwBdD1n+7jf2TuY64fE9kkZqG/4oezFBERuHaZSgd2yVyOS5fw2qVIst2AAs68JzGmBxkbT6MMSb3HYZ7Uv6af9KMv+k8CGig/T1doaoqIl/BjWJ9oYiUAv+Du6E8Ejcy9lbgJFVdE9lPRMbiRtmO9H41WET28P9epqox40IEiUhY25ZJIlIOGE6gtAAAAfRJREFULPKDEAL8A/gv4Esi8nfc79u3gH/he3dS1QUi8lXgfuAB3zD8KVz7mZnAD3HjWPwwcP5euDE8xvpFhYH0x7xepqpviMgc3Kjg94nIDbiufStwo6QfEzj2Hn6fYPuThNfhOxroBwz22/f1x9niByAEuBb3atUZwFx/nauAPXBjnfQCLlHVnQ3ffe9kI4Bd/KJeweP68UMGE/v/uF5V1+OCmULgORG5CTfmSxMwxV+PAt+LM/aJMaYnUVWbbLLJJptyeAJ+jn+SHVh2mF/2RgefqwS4FHgb17i5Ftee4hZgWMj283w6wqYZSZxvTIL9x0Rtez5uJO16XG9VjwITQo45DjeA3lKf/mrcaOA/AIqjtp2R4Pxnx0lzHm4E8/dxNS21uDFEfgUcGH2ckP3jXgcwO05aZocc52RcsLjRH2s1MAfYL2TbsxMdFxfQhK2/1q8vxg2c+ACuHclmXOC7CvgrbkT5rH9WbLLJpuxPotpmd+XGGGOMMcYY027W5sMYY4wxxhiTERZ8GGOMMcYYYzLCgg9jjDHGGGNMRljwYYwxxhhjjMkICz6MMcYYY4wxGWHBhzHGGGOMMSYjLPgwxhhjjDHGZIQFH8YYY4wxxpiMsODDGGOMMcYYkxEWfBhjjDHGGGMywoIPY4wxxhhjTEb8Px3lUyKpZzrWAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 864x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "font = {'family': 'serif',\n",
    "        'color':  'black',\n",
    "        'weight': 'normal',\n",
    "        'size': 24,}\n",
    "\n",
    "plt.rc('xtick',labelsize=22)\n",
    "plt.rc('ytick',labelsize=22)\n",
    "plt.rcParams[\"figure.figsize\"] = (12,9)\n",
    "plt.xlabel(\"# of iterations\",fontdict=font)\n",
    "plt.ylabel(\"Total loss\",fontdict=font)\n",
    "plt.plot(list(loss_plot.keys()), loss_plot.values(),'s:',linewidth =3)\n",
    "plt.yscale('log')\n",
    "\n",
    "plt.grid()\n",
    "plt.savefig(output_dir_prefix+'/loss_vs_iter.png',dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "References:\n",
    "1. https://github.com/NELSONZHAO/zhihu/tree/master/image_style_transfer?1529570173001&fbclid=IwAR3mjQzn6yGLKmdJ5aU8h0L4SqtQuP12YIAExTnlIfHsj9PGuU-ssYPhcvs\n",
    "2. https://github.com/wzirui/guided-neural-style"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}