From 095ed00b89296e62ce6299f3697a2e24f26ea95b Mon Sep 17 00:00:00 2001 From: lzzz7 <54894040+lzzz7@users.noreply.github.com> Date: Mon, 30 Sep 2019 19:24:28 +0800 Subject: [PATCH 1/3] Create 7 --- 201731024118/7 | 1 + 1 file changed, 1 insertion(+) create mode 100644 201731024118/7 diff --git a/201731024118/7 b/201731024118/7 new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/201731024118/7 @@ -0,0 +1 @@ + From ec8a435ffcff34d3f3a2d96fc32dd71d4938a0bf Mon Sep 17 00:00:00 2001 From: lzzz7 <1245736788@qq.com> Date: Mon, 30 Sep 2019 21:48:26 +0800 Subject: [PATCH 2/3] =?UTF-8?q?=E7=AC=AC=E4=B8=80=E6=AC=A1=E6=8F=90?= =?UTF-8?q?=E4=BA=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 201731024118/7 | 1 - .../DianMing/DaoLayer/DaoLayer.csproj | 57 + .../DaoLayer/Properties/AssemblyInfo.cs | 36 + 201731024118/DianMing/DaoLayer/StudentDAO.cs | 26 + .../DianMing/DataBase/DataBase.csproj | 53 + .../DataBase/Properties/AssemblyInfo.cs | 36 + .../DianMing/DataBase/StudentDataset.cs | 236 +++ 201731024118/DianMing/DianMing.sln | 43 + .../DianMing/DianMing/DianMing.csproj | 91 + .../DianMing/DianMing/Form1.Designer.cs | 260 +++ 201731024118/DianMing/DianMing/Form1.cs | 123 ++ 201731024118/DianMing/DianMing/Form1.resx | 1514 +++++++++++++++++ 201731024118/DianMing/DianMing/Program.cs | 21 + .../DianMing/Properties/AssemblyInfo.cs | 36 + .../DianMing/Properties/Resources.Designer.cs | 71 + .../DianMing/Properties/Resources.resx | 117 ++ .../DianMing/Properties/Settings.Designer.cs | 30 + .../DianMing/Properties/Settings.settings | 7 + 201731024118/DianMing/Entity/Entity.csproj | 47 + .../Entity/Properties/AssemblyInfo.cs | 36 + 201731024118/DianMing/Entity/student.cs | 36 + 21 files changed, 2876 insertions(+), 1 deletion(-) delete mode 100644 201731024118/7 create mode 100644 201731024118/DianMing/DaoLayer/DaoLayer.csproj create mode 100644 201731024118/DianMing/DaoLayer/Properties/AssemblyInfo.cs create mode 100644 201731024118/DianMing/DaoLayer/StudentDAO.cs create mode 100644 201731024118/DianMing/DataBase/DataBase.csproj create mode 100644 201731024118/DianMing/DataBase/Properties/AssemblyInfo.cs create mode 100644 201731024118/DianMing/DataBase/StudentDataset.cs create mode 100644 201731024118/DianMing/DianMing.sln create mode 100644 201731024118/DianMing/DianMing/DianMing.csproj create mode 100644 201731024118/DianMing/DianMing/Form1.Designer.cs create mode 100644 201731024118/DianMing/DianMing/Form1.cs create mode 100644 201731024118/DianMing/DianMing/Form1.resx create mode 100644 201731024118/DianMing/DianMing/Program.cs create mode 100644 201731024118/DianMing/DianMing/Properties/AssemblyInfo.cs create mode 100644 201731024118/DianMing/DianMing/Properties/Resources.Designer.cs create mode 100644 201731024118/DianMing/DianMing/Properties/Resources.resx create mode 100644 201731024118/DianMing/DianMing/Properties/Settings.Designer.cs create mode 100644 201731024118/DianMing/DianMing/Properties/Settings.settings create mode 100644 201731024118/DianMing/Entity/Entity.csproj create mode 100644 201731024118/DianMing/Entity/Properties/AssemblyInfo.cs create mode 100644 201731024118/DianMing/Entity/student.cs diff --git a/201731024118/7 b/201731024118/7 deleted file mode 100644 index 8b13789..0000000 --- a/201731024118/7 +++ /dev/null @@ -1 +0,0 @@ - diff --git a/201731024118/DianMing/DaoLayer/DaoLayer.csproj b/201731024118/DianMing/DaoLayer/DaoLayer.csproj new file mode 100644 index 0000000..af59b6f --- /dev/null +++ b/201731024118/DianMing/DaoLayer/DaoLayer.csproj @@ -0,0 +1,57 @@ + + + + + Debug + AnyCPU + {7DB5EC20-3E7E-471E-9D69-EBD86C84927B} + Library + Properties + DaoLayer + DaoLayer + v4.0 + 512 + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + {87c82052-2d8b-4ab7-94f6-113486de2aac} + DataBase + + + {e93667d6-319c-489d-92e1-e82a19454cf2} + Entity + + + + \ No newline at end of file diff --git a/201731024118/DianMing/DaoLayer/Properties/AssemblyInfo.cs b/201731024118/DianMing/DaoLayer/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..d05920a --- /dev/null +++ b/201731024118/DianMing/DaoLayer/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的一般信息由以下 +// 控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("DaoLayer")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DaoLayer")] +[assembly: AssemblyCopyright("Copyright © 2019")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 会使此程序集中的类型 +//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型 +//请将此类型的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("7db5ec20-3e7e-471e-9d69-ebd86c84927b")] + +// 程序集的版本信息由下列四个值组成: +// +// 主版本 +// 次版本 +// 生成号 +// 修订号 +// +// 可以指定所有值，也可以使用以下所示的 "*" 预置版本号和修订号 +//通过使用 "*"，如下所示: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/201731024118/DianMing/DaoLayer/StudentDAO.cs b/201731024118/DianMing/DaoLayer/StudentDAO.cs new file mode 100644 index 0000000..21e86e3 --- /dev/null +++ b/201731024118/DianMing/DaoLayer/StudentDAO.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +using DataBase; +using Entity; + +namespace DaoLayer +{ + public class StudentDAO + { + public int getStudentRecordsNums() + { + List studengList = StudentDataset.getAll(); + return studengList.Count; + } + + public List getAllStudents() + { + List studengList = StudentDataset.getAll(); + return studengList; + } + + } +} diff --git a/201731024118/DianMing/DataBase/DataBase.csproj b/201731024118/DianMing/DataBase/DataBase.csproj new file mode 100644 index 0000000..b73fb6b --- /dev/null +++ b/201731024118/DianMing/DataBase/DataBase.csproj @@ -0,0 +1,53 @@ + + + + + Debug + AnyCPU + {87C82052-2D8B-4AB7-94F6-113486DE2AAC} + Library + Properties + DataBase + DataBase + v4.0 + 512 + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + {e93667d6-319c-489d-92e1-e82a19454cf2} + Entity + + + + \ No newline at end of file diff --git a/201731024118/DianMing/DataBase/Properties/AssemblyInfo.cs b/201731024118/DianMing/DataBase/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..96f3bbf --- /dev/null +++ b/201731024118/DianMing/DataBase/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的一般信息由以下 +// 控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("DataBase")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DataBase")] +[assembly: AssemblyCopyright("Copyright © 2019")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 会使此程序集中的类型 +//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型 +//请将此类型的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("87c82052-2d8b-4ab7-94f6-113486de2aac")] + +// 程序集的版本信息由下列四个值组成: +// +// 主版本 +// 次版本 +// 生成号 +// 修订号 +// +// 可以指定所有值，也可以使用以下所示的 "*" 预置版本号和修订号 +//通过使用 "*"，如下所示: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/201731024118/DianMing/DataBase/StudentDataset.cs b/201731024118/DianMing/DataBase/StudentDataset.cs new file mode 100644 index 0000000..68a6602 --- /dev/null +++ b/201731024118/DianMing/DataBase/StudentDataset.cs @@ -0,0 +1,236 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Collections.ObjectModel; +using System.Collections; +using Entity; + +namespace DataBase +{ + public class StudentDataset + { + //模拟数据库中的学生集合 + + private static List studengList; + + + public static List getAll() + { + studengList = new List(); + + Student stu1 = new Student("001", "王川"); + studengList.Add(stu1); + Student stu2 = new Student("002", "于丁"); + studengList.Add(stu2); + + Student stu3 = new Student("003", "张莹"); + studengList.Add(stu3); + Student stu4 = new Student("004", "李楠"); + studengList.Add(stu4); + + Student stu5 = new Student("005", "陈欣"); + studengList.Add(stu5); + Student stu6 = new Student("006", "马芸慧"); + studengList.Add(stu6); + + Student stu7 = new Student("007", "汪小萍"); + studengList.Add(stu7); + Student stu8 = new Student("008", "母丹"); + studengList.Add(stu8); + + + Student stu9 = new Student("001", "许博"); + studengList.Add(stu9); + Student stu10 = new Student("002", "芦文钰"); + studengList.Add(stu10); + + Student stu11 = new Student("011", "马昊妍"); + studengList.Add(stu11); + Student stu12 = new Student("012", "李宣晓"); + studengList.Add(stu12); + + Student stu13 = new Student("013", "李清兰"); + studengList.Add(stu13); + Student stu14 = new Student("014", "成湘"); + studengList.Add(stu14); + + Student stu15 = new Student("015", "罗涵"); + studengList.Add(stu15); + Student stu16 = new Student("016", "肖逸菲"); + studengList.Add(stu16); + + Student stu17 = new Student("017", "冯士坤"); + studengList.Add(stu17); + Student stu18 = new Student("018", "杨汶桐"); + studengList.Add(stu18); + + Student stu19 = new Student("019", "张焱菁"); + studengList.Add(stu19); + Student stu20 = new Student("020", "雷槟源"); + studengList.Add(stu20); + + Student stu21 = new Student("021", "李志"); + studengList.Add(stu21); + Student stu22 = new Student("022", "黄涛"); + studengList.Add(stu22); + + Student stu23 = new Student("023", "宋杰"); + studengList.Add(stu23); + Student stu24 = new Student("024", "赵俊安"); + studengList.Add(stu24); + + + Student stu25 = new Student("025", "张新明"); + studengList.Add(stu25); + Student stu26 = new Student("026", "张旭"); + studengList.Add(stu26); + + Student stu27 = new Student("027", "王旭"); + studengList.Add(stu27); + Student stu28 = new Student("028", "李朋珂"); + studengList.Add(stu28); + + Student stu29 = new Student("029", "张微玖"); + studengList.Add(stu29); + Student stu30 = new Student("030", "何明钦"); + studengList.Add(stu30); + + Student stu31 = new Student("031", "姜玖林"); + studengList.Add(stu31); + Student stu32 = new Student("032", "涂才森"); + studengList.Add(stu32); + + + + Student stu33 = new Student("027", "陈林"); + studengList.Add(stu33); + Student stu34 = new Student("028", "曾正男"); + studengList.Add(stu34); + + Student stu35 = new Student("029", "江天宇"); + studengList.Add(stu35); + Student stu36 = new Student("036", "魏恩博"); + studengList.Add(stu36); + + Student stu37 = new Student("031", "邹扬锋"); + studengList.Add(stu37); + Student stu38 = new Student("032", "曾琅"); + studengList.Add(stu38); + + Student stu39 = new Student("032", "周成杰"); + studengList.Add(stu39); + + Student stu40 = new Student("032", "马驰"); + studengList.Add(stu40); + + Student stu41 = new Student("032", "宋树钱"); + studengList.Add(stu41); + Student stu42 = new Student("032", "马驰"); + studengList.Add(stu42); + Student stu43 = new Student("032", "任星辰"); + studengList.Add(stu43); + + Student stu44 = new Student("032", "严一笑"); + studengList.Add(stu44); + Student stu45 = new Student("032", "孙颖"); + studengList.Add(stu45); + Student stu46 = new Student("032", "吴明益"); + studengList.Add(stu46); + Student stu47 = new Student("032", "黄耀萱"); + studengList.Add(stu47); + Student stu48 = new Student("032", "王静宜"); + studengList.Add(stu48); + Student stu49 = new Student("032", "蔡玉蓝"); + studengList.Add(stu49); + + Student stu50 = new Student("032", "姜仪"); + studengList.Add(stu50); + + Student stu51 = new Student("032", "郑雪"); + studengList.Add(stu51); + Student stu52 = new Student("032", "刘俊"); + studengList.Add(stu52); + Student stu53 = new Student("032", "何玉姣"); + studengList.Add(stu53); + Student stu54 = new Student("032", "匡小娟"); + studengList.Add(stu54); + Student stu55 = new Student("032", "王春兰"); + studengList.Add(stu55); + Student stu56 = new Student("032", "顾毓"); + studengList.Add(stu56); + Student stu57 = new Student("032", "师志杰"); + studengList.Add(stu57); + Student stu58 = new Student("032", "许佳文"); + studengList.Add(stu58); + Student stu59 = new Student("032", "雷安勇"); + studengList.Add(stu59); + + Student stu60 = new Student("032", "张伟"); + studengList.Add(stu60); + + + Student stu61 = new Student("032", "袁志杰"); + studengList.Add(stu61); + Student stu62 = new Student("032", "何全江"); + studengList.Add(stu62); + Student stu63 = new Student("032", "舒鹏飞"); + studengList.Add(stu63); + Student stu64 = new Student("032", "何辉"); + studengList.Add(stu64); + Student stu65 = new Student("032", "李全喜"); + studengList.Add(stu65); + Student stu66 = new Student("032", "谢凯宇"); + studengList.Add(stu66); + Student stu67 = new Student("032", "黄本巍"); + studengList.Add(stu67); + Student stu68 = new Student("032", "罗俊杰"); + studengList.Add(stu68); + Student stu69 = new Student("032", "何宸锐"); + studengList.Add(stu69); + Student stu70 = new Student("032", "付昶宇"); + studengList.Add(stu70); + Student stu71 = new Student("032", "傅伟鑫"); + studengList.Add(stu71); + + Student stu72 = new Student("032", "王云飞"); + studengList.Add(stu72); + + Student stu73 = new Student("032", "李元港"); + studengList.Add(stu73); + + Student stu74 = new Student("032", "赵荣泽"); + studengList.Add(stu74); + + Student stu75 = new Student("032", "吴郑浩"); + studengList.Add(stu75); + + Student stu76 = new Student("032", "何继武"); + studengList.Add(stu76); + + Student stu77 = new Student("032", "郑博"); + studengList.Add(stu77); + + Student stu78 = new Student("032", "王万成"); + studengList.Add(stu78); + + Student stu79 = new Student("032", "陈杰"); + studengList.Add(stu79); + + Student stu80 = new Student("032", "胡志伟"); + studengList.Add(stu80); + + Student stu81 = new Student("032", "涂林"); + studengList.Add(stu81); + Student stu82 = new Student("032", "孟诚成"); + studengList.Add(stu82); + Student stu83 = new Student("032", "廖志丹"); + studengList.Add(stu83); + Student stu84 = new Student("032", "杨也"); + studengList.Add(stu84); + + + return studengList; + } + } +} diff --git a/201731024118/DianMing/DianMing.sln b/201731024118/DianMing/DianMing.sln new file mode 100644 index 0000000..7303928 --- /dev/null +++ b/201731024118/DianMing/DianMing.sln @@ -0,0 +1,43 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.28307.852 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DianMing", "DianMing\DianMing.csproj", "{67E8063D-EA75-40F2-B853-CD907D64D82D}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Entity", "Entity\Entity.csproj", "{E93667D6-319C-489D-92E1-E82A19454CF2}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DataBase", "DataBase\DataBase.csproj", "{87C82052-2D8B-4AB7-94F6-113486DE2AAC}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DaoLayer", "DaoLayer\DaoLayer.csproj", "{7DB5EC20-3E7E-471E-9D69-EBD86C84927B}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {67E8063D-EA75-40F2-B853-CD907D64D82D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {67E8063D-EA75-40F2-B853-CD907D64D82D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {67E8063D-EA75-40F2-B853-CD907D64D82D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {67E8063D-EA75-40F2-B853-CD907D64D82D}.Release|Any CPU.Build.0 = Release|Any CPU + {E93667D6-319C-489D-92E1-E82A19454CF2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E93667D6-319C-489D-92E1-E82A19454CF2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E93667D6-319C-489D-92E1-E82A19454CF2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E93667D6-319C-489D-92E1-E82A19454CF2}.Release|Any CPU.Build.0 = Release|Any CPU + {87C82052-2D8B-4AB7-94F6-113486DE2AAC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {87C82052-2D8B-4AB7-94F6-113486DE2AAC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {87C82052-2D8B-4AB7-94F6-113486DE2AAC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {87C82052-2D8B-4AB7-94F6-113486DE2AAC}.Release|Any CPU.Build.0 = Release|Any CPU + {7DB5EC20-3E7E-471E-9D69-EBD86C84927B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7DB5EC20-3E7E-471E-9D69-EBD86C84927B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7DB5EC20-3E7E-471E-9D69-EBD86C84927B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7DB5EC20-3E7E-471E-9D69-EBD86C84927B}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {5702519A-E0D7-4529-9B85-2495873BDA58} + EndGlobalSection +EndGlobal diff --git a/201731024118/DianMing/DianMing/DianMing.csproj b/201731024118/DianMing/DianMing/DianMing.csproj new file mode 100644 index 0000000..b43852b --- /dev/null +++ b/201731024118/DianMing/DianMing/DianMing.csproj @@ -0,0 +1,91 @@ + + + + + Debug + AnyCPU + {67E8063D-EA75-40F2-B853-CD907D64D82D} + WinExe + DianMing + DianMing + v4.0 + 512 + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + Form + + + Form1.cs + + + + + Form1.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + {7db5ec20-3e7e-471e-9d69-ebd86c84927b} + DaoLayer + + + {e93667d6-319c-489d-92e1-e82a19454cf2} + Entity + + + + + + + \ No newline at end of file diff --git a/201731024118/DianMing/DianMing/Form1.Designer.cs b/201731024118/DianMing/DianMing/Form1.Designer.cs new file mode 100644 index 0000000..935e1f3 --- /dev/null +++ b/201731024118/DianMing/DianMing/Form1.Designer.cs @@ -0,0 +1,260 @@ +namespace WinformControlUse +{ + partial class Form1 + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1)); + this.label1 = new System.Windows.Forms.Label(); + this.dgvStuList = new System.Windows.Forms.DataGridView(); + this.stuID = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.stuName = new System.Windows.Forms.DataGridViewTextBoxColumn(); + this.panel1 = new System.Windows.Forms.Panel(); + this.panel2 = new System.Windows.Forms.Panel(); + this.btnLoadStu = new System.Windows.Forms.Button(); + this.btnStop = new System.Windows.Forms.Button(); + this.btnStart = new System.Windows.Forms.Button(); + this.progressName = new System.Windows.Forms.ProgressBar(); + this.timerCallName = new System.Windows.Forms.Timer(this.components); + this.panel3 = new System.Windows.Forms.Panel(); + this.panel4 = new System.Windows.Forms.Panel(); + this.lblName = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + ((System.ComponentModel.ISupportInitialize)(this.dgvStuList)).BeginInit(); + this.panel1.SuspendLayout(); + this.panel2.SuspendLayout(); + this.panel4.SuspendLayout(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(28, 10); + this.label1.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(67, 15); + this.label1.TabIndex = 0; + this.label1.Text = "学生列表"; + // + // dgvStuList + // + this.dgvStuList.AllowUserToAddRows = false; + this.dgvStuList.AllowUserToDeleteRows = false; + this.dgvStuList.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; + this.dgvStuList.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { + this.stuID, + this.stuName}); + this.dgvStuList.Location = new System.Drawing.Point(0, 0); + this.dgvStuList.Margin = new System.Windows.Forms.Padding(4); + this.dgvStuList.Name = "dgvStuList"; + this.dgvStuList.ReadOnly = true; + this.dgvStuList.RowTemplate.Height = 23; + this.dgvStuList.Size = new System.Drawing.Size(388, 284); + this.dgvStuList.TabIndex = 1; + this.dgvStuList.CellContentClick += new System.Windows.Forms.DataGridViewCellEventHandler(this.dgvStuList_CellContentClick); + // + // stuID + // + this.stuID.DataPropertyName = "stuID"; + this.stuID.HeaderText = "学号"; + this.stuID.Name = "stuID"; + this.stuID.ReadOnly = true; + // + // stuName + // + this.stuName.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.Fill; + this.stuName.DataPropertyName = "stuName"; + this.stuName.HeaderText = "姓名"; + this.stuName.Name = "stuName"; + this.stuName.ReadOnly = true; + // + // panel1 + // + this.panel1.BackColor = System.Drawing.SystemColors.Info; + this.panel1.Controls.Add(this.label1); + this.panel1.Dock = System.Windows.Forms.DockStyle.Top; + this.panel1.Location = new System.Drawing.Point(0, 0); + this.panel1.Margin = new System.Windows.Forms.Padding(4); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(857, 37); + this.panel1.TabIndex = 2; + this.panel1.Paint += new System.Windows.Forms.PaintEventHandler(this.panel1_Paint); + // + // panel2 + // + this.panel2.BackColor = System.Drawing.Color.Transparent; + this.panel2.Controls.Add(this.btnLoadStu); + this.panel2.Controls.Add(this.btnStop); + this.panel2.Controls.Add(this.dgvStuList); + this.panel2.Controls.Add(this.btnStart); + this.panel2.Dock = System.Windows.Forms.DockStyle.Top; + this.panel2.Location = new System.Drawing.Point(0, 37); + this.panel2.Margin = new System.Windows.Forms.Padding(4); + this.panel2.Name = "panel2"; + this.panel2.Size = new System.Drawing.Size(857, 284); + this.panel2.TabIndex = 3; + this.panel2.Paint += new System.Windows.Forms.PaintEventHandler(this.panel2_Paint); + // + // btnLoadStu + // + this.btnLoadStu.Location = new System.Drawing.Point(648, 80); + this.btnLoadStu.Margin = new System.Windows.Forms.Padding(4); + this.btnLoadStu.Name = "btnLoadStu"; + this.btnLoadStu.Size = new System.Drawing.Size(142, 43); + this.btnLoadStu.TabIndex = 0; + this.btnLoadStu.Text = "加载学生"; + this.btnLoadStu.UseVisualStyleBackColor = true; + this.btnLoadStu.Click += new System.EventHandler(this.btnLoadStu_Click); + // + // btnStop + // + this.btnStop.Location = new System.Drawing.Point(449, 132); + this.btnStop.Margin = new System.Windows.Forms.Padding(4); + this.btnStop.Name = "btnStop"; + this.btnStop.Size = new System.Drawing.Size(121, 40); + this.btnStop.TabIndex = 3; + this.btnStop.Text = "停止点名"; + this.btnStop.UseVisualStyleBackColor = true; + this.btnStop.Click += new System.EventHandler(this.btnStop_Click); + // + // btnStart + // + this.btnStart.Location = new System.Drawing.Point(452, 34); + this.btnStart.Margin = new System.Windows.Forms.Padding(4); + this.btnStart.Name = "btnStart"; + this.btnStart.Size = new System.Drawing.Size(118, 41); + this.btnStart.TabIndex = 2; + this.btnStart.Text = "开始点名"; + this.btnStart.UseVisualStyleBackColor = true; + this.btnStart.Click += new System.EventHandler(this.btnStart_Click); + // + // progressName + // + this.progressName.Dock = System.Windows.Forms.DockStyle.Bottom; + this.progressName.Location = new System.Drawing.Point(0, 184); + this.progressName.Margin = new System.Windows.Forms.Padding(4); + this.progressName.Name = "progressName"; + this.progressName.Size = new System.Drawing.Size(857, 38); + this.progressName.TabIndex = 1; + this.progressName.Click += new System.EventHandler(this.progressName_Click); + // + // timerCallName + // + this.timerCallName.Interval = 50; + this.timerCallName.Tick += new System.EventHandler(this.timerCallName_Tick); + // + // panel3 + // + this.panel3.BackColor = System.Drawing.Color.Transparent; + this.panel3.Dock = System.Windows.Forms.DockStyle.Top; + this.panel3.Location = new System.Drawing.Point(0, 321); + this.panel3.Margin = new System.Windows.Forms.Padding(4); + this.panel3.Name = "panel3"; + this.panel3.Size = new System.Drawing.Size(857, 38); + this.panel3.TabIndex = 7; + // + // panel4 + // + this.panel4.BackColor = System.Drawing.Color.Transparent; + this.panel4.Controls.Add(this.label2); + this.panel4.Controls.Add(this.progressName); + this.panel4.Controls.Add(this.lblName); + this.panel4.Location = new System.Drawing.Point(0, 363); + this.panel4.Margin = new System.Windows.Forms.Padding(4); + this.panel4.Name = "panel4"; + this.panel4.Size = new System.Drawing.Size(857, 222); + this.panel4.TabIndex = 8; + this.panel4.Paint += new System.Windows.Forms.PaintEventHandler(this.panel4_Paint); + // + // lblName + // + this.lblName.AutoSize = true; + this.lblName.Font = new System.Drawing.Font("微软雅黑", 45F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(134))); + this.lblName.ForeColor = System.Drawing.Color.OrangeRed; + this.lblName.Location = new System.Drawing.Point(369, 64); + this.lblName.Margin = new System.Windows.Forms.Padding(4, 0, 4, 0); + this.lblName.Name = "lblName"; + this.lblName.Size = new System.Drawing.Size(0, 98); + this.lblName.TabIndex = 7; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(0, 0); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(55, 15); + this.label2.TabIndex = 8; + this.label2.Text = "label2"; + // + // Form1 + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 15F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("$this.BackgroundImage"))); + this.ClientSize = new System.Drawing.Size(857, 578); + this.Controls.Add(this.panel4); + this.Controls.Add(this.panel3); + this.Controls.Add(this.panel2); + this.Controls.Add(this.panel1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Margin = new System.Windows.Forms.Padding(4); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = "Form1"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "学生随机点名系统"; + this.Load += new System.EventHandler(this.FrmStudent_Load); + ((System.ComponentModel.ISupportInitialize)(this.dgvStuList)).EndInit(); + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + this.panel2.ResumeLayout(false); + this.panel4.ResumeLayout(false); + this.panel4.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.DataGridView dgvStuList; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Panel panel2; + private System.Windows.Forms.Button btnLoadStu; + private System.Windows.Forms.DataGridViewTextBoxColumn stuID; + private System.Windows.Forms.DataGridViewTextBoxColumn stuName; + private System.Windows.Forms.ProgressBar progressName; + private System.Windows.Forms.Button btnStop; + private System.Windows.Forms.Button btnStart; + private System.Windows.Forms.Timer timerCallName; + private System.Windows.Forms.Panel panel3; + private System.Windows.Forms.Panel panel4; + private System.Windows.Forms.Label lblName; + private System.Windows.Forms.Label label2; + } +} \ No newline at end of file diff --git a/201731024118/DianMing/DianMing/Form1.cs b/201731024118/DianMing/DianMing/Form1.cs new file mode 100644 index 0000000..806dbe1 --- /dev/null +++ b/201731024118/DianMing/DianMing/Form1.cs @@ -0,0 +1,123 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +using DaoLayer; +using Entity; +using System.Threading; + +namespace WinformControlUse +{ + public partial class Form1 : System.Windows.Forms.Form + { + List stuList; + + public Form1() + { + InitializeComponent(); + } + + void iniControl() + { + btnStart.Visible = false; + btnStop.Visible = false; + btnLoadStu.Enabled = true; + } + + void setControlVisible() + { + btnStart.Visible = true; + btnStop.Visible = true; + btnLoadStu.Visible = false; + } + + private void btnLoadStu_Click(object sender, EventArgs e) + { + + //获取学生数据源 + StudentDAO stuDao = new StudentDAO(); + stuList=stuDao.getAllStudents(); + + //进度条设置 + int stuCounts = stuList.Count;//及时学生人数 + progressName.Maximum = stuCounts; + + + //构造数据源 + DataTable dt = new DataTable(); + dt.Columns.Add("stuID", Type.GetType("System.String")); + dt.Columns.Add("stuName", Type.GetType("System.String")); + + //数据加载以进度条方式展现 + foreach (Student stu in stuList) + { + dt.Rows.Add(stu.Id,stu.Name); + progressName.Value += 1;//一个学生，进度条加1； + Thread.Sleep(5); + } + + dgvStuList.DataSource = dt; + + setControlVisible(); + + } + + private void FrmStudent_Load(object sender, EventArgs e) + { + iniControl(); + } + + private void timerCallName_Tick(object sender, EventArgs e) + { + Random ra = new Random(); + int i = ra.Next(stuList.Count); + lblName.Text = stuList[i].Name; + + } + + private void btnStart_Click(object sender, EventArgs e) + { + timerCallName.Start(); + } + + private void btnStop_Click(object sender, EventArgs e) + { + timerCallName.Stop(); + } + + private void dgvStuList_CellContentClick(object sender, DataGridViewCellEventArgs e) + { + + } + + private void panel1_Paint(object sender, PaintEventArgs e) + { + + } + + private void progressName_Click(object sender, EventArgs e) + { + + } + + private void panel4_Paint(object sender, PaintEventArgs e) + { + Console.WriteLine(); + } + + private void panel2_Paint(object sender, PaintEventArgs e) + { + + } + + private void label3_Click(object sender, EventArgs e) + { + + } + } +} diff --git a/201731024118/DianMing/DianMing/Form1.resx b/201731024118/DianMing/DianMing/Form1.resx new file mode 100644 index 0000000..92bcdd8 --- /dev/null +++ b/201731024118/DianMing/DianMing/Form1.resx @@ -0,0 +1,1514 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + True + + + True + + + 17, 17 + + + 25 + + + + + /9j/4AAQSkZJRgABAQEASABIAAD/4RdsRXhpZgAATU0AKgAAAAgABQESAAMAAAABAAEAAAExAAIAAAAm + AAAASgEyAAIAAAAUAAAAcIdpAAQAAAABAAAAhIglAAQAAAABAAAA8AAAAShXaW5kb3dzIFBob3RvIEVk + aXRvciAxMC4wLjEwMDExLjE2Mzg0ADIwMTk6MDk6MjggMTE6MDc6NTgAAAWQAwACAAAAFAAAAMaQBAAC + AAAAFAAAANqSkQACAAAAAzkzAACSkgACAAAAAzkzAACgAQADAAAAAQABAAAAAAAAMjAxOTowOToyOCAx + MDo1NTo1NwAyMDE5OjA5OjI4IDEwOjU1OjU3AAAAAAEACwACAAAAJgAAAQIAAAAAV2luZG93cyBQaG90 + byBFZGl0b3IgMTAuMC4xMDAxMS4xNjM4NAAABgEDAAMAAAABAAYAAAEaAAUAAAABAAABdgEbAAUAAAAB + AAABfgEoAAMAAAABAAIAAAIBAAQAAAABAAABhgICAAQAAAABAAAV3QAAAAAAAABgAAAAAQAAAGAAAAAB + /9j/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0 + Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy + MjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCACIAQADASEAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAA + AAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0Kx + wRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4 + eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl + 5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQD + BAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygp + KjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOk + paanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIR + AxEAPwDlytNxX6QfNiEU3FAxCKbikA0imEUDGEU0ipGRkUwikBGRTCKTGhhFMIqGi0NIppFZtFIaRTCK + zaLQhFMIrNloQim4qGihCKbipaKCkxUNDTDFJipaKuGKTFKw7noG2m7a988gQrTStADdtN20DEIphWkA + wrTCKQxhWoyKQyMimEUmAwimEVLKQwimkVmy0NIppFZtFoaRTSKhopMQim4qWikxMUmKhoq4m2k21LQx + MUYpWHcTFGKmyHc9C20m2vcPKG7aTbSGNK00rQB0nhvxBp2jRzJeaPb3gccF41J/XPHSsDVLlL/UJblL + eK3VzkRxLtUfhXJTw8o15VXK6fQ2lUTgopFFhUZFdRmMIpjCkMjK1GVoAYRTCKljQ0imEVDRSGkU0is2 + i0xMU0ipaKTEIppWoaKuJtpNtQ0O4m2kxU2HcTbRilYdw20m2lYdz0MrTdteweYJtpCtIY0rTCtAxCKY + VoGREUwrSAYVqNloGMK1GVpMYwrUZWpYDCtNK1LKGEUhFS0UmNxSYqGihMUhFSxjcUYqbDuJtpNtKxVw + 20m0VNgDbRtpWC5f/te8j2sk8hIH8TZH5Vdh8RyqVEsCOMdQcGlTxM4vXUmVKMlobcN5BcLHtcBpF3Kh + IzU22vShNSV0cbTT1G4pCKoBhWmFaBjGWoytIYwrUZWgYwrTCtSxkZWmFaQEZWmFaQDStN20mUNK0m2o + sO4hWm7alopMTbRtqbDE20m2lYdwxRtpWC4baNtFguVye1KDx9K4bmwschjYOrEMDkEdQa6SLxPCyjzo + GDZ+bYc4rehX9k3cyqU+c3IyssayIco4DA+oNBWvVTurnHawxtq/eIH1NV9QuI9P2rKQZGGQisCQPfHT + 8azqVow0e5pGm5FWHUreZQSdhPBBNWBtZcqQQe4ohUU9glBxGlajK1oSMK1GUpFDClMKUmAwrTClIBhS + m7KQCbKTZSGNKU0qaljE2Um2pY7hspNlKw7hsoEeTgVDsldjvcguZHgwFjZmPt0qulzKWCsg3E8DGK8y + rjmp2hsdcMOnG8ty3c25R+Y2X37GoPL960IYhjOaQQk8570rBc0bLU7vTz8jCSPH+rbOPw9K14/E8LjE + lu6ORxg5Ga6qWJcFysxnRUndEH2m8S4NyChJXBLqrbQfQHOP51G1nDcBRBcB5SPmAU9a5nUfM5dzoUFa + xVksLmC4MUhWN0PIcEYPuMZqxbyXdowCqrqQS2W+WtIV1F8yIdO/umk94iwGQxtuA5QfX1qs2qIisZIm + XBxgHPPpXW8ZG+iMVh5dSzHPDOu6NwRjNDbFGSygfWt1VhbmuZckk7WIUlhmYrHIrMOoB5pxSnGcZq8W + DTi7MjMdNKUwGlPam+XQAmyk8ukA0x0wx0gE2UbPakAnl0nl0mMikdUBIGQOWPoOtV/tCRyjexBx8wIz + wRnIrw8biPaS5Y7I76FLlV3uVTdEMwDj71H2lyc/Ln6VwG9mWY72deGcOP8Aaqyk9uyjciNnqG4P+fxr + t52jnuuo3bb7wcSbM84YEYp0gsyCYZyp/uup/nWsatyXFFVjhsfyOaQcHg1pdMnYmeeWZVjZ2OW6VJ5K + y+bIQAi4yw6HA5/z70noWtRvmS/bEjikYCTbnscUS+bKJIoyX+cABRxwP/r1m7IZXju54GCNyF/gcZra + tH0S8jja5+1eafMEkcbKNp2jyyMjkZznv7cczNySvEqLWzHvbQl2+y7hEOVPPyj05rH1CSeIeQ5GCckj + qeeM1Kk2tSnboUUleObzYmKsvINdBZatDPEBM22YdQB1+lduFr+zfK9jnrU+ZXW5YN9bYyHJB9FNSqyS + KGVgQelehGrGT0ZzODW44p7U3Z7VdyQ8lipYLwOvIFR3DQ2tu8skqFlyAgOcn6/iK46+LUPdjub0qLlq + 9jIk1+WWJU+zwptOflBGf1qza3kd1xjbIP4T3rLC13flk9y61LS6LOz2o2e1d5yhs9qhdUIYyFfKAPXu + cD9K4MfW5Yci3Z0YeF5XZWsUEtpArFR8jMRjnAP+PNU9UjMTpOpADqAR7gY/KvEZ6HUpQqrtgKH6Hk8f + SnRWhm3bQ27Hy7cY/WkO9iMSD3FPEgPRv1rRVEYuA5XPUE8U4O2c9a0UrkWDd3IJzTxICcHj8KtTaFYU + Nn+L9a0Yr2J9kcmI4UU8Yz+H6mr9pfcS0FkWV082MZ3gqHXoPUfypr25IZkkMikbsKc9vSnzIopSKjYK + q5OeSemKgwCeCw9Mii4jWh1sWtj9nWLc+CBIxOR9KxnyxJyalIpCxPsfkAg8HIp7RKAHWQZFMZat5ssF + k+/njIHNdfomg6XcLLNqWtf2dCoLKsls8jMAQM4HHt1zx0rSdXlhdasmMLuzNCbTtJifFtrC3MBXKu9t + KhPrxjtUL6bp6oDBqnmtnLqYWXH+7nqOP16Vn9crJ3aH7GGxVuZraMbYMM4G0uThR+HeuZuFM6vCEb5W + yTtz9PwrFSb1ZdktEYrKVJ9u9CSNG4dSQy8g1opWd0Fro6q2ljubOKVLy38xhh4gr7kPvkAc+xNWFRvK + DMoz329CfautY5395HO8OraC42jHBlIyEH+NR3FsgtXjEUrbV/gzlmPTp1zntXnYiu6s+Zm9OHKrFKS3 + jsprFGfySuMs42nHf73r/WotUvrGRcQuZZFbJymVOPrXM5F3SMdZkWF0aFfmbOc44/CrNtqjWcqyrZ2z + bR8okRiB79efxrOVXsLmbM0HPU0YWnzBrfQUZAyGH1p25h6mrU7Cdh4c07cfQVaqGbEyfTNAfB6kVSqB + YesjDBWQ5+vSphe3K8GVjxzzVqYrITzN+S27J603apOQxB+laKoLVMQRgkkkdc0x42zlTVcw09SJg6/e + U+1SRMcHnaMcmi5o7WuiQs5OTJnnkMuOa1v+Ei1qZUiu764u4ox8qzu0iqPYE0tOpPNYvweIp/M3tNED + 2BiDD6bTkVKt+8yvHHcYic7mQNhfrtpOMQUn1GIYkAWVhI4HzZGME1EskcCSyOQW3E4H8gPwFZNj5kcz + NCd+8NkP8wNR+W+CQMgeh61pdJFKS6j4AyyqwIXvuz0/KukttehgAaRJZnQYXIC5PqeuPyrCpWVrILq5 + Sm164Ny00KLGw+5jOU+nY/iKqy6pqEhTddS5UkqynDZ+o5rkcxXZSbLkndg55/rTBk4A5z2FZymNIn+x + TdWAB9MZ/lTDauTli3pnpWXOmNMri2uycLaTnPYRmnrZ3bE4s7g/SI103Zryjv7P1A/8uNznv+6b/Cl/ + s6/z/wAeU/J/uGjUXKWE0jU2XP2N/wDvtR/WpF0jUd+DZTN64Of60JtkSpsm/sDUiM/2fKuR/eX/ABpw + 8Oaz1Fp9B5if41SuS4W3HJ4fvhzcG1twDjE0wBP5Zqm9kqlgb+zGOw8xv/Za0VxcqW7IYApcB3wvcqpq + 55dr/wA/L/8Afn/7KqVxNR7j0gsduXvJR7C3B/8AZxURS1Df62Vh/wBcwP8A2atoxk+pDcQzbL96WX2+ + Qf8AxVNV4sEI6hT1/dj/ABrRQk+oaW0JR9nz80hxnkDAz+tX4YdOfoZkwOP34H/staqjfeRFx/8AZ9i5 + /wBdKPQhlP8AQUjaTaYBS6m4P9wH/wBmpToS+zJDunuTRWlqibZbi7b/AHVUfzJpPsujKSSb4keu2ueW + Hq9JI0Tj1K7f2V5h2DAJGPNRjj34bmkFhayTMI9TtQCx2gB149yy8fma5p4est9QvF7FlPDbuw2Xli6l + f4bgE5/Kof8AhGtQ3AIlvIM/e86M4/8AHq53CpezRXJ2ZUvNN+wMscs0bSclkRgxX64zUEVsrISELgjA + IXGawlJrRg9HYR7ZVGAMenqacqGGQOCETptBxn61m5poAklLNncFAXA2/wD1qjt4WupGj+1W8fy8tLkZ + /nRGKKSuUftd6f8Al8uP+/hpvnT85nmP/AzXfZlc4haXHEj/AJ0AzZ/1knX+8afKxc5Os90Bj7VcAenm + mnebOTlp5m+shqlTZDqMactnPP8AvHNADdNxx6VoqT6kczHiGQjKoce3SpFs5WGSVUYznNaqkTcTywo4 + weOxppbHAA5rVQSJ1Ym8qxB/DimMWb2qrDS1uRkevNSxjaCc449KC29CTa24KrDPsK6iLwpHNbLPazy3 + 5Cb5BbxHCeoNDulcUUmS2+lW8Uq71uEQjLfu/mHtg1JLYRkFrd5PlI4dMHn6E1EpMpKxSBaL93KpbaMZ + xVZJoVaRHcNhuPpj/P5VFr7FHPzbvNfnjJp0Fvc3Emy3illbriNCx/StOmpKsdfomiXTRAXOgXjnu73P + lcf7pANdD/Y09smLfSrFl7CRi5H1LVw1pNX5Hqaxguxzuoadetcea+mbd3JaKAYPfsP51hyTTpgPE0WS + R8wxXlunNtuQSgyKWUqhJIz6AdqqxxtfbI+GOeSfrSSsriimtTTghitsqqLIwOcsuVB+n+NMkFzfztII + WLcKXZQoIH86iCblzvc0V5e6jEAPYU4Kx6n8q9xU7nO2h6x89M07aemK2UEiGwwfWnbPWtFFslscF5AA + q8kUKoswG5QPmDc4/wA/1q+SwIZIdzmNXywGVPT/ADkU1pJJSVABA4x+FNjuVXIDY24IPrSKGY4Rc+wF + AGpBY281mWYkTYJGDx+NZMsbxttZcH3qVLoMSPG7J6Dmn7pJCEUZ+gpq4MtRxeUBkHJ6nHWt7S9X1nTX + MtneSwbicqhwDnviuhUXNctjP2lnc1G8R6vK2+XUbhpMYJEpH8qrTaxqNyu25vp5VByA7k/zq/qMEw+s + OxFJOJ1+cA4/iHBFYd1E0StIUIcEnOO3auOdP2cuU2UuZXMjJJzVqxa5S6V7WWSKQfxoxBH4iqjHnfKJ + vl1O0tfE2o28ao0/nYGCZBkn8avDxdIR80Sg+wz/AFpYjLlbmp79gp4p7SJB4shJAcBfYk/4Y/Wr1jqV + tqjMsez5Rkncp4/AmvHvZ2Z1xkpbFl9A0+VzNJbQSP8AxExKf1I/nWTr1hpunWLPDaQRDbkvEijjI44F + RUsoN2KsjlPt9pEjFChY46c4+tQya8Q3lxRq/wA2Mrxn864Iub6WDn5dImMIHH3gF+tTKsIHLY+gzX06 + hc89iB0DjKnbnkZpzPHjCRKo9Tya0UEhXIT1oHJxVbCJngdFDdcHmnRiR3ZYkZsnkevBzSuNA9vLHckE + KjxkDaTTZInZWIXJzkY/WpuhjUtGA3SfKo6+tacGqJYoiLYwSrGJApdedzDGT6kY4zQ1cq6Q17h7yZpI + otgY/KP7o9z3+tUrm0mKl2yzDtjtVKlO3NbQlzjcrxW8k0uxVI9T6VtW0MdrFsTk929a6sLT+2zGtP7K + JS/vSeZXbcwuIZKTzKVxjS+etBkO1lJO0ggispwjNWZcZOLuiq1jaeUuwPv3c5PapY0jiXai4FZ0qPJq + ypz5th+4VZtEhluY0mk2Rk/M3oKupJxi2gppN2Z2FhYeH5IkKW6zvnq7kk8+mcelX7S1tbSUtb20Ea8l + dkYQj6183UlKcuaW56kYxirItRyKsmTwzD+Mdf8APNZuraVbalD5Ny7qo4BWQDHvzUNKSsyjk9T8I2tq + itHe3AVPv5jBz09MY61mJpsdtEzBmfacAt1J/wAiuOpCKdkOMOrMR3y2ck03ca+iuefYNxo3nFK7CyL9 + tpsk+TKfLTj6mr6aZaoOhLY6k9K9CjhVy80zmnV1siKOwzNIsszIAhMZVdwZuwPpn1pt+b22eOK4h8lg + g2/IBkeue9cs6Li7M1jNNXRRBkZ87jk96twWhYh5SR7Z5NaUafM7dCZz5UXWSMpsKjb6VF5EABHlgg+t + dkqUG7tGCnIk346UheruIbuApN9TcYhek3+9K4xN3vSbqVwE3Um6lcYm6k3UrgKGpykk1LZcTX0S0ku7 + 5FEhRM/MwOP8967l4IgSyzNHgdeCePXNeFjJL2jselQj7upFHctG7FjwE+VgAQxz2PXpjPt05qxJGGkW + 4RVL7WHB6jIz+Ge/v3rkTNipPGXdXyI3A6x9vz61n6jp6TIuIM7ScBW5xjt0A9aUoqQJ2PLT1pfavWOE + liheWRUA5NaqafAmMgtj1NduGoKWsjnq1GtEXfMpvmV6FzlE8ymzN56qspLBfu5PSplaSsxptbEaqiAB + VAxTi1SrRWgasTdTSxobHYQtTd1S2MQtSZqbjG5ozSuMTdSbqVwDdRmlcYmaTNJsYbqUNg1LY0XLW7lt + pVkicqwP5/Wu60zUl1S27+Z1dcZwf8ORXlY2CupI9ChK6sXWcqTGijanOP4l/PqP6UvyMSQepz8vI/P/ + AD09jXnnShQ5Z2dlZOdo3j73YkY69j/Sq8shiVjLlW2nrkt+ABOTx2B707iseU/YZGPTFTJp6g5d/wAq + +ghhW/iPJlW7F4bV6AdMZo313bbHMG6k3UXAN1IWqWxjd1G6pbGJupN1JsYhakzUtgJupM0rjEzSZpcw + 7CbqTdUtjsGaM0rjsJmjNK4BmlB5qWxolU81p6Vd/Zrtd8hWJshuM498Vy4hc0GdlF2Z16XeQsV4DlWw + jK3oRyPY5/SrsphC4I8tiSVAB79T7/U/4V5N+51ld3k84K8ISA8b/M6Z4GOcj0JJ71D5bSMJEaKI7yis + YzubIztye/HI56euaEM//9kA/9sAQwADAgIDAgIDAwMDBAMDBAUIBQUEBAUKBwcGCAwKDAwLCgsLDQ4S + EA0OEQ4LCxAWEBETFBUVFQwPFxgWFBgSFBUU/9sAQwEDBAQFBAUJBQUJFA0LDRQUFBQUFBQUFBQUFBQU + FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQU/8AAEQgCHAP2AwEiAAIRAQMRAf/EAB8A + AAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFB + BhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldY + WVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfI + ycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYH + CAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy + 0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWG + h4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz + 9PX29/j5+v/aAAwDAQACEQMRAD8A8U5o5o5o5r+2D8UIqKl5qKgAplPooAZS/wAdJRQA2inU2gAplPoo + AZTKfRQWMo8un0yoAbRTv+AU2rAKj8upKZUAFR/71SUUAM5o5o5o5oAj8uo6n8uo6DQZTalpr1IyGjy6 + fRQGpDRT6ZQGo2k2Gn02o1DUjfrTeafRS1DUZzUbx1N5dN5o1DUr0uynUUahqReXTJKlpr1mGpDRT6ZQ + GpFRT6KA1IPLqOrFM5oDUiplPpr1BYz+CinU2gsZTKfR/v1IEVFOem0ihlFPplRqMZzUVWKjeszQjplT + +XUdQWMptPejZUAMplPoeo1LIaKfRRqAx6bTqKz5Sxj02n0VBoQ80nl+XUlFZ8oEf+9TPLqTmjmo1NCK + mU+io5ShlNp1FZgNplPeigsZTKfRUAMoooqNTQbRSbDS1kaDKKfTKkApnNPooAj8ujy6kpnNQWRUuzy3 + qTmoqACmU+is+UBv8dJRRWZQUUUUAN8unUUVBqN/1dFOooAbRRRUgFMp9FLlLGUU+is+UBlFFFMvmDy6 + ZT6KzAZRT6KAGUU+igBlFFFQacwUUUUcogoooo5QGbDRT6KOUD6mplPor9gPzkZTOafRQAzmo/Lqemc0 + AR+XR5dP8uj/AHqAGeXUdWOaioAZRT6ZQA3y6KdRQBF5dElPooLGUx46f5dFQAym06jy6AG0ypabQAyi + n0UAQf71Dx0/y6P9ZQBBRUj1HQAymvUtMqTQbR5dOptA9Rnl0yn0UBqQ7DRsNPptAajKjep6jfrUahqN + 5qKpJPuVHS1DUbspKkfpTHoDUZTP9yn0ySgNRn+7TalplAakVM5qao3jrMNSCipP9ZS80BqQbKSpH6Uz + /eoLGUypabUFjKZT/LplSA2inUx46QDaZzT6KgsZzUVSPHR5dBoQUVJ5dJWHKWRUP+8p1FLlAbTJKfR5 + dSWQ0U/y6KjUBlNp1FBY2o361JSPWcgIuaT+KpKKxNIjOaiqXmjms9TQipuynUVHKUMptS0yswG/7tMq + Wm+XQWM8uiijy6gBnl0eXT/lorPlNdSHYaWnUPTAiop2w0tZ8pYyin0ykAUzmn0VPKBH5dLzT6ZzUFkV + FS80c0uUCKmU+io5QGUU+io5ShlFPplIBf8AdpKXZRsp8oxKbTqKjlNNRtFOopcocw2inU2o5RcwUUUe + XRymnOMop9FRyhzjKKfRRygMo8un0Ucocwyjy6KPL/vUyw8uin0ylykc4UUUVmWfUvl0zYafRX66fng2 + inUUARUU7YaWgBlM5qamUAM5o5p9FAFeipeaOaAIqZU/l1HQAym1N5dM2UAMplTP9yjZUFkMlFPoqwIa + KfRUAQ7DR/u1NTKAG0ypaZsNADH60zy6m2GmeXQBBS+XU3l03mgCvRT6KDQipjx1LTakYymVNTKA1GeX + THp9FAakPl03mpdhptRqGpXoqTy6Z5dGoajNlMen/wAFGylqGpDTKm/3aZRqGozy6bTqbQGoymc1NUb9 + aA1IKKl5qKsyxv8Au0PHTqZQA2mVLTXjqCyGinyUz/eoAbSbDT/96m1BQymc1NTKjUBnNReX/t1LzRzR + qakfl1HVjmoqzDUZTadRUFjaZT/LoqCxlMp9Meo1AKbTqbWRYUyn0VBoQ80c07/WUeX8lSGo3mjmjmjm + s9TQioqXmo36UAR0U+mVmUNop+ykqAIqKf5dFBYymU+ioAY9Hl0+mUGuo2kSn0eXUagNplPpHrMNRtFO + 2Gh6OUsZ5dHl0tJ5dRygN5o5p9FBYzmjmjmjmoAioqTy6XmgCKipeaOaz5QIqZT6Xy6YCUypPLpKz5Sh + lFPoo5QGUUUuyjlASm+XTqKRqFNp1FRyhqN8uin/AMFJRygN8uinUUcouYbR5dOoo5Rjf96inUUcoan1 + HRU2ymeXX6mfADKPLp/l0eXQUQ0U/wAujy/71BIzy6PLp/l0eXQUQ7DRsNTeXTPL8ugCHy6WpaPLoAhf + rS07YaNhoAhejy6f5dHl0AQUVJ5dHl0AQ7KNlTeXTPLoLIfLoqby6joAioqZ6ZQAySmU/wAujy6gBlNq + Xy6ZQA2mVLTaAIeaR6f5dM8ugCOm7Km8uo6AIvLoqWm7KDQh8umVNTKBjKZsNTUypDUiop9FAakPNRVY + qPy6A1IKb5dS0yo1DUipnl1NR5dGoaleinUUtQ1IqZzUr02gNSB+lJUj0vNAalein0ysyxtMqWm0AQ0U + +iSoLIdho2Gn02pAjfrR5dP2Gm0ihnNJ5f8AdqSmc1BqRU3/AHqdRWRYym06isgG0yn0fwVGpYymVN5d + Mo1AZTadR5dZ8pY2k8v56fTajlNBlFPqN+tLlDUbzRzT6KkCN6jqTy6Xms+U0IqX+CpOaio5QG7KHp1F + RylEXl0U/ZRso5QIaKf5dHl1nyljPLop9MoAZ5dHl0/y/wC9RUD5hlM2GpvLplLlLG0U6h46keo2mVLT + az5Q1GUU+ikWMop9MqeUBPLo8ulooAZzRzT6Ty6gsZ5dLzT6Ty6AG81FUvNHNAEVFS80c0uUCKipeaOa + kCKl8un+XS80ARUUvl0lGpYyipPLpKyIGUU+l8ugoSiiigD6pfpSVLzRzX6ofCkfl1HVjmoqYDdlGynU + v+7SAjpvl1N5dHl0AQ+XR5dOpdlADPLpnl1LTaAGeXR5dP2f7tHl1mBD5dHl0+jy6AIqZUvl0eXQUQ+X + R5dP2GjYaAIuaTy6f5dLQBXqRIHk+RaXmnf8DoALbSri6mSKKJnd32IiV7t4B/Zg/wCEivrS3vtas9lw + qO0MLbJl/wC+68t8JyXEd4jx2s+obHR9kPyP/wB91778PfibqcGvQp/ZVrpkKJ881zcb3/8Ai6+Vzqri + owthmexgo0vtnvuh/sW+B18F3Ohzm6mS6lWb7R5vzo6/3Kzrz9gv4fwI8sX2x/k2fPcf+P8A+/XqngPx + cJrHzbnULfY33Nj/AHqp/Ej4gJo+i3Mq3GzYlfhcMdnP1rkhVlufVyjheT4T4n+NH7MWleA9Fub3RtVn + urm0b97bXOzfsr5wr6N+Jn7R83i6/ubK5tfP0rynh+5sd/7nz1893n7y5famxN++v3nI442GH5Md8R8j + jPZc37kp7DS07y6bX0p5pG/Wm81NUbx0AQUVLzUVQAym1M/So6AIqKfTP9+g01GfwU2pZKZ5dA9RtMp9 + FSGpDzUVTv1pvNAalemvUtMoDUb5dMp9Hl0BqQ0x6mplRqGpC8dM8up6ZRqGozmoqsVG9LUNSH/WUypn + 6VHWZY2meXUtNoAZTKmpklQWRUmw0+mf71ADPLpadsNNqChnNRv0qemc1BqRUyp/LqOs+UNRlL/t06m/ + wVHKWMop1NqAGeXR5dPeigsho8un0yo1AbRTqKNSxtMqWm1kAyk8upKKk0IPLpeafRUARpHS80j0vNBo + RUrx1JzRzWeoEVMp9FGpQ3ZTKlpuyswGUz5qloqAIqPLp/l0VBYyin0zy6B8wyin0eXQIZ5dFPoqDQio + qWmeXWQ9RtFOopi5htFO8uijlHqNqPy6kpNho5SxtJ5dP2GlqOUBlFO2GloAZRT6KOUBlJ5dP2GlrPlA + h5pPL+Sp6ZTFzkfl0vNO8ujy6XKMZ5dHl+ZUlJ/s0wGeWlFSUUuUD6n8ujy6m/3abX6SfDakfl0eXUlF + aahqQ80c07y6WszQj8uo6sUUAQf7tHl1JzRzQBFTKsc0nl0AQ7KNlOooAi8uipv46joAi8ujy6m2Uzy6 + Chnl0zy6mplADKZsNTUUAQ7DTPLqaigAhnlg/wBU7J/uPVzTdcutKmeW2lZJnTY838b1RoqJwhUNOaZ1 + dt8U/E9rbpbwaxLBCibNiVFc/EzxLdQzRXOqz3UMybGSZt6VzNMrn+p4e/PyF+1q/wA5HNO0n+xv/uVC + 9TPUL11mYymPHU2ymUAQ+X5dMeOpvLpnl0AQ+XTPLqbYaY8dQAx46Z5dP8ul5oAg2UypvLpj0Ggzy6Z5 + dS016BkL0eX5dPpjx1IajHpnl1NTNhoDUh8umeXU9R+XUahqQUVY5qN+lWGpD5dM8upab5dAakP+7TNh + qby6ZQGpC/Wjy6kpHoDUi5qN+lTP1pj1mGpC9JUnl0P0rMshop1NoAZJTKmooLIaY/8Aq6fR5dQBFRTt + hpj9agobzRzT6KjU1IPLo/1dSc0c0agRUyn0VnyhqN2Uyn/x0lRyljaKdTaz5QGUeXT6ZTLGUU+io1Ai + op1FIsbRTvLptRygR+XS0+io5TQj8um81K9Gw0uUNSLmjmneXS1HKXzkfl1HUvNHNHKBFS+XT/Lpeajl + GQbKNlTeXUdRygN2UypvLo8us+UrmIaPLqby6Zso5QGeXR5dP2UbKOUZDR5dS0uys+UCHy6P9yn+XR5d + HKXzDKKf5dFHKHMM8ujy6fR5dHKIho8un0VHKAzy6KfR5dHKAzy6PLp/+5RRyj5hnl0eXT/Lo8up5S+Y + h2GlqXy6PLpcocxFSbDU3l0eXRygRUU7y6PLo5Q5hmw0VNRRyjPqWipvLpnl1+jHxOoym1L5dHl0w1If + 4KWneXR5dINRmw02pfLo8v8Au1mGpD5dLTnjpaA1GUU+mUBqM5o5p9FBZB5dJUvNHNAyvS7Kf5dD9KAI + 6a9OooKG+XTKfRQAz/gNM8upqZ5dADKKfRQBC8dGw096KAIXjpnl1NsNMfrQWQUyp3pj9KAIXpklTbKZ + UAQ0eXT6KAIdhpj9am/1dNoAgeOmP0qeo3oAjplTvHTPLoAh8uinUUGhF5dMqZ6Y8dSMh2Gh6f5dM2Gg + NRnl0z+Kp6ZQGpXpr1PzUVAakX+9TJKlpr1GoajJKY8dTeXTKWoakL0zy6m8umbDRqGpFzUb9Km8umPH + QGpHTdlTeXTHjrMNSOm1LTKCyKmPU3l0z/WVBYym1L5dMoAbTKl8um1BQymc0+k8uo1AZ/rKXmn0zmjU + 1IqKk8ujy/71ZgQUU+l8ujlLI6bTqKjlGNop1NqBDKPLp7/vKKCyGin0eXUagMop/l0UagMptO8uh6NS + xtFOorIBtR+X/eqSinygR+XS07YaNhqOU0IuaOamqPy6XKA3mjmneXS1IcwzmjmneXTeaXKGonl/3qZ5 + dSc0c1GpoR+XR5dSc0n+9RygM8uo6n8ujy6OUCHZRsp/l0lRylDdlGynUUcoEXl0eXUtL5dLlHzEP+7R + U3l0eXUCIaPLqby6PLoAh8ujy6fso2UAMo8unUuyoAZ5dFP2UlAxtFOooENop1FRqM+qdlGypvL/AL1L + zX3x8gVfL/vUeXU3l0eXQBD5dHl0/ZRsoAh8ujy6m2Uzy6AGUzy6m8ujy6A1IfLpmw1N5dFAakVR+XUz + 0eXQGpFSeX/dp+w0tBZB5dHl1M8dNoGQeXSVP5dN5oAr0VO8dM8ugCOm+XU3l1HQUNpn+/UtN8ugBlMq + by6ZQAym06m1AEb9aY9T1H5dBZC/So6n8umeXQBDTKlpvl0AMplTeXTH/wBqgCHy/wC7THjqby6KAIfL + pjx1NsNM8ugCCip/LpvNAEDx0x46mfpTNlAEPl0PHT/L+ejy6DXUhptS+XTPL/u1IakVM5qxUVAakbx1 + HU79aZ5dZ6hqVvL/ALyUeXU3l0zZRqGpC8dMqajy6NQ1K2w0PHU3l0x46A1IfLpvNS7DTPLrMNRnl0zy + 6m8umeXQGpDsoen+XR5dBZD5dM8upabUAMkplTeXTKCxnl0zYamplSBFSeXU3l0zYaRQ2in0yoGM5pPL + p/8ABTPLo1NBj9KSpeajfpWYEdK9OpfLqCyOm06igBtFOoqAG0PHTqXZQBD5dFP8uio1LGUyn0UagMop + 9FZFkVFOooAbRTqKkBtFO8um0gCmU+ig0I/LpafRUgMop9MoDUKKdsNNoAZzRzT6KA1Gc0c0+k8us9TQ + bzRzRzT6NQGc0c0+o/LoAXmjmjmk8uswF5qPy6k5pPLp8oDPLo8un+XS81mBG8dHl/3qk5o5o5QIqKl5 + o5oFzkVFSeXRQM9aT40vs+bT7X/gF0/z0+b4xSyTfuNMt9n+3K+//wAcSvNLCRI4fK+0b0R/vpv/AOB/ + JV+aOKDZue485/nSHZ8//A99cX9qYr+YX1Oh/KehWfxefen2zR5dn9+2d/8A2dK3rP4leH777181q/8A + 08xOn/j/ANyvDbzUvLm/db/nXe7zJVOHUriCZHa4ZEd/79dNLNsTD4zGWAoSPqKGRLqFJYHV4X+46PvS + jy/avniz8R3Gku8tnqEsHz/M8Kf/AGddPbfFTU7VE3agl0n3P31l9/8A74r2KWd0/txOGeXS+wev0vl1 + wei/GLSrp/K1CKWym/hmRN6P/wCzpXVWHi7R9YZIrbUIHmf7kP3H/wC+Hr16WMoVvhkefLD1YfFE0vLq + Op/LqOu0w1IqY3+zUtN8ugNRlMp9FAajKHp9FAajKbTno/3qA1G0mw0+m0FjKKd/rKWgZB5dLzTvLpaA + IPLpmyp+aOaCiDy/kpnl1N5dR1AEX+/TPLqby6HjoAh8umf71TeXTPLoLIX60zy6nqN+tAEL9Kjqd6Hj + oAh2Ux6mfpTHoAh8uin0UAQ0x46mpnl0AM2GmeXT3paDQgeOo6n8umf71SMgpXjqfmo/LoDUhpn+/U2y + meXQGpDR5dTUzy6jUNSHYaY8dTUzYaWoakPl0vNSvHTH60ahqQ+XTNlT81H5dGoakPl0ypaKzDUi8umV + N5dM8utA1IdhptS0eXWYakPl0x46nplAakDx0eXT/Lo8ugsgpdlP8uo6gBtMqWl2UFkNMqby6PLqAIab + Uvl0zy6AIfLqSnU2o1KI/wCOjy6kpNhoGRc0c0+iszQr0VLzSeXUcoEdL5dP8ul5oAr0VP5f92jy6OUX + MQU3y6m8ujy6g0IfLo8unUVnygReXR5dTbKPL/vU9SyHy6Kf5dFZAMop9MoAZ5dFP8uigBlFPo8ugBlN + qXy6PLqQIqKl8umeXQXzDaKdR5dHKAzYaWnUUgGbDS07y6KjlAZsNLTqP9ZRygM2Glp1FMBtFOo8ulyg + RUnl1NR5dMCHy6PLqSk2Gs9R8wzy6Wnfx0bDRylcwzy6PL/vVJSbDRyj5htFPoo5Q5hNNuktYbl/vv8A + wJ/BUNzP9qd5m++/yVDbSf6759j7P++6d5n+xXzZ0jbn92ny1Wb/AFcNXHk+d/8Ac/uVW/uf98UGkS5b + SJIlzE3m7Nm/5P8AP+3TJpPLfeu5E2f8Dos5/IZ9yLJvT7jp/t0XieZvfYqJ/sJsoHqMSN479Eb7m/79 + X/tbo/mrLLvR96Pv+dKzYZ3km/4Hvq++zY/9zfVx02M5Hrvwr8d6h4guZtP1B/tTpE7pc/x/8D/v/fr0 + Ly68B8B+Irfwz4ktri5+S2dHhldE/g/v10vxB+Jtpqlv/Zuhzyybv9bcL8n8f3E/9D319Pg8yhRw3734 + jxa+FlOr7h6z5dM2V4X4b+IWq6Bcojyy3tn/AMtbe5f/ANAf+B69x0vULfXNOhvbKXzre4Xer16+Dx9L + F/AcNfCzoj9lM8urPl/3aZ5deocupDRT9lJQGpFRT6KA1IaKm8uh46A1IfLo8un+XR5dAakVFO8uh6Cy + Hy6Wn0UDIPLqOp/Lo8ugCF46ZsqZ46Y8f+xQUQvH5lM8urPl0zZUAVvLoeOpvL+Sh46AK2w0x46m8umb + DQWQ+XTPLqz5fl0x46AKtLsqby6jqQInjpnl1Nso2VRoVvLo8upvLplSMipNhqZ46Y8dAEPl03mpdhpn + l0AQ+XR5dTeXTPLoDUheOmVLTdlAakPl0zy6s7KZ5dRqGpC8dNqV46Y8dGoakLx0x46npNho1DUi5qKp + /LpvNIsg2UyrPl0x46zI1K0lHl1M8dM8v+9QGpDTHqaSiSgNSF6Z5dTPHTHjoDUh8v56PLqbYaY8f96o + DUh8ujy6f5dHl0FkL0lSeXQ8dAENFOpfL/vUAQ+XR5dP8ujy6z5SyHy6Km8umeXTAh2GjYam8v56Z5dQ + AzYaNhp/l0eXRqUM2Gm1L5dHl0DIqZzUuw0bDWYiHy6XmpqZRygQeXR5dTP1o8ujlNSHy6PLp7x0eXUc + ouYgoqxzUfl1nymhHRT6Xy6OUCHy6PLp1Po5QIvLo8upvLo8up1Ah8uinUUAN8uin7KNlBZD5dHl1LS7 + KyAho8un+XR5dPlAZ5dHl0+jy6zAZ5dHl0/y6PLoAZ5dFPo8ugBnl0U+igBnl0eXT/LooDmGUeXT/Lo8 + ugBnl0eXT/LooAhp/l0/y6PL/u1IEPl0VN5dFAGPbRvI/wDupTHk2VNa74/nWq00n+kvXy3MeoTeZ5lQ + v9+n+ZspnmfPvpj1H2v3nqzNI8cL/PVZJPnqzNIkiIn9+gNRkMaR23+3Qkjz/P8AwU9NnyVDD/Gm/wCT + fWeoajLz7n3/AOOnw/udktQzfv2/2F+5VlI/3P8ADRqA95PMfZ9/+Cu38A/ECXwnN/Z9xF9q064l/g+/ + E/3Pk/8AiK4JKm897X7j/cdH+f8Av1vh68qM+eBhKlGceWR9XOnz/NTea4Pw78ZNH1KG2i1B5bK8eL97 + N5X7nf8A+yJXfW0kN1CksEqzwv8AdeF96V+iYfFUq0PdkfL1aM6PxDPLpnl1N8kjvtf5/vuiUeXXXzmf + IQU3ZU3l0eXVkakOyjZT/Lp/l0BqQU2pvLo8ugsh8umeXU2yjZQMh8ujy6f5dHl0AQ+XTNhqz5dM8ugC + HYaZ5dTeXR5dAFby6HjqbYarXl9aab/x83EUD/3Hf5/++KiU4Q+MuMJzEprx0+2nt76HzYJVnh/vo++n + +XRzAVnjpnl1Z8umbKBFby6PLqby6ZQBDsNM8upqZsNAEPl0zy6meOh46CyrS7Km8umP0oAh8umeXUtL + soAheOmeX/eqamUAQ7DTH61Zpnl0GhC/WmeXU2w0zy6kepD5dM2VN5dM8ugNSF46Ke8dGygNSGmeXU3l + 0zy6A1IqKl/3KZ5f96o1DUiqN46m2GjYaWoalby/71JU/l0zy6A1IdlGypvLpnl0BqQvHTPLqbZTPLoD + UheOmbDVny6Y8dAakOw0zy6s+XTHjrMNSKo/LqbYaWgNSDy6Z5dTeXR5dBZD5dR1P5dLzRygQbKPL+f5 + am8umeXUAQ+XR5dTeXR5dAuch8ujy6m8vzKY8dHKMhoqbZR/q6gCHy6Z5dTeXRQWQ+XRU3l0yo1Aipvy + VPTKNQGbDTal8umbDWZQ2o/LqZ46NhpDIfLo8un/AOrpakvmI/Lpead5f92loGR+XUdWKKgCvS+XT/Lp + /l0AQ+XR5dP8ujy6jUNRnl0lS80nl0ahqQ7KSp/LpeaNQ1INlJU7x0zy/wDerPlLI6Kn8umeXSAjpdlP + 8un+XQBBRU/l0eXQLnIKKn8ujy6BkFFSTSRWsO+WXyU/vvVC61yytYXdZVn2fwI9ctXFUqPxyNI0qs/g + iW6XZXN/25e6lczQwbYUSJ3fyfn/APH6x4dWu03o9xK6Mn8bP8lfN1eIKEJ+5E9aGV1Z/Gd5sormLae7 + js02pcfaXl2Inzu9Tf8ACR3EF46TpE6ff+T5Hp0uIKE/jjyhLLav2JHQ7KKo2+tQyRg3KPZMeQG/ior1 + 1mmFkr8x57wddacpVWTy/kqs/wC8meprmN9/zff/AL9Vv9XXiandEm8zfTIZKP46fNH5ez51dH+5RqGo + eZ8lCSbH/wCAUz/WU94/ko1DUsvJ8lU/9W7/AO389TJP5dMf94/3KNQ1GInl7KvpImx0qg8nmUzzHkej + mDlLPmbPnWmP/wDZ0yhNu+swHt+4rb0G7isdNmee42I77/JSXY71z15J5dCfu6fOyuRHQx6rd6bbWGp2 + NxLBefOnnI//AI5XVaH8YtT037HDc/6bZp8jed88zp/v/wCxXAJdeZbJbs+zZvdKrPJ9zbW9LFVaPwzI + q0YS+I+tNN1G31jTba9tH321wu+J3TZU3l1wHwd8W2mqeHodHaXZf2KP8j/xpv8AkdP++69CWSGfeiyq + 7q+x9j/cr9EwuIjWpRkfKYil7GfIM8ujy6m8ujy67DEh8umeXU2w0zy6AIKKn8umeXVAR03ZU3l1m6xr + mn6Gm++uFg/uJ993/wCAVE5wh8ZcYc/wFul2Vx83xNt/O2QafcOn993RK2PD/juK4vrbz/DUt7D/ABw+ + bK+//gCbN/8A33XlYjN6FGJ20sBVmbCQPPMkUSM8z/IiIm93/wCAVreLPBuo/D/QItZ8Vx/8IxaTnFsm + o/Jc3X/XK3++/wDvPsRP79b2s/twaZ4M8PxaZ8KvAek+G9X8rZdeILyBJX3/ACf6lN77/wCP77/8Ar5b + 8aeNtf8AHuv3GueJtVudZ1S4/wBbd3bb3/3E/wBj/YT5K+V/tnMMbP3KXsof+THqfUKFH45cxua38Tbi + +R4tMRtOh/57b98z/wDxH/AK5J7qKeH967Pcu+9nd6rTeVH/AHqhTZJJ8r7/AJ63lOc/jLjyG3oPia90 + ObfbPvR/vwv9x67a28fxXVt8tuqTf3Hf5K8uSRo3rV03xNqGlJ5ttKqP88Ox4kdNjp/cetqWKq0Y+6Zy + pQnL3j0iw8YxSOn2y0lgTZ9+H5/nrVttStL7Z5Fwru/3U/jrxy28R3EGxG+dP40/v1vWeqvfQpLB+8RP + 40T50/369HD4/wDnOarhYnpeymPHXH2HjzyLxLe+2+T9x5v40/2/9uuzTZIiOvzo/wA6Ole7SxEK3wnl + ypSgM8umf6uptlMrczIabUrx0zy6AIqZzVh46ZsNBZC8dMeOpvL/AL1Dx0AVtlM8urLx0zy6AIfLpnl1 + ZeOmPHUgVvLo8upvLpnl0GhC8f8Adpnl1NR5dA9St5dM8urLx0zy6A1IfLpjx1Z8umeXQGpW8ujy6m8u + mPHS5g1IfLpnl1Z2Uzy6YakNNqXy6Z5dZhqQv1pnl1Z8umbDQGpD5dMeOpvLof8A1lZlkPl0x46svHTP + LoAreXRU3l0eXSAreXR5dTbKNlPmAreXR5dTeXR5dBGpW2GjYam8ujy6CyHYaZ5dWfLpjx1BGpD5dHl1 + N5dHl0FkPl0zy6s+XTNhoAh8ujy6m2GmeXUAQ+XQ8dTeXR5dAFbZRsqby6jqNQIvLo8upvLo8ujUsh8u + meXU2ykoAr+XR5dTeXR5dZAQ+XR5dTeXR5fmUAQ+XTNhqzTPLoAh2GlqXy6PLqQIdhpal8ujy6AIqTYa + m8ujy6C+Yh8v+9RsNTeX8lHl1nyiIdhpnl1N5dHl0x8xD5dHl/3qm8un+XUahzFby6PLqby6EjpcoEPl + 0/Yaf5dHl0wGbDRsNWUtXk/g/wC+6EgTenmXFum/7m9krza+PwuH/izN44erP4YlbYaNhq/cx6Zaw/v9 + TiSbf9yFfOf/AMcp72tpPCj213Fdfxp5P8f/AACvnsRxJQh/C949Sll05fGcf4zj/wBA2fa4oNj73h83 + 53riZt8EzpLXf69Hbzojy27Tunz/AL53/wC+PkqhbeGdPnR4p0uPtL7HR0uERET+P5Nnz18JiMRPE1fa + yPpMPCNGPIclbRvJM7wbv9U/3KIY5Y7lEX5H/jrp7nwjFH88XmwJ/Gm9/kp/9lRR3Pm+UkG9NnyfPWBv + 7Q57z72G83ru+eX+/V/7cmyG3udPt50d/nf7j/P/AHNlF/o8vyeV5U7/AH/3L/P/AN8VW/sq7uk/49G3 + /wC38lWBcfS2tbVroSqbXckSxs/zKxTdRXYx6M8lrY6a27zkgWZ/n2fwqv3v4qKgjmINV01I/ntvNeFP + k3zJsesq802WP979/f8A+h11s10j2abYvvPvd/8AcqnqUiT6On8ezZX6FynzUpHJJG8jvT5o9j7GTfVx + IPM2bt3+3TJoHkfb9/5PkqA5in5lPjk/vJT5oNn3lZKPLi2fLRqMh/j+5T3kT7//ALPUyWvzvuoS18z+ + PZRqGpC/7uT/AGKPLT50/wDZ6fc2rxun8fyUz599ZhqCR/uaY/7tE/v76f8A6uH5aY/7xHoLGTffSmf+ + yUNH5j/3KEj8yoLHps3/AH6PM8t/lp80D7Eeizg8z52oINvQdYTw/fWGoWO77fbvv3zbNn+5srZ8K/Eb + UvDt5rEqrFezag2+WaZnR93z/On/AH3XIpHNJJTHjeO5eJl2VvSrVaPwGcoRn8Z9XeG9ft/E2j217A6v + vRPNTf8AcfZ86PWl5dfLGieMtd8OQ+TpuoS2ULy72RNnzPs2V6D4b/aBuIUSLXNP+1fN/wAfNn8j/wDA + 0+49fXYXNqUoctU8KrgJfFA9m8umeXXLaL8VtA1++hsoJp0uZm2J9og2Jv8A7m+uphvrS6meKC4gnmT7 + 6JKjvXtUsVSn8EzzpUZw+MPLpmw1ZeP/AGK4b4qarLa6bbafbS7Hu3fzUR9j7Nn/AKBRXxEaMOculS9t + PkGeJ/H/APZVy9vZ28U6Q/I9y/3N/wDcRP468x8+XXNVmuJX3u+95X/4HWlqUCSWyW/mq9z/AHIUrKub + qLSrN4oJUSb/AHN6f8Dr4vEYyeIkfT0cLCiey/BS7+Fcd1/aHxD1LxLI9vdb7ew0jTonhlVP+ezv/f8A + 7iIn+/Wp+0b8U/AfiXVNKT4aaHF4O0i0gf7QqW6Q3NxcP8/z7Hf5PuKnz/xvXgaX13dXjpK9uifZ3mdP + KRER/wDYqbTZE1KFH+z/AD7Hd3RPk+SvmfqUfrH1mc5Hq+193kCHSv3KPAjTu/8ArUR//H0SoZoPkeXy + l2f9MX2f+OV0mm+H7i6hhlX5LZ/uTbH/AO+/kovNN/eOkv8Arv4JkTZvr3qWKpfAedUw8vjOGffGmz7j + p/fpnlv8nyffrV1LSv41+dP4HT56yprWWP8Aj3/3HSt7mFghfy/kZ/8Ax/5KHk8xH+79z+5UM0jx/wD7 + dM/1e/8A+Lp8xHKTQx+e+z/xytW21i3/AOEeS0gXZf73dn+f/wAcrB8zy3/i2UxP3D/NWHMXE6eO+/ti + Hfefu3h+R5k/+Ire8Pa5e+GU+z7FvbD7+zfsdP8AcrldEnW6Z7ee7ZEf5/8AfenzX0ulXKeRcb0fe7p/ + wOuqjipU5hKhGcD2y2uIr62S4gffC/3Ho2V4/o/jG40eZ5bZPk/uP/H/ALD/APxdeheEvGEXiaG5MqRw + XNv87IjfwP8Ax19Xh8fSq+4eFVw84e+b2ymeXVrmo/Lr0TlK3l0eX/eqy8dY83iPSoPvahb/AH9nyPvf + /wAcrOVaEPjLjCc/gLnl02qVt4g0q6uUt4L2J5nTeifc3/8AfdXEkin3+VKr7PvbH+5URrQn8My/ZziH + l+ZTPLqby6Z5f96r5yLMh8v+7TPLqzsNMeOnqIrbKNlTeXTPLo1Ah8umeXU2yh46epoQ+XTHqby6ZS1H + qQ7DTHjqz5dM8ujUCHy6Z5dTbDRsNGoalby6jq15dM8ujUNSHZTPLqz5dM8usyyt5dHl1Nso2UAVvLo8 + upvLo8ugCtsNGw1N5dFAFby6PLqby6PLqAK3l0eXU3+ro2GgCHy6Y8fz1Z2GmeXQBD5dM8v+9Vny6Z5d + AEFLsqby6PLoAreXR5dTeXR5fl1AENM8urPl0zZQBD5dHl1Nso2UAVvLo8urOymeXQBW2GjYameOjy6j + UCt5dM8urPl0PHRqBW8ujy6m2GjYaNQK3l0eXU3l0eX5dAEPl0eXU3l0eXQBD5dHl1N5dHl0AVtlGyrP + l0zy6zAh8v8AvUbKm8ujy6RZDso2VN5dM8ugBmymeXVny6Z5dAEPl0eXU3l0eXUgQ+XRs/3am8ujy6QE + Pl0eXU3l0fJ52xpVR9nnfP8A3ErlrYilho885G0ITrS9whSOsrzNQ1G8uYrNfu/JFsdP3rum9N71q6Jq + tvdOjyxKiNKiRb33/wAG/wC5/wB8b0rHhgt4NK83zZZ3u3d5dj/Ps/uIn/fFfnubZxPET5MPL3T6LB4P + 2X8UZqUdx/oGmQXEr3k0TvcXO9/uf7H++/8A6AlbdnpvkWFtLqe3fM+xIZtif5/26oQ2txa2zyt8k0yI + /wBp+RP9j/vj/wCLrmJrHz7xP+Pd3d/4JfkRP7718jNzqbnrnor77XfFbW6pCn3HR0f+OuS8Q+bAiSrZ + K7o/34fvp/3xW9f6bLJdPZaVpX7lIvOe5R9lcHf2OoRv9ovN0Ez/ACbN/wA9c4zY03UvtWy4dJX2ff8A + nrS8Q6x9ldPNTf8A8A+f/gdc891cQWyPBqEqTP8AO/yVmzardyPvndn2P99/4KcogdhDfW+xH+0W+x/u + Oj1cmntJLZJfKleZP+eKb64xJPMh837P8/3HdH+//vpT7bWJbHZulZ0ffs2S0couY2/tWn6xvRfnm/gh + fYm//c30+aR9N3+V+/2J86f5/jrmPssvkzSxJ+5/j/vpU0OsXcD/ALq42fx/P/HW3OHObi3csy+dGqsW + PzSMHXcP4f0zRWUt3fbzundVf51Vn3D8KKY+Y7XUvDl7Bslg3PD/AAQv/BWJNdPHC9vL9/8AubK9LttH + t5IXRrhd7pvSGaydHT/gaJVPWPDOnyWyS/f+T50R/nR6+7jXPGlS/kPNEk8z7vyJT3k+RH/uPsrem8M2 + jzfuJZ4X/wBt0f8A9kqnf+H9QsURNnn/ANx0Sr5omPJKBQfZOj/J9ymbP93/AOzo894H2TxNA/3PnSmJ + P/A3yf7aPWvuGYPBU3l/J8u5P+B0z/gbVNDJ/fSgBjxpJD/FvT+Oq3kP9zf/AL9X/wDWLsVGqF/3b/xb + KXKPmIfI+5/BR5HyfPUzyfIn3/kpiSf8Do5Q5iF4HkR3VF/26s2di8n8Gyof4f4kqzbfvPk3/PRyhzDP + LeSHY22mQyeQmzylqzs/26fNB5af/Z0eyDmIYZEj+Rrdf++6hmjSOZ5fuf7FTJvkd/kX7/8AHQ8nzv8A + J/t1HKXzFZI/M3/Ovz/36oTR7Ll0rVh2f7nz0x4E+/8AfTfRyhzFCGTy0mRnb5/9uprbUri1SG4iuGgv + IfuTI+x1qyljFv8A4arPa+ZD8v8AHUawL5jpfDfxU13wzD+4uPtULtvaG8+dP+Af3K0ZNffxbeTXuzZM + 0vnSonz7N/8Ac/2K4ZLF/J/i/wC+K6fwfay+dcxRRb/k373T7iVf1iry8k5BGMObnidDbaPcR2yS2z/P + 5vk/J8jun332VWvPCtxNC9w1pK++Xf8A7n996614L26h374oERvk/vp/uVWSO7ntpnubtXh2bPO83Y+/ + +/8A7dYcxvymJpvhW42XNxLb/flREhf7mzf9/wD3Pv0/StNW1S2S+u1spvs/z238b733/wAfyf3K1fE+ + uXFjMlpYxRQbIkeV3l+S1/3E/wC+K49dRt7WaF7Z4nmmfyft94/yJ/t7P/Z3o5pB7p7j8N/iLdfD3w3r + VlBb6Pqlnqex5bbXrWK4SJ0T78W/Z8/z/fqp4g+KFvfP5UXh2w0hHT54bO4uHS42fc3+c7/+OV8/a1JL + HIkrag11M/z703/fq/4e8W3Fq/lXLy3qP9yH+NP+B1xSwdLn5zb2/wBg9UvPFWj3T+bc2jI+93dEiSbe + 7p/t/PWVNa+H54ZvNtN/3EV/srwuj/3/AL6Vz1h4q0rTbyGZU89IZfO+zTP99P7j/wC/Xskfxh+E3iL4 + naVLe+FrzRfBzpsutL0u6lmf/Uu/nI7fP9/Z8lc81Oj8HMaQ5J/GeT6x4f0SR/8ARopYE3/3/wD0De71 + jzeGbd0+SbZ/v7H3V6d4wk8Lz2dzqFtutbN3d7VJvnm2b/kR9n3/AJNn+xXnWlfZ9SmmSLdaunyJ/G9d + lLET5TCpShzchNovh/RIYXtNVtFnd33peQu6On+xsrVk8EeFbiHbFcSwP/fed/v/APA6ZbeDr37M8rXF + qif9cv8A2epn8Of2VbzPc3sUFt/yy8753b/cSu+lmPJ7k4cxyyw0jBvPAf2XVbC3sUvNQ3yojPDb797/ + AOxsrm9ehS1vP9VLB/sTJXbWEn3H/dJbff8A3MXz/wC+/wDcq/HdJfbIoNPW6eb/AJ7Sp/wCsZYz3/hN + I0vd5Tz3RNHe6SaVvNgRE+/s+/8AP9yt6bwj9qmf+z7hUT7j7H+/XTw+MW8IpNcfbbjRbl4nhR9Nlffs + /jTfXN2fxNt47x5Z0uHT+Df/AB/98fcohiJyNvZUuU6HwTpeoeGXuXuU8+wuPveT99H/AL9b1/4ut4ER + LaJrqZ32Im/ZXK6JHLrln9tvJd/nb5vnl3/J/cRE+5/HVmGS3g8648r7nz+S/wAjuj/3P++K9SnmlejD + 2UTllgKU5c4eMPEdxJp/2eNNiXFu7u6fc/2//Q64DRLW4vrb908XnQ+bs3v/AJ/367zWp7STRL9G3T/Z + 97xP/Hsd0+T/AMfrN8JSWOmpDcT6Z5/2dN9uk2zY7un+uff9/ZvTYlefVxFWt70zeNGEPgMT7Lbv4ktr + f5pktLVHSH+O4mT7if8AfdHhuN5/EP7p12Wj/abq837P+Ab/APbf5KZDrkumpeXvlK95NF9jimdN7on8 + bp/t/wAH/A60oYE8P6VDbtFsv5v31w7v8kSfwJ/9hWfPMOQPE/ibzLbeqfvl/v8Az1D4J8cf2XePb6hc + f6BN/G//AC7vXHzXb3Vy7t/H/BULxtHCjsn3/wD0CuuhiKuHlzmFWEKseQ9+h1jT7r/VXtvJ/H8ktXPL + rx/TZHk2fJ8774U/2K29K1i403VYXilbY+/fZ/wP/wDEV9BRz73uSrE8+eV+77kj0LYaZ5dY6eNIp4Xe + CxlndH2bEdKfD4glnVP9Elgd32fOm+vXlmmFh9o4o4Cv/Kavl03msx/E3kb/ALZp6okKf8fMMuxH/wCA + P9z/AIBVP/hLvMdHisne237H2fO/z/cqf7Wwf8wfUa/8pt+X/eqG5nS3T5tz/wCwiVz2veKv7NhS4nVk + 3/PFZpLsd/8AfeuMfx5quq/dS3ghd9iW2/YnyV4GK4glzcmHiehQy7/n6elpqVpJc/Z/tEXnf3Ks+XXi + H/CTXFjePtfyN6fO6fO++rWifEPUtHu97N9ttG+9bzP93/c/uVpheIPe5MREirl3/Po9ieOjy6p6D4js + vE1n9otJfuf62F/vpWlsr66FWFaHPA8ScZ0/cmVnjpnl/wB6rPl0zy60HqQ+X89M8urLx0zy6A1Kzx0e + XVny6ZsNZlkPl0zy6s7DTPLoArbKPL/u1N5dHl/3aAK3l0eXVny6Z5dQBW8ujy6s+XTNlAFby6PLqzsp + nl0AQ+XTNhqz5fyUeXQBW8v56Nhqby6PLqAK3l0PHVny6Z5dAFby6PLqz5dHl0AVvLo8v+9U2w0bDQBD + 5dM8urOw0bDUallZI6Zsqz5dPubGW1m2TxNC/wAj7HXY+yl7SHwByFB46PL/ANipvLo8umQVvL/vUeXV + ny/kpmyjUCHy6Z5dWdlGygCt5fz0eXU3l0eXQBD5dHl1N5fl0eXQBW2GjYas+XR5dAFbYaNhqz5fz0zy + 6yAh2GjYam8ujy6AIdho2GpvLo8ugsh2GmeXVny6Hj8tH/2KiU4U/fmHxlby6ekfmOif36ytS8QW9rZu + 8G138p5ot/yb/wD4uobzxGk/geHUFt2kvLjfCmz7izfxv/t//Z18vj8+oYf3KPvSPXw+XVa3xmrbX1vP + DcvEm/ZvRJnlRE3/AN//AG6yrPTru40vSrf7P8k2+2eaZ/JRIfkdKfJ4ZuNuj2qvbwW1vLvl2P8AI6Im + /f8A+P7KmeS38R3ny3Hn7EfZbffRE+T/AIBv3v8A+OV+fYzGVcZLmqn0NLDwox5ImVfx2Viltb+bL512 + n+u+5s3vsdNn+5vqHStS1DyX82JUtvvxQ+Um/wAlP9v7+yq1zBL4m8VI9s8v2a0i373T5/k/+zrqtH03 + 7d4V164vHi+33fnf8DTZ8j7/AP0CvN5zqOMs/FyT3Mz3iSukKbFhhl2Js3/cSptSk0zUpvKiT7LNs37/ + AL+z/YeuPS3R5n819nyfL/v1c8u4k1VLeX5LzeiPvf79TqaSpwO20fxVLrEN/p8D2GnW3lfO/lbHT7if + I6Vyuq3Xl6rc7X3p9xNn8dVtbsX0PUt9tL/qtifc2VDc2r3SJcRbXhdP4P4P79GoRjEuTRy6bsuFiZHR + 9jpv+dH/ANyr+q30U9y6L5Wx4v7n3H/j+euY89502M7P8+/53p8OpXFrsXe3k79+ylzF+zNK2ung37du + x/klT+Onray3SfaN7O7/ACfvk3o9U5tZf+0prhdm+ZNm9KmfVfL8l9jfOvzv/G/+2lPUz9lIm8yW1dNr + tBsbenz/AHKmubXz3fbLsm3/ADo6VTfVYpPJ8pJU+T5/n3/P/uf3KLa6inh+bbBMn3Nj7KCfZTEjjDbm + MqI397f96irMuoG1kaDUMOYjtVbiBGZf+BL1oo1DlOutvHGoWuyL7Xsh/j+T79aT+Lor6ZPtMvkP/f2b + 64N433fNFv8A9tPv0JI/9xpK+o1PGPWodStL5N8DxSfJs85P8/JTL+11CSwd57tURE3xedKn+dleaWeo + vYzPt3I/3G31q23iOXf+/l3wv99NlLnkacx1qX1xaw/Z5YldETf5yIjon++6UyaRbrZ5+n2s6fxuiJVC + 2j/cw3sEW/YnyfZn2Ps/+Ire/wCEmSS2tvt1lcWqImz/AEaJNn+/sq44gPcIX8OaPrD7/sVxpe/7k1t8 + 6f8AfDvWbq3wy1ixj82xT+27b7+yFH85E/20rY+3afdP/oetyvcp/wAu0yeS/wDv7Hp9t44vdK87/j82 + P87zbN+z/vh66o4giVKJwCSS2szxNF5Dp9+F02PTJrp9+/Ytd/f6rp91C9xPFayO7u/+mRP99/8Abeob + DQ9F1/ekVpFBN/c810/39n8D/wC5W8cVEw9kcZDIk6fL/wAD30+aRI1/uP8A3K3tS8M29jN+6t7pE3/f + h3un/jldJ4Jn0qB5olspZ7xG2ecib3/74/gq/bx5Q9kcAknmJslff8m+nvGkaff2fwfO/wB+vV77Sorq + F/Psop4XfekzxbP/AB/79cxN8OU1KZ/Ke4tYYd7ukyJv/wCAVvGrHlI9mcZ5fz/3KPL/AOB/3K1bzwdc + aajywXCz/wAezZs31jvcPH8jIyOn9/79OMozIlHkGPA/9/YlM8vy/wDbepo7r5E+SmO/3Nr7P9+qEQvJ + /sVJTf8A4ql+SR3TZ93ZUgM+ePZtpk0CbPlp8kH+38lM8t4HrPUB7x+X92XZWlpupXFjcptdX/g3v99P + 9tKyvnkT/bqZJHj+8lLlDmkdPc6k/wBs/f3ESPC+zY+z5E/2/wDP8H+3W3/aVvprzXcWofaoUi/dJDs/ + 0dEf+/8Ac3u/zvsrzqaP+0rxHllVE+Te+z7las2pPBYWbxRMkL/IkL/ceolE64yK1zqqaxN5s7taonz7 + Pvu7/wC3VbRNn9pQpKjPC/8ArUh+/s/+Iqnc745pk27N/wB9K3vD1usem3MuyX7TcI/lPs+4kSfP/wCP + 7EpfZJNW80rT7rTX1CCKV0d0hSab53/ufP8A3K4xI/stynm7vv8AzpXT6rdf2do9no67kTzd8rvFsd3/ + AN/+BEqhpsOn6lr1tbzvKls8qI+xPnl/+zd6f2SZfEM8T2v2WaFG2+cifN/6H/7PTPDcaRzXOoSxf6Nb + /fffs/4AlavjC+fxBraW8Fp9l/5Yom//AL7d/wDP8FXLDSnn0eHT4tv2Z3/jTZv/ALm9/wDc+eolI05S + nNfXf2ma7WylTzvkRN/ybP4NlZth4kl05/Nif99s2OldVqulahHo95dt/Zv2b7m+zl3uqJ/f/j/g2V50 + ++R/79RGPMEjs9e8XXHiaG2T7VLsRHTY7ps37Pk3/PVC8ni1W/s7eLzUsIf3O/c7+bsT53euPm+R99ei + 6V4flks4UiRkR4oZvuPvffWfwGnxhrd9LAltb/bfP3xOmxJX2I/8CbKrWepS2uvWcUCefCj7NkyPsfYl + U/E8l3BJcxSyyvNb3Gz5/n+T76fPT/CUfnzX9wyXHz/6qaFE+X+/vf8A74/77qPsk/aKGpa46ak/npFd + Qumze6bP+B1iP+7/AL2//wAcrY8TyRPczfxzPK//AABEf/2f79c95dbQ2IkbGiaxcaPMnlSypDv3ypC+ + zfXSab488x3iu7f5/uJcw/wJ/tpXDJJT45/v/wBymaRnKB6vDdab4ghe1W7+1fOjyp9x3/2P9z/crS/s + 23n2eVLs85/ndHR0RK8ZSf50f+Pf9/f86V3/AIM8XW91qVtZazrv9l21x8j6lNE7pb/7bonzv/wCsJT5 + InTCpGcveNW/tbfw/N/aESNdXNv89qm/+P8A2K5KzkuNYmvJZ909y+//AIB/fr0vT/D/APbHja28P+HI + m8a/aL9IYptK/wCX1N/30d/ub0/v/c+TfXr/AO158PfAHw18TaJpXg/w1P4Un/s1LzVYZrh38p5X+RHT + e6I6Ij73T5PnSuH6/GFWFL+Y6JYf7Z8e2elXt1fQ2kFvPPcu+xYYYnd3/wBxP46s2fh+91iZLS1tLi6u + XfZFDDE7u7/wIifxvX6H/sc/DP4a698I/ED3ds/iXxVBqFvq91bWyy21zbqibIUtHR0d9m6b50Zd7vs/ + uV4p4W8YeGvhL8XtS8W+EdFurnTbS6l/saz1e4ffZb/k3un8bom/Yjv/ABpveuR5vKU5wjD4Qhg4nhH2 + W4gje3lilguU+SWF02On99Pn+5U0Om3exLjYzv8Aci+f7qf79dt8VPhzLo/xLvNEsbv/AISFL501KyvL + OLf9qS4/fI77PuP8+x0T5E/grnrmx+y2cNvO+9Ef7MkMO/55n/g/4BXZSxHtoRnEUockjHto7fSoUdvn + d/7n8b1TvPFVxJYJL/A8X7qFH/j3/crSv9Nl1Lw39riT99C7zfJ/DsT+P/vjZ/wOqGq6XaaVs2o32/d/ + o8P39u9Pkf8A4B8++t+cmUh8OlSzpbReasCW6fPM/wDG7un/AH3XT/a9C8I2Nsn223vZt/nXXkvv+f7m + z/YSvKPtT6lqV/8AvWRER3+dv4Eqg915ibFuG+//AH6zlHmMOcm8SaxcaxrE13Lcee7f3PuJ/sbP4Kp6 + bH5/8ez/AG9/3KrXMbx/P9+rOmz28F4jzozonzsifx/7FaEalN/9Z81Dx1Nfz+ZczfulT59+xPuVDNsj + d0V96fwPs2VZZseFdfl8M6pDdx/On3JYf76V7Touv6f4it/tFjceZ/fT7jr/AL6V8/PG8H3qfYX1xptz + 9otJZYZv78L7Hr18Dmk8J7n2Thr4OGI98+jKXZXN/D3xVL4q02b7Tt+2Wj7G2J9/f/HXT+XX3+HxEcTS + 54HzFWlKjPkkQ0eXU3l0zZXURqQ0eXU2ymeXUAQ+XR5dTeXTPLoDUZ5dM2GpvLpnl0Fjaj8upvLpmw0c + wDPLpnl1NsNH+ro5gIfLoeOn+XR5dZ8wEPl0eX89TeXTPL/vUcwDPLpnl/3qm8ujy/MpgQ7KZ5dWfLpn + l0uYCHy6PLqby6PLqOYsh8umeXVny9/+5VzRNLu9Ys0e2tGnmmlTytnz7U/2/wDP9+vOxWZUMP8AEdVL + C1axmpC877IkZ3/2K6fRPAD3yQy3l2trbO+yJIU3vL/uf/F1m/ELxU/g6aHT4NPiSa+i8503/JFD/t7P + 7/8A6B/v15RqHxi8UaleQ3EWoPZOkXk+Tbfc/wC+K+UxWdV63+7+6evRwEYfGfTNhpun6G/2fStP86/2 + fPebHd0/2Ed/uO9eafES61XUte82DT2+waYsz3E3yfvfk3v8/wDH/sVytn+0L4lmsLnT7x7d/tD/ADzI + myZE/jRKxPEPxK1CS4S30/8A4l1tEnyJsTe3+/8A7FeHSrV41fazn7x6EoQ5OQ6q2nS6tkli+dHTelP8 + uvOrDxpqFq++V4rpP40dNn/fFdJZ+ONPn2earWu//a37K+9w+Z0qvxnzdXByh8B0Pl0x6mSRJER1fej/ + AHHT+OjYa9jnPPIfLpnl1N5dHl0gIfLo8upvLo8umBD5dHl0/wAujy6AGeXTNlTeXR5dICHZT/Lp/l0/ + y6AIfLo8upvLo8ugCtso2VN5dDukCPKz7ERN7vUTqwpw55lwhOZDsqhc2txdaknlStsh3wv5L/ff/wCI + RPn30TX0V0lyn33T7kKP++l+TfvT/vtKrfDqxt9N+2arfRPPbXFw/wDqd+90/wDZ/nr80zjNJ4ufsqPw + n0+Dwfsoc8/iMfxbpqWuizOsUr7ItkU3mp8ifx70+/8APVb4dR/2qlhFOjT22nvcTbN/8b7Nj/8Afb12 + HxIgeTRbz70/2j502fcTZ8//AKBXmnw7ju5/FkNvYy+Q+x3d/wDYRP8Ax+vkD3ofAekarYxSabqV2tx5 + N+9vvif7nlJ/lKZ8vguwm1C8dZ7zUESG3tnT/j3T7++rkKS6rok37rZNcM6RO77Pk3oiO/8An+/WJo9j + /bF/YaVco072MrzSzI6fMifxv/sf7dWZDLDTZdKvHddr/a4tnyfwJ/Aif3Pn2Vq2F0kmg+IbfT0Z3tPk + eF9+xH/jff8A3P8A4hK2NYhTyba4V1ntoUSaJN/+t/fJ/B/BUPg+O3n8Pa9cMm976V3eFNn7rZ8/ybPk + /v1hzAeIW/lQeTcQS/vkfen+x/cq5fzvrjve/Mly7/Jv/wBhP/i66HVfD6abqUMrbX02aL5POTfvRE37 + EfZ9+uS+1PG6PEv/AB77/Kf+PZ/uUcxZqw3FlrFm6S7kuU++n+3s2b3/AL9YNhJ9lv8AbL88L/I/+49T + R6l5F+l3B8jp99H/AI6fNa/2k7ywRb4djv8AJ/BRzG0fdJtNguI5vskflb3Ten9//c31DeWMs7p5Ttdb + E3v8nyJWlo86X1sluybLm0V5n3/x7E+5/wCP0+HY9tf6hZuqIjuku9vkdH/g2fx1oR70R/iTw+mnWGlJ + Ann/AGiLen3P8/P89Yk1q91Z+bFEqfZ/klTf8/zvXSWHiC31XQf7Knl8nyXd4t//AKBXMeZ9lud6s/8A + t7//AECo1CMpFCOpobV7q6SKBN7v8iJW3baPZXV4nmXDQW1xv2TbPnT/AIBXTzfB147Ca7g1iK62JviS + GL7/APwPfWcom/tYnnUcyySMbh/Lzy0jfxNRT3s5Ip2Vxk4+ZV7NRSK54HW/LQm7ZVP7V/eTZT/PT+9X + 0vMfMcpN5fmfwLQkaff2f+P1Ck/l/eepvO8z5d//AACjmI94v6brN3puzypd6J/yxm+dK6eHxNZakmy5 + t/J/8fSuM8z/AIBQm/8A36iUYzCPunWzQWl1bJ5UUSfP8kyJ8jv/ALdFjHe6VM/2NGgf7/8Ao0vyP/wB + 65JPNj/6Z/8AAqspdXdrs23DJ/wOs/eL9qdVc6xqEiOl9o8TwpF87va7PN2f7n3K56a38zZcLb/ZYbhP + k+zS70/ufc/30oTxJqcabFuP/HE31NYeIEgs5reey8/zvn37/wCP+/WkZSgXzRDTf7bsXT7H9vtf+AOi + PXSab8Tdb0pJreeWDzvuP9pi+T/vtK5658Y3cGx7G4lg2JseF/uPT7yxS6hS70+X53i3ywu/8f8AGlEa + svtB/gNv/hZt7529reVH/wBiXfWlbfFhZP8AXpLv/ubNn/oGyvN2hWP5rnzbJ/4H2fJL8/8AfoSR4/4N + 6V2xxBn70T1F/iFo8/3kunf7jwzP8mz+/wDx1j6xHo+peT9h+1fOn3NiPsf/AOIrifL8vZuSn+Y+/wCW + n9YkRzGrc6PcWu9JYpU/4BWD9q8t3hn/AL/yfPVz+2b2OF4mlZ4f7jvvp6eIJZIfs8vlTo//AD2iR66v + rXu+8PlgVkd9n7p96f8Aj9PT94/y7qrf6v54k2P/ALFWYb6KT7ybP9+to1YzIJof3iPuf7n8FPeTzH3/ + APodM+ypJ88Ev36hm82N/wB6nyV1c5kTJG8ez56H83fs+X/gFQ+emypv9Y+/5d9MASR43fcm9HqaGfy5 + oWndnS3feif7f8Cf7lH+s+6/36rTf7SUpDjIZqUn2p5rtnXzpn3uiJ9yuhs7X7dDZpc3v2KG4iRERIt7 + vs+f+D7n3K57yHktrl1274UR66e+1LT9NsHSL9/eeUkMTp9zZs2O/wA/+x9yuWR1RIfEF9FJ5zSf8flx + LvihdEfyk3/xv/G71T8JeHLjX9YTyvkht3R5Zv7nz/JUOm6VLrFnD5CM8yXHk7Nn/A69F02xT4c+HrzT + 9Qu/+JrqFwieTZ/Ps/g2I/8Af+f5/wDviolPkiEY88ihpti+uateeesT+S/34fk83/Y/9krm/Ft9/Zus + QxQbY3t4k83Yjpvd/v767a81i48I201lBcW/9pX1x87v9+3+T+B/9j7m/wDv73ryWa1eCbyW279+ys6Z + pI6fTftuq+G7lLPTGunf9y8yJ9z/AIHXJXEfkTOjbd6f3Hr0LxPpstjpVnZWfmuiRfwRfI7v/BXnU0fl + /Js2VpGRnIhm2SSJ5u/Zv+f/AHK91ea4urD5nt0/0dHT96n8Cfc2J/AnyV5p4G8FS+ILxLue4WysLeVP + 3zpv819/3ET+Out8SX1pBf8A2LSndEf53e5RN7/O+/Z/sfJWEpc8jaJxnjDWLTVXhuIJW/ufc2Js/v8A + +/8A7FbF5qVr4Z0u5srO4i3zf6SkMO9/n+4m93/uJ/4+/wDsVz2vQfZbZPL8qeGZN6P/AHH/ALn/AACu + k02dZEsHg3JYbESLzpU+5F877/8Age+okQclqUm+83tvd0i2b5vn/gqteWsscKXCxbIf4H/vpXbaJrGn + zpNqd9aWr+S+xZpk3uz/ANxE/j+T/vitv/hLk/s2GKXUGS8e3877m9E/uJRzBynkXmfPR/q66fxBptpd + O9xbLv8AkR32RbNjvXK+W8Hyy1vGRA9/79Hl/wB2lpP4KsDp/APxO8SfCnxJDrvhLXLzw/qiLs+0Wjff + X+NHR/kdP9h6+gPF/wAdrL9ovwr4cl1y7aH4j6Zbtpt+948SQ6lDv3w3CP8AJ86b3R0/4Gm+vlVI6e8f + mJXm1cJCtNVvtHVGtKMOQ9r8M+Jtf+FOrvq+k67faLqK74VuLFtn3/v/AD13V5+0DceINHe38WaZpviu + 8ZNlvrE1qn29Jv8Abu0dHdPn/wBv/cdK8E0fxxdxpDp+oJa3sO/ek15Fvdfk+5v/ALlaupeJrTxBClpc + pKmz50+zbNn/AHxXLUwsJT55QCNWcfhO8h8TW+pWEyS/at8PyRPC77HRE+4jp/6B/t1g3+lXEfiHTbtp + fsUNoiPEkMW/f/fqzD4Z8t7aKC0utLtk2TXVzfv5KRJ/Am9/7/8AsVsQ2Np4fe5ltkWR0dE+0zP/AOgJ + /c+enGUafwF88/tkNnY6hPZ21lBtT7XdO/ku/wA/z/3/APgdVrafTLXxzremQIt6lpau9veXL7977/v/ + AO589dbYSfYdHSX+B03oifJv/uf79crqVjZaBeX+sanLLavcJ9mT+5En9zZ/G+9KPemHMcroPhW7/wCJ + xdSrEieU8Mr/AH3T5P8A7OvN7yxaN3/jf7/yV6LrHxNiutJm0eztFns9uyW5f5Hf/c/ufP8Ax/ff/Yrz + 25nt5H37GT/gdbw/vkFB5Hk+89PWRP8Acf8Agp/l/Pv3/Jv+fZ99KZdbN+9U2I/3UrTUB80nnsk3/fXz + 1Ds/3aE/dvT/AC/Lf+KrAuX6farZLvfLPNv2S70+RX/g2f8AAKoeZW3eQSx+GLDb9xpXmf8A23+5/wCg + JWOieZNsqNSy5o+sXejzfa7O48ib7m9K9g8M/ELT9Ys0Se4WPUk+8iJs3/7n/wARXiE0fkfddXT/AGHp + nzx/PXoYXMauE+A5auFhW+I97ufFr/P5Fp8/+2//AMRVaH4gWkfyXNvKj/cfyfnR68x0fxbcSTQ29zKu + x9kPnP8AI6fP/frodYtfLm/cP58KO6b0ffv/ANuvdoZpVn7/ADHn1cHGB39z4m0+1toZfNadJkd08lKy + k8eW8ly8TWUqJv2I+/8A9DSuPtpEgtkRovuSvv8An2b96J/8RU327/TPtDRfPNv+/wDwfwPW8sxrzMI4 + WkdJ/wAJ/vhR1tF+59zzf4//AIitXTfFWn6ls/e+Q7/IiTfJvrhrO1WS2tooN0lz87on9/8Avp/45/4/ + VOGNJLN7eJ1fbL50Tv8A3NlFLMasJFywsD13y/Lpnl1w3hXxc+nJ9n1Df9j37Emf5/K/2P8Acrrdb1hN + NhTa/wA+9N77d+xPv/8AoH/ode3HH0vZc55/1eXNyFzy6PLrnrDxbcSXNzaXVp/pMO9/kfZv2V0NnfW+ + pQ+bBKrp/H/fSrpYqlW+EzlSnAZ5dHl1Z8vzKPLrrIKfl0eXVny/MoeOlzoCt5dHl1N5dHl/3aOYCtsN + Gw1N5dHl1HOBDsNXNK0O91i58q2i3/33d9iJVm20qLyftFzcRWtnvRHd6s3msPfJDFp9vFp2mtLs/c/P + cyp/7Jv2f7+yvmsxzb2X7ql8R6mFwfP78zkpvDOseH9evIlvbe90r7U6Rb5Xd3/ubK6f/hDruaw81tsG + 9/leb5N+x6uaxqup2NzNaWMVvZeTF5MTwxb5nf8A3/4E2f3Pn/264zXvF39jokqy/arm4dEi+T7/APtu + /wBz/gFfMf2jX5eXmPa+q0ubm5Dv9NsdE0fYkt79tmR0d33olsn+/wD33/2Kh1Xx5LJczaJoe2yR9/m3 + jxfIuxE+4n/fCVwFna/2r4n/ALY1y4Z7C0R5ora2i3o7/wB/Z/v1zfiTWE1KG5lg82C2uP3MUL/O7w79 + jvXkTc6k9TtjEv8Axa1XT5PtiJ+/3ukMTo+996fO7u/+/Xj9bfiGN4NSvIv4ElT5P+AVgv8AfraPuk/E + P/j+SrkN15iJbzu3k/wf7NU0ko/+LrQXKWXjeD7zqj/3P46PM8uoU+5R5nz/AC1XORym94d8TXGhzJ87 + TWz/AH4d/wDn569Os76DUYfNtpVnh/vpXi3me9aug+JLjQ7nzY/nh/5awv8AcevewOYzpe5P4Ty8Vg/a + +/A9a8ujy6h0vULfWLNJ7Z96f+Pp/sVc8uvtYThUhzwPnuS25D5dHl1N5dHl1YEPl0eXU3l0eXUgVtho + 2GrPl0eXRzAQ+XR5dTeXT9lAcpW8ujy6m8un7Kz5+oFP5E/j2VNqUnl6Dc29m8U9/cI6I7vsRE/j+f8A + ubP461U0eKR7NJbje7fO9sif6pP771w1na2upeLdSivLjz0ZEhdJvubHd32f98JX5vm2bTxU5YeHwn0+ + DwfsvfmHw9sZY217VW3Jo9xF9gt7x0/1vz/99vW99litdN+z6QjyQ27uiJNL86P/ABvs/wDH/wDfer82 + pNHonzf8edpE77IU2I+xPkT/AGPkese8sbux02ziaXyHuE864eF/kd3+f7/36+TlI9bUzfiL4m+3eH79 + La3lgtvkh87fs37/AJ9if5/jrgPhvff2b4wtpfs/n74podn3H+dK3viLHL/Y8KNKqJDLsRHf533/AMey + sH4e/Z4/FVs8/wBxInf/AMcqDoj8B7TqsFlo+g2b+a0EOzZEn8e/f9zZWJ4B0m7t0v3b50uLd0id5fkd + N6I/ybPuf/Z1j+Lb6WSb7RL5roibLJEf7nyffffWb4G8azabfvbzxefbXCbJftMvz/8A7FBkeizWqT6l + bW8Uq/3HRE/uJv8A++NmyuY0eT+yvt+3ckN3qE1t5P8AsbERN+z/AHHf5K62/wBLmurn7RB8kMzvv2ff + ff8AJ/7JWbYeEX+2Wdx+9eZLp7n5PnT/AGNiJ/8AF1l9sooeJ5Io0mt7mXfDYukL74t+zf8Af2f99/8A + jleLXlrb2N4+1G+zb/k+b569vvLX7dCkv2e4eG7T7SiTJvd9jp8+z/fryXxhptxHfvu815k3u6On3KrU + 0iY813byX9zLB8kLu+xJvn2JVzw9fW+mpqsU/wB+4t/Jt3T7m/fWJTPM8v8A36z5jp5SzcpcWN4/8Eyf + JXQ+R5fhu2+x3C7LhN9wnlb33/3Heub8x5Idmz7m92/2q7m8sbLTdNs7L7RvvLeL/SET/Up/sb/7+/fR + Exq+4Y//AAiL/wDCMPrCS/PDLslRG+4nybHp95pun31hDNFexPePsSVHfZs/9kp83iB9Hs7yyW3tbq2u + 4tjbN/8AwD/2Sqej6b9usJpfK2Ij/O/8D1pqZ+98ZW/srUJ0hSK0WfYnyeT8/wD6BWrpUHiW1uYUtrSW + f7O+9IXi3on/AH3VzTdNst/mtqEUH2dN7p86O/8A33XSPPNYw3kWn+Q73D77eF/4E/2/9usiOY5XUtGv + YJZY7tJS+4ZXyt3IG3+lFep+G9ci8VWJWK2+3XNuFEyqn3CR/XGP+A0VnKtyuyElzK54087/AOx/sb6P + MX1amPO8aff30eZ5afNFXue1ODlH+Ynz/wCxQn+z9+h/s8j/AOfko8j938r/APj9HMLlH/PG/wD6BTPn + o8u4jRN22h5Pv1pzEco/zJZPuvR58sdMf93/AB/PT3k+/wDwUcwcoee/yVN57/39lQpIknz0eZ89XzEc + hZS6+T+F6EkSN9/3N/8Acaq3mbPvf8Dp8MiSUcxHKaT30skPlSys6f3Jk31WT7PGm9nlg+f76VTST5/l + fZR5j0GnKaVtHFOif6WsKO/3Nn3Ep81q8cz+Vtmh/gdHTe//AACs3zP87Kekj7/l21oLlH+f8/yvvp/m + P9z5v+BpUKXXmfe/3PnqaOTy02f5elzkco/y/n/+Ioh+/wDcinT+4/yPR56f3P8Avij7VFu2fx1fMQTe + XDI/8UH++9TQzpHN+/laeH+NP/Z6p/J95XoSN/8Aa/gq41ZAXHjt5N/kP/H9yq3lvG+z5ko8hpE/hfZR + /pEH97Z/33Wn1iUQD97H/t/7lM+1P/y1+dKenmx0+afzP9am+t44ogfDJ5bvt/jR0ff/ALaUyztbi+mt + rWP55ndIUR//ABxKhTZI/wDCj1veFdSt9D1J7qeKWeZInS3dPuI7/wAb1t9YiWdt8PYH8M6lqSLtuvsj + oksyfc+0f3E/3Pn+eriTpfaw/iW7tNkOk3H+jp8/+kOnz/O/9xPkf+//AAVz2j+MbiCGHTNDlij/AI5Z + kiTe/wDf+/8Ax1Q8TeJru+s/7P3yokLv5qf7f8f3Kx5ec6fsl/w9fXHirW9VuJfNnvH2Ted/Hs3/AMH9 + z5K20tfM8Q6bbs8uy4fzriF4t6bETe/z/wC2/wAlYngbw5LHpVzqbXf2L7RsSLf8juifO7/5/uPWrfzp + Y+Epr3zfPe7ld32fP9nT59if98JVBEZqXia31LXrmVtVlRET5ET/ANk/uVxPiG+tJ7Oz8h97pE6P5z73 + +/8A361dB0vT4LZ7i+luI98v/LHY+93+dEqG2gt5vE8LT+alhaf6TL8ib9n39m/++7/JT+AZq38j+EbO + F/8AXzW9v5MXyfIk3yfP/wAA/wDZ65Wz1h45vN/5bJFsR/4/9v5/+B1t+OdUtZ7j7JBb7HRvuI/3N6I+ + z/brnrC0lkv9n7rfb/eR0T7/APcoj8Jnze8X9bgeTR3l/wBR5Lp5SbP76VW0S6ePTb9F3fJ8/wAn9x// + ALOu28bR3FvoNzbrcRbJpUhd0T7/AMm/5P8AvisGz+yWOlXMUVvFA7/Jcb33v8ifJ/4/UcxfKc94eg+1 + TeSyfPDvdE2fxv8AJVm5ke+16a3WL7LDMnkon3Pk31c0SNI4fN2RO80u9Ef7mxN//s//AKBQkcvnXKMj + eTs3/wAD/wAH3KQzBv55ftMyLuSFP3KbP7n8FU382SPZ8z/+P12drY/anR1RbqGFN67H+ff/ALf3N9Gp + aolrCjwJF5z7/kR/kf8A4G/z0+YyOJT+5LuSlrRm1i9gfYzxP/sbN9MS6+3b/wDiXxPs+d3T5KvmAppJ + 5afcpjyff2/JVz7Kkk2ze0H+/wDOn/jlVrnS7iP7qROn99Ho5hxiMSN5P41T/bemJvkfYqb3/g/36ms7 + G43puTYlTf2Om91373/2P4KjmEegfDePULq2eJLdZ/skuxIbnfsTZ8/zp/4/s/2K9u0Tw+8lh5sssU7v + FvifYj7N/wDHvf8Az89eCab4gvbXS7awf5NEtHR5U3ff/wB9/wC/Xouq/F7ULWFPsOn2ul2334nm/fbE + rzqsfeNYnc3+j2ulabNd31wzwwxbH2J88r/3Er518f8AibUPEGsTStE1qifJsRv/AEOuz1X4t6h4g0dI + r63t38lXRJoYnR33/wDA9n8H/fFeXX+sfbk8qKLy02J/H9ytMPGX2ypGPNH5czo3z1DN/fqy8a7/AJqh + 8j/b+/XTKI4yIafD/cb7lDx/3v4fv0zy/wC7UcpY94/Jqa2/efIsTO7v/BUPmPImz/2Sn2d09rco609Q + 5TttKkim0REiSLzreJ9iTb/kT+N//H3rm7yxisdVRJf+Pbf8+yptH8QXGj3jur77Z0dHT/fT56fqVj5M + 0O12ns5tmyZ6NSDHvI9j/c2Pv/uVWrobex8h5orn52tHTzU+58n/AKGlULyO3k+aC3ZE+f8AjoDmKHl+ + Ylb3h7VfIT7Fcv8AuX+4/wD7JWD5bx09JPLetoS5JcwS9+B2cP7y2RFff/HVmaS3jhTcn3P4657StSmj + f7/zp/4/W8my+hd9kTv/AB/wV7UZ88TzvgHpO9rNbPF/B86PVnW7VLS8hlgTZZ3EXnRI/wA+zf8AfT/v + uoXg8uGFPKZ/4Pkeuts7H+2PBj/6JLvtL1E855URER0f/wCLqJFxOMT/AHP499aWizvdb7JnbyX85P8A + vtPk/wDZK3k+Hrz7JZ9QiRNn/Lsm+t3wb8E/FHizxZZ6L4ctZdRv7j50d98KRJ9/fNv/AIP9ulVkqEOe + bHBc8znGtZY/OuF2u728yf8AA08mb/P+5WrNpv2VL+WDciXErvbzJ8n/ACxR9n/fabK+g9B/YE+Kt1bt + dT3Hh/T4VXf5M147vv8AufwJ/t1t337AnxQsriOCAaJq8Kxf61b10Rn3/wBx0T/frwpZ1hac/wCKeh9V + l/IfO2g6l/bGmpcbG3/cd3TZ89X0geR9iozv/cRN713/AMQvhX4w+F95DoWoaLKl4mzZNZ2Us0Lebsd0 + R9nz7P43SuMsNK1CeZJYre8Szhd3lm8qVERNn39+yvoKXEcJ0tzzJZW+cZf/AA91C73yrerBs2bE37Pn + /j/8f+Sqd14Ou9NuX8/U18l3dN6S7/n/AIP/AECti/kuI4fs9sjec/8Aqk+//uf+h1Wk8K+INVvHi0rR + NW1R4UeZ/s1q77P9/Yn+3/45Xz/9oVJz55TPQ+rxhHk5DgNNutQjvNkTtdfJv8l//Q66e2klmm8prdkf + 7/8Af+TZv3132m/s4+OtH8G2epz/AA68S+dcO8zunkvvTZ+5/cp++R/nf7/+/XIar4Z1vSkSK80LWdEe + 4l8lv7Ssnh+T+4m9P8/JXbQzyUfhmZywEZ/FEoeZF8/zr8nyP89bem6VaPvlnuN/2e42Oib9mzZ/f/33 + 2VZf4ZXceqzeftghR0dE2b/uff8A/Q66G28M29j5zwW7Xtz99U3/ACb3+4laYzO5VaXJAxoYCMJ85zHi + HTZdc8PJb2MUX2abUv3rpv3xJFvd3+T7/wByppoLjWNStoooorKw0/Z5UOx/khdPv7H/AL/z139no/2W + 2RNQvYnmhX968KImz/cT+BNnyVialrmj+HIZnb7/APHN8iPL/cSvmPrjfwnqezKaWv2VNSu9cu1tdK2b + In2bHf8A74/j2fJ9+vE9bgsvsFtcSv5Hky70hmT7n9z/AD/sVval4gl8Tahcu3zoj/unf5ET/YRK5vW9 + KuPEF/YafbXGyG0TfcXO/eif/Z/frWPN9oNShDv8Taqmn2Msrwwy+dL/AHH2f7H/AI5U3jPSorGzS481 + Ue3t3SJE/jfZ9zZ/cq/pusaP4Vtvs+lbrrzn2S3MyfI//wAX/wAArntVebXNQS7vrhnTf5KI6fc/v1vz + hqcx4qn8zUIdr/JcW8Mz/J/HsrEf95XZ3PhX7VZv5txFBNboib/9zf8AJXJX+m3GmvslT/virjIzlEre + XR/q6KZVjiPST/gFHmUz+CjzKfMXyj3/AHf3aEkpnmUJRzEcp0vhLxN/wjN47Sq09tKmxkT/AMcevWdN + uotUsIbqD/Uypv8A9yvBHk316F8L9cih+06fO+xH/fRf+z19JlmP5Jeyn8J5GMwvPHngeheXR9nrHvPE + fn7EsfuO+zzv/iP++HrBtvNnmhlud2xH8597/wACf/sV6mIzelD4DhpYCc/jO28v+Ojy65Wbw/qEFneX + c73EH2vZNafaYtnmpv2b03/fT/bSmaD4jvYJktJ0a9T59mxPn2b/APx/5KilnFKfxFywEoHW+XR5fl1c + 8h5P4Go8mvWpYilW9+MzilRnD4in5dHl1NNJFBs8+VYN/wBzfVB9c8y8e3isrqeZPkdPubKxq42hR+OZ + ccPOZZ8urmmwJdTP/sJv+T+/WVbR6nrk3lLFFaojp5qb97v/ALH/AOxXSXNqmh23y2S2qP8AIiO/zvXy + mY537vsqJ6mFwfvc8zH0rzZ7+8uPN/0ZHR4pv9xPnd/990rkvD1jLqvjybWIrJf7Nt4tj/JvS4m2fwf3 + 9ldPqUaSab9nnu5bWG4l2P8AJsd/9hP9t/uJXSeGNLf+xERkXzreWaFIUdESL+NET+/sTZXwnOe+YM0H + kTeU1utr86faEeX7m/8A2/8A2SsHxd5scyOsXnusWzZ/G+//ANkT567a5hsrSwmlnvYoNn76Xf8Afl+f + 5KZ4Yj8P64+pfbHuoNVRESKGFE2OmzfvelzCieA+KrW7ktppZUXyYXTe/wDf3p/fq/8ADHw5LfXj6m7+ + RZ2+9H+T7/yfP89dn8WtVspNBube2llg2RQpLC/8bp99/wD7CtvwfpSaV4P0fQrN136pF9p1B7lPnR3R + 32J/45/3xUcxvze4ZutwafOkMUsWxNiTImz5/n+f/vjZXnWq/wDEteG78re/2jztmxPkT/Y/8f8Akr1H + xDpWnx3M0vmtDbI7wpNs8nYmxPk/74rz3xPY6VPebPtCvv8A9U6P9yiJj7p7T4V1i01HQfDF1EkWyZXS + X5H++/nJ/H9xE+5Rc65fSQ2dvvlRIbX7NEn3NiJsRE2f7n/fdY/hXTU0PTbO3W9Wf+z9iP8Ax/fff/3x + vd/++Hrp9K0pJLz5kuJNifvbl/43fe+xP/HP9yokXE4y8++lpKnn7HfY/lO/lfJv/wDQ64PxtAlrbbPv + o+xHf7+5Hf8A+wr2mz8M2+paq/zsjuibJpm37/79eXfEvwrd6dsilSKPfcJMkyP/AARJsqI1Yl8piWH9 + maloLxS+Gond32W7vK6bP4K5K5tdPeG2iXTGgvN2x3hlfY/+3/8AYVt389xa3NsnmxJCiJD8jo/3/nf/ + AOL/ALlc8++O5+a4byX/AI/v7KvmiZ851XhXwXo+uX9syXvkJb3qPcbPn2Q7/wDx+pvEOh6hqWpX6RbY + 7ZPnSF22fJ8/3P7+z5P++6x9F1LR9Dhuf+Pi9ubj5JX8pIURP7n36v6x4mh1Kwf/AERkTfvTfs/9DrP2 + sTGVU5uz8HarrFy6Wdp8nyI7v8iJ/wADr0LRPhzcaHYXlvPqCz/aHR08lHTZXMWfxC1LTbVLeCWLYj/I + 7xI8yf8AA3/+Iof4ha3I+xr1ntv7jxIm+oliIl+1kdV/wissdt5UUsSPsR/9V8n+3XefDH4H6n4q2eIL + 7yrKwm2fZ5vs+/emz76f98ff/grwS88TanfKkLXsrw7Niwo/yVZk8a+Jbuweyn8RatNZ/f8As016/k/9 + 8fcrCWKIjI++9A8N+HvB+l2+haRoXmRQr52+Rdgct95nf+N84/8AH6K+CD4k1jULeM3Wv3Rhj+WNZ7h2 + Uf7tFcvtzf2kTlHnbzkqbzno+y/u/wC/TGjf5/8AY+5XqcwvcHvdfvtn/fdTJIn+1/33VPzH++yfOlP8 + z7//AI5TjMiUS/DdNG6Pv3//ABFCTpJ8n36yn/74+TZQkkse92+Sr+sTD2Bsf6x3dV/+wpnmJsd/ufPW + b9qlj+f+D7lWUuk2fMi/d+/W0a5HspQLi/7+/wDgoT+Dc9MSSLzklb/vinwz+XsTbv8A9yt41TAm8zy0 + +Wj7RTPMikdP9/79PeP7m2tucx1D+D5vuUfP99v/AByhP3bp977mynv9z5vkrTmDUNibv4N9CR+WifPQ + n+d9CR/PsVK05jMZ9l8yNP4KHgf7/wB+npI8afN89PeT5Ho5i+YrJImz5t2+npJ5ifK++ppv3n+//t0z + y0jT+FP9ikMZ5dxvT5Nj7P4Kek/luiSuru1Cfcf+Df8A+h0JG8f+3s+f5/46A9wmhvkkf+L5/wCOpvtS + f39lUPLl3/Mn3Pn/ALmynwwLs3/Nvd9iVpzGXJEufapY3+/vqZLrzE/ep/BWb5kscOz5v9yhJ02/6pN9 + HMTyml5dvP8A6p/no8i4j+789UJp/wDpk33/AJ9lCTpG77biVP8Afo5jPlL7ySxv5rffT50entP5++Vn + /wBcnz1T+1P/ABSr8lTJdeZ/y1+erjVDlmdVoPjGLTba2tLnT/tVtbxTIieaj7vN++7/ACVt6xquj+IL + Ozis5YvJtPne2eLY/wBz5/k/jrz2b94/3N++oWtX374rhk2fc/jrSNU0jI9Xmkt76/v7hXZNN0+L5IYb + f5/O2PsRP4PkT59/+5WDrGnefYPKySwTXEqQ7HTf8n9+sfTfE2oQWH2KeVZ7Pdv2TfI/39/yP9+uzv8A + 4jaPqSJ5ulXSOkWzf5sTu7/x/cRP46r6wbc0Tj7rw/8AZb97jUPk3umyH+//AMDq/Z2tlY3NzqEVvcT2 + byon39mzf8/3KH1XSrq5heVL/Zs+SHemz7/3HqzqscupeTFp6f2XYOmx4fvp9z53/wBz/b+5WnteczNW + ztZdV0q2uLOyVES4e5l853fe779/yfx/I9Qpo8um6P8AZ3Sw/wCJh/07pvRPn+RHf7n/ANhVbw94f1iP + ybJZfsVn9o3y3MMTv5SbPn3v/f2JTNKtdQ8VXN5L+68m03vsR9jpsTYn3/krOXMac0inf2v9jp8t3vmt + 4nR/k+//ALCf991iJqt75LpdJ+537/n3pveu8vNK0+6uYf8AQmns1bf8kv3/AJHT/wAc+/XGX/hW4n+z + W8CSumz/AJbS797760iRI5iG6lkm3wbk/wBhKv6lH++/ufJv+RPv1fsNN0/7TDuuJUSH77+U+x/n+47/ + ANyi2kij1i8SX/j8u9jpvi+SL59/3P7myr5g905tN87JEv8Af/jrVvNV+w232eJ9+9/n+4++rkcFlpsz + 7X37U2S703pcb/vp8/3P/Q6yrmC3nea4+47732bKnUfNAzftTyTb23f8Aq/DqXybN/8A32lHkWlum9n8 + 90/gR9iVD5/mQ7Ni7E+5vT+/VikWUuv7z1N9q8j+PZWUkaRum77n9x61f7SuP33yLvf+PZ/BvqNSJRiQ + vdf9Nfk/gSi88QPI6bHigh/jhhT5P++KY195avuT9z5Xk/Ou/Yn36oPH8n/LJKRpAme6ef8Aj+Tf9zfT + 3kSPY8T7HrNSRE/gqZJEkq4yNZRHvJ5nz0fPs3bPufx1JzSPdP8AZtn8H3K0J1GeZ5b/APAKZ5m/5Plo + f94n3NlEkabk/gqCxnyRv/z0oeNKmmgSP51feifx1D/u0DJobqWB/lf5K3k1y31WHyrm32P8ifuX2fwb + K5inp+8T5Uao1K5Ts/D0lvdb4m+/Cj/P5SfvYf7n+3TNbnt9Sd3tlVE83Zs8pE2f7HyViW10lqkN39+b + 50+dN6U9NSvZ7mH7uzf8n+jpsrIgfN/Znyefp91a7/n320u9H/4A9VrzQ7iO2+1wfv7N/uv/AB/8Do1K + xuI7l/8AR7hPn/uVc0SPUJN8USSwJs3u+zZWnMBiJI8fzL9+tjTdV/ff3H/ufwPWreWtldOlvPd73df+ + Pma32Oj/ANz/AHKxLzw5ewO6Ii3X+3bPvreliOQzlDmOqT/SoUlX7lb3hXUriP8AtLTN7eTdxO/3/wCN + Ed0/8c3p/wADrz3RPEF3ps3yvsdPv/JX1V+zL8FR8df7QvtE1jS7nxHbROj6LeXHkzIjps+0/c+dPn2J + s/j+/srqxGNpUaHtZkUqUpy5Dzv4S6pd6dqltqDW/wDalhpL+c+lXnz21x8ju6On+2iV99aP+3F4Gji0 + Tz/CXiJ9ZSJYfsdslvtV9ifIj703p/tvsRay/Dv/AATnj8O+H5EuPFrPqLxfvHttIR0Vv7iPv3un+/Xz + t/wpfxh4V+KlzpWuaPf2Vt9id3v5k/c3u9/k2P8Ac++6fJ99NlfJYjE4bNZfH8J6lKlUon3n46/bA+G/ + gOzud2oNq95bxb/s2mp5yb/7nnfcrxC4/wCCoGk7XitfAV7Pcwje4l1FEj2/wHeif+y18MfEW+vY9YfT + 1SX7Bsd0SHfsf/Oyj4e+FdQ1jWP3tlcJbJF8803yJ/f/AOB1FHJMLGnz1nzFyxVXm5YH2zcf8FIPEuoW + zy6V4F06BGfZF9ov5X27/uO/yJWWn/BQ/wAe2r+Tc+GPDt0n99PtEP8A45vffXh2leEbfSrCbUJ7iW63 + 7JvJ+fZsR/8A9hP++65jXvDN7falZ3EsVrZb/n/4+E3/APjlOOAwPw8o/a1f5j6Jb9vTxRpP2m/k8K+E + LV4W3s8NlN8+9N/399T3n/BSXxFFpr58F6VcvMiC38m6uFRH3/O7r/d/2E/77rxPxJHLJClpbRM8P2X5 + 3hTfsSJPvv8A7Cb64m2nsoZHT7PvhSLZFbJs+f8Av732f7lZxwOFl9kiVSf8x9Dah/wUM+IUjOk3hXQX + lt/nl2faE3Jv+f8AjfZ/v/7ddV4n/acvfid4HGn6h4fs7F72JEuoZrj7WibPnTZ8ibH/ANv76V8q2F0/ + iD/iWWelXl1eP/qobOL7S7vv3v8AInz/AMFd5H8HfFVrpaXGs2U+nWb7Ht7a5lS2mZP76Q797/8AslFT + D4WnohRq1TVm1W0ndHneVLZPndEXyUff/wCPu9Fz4gSOzRIvNtUf5E+TY/8A3x/8XXK6tJb+HN/lXEUE + yfff77p/uf33/wBv/wAfrjPEPiC9nh+z2aN5L/O//PaX/f2fcT/Y/wDQ6mNLmDnOqv8AxpaadDMm9J3T + 5Etkf/0N64aa1u9cmhl+aT7/APsIn+d9U9N02K1tv9M/fu//ACxT770+51WW63+f5sFn9xIUf7//AAOu + mPufARzGw9rb6PbJE3z+Un8H9z/4uuS8Wz/8uUX7j7Qn8D/x/fdH/wB9N9TTSeZeTf62DTbe3+0u6fxb + P4N/+3Vm/wBKi1LUksoLdfOhskvJX2fff+BE/wBveiV1w/vhqedW0fkWz2//AC7W+pJC8Lv8+x/ufP8A + 3Pkqz9q8+aa+n+SFL3ZaoifffZs/8cRP/H60rDSopLDxbbxbftKSw3iI/wB/Ynz/APxdbGpaPbzXNhbt + ZefbWMsz+TCj73f+BH/8cer5ohqcxo8/mabeXHzJbI7ul5N87v8AcrE1XTfs9y8S/wCx/rvnf/vuvUb/ + AMIxXTw/bJdkPm+c8OzYkuz7ifJXnXxCt3tdY82J1eGVN6Pv+8/+xWcavPIiRzE1r8/y/wDfDpsqs+/+ + KrP9oyx/den/ANpQzpsvLfz/APbT5HWt+cUeb7RTpmw1NNap/wAsJfPT/c2P/wB8VFRzHQJvp9FFMBtb + Xg/XIvD/AIn03UJ7eK9treVHltpk+S4h/jR/+AVj0VXMZ8p9kaP4+/Zu03R7DHw48S3V+i75ZodZdPn/ + AL/+UrV8LfExbfVLPStDuvAPw08JXcu+41ptL+3I+z54fOe73yu6b9ifInz/ADvXxvYeKr2xsX0/5Z7P + fv2On3P9x67a2+Ldxa3Pm6f5TpcROl1YX8STQv8AJs3pv/j2fx1wzwkZ9S+aUD3vx5quheKtb+1XPjr/ + AISvVdsyXV/qvlQ/8tvkS3Te6P8AJsfYj7P4NibK4l9Ki85Eg1DfCnzu7ps3/wDfH/oFYlnqlv4juYbi + BLWBJpdmyaJEtn+T7iOmzZ/uVsTQanJeWdu1vao/3IrZHfZ8nz04xlRjyGEpc8gm0rT4/wB9+9/ub9lW + X8OS/JcRXDfOif6Mkr7/APvit5LFI4Xlnb5E2f6lH2JWJqV1/aV1Np8Hyab86XDwo6TXH9xP9z+N60pV + qv2AlCH2zEv55fDNymoSvFP9r3pbukr7/wDb2J/H/v8A3K6Hwl4ZfWJvtuoax/wi+lQvvuLl3f7TcfJ9 + xET79WdE8MXEEO9bdrq/eLY8yfIlun9xP7iJTJtNintnuPtqu6K6RJsd0/ubN9YYjEBCkPfxBpWmpcxa + VZSwWFpE/wBneb5HlfY6fPs+5/A+xP4N9ZX9pPG6XEUsX30dJvv/AHP49nz0zxbYvJDbJY7tiP8AvUm+ + T9zWD4S1K7vobnR7m3id7eJ5tkMv3N6f3P49nyfJXnRnE35Szf2OoeI9etrhUZ7a0fe7v8iO/wA6fJ/4 + 5/33XSJo72s0NwvlJN5WxN/zvv8A7/8A7PXQ+EvCusTQzeRFbzwvKj77lE3/ACJsfZv/AIN7u/yf3Km1 + zwrL/pP9oXrXSPK6IiP5MOz5P7/z7Nn399Y+1NOU4O/k+yzfaPtf2pJnRIoUT5Itif8Aobu+/wD74ohs + bjTdH1XUF3Qb02P8m9/4/wCD+N60n+Gvh+4vIZW83Ylw82+F9jom/wDg/wB//wBkqZ9ctLHXodC0Wy+2 + 6rd+dN88vyRPs+RN/wDvp/sUva+6LlPKPEPiay8VaxYafc+VZWH2rzriaFN77E/2/wDgFeo6b4g8Of2V + YaxfXcSTQu6Km/Zv/gdET7//AAP5N++pvDHwv0qPUvEmoX0UU+pW7pN++/1KQ/wbPub3fZ/3xvqhrHjz + 4aeB9SmTTLRtb1K3+5foiTO7/wAe9/uP/c/uJ/BWPteb3A+EyvEl94f8Qa95UuleQlvLMn2y5dES4R/k + T5//AB+vN/Eng63nkT+yP36Xdw6RPv3osPyIjv8A8D3/APfFbfi34yy+I4fs9jo9va/P53nP9+L53+5/ + B9zZXnv267kmSX5Y3T+NKIz5TGVU+hPBkn9labcpqEUVlbW+xGe5dId/ybP+B/cf5/8A0CmeNvixb6bp + r/YdQsHuWl+eFGSZ9nzo+yvnJ4Hkf5vn/wB+mJAn+f46zlMPaHrs37QV7aqn9no3nf8APa5ZPufwfcrh + tb8VTeKpnuLm68+53/Ik3+f8/JWCkHlps+z/APA6mSP5PKn+Tf8AOmysOciUpFZ5Lv7n9z+59ymPavGi + eb9z76IlTTbJLn5fk+f/AL7o8zy/7tYyqmYLsj+XZ8/36PLlk+f7n/odMe+8v54k+SmPJL/zyb56zlXL + 5ZD3jSPZ93/vumNP/wADplvHLPN9z+/9xK0rbTYo7P8Ae/fd/ubvnRKxlVkP3YlD7U8mzbtTd/4/UKyS + yP8ALuf5/kSr9zfW8D/LF/wP79FzI87w3H+o2t8sKVHMIy9QEsDrGN24feoqzcQTSXErSyea7tvPydKK + z5joI0k8zf8A3E/v0faPLm+/UPmefsT+CnwxpJv3fc/j/wBivb5jPlLP+rf+HZTPkf5vvps+WhI/423J + T/LSN/8AY2VpzGZC8Pmfx/coeP8Acv8A+OVZ8t9/zbfkoSPzPkb7/wB+jmD2syh5fybKPL+T/bq/5Cb6 + he1+d9v8fz1fMaRqkMMnz/79EMj+T/wOn/ZZY0+5v+T+CmPG8exP79HMX7ky59qfYn+5RDdJI+/5kfY9 + U3/d7P4PkoR/Lrf2pnyxLKSS/wC//uVM8/mf+h1Wh+R3f+NNlPhk+f5quNUmUB/25/nqys/975Kp/uqe + kif/AGFX7UzlCJc8zzP49lPeTy/k+VHqgnlSfdp+xa09qY8pceT+D5Xo8tP40+//ALdU4Y/9v/bqaGR/ + ++6v2ouUs7E+8u7+/T3j+T77P/sVWWR/n+ehLp43+b5/46v2xmWU/efd/v0zz32P8nybNiVD9qf/AK6f + JQk+/wD74o9qVyj3n2P/ALG/+5/BT0uqh8/zH+5v3/xpTPMidN7Ue1L1LPmJs27/AJ99Hz/7MlQ/Jv8A + 9bR/q9m1/wDx+r9qZA/z/df/AG/uUeYklts2b0/v0/5496fK/wDuUJ+7Tey/8ArT2pqEM/l/6qVoP4Nl + P8/7nyf98PTPLTY//wARTHjT+/so5zP4i486bP8AWyps/wBimfbnjR/Ndd7/AHPkqHy/7r/J/coeB/uM + m/8A23q+cPdLL338fyv/AHP9yrkOseR+6Xcm/wDuP9+sR0ikdPNVk+R02UyH92n+t+dfuP8Ax0cxfLE7 + O28f3tqkMS3aomzYiOm9P++HqZPHGpyW01vFdxPDM++VHiT5tlcT5cvyfvVf/fShIH/3Hf8AuVpzkezi + ds/i69+R1i8h0f5/7jp/cpj+KtQ2TJEuyF/9b8/397/+gVyqSXEb71erKXUuze3yPVxqmPsjYfxBcSPs + 37E2fc/26rQ30sc0z71RJvv70+d/+B1DDdJ8m7+On+Xbzp9yKtvawM/gIZpIpE+b5E+/8lQw+VH/AH0f + 76fJ89WXtYv7n/j9TeR/d+Sj2sA5jNmjik/gV/7myoZv3e/bWr9hf+F1qF7XzP8AWuuytPaxLjIx7mTf + DWlZwPPZ+avybPk+/wDPv/3KhudDd/8AVbd9TLBNHpsMWx0mT7jp/co5jfmjOJmzSPI/3/8Axyn/AGXz + F/2/++KZ5HkI/wDfq5b/AL5E2p/33SCUuT4AtrG3jT5pUf8A3/4KZNapH92JXT/YqymkvI/zbUpn2JUf + 5VWR/wDZfZ/45T5jHnKD/uPniqF5/M+9V97V9/3GR3/8fqs9r/n+NKOY6YyiQ+f8mynzSJIlVngeP733 + KZvo9qb8pZhk/vUzyP46hSSn+e9RzRL5Zj/3u+n+ZLHUKT+XT/P8z71XzD5Sykkvk+V/A7766dI5dvht + J0aCzfe6O77/ADUd/nfYn3K5L5JE+WtvQZHn+zRRv9x5nf8Ag+TZv30SMA1LUk1K5muP9Qj/AH4U+TZU + yeIPMsEt2uPuP+63/wCfuVjw/aJrnf5Ur/xt8lWZrG4kmfb9x3+5v+5/v1mZ+6XJtc/0ZPIdoE2P8m/f + /wCP1DZ6rcR3KPBcfP8Af+f+/UP9m+Qm9pV+RNkqVQubV7V3Rvvp/sfPQaGxc6k90+yWJbpP4Jpvv/8A + fdXNNutQ0O8TUNPvZdLvIfnie2uNkyf7jpXKp+83v9x/4NlP8y4j+T97/uOlHMLlPZtN/aC8YQfutV13 + VL1P773Du9dhpvxeivtK3z+KIkvN/wA8Nzaum/8A3HTf/wCyV82JJNG+xv4P4N9XEureRP36Mj/79Co4 + efxR5R89WB9XaJ40e+mmdtYiuof79s/+dn/fFWf7c0+Owubi5S61S8f+5qsqJb/3P3Lw/P8A7f8A6HXy + 1DpUt9sexfz/AO4iP89aVtBrdrbO+y6R/vo/z05YGP2Jh9akfQN54glk3/6QsEM33EeJ9n/A3/8AZKrX + +qyxwzXH+hpDv+REdE3/AP2FeJ2esax/ZU3n28r75URLl/vo+z7n/j6PW3ps7yW3/EwdoLn5ERPv/wC/ + vqvqvIYSqzPoLw58btI0CF1174beG9ThlsovssbS3CeU/wBzzvk3v8+/e6f7jpspY/jfd6r8nhXwR8P/ + AA88UW97xNK+1uif79w7p/wPZXh114Z8iZLiDyrp1ff/AH0l/wB/ZW3bWv2FHfYyfJs3/c37P9+vOll9 + L4zqjVqHYeLPiR4i15raW88SrJsR4dmlWUWnIkO9N6f6Oib3euSfWYrdPs8CfI/zyonyb/8Afd//AIiq + yT2/+qgdXuXTfLCn3H/4HWbf3UWmv9oiTe+/5337H2VpDDwgHNKZqvOkib2i2Qp/32//AAN6zdb8XWmm + o+353/54w/cSptKsU1X7TcMmzfsdN/8AfrmLbQ7jVfFU1pFbxfY7F9krp8m9/wDff/gCU+SIHSaVvvoY + ZrlJYHdN+x/kd/8AY/74qaz0P+1X+0Xe5Evnmht4dm9IofkR9mz/AIH8/wDt1sX+jSz2CW+779qiI6Js + 3/7lEMb2MMMSv86I6RQ7N77N/wDHXP8AAXGJc1LSk1KwubTeqJcO/wAiJ/qodiImz/viqfiHUrfQ7a8v + fNfzvsqf6T9z5Ef5Nn+3vq4myN4YvN3u/wC+d3+4ifxvXnvjbfrmsQ6fbJ58127uj/f8pN+z/gCVMfeN + NSn8N76XWNS1K9uW2XNxb/Y/ufI6b0d96V2dna3Ekzyz7Utvkd08377/AO29Y+m6bp9rDNp9ijOiOiXD + 7N/8dbepak9rbJ9mi3u/yRJN9zf/AAUqvxBqTW1j/pM3yM7p/Hs+5/sJXkXxUtUtdb+WWJNiIn2ZH+5X + rUM/l2by79kKJ882zYn+29eUeOdN/wCJxc3HyzwzfP8AOmz/AL4SopfGZylynA0+rb2MX9/yP9/56hex + lj+fZvT++nz16JpGrEip3meZ975/9umfx0tBY56bRRRqWJvpaKT+CjUjlH1Zs7H+0n8qCZUm/gSZ9m7/ + AIHVSijmDlN2G61PwzN5V9aS+S7b3trneiP/ALder/D3xFb+JrywRZfIvLFXmdJn+d/k2b/9uvKNH8Ta + huS1+e6Rvkit0T73+4n8dehaJ8MvnTU9VlWy+zy/8e1nL8//AH+T5ErOrWjGPvGH2j0W8vkvrx/KlleH + fs3u/wA7/wB/Yn8CUeEpIp7ma3sbJn2WX2lJptjp8k2x0ff/AB/x/wByubs9Y1XTtYe0ubdvsaO6S7Pk + e3f76ec7/f8Ak/jr0XwB4c0zTrC51DVdVsLK2aJ0T7ZcRIn30d//AECvIq4qXwQN4xibFhYxXUMNxc3H + 2pIYkeJ/+WP39/33++j7P4KxL+6uNKTZFoiwQ732Pv8AkuHd/uf99/8As9HjD4xeCtKuLaysdQvNeTb+ + 9vLOLeif7jv/AL/ybP7nz15X8Sviwni6H+zNOW/TRIX/AHVteS7/ALiffRE+49efKYSqxgWfGHjTULuZ + NqQQ2bom6FLhN6fP8jps+f5/4P8Abqz4J8B6xJf22saujaD5N08O/VXS2R/77/332V5KklxAjpBL5Fsj + o+yqdz+83+fLLdPv3/O7vvpe1jA5van0nc/Erw/4V87T7nxbZ6vf7ESWazil+zIn8aI6b9//AI4n+/Xn + V58WovtNs7XtxqPkvsl8mLYlwn++/wByvLkkX5E2bHf+/Q8n75Fj2v8A7dY/WIh7WZ61D8ek0bTXt9K8 + KWHnea7pc38ss38fyPs3/wD2Fc23xw8S2qoun3FlpD7NjzWdqiTP8mz77764D978+6Vf+ALT0jf7Sib/ + AJNnzvsrD2ouaZf1XxBquuPv1DU7q+d/+e0rvvqnDB5nz/wJ/t/cpjyeXv8A33/xdQwzxSTPt+4/3P8A + YqPahyzJppPL+7F8lQ+Y8j7/AJaZ8/nfK2x/vv8A30p95Y3dq6Iz73837n9yj2oco9Ps+9N0rPv/ANjZ + 89HmeX86xf8AjlQvayyJD/B5P33d6Z5CWrv+9aebZ/wCsJTNOUek/mfdf5KHmXZNLvZ9lMuZnhtpvk3o + 77/+Af7FHl3Enk/PsTf/AAf39lRzl8o945ZE3s+xE/goSO0tblEl/wDQ99Q3Mf8AdRn37P46Z5HmSff+ + T/0Cs+YOUmSdEmdFTfvTYiVNZyS/6M8n3/uOn8e+oYbH+0tSSKJmd9m+n3Ea2sMLffuZtjv/AOyUAFzv + tXml+/vbYmz5KpzSJs/v/wBz/Yp6QXc8L/6PLv37/kSprbQ72bZFs8je/wDG9Rzle5EhuZPIRPu/f3/7 + dVpr55H+/wDIlbD+H037J7rzHiTe/k/Ps+eiHTdKjZ4laWd3+f5/7lY8w+aBzsdw65mY7Vk5VaK6G40/ + 7bCghteIjswvaijmL9sZHmRbE2p8n/odTf6z7yf8ASqz7JHfb/AnyU//AFiIm+voeYiUSZN8ifN/H9yp + vk3uj/5+eq3zxzQo3yP/APZ0/wAzy3Td8m7/ANkoMZRH+Z8+z+59+jzP3O/7ib9lQ/6xN/8Atu70x5Ej + /wBtHqC/ZllJ/n3095/3P+3VB5PLTYu5/wCN6f5nl7/k/wCB0al+yL/2r502/wByn+f5jujfwVQePy3/ + APH6E/du/wDG+ytCPZRLjyJJ87Ivy0eX99P46ZNd+dv+7sf+Cq0N0/yJv/j+eq5uQj2UyzNAmzf9/e+/ + 79QvH8ibnZP7lMk1Ly32bPnqZ7pJE/77+/8AwVHOX7wzyHjmTbt2f79Hlyxp9ypvMt0Xf/qdqp9yiHai + JtdtlXGqZ80w8yLf9zYm/ZT4ZEkf7jUJI7/6r/YqZP3fzq6/3P8AYrTmMZDHh8yb5n/74p/8H36Z5j/7 + Ej/+gVN9xNn99/uJRzkah99H+8/8Hz0eX5m9F3fc2U9I3j+6+/Z9+oXklk37U+Tdso5w1Jv4Pl+SmPB5 + b/c30/8A29nz/wByoWn/ANiV/wCOr9oZ+8Dw/wAC7vv/APjlHl+ZvoS68x/79PS6ST73/oFX7U094heP + y0fb/wADo8yXZ8v+5VlLpKZ5lv8A7X+/R7UXMQrJLH977lM+1PG+xU+589XPk/v/ACPTHgWSb5tv+5V8 + 5pzR+2Mh1J5H2f7G+pv7SeRdjVD9ll8593yf7dP+yvGnyvFWnOZy5Sz58Un3oloSOKT7u5E/v76reXLv + f513/wAFMffG/wDcSjmI5S48Plp80u/+D50o8tJPvIn/AMRVZJHjf5X/AI6fDdNJJ+/i2On8CVt7U05Q + S1TeifvUpjwPIn399XPPikRFil/29n/fFQzSSyOm113/APfG2tPamfNMrLC/9z/b3pQk9xb70+Z3eppr + qWNNnlfJ/fpial5k3zI2z+D/AG6Pam/vFlLpP+B/+gVN5i/3/n++39yqcN9FI/8Aqv8AYqb5JP8Acf8A + 26uNUwkTJvk2P/t7P9yh7iWN9/zfJ/c/goT95s/9Aof/AK6tv+5V+1iR7o9L7y0+/wD991Zhvk2VTfZI + /wDtv/cffR9l8hPv7N6fP8lXzhyxL/n7/uuqPv8AkR031C87x/d27/8AY/jqt8/lomzf/wCOUJJ5af7/ + APG9acwcpZedJ9+5Njp86b0p8M6R/dRX/v7KpyRo/wB6n/PHsT76Vpzhyl/zEnT7jbKZ5nmb9vyP/cqn + /wBck2U/7Q/3N7IlLmM+UHjlj+7ULx+Z/sP/AAPU0M77/m+eh54o9n3q05hlN4LiN3/jT+NKh/s2K6+d + X2f7/wByr/nxSU9I03/f/wBijmL9rKBgzWssH+tSoq7K2f8A5ZXNurw1Q1LQ7eT51iaD/bT7n/fFGp1Q + xX85zlMrUfQLj78DxTp/v1Qmglt5P3sTJ/vpRqdUasJgn7yr+lXV1Y3ieRu3u/yVQSSt6w0O4kRH+VJv + vxfP9+rjy8phVlH7RNqWpeXNMiuzuj7HeqE115cybfuP/cqymnP9+eLyUh+/v+ffU1npSR6a7zyqjzSo + kX+xv/joOWMYlB9S8t38rd8/yPVm1S1uv9bF8/8AHWVbWNxO/wC63b9/3/8AbrVvoHuPtLqsUc25Hl/e + /ff/AGP/AB96Y5RiDz2kcLps31ZSdfJT5P3P3H2fPsqsmnPcMifKmz77+alMs/km8pnV0f5EdH/joMJR + GPH5fzrb7Pk/uf8As9QpA8fySJvTb/Gn8ddDNptv5P3287f8/wA/yJTLOxSeaFGuIkTf+9f/AOIrPmD2 + pj22yP5IkZH++jw1t2esahaok0UsrzJ/frYv4Yv9Vp/lQWyS7Em3pvdPvvvf771zeq2txptx5Sv57v8A + cT+OiNU2lHnNu88RvdWENu1vKmx97zf7f/s9bej65o9rCitcSwO773d4tlcTNHe2tz5UqbH+Te7v8lXP + MtI96S3crom9N6RO6Vp7eRnyyPQn8aafG7xWd3bwJ/G+9/nqtbarpV0jxNqEXnb9j75djv8A33rg/It9 + j/6RE6P8/wA6bKheOynT97L9/wCT+P7lL2pp7U9Rtp0jvEdd32ZJdjv/AM9dn39j0y/0e31J7C3giZ4d + /wA3nfff+/8AwV51psn9l/8AHtK/39/yS/wf3P8AcrVsPGmq2Nzv3wXsL/Jsm+R0/wBhHSsOY09vE9Lu + fK/4+LOJktt7u6Qy7Pv/ACbP/HKh02P+zbVP7QRbW5Z9/wBjh+d971yU3j+W+f5f+Jd/t7N+z/crVttc + 0ryXlgeKe52fPvf53/77rGUpC9rz/CdJN4j8h9+xvOf5Heb+BNn3N/3KzU8QRal9peC4+SH53m/jRP8A + YSuVv5NV8QTeVLcfZbDytn8CfwfwJV+zurfQ/tMVsks81w+9/wCN3RPuJsrDl5CJVeQ2P7N89HfULtnd + /v8Aky/wf3KrXKWX2Cb7DKyTOnku9t/8XWPdSXF1suL5/ItkeiHxNaT7IluLdP4Pv/P/AN8VEqsg9rVN + 6G7tIE+zwJL/AHIkTZ86U9763tdn+iPPc/wI779//fFcNf8AiNtNmdPK3u/8bp9//gdU7bXLfWLxPP26 + fvX96++V9/8AuVHvTCMqp0PiTXHkfyp7hbKH7/kp8+z/AOzrif3U+qon2hfJf++/zvVyb+z7p/s8H7hE + f/XXPyO//j9ULnw/b2uz/iZrP+6+b90juj/3Pv10xlGBp7o/XtKi0qFJdnyTJvRH2b3/AOAViQyWm/fF + K0D/ANx/uV1v9pafPbfZJ03o6eT5yI6On+3srlZrG3S5/wCWT2yN9/dsd/8AbrSNWAuaI+TzZP8AWpBN + /t0ya1svvy+ba7/7lQvHvmfyP3afwOjffq4kF3Gn+t3/APAKJYikP4Snb6bFdP8AurvYn994v/iKuTeE + r1Lb7RE8V1D/AH4X37Ke8EUk3yp9+iG18ib9x8j/AOx89cssfAv2sjEubWWD/Wpsohglk+6jV095puof + Jut5fnf/AJeW2VW+w+X5264X/YTZWEsxj9gv25lf2U/8W1P+B0+HTYo/9bcNs/2KuPa+Ym9pf4P7lDWs + T79y79/8G+uWWPkR7WR0Oj+Lk8Pw7NP0zTbXemx3eJ3eVP8Afd//AECjUPih4g1Kw+y/bpUtt33IYtn/ + AI//AHPnrBeDy0+RNiJ86f36f/rN+7anyb9mz79cUsRcOaQXOpahfTb5Xlf++80tMSPzP497p/sU+bZv + 379lVn1JI9nz+Z/wCuWVUZZef7/9z+HZTEn/AIG+/wD+yVThkuLqZ/It5X/ufwVNv/cp5qLB8iJs/wDQ + 6z5xcoTXXzpul/j/AI6hmnlkhfb9z7m+n2cDzJC7Jshd/nd1+46VZS1t7GFP3vnzP8/yVHMWZT3Txu6f + NvT5Pn/jqzDI/wA+5N+/7iI7/J/3xVmb93Mm2KJ/k++/z0PqVx5MMVtEyfP89EgGTb4E2S+UmxP3uxPn + qtsT9z+93p/y1/8AiP8Abp9xfWSX/wBqaKV/4Pv/AN/5KmSOKS1e42N5yP8AOn8H9+o5jTl5Sh5EUbu+ + zfv+fZu+RKekMUc32fymjf7+9/n2VZtvs8cLvPFE8zL8n8f8H/fFMuY1ukSXev2naiMiJ9/5P79Z8whn + z/61fk/e7Ed/vvR5fmJM/wC9R0fY7/8AAKHneez+ztMzv/ff+ChJLh7Cb597o7p/t0RkacoxbVPndv4P + k3u/8dWbaC3nd0luPuJ8ny/O77//AByqzyeWj7vkfZ8jv/uf/F1W8y4jmTb991dNn9+pAmeRI0fam9/u + Uee8f3X2Or/98ff+enw2Ms+xI4t7pFvlR32Ov+Xres/A9xfW3mr8/wDz1f8AufJXJKrGHxh7sTm7O1vd + VvEt7aLe+75/n+7/AL9dJD4RTZvluN6bETZClbH/AAisXh3SoX+0M8Lv83ybH/33/wDQK0oZEk+zPpmn + 3F0kyfPsRE8r5/8Ax+uWeIjKPukSkYln4ZsrVvtHzR7Ef53l+7TLmTT7V/3Sb3T/AGNibP8AgFbE0dvP + qttp+oS/ZX8rzvOm3zb/AJ9//AKh0rTdPj863ureWSF0fytj7N7v/f8A/HK5fayM+UxHvkjeGWdPk+// + AMArN1i6l3w/J5FtMnybPuPvrs7a1ijebyk8izmRP9d/AiJ8n+389U3gsvtKReSs/wDf+dNkX9yt41Yj + 92Jzdno93dX6XDIqJv2ff2b6szaHFa3iSs/zumxN6f8Aj6Vpf2rbyTeUtk3zvvSZ4kRP++P7lZVtPL50 + 0s6ee6Pvi2S73+f+5W/tCpSJBLPewRmKF2jI3CNvm20VFcXUayHy9r3H/LT56KXOTucm8fl2e/8Aj30z + /wBnf5Khff5Oxv8Af/4HT3/d7Pn+4j19NzHoco9d8nzt/c+/T5o/LutjfPVB7r5P/ZKmW+fe9LniV7KR + NNG/nJF/fT/0OiGCWd02/cSibdIiS/xu9MtpPLSZP7lX7vMOPw+6WU/eJsb5977P9/56ZcyPJC/yfIj0 + WcfmWFzK33E/1W/+/TIZP9cjO6b3SjmMeQswzpP91Pn3/wDslMs9kdyjTv8AJv2PTNNkt47xN7b03/8A + fXyfJRYfZN7pLu+/v+So5gBP3iQ/wVCkbyXjp/Bv31C915bpt+5v30+Gfy7nfRzG3LIs+X5kLuv396bK + NnzojfOiO+96rXMnl+Tt+TfsotpHkm+V9ib9lHMRye7zll/3nk/7H36PMdIfl/v0zzPL2f8Aff8A45R5 + 6Rx7/wC/89HMZkyXD7/l/ubKekjyfe+4n3Khh1LzIX/vp8/+/T0vot6J/Bt+WnzEShL+Uspv8nZ9/wD2 + 6Eun2J/u/fo+1ReT/t79lH2633/7H9ylzHLySHwxyyfx/I//AKB/HUKRvax7Vlb5037Ks/areP8A743o + lD3UW54v49n3/wCBKOcdpj3gl+TZLv8A4/kT7lWV06WT97u+d3+dPuf7iUyHZI/zS7N/36uNGlqn72X9 + y6I77H+f/vij2ph75Wm0q4jR03RTP/0x/gqtNBLH8nlMmytWb7FHMi212s8Mz7Pnf50/26feX1vvTc6/ + ZkuNn++myjmmHvmO8byTfcbYn/odM8yWN/4v+B1t/wBm2l1CksF6vzv8/wB96oXNq8Dp96f5N6bE/v0R + lMuKIZJ/LfZ/31/3xTI7qLc6K/z/AH231TfzZH3q+x99EnmxokTeU/8A7Mn9+tOaRfsol+GNZJP4v77/ + AO5UzwP/AH2+5v8AuVleXcQbH+X7lTJPcRp8yfP5v3Kv2pEqRf8AL8x/v0NAkPz/APfFU7mR5PkVP+B0 + xJ7iRn2yt8mz5HSt+cj2Rf8AISN9kT/x/cSnva/ufldv9h9lZth4g+w3L+fF/vpV+Hxp5aeV+9hT59j+ + b/BRKUypUKpC0Dxp8216E/d73/4BUM3iC3kR0aXY/wDfSqb6rcTzfutz7/4ETfV8xpHD1ZGl/rH+/sf/ + AH6Hk+f5fn/jrNf+0JE2fZ7hPn/55PUPn3sH3opU/wB9HSr5zf6tI1fkmk+ZPk/26mSH5/kRkT/YesqG + fU5P9Vbyv/uRVZhg1uN0lXT7/wCf/p3f5/8AxyjmM/qsjSSD5Pl+f56uJHKn8f8AwCodK0fxBqTokWha + ldb/APnjav8A/EV0ifDnxh9yLwvqk/8Af/dPT94wlhZHPeX/ANMonp/meZs3VvP8NfGsEb7fCl+nz79n + lUP8NfHElt/yLl+ju+/59iVXvE/VZnPPtk/26e/7xHrbm+GXj2S5f/ilNS/2k+T/AOLpk3wn8dyfd8L6 + oj7/ALnlVpzTL+qyMpP3jv8A+z0z7K2/5XWuhX4Q/EOdE/4py/37HR0fZ/8AF1q6V+z1441J/wB/pjac + mz77yo+/+58lHtZh7CRxk0bx7P4/vpR9luPsyf6O+zZv316pD+y944jREtpbL5P+e0v/ANhVbVf2b/He + lb/PuNGRPv7/ADX/APiKv2shewkeYpG/+/8A8D+9RNB5n3vN/wCAV6LD8HX8l11Dxn4Xgm/jT7bvff8A + 7fyUf8Kd0/eif8LF8L2Xyf8APw7p/wCgVvzTI9lI83TTftSb9jf7+/ZRDpX915f7/wB6vV4fhXoUCP5v + j3w5On3/AJPN/wDiKhufhPpn/HxbfEjwvao/8Ez3G9P/AByj2lUPZSPMfsNx9yKX/c3pRD/aEf3v4/8A + br0u5+Genxw/L8RfC7/7EPm//EVpQ/CvRfL3/wDCwtGff9/Zay76PazNPYHkqSXECfcbZv3/ACJVyG6W + NPmtd+77+/7j16pN8M9CjT/kcLf7j/OmnyulVrz4V+F4f+agbPk/g0K7f+//AJ/4BR7eZHsDzeztdPkm + d4rf7Lc7PubPkq/HdJAjxb4t/wA773eukf4e+Et6bviKqJ/2Bbuq3/CufCkezb8ULP7/APHpF3/8RV3q + mcqH94yn+w3Xz/aGgm2J8nlb0rNaO4+07F270+dNiJ8n/AK62H4a+FPvN8WLBNn8D6Vd/wDxFWY/AHhL + /lr8SLedE/jTSrhHpxlV/lIlT/vHDTQPJ95PuJs+5Vby3+0pL9x69CT4c+DI0/5KA2/++mm3FWU+Hvgr + 5/8Ai4sqf9wq4raMsR/z6M+X++eaeQm/5pfv1MujrBf/AGuW4im2P8iV6E/gPwZ5zuvj6637Nm9NFmdP + /H67l5PhZP8AvZ7fRnuf76aRfIj/APAN+zfR/tX/AD6kXGMf5zxB45ZE3tLF86fxvVBo4rV02uzuj/c8 + r5Pv17Zf33gSNNltpmh3Sf3EtdQhf/0PZWal14Hkf974Kaf5/keHVbhE/wDH66o4XFT+wY8sY/aPKIbq + 4d4fk2Im/wC/RbaxLa3Dy+b+++TZNs+dP79ewQzeB4/u+BH2f7eoO7/+gVDcx+CZ/wDmUr+D/rjqSb3/ + AO+0er+p4r/n0P3YfaPJZtcfzN7fPs/gfZsqF9cln2Jvl/2HRa9Xm0PwPdJsbQteT/uJWn/xmrlt4O8D + yQ+Uuj6zB/cm/tW03p/33sSolQxEP+XRceWf2jxB/Nk2TeVL/wADSnvDLI/3P+B769yh+E/hqS5/dS3S + Q/f3zalp7ulX0+BfhSSTzW8QXm/+49xYv/6BXFOVWH2Db2cpnz8lr5ez98qf8DoSF/n23a/7dfQ6fAvw + pJ97W7z/AHE+xf8AxdY/iD4A28iJ/ZF638e97y6t0/3PuV5/1qp/IL2EjxaGRI3+a4/74ShpLeT52l3/ + AO3sr1Gx/Z61BJv9O1C3eH+P7NL86f3Pv/fqnN8E9bjuZkgSweHf+6d7pEf/AIH/AJeo+t1OwewkcGl1 + FJCm3+D76bPneth9cl+wJFBbxQQu+9IUife//A69L0H4J28kKf2vb3E+pb98sNncJ5P+x99K25vgz4cg + f97ol07/AHNn2hErlli6n8hvHDSPFrjxbqdjbJp8tl5Gz+B0+d6xJt+pPNK0WxP9dsd9if8AAK+ltN8A + aPv3/wDCNSzun8by+d/7PWxbeB7e1eFbPweqQp9z/R0+SsPrtSP2Dq+qyl9o+RfIeTei/Om/+/vrSTw7 + LPD5rbt/lb/n3/39n+dlfWKeGbiNHT/hFLhE3/8ALGy2f+gU9PD93I+//hHL9Nn/AE7vWEswxH8hp9Uh + /OfKNn4V1O+mmSC33+Sn8aP/APEVZT4c63IiXE9lsR3r6o+w3cibP7KvE/20sqxE8P3Fu8P+l+I0mT7m + y4dK5fr1b7YfU4fznzx/wr24h+SV4oZpk3pCi732b/v/ACV0ln8IdTkhhdYood67/uf3/wDfrqvFv/Cy + J9Ym1CxiXTptn2ZP9Ii3vD9/53f/ANkrKTR/FtilteyXF5e3ljE8KTQyo82z77p/t1EsTP8AmMfZ0ynD + 8K/+EfuUfVbuwghmfZEly+x9+z++n/fdY/iTwJZWth9ovNQtbKzd0mT7G/nO+9PuJ8/3P4/n/v0ybR/E + HiC8+bStcn3/ACb5otif99vsqhrfg670eH7XquntZQvvRH+2pM7v/t7N9R7Sf8wcsfjhEzZtV0+DTdlt + b6jNNC6ffdE/772VlSawkj7GtGS5R3/fbt7/AOxU3mWkk3lWyfarlPuJv3pXYQ6VF9m2RRMj/cRIfk31 + rKryHNqcfNdWt1p8PyS/J8kT/cT5/v8A+/UNna/a5pvKt5Z5vvuifJ/6HXYLoej6XZu6xed5PzvD5u/5 + 0/vvVa21LT5PktkZJpt/yO/yIj/PWPt/5Bcpz01v9lXdO9um1N/39+//AL4/4BV+Gx+3b917EiP/AMsU + +R/++Kv3+sLaww7rtZ3f7kPyJVDRNV+3axN5FldXT3GxPOhid9n/AI5WftZC5JyGXljb2r/fln2P8+zY + iVjzSWlrsddzv/sP/wDF13OsaOkeq2dvc29xe/I++H7PsRH2fJsrntYtfsty4gitbWZpfm3um/Z/n+Ci + NU05ZFPTbG01Lzv3Xzv8/wA8u/b/ALdatumlWsL/AGOKKTa+xX2/Ov8Af2VWupNakR9zqibE/wBS6b0/ + 2Pkqs39pzon+kNC6fPv/AL9EpcxEjVSN55ESW42eT++TZsrHtp0vryZ2uIt7S/fmi376LPSpf9GRZW2b + P7n3Pnq4/g/y7l3WXZC/yPv/ANv/AG/79RKQalZ/s8+9/mukhT7if3Kyprry3R2dfJd96eS/8H/xddnc + +DorHe7P99Pk+f7/AN/5P/Q6zXtdKtYZpVRf3MqJveLfveiNU2+Ex1ht4Pn+z79779jy/P8A7FVn/eO9 + 3+9dHfYnyf5/3K6R3tI9Ed2il87Y+1IYtjo/8FMh029j0VLe7u1SZPn8mFPu/wDA0+/WcqpEfdMR7X7V + 50U8UVq7psWH53/j+TZVxNDeP5FSXe/+tf7iVpWFjNqkNs99L5CQsjv+6+f5Pn+//B/uVpPJ5jJcReak + KPv3p8if76VjKqXLmOY1jQ/srpcN5vyfI6f7b/P9+mW2j28d4lx9r3ps37Ei2b/n/wDQK6S3tbjUrnfv + X7N99H++/wDvv8n3KZqUcUc2yKK63p8nnOmz56OeQe8c9JpSPcTJBbs+z+CaX/x/5P4KP3Wl7JWlWBET + 5/8AbrSSOW6d/IRk/j3wps3/AOfnpl5pujvYQzXiXT7Itj/x/wDjn8FHOEff+MxEk0/7TDLKm9G2fc2b + ErpLPQ9Pm0p5Wvf9D2Pv2Ns2I9VptNspIbZLaLfC/wA7pN9yrL2tv86QPLao/wDyx/g2USnEsxLm4tNL + e5ig8re6bHmf532f7FTaVrGob7OKzlZPJ+dHf+D/AClUH8MpNeI3my/8ATf8/wD8RW9Z2tvpSPFslkm2 + fcf79Z8seX3wOhsLXz7Z9V1yW6nm+d0T+CthNct7FHis9uqXLoiS7FfY77E+4/8AGif+yVxNtJb/AGab + bFcbPkf79XE1X/Q4fsduyTW+9E3v8++vMqUOYcSbWPE1vPeJcReVPeb/AJ/7nyfwJWPDqWpyXn22e337 + EfZNMmzZ/uf/AGFM/wBI/iuG87+BH/v/APxdTabpUs+97m4+fyv+Bv8A/YV2xw/ue4HxlO/ur3yUuP7Q + ld0X7mz/AMc/36hTZve4iu9k2xN/zp/6BRcWNxPbTIr70TemxET5f9ysS28P6rJ+90+0urr5/n+zI71f + sZlxpc5sfZZZJNk+5/3Tps/+z/gqyt1ZaakMUGnsjv8AP/pP/jn3K5Z7rWLe8T/R7qB0ffsmidN/+3Vv + UP7Tks38/ds3+dE6I9HJM09l9ku6heNZR+fGsSxSMB5NnbrKwO0ctu6fSis+10y/1JC8OnXlwhOV+8qj + +9jb8vXHSio5Y9TeMNDmHunkffR57x19Dv8ACHwpsd1sriPZ8+zzX2VNN8JPB/yf8S+WD/tq9fXfVp/z + nR7WB82fwU+Gd46+k3+GXgqB4fNslTfLs+e4f/vj79bFz4D+HUcKfabSztdn3H+1on/s/wA9H1Yft4ny + 19qfy0T+BKZDJ5m/72x/7lfSc2lfDyx/1Etm77P76O9U7O68P2t/sgi02dPk82aZ0hdP+AJ/wColT5Q9 + qfPyQXEkOxbeX5P9h6h8x43/AIkr6fh1jRI7mHb9ljRP4/tD/f8A4N7/AOUqzpvi7wfAkyNdaH5O/wCd + LyXf/H/uUezM/aHy75kUlts+VJt+/fVl4Io7aG4/e7HT++nzPX0Vc+MfhZ5ybotBf+5stZX/AO+/kq5N + 40+HUaI8H9lwI33/APQvkf8A3Pkq/ZxI5j5gTbv8rZ5nz/wfPVm8sU+TyHVH/ubHT/0Ovp9PiV8N/J2T + y6TPD/zxTT3/APiKp3PxG+G+3ZbW9qj/AMGyyff/AN90ezDmPmz+w9Vk37dPuJtifwJvoTw/qsifLpV/ + 9/f/AMe719G23j/wlHbTJLcWe/8A6bRfP/338lP034heDI3d5bizdHT5EfY7o/8Av70qPZRNPaHzZ/Y+ + pyP/AMg+93/c2fZ3qZPDOtXSfuNHv3RP+nV6+h/+FleHI5t8WsW8CfwI9w+xf+AVsaf8UNC8lNviiwg2 + fxvK9Hsyo1D51h+GXjOdHeLwvqzp/sWTvVyz+C3jvUn2L4X1KPZ/z8xeT/6HX0//AMLK0yREdvHGhun+ + 3s/+Lq5Z+NLK++WDxbo106fO+x4v/i6jlNOY+YJvgX49hhf/AIpfUnd/7mx//Z6pzfBn4gR/L/wh+s/8 + At99fVyeJ7eB98vijRkT++8sXyf+P0P480+N9n/CZ6Cn/bWL/wCLo5SOY+XdV+EnjuC62f8ACH6t9zZ8 + kW//AMfSs1PAHjO1/dN4X1ZHdNib7J/7++vrG88cW9rNsbxnoKf7DtElQw/FTSrV9k/jPQX3/wBx0/8A + ZHrf2cTPmPlSHwV4tgk3/wDCNat86b9j2T1ZT4a+M9YfYvhrVEf7m+a1dK+qP+FzeF4/+Zt0n/gDv/8A + F0J8ZfCkj7/+Eq0v5Pv/AL16rlgR7p82W37PvxAktvNi0KX+P5HlRHoT4A+PZPkbRJYP+uz19CP8c/Bl + q7+b4jtZ/n+5Ckr/APoCVDeftLeB7Vf3V7eXX+5ay/8A2FTqXzHgn/Ci/HcaPF/Z67Pv/PdIlWdP+Bfj + uCZPKt7NH/29Qi+SvXbn9qvw/H/x7W+rT/8Abqif+hzVR/4a2t9+y10XUZN6/wAb26f/ABdLkn/MHMc7 + o/7NOu3ULvea1p1lN/Dv3zf+gVsTfsvarGkKJ4gsJk375dlvKif/AGdbdn+1Rpt1C73On6pBNv2J5MVu + /wD8RVyb9prR5HTbFq3zv994ok2Vpyx+2efL2Zx9z+zLqF1s263YbPuf8eUqf+z1DN+y3qu/zV8RaX97 + f5L28uyutuf2nrS0dNtpqjp/vxJvSqF5+1l++2QaJeSP9ze96iJ/44lactII8pyv/DK/iiPe8XiDSXd3 + 3/Isqf8Asld/4Y/Z30e10RLfxD/pt+j/APHzYeanmp/B/B9+uKb9p2/kkm+zeGl3s3zPNfu//oCVBN+0 + FrV3bvt0ezgfZ/z1leto+yCVTlPadN+E/g/TbZIv7CtdR2JsR7yJ3f8A77dKmuvD/g/wrbzXEvh+ztYU + +fzodNR0iT/gCV833PxN8QXTP59wsCfw+TWPfa49/D/p13cT/ffY770Wr5jCWKPoe5+I3w/j3+Xqth/c + 2f2an/xFc3f/AB+0fQ5tmh6Ppuooj/fmiS2/9nrwF5IpEfbTPJ/2K05oh7eR7r/w1Rqcc2//AIRzS3T+ + 491XN+J/2k/EusQ7LGysNI+ffvtn87/0N3ryvyVo8hI3/wDHKvmiHtjqpvjT44n+9rH3/wC5En/xFQ/8 + Li8d3GyL/hILj/gCJXN/6v8Aj31NH9/etIPrB1Wm/ErxhH88uuyun3/3yI++t5Pi94lj+eLU4k/7d0+S + uAh3yIn+/U3mU+UwlipnbTfFvxhIjousRO/3PkiSoX+KniuOHf8A2grvv2f6quM8zy3en+Z5n3f4Eq40 + /wC6P61VOw/4Wh4rjufm1VkT/YiT5Kf/AMLb8Sx/d1i6R/8AYiSuM+aj+Ct40jP6xM79fi/4ok+9rd/v + /vuqVZ/4XF4m/wCg9f8A/fCV5o8lP/1myuqNKP8AKR7SX8x3OofEnW9STZP4g1mT/trs/wDQHrEm1i4u + v9bqupPv/vyv/wDF1iJH5lP8itoxjD7JnzS/nLnmJ/z8XH/fFVppIpPvXEr/APbKof8AVt81MeT+9W8Z + f3COYuR3zx/6q9uE/wBxEqGaT7XJvlu5Xf8AvulVnnSN6En8ur5v7ge+XPnk/wCXu4/74oeR4/8AmITp + /wAAqg+seQn7qqdzqVxP956OaH8ppGNWZt+en8Wq3H/fdQvJaSfe1OX/AMfrB8ymVftIfyHV7CX8x0iR + 6f8A9BD/AMcq5DBZfJtuF+SuSSSrltP++hT+Df8APW8a8P5DlnQ/vHSeRZbv+Phf++KmhjtI/u3a/wDf + FYNzBLBM/wB7Yn3P9uofPlgj2723v/t1vHFQ/kMPZc32zqkkt/8An9X/AL4/+wp/mRR/8vv/AI4lce89 + 3G3/AB8XGzd/frShku53d/tEqJ/B89bfXv7hEqH946H7VFH/AMvv/jiVNDdRf8/q/wDjlcw0moR/duJf + ++3qzb3WoRp/x8Su7/7dP+0SPZHZ6bJFH87SxP8A77bK2La+i3pt+z/7nm15unirVYE/dXDf98JT4fHm + sb/+Prfs+f8A1Sf/ABFV/aBUaR679qX/AJ42v/f16Yl18/3IP+/r15unxG1V0+/F/wADt0p6ePNYk+79 + lf8A7d0pxx8TTlO/mk/2Lf8A7+vUP/ALf/v7/wDZ1xn/AAmOreS8v+i/K+z/AI96s23iDU7r+C1/79Vv + 9eiHsjs0j8z/AJZW/wD39/8As6PI8z/l3tf+/v8A9nWP9q1PZ9y1/wC/X/2dVlvtTk/5ZWf/AH6/+zrn + +vUjf2UzYex/6dLf/vv/AOzpk2m/uf8Ajyt/8/8AA6pw3VxI6JL9n+//AARP/wDF0+8uvIRN/lbP9x6j + 67RD2MwfTf8Apyt/8/8AA6Z9hf8A59Lf/P8AwOrj2sX8Kt/33UNtGk7umz+PZ8j0vr9EPYTK39mvIn/H + lb/5/wCB0z+zX/htIv8Avj/7OtV9N+RP3Tf991D/AGb9/duT/gdY/wBoYfsP2Myg9i//AD6Rf5/4HVa5 + tXj/AOXdUrVe1i/v/wDj9U7y1SNPvt9z+/UfW6PYr2czKhjfe+1F/wC+6mmjuNnyp/4/T4bXzHf5bj/f + qzNa/J/y1pSxdHsEacxlh4m13Q0dNP1O8sk/uW1w6f8AoD1ND8ZvGuj70g8S3ib/AL/nbJv/AENHqhc2 + r7P+Wv8AwOuY1WTyJvmRax9phK3xQIl7WB6En7RnjiNNja1bun+3p9u//slP/wCGjPGGxN1xpb/7+lRV + 5Rc3SR/8sl/4GtQ/akkX5ooqmWHwcvsRFGpX/mPXbb9ozxBJdQtfQ6XPbI/zpDp8ULsn+/seuttv2kPC + 8afvfB9w7v8AxvqCP/455Oyvm/7VFv8AuL/4/T3uov7i/wDfb1ySwWDl9g3jXrw+0fTMP7RHgySGaL/h + D2gSb5JfJdPn/wC+NlWbDxj8GrqH97Zf2dv+/Cmmu6f9976+XUvk2f8ALL/vt6sw6kn99f8AvuuKrl2D + mX9Zqn1pYeEfg5rFs/2a4sPJm+fZc/uf/HN6V0Om/CT4aRv5tjp+kzvsT57N/n/9Dr4zt9STyfmeJK0r + PUkR/llWvP8A7LofYkb/AF7+eB9da98E/Cuv2c1vPp9rJDN87u9w8P8A4/Vmb4a2kmlf2emoRfY0iSH7 + Ml6+xET7n8dfMEPiO7jhTypV/wC+0St7SviV4isf3VrqcsCf7EqVy1cppSj7szeOOh/Ie2f8KI0+TY8V + pb3WxPkdLp02fJs/2/4K5W8/ZF0/UrnfLLewfPv/ANGuPuf+OVgp8dPG2lbPK1jz0f8A5+Uif/2Sse8+ + M3i2a/e4lu7ed3f/AGET/viuGnlEIfCX9apfynT6r+ybdyJ9n0rVVsrZ/wDWzXiPcv8A+OIlVv8AhjvU + IG+0N4r2O2zaj2rom9Pvv9+nw/tBeMI0T97ZvsT/AJ90/wDi6mf9oLxhP/r0sHTYn37dP/i62/s8jmoE + 2m/sk3cd5NcXmsWr2yfOiW1q+96s2f7PV3pt46QPYJvl2RTXKOjun9x/v1DbftIeJbp/sjXFmiJ9z7NF + /wCyI9UPH/xm8R6b4e3t5sE02/7O81u8Kf76b3rjr4WlRjzyN4ypfZOk1j4ZeEvhklzL4j1OKfVZrf7T + b2dm/wC+3/303p/wD+CvnLVfGNxdXjvHFa7E/wCW3lIj/wDjlcZeeJtV1LUPtt9ey3s1umxJrmXe6Js2 + bPn+5W9pVi91bPe3SRIm3ZFC8rpv/wBuvBq8vxGdeX8pZTxdcWKeVLt2b967Pkd3/wBv+/UMniCWd0Rv + KRJvvonz0aVHqF1qmxtKWys/K3o7xb9//A3+/V/TdH1CPVUe8l+T/UxQzIm996fwbK5eeMDh5SnDHcSa + bD5C7Pn+/N8//A0qzc2txJYPb+bs3/3PvpXSeRaedbJ+9nR0/wCAIn+Upk1ra3UKPLb/AMHzoj7P4/8A + 4iuT60MwYZ3tYUigluEREf5H++9TPdXd1N+93fImx33/ANytj7Pp9r5yRW8Tpv3v53ybKp/6O6PLs2Tf + cTZ8iIm/+BP4Kf1rnLM22gt45pnlTYkKbHfzarPGsDu7bU3/AHPn31qzXEs6bIrhU2P5O/yv/Q99Zs1j + 583/AB8bE3on7l0R/wDgH+f4KI1QGWF1bzvsluFS5+4/z79n8dTJavdb9rr8n39/3KZ/ZtlpUiS21ou+ + VNnnff8A8/79D3Vva3iWn8CP8iJ99Hq/a/yF/wCEemlXFrbP5W15vN2b0f5E/wBz/YoTSre1R7iW43zT + Ps2JFvdP9+jWNY+w2zxeazvs+dNn8Fc9qWv3EcO/evkzf6qojKrMfvTOhhgsrV3t2uJZrmZPkf5ERP8A + gCJ9yoYbWWS2Td+42fI6b9/3P9z/AD8lcND4/uJ7abz/ACt6f6r5Pkd605tfe12Ijtap8nzwps/4H/uV + vGMoG0qU4/EbTxyx3LxSo2xE373T77/7FEN1FHbOkU0qPCjv5330+/TLaSW+sHuGlXYif8tvn3p8nyf5 + /uUzy3gs0+TyJni2bNn3/wC+9dPtZQiR7w954pL+Z4kl3p/B/fqzbePNQ0d5rSx1C6tUmieGVIfk3p9/ + ZVDw3pOoeI9YtrfStPe61XzUmiTZsRd/99/7ldJN8GfEuj6L/at9ZRfvd/m/Zp/NfZ/uf/EVxSx1KlLl + qz946o0py98xIfFWsXWtw3t48uo79ibLmXe7/wDfe+vb/h1rngzUbP7RqtpqiPdxIkqXMu9FdP402fJ/ + HXzemm6hHeQv5XyQv5yb3/gT/cretpH+zf6NK3z/ADu+/wC+9enGvKMPdI92B9SyeF/hxrUaSW2vTQR9 + opW+7RXypNqF/p9yRDcPGJEV9zS/d/2KKfNHrE6PayOJm1zVbp/3+oXUz/7cr1C91dz/AHri4f8A35Xe + pnkR/n+58tPePy/u/J8le37xHtV/KUPMeT+NqEj8yrL2v/xFPS1+f/frTlmae1gVvsr7E3fx0Qx/I77N + +yr7xv8AIn9yiGD5Jtv9yq5SPrHulP7L/o6Psb/fo8jzH/ufwVpW/wC7tni/gmf5f9imJ+4hd/lfY/8A + HU8pn7eRTSNJIdip++31N5/mRpF5X3EqzYSeXc72X5PnT/xyls3aD/lkr/N/7JRymUqpmeZ/G3zvvqzc + 3Ut1sRfk/g+TYn/oFH2TzPJdqfDGkkz/APA6XLM15o/GU5IPLf5v40piQPJH8v8Af2VfeB59j/wI6JRD + B5b0+UPb+6U/srxv/wCP0TQP8j1f8v7lH/LF933PuUcpHt5GakHmb/8AYo+y+Y6Js/3K2E8rZ9ynrIkm + +X+P+OjlH9aMr7L+5+58m/8AuUz7C+z7n/jlb3y+T/sUJ9//AFVHKYfWpGbc2KSTfLF5f7r7iUQ6d99G + +/s/9nrYTf8A3KiXzZl+6qf3qvlmZ/WpFKHSvn/f/c/g2PVz+x4pPk81f/ZKsv8AeRFT5Pnp/mP93yv4 + 6OWRhLEVSH/hH7W1mRPtHnpu+d0+4tPm8P2seyLe3zSum+nyXTun3IoH/wBhKhmkeT5/Nq+SZHtav8xc + S10yCHytsru/3/kqt5kUEyeREqfJ8m+oX/dv99v/ALOmfx76v2VUi8hjyOj/AN9/uUPO+zZv/wBvYlTe + Z5k33NlMeB9+9f8Acq44eZfMCR+Z959nyVZTyf8Age6mJA+/5qelq8dbxw5EpD/l3/7lQ+Z5b1N5aR/e + oTZH/t1vHDkEPmf8D+enwpLInzfJQ8n+6nyfcpm/zE++1b+wKJvLi/v76Y8io3y7ah/ubUan/wCs/gq4 + 0h8oP+8piRpvd/mqykHmPsWKpkg8v73yVcaRHNyEMNr5f8H+/U0cf92rKIkb/wC3so3/AN1K6o0DCUiF + I3+T5P46e9rLI9P8x9n3FojmeT+Cr9iHNIPsNTJapGlVvPeP71QzTvvq/Zke8X3jSNPv7Kh8tJE37/kr + KuZHkT77Vfto0nsE+f7n/j9OMTfl5Yj3ukjR9v8AHRbT+Zs3Vm/PG+xquJJ8n+xV8opRNLzE2fuqh8z7 + 9Vvsr/f+WmPvjf5pf++KOUx5SZ5Eqs8/mfx1DNJ5f3qreY/rTNo0iZ51R96/fqs87yfep/l0PBS946o8 + sCGipkjqT5KOU05yCj/WU/etPejlDnGJH/erV0GCKS5h81Pkd9n/AI5Wb/yz/wDQ627OCKNNKRfvu/z1 + cjCRD/aqTzfMtMkki875qrPA8cz/ACfx0/yHk3y7KDHlgXPMi+d/v70+Sq1zfPG/7qX5E+5UPkOifcpi + QeZ8lHMHLAmTUpfJepv7c8tPuVTe1+eut8AfD298eaqmn6fbtO+z+D5KgvljM5vzLiR9+xtn8HyUQwXE + i/uk2f7dfRVn+yT4gjRHn0zeifwfaqP+FTv4fT7FLaRJM/8AB5qP9ys/rEDb6vI8EttNu5E2eVLPWrZ6 + VqEcM223ZH+5XsdtodpY3LpL5UFaulaVp91bX8UtwvnIjvFsT79aRxUfsxD2B4nbaHqH2CbzdyfOjon9 + 9/nrY0rTZY7N/PT53RK9FudD8tJtsX7lE3q9VrnTfLTZ/A9X9a5zHl5DmLzUn3p+6iTf/t/wVcs9l07o + v39m+vdfhv8ACfw1rDw/2rqFvAn9lQzfP/z2d33p/wCOVfvPgnoUex9K1iJ3mTZs+SuaWJj8B0xjI+e/ + IXZ/to9ZWqwPOmyJ/n3/AN+vWvHnwvu/D9zptvA8V092s0yeT/sJXMal4D1Oxh+0S2TJD/frPmiUcxps + /l+cly+90T79YP8AbD2viR0lTfZzfc/2P79dPdWLwb9333rE1jw/56b4n2PT5olSOkmuLeOzhl8r5Hi3 + 0xPKnh3xJ9/50/26x9Nnlks7aKf+BNj1ZsNS8hEt/ufZ5X2f7mzfXPKIRkavkJ8jq/8Av1yvi26l0q5/ + vwo+x67N50jhmf5dif8A7dY/iHTYtYtn/vvb70qYlmbbfZ9j3ET+fC6ff31pXlq8cP7pPPdP/H64nwMk + sd/eafPu+477P9yu5hvvL/dUqseUiMislil1Dv8Aub031574wjS11J4t/wByvTkk8t3SvNPiXGkepebH + 990qKHxEVYnKzT+Z/HUP2ry6hpleoKNIn+1PSPP/ALFQ+XT/AC6NTTkiHnf7FP8AO/2KZRUcoe4Tfavk + +5U1tJLcPsgild/7kKb3qsm+uz8H/Fvxh4Dh+z6H4gvdOtvv+Sj70/74esJUv5COWA/Svh7441xP9B8L + 6zMjp9/7E6J/329dbpXwL+Icmzd4fay3ps33lwif+z10Phj9r3xXpsif21ZWutw/3/ntpv8AvtP/AIiv + RdK/bI0Kd0+3eH9Sg/v7Him/+IryK9Cr/KbQpUJfaOAh/Zl8W6k/+mS6Ta/c/wCXh3/9ASuk0P8AZFsZ + /wDkL+ILh0/gTTbdE/77d/8A4ivRdN/aQ8CarDvb7fB/e/0d0/8Ai6xPEnxsuJPk8OaZbojy7Em1K9T5 + /wDgGyuL2bh9k6vYUizYfsy/Dexh2T2+qai/8b3N66f+gIldVo/wk8CaVN5tt4U0nzk+48yPN/6G715L + c+PvGsiTJ9quIP8AYht7fYn/AAPZWbqXibUNY1B7e8u2uobdN8tz/wAA+58ifx15GMxqwPxRL5IH0h9h + 0m1R4ootO05G+59mRLbZ/ubK5Xxh4g8FaVDZ/wBrpYap9k3wxI6fafK+T/br51m8Tahded5Fv+5uE2Rf + ab3Zs31DDA8lz5uofv7l3dEdHd9j/wByvDq5tXqQ+HlN+T3Tp/HGs+D9VRE0fwVolq7/AD/aZrJPOT/b + 2Vxk0n7lN1vF877ERET/ANDq5qupW8jpbwRN5zxb0e5ff/v/AO5XMJOlrprutxbz/Ps3u/8AsP8A+P14 + Mq9Wt70jz5fF7xqw2r6xvi2M+/5Hf+//AN8VD5aWOzyrvYnzwokMv/2H9+obnTYrfRJkg3b1+d5kfZ8+ + z565v/hKn02H97tvXXZ8/wAnz1pCnOsZ+6dDNrnkecjJvRPk3p/f/wBumXOpJHbQusXyJ+++T+N3/v8A + +59yqE0nmW00s8tg/nfc2S/c/wB/+Cue0qTydNv/APSP3LsiRIkqO6f99/crp+r/AGyDp5o/MWGXf9lT + ej/98f7FTXOq3El58293m/jf7/8Av7P7lc9ZyPBYJC1ws8z/ADpviTYj0+wutTsbx0nS3RJn/wBc+zZv + /wCAURoc0iC/NG8bzbv+Wzf3P/H6rJH5iQ7d3ko+zf8Ac/8AsKhtvtc9ykTeU9mj7EfZvd9/3Nmz+Opt + btXk3xQIqPCvz/M/8H9yj7fIRqF5Pb2tt5sUuyZ/nT5/vun/ALJXPaPrHma2lpeW+yZ/kR0dH2UupQ/6 + PNNcvFNNM3y2235FRP7/APt1Sf7FBDYbkieFNjuiRff/AOB1vGPKdtKJ0msfZ7F/+WuxNnmu779n+3sr + j7+1+3awkUXzp5W/++/9/wCeuh+1JJIks/790iffs/gqhc6pLa3Dxb9iTO+/fs3/AOxserjzQLiYlxpr + axeTeRZb7l2R3d/uL/f/ANyukv8AQIr6a2drjyPs6bPvUaPa6hJbPcQeVao6fO7vs+eu28N/DnWNYsE1 + WX5LCFNlxCmx3/vps3v/AOP1jXxUaUffOr3pnN2f7uzdF+fZ/ff7n+xXoun/AA1u5NHh1PVXaysLhP3S + Wyb5nR/49n8Cfx1W0HxBpmlWdzFuuLW5S4+T/R0fe6f/ALf3PnplzrGp6xrG1tTZN77G86X5Nn368ivV + r4mXJS90I8sPjOzvPiVoXg/TXsvDmmxPZp88syb4Xl/3/k3vsd6mt/iV4cvtBhi1NJbW/wDKea4mhT5H + f/2SvK/LS187zZdnz/c/29/9+marBLAiS3nlJC7pv3vs+T+58nz1l/YeHnHnn8Zf16ptAxLm1+3Xkz2P + mvCj7/O/2P4Kmm02K1+edFeZ03y+S2/+P+CrMl8lqn7jUFR3/wCWKbET/frH1LWHjtptu6eF0373T/Y2 + b3f+5v2V78JWXIefyyLWl+TqhYTxvFLEMjcu4Krc7R+VFc/fahdaLpcH2KHa8jlXVykvKjDfN/vZorfm + L5JMxX2SQon+389M8vzET/vipnTzN+51+en/AMSV9jymPMQpH5jv/wAA2UeW8k2/+/VmFPufJ/sU+GNI + 6oz5im8bz/vf43Sj54HR/wDvurPkf/YUeR8mz/vugPakPmeX/wABeh40k+7/AAPVlLX5NlDweX/wOqH7 + UZ8mx0/gpltI8Ezsvz1MkcUb/f8A9umJIkO/5K05Rcwzy3j2f7CbP+B1DDB++3f7b1cefzH+58n36E+5 + /uJR7IOYp/7HzbPv1M8Dx7P7+x6spukf7v8AH8lP8h449lXHDyI9qVpoPn3r/BQkCbKs+XLJvp6QeZ/s + Vf1cz9oQwxpv37d6fco2JHs+T7lXEjSmeWn8X+5W31UjmIfMeP5VXem2pv4PuU/y0jp71pHCkEPl/JR5 + b/wpT/M8v73/AAOh5P8A4ur+rgCRvIny/wDAKZ5b0/z/ADKf5nmJ/D/t1fsCCF4P4KEj8z71P8x/kfZT + /n2fw1p7IvmGeQv/AACn+X8/3KH3x/7m+hI/M/jar9lEgY+yN/8Axyjy32I9TfZf71P+yps2NV8oc0Cs + n7z+On+R89WfljfYvyJT4YLi6dEgi/3d9achnzFZ4fk/i/2KY9q8iPuVkrrbPwy8aX/n/Pc2nz+Sn8af + 36v3k9pBDbXFtaKiPL5O9/v1fspFx5jjP7DuLpH227PVlPD7x3KJO62r/wBx/wDcrbmn/wBI82xlb5Pk + f5/v0/VY31JH8+JpNS3+Sz/8ArT2Y/eKem+GdP1KZIvtrec+9Iv7n3Puf+h0eHvD+mX0Nz59x5EyJ+6R + P461dNsbGPSoXuf+Pn53T+De/wDBT7y1skeG4guFjSX/AFrp/B8lHuB7w+HQ7SCZImiZ5k/g/wBuqDya + fH8kqbHdN6P/AHPnp+t6ldQP5y3HzxI+x/76bNn/ALPXMTSfaofvtvhXZ8/9yrjGJnyxNWGP7U//AB6f + Ps/v/JsqnDskvH/dfuf7/wDcqhbXzxzQuztvhf5Ks/avss1z/cm+dk/g/v1fKHKE0DfP/fR/++0qHy3j + h30yz1J45k3fPsTZFv8A4Pnpl5HLHM7/AN93oDlHzR3GzetQ/wCs/gqFLp43TbU3zyIibP8AgdBfwDJv + 36fLU38GyoUjfej/ANyr/n/f3Ivz0BIoTQeYn3Khkj/d/f8Akq+8j+W/yfPt2VTmjf8A2aDSIyG6lg+7 + T0keT71MjjeOpnj8tK0jEJcoeX8/zfPTJPuU/wAz5KPPTyXTZSAh8z5Ke9Mfe+z/AHKP9Y9BQ94/I/36 + reXUz/vHoeOoKiQ/LT0/3KPL+erNtYvIn3PkoiKUgSP/AEf/AG3erKX3mQ2ETJ/x7u/z1Z0q18+5+b7i + JRc2v2WT96io6PQRzEOq3yz3kz7PneprO+imh8potn8e+qc1q8779n36m8y3tbbY3zzUcpBfmgSTYjfc + ffVPzLS1m/56bP79UJr55E2L8iU+zsZbp/m+5WkYAXLaOW+m+TZs/wBivoH9nX4hJ8Oby5SKKD7ZM+9J + rn/crxZIPsqIi10PhWxlkmvNQ+bZaRf+PunyV2yw8fZcgoy94+6tH/aa0/XLCHz0tftKJ8/ky/JXgl/q + WoX3jO21C5uLP7NMj/J8/wD8RXlfw6024j1Wz+0u0FhcXCQyzP8AwJvTe/8A3xX3t4S+Ffw6vtH8K6e0 + v2q8mtfv+b87/J9+vFr0I4T7J6MKsqx8f+P/AAx4l028mmivbVIdju6I/wD9hXDeHtZ1C11VPPl3ps+d + N9frRqXwy8H+KtKeK+sop/8AR/JebZ/sbK8l1L9iPwFJ/qPNSZ/n37Hrhp5jS5eScDaVCR8YaV4jSe2m + ilT5P7//AAOsHW9SltbmFIPnRHdK+vdV/ZG8GaPczW8+tS2X9xPKl/8AiK562/Zi8Dyb2uvGS/J/sOn/ + ALJVxr0PiI9lI8HvNRljs7aWCVk2W/zolYNnqV35iSq9xs8r+4/yV9Pp+y34SuHmij8ZWrp8ifff/wCI + qy/7Gnhf+zZv+KlidEt/k2Sv8jv/AB1Ea9IPZyPmP7dqaOlxvuHmhR/K+SutTxx4jutBmtLy332zoiI/ + 9z599eta3+xTb2lslwniBnSb+Pf8lM174F6P4O8HzP8A2xE81pE8zvNL9/8A2KJVKc/hDlkeCalAmos7 + +Vsd/v1z2q6VcR22+BN+z5Nld/Na28Dp8m9P49lD6Tbz2/y/c370SseblIPIrOdJ0fzfkdPv0ya1eO5d + 2T/gddnf+EYrrzn8rY7p9+uYmnl01EilT+Otv8AcpQmvngdLeX/Uvb7Hf/xxKs/bnsbnTXb/AFP2V4Zf + 8/8AAKuPHaX1tvi+4/yVg+IYPLRP7iJ8/wDwCt4llDTb5INb1i9b79pZP/4/V+bUvLSzl/57bIf+B7K4 + 97j93rbL9+4WGH/2erN5I8j3llLuRPNSaJ/9v+5/6HW3sjHmO2m1W3g2ea+x96I9cN8QnSS8h/2Fqa2k + e6e8t7n9+n3N9ZWqzee6bvn2RIjvURpckjOUjnvJp6WryVcefy3qGaR5PvV1cpHNMhmjSP7v7ymVN5KU + eXRyl8xD5dFTfJJ/BXqnwdj+E88zxeP4tZ+0u/7q5trjZbImz5N6Im/fv/4BWNWXsYmkffPKP9X/AB1N + YWt3qU3lWNvLezfcRLaJ3f8A8cr788AfD34VX1hDe+HPD+g6jsV0S5hT7TN/H/BNv+evUbaOyjs7aK2S + 3tUR9+yz/wBGRET7nyJs/wC+Ery5Zn/LE7Y4U/O7QfgT491+5ht4vDk9rNKu9Ev3S0dk/v7HdHr1HQ/2 + QtamSF9T8QWFl9zekKPcvv8A7n8FfXt5fPdfduJX/dO/75Puf+z/ACf7/wDG9TXOmxTww7fKdJk3uiff + T7ledLMaszeODifPdh+zCmh/Zopdbafe+x/JiT59n9z53/ylehaP8GfD8cP7/R7q9dP33nXN07v/AN8J + sRPuV39tHaeSksW7yU3pvSXZ/wCOffqtDO/kujOqTJ9xN6Ps/wB/+P8A3K4pYmrP45G/1eBz03wy8PyQ + /Z4ol07fE6b9nzvv3p9/5/8Abf8A4BXK6l8GdCsXubddKl+xzRfurnTZXfyn+5vfe/3E+/v/AOAfO9el + pO8E29Im+f50ff8Af/uf/sPUPn2k9z+9i2TbP4/9/wDz/uVySjCt8ZXKeXTfs32mm2CWmi3GpfZki37L + +3R0f+5sdP8Ac/zvrzGb4V67Ak1xLZW8COj7IUl+d/n+4iV9PvIklt+61C4RH+d9/wAif7f/ALJVOHQ4 + rq8S4b5H8r76fI+//wCIrGrhaU/smnNM+PPE/gPVdDvPs89pcXv2eJHihs/9LTY/z/Ps+5sf+CuYubW7 + 0f8Ae3OnrZW2oSpNaw3iO7y/J99Idn+3/uV9+JJ5Fs6N/pu59/2bZsf/AHN/8Cf/AGdYni7R9P8AEelT + aZfW8s9t995obdEd03p/H/c/2P8AKedLK6X2JHL7KJ8Pa5dahHo9ykkVujwv+68mX53TZ/45/wDZ1wep + aVcai/3Gg2RO/wDqtibNm+vv/UvCOialC8X9lRQW2/7iWSbPubET/Y/4BXDa3+z14S1W5eX7bcWUzu7p + 5Mro/wDsI+9Nmzf/AAVt9T5Il8kD5Ms9BtYdHs4p/PtbnZ+9dN77X3/J8j/Inyf3Kq319azp9nnSzd4l + 2RQpbv8Aaf8AY2JX1FN8BLSOzS0luLzW32u8uy6RNnz/ACfO6fPXEv8AsqeKJ5raKzu7W1sPk3wvexO6 + bE/v/wC/UfVahEqZ5RpU/wDoH2ix2pMn7nzpv4/4/nen6pYvrE0264ln+yNvd3tUeFNn3/n+f+CvTtV/ + ZT8YQQp9huNGR/v+TZyvsT/vv771z158C/HHw9trm4vNH8/TZtm25huE2Rf7ex/n+f8A3K4quFqw98wl + h/tnJQ6r5F+6eVcPC6v5Wx02Js/j/wB+qGvaa986XE6fYtNh+eKb7jv/AH9lUPFsDwXOxvN2P8+xN6I6 + VceSK+toXi826Teifvovki/g++/+/WMKPvc5EaX2jH1LWPtzpEsWy2RPkRP4KoWGsf6TcpO8qffRERE2 + f/Z1f1KN9HS5vfKuHRHdPOS32JE7/frEmg1C6dLhbe62eb8lylu+z/c+5Xb7E6o0vdNubUntfng2zpE+ + 93RP4K29N0fT9UtvKvPs6Xlw+zft3+V/33Wbfab5kP8Ay18lE37/AJ3+ff8A7Fdz8N9HuNYuX8+ybfbu + jxJD9/8A29/+wlcWIjPl9wx/wl/wT4P03bcmVZYZll+zJCjvsV0T5N+z+D7n+389GvSXEafYoLiVE83/ + AFKSuiI+z7+z/c3/AMFX9SvpbWabT50uHttnnIkLuiI/+2/8CVj39jLJC939o3vs2bH/AN/7+/8Auf79 + eD7Kc6vNVL+CJThtbfZbS3lxFAiRfJsTf/l3p9s8sjp5T7POX53fZvSprDTZbqZ4v3To8Xz/ACb0R0/z + 9/8A3K2LDR7i3R4oLfz5n/2ETZ/f+eu2MuSZy8k5nPTWqWNs9xEnzv8AcS2dPk/9krhvEmq3c+mzW/lN + 5Nu/zunyfI/8FetQ+EX2PFK9vAjPvfyfnd3T/gf3KfZ+BNHsbj7Q1qt7cfcV7n59n9/ZXoQ5py55HVSw + 8uY8c8PWOoeMUhtNK0+W6mT5JdkX3P8Agf8ABXbWHwyvZLy2t9Tt2SH7kvzon/AK9X+w6ndQ/Z7ZFghT + +CH9yj/7+ypv7DvZHd1tPuffffWnPE9T6rE4zR/hj4f0ixFsscsrbtzSfxN/wLvRXXyaZMzhg/lrj/Vr + s4orPmOr2VM+W/L8v/c+5T0k/wDH6eiJHTE+/X3vKfID0keOpnkqsk/7z5aPM+R/79XymfKWXnSN6Y91 + 5af7dU3jf/x+npA8lXyGnLEe909DyPJsp6WLyfeqby9i1pGkRzRgVkgeNHSpktfMRN33N71Z8v5KEj+e + umNAz9oHkJv+ah4/k+X+5sp7/wCzT03yVvGkY8wJ/fof+DbTP/26Eq+UB/8A6BR/BTPLej/4mr5QH+Z5 + dMefy6I4f71PWD95TD3RnzyJ/co/1afN89TeRQkH+3QZ85D5iR/J/BQkb702/cqzs/2KP9X/AAVfKHOQ + patI/wA38FP+y+W9TeY9HzyUcpHNIEjp/kJH96mJ+8of/vur9lMzH+ZFH/BR+9k/2P8AcpiR1paJdW8G + pJ9sTfbOmyX/AGErf2AFNIJZ3T5Pv/cp9zavav8ANXeaD5U+mvaS28V1NaPsSZP40/geqGpWsWuaDvit + 9l5aO6Sp/wCgURjE05SHR9H0+60pLuP/AI+dmx0f+/VnxDvj0fSr2Db5yfP8if7CffrN8G7PJvPP3bN6 + bP8Af+etv7Kk839lf8sZonmi/wBh/wC5W32jePwlP7VLqT/a4EXf8+//AG02VjvH/at5c26/f2b4v+AJ + T7bSr2xeZFf/AFPzv89U3kuNK1K2u2+R/v1rqQGpQS6PrD/P8iS/J/tpT9H1KWO/f97990er/i395935 + 9n33/wB+uett8b+b/c+el8UQ+0dhrcn9m21t8+/7PcOnz/3NnyVmpdSwaJc27QxPvfer7Pn/ALlM17VU + vtHmTytm+WqFtqUv9lXKN8/z/J/7PWBcpE1nsnhR2+dNjpTP3Wx0VPnT56raPP8AO/8Ac3b/AP2SmQye + ZeeV9ze/z1ZjqPTTkkf5n+fZvpl/avHseoftzxzf7j7Kmm1jzPvJUhqZrx/3auJOkkLpKn+5TPtSSf8A + LKmPP5lXyhqHkLI9PedE+SoqjeOkVylmGdZHqbzE31Qh2R0J+7egjlNVLXz/AJF+++zZWrqXhyWDZuid + JlTZ9yrnhW6t7qwSKdPnhl+R69XtoLTUrNHlf50T565pS5JFxieD/wBhyyW3m7GrNeN/4q+gdY0O3n0d + 0tvndEd0T+/XhWqyeXM8TfJsq6VXnHIoP1pnmUTfu3qF/wB3VykUP8zy3o8z5Kh8ynpH5lRzFiUvz76e + /wDq6fbR+W6P/cpgPhj+fZs3vWrf3XlwwxL9/Ym+n6PAkCPdsn8D/wDoFULyP/SURfn31RkXLa68vekX + 3E+5UOpX0t07vL9+qDyeT91PuVC87yfeqRcpM988n8dQv+8ehE8urNha/apti/c/jq/jL+EfYWPnv/sV + vJGlqjpTEj8iH5fkqZ9mxN1enCHKcUp84SSeZCn/AH3XSWd0mleG7z5233EsOz/cTfXNpB57wov8fyJV + nUrpJ5oYov8AUwps/wDi6epcZGxD40uI9ibN6Vq6J8UNa0rXrDUNPvZYLmxlR4vn/wDHK4b+/wDP9ytL + TbV4JkuJfkRH3/P/AHNm+qmpTgOPxn0JoP7WXxA023mt2uIp0mR4W3p/H/lK2Ln9sDx3fXMN6txa2qeV + s2JFvT5/uf8AoFfOUN88bojff8p5v+B+T/8AZ1pWd0/nXNvF86W6Qon/AABH3/8Aj9eZ9SpTn8B2/WJQ + PY/FHxs8UeP9moNrDQXMKeS/2N9iN8+/f/4/srm08aeI45vl1i82PKm9PNrm9HgTTbBE8rY/33+ernn/ + AD17VPJIchxSx/vnQ3Oua3PC7rqF5v8A+ur1m3nibxBA6P8A2heJ/A/71/nqheeILiBPk+f5KrTaxd3V + z8yfJ8jv/wB8V5E8vqwnych2xxEZxOn0r4zeI5/Dz6Pea7fvNDcbIvn/AOWXzp/6G9Yl54g1XVbd4pdQ + up9/z7Jpfv1yUNjcSX/mt8nzu7vW9aweRsff86fcrqpZXUmYSxkYGk/i67jufm/eIkSVt23iBJ/kb5Pk + 2Vyvlr/cqza3SQI+5Pv7P/HKvFZPyUvdIpYyM5HbabqXmQ/v0V337P8AfrN1LTdP1jf5vyPs3/7ez+/W + Jqt09ro+pS2b/PC6TJ/wB0qF7540tr2B96TIibP7vz/OlfN/VWj0famDf6HcaHfuiPvtvvpWDrGpfYfJ + u2Tz7aZ9kqV6j9qSe8eK5RXs3i37HrzTW4LeS2uUb/UpLsT/AL7ohzfbL+yUE8OW91bTf2VLvhd97p/c + rN1KPyJnt502P8mz/vurNhI/h+8S4idnhdPnStXxJJaX1tC7ff8AN+R62I+KJgpqVpA80rfIn9/+/XN3 + 98l07+UmyptSj8uw03++6O7/APfdZlaRiYSF8v8AvUlL5lMeStgH+ZR5lM2U9+lACUsf3jSUqdKANLSt + YvdHukuNPvZbK5T50mtpXR//AByvY/hj8cPGv2z7PPq326zhTe/2yJHf/vuvGdNsX1W+S3i++/8AHXpf + hvSk0OzeL77s/wA7124fLY4iXPOPumNXFTo/DI+h9E+PUX/MQ09oH/jms5f/AGR//s66fR/ixpmpXn+g + 3Fvv++6XO+2m/wDs/wDgG+vmlJ6PtX96oxXDVCf8GXKXSzacPjPrf/hNIo3e4niuk/uuib0T/wBn2Vc/ + tKK+TfFd2t6/lbES2lT7n+2j/wDAK+TtN8Taho//AB43ssH+wj/JW9/ws3ULrZ9sS3utm9PuJXz1fhrF + w+D3j1IZpSl8Z9M3lxLY237p5U+VH+eLe6fwf5+f+CoZtVu4ESWSWz8596bHl2bH3/3/APcrwGw8eWUj + zStcXGlvs+SGGLen3/8AYdNlaT+I7idP9B8V2qJ/zxud6bPn/wBvelfN4nBYjCfxYcp2xxVKfwnsaalL + JC/7qLe67NkNxs2fc+f56e8aSPDKyfP8iImz5NleLWeseKJ9ktj/AGTqiP8Acmh8p61U8VeMIP8Aj50K + wTZ/ft3+f/gab64ec6uY9XSS387fK9wj/P8AfTem99lQpdJHv8rUPk/uPE+yvJX+Kl3pqIk+j+Qn/Tnq + H/sj1Na/GbT5E2N/aSf3N/lTUcwj1f7c8H/L3buj/d2Sunz/AO49H2r5E3W8Uyf7EqO9cNpXj/R7pdlz + rC2u/wC495ZbE/77StV57eSFHtr3Qb3/AHJdj/8AodHMB0M0dv8A8tdPlT/Y2VWuf7PjRPkvIH/2Ed0r + Hs9SSd0igsvP/ufYLr+D/gdX/P8ALfZO15ZP/cmd02VfOTyg91ZRv8uq7Nj7/wB9Fs/9DqtNqVls8r+0 + LCdP9utVI5ZIX8jU/P2f7e+mJ+8f/SYop4U+d99v9ymHKcNN4H0S61K5u1dt9xsd0tr14Yfk/j2Js/vv + VlPCun+SiNZXV1s+dEfVbh0/8fevRZvA9vPbJcRaPbpvfZvdNnz/APAP++/9yq3iSx0fwdYW0stpqWo3 + 9w+yKws4t8z/AHEfYn+w7/fd0Ss/dgHKclZx6fpSTRf8I1/rv9a/m79//fb10OlQXd8lz5Flf2SJFvl8 + 7Yif/Z/x10KQO94m6JktkRP4P3KIm/53T7+/5/v1T1iS41L54PtFlePs+46O9x5v8Hzp/B/wD/gdbcwc + pzf/AAj9vqUNz5D2Du8STeTqTxQ/f3om/f8Ac+4/3/76f3680+IUGseGdK1LyLK1+zXex5Xhf/WpsT7j + /wAf+587pXruvXV7JZve3Nvb/wCiS+dLc6l87pD/AH/k2fP/APF15j4q1i9+x6lcQbrXTZnR/JdHR4oU + +ff99/43RP4PuVxYqUZQLjE8ZSPWJ7a5l0rTLiezuE8nej73+f7/APt76H8F/bnm+2Stao6fPCnzu9dV + NfXFrbPcNqHno77Hfzf87KwZrq4ukTz3WC2SVESZER0f5P8AYevkZV6UJc0y/ZQ+2TWGm2mlTJ5G53f7 + 73L79n/AP4K1bySKR3ee4ad0T/U79iPWJYXWmed9n8241Ga4leH9zE+x9n9z/Yq/r3iBNHs3t1t4vk3/ + AH3+dE/ufx7HpSxUInV7lOJZto7LZ8tvFv8Avu9zL8if8Aq/bar5lzstks/JT7nk7HT/AH686fR9Tur+ + GXfdb2TzreaHe7/76bPkqn4n1KbQ5ke83Q7ER3eF9nz/AN+sfr/PLkicX1z+6eqQ3VxB/wAvsSJ/wD53 + qhc6x9+JrhoE3v8AO/zpXBza5d6jpSXd5cNa2yfwJcb3TZ8n/j9YNz400qD90sW9Lj5HTe77P7n+UrT2 + 85fBEv64eoDULaeNW84BRwJIvm3UV5dB4o0rSSVSX7U7IpMrDO445+X+HjbRVe0qmP1yR5ekL76spDVn + y/7tPSOv2GNA+dlVKCWvlvvqaOH5Km8upkjrf2REpELxp8lHl1N5Hl0eWlXyxI5hvNJ5n92pvISn/ZP9 + mtDPnKySfPT/AC6s/ZXjTfsqymm/Ij/7dAc5m+W+yn7DVx9NeObb/Bv+d6feSRIzpElBHMU/I8tKh8vz + NlTPJ5n3qI49lWPUIY4t6bvuUf36f/FT/LeR9lacouYr0n+rqy1rLGlM/dRp/t1XIHMM8yhKekfmfep6 + bI60jQMwSOhP3b/N89P8x5P9ymeX89dXsogHmUeW/pTqk/jq40oEcwxIKZJHsqbzKY8fmfdrTliAR/vP + +B/JU15pstom/wDg37KpzfcrofM+3edFv++m/Z/t1BZc8GeIItH8nz/uTO+//creffa69Z6xbOk9g77H + T++myuAuYfLRH/g2V0nhXWEfSptPlb5/N86L/visJR+2aRkPvLX+x7zfH/x5yyu6f7Gysqz8RvHqVtcK + vzpL9+t7SrqK60e8tJ/777K4y/tfsOoPF/ceiJodb4kure1v5n2f65P4K4+/vnunT/Yi2VsXN0l9psLz + /fRNm+ueeP5601I1Oz8MSW+sI6SuqTMnkuj/AMVZt1Y/2bePFKn/ACy/9krEsLqW1v4Xi+/vSu21K1Se + 2mdn3uifJXP8Eizj9Wk2eSn+xverlta+XbeV/G6Pv/36oXkEsexG++1at5I9jN5q/OibPnoI1Kdhpssl + n5sX30d96f7FTXOlXEm+4/vxJNvpkOuS2Mz+Ui7P7lXLnxVF9jSJLf8Ag2Ue8GplXlqkHnbvv7ErNfrU + 1zdS3Tu7VCkdWWLRSfx1JQAiSfJS0iQPI6Iv7x/ubE/jrtn+F+pabo+laxrMTadZ6hve3hf5JnRH2b/+ + +6OYDjIYPPmRFqz/AGVL99vuV0iWsU6ImmJ88L702J87pXTp8NfEHiDQfty6fL9gt/n8512b/wDcrHnM + /eKGm2un6bNbRR7rXztnlTO29N/+3W8+pPY+ckW3+5/sPvrm7Dw/cR2czy/cRk2b/wCP+OnrqSWOoJbx + Ns3J9x/n31yyjzm8TrUkaSwR4n+fZ9z/ANDrkvGGhxa5M93ZoqTI+x0rb03WIoIbZJfuO+x/9isf7LcW + /jPWLdn/AHKWru/9x/ufPREuR51daVcWszrPEyP/AAf7dVngd69LTVbfVdHvLL5d6f6p/wCP5P4686uZ + P9ut4+8Ylby/nof9wmz+Oj+PfQ++R99WWMSOpvufJQn7vZR5dMDYS++y6Pbf77o/+3WP5n77e1XHk/4l + aROv/LXen/s9UH6UAPmk/wBuo6kjrpPDfgt9Y2XE+5Lb/Y/irahh51pcsCJVY0Y++c9bWr3UyIqVvJap + YwpEv/A67NPCNpAmyB9n+/T4fCtps/fuzvXvUsrqwPOliozOSSPzLbe3/PX/AMc2U/yE+0+Vv/j2JXbT + aPaSWyW/lfIn3Kof8IraR3Pm722f3K6pYCr9gwjiInMQz+XCm37+75KYknmJM+xX+fYnyV06eFbeNNnm + vVyw0O0sfupvf/brOOAq83vlyrxMfw9obzv5tzEqJ/c2ffrodS01LqzdF+R9nyVZ8yjzK9uOFpcnIcvt + Zc3MY9r4ZT7TNcSy/O+/YifwJWxZwJaw7Iv/ANujzKPMq6eHpUfhIlVnMs+ZTPMqt5lHmV0GfMWfMpnm + e9Q+ZR5lZjJvM96PM96reZ/eo8ygCz5nvTPMqHzKZvoKL8N08aOn30f+Cpry18y2/wBBf/bSH+5WVvqa + G+ltX3r8jpXgYzAwq+/D4jvw+K5fcmat5BLP5LxS/wAGx0/9ArmNY8P3d9YOi/JN999n9+n6rrmoalrE + yQJstvKRHf8A2/79asOsPBC+75/k31839Sr8vNynr/WKXwHMQ/6DqVnZXybPO2J539yqfiSxuLWaa381 + p9u94n/v/JXbeZp+sQ7LxVR1+dH2Uar4c+1XKXFn+/RHR5U/8cevMnzwkbnjmsSJI8O37n2dKx3k+evS + PFXhm3gtkeD5N9v/AOgV5v5fz1tGXOZ8vKM/1lP/ANX96n/6uhE8ytA5hif6yn+X8lPeOh46ojmI6tWd + rLdTbI03u9Ps7F7qZEiXfvrvNH0eLS4U/wCe2z569HC4OWIOSviOQk8P6Iujw72+e5f7zVr+ZVbzKPMr + 66EI04ckDyefnLPmUeZVbzKPMrQCz5lP8yq3me9Hme9SGpZ8+npdPG6Ortvqn5nvR5nvWNajCvDkqQLh + Mm+y2kd1NKqSwb0fYkMuzY/9+r+j+JtbsbbyrHW7pJoX2bHld02b6zUko8yvi8XwthKkL4f3T1KWPqwN + u2+NPi7TU/0ya1vd/wAiQ3kSPs+f/gHz1pQ/GnR755rfVfClujom93tnTZs/74rj7mNLrZviid0TYjun + 3ErKS1eOGZ/s6o7um/f/AHK/KsZgMfl0+SrA9Sliuf7R6RDrnw88QW73G+/0iZP+WKJ9/wD9DSpodH8K + TzeVbeLYkdn2Il5bon/siV5LeWKSaD5sG2B/vuifI/8A9nXN/brjTZod1wqJ9z7/AM9c8KjkejCrI+lt + N8F3sjw/2ZrtndPM+yLY7w73/uJsevZvBnh/UNDSGLVdVlnfYn+hzXCPC77/AJ0R3+46f7ez/Yr5C8B6 + H4w1yFH8MaJqzzff86GJ3tv9/e/yV738JYPiW+qppniq3i1fTVi2ed9tie5t/wCDY7pv/wBj7711R5v5 + TtjLmPb5o9M+2Q7Yt/z7P3zun+59z+CtKzvreeb7JeRf2cj/AH0+y7P9vZ/t/wAHz/3Kyk8Ky6ayOz29 + kkMT+bbQxO/yb9iPs/gf79Car9lhS0sYmunhl3y/aXREdP4/k/jfZ/Bv+5srb2cpl8xZvPsUjp5t3E6Q + vv8A9Jbfv+fejv8A+Of3/noudSu9V1J7iVPkm+eW5uYkdLuV9+/5/wCP/wAc2fPs3/PWD/bmq6P4ksLe + 20f+3rBLhJrq/v3t0SJNj7NiI/8ABv8A7nz12c3i6W4ez22X2WG3/wBU8Muz5P7/AP44nz7KI0i+Yyrz + SnupobeKK43/ADpKkyJ51x8m/f8A8A+5V/SrGKe8vNKa7tUe0i2XH73f5W/503un+59zf/v1j3lrFdJ9 + olt4p4UR3eG8R0dH3/cm/wB//wAc31lWE9vo6J5ES2rp88SJbomze+/7mz+/W/sjHmD4iwfuba3/ALQ/ + 0l7d3WGaX5JdjpsRP9v/AHPkTZ/BXkV5BcQaPef2ndy2sNxap/piJ/qv77u7/Pvf+4ifIiV674n1K0tf + DdnNP9v1S5V3m/c75tn3E8lE379/99/ubH2J/HXzr8RfH8WlaJqWn7/IR3/eo8u903/fR3f7n8fyJ/uV + 4OY+0hSl7L4jpjKJ4/4z1i00qaa3tvksIZX8rzvvu/8AfrsF8VWXh+2s0g82Pfb/AGm3RNj7/k3v877/ + AJ/7j15LNJa6razefbyoifJFvb770zS5NVkh8qO4aeG33wolyz7Ik/uf36+Vlg41oxjM44y97nPUX8ea + V50MXm/antLfYiIiIlv8/wA+99/8af7/AM/+/XMX/iOKZEe8l853fe6fZ33/AHNibN9croOj2VjM9pP9 + qnuUffvh+RNnyb6fNJcRvNuuPk3/AOufZs2f3K2p4GlEzr1ec6qw8XPpt4ieas8KfJE/lOj/AO59z/L1 + T8SeIE1K5fUILRrKHfvltt+/e/8Afrm3tUnhRLmVfO819nzJvT+59ymXGm3F1Im14km+/wDvn3on+/s/ + jraODpQlznLzD/7Y+3W0ztcf6Ns2S7337P7j/wC/WIulS/ZnltX+R/kid02O71pW1jFpsKXE6eZeJLv/ + AHL/AO39x6nvvCusapb71T5H+eL/AKZfPXVGUYFx+L3C/p3w5nvGku7jUYfLkWPZEN6yr8vTb2UHcv4U + VsSab4u1jaLnWI7FAMxxwIFXA+XO1flHTtRXG5VJO7ZvynI+XT9hqHzKFkd6/cOU+a5SbfRvohgeRKsw + 2L0cpIW1jLO9X/7KSNPmqaHfJMiRfJVx7VJJv3j/AHKjllIy94yngih/2/kp8O+T7qfeetWHSknfYn9y + rn9hpY2f2hn+589beyHynPXkFx5OyXb89Vn+0SfOv3E+5WreXVvOyfx7KY+sRRp5SxLWn1cRWhnup/k/ + v1q2HhX7VYJKsvz76x0uvMffsrp9J1y0gsPK+49X7LkNIlOHwWkb/vXq5D4VtI03/fSobnxAmz5f7lY7 + 65cR/Jv+St/Ze6HNE2Ly10+x3u0X+wlYl/dRSTO8SKn+5VZ53ul/e0x08urjSIlIZNJ5iVCkeyrFNetD + MZ5fmUJH5klFP8zy6Cx8f3jTHkplMpc5BMlJTf46mhj8x0SmAxKmT9xNC/8A33T0sXnuUTf996uX9j5d + s7r87/cpc5Zg+Z89bdtJ5ey7/gTY/wD4/WP5fyP/ALFXLCR54Xt/+B1OoE1/H5c2z+D76UaDD5msQ/7G + +rmpbP7Ns9334d6PWVZ3TwX8Mq/wPS+yBfe6e11B0b5P4KmmjS+mSVv40qhr0/n6lNL/AH6fDdPPYJt/ + 10T1ma6l/Uo0j0Tyl+/vrm61byfz4XTZ/HWb5DyVoZEPmeXMj/3K7+bVYrremz5N6fcrifsLxv8AN8lX + IZH87ymf50+/WEo85vzBrcnn3jy/7eyrmmyfatKe3b53837/APsVWv4PLuU/uffo01/JuHi/vb3/AO+K + DHmKF4nlzbv76VWeTzKmvN8kz/7++ofL8urLiM8ulqVI/Mf5amtrGWd/uUGhXq3YaU986fwJ/G/9ytKz + 8P8AmbHnfYm/ZXT2cFvaQpF8ux/keolIuMeY1fhpa2ngf4u6Pdy28Wr2dvqHk7JvuPvfYj17N+2xG/8A + wn+lTRSxfY5tNhSKGH7kWx33p/32++vnu8naPe9m/wC+hfzk/wCAVQvPF2p+IHeXU7uW6dE2Jvf7lYcs + p++bc0Ie4faX7LXwn8L6V8PZvGG+11TVb5/sduk3zpbv8m9Hrz3XLrxh488Vax4P0+7ik/syV0+zWfyI + /wA+zf8A+P14J4G+L2t+B4UtLa4lew+2/bHh3fx7HT/P+5U3wv8AjLrHwy8fWHiiBvtVzbyu8qTP/wAf + G9HR0f8A77qJUJjjUpQO8+KmueH/AA/8V5rLRYlvfD2npaWz7/8Alq8UKJN/4/vrzqaO3nuba7i+/buj + pv8A7n9ys2+vv7SvLm7ZNn2iV5tn9x3ffVn7dFJZpFs+58n+3RGPILm5iy+pLa+Hn81Ed/Nd1/39lQza + rcabM93F+/TZ5Mu+qc0f26GH+PY++sp45Y4U+9v2b3/26vlMZENnfPBeXm7+OJ0rKaD95W9/ZsU77/N2 + b03pV+/8HSwQwywSrdJN9zZRzRI9449o0jp8MfmPsp80HlzbKfbfu3379j1qLnIZvv8A+5THj2PU00nm + O+6meXQaBNJ5mym805I/MdEX77/JXYaL4H8z/SL7/vzXZh8LVxMvdMKtWNH4yv4H8PxXrzXFyu+FPuJ/ + er0FNkCbItqIlVoY4bWFIokVEqZ5K+4weFhh48p89Vq+2lzD/Mo8yod9M8yu4x1LPmUzzKh8yjzKA1Jv + Mo8yofMo8ypLJvMo8yofMpnmUATb6N9Q+ZR5lAucm30efUPmUzzKzGTeZR5lQ+ZR5lHMBN5lM8yofPo8 + z3qOYsm8yjzKh8z3pnmUgJvMo8yofMo8yoAm8ymeZ70zzKPMoAm8z/x/5KfZ3Utq9ztlZN6b0/36p+ZR + 5lcNfC0q3xHVSxE4FnxVY3euaVbPbbXuW/1qf79eY3+h3trvla3lSF5XRH2V6Qk7p92r9nrCRo8M8Szw + vXhVcrlD+EehDGRn8Z5po/gvVtcuUigtG/v/AD/JU2peFbvTbZH8r/YlT+69e2W11aXyfupVgm+/XMeN + o7uCFL2B/n3ojp/f+evFtVjPknA7fc5Oc8otdNuJ5tixNvf/AGa27bwi/wDy3euhtoPIR/77vvqavqsP + l0Yw988ieKl9ghsdOt9Nh2RJ/wADqzTPMo8yvXhCNP4Dj+MfRTPMo8ytDMfHRR5lHmVBQeX/AHqf5fz0 + JJT0kT+Gs+Y6IxGeXUyQVJzTof8AgVYTq8hvCkMS1eut8MfC/WPEf73Z/Z1m8TvFc3n7lHdE+RN7/wC3 + sT/gdenfA3wjpUdsmoa1br9smeZLdJvkdNmze6fP/f8Ak+dE+/8Ax16XrGmxT2b2kH2dJt6Q273lxs2b + ET59+z5E/wBze6fP9yvhMfxFKE/Y0T6HD5XHl55nmOk/stpJbebqfjC1SbZv+zWFq82z/fd/4P8APz10 + mlfs0+FNHs7m41fUNWvbm3t/Oe2+REd/ueSmz53f77/fT7lenax4juLWzd3t10uZ3e2iuYdjp539/Y/z + /P8A3H+RKNeuvPmRIrhdkzvco/lI6Sun9z+D+P8A2E/74r52tmuJrfHI9GGBoQ+yc34b+BfgrR/9Igt7 + XUU+1b3mvIotifP+52b9+9Pk+5s/36NVtdM8BvDdy6Zoel2EqP8A8ecXk/aN7/I6Ps+f53+RNj/P9+ti + z1jR9NsHu7zW5Xs7d0+z75UTe+/Z5KbET+N0/v7NiffqnrGm6fa/ZrdtQt3+3P8AZm2fvn3p999iffT+ + PZ8m/wCT597pXic3PI7OWMDKtvGNpfTTXDXFxqMNpcQ7/tnlb9n8aIjv8/8AH9xE+RP4N9aXhvxHcakj + w6jcRT3KSukVz5SQoqfcTZD/ALmxE31w00cVrbJb3ej7IbF333L7EmffvTYib9iP8iP8nz/c3u/zpXZ2 + esWkFhrFxY3Fv503+h2W90877+/zt7vsf77p9z5E+f8AuUxl9I/7D0e5i1PxLdXtzCqea95LF/t7E3oi + fImz7iVm6bPpWpXl5rFte/2pbP8AuZfJ1DZDbvs3umx9nz7E+T/7OnrY3f8AbDvqsVhO9wiXMUM0vnQx + bPk+SF/n+f8Aj+d/7+xKs20FpHeTPbWX9nImyb7ZZpE/mun3E3p99ErTmD7Riabpv2qH+0G1C41H7Q++ + 1dHRHeF0+4mz7+zZ9/53+/XW2ckUc32f76OnyQ+V/Hs2fc/j/wBx6p6PfW+pOkv2i42TbJkhe4ltnlT+ + P7myofsKQWFnZWyNpyW6fZvOR9jv87v8/wDB9zZ/wP8AuVXMBqzX32pJpVl3oiJD9msH853TZ/f/AIHf + Z/4+n+3XK21rqcdneRXyaal586RXKWUr7HdH2P8A67+BPv8Az/P/AOgbCRxT/Y7i5Rb2G3lhd02IiS7P + vo+zZv8A4P8AbT56zfstxJvlg/1yOjxQ/aNm9/7+z7n+UqtRHJeKoPEEdvMmlSr5yI7y3Pm+S9x8n3ER + /wCB/wDgf8FeJ+JPDKeKtKf7Cnn3L7Eltrm3dHdP9/8A9kr6c03UvnRbxN7w/I/nS/On8fyf3/n/APQK + haSKTUrm6leVPO+RN/zp/ff+D+OsquHjW+Mk/P7xt4V/4RHVEi1yCSP7Qvm/aLxN6fI/3E2fNv8AkdP7 + lZ9h4qu9ZeG0trS4k8n/AFqQxP8Ac/3Er9CLnSrLUk/e2kTuifc8pHdP/HPv1T/4QvT4/wB7HFs+f59j + un+fnrz/AOy4/wAxnLlPga8guIEmuJ7iWF9+x0dNiVgvrGpT3HlbYnS4fyYn2Js/3K+8/Fvwy0TxHZzW + 99Zb32bHTdXj9/8Asv8Ahfzk/wBN1SDZv2IlwiJ/wD5PkrCWXSgRGMT5t8v+0IZpba4lkRG2NN5XyO2/ + 76JSeGNHl1K8fdLs/jd0+/X0mv7Pvhrw/ptzN/aes2um/clRLqF3+59xPk31Q/4QPSvCOm/aGSWC2uNn + lW1ze+dcpv8A7+xPkrhq0JQNI0pfZPMdHvtK0eF3nRXd/k33Pz7P+AVvWcd7rEybbe4n/wBtE/cun39i + f360rPQ/7YuUt7608+zRN6Qw2+99n/xddUk+oeEb+wla3vLJLFES3tvuPboibNn/AI589Y8kT0KVLkPP + 9TmW3xbXJe3eJ2UKw28/xfriitOFYZLt7i5hhVGBGydd27nhg3cYzRXE6WuhnP4jzq20OWd/uVZh0fy3 + /e10L6kkHk/J9z79Y95rCSTb6/dIwPiuYmhtYo/kWmXkiRvCn9ys3+0nqGaR5H+/WnsjM1fOijdNr0Jf + Red8z76yv4KP9XW0YgbH/CQPB/q6oXOpXF1956rU6tAFSP5KZ5fz0/zPemeZQSP8z3oeSmfx0ylzCLPm + eXR5nmVC9P8A4KOcY6lfpTPM96Z5nmPRziH/AOspnmUJR5lRzDCijzPkqHzqOYom/wBZTKZ5+9KZNJ8i + VHMacpZrV0eNJHf/AH6wfMf5K29Kk8hE3ffR99HxGZtyWsUf71fk+WrMMEUkLo38b/P/AL+yqc19Fsh/ + 20+f/vuibUoo9m3+/vrP3jTmMrVdN8i8mT/b+SqdtA9rN/wCukv763urPzv49m+qcNj5jzfP8lacxmYl + 5O8julMs4Hkeuzs/h7d6rYf2hBEzw+bs37KZN4cuNHme3aJkes/axNOU56w8P3usalDbwJvmuH2Ildb4 + V+E+sal4nv8ASli/fWlu8z/8A2UeHvtHh/XLO9VPnt5d9dbbeP8AULXxDeaxB8lzdo8L/wDA6xlVN4xi + cHrHhn7DZvcL8++srR4It7vP/BWxrGqvP+63/JsrE8zy0+/RHnnE5ZSjCXuG9rFjZak6SxuqfwVQ1LR0 + k/0uB/nT79Q21r5kO/f8lXEjSGF/3tbRwtUzlXiUJrVLr7v3/KqazsUgufNlT+B//QKY995Fz+6+eoZt + Yf7lR7Kr8ARGXmjyyec8EW+sq30q4un2LFXT6D4j+y+d5v8AH8lPh1WK1d/k/wBitIwmb+6UNF0eL7P5 + 0v3/AOCtK1tU2Pt+++xKuaVGmpQ/uvk2ffqa50qW1ffF8/z11fU6848/KR7aMfdM3Uo/L0qaVf7+9P8A + vuobPzb62m2/wJvp/iGOWO22/wACRf8As9Y+l6i9om//AGHSsOScPjL9r7wQz3Ef+kRJ88P3/wDcp9zC + kkKXEX3Jk/8AH6LaTyL+8T+B7f7n9+maPJ5jTWjfcf7n+/SMzH8uhvuVpalYtAm9kpuj6NLrFx5S/In8 + b/3a3pQnWlyQIlLk+Mltp3kT5v8AgdXLaN5LyFP4/nTZW3D4Rij+9K33NlatrptvYyeaqfP/AH69SllN + WcvfOWWMj9gxNN8OXEbvu+RN9as2j70/hetLzKPMr2P7Jwxy/X6pz154Z8uGFIvn2J8n+xTLP7bpqfZ/ + KZ/nR0rod9M8ysKuSUJGn1+RwfiHSvPuXuIItjv/AK2H+5WDDH/6HXqk0CTv8yVm3mjxSJv2fPXi18rq + 0fg96J1UsVGZ508b+dTFjeT5F+d67ZPCv+k/Nt2f+gVpWGh2mmzeaqb5n/jejD5XVq/GXLGRgZXhLwy9 + rMl1cpsdf9Uldb5lQ+ZR5lfXYfDxw0OWB4tWrKtLnJvMpnmVHTfM966znJvMo8yofM96PM96XOa6k3mU + zzKh8yjzKjmDUm8ymeZ70zzKZ5lHMGpN5nvR5nvUPmUeZUcwak3me9HmeXUPmUeZRzFj/MoeSofMoSSs + wJvMpnmUzzKbQBL5lHmVDvo30ATeZTPMpm+jfQA+jzKZvpnmUFk3mUeZUPmUeZUATeZR5lQ+ZR5lAD99 + G+meZTPMoAspM8b/AC/fp9zfS3Sokj70SqfmUeZWcoRmXzTH+ZR5lM8ymeZWhBN5lHmVD5lHmUFE3mUe + ZUPmf3aPMqNSSzvo31W8yjzKCi55lPSSqfmUeZWR0RkX0kq5Z3yQP+8iWdHT7jpv/j/8crHSepkuq5qt + L20OSR1Uq/Ie0+GPipplrYJ9pdbK5SXztn9n74Zfkfej7H/3H3/8A+4lX7DxNoV0lm9slxqCWkTpvvJd + 8yI779jzfPvTfv8Av/8AjleFJdVMl08b70fY/wDfR6+GxXDvv89GR9DSzGP2z66ufGnhfUoba4treLRH + sfk8lJfnukdNiedv3psT+DY6ff8A46mtvK1i5S7gt7e9f7iJ9xHf/cT+P/cr5XtvF17Hc+bcyy3Tu/zz + b9k33Nmzf/c/2HSu20fx5b3Wpf8AHx8838cyJbTI/wDf3/6l/wDgeyvmK+Er4f8AiwPUjVhW+GR7k8Pk + eTcSp89u+/8A0mL5Iv7iJN9/+CmWF9cRzJLYxefCib0hhlR0T+DZ/A7p8/8AcrktK+IVxBDNFfOrp9yW + H7jon+f7m9K7O2gfVbD+1dDu1gm373h370/39m//AMfrDlj9g0Jr/VX1Xf57+fc+UkMqbPnf/gDp8ifP + so0TTbKTYixXFq7/ADv51xv/AIN/39n3/wC+n8Fc3f8AjS4tbb+z9T2wfPve5tt7u/8Atv8A5/jrVh1J + JLC2ez8pIbjfsudju6b0+d0T/P3P9io5Q5i+mm2//HxpV75G/ZsRE3u/3H2J8m/76fwVW8+48PpDLFEq + Wyy7/wBzL88Xz/xv/B9/+Cq2rXWoSQzXa7rVIdjoj/uUd/k3/Jv/ALjpW9Yb5E/fxKibPOf5Pnd/7if7 + G/8Aj/goAoWf2KdHigRoLBP9VM770T59+z5Pn3/O/wD3xU1nqvmb4oHie8h+eXfL99H+4+z/AG9mze/3 + 9jvVDXoNPk0p9Yl+SHfs8m2id33oifPsT+D7nzv/AB/7lVvD2lRarDpVxZvLs1ZESL/R4oZvn3/ff/4v + +5/uVhzR5uUrkkdb57XUyW/8dx9xN/3f/sP9v/x+mTQJ/wAtbhdiO6fJ/wCOfJ/G9P03TbTTdlxB+/d9 + 8O9JUeGX++6Js+TZ8+/+D7+x6yrnVbuPWH+wva+TC7/ZZpklSbeifx7N6Q/I+/f8/wBx66Y1fdHyly50 + e91KaHzbe6ge3R3lRIkRH/vu7un8G/7m+sHVdNt57aGJbhrJ7hE8ryZf3zo77E2I77//ALDZUPiTWPD+ + lWKWWq6fqk9/d/aHsvsepPaWey3TznTyX+RPnR/nm++n8afcfK0qTT77wxYamztPf6tEk2pWGlSpM+yX + Y/yTIm94vkf7jo/3/neub2vMHszs9H/syOFLidNSf/SPJ+eJ0RJnTZsd037P+B/+OVWm8R/YdKhS8iuv + OuPNeL+x9Pd0iRER3eb50/v/APjn+xUN5pqaHrdhcQXEU6W63bpZwu6W1w7/AH3mT+P/AGPn/wDQKrah + qsUFmlxc3C+c/wDodrbOn7m3+0f89khdN+99nyb/AOBP9itvelEj3Tm0/t34lWPiGXQ73S7X7DaPNLDe + X8SPv/g2Om+V32f3N+x9m96891jxVd+TcpbXrXT2+/Zcumybyd/yO6OifPs++/3K9RuftWj+G9kGmRT3 + NxdXD2X2+VIUimR/JRHRN/7359+zeiIn3971iaPY6lrnh+20fUE/tfWLu6uPtE00T29n5KPv8532b4fv + v9/Y7v8AcTe+yvMqxq1vcjI6YckDxn+1bvxHNDb/AGj7bf8A/LLyfv1Q1uS303Vf7P8AtH76FPOl8nY6 + f7ex/n/77/v16Rqnwj0zwleeJPsOoalrWsJ89rbaakWx/n+5veb5E2P882//AHEeqH/CudQjm0TT9TuN + J0e/vrdHld5d6M6f650dN+/Z8nz/AHK8WdCcfcOrm5jm9Bm1O136hbXcWnPC77HfZvT/AL7+/VDxhqWm + WtzZxLexXu9POupoUld0ff8AO7u/3/k/4BXbTaPZaH4h82xeXV5k3u95NboiI7/xv/An+5XnXirUrSTx + PsaJr3VX2fuYYvkd/wCN3f8AuUo0uSJHNymZqkck8/m6XbTX4dmbyVT5iufvt/n+OitS287S5GuFuvss + 8ow5Z/8Ax35qK6I8tjklT1PLXklkf5qhuY/Lqy+zzqrX8n76v2nmPh4jKP8AWUxJKZvqOY35SZ5KZ5lQ + +Z5dP30cwco/zPnqbzKrb6Eko5g5SZ5KZ/q6h/1j0tZ8xfKSvJQ8lMemfx0cxHKP31NHP8lVOacklHMX + ylmaTy6PM8tKrPJ5lCSfJT5iOUueZVZJKEoht3ndEX+N9lHvgP8AM+T5aZDayzfdSu303wJ58Ns8n8ap + urrNP8M2lqn3P4K93D5PVre/M8+eMhD4DzHTfDl3fb/k+589att4HuJt+5NmyvSIbWKDftT79T17dLJ6 + UfjOGWMnM5HSvAcMaI8/zvWV4k0pNO1REVP3LpXoW+qepWMWpfe/grpxGW0pUuWBFLET5uaZ5pMnlv8A + 8AqnNvjdK29V0OWDf8nyJWVD+8+Rq+Lq4edGfvnrwnCZCkj+TMn9x6uQzvGk27+PZXvHwl+BmmePNEs5 + ftESXNwu90evLviv4HbwB451XRG+dLR/lf8A2P4KwN+U7zwl8VLfw/8AD3+wool3vcec7v8A8Arldb8c + Jqt/9rZPn3/+OVw3n+XUM0/7uiOFj9ozlXNW/wDE8sju6/3NlU/7cuPub/8AbrNf95UdbeygHPInmunk + eofM8yj/AFlHl0cpI9J32bN/yUzz3k/joSP5Hqb7L5cML/3605hD7aPzH31DNH5k1WYY/LT/AG99X9N0 + 17r+CtKVKdaRnKryFCz0qWf7qV0+ieH0+zP56fO71q2djFap9yrnmeXX0+FwEKXvzPMq4qUxlhaxabDs + iqZ5P71M8ymb69T3IHFzjL+1S6heJv46wX8Kps+Wuh30zzK5auFpVvjNo1ZQMSHwykdykrP9xKs2fh+3 + tZvN+/sbfWl5lM8yojg8PD7JpLESmQ3OlW9196n2djFYp+6/jp7yUeZW0aVKEueETOVWUx/mUeZTPMpn + mVvzGY/zKPMpnmeZTPM96jnAm8z56Z5lM8z3o8z3o5wH+ZUdNo8yjnAf5nvR5nvUPmUeZWfMA/zKPMpn + mUeZU8xpqP8AMpnmUzzKPMpcwx7yUeZTPMpm+o5g1JvMpnmUzfRvo5g1H+ZR5lQvJS0cxY7fRvptFADt + 9G+m0zmgB3mUeZTeaOagB3mUeZTeaioAn8zzKZ5lM/h+WkoAk8yjzKZ5lM8z3oLJvMpnmUzzPejzPes+ + YB/mUeZTPM96PM96eoD/ADKPMqOl8z3o5gH+ZSVF5lHmUATeZTPM96ZR5lLmAf5nvTPMo8ymVAD6dUVH + mUFD/Mo8x/WmUUcwD/Mo8ymUVAybzPejzP7tM8yj+OjmNNR1L5nvTKmTpWfOWPSpkqFKnrGUjeMRySVM + knmPUKR+ZWxo9j/aSvtt2nmT59/30RP7/wDwCvHx+Jhh6XPOB6+HpSlI3vBlrcaw/wC9817a3+dPJT53 + /wBhP7n+/wD9919CeHvBaeEbZ7u+eVH370RPn3p8nyf/AGb1z3wi0qLWIYdTnvdkNjcfJbWGxEldET7/ + AP45/wB8P/t16dqV0mq3ibki1HfKnm22zen3/wCPZ/ff/vivzac+f978J9DCJx9/a28lzDcX1pZ2tsiI + 6QzSpvff9zeib/8Avisrx/4quPA/hjTYtB8OS6pr2syvDptnCiOmxN++b/cR/wC/s+//AHK7C5gdJry3 + g2veJcPNFc2yO+9/kTyd6b0f7+x3T5N6ff8A4K3rbwq+j2dtFrmn3CaxcIlza21zv+R9+zY6I6eb8iP9 + /wCR0f8A744pVfdN4x9489ttY8UWv/Ht4X+1aw2yGL+0tQ2QpMifPsSHe8yJ8/z/ACJvT79PsP7bj1v/ + AE6733MyPM9n5WxEfZ9xETfsf+D5N/8Atv8APXT6xo/n/wCjxJ/aN5Y26Q3Ez2SQzI7omxE+fZvTfs+R + /n2f7Fcfc/8AIyP4fl8qy1VNKd4rO5vd80SbHT7TN8/yP8/3N6fwURlKcQ5eQ62HxNaab4kh0rTLe6vb + b7FNf/2rNbpbJbv5L+SiWib/ALR8jvvSZ0/g/wByn6b4gvZ9Emsra3tdOtrt99xC8sSXLvE6I+zZvdNm + ze6fI/8ABveuVTxBe6xc6Po8Gp/bZkuPJ+d/tKRRJs/ffOmxIk3ojvvf+BE2PXQwwfbt/wBu0eXS/s6Q + pbwvKmxvNf59/wB/5N/8fyb/AOP5KxNuYm0TWLLxdo6S30WpQWbb4YkSLY7pvf59j7Nib/7m9NlXNbsb + 2Tzks9QuE8nZ/o0OzZK/993+/wDf/uVz3ibxp4a0f4hWfh/V/EFhBc7P9F0ezld5k+Te+/YmyFNifIj/ + AOxWrZyQ3cNzb6Yn+gQu7xTW1wjomx9ib5kT+B0+f+P5HrphyzMTK8Q+FbK+0fUr3Xr28e2fZpSaUm97 + NHebe/8Aon3HTY6b3dN+/wCesqz0eLwzoN/o9skvh6a3i+x2WyVJoUhifYnyfc3/AD7/AJ3/AI03766T + +x9K/ti/lvItSfVZvs9nE9g7ukro+/5N/wDc/wDQ3+f+5QlrLqVnDZWenxaDbWMSTXGpXLp/f++6ImzY + jvv3v/G6bPuIlY/AUFnJ5iTWl9La2qeVvl/db/tD/wC26J/sf3//ALO5qUcqfbLeJLe632u+XybhESX5 + 9+9/7n8Hzvv+4nyVxPijxNrGh6DeRaPp8uvfYZU/s/7HboieTv8AnSZP497/ADo+/wCRE+5WlJJ5F/bW + 9y8tlc3HyW+9P9Vv379/+3/AifO/z/cq+eJIzxnsg1X7Q0u/Srd7eH7NeOk2yZP4Nn3Hi+RN7/fd9n9z + 5OYvPDNxY/b7iW7in0e3iu3vX+0XE0zpKnzpDv3pv3/f3/Js/geukeNLWZPn+2pfb5pYYZf30v8AcR33 + 79jv9/f8m/8AgerkN1FfPptw2n/8e90kL3KSoifc2O6b/ubNmz5P7/z/AHE37c0YmfxnGeFfiF4juppr + htKi0h3idH1J9Vimd5ndNkMyOibERNifIm9PuJ9/ZWlrcmu6wkMsWoW+yGKaHUkvInd5X3/PsfZvf76I + /wA6bPkdN6JWwmuWVj/pd48W+3TyYtmzyXd33ukKO+z/AF3z73/2Hf5HqH4hX1xrk2j6PZy3WlpaWr+b + c6bp9vssrR/v77t0+/8AcT5H+5XNKMTb3jE8Q/DJ9YttYuJ72/8AD32eXzpdmnvcw26bE+SFJvnRH+/+ + +f8AjT5/4680v/h7d+H0mi+16X/bF9Ek0VtNKm/e6fJDM6fx7E+4n8Cf8Df0vXtc1C+httPvri8g8PW8 + tvf3ENs7ujy27u7zTTbPnd02Ps3+V+52VzH/AAjNxpvxOvPEFn4gs73RLhNn2N4nvrmVNnz3KTfwb33p + vR/9jf8AceuSrQHGcTzzx7osXhG6FtflhPa7LeWSVTDG0mz59pHyt86P05/vc4or1Tw/qUfjKQPqGnwQ + aisW8RahcMu1SxDNiIZjLEKdnTjksyE0Vy/Uzq9qfHTz/wAdQvJ5lMel5r9X5z4aMRydabzSf6ul5pmg + nl1JUfz/AHKf/HQQCdaWk/1dLQAUnmfJQnWloAR5KP46WkTrQAz+Kl5pP4qe8fl0AH8FH8dTPH5cmyn6 + fYvdXkMX996uEJVJ8hnz+4b2j+HH1DTby4/uJ8ldF4f8JxLaWM0ifvlfe1dHbWsVrD5S/cqb/Vp8tffY + XK6VLknM+bq4qctCb/VpR5lQ+ZQ8le4cQ/zKPMqHzPno8z3oAm8ymeZUPmUeZWfMA+aOKdHT+/XMXnhn + 95virpPMplclfDwrfGbRqzgQ+DPFWt+DryF7aV9kO9EStLVbW7+Jvie5u7n57m4iRH/4BVP5av6Pqj6V + cJKteNVymP2D0KWM+xMPGH7PusaHbQ3FsjTI6V5Lf2Nxpty9vOmx0f599fXXh740pJDDb6gu9E/v15X8 + ddN0zWL9NQ0xNm/72yvOq4OrA7eaHxwPEPLpeasXNjLBUPl+XXnS5x8wz/dp7xvs31Nb2rzfwVqppssd + s/yff+St4YeczOVWJiJA8lX0j8yFIv7laVto7yb61bbSkgeu3D4OcjCriDEs9He6m+b7ldPb2qWqIi0J + tj/g8ujzK+hw+HhRPMlV5ybzKPMqHzKPMrqMybzKZ5lM8ymeZ70cwE3mUzzKZ5nvR5nvUgP8yjzKZ5nv + TPMpc4EzyUzzPemPJTPMqOYsm8z3pnmeZTPMpnmUcwE3mUzzKZTN9RzGhN5m+jzKh30b6XMMm8ymeZTN + 9G+oAfTN9M8yjzKjmAfvo31D5lH8VBY/zKPMpnmUzzKXOBN5lM8ymeZR5lRzAP8AMo8yofM96PM96OYB + /mUeZTPM96SjmAk8yjzKZ5nvTPMo5gJvMo8z/eqGijmLJvMo8yofMoqOYCbzKZ5nvTKPMo5gH+Z70eZ7 + 0zzKKOYB1N8ymUUcwD6PMpnmUeZRzAP8yimUeZSAKKKZU8xQ/wAyjzKZR/u0AP8AMpnmU2ijmAdR5lM3 + 0tHMA6jzKZvo8z+9UcwD6KbRS5xjvMp9RUUc5oS+ZRTPMo8yo5g1Jkp6VCklPSSs5SNolxOtPSOoUkp6 + da5pSO2JpaPpdxrF+llbf66b7m99n3E316v4B8IxabDN/o8t7Nd2syPcvFvtokfYm/Zs3/xp8/8At/wV + 5FYalcabeJd2crwTIjoj/wC+mx/v16X4Y8W2viN3S+1i40S8S3+zJsi2Wz/30dE2Jsf+Pfvr4rOpYj/t + 097B8p9FJYpHo8NlY7bL5PJdPk3/ACP9x6mTWLT+1bbSoLe10izeV5vOsH/0lE2OnnO6I7/x/cR0rlfD + 3iC0jdP7Viltd/76K5mffDdv/fR0/jf/ANn+eukmnt5EhSXzXhRN7v8Ac/j+/wD7abK+Uly1T2Iy5R9/ + 52lXP2iC3uHsPK33D23yTW+9Nmx/ubHT59+9NlP8N65af23Desnn7EdL3fE6ebvRESZ3d/n/AIP4ESqf + 7qxt0+x29rO+z54byX5H/uP8nzps3v8APvrNv47eTR7+3gt5b3VdiW1rc3lw6I+yb+P+N9m/5ETZvd/n + rCUeQuMy5DHceHE8QxT6fL4ovLd0miTUrrYiXe//AFLun3HREd9nz/c/jfelZWpeB9Turl7u8e1TUnlT + 7beTW720O/ZsSGFPvv8AP8m9/nf5P43rH1XWNT8OaxbJc3sUCQ7302HeiIzyu6Ojpv8And9n3037Pn2f + xvW94V8rTbC2u59Pl06zt96JeTO7pvdNifvnf+D+587/AD/8ArCPN9g0lLmPPviR4P1jWNVsLu68RXWn + zWLLNb3mjuiI6fwQ79nzp9/7/wB+u+tvE3/CPww2msyxbLiJLl5rZ03/AH3dPO2fc+f53RPn/g+TfW3D + pVvY6bDcW32/VEuInd0m+dH2P86In3ER3f5Nn8ez+/Wa/gqK+v4bextFdEd4Zf3qTeVN8m9Nifxo/wDA + nyJ8/wA/yVceX4TOXNzcxzem6P4d8Jaxf6fpWiQWupXdkj3t+lrLs+dPvzO7/fd3TfsfYiff2b67Ow1W + 3nhsIoLiXW7aayT/AEnfFbI+z5EdNnybHdNiJ8/z/PsrBfwzpl9DNqECXF1M9u9tKjvvmlhT79snyb0R + 3++7/wDA0pmiXVxpUN/LEksCJb7LeaG32eV8iPs8n76P/HvT5/kd/wCPZT96HwAdnYabaa5Z6lFp93bz + vDEjuk1w6J87/f3umxE3o6b/AODYn3N6VQm8P287vtSVHvovsbv5u/zU3v8AJ/6H8n/jn3KzU1h9VmvE + luJZ9Vu7jZb/ANpXCJs+R33pCn3Puff3/wACb6spfar4cR/sOnxaRpun2/2m4T5Nkr73+d5t+xPn+f8A + gfe/yVXtZfbDl/lDVdKlns7ZJXlnmt96RO773b7nyO/8aI6fc+RP4PuU/Up01LSrDTJ9r21pKlzbokSW + 3lTfO+/f8/zv9z+Oq02sW91+91BGRPnmt3s0d0Sb7/yfJv2In8f9xPk+f5Km1jStVtbP7Qt3Zz2yP50q + eU7vcQ/J8ib/AJ/4/nf7n9ytP3UyPeIdbnuLq2d4Et7J0t/9Hmhtfnt0R03p86P5yP8APv8A7m90SqEO + h3Em9L6W4Sa3i+2I9sjzbIt6fJ8n3Pv/ANz502b/AO4+9Z33l6bD9jR4LnY/lXP2rY8SP8joib//AB+s + SbTfL0W20+J2tfskTwxTb/3yPL86TfJ8j/Ps379/yf8AA6iUZBCUSbQYNQnmdLxLh0097h9iW7v5T73R + POT7mx/7+z+P7lUPI0+CzS7+23H2Z3R7j966PE6O+9P9zZsTYn/7c15Yvo+q7INQbVLm3/fXu9Nlm/yb + E37Pvu7u/wA+/wDgqzqU+nyaakVjexf6CkP+kpE6fa/9tH+/N8/z73/j+5v2PRzchfKU4Z/sqImoW63u + +KGG9sLaJ0hZPv7HdH3pvTZ8n+/WDqXhzy7N5YrK48m0ihSWaz81IXmf50RER0TYn3Pv/Psd629YnS1u + baK5uNn2iXfpsL3CbLvY6fOkO/5/v/xp/sU++n0fTtYs4oNYl3vdeSnnRQ7E2P8Acmd0f/YR9n/AE/jq + +YjlPIPHnwph8QW8drLrF5YWiMkpa3SSWBpdrZCiVieh6sAfQKMiivUEktNQMk8N7eWWCsRWKLz0iCqG + VURuoZXBL9mUr2oq+WJnzSPgmT7opiU+T7oqCvudT5skel5qP+Cko1Al5pydaE60eZ5b0agEn3RTeaSa + pKNQETrT32bKhj+/T361fMQLTkj+fZQlbnhXTftWo/N9xV31vh6Xtp8hnVq8kOcz7bR5Z/4K2H8OS7U+ + T+5XZ22mpB91KsvH/sV9dSyePL754MsfKRw1t4Zmnfe39+uk0rQIrG582tJP3a/w1N5lejh8BSonLVxE + 5FnzPemeZUPmUeZXqcxzE3mUzzKh30eZ/t1HMBN5nyUeZVbzKPMo5gJvMo8yofMpnmUcwFl5KZvqHzKP + MrPmAm30b6i5pPMo5gJvM8uia6edPmffUXNR+ZQWQ3NjFcJWVN4c8z7r1t+ZTPM964pYelM2jVkQ2emx + Wq/Kvz1Ypvme9M8ytowhD4DH3ybzKPM+eofMo8ytRD/M96Sm+ZTKz5gH+ZR5lMeSjzKOYsf5lHmVD5lH + mUuYfKTUzzKZ5n+3R5lTzCHvJR5lRUUcw+Uc8lHmVFRWfMWO30b6bRRzDHb6bTOaTzKjnDUf5lHmUz/d + qOs+YNSTzKPMpnmUlHMWSeZTPMpnmfJTqOYBfMpKZRUcwBRRTfMpAOptFFBYUUUVIBRRTPMoAfTJKPMo + oAKKKZQA/wAyjzKZ5lHmVABR5lFM30AP8yh6PMptWUOopm+lrPnJHUU2k30+Yof/AAUUzfSfPRzDJKPM + pm+m0uYB9FMoqOYB9FMoo5gH0yiio5jQTzKPMpvNHNHMA+k8ym80j0gH+ZQklN5o5qA1H0nmU3mjmgNS + XfT/ADKh8z+7R5lSWXIZP71WUkqgklTJJWEjqpSL++np+8/jqmklPSSuScL7no0pnqnw98f3FvZpojff + eXemz5Hf/gf8Dv8AIn+3XtltJdyeSk+7Ubm+i+2WV5DK6Psff/A/8fyJ8lfIXmSxujq/3Pnr2D4b+Kn1 + yz03QpXtUuYbhHtZnRN6P8++F3f7+/5ET+BHT56+BzPB/V588PhPoKFXn9w9ssLr7C/2SVPkhd0fyfn/ + AI/vp/sf7CU/xhvnmhigi893l8nZDLsd/k/8c+Sq011b+IHe7g+TUrT5NQhm+5E+x/kf+4nzp/45T9Ku + rSSzS38pr3Z87pv/AH2//gez7mxP+Af98V5XNzm/KQ6DPb647y2aS+c8SW0qQomxPn379+z7mxH3/c2U + +bwyl06OtwrukqbL/wCf/Xb/AJPk/wBv5ET/AGPn/j+S5eaH9h1L7Rsi2fO9xDC/3E2fO6b/AP0CrOm3 + 134gS53Jbz3/AJTvE94ibHTf8iPs+5s/gff8/wDsVjLmgafEZVtrEUEOt/adVuEm+0PN9phRHT7/AMmz + +5vdN+/7mxE/v7K3rO++16kifZLi6+1272yX6Jsf/U7/AJ9j/cTf990370+SuS1jw/cSeT5qNBbJE6RT + PLs+Tf8Ac/77/wDH/wDcq/o8ksn9mxLE17Z28vnfudnnI+/fCnz/AHNmxPkT7m//AG6z5S+Y0rOe9n01 + 3g8rfCm+68mV3eJ3+4ifP87ujo/zv9yq1/o/9pOlvLFLA7okL6wlq+y4/wBvfs++n3PubPk+emXOpWl9 + fpdxfaNPh+e8iT/R5oZbj+/s3p/GiIj/AMG93/2Kv3OyB7a3ttPun/0fY7+a832i78nfs+d/7j7NibE/ + 77qPeNDm4dG8QWtzv0xJdRtpopoYrZ7JLv7R/wBNkhf+P7/z/wAD/PV+GPVf7VSJPEFr4hubd5rlEton + Szsk2fwb0/fSpv2J8/z/ADvvTYm+/wCZ/wAS1Ps1xEnnbNjuj/ff5N/+38iOiJ/6HQ8llazTRf6PHpvz + zeSkroiOibN+/wCf53T59n/xFbSpc5HMUNNtXgSG4l+3pc3cqTWr/PCib/kRP43dEf8AjT+P+PZVzTZL + vUt+ntK376Lzre2mtfJe4ffsfZ8/yfx/I7/f2fxvTJo9PsbCHyks/t726Wdq9ts864h2b0RE/gR3f7n3 + Hf8AvvU1zodp5P719Ud7tLdPt/2h0s0RE3/cm+fYn33T5E+f+Ooj7khfGZVtfXGh39zZahZRb0ld5Zvs + rv8A3P43/g3/AMf+5WlZ2Mt1DYanA8unWz/Ijw73RPn/AINn3/nrEh1LStK1X+0LPULOfxCluiPNM6Q2 + zujokMPzp/uO/wDH9/Z8m96vzR6f4gvLC3vNb1bV3vonS9e2bZNKmzZsR0+fY/3N6f3/AJPk+St41f5y + PZFnVZLe1tksp92owzfP/wAe7/Jsff8AP/t70+4n+x86b6htvs98k0TaVriXl3cTOlm6J9p8lPn/AIN8 + Lv8A7G/5E3/79FhrFva6q8VncLPf2nySoj/PbpEiJv3v99NmxN/+2n9+i/8ADOn3VnYXEFl9qS3ut7vc + y/OjvvfYn39773d9/wBz5H/3KvlhMPeKFtobz6DDbxaro2kPDbu9k9zpr28339721on30R3/AL+xE++l + Gm2PhrSvD0MVnqFhZf6P9ve202Le9un9xNn3E+f5/k++9FtY/amRJZVgs5v+PhLaJH3/ANz/AH/v/f37 + Pv8AyVjw6UlrDeXEVxFZWdvFDvh+0OiS/f8AuJ/cT53fZURiHMc9f+PtaNvPf+Dtb1LW7K4ljilubKzi + kkh8tWCRpIPJAXlt6kM25F+70JXQapYT6tp4t9PFlbNdPHetBZ2CadGoEYUbl/crv+buC56McrRWfMB8 + JyfcqOp/Lpnl1+gany5HRUvNRUagTx/dNMf5Hp/8FMejUB6dafsNMj+6af8Ax09SCa3tfMXe26mPGm+u + z0HRlk0pGZPvVlXPh947x/k+SvZlgJ+yhOB50cVHm5DKs7VZnRNjf99V3OiaV9h3uv7vemyqej6P9l+d + q3vMr6HLsH7GPPM8vFYjnlyQJvn2ffamf8DpnmUeZXt8x54//ts1L/wNqj8ymeZ70FE3mUeZUPme9Hme + 9HMBN5lM8ymeZ70zzKjnAm8yjzKh8yjzKjmAm8ymeZ70zzKPMo5gH+Z70eZ/BUPmUeZRzATeZ70eZ71D + 5lHmUcwE3me9M8ymeZTPMo5hk3mUeZ/dqHzKHqOYof5lHmVDvpaXMA7zKKbSb6jmAfR5lRUUcxoO30tR + +ZS1HOMdvo30zzKPMoDUkplFR+ZQBJRUfmUvNLnDUfTOaTzKY8lRzBqSc0c1FS+ZUcxYlFMoo5gJPMpn + me9JRUcwC+Z70lNoo5gHUU2igAoplFBY+imeZRQAeZRTKKz5wH0eZTPMopgFHmU2igB1FNpN9AD6bRTK + XMUO30tMpP46jmAfvpnmUtFHMMKKKKjmEFFM5o5o5gH0VH5lD0cwD/MpaZzRzWfMajvMpaZzRzRzAPop + nNJ5lHMAvNHNHNRUcwEvNJ5lM8yko5g1JeaOaioqOcNSXmjmoqKOcNRfMpKKKjmDUl5o5o5o5o5iyKpP + Mpn+9UnNRzFjkkqZKhTrU3mVnzG8SZJKmSSq0dTJWEpHVEswyfwVNDP9km3r86Omx0qn/HVlJPkrzsRC + NaHJM9SjLkPXfBviq41iS28q4ig1hItllcwxJvTZ86QumzY6f3P7m/8A4BXq9hdS3VsmobJYNV3ulwjp + sd33/OibHdP4/wCCvnj4XaxaaV4kT7ZFLPvdPKhhRH3zfcRH3un9+vV08VXHhHUr/T4JYks7iXfcQwxJ + dpaeanyO7p8if7Cb/kr87xEfq1XkPdh78eY9L0q+fWXe3+zy70i+Tzvn/wBxP+B//EVm+MrWKCTe0Vui + TS738lPu/wC3vqF7rU3hh/s+7igS4/1rzOiJEifxzfPsT/4v/vitvw3rj6ron7+9iSFJdm+bfvR3/j2b + PkT+4/yJVcxHKYP9saffOlleXEv2++R3i+TfsTZv+f8Aufc/+w+5T5tK1Cd5ri5t7i1vLeX90k1u6Oj7 + 9+z5PkTZ8n3/AL6fP/BVzVfB1pYp9r0q9ffv86KbeiJv/wB/+5/6B/v1QmurvSoUlvpbp9j74kSXZbbE + dE+dNnz732f7dRy8hoMtr6y8m28pPtSb/wC5stkff8+9H+dPk+RNnz1cv9KiunSKz1CW6v3f7M9nDZfu + Xt/498yTb96fPsT/AH/76U+G6/tizh1D7JLp15s8l5kl+/Nv2Ps2Imz+P/brkrzSpYLl7ix8qO5/1KTP + Fs/3NlYSiXzHW6l4gl03+0rj7PFpCQ2SIlmjun77+5529/kf+NET5Pufx76p+Ho9T1W51KVdPX7NNLb7 + IbbeiS3Gz998iO77Pk+R9/z/ACJsT560vBPiaWTR3+02kt1qT3syW9tbWvnQxb4Uhfem9P8A2f7lQpff + 2bDDb3mmW/k6hF5NqmpP5Nzs3oiXPk/3PufJ/Bs3/J/Ae9EPjOnhsdPjubO01W9bw1qSPM/yIly/zp/G + n33d9if7myuA1LwrpniC8s9VXwor6988MTzInz70+R/kf/b/AINmyrP266g1S/vYLjSbVHR0sobOyea5 + uLjzk2fuUfZ86I6IiJv+R/v7627O6t5Jkt57fff6nLsS2SXZcvN8+93TY/8Auf7FEYx+2XzfyHE2cEXh + +6mlX7Lev9l2SpNve2e3fZv2I7v+9R9iJs+Tfs/gR3rtr/WPD99Yalb6ndalrdzqFhbwypDLcTXNw8Wz + Y6PbomxN6Om9/k+/s31f8u4js5rfU7dNOuf+XhPK8neiJvRHT+P7iP8AP9/fXPW1jcX2sWF7pVpdPM6b + 5UvLrZ9ntET/AJbeSj79+/Zsd0/36JR5SIyM2bx1pmpeBLmDXNNWDQbjzrBv7Vt007596fJFLvR0t9jp + v+f53T5/nplh4ctNH1i2efxBqmtp5tumx9NltktHdN8MMMKb3RHTZ999n3KreOPiho/w3ksrfxrqtrav + d28t5aPDZPLNK8ybHm+47ps3un/APk/grpE8Tah4q0HSk0W4W6vHZLl9VudS2Qpbv8jvCmz53+T+P502 + P86J8lY/a5ol/EVrzWNHjmS3leKG58pPNtvtW97d0f50TZ8j7Nj/AOw+x/v1jw+LfC/hLQZn1XxRa2sK + b3/4mV7515v3/Oj/AN93/wDiKJtD8V/aXuNM0qz1tNQleH59QitHt0RPkeben3/7ifO/9yub0rwzcWN5 + D4g8UWWgwX98nkxabNapNco6fP50z7Pn+RH/AI0TY6f7ldMZfykSMnWf2hJdRuQ/g3wVrGsWcnzNf6He + fZJWAAALlBJhWJY/OFZ8bv4aK9T+w6lZ3xsY4przUYUD3FnpiybrfcqEGTa+1dwClQOoBH8NFbRjpqZ8 + 0j8/3jptXvssv+zTPsr/AOzX6D7KZ8dGrEzfL+enwx76vpY/52VZh03zE+arjh5zLlXgZuxqZ5L10iaP + 5kn3KuQ6P/sV2xy6rM5ZYqEDmIbGV4/uVfsNDeeuqh0pI0q5DAkCV6mHyn+c4auM/lH2KfZbOGL+7T3j + TfR5lM8z56+khy8nIeSTeZ70eZ71DR5lPmEP8yimeZTPMo5gJvMpnmf3aZ5lDyVHMWP8yjzKh30b6OYC + bzKPMqKk30uYB/mUeZTPM/u0b6gB9FNoo5gHeZTaT/dptADt9G+lpN9AC0VH5lHmVHOaB5lHmU3mjmjn + GO8yjzKbzSPS5wH+ZTeaOaj8yo5gH+ZS81FS+ZRzBqSc0nmUzzKjqOYNSxzRzUHme9Hme9HMWTeZ/epn + mUzzPeko5iNR9L5lM8z3o8z3qOYsPM96PM/u0zzKKOYB7yUlNpnmUcwD/Mo8ymUVnzgP8yimUUcxYUeZ + TKKjmAf5lH+/TPMoo5gCjzP7tM30eZ/eo5gH0PTaTfRzAP8AMpm+jfTaOYofSPJTaKOYY+mUUVHMIKR+ + tLTOaOYB9FM5o5rPmGPpnNJ5lHmUcwC80c0c1H5lHMaEnNJ5lM8yjzKjmAk5o5qKijnAKKKKOcApfMpK + ZUahqPpfMpKKXMWFFFMp8xGpJ/vUlMooLH0Uyl/go1AdTKKKzAKKX/epKACiilSjmAdRTKXzPeo5gHUU + yio5yydJKm/jqsnSp6z5jeJLT46hSSpo6wkdUNyb/WJU0MlQpQn+srGUj0IEzRpJ977lei/DHxjLpttN + oltZWrzXybHmd3ff99EhdE++jvs+T/Y+T+OvOv8AWVpaVHb75vNtJbq5eJ0tfJldP9I+TY7/AN/+P5Pk + r57MaEa1LnPUw8uWR7l/aT+ALywuL5JdR0S7idPOmtdjvcI6fuXT7m//AGEf/froZtNi1iwfU9Du7X7M + j/PCkvz7/wC5Ds/j+dPkRP79UPCWpW/jzQZtHudTt9XmsYnm/wBPR3S3d/ndE2J/z23/AOp/j/jffvrj + NEtL3wd4ws7KfUGgeGV0iubZPOdNn99E2f8Aof3/AO5XxXNI9U9m0Hxok9v9i/gt33vNc/ciT+P5P87K + 2H020tb6G4ubSLUZl3okM0r+Sm/7j/I/zun+38leRW2uaZ4m02bVftf9nXPz3PnIj77hNmzY83yJ/t70 + 3/79dP4b8afarB4vN8/503o/yPv2J8j/APfFdkZc/uGEvcL+j6a+lX9ncanb3E6W8u97Pzf+Pt9/zzO6 + f39n3P8A0D7ldDrdrayTPFEkVrD9l2Wru+97hE++/k7/AN9sd9j70d5nfYmzZT3n+1Qv5Eu+881/kf5H + 3/8AxdVtKtbf+1byXWrfVHtnRPKttHlTeiI/yO/nPsT7/wAjp/G7vU1Y8kfcCMjN8Q2MvjjTXt9eu9Ug + sN8KSzaVLFaTXCRPvhTem/Z8+x/+Af7FVkg0+1he7vLuef7P5zvbJ++RE+R3ebf8mz/Y+f5EdP46uf8A + CVaPHo/9j2dpFda27pbXs2pIn+u/j2Ojvsi3/c/j+R3+ffsqy8kV1/x53bXUKf613tHhh3ps2Iiff37N + j/P8+zZ8lEZRmXKPIcfoPibw/wDELWJdQ0P/AEqa3Z0uNSvLeWF0fZ9+J0Tfs+RE2Js/uf3662HSbTwr + cv8AYb21S/8AtrwxPokSWz3to6fI7zTfOj/f+TZsT/gFVkkt7WHzZ18+2VHSKZP3O9N/3/8Af+T79UG0 + 2W+ffpWlWqTbHh3ukqTOmzfCmx/v7Nj/ACfx7P79KUeUIyJl8SaJa6O7rF5ELyo++2837N9nd9kM0M0z + 75kfZshTYifO77Pv1DDrmnyQ3NpeXth9ssdn2qw837S8XmpvRHf5P9/f/HsqnN4g1CxkTSrm0tfsevOi + RPqt0iTW/lP8/ko/77f8773/AP2KwdNtdQTQ7m303wkvhSz1Z5kTWLa9tHtvvujunkoju6In30T7n9z7 + 9c0avKXKPMdPf+EdE1hIbu+0ezury3R0Sa5tU/dI/wB/Z/t7/uf+OVDrEcWjPDd6hqsUFg7/ALpJnf5E + RPkhdNju7/c2P/sfP/crp7/wr4g8M+Bk8QahcXl7YaemyXVbyL7I77PnmdIX+/8AwbH3/PvTZXB+IPF3 + hrXPJt4PBmpeK9VuNk2y5t9iRQyp+5e4m/g3/P8AJ9//AGK6eaM/gIjH+Y6qw8aaZBpVtZaC+l3Xh7UH + S5d5pUR7jemz9y6Pvd0/jf8A2Pk3732cVd+LNF0f7DZXd/YwtZy+VBZzXqQwzs/3E8n59/yfc3/7710e + m+H7TVfCtnol94fs0ht5fO+zW0WxLebZsfZ8iffT/Y/3Nm+qGg/C/wANaBrb3Wn6LFpevStsTVbOLybl + N6bH8l/n2P8Awb/9v/gdHspRD2hyvjTxZZ+GdMhXxJJa6RYTzAqjWjy+fMilfM2d/lA+f/4uiu10n4a6 + l8O/En9oPqL3OpXdmYTJ4iu11KZoRJvVliZ/lBZ3G7/Z/wBuisuWRqfIf9jvspn9h1uZNGTX9C/UaR+R + /WJGZDoaR1chsYo/4KnyaMmuiFCnHZESnKY75I6KjyaMmteYjlJPMo8yo8mmZNHMIn8yjzKjyaMmjmDl + HUm+kyaMms+YBd9G+m1Huo5gH+ZS1Hup2TUcxoK/WlqPdTsmjmGL5lD9aZuob5elAh/+9S1Hup2TQZi+ + ZS1Huo3UcxoSUzmk3U7JqOYYnNPqvUm6lqAeZS80m6o6A1JeaOaiorMNSTzKjpNxptAahRRRUhqL5nvS + UrfJ0plBY6mvRRQAeZRRRQAUUUyoAf5lMoooAKKKZWdyx9MooeswDzKPMptFPmAdRTaKQDqbRSPQAtJ/ + HTaKCh9MooqACiio91AElFR7qN1PmAkqPzP71G6jdUczNQ8yl5qKijmYEnmUvNR/x0lHMwJPMpnmUlMr + PmAfRTKKOYsfTKKKLgL5n96kooqOYAooopAFFFFABRTadQAUUUUcwBRRTf46jmAdRSbqSgB1FJupKOYB + 70lNooLCiiio5mAeZTqTdSUAP8z3pKbRQAU6m0VGoRJk6VMnWqyVMlZG8SenJJUK9aen36yOqJZhkp71 + DHT3rCR1QJk+/wDLU3l/3d3+/VZKtIvy4ycVySPRgd94A+KGsaHeJFeXEt1pSb0+zfcRPkT7mz/YRE/u + fO9ekeM9Ni1hLbxBZyt/ZSb3+wPp7ww79iJv8n77p/Bs/wD26+ftNuJLVmuI2ZWhkQhVJUN/vYwT+dfS + Gn2KeIvBd9Z30ksiQ2kdx5iyFXdjJbhd2OCFDnAxj5VznAr4XE0YxqyPXpS90Z4b0fz9J825tJUs4dnl + eS+/fvfejoj7/k2P/wCgViaDdRQQvF5UU7vLsuH+dHl/2P7iJ99/7/z10XhORtQ0Cx+0kTStF9pebaFd + 2MaZDFQN2QSuSCwXgECsnw7a27+M9JsDAotWgRljUkCPdEAQoB4GCP8AvlfSuMo1dHnextkl3ypsdHR3 + l37E2b32V3ia5aSaakUSLdW2/wAn7Sl0j+Uj/wCw/wA7v/t/PXJGzttOmv7FLaJ7bTwlxBHIMgNLpzzv + kDrktsz1CAAHqTmeKPHmpeGbZzZpa7URp40aABY2BiTCgYwCGYkfxFiTmtIyHynV6lPd+GLx7dbeJIbi + 1eHyXt/k/e/c3v8AfdPubH/uJ/t1m6l40uHuYbjStKuL2z+y+Sj3ksX2yXY/yO6J8ibEd/n++7v/ALFd + J4gh+zfEK80eN3W2t7R76JwfnSRVQjB6Y+YDpn5EOcqDXA+G7yWTxR4d02eSS6tptaWBxLK+SnnzxAHD + DIAAbByNw9OKzEdHDJFqVncuvmwW3m+S73OzeiP9zeib9jv8nyf3NlPuNDstUt3sJZZ7JJd9ndJbNKk3 + z7P3KOj/ACP9/wDj/j/g/jzUhCyeOb2z8vS28P8AiBfDumw2VvEkcEBLHzApQ5lBAwT8uABtxxVfwXrb + +I/E+u6HNa2trZWZkZPsUXks375FIOOMNkscAZOD2Fawqe0+IfLymH4w+E/g+1mmtIE0aDTdPlSZ7m2d + /tkU2/5He4dPkih+T5Pub/vvW9qsjeI4bbVbm4l1SFJU+z75USF/kRPkhd3RHf76f7FaVxq01jHaXEap + 5k9qzHcCQpwSNvPG0xjHpk+pqHRbqXxZqWi6XduVW4soZ57ofvLiZmdDl3k3ZIHyKeqrwpFL2aiHNzGV + cz28fh68lubK8+374baLw9bIn2Z7eL7m95n+R/n37N/z/wCx89M8Tya7deD5k0O7l0XUtTdJrW5SJJnl + ff8Ac2b/AOBPk3/wfOiI9ZsSz3Gg3OqvfXRaxYxx2rSboHUrvIdCDvO/5txOSepI4rW03S/7e1nRNV1S + 9vdQuv7Qt9KVZrhhHHbvLyqIuFUg8ggZB5HNRGIiX4aR+ILrTXl167t9X1LekMr6VZP5MXybEf59m/5/ + k+5s+f8Ajref7Pa69c6PKyprFu8MNxDbJve33/OjzIn3PkffXn3xg+N/iT4LPqlzohtrya/m8yRtTRpQ + gCPhEAZQq5wcD0A6cVz3g1jJodx8SbxpNQ8U+JdRl+2SzzOsCCJdqhIY2VO5PzBsHkYrSNR83KEqa5ec + 9ftbyK6muLVbW5uZo9ryQXFnLEOh/eIZFAIbqdpIwy7eM0VzviLxNc6HJa2yxQXkcaMq/aVJI5/2SKKs + k//Z + + + \ No newline at end of file diff --git a/201731024118/DianMing/DianMing/Program.cs b/201731024118/DianMing/DianMing/Program.cs new file mode 100644 index 0000000..62e9470 --- /dev/null +++ b/201731024118/DianMing/DianMing/Program.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace DianMing +{ + static class Program + { + /// + /// 应用程序的主入口点。 + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new WinformControlUse.Form1()); + } + } +} diff --git a/201731024118/DianMing/DianMing/Properties/AssemblyInfo.cs b/201731024118/DianMing/DianMing/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..5c32070 --- /dev/null +++ b/201731024118/DianMing/DianMing/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的一般信息由以下 +// 控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("DianMing")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("DianMing")] +[assembly: AssemblyCopyright("Copyright © 2019")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 会使此程序集中的类型 +//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型 +//请将此类型的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("67e8063d-ea75-40f2-b853-cd907d64d82d")] + +// 程序集的版本信息由下列四个值组成: +// +// 主版本 +// 次版本 +// 生成号 +// 修订号 +// +// 可以指定所有值，也可以使用以下所示的 "*" 预置版本号和修订号 +// 方法是按如下所示使用“*”: : +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/201731024118/DianMing/DianMing/Properties/Resources.Designer.cs b/201731024118/DianMing/DianMing/Properties/Resources.Designer.cs new file mode 100644 index 0000000..1f285db --- /dev/null +++ b/201731024118/DianMing/DianMing/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 此代码由工具生成。 +// 运行时版本: 4.0.30319.42000 +// +// 对此文件的更改可能导致不正确的行为，如果 +// 重新生成代码，则所做更改将丢失。 +// +//------------------------------------------------------------------------------ + +namespace DianMing.Properties +{ + + + /// + /// 强类型资源类，用于查找本地化字符串等。 + /// + // 此类是由 StronglyTypedResourceBuilder + // 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。 + // 若要添加或删除成员，请编辑 .ResX 文件，然后重新运行 ResGen + // (以 /str 作为命令选项)，或重新生成 VS 项目。 + [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() + { + } + + /// + /// 返回此类使用的缓存 ResourceManager 实例。 + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DianMing.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// 覆盖当前线程的 CurrentUICulture 属性 + /// 使用此强类型的资源类的资源查找。 + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/201731024118/DianMing/DianMing/Properties/Resources.resx b/201731024118/DianMing/DianMing/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/201731024118/DianMing/DianMing/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/201731024118/DianMing/DianMing/Properties/Settings.Designer.cs b/201731024118/DianMing/DianMing/Properties/Settings.Designer.cs new file mode 100644 index 0000000..b7e9e72 --- /dev/null +++ b/201731024118/DianMing/DianMing/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace DianMing.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.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; + } + } + } +} diff --git a/201731024118/DianMing/DianMing/Properties/Settings.settings b/201731024118/DianMing/DianMing/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/201731024118/DianMing/DianMing/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/201731024118/DianMing/Entity/Entity.csproj b/201731024118/DianMing/Entity/Entity.csproj new file mode 100644 index 0000000..7f3b267 --- /dev/null +++ b/201731024118/DianMing/Entity/Entity.csproj @@ -0,0 +1,47 @@ + + + + + Debug + AnyCPU + {E93667D6-319C-489D-92E1-E82A19454CF2} + Library + Properties + Entity + Entity + v4.0 + 512 + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/201731024118/DianMing/Entity/Properties/AssemblyInfo.cs b/201731024118/DianMing/Entity/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..a742db4 --- /dev/null +++ b/201731024118/DianMing/Entity/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的一般信息由以下 +// 控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("Entity")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Entity")] +[assembly: AssemblyCopyright("Copyright © 2019")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 会使此程序集中的类型 +//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型 +//请将此类型的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("e93667d6-319c-489d-92e1-e82a19454cf2")] + +// 程序集的版本信息由下列四个值组成: +// +// 主版本 +// 次版本 +// 生成号 +// 修订号 +// +// 可以指定所有值，也可以使用以下所示的 "*" 预置版本号和修订号 +//通过使用 "*"，如下所示: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/201731024118/DianMing/Entity/student.cs b/201731024118/DianMing/Entity/student.cs new file mode 100644 index 0000000..16dccc6 --- /dev/null +++ b/201731024118/DianMing/Entity/student.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Entity +{ + public class Student + { + private String id; + + public String Id + { + get { return id; } + set { id = value; } + } + + private String name; + + public String Name + { + get { return name; } + set { name = value; } + } + + public Student() + { + + } + public Student(String id, String name) + { + this.id = id; + this.name = name; + } + } +} From 030f2b4ce021266e573f1df8f84edff86c894106 Mon Sep 17 00:00:00 2001 From: lzzz7 <1245736788@qq.com> Date: Mon, 30 Sep 2019 22:02:03 +0800 Subject: [PATCH 3/3] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E6=8A=BD=E5=8F=96?= =?UTF-8?q?=E5=AD=A6=E5=8F=B7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../DianMing/DataBase/StudentDataset.cs | 106 +++++++++--------- .../DianMing/DianMing/Form1.Designer.cs | 30 +++-- 201731024118/DianMing/DianMing/Form1.cs | 1 + 3 files changed, 76 insertions(+), 61 deletions(-) diff --git a/201731024118/DianMing/DataBase/StudentDataset.cs b/201731024118/DianMing/DataBase/StudentDataset.cs index 68a6602..0496dbc 100644 --- a/201731024118/DianMing/DataBase/StudentDataset.cs +++ b/201731024118/DianMing/DataBase/StudentDataset.cs @@ -40,9 +40,9 @@ public static List getAll() studengList.Add(stu8); - Student stu9 = new Student("001", "许博"); + Student stu9 = new Student("009", "许博"); studengList.Add(stu9); - Student stu10 = new Student("002", "芦文钰"); + Student stu10 = new Student("010", "芦文钰"); studengList.Add(stu10); Student stu11 = new Student("011", "马昊妍"); @@ -103,130 +103,130 @@ public static List getAll() - Student stu33 = new Student("027", "陈林"); + Student stu33 = new Student("033", "陈林"); studengList.Add(stu33); - Student stu34 = new Student("028", "曾正男"); + Student stu34 = new Student("034", "曾正男"); studengList.Add(stu34); - Student stu35 = new Student("029", "江天宇"); + Student stu35 = new Student("035", "江天宇"); studengList.Add(stu35); Student stu36 = new Student("036", "魏恩博"); studengList.Add(stu36); - Student stu37 = new Student("031", "邹扬锋"); + Student stu37 = new Student("037", "邹扬锋"); studengList.Add(stu37); - Student stu38 = new Student("032", "曾琅"); + Student stu38 = new Student("038", "曾琅"); studengList.Add(stu38); - Student stu39 = new Student("032", "周成杰"); + Student stu39 = new Student("039", "周成杰"); studengList.Add(stu39); - Student stu40 = new Student("032", "马驰"); + Student stu40 = new Student("040", "马驰"); studengList.Add(stu40); - Student stu41 = new Student("032", "宋树钱"); + Student stu41 = new Student("041", "宋树钱"); studengList.Add(stu41); - Student stu42 = new Student("032", "马驰"); + Student stu42 = new Student("042", "马驰"); studengList.Add(stu42); - Student stu43 = new Student("032", "任星辰"); + Student stu43 = new Student("043", "任星辰"); studengList.Add(stu43); - Student stu44 = new Student("032", "严一笑"); + Student stu44 = new Student("044", "严一笑"); studengList.Add(stu44); - Student stu45 = new Student("032", "孙颖"); + Student stu45 = new Student("045", "孙颖"); studengList.Add(stu45); - Student stu46 = new Student("032", "吴明益"); + Student stu46 = new Student("046", "吴明益"); studengList.Add(stu46); - Student stu47 = new Student("032", "黄耀萱"); + Student stu47 = new Student("047", "黄耀萱"); studengList.Add(stu47); - Student stu48 = new Student("032", "王静宜"); + Student stu48 = new Student("048", "王静宜"); studengList.Add(stu48); - Student stu49 = new Student("032", "蔡玉蓝"); + Student stu49 = new Student("049", "蔡玉蓝"); studengList.Add(stu49); - Student stu50 = new Student("032", "姜仪"); + Student stu50 = new Student("050", "姜仪"); studengList.Add(stu50); - Student stu51 = new Student("032", "郑雪"); + Student stu51 = new Student("051", "郑雪"); studengList.Add(stu51); - Student stu52 = new Student("032", "刘俊"); + Student stu52 = new Student("052", "刘俊"); studengList.Add(stu52); - Student stu53 = new Student("032", "何玉姣"); + Student stu53 = new Student("053", "何玉姣"); studengList.Add(stu53); - Student stu54 = new Student("032", "匡小娟"); + Student stu54 = new Student("054", "匡小娟"); studengList.Add(stu54); - Student stu55 = new Student("032", "王春兰"); + Student stu55 = new Student("055", "王春兰"); studengList.Add(stu55); - Student stu56 = new Student("032", "顾毓"); + Student stu56 = new Student("056", "顾毓"); studengList.Add(stu56); - Student stu57 = new Student("032", "师志杰"); + Student stu57 = new Student("057", "师志杰"); studengList.Add(stu57); - Student stu58 = new Student("032", "许佳文"); + Student stu58 = new Student("058", "许佳文"); studengList.Add(stu58); - Student stu59 = new Student("032", "雷安勇"); + Student stu59 = new Student("059", "雷安勇"); studengList.Add(stu59); - Student stu60 = new Student("032", "张伟"); + Student stu60 = new Student("060", "张伟"); studengList.Add(stu60); - Student stu61 = new Student("032", "袁志杰"); + Student stu61 = new Student("061", "袁志杰"); studengList.Add(stu61); - Student stu62 = new Student("032", "何全江"); + Student stu62 = new Student("062", "何全江"); studengList.Add(stu62); - Student stu63 = new Student("032", "舒鹏飞"); + Student stu63 = new Student("063", "舒鹏飞"); studengList.Add(stu63); - Student stu64 = new Student("032", "何辉"); + Student stu64 = new Student("064", "何辉"); studengList.Add(stu64); - Student stu65 = new Student("032", "李全喜"); + Student stu65 = new Student("065", "李全喜"); studengList.Add(stu65); - Student stu66 = new Student("032", "谢凯宇"); + Student stu66 = new Student("066", "谢凯宇"); studengList.Add(stu66); - Student stu67 = new Student("032", "黄本巍"); + Student stu67 = new Student("067", "黄本巍"); studengList.Add(stu67); - Student stu68 = new Student("032", "罗俊杰"); + Student stu68 = new Student("068", "罗俊杰"); studengList.Add(stu68); - Student stu69 = new Student("032", "何宸锐"); + Student stu69 = new Student("069", "何宸锐"); studengList.Add(stu69); - Student stu70 = new Student("032", "付昶宇"); + Student stu70 = new Student("070", "付昶宇"); studengList.Add(stu70); - Student stu71 = new Student("032", "傅伟鑫"); + Student stu71 = new Student("071", "傅伟鑫"); studengList.Add(stu71); - Student stu72 = new Student("032", "王云飞"); + Student stu72 = new Student("072", "王云飞"); studengList.Add(stu72); - Student stu73 = new Student("032", "李元港"); + Student stu73 = new Student("073", "李元港"); studengList.Add(stu73); - Student stu74 = new Student("032", "赵荣泽"); + Student stu74 = new Student("074", "赵荣泽"); studengList.Add(stu74); - Student stu75 = new Student("032", "吴郑浩"); + Student stu75 = new Student("075", "吴郑浩"); studengList.Add(stu75); - Student stu76 = new Student("032", "何继武"); + Student stu76 = new Student("076", "何继武"); studengList.Add(stu76); - Student stu77 = new Student("032", "郑博"); + Student stu77 = new Student("077", "郑博"); studengList.Add(stu77); - Student stu78 = new Student("032", "王万成"); + Student stu78 = new Student("078", "王万成"); studengList.Add(stu78); - Student stu79 = new Student("032", "陈杰"); + Student stu79 = new Student("079", "陈杰"); studengList.Add(stu79); - Student stu80 = new Student("032", "胡志伟"); + Student stu80 = new Student("080", "胡志伟"); studengList.Add(stu80); - Student stu81 = new Student("032", "涂林"); + Student stu81 = new Student("081", "涂林"); studengList.Add(stu81); - Student stu82 = new Student("032", "孟诚成"); + Student stu82 = new Student("082", "孟诚成"); studengList.Add(stu82); - Student stu83 = new Student("032", "廖志丹"); + Student stu83 = new Student("083", "廖志丹"); studengList.Add(stu83); - Student stu84 = new Student("032", "杨也"); + Student stu84 = new Student("084", "杨也"); studengList.Add(stu84); diff --git a/201731024118/DianMing/DianMing/Form1.Designer.cs b/201731024118/DianMing/DianMing/Form1.Designer.cs index 935e1f3..6b67cfc 100644 --- a/201731024118/DianMing/DianMing/Form1.Designer.cs +++ b/201731024118/DianMing/DianMing/Form1.Designer.cs @@ -43,8 +43,9 @@ private void InitializeComponent() this.timerCallName = new System.Windows.Forms.Timer(this.components); this.panel3 = new System.Windows.Forms.Panel(); this.panel4 = new System.Windows.Forms.Panel(); - this.lblName = new System.Windows.Forms.Label(); this.label2 = new System.Windows.Forms.Label(); + this.lblName = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); ((System.ComponentModel.ISupportInitialize)(this.dgvStuList)).BeginInit(); this.panel1.SuspendLayout(); this.panel2.SuspendLayout(); @@ -181,6 +182,7 @@ private void InitializeComponent() // panel4 // this.panel4.BackColor = System.Drawing.Color.Transparent; + this.panel4.Controls.Add(this.label3); this.panel4.Controls.Add(this.label2); this.panel4.Controls.Add(this.progressName); this.panel4.Controls.Add(this.lblName); @@ -191,6 +193,15 @@ private void InitializeComponent() this.panel4.TabIndex = 8; this.panel4.Paint += new System.Windows.Forms.PaintEventHandler(this.panel4_Paint); // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(0, 0); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(55, 15); + this.label2.TabIndex = 8; + this.label2.Text = "label2"; + // // lblName // this.lblName.AutoSize = true; @@ -202,14 +213,16 @@ private void InitializeComponent() this.lblName.Size = new System.Drawing.Size(0, 98); this.lblName.TabIndex = 7; // - // label2 + // label3 // - this.label2.AutoSize = true; - this.label2.Location = new System.Drawing.Point(0, 0); - this.label2.Name = "label2"; - this.label2.Size = new System.Drawing.Size(55, 15); - this.label2.TabIndex = 8; - this.label2.Text = "label2"; + this.label3.AutoSize = true; + this.label3.Font = new System.Drawing.Font("宋体", 36F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(134))); + this.label3.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(255)))), ((int)(((byte)(128)))), ((int)(((byte)(0))))); + this.label3.Location = new System.Drawing.Point(679, 90); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(147, 60); + this.label3.TabIndex = 9; + this.label3.Text = "学号"; // // Form1 // @@ -256,5 +269,6 @@ private void InitializeComponent() private System.Windows.Forms.Panel panel4; private System.Windows.Forms.Label lblName; private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label3; } } \ No newline at end of file diff --git a/201731024118/DianMing/DianMing/Form1.cs b/201731024118/DianMing/DianMing/Form1.cs index 806dbe1..c9346f7 100644 --- a/201731024118/DianMing/DianMing/Form1.cs +++ b/201731024118/DianMing/DianMing/Form1.cs @@ -77,6 +77,7 @@ private void timerCallName_Tick(object sender, EventArgs e) Random ra = new Random(); int i = ra.Next(stuList.Count); lblName.Text = stuList[i].Name; + label3.Text = stuList[i].Id; }