# HG changeset patch
# User bastiena
# Date 1333377056 -7200
# Node ID 4b78f179e7ce9cf280c8ff0c02ffdeb47eaf6dd5
# Parent 10d5199d9874b5d757fabd71c23842d52549ceac
Middleware :
segmentation of Middleware between 4 modules :
Communication
Debug
Tracking
MainModule
I chose to integer the events in the mainModule, so I can use them to send data to Debug and Communication.
Soon DLLs will be copied to a main root folder "lib".
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Communication/Communication.csproj
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Communication/Communication.csproj Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,62 @@
+
+
+
+ Debug
+ AnyCPU
+ 8.0.30703
+ 2.0
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}
+ Library
+ Properties
+ Communication
+ Communication
+ v4.0
+ 512
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+ False
+ ..\lib\Microsoft.Kinect.dll
+
+
+
+
+
+
+
+
+
+
+ ..\lib\TuioServer.dll
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Communication/Properties/AssemblyInfo.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Communication/Properties/AssemblyInfo.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Communication")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Communication")]
+[assembly: AssemblyCopyright("Copyright © 2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3d4ee9d9-0965-40e2-ac20-2e1e4a2c698e")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Communication/Server.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Communication/Server.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,242 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Communication
+ * Classe : Server
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Reçoit des notifications du module sous-module Tracking.
+ * Traduit les notifications sous forme de messages OSC et les envoie au Front Atelier.
+ * Forme des messages :
+ * - Notification de main dans le champ de recherche : Point3D indiquant la position de la main dans l'espace.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using Tuio;
+using System.Windows;
+using Microsoft.Kinect;
+using System.Windows.Media.Media3D;
+using System.Timers;
+using System.Resources;
+using System.Reflection;
+
+namespace Trakers.Communication
+{
+ public class Server
+ {
+ //Serveur TUIO, provenant de la DLL TuioServer créé par Bespoke.
+ private TuioServer server;
+
+ //Permet de savoir si un curseur pour la main gauche/droite a été créé.
+ private bool leftHandCursorCreated;
+ private bool rightHandCursorCreated;
+ private bool messageCreated;
+ private bool gestureLocked, modLocked;
+ //Intervalle minimum entre les gestures.
+ private int timerElapsing;
+ //Timer.
+ private System.Timers.Timer _timer;
+ //Dernier code envoyé.
+ private String lastCode;
+
+ /*
+ * Constructeur : On initialise le serveur avec une adresse et un port, au début les curseurs
+ * ne sont pas créés et on indique au ThreadPool une fonction de callback de manière à vérifier
+ * s'il reçoit des notifications.
+ */
+ public Server(String host, int port, int _timerElapsing)
+ {
+ //Au départ, aucune main n'est dans le champ de recherche et aucune gesture n'est détectée.
+ leftHandCursorCreated = false;
+ rightHandCursorCreated = false;
+ messageCreated = false;
+ gestureLocked = false;
+ modLocked = false;
+ lastCode = "";
+
+ timerElapsing = _timerElapsing;
+
+ //On démarre le serveur TUIO.
+ server = new TuioServer(host, port);
+ //On initialise le threadPool (appelé toutes les N ms).
+ ThreadPool.QueueUserWorkItem(ThreadPoolCallback);
+
+ //On instancie le timer à N ms.
+ _timer = new System.Timers.Timer(timerElapsing);
+ //Dès que le timer est expiré, on appelle _timer_Elapsed.
+ _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
+ }
+
+ /*
+ * Getter du serveur.
+ */
+ public TuioServer getServer()
+ {
+ return server;
+ }
+
+ /*
+ * Méthode appelée à l'expiration du timer pour les gestures et modes.
+ */
+ public void _timer_Elapsed(object sender, ElapsedEventArgs e)
+ {
+ //On débloque la détection de gesture.
+ gestureLocked = false;
+ //On débloque la notification de nouveau mode.
+ modLocked = false;
+ //On arrête le timer.
+ _timer.Stop();
+ }
+
+ /*
+ * Méthode appelée lors d'une notification de type : main gauche entrée dans le champ.
+ */
+ public void LeftHandTracked(Point3D pt)
+ {
+ //Si le curseur de la main gauche n'est pas créé, alors on le crée.
+ if (!leftHandCursorCreated)
+ {
+ server.AddTuioCursor(0, pt);
+ leftHandCursorCreated = true;
+ }
+ //S'il existe, on le met simplement à jour.
+ else
+ server.UpdateTuioCursor(0, pt);
+ }
+
+ /*
+ * Méthode appelée lors d'une notification de type : main droite entrée dans le champ.
+ */
+ public void RightHandTracked(Point3D pt)
+ {
+ //Si le curseur de la main droite n'est pas créé, alors on le crée.
+ if (!rightHandCursorCreated)
+ {
+ server.AddTuioCursor(1, pt);
+ rightHandCursorCreated = true;
+ }
+ //S'il existe, on le met simplement à jour.
+ else
+ server.UpdateTuioCursor(1, pt);
+ }
+
+ /*
+ * Méthode appelée lors d'une notification de type : main gauche sortie du champ.
+ */
+ public void LeftHandQuit()
+ {
+ //Si le curseur de la main gauche existe, alors on le supprime.
+ if (leftHandCursorCreated)
+ {
+ server.DeleteTuioCursor(0);
+ leftHandCursorCreated = false;
+ }
+ }
+
+ /*
+ * Méthode appelée lors d'une notification de type : main droite sortie du champ.
+ */
+ public void RightHandQuit()
+ {
+ //Si le curseur de la main droite existe, alors on le supprime.
+ if (rightHandCursorCreated)
+ {
+ server.DeleteTuioCursor(1);
+ rightHandCursorCreated = false;
+ }
+ }
+
+ /*
+ * Méthode appelée lorsqu'une gesture a été détectée et que l'événement approprié a été lancé.
+ */
+ public void GesturePerformed(String code)
+ {
+ //Si le code vient d'être envoyé, on passe.
+ if (lastCode.Equals(code))
+ return;
+ lastCode = code;
+ //Si une gesture a été effectuée, on bloque un certain temps.
+ if (!gestureLocked)
+ {
+ gestureLocked = true;
+
+ //On crée un message contenant le code à envoyer.
+ if (!messageCreated)
+ {
+ messageCreated = true;
+ server.AddTuioString(2, code);
+ //On démarre le timer.
+ _timer.Start();
+ }
+ }
+ }
+
+ /*
+ * Méthode appelée lorsqu'on doit entrer dans un autre mode.
+ */
+ public void ModeNotification(String code)
+ {
+ //Si le code vient d'être envoyé, on passe.
+ if (lastCode.Equals(code))
+ return;
+ lastCode = code;
+ //Si on a été notifié.
+ if (!modLocked)
+ {
+ modLocked = true;
+
+ //On crée un message contenant le code à envoyer.
+ if (!messageCreated)
+ {
+ messageCreated = true;
+ server.AddTuioString(2, code);
+ //On démarre le timer.
+ _timer.Start();
+ }
+ }
+ }
+
+ /*
+ * Méthode de callback vérifiant toutes les 25 ms les nouvelles notifications.
+ * Il est à noter que si le temps de rafraîchissement des trop rapide, les messages n'ont pas
+ * le temps d'être envoyés.
+ */
+ private void ThreadPoolCallback(Object threadContext)
+ {
+ while (true)
+ {
+ //On initialise le message OSC.
+ server.InitFrame();
+ //On l'envoie au client (au host et au port spécifiés dans le constructeur).
+ server.CommitFrame();
+ //On attend 25 ms.
+ Thread.Sleep(25);
+
+ //Si une gesture a été effectuée et que le délai d'attente est expiré.
+ if (messageCreated && !gestureLocked && !modLocked)
+ {
+ //On débloque la détection de gesture et on supprime l'objet envoyant les messages OSC de gesture.
+ messageCreated = false;
+ server.DeleteTuioString(2);
+ }
+ }
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/App.config
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/App.config Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,110 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1
+
+
+
+
+ 1
+
+
+
+
+
+
+ 1.5
+
+
+ 1
+
+
+ 3.2
+
+
+ 1.8
+
+
+ 127.0.0.1
+
+
+ 80
+
+
+ 1000
+
+
+ 25
+
+
+ 10
+
+
+ 10
+
+
+ 0.01
+
+
+
+
+ 1.5
+
+
+ 1
+
+
+ 3.2
+
+
+ 1.8
+
+
+ 127.0.0.1
+
+
+ 80
+
+
+ 1000
+
+
+ 25
+
+
+ 10
+
+
+ 10
+
+
+ 0.01
+
+
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Debug.csproj
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Debug.csproj Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,154 @@
+
+
+
+ Debug
+ AnyCPU
+ 8.0.30703
+ 2.0
+ {EC766553-473F-4865-84E9-88F79D5F12A9}
+ Library
+ Properties
+ Trakers.Debug
+ Debug
+ v4.0
+ 512
+ publish\
+ true
+ Disk
+ false
+ Foreground
+ 7
+ Days
+ false
+ false
+ true
+ 0
+ 1.0.0.%2a
+ false
+ false
+ true
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+
+
+
+ True
+
+
+ ..\lib\Coding4Fun.Kinect.Wpf.dll
+
+
+ False
+ ..\lib\Microsoft.Kinect.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ DebugParameters.xaml
+
+
+ DebugWindow.xaml
+
+
+
+ Resources.resx
+ True
+ PreserveNewest
+ True
+
+
+ True
+ True
+ Settings.settings
+
+
+
+
+
+ MSBuild:Compile
+ Designer
+
+
+
+
+ MSBuild:Compile
+ Designer
+
+
+
+
+
+ SettingsSingleFileGenerator
+ Settings.Designer.cs
+
+
+
+
+ ResXFileCodeGenerator
+ Resources.Designer.cs
+ PreserveNewest
+
+
+
+
+ False
+ Microsoft .NET Framework 4 %28x86 and x64%29
+ true
+
+
+ False
+ .NET Framework 3.5 SP1 Client Profile
+ false
+
+
+ False
+ .NET Framework 3.5 SP1
+ false
+
+
+ False
+ Windows Installer 3.1
+ true
+
+
+
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Debug.csproj.user
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Debug.csproj.user Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,13 @@
+
+
+
+ publish\
+
+
+
+
+
+ en-US
+ false
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/DebugParameters.xaml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/DebugParameters.xaml Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,133 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/DebugParameters.xaml.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/DebugParameters.xaml.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,132 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Debug
+ * Classe : DebugParameters
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Code source attaché à la fenêtre de paramétrage du Middleware.
+ * Celui-ci permet de charger/sauvegarder les paramètres stockés dans KinectMain.
+ */
+
+using System;
+using System.Reflection;
+using System.Resources;
+using System.Windows;
+
+namespace Trakers.Debug
+{
+ ///
+ /// Interaction logic for DebugParameters.xaml
+ ///
+ public partial class DebugParameters : Window
+ {
+ private ResourceManager rm;
+ private DebugWindow debug;
+
+ /*
+ * Constructeur : On ouvre la fenêtre et on charge les paramètres.
+ */
+ public DebugParameters(DebugWindow _debug)
+ {
+ rm = new ResourceManager("Trakers.Debug.Properties.Resources", Assembly.GetExecutingAssembly());
+ debug = _debug;
+ InitializeComponent();
+ getParameters();
+ }
+
+ /*
+ * Permet de charger les paramètres depuis KinectMain et les affiche dans la fenêtre de paramétrage.
+ */
+ public void getParameters()
+ {
+ searchMinDistanceTB.Text = debug.getMinDistHands().ToString();
+ searchMaxDistanceTB.Text = debug.getMaxDistHands().ToString();
+ minDistanceTB.Text = debug.getMinDist().ToString();
+ maxDistanceTB.Text = debug.getMaxDist().ToString();
+ zeroPointTB.Text = debug.getZeroPoint().ToString();
+ connexionHostTB.Text = debug.getConnexionHost();
+ connexionPortTB.Text = debug.getConnexionPort().ToString();
+ timerElapsingTB.Text = debug.getTimerElapsing().ToString();
+ imagesToShowTB.Text = debug.getImagesToShow().ToString();
+ takenPointsTB.Text = debug.getTakenPoints().ToString();
+ directionChangeTresholdXYTB.Text = debug.getTakenPoints().ToString();
+ directionChangeTresholdZTB.Text = debug.getTakenPoints().ToString();
+ }
+
+ /*
+ * Permet de sauvegarder les paramètres de la fenêtre de paramétrage vers KinectMain.
+ */
+ public void setParameters()
+ {
+ try
+ {
+ ExceptionInParametersLbl.Content = "";
+
+ float minDistHands = float.Parse(searchMinDistanceTB.Text);
+ float maxDistHands = float.Parse(searchMaxDistanceTB.Text);
+ float minDist = float.Parse(minDistanceTB.Text);
+ float maxDist = float.Parse(maxDistanceTB.Text);
+ float zeroPoint = float.Parse(zeroPointTB.Text);
+ int connexionPort = int.Parse(connexionPortTB.Text);
+ int timerElapsing = int.Parse(timerElapsingTB.Text);
+ int imagesToShow = int.Parse(imagesToShowTB.Text);
+ int takenPoints = int.Parse(takenPointsTB.Text);
+ int directionChangeTresholdXY = int.Parse(directionChangeTresholdXYTB.Text);
+ float directionChangeTresholdZ = float.Parse(directionChangeTresholdZTB.Text);
+
+ if (maxDistHands <= 0f || minDistHands <= 0f || maxDistHands > maxDist || minDistHands > maxDist ||
+ minDistHands >= maxDistHands || zeroPoint < maxDistHands || minDistHands > minDist ||
+ zeroPoint >= maxDist || connexionPort < 0 || timerElapsing < 0 || imagesToShow < 1 ||
+ takenPoints <= 0 || directionChangeTresholdXY < 0 || directionChangeTresholdZ < 0)
+ {
+ ExceptionInParametersLbl.Content = rm.GetString("loadParametersIncorrect");
+ }
+ else
+ {
+ debug.setMinDistHands(minDistHands);
+ debug.setMaxDistHands(maxDistHands);
+ debug.setMinDist(minDist);
+ debug.setMaxDist(maxDist);
+ debug.setZeroPoint(zeroPoint);
+ debug.setConnexionHost(connexionHostTB.Text);
+ debug.setConnexionPort(connexionPort);
+ debug.setTimerElapsing(timerElapsing);
+ debug.setImagesToShow(imagesToShow);
+ debug.setTakenPoints(takenPoints);
+ debug.setDirectionChangeTresholdXY(directionChangeTresholdXY);
+ debug.setDirectionChangeTresholdZ(directionChangeTresholdZ);
+
+ debug.updateParameters();
+ ExceptionInParametersLbl.Content = null;
+ }
+ }
+ catch (Exception)
+ {
+ //S'il y a eu un problème de parsing (i.e si l'utilisateur a entré une mauvaise valeur),
+ //Alors on affiche l'erreur, puis on recharge les paramètres précédents.
+ ExceptionInParametersLbl.Content = rm.GetString("loadParametersFail");
+ getParameters();
+ }
+ }
+
+ /*
+ * Méthode attachée à l'événement click sur le bouton de validation de la fenêtre de paramétrage.
+ * Les données sont sauvegardées vers KinectMain, puis rechargées dans la fenêtre.
+ */
+ private void Button_Click(object sender, RoutedEventArgs e)
+ {
+ setParameters();
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/DebugWindow.xaml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/DebugWindow.xaml Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,92 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/DebugWindow.xaml.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/DebugWindow.xaml.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,872 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Debug
+ * Classe : DebugWindow
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Reçoit des notifications des sous-modules Tracking, Communication et Exception.
+ * Intéragit avec la fenêtre XAML de debug de façon à afficher un rendu visuel.
+ */
+
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Shapes;
+using System.Drawing;
+using Microsoft.Kinect;
+using System.Resources;
+using System.Reflection;
+using System.Timers;
+using System.Configuration;
+
+namespace Trakers.Debug
+{
+ public partial class DebugWindow : Window
+ {
+ //Gestionnaire de ressources.
+ private ResourceManager rm;
+
+ //Paramètres du serveur TUIO.
+ private string connexionHost;
+ private int connexionPort;
+ //Temps de rafraichissement pour le timer (Détection de gesture dans le serveur TUIO).
+ private int timerElapsing;
+ //Distances min/max délimitant le champ de recherche.
+ private float minDistHands;
+ private float maxDistHands;
+ private float minDist;
+ private float maxDist;
+ private float zeroPoint;
+ //Paramètres de la mosaïque.
+ private int imagesToShow;
+ //Paramètres de la recherche par courbes.
+ private int takenPoints;
+ private int directionChangeTresholdXY;
+ private float directionChangeTresholdZ;
+
+ //Timer.
+ private System.Timers.Timer _timer;
+ //Membre permettant d'atteindre la classe KinectMain du sous-module Tracking.
+ //private KinectMain kinectMain;
+ //Tableau contenant une image en couleurs.
+ private byte[] colorPixelData;
+ //Indique si la kinect est allumée/éteinte.
+ private bool on;
+ //Indique si la fenêtre de debug est actuellement en cours de fermeture.
+ private bool closing;
+ //Indique si l'image doit être raffraichie.
+ private Boolean refreshImage;
+
+ /*
+ * Constructeur : Affiche la fenêtre de debug en lui passant en paramètre une instanciation de la
+ * classe KinectMain.
+ * Au départ, la kinect est éteinte.
+ */
+ public DebugWindow()//KinectMain main)
+ {
+ InitializeComponent();
+ //On fait appel au gestionnaire de ressources.
+ rm = new ResourceManager("Trakers.Debug.Properties.Resources", Assembly.GetExecutingAssembly());
+ //On tente de charger les paramètres du fichier params.ini.
+ //Si on n'y arrive pas, on affiche une erreur et on charge les paramètres par défaut.
+ if (!loadParameters())
+ {
+ ExceptionLbl.Content = rm.GetString("loadParametersFail");
+ //Distances de détection des mains par défaut pour la recherche (ici de 1m à 2m de la Kinect).
+ minDistHands = 1.0f;
+ maxDistHands = 1.5f;
+ minDist = 1.0f;
+ maxDist = 4.0f;
+ zeroPoint = 1.7f;
+ connexionHost = "127.0.0.1";
+ connexionPort = 80;
+ timerElapsing = 1000;
+ imagesToShow = 25;
+ takenPoints = 10;
+ directionChangeTresholdXY = 10;
+ directionChangeTresholdZ = 0.01f;
+ }
+
+ //kinectMain = main;
+ on = true;
+ closing = false;
+ refreshImage = true;
+ try
+ {
+ //On instancie le timer à N ms.
+ _timer = new System.Timers.Timer(timerElapsing);
+ //Dès que le timer est expiré, on appelle _timer_Elapsed.
+ _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
+ }
+ catch (Exception){}
+ }
+
+ /*
+ * Méthode d'effacement du label d'exceptions.
+ */
+ public void NoException()
+ {
+ ExceptionLbl.Content = "";
+ }
+
+ /*
+ * Méthode d'affichage des exceptions dans le label d'exceptions.
+ */
+ public void ShowException(String reference)
+ {
+ ExceptionLbl.Content = rm.GetString(reference);
+ }
+
+ /*
+ * Méthode de fermeture de l'interface.
+ */
+ public void ShutDownInterface()
+ {
+ DebugImage.Source = null;
+ ExceptionLbl.Content = "";
+ }
+
+ /*
+ * Méthode appelée à l'expiration du timer pour les gestures et modes.
+ */
+ public void _timer_Elapsed(object sender, ElapsedEventArgs e)
+ {
+ //On débloque le raffraichissement de l'image.
+ refreshImage = true;
+ //On arrête le timer.
+ _timer.Stop();
+ }
+
+ /*
+ * Getter pour le membre indiquant la fermeture de la fenêtre de debug.
+ */
+ public bool isClosing()
+ {
+ return closing;
+ }
+
+ /*
+ * Est appelée à la fermeture de la fenêtre.
+ */
+ public void Window_Closed(object sender, EventArgs e)
+ {
+ closing = true;
+ }
+
+ /*
+ * Bouton ON/OFF.
+ */
+ private void Switch_Click(object sender, RoutedEventArgs e)
+ {
+ //S'il valait faux, il vaut vrai maintenant et inversement.
+ on = !on;
+ //Si la kinect est allumée.
+ if (on)
+ {
+ //Il affiche OFF (pour éteindre la kinect).
+ Switch.Content = "OFF";
+ //On vide le label des exceptions.
+ ExceptionLbl.Content = "";
+ }
+ else
+ {
+ //Il affiche ON (pour allumer la kinect).
+ Switch.Content = "ON";
+ //On remet à zéro tous les éléments du retour visuel.
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ DistanceLbl.Content = "Distance :";
+ LeftHand.Background = System.Windows.Media.Brushes.DarkGray;
+ LeftHand.Content = "";
+ RightHand.Background = System.Windows.Media.Brushes.DarkGray;
+ RightHand.Content = "";
+ DebugCanvas.Children.RemoveRange(1, DebugCanvas.Children.Count - 1);
+ }
+ }
+
+ /*
+ * Récupère le flux video et met à jour le rendu visuel de debug.
+ */
+ public void RefreshVideo(AllFramesReadyEventArgs e)
+ {
+ if (refreshImage)
+ {
+ bool receivedData = false;
+ ColorImageFrame colorImageFrameData;
+ using (colorImageFrameData = e.OpenColorImageFrame())
+ {
+ //Si on ne reçoit pas de trames de la kinect.
+ if (colorImageFrameData == null)
+ {
+ //L'image est supprimée.
+ DebugImage.Source = null;
+ }
+ //Si le tableau stockant l'image en cours est nul.
+ if (colorPixelData == null)
+ //On alloue un nouveau tableau.
+ colorPixelData = new byte[colorImageFrameData.PixelDataLength];
+ else
+ {
+ try
+ {
+ //Sinon on met à jour le tableau en copiant le contenu de la trame dans le tableau.
+ colorImageFrameData.CopyPixelDataTo(colorPixelData);
+ receivedData = true;
+ }
+ catch (Exception) { }
+ }
+ }
+ //Si on a des données dans le tableau et que la kinect est allumée.
+ if (receivedData && on)
+ {
+ //On met à jour l'image de la caméra.
+ DebugImage.Source = BitmapSource.Create(colorImageFrameData.Width, colorImageFrameData.Height, 96, 96, PixelFormats.Bgr32, null, colorPixelData, colorImageFrameData.Width * colorImageFrameData.BytesPerPixel);
+ DebugImage.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
+ DebugImage.VerticalAlignment = System.Windows.VerticalAlignment.Center;
+ DebugImage.Stretch = Stretch.Fill;
+ //On annule l'image associée aux gestures.
+ Gestures.Source = null;
+ }
+ }
+ }
+
+ /*
+ * Affiche la distance de l'utilisateur dans le rendu visuel.
+ * Sous forme de nombre en m et de rectangles changeant de couleur en fonction de la distance.
+ */
+ public void showDistance(float proximity)
+ {
+ DistanceLbl.Content = "Proximity : " + proximity + "%";
+
+ if (proximity == 0)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.DarkGray;
+ R6.Fill = System.Windows.Media.Brushes.DarkGray;
+ R7.Fill = System.Windows.Media.Brushes.DarkGray;
+ R8.Fill = System.Windows.Media.Brushes.DarkGray;
+ R9.Fill = System.Windows.Media.Brushes.DarkGray;
+ R10.Fill = System.Windows.Media.Brushes.DarkGray;
+ }
+ else if (proximity > 0 && proximity < 10)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.DarkGray;
+ R6.Fill = System.Windows.Media.Brushes.DarkGray;
+ R7.Fill = System.Windows.Media.Brushes.DarkGray;
+ R8.Fill = System.Windows.Media.Brushes.DarkGray;
+ R9.Fill = System.Windows.Media.Brushes.DarkGray;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 10 && proximity < 20)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.DarkGray;
+ R6.Fill = System.Windows.Media.Brushes.DarkGray;
+ R7.Fill = System.Windows.Media.Brushes.DarkGray;
+ R8.Fill = System.Windows.Media.Brushes.DarkGray;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 20 && proximity < 30)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.DarkGray;
+ R6.Fill = System.Windows.Media.Brushes.DarkGray;
+ R7.Fill = System.Windows.Media.Brushes.DarkGray;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 30 && proximity < 40)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.DarkGray;
+ R6.Fill = System.Windows.Media.Brushes.DarkGray;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 40 && proximity < 50)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.DarkGray;
+ R6.Fill = System.Windows.Media.Brushes.Orange;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 50 && proximity < 60)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.Orange;
+ R6.Fill = System.Windows.Media.Brushes.Orange;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 60 && proximity < 70)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.Yellow;
+ R5.Fill = System.Windows.Media.Brushes.Orange;
+ R6.Fill = System.Windows.Media.Brushes.Orange;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 70 && proximity < 80)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.Yellow;
+ R4.Fill = System.Windows.Media.Brushes.Yellow;
+ R5.Fill = System.Windows.Media.Brushes.Orange;
+ R6.Fill = System.Windows.Media.Brushes.Orange;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 80 && proximity < 90)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.Yellow;
+ R3.Fill = System.Windows.Media.Brushes.Yellow;
+ R4.Fill = System.Windows.Media.Brushes.Yellow;
+ R5.Fill = System.Windows.Media.Brushes.Orange;
+ R6.Fill = System.Windows.Media.Brushes.Orange;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity > 90 && proximity < 100)
+ {
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.Yellow;
+ R2.Fill = System.Windows.Media.Brushes.Yellow;
+ R3.Fill = System.Windows.Media.Brushes.Yellow;
+ R4.Fill = System.Windows.Media.Brushes.Yellow;
+ R5.Fill = System.Windows.Media.Brushes.Orange;
+ R6.Fill = System.Windows.Media.Brushes.Orange;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ else if (proximity == 100)
+ {
+ R0.Fill = System.Windows.Media.Brushes.Green;
+ R1.Fill = System.Windows.Media.Brushes.Yellow;
+ R2.Fill = System.Windows.Media.Brushes.Yellow;
+ R3.Fill = System.Windows.Media.Brushes.Yellow;
+ R4.Fill = System.Windows.Media.Brushes.Yellow;
+ R5.Fill = System.Windows.Media.Brushes.Orange;
+ R6.Fill = System.Windows.Media.Brushes.Orange;
+ R7.Fill = System.Windows.Media.Brushes.Orange;
+ R8.Fill = System.Windows.Media.Brushes.Red;
+ R9.Fill = System.Windows.Media.Brushes.Red;
+ R10.Fill = System.Windows.Media.Brushes.Red;
+ }
+ }
+
+ /*
+ * Affiche la détection de la main droite via un label.
+ */
+ public void showRightHandRect(bool show)
+ {
+ if (show)
+ RightHand.Background = System.Windows.Media.Brushes.Blue;
+ else
+ RightHand.Background = System.Windows.Media.Brushes.DarkGray;
+ }
+
+ /*
+ * Affiche la détection de la main gauche via un label.
+ */
+ public void showLeftHandRect(bool show)
+ {
+ if (show)
+ LeftHand.Background = System.Windows.Media.Brushes.Blue;
+ else
+ LeftHand.Background = System.Windows.Media.Brushes.DarkGray;
+ }
+
+ /*
+ * Dessine les noeuds du squelette dans le rendu visuel.
+ */
+ public void drawJoints(JointCollection joints, Skeleton first)
+ {
+ if (refreshImage)
+ {
+ //On enlève tout élément du Canvas à part l'image, de manière à mettre à jour la position du squelette.
+ DebugCanvas.Children.RemoveRange(1, DebugCanvas.Children.Count - 1);
+
+ //Pour chaque noeud.
+ foreach (Joint joint in first.Joints)
+ {
+ //On crée une ellipse de taille 20 et de largeur 20.
+ Ellipse node = new Ellipse();
+ node.Height = 20;
+ node.Width = 20;
+
+ //S'il s'agit d'un noeud de tête, on le colorie en rouge, sinon en bleu.
+ if (joint.JointType == JointType.Head)
+ node.Fill = System.Windows.Media.Brushes.Red;
+ else if (joint.JointType == JointType.ShoulderCenter)
+ node.Fill = System.Windows.Media.Brushes.Green;
+ else if (joint.JointType == JointType.HipCenter)
+ node.Fill = System.Windows.Media.Brushes.Green;
+ else if (joint.JointType == JointType.HandRight)
+ node.Fill = System.Windows.Media.Brushes.Red;
+ else
+ node.Fill = System.Windows.Media.Brushes.Blue;
+
+ //On met à la bonne échelle les coordonnées des positions des noeuds.
+ Joint scaledJoint = Coding4Fun.Kinect.Wpf.SkeletalExtensions.ScaleTo(joint, 600, 400, 0.75f, 0.75f);
+
+ //On positionne le noeud dans le Canvas, et on l'ajoute.
+ Canvas.SetLeft(node, scaledJoint.Position.X);
+ Canvas.SetTop(node, scaledJoint.Position.Y);
+ DebugCanvas.Children.Add(node);
+ }
+ }
+ }
+
+ /*
+ * Dessine un os, en ayant en paramètres deux noeuds.
+ */
+ public void drawBone(Joint j1, Joint j2)
+ {
+ //On crée une nouvelle ligne verte d'épaisseur 8 entre les deux noeuds et on l'ajoute au Canvas.
+ Line line = new Line();
+ line.Stroke = System.Windows.Media.Brushes.Green;
+ line.X1 = j1.Position.X;
+ line.X2 = j2.Position.X;
+ line.Y1 = j1.Position.Y;
+ line.Y2 = j2.Position.Y;
+ line.StrokeThickness = 8;
+ DebugCanvas.Children.Add(line);
+ }
+
+ /*
+ * Dessine le squelette (ensemble des os), en ayant en paramètres tous les noeuds.
+ */
+ public void showSkeleton(Joint hipCenter, Joint spine, Joint shoulderCenter, Joint head, Joint shoulderLeft, Joint elbowLeft, Joint wristLeft, Joint handLeft, Joint shoulderRight, Joint elbowRight, Joint wristRight, Joint handRight, Joint hipLeft, Joint kneeLeft, Joint ankleLeft, Joint footLeft, Joint hipRight, Joint kneeRight, Joint ankleRight, Joint footRight)
+ {
+ if (refreshImage)
+ {
+ //On met les noeuds deux par deux en fonction de leur position dans le squelette.
+ drawBone(head, shoulderCenter);
+ drawBone(shoulderCenter, shoulderLeft);
+ drawBone(shoulderLeft, elbowLeft);
+ drawBone(elbowLeft, wristLeft);
+ drawBone(wristLeft, handLeft);
+ drawBone(shoulderCenter, shoulderRight);
+ drawBone(shoulderRight, elbowRight);
+ drawBone(elbowRight, wristRight);
+ drawBone(wristRight, handRight);
+ drawBone(shoulderCenter, spine);
+ drawBone(spine, hipCenter);
+ drawBone(hipCenter, hipLeft);
+ drawBone(hipLeft, kneeLeft);
+ drawBone(kneeLeft, ankleLeft);
+ drawBone(ankleLeft, footLeft);
+ drawBone(hipCenter, hipRight);
+ drawBone(hipRight, kneeRight);
+ drawBone(kneeRight, ankleRight);
+ drawBone(ankleRight, footRight);
+ }
+ }
+
+ /*
+ * Cache le squelette et le reste de l'interface à part l'image.
+ */
+ public void hideSkeleton()
+ {
+ //On vide le canvas mais en gardant l'image.
+ if(DebugCanvas.Children.Count > 1)
+ DebugCanvas.Children.RemoveRange(1, DebugCanvas.Children.Count - 1);
+ //On colore en gris tous les indicateurs.
+ R0.Fill = System.Windows.Media.Brushes.DarkGray;
+ R1.Fill = System.Windows.Media.Brushes.DarkGray;
+ R2.Fill = System.Windows.Media.Brushes.DarkGray;
+ R3.Fill = System.Windows.Media.Brushes.DarkGray;
+ R4.Fill = System.Windows.Media.Brushes.DarkGray;
+ R5.Fill = System.Windows.Media.Brushes.DarkGray;
+ R6.Fill = System.Windows.Media.Brushes.DarkGray;
+ R7.Fill = System.Windows.Media.Brushes.DarkGray;
+ R8.Fill = System.Windows.Media.Brushes.DarkGray;
+ R9.Fill = System.Windows.Media.Brushes.DarkGray;
+ R10.Fill = System.Windows.Media.Brushes.DarkGray;
+ }
+
+ /*
+ * Affiche la position de la main gauche dans le rendu visuel.
+ */
+ public void showLeftHandCoord(String coord)
+ {
+ LeftHand.Content = coord;
+ }
+
+ /*
+ * Affiche la position de la main gauche dans le rendu visuel.
+ */
+ public void showRightHandCoord(String coord)
+ {
+ RightHand.Content = coord;
+ }
+
+ /*
+ * Méthode associée à l'événement : Ouvrir la fenêtre de paramétrage via le menu.
+ */
+ private void Parameters_Click(object sender, RoutedEventArgs e)
+ {
+ DebugParameters param = new DebugParameters(this);
+
+ try
+ {
+ param.ShowDialog();
+ }
+ catch (Exception)
+ {
+ ExceptionLbl.Content = rm.GetString("loadParamFail");
+ }
+ }
+
+ /*
+ * Méthode associée à l'événement : Quitter via le menu.
+ */
+ public void Quit_Click(object sender, RoutedEventArgs e)
+ {
+ closing = true;
+ //On éteint la Kinect (pour éviter qu'elle reste allumée même lorsque le programme est éteint).
+
+ Application.Current.Shutdown();
+ }
+
+ /*
+ * Permet d'initialiser la Kinect dès que la fenêtre est lancée.
+ */
+ private void Window_Loaded(object sender, RoutedEventArgs e)
+ {
+ //kinectMain.KinectInitialization();
+ }
+
+ /*
+ * Méthode d'affichage des gestures.
+ */
+ public void showGesture(String gesture)
+ {
+ if (refreshImage)
+ {
+ refreshImage = false;
+ _timer.Start();
+ Bitmap bitmap = null;
+ //S'il s'agit de telle ou telle gesture, on prend l'image correspondante dans les ressources,
+ //on la convertit et on l'affiche.
+ switch (gesture)
+ {
+ case "SWIPE-LEFT": bitmap = (Bitmap)rm.GetObject("swipe_left");
+ break;
+ case "SWIPE-RIGHT": bitmap = (Bitmap)rm.GetObject("swipe_right");
+ break;
+ case "PUSH-RIGHT": bitmap = (Bitmap)rm.GetObject("push_right");
+ break;
+ case "PUSH-LEFT": bitmap = (Bitmap)rm.GetObject("push_left");
+ break;
+ case "PUSH-BOTH": bitmap = (Bitmap)rm.GetObject("push_both");
+ break;
+ case "PULL-RIGHT": bitmap = (Bitmap)rm.GetObject("pull_right");
+ break;
+ case "PULL-LEFT": bitmap = (Bitmap)rm.GetObject("pull_left");
+ break;
+ case "PULL-BOTH": bitmap = (Bitmap)rm.GetObject("pull_both");
+ break;
+ }
+ Gestures.Source = CreateBitmapSourceFromBitmap(bitmap);
+ }
+
+ DebugImage.Source = null;
+ hideSkeleton();
+ }
+
+ /*
+ * Méthode d'indication de raffraichissement de l'image ("on la raffraichit ou pas ?").
+ */
+ public void setRefreshImage(bool refresh)
+ {
+ refreshImage = refresh;
+ }
+
+ /*
+ * Méthode de conversion de Bitmap (des ressources) en BitmapSource (du debug).
+ */
+ public static BitmapSource CreateBitmapSourceFromBitmap(Bitmap bitmap)
+ {
+ if (bitmap == null)
+ return null;
+
+ return System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
+ bitmap.GetHbitmap(),
+ IntPtr.Zero,
+ Int32Rect.Empty,
+ BitmapSizeOptions.FromEmptyOptions());
+ }
+
+ /*
+ * Méthode de chargement des paramètres (position du champ de recherche...).
+ */
+ public bool loadParameters()
+ {
+ try
+ {
+ minDistHands = Properties.Settings.Default.searchMinDistance;
+ maxDistHands = Properties.Settings.Default.searchMaxDistance;
+ minDist = Properties.Settings.Default.minDistance;
+ maxDist = Properties.Settings.Default.maxDistance;
+ zeroPoint = Properties.Settings.Default.zeroPoint;
+ connexionHost = Properties.Settings.Default.connexionHost;
+ connexionPort = Properties.Settings.Default.connexionPort;
+ timerElapsing = Properties.Settings.Default.timerElapsing;
+ imagesToShow = Properties.Settings.Default.imagesToShow;
+ takenPoints = Properties.Settings.Default.takenPoints;
+ directionChangeTresholdXY = Properties.Settings.Default.directionChangeTresholdXY;
+ directionChangeTresholdZ = Properties.Settings.Default.directionChangeTresholdZ;
+ }
+ catch (Exception)
+ {
+ return false;
+ }
+
+ if (maxDistHands <= 0f || minDistHands <= 0f || maxDistHands > maxDist || minDistHands > maxDist ||
+ minDistHands >= maxDistHands || zeroPoint < maxDistHands || minDistHands > minDist ||
+ zeroPoint >= maxDist || connexionPort < 0 || timerElapsing < 0 || imagesToShow < 1 ||
+ takenPoints <= 0 || directionChangeTresholdXY < 0 || directionChangeTresholdZ < 0)
+ {
+ ExceptionLbl.Content = rm.GetString("loadParametersIncorrect");
+ return false;
+ }
+ return true;
+ }
+
+ /*
+ * Met à jour les nouveaux paramètres dans la configuration.
+ */
+ public void updateParameters()
+ {
+ //userPositionDetector.setParams(minDist, maxDist, minDistHands, maxDistHands, zeroPoint);
+ //segmenter.setParams(takenPoints, directionChangeTresholdXY, directionChangeTresholdZ);
+
+ //On récupère la config.
+ Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
+ //On met à jour.
+ Properties.Settings.Default.Context.Remove("searchMinDistance");
+ Properties.Settings.Default.Context.Add("searchMinDistance", minDistHands.ToString());
+ Properties.Settings.Default.Context.Remove("searchMaxDistance");
+ Properties.Settings.Default.Context.Add("searchMaxDistance", maxDistHands.ToString());
+ Properties.Settings.Default.Context.Remove("minDistance");
+ Properties.Settings.Default.Context.Add("minDistance", minDist.ToString());
+ Properties.Settings.Default.Context.Remove("maxDistance");
+ Properties.Settings.Default.Context.Add("maxDistance", maxDist.ToString());
+ Properties.Settings.Default.Context.Remove("zeroPoint");
+ Properties.Settings.Default.Context.Add("zeroPoint", zeroPoint.ToString());
+ Properties.Settings.Default.Context.Remove("connexionHost");
+ Properties.Settings.Default.Context.Add("connexionHost", connexionHost);
+ Properties.Settings.Default.Context.Remove("connexionPort");
+ Properties.Settings.Default.Context.Add("connexionPort", connexionPort.ToString());
+ Properties.Settings.Default.Context.Remove("timerElapsing");
+ Properties.Settings.Default.Context.Add("timerElapsing", timerElapsing.ToString());
+ Properties.Settings.Default.Context.Remove("imagesToShow");
+ Properties.Settings.Default.Context.Add("imagesToShow", imagesToShow.ToString());
+ Properties.Settings.Default.Context.Remove("takenPoints");
+ Properties.Settings.Default.Context.Add("takenPoints", takenPoints.ToString());
+ Properties.Settings.Default.Context.Remove("directionChangeTresholdXY");
+ Properties.Settings.Default.Context.Add("directionChangeTresholdXY", directionChangeTresholdXY.ToString());
+ Properties.Settings.Default.Context.Remove("directionChangeTresholdZ");
+ Properties.Settings.Default.Context.Add("directionChangeTresholdZ", directionChangeTresholdZ.ToString());
+
+ //Sauvegarde la configuration.
+ Properties.Settings.Default.Save();
+ Properties.Settings.Default.Reload();
+ }
+
+ /*
+ * Getters et setters des paramètres du Middleware.
+ */
+ public void setMinDistHands(float min)
+ {
+ minDistHands = min;
+ }
+ public void setMaxDistHands(float max)
+ {
+ maxDistHands = max;
+ }
+ public void setMinDist(float min)
+ {
+ minDist = min;
+ }
+ public void setMaxDist(float max)
+ {
+ maxDist = max;
+ }
+ public void setZeroPoint(float zero)
+ {
+ zeroPoint = zero;
+ }
+ public void setConnexionHost(String host)
+ {
+ connexionHost = host;
+ }
+ public void setConnexionPort(int port)
+ {
+ connexionPort = port;
+ }
+ public void setTimerElapsing(int time)
+ {
+ timerElapsing = time;
+ }
+ public void setImagesToShow(int _imagesToShow)
+ {
+ imagesToShow = _imagesToShow;
+ }
+ public void setTakenPoints(int _takenPoints)
+ {
+ takenPoints = _takenPoints;
+ }
+ public void setDirectionChangeTresholdXY(int _directionChangeTresholdXY)
+ {
+ directionChangeTresholdXY = _directionChangeTresholdXY;
+ }
+ public void setDirectionChangeTresholdZ(float _directionChangeTresholdZ)
+ {
+ directionChangeTresholdZ = _directionChangeTresholdZ;
+ }
+ public void setSwitch(Button _switch)
+ {
+ Switch = _switch;
+ }
+ public void setOn(bool _on)
+ {
+ on = _on;
+ }
+ public void setQuitMenu(MenuItem quitMenu)
+ {
+ QuitMenu = quitMenu;
+ }
+
+ public float getMinDistHands()
+ {
+ return minDistHands;
+ }
+ public float getMaxDistHands()
+ {
+ return maxDistHands;
+ }
+ public float getMinDist()
+ {
+ return minDist;
+ }
+ public float getMaxDist()
+ {
+ return maxDist;
+ }
+ public float getZeroPoint()
+ {
+ return zeroPoint;
+ }
+ public String getConnexionHost()
+ {
+ return connexionHost;
+ }
+ public int getConnexionPort()
+ {
+ return connexionPort;
+ }
+ public int getTimerElapsing()
+ {
+ return timerElapsing;
+ }
+ public int getImagesToShow()
+ {
+ return imagesToShow;
+ }
+ public int getTakenPoints()
+ {
+ return takenPoints;
+ }
+ public int getDirectionChangeTresholdXY()
+ {
+ return directionChangeTresholdXY;
+ }
+ public float getDirectionChangeTresholdZ()
+ {
+ return directionChangeTresholdZ;
+ }
+ public Button getSwitch()
+ {
+ return Switch;
+ }
+ public bool getOn()
+ {
+ return on;
+ }
+ public MenuItem getQuitMenu()
+ {
+ return QuitMenu;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Properties/AssemblyInfo.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Properties/AssemblyInfo.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Debug")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Debug")]
+[assembly: AssemblyCopyright("Copyright © 2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3a95cd86-6297-4cb5-9dc2-a3a6ebb1a9fc")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Properties/Resources.Designer.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Properties/Resources.Designer.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,171 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:4.0.30319.261
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace Trakers.Debug.Properties {
+ using System;
+
+
+ ///
+ /// A strongly-typed resource class, for looking up localized strings, etc.
+ ///
+ // This class was auto-generated by the StronglyTypedResourceBuilder
+ // class via a tool like ResGen or Visual Studio.
+ // To add or remove a member, edit your .ResX file then rerun ResGen
+ // with the /str option, or rebuild your VS project.
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ internal class Resources {
+
+ private static global::System.Resources.ResourceManager resourceMan;
+
+ private static global::System.Globalization.CultureInfo resourceCulture;
+
+ [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+ internal Resources() {
+ }
+
+ ///
+ /// Returns the cached ResourceManager instance used by this class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Resources.ResourceManager ResourceManager {
+ get {
+ if (object.ReferenceEquals(resourceMan, null)) {
+ global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Trakers.Debug.Properties.Resources", typeof(Resources).Assembly);
+ resourceMan = temp;
+ }
+ return resourceMan;
+ }
+ }
+
+ ///
+ /// Overrides the current thread's CurrentUICulture property for all
+ /// resource lookups using this strongly typed resource class.
+ ///
+ [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+ internal static global::System.Globalization.CultureInfo Culture {
+ get {
+ return resourceCulture;
+ }
+ set {
+ resourceCulture = value;
+ }
+ }
+
+ internal static System.Drawing.Bitmap jump {
+ get {
+ object obj = ResourceManager.GetObject("jump", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ ///
+ /// Looks up a localized string similar to Kinect non connectée..
+ ///
+ internal static string kinectNotConnected {
+ get {
+ return ResourceManager.GetString("kinectNotConnected", resourceCulture);
+ }
+ }
+
+ ///
+ /// Looks up a localized string similar to Impossible de charger les paramètres. Paramètres par défaut..
+ ///
+ internal static string loadParametersFail {
+ get {
+ return ResourceManager.GetString("loadParametersFail", resourceCulture);
+ }
+ }
+
+ ///
+ /// Looks up a localized string similar to Paramètres incorrects. Paramètres par défaut..
+ ///
+ internal static string loadParametersIncorrect {
+ get {
+ return ResourceManager.GetString("loadParametersIncorrect", resourceCulture);
+ }
+ }
+
+ ///
+ /// Looks up a localized string similar to Impossible de charger la fenêtre de paramétrage..
+ ///
+ internal static string loadParamFail {
+ get {
+ return ResourceManager.GetString("loadParamFail", resourceCulture);
+ }
+ }
+
+ internal static System.Drawing.Bitmap pull_both {
+ get {
+ object obj = ResourceManager.GetObject("pull_both", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ internal static System.Drawing.Bitmap pull_left {
+ get {
+ object obj = ResourceManager.GetObject("pull_left", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ internal static System.Drawing.Bitmap pull_right {
+ get {
+ object obj = ResourceManager.GetObject("pull_right", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ internal static System.Drawing.Bitmap push_both {
+ get {
+ object obj = ResourceManager.GetObject("push_both", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ internal static System.Drawing.Bitmap push_left {
+ get {
+ object obj = ResourceManager.GetObject("push_left", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ internal static System.Drawing.Bitmap push_right {
+ get {
+ object obj = ResourceManager.GetObject("push_right", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ ///
+ /// Looks up a localized string similar to Impossible de démarrer le serveur TUIO (peut-être host ou port invalide ?)..
+ ///
+ internal static string serverCantStart {
+ get {
+ return ResourceManager.GetString("serverCantStart", resourceCulture);
+ }
+ }
+
+ internal static System.Drawing.Bitmap swipe_left {
+ get {
+ object obj = ResourceManager.GetObject("swipe_left", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+
+ internal static System.Drawing.Bitmap swipe_right {
+ get {
+ object obj = ResourceManager.GetObject("swipe_right", resourceCulture);
+ return ((System.Drawing.Bitmap)(obj));
+ }
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Properties/Resources.resx
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Properties/Resources.resx Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,5310 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ Kinect non connectée.
+ S'affiche si la Kinect n'est pas connectée.
+
+
+ Impossible de charger les paramètres. Paramètres par défaut.
+ S'affiche si les paramètres ne peuvent être chargés à cause d'un problème inconnu.
+
+
+ Paramètres incorrects. Paramètres par défaut.
+ S'affiche si les paramètres sont incorrects.
+
+
+ Impossible de charger la fenêtre de paramétrage.
+ S'affiche si l'affichage de la fenêtre de paramétrage a échoué.
+
+
+ Impossible de démarrer le serveur TUIO (peut-être host ou port invalide ?).
+ S'affiche si le serveur ne peut pas démarrer.
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+ELckV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDg6MDYAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAAKSAAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUpJJIAkw0Ek8ACSkpSSRDmmHAtPMEQY+aSSl
+ JJJJKUkkkkpSSSSSlIuJ/TMb/jqv+rYhIuJ/TMb/AI6r/q2JKf/R1sv+mZP/AB1v/VvQkXL/AKZk/wDH
+ W/8AVvQklKSSSSUpJJJJSkkkklKVvGY0VB4+k+ZPwJb/AN9VRWaGXsbIDNrjuLXEg8bR7g1/gkpJkMa6
+ pxI1YC5pHwVJWrmZFjYhm3Q7QSSSPAljFVSUpJJJJSkkkklKSSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HV
+ f9WxJT//0tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpJJExzULP0n9kn6M/yv9dn
+ /QSUlooDR6tukagHt/Kd/K/db/6NRmPD2h4mDMT5Et/gqt95tMDRgOnif5Tv/Iqxj/zDPn/1TklM3uDW
+ OcRIaCSBzog3UttHq1QXHUxpu+/8/wDrIl38zZ/VP5FVpudU7xYeW/xakpGki5LqnOBr1cdXEcaj/q/9
+ bP0iEkpSSSSSlJJJJKUi4n9Mxv8Ajqv+rYhIuJ/TMb/jqv8Aq2JKf//T1sv+mZP/AB1v/VvQkXL/AKZk
+ /wDHW/8AVvQklKSSSSUpJJJJSkkkklKVuokYkgwQ15B8wXqordf9DP8AUf8AlekpUl2IXOMksdJ+9VFb
+ H9DP9R3/AH5VElKSSSSUpJJJJSkkkklKRcT+mY3/AB1X/VsQkXE/pmN/x1X/AFbElP8A/9TWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUpW6/wChn+o/8r1URm5DW0eltJO1wmRHu3f+
+ SSUlH9DP9R3/AH5VEYZDfQ9LaZ2lsyI1lBSUpJJJJSkkkklKSSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HV
+ f9WxJT//1dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpJJGw2VPvDbqrb2bXE10fT
+ mPa7+o385JSFIAkwE4rt2McWOiz6DoMOP/Bu/P8A7KO3GyASwU2F7SA9oY6QXfQa5se3cnRjZ8GHPm9u
+ OguZ+UftLXIIMFJWTh5Ty5gotL6/pgMdLZ19+iAym+z+aqfYJ2yxpd7udvtH0kpRo+CsGb3I6ipj5h+2
+ LFJO9llbyyxrq3t5Y8FpH9lyZNZlJJJJKUkkkkpSLif0zG/46r/q2ISLif0zG/46r/q2JKf/1tbL/pmT
+ /wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpan1a/5WH/ABVn5a1lrV+rddg6j65Y4Utqs3Wk
+ EMGrP8J9DskpjY6Ok9E/rO/6tq0sm2yu3rj63Fj2sohzdCPZ+aVlY+X063p2HTmOtrswXFzBU0OFgJ37
+ fd9BHyOq4tp6mWh4+2tqFMt7sbtdv/dTonoxZID5up6/4Eohs2ZmWKOin1rJteBad30/fUz9J+/7XJ8u
+ 2ynF6w6hzqnDKrAcw7T7m0b4I/e3LPfn0GrpbBunBcHXadt1b/0f730Fd9bDy8Hql9rrK8a7JrIe1svH
+ toa0+mf5bUpFWOI3OpFf9ARanWXOsxel3WHdbZjS955cYqPuP9pyzFd6nl494xqMXcaMOr0mveIc76Pu
+ 2/8AW1STWVSSSSSlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jqv+rYkp//19bL/pmT/wAdb/1b0JFy/wCm
+ ZP8Ax1v/AFb0JJSkkkklKSSSSUpE+1ZIo+zC54x9f0QMN1O52g/echpJKUnBTJJBEhYXJTi65tTqWvcK
+ Xnc+sH2kiIc5v9lRSSKoigpJJJJKkkkklKSSSSUpFxP6Zjf8dV/1bEJFxP6Zjf8AHVf9WxJT/9DWy/6Z
+ k/8AHW/9W9CVnKxcs5eQRj3EG60gip5BBe/X6CH9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9k
+ zP8AuNd/20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZM
+ z/uNd/20/wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9kzP8A
+ uNd/20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZMz/uN
+ d/20/wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEi4n9Mxv8Ajqv+rYl9kzP+413/AG0/
+ /wAgiYuLljLxyce4AXVEk1PAAD2a/QSU/wD/2f/tFD5QaG90b3Nob3AgMy4wADhCSU0EBAAAAAAAHxwB
+ WgADGyVHHAFaAAMbJUccAVoAAxslRxwCAAACAAAAOEJJTQQlAAAAAAAQ08mfSz2N6iiFSDVqhBWcKzhC
+ SU0EOgAAAAAAmwAAABAAAAABAAAAAAALcHJpbnRPdXRwdXQAAAAEAAAAAFBzdFNib29sAQAAAABJbnRl
+ ZW51bQAAAABJbnRlAAAAAENscm0AAAAPcHJpbnRTaXh0ZWVuQml0Ym9vbAAAAAALcHJpbnRlck5hbWVU
+ RVhUAAAAEwBDAGEAbgBvAG4AIABNAFAAMQA0ADAAIABzAGUAcgBpAGUAcwAAADhCSU0EOwAAAAABsgAA
+ ABAAAAABAAAAAAAScHJpbnRPdXRwdXRPcHRpb25zAAAAEgAAAABDcHRuYm9vbAAAAAAAQ2xicmJvb2wA
+ AAAAAFJnc01ib29sAAAAAABDcm5DYm9vbAAAAAAAQ250Q2Jvb2wAAAAAAExibHNib29sAAAAAABOZ3R2
+ Ym9vbAAAAAAARW1sRGJvb2wAAAAAAEludHJib29sAAAAAABCY2tnT2JqYwAAAAEAAAAAAABSR0JDAAAA
+ AwAAAABSZCAgZG91YkBv4AAAAAAAAAAAAEdybiBkb3ViQG/gAAAAAAAAAAAAQmwgIGRvdWJAb+AAAAAA
+ AAAAAABCcmRUVW50RiNSbHQAAAAAAAAAAAAAAABCbGQgVW50RiNSbHQAAAAAAAAAAAAAAABSc2x0VW50
+ RiNQeGxAUgAAAAAAAAAAAAp2ZWN0b3JEYXRhYm9vbAEAAAAAUGdQc2VudW0AAAAAUGdQcwAAAABQZ1BD
+ AAAAAExlZnRVbnRGI1JsdAAAAAAAAAAAAAAAAFRvcCBVbnRGI1JsdAAAAAAAAAAAAAAAAFNjbCBVbnRG
+ I1ByY0BZAAAAAAAAOEJJTQPtAAAAAAAQAEgAAAABAAIASAAAAAEAAjhCSU0EJgAAAAAADgAAAAAAAAAA
+ AAA/gAAAOEJJTQPyAAAAAAAKAAD///////8AADhCSU0EDQAAAAAABAAAAHg4QklNBBkAAAAAAAQAAAAe
+ OEJJTQPzAAAAAAAJAAAAAAAAAAABADhCSU0nEAAAAAAACgABAAAAAAAAAAI4QklNA/UAAAAAAEgAL2Zm
+ AAEAbGZmAAYAAAAAAAEAL2ZmAAEAoZmaAAYAAAAAAAEAMgAAAAEAWgAAAAYAAAAAAAEANQAAAAEALQAA
+ AAYAAAAAAAE4QklNA/gAAAAAAHAAAP////////////////////////////8D6AAAAAD/////////////
+ ////////////////A+gAAAAA/////////////////////////////wPoAAAAAP//////////////////
+ //////////8D6AAAOEJJTQQAAAAAAAACAAY4QklNBAIAAAAAABIAAAAAAAAAAAAAAAAAAAAAAAA4QklN
+ BDAAAAAAAAkBAQEBAQEBAQEAOEJJTQQtAAAAAAAGAAEAAAAjOEJJTQQIAAAAAAAkAAAAAQAAAkAAAAJA
+ AAAABAAAD6ABAAAPsAAAABM1AQAAB1UBOEJJTQQeAAAAAAAEAAAAADhCSU0EGgAAAAADPQAAAAYAAAAA
+ AAAAAAAAAPoAAAD6AAAABABqAHUAbQBwAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAD6
+ AAAA+gAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAABAAAAABAAAAAAAAbnVsbAAAAAIA
+ AAAGYm91bmRzT2JqYwAAAAEAAAAAAABSY3QxAAAABAAAAABUb3AgbG9uZwAAAAAAAAAATGVmdGxvbmcA
+ AAAAAAAAAEJ0b21sb25nAAAA+gAAAABSZ2h0bG9uZwAAAPoAAAAGc2xpY2VzVmxMcwAAAAFPYmpjAAAA
+ AQAAAAAABXNsaWNlAAAAEgAAAAdzbGljZUlEbG9uZwAAAAAAAAAHZ3JvdXBJRGxvbmcAAAAAAAAABm9y
+ aWdpbmVudW0AAAAMRVNsaWNlT3JpZ2luAAAADWF1dG9HZW5lcmF0ZWQAAAAAVHlwZWVudW0AAAAKRVNs
+ aWNlVHlwZQAAAABJbWcgAAAABmJvdW5kc09iamMAAAABAAAAAAAAUmN0MQAAAAQAAAAAVG9wIGxvbmcA
+ AAAAAAAAAExlZnRsb25nAAAAAAAAAABCdG9tbG9uZwAAAPoAAAAAUmdodGxvbmcAAAD6AAAAA3VybFRF
+ WFQAAAABAAAAAAAAbnVsbFRFWFQAAAABAAAAAAAATXNnZVRFWFQAAAABAAAAAAAGYWx0VGFnVEVYVAAA
+ AAEAAAAAAA5jZWxsVGV4dElzSFRNTGJvb2wBAAAACGNlbGxUZXh0VEVYVAAAAAEAAAAAAAlob3J6QWxp
+ Z25lbnVtAAAAD0VTbGljZUhvcnpBbGlnbgAAAAdkZWZhdWx0AAAACXZlcnRBbGlnbmVudW0AAAAPRVNs
+ aWNlVmVydEFsaWduAAAAB2RlZmF1bHQAAAALYmdDb2xvclR5cGVlbnVtAAAAEUVTbGljZUJHQ29sb3JU
+ eXBlAAAAAE5vbmUAAAAJdG9wT3V0c2V0bG9uZwAAAAAAAAAKbGVmdE91dHNldGxvbmcAAAAAAAAADGJv
+ dHRvbU91dHNldGxvbmcAAAAAAAAAC3JpZ2h0T3V0c2V0bG9uZwAAAAAAOEJJTQQoAAAAAAAMAAAAAj/w
+ AAAAAAAAOEJJTQQUAAAAAAAEAAAAIzhCSU0EDAAAAAAKZAAAAAEAAACgAAAAoAAAAeAAASwAAAAKSAAY
+ AAH/2P/tAAxBZG9iZV9DTQAB/+4ADkFkb2JlAGSAAAAAAf/bAIQADAgICAkIDAkJDBELCgsRFQ8MDA8V
+ GBMTFRMTGBEMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAENCwsNDg0QDg4QFA4ODhQU
+ Dg4ODhQRDAwMDAwREQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM/8AAEQgAoACgAwEi
+ AAIRAQMRAf/dAAQACv/EAT8AAAEFAQEBAQEBAAAAAAAAAAMAAQIEBQYHCAkKCwEAAQUBAQEBAQEAAAAA
+ AAAAAQACAwQFBgcICQoLEAABBAEDAgQCBQcGCAUDDDMBAAIRAwQhEjEFQVFhEyJxgTIGFJGhsUIjJBVS
+ wWIzNHKC0UMHJZJT8OHxY3M1FqKygyZEk1RkRcKjdDYX0lXiZfKzhMPTdePzRieUpIW0lcTU5PSltcXV
+ 5fVWZnaGlqa2xtbm9jdHV2d3h5ent8fX5/cRAAICAQIEBAMEBQYHBwYFNQEAAhEDITESBEFRYXEiEwUy
+ gZEUobFCI8FS0fAzJGLhcoKSQ1MVY3M08SUGFqKygwcmNcLSRJNUoxdkRVU2dGXi8rOEw9N14/NGlKSF
+ tJXE1OT0pbXF1eX1VmZ2hpamtsbW5vYnN0dXZ3eHl6e3x//aAAwDAQACEQMRAD8A2srKyxl5AGRcALrQ
+ ALXgAB79Ppof2vM/7k3f9uv/APJpZf8ATMn/AI63/q3oSSkv2vM/7k3f9uv/APJpfa8z/uTd/wBuv/8A
+ JoSSSkv2vM/7k3f9uv8A/Jpfa8z/ALk3f9uv/wDJoSSSkv2vM/7k3f8Abr//ACaX2vM/7k3f9uv/APJo
+ SSSkv2vM/wC5N3/br/8AyaX2vM/7k3f9uv8A/JoSSSkv2vM/7k3f9uv/APJpfa8z/uTd/wBuv/8AJoSS
+ Skv2vM/7k3f9uv8A/Jpfa8z/ALk3f9uv/wDJoSSSkv2vM/7k3f8Abr//ACaX2vM/7k3f9uv/APJoSSSk
+ v2vM/wC5N3/br/8AyaX2vM/7k3f9uv8A/JoSSSkv2vM/7k3f9uv/APJomLlZZy8cHIuIN1QINryCC9mn
+ 01WRcT+mY3/HVf8AVsSU/wD/0NbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpJJJJS
+ kkkgCTDQSTwAJKSlJJEOaYcC08wRBj5pJKUkkkkpSSSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv8Ajqv+
+ rYkp/9HWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUpW8ZjRUHj6T5k/Alv8A
+ 31VFZoZexsgM2uO4tcSDxtHuDX+CSkmQxrqnEjVgLmkfBUlauZkWNiGbdDtBJJI8CWMVVJSkkkklKSSS
+ SUpJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//S1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQk
+ lKSSSSUpJJJJSkkkTHNQs/Sf2Sfoz/K/12f9BJSWigNHq26RqAe38p38r91v/o1GY8PaHiYMxPkS3+Cq
+ 33m0wNGA6eJ/lO/8irGP/MM+f/VOSUze4NY5xEhoJIHOiDdS20erVBcdTGm77/z/AOsiXfzNn9U/kVWm
+ 51TvFh5b/FqSkaSLkuqc4GvVx1cRxqP+r/1s/SISSlJJJJKUkkkkpSLif0zG/wCOq/6tiEi4n9Mxv+Oq
+ /wCrYkp//9PWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUpW6iRiSDBDXkHzB
+ eqit1/0M/wBR/wCV6SlSXYhc4ySx0n71UVsf0M/1Hf8AflUSUpJJJJSkkkklKSSSSUpFxP6Zjf8AHVf9
+ WxCRcT+mY3/HVf8AVsSU/wD/1NbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpJJJJS
+ lbr/AKGf6j/yvVRGbkNbR6W0k7XCZEe7d/5JJSUf0M/1Hf8AflURhkN9D0tpnaWzIjWUFJSkkkklKSSS
+ SUpJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//V1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQk
+ lKSSSSUpJJJJSkkkbDZU+8NuqtvZtcTXR9OY9rv6jfzklIUgCTATiu3YxxY6LPoOgw4/8G78/wDso7cb
+ IBLBTYXtID2hjpBd9Brmx7dydGNnwYc+b246C5n5R+0tcggwUlZOHlPLmCi0vr+mAx0tnX36IDKb7P5q
+ p9gnbLGl3u52+0fSSlGj4KwZvcjqKmPmH7YsUk72WVvLLGure3ljwWkf2XJk1mUkkkkpSSSSSlIuJ/TM
+ b/jqv+rYhIuJ/TMb/jqv+rYkp//W1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSlqf
+ Vr/lYf8AFWflrWWtX6t12DqPrljhS2qzdaQQwas/wn0OySmNjo6T0T+s7/q2rSybbK7euPrcWPayiHN0
+ I9n5pWVj5fTrenYdOY62uzBcXMFTQ4WAnft930EfI6ri2nqZaHj7a2oUy3uxu12/91OiejFkgPm6nr/g
+ SiGzZmZYo6KfWsm14Fp3fT99TP0n7/tcny7bKcXrDqHOqcMqsBzDtPubRvgj97cs9+fQaulsG6cFwddp
+ 23Vv/R/vfQV31sPLweqX2usrxrsmsh7Wy8e2hrT6Z/ltSkVY4jc6kV/0BFqdZc6zF6XdYd1tmNL3nlxi
+ o+4/2nLMV3qeXj3jGoxdxow6vSa94hzvo+7b/wBbVJNZVJJJJKUkkkkpSLif0zG/46r/AKtiEi4n9Mxv
+ +Oq/6tiSn//X1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSkT7Vkij7MLnjH1/RAw3
+ U7naD95yGkkpScFMkkESFhclOLrm1Opa9wpedz6wfaSIhzm/2VFJIqiKCkkkkkqSSSSUpJJJJSkXE/pm
+ N/x1X/VsQkXE/pmN/wAdV/1bElP/0NbL/pmT/wAdb/1b0JWcrFyzl5BGPcQbrSCKnkEF79foIf2TM/7j
+ Xf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/bT/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+41
+ 3/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8A
+ bT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/bT/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT
+ /wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//
+ ACCSkSLif0zG/wCOq/6tiX2TM/7jXf8AbT//ACCJi4uWMvHJx7gBdUSTU8AAPZr9BJT/AP/ZOEJJTQQh
+ AAAAAABVAAAAAQEAAAAPAEEAZABvAGIAZQAgAFAAaABvAHQAbwBzAGgAbwBwAAAAEwBBAGQAbwBiAGUA
+ IABQAGgAbwB0AG8AcwBoAG8AcAAgAEMAUwA1AAAAAQA4QklND6AAAAAAAPhtYW5pSVJGUgAAAOw4QklN
+ QW5EcwAAAMwAAAAQAAAAAQAAAAAAAG51bGwAAAADAAAAAEFGU3Rsb25nAAAAAAAAAABGckluVmxMcwAA
+ AAFPYmpjAAAAAQAAAAAAAG51bGwAAAABAAAAAEZySURsb25nAyEH3wAAAABGU3RzVmxMcwAAAAFPYmpj
+ AAAAAQAAAAAAAG51bGwAAAAEAAAAAEZzSURsb25nAAAAAAAAAABBRnJtbG9uZwAAAAAAAAAARnNGclZs
+ THMAAAABbG9uZwMhB98AAAAATENudGxvbmcAAAAAAAA4QklNUm9sbAAAAAgAAAAAAAAAADhCSU0PoQAA
+ AAAAHG1mcmkAAAACAAAAEAAAAAEAAAAAAAAAAQAAAAA4QklNBAYAAAAAAAcACAEBAAEBAP/hJhpodHRw
+ Oi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2Vo
+ aUh6cmVTek5UY3prYzlkIj8+DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4Onht
+ cHRrPSJBZG9iZSBYTVAgQ29yZSA1LjAtYzA2MCA2MS4xMzQ3NzcsIDIwMTAvMDIvMTItMTc6MzI6MDAg
+ ICAgICAgICI+DQoJPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIy
+ LXJkZi1zeW50YXgtbnMjIj4NCgkJPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1w
+ PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczpwaG90b3Nob3A9Imh0dHA6Ly9ucy5h
+ ZG9iZS5jb20vcGhvdG9zaG9wLzEuMC8iIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVu
+ dHMvMS4xLyIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5z
+ OnN0RXZ0PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VFdmVudCMiIHht
+ bG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4
+ bXA6Q3JlYXRvclRvb2w9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiB4bXA6Q3JlYXRlRGF0
+ ZT0iMjAxMi0wMy0yMVQxMjozNzowMSswMTowMCIgeG1wOk1ldGFkYXRhRGF0ZT0iMjAxMi0wMy0yMVQx
+ ODo0ODowNiswMTowMCIgeG1wOk1vZGlmeURhdGU9IjIwMTItMDMtMjFUMTg6NDg6MDYrMDE6MDAiIHBo
+ b3Rvc2hvcDpDb2xvck1vZGU9IjMiIHBob3Rvc2hvcDpJQ0NQcm9maWxlPSJzUkdCIElFQzYxOTY2LTIu
+ MSIgZGM6Zm9ybWF0PSJpbWFnZS9qcGVnIiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOkM0NzUwQ0ZB
+ MEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0
+ MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiB4bXBNTTpPcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6
+ MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiPg0KCQkJPHBob3Rvc2hvcDpUZXh0TGF5ZXJz
+ Pg0KCQkJCTxyZGY6QmFnPg0KCQkJCQk8cmRmOmxpIHBob3Rvc2hvcDpMYXllck5hbWU9ImwiIHBob3Rv
+ c2hvcDpMYXllclRleHQ9ImwiLz4NCgkJCQkJPHJkZjpsaSBwaG90b3Nob3A6TGF5ZXJOYW1lPSJqdW1w
+ IiBwaG90b3Nob3A6TGF5ZXJUZXh0PSJqdW1wIi8+DQoJCQkJPC9yZGY6QmFnPg0KCQkJPC9waG90b3No
+ b3A6VGV4dExheWVycz4NCgkJCTxwaG90b3Nob3A6RG9jdW1lbnRBbmNlc3RvcnM+DQoJCQkJPHJkZjpC
+ YWc+DQoJCQkJCTxyZGY6bGk+eG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMTwv
+ cmRmOmxpPg0KCQkJCTwvcmRmOkJhZz4NCgkJCTwvcGhvdG9zaG9wOkRvY3VtZW50QW5jZXN0b3JzPg0K
+ CQkJPHhtcE1NOkhpc3Rvcnk+DQoJCQkJPHJkZjpTZXE+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJjcmVhdGVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYx
+ NUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEyOjM3OjAxKzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDI4MDExNzQwNzIwNjgx
+ MUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTI6Mzc6MzkrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDowMzgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxMjo1NzoxMyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjA0ODAxMTc0MDcyMDY4MTFCQTlEREYx
+ NUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjAwOjA4KzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIv
+ Pg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5p
+ aWQ6MDU4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFU
+ MTM6MDI6NDMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFj
+ aW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZl
+ ZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNjgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgx
+ MSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowNzo1NiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2Vu
+ dD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJ
+ PHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjA3ODAx
+ MTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA4OjEx
+ KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIg
+ c3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0
+ Omluc3RhbmNlSUQ9InhtcC5paWQ6MDg4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0
+ OndoZW49IjIwMTItMDMtMjFUMTM6MDg6MTgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2Jl
+ IFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkg
+ c3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowQTgwMTE3NDA3MjA2
+ ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowOTozOSswMTowMCIg
+ c3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNo
+ YW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5j
+ ZUlEPSJ4bXAuaWlkOjIyMjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIy
+ MDEyLTAzLTIxVDEzOjA5OjQ5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3No
+ b3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFj
+ dGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjMyM0RFMEEwQzIwNjgxMUJBOURE
+ RjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MTArMDE6MDAiIHN0RXZ0OnNvZnR3
+ YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+
+ DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlp
+ ZDoyNDIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQx
+ MzoxMDoyOCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNp
+ bnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVk
+ IiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI1MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODEx
+ IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEyOjQzKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50
+ PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8
+ cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjYyM0RF
+ MEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MTM6MDYr
+ MDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBz
+ dEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6
+ aW5zdGFuY2VJRD0ieG1wLmlpZDoyNzIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6
+ d2hlbj0iMjAxMi0wMy0yMVQxMzoxODo0MCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUg
+ UGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBz
+ dEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI4MjNERTBBMEMyMDY4
+ MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjE0OjA1KzAxOjAwIiBz
+ dEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hh
+ bmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNl
+ SUQ9InhtcC5paWQ6Rjc3RjExNzQwNzIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIw
+ MTItMDMtMjFUMTc6NTQrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGQTdGMTE3NDA3MjA2ODExOTQ1NzlBMzNG
+ QjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1NTo1MCswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OkZCN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3
+ OjU2OjA1KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkM3RjExNzQwNzIwNjgxMTk0NTc5QTMzRkIzNTY0Nzki
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTY6NTIrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1OUFDOURF
+ RTBCMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODozOTozOSsw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDpp
+ bnN0YW5jZUlEPSJ4bXAuaWlkOjVBQUM5REVFMEIyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3
+ aGVuPSIyMDEyLTAzLTIxVDE4OjM5OjQxKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RDI1MzFEODQwRTIwNjgx
+ MTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6NDQ6MzMrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDpEMzUzMUQ4NDBFMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxODo0NTowMiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkQ0NTMxRDg0MEUyMDY4MTE5NDU3OUEz
+ M0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjQ1OjEwKzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIv
+ Pg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5p
+ aWQ6RDU1MzFEODQwRTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFU
+ MTg6NDU6MjArMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFj
+ aW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZl
+ ZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpEODUzMUQ4NDBFMjA2ODExOTQ1NzlBMzNGQjM1NjQ3
+ OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODo0NjowMyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2Vu
+ dD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJ
+ PHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkMzNzUw
+ Q0ZBMEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjQ4OjA2
+ KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIg
+ c3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iY29udmVydGVkIiBz
+ dEV2dDpwYXJhbWV0ZXJzPSJmcm9tIGFwcGxpY2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8gaW1h
+ Z2UvanBlZyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iZGVyaXZlZCIgc3RFdnQ6cGFyYW1l
+ dGVycz0iY29udmVydGVkIGZyb20gYXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rvc2hvcCB0byBpbWFn
+ ZS9qcGVnIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDpDNDc1MENGQTBFMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxODo0ODowNiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQk8L3JkZjpTZXE+DQoJCQk8L3ht
+ cE1NOkhpc3Rvcnk+DQoJCQk8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlp
+ ZDpDMzc1MENGQTBFMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRp
+ ZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RSZWY6b3JpZ2luYWxEb2N1bWVudElE
+ PSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIi8+DQoJCTwvcmRmOkRlc2Ny
+ aXB0aW9uPg0KCTwvcmRmOlJERj4NCjwveDp4bXBtZXRhPg0KICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgPD94cGFja2V0IGVuZD0ndyc/Pv/iDFhJQ0NfUFJPRklMRQABAQAADEhMaW5vAhAAAG1u
+ dHJSR0IgWFlaIAfOAAIACQAGADEAAGFjc3BNU0ZUAAAAAElFQyBzUkdCAAAAAAAAAAAAAAABAAD21gAB
+ AAAAANMtSFAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWNw
+ cnQAAAFQAAAAM2Rlc2MAAAGEAAAAbHd0cHQAAAHwAAAAFGJrcHQAAAIEAAAAFHJYWVoAAAIYAAAAFGdY
+ WVoAAAIsAAAAFGJYWVoAAAJAAAAAFGRtbmQAAAJUAAAAcGRtZGQAAALEAAAAiHZ1ZWQAAANMAAAAhnZp
+ ZXcAAAPUAAAAJGx1bWkAAAP4AAAAFG1lYXMAAAQMAAAAJHRlY2gAAAQwAAAADHJUUkMAAAQ8AAAIDGdU
+ UkMAAAQ8AAAIDGJUUkMAAAQ8AAAIDHRleHQAAAAAQ29weXJpZ2h0IChjKSAxOTk4IEhld2xldHQtUGFj
+ a2FyZCBDb21wYW55AABkZXNjAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAEnNSR0Ig
+ SUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AABYWVogAAAAAAAA81EAAQAAAAEWzFhZWiAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAG+iAAA49QAA
+ A5BYWVogAAAAAAAAYpkAALeFAAAY2lhZWiAAAAAAAAAkoAAAD4QAALbPZGVzYwAAAAAAAAAWSUVDIGh0
+ dHA6Ly93d3cuaWVjLmNoAAAAAAAAAAAAAAAWSUVDIGh0dHA6Ly93d3cuaWVjLmNoAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlc2MAAAAAAAAALklFQyA2MTk2Ni0yLjEg
+ RGVmYXVsdCBSR0IgY29sb3VyIHNwYWNlIC0gc1JHQgAAAAAAAAAAAAAALklFQyA2MTk2Ni0yLjEgRGVm
+ YXVsdCBSR0IgY29sb3VyIHNwYWNlIC0gc1JHQgAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAA
+ ACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAsUmVm
+ ZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAdmlldwAAAAAAE6T+ABRfLgAQzxQAA+3MAAQTCwADXJ4AAAABWFlaIAAAAAAATAlWAFAAAABX
+ H+dtZWFzAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAACjwAAAAJzaWcgAAAAAENSVCBjdXJ2AAAAAAAA
+ BAAAAAAFAAoADwAUABkAHgAjACgALQAyADcAOwBAAEUASgBPAFQAWQBeAGMAaABtAHIAdwB8AIEAhgCL
+ AJAAlQCaAJ8ApACpAK4AsgC3ALwAwQDGAMsA0ADVANsA4ADlAOsA8AD2APsBAQEHAQ0BEwEZAR8BJQEr
+ ATIBOAE+AUUBTAFSAVkBYAFnAW4BdQF8AYMBiwGSAZoBoQGpAbEBuQHBAckB0QHZAeEB6QHyAfoCAwIM
+ AhQCHQImAi8COAJBAksCVAJdAmcCcQJ6AoQCjgKYAqICrAK2AsECywLVAuAC6wL1AwADCwMWAyEDLQM4
+ A0MDTwNaA2YDcgN+A4oDlgOiA64DugPHA9MD4APsA/kEBgQTBCAELQQ7BEgEVQRjBHEEfgSMBJoEqAS2
+ BMQE0wThBPAE/gUNBRwFKwU6BUkFWAVnBXcFhgWWBaYFtQXFBdUF5QX2BgYGFgYnBjcGSAZZBmoGewaM
+ Bp0GrwbABtEG4wb1BwcHGQcrBz0HTwdhB3QHhgeZB6wHvwfSB+UH+AgLCB8IMghGCFoIbgiCCJYIqgi+
+ CNII5wj7CRAJJQk6CU8JZAl5CY8JpAm6Cc8J5Qn7ChEKJwo9ClQKagqBCpgKrgrFCtwK8wsLCyILOQtR
+ C2kLgAuYC7ALyAvhC/kMEgwqDEMMXAx1DI4MpwzADNkM8w0NDSYNQA1aDXQNjg2pDcMN3g34DhMOLg5J
+ DmQOfw6bDrYO0g7uDwkPJQ9BD14Peg+WD7MPzw/sEAkQJhBDEGEQfhCbELkQ1xD1ERMRMRFPEW0RjBGq
+ EckR6BIHEiYSRRJkEoQSoxLDEuMTAxMjE0MTYxODE6QTxRPlFAYUJxRJFGoUixStFM4U8BUSFTQVVhV4
+ FZsVvRXgFgMWJhZJFmwWjxayFtYW+hcdF0EXZReJF64X0hf3GBsYQBhlGIoYrxjVGPoZIBlFGWsZkRm3
+ Gd0aBBoqGlEadxqeGsUa7BsUGzsbYxuKG7Ib2hwCHCocUhx7HKMczBz1HR4dRx1wHZkdwx3sHhYeQB5q
+ HpQevh7pHxMfPh9pH5Qfvx/qIBUgQSBsIJggxCDwIRwhSCF1IaEhziH7IiciVSKCIq8i3SMKIzgjZiOU
+ I8Ij8CQfJE0kfCSrJNolCSU4JWgllyXHJfcmJyZXJocmtyboJxgnSSd6J6sn3CgNKD8ocSiiKNQpBik4
+ KWspnSnQKgIqNSpoKpsqzysCKzYraSudK9EsBSw5LG4soizXLQwtQS12Last4S4WLkwugi63Lu4vJC9a
+ L5Evxy/+MDUwbDCkMNsxEjFKMYIxujHyMioyYzKbMtQzDTNGM38zuDPxNCs0ZTSeNNg1EzVNNYc1wjX9
+ Njc2cjauNuk3JDdgN5w31zgUOFA4jDjIOQU5Qjl/Obw5+To2OnQ6sjrvOy07azuqO+g8JzxlPKQ84z0i
+ PWE9oT3gPiA+YD6gPuA/IT9hP6I/4kAjQGRApkDnQSlBakGsQe5CMEJyQrVC90M6Q31DwEQDREdEikTO
+ RRJFVUWaRd5GIkZnRqtG8Ec1R3tHwEgFSEtIkUjXSR1JY0mpSfBKN0p9SsRLDEtTS5pL4kwqTHJMuk0C
+ TUpNk03cTiVObk63TwBPSU+TT91QJ1BxULtRBlFQUZtR5lIxUnxSx1MTU19TqlP2VEJUj1TbVShVdVXC
+ Vg9WXFapVvdXRFeSV+BYL1h9WMtZGllpWbhaB1pWWqZa9VtFW5Vb5Vw1XIZc1l0nXXhdyV4aXmxevV8P
+ X2Ffs2AFYFdgqmD8YU9homH1YklinGLwY0Njl2PrZEBklGTpZT1lkmXnZj1mkmboZz1nk2fpaD9olmjs
+ aUNpmmnxakhqn2r3a09rp2v/bFdsr20IbWBtuW4SbmtuxG8eb3hv0XArcIZw4HE6cZVx8HJLcqZzAXNd
+ c7h0FHRwdMx1KHWFdeF2Pnabdvh3VnezeBF4bnjMeSp5iXnnekZ6pXsEe2N7wnwhfIF84X1BfaF+AX5i
+ fsJ/I3+Ef+WAR4CogQqBa4HNgjCCkoL0g1eDuoQdhICE44VHhauGDoZyhteHO4efiASIaYjOiTOJmYn+
+ imSKyoswi5aL/IxjjMqNMY2Yjf+OZo7OjzaPnpAGkG6Q1pE/kaiSEZJ6kuOTTZO2lCCUipT0lV+VyZY0
+ lp+XCpd1l+CYTJi4mSSZkJn8mmia1ZtCm6+cHJyJnPedZJ3SnkCerp8dn4uf+qBpoNihR6G2oiailqMG
+ o3aj5qRWpMelOKWpphqmi6b9p26n4KhSqMSpN6mpqhyqj6sCq3Wr6axcrNCtRK24ri2uoa8Wr4uwALB1
+ sOqxYLHWskuywrM4s660JbSctRO1irYBtnm28Ldot+C4WbjRuUq5wro7urW7LrunvCG8m70VvY++Cr6E
+ vv+/er/1wHDA7MFnwePCX8Lbw1jD1MRRxM7FS8XIxkbGw8dBx7/IPci8yTrJuco4yrfLNsu2zDXMtc01
+ zbXONs62zzfPuNA50LrRPNG+0j/SwdNE08bUSdTL1U7V0dZV1tjXXNfg2GTY6Nls2fHadtr724DcBdyK
+ 3RDdlt4c3qLfKd+v4DbgveFE4cziU+Lb42Pj6+Rz5PzlhOYN5pbnH+ep6DLovOlG6dDqW+rl63Dr++yG
+ 7RHtnO4o7rTvQO/M8Fjw5fFy8f/yjPMZ86f0NPTC9VD13vZt9vv3ivgZ+Kj5OPnH+lf65/t3/Af8mP0p
+ /br+S/7c/23////bAEMAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQIC
+ AgICAgICAgICAwMDAwMDAwMDA//bAEMBAQEBAQEBAQEBAQICAQICAwMDAwMDAwMDAwMDAwMDAwMDAwMD
+ AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDA//CABEIAPoA+gMBEQACEQEDEQH/xAAdAAEAAwEBAQEB
+ AQAAAAAAAAAABwgJBgQDBQEC/8QALhAAAAQFBAEEAQMFAAAAAAAABQYHCAABAgMEMEAYOBMREhQJFRBw
+ kBY2Fyc3/8QAHQEBAAICAwEBAAAAAAAAAAAAAAUGBAcBAgMICf/EAFkRAAAEBAICDQkEAgkVAAAAAAID
+ BAUBFAYHABUREjAT1RYmthc3d5cISYkhJDQ1RWVHGGhAMSIlQTbwYZGh0TIjtHYQUYGxweHxQmOzZFV1
+ VmamOEiICTn/xAA9EgABAwIEBAIECgsBAAAAAAABEQIDIQQAMRIFQEFRBiIy8GFxE3CQgaHB0UJSohQQ
+ kbHhcsLSwyRUFQf/2gAMAwEAAhADEAAAANhyJgAAAAAAAAAAAAAAaymTRDIAAAAAAAAAAAAAANmDM0hk
+ AAAAAAAAAAAAAAGzBmaQyAAAAAAAAAAAAAADZgzNIZAAAAAAAAAAAAAABswZmkMgAAAAAAAAAAAAAA2Y
+ MzSGQAAAAADpizJwBX8AAAAAAGzBmaQyAAAAAASyTmeIqAAAAAAADZgzNIZAAAAAAOmJmOZIZAAAAAAB
+ swZmkMgAAAAA6Ysye0EZlfwAAAAADZgzNIZAAAAAOmLGnMEgAjMFfwAAAAAbMGZpDIAAAAPaWmK5EgEz
+ ApmWAPxSGQAAAADZgzNIZAAAAAPaeImYk0/ZKZg9p4gAAAADZgzNIZAAAAAAJmBMxTMAAAAAAGzBmaQy
+ AAAAAATMCZimYAAAAAANmDM0hkAAAAAAmYEzFMwAAAAAAbMGZpDIAAAAABMwJmKZgAAAAAA2YMzSGQAA
+ AAACZgTMUzAAAAAABswZmkMgAAAAAAAAAAAAAA2YMzSGQAAAAAAffLrvwxLEAAAAAABswZmkMgAAAAHf
+ HAntlte91uH83+U1t9s/h1H6JAAAAAAGzBmaQyAAAAAXnK351WmXY3xfKvPX8t1rjRPrGbYXZlWzhwAA
+ AADZgzNIZAAAAAN/imVp0NcnzzYPz6j7saZnKMvNNYfY/bOciQAAAADZgzNIZAAAAAN/SjxdiZ1tViVo
+ PvjLvaKE2hQMnwyBAAAAANmDM0hkAAAAEnGmhyhCErr+P5SjfXDslhoLattzJUr+AAAAAbMGZpDIAAAA
+ LEEMHPHpkKj6c6p/PxlP0ofY3QEfgAAAAA2YMzSGQAAAAAD6e8X9PaM/z0yfjizwAAAAAA2YMzSGQAAA
+ AAD+89XPRx2/nHcAAAAAAbMGZpDIAAAAAAAAAAAAAANmDM0hkAAAAAAAAAAAAAAGzBmaQyAAAAAAAAAA
+ AAAADZg7M4wAAAAAAAAAAAAAAFzD/9oACAECAAEFAP4b7OBl38ffBATfFsnExsbDxTIATwa95gYN3Pvh
+ WaFY4fUaQmmMoxhFEhTAs294ECuFg4QVdlIJB7ONUDAVWJZwMLNs2MPeB1Xtwgq57QvEq9Ajeh0pV2se
+ iVixXZpxsLe4Vftl5oybnus72zV7Y8kXK/Wjeyn6R7px6zn+yH//2gAIAQMAAQUA/hvETYXgkY3yiqEG
+ J8CmAcGjKOIortJqxd4bTWHlILP5ZPwucLCDKFfgCRhRcisim0TzJ7tRCAZTUaFAwa7ihKMJDVhSlVsm
+ ISNpmLAmKmSU5znuzlZ8hlPuH5T4YLHvUTenG5Vj54tlXBYWxhG4NmfemfG89X4+AbC8QlvRGx5p/ClG
+ Jiyt5G9qolVHioiVummf7H//2gAIAQEAAQUAXxfF1Bl15GuFjka4WORrhY5GuFjka4WORrhY5GuFjka4
+ WORrhY5GuFjka4WORrhY5GuFjka4WORrhY5GuFjka4WORrhY5GuFjka4WORrhY5GuFjka4WORrhY5GuF
+ jka4WORrhY5GuFjka4WORrhY/wAjqHDjewu/cb2F37jewu/cb2F37jewu/cb2F1S6Uhoy0CZLsAgcp6Y
+ ClApruN7C6qcSDsgJMpa8EHQMDgSxruN7C6pdCzRkUZX9WWw45hKjiuVruN7C6hdKQ0ZaBMl2AQOMpa8
+ EGUteCFPTAUoFNZxvYXTLpSGjLQYi6Dk8HAs+g54RlLXggylrwQXjCFmwLU9MBSgU1XG9hdLAxbGZfMR
+ dByeDm0xUGUaTUN+aWDKWvBBlLXg/QvGELNgWsJUwQId1HG9hdPKz7+ZYhNQ35pYO8i8X8oylrwfqJZ9
+ 8VEdRxvYXVTUN+aWFvDfxZnMpa8Gwcb2F1U1Dfmlhbw38WZzKWvBsHG9hdVNQ35pYW8N/FmcylrwbBxv
+ YXVTUN+aWFvDfxZnMpa8Gwcb2F1U1Dfmlhbw38WZzKWvBsHG9hd+43sLrUY1+5a2Djewume0tUNMaowc
+ K5m3bNm1YsiwZPHq13G9hdNxCfu+M51UJFT+lh7M7YFbTs5B7CHO58FNjjkTlhGNvipF1UQn68XVCl9R
+ E2O6TmnUcb2F03f9tX+ZtjHd06uv0eS8FSj8APJ+y1RjuUVOdDcsXF++w5WFNKjmvtoxcag2ajjewum7
+ +cpO1+wm3cm8R10/R5z2qvR6/wBq0/8Aazov+4/ZbauTdF9tf9xajjewukn6LqsqdX2kHCsBVLL+ygvD
+ wcoL1B1UFXWhw2WsSzOlchmOWM4e6oQco4N0ruiEjy4OPcObHJH3Ucb2F0kqdUuSKFU1G0zHkejHq9se
+ WLtz1tlQ0jxIMqlqke1hNGq43sLq0T9I98oqqlOnXcb2F1ZT9I9049Zz2Djewu/cb2F37jewu/Uf/oe/
+ /9oACAECAgY/APib57qKBzoI01HovpXjxEzwwjzO6D6zyGGWkEYEICJ16r1Xnh17aNJtHGo+4f6T83Gi
+ KMI0VceQHM/ViU2Tj+XhCvOkgkopJop9Bhn+QSo5NdT20x7qSbW1zagNLghHPllmMxzGPzu3ya9veaHm
+ 0/dINR6l4x8MgImcSpA/VjeI+ZaT+EjE5khaXO1qSATQUrnTl0Nc8XlxcwtcA9CoBogpX243S2kVJQNI
+ 9Y1fuwK8ZuY6x/QcPb/Hi9b1d9A466jLkDgmDAJFBWvtxPG1+pSvTjn4zw8Lxx/QR8GH/9oACAEDAgY/
+ APib9r2HcN0ii3W91e6jJALtIX5FyauZoOPff3KS7lICIIVrI7qejG5ud0oFNMXHcO53T3blJIHBwJGh
+ CrQxPKG/ZRENc8Q9s9wytZ3FCxGPJQXDR/daMx9oIQpXjX3947VO46Yo18Ukho1o6BfMcgMWMfc0DP8A
+ sbg7TbxiVjmNaXaWsaQ4tYATzRSrjni5XaI2GNyeKaMayi+BHEEesoFoqgoNwstsNrNBKQ10krYn643I
+ SwLqo4Uega7NriK4PbPd9obXu63YC5pTTOzISxuaS1yodWkkKDWhTi7XcbRzHbZCyMNa5wCEFXlOpPPn
+ TH/nF6g922drflErXfsONqbabnPHBF+X0ta9zWjU5XK0HSdSo5QdTfCVaAMdubRse4zQvdb62hkjox7z
+ 3jhqOkiqNABOSUzK9ib3aaQ6xkcZ3KASxxiKBEUUkoKV9eHAhADT109BxnYz08l2v4mYtZU/1/mIx2xM
+ nlg/nfx2x3jYtboHl4CoqEU5pliPdX2oY9ujwqT5CuaDP2Y2q9ltREY26UB1LUlch1461oqA48mLZ+nI
+ 8dHTLGWI3JkeOC4ywo+BD//aAAgBAQEGPwC9LQ0Xpuy1NLVdm4za1tbbcasELc2tyGsHlKiQIESV5KTI
+ 0SNMUEsoosIQFgDAIYQhCEMc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/
+ F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5u
+ tCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt
+ 93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93Mc/F5utCt93M
+ c/F5utCt93Mc/F5utCt93Mc/F5utCt93Mfr5Wf8A8muUf9aHznD/AN/PTv1z96enf5XF+Oma6HHd8+3+
+ DPi/HTNdDju+fb/Bnxfjpmuhx3fPt/gz4vx0zXQ47vn2/wAGfF+Oma6HHd8+3+DPi/HTNdDju+bM4qG9
+ Gti3tKJ0VODqWzvzm3JD22l6mq4ltVHMLS7mI1rq00ivEQI4BacAExyhQaQjTqVJL41paXWgTMyKt0Cc
+ 1ypBxWuJRDQR2tU5Ri93d+yg2Ox61IXTUImqVR6FQAbZEZg24baIVEPz4xsL0Xtb1Uxrs0lUzV5O1bTV
+ 96BKlyFKGy9rKbp1lp2m7WKYq0kEyXapVQaUnSyrm2MezeDPi/HTNdDju+bNVjeaQiWOxiJ6ckSQxpId
+ XHLmi1F3T3RelgK01wlKZE1qTUZx5oF7QBOOBKgcSokAfKfqvgpLy/KD8PpOWk/m5+kanpGR3ve65XK/
+ ZeV8B6oVOjGiZkwFtXtpShfRBDQQU4rXHtXtDQgLNUdkqmi0i092bCEqYqEWwYFCEBYINo24IaI2bwZ8
+ X46Zrocd3zZnF2p+nVr0mQInRA6Ki6ZBUbc3EONL1MtWmKgqm5xQt61PS7I6uBCmMAKEQG05cQMoaOJ5
+ TkU+WXqYh2Aiqct5Wp7e0GwtyNxCR2hwuyotrDZQSljRMakS8YyALADQgo1cAo5NFubB03UJYrXPTAzB
+ enlzgkHbFia3hkStTxdZ1PQub7TdA0joyTKqmKXQJTIEcSqdNKEmJTsidOg2bwZ8X46Zrocd3zZXFQ3o
+ 1sW9pROipwdS2d+c25Ie20vU1XEtqo5haXcxGtdWmkV4iBHALTgAmOUKDSEadSpJfGtLS60CZmRVugTm
+ uVIOK1xKIaCO1qnKMXu7v2UGx2PWpC6ahE1SqPQqADbIjMG3DbRCoiq+CkvL8oPw+k5aT+bn6RqekZHe
+ 97rlcr9l5XwHqvgpLy/KD8PpOWk/m5+kanpGR3ve65XK/ZeV8B358Y2F6L2t6qY12aSqZq8natpq+9Al
+ S5ClDZe1lN06y07TdrFMVaSCZLtUqoNKTpZVzbGPZfBnxfjpmuhx3fNkcVDejWxb2lE6KnB1LZ35zbkh
+ 7bS9TVcS2qjmFpdzEa11aaRXiIEcAtOACY5QoNIRp1Kkl5SqmbKm1q3y08iW1DTSqKqCqKrtVsDEkVvr
+ /wBlRnclT0qcmchMWYpPRLDFiIMIiQHIOBNwndPTCIlvTLaiMaiEtFUuce0Nzjb/ALQtXkpXJypHs+ur
+ SYtQmDGYE8IqdAUnbyhJyUiNsTOdL1XwUl5flB+H0nLSfzc/SNT0jI73vdcrlfsvK+A9V8FJeX5Qfh9J
+ y0n83P0jU9IyO973XK5X7LyvgO8EnM7KXUhbLVa5SmQ0pSBM/tNIX/qh2eWZppewD9krKy583liCY4JZ
+ CVIMLPSo0qFdSb8+MbC9F7W9VMa7NJVM1eTtW01fegSpchShsvaym6dZadpu1imKtJBMl2qVUGlJ0sq5
+ tjHsngz4vx0zXQ47vmxmFKHJE1FgROSoKpeW4mEGnoW5UtStpYWtA5KYLXlSnAjTCEWFOFQeASg0giBh
+ 5bylVM2VNrVvlp5EtqGmlUVUFUVXarYGJIrfX/sqM7kqelTkzkJizFJ6JYYsRBhESA5BwJWOCduRNLfF
+ a8GNTela6XbT0jc5vzs/EpXI6kaZpFpdVqMx3GSE8KBMACcspOnJToyEyYmtj8pzCVm/ON7+cSeraG97
+ j6ZyR3Dy7Vyua9ZM2rJzX4JPPKeqvgpLy/KD8PpOWk/m5+kanpGR3ve65XK/ZeV8B6r4KS8vyg/D6Tlp
+ P5ufpGp6Rkd73uuVyv2XlfAfDwSczspdSFstVrlKZDSlIEz+00hf+qHZ5Zmml7AP2SsrLnzeWIJjglkJ
+ Ugws9KjSoV1JuK4v8lWr3qpDTKeXNtQtapXq3HuawHLmNuUWetOwM7KwFUkmRKUhSRPtaw6ASk6UwC5q
+ Ztj8GfF+Oma6HHd82RtTmlogFtSIxAlElbW5CeaQY4r3QRjkqRJU6l5WwUuRgQqVgz1AU4Sk4RwIIILL
+ xWx+U5hKzfnG9/OJPVtDe9x9M5I7h5dq5XNesmbVk5r8EnnlPPyF4RMrCtV7/stSOdJIWVUfLvHadp4u
+ RTquybTJoJR/NbUMNrg2yywCYn8sMRlBoqq+CkvL8oPw+k5aT+bn6RqekZHe97rlcr9l5XwH/qL3RUWi
+ KUuS1UvUFNra3MzcWesPMUGloGhoSoWlqRAMMjApMlIJTkA0ALAAAQhhsfgz4vx0zXQ47vmzVsflOYSs
+ 35xvfziT1bQ3vcfTOSO4eXauVzXrJm1ZOa/BJ55TyQjKcn1t+3m+9/e5rSt3rlN3ofJHZvXk5KV9Wmy0
+ vK/l8vkbTVfBSXl+UH4fSctJ/Nz9I1PSMjve91yuV+y8r4D7N4M+L8dM10OO75s1bH5TmErN+cb384k9
+ W0N73H0zkjuHl2rlc16yZtWTmvwSeeU8kIynJ9bft5vvf3ua0rd65Td6HyR2b15OSlfVpstLyv5fL5G0
+ 1XwUl5flB+H0nLSfzc/SNT0jI73vdcrlfsvK+A+zeDPi/HTNdDju+bNWx+U5hKzfnG9/OJPVtDe9x9M5
+ I7h5dq5XNesmbVk5r8EnnlPJCMpyfW37eb7397mtK3euU3eh8kdm9eTkpX1abLS8r+Xy+RtNV8FJeX5Q
+ fh9Jy0n83P0jU9IyO973XK5X7LyvgPs3gz4vx0zXQ47vmzVsflOYSs35xvfziT1bQ3vcfTOSO4eXauVz
+ XrJm1ZOa/BJ55TyQjKcn1t+3m+9/e5rSt3rlN3ofJHZvXk5KV9Wmy0vK/l8vkbTVfBSXl+UH4fSctJ/N
+ z9I1PSMjve91yuV+y8r4D7N4M+L8dM10OO75s1bH5TmErN+cb384k9W0N73H0zkjuHl2rlc16yZtWTmv
+ wSeeU8kIynJ9bft5vvf3ua0rd65Td6HyR2b15OSlfVpstLyv5fL5G01XwUl5flB+H0nLSfzc/SNT0jI7
+ 3vdcrlfsvK+A+zeDPi/HTNdDju+fb/Bnxfjpmuhx3fNnMOAWIRZWjXFCHkhp/t6P0/YPBnxfjpmuhx3f
+ NkYgV/SLzSgqmagPTFB2TbRmLcOIYRNKiEQ4AOJiMO2kD1TydcO2ADrB04gAOkJYdETDNHkDD+6KP6MB
+ ILBoLDDRoj5dbTDRGItMPLGOIqCIRiQKOkQYaf5KMf7H8SP72z+DPi/HTNdDju+bJZyg76KCHqqX8g6l
+ rZJIu9JxJNjFW2JFg1itlGSkAuWKDksD1awW3HQAGIhxgDyAtzWzWmbKpEQ2KopE7kgciAp3ePmQ4rUB
+ 56TSbo8sNfSH9OjFE22f6fQo6pr84pPTKIp9ZlhS885YBvBt65MsNSI9ZUOAdJowwhDy/dh11qJb0Amw
+ 8SYAXCp6fIzQwBQDdZqGWvOKPIEEwMIGjEUVEUYh1tIRwCuWE0KWyp0i1wbRAqd2bWZQqVtikxEsAlRn
+ HmKjU8FBQglqIgCmOhDWLMEHRHDTaN1pVS01tUDmgbGdrcFKMlMuPdVEUqA9I7wUDaVLcpPhEIVJZwiY
+ CCIMRQEEUIOxA6Eb2rKjxJ4HO1U0+QQ6GhLAbDKRkL1UVZAgGB0HRgAnW0h19YI4BW0ZcGn1lN1EgCWa
+ ahVxJNAelOiOBC5AtSmnonFAoiWKADyDDCxRCKEI6QxhDY/Bnxfjpmuhx3fNk7EP9MlnGOksEAFpgYJn
+ t9GMYBjHTpjoD5cdkMGnRGLs3R/5vSwxRDcy1lUbS3M/J1l7a3uyxI3E5k5hNctsbyDQI1WZbbECnbgD
+ 28nQUZrFhCGFt0VO1hUlPIUdHZ8SmZHhe1lgeB1A5psyFBCeRE1UElCUAAha0QQDHV0awtPYJdVAACdH
+ mr15apXAoITFIU7hbdWQAeoEIAlkqHM4YYQhCAYmi0YTJqZr2q2BJTFL0svY0TO9r29C3rlQVCtUrCiS
+ nFJD1Cs7RA4ZgBiNLCEseksIQwswuCQUFYop2r0p6mAIQONTI3JkOSEGGaNYRSc1ccIEI+QMTRRh98dk
+ 8GfF+Oma6HHd82TsQxjGEIb81cNMY6PKKpKRCGHl/TGMdEP28IYQLHGJzNbvaoQCKMTdJwi4bXDRpHpM
+ DEPk0+WGj78dkCH9d1beOCbFNw8nws/n5OKBh5PLbYHGd+x/67v6ZO3+ftPhxDAscRHUZR+1QgAUYm6U
+ 6kuG1whDSPSYGIfJp/FDR9+LJf7Frj+fUzsngz4vx0zXQ47vmxlRt7QFU1WlG6lsxzmzs61UzNzgYWSd
+ Ap4eAFRbWcASDwjiNUaUCAI6dOLDqKedgpKuo1sdqsTCIiWNU0nif2c+nnIRYwjLhEThT5wi4ChGEYkx
+ 0w0YZn2r+zRQdT3ZpxEWQx1o5KW5Wlbl5QoHluTYWvphZUDKnAtGI2UTuGnW8oVAYi0hs7dl2oVqb3W0
+ o0B42xA8K4oKiVpXIh0PMgM9EYoZyDzyowCXpVRLAKGkY4w0xbrwqaYTsKlv3saGIh1NXkG72jwHg0rz
+ EKUwE3EGiP8AJR1P28MdVLaUS0kYxU4GngIkjsc7gUgg5rnKaEccgb4lC1l0QakAihoDp0+XRjshoF1G
+ I6Shbi4CJGQakej3eLrB9X0kSMZoTm1BBJFNCmwxhCETNbbY/dq+WNM1t2faSuc60wyMD3SFYrjGYqoG
+ Q5eGK6UTKHal31ShgSvKiaWelPJiAWj+TiKGvgNZ1KiRsyNubi2anKcbzBnpWVqAecqEWNWaWUa4L1So
+ 8Zh6gQARHHVCEACwAAHY/Bnxfjpmuhx3fNjcqNtrVyWnWJzcznk8qFMUq5KgOilMlRqlpa91ZVqsRp6R
+ CSXoMGYEsJQdrgCOmMXCqKwfXOpKhdTYHL3d3VmrFqgQQwAWGJpoo6hJBQYALLDqllFhgEAYBhCEMC8u
+ jH8b9n7uBQ04Y6vpddllRU25pHhlcZVGtknJCaE9KplHBOrQqNqNDCOoaUYWL7ohjDBtaXGfd8VSnokb
+ ea5ZYztGsjQAEWkJk2JvbEAdqAOMNaBUBC/xox2XwZ8X46Zrocd3zZo4/T+5H+HEYeX9/Z/Bnxfjpmuh
+ x3fNn/vx/hx/h2fwZ8X46Zrocd3z7f4M+L8dM10OO759v8GfF+Oma6HHd8+3+DPivP8A5NfrnVHOPzh+
+ vF36+f8AGf8ArT/Tttx3M+O5nx3M+O5nx3M+O5nx3M+O5nx3M+O5nx3M+O5nx3M+O5nx3M+O5nx3M+O5
+ nx3M+O5nx3M+O5nx3M+O5nx3M+O5nx3M+O5nx3M+O5nx/wBmf/Rn+z/wzx//2Q==
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+EOPEV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDg6NDMAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAANEQAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSAJMNBJ8AJP4JGQSDoRoQeQUlKSSSSUpJJJJSkk
+ ki1zTDgWnmCCDHzSUpJJJJSkkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//R1sv+mZP/AB1v/VvQ
+ kXL/AKZk/wDHW/8AVvQklKSSSSUoAuIa0STwBz4o2PU11jm2DVgHtOnP7yfD/nHf1P4tR/8ADH/ix/1T
+ 0lMa2NZbYGiAWsMeGtg0/wA1RfS22924kBrW6DmTu/8AIog/nn/1GfltSb/PWfBn/f0lNO1grscwGQOD
+ 5EblFEyf593wb/1IQ0lKT1t3vayY3GJ5TKdH8+z4/wACkpOKG13VuYTBJEOg/mvPIDf3VO1jXvqa7jcS
+ fk3cnf8ATq/rn/qLEnfzlXxd/wBSUlIMmprSz0xBfI2juRER/K9yA5rmna4EHmDodVed/PV/1X/98Qcz
+ /B/2v++JKa6SSSSlIuJ/TMb/AI6r/q2ISLif0zG/46r/AKtiSn//0tbL/pmT/wAdb/1b0JFy/wCmZP8A
+ x1v/AFb0JJSkkkklJ8P+cd/V/i1H/wAOf+LH/VOQMP8AnHf1f4tVnaN++dYDfkCXfxSUxH88/wDqM/La
+ k3+es+DP+/qW0bi7uQB9xcf+/pBoDnO7uAB/sz/5JJTXtpfbe/bAADZJ8drdNJcgOa5ji12hHKut/nLf
+ i3/qQquR/Pv+X/UtSUjALiGtEk6AeJ+aO2h9V1ZJBBdEjxg/vbUKn+er/rD8quWc1f8AGD/qbElKf9Or
+ +uf+osSd/OVfF3/UlSLQS0z9EyPucz/v6RaC5ru7Zj5jakpi7+er+D/++IOZzX/a/wC+KwWgua7u0ED+
+ 1H/kVXzOa/7X/fElNdJJJJSkXE/pmN/x1X/VsQkXE/pmN/x1X/VsSU//09bL/pmT/wAdb/1b0JFy/wCm
+ ZP8Ax1v/AFb0JJSkkkklJ8P+cd/V/i1WlVw/5x39X+LVaSUpJJJJTFrSHvd2cWx8m7VUyP59/wAv+par
+ qo3kG55BkSPwAaUlLU/z1f8AWH5Vde0ksj8124/CHt/78qVZDbGOcYAcCT5BX0lKSSSSUpVszmv+1/3x
+ WVWzOa/7X/fUlNdJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//U1sv+mZP/AB1v/VvQkXL/AKZk
+ /wDHW/8AVvQklKSSSSUyqc1lrXu4BPHmC3/vyvNc1zQ5plp4OvbTus9HqyWsrawtJInUEdyXfxSU2klX
+ +2M/cd94S+2M/cd94SUlttbWySdfzR3lUSSSSeTqfmiX2i0tIBECNfihpKWV6m4Wt1PvA9441/eCpKdN
+ gqeXETLSIHmQf++pKbySr/bG/uO+8JfbG/uO+8JKTuIaC46ACSfIKle9r7S5vEAT4wivymuY5oaRuBEy
+ O6rpKUkkkkpSLif0zG/46r/q2ISLif0zG/46r/q2JKf/1dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0
+ JJSkkkklKSSTtrsfPpsc/bG7a0uiTtbO2fzklLJKbsfJZa2l9NjbXfRrLHBx/qMjc5RNdu2xwrcfRBNn
+ tPs5/nf9H9H85JSyS139HxW5D6t1hbXhfapkSXy4Qfb/ADeiodLxq8zOoxrSQy0u3Fuh0Y+zSd37iSmu
+ ki3411LnF9VldRe5tb3tcAQCQ33uH7qi2jIdUbm02OpHNoY4s0598bUlMElaxum5GTiX5VbXFtIGxrWO
+ cbCTtipzf3Pz/pqeP0424GZcWWHKx3srZSAZlxZu3V7fU3bXpKaSSeyuyp5rtY6t45Y8Fp/zXJklKSSS
+ SUpFxP6Zjf8AHVf9WxCRcT+mY3/HVf8AVsSU/wD/1tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSk
+ kkklKWp0N766epPrcWvbjFzXDkECza5Za1ehel6fUfW3el9m/SbPpbffu2T+dtSU28C227F6Tbc822jL
+ saLHmXbdmR7d59yrV/0f6x/B3/VZKTepYWMzCoxN97MW43WPeNhO4PYWsb7fzbXJ7crpjKOosxnXPs6i
+ 1x9zQGtcS9zWfmu+la/3JwiSwyzxjYIojofL/nN+0frl3/pr/i9ZPQB/lbE+L/8Az1YrVnVcR2RZYA/a
+ /D+zD2675cf8z3Kj0zIrxM6jItBLKt27aJOrH16f2nJwjodOjBLMOONS04tfK25VkZF+H1pt9rrWtre5
+ jXmQ0g27dn7m3a36KuXXX1dfwseqxzMf0mD0WmGRFv5n0fzWrPfk9PqxcxmI619ueC1zbGgCtri7dqPp
+ /wA45WP2l023Ko6jcbmZNDA00NaC1xAdDmv/AHf0n76XD4JGUaAzF6E69OKXVHTddTh9aZVY+ttFsUta
+ 4gMBssn0o/m/7KHhZGQ3ovU722vFxtqm0E79fSa73/S+io4uXjObnVZm6tmedxfWN2x25z42/nN9yj9q
+ wqcHNw6i94vsY6kubHtaWE+p+79BNMKZY8wJVQs0dB4Mupvfb0vpl1rjZa4WtdY7VxAI+k75LMVvKy6r
+ un4WMwEWY2/1JGnuPt2n85VE1nH2KSSSSUpFxP6Zjf8AHVf9WxCRcT+mY3/HVf8AVsSU/wD/19bL/pmT
+ /wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKUmXW1h7a3uY2wbbA0wHN/df96ikkpScPI8wmSRBI2Wz
+ hGYqQsJQ4Hj7k6CpNsI51Ukcg66NHNychrjPEP3T8yRMSBz9yg6w9tFFKWQdNVYuTkdch4R+6PmZF5PG
+ gUUklGSTu3oQjAVEUFJJJILlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jqv+rYkp//0NbL/pmT/wAdb/1b
+ 0JWcrFyzl5BGPcQbrSCKnkEF79foIf2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/b
+ T/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/
+ APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/bT/8A
+ yCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/APyC
+ SkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSLif0zG/wCOq/6tiX2TM/7jXf8AbT//ACCJi4uW
+ MvHJx7gBdUSTU8AAPZr9BJT/AP/ZAP/tFvRQaG90b3Nob3AgMy4wADhCSU0EBAAAAAAAJxwBWgADGyVH
+ HAFaAAMbJUccAVoAAxslRxwBWgADGyVHHAIAAAIAAAA4QklNBCUAAAAAABCaia1dKG26IQLIy6lnBT/b
+ OEJJTQQ6AAAAAACbAAAAEAAAAAEAAAAAAAtwcmludE91dHB1dAAAAAQAAAAAUHN0U2Jvb2wBAAAAAElu
+ dGVlbnVtAAAAAEludGUAAAAAQ2xybQAAAA9wcmludFNpeHRlZW5CaXRib29sAAAAAAtwcmludGVyTmFt
+ ZVRFWFQAAAATAEMAYQBuAG8AbgAgAE0AUAAxADQAMAAgAHMAZQByAGkAZQBzAAAAOEJJTQQ7AAAAAAGy
+ AAAAEAAAAAEAAAAAABJwcmludE91dHB1dE9wdGlvbnMAAAASAAAAAENwdG5ib29sAAAAAABDbGJyYm9v
+ bAAAAAAAUmdzTWJvb2wAAAAAAENybkNib29sAAAAAABDbnRDYm9vbAAAAAAATGJsc2Jvb2wAAAAAAE5n
+ dHZib29sAAAAAABFbWxEYm9vbAAAAAAASW50cmJvb2wAAAAAAEJja2dPYmpjAAAAAQAAAAAAAFJHQkMA
+ AAADAAAAAFJkICBkb3ViQG/gAAAAAAAAAAAAR3JuIGRvdWJAb+AAAAAAAAAAAABCbCAgZG91YkBv4AAA
+ AAAAAAAAAEJyZFRVbnRGI1JsdAAAAAAAAAAAAAAAAEJsZCBVbnRGI1JsdAAAAAAAAAAAAAAAAFJzbHRV
+ bnRGI1B4bEBSAAAAAAAAAAAACnZlY3RvckRhdGFib29sAQAAAABQZ1BzZW51bQAAAABQZ1BzAAAAAFBn
+ UEMAAAAATGVmdFVudEYjUmx0AAAAAAAAAAAAAAAAVG9wIFVudEYjUmx0AAAAAAAAAAAAAAAAU2NsIFVu
+ dEYjUHJjQFkAAAAAAAA4QklNA+0AAAAAABAASAAAAAEAAgBIAAAAAQACOEJJTQQmAAAAAAAOAAAAAAAA
+ AAAAAD+AAAA4QklNBA0AAAAAAAQAAAB4OEJJTQQZAAAAAAAEAAAAHjhCSU0D8wAAAAAACQAAAAAAAAAA
+ AQA4QklNJxAAAAAAAAoAAQAAAAAAAAACOEJJTQP1AAAAAABIAC9mZgABAGxmZgAGAAAAAAABAC9mZgAB
+ AKGZmgAGAAAAAAABADIAAAABAFoAAAAGAAAAAAABADUAAAABAC0AAAAGAAAAAAABOEJJTQP4AAAAAABw
+ AAD/////////////////////////////A+gAAAAA/////////////////////////////wPoAAAAAP//
+ //////////////////////////8D6AAAAAD/////////////////////////////A+gAADhCSU0EAAAA
+ AAAAAgAEOEJJTQQCAAAAAAAOAAAAAAAAAAAAAAAAAAA4QklNBDAAAAAAAAcBAQEBAQEBADhCSU0ELQAA
+ AAAABgABAAAADThCSU0ECAAAAAAAGgAAAAEAAAJAAAACQAAAAAIAAA+gAQAAD7AAOEJJTQQeAAAAAAAE
+ AAAAADhCSU0EGgAAAAADRwAAAAYAAAAAAAAAAAAAAPoAAAD6AAAACQBwAHUAbABsAF8AYgBvAHQAaAAA
+ AAEAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAA+gAAAPoAAAAAAAAAAAAAAAAAAAAAAQAAAAAA
+ AAAAAAAAAAAAAAAAAAAQAAAAAQAAAAAAAG51bGwAAAACAAAABmJvdW5kc09iamMAAAABAAAAAAAAUmN0
+ MQAAAAQAAAAAVG9wIGxvbmcAAAAAAAAAAExlZnRsb25nAAAAAAAAAABCdG9tbG9uZwAAAPoAAAAAUmdo
+ dGxvbmcAAAD6AAAABnNsaWNlc1ZsTHMAAAABT2JqYwAAAAEAAAAAAAVzbGljZQAAABIAAAAHc2xpY2VJ
+ RGxvbmcAAAAAAAAAB2dyb3VwSURsb25nAAAAAAAAAAZvcmlnaW5lbnVtAAAADEVTbGljZU9yaWdpbgAA
+ AA1hdXRvR2VuZXJhdGVkAAAAAFR5cGVlbnVtAAAACkVTbGljZVR5cGUAAAAASW1nIAAAAAZib3VuZHNP
+ YmpjAAAAAQAAAAAAAFJjdDEAAAAEAAAAAFRvcCBsb25nAAAAAAAAAABMZWZ0bG9uZwAAAAAAAAAAQnRv
+ bWxvbmcAAAD6AAAAAFJnaHRsb25nAAAA+gAAAAN1cmxURVhUAAAAAQAAAAAAAG51bGxURVhUAAAAAQAA
+ AAAAAE1zZ2VURVhUAAAAAQAAAAAABmFsdFRhZ1RFWFQAAAABAAAAAAAOY2VsbFRleHRJc0hUTUxib29s
+ AQAAAAhjZWxsVGV4dFRFWFQAAAABAAAAAAAJaG9yekFsaWduZW51bQAAAA9FU2xpY2VIb3J6QWxpZ24A
+ AAAHZGVmYXVsdAAAAAl2ZXJ0QWxpZ25lbnVtAAAAD0VTbGljZVZlcnRBbGlnbgAAAAdkZWZhdWx0AAAA
+ C2JnQ29sb3JUeXBlZW51bQAAABFFU2xpY2VCR0NvbG9yVHlwZQAAAABOb25lAAAACXRvcE91dHNldGxv
+ bmcAAAAAAAAACmxlZnRPdXRzZXRsb25nAAAAAAAAAAxib3R0b21PdXRzZXRsb25nAAAAAAAAAAtyaWdo
+ dE91dHNldGxvbmcAAAAAADhCSU0EKAAAAAAADAAAAAI/8AAAAAAAADhCSU0EFAAAAAAABAAAACM4QklN
+ BAwAAAAADS0AAAABAAAAoAAAAKAAAAHgAAEsAAAADREAGAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSAJMNBJ8AJP4JGQSDoRoQeQUlKSSSSUpJJJJSkk
+ ki1zTDgWnmCCDHzSUpJJJJSkkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//R1sv+mZP/AB1v/VvQ
+ kXL/AKZk/wDHW/8AVvQklKSSSSUoAuIa0STwBz4o2PU11jm2DVgHtOnP7yfD/nHf1P4tR/8ADH/ix/1T
+ 0lMa2NZbYGiAWsMeGtg0/wA1RfS22924kBrW6DmTu/8AIog/nn/1GfltSb/PWfBn/f0lNO1grscwGQOD
+ 5EblFEyf593wb/1IQ0lKT1t3vayY3GJ5TKdH8+z4/wACkpOKG13VuYTBJEOg/mvPIDf3VO1jXvqa7jcS
+ fk3cnf8ATq/rn/qLEnfzlXxd/wBSUlIMmprSz0xBfI2juRER/K9yA5rmna4EHmDodVed/PV/1X/98Qcz
+ /B/2v++JKa6SSSSlIuJ/TMb/AI6r/q2ISLif0zG/46r/AKtiSn//0tbL/pmT/wAdb/1b0JFy/wCmZP8A
+ x1v/AFb0JJSkkkklJ8P+cd/V/i1H/wAOf+LH/VOQMP8AnHf1f4tVnaN++dYDfkCXfxSUxH88/wDqM/La
+ k3+es+DP+/qW0bi7uQB9xcf+/pBoDnO7uAB/sz/5JJTXtpfbe/bAADZJ8drdNJcgOa5ji12hHKut/nLf
+ i3/qQquR/Pv+X/UtSUjALiGtEk6AeJ+aO2h9V1ZJBBdEjxg/vbUKn+er/rD8quWc1f8AGD/qbElKf9Or
+ +uf+osSd/OVfF3/UlSLQS0z9EyPucz/v6RaC5ru7Zj5jakpi7+er+D/++IOZzX/a/wC+KwWgua7u0ED+
+ 1H/kVXzOa/7X/fElNdJJJJSkXE/pmN/x1X/VsQkXE/pmN/x1X/VsSU//09bL/pmT/wAdb/1b0JFy/wCm
+ ZP8Ax1v/AFb0JJSkkkklJ8P+cd/V/i1WlVw/5x39X+LVaSUpJJJJTFrSHvd2cWx8m7VUyP59/wAv+par
+ qo3kG55BkSPwAaUlLU/z1f8AWH5Vde0ksj8124/CHt/78qVZDbGOcYAcCT5BX0lKSSSSUpVszmv+1/3x
+ WVWzOa/7X/fUlNdJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//U1sv+mZP/AB1v/VvQkXL/AKZk
+ /wDHW/8AVvQklKSSSSUyqc1lrXu4BPHmC3/vyvNc1zQ5plp4OvbTus9HqyWsrawtJInUEdyXfxSU2klX
+ +2M/cd94S+2M/cd94SUlttbWySdfzR3lUSSSSeTqfmiX2i0tIBECNfihpKWV6m4Wt1PvA9441/eCpKdN
+ gqeXETLSIHmQf++pKbySr/bG/uO+8JfbG/uO+8JKTuIaC46ACSfIKle9r7S5vEAT4wivymuY5oaRuBEy
+ O6rpKUkkkkpSLif0zG/46r/q2ISLif0zG/46r/q2JKf/1dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0
+ JJSkkkklKSSTtrsfPpsc/bG7a0uiTtbO2fzklLJKbsfJZa2l9NjbXfRrLHBx/qMjc5RNdu2xwrcfRBNn
+ tPs5/nf9H9H85JSyS139HxW5D6t1hbXhfapkSXy4Qfb/ADeiodLxq8zOoxrSQy0u3Fuh0Y+zSd37iSmu
+ ki3411LnF9VldRe5tb3tcAQCQ33uH7qi2jIdUbm02OpHNoY4s0598bUlMElaxum5GTiX5VbXFtIGxrWO
+ cbCTtipzf3Pz/pqeP0424GZcWWHKx3srZSAZlxZu3V7fU3bXpKaSSeyuyp5rtY6t45Y8Fp/zXJklKSSS
+ SUpFxP6Zjf8AHVf9WxCRcT+mY3/HVf8AVsSU/wD/1tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSk
+ kkklKWp0N766epPrcWvbjFzXDkECza5Za1ehel6fUfW3el9m/SbPpbffu2T+dtSU28C227F6Tbc822jL
+ saLHmXbdmR7d59yrV/0f6x/B3/VZKTepYWMzCoxN97MW43WPeNhO4PYWsb7fzbXJ7crpjKOosxnXPs6i
+ 1x9zQGtcS9zWfmu+la/3JwiSwyzxjYIojofL/nN+0frl3/pr/i9ZPQB/lbE+L/8Az1YrVnVcR2RZYA/a
+ /D+zD2675cf8z3Kj0zIrxM6jItBLKt27aJOrH16f2nJwjodOjBLMOONS04tfK25VkZF+H1pt9rrWtre5
+ jXmQ0g27dn7m3a36KuXXX1dfwseqxzMf0mD0WmGRFv5n0fzWrPfk9PqxcxmI619ueC1zbGgCtri7dqPp
+ /wA45WP2l023Ko6jcbmZNDA00NaC1xAdDmv/AHf0n76XD4JGUaAzF6E69OKXVHTddTh9aZVY+ttFsUta
+ 4gMBssn0o/m/7KHhZGQ3ovU722vFxtqm0E79fSa73/S+io4uXjObnVZm6tmedxfWN2x25z42/nN9yj9q
+ wqcHNw6i94vsY6kubHtaWE+p+79BNMKZY8wJVQs0dB4Mupvfb0vpl1rjZa4WtdY7VxAI+k75LMVvKy6r
+ un4WMwEWY2/1JGnuPt2n85VE1nH2KSSSSUpFxP6Zjf8AHVf9WxCRcT+mY3/HVf8AVsSU/wD/19bL/pmT
+ /wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKUmXW1h7a3uY2wbbA0wHN/df96ikkpScPI8wmSRBI2Wz
+ hGYqQsJQ4Hj7k6CpNsI51Ukcg66NHNychrjPEP3T8yRMSBz9yg6w9tFFKWQdNVYuTkdch4R+6PmZF5PG
+ gUUklGSTu3oQjAVEUFJJJILlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jqv+rYkp//0NbL/pmT/wAdb/1b
+ 0JWcrFyzl5BGPcQbrSCKnkEF79foIf2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/b
+ T/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/
+ APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/bT/8A
+ yCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/APyC
+ SkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSLif0zG/wCOq/6tiX2TM/7jXf8AbT//ACCJi4uW
+ MvHJx7gBdUSTU8AAPZr9BJT/AP/ZADhCSU0EIQAAAAAAVQAAAAEBAAAADwBBAGQAbwBiAGUAIABQAGgA
+ bwB0AG8AcwBoAG8AcAAAABMAQQBkAG8AYgBlACAAUABoAG8AdABvAHMAaABvAHAAIABDAFMANQAAAAEA
+ OEJJTQ+gAAAAAAD4bWFuaUlSRlIAAADsOEJJTUFuRHMAAADMAAAAEAAAAAEAAAAAAABudWxsAAAAAwAA
+ AABBRlN0bG9uZwAAAAAAAAAARnJJblZsTHMAAAABT2JqYwAAAAEAAAAAAABudWxsAAAAAQAAAABGcklE
+ bG9uZwMhB98AAAAARlN0c1ZsTHMAAAABT2JqYwAAAAEAAAAAAABudWxsAAAABAAAAABGc0lEbG9uZwAA
+ AAAAAAAAQUZybWxvbmcAAAAAAAAAAEZzRnJWbExzAAAAAWxvbmcDIQffAAAAAExDbnRsb25nAAAAAAAA
+ OEJJTVJvbGwAAAAIAAAAAAAAAAA4QklND6EAAAAAABxtZnJpAAAAAgAAABAAAAABAAAAAAAAAAEAAAAA
+ OEJJTQQGAAAAAAAHAAgBAQABAQD/4SPOaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLwA8P3hwYWNr
+ ZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pg0KPHg6eG1wbWV0YSB4
+ bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS4wLWMwNjAgNjEu
+ MTM0Nzc3LCAyMDEwLzAyLzEyLTE3OjMyOjAwICAgICAgICAiPg0KCTxyZGY6UkRGIHhtbG5zOnJkZj0i
+ aHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+DQoJCTxyZGY6RGVzY3Jp
+ cHRpb24gcmRmOmFib3V0PSIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIg
+ eG1sbnM6cGhvdG9zaG9wPSJodHRwOi8vbnMuYWRvYmUuY29tL3Bob3Rvc2hvcC8xLjAvIiB4bWxuczpk
+ Yz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMu
+ YWRvYmUuY29tL3hhcC8xLjAvbW0vIiB4bWxuczpzdEV2dD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAv
+ MS4wL3NUeXBlL1Jlc291cmNlRXZlbnQjIiB4bWxuczpzdFJlZj0iaHR0cDovL25zLmFkb2JlLmNvbS94
+ YXAvMS4wL3NUeXBlL1Jlc291cmNlUmVmIyIgeG1wOkNyZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3Ag
+ Q1M1IE1hY2ludG9zaCIgeG1wOkNyZWF0ZURhdGU9IjIwMTItMDMtMjFUMTI6Mzc6MDErMDE6MDAiIHht
+ cDpNZXRhZGF0YURhdGU9IjIwMTItMDMtMjFUMTg6NDg6NDMrMDE6MDAiIHhtcDpNb2RpZnlEYXRlPSIy
+ MDEyLTAzLTIxVDE4OjQ4OjQzKzAxOjAwIiBwaG90b3Nob3A6Q29sb3JNb2RlPSIzIiBwaG90b3Nob3A6
+ SUNDUHJvZmlsZT0ic1JHQiBJRUM2MTk2Ni0yLjEiIGRjOmZvcm1hdD0iaW1hZ2UvanBlZyIgeG1wTU06
+ SW5zdGFuY2VJRD0ieG1wLmlpZDowODE1QUExODBGMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgeG1wTU06
+ RG9jdW1lbnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgeG1wTU06
+ T3JpZ2luYWxEb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODEx
+ Ij4NCgkJCTxwaG90b3Nob3A6VGV4dExheWVycz4NCgkJCQk8cmRmOkJhZz4NCgkJCQkJPHJkZjpsaSBw
+ aG90b3Nob3A6TGF5ZXJOYW1lPSJwdWxsIGJvdGgiIHBob3Rvc2hvcDpMYXllclRleHQ9InB1bGwgYm90
+ aCIvPg0KCQkJCTwvcmRmOkJhZz4NCgkJCTwvcGhvdG9zaG9wOlRleHRMYXllcnM+DQoJCQk8eG1wTU06
+ SGlzdG9yeT4NCgkJCQk8cmRmOlNlcT4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImNyZWF0ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEi
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTI6Mzc6MDErMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowMjgwMTE3NDA3MjA2ODExQkE5RERGMTVB
+ NUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMjozNzozOSswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OjAzODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEy
+ OjU3OjEzKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDQ4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEi
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDA6MDgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNTgwMTE3
+ NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowMjo0Mysw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDpp
+ bnN0YW5jZUlEPSJ4bXAuaWlkOjA2ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3
+ aGVuPSIyMDEyLTAzLTIxVDEzOjA3OjU2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDc4MDExNzQwNzIwNjgx
+ MUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDg6MTErMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDowODgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxMzowODoxOCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjBBODAxMTc0MDcyMDY4MTFCQTlEREYx
+ NUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA5OjM5KzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIv
+ Pg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5p
+ aWQ6MjIyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFU
+ MTM6MDk6NDkrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFj
+ aW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZl
+ ZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyMzIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgx
+ MSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0i
+ QWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJk
+ ZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI0MjNERTBB
+ MEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEwOjI4KzAx
+ OjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RF
+ dnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omlu
+ c3RhbmNlSUQ9InhtcC5paWQ6MjUyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0Ondo
+ ZW49IjIwMTItMDMtMjFUMTM6MTI6NDMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBo
+ b3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RF
+ dnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyNjIzREUwQTBDMjA2ODEx
+ QkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMzowNiswMTowMCIgc3RF
+ dnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5n
+ ZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlE
+ PSJ4bXAuaWlkOjI3MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEy
+ LTAzLTIxVDEzOjE4OjQwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3Ag
+ Q1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlv
+ bj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjgyM0RFMEEwQzIwNjgxMUJBOURERjE1
+ QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6MTQ6MDUrMDE6MDAiIHN0RXZ0OnNvZnR3
+ YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+
+ DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlp
+ ZDpGNzdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQx
+ Nzo1NCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkZBN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjU1OjUwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkI3RjExNzQw
+ NzIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTY6MDUrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDpGQzdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxNzo1Njo1MiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhv
+ dG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2
+ dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjUwOUZENDIxMDkyMDY4MTE5
+ NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjA2OjAxKzAxOjAwIiBzdEV2
+ dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdl
+ ZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9
+ InhtcC5paWQ6NTE5RkQ0MjEwOTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTIt
+ MDMtMjFUMTg6MTA6MTIrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1MjlGRDQyMTA5MjA2ODExOTQ1NzlBMzNG
+ QjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoxMDoyMyswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OjU2OUZENDIxMDkyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4
+ OjEyOjA4KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RUExNzdEQ0MwRTIwNjgxMTk0NTc5QTMzRkIzNTY0Nzki
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6NDY6NDArMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpBQzU5QjEw
+ QTBGMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODo0ODo0Misw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImNvbnZlcnRlZCIgc3RF
+ dnQ6cGFyYW1ldGVycz0iZnJvbSBhcHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRvIGltYWdl
+ L2pwZWciLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImRlcml2ZWQiIHN0RXZ0OnBhcmFtZXRl
+ cnM9ImNvbnZlcnRlZCBmcm9tIGFwcGxpY2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8gaW1hZ2Uv
+ anBlZyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9
+ InhtcC5paWQ6MDgxNUFBMTgwRjIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTIt
+ MDMtMjFUMTg6NDg6NDMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJPC9yZGY6U2VxPg0KCQkJPC94bXBN
+ TTpIaXN0b3J5Pg0KCQkJPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6
+ QUM1OUIxMEEwRjIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6
+ MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0UmVmOm9yaWdpbmFsRG9jdW1lbnRJRD0i
+ eG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIvPg0KCQk8L3JkZjpEZXNjcmlw
+ dGlvbj4NCgk8L3JkZjpSREY+DQo8L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAog
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ IAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDw/eHBhY2tldCBl
+ bmQ9J3cnPz7/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkABgAx
+ AABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLUhQICAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAA
+ AGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFlaAAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAA
+ ABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVkAAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAA
+ ABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJDAAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAA
+ CAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBIZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAA
+ AAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAAB
+ FsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAA
+ GNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAA
+ AAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBz
+ cGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFj
+ ZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcg
+ Q29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRp
+ dGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk/gAU
+ Xy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQAAAAVx/nbWVhcwAAAAAAAAABAAAAAAAA
+ AAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQgY3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAo
+ AC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQByAHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8
+ AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFu
+ AXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJn
+ AnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOu
+ A7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRxBH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJ
+ BVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9
+ B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRghaCG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmP
+ CaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrcCvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxD
+ DFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3DDd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9e
+ D3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RETETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLj
+ EwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbW
+ FvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7
+ G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAV
+ IEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVo
+ JZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2
+ K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGC
+ Mbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTYNRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQ
+ OIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+i
+ P+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7
+ R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/d
+ UCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRCVI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjL
+ WRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJ
+ Ypxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xX
+ bK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4
+ d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyBfOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIw
+ gpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gEiGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/
+ jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQglIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/Jpo
+ mtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDYoUehtqImopajBqN2o+akVqTHpTilqaYapoum/adu
+ p+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4trqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUT
+ tYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NY
+ w9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/
+ 0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM
+ 4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/
+ 8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26/kv+3P9t////2wBDAAEBAQEB
+ AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgMDAwMDAwMDAwP/
+ 2wBDAQEBAQEBAQEBAQECAgECAgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD
+ AwMDAwMDAwP/wgARCAD6APoDAREAAhEBAxEB/8QAHQABAAMBAQEBAQEAAAAAAAAAAAYHCQgFBAMCAf/E
+ ADIQAAEBBwEHAwMEAwEAAAAAAAYFAAIDEwQHCAEgQBQVGDgJMBESEBYXcJAmGSc3KDn/xAAcAQEAAgID
+ AQAAAAAAAAAAAAAABQYDBAIHCAH/xABdEQAABAQCBgYFBggHCREAAAADBBQFAQIVBhMHABESFiYYRWUX
+ RwhoITG2N3cgMNWXSYlAQZEiIyQ0NRBRYXGBJTbwobHRMkJTtHbhUnKCojNDY2RVdVZmOEiIOf/EAEMS
+ AAIABAQDBQQDDAsAAAAAAAECABEDBCExEgVBYRNRcSIyBkCBkRSxUhVwkMHRQmKCsiPDNAcQ8KHhwtIz
+ k7OUFv/aAAwDAQACEAMQAAAA2HKmAAAAAAAAAAAAAABrKZNFMgAAAAAAAAAAAAAA2YMzSmQAAAAAAAAA
+ AAAAAbMGZpTIAAAAAAAAAAAAAANmDM0pkAAAAAAAAAAAAAAGzBmaUyAAAAAAAAAAAAAADZgzNKZAAAPt
+ LMJmQwhhGQAD7T7TqUo0+Ir8AAAGzBmaUyAACwD2S8yGAmZxmAAXMTMmZDAV+VmfEAADZgzNKZAAB0yC
+ ZkMBMzjMAAuYmZMyGAmZzMQwAAGzBmaUyAADpkEzIYCZnGYABcxMyZkMBMzmYhgAANmDM0pkAAHTIJmQ
+ wEzKZIyV+Dow+M9kmZDATM5mIYAADZgzNKZAAB0ye0eyeMD2SGEMKZB2YQw9o9k8YHsnMxDAAAbMGZpT
+ IAAOmSZgAEMIYUyDswhhMwADmYhgAANmDM0pkAAHTJMwADxisimQdmHjHsgAHMxDAAAbMGZpTIAAOmSZ
+ gAApkpkHZgAABzMQwAAGzBmaUyAADoAswAAHOZX4OpiTAAA5NPFAABswZmlMgAAsAv8APtABGTlkAsA6
+ MAAIYczAAAGzBmaUyAAAdMkzABzMQwAHTJMwAczEMAAANmDM0pkAAAAAAAAAAAAAAGzBmaUyAAAAAAAA
+ AAAAAADZgzNKZAAAAAJKemQclxEQACXERAAAANmDM0pkAAAsg6RKUPANLyafceJ/LFtvxz52kIcZN8yd
+ 9Ge5rmY1FMgAAA2YMzSmQAADv8sI7oM7juf7wgU51ZjFYenNioHtofK+fphk/GhezcjTYo8cxvAAABsw
+ ZmlMgAAGgPPX++To+k2nYs8duA7lyaFdyFTxqt3nbWmrd9fy+D/PnL4YfsfIbbr+uuhbfz15bHvWnAAA
+ BswZmlMgAAHf51XmjeGrv5b66+Zab3axHcmlyHM9b95V/tz0OOeEZ4qXYZGkN+qzeOuMBqXob5Iu9clc
+ c4AAA2YMzSmQAACwCPngfeHr2fouSXzyb9MhUQAP4wyPgUz0x4FL9NfnglAAAABswZmlMgAAAAH95NP3
+ 7r5ikt98lftswn88Njwad6TjVB9c/PpWUAAAAAbMGZpTIAAAAAB+21ASC6+YvFqvf3xxV+AAAAAAGzBm
+ aUyAAAAAAAAAAAAAADZgzNKZAAAAAAAAAAAAAABswZmlMgAAAAAAAAAAAAAA2YJmQwAAAAAAAAAAAAAA
+ HZh//9oACAECAAEFAP2rdXddGlvtrprprpprrrq7q7vftr7V0Bxyo4CC3DQnltVpoUCp4aG+trVPDp42
+ 66O6aucmq+Deo4rtHGSKqBSR6Z2EiqbvtVymdd/k6+77Vbrv8nW3NOYqaZEoI322oNQplSoaR6V+nj7l
+ pHjS6PRIUk50XivOR0B2NQVSI7UxpbVg67VVdIO6w6lRQnK2LRj0mpU0mEpQaejeR3oSjqnuvvvxH9z0
+ 11d1TSeppWoa+iUHJbS2ltLaW0aJBpoakVuaNUVMeqibvCjRYD6WXvuNS1NLWw/g0TWHCdVC2lp2rFCr
+ r4m90lbVUMSAcPu0yis16m/+h/8A/9oACAEDAAEFAP2rXYsN7TjKVnH3Yjr77sN2HFhxd71iOaRBdUqa
+ pJ+61NtVyug2vAlyuVkXnVbT2vtks1qunbq/HecqPySP/ccMioIpEm3FQVQiSVmLX3MB4+j6Bx2jRY2u
+ tjbSR5g9Gj/4NtdVPfZgOc0Zam/mwOYqOUUPiJa9TLCTuT6UncYSPXDCTKPfZPhVCZdyMmlyDdCKhp3G
+ sO3kioI8Q3kh1iKF3XqRegJLxcxRQi4dcEqKuRwbjQq4Nhl0ampqejp9ziQ4cVw1sYhruhSJEwdUcW3F
+ txbcW3FsmUiks1YVYCoiMkoqUhUm716dQqlMd46U1Sy6irg1WcTq1K7V10cEx5XFfQaEB4SpN7IBhBKK
+ JVxZpoq0GW1FAen/AEP/AP/aAAgBAQABBQC/l/L6o19eo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo
+ 3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo
+ 3IVuo3IVuo3IVuo3IVuo3IVuo3IVuo3IVvyPcNsje4Xf8je4Xf8AI3uF3/I3uF3/ACN7hd/yN7hdugTV
+ FVjkNmi4fgCYpAggd5R6APlywFGQ7A2aBNUVWOuDhCM1SmFwEROVLcqkQvNLbEgQ/wCjkb3C7SJbYkWk
+ WgCFoVNiUakMOoc63hmh8NcMlGpG1bVN40YvCh8uQyUakM4h+65eFD5ch62aLoKcpJqijKO3kb3C7Q6h
+ zreGaHw1wyUakMOoc63hmh8NcMlGpG1bVN40YvCh8uQyUakM4h+65eFD5chko1Ia49NwVw9vI3uF2h1D
+ nW8M0Phrhko1IYdQ51vDND4a4ZKNSNq2qbxoxeFD5chko1IZxD91y8KHy5DJRqQ1x6bgrh7eRvcLtDqH
+ Ot4ZofDXDJRqQw6hzreGaHw1wyUakMOWzh1opckLfCCT6VVm6RJThgRqkaDeFD5chko1IZxD91y8KHy5
+ DJRqQ1x6bgrh7eRvcLtDqHOt4WBFU6Qko1IbUIqh8eLAiqdISUakMOoc63l703lZP9CUakM4h+65cMIq
+ q+hJRqQyiEVSVXXDCKqvoSUakNcem4K4e3kb3C7Q6hzreEo1IYlGpDEo1IYlGpDEo1IYdQ51vL3pvKyf
+ 6Eo1IZxD91wlGpDEo1IYlGpDEo1IYlGpDXHpuCuHt5G9wu0Ooc63hKNSGJRqQxKNSGJRqQxKNSG1CKof
+ Hr3pvKyf6Eo1IZRCKpKriUakMSjUhiUakMSjUhiUakNcem4K4e3kb3C7Q6hzreEo1IYlGpDEo1IYlGpD
+ Eo1IYlGpDXvTeVk/0JRqQxKNSGJRqQxKNSGJRqQxKNSGJRqQ1x6bgrh7eRvcLtBPCrgUSjUhiUakMSjU
+ hiUakMSjUhiUakNdGNH0PPon0UdbDSUakMSjUhiUakMSjUhiUakMSjUhiNTpVoh28je4XaC1tFoKJTTE
+ 5STiUakMSjUhiUakMSjUhrjVKKJv/ULW0WgoiUakMSjUhiUakMSjUhiUakMeLQog1XoZG9wu2Ooc63hK
+ NSGJRqQxKNSGJRqQ1x6bgrh7A6hzreEo1IYlGpDEo1IYlGpDXHpuCuH6GRvcLv8Akb3C7/kb3C+mKhpc
+ cqiNbO4RFFaCAHEcT2SYAOAul9LI3uF27VWnNr0FqX488qlRFt/jrdy5dwROzx4bXR8cYETWvyUxM01/
+ DnxeYLtqZXb8Yt2sMsgrMD9nMcrw35qLwYjX4sck4DYmU6mG3ixYvPYdDz8xnu1kIR3hx+uzYdR9HI3u
+ F2/Gl3Q/li5v9jQhSU1N5KsY/wD0gsTpr/YjipD0dtBw7jUJEQCXizwQJCMzsOkqqqEeLnEAgXzfEnxd
+ LCvWCqsVFC9B8qR0Zjlbe9WUzbxmejkb3C7fjR0/6f5ZVf2QjEF53yQY0JtVB8jVjoWjnkDxX01/EXx1
+ ZQhRIniq8eLr0Ozii7q/4q8F3dXcYPF3RRICFympbyxUcWqIblQXoXi09HI3uF2/Gl3Q3Oz2CrY3iQMs
+ 7h0t/FDyJDtErBmaCoH33tjlgo21FPhq1ps41O19qLpZxQl23OPOYC3ZYXu3nBEKrdY3ZGFOOBZkRkra
+ u64rlPloo5MV5HlYpEWMno5G9wu3bS6R3Z4oKyleNyXTXXTWlV4sFqeop6p34N8G+DfBvg0TWHCdq1l3
+ RokWJGe9PI3uF9Nx9+G9RrjzrQY0God+LPauuO1i3BhNHqo9S96uRvcL6sGojU78Mh10hVVfU1b3r5G9
+ wu/5G9wu/wCRvcLv9x/9h7//AP/aAAgBAgIGPwD71aJjOPKYkRjEhnGIl7WWlhONtUDBgs/iI8kNQZZ0
+ 5ZfoAxZ9NANRx9xENbss6YGX6AP0xRFNAJrj8fZmbWJjhxPdHzs06OjVnjL4Zwl6ZdEvp5zkT+CPnXKd
+ GSnPGTSlw5xaVgPFUqkn3BgPojZh2hPpEZQ68v3YjbRxn/iWHXl+7EbahGZH6whQSOlUY6e2Qln8RGdP
+ 4n8UVDQKyWU5mWc/xRVt6rqHTPsyBkPj7GKBrP8ALz8szL4ZQu20nKkDI+YNnq7DiTl3YR0a+5u1uB4V
+ AMgeBkWIw7AMe0RbWPzBApmeqWefCfPtiyqmuV6IGEpzkQe3DKMorXgu3Sq0tMh5SABOc5nLhLvhLq9u
+ 2r1VynPhlMkkmXAYYwtzSrtSugPMOMsuIIPMH4wl3eXbVqy5TngRlMkkmXDKRhabsVdTNWGMu2Y4g94y
+ zhri/wB3LU9MtJ4yyzLHDgBLvivR29yVcjxMADhPITMs4Z6jEuTiTn7ICpkRC07sdWj2/lD38ffGq1rA
+ niMiO8RlGUZRlGUGrXqKlMcTDUtuSZ+uRh7h+ODVuKpdz2+0CpRqFXHEGULS3JNS/XGfvHGBVtqqunL8
+ P9BeowVBxOENSsFFSr9b8kd3bHUuqxY9nAdw9sFW1rMjjs/CIK3FrquuBHlPM4/RBNxWPT4KMAPd9xD/
+ 2gAIAQMCBj8A+9WuVcELnyj/AF1+MB0aanjBZzJRBNNwQOz2taWr9oVJlyBAJ+JEetqtSpNqL1tPKSOR
+ 9EfxBihu1KuVuyxGoZyNyyH+zCPUpvLhqgpJ4Z4y1JUJ+Mh/UxR3ajWK3bOQWGf8QyfqgDujcmvbhn6d
+ YATM5ArM4nh7NRofLuVcHxiWlZcGxmJ8MJR/5fRcfaXzHR8g065ynPVPTxnLLGLj0wof7Sp2wrnAadBZ
+ VwM5zm4wl2wfTFslf7SFSqhmgChqQcvjqJl4DLDOUeoduZj0LSyVVHNmpMx95aXuj+ZbT8tS4/46keaL
+ WuMQHM+751xHrWoT4RTGPDClVJx5Ra1gcOoZ/wDdcR62uFYgojkHsIoMc+WcV6io4vrSlT6+A0lmD4pI
+ 4gmmxlISmBHku/8AbX/PFlT3ZaxauGK6FDeQqDOZH1hFhvG329V7W4PhEgGA1MpZhOQAKmeJ4extulPb
+ bb7X0yFY016mUgDUA1ylhIHLCK/rS+tUrq7EF6YJoNSkF6ZA8VMBVUAnEEBiWM5jcdq9EWtHd6jDq1WZ
+ S7LMal1pSRyWAkGZiFwJRso3z1WNnR3vaYQ0uoQEl08Q2gz8n1Rnyj1Rt67WlUbm1QljUI6fUVlwGk6p
+ ap5ico80bb6bf0/b3VhSNQVOox/apUepUK6dJVSC4E2FQEDy44XGwemPTtDa7KuCKhQrMhsGCqiU1XUM
+ GY6iVmMM4r7JuG2Ur/YqjE9JzIrq8wBKurKcyjKQTiCszOv6e9Oen6G2bZVBFTQVJZW8wVUSmiasmMmL
+ LxE4rXltQSvbVlC1KbErqAM1KsAdLLMyMmEmM1PChs3pP+XlOheirrNWmQCpbzT6dOkkmAGpqhaeYUEA
+ xtO4+r7VFr2ysBQpVGanNypOtyqlpaQJAAczFK1tKK07amslVQAoA4AD2RqdVA1NhIgiYI7CDgYq3vp+
+ oLHcjM6QJ0WPNc1meK4coNDfNvemk/DUHiptzVxh7jI8o80eaPNHmjzRTsdqtKte7c4KgJP9w5mQilfe
+ s7komfy9NvF3O4wHML8YSx2iwp0LVeCCU+ZOZPMkn2ipZ7jaU61q4kVdQwPuMVtw9E3HRrYk27maHkjZ
+ r3GYh7DfNvq29yDkwMjzU5Ed0ZmKdrZ0Hq3DmQVQWJJ7AIo3/q6s1lYmR6QxrMPzuCfTAtNi22nRWWLS
+ m7c2c4n4y9sew33baVxbsPygJjmrZg8xCVdp37pbETNkeZqr+ahCkEc2M+UImz7cpu5eKs8mqE8fEcu4
+ fcQ//9oACAEBAQY/AM6WhozpzZamlqzZzGbWtrbcxrwItza3EbweSpIgQJFXkIsTJEywUoYQQcssgcks
+ JZYQhCENPfxnN9aF7/Tmnv4zm+tC9/pzT38ZzfWhe/05p7+M5vrQvf6c09/Gc31oXv8ATmnv4zm+tC9/
+ pzT38ZzfWhe/05p7+M5vrQvf6c09/Gc31oXv9Oae/jOb60L3+nNPfxnN9aF7/Tmnv4zm+tC9/pzT38Zz
+ fWhe/wBOae/jOb60L3+nNPfxnN9aF7/Tmnv4zm+tC9/pzT38ZzfWhe/05p7+M5vrQvf6c09/Gc31oXv9
+ Oae/jOb60L3+nNPfxnN9aF7/AE5p7+M5vrQvf6c09/Gc31oXv9Oae/jOb60L3+nNPfxnN9aF7/Tmnv4z
+ m+tC9/pzT38ZzfWhe/05p7+M5vrQvf6c09/Gc31oXv8ATmnv4zm+tC9/pzT+3l5//k12j/2ofPeH/wCf
+ P27+2fWn7d/1umfHxmzQ9t3z8P8AuZ9M+PjNmh7bvn4f9zPpnx8Zs0Pbd8/D/uZ9M+PjNmh7bvn4f9zP
+ pnx8Zs0Pbd8/D/uZ9M+PjNmh7bvnzAhVrIHXIyEScnIUuQKjnBw25mbjTu7nxAi4YgkhJqaSI5oyLGGw
+ AXBnEnjLJJNNByFgAddxGo6fKmipCzMziI8gDU45pEnZyEmuWxGAsUJNRbKJ0OGZTAgJgEvLPLMFAcg8
+ ANsXQJiOmhHi2XV4NHDTA4vIEBy1p+JwhKO2nDvh+ucs2Egy1nhizQJvcS8phvFNzHAByg52zx4hNp1q
+ Edzt5nzRU0QcWoCQcjmdfdtShtrSdytyiLNRIoWYAy8xYm1ylwTAIss0hAeA7O2jmrgtK5mMsVOwbTRh
+ 4YXVsALOMzjcjRKQHFOlAAwTsztZrwVgFNGE8TDUcD1bZYeWT5IhVrIHXIyEScnIUuQKjnBw25mbjTu7
+ nxAi4YgkhJqaSI5oyLGGwAXBnEnjLJJNNCQjcjC9W8dEXYZR8azzSanpjw5285bBc+AXFmp7+ynCI+qH
+ 6I4UGBm1CBTyyvjWVtc7IWZiV7kC4rlaDidcQgGgDxalwhD7u7+FBsdhzpQO2oRFMmhyJiSdsjOJO3Tt
+ s01kX80MrW9FmazXq8iJg2eabvdaXu013hcJRmeTAFisjyVenBlso9szODKzbCUcwdAbi5c3MVFmcSp0
+ 0RLnTjabdg7avZkbibiWui97VLEDU942tbBkI66GcvnMcALCjPCQuMANAI6UPlCnzH3M+mfHxmzQ9t3z
+ 5Zl/gVOt7eESMuRIY1bV7HAHhuKMOYz4OfbXBitZ4aUQYmVzoTmFMGAJJDAIok0ZSZF0NEHq33toOiiF
+ LZzegTGNWu/FwHUC2Lbv5lOPra1XNl29PYJJue7bNyzDGWcgYbTBIXHNMg5YU+QuvhROn7Qe75GmR83P
+ lGt5Ch3e6rS0voul8Dtxzd7H27MeTK7c5XiYbH4qxVdV5dH/ABcKgbaivGMOm7a8vTVFlzk93kmqzM/T
+ KHc6n6qQ+Z5BK6Vy6WjqolK2FFBhS0ewvtlGnt26+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwP8AJvYe
+ k1BKr/WN36wj2coc73H9s7I8w6ds0tV+8mbZRqvzEdct59F3epWFeYJbG3OoGDrzD8SJNIp5dMp02ui4
+ CdaS1oMBBMgpdp3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B88gt3tdKvO8y2Dudro6bLzP04kTcuk+
+ 7aSkY6dFZadFjoCCKqWy+i7vUrCvMEtjbnUDB15h+JEmkU8umU6bXRcBOtJa0GAgmQUu0xzriAdaDJMk
+ 7GnBocrMzOCcWwdkAzZFcm0+KDYg7SAdKiZOuYQsyqJcCeaMRhQ5G97naj7Q7kDrU7NR002ujW5FRyLi
+ 2uJEcQqdIHyRoMIyTOkzIUwYoQkss4c8sZZoQjCMPl/cz6Z8fGbND23fPltxzd7H27MeTK7c5XiYbH4q
+ xVdV5dH/ABcKgbaivGMOm7a8vTVFlzk93kmqzM/TKHc6n6qQ+Z5BK6Vy6WjqolK2FFBhS0ewvtlGnt26
+ +FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwO3HN3sfbsx5MrtzleJhsfirFV1Xl0f8XCoG2orxjDpu2vL0
+ 1RZc5Pd5JqszP0yh3Op+qkPmeQSulculo6qJSthRQYUtHsL7ZRp7duvhROn7Qe75GmR83PlGt5Ch3e6r
+ S0voul8D/JvYek1BKr/WN36wj2coc73H9s7I8w6ds0tV+8mbZRqvzEdct59F3epWFeYJbG3OoGDrzD8S
+ JNIp5dMp02ui4CdaS1oMBBMgpdp3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B88gt3tdKvO8y2Dudro
+ 6bLzP04kTcuk+7aSkY6dFZadFjoCCKqWy+i7vUrCvMEtjbnUDB15h+JEmkU8umU6bXRcBOtJa0GAgmQU
+ u07r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA9+E0iBJed0FkNPpCLAfDwSSlbo5f0xNsbCegsmDq2EB
+ PUnD+V9zPpnx8Zs0Pbd8+W3HN3sfbsx5MrtzleJhsfirFV1Xl0f8XCoG2orxjDpu2vL01RZc5Pd5Jqsz
+ P0yh3Op+qkPmeQSulculo6qJSthRQYUtHsL7ZRp7duvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8Dtxzd
+ 7H27MeTK7c5XiYbH4qxVdV5dH/FwqBtqK8Yw6btry9NUWXOT3eSarMz9ModzqfqpD5nkErpXLpaOqiUr
+ YUUGFLR7C+2Uae3br4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA/yb2HpNQSq/wBY3frCPZyhzvcf2zsj
+ zDp2zS1X7yZtlGq/MR1y3n0Xd6lYV5glsbc6gYOvMPxIk0inl0ynTa6LgJ1pLWgwEEyCl2ndfCidP2g9
+ 3yNMj5ufKNbyFDu91WlpfRdL4HzyC3e10q87zLYO52ujpsvM/TiRNy6T7tpKRjp0Vlp0WOgIIqpbL6Lu
+ 9SsK8wS2NudQMHXmH4kSaRTy6ZTptdFwE60lrQYCCZBS7TuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8
+ D34TSIEl53QWQ0+kIsB8PBJKVujl/TE2xsJ6CyYOrYQE9ScP5X3M+mfHxmzQ9t3z5bcc3ex9uzHkyu3O
+ V4mGx+KsVXVeXR/xcKgbaivGMOm7a8vTVFlzk93kmqzM/TKHc6n6qQ+Z5BK6Vy6WjqolK2FFBhS0ewvt
+ lGnt26+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwO3HN3sfbsx5MrtzleJhsfirFV1Xl0f8XCoG2orxjD
+ pu2vL01RZc5Pd5JqszP0yh3Op+qkPmeQSulculo6qJSthRQYUtHsL7ZRp7duvhROn7Qe75GmR83PlGt5
+ Ch3e6rS0voul8Di3E5E3o6tZT741CNhS+SRUmVJW1niYjIeGBykuZmdNTzlVKZiOA5gk5SYJkCcYPDdT
+ 1vGm6UI6XImjtyiNJRyJ3QWcSbcyXtdNnSFT5m6rIy+Muh0IzbAuKOA2F5ITxiCOCUOhGyBT+ByCcmy5
+ jLszErnDPHS5bMprbhnG3QPEPKIaDa3bICUy3koGcpis84Bs4FOFITPSGRikarPauajEebKmdtV6f2M2
+ c3ReBU5pnyvz2mMT4Vw5IXS/29+lY4m8A8NbhwBIoGBLiEpnm3H0Xd6lYV5glsbc6gYOvMPxIk0inl0y
+ nTa6LgJ1pLWgwEEyCl2ndfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HzyC3e10q87zLYO52ujpsvM/Ti
+ RNy6T7tpKRjp0Vlp0WOgIIqpbL6Lu9SsK8wS2NudQMHXmH4kSaRTy6ZTptdFwE60lrQYCCZBS7TuvhRO
+ n7Qe75GmR83PlGt5Ch3e6rS0voul8D34TSIEl53QWQ0+kIsB8PBJKVujl/TE2xsJ6CyYOrYQE9ScP5X3
+ M+mfHxmzQ9t3z5bcc3ex9uzHkyu3OV4mGx+KsVXVeXR/xcKgbaivGMOm7a8vTVFlu7xIwoyTSy5vthht
+ 3BeCes0aPeJU0UPYYHhitZgJ0EKxBw9ZltLHCaX9WMsIbabCtS6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+
+ i6XwOdZzzCrOsLLdrYbctwXgvjmmUj4sipg9iXD4YhX8psC2zETWecpDham/pjJMRsmFsp3eJGFGSaWX
+ N9sMNu4LwT1mjR7xKmih7DA8MVrMBOghWIOHrMtpY4TS/qxlhDbTYVqXXwonT9oPd8jTI+bnyjW8hQ7v
+ dVpaX0XS+B245u9j7dmPJlducrxMNj8VYquq8uj/AIuFQNtRXjGHTdteXpqiyygFJo+1vt+r7v7ubSXN
+ 7Mpu/Y+yPJvbRokv7tFTJ0v9Xp6G0/wXXwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B88gt3tdKvO8y2D
+ udro6bLzP04kTcuk+7aSkY6dFZadFjoCCKqWzchUow0cUk9PznOPuC8EMIrbVw+KV4PEdbH4YsvTpLFJ
+ WeIW1Tjt5Muh1GywBVsGJ2ddfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HzPNGGHbCcnq+nMiBuC8FaG
+ Vbre8TbPOR1OfhiJkm1KdsgYzqbwLYJlUeuYs3GmwyctK5CpRho4pJ6fnOcfcF4IYRW2rh8UrweI62Pw
+ xZenSWKSs8QtqnHbyZdDqNlgCrYMTs66+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPfhNIgSXndBZDT6
+ QiwHw8EkpW6OX9MTbGwnoLJg6thAT1Jw/lfcz6Z8fGbND23fPltxzd7H27MeTK7c5XiYbH4qxVdV5dH/
+ ABcKgbaivGMOm7a8vTVFl3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod
+ 3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6X
+ wPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4Hbjm72Pt2Y8mV25yvEw2PxViq6ry6P8Ai4VA21FeMYdN
+ 215emqLLKAUmj7W+36vu/u5tJc3sym79j7I8m9tGiS/u0VMnS/1enobT/BdfCidP2g93yNMj5ufKNbyF
+ Du91WlpfRdL4HzyC3e10q87zLYO52ujpsvM/TiRNy6T7tpKRjp0Vlp0WOgIIqpbN18KJ0/aD3fI0yPm5
+ 8o1vIUO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91
+ WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7
+ 8JpECS87oLIafSEWA+HgklK3Ry/pibY2E9BZMHVsICepOH8r7mfTPj4zZoe2758tuObvY+3ZjyZXbnK8
+ TDY/FWKrqvLo/wCLhUDbUV4xh03bXl6aosu6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93
+ yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW
+ 8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA51nPMKs6wst2thty3BeC+OaZSPiyKm
+ D2JcPhiFfymwLbMRNZ5ykOFqb+mMkxGyYWyigFJo+1vt+r7v7ubSXN7Mpu/Y+yPJvbRokv7tFTJ0v9Xp
+ 6G0/wXXwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B8zzRhh2wnJ6vpzIgbgvBWhlW63vE2zzkdTn4YiZJ
+ tSnbIGM6m8C2CZVHrmLNxpsMnLSuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bny
+ jW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73Va
+ Wl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPfhNIgSXndBZDT6QiwHw8EkpW6OX9MTbGwnoLJ
+ g6thAT1Jw/lfcz6Z8fGbND23fPltxzd7H27MeTK7c5XiYbH4qxVdV5dH/FwqBtqK8Yw6btry9NUWXdfC
+ idP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jT
+ I+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIU
+ O73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwOUApNH2t9v1fd/dzaS5vZlN37H2R5N7aN
+ El/doqZOl/q9PQ2n+C6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91W
+ lpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r
+ 4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6+FE6ftB7vk
+ aZHzc+Ua3kKHd7qtLS+i6XwPfhNIgSXndBZDT6QiwHw8EkpW6OX9MTbGwnoLJg6thAT1Jw/lfcz6Z8fG
+ bND23fPluche3MUW3GVybDzhu4zuuOansLxG3TIeXNmQ92nSWCSmBjrcHkI5LS1MpkEqSLOFp3XwonT9
+ oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm5
+ 8o1vIUO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91
+ WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3U1ikSTaHb9zXYzlSZW3W62xy4El2Pp+YByJ
+ krHy3MinSxk+IFLE4yNZgsXDCKSkyQBcAkX/AIJbgNW2SmMuts3G8GDTbl63EW6A47V4rjoo5CVo8NTi
+ 0t5IuIyRmCgVeJi5SRshhnCsjXKPZV18KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6+FE6ftB7vkaZHz
+ c+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e
+ 6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA
+ 788ESNMJOz06OZRt2GcOnlT54c0XI4dvMdssEiQIWAeoi2t5OGz+hLAB7IUnyvuZ9M+PjNmh7bvny39r
+ dixKAjiSdzRN0PlmEwAWHK5f5gtRNtDX5c309hnXZ7uAlEtMVHbi8hgvJOMKWHkJPDO+O7QxkjrSdJXu
+ 5Nbo22QBM3GG6YDxamiR8gdK+EpjLSkpSzHKIEKHM2yAyNsJpYtkGyEbHuvhROn7Qe75GmR83PlGt5Ch
+ 3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6Lp
+ fA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vgd6LuDASLOB47dpVvahLWYWFxmAGujxJ2iM5FQX7wuWO
+ HKStx2OkJR5QZ28wBOVBLlwiZwoWLWd/C/tbsWJQEcSTuaJuh8swmACw5XL/ADBaibaGvy5vp7DOuz3c
+ BKJaYqO3F5DBeScYUsPISeGe6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNby
+ FDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0
+ XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA92Ns7eyzvJR6uljHYgWC2mh4bDRt48QjRGcwUePDB
+ ZVPoG8TMOMBCZtOBBQKSFgSZguTAs/5f3M+mfHxmzQ9t3z5huObvY+3ZjyZXbnK8TDY/FWKrqvLo/wCL
+ hUDbUV4xh03bXl6aosu6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91
+ WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7
+ 8JpECS87oLIafSEWA+HgklK3Ry/pibY2E9BZMHVsICepOH8huObvY+3ZjyZXbnK8TDY/FWKrqvLo/wCL
+ hUDbUV4xh03bXl6aosu6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91
+ WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7
+ 8JpECS87oLIafSEWA+HgklK3Ry/pibY2E9BZMHVsICepOH8v7mfTPj4zZoe275+H/cz6Z8fGbND23fPw
+ /wC5n0z4+M2aHtu+fOSsll2vcF2O80kRYNluM7g9HpQYTSyTDzlm4uYFDLyTTQ2hJoQkl1+mMNLgBYbK
+ uZ5jacjiJdAzWzHjxO3gmkMcVxFejxYEQk2BFZC0+1MMJJLGMuqEYxjCEdDd+hWjcc1kERQQDV3RZz8l
+ tyGBzsjcEWlepwJW8Y1MeEgFhyCTCQm164Q1R1fJZjt4WjcdrFriCNDsU9ws59mmdi5KJaBkyRCcAC4x
+ gqHE2H+klliHNteiMfT819zPpnx8Zs0Pbd8+YBsfL9uLutxDkTrkEUNOJFrCiUb5JRDU8TbgOXLQmkln
+ hqljNrm/FoI8QsAk3zy4mCzOl026SejUAhJg4xDLTuMxcDajLGMsBxgYzS6ow1wjLGNxZW21a08l9Wm3
+ uDncDC9niLAYbizW5NrScxRHUcqDMKGddwISyyzRjPJPty65Ya9IZOW82Fjd/RdbiZaWK5kCpaoWqVdT
+ r0FUzA4bfsly7MYjLPibIkZIQljGM0NecVh3iTBb7lt3LoMs6kwDhU+CAMZfbWPhSyHCQoxYeExY3JNr
+ kmjCEY6vXCOnjv8A5XrMn2WubT1R0sew7CaYPVzvDy4zkyM50g3BYJHPC5Dx0wMdcjJQmACVJl5xJtqf
+ am2dmSE08ZZYi3Zd1ngmLYKRCg4vluuxB8KNURhIBBTOYBUWDiSLTCTSy484EC8J5pZYiQmmlhE9Jlra
+ QzuRahQgXV7OHCLQxtww0kRAwBnJyMFgjBuIeqaIBeAw8sk0JoyQljr03hvmztVsyigADXIxOJF9aSg5
+ iaQMENxnIizG2yAo4kocghkEIIQWaEkk000YQjeOYmamXVr3GTu1gt07lEde52t9kD1h3WG9GKSIOYAb
+ zExmnxlnNAwEljJrDjDVPo13FmXbxBnanh1gykBylwMrvOK4RJmT0ApgGw6ZFClTFJ47c0IS64ateuMN
+ Mrp8tmZuOk7bZ7rCeXB0e21pKkx3I2xiES8AzI60yIZkJCx1hAzySbP580uuXWSb8zLUMMgbpjUh2AMl
+ HRjdk+xEeUi6t4xgtEwDKJLNOAJEMxJLNLNMHCE0Ix+Y+5n0z4+M2aHtu+fMNX+xl3/6oX0pm/l10rtx
+ 3LpFbP0fdSs0qg0jGptNSf8AR4WrG/Tf89+k0zRFLgBAiHvDcQNnJw5ISzGTMLjy7KQHGjD/ACxUxQOT
+ XH07MkIfi0l+JmfPs1mTp4qY6vRuc0Q1/wAuxYHo/vaeOWEIf5bxmNr/AKbXuX/Hp6v73+5owuNsPLkw
+ OYhtzbouLQaGIOEhJxzufyx8uCcLzBmS8psqJMEJEOaWMwU80sY7M0YR8S1v3g+u90M5BjGCIkX9wNOo
+ ZMF8ta6ZXYuWnOiDCgljsSkk04Us0A9vXPCEJp54zN7xZ7ictl5dnVxkcXZkHFbnMzKdzhc2U5GJ4tMG
+ aDnMs5MIrPNJNLNMXlw4x2YxhHxQM15vTpdTa1sF1htpa4Dxl2QBG7DcjYwJQY8IMYLgrC8o8kks8JQh
+ 9YkkJZ5ppo+JAobdXI0VaGOwJWksYPGhy7XKKSzMmFlbgRRZgyUokwMkZoBQl1xkhr9UNAyz5cj89FwR
+ ccEB2eHBxBCG2Jg8YMI4YGkkF2J4y7UIQjqjGH49MnmS3rqf2FpcSd4OTgRZnU61gnzpMxb5cmYPIRgJ
+ jcxMEwJAKAkZpQ8SeMsIRmmjHK25ruPmrjuIN9YBoPbuNOddJzBR/ui3wTIx0aMw45qjxiBOLPNMIJLG
+ MZ4zTRjGPzH3M+mfHxmzQ9t3z5hrjtQhqs274bMfXHWUL+mHo1ejTG2I6uZJRs6ptvB3mxtvZ2dezg/n
+ a/Vs+n1aZiDxjLCSfw1EQpYRj+dGeF1WLPqhD8f5skY/0aTDTyRhKDmVnvMLLqmhMHCa3sxgv0ksYfma
+ hBISx1/jjq9eniinh6xLSaYxj/MHYUIQ/vaeOD/xjMT2YuTT1R/u/p0YdgOeeATqOIJGSWaaAYcM9XqW
+ Ik8Ya9iSE08Ia4+jXGH8enifGEhGQGkE4Y08IyhawrWu6cWGJN+brDkEljN6fRCaEY+vRh2YRmwncaIm
+ zCMcOEc9HqEIz6v8mEYiSw9P++h/HDTxUzzwjAOLPcUu3NCMJIxky9dYzw2o/m65ZZ4Rj6fRCMP49PE9
+ LD86AzRl9AKENcZo/qWZ8IQjDV6/z4Q/l09cn5Y/4tMlIh7P5jNe8I7UdXrPW1q/waZaBTxlhNI8tOv0
+ x1R43ueOqHo9MYwj8z9zPpnx8Zs0Pbd8+Yav9jLv/wBUL6ZjkzXhvtF7zIs257gtdszGLn2lteXAk3jj
+ tZIQ84CWkffi0ZG6WUIUMM5PILLCMsuFLNCWU34g4Ctpi6nIxOE6MgwU4LMat6coXboW2GHLPEcEkWbi
+ YMgIsJ5hpRQZBZ4zz7W1Ld1k+G+x2K/HMcDea6zx1vMuzk3RFLzuJCDu1WwzPBkY8EFGSUcwPPIDNLLN
+ MCLq2YZk54h5ft583mM0lWoa3Z7iMFy7VKWgxwgME5StAohuaeiQ9EQQ9WJH0+j050WsBZJJ2DzjN3Aa
+ MnBX0YnOwxfm1xbp5AAZGwxKfTSuEZ4RmmC2oy6vRr1w/F+WH+LS0Mnx8q7VvG1mMV9BuKR/chhYXQzv
+ z29vo7bKSEbTLe2iBmXeWTEGCPhzyBekLXPrld8rcm8pbbyZtu5AjJe4RWQRvkHNE3APAcypBvZGRhbS
+ AjmWlgCYMTyjiCATTSQhJGMJoOWXFz2WzZnZZOhgwYntl4HBLCkJz0ZYuAZYYy3OxA42m55cUQmYLTyT
+ DQjNJOHGeeMzplRlLlVbWTlmPoQxV8kZhCMxg6SOwkqRQkRaWVhaWkNzkliCZnwzAowOuEJpNqMIOL8y
+ NhK4Gh+JF2+47dPGRSMjgAUHmMEzBRwACHnIOJOcUSUMWYIcOEg08Jg5tcIylGC1fD3Z+Wp4u7CPc10N
+ xoiC6SmzcZJXMMImwMNvljdTkADgMIcmMwn1QjAOQSSQSFoGxbOKWfukUeSgaZ4FeIn5XgZuFmEjEZub
+ 00QKfCEIQhPtbf4tXptzw2C2aULk7eOFTkt3QexxjhuYs9ObzCSdpmbpAgoTzOUQ9cDE2qEmv8eqHzH3
+ M+mfHxmzQ9t3z5gK9MuX3d25QCRxvCcqYzu+yTPyShmwUb63uZCbFkkhDaiFGaX/ADYw0fLvug9U7iuR
+ zNvD04pSZJa5HhZhzRlI3lyhEviizRjsBBBhy+qEsIaa4RjCMPVGHojpCUeGMHDVDX/nwh6vX/nf06aw
+ Z5Jo/jljGMJ4fzyx9Onql/Lp6pfy6eqX8unql/Lp6pfy6RnEjJJLD1xmm1Q0jIVkhGP+lmhHV/xZY+v+
+ nSM4k8080fxxj/gh6oQ+b+5n0z4+M2aHtu+fOQmkmmkmh6oyxjCOkJDcu3D/AEssIbUP+FD1R0hODPCe
+ X+SMuuH88PXDT1R/5OkZp4wllh6YxmjLCEPy6RkLQxZ/Vtx1YcP5vR+dptDCRm/ih6pYfzS+qHzv3M+m
+ fHxmzQ9t3z56E4Ik0k0P4o+iP88PVHTUIDtDQhqhNLqhJH+WMNeuEdIxFnjs/iDl/Nkh/F6IeuPz/wBz
+ Ppnx8Zs0Pbd8/D/uZ9M+PjNmh7bvn4f9zPpnx8Zs0Pbd8/D/ALmfS/P/AMmv7Z3R7x/eH+/D39vP/Wf/
+ AHp/27F0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0
+ +xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0+xn0/wDhn/7M/wC7/wCmen//2Q==
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+EY2EV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDg6MzMAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAAXrgAAAAAAAABIAAAAAQAAAEgAAAAB/9j/4gxYSUNDX1BST0ZJTEUAAQEAAAxI
+ TGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAA
+ AAAAAAAA9tYAAQAAAADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFla
+ AAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVk
+ AAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJD
+ AAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBI
+ ZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAA
+ AAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAA
+ AABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAA
+ AAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMg
+ NjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5
+ NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ ZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAA
+ AAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAA
+ AEwJVgBQAAAAVx/nbWVhcwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQg
+ Y3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQBy
+ AHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwEN
+ ARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHh
+ AekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMA
+ AwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRx
+ BH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3
+ BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRgha
+ CG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrc
+ CvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3D
+ Dd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RET
+ ETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTO
+ FPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6
+ GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2Z
+ HcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKv
+ It0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/
+ KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5M
+ LoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTY
+ NRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvo
+ PCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9
+ Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0ua
+ S+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRC
+ VI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114
+ XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9
+ Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGV
+ cfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyB
+ fOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gE
+ iGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQg
+ lIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDY
+ oUehtqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4t
+ rqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7wh
+ vJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3
+ yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx
+ 2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ
+ 6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX
+ +uf7d/wH/Jj9Kf26/kv+3P9t////7QAMQWRvYmVfQ00AAf/uAA5BZG9iZQBkgAAAAAH/2wCEAAwICAgJ
+ CAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwB
+ DQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM
+ DAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEBAQAAAAAAAAADAAECBAUGBwgJ
+ CgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUHBggFAwwzAQACEQMEIRIxBUFR
+ YRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNUZEXCo3Q2F9JV4mXys4TD03Xj
+ 80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3EQACAgECBAQDBAUGBwcGBTUB
+ AAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPElBhaisoMHJjXC0kSTVKMXZEVV
+ NnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdHV2d3h5ent8f/2gAMAwEAAhED
+ EQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ/wCOt/6t6EkpL9rzP+5N3/br
+ /wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6/
+ /wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDy
+ aX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6//wAm
+ l9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDyaJi5
+ WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW
+ 9CSUpJJJJSkkkklKSSSSUpJJIAkgASTwBqSkpSSRBBgggjkHQpJKUkkkkpSSSSSlJJJJKUi4n9Mxv+Oq
+ /wCrYhIuJ/TMb/jqv+rYkp//0dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpIakAc
+ kwB5lJFxf59vwd/1JSUqmqbgywEabtp0n/zFHbWxl4LBG5jpHbQ1/wDklJ387X8H/wDotI/zzP6j/wAt
+ SSmFtQsuaHGAGEmOTqB/FAvqFT4BkESJ58P++q1/hx/xZ/6pqBmfzjf6v8XJKQJJJJKUkkkkpSSSSSlI
+ uJ/TMb/jqv8Aq2ISLif0zG/46r/q2JKf/9LWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkk
+ kklKRMb+fb8Hf9SUNExv59vwd/1JSU2nfz1fwf8A98SP88z+o/8ALUpFoLmu7tBA/tR/5FLaNwd3AI+8
+ tP8A3xJTH/Dj/iz/ANU1CvqdZc0NgQySTwNXI+0b986wW/IkO/go/wCHP/Fj/qnJKadlbq3bXc8gjghR
+ Rsv+dH9QflegpKUkkkkpSSSSSlIuJ/TMb/jqv+rYhIuJ/TMb/jqv+rYkp//T1sv+mZP/AB1v/VvQkXL/
+ AKZk/wDHW/8AVvQklKSSSSUpJJJJSkTG/n2/B3/UlDRMb+fb8Hf9SUlN1JJJJSlHafVLu2wN+YLnfxUk
+ klNTL/nR/UH5XoKLlEG7QzDQD8Zcf4oSSlJJJJKUkkkkpSLif0zG/wCOq/6tiEi4n9Mxv+Oq/wCrYkp/
+ /9TWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKTtIa9riJDXB0fA7kySSm+x7Hjcwy
+ OJgjX+0pKpTkNqYWlpMkmQR4Af8AfVP7Yz9x33hJTYUXvZW0ufwO3c+TUH7Y39x33hDvubaGgNI2mdfg
+ kpG5xc4udqTymSSSUpJJJJSkkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//V1sv+mZP/AB1v/VvQ
+ kXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSkkRmNlWQa6LXgjcC1jiC3jcIH0VAV2FjrAxxYww98GGn917
+ vzHf1klLJK50zA+1Z1FGQ19dV7XOa4DbuDRumtzh7mprsSqvpeLmNLjZkWWNcCfaAwva3aP7CSmokrdG
+ HVZ0vLzHF3qY7mNYAfb7iwOLv89V/QyPS9f0rPR/0ux2z/PjakpgktLE6fS3p37QyqL8gPs2VU0gj2x/
+ POd9La78z8xAzel5OI2t7mPc2ysWvIY4Nrk/zVjz+e3+V6aSmokkkkpSSSSSlIuJ/TMb/jqv+rYhIuJ/
+ TMb/AI6r/q2JKf/W1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJIGPNJButBbs3ZOTR0/
+ owotfUHE7w0wHQ6sQ/8Aeb7lY6k0No62GiAbscwPEtx5KE/9nnpvSXZj7KywOfX6bQ4HaWOex2h2/mKB
+ 6liZL8+vJD6ac1zHMewBzmmsMa3e33fS9Jrk4RtilnETR0PYnwbeJ/SehT2xH/8AUVLPyh/kHA/467/q
+ rVYZ1TBryunvrFvo4VVlTi5o3GQ1lbvafztipX5VVnTMXEbu9Siyxz5GkPL3Nh39tOEdtP5ephlmFS9W
+ tf8Aqv8A9DTYjQehZ4IkG6gEeRfUtWw5dXWMjIyHuZ0umuHB5/RulrfZXX+e7f8A+kliUZddfTMrFM+r
+ dZW+vT2+wsf7nf2FdyOodLyb/tt/rXPDfZgvE1NfH05+gkY+Co5hQ9Woo7+M2ub8mv6s0llr63NySwbX
+ EENAs21z+42FLrmRkxh1+s/ZZisNjNxhxPLnt/PVd2RU7o9eCZNzbza4x7YIePpf20XMyenZWNS6x1le
+ Xj0iltQaHMcW/Rdv/Nb/AGk0wplhzAloBcqBofi5iSRM9oSTWYXWopSSSSSVIuJ/TMb/AI6r/q2ISLif
+ 0zG/46r/AKtiSn//19bL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUydba9jK3vc5lQi
+ tpMhoP7iYPI8wmSRBI2WzhGYqQsJQ4Hj7k6CpNsI51Ukcg66NHNychrjPEP3T8yRMSBz9yg6w9tFFKWQ
+ dNVYuTkdch4R+6PmZF5PGgUUklGSTu3oQjAVEUFJJJILlJJJJKUi4n9Mxv8Ajqv+rYhIuJ/TMb/jqv8A
+ q2JKf//Q1sv+mZP/AB1v/VvQlZysXLOXkEY9xButIIqeQQXv1+gh/ZMz/uNd/wBtP/8AIJKRJIv2TM/7
+ jXf9tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC4
+ 13/bT/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9
+ tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/b
+ T/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRIuJ/TMb/AI6r/q2J
+ fZMz/uNd/wBtP/8AIImLi5Yy8cnHuAF1RJNTwAA9mv0ElP8A/9n/7SGgUGhvdG9zaG9wIDMuMAA4QklN
+ BAQAAAAAADccAVoAAxslRxwBWgADGyVHHAFaAAMbJUccAVoAAxslRxwBWgADGyVHHAFaAAMbJUccAgAA
+ AgAAADhCSU0EJQAAAAAAEDIfuv4AFXWqy/sJUlvbttE4QklNBDoAAAAAAJsAAAAQAAAAAQAAAAAAC3By
+ aW50T3V0cHV0AAAABAAAAABQc3RTYm9vbAEAAAAASW50ZWVudW0AAAAASW50ZQAAAABDbHJtAAAAD3By
+ aW50U2l4dGVlbkJpdGJvb2wAAAAAC3ByaW50ZXJOYW1lVEVYVAAAABMAQwBhAG4AbwBuACAATQBQADEA
+ NAAwACAAcwBlAHIAaQBlAHMAAAA4QklNBDsAAAAAAbIAAAAQAAAAAQAAAAAAEnByaW50T3V0cHV0T3B0
+ aW9ucwAAABIAAAAAQ3B0bmJvb2wAAAAAAENsYnJib29sAAAAAABSZ3NNYm9vbAAAAAAAQ3JuQ2Jvb2wA
+ AAAAAENudENib29sAAAAAABMYmxzYm9vbAAAAAAATmd0dmJvb2wAAAAAAEVtbERib29sAAAAAABJbnRy
+ Ym9vbAAAAAAAQmNrZ09iamMAAAABAAAAAAAAUkdCQwAAAAMAAAAAUmQgIGRvdWJAb+AAAAAAAAAAAABH
+ cm4gZG91YkBv4AAAAAAAAAAAAEJsICBkb3ViQG/gAAAAAAAAAAAAQnJkVFVudEYjUmx0AAAAAAAAAAAA
+ AAAAQmxkIFVudEYjUmx0AAAAAAAAAAAAAAAAUnNsdFVudEYjUHhsQFIAAAAAAAAAAAAKdmVjdG9yRGF0
+ YWJvb2wBAAAAAFBnUHNlbnVtAAAAAFBnUHMAAAAAUGdQQwAAAABMZWZ0VW50RiNSbHQAAAAAAAAAAAAA
+ AABUb3AgVW50RiNSbHQAAAAAAAAAAAAAAABTY2wgVW50RiNQcmNAWQAAAAAAADhCSU0D7QAAAAAAEABI
+ AAAAAQACAEgAAAABAAI4QklNBCYAAAAAAA4AAAAAAAAAAAAAP4AAADhCSU0EDQAAAAAABAAAAHg4QklN
+ BBkAAAAAAAQAAAAeOEJJTQPzAAAAAAAJAAAAAAAAAAABADhCSU0nEAAAAAAACgABAAAAAAAAAAI4QklN
+ A/UAAAAAAEgAL2ZmAAEAbGZmAAYAAAAAAAEAL2ZmAAEAoZmaAAYAAAAAAAEAMgAAAAEAWgAAAAYAAAAA
+ AAEANQAAAAEALQAAAAYAAAAAAAE4QklNA/gAAAAAAHAAAP////////////////////////////8D6AAA
+ AAD/////////////////////////////A+gAAAAA/////////////////////////////wPoAAAAAP//
+ //////////////////////////8D6AAAOEJJTQQAAAAAAAACAAQ4QklNBAIAAAAAAA4AAAAAAAAAAAAA
+ AAAAADhCSU0EMAAAAAAABwEBAQEBAQEAOEJJTQQtAAAAAAAGAAEAAAANOEJJTQQIAAAAAAAaAAAAAQAA
+ AkAAAAJAAAAAAgAAD6ABAAAPsAA4QklNBB4AAAAAAAQAAAAAOEJJTQQaAAAAAANHAAAABgAAAAAAAAAA
+ AAAA+gAAAPoAAAAJAHAAdQBsAGwAXwBsAGUAZgB0AAAAAQAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAA
+ AAAAAAD6AAAA+gAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAABAAAAABAAAAAAAAbnVs
+ bAAAAAIAAAAGYm91bmRzT2JqYwAAAAEAAAAAAABSY3QxAAAABAAAAABUb3AgbG9uZwAAAAAAAAAATGVm
+ dGxvbmcAAAAAAAAAAEJ0b21sb25nAAAA+gAAAABSZ2h0bG9uZwAAAPoAAAAGc2xpY2VzVmxMcwAAAAFP
+ YmpjAAAAAQAAAAAABXNsaWNlAAAAEgAAAAdzbGljZUlEbG9uZwAAAAAAAAAHZ3JvdXBJRGxvbmcAAAAA
+ AAAABm9yaWdpbmVudW0AAAAMRVNsaWNlT3JpZ2luAAAADWF1dG9HZW5lcmF0ZWQAAAAAVHlwZWVudW0A
+ AAAKRVNsaWNlVHlwZQAAAABJbWcgAAAABmJvdW5kc09iamMAAAABAAAAAAAAUmN0MQAAAAQAAAAAVG9w
+ IGxvbmcAAAAAAAAAAExlZnRsb25nAAAAAAAAAABCdG9tbG9uZwAAAPoAAAAAUmdodGxvbmcAAAD6AAAA
+ A3VybFRFWFQAAAABAAAAAAAAbnVsbFRFWFQAAAABAAAAAAAATXNnZVRFWFQAAAABAAAAAAAGYWx0VGFn
+ VEVYVAAAAAEAAAAAAA5jZWxsVGV4dElzSFRNTGJvb2wBAAAACGNlbGxUZXh0VEVYVAAAAAEAAAAAAAlo
+ b3J6QWxpZ25lbnVtAAAAD0VTbGljZUhvcnpBbGlnbgAAAAdkZWZhdWx0AAAACXZlcnRBbGlnbmVudW0A
+ AAAPRVNsaWNlVmVydEFsaWduAAAAB2RlZmF1bHQAAAALYmdDb2xvclR5cGVlbnVtAAAAEUVTbGljZUJH
+ Q29sb3JUeXBlAAAAAE5vbmUAAAAJdG9wT3V0c2V0bG9uZwAAAAAAAAAKbGVmdE91dHNldGxvbmcAAAAA
+ AAAADGJvdHRvbU91dHNldGxvbmcAAAAAAAAAC3JpZ2h0T3V0c2V0bG9uZwAAAAAAOEJJTQQoAAAAAAAM
+ AAAAAj/wAAAAAAAAOEJJTQQUAAAAAAAEAAAAIzhCSU0EDAAAAAAXygAAAAEAAACgAAAAoAAAAeAAASwA
+ AAAXrgAYAAH/2P/iDFhJQ0NfUFJPRklMRQABAQAADEhMaW5vAhAAAG1udHJSR0IgWFlaIAfOAAIACQAG
+ ADEAAGFjc3BNU0ZUAAAAAElFQyBzUkdCAAAAAAAAAAAAAAAAAAD21gABAAAAANMtSFAgIAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWNwcnQAAAFQAAAAM2Rlc2MAAAGE
+ AAAAbHd0cHQAAAHwAAAAFGJrcHQAAAIEAAAAFHJYWVoAAAIYAAAAFGdYWVoAAAIsAAAAFGJYWVoAAAJA
+ AAAAFGRtbmQAAAJUAAAAcGRtZGQAAALEAAAAiHZ1ZWQAAANMAAAAhnZpZXcAAAPUAAAAJGx1bWkAAAP4
+ AAAAFG1lYXMAAAQMAAAAJHRlY2gAAAQwAAAADHJUUkMAAAQ8AAAIDGdUUkMAAAQ8AAAIDGJUUkMAAAQ8
+ AAAIDHRleHQAAAAAQ29weXJpZ2h0IChjKSAxOTk4IEhld2xldHQtUGFja2FyZCBDb21wYW55AABkZXNj
+ AAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAEnNSR0IgSUVDNjE5NjYtMi4xAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYWVogAAAAAAAA81EAAQAA
+ AAEWzFhZWiAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAG+iAAA49QAAA5BYWVogAAAAAAAAYpkAALeF
+ AAAY2lhZWiAAAAAAAAAkoAAAD4QAALbPZGVzYwAAAAAAAAAWSUVDIGh0dHA6Ly93d3cuaWVjLmNoAAAA
+ AAAAAAAAAAAWSUVDIGh0dHA6Ly93d3cuaWVjLmNoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAGRlc2MAAAAAAAAALklFQyA2MTk2Ni0yLjEgRGVmYXVsdCBSR0IgY29sb3Vy
+ IHNwYWNlIC0gc1JHQgAAAAAAAAAAAAAALklFQyA2MTk2Ni0yLjEgRGVmYXVsdCBSR0IgY29sb3VyIHNw
+ YWNlIC0gc1JHQgAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAACxSZWZlcmVuY2UgVmlld2lu
+ ZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29u
+ ZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdmlldwAAAAAAE6T+
+ ABRfLgAQzxQAA+3MAAQTCwADXJ4AAAABWFlaIAAAAAAATAlWAFAAAABXH+dtZWFzAAAAAAAAAAEAAAAA
+ AAAAAAAAAAAAAAAAAAACjwAAAAJzaWcgAAAAAENSVCBjdXJ2AAAAAAAABAAAAAAFAAoADwAUABkAHgAj
+ ACgALQAyADcAOwBAAEUASgBPAFQAWQBeAGMAaABtAHIAdwB8AIEAhgCLAJAAlQCaAJ8ApACpAK4AsgC3
+ ALwAwQDGAMsA0ADVANsA4ADlAOsA8AD2APsBAQEHAQ0BEwEZAR8BJQErATIBOAE+AUUBTAFSAVkBYAFn
+ AW4BdQF8AYMBiwGSAZoBoQGpAbEBuQHBAckB0QHZAeEB6QHyAfoCAwIMAhQCHQImAi8COAJBAksCVAJd
+ AmcCcQJ6AoQCjgKYAqICrAK2AsECywLVAuAC6wL1AwADCwMWAyEDLQM4A0MDTwNaA2YDcgN+A4oDlgOi
+ A64DugPHA9MD4APsA/kEBgQTBCAELQQ7BEgEVQRjBHEEfgSMBJoEqAS2BMQE0wThBPAE/gUNBRwFKwU6
+ BUkFWAVnBXcFhgWWBaYFtQXFBdUF5QX2BgYGFgYnBjcGSAZZBmoGewaMBp0GrwbABtEG4wb1BwcHGQcr
+ Bz0HTwdhB3QHhgeZB6wHvwfSB+UH+AgLCB8IMghGCFoIbgiCCJYIqgi+CNII5wj7CRAJJQk6CU8JZAl5
+ CY8JpAm6Cc8J5Qn7ChEKJwo9ClQKagqBCpgKrgrFCtwK8wsLCyILOQtRC2kLgAuYC7ALyAvhC/kMEgwq
+ DEMMXAx1DI4MpwzADNkM8w0NDSYNQA1aDXQNjg2pDcMN3g34DhMOLg5JDmQOfw6bDrYO0g7uDwkPJQ9B
+ D14Peg+WD7MPzw/sEAkQJhBDEGEQfhCbELkQ1xD1ERMRMRFPEW0RjBGqEckR6BIHEiYSRRJkEoQSoxLD
+ EuMTAxMjE0MTYxODE6QTxRPlFAYUJxRJFGoUixStFM4U8BUSFTQVVhV4FZsVvRXgFgMWJhZJFmwWjxay
+ FtYW+hcdF0EXZReJF64X0hf3GBsYQBhlGIoYrxjVGPoZIBlFGWsZkRm3Gd0aBBoqGlEadxqeGsUa7BsU
+ GzsbYxuKG7Ib2hwCHCocUhx7HKMczBz1HR4dRx1wHZkdwx3sHhYeQB5qHpQevh7pHxMfPh9pH5Qfvx/q
+ IBUgQSBsIJggxCDwIRwhSCF1IaEhziH7IiciVSKCIq8i3SMKIzgjZiOUI8Ij8CQfJE0kfCSrJNolCSU4
+ JWgllyXHJfcmJyZXJocmtyboJxgnSSd6J6sn3CgNKD8ocSiiKNQpBik4KWspnSnQKgIqNSpoKpsqzysC
+ KzYraSudK9EsBSw5LG4soizXLQwtQS12Last4S4WLkwugi63Lu4vJC9aL5Evxy/+MDUwbDCkMNsxEjFK
+ MYIxujHyMioyYzKbMtQzDTNGM38zuDPxNCs0ZTSeNNg1EzVNNYc1wjX9Njc2cjauNuk3JDdgN5w31zgU
+ OFA4jDjIOQU5Qjl/Obw5+To2OnQ6sjrvOy07azuqO+g8JzxlPKQ84z0iPWE9oT3gPiA+YD6gPuA/IT9h
+ P6I/4kAjQGRApkDnQSlBakGsQe5CMEJyQrVC90M6Q31DwEQDREdEikTORRJFVUWaRd5GIkZnRqtG8Ec1
+ R3tHwEgFSEtIkUjXSR1JY0mpSfBKN0p9SsRLDEtTS5pL4kwqTHJMuk0CTUpNk03cTiVObk63TwBPSU+T
+ T91QJ1BxULtRBlFQUZtR5lIxUnxSx1MTU19TqlP2VEJUj1TbVShVdVXCVg9WXFapVvdXRFeSV+BYL1h9
+ WMtZGllpWbhaB1pWWqZa9VtFW5Vb5Vw1XIZc1l0nXXhdyV4aXmxevV8PX2Ffs2AFYFdgqmD8YU9homH1
+ YklinGLwY0Njl2PrZEBklGTpZT1lkmXnZj1mkmboZz1nk2fpaD9olmjsaUNpmmnxakhqn2r3a09rp2v/
+ bFdsr20IbWBtuW4SbmtuxG8eb3hv0XArcIZw4HE6cZVx8HJLcqZzAXNdc7h0FHRwdMx1KHWFdeF2Pnab
+ dvh3VnezeBF4bnjMeSp5iXnnekZ6pXsEe2N7wnwhfIF84X1BfaF+AX5ifsJ/I3+Ef+WAR4CogQqBa4HN
+ gjCCkoL0g1eDuoQdhICE44VHhauGDoZyhteHO4efiASIaYjOiTOJmYn+imSKyoswi5aL/IxjjMqNMY2Y
+ jf+OZo7OjzaPnpAGkG6Q1pE/kaiSEZJ6kuOTTZO2lCCUipT0lV+VyZY0lp+XCpd1l+CYTJi4mSSZkJn8
+ mmia1ZtCm6+cHJyJnPedZJ3SnkCerp8dn4uf+qBpoNihR6G2oiailqMGo3aj5qRWpMelOKWpphqmi6b9
+ p26n4KhSqMSpN6mpqhyqj6sCq3Wr6axcrNCtRK24ri2uoa8Wr4uwALB1sOqxYLHWskuywrM4s660JbSc
+ tRO1irYBtnm28Ldot+C4WbjRuUq5wro7urW7LrunvCG8m70VvY++Cr6Evv+/er/1wHDA7MFnwePCX8Lb
+ w1jD1MRRxM7FS8XIxkbGw8dBx7/IPci8yTrJuco4yrfLNsu2zDXMtc01zbXONs62zzfPuNA50LrRPNG+
+ 0j/SwdNE08bUSdTL1U7V0dZV1tjXXNfg2GTY6Nls2fHadtr724DcBdyK3RDdlt4c3qLfKd+v4DbgveFE
+ 4cziU+Lb42Pj6+Rz5PzlhOYN5pbnH+ep6DLovOlG6dDqW+rl63Dr++yG7RHtnO4o7rTvQO/M8Fjw5fFy
+ 8f/yjPMZ86f0NPTC9VD13vZt9vv3ivgZ+Kj5OPnH+lf65/t3/Af8mP0p/br+S/7c/23////tAAxBZG9i
+ ZV9DTQAB/+4ADkFkb2JlAGSAAAAAAf/bAIQADAgICAkIDAkJDBELCgsRFQ8MDA8VGBMTFRMTGBEMDAwM
+ DAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAENCwsNDg0QDg4QFA4ODhQUDg4ODhQRDAwMDAwR
+ EQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM/8AAEQgAoACgAwEiAAIRAQMRAf/dAAQA
+ Cv/EAT8AAAEFAQEBAQEBAAAAAAAAAAMAAQIEBQYHCAkKCwEAAQUBAQEBAQEAAAAAAAAAAQACAwQFBgcI
+ CQoLEAABBAEDAgQCBQcGCAUDDDMBAAIRAwQhEjEFQVFhEyJxgTIGFJGhsUIjJBVSwWIzNHKC0UMHJZJT
+ 8OHxY3M1FqKygyZEk1RkRcKjdDYX0lXiZfKzhMPTdePzRieUpIW0lcTU5PSltcXV5fVWZnaGlqa2xtbm
+ 9jdHV2d3h5ent8fX5/cRAAICAQIEBAMEBQYHBwYFNQEAAhEDITESBEFRYXEiEwUygZEUobFCI8FS0fAz
+ JGLhcoKSQ1MVY3M08SUGFqKygwcmNcLSRJNUoxdkRVU2dGXi8rOEw9N14/NGlKSFtJXE1OT0pbXF1eX1
+ VmZ2hpamtsbW5vYnN0dXZ3eHl6e3x//aAAwDAQACEQMRAD8A2srKyxl5AGRcALrQALXgAB79Ppof2vM/
+ 7k3f9uv/APJpZf8ATMn/AI63/q3oSSkv2vM/7k3f9uv/APJpfa8z/uTd/wBuv/8AJoSSSkv2vM/7k3f9
+ uv8A/Jpfa8z/ALk3f9uv/wDJoSSSkv2vM/7k3f8Abr//ACaX2vM/7k3f9uv/APJoSSSkv2vM/wC5N3/b
+ r/8AyaX2vM/7k3f9uv8A/JoSSSkv2vM/7k3f9uv/APJpfa8z/uTd/wBuv/8AJoSSSkv2vM/7k3f9uv8A
+ /Jpfa8z/ALk3f9uv/wDJoSSSkv2vM/7k3f8Abr//ACaX2vM/7k3f9uv/APJoSSSkv2vM/wC5N3/br/8A
+ yaX2vM/7k3f9uv8A/JoSSSkv2vM/7k3f9uv/APJomLlZZy8cHIuIN1QINryCC9mn01WRcT+mY3/HVf8A
+ VsSU/wD/0NbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpJJJJSkkkgCSABJPAGpKSl
+ JJEEGCCCOQdCkkpSSSSSlJJJJKUkkkkpSLif0zG/46r/AKtiEi4n9Mxv+Oq/6tiSn//R1sv+mZP/AB1v
+ /VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSkhqQByTAHmUkXF/n2/B3/UlJSqapuDLARpu2nSf/MUd
+ tbGXgsEbmOkdtDX/AOSUnfztfwf/AOi0j/PM/qP/AC1JKYW1Cy5ocYAYSY5OoH8UC+oVPgGQRInnw/76
+ rX+HH/Fn/qmoGZ/ON/q/xckpAkkkkpSSSSSlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jqv+rYkp//0tbL
+ /pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpExv59vwd/1JQ0TG/n2/B3/UlJTad/PV/B
+ /wD3xI/zzP6j/wAtSkWgua7u0ED+1H/kUto3B3cAj7y0/wDfElMf8OP+LP8A1TUK+p1lzQ2BDJJPA1cj
+ 7Rv3zrBb8iQ7+Cj/AIc/8WP+qckpp2VurdtdzyCOCFFGy/50f1B+V6CkpSSSSSlJJJJKUi4n9Mxv+Oq/
+ 6tiEi4n9Mxv+Oq/6tiSn/9PWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKRMb+fb8H
+ f9SUNExv59vwd/1JSU3UkkklKUdp9Uu7bA35gud/FSSSU1Mv+dH9QflegouUQbtDMNAPxlx/ihJKUkkk
+ kpSSSSSlIuJ/TMb/AI6r/q2ISLif0zG/46r/AKtiSn//1NbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0
+ JJSkkkklKSSSSUpO0hr2uIkNcHR8DuTJJKb7HseNzDI4mCNf7SkqlOQ2phaWkySZBHgB/wB9U/tjP3Hf
+ eElNhRe9lbS5/A7dz5NQftjf3HfeEO+5toaA0jaZ1+CSkbnFzi52pPKZJJJSkkkklKSSSSUpFxP6Zjf8
+ dV/1bEJFxP6Zjf8AHVf9WxJT/9XWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSRGY
+ 2VZBroteCNwLWOILeNwgfRUBXYWOsDHFjDD3wYaf3Xu/Md/WSUskrnTMD7VnUUZDX11Xtc5rgNu4NG6a
+ 3OHuamuxKq+l4uY0uNmRZY1wJ9oDC9rdo/sJKaiSt0YdVnS8vMcXepjuY1gB9vuLA4u/z1X9DI9L1/Ss
+ 9H/S7HbP8+NqSmCS0sTp9LenftDKovyA+zZVTSCPbH88530trvzPzEDN6Xk4ja3uY9zbKxa8hjg2uT/N
+ WPP57f5XppKaiSSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv8Ajqv+rYkp/9bWy/6Zk/8AHW/9W9CRcv8A
+ pmT/AMdb/wBW9CSUpJJJJSkkkgY80kG60Fuzdk5NHT+jCi19QcTvDTAdDqxD/wB5vuVjqTQ2jrYaIBux
+ zA8S3HkoT/2eem9JdmPsrLA59fptDgdpY57HaHb+YoHqWJkvz68kPppzXMcx7AHOaawxrd7fd9L0muTh
+ G2KWcRNHQ9ifBt4n9J6FPbEf/wBRUs/KH+QcD/jrv+qtVhnVMGvK6e+sW+jhVWVOLmjcZDWVu9p/O2Kl
+ flVWdMxcRu71KLLHPkaQ8vc2Hf204R20/l6mGWYVL1a1/wCq/wD0NNiNB6FngiQbqAR5F9S1bDl1dYyM
+ jIe5nS6a4cHn9G6Wt9ldf57t/wD6SWJRl119MysUz6t1lb69Pb7Cx/ud/YV3I6h0vJv+23+tc8N9mC8T
+ U18fTn6CRj4KjmFD1aijv4za5vya/qzSWWvrc3JLBtcQQ0CzbXP7jYUuuZGTGHX6z9lmKw2M3GHE8ue3
+ 89V3ZFTuj14Jk3NvNrjHtgh4+l/bRczJ6dlY1LrHWV5ePSKW1Bocxxb9F2/81v8AaTTCmWHMCWgFyoGh
+ +LmJJEz2hJNZhdailJJJJJUi4n9Mxv8Ajqv+rYhIuJ/TMb/jqv8Aq2JKf//X1sv+mZP/AB1v/VvQkXL/
+ AKZk/wDHW/8AVvQklKSSSSUpJJJJTJ1tr2Mre9zmVCK2kyGg/uJg8jzCZJEEjZbOEZipCwlDgePuToKk
+ 2wjnVSRyDro0c3JyGuM8Q/dPzJExIHP3KDrD20UUpZB01Vi5OR1yHhH7o+ZkXk8aBRSSUZJO7ehCMBUR
+ QUkkkguUkkkkpSLif0zG/wCOq/6tiEi4n9Mxv+Oq/wCrYkp//9DWy/6Zk/8AHW/9W9CVnKxcs5eQRj3E
+ G60gip5BBe/X6CH9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9kzP8AuNd/20//AMgkpEki/ZMz
+ /uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZMz/uNd/20/wD8gkpEki/ZMz/u
+ Nd/20/8A8gl9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9kzP8AuNd/20//AMgkpEki/ZMz/uNd
+ /wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZMz/uNd/20/wD8gkpEki/ZMz/uNd/2
+ 0/8A8gl9kzP+413/AG0//wAgkpEi4n9Mxv8Ajqv+rYl9kzP+413/AG0//wAgiYuLljLxyce4AXVEk1PA
+ AD2a/QSU/wD/2ThCSU0EIQAAAAAAVQAAAAEBAAAADwBBAGQAbwBiAGUAIABQAGgAbwB0AG8AcwBoAG8A
+ cAAAABMAQQBkAG8AYgBlACAAUABoAG8AdABvAHMAaABvAHAAIABDAFMANQAAAAEAOEJJTQ+gAAAAAAD4
+ bWFuaUlSRlIAAADsOEJJTUFuRHMAAADMAAAAEAAAAAEAAAAAAABudWxsAAAAAwAAAABBRlN0bG9uZwAA
+ AAAAAAAARnJJblZsTHMAAAABT2JqYwAAAAEAAAAAAABudWxsAAAAAQAAAABGcklEbG9uZwMhB98AAAAA
+ RlN0c1ZsTHMAAAABT2JqYwAAAAEAAAAAAABudWxsAAAABAAAAABGc0lEbG9uZwAAAAAAAAAAQUZybWxv
+ bmcAAAAAAAAAAEZzRnJWbExzAAAAAWxvbmcDIQffAAAAAExDbnRsb25nAAAAAAAAOEJJTVJvbGwAAAAI
+ AAAAAAAAAAA4QklND6EAAAAAABxtZnJpAAAAAgAAABAAAAABAAAAAAAAAAEAAAAAOEJJTQQGAAAAAAAH
+ AAgBAQABAQD/4SYmaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLwA8P3hwYWNrZXQgYmVnaW49Iu+7
+ vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pg0KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9i
+ ZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS4wLWMwNjAgNjEuMTM0Nzc3LCAyMDEw
+ LzAyLzEyLTE3OjMyOjAwICAgICAgICAiPg0KCTxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53
+ My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+DQoJCTxyZGY6RGVzY3JpcHRpb24gcmRmOmFi
+ b3V0PSIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1sbnM6cGhvdG9z
+ aG9wPSJodHRwOi8vbnMuYWRvYmUuY29tL3Bob3Rvc2hvcC8xLjAvIiB4bWxuczpkYz0iaHR0cDovL3B1
+ cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hh
+ cC8xLjAvbW0vIiB4bWxuczpzdEV2dD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL3NUeXBlL1Jl
+ c291cmNlRXZlbnQjIiB4bWxuczpzdFJlZj0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL3NUeXBl
+ L1Jlc291cmNlUmVmIyIgeG1wOkNyZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9z
+ aCIgeG1wOkNyZWF0ZURhdGU9IjIwMTItMDMtMjFUMTI6Mzc6MDErMDE6MDAiIHhtcDpNZXRhZGF0YURh
+ dGU9IjIwMTItMDMtMjFUMTg6NDg6MzMrMDE6MDAiIHhtcDpNb2RpZnlEYXRlPSIyMDEyLTAzLTIxVDE4
+ OjQ4OjMzKzAxOjAwIiBwaG90b3Nob3A6Q29sb3JNb2RlPSIzIiBwaG90b3Nob3A6SUNDUHJvZmlsZT0i
+ c1JHQiBJRUM2MTk2Ni0yLjEiIGRjOmZvcm1hdD0iaW1hZ2UvanBlZyIgeG1wTU06SW5zdGFuY2VJRD0i
+ eG1wLmlpZDpBOTU5QjEwQTBGMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgeG1wTU06RG9jdW1lbnRJRD0i
+ eG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgeG1wTU06T3JpZ2luYWxEb2N1
+ bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIj4NCgkJCTxwaG90
+ b3Nob3A6VGV4dExheWVycz4NCgkJCQk8cmRmOkJhZz4NCgkJCQkJPHJkZjpsaSBwaG90b3Nob3A6TGF5
+ ZXJOYW1lPSJwdWxsIGxlZnQiIHBob3Rvc2hvcDpMYXllclRleHQ9InB1bGwgbGVmdCIvPg0KCQkJCTwv
+ cmRmOkJhZz4NCgkJCTwvcGhvdG9zaG9wOlRleHRMYXllcnM+DQoJCQk8eG1wTU06SGlzdG9yeT4NCgkJ
+ CQk8cmRmOlNlcT4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImNyZWF0ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTI6Mzc6MDErMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RF
+ dnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowMjgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RF
+ dnQ6d2hlbj0iMjAxMi0wMy0yMVQxMjozNzozOSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRv
+ YmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjAzODAxMTc0MDcy
+ MDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEyOjU3OjEzKzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6MDQ4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTM6MDA6MDgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6
+ YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNTgwMTE3NDA3MjA2ODExQkE5
+ RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowMjo0MyswMTowMCIgc3RFdnQ6
+ c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9
+ Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4
+ bXAuaWlkOjA2ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAz
+ LTIxVDEzOjA3OjU2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDc4MDExNzQwNzIwNjgxMUJBOURERjE1QTVB
+ RUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDg6MTErMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDow
+ ODgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzow
+ ODoxOCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjBBODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA5OjM5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjIyM0RFMEEw
+ QzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDk6NDkrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDoyMzIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxMzoxMCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9z
+ aG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDph
+ Y3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI0MjNERTBBMEMyMDY4MTFCQTlE
+ REYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEwOjI4KzAxOjAwIiBzdEV2dDpz
+ b2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0i
+ LyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9Inht
+ cC5paWQ6MjUyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMt
+ MjFUMTM6MTI6NDMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJz
+ YXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyNjIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFF
+ RTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMzowNiswMTowMCIgc3RFdnQ6c29mdHdhcmVB
+ Z2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJ
+ CQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI3
+ MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjE4
+ OjQwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9z
+ aCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0
+ RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjgyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0
+ RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6MTQ6MDUrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFk
+ b2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6
+ bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGNzdGMTE3NDA3
+ MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1NCswMTowMCIg
+ c3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNo
+ YW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5j
+ ZUlEPSJ4bXAuaWlkOkZBN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIy
+ MDEyLTAzLTIxVDE3OjU1OjUwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3No
+ b3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFj
+ dGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkI3RjExNzQwNzIwNjgxMTk0NTc5
+ QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTY6MDUrMDE6MDAiIHN0RXZ0OnNv
+ ZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIv
+ Ii8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1w
+ LmlpZDpGQzdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0y
+ MVQxNzo1Njo1MiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBN
+ YWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNh
+ dmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjUwOUZENDIxMDkyMDY4MTE5NDU3OUEzM0ZCMzU2
+ NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjA2OjAxKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFn
+ ZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJ
+ CQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6NTE5
+ RkQ0MjEwOTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6MTA6
+ MTIrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3No
+ IiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RF
+ dnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1MjlGRDQyMTA5MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RF
+ dnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoxMDoyMyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRv
+ YmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjU2OUZENDIxMDky
+ MDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjEyOjA4KzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6NTc5RkQ0MjEwOTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTg6MTI6NDcrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6
+ YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1ODlGRDQyMTA5MjA2ODExOTQ1
+ NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoxMjo1MiswMTowMCIgc3RFdnQ6
+ c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9
+ Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4
+ bXAuaWlkOjQxMzY2QjNBMEEyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAz
+ LTIxVDE4OjEzOjU1KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RTkxNzdEQ0MwRTIwNjgxMTk0NTc5QTMzRkIz
+ NTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6NDY6MzgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpB
+ ODU5QjEwQTBGMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODo0
+ ODozMyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImNvbnZlcnRl
+ ZCIgc3RFdnQ6cGFyYW1ldGVycz0iZnJvbSBhcHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRv
+ IGltYWdlL2pwZWciLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImRlcml2ZWQiIHN0RXZ0OnBh
+ cmFtZXRlcnM9ImNvbnZlcnRlZCBmcm9tIGFwcGxpY2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8g
+ aW1hZ2UvanBlZyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6QTk1OUIxMEEwRjIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTg6NDg6MzMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJPC9yZGY6U2VxPg0KCQkJ
+ PC94bXBNTTpIaXN0b3J5Pg0KCQkJPHhtcE1NOkRlcml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9Inht
+ cC5paWQ6QTg1OUIxMEEwRjIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0UmVmOmRvY3VtZW50SUQ9Inht
+ cC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0UmVmOm9yaWdpbmFsRG9jdW1l
+ bnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIvPg0KCQk8L3JkZjpE
+ ZXNjcmlwdGlvbj4NCgk8L3JkZjpSREY+DQo8L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ IAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDw/eHBhY2tldCBlbmQ9J3cnPz7/4gxY
+ SUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAA
+ AABJRUMgc1JHQgAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAA
+ ABRia3B0AAACBAAAABRyWFlaAAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAA
+ AHBkbWRkAAACxAAAAIh2dWVkAAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAA
+ ACR0ZWNoAAAEMAAAAAxyVFJDAAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENv
+ cHlyaWdodCAoYykgMTk5OCBIZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJ
+ RUM2MTk2Ni0yLjEAAAAAAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAA
+ AAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAA
+ JKAAAA+EAAC2z2Rlc2MAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBo
+ dHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AABkZXNjAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IA
+ AAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGlu
+ IElFQzYxOTY2LTIuMQAAAAAAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2
+ MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk/gAUXy4AEM8UAAPtzAAE
+ EwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQAAAAVx/nbWVhcwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+ Ao8AAAACc2lnIAAAAABDUlQgY3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABF
+ AEoATwBUAFkAXgBjAGgAbQByAHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDb
+ AOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGa
+ AaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKi
+ AqwCtgLBAssC1QLgAusC9QMAAwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5
+ BAYEEwQgBC0EOwRIBFUEYwRxBH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWm
+ BbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQes
+ B78H0gflB/gICwgfCDIIRghaCG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woR
+ CicKPQpUCmoKgQqYCq4KxQrcCvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZ
+ DPMNDQ0mDUANWg10DY4NqQ3DDd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJ
+ ECYQQxBhEH4QmxC5ENcQ9RETETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOk
+ E8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReu
+ F9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwq
+ HFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEc
+ IUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaH
+ Jrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxu
+ LKIs1y0MLUEtdi2rLeEuFi5MLoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLU
+ Mw0zRjN/M7gz8TQrNGU0njTYNRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8
+ Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50Ep
+ QWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kd
+ SWNJqUnwSjdKfUrESwxLU0uaS+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGb
+ UeZSMVJ8UsdTE1NfU6pT9lRCVI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqm
+ WvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RA
+ ZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5r
+ bsRvHm94b9FwK3CGcOBxOnGVcfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkq
+ eYl553pGeqV7BHtje8J8IXyBfOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSA
+ hOOFR4Wrhg6GcobXhzuHn4gEiGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBu
+ kNaRP5GokhGSepLjk02TtpQglIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3
+ nWSd0p5Anq6fHZ+Ln/qgaaDYoUehtqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaoc
+ qo+rAqt1q+msXKzQrUStuK4trqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfg
+ uFm40blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZG
+ xsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO
+ 1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T8
+ 5YTmDeaW5x/nqegy6LzpRunQ6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ
+ 9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26/kv+3P9t////2wBDAAEBAQEBAQEBAQEBAQEBAQEB
+ AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgMDAwMDAwMDAwP/2wBDAQEBAQEBAQEB
+ AQECAgECAgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwP/wgAR
+ CAD6APoDAREAAhEBAxEB/8QAHQABAAIDAQEBAQAAAAAAAAAAAAcJBQYIBAMCAf/EADEQAAAFAwMEAgAF
+ AwUAAAAAAAADBAUGAgcIMAETQBQYOBIJERUWFxkQcJAgISY3Kf/EABwBAQABBQEBAAAAAAAAAAAAAAAG
+ AwQFBwgCAf/EAF8RAAAEAwQECgcDBQgLEQAAAAIDBAUBFAYAExUHERIWJjAxRWUXN0cIGGgh1bZ3l0mJ
+ QEEiUXGRIzYQ8GGBodEyQrFyM1MkNGS0Vqc5weGCokNjNVVmdoZnxzhIiAn/xABGEgACAAMFBQUCCgQP
+ AAAAAAABAhEDBAAhMRIFQWEyEwZAUYGRInFiobHB0UJS0iMUFXCQcjMQ4aKywmODk7PTJDTEFgf/2gAM
+ AwEAAhADEAAAALhyJgAAAAAAAAAAAAAAWylTRDIAAAAAAAAAAAAAALmCs0hkAAAAAAAAAAAAAAFzBWaQ
+ yAAAAAAAAAAAAAAC5grNIZAAAAAAAAAAAAAABcwVmkMgAAAAAAAAAAAAAAuYKzSGQAAAAAbMZon85zMM
+ YUAAAAAAuYKzSGQAAAACWTNGzG5mmA5mAAAAAALmCs0hkAAAAA7MNMBuZpgOZgAAAAAC5grNIZAAAAAO
+ zDTAbmaYDmYAAAAAAuYKzSGQAAAADsw0wG5mmA8RBphQAAAAC5grNIZAAAAAOzDDAzJhjCm5nMxpgAAA
+ ABcwVmkMgAAAAHZgABphuZzMaYAAAAAXMFZpDIAAAAB2YAAYYzJzMaYAAAAAXMFZpDIAAAAB2YAAAczG
+ mAAAAAFzBWaQyAAAAAdZmZAAByAeIAAAAAuYKzSGQAAAACZiZgACJiDAAAAAAXMFZpDIAAAAAOzAADjM
+ AAAAAAuYKzSGQAAAAAAAAAAAAAAXMFZpDIAAAAAAAAAAAAAALmCs0hkAAAAAGwmbNDNuNRBIB/SPgAAA
+ AXMFZpDIAAAJIOkSFDAFi32nM5Rr6pW/fKnCXz1gfnu5w0UqpOfgAAAC5grNIZAAAB3+SEd0FeNWx7Yy
+ kCw/qjSTI9L224La+a+e/NYynyY2bfgqHMEAAAAXMFZpDIAAB9rrBWDXkb+j7ZNZyKv6Q6d7Et8xh/dv
+ SlMebrZotvnoiwlnB+a1lLMb3V/Kd7URfxL42kh8WKnwAAAuYKzSGQAAAWDXkc62zGuOFZfzp1biNiQh
+ fRPyeqfG+a1n1NidgSba53V6thrVWwxNHJ+mFdPcV42afnxcgAAC5grNIZAAABIBgPvjzSfReyTzk305
+ CIgAfijkcBDOmMBC+mvnQygAAAAuYKzSGQAAAAD91LPPzXmLZZ7yV9rnCfnxcYGHdJ61AeufPZSUAAAA
+ AXMFZpDIAAAAAB9rrAbBNeYsLFd/ePFT4AAAAAAXMFZpDIAAAAAAAAAAAAAALmCs0hkAAAAAAAAAAAAA
+ AFzBWaQyAAAAAAAAAAAAAAC5g3M0wAAAAAAAAAAAAAAHZh//2gAIAQIAAQUA/wAVvx3223p32HHWPjV+
+ O+2+2/VUFVVlqCaKWhcTRQOwJBqejZ6QpijnJxIo2W9KlS7qq1jMrREfkyvs6kZtKMxDslj6yn8I86U/
+ gOIH0f8AJCU6w91RJm9CoNbDN3NY2KURn6bcAqaTkdPRbr1VSZvQFuBNbMmrb6YubVQcw0nNypjpVDjB
+ jPSY5rY/zqW5ioRG7M9Ozo+IkR6el0WJqzDKzauj233p3bZOpShCvROFHGOMcY4xxg4wlMW5SujYKFJ6
+ ozpyjjSK2uX10BKpSrS/gDNyyqXSWpU4WOCteZ1aRaqQmETiulM4vK9zr/sf/9oACAEDAAEFAP8AFbsa
+ XVXSaXWO8SjY4rcugygzbqlK8hMrZnJQdcaKuahUP1W5hvd1Rls5U9rm2Ew50UVRjpXx9pYk8duTHpO6
+ fuTH/wBRlyJAbIkkorf7vRw75Xhgp3zHfbBpP23ss5O8caYFJnuYSpmQTpHTBo7OWaTpP3shwYbhNklP
+ 6IuKMZD3MJYshzgnuY+ES8++zeUobbsHN0zYLqGsQ70I7kGJIPGLwflbLM7rKJOgruQbXA7VyWTtTwdB
+ I69J0iNKgI6Mwss2ia2MY33aUxKTQ5R3Y7sd2O7HdhsSOTyrhVgFBgaWVqYknTr25C6Jp3jomUh9ZXyN
+ LO53CWlWuPgmPL477RqIR6JJOrkEYYZQidcWUxr1DLaxSDp/7H//2gAIAQEAAQUAv5fy+rNfXyNyFHkb
+ kKPI3IUeRuQo8jchR5G5CjyNyFHkbkKPI3IUeRuQo8jchR5G5CjyNyFHkbkKPI3IUeRuQo8jchR5G5Cj
+ yNyFHkbkKPI3IUeRuQo8jchR5G5CjyNyFHkbkKPI3IUeRuQo8jchR5G5Cj9x7hjI32F6/I32F6/I32F6
+ /I32F6/I32F6/I32F1IlEnqaPT3baSMrLC4WQkIe4qqLkrnHJCypdbI32F049ZqXSAiz8bcdpdImPht5
+ Go1ziGMfc3DkTHw281sjfYXTjUa5xDGPubhyJj4beRqNc4hjH3Nw5Ex8NvNbI32F041GucQxj7m4ciY+
+ G3kajXOIYx9zcORMfDbzWyN9hdONRrnEMY+5uHImPht5Go1ziGMfc3DkTHw28ilm0i0h+Y1UeXamRvsL
+ pxqNc4icIVVSHaEKpBHo1GucROEKqpDImPht5Go1zieJu0fNTI32F041GucRqNc4jUa5xGo1ziNRrnEi
+ Y+G3kajXOJ4m7R81MjfYXTjUa5xGo1ziNRrnEajXOI1GucbQhVII9Go1zieJu0fNTI32F041GucRqNc4
+ jUa5xGo1ziNRrnEajXOI1GucTxN2j5qZG+wunbxMlk6GNRrnEajXOI1GucRqNc4jUa5xGo1zhevPcj9T
+ I32F07ZyOKIi41GucRqNc4jUa5xGo1ziNRrnEycmVojerkb7C6kajXOI1GucRqNc4jUa5xGo1z6+RvsL
+ 1+RvsL1+RvsLqRiJSmaurPa648gcw3QCcO8b/pb61Vx7rOVx7V3BtG9aeRvsLoWqtPNr0S1r+vPKp0Zb
+ f463cuXcGJ2enk2uj9dcBk9r8tsRdt9tvjULc7b/AMWFnsSL73ybLyY2XksNXa6zN77T4R4545zy4Mdv
+ JjBeKwjZpZG+wuh9aXtD+7Fzf5GogkTJvsqxhoqq+x6y1G232TYnF7Ujt6Bbwrbb6v8AJx/foRgu/K31
+ b9XjjI5CV9VP1zv7642cdpRJn8vSyN9hf9ZJPNv9bKE5Pk7+WKv5IYwTVT9kGMyMxP8AYdZjb/0gxR2/
+ 2+O4t7tv/GLM5hZeC4l5CS/IjJK2Tujq3+qD64UZxFnvylSDkRhFOjkb7C6H1pKTqsm7i50wW3d4mnKS
+ 5bXf1w+xKOonaH5iucRyGtdl05WyHw3DBk2vYsbbN5smwu3WQuX7zeeKqcm3BRjDjfk7IsZn/I3J62V3
+ 47VXVXvo5G+wuhbS6U7s9KJVKn6bSVK7mkhOoTqqfgPgPgPgPgDNyyqVbzTsDDTDqtPI32F06K6y6kb5
+ VSCTiVFPxFW9NFKx7JKB6o9TVq5G+wuqSoOT1lyHfYpUvUq6tfI32F6/I32F6/I32F6+4/8A2H1//9oA
+ CAECAgY/AP1VoaF1hEY24TbLC+0CL+1zZgHpQAnxIHy2pJwHqL/b+a2lwHEoj/JtwWkyQPQQPiNq6XMW
+ KqWh4ND4rTpdMtyrEw2QET5bd/ZsizkV9mYwj8FjUTinLiBcY4+FvxsU5OTNjfDyxslaYckvl3xgT8lp
+ zmGdwjR9rKQPK2nt/Wf5ltD3ov8AQthanXcP5ptqMmjmhGzvmPu59m3GGEPbb8DzC9c49UQcIZodwBGy
+ JJ22m6fJIzAxEe6GYfAbSJc4rmmYQO8C/wA7Yy/M/NbNUT5QPdG8+wQ7GaR5haTEGBvhDuNpchNXZVuz
+ SzHHbAZgDfeLrrDToESgLjtjjm9sYx2bLcmfqbtTgelQDAHYYFiLu4C/vFqfT/xBAltHNDHi2R97v2Wo
+ IzyvIAGEYwhvuw32wtL1LnEFRww3EYx391mq6SqaTPOMI37xAgiO3GNmqZ09ptURxHZHHaSSe8nys2p8
+ 4xI4Ye6FxjujhZWq6jlMkSrY44iG2MBhDDG00SK2Y6sIRbdhAEtDzFi8xyznab+yAqYEWWXVjmye/wCk
+ PHb42zUs4E7RgR7RbC2FsLYWwsZs+YqSxtNmlackT9ci7wHz2M2oml3Pf2gTJMwq42gwssrUkzL9cY+I
+ 22E2mmq6bvl/gLzGCoNpus0qgUTJv1voj2d9uZVTix7tg9g7YJtLOZHHd8osVqKXNVbCOE7zf8Viaice
+ XsUXAeH6EP/aAAgBAwIGPwD9Va0sODMGIs+VwcuO6379fOxmiYOWNuy2ZGivf2vT6N2+/qXZVH7MtnJ8
+ l+G3UWnu/wBxLpiQN8af7Rt13zHjyJzhd0Od8wt/uDbUtSaZ/qFdoH+0QfLbperpJ5SbPSTmIujmk5z5
+ tfbTa3Wp8Jk6blQtiwd8ssX3nMeH3YEXdm/FTtOqp8gcRkoHy7yMwMN4Bsuk6clQKsozetAoguP0jf4W
+ /wCr5Kj8y/EcngGXPGEY5o5dsYYX2qOmFD/mUumE83DLkLKtxjGMXF0O+2nUyBhS0r1MoKe9JM5XYjew
+ ut1fKjhRn46X57f+pX8NRN/5FuK2sTo4TG/xpdujtR6j09qqSKam5SARBmmnBGYEhYZQ0c2Ydyk2HVRo
+ 1pelaZwZQV14uYJQbEO7q5gGyKqiOUC+NB1hqaOJLKFcKATnEwyWIEQIF1JF9wNtTrdNWdyqQAvmUA3q
+ zekAmNynutwVf92v27CTpGmV0xI3vywJa/tOWh4CJ3djl9Q01EsrUwrKWT0hwwgcyi4nfj32q9Wqv/O5
+ M+cCwlVssrEpCC8xuS0xCF9LDPBoXEAwEzrEtLaudoMkCJZlwC8qGIUKFCmOYEBiSYxGo6V0RSydXmMO
+ bNZlLssRmXOkpHJYCAZmIW4lGwtrPWA0hHesk8syuYQEvkmIfISf3WGUcW6/qvLpKTfzSYzmMwry83Mu
+ HoOaHM93DfbitW9FjTVaXOYnnZyCIur8GWB4YcW20rp3qHQZOp6VL4A5UFQLwrB0mK4U8MQpUbSAAJGi
+ adpcrT9ClsDykIJbLwgkKiqq4hFUCOJaAhJ6G/LVEtGjzs5ifv2ncGWH0svFsjutPldP6Oa+TUBVmyr1
+ HpJKtzIESyuZr2DCDGKkwIoW1Xpmkppkty+SSQBFoZg7S0lBwYCIKteLjjGXS0VOkqnQQCqAoHgOyNLm
+ oGlsIEERBHcQbjabW9PzBQ6kYnKBGSx3risTtW7dYyNc095aR9MweqW29XF3gYHdbitxW4rcVuK0uh0q
+ kmz6tzcqAk/xDeYC0qu6zqSiY/h5ber2O4uG8L52Sh0iglyKVdiCEd5OJO8kntEyj1GklzqVxAq6hgfA
+ 2nah0TUcmdeTTuYodyNivsMRZ6DXNPm09SDgwMDvU4Eey2JtLpaOQ82ocwCqCxJPcBaTX9XTmoqEwPKF
+ 85h72xPjsKTQtNlyVhe0Iu29nN584dseg13TZVRTsPpARG9WxB3iyTdJ17laETFkeJmr7qEKQRvYx3WR
+ NH05TVw9U54NMJ2+o4ewfoQ//9oACAEBAQY/AM6WhozpzZamlqzZzGbWtrbcxqwQtza3IaweUqJAgRJX
+ kpMjRI0xQSyiiwhAWAMAhhCEIQt18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFC
+ t/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4o
+ Vv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfF
+ Ct/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4
+ oVv68t18ZzfFCt/XluvjOb4oVv68t18ZzfFCt/XluvjOb4oVv68t+3lZ/wCya6R/2ofOsP8A08/x79s+
+ dP8AHv8AnbZ8e+bND23fPt/0Z7Z8e+bND23fPt/0Z7Z8e+bND23fPt/0Z7Z8e+bND23fPt/0Z7Z8e+bN
+ D23fPt/0Z7Z8e+bND23fOFRsjIjWqDFC1nSrFiVnfnshnIe35pplG5OSOmWl8exIhPb4kTBCmSKFB6hQ
+ UQQUaeaUUNM/xSrXBvNRJnJaclpqtkZDO3K2HLl8IXuTg+0sztMkYZmi1owmp1B4BqDijAxEjXNapfS6
+ dPS61YWsW0gvEJfSDjUB6g+oHHuoOiostU6d1CrVKlEpU1aMKZMEbknCncgJ04F5C8sutWWm2Bpeljk9
+ stAHNrOBM8ODw6PFX0pTrsWnbEaql6ZcleLOTxpQkkozyhlGlBSq3ImJS9UhXPDC9NKJz1MNVubWuQJX
+ C8Z2OoS5FQqIKKV67BUzauhdxFpRuCY7+5nlCHwv0Z7Z8e+bND23fOEbTYkLWgx1WoEqVKvozM5ceMh1
+ ccrUTS5FipqhH9MrROqbN1rWJgpzDlBycQAhKievZyHI9udKaWnKRost3IpvX0qe7nibqizOyrOaF5ba
+ oyfzgMgiqBpeyJY2DYWBwTrgEgi5AVBZHdxWbPXGpRjMpntjpS7vGPuqGzeK+HRgur3H9eYx5PeYlrz6
+ jEpitKU3UmJjo+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+AI9npvTRmQSmR2OxDTi75kaVN4V4dKu043iupM
+ YDHFJzUn6mnJeonFZs9calGMyme2OlLu8Y+6obN4r4dGC6vcf15jHk95iWvPqMSmK04X6M9s+PfNmh7b
+ vnCUpupMTHR92fTkzOeEbyjVDPT20POk1inKmKb8AR7PTemjMglMjsdiGnF3zI0qbwrw6VdpxvFdSYwG
+ OKTmpP1NOS9ROKzZ641KMZlM9sdKXd4x91Q2bxXw6MF1e4/rzGPJ7zEtefUYlMVpSm6kxMdH3Z9OTM54
+ RvKNUM9PbQ86TWKcqYpvwBHs9N6aMyCUyOx2IacXfMjSpvCvDpV2nG8V1JjAY4pOak/U05L1E4rNnrjU
+ oxmUz2x0pd3jH3VDZvFfDowXV7j+vMY8nvMS159RiUxWnC/Rntnx75s0Pbd84SlN1JiY6Puz6cmZzwje
+ UaoZ6e2h50msU5UxTfgCPZ6b00ZkEpkdjsQ04u+ZGlTeFeHSrtON4rqTGAxxSc1J+ppyXqJxWbPXGpRj
+ MpntjpS7vGPuqGzeK+HRgur3H9eYx5PeYlrz6jEpitKU3UmJjo+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+A
+ I9npvTRmQSmR2OxDTi75kaVN4V4dKu043iupMYDHFJzUn6mnJeonFZs9calGMyme2OlLu8Y+6obN4r4d
+ GC6vcf15jHk95iWvPqMSmK04X6M9s+PfNmh7bvnCUpupMTHR92fTkzOeEbyjVDPT20POk1inKmKb8AR7
+ PTemjMglMjsdiGnF3zI0qbwrw6VdpxvFdSYwGOKTmpP1NOS9ROKzZ641KMZlM9sdKXd4x91Q2bxXw6MF
+ 1e4/rzGPJ7zEtefUYlMVpSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvwBHs9N6aMyCUyOx2IacXfMj
+ SpvCvDpV2nG8V1JjAY4pOak/U05L1E4rNnrjUoxmUz2x0pd3jH3VDZvFfDowXV7j+vMY8nvMS159RiUx
+ WjEF5bKmcVLstYDIms6bMpsIG3VI49341ClITl5AVeYNaU05tHERPTmrQKVClGelJPAJpT1OQgVj1zVD
+ LTj4CMi8N+hLU1PNdSIQXD42NK0y7ROxYb8BQ0anRfJDlKUwlQbwf0Z7Z8e+bND23fOEpTdSYmOj7s+n
+ Jmc8I3lGqGentoedJrFOVMU34aHgbDOInZlygbE7bsC8LNCpKu7tSpWuuz+7FVLAsx4quyC9KZtUrFk1
+ /hKl+LckhVVomdCwyi1+ZaSbEjlsC8KLhU9Ie6alTrrynu7EU/q9c2poGaULkNYpxL9SpWGOYTa1pTdS
+ YmOj7s+nJmc8I3lGqGentoedJrFOVMU34aHgbDOInZlygbE7bsC8LNCpKu7tSpWuuz+7FVLAsx4quyC9
+ KZtUrFk1/hKl+LckhVVuKzZ641KMZlM9sdKXd4x91Q2bxXw6MF1e4/rzGPJ7zEtefUYlMVpSm6kxMdH3
+ Z9OTM54RvKNUM9PbQ86TWKcqYpvwhKlJLXozLhTc4fhmvO5eUusm5bZGibyfv7+Ykjpu8v591vMUWcH9
+ Ge2fHvmzQ9t3zhKU3UmJjo+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+KU3UmJjo+7PpyZnPCN5Rqhnp7aHnS
+ axTlTFN+KU3UmJjo+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+KU3UmJjo+7PpyZnPCN5Rqhnp7aHnSaxTlTF
+ N+KU3UmJjo+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+HFZs9calGMyme2OlLu8Y+6obN4r4dGC6vcf15jHk9
+ 5iWvPqMSmK0pTdSYmOj7s+nJmc8I3lGqGentoedJrFOVMU34QlSklr0ZlwpucPwzXncvKXWTctsjRN5P
+ 39/MSR03eX8+63mKLOD+jPbPj3zZoe275wlKbqTEx0fdn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx0f
+ dn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx0fdn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx0fdn05Mz
+ nhG8o1Qz09tDzpNYpypim/FKbqTEx0fdn05MznhG8o1Qz09tDzpNYpypim/CJnQsMotfmWkmxI5bAvCi
+ 4VPSHumpU668p7uxFP6vXNqaBmlC5DWKcS/UqVhjmE2taU3UmJjo+7PpyZnPCN5Rqhnp7aHnSaxTlTFN
+ +EJUpJa9GZcKbnD8M153Lyl1k3LbI0TeT9/fzEkdN3l/Put5iizg/oz2z4982aHtu+cJSm6kxMdH3Z9O
+ TM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54Rv
+ KNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9P
+ bQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TW
+ KcqYpvwhKlJLXozLhTc4fhmvO5eUusm5bZGibyfv7+Ykjpu8v591vMUWcH9Ge2fHvmzQ9t3zhKbXpKRv
+ SsaYWMcNjGd8mlTJUPdaptcO/Y+6zW6JViS1YYK4Ga4rI4rcqyVapwOT1nSm6kxMdH3Z9OTM54RvKNUM
+ 9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86
+ TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqY
+ pvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvwWoUFoizC0TagCFA2tzUREhqbkrWlMMStaVGmNWmp
+ kYBKVIgRULFERqFAzTzTDB8H9Ge2fHvmzQ9t3zhEbbURTKiknpI5mOr4gppalWJVtc5SHHIQQUZHZqvM
+ cLZqZczz4KRHIxIzjgEJjLxc1VDSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54
+ RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM
+ 9PbQ86TWKcqYpvxSm6kxMdH3Z9OTM54RvKNUM9PbQ86TWKcqYpvwmZRtaKD27UzT0LstmYWxxbCHKich
+ Kgbn1VFxyKpN2ORPBbK4gIOQu5ihQNScfBUemULHCq+E+jPbPj3zZoe275wtKbqTEx0fdn05MznhG8o1
+ Qz09tDzpNYpypim/FKbqTEx0fdn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx0fdn05MznhG8o1Qz09tD
+ zpNYpypim/FKbqTEx0fdn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx0fdn05MznhG8o1Qz09tDzpNYpy
+ pim/HC/Rntnx75s0Pbd8+3/Rntnx75s0Pbd8+3/Rntnx75s0Pbd84Utio6m32qno0sRxbTTrSveXERIB
+ lgMPk24hQfAgsZoYCHEOoHWhpjDTZ+ZmKh6peXGlTlpFTkNbKvXhp4xtGoLXY2oSkmpmotKYlMgMZ4wA
+ hEEfT6P3HesmykajW0iwACN6qkhnXjp1s11BKQBat6uINxSgxQoAAJUTLwUY+gMdEdH7hzTlzRdQVetS
+ hKGtgzIDVCZvAfEYSDHNwFACBsKOEWKABKDSwiiGMIRjGFk9O5j0uvpR5VoQuSVC4DSGDUt4zz0oFhBq
+ JQqIOTDUJjAQGEcYREWKHHCPB/Rntnx75s0Pbd84Emh8v25O61EehWuRSRU4oWsqKRvAExUOKtwPTpoC
+ AEcNAYi0i+6xjxCgETeMN5cszpVNOonpVAowRcYlphuIk5GtEMYhgecTEQdEYaYRDGNRZW01SwwV1Sbe
+ 4OdQML2uQsChuTNbk2tKy9MdT0pIjS1ruRAIQijEYB64dIYabQycp5sTK6+i61Ey4Wa5oEqbEKVSuq16
+ KxNQeW36qdOzKIhHeapkQQgGMYihpzNoOskRTfUtO5QPSZ1RkLEq8kg5TVeWS8kIFiI05MfASVWAWkAo
+ whGOiPphG3/6B6f9M6s/9SbcUbZnQ0enGXb23pe0X+haNEKmb08gupn1wRMTMrUJhiKOJbjVxoFbrdHl
+ iKGNKScUUaAQDBhFCMLJB5kUie1tjifFK3VAhVJHdgWqYBMMgmA5txx5SZYMokYwkKIEniACIoA1YRjY
+ uj8qmptYM+ahXKnhyUlOTCMeh1qyIAuJTsrOG0Tocv0yUsuIxDETHTAMAmwhEOZuZHeWpdmzCr+paabk
+ GVz/AFUtZKjOSpkrM+pAQTJSzTm1oOIcRphgNMJAaEzSZAUBRGKLM75mMCBnQv65Q2thqR+ZngRytMng
+ qOAMtsWKTCQhJjp1hQhCPFwX0Z7Z8e+bND23fOBav+5lX/5onthm3lV4V047F4Rja/B9lMZwrAcIvsNw
+ 2U/5O60X367+7frLZompyCiTF3duQK1gywQCJSphUeXaSB50Yf0zZZIWDTH06oIQ+60Rwh+EGZefEYx/
+ tqczIDCH5/TbvHD0emOWx8NOj/KsoP5rd/j0f06wqrT/AKxv57cX8n+9bMsGj0ReXT0f+NaZj/uW7sKK
+ jXlzpYh8ZstwvEGBaoajHEtVlwe+KiVR6Iwk8whU8DipNL1tQw6EBChGIQ6HJfmmrcHd0XLEB1FqagUG
+ q3wSSOYjcXT5pKlwHBaMIEBakwmMRijFq9ANJMQhtTb6U/PRb3i5pWMFui4DrdhzyfEYS8QCfBXqBSAC
+ VCGvogXCAf6MNFu84JwenZcJsZkGGxWOKxTFv00xWJkZGJ5w4pNJhYRfq9X8QYR44QsSS+1E+vRKcYjS
+ CnZ3cHEsgwQdURhIFig4JYxB9EYhhCMYcF9Ge2fHvmzQ9t3zgNWBhYI/dAwWrp/NHRGFmowerEOxtXQ/
+ DHTxpE+j7rX2pHR4kpjV0C17naa+19XV06tz+LTxavp4rZiHxiGAB92pCUGEY/iiOFVUKPRCH3/hBGP8
+ VjdYscDA5l56jO0hFCJUMBzEBoMhGEIg0DHAMdP9aOi3eLj/AOW5/wDnWUVu/n/DWFU6P9YtuKP7/wCO
+ 2ZMOeHT20pm3drqnOeiVOYLe3UXliGlKfITAWJDqrFluREkbkSqWpGkaMtCQogOCqCgEIRjEJJg4QhAz
+ ONzpRBR3d7pJQVGnWhG8N8U56w58T0aFQNPflOz85pF6sSeB0UiZInJgbAkIYxMiOnkxcYaYPaiIdPoh
+ qxz4fhwhHj9MAxt3pSxQhERrO3wBAOmMYx2XrIOjRo06YxjbjB+mP81tJhhQfyB1o60fzQ0cD9Ge2fHv
+ mzQ9t3zgWsgQ4iL2Nq6MIC9MQxgkT6NEePRbMVGf3eaQeMy6NqZ/pdvzCKWNLa9r0jece1ozFjgZSi19
+ IgBvCEowstYMJoYRCG7CKAQq+8GIbaqqdyUDKdGgZQy2RVTw0idtDTYCwjioIRJm5GSAk2AxHBNJAaOJ
+ g9bWDV1E92+h2KvHM8jaaq1y1vUuzk3RNTjcUEHdqphmeFJy4oqIAnqDxgJEEIhEm6NWGYOf5dBoFyyv
+ aeHT51MjqA8hM2gGbShk0W6BaTTVQobLBhqxIBD9dH0/hhpzxuKGQu/TW7ObqqvX49Hs+Jy2g1iU+o1K
+ MQgVj0dAhXWm6h6IafR936YfzWqLu6go9GpRVArUqx1UJ6OKVJYqXhud4gC0wbhkmwAJugDTE8OmA9P3
+ aIo8pc1cr6eziodp1S2RO9moAHt6QkYj0iBWjdWR8a3lMgPjoTRGWScnBHRAYwgAALZltS9FM2WGWTSo
+ IUF0yzHkqRrooIxw0lQYlbWhAibUQ4xNLSJ0wABNjCIhmRACIUHdpjR6MKFArGrhVuMnRVmRHWq2s9SL
+ Rh0CQQgasin0zEfwh1+OOrZ5c29qb6jp6pkyJNUlNr1ZjfFdBsMUjb1SByJTq4oF6WdPAEQyFBQizhwE
+ XGOqILXT1Ad3qksrlDa6HOe0zWehIcTJwEAOCQDbT7HT7eYFcIgkQzVUVQvwfgCWKOvGIhiiIUeOIoxj
+ H+Xgfoz2z4982aHtu+cCVWmXL7s7UpCJY3lOWGM7vqo14AlqyZN9b3NAK9ACENaJURB/qxhZ8rCp18XO
+ o6kc1by8uMEyNFFY5LjRHqlMo3J0iFNemijHUJKLLDxQDCFoBPhfFw0Q0/14Q4uP+t/HbSSMAo/eGMYw
+ HD84Y+m3EH9NuIP6bcQf024g/ptxB/TaIzIgAGHHEQtELRAlBCMf76KEdH/BDHj/AI7RGYMQxR++Mf7E
+ OKEOD+jPbPj3zZoe275wkBAEIAocUQxjCNoAVh14f30MIa0P7aHFG0BkjgMP8EQ6YfnhxwtxR/4toiHG
+ AQw9MYiiGEIfptECaF6Pi146LuH5vR+K2scZEX5IcQYfmDxQ4X6M9s+PfNmh7bvnDQGSYIAofkj6I/nh
+ xRtoMJ1joQ0QEHRAEf4Yw06YRtGJo46v3Fh/CCH5PRDjjw/0Z7Z8e+bND23fPt/0Z7Z8e+bND23fPt/0
+ Z7Z8e+bND23fPt/0Z7V5/smv2zqjrH6w/wDpxd+3n/bP/rT/AC69t8me3yZ7fJnt8me3yZ7fJnt8me3y
+ Z7fJnt8me3yZ7fJnt8me3yZ7fJnt8me3yZ7fJnt8me3yZ7fJnt8me3yZ7fJnt8me3yZ7fJnt8me3yZ7f
+ Jnt/8M//AGZ/v/8Apnb/2Q==
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+ENBkV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDg6MjgAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAAL3AAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUpJJIAkgASTwBqSkpSSRBBgggjkHQpJKUkkk
+ kpSSSSSlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jqv+rYkp//0dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/
+ AFb0JJSkkkklKSSSSUpJJJJTOmsWWBpMDkx5KxXU2q8bSSHMdzyINff+0g4v89/ZKsn+eZ/Uf+WpJTF9
+ bX3NDhIDCY7TIbr/AJyBfUBaG1gy5s7RrxP0f81Wf8OP+LP/AFTUv8Mf+Lb/ANU5JTRIIJBEEaEHkJI2
+ X/Oj+oPyvQUlKSSSSUpJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//S1sv+mZP/AB1v/VvQkXL/
+ AKZk/wDHW/8AVvQklKSSSSUpJJJJSk7GOe4Mbyf9ZTImN/Pt+Dv+pKSklVT6rxuggtdBHlCMf55n9R/5
+ aknfz1fwf/3xS2jcHdwCPvLT/wB8SUx/w4/4s/8AVNS/w5/4sf8AVOUto3751gt+RId/BLaN++dYDfkC
+ XfxSU1cv+dH9Qflego2X/Oj+oPyvQUlKSSSSUpJJJJSkXE/pmN/x1X/VsQkXE/pmN/x1X/VsSU//09bL
+ /pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpExv59vwd/1JQ0THIFzZMcj5kFrUlNstJs
+ Y7s0OB+e2P8AqVJJJJSkkkklNTL/AJ0f1B+V6CjZf86P6g/K9BSUpJJJJSkkkklKRcT+mY3/AB1X/VsQ
+ kXE/pmN/x1X/AFbElP8A/9TWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSBIIc3Rw
+ Mg+Y4SSSU367GWN3N+BB5CkqVFwq3SCd0ceU/wDkkX7Yz9x33hJTYTOc1jdzjDREnU86fmygfbG/uO+8
+ KNuQ2yssDSCY1JHYykpFY4Psc8CA4zrzxCikkkpSSSSSlJJJJKUi4n9Mxv8Ajqv+rYhIuJ/TMb/jqv8A
+ q2JKf//V1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJSZTfZrVU+wTtljS73c7faPpJKY
+ pKfoZHqGn0rPVaJdXsduA/eLI3bU9NL7XVna70X2sqdaAdoL3NbG/wChv2uSUjSWpldLxqW9Tcxzz9hd
+ U2oEjXeK3PdZp7vprMax7p2Nc7aC520Ew0cuO381JSySP6Hp0Xi/Hvbe3Ya37S1jAT7vX3R/Of4NQZjZ
+ NjDZVRbZWPz2Mc5v+c0JKRpK9j9NdbgZd5Zacmh7GV0hpn3lk7qtvqfQeq9WJkWZTMT03sucQC1zXS0E
+ x6j2xu9Nv76SkKSPm4V2He+qxryxrtjbiwsa/SfZulv/AE0BJSkkkklKRcT+mY3/AB1X/VsQkXE/pmN/
+ x1X/AFbElP8A/9bWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSlq4VttPQM19L3Vv9dgDmGC
+ J9IOhwWUtbpwxj0LNGS57KjeyXsAc4H9HtO0/S9ySjt3dLDe+zI6bc8l1tnT7C+w/SdrjO9x/tLL6d/y
+ BV/6cMf8uOj19YwqszFFTXuxcWh2NvcIeQ7Z7w3+T6LEL7T03HwmYWM62wMyary97QJDHMLg36P0a604
+ RJYZZ4xsHQju288fo+ueb6P+pqVX6vEszb3N0Ix3kHzBYnyupY1repBm79cdUapEaMDGu3/u/QVfpeXT
+ iX22Xbtr6XVjaJO5xb/5FO4dDowHMPcHq016/wBaTPGstt6H1Oy17rLHelL3kucdW9ytB9uRX1XpVNL3
+ toNDP0bCdhEP3y1vsd7QxZWLkV19NysN0+rkmsV/u+0t+m/81bFjH4mNVg/acqo0NPq2UUuex273e217
+ Ldja2/6J6RCYZCQDewF6/pccvT/itU221YfXLKnuZYMsAPaYcAXsZo7+r7U3r3ub0G51jjdY9zLLJ9zm
+ 72ex7vzm6KpXk41fTszEZvJvsY6kuA1a0sO6wj852xJ+fS2jprWNLrMFxe9pEA+5r4a7+ymmBDLHmBKg
+ ASauhr14WHWb739Ryan2vfWy07GOcS1ug+g381Uld6pb0/Itdk4tlptufufU9gAaIj6f724fy1STWcKS
+ SSSUpFxP6Zjf8dV/1bEJFxP6Zjf8dV/1bElP/9fWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJ
+ JSlIXXNqdS17hS87n1g+0kRDnN/sqKSSlJw8jnUJkkQSNls4RmKkLCUOB4+5OgqTbCOdVJHIOujRzcnI
+ a4zxD90/MkidCivzsz0zU/JtNZG0sLiQR+6qzrD20UUpZB01Th5Se8yYA/ox+b/CXLyeNAmSSUZJO7dh
+ CMBURQUkkkguUkkkkpSLif0zG/46r/q2ISLif0zG/wCOq/6tiSn/0NbL/pmT/wAdb/1b0JWcrFyzl5BG
+ PcQbrSCKnkEF79foIf2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/bT/8AyCSkSSL9
+ kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/APyCSkSSL9kz
+ P+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/bT/8AyCSkSSL9kzP+
+ 413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/APyCSkSSL9kzP+41
+ 3/bT/wDyCX2TM/7jXf8AbT//ACCSkSLif0zG/wCOq/6tiX2TM/7jXf8AbT//ACCJi4uWMvHJx7gBdUST
+ U8AAPZr9BJT/AP/Z/+0V3lBob3Rvc2hvcCAzLjAAOEJJTQQEAAAAAAAvHAFaAAMbJUccAVoAAxslRxwB
+ WgADGyVHHAFaAAMbJUccAVoAAxslRxwCAAACAAAAOEJJTQQlAAAAAAAQbrNy3vn/dsPQ3CJIvyt90zhC
+ SU0EOgAAAAAAmwAAABAAAAABAAAAAAALcHJpbnRPdXRwdXQAAAAEAAAAAFBzdFNib29sAQAAAABJbnRl
+ ZW51bQAAAABJbnRlAAAAAENscm0AAAAPcHJpbnRTaXh0ZWVuQml0Ym9vbAAAAAALcHJpbnRlck5hbWVU
+ RVhUAAAAEwBDAGEAbgBvAG4AIABNAFAAMQA0ADAAIABzAGUAcgBpAGUAcwAAADhCSU0EOwAAAAABsgAA
+ ABAAAAABAAAAAAAScHJpbnRPdXRwdXRPcHRpb25zAAAAEgAAAABDcHRuYm9vbAAAAAAAQ2xicmJvb2wA
+ AAAAAFJnc01ib29sAAAAAABDcm5DYm9vbAAAAAAAQ250Q2Jvb2wAAAAAAExibHNib29sAAAAAABOZ3R2
+ Ym9vbAAAAAAARW1sRGJvb2wAAAAAAEludHJib29sAAAAAABCY2tnT2JqYwAAAAEAAAAAAABSR0JDAAAA
+ AwAAAABSZCAgZG91YkBv4AAAAAAAAAAAAEdybiBkb3ViQG/gAAAAAAAAAAAAQmwgIGRvdWJAb+AAAAAA
+ AAAAAABCcmRUVW50RiNSbHQAAAAAAAAAAAAAAABCbGQgVW50RiNSbHQAAAAAAAAAAAAAAABSc2x0VW50
+ RiNQeGxAUgAAAAAAAAAAAAp2ZWN0b3JEYXRhYm9vbAEAAAAAUGdQc2VudW0AAAAAUGdQcwAAAABQZ1BD
+ AAAAAExlZnRVbnRGI1JsdAAAAAAAAAAAAAAAAFRvcCBVbnRGI1JsdAAAAAAAAAAAAAAAAFNjbCBVbnRG
+ I1ByY0BZAAAAAAAAOEJJTQPtAAAAAAAQAEgAAAABAAIASAAAAAEAAjhCSU0EJgAAAAAADgAAAAAAAAAA
+ AAA/gAAAOEJJTQPyAAAAAAAKAAD///////8AADhCSU0EDQAAAAAABAAAAHg4QklNBBkAAAAAAAQAAAAe
+ OEJJTQPzAAAAAAAJAAAAAAAAAAABADhCSU0nEAAAAAAACgABAAAAAAAAAAI4QklNA/UAAAAAAEgAL2Zm
+ AAEAbGZmAAYAAAAAAAEAL2ZmAAEAoZmaAAYAAAAAAAEAMgAAAAEAWgAAAAYAAAAAAAEANQAAAAEALQAA
+ AAYAAAAAAAE4QklNA/gAAAAAAHAAAP////////////////////////////8D6AAAAAD/////////////
+ ////////////////A+gAAAAA/////////////////////////////wPoAAAAAP//////////////////
+ //////////8D6AAAOEJJTQQAAAAAAAACAAQ4QklNBAIAAAAAAA4AAAAAAAAAAAAAAAAAADhCSU0EMAAA
+ AAAABwEBAQEBAQEAOEJJTQQtAAAAAAAGAAEAAAANOEJJTQQIAAAAAAAaAAAAAQAAAkAAAAJAAAAAAgAA
+ D6ABAAAPsAA4QklNBB4AAAAAAAQAAAAAOEJJTQQaAAAAAANJAAAABgAAAAAAAAAAAAAA+gAAAPoAAAAK
+ AHAAdQBsAGwAXwByAGkAZwBoAHQAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAPoAAAD6
+ AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEAAAAAAABudWxsAAAAAgAAAAZi
+ b3VuZHNPYmpjAAAAAQAAAAAAAFJjdDEAAAAEAAAAAFRvcCBsb25nAAAAAAAAAABMZWZ0bG9uZwAAAAAA
+ AAAAQnRvbWxvbmcAAAD6AAAAAFJnaHRsb25nAAAA+gAAAAZzbGljZXNWbExzAAAAAU9iamMAAAABAAAA
+ AAAFc2xpY2UAAAASAAAAB3NsaWNlSURsb25nAAAAAAAAAAdncm91cElEbG9uZwAAAAAAAAAGb3JpZ2lu
+ ZW51bQAAAAxFU2xpY2VPcmlnaW4AAAANYXV0b0dlbmVyYXRlZAAAAABUeXBlZW51bQAAAApFU2xpY2VU
+ eXBlAAAAAEltZyAAAAAGYm91bmRzT2JqYwAAAAEAAAAAAABSY3QxAAAABAAAAABUb3AgbG9uZwAAAAAA
+ AAAATGVmdGxvbmcAAAAAAAAAAEJ0b21sb25nAAAA+gAAAABSZ2h0bG9uZwAAAPoAAAADdXJsVEVYVAAA
+ AAEAAAAAAABudWxsVEVYVAAAAAEAAAAAAABNc2dlVEVYVAAAAAEAAAAAAAZhbHRUYWdURVhUAAAAAQAA
+ AAAADmNlbGxUZXh0SXNIVE1MYm9vbAEAAAAIY2VsbFRleHRURVhUAAAAAQAAAAAACWhvcnpBbGlnbmVu
+ dW0AAAAPRVNsaWNlSG9yekFsaWduAAAAB2RlZmF1bHQAAAAJdmVydEFsaWduZW51bQAAAA9FU2xpY2VW
+ ZXJ0QWxpZ24AAAAHZGVmYXVsdAAAAAtiZ0NvbG9yVHlwZWVudW0AAAARRVNsaWNlQkdDb2xvclR5cGUA
+ AAAATm9uZQAAAAl0b3BPdXRzZXRsb25nAAAAAAAAAApsZWZ0T3V0c2V0bG9uZwAAAAAAAAAMYm90dG9t
+ T3V0c2V0bG9uZwAAAAAAAAALcmlnaHRPdXRzZXRsb25nAAAAAAA4QklNBCgAAAAAAAwAAAACP/AAAAAA
+ AAA4QklNBBQAAAAAAAQAAAAjOEJJTQQMAAAAAAv4AAAAAQAAAKAAAACgAAAB4AABLAAAAAvcABgAAf/Y
+ /+0ADEFkb2JlX0NNAAH/7gAOQWRvYmUAZIAAAAAB/9sAhAAMCAgICQgMCQkMEQsKCxEVDwwMDxUYExMV
+ ExMYEQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAQ0LCw0ODRAODhAUDg4OFBQODg4O
+ FBEMDAwMDBERDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAz/wAARCACgAKADASIAAhEB
+ AxEB/90ABAAK/8QBPwAAAQUBAQEBAQEAAAAAAAAAAwABAgQFBgcICQoLAQABBQEBAQEBAQAAAAAAAAAB
+ AAIDBAUGBwgJCgsQAAEEAQMCBAIFBwYIBQMMMwEAAhEDBCESMQVBUWETInGBMgYUkaGxQiMkFVLBYjM0
+ coLRQwclklPw4fFjczUWorKDJkSTVGRFwqN0NhfSVeJl8rOEw9N14/NGJ5SkhbSVxNTk9KW1xdXl9VZm
+ doaWprbG1ub2N0dXZ3eHl6e3x9fn9xEAAgIBAgQEAwQFBgcHBgU1AQACEQMhMRIEQVFhcSITBTKBkRSh
+ sUIjwVLR8DMkYuFygpJDUxVjczTxJQYWorKDByY1wtJEk1SjF2RFVTZ0ZeLys4TD03Xj80aUpIW0lcTU
+ 5PSltcXV5fVWZnaGlqa2xtbm9ic3R1dnd4eXp7fH/9oADAMBAAIRAxEAPwDaysrLGXkAZFwAutAAteAA
+ Hv0+mh/a8z/uTd/26/8A8mll/wBMyf8Ajrf+rehJKS/a8z/uTd/26/8A8ml9rzP+5N3/AG6//wAmhJJK
+ S/a8z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS/a8z/uTd/wBuv/8AJpfa8z/uTd/26/8A8mhJJKS/
+ a8z/ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a8z/uTd/26/8A8ml9rzP+5N3/AG6//wAmhJJKS/a8
+ z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS/a8z/uTd/wBuv/8AJpfa8z/uTd/26/8A8mhJJKS/a8z/
+ ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a8z/uTd/26/8A8miYuVlnLxwci4g3VAg2vIIL2afTVZFx
+ P6Zjf8dV/wBWxJT/AP/Q1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSkkkklKSSSAJ
+ IAEk8AakpKUkkQQYIII5B0KSSlJJJJKUkkkkpSSSSSlIuJ/TMb/jqv8Aq2ISLif0zG/46r/q2JKf/9HW
+ y/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUzprFlgaTA5MeSsV1NqvG0khzHc8
+ iDX3/tIOL/Pf2SrJ/nmf1H/lqSUxfW19zQ4SAwmO0yG6/wCcgX1AWhtYMubO0a8T9H/NVn/Dj/iz/wBU
+ 1L/DH/i2/wDVOSU0SCCQRBGhB5CSNl/zo/qD8r0FJSkkkklKSSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HV
+ f9WxJT//0tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpOxjnuDG8n/WUyJjfz7fg7
+ /qSkpJVU+q8boILXQR5QjH+eZ/Uf+WpJ389X8H/98Uto3B3cAj7y0/8AfElMf8OP+LP/AFTUv8Of+LH/
+ AFTlLaN++dYLfkSHfwS2jfvnWA35Al38UlNXL/nR/UH5XoKNl/zo/qD8r0FJSkkkklKSSSSUpFxP6Zjf
+ 8dV/1bEJFxP6Zjf8dV/1bElP/9PWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKRMb+
+ fb8Hf9SUNExyBc2THI+ZBa1JTbLSbGO7NDgfntj/AKlSSSSUpJJJJTUy/wCdH9Qflego2X/Oj+oPyvQU
+ lKSSSSUpJJJJSkXE/pmN/wAdV/1bEJFxP6Zjf8dV/wBWxJT/AP/U1sv+mZP/AB1v/VvQkXL/AKZk/wDH
+ W/8AVvQklKSSSSUpJJJJSkgSCHN0cDIPmOEkklN+uxljdzfgQeQpKlRcKt0gndHHlP8A5JF+2M/cd94S
+ U2EznNY3c4w0RJ1POn5soH2xv7jvvCjbkNsrLA0gmNSR2MpKRWOD7HPAgOM688QopJJKUkkkkpSSSSSl
+ IuJ/TMb/AI6r/q2ISLif0zG/46r/AKtiSn//1dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkkl
+ KSSUmU32a1VPsE7ZY0u93O32j6SSmKSn6GR6hp9Kz1WiXV7HbgP3iyN21PTS+11Z2u9F9rKnWgHaC9zW
+ xv8Aob9rklI0lqZXS8alvU3Mc8/YXVNqBI13itz3Wae76azGse6djXO2gudtBMNHLjt/NSUskj+h6dF4
+ vx723t2Gt+0tYwE+7190fzn+DUGY2TYw2VUW2Vj89jHOb/nNCSkaSvY/TXW4GXeWWnJoexldIaZ95ZO6
+ rb6n0HqvViZFmUzE9N7LnEAtc10tBMeo9sbvTb++kpCkj5uFdh3vqsa8sa7Y24sLGv0n2bpb/wBNASUp
+ JJJJSkXE/pmN/wAdV/1bEJFxP6Zjf8dV/wBWxJT/AP/W1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQk
+ lKSSSSUpauFbbT0DNfS91b/XYA5hgifSDocFlLW6cMY9CzRkueyo3sl7AHOB/R7TtP0vcko7d3Sw3vsy
+ Om3PJdbZ0+wvsP0na4zvcf7Sy+nf8gVf+nDH/Ljo9fWMKrMxRU17sXFodjb3CHkO2e8N/k+ixC+09Nx8
+ JmFjOtsDMmq8ve0CQxzC4N+j9GutOESWGWeMbB0I7tvPH6Prnm+j/qalV+rxLM29zdCMd5B8wWJ8rqWN
+ a3qQZu/XHVGqRGjAxrt/7v0FX6Xl04l9tl27a+l1Y2iTucW/+RTuHQ6MBzD3B6tNev8AWkzxrLbeh9Ts
+ te6yx3pS95LnHVvcrQfbkV9V6VTS97aDQz9GwnYRD98tb7He0MWVi5FdfTcrDdPq5JrFf7vtLfpv/NWx
+ Yx+JjVYP2nKqNDT6tlFLnsdu93ttey3Y2tv+iekQmGQkA3sBev6XHL0/4rVNttWH1yyp7mWDLAD2mHAF
+ 7GaO/q+1N697m9BudY43WPcyyyfc5u9nse785uiqV5ONX07MxGbyb7GOpLgNWtLDusI/OdsSfn0to6a1
+ jS6zBcXvaRAPua+Gu/sppgQyx5gSoAEmroa9eFh1m+9/Ucmp9r31stOxjnEtboPoN/NVJXeqW9PyLXZO
+ LZabbn7n1PYAGiI+n+9uH8tUk1nCkkkklKRcT+mY3/HVf9WxCRcT+mY3/HVf9WxJT//X1sv+mZP/AB1v
+ /VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpSF1zanUte4UvO59YPtJEQ5zf7KikkpScPI51CZJEEjZbOEZi
+ pCwlDgePuToKk2wjnVSRyDro0c3JyGuM8Q/dPzJInQor87M9M1PybTWRtLC4kEfuqs6w9tFFKWQdNU4e
+ UnvMmAP6Mfm/wly8njQJkklGSTu3YQjAVEUFJJJILlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv8Ajqv+rYkp
+ /9DWy/6Zk/8AHW/9W9CVnKxcs5eQRj3EG60gip5BBe/X6CH9kzP+413/AG0//wAgkpEki/ZMz/uNd/20
+ /wD8gl9kzP8AuNd/20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP
+ /wDIJfZMz/uNd/20/wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8
+ gl9kzP8AuNd/20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDI
+ JfZMz/uNd/20/wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEi4n9Mxv8Ajqv+rYl9kzP+
+ 413/AG0//wAgiYuLljLxyce4AXVEk1PAAD2a/QSU/wD/2ThCSU0EIQAAAAAAVQAAAAEBAAAADwBBAGQA
+ bwBiAGUAIABQAGgAbwB0AG8AcwBoAG8AcAAAABMAQQBkAG8AYgBlACAAUABoAG8AdABvAHMAaABvAHAA
+ IABDAFMANQAAAAEAOEJJTQ+gAAAAAAD4bWFuaUlSRlIAAADsOEJJTUFuRHMAAADMAAAAEAAAAAEAAAAA
+ AABudWxsAAAAAwAAAABBRlN0bG9uZwAAAAAAAAAARnJJblZsTHMAAAABT2JqYwAAAAEAAAAAAABudWxs
+ AAAAAQAAAABGcklEbG9uZwMhB98AAAAARlN0c1ZsTHMAAAABT2JqYwAAAAEAAAAAAABudWxsAAAABAAA
+ AABGc0lEbG9uZwAAAAAAAAAAQUZybWxvbmcAAAAAAAAAAEZzRnJWbExzAAAAAWxvbmcDIQffAAAAAExD
+ bnRsb25nAAAAAAAAOEJJTVJvbGwAAAAIAAAAAAAAAAA4QklND6EAAAAAABxtZnJpAAAAAgAAABAAAAAB
+ AAAAAAAAAAEAAAAAOEJJTQQGAAAAAAAHAAgBAQABAQD/4SSYaHR0cDovL25zLmFkb2JlLmNvbS94YXAv
+ MS4wLwA8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pg0K
+ PHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUg
+ NS4wLWMwNjAgNjEuMTM0Nzc3LCAyMDEwLzAyLzEyLTE3OjMyOjAwICAgICAgICAiPg0KCTxyZGY6UkRG
+ IHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+DQoJ
+ CTxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNv
+ bS94YXAvMS4wLyIgeG1sbnM6cGhvdG9zaG9wPSJodHRwOi8vbnMuYWRvYmUuY29tL3Bob3Rvc2hvcC8x
+ LjAvIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOnhtcE1N
+ PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvbW0vIiB4bWxuczpzdEV2dD0iaHR0cDovL25zLmFk
+ b2JlLmNvbS94YXAvMS4wL3NUeXBlL1Jlc291cmNlRXZlbnQjIiB4bWxuczpzdFJlZj0iaHR0cDovL25z
+ LmFkb2JlLmNvbS94YXAvMS4wL3NUeXBlL1Jlc291cmNlUmVmIyIgeG1wOkNyZWF0b3JUb29sPSJBZG9i
+ ZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgeG1wOkNyZWF0ZURhdGU9IjIwMTItMDMtMjFUMTI6Mzc6
+ MDErMDE6MDAiIHhtcDpNZXRhZGF0YURhdGU9IjIwMTItMDMtMjFUMTg6NDg6MjgrMDE6MDAiIHhtcDpN
+ b2RpZnlEYXRlPSIyMDEyLTAzLTIxVDE4OjQ4OjI4KzAxOjAwIiBwaG90b3Nob3A6Q29sb3JNb2RlPSIz
+ IiBwaG90b3Nob3A6SUNDUHJvZmlsZT0ic1JHQiBJRUM2MTk2Ni0yLjEiIGRjOmZvcm1hdD0iaW1hZ2Uv
+ anBlZyIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDpBNzU5QjEwQTBGMjA2ODExOTQ1NzlBMzNGQjM1
+ NjQ3OSIgeG1wTU06RG9jdW1lbnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFF
+ RTgxMSIgeG1wTU06T3JpZ2luYWxEb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlE
+ REYxNUE1QUVFODExIj4NCgkJCTxwaG90b3Nob3A6VGV4dExheWVycz4NCgkJCQk8cmRmOkJhZz4NCgkJ
+ CQkJPHJkZjpsaSBwaG90b3Nob3A6TGF5ZXJOYW1lPSJwdWxsIHJpZ2h0IiBwaG90b3Nob3A6TGF5ZXJU
+ ZXh0PSJwdWxsIHJpZ2h0Ii8+DQoJCQkJPC9yZGY6QmFnPg0KCQkJPC9waG90b3Nob3A6VGV4dExheWVy
+ cz4NCgkJCTx4bXBNTTpIaXN0b3J5Pg0KCQkJCTxyZGY6U2VxPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFj
+ dGlvbj0iY3JlYXRlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowMTgwMTE3NDA3MjA2ODExQkE5
+ RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMjozNzowMSswMTowMCIgc3RFdnQ6
+ c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjAyODAxMTc0MDcy
+ MDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEyOjM3OjM5KzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6MDM4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTI6NTc6MTMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6
+ YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNDgwMTE3NDA3MjA2ODExQkE5
+ RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowMDowOCswMTowMCIgc3RFdnQ6
+ c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9
+ Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4
+ bXAuaWlkOjA1ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAz
+ LTIxVDEzOjAyOjQzKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDY4MDExNzQwNzIwNjgxMUJBOURERjE1QTVB
+ RUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDc6NTYrMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDow
+ NzgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzow
+ ODoxMSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjA4ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA4OjE4KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MEE4MDExNzQw
+ NzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDk6MzkrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDoyMjIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxMzowOTo0OSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhv
+ dG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2
+ dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjIzMjNERTBBMEMyMDY4MTFC
+ QTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEwKzAxOjAwIiBzdEV2dDpz
+ b2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0i
+ LyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9Inht
+ cC5paWQ6MjQyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMt
+ MjFUMTM6MTA6MjgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJz
+ YXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyNTIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFF
+ RTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMjo0MyswMTowMCIgc3RFdnQ6c29mdHdhcmVB
+ Z2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJ
+ CQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI2
+ MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEz
+ OjA2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9z
+ aCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0
+ RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjcyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0
+ RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MTg6NDArMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFk
+ b2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6
+ bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyODIzREUwQTBD
+ MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzoxNDowNSswMTow
+ MCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0
+ OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0
+ YW5jZUlEPSJ4bXAuaWlkOkY3N0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVu
+ PSIyMDEyLTAzLTIxVDE3OjU0KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3No
+ b3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFj
+ dGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkE3RjExNzQwNzIwNjgxMTk0NTc5
+ QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTU6NTArMDE6MDAiIHN0RXZ0OnNv
+ ZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIv
+ Ii8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1w
+ LmlpZDpGQjdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0y
+ MVQxNzo1NjowNSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBN
+ YWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNh
+ dmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkZDN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2
+ NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjU2OjUyKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFn
+ ZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJ
+ CQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6NTA5
+ RkQ0MjEwOTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6MDY6
+ MDErMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3No
+ IiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RF
+ dnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1MTlGRDQyMTA5MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RF
+ dnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoxMDoxMiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRv
+ YmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjUyOUZENDIxMDky
+ MDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjEwOjIzKzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6NTY5RkQ0MjEwOTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTg6MTI6MDgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6
+ YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1OTlGRDQyMTA5MjA2ODExOTQ1
+ NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoxMzowNyswMTowMCIgc3RFdnQ6
+ c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9
+ Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4
+ bXAuaWlkOkU4MTc3RENDMEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAz
+ LTIxVDE4OjQ2OjM1KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6QTY1OUIxMEEwRjIwNjgxMTk0NTc5QTMzRkIz
+ NTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6NDg6MjgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJjb252ZXJ0ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImZyb20g
+ YXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rvc2hvcCB0byBpbWFnZS9qcGVnIi8+DQoJCQkJCTxyZGY6
+ bGkgc3RFdnQ6YWN0aW9uPSJkZXJpdmVkIiBzdEV2dDpwYXJhbWV0ZXJzPSJjb252ZXJ0ZWQgZnJvbSBh
+ cHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRvIGltYWdlL2pwZWciLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkE3NTlCMTBBMEYy
+ MDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjQ4OjI4KzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCTwvcmRmOlNlcT4NCgkJCTwveG1wTU06SGlzdG9yeT4NCgkJCTx4bXBN
+ TTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOkE2NTlCMTBBMEYyMDY4MTE5NDU3
+ OUEzM0ZCMzU2NDc5IiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlE
+ REYxNUE1QUVFODExIiBzdFJlZjpvcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIw
+ NjgxMUJBOURERjE1QTVBRUU4MTEiLz4NCgkJPC9yZGY6RGVzY3JpcHRpb24+DQoJPC9yZGY6UkRGPg0K
+ PC94OnhtcG1ldGE+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSd3Jz8+/+IMWElDQ19QUk9GSUxFAAEB
+ AAAMSExpbm8CEAAAbW50clJHQiBYWVogB84AAgAJAAYAMQAAYWNzcE1TRlQAAAAASUVDIHNSR0IAAAAA
+ AAAAAAAAAAEAAPbWAAEAAAAA0y1IUCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAARY3BydAAAAVAAAAAzZGVzYwAAAYQAAABsd3RwdAAAAfAAAAAUYmtwdAAAAgQAAAAU
+ clhZWgAAAhgAAAAUZ1hZWgAAAiwAAAAUYlhZWgAAAkAAAAAUZG1uZAAAAlQAAABwZG1kZAAAAsQAAACI
+ dnVlZAAAA0wAAACGdmlldwAAA9QAAAAkbHVtaQAAA/gAAAAUbWVhcwAABAwAAAAkdGVjaAAABDAAAAAM
+ clRSQwAABDwAAAgMZ1RSQwAABDwAAAgMYlRSQwAABDwAAAgMdGV4dAAAAABDb3B5cmlnaHQgKGMpIDE5
+ OTggSGV3bGV0dC1QYWNrYXJkIENvbXBhbnkAAGRlc2MAAAAAAAAAEnNSR0IgSUVDNjE5NjYtMi4xAAAA
+ AAAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAADzUQABAAAAARbMWFlaIAAAAAAAAAAAAAAAAAAAAABYWVog
+ AAAAAAAAb6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9kZXNj
+ AAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMu
+ Y2gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAu
+ SUVDIDYxOTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAuSUVD
+ IDYxOTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAGRlc2MAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEA
+ AAAAAAAAAAAAACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAB2aWV3AAAAAAATpP4AFF8uABDPFAAD7cwABBMLAANcngAAAAFYWVog
+ AAAAAABMCVYAUAAAAFcf521lYXMAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAKPAAAAAnNpZyAAAAAA
+ Q1JUIGN1cnYAAAAAAAAEAAAAAAUACgAPABQAGQAeACMAKAAtADIANwA7AEAARQBKAE8AVABZAF4AYwBo
+ AG0AcgB3AHwAgQCGAIsAkACVAJoAnwCkAKkArgCyALcAvADBAMYAywDQANUA2wDgAOUA6wDwAPYA+wEB
+ AQcBDQETARkBHwElASsBMgE4AT4BRQFMAVIBWQFgAWcBbgF1AXwBgwGLAZIBmgGhAakBsQG5AcEByQHR
+ AdkB4QHpAfIB+gIDAgwCFAIdAiYCLwI4AkECSwJUAl0CZwJxAnoChAKOApgCogKsArYCwQLLAtUC4ALr
+ AvUDAAMLAxYDIQMtAzgDQwNPA1oDZgNyA34DigOWA6IDrgO6A8cD0wPgA+wD+QQGBBMEIAQtBDsESARV
+ BGMEcQR+BIwEmgSoBLYExATTBOEE8AT+BQ0FHAUrBToFSQVYBWcFdwWGBZYFpgW1BcUF1QXlBfYGBgYW
+ BicGNwZIBlkGagZ7BowGnQavBsAG0QbjBvUHBwcZBysHPQdPB2EHdAeGB5kHrAe/B9IH5Qf4CAsIHwgy
+ CEYIWghuCIIIlgiqCL4I0gjnCPsJEAklCToJTwlkCXkJjwmkCboJzwnlCfsKEQonCj0KVApqCoEKmAqu
+ CsUK3ArzCwsLIgs5C1ELaQuAC5gLsAvIC+EL+QwSDCoMQwxcDHUMjgynDMAM2QzzDQ0NJg1ADVoNdA2O
+ DakNww3eDfgOEw4uDkkOZA5/DpsOtg7SDu4PCQ8lD0EPXg96D5YPsw/PD+wQCRAmEEMQYRB+EJsQuRDX
+ EPURExExEU8RbRGMEaoRyRHoEgcSJhJFEmQShBKjEsMS4xMDEyMTQxNjE4MTpBPFE+UUBhQnFEkUahSL
+ FK0UzhTwFRIVNBVWFXgVmxW9FeAWAxYmFkkWbBaPFrIW1hb6Fx0XQRdlF4kXrhfSF/cYGxhAGGUYihiv
+ GNUY+hkgGUUZaxmRGbcZ3RoEGioaURp3Gp4axRrsGxQbOxtjG4obshvaHAIcKhxSHHscoxzMHPUdHh1H
+ HXAdmR3DHeweFh5AHmoelB6+HukfEx8+H2kflB+/H+ogFSBBIGwgmCDEIPAhHCFIIXUhoSHOIfsiJyJV
+ IoIiryLdIwojOCNmI5QjwiPwJB8kTSR8JKsk2iUJJTglaCWXJccl9yYnJlcmhya3JugnGCdJJ3onqyfc
+ KA0oPyhxKKIo1CkGKTgpaymdKdAqAio1KmgqmyrPKwIrNitpK50r0SwFLDksbiyiLNctDC1BLXYtqy3h
+ LhYuTC6CLrcu7i8kL1ovkS/HL/4wNTBsMKQw2zESMUoxgjG6MfIyKjJjMpsy1DMNM0YzfzO4M/E0KzRl
+ NJ402DUTNU01hzXCNf02NzZyNq426TckN2A3nDfXOBQ4UDiMOMg5BTlCOX85vDn5OjY6dDqyOu87LTtr
+ O6o76DwnPGU8pDzjPSI9YT2hPeA+ID5gPqA+4D8hP2E/oj/iQCNAZECmQOdBKUFqQaxB7kIwQnJCtUL3
+ QzpDfUPARANER0SKRM5FEkVVRZpF3kYiRmdGq0bwRzVHe0fASAVIS0iRSNdJHUljSalJ8Eo3Sn1KxEsM
+ S1NLmkviTCpMcky6TQJNSk2TTdxOJU5uTrdPAE9JT5NP3VAnUHFQu1EGUVBRm1HmUjFSfFLHUxNTX1Oq
+ U/ZUQlSPVNtVKFV1VcJWD1ZcVqlW91dEV5JX4FgvWH1Yy1kaWWlZuFoHWlZaplr1W0VblVvlXDVchlzW
+ XSddeF3JXhpebF69Xw9fYV+zYAVgV2CqYPxhT2GiYfViSWKcYvBjQ2OXY+tkQGSUZOllPWWSZedmPWaS
+ ZuhnPWeTZ+loP2iWaOxpQ2maafFqSGqfavdrT2una/9sV2yvbQhtYG25bhJua27Ebx5veG/RcCtwhnDg
+ cTpxlXHwcktypnMBc11zuHQUdHB0zHUodYV14XY+dpt2+HdWd7N4EXhueMx5KnmJeed6RnqlewR7Y3vC
+ fCF8gXzhfUF9oX4BfmJ+wn8jf4R/5YBHgKiBCoFrgc2CMIKSgvSDV4O6hB2EgITjhUeFq4YOhnKG14c7
+ h5+IBIhpiM6JM4mZif6KZIrKizCLlov8jGOMyo0xjZiN/45mjs6PNo+ekAaQbpDWkT+RqJIRknqS45NN
+ k7aUIJSKlPSVX5XJljSWn5cKl3WX4JhMmLiZJJmQmfyaaJrVm0Kbr5wcnImc951kndKeQJ6unx2fi5/6
+ oGmg2KFHobaiJqKWowajdqPmpFakx6U4pammGqaLpv2nbqfgqFKoxKk3qamqHKqPqwKrdavprFys0K1E
+ rbiuLa6hrxavi7AAsHWw6rFgsdayS7LCszizrrQltJy1E7WKtgG2ebbwt2i34LhZuNG5SrnCuju6tbsu
+ u6e8IbybvRW9j74KvoS+/796v/XAcMDswWfB48JfwtvDWMPUxFHEzsVLxcjGRsbDx0HHv8g9yLzJOsm5
+ yjjKt8s2y7bMNcy1zTXNtc42zrbPN8+40DnQutE80b7SP9LB00TTxtRJ1MvVTtXR1lXW2Ndc1+DYZNjo
+ 2WzZ8dp22vvbgNwF3IrdEN2W3hzeot8p36/gNuC94UThzOJT4tvjY+Pr5HPk/OWE5g3mlucf56noMui8
+ 6Ubp0Opb6uXrcOv77IbtEe2c7ijutO9A78zwWPDl8XLx//KM8xnzp/Q09ML1UPXe9m32+/eK+Bn4qPk4
+ +cf6V/rn+3f8B/yY/Sn9uv5L/tz/bf///9sAQwABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+ AQEBAQEBAQEBAQEBAgICAgICAgICAgIDAwMDAwMDAwMD/9sAQwEBAQEBAQEBAQEBAgIBAgIDAwMDAwMD
+ AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD/8IAEQgA+gD6AwERAAIRAQMR
+ Af/EAB0AAQADAQEBAQEBAAAAAAAAAAAGBwkIBQQDAgH/xAAxEAABAgUCBgECBgIDAAAAAAAGBAUAAgMH
+ CAETMEAUGDgJEiAVEHCQERYXJhk2Nzn/xAAcAQEAAQUBAQAAAAAAAAAAAAAABgIDBAUHAQj/xABdEQAA
+ BAMEBAoHAgcJCw0AAAACAwQFARQGABMVBxESFiYwIUVlthdHCBhoMdU3d5dJiUBBUWFxkSQ0NhDwgSIy
+ JTV1CaGxwdHhQnIjU7Q5gqIzY2RVVmaGtzhIiP/EADwSAAIBAgQDBgIHBgcBAAAAAAECAxEEACESBTFB
+ YVFxIjITBkCBkbHB0UJSFBBwkKFis7LCIzODNBUH/9oADAMBAAIQAxAAAADYcqYAAAAAAAAAAAAAAGsp
+ k0UyAAAAAAAAAAAAAADZgzNKZAAAAAAAAAAAAAABswZmlMgAAAAAAAAAAAAAA2YMzSmQAAAAAAAAAAAA
+ AAbMGZpTIAAAAAAAAAAAAAANmDM0pkAAAAAH2n2nUpRp8RX4AAAAABswZmlMgAAAAAuYmZMyGAr8rM+I
+ AAAAA2YMzSmQAAAAAXMTMmZDATM5mIYAAAAAbMGZpTIAAAAALmJmTMhgJmczEMAAAAANmDM0pkAAAAA6
+ MPjPZJmQwEzOZiGAAAAAGzBmaUyAAAAAdmEMPaPZPGB7JzMQwAAAAA2YMzSmQAAAADswhhMwADmYhgAA
+ AABswZmlMgAAAAHZh4x7IABzMQwAAAAA2YMzSmQAAAADswAAA5mIYAAAAAbMGZpTIAAAAB1MSYAAHJp4
+ oAAAABswZmlMgAAAAFgHRgABDDmYAAAAAGzBmaUyAAAAADpkmYAOZiGAAAAAA2YMzSmQAAAAAAAAAAAA
+ AAbMGZpTIAAAAAAAAAAAAAANmDM0pkAAAAAlwIiCfEBBLiIgAAAAGzBmaUyAAAXYXCU8DRI/r23kDVa7
+ GoyPS9oo0vry518cYFjnkGfwAAANmDM0pkAAA2KI6W0V2frkab79zzbJLe8o2V0HXIxVa+p79trN8PR9
+ Ur89040OXwAAAbMGZpTIAABsFVZrzZQvpSzsa2rxv2zYz9Wwh+TMp4NrNFu8j8faP4efjpem0y9sujJ4
+ Zpvc66+XgAADZgzNKZAAANlCv7+qoiZ/NHT9VnmbaQM95Z23P+ptT0AaVxbvVJZ8S5E3XMoXRkRuI/RH
+ SOg65nA9AAAGzBmaUyAAAXAU+f77R68n4XJJ58m/TsIiAL71s2jvldCRnuHgQv6a/OxtAAAABswZmlMg
+ AAAAH93MP35r8xSWe/JX7ZOk/mjI8GHfScagP1z8+FJQAAAABswZmlMgAAAAAH7ZWgkE1+YvFivfvj1U
+ +AAAAAAGzBmaUyAAAAAAAAAAAAAADZgzNKZAAAAAAAAAAAAAABswZmlMgAAAAAAAAAAAAAA2YJmQwAAA
+ AAAAAAAAAAAHZh//2gAIAQIAAQUA/St0lm1125/w+Ov76yzS82kp6VVVJPT1eugow1JaVdQpTySu9dPT
+ +8vaenQn5WWX5TLWlUgpVG+vSqrmxQ36aIZkLpQk/wAk2oYJPkrWyfsQvNGdKt1QOTmqcGyokWLWdWho
+ 1mtTQRzt9Skn5LSvNNNUlbSClML1K0qpnlUuFNnlpue3DezyoK1dnlrOKyrO5OKRvqqKy5mlWqXtOlqo
+ 17xJVR/vrrymmusuraTqUsIV6Jwk24242424VMjatqUULYz03Irk0hQprqqnL0q1WhO1l88kJVKVbT+E
+ VNadKV0LUqeFjgrX1ObSLVSGpQOJ5Uzi8r3Of8j/AP/aAAgBAwABBQD9K2arSlk6xLGmumsbtP4061Kr
+ zZCrqIGJwd1Uls/5W5wfvq9rZmR3VV7dNjys0tra95WOyXla1bShSGLhMRY4Ii9qXIRU5ZjCecqoFQI7
+ V9NLLddpF3K+lJgGa+k1nraOSV/GZC0JCGIROkRCOjVxx8rcWw9ZHUiSmKRc8clUa6NCkkqm1n11K+6R
+ srsdyKrIILLkVFYP1sGNyKhc3NdyKjYGDiBMEBhEYIGdsF7k1Rlkte7vreRiduFDeR6Syy8pUp06shrY
+ xjfdCkSJg5R1cdXHVx1cMN0DQaSOJScXIWBVgFFSGllamJJy69uQuiY7x0TKYfWV8GlnU6wllVrq4Jjy
+ +O+g0IDwkk5sgGGEoROuLKaq9BltRQHT/kf/AP/aAAgBAQABBQC/l/L6s19e43IWO43IWO43IWO43IWO
+ 43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO
+ 43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWO43IWP7HuHGRvkLz+RvkLz+RvkLz+RvkLz+R
+ vkLz+RvkLxG1tcXlxcxwhZUoWF0ElD+uXR4L3u2xIysvGyN8heJZBt+6E5Ex7NvBoa34DGPqbhkTHs28
+ HrNFxBQXtri1V+Jkb5C8SyDb90JyJj2beDQ1vwGMfU3DImPZt4NDW/B4m6R84mRvkLxLINv3QnImPZt4
+ NDW/AYx9TcMiY9m3g0Nb8HibpHziZG+QvDFLNpFtC1wiqRGpEx7NvBoa34DGPqbhkTHs28Ghrfg8TdI+
+ cTI3yF4Y0Nb8BjH1Nw9AhUQDw0Nb8CYQqmIdAhUQDw0Nb8HibpHziZG+QvDGhrfgMY+puGNDW/A0Nb8D
+ Q1vwNDW/A0Nb8HibpHziZG+QvDGhrfgTCFUxCNDW/A0Nb8DQ1vwNDW/A0Nb8HibpHziZG+QvDGhrfgaG
+ t+Boa34GhrfgaGt+Boa34Ghrfg8TdI+cTI3yF4drUVcjahoa34GhrfgaGt+Boa34GhrfgaGt+H5zSuy7
+ iZG+QvDts9srKSDQ1vwNDW/A0Nb8DQ1vwNDW/FV6FBZLxcjfIXiWeY/uLGNDW/A0Nb8DQ1vwNDW/B4m6
+ R84uRvkLz+RvkLz+RvkLw2MAOCZn/gBx/E/waLW3Dfgf8BkAODOhxMjfIX67WY8XbvUzE2AeUIqLguPd
+ 0rkW+szj3dK/qrFX/wA5rjaa6+rD4zQyYEZOvy5gC8sRvHyz+Pd3L7rnb105Xts/r/FntTYMq9f2UQmP
+ ev3GmrdY0ypw7u0HlHByN8hfr9Zi5W12p9Y1yrhFF8rHJUyHHD1Kf8ixOl0n9dlw6Wmvq/6eSM+DItGb
+ IWPl1m9bdnla0W9afr9IH90sd68HReyY2+tO5Nwn7IDE9SqavYPlgWFVW/8AwcjfIX6/WxJNUs76sUCh
+ PkBZpJV/oD1Ooa6Z/wAVE+qb15XC01/1i/HWPYjprraGx+mv+t7CR8ZLpWHR3hxjxdtBgcknoYwesVDW
+ T5IYxo6tP2P5XpJ6eR/ByN8hfr9XztWYbbTeyVgGx7GXLoisO9N3sVaAtwtrk24W5sK/5Nr33G34axf/
+ ACbX34EwvJteHY82gC2TG+wN0rwigOIWVydcbOW6x5vxWxzPmrJEpFr93izitddoM4ORvkL9dtr93YtE
+ zRprrpqld6tGE6hOql+EfCPhHwi3eTl+bUs9178XUvLCt5l0ipVqVpuHkb5C8OSeenMjfJpYo1qKiX4x
+ NrLJKse6NKK6qupm4uRvkLxaKisnnpkOulJUvUq5uPkb5C8/kb5C8/kb5C8/cf8A7D5//9oACAECAgY/
+ AP4VtAM8eU/sApnjMU+Lt428rOAfpxNDp8AB+oY8mLwSIDpOX0n7sW0IXwkD7cQwFf8ATIGXyJxb+mtN
+ QNflT4ZVBFSaYWacroLUFDXOhPZ0xaRMV1TBSueXiNBXEZnK+OtKGvCn3422ByDIdJNO0sw+zFwvQ/4R
+ jhjch1H1tiyXov8AmxaX0LAzHIIakkjLIDiKGh4cqccQS3kCxQJyrmc6kUqTU8M6AYSAEaZG8HcTQVwJ
+ 5iujUBkeZr06YjvXK+iwUjPPxCo5YjuZJowrrUCviNelPg4hcM7wqfLqPDmBxpXpiFYp/Suk4A8R0pUV
+ HZQ1GK3W5SPKOBIqAOzMk/zHccW1+ZiDGB4acaEnjXr2Yk3L1iSw8tOgHGvTsxwxcyiYv6h4UpTMntPb
+ iDcPWIKAeGnGledevZie3ubxLeKFm06hzBpxyzNK8e4YVU9xNKBmyq7VpXP8Zp2Vxa3BmK+kRlStaGvG
+ uPTuroRIGBrxJpXICo7cR7dbx1gVVXU3E6aUIHLh1xmfhAVNCMLHdj1Ye38Q+fP541WswJ5jgR3jHDHD
+ HDHDHq3NorSdoJUnv0kV+eJZI0WKM8SSTw4ZsSfkMNFtyVP5yMvkPvwZbiUu57fiBJDIVccwaYWLck1L
+ +ccfmOeBLbSq6dPt/YXkYKg5nLDRWCiSX834R3duPUupix7OQ7h8YJbWZkcdn2jBW4tdV1yI8p6nP6sE
+ 3Ex9PkoyA+X7kP/aAAgBAwIGPwD+Fb6jOAnbj/fX6cCnDDPrGgHM9mD6bhqdnxe73kJpLHbyMp7CFND8
+ jjbtyEp/UM61P/I4+zH/AGDj229pcMhmWrUyrREI/mxy+7G97i8tZ0eSh7hH9+Ny3VZiLtXbxDj50X6j
+ TG7/AKucuI3j015ag1fpoPhppmRiqIWyFSaAmgHM5cOoxPtu2JOLiOIyHWgUaQyqRUMc6uMu/sx7g3CB
+ ZfR215VlBUaiYVLPoFc8hlwqcXqbSswNuFLa1Cjx6qUoT+U497braoy2sfrRpqyOlYImqQCaZscbPNXj
+ Iv8Aekx5seymrxjb+3Fj3NLXhJL9UWN/9q7nDIu3RgyPcKVVI0bxeNm8rBoy65MCA2oALnu1j7b3aW+3
+ a5BGoqQqnSVVixVV0pUkBdTMciQDUXO7OjiazircZCmpULMUzzBAJFaUrTDbZtizi5EbP41AGlSAcwxz
+ 8Q5YvPbFqs3/AKMDyq1VASsLFXodRPEZZZ4vNms9svJJoJTHI4jHpKVNCS5YCn8+nwe4SbPBb2u5Tqay
+ iJalqHSz00lypNRqJ+eYO4zbhtQ3DYLo1kZSdLEVo+rSxjbM6g6lWGRzAIK7D7KtLbb2BLqrBGd8qNWO
+ NVFBUEFWJqDqWlDvftNdtWRL1pCZS5BT1I0jyXSQaaK+YVrTFl7LO2qscLA+trJJo7P5NNB5qebljzY2
+ Pb321YBZKQGDltdVRcwVWnkrxPHG6ezxtqulyzn1dZBXWEHk0kGmj8w442rdtl9uXO8X+5QRmf0mqCro
+ XoU8Q0JqKCkZJqdbCtDNNdf/ABmGxkkBSKWeCHQJCpK5G3XXShbTUVAPLG/7Mu2pML9WBcuU0aoymShS
+ DStaVHZj9XsWxtf3DQtGVqUVdRU6mfSwFNPPtxd+8t4vNO7TzzSiGI1jj9YsWRnIBkoHIrRRkCM8HSoF
+ TU9T8I0cqBo2FCCKgjsIORxLe+35BY7kanSBWFj1XitTzXLpgwb5t7xpXwyDxRt1Vxl8jQ9MebHmx5se
+ bAsdm9wSxWYrRGWOVVqanSJUcICc6LQVJPEnFjZXlzNuF3HURokaKBqpqOmJEXOgqzCtBStMRX3vO5KJ
+ x/Txt4u53GQ6hfpwljtFhHBaryQUr1J4k9SSfiJLPcbSOa1cUKuoYH5HE24eybj0ZsybdzVD0RuK9xqM
+ PYb5t8tvcg8GBoeqngR3Y4nEdrZwPLcOaBVBYknsAxDf+7pmsrE0PpDOZh/VyT68C02LbY4Vpm1Ku3Vn
+ OZ+mnxj2G+7bFcW7D8QFR1VuIPUYSXad+9LYiasj1Mq/0oQpBHVjXphE2fblN3TxTPRpCefiPDuH7kP/
+ 2gAIAQEBBj8AzpaGjOnNlqaWrNnMZta2ttzGrBC3NrchrB5SokCBEleSkyNEjTFBLKKLCEBYAwCGEIQh
+ C3t4zm+KFb+vLe3jOb4oVv68t7eM5vihW/ry3t4zm+KFb+vLe3jOb4oVv68t7eM5vihW/ry3t4zm+KFb
+ +vLe3jOb4oVv68t7eM5vihW/ry3t4zm+KFb+vLe3jOb4oVv68t7eM5vihW/ry3t4zm+KFb+vLe3jOb4o
+ Vv68t7eM5vihW/ry3t4zm+KFb+vLe3jOb4oVv68t7eM5vihW/ry3t4zm+KFb+vLe3jOb4oVv68t7eM5v
+ ihW/ry3t4zm+KFb+vLe3jOb4oVv68t7eM5vihW/ry3t4zm+KFb+vLe3jOb4oVv68t7eM5vihW/ry3t4z
+ m+KFb+vLe3jOb4oVv68t7eM5vihW/ry37eVn/wAJrrH/AGofPaH/AOPP179s+dP17/rbZ8e+bNDpu+fb
+ /oz2z4982aHTd8+3/Rntnx75s0Om759v+jPbPj3zZodN3z7f9Ge2fHvmzQ6bvn2/6M9s+PfNmh03fOFQ
+ NDQgWurs6rUra1tbalPXOLk4rjy0qJAgRJSzVKxasUmhLKKLCIZgxQCGEYxhCyFc8ML00onPUw1W5ta5
+ AlcLxnY6hLkVCogopXrsFTNq6F3EWlG4Jjv+jPKEOl06el1qwtYtpBeIS+kHGoD1B9QOPdQdFRZap07q
+ FWqVKJSpq0YUyYI3JOFO5ATpwLyF5ZdatFL041vUJ9lyyXLlBrTV75hO3jXRZAHlckbKFQ1IJlWVJV6c
+ tIFI1Lb6bTkID3a9TK1qZ/ilWuDeaiTOS05LTVbIyGduVsOXL4QvcnB9pZnaZIwzNFrRhNTqDwDUHFGB
+ iJGua1S/hfoz2z4982aHTd84VWRhOMauxP6Ps/tHqzWb2Wrd+p9UecmpOTsr/RpUzMSv84TGBuzis2eu
+ NSjGZTPbHSl3eMfdUNm8V8OjBdXuP68xjye8xLXn1GJTFaUpupMTHV92fTkzOeEbyjVDPT20POk1inKm
+ Kb8AR7PTemjMglMjsdiGnF3zI0qbwrw6VdpxvFdSYwGOKTmpP1NOS9ROKzZ641KMZlM9sdKXd4x91Q2b
+ xXw6MF1e4/rzGPJ7zEtefUYlMVo2mxIWtBjqtQJUqVfRmZy48ZDq45WomlyLFTVCP6ZWidU2brWsTBTm
+ HKDk4gBCVE9ezkORaV0QLW1SaibXIpOvSnozzG55bkru0LyylBZZg0Tq0riFSY2ENQ9OcAwERAGEUeD+
+ jPbPj3zZodN3zhVZGE4xq7E/o+z+0erNZvZat36n1R5yak5Oyv8ARpUzMSv84TGBuzis2euNSjGZTPbH
+ Sl3eMfdUNm8V8OjBdXuP68xjye8xLXn1GJTFaUpupMTHV92fTkzOeEbyjVDPT20POk1inKmKb8AR7PTe
+ mjMglMjsdiGnF3zI0qbwrw6VdpxvFdSYwGOKTmpP1NOS9ROKzZ641KMZlM9sdKXd4x91Q2bxXw6MF1e4
+ /rzGPJ7zEtefUYlMVpSm6kxMdX3Z9OTM54RvKNUM9PbQ86TWKcqYpvwhKlJLXozLhTc4fhmvO5eUusm5
+ bZGibyfv7+Ykjpu8v591vMUWcH9Ge2fHvmzQ6bvnCqyMJxjV2J/R9n9o9Wazey1bv1Pqjzk1Jydlf6NK
+ mZiV/nCYwN2cVmz1xqUYzKZ7Y6Uu7xj7qhs3ivh0YLq9x/XmMeT3mJa8+oxKYrSlN1JiY6vuz6cmZzwj
+ eUaoZ6e2h50msU5UxTfgCPZ6b00ZkEpkdjsQ04u+ZGlTeFeHSrtON4rqTGAxxSc1J+ppyXqJxWbPXGpR
+ jMpntjpS7vGPuqGzeK+HRgur3H9eYx5PeYlrz6jEpitKU3UmJjq+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+
+ EJUpJa9GZcKbnD8M153Lyl1k3LbI0TeT9/fzEkdN3l/Put5iizg/oz2z4982aHTd84RiC8tlTOKl2WsB
+ kTWdNmU2EDbqkce78ahSkJy8gKvMGtKac2jiInpzVoFKhSjPSkngE0p6nMaVbZjZpzLlK+AI2ReHPUS1
+ hXuULmhBhb5khmet/SEVRlo78DQFG5X92kOeUqslre3FZs9calGMyme2OlLu8Y+6obN4r4dGC6vcf15j
+ Hk95iWvPqMSmK0pTdSYmOr7s+nJmc8I3lGqGentoedJrFOVMU34Aj2em9NGZBKZHY7ENOLvmRpU3hXh0
+ q7TjeK6kxgMcUnNSfqacl6icVmz1xqUYzKZ7Y6Uu7xj7qhs3ivh0YLq9x/XmMeT3mJa8+oxKYrSlN1Ji
+ Y6vuz6cmZzwjeUaoZ6e2h50msU5UxTfhCVKSWvRmXCm5w/DNedy8pdZNy2yNE3k/f38xJHTd5fz7reYo
+ s4P6M9s+PfNmh03fOEpTdSYmOr7s+nJmc8I3lGqGentoedJrFOVMU34Aj2em9NGZBKZHY7ENOLvmRpU3
+ hXh0q7TjeK6kxgMcUnNSfqacl6iRM6FhlFr8y0k2JHLYF4UXCp6Q901KnXXlPd2Ip/V65tTQM0oXIaxT
+ iX+pUrDHMJta0pupMTHV92fTkzOeEbyjVDPT20POk1inKmKb8NDwNhnETsy5QNidt2BeFmhUlXd2pUrX
+ XZ/diqlgWY8VXZBelM2qViya/SVL8W5JCqrRM6FhlFr8y0k2JHLYF4UXCp6Q901KnXXlPd2Ip/V65tTQ
+ M0oXIaxTiX+pUrDHMJta0pupMTHV92fTkzOeEbyjVDPT20POk1inKmKb8ISpSS16My4U3OH4ZrzuXlLr
+ JuW2Rom8n7+/mJI6bvL+fdbzFFnB/Rntnx75s0Om75wlKbqTEx1fdn05MznhG8o1Qz09tDzpNYpypim/
+ AEez03pozIJTI7HYhpxd8yNKm8K8OlXacbxXUmMBjik5qT9TTkvUVKbqTEx1fdn05MznhG8o1Qz09tDz
+ pNYpypim/FKbqTEx1fdn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx1fdn05MznhG8o1Qz09tDzpNYpyp
+ im/FKbqTEx1fdn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx1fdn05MznhG8o1Qz09tDzpNYpypim/CEq
+ UktejMuFNzh+Ga87l5S6ybltkaJvJ+/v5iSOm7y/n3W8xRZwf0Z7Z8e+bNDpu+cJSm6kxMdX3Z9OTM54
+ RvKNUM9PbQ86TWKcqYpvw0PA2GcROzLlA2J23YF4WaFSVd3alStddn92KqWBZjxVdkF6UzapWLJr9JUv
+ xbkkKqulN1JiY6vuz6cmZzwjeUaoZ6e2h50msU5UxTfilN1JiY6vuz6cmZzwjeUaoZ6e2h50msU5UxTf
+ ilN1JiY6vuz6cmZzwjeUaoZ6e2h50msU5UxTfilN1JiY6vuz6cmZzwjeUaoZ6e2h50msU5UxTfilN1Ji
+ Y6vuz6cmZzwjeUaoZ6e2h50msU5UxTfhCVKSWvRmXCm5w/DNedy8pdZNy2yNE3k/f38xJHTd5fz7reYo
+ s4P6M9s+PfNmh03fOEpTdSYmOr7s+nJmc8I3lGqGentoedJrFOVMU34pTdSYmOr7s+nJmc8I3lGqGent
+ oedJrFOVMU34pTdSYmOr7s+nJmc8I3lGqGentoedJrFOVMU34pTdSYmOr7s+nJmc8I3lGqGentoedJrF
+ OVMU34pTdSYmOr7s+nJmc8I3lGqGentoedJrFOVMU34pTdSYmOr7s+nJmc8I3lGqGentoedJrFOVMU34
+ pTdSYmOr7s+nJmc8I3lGqGentoedJrFOVMU34QlSklr0ZlwpucPwzXncvKXWTctsjRN5P39/MSR03eX8
+ +63mKLOD+jPbPj3zZodN3zhKeWqKbROBkamRs4TEGXrcqIPIaay7slPpSDINfdqzMTLlpiZcApTESpeo
+ VqHEcVCMZ7oY31dSm6kxMdX3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdX3Z9OTM54RvKNUM9PbQ86
+ TWKcqYpvxSm6kxMdX3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdX3Z9OTM54RvKNUM9PbQ86TWKcqY
+ pvxSm6kxMdX3Z9OTM54RvKNUM9PbQ86TWKcqYpvxSm6kxMdX3Z9OTM54RvKNUM9PbQ86TWKcqYpvwQqS
+ IcPKKZacbBkajOC8VMtPNbOuXaGNjp5FHE1qAxTpGQYsFe6ValaqicsP4P6M9s+PfNmh03fOESxf0yI1
+ vcFtNJTlrkmYVbczkI62pZ9cHJeQ+Zc5omGIsJZ1Cc0KNrOUDAfEJhS5GJU1r6U3UmJjq+7PpyZnPCN5
+ Rqhnp7aHnSaxTlTFN+KU3UmJjq+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+KU3UmJjq+7PpyZnPCN5Rqhnp7
+ aHnSaxTlTFN+KU3UmJjq+7PpyZnPCN5Rqhnp7aHnSaxTlTFN+KU3UmJjq+7PpyZnPCN5Rqhnp7aHnSax
+ TlTFN+Gox2b2UxyQstDvkWA5gppG8OqU5n7tz6QBPCpO7Ac2mY62tbuaSesUqkaoqKs0w5wJVKDKz4T6
+ M9s+PfNmh03fOFYjdnsVvazOTX2x2P32jMPu3I5SZ8OmbEzoxq4l51bon7iQDP4XVlKbqTEx1fdn05Mz
+ nhG8o1Qz09tDzpNYpypim/FKbqTEx1fdn05MznhG8o1Qz09tDzpNYpypim/FKbqTEx1fdn05MznhG8o1
+ Qz09tDzpNYpypim/FKbqTEx1fdn05MznhG8o1Qz09tDzpNYpypim/CEqUktejMuFNzh+Ga87l5S6yblt
+ kaJvJ+/v5iSOm7y/n3W8xRZwn0Z7Z8e+bNDpu+fb/oz2z4982aHTd8+3/Rntnx75s0Om75wj3UVP0jUb
+ zT1NpVSyoH5vZ16lkZE6JNBWpG6OxZEW9CItNGA9UwwIxQjDRCOmGkyvBUjUZdElKCUkatOZ15FOmK1B
+ 0U5KRO8HEAQK1QjgxDEsoYxh0RjGEIQj+7UGZLNSDy40LSqspDUFTJU143Nqo2CYV0cLWgaO4AsJEcIs
+ IwkBNAIyIYCDGP7jqrpOkajqNExIlLi+L2dnXr29lQI0xixSrd16cgaNtTlJiRC1jhghHRohpjGEI8H9
+ Ge2fHvmzQ6bvnAVS95aUvGpk1HjQFvKdO5NaVwgY5AVGJC0KFcrTHuBgy0ZgohKgKMNXR6YwhFRVS6g0
+ y5KiRjXuLWyVCyvD6hTFBgI0QmxEsMMXmFAjGMQIxKR6IRjo0QtW2aFJsqNdRuXpDupqlwPeWpCeiJYm
+ SFQuQiUCtUUtWxJao68IFAFEYv4odIuKz+jyyZUbyfTJDepdwrHlqZ4JyXMxWUjEAToqShPiYNEZpgDT
+ EOjj0aYW70X9dZm/+2dB2yxho48Zaem9UW9EbNaVHQiYpE708jqVM/KqhZS2AKBfAYkhBrgWsO/nQ2AQ
+ xilAAZ5YBhGMIQR1oZyMzAtRkZIM1VPrXmSjTvFIrIY5TR7WjfANagYz3kxGoGSkCYJCZAlUAuH8oMR6
+ y5HlnSSh8JarnF3U9UhamVsiogKJJap0c1CVLFUaEERBILiYeIMIigCIYRjAEEtBtD6AQYiGc11xRxBZ
+ Gj7jcdemUzTo+8IRQ/HbvW0UkTpltRqTnymEqRC5tS5Irej6KdmshMkeEi05lVEHrhwCBSWoEmGGMBwM
+ iCOtY6o1NCJXdOkTiVLm6m39penpGSAu8MjhaVRMOAy/RECOZHGMOKEYcdgZh1lRjNVWUbKe/wBOuAXZ
+ akMK2uStTQ5oSjWOKotYtILIdyRawixp4xHGAtOiMIZv5sIqLYGTKRDUzm7NYmp2ptIQgp1weSkbQWip
+ xCqLUJCQxWFACQAgN0GP8mEIcD9Ge2fHvmzQ6bvnAd5xzQHCTLm5CzLkSgIQCEQrSU3WKhMcEJgRliEU
+ cWEUIChGEdHHCNq9Zamraqaia12WjzUitC/Prk8EGv6SrqNRkO8YOChREC6CV3UgEYGMIjCbHW06A6P7
+ Q5CjIKSo0dVd4hKkTEAgWSnTJ6EXkkEElhhAICiigQCGEOKEIaLZ2/1LQ/8Av1TW7zwY8cBPuZkI/kjl
+ nQdstAaOKDy18X/rWpo/4bej+5/kt3cmymqkeqfRvTaA53AyuKtsG4CZ6YpoTaWqORGknHJ0xq8wyBYh
+ RLiZqjjCIgAiHPXXiIQjHqsBjEKMYiEISakIiEKMeMQhR9MfvjbNB5ptWoY3hQ8vojXRqNMROAhLKgpp
+ kUjmiIgPCYa0Rl4ihGAoFcUIwt3k2t1enRzb2hpic1I3BcpVkNxjnS9UicIogKDDIJoLBoyhGQBoCIQN
+ OjTGMY96F6alRiJ0aErq6Nq0nVvUi9BQTorRqitcIgXidQUEYdMIw0w44Wf2V+reqn1qdqCqB1cW97fn
+ N3TK3RI7sQk7mYU4qVMMRKmzYQPhoNiE0YYijAQoRzcpVtVq0NMpqzz3iRT6ZUoKZixJKkXJExkG4JkE
+ kTSEyYssI4giKAABhp0QhbPBjNqWoDGWGY1UJoM5jy4ja4JyXc0RJEG8SmKSBJQgBiEGpqhjCGiHFwP0
+ Z7Z8e+bNDpu+cB3piwQiIZjS2gAEMIxEIQqXrMIYQhCEYxjGMeLRx2rE4cIRL6nX8qIg6YhgMda5fjBC
+ MdGiERBKFo/Dojb+0QIDoGaprLvE3QAaRCjfUU4gLhqwhEWkQuKH4bZ2GGQ0giz0MDWDpiGAoranEEIh
+ aNEIigGOiH36I/gt3mCxcYovWZQhaPRpjlvQ0OL0fdC2W0OeGvppU1vRH9/8Nu7B/U6/oxR1s8Ic8Vd/
+ u1IWzb7vFeNT2gopCSsqVzzAbVDega6banAJTjduzguHqIl6RyYDFaYUSlJZxQTYGgAWTGI8yqKyWrV9
+ zXrrMJIqQnLVTYsStaE81tVtKJWoVHtbU2xbWolcccEpMJUepOFqiEAsUBl97IuGjQa0VDdfkjl48QhA
+ X4Iw02WmGaur1a1OHijpjpi601+L8Vs4FAtXUHWWfkYaI8egdVukYaeK2dxpgywQHmVVQwgFGMBxCJ0P
+ EGMA6NPGGOngfoz2z4982aHTd84DvIviYso5Qyl0+7EEn69yac3MNXLCizrsQB3QxkwgLVjCOiPFGFnk
+ OU/dworLet6jIFB1qJtUs8EM9G/iF0UN7VSLKofVBRygZpQFZ2oAwUde9hEUBVKcJpTVrTlaiAfVNOOq
+ 6KBSqcS4qdR1ROkUbgElWMKw0B4RkmlqQC0DhAQQDAInLDu60JRtMKyzj3lrbliRnXOzwKJUEziNTT9O
+ tqAoCYmBgBANTKTDdeAoGlwhEMcx8iyKPRuqTMNXUSs6ozXk5Ioa41BTzLT4wFNoG48pVBKBmgbCMTga
+ 0TIh4tGmNO93UdHo0yKn1aZWCqgvRxqpVFM8OLvAAmmLcAkqAxOMQaYHi0QBp+/RD7vzw/xWy1pZXR6O
+ my8uUh6QhanejnMbrA9taG6IzSDW5GFJEIWmA9EBGcY4w+7TGtMgCqPRr0dZK3VWbUw3o5OpQRdC2ksQ
+ C2sLcaUogThUIwjE8Gtrx9Gjjo6s8u8pqpzzqbNynqfOriDAvmEx6N2ZjXeVVNRgV6QLK2CWmoytRAMw
+ cRDgoMDEcAxcFzp/Z90pl6sci1DPTtR1fQtGYQlqBUiVGoRjRn0IjxMaYKcZ8vAwN4EqMIxgHTG2aOXy
+ ej0L8VmamcE6h0MdhtQmjEGJWyCGnQJ2xQQogUFXEyAdYoP8XVhohx2Or8in0lSmnU65MGGqnMxqBADg
+ qblMVIVJKJcMQyooIQgDU0R1vTDRZ0z6pJAhQPLlWlU1YYzLhmrm0xLVq9yVObCpMBJnqEY0rmMmBsLs
+ yEYBMDqjhDRVDYr7rFFpq4rFASQ61spdkRrmncUJQS2x3LdGulmapXE5uEWGJRZi4oIS4XQ4mFREEXAf
+ Rntnx75s0Om75wFVU/l5VezzRWxJaep0mBU07YmSUlWoiwTD4zuapFqpXE4OlOMqMdfTGOmAYwtphGMI
+ w9EYcUbQCfC+Lhohp/z4Q9Hp/wA7+G2kkYBR+8MYxgOH5Qx47egP57egP57egP57egP57Ap6hcxnRpYi
+ YmSrQrRslQt6GBxsTzQtyWpGt3KbSzDxCGIJECwxGIQtGkQoxaDs0axNqMtgCrC0lCbmRmSI4rYkxVmh
+ RsDY1JDlB0E4IRNGAZmqGAYC1YaLRAlBCMf9qKEdH/JDH0/w2iMwYhij98Y/3oeiEOD+jPbPj3zZodN3
+ zhICAIQBQ9EQxjCNoAVh14f7UMIa0P8ASh6I2gMkcBh/FEOmH5YemFvRH/m2iIcYBDDjjEUQwhD89ogT
+ QvR+jXjou4fk4v41tY4yIvwQ9AYfkD6IcL9Ge2fHvmzQ6bvnDQGSYIAofgjxR/LD0RtoMJ1joQ0QEHRA
+ Efxxhp0wjaMTRx1fuLD/ABQQ/BxQ9MeH+jPbPj3zZodN3z7f9Ge2fHvmzQ6bvn2/6M9s+PfNmh03fPt/
+ 0Z7V5/wmv2zqj2j+0P8Apxd+3n/nP/vT/t17b5M9vkz2+TPb5M9vkz2+TPb5M9vkz2+TPb5M9vkz2+TP
+ b5M9vkz2+TPb5M9vkz2+TPb5M9vkz2+TPb5M9vkz2+TPb5M9vkz2+TPb5M9vkz2+TPb/AOmf/wAM/wB/
+ /wCM7f/Z
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+EOekV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDg6MDAAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAANUAAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSAJMNBJ8AJP4JGQSDoRoQeQUlKSSSSUpJJJJSkk
+ ki1zTDgWnmCCDHzSUpJJJJSkkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//R1sv+mZP/AB1v/VvQ
+ kXL/AKZk/wDHW/8AVvQklKSSSSUoAuIa0STwBz4o2PU11jm2DVgHtOnP7yfD/nHf1P4tR/8ADH/ix/1T
+ 0lMa2NZbYGiAWsMeGtg0/wA1RfS22924kBrW6DmTu/8AIog/nn/1GfltSb/PWfBn/f0lNO1grscwGQOD
+ 5EblFEyf593wb/1IQ0lKT1t3vayY3GJ5TKdH8+z4/wACkpOKG13VuYTBJEOg/mvPIDf3VO1jXvqa7jcS
+ fk3cnf8ATq/rn/qLEnfzlXxd/wBSUlIMmprSz0xBfI2juRER/K9yA5rmna4EHmDodVed/PV/1X/98Qcz
+ /B/2v++JKa6SSSSlIuJ/TMb/AI6r/q2ISLif0zG/46r/AKtiSn//0tbL/pmT/wAdb/1b0JFy/wCmZP8A
+ x1v/AFb0JJSkkkklJ8P+cd/V/i1H/wAOf+LH/VOQMP8AnHf1f4tVnaN++dYDfkCXfxSUxH88/wDqM/La
+ k3+es+DP+/qW0bi7uQB9xcf+/pBoDnO7uAB/sz/5JJTXtpfbe/bAADZJ8drdNJcgOa5ji12hHKut/nLf
+ i3/qQquR/Pv+X/UtSUjALiGtEk6AeJ+aO2h9V1ZJBBdEjxg/vbUKn+er/rD8quWc1f8AGD/qbElKf9Or
+ +uf+osSd/OVfF3/UlSLQS0z9EyPucz/v6RaC5ru7Zj5jakpi7+er+D/++IOZzX/a/wC+KwWgua7u0ED+
+ 1H/kVXzOa/7X/fElNdJJJJSkXE/pmN/x1X/VsQkXE/pmN/x1X/VsSU//09bL/pmT/wAdb/1b0JFy/wCm
+ ZP8Ax1v/AFb0JJSkkkklJ8P+cd/V/i1WlVw/5x39X+LVaSUpJJJJTFrSHvd2cWx8m7VUyP59/wAv+par
+ qo3kG55BkSPwAaUlLU/z1f8AWH5Vde0ksj8124/CHt/78qVZDbGOcYAcCT5BX0lKSSSSUpVszmv+1/3x
+ WVWzOa/7X/fUlNdJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//U1sv+mZP/AB1v/VvQkXL/AKZk
+ /wDHW/8AVvQklKSSSSUyqc1lrXu4BPHmC3/vyvNc1zQ5plp4OvbTus9HqyWsrawtJInUEdyXfxSU2klX
+ +2M/cd94S+2M/cd94SUlttbWySdfzR3lUSSSSeTqfmiX2i0tIBECNfihpKWV6m4Wt1PvA9441/eCpKdN
+ gqeXETLSIHmQf++pKbySr/bG/uO+8JfbG/uO+8JKTuIaC46ACSfIKle9r7S5vEAT4wivymuY5oaRuBEy
+ O6rpKUkkkkpSLif0zG/46r/q2ISLif0zG/46r/q2JKf/1dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0
+ JJSkkkklKSTta57gxjS97jDWtEkn+S0KT6L2Vi2yqxlTtBY5jmtJ/rOCSmCSn6F+9tfpP9R4ljNp3OB7
+ sZG5yVdF9ryymp9j2/SaxpcR/W2j2pKYAE8BSFbj5fFW+nYQyhmCz1BZi0l7K2yCX+/2PZG/836CFZXd
+ U4NurfU4iQ17S0keW5SQjE721eYzZcdCIjr4E0hNbviolpHIK0MTDbkYmZdD3W47W+kxmsl27loBc76K
+ p3120WbbWvqdE7XgtMfByUoxG1owZs0iBIR1FjfVGkp20ZFQa66qyprtGusY5oPzeFZv6Vl04tGQa7He
+ sHOfWK3TUGx/PH+V/VUbbaaSvZPTHtxcK7Frtudk0+rcWtLw0kVlobsb7fpPVFJSkkkklKRcT+mY3/HV
+ f9WxCRcT+mY3/HVf9WxJT//W1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSU2+kf8q4n/ABv8
+ HLQGRff+36r7HW1Mru2MeZa3abms2D8zbtas7pH/ACrif8aPyOV3KyenYx6o3HdbZk5hspcx7QGMJc9t
+ r9/57dz3urSU2rCf+cfTf/C7f+puVfHtdfRl9Pxsj7JnfarLa3Ts9UbnD0vVH5/+v+kTs6p0x2TidQuN
+ zcjGrFTqGNBadHN9Tf8Au/pHfnKoLOk5NVlWUH0Wes+2vJrYHOcx7nPFdn0vo70lOhi5WW+7ql2QwY2Z
+ ViAP2aHcwWlln53u/lNVa622/wCr9dl73W2Myi1r3nc4Da7TcfcpXdaxrbsx+14bdijGoJEucR6nvu/d
+ 91qp/a6v2QMLX1hf6vHt2xt+knAsMoXdncFtdMtsq6Z1SypxY9rK9rm6EfT4VzDccijo9mQTdYMm4b3+
+ 50NbkFvuP7vp1/5izOn5eHVjZmNl+oG5YY0OqAJEbtzvd+7uR/2pi4v2GnED76cKx9r7LAGuebBY1wY3
+ 2/R9Z6RKow4a8B/3XEkpyL8mnrdeRY65jA8sY8yGlr7dmwfmbdjPoofUMvL/AGT0w+vZNrLPVO8y/wCh
+ /OfvqNmb02inN+xuttt6hIIsaGtrDi5ztdN3845Q+09OyOnY2Pkvtpuww9rNjA9r930T/wBFv51aazNj
+ KysmjF6I2i19TXVMLmsMA60N94/P5VTrzWt6xlBoABLDA8SxhcU2Vm03U9MY3duw62sukaSDVPp/v/zb
+ lDqmVVl9Quyap9Ozbt3CD7WtZx/ZSU1UkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//X1sv+mZP/
+ AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUux763tsrcWPaZa5uhB8knOc5xe4lznEuc48knVzimSSUp
+ JJJJSkkkklKSSSSUpJJJJSkkkklKSSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HVf9WxJT//0NbL/pmT/wAd
+ b/1b0JWcrFyzl5BGPcQbrSCKnkEF79foIf2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC4
+ 13/bT/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413
+ /bT/APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/APyCX2TM/wC413/b
+ T/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//AMgl9kzP+413/bT/
+ APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSLif0zG/wCOq/6tiX2TM/7jXf8AbT//ACCJ
+ i4uWMvHJx7gBdUSTU8AAPZr9BJT/AP/Z/+0XPFBob3Rvc2hvcCAzLjAAOEJJTQQEAAAAAAAfHAFaAAMb
+ JUccAVoAAxslRxwBWgADGyVHHAIAAAIAAAA4QklNBCUAAAAAABDTyZ9LPY3qKIVINWqEFZwrOEJJTQQ6
+ AAAAAACbAAAAEAAAAAEAAAAAAAtwcmludE91dHB1dAAAAAQAAAAAUHN0U2Jvb2wBAAAAAEludGVlbnVt
+ AAAAAEludGUAAAAAQ2xybQAAAA9wcmludFNpeHRlZW5CaXRib29sAAAAAAtwcmludGVyTmFtZVRFWFQA
+ AAATAEMAYQBuAG8AbgAgAE0AUAAxADQAMAAgAHMAZQByAGkAZQBzAAAAOEJJTQQ7AAAAAAGyAAAAEAAA
+ AAEAAAAAABJwcmludE91dHB1dE9wdGlvbnMAAAASAAAAAENwdG5ib29sAAAAAABDbGJyYm9vbAAAAAAA
+ UmdzTWJvb2wAAAAAAENybkNib29sAAAAAABDbnRDYm9vbAAAAAAATGJsc2Jvb2wAAAAAAE5ndHZib29s
+ AAAAAABFbWxEYm9vbAAAAAAASW50cmJvb2wAAAAAAEJja2dPYmpjAAAAAQAAAAAAAFJHQkMAAAADAAAA
+ AFJkICBkb3ViQG/gAAAAAAAAAAAAR3JuIGRvdWJAb+AAAAAAAAAAAABCbCAgZG91YkBv4AAAAAAAAAAA
+ AEJyZFRVbnRGI1JsdAAAAAAAAAAAAAAAAEJsZCBVbnRGI1JsdAAAAAAAAAAAAAAAAFJzbHRVbnRGI1B4
+ bEBSAAAAAAAAAAAACnZlY3RvckRhdGFib29sAQAAAABQZ1BzZW51bQAAAABQZ1BzAAAAAFBnUEMAAAAA
+ TGVmdFVudEYjUmx0AAAAAAAAAAAAAAAAVG9wIFVudEYjUmx0AAAAAAAAAAAAAAAAU2NsIFVudEYjUHJj
+ QFkAAAAAAAA4QklNA+0AAAAAABAASAAAAAEAAgBIAAAAAQACOEJJTQQmAAAAAAAOAAAAAAAAAAAAAD+A
+ AAA4QklNA/IAAAAAAAoAAP///////wAAOEJJTQQNAAAAAAAEAAAAeDhCSU0EGQAAAAAABAAAAB44QklN
+ A/MAAAAAAAkAAAAAAAAAAAEAOEJJTScQAAAAAAAKAAEAAAAAAAAAAjhCSU0D9QAAAAAASAAvZmYAAQBs
+ ZmYABgAAAAAAAQAvZmYAAQChmZoABgAAAAAAAQAyAAAAAQBaAAAABgAAAAAAAQA1AAAAAQAtAAAABgAA
+ AAAAAThCSU0D+AAAAAAAcAAA/////////////////////////////wPoAAAAAP//////////////////
+ //////////8D6AAAAAD/////////////////////////////A+gAAAAA////////////////////////
+ /////wPoAAA4QklNBAAAAAAAAAIAAzhCSU0EAgAAAAAADAAAAAAAAAAAAAAAADhCSU0EMAAAAAAABgEB
+ AQEBAThCSU0ELQAAAAAABgABAAAADThCSU0ECAAAAAAAGgAAAAEAAAJAAAACQAAAAAIAAA+gAQAAD7AA
+ OEJJTQQeAAAAAAAEAAAAADhCSU0EGgAAAAADRwAAAAYAAAAAAAAAAAAAAPoAAAD6AAAACQBwAHUAcwBo
+ AF8AYgBvAHQAaAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAA+gAAAPoAAAAAAAAAAAAA
+ AAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAQAAAAAAAG51bGwAAAACAAAABmJvdW5kc09iamMA
+ AAABAAAAAAAAUmN0MQAAAAQAAAAAVG9wIGxvbmcAAAAAAAAAAExlZnRsb25nAAAAAAAAAABCdG9tbG9u
+ ZwAAAPoAAAAAUmdodGxvbmcAAAD6AAAABnNsaWNlc1ZsTHMAAAABT2JqYwAAAAEAAAAAAAVzbGljZQAA
+ ABIAAAAHc2xpY2VJRGxvbmcAAAAAAAAAB2dyb3VwSURsb25nAAAAAAAAAAZvcmlnaW5lbnVtAAAADEVT
+ bGljZU9yaWdpbgAAAA1hdXRvR2VuZXJhdGVkAAAAAFR5cGVlbnVtAAAACkVTbGljZVR5cGUAAAAASW1n
+ IAAAAAZib3VuZHNPYmpjAAAAAQAAAAAAAFJjdDEAAAAEAAAAAFRvcCBsb25nAAAAAAAAAABMZWZ0bG9u
+ ZwAAAAAAAAAAQnRvbWxvbmcAAAD6AAAAAFJnaHRsb25nAAAA+gAAAAN1cmxURVhUAAAAAQAAAAAAAG51
+ bGxURVhUAAAAAQAAAAAAAE1zZ2VURVhUAAAAAQAAAAAABmFsdFRhZ1RFWFQAAAABAAAAAAAOY2VsbFRl
+ eHRJc0hUTUxib29sAQAAAAhjZWxsVGV4dFRFWFQAAAABAAAAAAAJaG9yekFsaWduZW51bQAAAA9FU2xp
+ Y2VIb3J6QWxpZ24AAAAHZGVmYXVsdAAAAAl2ZXJ0QWxpZ25lbnVtAAAAD0VTbGljZVZlcnRBbGlnbgAA
+ AAdkZWZhdWx0AAAAC2JnQ29sb3JUeXBlZW51bQAAABFFU2xpY2VCR0NvbG9yVHlwZQAAAABOb25lAAAA
+ CXRvcE91dHNldGxvbmcAAAAAAAAACmxlZnRPdXRzZXRsb25nAAAAAAAAAAxib3R0b21PdXRzZXRsb25n
+ AAAAAAAAAAtyaWdodE91dHNldGxvbmcAAAAAADhCSU0EKAAAAAAADAAAAAI/8AAAAAAAADhCSU0EFAAA
+ AAAABAAAAB04QklNBAwAAAAADWwAAAABAAAAoAAAAKAAAAHgAAEsAAAADVAAGAAB/9j/7QAMQWRvYmVf
+ Q00AAf/uAA5BZG9iZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwM
+ EQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREM
+ DAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/
+ xAE/AAABBQEBAQEBAQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkK
+ CxAAAQQBAwIEAgUHBggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh
+ 8WNzNRaisoMmRJNUZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3
+ R1dnd4eXp7fH1+f3EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi
+ 4XKCkkNTFWNzNPElBhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZm
+ doaWprbG1ub2JzdHV2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N
+ 3/br/wDyaWX/AEzJ/wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/
+ APyaX2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//
+ AMml9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APya
+ X2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml
+ 9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbE
+ lP8A/9DWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSAJMNBJ8AJP4JGQSDoRoQeQ
+ UlKSSSSUpJJJJSkkki1zTDgWnmCCDHzSUpJJJJSkkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//R
+ 1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUoAuIa0STwBz4o2PU11jm2DVgHtOnP7yfD/nHf
+ 1P4tR/8ADH/ix/1T0lMa2NZbYGiAWsMeGtg0/wA1RfS22924kBrW6DmTu/8AIog/nn/1GfltSb/PWfBn
+ /f0lNO1grscwGQOD5EblFEyf593wb/1IQ0lKT1t3vayY3GJ5TKdH8+z4/wACkpOKG13VuYTBJEOg/mvP
+ IDf3VO1jXvqa7jcSfk3cnf8ATq/rn/qLEnfzlXxd/wBSUlIMmprSz0xBfI2juRER/K9yA5rmna4EHmDo
+ dVed/PV/1X/98Qcz/B/2v++JKa6SSSSlIuJ/TMb/AI6r/q2ISLif0zG/46r/AKtiSn//0tbL/pmT/wAd
+ b/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklJ8P+cd/V/i1H/wAOf+LH/VOQMP8AnHf1f4tVnaN++dYDfkCX
+ fxSUxH88/wDqM/Lak3+es+DP+/qW0bi7uQB9xcf+/pBoDnO7uAB/sz/5JJTXtpfbe/bAADZJ8drdNJcg
+ Oa5ji12hHKut/nLfi3/qQquR/Pv+X/UtSUjALiGtEk6AeJ+aO2h9V1ZJBBdEjxg/vbUKn+er/rD8quWc
+ 1f8AGD/qbElKf9Or+uf+osSd/OVfF3/UlSLQS0z9EyPucz/v6RaC5ru7Zj5jakpi7+er+D/++IOZzX/a
+ /wC+KwWgua7u0ED+1H/kVXzOa/7X/fElNdJJJJSkXE/pmN/x1X/VsQkXE/pmN/x1X/VsSU//09bL/pmT
+ /wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklJ8P+cd/V/i1WlVw/5x39X+LVaSUpJJJJTFrSHvd2cWx8
+ m7VUyP59/wAv+parqo3kG55BkSPwAaUlLU/z1f8AWH5Vde0ksj8124/CHt/78qVZDbGOcYAcCT5BX0lK
+ SSSSUpVszmv+1/3xWVWzOa/7X/fUlNdJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//U1sv+mZP/
+ AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUyqc1lrXu4BPHmC3/vyvNc1zQ5plp4OvbTus9HqyWsrawt
+ JInUEdyXfxSU2klX+2M/cd94S+2M/cd94SUlttbWySdfzR3lUSSSSeTqfmiX2i0tIBECNfihpKWV6m4W
+ t1PvA9441/eCpKdNgqeXETLSIHmQf++pKbySr/bG/uO+8JfbG/uO+8JKTuIaC46ACSfIKle9r7S5vEAT
+ 4wivymuY5oaRuBEyO6rpKUkkkkpSLif0zG/46r/q2ISLif0zG/46r/q2JKf/1dbL/pmT/wAdb/1b0JFy
+ /wCmZP8Ax1v/AFb0JJSkkkklKSTta57gxjS97jDWtEkn+S0KT6L2Vi2yqxlTtBY5jmtJ/rOCSmCSn6F+
+ 9tfpP9R4ljNp3OB7sZG5yVdF9ryymp9j2/SaxpcR/W2j2pKYAE8BSFbj5fFW+nYQyhmCz1BZi0l7K2yC
+ X+/2PZG/836CFZXdU4NurfU4iQ17S0keW5SQjE721eYzZcdCIjr4E0hNbviolpHIK0MTDbkYmZdD3W47
+ W+kxmsl27loBc76Kp3120WbbWvqdE7XgtMfByUoxG1owZs0iBIR1FjfVGkp20ZFQa66qyprtGusY5oPz
+ eFZv6Vl04tGQa7HesHOfWK3TUGx/PH+V/VUbbaaSvZPTHtxcK7Frtudk0+rcWtLw0kVlobsb7fpPVFJS
+ kkkklKRcT+mY3/HVf9WxCRcT+mY3/HVf9WxJT//W1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSS
+ SSU2+kf8q4n/ABv8HLQGRff+36r7HW1Mru2MeZa3abms2D8zbtas7pH/ACrif8aPyOV3KyenYx6o3Hdb
+ Zk5hspcx7QGMJc9tr9/57dz3urSU2rCf+cfTf/C7f+puVfHtdfRl9Pxsj7JnfarLa3Ts9UbnD0vVH5/+
+ v+kTs6p0x2TidQuNzcjGrFTqGNBadHN9Tf8Au/pHfnKoLOk5NVlWUH0Wes+2vJrYHOcx7nPFdn0vo70l
+ Ohi5WW+7ql2QwY2ZViAP2aHcwWlln53u/lNVa622/wCr9dl73W2Myi1r3nc4Da7TcfcpXdaxrbsx+14b
+ dijGoJEucR6nvu/d91qp/a6v2QMLX1hf6vHt2xt+knAsMoXdncFtdMtsq6Z1SypxY9rK9rm6EfT4VzDc
+ cijo9mQTdYMm4b3+50NbkFvuP7vp1/5izOn5eHVjZmNl+oG5YY0OqAJEbtzvd+7uR/2pi4v2GnED76cK
+ x9r7LAGuebBY1wY32/R9Z6RKow4a8B/3XEkpyL8mnrdeRY65jA8sY8yGlr7dmwfmbdjPoofUMvL/AGT0
+ w+vZNrLPVO8y/wCh/OfvqNmb02inN+xuttt6hIIsaGtrDi5ztdN3845Q+09OyOnY2Pkvtpuww9rNjA9r
+ 930T/wBFv51aazNjKysmjF6I2i19TXVMLmsMA60N94/P5VTrzWt6xlBoABLDA8SxhcU2Vm03U9MY3duw
+ 62sukaSDVPp/v/zblDqmVVl9Quyap9Ozbt3CD7WtZx/ZSU1UkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X
+ /VsSU//X1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUux763tsrcWPaZa5uhB8knOc5xe4lz
+ nEuc48knVzimSSUpJJJJSkkkklKSSSSUpJJJJSkkkklKSSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HVf9Wx
+ JT//0NbL/pmT/wAdb/1b0JWcrFyzl5BGPcQbrSCKnkEF79foIf2TM/7jXf8AbT//ACCSkSSL9kzP+413
+ /bT/APyCX2TM/wC413/bT/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/
+ 20//AMgl9kzP+413/bT/APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSSL9kzP+413/bT/
+ APyCX2TM/wC413/bT/8AyCSkSSL9kzP+413/AG0//wAgl9kzP+413/bT/wDyCSkSSL9kzP8AuNd/20//
+ AMgl9kzP+413/bT/APyCSkSSL9kzP+413/bT/wDyCX2TM/7jXf8AbT//ACCSkSLif0zG/wCOq/6tiX2T
+ M/7jXf8AbT//ACCJi4uWMvHJx7gBdUSTU8AAPZr9BJT/AP/ZOEJJTQQhAAAAAABVAAAAAQEAAAAPAEEA
+ ZABvAGIAZQAgAFAAaABvAHQAbwBzAGgAbwBwAAAAEwBBAGQAbwBiAGUAIABQAGgAbwB0AG8AcwBoAG8A
+ cAAgAEMAUwA1AAAAAQA4QklND6AAAAAAAPhtYW5pSVJGUgAAAOw4QklNQW5EcwAAAMwAAAAQAAAAAQAA
+ AAAAAG51bGwAAAADAAAAAEFGU3Rsb25nAAAAAAAAAABGckluVmxMcwAAAAFPYmpjAAAAAQAAAAAAAG51
+ bGwAAAABAAAAAEZySURsb25nAyEH3wAAAABGU3RzVmxMcwAAAAFPYmpjAAAAAQAAAAAAAG51bGwAAAAE
+ AAAAAEZzSURsb25nAAAAAAAAAABBRnJtbG9uZwAAAAAAAAAARnNGclZsTHMAAAABbG9uZwMhB98AAAAA
+ TENudGxvbmcAAAAAAAA4QklNUm9sbAAAAAgAAAAAAAAAADhCSU0PoQAAAAAAHG1mcmkAAAACAAAAEAAA
+ AAEAAAAAAAAAAQAAAAA4QklNBAYAAAAAAAcACAEBAAEBAP/hIjJodHRwOi8vbnMuYWRvYmUuY29tL3hh
+ cC8xLjAvADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+
+ DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29y
+ ZSA1LjAtYzA2MCA2MS4xMzQ3NzcsIDIwMTAvMDIvMTItMTc6MzI6MDAgICAgICAgICI+DQoJPHJkZjpS
+ REYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4N
+ CgkJPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUu
+ Y29tL3hhcC8xLjAvIiB4bWxuczpwaG90b3Nob3A9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGhvdG9zaG9w
+ LzEuMC8iIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIgeG1sbnM6eG1w
+ TU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0RXZ0PSJodHRwOi8vbnMu
+ YWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VFdmVudCMiIHhtbG5zOnN0UmVmPSJodHRwOi8v
+ bnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bXA6Q3JlYXRvclRvb2w9IkFk
+ b2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiB4bXA6Q3JlYXRlRGF0ZT0iMjAxMi0wMy0yMVQxMjoz
+ NzowMSswMTowMCIgeG1wOk1ldGFkYXRhRGF0ZT0iMjAxMi0wMy0yMVQxODo0OCswMTowMCIgeG1wOk1v
+ ZGlmeURhdGU9IjIwMTItMDMtMjFUMTg6NDgrMDE6MDAiIHBob3Rvc2hvcDpDb2xvck1vZGU9IjMiIHBo
+ b3Rvc2hvcDpJQ0NQcm9maWxlPSJzUkdCIElFQzYxOTY2LTIuMSIgZGM6Zm9ybWF0PSJpbWFnZS9qcGVn
+ IiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOkMyNzUwQ0ZBMEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5
+ IiB4bXBNTTpEb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODEx
+ IiB4bXBNTTpPcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1
+ QTVBRUU4MTEiPg0KCQkJPHBob3Rvc2hvcDpUZXh0TGF5ZXJzPg0KCQkJCTxyZGY6QmFnPg0KCQkJCQk8
+ cmRmOmxpIHBob3Rvc2hvcDpMYXllck5hbWU9InB1c2ggYm90aCIgcGhvdG9zaG9wOkxheWVyVGV4dD0i
+ cHVzaCBib3RoIi8+DQoJCQkJPC9yZGY6QmFnPg0KCQkJPC9waG90b3Nob3A6VGV4dExheWVycz4NCgkJ
+ CTx4bXBNTTpIaXN0b3J5Pg0KCQkJCTxyZGY6U2VxPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ Y3JlYXRlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVB
+ NUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMjozNzowMSswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giLz4NCgkJCQkJPHJkZjpsaSBzdEV2
+ dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjAyODAxMTc0MDcyMDY4MTFC
+ QTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEyOjM3OjM5KzAxOjAwIiBzdEV2
+ dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdl
+ ZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9
+ InhtcC5paWQ6MDM4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTIt
+ MDMtMjFUMTI6NTc6MTMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNDgwMTE3NDA3MjA2ODExQkE5RERGMTVB
+ NUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowMDowOCswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OjA1ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEz
+ OjAyOjQzKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDY4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEi
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDc6NTYrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNzgwMTE3
+ NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowODoxMSsw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDpp
+ bnN0YW5jZUlEPSJ4bXAuaWlkOjA4ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3
+ aGVuPSIyMDEyLTAzLTIxVDEzOjA4OjE4KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MEE4MDExNzQwNzIwNjgx
+ MUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDk6MzkrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDoyMjIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxMzowOTo0OSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjIzMjNERTBBMEMyMDY4MTFCQTlEREYx
+ NUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEwKzAxOjAwIiBzdEV2dDpzb2Z0d2Fy
+ ZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0K
+ CQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6
+ MjQyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6
+ MTA6MjgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50
+ b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIg
+ c3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyNTIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIg
+ c3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMjo0MyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0i
+ QWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJk
+ ZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI2MjNERTBB
+ MEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEzOjA2KzAx
+ OjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RF
+ dnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omlu
+ c3RhbmNlSUQ9InhtcC5paWQ6MjcyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0Ondo
+ ZW49IjIwMTItMDMtMjFUMTM6MTg6NDArMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBo
+ b3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RF
+ dnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyODIzREUwQTBDMjA2ODEx
+ QkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzoxNDowNSswMTowMCIgc3RF
+ dnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5n
+ ZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlE
+ PSJ4bXAuaWlkOkY3N0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEy
+ LTAzLTIxVDE3OjU0KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkE3RjExNzQwNzIwNjgxMTk0NTc5QTMzRkIz
+ NTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTU6NTArMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpG
+ QjdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1
+ NjowNSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkZDN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjU2OjUyKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkQ3RjExNzQw
+ NzIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTc6MDkrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDpGRTdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxNzo1NzowOSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhv
+ dG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2
+ dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkRCNTMxRDg0MEUyMDY4MTE5
+ NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjQ2OjI2KzAxOjAwIiBzdEV2
+ dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdl
+ ZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9
+ InhtcC5paWQ6QzE3NTBDRkEwRTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTIt
+ MDMtMjFUMTg6NDgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJj
+ b252ZXJ0ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImZyb20gYXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rv
+ c2hvcCB0byBpbWFnZS9qcGVnIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJkZXJpdmVkIiBz
+ dEV2dDpwYXJhbWV0ZXJzPSJjb252ZXJ0ZWQgZnJvbSBhcHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9z
+ aG9wIHRvIGltYWdlL2pwZWciLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2
+ dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkMyNzUwQ0ZBMEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2
+ dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjQ4KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCTwvcmRmOlNlcT4N
+ CgkJCTwveG1wTU06SGlzdG9yeT4NCgkJCTx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlE
+ PSJ4bXAuaWlkOkMxNzUwQ0ZBMEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdFJlZjpkb2N1bWVudElE
+ PSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdFJlZjpvcmlnaW5hbERv
+ Y3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiLz4NCgkJPC9y
+ ZGY6RGVzY3JpcHRpb24+DQoJPC9yZGY6UkRGPg0KPC94OnhtcG1ldGE+DQogICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAog
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ IAogICAgICAgICA8P3hwYWNrZXQgZW5kPSd3Jz8+/+IMWElDQ19QUk9GSUxFAAEBAAAMSExpbm8CEAAA
+ bW50clJHQiBYWVogB84AAgAJAAYAMQAAYWNzcE1TRlQAAAAASUVDIHNSR0IAAAAAAAAAAAAAAAEAAPbW
+ AAEAAAAA0y1IUCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR
+ Y3BydAAAAVAAAAAzZGVzYwAAAYQAAABsd3RwdAAAAfAAAAAUYmtwdAAAAgQAAAAUclhZWgAAAhgAAAAU
+ Z1hZWgAAAiwAAAAUYlhZWgAAAkAAAAAUZG1uZAAAAlQAAABwZG1kZAAAAsQAAACIdnVlZAAAA0wAAACG
+ dmlldwAAA9QAAAAkbHVtaQAAA/gAAAAUbWVhcwAABAwAAAAkdGVjaAAABDAAAAAMclRSQwAABDwAAAgM
+ Z1RSQwAABDwAAAgMYlRSQwAABDwAAAgMdGV4dAAAAABDb3B5cmlnaHQgKGMpIDE5OTggSGV3bGV0dC1Q
+ YWNrYXJkIENvbXBhbnkAAGRlc2MAAAAAAAAAEnNSR0IgSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAASc1JH
+ QiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAFhZWiAAAAAAAADzUQABAAAAARbMWFlaIAAAAAAAAAAAAAAAAAAAAABYWVogAAAAAAAAb6IAADj1
+ AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9kZXNjAAAAAAAAABZJRUMg
+ aHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAuSUVDIDYxOTY2LTIu
+ MSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAuSUVDIDYxOTY2LTIuMSBE
+ ZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlc2MAAAAA
+ AAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAACxS
+ ZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAB2aWV3AAAAAAATpP4AFF8uABDPFAAD7cwABBMLAANcngAAAAFYWVogAAAAAABMCVYAUAAA
+ AFcf521lYXMAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAKPAAAAAnNpZyAAAAAAQ1JUIGN1cnYAAAAA
+ AAAEAAAAAAUACgAPABQAGQAeACMAKAAtADIANwA7AEAARQBKAE8AVABZAF4AYwBoAG0AcgB3AHwAgQCG
+ AIsAkACVAJoAnwCkAKkArgCyALcAvADBAMYAywDQANUA2wDgAOUA6wDwAPYA+wEBAQcBDQETARkBHwEl
+ ASsBMgE4AT4BRQFMAVIBWQFgAWcBbgF1AXwBgwGLAZIBmgGhAakBsQG5AcEByQHRAdkB4QHpAfIB+gID
+ AgwCFAIdAiYCLwI4AkECSwJUAl0CZwJxAnoChAKOApgCogKsArYCwQLLAtUC4ALrAvUDAAMLAxYDIQMt
+ AzgDQwNPA1oDZgNyA34DigOWA6IDrgO6A8cD0wPgA+wD+QQGBBMEIAQtBDsESARVBGMEcQR+BIwEmgSo
+ BLYExATTBOEE8AT+BQ0FHAUrBToFSQVYBWcFdwWGBZYFpgW1BcUF1QXlBfYGBgYWBicGNwZIBlkGagZ7
+ BowGnQavBsAG0QbjBvUHBwcZBysHPQdPB2EHdAeGB5kHrAe/B9IH5Qf4CAsIHwgyCEYIWghuCIIIlgiq
+ CL4I0gjnCPsJEAklCToJTwlkCXkJjwmkCboJzwnlCfsKEQonCj0KVApqCoEKmAquCsUK3ArzCwsLIgs5
+ C1ELaQuAC5gLsAvIC+EL+QwSDCoMQwxcDHUMjgynDMAM2QzzDQ0NJg1ADVoNdA2ODakNww3eDfgOEw4u
+ DkkOZA5/DpsOtg7SDu4PCQ8lD0EPXg96D5YPsw/PD+wQCRAmEEMQYRB+EJsQuRDXEPURExExEU8RbRGM
+ EaoRyRHoEgcSJhJFEmQShBKjEsMS4xMDEyMTQxNjE4MTpBPFE+UUBhQnFEkUahSLFK0UzhTwFRIVNBVW
+ FXgVmxW9FeAWAxYmFkkWbBaPFrIW1hb6Fx0XQRdlF4kXrhfSF/cYGxhAGGUYihivGNUY+hkgGUUZaxmR
+ GbcZ3RoEGioaURp3Gp4axRrsGxQbOxtjG4obshvaHAIcKhxSHHscoxzMHPUdHh1HHXAdmR3DHeweFh5A
+ HmoelB6+HukfEx8+H2kflB+/H+ogFSBBIGwgmCDEIPAhHCFIIXUhoSHOIfsiJyJVIoIiryLdIwojOCNm
+ I5QjwiPwJB8kTSR8JKsk2iUJJTglaCWXJccl9yYnJlcmhya3JugnGCdJJ3onqyfcKA0oPyhxKKIo1CkG
+ KTgpaymdKdAqAio1KmgqmyrPKwIrNitpK50r0SwFLDksbiyiLNctDC1BLXYtqy3hLhYuTC6CLrcu7i8k
+ L1ovkS/HL/4wNTBsMKQw2zESMUoxgjG6MfIyKjJjMpsy1DMNM0YzfzO4M/E0KzRlNJ402DUTNU01hzXC
+ Nf02NzZyNq426TckN2A3nDfXOBQ4UDiMOMg5BTlCOX85vDn5OjY6dDqyOu87LTtrO6o76DwnPGU8pDzj
+ PSI9YT2hPeA+ID5gPqA+4D8hP2E/oj/iQCNAZECmQOdBKUFqQaxB7kIwQnJCtUL3QzpDfUPARANER0SK
+ RM5FEkVVRZpF3kYiRmdGq0bwRzVHe0fASAVIS0iRSNdJHUljSalJ8Eo3Sn1KxEsMS1NLmkviTCpMcky6
+ TQJNSk2TTdxOJU5uTrdPAE9JT5NP3VAnUHFQu1EGUVBRm1HmUjFSfFLHUxNTX1OqU/ZUQlSPVNtVKFV1
+ VcJWD1ZcVqlW91dEV5JX4FgvWH1Yy1kaWWlZuFoHWlZaplr1W0VblVvlXDVchlzWXSddeF3JXhpebF69
+ Xw9fYV+zYAVgV2CqYPxhT2GiYfViSWKcYvBjQ2OXY+tkQGSUZOllPWWSZedmPWaSZuhnPWeTZ+loP2iW
+ aOxpQ2maafFqSGqfavdrT2una/9sV2yvbQhtYG25bhJua27Ebx5veG/RcCtwhnDgcTpxlXHwcktypnMB
+ c11zuHQUdHB0zHUodYV14XY+dpt2+HdWd7N4EXhueMx5KnmJeed6RnqlewR7Y3vCfCF8gXzhfUF9oX4B
+ fmJ+wn8jf4R/5YBHgKiBCoFrgc2CMIKSgvSDV4O6hB2EgITjhUeFq4YOhnKG14c7h5+IBIhpiM6JM4mZ
+ if6KZIrKizCLlov8jGOMyo0xjZiN/45mjs6PNo+ekAaQbpDWkT+RqJIRknqS45NNk7aUIJSKlPSVX5XJ
+ ljSWn5cKl3WX4JhMmLiZJJmQmfyaaJrVm0Kbr5wcnImc951kndKeQJ6unx2fi5/6oGmg2KFHobaiJqKW
+ owajdqPmpFakx6U4pammGqaLpv2nbqfgqFKoxKk3qamqHKqPqwKrdavprFys0K1ErbiuLa6hrxavi7AA
+ sHWw6rFgsdayS7LCszizrrQltJy1E7WKtgG2ebbwt2i34LhZuNG5SrnCuju6tbsuu6e8IbybvRW9j74K
+ voS+/796v/XAcMDswWfB48JfwtvDWMPUxFHEzsVLxcjGRsbDx0HHv8g9yLzJOsm5yjjKt8s2y7bMNcy1
+ zTXNtc42zrbPN8+40DnQutE80b7SP9LB00TTxtRJ1MvVTtXR1lXW2Ndc1+DYZNjo2WzZ8dp22vvbgNwF
+ 3IrdEN2W3hzeot8p36/gNuC94UThzOJT4tvjY+Pr5HPk/OWE5g3mlucf56noMui86Ubp0Opb6uXrcOv7
+ 7IbtEe2c7ijutO9A78zwWPDl8XLx//KM8xnzp/Q09ML1UPXe9m32+/eK+Bn4qPk4+cf6V/rn+3f8B/yY
+ /Sn9uv5L/tz/bf///9sAQwABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+ AgICAgICAgICAgIDAwMDAwMDAwMD/9sAQwEBAQEBAQEBAQEBAgIBAgIDAwMDAwMDAwMDAwMDAwMDAwMD
+ AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD/8IAEQgA+gD6AwERAAIRAQMRAf/EAB0AAQADAQEB
+ AQEBAAAAAAAAAAAGBwkIBQQBAwL/xAAvEAABAQgABQQCAgMBAQAAAAAGBQABAgMTBAcIIEARGDgSFBUJ
+ EDA2F3CQNzE5/8QAHAEBAAEFAQEAAAAAAAAAAAAAAAQBAgUGBwMI/8QAVxEAAAQEAgYGBwMHCAQOAwAA
+ AwQUBQECFQYTBwAREhYmGEVlF0cIaCDVtjd3l0khMYkQMEBBIiQ0UaEjtCU1dTaRMmIJ8HGxQnKCY2RV
+ tVZmtzk4SIj/xAA6EgACAQIEAwQIAwcFAAAAAAABAgMAESExEgRBYQVAUSIGcYGRobHBMkJwYhMQkKKy
+ IxQH8IKSY3P/2gAMAwEAAhADEAAAANhypgAAAAAAAAAAAAAAaymTRTIAAAAAAAAAAAAAANmDM0pkAAAA
+ AAAAAAAAAAGzBmaUyAAAAAAAAAAAAAADZgzNKZAAAAAAAAAAAAAABswZmlMgAAAAAAAAAAAAAA2YMzSm
+ QAAD7SzCZkMIYRkAA+0+06lKNPiK/AAABswZmlMgAAsA9kvMhgJmcZgAFzEzJmQwFflZnxAAA2YMzSmQ
+ AAdMgmZDATM4zAALmJmTMhgJmczEMAABswZmlMgAA6ZBMyGAmZxmAAXMTMmZDATM5mIYAADZgzNKZAAB
+ 0yCZkMBMymSMlfg6MPjPZJmQwEzOZiGAAA2YMzSmQAAdMntHsnjA9khhDCmQdmEMPaPZPGB7JzMQwAAG
+ zBmaUyAADpkmYABDCGFMg7MIYTMAA5mIYAADZgzNKZAAB0yTMAA8YrIpkHZh4x7IABzMQwAAGzBmaUyA
+ ADpkmYAAKZKZB2YAAAczEMAABswZmlMgAA6ALMAABzmV+DqYkwAAOTTxQAAbMGZpTIAALAL/AD7QARk5
+ ZALAOjAACGHMwAABswZmlMgAAHTJMwAczEMAB0yTMAHMxDAAADZgzNKZAAAAAAAAAAAAAABswZmlMgAA
+ AAAH9ZOF+7Lc9/hE2D5MZvP5S8AAAAADZgzNKZAAAAAU+rI6ZP8AO8s/enfDH7dHlXjlK81rtce0n6h+
+ HD9I/wAeU4S4iIAAANmDM0pkAAFwl6FMHnHxl2ndEzWuTeifG3JOW59rvpv0txzKwXLWhfWd5Uv6IKPN
+ BzKo55AAANmDM0pkAAGvxATrc5ULaOervDo3Ncz8KVgMws/yTVPX+wRS+LbGH6TU2P274DP802PjMaQA
+ ADZgzNKZAABr8UGd/HJpzUaFe2M8WfqdYekPO+fqmouN3OtPSH0dE2PnuBtfrK50GmJ+mQAAABswZmlM
+ gAA1+IwcrnVJzNW3oX2xfPHrC8StvP18Trfyn3hZJ5o9InSMbN8Q2SOpCqgcmAAAGzBmaUyAAC4CnwAp
+ +1sAAA/FVLwAAAANmDM0pkAAAAAAAAAAAAAAGzBmaUyAAAAAAAAAAAAAADZgzNKZAAAAAAAAAAAAAABs
+ wZmlMgAAAAAAAAAAAAAA2YMzSmQAAAAAAAAAAAAAAbMEzIYAAAAAAAAAAAAAADsw/9oACAECAAEFAP8A
+ TdIs7u5fALr0yG4RFa1Z7nwv5q3uE2U1ovWcuZLmvdBWabf28mMiVYbCKepJM9psUmKLmU+bBb30gjTr
+ iZ7hl6fBAtKCqlq9s9z4X8zBBFMjnyJUq/XYZNGVcvfKVYoZykuQyPbKEuGCbzMqKZJfPm+u9UpvrlS7
+ jpBdzPVeKU31yLt75kT3dH8u53V7oHNE90UcyJ01zp3R0zpMi9PV8x8Mx0cPR/L/APjep7ep7ep7ep7e
+ p7ep7ep7Pe9/+Tf/2gAIAQMAAQUA/wBNyoRj6JDdZ3xPZzUjJ+PV18uZLnQcy/r0Vkc0v3kWJiS9tLqx
+ gmXPxzWImsKdvhoAmlchLCsgJT7CUoypXMmFhcq4sq4YMkiy+Ie2J0m4uMZB4AdY7XJcyCbL5m6uZVnb
+ pSpf3wpiqapfJ36JBBfAEmcnBOLJyn84HXky4suZvpVopQpSf7UZCbF1rf3aS6K6HrKkNhVh7VUH4IbO
+ VDE6KHl4onQwzLiPpJgjk2tlJispkae6OKzqWUqtThs4ZtnFbzXTIeXe50TqUDUoGpQNSgalA1KBqUDQ
+ wQwv/wAmf//aAAgBAQABBQDPmfM6o2de43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43Y
+ Vu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43YVu43Y
+ Vu43YVu43YVu43YVu43YVv7HyG2xvkLz+xvkLz+xvkLz+xvkLz+xvkLz+xvkLx2Caoqs8hw0XD8gTFJE
+ kDzKPSB8uWAoyHZHDYJqiqz1wcIRm6UwuQiJypjlUmF5pjYkCI/07G+QvEiY2JFpFsAhaFTYlGqDDqHW
+ x4Zoftshko1Q4sapvvRjMKH8chko1QaBD6rmYUP45DfhoukpykmqKMo8exvkLxDqHWx4Zoftshko1QYd
+ Q62PDND9tkMlGqHFjVN96MZhQ/jkMlGqDQIfVczCh/HIZKNUGyPbeyyHx7G+QvEOodbHhmh+2yGSjVBh
+ 1DrY8M0P22QyUaocWNU33oxmFD+OQyUaoNAh9VzMKH8chko1QbI9t7LIfHsb5C8Q6h1seGaH7bIZKNUG
+ HUOtjwzQ/bZDJRqgw5jOXeimSQuMIJPxdYbtElOGBG6RpOYUP45DJRqg0CH1XMwofxyGSjVBsj23ssh8
+ exvkLxDqHWx4WBF1CQko1QZ4RdD48WBF1CQko1QYdQ62PM3pvxZP+CUaoNAh9VzIYRdX9iSjVBlEIukq
+ +yGEXV/Yko1QbI9t7LIfHsb5C8Q6h1seEo1QYlGqDEo1QYlGqDEo1QYdQ62PM3pvxZP+CUaoNAh9VwlG
+ qDEo1QYlGqDEo1QYlGqDZHtvZZD49jfIXiHUOtjwlGqDEo1QYlGqDEo1QYlGqDPCLofHs3pvxZP+CUao
+ MohF0lXxKNUGJRqgxKNUGJRqgxKNUGyPbeyyHx7G+QvEOodbHhKNUGJRqgxKNUGJRqgxKNUGJRqg2b03
+ 4sn/AASjVBiUaoMSjVBiUaoMSjVBiUaoMSjVBsj23ssh8exvkLxBPtVwKJRqgxKNUGJRqgxKNUGJRqgx
+ KNUGyjOnuPPwn2U9bDSUaoMSjVBiUaoMSjVBiUaoMSjVBiNTtVoh49jfIXiC1tFsLJTTE5STiUaoMSjV
+ BiUaoMSjVBsjXKKJx/kLW0WwsiUaoMSjVBiUaoMSjVBiUaoMeLQog3X6NjfIXjHUOtjwlGqDEo1QYlGq
+ DEo1QbI9t7LIfAOodbHhKNUGJRqgxKNUGJRqg2R7b2WQ/wBGxvkLz+xvkL+2XInzmhR1KJ01PvZLPc9z
+ /wB2xvkL+uVNtYGHBExI0mGJ7ofU9kEINChPVLx1s+ZdWUxo3wPf+FEAOEcY/Tsb5C8WJ8DZQzdBf/Xx
+ tQnjWMNd8q5gRsO4MyPnhcB8MZLySb5E0V2TxoNaQDK2ZaKHOkuxgAOVnNpEjKpRqIeaKbJCwpi/EGR8
+ zEeRdGNksZDf13awSz8i2Q1EzHjO8zVg3I2e9Oszas5twNa/o2N8heL6lP5F9eOWMmlezevtpbWJR9UX
+ /Y9CSJEnleO8/wCdNJ8hakrt+O6JfWWempDkc3kW6eaaRrKmg6c/WlkM6IM0a9y4QjC/1e5AOSbJf1z3
+ d3ZbVZ0LCq/ylteYlYnoljRfXDz6zf0bG+QvF9Sn8i+tKVMdtFgVz4zL6ooYn5hssI5oI77WTK6dvSE4
+ DRIxjRb6rY/VmHIkx39gaZQzJ+kP1Zujjz9ht7rnXz6ooYv7i+u97n7j5rc+HMm5/gtgf/5l/o2N8heL
+ 6lP5FafZMNDydr5tyfYHyRbfZSOhqtgXcMzwUZLn2JISAN412vVMd4C1e2VvdZy4hWol9f1z3QItcARU
+ +xhDQBnWzbM31zXSL7F0tDGMF5uLMB5HzvuVirMQRmHapQy5hIH2qUArW/8ARsb5C8WJM9ZYwXccHV7d
+ Xt1e3V7dXt1e3V7dX/t2N8hef2N8hef2N8hef2N8hef2N8hefyP/AND5/wD/2gAIAQICBj8A/c3W2+2k
+ kP5VJ+ArUvTzbmyKfYWBombp8oUcQNQ9q3FEMCD2rHKv63TmlPOUgexUB99Rx7Xy7D+qxAGNzcnDFlJz
+ 50gIAawuBkDy5fsjjlnVZHICgkAkk2AAzOPdUIm6XFPA4za2BGYxU8LEd+PdRv0JUbvWVh7rEe6rwxsq
+ 9xYN79K9q2k8ptGsgJPIGhEsxDk4agQD68vbas66VO7WRNBJ7gJLmpNmJrSnFCwIGoZY8L5Y2zoqRYjt
+ Soo8RNq6dAVBjCKDz8TE39NQskah9VrgWwscMKjJbHSPhWwDi6HSCOWvGomSJQ4cC4AGFjhh6BUTr98a
+ sfTbH25+vtSbhOBraycl+JqMfm+RpBfgK2r9xH81IL/ePga2q8dAFWPaLUNT3A4Ur3xFAE0BegxbIUNc
+ hIFC5xFZ3/G3/9oACAEDAgY/AP3NxfrPXNptV/7Zo4/5mFGGXzfGX/JDuZV/5RwuvvpU6b5v2LStkrSC
+ JzjbBJdDnHl3d4pZIpFaMi4IIII5EYHtR0nGiOn+c4NjH+TYrI3H7pp3XiPsGXprebzr3+Zep/2EUbPJ
+ aP8ATjCKt2JSKZFsFBJ8Pf31uHjkd4i50s/1lbmxbE+IjE4nHiayrebvp/Sp5tpt0Z5XSNmSNUUsxdwN
+ KgKCcSOVdSbpvnzfdK6ttXF44dQDRsPC4KzR38QZWFjp8OPitSgf5Wm3EQ+2fZQyX9L/AKiycvrrR1Le
+ QzS4eKOJohzupll5ZEce/DtPmLpewTXvJ9pJGq3AuzpYAkkAXuMyBY3OFPv5+mLJt0W7/pursoGJJUeI
+ gcSoYAAk4Y19Brz70zaxFt1uRuI0XAamfaBFFzYC5IFyQO81svMr9ND7BQV3CxSI7CFra7oDdtBs4Cas
+ U7saSWNg0bAEEZEHEEdqm3U7WhjUsTyH+sK86dWWVk3cm4nZCDigEESoFPAqALEYg4511ODdbyWTbmDV
+ pdiw1a1GoaibGxINs+N7C29SOECMSuAAMAAxsB6q81vt2KbhRMysMwwgGkjmCARW/h3W+mk27bVmKu7M
+ NYkjAbxE42ZhfjfGuobWQWG13ksS/wDmGug/2g6RyHatx0jcAkNHc2wtjhj3g2Nsjxwwrr2yuD/UlHI+
+ BBf12rdvbOG38S1uW05yN8TXXduB9aye+K1biTTnt2H8aH5V12U/T/dSP7r/ACoMpwI7QWPCnMO3CyNm
+ 2F/hj66n2ojurk3N+8AfKnkSO5It770zlMSb+2njjiBu18fUKcbbaJG7ZkW+QF/XTlFujZg8efpqwj02
+ 4doscqyrKsqyrKsqyq4H4m//2gAIAQEBBj8AzpaGjOnNlqaWrNnMZta2ttzGvAi3NrcRvB5KkiBAkVeQ
+ ixMkTLBShhBByyyBySwllhCEIQ09/Gc3zQvf15p7+M5vmhe/rzT38ZzfNC9/Xmnv4zm+aF7+vNPfxnN8
+ 0L39eae/jOb5oXv6809/Gc3zQvf15p7+M5vmhe/rzT38ZzfNC9/Xmnv4zm+aF7+vNPfxnN80L39eae/j
+ Ob5oXv6809/Gc3zQvf15p7+M5vmhe/rzT38ZzfNC9/Xmnv4zm+aF7+vNPfxnN80L39eae/jOb5oXv680
+ 9/Gc3zQvf15p7+M5vmhe/rzT38ZzfNC9/Xmnv4zm+aF7+vNPfxnN80L39eae/jOb5oXv6809/Gc3zQvf
+ 15p7+M5vmhe/rzT38ZzfNC9/Xmnv4zm+aF7+vNPfxnN80L39eae/jOb5oXv680/z5ef/ANTXaP8A5ofP
+ eH/68/jv859afx3/AGumfHxmzQ9t3z9P/Bn0z4+M2aHtu+fp/wCDPpnx8Zs0Pbd8/T/wZ9M+PjNmh7bv
+ n6f+DPpnx8Zs0Pbd8/T/AMGfTPj4zZoe275+YEKtZA65GQiTk5ClyBUc4OG3Mzcad3c+IEXDEEkJNTSR
+ HNGRYw2AC4M4k8ZZJJpoOQsADruI1HT5U0VIWZmcRHkAanHNIk7OQk1y2IwFihJqLZROhwzKYEBMAl5Z
+ 5ZgoDkHgBti6BMR00I8Wy6vBo4aYHF5AgOWtPxOEJR204d8P1zlmwkGWs8MWaBN7iXlMN4puY4AOUHO2
+ ePEJtOtQjudvM+aKmiDi1ASDkczr7tqUNtaTuVuURZqJFCzAGXmLE2uUuCYBFlmkIDwHZ20c1cFpXMxl
+ ip2DaaMPDC6tgBZxmcbkaJSA4p0oAGCdmdrNeCsApowniYajgerbLDyyeiIVayB1yMhEnJyFLkCo5wcN
+ uZm407u58QIuGIJISamkiOaMixhsAFwZxJ4yySTTQkI3IwvVvHRF2GUfGs80mp6Y8OdvOWwXPgFxZqe/
+ spwiPqh/RHCgwM2oQKeWV8aytrnZCzMSvcgXFcrQcTriEA0AeLUuEIfd3fwoNjsOdKB21CIpk0ORMSTt
+ kZxJ26dtmmsi/mhla3oszWa9XkRMGzzTd7rS92mu8LhKMzyYAsVkeSr04MtlHtmZwZWbYSjmDoDcXLm5
+ iosziVOmiJc6cbTbsHbV7MjcTcS10XvapYganvG1rYMhHXQzl85jgBYUZ4SFxgBoBHSh8oU/Mfgz6Z8f
+ GbND23fPTMv8Cp1vbwiRlyJDGravY4A8NxRhzGfBz7a4MVrPDSiDEyudCcwpgwBJIYBFEmjKTIuhog9W
+ +9tB0UQpbOb0CYxq134uA6gWxbd/Mpx9bWq5su3p7BJNz3bZuWYYyzkDDaYJC45pkHLCnyF18KJ0/aD3
+ fI0yPm58o1vIUO73VaWl9F0vgduObvY+3ZjyZXbnK8TDY/FWKrqvLo/4uFQNtRXjGHTdteXpqiy5ye7y
+ TVZmfplDudT9VIfM8gldK5dLR1USlbCigwpaPYX2yjT27dfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4H
+ 9G9h6TUEqv8AeN36wj2coc73H+M7I8w6ds0tV/eTNso1X7COuW8+i7vUrCvMEtjbnUDB15h+JEmkU8um
+ U6bXRcBOtJa0GAgmQUu07r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA+eQW72ulXneZbB3O10dNl5n6c
+ SJuXSfdtJSMdOistOix0BBFVLZfRd3qVhXmCWxtzqBg68w/EiTSKeXTKdNrouAnWktaDAQTIKXaY51xA
+ OtBkmSdjTg0OVmZnBOLYOyAZsiuTafFBsQdpAOlRMnXMIWZVEuBPNGIwocje9ztR9odyB1qdmo6abXRr
+ cio5FxbXEiOIVOkD5I0GEZJnSZkKYMUISWWcOeWMs0IRhGHp/gz6Z8fGbND23fPTbjm72Pt2Y8mV25yv
+ Ew2PxViq6ry6P+LhUDbUV4xh03bXl6aosucnu8k1WZn6ZQ7nU/VSHzPIJXSuXS0dVEpWwooMKWj2F9so
+ 09u3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B245u9j7dmPJlducrxMNj8VYquq8uj/AIuFQNtRXjGH
+ TdteXpqiy5ye7yTVZmfplDudT9VIfM8gldK5dLR1USlbCigwpaPYX2yjT27dfCidP2g93yNMj5ufKNby
+ FDu91WlpfRdL4H9G9h6TUEqv943frCPZyhzvcf4zsjzDp2zS1X95M2yjVfsI65bz6Lu9SsK8wS2NudQM
+ HXmH4kSaRTy6ZTptdFwE60lrQYCCZBS7TuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D55Bbva6Ved5l
+ sHc7XR02XmfpxIm5dJ920lIx06Ky06LHQEEVUtl9F3epWFeYJbG3OoGDrzD8SJNIp5dMp02ui4CdaS1o
+ MBBMgpdp3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B78JpECS87oLIafSEWA+HgklK3Ry/pibY2E9BZ
+ MHVsICepOH6X4M+mfHxmzQ9t3z0245u9j7dmPJlducrxMNj8VYquq8uj/i4VA21FeMYdN215emqLLnJ7
+ vJNVmZ+mUO51P1Uh8zyCV0rl0tHVRKVsKKDClo9hfbKNPbt18KJ0/aD3fI0yPm58o1vIUO73VaWl9F0v
+ gduObvY+3ZjyZXbnK8TDY/FWKrqvLo/4uFQNtRXjGHTdteXpqiy5ye7yTVZmfplDudT9VIfM8gldK5dL
+ R1USlbCigwpaPYX2yjT27dfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4H9G9h6TUEqv8AeN36wj2coc73
+ H+M7I8w6ds0tV/eTNso1X7COuW8+i7vUrCvMEtjbnUDB15h+JEmkU8umU6bXRcBOtJa0GAgmQUu07r4U
+ Tp+0Hu+RpkfNz5RreQod3uq0tL6LpfA+eQW72ulXneZbB3O10dNl5n6cSJuXSfdtJSMdOistOix0BBFV
+ LZfRd3qVhXmCWxtzqBg68w/EiTSKeXTKdNrouAnWktaDAQTIKXad18KJ0/aD3fI0yPm58o1vIUO73VaW
+ l9F0vge/CaRAkvO6CyGn0hFgPh4JJSt0cv6Ym2NhPQWTB1bCAnqTh+l+DPpnx8Zs0Pbd89NuObvY+3Zj
+ yZXbnK8TDY/FWKrqvLo/4uFQNtRXjGHTdteXpqiy5ye7yTVZmfplDudT9VIfM8gldK5dLR1USlbCigwp
+ aPYX2yjT27dfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4Hbjm72Pt2Y8mV25yvEw2PxViq6ry6P8Ai4VA
+ 21FeMYdN215emqLLnJ7vJNVmZ+mUO51P1Uh8zyCV0rl0tHVRKVsKKDClo9hfbKNPbt18KJ0/aD3fI0yP
+ m58o1vIUO73VaWl9F0vgcW4nIm9HVrKffGoRsKXySKkypK2s8TEZDwwOUlzMzpqecqpTMRwHMEnKTBMg
+ TjB4bqet403ShHS5E0duURpKORO6CziTbmS9rps6QqfM3VZGXxl0OhGbYFxRwGwvJCeMQRwSh0I2QKfk
+ cgnJsuYy7MxK5wzx0uWzKa24Zxt0DxDyiGg2t2yAlMt5KBnKYrPOAbOBThSEz0hkYpGqz2rmoxHmypnb
+ Ven9jNnN0XgVOaZ8r89pjE+FcOSF0v8Ab39KxxN4B4a3DgCRQMCXEJTPNuPou71KwrzBLY251AwdeYfi
+ RJpFPLplOm10XATrSWtBgIJkFLtO6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPnkFu9rpV53mWwdztd
+ HTZeZ+nEibl0n3bSUjHTorLTosdAQRVS2X0Xd6lYV5glsbc6gYOvMPxIk0inl0ynTa6LgJ1pLWgwEEyC
+ l2ndfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HvwmkQJLzugshp9IRYD4eCSUrdHL+mJtjYT0FkwdWwg
+ J6k4fpfgz6Z8fGbND23fPTbjm72Pt2Y8mV25yvEw2PxViq6ry6P+LhUDbUV4xh03bXl6aost3eJGFGSa
+ WXN9sMNu4LwT1mjR7xKmih7DA8MVrMBOghWIOHrMtpY4TS/uxlhDbTYVqXXwonT9oPd8jTI+bnyjW8hQ
+ 7vdVpaX0XS+BzrOeYVZ1hZbtbDbluC8F8c0ykfFkVMHsS4fDEK/lNgW2YiazzlIcLU3+mMkxGyYWynd4
+ kYUZJpZc32ww27gvBPWaNHvEqaKHsMDwxWswE6CFYg4esy2ljhNL+7GWENtNhWpdfCidP2g93yNMj5uf
+ KNbyFDu91WlpfRdL4Hbjm72Pt2Y8mV25yvEw2PxViq6ry6P+LhUDbUV4xh03bXl6aossoBSaPtb7fu+7
+ +7m0lzezKbv4Psjyb20aJL/doqZOl/s9PQ2n8l18KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vgfPILd7XS
+ rzvMtg7na6Omy8z9OJE3LpPu2kpGOnRWWnRY6Agiqls3IVKMNHFJPT85zj7gvBDCK21cPileDxHWx+GL
+ L06SxSVniFtU47eTLodRssAVbBidnXXwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B8zzRhh2wnJ6vpzIg
+ bgvBWhlW63vE2zzkdTn4YiZJtSnbIGM6m8C2CZVHrmLNxpsMnLSuQqUYaOKSen5znH3BeCGEVtq4fFK8
+ HiOtj8MWXp0likrPELapx28mXQ6jZYAq2DE7OuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D34TSIEl5
+ 3QWQ0+kIsB8PBJKVujl/TE2xsJ6CyYOrYQE9ScP0vwZ9M+PjNmh7bvnptxzd7H27MeTK7c5XiYbH4qxV
+ dV5dH/FwqBtqK8Yw6btry9NUWXdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlG
+ t5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0t
+ L6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vgduObvY+3ZjyZXbnK8TDY/FWKrqvLo/4uFQNtRXj
+ GHTdteXpqiyygFJo+1vt+77v7ubSXN7Mpu/g+yPJvbRokv8AdoqZOl/s9PQ2n8l18KJ0/aD3fI0yPm58
+ o1vIUO73VaWl9F0vgfPILd7XSrzvMtg7na6Omy8z9OJE3LpPu2kpGOnRWWnRY6Agiqls3XwonT9oPd8j
+ TI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vI
+ UO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfR
+ dL4HvwmkQJLzugshp9IRYD4eCSUrdHL+mJtjYT0FkwdWwgJ6k4fpfgz6Z8fGbND23fPTbjm72Pt2Y8mV
+ 25yvEw2PxViq6ry6P+LhUDbUV4xh03bXl6aosu6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2
+ g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bn
+ yjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA51nPMKs6wst2thty3BeC+OaZSPi
+ yKmD2JcPhiFfymwLbMRNZ5ykOFqb/TGSYjZMLZRQCk0fa32/d9393NpLm9mU3fwfZHk3to0SX+7RUydL
+ /Z6ehtP5Lr4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA+Z5oww7YTk9X05kQNwXgrQyrdb3ibZ5yOpz8M
+ RMk2pTtkDGdTeBbBMqj1zFm402GTlpXXwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+Rpkf
+ Nz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd
+ 7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HvwmkQJLzugshp9IRYD4eCSUrdHL+mJtjYT
+ 0FkwdWwgJ6k4fpfgz6Z8fGbND23fPTbjm72Pt2Y8mV25yvEw2PxViq6ry6P+LhUDbUV4xh03bXl6aosu
+ 6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe7
+ 5GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5Rr
+ eQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vgcoBSaPtb7fu+7+7m0lzezKbv4Psjyb
+ 20aJL/doqZOl/s9PQ2n8l18KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd
+ 7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8
+ D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD
+ 3fI0yPm58o1vIUO73VaWl9F0vge/CaRAkvO6CyGn0hFgPh4JJSt0cv6Ym2NhPQWTB1bCAnqTh+l+DPpn
+ x8Zs0Pbd89NzkL25ii24yuTYecN3Gd1xzU9heI26ZDy5syHu06SwSUwMdbg8hHJaWplMglSRZwtO6+FE
+ 6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR
+ 83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod
+ 3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6msUiSbQ7fua7GcqTK263W2OXAkux9PzA
+ ORMlY+W5kU6WMnxApYnGRrMFi4YRSUmSALgEi/5JbgNW2SmMuts3G8GDTbl63EW6A47V4rjoo5CVo8NT
+ i0t5IuIyRmCgVeJi5SRshhnCsjXKPZV18KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6+FE6ftB7vkaZH
+ zc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3
+ e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6Lpf
+ A788ESNMJOz06OZRt2GcOnlT54c0XI4dvMdssEiQIWAeoi2t5OGz/QlgA9kKT0vwZ9M+PjNmh7bvnpv7
+ W7FiUBHEk7mibofLMJgAsOVy/wAwWom2hr8ub6ewzrs93ASiWmKjtxeQwXknGFLDyEnhnfHdoYyR1pOk
+ r3cmt0bbIAmbjDdMB4tTRI+QOlfCUxlpSUpZjlECFDmbZAZG2E0sWyDZCNj3XwonT9oPd8jTI+bnyjW8
+ hQ7vdVpaX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9
+ F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwO9F3BgJFnA8du0q3tQlrMLC4zADXR4k7RGcioL94X
+ LHDlJW47HSEo8oM7eYAnKgly4RM4ULFrO/K/tbsWJQEcSTuaJuh8swmACw5XL/MFqJtoa/Lm+nsM67Pd
+ wEolpio7cXkMF5JxhSw8hJ4Z7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1v
+ IUO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtLS+i6XwPdfCidP2g93yNMj5ufKNbyFDu91Wlpf
+ RdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3Y2zt7LO8lHq6WMdiBYLaaHhsNG3jxCNEZzBR48M
+ FlU+gbxMw4wEJm04EFApIWBJmC5MCz/T/Bn0z4+M2aHtu+fmG45u9j7dmPJlducrxMNj8VYquq8uj/i4
+ VA21FeMYdN215emqLLuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D3XwonT9oPd8jTI+bnyjW8hQ7vdV
+ paX0XS+B7r4UTp+0Hu+RpkfNz5RreQod3uq0tL6LpfA918KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge/
+ CaRAkvO6CyGn0hFgPh4JJSt0cv6Ym2NhPQWTB1bCAnqTh+g3HN3sfbsx5MrtzleJhsfirFV1Xl0f8XCo
+ G2orxjDpu2vL01RZd18KJ0/aD3fI0yPm58o1vIUO73VaWl9F0vge6+FE6ftB7vkaZHzc+Ua3kKHd7qtL
+ S+i6XwPdfCidP2g93yNMj5ufKNbyFDu91WlpfRdL4HuvhROn7Qe75GmR83PlGt5Ch3e6rS0voul8D34T
+ SIEl53QWQ0+kIsB8PBJKVujl/TE2xsJ6CyYOrYQE9ScP0/wZ9M+PjNmh7bvn6f8Agz6Z8fGbND23fPz2
+ oIEQT/oSTTf8kI6a4Fowh/tCAyR/0TiSx0jEQqNCEPvjLLGeX7tf+tJtQ+7TVGEYRh98I/ZH89+DPpnx
+ 8Zs0Pbd8/OftlZxY/wC0YjLL+r9UgUsf59Hi4LYy9fHlhtwuZNPz+3tR44zsoBQvA2Ymc3iBSciRmDLz
+ Qn2RBZZ4wjDVCOuGksI6oR1Q1wljDZhHV9sIfZD7Nen3/wA8NHp3ty1rge2m3CB1zuB2bGo6ba2Qg3Ex
+ XA4adXEEGYmQDAJgzCRxZ5YxhD7NcYwhoHiEwjAYkI6phIyx1Tyx+2WMIhz/AKowjDSP9nSyR/lDMTya
+ v+rsRk/m0/o5ZpIfyTTwn/0RhJJ+VtvR3tG42q0nk0CTZrjc2c+QZ3gwOVGOhSNJ42AEA5SzlC84m0BG
+ eSEsPtj9sNf5j8GfTPj4zZoe2756d1TZZ27LcYtnN5Zyeikjk2kjic4sSyEC580WncTQ8SAkJQgdqeM0
+ IQhDXNCEZrkny/LGohFYnBmAhcbEduUMGWTEmllbADs8ps1KH9qcAQUxNH9mWSM/7Ol5v1isRVwbbBCk
+ Fuic68NbSMQlnKnzsISFnI0WHMzwAbBoxlDlmjCMuqP2xhDR0t3LRoKvDqztMXo+Abdm1okCb4HCxGIs
+ o7mZLBCzqTckNiWMZtUderVCOh3Lux7WOXFdTaOeAciZMYoGUbZW02hOmnB1NGC7WRIgmtUmMKNJJPPN
+ LLLGM00sInLte7KLObG1lRDzwYtp7bXsy0lAZIiDmTjcXGlcJyxYOWMwooAQwYUksZp5pZYRjpn9aluE
+ qi/3Fed/NDORiOWKwNuB7LuwC5UGJk6MXKF5Zxp4QjOIJJJL980YQhr0NXS62aXc2luKiHXWNuPLc9HW
+ soCHijmTLcWFgdGALyQjMJOXkHlDlljNNGEkIzaf638+niWtxiKzOD2/y34xs5CQQEKc66uuWJUi3lJB
+ jAgJcKYybMSSQmEnlkljHXNGENcdDdxH7JLuZMgVEPny1vvjU8uraCAHiiiiNpUypOwDl1wmgTgZjCEI
+ zatmG1pG1ctrXO3K8BARNnJARCpMk2kpZ5Q5jjm5uA5Ruby+JNCWWIossRJ4wlkhNNGEsTd2PlkgubE2
+ FZjjuZtl5bn4w0lQ5JhBzJxuKjQcolSockZxhgghQQZIRmnmllhGMDmZ+ZFisF15VTW6/NTFWzBBwAjf
+ BF+tyUOJi3pjERxgwmmB6WExgGcvHa+6M2xGGY+aDvabOzZbwvZ1GbB258t+eUs1P9zDgW+CXZSBuYyV
+ BiEcBkgFKFLAGX7IwlhL9nhNtbLZpKujk22nlc8Oc551b2koQbJcqQiUTYwx8wFMNBUbDkgGDKKLHa17
+ OzCaMCrpmFaUxVgOmJCZa5Gk+TemOJ0SScSQmYNERRBG40JKHNhyGQwYi7M2HtbMdXp/gz6Z8fGbND23
+ fPTzt/wWx/69c2hkrc1+3W/lLnte6T76SeHs+4ET50rKXOFTcxI0MKVBMFBtcAZwpJJgg5pg5NQc00sf
+ 94wWJgBFi4d63BMGADJAMIOIrffwwmxJLCEskswgkY6oaoQ1/ZpmN8M5/am39PFflu3u5W2czbrfHw9a
+ ryJAKJwYsUHukhKMRDn/AGjQlrOR+Q5MDDXGaQeM0IRlknjLetmZ0Wxct/lrilClGaLju9xg2nIgjmA4
+ 3VbDu5tr8WdCjoXGjILGSSSA8JYBj7AgeyH4krhtcyZYHFuujM1wZjZAaIRxpH7O7KELCkzMsITgmSm3
+ DDFl2Z5JpYTSxhNCEYZi2+/XZcL4yzWVK9U15dzzqVkdQn1qJQPghnxjGAZnKHBAxJpNnFljLt7WxJs3
+ eQJhSFiZK6H8oULhQ2QgCxZ2NggAhy/80MIKSEsIfqhDTxPv7MdHbnhjAzBd2lxLTbBkg5NuVpY6QOl5
+ 4wjCQcqaBknkjq+yaWGl7ML9eFyvjOZy2drgGbnl6cHUtM9E7rs8kA6QkPjjxkOylXUxJNPLGEZ5RI7W
+ vVLq8fly2lLKwPrJdudUzO6N0soJtujadovB63IFxNUYyysx0yIKBCOuEk4k0f1x0zMt+5LvuS4mUeyK
+ 4I2vzyfeC1Ykf2olFxkkcRzOEaGKHhAxZpYyxGljDb2tiTZzftYqcOA2012bmHM3MEhsxRyU5fMuyyoI
+ hZuiLEqCMGWmjJCeEsJtmMYa9UY6Zrs565bgOtMmZN6hyNZt5cTLdKGVulyTBykhjM5aWQvhy4cIS6pN
+ mGrVq08Kwdr3E827B8tvKci7zsrgZbB3AiBlRA6GSMmSYgJgQmrBkEmC2sOecOSM0Ixll1ZyCXq7uN1D
+ Mp+4CLWYfjY7oaKFGYzaTw0l5DZucUzMG2OIsRAITTzYUISyy6pJZZYen+DPpnx8Zs0Pbd89PO3/AAWx
+ /wCvXNo3SxDnhMDZl4YsIyTQiFqLlg44kIw1yahJoS/bq/ajq+/T/eMhSQjOJNej1CUOWG1PGM7Zfksk
+ ISQ1zRjPNDVD+WOmY88JZtiXLSMs02qOzCaa6GGMssZvuhNNCSOqH69Uf5NM389csIyl2/KnMC+D7q7N
+ 1xAMlxsU1uxNXKcdm6QUYmMPKVbZ9qWBcSYeeaEZZQ4xjDXdOSfiBtki+3HajGE8tF+kAACLmICMOG2T
+ OwUAAJAmS5m40MBNEQtqKnwpppBQISyTwG8YFtimgTwlu3tnGxCHS32Fzc7RYlmkJzQH7U/9CPMX25ft
+ j+zGH26ZiQ192s/tQwaX19sP843P/wCdntPFoGDJOKKI05nBhBhyzTiCCT5RhSyBySSwjNPPPNGEIQhD
+ XGMdLyEhLNEOTJ59kmEhLGMks4l6WDMHJNNq2YTTyhzRhCP2xhLHV90dP94fIBGAswt3eImAcAo4kZ4C
+ 2S4wCjJCTajNASP+rq16/wBWmY82zNsy5axlmm1R2YTTXQwxlljH7oRmhJGMIfr1R/k0ztjCMIwjZeZM
+ YRhHXCMI5pWTGEYRh9kYRhpm1LNCMIwzNvyEYRhqjCMLqdYRhGEfthGEdPCD/guVn/w+Jpnv/jN5f1Wz
+ vzH4M+mfHxmzQ9t3z087f8Fsf+vXNo8vVj+GWw7SzRuMqIG93c3GmwsVcT4005gVzdJG21W19egp3CMB
+ 0pg9r2po7Q800Nqa7L+iVL3oDmGaGPZgMriZpc9wOAh886BupdzLFDVLdS55zMxknTjA7BgSWIUdcs0i
+ jKfwzWDZba6CjmrvlKmSDW7XIbiGMjFmO25bTUADOVMjREnEMhHZxoTTSy4UYxnjfDyRYW65rOzFdDrp
+ c9huhwQEmIYNGjY4Rhtc4FDUSJ0IA5OXEnmLDAmQIwgKFNGQKYN8acg/D7ZOTr7cZacE/c7ZBilFLizy
+ ThynAWtitZhAPuJWAs0wAxoUUMMT7ZgZ4a4RzPyKhaJV8CzMP3M4G7qNPxgudbhblt1kYBtTfTjMp6YC
+ DNAbamHkiJMJGEdWrXG4LsI2oUu8R/tyNvTkjbwMzyFpIuZByVSjgt7hMLNtEYSbEZZYaptev7NUXx9n
+ BlLTPTu5O0xaUWIspeZxOjHIgSixlkiJAKI2zCaMsNerXqhpclmMFkMFyC3Hc4FwCuT64HZSwBeJRrbj
+ 7bM1lAQ4mFRAhPLILExLAIQWE0QxISxkneiWSHh4sfKO7LlLzBu1zNs7LNIAPGE0IHZCDJaluxeTwERx
+ ZgBTYmwEJqmmCEhGaXR/NE28neds3fMEJdlsPZwYCLkbAUYLoTd8E6KQdIwNCSCiTgmAjAU8YCBzTShT
+ hvzJkFkDZmTjxcwU0HK5m2ZngKEZEDFBifBaWG2LeLnXYrILGYuZNCjSBzx1zAzw+yLfmPashQ+eALnG
+ 50bHTGmJPjQ5YcTxA2IDPIYDmnFBDGDFlm1yDhSTRhNCEZJriYiPhes227vu0yA6Ot9RcyM7yUfC23AF
+ 5kOslr2+7vbjJAyNLCc2agFGWeMooQ0k80mmU2TBmzCbGVyrJ2wTLv4D0OeHeYW1aU1qSTjN4jaVDJRN
+ hzY0YSiibE37P2w+3S+PDsFZhNwJXqcdzYt0iPQ5c03xdgmgOaQNqlbRgjEAKTCMIxHk2tuP3avt9P8A
+ Bn0z4+M2aHtu+em9m8q7r3WMXGARLvIlCtp7WAtohkUlJsXGzu8hfBnOCR1hQkjNtftRjqhq9D746ffH
+ T746ffHT746ffHT746fbHX/x/nPwZ9M+PjNmh7bvn6f+DPpnx8Zs0Pbd8/T/AMGfTPj4zZoe275+n/gz
+ 6Z8fGbND23fP0/8ABn0z4+M2aHtu+fp/4M+l+f8A1Nf5zuj3j+8P+/D3+fP/AHn/AOKf9+xdPoz6fRn0
+ +jPp9GfT6M+n0Z9Poz6fRn0+jPp9GfT6M+n0Z9Poz6fRn0+jPp9GfT6M+n0Z9Poz6fRn0+jPp9GfT6M+
+ n0Z9Poz6fRn0+jPp9GfT6M+n0Z9P/wBM/wD8M/8Ah/8Axnp//9k=
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+EZGkV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDc6NDcAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAAX8AAAAAAAAABIAAAAAQAAAEgAAAAB/9j/4gxYSUNDX1BST0ZJTEUAAQEAAAxI
+ TGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAA
+ AAAAAAAA9tYAAQAAAADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFla
+ AAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVk
+ AAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJD
+ AAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBI
+ ZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAA
+ AAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAA
+ AABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAA
+ AAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMg
+ NjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5
+ NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ ZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAA
+ AAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAA
+ AEwJVgBQAAAAVx/nbWVhcwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQg
+ Y3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQBy
+ AHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwEN
+ ARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHh
+ AekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMA
+ AwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRx
+ BH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3
+ BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRgha
+ CG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrc
+ CvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3D
+ Dd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RET
+ ETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTO
+ FPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6
+ GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2Z
+ HcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKv
+ It0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/
+ KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5M
+ LoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTY
+ NRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvo
+ PCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9
+ Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0ua
+ S+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRC
+ VI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114
+ XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9
+ Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGV
+ cfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyB
+ fOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gE
+ iGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQg
+ lIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDY
+ oUehtqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4t
+ rqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7wh
+ vJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3
+ yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx
+ 2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ
+ 6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX
+ +uf7d/wH/Jj9Kf26/kv+3P9t////7QAMQWRvYmVfQ00AAf/uAA5BZG9iZQBkgAAAAAH/2wCEAAwICAgJ
+ CAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwB
+ DQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM
+ DAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEBAQAAAAAAAAADAAECBAUGBwgJ
+ CgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUHBggFAwwzAQACEQMEIRIxBUFR
+ YRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNUZEXCo3Q2F9JV4mXys4TD03Xj
+ 80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3EQACAgECBAQDBAUGBwcGBTUB
+ AAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPElBhaisoMHJjXC0kSTVKMXZEVV
+ NnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdHV2d3h5ent8f/2gAMAwEAAhED
+ EQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ/wCOt/6t6EkpL9rzP+5N3/br
+ /wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6/
+ /wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDy
+ aX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6//wAm
+ l9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDyaJi5
+ WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW
+ 9CSUpJJJJSkkkklKSSSSUpJJIAkgASTwBqSkpSSRBBgggjkHQpJKUkkkkpSSSSSlJJJJKUi4n9Mxv+Oq
+ /wCrYhIuJ/TMb/jqv+rYkp//0dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpIakAc
+ kwB5lJFxf59vwd/1JSUqmqbgywEabtp0n/zFHbWxl4LBG5jpHbQ1/wDklJ387X8H/wDotI/zzP6j/wAt
+ SSmFtQsuaHGAGEmOTqB/FAvqFT4BkESJ58P++q1/hx/xZ/6pqBmfzjf6v8XJKQJJJJKUkkkkpSSSSSlI
+ uJ/TMb/jqv8Aq2ISLif0zG/46r/q2JKf/9LWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkk
+ kklKRMb+fb8Hf9SUNExv59vwd/1JSU2nfz1fwf8A98SP88z+o/8ALUpFoLmu7tBA/tR/5FLaNwd3AI+8
+ tP8A3xJTH/Dj/iz/ANU1CvqdZc0NgQySTwNXI+0b986wW/IkO/go/wCHP/Fj/qnJKadlbq3bXc8gjghR
+ Rsv+dH9QflegpKUkkkkpSSSSSlIuJ/TMb/jqv+rYhIuJ/TMb/jqv+rYkp//T1sv+mZP/AB1v/VvQkXL/
+ AKZk/wDHW/8AVvQklKSSSSUpJJJJSkTG/n2/B3/UlDRMb+fb8Hf9SUlN1JJJJSlHafVLu2wN+YLnfxUk
+ klNTL/nR/UH5XoKLlEG7QzDQD8Zcf4oSSlJJJJKUkkkkpSLif0zG/wCOq/6tiEi4n9Mxv+Oq/wCrYkp/
+ /9TWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKTtIa9riJDXB0fA7kySSm+x7Hjcwy
+ OJgjX+0pKpTkNqYWlpMkmQR4Af8AfVP7Yz9x33hJTYUXvZW0ufwO3c+TUH7Y39x33hDvubaGgNI2mdfg
+ kpG5xc4udqTymSSSUpJJJJSkkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//V1sv+mZP/AB1v/VvQ
+ kXL/AKZk/wDHW/8AVvQklKSSSSUpJJSZVdZ/N1vsggHY0u1P0W+0fnJKYpKf2fIFvoGmz1ufS2O3x47I
+ 3KIZYWOsaxxYww94B2tJ7Od9FqSlgCeApCtx8vipNpyTWLjXZ6H+l2u2R/Xjar1nT3nCxL8euy2zID3W
+ hoLg0NIa2Ng9qfGMTvbVz5csTUBE6cR3lpfC55rd8VEtI5BRZ5B0I0IOhBVjPxGY9GFZUXufl1l7wTPu
+ 9m1lbW/10ZxiBpaOXz5chIkI6C+oaSSndTkUkC6mxjnfQa9rgXeTNw9y1Luj11ehhim+zMyGtccqD6NZ
+ cfe0sb/o2t/O/kKNtuQkjZeJdiXPrsY8Na9zGWOYWtft/OZu/wDJIKSlJJJJKUi4n9Mxv+Oq/wCrYhIu
+ J/TMb/jqv+rYkp//1tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKWn0y22rpPVLKnmt49KH
+ tMESS32lZi1elCg9L6mMgvbSfS3OrEuGphwafpe5JTfwXvts6Lda42WlmQHWO1cQB+c7+yszF1+r/VBz
+ +mr0P9atGb1XDxsjAbjiy3HwQ8PscIc42CHOYz2/QQ35XTKOn5WHhutufkPZaHWtAb7XMf6X5rvos/cS
+ U3rczKsd+0+mv+0YorDL8F3+C01mhv8A1X/nylU8nKyMfonTPs1z6gW2E7DE7T7J/e5RKM/o+NlnqOOL
+ q7Swt+xNaG17iP8ASAbfT03Khl5Vd3TsPGbPq44s9TSGy87hsTgWGUCbN6kf962vrCAOrWwIljCfMxH/
+ AH1aeEAcnpBIktw7HN8jFLZ/zXLF6vmU5ue/Ipn03Na0bhBlszorVPWcei3p1ga94xaHU3iIPu9P3V6+
+ /wB1SV6UoQqRPc3/AM5jkWZlHQLB1Gx/2u+1tmKyx02s2bHOt/fq+i/+p/1xW87JyW9d6dW254Y+ukuY
+ HENJc63fub+du2rMzbOm/Zba8c25eXe4F2XkD3NaI/RNJ/q/u/vomb1Km3qWLmUtc5mMyprmuG0ksc9z
+ 4/svTWZD1W++zPyWWWPeyu54ra5xIbrHsafoqornUndPttdkYltr7LnufYyxm0NDtYa7+t/XVNJSkkkk
+ lKRcT+mY3/HVf9WxCRcT+mY3/HVf9WxJT//X1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUp
+ Sbbaxj62Pc2uyPUYDo6ONyikkpSSSSSlJJJJKUkkkkpSSSSSlJJJJKUkkkkpSLif0zG/46r/AKtiEi4n
+ 9Mxv+Oq/6tiSn//Q1sv+mZP/AB1v/VvQlZysXLOXkEY9xButIIqeQQXv1+gh/ZMz/uNd/wBtP/8AIJKR
+ JIv2TM/7jXf9tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJI
+ v2TM/wC413/bT/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRJIv2
+ TM/7jXf9tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM
+ /wC413/bT/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRIuJ/TMb/
+ AI6r/q2JfZMz/uNd/wBtP/8AIImLi5Yy8cnHuAF1RJNTwAA9mv0ElP8A/9n/7SHsUGhvdG9zaG9wIDMu
+ MAA4QklNBAQAAAAAAC8cAVoAAxslRxwBWgADGyVHHAFaAAMbJUccAVoAAxslRxwBWgADGyVHHAIAAAIA
+ AAA4QklNBCUAAAAAABBus3Le+f92w9DcIki/K33TOEJJTQQ6AAAAAACbAAAAEAAAAAEAAAAAAAtwcmlu
+ dE91dHB1dAAAAAQAAAAAUHN0U2Jvb2wBAAAAAEludGVlbnVtAAAAAEludGUAAAAAQ2xybQAAAA9wcmlu
+ dFNpeHRlZW5CaXRib29sAAAAAAtwcmludGVyTmFtZVRFWFQAAAATAEMAYQBuAG8AbgAgAE0AUAAxADQA
+ MAAgAHMAZQByAGkAZQBzAAAAOEJJTQQ7AAAAAAGyAAAAEAAAAAEAAAAAABJwcmludE91dHB1dE9wdGlv
+ bnMAAAASAAAAAENwdG5ib29sAAAAAABDbGJyYm9vbAAAAAAAUmdzTWJvb2wAAAAAAENybkNib29sAAAA
+ AABDbnRDYm9vbAAAAAAATGJsc2Jvb2wAAAAAAE5ndHZib29sAAAAAABFbWxEYm9vbAAAAAAASW50cmJv
+ b2wAAAAAAEJja2dPYmpjAAAAAQAAAAAAAFJHQkMAAAADAAAAAFJkICBkb3ViQG/gAAAAAAAAAAAAR3Ju
+ IGRvdWJAb+AAAAAAAAAAAABCbCAgZG91YkBv4AAAAAAAAAAAAEJyZFRVbnRGI1JsdAAAAAAAAAAAAAAA
+ AEJsZCBVbnRGI1JsdAAAAAAAAAAAAAAAAFJzbHRVbnRGI1B4bEBSAAAAAAAAAAAACnZlY3RvckRhdGFi
+ b29sAQAAAABQZ1BzZW51bQAAAABQZ1BzAAAAAFBnUEMAAAAATGVmdFVudEYjUmx0AAAAAAAAAAAAAAAA
+ VG9wIFVudEYjUmx0AAAAAAAAAAAAAAAAU2NsIFVudEYjUHJjQFkAAAAAAAA4QklNA+0AAAAAABAASAAA
+ AAEAAgBIAAAAAQACOEJJTQQmAAAAAAAOAAAAAAAAAAAAAD+AAAA4QklNA/IAAAAAAAoAAP///////wAA
+ OEJJTQQNAAAAAAAEAAAAeDhCSU0EGQAAAAAABAAAAB44QklNA/MAAAAAAAkAAAAAAAAAAAEAOEJJTScQ
+ AAAAAAAKAAEAAAAAAAAAAjhCSU0D9QAAAAAASAAvZmYAAQBsZmYABgAAAAAAAQAvZmYAAQChmZoABgAA
+ AAAAAQAyAAAAAQBaAAAABgAAAAAAAQA1AAAAAQAtAAAABgAAAAAAAThCSU0D+AAAAAAAcAAA////////
+ /////////////////////wPoAAAAAP////////////////////////////8D6AAAAAD/////////////
+ ////////////////A+gAAAAA/////////////////////////////wPoAAA4QklNBAAAAAAAAAIAAzhC
+ SU0EAgAAAAAADAAAAAAAAAAAAAAAADhCSU0EMAAAAAAABgEBAQEBAThCSU0ELQAAAAAABgABAAAADThC
+ SU0ECAAAAAAAGgAAAAEAAAJAAAACQAAAAAIAAA+gAQAAD7AAOEJJTQQeAAAAAAAEAAAAADhCSU0EGgAA
+ AAADRwAAAAYAAAAAAAAAAAAAAPoAAAD6AAAACQBwAHUAcwBoAF8AbABlAGYAdAAAAAEAAAAAAAAAAAAA
+ AAAAAAAAAAAAAQAAAAAAAAAAAAAA+gAAAPoAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAA
+ AAAQAAAAAQAAAAAAAG51bGwAAAACAAAABmJvdW5kc09iamMAAAABAAAAAAAAUmN0MQAAAAQAAAAAVG9w
+ IGxvbmcAAAAAAAAAAExlZnRsb25nAAAAAAAAAABCdG9tbG9uZwAAAPoAAAAAUmdodGxvbmcAAAD6AAAA
+ BnNsaWNlc1ZsTHMAAAABT2JqYwAAAAEAAAAAAAVzbGljZQAAABIAAAAHc2xpY2VJRGxvbmcAAAAAAAAA
+ B2dyb3VwSURsb25nAAAAAAAAAAZvcmlnaW5lbnVtAAAADEVTbGljZU9yaWdpbgAAAA1hdXRvR2VuZXJh
+ dGVkAAAAAFR5cGVlbnVtAAAACkVTbGljZVR5cGUAAAAASW1nIAAAAAZib3VuZHNPYmpjAAAAAQAAAAAA
+ AFJjdDEAAAAEAAAAAFRvcCBsb25nAAAAAAAAAABMZWZ0bG9uZwAAAAAAAAAAQnRvbWxvbmcAAAD6AAAA
+ AFJnaHRsb25nAAAA+gAAAAN1cmxURVhUAAAAAQAAAAAAAG51bGxURVhUAAAAAQAAAAAAAE1zZ2VURVhU
+ AAAAAQAAAAAABmFsdFRhZ1RFWFQAAAABAAAAAAAOY2VsbFRleHRJc0hUTUxib29sAQAAAAhjZWxsVGV4
+ dFRFWFQAAAABAAAAAAAJaG9yekFsaWduZW51bQAAAA9FU2xpY2VIb3J6QWxpZ24AAAAHZGVmYXVsdAAA
+ AAl2ZXJ0QWxpZ25lbnVtAAAAD0VTbGljZVZlcnRBbGlnbgAAAAdkZWZhdWx0AAAAC2JnQ29sb3JUeXBl
+ ZW51bQAAABFFU2xpY2VCR0NvbG9yVHlwZQAAAABOb25lAAAACXRvcE91dHNldGxvbmcAAAAAAAAACmxl
+ ZnRPdXRzZXRsb25nAAAAAAAAAAxib3R0b21PdXRzZXRsb25nAAAAAAAAAAtyaWdodE91dHNldGxvbmcA
+ AAAAADhCSU0EKAAAAAAADAAAAAI/8AAAAAAAADhCSU0EFAAAAAAABAAAAB04QklNBAwAAAAAGAwAAAAB
+ AAAAoAAAAKAAAAHgAAEsAAAAF/AAGAAB/9j/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRy
+ UkdCIFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAAAA9tYAAQAA
+ AADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFjcHJ0
+ AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFlaAAACGAAAABRnWFla
+ AAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVkAAADTAAAAIZ2aWV3
+ AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJDAAAEPAAACAxnVFJD
+ AAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBIZXdsZXR0LVBhY2th
+ cmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAABJzUkdCIElF
+ QzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ WFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQ
+ WFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAAAAAAFklFQyBodHRw
+ Oi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERl
+ ZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1
+ bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAs
+ UmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAALFJlZmVy
+ ZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAHZpZXcAAAAAABOk/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQAAAAVx/n
+ bWVhcwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQgY3VydgAAAAAAAAQA
+ AAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQByAHcAfACBAIYAiwCQ
+ AJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEy
+ ATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMCDAIU
+ Ah0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsDFgMhAy0DOAND
+ A08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRxBH4EjASaBKgEtgTE
+ BNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZqBnsGjAad
+ Bq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRghaCG4IggiWCKoIvgjS
+ COcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrcCvMLCwsiCzkLUQtp
+ C4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3DDd4N+A4TDi4OSQ5k
+ Dn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RETETERTxFtEYwRqhHJ
+ EegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWb
+ Fb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlrGZEZtxnd
+ GgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4WHkAeah6U
+ Hr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPC
+ I/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClr
+ KZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIuty7uLyQvWi+R
+ L8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTYNRM1TTWHNcI1/TY3
+ NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1h
+ PaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUS
+ RVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JMKkxyTLpNAk1K
+ TZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRCVI9U21UoVXVVwlYP
+ VlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1fD19h
+ X7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/aJZo7GlD
+ aZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfByS3KmcwFzXXO4
+ dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyBfOF9QX2hfgF+Yn7C
+ fyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gEiGmIzokziZmJ/opk
+ isqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQglIqU9JVflcmWNJaf
+ lwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDYoUehtqImopajBqN2
+ o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4trqGvFq+LsACwdbDq
+ sWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/
+ v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21
+ zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA3AXcit0Q
+ 3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ6lvq5etw6/vshu0R
+ 7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26
+ /kv+3P9t////7QAMQWRvYmVfQ00AAf/uAA5BZG9iZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUP
+ DAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQO
+ Dg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAA
+ oAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEBAQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEB
+ AAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUHBggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFC
+ IyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNUZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0
+ pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFx
+ IhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPElBhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePz
+ RpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdHV2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBk
+ XAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ/wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8A
+ br//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br
+ /wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//
+ ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDy
+ aEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APyaEkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8
+ ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklK
+ SSSSUpJJIAkgASTwBqSkpSSRBBgggjkHQpJKUkkkkpSSSSSlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jq
+ v+rYkp//0dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpIakAckwB5lJFxf59vwd/1
+ JSUqmqbgywEabtp0n/zFHbWxl4LBG5jpHbQ1/wDklJ387X8H/wDotI/zzP6j/wAtSSmFtQsuaHGAGEmO
+ TqB/FAvqFT4BkESJ58P++q1/hx/xZ/6pqBmfzjf6v8XJKQJJJJKUkkkkpSSSSSlIuJ/TMb/jqv8Aq2IS
+ Lif0zG/46r/q2JKf/9LWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKRMb+fb8Hf9SU
+ NExv59vwd/1JSU2nfz1fwf8A98SP88z+o/8ALUpFoLmu7tBA/tR/5FLaNwd3AI+8tP8A3xJTH/Dj/iz/
+ ANU1CvqdZc0NgQySTwNXI+0b986wW/IkO/go/wCHP/Fj/qnJKadlbq3bXc8gjghRRsv+dH9QflegpKUk
+ kkkpSSSSSlIuJ/TMb/jqv+rYhIuJ/TMb/jqv+rYkp//T1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQk
+ lKSSSSUpJJJJSkTG/n2/B3/UlDRMb+fb8Hf9SUlN1JJJJSlHafVLu2wN+YLnfxUkklNTL/nR/UH5XoKL
+ lEG7QzDQD8Zcf4oSSlJJJJKUkkkkpSLif0zG/wCOq/6tiEi4n9Mxv+Oq/wCrYkp//9TWy/6Zk/8AHW/9
+ W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKTtIa9riJDXB0fA7kySSm+x7HjcwyOJgjX+0pKpTkNqYW
+ lpMkmQR4Af8AfVP7Yz9x33hJTYUXvZW0ufwO3c+TUH7Y39x33hDvubaGgNI2mdfgkpG5xc4udqTymSSS
+ UpJJJJSkkkklKRcT+mY3/HVf9WxCRcT+mY3/AB1X/VsSU//V1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8A
+ VvQklKSSSSUpJJSZVdZ/N1vsggHY0u1P0W+0fnJKYpKf2fIFvoGmz1ufS2O3x47I3KIZYWOsaxxYww94
+ B2tJ7Od9FqSlgCeApCtx8vipNpyTWLjXZ6H+l2u2R/Xjar1nT3nCxL8euy2zID3WhoLg0NIa2Ng9qfGM
+ TvbVz5csTUBE6cR3lpfC55rd8VEtI5BRZ5B0I0IOhBVjPxGY9GFZUXufl1l7wTPu9m1lbW/10ZxiBpaO
+ Xz5chIkI6C+oaSSndTkUkC6mxjnfQa9rgXeTNw9y1Luj11ehhim+zMyGtccqD6NZcfe0sb/o2t/O/kKN
+ tuQkjZeJdiXPrsY8Na9zGWOYWtft/OZu/wDJIKSlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jqv+rYkp//
+ 1tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKWn0y22rpPVLKnmt49KHtMESS32lZi1elCg9
+ L6mMgvbSfS3OrEuGphwafpe5JTfwXvts6Lda42WlmQHWO1cQB+c7+yszF1+r/VBz+mr0P9atGb1XDxsj
+ Abjiy3HwQ8PscIc42CHOYz2/QQ35XTKOn5WHhutufkPZaHWtAb7XMf6X5rvos/cSU3rczKsd+0+mv+0Y
+ orDL8F3+C01mhv8A1X/nylU8nKyMfonTPs1z6gW2E7DE7T7J/e5RKM/o+NlnqOOLq7Swt+xNaG17iP8A
+ SAbfT03Khl5Vd3TsPGbPq44s9TSGy87hsTgWGUCbN6kf962vrCAOrWwIljCfMxH/AH1aeEAcnpBIktw7
+ HN8jFLZ/zXLF6vmU5ue/Ipn03Na0bhBlszorVPWcei3p1ga94xaHU3iIPu9P3V6+/wB1SV6UoQqRPc3/
+ AM5jkWZlHQLB1Gx/2u+1tmKyx02s2bHOt/fq+i/+p/1xW87JyW9d6dW254Y+ukuYHENJc63fub+du2rM
+ zbOm/Zba8c25eXe4F2XkD3NaI/RNJ/q/u/vomb1Km3qWLmUtc5mMyprmuG0ksc9z4/svTWZD1W++zPyW
+ WWPeyu54ra5xIbrHsafoqornUndPttdkYltr7LnufYyxm0NDtYa7+t/XVNJSkkkklKRcT+mY3/HVf9Wx
+ CRcT+mY3/HVf9WxJT//X1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpSbbaxj62Pc2uyPUY
+ Do6ONyikkpSSSSSlJJJJKUkkkkpSSSSSlJJJJKUkkkkpSLif0zG/46r/AKtiEi4n9Mxv+Oq/6tiSn//Q
+ 1sv+mZP/AB1v/VvQlZysXLOXkEY9xButIIqeQQXv1+gh/ZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A
+ /IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8A
+ yCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A/IJf
+ ZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8AyCX2
+ TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRIuJ/TMb/AI6r/q2JfZMz/uNd
+ /wBtP/8AIImLi5Yy8cnHuAF1RJNTwAA9mv0ElP8A/9k4QklNBCEAAAAAAFUAAAABAQAAAA8AQQBkAG8A
+ YgBlACAAUABoAG8AdABvAHMAaABvAHAAAAATAEEAZABvAGIAZQAgAFAAaABvAHQAbwBzAGgAbwBwACAA
+ QwBTADUAAAABADhCSU0PoAAAAAAA+G1hbmlJUkZSAAAA7DhCSU1BbkRzAAAAzAAAABAAAAABAAAAAAAA
+ bnVsbAAAAAMAAAAAQUZTdGxvbmcAAAAAAAAAAEZySW5WbExzAAAAAU9iamMAAAABAAAAAAAAbnVsbAAA
+ AAEAAAAARnJJRGxvbmcDIQffAAAAAEZTdHNWbExzAAAAAU9iamMAAAABAAAAAAAAbnVsbAAAAAQAAAAA
+ RnNJRGxvbmcAAAAAAAAAAEFGcm1sb25nAAAAAAAAAABGc0ZyVmxMcwAAAAFsb25nAyEH3wAAAABMQ250
+ bG9uZwAAAAAAADhCSU1Sb2xsAAAACAAAAAAAAAAAOEJJTQ+hAAAAAAAcbWZyaQAAAAIAAAAQAAAAAQAA
+ AAAAAAABAAAAADhCSU0EBgAAAAAABwAIAQEAAQEA/+Eklmh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEu
+ MC8APD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4NCjx4
+ OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUu
+ MC1jMDYwIDYxLjEzNDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4NCgk8cmRmOlJERiB4
+ bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPg0KCQk8
+ cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20v
+ eGFwLzEuMC8iIHhtbG5zOnBob3Rvc2hvcD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90b3Nob3AvMS4w
+ LyIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIiB4bWxuczp4bXBNTT0i
+ aHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RFdnQ9Imh0dHA6Ly9ucy5hZG9i
+ ZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZUV2ZW50IyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5h
+ ZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUg
+ UGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHhtcDpDcmVhdGVEYXRlPSIyMDEyLTAzLTIxVDEyOjM3OjAx
+ KzAxOjAwIiB4bXA6TWV0YWRhdGFEYXRlPSIyMDEyLTAzLTIxVDE4OjQ3OjQ3KzAxOjAwIiB4bXA6TW9k
+ aWZ5RGF0ZT0iMjAxMi0wMy0yMVQxODo0Nzo0NyswMTowMCIgcGhvdG9zaG9wOkNvbG9yTW9kZT0iMyIg
+ cGhvdG9zaG9wOklDQ1Byb2ZpbGU9InNSR0IgSUVDNjE5NjYtMi4xIiBkYzpmb3JtYXQ9ImltYWdlL2pw
+ ZWciIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6RjExNzdEQ0MwRTIwNjgxMTk0NTc5QTMzRkIzNTY0
+ NzkiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4
+ MTEiIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERG
+ MTVBNUFFRTgxMSI+DQoJCQk8cGhvdG9zaG9wOlRleHRMYXllcnM+DQoJCQkJPHJkZjpCYWc+DQoJCQkJ
+ CTxyZGY6bGkgcGhvdG9zaG9wOkxheWVyTmFtZT0icHVzaCBsZWZ0IiBwaG90b3Nob3A6TGF5ZXJUZXh0
+ PSJwdXNoIGxlZnQiLz4NCgkJCQk8L3JkZjpCYWc+DQoJCQk8L3Bob3Rvc2hvcDpUZXh0TGF5ZXJzPg0K
+ CQkJPHhtcE1NOkhpc3Rvcnk+DQoJCQkJPHJkZjpTZXE+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJjcmVhdGVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYx
+ NUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEyOjM3OjAxKzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDI4MDExNzQwNzIwNjgx
+ MUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTI6Mzc6MzkrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDowMzgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxMjo1NzoxMyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjA0ODAxMTc0MDcyMDY4MTFCQTlEREYx
+ NUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjAwOjA4KzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIv
+ Pg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5p
+ aWQ6MDU4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFU
+ MTM6MDI6NDMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFj
+ aW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZl
+ ZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNjgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgx
+ MSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowNzo1NiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2Vu
+ dD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJ
+ PHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjA3ODAx
+ MTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA4OjEx
+ KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIg
+ c3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0
+ Omluc3RhbmNlSUQ9InhtcC5paWQ6MDg4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0
+ OndoZW49IjIwMTItMDMtMjFUMTM6MDg6MTgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2Jl
+ IFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkg
+ c3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowQTgwMTE3NDA3MjA2
+ ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowOTozOSswMTowMCIg
+ c3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNo
+ YW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5j
+ ZUlEPSJ4bXAuaWlkOjIyMjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIy
+ MDEyLTAzLTIxVDEzOjA5OjQ5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3No
+ b3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFj
+ dGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjMyM0RFMEEwQzIwNjgxMUJBOURE
+ RjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MTArMDE6MDAiIHN0RXZ0OnNvZnR3
+ YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+
+ DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlp
+ ZDoyNDIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQx
+ MzoxMDoyOCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNp
+ bnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVk
+ IiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI1MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODEx
+ IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEyOjQzKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50
+ PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8
+ cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjYyM0RF
+ MEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MTM6MDYr
+ MDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBz
+ dEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6
+ aW5zdGFuY2VJRD0ieG1wLmlpZDoyNzIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6
+ d2hlbj0iMjAxMi0wMy0yMVQxMzoxODo0MCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUg
+ UGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBz
+ dEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI4MjNERTBBMEMyMDY4
+ MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjE0OjA1KzAxOjAwIiBz
+ dEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hh
+ bmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNl
+ SUQ9InhtcC5paWQ6Rjc3RjExNzQwNzIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIw
+ MTItMDMtMjFUMTc6NTQrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGQTdGMTE3NDA3MjA2ODExOTQ1NzlBMzNG
+ QjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1NTo1MCswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OkZCN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3
+ OjU2OjA1KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkM3RjExNzQwNzIwNjgxMTk0NTc5QTMzRkIzNTY0Nzki
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTY6NTIrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGRDdGMTE3
+ NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1NzowOSsw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDpp
+ bnN0YW5jZUlEPSJ4bXAuaWlkOkZFN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3
+ aGVuPSIyMDEyLTAzLTIxVDE3OjU3OjA5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDA4MDExNzQwNzIwNjgx
+ MTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTg6MTQrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDo1QTlGRDQyMTA5MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxODoxMzo0MyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjQwMzY2QjNBMEEyMDY4MTE5NDU3OUEz
+ M0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjEzOjUyKzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIv
+ Pg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5p
+ aWQ6REE1MzFEODQwRTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFU
+ MTg6NDY6MjQrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFj
+ aW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZl
+ ZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGMDE3N0RDQzBFMjA2ODExOTQ1NzlBMzNGQjM1NjQ3
+ OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODo0Nzo0NyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2Vu
+ dD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJ
+ PHJkZjpsaSBzdEV2dDphY3Rpb249ImNvbnZlcnRlZCIgc3RFdnQ6cGFyYW1ldGVycz0iZnJvbSBhcHBs
+ aWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRvIGltYWdlL2pwZWciLz4NCgkJCQkJPHJkZjpsaSBz
+ dEV2dDphY3Rpb249ImRlcml2ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImNvbnZlcnRlZCBmcm9tIGFwcGxp
+ Y2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8gaW1hZ2UvanBlZyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RjExNzdEQ0MwRTIwNjgx
+ MTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6NDc6NDcrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJPC9yZGY6U2VxPg0KCQkJPC94bXBNTTpIaXN0b3J5Pg0KCQkJPHhtcE1NOkRl
+ cml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6RjAxNzdEQ0MwRTIwNjgxMTk0NTc5QTMz
+ RkIzNTY0NzkiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1
+ QTVBRUU4MTEiIHN0UmVmOm9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODEx
+ QkE5RERGMTVBNUFFRTgxMSIvPg0KCQk8L3JkZjpEZXNjcmlwdGlvbj4NCgk8L3JkZjpSREY+DQo8L3g6
+ eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAK
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgIDw/eHBhY2tldCBlbmQ9J3cnPz7/4gxYSUNDX1BST0ZJTEUAAQEAAAxI
+ TGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkABgAxAABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAA
+ AAAAAQAA9tYAAQAAAADTLUhQICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAAAGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFla
+ AAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAAABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVk
+ AAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAAABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJD
+ AAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAACAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBI
+ ZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAAAAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAA
+ AAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAABFsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAA
+ AABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAAGNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAA
+ AAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMg
+ NjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5
+ NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFjZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ ZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcgQ29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAA
+ AAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk/gAUXy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAA
+ AEwJVgBQAAAAVx/nbWVhcwAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQg
+ Y3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAoAC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQBy
+ AHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwEN
+ ARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFuAXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHh
+ AekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJnAnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMA
+ AwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOuA7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRx
+ BH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJBVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3
+ BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRgha
+ CG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmPCaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrc
+ CvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxDDFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3D
+ Dd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9eD3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RET
+ ETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLjEwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTO
+ FPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbWFvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6
+ GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2Z
+ HcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAVIEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKv
+ It0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVoJZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/
+ KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5M
+ LoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGCMbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTY
+ NRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQOIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvo
+ PCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+iP+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9
+ Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0ua
+ S+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/dUCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRC
+ VI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjLWRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114
+ XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJYpxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9
+ Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xXbK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGV
+ cfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyB
+ fOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIwgpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gE
+ iGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQg
+ lIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/JpomtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDY
+ oUehtqImopajBqN2o+akVqTHpTilqaYapoum/adup+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4t
+ rqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUTtYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7wh
+ vJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NYw9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3
+ yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx
+ 2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ
+ 6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX
+ +uf7d/wH/Jj9Kf26/kv+3P9t////2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+ AQEBAQEBAQECAgICAgICAgICAgMDAwMDAwMDAwP/2wBDAQEBAQEBAQEBAQECAgECAgMDAwMDAwMDAwMD
+ AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwP/wgARCAD6APoDAREAAhEBAxEB/8QA
+ HQABAAMBAQEBAQEAAAAAAAAAAAcICQYFBAMBAv/EAC0QAAADBwMFAAEEAwAAAAAAAAYHCAABAgMTBAUw
+ GDhAERIUCSBwkBU3EDEX/8QAHAEBAAEFAQEAAAAAAAAAAAAAAAUBAgQGBwMI/8QAWBEAAAQDBAQLBgIE
+ CAgPAAAAAgMEBQEUBgATFQcREhYmMEVlthc3R3cIGGghMdWXSYlAQVGhIjaRMiMkNLV2txDwcbFiJQk5
+ coIzY2Q1VXVWZqZnOEiI/8QAPBIAAgECBAIHBQQJBQAAAAAAAQIDABEhMRIEQQVAUWGRoSIGcYGxYhNw
+ wTJCEJDRcrIjsxQH8OGSomP/2gAMAwEAAhADEAAAANhyJgAAAAAAAAAAAAAAaymTRDIAAAAAAAAAAAAA
+ ANmDM0hkAAAAAAAAAAAAAAGzBmaQyAAAAAAAAAAAAAADZgzNIZAAAAAAAAAAAAAABswZmkMgAAAAAAAA
+ AAAAAA2YMzSGQAAAAAdMe0T+VzPGPFAAAAAANmDM0hkAAAAAlk9o6Y7M4wFZgAAAAADZgzNIZAAAAALm
+ HGA7M4wFZgAAAAADZgzNIZAAAAALmHGA7M4wFZgAAAAADZgzNIZAAAAALmHGA7M4wHxEGnigAAAAGzBm
+ aQyAAAAAXMPGB7J4x4p2ZWY4wAAAAA2YMzSGQAAAAC5gABxh2ZWY4wAAAAA2YMzSGQAAAAC5gAB4x7JW
+ Y4wAAAAA2YMzSGQAAAAC5gAABWY4wAAAAA2YMzSGQAAAAC2Z7IAAKgHxAAAAAGzBmaQyAAAAATMTMAAR
+ MQYAAAAADZgzNIZAAAAABcwAApmAAAAAAbMGZpDIAAAAAAAAAAAAAANmDM0hkAAAAAA/XJhfulue/hib
+ B8kZvP8AKXgAAAAAbMGZpDIAAAACn1SOmejO8slno/xZy2TBj1NT+gox0r6e+GH6R0XlndsRIAAAAbMG
+ ZpDIAABLpPJDR4h+JYif5Jd6V0Gok3y2oUvzvV3SPqLNfUforoqX6fnmlESlYAAANmDM0hkAAA1lObLn
+ FIifiCto4VP/AJZ3A+sfndN8w0rg+qftEdC/3H7h8BHhR4hMAAAGzBmaQyAAAaykOmipRsiDN1m9ftG/
+ Nd5QT7RtIczXNKI/b5gxpuqODs8gqxmUaIyAAABswZmkMgAAGsp+hUEtdW2teTB2Gt9q6+mJylbIVvxr
+ HeeX1FPTpMeXiyzJi8tKZ7gAAA2YMzSGQAACWSLT8Ap/a2AAAfxVS8AAAADZgzNIZAAAAAAAAAAAAAAB
+ swZmkMgAAAAAAAAAAAAAA2YMzSGQAAAAAAAAAAAAAAbMGZpDIAAAAAAAAAAAAAANmDM0hkAAAAAAAAAA
+ AAAAGzB2ZxgAAAAAAAAAAAAAALmH/9oACAECAAEFAP2bpFnd3L4AvnpkNxhMtas9z4X9Vb3GNlNZ56zl
+ zH30i3dWaswiy8FhMn5LEz2mxSYoupDsVpLv89cQQZqSJMbPmewwp73F49z4X9U60s72yyT3TMhnIZHr
+ W9y99vlpnnf5V0Lr/qbN8qCOdD6kdxOqXWSm+ciTP7Sr2Z5XN06KdePd2f07nd3xOhig8e74nuijmROm
+ Qum9nRvdHFM7RxRw9n9P/pvJ7eT28nt5Pbye3k9vJ7Pe9/6m/wD/2gAIAQMAAQUA/ZuygjD+Ehuj3Kez
+ m4gzy9zr5cyXOg6l/ftlsONL94iKcSXtnLC2Vy0X8c38cxNF3ciy0xYKMDFPsJWRlSupOWSIr0JlPiLi
+ 5LPJEqNMXZ/xD2IZ0GJDkuZBNl9VGIhIGBMCIZloECsnZP8AnMxhIIcsXtl64TAUU6II9SJJd/dWuMmu
+ EFth8a6ywYKsHWuVyGKdHfhiydIwuBjlYwOQxOih6eKJ0MMqOfKuKtOGRBHIt7KRFZTZlg6ZMtZcVrJt
+ PO2lW810yHp3udE6lA1KBqUDUoGpQNSgalA0MEML/wBTP//aAAgBAQABBQA/D8PXDHruNUK241QrbjVC
+ tuNUK241QrbjVCtuNUK241QrbjVCtuNUK241QrbjVCtuNUK241QrbjVCtuNUK241QrbjVCtuNUK241Qr
+ bjVCtuNUK241QrbjVCtuNUK241QrbjVCtuNUK241QrbjVCt/0cw2UbyF69RvIXr1G8hevUbyF69RvIXr
+ 1G8hdQJBLNDTNZsthJhcKCwXItJGbCt1LEuTDghwtrrKN5C6YeJoXCCQT4byLhcIsHRLwNBquwMwfsmG
+ IsHRLzWUbyF0w0Gq7AzB+yYYiwdEvA0Gq7AzB+yYYiwdEvNZRvIXTDQarsDMH7JhiLB0S8DQarsDMH7J
+ hiLB0S81lG8hdMNBquwMwfsmGIsHRLwNBquwMwfsmGIsHRLwKE3aXsjPYO6D19qKN5C6YaDVdgmCLqIQ
+ uBF0IA8Gg1XYJgi6iEIiwdEvA0Gq7Dy29TOaijeQumGg1XYNBquwaDVdg0Gq7BoNV2EWDol4Gg1XYeW3
+ qZzUUbyF0w0Gq7BoNV2DQarsGg1XYNBquzgRdCAPBoNV2Hlt6mc1FG8hdMNBquwaDVdg0Gq7BoNV2DQa
+ rsGg1XYNBquw8tvUzmoo3kLpl5bWonsQ0Gq7BoNV2DQarsGg1XYNBquwaDVdr+/n5KfqKN5C6ZZiMKWU
+ sNBquwaDVdg0Gq7BoNV2DQarsMslhcQG9VRvIXUDQarsGg1XYNBquwaDVdg0Gq+uo3kL16jeQurLkT5z
+ Q4fJROm4+9ks9z3P1lG8hdOVNtYGkZGRBEHwONBPjfJ7eT2xoNG4qlTLqymNG+B7wkDBaPc2ZZEm4Tsj
+ SUbyF/MpiMMs8Lid89lUyA2VKczZOiEnyVME9hMFyYMsbGEJ0HKRLzCIgwmVFaRhih1SQKD1ZzIee+am
+ AnE3HGfM44EjnwR2KQGUg6Aqc07EKeJmG0pBIhxlneaKjeQv5/Jv+w0RmwZojWQnG0trI+vlTyFQ+Jw5
+ IPgFHYfCJDMR6JbqySl80jDHQgOg2Le2xxpoTje9MVtm8uB/lklnLifLoVRhmMu9Dfy6EwjzB/HoLBVf
+ mloqN5C/n8m/7DQVLmOWknlz41BfKmGJ6g7gizgHA/S2c9mtQOpyDTwSlb5aR+SgTnmdjhQbF3S8TuYK
+ jB/OY1DOPlWZVIw4LfKnkKdbnwnJoqN5C/n8m/7DnfR0KhK8I5W5hkybUv6UhwJ5kmlijQmTMyn0XDgd
+ whUq0zBZE6mFRV4moejESxi4XEYqu/JIsk4rSzBIhI7V2TRwWxPKqyBRkkRB2CpP5inusoqjiBGio3kL
+ +ZTHkaRG5G5uJ15cf47vbu9u727vbu9u727vbu/VUbyF69RvIXr1G8hevUbyF69RvIXrzH/sPr//2gAI
+ AQICBj8A/U3W2+2kkPyqT8BWpeXm3ayKe4sDRM3L5Qo4gah3rcUQwIPSscq/ncuaU9spA7lQHxqOPa+n
+ YfqsQBjc3JwxZSfGoI55Y0lewC3AuThZRgTjhl+mFJuWRTwupsWtcEHEWKnssfb1Ub8iVG61lYeFiPCr
+ wxsq9RYN46V6Usu5lCuB5AcixwzyFhlfia5XO7WjTQSeoCS5yoRLMQxOFwQD7/22rOtii/iK2HvaipFi
+ Ol7dIJArpxtjfiGxHH/auXJJ5lsoN+Pmx76iZIlDhwLgAYWOGHsFQFmx0L8BXL2vkR/EK3OkYEg94BPj
+ 0rVKM8BhcdVLPtmKgm1v9cK2cv7p8b0g+cfA1EL/AJR8K2zdRHxqQLmbeCirHpFqVeIoa5CQKR75UFJ4
+ 0BfIUrFsRQcNZqve/wBtv//aAAgBAwIGPwD9TcX5zzzabVf/AFmjj/iYUYZfV8Zf5IdzKv8AyjhdfGlT
+ lvq/YtK2StIInONsEl0Ocezq6xSyRSK0ZFwQQQR2EYHpR0nGiOX+s4NjH8mxWRuP5pp3XiPyDL21vN5z
+ /wDzLzP+wijZ5LR/TjCKt2JSKZFsAMtPia5pveVcv3W62EH1HeX6bNojUFy8rDUqHQNRu3sJrKsq5luO
+ W+uOYcq5htZVDLCHCsjr5WDrLHc3DhlsbDSb+alA/wArTbiIfln2UMl/a/1Fk7Px1o5lvIZpcPNHE0Q7
+ bqZZezIjj14dJl2HI9i8m2ka+5ZSNSxJZrBb62DNYsVBsqm+BNeveV7WLVutyNxGi3A1PJtQii7EAXJA
+ uSAOJAp99LyxZIlW7CN1dlAFySoxNuOjV3Y1+A16r3UwIijlDn2JESfAUksbBo2AIIyIOII6Xzjcc12j
+ zQbg4RmQiMKD5GjOlhguBsBe/msRh6y3GzBhlLTyJpzQ/Rutv3Ta3srfw7rfTSbdtqzFXdmGsSRgN5ic
+ bMwvxvjXNFihAjG5lAAGAGtrAdgFer4tNtaP/RYVyYTsTIqOuPUkjqo9ygD3dKMHL2sUIdyG0sLYi2WO
+ F8OypeVc7gWUquoPaxzAv2MLjEZjAjO/qTZAgi8y36/5em/vtW4ktnt2H/dD91b59OcznvY1zyK341b+
+ mRWyaUH6aFsvmlb9tBlOBHSCx4VNMBdXOIPh3U/9ts0jduIA+4C/vrcbcR3El7m/WLU0qR3JW3iD91SS
+ FMWYnvN6nhWK6vnj2WpoGiDwHgfHrw7K0iPQBw7OkWOVZVlWVZVlWVZVcD7Tf//aAAgBAQEGPwDOloaM
+ 6c2Wppas2cxm1ra23MasELc2tyGsHlKiQIESV5KTI0SNMUEsoosIQFgDAIYQhCELdfGc3zQrf45br4zm
+ +aFb/HLdfGc3zQrf45br4zm+aFb/ABy3XxnN80K3+OW6+M5vmhW/xy3XxnN80K3+OW6+M5vmhW/xy3Xx
+ nN80K3+OW6+M5vmhW/xy3XxnN80K3+OW6+M5vmhW/wAct18ZzfNCt/jluvjOb5oVv8ct18ZzfNCt/jlu
+ vjOb5oVv8ct18ZzfNCt/jluvjOb5oVv8ct18ZzfNCt/jluvjOb5oVv8AHLdfGc3zQrf45br4zm+aFb/H
+ LdfGc3zQrf45br4zm+aFb/HLdfGc3zQrf45br4zm+aFb/HLdfGc3zQrf45br4zm+aFb/ABy3XxnN80K3
+ +OW6+M5vmhW/xy37+Vn/ALprpH/eh86w/wDx5/Tv3z5U/p3/ADts+O+bNDnu+fj/ALM9s+O+bNDnu+fj
+ /sz2z475s0Oe75+P+zPbPjvmzQ57vn4/7M9s+O+bNDnu+fj/ALM9s+O+bNDnu+cKjZGRGtUGKFrOlWLE
+ rO/PZDOQ9vzTTKNyckdMtL49iRCe3xImCFMkUKD1Cgoggo080ooaZ/ilWuDeaiTOS05LTVbIyGduVsOX
+ L4QvcnB9pZnaZIwzNFrRhNTqDwDUHFGBiJGua1S+l06el1qwtYtpBeIS+kHGoD1B9QOPhQdFRZap08KF
+ WqVKJSpq0YUyYI3JOFO5ATpwLyF5ZdastNsDS9LHJ7ZaAObWcCZ4cHh0eKvpSnXYtO2I1VL0y5K8Wcnj
+ ShJJRnlDKNKClVuRMSl6pCueGF6aUTnqYarc2tcgSuF4zsdQlyKhUQUUr12Cpm1dC7iLSjcEx3/JnlCH
+ wv2Z7Z8d82aHPd84RtNiQtaDHVagSpUq+jMzlx4yHVxytRNLkWKmqEf0ytE6ps3WtYmCnMOUHJxACEqJ
+ 69nIcj250ppacpGiy3cim9fSp7ueJuqLM7Ks5oXltqjJ/OAyCKoGl7IljYNhYHBOuASCLkBUFkd3FZs9
+ calGMyme2OlLu8Y/CobN4r5dGC6vcf15jHk95iWvPqMSmK0pTdSYmOj7s+nJmc8o3pGqGentoeVJrFON
+ MU34Aj2em9NGZBKZHY7ENOLvmRpU3hXl0q7TjeK6kxgMcUnNSfqacl6icVmz1xqUYzKZ7Y6Uu7xj8Khs
+ 3ivl0YLq9x/XmMeT3mJa8+oxKYrThfsz2z475s0Oe75wlKbqTEx0fdn05MznlG9I1Qz09tDypNYpxpim
+ /AEez03pozIJTI7HYhpxd8yNKm8K8ulXacbxXUmMBjik5qT9TTkvUTis2euNSjGZTPbHSl3eMfhUNm8V
+ 8ujBdXuP68xjye8xLXn1GJTFaUpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8AR7PTemjMglMjsdiGn
+ F3zI0qbwry6VdpxvFdSYwGOKTmpP1NOS9ROKzZ641KMZlM9sdKXd4x+FQ2bxXy6MF1e4/rzGPJ7zEtef
+ UYlMVpwv2Z7Z8d82aHPd84SlN1JiY6Puz6cmZzyjekaoZ6e2h5UmsU40xTfgCPZ6b00ZkEpkdjsQ04u+
+ ZGlTeFeXSrtON4rqTGAxxSc1J+ppyXqJxWbPXGpRjMpntjpS7vGPwqGzeK+XRgur3H9eYx5PeYlrz6jE
+ pitKU3UmJjo+7PpyZnPKN6Rqhnp7aHlSaxTjTFN+AI9npvTRmQSmR2OxDTi75kaVN4V5dKu043iupMYD
+ HFJzUn6mnJeonFZs9calGMyme2OlLu8Y/CobN4r5dGC6vcf15jHk95iWvPqMSmK04X7M9s+O+bNDnu+c
+ JSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvwBHs9N6aMyCUyOx2IacXfMjSpvCvLpV2nG8V1JjAY4p
+ Oak/U05L1E4rNnrjUoxmUz2x0pd3jH4VDZvFfLowXV7j+vMY8nvMS159RiUxWlKbqTEx0fdn05MznlG9
+ I1Qz09tDypNYpxpim/AEez03pozIJTI7HYhpxd8yNKm8K8ulXacbxXUmMBjik5qT9TTkvUTis2euNSjG
+ ZTPbHSl3eMfhUNm8V8ujBdXuP68xjye8xLXn1GJTFaMQXlsqZxUuy1gMiazpsymwgbdUjj4fjUKUhOXk
+ BV5g1pTTm0cRE9OatApUKUZ6Uk8AmlPU5CBWPXNUMtOPgIyLw36EtTU811IhBcPjY0rTLtE7FhvwFDRq
+ dF8kOUpTCVBvB/Zntnx3zZoc93zhKU3UmJjo+7PpyZnPKN6Rqhnp7aHlSaxTjTFN+Gh4GwziJ2ZcoGxO
+ 27AvCzQqSrvDUqVrrs/wxVSwLMeKrsgvSmbVKxZNfzlS/FuSQqq0TOhYZRa/MtJNiRy2BeFFwqekPhNS
+ p115T3hiKf1eubU0DNKFyGsU4l/IqVhjmE2taU3UmJjo+7PpyZnPKN6Rqhnp7aHlSaxTjTFN+Gh4Gwzi
+ J2ZcoGxO27AvCzQqSrvDUqVrrs/wxVSwLMeKrsgvSmbVKxZNfzlS/FuSQqq3FZs9calGMyme2OlLu8Y/
+ CobN4r5dGC6vcf15jHk95iWvPqMSmK0pTdSYmOj7s+nJmc8o3pGqGentoeVJrFONMU34QlSklr0Zlwpu
+ cPwzXncvKXWTctsjRN5P39/MSR03eX8+63mKLOD+zPbPjvmzQ57vnCUpupMTHR92fTkzOeUb0jVDPT20
+ PKk1inGmKb8UpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8UpupMTHR92fTkzOeUb0jVDPT20PKk1in
+ GmKb8UpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8UpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8O
+ KzZ641KMZlM9sdKXd4x+FQ2bxXy6MF1e4/rzGPJ7zEtefUYlMVpSm6kxMdH3Z9OTM55RvSNUM9PbQ8qT
+ WKcaYpvwhKlJLXozLhTc4fhmvO5eUusm5bZGibyfv7+Ykjpu8v591vMUWcH9me2fHfNmhz3fOEpTdSYm
+ Oj7s+nJmc8o3pGqGentoeVJrFONMU34pTdSYmOj7s+nJmc8o3pGqGentoeVJrFONMU34pTdSYmOj7s+n
+ Jmc8o3pGqGentoeVJrFONMU34pTdSYmOj7s+nJmc8o3pGqGentoeVJrFONMU34pTdSYmOj7s+nJmc8o3
+ pGqGentoeVJrFONMU34RM6FhlFr8y0k2JHLYF4UXCp6Q+E1KnXXlPeGIp/V65tTQM0oXIaxTiX8ipWGO
+ YTa1pTdSYmOj7s+nJmc8o3pGqGentoeVJrFONMU34QlSklr0ZlwpucPwzXncvKXWTctsjRN5P39/MSR0
+ 3eX8+63mKLOD+zPbPjvmzQ57vnCUpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8UpupMTHR92fTkzOe
+ Ub0jVDPT20PKk1inGmKb8UpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8UpupMTHR92fTkzOeUb0jVD
+ PT20PKk1inGmKb8UpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8UpupMTHR92fTkzOeUb0jVDPT20PK
+ k1inGmKb8UpupMTHR92fTkzOeUb0jVDPT20PKk1inGmKb8ISpSS16My4U3OH4ZrzuXlLrJuW2Rom8n7+
+ /mJI6bvL+fdbzFFnB/Zntnx3zZoc93zhKbXpKRvSsaYWMcNjGd8mlTJUPhaptcO/Y/CzW6JViS1YYK4G
+ a4rI4rcqyVapwOT1nSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ
+ 8qTWKcaYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKc
+ aYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvwW
+ oUFoizC0TagCFA2tzUREhqbkrWlMMStaVGmNWmpkYBKVIgRULFERqFAzTzTDB8H9me2fHfNmhz3fOERt
+ tRFMqKSekjmY6viCmlqVYlW1zlIcchBBRkdmq8xwtmplzPPgpEcjEjOOAQmMvFzVUNKbqTEx0fdn05Mz
+ nlG9I1Qz09tDypNYpxpim/FKbqTEx0fdn05MznlG9I1Qz09tDypNYpxpim/FKbqTEx0fdn05MznlG9I1
+ Qz09tDypNYpxpim/FKbqTEx0fdn05MznlG9I1Qz09tDypNYpxpim/FKbqTEx0fdn05MznlG9I1Qz09tD
+ ypNYpxpim/CZlG1ooPbtTNPQuy2ZhbHFsIcqJyEqBufVUXHIqk3Y5E8FsriAg5C7mKFA1Jx8FR6ZQscK
+ r4T7M9s+O+bNDnu+cLSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvxSm6kxMdH3Z9OTM55RvSNUM9Pb
+ Q8qTWKcaYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWK
+ caYpvxSm6kxMdH3Z9OTM55RvSNUM9PbQ8qTWKcaYpvxwv2Z7Z8d82aHPd8/H/Zntnx3zZoc93zhtBRJh
+ n/AAIX+aEbaYJowh/pGEgj/AMwMbRiYlOhCHviEMRh92n+MDWh7raIwjCMPfCPsjw32Z7Z8d82aHPd84
+ T9tKM2P+koiEP5fkAoMf12AElrI1xCgEH7esOIox0QhAQyxC98f02eHanaUf3lppxvWOdQurW1LVbSxo
+ W5Ea4LVLo4kkCRoCiEZIzP5UYIxDD2QjGMIW9/64W9/64WcVNL0M+1W3syBU5Pbg1tC1ehZESFOYrVKn
+ daQkORtqYpMVEeucYCEdGiGmOiEY/wCrggj+ktQMGj/i6kQfqt/JhECH6BDgP+CMAAsnpuiqbeqqflQR
+ mEtLC3KnNaIkrVvlIyEhZoikqeAoRMNHqllh9ohQh7bNSnMuh3Wk072M0pqPXmt55Kw1OWA08ksxAsVg
+ CcSWYGIwCiEQYRhphwX2Z7Z8d82aHPd84Co0eWjCCoFtLNMHp0R4k3N6iKMYxlFBRgcFKaC1UcaDUAUX
+ GIoijD9Ntoo0AlMFBNNjp8mpWA2pAEXUTo/6uAviUYpgCH9HAaJTEcdSBcR/s2rQVBU8QuFl8FDGqyXJ
+ 1bWNQ2CcYPEU5UU7spSHGnQiwqoDACERFiL0ChCMYaV1I5bNSV3fG5iU1GrTK3RuaCwNKRwbGw88KlyU
+ JiBjCsdyAwBAURxgKMYQ0BjocMrKSpZZUFbNTi6trk1t5ySKdAayLRt7moWux6glpRNyZYDUipOPAREQ
+ gwgKMRhhFVVz1RaR0a2tGYucQ02+Nj0ubE5Rd4eoUNqc4K1SWmL0xHFMA+AAhiMWgENa3iUpphSxcHyo
+ YV2xMyGBydPFY7O+WSVA3JIKFZqdIRFSsUABrmmALDp0iFCEIxsoqVdRad1QIUxixyT069tjy5t6Ykm+
+ ONNbU50FSyBIYR1oJAqIw1Yx0av7Vv4367eKsMI6YxY6iDD2/nHL14hCyzo2pBQ6trYoCkdKgXKkjPT7
+ epEWA2KU10cTk5SlaAo0Axp00D1ICzAjiXAIoRtCoK5o6MKZgYSSbUjE4In1oRnHjLKKLcTEJo1TXA08
+ 0JYBqSiizDIwCAQoxhC2aGYLExtZWY+Y7K4rsrnBSqa1YV5DfTavZIhZeHXTckMq44yJ5SgRUBhCERkN
+ UIYwdHvxhtiLMqlaEYakp1gS1Q7sFQN7TXSx2oxyMCUyth0upKOY4nawzSjE0dAQx/aCCEMx80Hek2dm
+ y3hWzqc2Htz5T4wpmp/qY8inyU7KgViUpSYlLCQQKCUGBIfZGAYB9nAfZntnx3zZoc93zgM2v7GMn9eD
+ saif68qt6QVPt/jre5va9a3L8ObXVe3azeoOMREYaoSglroAJcuESy9UuIgx/wBoWQkIKTkxqCkFMSyQ
+ QACJ61vzKWKzdUOiGuoVHjMFH8xCjH87Vl3M1Dz3y7t4vqDE4pWGvqwq6olNIOpwSDVJxDPUdbFORKAt
+ REATlLWoc0yyKcMYxUFgGIUNUiMYVWxZvs1TV8mqAgwI0b5V7pBpejynCBoKypt7cW97LWzJJhgDIQKA
+ MUDoAPgAwuAQ+LWr6ZibTqxEszQqOnoozAwOYlKbLcDm0yhoQBBA1sNAXqCgGENIIR0flatmF+rCpXxn
+ U5bO1QHNzy9ODqmE9I6ro9EQ6QAvPPiBaFK6qACGGMIjCZHW06A6Mym9CSWlRIK/rJGjSkhgAlMlS1E4
+ kJyCgQ9gCySgQCGH5QhbxVR0+5nf/wC753shfKNcltMPLs7uBbg7Mik1uclAV+cjmzLf58mEWpKEqaUh
+ aUwQBBEJOG7jHVjGEfEm65quju+0cJqrwilh1MtUuBwpajIQUlsqh1NEZBMKpDCQJbs2BQXIJupqmwMj
+ HxWHRdXKJzKx5mhZzZ5VetIU+UoFKcLYZe6yAJCmMTAQKiDVHHWhoj7bVmldqge3RKLKSoV4kzi6r1qc
+ S+FZZep4LREqTzS4q4EDiC80a+pGMNOi2a7OuqWoFrSDMmtSwNat5cVLcEtLVLlLFhRHKRpggT3YbuEA
+ 6AasNGjRwP2Z7Z8d82aHPd84DNr+xjJ/Xg7NQYljhErpLvYRCKEStDI9lxvIaNINBgoB9uj2x0e+3+0I
+ LBCIjBvVDQAWGGsMcYs+YYYQAGGkQo6woQ9n5xtWY4BFEAcm38IhaI6oRDrbL2IQxF7oCFAEYwh+eiP6
+ LZ/ZtZYgAEnK7NWvnBxXo6hJYn9nObXh4fYOjWM49GYM1MmTiGCJBt9eB0BDp0aamyA8QdNoqqdGSmTK
+ laq1TEkoXMxIlXtzOYtiNOQADTVLapdyBFKk2qWrJiMBxMYBMv8Ax10aJaU4ipByzzpgTiRCASV4qfy5
+ UNUVhQYCHCBSqKTXDDTH2C99qwh/7OVBH/1tl7bNeHs9mZVdc6HS3iujp9zNUH93jxaiXzOin11WUA0r
+ X1W50+2lGnqXFwDnLUgWNPEotxaixgi7GkREE9QWQKHsM0gjEIqp6J8uWrLfwx5VIXJW8t6F1ZW8BxdF
+ s0KiC3LwAMbzFYUTbAk9M2N6KKYk8ZcTTDBBKGDxff8Acuaf9z5dqy7mah575d2zaCKEYRhmbXkIwjDR
+ GEYVU6wjCMI+2EYR4H7M9s+O+bNDnu+cBm1/Yxk/rwdqodqV8MtCMearia4NzvWyBW2IwPCqCsQj3F3E
+ 30qjqJ0JUqyAnCSmuEYxFojFQKIdMapzUGSlq8/MBUvVV+yrzcNKqA5e4HOolSVYlTHwZ1yReeOJAwEG
+ kllmDLuohjCEAuWVfhloGjoPB5qqt1BSpvQvFTGCLViTgi407TLRqGp154TxKFYFsTYRGCBZYhXlswK2
+ aWVueKazNfHR6qqgnJaaFCcNe6L3JONC6ATGGJHBvC5GkBPiQYWcUOMDCRaAaj2RkX4dKGyoqqokwyV9
+ VI8BiIk4cBRCqE2slJsQXpWmMNEYSJWcIoJsIRGSZCIgxzgymMpQiphZvFVYFxqhc/qUy5uUVZS2zSpX
+ FJhyuDkcTGMVEYjOLiYOMQxjD+NZ3rpFS6WrjXakF9JCbVbsa0FkFrnlgeIrgqSULgIYyxMMC4F6kIRg
+ bGOtDV0RqmrDEwEJlT1G+VCNEA6J4EY3pzVOQkoDxFlCOCnEp1IDiEMRQhp0Q91s08tktGoqhJzORr0h
+ 7soez241ngup9WwxGSjLbVgFkSwK4m6ImF6Yh1fZ77OuWVWUOy5q5XO6hQoFS7ypISmN4nAQYuZRBqtr
+ ekDg1rhQvTESlMIAjoREAZeuZrLsn8pMqqbyXoF4gIt8TMRiAalxSHmQULkCRG0sjC0sqVxPhCCmICjj
+ lAA6ImBCMYI5s5MJqMRviXNRHU6NQ/nvR6E9mhUtJBpQYyW8ttVFrYpCw30ICNL1xfs+yHts25iUkUiW
+ K0qZW2OTS5QNkHlmcIFzjcpGQMs8nSYSWaUYCOks8oAowEGEQCqJiQ+F6jabq+rVJDo611FzQjeUj4m1
+ 4EvIFrJS9Pu724ggpODAatVAqIRxCaUcAYgcD9me2fHfNmhz3fOAdnXK2qNl176iIb3U/BKde5pGmPip
+ JJuqiaHckjUOjraxYQCj7oxjD2WUK1A7xQqPNUHmaoQa5x5gjTR6gAhAHWGKMdEIQhD8of4ffG3vjb3x
+ t74298be+NvfG3tjp/y8J9me2fHfNmhz3fPx/wBme2fHfNmhz3fPx/2Z7Z8d82aHPd8/H/Zntnx3zZoc
+ 93z8f9me2fHfNmhz3fPx/wBme1ef7pr986o6x+sP/rxd+/n/AJz/AO1P+nXtvoz2+jPb6M9voz2+jPb6
+ M9voz2+jPb6M9voz2+jPb6M9voz2+jPb6M9voz2+jPb6M9voz2+jPb6M9voz2+jPb6M9voz2+jPb6M9v
+ oz2+jPb6M9v/AKZ//DP/AB//ABnb/9k=
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+ENRkV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDc6MzkAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAAMHAAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUpJJIAkgASTwBqSkpSSRBBgggjkHQpJKUkkk
+ kpSSSSSlJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TMb/jqv+rYkp//0dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/
+ AFb0JJSkkkklKSSSSUpJJJJTOmsWWBpMDkx5KxXU2q8bSSHMdzyINff+0g4v89/ZKsn+eZ/Uf+WpJTF9
+ bX3NDhIDCY7TIbr/AJyBfUBaG1gy5s7RrxP0f81Wf8OP+LP/AFTUv8Mf+Lb/ANU5JTRIIJBEEaEHkJI2
+ X/Oj+oPyvQUlKSSSSUpJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//S1sv+mZP/AB1v/VvQkXL/
+ AKZk/wDHW/8AVvQklKSSSSUpJJJJSk7GOe4Mbyf9ZTImN/Pt+Dv+pKSklVT6rxuggtdBHlCMf55n9R/5
+ aknfz1fwf/3xS2jcHdwCPvLT/wB8SUx/w4/4s/8AVNS/w5/4sf8AVOUto3751gt+RId/BLaN++dYDfkC
+ XfxSU1cv+dH9Qflego2X/Oj+oPyvQUlKSSSSUpJJJJSkXE/pmN/x1X/VsQkXE/pmN/x1X/VsSU//09bL
+ /pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpExv59vwd/1JQ0THIFzZMcj5kFrUlNstJs
+ Y7s0OB+e2P8AqVJJJJSkkkklNTL/AJ0f1B+V6CjZf86P6g/K9BSUpJJJJSkkkklKRcT+mY3/AB1X/VsQ
+ kXE/pmN/x1X/AFbElP8A/9TWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSBIIc3Rw
+ Mg+Y4SSSU367GWN3N+BB5CkqVFwq3SCd0ceU/wDkkX7Yz9x33hJTYTOc1jdzjDREnU86fmygfbG/uO+8
+ KNuQ2yssDSCY1JHYykpFY4Psc8CA4zrzxCikkkpSSSSSlJJJJKUi4n9Mxv8Ajqv+rYhIuJ/TMb/jqv8A
+ q2JKf//V1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJO1j3khjXPIBcQ0EmB9J3t/dUrKM
+ irb6tVle/wChva5u7+puHuSUwSU/QyPUNXpWeq0S6vadwHMuZG7ulVRkXAuoqstDfpGtrnAfNgSUwAJ4
+ CkK3Hy+KuYuD9p6bkZTfUffVayuutkkEONe/2NG7dte9Ae19byyxrq3jljgWkf2XKSEYne2pzGfLjIER
+ HXwJpEa3fFRLSOQVYZVfZHp1Ps3HaNjS6SBu2+0fS2pslrGU0ObXbW9wd6r3yGPIPt9D+p+elOMQLFow
+ Z8s5cMhHa9iLQJIrsPNABdjXAHgmt/8A5FWb+mOGHhX41dtz8it1l21peGxs27djfb9JRtxopK10/p12
+ c6wMlramOc5+wuBc3/A/m/pXT9FVn121nbbW6p8A7HgtMH+S6ElLJJJJKUi4n9Mxv+Oq/wCrYhIuJ/TM
+ b/jqv+rYkp//1tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklOp9Wv+VR/wAU/wD74p4l9+T0
+ O1+TY657MugsdYdxEvp+if7Sh9Wv+VR/xT/++obszAx+mnEwHW3OttZc51zdoaGFr2s9sbv5trUlOnRp
+ 9bM3/if++Yyp9OtvyOl4dHTrvRzML3Pxt2wXid+6f8J/Lb/6jeis6r0hvUbOpTf6uRXsfTsG1hhjd278
+ 7+aZ9FypYlnSTRiHI9TFysPaXPoaD6u0gtcXfmv9qSm4zLyD0rqeSAca9+TXvbXLS0n0K7Br72ud+eg9
+ Tsfb07pd1hL7X1vDrHauMbPpOTZXVqcnGz2bXMsy7q7KmxoGVilv6Rw/P20qvlZdV2Dg47J9TFa8WSIE
+ u2xtP530U4GmGcDK76iv+dbbx77qfq9c+l7q3HKDdzTBgir85HoDXD6v7oImw6+IALf+ks1uZUOkWYR3
+ es68WjT27QGD6X9lWsbb1IdNwanGuzDa99ziCNAa3fotjmvc/wDqJEqECKroAP8AncSerIynt6822yxz
+ GB4aHkw3W0Qzd9D2bfoIWVlZNHT+jii19QcyXBhgGDV9L976SJ1fIZfVa+zIzBU4/osd1Hp1l3+DY6x9
+ bN3ubv8A0j1n5WZTdi9OqZu34jYtkQJms+z976CazOw176+u9TZW5zGfZzZtaSBv21fpdv8ApP5a5x1t
+ t0WXWOteQBveS4x/WctYdWxP2zkZbmvOLk1eiSBD2yGN37P7CzMhmKywNxLH21Bo99jdp3fnafupKRpJ
+ JJKUi4n9Mxv+Oq/6tiEi4n9Mxv8Ajqv+rYkp/9fWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJ
+ JTOq66h/qU2OqfEbmGDB7IYEaBOkkpSSSSSlJJJJKUnY99bw+tzmPbq17SQR8HBMkkpLdlZWQAMi59wa
+ ZaHukA+KEkkkpSSSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv+Oq/6tiSn/9DWy/6Zk/8AHW/9W9CVnKxc
+ s5eQRj3EG60gip5BBe/X6CH9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9kzP8AuNd/20//AMgk
+ pEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZMz/uNd/20/wD8gkpE
+ ki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9kzP8AuNd/20//AMgkpEki
+ /ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZMz/uNd/20/wD8gkpEki/Z
+ Mz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEi4n9Mxv8Ajqv+rYl9kzP+413/AG0//wAgiYuLljLxyce4
+ AXVEk1PAAD2a/QSU/wD/2f/tFfxQaG90b3Nob3AgMy4wADhCSU0EBAAAAAAAJxwBWgADGyVHHAFaAAMb
+ JUccAVoAAxslRxwBWgADGyVHHAIAAAIAAAA4QklNBCUAAAAAABCaia1dKG26IQLIy6lnBT/bOEJJTQQ6
+ AAAAAACbAAAAEAAAAAEAAAAAAAtwcmludE91dHB1dAAAAAQAAAAAUHN0U2Jvb2wBAAAAAEludGVlbnVt
+ AAAAAEludGUAAAAAQ2xybQAAAA9wcmludFNpeHRlZW5CaXRib29sAAAAAAtwcmludGVyTmFtZVRFWFQA
+ AAATAEMAYQBuAG8AbgAgAE0AUAAxADQAMAAgAHMAZQByAGkAZQBzAAAAOEJJTQQ7AAAAAAGyAAAAEAAA
+ AAEAAAAAABJwcmludE91dHB1dE9wdGlvbnMAAAASAAAAAENwdG5ib29sAAAAAABDbGJyYm9vbAAAAAAA
+ UmdzTWJvb2wAAAAAAENybkNib29sAAAAAABDbnRDYm9vbAAAAAAATGJsc2Jvb2wAAAAAAE5ndHZib29s
+ AAAAAABFbWxEYm9vbAAAAAAASW50cmJvb2wAAAAAAEJja2dPYmpjAAAAAQAAAAAAAFJHQkMAAAADAAAA
+ AFJkICBkb3ViQG/gAAAAAAAAAAAAR3JuIGRvdWJAb+AAAAAAAAAAAABCbCAgZG91YkBv4AAAAAAAAAAA
+ AEJyZFRVbnRGI1JsdAAAAAAAAAAAAAAAAEJsZCBVbnRGI1JsdAAAAAAAAAAAAAAAAFJzbHRVbnRGI1B4
+ bEBSAAAAAAAAAAAACnZlY3RvckRhdGFib29sAQAAAABQZ1BzZW51bQAAAABQZ1BzAAAAAFBnUEMAAAAA
+ TGVmdFVudEYjUmx0AAAAAAAAAAAAAAAAVG9wIFVudEYjUmx0AAAAAAAAAAAAAAAAU2NsIFVudEYjUHJj
+ QFkAAAAAAAA4QklNA+0AAAAAABAASAAAAAEAAgBIAAAAAQACOEJJTQQmAAAAAAAOAAAAAAAAAAAAAD+A
+ AAA4QklNBA0AAAAAAAQAAAB4OEJJTQQZAAAAAAAEAAAAHjhCSU0D8wAAAAAACQAAAAAAAAAAAQA4QklN
+ JxAAAAAAAAoAAQAAAAAAAAACOEJJTQP1AAAAAABIAC9mZgABAGxmZgAGAAAAAAABAC9mZgABAKGZmgAG
+ AAAAAAABADIAAAABAFoAAAAGAAAAAAABADUAAAABAC0AAAAGAAAAAAABOEJJTQP4AAAAAABwAAD/////
+ ////////////////////////A+gAAAAA/////////////////////////////wPoAAAAAP//////////
+ //////////////////8D6AAAAAD/////////////////////////////A+gAADhCSU0EAAAAAAAAAgAD
+ OEJJTQQCAAAAAAAMAAAAAAAAAAAAAAAAOEJJTQQwAAAAAAAGAQEBAQEBOEJJTQQtAAAAAAAGAAEAAAAN
+ OEJJTQQIAAAAAAAaAAAAAQAAAkAAAAJAAAAAAgAAD6ABAAAPsAA4QklNBB4AAAAAAAQAAAAAOEJJTQQa
+ AAAAAANJAAAABgAAAAAAAAAAAAAA+gAAAPoAAAAKAHAAdQBzAGgAXwByAGkAZwBoAHQAAAABAAAAAAAA
+ AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAPoAAAD6AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAA
+ AAAAAAAAEAAAAAEAAAAAAABudWxsAAAAAgAAAAZib3VuZHNPYmpjAAAAAQAAAAAAAFJjdDEAAAAEAAAA
+ AFRvcCBsb25nAAAAAAAAAABMZWZ0bG9uZwAAAAAAAAAAQnRvbWxvbmcAAAD6AAAAAFJnaHRsb25nAAAA
+ +gAAAAZzbGljZXNWbExzAAAAAU9iamMAAAABAAAAAAAFc2xpY2UAAAASAAAAB3NsaWNlSURsb25nAAAA
+ AAAAAAdncm91cElEbG9uZwAAAAAAAAAGb3JpZ2luZW51bQAAAAxFU2xpY2VPcmlnaW4AAAANYXV0b0dl
+ bmVyYXRlZAAAAABUeXBlZW51bQAAAApFU2xpY2VUeXBlAAAAAEltZyAAAAAGYm91bmRzT2JqYwAAAAEA
+ AAAAAABSY3QxAAAABAAAAABUb3AgbG9uZwAAAAAAAAAATGVmdGxvbmcAAAAAAAAAAEJ0b21sb25nAAAA
+ +gAAAABSZ2h0bG9uZwAAAPoAAAADdXJsVEVYVAAAAAEAAAAAAABudWxsVEVYVAAAAAEAAAAAAABNc2dl
+ VEVYVAAAAAEAAAAAAAZhbHRUYWdURVhUAAAAAQAAAAAADmNlbGxUZXh0SXNIVE1MYm9vbAEAAAAIY2Vs
+ bFRleHRURVhUAAAAAQAAAAAACWhvcnpBbGlnbmVudW0AAAAPRVNsaWNlSG9yekFsaWduAAAAB2RlZmF1
+ bHQAAAAJdmVydEFsaWduZW51bQAAAA9FU2xpY2VWZXJ0QWxpZ24AAAAHZGVmYXVsdAAAAAtiZ0NvbG9y
+ VHlwZWVudW0AAAARRVNsaWNlQkdDb2xvclR5cGUAAAAATm9uZQAAAAl0b3BPdXRzZXRsb25nAAAAAAAA
+ AApsZWZ0T3V0c2V0bG9uZwAAAAAAAAAMYm90dG9tT3V0c2V0bG9uZwAAAAAAAAALcmlnaHRPdXRzZXRs
+ b25nAAAAAAA4QklNBCgAAAAAAAwAAAACP/AAAAAAAAA4QklNBBQAAAAAAAQAAAAdOEJJTQQMAAAAAAw4
+ AAAAAQAAAKAAAACgAAAB4AABLAAAAAwcABgAAf/Y/+0ADEFkb2JlX0NNAAH/7gAOQWRvYmUAZIAAAAAB
+ /9sAhAAMCAgICQgMCQkMEQsKCxEVDwwMDxUYExMVExMYEQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwM
+ DAwMDAwMDAwMAQ0LCw0ODRAODhAUDg4OFBQODg4OFBEMDAwMDBERDAwMDAwMEQwMDAwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAz/wAARCACgAKADASIAAhEBAxEB/90ABAAK/8QBPwAAAQUBAQEBAQEAAAAAAAAA
+ AwABAgQFBgcICQoLAQABBQEBAQEBAQAAAAAAAAABAAIDBAUGBwgJCgsQAAEEAQMCBAIFBwYIBQMMMwEA
+ AhEDBCESMQVBUWETInGBMgYUkaGxQiMkFVLBYjM0coLRQwclklPw4fFjczUWorKDJkSTVGRFwqN0NhfS
+ VeJl8rOEw9N14/NGJ5SkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2N0dXZ3eHl6e3x9fn9xEAAgIBAgQE
+ AwQFBgcHBgU1AQACEQMhMRIEQVFhcSITBTKBkRShsUIjwVLR8DMkYuFygpJDUxVjczTxJQYWorKDByY1
+ wtJEk1SjF2RFVTZ0ZeLys4TD03Xj80aUpIW0lcTU5PSltcXV5fVWZnaGlqa2xtbm9ic3R1dnd4eXp7fH
+ /9oADAMBAAIRAxEAPwDaysrLGXkAZFwAutAAteAAHv0+mh/a8z/uTd/26/8A8mll/wBMyf8Ajrf+rehJ
+ KS/a8z/uTd/26/8A8ml9rzP+5N3/AG6//wAmhJJKS/a8z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS
+ /a8z/uTd/wBuv/8AJpfa8z/uTd/26/8A8mhJJKS/a8z/ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a
+ 8z/uTd/26/8A8ml9rzP+5N3/AG6//wAmhJJKS/a8z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS/a8z
+ /uTd/wBuv/8AJpfa8z/uTd/26/8A8mhJJKS/a8z/ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a8z/u
+ Td/26/8A8miYuVlnLxwci4g3VAg2vIIL2afTVZFxP6Zjf8dV/wBWxJT/AP/Q1sv+mZP/AB1v/VvQkXL/
+ AKZk/wDHW/8AVvQklKSSSSUpJJJJSkkkklKSSSAJIAEk8AakpKUkkQQYIII5B0KSSlJJJJKUkkkkpSSS
+ SSlIuJ/TMb/jqv8Aq2ISLif0zG/46r/q2JKf/9HWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJ
+ JSkkkklKSSSSUzprFlgaTA5MeSsV1NqvG0khzHc8iDX3/tIOL/Pf2SrJ/nmf1H/lqSUxfW19zQ4SAwmO
+ 0yG6/wCcgX1AWhtYMubO0a8T9H/NVn/Dj/iz/wBU1L/DH/i2/wDVOSU0SCCQRBGhB5CSNl/zo/qD8r0F
+ JSkkkklKSSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HVf9WxJT//0tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/
+ AFb0JJSkkkklKSSSSUpOxjnuDG8n/WUyJjfz7fg7/qSkpJVU+q8boILXQR5QjH+eZ/Uf+WpJ389X8H/9
+ 8Uto3B3cAj7y0/8AfElMf8OP+LP/AFTUv8Of+LH/AFTlLaN++dYLfkSHfwS2jfvnWA35Al38UlNXL/nR
+ /UH5XoKNl/zo/qD8r0FJSkkkklKSSSSUpFxP6Zjf8dV/1bEJFxP6Zjf8dV/1bElP/9PWy/6Zk/8AHW/9
+ W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKRMb+fb8Hf9SUNExyBc2THI+ZBa1JTbLSbGO7NDgfntj/
+ AKlSSSSUpJJJJTUy/wCdH9Qflego2X/Oj+oPyvQUlKSSSSUpJJJJSkXE/pmN/wAdV/1bEJFxP6Zjf8dV
+ /wBWxJT/AP/U1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSkgSCHN0cDIPmOEkklN+
+ uxljdzfgQeQpKlRcKt0gndHHlP8A5JF+2M/cd94SU2EznNY3c4w0RJ1POn5soH2xv7jvvCjbkNsrLA0g
+ mNSR2MpKRWOD7HPAgOM688QopJJKUkkkkpSSSSSlIuJ/TMb/AI6r/q2ISLif0zG/46r/AKtiSn//1dbL
+ /pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSTtY95IY1zyAXENBJgfSd7f3VKyjIq2+rVZXv8A
+ ob2ubu/qbh7klMElP0Mj1DV6VnqtEur2ncBzLmRu7pVUZFwLqKrLQ36Rra5wHzYElMACeApCtx8virmL
+ g/aem5GU31H31WsrrrZJBDjXv9jRu3bXvQHtfW8ssa6t45Y4FpH9lykhGJ3tqcxny4yBER18CaRGt3xU
+ S0jkFWGVX2R6dT7Nx2jY0ukgbtvtH0tqbJaxlNDm121vcHeq98hjyD7fQ/qfnpTjECxaMGfLOXDIR2vY
+ i0CSK7DzQAXY1wB4Jrf/AORVm/pjhh4V+NXbc/IrdZdtaXhsbNu3Y32/SUbcaKStdP6ddnOsDJa2pjnO
+ fsLgXN/wP5v6V0/RVZ9dtZ221uqfAOx4LTB/kuhJSySSSSlIuJ/TMb/jqv8Aq2ISLif0zG/46r/q2JKf
+ /9bWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJTqfVr/lUf8AFP8A++KeJffk9Dtfk2OuezLo
+ LHWHcRL6fon+0ofVr/lUf8U//vqG7MwMfppxMB1tzrbWXOdc3aGhha9rPbG7+ba1JTp0afWzN/4n/vmM
+ qfTrb8jpeHR0670czC9z8bdsF4nfun/Cfy2/+o3orOq9Ib1GzqU3+rkV7H07BtYYY3du/O/mmfRcqWJZ
+ 0k0YhyPUxcrD2lz6Gg+rtILXF35r/akpuMy8g9K6nkgHGvfk1721y0tJ9Cuwa+9rnfnoPU7H29O6XdYS
+ +19bw6x2rjGz6Tk2V1anJxs9m1zLMu6uypsaBlYpb+kcPz9tKr5WXVdg4OOyfUxWvFkiBLtsbT+d9FOB
+ phnAyu+or/nW28e+6n6vXPpe6txyg3c0wYIq/OR6A1w+r+6CJsOviAC3/pLNbmVDpFmEd3rOvFo09u0B
+ g+l/ZVrG29SHTcGpxrsw2vfc4gjQGt36LY5r3P8A6iRKhAiq6AD/AJ3EnqyMp7evNtsscxgeGh5MN1tE
+ M3fQ9m36CFlZWTR0/o4otfUHMlwYYBg1fS/e+kidXyGX1WvsyMwVOP6LHdR6dZd/g2OsfWzd7m7/ANI9
+ Z+VmU3YvTqmbt+I2LZECZrPs/e+gmszsNe+vrvU2Vucxn2c2bWkgb9tX6Xb/AKT+WucdbbdFl1jrXkAb
+ 3kuMf1nLWHVsT9s5GW5rzi5NXokgQ9shjd+z+wszIZissDcSx9tQaPfY3ad352n7qSkaSSSSlIuJ/TMb
+ /jqv+rYhIuJ/TMb/AI6r/q2JKf/X1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUzquuof6lN
+ jqnxG5hgweyGBGgTpJKUkkkkpSSSSSlJ2PfW8Prc5j26te0kEfBwTJJKS3ZWVkADIufcGmWh7pAPihJJ
+ JKUkkkkpSSSSSlIuJ/TMb/jqv+rYhIuJ/TMb/jqv+rYkp//Q1sv+mZP/AB1v/VvQlZysXLOXkEY9xBut
+ IIqeQQXv1+gh/ZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7j
+ Xf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf
+ 9tP/APIJfZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8A
+ bT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/
+ APIJfZMz/uNd/wBtP/8AIJKRIuJ/TMb/AI6r/q2JfZMz/uNd/wBtP/8AIImLi5Yy8cnHuAF1RJNTwAA9
+ mv0ElP8A/9k4QklNBCEAAAAAAFUAAAABAQAAAA8AQQBkAG8AYgBlACAAUABoAG8AdABvAHMAaABvAHAA
+ AAATAEEAZABvAGIAZQAgAFAAaABvAHQAbwBzAGgAbwBwACAAQwBTADUAAAABADhCSU0PoAAAAAAA+G1h
+ bmlJUkZSAAAA7DhCSU1BbkRzAAAAzAAAABAAAAABAAAAAAAAbnVsbAAAAAMAAAAAQUZTdGxvbmcAAAAA
+ AAAAAEZySW5WbExzAAAAAU9iamMAAAABAAAAAAAAbnVsbAAAAAEAAAAARnJJRGxvbmcDIQffAAAAAEZT
+ dHNWbExzAAAAAU9iamMAAAABAAAAAAAAbnVsbAAAAAQAAAAARnNJRGxvbmcAAAAAAAAAAEFGcm1sb25n
+ AAAAAAAAAABGc0ZyVmxMcwAAAAFsb25nAyEH3wAAAABMQ250bG9uZwAAAAAAADhCSU1Sb2xsAAAACAAA
+ AAAAAAAAOEJJTQ+hAAAAAAAcbWZyaQAAAAIAAAAQAAAAAQAAAAAAAAABAAAAADhCSU0EBgAAAAAABwAI
+ AQEAAQEA/+EjCGh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0IGJlZ2luPSLvu78i
+ IGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4NCjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6
+ bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMC1jMDYwIDYxLjEzNDc3NywgMjAxMC8w
+ Mi8xMi0xNzozMjowMCAgICAgICAgIj4NCgk8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMu
+ b3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPg0KCQk8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91
+ dD0iIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtbG5zOnBob3Rvc2hv
+ cD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90b3Nob3AvMS4wLyIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJs
+ Lm9yZy9kYy9lbGVtZW50cy8xLjEvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAv
+ MS4wL21tLyIgeG1sbnM6c3RFdnQ9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNv
+ dXJjZUV2ZW50IyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9S
+ ZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2gi
+ IHhtcDpDcmVhdGVEYXRlPSIyMDEyLTAzLTIxVDEyOjM3OjAxKzAxOjAwIiB4bXA6TWV0YWRhdGFEYXRl
+ PSIyMDEyLTAzLTIxVDE4OjQ3OjM5KzAxOjAwIiB4bXA6TW9kaWZ5RGF0ZT0iMjAxMi0wMy0yMVQxODo0
+ NzozOSswMTowMCIgcGhvdG9zaG9wOkNvbG9yTW9kZT0iMyIgcGhvdG9zaG9wOklDQ1Byb2ZpbGU9InNS
+ R0IgSUVDNjE5NjYtMi4xIiBkYzpmb3JtYXQ9ImltYWdlL2pwZWciIHhtcE1NOkluc3RhbmNlSUQ9Inht
+ cC5paWQ6RUYxNzdEQ0MwRTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHhtcE1NOkRvY3VtZW50SUQ9Inht
+ cC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHhtcE1NOk9yaWdpbmFsRG9jdW1l
+ bnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSI+DQoJCQk8cGhvdG9z
+ aG9wOlRleHRMYXllcnM+DQoJCQkJPHJkZjpCYWc+DQoJCQkJCTxyZGY6bGkgcGhvdG9zaG9wOkxheWVy
+ TmFtZT0icHVzaCByaWdodCIgcGhvdG9zaG9wOkxheWVyVGV4dD0icHVzaCByaWdodCIvPg0KCQkJCTwv
+ cmRmOkJhZz4NCgkJCTwvcGhvdG9zaG9wOlRleHRMYXllcnM+DQoJCQk8eG1wTU06SGlzdG9yeT4NCgkJ
+ CQk8cmRmOlNlcT4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImNyZWF0ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTI6Mzc6MDErMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RF
+ dnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowMjgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RF
+ dnQ6d2hlbj0iMjAxMi0wMy0yMVQxMjozNzozOSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRv
+ YmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjAzODAxMTc0MDcy
+ MDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEyOjU3OjEzKzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6MDQ4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTM6MDA6MDgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6
+ YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNTgwMTE3NDA3MjA2ODExQkE5
+ RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowMjo0MyswMTowMCIgc3RFdnQ6
+ c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9
+ Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4
+ bXAuaWlkOjA2ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAz
+ LTIxVDEzOjA3OjU2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDc4MDExNzQwNzIwNjgxMUJBOURERjE1QTVB
+ RUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDg6MTErMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDow
+ ODgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzow
+ ODoxOCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjBBODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA5OjM5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjIyM0RFMEEw
+ QzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDk6NDkrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDoyMzIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxMzoxMCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9z
+ aG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDph
+ Y3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI0MjNERTBBMEMyMDY4MTFCQTlE
+ REYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEwOjI4KzAxOjAwIiBzdEV2dDpz
+ b2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0i
+ LyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9Inht
+ cC5paWQ6MjUyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMt
+ MjFUMTM6MTI6NDMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJz
+ YXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyNjIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFF
+ RTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMzowNiswMTowMCIgc3RFdnQ6c29mdHdhcmVB
+ Z2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJ
+ CQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI3
+ MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjE4
+ OjQwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9z
+ aCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0
+ RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjgyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0
+ RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6MTQ6MDUrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFk
+ b2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6
+ bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGNzdGMTE3NDA3
+ MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1NCswMTowMCIg
+ c3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNo
+ YW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5j
+ ZUlEPSJ4bXAuaWlkOkZBN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIy
+ MDEyLTAzLTIxVDE3OjU1OjUwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3No
+ b3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFj
+ dGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkI3RjExNzQwNzIwNjgxMTk0NTc5
+ QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTY6MDUrMDE6MDAiIHN0RXZ0OnNv
+ ZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIv
+ Ii8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1w
+ LmlpZDpGQzdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0y
+ MVQxNzo1Njo1MiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBN
+ YWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNh
+ dmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkZEN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2
+ NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjU3OjA5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFn
+ ZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJ
+ CQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkU3
+ RjExNzQwNzIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTc6
+ MDkrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3No
+ IiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RF
+ dnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGRjdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RF
+ dnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1Nzo1NCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRv
+ YmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkQ5NTMxRDg0MEUy
+ MDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjQ2OjIxKzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6RUUxNzdEQ0MwRTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTg6NDc6MzkrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6
+ YWN0aW9uPSJjb252ZXJ0ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImZyb20gYXBwbGljYXRpb24vdm5kLmFk
+ b2JlLnBob3Rvc2hvcCB0byBpbWFnZS9qcGVnIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJk
+ ZXJpdmVkIiBzdEV2dDpwYXJhbWV0ZXJzPSJjb252ZXJ0ZWQgZnJvbSBhcHBsaWNhdGlvbi92bmQuYWRv
+ YmUucGhvdG9zaG9wIHRvIGltYWdlL2pwZWciLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNh
+ dmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkVGMTc3RENDMEUyMDY4MTE5NDU3OUEzM0ZCMzU2
+ NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjQ3OjM5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFn
+ ZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJ
+ CTwvcmRmOlNlcT4NCgkJCTwveG1wTU06SGlzdG9yeT4NCgkJCTx4bXBNTTpEZXJpdmVkRnJvbSBzdFJl
+ ZjppbnN0YW5jZUlEPSJ4bXAuaWlkOkVFMTc3RENDMEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdFJl
+ Zjpkb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdFJl
+ ZjpvcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4
+ MTEiLz4NCgkJPC9yZGY6RGVzY3JpcHRpb24+DQoJPC9yZGY6UkRGPg0KPC94OnhtcG1ldGE+DQogICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAog
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ IAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgIAogICA8P3hwYWNrZXQgZW5kPSd3Jz8+/+IMWElDQ19QUk9GSUxFAAEBAAAMSExp
+ bm8CEAAAbW50clJHQiBYWVogB84AAgAJAAYAMQAAYWNzcE1TRlQAAAAASUVDIHNSR0IAAAAAAAAAAAAA
+ AAEAAPbWAAEAAAAA0y1IUCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAARY3BydAAAAVAAAAAzZGVzYwAAAYQAAABsd3RwdAAAAfAAAAAUYmtwdAAAAgQAAAAUclhZWgAA
+ AhgAAAAUZ1hZWgAAAiwAAAAUYlhZWgAAAkAAAAAUZG1uZAAAAlQAAABwZG1kZAAAAsQAAACIdnVlZAAA
+ A0wAAACGdmlldwAAA9QAAAAkbHVtaQAAA/gAAAAUbWVhcwAABAwAAAAkdGVjaAAABDAAAAAMclRSQwAA
+ BDwAAAgMZ1RSQwAABDwAAAgMYlRSQwAABDwAAAgMdGV4dAAAAABDb3B5cmlnaHQgKGMpIDE5OTggSGV3
+ bGV0dC1QYWNrYXJkIENvbXBhbnkAAGRlc2MAAAAAAAAAEnNSR0IgSUVDNjE5NjYtMi4xAAAAAAAAAAAA
+ AAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAFhZWiAAAAAAAADzUQABAAAAARbMWFlaIAAAAAAAAAAAAAAAAAAAAABYWVogAAAAAAAA
+ b6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9kZXNjAAAAAAAA
+ ABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAuSUVDIDYx
+ OTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAuSUVDIDYxOTY2
+ LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRl
+ c2MAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAA
+ AAAAACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAB2aWV3AAAAAAATpP4AFF8uABDPFAAD7cwABBMLAANcngAAAAFYWVogAAAAAABM
+ CVYAUAAAAFcf521lYXMAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAKPAAAAAnNpZyAAAAAAQ1JUIGN1
+ cnYAAAAAAAAEAAAAAAUACgAPABQAGQAeACMAKAAtADIANwA7AEAARQBKAE8AVABZAF4AYwBoAG0AcgB3
+ AHwAgQCGAIsAkACVAJoAnwCkAKkArgCyALcAvADBAMYAywDQANUA2wDgAOUA6wDwAPYA+wEBAQcBDQET
+ ARkBHwElASsBMgE4AT4BRQFMAVIBWQFgAWcBbgF1AXwBgwGLAZIBmgGhAakBsQG5AcEByQHRAdkB4QHp
+ AfIB+gIDAgwCFAIdAiYCLwI4AkECSwJUAl0CZwJxAnoChAKOApgCogKsArYCwQLLAtUC4ALrAvUDAAML
+ AxYDIQMtAzgDQwNPA1oDZgNyA34DigOWA6IDrgO6A8cD0wPgA+wD+QQGBBMEIAQtBDsESARVBGMEcQR+
+ BIwEmgSoBLYExATTBOEE8AT+BQ0FHAUrBToFSQVYBWcFdwWGBZYFpgW1BcUF1QXlBfYGBgYWBicGNwZI
+ BlkGagZ7BowGnQavBsAG0QbjBvUHBwcZBysHPQdPB2EHdAeGB5kHrAe/B9IH5Qf4CAsIHwgyCEYIWghu
+ CIIIlgiqCL4I0gjnCPsJEAklCToJTwlkCXkJjwmkCboJzwnlCfsKEQonCj0KVApqCoEKmAquCsUK3Arz
+ CwsLIgs5C1ELaQuAC5gLsAvIC+EL+QwSDCoMQwxcDHUMjgynDMAM2QzzDQ0NJg1ADVoNdA2ODakNww3e
+ DfgOEw4uDkkOZA5/DpsOtg7SDu4PCQ8lD0EPXg96D5YPsw/PD+wQCRAmEEMQYRB+EJsQuRDXEPURExEx
+ EU8RbRGMEaoRyRHoEgcSJhJFEmQShBKjEsMS4xMDEyMTQxNjE4MTpBPFE+UUBhQnFEkUahSLFK0UzhTw
+ FRIVNBVWFXgVmxW9FeAWAxYmFkkWbBaPFrIW1hb6Fx0XQRdlF4kXrhfSF/cYGxhAGGUYihivGNUY+hkg
+ GUUZaxmRGbcZ3RoEGioaURp3Gp4axRrsGxQbOxtjG4obshvaHAIcKhxSHHscoxzMHPUdHh1HHXAdmR3D
+ HeweFh5AHmoelB6+HukfEx8+H2kflB+/H+ogFSBBIGwgmCDEIPAhHCFIIXUhoSHOIfsiJyJVIoIiryLd
+ IwojOCNmI5QjwiPwJB8kTSR8JKsk2iUJJTglaCWXJccl9yYnJlcmhya3JugnGCdJJ3onqyfcKA0oPyhx
+ KKIo1CkGKTgpaymdKdAqAio1KmgqmyrPKwIrNitpK50r0SwFLDksbiyiLNctDC1BLXYtqy3hLhYuTC6C
+ Lrcu7i8kL1ovkS/HL/4wNTBsMKQw2zESMUoxgjG6MfIyKjJjMpsy1DMNM0YzfzO4M/E0KzRlNJ402DUT
+ NU01hzXCNf02NzZyNq426TckN2A3nDfXOBQ4UDiMOMg5BTlCOX85vDn5OjY6dDqyOu87LTtrO6o76Dwn
+ PGU8pDzjPSI9YT2hPeA+ID5gPqA+4D8hP2E/oj/iQCNAZECmQOdBKUFqQaxB7kIwQnJCtUL3QzpDfUPA
+ RANER0SKRM5FEkVVRZpF3kYiRmdGq0bwRzVHe0fASAVIS0iRSNdJHUljSalJ8Eo3Sn1KxEsMS1NLmkvi
+ TCpMcky6TQJNSk2TTdxOJU5uTrdPAE9JT5NP3VAnUHFQu1EGUVBRm1HmUjFSfFLHUxNTX1OqU/ZUQlSP
+ VNtVKFV1VcJWD1ZcVqlW91dEV5JX4FgvWH1Yy1kaWWlZuFoHWlZaplr1W0VblVvlXDVchlzWXSddeF3J
+ XhpebF69Xw9fYV+zYAVgV2CqYPxhT2GiYfViSWKcYvBjQ2OXY+tkQGSUZOllPWWSZedmPWaSZuhnPWeT
+ Z+loP2iWaOxpQ2maafFqSGqfavdrT2una/9sV2yvbQhtYG25bhJua27Ebx5veG/RcCtwhnDgcTpxlXHw
+ cktypnMBc11zuHQUdHB0zHUodYV14XY+dpt2+HdWd7N4EXhueMx5KnmJeed6RnqlewR7Y3vCfCF8gXzh
+ fUF9oX4BfmJ+wn8jf4R/5YBHgKiBCoFrgc2CMIKSgvSDV4O6hB2EgITjhUeFq4YOhnKG14c7h5+IBIhp
+ iM6JM4mZif6KZIrKizCLlov8jGOMyo0xjZiN/45mjs6PNo+ekAaQbpDWkT+RqJIRknqS45NNk7aUIJSK
+ lPSVX5XJljSWn5cKl3WX4JhMmLiZJJmQmfyaaJrVm0Kbr5wcnImc951kndKeQJ6unx2fi5/6oGmg2KFH
+ obaiJqKWowajdqPmpFakx6U4pammGqaLpv2nbqfgqFKoxKk3qamqHKqPqwKrdavprFys0K1ErbiuLa6h
+ rxavi7AAsHWw6rFgsdayS7LCszizrrQltJy1E7WKtgG2ebbwt2i34LhZuNG5SrnCuju6tbsuu6e8Ibyb
+ vRW9j74KvoS+/796v/XAcMDswWfB48JfwtvDWMPUxFHEzsVLxcjGRsbDx0HHv8g9yLzJOsm5yjjKt8s2
+ y7bMNcy1zTXNtc42zrbPN8+40DnQutE80b7SP9LB00TTxtRJ1MvVTtXR1lXW2Ndc1+DYZNjo2WzZ8dp2
+ 2vvbgNwF3IrdEN2W3hzeot8p36/gNuC94UThzOJT4tvjY+Pr5HPk/OWE5g3mlucf56noMui86Ubp0Opb
+ 6uXrcOv77IbtEe2c7ijutO9A78zwWPDl8XLx//KM8xnzp/Q09ML1UPXe9m32+/eK+Bn4qPk4+cf6V/rn
+ +3f8B/yY/Sn9uv5L/tz/bf///9sAQwABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+ AQEBAQEBAgICAgICAgICAgIDAwMDAwMDAwMD/9sAQwEBAQEBAQEBAQEBAgIBAgIDAwMDAwMDAwMDAwMD
+ AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD/8IAEQgA+gD6AwERAAIRAQMRAf/EAB0A
+ AQADAQADAQEAAAAAAAAAAAAGBwkIAQQFAwL/xAAuEAAAAwcDBAIBBAMAAAAAAAAFBgcAAQIDEwQIMBg4
+ QBEUCRIVIHCQFzkxNyn/xAAcAQEAAQUBAQAAAAAAAAAAAAAABQECBAYHAwj/xABZEQAABAMEBAkIAwsF
+ EAMAAAACAwQFARQGABMVBxESFiYwRWUXN0cIGGghMdW2d5dJiUBRIiBBkaEyIyQ0JTU2YWJ1tbfwgbFC
+ coIzY2S0VVZmdjg5SIgJ/8QAOxIAAgECAwQGCAQFBQAAAAAAAQIDABEhMQRRYRIFQEGhwSIycYGRsdFC
+ EwZwkGIUEPCyIweSwjNjJP/aAAwDAQACEAMQAAAA2HKmAAAAAAAAAAAAAABrKZNFMgAAAAAAAAAAAAAA
+ 2YMzSmQAAAAAAAAAAAAAAbMGZpTIAAAAAAAAAAAAAANmDM0pkAAAAAAAAAAAAAAGzBmaUyAAAAAAAAAA
+ AAAADZgzNKZAAAAAB7p7p1KUaekV+AAAAAAbMGZpTIAAAAALmJmTMhgK/KzPSAAAAANmDM0pkAAAAAFz
+ EzJmQwEzOZiGAAAAAGzBmaUyAAAAAC5iZkzIYCZnMxDAAAAADZgzNKZAAAAAOjD0z7JMyGAmZzMQwAAA
+ AA2YMzSmQAAAADswhh9o+yfGB9k5mIYAAAAAbMGZpTIAAAAB2YQwmYABzMQwAAAAA2YMzSmQAAAADsw+
+ MfZAAOZiGAAAAAGzBmaUyAAAAAdmAAAHMxDAAAAADZgzNKZAAAAAOpiTAAA5NPigAAAAGzBmaUyAAAAA
+ WAdGAAEMOZgAAAAAbMGZpTIAAAAAOmSZgA5mIYAAAAADZgzNKZAAAAAAAAAAAAAABswZmlMgAAAAAH65
+ ML70tz38MTYPUjN58UvAAAAAA2YMzSmQAAAAFPakdMn87yzz074Y83Y4kmqfQNQ6T9P+jD9IkXlnfEPV
+ AAAANmDM0pkAAHRhICvwfqffNUZjnOcG/fIvPchqHS0butpRPQ+I9C+tOnaX9GFJlaHWBkmAAAbMGZpT
+ IAANmT9SPgl5yFd4dhTfL/y94vH7ZeJbEaz3D5V/h6Mft0cieg/RKQLcKyM4AAADZgzNKZAABsCD+Tyc
+ VmiGTCw7O1YZGymia5Re9iELLDiOiwVXm46aKZM/wAADZgzNKZAABuMcvFcFnlcVtkeRDVffjjk/1wOs
+ fLO8K6B+eV6PjJ8BW+1XElOxjLo/EAAGzBmaUyAAC4CnwAp5rYAALrXfRpWglQAAAANmDM0pkAAAAAAA
+ AAAAAAAGzBmaUyAAAAAAAAAAAAAADZgzNKZAAAAAAAAAAAAAABswZmlMgAAAAAAAAAAAAAA2YMzSmQAA
+ AAAAAAAAAAAAbMEzIYAAAAAAAAAAAAAADsw//9oACAECAAEFAP2bpFnd3L4CuPTIbgEFrVnufC/qre4D
+ ZTWY9Zy5kua90FZqzGIWhsI54kEz2mxSYoupBLm0tL20G7K9i8hpw9YW8wZvAwRsHufC/qYIIpkYZJlS
+ xK6fBKGfIaCnMHRyNz4hmVDBd9TazHyZ9tM+N/czPlf+Q0uZ2ERGZ84hHtNh6hzu75cMMD4XuhmRPdFM
+ rM57nTJj3TGmzIpkUTnOf0/+G+T2+T2+T2+T2+T2+T279/1O/9oACAEDAAEFAP2bhQxl8Ehul3SezmhC
+ np6OvlzJc6DqX9+wsDnS/eYknMl7Z3VjBMufrm+uZGk9nmy1CyUoAU+wlCMqV1KogxhMJXMSXGYryvqH
+ sGpMbRe0TYuHgmmyXMgmy+purmVZ256EL+7JYBBdXyafTNceXZpSldtMlyU2v590XepHrSEQChqyqlQF
+ sqRU+nc13ZOiJZLsvFlEv52M1z3Pd08UToYbqbNuJc+XFPtJEuKRafWuaOXFHZWUuKydY2Uq0lSYoooe
+ ne50TqUDUoGpQNSgalA1KBnQuhbt+pv/2gAIAQEAAQUAXxfF1Bl13G5CtuNyFbcbkK243IVtxuQrbjch
+ W3G5CtuNyFbcbkK243IVtxuQrbjchW3G5CtuNyFbcbkK243IVtxuQrbjchW3G5CtuNyFbcbkK243IVtx
+ uQrbjchW3G5CtuNyFbcbkK243IVtxuQrbjchW/kdQ2yN5C9fkbyF6/I3kL1+RvIXr8jeQvX5G8hdQNDR
+ EZERMuGEFtSWS5FpI/jkUGDeNpsZAUF1sjeQuoiAb9oZzEB0U8LRarsTAPyVDMQHRTwvI0bjBIvw0RCp
+ +pkbyF1EQDftDOYgOinhaLVdiYB+SoZiA6KeFotV2Plt4g5qZG8hdREA37QzmIDop4Wi1XYmAfkqGYgO
+ inhaLVdj5beIOamRvIXTKiN2l7IS4o3VkdTEB0U8LRarsTAPyVDMQHRTwtFqux8tvEHNTI3kLplotV2J
+ gH5KhuJF0YC8Wi1XYpki6iMLiRdGAvFotV2Plt4g5qZG8hdMtFquxMA/JUMtFquxaLVdi0Wq7FotV2LR
+ arsfLbxBzUyN5C6ZaLVdimSLqIwlotV2LRarsWi1XYtFquxaLVdj5beIOamRvIXTLRarsWi1XYtFquxa
+ LVdi0Wq7FotV2LRarsfLbxBzUyN5C6aW2U8xhRaLVdi0Wq7FotV2LRarsWi1XYtFquw8J2otfamRvIXT
+ TYbBQUyFotV2LRarsWi1XYtFquxaLVdpo0VCta6uRvIXUR4D+xAy0Wq7FotV2LRarsWi1XY+W3iDmrkb
+ yF6/I3kLqy5E+c0IOJROmh97JZ7nufrZG8hdOVNtYGnFE4hZWhie6H5Pb5PYtpyoShNMurKY0b4HvKpN
+ Nx5FL2yug290sjeQv5J5ieu6rFBVMK8hUeLMnHtUp6MkXHtUlIT5GsclgXu4WTExdEKDTwjh6XDBpXcY
+ VqRGwrOYm4lL2fwFM0ly+TowJekCjrMYxP1yZXWEn1qk4wJ/kWevX3lAIjGK2OBuVRaMwsH1DFlG0Mje
+ Qv5IuYx4pesbAM1GU7oGF/1KYYcFsa4BRWMAg7Kk/kNFF7NZmJ3r1QkxDp79elV7GI1mMp+sv1oCF6Jh
+ OAMcwDx79WJvNQqqXrp5TISrqoiOcas3N0Bezz2Pmw1BeSehkbyF/JN4YovVj63IYnIwEOfH6lcMIYnY
+ KFMg5EoSRr+7J+dmKOUsXb134tRd/XfUcyiRf8uvV3F8i/63z06+FE+PWGOE9x6uhO6G15x85xrd/aF7
+ LnPdlBoZG8hfyxdUCBLfXqpfsBsBRLcZczxJByqafYhIvCPj1mwKpCRVnzrjOicKdlXfqVj8mOVd+muP
+ 1R7GDKu/H8ZMZcq7/G0Pw2T0upFjueFlKJSBcecqhNA1JISt3BFWpYchh9UVyH/YkQz2BXM2XOuPzyN5
+ C/kGr2rAQlf4d3t3e3d7d3t3e3d7JbkatqLW6qZQrutgHqZG8hevyN5C9fkbyF6/I3kL1+RvIXr1H/2H
+ 1/8A/9oACAECAgY/APybrafTSSH9Kk+4VxLy823sin2FgaJm5fKFHWBxD2rcUQwIPSscq/vcuaU75SB7
+ FQHtqOPS/bsP1WIAxubk4YspPbSAgBrC4GQO7d/GBZuWRTwyA2LWvcZixU7Qb/CjfkSo21ZWHZYjsq8M
+ bKuwsG7eFelfudWfCiErgT4sAMtxOdFIJv7mwix7c/VWdTRSz2kTMWPXs21C8jESPxfSNje4sCDuJsDf
+ DrGVFSLEdKVFHiJtU8cihgim1xfEFRf31o3hULcLe2GZIPtGFZ1M0ihlzxxF+EVoAosAW/20ZE8ri/r6
+ /j0qJ7Xxt7cK1D7QfeK077APeazqR93cK0+4nupJOLEYem/SbUGJuRTSBsTSyFsRWdGTixNLdsq4C1kr
+ Br/jb//aAAgBAwIGPwD8m4vznnmk0q/9s0cf9TCjDL93xl/0Q6mVf9UcLr20qct+79C0rZK0gic42wSX
+ gc47tm0UskUitGRcEEEEbiMD0o8Jxojl/wB5waGP9GhWRuv5pp3XrHyDL01rNZz/APzLzP8AYRRs8lo/
+ pxhFW7EpFMi2AGXD2mtQ8cjvEXPCz+crc2LYnxEYnE49ZrKsq5pNy3761/KuZ6SRQyQBuEpIDwOGWWPE
+ lZFK2NrA38WCgf5Wm1EQ+WfRQyX9L/UWTd564OZayGaXDxRxNEN91Msu7Ijr24dJPJft1AZtRqEWW7Kg
+ EIDs1yxGHGsYIW5IJFiL0uo5py7/AMZIH1EYOgJyBK4qdnEACcATXkNct12g5Xx6PVE8D8aAAKSCXubo
+ MDa4xtYAkgHmen0cMbaSAwjXRiSMgxuHaNgSRd0XideGzDFWwaxSWNg0bAEEZEHEEdKn1U7WijUsTuH8
+ 4VyzV6Wd4ZNTNGW4GKngZJG4LjG1wvptjX3JpuYzPMVaULxksQFjjdQCcbK92Gw7q/465dDop3ilJCkq
+ SrcJlckAjEXyNsxcHAmvuySZi0kiQ3JJJNhPmTic6TSakkyaV/pgnrSwKewHh9XStfpvqFSF4vWvisdx
+ tj6b1ybT28rR9kbjvrnOnt5mk7Y0HdXlrR6W2TD+tjXORbzKnYJPjWp0QhJSSzXHylcDfcbj19RvQIOH
+ SCxyFPCkfCjZ7T7s6h0jRWRLWN9gI76m0ixXR73N9oA7q8tJojF4FOd95PfUwSK/Ha+Oy/xr9wkRbUHD
+ Pqvl39dWMPBbq6RY5VlWVZVlWVZVh+J3/9oACAEBAQY/AM6WhozpzZamlqzZzGbWtrbcxqwQtza3Iawe
+ UqJAgRJXkpMjRI0xQSyiiwhAWAMAhhCEIQt08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6c
+ t08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/T
+ lunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6
+ ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/
+ TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct08Zze9Ct/TlunjOb3oVv6ct/HlZ/wDqa5x/4ofOkP8A
+ 58/Xv4z5U/Xv9bbPj2zZoeu759P+TPbPj2zZoeu759P+TPbPj2zZoeu759P+TPbPj2zZoeu759P+TPbP
+ j2zZoeu759P+TPbPj2zZoeu75wqBoaEC11dnValbWtrbUp65xcnFceWlRIECJKWapWLVik0JZRRYRDMG
+ KAQwjGMIWQrnhhemlE56mGq3NrXIErheM7HUJcioVEFFK9dgqZtXQu4i0o3BMd/ozyhDpdOnpdasLWLa
+ QXiEvpBxqA9QfUDj2UHRUWWqdOyhVqlSiUqatGFMmCNyThTuQE6cC8heWXWrRS9ONb1CfZcsly5Qa01e
+ +YTt410WQB5XJGyhUNSCZVlSVenLSBSNS2+m05CA92vUytamf4pVrg3mokzktOS01WyMhnblbDly+EL3
+ JwfaWZ2mSMMzRa0YTU6g8A1BxRgYiRrmtUv4X5M9s+PbNmh67vnCqyMJxjV2J/R9n9o9Wazey1bv1Pmj
+ zk1Jydlf3aVMzEr+0JjA3ZxWbPXGpRjMpntjpS7vGPsqGzeK93Rgur3H9eYx5PeYlrz6jEpitKU3UmJj
+ m+6vpyZnO6N4Rqhnp7aHlSaxTjTFN+AI9npvTRmQSmR2OxDTi75kaVN4V3dKu043iupMYDHFJzUn6mnJ
+ eonFZs9calGMyme2OlLu8Y+yobN4r3dGC6vcf15jHk95iWvPqMSmK0bTYkLWgx1WoEqVKvozM5ceMh1c
+ crUTS5FipqhH9MrROqbN1rWJgpzDlBycQAhKievZyHItK6IFrapNRNrkUnXpT0Z5jc8tyV3aF5ZSgssw
+ aJ1aVxCpMbCGoenOAYCIgDCKPB/Jntnx7Zs0PXd84VWRhOMauxP6Ps/tHqzWb2Wrd+p80ecmpOTsr+7S
+ pmYlf2hMYG7OKzZ641KMZlM9sdKXd4x9lQ2bxXu6MF1e4/rzGPJ7zEtefUYlMVpSm6kxMc33V9OTM53R
+ vCNUM9PbQ8qTWKcaYpvwBHs9N6aMyCUyOx2IacXfMjSpvCu7pV2nG8V1JjAY4pOak/U05L1E4rNnrjUo
+ xmUz2x0pd3jH2VDZvFe7owXV7j+vMY8nvMS159RiUxWlKbqTExzfdX05MzndG8I1Qz09tDypNYpxpim/
+ CEqUktejMuFNzh+Ga87l5S6ybltkaJvJ+/v5iSOm7y/n3W8xRZwfyZ7Z8e2bND13fOFVkYTjGrsT+j7P
+ 7R6s1m9lq3fqfNHnJqTk7K/u0qZmJX9oTGBuzis2euNSjGZTPbHSl3eMfZUNm8V7ujBdXuP68xjye8xL
+ Xn1GJTFaUpupMTHN91fTkzOd0bwjVDPT20PKk1inGmKb8AR7PTemjMglMjsdiGnF3zI0qbwru6VdpxvF
+ dSYwGOKTmpP1NOS9ROKzZ641KMZlM9sdKXd4x9lQ2bxXu6MF1e4/rzGPJ7zEtefUYlMVpSm6kxMc33V9
+ OTM53RvCNUM9PbQ8qTWKcaYpvwhKlJLXozLhTc4fhmvO5eUusm5bZGibyfv7+Ykjpu8v591vMUWcH8me
+ 2fHtmzQ9d3zhGILy2VM4qXZawGRNZ02ZTYQNuqRx7PxqFKQnLyAq8wa0ppzaOIienNWgUqFKM9KSeATS
+ nqcxpVtmNmnMuUr4AjZF4c9RLWFe5QuaEGFvmSGZ639IRVGWjvwNAUblf3aQ55SqyWt7cVmz1xqUYzKZ
+ 7Y6Uu7xj7Khs3ivd0YLq9x/XmMeT3mJa8+oxKYrSlN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfgCPZ
+ 6b00ZkEpkdjsQ04u+ZGlTeFd3SrtON4rqTGAxxSc1J+ppyXqJxWbPXGpRjMpntjpS7vGPsqGzeK93Rgu
+ r3H9eYx5PeYlrz6jEpitKU3UmJjm+6vpyZnO6N4Rqhnp7aHlSaxTjTFN+EJUpJa9GZcKbnD8M153Lyl1
+ k3LbI0TeT9/fzEkdN3l/Put5iizg/kz2z49s2aHru+cJSm6kxMc33V9OTM53RvCNUM9PbQ8qTWKcaYpv
+ wBHs9N6aMyCUyOx2IacXfMjSpvCu7pV2nG8V1JjAY4pOak/U05L1EiZ0LDKLX5lpJsSOWwLwouFT0h7J
+ qVOuvKe7MRT+r1zamgZpQuQ1inEvzKlYY5hNrWlN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfhoeBsM
+ 4idmXKBsTtuwLws0Kkq7s1Kla67P7MVUsCzHiq7IL0pm1SsWTX6Spfi3JIVVaJnQsMotfmWkmxI5bAvC
+ i4VPSHsmpU668p7sxFP6vXNqaBmlC5DWKcS/MqVhjmE2taU3UmJjm+6vpyZnO6N4Rqhnp7aHlSaxTjTF
+ N+EJUpJa9GZcKbnD8M153Lyl1k3LbI0TeT9/fzEkdN3l/Put5iizg/kz2z49s2aHru+cJSm6kxMc33V9
+ OTM53RvCNUM9PbQ8qTWKcaYpvwBHs9N6aMyCUyOx2IacXfMjSpvCu7pV2nG8V1JjAY4pOak/U05L1FSm
+ 6kxMc33V9OTM53RvCNUM9PbQ8qTWKcaYpvxSm6kxMc33V9OTM53RvCNUM9PbQ8qTWKcaYpvxSm6kxMc3
+ 3V9OTM53RvCNUM9PbQ8qTWKcaYpvxSm6kxMc33V9OTM53RvCNUM9PbQ8qTWKcaYpvxSm6kxMc33V9OTM
+ 53RvCNUM9PbQ8qTWKcaYpvwhKlJLXozLhTc4fhmvO5eUusm5bZGibyfv7+Ykjpu8v591vMUWcH8me2fH
+ tmzQ9d3zhKU3UmJjm+6vpyZnO6N4Rqhnp7aHlSaxTjTFN+Gh4GwziJ2ZcoGxO27AvCzQqSruzUqVrrs/
+ sxVSwLMeKrsgvSmbVKxZNfpKl+LckhVV0pupMTHN91fTkzOd0bwjVDPT20PKk1inGmKb8UpupMTHN91f
+ TkzOd0bwjVDPT20PKk1inGmKb8UpupMTHN91fTkzOd0bwjVDPT20PKk1inGmKb8UpupMTHN91fTkzOd0
+ bwjVDPT20PKk1inGmKb8UpupMTHN91fTkzOd0bwjVDPT20PKk1inGmKb8ISpSS16My4U3OH4ZrzuXlLr
+ JuW2Rom8n7+/mJI6bvL+fdbzFFnB/Jntnx7Zs0PXd84SlN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTf
+ ilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1Ji
+ Y5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6
+ cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfhCVKSWvRmXCm5w/DNe
+ dy8pdZNy2yNE3k/f38xJHTd5fz7reYos4P5M9s+PbNmh67vnCU8tUU2icDI1MjZwmIMvW5UQeQ01l2ZK
+ fSkGQa+zVmYmXLTEy4BSmIlS9QrUOI4qEYz3Qxvq6lN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN
+ 1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5v
+ ur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZ
+ zujeEaoZ6e2h5UmsU40xTfghUkQ4eUUy042DI1GcF4qZaea2dcu0MbHTyKOJrUBinSMgxYK90q1K1VE5
+ YfwfyZ7Z8e2bND13fOESxf0yI1vcFtNJTlrkmYVbczkI62pZ9cHJeQ+Zc5omGIsJZ1Cc0KNrOUDAfEJh
+ S5GJU1r6U3UmJjm+6vpyZnO6N4Rqhnp7aHlSaxTjTFN+KU3UmJjm+6vpyZnO6N4Rqhnp7aHlSaxTjTFN
+ +KU3UmJjm+6vpyZnO6N4Rqhnp7aHlSaxTjTFN+KU3UmJjm+6vpyZnO6N4Rqhnp7aHlSaxTjTFN+KU3Um
+ Jjm+6vpyZnO6N4Rqhnp7aHlSaxTjTFN+Gox2b2UxyQstDvkWA5gppG8OqU5n7Nz6QBPCpOzAc2mY62tb
+ uaSesUqkaoqKs0w5wJVKDKz4T5M9s+PbNmh67vnCsRuz2K3tZnJr7Y7H77RmH2bkcpM93TNiZ0Y1cS86
+ t0T9xIBn8LqylN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU
+ 40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfilN1JiY5vur6cmZzujeEaoZ6e2h5UmsU40xTfh
+ CVKSWvRmXCm5w/DNedy8pdZNy2yNE3k/f38xJHTd5fz7reYos4T5M9s+PbNmh67vn0/5M9s+PbNmh67v
+ nDaCiTDP8gAhf4IRtpgmjCH84wkEfwDMDG0YmJToQh54hDEYfNp/KBrQ81tEYRhGHnhHyR4b5M9s+PbN
+ mh67vnCfbSjNj/OURCH733gFBj+OyCuFeXr430e6OSVoaqpXtS9KyOjksTrliZI1uqxIBM4GmJm08f5k
+ Y4BCXHTGHk0hhHRCOiGmAYw1YR0eWEPJDyabef8AHC3n/HCz4KhqFdKyJpppMe34bYnCoi2ICryOuaEQ
+ dJhxwShRJJL1zztQd2AWqLRH9nBBH6y1AwaP83UiD8VvzYRAh9QhwH+CMAAsFkoul6gqx3ECJsGynGdw
+ elwSYCCAR40zcnUGlpwCFDWMFCAA6fLGFlbcuIGmWoFShEsTGQhAxOqSmjIUEGQhGMIDKNBEMfL54cF8
+ me2fHtmzQ9d3z7turnL+i9o6ec306niFCd6Ykx5K1OKIFJyxKvcUhyRvTjhCA1A4QLDrQ8uiNj6yqyj0
+ 59NIQFDdXSn3luewMwTjIFBG5pUp0+QnCMUIDPCUNOCIoaxkNMLKs/S2VHHLFEeFMoeYvLVBYE4VRJqV
+ CGDPFVigoY0rAXpgVo1Y6/5MIxtW2aFJsqNdRuXpDupqlwPeWpCeiJYmSFQuQiUCtUUtWxJao68IFAFE
+ Yvsh0i8llxeWtJnOyFqOKIdn1asRNDE2nHAvAEHOTieQWoV3cYCiQngeoCAUBRBqxhGxT9XtIQLpo08h
+ JtKyOSF8ZyFajyFJlxiI4atsEYPQAAlJJJRpkYBAIQo6LdmGkcvmpO6vCKOXj8rgrckDWlQNSXL+q249
+ wPPXnkwMLKVupANQqBp0YmQjAEYQFGBTzXVK3NPHHEpoVEzr0byzlKlGm6TLDkZolDcYYKGqCKgooBg/
+ sgEKNvyvx2o6qKUoyDrT1biV4Q7lvDQWkSkoT1CdSqeomLAmtCcJqQyAInBgI0QdUuAhiCGOddC5Tq21
+ remJhYm/M0lG+0irTAQVC2O7mwGEHO8TQhcQtwFQizU8AK0sDYw0giOGmNK5bUutqV4KIirWAJMSo0Ta
+ iCMJYljm5uB6Rub094KAQxNNDEwcYBBAQowDEk1LRLI9jN0a6dsralCjk+mGn88J5dGhOLRHyfmxj8v8
+ ls3qNqpKlQ1EwZemIXdCjd2d8KRLQ1NTgzUg3JhXubWapTRHqHAAcIRJsBFjgEwIgwrGrENFtSlOvqKo
+ XZG0lVZTsXpQhVOatWnMLTxXwRxNNTjgKBV/faY6urr/AGbI2V0o4K2n8u6sYIZtMT8qLZFbc0GOqlK4
+ IVTerUIXI5QGLceWYSVC+DEOiMIRjCzvVeTeXVKs2WDLRraOCdocaZpxOQYzoVSl6OCzxUpFBqgUYRGM
+ yJYhnj8ukUY8B8me2fHtmzQ9d3z7vMV/pl3XsT2idaiLROzWpMRuKKC+qmBuVDRqyYhPSnjRqzABMLEE
+ wvW1gCCKEIw7TjBWT+71UztrGaWgQ1C4KncpGS+UpVUHZMnEvMPMKSrooyxDKgKBevrCgGAhjiKpP6aI
+ /t6YLdr7+hc0/wCx8u1V5V5KVAVTmb1PODvB7JRuIWh2dTF1VDqRNAS4oZKlCRU1Lhg1EqoiAUMxKMkZ
+ gSwmauZ3Zczcol/qR1eBPzcldauflqZ9oo9amQCRIDWh1aVxy9G1vSMS4mMVJIoDPjEEdWALdnUdLv7t
+ T57uLLdidFLOuUNyla0mUHVLka3mqUoyj4JTlrWQMYYChAd3CEdIYxhHtCbZu7lVImJbXSBoMfVh7meh
+ RtVIUdUTYmJUKxmn3Te9KhqCYRFG7HH7OiEIQh54/htQK+mXpxYV689G0qF7SrOQL4t6uuH8atKUtTCL
+ UkAVQTwAbqCDEwqIgC0gEKEe06ucVipetPaaAGoWLVBqpUeOQzLDAZyg8YzTRQCGENIoxjohbtVVM0Di
+ 3vyZpXqUrsl/NLk57RQz8ubTClAfthEiWnjNL0fkjHGP37Zms7pUj45tamiIPp6BxdFq5MY8l1E0pQug
+ ilRxoZ+KdYaARv5Ywj0CjHRDR2gv6Gqv+0VtszAcMwKuWp3zNOo2V2Qqn5xPbVzOYqdk4Ws5rMPE3Yen
+ JJLgQTAqBae6LiVAESwRDTqZlVq2lM/1rlAY9pm5UoRpnYRrKwgNxBOnMLJVhNhpiKAwxgIQhCjCIhCj
+ F4a2ypagbm0dGUrrtyB5cUiEd+jUQP1kidSWnFfQ8g9IftQ8/AfJntnx7Zs0PXd8+7zOgEIhRg8PAowD
+ CMY6oK2pkYxaIf4oQBjGMfvQhpt2qBxCLUEzoQhFojqxEGlayiIMBeaIgwHDTD72mH12qYIIRGILyVEQ
+ Qw1ohgDPdhMHGMIaYwgEuGtH6g+XzW7Xo4hFAAmfNUIRaI6ohAyeJiIMBeaIgwHCMYfe0w+u1KdqiiF4
+ afpd0GWlSPzS9IDThlKnRU3YXUFOKxQE4tqtwa9AyTCFCeMYFjjojCAg1tmrVdJtdK5t5RN9RlhqdugI
+ khQqpin01UmlhUD0nDpt8RHiLEkUjPigPiMwsXmEPswx+t5y0/HlpXUbdp6P1POZf4stKFjbzwtlmLTx
+ y1eu1T27Tf8AIzZff7lmdbMvIRzph5fqezNYDla9yZIkF7OJCUShgelLyccemGnanBE8FFAPLEM0lUEs
+ ACxxO0gzCf6AzNqXN/MByb1DAhYiEwjkpZKVZNEt+PImNupuBJrgQTNLIHnCuytYgiPlAPNp5W3c670I
+ 4Oau5BdlTS+smRWoui9ItQu9Njqw0x0QtSPtmf8A+sHq1Df95ZO/1QxWdIxhGEI0XSEYaYeeEqphph9c
+ NMIw/vcB8me2fHtmzQ9d3z7uqK8Op1tq5Mw1FUMV1MvEYBbX1tcqlZWdybVYhJ1ZYS1KBwMDCIyTi4C0
+ a5Yw6QRfsqslckqYyXaKtRrkNRKmY9q1IJXdPBE8lNTSyU3TzenWuKEMSDFpkDDboUdQABhAYF/y2qmh
+ GrNDLOoFSlaZTjkqIRmoVS8klM5lhGsa3lC5tLkSnBeozyNS8hEYRh1jIDzCytojIWiKCy9rKjKhpVta
+ 2FaW2KWVZU7S5tLq/GlNDG3Mq0Rpa4swKYCQgQRlRgI8zXhEKrKSvMv2LODKtQeoNSU0/HJyRtQFyoS5
+ cjLgvanxrcmk9eMSmVPTaQqBjEE0MBaIOGUOUOVNNZKUG9awH5OwmN8VTmlPiAxchTJGdkYGpnTOIwBA
+ qiAs45QUDViYEAxgjlpkIfRqJoSZcLKbVk1KU9nLFLtGnacfKdAA1sG2pykkFQHqJsYwPM1IlwD5dOmG
+ ZeQhFGondJmOsqRWdUpr2cjUtMaipxjp0YCmwDaoKVwSgZYGwjE8vXiZEPk0aY+eH4bU32bB0aiTIqdW
+ JVYKtC9nmqlUUz05PEADaItoCioDE4xL0wUC0QBp+/ohmUgRUaiq2GYyNgSHGKns5oi1QYialJAMoJTa
+ 4QVxUwqMUYwjEvVuoefW8iHtL0nQlT5w5r1HB1bBMdLOhhKptaI1OcxHsqZvCbLnElQaylisZiVWpgZE
+ MSwhKBrweKwrP/8AM9rYm8gUDnCo6noyjkyAC5xVATpzXJeqy7AIZi1xVADGMR3hgx6Ifajat8yE9DU+
+ +qa2bFrcewtphNGsTPBa9o3mMGdvamtUkRIUwkkCSUxZYAFlxhoj5PK1ZylMhDkpa6wXVaFhMXGJiDjF
+ yhYfFDFwCmOMAAuKyMLy6jGOr+T5bAz2bWomjKjSLKTcmlIkXCdi21ypBO3ltywClQkR38YqG4BsQiKg
+ Hy6sdMPOI3Mrsr0HWVdjYFVNm1EqckMCRNy4k8pUWgVLKVcKnZEJkVhwoJiF4hBEKIgnhELSE84lOUjK
+ NONNKSECPGSlLMGIYE5I1RyhSMogMYBDEwwY4wh9oUY6Yx+6+TPbPj2zZoeu759255KN9Vy+WTycaocq
+ ZwKmjZk49clcjR4yezm1ATrLURQ9BasMIauiENWMYR+488beeNvPG3njbzxt542VIss8wnim25YeJUoa
+ YkNb0yiVmFhJMWAZagQOzUSsNKAEIzQEhMHAAdIo6gdCOmszK/U1GxIHEDsnbC2Ol2FNFwLINTlKVMKb
+ Y2cS0RBJ44FwOiYEuI4xDCEYxjwnyZ7Z8e2bND13fPp/yZ7Z8e2bND13fPp/yZ7Z8e2bND13fPp/yZ7Z
+ 8e2bND13fPp/yZ7Z8e2bND13fPp/yZ7V5/6mv4zqjpH6Q/34u/jz/rP/AIp/t17b4M9vgz2+DPb4M9vg
+ z2+DPb4M9vgz2+DPb4M9vgz2+DPb4M9vgz2+DPb4M9vgz2+DPb4M9vgz2+DPb4M9vgz2+DPb4M9vgz2+
+ DPb4M9vgz2+DPb/4Z/8Ahn/d/wDTO3//2Q==
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+EM4EV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDg6NTEAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAALtgAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUpJJJJSkkkklKSSAc47WguJ7ASfuCYEHUahJ
+ S6SSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv+Oq/6tiSn/9HWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW
+ 9CSUpJJJJSkkkklKSSSSUpJJJJSkkkklNrEA9Nzu5dBPkA2P+qUMtoD2u7uBB8PbEf8AVImJ/NH+ufyM
+ UMzmv+1/3xJTXSSSSUpJJJJSkXE/pmN/x1X/AFbEJFxP6Zjf8dV/1bElP//S1sv+mZP/AB1v/VvQkXL/
+ AKZk/wDHW/8AVvQklKSSSSUpJJJJSkkkklKSSUmVvsJDBMansB8ykpikQRoQR8RCuVYzGQT73zodY+Tf
+ /JKNoF7wxvDD+ksHb/g2n99JS+J/NH+ufyMUMzmv+1/3xWGta0bWiAOyr5n+D/tf98SU10kkklKSSSSU
+ pFxP6Zjf8dV/1bEJFxP6Zjf8dV/1bElP/9PWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkk
+ kklKSSSSUuxu97WAxuIE8xKvMY1jQ1ugHjz8SqVP89X/AFh+VX0lI7WWWeyQyvQkjUu/k/yFNrQ1oa3Q
+ DhOmc5rGlztAOfH5JKWseK2F5EgaQPE8Ki97nu3OMk+HHyUrbXWuk6AfRb4KCSlJJJJKUkkkkpSLif0z
+ G/46r/q2ISLif0zG/wCOq/6tiSn/1NbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUpJ
+ JJJTKn+er/rD8qvrPY7a9rudpBj4Kx9sb+477wkpsKnkucbi0nRsbR4SAf8AvyJ9sb+477wgWvD7HPAg
+ GND5AN/gkpikkkkpSSSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv8Ajqv+rYkp/9XWy/6Zk/8AHW/9W9CR
+ cv8ApmT/AMdb/wBW9CSUpJJO1pcYHzKQF6BEpCIMpGgNyskncACQFL0L/R9f0rPR/wBLsds+O+NqRFGl
+ RIlESG0gCPqwSUjTcNgNbx6v81LT7/8AitP0n0vzEvRuIsit81fzvtPs/wCN0/R8fnpJYpKxk0Tk2Nxc
+ e9lbdo9OxpNjS4R7w3dt9R/82g21W0v2XVuqfzte0tOvHtckpikp20ZFO03VWVB30S9rmz8NwVnpOFVm
+ 5ZpuLgxtbrPaYJLS3Sdf3klNNJSooyL2b6qbLQ36RrY5wB/sgq50rp7cx11tosdRjsL3NqEue4cUsP7/
+ AP00lNFJX7umWvxzm4uPdXW6wVsxS1z7AIl9znfublQSUpJJJJSkXE/pmN/x1X/VsQkXE/pmN/x1X/Vs
+ SU//1tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJS7RuMcIoAAgIKIx86HnxUmMgadT1aXO48kgJRN
+ wjvD/u/6y7mgjgH491vXZeU937R6c/7RiisMvwXf4PT3TQ3/AF/4ypc+57mu0AMEaHy8VrU9S6Rj5R6h
+ QLa7Swt+xNaAzcR/pANvp7kZSjfktw4c3CDfplwker1R/dl/6A2enMbdidMvfqzAdaLHHs1rXen/ANTU
+ m6pX9mx+o2tENzrqQw+I2sfZ/wCjVn4XVRj9NzcR49+RJq2j2gvb6dk/uN/dS6j1VuXhYWOzduxwPW3C
+ AXNa1jSz97/CJti2cY8nBX6Vd/0uH23WyrLKsjrVlTix7aKSHDkHbZwo4Jdezo1t5Ntgsv8Ae/3O0bbt
+ 9x/qMQ68zEzXdXyDvbjOpqDiB7wALGuIaVVb1bExX4FeMLL6MNz3WWPAa53qBzXem32/R9TchYr+XZcI
+ T4r6a9f9Zxf9BJc7Lr6VmHqT3F2VYBiVWmXy1251jWf4Nn/kEH6ux+0H/wDEWflYh5mR0w13Oqdbl5V5
+ 9t14/mmTu2M3f5qH0nOpw8t11+7YanMG0SZcWx/1KVhQhOx2Hi6VNXUHYXRWYLn1V7DZkPadrAJqeXXf
+ mu3Tb+j/AMInpymvyet24jy2r0S9hYYG8NLX3sj85z2fzip1Z2Bf0/FxM6y6oYg2vqqE13NG2G2R/V/6
+ tDo6hi1u6iW1GmvLpNWPUwSG6OY3fH0f33oWvET/AC8k32vLH1eZYL7RZ9rLd4e7dt2u9m6forJ/itDE
+ ycB/TjgZrrKg2712WVN3TpBYdHfylQdG4hpJbJ2kiCR2JbLtqSaKySSSCQpFxP6Zjf8AHVf9WxCRcT+m
+ Y3/HVf8AVsSS/wD/19bL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKJJ5SSSSVtoFJJJJKZMu
+ urY9lb3MZaIsaDAcPB/3qKSSSlJJJJKUkkkkpSSSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv+Oq/6tiSn
+ /9DWy/6Zk/8AHW/9W9CVnKxcs5eQRj3EG60gip5BBe/X6CH9kzP+413/AG0//wAgkpEki/ZMz/uNd/20
+ /wD8gl9kzP8AuNd/20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP
+ /wDIJfZMz/uNd/20/wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8
+ gl9kzP8AuNd/20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDI
+ JfZMz/uNd/20/wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEi4n9Mxv8Ajqv+rYl9kzP+
+ 413/AG0//wAgiYuLljLxyce4AXVEk1PAAD2a/QSU/wD/2f/tFbpQaG90b3Nob3AgMy4wADhCSU0EBAAA
+ AAAALxwBWgADGyVHHAFaAAMbJUccAVoAAxslRxwBWgADGyVHHAFaAAMbJUccAgAAAgAAADhCSU0EJQAA
+ AAAAEG6zct75/3bD0NwiSL8rfdM4QklNBDoAAAAAAJsAAAAQAAAAAQAAAAAAC3ByaW50T3V0cHV0AAAA
+ BAAAAABQc3RTYm9vbAEAAAAASW50ZWVudW0AAAAASW50ZQAAAABDbHJtAAAAD3ByaW50U2l4dGVlbkJp
+ dGJvb2wAAAAAC3ByaW50ZXJOYW1lVEVYVAAAABMAQwBhAG4AbwBuACAATQBQADEANAAwACAAcwBlAHIA
+ aQBlAHMAAAA4QklNBDsAAAAAAbIAAAAQAAAAAQAAAAAAEnByaW50T3V0cHV0T3B0aW9ucwAAABIAAAAA
+ Q3B0bmJvb2wAAAAAAENsYnJib29sAAAAAABSZ3NNYm9vbAAAAAAAQ3JuQ2Jvb2wAAAAAAENudENib29s
+ AAAAAABMYmxzYm9vbAAAAAAATmd0dmJvb2wAAAAAAEVtbERib29sAAAAAABJbnRyYm9vbAAAAAAAQmNr
+ Z09iamMAAAABAAAAAAAAUkdCQwAAAAMAAAAAUmQgIGRvdWJAb+AAAAAAAAAAAABHcm4gZG91YkBv4AAA
+ AAAAAAAAAEJsICBkb3ViQG/gAAAAAAAAAAAAQnJkVFVudEYjUmx0AAAAAAAAAAAAAAAAQmxkIFVudEYj
+ Umx0AAAAAAAAAAAAAAAAUnNsdFVudEYjUHhsQFIAAAAAAAAAAAAKdmVjdG9yRGF0YWJvb2wBAAAAAFBn
+ UHNlbnVtAAAAAFBnUHMAAAAAUGdQQwAAAABMZWZ0VW50RiNSbHQAAAAAAAAAAAAAAABUb3AgVW50RiNS
+ bHQAAAAAAAAAAAAAAABTY2wgVW50RiNQcmNAWQAAAAAAADhCSU0D7QAAAAAAEABIAAAAAQACAEgAAAAB
+ AAI4QklNBCYAAAAAAA4AAAAAAAAAAAAAP4AAADhCSU0D8gAAAAAACgAA////////AAA4QklNBA0AAAAA
+ AAQAAAB4OEJJTQQZAAAAAAAEAAAAHjhCSU0D8wAAAAAACQAAAAAAAAAAAQA4QklNJxAAAAAAAAoAAQAA
+ AAAAAAACOEJJTQP1AAAAAABIAC9mZgABAGxmZgAGAAAAAAABAC9mZgABAKGZmgAGAAAAAAABADIAAAAB
+ AFoAAAAGAAAAAAABADUAAAABAC0AAAAGAAAAAAABOEJJTQP4AAAAAABwAAD/////////////////////
+ ////////A+gAAAAA/////////////////////////////wPoAAAAAP//////////////////////////
+ //8D6AAAAAD/////////////////////////////A+gAADhCSU0EAAAAAAAAAgAGOEJJTQQCAAAAAAAQ
+ AAAAAAAAAAAAAAAAAAAAADhCSU0EMAAAAAAACAEBAQEBAQEBOEJJTQQtAAAAAAAGAAEAAAAfOEJJTQQI
+ AAAAAAAaAAAAAQAAAkAAAAJAAAAAAgAAD6ABAAAPsAA4QklNBB4AAAAAAAQAAAAAOEJJTQQaAAAAAANJ
+ AAAABgAAAAAAAAAAAAAA+gAAAPoAAAAKAHMAdwBpAHAAZQBfAGwAZQBmAHQAAAABAAAAAAAAAAAAAAAA
+ AAAAAAAAAAEAAAAAAAAAAAAAAPoAAAD6AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAA
+ EAAAAAEAAAAAAABudWxsAAAAAgAAAAZib3VuZHNPYmpjAAAAAQAAAAAAAFJjdDEAAAAEAAAAAFRvcCBs
+ b25nAAAAAAAAAABMZWZ0bG9uZwAAAAAAAAAAQnRvbWxvbmcAAAD6AAAAAFJnaHRsb25nAAAA+gAAAAZz
+ bGljZXNWbExzAAAAAU9iamMAAAABAAAAAAAFc2xpY2UAAAASAAAAB3NsaWNlSURsb25nAAAAAAAAAAdn
+ cm91cElEbG9uZwAAAAAAAAAGb3JpZ2luZW51bQAAAAxFU2xpY2VPcmlnaW4AAAANYXV0b0dlbmVyYXRl
+ ZAAAAABUeXBlZW51bQAAAApFU2xpY2VUeXBlAAAAAEltZyAAAAAGYm91bmRzT2JqYwAAAAEAAAAAAABS
+ Y3QxAAAABAAAAABUb3AgbG9uZwAAAAAAAAAATGVmdGxvbmcAAAAAAAAAAEJ0b21sb25nAAAA+gAAAABS
+ Z2h0bG9uZwAAAPoAAAADdXJsVEVYVAAAAAEAAAAAAABudWxsVEVYVAAAAAEAAAAAAABNc2dlVEVYVAAA
+ AAEAAAAAAAZhbHRUYWdURVhUAAAAAQAAAAAADmNlbGxUZXh0SXNIVE1MYm9vbAEAAAAIY2VsbFRleHRU
+ RVhUAAAAAQAAAAAACWhvcnpBbGlnbmVudW0AAAAPRVNsaWNlSG9yekFsaWduAAAAB2RlZmF1bHQAAAAJ
+ dmVydEFsaWduZW51bQAAAA9FU2xpY2VWZXJ0QWxpZ24AAAAHZGVmYXVsdAAAAAtiZ0NvbG9yVHlwZWVu
+ dW0AAAARRVNsaWNlQkdDb2xvclR5cGUAAAAATm9uZQAAAAl0b3BPdXRzZXRsb25nAAAAAAAAAApsZWZ0
+ T3V0c2V0bG9uZwAAAAAAAAAMYm90dG9tT3V0c2V0bG9uZwAAAAAAAAALcmlnaHRPdXRzZXRsb25nAAAA
+ AAA4QklNBCgAAAAAAAwAAAACP/AAAAAAAAA4QklNBBQAAAAAAAQAAAAgOEJJTQQMAAAAAAvSAAAAAQAA
+ AKAAAACgAAAB4AABLAAAAAu2ABgAAf/Y/+0ADEFkb2JlX0NNAAH/7gAOQWRvYmUAZIAAAAAB/9sAhAAM
+ CAgICQgMCQkMEQsKCxEVDwwMDxUYExMVExMYEQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM
+ DAwMAQ0LCw0ODRAODhAUDg4OFBQODg4OFBEMDAwMDBERDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwM
+ DAwMDAwMDAz/wAARCACgAKADASIAAhEBAxEB/90ABAAK/8QBPwAAAQUBAQEBAQEAAAAAAAAAAwABAgQF
+ BgcICQoLAQABBQEBAQEBAQAAAAAAAAABAAIDBAUGBwgJCgsQAAEEAQMCBAIFBwYIBQMMMwEAAhEDBCES
+ MQVBUWETInGBMgYUkaGxQiMkFVLBYjM0coLRQwclklPw4fFjczUWorKDJkSTVGRFwqN0NhfSVeJl8rOE
+ w9N14/NGJ5SkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2N0dXZ3eHl6e3x9fn9xEAAgIBAgQEAwQFBgcH
+ BgU1AQACEQMhMRIEQVFhcSITBTKBkRShsUIjwVLR8DMkYuFygpJDUxVjczTxJQYWorKDByY1wtJEk1Sj
+ F2RFVTZ0ZeLys4TD03Xj80aUpIW0lcTU5PSltcXV5fVWZnaGlqa2xtbm9ic3R1dnd4eXp7fH/9oADAMB
+ AAIRAxEAPwDaysrLGXkAZFwAutAAteAAHv0+mh/a8z/uTd/26/8A8mll/wBMyf8Ajrf+rehJKS/a8z/u
+ Td/26/8A8ml9rzP+5N3/AG6//wAmhJJKS/a8z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS/a8z/uTd
+ /wBuv/8AJpfa8z/uTd/26/8A8mhJJKS/a8z/ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a8z/uTd/2
+ 6/8A8ml9rzP+5N3/AG6//wAmhJJKS/a8z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS/a8z/uTd/wBu
+ v/8AJpfa8z/uTd/26/8A8mhJJKS/a8z/ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a8z/uTd/26/8A
+ 8miYuVlnLxwci4g3VAg2vIIL2afTVZFxP6Zjf8dV/wBWxJT/AP/Q1sv+mZP/AB1v/VvQkXL/AKZk/wDH
+ W/8AVvQklKSSSSUpJJJJSkkkklKSSSSUpJJJJSkkgHOO1oLiewEn7gmBB1GoSUukkkkpSSSSSlIuJ/TM
+ b/jqv+rYhIuJ/TMb/jqv+rYkp//R1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSkkk
+ klKSSSSUpJJJJTaxAPTc7uXQT5ANj/qlDLaA9ru7gQfD2xH/AFSJifzR/rn8jFDM5r/tf98SU10kkklK
+ SSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HVf9WxJT//0tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSk
+ kkklKSSSSUpJJJJSkklJlb7CQwTGp7AfMpKYpEEaEEfEQrlWMxkE+986HWPk3/ySjaBe8Mbww/pLB2/4
+ Np/fSUvifzR/rn8jFDM5r/tf98VhrWtG1ogDsq+Z/g/7X/fElNdJJJJSkkkklKRcT+mY3/HVf9WxCRcT
+ +mY3/HVf9WxJT//T1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSkkkklLsbve1gMbi
+ BPMSrzGNY0NboB48/EqlT/PV/wBYflV9JSO1llnskMr0JI1Lv5P8hTa0NaGt0A4TpnOaxpc7QDnx+SSl
+ rHitheRIGkDxPCove57tzjJPhx8lK211rpOgH0W+CgkpSSSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv8A
+ jqv+rYkp/9TWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUyp/nq/6w/Kr6z2O
+ 2va7naQY+CsfbG/uO+8JKbCp5LnG4tJ0bG0eEgH/AL8ifbG/uO+8IFrw+xzwIBjQ+QDf4JKYpJJJKUkk
+ kkpSSSSSlIuJ/TMb/jqv+rYhIuJ/TMb/AI6r/q2JKf/V1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQk
+ lKSSTtaXGB8ykBegRKQiDKRoDcrJJ3AAkBS9C/0fX9Kz0f8AS7HbPjvjakRRpUSJREhtIAj6sElI03DY
+ DW8er/NS0+//AIrT9J9L8xL0biLIrfNX877T7P8AjdP0fH56SWKSsZNE5NjcXHvZW3aPTsaTY0uEe8N3
+ bfUf/NoNtVtL9l1bqn87XtLTrx7XJKYpKdtGRTtN1VlQd9Eva5s/DcFZ6ThVZuWabi4MbW6z2mCS0t0n
+ X95JTTSUqKMi9m+qmy0N+ka2OcAf7IKudK6e3MddbaLHUY7C9zahLnuHFLD+/wD9NJTRSV+7plr8c5uL
+ j3V1usFbMUtc+wCJfc537m5UElKSSSSUpFxP6Zjf8dV/1bEJFxP6Zjf8dV/1bElP/9bWy/6Zk/8AHW/9
+ W9CRcv8ApmT/AMdb/wBW9CSUu0bjHCKAAICCiMfOh58VJjIGnU9WlzuPJICUTcI7w/7v+su5oI4B+Pdb
+ 12XlPd+0enP+0YorDL8F3+D0900N/wBf+MqXPue5rtADBGh8vFa1PUukY+UeoUC2u0sLfsTWgM3Ef6QD
+ b6e5GUo35LcOHNwg36ZcJHq9Uf3Zf+gNnpzG3YnTL36swHWixx7Na13p/wDU1JuqV/ZsfqNrRDc66kMP
+ iNrH2f8Ao1Z+F1UY/Tc3EePfkSato9oL2+nZP7jf3Uuo9Vbl4WFjs3bscD1twgFzWtY0s/e/wibYtnGP
+ JwV+lXf9Lh9t1sqyyrI61ZU4se2ikhw5B22cKOCXXs6NbeTbYLL/AHv9ztG27fcf6jEOvMxM13V8g724
+ zqag4ge8ACxriGlVW9WxMV+BXjCy+jDc91ljwGud6gc13pt9v0fU3IWK/l2XCE+K+mvX/WcX/QSXOy6+
+ lZh6k9xdlWAYlVpl8tdudY1n+DZ/5BB+rsftB/8AxFn5WIeZkdMNdzqnW5eVefbdeP5pk7tjN3+ah9Jz
+ qcPLddfu2GpzBtEmXFsf9SlYUITsdh4ulTV1B2F0VmC59Vew2ZD2nawCanl135rt02/o/wDCJ6cpr8nr
+ duI8tq9EvYWGBvDS197I/Oc9n84qdWdgX9PxcTOsuqGINr6qhNdzRthtkf1f+rQ6OoYtbuoltRpry6TV
+ j1MEhujmN3x9H996FrxE/wAvJN9ryx9XmWC+0Wfay3eHu3bdrvZun6Kyf4rQxMnAf044Ga6yoNu9dllT
+ d06QWHR38pUHRuIaSWydpIgkdiWy7akmiskkkgkKRcT+mY3/AB1X/VsQkXE/pmN/x1X/AFbEkv8A/9fW
+ y/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSiSeUkkklbaBSSSSSmTLrq2PZW9zGWiLGgwHDwf
+ 96ikkkpSSSSSlJJJJKUkkkkpSSSSSlIuJ/TMb/jqv+rYhIuJ/TMb/jqv+rYkp//Q1sv+mZP/AB1v/VvQ
+ lZysXLOXkEY9xButIIqeQQXv1+gh/ZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A/IJfZMz/ALjXf9tP
+ /wDIJKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8AyCX2TM/7jXf9tP8A
+ /IJKRJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A/IJfZMz/ALjXf9tP/wDI
+ JKRJIv2TM/7jXf8AbT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8AyCX2TM/7jXf9tP8A/IJK
+ RJIv2TM/7jXf9tP/APIJfZMz/uNd/wBtP/8AIJKRIuJ/TMb/AI6r/q2JfZMz/uNd/wBtP/8AIImLi5Yy
+ 8cnHuAF1RJNTwAA9mv0ElP8A/9k4QklNBCEAAAAAAFUAAAABAQAAAA8AQQBkAG8AYgBlACAAUABoAG8A
+ dABvAHMAaABvAHAAAAATAEEAZABvAGIAZQAgAFAAaABvAHQAbwBzAGgAbwBwACAAQwBTADUAAAABADhC
+ SU0PoAAAAAAA+G1hbmlJUkZSAAAA7DhCSU1BbkRzAAAAzAAAABAAAAABAAAAAAAAbnVsbAAAAAMAAAAA
+ QUZTdGxvbmcAAAAAAAAAAEZySW5WbExzAAAAAU9iamMAAAABAAAAAAAAbnVsbAAAAAEAAAAARnJJRGxv
+ bmcDIQffAAAAAEZTdHNWbExzAAAAAU9iamMAAAABAAAAAAAAbnVsbAAAAAQAAAAARnNJRGxvbmcAAAAA
+ AAAAAEFGcm1sb25nAAAAAAAAAABGc0ZyVmxMcwAAAAFsb25nAyEH3wAAAABMQ250bG9uZwAAAAAAADhC
+ SU1Sb2xsAAAACAAAAAAAAAAAOEJJTQ+hAAAAAAAcbWZyaQAAAAIAAAAQAAAAAQAAAAAAAAABAAAAADhC
+ SU0EBgAAAAAABwAIAQEAAQEA/+EogGh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8APD94cGFja2V0
+ IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4NCjx4OnhtcG1ldGEgeG1s
+ bnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMC1jMDYwIDYxLjEz
+ NDc3NywgMjAxMC8wMi8xMi0xNzozMjowMCAgICAgICAgIj4NCgk8cmRmOlJERiB4bWxuczpyZGY9Imh0
+ dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPg0KCQk8cmRmOkRlc2NyaXB0
+ aW9uIHJkZjphYm91dD0iIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHht
+ bG5zOnBob3Rvc2hvcD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90b3Nob3AvMS4wLyIgeG1sbnM6ZGM9
+ Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFk
+ b2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RFdnQ9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEu
+ MC9zVHlwZS9SZXNvdXJjZUV2ZW50IyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFw
+ LzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENT
+ NSBNYWNpbnRvc2giIHhtcDpDcmVhdGVEYXRlPSIyMDEyLTAzLTIxVDEyOjM3OjAxKzAxOjAwIiB4bXA6
+ TWV0YWRhdGFEYXRlPSIyMDEyLTAzLTIxVDE4OjQ4OjUxKzAxOjAwIiB4bXA6TW9kaWZ5RGF0ZT0iMjAx
+ Mi0wMy0yMVQxODo0ODo1MSswMTowMCIgcGhvdG9zaG9wOkNvbG9yTW9kZT0iMyIgcGhvdG9zaG9wOklD
+ Q1Byb2ZpbGU9InNSR0IgSUVDNjE5NjYtMi4xIiBkYzpmb3JtYXQ9ImltYWdlL2pwZWciIHhtcE1NOklu
+ c3RhbmNlSUQ9InhtcC5paWQ6MEMxNUFBMTgwRjIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHhtcE1NOkRv
+ Y3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHhtcE1NOk9y
+ aWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSI+
+ DQoJCQk8cGhvdG9zaG9wOlRleHRMYXllcnM+DQoJCQkJPHJkZjpCYWc+DQoJCQkJCTxyZGY6bGkgcGhv
+ dG9zaG9wOkxheWVyTmFtZT0ic3dpcGUgbGVmdCIgcGhvdG9zaG9wOkxheWVyVGV4dD0ic3dpcGUgbGVm
+ dCIvPg0KCQkJCTwvcmRmOkJhZz4NCgkJCTwvcGhvdG9zaG9wOlRleHRMYXllcnM+DQoJCQk8eG1wTU06
+ SGlzdG9yeT4NCgkJCQk8cmRmOlNlcT4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249ImNyZWF0ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEi
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTI6Mzc6MDErMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowMjgwMTE3NDA3MjA2ODExQkE5RERGMTVB
+ NUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMjozNzozOSswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OjAzODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEy
+ OjU3OjEzKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDQ4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEi
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDA6MDgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowNTgwMTE3
+ NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowMjo0Mysw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDpp
+ bnN0YW5jZUlEPSJ4bXAuaWlkOjA2ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3
+ aGVuPSIyMDEyLTAzLTIxVDEzOjA3OjU2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDc4MDExNzQwNzIwNjgx
+ MUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDg6MTErMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDowODgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxMzowODoxOCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjBBODAxMTc0MDcyMDY4MTFCQTlEREYx
+ NUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA5OjM5KzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIv
+ Pg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5p
+ aWQ6MjIyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFU
+ MTM6MDk6NDkrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFj
+ aW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZl
+ ZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyMzIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgx
+ MSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0i
+ QWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJk
+ ZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjI0MjNERTBB
+ MEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjEwOjI4KzAx
+ OjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RF
+ dnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omlu
+ c3RhbmNlSUQ9InhtcC5paWQ6MjUyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0Ondo
+ ZW49IjIwMTItMDMtMjFUMTM6MTI6NDMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBo
+ b3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RF
+ dnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyNjIzREUwQTBDMjA2ODEx
+ QkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMzowNiswMTowMCIgc3RF
+ dnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5n
+ ZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlE
+ PSJ4bXAuaWlkOjI3MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEy
+ LTAzLTIxVDEzOjE4OjQwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3Ag
+ Q1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlv
+ bj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjgyM0RFMEEwQzIwNjgxMUJBOURERjE1
+ QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6MTQ6MDUrMDE6MDAiIHN0RXZ0OnNvZnR3
+ YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+
+ DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlp
+ ZDpGNzdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQx
+ Nzo1NCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkZBN0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjU1OjUwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkI3RjExNzQw
+ NzIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTY6MDUrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDpGQzdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxNzo1Njo1MiswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhv
+ dG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2
+ dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjQyMzY2QjNBMEEyMDY4MTE5
+ NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjIwOjQ0KzAxOjAwIiBzdEV2
+ dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdl
+ ZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9
+ InhtcC5paWQ6NDMzNjZCM0EwQTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTIt
+ MDMtMjFUMTg6MjA6NTYrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo0NDM2NkIzQTBBMjA2ODExOTQ1NzlBMzNG
+ QjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoyMTozNiswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OjQ1MzY2QjNBMEEyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4
+ OjIyOjE3KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6NDYzNjZCM0EwQTIwNjgxMTk0NTc5QTMzRkIzNTY0Nzki
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6MjI6MzArMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo0NzM2NkIz
+ QTBBMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoyMjozNysw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDpp
+ bnN0YW5jZUlEPSJ4bXAuaWlkOjQ4MzY2QjNBMEEyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3
+ aGVuPSIyMDEyLTAzLTIxVDE4OjI0OjM2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6NDkzNjZCM0EwQTIwNjgx
+ MTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6MjU6MTMrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJ
+ RD0ieG1wLmlpZDo1MEFDOURFRTBCMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAx
+ Mi0wMy0yMVQxODoyNjowMyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9w
+ IENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rp
+ b249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjU1QUM5REVFMEIyMDY4MTE5NDU3OUEz
+ M0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjMwOjUzKzAxOjAwIiBzdEV2dDpzb2Z0
+ d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIv
+ Pg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5p
+ aWQ6RUIxNzdEQ0MwRTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFU
+ MTg6NDY6NDIrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFj
+ aW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZl
+ ZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDowQjE1QUExODBGMjA2ODExOTQ1NzlBMzNGQjM1NjQ3
+ OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODo0ODo1MSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2Vu
+ dD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJ
+ PHJkZjpsaSBzdEV2dDphY3Rpb249ImNvbnZlcnRlZCIgc3RFdnQ6cGFyYW1ldGVycz0iZnJvbSBhcHBs
+ aWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRvIGltYWdlL2pwZWciLz4NCgkJCQkJPHJkZjpsaSBz
+ dEV2dDphY3Rpb249ImRlcml2ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImNvbnZlcnRlZCBmcm9tIGFwcGxp
+ Y2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8gaW1hZ2UvanBlZyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MEMxNUFBMTgwRjIwNjgx
+ MTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6NDg6NTErMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJPC9yZGY6U2VxPg0KCQkJPC94bXBNTTpIaXN0b3J5Pg0KCQkJPHhtcE1NOkRl
+ cml2ZWRGcm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6MEIxNUFBMTgwRjIwNjgxMTk0NTc5QTMz
+ RkIzNTY0NzkiIHN0UmVmOmRvY3VtZW50SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1
+ QTVBRUU4MTEiIHN0UmVmOm9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDowMTgwMTE3NDA3MjA2ODEx
+ QkE5RERGMTVBNUFFRTgxMSIvPg0KCQk8L3JkZjpEZXNjcmlwdGlvbj4NCgk8L3JkZjpSREY+DQo8L3g6
+ eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAK
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDw/eHBhY2tldCBl
+ bmQ9J3cnPz7/4gxYSUNDX1BST0ZJTEUAAQEAAAxITGlubwIQAABtbnRyUkdCIFhZWiAHzgACAAkABgAx
+ AABhY3NwTVNGVAAAAABJRUMgc1JHQgAAAAAAAAAAAAAAAQAA9tYAAQAAAADTLUhQICAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFjcHJ0AAABUAAAADNkZXNjAAABhAAA
+ AGx3dHB0AAAB8AAAABRia3B0AAACBAAAABRyWFlaAAACGAAAABRnWFlaAAACLAAAABRiWFlaAAACQAAA
+ ABRkbW5kAAACVAAAAHBkbWRkAAACxAAAAIh2dWVkAAADTAAAAIZ2aWV3AAAD1AAAACRsdW1pAAAD+AAA
+ ABRtZWFzAAAEDAAAACR0ZWNoAAAEMAAAAAxyVFJDAAAEPAAACAxnVFJDAAAEPAAACAxiVFJDAAAEPAAA
+ CAx0ZXh0AAAAAENvcHlyaWdodCAoYykgMTk5OCBIZXdsZXR0LVBhY2thcmQgQ29tcGFueQAAZGVzYwAA
+ AAAAAAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAABJzUkdCIElFQzYxOTY2LTIuMQAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFlaIAAAAAAAAPNRAAEAAAAB
+ FsxYWVogAAAAAAAAAAAAAAAAAAAAAFhZWiAAAAAAAABvogAAOPUAAAOQWFlaIAAAAAAAAGKZAAC3hQAA
+ GNpYWVogAAAAAAAAJKAAAA+EAAC2z2Rlc2MAAAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAA
+ AAAAAAAAFklFQyBodHRwOi8vd3d3LmllYy5jaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAABkZXNjAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBz
+ cGFjZSAtIHNSR0IAAAAAAAAAAAAAAC5JRUMgNjE5NjYtMi4xIERlZmF1bHQgUkdCIGNvbG91ciBzcGFj
+ ZSAtIHNSR0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAsUmVmZXJlbmNlIFZpZXdpbmcg
+ Q29uZGl0aW9uIGluIElFQzYxOTY2LTIuMQAAAAAAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRp
+ dGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHZpZXcAAAAAABOk/gAU
+ Xy4AEM8UAAPtzAAEEwsAA1yeAAAAAVhZWiAAAAAAAEwJVgBQAAAAVx/nbWVhcwAAAAAAAAABAAAAAAAA
+ AAAAAAAAAAAAAAAAAo8AAAACc2lnIAAAAABDUlQgY3VydgAAAAAAAAQAAAAABQAKAA8AFAAZAB4AIwAo
+ AC0AMgA3ADsAQABFAEoATwBUAFkAXgBjAGgAbQByAHcAfACBAIYAiwCQAJUAmgCfAKQAqQCuALIAtwC8
+ AMEAxgDLANAA1QDbAOAA5QDrAPAA9gD7AQEBBwENARMBGQEfASUBKwEyATgBPgFFAUwBUgFZAWABZwFu
+ AXUBfAGDAYsBkgGaAaEBqQGxAbkBwQHJAdEB2QHhAekB8gH6AgMCDAIUAh0CJgIvAjgCQQJLAlQCXQJn
+ AnECegKEAo4CmAKiAqwCtgLBAssC1QLgAusC9QMAAwsDFgMhAy0DOANDA08DWgNmA3IDfgOKA5YDogOu
+ A7oDxwPTA+AD7AP5BAYEEwQgBC0EOwRIBFUEYwRxBH4EjASaBKgEtgTEBNME4QTwBP4FDQUcBSsFOgVJ
+ BVgFZwV3BYYFlgWmBbUFxQXVBeUF9gYGBhYGJwY3BkgGWQZqBnsGjAadBq8GwAbRBuMG9QcHBxkHKwc9
+ B08HYQd0B4YHmQesB78H0gflB/gICwgfCDIIRghaCG4IggiWCKoIvgjSCOcI+wkQCSUJOglPCWQJeQmP
+ CaQJugnPCeUJ+woRCicKPQpUCmoKgQqYCq4KxQrcCvMLCwsiCzkLUQtpC4ALmAuwC8gL4Qv5DBIMKgxD
+ DFwMdQyODKcMwAzZDPMNDQ0mDUANWg10DY4NqQ3DDd4N+A4TDi4OSQ5kDn8Omw62DtIO7g8JDyUPQQ9e
+ D3oPlg+zD88P7BAJECYQQxBhEH4QmxC5ENcQ9RETETERTxFtEYwRqhHJEegSBxImEkUSZBKEEqMSwxLj
+ EwMTIxNDE2MTgxOkE8UT5RQGFCcUSRRqFIsUrRTOFPAVEhU0FVYVeBWbFb0V4BYDFiYWSRZsFo8WshbW
+ FvoXHRdBF2UXiReuF9IX9xgbGEAYZRiKGK8Y1Rj6GSAZRRlrGZEZtxndGgQaKhpRGncanhrFGuwbFBs7
+ G2MbihuyG9ocAhwqHFIcexyjHMwc9R0eHUcdcB2ZHcMd7B4WHkAeah6UHr4e6R8THz4faR+UH78f6iAV
+ IEEgbCCYIMQg8CEcIUghdSGhIc4h+yInIlUigiKvIt0jCiM4I2YjlCPCI/AkHyRNJHwkqyTaJQklOCVo
+ JZclxyX3JicmVyaHJrcm6CcYJ0kneierJ9woDSg/KHEooijUKQYpOClrKZ0p0CoCKjUqaCqbKs8rAis2
+ K2krnSvRLAUsOSxuLKIs1y0MLUEtdi2rLeEuFi5MLoIuty7uLyQvWi+RL8cv/jA1MGwwpDDbMRIxSjGC
+ Mbox8jIqMmMymzLUMw0zRjN/M7gz8TQrNGU0njTYNRM1TTWHNcI1/TY3NnI2rjbpNyQ3YDecN9c4FDhQ
+ OIw4yDkFOUI5fzm8Ofk6Njp0OrI67zstO2s7qjvoPCc8ZTykPOM9Ij1hPaE94D4gPmA+oD7gPyE/YT+i
+ P+JAI0BkQKZA50EpQWpBrEHuQjBCckK1QvdDOkN9Q8BEA0RHRIpEzkUSRVVFmkXeRiJGZ0arRvBHNUd7
+ R8BIBUhLSJFI10kdSWNJqUnwSjdKfUrESwxLU0uaS+JMKkxyTLpNAk1KTZNN3E4lTm5Ot08AT0lPk0/d
+ UCdQcVC7UQZRUFGbUeZSMVJ8UsdTE1NfU6pT9lRCVI9U21UoVXVVwlYPVlxWqVb3V0RXklfgWC9YfVjL
+ WRpZaVm4WgdaVlqmWvVbRVuVW+VcNVyGXNZdJ114XcleGl5sXr1fD19hX7NgBWBXYKpg/GFPYaJh9WJJ
+ Ypxi8GNDY5dj62RAZJRk6WU9ZZJl52Y9ZpJm6Gc9Z5Nn6Wg/aJZo7GlDaZpp8WpIap9q92tPa6dr/2xX
+ bK9tCG1gbbluEm5rbsRvHm94b9FwK3CGcOBxOnGVcfByS3KmcwFzXXO4dBR0cHTMdSh1hXXhdj52m3b4
+ d1Z3s3gReG54zHkqeYl553pGeqV7BHtje8J8IXyBfOF9QX2hfgF+Yn7CfyN/hH/lgEeAqIEKgWuBzYIw
+ gpKC9INXg7qEHYSAhOOFR4Wrhg6GcobXhzuHn4gEiGmIzokziZmJ/opkisqLMIuWi/yMY4zKjTGNmI3/
+ jmaOzo82j56QBpBukNaRP5GokhGSepLjk02TtpQglIqU9JVflcmWNJaflwqXdZfgmEyYuJkkmZCZ/Jpo
+ mtWbQpuvnByciZz3nWSd0p5Anq6fHZ+Ln/qgaaDYoUehtqImopajBqN2o+akVqTHpTilqaYapoum/adu
+ p+CoUqjEqTepqaocqo+rAqt1q+msXKzQrUStuK4trqGvFq+LsACwdbDqsWCx1rJLssKzOLOutCW0nLUT
+ tYq2AbZ5tvC3aLfguFm40blKucK6O7q1uy67p7whvJu9Fb2Pvgq+hL7/v3q/9cBwwOzBZ8Hjwl/C28NY
+ w9TEUcTOxUvFyMZGxsPHQce/yD3IvMk6ybnKOMq3yzbLtsw1zLXNNc21zjbOts83z7jQOdC60TzRvtI/
+ 0sHTRNPG1EnUy9VO1dHWVdbY11zX4Nhk2OjZbNnx2nba+9uA3AXcit0Q3ZbeHN6i3ynfr+A24L3hROHM
+ 4lPi2+Nj4+vkc+T85YTmDeaW5x/nqegy6LzpRunQ6lvq5etw6/vshu0R7ZzuKO6070DvzPBY8OXxcvH/
+ 8ozzGfOn9DT0wvVQ9d72bfb794r4Gfio+Tj5x/pX+uf7d/wH/Jj9Kf26/kv+3P9t////2wBDAAEBAQEB
+ AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQECAgICAgICAgICAgMDAwMDAwMDAwP/
+ 2wBDAQEBAQEBAQEBAQECAgECAgMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD
+ AwMDAwMDAwP/wgARCAD6APoDAREAAhEBAxEB/8QAHQABAAICAwEBAAAAAAAAAAAAAAcJBggCAwUEAf/E
+ ADQQAAAEBQIEBAQFBQAAAAAAAAIFBgcAAQMECBMYMEAROCASFAkQMRUWcJBBFzkhMzQ3Gf/EABwBAQAB
+ BQEBAAAAAAAAAAAAAAAEAQIDBQcGCP/EAFMRAAAFAgMCBw4DAwgGCwAAAAECAwQFFAYAEQcSFRMWJrYX
+ NwgwQCExRWXVR3eXGGhJiSBBUYEiNhBhscEjNDV18JEyUiQ5gmNktCVVVmY4SIj/xAA/EgABAwMCAwQF
+ CAkFAQAAAAABEQIDACEEMRJBUQVhMhMGcYGRoSIQMECxUrIjFHCQ8MHRQpIzY+FicsIHNP/aAAwDAQAC
+ EAMQAAAAuHImAAAAAAAAAAAAAABbKVNEMgAAAAAAAAAAAAAAuYKzSGQAAAAAAAAAAAAAAXMFZpDIAAAA
+ AAAAAAAAAALmCs0hkAAAAAAAAAAAAAAFzBWaQyAAAAAAAAAAAAAAC5grNIZAAAAAAAABOZ7JrmAAAAC5
+ grNIZAAAAAAAABsyZmaZgAAAAuYKzSGQAAAAAAAAbMmZmmYAAAALmCs0hkAAAAAAAAGzJmZpmAAAAC5g
+ rNIZAAAAAAABkxjJsyZmaZgAAAAuYKzSGQAAAAAAe0T+ZMQaT+DTMAAAAFzBWaQyAAAAAASaT+YyYYSy
+ DGTVkAAAAFzBWaQyAAAAADJjaYEfkgA8Y1ZPiAAAABcwVmkMgAAAAAzM2ZAB8RrMYyAAAAAXMFZpDIAA
+ AAAMzNmQD4jWYxkAAAAAFzBWaQyAAAAADMzZkAhkhkAAAAAAuYKzSGQAAAAAZmbMgEMkMgAAAAAFzBWa
+ QyAAAAAAAAAAAAAAC5grNIZAAAAAAAAAAAAAABcwVmkMgAHZn1fXg2gAGfGAgAGXGIgks8kwoAAAFzBW
+ aQyAD2PT8K9P0PHcZ5v9rbrKw8p5J+GyasLHvmHHpGuSlv6ulRHRd6RUVSkGAAAFzBWaQyAe97H5tzHq
+ Pwf14djM2k6jYF5juuI3xdptH1TsskxdJ0mI3YeyyT8eOZ9GOXTftufW26PqfuY5vzY5PK2T0WZqh8sL
+ w8U7hjmcMcv8slAC5grNIZAMm6D8f5V0P434Y5uba/127/l+7eFVZV5D6JyDFsdDN5yrjjm/lkmZoPqt
+ SZfna2Nj462zQ9Z2thenrAmeb2Mi73jZnqEywevFP44p3CyXxxyioFzBWaQyADIPa/Mf37nmbm32zZjb
+ m0BrbNduX8PIrbYlS/V5TAFfUpXQa7FtlblnFWF1fmOw6jU0/KVKgAXMFZpDIAB3zPNdEP0oAAmAh8AA
+ AAAAAAuYKzSGQAAAAAAAAAAAAAAXMFZpDIAAAAAAAAAAAAAALmCs0hkAAAAAAAAAAAAAAFzBWaQyAAAA
+ AAAAAAAAAAC5grNIZAAAAAAAAAAAAAABcwZmYYAAAAAAAAAAAAAADcw//9oACAECAAEFAPyhvTVvT88Q
+ J2qajWFClblfSfOp5MVL+YaYKQKtGlWkbltOqXEASq9L70jDYkV7UpiI6lWkJPm1sC2FdUKMz85oUaN0
+ GlSGd3lOlI0FRowEAPqdiAAxUwgndgCH1VcIZVphDE5SicpRPhJxU+SJzlOQpylF7e29jbmZYXmtqS3l
+ U2KicIrgxtqQ536inKd3czl9xns5Tuq4a4zejRtbGsKcoDOX1S3p1qgqMqFIQP8ALr/3xROJxPhp1TCs
+ 5rKtOReKvWHKVSpIIatUEgjGEUhjkIVQY5zGIU5jEKfmFMXmF11KkeYXWU5yiU5yjrPrOc5x1nHWcdZ8
+ UV/cjs/xZ//aAAgBAwABBQD8ob60WTN+edx5bBBW+OJpfHC68wfh1l16y69Zdeso+fw69Y+UdZcm8T6W
+ iSp17u6v7ovMb8uG3S1vS9aO3XX6YV6YdSuqnVTVne0XSsrG/pO+3x3dHVIgNDKm0TaGZiYkFa/vrZsE
+ 7eX40HRMzGcV7m4kiFVdXNtQvK1xTTtxWrSISurVGW069acU6g+tMQoBOfWXy4D0ML6mYQCAKiAY4S6Y
+ NlScodbq5AHrmJqxb5fuTXok6MOjC3AkWbAMKfIwD/ZhqQDCRFVYptm7MzE/VJbRAOK4RfYhvdl9lSMB
+ mt/SuJT+3yqU/pdKU4pyn1pygHzl8uC8zHUlFLGsupiV1ErLLeoOys6levYWN0OrbW9amK3txUaVpa0A
+ gt6FOmC3oUqcqFENKVGjKn6O0jSpTAKnTHIQACl5ATCEAQy8gI8gY8oY6cSgkyW1Un4s/wD/2gAIAQEA
+ AQUAfx/H1Jn13G5CxuNyFjcbkLG43IWNxuQsbjchY3G5CxuNyFjcbkLG43IWNxuQsbjchY3G5CxuNyFj
+ cbkLG43IWNxuQsbjchY3G5CxuNyFjcbkLG43IWNxuQsbjchY3G5CxuNyFjcbkLG43IWNxuQsbjchY/cd
+ w4yN7hefyN7hefyN7hefyN7hefyN7hefyN7heSaFBDOL03bQZ0S8PI3uF5JniP6iRppNa/EyN7heSZ4j
+ +okaaTWvxMje4XkmeI/qJGmk1r8TI3uF5C4RSysy6GeI/qJGmk1r8TI3uF4xGnFCprpBtVToXRYWFxaX
+ Ny3JosjRNJrXhNJrX4mRvcLxW5bk0WRomk1rxc3JKkSVNpsxcwxTSa14TSa14ubklSJLw8je4XiIonoK
+ JZJpNa8JpNa8EDTXp8YppNa8JpNa8StrVPp6/v65lX4eRvcLxG4tvWuGmk1rwmk1rwmk1rwmk1rwWFhc
+ WlyiUQDoHEyN7heI3Ft61w00mteE0mteE0mteCwsLi0uUSiAdA4uRvcLxG4tvWuGmk1rwmk1rwmk1rw5
+ Rb6JMcbI3uF4jcW3rXDTSa14TSa14TSa14cot9EmONkb3C8/kb3C8/kb3C+HSqaXhRjWuG4lh4fsBcfa
+ fwblm3Sdu6X7crdrVDwcje4XwFhUO9EeUwUrOhQrXNYo9vLKk4IURjM8y/cJLsI56xdYlYRz1A7rVtVm
+ M3U28xPfd1kg6mFeQrPJlm8ZXofmTx4oPmxVhDj/AMWDU4W5DPEQOlj+7TMH9ozr/tbhszGMyycJjnox
+ ydfH/g5G9wvxKygVzOQQgCIAKkY3qBKIx9sygvw2D2tXk5Zu1muzja2pBmymmwkWe4diUq/vyyZ4/O0n
+ 7bGCSmUSzYk6OjdDe2SxpmojT29xU6cOKEP/AC79xxUqREILJm4OR+3y96kUVr7cmHR8eXGERyolAfxO
+ Uun6z+fhyN7hfiVHPlif9Y6ylNtG7UbsrZkMgnYx2cTLVuUzjNkXlqbliBYByFcTWTC+3hOU2hbwIh+2
+ J7doRfs+hD1pE3gE77jP1lU1opyhxf4vMpHQY1pU/lCa5JPSkn2/jSwzlMWDYonH6z8WRvcL4Co3nQme
+ jnK2Qy7VDcK4HuSIQyuHwe9av4v3izLVLwMapcyVKpMY8eMrDLH9IYvOEFrvb1cv3ArI1a7HbNo1ZxDP
+ tnPduO3HmFChyrMT/GNuvcDtLZu8ncvVVkdRXGVZitcb8W8tlHjVc5JZAtk89l1nwMje4XwzuaoqHiLX
+ 7dgoavksje4Xn8je4Xn8je4Xn8je4Xn8je4Xn3H/ANh8/wD/2gAIAQICBj8A/VDfmjGfA3bV4E8hz+nj
+ InVmCDrxd2N7OZ4cL1hQQRhsTZEAHoNafTWZec0twhoNC/8Ag3t48KbHGwNjaEAFgBQbLG1wHMA/XWZH
+ i4zBkFhRGhbXQW1It66k6bNCxuf8QJcBuKqjmk3VuiAqEWsyLeJJGv3h21CB8KjU8Nx1410mNkY8ZznK
+ QLnYS0Be1R+wqABjfGExaSgVAC7XXiBXRoQwAhoDrakFqr76giMTfCIFktoTpWCYomtU3QIqEVMx0YLA
+ LBLd0cNKxo4WNHd3AC2pW3/H3V/ab7BUrdo2pp6hWQXtBII19dShrR4YX0fstSN2hL1GAAlvrruitK0+
+ bZgdTf8ADo154djuzkfbQINquakyp3fhNRUubkDT0mj1XAk2ZG0uDhbdtXvCxBUd7XmtZMGW5ZACzceI
+ LbE9oW/qOtYOPIPw43OKckU/WBUXTyfw25F/UUPuFdMQ8T95tY5WyD7prp6HifrbWQ3GkDZDx7NoXn7q
+ a2SYvzH8b8f21JWtal9H7hUzI5NrVv7/APWnQxuV/E1L6/3VF6vr+fZhdQeTi6NcdWenm36vRasSSGUo
+ ZNWnUJzFFrpnFvIk0WCRwZyUp7KRkjgOwkVua8h3MG9bw47+a39tAueSRzNbi4l3Og4uJdW4uO7nxrdu
+ O7nXfPtNLuK0oN6UG9Kt6ua1rX55mDI/djtduauo7AeXZ+lr/9oACAEDAgY/AP1Qx6E3MYerCHxTGLub
+ GqBzk7oJsFReH0+TpHSSzI81yMs3VsAItJL/ALuLI/5rF3w6+ZeqdUy3zZ02Jue95UkmQc/cOFd4fIi3
+ pFvSLetflt8mv0PI8veVpmTeZXBHyBHMxl9zpeIbo2xculT5ubkPly5Xlz3uJc5zjckk3JJ406Xp+bLB
+ I4ITG9zCRyJaRavLmX17reS/pDMlvib5XlgDgWh7gXEbY3EPNtG1iedOm9SypfKawOayOR/gs2BodFK1
+ qtDJiC7e5pa7xNqkgCvLWb+Wfh4U2OcaSHxTIx0hExZJ3WBS4xNu1Rt1Nf8AoOVk5kh6ZBDDsa558Npy
+ GMlc4NJQbfDeFsgJ4Orqsj8mU9Nd0xs7WbnbA5zmQWau0ElkjtNSqXWv/SuoPynujdK58auJDGubOWhv
+ IABqJyFdU6gzOl/PNe8CTcd4WRjbOJUWJAIKjghrzU3PzpZhGz4d7i4t3RyKhJJCoCi63Fya6blQZcjM
+ p7gHPDjvKyvX4l3XQDXS2lq63l9SyZXD8XwnOcS7uNDSHEqni2F9QUq+dN/W7+NYE4nf4xcFcpXvu461
+ 0lmPO9jXNcu0kKgYipqimsB88rhlOLbqd11N+PdRe3WsKUSuEhLVKlTrxrMe+RxcA5CSVHw8KCyuPrNd
+ 8+2u8aF6HzOV5s8kYoE93T4rRZ3OSEcHfajFjq1CoLmPaQ8FCDYgjUEcCKRjST2BaxOhdLhH5+cP2bzs
+ b8Eb5CriEHwsKLqUFqj8gebMQ5XSPFZA+F5EhgEm0AxvG5ro9rwTESWEWbsJK9E6p0CEswnOjyhE1Ujf
+ HL8TW6ox20Fo4EuaEaAK81dYwnEZmZFFHuGrtxbGE9DHPPoWuoecY2pmy9IG0j/IwvjA4/3JBXnjc0hY
+ 28P8c1dWbsO7xHWT/LHXm/c0hWN4f45a6RP1vEdNhsvsAJJd4r9qhWhF13FOa6VNNhdObjeXMZfhBaF2
+ AEAixKAhGtaGg8SQDXcPsrp4QruH33V06fMwzNOGnwxwBRqkrYfyoUJ5DWouo5cQZikgMaDzvoq3S5Kd
+ lrVghLq3/tWaEujvuULVp8gofNZHmjyjjNZ14AulgagbkJqW6Bs3uedUcd1dfxOpYLTJHiIWSsBLXCQA
+ gtcLEaHQ8KbNB06Bko0c2NgI4WIAItTcmTEidkjR5a0uCaI5Ft6aEmThxSSAIrmNcU5KQbUIZoGPhCI1
+ zQRbSxCW4V+WdAw46AbS0bUGg2olkta1PbBjRsa7UNaAD6UF/XRhjhY2Er8IAAvrYWvxp0UcDGxHUAAA
+ rqoAS9eC2Foh+yg289NNa8ERN8L7KBPZpX/yx/0t/hQjMTfDHBAns0oNcwFo4ECg1zAWjgRQaWDaOCWo
+ hrQB2V3B7K7orQfO5PmrFxvD6vPD4UpbZsgVQ5zftg/zakar+lr/2gAIAQEBBj8A1piIjWnVmKiYrVnU
+ aNi4uN1GvBjHRscxvCZasmDBk1mUmzNkzbJFTSSTKUiZCgUoAAAGOvjWb3oXv6cx18aze9C9/TmOvjWb
+ 3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18az
+ e9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjW
+ b3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18a
+ ze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmOvjWb3oXv6cx18aze9C9/TmP48
+ vP8A5TXSP/FE51h/+vP79/GfnT+/f9bjXj2zaoc95zv/AOzPjXj2zaoc95zv/wCzPjXj2zaoc95zv/7M
+ +NePbNqhz3nO/wD7M+NePbNqhz3nO/8A7M+NePbNqhz3nO84S5XDB7LNguaKZRzFrB3RJIbxjNQNIYl6
+ Ekmho1qva9wMnzHUUjcseZu5OVwolUNXB146Km0ZGLte5nlxubZtFvDs4eIuhFCQkVYHs4x8YmhDRugs
+ BEyL2UU1KXzOMmU8g4kGax3ztVRg6uvuX2Z8a8e2bVDnvOd5wSvF7evC3ms24bidv/hstQ+zczpKn4dN
+ WKnLfXAU9a9yr+AoC1+67stTkpUVHR96vqyprPhG+Ua4a6u4w+dKrenlTenLjuX2Z8a8e2bVDnvOd5wS
+ vF7evC3ms24bidv/AIbLUPs3M6Sp+HTVipy31wFPWvcq/gKAtfuu7LU5KVFR0fer6sqaz4RvlGuGuruM
+ PnSq3p5U3py47l9mfGvHtm1Q57znecErxe3rwt5rNuG4nb/4bLUPs3M6Sp+HTVipy31wFPWvcq/gKAtf
+ uu7LU5KVFR0fer6sqaz4RvlGuGuruMPnSq3p5U3py47l9mfGvHtm1Q57zneKku7tK5msSiyRklZRxAyq
+ EclHOULUdN36j1VoVsRku2vuDUIqJgIYkyxMAiDtuKmIJXi9vXhbzWbcNxO3/wANlqH2bmdJU/DpqxU5
+ b64CnrXuVfwFAWv3XdlqclKio6PvV9WVNZ8I3yjXDXV3GHzpVb08qb05cdy+zPjXj2zaoc95zu52NtwM
+ 1cL1Oh4RpBxb6WdE3nMRlvRu23YIOFS7wn5pmxQzD+1eO0US5qKkKa05J/ETUtJKTVrSaAowl8rQ7hrM
+ THZ7exbFxASfZ2v2NmNmN1WVQWAxZNnIKumh0WzpFSLa3RBy8vBsmUSyZWRJSkpJWQgWObxxUOyU6ev3
+ 7112SpxsZkZtOGUVVUNJEWJJCYwyYSYjfEWstFzSltqTUSxcuWMTd62+OGu+xbXloaGlrXsXUCimmXSB
+ HqGMpHuuCqkE00HTx0xYvLU5KVFR0fer6sqaz4RvlGuGuruMPnSq3p5U3py4tTkpUVHR96vqyprPhG+U
+ a4a6u4w+dKrenlTenLjuX2Z8a8e2bVDnvOd2i1louaUttSaiWLlyxibvW3xw132La8tDQ0ta9i6gUU0y
+ 6QI9QxlI91wVUgmmg6eOmLF5anJSoqOj71fVlTWfCN8o1w11dxh86VW9PKm9OXEBNzcAy4OitZ0zZurW
+ gWC9wrsIHsuXM8jY15c3ZcVhHj15CKu3JjOXbtuo3dqrrqvkHyqt620QltPWVmsntqxqy0baq5ZGfkSr
+ 6P6b3YwYXZpvo/OOTPTOZyOfJJPo6SOyPJAIhJzMn/4xanJSoqOj71fVlTWfCN8o1w11dxh86VW9PKm9
+ OXFqclKio6PvV9WVNZ8I3yjXDXV3GHzpVb08qb05cQE3NwDLg6K1nTNm6taBYL3Cuwgey5czyNjXlzdl
+ xWEePXkIq7cmM5du26jd2quuq+QfKq3r3L7M+NePbNqhz3nO62lb7pB66bTlzQMO4axoyJZFyhJyrRkq
+ gwNEW3eUsV6smuJUhaw8q4A4hwbNyfZQPanJSoqOj71fVlTWfCN8o1w11dxh86VW9PKm9OXFqclKio6P
+ vV9WVNZ8I3yjXDXV3GHzpVb08qb05cRDu5WT2QbSjLT9gxa2pauoFpnIg7X0GZJqLGidCLoYyj15a+qj
+ dAzlu2XcPZRQkjtyZ30UhcVqclKio6PvV9WVNZ8I3yjXDXV3GHzpVb08qb05cWpyUqKjo+9X1ZU1nwjf
+ KNcNdXcYfOlVvTypvTlwyuR9aNYyhoW0px2nxMh0Kxq1Y9k1+4JvK4eyy4gC7wSmhDh3zxyzV3ptLLP0
+ 5Ix72TcOE2SaibKNYFKwjY6KQFCKjmsW1UUaxbVm2VeqtmZDOXJiC4eOBO4cHVXVUUP3L7M+NePbNqhz
+ 3nO62GzpK+rvO121Du/e9bw84xSpN1cUdQN51O3sU+4Zvhs9igeZ06lqclKio6PvV9WVNZ8I3yjXDXV3
+ GHzpVb08qb05cWpyUqKjo+9X1ZU1nwjfKNcNdXcYfOlVvTypvTlxanJSoqOj71fVlTWfCN8o1w11dxh8
+ 6VW9PKm9OXFqclKio6PvV9WVNZ8I3yjXDXV3GHzpVb08qb05cQcvLwbJlEsmVkSUpKSVkIFjm8cVDslO
+ nr9+9ddkqcbGZGbThlFVVDSRFiSQmMMmEmI3xHNWscyjmMcyi0yETi7XbyK0i3te2bflnTqWt+2bccv2
+ T9zbgOkEHQODtjuFlFFnL1y+fPO5/Znxrx7ZtUOe853Ww2dJX1d52u2od373reHnGKVJurijqBvOp29i
+ n3DN8NnsUDzOnUtTkpUVHR96vqyprPhG+Ua4a6u4w+dKrenlTenLi1OSlRUdH3q+rKms+Eb5Rrhrq7jD
+ 50qt6eVN6cuLU5KVFR0fer6sqaz4RvlGuGuruMPnSq3p5U3py4g5eXg2TKJZMrIkpSUkrIQLHN44qHZK
+ dPX79667JU42MyM2nDKKqqGkiLEkhMYZMJMRviOatY5lHMY5lFpkInF2u3kVpFva9s2/LOnUtb9s245f
+ sn7m3AdIIOgcHbHcLKKLOXrl8+ed0+zPjXj2zaoc95zuths6Svq7ztdtQ7v3vW8POMUqTdXFHUDedTt7
+ FPuGb4bPYoHmdOpanJSoqOj71fVlTWfCN8o1w11dxh86VW9PKm9OXFqclKio6PvV9WVNZ8I3yjXDXV3G
+ HzpVb08qb05cWpyUqKjo+9X1ZU1nwjfKNcNdXcYfOlVvTypvTlxZK+6d31VJ/wARxf3PWbWkOiEj/fOi
+ PTzeO1vSq/xKZ2qyq/frN+XD3X7M+NePbNqhz3nO62GzpK+rvO121Du/e9bw84xSpN1cUdQN51O3sU+4
+ Zvhs9igeZ06lqclKio6PvV9WVNZ8I3yjXDXV3GHzpVb08qb05cWpyUqKjo+9X1ZU1nwjfKNcNdXcYfOl
+ VvTypvTlxanJSoqOj71fVlTWfCN8o1w11dxh86VW9PKm9OXFkr7p3fVUn/EcX9z1m1pDohI/3zoj083j
+ tb0qv8Smdqsqv36zflw91+zPjXj2zaoc95zv/wCzPjXj2zaoc95zv/7M+NePbNqhz3nPxcNsiCW3sAcf
+ EJss8g/UQD8V0SdkWhM3MwsuMCYuhzFNuHTiI8xHChFV8zFMoqqmzWMRJMDrHIkcxSiBDCH4VL8NaNxp
+ 2Sk4RaDdq0O/Qt1R24WFui0bzCyBGDt0ZYolFNI5zlyERAAAf5XLTTexbiu4zIyZHzmLYmGNjzrAIopy
+ Eu4FCKYKrlKIkKssQxwKIlAQAclLU1At19bFwpNkXh4x+LcywtHB1SIOSKNVnCCqCxkD7BynEpgDMBy7
+ j9mfGvHtm1Q57zn4QUUzI2AfCPiFQQ8ZSfzfqP5YQTTKBSEV2SlAMgAAKOEWzZFVw4cKpoIIIJnVWXWV
+ OCaSKKSYGOoqocwFKUoCIiOQYJOEsRhHnXQK4bQkvdEBHTyyZylOmU7NZ9wLBc4G8KTtVuqmICBylHwY
+ uXSqEtIzW/rRjl5Wft2ekY6Ads2Dd5HMlHJTyjlug6SMtLNhIdIxyKprFUIJiGAwy+i0DBIudQYN/cMb
+ JxSsnHtWrdza6rhGXEZRy4TjzoJqNhBNQqgkWzLsCYDBm70NjIFJTUdjITca6iFZOOQapOIBk7kJAxpZ
+ RyWNpwaMzGTU4XYV2igUREwAOv1laZqsodOBiY+I1iZIzlnO0Umr6AkJhmLFzIqOQ3glCunRBWYGBZIV
+ DEEwHAuzHXzp/ZfGO3pOdWt5Bw3moNqui9bmEjhZ41fyLRZpHtzgAHcHAEy7QeHIcL3ldlnt17aYkSPK
+ ylvzMdNkhirKAkU8m1arV6DcpzAB1ypHbkEwbSgZhh2504s9eRh49xSP7jkXbOFt9s62CKGaFkZFZAj5
+ 6kmqQyiDUq6yRFCGOQpTAIpTV/WeZK3FVUm4XLCvmc5CoOVjbCTd+4YKqLxaixxAqYuk0SqmECkExsw/
+ k0x/zmJ573Rhvddq2YRnbL0gqRk1csoxgW0snmAAtGNnau8njQ4D+44KhTHyECqCICGIy3dRbRdwTqbV
+ BGEe1DN/CzBxOiQ5Y+aYLuY5ZVAzlPhUhUBVEDl4QpcwzszTPQ+PYW3rDXt17vXbylvkcpjIvpSRuB83
+ m3ywxq79QxWjYioGUUI0AE09kEyiTWW/ta7Rg741x1Rs2WV0zuy5XkJOSYx8tpe1jrKWbOTrKxtuPEHy
+ hNhYSIOEBADGMGyAhbXSfBsobjbvjcdHNxMzU7h3VvPhN1u3VNwO+W+XCbO3tjs57I5fj+zPjXj2zaoc
+ 95z8ALuAEiAeEpfEZX+sCfz/AJ4IQhQKUoCBSgGQAAeIAD9MZHIU4AYRADAAgA/r4caW3PdyTNO34m7G
+ C7905TTBvGGUBRsymVzGKPBpQj9dJ2YwBmQENoPCAYge0Bbk1cUxpg3UtR3EpQss+CBhCRqDJOSt6cbN
+ DKtUIy6XBFlqlRJRBwV8KeYmKBMaW38FqJ2OM/aDnTO4WaUqEwEo/VSuR3FvheljIo5yuXyscgCaiYim
+ CAfvmyKOO1DfK6KDSPirfto6L5XgG7cqmoTCKuaUeGOYwAQyDi3XJVTmEMgMJjZAcBG+rvFqBGclo0zv
+ BqsVMQIWRkHMHY6pdshgLwjgIN6qbazHMc9nwgYO3Fee0Cid0TUpMNjAIGKDB5G30pHIFMABtptmBk0y
+ iPhEpQz8ONQZy2ZR7BTLOUuBNnKRa52b9mD+54KPdHaOkRKs1XOzdqEBRMSqE2topimABDtKQF3Tkrc8
+ PHwiqbFhPvnMsi0Rm7WugJVu3F8ouok1fC0IY6QDwe3tGAoGOcTWM8s2Se2w9lpJJtIPoNyrGv3KEpfN
+ wqSSZnzUybsoPQRKRUSnKJ0Q4If7MRKOvklqpISk1BOGt8oWQtcrtd+rknAxbaGUj3EioYwx6OoA5Nyl
+ UHZeJK7BdrLaH9wvj/3Q/TP9MaaFyDLfUX4MvB/G1z47N1sWdPS9rQD6FuYryLgJB1EtnRLbitP20Eku
+ DJVE6qEWjJrgkmIiQonzyzAohoo51PXevdQ3U1abqNfTKp1rgBRdpcjxo4eOHRiyB3XFEUyuDn2lRVEo
+ qCJ/3saJTTafmm8w6mLSK5lkJR8lJOCqN7uFQq75NcrpYpxTLmBjjnshn4gx2qnbiZll3UPB6lJxDlaR
+ eKuItNnpGkq0TjljrGUZEaqFAyYJCUCGDMuQ4b7+nZmbpAWFpveTeyVKK/B8PT1i63A8NwJNvZy2tguf
+ iDHiDxh/Xgf2YN+38P2Z8a8e2bVDnvOfgK2dm8HiTXH8v0KoP5h+g4KIeIcxDA5jl4RxC6f2gRktcU8W
+ VNHJP3ZWTVQYiHkJx0RR0YpypGMyjFAJmGQnyARABzBDs76vsCXRaAy8TaMna8m6ZzTi1kZ8rJNBSCkE
+ jvm76HopJJQ8coZRuZIRInwBxOI2BdtgIljIV24g9QW1vN1TbMLJQVxAZ80YFOY50op6ZiVREgiJSGOo
+ mUATIUoayX5COaebvuItiCTfIiXbekfuWMC1K3OBQHZShZF0rmYf9nay8OQDdfaCbFSQnJnQZvux8moB
+ QISfi1JOBQRWyA4EPOXAkIZZCbweDPLLtPeHyOw5sXhjUoCAJhCWljCBQEwgUl5W2c5hAM/AQpRER/IA
+ x2nz5DsjEMSgbIdkTFte8BMUB8QmKBwEQ/LMP1xpfP60W29u+yYo4ORgI5E7lV9NFvS4UolNVEJGLaqo
+ EdHHbK5WK3HLI4G8BRuCbsaw4vT3s1aYkdquoxjLRDJFwpa8e1eoM3iQHYupI0ezcpHbM2LIjBuoYoGM
+ dVNM4D4Q8Yf0Y00/zqL57XPjRi89U9OF9SrsZRUwfS+OFJFWJZviMbSXmnkms+XPEtA202AornZvnCRy
+ bSCYZHMFv9oHU6DY21pU4eNovTqHZyrEWaKM+k6eJu2kYV65lnLp+2iNpy9dpomVAhODIVICEJoX/nVn
+ /wDdrxx2uwABERh9UgAA8IiI6QpgAAAeEREcf9HH7Q/rwP7MG/b+H7M+NePbNqhz3nPwlbuTCKOeRFB8
+ IpZ/kP5iT+jCRkziACtmBiGEAEBKIh4Sj4QxAXxaMorGXHbUilJRbwMlSFWTAyaqDhBTNNyzeN1DorpG
+ ASqoqGIbwGHDK8Lr7K1jzeqcamgDW8CSEMDgjlqQpGrplJyVmSlxRKbfaMCaJXS5iFKAAqG1+7IX/eSy
+ CTtdujHRcTHAqlFwUK0OsdnFMCKqKLGTTUcKKqKKGMdVZU5xyzAoWHoq/thpEJWcNqGkLoQmXDt7cx7V
+ t11BIi6YGYNkGQP1nIO1QKopksmUC5FzxEdmta1WzdnGs4KNcXcWbcKvH8bb00lMx7Q8SMeRJIqZmjdP
+ OoNkCADl4cg1PtNpZzS6U9Smbdos+dTi8YpEAhGTEaB0UE458V2Jiy4nyEyeQpgH55hc9+r29HXe3gbi
+ uEX1tTJgCNnI2SuWFh5KNdnO3dkKm5YSChQE6KyYGy2kzlzKM9pZotopbOi8TdrN8xuJ3DLxeyDWXbgz
+ mEomJhLct6PbvZFiUUDvVOEV4Iw7BCHKRQr7Sa+dP4TV3S12s5VbW3NuG7ZSMLIO66RaAD6JnIyWiHL4
+ x3NK4bAIODmMCpQHZwpo9pfpjb+jOnLw5N7RsEqzUcyLYjssiaPaoRcNAxcHHupAoKOSooqKuBKAGVBM
+ 6qZ/9o3+scW32az2a0asrceNXZLuJNrqu3QtZqTmQIeIGOIkkBzSQp5g4NkBM/zyCA02120UtXW6MtRB
+ o1gJSbPEncEbxzYWUdvOKnbcuCOfSbVkbgQepi3WMkX+0KooY6hrft0luRlg6eWoqR1CWbEua8oPkmik
+ e2ev5CijUVjR8cqdBqkg2booJKnDZMJswsfs7K2Yzj2dlPIh2ldSc2u4dSAxKUumUikUaORSbgvvYREQ
+ XPs7AePPwXHHBbUdfFkXeDc0/a8g7NHKi5bIrtSPI6QpJFBAy7VwKbhJZsum4TKQo7AlA2LZjrB7P9o6
+ QhbSrnYlYFw0RePWLvhV1oo0ZAwtuwqTKvWMvtKpOlgUzFM6QKLFU8Y/j+zPjXj2zaoc95z8RWxjbSZD
+ bZAHwiUcshAB8ez/ADfjk9FI+66fTKZWVcSVs7itpWpWXfNZJU++V4dW4Edp6ySPkm7KAbOQBsiID3j9
+ mfGvHtm1Q57znf8A9mfGvHtm1Q57znf/ANmfGvHtm1Q57znf/wBmfGvHtm1Q57znf/2Z8a8e2bVDnvOd
+ /wD2Z8X5/wApr+M7o6x+sP8Axx9/Hn/vP/zT/t3C4+jPj6M+Poz4+jPj6M+Poz4+jPj6M+Poz4+jPj6M
+ +Poz4+jPj6M+Poz4+jPj6M+Poz4+jPj6M+Poz4+jPj6M+Poz4+jPj6M+Poz4+jPj6M+Poz4/+mf/AMM/
+ 9P8A8Z4//9k=
+
+
+
+
+ /9j/4AAQSkZJRgABAQEASABIAAD/7gAOQWRvYmUAZAAAAAAB/+ENUEV4aWYAAE1NACoAAAAIAAcBEgAD
+ AAAAAQABAAABGgAFAAAAAQAAAGIBGwAFAAAAAQAAAGoBKAADAAAAAQACAAABMQACAAAAHgAAAHIBMgAC
+ AAAAFAAAAJCHaQAEAAAAAQAAAKQAAADEAEgAAAABAAAASAAAAAEAAEFkb2JlIFBob3Rvc2hvcCBDUzUg
+ TWFjaW50b3NoADIwMTI6MDM6MjEgMTg6NDg6MTkAAAKgAgAEAAAAAQAAAPqgAwAEAAAAAQAAAPoAAAAA
+ AAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABEgEbAAUAAAABAAABGgEoAAMAAAABAAIAAAIBAAQAAAAB
+ AAABIgICAAQAAAABAAAMJQAAAAAAAABIAAAAAQAAAEgAAAAB/9j/7QAMQWRvYmVfQ00AAf/uAA5BZG9i
+ ZQBkgAAAAAH/2wCEAAwICAgJCAwJCQwRCwoLERUPDAwPFRgTExUTExgRDAwMDAwMEQwMDAwMDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwBDQsLDQ4NEA4OEBQODg4UFA4ODg4UEQwMDAwMEREMDAwMDAwRDAwMDAwM
+ DAwMDAwMDAwMDAwMDAwMDAwMDAwMDP/AABEIAKAAoAMBIgACEQEDEQH/3QAEAAr/xAE/AAABBQEBAQEB
+ AQAAAAAAAAADAAECBAUGBwgJCgsBAAEFAQEBAQEBAAAAAAAAAAEAAgMEBQYHCAkKCxAAAQQBAwIEAgUH
+ BggFAwwzAQACEQMEIRIxBUFRYRMicYEyBhSRobFCIyQVUsFiMzRygtFDByWSU/Dh8WNzNRaisoMmRJNU
+ ZEXCo3Q2F9JV4mXys4TD03Xj80YnlKSFtJXE1OT0pbXF1eX1VmZ2hpamtsbW5vY3R1dnd4eXp7fH1+f3
+ EQACAgECBAQDBAUGBwcGBTUBAAIRAyExEgRBUWFxIhMFMoGRFKGxQiPBUtHwMyRi4XKCkkNTFWNzNPEl
+ BhaisoMHJjXC0kSTVKMXZEVVNnRl4vKzhMPTdePzRpSkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2JzdH
+ V2d3h5ent8f/2gAMAwEAAhEDEQA/ANrKyssZeQBkXAC60AC14AAe/T6aH9rzP+5N3/br/wDyaWX/AEzJ
+ /wCOt/6t6EkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/b
+ r/8AyaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/
+ APyaEkkpL9rzP+5N3/br/wDyaX2vM/7k3f8Abr//ACaEkkpL9rzP+5N3/br/APyaX2vM/wC5N3/br/8A
+ yaEkkpL9rzP+5N3/AG6//wAml9rzP+5N3/br/wDyaEkkpL9rzP8AuTd/26//AMml9rzP+5N3/br/APya
+ EkkpL9rzP+5N3/br/wDyaJi5WWcvHByLiDdUCDa8ggvZp9NVkXE/pmN/x1X/AFbElP8A/9DWy/6Zk/8A
+ HW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSTccpyCIkESJEiJH7ySlJJJJKUkkkkpSSSSSlJJJ
+ JKUkkkkpSLif0zG/46r/AKtiEi4n9Mxv+Oq/6tiSn//R1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQk
+ lKSSSSUpJJJJSbFaDbJ/NaSP+o/7+i5QBpJI1BEHwkgIeH/OO/q/xai5P8w74t/KElNNJJJJSkkkklKS
+ SSSUpJJJJSkkkklKRcT+mY3/AB1X/VsQkXE/pmN/x1X/AFbElP8A/9LWy/6Zk/8AHW/9W9CRcv8ApmT/
+ AMdb/wBW9CSUpJJJJSkkkklJ8P8AnHf1f4tRcn+Yd8W/9UELD/nHf1P4tVkhrgQ4SDoQUlOeAToASfAa
+ peR0PgrTGtx7DuPsfAbYfzTr7Xu/N3Sp3Y7XyY22fva/9JqSmkkpWVPrPuGhMB3Y/wCv7qikpSSSSSlJ
+ JJJKUkkkkpSLif0zG/46r/q2ISLif0zG/wCOq/6tiSn/09bL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0
+ JJSkkkklKSSSSUu1zmuDmmCOFdqs9Vm6IIMEdp8lRUq7HVu3N+Y8R+6kpvEAggiQRBBQ6631Ha076zPO
+ hb/5Pd+cpse2xu5vHBnkFSSUs5oc0tdqDyqNjNljmTMd/iN38VfVLI/n3/L/AKlqSkaSSSSlJJJJKUkk
+ kkpSLif0zG/46r/q2ISLif0zG/46r/q2JKf/1NbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkkl
+ KSSSSUpJJJJTOhzm3NAMBxDXDxEq8s9jtr2u52kGPgrH2xv7jvvCSmwqWR/Pv+X/AFLUX7Y39x33hAte
+ H2OeBAMaHyAb/BJTFJJJJSkkkklKSSSSUpFxP6Zjf8dV/wBWxCRcT+mY3/HVf9WxJT//1dbL/pmT/wAd
+ b/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSU66Mi4OdTTZa1v0ixjnAfHaFEMsNRuDHekDtNkHYD+6X/R
+ 3JKWSUxReXtrFTzY8bms2u3Ec7msjc5qI+kGrHFNFwucH+oS0lthaeccD/Rt/nElIElN9F9bWvtqfWx/
+ 0HPaWg9/a5wS9DI9H1zVZ6P+l2O2f58bUlMEkmhznBrQXOcQGtAkkngAKzi459VpycbIspcHgNqaQ4ub
+ p7ZH+Dd/OJKaySlTRkX6U1vuc0Dd6bS6PjtCudL6d9qzm4+Uy2phY9+rSwnYW8eo36PvSU0UlJ1GTWGe
+ tTZWbPoB7HN3H91m4e5ys5fS8rFqpscx7m2V+rYRW4Cuf8Ha79797dsSU1ElJrdwMcqPxRIIAPdbGcZS
+ lEH1R+YKRcT+mY3/AB1X/VsQkXE/pmN/x1X/AFbEFz//1tbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0
+ JJSkkkkkF28S7IycHFq6bd6WXgkmzE3bRcJDvU7ep/Lb/wAJZ/wajjOt6jidUxXM9O22yu01AEbXFzWX
+ +13u/wADvsVfHv6Q5mLZd6mLk4kF5paCLi0t2vc79/2+/wDr2ImJ1quvrV3ULWFtN7S0saJcANnpzH53
+ 6P3ooouzktqbmt6nWJrxcfIY7ydU5jWs/wDP6pdOn/IE6n075Pns1VEdXB6TlYj93r5FzntMe3ZY9ttk
+ u/7cVnpWXVdldJx2TvxW3C2RAlzNNh/O+ikog2jqvvyemdUbk2OuDbKy0PO6Js/N/d+itKx2XV1jIyMh
+ 7q+l01AODz+jdLW+yuv892//ANJLIty+n4+HlUYbrbbcqwF3qtDWsDHb9un00bJ6l0nJv+23+te8M9mB
+ YJqbZH0930NqNhZwyodxXX+853TwPtuJpH6erTw97VuYt11n1nubY9zm1tsFbSdGiKvoN/NWBi3CnIot
+ fq2qxj3xzDXNc6PuWhjdUxqut3Z7w70LA/bDfd7vTiW/2ESR+CyOPIKs/pA79FvUuo+rNDsZz6nuvdud
+ USCTD9u4s/qsWsST9Z6yeRifd7lT6Yy3C6WxxtuY/Ni1jsap12xoDfa7221Ne/8Aqb/+21Xxs/Gw+sOy
+ LLL727HNtstZFnqEt9vp+za1jWbfckSNfqoY8g4f8Hi1/c/75fHyMi/omc6+19rq3VPrc8yWu3NO5jvz
+ VLq+RkGnBYbX7bcVptbuMPJDZNg/PVHGzK6umZeI8H1b9npwJb7SN25yPkZmBlYdHqPtqysakUtrDQ5j
+ iI2u3fu+395Hijf1YjhzcFX6uED5uvHxf9FpgAcJnNDvj4pmuJBJ0hRc+dBwnmUeHvfRr48OY5aB4ZQP
+ qnvw/wDff3WKLif0zG/46r/q2ISLif0zG/46r/q2KB1X/9fWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW
+ 9CSUpJJJJSkkkklKUq7baniyp5rsbw9pgidFFJJSiSSSdSdSfMpJJJKUkkkkpNVm5tDNlORZUyZ2NcQJ
+ P8lBJJJJMkmSTqSTyUkklKSSSSUqdI7JJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv+Oq/6tiSn/9DWy/6Zk/8A
+ HW/9W9CVnKxcs5eQRj3EG60gip5BBe/X6CH9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9kzP8A
+ uNd/20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZMz/uN
+ d/20/wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEki/ZMz/uNd/20/wD8gl9kzP8AuNd/
+ 20//AMgkpEki/ZMz/uNd/wBtP/8AIJfZMz/uNd/20/8A8gkpEki/ZMz/ALjXf9tP/wDIJfZMz/uNd/20
+ /wD8gkpEki/ZMz/uNd/20/8A8gl9kzP+413/AG0//wAgkpEi4n9Mxv8Ajqv+rYl9kzP+413/AG0//wAg
+ iYuLljLxyce4AXVEk1PAAD2a/QSU/wD/2QD/7RYsUGhvdG9zaG9wIDMuMAA4QklNBAQAAAAAAC8cAVoA
+ AxslRxwBWgADGyVHHAFaAAMbJUccAVoAAxslRxwBWgADGyVHHAIAAAIAAAA4QklNBCUAAAAAABBus3Le
+ +f92w9DcIki/K33TOEJJTQQ6AAAAAACbAAAAEAAAAAEAAAAAAAtwcmludE91dHB1dAAAAAQAAAAAUHN0
+ U2Jvb2wBAAAAAEludGVlbnVtAAAAAEludGUAAAAAQ2xybQAAAA9wcmludFNpeHRlZW5CaXRib29sAAAA
+ AAtwcmludGVyTmFtZVRFWFQAAAATAEMAYQBuAG8AbgAgAE0AUAAxADQAMAAgAHMAZQByAGkAZQBzAAAA
+ OEJJTQQ7AAAAAAGyAAAAEAAAAAEAAAAAABJwcmludE91dHB1dE9wdGlvbnMAAAASAAAAAENwdG5ib29s
+ AAAAAABDbGJyYm9vbAAAAAAAUmdzTWJvb2wAAAAAAENybkNib29sAAAAAABDbnRDYm9vbAAAAAAATGJs
+ c2Jvb2wAAAAAAE5ndHZib29sAAAAAABFbWxEYm9vbAAAAAAASW50cmJvb2wAAAAAAEJja2dPYmpjAAAA
+ AQAAAAAAAFJHQkMAAAADAAAAAFJkICBkb3ViQG/gAAAAAAAAAAAAR3JuIGRvdWJAb+AAAAAAAAAAAABC
+ bCAgZG91YkBv4AAAAAAAAAAAAEJyZFRVbnRGI1JsdAAAAAAAAAAAAAAAAEJsZCBVbnRGI1JsdAAAAAAA
+ AAAAAAAAAFJzbHRVbnRGI1B4bEBSAAAAAAAAAAAACnZlY3RvckRhdGFib29sAQAAAABQZ1BzZW51bQAA
+ AABQZ1BzAAAAAFBnUEMAAAAATGVmdFVudEYjUmx0AAAAAAAAAAAAAAAAVG9wIFVudEYjUmx0AAAAAAAA
+ AAAAAAAAU2NsIFVudEYjUHJjQFkAAAAAAAA4QklNA+0AAAAAABAASAAAAAEAAgBIAAAAAQACOEJJTQQm
+ AAAAAAAOAAAAAAAAAAAAAD+AAAA4QklNA/IAAAAAAAoAAP///////wAAOEJJTQQNAAAAAAAEAAAAeDhC
+ SU0EGQAAAAAABAAAAB44QklNA/MAAAAAAAkAAAAAAAAAAAEAOEJJTScQAAAAAAAKAAEAAAAAAAAAAjhC
+ SU0D9QAAAAAASAAvZmYAAQBsZmYABgAAAAAAAQAvZmYAAQChmZoABgAAAAAAAQAyAAAAAQBaAAAABgAA
+ AAAAAQA1AAAAAQAtAAAABgAAAAAAAThCSU0D+AAAAAAAcAAA/////////////////////////////wPo
+ AAAAAP////////////////////////////8D6AAAAAD/////////////////////////////A+gAAAAA
+ /////////////////////////////wPoAAA4QklNBAAAAAAAAAIABjhCSU0EAgAAAAAAEAAAAAAAAAAA
+ AAAAAAAAAAA4QklNBDAAAAAAAAgBAQEBAQEBAThCSU0ELQAAAAAABgABAAAAIThCSU0ECAAAAAAAGgAA
+ AAEAAAJAAAACQAAAAAIAAA+gAQAAD7AAOEJJTQQeAAAAAAAEAAAAADhCSU0EGgAAAAADSwAAAAYAAAAA
+ AAAAAAAAAPoAAAD6AAAACwBzAHcAaQBwAGUAXwByAGkAZwBoAHQAAAABAAAAAAAAAAAAAAAAAAAAAAAA
+ AAEAAAAAAAAAAAAAAPoAAAD6AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEA
+ AAAAAABudWxsAAAAAgAAAAZib3VuZHNPYmpjAAAAAQAAAAAAAFJjdDEAAAAEAAAAAFRvcCBsb25nAAAA
+ AAAAAABMZWZ0bG9uZwAAAAAAAAAAQnRvbWxvbmcAAAD6AAAAAFJnaHRsb25nAAAA+gAAAAZzbGljZXNW
+ bExzAAAAAU9iamMAAAABAAAAAAAFc2xpY2UAAAASAAAAB3NsaWNlSURsb25nAAAAAAAAAAdncm91cElE
+ bG9uZwAAAAAAAAAGb3JpZ2luZW51bQAAAAxFU2xpY2VPcmlnaW4AAAANYXV0b0dlbmVyYXRlZAAAAABU
+ eXBlZW51bQAAAApFU2xpY2VUeXBlAAAAAEltZyAAAAAGYm91bmRzT2JqYwAAAAEAAAAAAABSY3QxAAAA
+ BAAAAABUb3AgbG9uZwAAAAAAAAAATGVmdGxvbmcAAAAAAAAAAEJ0b21sb25nAAAA+gAAAABSZ2h0bG9u
+ ZwAAAPoAAAADdXJsVEVYVAAAAAEAAAAAAABudWxsVEVYVAAAAAEAAAAAAABNc2dlVEVYVAAAAAEAAAAA
+ AAZhbHRUYWdURVhUAAAAAQAAAAAADmNlbGxUZXh0SXNIVE1MYm9vbAEAAAAIY2VsbFRleHRURVhUAAAA
+ AQAAAAAACWhvcnpBbGlnbmVudW0AAAAPRVNsaWNlSG9yekFsaWduAAAAB2RlZmF1bHQAAAAJdmVydEFs
+ aWduZW51bQAAAA9FU2xpY2VWZXJ0QWxpZ24AAAAHZGVmYXVsdAAAAAtiZ0NvbG9yVHlwZWVudW0AAAAR
+ RVNsaWNlQkdDb2xvclR5cGUAAAAATm9uZQAAAAl0b3BPdXRzZXRsb25nAAAAAAAAAApsZWZ0T3V0c2V0
+ bG9uZwAAAAAAAAAMYm90dG9tT3V0c2V0bG9uZwAAAAAAAAALcmlnaHRPdXRzZXRsb25nAAAAAAA4QklN
+ BCgAAAAAAAwAAAACP/AAAAAAAAA4QklNBBQAAAAAAAQAAAAhOEJJTQQMAAAAAAxBAAAAAQAAAKAAAACg
+ AAAB4AABLAAAAAwlABgAAf/Y/+0ADEFkb2JlX0NNAAH/7gAOQWRvYmUAZIAAAAAB/9sAhAAMCAgICQgM
+ CQkMEQsKCxEVDwwMDxUYExMVExMYEQwMDAwMDBEMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMAQ0L
+ Cw0ODRAODhAUDg4OFBQODg4OFBEMDAwMDBERDAwMDAwMEQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwM
+ DAz/wAARCACgAKADASIAAhEBAxEB/90ABAAK/8QBPwAAAQUBAQEBAQEAAAAAAAAAAwABAgQFBgcICQoL
+ AQABBQEBAQEBAQAAAAAAAAABAAIDBAUGBwgJCgsQAAEEAQMCBAIFBwYIBQMMMwEAAhEDBCESMQVBUWET
+ InGBMgYUkaGxQiMkFVLBYjM0coLRQwclklPw4fFjczUWorKDJkSTVGRFwqN0NhfSVeJl8rOEw9N14/NG
+ J5SkhbSVxNTk9KW1xdXl9VZmdoaWprbG1ub2N0dXZ3eHl6e3x9fn9xEAAgIBAgQEAwQFBgcHBgU1AQAC
+ EQMhMRIEQVFhcSITBTKBkRShsUIjwVLR8DMkYuFygpJDUxVjczTxJQYWorKDByY1wtJEk1SjF2RFVTZ0
+ ZeLys4TD03Xj80aUpIW0lcTU5PSltcXV5fVWZnaGlqa2xtbm9ic3R1dnd4eXp7fH/9oADAMBAAIRAxEA
+ PwDaysrLGXkAZFwAutAAteAAHv0+mh/a8z/uTd/26/8A8mll/wBMyf8Ajrf+rehJKS/a8z/uTd/26/8A
+ 8ml9rzP+5N3/AG6//wAmhJJKS/a8z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS/a8z/uTd/wBuv/8A
+ Jpfa8z/uTd/26/8A8mhJJKS/a8z/ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a8z/uTd/26/8A8ml9
+ rzP+5N3/AG6//wAmhJJKS/a8z/uTd/26/wD8ml9rzP8AuTd/26//AMmhJJKS/a8z/uTd/wBuv/8AJpfa
+ 8z/uTd/26/8A8mhJJKS/a8z/ALk3f9uv/wDJpfa8z/uTd/26/wD8mhJJKS/a8z/uTd/26/8A8miYuVln
+ Lxwci4g3VAg2vIIL2afTVZFxP6Zjf8dV/wBWxJT/AP/Q1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQk
+ lKSSSSUpJJJJSkk3HKcgiJBEiRIiR+8kpSSSSSlJJJJKUkkkkpSSSSSlJJJJKUi4n9Mxv+Oq/wCrYhIu
+ J/TMb/jqv+rYkp//0dbL/pmT/wAdb/1b0JFy/wCmZP8Ax1v/AFb0JJSkkkklKSSSSUmxWg2yfzWkj/qP
+ +/ouUAaSSNQRB8JICHh/zjv6v8WouT/MO+LfyhJTTSSSSUpJJJJSkkkklKSSSSUpJJJJSkXE/pmN/wAd
+ V/1bEJFxP6Zjf8dV/wBWxJT/AP/S1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSfD/
+ AJx39X+LUXJ/mHfFv/VBCw/5x39T+LVZIa4EOEg6EFJTngE6AEnwGqXkdD4K0xrcew7j7HwG2H806+17
+ vzd0qd2O18mNtn72v/SakppJKVlT6z7hoTAd2P8Ar+6opKUkkkkpSSSSSlJJJJKUi4n9Mxv+Oq/6tiEi
+ 4n9Mxv8Ajqv+rYkp/9PWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklLtc5rg5pgjhXa
+ rPVZuiCDBHafJUVKux1btzfmPEfupKbxAIIIkEQQUOut9R2tO+szzoW/+T3fnKbHtsbubxwZ5BUklLOa
+ HNLXag8qjYzZY5kzHf4jd/FX1SyP59/y/wCpakpGkkkkpSSSSSlJJJJKUi4n9Mxv+Oq/6tiEi4n9Mxv+
+ Oq/6tiSn/9TWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJSkkkklKSSSSUzoc5tzQDAcQ1w8R
+ KvLPY7a9rudpBj4Kx9sb+477wkpsKlkfz7/l/wBS1F+2N/cd94QLXh9jngQDGh8gG/wSUxSSSSUpJJJJ
+ SkkkklKRcT+mY3/HVf8AVsQkXE/pmN/x1X/VsSU//9XWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSU
+ pJJJJSklOujIuDnU02Wtb9IsY5wHx2hRDLDUbgx3pA7TZB2A/ul/0dySlklMUXl7axU82PG5rNrtxHO5
+ rI3OaiPpBqxxTRcLnB/qEtJbYWnnHA/0bf5xJSBJTfRfW1r7an1sf9Bz2loPf2ucEvQyPR9c1Wej/pdj
+ tn+fG1JTBJJoc5wa0FznEBrQJJJ4ACs4uOfVacnGyLKXB4DamkOLm6e2R/g3fziSmskpU0ZF+lNb7nNA
+ 3em0uj47QrnS+nfas5uPlMtqYWPfq0sJ2FvHqN+j70lNFJSdRk1hnrU2Vmz6Aexzdx/dZuHucrOX0vKx
+ aqbHMe5tlfq2EVuArn/B2u/e/e3bElNRJSa3cDHKj8USCAD3WxnGUpRB9UfmCkXE/pmN/wAdV/1bEJFx
+ P6Zjf8dV/wBWxBc//9bWy/6Zk/8AHW/9W9CRcv8ApmT/AMdb/wBW9CSUpJJJJBdvEuyMnBxaum3ell4J
+ JsxN20XCQ71O3qfy2/8ACWf8Go4zreo4nVMVzPTttsrtNQBG1xc1l/td7v8AA77FXx7+kOZi2Xepi5OJ
+ BeaWgi4tLdr3O/f9vv8A69iJidarr61d1C1hbTe0tLGiXADZ6cx+d+j96KKLs5Lam5rep1ia8XHyGO8n
+ VOY1rP8Az+qXTp/yBOp9O+T57NVRHVwek5WI/d6+Rc57THt2WPbbZLv+3FZ6Vl1XZXScdk78VtwtkQJc
+ zTYfzvopKINo6r78npnVG5Njrg2ystDzuibPzf3forSsdl1dYyMjIe6vpdNQDg8/o3S1vsrr/Pdv/wDS
+ SyLcvp+Ph5VGG6223KsBd6rQ1rAx2/bp9NGyepdJyb/tt/rXvDPZgWCam2R9Pd9DajYWcMqHcV1/vOd0
+ 8D7biaR+nq08Pe1bmLddZ9Z7m2Pc5tbbBW0nRoir6DfzVgYtwpyKLX6tqsY98cw1zXOj7loY3VMarrd2
+ e8O9CwP2w33e704lv9hEkfgsjjyCrP6QO/Rb1LqPqzQ7Gc+p7r3bnVEgkw/buLP6rFrEk/WesnkYn3e5
+ U+mMtwulscbbmPzYtY7GqddsaA32u9ttTXv/AKm//ttV8bPxsPrDsiyy+9uxzbbLWRZ6hLfb6fs2tY1m
+ 33JEjX6qGPIOH/B4tf3P++Xx8jIv6JnOvtfa6t1T63PMlrtzTuY781S6vkZBpwWG1+23FabW7jDyQ2TY
+ Pz1RxsyurpmXiPB9W/Z6cCW+0jducj5GZgZWHR6j7asrGpFLaw0OY4iNrt37vt/eR4o39WI4c3BV+rhA
+ +brx8X/RaYAHCZzQ74+KZriQSdIUXPnQcJ5lHh730a+PDmOWgeGUD6p78P8A3391ii4n9Mxv+Oq/6tiE
+ i4n9Mxv+Oq/6tigdV//X1sv+mZP/AB1v/VvQkXL/AKZk/wDHW/8AVvQklKSSSSUpJJJJSlKu22p4sqea
+ 7G8PaYInRRSSUokkknUnUnzKSSSSlJJJJKTVZubQzZTkWVMmdjXECT/JQSSSSTJJkk6kk8lJJJSkkkkl
+ KnSOySSSSlIuJ/TMb/jqv+rYhIuJ/TMb/jqv+rYkp//Q1sv+mZP/AB1v/VvQlZysXLOXkEY9xButIIqe
+ QQXv1+gh/ZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8A
+ bT//ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/
+ APIJfZMz/uNd/wBtP/8AIJKRJIv2TM/7jXf9tP8A/IJfZMz/ALjXf9tP/wDIJKRJIv2TM/7jXf8AbT//
+ ACCX2TM/7jXf9tP/APIJKRJIv2TM/wC413/bT/8AyCX2TM/7jXf9tP8A/IJKRJIv2TM/7jXf9tP/APIJ
+ fZMz/uNd/wBtP/8AIJKRIuJ/TMb/AI6r/q2JfZMz/uNd/wBtP/8AIImLi5Yy8cnHuAF1RJNTwAA9mv0E
+ lP8A/9kAOEJJTQQhAAAAAABVAAAAAQEAAAAPAEEAZABvAGIAZQAgAFAAaABvAHQAbwBzAGgAbwBwAAAA
+ EwBBAGQAbwBiAGUAIABQAGgAbwB0AG8AcwBoAG8AcAAgAEMAUwA1AAAAAQA4QklND6AAAAAAAPhtYW5p
+ SVJGUgAAAOw4QklNQW5EcwAAAMwAAAAQAAAAAQAAAAAAAG51bGwAAAADAAAAAEFGU3Rsb25nAAAAAAAA
+ AABGckluVmxMcwAAAAFPYmpjAAAAAQAAAAAAAG51bGwAAAABAAAAAEZySURsb25nAyEH3wAAAABGU3Rz
+ VmxMcwAAAAFPYmpjAAAAAQAAAAAAAG51bGwAAAAEAAAAAEZzSURsb25nAAAAAAAAAABBRnJtbG9uZwAA
+ AAAAAAAARnNGclZsTHMAAAABbG9uZwMhB98AAAAATENudGxvbmcAAAAAAAA4QklNUm9sbAAAAAgAAAAA
+ AAAAADhCSU0PoQAAAAAAHG1mcmkAAAACAAAAEAAAAAEAAAAAAAAAAQAAAAA4QklNBAYAAAAAAAcACAEB
+ AAEBAP/hLC5odHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0i77u/IiBp
+ ZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5z
+ Om1ldGEvIiB4OnhtcHRrPSJBZG9iZSBYTVAgQ29yZSA1LjAtYzA2MCA2MS4xMzQ3NzcsIDIwMTAvMDIv
+ MTItMTc6MzI6MDAgICAgICAgICI+DQoJPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9y
+ Zy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4NCgkJPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9
+ IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczpwaG90b3Nob3A9
+ Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGhvdG9zaG9wLzEuMC8iIHhtbG5zOmRjPSJodHRwOi8vcHVybC5v
+ cmcvZGMvZWxlbWVudHMvMS4xLyIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEu
+ MC9tbS8iIHhtbG5zOnN0RXZ0PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3Vy
+ Y2VFdmVudCMiIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVz
+ b3VyY2VSZWYjIiB4bXA6Q3JlYXRvclRvb2w9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiB4
+ bXA6Q3JlYXRlRGF0ZT0iMjAxMi0wMy0yMVQxMjozNzowMSswMTowMCIgeG1wOk1ldGFkYXRhRGF0ZT0i
+ MjAxMi0wMy0yMVQxODo0ODoxOSswMTowMCIgeG1wOk1vZGlmeURhdGU9IjIwMTItMDMtMjFUMTg6NDg6
+ MTkrMDE6MDAiIHBob3Rvc2hvcDpDb2xvck1vZGU9IjMiIHBob3Rvc2hvcDpJQ0NQcm9maWxlPSJzUkdC
+ IElFQzYxOTY2LTIuMSIgZGM6Zm9ybWF0PSJpbWFnZS9qcGVnIiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAu
+ aWlkOkEzNTlCMTBBMEYyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiB4bXBNTTpEb2N1bWVudElEPSJ4bXAu
+ ZGlkOjAxODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiB4bXBNTTpPcmlnaW5hbERvY3VtZW50
+ SUQ9InhtcC5kaWQ6MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiPg0KCQkJPHBob3Rvc2hv
+ cDpUZXh0TGF5ZXJzPg0KCQkJCTxyZGY6QmFnPg0KCQkJCQk8cmRmOmxpIHBob3Rvc2hvcDpMYXllck5h
+ bWU9InN3aXBlIHJpZ2h0IiBwaG90b3Nob3A6TGF5ZXJUZXh0PSJzd2lwZSByaWdodCIvPg0KCQkJCTwv
+ cmRmOkJhZz4NCgkJCTwvcGhvdG9zaG9wOlRleHRMYXllcnM+DQoJCQk8cGhvdG9zaG9wOkRvY3VtZW50
+ QW5jZXN0b3JzPg0KCQkJCTxyZGY6QmFnPg0KCQkJCQk8cmRmOmxpPnhtcC5kaWQ6MDE4MDExNzQwNzIw
+ NjgxMUJBOURERjE1QTVBRUU4MTE8L3JkZjpsaT4NCgkJCQk8L3JkZjpCYWc+DQoJCQk8L3Bob3Rvc2hv
+ cDpEb2N1bWVudEFuY2VzdG9ycz4NCgkJCTx4bXBNTTpIaXN0b3J5Pg0KCQkJCTxyZGY6U2VxPg0KCQkJ
+ CQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iY3JlYXRlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDow
+ MTgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMjoz
+ NzowMSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4
+ bXAuaWlkOjAyODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAz
+ LTIxVDEyOjM3OjM5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDM4MDExNzQwNzIwNjgxMUJBOURERjE1QTVB
+ RUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTI6NTc6MTMrMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDow
+ NDgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzow
+ MDowOCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjA1ODAxMTc0MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjAyOjQzKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MDY4MDExNzQw
+ NzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MDc6NTYrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDowNzgwMTE3NDA3MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxMzowODoxMSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhv
+ dG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2
+ dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjA4ODAxMTc0MDcyMDY4MTFC
+ QTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEzOjA4OjE4KzAxOjAwIiBzdEV2
+ dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdl
+ ZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9
+ InhtcC5paWQ6MEE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTIt
+ MDMtMjFUMTM6MDk6MzkrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyMjIzREUwQTBDMjA2ODExQkE5RERGMTVB
+ NUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzowOTo0OSswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OjIzMjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDEz
+ OjEwKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9z
+ aCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0
+ RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjQyM0RFMEEwQzIwNjgxMUJBOURERjE1QTVBRUU4MTEiIHN0
+ RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MTA6MjgrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFk
+ b2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6
+ bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDoyNTIzREUwQTBD
+ MjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxMzoxMjo0MyswMTow
+ MCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0
+ OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0
+ YW5jZUlEPSJ4bXAuaWlkOjI2MjNERTBBMEMyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdEV2dDp3aGVu
+ PSIyMDEyLTAzLTIxVDEzOjEzOjA2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90
+ b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0
+ OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6MjcyM0RFMEEwQzIwNjgxMUJB
+ OURERjE1QTVBRUU4MTEiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTM6MTg6NDArMDE6MDAiIHN0RXZ0
+ OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2Vk
+ PSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0i
+ eG1wLmlpZDoyODIzREUwQTBDMjA2ODExQkE5RERGMTVBNUFFRTgxMSIgc3RFdnQ6d2hlbj0iMjAxMi0w
+ My0yMVQxNzoxNDowNSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENT
+ NSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249
+ InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkY3N0YxMTc0MDcyMDY4MTE5NDU3OUEzM0ZC
+ MzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjU0KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFn
+ ZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJ
+ CQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6RkE3
+ RjExNzQwNzIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTc6NTU6
+ NTArMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3No
+ IiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RF
+ dnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpGQjdGMTE3NDA3MjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RF
+ dnQ6d2hlbj0iMjAxMi0wMy0yMVQxNzo1NjowNSswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRv
+ YmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjps
+ aSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOkZDN0YxMTc0MDcy
+ MDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE3OjU2OjUyKzAxOjAw
+ IiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6
+ Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3Rh
+ bmNlSUQ9InhtcC5paWQ6NDIzNjZCM0EwQTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49
+ IjIwMTItMDMtMjFUMTg6MjA6NDQrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rv
+ c2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6
+ YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo0MzM2NkIzQTBBMjA2ODExOTQ1
+ NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoyMDo1NiswMTowMCIgc3RFdnQ6
+ c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9
+ Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4
+ bXAuaWlkOjQ0MzY2QjNBMEEyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAz
+ LTIxVDE4OjIxOjM2KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1
+ IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0i
+ c2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6NDUzNjZCM0EwQTIwNjgxMTk0NTc5QTMzRkIz
+ NTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6MjI6MTcrMDE6MDAiIHN0RXZ0OnNvZnR3YXJl
+ QWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJ
+ CQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo0
+ NjM2NkIzQTBBMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoy
+ MjozMCswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRv
+ c2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBz
+ dEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjQ3MzY2QjNBMEEyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBz
+ dEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjIyOjM3KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJB
+ ZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRm
+ OmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6NDgzNjZCM0Ew
+ QTIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6MjQ6MzYrMDE6
+ MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2
+ dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5z
+ dGFuY2VJRD0ieG1wLmlpZDo0OTM2NkIzQTBBMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hl
+ bj0iMjAxMi0wMy0yMVQxODoyNToxMyswMTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhv
+ dG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2
+ dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjUxQUM5REVFMEIyMDY4MTE5
+ NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4OjI2OjQxKzAxOjAwIiBzdEV2
+ dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdl
+ ZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9
+ InhtcC5paWQ6NTJBQzlERUUwQjIwNjgxMTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTIt
+ MDMtMjFUMTg6Mjc6MzcrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBD
+ UzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9u
+ PSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1M0FDOURFRTBCMjA2ODExOTQ1NzlBMzNG
+ QjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODoyODo0MSswMTowMCIgc3RFdnQ6c29mdHdh
+ cmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OjU0QUM5REVFMEIyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4
+ OjMwOjExKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0RXZ0OmFjdGlvbj0ic2F2ZWQi
+ IHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6NTZBQzlERUUwQjIwNjgxMTk0NTc5QTMzRkIzNTY0Nzki
+ IHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6MzE6MjUrMDE6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9
+ IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFuZ2VkPSIvIi8+DQoJCQkJCTxy
+ ZGY6bGkgc3RFdnQ6YWN0aW9uPSJzYXZlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDo1N0FDOURF
+ RTBCMjA2ODExOTQ1NzlBMzNGQjM1NjQ3OSIgc3RFdnQ6d2hlbj0iMjAxMi0wMy0yMVQxODozMjowMSsw
+ MTowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIENTNSBNYWNpbnRvc2giIHN0
+ RXZ0OmNoYW5nZWQ9Ii8iLz4NCgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDpp
+ bnN0YW5jZUlEPSJ4bXAuaWlkOkRDNTMxRDg0MEUyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3
+ aGVuPSIyMDEyLTAzLTIxVDE4OjQ2OjMyKzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQ
+ aG90b3Nob3AgQ1M1IE1hY2ludG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCQk8cmRmOmxpIHN0
+ RXZ0OmFjdGlvbj0ic2F2ZWQiIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6QTI1OUIxMEEwRjIwNjgx
+ MTk0NTc5QTMzRkIzNTY0NzkiIHN0RXZ0OndoZW49IjIwMTItMDMtMjFUMTg6NDg6MTkrMDE6MDAiIHN0
+ RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCBDUzUgTWFjaW50b3NoIiBzdEV2dDpjaGFu
+ Z2VkPSIvIi8+DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJjb252ZXJ0ZWQiIHN0RXZ0OnBhcmFt
+ ZXRlcnM9ImZyb20gYXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rvc2hvcCB0byBpbWFnZS9qcGVnIi8+
+ DQoJCQkJCTxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJkZXJpdmVkIiBzdEV2dDpwYXJhbWV0ZXJzPSJjb252
+ ZXJ0ZWQgZnJvbSBhcHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRvIGltYWdlL2pwZWciLz4N
+ CgkJCQkJPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlk
+ OkEzNTlCMTBBMEYyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdEV2dDp3aGVuPSIyMDEyLTAzLTIxVDE4
+ OjQ4OjE5KzAxOjAwIiBzdEV2dDpzb2Z0d2FyZUFnZW50PSJBZG9iZSBQaG90b3Nob3AgQ1M1IE1hY2lu
+ dG9zaCIgc3RFdnQ6Y2hhbmdlZD0iLyIvPg0KCQkJCTwvcmRmOlNlcT4NCgkJCTwveG1wTU06SGlzdG9y
+ eT4NCgkJCTx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOkEyNTlCMTBB
+ MEYyMDY4MTE5NDU3OUEzM0ZCMzU2NDc5IiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjAxODAxMTc0
+ MDcyMDY4MTFCQTlEREYxNUE1QUVFODExIiBzdFJlZjpvcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6
+ MDE4MDExNzQwNzIwNjgxMUJBOURERjE1QTVBRUU4MTEiLz4NCgkJPC9yZGY6RGVzY3JpcHRpb24+DQoJ
+ PC9yZGY6UkRGPg0KPC94OnhtcG1ldGE+DQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAK
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
+ ICAKICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSd3Jz8+/+IMWElDQ19QUk9GSUxFAAEBAAAMSExp
+ bm8CEAAAbW50clJHQiBYWVogB84AAgAJAAYAMQAAYWNzcE1TRlQAAAAASUVDIHNSR0IAAAAAAAAAAAAA
+ AAEAAPbWAAEAAAAA0y1IUCAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAARY3BydAAAAVAAAAAzZGVzYwAAAYQAAABsd3RwdAAAAfAAAAAUYmtwdAAAAgQAAAAUclhZWgAA
+ AhgAAAAUZ1hZWgAAAiwAAAAUYlhZWgAAAkAAAAAUZG1uZAAAAlQAAABwZG1kZAAAAsQAAACIdnVlZAAA
+ A0wAAACGdmlldwAAA9QAAAAkbHVtaQAAA/gAAAAUbWVhcwAABAwAAAAkdGVjaAAABDAAAAAMclRSQwAA
+ BDwAAAgMZ1RSQwAABDwAAAgMYlRSQwAABDwAAAgMdGV4dAAAAABDb3B5cmlnaHQgKGMpIDE5OTggSGV3
+ bGV0dC1QYWNrYXJkIENvbXBhbnkAAGRlc2MAAAAAAAAAEnNSR0IgSUVDNjE5NjYtMi4xAAAAAAAAAAAA
+ AAASc1JHQiBJRUM2MTk2Ni0yLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAFhZWiAAAAAAAADzUQABAAAAARbMWFlaIAAAAAAAAAAAAAAAAAAAAABYWVogAAAAAAAA
+ b6IAADj1AAADkFhZWiAAAAAAAABimQAAt4UAABjaWFlaIAAAAAAAACSgAAAPhAAAts9kZXNjAAAAAAAA
+ ABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAAAAAAAAAAABZJRUMgaHR0cDovL3d3dy5pZWMuY2gAAAAA
+ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGVzYwAAAAAAAAAuSUVDIDYx
+ OTY2LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAuSUVDIDYxOTY2
+ LTIuMSBEZWZhdWx0IFJHQiBjb2xvdXIgc3BhY2UgLSBzUkdCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRl
+ c2MAAAAAAAAALFJlZmVyZW5jZSBWaWV3aW5nIENvbmRpdGlvbiBpbiBJRUM2MTk2Ni0yLjEAAAAAAAAA
+ AAAAACxSZWZlcmVuY2UgVmlld2luZyBDb25kaXRpb24gaW4gSUVDNjE5NjYtMi4xAAAAAAAAAAAAAAAA
+ AAAAAAAAAAAAAAAAAAB2aWV3AAAAAAATpP4AFF8uABDPFAAD7cwABBMLAANcngAAAAFYWVogAAAAAABM
+ CVYAUAAAAFcf521lYXMAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAKPAAAAAnNpZyAAAAAAQ1JUIGN1
+ cnYAAAAAAAAEAAAAAAUACgAPABQAGQAeACMAKAAtADIANwA7AEAARQBKAE8AVABZAF4AYwBoAG0AcgB3
+ AHwAgQCGAIsAkACVAJoAnwCkAKkArgCyALcAvADBAMYAywDQANUA2wDgAOUA6wDwAPYA+wEBAQcBDQET
+ ARkBHwElASsBMgE4AT4BRQFMAVIBWQFgAWcBbgF1AXwBgwGLAZIBmgGhAakBsQG5AcEByQHRAdkB4QHp
+ AfIB+gIDAgwCFAIdAiYCLwI4AkECSwJUAl0CZwJxAnoChAKOApgCogKsArYCwQLLAtUC4ALrAvUDAAML
+ AxYDIQMtAzgDQwNPA1oDZgNyA34DigOWA6IDrgO6A8cD0wPgA+wD+QQGBBMEIAQtBDsESARVBGMEcQR+
+ BIwEmgSoBLYExATTBOEE8AT+BQ0FHAUrBToFSQVYBWcFdwWGBZYFpgW1BcUF1QXlBfYGBgYWBicGNwZI
+ BlkGagZ7BowGnQavBsAG0QbjBvUHBwcZBysHPQdPB2EHdAeGB5kHrAe/B9IH5Qf4CAsIHwgyCEYIWghu
+ CIIIlgiqCL4I0gjnCPsJEAklCToJTwlkCXkJjwmkCboJzwnlCfsKEQonCj0KVApqCoEKmAquCsUK3Arz
+ CwsLIgs5C1ELaQuAC5gLsAvIC+EL+QwSDCoMQwxcDHUMjgynDMAM2QzzDQ0NJg1ADVoNdA2ODakNww3e
+ DfgOEw4uDkkOZA5/DpsOtg7SDu4PCQ8lD0EPXg96D5YPsw/PD+wQCRAmEEMQYRB+EJsQuRDXEPURExEx
+ EU8RbRGMEaoRyRHoEgcSJhJFEmQShBKjEsMS4xMDEyMTQxNjE4MTpBPFE+UUBhQnFEkUahSLFK0UzhTw
+ FRIVNBVWFXgVmxW9FeAWAxYmFkkWbBaPFrIW1hb6Fx0XQRdlF4kXrhfSF/cYGxhAGGUYihivGNUY+hkg
+ GUUZaxmRGbcZ3RoEGioaURp3Gp4axRrsGxQbOxtjG4obshvaHAIcKhxSHHscoxzMHPUdHh1HHXAdmR3D
+ HeweFh5AHmoelB6+HukfEx8+H2kflB+/H+ogFSBBIGwgmCDEIPAhHCFIIXUhoSHOIfsiJyJVIoIiryLd
+ IwojOCNmI5QjwiPwJB8kTSR8JKsk2iUJJTglaCWXJccl9yYnJlcmhya3JugnGCdJJ3onqyfcKA0oPyhx
+ KKIo1CkGKTgpaymdKdAqAio1KmgqmyrPKwIrNitpK50r0SwFLDksbiyiLNctDC1BLXYtqy3hLhYuTC6C
+ Lrcu7i8kL1ovkS/HL/4wNTBsMKQw2zESMUoxgjG6MfIyKjJjMpsy1DMNM0YzfzO4M/E0KzRlNJ402DUT
+ NU01hzXCNf02NzZyNq426TckN2A3nDfXOBQ4UDiMOMg5BTlCOX85vDn5OjY6dDqyOu87LTtrO6o76Dwn
+ PGU8pDzjPSI9YT2hPeA+ID5gPqA+4D8hP2E/oj/iQCNAZECmQOdBKUFqQaxB7kIwQnJCtUL3QzpDfUPA
+ RANER0SKRM5FEkVVRZpF3kYiRmdGq0bwRzVHe0fASAVIS0iRSNdJHUljSalJ8Eo3Sn1KxEsMS1NLmkvi
+ TCpMcky6TQJNSk2TTdxOJU5uTrdPAE9JT5NP3VAnUHFQu1EGUVBRm1HmUjFSfFLHUxNTX1OqU/ZUQlSP
+ VNtVKFV1VcJWD1ZcVqlW91dEV5JX4FgvWH1Yy1kaWWlZuFoHWlZaplr1W0VblVvlXDVchlzWXSddeF3J
+ XhpebF69Xw9fYV+zYAVgV2CqYPxhT2GiYfViSWKcYvBjQ2OXY+tkQGSUZOllPWWSZedmPWaSZuhnPWeT
+ Z+loP2iWaOxpQ2maafFqSGqfavdrT2una/9sV2yvbQhtYG25bhJua27Ebx5veG/RcCtwhnDgcTpxlXHw
+ cktypnMBc11zuHQUdHB0zHUodYV14XY+dpt2+HdWd7N4EXhueMx5KnmJeed6RnqlewR7Y3vCfCF8gXzh
+ fUF9oX4BfmJ+wn8jf4R/5YBHgKiBCoFrgc2CMIKSgvSDV4O6hB2EgITjhUeFq4YOhnKG14c7h5+IBIhp
+ iM6JM4mZif6KZIrKizCLlov8jGOMyo0xjZiN/45mjs6PNo+ekAaQbpDWkT+RqJIRknqS45NNk7aUIJSK
+ lPSVX5XJljSWn5cKl3WX4JhMmLiZJJmQmfyaaJrVm0Kbr5wcnImc951kndKeQJ6unx2fi5/6oGmg2KFH
+ obaiJqKWowajdqPmpFakx6U4pammGqaLpv2nbqfgqFKoxKk3qamqHKqPqwKrdavprFys0K1ErbiuLa6h
+ rxavi7AAsHWw6rFgsdayS7LCszizrrQltJy1E7WKtgG2ebbwt2i34LhZuNG5SrnCuju6tbsuu6e8Ibyb
+ vRW9j74KvoS+/796v/XAcMDswWfB48JfwtvDWMPUxFHEzsVLxcjGRsbDx0HHv8g9yLzJOsm5yjjKt8s2
+ y7bMNcy1zTXNtc42zrbPN8+40DnQutE80b7SP9LB00TTxtRJ1MvVTtXR1lXW2Ndc1+DYZNjo2WzZ8dp2
+ 2vvbgNwF3IrdEN2W3hzeot8p36/gNuC94UThzOJT4tvjY+Pr5HPk/OWE5g3mlucf56noMui86Ubp0Opb
+ 6uXrcOv77IbtEe2c7ijutO9A78zwWPDl8XLx//KM8xnzp/Q09ML1UPXe9m32+/eK+Bn4qPk4+cf6V/rn
+ +3f8B/yY/Sn9uv5L/tz/bf///9sAQwABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+ AQEBAQEBAgICAgICAgICAgIDAwMDAwMDAwMD/9sAQwEBAQEBAQEBAQEBAgIBAgIDAwMDAwMDAwMDAwMD
+ AwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMD/8IAEQgA+gD6AwERAAIRAQMRAf/EAB0A
+ AQACAgMBAQAAAAAAAAAAAAAHCQYIAwQFAQL/xAA3EAAABQQABAMFBgYDAAAAAAACAwQFBgABBwhAExg4
+ IDAJEBExFBUSNDUWNhdwkCI3GTkhMiP/xAAdAQEAAQUBAQEAAAAAAAAAAAAAAwECBAUGBwgJ/8QAWxEA
+ AAUCAgQGDgMJCwsFAAAAAQIDBAUUBgAHERITFSEWJhc3CDBAMUVl1bZHd5cYaEmJIEEiEFFhgTIkNDU2
+ 8HGxwdFCIzMldbeR8VKCY4NktFVWOWZ2OEiI/8QASBIAAgAEBAIFBQkNCQAAAAAAAQIAEQMEITESBUFR
+ YXEyEwYw8JGxIhBAgaHB0UIzFHCQUnKSssJDc7PDNLRQ4eIjY5PEFTX/2gAMAwEAAhADEAAAALhyJgAA
+ AAAAAAAAAAAAWylTRDIAAAAAAAAAAAAAALmCs0hkAAAAAAAAAAAAAAFzBWaQyAAAAAAAAAAAAAAC5grN
+ IZAAAAAAAAAAAAAABcwVmkMgAAAAAAAAAAAAAAuYKzSGQAAACWSTTVkAAAAAAAAAuYKzSGQAAADZkzM0
+ zAAAAAAAAALmCs0hkAAAA2ZMzNMwAAAAAAAAC5grNIZAAAANmTMzTMAAAAAAAAAuYKzSGQAAADZkzM0z
+ PaOkdIAAAAAAAFzBWaQyAAAAbMmZkZncMnNfzDAAAAAAAC5grNIZAAAAJzJZBH4JAIzNfwAAAAAAXMFZ
+ pDIAAAANjCQAYYZMd0gwiYAAAAAAuYKzSGQAAAAd02ZMmABDJDIAAAAABcwVmkMgAAAAHdNmTJgCGSGQ
+ AAAAAC5grNIZAAAAABmZsyAQyQyAAAAAAXMFZpDIAAAAAMzNmQCGSGQAAAAAC5grNIZAAAAAAAAAAAAA
+ ABcwVmkMgAAAAAAAAAAAAAAuYKzSGQAAAAZ8YCAADPjAQZcYiAck+r44NoABcwVmkMgAGWm0pEx0DlJV
+ PhGRnpEJFRusdQjQlY3KNIjYEg81F6z599LfeS4p5v8Aa/y2UC5grNIZArZ+78X7fjWgLvPkw52pfPls
+ sKza3DJdflF+P59+N6EmL0rseoPpPFbmND6xi0uD6N0Hbvg/N0Hk5Gp6d2Pov1HhMQbXgubL5/yeZ9uw
+ vyn9AeODaC5grNIZArZySYn2/Fnu+CyGyeDZtbYjFsMAlwYIn1HLJifb8bbrF31We/8AJNLdx5vbZofW
+ Pt+P7CmD5fPZNbNiWVovZV0D6355jzYcd+pcPo6f0fCPI/0R62B1YuYKzSGQAoNhTc0rsrbNyvpHTW2t
+ K1oKSmQBWmqF0G2VsqtLb1NNrodWbZvHrbj5sdWPRDrPn72ep8Ew3yv76/EOxAuYKzSGQAAAACYCHwAA
+ bMEbkXgA583meHD6L5SQAXMFZpDIAAAAAAAAAAAAAALmCs0hkAAAAAAAAAAAAAAFzBWaQyAAAAAAAAAA
+ AAAAC5grNIZAAAAAAAAAAAAAABcwVmkMgAAAAAAAAAAAAAAuYMzMMAAAAAAAAAAAAAABuYf/2gAIAQIA
+ AQUA/lMkJj1N+Ph34q/xYKiwgiALx2q1qta1GB/psABoTwfZCova4x2CYaEIfqCIssakssuzqzlFG0gL
+ KG5BTJ6j6cg6wCivzGQQSORuKcguQOqcj8wSlGlISSROQWzt7ehujKSpiRWp9jRDoFQmPSHeK1Wq1XEE
+ NDD9ijP6yCg3MCi94zg/iTf96B+MICFCiyD5MgYb2qN/9C/1M4WOQO6dC4rnN0/Uku+4yb8Cbr2+Qte1
+ Wp5fUrOU4OKpzP8AI99/Z771771a97Va97V9oXvte9r2EK17CEGrCEG/ONoIxgrmD+1cwwV+efVzDBCG
+ aaZYRpowhPODaIHHGOj7JCWwJ55yo3jUS9Q3jEIQxfxF/9oACAEDAAEFAP5TLm9NbKG17Xtx2yXv/IOI
+ s8HM4iDyVJPjHf3WGK9DGKkZv/qNQpQntai5x7MEwKVOM5EgPPOtDpQtVpmRYsVmQHI7guQXlyxclhBz
+ 07WrMDu6NxipwXWwu6ujklwxDnh1WYigLy62xFgSRPzrIcKvDsqyRMJfKgSRwfXlxJMrFGbXSCHsz01y
+ Fu8Q/gOh0Ek026Y/5qkdvlXZcdZIfJrhTtp/6Kl1r3YlNr/tzLXRmaDJbeSOqY4IqzXa91Cu1/2NiBjd
+ K8dvEqhsWg0Ctf8AZTXa17SrB1r2yrMgD/NZgRWoysbYpfsjOEQhbBCGrx+61fZDVrWtVghtXLB7xAAK
+ 4gAHXKKuARZYwiKKGAwkk2xhBJwfpyCjkqZRe6VNckCNIWX9Ka6AiRlEp0CJIIlAhTmmtbYcLYptbkkE
+ xVhVynJ7S0tzG38bJ4m0S5MSSUnK/iL/AP/aAAgBAQABBQDPmfM6s2deo3YWuo3YWuo3YWuo3YWuo3YW
+ uo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YW
+ uo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWuo3YWv3HyHWxvcLx+xvcLx+xvcLx+xvcLx+xvcLx
+ +xvcL5OL8ejmC1TjkcsZeE2N7hfJw8x/UWONRrn8Lsb3C+Th5j+oscajXP4XY3uF8nDzH9RY41Gufwux
+ vcL5OHmP6ixxqNc/2McckMmVL21xaj+B2N7hfJw8x/UWONRrn1IcYOj614bStzskTY8QydK7wCVs6XgN
+ je4XycQuTKrWxqNc+o1GufS/H70oBj+SRuQvUajXPqQ4wdH1r8/Y3uF8rEy8ErWxqNc+o1GufRuKi5Ql
+ hcXcRERqNc+sjx4huafO2N7hfKbV57U445UsssHGo1z6jUa59RqNc+o1GufWSm35KMedsb3C+W2rz2px
+ xypZZYONRrn1Go1z6jUa59ZKbfkox52xvcL5mOE3zuQ41GufUajXPqNRrn1kpt+SjHnbG9wvmY4TfO5D
+ jUa59RqNc+o1GufWSm35KMedsb3C8fsb3C8fsb3C+VfFuQw4+8V8W5DDj72McAnEmZ/aWUYb49je4Xww
+ aBzDJUmlPp+7RRWPY51qy5laD4q18yrmlpwzrvlXPo1jPtCRqIwaHbNyUGZ9bMw4CNxdpHsXlqPZYwll
+ DCDzSP099qFb67R7aVs1Nw1rBmrPJL96e+1DADS6Jv0z0Pn2h+y2O416d2sBc/kWyGomY8ZrGL765s9j
+ bXtcN/Bsb3C+y3xDVrWvf0tZfEWDLqfKmxej+dfTtyE0T3JXpywD8g4UwZHh684Ec7W/xPbpzGVxfVWd
+ vLrNvS89TWVyeGX3BE5D0gsUVXqfzWXMKlzAD/FRI166LemRru+vT96fOorw6RnRD005xMn3Inp9nHoN
+ nM1yOQuGTCySgVb4OTSWssaUYQP27G9wvst8Q1b44UwFlnMqfUXYU3aVNq8iJwJvzn2aNmFcg+oysaoB
+ r+5/6nt8Aivq46BEH0o9v8s4Qw457Qqtjspx21eqr+oHP/VVrk4Q/O+n00zdrxhfW/WL/X56X3929Bu7
+ fMH/ABly3wt8F7iShAqVHKzPbsb3C+HXLZCba2TJT6jkOjiOPZHkbJk7ZTayR7ETjarbl62ipVtW4qdV
+ s25yjWFddNmt0XXPMWg/qFoDYLs5ttL9k1PMHW1G1jls+4KdrHJTqsRD2HVDFWwObYvFYHjDaxyxpr7q
+ 7ss46zS7FewsvxBmPO25+LswwhjMMEscXUtGEw0w4fg2N7hfLn+e8sZQi3igm4uyuNWDKuaMnZuevAnU
+ mphXvcV/Dsb3C8fsb3C8fsb3C8fsb3C8fsb3C8fkf+4fH//aAAgBAgIGPwD70y4oUyxVZkDOQzP9gN+z
+ MPe7cgFfNk4N0jkejjDI6kMDiDw8llAIEDTgYpkZjCAFGAAi2UASIBPy+qCukaf8MXAdAQCZemGphBol
+ lw7IPriu1SmGMxmJ84ugiA0AD1ZjL45dEfUr6BFy1WkrEFQJics4el3Y7uWUsPqwcor0npKaYBkJYdkc
+ I26mlFRTYISAMCdbDLqAjbKPdL3TKkxLA+22cW1Shboj95KYAGEiZYdUWVZKKiq1RJkAAmaMTj1xZubO
+ nrNJCTpE5lR0RrpUEVuYAHuNcW8kvgM+DdDdPTD0LimUqqcQfP4/JCfGA6GUauOcV2OYXz9UAn6K+frg
+ 9X6MXXWfXDdX6AirTpVtFLDVz4/38QIe0t2nWGLHqIGeXHIe5dda/LD9X8MRTu7Qq9aqOxiTlI5cDKYM
+ 858BFHcNwprSSnKQBBJlMgYE8TMk9QEbV+Kn57Ra/tf0Wiw/aJ+7eLHH9Sn5ojP3PbOq5I9lBn1nkPMQ
+ a91UmeA4AcgPI5+5nEpxgYwMTmZxMHGJgmcTViDBKsQY+sb0mDocjqjXrOvnPGAxclhkZx9c/pMBy5Lj
+ IzxgB6jEdJnAV6jFeRJgBazADpMFXqsR3ZzJMNb25D3xGXBek9PIemHr16haqxmSff1SpbNKoylZ8QDy
+ 6YLMxLE4k/dG/9oACAEDAgY/APvTNq+6XqUKdaqKaM+Cl27KzyBPCchAIOHv+kRwvKfyxa+GvGdw1Tas
+ FpXBxalwC1Dm1MZBsSozmIpXFvVV6DqCrKQQwOIIIwIPkMIzMdow6u2JGEMas3U8zgekZxeIxOlvaA5C
+ Zn6xDNWcl2qMMTywl6QY3yrUqMWR3VZnkJKR8LCErCq3ezznj9aRn1YRs7W9y6M6rqIJBPsDMjHPGKV4
+ 9w5utXbmdWFZlGOfZwjaaNld1KVMq5IRis5aAJyxMhlGxPc3FRd0dqczMh5d25OrI5adU8dUp44wZblX
+ /Lb542SjYX9WjTdarMEYrqIKATlKcpmXWYt70XdT7Yah9vUdX8469rPLDqwja762vqqXjuoaoGIcg1qk
+ 5tOeMgM8sMsI8aXd1uFapdUWuVR2YllAt6LABiZgBmYjHAkx433P/sKp3CjVudFQsS6StqBGkmZEiSRL
+ I4jGN8s9z3e4uLUWesLUdnAcVEXUNRMjJiDKU8JzkJeJ9tutyr1LCla3JSmzsyKVuqCqQpJAIUkA5yJ5
+ x4ktU8RXotkv7hVXvqmkKtZwABqkAAAAOEChf7pXrUJz0u7MJ85EwYpbRu5e68LM3ZnN6E/pUp5rzp5H
+ hIxbbrs16lxYVVBVlM/gIzBGRBkQcCPIH3GNMYrLo88oa1uU1CWB6vPOO6n7MyvzfGBG10kwVq5J+GYP
+ 58PTpiRrVQT8AmT6VEJ+N/GMbHIfRX92IpiWOr/kNFheX+2m5vgG7kfREipJJOAx0yOlmHCWcW+/7tQF
+ PbnIWioIkA6s4IWZbELizSJwwlIA4GNgkP1db104thLHvD/WvF74e39attt1i0zdAqqD2zUXFs3XUVZd
+ JBUqZh2Ebn4P8I3la+ubwt3lRkZVXvAqux1IkzoQKioCB2maYIPj8Sx7y6/paEb7MH+QP76nHi0kGX2S
+ 6/q7ePFHsH/0bnh/rPGKmDB+zKaGx02/zbhh7I5qn4dQjgMBm0hFPathtBTpyGtzi9RhP2nbiZky4Cch
+ 5DKOyIwETCicatAn1QCyAkcxA1oD1icd2aa93ykJeiAjUwU5EAj0QKbU1NMcCBL0QFq0lZRkCAfXCpVp
+ KyjIEAgR/JUvyV+aFNe3RyMtQBl1Tj7MbdPs/wCDpGnOeWWePXFSjTtaa0m7ShRI9YlI/DH/AJtv/tp8
+ 0VLena01t2nNQoCmYkZiUjMACGe1tKVNyJEqoUkcsBDV6FnSSsZzZVAJniZkCeJxh2rbdQZmMyTTUknm
+ SRiekxTqWthRp1PtdPFUVTx4gCKW77wr23hdW7WT15Hs05/R4NUy4LM5W21bTZpQsKK6URRIAfKTmScS
+ cT7+s7Le6RqWVGutXROSsy5BuJXmMjxinQoUlSgigKqgAADAAAYADl90b//aAAgBAQEGPwDOmIiM6c2Y
+ qJis2cxo2Li43Ma8GMdGxzG8JlqyYMGTWZSbM2TNskVNJJMpSJkKBSgAAAY6eM5vWhe/jzHTxnN60L38
+ eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/
+ jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L3
+ 8eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe
+ /jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L38eY6eM5vWhe/jzHTxnN60L
+ 38eY/by8/wDxNc4/7UTnSH/35+nftn4U/Tv9rjPj0zZoeW852/8AJnxnx6Zs0PLec7f+TPjPj0zZoeW8
+ 52/8mfGfHpmzQ8t5zt/5M+M+PTNmh5bznb/yZ8Z8embNDy3nOxFVlIG5nkI5ewsawfQ6F0IoOpFXMDLa
+ 3Jtgg+t3LPM5Rw9axN+IEFIGZToOJBmcgO3KjSJk4CPbwr1jIOWVrJxUg1tK6EUCyM9A9VyBRdSSNo9W
+ xlLXGyMnfB1ioFfujruJBJw3WdvHjZzePafyZ8Z8embNDy3nOxQSvF7eu1vNZttuJ2/9tozD6tzOkqfZ
+ 0zYqdG+thT1r3RX7CgLX7ruy1OSlRUc33m+rKms9kb3Rrhrq7jD4Uqt6d9N6cuO0/kz4z49M2aHlvOdi
+ gleL29dreazbbcTt/wC20Zh9W5nSVPs6ZsVOjfWwp617or9hQFr913ZanJSoqOb7zfVlTWeyN7o1w11d
+ xh8KVW9O+m9OXHafyZ8Z8embNDy3nOxQSvF7eu1vNZttuJ2/9tozD6tzOkqfZ0zYqdG+thT1r3RX7CgL
+ X7ruy1OSlRUc33m+rKms9kb3Rrhrq7jD4Uqt6d9N6cuO0/kz4z49M2aHlvOdigleL29dreazbbcTt/7b
+ RmH1bmdJU+zpmxU6N9bCnrXuiv2FAWv3XdlqclKio5vvN9WVNZ7I3ujXDXV3GHwpVb076b05cYOxtuBm
+ rhep0O0aQcW+lnRN5zEZb0brt2CDhUu8J+aZsUNIf0rx2iiXSoqQpk2sowexrlVlGySTd+1XZrqR0zHN
+ ZeIfppOE01DspWJfIOmyoBqLt1iKEExDlMPaHyZ8Z8embNDy3nOxQSvF7eu1vNZttuJ2/wDbaMw+rczp
+ Kn2dM2KnRvrYU9a90V+woC1+67stTkpUVHN95vqyprPZG90a4a6u4w+FKrenfTenLiHk7egZpSZUhbUS
+ COY2zd62/ttaGQEVDsYaPiMl7Shk5qRmsziLmdrPnW8qpADuHTh1GyVyRkalGspmWbXM2cPWKdsIXFIo
+ x0pmVkBExajpMvV4zZciykHJnjRAh3Twip1VmxGOl2eKuq0Wj+25rZK8TNB4OBuGEdOt+Q/VZg19d9bf
+ VaePZKqZXuqdDWUldLyRRdo7wdO2615jJHhJp3DEhYecXnUbduVpDtWsvD2VLiRw7mIWL1d3c4cMgsuB
+ RZqqyTQ7ZZw3eM13HZ/kz4z49M2aHlvOdihLWdRbJxLOLmihYC6hoGbXnV5vMDKFNCCjWIZFZtXG9eto
+ +3pE5kVAcN1m7hVJs1VFV9E3FanJSoqOb7zfVlTWeyN7o1w11dxh8KVW9O+m9OXFqclKio5vvN9WVNZ7
+ I3ujXDXV3GHwpVb076b05cWxc1q269c3GxZWU6bRKljz09HXEuja/V9ZQUa1tfmNgLQkXspO5lJrLmkF
+ 5BvMkdIprqvFXcfIXLbsAFusm8gd7Y8ayRdQdky69wyIz2RsGuwjY+C6t98yz166Ts+UeGScN3h3Dd8q
+ mYJJ4tKNbptTkpUVHN95vqyprPZG90a4a6u4w+FKrenfTenLiHk7egZpSZUhbUSCOY2zd62/ttaGQEVD
+ sYaPiMl7Shk5qRmsziLmdrPnW8qpADuHTh1GyVydm+TPjPj0zZoeW852NlEK2wykJCKe2qosuwsq13yD
+ mOd5gZEWhFNVI2F6vuaMso92cOom5XeFXJJuJM5Sounj5/GXNanJSoqOb7zfVlTWeyN7o1w11dxh8KVW
+ 9O+m9OXFqclKio5vvN9WVNZ7I3ujXDXV3GHwpVb076b05cRSjWImmUzKwtjxke7RhL5CHSdPYfq3RTF8
+ 4grW6uzXeu25zV1VhbOVnkiq9aKg5fuFI9xdtrllLeZSjly9tBRJVhleuigtHSMj1UFYhqo3cdVi9lJJ
+ 7um5EEHK4KyJJVxIHXIi7JMFb3nanJSoqOb7zfVlTWeyN7o1w11dxh8KVW9O+m9OXFpzZY16wcyzKFYK
+ qKMJGMjnKEflRlFMt1GrRXK3L+JO9WUulVyu5Qdyrh4Ryiuudcijebney/Jnxnx6Zs0PLec7GwlGqbJV
+ zGvWr9ulJRsdMxyi7NdNwkm/iJdq+iZVkdRMAVbOkFm65NJFCHIYxRhW8fAMnMgxe2k1kIpO1oGekSoI
+ 3R1bLRRknSMD1XL4TMyuOWZPyoFWPIOFzulm7hJ48duW142pyUqKjm+831ZU1nsje6NcNdXcYfClVvTv
+ pvTlxanJSoqOb7zfVlTWeyN7o1w11dxh8KVW9O+m9OXFqclKio5vvN9WVNZ7I3ujXDXV3GHwpVb076b0
+ 5cWpyUqKjm+831ZU1nsje6NcNdXcYfClVvTvpvTlxZK+6d31VJ+ccX9z1mtlDkhI/pnNHl5vHW3pVfrK
+ Z1qyq+3Wb8uHsvyZ8Z8embNDy3nOyMJRqmyVcxr1q/bpSUbHTMcouzXTcJJv4iXavomVZHUTAFWzpBZu
+ uTSRQhyGMUYVvHwDJzIMXtpNZCKTtaBnpEqCN0dWy0UZJ0jA9Vy+EzMrjlmT8qBVjyDhc7pZu4SePHbl
+ teNqclKio5vvN9WVNZ7I3ujXDXV3GHwpVb076b05cWpyUqKjm+831ZU1nsje6NcNdXcYfClVvTvpvTlx
+ anJSoqOb7zfVlTWeyN7o1w11dxh8KVW9O+m9OXFkr7p3fVUn5xxf3PWa2UOSEj+mc0eXm8dbelV+spnW
+ rKr7dZvy4ey/Jnxnx6Zs0PLec7LYbOkr6u87XbUO7971u3nGKVJurijmBvOp19Sn3DN7bTqUDzTTqWpy
+ UqKjm+831ZU1nsje6NcNdXcYfClVvTvpvTlxanJSoqOb7zfVlTWeyN7o1w11dxh8KVW9O+m9OXFqclKi
+ o5vvN9WVNZ7I3ujXDXV3GHwpVb076b05cWSvund9VSfnHF/c9ZrZQ5ISP6ZzR5ebx1t6VX6ymdasqvt1
+ m/Lh7L8mfGfHpmzQ8t5zsths6Svq7ztdtQ7v3vW7ecYpUm6uKOYG86nX1KfcM3ttOpQPNNOpanJSoqOb
+ 7zfVlTWeyN7o1w11dxh8KVW9O+m9OXFqclKio5vvN9WVNZ7I3ujXDXV3GHwpVb076b05cWpyUqKjm+83
+ 1ZU1nsje6NcNdXcYfClVvTvpvTlxZK+6d31VJ+ccX9z1mtlDkhI/pnNHl5vHW3pVfrKZ1qyq+3Wb8uHs
+ vyZ8Z8embNDy3nO3/kz4z49M2aHlvOdv/Jnxnx6Zs0PLec7GXNYbRmQy7PK7lLdtN/ZQyIKGQ2WuBtsC
+ NUUUNuJNhUf0WvtPs/TLmsNozIZdnldylu2m/soZEFDIbLXA22BGqKKG3EmwqP6LX2n2fuzdxW/aNxzN
+ vW21dPLgno+HfuYSEbsmwO3J5SWTQGPYmTbCB9VRQpzAIaAHSGn7pgTIJxIUTGAOEQKHdHR9ej6XyZ8Z
+ 8embNDy3nPpR1nWLAP7luSVMcrKLjyEFQxUiCou4XXXURasmbdMBMquuomikUNJzAHDhe43FitJduzan
+ eP463bhh5iaaIJJ7RUSxbd0C8kqmHBs2VUoIgOqUQ4cXTmJZECylLZs1aUbz6yk5EMX7VWHiG849KnFO
+ 3aMg60R7kop7NM20OAkLpMUQC8ZvLu30ZmPsVs1dXCotKxsadIjxtJu0E2aUg5bnkFzIxKwiRHWMUdUB
+ 0a5dNxkyygmkzxUTi1ZxR5MxcMk0LMjIBHACso6akWOvupcdBREQBMRHDN24kED9WU9wKvmbYj+2FV95
+ EvB7DHTTTKA3OEaN3IrLAhrU4rDt9XQIGxbTqLsRqeJuqBZ3JHTity28nEoxb9Bs5amfrBImXau1kHaZ
+ it9mZcQERAogQ+rHjmTaxoyOl1VEIqdYPmcvCPnCRTnO0K/YLKlbPdkmY4IOCorGTATAUSgIg0uy3LLS
+ jrbkm5HURK3RLMYEkw2V0GScxrFyoaVXZLpGBRJwKBWyyYgZNQ4YbwWZlpvrbdPk1VoxydRq+ipZFEUw
+ WUi5eOXdRz0UNsTakIoKiOuUFClEQD7j2CNYLVmZlGt5I8s8uSCJBLg7UcpIMWUoi9XReSWs0OKiKYGM
+ 3LqGW2ZVUhOmD6RaKdWpC53ayDZvK2o8EZZrej+BWTbHbipcSsSa8G6yxUyqC1OqNQACBgNh2/y5tE7+
+ EYOqJ7cUk/YwsGg8Aiah2ibyRXRM/dIpqkMom2IuomU5ROBQMXS5cKWLCvo1k1VePJdvf9iMY1o1boiu
+ 5XcrT9xQqqCLZIphUOcgEKBRER0cOOsRZltMiydx3FeOYUFDsSPGSCbyTfZd2C1bIFfunKMekmoscA2p
+ 1SpAH2hNo4cO7slrJbSkRGtVH0uNszcbOPopointXDl1GtlgfLoNkwMZU7Yi5UylE5hAgCbDzM/MixYC
+ 68qjW7PRUFvtwwkEBvhjPW4VMXFvGcCusmlEg+KBnCJ2463cE2oIZj5oS9pw8NluF7Sq0YvHTlvnK2ip
+ +5l0LfRbwrB2Zy1RFJ4iQEipFBEvAIFAvB/uj/xYM4alAFNIidINAAf69JQ7gG/hwJTAICA6BAQ0CAh3
+ QEB7g/Q+TPjPj0zZoeW8590Px4N+77+OH72Lyt6bUZsrjvG02zO03ro6aRnKkXJC/loBmofQYzqTb7Jy
+ CYCG0KwHumAoDc73NVG58you5kJVIgy10SbS2L0TWkm75tc0LJLsZpk0k2hSiUyBW4LNAcmSOUpRADda
+ G3t2EioLMh46zCi7XFRNdKJiH09OMZOMIYiKKCxUGd0sW5jAmUpgSLoKAcGJ1WVBJGTuvM67WyYqiimZ
+ 6jagBbNKgTXNthRfQEioJSmPoKBx/JKI468k4CYs3Nv3tfNjQq5gMltVLdiBjrXdpgYximbqPbwSOTQG
+ k2kS6dIaC22GgNG+luDRwdPE79WOrKztu4pmAQm4S005csNIOYxSRRY2DFrNW7tdmoiuq1SXVFTZCbZm
+ UKUwlExCCW17iu+Qd3JPIzLYCTEysd/Ja0Xm1N2ywVO8cCddRdvAkBqChjCoZLSBhERERyVta0bhmrXt
+ 7dlyrGibfknkQ0VUiT26xixWIwWQMuWNaKnIgU4mKkBzaoAJjaer4OZRnD3MhzKWgsDiWMKlwgC1oT68
+ geUUdCR+dwDAzQj/AGmsqLwUxV0qBrB/Vk7uj8kO5wYykgYO5JqFiZFrdsjIsomSdxyUg8aLQLZoq9o1
+ UTOqRFyqCQHESk2pxANJhxbxdUuqEwv9nQGjp0nB7nc7uLGPbbxzAqysi3byK0SsowXeIyF83As+SXXb
+ GTWOR4ZEoKhrfbIGoOkmkuOsMSblZCXCIXzHh4zeTtd6ZjFEsS1JAke2M4OoZJmR7IrqFTAdUplTaA4c
+ dYact984h5iLuDMR5HSTA4t3jF4nlvZGydtFyaDt3SI/aTUKIHTMAGKIGABDMOAnLpuCbhlLMCaGNmJZ
+ 9KNSyqU7FsgfpJvlnAIOVGjxRNQxNXal1QPrahNXNi2mbhy3t6NtG/Rj4NNyuESzMjmLZ7ZJRuw2lKkq
+ m3ESAcC62qIhp0COM0Il/Pzb2KLmHeCYRjuWfuY8CNrmkRbkBks4O2AjcUy6gaugmqGjRoxrETIU3CGk
+ pQAdGjuaQ+rA/v8A8mNoloTcAAcPcKpwdw/4fw4MmqQSHKOgQENH4w++A/d+TPjPj0zZoeW8590Px/wY
+ N+77+Pxfx4uq4MqWrZ09y2NAyUhonW0FLN1pMZl1Fu4dw6Wapmctj28sbWBZNRM4EEukR4JDq1dYm32W
+ YTde3XkpDXY7TKnKqkhxbEFCWUblSUJMtkHAqNpVA6LrWT1VdoooKuHOW6EmZ9D79vfLcJAyhQWdsFmL
+ qQgAdlTAqRnh5KMYprkDQUi+to06oAPVKsqEVBjH3Lnrc049bAJSEIjdCstCSp1zplACNCv82lzlKfgP
+ qawiJkxMEvBw5Qauc381Id9MtiGKSoNHxaErIvRKAAZUgvbVjxPrCOhRUNGgAKAW3/fS/wDjvO46qRwK
+ OoWItwpjaB1SmNl5EiUom7gCYCDoD69A/exbYGKJRGYVMAGAQHVPnpOHIbQP80xDAID9YDpxl7eWYeWy
+ 2ZF/oNp0+WjdQiQxMao0XiF5F87dP1VY1koRydoZJcjJ67ROUpkykDSbFrZ/5twzO3svZ12wh8todnJM
+ RaN2FxRshcDR0xiEXzyS/tCOh9o4evCpLLiCQFKCQJkJ/rfyYyY/ue9P+etvFvf3wv8A46TmLiymzVJN
+ 2bZ+Vr0662Z7ZeNZQiABLL3JHJmcPBUKrKsBlDILtqZUh2p0jbQq6pBC7chMh7lm8x5e/F5E07cUlGvW
+ DBmecbR8fNPVTvoyIIqqMJGJNmqDVNQhDCCiionKYp+sr/e+Y/8AhxY+MwPRyp5TwOM5f/aGYX+JlnYz
+ SAeAS5jXuBgHgEBC5ZQBAQHhAQHH4/4sD+//ACYDW+2sYA1EgHhHg/KN/olwKixtI6R1S/zSAOjgKH1B
+ wfd+TPjPj0zZoeW859Jzc9qpNJaNl2icdc1sSZ1U46cZInOq1MKyGlZlIx6yhjN3BAMKeucpinTUOQ0x
+ JZQ9WGw8vb9n2iqL+601YMRKuuILHVepwVoW/IXEUrswqAC7lEpjlAxim0iXELmw5drS90xd8ML9dOna
+ uopLTTScSnnJnihExKBZF2QwK6CCXVOIaohwYs29FLebWYeyIxJrExzKVXlyhIkl1ZVWVM6WZx4kOqJW
+ 6ezBP7Ow06w62gtkpv7RaWa0svf50mrKbXmCyLme3QU7hcy0dHbIzRKIApA0H/rTcIaeGO6rw2a0Ixj3
+ h3YXiE2uLxUT3y+vbZjD7uBEoAq9FvpqB+yXX7o6uOrepeeVVt5vWrdVq2gxkrbuQGB0GziNsiHeMZRq
+ nKw89HKuG5jnDVUbgYdb7KhOHTA5b2xY8Xlhlpb7pq9Rt2NdIvF3riObKtItI6jSMh2MbExiK59izboA
+ QDiBjGNqJgS37Gz6yOtTOstqoIIQ09MHiFHJitESNGi0hEzttzzFSVKzDZneonQOoBA1yGOY6gwLBxBx
+ 1kWPau0Pb9nRLkz5NF0qkDYX0jJGaR4PnKDMoIIgm3booJawETATnMb8o3+UcWY/fWa0s0bPZzTRNJnN
+ rzAPwmVo1Yyihlo6OFAW+7gAAAD62v8AVo4Y7qwDZrQjKPeHdheQTa4vVRPfL69tmMPu4ESACr0W+mpH
+ 7Jdfujq4t6zcsMgLv6xkZmRHVF/v452SZhZtZCOaFB9KxL1tOskmU0i/MDdBJik2M2SAFFFFC6RkYZfq
+ E2nk1ct4Mn0Va113XY1lFo1CUxJV/Esj2NHKu5GOZPAFI5VNVuuqkcwGAAIbMvIRGzmku1zHeXI7Wuda
+ cXaOogbituDt06aMYWOcJuwaEhQVARXT1xUEvBo0jcF1srVbXgeetwbeMxeTC8Qm1IMmwkqsiyTCQFU+
+ sxAmqJShoNp08GgXOcNrtWaj2QfTqkpb8goutGyMRcLw7x9Drroig4KVNXZnSWLoEiyJDiUwAJDXDBMO
+ rDaFt3ddjhCTlL5GWZHmGk23A4IzCb2Dti35aakCA4VKB3boEhKcSqpLEOYmNBjmENmbgEwj977+DJJa
+ FHA/V3Sp6frPo+v8GDKKGE5zDpExh0j/AJvofJnxnx6Zs0PLec7JaVlX1de/LZsZFu3taM3FbUZutFpH
+ IxLclZDw8fIPdnHtyJ6XKqwjo1hETCIj9Jna9oZqy7OBjkU20dHykVbV0Ej2qJQIgzYLXTCTTlkxbpgB
+ U0EjlSTKAFKUAAAwxuHNC63N0ysZHBFR6qjCIiWrNiC6rkyTeNgo+LjElFV1hMoqCO1V0FA5jAQgF+gY
+ 6I6pzEEmto0iUDd0Q/DgTGERER0iIjpERHuiI/R+TPjPj0zZoeW852/8mfGfHpmzQ8t5zt/5M+M+PTNm
+ h5bznb/yZ8Z8embNDy3nO3/kz4z49M2aHlvOdv8AyZ8X5/4mv2zujpH6Q/14+/bz/wBZ/wDVP+O2uPgz
+ 4+DPj4M+Pgz4+DPj4M+Pgz4+DPj4M+Pgz4+DPj4M+Pgz4+DPj4M+Pgz4+DPj4M+Pgz4+DPj4M+Pgz4+D
+ Pj4M+Pgz4+DPj4M+Pgz4+DPj4M+P/pn/APDP93/4zx//2Q==
+
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Properties/Settings.Designer.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Properties/Settings.Designer.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,167 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:4.0.30319.261
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace Trakers.Debug.Properties {
+
+
+ [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+ [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
+ internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
+
+ private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+ public static Settings Default {
+ get {
+ return defaultInstance;
+ }
+ }
+
+ [global::System.Configuration.ApplicationScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("1")]
+ public float searchMinDistance {
+ get {
+ return ((float)(this["searchMinDistance"]));
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("1.5")]
+ public float searchMaxDistance {
+ get {
+ return ((float)(this["searchMaxDistance"]));
+ }
+ set {
+ this["searchMaxDistance"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("1")]
+ public float minDistance {
+ get {
+ return ((float)(this["minDistance"]));
+ }
+ set {
+ this["minDistance"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("3.2")]
+ public float maxDistance {
+ get {
+ return ((float)(this["maxDistance"]));
+ }
+ set {
+ this["maxDistance"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("1.8")]
+ public float zeroPoint {
+ get {
+ return ((float)(this["zeroPoint"]));
+ }
+ set {
+ this["zeroPoint"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("127.0.0.1")]
+ public string connexionHost {
+ get {
+ return ((string)(this["connexionHost"]));
+ }
+ set {
+ this["connexionHost"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("80")]
+ public int connexionPort {
+ get {
+ return ((int)(this["connexionPort"]));
+ }
+ set {
+ this["connexionPort"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("1000")]
+ public int timerElapsing {
+ get {
+ return ((int)(this["timerElapsing"]));
+ }
+ set {
+ this["timerElapsing"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("25")]
+ public int imagesToShow {
+ get {
+ return ((int)(this["imagesToShow"]));
+ }
+ set {
+ this["imagesToShow"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("10")]
+ public int takenPoints {
+ get {
+ return ((int)(this["takenPoints"]));
+ }
+ set {
+ this["takenPoints"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("10")]
+ public int directionChangeTresholdXY {
+ get {
+ return ((int)(this["directionChangeTresholdXY"]));
+ }
+ set {
+ this["directionChangeTresholdXY"] = value;
+ }
+ }
+
+ [global::System.Configuration.UserScopedSettingAttribute()]
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ [global::System.Configuration.DefaultSettingValueAttribute("0.01")]
+ public float directionChangeTresholdZ {
+ get {
+ return ((float)(this["directionChangeTresholdZ"]));
+ }
+ set {
+ this["directionChangeTresholdZ"] = value;
+ }
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Properties/Settings.settings
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Properties/Settings.settings Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,42 @@
+
+
+
+
+
+ 1
+
+
+ 1.5
+
+
+ 1
+
+
+ 3.2
+
+
+ 1.8
+
+
+ 127.0.0.1
+
+
+ 80
+
+
+ 1000
+
+
+ 25
+
+
+ 10
+
+
+ 10
+
+
+ 0.01
+
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Debug/Settings.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Debug/Settings.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,55 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Debug
+ * Classe : Settings
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Spécifie les instructions à suivre lors de la modification des settings.
+ */
+
+namespace Trakers.Debug.Properties
+{
+
+
+ // This class allows you to handle specific events on the settings class:
+ // The SettingChanging event is raised before a setting's value is changed.
+ // The PropertyChanged event is raised after a setting's value is changed.
+ // The SettingsLoaded event is raised after the setting values are loaded.
+ // The SettingsSaving event is raised before the setting values are saved.
+ internal sealed partial class Settings
+ {
+
+ public Settings()
+ {
+ this.SettingChanging += this.SettingChangingEventHandler;
+ this.SettingsSaving += this.SettingsSavingEventHandler;
+ }
+
+ /*
+ * Gère la modification des paramètres.
+ */
+ private void SettingChangingEventHandler(object sender, System.Configuration.SettingChangingEventArgs e)
+ {
+
+ }
+
+ /*
+ * Gère la sauvegarde des paramètres.
+ */
+ private void SettingsSavingEventHandler(object sender, System.ComponentModel.CancelEventArgs e)
+ {
+
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Gestures/CircleDetector.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Gestures/CircleDetector.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,147 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking/Gestures
+ * Classe : CircleDetector
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet de détecter si l'utilisateur a effectué un cercle, en se basant sur
+ * des règles appliquées à la positions des noeuds dans le temps.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using System.Windows.Media.Media3D;
+using System.Drawing;
+
+namespace Trakers.MainModule.Gestures
+{
+ public class CircleDetector : GestureDetector
+ {
+ public CircleDetector() : base()
+ {
+ gesturePeriod = (float)1;
+ indexesPerSecond = 30;
+ indexesToCheck = (int)(gesturePeriod * indexesPerSecond);
+ }
+
+ /*
+ * Lit les noeuds de l'historique du squelette afin de détecter un cercle.
+ * Règles :
+ * Se fait avec une main.
+ * Chaque point est à la même distance du barycentre.
+ * Traitement :
+ * On .
+ */
+ public bool CheckForCircle()
+ {
+ //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
+ List> localHistory = new List>(history);
+
+ //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
+ if (localHistory.Count < indexesToCheck + 1)
+ return false;
+
+ //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
+ refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
+ //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
+ startPoint = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position;
+
+ //Barycentres pour les mains.
+ PointF leftBarycenter = new PointF(0, 0);
+ PointF rightBarycenter = new PointF(0, 0);
+ //Distances moyennes des points aux barycentres.
+ float averageDistToLeftBarycenter = 0;
+ float averageDistToRightBarycenter = 0;
+
+ //Index du point de départ dans la détection.
+ int beginIndex = localHistory.Count - indexesToCheck;
+
+ //Calcul du barycentre de la main gauche.
+ for (int i = beginIndex; i > 0; i--)
+ {
+ leftBarycenter.X += localHistory[i][(int)JointType.HandLeft].Position.X;
+ leftBarycenter.Y += localHistory[i][(int)JointType.HandLeft].Position.Y;
+ }
+ leftBarycenter.X /= indexesToCheck;
+ leftBarycenter.Y /= indexesToCheck;
+
+ //Calcul du barycentre de la main droite.
+ for (int i = beginIndex; i > 0; i--)
+ {
+ rightBarycenter.X += localHistory[i][(int)JointType.HandRight].Position.X;
+ rightBarycenter.Y += localHistory[i][(int)JointType.HandRight].Position.Y;
+ }
+ rightBarycenter.X /= indexesToCheck;
+ rightBarycenter.Y /= indexesToCheck;
+
+ //Estimation de la distance moyenne d'un point au barycentre gauche.
+ for (int i = beginIndex; i > 0; i--)
+ {
+ float ptX = localHistory[i][(int)JointType.HandLeft].Position.X;
+ float ptY = localHistory[i][(int)JointType.HandLeft].Position.Y;
+ averageDistToLeftBarycenter += (float)Distance2D(ptX, leftBarycenter.X, ptY, leftBarycenter.Y);
+ }
+ averageDistToLeftBarycenter /= indexesToCheck;
+
+ //Estimation de la distance moyenne d'un point au barycentre droit.
+ for (int i = beginIndex; i > 0; i--)
+ {
+ float ptX = localHistory[i][(int)JointType.HandRight].Position.X;
+ float ptY = localHistory[i][(int)JointType.HandRight].Position.Y;
+ averageDistToRightBarycenter += (float)Distance2D(ptX, rightBarycenter.X, ptY, rightBarycenter.Y);
+ }
+ averageDistToRightBarycenter /= indexesToCheck;
+
+ //De la position p1 à pn, on suit l'algorithme.
+ for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
+ {
+ //Si la position Y de la main est plus haute que la tête
+ //OU si la position Y de la main est plus basse que la hanche
+ //OU si la nouvelle position X de la main est à droite de la précédente
+ //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
+ //Alors on retourne faux.
+ if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.X > localHistory[i - 1][(int)JointType.HandRight].Position.X ||
+ Math.Abs(localHistory[i][(int)JointType.HandRight].Position.Y - startPoint.Y) > refDistance / 2)
+ return false;
+ }
+
+ //Si la distance horizontale du geste a été plus courte que la distance N
+ //Alors on retourne faux.
+ if (Math.Abs(localHistory[0][(int)JointType.HandRight].Position.X - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X) < refDistance / 2)
+ return false;
+
+ //Si la dernière position de la main droite est sur le côté droit du corps
+ //OU si la première position calculée de la main droite est sur le côté gauche du corps
+ //Alors on retourne faux.
+ if (localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
+ localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
+ return false;
+
+ //On supprime l'historique local.
+ localHistory.Clear();
+ //Si on est arrivé jusqu'ici, toutes les conditions pour un swipe left ont été remplies.
+ return true;
+ }
+
+ public double Distance2D(float x1, float x2, float y1, float y2)
+ {
+ return Math.Sqrt((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Gestures/GestureDetector.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Gestures/GestureDetector.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,154 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking/Gestures
+ * Classe : GestureDetector
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Reçoit les positions des noeuds envoyés par la classe de manipulation de la Kinect
+ * et les stocke dans un historique.
+ * Contient également des variables propres à toute gesture : distance de référence, point de départ,
+ * durée de la gesture, FPS et nombre de frames à traiter.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using System.Drawing;
+
+namespace Trakers.MainModule.Gestures
+{
+ public class GestureDetector
+ {
+ //Historique des positions du squelette.
+ protected static List> history = new List>();
+ //protected JointCollection previousSkeleton;
+
+ //Voici les ID des noeuds d'un squelette : variables magiques en attente de factorisation.
+ /*protected int hipCenterID = 0, spineID = 1, shoulderCenterID = 2, headID = 3;
+ protected int shoulderLeftID = 4, elbowLeftID = 5, wristLeftID = 6, handLeftID = 7;
+ protected int shoulderRightID = 8, elbowRightID = 9, wristRightID = 10, handRightID = 11;
+ protected int hipLeftID = 12, kneeLeftID = 13, ankleLeftID = 14, footLeftID = 15;
+ protected int hipRightID = 16, kneeRightID = 17, ankleRightID = 18, footRightID = 19;*/
+
+ //Elements nécessaires à la reconnaissance du geste :
+ //Distance du parcours du geste (va dépendre de la distance de l'utilisateur).
+ protected float refDistance;
+ //Position de départ pour le geste.
+ protected SkeletonPoint startPoint;
+ //Estimation du temps que prend la gesture (en s).
+ protected float gesturePeriod = 1;
+ //Estimation du nombre d'indexes par seconde (framerate).
+ protected int indexesPerSecond = 30;
+ //Estimation du nombre de positions du squelette à vérifier dans l'historique.
+ protected int indexesToCheck;// = gesturePeriod * indexesPerSecond;
+
+ public GestureDetector()
+ {
+
+ }
+
+ //Setters.
+ public void setRefDistance(float _refDistance)
+ {
+ refDistance = _refDistance;
+ }
+ public void setStartPoint(SkeletonPoint _startPoint)
+ {
+ startPoint = _startPoint;
+ }
+ public void setGesturePeriod(float _gesturePeriod)
+ {
+ gesturePeriod = _gesturePeriod;
+ }
+ public void setIndexesPerSecond(int _indexesPerSecond)
+ {
+ indexesPerSecond = _indexesPerSecond;
+ }
+ public void setIndexesToCheck(int _indexesToCheck)
+ {
+ indexesToCheck = _indexesToCheck;
+ }
+
+ //Getters.
+ public float getRefDistance()
+ {
+ return refDistance;
+ }
+ public SkeletonPoint getStartPoint()
+ {
+ return startPoint;
+ }
+ public float getGesturePeriod()
+ {
+ return gesturePeriod;
+ }
+ public int getIndexesPerSecond()
+ {
+ return indexesPerSecond;
+ }
+ public int getIndexesToCheck()
+ {
+ return indexesToCheck;
+ }
+
+ //Stocke les gestes du skelette pour ~3 seconds (si on prend en compte que le framerate de la Kinect
+ //est de ~30 fps.
+ public static void UpdateSkeletonHistory(List latestSkeleton)
+ {
+ history.Add(latestSkeleton);
+
+ if (history.Count > 90)
+ {
+ history.RemoveAt(0);
+ }
+ }
+
+ /*public bool CheckForHandWave()
+ {
+ //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
+ List history = new List(history);
+ //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
+ if (history.Count < indexesToCheck)
+ return false;
+
+ float refDistance = Math.Abs(history[0].Joints.ElementAt(spineID).Position.Y - history[0].Joints.ElementAt(hipCenterID).Position.Y);
+ float startPos = history[history.Count - indexesToCheck].Joints.ElementAt(handRightID).Position.X;
+ bool movedRight = false;
+ for (int i = history.Count - indexesToCheck + 1; i < history.Count; i++)
+ {
+ // Throughout the gesture period, right hand should be above theelbow, below the head and hand should be higher than the wrist
+ if (!(history[i].Joints[JointID.HandRight].Position.Y > history[i].Joints[JointID.ElbowRight].Position.Y + refDistance &&
+ history[i].Joints[JointID.HandRight].Position.Y < history[i].Joints[JointID.Head].Position.Y &&
+ history[i].Joints[JointID.HandRight].Position.Y > history[i].Joints[JointID.WristRight].Position.Y + refDistance / 4))
+ {
+ return false;
+ }
+ // If the previous condition was met, check if the hand has moved to the right
+ if (history[i].Joints[JointID.HandRight].Position.X >= startPos + refDistance / 2 && !movedRight)
+ {
+ movedRight = true;
+ }
+ // If the hand did move to the right, check if it returned near the original position
+ if (movedRight && history[i].Joints[JointID.HandRight].Position.X <= startPos + refDistance / 5)
+ {
+ skeletonHistory.Clear();
+ return true;
+ }
+ }
+ return false;
+ }*/
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Gestures/JumpDetector.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Gestures/JumpDetector.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,127 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking/Gestures
+ * Classe : JumpDetector
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet de détecter si l'utilisateur a sauté, en se basant sur
+ * des règles appliquées à la positions des noeuds dans le temps.
+ *
+ * P.S : Cette partie est encore en développement.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+
+namespace Trakers.MainModule.Gestures
+{
+ public class JumpDetector : GestureDetector
+ {
+ static int n = 0;
+
+ public JumpDetector() : base()
+ {
+ gesturePeriod = (float)1;
+ indexesPerSecond = 30;
+ indexesToCheck = (int)(gesturePeriod * indexesPerSecond);
+ }
+
+ /*
+ * Lit les noeuds de l'historique du squelette afin de détecter un Jump.
+ * Règles :
+ * .
+ */
+ public bool CheckForJump()
+ {
+ //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
+ List> localHistory = new List>(history);
+
+ //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
+ if (localHistory.Count < indexesToCheck)
+ return false;
+
+ /* (HeadBelowBaseLine || LeftKneeBelowBaseLine || RightKneeBelowBaseLine ||
+ * LeftAnkleBelowBaseLine || RightAnkleBelowBaseLine || BodyFaceUpwards
+ *
+ * NOT
+ *
+ * AND
+ *
+ * HeadAboveBaseLine && LeftKneeAboveBaseLine && RightKneeAboveBaseLine &&
+ * LegsStraightPreviouslyBent)
+ *
+ * OR
+ *
+ * HeadFarAboveBaseLine
+ */
+
+ //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
+ refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
+ //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
+
+ int beginIdx = localHistory.Count - indexesToCheck + 1;
+ int middleIdx = localHistory.Count - indexesToCheck / 2;
+
+ //bool middleOK = true
+ bool topOfJump = false;
+
+
+
+ //De la position p1 à pn, on suit l'algorithme.
+ for (int i = beginIdx ; i < localHistory.Count ; i++)
+ {
+
+ if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[beginIdx][(int)JointType.HandRight].Position.Y + refDistance &&
+ localHistory[i - 1][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.HandRight].Position.Y)
+ {
+ topOfJump = true;
+ //Console.Out.WriteLine("TOP");
+ }
+
+ if (localHistory[i - 1][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HandRight].Position.Y && !topOfJump)
+ return false;
+
+ //Si la position Y de la main est plus haute que la tête
+ //OU si la position Y de la main est plus basse que la hanche
+ //OU si la nouvelle position Z de la main est moins profonde que la précédente
+ //OU si la nouvelle position X de la main est plus éloignée de la distance N par rapport à la première position X
+ //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
+ //Alors la main en question ne fait pas de push.
+ if (localHistory[i - 1][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HandRight].Position.Y &&
+ topOfJump || localHistory[i - 1][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.HandRight].Position.Y &&
+ !topOfJump)
+ return false;
+ }
+
+ //Console.Out.WriteLine("OK");
+
+ //Si la distance en Z du geste a été plus courte que la distance N
+ //Alors on retourne faux.
+ //float dist = (localHistory[localHistory.Count - 1][handRightID].Position.X - localHistory[localHistory.Count - indexesToCheck][handRightID].Position.X);
+
+ //Console.WriteLine(Math.Abs(localHistory[0][handLeftID].Position.Z - localHistory[localHistory.Count - indexesToCheck][handLeftID].Position.Z) * 100 + " " + refDistance);
+
+ //Si la dernière position de la main droite/gauche est sur le côté gauche/droit du corps
+ //OU si la première position calculée de la main droite/gauche est sur le côté gauche/droit du corps
+ //Alors on retourne faux.
+
+ //On supprime l'historique local.
+
+ return false;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Gestures/PushDetector.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Gestures/PushDetector.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,215 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking/Gestures
+ * Classe : PushDetector
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet de détecter si l'utilisateur a effectué un Push, en se basant sur
+ * des règles appliquées à la positions des noeuds dans le temps.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+
+namespace Trakers.MainModule.Gestures
+{
+ public class PushDetector : GestureDetector
+ {
+ public enum Direction { PUSH, PULL };
+ public enum Hand { LEFT, RIGHT, BOTH, NONE };
+
+ public PushDetector() : base()
+ {
+ gesturePeriod = (float)0.3;
+ indexesPerSecond = 30;
+ indexesToCheck = (int)(gesturePeriod * indexesPerSecond);
+ }
+
+ /*
+ * Lit les noeuds de l'historique du squelette afin de détecter un Push.
+ * Règles :
+ * Se fait avec une main (gauche ou droite).
+ * Chaque nouvelle position de la main doit être plus profonde que la précédente.
+ * Chaque nouvelle position de la main ne doit pas dévier trop de l'axe perpendiculaire au plan (X, Y).
+ * Le geste doit mesurer en profondeur une certaine distance.
+ */
+ public Hand CheckForPush()
+ {
+ //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
+ List> localHistory = new List>(history);
+
+ //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
+ if (localHistory.Count < indexesToCheck + 1)
+ return Hand.NONE;
+
+ //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
+ refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
+ //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
+ SkeletonPoint startPointLeft = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position;
+ SkeletonPoint startPointRight = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position;
+
+ //Booléens indiquant si le mouvement serait valide pour la main gauche ou droite.
+ bool leftHandOK = true, rightHandOK = true;
+
+ //De la position p1 à pn, on suit l'algorithme.
+ for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
+ {
+ //Si la position Y de la main est plus haute que la tête
+ //OU si la position Y de la main est plus basse que la hanche
+ //OU si la nouvelle position Z de la main est moins profonde que la précédente
+ //OU si la nouvelle position X de la main est plus éloignée de la distance N par rapport à la première position X
+ //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
+ //Alors la main en question ne fait pas de push.
+ if (localHistory[i][(int)JointType.HandLeft].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
+ localHistory[i][(int)JointType.HandLeft].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
+ localHistory[i][(int)JointType.HandLeft].Position.Z > localHistory[i - 1][(int)JointType.HandLeft].Position.Z ||
+ Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.X - startPointLeft.X) > refDistance / 5 ||
+ Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.Y - startPointLeft.Y) > refDistance / 5)
+ leftHandOK = false;
+ if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.Z > localHistory[i - 1][(int)JointType.HandRight].Position.Z ||
+ Math.Abs(localHistory[i][(int)JointType.HandRight].Position.X - startPointRight.X) > refDistance / 5 ||
+ Math.Abs(localHistory[i][(int)JointType.HandRight].Position.Y - startPointRight.Y) > refDistance / 5)
+ rightHandOK = false;
+
+ if (!leftHandOK && !rightHandOK)
+ return Hand.NONE;
+ }
+
+ //Si la distance en Z du geste a été plus courte que la distance N
+ //Alors on retourne faux.
+ if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.Z) * 100 < 20)
+ leftHandOK = false;
+ if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.Z) * 100 < 20)
+ rightHandOK = false;
+
+ //Si la dernière position de la main droite/gauche est sur le côté gauche/droit du corps
+ //OU si la première position calculée de la main droite/gauche est sur le côté gauche/droit du corps
+ //Alors on retourne faux.
+ if (localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
+ localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
+ leftHandOK = false;
+ if (localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
+ localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
+ rightHandOK = false;
+
+ if (!leftHandOK && !rightHandOK)
+ return Hand.NONE;
+
+ //On supprime l'historique local.
+ localHistory.Clear();
+
+ //Si on est arrivé jusqu'ici, toutes les conditions pour un push ont été remplies.
+
+ if (leftHandOK && rightHandOK)
+ return Hand.BOTH;
+ else if (leftHandOK)
+ return Hand.LEFT;
+ else if (rightHandOK)
+ return Hand.RIGHT;
+
+ return Hand.NONE;
+ }
+
+ /*
+ * Lit les noeuds de l'historique du squelette afin de détecter un Pull.
+ * Règles :
+ * Se fait avec une main.
+ * Chaque nouvelle position de la main doit être moins profonde que la précédente.
+ * Chaque nouvelle position de la main ne doit pas dévier trop de l'axe perpendiculaire au plan (X, Y).
+ * Le geste doit mesurer en profondeur une certaine distance.
+ */
+ public Hand CheckForPull()
+ {
+ //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
+ List> localHistory = new List>(history);
+
+ //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
+ if (localHistory.Count < indexesToCheck + 1)
+ return Hand.NONE;
+
+ //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
+ refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
+ //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
+ SkeletonPoint startPointLeft = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position;
+ SkeletonPoint startPointRight = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position;
+
+ //Booléens indiquant si le mouvement serait valide pour la main gauche ou droite.
+ bool leftHandOK = true, rightHandOK = true;
+
+ //De la position p1 à pn, on suit l'algorithme.
+ for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
+ {
+ //Si la position Y de la main est plus haute que la tête
+ //OU si la position Y de la main est plus basse que la hanche
+ //OU si la nouvelle position Z de la main est plus profonde que la précédente
+ //OU si la nouvelle position X de la main est plus éloignée de la distance N par rapport à la première position X
+ //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
+ //Alors la main en question ne fait pas de push.
+ if (localHistory[i][(int)JointType.HandLeft].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
+ localHistory[i][(int)JointType.HandLeft].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
+ localHistory[i][(int)JointType.HandLeft].Position.Z < localHistory[i - 1][(int)JointType.HandLeft].Position.Z ||
+ Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.X - startPointLeft.X) > refDistance / 5 ||
+ Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.Y - startPointLeft.Y) > refDistance / 5)
+ leftHandOK = false;
+ if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.Z < localHistory[i - 1][(int)JointType.HandRight].Position.Z ||
+ Math.Abs(localHistory[i][(int)JointType.HandRight].Position.X - startPointRight.X) > refDistance / 5 ||
+ Math.Abs(localHistory[i][(int)JointType.HandRight].Position.Y - startPointRight.Y) > refDistance / 5)
+ rightHandOK = false;
+
+ if (!leftHandOK && !rightHandOK)
+ return Hand.NONE;
+ }
+
+ //Si la distance en Z du geste a été plus courte que la distance N
+ //Alors on retourne faux.
+ if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.Z) * 100 < 20)
+ leftHandOK = false;
+ if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.Z) * 100 < 20)
+ rightHandOK = false;
+
+ //Si la dernière position de la main droite/gauche est sur le côté gauche/droit du corps
+ //OU si la première position calculée de la main droite/gauche est sur le côté gauche/droit du corps
+ //Alors on retourne faux.
+ if (localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
+ localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
+ leftHandOK = false;
+ if (localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
+ localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
+ rightHandOK = false;
+
+ if (!leftHandOK && !rightHandOK)
+ return Hand.NONE;
+
+ //On supprime l'historique local.
+ localHistory.Clear();
+
+ //Si on est arrivé jusqu'ici, toutes les conditions pour un push ont été remplies.
+ if (leftHandOK && rightHandOK)
+ return Hand.BOTH;
+ else if (leftHandOK)
+ return Hand.LEFT;
+ else if (rightHandOK)
+ return Hand.RIGHT;
+
+ return Hand.NONE;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Gestures/SwipeDetector.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Gestures/SwipeDetector.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,151 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking/Gestures
+ * Classe : SwipeDetector
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet de détecter si l'utilisateur a effectué un Swipe, en se basant sur
+ * des règles appliquées à la positions des noeuds dans le temps.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+
+namespace Trakers.MainModule.Gestures
+{
+ public class SwipeDetector : GestureDetector
+ {
+ public enum Direction {LEFT, RIGHT, TOP, DOWN};
+
+ public SwipeDetector() : base()
+ {
+ gesturePeriod = (float)0.5;
+ indexesPerSecond = 30;
+ indexesToCheck = (int)(gesturePeriod * indexesPerSecond);
+ }
+
+ /*
+ * Lit les noeuds de l'historique du squelette afin de détecter un Swipe left.
+ * Règles :
+ * Se fait avec la main droite.
+ * Chaque nouvelle position de la main doit être à la gauche de la précédente.
+ * Chaque nouvelle position de la main ne doit pas s'éloigner verticalement de plus d'une certaine distance.
+ * Le geste doit mesurer horizontalement une certaine distance.
+ */
+ public bool CheckForSwipeLeft()
+ {
+ //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
+ List> localHistory = new List>(history);
+
+ //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
+ if (localHistory.Count < indexesToCheck+1)
+ return false;
+
+ //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
+ refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
+ //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
+ startPoint = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position;
+
+ //De la position p1 à pn, on suit l'algorithme.
+ for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
+ {
+ //Si la position Y de la main est plus haute que la tête
+ //OU si la position Y de la main est plus basse que la hanche
+ //OU si la nouvelle position X de la main est à droite de la précédente
+ //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
+ //Alors on retourne faux.
+ if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
+ localHistory[i][(int)JointType.HandRight].Position.X > localHistory[i - 1][(int)JointType.HandRight].Position.X ||
+ Math.Abs(localHistory[i][(int)JointType.HandRight].Position.Y - startPoint.Y) > refDistance / 2)
+ return false;
+ }
+
+ //Si la distance horizontale du geste a été plus courte que la distance N
+ //Alors on retourne faux.
+ if (Math.Abs(localHistory[0][(int)JointType.HandRight].Position.X - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X) < refDistance / 2)
+ return false;
+
+ //Si la dernière position de la main droite est sur le côté droit du corps
+ //OU si la première position calculée de la main droite est sur le côté gauche du corps
+ //Alors on retourne faux.
+ if (localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
+ localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
+ return false;
+
+ //On supprime l'historique local.
+ localHistory.Clear();
+ //Si on est arrivé jusqu'ici, toutes les conditions pour un swipe left ont été remplies.
+ return true;
+ }
+
+ /*
+ * Lit les noeuds de l'historique du squelette afin de détecter un Swipe right.
+ * Règles :
+ * Se fait avec la main gauche.
+ * Chaque nouvelle position de la main doit être à la droite de la précédente.
+ * Chaque nouvelle position de la main ne doit pas s'éloigner verticalement de plus d'une certaine distance.
+ * Le geste doit mesurer horizontalement une certaine distance.
+ */
+ public bool CheckForSwipeRight()
+ {
+ //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
+ List> localHistory = new List>(history);
+
+ //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
+ if (localHistory.Count < indexesToCheck + 1)
+ return false;
+
+ //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
+ refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
+ //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
+ startPoint = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position;
+
+ //De la position p1 à pn, on suit l'algorithme.
+ for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
+ {
+ //Si la position Y de la main est plus haute que la tête
+ //OU si la position Y de la main est plus basse que la hanche
+ //OU si la nouvelle position X de la main est à gauche de la précédente
+ //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
+ //Alors on retourne faux.
+ if (localHistory[i][(int)JointType.HandLeft].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
+ localHistory[i][(int)JointType.HandLeft].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
+ localHistory[i][(int)JointType.HandLeft].Position.X < localHistory[i - 1][(int)JointType.HandLeft].Position.X ||
+ Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.Y - startPoint.Y) > refDistance / 2)
+ return false;
+ }
+
+ //Si la distance horizontale du geste a été plus courte que la distance N
+ //Alors on retourne faux.
+ if (Math.Abs(localHistory[0][(int)JointType.HandLeft].Position.X - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X) < refDistance / 2)
+ return false;
+
+ //Si la dernière position de la main droite est sur le côté gauche du corps
+ //OU si la première position calculée de la main droite est sur le côté droit du corps
+ //Alors on retourne faux.
+ if (localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
+ localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
+ return false;
+
+ //On supprime l'historique local.
+ localHistory.Clear();
+ //Si on est arrivé jusqu'ici, toutes les conditions pour un swipe right ont été remplies.
+ return true;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Gestures/UserPositionDetector.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Gestures/UserPositionDetector.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,103 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking/Gestures
+ * Classe : UserPositionDetector
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet de détecter si l'utilisateur s'est déplacé dans la zone de détection, en se basant
+ * sur la distance de l'utilisateur à Kinect.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Gestures
+{
+ public class UserPositionDetector
+ {
+ float minDistance, maxDistance, zeroPoint;
+ float searchMinDistance, searchMaxDistance;
+
+ static int n = 0;
+
+ /*
+ * Le constructeur prend en entrée le debug mais aussi les principales distances qui délimitent la
+ * zone de détection.
+ */
+ public UserPositionDetector(float _minDistance, float _maxDistance, float _zeroPoint, float _searchMinDistance, float _searchMaxDistance)
+ {
+ minDistance = _minDistance;
+ maxDistance = _maxDistance;
+ searchMinDistance = _searchMinDistance;
+ searchMaxDistance = _searchMaxDistance;
+ zeroPoint = _zeroPoint;
+ }
+
+ public void setParams(float minDist, float maxDist, float minDistHands, float maxDistHands, float zero)
+ {
+ //On charge tous les paramètres d'un coup.
+ minDistance = minDist;
+ maxDistance = maxDist;
+ searchMinDistance = minDistHands;
+ searchMaxDistance = maxDistHands;
+ zeroPoint = zero;
+ }
+
+ /*
+ * Lit la position de l'utilisateur à Kinect et ressort un pourcentage de proximité.
+ * Règles : Droite affine de coefficient négatif.
+ * .
+ */
+ public float CalcProximity(float distance)
+ {
+ //Si on se trouve trop loin.
+ if (distance > maxDistance)
+ return 0.0f;
+ //Si on se trouve trop près.
+ if (distance < searchMinDistance)
+ return 0.0f;
+ //Si on n'est pas encore trop près mais qu'on dépasse le point zéro.
+ if (distance < zeroPoint)
+ return 100.0f;
+
+ //Equation, de droite affine à partir de deux points.
+ //Ici 99 tout simplement car 100 - 1, les limites de pourcentage de proximité.
+ float a = 99/((float)zeroPoint - maxDistance);
+ float b = 100 - a * zeroPoint;
+
+ return a * distance + b;
+ }
+
+ /*
+ * Estime le nombre de vidéos à afficher en fonction du pourcentage de proximité et du nombre de
+ * vidéos dans la mosaïque.
+ * .
+ */
+ public int ImagesToShow(float proximity, int N)
+ {
+ //Si la proximité est nulle, on retourne 0.
+ if (proximity == 0f)
+ return 0;
+ //Si on n'est pas encore trop près mais qu'on dépasse le point zéro.
+ if (proximity >= 90f)
+ return N;
+
+ //Pour chaque intervalle de déciles (dans les pourcentages), le nombre de dizaines
+ //du pourcentage de proximité plus un, fois le nombre de dizaines d'images seront affichées.
+ return (((int)proximity / 10) + 1) * ((int)N / 2);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Properties/AssemblyInfo.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Properties/AssemblyInfo.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Tracking")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Tracking")]
+[assembly: AssemblyCopyright("Copyright © 2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("e248913f-2292-45d2-8fa5-25d8531514e1")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Search/Comparator.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Search/Comparator.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,36 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Search
+ * Classe : Comparator
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet de comparer une courbe tracée avec un dictionnaire.
+ * La comparaison se fait sur les segments de chaque courbe, ce qui permet d'avancer dans l'arbre du
+ * dictionnaire et de présenter des complétions potentielles.
+ * Lors d'une comparaison entre deux structures de courbes, chaque segment est comparé un à un, ensuite,
+ * c'est l'ensemble de la structure qui est comparée à l'autre (afin d'éviter les problèmes de changement
+ * d'échelle partielle).
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Search
+{
+ public class Comparator
+ {
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Search/Constructor.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Search/Constructor.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,38 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Search
+ * Classe : Constructor
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Construit une structure au fur et à mesure que ses segments sont tracés.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Search
+{
+ public class Constructor
+ {
+ /*public double Bernstein(int i, int k, double t)
+ {
+ if(i == 0 && k == 0)
+ return 1;
+
+ }*/
+
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Search/Curve.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Search/Curve.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,32 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Search
+ * Classe : Curve
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Définit l'objet de courbe en lui-même, composé d'une ou deux structures et
+ * d'un pictogramme le représentant.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Search
+{
+ public class Curve
+ {
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Search/Dictionnary.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Search/Dictionnary.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,31 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Search
+ * Classe : Dictionnary
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Dictionnaire sous forme d'arbre contenant les courbes répertoriées pour la recherche.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Search
+{
+ public class Dictionnary
+ {
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Search/Segment.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Search/Segment.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,36 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Search
+ * Classe : Segment
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Définit un composant de structure de courbe.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Media.Media3D;
+
+namespace Trakers.MainModule.Search
+{
+ public class Segment
+ {
+ //Points de la courbe réelle.
+ private List knots;
+ //Points de contrôle.
+ private List P;
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Search/Segmenter.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Search/Segmenter.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,281 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Search
+ * Classe : Segmenter
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet d'extraire à la volée les segments du tracé en cours.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows.Media.Media3D;
+
+namespace Trakers.MainModule.Search
+{
+ public class Segmenter
+ {
+ //Stocke les positions d'une main au cours du temps.
+ private List handPointerHistory;
+ //Point précédent.
+ private Point3D prevPt;
+ //Ratio : on prend 1/ratio points.
+ private int ratio;
+ //Indique le numéro du point actuellement enregistré (pour le ratio).
+ private int currentPointNumber;
+ //Extremums enregistrés parmi les 3 axes pour détecter les changements de sens.
+ private double Xmax, Ymax, Zmax;
+ private double Xmin, Ymin, Zmin;
+ //On établit une distance en nombre de points entre le point actuel l'extremum
+ //local détecté dans les 3 axes (pour copier le segment : points de 0 à id de l'extremum).
+ private int distToXmax, distToYmax, distToZmax;
+ private int distToXmin, distToYmin, distToZmin;
+ //Points critiques.
+ private Point3D minPt, maxPt;
+ //Tendance actuelle du tracé.
+ private bool XtowardRight, YtowardUp, ZtowardFront;
+ //Limites de différences à partir desquelles .
+ private int directionChangeTresholdXY;
+ private float directionChangeTresholdZ;
+
+ /*
+ * Initialisation du segmenter.
+ * Coupe une courbe en deux dès qu'il repère un changement important de trajectoire.
+ */
+ public Segmenter(int _ratio)
+ {
+ //directionChangeTresholdXY = kinectMain.getDirectionChangeTresholdXY();
+ //directionChangeTresholdZ = kinectMain.getDirectionChangeTresholdZ();
+ handPointerHistory = new List();
+ ratio = _ratio;
+ currentPointNumber = 1;
+ prevPt = new Point3D(0, 0, 0);
+
+ Xmax = Ymax = Zmax = Xmin = Ymin = Zmin = -1;
+ distToXmax = distToYmax = distToZmax = distToXmin = distToYmin = distToZmin = -1;
+ }
+
+ /*
+ * Getters et setters.
+ */
+ public void SetRatio(int _ratio)
+ {
+ ratio = _ratio;
+ }
+ public void SetDirectionChangeTresholdXY(int _directionChangeTresholdXY)
+ {
+ directionChangeTresholdXY = _directionChangeTresholdXY;
+ }
+ public void SetDirectionChangeTresholdZ(float _directionChangeTresholdZ)
+ {
+ directionChangeTresholdZ = _directionChangeTresholdZ;
+ }
+
+ public int GetRatio()
+ {
+ return ratio;
+ }
+ public int SetDirectionChangeTresholdXY()
+ {
+ return directionChangeTresholdXY;
+ }
+ public float SetDirectionChangeTresholdZ()
+ {
+ return directionChangeTresholdZ;
+ }
+
+ /*
+ * On charge tous les paramètres d'un coup.
+ */
+ public void setParams(int _ratio, int _directionChangeTresholdXY, float _directionChangeTresholdZ)
+ {
+ ratio = _ratio;
+ directionChangeTresholdXY = _directionChangeTresholdXY;
+ directionChangeTresholdZ = _directionChangeTresholdZ;
+ }
+
+ /*
+ * Enregistre le point passé en paramètre d'après le ratio.
+ */
+ public void RecordPoint(Point3D pt)
+ {
+ //Indique l'ID du point à couper.
+ int whereToCut;
+ //Si le ratio est excédé, on peut enregistrer.
+ if (currentPointNumber > ratio)
+ currentPointNumber = 1;
+
+ //Si le point précédent est à une position différente du point actuel.
+ if(prevPt.X != pt.X || prevPt.Y != pt.Y || prevPt.Z != pt.Z)
+ {
+ //Si le numéro est 1 (début ou ratio atteint), on enregistre.
+ if(currentPointNumber == 1)
+ handPointerHistory.Add(pt);
+
+ //Si le point précédent a été initialisé avec un vrai point.
+ if (prevPt.X > 0 && prevPt.Y > 0 && prevPt.Z > 0)
+ {
+ //Appel aux detecteurs d'extremums.
+ if ((whereToCut = DetectDirectionChangeAtXAxis(pt)) > 0)
+ Segment(whereToCut);
+ else if((whereToCut = DetectDirectionChangeAtYAxis(pt)) > 0)
+ Segment(whereToCut);
+ else if ((whereToCut = DetectDirectionChangeAtZAxis(pt)) > 0)
+ Segment(whereToCut);
+ }
+ //On met à jour le point précédent.
+ prevPt = pt;
+ //On passe au numéro suivant (jusqu'à atteindre le ration plus tard).
+ currentPointNumber++;
+ }
+ }
+
+ /*
+ * Détecte un changement de sens (extremum) dans l'axe X.
+ */
+ public int DetectDirectionChangeAtXAxis(Point3D pt)
+ {
+ //ID où couper en cas d'extremum.
+ int whereToCut = -1;
+
+ //Mise à jour des extremums.
+ if (Xmax == -1 || Xmax < pt.X)
+ {
+ //Si le point est plus grand en X que Xmax, alors il est remplacé et on réinitialise la
+ //distance au dernier maximum en X.
+ Xmax = pt.X;
+ maxPt = pt;
+ distToXmax = 0;
+ }
+ else
+ distToXmax++;
+ if (Xmin == -1 || Xmin > pt.X)
+ {
+ //Si le point est plus petit en X que Xmin, alors il est remplacé et on réinitialise la
+ //distance au dernier minimum en X.
+ Xmin = pt.X;
+ minPt = pt;
+ distToXmin = 0;
+ }
+ else
+ distToXmin++;
+
+ //Si X max est plus grand que la position actuelle additionnée du seuil
+ //et que l'extremum n'est pas le premier point sauvegardé.
+ if (Xmax > pt.X + directionChangeTresholdXY && maxPt != handPointerHistory.First())
+ whereToCut = currentPointNumber - distToXmax;
+ //Si X min est plus petit que la position actuelle à laquelle on a retiré le seuil
+ //et que l'extremum n'est pas le premier point sauvegardé.
+ if (Xmin < pt.X - directionChangeTresholdXY && minPt != handPointerHistory.First())
+ whereToCut = currentPointNumber - distToXmin;
+
+ return whereToCut;
+ }
+
+ /*
+ * Détecte un changement de sens (extremum) dans l'axe Y.
+ */
+ public int DetectDirectionChangeAtYAxis(Point3D pt)
+ {
+ //ID où couper en cas d'extremum.
+ int whereToCut = -1;
+
+ //Mise à jour des extremums.
+ if (Ymax == -1 || Ymax < pt.Y)
+ {
+ //Si le point est plus grand en Y que Ymax, alors il est remplacé et on réinitialise la
+ //distance au dernier maximum en Y.
+ Ymax = pt.Y;
+ maxPt = pt;
+ distToYmax = 0;
+ }
+ else
+ distToYmax++;
+ if (Ymin == -1 || Ymin > pt.Y)
+ {
+ //Si le point est plus petit en Y que Ymin, alors il est remplacé et on réinitialise la
+ //distance au dernier minimum en Y.
+ Ymin = pt.Y;
+ minPt = pt;
+ distToYmin = 0;
+ }
+ else
+ distToYmin++;
+
+ //Si Y max est plus grand que la position actuelle additionnée du seuil
+ //et que l'extremum n'est pas le premier point sauvegardé.
+ if (Ymax > pt.Y + directionChangeTresholdXY && maxPt != handPointerHistory.First())
+ whereToCut = currentPointNumber - distToYmax;
+ //Si Y min est plus petit que la position actuelle à laquelle on a retiré le seuil
+ //et que l'extremum n'est pas le premier point sauvegardé.
+ if (Ymin < pt.Y - directionChangeTresholdXY && minPt != handPointerHistory.First())
+ whereToCut = currentPointNumber - distToYmin;
+
+ return whereToCut;
+ }
+
+ /*
+ * Détecte un changement de sens (extremum) dans l'axe Z.
+ */
+ public int DetectDirectionChangeAtZAxis(Point3D pt)
+ {
+ //ID où couper en cas d'extremum.
+ int whereToCut = -1;
+
+ //Mise à jour des extremums.
+ if (Zmax == -1 || Zmax < pt.Z)
+ {
+ //Si le point est plus grand en Z que Ymax, alors il est remplacé et on réinitialise la
+ //distance au dernier maximum en Z.
+ Zmax = pt.Z;
+ maxPt = pt;
+ distToZmax = 0;
+ }
+ else
+ distToZmax++;
+ if (Zmin == -1 || Zmin > pt.Z)
+ {
+ //Si le point est plus petit en Z que Zmin, alors il est remplacé et on réinitialise la
+ //distance au dernier minimum en Z.
+ Zmin = pt.Z;
+ minPt = pt;
+ distToZmin = 0;
+ }
+ else
+ distToZmin++;
+
+ //Si Z max est plus grand que la position actuelle additionnée du seuil
+ //et que l'extremum n'est pas le premier point sauvegardé.
+ if (Zmax > pt.Z + directionChangeTresholdXY && maxPt != handPointerHistory.First())
+ whereToCut = currentPointNumber - distToZmax;
+ //Si Z min est plus petit que la position actuelle à laquelle on a retiré le seuil
+ //et que l'extremum n'est pas le premier point sauvegardé.
+ if (Zmin < pt.Z - directionChangeTresholdXY && minPt != handPointerHistory.First())
+ whereToCut = currentPointNumber - distToZmin;
+
+ return whereToCut;
+ }
+
+ /*
+ * Découpe le tracé en cours en segment allant du premier point au premier extremum trouvé.
+ */
+ public void Segment(int whereToCut)
+ {
+ handPointerHistory.RemoveRange(0, whereToCut);
+ currentPointNumber -= whereToCut;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Search/Structure.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Search/Structure.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,32 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Search
+ * Classe : Structure
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Définit la structure d'une courbe d'un point de vue algorithmique.
+ * Ce sont ces structures là qui seront comparées par la suite.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Search
+{
+ public class Structure
+ {
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Tracking/Tracking.csproj
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/Tracking/Tracking.csproj Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,72 @@
+
+
+
+ Debug
+ AnyCPU
+ 8.0.30703
+ 2.0
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}
+ Library
+ Properties
+ Trakers
+ Tracking
+ v4.0
+ 512
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+ False
+ ..\lib\Microsoft.Kinect.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/Trakers.sln
--- a/middleware/Trakers.sln Fri Mar 30 11:14:14 2012 +0200
+++ b/middleware/Trakers.sln Mon Apr 02 16:30:56 2012 +0200
@@ -1,18 +1,64 @@
Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Trakers", "src\Trakers.csproj", "{09EF8613-2F1B-4F1D-B6B1-22938EBB529A}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MainModule", "src\MainModule.csproj", "{09EF8613-2F1B-4F1D-B6B1-22938EBB529A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Debug", "Debug\Debug.csproj", "{EC766553-473F-4865-84E9-88F79D5F12A9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Communication", "Communication\Communication.csproj", "{D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tracking", "Tracking\Tracking.csproj", "{1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Debug|Mixed Platforms = Debug|Mixed Platforms
Debug|x86 = Debug|x86
+ Release|Any CPU = Release|Any CPU
+ Release|Mixed Platforms = Release|Mixed Platforms
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Debug|Any CPU.ActiveCfg = Debug|x86
+ {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
+ {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Debug|Mixed Platforms.Build.0 = Debug|x86
{09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Debug|x86.ActiveCfg = Debug|x86
{09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Debug|x86.Build.0 = Debug|x86
+ {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Release|Any CPU.ActiveCfg = Release|x86
+ {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Release|Mixed Platforms.ActiveCfg = Release|x86
+ {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Release|Mixed Platforms.Build.0 = Release|x86
{09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Release|x86.ActiveCfg = Release|x86
{09EF8613-2F1B-4F1D-B6B1-22938EBB529A}.Release|x86.Build.0 = Release|x86
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Release|Any CPU.Build.0 = Release|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+ {EC766553-473F-4865-84E9-88F79D5F12A9}.Release|x86.ActiveCfg = Release|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Release|Any CPU.Build.0 = Release|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}.Release|x86.ActiveCfg = Release|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Release|Any CPU.Build.0 = Release|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}.Release|x86.ActiveCfg = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/compilation_script.bat
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/compilation_script.bat Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,3 @@
+copy "Communication\bin\Release\Communication.dll" "lib\Communication.dll"
+copy "Debug\bin\Release\Debug.dll" "lib\Debug.dll"
+copy "Tracking\bin\Release\Tracking.dll" "lib\Tracking.dll"
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/App.config
--- a/middleware/src/App.config Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Communication/Server.cs
--- a/middleware/src/Communication/Server.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,309 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Communication
- * Classe : Server
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Reçoit des notifications du module sous-module Tracking.
- * Traduit les notifications sous forme de messages OSC et les envoie au Front Atelier.
- * Forme des messages :
- * - Notification de main dans le champ de recherche : Point3D indiquant la position de la main dans l'espace.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.IO;
-using System.Net;
-using System.Net.Sockets;
-using System.Threading;
-using Tuio;
-using System.Windows;
-using Microsoft.Kinect;
-using Trakers.Tracking;
-using System.Windows.Media.Media3D;
-using Trakers.Tracking.Events;
-using System.Timers;
-using Trakers.Debug;
-using System.Resources;
-using System.Reflection;
-
-namespace Trakers.Communication
-{
- public class Server
- {
- //Serveur TUIO, provenant de la DLL TuioServer créé par Bespoke.
- private TuioServer server;
- //Affichage de debug.
- private DebugWindow debug;
-
- //Permet de savoir si un curseur pour la main gauche/droite a été créé.
- private bool leftHandCursorCreated;
- private bool rightHandCursorCreated;
- private bool messageCreated;
- private bool gestureLocked, modLocked;
- //Intervalle minimum entre les gestures.
- private int timerElapsing;
- //Timer.
- private System.Timers.Timer _timer;
- //Gestionnaire de ressources.
- private ResourceManager rm;
- //Dernier code envoyé.
- private String lastCode;
-
- /*
- * Constructeur : On initialise le serveur avec une adresse et un port, au début les curseurs
- * ne sont pas créés et on indique au ThreadPool une fonction de callback de manière à vérifier
- * s'il reçoit des notifications.
- */
- public Server(String host, int port, int _timerElapsing, DebugWindow _debug)
- {
- debug = _debug;
- rm = new ResourceManager("Trakers.Properties.resources", Assembly.GetExecutingAssembly());
- //Au départ, aucune main n'est dans le champ de recherche et aucune gesture n'est détectée.
- leftHandCursorCreated = false;
- rightHandCursorCreated = false;
- messageCreated = false;
- gestureLocked = false;
- modLocked = false;
- lastCode = "";
-
- timerElapsing = _timerElapsing;
-
- try
- {
- //On démarre le serveur TUIO.
- server = new TuioServer(host, port);
- //On initialise le threadPool (appelé toutes les N ms).
- ThreadPool.QueueUserWorkItem(ThreadPoolCallback);
-
- //On instancie le timer à N ms.
- _timer = new System.Timers.Timer(timerElapsing);
- //Dès que le timer est expiré, on appelle _timer_Elapsed.
- _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
- }
- catch (Exception)
- {
- debug.ExceptionLbl.Content = rm.GetString("serverCantStart");
- }
- }
-
- /*
- * Getter du serveur.
- */
- public TuioServer getServer()
- {
- return server;
- }
-
- /*
- * Méthode appelée à l'expiration du timer pour les gestures et modes.
- */
- public void _timer_Elapsed(object sender, ElapsedEventArgs e)
- {
- //On débloque la détection de gesture.
- gestureLocked = false;
- //On débloque la notification de nouveau mode.
- modLocked = false;
- //On arrête le timer.
- _timer.Stop();
- }
-
- /*
- * Méthode appelée lors d'une notification de type : main gauche entrée dans le champ.
- */
- public void LeftHandTracked(object sender, LeftHandTrackedEventArgs e)
- {
- //Si le curseur de la main gauche n'est pas créé, alors on le crée.
- if (!leftHandCursorCreated)
- {
- server.AddTuioCursor(0, SkeletonPointToPoint3D(e.handJoint.Position));
- leftHandCursorCreated = true;
- }
- //S'il existe, on le met simplement à jour.
- else
- {
- server.UpdateTuioCursor(0, SkeletonPointToPoint3D(e.handJoint.Position));
- }
- }
-
- /*
- * Méthode appelée lors d'une notification de type : main droite entrée dans le champ.
- */
- public void RightHandTracked(object sender, RightHandTrackedEventArgs e)
- {
- //Si le curseur de la main droite n'est pas créé, alors on le crée.
- if (!rightHandCursorCreated)
- {
- server.AddTuioCursor(1, SkeletonPointToPoint3D(e.handJoint.Position));
- rightHandCursorCreated = true;
- }
- //S'il existe, on le met simplement à jour.
- else
- {
- server.UpdateTuioCursor(1, SkeletonPointToPoint3D(e.handJoint.Position));
- }
- }
-
- /*
- * Méthode appelée lors d'une notification de type : main gauche sortie du champ.
- */
- public void LeftHandQuit(object sender, LeftHandQuitEventArgs e)
- {
- //Si le curseur de la main gauche existe, alors on le supprime.
- if (leftHandCursorCreated)
- {
- server.DeleteTuioCursor(0);
- leftHandCursorCreated = false;
- }
- }
-
- /*
- * Méthode appelée lors d'une notification de type : main droite sortie du champ.
- */
- public void RightHandQuit(object sender, RightHandQuitEventArgs e)
- {
- //Si le curseur de la main droite existe, alors on le supprime.
- if (rightHandCursorCreated)
- {
- server.DeleteTuioCursor(1);
- rightHandCursorCreated = false;
- }
- }
-
- /*
- * Méthode appelée lors d'une notification de type : l'utilisateur fait un swipe.
- */
- public void Swipe(object sender, SwipeEventArgs e)
- {
- if (e.direction == Tracking.Gestures.SwipeDetector.Direction.LEFT)
- GesturePerformed("SWIPE LEFT");
- else if (e.direction == Tracking.Gestures.SwipeDetector.Direction.RIGHT)
- GesturePerformed("SWIPE RIGHT");
- }
-
- /*
- * Méthode appelée lors d'une notification de type : l'utilisateur fait un push/pull.
- */
- public void Push(object sender, PushEventArgs e)
- {
- if(e.hand == Tracking.Gestures.PushDetector.Hand.NONE)
- return;
-
- String pushPull = "", hand = "";
- if (e.direction == Tracking.Gestures.PushDetector.Direction.PUSH)
- pushPull = "PUSH";
- else
- pushPull = "PULL";
-
- if (e.hand == Tracking.Gestures.PushDetector.Hand.LEFT)
- hand = "LEFT";
- else if (e.hand == Tracking.Gestures.PushDetector.Hand.RIGHT)
- hand = "RIGHT";
- else
- hand = "BOTH";
-
- GesturePerformed(pushPull + "-" + hand);
- }
-
- /*
- * Méthode appelée lorsqu'une gesture a été détectée et que l'événement approprié a été lancé.
- */
- public void GesturePerformed(String code)
- {
- //Si le code vient d'être envoyé, on passe.
- if (lastCode.Equals(code))
- return;
- lastCode = code;
- //Si une gesture a été effectuée, on bloque un certain temps.
- if (!gestureLocked)
- {
- gestureLocked = true;
-
- //On crée un message contenant le code à envoyer.
- if (!messageCreated)
- {
- messageCreated = true;
- Console.Out.WriteLine("A 2");
- server.AddTuioString(2, code);
- //On démarre le timer.
- _timer.Start();
- }
- }
- }
-
- /*
- * Méthode appelée lorsqu'on doit entrer dans un autre mode.
- */
- public void ModeNotification(String code)
- {
- //Si le code vient d'être envoyé, on passe.
- if (lastCode.Equals(code))
- return;
- lastCode = code;
- //Si on a été notifié.
- if (!modLocked)
- {
- modLocked = true;
-
- //On crée un message contenant le code à envoyer.
- if (!messageCreated)
- {
- messageCreated = true;
- Console.Out.WriteLine("A 3");
- server.AddTuioString(2, code);
- //On démarre le timer.
- _timer.Start();
- }
- }
- }
-
- /*
- * Permet de convertir un point de position de noeud en Point3D.
- */
- private Point3D SkeletonPointToPoint3D(SkeletonPoint p)
- {
- return new Point3D((double)p.X, (double)p.Y, (double)p.Z);
- }
-
- /*
- * Méthode de callback vérifiant toutes les 25 ms les nouvelles notifications.
- * Il est à noter que si le temps de rafraîchissement des trop rapide, les messages n'ont pas
- * le temps d'être envoyés.
- */
- private void ThreadPoolCallback(Object threadContext)
- {
- while (true)
- {
- //On initialise le message OSC.
- server.InitFrame();
- //On l'envoie au client (au host et au port spécifiés dans le constructeur).
- server.CommitFrame();
- //On attend 25 ms.
- Thread.Sleep(25);
-
- //Si une gesture a été effectuée et que le délai d'attente est expiré.
- if (messageCreated && !gestureLocked && !modLocked)
- {
- //On débloque la détection de gesture et on supprime l'objet envoyant les messages OSC de gesture.
- messageCreated = false;
- server.DeleteTuioString(2);
- //server.DeleteTuioString(3);
- Console.Out.WriteLine("R");
- }
- }
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Debug/DebugParameters.xaml
--- a/middleware/src/Debug/DebugParameters.xaml Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,133 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Debug/DebugParameters.xaml.cs
--- a/middleware/src/Debug/DebugParameters.xaml.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,144 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Debug
- * Classe : DebugParameters
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Code source attaché à la fenêtre de paramétrage du Middleware.
- * Celui-ci permet de charger/sauvegarder les paramètres stockés dans KinectMain.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Shapes;
-using Trakers.Tracking;
-using System.Reflection;
-using System.Resources;
-
-namespace Trakers.Debug
-{
- ///
- /// Interaction logic for DebugParameters.xaml
- ///
- public partial class DebugParameters : Window
- {
- //Membre d'accès à KinectMain.
- private KinectMain kinectMain;
- private ResourceManager rm;
-
- /*
- * Constructeur : On ouvre la fenêtre et on charge les paramètres.
- */
- public DebugParameters(KinectMain _kinectMain)
- {
- rm = new ResourceManager("Trakers.Properties.resources", Assembly.GetExecutingAssembly());
- kinectMain = _kinectMain;
- InitializeComponent();
- getParameters();
- }
-
- /*
- * Permet de charger les paramètres depuis KinectMain et les affiche dans la fenêtre de paramétrage.
- */
- public void getParameters()
- {
- searchMinDistanceTB.Text = kinectMain.getMinDistHands().ToString();
- searchMaxDistanceTB.Text = kinectMain.getMaxDistHands().ToString();
- minDistanceTB.Text = kinectMain.getMinDist().ToString();
- maxDistanceTB.Text = kinectMain.getMaxDist().ToString();
- zeroPointTB.Text = kinectMain.getZeroPoint().ToString();
- connexionHostTB.Text = kinectMain.getConnexionHost();
- connexionPortTB.Text = kinectMain.getConnexionPort().ToString();
- timerElapsingTB.Text = kinectMain.getTimerElapsing().ToString();
- imagesToShowTB.Text = kinectMain.getImagesToShow().ToString();
- takenPointsTB.Text = kinectMain.getTakenPoints().ToString();
- directionChangeTresholdXYTB.Text = kinectMain.getTakenPoints().ToString();
- directionChangeTresholdZTB.Text = kinectMain.getTakenPoints().ToString();
- }
-
- /*
- * Permet de sauvegarder les paramètres de la fenêtre de paramétrage vers KinectMain.
- */
- public void setParameters()
- {
- try
- {
- ExceptionInParametersLbl.Content = "";
-
- float minDistHands = float.Parse(searchMinDistanceTB.Text);
- float maxDistHands = float.Parse(searchMaxDistanceTB.Text);
- float minDist = float.Parse(minDistanceTB.Text);
- float maxDist = float.Parse(maxDistanceTB.Text);
- float zeroPoint = float.Parse(zeroPointTB.Text);
- int connexionPort = int.Parse(connexionPortTB.Text);
- int timerElapsing = int.Parse(timerElapsingTB.Text);
- int imagesToShow = int.Parse(imagesToShowTB.Text);
- int takenPoints = int.Parse(takenPointsTB.Text);
- int directionChangeTresholdXY = int.Parse(directionChangeTresholdXYTB.Text);
- float directionChangeTresholdZ = float.Parse(directionChangeTresholdZTB.Text);
-
- if (maxDistHands <= 0f || minDistHands <= 0f || maxDistHands > maxDist || minDistHands > maxDist ||
- minDistHands >= maxDistHands || zeroPoint < maxDistHands || minDistHands < minDist ||
- zeroPoint >= maxDist || connexionPort < 0 || timerElapsing < 0 || imagesToShow < 1 ||
- takenPoints <= 0 || directionChangeTresholdXY < 0 || directionChangeTresholdZ < 0)
- {
- ExceptionInParametersLbl.Content = rm.GetString("loadParametersIncorrect");
- }
- else
- {
- kinectMain.setMinDistHands(minDistHands);
- kinectMain.setMaxDistHands(maxDistHands);
- kinectMain.setMinDist(minDist);
- kinectMain.setMaxDist(maxDist);
- kinectMain.setZeroPoint(zeroPoint);
- kinectMain.setConnexionHost(connexionHostTB.Text);
- kinectMain.setConnexionPort(connexionPort);
- kinectMain.setTimerElapsing(timerElapsing);
- kinectMain.setImagesToShow(imagesToShow);
- kinectMain.setTakenPoints(takenPoints);
- kinectMain.setDirectionChangeTresholdXY(directionChangeTresholdXY);
- kinectMain.setDirectionChangeTresholdZ(directionChangeTresholdZ);
-
- kinectMain.updateParameters();
- ExceptionInParametersLbl.Content = null;
- }
- }
- catch (Exception)
- {
- //S'il y a eu un problème de parsing (i.e si l'utilisateur a entré une mauvaise valeur),
- //Alors on affiche l'erreur, puis on recharge les paramètres précédents.
- ExceptionInParametersLbl.Content = rm.GetString("loadParametersFail");
- getParameters();
- }
- }
-
- /*
- * Méthode attachée à l'événement click sur le bouton de validation de la fenêtre de paramétrage.
- * Les données sont sauvegardées vers KinectMain, puis rechargées dans la fenêtre.
- */
- private void Button_Click(object sender, RoutedEventArgs e)
- {
- setParameters();
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Debug/DebugWindow.xaml
--- a/middleware/src/Debug/DebugWindow.xaml Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,92 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Debug/DebugWindow.xaml.cs
--- a/middleware/src/Debug/DebugWindow.xaml.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,627 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Debug
- * Classe : DebugWindow
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Reçoit des notifications des sous-modules Tracking, Communication et Exception.
- * Intéragit avec la fenêtre XAML de debug de façon à afficher un rendu visuel.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
-using System.Drawing;
-using System.Windows.Media.Media3D;
-using Microsoft.Kinect;
-
-using Coding4Fun.Kinect.Wpf;
-
-using Trakers.Tracking;
-using System.Threading;
-using Trakers.Tracking.Events;
-using Trakers.Tracking.Gestures;
-using System.Resources;
-using System.Reflection;
-using System.Timers;
-using Trakers.Communication;
-
-namespace Trakers.Debug
-{
- public partial class DebugWindow : Window
- {
- //Gestionnaire de ressources.
- private ResourceManager rm;
- //Timer.
- private System.Timers.Timer _timer;
- //Membre permettant d'atteindre la classe KinectMain du sous-module Tracking.
- private KinectMain kinectMain;
- //Tableau contenant une image en couleurs.
- private byte[] colorPixelData;
- //Indique si la kinect est allumée/éteinte.
- private bool on;
- //Indique si la fenêtre de debug est actuellement en cours de fermeture.
- private bool closing;
- //Indique si l'image doit être raffraichie.
- private Boolean refreshImage;
-
- /*
- * Constructeur : Affiche la fenêtre de debug en lui passant en paramètre une instanciation de la
- * classe KinectMain.
- * Au départ, la kinect est éteinte.
- */
- public DebugWindow(KinectMain main)
- {
- rm = new ResourceManager("Trakers.Properties.resources", Assembly.GetExecutingAssembly());
- InitializeComponent();
- kinectMain = main;
- on = true;
- closing = false;
- refreshImage = true;
-
- try
- {
- //On instancie le timer à N ms.
- _timer = new System.Timers.Timer(kinectMain.getTimerElapsing());
- //Dès que le timer est expiré, on appelle _timer_Elapsed.
- _timer.Elapsed += new ElapsedEventHandler(_timer_Elapsed);
- }
- catch (Exception){}
- }
-
- /*
- * Méthode appelée à l'expiration du timer pour les gestures et modes.
- */
- public void _timer_Elapsed(object sender, ElapsedEventArgs e)
- {
- //On débloque le raffraichissement de l'image.
- refreshImage = true;
- //On arrête le timer.
- _timer.Stop();
- }
-
- /*
- * Getter pour le membre indiquant la fermeture de la fenêtre de debug.
- */
- public bool isClosing()
- {
- return closing;
- }
-
- /*
- * Est appelée à la fermeture de la fenêtre.
- */
- private void Window_Closed(object sender, EventArgs e)
- {
- closing = true;
- //On éteint la Kinect (pour éviter qu'elle reste allumée même lorsque le programme est éteint).
- kinectMain.KinectClose();
- }
-
- /*
- * Bouton ON/OFF.
- */
- private void Switch_Click(object sender, RoutedEventArgs e)
- {
- //S'il valait faux, il vaut vrai maintenant et inversement.
- on = !on;
- //Si la kinect est allumée.
- if (on)
- {
- //Il affiche OFF (pour éteindre la kinect).
- Switch.Content = "OFF";
- //On vide le label des exceptions.
- ExceptionLbl.Content = "";
- //On initialise la Kinect.
- kinectMain.KinectInitialization();
- }
- else
- {
- //Il affiche ON (pour allumer la kinect).
- Switch.Content = "ON";
- //On remet à zéro tous les éléments du retour visuel.
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- DistanceLbl.Content = "Distance :";
- LeftHand.Background = System.Windows.Media.Brushes.DarkGray;
- LeftHand.Content = "";
- RightHand.Background = System.Windows.Media.Brushes.DarkGray;
- RightHand.Content = "";
- DebugCanvas.Children.RemoveRange(1, DebugCanvas.Children.Count - 1);
- //On éteint la Kinect.
- kinectMain.KinectClose();
- }
- }
-
- /*
- * Récupère le flux video et met à jour le rendu visuel de debug.
- */
- public void RefreshVideo(AllFramesReadyEventArgs e)
- {
- if (refreshImage)
- {
- bool receivedData = false;
- ColorImageFrame colorImageFrameData;
- using (colorImageFrameData = e.OpenColorImageFrame())
- {
- //Si on ne reçoit pas de trames de la kinect.
- if (colorImageFrameData == null)
- {
- //L'image est supprimée.
- DebugImage.Source = null;
- }
- //Si le tableau stockant l'image en cours est nul.
- if (colorPixelData == null)
- //On alloue un nouveau tableau.
- colorPixelData = new byte[colorImageFrameData.PixelDataLength];
- else
- {
- try
- {
- //Sinon on met à jour le tableau en copiant le contenu de la trame dans le tableau.
- colorImageFrameData.CopyPixelDataTo(colorPixelData);
- receivedData = true;
- }
- catch (Exception) { }
- }
- }
- //Si on a des données dans le tableau et que la kinect est allumée.
- if (receivedData && on)
- {
- //On met à jour l'image de la caméra.
- DebugImage.Source = BitmapSource.Create(colorImageFrameData.Width, colorImageFrameData.Height, 96, 96, PixelFormats.Bgr32, null, colorPixelData, colorImageFrameData.Width * colorImageFrameData.BytesPerPixel);
- DebugImage.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
- DebugImage.VerticalAlignment = System.Windows.VerticalAlignment.Center;
- DebugImage.Stretch = Stretch.Fill;
- //On annule l'image associée aux gestures.
- Gestures.Source = null;
- }
- }
- }
-
- /*
- * Affiche la distance de l'utilisateur dans le rendu visuel.
- * Sous forme de nombre en m et de rectangles changeant de couleur en fonction de la distance.
- */
- public void showDistance(float proximity)
- {
- DistanceLbl.Content = "Proximity : " + proximity + "%";
-
- if (proximity == 0)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.DarkGray;
- R6.Fill = System.Windows.Media.Brushes.DarkGray;
- R7.Fill = System.Windows.Media.Brushes.DarkGray;
- R8.Fill = System.Windows.Media.Brushes.DarkGray;
- R9.Fill = System.Windows.Media.Brushes.DarkGray;
- R10.Fill = System.Windows.Media.Brushes.DarkGray;
- }
- else if (proximity > 0 && proximity < 10)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.DarkGray;
- R6.Fill = System.Windows.Media.Brushes.DarkGray;
- R7.Fill = System.Windows.Media.Brushes.DarkGray;
- R8.Fill = System.Windows.Media.Brushes.DarkGray;
- R9.Fill = System.Windows.Media.Brushes.DarkGray;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 10 && proximity < 20)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.DarkGray;
- R6.Fill = System.Windows.Media.Brushes.DarkGray;
- R7.Fill = System.Windows.Media.Brushes.DarkGray;
- R8.Fill = System.Windows.Media.Brushes.DarkGray;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 20 && proximity < 30)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.DarkGray;
- R6.Fill = System.Windows.Media.Brushes.DarkGray;
- R7.Fill = System.Windows.Media.Brushes.DarkGray;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 30 && proximity < 40)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.DarkGray;
- R6.Fill = System.Windows.Media.Brushes.DarkGray;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 40 && proximity < 50)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.DarkGray;
- R6.Fill = System.Windows.Media.Brushes.Orange;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 50 && proximity < 60)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.Orange;
- R6.Fill = System.Windows.Media.Brushes.Orange;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 60 && proximity < 70)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.Yellow;
- R5.Fill = System.Windows.Media.Brushes.Orange;
- R6.Fill = System.Windows.Media.Brushes.Orange;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 70 && proximity < 80)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.Yellow;
- R4.Fill = System.Windows.Media.Brushes.Yellow;
- R5.Fill = System.Windows.Media.Brushes.Orange;
- R6.Fill = System.Windows.Media.Brushes.Orange;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 80 && proximity < 90)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.Yellow;
- R3.Fill = System.Windows.Media.Brushes.Yellow;
- R4.Fill = System.Windows.Media.Brushes.Yellow;
- R5.Fill = System.Windows.Media.Brushes.Orange;
- R6.Fill = System.Windows.Media.Brushes.Orange;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity > 90 && proximity < 100)
- {
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.Yellow;
- R2.Fill = System.Windows.Media.Brushes.Yellow;
- R3.Fill = System.Windows.Media.Brushes.Yellow;
- R4.Fill = System.Windows.Media.Brushes.Yellow;
- R5.Fill = System.Windows.Media.Brushes.Orange;
- R6.Fill = System.Windows.Media.Brushes.Orange;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- else if (proximity == 100)
- {
- R0.Fill = System.Windows.Media.Brushes.Green;
- R1.Fill = System.Windows.Media.Brushes.Yellow;
- R2.Fill = System.Windows.Media.Brushes.Yellow;
- R3.Fill = System.Windows.Media.Brushes.Yellow;
- R4.Fill = System.Windows.Media.Brushes.Yellow;
- R5.Fill = System.Windows.Media.Brushes.Orange;
- R6.Fill = System.Windows.Media.Brushes.Orange;
- R7.Fill = System.Windows.Media.Brushes.Orange;
- R8.Fill = System.Windows.Media.Brushes.Red;
- R9.Fill = System.Windows.Media.Brushes.Red;
- R10.Fill = System.Windows.Media.Brushes.Red;
- }
- }
-
- /*
- * Affiche la détection de la main droite via un label.
- */
- public void showRightHandRect(bool show)
- {
- if (show)
- RightHand.Background = System.Windows.Media.Brushes.Blue;
- else
- RightHand.Background = System.Windows.Media.Brushes.DarkGray;
- }
-
- /*
- * Affiche la détection de la main gauche via un label.
- */
- public void showLeftHandRect(bool show)
- {
- if (show)
- LeftHand.Background = System.Windows.Media.Brushes.Blue;
- else
- LeftHand.Background = System.Windows.Media.Brushes.DarkGray;
- }
-
- /*
- * Dessine les noeuds du squelette dans le rendu visuel.
- */
- public void drawJoints(JointCollection joints, Skeleton first)
- {
- if (refreshImage)
- {
- //On enlève tout élément du Canvas à part l'image, de manière à mettre à jour la position du squelette.
- DebugCanvas.Children.RemoveRange(1, DebugCanvas.Children.Count - 1);
-
- //Pour chaque noeud.
- foreach (Joint joint in first.Joints)
- {
- //On crée une ellipse de taille 20 et de largeur 20.
- Ellipse node = new Ellipse();
- node.Height = 20;
- node.Width = 20;
-
- //S'il s'agit d'un noeud de tête, on le colorie en rouge, sinon en bleu.
- if (joint.JointType == JointType.Head)
- node.Fill = System.Windows.Media.Brushes.Red;
- else if (joint.JointType == JointType.ShoulderCenter)
- node.Fill = System.Windows.Media.Brushes.Green;
- else if (joint.JointType == JointType.HipCenter)
- node.Fill = System.Windows.Media.Brushes.Green;
- else if (joint.JointType == JointType.HandRight)
- node.Fill = System.Windows.Media.Brushes.Red;
- else
- node.Fill = System.Windows.Media.Brushes.Blue;
-
- //On met à la bonne échelle les coordonnées des positions des noeuds.
- Joint scaledJoint = Coding4Fun.Kinect.Wpf.SkeletalExtensions.ScaleTo(joint, 600, 400, 0.75f, 0.75f);
-
- //On positionne le noeud dans le Canvas, et on l'ajoute.
- Canvas.SetLeft(node, scaledJoint.Position.X);
- Canvas.SetTop(node, scaledJoint.Position.Y);
- DebugCanvas.Children.Add(node);
- }
- }
- }
-
- /*
- * Dessine un os, en ayant en paramètres deux noeuds.
- */
- public void drawBone(Joint j1, Joint j2)
- {
- //On crée une nouvelle ligne verte d'épaisseur 8 entre les deux noeuds et on l'ajoute au Canvas.
- Line line = new Line();
- line.Stroke = System.Windows.Media.Brushes.Green;
- line.X1 = j1.Position.X;
- line.X2 = j2.Position.X;
- line.Y1 = j1.Position.Y;
- line.Y2 = j2.Position.Y;
- line.StrokeThickness = 8;
- DebugCanvas.Children.Add(line);
- }
-
- /*
- * Dessine le squelette (ensemble des os), en ayant en paramètres tous les noeuds.
- */
- public void showSkeleton(Joint hipCenter, Joint spine, Joint shoulderCenter, Joint head, Joint shoulderLeft, Joint elbowLeft, Joint wristLeft, Joint handLeft, Joint shoulderRight, Joint elbowRight, Joint wristRight, Joint handRight, Joint hipLeft, Joint kneeLeft, Joint ankleLeft, Joint footLeft, Joint hipRight, Joint kneeRight, Joint ankleRight, Joint footRight)
- {
- if (refreshImage)
- {
- //On met les noeuds deux par deux en fonction de leur position dans le squelette.
- drawBone(head, shoulderCenter);
- drawBone(shoulderCenter, shoulderLeft);
- drawBone(shoulderLeft, elbowLeft);
- drawBone(elbowLeft, wristLeft);
- drawBone(wristLeft, handLeft);
- drawBone(shoulderCenter, shoulderRight);
- drawBone(shoulderRight, elbowRight);
- drawBone(elbowRight, wristRight);
- drawBone(wristRight, handRight);
- drawBone(shoulderCenter, spine);
- drawBone(spine, hipCenter);
- drawBone(hipCenter, hipLeft);
- drawBone(hipLeft, kneeLeft);
- drawBone(kneeLeft, ankleLeft);
- drawBone(ankleLeft, footLeft);
- drawBone(hipCenter, hipRight);
- drawBone(hipRight, kneeRight);
- drawBone(kneeRight, ankleRight);
- drawBone(ankleRight, footRight);
- }
- }
-
- /*
- * Cache le squelette et le reste de l'interface à part l'image.
- */
- public void hideSkeleton()
- {
- //On vide le canvas mais en gardant l'image.
- if(DebugCanvas.Children.Count > 1)
- DebugCanvas.Children.RemoveRange(1, DebugCanvas.Children.Count - 1);
- //On colore en gris tous les indicateurs.
- R0.Fill = System.Windows.Media.Brushes.DarkGray;
- R1.Fill = System.Windows.Media.Brushes.DarkGray;
- R2.Fill = System.Windows.Media.Brushes.DarkGray;
- R3.Fill = System.Windows.Media.Brushes.DarkGray;
- R4.Fill = System.Windows.Media.Brushes.DarkGray;
- R5.Fill = System.Windows.Media.Brushes.DarkGray;
- R6.Fill = System.Windows.Media.Brushes.DarkGray;
- R7.Fill = System.Windows.Media.Brushes.DarkGray;
- R8.Fill = System.Windows.Media.Brushes.DarkGray;
- R9.Fill = System.Windows.Media.Brushes.DarkGray;
- R10.Fill = System.Windows.Media.Brushes.DarkGray;
- }
-
- /*
- * Affiche la position de la main gauche dans le rendu visuel.
- */
- public void showLeftHandCoord(String coord)
- {
- LeftHand.Content = coord;
- }
-
- /*
- * Affiche la position de la main gauche dans le rendu visuel.
- */
- public void showRightHandCoord(String coord)
- {
- RightHand.Content = coord;
- }
-
- /*
- * Méthode associée à l'événement : Ouvrir la fenêtre de paramétrage via le menu.
- */
- private void Parameters_Click(object sender, RoutedEventArgs e)
- {
- DebugParameters param = new DebugParameters(kinectMain);
-
- try
- {
- param.ShowDialog();
- }
- catch (Exception)
- {
- ExceptionLbl.Content = rm.GetString("loadParamFail");
- }
- }
-
- /*
- * Méthode associée à l'événement : Quitter via le menu.
- */
- private void Quit_Click(object sender, RoutedEventArgs e)
- {
- closing = true;
- //On éteint la Kinect (pour éviter qu'elle reste allumée même lorsque le programme est éteint).
- kinectMain.KinectClose();
- Application.Current.Shutdown();
- }
-
- /*
- * Permet d'initialiser la Kinect dès que la fenêtre est lancée.
- */
- private void Window_Loaded(object sender, RoutedEventArgs e)
- {
- kinectMain.KinectInitialization();
- }
-
- /*
- * Méthode d'affichage des gestures.
- */
- public void showGesture(String gesture)
- {
- if (refreshImage)
- {
- refreshImage = false;
- _timer.Start();
- Bitmap bitmap = null;
- //S'il s'agit de telle ou telle gesture, on prend l'image correspondante dans les ressources,
- //on la convertit et on l'affiche.
- switch (gesture)
- {
- case "SWIPE-LEFT": bitmap = (Bitmap)rm.GetObject("swipe_left");
- break;
- case "SWIPE-RIGHT": bitmap = (Bitmap)rm.GetObject("swipe_right");
- break;
- case "PUSH-RIGHT": bitmap = (Bitmap)rm.GetObject("push_right");
- break;
- case "PUSH-LEFT": bitmap = (Bitmap)rm.GetObject("push_left");
- break;
- case "PUSH-BOTH": bitmap = (Bitmap)rm.GetObject("push_both");
- break;
- case "PULL-RIGHT": bitmap = (Bitmap)rm.GetObject("pull_right");
- break;
- case "PULL-LEFT": bitmap = (Bitmap)rm.GetObject("pull_left");
- break;
- case "PULL-BOTH": bitmap = (Bitmap)rm.GetObject("pull_both");
- break;
- }
- Gestures.Source = CreateBitmapSourceFromBitmap(bitmap);
- }
-
- DebugImage.Source = null;
- hideSkeleton();
- }
-
- /*
- * Méthode d'indication de raffraichissement de l'image ("on la raffraichit ou pas ?").
- */
- public void setRefreshImage(bool refresh)
- {
- refreshImage = refresh;
- }
-
- /*
- * Méthode de conversion de Bitmap (des ressources) en BitmapSource (du debug).
- */
- public static BitmapSource CreateBitmapSourceFromBitmap(Bitmap bitmap)
- {
- if (bitmap == null)
- return null;
-
- return System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
- bitmap.GetHbitmap(),
- IntPtr.Zero,
- Int32Rect.Empty,
- BitmapSizeOptions.FromEmptyOptions());
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainClass.cs
--- a/middleware/src/MainClass.cs Fri Mar 30 11:14:14 2012 +0200
+++ b/middleware/src/MainClass.cs Mon Apr 02 16:30:56 2012 +0200
@@ -19,20 +19,7 @@
*/
using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-using Trakers.Debug;
-using Trakers.Tracking;
-using Trakers.Communication;
-using System.Windows.Media.Media3D;
-using System.Drawing;
-using System.Threading;
-using System.IO;
-using System.Resources;
-using System.Reflection;
-using Tuio;
+using Trakers.MainModule;
namespace Trakers
{
@@ -41,21 +28,8 @@
[STAThread]
public static void Main()
{
- //Crée le gestionnaire de ressources.
- ResourceManager rm = new ResourceManager("Trakers.Properties.resources", Assembly.GetExecutingAssembly());
//Fait appel à la classe qui gère la Kinect.
- KinectMain kinectMain = new KinectMain(rm);
-
- /*TuioServer s = new TuioServer("127.0.0.1", 80);
-
- s.AddTuioCursor(0, new Point3D(100, 100, 1));
- for (int i = 0; i < 10000; i++)
- {
- Thread.Sleep(100);
- s.UpdateTuioCursor(0, new Point3D(100, 100, 1));
- Console.Out.WriteLine("ref");
- }
- s.DeleteTuioCursor(0);*/
+ KinectMain kinectMain = new KinectMain();
}
}
}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule.csproj
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule.csproj Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,150 @@
+
+
+
+ Debug
+ x86
+ 8.0.30703
+ 2.0
+ {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}
+ WinExe
+ Properties
+ Trakers
+ MainModule
+ v4.0
+ Client
+ 512
+ {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
+ 4
+
+
+ x86
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+
+
+ x86
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+
+
+
+
+
+
+ True
+
+
+ ..\lib\Bespoke.Common.dll
+
+
+ ..\lib\Bespoke.Common.Osc.dll
+
+
+ False
+ ..\lib\Coding4Fun.Kinect.Wpf.dll
+
+
+ False
+ ..\lib\Microsoft.Kinect.dll
+
+
+
+
+
+
+
+
+
+
+
+ 4.0
+
+
+ ..\lib\TuioServer.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Code
+
+
+ True
+ True
+ Resources.resx
+ PreserveNewest
+
+
+ True
+ Settings.settings
+ True
+
+
+
+
+
+
+ ResXFileCodeGenerator
+ Resources.Designer.cs
+ PreserveNewest
+
+
+ SettingsSingleFileGenerator
+ Settings.Designer.cs
+
+
+
+
+
+ {D8DC5409-6FF4-49CC-BC53-85AE6AE43E91}
+ Communication
+
+
+ {EC766553-473F-4865-84E9-88F79D5F12A9}
+ Debug
+
+
+ {1AE0776C-DED9-4B45-BAAB-99E7A365B8A1}
+ Tracking
+
+
+
+
+
\ No newline at end of file
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/CircleEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/CircleEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,40 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : CircleEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : L'utilisateur a tracé un cercle.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.Communication;
+using Trakers.Debug;
+
+namespace Trakers.MainModule.Events
+{
+ public class CircleEventArgs : MainEventArgs
+ {
+ /*
+ * Constructeur.
+ */
+ public CircleEventArgs(Server _server, DebugWindow _debug) : base(_server, _debug)
+ {
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/CircleListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/CircleListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,40 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : CircleListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur a tracé un cercle.
+ * Il contient le code a être éxecuté au cas où cet événement survient.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Events
+{
+ public class CircleListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : L'utilisateur a tracé un cercle.
+ */
+ public void showAndSend(object o, JumpEventArgs e)
+ {
+ e.debug.showGesture("CIRCLE");
+ e.server.GesturePerformed("CIRCLE");
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/JumpEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/JumpEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,41 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : JumpEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : L'utilisateur a sauté.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.Debug;
+using Trakers.Communication;
+
+namespace Trakers.MainModule.Events
+{
+ public class JumpEventArgs : MainEventArgs
+ {
+
+ /*
+ * Constructeur.
+ */
+ public JumpEventArgs(Server _server, DebugWindow _debug) : base(_server, _debug)
+ {
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/JumpListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/JumpListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,40 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : JumpListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur a sauté.
+ * Il contient le code a être éxecuté au cas où cet événement survient.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Events
+{
+ public class JumpListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : L'utilisateur a sauté.
+ */
+ public void showAndSend(object o, JumpEventArgs e)
+ {
+ e.debug.showGesture("JUMP");
+ e.server.GesturePerformed("JUMP");
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/LeftHandQuitEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/LeftHandQuitEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,41 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : LeftHandQuitEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : La main gauche est sortie du champ.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using Trakers.Communication;
+using Trakers.Debug;
+
+namespace Trakers.MainModule.Events
+{
+ public class LeftHandQuitEventArgs : MainEventArgs
+ {
+ /*
+ * Constructeur.
+ */
+ public LeftHandQuitEventArgs(Server _server, DebugWindow _debug) : base(_server, _debug)
+ {
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/LeftHandQuitListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/LeftHandQuitListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,41 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : LeftHandQuitListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : La main gauche est sortie du champ.
+ * Il contient le code a être éxecuté au cas où cet événement survient.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+
+namespace Trakers.MainModule.Events
+{
+ public class LeftHandQuitListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : La main gauche est sortie du champ.
+ */
+ public void showAndSend(object o, LeftHandQuitEventArgs e)
+ {
+ e.debug.showLeftHandRect(false);
+ e.server.LeftHandQuit();
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/LeftHandTrackedEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/LeftHandTrackedEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,46 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : LeftHandTrackedEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : La main gauche est entrée dans le champ.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using Trakers.Communication;
+using Trakers.Debug;
+
+namespace Trakers.MainModule.Events
+{
+ public class LeftHandTrackedEventArgs : MainEventArgs
+ {
+ public readonly Joint handJoint;
+ public readonly float position;
+
+ /*
+ * Constructeur : Il prend le noeud de la main et sa position.
+ */
+ public LeftHandTrackedEventArgs(Server _server, DebugWindow _debug, Joint joint, float pos) : base(_server, _debug)
+ {
+ handJoint = joint;
+ position = pos;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/LeftHandTrackedListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/LeftHandTrackedListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,43 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : LeftHandTrackedListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : La main gauche est entrée dans le champ.
+ * Il contient le code a être éxecuté au cas où cet événement survient.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using System.Windows.Media.Media3D;
+
+namespace Trakers.MainModule.Events
+{
+ public class LeftHandTrackedListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : La main gauche est entrée dans le champ.
+ */
+ public void showAndSend(object o, LeftHandTrackedEventArgs e)
+ {
+ e.debug.showLeftHandRect(true);
+ Point3D pt = new Point3D(e.handJoint.Position.X, e.handJoint.Position.Y, e.handJoint.Position.Z);
+ e.server.LeftHandTracked(pt);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/MainEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/MainEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,42 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : MainEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient un accès au serveur pour la transmission au front et
+ * un accès au debug pour afficher la gesture.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.Communication;
+using Trakers.Debug;
+
+namespace Trakers.MainModule.Events
+{
+ public class MainEventArgs : EventArgs
+ {
+ public readonly Server server;
+ public readonly DebugWindow debug;
+
+ public MainEventArgs(Server _server, DebugWindow _debug) : base()
+ {
+ server = _server;
+ debug = _debug;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/ModChangeEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/ModChangeEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,44 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : ModChangeEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : On entre dans un nouveau mode.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.Communication;
+using Trakers.Debug;
+
+namespace Trakers.MainModule.Events
+{
+ public class ModChangeEventArgs : MainEventArgs
+ {
+ //Code du mode.
+ public readonly String code;
+
+ /*
+ * Constructeur : Il prend l'affichage de debug et le serveur TUIO.
+ */
+ public ModChangeEventArgs(Server _server, DebugWindow _debug, String _code) : base(_server, _debug)
+ {
+ code = _code;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/ModChangeListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/ModChangeListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,42 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : ModChangeListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : On change de mode.
+ * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
+ * - On affiche un visuel dans le debug.
+ * - On notifie le serveur TUIO.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Events
+{
+ public class ModChangeListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : On change de mode.
+ */
+ public void showAndSend(object o, ModChangeEventArgs e)
+ {
+ //e.debug.showGesture(e.code);
+ //e.server.ModeNotification(e.code);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/PushEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/PushEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,48 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : PushEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : L'utilisateur a effectué un push.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.MainModule.Gestures;
+using Trakers.Debug;
+using Trakers.Communication;
+
+namespace Trakers.MainModule.Events
+{
+ public class PushEventArgs : MainEventArgs
+ {
+ //Direction du push.
+ public readonly PushDetector.Direction direction;
+ //Main ayant réalisé le push.
+ public readonly PushDetector.Hand hand;
+
+ /*
+ * Constructeur : Il prend l'affichage de debug, le serveur TUIO et la direction du swipe.
+ */
+ public PushEventArgs(Server _server, DebugWindow _debug, PushDetector.Direction _direction, PushDetector.Hand _hand) : base(_server, _debug)
+ {
+ direction = _direction;
+ hand = _hand;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/PushListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/PushListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,63 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : PushListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur a effectué un push.
+ * Il contient le code a être éxecuté au cas où cet événement survient.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Events
+{
+ public class PushListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : L'utilisateur a effectué un push.
+ */
+ public void showAndSend(object o, PushEventArgs e)
+ {
+ //On l'indique dans le debug.
+ //Lorsqu'il s'agit d'un push/pull de la main gauche/droite/deux deux on envoie le message
+ //correspondant.
+ String code = "";
+ if (e.direction == Gestures.PushDetector.Direction.PUSH)
+ {
+ if (e.hand == Gestures.PushDetector.Hand.RIGHT)
+ code = "PUSH-RIGHT";
+ else if (e.hand == Gestures.PushDetector.Hand.LEFT)
+ code = "PUSH-LEFT";
+ else
+ code = "PUSH-BOTH";
+ }
+ else
+ {
+ if (e.hand == Gestures.PushDetector.Hand.RIGHT)
+ code = "PULL-RIGHT";
+ else if (e.hand == Gestures.PushDetector.Hand.LEFT)
+ code = "PULL-LEFT";
+ else
+ code = "PULL-BOTH";
+ }
+
+ e.debug.showGesture(code);
+ e.server.GesturePerformed(code);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/RightHandQuitEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/RightHandQuitEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,41 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : RightHandQuitEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : La main droite est sortie du champ.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using Trakers.Debug;
+using Trakers.Communication;
+
+namespace Trakers.MainModule.Events
+{
+ public class RightHandQuitEventArgs : MainEventArgs
+ {
+ /*
+ * Constructeur.
+ */
+ public RightHandQuitEventArgs(Server _server, DebugWindow _debug) : base(_server, _debug)
+ {
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/RightHandQuitListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/RightHandQuitListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,43 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : RightHandQuitListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : La main droite est sortie du champ.
+ * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
+ * - On affiche un visuel dans le debug.
+ * - On notifie le serveur TUIO.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+
+namespace Trakers.MainModule.Events
+{
+ public class RightHandQuitListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : La main droite est sortie du champ.
+ */
+ public void showAndSend(object o, RightHandQuitEventArgs e)
+ {
+ e.debug.showRightHandRect(false);
+ e.server.RightHandQuit();
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/RightHandTrackedEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/RightHandTrackedEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,46 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : RightHandTrackedEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : La main droite est entrée dans le champ.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using Trakers.Debug;
+using Trakers.Communication;
+
+namespace Trakers.MainModule.Events
+{
+ public class RightHandTrackedEventArgs : MainEventArgs
+ {
+ public readonly Joint handJoint;
+ public readonly float position;
+
+ /*
+ * Constructeur : Il prend le noeud de la main et sa position.
+ */
+ public RightHandTrackedEventArgs(Server _server, DebugWindow _debug, Joint joint, float pos) : base(_server, _debug)
+ {
+ handJoint = joint;
+ position = pos;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/RightHandTrackedListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/RightHandTrackedListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,45 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : RightHandTrackedListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : La main droite est entrée dans le champ.
+ * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
+ * - On affiche un visuel dans le debug.
+ * - On notifie le serveur TUIO.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Microsoft.Kinect;
+using System.Windows.Media.Media3D;
+
+namespace Trakers.MainModule.Events
+{
+ public class RightHandTrackedListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : La main droite est entrée dans le champ.
+ */
+ public void showAndSend(object o, RightHandTrackedEventArgs e)
+ {
+ e.debug.showRightHandRect(true);
+ Point3D pt = new Point3D(e.handJoint.Position.X, e.handJoint.Position.Y, e.handJoint.Position.Z);
+ e.server.RightHandTracked(pt);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/SwipeEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/SwipeEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,45 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : SwipeEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : L'utilisateur a effectué un swipe.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.MainModule.Gestures;
+using Trakers.Debug;
+using Trakers.Communication;
+
+namespace Trakers.MainModule.Events
+{
+ public class SwipeEventArgs : MainEventArgs
+ {
+ //Direction du swipe.
+ public readonly SwipeDetector.Direction direction;
+
+ /*
+ * Constructeur : Il prend la direction du swipe.
+ */
+ public SwipeEventArgs(Server _server, DebugWindow _debug, SwipeDetector.Direction _direction) : base(_server, _debug)
+ {
+ direction = _direction;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/SwipeListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/SwipeListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,47 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : SwipeListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur a effectué un swipe.
+ * Il contient le code a être éxecuté au cas où cet événement survient.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Trakers.MainModule.Events
+{
+ public class SwipeListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : L'utilisateur a effectué un swipe.
+ */
+ public void showAndSend(object o, SwipeEventArgs e)
+ {
+ String code = "";
+ if (e.direction == Gestures.SwipeDetector.Direction.LEFT)
+ code = "SWIPE-LEFT";
+ else
+ code = "SWIPE-RIGHT";
+
+ e.debug.showGesture(code);
+ e.server.GesturePerformed(code);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/UserPositionEventArgs.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/UserPositionEventArgs.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,47 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : UserPositionEventArgs
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
+ * à l'événement : L'utilisateur se déplace dans la zone de détection.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.Communication;
+using Trakers.Debug;
+
+namespace Trakers.MainModule.Events
+{
+ public class UserPositionEventArgs : MainEventArgs
+ {
+ //Distance à Kinect.
+ public readonly float distance;
+ //Nombre d'images à afficher.
+ public readonly int imagesToShow;
+
+ /*
+ * Constructeur : Il prend la distance à Kinect.
+ */
+ public UserPositionEventArgs(Server _server, DebugWindow _debug, float _distance, int _imagesToShow) : base(_server, _debug)
+ {
+ distance = _distance;
+ imagesToShow = _imagesToShow;
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/Events/UserPositionListener.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/Events/UserPositionListener.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,41 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : MainModule/Events
+ * Classe : UserPositionListener
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur s'est déplacé dans la zone de
+ * détection.
+ * Il contient le code a être éxecuté au cas où cet événement survient.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Trakers.MainModule.Events
+{
+ public class UserPositionListener
+ {
+ /*
+ * Méthode appelée lorsque on a l'événement : L'utilisateur s'est déplacé dans la zone de détection.
+ */
+ public void showAndSend(object o, UserPositionEventArgs e)
+ {
+ e.debug.showDistance(e.distance);
+ e.server.GesturePerformed("MOSSHOW-" + e.imagesToShow);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/KinectMain.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/KinectMain.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,568 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking
+ * Classe : KinectMain
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Récupère les trames de données de la Kinect, les squelettes détectés via le SDK 1.0 de Microsoft.
+ * Interprète ces trames de façon à afficher le flux vidéo couleurs, et récupérer la distance de l'utilisateur et les
+ * noeuds de son squelette. Lance des événements lorsque la main gauche/droite entre dans/quitte le champ.
+ * Envoie des données au sous-module de debug de manière a afficher un retour visuel sur la position de l'utilisateur,
+ * son squelette, la détection de ses mains.
+ * Découpe l'interaction avec le middleware en différents modes.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Documents;
+using Microsoft.Kinect;
+using Trakers.Communication;
+using Trakers.MainModule.Events;
+using Trakers.MainModule.Gestures;
+using Trakers.MainModule.Search;
+using Trakers.Debug;
+using System.Windows;
+
+namespace Trakers.MainModule
+{
+ //Il s'agit des fonctions permettant d'appeler les fonctions des événements Main droite/gauche entre/quitte le champ.
+ public delegate void LeftHandTrackedHandler(object o, LeftHandTrackedEventArgs e);
+ public delegate void RightHandTrackedHandler(object o, RightHandTrackedEventArgs e);
+ public delegate void LeftHandQuitHandler(object o, LeftHandQuitEventArgs e);
+ public delegate void RightHandQuitHandler(object o, RightHandQuitEventArgs e);
+ //Il s'agit de la fonction permettant d'appeler les fonctions des événements Swipe left/right/up/down.
+ public delegate void SwipeHandler(object o, SwipeEventArgs e);
+ //Il s'agit de la fonction permettant d'appeler les fonctions des événements Push/Pull.
+ public delegate void PushHandler(object o, PushEventArgs e);
+ //Il s'agit de la fonction permettant d'appeler les fonctions des événements Jump.
+ public delegate void JumpHandler(object o, JumpEventArgs e);
+ //Il s'agit de la fonction permettant d'appeler les fonctions des événements de proximité.
+ public delegate void UserPositionHandler(object o, UserPositionEventArgs e);
+
+ public class KinectMain
+ {
+ //Fenêtre de debug.
+ private DebugWindow debug;
+ //Squelettes (Il y en a 6 par défaut).
+ private Skeleton[] skeletons;
+ //Caméra infrarouge (sensor) de la Kinect.
+ private KinectSensor kinectSensor;
+
+ //Détecteur de swipes.
+ private SwipeDetector swipeDetector;
+ //Détecteur de pushes.
+ private PushDetector pushDetector;
+ //Détecteur de jumps.
+ private JumpDetector jumpDetector;
+ //Détecteur de proximité.
+ private UserPositionDetector userPositionDetector;
+
+ //Serveur TUIO pour la connexion du Middleware vers le Front Atelier.
+ private Server server;
+
+ //Gestionnaire de modes.
+ private ModeManagement modeManagement;
+
+ //Les événements des mains pour la recherche.
+ public static event LeftHandTrackedHandler LeftHandTrackedEvent;
+ public static event RightHandTrackedHandler RightHandTrackedEvent;
+ public static event LeftHandQuitHandler LeftHandQuitEvent;
+ public static event RightHandQuitHandler RightHandQuitEvent;
+ //L'événement swipe.
+ public static event SwipeHandler SwipeEvent;
+ //L'événement push.
+ public static event PushHandler PushEvent;
+ //L'événement jump.
+ public static event JumpHandler JumpEvent;
+ //L'événement l'utilisateur se déplace dans la zone de détection.
+ public static event UserPositionHandler UserPositionEvent;
+
+ /*
+ * Initialisation de la classe principale.
+ * Affiche l'écran de debug dans lequel on voit la distance à la Kinect,
+ * les mains détectées et le squelette de l'utilisateur.
+ */
+ public KinectMain()
+ {
+ //On crée la fenêtre de debug.
+ debug = new DebugWindow();
+
+ //On crée les détecteurs de gestes.
+ swipeDetector = new SwipeDetector();
+ pushDetector = new PushDetector();
+ jumpDetector = new JumpDetector();
+ //On crée le détecteur de proximité.
+ userPositionDetector = new UserPositionDetector(debug.getMinDist(), debug.getMaxDist(), debug.getZeroPoint(), debug.getMinDistHands(), debug.getMaxDistHands());
+
+ //On écoute l'événement de clic sur le bouton on/off du debug.
+ //Car on lancera l'intitialisation/fermeture de la kinect.
+ debug.getSwitch().Click += new RoutedEventHandler(Switch_ClickInKinectMain);
+ debug.Loaded += new RoutedEventHandler(Window_LoadedInKinectMain);
+ debug.Closed += new EventHandler(Window_CloseInKinectMain);
+ debug.getQuitMenu().Click += new RoutedEventHandler(Quit_ClickInKinectMain);
+
+ //On affiche la fenêtre de debug.
+ try
+ {
+ debug.ShowDialog();
+ }
+ catch(Exception){
+ }
+ }
+
+ /*
+ * Initialisation du sensor de la Kinect.
+ */
+ public void KinectInitialization()
+ {
+ try
+ {
+ //On sélectionne la première kinect détectée.
+ kinectSensor = KinectSensor.KinectSensors.FirstOrDefault(s => s.Status == KinectStatus.Connected);
+ //La caméra couleur est activée avec une résolution 640x480 et un framerate de 30 FPS.
+ kinectSensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
+ //La caméra de profondeur est activée.
+ kinectSensor.DepthStream.Enable();
+ //Le squelette est activé.
+ kinectSensor.SkeletonStream.Enable();
+
+ //Quand le Middleware reçoit des trames de la Kinect, on va dans cette fonction.
+ kinectSensor.AllFramesReady += new EventHandler(AllFramesReady);
+
+ //On applique des paramètres d'ajustement pour le squelette.
+ TransformSmoothParameters parameters = new TransformSmoothParameters();
+ parameters.Smoothing = 0.2f;
+ parameters.Correction = 0.8f;
+ parameters.Prediction = 0.0f;
+ parameters.JitterRadius = 0.5f;
+ parameters.MaxDeviationRadius = 0.5f;
+ kinectSensor.SkeletonStream.Enable(parameters);
+ //On démarre la Kinect.
+ kinectSensor.Start();
+
+ }
+ catch (System.Exception)
+ {
+ debug.ShowException("KinectNotConnected");
+ }
+
+ //Pour les événements main gauche/droite entre dans/quitte le champ, on a 4 listeners.
+ //Fonction appelée lorsque la main gauche entre dans le champ de recherche.
+ LeftHandTrackedListener leftHandTrackedListener = new LeftHandTrackedListener();
+ LeftHandTrackedEvent += new LeftHandTrackedHandler(leftHandTrackedListener.showAndSend);
+
+ //Fonction appelée lorsque la main droite entre dans le champ de recherche.
+ RightHandTrackedListener rightHandTrackedListener = new RightHandTrackedListener();
+ RightHandTrackedEvent += new RightHandTrackedHandler(rightHandTrackedListener.showAndSend);
+
+ //Fonction appelée lorsque la main gauche quitte le champ de recherche.
+ LeftHandQuitListener leftHandQuitListener = new LeftHandQuitListener();
+ LeftHandQuitEvent += new LeftHandQuitHandler(leftHandQuitListener.showAndSend);
+
+ //Fonction appelée lorsque la main droite quitte le champ de recherche.
+ RightHandQuitListener rightHandQuitListener = new RightHandQuitListener();
+ RightHandQuitEvent += new RightHandQuitHandler(rightHandQuitListener.showAndSend);
+
+ //Fonction appelée lorsque l'utilisateur effectue un Swipe right/left/up/down.
+ SwipeListener swipeListener = new SwipeListener();
+ SwipeEvent += new SwipeHandler(swipeListener.showAndSend);
+
+ //Fonction appelée lorsque l'utilisateur effectue un Push/Pull.
+ PushListener pushListener = new PushListener();
+ PushEvent += new PushHandler(pushListener.showAndSend);
+
+ //Fonction appelée lorsque l'utilisateur effectue un Jump.
+ JumpListener jumpListener = new JumpListener();
+ JumpEvent += new JumpHandler(jumpListener.showAndSend);
+
+ //Fonction appelée lorsque l'utilisateur se déplace dans la zone de détection.
+ UserPositionListener userPositionListener = new UserPositionListener();
+ UserPositionEvent += new UserPositionHandler(userPositionListener.showAndSend);
+
+ //On connecte le serveur à l'adresse locale sur le port 80.
+ try
+ {
+ server = new Server(debug.getConnexionHost(), debug.getConnexionPort(), debug.getTimerElapsing());
+ //On crée le gestionnaire de modes.
+ modeManagement = new ModeManagement(server, debug, this);
+ modeManagement.DetectProximityBasedModes(0);
+ }
+ catch (Exception)
+ {
+ debug.ShowException("serverCantStart");
+ }
+ }
+
+ /*
+ * Bouton ON/OFF du debug écouté dans KinectMain.
+ */
+ public void Switch_ClickInKinectMain(object sender, RoutedEventArgs e)
+ {
+ Console.Out.WriteLine(debug.getOn());
+ //Si la kinect est allumée.
+ if (debug.getOn())
+ {
+ //On initialise la Kinect.
+ KinectInitialization();
+ }
+ else
+ {
+ //On éteint la Kinect.
+ KinectClose();
+ }
+ }
+
+ /*
+ * Méthode associée à l'événement : Quitter via le menu écoutée dans KinectMain.
+ */
+ private void Quit_ClickInKinectMain(object sender, RoutedEventArgs e)
+ {
+ KinectClose();
+ debug.Quit_Click(sender, e);
+ }
+
+ /*
+ * Permet d'initialiser la Kinect dès que la fenêtre est lancée écoutée dans KinectMain.
+ */
+ private void Window_LoadedInKinectMain(object sender, RoutedEventArgs e)
+ {
+ KinectInitialization();
+ }
+
+ /*
+ * Fermeture du debug écouté dans KinectMain.
+ */
+ private void Window_CloseInKinectMain(object sender, EventArgs e)
+ {
+ //On éteint la Kinect.
+ KinectClose();
+ debug.Window_Closed(sender, e);
+ }
+
+ /*
+ * Fermeture du sensor de la Kinect.
+ */
+ public void KinectClose()
+ {
+ try
+ {
+ //On stoppe la Kinect.
+ kinectSensor.Stop();
+ //On met a zero l'image d'affichage et le serveur.
+ debug.ShutDownInterface();
+ }
+ catch (System.Exception)
+ {
+ debug.ShowException("KinectNotConnected");
+ }
+ }
+
+ /*
+ * Récupère le premier squelette.
+ */
+ Skeleton GetFirstSkeleton(object sender, AllFramesReadyEventArgs e)
+ {
+ using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame())
+ {
+ if (skeletonFrameData == null)
+ return null;
+ if ((skeletons == null) || (skeletons.Length != skeletonFrameData.SkeletonArrayLength))
+ skeletons = new Skeleton[skeletonFrameData.SkeletonArrayLength];
+ skeletonFrameData.CopySkeletonDataTo(skeletons);
+
+ //On obtient le premier skelette.
+ Skeleton first = (from s in skeletons where s.TrackingState == SkeletonTrackingState.Tracked select s).FirstOrDefault();
+
+ return first;
+ }
+ }
+
+ /*
+ * Récupère le squelette le plus proche.
+ */
+ Skeleton GetNearestSkeleton(object sender, AllFramesReadyEventArgs e)
+ {
+ using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame())
+ {
+ if (skeletonFrameData == null)
+ return null;
+ if ((skeletons == null) || (skeletons.Length != skeletonFrameData.SkeletonArrayLength))
+ skeletons = new Skeleton[skeletonFrameData.SkeletonArrayLength];
+ skeletonFrameData.CopySkeletonDataTo(skeletons);
+
+ Skeleton s;
+ float minDist = (float)-1.0;
+ int minID = 0;
+
+ //Pour tous les squelettes.
+ for(int i = 0 ; i < skeletons.Count() ; i++)
+ {
+ s = skeletons.ElementAt(i);
+ //S'il est tracké.
+ if(s.TrackingState == SkeletonTrackingState.Tracked)
+ {
+ //On récupère sa position et on obtient la distance min et l'ID du squelette qui est à la distance min.
+ float dist = skeletons.ElementAt(i).Position.Z;
+ if (minDist == -1)
+ {
+ minDist = dist;
+ minID = i;
+ }
+ else if(minDist > dist)
+ {
+ minDist = dist;
+ minID = i;
+ }
+ }
+ }
+
+ //On renvoie le skelette le plus proche.
+ return skeletons.ElementAt(minID);
+ }
+ }
+
+ /*
+ * Récupère le squelette le plus proche.
+ */
+ private void AllFramesReady(object sender, AllFramesReadyEventArgs e)
+ {
+ //On ne calcule rien si la fenêtre de debug se ferme.
+ if (debug.isClosing())
+ return;
+
+ //On écoute le debug pour savoir si les paramètres ont été modifiés.
+
+
+ //On met à jour la vidéo de debug.
+ debug.RefreshVideo(e);
+ //On récupère le premier squelette tracké.
+ //Skeleton first = GetFirstSkeleton(e);
+ //On récupère le plus proche squelette tracké.
+ Skeleton first = GetNearestSkeleton(sender, e);
+ //Si celui-ci n’est pas nul
+ if (first == null)
+ return;
+
+ //Si ce squelette est tracké (donc suivi et reconnu par la camera)
+ if (first.TrackingState == SkeletonTrackingState.Tracked)
+ {
+ //Ensemble des noeuds du squelette.
+ Joint hipCenter = getJoint(first, JointType.HipCenter), spine = getJoint(first, JointType.Spine), shoulderCenter = getJoint(first, JointType.ShoulderCenter), head = getJoint(first, JointType.Head);
+ Joint shoulderLeft = getJoint(first, JointType.ShoulderLeft), elbowLeft = getJoint(first, JointType.ElbowLeft), wristLeft = getJoint(first, JointType.WristLeft), handLeft = getJoint(first, JointType.HandLeft);
+ Joint shoulderRight = getJoint(first, JointType.ShoulderRight), elbowRight = getJoint(first, JointType.ElbowRight), wristRight = getJoint(first, JointType.WristRight), handRight = getJoint(first, JointType.HandRight);
+ Joint hipLeft = getJoint(first, JointType.HipLeft), kneeLeft = getJoint(first, JointType.KneeLeft), ankleLeft = getJoint(first, JointType.AnkleLeft), footLeft = getJoint(first, JointType.FootLeft);
+ Joint hipRight = getJoint(first, JointType.HipRight), kneeRight = getJoint(first, JointType.KneeRight), ankleRight = getJoint(first, JointType.AnkleRight), footRight = getJoint(first, JointType.FootRight);
+
+ //On construit l'historique des postures.
+ List joints = new List();
+ joints.Clear();
+ joints.Insert((int)JointType.HipCenter, hipCenter);
+ joints.Insert((int)JointType.Spine, spine);
+ joints.Insert((int)JointType.ShoulderCenter, shoulderCenter);
+ joints.Insert((int)JointType.Head, head);
+ joints.Insert((int)JointType.ShoulderLeft, shoulderLeft);
+ joints.Insert((int)JointType.ElbowLeft, elbowLeft);
+ joints.Insert((int)JointType.WristLeft, wristLeft);
+ joints.Insert((int)JointType.HandLeft, handLeft);
+ joints.Insert((int)JointType.ShoulderRight, shoulderRight);
+ joints.Insert((int)JointType.ElbowRight, elbowRight);
+ joints.Insert((int)JointType.WristRight, wristRight);
+ joints.Insert((int)JointType.HandRight, handRight);
+ joints.Insert((int)JointType.HipLeft, hipLeft);
+ joints.Insert((int)JointType.KneeLeft, kneeLeft);
+ joints.Insert((int)JointType.AnkleLeft, ankleLeft);
+ joints.Insert((int)JointType.FootLeft, footLeft);
+ joints.Insert((int)JointType.HipRight, hipRight);
+ joints.Insert((int)JointType.KneeRight, kneeRight);
+ joints.Insert((int)JointType.AnkleRight, ankleRight);
+ joints.Insert((int)JointType.FootRight, footRight);
+ GestureDetector.UpdateSkeletonHistory(joints);
+
+ //Si la main gauche est dans le champ, on lance l'événement approprié.
+ if (handLeft.Position.Z < debug.getMaxDistHands() && handLeft.Position.Z > debug.getMinDistHands())
+ {
+ LeftHandTrackedEventArgs leftHandTrackedEvent = new LeftHandTrackedEventArgs(server, debug, handLeft, handLeft.Position.Z);
+ OnLeftHandTrackedEvent(leftHandTrackedEvent);
+ }
+ //Si la main gauche quitte le champ, on lance l'événement approprié.
+ else
+ {
+ LeftHandQuitEventArgs leftHandQuitEvent = new LeftHandQuitEventArgs(server, debug);
+ OnLeftHandQuitEvent(leftHandQuitEvent);
+ }
+ //Si la main droite est dans le champ, on lance l'événement approprié.
+ if (handRight.Position.Z < debug.getMaxDistHands() && handRight.Position.Z > debug.getMinDistHands())
+ {
+ RightHandTrackedEventArgs rightHandTrackedEvent = new RightHandTrackedEventArgs(server, debug, handRight, handRight.Position.Z);
+ OnRightHandTrackedEvent(rightHandTrackedEvent);
+ }
+ //Si la main droite quitte le champ, on lance l'événement approprié.
+ else
+ {
+ RightHandQuitEventArgs rightHandQuitEvent = new RightHandQuitEventArgs(server, debug);
+ OnRightHandQuitEvent(rightHandQuitEvent);
+ }
+
+ //Si l'utilisateur effectue un swipe left.
+ if (swipeDetector.CheckForSwipeLeft())
+ {
+ SwipeEventArgs swipeEvent = new SwipeEventArgs(server, debug, SwipeDetector.Direction.LEFT);
+ OnSwipeEvent(swipeEvent);
+ }
+
+ //Si l'utilisateur effectue un swipe right.
+ if (swipeDetector.CheckForSwipeRight())
+ {
+ SwipeEventArgs swipeEvent = new SwipeEventArgs(server, debug, SwipeDetector.Direction.RIGHT);
+ OnSwipeEvent(swipeEvent);
+ }
+
+ //Enum sur la main qui effectue le geste.
+ PushDetector.Hand handPush;
+ //Si l'utilisateur effectue un push.
+ if ((handPush = pushDetector.CheckForPush()) != PushDetector.Hand.NONE)
+ {
+ PushEventArgs pushEvent = new PushEventArgs(server, debug, PushDetector.Direction.PUSH, handPush);
+ OnPushEvent(pushEvent);
+ }
+ //Si l'utilisateur effectue un pull.
+ if ((handPush = pushDetector.CheckForPull()) != PushDetector.Hand.NONE)
+ {
+ PushEventArgs pushEvent = new PushEventArgs(server, debug, PushDetector.Direction.PULL, handPush);
+ OnPushEvent(pushEvent);
+ }
+
+ //Si l'utilisateur se déplace dans la zone de détection.
+ //On traite le problème en plusieurs limites, on discrétise la zone.
+ if (first.TrackingState == SkeletonTrackingState.Tracked)
+ {
+ float proximity = userPositionDetector.CalcProximity(first.Position.Z);
+ int numberOfImages = userPositionDetector.ImagesToShow(proximity, debug.getImagesToShow());
+
+ modeManagement.DetectProximityBasedModes(proximity);
+
+ if (proximity > 0f)
+ {
+ UserPositionEventArgs userPositionEvent = new UserPositionEventArgs(server, debug, proximity, numberOfImages);
+ OnUserPositionEvent(userPositionEvent);
+ }
+ else if(proximity < 10f)
+ {
+ debug.hideSkeleton();
+ modeManagement.DetectProximityBasedModes(0);
+ LeftHandQuitEventArgs leftHandQuitEvent = new LeftHandQuitEventArgs(server, debug);
+ OnLeftHandQuitEvent(leftHandQuitEvent);
+ RightHandQuitEventArgs rightHandQuitEvent = new RightHandQuitEventArgs(server, debug);
+ OnRightHandQuitEvent(rightHandQuitEvent);
+ }
+ }
+
+ //Dessine le squelette dans le debug.
+ debug.drawJoints(first.Joints, first);
+ debug.showSkeleton(hipCenter, spine, shoulderCenter, head, shoulderLeft, elbowLeft, wristLeft, handLeft, shoulderRight, elbowRight, wristRight, handRight, hipLeft, kneeLeft, ankleLeft, footLeft, hipRight, kneeRight, ankleRight, footRight);
+ }
+ else
+ {
+ debug.hideSkeleton();
+ modeManagement.DetectProximityBasedModes(0);
+ LeftHandQuitEventArgs leftHandQuitEvent = new LeftHandQuitEventArgs(server, debug);
+ OnLeftHandQuitEvent(leftHandQuitEvent);
+ RightHandQuitEventArgs rightHandQuitEvent = new RightHandQuitEventArgs(server, debug);
+ OnRightHandQuitEvent(rightHandQuitEvent);
+ }
+ }
+
+ /*
+ * Change l'échelle des coordonnées d'un noeud pour qu'en X et Y il corresponde à la résolution et en Z à la distance à la Kinect.
+ */
+ public Joint getJoint(Skeleton ske, JointType jointID)
+ {
+ return Coding4Fun.Kinect.Wpf.SkeletalExtensions.ScaleTo(ske.Joints[jointID], 600, 400, 0.75f, 0.75f);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand la main gauche entre dans le champ.
+ */
+ public static void OnLeftHandTrackedEvent(LeftHandTrackedEventArgs e)
+ {
+ if (LeftHandTrackedEvent != null)
+ LeftHandTrackedEvent(new object(), e);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand la main droite entre dans le champ.
+ */
+ public static void OnRightHandTrackedEvent(RightHandTrackedEventArgs e)
+ {
+ if (RightHandTrackedEvent != null)
+ RightHandTrackedEvent(new object(), e);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand la main gauche quitte le champ.
+ */
+ public static void OnLeftHandQuitEvent(LeftHandQuitEventArgs e)
+ {
+ if (LeftHandQuitEvent != null)
+ LeftHandQuitEvent(new object(), e);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand la main droite quitte le champ.
+ */
+ public static void OnRightHandQuitEvent(RightHandQuitEventArgs e)
+ {
+ if (RightHandQuitEvent != null)
+ RightHandQuitEvent(new object(), e);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur effectue un swipe right.
+ */
+ public static void OnSwipeEvent(SwipeEventArgs e)
+ {
+ if (SwipeEvent != null)
+ SwipeEvent(new object(), e);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur effectue un push.
+ */
+ public static void OnPushEvent(PushEventArgs e)
+ {
+ if (PushEvent != null)
+ PushEvent(new object(), e);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur effectue un saut.
+ */
+ public static void OnJumpEvent(JumpEventArgs e)
+ {
+ if (JumpEvent != null)
+ JumpEvent(new object(), e);
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur se déplace
+ * dans la zone de détection.
+ */
+ public static void OnUserPositionEvent(UserPositionEventArgs e)
+ {
+ if (UserPositionEvent != null)
+ UserPositionEvent(new object(), e);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/MainModule/ModeManagement.cs
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/middleware/src/MainModule/ModeManagement.cs Mon Apr 02 16:30:56 2012 +0200
@@ -0,0 +1,162 @@
+/*
+* This file is part of the TraKERS\Middleware package.
+*
+* (c) IRI
+*
+* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
+* file that was distributed with this source code.
+*/
+
+/*
+ * Projet : TraKERS
+ * Module : MIDDLEWARE
+ * Sous-Module : Tracking
+ * Classe : ModeManagement
+ *
+ * Auteur : alexandre.bastien@iri.centrepompidou.fr
+ *
+ * Fonctionnalités : Permet de gérer les différents modes qui découpent l'interaction avec le middleware.
+ * Découpe l'interaction avec le middleware en différents modes.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Trakers.Communication;
+using Trakers.MainModule.Events;
+using Trakers.Debug;
+
+namespace Trakers.MainModule
+{
+ public class ModeManagement
+ {
+ //Il s'agit de la fonctoin permettant de notifier le serveur en cas de changement de mode.
+ public delegate void ModChangeHandler(object o, ModChangeEventArgs e);
+ //L'événement on change de mode.
+ public static event ModChangeHandler ModChangeEvent;
+
+ //Accès au module d'interaction principal.
+ private KinectMain kinectMain;
+ //Accès au debug.
+ private DebugWindow debug;
+ //Accès au serveur.
+ private Server server;
+ //La liste des modes.
+ public enum Mode {NO_USER, USER_INCOMING, MOSAIC, FILTER, VIDEO, TIMELINE, SEARCH};
+ //Mode actuel.
+ private Mode currentMode;
+
+ /*
+ * Constructeur qui prend en paramètres le module principal et le serveur.
+ */
+ public ModeManagement(Server _server, DebugWindow _debug, KinectMain _kinectMain)
+ {
+ server = _server;
+ debug = _debug;
+ kinectMain = _kinectMain;
+ server = _server;
+ currentMode = Mode.NO_USER;
+
+ //Fonction appelée lorsqu'on change de mode.
+ ModChangeListener modChangeListener = new ModChangeListener();
+ ModChangeEvent += new ModChangeHandler(modChangeListener.showAndSend);
+ }
+
+ /*
+ * Détecte tout changement de mode en se basant sur la proximité de l'utilisateur.
+ */
+ public void DetectProximityBasedModes(float proximity)
+ {
+ //Si l'utilisateur se déplace dans la zone de détection.
+ //On traite le problème en plusieurs limites, on discrétise la zone.
+ //On considère qu'il n'y a pas d'utilisateur si sa proximité est trop faible.
+ if (proximity < 10f && currentMode != Mode.NO_USER)
+ {
+ currentMode = Mode.NO_USER;
+ ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(server, debug, "NO_USER");
+ OnModChangeEvent(modChangeEvent);
+ }
+ //S'il n'est pas encore au point d'interaction maximale, on considère qu'il est en chemin.
+ else if (proximity >= 10f && proximity < 100f && currentMode != Mode.USER_INCOMING)
+ {
+ currentMode = Mode.USER_INCOMING;
+ ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(server, debug, "USER_INCOMING");
+ OnModChangeEvent(modChangeEvent);
+ }
+ //S'il est arrivé au point, il a la mosaïque complète.
+ else if(proximity == 100f && currentMode != Mode.MOSAIC)
+ {
+ currentMode = Mode.MOSAIC;
+ ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(server, debug, "MOSAIC");
+ OnModChangeEvent(modChangeEvent);
+ }
+ }
+
+ /*
+ * Détecte si l'utilisateur veut filtrer la mosaïque.
+ */
+ public void DetectFilterMode()
+ {
+ //Ne fonctionne que si on se trouve dans la mosaïque.
+ if (currentMode == Mode.MOSAIC)
+ {
+ currentMode = Mode.FILTER;
+ ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(server, debug, "FILTER");
+ OnModChangeEvent(modChangeEvent);
+ }
+ }
+
+ /*
+ * Détecte si l'utilisateur veut entrer dans une vidéo.
+ */
+ public void DetectVideoMode()
+ {
+ //Si on vient de la mosaïque, d'un filtrage, de la timeline ou d'une recherche, on peut entrer.
+ if (currentMode == Mode.MOSAIC || currentMode == Mode.FILTER ||
+ currentMode == Mode.TIMELINE || currentMode == Mode.SEARCH)
+ {
+ currentMode = Mode.VIDEO;
+ ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(server, debug, "VIDEO");
+ OnModChangeEvent(modChangeEvent);
+ }
+ }
+
+ /*
+ * Détecte si l'utilisateur veut entrer dans la timeline.
+ */
+ public void DetectTimeLineMode()
+ {
+ //Si on est dans une vidéo, on peut entrer.
+ if (currentMode == Mode.VIDEO)
+ {
+ currentMode = Mode.TIMELINE;
+ ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(server, debug, "TIMELINE");
+ OnModChangeEvent(modChangeEvent);
+ }
+ }
+
+ /*
+ * Détecte si l'utilisateur veut effectuer une recherche dans cette vidéo.
+ */
+ public void DetectSearchMode()
+ {
+ //Si on est dans une vidéo, on peut entrer.
+ if (currentMode == Mode.VIDEO)
+ {
+ currentMode = Mode.SEARCH;
+ ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(server, debug, "SEARCH");
+ OnModChangeEvent(modChangeEvent);
+ }
+ }
+
+ /*
+ * Initialise l'événement et fait appel aux fonctions du listener quand on change de mode.
+ */
+ public static void OnModChangeEvent(ModChangeEventArgs e)
+ {
+ if (ModChangeEvent != null)
+ ModChangeEvent(new object(), e);
+ }
+ }
+}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Properties/AssemblyInfo.cs
--- a/middleware/src/Properties/AssemblyInfo.cs Fri Mar 30 11:14:14 2012 +0200
+++ b/middleware/src/Properties/AssemblyInfo.cs Mon Apr 02 16:30:56 2012 +0200
@@ -7,11 +7,11 @@
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
-[assembly: AssemblyTitle("Mid-Dist")]
+[assembly: AssemblyTitle("MainModule")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Mid-Dist")]
+[assembly: AssemblyProduct("MainModule")]
[assembly: AssemblyCopyright("Copyright © 2012")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/JumpEventArgs.cs
--- a/middleware/src/Tracking/Events/JumpEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : JumpEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : L'utilisateur a sauté.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Trakers.Communication;
-
-namespace Trakers.Tracking.Events
-{
- public class JumpEventArgs : EventArgs
- {
- //Fenêtre de debug.
- public readonly Debug.DebugWindow debug;
- //Serveur TUIO.
- public readonly Server server;
-
- /*
- * Constructeur : Il prend l'affichage de debug et le serveur TUIO.
- */
- public JumpEventArgs(Debug.DebugWindow _debug, Server _server)
- {
- debug = _debug;
- server = _server;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/JumpListener.cs
--- a/middleware/src/Tracking/Events/JumpListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : JumpListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur a sauté.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Events
-{
- public class JumpListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : L'utilisateur a sauté.
- */
- public void ShowOnScreen(object o, JumpEventArgs e)
- {
- //On l'indique dans le debug.
- //e.debug.showSwipe(e);
- //e.debug.ExceptionLbl.Content = "SWIPE";
- //On notifie le serveur TUIO.
- //e.server.LeftHandQuit(o, e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/LeftHandQuitEventArgs.cs
--- a/middleware/src/Tracking/Events/LeftHandQuitEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : LeftHandQuitEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : La main gauche est sortie du champ.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-using Trakers.Communication;
-
-namespace Trakers.Tracking.Events
-{
- public class LeftHandQuitEventArgs : EventArgs
- {
- public readonly Debug.DebugWindow debug;
- public readonly Server server;
-
- /*
- * Constructeur : Il prend l'affichage de debug et le serveur TUIO.
- */
- public LeftHandQuitEventArgs(Debug.DebugWindow _debug, Server _server)
- {
- debug = _debug;
- server = _server;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/LeftHandQuitListener.cs
--- a/middleware/src/Tracking/Events/LeftHandQuitListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : LeftHandQuitListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : La main gauche est sortie du champ.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-
-namespace Trakers.Tracking.Events
-{
- public class LeftHandQuitListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : La main gauche est sortie du champ.
- */
- public void ShowOnScreen(object o, LeftHandQuitEventArgs e)
- {
- //On l'indique dans le debug.
- e.debug.showLeftHandRect(false);
- e.debug.showLeftHandCoord("");
- e.debug.ExceptionLbl.Background = System.Windows.Media.Brushes.Transparent;
- //On notifie le serveur TUIO.
- e.server.LeftHandQuit(o, e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/LeftHandTrackedEventArgs.cs
--- a/middleware/src/Tracking/Events/LeftHandTrackedEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : LeftHandTrackedEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : La main gauche est entrée dans le champ.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-using Trakers.Communication;
-
-namespace Trakers.Tracking.Events
-{
- public class LeftHandTrackedEventArgs : EventArgs
- {
- public readonly Joint handJoint;
- public readonly float position;
- public readonly Debug.DebugWindow debug;
- public readonly Server server;
-
- /*
- * Constructeur : Il prend le noeud de la main, sa position, l'affichage de debug et le serveur TUIO.
- */
- public LeftHandTrackedEventArgs(Joint joint, float pos, Debug.DebugWindow _debug, Server _server)
- {
- handJoint = joint;
- position = pos;
- debug = _debug;
- server = _server;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/LeftHandTrackedListener.cs
--- a/middleware/src/Tracking/Events/LeftHandTrackedListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : LeftHandTrackedListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : La main gauche est entrée dans le champ.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-
-namespace Trakers.Tracking.Events
-{
- public class LeftHandTrackedListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : La main gauche est entrée dans le champ.
- */
- public void ShowOnScreen(object o, LeftHandTrackedEventArgs e)
- {
- Joint handJoint = e.handJoint;
- //On l'indique dans le debug.
- e.debug.showLeftHandRect(true);
- e.debug.showLeftHandCoord("(" + handJoint.Position.X + ";" + handJoint.Position.Y + ")");
- //On notifie le serveur TUIO.
- e.server.LeftHandTracked(o, e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/ModChangeEventArgs.cs
--- a/middleware/src/Tracking/Events/ModChangeEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : ModChangeEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : On entre dans un nouveau mode.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Trakers.Communication;
-
-namespace Trakers.Tracking.Events
-{
- public class ModChangeEventArgs : EventArgs
- {
- //Fenêtre de debug.
- public readonly Debug.DebugWindow debug;
- //Serveur TUIO.
- public readonly Server server;
- //Code du mode.
- public readonly String code;
-
- /*
- * Constructeur : Il prend l'affichage de debug et le serveur TUIO.
- */
- public ModChangeEventArgs(Debug.DebugWindow _debug, Server _server, String _code)
- {
- debug = _debug;
- server = _server;
- code = _code;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/ModChangeListener.cs
--- a/middleware/src/Tracking/Events/ModChangeListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : ModChangeListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : On change de mode.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Events
-{
- public class ModChangeListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : On change de mode.
- */
- public void ShowOnScreen(object o, ModChangeEventArgs e)
- {
- //On notifie le serveur TUIO.
- e.server.ModeNotification(e.code);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/PushEventArgs.cs
--- a/middleware/src/Tracking/Events/PushEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,53 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : PushEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : L'utilisateur a effectué un push.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Trakers.Communication;
-using Trakers.Tracking.Gestures;
-
-namespace Trakers.Tracking.Events
-{
- public class PushEventArgs : EventArgs
- {
- //Fenêtre de debug.
- public readonly Debug.DebugWindow debug;
- //Serveur TUIO.
- public readonly Server server;
- //Direction du push.
- public readonly PushDetector.Direction direction;
- //Main ayant réalisé le push.
- public readonly PushDetector.Hand hand;
-
- /*
- * Constructeur : Il prend l'affichage de debug, le serveur TUIO et la direction du swipe.
- */
- public PushEventArgs(Debug.DebugWindow _debug, Server _server, PushDetector.Direction _direction, PushDetector.Hand _hand)
- {
- debug = _debug;
- server = _server;
- direction = _direction;
- hand = _hand;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/PushListener.cs
--- a/middleware/src/Tracking/Events/PushListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,63 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : PushListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur a effectué un push.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Events
-{
- public class PushListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : L'utilisateur a effectué un push.
- */
- public void ShowOnScreen(object o, PushEventArgs e)
- {
- //On l'indique dans le debug.
- //Lorsqu'il s'agit d'un push/pull de la main gauche/droite/deux deux on envoie le message
- //correspondant.
- if (e.direction == Gestures.PushDetector.Direction.PUSH)
- {
- if (e.hand == Gestures.PushDetector.Hand.RIGHT)
- e.debug.showGesture("PUSH-RIGHT");
- else if (e.hand == Gestures.PushDetector.Hand.LEFT)
- e.debug.showGesture("PUSH-LEFT");
- else
- e.debug.showGesture("PUSH-BOTH");
- }
- else
- {
- if (e.hand == Gestures.PushDetector.Hand.RIGHT)
- e.debug.showGesture("PULL-RIGHT");
- else if (e.hand == Gestures.PushDetector.Hand.LEFT)
- e.debug.showGesture("PULL-LEFT");
- else
- e.debug.showGesture("PULL-BOTH");
- }
- //On notifie le serveur TUIO.
- e.server.Push(o, e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/RightHandQuitEventArgs.cs
--- a/middleware/src/Tracking/Events/RightHandQuitEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : RightHandQuitEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : La main droite est sortie du champ.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-using Trakers.Communication;
-
-namespace Trakers.Tracking.Events
-{
- public class RightHandQuitEventArgs : EventArgs
- {
- public readonly Debug.DebugWindow debug;
- public readonly Server server;
-
- /*
- * Constructeur : Il prend l'affichage de debug et le serveur TUIO.
- */
- public RightHandQuitEventArgs(Debug.DebugWindow _debug, Server _server)
- {
- debug = _debug;
- server = _server;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/RightHandQuitListener.cs
--- a/middleware/src/Tracking/Events/RightHandQuitListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : RightHandQuitListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : La main droite est sortie du champ.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-
-namespace Trakers.Tracking.Events
-{
- public class RightHandQuitListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : La main droite est sortie du champ.
- */
- public void ShowOnScreen(object o, RightHandQuitEventArgs e)
- {
- //On l'indique dans le debug.
- e.debug.showRightHandRect(false);
- e.debug.showRightHandCoord("");
- //On notifie le serveur TUIO.
- e.server.RightHandQuit(o, e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/RightHandTrackedEventArgs.cs
--- a/middleware/src/Tracking/Events/RightHandTrackedEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : RightHandTrackedEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : La main droite est entrée dans le champ.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-using Trakers.Communication;
-
-namespace Trakers.Tracking.Events
-{
- public class RightHandTrackedEventArgs : EventArgs
- {
- public readonly Joint handJoint;
- public readonly float position;
- public readonly Debug.DebugWindow debug;
- public readonly Server server;
-
- /*
- * Constructeur : Il prend le noeud de la main, sa position, l'affichage de debug et le serveur TUIO.
- */
- public RightHandTrackedEventArgs(Joint joint, float pos, Debug.DebugWindow _debug, Server _server)
- {
- handJoint = joint;
- position = pos;
- debug = _debug;
- server = _server;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/RightHandTrackedListener.cs
--- a/middleware/src/Tracking/Events/RightHandTrackedListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : RightHandTrackedListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : La main droite est entrée dans le champ.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-
-namespace Trakers.Tracking.Events
-{
- public class RightHandTrackedListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : La main droite est entrée dans le champ.
- */
- public void ShowOnScreen(object o, RightHandTrackedEventArgs e)
- {
- Joint handJoint = e.handJoint;
- //On l'indique dans le debug.
- e.debug.showRightHandRect(true);
- e.debug.showRightHandCoord("(" + handJoint.Position.X + ";" + handJoint.Position.Y + ")");
- //On notifie le serveur TUIO.
- e.server.RightHandTracked(o, e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/SwipeEventArgs.cs
--- a/middleware/src/Tracking/Events/SwipeEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,50 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : SwipeEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : L'utilisateur a effectué un swipe.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Trakers.Communication;
-using Trakers.Tracking.Gestures;
-
-namespace Trakers.Tracking.Events
-{
- public class SwipeEventArgs : EventArgs
- {
- //Fenêtre de debug.
- public readonly Debug.DebugWindow debug;
- //Serveur TUIO.
- public readonly Server server;
- //Direction du swipe.
- public readonly SwipeDetector.Direction direction;
-
- /*
- * Constructeur : Il prend l'affichage de debug, le serveur TUIO et la direction du swipe.
- */
- public SwipeEventArgs(Debug.DebugWindow _debug, Server _server, SwipeDetector.Direction _direction)
- {
- debug = _debug;
- server = _server;
- direction = _direction;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/SwipeListener.cs
--- a/middleware/src/Tracking/Events/SwipeListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : SwipeListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur a effectué un swipe.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-
-namespace Trakers.Tracking.Events
-{
- public class SwipeListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : L'utilisateur a effectué un swipe.
- */
- public void ShowOnScreen(object o, SwipeEventArgs e)
- {
- //On l'indique dans le debug.
- if (e.direction == Gestures.SwipeDetector.Direction.LEFT)
- e.debug.showGesture("SWIPE-LEFT");
- else
- e.debug.showGesture("SWIPE-RIGHT");
- //e.debug.ExceptionLbl.Content = "SWIPE";
- //On notifie le serveur TUIO.
- e.server.Swipe(o, e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/UserPositionEventArgs.cs
--- a/middleware/src/Tracking/Events/UserPositionEventArgs.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,52 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : UserPositionEventArgs
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Cette classe contient les membres utilisés lors de l'appel au listener correspondant
- * à l'événement : L'utilisateur se déplace dans la zone de détection.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Trakers.Communication;
-
-namespace Trakers.Tracking.Events
-{
- public class UserPositionEventArgs : EventArgs
- {
- //Fenêtre de debug.
- public readonly Debug.DebugWindow debug;
- //Serveur TUIO.
- public readonly Server server;
- //Distance à Kinect.
- public readonly float distance;
- //Nombre d'images à afficher.
- public readonly int imagesToShow;
-
- /*
- * Constructeur : Il prend l'affichage de debug, le serveur TUIO et la distance à Kinect.
- */
- public UserPositionEventArgs(Debug.DebugWindow _debug, Server _server, float _distance, int _imagesToShow)
- {
- debug = _debug;
- server = _server;
- distance = _distance;
- imagesToShow = _imagesToShow;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Events/UserPositionListener.cs
--- a/middleware/src/Tracking/Events/UserPositionListener.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Events
- * Classe : UserPositionListener
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Ce listener écoute l'événement du type : L'utilisateur s'est déplacé dans la zone de
- * détection.
- * Il contient le code a être éxecuté au cas où cet événement survient, à savoir :
- * - On affiche un visuel dans le debug.
- * - On notifie le serveur TUIO.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Events
-{
- public class UserPositionListener
- {
- /*
- * Méthode appelée lorsque on a l'événement : L'utilisateur s'est déplacé dans la zone de détection.
- */
- public void ShowOnScreen(object o, UserPositionEventArgs e)
- {
- //On l'indique dans le debug.
- e.debug.showDistance(e.distance);
- //On notifie le serveur TUIO.
- if(e.distance > 10f && e.distance < 100f)
- e.server.ModeNotification("MOSSHOW-" + e.imagesToShow);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Gestures/GestureDetector.cs
--- a/middleware/src/Tracking/Gestures/GestureDetector.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,154 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Gestures
- * Classe : GestureDetector
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Reçoit les positions des noeuds envoyés par la classe de manipulation de la Kinect
- * et les stocke dans un historique.
- * Contient également des variables propres à toute gesture : distance de référence, point de départ,
- * durée de la gesture, FPS et nombre de frames à traiter.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-using System.Drawing;
-
-namespace Trakers.Tracking.Gestures
-{
- public class GestureDetector
- {
- //Historique des positions du squelette.
- protected static List> history = new List>();
- //protected JointCollection previousSkeleton;
-
- //Voici les ID des noeuds d'un squelette : variables magiques en attente de factorisation.
- /*protected int hipCenterID = 0, spineID = 1, shoulderCenterID = 2, headID = 3;
- protected int shoulderLeftID = 4, elbowLeftID = 5, wristLeftID = 6, handLeftID = 7;
- protected int shoulderRightID = 8, elbowRightID = 9, wristRightID = 10, handRightID = 11;
- protected int hipLeftID = 12, kneeLeftID = 13, ankleLeftID = 14, footLeftID = 15;
- protected int hipRightID = 16, kneeRightID = 17, ankleRightID = 18, footRightID = 19;*/
-
- //Elements nécessaires à la reconnaissance du geste :
- //Distance du parcours du geste (va dépendre de la distance de l'utilisateur).
- protected float refDistance;
- //Position de départ pour le geste.
- protected SkeletonPoint startPoint;
- //Estimation du temps que prend la gesture (en s).
- protected float gesturePeriod = 1;
- //Estimation du nombre d'indexes par seconde (framerate).
- protected int indexesPerSecond = 30;
- //Estimation du nombre de positions du squelette à vérifier dans l'historique.
- protected int indexesToCheck;// = gesturePeriod * indexesPerSecond;
-
- public GestureDetector()
- {
-
- }
-
- //Setters.
- public void setRefDistance(float _refDistance)
- {
- refDistance = _refDistance;
- }
- public void setStartPoint(SkeletonPoint _startPoint)
- {
- startPoint = _startPoint;
- }
- public void setGesturePeriod(float _gesturePeriod)
- {
- gesturePeriod = _gesturePeriod;
- }
- public void setIndexesPerSecond(int _indexesPerSecond)
- {
- indexesPerSecond = _indexesPerSecond;
- }
- public void setIndexesToCheck(int _indexesToCheck)
- {
- indexesToCheck = _indexesToCheck;
- }
-
- //Getters.
- public float getRefDistance()
- {
- return refDistance;
- }
- public SkeletonPoint getStartPoint()
- {
- return startPoint;
- }
- public float getGesturePeriod()
- {
- return gesturePeriod;
- }
- public int getIndexesPerSecond()
- {
- return indexesPerSecond;
- }
- public int getIndexesToCheck()
- {
- return indexesToCheck;
- }
-
- //Stocke les gestes du skelette pour ~3 seconds (si on prend en compte que le framerate de la Kinect
- //est de ~30 fps.
- public static void UpdateSkeletonHistory(List latestSkeleton)
- {
- history.Add(latestSkeleton);
-
- if (history.Count > 90)
- {
- history.RemoveAt(0);
- }
- }
-
- /*public bool CheckForHandWave()
- {
- //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
- List history = new List(history);
- //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
- if (history.Count < indexesToCheck)
- return false;
-
- float refDistance = Math.Abs(history[0].Joints.ElementAt(spineID).Position.Y - history[0].Joints.ElementAt(hipCenterID).Position.Y);
- float startPos = history[history.Count - indexesToCheck].Joints.ElementAt(handRightID).Position.X;
- bool movedRight = false;
- for (int i = history.Count - indexesToCheck + 1; i < history.Count; i++)
- {
- // Throughout the gesture period, right hand should be above theelbow, below the head and hand should be higher than the wrist
- if (!(history[i].Joints[JointID.HandRight].Position.Y > history[i].Joints[JointID.ElbowRight].Position.Y + refDistance &&
- history[i].Joints[JointID.HandRight].Position.Y < history[i].Joints[JointID.Head].Position.Y &&
- history[i].Joints[JointID.HandRight].Position.Y > history[i].Joints[JointID.WristRight].Position.Y + refDistance / 4))
- {
- return false;
- }
- // If the previous condition was met, check if the hand has moved to the right
- if (history[i].Joints[JointID.HandRight].Position.X >= startPos + refDistance / 2 && !movedRight)
- {
- movedRight = true;
- }
- // If the hand did move to the right, check if it returned near the original position
- if (movedRight && history[i].Joints[JointID.HandRight].Position.X <= startPos + refDistance / 5)
- {
- skeletonHistory.Clear();
- return true;
- }
- }
- return false;
- }*/
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Gestures/JumpDetector.cs
--- a/middleware/src/Tracking/Gestures/JumpDetector.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,131 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Gestures
- * Classe : JumpDetector
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Permet de détecter si l'utilisateur a sauté, en se basant sur
- * des règles appliquées à la positions des noeuds dans le temps.
- *
- * P.S : Cette partie est encore en développement.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-
-namespace Trakers.Tracking.Gestures
-{
- public class JumpDetector : GestureDetector
- {
- Debug.DebugWindow debug;
- static int n = 0;
-
- public JumpDetector(Debug.DebugWindow _d) : base()
- {
- debug = _d;
- gesturePeriod = (float)1;
- indexesPerSecond = 30;
- indexesToCheck = (int)(gesturePeriod * indexesPerSecond);
- }
-
- /*
- * Lit les noeuds de l'historique du squelette afin de détecter un Jump.
- * Règles :
- * .
- */
- public bool CheckForJump()
- {
- //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
- List> localHistory = new List>(history);
-
- //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
- if (localHistory.Count < indexesToCheck)
- return false;
-
- /* (HeadBelowBaseLine || LeftKneeBelowBaseLine || RightKneeBelowBaseLine ||
- * LeftAnkleBelowBaseLine || RightAnkleBelowBaseLine || BodyFaceUpwards
- *
- * NOT
- *
- * AND
- *
- * HeadAboveBaseLine && LeftKneeAboveBaseLine && RightKneeAboveBaseLine &&
- * LegsStraightPreviouslyBent)
- *
- * OR
- *
- * HeadFarAboveBaseLine
- */
-
- //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
- refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
- //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
-
- int beginIdx = localHistory.Count - indexesToCheck + 1;
- int middleIdx = localHistory.Count - indexesToCheck / 2;
-
- //bool middleOK = true
- bool topOfJump = false;
-
-
-
- //De la position p1 à pn, on suit l'algorithme.
- for (int i = beginIdx ; i < localHistory.Count ; i++)
- {
-
- if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[beginIdx][(int)JointType.HandRight].Position.Y + refDistance &&
- localHistory[i - 1][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.HandRight].Position.Y)
- {
- topOfJump = true;
- //Console.Out.WriteLine("TOP");
- }
-
- if (localHistory[i - 1][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HandRight].Position.Y && !topOfJump)
- return false;
-
- //Si la position Y de la main est plus haute que la tête
- //OU si la position Y de la main est plus basse que la hanche
- //OU si la nouvelle position Z de la main est moins profonde que la précédente
- //OU si la nouvelle position X de la main est plus éloignée de la distance N par rapport à la première position X
- //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
- //Alors la main en question ne fait pas de push.
- if (localHistory[i - 1][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HandRight].Position.Y &&
- topOfJump || localHistory[i - 1][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.HandRight].Position.Y &&
- !topOfJump)
- return false;
- }
-
- //Console.Out.WriteLine("OK");
-
- //Si la distance en Z du geste a été plus courte que la distance N
- //Alors on retourne faux.
- //float dist = (localHistory[localHistory.Count - 1][handRightID].Position.X - localHistory[localHistory.Count - indexesToCheck][handRightID].Position.X);
-
- //Console.WriteLine(Math.Abs(localHistory[0][handLeftID].Position.Z - localHistory[localHistory.Count - indexesToCheck][handLeftID].Position.Z) * 100 + " " + refDistance);
-
- //Si la dernière position de la main droite/gauche est sur le côté gauche/droit du corps
- //OU si la première position calculée de la main droite/gauche est sur le côté gauche/droit du corps
- //Alors on retourne faux.
-
- //On supprime l'historique local.
-
- debug.ExceptionLbl.Background = System.Windows.Media.Brushes.Yellow;
-
- return false;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Gestures/PushDetector.cs
--- a/middleware/src/Tracking/Gestures/PushDetector.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,218 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Gestures
- * Classe : PushDetector
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Permet de détecter si l'utilisateur a effectué un Push, en se basant sur
- * des règles appliquées à la positions des noeuds dans le temps.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-
-namespace Trakers.Tracking.Gestures
-{
- public class PushDetector : GestureDetector
- {
- public enum Direction { PUSH, PULL };
- public enum Hand { LEFT, RIGHT, BOTH, NONE };
-
- Debug.DebugWindow debug;
-
- public PushDetector(Debug.DebugWindow _d) : base()
- {
- debug = _d;
- gesturePeriod = (float)0.3;
- indexesPerSecond = 30;
- indexesToCheck = (int)(gesturePeriod * indexesPerSecond);
- }
-
- /*
- * Lit les noeuds de l'historique du squelette afin de détecter un Push.
- * Règles :
- * Se fait avec une main (gauche ou droite).
- * Chaque nouvelle position de la main doit être plus profonde que la précédente.
- * Chaque nouvelle position de la main ne doit pas dévier trop de l'axe perpendiculaire au plan (X, Y).
- * Le geste doit mesurer en profondeur une certaine distance.
- */
- public Hand CheckForPush()
- {
- //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
- List> localHistory = new List>(history);
-
- //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
- if (localHistory.Count < indexesToCheck + 1)
- return Hand.NONE;
-
- //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
- refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
- //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
- SkeletonPoint startPointLeft = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position;
- SkeletonPoint startPointRight = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position;
-
- //Booléens indiquant si le mouvement serait valide pour la main gauche ou droite.
- bool leftHandOK = true, rightHandOK = true;
-
- //De la position p1 à pn, on suit l'algorithme.
- for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
- {
- //Si la position Y de la main est plus haute que la tête
- //OU si la position Y de la main est plus basse que la hanche
- //OU si la nouvelle position Z de la main est moins profonde que la précédente
- //OU si la nouvelle position X de la main est plus éloignée de la distance N par rapport à la première position X
- //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
- //Alors la main en question ne fait pas de push.
- if (localHistory[i][(int)JointType.HandLeft].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
- localHistory[i][(int)JointType.HandLeft].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
- localHistory[i][(int)JointType.HandLeft].Position.Z > localHistory[i - 1][(int)JointType.HandLeft].Position.Z ||
- Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.X - startPointLeft.X) > refDistance / 5 ||
- Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.Y - startPointLeft.Y) > refDistance / 5)
- leftHandOK = false;
- if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
- localHistory[i][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
- localHistory[i][(int)JointType.HandRight].Position.Z > localHistory[i - 1][(int)JointType.HandRight].Position.Z ||
- Math.Abs(localHistory[i][(int)JointType.HandRight].Position.X - startPointRight.X) > refDistance / 5 ||
- Math.Abs(localHistory[i][(int)JointType.HandRight].Position.Y - startPointRight.Y) > refDistance / 5)
- rightHandOK = false;
-
- if (!leftHandOK && !rightHandOK)
- return Hand.NONE;
- }
-
- //Si la distance en Z du geste a été plus courte que la distance N
- //Alors on retourne faux.
- if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.Z) * 100 < 20)
- leftHandOK = false;
- if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.Z) * 100 < 20)
- rightHandOK = false;
-
- //Si la dernière position de la main droite/gauche est sur le côté gauche/droit du corps
- //OU si la première position calculée de la main droite/gauche est sur le côté gauche/droit du corps
- //Alors on retourne faux.
- if (localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
- localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
- leftHandOK = false;
- if (localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
- localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
- rightHandOK = false;
-
- if (!leftHandOK && !rightHandOK)
- return Hand.NONE;
-
- //On supprime l'historique local.
- localHistory.Clear();
-
- //Si on est arrivé jusqu'ici, toutes les conditions pour un push ont été remplies.
-
- if (leftHandOK && rightHandOK)
- return Hand.BOTH;
- else if (leftHandOK)
- return Hand.LEFT;
- else if (rightHandOK)
- return Hand.RIGHT;
-
- return Hand.NONE;
- }
-
- /*
- * Lit les noeuds de l'historique du squelette afin de détecter un Pull.
- * Règles :
- * Se fait avec une main.
- * Chaque nouvelle position de la main doit être moins profonde que la précédente.
- * Chaque nouvelle position de la main ne doit pas dévier trop de l'axe perpendiculaire au plan (X, Y).
- * Le geste doit mesurer en profondeur une certaine distance.
- */
- public Hand CheckForPull()
- {
- //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
- List> localHistory = new List>(history);
-
- //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
- if (localHistory.Count < indexesToCheck + 1)
- return Hand.NONE;
-
- //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
- refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
- //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
- SkeletonPoint startPointLeft = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position;
- SkeletonPoint startPointRight = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position;
-
- //Booléens indiquant si le mouvement serait valide pour la main gauche ou droite.
- bool leftHandOK = true, rightHandOK = true;
-
- //De la position p1 à pn, on suit l'algorithme.
- for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
- {
- //Si la position Y de la main est plus haute que la tête
- //OU si la position Y de la main est plus basse que la hanche
- //OU si la nouvelle position Z de la main est plus profonde que la précédente
- //OU si la nouvelle position X de la main est plus éloignée de la distance N par rapport à la première position X
- //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
- //Alors la main en question ne fait pas de push.
- if (localHistory[i][(int)JointType.HandLeft].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
- localHistory[i][(int)JointType.HandLeft].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
- localHistory[i][(int)JointType.HandLeft].Position.Z < localHistory[i - 1][(int)JointType.HandLeft].Position.Z ||
- Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.X - startPointLeft.X) > refDistance / 5 ||
- Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.Y - startPointLeft.Y) > refDistance / 5)
- leftHandOK = false;
- if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
- localHistory[i][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
- localHistory[i][(int)JointType.HandRight].Position.Z < localHistory[i - 1][(int)JointType.HandRight].Position.Z ||
- Math.Abs(localHistory[i][(int)JointType.HandRight].Position.X - startPointRight.X) > refDistance / 5 ||
- Math.Abs(localHistory[i][(int)JointType.HandRight].Position.Y - startPointRight.Y) > refDistance / 5)
- rightHandOK = false;
-
- if (!leftHandOK && !rightHandOK)
- return Hand.NONE;
- }
-
- //Si la distance en Z du geste a été plus courte que la distance N
- //Alors on retourne faux.
- if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.Z) * 100 < 20)
- leftHandOK = false;
- if (Math.Abs(localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.Z - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.Z) * 100 < 20)
- rightHandOK = false;
-
- //Si la dernière position de la main droite/gauche est sur le côté gauche/droit du corps
- //OU si la première position calculée de la main droite/gauche est sur le côté gauche/droit du corps
- //Alors on retourne faux.
- if (localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
- localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
- leftHandOK = false;
- if (localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
- localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
- rightHandOK = false;
-
- if (!leftHandOK && !rightHandOK)
- return Hand.NONE;
-
- //On supprime l'historique local.
- localHistory.Clear();
-
- //Si on est arrivé jusqu'ici, toutes les conditions pour un push ont été remplies.
- if (leftHandOK && rightHandOK)
- return Hand.BOTH;
- else if (leftHandOK)
- return Hand.LEFT;
- else if (rightHandOK)
- return Hand.RIGHT;
-
- return Hand.NONE;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Gestures/SwipeDetector.cs
--- a/middleware/src/Tracking/Gestures/SwipeDetector.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,154 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Gestures
- * Classe : SwipeDetector
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Permet de détecter si l'utilisateur a effectué un Swipe, en se basant sur
- * des règles appliquées à la positions des noeuds dans le temps.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Kinect;
-
-namespace Trakers.Tracking.Gestures
-{
- public class SwipeDetector : GestureDetector
- {
- public enum Direction {LEFT, RIGHT, TOP, DOWN};
-
- Debug.DebugWindow debug;
-
- public SwipeDetector(Debug.DebugWindow _d) : base()
- {
- debug = _d;
- gesturePeriod = (float)0.5;
- indexesPerSecond = 30;
- indexesToCheck = (int)(gesturePeriod * indexesPerSecond);
- }
-
- /*
- * Lit les noeuds de l'historique du squelette afin de détecter un Swipe left.
- * Règles :
- * Se fait avec la main droite.
- * Chaque nouvelle position de la main doit être à la gauche de la précédente.
- * Chaque nouvelle position de la main ne doit pas s'éloigner verticalement de plus d'une certaine distance.
- * Le geste doit mesurer horizontalement une certaine distance.
- */
- public bool CheckForSwipeLeft()
- {
- //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
- List> localHistory = new List>(history);
-
- //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
- if (localHistory.Count < indexesToCheck+1)
- return false;
-
- //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
- refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
- //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
- startPoint = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position;
-
- //De la position p1 à pn, on suit l'algorithme.
- for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
- {
- //Si la position Y de la main est plus haute que la tête
- //OU si la position Y de la main est plus basse que la hanche
- //OU si la nouvelle position X de la main est à droite de la précédente
- //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
- //Alors on retourne faux.
- if (localHistory[i][(int)JointType.HandRight].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
- localHistory[i][(int)JointType.HandRight].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
- localHistory[i][(int)JointType.HandRight].Position.X > localHistory[i - 1][(int)JointType.HandRight].Position.X ||
- Math.Abs(localHistory[i][(int)JointType.HandRight].Position.Y - startPoint.Y) > refDistance / 2)
- return false;
- }
-
- //Si la distance horizontale du geste a été plus courte que la distance N
- //Alors on retourne faux.
- if (Math.Abs(localHistory[0][(int)JointType.HandRight].Position.X - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X) < refDistance / 2)
- return false;
-
- //Si la dernière position de la main droite est sur le côté droit du corps
- //OU si la première position calculée de la main droite est sur le côté gauche du corps
- //Alors on retourne faux.
- if (localHistory[localHistory.Count - 1][(int)JointType.HandRight].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
- localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandRight].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
- return false;
-
- //On supprime l'historique local.
- localHistory.Clear();
- //Si on est arrivé jusqu'ici, toutes les conditions pour un swipe left ont été remplies.
- return true;
- }
-
- /*
- * Lit les noeuds de l'historique du squelette afin de détecter un Swipe right.
- * Règles :
- * Se fait avec la main gauche.
- * Chaque nouvelle position de la main doit être à la droite de la précédente.
- * Chaque nouvelle position de la main ne doit pas s'éloigner verticalement de plus d'une certaine distance.
- * Le geste doit mesurer horizontalement une certaine distance.
- */
- public bool CheckForSwipeRight()
- {
- //Crée un historique de squelette local, puisque l'historique est mis à jour toutes les ~1/30 s.
- List> localHistory = new List>(history);
-
- //Si il n'y a pas assez de positions dans l'historique local pour vérifier le geste.
- if (localHistory.Count < indexesToCheck + 1)
- return false;
-
- //La distance de référence est ici la distance entre le milieu du dos et le milieu des épaules.
- refDistance = Math.Abs(localHistory[0][(int)JointType.Spine].Position.Y - localHistory[0][(int)JointType.ShoulderCenter].Position.Y);
- //On commence la position pour les indexesToCheck dernières postures (celle à l'index 0 étant la dernière).
- startPoint = localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position;
-
- //De la position p1 à pn, on suit l'algorithme.
- for (int i = localHistory.Count - indexesToCheck + 1; i < localHistory.Count; i++)
- {
- //Si la position Y de la main est plus haute que la tête
- //OU si la position Y de la main est plus basse que la hanche
- //OU si la nouvelle position X de la main est à gauche de la précédente
- //OU si la nouvelle position Y de la main est plus éloignée de la distance N par rapport à la première position Y
- //Alors on retourne faux.
- if (localHistory[i][(int)JointType.HandLeft].Position.Y < localHistory[i][(int)JointType.Head].Position.Y ||
- localHistory[i][(int)JointType.HandLeft].Position.Y > localHistory[i][(int)JointType.HipCenter].Position.Y ||
- localHistory[i][(int)JointType.HandLeft].Position.X < localHistory[i - 1][(int)JointType.HandLeft].Position.X ||
- Math.Abs(localHistory[i][(int)JointType.HandLeft].Position.Y - startPoint.Y) > refDistance / 2)
- return false;
- }
-
- //Si la distance horizontale du geste a été plus courte que la distance N
- //Alors on retourne faux.
- if (Math.Abs(localHistory[0][(int)JointType.HandLeft].Position.X - localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X) < refDistance / 2)
- return false;
-
- //Si la dernière position de la main droite est sur le côté gauche du corps
- //OU si la première position calculée de la main droite est sur le côté droit du corps
- //Alors on retourne faux.
- if (localHistory[localHistory.Count - 1][(int)JointType.HandLeft].Position.X < localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X ||
- localHistory[localHistory.Count - indexesToCheck][(int)JointType.HandLeft].Position.X > localHistory[localHistory.Count - 1][(int)JointType.HipCenter].Position.X)
- return false;
-
- //On supprime l'historique local.
- localHistory.Clear();
- //Si on est arrivé jusqu'ici, toutes les conditions pour un swipe right ont été remplies.
- return true;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Gestures/UserPositionDetector.cs
--- a/middleware/src/Tracking/Gestures/UserPositionDetector.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,150 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking/Gestures
- * Classe : UserPositionDetector
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Permet de détecter si l'utilisateur s'est déplacé dans la zone de détection, en se basant
- * sur la distance de l'utilisateur à Kinect.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Gestures
-{
- public class UserPositionDetector
- {
- Debug.DebugWindow debug;
-
- float minDistance, maxDistance, zeroPoint;
- float searchMinDistance, searchMaxDistance;
-
- static int n = 0;
-
- /*
- * Le constructeur prend en entrée le debug mais aussi les principales distances qui délimitent la
- * zone de détection.
- */
- public UserPositionDetector(Debug.DebugWindow _d, float _minDistance, float _maxDistance, float _zeroPoint, float _searchMinDistance, float _searchMaxDistance)
- {
- minDistance = _minDistance;
- maxDistance = _maxDistance;
- searchMinDistance = _searchMinDistance;
- searchMaxDistance = _searchMaxDistance;
- zeroPoint = _zeroPoint;
- debug = _d;
- }
-
- /*
- * Getters et Setters des distances (dans le cadre d'une modification des paramètres).
- */
- public void setMinDistance(float dist)
- {
- minDistance = dist;
- }
- public void setMaxDistance(float dist)
- {
- maxDistance = dist;
- }
- public void setSearchMinDistance(float dist)
- {
- searchMinDistance = dist;
- }
- public void setSearchMaxDistance(float dist)
- {
- searchMaxDistance = dist;
- }
- public void setZeroPoint(float dist)
- {
- zeroPoint = dist;
- }
- public void setParams(float minDist, float maxDist, float minDistHands, float maxDistHands, float zero)
- {
- //On charge tous les paramètres d'un coup.
- minDistance = minDist;
- maxDistance = maxDist;
- searchMinDistance = minDistHands;
- searchMaxDistance = maxDistHands;
- zeroPoint = zero;
- }
-
- public float getMinDistance()
- {
- return minDistance;
- }
- public float getMaxDistance()
- {
- return maxDistance;
- }
- public float getSearchMinDistance()
- {
- return searchMinDistance;
- }
- public float getSearchMaxDistance()
- {
- return searchMaxDistance;
- }
- public float getZeroPoint()
- {
- return zeroPoint;
- }
-
- /*
- * Lit la position de l'utilisateur à Kinect et ressort un pourcentage de proximité.
- * Règles : Droite affine de coefficient négatif.
- * .
- */
- public float CalcProximity(float distance)
- {
- //Si on se trouve trop loin.
- if (distance > maxDistance)
- return 0.0f;
- //Si on se trouve trop près.
- if (distance < searchMinDistance)
- return 0.0f;
- //Si on n'est pas encore trop près mais qu'on dépasse le point zéro.
- if (distance < zeroPoint)
- return 100.0f;
-
- //Equation, de droite affine à partir de deux points.
- //Ici 99 tout simplement car 100 - 1, les limites de pourcentage de proximité.
- float a = 99/((float)zeroPoint - maxDistance);
- float b = 100 - a * zeroPoint;
-
- return a * distance + b;
- }
-
- /*
- * Estime le nombre de vidéos à afficher en fonction du pourcentage de proximité et du nombre de
- * vidéos dans la mosaïque.
- * .
- */
- public int ImagesToShow(float proximity, int N)
- {
- //Si la proximité est nulle, on retourne 0.
- if (proximity == 0f)
- return 0;
- //Si on n'est pas encore trop près mais qu'on dépasse le point zéro.
- if (proximity >= 90f)
- return N;
-
- //Pour chaque intervalle de déciles (dans les pourcentages), le nombre de dizaines
- //du pourcentage de proximité plus un, fois le nombre de dizaines d'images seront affichées.
- return (((int)proximity / 10) + 1) * ((int)N / 2);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/KinectMain.cs
--- a/middleware/src/Tracking/KinectMain.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,760 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking
- * Classe : KinectMain
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Récupère les trames de données de la Kinect, les squelettes détectés via le SDK 1.0 de Microsoft.
- * Interprète ces trames de façon à afficher le flux vidéo couleurs, et récupérer la distance de l'utilisateur et les
- * noeuds de son squelette. Lance des événements lorsque la main gauche/droite entre dans/quitte le champ.
- * Envoie des données au sous-module de debug de manière a afficher un retour visuel sur la position de l'utilisateur,
- * son squelette, la détection de ses mains.
- * Découpe l'interaction avec le middleware en différents modes.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows;
-using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
-using System.Drawing;
-using System.Windows.Media.Media3D;
-using Microsoft.Kinect;
-
-using Coding4Fun.Kinect.Wpf;
-using System.ComponentModel;
-
-using Trakers.Debug;
-using Tuio;
-using Trakers.Communication;
-using System.IO;
-using Trakers.Tracking.Gestures;
-using Trakers.Tracking.Events;
-using System.Configuration;
-using System.Resources;
-using System.Reflection;
-
-namespace Trakers.Tracking
-{
- //Il s'agit des fonctions permettant d'appeler les fonctions des événements Main droite/gauche entre/quitte le champ.
- public delegate void LeftHandTrackedHandler(object o, LeftHandTrackedEventArgs e);
- public delegate void RightHandTrackedHandler(object o, RightHandTrackedEventArgs e);
- public delegate void LeftHandQuitHandler(object o, LeftHandQuitEventArgs e);
- public delegate void RightHandQuitHandler(object o, RightHandQuitEventArgs e);
- //Il s'agit de la fonction permettant d'appeler les fonctions des événements Swipe left/right/up/down.
- public delegate void SwipeHandler(object o, SwipeEventArgs e);
- //Il s'agit de la fonction permettant d'appeler les fonctions des événements Push/Pull.
- public delegate void PushHandler(object o, PushEventArgs e);
- //Il s'agit de la fonction permettant d'appeler les fonctions des événements Jump.
- public delegate void JumpHandler(object o, JumpEventArgs e);
- //Il s'agit de la fonction permettant d'appeler les fonctions des événements de proximité.
- public delegate void UserPositionHandler(object o, UserPositionEventArgs e);
-
- public class KinectMain
- {
- //Gestionnaire de ressources.
- private ResourceManager rm;
- //Fenêtre de debug.
- private Debug.DebugWindow debug;
- //Squelettes (Il y en a 6 par défaut).
- private Skeleton[] skeletons;
- //Caméra infrarouge (sensor) de la Kinect.
- private KinectSensor kinectSensor;
-
- //Détecteur de swipes.
- private SwipeDetector swipeDetector;
- //Détecteur de pushes.
- private PushDetector pushDetector;
- //Détecteur de jumps.
- private JumpDetector jumpDetector;
- //Détecteur de proximité.
- private UserPositionDetector userPositionDetector;
-
- //Distances min/max délimitant le champ de recherche.
- private float minDistHands;
- private float maxDistHands;
- private float minDist;
- private float maxDist;
- private float zeroPoint;
- private int imagesToShow;
- private int takenPoints;
- private int directionChangeTresholdXY;
- private float directionChangeTresholdZ;
-
- //Temps de rafraichissement pour le timer (Détection de gesture dans le serveur TUIO).
- private int timerElapsing;
-
- //Serveur TUIO pour la connexion du Middleware vers le Front Atelier.
- private Server server;
-
- //Gestionnaire de modes.
- private ModeManagement modeManagement;
-
- //Les événements des mains pour la recherche.
- public static event LeftHandTrackedHandler LeftHandTrackedEvent;
- public static event RightHandTrackedHandler RightHandTrackedEvent;
- public static event LeftHandQuitHandler LeftHandQuitEvent;
- public static event RightHandQuitHandler RightHandQuitEvent;
- //L'événement swipe.
- public static event SwipeHandler SwipeEvent;
- //L'événement push.
- public static event PushHandler PushEvent;
- //L'événement jump.
- public static event JumpHandler JumpEvent;
- //L'événement l'utilisateur se déplace dans la zone de détection.
- public static event UserPositionHandler UserPositionEvent;
-
- private string connexionHost;
- private int connexionPort;
-
- /*
- * Initialisation de la classe principale.
- * Affiche l'écran de debug dans lequel on voit la distance à la Kinect,
- * les mains détectées et le squelette de l'utilisateur.
- */
- public KinectMain()
- {
- //On fait appel au gestionnaire de ressources.
- rm = new ResourceManager("Trakers.Properties.resources", Assembly.GetExecutingAssembly());
-
- //On tente de charger les paramètres du fichier params.ini.
- //Si on n'y arrive pas, on affiche une erreur et on charge les paramètres par défaut.
- if (!loadParameters())
- {
- debug.ExceptionLbl.Content = rm.GetString("loadParametersFail");
- //Distances de détection des mains par défaut pour la recherche (ici de 1m à 2m de la Kinect).
- minDistHands = 1.0f;
- maxDistHands = 1.5f;
- minDist = 1.0f;
- maxDist = 4.0f;
- zeroPoint = 1.7f;
- connexionHost = "127.0.0.1";
- connexionPort = 80;
- timerElapsing = 1000;
- imagesToShow = 25;
- takenPoints = 10;
- directionChangeTresholdXY = 10;
- directionChangeTresholdZ = 0.01f;
- }
-
- //On crée la fenêtre de debug.
- debug = new Debug.DebugWindow(this);
-
- //On crée les détecteurs de gestes.
- swipeDetector = new SwipeDetector(debug);
- pushDetector = new PushDetector(debug);
- jumpDetector = new JumpDetector(debug);
- //On crée le détecteur de proximité.
- userPositionDetector = new UserPositionDetector(debug, minDist, maxDist, zeroPoint, minDistHands, maxDistHands);
-
- //On affiche la fenêtre de debug.
- try
- {
- debug.ShowDialog();
- }
- catch(Exception){}
- }
-
- /*
- * Initialisation de la classe principale avec comme argument le gestionnaire de ressources.
- */
- public KinectMain(ResourceManager _rm) : this()
- {
- rm = _rm;
- }
-
- /*
- * Initialisation du sensor de la Kinect.
- */
- public void KinectInitialization()
- {
- try
- {
- //On sélectionne la première kinect détectée.
- kinectSensor = KinectSensor.KinectSensors.FirstOrDefault(s => s.Status == KinectStatus.Connected);
- //La caméra couleur est activée avec une résolution 640x480 et un framerate de 30 FPS.
- kinectSensor.ColorStream.Enable(ColorImageFormat.RgbResolution640x480Fps30);
- //La caméra de profondeur est activée.
- kinectSensor.DepthStream.Enable();
- //Le squelette est activé.
- kinectSensor.SkeletonStream.Enable();
-
- //Quand le Middleware reçoit des trames de la Kinect, on va dans cette fonction.
- kinectSensor.AllFramesReady += new EventHandler(AllFramesReady);
-
- //On applique des paramètres d'ajustement pour le squelette.
- TransformSmoothParameters parameters = new TransformSmoothParameters();
- parameters.Smoothing = 0.2f;
- parameters.Correction = 0.8f;
- parameters.Prediction = 0.0f;
- parameters.JitterRadius = 0.5f;
- parameters.MaxDeviationRadius = 0.5f;
- kinectSensor.SkeletonStream.Enable(parameters);
- //On démarre la Kinect.
- kinectSensor.Start();
- debug.ExceptionLbl.Content = "";
- }
- catch (System.Exception)
- {
- debug.ExceptionLbl.Content = rm.GetString("KinectNotConnected");
- }
-
- //Pour les événements main gauche/droite entre dans/quitte le champ, on a 4 listeners.
- //Fonction appelée lorsque la main gauche entre dans le champ de recherche.
- LeftHandTrackedListener leftHandTrackedListener = new LeftHandTrackedListener();
- LeftHandTrackedEvent += new LeftHandTrackedHandler(leftHandTrackedListener.ShowOnScreen);
-
- //Fonction appelée lorsque la main droite entre dans le champ de recherche.
- RightHandTrackedListener rightHandTrackedListener = new RightHandTrackedListener();
- RightHandTrackedEvent += new RightHandTrackedHandler(rightHandTrackedListener.ShowOnScreen);
-
- //Fonction appelée lorsque la main gauche quitte le champ de recherche.
- LeftHandQuitListener leftHandQuitListener = new LeftHandQuitListener();
- LeftHandQuitEvent += new LeftHandQuitHandler(leftHandQuitListener.ShowOnScreen);
-
- //Fonction appelée lorsque la main droite quitte le champ de recherche.
- RightHandQuitListener rightHandQuitListener = new RightHandQuitListener();
- RightHandQuitEvent += new RightHandQuitHandler(rightHandQuitListener.ShowOnScreen);
-
- //Fonction appelée lorsque l'utilisateur effectue un Swipe right/left/up/down.
- SwipeListener swipeListener = new SwipeListener();
- SwipeEvent += new SwipeHandler(swipeListener.ShowOnScreen);
-
- //Fonction appelée lorsque l'utilisateur effectue un Push/Pull.
- PushListener pushListener = new PushListener();
- PushEvent += new PushHandler(pushListener.ShowOnScreen);
-
- //Fonction appelée lorsque l'utilisateur effectue un Jump.
- JumpListener jumpListener = new JumpListener();
- JumpEvent += new JumpHandler(jumpListener.ShowOnScreen);
-
- //Fonction appelée lorsque l'utilisateur se déplace dans la zone de détection.
- UserPositionListener userPositionListener = new UserPositionListener();
- UserPositionEvent += new UserPositionHandler(userPositionListener.ShowOnScreen);
-
- //On connecte le serveur à l'adresse locale sur le port 80.
- server = new Server(connexionHost, connexionPort, timerElapsing, debug);
-
- //On crée le gestionnaire de modes.
- modeManagement = new ModeManagement(this, server, debug);
- modeManagement.DetectProximityBasedModes(0);
- }
-
- /*
- * Fermeture du sensor de la Kinect.
- */
- public void KinectClose()
- {
- try
- {
- //On stoppe la Kinect.
- kinectSensor.Stop();
- //On met a zero l'image d'affichage et le serveur.
- debug.DebugImage.Source = null;
- //server = null;
- debug.ExceptionLbl.Content = "";
- }
- catch (System.Exception)
- {
- debug.ExceptionLbl.Content = rm.GetString("KinectNotConnected");
- }
- }
-
- /*
- * Récupère le premier squelette.
- */
- Skeleton GetFirstSkeleton(object sender, AllFramesReadyEventArgs e)
- {
- using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame())
- {
- if (skeletonFrameData == null)
- return null;
- if ((skeletons == null) || (skeletons.Length != skeletonFrameData.SkeletonArrayLength))
- skeletons = new Skeleton[skeletonFrameData.SkeletonArrayLength];
- skeletonFrameData.CopySkeletonDataTo(skeletons);
-
- //On obtient le premier skelette.
- Skeleton first = (from s in skeletons where s.TrackingState == SkeletonTrackingState.Tracked select s).FirstOrDefault();
-
- return first;
- }
- }
-
- /*
- * Récupère le squelette le plus proche.
- */
- Skeleton GetNearestSkeleton(object sender, AllFramesReadyEventArgs e)
- {
- using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame())
- {
- if (skeletonFrameData == null)
- return null;
- if ((skeletons == null) || (skeletons.Length != skeletonFrameData.SkeletonArrayLength))
- skeletons = new Skeleton[skeletonFrameData.SkeletonArrayLength];
- skeletonFrameData.CopySkeletonDataTo(skeletons);
-
- Skeleton s;
- float minDist = (float)-1.0;
- int minID = 0;
-
- //Pour tous les squelettes.
- for(int i = 0 ; i < skeletons.Count() ; i++)
- {
- s = skeletons.ElementAt(i);
- //S'il est tracké.
- if(s.TrackingState == SkeletonTrackingState.Tracked)
- {
- //On récupère sa position et on obtient la distance min et l'ID du squelette qui est à la distance min.
- float dist = skeletons.ElementAt(i).Position.Z;
- if (minDist == -1)
- {
- minDist = dist;
- minID = i;
- }
- else if(minDist > dist)
- {
- minDist = dist;
- minID = i;
- }
- }
- }
-
- //On renvoie le skelette le plus proche.
- return skeletons.ElementAt(minID);
- }
- }
-
- /*
- * Récupère le squelette le plus proche.
- */
- private void AllFramesReady(object sender, AllFramesReadyEventArgs e)
- {
- //On ne calcule rien si la fenêtre de debug se ferme.
- if (debug.isClosing())
- return;
-
- //On met à jour la vidéo de debug.
- debug.RefreshVideo(e);
- //On récupère le premier squelette tracké.
- //Skeleton first = GetFirstSkeleton(e);
- //On récupère le plus proche squelette tracké.
- Skeleton first = GetNearestSkeleton(sender, e);
- //Si celui-ci n’est pas nul
- if (first == null)
- return;
-
- //Si ce squelette est tracké (donc suivi et reconnu par la camera)
- if (first.TrackingState == SkeletonTrackingState.Tracked)
- {
- //Ensemble des noeuds du squelette.
- Joint hipCenter = getJoint(first, JointType.HipCenter), spine = getJoint(first, JointType.Spine), shoulderCenter = getJoint(first, JointType.ShoulderCenter), head = getJoint(first, JointType.Head);
- Joint shoulderLeft = getJoint(first, JointType.ShoulderLeft), elbowLeft = getJoint(first, JointType.ElbowLeft), wristLeft = getJoint(first, JointType.WristLeft), handLeft = getJoint(first, JointType.HandLeft);
- Joint shoulderRight = getJoint(first, JointType.ShoulderRight), elbowRight = getJoint(first, JointType.ElbowRight), wristRight = getJoint(first, JointType.WristRight), handRight = getJoint(first, JointType.HandRight);
- Joint hipLeft = getJoint(first, JointType.HipLeft), kneeLeft = getJoint(first, JointType.KneeLeft), ankleLeft = getJoint(first, JointType.AnkleLeft), footLeft = getJoint(first, JointType.FootLeft);
- Joint hipRight = getJoint(first, JointType.HipRight), kneeRight = getJoint(first, JointType.KneeRight), ankleRight = getJoint(first, JointType.AnkleRight), footRight = getJoint(first, JointType.FootRight);
-
- //On construit l'historique des postures.
- List joints = new List();
- joints.Clear();
- joints.Insert((int)JointType.HipCenter, hipCenter);
- joints.Insert((int)JointType.Spine, spine);
- joints.Insert((int)JointType.ShoulderCenter, shoulderCenter);
- joints.Insert((int)JointType.Head, head);
- joints.Insert((int)JointType.ShoulderLeft, shoulderLeft);
- joints.Insert((int)JointType.ElbowLeft, elbowLeft);
- joints.Insert((int)JointType.WristLeft, wristLeft);
- joints.Insert((int)JointType.HandLeft, handLeft);
- joints.Insert((int)JointType.ShoulderRight, shoulderRight);
- joints.Insert((int)JointType.ElbowRight, elbowRight);
- joints.Insert((int)JointType.WristRight, wristRight);
- joints.Insert((int)JointType.HandRight, handRight);
- joints.Insert((int)JointType.HipLeft, hipLeft);
- joints.Insert((int)JointType.KneeLeft, kneeLeft);
- joints.Insert((int)JointType.AnkleLeft, ankleLeft);
- joints.Insert((int)JointType.FootLeft, footLeft);
- joints.Insert((int)JointType.HipRight, hipRight);
- joints.Insert((int)JointType.KneeRight, kneeRight);
- joints.Insert((int)JointType.AnkleRight, ankleRight);
- joints.Insert((int)JointType.FootRight, footRight);
- GestureDetector.UpdateSkeletonHistory(joints);
-
- //Si la main gauche est dans le champ, on lance l'événement approprié.
- if (handLeft.Position.Z < maxDistHands && handLeft.Position.Z > minDistHands)
- {
- LeftHandTrackedEventArgs leftHandTrackedEvent = new LeftHandTrackedEventArgs(handLeft, handLeft.Position.Z, debug, server);
- OnLeftHandTrackedEvent(leftHandTrackedEvent);
- }
- //Si la main gauche quitte le champ, on lance l'événement approprié.
- else
- {
- LeftHandQuitEventArgs leftHandQuitEvent = new LeftHandQuitEventArgs(debug, server);
- OnLeftHandQuitEvent(leftHandQuitEvent);
- }
- //Si la main droite est dans le champ, on lance l'événement approprié.
- if (handRight.Position.Z < maxDistHands && handRight.Position.Z > minDistHands)
- {
- RightHandTrackedEventArgs rightHandTrackedEvent = new RightHandTrackedEventArgs(handRight, handRight.Position.Z, debug, server);
- OnRightHandTrackedEvent(rightHandTrackedEvent);
- }
- //Si la main droite quitte le champ, on lance l'événement approprié.
- else
- {
- RightHandQuitEventArgs rightHandQuitEvent = new RightHandQuitEventArgs(debug, server);
- OnRightHandQuitEvent(rightHandQuitEvent);
- }
-
- //Si l'utilisateur effectue un swipe left.
- if (swipeDetector.CheckForSwipeLeft())
- {
- SwipeEventArgs swipeEvent = new SwipeEventArgs(debug, server, SwipeDetector.Direction.LEFT);
- OnSwipeEvent(swipeEvent);
- }
-
- //Si l'utilisateur effectue un swipe right.
- if (swipeDetector.CheckForSwipeRight())
- {
- SwipeEventArgs swipeEvent = new SwipeEventArgs(debug, server, SwipeDetector.Direction.RIGHT);
- OnSwipeEvent(swipeEvent);
- }
-
- //Enum sur la main qui effectue le geste.
- PushDetector.Hand handPush;
- //Si l'utilisateur effectue un push.
- if ((handPush = pushDetector.CheckForPush()) != PushDetector.Hand.NONE)
- {
- PushEventArgs pushEvent = new PushEventArgs(debug, server, PushDetector.Direction.PUSH, handPush);
- OnPushEvent(pushEvent);
- }
- //Si l'utilisateur effectue un pull.
- if ((handPush = pushDetector.CheckForPull()) != PushDetector.Hand.NONE)
- {
- PushEventArgs pushEvent = new PushEventArgs(debug, server, PushDetector.Direction.PULL, handPush);
- OnPushEvent(pushEvent);
- }
-
- //Si l'utilisateur effectue un saut.
- /*if (jumpDetector.CheckForJump())
- {
- JumpEventArgs jumpEvent = new JumpEventArgs(debug, server);
- OnJumpEvent(jumpEvent);
- }*/
-
- //Si l'utilisateur se déplace dans la zone de détection.
- //On traite le problème en plusieurs limites, on discrétise la zone.
- if (first.TrackingState == SkeletonTrackingState.Tracked)
- {
- float proximity = userPositionDetector.CalcProximity(first.Position.Z);
- int numberOfImages = userPositionDetector.ImagesToShow(proximity, imagesToShow);
-
- modeManagement.DetectProximityBasedModes(proximity);
-
- if (proximity > 0f)
- {
- UserPositionEventArgs userPositionEvent = new UserPositionEventArgs(debug, server, proximity, numberOfImages);
- OnUserPositionEvent(userPositionEvent);
- }
- else if(proximity < 10f)
- {
- debug.hideSkeleton();
- modeManagement.DetectProximityBasedModes(0);
- LeftHandQuitEventArgs leftHandQuitEvent = new LeftHandQuitEventArgs(debug, server);
- OnLeftHandQuitEvent(leftHandQuitEvent);
- RightHandQuitEventArgs rightHandQuitEvent = new RightHandQuitEventArgs(debug, server);
- OnRightHandQuitEvent(rightHandQuitEvent);
- }
- }
-
- //Dessine le squelette dans le debug.
- debug.drawJoints(first.Joints, first);
- debug.showSkeleton(hipCenter, spine, shoulderCenter, head, shoulderLeft, elbowLeft, wristLeft, handLeft, shoulderRight, elbowRight, wristRight, handRight, hipLeft, kneeLeft, ankleLeft, footLeft, hipRight, kneeRight, ankleRight, footRight);
- }
- else
- {
- debug.hideSkeleton();
- modeManagement.DetectProximityBasedModes(0);
- LeftHandQuitEventArgs leftHandQuitEvent = new LeftHandQuitEventArgs(debug, server);
- OnLeftHandQuitEvent(leftHandQuitEvent);
- RightHandQuitEventArgs rightHandQuitEvent = new RightHandQuitEventArgs(debug, server);
- OnRightHandQuitEvent(rightHandQuitEvent);
- }
- }
-
- /*
- * Change l'échelle des coordonnées d'un noeud pour qu'en X et Y il corresponde à la résolution et en Z à la distance à la Kinect.
- */
- public Joint getJoint(Skeleton ske, JointType jointID)
- {
- return Coding4Fun.Kinect.Wpf.SkeletalExtensions.ScaleTo(ske.Joints[jointID], 600, 400, 0.75f, 0.75f);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand la main gauche entre dans le champ.
- */
- public static void OnLeftHandTrackedEvent(LeftHandTrackedEventArgs e)
- {
- if (LeftHandTrackedEvent != null)
- LeftHandTrackedEvent(new object(), e);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand la main droite entre dans le champ.
- */
- public static void OnRightHandTrackedEvent(RightHandTrackedEventArgs e)
- {
- if (RightHandTrackedEvent != null)
- RightHandTrackedEvent(new object(), e);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand la main gauche quitte le champ.
- */
- public static void OnLeftHandQuitEvent(LeftHandQuitEventArgs e)
- {
- if (LeftHandQuitEvent != null)
- LeftHandQuitEvent(new object(), e);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand la main droite quitte le champ.
- */
- public static void OnRightHandQuitEvent(RightHandQuitEventArgs e)
- {
- if (RightHandQuitEvent != null)
- RightHandQuitEvent(new object(), e);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur effectue un swipe right.
- */
- public static void OnSwipeEvent(SwipeEventArgs e)
- {
- if (SwipeEvent != null)
- SwipeEvent(new object(), e);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur effectue un push.
- */
- public static void OnPushEvent(PushEventArgs e)
- {
- if (PushEvent != null)
- PushEvent(new object(), e);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur effectue un saut.
- */
- public static void OnJumpEvent(JumpEventArgs e)
- {
- if (JumpEvent != null)
- JumpEvent(new object(), e);
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand l'utilisateur se déplace
- * dans la zone de détection.
- */
- public static void OnUserPositionEvent(UserPositionEventArgs e)
- {
- if (UserPositionEvent != null)
- UserPositionEvent(new object(), e);
- }
-
- /*
- * Méthode de chargement des paramètres (position du champ de recherche...).
- */
- public bool loadParameters()
- {
- try
- {
- minDistHands = (float)double.Parse(ConfigurationManager.AppSettings["searchMinDistance"]);
- maxDistHands = (float)double.Parse(ConfigurationManager.AppSettings["searchMaxDistance"]);
- minDist = (float)double.Parse(ConfigurationManager.AppSettings["minDistance"]);
- maxDist = (float)double.Parse(ConfigurationManager.AppSettings["maxDistance"]);
- zeroPoint = (float)double.Parse(ConfigurationManager.AppSettings["zeroPoint"]);
- connexionHost = ConfigurationManager.AppSettings["connexionHost"];
- connexionPort = int.Parse(ConfigurationManager.AppSettings["connexionPort"]);
- timerElapsing = int.Parse(ConfigurationManager.AppSettings["timerElapsing"]);
- imagesToShow = int.Parse(ConfigurationManager.AppSettings["imagesToShow"]);
- takenPoints = int.Parse(ConfigurationManager.AppSettings["takenPoints"]);
- directionChangeTresholdXY = int.Parse(ConfigurationManager.AppSettings["directionChangeTresholdXY"]);
- directionChangeTresholdZ = (float)double.Parse(ConfigurationManager.AppSettings["directionChangeTresholdZ"]);
- }
- catch (Exception)
- {
- return false;
- }
-
- if (maxDistHands <= 0f || minDistHands <= 0f || maxDistHands > maxDist || minDistHands > maxDist ||
- minDistHands >= maxDistHands || zeroPoint < maxDistHands || minDistHands < minDist ||
- zeroPoint >= maxDist || connexionPort < 0 || timerElapsing < 0 || imagesToShow < 1 ||
- takenPoints <= 0 || directionChangeTresholdXY < 0 || directionChangeTresholdZ < 0)
- {
- debug.ExceptionLbl.Content = rm.GetString("loadParametersIncorrect");
- return false;
- }
- return true;
- }
-
- /*
- * Met à jour les nouveaux paramètres dans la configuration.
- */
- public void updateParameters()
- {
- userPositionDetector.setParams(minDist, maxDist, minDistHands, maxDistHands, zeroPoint);
- //segmenter.setParams(takenPoints, directionChangeTresholdXY, directionChangeTresholdZ);
-
- //On récupère la config.
- Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
- //On met à jour.
- config.AppSettings.Settings.Remove("searchMinDistance");
- config.AppSettings.Settings.Add("searchMinDistance", minDistHands.ToString());
- config.AppSettings.Settings.Remove("searchMaxDistance");
- config.AppSettings.Settings.Add("searchMaxDistance", maxDistHands.ToString());
- config.AppSettings.Settings.Remove("minDistance");
- config.AppSettings.Settings.Add("minDistance", minDist.ToString());
- config.AppSettings.Settings.Remove("maxDistance");
- config.AppSettings.Settings.Add("maxDistance", maxDist.ToString());
- config.AppSettings.Settings.Remove("zeroPoint");
- config.AppSettings.Settings.Add("zeroPoint", zeroPoint.ToString());
- config.AppSettings.Settings.Remove("connexionHost");
- config.AppSettings.Settings.Add("connexionHost", connexionHost);
- config.AppSettings.Settings.Remove("connexionPort");
- config.AppSettings.Settings.Add("connexionPort", connexionPort.ToString());
- config.AppSettings.Settings.Remove("timerElapsing");
- config.AppSettings.Settings.Add("timerElapsing", timerElapsing.ToString());
- config.AppSettings.Settings.Remove("imagesToShow");
- config.AppSettings.Settings.Add("imagesToShow", imagesToShow.ToString());
- config.AppSettings.Settings.Remove("takenPoints");
- config.AppSettings.Settings.Add("takenPoints", takenPoints.ToString());
- config.AppSettings.Settings.Remove("directionChangeTresholdXY");
- config.AppSettings.Settings.Add("directionChangeTresholdXY", directionChangeTresholdXY.ToString());
- config.AppSettings.Settings.Remove("directionChangeTresholdZ");
- config.AppSettings.Settings.Add("directionChangeTresholdZ", directionChangeTresholdZ.ToString());
-
- //Sauvegarde la configuration.
- config.Save(ConfigurationSaveMode.Modified);
- ConfigurationManager.RefreshSection("appSettings");
- }
-
- /*
- * Getters et setters des paramètres du Middleware.
- */
- public void setMinDistHands(float min)
- {
- minDistHands = min;
- }
- public void setMaxDistHands(float max)
- {
- maxDistHands = max;
- }
- public void setMinDist(float min)
- {
- minDist = min;
- }
- public void setMaxDist(float max)
- {
- maxDist = max;
- }
- public void setZeroPoint(float zero)
- {
- zeroPoint = zero;
- }
- public void setConnexionHost(String host)
- {
- connexionHost = host;
- }
- public void setConnexionPort(int port)
- {
- connexionPort = port;
- }
- public void setTimerElapsing(int time)
- {
- timerElapsing = time;
- }
- public void setImagesToShow(int _imagesToShow)
- {
- imagesToShow = _imagesToShow;
- }
- public void setTakenPoints(int _takenPoints)
- {
- takenPoints = _takenPoints;
- }
- public void setDirectionChangeTresholdXY(int _directionChangeTresholdXY)
- {
- directionChangeTresholdXY = _directionChangeTresholdXY;
- }
- public void setDirectionChangeTresholdZ(float _directionChangeTresholdZ)
- {
- directionChangeTresholdZ = _directionChangeTresholdZ;
- }
-
- public float getMinDistHands()
- {
- return minDistHands;
- }
- public float getMaxDistHands()
- {
- return maxDistHands;
- }
- public float getMinDist()
- {
- return minDist;
- }
- public float getMaxDist()
- {
- return maxDist;
- }
- public float getZeroPoint()
- {
- return zeroPoint;
- }
- public String getConnexionHost()
- {
- return connexionHost;
- }
- public int getConnexionPort()
- {
- return connexionPort;
- }
- public int getTimerElapsing()
- {
- return timerElapsing;
- }
- public int getImagesToShow()
- {
- return imagesToShow;
- }
- public int getTakenPoints()
- {
- return takenPoints;
- }
- public int getDirectionChangeTresholdXY()
- {
- return directionChangeTresholdXY;
- }
- public float getDirectionChangeTresholdZ()
- {
- return directionChangeTresholdZ;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/ModeManagement.cs
--- a/middleware/src/Tracking/ModeManagement.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,161 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Tracking
- * Classe : ModeManagement
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Permet de gérer les différents modes qui découpent l'interaction avec le middleware.
- * Découpe l'interaction avec le middleware en différents modes.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Trakers.Communication;
-using Trakers.Tracking.Events;
-using Trakers.Debug;
-
-namespace Trakers.Tracking
-{
- public class ModeManagement
- {
- //Il s'agit de la fonctoin permettant de notifier le serveur en cas de changement de mode.
- public delegate void ModChangeHandler(object o, ModChangeEventArgs e);
- //L'événement on change de mode.
- public static event ModChangeHandler ModChangeEvent;
-
- //Accès au module d'interaction principal.
- private KinectMain kinectMain;
- //Accès au debug.
- private DebugWindow debug;
- //Accès au serveur.
- private Server server;
- //La liste des modes.
- public enum Mode {NO_USER, USER_INCOMING, MOSAIC, FILTER, VIDEO, TIMELINE, SEARCH};
- //Mode actuel.
- private Mode currentMode;
-
- /*
- * Constructeur qui prend en paramètres le module principal et le serveur.
- */
- public ModeManagement(KinectMain _kinectMain, Server _server, DebugWindow _debug)
- {
- kinectMain = _kinectMain;
- server = _server;
- debug = _debug;
- currentMode = Mode.NO_USER;
-
- //Fonction appelée lorsqu'on change de mode.
- ModChangeListener modChangeListener = new ModChangeListener();
- ModChangeEvent += new ModChangeHandler(modChangeListener.ShowOnScreen);
- }
-
- /*
- * Détecte tout changement de mode en se basant sur la proximité de l'utilisateur.
- */
- public void DetectProximityBasedModes(float proximity)
- {
- //Si l'utilisateur se déplace dans la zone de détection.
- //On traite le problème en plusieurs limites, on discrétise la zone.
- //On considère qu'il n'y a pas d'utilisateur si sa proximité est trop faible.
- if (proximity < 10f && currentMode != Mode.NO_USER)
- {
- currentMode = Mode.NO_USER;
- ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(debug, server, "NO_USER");
- OnModChangeEvent(modChangeEvent);
- }
- //S'il n'est pas encore au point d'interaction maximale, on considère qu'il est en chemin.
- else if (proximity >= 10f && proximity < 100f && currentMode != Mode.USER_INCOMING)
- {
- currentMode = Mode.USER_INCOMING;
- ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(debug, server, "USER_INCOMING");
- OnModChangeEvent(modChangeEvent);
- }
- //S'il est arrivé au point, il a la mosaïque complète.
- else if(proximity == 100f && currentMode != Mode.MOSAIC)
- {
- currentMode = Mode.MOSAIC;
- ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(debug, server, "MOSAIC");
- OnModChangeEvent(modChangeEvent);
- }
- }
-
- /*
- * Détecte si l'utilisateur veut filtrer la mosaïque.
- */
- public void DetectFilterMode()
- {
- //Ne fonctionne que si on se trouve dans la mosaïque.
- if (currentMode == Mode.MOSAIC)
- {
- currentMode = Mode.FILTER;
- ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(debug, server, "FILTER");
- OnModChangeEvent(modChangeEvent);
- }
- }
-
- /*
- * Détecte si l'utilisateur veut entrer dans une vidéo.
- */
- public void DetectVideoMode()
- {
- //Si on vient de la mosaïque, d'un filtrage, de la timeline ou d'une recherche, on peut entrer.
- if (currentMode == Mode.MOSAIC || currentMode == Mode.FILTER ||
- currentMode == Mode.TIMELINE || currentMode == Mode.SEARCH)
- {
- currentMode = Mode.VIDEO;
- ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(debug, server, "VIDEO");
- OnModChangeEvent(modChangeEvent);
- }
- }
-
- /*
- * Détecte si l'utilisateur veut entrer dans la timeline.
- */
- public void DetectTimeLineMode()
- {
- //Si on est dans une vidéo, on peut entrer.
- if (currentMode == Mode.VIDEO)
- {
- currentMode = Mode.TIMELINE;
- ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(debug, server, "TIMELINE");
- OnModChangeEvent(modChangeEvent);
- }
- }
-
- /*
- * Détecte si l'utilisateur veut effectuer une recherche dans cette vidéo.
- */
- public void DetectSearchMode()
- {
- //Si on est dans une vidéo, on peut entrer.
- if (currentMode == Mode.VIDEO)
- {
- currentMode = Mode.SEARCH;
- ModChangeEventArgs modChangeEvent = new ModChangeEventArgs(debug, server, "SEARCH");
- OnModChangeEvent(modChangeEvent);
- }
- }
-
- /*
- * Initialise l'événement et fait appel aux fonctions du listener quand on change de mode.
- */
- public static void OnModChangeEvent(ModChangeEventArgs e)
- {
- if (ModChangeEvent != null)
- ModChangeEvent(new object(), e);
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Search/Comparator.cs
--- a/middleware/src/Tracking/Search/Comparator.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Search
- * Classe : Comparator
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Permet de comparer une courbe tracée avec un dictionnaire.
- * La comparaison se fait sur les segments de chaque courbe, ce qui permet d'avancer dans l'arbre du
- * dictionnaire et de présenter des complétions potentielles.
- * Lors d'une comparaison entre deux structures de courbes, chaque segment est comparé un à un, ensuite,
- * c'est l'ensemble de la structure qui est comparée à l'autre (afin d'éviter les problèmes de changement
- * d'échelle partielle).
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Search
-{
- public class Comparator
- {
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Search/Constructor.cs
--- a/middleware/src/Tracking/Search/Constructor.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Search
- * Classe : Constructor
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Construit une structure au fur et à mesure que ses segments sont tracés.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Search
-{
- public class Constructor
- {
- /*public double Bernstein(int i, int k, double t)
- {
- if(i == 0 && k == 0)
- return 1;
-
- }*/
-
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Search/Curve.cs
--- a/middleware/src/Tracking/Search/Curve.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,32 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Search
- * Classe : Curve
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Définit l'objet de courbe en lui-même, composé d'une ou deux structures et
- * d'un pictogramme le représentant.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Search
-{
- public class Curve
- {
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Search/Dictionnary.cs
--- a/middleware/src/Tracking/Search/Dictionnary.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,31 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Search
- * Classe : Dictionnary
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Dictionnaire sous forme d'arbre contenant les courbes répertoriées pour la recherche.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Search
-{
- public class Dictionnary
- {
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Search/Segment.cs
--- a/middleware/src/Tracking/Search/Segment.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Search
- * Classe : Segment
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Définit un composant de structure de courbe.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows.Media.Media3D;
-
-namespace Trakers.Tracking.Search
-{
- public class Segment
- {
- //Points de la courbe réelle.
- private List knots;
- //Points de contrôle.
- private List P;
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Search/Segmenter.cs
--- a/middleware/src/Tracking/Search/Segmenter.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,284 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Search
- * Classe : Segmenter
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Permet d'extraire à la volée les segments du tracé en cours.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Windows.Media.Media3D;
-
-namespace Trakers.Tracking.Search
-{
- public class Segmenter
- {
- //Accès à la classe de détection principale pour les paramètres.
- private KinectMain kinectMain;
- //Stocke les positions d'une main au cours du temps.
- private List handPointerHistory;
- //Point précédent.
- private Point3D prevPt;
- //Ratio : on prend 1/ratio points.
- private int ratio;
- //Indique le numéro du point actuellement enregistré (pour le ratio).
- private int currentPointNumber;
- //Extremums enregistrés parmi les 3 axes pour détecter les changements de sens.
- private double Xmax, Ymax, Zmax;
- private double Xmin, Ymin, Zmin;
- //On établit une distance en nombre de points entre le point actuel l'extremum
- //local détecté dans les 3 axes (pour copier le segment : points de 0 à id de l'extremum).
- private int distToXmax, distToYmax, distToZmax;
- private int distToXmin, distToYmin, distToZmin;
- //Points critiques.
- private Point3D minPt, maxPt;
- //Tendance actuelle du tracé.
- private bool XtowardRight, YtowardUp, ZtowardFront;
- //Limites de différences à partir desquelles .
- private int directionChangeTresholdXY;
- private float directionChangeTresholdZ;
-
- /*
- * Initialisation du segmenter.
- * Coupe une courbe en deux dès qu'il repère un changement important de trajectoire.
- */
- public Segmenter(int _ratio, KinectMain _kinectMain)
- {
- kinectMain = _kinectMain;
- directionChangeTresholdXY = kinectMain.getDirectionChangeTresholdXY();
- directionChangeTresholdZ = kinectMain.getDirectionChangeTresholdZ();
- handPointerHistory = new List();
- ratio = _ratio;
- currentPointNumber = 1;
- prevPt = new Point3D(0, 0, 0);
-
- Xmax = Ymax = Zmax = Xmin = Ymin = Zmin = -1;
- distToXmax = distToYmax = distToZmax = distToXmin = distToYmin = distToZmin = -1;
- }
-
- /*
- * Getters et setters.
- */
- public void SetRatio(int _ratio)
- {
- ratio = _ratio;
- }
- public void SetDirectionChangeTresholdXY(int _directionChangeTresholdXY)
- {
- directionChangeTresholdXY = _directionChangeTresholdXY;
- }
- public void SetDirectionChangeTresholdZ(float _directionChangeTresholdZ)
- {
- directionChangeTresholdZ = _directionChangeTresholdZ;
- }
-
- public int GetRatio()
- {
- return ratio;
- }
- public int SetDirectionChangeTresholdXY()
- {
- return directionChangeTresholdXY;
- }
- public float SetDirectionChangeTresholdZ()
- {
- return directionChangeTresholdZ;
- }
-
- /*
- * On charge tous les paramètres d'un coup.
- */
- public void setParams(int _ratio, int _directionChangeTresholdXY, float _directionChangeTresholdZ)
- {
- ratio = _ratio;
- directionChangeTresholdXY = _directionChangeTresholdXY;
- directionChangeTresholdZ = _directionChangeTresholdZ;
- }
-
- /*
- * Enregistre le point passé en paramètre d'après le ratio.
- */
- public void RecordPoint(Point3D pt)
- {
- //Indique l'ID du point à couper.
- int whereToCut;
- //Si le ratio est excédé, on peut enregistrer.
- if (currentPointNumber > ratio)
- currentPointNumber = 1;
-
- //Si le point précédent est à une position différente du point actuel.
- if(prevPt.X != pt.X || prevPt.Y != pt.Y || prevPt.Z != pt.Z)
- {
- //Si le numéro est 1 (début ou ratio atteint), on enregistre.
- if(currentPointNumber == 1)
- handPointerHistory.Add(pt);
-
- //Si le point précédent a été initialisé avec un vrai point.
- if (prevPt.X > 0 && prevPt.Y > 0 && prevPt.Z > 0)
- {
- //Appel aux detecteurs d'extremums.
- if ((whereToCut = DetectDirectionChangeAtXAxis(pt)) > 0)
- Segment(whereToCut);
- else if((whereToCut = DetectDirectionChangeAtYAxis(pt)) > 0)
- Segment(whereToCut);
- else if ((whereToCut = DetectDirectionChangeAtZAxis(pt)) > 0)
- Segment(whereToCut);
- }
- //On met à jour le point précédent.
- prevPt = pt;
- //On passe au numéro suivant (jusqu'à atteindre le ration plus tard).
- currentPointNumber++;
- }
- }
-
- /*
- * Détecte un changement de sens (extremum) dans l'axe X.
- */
- public int DetectDirectionChangeAtXAxis(Point3D pt)
- {
- //ID où couper en cas d'extremum.
- int whereToCut = -1;
-
- //Mise à jour des extremums.
- if (Xmax == -1 || Xmax < pt.X)
- {
- //Si le point est plus grand en X que Xmax, alors il est remplacé et on réinitialise la
- //distance au dernier maximum en X.
- Xmax = pt.X;
- maxPt = pt;
- distToXmax = 0;
- }
- else
- distToXmax++;
- if (Xmin == -1 || Xmin > pt.X)
- {
- //Si le point est plus petit en X que Xmin, alors il est remplacé et on réinitialise la
- //distance au dernier minimum en X.
- Xmin = pt.X;
- minPt = pt;
- distToXmin = 0;
- }
- else
- distToXmin++;
-
- //Si X max est plus grand que la position actuelle additionnée du seuil
- //et que l'extremum n'est pas le premier point sauvegardé.
- if (Xmax > pt.X + directionChangeTresholdXY && maxPt != handPointerHistory.First())
- whereToCut = currentPointNumber - distToXmax;
- //Si X min est plus petit que la position actuelle à laquelle on a retiré le seuil
- //et que l'extremum n'est pas le premier point sauvegardé.
- if (Xmin < pt.X - directionChangeTresholdXY && minPt != handPointerHistory.First())
- whereToCut = currentPointNumber - distToXmin;
-
- return whereToCut;
- }
-
- /*
- * Détecte un changement de sens (extremum) dans l'axe Y.
- */
- public int DetectDirectionChangeAtYAxis(Point3D pt)
- {
- //ID où couper en cas d'extremum.
- int whereToCut = -1;
-
- //Mise à jour des extremums.
- if (Ymax == -1 || Ymax < pt.Y)
- {
- //Si le point est plus grand en Y que Ymax, alors il est remplacé et on réinitialise la
- //distance au dernier maximum en Y.
- Ymax = pt.Y;
- maxPt = pt;
- distToYmax = 0;
- }
- else
- distToYmax++;
- if (Ymin == -1 || Ymin > pt.Y)
- {
- //Si le point est plus petit en Y que Ymin, alors il est remplacé et on réinitialise la
- //distance au dernier minimum en Y.
- Ymin = pt.Y;
- minPt = pt;
- distToYmin = 0;
- }
- else
- distToYmin++;
-
- //Si Y max est plus grand que la position actuelle additionnée du seuil
- //et que l'extremum n'est pas le premier point sauvegardé.
- if (Ymax > pt.Y + directionChangeTresholdXY && maxPt != handPointerHistory.First())
- whereToCut = currentPointNumber - distToYmax;
- //Si Y min est plus petit que la position actuelle à laquelle on a retiré le seuil
- //et que l'extremum n'est pas le premier point sauvegardé.
- if (Ymin < pt.Y - directionChangeTresholdXY && minPt != handPointerHistory.First())
- whereToCut = currentPointNumber - distToYmin;
-
- return whereToCut;
- }
-
- /*
- * Détecte un changement de sens (extremum) dans l'axe Z.
- */
- public int DetectDirectionChangeAtZAxis(Point3D pt)
- {
- //ID où couper en cas d'extremum.
- int whereToCut = -1;
-
- //Mise à jour des extremums.
- if (Zmax == -1 || Zmax < pt.Z)
- {
- //Si le point est plus grand en Z que Ymax, alors il est remplacé et on réinitialise la
- //distance au dernier maximum en Z.
- Zmax = pt.Z;
- maxPt = pt;
- distToZmax = 0;
- }
- else
- distToZmax++;
- if (Zmin == -1 || Zmin > pt.Z)
- {
- //Si le point est plus petit en Z que Zmin, alors il est remplacé et on réinitialise la
- //distance au dernier minimum en Z.
- Zmin = pt.Z;
- minPt = pt;
- distToZmin = 0;
- }
- else
- distToZmin++;
-
- //Si Z max est plus grand que la position actuelle additionnée du seuil
- //et que l'extremum n'est pas le premier point sauvegardé.
- if (Zmax > pt.Z + directionChangeTresholdXY && maxPt != handPointerHistory.First())
- whereToCut = currentPointNumber - distToZmax;
- //Si Z min est plus petit que la position actuelle à laquelle on a retiré le seuil
- //et que l'extremum n'est pas le premier point sauvegardé.
- if (Zmin < pt.Z - directionChangeTresholdXY && minPt != handPointerHistory.First())
- whereToCut = currentPointNumber - distToZmin;
-
- return whereToCut;
- }
-
- /*
- * Découpe le tracé en cours en segment allant du premier point au premier extremum trouvé.
- */
- public void Segment(int whereToCut)
- {
- handPointerHistory.RemoveRange(0, whereToCut);
- currentPointNumber -= whereToCut;
- }
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Tracking/Search/Structure.cs
--- a/middleware/src/Tracking/Search/Structure.cs Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,32 +0,0 @@
-/*
-* This file is part of the TraKERS\Middleware package.
-*
-* (c) IRI
-*
-* For the full copyright and license information, please view the LICENSE_MIDDLEWARE
-* file that was distributed with this source code.
-*/
-
-/*
- * Projet : TraKERS
- * Module : MIDDLEWARE
- * Sous-Module : Search
- * Classe : Structure
- *
- * Auteur : alexandre.bastien@iri.centrepompidou.fr
- *
- * Fonctionnalités : Définit la structure d'une courbe d'un point de vue algorithmique.
- * Ce sont ces structures là qui seront comparées par la suite.
- */
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Trakers.Tracking.Search
-{
- public class Structure
- {
- }
-}
diff -r 10d5199d9874 -r 4b78f179e7ce middleware/src/Trakers.csproj
--- a/middleware/src/Trakers.csproj Fri Mar 30 11:14:14 2012 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,174 +0,0 @@
-
-
-
- Debug
- x86
- 8.0.30703
- 2.0
- {09EF8613-2F1B-4F1D-B6B1-22938EBB529A}
- WinExe
- Properties
- Trakers
- Trakers
- v4.0
- Client
- 512
- {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}
- 4
-
-
- x86
- true
- full
- false
- bin\Debug\
- DEBUG;TRACE
- prompt
- 4
-
-
- x86
- pdbonly
- true
- bin\Release\
- TRACE
- prompt
- 4
-
-
-
-
-
-
- True
-
-
- ..\lib\Bespoke.Common.dll
-
-
- ..\lib\Bespoke.Common.Osc.dll
-
-
- False
- ..\lib\Coding4Fun.Kinect.Wpf.dll
-
-
- False
- ..\lib\Microsoft.Kinect.dll
-
-
-
-
-
-
-
-
-
-
-
- 4.0
-
-
- ..\lib\TuioServer.dll
-
-
-
-
-
-
-
-
- DebugParameters.xaml
-
-
- DebugWindow.xaml
-
-
-
- Code
-
-
- True
- True
- Resources.resx
- PreserveNewest
-
-
- True
- Settings.settings
- True
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Code
-
-
- Code
-
-
-
-
- Code
-
-
- Code
-
-
-
-
-
-
-
-
-
-
- ResXFileCodeGenerator
- Resources.Designer.cs
- PreserveNewest
-
-
- Designer
-
-
- SettingsSingleFileGenerator
- Settings.Designer.cs
-
-
-
-
-
- Designer
- MSBuild:Compile
-
-
- MSBuild:Compile
- Designer
-
-
-
-
-
-
\ No newline at end of file