diff --git a/hp4155/pn_Diode/diode.py b/hp4155/pn_Diode/diode.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fa800438af6f19b7b5fb0c02eb360dc276fc50f
--- /dev/null
+++ b/hp4155/pn_Diode/diode.py
@@ -0,0 +1,42 @@
+import sys
+sys.path.insert(0, './lib')
+sys.path.insert(0, '..') #append parent directory
+
+import hp4155a
+from interface import *
+from help import *
+
+sample = sample_information_interface()
+parameters_1 = parameters_interface(0,0.02,10,"First Measurement")
+parameters_2 = parameters_interface(0,0.5,100,"Second Measurement")
+button = widgets.Button(description ='Start Measurement')
+output = widgets.Output()
+
+display(button,output)
+all_widgets = [button]
+add_widgets_to_list(sample,all_widgets)
+add_widgets_to_list(measurements_1,all_widgets)
+add_widgets_to_list(measurements_2,all_widgets)
+
+
+device = hp4155a.HP4155a('GPIB0::17::INSTR')
+setup(device)
+def on_button_clicked(b):
+    with output:
+        clear_output(wait = True)
+        change_state(all_widgets)
+        area=circle_area(sample['radius'].value)
+        
+        valid = check_values(parameters_1) and check_values(parameters_2)
+        if valid == True:
+            values = measure(parameters_1,parameters_2,area,device)
+            plot_results(values['VS'],values['ABSNOR'])
+            filename = f"DIODE_{sample['field'].value}.txt"
+            file = create_file(filename)
+            save_to_file(values,sample,parameters_1,parameters_2,file)
+        
+        change_state(all_widgets)
+
+
+
+button.on_click(on_button_clicked)
\ No newline at end of file
diff --git a/hp4155/pn_Diode/diode_interface.ipynb b/hp4155/pn_Diode/diode_interface.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..36b70e047b189b878d62bc8207edf72c41aeefc4
--- /dev/null
+++ b/hp4155/pn_Diode/diode_interface.ipynb
@@ -0,0 +1,100 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1b607685-438c-466e-9671-140ae6c8d9f9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "399e5292f4d947f5b42b6090af57b70d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(VBox(children=(Label(value='Sample Information', layout=Layout(height='auto', width='50%'), sty…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7eb1e9d92b4b4801b28229fe7fafc543",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "GridspecLayout(children=(Label(value='V (SMU3)', layout=Layout(grid_area='widget001', height='auto', width='au…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "68855659a4894faf99c50de161203cef",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Button(description='Start Measurement', style=ButtonStyle())"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "072519b84c6e4ff399c113b531f0e368",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%run diode.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5bc60dda-f423-4cdc-bc39-3404a8cfa1df",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/pn_Diode/interactive_plot.ipynb b/hp4155/pn_Diode/interactive_plot.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..962b32197eed5d4eebc858422af441097d883882
--- /dev/null
+++ b/hp4155/pn_Diode/interactive_plot.ipynb
@@ -0,0 +1,111 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ff9aadf7-f6cd-4a29-87ca-c344189622ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_results(x,y):\n",
+    "    fig, ax1 = plt.subplots()\n",
+    "\n",
+    "    color = 'tab:red'\n",
+    "    ax1.set_xlabel('Voltage (V)') \n",
+    "    ax1.set_ylabel('Current density $(A/{cm}^2)$')\n",
+    "    ax1.set_yscale('log')\n",
+    "\n",
+    "    ax1.plot(x,y, color = color) \n",
+    "\n",
+    "    ax1.grid(True,linestyle = '--',axis = 'y',color =\"k\",linewidth = 0.5)\n",
+    "    ax1.axvline(linestyle='--',color = 'k',linewidth =0.5)\n",
+    "\n",
+    "    fig.suptitle('Diode Plot', fontweight =\"bold\")\n",
+    "    fig.tight_layout()\n",
+    "\n",
+    "    manager = plt.get_current_fig_manager()\n",
+    "    manager.window.showMaximized() # For Qt5 backend\n",
+    "    plt.show()\n",
+    "\n",
+    "    return fig\n",
+    "\n",
+    "#only opens a window\n",
+    "def create_file(filename):\n",
+    "    root = tk.Tk()\n",
+    "    root.withdraw()\n",
+    "    root.lift() #show window above all other applications\n",
+    "\n",
+    "    root.attributes(\"-topmost\", True)#window stays above all other applications\n",
+    "\n",
+    "    file = filedialog.asksaveasfilename(defaultextension=\".txt\", filetypes=[(\"Text files\",\"*.txt\")],title = \"save results path\",initialfile =filename)\n",
+    "\n",
+    "    #check if the file path is correct(.txt)\n",
+    "    while file.endswith(\".txt\") == False:\n",
+    "        #open again filedialog with error message box\n",
+    "        tk.messagebox.showerror(message='invalid filename!')\n",
+    "        file = filedialog.asksaveasfilename(defaultextension=\".txt\", filetypes=[(\"Text files\",\"*.txt\")],title = \"save results path\",initialfile =filename)\n",
+    "    root.destroy()\n",
+    "    return file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "151b8338-e606-415d-906d-80f33c32db57",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib qt\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from IPython.display import clear_output\n",
+    "\n",
+    "import tkinter as tk\n",
+    "from tkinter import filedialog\n",
+    "import tkinter.messagebox\n",
+    "\n",
+    "plt.ioff()\n",
+    "# load the file (dataframe)\n",
+    "file = r\"\\\\FILESERVER\\public\\Datentransfer\\Asonitis, Alexandros\\diode\\DIODE_Q22.txt\"\n",
+    "df = pd.read_csv(file,sep=\" \",skiprows=12)\n",
+    "\n",
+    "#display(df)\n",
+    "\n",
+    "fig=plot_results(df[\"VS/V\"],df[\"ABSNOR/A/CM^2\"])\n",
+    "create_file('default.txt')\n",
+    "clear_output(wait = True)\n",
+    "#%matplotlib widget\n",
+    "#fig.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7a736b9-44c1-4d97-b092-43ceadae1ef3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/pn_Diode/lib/diode_smu_configuration.png b/hp4155/pn_Diode/lib/diode_smu_configuration.png
new file mode 100644
index 0000000000000000000000000000000000000000..86131ea625c4f279226f3dcb838941e1561d02ba
Binary files /dev/null and b/hp4155/pn_Diode/lib/diode_smu_configuration.png differ
diff --git a/hp4155/pn_Diode/lib/help.py b/hp4155/pn_Diode/lib/help.py
new file mode 100644
index 0000000000000000000000000000000000000000..238433dfad1cb02af0c41a0805b63398005d4436
--- /dev/null
+++ b/hp4155/pn_Diode/lib/help.py
@@ -0,0 +1,241 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import time
+from datetime import datetime
+
+import tkinter as tk
+from tkinter import filedialog
+import tkinter.messagebox
+
+import pandas as pd
+
+#returns area in cm^2
+def circle_area(radius):
+    #input is in um
+    radius = radius*10**(-6) #m^2
+    area = np.pi*radius**2 # m^2
+    area = area * 10**4 # cm^2
+    return area
+
+def add_widgets_to_list(source_dictionary,target_list):
+    for widget in source_dictionary.values():
+        target_list.append(widget)
+
+def change_state(widgets_list):
+    for widget in widgets_list:
+        widget.disabled = not widget.disabled
+
+#saving functions : save parameters and dataframe to txt
+def create_file(filename):
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =filename)
+
+    #check if the file path is correct(.txt)
+    while file.endswith(".txt") == False:
+        #open again filedialog with error message box
+        answer = tk.messagebox.askyesno(message = "Do you want to cancel the file operation?")
+        if answer == True:
+            file = None
+            break
+        file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =filename)
+    root.destroy()
+    return file
+
+
+def check_values(parameters):
+    valid = True
+
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    #get better variable names
+    start = parameters['start']
+    stop = parameters['stop']
+    step = parameters['step']
+
+    #check values
+    if abs(step.value) > abs(stop.value-start.value) or step.value==0:#invalid parameter setting 
+        valid = False
+        tkinter.messagebox.showerror(message="Invalid parameter setting!")
+
+    if start.value<stop.value and step.value<0: #change polarity
+        step.value =(-1)*step.value
+
+    elif start.value>stop.value and step.value>0:
+        step.value = (-1)*step.value
+
+    else:
+        pass
+
+    root.destroy()
+    return valid
+
+#Setup The device for diode measurement 
+def setup(device):
+    device.reset()
+
+    #setup sweep measurement mode
+    device.measurement_mode('SWE')
+
+    #disable all irrelevant units
+    device.disable_not_smu()
+
+    #disable smu 2 and 4
+    device.smu_disable(2)
+    device.smu_disable(4)
+
+    smu1 = device.smu_dict()
+    smu1.update(vname ='VGND',iname = 'IGND',mode = 'COMM',func='CONS')
+
+    smu3 = device.smu_dict()
+    smu3.update(vname='VS',iname='IS',mode ='V',func='VAR1')
+
+
+    device.setup_smu(1,smu1)
+    device.setup_smu(3,smu3)
+    
+
+    #define user functions
+    device.user_function("AREA",'CM^2',str(area))
+    device.user_function("INORM",'A/CM^2','IS/AREA')
+    device.user_function("ABSNOR","A/CM^2","ABS(INORM)")
+    device.user_function("ABSRAW",'A','ABS(IS)')
+
+
+def measure(parameters_1,parameters_2,area,device):    
+
+    var1 = device.var1_dict()
+    var1.update(
+        mode = parameters_1['hyst'].value,
+        start = parameters_1['start'].value,
+        stop = parameters_1['stop'].value,
+        step = parameters_1['step'].value,
+        comp = parameters_1['comp'].value,
+        pcomp = 0
+    )
+
+    device.setup_var1(var1)
+    
+    device.integration_time(parameters_1['integration'].value)
+    
+
+    #display
+    device.display_variable('X','VS')
+    
+    device.display_variable('Y1','ABSNOR')
+    
+
+    device.axis_scale('Y1','LOG')
+
+    if parameters_1['start'].value < parameters_1['stop'].value:
+        device.display_variable_min_max('X','MIN',parameters_1['start'].value)
+        device.display_variable_min_max('X','MAX',parameters_1['stop'].value)
+
+    else:
+        device.display_variable_min_max('X','MAX',parameters_1['start'].value)
+        device.display_variable_min_max('X','MIN',parameters_1['stop'].value)
+
+    if parameters_1['comp'].value !=0:
+        device.display_variable_min_max('Y1','MIN',0)
+        device.display_variable_min_max('Y1','MAX',abs(parameters_1['comp'].value)/area)
+
+ 
+    variables_list = ['VS','IS','ABSRAW','INORM','ABSNOR']# look at the tool
+    device.variables_to_save(variables_list)
+    
+
+    device.single_measurement()
+    while device.operation_completed() == False:
+        pass
+    
+    device.autoscaling()
+
+    # Start Second measurement
+    var1.update(
+        mode = parameters_2['hyst'].value,
+        start = parameters_2['start'].value,
+        stop = parameters_2['stop'].value,
+        step = parameters_2['step'].value,
+        comp = parameters_2['comp'].value,
+        pcomp = 0
+    )
+
+    device.setup_var1(var1)
+    
+    device.integration_time(parameters_2['integration'].value)
+
+    if parameters_2['start'].value < parameters_2['stop'].value:
+        device.display_variable_min_max('X','MIN',parameters_2['start'].value)
+        device.display_variable_min_max('X','MAX',parameters_2['stop'].value)
+
+    else:
+        device.display_variable_min_max('X','MAX',parameters_2['start'].value)
+        device.display_variable_min_max('X','MIN',parameters_2['stop'].value)
+
+    if parameters_2['comp'].value !=0:
+        device.display_variable_min_max('Y1','MIN',0)
+        device.display_variable_min_max('Y1','MAX',abs(parameters_2['comp'].value)/area)
+
+    device.append_measurement()
+    while device.operation_completed() == False:
+        pass
+
+    
+    values = dict([(variable,device.return_values(variable)) for variable in variables_list])
+    return values
+
+def plot_results(x,y):
+    fig, ax1 = plt.subplots()
+
+    color = 'tab:red'
+    ax1.set_xlabel('Voltage (V)') 
+    ax1.set_ylabel('Current density $(A/{cm}^2)$')
+    ax1.set_yscale('log')
+
+    ax1.plot(x,y, color = color) 
+
+    ax1.grid(True,linestyle = '--',axis = 'y',color ="k",linewidth = 0.5)
+    ax1.axvline(linestyle='--',color = 'k',linewidth =0.5)
+
+    fig.suptitle('Diode Plot', fontweight ="bold")
+    fig.tight_layout()
+
+    display(fig)
+
+#also for file
+def save_to_file(values,sample,parameters_1,parameters_2,file):
+    if file != None:
+        with open(file,'w') as f:
+            date = str(datetime.today().replace(microsecond=0))
+            f.write(f"Diode Measurement at {date}"+"\n")
+            f.write(f"Series:{sample['processing_number'].value}"+"\n")
+            f.write(f"Sample:{sample['sample'].value}"+"\n")
+            f.write(f"Field:{sample['field'].value}"+"\n")
+            f.write(f"Radius/um:{sample['radius'].value}"+"\n\n")
+    
+            f.write('Parameters of first Measurement\n')
+            f.write(f"V from {parameters_1['start'].value}V to {parameters_1['stop'].value}V with step {parameters_1['step'].value}V"+"\n")
+            f.write(f"I Compliance/A:{parameters_1['comp'].value}"+"\n")
+            f.write(f"Integration Time:{parameters_1['integration'].value}"+"\n")
+
+            f.write('\nParameters of second Measurement\n')
+            f.write(f"V from {parameters_2['start'].value}V to {parameters_2['stop'].value}V with step {parameters_2['step'].value}V"+"\n")
+            f.write(f"I Compliance/A:{parameters_2['comp'].value}"+"\n")
+            f.write(f"Integration Time:{parameters_2['integration'].value}"+"\n")
+            
+            f.write("\nResults\n")
+    
+        #create pandas dataframe
+        df = pd.DataFrame(values)
+        #df =df.drop(columns=['ABSNOR'])
+        df =df.rename(columns={'VS':'VS/V','IS':'IRAW/A','ABSRAW':'ABSRAW/A','INORM':'INORM/A/CM^2','ABSNOR':'ABSNOR/A/CM^2'})
+    
+        df.to_csv(file,sep= " ",mode = 'a')
\ No newline at end of file
diff --git a/hp4155/pn_Diode/lib/interface.py b/hp4155/pn_Diode/lib/interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..6105b0de8394e2d42b201f881f8365f45ce553db
--- /dev/null
+++ b/hp4155/pn_Diode/lib/interface.py
@@ -0,0 +1,111 @@
+import ipywidgets as widgets
+from ipywidgets import GridspecLayout,Layout
+from IPython.display import clear_output,display
+import sys
+import os
+
+
+style = {'description_width': 'initial'}
+
+def parameters_interface(start,step,stop,title):
+    grid = GridspecLayout(5,4)
+    grid[0,:]=widgets.Label(title,layout=Layout(height='auto', width='auto'))
+    grid[0,:].style.font_weight='bold'
+
+
+    #first line
+    grid[1,0]=widgets.Label("Start(V)",layout=Layout(height='auto', width='auto'))
+    grid[1,1]=widgets.Label("Step(V)",layout=Layout(height='auto', width='auto'))
+    grid[1,2]=widgets.Label("Stop(V)",layout=Layout(height='auto', width='auto'))
+
+    #second line
+    grid[2,0]=widgets.BoundedFloatText(value=start,min=-100,max=100,step=1,layout=Layout(height='auto', width='auto'))
+    grid[2,1]=widgets.BoundedFloatText(value=step,min=-200,max=200,step=1,layout=Layout(height='auto', width='auto'))
+    grid[2,2]=widgets.BoundedFloatText(value=stop,min=-100,max=100,step=1,layout=Layout(height='auto', width='auto'))
+
+    #third line 
+    grid[3,0]=widgets.Label("Compliance(A)",layout=Layout(height='auto', width='auto'))
+    grid[3,1] =widgets.Label("Integration Time",layout=Layout(height='auto', width='auto'))#mind the gap
+    grid[3,2] =widgets.Label("Hysterisis",layout=Layout(height='auto', width='auto'))#mind the gap
+
+    #fourth line
+    grid[4,0]=widgets.BoundedFloatText(value=0.10,min=-0.1,max=0.1,step=0.01,layout=Layout(height='auto', width='auto'))
+    grid[4,1]=widgets.Dropdown(options=["SHORt","MEDium","LONG"],value="MEDium",style =style,layout=Layout(height='auto', width='auto'))
+    grid[4,2]=widgets.Dropdown(options=['SINGle','DOUBle'],value='SINGle',layout=Layout(height='auto', width='auto'))#mind the gap
+
+    parameters = {
+        'start': grid[2,0],
+        'step': grid[2,1],
+        'stop': grid[2,2],
+        'comp': grid[4,0],
+        'hyst':grid[4,2],
+        'integration':grid[4,1]
+    }
+    
+
+    display(grid)
+    return parameters
+
+
+def sample_information_interface():
+    sample_information=widgets.Label("Sample Information",layout=Layout(height='auto', width='auto'))
+    sample_information.style.font_weight='bold'
+    information_grid=GridspecLayout(3,2)
+    
+    for i in range(3):
+        for j in range(2):
+            if i ==2 and j == 1:
+                pass
+            elif i == 2 and j == 0: #look at the tool for diode area          
+                information_grid[i,j]=widgets.BoundedFloatText(
+                    value=50,
+                    min=1,
+                    max=200,step=1,
+                    layout=Layout(height='auto', width='auto')
+                )
+            else:
+                information_grid[i,j]=widgets.Text(layout=Layout(height='auto', width='auto'))
+
+    information_grid[0,0].description = "Processing-Nr:"
+    information_grid[1,0].description = "Sample:"
+    information_grid[2,0].description = "Radius(um):"
+    information_grid[0,1].description = "Field(XYY):"
+    information_grid[1,1].description = "Device:"
+    information_grid[1,1].disabled = True
+
+
+    for i in range(3):
+        for j in range(2):
+            try:
+                information_grid[i,j].style = style
+            except:
+                pass
+
+    image_title = widgets.Label("SMU Configuration",layout=Layout(height='auto', width='auto'))
+    image_title.style.font_weight='bold'
+
+    filename = os.getcwd()+r"\lib\diode_smu_configuration.png"
+    #print(filename)
+
+    file = open(filename, "rb")
+    image = file.read()
+    image_widget =widgets.Image(
+        value = image,
+        format='png',
+        width='auto',
+        height='auto',
+    )
+    
+    vbox1 =widgets.VBox([sample_information,information_grid])
+    vbox2 =widgets.VBox([image_title,image_widget])
+
+    display(widgets.HBox([vbox1,vbox2]))
+
+    information = {
+        'processing_number': information_grid[0,0],
+        'sample' : information_grid[1,0],
+        'field': information_grid[0,1],
+        'radius': information_grid[2,0],
+    }
+
+    return information
diff --git a/hp4155/pn_Diode/plot_example.ipynb b/hp4155/pn_Diode/plot_example.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f1b5eb89955b8142901a4501462947fe03cb1252
--- /dev/null
+++ b/hp4155/pn_Diode/plot_example.ipynb
@@ -0,0 +1,266 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "497d8a64-fc7f-430b-8bf6-be0437dfafc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib widget\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "\n",
+    "def plot_results(x,y):\n",
+    "    fig, ax1 = plt.subplots()\n",
+    "\n",
+    "    color = 'tab:red'\n",
+    "    ax1.set_xlabel('Voltage (V)') \n",
+    "    ax1.set_ylabel('Current density $(A/{cm}^2)$')\n",
+    "    ax1.set_yscale('log')\n",
+    "\n",
+    "    ax1.plot(x,y, color = color) \n",
+    "    #ax1.tick_params(axis ='y', labelcolor = color)\n",
+    "\n",
+    "    ax1.grid(True,linestyle = '--',axis = 'y',color =\"k\",linewidth = 0.5)\n",
+    "    ax1.axvline(linestyle='--',color = 'k',linewidth =0.5)\n",
+    "\n",
+    "    fig.suptitle('Diode Plot', fontweight =\"bold\")\n",
+    "    fig.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e7228275-b6d8-49d9-99d3-7dbaeec1373a",
+   "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>Unnamed: 0</th>\n",
+       "      <th>VS/V</th>\n",
+       "      <th>IRAW/A</th>\n",
+       "      <th>ABSRAW/A</th>\n",
+       "      <th>INORM/A/CM^2</th>\n",
+       "      <th>ABSNOR/A/CM^2</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>-8.00</td>\n",
+       "      <td>-0.000001</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>-0.016506</td>\n",
+       "      <td>0.016506</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>-7.95</td>\n",
+       "      <td>-0.000001</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>-0.016326</td>\n",
+       "      <td>0.016326</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>-7.90</td>\n",
+       "      <td>-0.000001</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>-0.016283</td>\n",
+       "      <td>0.016283</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>-7.85</td>\n",
+       "      <td>-0.000001</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>-0.016199</td>\n",
+       "      <td>0.016199</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>-7.80</td>\n",
+       "      <td>-0.000001</td>\n",
+       "      <td>0.000001</td>\n",
+       "      <td>-0.016161</td>\n",
+       "      <td>0.016161</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>236</th>\n",
+       "      <td>236</td>\n",
+       "      <td>3.80</td>\n",
+       "      <td>0.074660</td>\n",
+       "      <td>0.074660</td>\n",
+       "      <td>950.603200</td>\n",
+       "      <td>950.603200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>237</th>\n",
+       "      <td>237</td>\n",
+       "      <td>3.85</td>\n",
+       "      <td>0.077039</td>\n",
+       "      <td>0.077039</td>\n",
+       "      <td>980.893600</td>\n",
+       "      <td>980.893600</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>238</th>\n",
+       "      <td>238</td>\n",
+       "      <td>3.90</td>\n",
+       "      <td>0.079420</td>\n",
+       "      <td>0.079420</td>\n",
+       "      <td>1011.200000</td>\n",
+       "      <td>1011.200000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>239</th>\n",
+       "      <td>239</td>\n",
+       "      <td>3.95</td>\n",
+       "      <td>0.081812</td>\n",
+       "      <td>0.081812</td>\n",
+       "      <td>1041.669000</td>\n",
+       "      <td>1041.669000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>240</th>\n",
+       "      <td>240</td>\n",
+       "      <td>4.00</td>\n",
+       "      <td>0.084198</td>\n",
+       "      <td>0.084198</td>\n",
+       "      <td>1072.046000</td>\n",
+       "      <td>1072.046000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>241 rows × 6 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     Unnamed: 0  VS/V    IRAW/A  ABSRAW/A  INORM/A/CM^2  ABSNOR/A/CM^2\n",
+       "0             0 -8.00 -0.000001  0.000001     -0.016506       0.016506\n",
+       "1             1 -7.95 -0.000001  0.000001     -0.016326       0.016326\n",
+       "2             2 -7.90 -0.000001  0.000001     -0.016283       0.016283\n",
+       "3             3 -7.85 -0.000001  0.000001     -0.016199       0.016199\n",
+       "4             4 -7.80 -0.000001  0.000001     -0.016161       0.016161\n",
+       "..          ...   ...       ...       ...           ...            ...\n",
+       "236         236  3.80  0.074660  0.074660    950.603200     950.603200\n",
+       "237         237  3.85  0.077039  0.077039    980.893600     980.893600\n",
+       "238         238  3.90  0.079420  0.079420   1011.200000    1011.200000\n",
+       "239         239  3.95  0.081812  0.081812   1041.669000    1041.669000\n",
+       "240         240  4.00  0.084198  0.084198   1072.046000    1072.046000\n",
+       "\n",
+       "[241 rows x 6 columns]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f8aefc1fb23644ff9c8fb46f26081481",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "image/png": "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",
+      "text/html": [
+       "\n",
+       "            <div style=\"display: inline-block;\">\n",
+       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
+       "                    Figure\n",
+       "                </div>\n",
+       "                <img src='data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACGBElEQVR4nOzdeZyN5f/H8dc5s49ZjLHLrqQmQzSSRLJkX5I1xpKv0pSvCSllqUgqWvAlv1CyL4NSIrKETDREacouxhJjxuzLOb8/ZuZksmSZ4z7nzPv5eMzDOfe5z329z8GZz7nu67puk9VqtSIiIiIihYbZ6AAiIiIicnupABQREREpZFQAioiIiBQyKgBFREREChkVgCIiIiKFjApAERERkUJGBaCIiIhIIaMCUERERKSQUQEoIiIiUsioABSR265SpUqYTCZMJlOBH3vMmDG2Y8+ZM6fAj38j+vTpY8uyceNGQ7OIiFxKBaCI3LRLiy2TyYSHhwdFixalRo0adOvWjTVr1hgdsUBdWtDl/ZjNZooVK8Zjjz3G8uXLC7zNCxcuMGbMGMaMGWN4QSsirsPd6AAi4jqysrJISEggISGB3377jUWLFtG2bVvmzZuHv7+/bb+lS5eSlpZmYNKCY7VaiY+PZ8OGDWzYsIGxY8cyatSoAjv+hQsXGDt2LACNGjWiT58+BXZsESm81AMoIgWiZcuWbNmyhZUrV/L888/j6ekJwBdffEGvXr3y7Vu3bl0efvhhHn74YSOiFoi+ffuyZcsW1qxZQ/v27W3b33jjDeLi4gxMJiLy71QAikiBKFmyJA8//DDt2rXjww8/ZNmyZbbHVq5cyfr16233rzYG0Gq18vHHH/Pggw/i7++Pt7c3d999N6+88goJCQmXtbl48WLuvfdevL29CQkJYfHixdfM+PPPP9O9e3fKlCmDp6cn5cqV4+mnn+bPP/+84ddboUIFHn74YVq0aMHChQvx8fEBcnpBf/jhh399/oYNG2jdujXFixfH09OT8uXL06dPH/744w/bPn369KFy5cq2+5s2bbK9b40bN77hzCIieVQAiohdtGnThqZNm9ruL1iw4Jr7W61WevTowcCBA9mxYwdJSUmkp6cTGxvLW2+9xYMPPkh8fLxt/yVLltCtWzd+/fVX0tPT+eWXX+jatStRUVFXPP7XX39NWFgYCxcu5NSpU2RmZnLy5Ek++eQTHnjgAQ4fPnzTr9Xb2xsvLy/b/YyMjGvuP23aNJo2bcpXX33FuXPnyMzM5M8//+TTTz+lTp06/PjjjzedRUTkeqgAFBG7qV+/vu327t27r7nv4sWLWbhwIQBBQUF8/PHHREVFUbNmTQB+++03XnnlFQCys7MZMmQIVqsVgG7durF69WqGDBnCzz//fNmxU1JSCA8PJz09HXd3d8aNG8fatWsZPnw4AKdOnWLQoEE39RqTk5N56623uHDhgm3bfffdd9X9jx8/bstuNpt59dVXWb16NU8++SQAFy9epE+fPlitVkaOHMmSJUtsz61VqxZbtmxhy5YtfPTRRzeVV0QENAlEROyoTJkytttXOoV7qfnz59tuv/766wwYMACAatWq2QqqRYsWMW3aNHbt2sWJEycAKFu2LHPnzsXd3Z1WrVoRHR3N1q1b8x177dq1nD17FoBmzZrxyCOPANC2bVsWL17MkSNH+Oabb/jrr78oXrz4db22sWPH2iZnXKpjx47cc889V33e0qVLbT2EHTt25I033rDl2rJlC6dOneLXX39lz5491KpVCw8PD9tzAwMDnXrcpIg4DvUAiojd5BVpkFO8XMvvv/9uu12vXj3b7ZCQEHx9fQGIj4/n7NmzHDp0yPZ4rVq1cHf/+7tsWFjYNY/99ddf07BhQ9vPkSNHgJxT0L/99tt1vrLLFSlShBdeeIHPP//8mvtd7XV6eHhQu3btK+4nIlLQ1AMoInZzaU9crVq1bkubt7K4dHJy8nXv27dvX/r164fZbCYwMJC77rorX2/dzbDHwtgiIleiHkARsYsVK1bku/pF165dr7n/XXfdZbsdHR1tu71v3z5SUlKAnLGBJUqUoEqVKrbHd+/eTXZ2tu3+jh07rnns8PBwrFbrZT/Jycm0aNHiul9f3izghx56iHvvvfe6i7+rvc7MzExiYmIu289s/vtj2mKxXHc+EZFrUQ+giBSIM2fO8P3333P+/HnWrVvHxx9/bHusbdu2NGvW7JrP79GjB6tWrQJg1KhReHl5Ubx48Xzj7Lp27YrJZKJOnTqUK1eOEydOcPLkSXr37s1TTz3F+vXrLxv/Bznj60qUKMHZs2f57LPPKFasGM2aNSM7O5sjR46wdetW9uzZw6+//lpA78bVde7cmZdeeonMzEyWL1/O6NGjefDBB/n0009t6wfec889hIaGAjlFb569e/eyYsUKihcvToUKFahQoYLd84qIi7KKiNyk0aNHW4Fr/rRu3dqamJiY73kVK1a0PZ7HYrFYu3btetXj3H333dbz58/b9l+wYMEV96tWrZrt9uzZs237r1692url5XXV41esWPFfX294eLht/9GjR9/Q/t99951t+9SpU60mk+mKOfz9/a3R0dH5jlOnTp3L9rue9kVErkangEWkwJjNZvz9/bnrrrt48skn+eKLL/jiiy/yXQbuakwmE/Pnz2f69OmEhYVRpEgRvLy8uOuuuxgxYgQ//PBDvt6wbt26sWDBAmrUqIGnpyfVq1dn1qxZ9OzZ84rHb9WqFTt37qRXr17ccccdeHh4ULx4cWrVqkVkZGS+5VbsbdCgQaxbt46WLVtSrFgx3N3dKVu2LL1792bXrl088MAD+fZfsGABjz/+eL7XLyJyK0xWa+5CWiIiIiJSKKgHUERERKSQUQEoIiIiUsioABQREREpZFQAioiIiBQyKgBFREREChkVgCIiIiKFjApAERERkUJGBaCIiIhIIaMCUERERKSQUQEoIiIiUsioABQREREpZFQAioiIiBQyKgBFREREChkVgCIiIiKFjApAERERkUJGBaCIiIhIIaMCUERERKSQUQEoIiIiUsioABQREREpZFQAioiIiBQyKgBFREREChkVgCIiIiKFjLvRAVyNxWLh5MmT+Pv7YzKZjI4jIiIiLshqtXLx4kXKli2L2Xzj/XkqAAvYyZMnKV++vNExREREpBA4fvw4d9xxxw0/TwVgAfP39wdy/kICAgIMTiMiUrh07dqVRYsWGR1DxO4SExMpX768re64USoAC1jead+AgAAVgCIit1nNmjX12SuFys0ON9MkEBERcRmRkZFGRxBxCioARUTEZQwYMMDoCCJOQQWgiIiISCGjAlBERFxGv379jI4g4hRUAIqIiIgUMioARUTEZcyaNcvoCCJOQQWgiIiISCGjAlBERFzGzJkzjY4g4hRUAIqIiMuYNGmS0RFEnIIKwH+4cOECdevWpVatWoSEhOjbpIiIE9m/f7/REUScgi4F9w/+/v5s3rwZX19fkpOTCQkJoVOnTgQHBxsdTURE/kWVKlWMjiDiFNQD+A9ubm74+voCkJ6ejtVqxWq1GpxKRESux9ixY42OIOIUXK4A3Lx5M23btqVs2bKYTCZWrFhx2T5Tp06lUqVKeHt7U69ePaKjo/M9fuHCBUJDQ7njjjsYNmwYxYsXv03pRUTkVvTq1cvoCCIAZMXHk52QYHSMq3K5AjA5OZnQ0FCmTp16xccXLVpEZGQko0eP5qeffiI0NJQWLVpw5swZ2z5FixZlz549HD58mPnz53P69OnbFV9ERESciCUtjdS9+7iwbBmnxo3naO9wfm/wMH/Uf4gLUVFGx7sqlxsD2LJlS1q2bHnVxydNmsSAAQPo27cvANOnT2f16tXMmjWLESNG5Nu3VKlShIaGsmXLFjp37nzF46Wnp5Oenm67n5iYWACvQkREbkbPnj2NjiAuymq1knX6NOmxsaT9Fkt67G+kxf5OxuHDYLFc8TlZZ87e5pTXz+UKwGvJyMhg165dvPzyy7ZtZrOZpk2bsn37dgBOnz6Nr68v/v7+JCQksHnzZp599tmrHvOtt9664piTrl274uHhwbx583jllVc4evQoISEhRERE8MwzzwAwYMAAMjMzmTNnDpCzgv3bb79NbGws1apV49VXX6VPnz5AzmkNX19fZsyYAcC0adOYMWMGe/bsoXz58rzzzjt069YNgC5dulCmTBk++OADACZPnsyCBQuIjo6mZMmSzJgxg44dOwLQvn17qlevzsSJEwGYMGECq1evZsuWLQQEBPD555/TqVMnsrKyaNGiBWFhYbzxxhsAjBkzhq1bt7Ju3Tq8vLxYsmQJPXr0ICkpiUaNGtG8eXNGjhwJwIgRI9i3bx9ffvklAKtWraJv376cO3eO+vXr07lzZ1588UUAIiMjOXbsGEuXLgVg8eLFDBkyhBMnTlC7dm369+9PREQEAIMGDSIhIYF58+YBMHfuXEaPHs2hQ4eoUaMGkZGRDBgwAPj7GqF5VwqYOXMmkyZNYv/+/VSpUoWxY8faTh/17NmTwMBApk2bBsCUKVP45JNPiImJoVy5ckyePJkuXboA0LlzZypUqGBbfuK9995j6dKlbN++neDgYGbPnk27du0AaNOmDSEhIUyYMAGAcePGsXbtWjZt2oSfnx/z58/nySefJD09nWbNmtGgQQPGjBkDwGuvvUZ0dDTffPMN7u7uLF++nKeeeorExEQaNmxI69atbV9ihg8fTmxsLCtXrgQgKiqKgQMHcubMGcLCwujevTtDhgwBYPDgwcTFxbF48WIAFi5cyLBhwzh+/DihoaEMHDiQQYMGATBw4EBSUlKYO3cuAHPmzOHNN9/kwIEDVK9enZdeesn2Pvfp0wcPDw/bTPrp06czZcoU9u3bR8WKFRk/frztl3X37t0JDg5mypQpAHz44Yd89tln7Ny5kzJlyjBlyhSeeOIJADp27EjVqlV59913AZg4cSIrV65k69atBAUF8emnn9KhQwcsFgutWrWidu3ajBs3DoDXX3+djRs3smHDBnx8fFi0aBFdu3YlNTWVJk2a0LhxY0aNGgXAyJEjiYmJ4auvvsJsNrNixQrCw8OJj4+nQYMGtG/fnuHDhwMwdOhQDh48SFTut/1ly5YRERFBXFwcdevWpXfv3rzwwgsAREREcO7cORYsWACgz4gC/ozw9/enfv36+ozQZ8Qtf0aUdHdn8qBBzH/9DcokXaRitgXPSzp8LpXs5kaJBx5g45HDHLFCqbAHaNSjBwNGj4bvt9jlMyIzM/OKWa6XyerCMxxMJhNRUVF06NABgJMnT1KuXDm2bdtG/fr1bfsNHz6cTZs2sWPHDqKjo/nPf/5jm/zx3HPPMXDgwKu2caUewPLly5OQkEBAQIDdXpuIiFyuXbt2rFq1yugY4mSyk5JI27uX1J/3krr3Z9L27iPrSsO/3NzwqlIZr+p341X9Lrzvvhuvu6rjXrIEJpPptmZOTEwkMDDwpuuNQtUDeD3CwsLYvXv3de/v5eWFl5eX/QKJiIhIgcr66y9Sdu4iZedOUnbtIj029vLTuGYzXtWq4V3zPnzuq4l3yL14VauG2UV+5xeqArB48eK4ubldNqnj9OnTlC5d2qBUIiJSUPJOEYpcKuPPP0mJ/pGUXTtJ3bmLjKNHL9vHo1w5W7HnU/M+vO+5B3PusnCuqFAVgJ6entSpU4f169fbTgtbLBbWr19vGy8iIiLO65NPPtFagEJ2YiLJO3aQvG0byVu3kXnsWP4dTCa87roL3zp18K1bB586dfEoVdKYsAZxuQIwKSmJAwcO2O4fPnyY3bt3U6xYMSpUqEBkZCTh4eHUrVuXsLAw3n//fZKTk22zgkVExHnFxMQYHUEMYLVaSd+/n4sbviP5++9J3bsXsrP/3sHdHZ+QkJxir25dfGvXxi0w0LjADsDlCsCdO3fy6KOP2u5HRkYCEB4ezpw5c+jatStnz55l1KhRnDp1ilq1arFmzRpKlSplVGQRESkg5cqVMzqC3CbWzExSfvyRi+s3cPG7DWSdjMv3uGelShRp0IAiDRrgGxaGm18Rg5I6JpeeBWyEW52VIyIiNy8tLQ1vb2+jY4idWDMySPp+K4lff03Spk1YLll71+TtTZGHG+D3yCP4NWiAh4t/GdAsYBERkVxdunTRMjAuxmqxkLJzJ4lfribxm2+wXHJ5NbfgYPwebYx/k8co8lB9zCr+r5sKQBEREXE46QcOcCEqisTVX5F16pRtu3uJEgS0aoV/ixb4hNbE5OZmYErnpQJQRERcxtUu2ynOwZKWxsVvviF+8RJSd+2ybTf7++PfojmBbdrg+8ADKvoKgApAERFxGRUqVDA6gtyEzLg4zn/+OReWLvv7FK+bG36NGxPYoT1+jzziMgswOwoVgCIi4jImTZpE48aNjY4h1yl17z7Oz5lD4po1tmVbPMqWpWiXJwns2KnQrc13O6kAFBERkdsqZedOzk6ZSsoPP9i2+T74IMXCe+P3yCM6xXsbqAAUERGX8d577xkdQa4h5aefOPvRR6Rszy38PDwIbNWKYn3C8a5Rw9hwhYwKQBERcRlLly7l5ZdfNjqG/EP6ocOcfnsCyZs252zw8KBop04UH/gfPMqWNTZcIaUCUEREXMb27duNjiCXyL54kb+mTuP8559DVha4u1O0Y0eKPzPQ5RdqdnQqAEVExGUEBwcbHUHIuTZvQtQKzrz3HtnnzgHg17gxJV8ajlflyganE1ABKCIiLmT27NlGRyj0Mk+dIu61USRv2QKAZ+XKlHrlZfwaNjQ4mVzKbHQAERGRgtKuXTujIxRaVquVC8uWc6htO5K3bMHk6UmJFyOpsnKFij8HpB5AERERuSXZFy5w8uVXSPruOwC8a9ak7Fvj8apa1eBkcjUqAEVExGW0adPG6AiFTtpvv/Hn8y+Qefw4Jg8Pir/wPMF9+2JyV4nhyPS3IyIiLiMkJMToCIVKwhdfEPfaKKxpaXiUK8cdH32I9z33GB1LroPGAIqIiMuYMGGC0REKBWt2NqffeouTw4ZjTUujyMMPU3nZUhV/TkQ9gCIiInLdLOnpnBw6jIvr1gEQ/OwzlIiI0OXbnIwKQBERcRnjxo0zOoJLsyQnc/zZQaRER2Py8KDsOxMJePxxo2PJTdApYBERcRlr1641OoLLsiQnc2zgQFKiozEXKUL5mTNV/DkxFYAiIuIyNm3aZHQEl2RJTeX4wGdI3bkLs78/FebMpsiD9YyOJbdABaCIiLgMPz8/oyO4HGtWFideHErKzp2Y/fyo8Mn/4XPffUbHklukAlBERFzG/PnzjY7gUqxWK6fefJOkDRsweXpSfsZ0fGrWNDqWFAAVgCIi4jKefPJJoyO4lPh587mwcBGYTJR99x1869QxOpIUEBWAIiLiMtLT042O4DJSdu3idO66iiWHDSOgeXODE0lBUgEoIiIuo1mzZkZHcAlZZ8/y53//C1lZBLRqRbG+fYyOJAVMBaCIiLiMBg0aGB3B6VmtVk6++irZZ//C6847KfPmG5hMJqNjSQFTASgiIi5jzJgxRkdwehcWLSZ502ZMnp6Um/QeZl9foyOJHagAFBEREQAyjh3j9NtvA1Aicghed95pcCKxFxWAIiLiMl577TWjIzgtq9XKqTfexJqaim+9ehTr3dvoSGJHKgBFRMRlREdHGx3BaV1ct47kLVsweXhQZuwYTGaVCK5Mf7siIuIyvvnmG6MjOCVLSgqn38pZ8qXY0/3xrFTJ2EBidyoARUTEZbi7uxsdwSmdmz2brLg4PMqVo/h//mN0HLkNVACKiIjLWL58udERnE72hQucnz0HgJIvRmL28TE2kNwWKgBFRMRlPPXUU0ZHcDrnPvkES1ISXnffjf/jjxsdR24TFYAiIuIyEhMTjY7gVLLOnuX83M8BKPHCC5r4UYjob1pERFxGw4YNjY7gVM7NmYM1LQ3v0Jr4PdrY6DhyG6kAFBERl9G6dWujIziN7KQkLixaDEDxZ57R5d4KGRWAIiLiMkaMGGF0BKdxYfESLElJeFapgl+jRkbHkdtMBaCIiEghY83M5PxnnwEQ3K+vxv4VQvobFxERlzF8+HCjIziFxDVryDp1CrfixQlo187oOGIAFYBX0bFjR4KCgujcubPRUURE5DrFxsYaHcEpxC9aBEBQj+6YPT0NTiNGUAF4FYMHD+az3O5xERFxDitXrjQ6gsNLP3SI1J27wGym6BNPGB1HDKIC8CoaN26Mv7+/0TFEREQK1IUlSwHwa9QIj1KlDE4jRnHJAnDz5s20bduWsmXLYjKZWLFixWX7TJ06lUqVKuHt7U29evWIjo6+/UFFRKRARUVFGR3BoVkzMkjI/Z1Y9EkNcSrMXLIATE5OJjQ0lKlTp17x8UWLFhEZGcno0aP56aefCA0NpUWLFpw5c+Y2JxURkYI0cOBAoyM4tIsbviM7Ph73kiXxe+QRo+OIgdyNDmAPLVu2pGXLlld9fNKkSQwYMIC+ffsCMH36dFavXs2sWbNueA2p9PR00tPTbfd1GSIREePoi/y1JXzxBQCBHTpgcnfJEkCuU6H728/IyGDXrl28/PLLtm1ms5mmTZuyffv2Gz7eW2+9xdixYy/b3rVrVzw8PJg3bx6vvPIKR48eJSQkhIiICJ555hkABgwYQGZmJnPmzAFg1qxZvP3228TGxlKtWjVeffVV+vTpA0CvXr3w9fVlxowZAEybNo0ZM2awZ88eypcvzzvvvEO3bt0A6NKlC2XKlOGDDz4AYPLkySxYsIDo6GhKlizJjBkz6NixIwDt27enevXqTJw4EYAJEyawevVqtmzZQkBAAJ9//jmdOnUiKyuLFi1aEBYWxhtvvAHAmDFj2Lp1K+vWrcPLy4slS5bQo0cPkpKSaNSoEc2bN2fkyJFAzuKs+/bt48svvwRg1apV9O3bl3PnzlG/fn06d+7Miy++CEBkZCTHjh1j6dKccSqLFy9myJAhnDhxgtq1a9O/f38iIiIAGDRoEAkJCcybNw+AuXPnMnr0aA4dOkSNGjWIjIxkwIABAPTr18/2PgPMnDmTSZMmsX//fqpUqcLYsWPp1asXAD179iQwMJBp06YBMGXKFD755BNiYmIoV64ckydPpkuXLgB07tyZChUqMGnSJADee+89li5dyvbt2wkODmb27Nm0y11moU2bNoSEhDBhwgQAxo0bx9q1a9m0aRN+fn7Mnz+fJ598kvT0dJo1a0aDBg0YM2YMAK+99hrR0dF88803uLu7s3z5cp566ikSExNp2LAhrVu3tn2BGT58OLGxsbYB8VFRUQwcOJAzZ84QFhZG9+7dGTJkCJAz4SkuLo7Fi3OuCLBw4UKGDRvG8ePHCQ0NZeDAgQwaNAjI6V1JSUlh7ty5AMyZM4c333yTAwcOUL16dV566SXb+9ynTx88PDyYOXMmkPNFa8qUKezbt4+KFSsyfvx4evbsCUD37t0JDg5mypQpAHz44Yd89tln7Ny5kzJlyjBlyhSeyB2s3rFjR6pWrcq7774LwMSJE1m5ciVbt24lKCiITz/9lA4dOmCxWGjVqhW1a9dm3LhxALz++uts3LiRDRs24OPjw6JFi+jatSupqak0adKExo0bM2rUKABGjhxJTEwMX331FWazmRUrVhAeHk58fDwNGjSgffv2tiVHhg4dysGDB22nH5ctW0ZERARxcXHUrVuX3r1788ILLwAQERHBuXPnWLBgAYA+Iwr4M+LixYscO3ZMnxFX+oxo3JjsDRtwBw6WLcMXn3yizwgn/ozIzMzkVpisVqv1lo7g4EwmE1FRUXTo0AGAkydPUq5cObZt20b9+vVt+w0fPpxNmzaxY8cOAJo2bcqePXtITk6mWLFiLFmyJN/+ea7UA1i+fHkSEhIICAiw74sTEZF8Dh48SNWqVY2O4ZAurFhB3IiX8axalSpffqFLvzm5xMREAgMDb7reKHQ9gNfr22+/va79vLy88PLysnMaERG5HkOGDGHVqlVGx3BIiV9/DUBAy5Yq/sQ1J4FcS/HixXFzc+P06dP5tp8+fZrSpUsblEpERMR+si9cIHnrNgACWl19jLwUHoWuAPT09KROnTqsX7/ets1isbB+/fornuIVERHnMXjwYKMjOKSL334LWVl4Va+OV5UqRscRB+CSp4CTkpI4cOCA7f7hw4fZvXs3xYoVo0KFCkRGRhIeHk7dunUJCwvj/fffJzk52TYrWEREnFNcXJzRERzSxW9zOj0CWj5ucBJxFC5ZAO7cuZNHH33Udj8yMhKA8PBw5syZQ9euXTl79iyjRo3i1KlT1KpVizVr1lBKK6KLiDi1xYsX89RTTxkdw6FY0tJI/uEHAPwu+d0ohZtLFoCNGzfm3yY3R0RE2JYJEBERcVUp0dFY09JwL10ar7vuMjqOOIhCNwZQRERc18KFC42O4HCSNm4Ecq79q9m/kkcFoIiIuIxhw4YZHcGhWK1WkjZuAnIKQJE8KgBFRMRlHD9+3OgIDiXjwAEyT57E5OlJkQfrGR1HHIgKQBERcRmhoaFGR3AoSZtyev9869XD7OtrcBpxJCoARUTEZQwcONDoCA4laetWAPweecTgJOJoVACKiIjLGDRokNERHIYlI4PUn2IAdPpXLqMCUERExAWl7dmDNT0dt+BgPKtVMzqOOBgVgCIi4jJ0CvhvyTuiAShSL0zLv8hlVACKiIjLSElJMTqCw0jJvfqHb5hO/8rlVACKiIjLmDt3rtERHIIlLY3UPXsAjf+TK1MBKCIi4mJSY2KwZmbiXqoUHhUrGh1HHJAKQBERcRlz5swxOoJDSN6xAwBfjf+Tq1ABKCIiLuPNN980OoJDSPlxJwBFwsIMTiKOSgWgiIi4jAMHDhgdwXCW9HTSfv4ZAN+6dQ1OI45KBaCIiLiM6tWrGx3BcGm//II1MxO34GCN/5OrUgEoIiIu46WXXjI6guFSdu4CwLdOHY3/k6tSASgiIi6jX79+RkcwXOquvALwfoOTiCNTASgiIuIirBYLKTE51//1ub+OwWnEkakAFBERl9GnTx+jIxgq/Y8DWBITMfn64l3jbqPjiANTASgiIi7Dw8PD6AiGSv0p9/RvrVBM7u4GpxFHpgJQRERcxsyZM42OYKiUXT8B4FNHp3/l2lQAioiIuIjU3bsB8KlVy9Ac4vhUAIqIiMuYPn260REMk/XXX2T++SeYTPiEhhodRxycCkAREXEZU6ZMMTqCYVL37AHAq1o13Pz8DE4jjk4FoIiIuIx9+/YZHcEwqbtzCkCfWur9k39ntylCmZmZnDp1ipSUFEqUKEGxYsXs1ZSIiAgAFQvxpc/yegB1+leuR4H2AF68eJH//e9/NGrUiICAACpVqkSNGjUoUaIEFStWZMCAAfz4448F2aSIiIjN+PHjjY5gCGtWFqm5vZ8qAOV6FFgBOGnSJCpVqsTs2bNp2rQpK1asYPfu3fz+++9s376d0aNHk5WVRfPmzXn88cf5448/CqppERERAHr27Gl0BEOkHziANSUFs58fnlWrGh1HnECBnQL+8ccf2bx5M/fee+8VHw8LC6Nfv35Mnz6d2bNns2XLFu68886Cal5ERKTQso3/q3kfJrOG98u/K7ACcMGCBde1n5eXF88880xBNSsiImLTvXt3oyMYQuv/yY3S1wQREXEZwcHBRkcwhCaAyI0qkAIwNTWVEydOXLb9l19+KYjDi4iIXJfCuA5g9oULZBw+DIB3zZoGpxFnccsF4NKlS7nzzjtp3bo1NWvWZMeOHbbHevXqdauHFxERkWtI3bsXAM+KFXEPCjI4jTiLWy4A33zzTXbt2sXu3buZPXs2/fv3Z/78+QBYrdZbDigiInK9PvzwQ6Mj3HZaAFpuxi0XgJmZmZQqVQqAOnXqsHnzZmbMmMHrr7+OyWS65YAiIiLX67PPPjM6wm2XN/7PW+P/5AbccgFYsmRJfv75Z9v9YsWKsW7dOvbv359vu4iIiL3t3LnT6Ai3ldViITX3d62vZgDLDbjlAnDu3LmULFky3zZPT08WLFjApk2bbvXwIiIi161MmTJGR7itMg4fxpKYiMnbG6+77jI6jjiRW14H8I477rjqYw0aNLjVw4uIiFy3wjYL2Db+LyQEk3uBLe0rhYBd/rUkJiYye/ZsTp06ReXKlQkNDeW+++7D19fXHs2JiIgA8MQTT7Bq1SqjY9w2tvX/NAFEbpBdCsBOnTqxZ88eHnjgAb744gtiY2MBqFq1KqGhoSxatMgezYqIiBQqqTExgCaAyI2zSwG4fft2Nm7cyAMPPABAeno6e/fuZffu3ezJ/bYiIiJS0Dp27Gh0hNsm6/x50v/4AwDfOnUMTiPOxi4FYM2aNXG/ZCyCl5cXdevWpW7duvZorsB17NiRjRs38thjj7F06VKj44iIyHWqWrWq0RFum5Qfc2Y8e915J+7FihmcRpyNXa4FPHHiREaNGkV6ero9Dm93gwcPLpRrSYmIOLt3333X6Ai3TcqPPwLgGxZmcBJxRnYpACtVqkRiYiL33HMPr7zyCqtWreL48eP2aMouGjdujL+/v9ExREREriolOhpQASg3xy4F4BNPPMGRI0do0KAB27ZtIzw8nEqVKlGiRAmaN29+S8fevHkzbdu2pWzZsphMJlasWHHZPlOnTqVSpUp4e3tTr149onP/k4iIiGubOHGi0RFui6z4eNJ//x0A3wecY3iVOBa7jAHct28f27dvJ/SSWUlHjhwhJibmlq8OkpycTGhoKP369aNTp06XPb5o0SIiIyOZPn069erV4/3336dFixbExsbaFqyuVasWWVlZlz137dq1lC1b9pbyiYiIcVauXMndd99tdAy7yzv963VnNY3/k5tilwLwgQceIDk5Od+2SpUqUalSpVueodWyZUtatmx51ccnTZrEgAED6Nu3LwDTp09n9erVzJo1ixEjRgCwe/fuW8pwqfT09HxjHRMTEwvs2CIicmO2bt1qdITbIiU6d/zfAzr9KzfHLgXg4MGDGTNmDIsXL6Zo0aL2aOKKMjIy2LVrFy+//LJtm9lspmnTpmzfvt0ubb711luMHTv2su1du3bFw8ODefPm8corr3D06FFCQkKIiIjgmWeeAWDAgAFkZmYyZ84cAGbNmsXbb79NbGws1apV49VXX6VPnz4A9OrVC19fX2bMmAHAtGnTmDFjBnv27KF8+fK88847dOvWDYAuXbpQpkwZPvjgAwAmT57MggULiI6OpmTJksyYMcNWiLdv357q1avbTptMmDCB1atXs2XLFgICAvj888/p1KkTWVlZtGjRgrCwMN544w0AxowZw9atW1m3bh1eXl4sWbKEHj16kJSURKNGjWjevDkjR44EYMSIEezbt48vv/wSgFWrVtG3b1/OnTtH/fr16dy5My+++CIAkZGRHDt2zDYDe/HixQwZMoQTJ05Qu3Zt+vfvT0REBACDBg0iISGBefPmATmXJhw9ejSHDh2iRo0aREZGMmDAAAD69etne58BZs6cyaRJk9i/fz9VqlRh7Nix9OrVC4CePXsSGBjItGnTgJyrC3zyySfExMRQrlw5Jk+eTJcuXQDo3LkzFSpUYNKkSQC89957LF26lO3btxMcHMzs2bNp164dAG3atCEkJIQJEyYAMG7cONauXcumTZvw8/Nj/vz5PPnkk6Snp9OsWTMaNGjAmDFjAHjttdeIjo7mm2++wd3dneXLl/PUU0+RmJhIw4YNad26te1LzvDhw4mNjWXlypUAREVFMXDgQM6cOUNYWBjdu3dnyJAhQM7/17i4OBYvXgzAwoULGTZsGMePHyc0NJSBAwcyaNAgAAYOHEhKSgpz584FYM6cObz55pscOHCA6tWr89JLL9ne5z59+uDh4cHMmTOBnC9jU6ZMYd++fVSsWJHx48fTs2dPALp3705wcLDtKg4ffvghn332GTt37qRMmTJMmTKFJ554AsiZpV+1alXbYP+JEyeycuVKtm7dSlBQEJ9++ikdOnTAYrHQqlUrateuzbhx4wB4/fXX2bhxIxs2bMDHx4dFixbRtWtXUlNTadKkCY0bN2bUqFEAjBw5kpiYGL766ivMZjMrVqwgPDyc+Ph4GjRoQPv27Rk+fDgAQ4cO5eDBg0RFRQGwbNkyIiIiiIuLo27duvTu3ZsXXngBgIiICM6dO8eCBQsA9BlRwJ8RR48e5dixYy7/GTEo9ndKA6eKF+c/uc/VZ0Th+ozIzMzkVpisVqv1lo5wBWZzztDC4OBgOnbsSL169ahduzYhISF4enoWWDsmk4moqCg6dOgAwMmTJylXrhzbtm2jfv36tv2GDx/Opk2b2LFjx3Udt2nTpuzZs4fk5GSKFSvGkiVL8h3vUlfqASxfvjwJCQkEBATc/IsTERG5gow/T3CwaVNwc+Ourd/jdhs7WsRxJCYmEhgYeNP1hl16AA8fPsyePXtsCz+PHz+eI0eO4O7uTvXq1W95HKC9ffvtt9e9r5eXF15eXnZMIyIi16tDhw5XnBzoSpK++w4A39q1VfzJTbNLAVixYkUqVqxo69IGuHjxIrt377Zr8Ve8eHHc3Nw4ffp0vu2nT5+mdOnSdmtXREQcg8ViMTqC3eUVgH6PPmpwEnFmdlkGZtu2bezbty/fNn9/fxo2bMhzzz1njyYB8PT0pE6dOqxfv962zWKxsH79+quewhUREdfRqlUroyPYVXZSEsm5M4BVAMqtsEsB+Nxzz11xvN3Bgwe5ePHiLR07KSmJ3bt322byHj58mN27d3Ps2DEgZ3DwzJkz+fTTT9m/fz/PPvssycnJtlnBIiLiumrXrm10BLtK/v57yMzEs1IlvKpUNjqOODG7FICxsbE0btz4su3ffvst3bt3v6Vj79y5k9q1a9v+k0dGRlK7dm3brJyuXbvy7rvvMmrUKGrVqsXu3btZs2YNpUqVuqV2RUTE8eXN5nRVOv0rBcUuYwADAgKIj4+/bHvDhg1tU/5vVuPGjfm3icsRERG2JQBERERcgSUtjYvfbQTA79HGRkYRF2CXHsDHH3/8ihfkNpvNZGRk2KNJERERXn/9daMj2M3Fdd9iSUzEvWwZfOvq8m9ya+xSAL7xxhts2rSJJ554gr179wKQlpbG22+/Tc2aNe3RpIiICBs3bjQ6gt1cWLYMgKIdO2Ey2+XXtxQidvkXVL58eX744QdSU1MJDQ3Fx8cHf39/vvjiC9555x17NCkiIsKGDRuMjmAXGcePk/LDD2AyUbTTrV1SVQQKeAzgqFGjaN++PXXq1KFixYp89dVXHD16lD179uDh4UG9evUopotWi4iInfj4+BgdwS4uLF8OQJH69fEoV87gNOIKCrQA/PPPP2nZsiWenp60bduW9u3b06RJEypWrFiQzYiIiFzRokWLjI5Q4CwZGSQsyykAi3Z+wuA04ioK9BTwrFmzOHXqFAsWLMDf35/BgwdTvHhxnnjiCT777DPOnz9fkM2JiIjk07VrV6MjFLiEFSvIOnMG95Il8Wva1Og44iIKfAyg2WymYcOGTJw4kdjYWHbs2EG9evWYMWMGZcuW5ZFHHuHdd9/lxIkTBd20iIgUcqmpqUZHKFDWrCzOzfw/AIL798Ps6WlwInEVdp9GVKNGDYYPH87WrVs5fvw44eHhbNmyhQULFti7aRERKWSaNGlidIQClfjVV2QeP45bUBBFn3zS6DjiQuyyEPTVlChRgv79+9O/f//b2ayIiBQSV7oKlbOyWiz89fHHABQLD8fs62twInElt20hocTERDZv3syHH354u5oUEZFCJu+yoK7g4rffknHgIGZ/f4J69jA6jrgYu/QAHjt2jN27d+f7OXr0KFarlSJFivDCCy/Yo1kRERGXYLVaOTd9BgBBPXvg5u9vcCJxNQVaADZp0oQ9e/YQHx9PYGAg99xzDyEhIRw7doxPPvmExx57jPLlyxdkkyIiIja3er15R5G8ZQtpv/6KyceHYuHhRscRF1SgBeD333/PsGHDGDRoEOUuWahy1qxZhIWFqfgrABl//smp0WMw+Xhj9vbB7OOTc9vLC9zdMXl4XOHH8x/3c/7aLcnJWNPTwWwGsznn0kJmN0xuV/ozdx83t0v+dMNkNoGbW85z//ln7vHACllZWC0WyM7GarFgzcoCiwVrdjZmT0/M/v6YvLzyvVaTyZRzIy+Xe+5x3d11GSQRuaKYmBjq1atndIxbYrVa+Suv969rV9yDggxOJK6oQAvAHTt2MHjwYH755RcmTpzIXXfdVZCHFyA7Pp7krVuNjuEY8grB3D9Nbm45xecV/zRjcnO3/Wl73iU/eOQW0O4ef29zd8Nkyit+zZB322yy3cZsytnHZMq5bc69bcp7zPSP5/39GKa8/c1g4u/bZnNOwevmli8nbm65+dxy77tfctstJ79b7v285116X4WzuLivvvqKZ555xugYtyTlxx9J/eknTB4eFOvb1+g44qIKtACsXbs2mzdvZv78+bRo0YJWrVoxevTogmyi0PMoV46yb0/AkpqGJS0Va1oalpRUrBkZWDMzr/2T9fdtrOBWpEhOr5vVmq93Lt+fVgtkW8CSjTX7n49Zr/wciwUuvZ3Xu5jbM5hXmOFmxmR2w5qRQfbFi5CVdWNvRlYWVoCMjJw/5d/lvf+XFId4uOcUxf+87+WFm18RzEX8MPv74+bvj1twMO7BxXL+LFECz4oVcfPzM/pVidiYXeBLTt7Yv8AnOuFRqqTBacRVmaxWq11+d6akpDB+/HhmzJjB+fPn2b17N/fdd589mnIoiYmJBAYGkpCQQEBAgNFxnIbVaoVL/yleevvS4jL3J+e2BbJzTy3nnmK2nVrOys4pWv/556XPz8rGmpWZ89ysrNziOPfPrCysmRlgsYLVklvUXnI724LVkg3W3KwWS06xbLX+vV/ebUvOdqvV8vd9rFiv9FjesfJeb1ZWTuasTMjKu58FmXnbL79P7nNy2rE/91KlKPJgPYo0fIQiDR7S6SqRW5D6888c6dIV3Nyo+s0aPO+4w+hI4qButd6wWwGY59ChQwwZMoTt27czfPhwnnvuOZe9WDeoABTHYSuMs/5RHObdz8z8u8jMyoaszNz9cgpOa3o6luRksi9exJKUTHbCBbLPnSfr3Dmyzv1F1ukzZJ87l79Rsxmf++6jyCMN8XvkEbzvvVenneW2Cg8P59NPPzU6xk07Pug5kjZsILB9e8q+PcHoOOLAHL4AzLN27VqGDBnC+fPniYuLux1NGkIFoBQm2RcvkvbLryR/v4WkzVtI//33fI+7BQVR5OGH8W/aFL9HGmJ24S9/4hjatWvHqlWrjI5xUzKOHuVgi8fBZKLK6i/xqlLF6EjiwG613iiwMYDHjh2jQoUKV328efPm7N69m6lTpwJw4sSJfDOFRcT5uPn755z+fbAeJYcOJfPUKZK2bCF58xaSt28nOz6exC++IPGLLzD5+uLX6BECWjyOX6NHVAyKXTRo0MDoCDftwpIlABRp+LCKP7G7Ajs388ADDzBw4EB+/PHHq+6TkpKCr68vISEhLFu2rKCaFhEH4VG6NEFPPskdH33IXdu3UXHuZxTr1w+PcuWwpqRw8es1nPjvf/n9oQb8+d8hJK5ZgyUlxejY4kLat29vdISbYs3I4MLyKACCunQxOI0UBgV2CvjcuXOMGzeOWbNm4e3tTZ06dShbtize3t7Ex8fz66+/8ssvv3D//ffz2muv0apVq4Jo1uHoFLDI5axWK2n7fuHiN2tI/HoNmSdO2B4zeXvj36QJge3bUaRBg5wla0RukrOeAk5cs4YT/x2Ce4kSVPtug/4fyL9yuDGAqamprF69mu+//56jR4+SmppK8eLFqV27Ni1atCAkJKQgm3M4KgBFri1fMbjmGzL//NP2mFvx4gS2bk1gh/Z43X3334uBi1wnZy0Aj/btS8r2Hwh+9hlKDh5sdBxxAg5XABZ2KgBFrl9OMbiPhFVfkPjll2THx9se87rrLgLbtyOgTVuthSbXbfPmzTzyyCNGx7ghmXFxHHi0CZhMVF23Ds87ND5e/t2t1htan0FEDGMymfC57z5Kj3yFOzdv4o5p0/Bv0QKThwfpv//OmXfe5cCjj3Ks/9MkfPGFxgvKvzp48KDREW7YxfUbAPC5/34Vf3LbaJCBiDgEk4cH/k0exb/Jo2QnJJC45hsSVq4k9aefSN66leStWzH7+uLfvDmBHdrjGxamNQblMlFRUfR1ssunXVz/LQD+jz1mcBIpTFQAiojDcQsMJKhrF4K6diHj2DESVn1BwsqVZB4/TsKKFSSsWIF7mTIEtmmTM16walWjI4vclOzERFJ+3AmA/2NNDE4jhYnGABYwjQEUsQ+r1UpqTAwJK1eR+PXXWBITbY9533cfRbs8SWCrVpiLFDEwpRgtMzMTDw8Po2Nct4QvvuTksGF4VqtK1S+/NDqOOBGNARSRQsFkMuF7//2UGTuGO7dsptz77+P36KPg7k7a3r2cem0Uvz/ckD9fGEzC6tVYMjKMjiwGiIiIMDrCDbm4fj0A/o81NTiJFDZ2KQDDw8PZvHmzPQ4tIoLZy4uAx1tQ/n/TuHPTRkoOG4ZnxYpYU1O5uHYtJ18cyoHGj3Jm0mTSDx82Oq7cRs50qVFLRgbJub8rdfpXbje7FIAJCQk0bdqUO++8k/Hjx3PikkVfRUQKkntwMMH9+1FlzddUWraU4IEDcS9Viuzz5zn38cccatmKI926E79wIdkXLhgdV+ysbt26Rke4bmk//4wlJQW34sXxdvE1csXx2KUAXLFiBSdOnODZZ59l0aJFVKpUiZYtW7J06VIyMzPt0aSIFHImkwmfe++l5JD/Um39t5T74AOKNHoE3NxI3b2bU2PG8kfDR/jzhcFc3LABqz6LXFLv3r2NjnDdUnb9BIBvnTqa0S63nd3+xZUoUYLIyEj27NnDjh07qFatGr169aJs2bIMGTKEP/74w15Ni0ghZ3J3J6BFcyrMmMGdG7+j5Esv4XX33VgzM7m4di1/DnqOP5o04cx7k8g4etTouFKAXnjhBaMjXLeUn3YB4FvnfoOTSGFk968ccXFxrFu3jnXr1uHm5karVq3Yu3cv99xzD5MnT7Z38yJSyLmXKEFw3z5UWRFF5RVRFOvTB7fgYLLP/sW5mTM52OJxjvbqTfyCBWSeOWN0XCkkrBYLqT/FAOBzfx2D00hhZJdlYDIzM1m1ahWzZ89m7dq11KxZk6effpoePXrYpipHRUXRr18/4i+59JMr0DIwIo7PmpnJxY0bubB0KclbvgeLJecBkwnfB+tRtGNH/Js2xezra2xQuWFr166lefPmRsf4V2mxv3O4fXtMvr5Uj96ByV3L8sqNudV6wy7/4sqUKYPFYqF79+5ER0dTq1aty/Z59NFHKVq0qD2aFxG5JpOHBwHNmhHQrBmZcXEkrl7NxXXfkrpnDynbfyBl+w+YixTBv+XjFO3YEZ/778dkMhkdW67DuXPnjI5wXVLzTv/WClXxJ4awyyngwYMH8+effzJ16tR8xZ/VauXYsWMAFC1alMNankFEDOZRpgzBTz9NpUULqfrttxR/4Xk8ypfHkpxMwtJlHO35FAdbPM5f//sfmSdPGh1X/sWCBQuMjnBd8iaA6PSvGMUup4Dd3NyIi4ujZMmS+bafO3eOkiVLkp2dXdBNOgydAhZxflarldRdu7gQFcXFr9dgSUnJecBkwqd2bfybNcO/WVM877jD2KBymXbt2rFq1SqjY/yrP5o0IetkHBVmz6JI/fpGxxEndKv1hl0KQLPZzKlTpy4rAI8ePco999xDcnJyQTfpMFQAirgWS0oKF9et40LUClJ++CHfY141ahDYrh1Fn+iEm/6/O4SLFy/i7+9vdIxryoyL48CjTcDNjerRO3T5QrkpDjUGMDIyEshZj2vUqFH4XjKAOjs7mx07dlxxPKCIiKMy+/oS2L49ge3bk3nqFBe/Xc/FdetI+fFH0vfv58z+/Zz96CMCW7cioG1bfOvW1ZpuBnrllVf46KOPjI5xTWm//gqA1513qvgTwxRoARgTkzOl3Wq1snfvXjw9PW2PeXp6EhoaytChQwuySRGR28ajdGmKPdWTYk/1JCs+novffEP8vHmk/3GAC0uWcmHJUtzLlCGwdSsCO3TAq1o1oyMXOkedYF3HtNhYALyrVzc4iRRmBVoAfvfddwD07duXDz74wClPgV64cIGmTZuSlZVFVlYWgwcPZsCAAUbHEhEH4x4URFC3bhTt2pWUH38kYdUqLn6zlqy4OM793yec+79P8A0LI6hHD/wfa4LJw8PoyIVCiBNcUi099ncAvFQAioHsMgbQmWVnZ5Oeno6vry/JycmEhISwc+dOgoODr+v5GgMoUnhZ0tNJ2riJhFWrSPruO9v6gu4lS1K0axeKPvkkHv8YGy0F6+TJk5QtW9boGNd0sMXjZBw9SvlP/g+/Bg2MjiNOymHGAEZGRvLGG29QpEgR21jAq5k0aVJBNVvg3NzcbGMX09PTsVqtqEYWketh9vIioEVzAlo0JzMujvhFi7iwZClZZ87w10dT+Ot/0/Fv1pRiPXrgU7eu1ha0g2eeecahZwFbUlLIyF0Ozfvuuw1OI4VZgY1UjomJITP34uoxMTFX/dm9e/cttbN582batm1L2bJlMZlMrFix4rJ9pk6dSqVKlfD29qZevXpER0ffUBsXLlwgNDSUO+64g2HDhlG8ePFbyiwihY9HmTKU/O9/qfbdBsq+8w4+tWtDVhYXv17D0V69Ody+A/ELF2Jx4VUR5HLpBw6A1Ypb8eK4X+eZJRF7KLAewLzxf/+8XdCSk5MJDQ2lX79+dOrU6bLHFy1aRGRkJNOnT6devXq8//77tGjRgtjYWNuyNLVq1SIrK+uy565du5ayZctStGhR9uzZw+nTp+nUqROdO3emVKlSdntNIuK6zJ6eBLZtQ2DbNqTt30/8/PkkfPEl6b//zqkxYznzzrsEduhAUM8eeFWpYnRcp+foY7bTfvsNAO+77jI4iRR2dhkDmJqaitVqtZ1KPXr0KFFRUdxzzz0Feo1Gk8lEVFQUHTp0sG2rV68eDzzwAFOmTAHAYrFQvnx5nn/+eUaMGHHDbQwaNIgmTZrQuXPn69pfYwBF5N9kJySQsGIF8fMXkJE3a9VkIqBVK4o/9xxeVSobG9CJLV++/IqdA47i1BtvEj9vHsX69aPU8GFGxxEndqv1hl0Wq2rfvj2fffYZkHM6NSwsjPfee4/27dvzv//9zx5NApCRkcGuXbto2rSpbZvZbKZp06Zs3779uo5x+vRpLl68CEBCQgKbN2+m+jVmaqWnp5OYmJjvR0TkWtwCAykWHk6Vr7+i/P/9H36PPgpWK4mrV3OodWuOD3qO5O3bNf74JsyZM8foCNeUblsCRj2AYiy7XIH6p59+YvLkyQAsXbqU0qVLExMTw7Jlyxg1ahTPPvusPZrlr7/+Ijs7+7LTtaVKleK33G73f3P06FH+85//2CZ/PP/889x3331X3f+tt95i7Nixl23v2rUrHh4ezJs3j1deeYWjR48SEhJCREQEzzzzDJBzqiIzM9P2gTVr1izefvttYmNjqVatGq+++ip9+vQBoFevXvj6+jJjxgwApk2bxowZM9izZw/ly5fnnXfeoVu3bgB06dKFMmXK8MEHHwAwefJkFixYQHR0NCVLlmTGjBl07NgRyCnWq1evzsSJEwGYMGECq1evZsuWLQQEBPD555/TqVMnsrKyaNGiBWFhYbzxxhsAjBkzhq1bt7Ju3Tq8vLxYsmQJPXr0ICkpiUaNGtG8eXNGjhwJwIgRI9i3bx9ffvklAKtWraJv376cO3eO+vXr07lzZ1588UUgZ0LRsWPHWLp0KQCLFy9myJAhnDhxgtq1a9O/f38iIiKAnB7ahIQE5s2bB8DcuXMZPXo0hw4dokaNGkRGRtpOCfXr18/2PgPMnDmTSZMmsX//fqpUqcLYsWPp1asXAD179iQwMJBp06YBMGXKFD755BNiYmIoV64ckydPpkuXLgB07tyZChUq2CY3vffeeyxdupTt27cTHBzM7NmzadeuHQBt2rQhJCSECRMmADBu3DjWrl3Lpk2b8PPzY/78+Tz55JOkp6fTrFkzGjRowJgxYwB47bXXiI6O5ptvvsHd3Z3ly5fz1FNPkZiYSMOGDWndurWtl3v48OHExsaycuVKAKKiohg4cCBnzpwhLCyM7t27M2TIECDn2t1xcXEsXrwYgIULFzJs2DCOHz9OaGgoAwcOZNCgQQAMHDiQlJQU5s6dC+T8sn3zzTc5cOAA1atX56WXXrK9z3369MHDw4OZM2cCMH36dKZMmcK+ffuoWLEi48ePp2fPngB0796d4OBgW8/9hx9+yGeffcbOnTspU6YMU6ZM4YknngCgY8eOVK1alXfffReAiRMnsnLlSrZu3UpQUBCffvopHTp0wGKx0KpVK2rXrs24ceMAeP3119m4cSMbNmzAx8eHRYsW0bVrV1JTU2nSpAmNGzdm1KhRAIwcOZKYmBi++uorzGYzK1asIDw8nPj4eBo0aED79u0ZPnw4AEOHDuXgwYNERUUBsGzZMiIiIoiLi6Nu3br07t2bF154AYCIiAjOnTtnu2btvHnzmLhoIZkVytMpM5PycadI2rCBpA0bSC9VivMPPsiUX/aRZTbrM+I6PiNiY2M5duyYY35GvPceYw4ewgf4/PutfPPJJ/qM0GfEdX1GXKmOyJt3cbPscgrY19eX3377jQoVKtClSxfuvfdeRo8ezfHjx6levTopedfVvEX/PAV88uRJypUrx7Zt26h/ybUVhw8fzqZNm9ixY0eBtHup9PR00tPTbfcTExMpX768TgGLyE1JP3Q4Z5zg8uW2axC7lShOcN9+BHXvhtnHx+CEju2vv/5y2Il7mSdPcqDJY+Duzt0/7cJ0ycUSRG6UQ54CrlatGitWrOD48eN88803tnF/Z86csWtRVLx4cdzc3Dh9+nS+7adPn6Z06dJ2adPLy4uAgIB8PyIiN8urSmVKvzqSaps3UeqVl3EvW4bss39xZuJEDj7ekgvLlmHNzjY6psN6++23jY5wVekHDwLgVbmSij8xnF0KwFGjRjF06FAqVapEvXr1bL1xa9eupXbt2vZoEsi53FydOnVYv369bZvFYmH9+vX5egRFRBydm58fxXr3pto331Bm3Dg8ypYl6/Rp4ka+yuEOHbj43XcaI3gFsblj7BxRxuEjAHhW0iQfMZ5dxgB27tyZhx9+mLi4OEJDQ23bH3vsMdu4kpuVlJTEgQMHbPcPHz7M7t27KVasGBUqVCAyMpLw8HDq1q1LWFgY77//PsnJyfTt2/eW2hURMYLJw4OiT3QioG0b4ufN56/p00n/4wB/PjsIrxo1CO4TTkDr1pjc7fJx7nSqOfD1lzOOHAHAs1JFY4OI4ISXgtu4cSOPPvroZdvDw8NtkymmTJnCO++8w6lTp6hVqxYffvgh9erVuy35tAyMiNhTdmIi52bO5Pzn87CmpgLgdeedlBr5CkUefNDgdMY7f/48xYoVMzrGFR3r/zTJW7dSZtybFM2dsCBys2613rBbAbh+/XrWr1/PmTNnsOReDzNP3gwrV6QCUERuh+wLF4hftJjzs2aRnZAAgF+jRhR/4Xl87r3X4HTGadeuncNeCu7AY03JPHGCivM+x7dOHaPjiJNzyEkgY8eOpXnz5qxfv56//vqL+Pj4fD8iInJr3IoWpfjA/1D1mzUE9egBbm4kbdrEkSc6c/LVV8nOXc9UHIMlPZ3MkycB8KyoU8BiPLsMGpk+fTpz5syxrZckIiL24Va0KKVHvUax3r04O3UaiV9+ScLSZSR/v5VSI1/Bv2lTTCaT0TFvG0f9vZN5/DhYrZj9/HDTNYDFAdilBzAjI4OHHnrIHocWEZEr8KxUiXLvTKTi3M/wqFCBrFOnOPH8Cxzt3oO0/fuNjnfb5F2C1NHYJoBUrFioCnJxXHYpAJ9++mnmz59vj0OLiMg1+NatS5UVUQQ/+wwmHx9Sd+/mSPceJH71ldHRbou8K6E4mr9nAFcyNIdIHrucAk5LS+Pjjz/m22+/pWbNmnh4eOR7PO+SWSIiUvDMvr6UHDyYoO7diXv1VZI3b+FE5Isk//gjJSIicNcpyNsu4+hRQAWgOA67FIA///wztWrVAmDfvn35HlPXt4jI7eFRsiTl//c/zrz7Hudnz+bCgoUkrlxF8Reep1jv3pjMdjkJZKi8a/M6mr8XgdYEEHEMdikAv/vuO3scVkREbpDJzY1SLw3Hr9EjnHnnXdJ++YUzE94mees2yr41HncHvW7uzZoxYwZvvPGG0TEuk370CKAeQHEcrvf1T0RELlPkwQeptGQxpceMxuTlRfKWLRzp2o2MP08YHa1A7dmzx+gIl8lOSib77F+AloARx2G3AnDLli089dRT1K9fnxMncj5g5s6dy/fff2+vJkVE5BpMZjNB3bpReekSPCpUIPPECY726mUbn+YKypcvb3SEy2Tk9v65FSuGmy4QIA7CLgXgsmXLaNGiBT4+PsTExJCeng5AQkIC48ePt0eTIiJynbzuvJOKcz/Ds3JlsuLiOPxE55xLy2VnGx3tlr3zzjtGR7hM5rFjAHhWqGBwEpG/2aUAfPPNN5k+fTozZ87MNwO4QYMG/PTTT/ZoUkREboBHqVJU/OxTfEJDsSQlcfrNNznWtx+WlBSjo92Sbt26GR3hMpm5Z8E87rjD4CQif7NLARgbG8sjjzxy2fbAwEAuXLhgjyZFROQGuZcoQcX58yg9ZjTmIkVIiY7mz4jnseSetZGCkfHnnwB43FHO4CQif7NLAVi6dGkOHDhw2fbvv/+eKlWq2KNJERG5CSY3N4K6daP8/83E5OtL8rZtnBj8X6ctArt06WJ0hMtk5k608VQPoDgQuxSAAwYMYPDgwezYsQOTycTJkyeZN28eQ4cO5dlnn7VHkyIicgt8a9em/P/+h8nLi6SNG/nz2UFYUlONjnXDypQpY3SEy2TaegBVAIrjsEsBOGLECHr06MFjjz1GUlISjzzyCE8//TQDBw7k+eeft0eTIiJyi4rUC6P8jOm2nsDjA/5DdlKy0bFuyAcffGB0hHysFovGAIpDsksBaDKZGDlyJOfPn2ffvn388MMPnD171iEX5xQRkb8VefBBKvzf/2H28yNl506O9etHdkKC0bGcVtbZs1gzM8HNDY/SpY2OI2JTYFcCiYyMvO59dS1gERHH5Xt/bSrMmcPx/v1J+/lnjvbtS6W5czEXKWJ0tH81efJkoyPkYzv9W7o0Jne7XHxL5KYU2L/GmJiYfPd/+uknsrKyqF69OgC///47bm5u1KlTp6CaFBERO/EJuZcKn33Gsb59Sf91PydfGUm59yc7/PXcFyxYwKuvvmp0DBud/hVHVWAF4KXX/500aRL+/v58+umnBAUFARAfH0/fvn1p2LBhQTUpIiJ25F39Lu6Y8hFHw/tw8ZtvODfjY4o/M9DoWNcUHR1tdIR8tASMOCq7jAF87733eOutt2zFH0BQUBBvvvkm7733nj2aFBERO/C9/35K5/aonf3gAy5u3GhsoH9RsmRJoyPkk7cEjEc5FYDiWOxSACYmJnL27NnLtp89e5aLFy/ao0kREbGToK5dKNqtK1itnBw6jPRDh4yOdFUzZswwOkI+eWMAtQagOBq7FIAdO3akb9++LF++nD///JM///yTZcuW0b9/fzp16mSPJkVExI5Kv/IKPnXqYElK4s/nIhx2eZiOHTsaHSEfrQEojsouBeD06dNp2bIlPXr0oGLFilSsWJEePXrw+OOPM23aNHs0KSIidmTy9OSOD97HvXRpMg4f5vSbbxodyeFZMzPJPHUKAI9yKgDFsdilAPT19WXatGmcO3eOmJgYYmJiOH/+PNOmTaOIEywjICIil3MvXpxy774DZjMJK1aQ8OVqoyNdpn379kZHsMk8fRosFkyenriXKG50HJF87FIA5ilSpAg1a9akZs2aKvxERFyAb926FM+9pOepMWPIOH7c4ET55S095ghsp3/LlcNktuuvW5Ebpn+RIiJyQ4o/+ww+99+PJSmJE0OH5lzpwkFMnDjR6Ag2tjUANQNYHJAKQBERuSEmd3fKvTMRs78/aXt+5uyUqUZHckiZJ+MA8Chb1uAkIpdTASgiIjfMo1w5yrzxOgDnPv6YlJ07DU6UY8KECUZHsMmMyysAyxicRORydikAjx07htVqvWy71Wrl2LFj9mhSRERus4DHHyewU6ec9QFfGYklJcXoSKxe7TgTUzJPngTUAyiOyS4FYOXKla+4EPT58+epXLmyPZoUEREDlHp5BO6lS5N57BhnJr9vdBy2bNlidASbzLjcArCMegDF8dilALRarVe8YHhSUhLe3t72aFJERAzg5u9Pmdw1AePnziUlJsbQPAEBAYa2n8dqsZCVOwbQvYx6AMXxuBfkwSIjIwEwmUy89tpr+Pr62h7Lzs5mx44d1KpVqyCbFBERg/k93IDATp1IWL6c029NoNLCBYYte/L5558b0u4/ZZ87lzM72mzGo5RjXZ9YBAq4AIzJ/eZntVrZu3cvnp6etsc8PT0JDQ1l6NChBdmkiIg4gJJD/svFNWtI+/lnElevJrBtW0NydOrUieXLlxvS9qXyxv+5lyyJycPD4DQilyvQAvC7774DoG/fvnzwwQcO0xUvIiL25V6iBMH/+Q9n33+fM+9Nwr9pU8w+Prc9R1ZW1m1v80r+ngGs07/imOzSRz979mwVfyIihUyxPuG4ly1D1qlTxM+bZ0iGFi1aGNLuP2We0AQQcWwF2gN4qfXr17N+/XrOnDmDxWLJ99isWbPs1ayIiBjE7O1NiedfIO7llzk38/8o2q0bbn5+tzVDWFjYbW3varQGoDg6u/QAjh07lubNm7N+/Xr++usv4uPj8/2IiIhrCmzXFs8qVchOSOD8nE9ve/tvvPHGbW/zSrQGoDg6u/QATp8+nTlz5tCrVy97HF5ERByUyc2NEi88z4n/DuH87NkE9eyBe1CQ0bFuu7weQHedAhYHZZcewIyMDB566CF7HFpERBycf/PmeNWogSU5mfi5c29r22PGjLmt7V1NlnoAxcHZpQB8+umnmT9/vj0OLSIiDs5kNlP8mWcAOP/5PLKTkm9b21u3br1tbV2NJTmZ7IQEQAWgOC67nAJOS0vj448/5ttvv6VmzZp4/GMNpEmTJtmjWRERcRD+zZriWbkyGYcPc2HRIoL797st7a5bt47nn3/+trR1NXmnf80BAbd9EozI9bJLAfjzzz/brvixb9++fI9d6RJxjqZSpUoEBARgNpsJCgqyrW8oIiLXx2Q2E/z008SNHMm5ObMJeqonZi8vu7frdRva+De2CSAa/ycOzC4FoCsUTNu2bcNP39xERG5aYNs2nP3oI7JOnSJh5UqCunSxe5tLliyxexv/JjP3GsAqAMWRGXOxRhERcXkmT0+KhYcDED93Llar1e5t9ujRw+5t/BstASPOwG4F4JYtW3jqqaeoX78+J06cAGDu3Ll8//33t3TczZs307ZtW8qWLYvJZGLFihWX7TN16lQqVaqEt7c39erVIzo6+obaMJlMNGrUiAceeIB5Bq1mLyLiCoo+0QmTry/pfxwg5Ycf7N5eUlKS3dv4N1oEWpyBXQrAZcuW0aJFC3x8fIiJiSE9PR2AhIQExo8ff0vHTk5OJjQ0lKlTp17x8UWLFhEZGcno0aP56aefCA0NpUWLFpw5c8a2T61atQgJCbns52Tut7bvv/+eXbt2sWrVKsaPH8/PP/98S5lFRAort4AAinboAMD5Tz+ze3uNGjWyexv/Rj2A4gxMVjv0ydeuXZshQ4bQu3dv/P392bNnD1WqVCEmJoaWLVty6tSpAmnHZDIRFRVFh9wPF4B69erxwAMPMGXKFAAsFgvly5fn+eefZ8SIETfcxrBhw7j33nvp06fPFR9PT0+3FbgAiYmJlC9fnoSEBF0PWUQESD98mEMtW4HJRNU1X+NZsaLd2tq7dy/33Xef3Y5/Pf54tAlZcXFUWrgAn9wJkSIFLTExkcDAwJuuN+wyCSQ2NpZHHnnksu2BgYFcuHDBHk0COQtQ79q1i5dfftm2zWw207RpU7Zv335dx0hOTsZiseDv709SUhIbNmygyzUGLr/11luMHTv2su1du3bFw8ODefPm8corr3D06FFCQkKIiIjgmdz1sQYMGEBmZiZz5swBcq6R/PbbbxMbG0u1atV49dVXbYVnr1698PX1ZcaMGQBMmzaNGTNmsGfPHsqXL88777xDt27dAOjSpQtlypThgw8+AGDy5MksWLCA6OhoSpYsyYwZM+jYsSMA7du3p3r16kycOBGACRMmsHr1arZs2UJAQACff/45nTp1IisrixYtWhAWFma71NKYMWPYunUr69atw8vLiyVLltCjRw+SkpJo1KgRzZs3Z+TIkQCMGDGCffv28eWXXwKwatUq+vbty7lz56hfvz6dO3fmxRdfBCAyMpJjx46xdOlSABYvXsyQIUM4ceIEtWvXpn///kRERAAwaNAgEhISbKfq586dy+jRozl06BA1atQgMjKSAQMGANCvXz/b+wwwc+ZMJk2axP79+6lSpQpjx461Xb2mZ8+eBAYGMm3aNACmTJnCJ598QkxMDOXKlWPy5Mm2fxedO3emQoUKtuWN3nvvPZYuXcr27dsJDg5m9uzZtGvXDoA2bdoQEhLChAkTABg3bhxr165l06ZN+Pn5MX/+fJ588knS09Np1qwZDRo0sC1s+9prrxEdHc0333yDu7s7y5cv56mnniIxMZGGDRvSunVr25ec4cOHExsby8qVKwGIiopi4MCBnDlzhrCwMLp3786QIUMAGDx4MHFxcSxevBiAhQsXMmzYMI4fP05oaCgDBw5k0KBBAAwcOJCUlBTm5i7uO2fOHN58800OHDhA9erVeemll2zvc58+ffDw8GDmzJlAzhWCpkyZwr59+6hYsSLjx4+nZ8+eAHTv3p3g4GDbF7cPP/yQzz77jJ07d1KmTBmmTJnCE088AUDHjh2pWrUq7777LgATJ05k5cqVbN26laCgID799FM6dOiAxWKhVatW1K5dm3HjxgHw+uuvs3HjRjZs2ICPjw+LFi2ia9eupKam0qRJExo3bsyoUaMAGDlyJDExMXz11VeYzWZWrFhBeHg48fHxNGjQgPbt2zN8+HAAhg4dysGDB4mKigJyzoJEREQQFxdH3bp16d27Ny+88AIAERERnDt3jgULFgAUms+I/v5+3HUxiU97h/NFYIDdPiNiY2NZt26dYZ8Re376iXFxcZiBp195hYvu7vqM0GeEXT4jMjMzuRV26QGsUqUKH3/8MU2bNs3XA/jZZ58xYcIEfv311wJp5589gCdPnqRcuXJs27aN+vXr2/YbPnw4mzZtYseOHf96zEOHDtk++LKzsxkwYACDBw++6v7qARQR+XcJq1dz8sWheFasSJU1X9ttSbB27dqxatUquxz7emSeOMGBx5qChwd379mNyay5lmIfDtkDmFc0zZo1C5PJxMmTJ9m+fTtDhw7ltddes0eTBaZKlSrs2bPnuvf38vJyiHWnREQcmX/jxpi8vMg4epT0337Du0YNu7RzM0N9CpJtAkjp0ir+xKHZpQAcMWIEFouFxx57jJSUFB555BG8vLwYOnSoXVdoL168OG5ubpw+fTrf9tOnT1O6dGm7tSsiItdmLlIEv0aNuLh2LYlfr7FbAbhv3z5Dr0WvCSDiLAr860lmZiZNmzalS5cunD9/nn379vHDDz9w9uxZ27gQe/H09KROnTqsX7/ets1isbB+/fp8p4RFROT2C3i8BQCJa9bYbU3AvDGERtEi0OIsCrwH0MPDw7ZsiqenJ/fcc0+BHj8pKYkDBw7Y7h8+fJjdu3dTrFgxKlSoQGRkJOHh4dStW5ewsDDef/99kpOT6du3b4HmEBGRG+PXqBEmb28yjx0jff9+vAv494MjUA+gOAu7DFB46qmn+OSTT+xxaHbu3Ent2rWpXbs2kDMbrHbt2rZZOV27duXdd99l1KhR1KpVi927d7NmzRpKlSpllzwiInJ98k4DAyR+vcYubRg5AQQuGQNYTgWgODa7jAHMyspi1qxZfPvtt9SpU4ciRYrkezxvKvzNaNy48b+eOoiIiLAtASAiIo4j4PEWXPzmGxLXrKFE5JACnw3ct29fZs+eXaDHvBG2HkCdAhYHZ5cCcN++fdx///0A/P777/kes9fUfxERcXy208DHj5P266/43HtvgR7/3LlzBXq8G2G1WnUKWJyGXQrA7777zh6HFRERJ2f29cWvcWMurlnDxTVrCrwANHLCX/aFC1hTUwFwVw+gODi7zAJ+7LHH+OOPPwr60CIi4gJss4G/LvjZwJ07dy7Q492IvN4/t+LFMWt9WHFwBV4AXjoLWERE5J/8HnkEk48PmX/+SdovBXNlqDx5l4szQlacloAR5+F0s4BFRMS55ZwGzpkNfHHN1wanKTga/yfOxOlmAYuIiPMLaPE4F79eQ+LXayjx4osFNkEwMjKyQI5zM7QItDgTzQIWEZHbzq9R7mngEydI2/cLPveFFMhxjx07ViDHuRnqARRnolnAIiJy25l9fPBr3CinF3DN1wVWAC5dupTevXsXyLFulK0A1CLQ4gTsMgZQRETk3wQ83hKAi3aYDWyETE0CESdilx7A119//ZqP5122TURECi+/Rxpi8vUl8+RJ0vbtw+e++275mIsXLy6AZDfOkpZGdu4i1DoFLM7ALgVgVFRUvvuZmZkcPnwYd3d3qlatqgJQREQw+/jg37gRiV99TeKaNQVSAA4ZMoT//e9/BZDuxuT1/pl8fTEHBt729kVulF0KwJiYmMu2JSYm0qdPHzp27GiPJkVExAn5N2tG4ldfk7ThO0oNG3bLxztx4kQBpLpxf08AKaPJjuIUbtsYwICAAMaOHctrr712u5oUEREHV+Thh8HdnYzDh8k4cuSWj1e7du1bD3UT/l4EWqd/xTnc1kkgCQkJJCQk3M4mRUTEgbn5+1Mk7AEALn638ZaP179//1s+xs3QEjDibOxyCvjDDz/Md99qtRIXF8fcuXNp2bKlPZoUEREn5df4UZK3bSdpwwaC+/a5pWNFRESwatWqggl2A2yLQKsAFCdhlwJw8uTJ+e6bzWZKlChBeHg4L7/8sj2aFBERJ+XX5FFOjx9Pyk8/kZ2QgJsTTqK4dAygiDOwSwF4+PBhexxWRERckOcdd+B1ZzXS/zhA0uYtBLZtc9PHGjRoUAEmu346BSzOpkDHAG7YsIF77rmHxMTEyx5LSEjg3nvvZcuWLQXZpIiIuAC/xo8CkPz9rf2OMGKcuTU7m8zTpwEtAi3Oo0ALwPfff58BAwYQEBBw2WOBgYEMHDiQSZMmFWSTIiLiAnwfqAtA6u49t3ScefPmFUScG5L111+QmQlubriXLHnb2xe5GQVaAO7Zs4fHH3/8qo83b96cXbt2FWSTIiLiArxzF4HOOHqUrPh4g9PcmLzTv+6lSmJyt8vIKpECV6AF4OnTp/Hw8Ljq4+7u7pw9e7YgmxQRERfgHhSEZ6VKAKTt3XvTx5k7d24BJbp+Gv8nzqhAC8By5cqxb9++qz7+888/U0bjI0RE5Ap8QkOBWzsNPHr06IKKc90y/8y5+ogKQHEmBVoAtmrVitdee420tLTLHktNTWX06NG0aXPzs7tERMR1+dTKLQD33HwBeOjQoYKKc93SDxwAwKtqtdvetsjNKtDBCq+++irLly/nrrvuIiIigurVqwPw22+/MXXqVLKzsxk5cmRBNikiIi7Cu2ZNAFL37sVqsWAy33gfRY0aNQo61r9K/+MPALzuVAEozqNAC8BSpUqxbds2nn32WV5++WWsVisAJpOJFi1aMHXqVEqVKlWQTYqIiIvwvusuTN7eWBITyThyBK8qVW74GJGRkXZIdnXWrCwycnsdve6887a2LXIrCny6UsWKFfnqq6+Ij4/nwIEDWK1W7rzzToKCggq6KRERcSEmDw+8Q+4ldecuUnfvuakCcMCAAbf1UnAZx45jzcjA5OODR7lyt61dkVtVoGMALxUUFMQDDzxAWFiYij8REbkutokgP9/aeoC3i+30b7VqN3XKWsQo+tcqIiIOw7vGPQCk//7HTT2/X79+BRnnX11aAIo4ExWAIiLiMLyq5pz2zTBgNu/N+HsCiMb/iXNRASgiIg7Ds3JlMJnIvnCBrPPnb/j5s2bNskOqq7MtAaMCUJyMCkAREXEYZm9v22SKjIMHDU5zbZaMDDKOHAHA6y4VgOJcVACKiIhD8axSGYD0gzd+GnjmzJkFHeeqMg4fhuxszAEBuJcsedvaFSkIKgBFRMSheFWpCkDG4RsvACdNmlTQca4qb6KKV7VqmEym29auSEFQASgiIg7FM3ciyM30AO7fv7+g41xVeuxvgMb/iXNSASgiIg7Fq2pOD2D6oRsfA1jlJhaPvlmpe/cB4HNfyG1rU6SgqAAUERGH4lk5Zwxg1sk4LMnJN/TcsWPH2iPSZazZ2aTtyykAve+reVvaFClIKgBFRMShuAcF4VasGADph4/c0HN79eplh0SXyzh8GEtyMiZfX7yqVb0tbYoUJBWAIiLicPKuA3wzE0Fuh9Sf9wLgc889mNzcDE4jcuNUAIqIiMPxzBsHeINrAfbs2dMecS6TuvdnALxr6vSvOCcVgCIi4nC88tYC/OPADT0vMDDQHnEuk5bXA1jzvtvSnkhBUwEoIiIOx6dWLQBSfvwRa3b2dT9v2rRpdkr0N0t6OmmxsQD43KcCUJyTCsB/iI2NpVatWrYfHx8fVqxYYXQsEZFCxTskBHNAAJbERNtsW0eRvn8/ZGXhVrw47mXLGh1H5KaoAPyH6tWrs3v3bnbv3s33339PkSJFaNasmdGxREQKFZObG0Xq1QMgedu2637elClT7BXJ5uL6DUBO75+uACLOSgXgNaxatYrHHnuMIkWKGB1FRKTQKdKgAQBJW7de93M++eQTe8XBmpXFqTfe5Fzu9Yb9GjWyW1si9uZ0BeDmzZtp27YtZcuWxWQyXfH07NSpU6lUqRLe3t7Uq1eP6Ojom2pr8eLFdO3a9RYTi4jIzSjS4CEAUnfvITvp+haEjomJsVues1OnEj9vHgAl/juYol272K0tEXtzugIwOTmZ0NBQpk6desXHFy1aRGRkJKNHj+ann34iNDSUFi1acObMGds+tWrVIiQk5LKfkydP2vZJTExk27ZttGrVyu6vSURELudZvjwe5ctDVhYp1/lFvly5cnbJYklL48L8BQCUefMNij/zjE7/ilNzNzrAjWrZsiUtW7a86uOTJk1iwIAB9O3bF4Dp06ezevVqZs2axYgRIwDYvXv3v7azcuVKmjdvjre39zX3S09PJz093XY/MTHxOl6FiIhcjyINHuLCwkUkb9uGf5NH/3X/yZMn2yVH4po1ZCck4F62DIEdO9qlDZHbyekKwGvJyMhg165dvPzyy7ZtZrOZpk2bsn379hs61uLFi/nPf/7zr/u99dZbV7z2ZNeuXfHw8GDevHm88sorHD16lJCQECIiInjmmWcAGDBgAJmZmcyZMweAWbNm8fbbbxMbG0u1atV49dVX6dOnD5BzeSNfX19mzJgB5Cx1MGPGDPbs2UP58uV555136NatGwBdunShTJkyfPDBB0DOB+KCBQuIjo6mZMmSzJgxg465H2Dt27enevXqTJw4EYAJEyawevVqtmzZQkBAAJ9//jmdOnUiKyuLFi1aEBYWxhtvvAHAmDFj2Lp1K+vWrcPLy4slS5bQo0cPkpKSaNSoEc2bN2fkyJEAjBgxgn379vHll18COeMr+/bty7lz56hfvz6dO3fmxRdfBCAyMpJjx46xdOlS29/FkCFDOHHiBLVr16Z///5EREQAMGjQIBISEpiXe1pm7ty5jB49mkOHDlGjRg0iIyMZMGAAAP369bO9zwAzZ85k0qRJ7N+/nypVqjB27FjbZaR69uxJYGCgbUmJKVOm8MknnxATE0O5cuWYPHkyXbrknP7p3LkzFSpUYNKkSQC89957LF26lO3btxMcHMzs2bNp164dAG3atCEkJIQJEyYAMG7cONauXcumTZvw8/Nj/vz5PPnkk6Snp9OsWTMaNGjAmDFjAHjttdeIjo7mm2++wd3dneXLl/PUU0+RmJhIw4YNad26te1LzvDhw4mNjWXlypUAREVFMXDgQM6cOUNYWBjdu3dnyJAhAAwePJi4uDgWL14MwMKFCxk2bBjHjx8nNDSUgQMHMmjQIAAGDhxISkoKc+fOBWDOnDm8+eabHDhwgOrVq/PSSy/Z3uc+ffrg4eHBzNzxUtOnT2fKlCns27ePihUrMn78eNuivd27dyc4ONg2gP/DDz/ks88+Y+fOnZQpU4YpU6bwxBNPANCxY0eqVq3Ku+++C8DEiRNZuXIlW7duJSgoiE8//ZQOHTpgsVho1aoVtWvXZty4cQC8/vrrbNy4kQ0bNuDj48OiRYvo2rUrqampNGnShMaNGzNq1CgARo4cSUxMDF999RVms5kVK1YQHh5OfHw8DRo0oH379gwfPhyAoUOHcvDgQaKiogBYtmwZERERxMXFUbduXXr37s0LL7wAQEREBOfOnWPBgpzeJH1GXPszotyRI/QE4nfs4D+5/4+u9RkRGxvLunXrCvwzIvL0GUoBX6Zn8F3HjvqM0GeE4Z8RmZmZ3AqT1Wq13tIRDGQymYiKiqJDhw4AnDx5knLlyrFt2zbq169v22/48OFs2rSJHTt2XNdxExISuOuuuzh+/Dienp7X3PdKPYDly5cnISGBgICAG39RIiJik/b77xxu1x5zQAB37fjhX0+7tmvXjlWrVhVshl9/5XCnJ8DDgzu/24B78eIFenyRm5GYmEhgYOBN1xsu1QNYUAIDAzl9+vR17evl5YWXl5edE4mIFE6eFSoAYElMJPvCBdyDgq65f+fOnW23sy9eBMDN3/+WMsQvWQJAQLOmKv7EZTjdJJBrKV68OG5ubpcVb6dPn6Z06dIGpRIRkZtl9vbGvUwZADKOHPnX/SvkFoxWi4XD7TtwqFVrLBkZN92+1WolKXfdv8D27W/6OCKOxqUKQE9PT+rUqcP69ett2ywWC+vXr893SlhERJyHZ6WKAGQcOfqv++aNs7OkpJB58iRZZ89etXA8++FHHH6iM1nnzl31eGm//krWmTOYfHzwffDBGw8v4qCcrgBMSkqyXakD4PDhw+zevZtjx44BOYODZ86cyaeffsr+/ft59tlnSU5Ots0KFhER5+JZMbcAPHrkup9jvWRsdsahQ1fcJ2HFCtJ++YX4efOvepyk7zYCUOShhzBruI+4EKcbA7hz504effTvpQAiIyMBCA8PZ86cOXTt2pWzZ88yatQoTp06Ra1atVizZg2lSpUyKrKIiNwCz4qVAMg4+u89gO+99x6QvwBMv0oBmJ2cs7h0/OLFFH9mIFaLhczjx/G6807bPkkbNwLg/2jjGw8u4sCcrgewcePGWK3Wy37ylkmAnCnUR48eJT09nR07dlAv93qSIiLifG7kFHDe0jCWtEt6AA9eXgBarVYsSUkAZP/1F/GLFnPkySc51LYdKT/lXE0k8/QZ0vbtA3TZN3E9TlcAiohI4XJpD2Dm6dMcbPE4p9+eeMV989Z8tWZc0gN4+AoFYFoaZGfb7p8eN470Pw4AkPz9FgCSNm0EwLtmTdxLlLjl1yHiSFQAioiIQ/O8oxyYzVhTUjj74YdkHD3KheXLudIytsHBwUBugZcr49BhrBZLvv3yev8wmcDDI99jqbljzJM2bQbAr7F6/8T1qAAUERGHZvL0xOOOOwBIiFoBgCUhgewrzN6dPXt2zuPpfy/9Yk1LIysuLt9+2bkFoNnPj+IDnsazWlXKTHgLgNQ9P2NJTyflhx8A8HtEBaC4HhWAIiLi8PJmAnNJT176Fcb25V1SzZqelm/7PyeCWJJyJoCYixShxAsvUPXLLwls2xaTry+W5GQSli/HkpyMW1AQ3vfUKMiXIuIQVACKiIjDsxWAl0g/eCDf/dQ9e7Dkzuy1XDILOGffg/nuW5LzegCL2LaZ3Nzwue8+AP76OOf6tEUeegiTWb8qxfXoX7WIiDg8z0qVbLeLNHoEgIwDfxd1WfHxHHmqF/WOHwfAmp7/6h8Zhw7nu583BtCtiF++7T61auUcL/eUcZGHH7718CIOSAWgiIg4PJ/Q0Jw/69YhoGVLIH+vXsaRI5CZSdX0dKwWyxVOAefvAbx0DOCV2slT5KGHCiS/iKNxuoWgRUSk8PG5L4RKS5fiWf4OMo7l9PJdWgBm5V4D/v/OnadbWprtFLDHHXeQ+eefV+gBzB0D+M8CsNbfBaDXXXfhUapkwb8YEQegHkAREXEKPiH34hYYiFeVykDOAs5Z8fEAZMadsu1nSUvDmrsQtHeNu3P2PX+eo+F9SM6d2WtJunwMIIB7sWJ4VKwA6PSvuDYVgCIi4lTMRYrgXrYM8Pd1frNO5YzZG1yiONbUVNtC0G5Fi1Ksfz9wdydlxw6O9e1H1tmztkkgbv/oAQQo2rkzbkFBFO3Y4Ta8GhFjqAAUERGn41W1GgDpuRNBMk/lnALempyMJS0NS+5C0CYvb0oNG0a1dWtxCw4Gq5XMkydts4XNRS4vAIsPGMBd27fluyawiKtRASgiIk7Hq2pV4O+lYDJzewB3pqRiSU2zzQI2eXkC4FGmDB5lcnoNs86fv+okEJHCQgWgiIg4Ha9qOQVgRu5i0Fm5YwB9zWasaam2WcBmLy/bc9yKBQGQfT7+kkkg+ccAihQWKgBFRMTpeOb1AP7+O9bMTLLOngXgnbJlsaT+PQvY5OVte457UG4BGH/+73UA1QMohZQKQBERcTred90FJhNZZ8+S9ttvYLUC8N8TJ7CkpV52ChjALagYAFnn4y+ZBawCUAonFYAiIuJ0zEWK4Fk5ZzmYixs22LZnWq1Y09L+PgXs/XcPoFuxnAIw+/x5spNVAErhpgJQRESckve99wKQtP7vArB+EV8sqal/nwL2/HsMoHvuGMCs+PN/jwG8wixgkcJABaCIiDgl73vuAXLGAea538c3pwcwdyFos/elk0DyegAvOQVcRJNApHBSASgiIk4prwC81NS//spdBiZvEsglBWDuJJCsM2dsj7tpFrAUUioARUTEKXnfUyP/Bvecy9tb0lKvPAs4twcw77rBoB5AKbxUAIqIiFNy8/e3XbcXwPOOO3gmOBjrJT2A5ktnAecWgHlM3t6YPDxuT1gRB6MCUEREnNalp4E9K1dmb1pa7jIwuT2Al8wCNvv5wSUFn2YAS2GmAlBERJyWT+5MYADPSpXYmpyM9dKFoC+ZBWwymWyLQQO46fSvFGIqAEVExGnl9QCaPDzwKFsWNxNY0i45BXzJLGDIfxpYPYBSmLkbHUBERORm+dSujXfNmnjffTdmX18+LHfHPyaB5C8A3YsFkZ57WwWgFGYqAEVExGmZfXyovHgRAIlffcXwkyf5KDkZMjOBywtAt6J/nwJWASiFmU4Bi4iISzB5+5BssWBJSLBtM/+zALzkFLDWAJTCTAWgiIi4BLOPN/f7+pB14YJt22U9gMUu6QHUZeCkEFMBKCIiLsHk7U2jIn5YLuT2AHp4YHJzy7ePuyaBiAAqAEVExEWYfXyYfPYs1tzxf2ZPz8v2cQtSASgCKgBFRMRFmC9Z9BnyLwKdx/3SU8AaAyiFmApAERFxCSYfH/pdcorX5HWFHsB8k0DUAyiFlwpAERFxCWZvb45kZPx93+vyHsB8C0HrSiBSiKkAFBERl2Dy8WFDUtLf9/8xAxjALTAQzDm/+jQLWAozFYAiIuISTB4eYPr7/j/XAAQwmc24Bef0AroFBtyuaCIOR1cCERERl2AymZhy512QkpJz/woFIECp4S+R9ssveFWvfjvjiTgU9QCKiIjLGH3ihO321QrAwLZtKDXiJUxm/QqUwkv/+kVExGWct2Tbbpu9r1wAiogKQBERcSGhwcG22yZPFYAiV6MCUEREXEa7ylVst03qARS5KhWAV/Duu+9y7733EhISwueff250HBERuU7j9u613b7SLGARyaFZwP+wd+9e5s+fz65du7BarTz66KO0adOGokWLGh1NRET+jdvf/RqmKywELSI51AP4D/v376d+/fp4e3vj4+NDaGgoa9asMTqWiIhch/7317HdvtKl4EQkh9MVgJs3b6Zt27aULVsWk8nEihUrLttn6tSpVKpUCW9vb+rVq0d0dPR1Hz8kJISNGzdy4cIF4uPj2bhxIycuWVZAREQc19nMSy4F560eQJGrcbpTwMnJyYSGhtKvXz86dep02eOLFi0iMjKS6dOnU69ePd5//31atGhBbGwsJUuWBKBWrVpkZWVd9ty1a9dyzz338MILL9CkSRMCAwN58MEHcXNzs/vrEhGRW/fFH3/Q1JTTt6FZwCJX53QFYMuWLWnZsuVVH580aRIDBgygb9++AEyfPp3Vq1cza9YsRowYAcDu3buv2cbAgQMZOHAgAE8//TR33nnnVfdNT08nPT3ddj8xMfF6X4qIiBQwk9kNrNac25oFLHJVTlcAXktGRga7du3i5Zdftm0zm800bdqU7du3X/dxzpw5Q8mSJYmNjSU6Oprp06dfdd+33nqLsWPHXra9a9eueHh4MG/ePF555RWOHj1KSEgIERERPPPMMwAMGDCAzMxM5syZA8CsWbN4++23iY2NpVq1arz66qv06dMHgF69euHr68uMGTMAmDZtGjNmzGDPnj2UL1+ed955h27dugHQpUsXypQpwwcffADA5MmTWbBgAdHR0ZQsWZIZM2bQsWNHANq3b0/16tWZOHEiABMmTGD16tVs2bKFgIAAPv/8czp16kRWVhYtWrQgLCyMN954A4AxY8awdetW1q1bh5eXF0uWLKFHjx4kJSXRqFEjmjdvzsiRIwEYMWIE+/bt48svvwRg1apV9O3bl3PnzlG/fn06d+7Miy++CEBkZCTHjh1j6dKlACxevJghQ4Zw4sQJateuTf/+/YmIiABg0KBBJCQkMG/ePADmzp3L6NGjOXToEDVq1CAyMpIBAwYA0K9fP9v7DDBz5kwmTZrE/v37qVKlCmPHjqVXr14A9OzZk8DAQKZNmwbAlClT+OSTT4iJiaFcuXJMnjyZLl26ANC5c2cqVKjApEmTAHjvvfdYunQp27dvJzg4mNmzZ9OuXTsA2rRpQ0hICBMmTABg3LhxrF27lk2bNuHn58f8+fN58sknSU9Pp1mzZjRo0IAxY8YA8NprrxEdHc0333yDu7s7y5cv56mnniIxMZGGDRvSunVr25ec4cOHExsby8qVKwGIiopi4MCBnDlzhrCwMLp3786QIUMAGDx4MHFxcSxevBiAhQsXMmzYMI4fP05oaCgDBw5k0KBBQM6Xo5SUFObOnQvAnDlzePPNNzlw4ADVq1fnpZdesr3Pffr0wcPDg5kzZwI5X8amTJnCvn37qFixIuPHj6dnz54AdO/eneDgYKZMmQLAhx9+yGeffcbOnTspU6YMU6ZM4YknngCgY8eOVK1alXfffReAiRMnsnLlSrZu3UpQUBCffvopHTp0wGKx0KpVK2rXrs24ceMAeP3119m4cSMbNmzAx8eHRYsW0bVrV1JTU2nSpAmNGzdm1KhRAIwcOZKYmBi++uorzGYzK1asIDw8nPj4eBo0aED79u0ZPnw4AEOHDuXgwYNERUUBsGzZMiIiIoiLi6Nu3br07t2bF154AYCIiAjOnTvHggULAPQZUcCfEb3vrAa//5Hz/3bGDMKKFdNnhD4jXPIzIjMzk1thslpzvyo5IZPJRFRUFB06dADg5MmTlCtXjm3btlG/fn3bfsOHD2fTpk3s2LHjuo5bv359EhISKFKkCNOnT6dOnTpX3fdKPYDly5cnISGBgABdaFxE5Hbq16gxw06fBqDsO+8Q2LaNwYlE7CMxMZHAwMCbrjdcqgewoNxIb6GXlxdeWmtKRMQhxCUm2G7rFLDI1TndLOBrKV68OG5ubpzO/faX5/Tp05QuXdqgVCIicrvce8mVQLQQtMjVuVQB6OnpSZ06dVi/fr1tm8ViYf369flOCYuIiGvq16a17bYWgha5Oqc7BZyUlMSBAwds9w8fPszu3bspVqwYFSpUIDIykvDwcOrWrUtYWBjvv/8+ycnJtlnBIiLiuobOnMl7ubfNWgha5KqcrgDcuXMnjz76qO1+ZGQkAOHh4cyZM4euXbty9uxZRo0axalTp6hVqxZr1qyhVKlSRkUWEZHbxXzJpeC0ELTIVTn1LGBHdKuzckRE5OYtnzyZGjM+BqDKV1/hVaWywYlE7ONW6w2XGgMoIiKFW6rl7z4Ns2YBi1yVCkAREXEZC75abbtt0ixgkatSASgiIq7jkmu3axawyNWpABQREZcxK+/SnSaTZgGLXIPTzQIWERG5mglTpjDi6f6YixTB5OFhdBwRh6UCUEREXMaBAwcoOWmS0TFEHJ5OAYuIiMuoXr260RFEnIIKQBERcRkvvfSS0RFEnIIKQBERcRn9+vUzOoKIU1ABKCIiIlLIqAAUERGX0adPH6MjiDgFFYAiIuIyPLT0i8h1UQEoIiIuY+bMmUZHEHEKKgBFREREChkVgCIi4jKm510KTkSuSQWgiIi4jClTphgdQcQpqAAUERGXsW/fPqMjiDgFFYAiIuIyKlasaHQEEaegAlBERFzG+PHjjY4g4hRUAIqIiMvo2bOn0RFEnIK70QFcjdVqBSAxMdHgJCIihU9mZqY+f6VQyPt3nld33CgVgAXs4sWLAJQvX97gJCIihVNgYKDREURum4sXL97Uv3mT9WZLR7kii8XCyZMn8ff3x2Qy2aWNxMREypcvz/HjxwkICLBLG4WB3sdbp/ewYOh9LBh6HwuG3sdbdzveQ6vVysWLFylbtixm842P6FMPYAEzm83ccccdt6WtgIAA/ecsAHofb53ew4Kh97Fg6H0sGHofb52938Nb6e3WJBARERGRQkYFoIiIiEghowLQCXl5eTF69Gi8vLyMjuLU9D7eOr2HBUPvY8HQ+1gw9D7eOmd4DzUJRERERKSQUQ+giIiISCGjAlBERESkkFEBKCIiIlLIqAB0cr///jvt27enePHiBAQE8PDDD/Pdd98ZHcsprV69mnr16uHj40NQUBAdOnQwOpLTSk9Pp1atWphMJnbv3m10HKdx5MgR+vfvT+XKlfHx8aFq1aqMHj2ajIwMo6M5vKlTp1KpUiW8vb2pV68e0dHRRkdyKm+99RYPPPAA/v7+lCxZkg4dOhAbG2t0LKc3YcIETCYT//3vf42OchkVgE6uTZs2ZGVlsWHDBnbt2kVoaCht2rTh1KlTRkdzKsuWLaNXr1707duXPXv2sHXrVnr06GF0LKc1fPhwypYta3QMp/Pbb79hsViYMWMGv/zyC5MnT2b69Om88sorRkdzaIsWLSIyMpLRo0fz008/ERoaSosWLThz5ozR0ZzGpk2beO655/jhhx9Yt24dmZmZNG/enOTkZKOjOa0ff/yRGTNmULNmTaOjXJlVnNbZs2etgHXz5s22bYmJiVbAum7dOgOTOZfMzExruXLlrP/3f/9ndBSX8NVXX1nvvvtu6y+//GIFrDExMUZHcmoTJ060Vq5c2egYDi0sLMz63HPP2e5nZ2dby5Yta33rrbcMTOXczpw5YwWsmzZtMjqKU7p48aL1zjvvtK5bt87aqFEj6+DBg42OdBn1ADqx4OBgqlevzmeffUZycjJZWVnMmDGDkiVLUqdOHaPjOY2ffvqJEydOYDabqV27NmXKlKFly5bs27fP6GhO5/Tp0wwYMIC5c+fi6+trdByXkJCQQLFixYyO4bAyMjLYtWsXTZs2tW0zm800bdqU7du3G5jMuSUkJADo395Neu6552jdunW+f5eORgWgEzOZTHz77bfExMTg7++Pt7c3kyZNYs2aNQQFBRkdz2kcOnQIgDFjxvDqq6/y5ZdfEhQUROPGjTl//rzB6ZyH1WqlT58+PPPMM9StW9foOC7hwIEDfPTRRwwcONDoKA7rr7/+Ijs7m1KlSuXbXqpUKQ2FuUkWi4X//ve/NGjQgJCQEKPjOJ2FCxfy008/8dZbbxkd5ZpUADqgESNGYDKZrvnz22+/YbVaee655yhZsiRbtmwhOjqaDh060LZtW+Li4ox+GYa73vfRYrEAMHLkSJ544gnq1KnD7NmzMZlMLFmyxOBXYbzrfR8/+ugjLl68yMsvv2x0ZIdzve/hpU6cOMHjjz/Ok08+yYABAwxKLoXRc889x759+1i4cKHRUZzO8ePHGTx4MPPmzcPb29voONekK4E4oLNnz3Lu3Llr7lOlShW2bNlC8+bNiY+PJyAgwPbYnXfeSf/+/RkxYoS9ozq0630ft27dSpMmTdiyZQsPP/yw7bF69erRtGlTxo0bZ++oDu1638cuXbrwxRdfYDKZbNuzs7Nxc3OjZ8+efPrpp/aO6rCu9z309PQE4OTJkzRu3JgHH3yQOXPmYDbru/rVZGRk4Ovry9KlS/PN3A8PD+fChQusXLnSuHBOKCIigpUrV7J582YqV65sdByns2LFCjp27Iibm5ttW3Z2NiaTCbPZTHp6er7HjORudAC5XIkSJShRosS/7peSkgJw2S8Hs9ls69UqzK73faxTpw5eXl7ExsbaCsDMzEyOHDlCxYoV7R3T4V3v+/jhhx/y5ptv2u6fPHmSFi1asGjRIurVq2fPiA7vet9DyOn5e/TRR2090Sr+rs3T05M6deqwfv16WwFosVhYv349ERERxoZzIlarleeff56oqCg2btyo4u8mPfbYY+zduzfftr59+3L33Xfz0ksvOUzxByoAnVr9+vUJCgoiPDycUaNG4ePjw8yZMzl8+DCtW7c2Op7TCAgI4JlnnmH06NGUL1+eihUr8s477wDw5JNPGpzOeVSoUCHffT8/PwCqVq3KHXfcYUQkp3PixAkaN25MxYoVeffddzl79qztsdKlSxuYzLFFRkYSHh5O3bp1CQsL4/333yc5OZm+ffsaHc1pPPfcc8yfP5+VK1fi7+9vGz8ZGBiIj4+Pwemch7+//2XjJosUKUJwcLDDjadUAejEihcvzpo1axg5ciRNmjQhMzOTe++9l5UrVxIaGmp0PKfyzjvv4O7uTq9evUhNTaVevXps2LBBk2nktlq3bh0HDhzgwIEDlxXNGq1zdV27duXs2bOMGjWKU6dOUatWLdasWXPZxBC5uv/9738ANG7cON/22bNn06dPn9sfSOxOYwBFREREChkNLhEREREpZFQAioiIiBQyKgBFREREChkVgCIiIiKFjApAERERkUJGBaCIiIhIIaMCUERERKSQUQEoIiIiUsioABQRuQmVKlXi/fffNzrGNX3yySc0b978hp7z119/UbJkSf788087pRIRR6ACUEQKlbZt2/L4449f8bEtW7ZgMpn4+eefb/i4JpOJFStW3GK6gpOWlsZrr73G6NGjAXj++eepUaPGFfc9duwYbm5urFq1iuLFi9O7d2/b80TENakAFJFCpX///qxbt+6KPVyzZ8+mbt261KxZ04BkBWvp0qUEBATQoEEDIOd1//bbb2zbtu2yfefMmUPJkiVp1aoVAH379mXevHmcP3/+tmYWkdtHBaCIFCpt2rShRIkSzJkzJ9/2pKQklixZQv/+/QFYtmwZ9957L15eXlSqVIn33nvvqsesVKkSAB07dsRkMtnuHzx4kPbt21OqVCn8/Px44IEH+Pbbb/M9Ny4ujtatW+Pj40PlypWZP3/+ZaeXL1y4wNNPP02JEiUICAigSZMm7Nmz55qvc+HChbRt29Z2v1atWtx///3MmjUr335Wq5U5c+YQHh6Ou7s7APfeey9ly5YlKirqmm2IiPNSASgihYq7uzu9e/dmzpw5WK1W2/YlS5aQnZ1N9+7d2bVrF126dKFbt27s3buXMWPG8Nprr11WNOb58ccfgZwexLi4ONv9pKQkWrVqxfr164mJieHxxx+nbdu2HDt2zPbc3r17c/LkSTZu3MiyZcv4+OOPOXPmTL7jP/nkk5w5c4avv/6aXbt2cf/99/PYY49ds4fu+++/p27duvm29e/fn8WLF5OcnGzbtnHjRg4fPky/fv3y7RsWFsaWLVuu8U6KiFOziogUMvv377cC1u+++862rWHDhtannnrKarVarT169LA2a9Ys33OGDRtmveeee2z3K1asaJ08ebLtPmCNior617bvvfde60cffZQvx48//mh7/I8//rACtmNv2bLFGhAQYE1LS8t3nKpVq1pnzJhxxTbi4+OtgHXz5s2Xbff29rbOnj3btq1Xr17Whx9++LJjDBkyxNq4ceN/fT0i4pzUAygihc7dd9/NQw89ZDsdeuDAAbZs2WI7/bt//37b2Lk8DRo04I8//iA7O/u620lKSmLo0KHUqFGDokWL4ufnx/79+209gLGxsbi7u3P//ffbnlOtWjWCgoJs9/fs2UNSUhLBwcH4+fnZfg4fPszBgwev2G5qaioA3t7e+bYXLVqUTp062V53YmIiy5Yts73uS/n4+JCSknLdr1VEnIu70QFERIzQv39/nn/+eaZOncrs2bOpWrUqjRo1KtA2hg4dyrp163j33XepVq0aPj4+dO7cmYyMjOs+RlJSEmXKlGHjxv9v535CodvjOI5/jj9PyShCpIZRjP8Ls8GUKZmalUJhWA0yS5uxkbJgKbJQlpNZSBaKxZT/d2FGiVCy0MQoxUJkYyXP3U3XHc/TlYXHPe9Xzeb3/f2+53dm9el3TuevpFp2dva7a3Jzc2UYhh4fH5Nqg4ODam1tVSwW0+7urlJTU9XV1ZU07+HhQfn5+f95nwC+F04AAZhSd3e3UlJStLi4qFAopIGBARmGIUmqqqpSJBJ5Mz8Sichutys1NfXdfunp6Umng5FIRD6fTx0dHaqrq1NhYaHi8XiiXlFRoZeXFx0fHyfGYrHYm+DmcDh0d3entLQ0lZWVvfnl5eW9u5cfP36ourpa5+fnSbWWlhaVlpYqGAwqGAzK6/UqMzMzad7Z2Znq6+vf7Q/g+yMAAjAli8Winp4ejY6O6vb2Vj6fL1ELBALa3t7W5OSkLi4utLCwoLm5OY2MjPyyn81m0/b2tu7u7hIBrry8XCsrKzo5OdHp6an6+vr0+vqaWFNZWSm32y2/36+DgwMdHx/L7/crIyMjEUbdbreamprU3t6ujY0NxeNxRaNRjY2N6fDw8Jf78Xg82tvbSxo3DEMDAwOan5/X/v7+u49/n5+fdXR09OGPSAP4PgiAAExrcHBQj4+P8ng8KioqSow7HA4tLy9raWlJtbW1Gh8f18TExJuQ+G/T09Pa3NyU1WpNnJzNzMwoJydHTqdTbW1t8ng8b973k6RQKKSCggK5XC51dHRoaGhIWVlZiff3DMNQOByWy+VSf3+/7Ha7vF6vrq+vVVBQ8Nt7C4fDenp6Sqr5fD49PT2ppqZGDQ0NSfXV1VUVFxerubn5t/8fgO/L+PnzH99BAAB8qZubG1mtVm1tbam1tfVTvbq6uuRwODQ6OvqhdY2NjRoeHlZfX9+nrg/gz8UJIAB8oZ2dHa2trenq6krRaFRer1c2m00ul+vTvaempmSxWD605v7+Xp2dnert7f309QH8uTgBBIAvtL6+rkAgoMvLS2VlZcnpdGp2dlYlJSVfvTUA/2MEQAAAAJPhETAAAIDJEAABAABMhgAIAABgMgRAAAAAkyEAAgAAmAwBEAAAwGQIgAAAACZDAAQAADAZAiAAAIDJEAABAABMhgAIAABgMgRAAAAAkyEAAgAAmAwBEAAAwGT+BjJ1Sbdy7Et3AAAAAElFTkSuQmCC' width=640.0/>\n",
+       "            </div>\n",
+       "        "
+      ],
+      "text/plain": [
+       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# load the file (dataframe)\n",
+    "file = r\"\\\\FILESERVER\\public\\Datentransfer\\Asonitis, Alexandros\\diode\\DIODE_Q22.txt\"\n",
+    "df = pd.read_csv(file,sep=\" \",skiprows=12)\n",
+    "\n",
+    "display(df)\n",
+    "\n",
+    "plot_results(df[\"VS/V\"],df[\"ABSNOR/A/CM^2\"])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "866ce096-e470-47e3-bc35-9b31d533a0f9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa1e620e-087e-45ba-bd80-052a3116c33b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/pn_Diode/test_interface.ipynb b/hp4155/pn_Diode/test_interface.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..d44f64e70c3f616ce061fb637bc10bfba072a87b
--- /dev/null
+++ b/hp4155/pn_Diode/test_interface.ipynb
@@ -0,0 +1,134 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "33da914c-b84e-47ad-b53a-a7e0f3762793",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.insert(0, './lib')\n",
+    "sys.path.insert(0, '..') #append parent directory\n",
+    "\n",
+    "from interface import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fd3b6bc2-b9f2-44a0-a511-68e210200d04",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "79d9fa27fc4f4ff29fca140d17248941",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(VBox(children=(Label(value='Sample Information', layout=Layout(height='auto', width='auto'), st…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "63db6f40ae0049478a8793320dd11e97",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "GridspecLayout(children=(Label(value='First Measurement', layout=Layout(grid_area='widget001', height='auto', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a9ed6c51148147ddabcca6fee7198212",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "GridspecLayout(children=(Label(value='Second Measurement', layout=Layout(grid_area='widget001', height='auto',…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a79d38fd3dab46e8b8b2278ee6e4896d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Button(description='Start Measurement', style=ButtonStyle())"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "5d149cf248cd4805bfc3372ceb4d058a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sample = sample_information_interface()\n",
+    "measurement_1 = parameters_interface(0,0.02,10,\"First Measurement\")\n",
+    "measurement_2 = parameters_interface(0,0.5,100,\"Second Measurement\")\n",
+    "button = widgets.Button(description ='Start Measurement')\n",
+    "output = widgets.Output()\n",
+    "\n",
+    "display(button,output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "690e0b71-7d0e-4651-baf8-a1330c4a19fa",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}