Design for Heat Exchanger Network.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing Libraries "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import interpolate\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing Data from Excel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Stream Information</th>\n",
       "      <th>Supply Temperture (°C)</th>\n",
       "      <th>Target Temperature (°C)</th>\n",
       "      <th>Heat Load (kW)</th>\n",
       "      <th>Stream Type</th>\n",
       "      <th>Heat Capacity Flowrate (kW/K)</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Stream Number</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Stream 1</td>\n",
       "      <td>170</td>\n",
       "      <td>130</td>\n",
       "      <td>60</td>\n",
       "      <td>HOT</td>\n",
       "      <td>-1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Stream 2</td>\n",
       "      <td>160</td>\n",
       "      <td>100</td>\n",
       "      <td>180</td>\n",
       "      <td>HOT</td>\n",
       "      <td>-3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Stream 3</td>\n",
       "      <td>80</td>\n",
       "      <td>140</td>\n",
       "      <td>240</td>\n",
       "      <td>COLD</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              Stream Information  Supply Temperture (°C)  \\\n",
       "Stream Number                                              \n",
       "1                       Stream 1                     170   \n",
       "2                       Stream 2                     160   \n",
       "3                       Stream 3                      80   \n",
       "\n",
       "               Target Temperature (°C)  Heat Load (kW) Stream Type  \\\n",
       "Stream Number                                                        \n",
       "1                                  130              60         HOT   \n",
       "2                                  100             180         HOT   \n",
       "3                                  140             240        COLD   \n",
       "\n",
       "               Heat Capacity Flowrate (kW/K)  \n",
       "Stream Number                                 \n",
       "1                                       -1.5  \n",
       "2                                       -3.0  \n",
       "3                                        4.0  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_table=pd.read_excel('Input Sheet.xlsx')\n",
    "input_table[\"Stream Type\"]=np.where(input_table[\"Supply Temperture (°C)\"]>input_table[\"Target Temperature (°C)\"],\"HOT\",\"COLD\")\n",
    "input_table[\"Heat Capacity Flowrate (kW/K)\"]=round(input_table[\"Heat Load (kW)\"]/(input_table[\"Target Temperature (°C)\"]-input_table[\"Supply Temperture (°C)\"]),2)\n",
    "#Heat Capacity Flowrate values of all hot streams have been made negative. This convention will be used later to simplify calculations for problem table algorithm.\n",
    "index=[]\n",
    "for n in range(1,len(input_table)+1):\n",
    "    index.append(n)\n",
    "input_table[\"Stream Number\"]=index\n",
    "input_table=input_table.set_index('Stream Number')\n",
    "input_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Renaming the column names for faster calculations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_table=input_table.rename(columns={\"Supply Temperture (°C)\": \"Ts\", \"Target Temperature (°C)\": \"Tt\", \"Heat Capacity Flowrate (kW/K)\":\"FCp\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating two separate DataFrames for Hot Streams and Cold Streams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "hot_streams=input_table[input_table[\"Stream Type\"]==\"HOT\"]\n",
    "cold_streams=input_table[input_table[\"Stream Type\"]==\"COLD\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Prompting the user to enter ΔTmin "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your ΔTmin (°C): 20\n"
     ]
    }
   ],
   "source": [
    "Tmin=float(input(\"Enter your ΔTmin (°C): \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting the Temperatures required for Generating Problem Table algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp_left=cold_streams[\"Ts\"].append(cold_streams[\"Tt\"]).append(round((hot_streams[\"Ts\"]-Tmin),2)).append(round((hot_streams[\"Tt\"]-Tmin),2)).sort_values(ascending=False) \n",
    "temp_left=list(dict.fromkeys(temp_left)) #this will drop duplicates\n",
    "temp_right=hot_streams[\"Ts\"].append(hot_streams[\"Tt\"]).append(round((cold_streams[\"Ts\"]+Tmin),2)).append(round((cold_streams[\"Tt\"]+Tmin),2)).sort_values(ascending=False) \n",
    "temp_right=list(dict.fromkeys(temp_right)) #this will drop duplicates\n",
    "problem_table=pd.DataFrame()\n",
    "problem_table[\"Network\"]=[i for i in range(len(temp_left))]\n",
    "problem_table[\"Network\"]=problem_table[\"Network\"].astype(str)\n",
    "problem_table[\"Sub\"]=np.repeat(\"SN\",len(temp_left))\n",
    "problem_table['Subnetwork'] = problem_table['Sub']+problem_table[\"Network\"]\n",
    "problem_table=problem_table.drop([\"Sub\",\"Network\"],axis=1)\n",
    "problem_table[\"Tleft\"]=temp_left\n",
    "problem_table[\"Tright\"]=temp_right"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining a function to generate Temperature Interval Diagram "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Temperature_Interval_Diagram():\n",
    "    plt.figure(figsize=(20,20))\n",
    "    plt.xlim(0,len(input_table.index)+1)\n",
    "    plt.ylim(min(0.9*problem_table[\"Tleft\"].min(),1.1*problem_table[\"Tleft\"].min()),max(1.1*problem_table[\"Tleft\"].max(),0.9*problem_table[\"Tleft\"].max()))\n",
    "    for stream_number,Ts,Tt,stream_name in zip(range(len(cold_streams)),cold_streams[\"Ts\"],cold_streams[\"Tt\"],cold_streams.index):\n",
    "        plt.arrow(stream_number+1,Ts,0,Tt-Ts,length_includes_head=True,head_length=1.0,head_width=0.1)\n",
    "        plt.axhline(Ts,color='black',lw=0.5,linestyle='dashed')\n",
    "        plt.axhline(Tt,color='black',lw=0.5,linestyle='dashed')\n",
    "        plt.text(stream_number+1,min(0.9*problem_table[\"Tleft\"].min(),1.1*problem_table[\"Tleft\"].min()),stream_name,fontsize=15)\n",
    "    for stream_number,Ts,Tt,stream_name in zip(range(len(cold_streams),len(cold_streams)+len(hot_streams)),hot_streams[\"Ts\"],hot_streams[\"Tt\"],hot_streams.index):\n",
    "        plt.arrow(stream_number+1,Ts-Tmin,0,Tt-Ts,length_includes_head=True,head_length=1.0,head_width=0.1)\n",
    "        plt.axhline(Ts-Tmin,color='black',lw=0.5,linestyle='dashed')\n",
    "        plt.axhline(Tt-Tmin,color='black',lw=0.5,linestyle='dashed')\n",
    "        plt.text(stream_number+1,min(0.9*problem_table[\"Tleft\"].min(),1.1*problem_table[\"Tleft\"].min()),stream_name,fontsize=15)\n",
    "    plt.axvline(len(cold_streams)+0.5,color='red',lw=0.5)\n",
    "    for j in problem_table[\"Tleft\"]:\n",
    "        plt.text(len(cold_streams)+0.5,j,j,ha='right')\n",
    "        plt.text(len(cold_streams)+0.5,j,j+Tmin)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.title('Temperature Interval Diagram',fontsize=40)\n",
    "    plt.savefig('Temperature Interval Diagram.png', dpi=300, bbox_inches='tight')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Completing the Problem Table Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "streams_involved=np.zeros((len(problem_table),len(input_table)+1),dtype='int')\n",
    "cold_streams_involved_1=np.zeros((len(problem_table),len(input_table)+1),dtype='int')\n",
    "hot_streams_involved_1=np.zeros((len(problem_table),len(input_table)+1),dtype='int')\n",
    "for i in range(len(problem_table)):\n",
    "    for j in range(len(cold_streams)):\n",
    "        cold_streams_involved=np.where(cold_streams.iloc[j][\"Ts\"]<=problem_table.iloc[i][\"Tleft\"]<cold_streams.iloc[j][\"Tt\"],cold_streams.iloc[j].name,0)\n",
    "        streams_involved[i][cold_streams_involved]=cold_streams_involved\n",
    "        cold_streams_involved_1[i][cold_streams_involved]=cold_streams_involved\n",
    "    for k in range(len(hot_streams)):\n",
    "        hot_streams_involved=np.where(hot_streams.iloc[k][\"Tt\"]<=problem_table.iloc[i][\"Tright\"]<hot_streams.iloc[k][\"Ts\"],hot_streams.iloc[k].name,0)\n",
    "        streams_involved[i][hot_streams_involved]=hot_streams_involved\n",
    "        hot_streams_involved_1[i][hot_streams_involved]=hot_streams_involved\n",
    "problem_table[\"Streams Involved\"]=[streams_involved[i] for i in range(len(problem_table))]\n",
    "difference=[0]\n",
    "for i in range(1,len(problem_table)):\n",
    "    difference.append(problem_table[\"Tleft\"][i-1]-problem_table[\"Tleft\"][i])\n",
    "problem_table[\"Temperature Difference\"]=difference\n",
    "k=np.zeros(len(problem_table))\n",
    "for i in range(len(problem_table)):\n",
    "    streams=np.extract(problem_table[\"Streams Involved\"][i]!=0, problem_table[\"Streams Involved\"][i]) \n",
    "    sum_1=0#this is done so that there isn't error in the future\n",
    "    n=len(streams)\n",
    "    for n in range(len(streams)):\n",
    "        sum_1=sum_1+input_table.loc[streams[n]][\"FCp\"] \n",
    "    k[i]=sum_1\n",
    "problem_table[\"Summation of FCp\"]=k\n",
    "problem_table[\"Deficit\"]=problem_table[\"Summation of FCp\"]*problem_table[\"Temperature Difference\"]\n",
    "x=[-problem_table[\"Deficit\"].cumsum()[i-1] for i in range(1,len(problem_table))]\n",
    "x=np.array(x)\n",
    "y=[0]\n",
    "y=np.array(y)\n",
    "z=np.concatenate((y,x))\n",
    "problem_table[\"Accumulated Input\"]=z \n",
    "problem_table[\"Accumulated Output\"]=-problem_table[\"Deficit\"].cumsum() \n",
    "problem_table[\"Heat Flows Input\"]=abs(problem_table[\"Accumulated Output\"].min())+problem_table[\"Accumulated Input\"] \n",
    "problem_table[\"Heat Flows Output\"]=abs(problem_table[\"Accumulated Output\"].min())+problem_table[\"Accumulated Output\"] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finding Pinch Temperature, Minimum Hot Utility Required, and Minimum Cold Utility Required"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "pinch_temp=problem_table[problem_table[\"Heat Flows Output\"]==0.0][\"Tright\"]\n",
    "pinch_temp=pinch_temp.values\n",
    "pinch_temp=pinch_temp[0]\n",
    "minimum_hot_utility=problem_table.iloc[0][\"Heat Flows Input\"] \n",
    "minimum_cold_utility=problem_table.iloc[-1][\"Heat Flows Output\"] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating necessary data for constructing Hot Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "hot_composite_curve=pd.DataFrame()\n",
    "hot_composite_curve[\"Temperature\"]=problem_table[\"Tright\"].values[::-1]\n",
    "hot_composite_curve[\"Streams Involved\"]=[hot_streams_involved_1[len(hot_streams_involved_1)-i-1] for i in range(len(hot_streams_involved_1))]\n",
    "k=np.zeros(len(problem_table))\n",
    "for i in range(len(problem_table)):\n",
    "    streams=np.extract(hot_composite_curve[\"Streams Involved\"][i]!=0, hot_composite_curve[\"Streams Involved\"][i]) \n",
    "    sum_2=0\n",
    "    n=len(streams)\n",
    "    for n in range(len(streams)):\n",
    "        sum_2=sum_2+input_table.loc[streams[n]][\"FCp\"] \n",
    "    k[i]=sum_2\n",
    "hot_composite_curve[\"Summation of FCp\"]=k\n",
    "hot_composite_curve[\"Difference\"]=problem_table[\"Temperature Difference\"].values[::-1]\n",
    "hot_composite_curve[\"Enthalpy not Final\"]=hot_composite_curve[\"Difference\"]*hot_composite_curve[\"Summation of FCp\"]\n",
    "hot_composite_curve[\"Enthalpy not Final Cumulative\"]=hot_composite_curve[\"Enthalpy not Final\"].cumsum()\n",
    "final_enthalpy_hot_streams=np.concatenate((0, abs(hot_composite_curve[\"Enthalpy not Final Cumulative\"]).values[:-1]), axis=None)\n",
    "x=np.array(final_enthalpy_hot_streams,dtype=np.float)\n",
    "y=np.array(hot_composite_curve[\"Temperature\"],dtype=np.float)\n",
    "hot_streams; z=hot_streams[\"Ts\"].append(hot_streams[\"Tt\"])\n",
    "temp_values_of_hot_streams=np.array(z)\n",
    "hot_composite_curve=pd.DataFrame()\n",
    "hot_composite_curve[\"Temperature\"]=y\n",
    "hot_composite_curve[\"Final Enthalpy\"]=x\n",
    "hot_composite_curve=hot_composite_curve[hot_composite_curve['Temperature'].isin(z)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating necessary data for constructing Cold Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "cold_composite_curve=pd.DataFrame()\n",
    "cold_composite_curve[\"Temperature\"]=problem_table[\"Tleft\"].values[::-1]\n",
    "cold_composite_curve[\"Streams Involved\"]=[cold_streams_involved_1[len(cold_streams_involved_1)-i-1] for i in range(len(cold_streams_involved_1))]\n",
    "k=np.zeros(len(problem_table))\n",
    "for i in range(len(problem_table)):\n",
    "    streams=np.extract(cold_composite_curve[\"Streams Involved\"][i]!=0, cold_composite_curve[\"Streams Involved\"][i]) \n",
    "    sum_3=0\n",
    "    n=len(streams)\n",
    "    for n in range(len(streams)):\n",
    "        sum_3=sum_3+input_table.loc[streams[n]][\"FCp\"] \n",
    "    k[i]=sum_3\n",
    "cold_composite_curve[\"Summation of FCp\"]=k\n",
    "cold_composite_curve[\"Difference\"]=problem_table[\"Temperature Difference\"].values[::-1]\n",
    "cold_composite_curve[\"Enthalpy not Final\"]=cold_composite_curve[\"Difference\"]*cold_composite_curve[\"Summation of FCp\"]\n",
    "cold_composite_curve[\"Enthalpy not Final Cumulative\"]=cold_composite_curve[\"Enthalpy not Final\"].cumsum()\n",
    "final_enthalpy_cold_streams=np.concatenate((0, abs(cold_composite_curve[\"Enthalpy not Final Cumulative\"]).values[:-1]), axis=None)\n",
    "a=np.array(final_enthalpy_cold_streams,dtype=np.float)\n",
    "b=np.array(cold_composite_curve[\"Temperature\"],dtype=np.float)\n",
    "cold_streams; c=cold_streams[\"Ts\"].append(cold_streams[\"Tt\"])\n",
    "temp_values_of_cold_streams=np.array(c)\n",
    "cold_composite_curve=pd.DataFrame()\n",
    "cold_composite_curve[\"Temperature\"]=b\n",
    "cold_composite_curve[\"Final Enthalpy\"]=a+minimum_cold_utility\n",
    "cold_composite_curve=cold_composite_curve[cold_composite_curve['Temperature'].isin(c)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining a function to plot Combined Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Combined_Composite_Curve():\n",
    "    plt.xlim(0,1.1*cold_composite_curve[\"Final Enthalpy\"].max())\n",
    "    plt.ylim(0,1.1*max(hot_composite_curve[\"Temperature\"].max(),cold_composite_curve[\"Temperature\"].max()))\n",
    "    plt.plot(hot_composite_curve[\"Final Enthalpy\"],hot_composite_curve[\"Temperature\"],color='red',label='Hot Composite Curve')\n",
    "    plt.plot(cold_composite_curve[\"Final Enthalpy\"],cold_composite_curve[\"Temperature\"],color='blue',label='Cold Composite Curve')\n",
    "    plt.legend()\n",
    "    plt.xlabel('Enthalpy (kW)')\n",
    "    plt.ylabel('Temperature (°C)')\n",
    "    plt.title('Combined Composite Curve',fontsize=20)\n",
    "    plt.savefig('Combined Composite Curve.png', dpi=300, bbox_inches='tight')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining a function to plot Grand Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Grand_Composite_Curve():\n",
    "    plt.xlim(0,problem_table[\"Heat Flows Output\"].max()+10)\n",
    "    plt.ylim(0,problem_table[\"Tright\"].max()+10)\n",
    "    plt.plot(problem_table[\"Heat Flows Output\"],problem_table[\"Tright\"],color='blue',lw=2)\n",
    "    plt.xlabel('Enthalpy(kW)')\n",
    "    plt.ylabel('Temperature (°C)')\n",
    "    plt.title('Grand Composite Curve',fontsize=20)\n",
    "    plt.savefig('Grand Composite Curve.png', dpi=300, bbox_inches='tight')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining a function to plot pinch in the grid representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Pinch_in_the_grid_representation():\n",
    "    plt.figure(figsize=(30,10))\n",
    "    plt.ylim(-1,len(input_table)-0.5)\n",
    "    plt.xlim(max(input_table[\"Ts\"].max(),input_table[\"Tt\"].max())+Tmin+5,min(input_table[\"Ts\"].min(),input_table[\"Tt\"].min())-Tmin-5) #this will also invert the x-axis limits\n",
    "    plt.axvline(pinch_temp,color='black',lw=0.5,linestyle='dashed')\n",
    "    for i in range(len(cold_streams)):\n",
    "        for j in range(len(cold_streams),len(cold_streams)+len(hot_streams)):\n",
    "            plt.arrow(hot_streams.iloc[j-len(cold_streams)][\"Ts\"],j,hot_streams.iloc[j-len(cold_streams)][\"Tt\"]-hot_streams.iloc[j-len(cold_streams)][\"Ts\"],0,length_includes_head=True,head_length=1.0,head_width=0.1)\n",
    "            supply_hot=hot_streams.iloc[j-len(cold_streams)][\"Ts\"]\n",
    "            plt.text(hot_streams.iloc[j-len(cold_streams)][\"Ts\"],j,f\"{supply_hot}°\",ha='right',fontsize=25)\n",
    "            target_hot=hot_streams.iloc[j-len(cold_streams)][\"Tt\"]\n",
    "            plt.text(hot_streams.iloc[j-len(cold_streams)][\"Tt\"],j,f\"{target_hot}°\",fontsize=25,ha='right')\n",
    "            FCp_hot=abs(hot_streams.iloc[j-len(cold_streams)][\"FCp\"])\n",
    "            plt.text(hot_streams.iloc[j-len(cold_streams)][\"Tt\"]-5,j,f\"FCp={FCp_hot}kW/K\",fontsize=25,fontweight='bold')\n",
    "            plt.arrow(cold_streams.iloc[i][\"Ts\"]+Tmin,i,cold_streams.iloc[i][\"Tt\"]-cold_streams.iloc[i][\"Ts\"],0,length_includes_head=True,head_length=1.0,head_width=0.1)\n",
    "            supply_cold=cold_streams.iloc[i][\"Ts\"]\n",
    "            plt.text(cold_streams.iloc[i][\"Ts\"]+Tmin,i,f\"{supply_cold}°\",fontsize=25,ha='right')\n",
    "            target_cold=cold_streams.iloc[i][\"Tt\"]\n",
    "            plt.text(cold_streams.iloc[i][\"Tt\"]+Tmin,i,f\"{target_cold}°\",fontsize=25,ha='right')\n",
    "            FCp_cold=cold_streams.iloc[i][\"FCp\"]\n",
    "            plt.text(cold_streams.iloc[i][\"Ts\"]+Tmin-5,i,f\"FCp={FCp_cold}kW/K\",fontsize=25,fontweight='bold') \n",
    "    plt.text(max(input_table[\"Ts\"].max(),input_table[\"Tt\"].max())+Tmin,-1,\"Hot End\",fontsize=20,fontweight='bold')\n",
    "    plt.text(min(input_table[\"Ts\"].min(),input_table[\"Tt\"].min())-Tmin,-1,\"Cold End\",fontsize=20,ha=\"right\",fontweight='bold')\n",
    "    plt.text(pinch_temp,-1.5,\"The pinch effectively divides the problem into two parts\\n Heat exchange cannot take place from one end to another, otherwise there will be penalties\",ha=\"center\",fontsize=25) \n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.title('Pinch in the grid representation',fontsize=40)\n",
    "    plt.savefig('Pinch in the grid representation.png', dpi=300, bbox_inches='tight')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generating necessary data for area targetting while maximizing energy recovery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = interpolate.interp1d(cold_composite_curve[\"Final Enthalpy\"], cold_composite_curve[\"Temperature\"],bounds_error=False)\n",
    "g=interpolate.interp1d(hot_composite_curve[\"Final Enthalpy\"], hot_composite_curve[\"Temperature\"],bounds_error=False)\n",
    "extra_temp_hot=g(cold_composite_curve[\"Final Enthalpy\"]);extra_enthalpy_hot=cold_composite_curve[\"Final Enthalpy\"].to_numpy()\n",
    "extra_temp_cold=f(hot_composite_curve[\"Final Enthalpy\"]);extra_enthalpy_cold=hot_composite_curve[\"Final Enthalpy\"].to_numpy()\n",
    "temp={\"Temperature\":extra_temp_hot,\"Final Enthalpy\":extra_enthalpy_hot}\n",
    "temp2=pd.DataFrame(temp)\n",
    "hot_composite_duplicate=pd.concat([hot_composite_curve,temp2])\n",
    "hot_composite_duplicate=hot_composite_duplicate.drop_duplicates()\n",
    "hot_composite_duplicate=hot_composite_duplicate.sort_values('Final Enthalpy', ascending=True)\n",
    "hot_composite_duplicate=hot_composite_duplicate.reset_index(drop=True)\n",
    "temp={\"Temperature\":extra_temp_cold,\"Final Enthalpy\":extra_enthalpy_cold}\n",
    "temp2=pd.DataFrame(temp)\n",
    "cold_composite_duplicate=pd.concat([cold_composite_curve,temp2])\n",
    "cold_composite_duplicate=cold_composite_duplicate.drop_duplicates()\n",
    "cold_composite_duplicate=cold_composite_duplicate.sort_values('Final Enthalpy', ascending=True)\n",
    "cold_composite_duplicate=cold_composite_duplicate.reset_index(drop=True)\n",
    "hot_composite_duplicate = hot_composite_duplicate.rename(columns={'Temperature': 'Temperature of Hot Streams','Final Enthalpy': 'Final Enthalpy of Hot Streams'})\n",
    "cold_composite_duplicate = cold_composite_duplicate.rename(columns={'Temperature': 'Temperature of Cold Streams','Final Enthalpy':'Final Enthalpy of Cold Streams'})\n",
    "minimum_area_calculation=pd.concat([hot_composite_duplicate,cold_composite_duplicate],axis=1)\n",
    "minimum_area_calculation=minimum_area_calculation.drop(['Final Enthalpy of Hot Streams'],axis=1)\n",
    "minimum_area_calculation=minimum_area_calculation.rename(columns={'Final Enthalpy of Cold Streams':'Final Enthalpy of either streams'})\n",
    "minimum_area_calculation=minimum_area_calculation.dropna()\n",
    "minimum_area_calculation=minimum_area_calculation.drop_duplicates(subset='Final Enthalpy of either streams')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Outputs</b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drawing the final Problem Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Subnetwork</th>\n",
       "      <th>Tleft</th>\n",
       "      <th>Tright</th>\n",
       "      <th>Streams Involved</th>\n",
       "      <th>Temperature Difference</th>\n",
       "      <th>Summation of FCp</th>\n",
       "      <th>Deficit</th>\n",
       "      <th>Accumulated Input</th>\n",
       "      <th>Accumulated Output</th>\n",
       "      <th>Heat Flows Input</th>\n",
       "      <th>Heat Flows Output</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>SN0</td>\n",
       "      <td>150.0</td>\n",
       "      <td>170.0</td>\n",
       "      <td>[0, 0, 0, 0]</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>SN1</td>\n",
       "      <td>140.0</td>\n",
       "      <td>160.0</td>\n",
       "      <td>[0, 1, 0, 0]</td>\n",
       "      <td>10.0</td>\n",
       "      <td>-1.5</td>\n",
       "      <td>-15.0</td>\n",
       "      <td>-0.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>SN2</td>\n",
       "      <td>110.0</td>\n",
       "      <td>130.0</td>\n",
       "      <td>[0, 1, 2, 3]</td>\n",
       "      <td>30.0</td>\n",
       "      <td>-0.5</td>\n",
       "      <td>-15.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>SN3</td>\n",
       "      <td>80.0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>[0, 0, 2, 3]</td>\n",
       "      <td>30.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>-0.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Subnetwork  Tleft  Tright Streams Involved  Temperature Difference  \\\n",
       "0        SN0  150.0   170.0     [0, 0, 0, 0]                     0.0   \n",
       "1        SN1  140.0   160.0     [0, 1, 0, 0]                    10.0   \n",
       "2        SN2  110.0   130.0     [0, 1, 2, 3]                    30.0   \n",
       "3        SN3   80.0   100.0     [0, 0, 2, 3]                    30.0   \n",
       "\n",
       "   Summation of FCp  Deficit  Accumulated Input  Accumulated Output  \\\n",
       "0               0.0      0.0                0.0                -0.0   \n",
       "1              -1.5    -15.0               -0.0                15.0   \n",
       "2              -0.5    -15.0               15.0                30.0   \n",
       "3               1.0     30.0               30.0                -0.0   \n",
       "\n",
       "   Heat Flows Input  Heat Flows Output  \n",
       "0               0.0                0.0  \n",
       "1               0.0               15.0  \n",
       "2              15.0               30.0  \n",
       "3              30.0                0.0  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "problem_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drawing the Temperature Interval Diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAAR5CAYAAAB3KfhKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdebwkVWEv8N+ZQTYZZZPNQQYFcUHgEQSJCirBGGNwS1iSCIiKisaIohJfwmfUKKhgCKCgPg3z9EXEDcQIiiiKUQKogKLCCIyyjBA2l6DAwHl/1L1j3567dA/3zj0zfL+fT33u7epTVaequ7qrfn3qVKm1BgAAAIC2zJntCgAAAACwIqENAAAAQIOENgAAAAANEtoAAAAANEhoAwAAANAgoQ0AAABAg4Q2AAA0o5RyYSmljgxLZrs+06WUsqBnvWopZeFs1wmA9gltgIGMc7A5E8PC2V5PYPr0nXzXUsqzZrtOMM77sn94oJTyu1LK7aWUn5RSvlZKObmU8vJSymNnu/4APLQIbQBY4/WdkJ0+2/Vh9qyprTiYViXJukk2TvKEJPskeX2Sjye5tpTyg1LK60sp689iHQF4iBDaAADA4HZJcnKSn5VS9p/tygCwZltrtisArDZuTLLtgGXPSLJHz+ODklw8wHR3DVspAHiQxvuOWjfJRkk2TLJjkj2TPGtk3Kgtk3y6lLJXkr+rtdaZryoADzVCG2AgtdZlSZYMUraU8vu+Ub+stQ40LQCsYlN9R52bJCOXQx2S5B+SbN3z/OvSXVL1uskWMrKM8mAqCsBDj8ujAABgCrXWu2utp6a7POorfU8fUUr561moFgBrOKENAAAMqNZ6R5IXJPnPvqdOKKVsMAtVAmAN5vIooDmllC2TPC3J5unu3nFXkqVJLqq13jaNy3lYkr2SLEiyWZLfJPlekosn65uglLJWuv4NdkrX38GdSX6a5Fsjl5FNR902SPLMdE3wN05yS5IfJ7lkOvpNWIXbeG66bbUgXf8PSbcO35xkmkel60Ni+3Tbd266bXxzku/WWv97uuq3OimlPDXJdum249pJflRr/dIU06yT5I+TbJPuPX5/uvfSlbXWK2e2xtNrnP31riQ/S/ee7b8kc5UqpZQku6a709CjkqyT5L/T1e+7tdb7pnFZGyd5err3waZJfp3k87XWm6drGUPW5+Hp9tcdRuqzXpJfpVv/y2qt185GvWZarXVZKeXAdJ/L80ZGb5HksCQnTffyRr53njgybJlkgyR3J7kjyY+SXF5rvX8alrNNus+MrZI8kK4/u8trrYsf7LwnWF7z3xEtHysADxG1VoPBYJjWIcmFSWrP8KwBppmT5GVJftA3be9w/8i8nz5gPRb0Tb9wZPzDkxyb5NYJlnN1kn3Gmd/cJG9Kd9I73nS3JDl4wLo9q2/aQ0fGb57kI+kOCsdbxpIkh63k67Iqt/G6Sd6TLgjqX8ZZ48xntyQnJLlqkrqNDv+V5MUD1O30Aea1wjDVfIbc5kt6pr1wirK99Ti95zU7Ksl149T18knmtWOSzyT5n0nW9YYkb0zysBY+CybZJ9ZO8q5MvL/+duT59SaZ96Er816YrL4j8900yb9k4s+Emi7AODnJpgNus4V90y8YGf/EJGcnuXecZbwoybP7xn1gJV6v7frm8ZkJym2T5G1Jvj1Bffo/s9442eszxftmyWy+LweY10l985psv1zQV3bhFPN+ZJKXJzknXTg32Xb+1ch7cauVXI890rUcmmj+30qyd0/5FT6vhlnnNPAdMUAdZ/1YwWAwGGqtmfUKGAyGNW8Y9oA4yWPS/Wo1zMnU8UnKFPNd4UAs3S95Pxxg/suS/E3PvDZIcsGAdTtmgG30rL5pDk33a9x4B7DjDWclWXuI12RVbuNtklwxWd375vGcIes1Onwqk5+on74y851qPkPuC0t6pr1wirK99Tg93V1qvjFJXVc4OUwX8rw/Xfg26DpfkeTRs/1ZkPH3iflJLh1wPS5KMm+CeR+6ku+xyep7ULoT5UHndUeSvQbYZgv7pluQ5G8yeQD3onQd3F7fM+6WJGsN+Xq9s2++LxinzNx0LTCG3ZaXJ9lmJd43S2bzfTnAvHYYZ13nT1B2QV+5hVPM+1srsZ1vzzhBwhTLOSqDfWYsS/LGkWl6x58+ybxXWOc08h0xRR2bOFYwGAyGWqvLo4DZVUp5UpLz0zXF7nVjkivTXQLxyHS/sm3e8/yb0x0cvWaIxa2T5D/StUJIuqbK/zXyd/N0TcLXHXlubpKPlVIuS7I4yefSHTgm3cnTxel+fdso3aUKo83jk+QdpZRv1VovHKJuj0p3h5ItRh7/Nsl3k9yWrjn2nknW7yn/wnS3mn1JrbVONuNVvI3XTfKFdAFUkvw+3TZemm4bPWmcafr7V7svyU/StQT5VbqWFlul6/yzdxscmO5E9cAh6re6KEk+mS7ISLoTg0vTbZN1010WMHaC7jKDTyd5ad9Td6cL7Jame18/LsnO+cNdbHZK8p1Syu611lumdS0enIcn+VK6uiZdS4NL0l12My/d5X2b9pR/RrqWBq+c6YqVUo5M96t/752A7k+3Py1Jck+SR6drvbD2yPMbJflqKeV5Q342PD1diDd6zHZTuhPeX6fbX5+aJLXWWkr5RJJ/Gim3WZLnpduGg6xTSdcSb9QtSc4br2jGrndNFxYtTvdZUtO9Lrtk7Ouzc5KvlVJ2rbX+ZpA6rQ5qrVeXUm7O2M/XpyX57DTMvv+zcfQy2TvSfbZumO4zddueMhsn+Y9Syh611iumWkAp5fXpgt5eD6T7zFiS7v37pHSfOXOT/Esp5cFc8rY6fEe0fKwAPBTNdmpkMBjWvCED/oqZLhC4uq/s+Ul2H6dsSfLidCcsveUPmKQeC/rK3jny964kr0gyt6/8aHDSO80ZSd468v89Sd6SZN1x1uP/9k13yRTb6FkT1O3eJG9P36+D6U5g35Hu5L13uldPsZxVvY1HL+u6Z2Q9Hj7ONNv0Pf6TkdfkpHQHu+NerpPuYPzwdEFW7zL/aoLym47Ur7+On+0Zv8IwznxO751+yH1hSc+0F05Rdrzt+ECSDyTZeLxt3/f43X3zuCXdpRUrtMhKF9x8qa/8l2frs2CCfWL0db49XT8ha/WVXyvJ0Vmx1ceTJtgPRl/ji3vK3jjZeyF9+/rIvJ7bt8x7012etcLlT+nC0Pf2lb9xvNezZ5qFE7wXrk6y7wTrtmnP69o77biXN02w3L37pj1hgnJrpTtp/kyS/ZM8coJyc5L8aVZsrfDBId83S2bzfTng/D7fN793TFBuQV+5hVPM96J0lyy9NhO03hkpt2O61pe98/5hpm4p+YR0oUn/5+MKy0r3w8GVGbtvjg6nT7KM/nVu5jtikjo2c6xgMBgMtVahjcFgmP5h0APiJB/sK3fiAAeZW6frbLD3BGiiA7j+A7Ga7pevXSeZ/3oZe6J9b7pWL/cn+dNJppuT7pe4SU8ee8o/a5y6PZBk/ynW/+V909yV5BGTlJ+NbXx/kucP8X7ZOMkGQ5R/fN9B+X8NMM1AJxgTTHt67/RDTtv7XrpwiDqODpOGcj3T7pGxlzdcnWSLKaaZk2RR3/L+bJj1G6BeF/bN/1lD7hO3J3nCFMt4T9807xuiTkuGXJ8NMrafiv9J8owBpntFXx3fO0nZheNshx8l2WTAOl7UM93vk2w04HQf71vmThOUK0keM8Q2e3i6VoOj8707k4RWD/Y1mu735YDzO7Zvfh+foNyCvnILp5jvNkPWo79/nUn353StSXrLf2yK8o/M+H2inT7JNP3r3Nx3xAR1bOJYwWAwGGqtbvkNzI5SyubpTmRGfTvJkbXWOtl0tdYbkry6Z9Sjk/zlEIv+p1rr9yeZ/++SnNoz6mHpTjpOqrV+ZZLpHkh3aUavvYeoV5IsqrWeOVmBWuu/pWt+PeqRSf52vLKzuI0/WGv98qCFa6131Fp/O0T5a9K1Ohq1eyllweDVW22cU2v98IBlj84fLiFYluRFtdZfTjbByHv21elaVo1649C1nFmvq7X+dIoy700XTowadr8bxivSXXY06u9rrd+eaqJa68fStcYYdXgpZf2JyvdPnuSQWuvtA5Y/vef/dTLApSEjdendx39QJ7i7WO38YsC6pNb6P+laP4xaL8l+g06/mrir7/Gm45YaUq3150NO8pZ0lxmNOmCigiOfmc/rGfXzJK+foj6/Stc/1IO9S9Xq8B3R8rEC8BAjtAFmy2HpTihGHTNVmDCq1npOurvpjPrzAZf523R3ZprK1/sXmRUPsgaZbudxS03s3QOWe2ff47+ZoNxsbOOa7nKemXZ23+M9VsEyV7XjBylUSnl0xp4E/3ut9SeDTFu7W2X37hPPHiJMmGlLkkwaYibLTyT/s2fUTiP9s8yEI3r+vz5d65RB/WvP/xum6xdjEBfWWr83xHI+k641y6hDBpjmxRnb18aiIZY3pVrrD9Ntr1Fr2v7aH9qsNxuVqLXek7H9EE22nV+asecBJ48EEVMt44qM39fRoFaH74jWjxWAhxgdEQOz5Tk9/9+e5JtDTn9RkseO/P/0Aaf5zoC/1vV3snjNIL8s11pvLaX8Jn84+XnUgPVKku/XWn82SMFa65WllJ+m648gSf6olLJ2rfXevqKzsY1/WGtdMuRyxjVy4r1+kkdkbPiUdJ0/9npC1iy/Srf9B/GsjD35+twE5SbyrZ7/H5auY9th3ysz4fyRX6UH8dMk+4z8v266y5imtbPbkXDs8T2jzhqifknXl8596bZx0u1TXxtgunOGWEZqrb8upXwhfwhz9yil7FBrvXqSyXqDnfuS/PswyxxVSlk33f66XsZ2Vpx0n0GjHeauafvrKv0RtJTysHTfMxuMs+z/6fn/8aWUORO8T5/W93iYz43PZfAgv9/q8B3R8rEC8BAktAFWuZEDrT17Rl2b5DFD/jje+4vgNpMcmPaa6jKLUb/uezzZyc54044eiD1iiOkuHaLsaPnRg9B1kjw5XV8DSWZ1G18+zAL6lVKenu5yjqelW6dBf7He6MEst0FXDNoqKisGancOeSlA/8nNY9NGaDNQa6ERv+p7/IhMc2iTFbfz0pW45OJX+cOlM4+drGCPldmnFmVsC7yDk/zv8QqOhFH79Iz6cq31vwdZSCll+yR/neTZSZ6Sru+RQaxp++sj+x5P2WJlGKWUTZL8VbqgZOd0/Y4NYk66faG/JVDyh7s3JckdQwYpE142NIDV4Tui5WMF4CFIaAPMho3SXfs9aveMbTo/rDIyz6n6fOg/sRtXrXVZX7gx0HQjlvX8/7AJS61o2Fuo9rfK2azv8Wxt44FO9laYeSlPTPLhJM9cmemz5h30DrMd5/c9/ta4pQY36In3TBtmv7uv7/Ew+96g+rfz+0aGlTXodl6ZfeqCdB2Ij9b5ZaWUf5ogdP3bjG2tcfpUMy+lbJju8r3DsmKLmkGsafvrhn2PV+pzsF8pZU6SNyc5Jl2rmpUxUWizSc//Nw45zxtWsi7J6vEd0fKxAvAQpE8bYDbMxEnhIAe0w1zKMB3TDaP/F7up9B8c9p80zNY2HrizyFGllF3T9UmysgfjyZr3fTbMdpzu13plTw6n26rY74YxW9t56H1qJJz5RM+ordO1hhnPwT3/35bujkITKqVslK5Pjldk5QKbZM3bX/svvXkwoUaS5a0lP5YuGHww++RE27q3ddCwrdKG/b7qtTp8R7R8rAA8BK1pX5rA6mEmflWaqY5HV5VBL4UZNdX6rhbbuJSydpJPZWzT9VuTnJDkhemav2+cZL1aa+kdprsuq7Hpfq1t2/Gtbtu5vzPhFTokLqU8NcmTekb9e621v9VSvw8k+V89j3+f5P8mednI+M3TtfKb27e/tnDJ3UzZve/xuHfeGtLB6e7UNKom+Wq6OzztmS6Im5dkrb7t/I7+GU2gtw+0Yd/b/f3HzBjfEQAujwJmxx19jxfVWg+djYo0pL9PhKn0N/Xub/6+umzj/TO2c9cLk7yw1jrpL7mllHmTPd+QVfHjSO9rvSzdycuyiQqz0vr3qWfXWi+cjYoMotZ6dSnl4vyhw9mXlFKO6Otg9eC+ySa9a1QpZeuMDX9uTvKcKTo5HrW67LNDGblsZ8u+0RdPw6z/sef/+5P8Za31rAGmG3Q735muE99k+D6GVmWfRGv6dwTAlLS0AWbD7ekOQkdtP1sVacjjhiy/Xd/jW/sery7buPcOJA8kOWSqg/ERW8xQfcYzJgAppQzzg0f/ZWsz4Zae/9fKH+7Qw/S6pe9xq/tUr94Q5uFJ/nL0wcgdiA7qef5HtdapOph9fsa2EHrrgIFNsmr32VXpiL7HP6i13vxgZlhK2SFjP+P/bcDAJhl8O/fe5eixpZRhblP+5CHKPlirw3cEwIwS2gCr3EgrgMt6Ru1WSlnTOqYc1lMfRPl7klzV++RqtI17T0x+MsjtUkf03652JvWfIAwUxIzclWdV/Nrb/6v+PuOWYtSwlyKOWh238xnpLl8a1dtK5gUZ2xnt6QPMrz8s/soglRhpobPVIGVXJ+O0PEqSj0/DrFdqO48Y9LPxkp7/52bFu6NNZq8hyj5Yq8N3BMCMEtoAs+VrPf+vne62sQ9lu5ZS+g/Ux1VK2SljO778Xq313nGKrg7buPeysGE6t/ybqYuMcU/P/2sPOW3/3U76Ox2dyPOGXM7K+lrf40NX0XJXVyv1Xqi1/jRj77Lz56WUTScq34Ja611Jvtgzau9SyjYj//deGnV/kv83wCz7L+McdJ8ddn9t3kiLu09lbDD7ywwWfk1lpbZzKeVpGfxW8t/oe/zyAZfxsHR3HFtVVtV3BECzhDbAbPlYxl52ckzrJ0CrwP8esNwxfY8nOtlaHbZxb188243c4nZSpZS9kzx3yOX03m1r2GbzV/Q9njKMGek8801DLmel1Fp/lu4Wz6P2KKU4YZlY73th01LK3CGm/XDP/xskOXZ6qjSjTu/5v6S7/fcmGXvZyXm11l8OMK/+vrMeP26p3gV2nzlHDjDv1UYpZeMk52TF1ilv7uszaGWtzHYuSf55iGX8R5KlPY8PKqXsOcB0RyV5zBDLebBW1XcEQLOENsCsqLVen7EnE1sm+eKwoUIpZa9SypQHtKuJQ0opfzVZgVLKoUle2jPqV0k+OV7Z1WQb/7Dn/0dlil9wR1ojfTLD33mnt9+Np5ZShrmF7ncztnXGa0spj5qo8MjJ079m7F15ZtrCvscfLaXsO8wMSilbllKeP31Valbve+FhSZ4xxLQnpesvatQrSylvH2bhpZT1SymrstXbVzP25PyQdK3ueu8YNGkHxD1+2Pd40mCylLJ+kk8n2WzA+TetlLJeKeU1SX6QFcPbU2ut/z5Ni+rfzkeUUtadYpr3ZIhL9kYuoT2+Z1RJclYpZZeJpimlHJzkXYMuY5qsqu8IgGYJbYDZ9OYkP+15vGeSK0oprymlPHyiiUopjy+lvKWU8r10t5EdtDl4y+5Kd5D5/0opb+/vFLKU8vBSysIk/6dvurdN0Slj69v4s32PTyulvLy/9UMp5WEjJwz/mWR+ktuGXM63ev7fIMl/lFJeXEp5YillQe/QP2Gt9c4kX+gZtXGSr5ZSVrhMqpSyfZKzkrwmyX1J7h6yniul1vrtdCdto9ZLcl4p5UMjdRpXKWXDUsr+pZRPJ1mSFe8mtCb6Vt/jRaWUV5RSdimlbNv3fhhzojyyr/1tug5RR727lPLVkXBz3BPFUso6pZTnlFJOTtcB7Aemc4UmU2u9P2OD3e0ytrXenRl7CdVkzs3Y9/TLSykfGO9OPaWUZ6bbX5+Trh+h2/vLNGSL/s+BUsoOpZQ9SinPK6W8uZTyuSQ3JTk1K7Y0+WC6W3FPi1rrDRnb58wTk3yp59K25Uopjy2lfCbJ0SOjhvls/Nckl/Y83izJJaWU00bW+4mllJ1LKQeVUs5NF+7NzYqf2zNpVX1HADTLLb+BWVNr/XUpZb8k5ycZPRjdKt1B8cmllMvT9SHx23T9BmyaZMcMf3vs1cGxSd6YrjXMu5McXUr5broTnUelC1v6Q5azknxkspm2vo1rreeWUr6VP3RsuV66jjzfU0q5NMlvRuq0e/7QAfADSQ7L4CeaSRd2vTnJ6En4Xpm4M83xTrz/MckLR+qXJLskuaqUclmS69L1jbJ9kqf0TPOmdJcSrHCiNUP+Kd3J5Ogv0XOSvDZdy6CfJ/lxuhP0h6XbltsnWbCK6taSC9Jti9GWUNtkxTB01LPT3WJ4uVrreaWU1yc5Od0JbJLsOzLcMbJP3Zaun5gNk2ydrh+k3mOu/jtRzbRFSd7S87i3td0ZtdZ7MoBa622llBPSvddGHZnkVaW7vfgtSR6RZOeMDTZOSNd5+t4rUfdV4VMrOd3SJEfWWj89nZUZ8fZ0n9ujn0f7JLm25zNnnXR3Hdy5Z5rvpuurZqDWX7XW+0spL0oXzI/2qfawJK8eGcZzbZJXpudOZFn5zr0HqeOq+o4AaJbQBphVtdbFpZTd0v0S/Kc9T62VZLeRYTLL0gUOq7tb091O96vpQpp5mfya/C8mOaDWOuXB8mqwjfdPd2Lc23JliyR/MU7Z+5IcXms9Z4JGDeOqtS4ZubTs3/KH4GWY6a8tpbws3cnd6GUlc9KdKOzeXzzJP9ZaTymlHDXsslZWrfWBdP2VXJGub4t1ep7eJoOFR3fORN1aUmutpZQD0vXpsVJ9c9RaTy2lLE63T23e89TG6VqWTGWVbuda62jAON6+fvqQs3tHupYfvSftGyT5kwnKfyTJ25J8fcjltOyKdEHfx2utM9KartZ6QSnlTelaZY1+2M1NssfI0O/idJ+Zfzfkcm4uXR8w/yfJn01R/Px0l9b1d3w/09/BM/4dAdAyl0cBs67Welut9Xnpfkk8L2P7DxnPPekO4I5KsvXIpSGrvVrr5elacPxbJr6s5udJXllrfeEEd4yaaN7NbuNa6y3pgo+Tk/xugmL3prtE6am11tNXcjmfTney+Y5067Z0kuWNN/3n0v3a+91Jil2U5E9qre+ZpMyMqrUen+5ythPT3c1mKlen2/Z71lpfO5N1a0Wt9UfpWkW9LsmX0l0a9tsM0WKg1vq1dNv5TRl7CeJEbknXafiLk+w0XI2nxXj91vy01nrJOOMnNHK51f5J/j6Tv7++m+SltdZXjwSKq5Oa7jPwznT7x9eTfCjJK5I8tta6S631lJkKbJZXotYT0/Wd098Zeq+fJXlrkr1qrSt1CVqt9eZa6/PT/VCwKMniJP+TrhXLT9K9b/8kyZ/WWm/LH1q0jPpVZtCq+o4AaFUZ4EdagFVqpB+Jp6W7dGOTdJe0/DZda5SfJvlJrfX3s1bBaVBKeVbG3nL15b0HmiN9ROyV7tKKjdKt+1VJ/muQ1jUDLL/JbTyy3s9M11R/g3SXmdyU5Dsjfcs0oZTy2HR3jtk83Qnejeluvf6zWa3YOEopT0oXEmya7mTr9+n6ULo2yVW11ltnsXprjFLKVulaQGyWrsXNA+luUfyLdCe+10/HvtuS0t3+efd076+N0q3v0iTfH+kInWlSSnlyuvfXo9K1Jlma5Jpa6/dmoS7PztiWU2+otZ68ipa9WnxHAEwnoQ3ALJgqtAGAFpVS/inJO3tGPXNNafEK0CKXRwEAAFMauWvTy3tG3Zfk8lmqDsBDgtAGAAAYxD8k2bbn8RdrrWvCzQAAmiW0AQCAh6BSyp+VUo4tpWwyRbk5pZS3ZuxlUUnywZmrHQCJW34DAMBD1cOTHJ3kyFLKl9J1MHxFug5+56brWPuPk7wsY2+5nSSn11q/EQBmlNAGAAAe2tZJ8tKRYRBfT/KGmasOAKNcHgUAAA9Nv06ybIjydyd5b5Ln1Vp/MzNVAqCXljYAAPAQVGv9ailliyTPT/LMJE9Jsk2SDZOsnS7UuT3JD5N8I8mna623zlJ1AR6SSq114MKbbrppXbBgwczVBgAmc/vtySaT9pcJAACrne9973u31Vof1T9+qJY2CxYsyGWXXTZ9tQKAYSxc2A0AALAGKaX8fLzx+rQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJD7G7QYAACAASURBVLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAB6Uww47LJtttll23HHH5eMWLlyYRz/60dlll12yyy675Mtf/vLy54499thst9122WGHHfKVr3xl3Hnecccd2XfffbP99ttn3333zZ133jnp8g444IDly1qwYEF22WWXaVseAADMFqENAA/KoYcemvPOO2+F8UceeWQuv/zyXH755Xn+85+fJPnxj3+cM844I1dddVXOO++8HHHEEbn//vtXmPa4447LPvvsk8WLF2efffbJcccdN+nyPv3pTy9f1ktf+tK85CUvmbblAQDAbBHaAPCg7LXXXtl4440HKnv22WfnwAMPzDrrrJNtt9022223XS655JJxyx1yyCFJkkMOOSRnnXXWQMurtebMM8/MQQcdNG3LAwCA2SK0AWBGnHLKKdlpp51y2GGHLb/c6KabbsrWW2+9vMz8+fNz0003rTDtLbfcki233DJJsuWWW+bWW28daJkXXXRRNt9882y//farZHkAADCThDYATLvXvva1ufbaa3P55Zdnyy23zJvf/OYkXUuYfqWUaVvupz71qeWtbFbF8gAAYCYJbQCYdptvvnnmzp2bOXPm5FWvetXyS5Lmz5+fG264YXm5G2+8MVtttdW40y9dujRJsnTp0my22WZTLnPZsmX5/Oc/nwMOOGD5uJlcHgAAzDShDQDTbjQASZIvfOELy+/0tN9+++WMM87IPffck+uvvz6LFy/O7rvvvsL0++23XxYtWpQkWbRoUV74whdOucyvfe1recITnpD58+ePmc9MLY+2LVu2bLarAADwoM1duHDhwIVPOOGEhbfffns22WSTnHnmmTn33HPz+Mc/PieccEJuv/323HDDDfnkJz+ZLbfcMosWLcqFF16YrbfeOieeeGJ+85vf5JprrsmnPvWpLFiwIB/60IdyySWXZJNNNskpp5ySe+65J1dccUXOPPPM5fP84Q9/mPXXXz+nnnpqkuQ73/lOPve5zy1//uqrr04pJR/5yEey9tpr54ILLshZZ521/PklS5bk7rvvzsc+9rHMmzcv55xzTr70pS8tf/7mm2/O7bffntNPP906WSfrZJ2s00qu0xve8IZ84AMfyC9+8YuccsopWbJkSY499ticdNJJede73pVrrrkm//iP/5hFixZls802y/XXX5/Xve51+cxnPpM999wzt99+e0opecELXpC11lorV155ZW677bZccMEFectb3pJrr702r3nNa/LJT34yj7/55jznne/Mu971rtxyyy05/vjjc/3112fevHk56qij8tznPjdXXXXV8nX6xCc+kblz5+bII4/MaaedloULF+ab3/xmLrzwwpxyyik5//zzkyQbbbRRjj/++Jx44on5wQ9+kD322CNbbLHFGvU6rYnvvcnWacMNN8ytt96axzzmMWvMOq2Jr5N1sk7WyTpZJ+tknbp1OvXUU5cuXLjwI/05TBnvev+J7LbbbvWyyy4buDwATKuFC7sBplBKyYc//OEcfvjhs10VAIAplVK+V2vdrX+8y6MAAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAelMMOOyybbbZZdtxxxxWeO/7441NKyW233bZ83LHHHpvtttsuO+ywQ77yla+MO8877rgj++67b7bffvvsu+++ufPOO6dc3sknn5wddtghT37yk/PWt7512pYHAACzRWgDwINy6KGH5rzzzlth/A033JDzzz8/j3nMY5aP+/GPf5wzzjgjV111Vc4777wcccQRuf/++1eY9rjjjss+++yTxYsXZ5999slxxx036fK+8Y1v5Oyzz86VV16Zq666KkcdddS0LQ8AAGaL0AaAB2WvvfbKxhtvvML4I488Mu973/tSSlk+7uyzz86BBx6YddZZJ9tuu2222267XHLJJStMe/bZZ+eQQw5JkhxyyCE566yzJl3eqaeemqOPPjrrrLNOkmSzzTabtuUBAMBsEdoAMO2++MUv5tGPfnR23nnnMeNvuummbL311ssfz58/PzfddNMK099yyy3ZcsstkyRbbrllbr311kmXd8011+Siiy7KHnvskb333juXXnrpjC4PAABWhbVmuwIArFnuvvvuvPvd785Xv/rVFZ6rta4wrrclzspatmxZ7rzzzlx88cW59NJLs//+++e6666bseUBAMCqoKUNANPq2muvzfXXX5+dd945CxYsyI033phdd901v/zlLzN//vzccMMNy8veeOON2WqrrVaYx+abb56lS5cmSZYuXbr8cqeJzJ8/Py95yUtSSsnuu++eOXPm5Lbbbpux5QEAwKogtAFgWj3lKU/JrbfemiVLlmTJkiWZP39+vv/972eLLbbIfvvtlzPOOCP33HNPrr/++ixevDi77777CvPYb7/9smjRoiTJokWL8sIXvnDSZb7oRS/K17/+9STdpVL33ntvNt100xlbHgAArApCG2BWLVu2bNxLWFh9HHTQQdlzzz1z9dVXZ/78+fnYxz42YdknP/nJ2X///fOkJz0pz3ve8/LBD34wc+fOTZK88pWvzGWXXZYkOfroo3P++edn++23z/nnn5+jjz560uUddthhue6667LjjjvmwAMPzKJFi1JKmZblAcCou+66a7arADzEzF24cOHAhd/1rnct/OIXv5h58+blmGOOyYc+9KHstNNOOeigg3LVVVfl0ksvzTHHHJPNN988b3rTm3L66adn2223zcEHH5xrr7023/jGN/LOd74z2223XV75ylfmzDPPzEYbbZRXvepVuemmm3LOOefkPe95z/J5fulLX8rcuXNzxBFH5K677sonPvGJvP/971/+/Pnnn5/f/e53ecMb3pB77rknp512Wj7wgQ8sf/7b3/52li5dmqOOOiprrbVW3vve9+bkk09e/vyll16axYsX5+ijj7ZO1sk6zcI6vf/9788bjzwyp5xySu64445885vfXO3XaU18naZapwceeCD//M//nF/84hc54IADcuONN45Zp+222y7z5s1bvk4///nPc8899+SjH/1ojjnmmOXr9LWvfS2bbLJJTjvttJx22mk54YQT8t3vfjePe9zjctddd+Woo47Krr/+db6z9tpZe+2189nPfjaXXnpp7r///lx33XW55JJL8ra3vS033XRTzj333OXL32STTbLnnnvm1ltvzTOe8Yzl6/T3f//3Ofroo3Pttdfm4osvzpIlS3LSSSfloosuyjnnnLPGvU5r4ntvsnX6yEc+kptuuimbbrrpGrNOa+LrZJ2s0+q2TgcccEDmzZuXt7/97WvMOq2Jr5N1sk6r4zqdeeaZSxcuXPiR/hymDPML92677VZHf5UEWFm11hz3vvfn3e89Phv86ZG578ovZ9t5D+Tcc87Kox71qNmuHi1buLAbYAqllHz4wx/O4YcfPttVAdYgPluAmVJK+V6tdbf+8S6PAlape++9N39z8KF578kfzYYHvi/rbrNTNnjBW7Nkra2z06675aqrrprtKgIAADRBaAOsMrfddluevvdz8pXvX5tH7H9s1npE16qmlDnZ4Bkvy7Jd/jJ7PmOvfPnLX57lmgIAAMw+oQ2wSvz4xz/OTrvuluvnPDobvOBtmbP2eiuUefiTn5P1//wfsv/fHpoTPnCiDooBAICHNKENMOPOPffcPO3pz8x9O70kGzzz4JQy8UfPuvOfmA0POC7vPOHkvPwVr8p99923CmsKAADQDqENMGNqrfmXE0/KX/31wVn/z9+Wh++4z0DTrfXIzfPI/Y/LF7/7o+z1nH1zxx13zHBNAQAA2iO0AWbEfffdl1cc/posfP+JeeQBx2Xd+U8eavo566yfeX/x9ixetml23vWpufrqq2eopgAAAG0S2gDT7s4778ze+zw3Z337ijxy//fmYRtusVLzKXPmZoO9X57fP+kF2X3Pp+f888+f5poCAAC0S2gDTKvFixdn512fmmvu3Sjz/uLtmbPO+g96ng/f6blZ73lvzov3Pygf/NCHpqGWAAAA7RPaANPmggsuyG577Jm7n/Bn2eBZr0iZM3fa5r3uY3bKI/c/Nm9/1/vy6iNel2XLlk3bvAEAAFq01mxXAFgzfO4LX8j+f7V/1lnwvzLn93fnV//1+YGme+B3v86c9eYlKYMtaNun5aMf/Wiuu35Jzj/3P1a+wgAAAI0T2gDTYpvHbJPX/93fDT3dSSd+PHv+8dPz1N13H3CKRyZ7vD6Pe9zjhl4WAADA6kRoA0yL3f5o1+z2R7sOPd1JJ/5LDj3k4Bx++OEzUCsAAIDVlz5tAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBAAAAaJDQBgAAAKBBQhsAAACABgltAAAAABoktAEAAABokNAGAAAAoEFCGwAAAIAGCW0AAAAAGiS0AQAAAGiQ0AYAAACgQUIbAAAAgAYJbQAAAAAaJLQBgP/f3r0HeV3f9x5/LbtighovKBYDRAxKFXNR0dwobYNYk1o8pmqUzBFjrDVQ6zQxloyJ3WhVcgxqFJXYYyJTWwmodUERIVgTFRGQqKnkWDSYImCQS7wAgqx7/shkO16LiO6b5fGY2Rn29/1+P9/3Z36Os/Pc3++3AABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFBQU0cPAADwZtavX58VK1Zs0bXPPvtsfv3rX7+ta7p165a99tpri+4HALC1iTYAQFnXXDs+53z9a+m2a/c07tD1bV178aWX57tXXL3Z569d82z6frhfnnj8l293TACAd4VoAwCUNfKrZ+Zn98/Ozx5amJ2P+WYad959s67b423co62tLWvn3pyuv5yRH//rjVs2KADAu8Bn2gAAZb3//e/PbTdPysj//Zf57Y/PzcYVv9qq67dt2pgXp1+RvVc/mkcXzM9hhx22VdcHAHgnRBsAoLSGhoZcdOEF+cH3x+b5W/8h6xY9uFXWbV27Js/f8u18er9dM++B+7LPPvtslXUBALYW0QaAd+S0005Ljx49cvDBB7c/Nnny5AwYMCBdunTJ/PnzX3X+JZdckn79+qV///6566673nDN1atXZ+jQodl///0zdOjQrFmz5i3v9+1vfzsf/ehH8/GPfzxHHXVUli1bttXuRx3Dh5+cu2dMT+u912XtvFvT1ta2xWttXLE4v514bs4cflxabpmcbt26bcVJAQC2DtEGgHfk1FNPzfTp01/12MEHH5xbb701gwcPftXjCxcuzMSJE/PYY49l+vTpGTlyZFpbW1+35pgxYzJkyJAsWrQoQ4YMyZgxY97yft/4xjfy6KOP5uGHH84xxxyTCy64YKvdj1qOOOKIPPzQvOzxzLysnTkuba0vv+011j3xYJ6/5fyMv+J7ueSiC9Olix+HAICa/JQCwDsyePDg7LHHqz/29cADD0z//v1fd25LS0tOOumk7Ljjjunbt2/69euXuXPnvuF5I0aMSJKMGDEit91221ve7wMf+ED7v9euXZuGhoatdj/q6d27dxbMfSCH77Njnr/1H9K67rnNuq6trS1r59+W1p9dl1kz7syXvjT8XZ4UAOCdEW0AeM8sXbo0vXv3bv++V69eWbp06evO+81vfpOePXsmSXr27JkVK1b8j2ufd9556d27d/7lX/6l/ZU27+b96Fg77bRT7pjyb/nKX34uz008NxtX/tdbnt/W+nJe/Mm47L5sTn4+f24+8YlPvEeTAgBsOdEGgPfMG30Gye9fFfNOXXTRRVmyZEm+9KUvZdy4ce/6/eh4Xbp0yff+z5hcdenFef7mb2X9rx56w/Na1z2X529tzsC9d8iCuQ+kT58+7/GkAABbRrQB4D3Tq1evLFmypP37p59++g3/Ys/ee++d5cuXJ0mWL1+eHj16bPY9hg8fnltuueU9ux8db8SIU3LXHVOy8e5xefGhqa+KdS+vXJLnfvz3+fJxQ3Pn7S3ZeeedO3BSAIC3R7QB4D0zbNiwTJw4MRs2bMjixYuzaNGiHHHEEW943oQJE5IkEyZMyLHHHvuW6y5atKj931OmTMkf/uEfvqv3o57PfOYz+fn8udn1v36WtXePT1vrpqz/1UN57ubz8v0xF+ay713qA4cBgG1OU0cPAMC27eSTT84999yTlStXplevXvnOd76TPfbYI2eddVaeffbZ/Pmf/3k+/vGP56677sqAAQNy4okn5qCDDkpTU1OuvvrqNDY2JklOP/30nHnmmRk4cGBGjx6dE088Mddff3369OmTyZMnv+X9pk2blscffzxdunTJhz70oYwfPz5Jtsr92Hbsu++++fm8OTnu+C9m3r+ek8YNz2X67S0ZNGhQR48GALBFGpubmzf75LFjxzavWrUq3bt3z6RJk3LnnXfmgAMOyNixY7Nq1aosWbIkN954Y3r27JkJEybknnvuSe/evXPFFVfkhRdeyH/+53/mpptuyr777ptrrrkmc+fOTffu3TNu3Lhs2LAhjzzySCZNmtS+5i9+8Yt069Yt1157bZJk9uzZueWWW9qPP/7442loaMh1112Xrl27bz7uXgAAF99JREFUZtasWbntttvajz/11FNZt25drr/++uyyyy6ZOnVqbr/99vbjy5Yty6pVq3LDDTfYkz3ZUwft6e67706S7LLLLp1mT53xeXqrPfXp0ycXX3xxdt9994waNSpdunTJo48+mvHjx6dbt245+uijc8YZZ7TvqampKb169cpVV12VKVOmtO/pmWeeyb777ptZs2ZlxowZueiii/Lyyy/nj//4j9PW1pbrr78+Byxblo2f/nT69++fG2+8MW1tbfmDP/iDHHnkkenWrVu+9a1vpbGxMffdd1/7ngYMGJDjjjsuu+22WwYPHty+p1GjRmXSpEl54YUXsmTJkuywww657LLLsnbt2vziF7/odM9TZ/xv74321NLSkgua/yGPLXgw/+vYYTn00EO3+T11xufJnuxpW91TS0tL/uiP/igzZ87sNHvqjM+TPdnTtrina6+9dnlzc/N1r+0wDW/0IY1vZuDAgW3z58/f7PMB/icNDQ35wQ9+kDPOOKOjR2Fb0Nz8uy8A6AB+bgHeLQ0NDQ+1tbUNfO3j3twNAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQkGgDAAAAUJBoAwAAAFCQaAMAAABQUFNHDwAAAPBeevLJJ3PXXXdt0bUzZszIpk2b3tY1vXv3zl/8xV9s0f2A7ZtoAwAAbFfu+dm9GTVqVHbu+7G8b8/em31dtz4fyU9//VJ+esOdm3V+W+umrH5kVg459DDRBtgiog0AALBd+cqXT02XJGf93dfTZeAX8v79Dtus63Z6G/doXf98Xrzjuxly5NDcOnniFs0J4DNtAACA7c6Xv3xqpt/eko13j8vaBVPT1ta21dZ+edWSPDfx3IwYNiTT75iSXXbZZautDWxfRBsAAGC7NGjQoCyY92B2eeqnWXv3D9LW+vY+q+aNrF+8IM9NPi+XXdycKy4bm8bGxq0wKbC9Em0AeFdcfvnlGTBgQA4++OCcfPLJeemll7J69eoMHTo0+++/f4YOHZo1a9a84bXTp09P//79069fv4wZM+ZVx0477bT06NEjBx98cPtjb7XuJZdckn79+qV///5v+qGTmzsXAJ1P37598/D8B/OR3V7OCy0XpvWlF7d4rbU/vyMbfnJlpk35t5z+la9sxSmB7ZVoA8BWt3Tp0lx55ZWZP39+/uM//iOtra2ZOHFixowZkyFDhmTRokUZMmTI64JMkrS2tmbUqFG58847s3Dhwtx0001ZuHBh+/FTTz0106dPf9U1b7buwoULM3HixDz22GOZPn16Ro4cmdbW1tfdc3PmAqDz+sAHPpCfTL8jJx31mTw38dy8vHrp27q+7ZXWvHj3D7Lzk7OyYN6DGTx48Ls0KbC9EW0AeFds2rQp69evz6ZNm7Ju3brss88+aWlpyYgRI5IkI0aMyG233fa66+bOnZt+/fplv/32S9euXXPSSSelpaWl/fjgwYOzxx57vOqaN1u3paUlJ510Unbcccf07ds3/fr1y9y5c193z82ZC4DOrbGxMdeM+36+2/zNPDfpm3np149u1nWvvPRiXrjtwhy08/o8/NDc7Lfffu/ypMD2RLQBYKv74Ac/mHPOOSd9+vRJz549s+uuu+aoo47Kb37zm/Ts2TNJ0rNnz6xYseJ11y5dujS9e//3n1/t1atXli596994vtm6m7vW5swFwPbhq2eemSm3Ts76u8bmxUemv+W5L69Zlud+fG5OPPKTuXvGndl1113foymB7YVoA8BWt2bNmrS0tGTx4sVZtmxZ1q5dmxtvvHGzrn2jv97R0NCwRXNszbUA2H589rOfzfwHH0i3/3dnXrzn+rS98vq31r70X4/muUnfzMXf/vuMv+aqNDU1dcCkQGcn2gCw1f3kJz9J3759s9dee2WHHXbIF77whcyePTt77713li9fniRZvnx5evTo8bpre/XqlSVLlrR///TTT2efffZ5y/u92bqbu9bmzAXA9mX//ffPIwvmpX/XNXlh6sV5ZcO69mNrH52R9dPH5rbJEzNq5MgOnBLo7EQbALa6Pn36ZM6cOVm3bl3a2toya9asHHjggRk2bFgmTJiQJJkwYUKOPfbY1117+OGHZ9GiRVm8eHE2btyYiRMnZtiwYW95vzdbd9iwYZk4cWI2bNiQxYsXZ9GiRTniiCM2+3oAtm+777577pk1I8cN+liem/T3eXnN8rz40x/mfQtvz7w5s3PkkUd29IhAJyfaAB2uW7duHT0CW9knPvGJHH/88Tn00EPzkY98JK+88krOOOOMjB49OjNnzsz++++fmTNnZvTo0UmSZcuW5fOf/3ySpKmpKePGjcuf/dmf5cADD8yJJ56YAQMGtK998skn51Of+lQef/zx9OrVK9dff/2brjtgwICceOKJOeigg3L00Ufn6quvTmNjY5Lk9NNPz/z585PkTa8HgB122CH/97rx+c65f5cVPxqV/ZtW5ZEF83LAAQd09GjAdqCxubl5s0++8MILm6dMmZJddtkl559/fq655pp89KMfzcknn5zHHnss8+bNy/nnn5+99947X/va13LDDTekb9++OeWUU/Lkk0/m3//933PBBRekX79+Of300zNp0qTsvvvu+au/+qssXbo0U6dOzcUXX9y+5u23357GxsaMHDkyv/3tb/PP//zPufTSS9uPz5w5M+vXr8/f/u3fZsOGDRk/fnwuu+yy9uP33Xdfli9fnnPOOSdNTU357ne/m6uuuqr9+Lx587Jo0aKMHj3anuzJnjpoTxdeeGGuu+66/OpXv+o0e+qMz9OW7Onss8/O/fffnz59+uSEE07IWWedlY0bN6ZLly556aWXMnbs2Jx22mmZOXNmmpqa8uCDD7bvaerUqfmnf/qnzJkzJ126dGnf06HPP5/ZXbuma9euufnmmzNv3ry0trbm6aefzi9/+cucd955eeKJJ/KjH/2ofU/du3fPpz71qaxYsSKDBg1q39PZZ5+d0aNH58knn8ycOXPy1FNP5corr8y9996bqVOnbjfPkz3Zkz3Zkz39z3vauHFjHv75gjQ1NubKKy7L6aefvs3vqTM+T/ZkT9vyniZNmrS8ubn5utd2mIY3+pDGNzNw4MC23/9WEgDec83Nv/sCAIBOpKGh4aG2traBr33c26MAAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtAAAAAAoSbQAAAAAKEm0AAAAAChJtgBJuvvnmfPrTn0737t3zvve9L/37988//uM/ZuPGjR09GrANe+KJJ/LXf/3X+djHPpbGxsb8yZ/8SUePBHQCkydPzrBhw/LBD34wO++8cw477LDcdNNNHT0W0Ak1dfQAAEmyatWq/Omf/mm+8Y1vZLfddsvcuXPT3NycZ555JuPGjevo8YBt1GOPPZZp06blk5/8pAgMbDWXXXZZ+vbtm8svvzx77rlnpk2bluHDh2flypU566yzOno8oBNpaGtr2+yTBw4c2DZ//vx3cRyA/3beeefl6quvzpo1a9LQ0NDR41BBc/PvvmAzvfLKK+nS5XcvLD7++OOzcuXK3HPPPR07FLDNW7lyZfbcc89XPTZ8+PA88MADWbx4cQdNBWzLGhoaHmpraxv42se9PQooq3v37n4zDrwjvw82AFvTa4NNkhxyyCFZsWJFB0wDdGbeHgWU0tramg0bNmTBggW58sor89WvftWrbACA8mbPnp2DDjqoo8cAOhnRBihlp512yoYNG5Ikp5xySi699NIOnggA4K3NmjUrLS0t+eEPf9jRowCdjNcMA6XMnj079957b8aOHZuWlpb8zd/8TUePBADwpp566qkMHz48xx57bE499dSOHgfoZLzSBijl0EMPTZIMGjQoe+65Z0aMGJGvf/3r+fCHP9zBkwEAvNrq1avzuc99Ln369MmNN97Y0eMAnZBX2gBl/T7g+CsMAEA169atyzHHHJONGzfmjjvuyE477dTRIwGdkFfaAGXdf//9SZK+fft28CQAAP9t06ZNOeGEE7Jo0aLcf//96dGjR0ePBHRSog1QwtFHH50jjzwyAwYMSGNjY+6///6MHTs2X/ziF701Cthi69aty7Rp05IkS5cuzfPPP5+bb745SfL5z38+3bp168jxgG3UyJEjM23atHz/+9/P6tWrM2fOnPZjhxxySHbccccOnA7oTEQboITDDz88N9xwQ5566qk0NTVlv/32yyWXXJIzzzyzo0cDtmErVqzICSec8KrHfv/94sWLs++++3bAVMC2bsaMGUmSs88++3XH/L8F2Joa2traNv/khoZnk/z63RsHAAAAYLvzoba2tr1e++DbijYAAAAAvDf89SgAAACAgkQbAAAAgIJEGwAAAICCRBsAAACAgkQbAAAAgIJEGwAAAICCRBsAAACAgkQbAAAAgIJEGwAAAICC/j/mZs+RD6Mo1gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x1440 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Temperature_Interval_Diagram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drawing the Combined Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEbCAYAAAA1T5h7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhU1fnA8e8LhB0VEBEBCbITNiGAsruBUgpi3assahGrP0TFtVattWprFR9rq9VaUGvFahVo1brggiwKCSCyiIJERBAQBNkh5P39ce6duQkzk0nIzCSZ9/M880zmLjPnzr2575xz7nmvqCrGGGMMQJVUF8AYY0z5YUHBGGNMiAUFY4wxIRYUjDHGhFhQMMYYE2JBwRhjTIgFhTQgIoNEREXknhKsc4+3zqDElazkRGSqV67MVJclXZTXY8EkhgWFUhKR9iLyJxFZJiI7ROSAiGwQkddF5EoRqZnqMpowEakjIhNF5D0R2eztr+0iskBEficiJ6W6jBWNFyg+SPJnniUiL4jIWhHZIyJ7RWS1iDwvIucksyyVVbVUF6AiEpG7gLtxQfVj4FlgF9AYGAT8DbgGyE5REcvC48A0YF2qC3KkROQU4BWgKbAeeAPYANQBTgZuBW4WkVNUdVHKClp+pfxYEJF6wHPAucA+4D3gVeAg0BIYClwmIg+r6qRUlbMysKBQQiJyB/Ab4BvgAlX9JMIyw4Cbkl22sqSq3wPfp7ocR0pE2gNvAXWB24CHVTW/yDItgd8DRyW/hOVfqo8FEakCvAwMAd4HLlPVDUWWqQGMB9omv4SVjKraI84HkAkc8B6dilm2RoRpFwKzgR3AXuAz4PYoy+Z5j7rAZFwQ2gssAc71lqkG3AF8ifv1tAa4LsJ7DQIUuAc4FXjXK8NO3AkzO8I693jrDCoyXYEPgGOBp4CNwH5gOTA2xvcxBPcL/Xtv+TXAQ8AxUZY/E/gI2A1sA6YD7YGpXhky49xn73jL3x/HsjWKvG6D+3X6rbfPN3iv28T6voBLgFxgj7fOI/57A6d739+PwA/A80DDGPv/aNwv9W+9fbwCmABIlG0oyTHWBXjR+5z9wBZgEfAokBHtWADGeK8jPe4p8hm9cbW077zv8Bvgr8AJJfi/+7n33l8CdeLdh9GO4cD/sgJTi0z3j6+TgP8Dlnrf4wfeflXgkWif7e3T74BqReZdggtoP3j7cSVwZ6T9kupHygtQkR64GoICL5Zi3fu9dbcAT+BOiMsIn2Qziiyf550I5gOrvBPDU7gT+SHgDODfuOaQp735m7z3u6jIew3ypr/p/fO/7pXnX0C+d9D3L7JOxH8ob9oSr0yfAX/yPv8Hb97oCNt+lzdvK66p7SFcMFJcMDmqyPLne9u41/snfQAXIH4APiTOoIBrVlDvfSIGnxjr9sSdWAtwAel+XHPFIW96tkb+vv6NCwb/BB72viP1tmOk9/2/CvwRmOfvlwifn4cLKAtxJ8OHve96g7fOn4/kGMMFhL1eWad53/Gfvf1yAKgb7VgAugWm5Xl/+49BgfXGesfXblzw+QPwmvcdbgBOjHNf+Pv86hLuw0LlLjIvk9hB4T/AduAF4EHgd0BNb9omipz0vXUv9Nb9Y5Hpz3jTv/H+fhiY6017P9J7pfKR8gJUpAcwy9uRV5VwvVO99dYBxwemV/MOPgXuKLJOXuDgDP766e9N3+adMI4JzDvJ+4deXOS9BhH+JXddkXkjCP8KqxKYHvEfKvA+fwOqBqZ39E4AK4osf5q3/DyKnJgJ/+KcHJhWFxc8DnL4iXdy4PMz4/jeL/eWnVPC/SW4X3IK/LzIvIu86Z9H+b52AB0C02vgAt8hb7sGBuZVIVyT6RZl/88psv8b4GpZCgwo7TGGOzEpMCLC9tcvwbHwQZTvsK13LK4GmhaZd7r3fbwWx76ohgukCrQu4X6MWG5vXiaxg8K3QMsI6/3Vmz8swrzXvXmdIxzjrwK1opTv+pJsV6IfKS9ARXrgqu4KnF3C9Z721hsXYV5b7x/kqyLT/ZNCqwjrfOXNOz3CvPdxJ+fgCXsQEU78gfkfePMHBqbFOhHspsive2+e/4uuXmDaa960rCjfzWJgc+C131TwbIRlj8b9Uos3KNziLTuthPurr7fevCjzP+Lwk7L/ff02wvJ+Tem5CPNGE6GGFdj//SOs459oppT2GCMcFAbH8X3EOhY+iLKOH8B/EmX+a95xWq+Yzz6O8A+BmiXcjxHL7c3LJHZQiHiiBvp4818uMv14b3sWRTi+DxKhpgpUxTWnLijJdiX6YR3NJSPes5Zwve7e83tFZ6jqFyKyHmgpIseo6vbA7O2quibC+23ANY3kRpj3Le5gO977O+gjVS2IsM4HwEDclTgfxtoQz5eq+mOE6d94z8fgmrnA/YI9CFwgIhdEWKc60EhEGqrqVsLf1WHlUNUdIrLEK2s8ynx/Bab3w31fs4vMy4mwvN8pGm1/ATSLMC8fV8Mq6gPv+eTAtJIeYy8B1wPTReQVXD/T3CjHW2mc6j0PFJGeEeYfhztO2xL5e/FJjHmJtCDSRFWdJyJfAD8Vkfqq+oM36+e47ZnqLysitYGuuBP/RJGIm7If6FCG5T5iFhRKZgOuszPSP3AsR3vPG6PM3wicSPiXsG9HlOXzwZ0ko80DMiLM2xTl/b4rUs7ibI8y3f/sqoFpDXHH2d3FvKffbOSXobiyxsM/GSdif4ELfkXF2icl3V/fq+qhCNMj7a8SHWOqukBE+gO/wvXhXA4gIquA36jqi1HeJ14Nveebi1mubjHzt+KaoarjLikuq6BVnFjH2bO4PoaLcX034Gp8B3F9J776uKDWiOKP/3LDBq+VzBzv+YwSruefDI6PMr9JkeUSpXGU6X65EvH5O4AfVFWKeXxdpAzFlTUe/v7KFpF4A16wDKneX8eKSNUI0yPtrxKXWVXnq+ow3MmrL/Bb3Pf+TxE5s9SlLvw5Rxez32PWTNVdPvyx97Kk/3d+rTjSj99IAb3QR8eY97z33qMBRORkoDPwhqpuCSznfweLizv+i9+U5LGgUDJTcL8GfiYiHWMt6F037VvsPQ+KsFxr3C/ZtUWajhKhn3fNd1F+uRZHmHekPgbqi0hWnMv7g8cOayLyTuzd4v1gVV2LaxapSfG/WIP7LOr+KjI90QPdquHasKN9fnB/lfoYU9X9qjpPVe/CXe4K7gKE4hRQuFYY5J/I+8fxPsV5ynue5DXJRFXk/85v2mkeYdFSDyxV1W9wzXS9RaQdXnDA1SCCy+3CXWSQJSINSvt5yWZBoQRUNQ/XeVUdeF1EIh5YInI27vJP39+95ztFpFFguaq4SxOr4C5VS7Q2wC+DE0RkBO4EvBrXgVrWJnvPT4vICUVneuknTglMmoH7Z740wvd7D/E3cfn+Dzcm4HYRuUlEDvvVKCInisg0wu3gc3GX3PYTkfOLLHs+MAD4gnBNJJEeCJ7ovJPLnd7LKYHlSnSMiUj/KLUnv4a2J46ybSXyCRfcJdIHgckictiAMhGp7jVfxeNF3KWybYAZItKk6ALe+12L60D3+f0CY4P7XUSa4zr/j8RU7/lK3BiErcB/Iyz3CO588XcROax2IiL1RaT74auljvUplJCq3u8dYHcDC0VkHq5z0U9zMQB38OYE1pknIn/AXQ2zzOvY2w2cA3TCnVweSkLx/wc87OWI+RRoDZyHG0xzZZRO6COiqrNE5DbcdfBfisgbwFpcW3ILXECaA5ztLb9LRMbhOkI/EpGXcO3h/XDf1Wzcdxzv538uIkNw4wf+CFwvIrMIp7noSvhqo99766iIjMZdLvqSiMzAXYLaDpdmYScwKhHfVxEbcZe0LhORmbh+h/NxTUF/UdVQJ3cpjrGbgMFe7qKvcMdvlrf8D4R/nccyC7hYRP6D6yzOB2ar6mzve78CF6yWi8j/cIE0A9e30R83nqJ9cR+iqgXeRQrP42owX3n7cCXuqqoWuKalRrh97K/3iYj4x8sCEXkP9z/6U1yQiRbQ4vEq7sfGRG+b/qSqByOU/e8i0gP3Y2yNiLyFu2y4Ae5ikQG44D7+CMpStlJ9+VNFfeCuGPgTbnDQj7jOsI24GsKVRB5BejHun3Mn7kS8HNfRd9ildngjWqN89gdu10WcN5Uil2wSeUTzj1453gZ6Rnifeyj5ZYiHfXZgXj/cYLkN3ne1BTcI7hEij6g+y/uu9uBOUjMoxYjmwPvVBW7AXbK7GfcrdgfuZPYAka9Jb4c7EW30lt8I/ANoF+/35c0b480bE2FeaN9E2v+4mtGfcVcp7cedCGONaI7rGAMG405GK7zvYTeudvQY0CLOY+E43CC9TbiTc6Tt6Ozts6+98m/D/c/8lQiXVMexHwd7n7kWN/huHy6o/ZMIl4rj+g6e9vb5fu+zx1H8JanFHl+4sTr+5bI9ill2GK4msRl3/H+Hq8ncB7Qv6feQyId4BTbGlCMikgegqpmpLYlJN9anYIwxJsSCgjHGmBALCsYYY0KsT8EYY0xIhb4k9dhjj9XMzMxUF8MYYyqU3Nzc71W1UaR5FTooZGZmkpMTKf+YMcaYaETk62jzrE/BGGNMiAUFY4wxIRYUjDHGhFToPoVIDh48yPr169m3b1+qi2IqsJo1a9KsWTMyMiLd5sCYyqvSBYX169dTr149MjMziXKnI2NiUlW2bt3K+vXradmyZaqLY0xSVbrmo3379tGwYUMLCKbURISGDRtabdOkpUoXFAALCOaI2TFk0lWlDArGGGNKx4JCAtStW/he5FOnTuW6666Luc706dNZsWJF1PnPPfccnTp1Iisri44dO/LHP/4x6rLJ9uSTT/Lcc88Bbls3bNhQ4vcoz9tnTDpJWFAQkb+LyGYRWRaY9pKILPEeeSKyxJueKSJ7A/OeTFS5yqtYQeHNN9/k0Ucf5e2332b58uUsWrSIo48u6V0pE2f8+PGMGjUKKF1QONLty8/PL9HnGWNiSNTde3C3mesOLIsy/2HgLu/vzGjLxXr06NFDi1qxYsVh05KtTp06hV5PmTJFr732WlVVzcvL09NPP107d+6sp59+un799dc6d+5crV+/vmZmZmrXrl119erVhdbv37+/zpo1K+JnLV68WHv37q2dO3fWc889V7dt26aqqgMHDtSJEydq//79tX379rpgwQIdOXKktm7dWn/1q1+pquratWu1Xbt2OmrUKO3cubP+7Gc/0927d6uq6rvvvqvdunXTTp066dixY3Xfvn2qqnrrrbdqhw4dtHPnznrTTTepqurdd9+tDz30kL788stap04dbdu2rXbt2lX37NmjOTk5OmDAAO3evbsOHjxYN2zYcNg2xNq+gQMH6sKFC1VVdcuWLdqiRYvQd3r++efrsGHD9LTTTtMLL7xQX3/99dB6o0eP1ldeeUXz8/N10qRJmp2drZ07d9Ynn3wyyl47XHk4loxJBCBHo527o80oi0e0kz0gwDdAm1jLFfcoNihcf73qwIFl+7j++mK/8CpVqmjXrl1Dj+bNm4eCwrBhw3Tq1KmqqvrMM8/oiBEjVNWdxF5++eWI71e/fn3dvn17xHmdO3fWDz74QFVVf/3rX+v1XvkGDhyot9xyi6qqPvroo9qkSRPdsGGD7tu3T5s2barff/+9rl27VgGdM2eOqqqOHTtWH3roId27d682a9ZMV61apaqql19+uU6ePFm3bt2qbdu21YKCAlVV/eGHH1Q1HBT8z/VP4gcOHNBTTz1VN2/erKqq06ZN07Fjx5Zo+2IFhaZNm+rWrVtVVfXVV1/VUaNGqarq/v37tVmzZrpnzx7961//qr/97W9VVXXfvn3ao0cP/eqrryJ+VlEWFExlFSsopKpPoT+wSVW/DExrKSKLReRDEekfbUURGSciOSKSs2XLlsSXtBRq1arFkiVLQo977703NG/+/PlceumlAFx++eXMmTOn1J+zY8cOtm/fzsCBAwEYPXo0s2eH7uXO8OHDAejcuTNZWVk0adKEGjVqcNJJJ/HNN98A0Lx5c/r27QvAZZddxpw5c1i1ahUtW7akbdu2hd73qKOOombNmlx11VW8+uqr1K5dO2b5Vq1axbJlyzjrrLPo1q0b9913H+vXry/19hZ11lln0aBBAwDOOecc3nvvPfbv38+bb77JgAEDqFWrFm+//TbPPfcc3bp1o3fv3mzdupUvv/yymHc2Jn2lavDaJcCLgdcbgRNVdauI9ACmi0iWqv5YdEVVfQp4CiA7Ozv2zSAefbTsSpwg8Vz6mJWVRW5uLqeffnqJ3rtGjRoAVKlSJfS3/9pvhy/6+SLi1+YOU61aNRYsWMCsWbOYNm0ajz/+OO+9917Uz1dVsrKymD9/fsxyxtq+atWqUVBQAHDYuIE6deqE/q5ZsyaDBg3irbfe4qWXXuKSSy4JleFPf/oTQ4YMiVkGY4yT9JqCiFQDzgNe8qep6n5V3er9nQusAdomu2zJ0KdPH6ZNmwbACy+8QL9+/QCoV68eO3fujLjO7bffzi233MJ3330HwP79+3nsscc4+uijqV+/Ph999BEAzz//fKjWEK9169aFTtovvvgi/fr1o3379uTl5bF69epC77tr1y527NjB0KFDefTRR1myZMlh7xfcjnbt2rFly5bQ+x88eJDly5fHvX3g0qPn5uYC8Morr8TclosvvpgpU6bw0UcfhYLAkCFDeOKJJzh48CAAX3zxBbt37y7Rd2RMOklFTeFM4HNVDbUjiEgjYJuqHhKRk4A2wFcpKFvCPfbYY1xxxRU89NBDNGrUiClTpgDuhPaLX/yCxx57jFdeeYVWrVqF1hk6dCibNm3izDPPRFUREa644goAnn32WcaPH8+ePXs46aSTQu8Xrw4dOvDss89y9dVX06ZNG6655hpq1qzJlClTuOCCC8jPz6dnz56MHz+ebdu2MWLECPbt24eqMnny5MPeb8yYMYwfP55atWoxf/58XnnlFSZMmMCOHTvIz89n4sSJZGVlFVon1vZNmjSJCy+8kOeff77YmtLgwYMZNWoUw4cPp3r16gBcddVV5OXl0b17d1SVRo0aMX369BJ9R8akk4TdjlNEXgQGAccCm4C7VfUZEZkKfKyqTwaW/RlwL5APHPKW/U9xn5Gdna1Fb7KzcuVKOnToUFabUanl5eUxbNgwli1bVvzCaciOJVNZiUiuqmZHmpewmoKqXhJl+pgI0/4N/DtRZTHGmHJl0ya4+Wa4/nro0SPVpSnERjSnsczMTKslGJNMhw7BX/4C7drBSy9BhH65VLOgYIwxyZCTA717w7XXQs+e8NlncOWVqS7VYSwoGGNMIm3f7gJBr16wYQNMmwZvvw1ty+cFlhYUjDEmEVThH/9wTUVPPgkTJsDnn8NFF0E5Ts1e6e68ZowxKbdiBfzyl/Dhh67J6H//g5NPTnWp4mI1hQT47rvvuPjii2nVqhUdO3Zk6NChfPHFF1GXz8vLo1OnThHnDRo0iKKX3YIbCHbbbbfRpk0bOnXqRK9evXjzzTfLbBuO1FVXXRXK+nr//feXeP3yvn3GRLR7N9x+O3TtCkuXwl//CvPmVZiAAFZTKHOqysiRIxk9enRo5PKSJUvYtGlTKJdQWfj1r3/Nxo0bWbZsGTVq1GDTpk18+OGHZfb+R+pvf/tb6O/777+fO+64o0TrH+n25efnU62aHd4miWbOdE1EX38NY8bAH/4AjRqlulQlFy1TXkV4lMfU2bNmzdL+/ftHnFdQUKCTJk3SrKws7dSpk06bNk1VXQrrrKwsVVXds2ePXnTRRdq5c2e98MILtVevXqEsob7du3drgwYNdMeOHRE/55///Kd26tRJs7KyQplSVV1K71tuuUW7d++uZ5xxhn7yySc6cOBAbdmypc6YMUNVXfbR4cOH65AhQ7Rt27Z6zz33hNZ/+OGHNSsrS7OysnTy5Mmqqrpr1y4dOnSodunSRbOyskLb5Gc3vfXWW0NZYy+99FJVVX3++ee1Z8+e2rVrVx03bpzm5+eXaPuCqclffvllHT16tKq6TLM33HCDDho0SCdOnKgtWrQIZXJVVW3VqpV+9913unnzZj3vvPM0Oztbs7OzQ1lii0r1sWQqiLVrVYcPd0mns7JUZ89OdYmKRYwsqZX6p9TEiWV/GXC3brHz7C1btoweUQajvPrqqyxZsoRPP/2U77//np49ezJgwIBCyzzxxBPUrl2bpUuXsnTpUrp3737Y+6xevZoTTzyRo4466rB5GzZs4NZbbyU3N5f69eszePBgpk+fzrnnnsvu3bsZNGgQv//97xk5ciR33nkn77zzDitWrGD06NGhrKoLFixg2bJl1K5dm549e/KTn/wEEWHKlCl88sknqCq9e/dm4MCBfPXVV5xwwgm8/vrrgMvcGvTggw/y+OOPh/IkrVy5kpdeeom5c+eSkZHBL3/5S1544YXQTXqK277ifPHFF7z77rtUrVqVgoICXnvtNcaOHcsnn3xCZmYmjRs35tJLL+WGG26gX79+rFu3jiFDhrBy5coSf5ZJcwcOwCOPwL33QpUq8NBDbjBaRkaqS3ZEKnVQKG/mzJnDJZdcQtWqVWncuDEDBw5k4cKFdOnSJbTM7NmzmTBhAgBdunQpNC8eCxcuZNCgQTTyqq0///nPmT17Nueeey7Vq1fn7LPPBlw67Ro1apCRkUHnzp3Jy8sLvcdZZ51Fw4YNATjvvPOYM2cOIsLIkSNDmUnPO+88PvroI84++2wmTZrErbfeyrBhw+jfP2rWcwBmzZpFbm4uPXv2BGDv3r0cd9xxJdrGWC644AKqVq0KwEUXXcS9997L2LFjmTZtGhdddBEA7777bqG73P3444/s3LmTevXqlVk5TCX3/vuuI/nzz+G889wvxebNU12qMlGpg0IqMmdnZWVFzeapceaZKi6dduvWrVm3bl3EE1msz8jIyAi9dzCddjCVdqTPj5VOu23btuTm5vLGG29w++23M3jwYO66666oZVBVRo8ezQMPPFCq7StavljptE899VRWr17Nli1bmD59OnfeeScABQUFzJ8/n1q1akUtgzERbdoEkya5S01btoTXX4ehQ1NdqjJlVx+VsdNPP539+/fz9NNPh6YtXLiQDz/8kAEDBvDSSy9x6NAhtmzZwuzZs+nVq1eh9QcMGMALL7wAuKaopUuXHvYZtWvX5sorr2TChAkcOHAAgI0bN/KPf/yD3r178+GHH/L9999z6NAhXnzxxRKn037nnXfYtm0be/fuZfr06fTt25cBAwYwffp09uzZw+7du3nttdfo378/GzZsoHbt2lx22WVMmjSJRYsWHfZ+GRkZodTVZ5xxBq+88gqbN28GYNu2bXz99ddxbx9A48aNWblyZah5KBq/dnPjjTfSoUOHUO1n8ODBPP7446HlIqUAN4ZDh9ylpc895zqQ+/SBFi1ceoo774TlyytdQIBKXlNIBRHhtddeY+LEiTz44IPUrFmTzMxMHn30UQYMGMD8+fPp2rUrIsIf/vAHjj/++EJNN9dccw1jx46lS5cudOvW7bCg4bvvvvu488476dixIzVr1qROnTrce++9NGnShAceeIDTTjsNVWXo0KGMGDGiRNvQr18/Lr/8clavXs2ll15KdrZLpjhmzJhQea666ipOPvlk3nrrLW6++WaqVKlCRkYGTzzxxGHvN27cOLp06UL37t154YUXuO+++xg8eDAFBQVkZGTw5z//mRYtWsS1feD6KYYNG0bz5s3p1KkTu3btirotF110ET179mTq1KmhaY899hjXXnstXbp0IT8/nwEDBvDkk09GfQ+TBgoKYM0al4pi4UL3vGiRu8QUoE4dl7ju2mth3Dg3IK2SSljq7GSw1Nllb+rUqeTk5BT6JZ2u7FiqpFTdZaP+yT8nB3Jzwb9IomZNN64gOzv8aNcOvL6qyiAlqbONMSblVF2+oWAAyMmBrVvd/IwMN9DskktckrrsbOjYEdJ4jEv6brmJaMyYMYwZMybVxTCmdDZtKnzyz8kB7zavVK0KnTrBueeGA0CnThC4f7mppEFBvVs6GlNaFblZNW1s3eqaffyT/8KFsN67y6+I+8U/ZEi4CahrV7ArzopV6YJCzZo12bp1Kw0bNrTAYEpFVdm6dSs1a9ZMdVGMb8cO1/Eb7AheuzY8v21bGDAgHABOPhnq1k1deSuwShcUmjVrxvr169myZUuqi2IqsJo1a9KsWbNUFyM97doFixcXbgIKJpRs2dKd+MePd889esDRR6euvJVMpQsKGRkZtGzZMtXFMMbEY+9e+PTTwgFg5Up3iShAs2buxD9qlOsH6NEDvPEmJjESFhRE5O/AMGCzqnbypt0D/ALwf8bfoapvePNuB64EDgETVPWtRJXNGJMCBw64W1AGA8CyZeCPpj/uOHfiv+CCcA3g+ONTW+Y0lMiawlTgceC5ItMnq+ofgxNEpCNwMZAFnAC8KyJtVfVQAstnjEmU/Hw3GjjYCbx0qQsMAA0auADwk5+E+wGaNi3XdyRLFwkLCqo6W0Qy41x8BDBNVfcDa0VkNdALmJ+g4hljysqhQ67NPzgWYMkS1zQEcNRR7qQ/cWI4AGRmWgAop1LRp3CdiIwCcoCbVPUHoCnwcWCZ9d60w4jIOGAcwIknnpjgohpjClGF1asLNwEtWuQ6h8Glg+jePdwJnJ0NrVu71NKmQkh2UHgC+C2g3vPDwBVApJ8MES8UV9WngKfApblITDGNMaF0EEUHgwXTQXTr5u4y5g8Gq2TpINJRUoOCqm7y/xaRp4H/ei/XA8Fk5M2ADUksmjHpzU8HUTQAfP+9m5+RAV26uHQQfg2gY8cKf0MZc7ikBgURaaKqG72XI4Fl3t8zgX+KyCO4juY2wIJkls2YtLJ5c+GBYEXTQWRlwYgR4QDQubOlg0gTibwk9UVgEHCsiKwH7gYGiUg3XNNQHnA1gKouF5F/ASuAfOBau/LImDKybdvhNYBvvnHzRKBDBxg8uHA6iNq1U1tmkzKVLnW2MWktmA7Cf3z1VXh+mzaFU0KffDLYbUjTjqXONqYy2r378HQQq1aF52dmuhP/uHGuI7h7dzjmmJQV11QMFhSMqQj27Qung/D7AYLpIJo2ddSow2MAAB+fSURBVAHg8svDo4GPPTa1ZTYVkgUFY8qbAwdc+odgJ3CkdBDnnx8OAE2apLbMptKwoGBMKhVNB5GT42oEwXQQ2dlwyy3hfoBmzWw0sEkYCwrGJIufDiIYABYvLpwOokcPuP76cABo2dICgEkqCwrGJIIqrFlTOCFcMB1E7dqu4/fqq8OjgS0dRKW3axcsWABz57rHNde44SDliQUFY46UKqxbV7gTODcXtm9382vUcOkgRo8OB4D27S0dRBr45ht38p83zz1/+qmrMIq420Pv25fqEh7OgoIxJbVhQ+FO4EjpIC66KNwElJVl6SDSQH6+yw7u1wLmzQuPEaxTB3r3hjvugD594JRTyu/VwRYUjInFTwcRfGz0MrX46SCGDy+cDsLu7ZwWduyA+fPDtYBPPnFDR8BdC9C3b/jRpQtUqyBn2wpSTGOSYNs21+wTDADr1rl5Iq7J58wzwwGgWzdLB5EmVGHt2sJNQcuWuelVqrhDYezYcBBo3rz49yyvLCiY9PTjj+F0EH5TUDAdROvWrp4/YYLrB7B0EGnlwAF3YViwKcjPF3jUUXDqqe6uoX36uGahunVTW96yZEHBVH67d7s7gQX7AYLpIFq0CKeDyM52VwXVr5+68pqk27rVnfj9WsDCheFO4JNOchVEvxbQsWPlvkbAgoKpXILpIPzHihXhdBAnnOBO/JddFh4N3KhRastskkrVDRcJ1gI+/9zNy8hwvwl++UtXC+jTJ/0Gi1tQMBWXnw4iGAA++yycDqJRI9f0c9554QBwwgmpLbNJur173aHh1wLmzXM1A3ADxvv0cVcL9+3rDpNatVJb3lSzoGAqhvx8lwAuOBgsmA6ifn33H33zzeGO4ObNbTRwGtq0qXAtIDcXDh5089q1cxeL+U1BbdvaeMGiLCiY8qegIJwOwu8HCKaDqFfP/eqfMMGd/Hv2tHQQaaqgwLUO+kFg7tzw9QI1arhD48Ybw01Blji2eBYUTGr51/otWBCuBSxaBDt3uvm1a7srf/x7AmRnuxvF2M+7tLR7txsP4DcFzZ/vxguASx7bt6/rD+jb1x02dgfRkrOgYJIvP9/9V8+YATNnwurVbnqNGu5WkKNGhZuA2revOKN+TJlbv75wU9CSJeE0EVlZcPHFrgbQt6+7Ssgqi0fO/ttMcuzcCW+95YLA66+7gWLVq8Ppp8PEie4/OyvLTTNpyU8T4dcC5s4Np4moXduNB7j9dhcAynOaiIrOgoJJnPXr4T//cYHgvfdcp3CDBvCTn7jUkIMH24CwNLZjB3z8cbgW8Mkn4SSyTZu6k/+kSeE0EZY+KjliBgURORW4DOgPNAH2AsuA14F/qOqOGOv+HRgGbFbVTt60h4CfAgeANcBYVd0uIpnASsAfUfSxqo4v/WaZlFB1VwTNnOkeublueuvW8H//5y776NPHmoPSkN91FKwFBNNEdO0KY8aEm4JOPDHVJU5fUf87ReRNYAMwA/gdsBmoCbQFTgNmiMgjqjozyltMBR4HngtMewe4XVXzReT3wO3Ard68Nara7Qi2xaTCgQPw4YfhQLBunWvYPeUUePBBFwjat7fG3jQTTBPhBwI/TUS9ei5NxPnnuwDQq5dVGMuTWD/ZLlfV74tM2wUs8h4Pi0jUC7xUdbZXAwhOezvw8mPg/BKV1pQPP/wAb77pOor/9z+XR6hWLdccdPfdrnmoceNUl9Ik0bZthWsBwTQRLVu6NBF+LSArq3KniajoYgWFY0SknarODU4Ukf7ABlVdEyFolMQVwEuB1y1FZDHwI3Cnqn4UaSURGQeMAzjR6pjJ89VX4drA7NnuEpDGjeHCC11t4MwzbShomvDTRASDgJ8molo1lybimmtcAEjHNBEVXayg8ChwR4Tpe715Py3th4rIr4B84AVv0kbgRFXdKiI9gOkikqWqPxZdV1WfAp4CyM7O1tKWwRSjoMD93PMDwbJlbnpWlruJ/IgRbtyAjReo9Pbtc8NH/KagefPC9xSqX9+d+EeNCqeJsGziFVusoJCpqkuLTlTVnKLNQiUhIqNxHdBnqKp677kf2O/9nSsia3B9Fzml/RxTCnv3wqxZLgj85z+uEbhqVejfHyZPhp/+FFq1SnUpTYJt2lS4FhBME9G2rTsM/Kagdu3sd0FlEysoxLp9VKnaCUTkbFzH8kBV3ROY3gjYpqqHROQkoA3wVZS3MWVp82Y3bmDGDHj7bRcY6tWDc85xzULnnOMuIzWVUjBNhB8I1qxx82rUcL/8b7jBBYBTT7WEsukgVlBYKCK/UNWngxNF5Eogt7g3FpEXgUHAsSKyHrgbd7VRDeAdcVej+JeeDgDuFZF84BAwXlW3lWJ7THFU3b0E/NHE8+e7ac2bwxVXuEAwcKDlB6ikdu92GUX8WkCkNBHjx7vn7t3tMEhH4rXgHD5DpDHwGm5MgR8EsoHqwEhV/S4pJYwhOztbc3KshalYfloJv3/gyy/d9O7dXRAYMcJdKG6XjVY6fpoIvxbgp4kA1z3kZwvt08e1DNohkB5EJFdVsyPNi1pTUNVNQB8ROQ3o5E1+XVXfS0AZTVnbudM1B/lpJbZudUNCTz/dtQcMG1axbyRrDpOf724nEQwC/i2ma9d24wFuuy2cJsJuLmciKXZoqaq+D7yfhLKYI/Xtt+G0ErNmFU4rMXy4G0dw1FGpLqUpIzt2uNQQflNQpDQRN97onrt2tTQRJj6xRjRfAPwcUGCaqr4UbVmTIqoug5jfP+CnlWjVCq67Lnw3EUsrUeGpQl5e4VrAZ5+F00R06RK+e1ifPi5NhDUFmdKIdba4Fejl/b2QwgPNTKrESivxwAMuEHToYGeECu7AAdf+H0wbvXGjm+eniTjvPBcEeve2NBGm7MQKCv8gnLfo5SSUxUTjp5WYOdM9+2klzjoL7rrL9Q9YWokKzU8T4dcCFi4M32guM9N1Bfm1gE6dLE2ESZxYHc2Pikgd3BVKu5JYJgMupWQwrUR+vrtm8IIL3NVCZ5xhQ0crKFV3AViwFrBypZtXrZq7Y9jVV4eDwAknpLa8Jr3E6lMQVd0da2VvGUs1URYKClwugZkzXR+Bn1aiY0d3M/rhw93lIzZ8tMLx00T4tYBIaSIuu8wFgZ49Ldab1IrVfPS+iPwbmKGq6/yJIlId6AeMxl2VNDWhJazM9u51N5+ZMePwtBKPPOLyCbRunepSmhLavLlwh3BurusjAHd76WHDwrWA9u0tzpvyJVZQOBuXyfRFEWkJbMelvqgKvA1MVtUliS9iJeOnlZg5040j2LMH6tYtnFaiYcNUl9LEqaDANf0Em4L8W05Xr+5++V9/fTgIWJoIU97F6lPYB/wF+IuIZADHAntVdXuyCldpfP55uH9g3jzXqNysmbvV1IgRllaiAvHTRPi1gPnzYbv3H9GokTv5X321CwA9ethuNRVPXBewq+pBXHprE4/8fHe28APBF1+46Sef7G5CM3w4dOtml41WAN9+W7gWsHhxOE1Ex46u39+vBbRubbvUVHw2qqms7NrlmoNmzDg8rcT117v+AUsrUa4dOuTGAgbTRvtpImrVcuMBbr01nDHU0kSYysiCwpGIlFaifv1wWokhQyytRDn244/w8cfhIPDxx+E0ESecEE4T0aePq9hZmgiTDuIKCiLSAmijqu+KSC2gmqruTGzRyiE/rYTfLORnaD3pJLj2WhcI+vWztBLlkCp8/XXhpqDPPnMdxX6aCP/uYX37WpoIk76KPXuJyC9w90RuALQCmgFPAmcktmjlxIEDbvCYHwi+/tqdLXr3hvvvdx3Fllai3Dl40LX/B8cGbNjg5tWr57KC3HWXqwX07m0VOmN88fykvRaXA+kTAFX9UkSOS2ipUm37dpdOYsaMcFqJmjVdWolf/9o1Dx1/fKpLaQK2bXN9+34AWLAgnCaiRQsYNCjcIdy5s6WJMCaaeILCflU94N0pDRGphsucWrnESisxfDiceaYNNS0n/DQRwQ7homkixo0LB4GmTVNbXmMqkniCwocicgdQS0TOAn4J/CexxUqCYFqJmTNdAzO46wwnTQqnlbCflCm3b58bFRxsCtqyxc075phwmog+fdwus9htTOnFExRuBa4CPgOuBt4A/pbIQiWMn1Zi5kx31dDGja6XsX9/ePhhFwgsrUTKbd5cOADk5BROEzF0aLhD2NJEGFO2YgYFEakCLFXVTsDTySlSGduyJZxW4q23wmklzj7bdRJbWomU8tNEBJuCgmkisrPdMI8+fdzjuMrdm2VMysUMCqpaICKfisiJwaR48RCRvwPDgM1eUEFEGuBu1pMJ5AEXquoP3rzbgSuBQ8AEVX2rhNsStmpV+G5kflqJpk3dralGjHC9jpZ/ICX27HGdwH4tYP58d7sIcGki+vQJ9wd07+76940xyRNP81ETYLmILABCqbRVdXgx600FHid8ox6A24BZqvqgiNzmvb5VRDoCFwNZwAnAuyLSVlUPxbUVhw65M0yktBJ33eWahU4+2S4bTYFvvy1cC1iyxPXhg+u++dnPwk1BlibCmNSLJyj8pjRvrKqzRSSzyOQRwCDv72eBD3B9FiNw94HeD6wVkdW4y2Dnx/yQ7dtdUrn//jecVuK002DCBJdW4sQTS1N0U0qHDrn++mAQ+PprN69WLdcJfMstrjZw6qnQoEFqy2uMOVyxQUFVPyzDz2usqhu9990YGO/QFPg4sNx6b1psa9a4YOCnlTj7bBuFlEQ7d7rUEH5T0Mcfu2kATZq4X/8TJ7pnSxNhTMUQz4jmnYTHJVQHMoDdqlqWZ99IjQYRx0KIyDjcCGtaN24M33xjZ5sk8NNEBGsBwTQRnTvD5Ze7WkDfvm7AmDUFGVPxxFNTqBd8LSLn4pp2SmOTiDTxaglNgM3e9PVAMIVoM2BDlPI8BTwFkJ2drRYQEuPgQdf+H7yDmJ8mom5dlybi1792AcDSRBhTeZQ4c5uqTvc6iUtjJu42ng96zzMC0/8pIo/gOprbAAtK+RmmFH74IZwmYu7cyGki/FqApYkwpvKKp/novMDLKkA2caS5EJEXcZ3Kx4rIeuBuXDD4l4hcCawDLgBQ1eUi8i9gBZAPXBv3lUemxFTdWIBgLWDFCjevatVwmgg/CFiaCGPSRzw1hZ8G/s7HjS8YUdxKqnpJlFkRs6uq6u+A38VRHlNC+/e7NBF+EJg3z40aBpcm4tRT4dJLXQDo2RPq1ElteY0xqRNPUPibqs4NThCRvoT7A0w5s2VL4Q7hYJqI1q3dIG6/FtChg6WJMMaExRMU/gR0j2OaSYGCAvj888JNQV9+6eZVr+5uHj9hQvgWko0bp7a8xpjyLWpQEJFTgT5AIxG5MTDrKMC6GVNkzx5YuDBcCwimiTj2WHfyv+oq99yjh6WJMMaUTKyaQnWgrrdM8LLUH4HzE1koE7ZhQ+FawOLF4TQRHTq4NBF+U1CbNjY2wBhzZKIGBW8k84ciMlVVv05imdLWoUOwbFnh+wjn5bl5NWu6NBE33+wCwCmnWHJXY0zZi6dPYY+IPIRLVhdqjFDV0xNWqjThp4nwawGR0kT4/QHdurk+AmOMSaR4gsILuHTXw4DxuEFnWxJZqMpIFdatK9wUtHSp6ygWcQPCLrssfAvJzExrCjLGJF88QaGhqj4jItcHmpTKMklepXTwIHz6aeGmoG+/dfP8NBF33hluCrI0EcaY8iCeoHDQe94oIj/B5SRqlrgiVUx+mgi/FrBggbtSCFwG7wEDwrWAzp3dDeaNMaa8iefUdJ+IHA3chBufcBRwQ0JLVc6puqzdwVrA8uVuXtWqrv3fvyy0Tx9oZiHUGFNBFHeP5qpAG1X9L7ADOC0ppSpn/DQRwZvJ+2kijj7anfgvvtgFgV69LE2EMabiKu4ezYdEZDgwOUnlKReCaSLmzXNpIvbvd/NatXL38vFrAR07WpoIY0zlEU/z0TwReRx3BVLwHs2LElaqJCoogFWrwk1BwTQRGRmQnQ3XXRcOApYmwhhTmcUTFPp4z/cGpilQIccp+Gki/JrA/PmwbZubd+yx7sR/1VXuOTvb0kQYY9JLPHdeq9D9CBs3Fu4QXrQonCaifXsYOdLVAixNhDHGxHeTncbA/cAJqnqOiHQETlXVZxJeuhLy00QE00YXTRMxaVI4Y6iliTDGmMLiaT6aCkwBfuW9/gLXv5DyoFBQAO++G64FfPwx/Pijm3f88eE0EX36uLuJWZoIY4yJTVRj31lTRBaqak8RWayqJ3vTlqhqt6SUMGbZshVyQmki/GyhfftamghjjIlGRHJVNTvSvHhqCrtFpCHefZlF5BTcmIWUa9IEpkxxaSKOPjrVpTHGmIovnqBwIzATaCUic4FGlJP7KZxwAgwZkupSGGNM5RHP1UeLRGQg0A4QYJWqHixmtahEpB2uT8J3EnAXcAzwC8IZWO9Q1TdK+znGGGNKLp6rj2oCvwT64ZqQPhKRJ1V1X2k+UFVXAd28964KfAu8BowFJqvqH0vzvsYYY45cPM1HzwE7ccnwAC4BngcuKIPPPwNYo6pfi/UKG2NMysUTFNqpatfA6/dF5NMy+vyLgRcDr68TkVFADnCTqv5QRp9jjDEmDvGkclvsXXEEgIj0BuYe6QeLSHVgOPCyN+kJoBWuaWkj8HCU9caJSI6I5GzZYjeAM8aYshRPUOiNS4qXJyJ5wHxgoIh8JiJLj+CzzwEWqeomAFXdpKqHVLUAeBroFWklVX1KVbNVNbtRo0ZH8PHGGGOKiqf56OwEffYlBJqORKSJqm70Xo4EliXoc40xxkQRzyWpX4tIfaB5cPkjSZ0tIrWBs4CrA5P/ICLdcFc45RWZZ4wxJgniuST1t8AYYA3eqGaOMHW2qu4BGhaZdnlp388YY0zZiKf56EKglaoeSHRhjDHGpFY8Hc3LcKONjTHGVHLx1BQewF2WugzY709U1eEJK5UxxpiUiCcoPAv8HvgMKEhscYwxxqRSPEHhe1V9LOElMcYYk3LxBIVcEXkAlz472HxU6ktSjTHGlE/xBIWTvedTAtOO6JJUY4wx5VM8g9dOS0ZBjDHGpF6xl6SKSGMReUZE3vRedxSRKxNfNGOMMckWzziFqcBbwAne6y+AiYkqkDHGmNSJGhRExG9aOlZV/4V3Oaqq5gOHklA2Y4wxSRarprDAe94tIg3x8h5591bYkeiCGWOMSb5YHc3+/TFvxF2O2kpE5gKNgPMTXTBjjDHJFysoNBKRG72/XwPewAWK/cCZwJHcYMcYY0w5FCsoVAXqEq4x+GonrjjGGGNSKVZQ2Kiq9yatJMYYY1IuVkdz0RqCMcaYSi5WUDgjaaUwxhhTLkQNCqq6LZkFMcYYk3rxjGg2xhiTJiwoGGOMCYkndXaZE5E8YCcuXUa+qmaLSAPgJSATyAMuVNUfUlE+Y4xJV6msKZymqt1UNdt7fRswS1XbALO818YYY5KoPDUfjcDdDxrv+dwUlsUYY9JSqoKCAm+LSK6IjPOmNVbVjQDe83GRVhSRcSKSIyI5W7ZsSVJxjTEmPaSkTwHoq6obROQ44B0R+TzeFVX1KeApgOzsbE1UAY0xJh2lpKagqhu85824ZHu9gE0i0gTAe96cirIZY0w6S3pQEJE6IlLP/xsYDCzDpece7S02GpiR7LIZY0y6S0XzUWPgNRHxP/+fqvo/EVkI/Mu7//M64IIUlM0YY9Ja0oOCqn4FdI0wfSuWb8kYY1KqPF2SaowxJsUsKBhjjAmxoGCMMSbEgoIxxpgQCwrGGGNCLCgYY4wJsaBgjDEmxIKCMcaYEAsKxhhjQiwoGGOMCbGgYIwxJsSCgjHGmBALCsYYY0IsKBhjjAmxoGCMMSbEgoIxxpgQCwrGGGNCLCgYY4wJsaBgjDEmxIKCMcaYkKQHBRFpLiLvi8hKEVkuItd70+8RkW9FZIn3GJrsshljTLqrloLPzAduUtVFIlIPyBWRd7x5k1X1jykokzHGGFIQFFR1I7DR+3uniKwEmia7HMYYYw6X0j4FEckETgY+8SZdJyJLReTvIlI/yjrjRCRHRHK2bNmSpJIaY0x6SFlQEJG6wL+Biar6I/AE0ArohqtJPBxpPVV9SlWzVTW7UaNGSSuvMcakg5QEBRHJwAWEF1T1VQBV3aSqh1S1AHga6JWKshljTDpLxdVHAjwDrFTVRwLTmwQWGwksS3bZjDEm3aXi6qO+wOXAZyKyxJt2B3CJiHQDFMgDrk5B2YwxJq2l4uqjOYBEmPVGsstijDGmMBvRbIwxJsSCgjHGmBALCsYYY0IsKBhjjAmxoGCMMSbEgoIxxpgQCwrGGGNCLCgYY4wJsaBgjDEmxIKCMcaYEAsKxhhjQiwoGGOMCbGgYIwxJsSCgjHGmBALCsYYY0IsKBhjjAmxoGCMMSbEgoIxxpgQCwrGGGNCLCgYY4wJKXdBQUTOFpFVIrJaRG5LdXmMMSadlKugICJVgT8D5wAdgUtEpGNqS2WMMemjXAUFoBewWlW/UtUDwDRgRIrLZIwxaaNaqgtQRFPgm8Dr9UDv4AIiMg4Y573cLyLLklS28uhY4PtUFyJF0nnbIb2337b9yLWINqO8BQWJME0LvVB9CngKQERyVDU7GQUrj9J5+9N52yG9t9+2PbHbXt6aj9YDzQOvmwEbUlQWY4xJO+UtKCwE2ohISxGpDlwMzExxmYwxJm2Uq+YjVc0XkeuAt4CqwN9VdXmMVZ5KTsnKrXTe/nTedkjv7bdtTyBR1eKXMsYYkxbKW/ORMcaYFLKgYIwxJqTCBoV0S4chInki8pmILBGRHG9aAxF5R0S+9J7rp7qcZUVE/i4im4PjUGJtr4jc7h0Lq0RkSGpKXTaibPs9IvKtt/+XiMjQwLzKtO3NReR9EVkpIstF5Hpverrs+2jbn7z9r6oV7oHrhF4DnARUBz4FOqa6XAne5jzg2CLT/gDc5v19G/D7VJezDLd3ANAdWFbc9uJSonwK1ABaesdG1VRvQxlv+z3ApAjLVrZtbwJ09/6uB3zhbWO67Pto25+0/V9RawqWDsMZATzr/f0scG4Ky1KmVHU2sK3I5GjbOwKYpqr7VXUtsBp3jFRIUbY9msq27RtVdZH3905gJS7TQbrs+2jbH02Zb39FDQqR0mHE+uIqAwXeFpFcL9UHQGNV3QjuYAKOS1npkiPa9qbL8XCdiCz1mpf85pNKu+0ikgmcDHxCGu77ItsPSdr/FTUoFJsOoxLqq6rdcRlkrxWRAakuUDmSDsfDE0AroBuwEXjYm14pt11E6gL/Biaq6o+xFo0wrTJuf9L2f0UNCmmXDkNVN3jPm4HXcFXETSLSBMB73py6EiZFtO2t9MeDqm5S1UOqWgA8TbiJoNJtu4hk4E6IL6jqq97ktNn3kbY/mfu/ogaFtEqHISJ1RKSe/zcwGFiG2+bR3mKjgRmpKWHSRNvemcDFIlJDRFoCbYAFKShfwvgnRM9I3P6HSrbtIiLAM8BKVX0kMCst9n207U/q/k91b/sR9NIPxfXMrwF+leryJHhbT8JdYfApsNzfXqAhMAv40ntukOqyluE2v4irJh/E/Rq6Mtb2Ar/yjoVVwDmpLn8Ctv154DNgqXciaFJJt70frvljKbDEewxNo30fbfuTtv8tzYUxxpiQitp8ZIwxJgEsKBhjjAmxoGCMMSbEgoIxxpgQCwrGGGNCLCiYSkVEDgUySS4pLoOuiAwSkT6B11NF5PwSfuau0pa3yPuIiLwnIkeJSGYwS2pgmcUi0s37u5qI7BaRywLzc0Wku4gME5HflEW5THqxoGAqm72q2i3weLCY5QcBfYpZJlmGAp9q7LQO8wiXtyvu2vQ+EBrY6I9peR0YLiK1E1dcUxlZUDBpQdz9KH4jIovE3ZeivZdwbDxwg1er6O8tPkBE5onIV36tQUTqisiswPqHZeX1ah2zReQ1EVkhIk+KSBURuVJEJgeW+4WIPFJ0feDnRBiVLiIneTWEnsBcwkGhD/AkLh8OuNQHi9SlQ1DgA2BYib8sk9YsKJjKplaR5qOLAvO+V5dU8Alcbvo83El1sler+MhbrgluZOkwwK9p7ANGeuufBjzspSQoqhdwE9AZl8DsPFxq9+FeThuAscCUCOv2BXKDE0SkHS4PzlhVXUjhmkIfYDaw30uD0gcXNHw5QH+MKYFqqS6AMWVsr6p2izLPT66WiztZRzNdXeKxFSLS2JsmwP1edtoCXHrixsB3RdZdoKpfAYjIi0A/VX1FRN4DhonISiBDVT+L8LkN1OXQ9zXC1Rx+pqrLAVQ1T0Sqi8jxQHtc89FCoDcuKPwpsP5m4IQY22nMYSwomHSy33s+ROxjf3/gb7828HPcSbqHqh4UkTygZoR1i+aN8V//DbgD+JzItQSAfBGp4gUkgB24XPl9cTmvfPOB84GNqqoi8rG3TC/g48ByNYG9UT7LmIis+ciku5242x4W52hgsxcQTgNaRFmul5e9twpwETAHQFU/waU4vhSX8C6SVbiOYt8B3B3GRonIpYHpc4EbcMEB73kU8J2qbg8s15ZwNk1j4mJBwVQ2RfsUirv66D/AyCIdzZG8AGSLSA6u1vB5lOXm4/ohlgFrcfe+8P0LmKuqP0RZ93Xc1VAhqrob17dxQ6Bzey4ueMz3ltmIu2/5vCLvd5r3nsbEzbKkGlNGRGQQrgM74hU/IvJfXKf2rCjzmwDPqepZZVCWxsA/VfWMI30vk16spmBMgonIMSLyBa4TPGJAgNAv/qdF5Kgy+NgTcVdBGVMiVlMwxhgTYjUFY4wxIRYUjDHGhFhQMMYYE2JBwRhjTIgFBWOMMSH/D4xZWlivoGN5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Combined_Composite_Curve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drawing the Grand Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "Grand_Composite_Curve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Drawing Pinch in the Grid Representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Pinch_in_the_grid_representation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data necessary for drawing Hot Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Temperature</th>\n",
       "      <th>Final Enthalpy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>130.0</td>\n",
       "      <td>90.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>160.0</td>\n",
       "      <td>225.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>170.0</td>\n",
       "      <td>240.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Temperature  Final Enthalpy\n",
       "0        100.0             0.0\n",
       "1        130.0            90.0\n",
       "2        160.0           225.0\n",
       "3        170.0           240.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hot_composite_curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Necessary for drawing Cold Composite Curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Temperature</th>\n",
       "      <th>Final Enthalpy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>80.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>140.0</td>\n",
       "      <td>240.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Temperature  Final Enthalpy\n",
       "0         80.0             0.0\n",
       "2        140.0           240.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cold_composite_curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Necessary for Area Targetting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Temperature of Hot Streams</th>\n",
       "      <th>Temperature of Cold Streams</th>\n",
       "      <th>Final Enthalpy of either streams</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100.0</td>\n",
       "      <td>80.00</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>130.0</td>\n",
       "      <td>102.50</td>\n",
       "      <td>90.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>160.0</td>\n",
       "      <td>136.25</td>\n",
       "      <td>225.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>170.0</td>\n",
       "      <td>140.00</td>\n",
       "      <td>240.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Temperature of Hot Streams  Temperature of Cold Streams  \\\n",
       "0                       100.0                        80.00   \n",
       "1                       130.0                       102.50   \n",
       "2                       160.0                       136.25   \n",
       "3                       170.0                       140.00   \n",
       "\n",
       "   Final Enthalpy of either streams  \n",
       "0                               0.0  \n",
       "1                              90.0  \n",
       "2                             225.0  \n",
       "3                             240.0  "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minimum_area_calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Renaming the columns of Pandas DataFrames to include units in final output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "problem_table=problem_table.rename(columns={\"Tleft\": \"Tleft (°C)\", \"Tright\": \"Tright (°C)\", \"Temperature Difference\": \"Temperature Difference (°C)\", \"Summation of FCp\": \"Summation of FCp (kW/K)\", \"Deficit\":\"Deficit (kW)\",\n",
    "                             \"Accumulated Input\":\"Accumulated Input (kW)\",\"Accumulated Output\":\"Accumulated Output (kW)\",\"Heat Flows Input\":\"Heat Flows Input (kW)\",\"Heat Flows Output\":\"Heat Flows Output (kW)\"})\n",
    "hot_composite_curve=hot_composite_curve.rename(columns={\"Temperature\":\"Temperature of Hot Streams (°C)\",\"Final Enthalpy\":\"Enthalpy (kW)\"})\n",
    "cold_composite_curve=cold_composite_curve.rename(columns={\"Temperature\":\"Temperature of Cold Streams (°C)\",\"Final Enthalpy\":\"Enthalpy (kW)\"})\n",
    "minimum_area_calculation=minimum_area_calculation.rename(columns={\"Temperature of Hot Streams\":\"Temperature of Hot Streams (°C)\",\"Temperature of Cold Streams\":\"Temperature of Cold Streams (°C)\",\"Final Enthalpy of either streams\":\"Enthalpy (kW)\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exporting the Pandas DataFrame to Excel Sheet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer = pd.ExcelWriter('Design for Heat Exchanger Network.xlsx',engine='xlsxwriter')   \n",
    "workbook=writer.book\n",
    "worksheet=workbook.add_worksheet('Sheet 1')\n",
    "writer.sheets['Sheet 1'] = worksheet\n",
    "problem_table.to_excel(writer,sheet_name='Sheet 1',startrow=0 , startcol=0)   \n",
    "hot_composite_curve.to_excel(writer,sheet_name='Sheet 1',startrow=len(problem_table)+1, startcol=0)\n",
    "cold_composite_curve.to_excel(writer,sheet_name='Sheet 1',startrow=len(problem_table)+len(hot_composite_curve)+2, startcol=0)\n",
    "minimum_area_calculation.to_excel(writer,sheet_name='Sheet 1',startrow=len(problem_table)+len(hot_composite_curve)+len(cold_composite_curve)+3, startcol=0)\n",
    "writer.save()"
   ]
  }
 ],
 "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": 4
}