commit dfabe611babba8844f162e98c8792e2a13520af3
Author: 尚美 <2370337237@qq.com>
Date: Wed Mar 12 14:06:44 2025 +0800
初始化提交
diff --git a/.vs/ProjectEvaluation/quicklauncher.metadata.v9.bin b/.vs/ProjectEvaluation/quicklauncher.metadata.v9.bin
new file mode 100644
index 0000000..e3f2c7d
Binary files /dev/null and b/.vs/ProjectEvaluation/quicklauncher.metadata.v9.bin differ
diff --git a/.vs/ProjectEvaluation/quicklauncher.projects.v9.bin b/.vs/ProjectEvaluation/quicklauncher.projects.v9.bin
new file mode 100644
index 0000000..474ed3d
Binary files /dev/null and b/.vs/ProjectEvaluation/quicklauncher.projects.v9.bin differ
diff --git a/.vs/ProjectEvaluation/quicklauncher.strings.v9.bin b/.vs/ProjectEvaluation/quicklauncher.strings.v9.bin
new file mode 100644
index 0000000..8288928
Binary files /dev/null and b/.vs/ProjectEvaluation/quicklauncher.strings.v9.bin differ
diff --git a/.vs/QuickLauncher/CopilotIndices/17.13.439.2385/CodeChunks.db b/.vs/QuickLauncher/CopilotIndices/17.13.439.2385/CodeChunks.db
new file mode 100644
index 0000000..c2b449e
Binary files /dev/null and b/.vs/QuickLauncher/CopilotIndices/17.13.439.2385/CodeChunks.db differ
diff --git a/.vs/QuickLauncher/CopilotIndices/17.13.439.2385/SemanticSymbols.db b/.vs/QuickLauncher/CopilotIndices/17.13.439.2385/SemanticSymbols.db
new file mode 100644
index 0000000..08934d9
Binary files /dev/null and b/.vs/QuickLauncher/CopilotIndices/17.13.439.2385/SemanticSymbols.db differ
diff --git a/.vs/QuickLauncher/DesignTimeBuild/.dtbcache.v2 b/.vs/QuickLauncher/DesignTimeBuild/.dtbcache.v2
new file mode 100644
index 0000000..c52f4ac
Binary files /dev/null and b/.vs/QuickLauncher/DesignTimeBuild/.dtbcache.v2 differ
diff --git a/.vs/QuickLauncher/FileContentIndex/0afd8cc9-2b3f-4815-9025-1d55fc4d759c.vsidx b/.vs/QuickLauncher/FileContentIndex/0afd8cc9-2b3f-4815-9025-1d55fc4d759c.vsidx
new file mode 100644
index 0000000..f0b136c
Binary files /dev/null and b/.vs/QuickLauncher/FileContentIndex/0afd8cc9-2b3f-4815-9025-1d55fc4d759c.vsidx differ
diff --git a/.vs/QuickLauncher/FileContentIndex/b506e14f-896f-4f86-8602-f1cfaecf95aa.vsidx b/.vs/QuickLauncher/FileContentIndex/b506e14f-896f-4f86-8602-f1cfaecf95aa.vsidx
new file mode 100644
index 0000000..6794246
Binary files /dev/null and b/.vs/QuickLauncher/FileContentIndex/b506e14f-896f-4f86-8602-f1cfaecf95aa.vsidx differ
diff --git a/.vs/QuickLauncher/v17/.futdcache.v2 b/.vs/QuickLauncher/v17/.futdcache.v2
new file mode 100644
index 0000000..6489d15
Binary files /dev/null and b/.vs/QuickLauncher/v17/.futdcache.v2 differ
diff --git a/.vs/QuickLauncher/v17/.suo b/.vs/QuickLauncher/v17/.suo
new file mode 100644
index 0000000..103291c
Binary files /dev/null and b/.vs/QuickLauncher/v17/.suo differ
diff --git a/.vs/QuickLauncher/v17/DocumentLayout.backup.json b/.vs/QuickLauncher/v17/DocumentLayout.backup.json
new file mode 100644
index 0000000..2c19a39
--- /dev/null
+++ b/.vs/QuickLauncher/v17/DocumentLayout.backup.json
@@ -0,0 +1,44 @@
+{
+ "Version": 1,
+ "WorkspaceRootPath": "I:\\Desktop\\CusserCore\\ToolBox\\",
+ "Documents": [
+ {
+ "AbsoluteMoniker": "D:0:0:{8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}|QuickLauncher.csproj|i:\\desktop\\cussercore\\toolbox\\mainform.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form",
+ "RelativeMoniker": "D:0:0:{8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}|QuickLauncher.csproj|solutionrelative:mainform.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form"
+ }
+ ],
+ "DocumentGroupContainers": [
+ {
+ "Orientation": 0,
+ "VerticalTabListWidth": 256,
+ "DocumentGroups": [
+ {
+ "DockedWidth": 200,
+ "SelectedChildIndex": 2,
+ "Children": [
+ {
+ "$type": "Bookmark",
+ "Name": "ST:0:0:{cce594b6-0c39-4442-ba28-10c64ac7e89f}"
+ },
+ {
+ "$type": "Bookmark",
+ "Name": "ST:0:0:{aa2115a1-9712-457b-9047-dbb71ca2cdd2}"
+ },
+ {
+ "$type": "Document",
+ "DocumentIndex": 0,
+ "Title": "MainForm.cs [\u8BBE\u8BA1]",
+ "DocumentMoniker": "I:\\Desktop\\CusserCore\\ToolBox\\MainForm.cs",
+ "RelativeDocumentMoniker": "MainForm.cs",
+ "ToolTip": "I:\\Desktop\\CusserCore\\ToolBox\\MainForm.cs [\u8BBE\u8BA1]*",
+ "RelativeToolTip": "MainForm.cs [\u8BBE\u8BA1]*",
+ "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|",
+ "WhenOpened": "2025-03-12T06:05:42.834Z",
+ "EditorCaption": " [\u8BBE\u8BA1]"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/.vs/QuickLauncher/v17/DocumentLayout.json b/.vs/QuickLauncher/v17/DocumentLayout.json
new file mode 100644
index 0000000..f73da02
--- /dev/null
+++ b/.vs/QuickLauncher/v17/DocumentLayout.json
@@ -0,0 +1,44 @@
+{
+ "Version": 1,
+ "WorkspaceRootPath": "I:\\Desktop\\CusserCore\\ToolBox\\",
+ "Documents": [
+ {
+ "AbsoluteMoniker": "D:0:0:{8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}|QuickLauncher.csproj|i:\\desktop\\cussercore\\toolbox\\mainform.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form",
+ "RelativeMoniker": "D:0:0:{8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}|QuickLauncher.csproj|solutionrelative:mainform.cs||{A6C744A8-0E4A-4FC6-886A-064283054674}|Form"
+ }
+ ],
+ "DocumentGroupContainers": [
+ {
+ "Orientation": 0,
+ "VerticalTabListWidth": 256,
+ "DocumentGroups": [
+ {
+ "DockedWidth": 200,
+ "SelectedChildIndex": 2,
+ "Children": [
+ {
+ "$type": "Bookmark",
+ "Name": "ST:0:0:{cce594b6-0c39-4442-ba28-10c64ac7e89f}"
+ },
+ {
+ "$type": "Bookmark",
+ "Name": "ST:0:0:{aa2115a1-9712-457b-9047-dbb71ca2cdd2}"
+ },
+ {
+ "$type": "Document",
+ "DocumentIndex": 0,
+ "Title": "MainForm.cs [\u8BBE\u8BA1]",
+ "DocumentMoniker": "I:\\Desktop\\CusserCore\\ToolBox\\MainForm.cs",
+ "RelativeDocumentMoniker": "MainForm.cs",
+ "ToolTip": "I:\\Desktop\\CusserCore\\ToolBox\\MainForm.cs [\u8BBE\u8BA1]",
+ "RelativeToolTip": "MainForm.cs [\u8BBE\u8BA1]",
+ "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000738|",
+ "WhenOpened": "2025-03-12T06:05:42.834Z",
+ "EditorCaption": " [\u8BBE\u8BA1]"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/MainForm.Designer.cs b/MainForm.Designer.cs
new file mode 100644
index 0000000..00d4507
--- /dev/null
+++ b/MainForm.Designer.cs
@@ -0,0 +1,186 @@
+namespace QuickLauncher
+{
+ partial class MainForm
+ {
+ ///
+ /// 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()
+ {
+ System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm));
+ leftPanel = new Panel();
+ rightPanel = new Panel();
+ shortcutsPanel = new FlowLayoutPanel();
+ toolPanel = new Panel();
+ addButton = new Button();
+ categoryLabel = new Label();
+ menuStrip = new MenuStrip();
+ fileMenu = new ToolStripMenuItem();
+ addCategoryItem = new ToolStripMenuItem();
+ deleteCategoryItem = new ToolStripMenuItem();
+ rightPanel.SuspendLayout();
+ toolPanel.SuspendLayout();
+ menuStrip.SuspendLayout();
+ SuspendLayout();
+ //
+ // leftPanel
+ //
+ leftPanel.AutoScroll = true;
+ leftPanel.BackColor = Color.FromArgb(230, 255, 230);
+ leftPanel.Dock = DockStyle.Left;
+ leftPanel.Location = new Point(0, 36);
+ leftPanel.Margin = new Padding(6, 6, 6, 6);
+ leftPanel.Name = "leftPanel";
+ leftPanel.Size = new Size(275, 1164);
+ leftPanel.TabIndex = 0;
+ //
+ // rightPanel
+ //
+ rightPanel.BackColor = Color.White;
+ rightPanel.Controls.Add(shortcutsPanel);
+ rightPanel.Controls.Add(toolPanel);
+ rightPanel.Dock = DockStyle.Fill;
+ rightPanel.Location = new Point(275, 36);
+ rightPanel.Margin = new Padding(6, 6, 6, 6);
+ rightPanel.Name = "rightPanel";
+ rightPanel.Size = new Size(1192, 1164);
+ rightPanel.TabIndex = 1;
+ //
+ // shortcutsPanel
+ //
+ shortcutsPanel.AllowDrop = true;
+ shortcutsPanel.AutoScroll = true;
+ shortcutsPanel.BackColor = Color.White;
+ shortcutsPanel.Dock = DockStyle.Fill;
+ shortcutsPanel.Location = new Point(0, 80);
+ shortcutsPanel.Margin = new Padding(6, 6, 6, 6);
+ shortcutsPanel.Name = "shortcutsPanel";
+ shortcutsPanel.Padding = new Padding(18, 20, 18, 20);
+ shortcutsPanel.Size = new Size(1192, 1084);
+ shortcutsPanel.TabIndex = 1;
+ //
+ // toolPanel
+ //
+ toolPanel.BackColor = Color.FromArgb(240, 240, 240);
+ toolPanel.Controls.Add(addButton);
+ toolPanel.Controls.Add(categoryLabel);
+ toolPanel.Dock = DockStyle.Top;
+ toolPanel.Location = new Point(0, 0);
+ toolPanel.Margin = new Padding(6, 6, 6, 6);
+ toolPanel.Name = "toolPanel";
+ toolPanel.Padding = new Padding(9, 10, 9, 10);
+ toolPanel.Size = new Size(1192, 80);
+ toolPanel.TabIndex = 0;
+ //
+ // addButton
+ //
+ addButton.BackColor = Color.FromArgb(200, 255, 200);
+ addButton.FlatStyle = FlatStyle.Flat;
+ addButton.Location = new Point(18, 10);
+ addButton.Margin = new Padding(6, 6, 6, 6);
+ addButton.Name = "addButton";
+ addButton.Size = new Size(183, 60);
+ addButton.TabIndex = 0;
+ addButton.Text = "添加程序";
+ addButton.UseVisualStyleBackColor = false;
+ addButton.Click += AddButton_Click;
+ //
+ // categoryLabel
+ //
+ categoryLabel.AutoSize = true;
+ categoryLabel.Font = new Font("Microsoft YaHei UI", 10F, FontStyle.Regular, GraphicsUnit.Point);
+ categoryLabel.Location = new Point(220, 20);
+ categoryLabel.Margin = new Padding(6, 0, 6, 0);
+ categoryLabel.Name = "categoryLabel";
+ categoryLabel.Size = new Size(0, 27);
+ categoryLabel.TabIndex = 1;
+ //
+ // menuStrip
+ //
+ menuStrip.ImageScalingSize = new Size(24, 24);
+ menuStrip.Items.AddRange(new ToolStripItem[] { fileMenu });
+ menuStrip.Location = new Point(0, 0);
+ menuStrip.Name = "menuStrip";
+ menuStrip.Padding = new Padding(11, 4, 0, 4);
+ menuStrip.Size = new Size(1467, 36);
+ menuStrip.TabIndex = 2;
+ //
+ // fileMenu
+ //
+ fileMenu.DropDownItems.AddRange(new ToolStripItem[] { addCategoryItem, deleteCategoryItem });
+ fileMenu.Name = "fileMenu";
+ fileMenu.Size = new Size(62, 28);
+ fileMenu.Text = "菜单";
+ //
+ // addCategoryItem
+ //
+ addCategoryItem.Name = "addCategoryItem";
+ addCategoryItem.Size = new Size(218, 34);
+ addCategoryItem.Text = "添加新分类";
+ addCategoryItem.Click += AddCategory_Click;
+ //
+ // deleteCategoryItem
+ //
+ deleteCategoryItem.Name = "deleteCategoryItem";
+ deleteCategoryItem.Size = new Size(218, 34);
+ deleteCategoryItem.Text = "删除当前分类";
+ deleteCategoryItem.Click += DeleteCategory_Click;
+ //
+ // MainForm
+ //
+ AutoScaleDimensions = new SizeF(11F, 24F);
+ AutoScaleMode = AutoScaleMode.Font;
+ ClientSize = new Size(1467, 1200);
+ Controls.Add(rightPanel);
+ Controls.Add(leftPanel);
+ Controls.Add(menuStrip);
+ Icon = (Icon)resources.GetObject("$this.Icon");
+ MainMenuStrip = menuStrip;
+ Margin = new Padding(6, 6, 6, 6);
+ Name = "MainForm";
+ StartPosition = FormStartPosition.CenterScreen;
+ Text = "快捷启动工具箱";
+ rightPanel.ResumeLayout(false);
+ toolPanel.ResumeLayout(false);
+ toolPanel.PerformLayout();
+ menuStrip.ResumeLayout(false);
+ menuStrip.PerformLayout();
+ ResumeLayout(false);
+ PerformLayout();
+ }
+
+ #endregion
+
+ private System.Windows.Forms.Panel leftPanel;
+ private System.Windows.Forms.Panel rightPanel;
+ private System.Windows.Forms.Panel toolPanel;
+ private System.Windows.Forms.Button addButton;
+ private System.Windows.Forms.Label categoryLabel;
+ private System.Windows.Forms.FlowLayoutPanel shortcutsPanel;
+ private System.Windows.Forms.MenuStrip menuStrip;
+ private System.Windows.Forms.ToolStripMenuItem fileMenu;
+ private System.Windows.Forms.ToolStripMenuItem addCategoryItem;
+ private System.Windows.Forms.ToolStripMenuItem deleteCategoryItem;
+ }
+}
\ No newline at end of file
diff --git a/MainForm.cs b/MainForm.cs
new file mode 100644
index 0000000..a0b31eb
--- /dev/null
+++ b/MainForm.cs
@@ -0,0 +1,999 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using System.Linq;
+
+namespace QuickLauncher
+{
+ public partial class MainForm : Form
+ {
+ private Dictionary> categories;
+ private string dataFilePath = "shortcuts.json";
+ private string settingsFilePath = "settings.json";
+ private const int CATEGORY_BUTTON_HEIGHT = 40;
+ private string currentCategory = "";
+ private ContextMenuStrip categoryContextMenu;
+ private ContextMenuStrip shortcutsPanelContextMenu;
+ private ContextMenuStrip shortcutItemContextMenu;
+ private int iconSize = 48; // 默认图标大小
+ private const int MIN_ICON_SIZE = 24; // 最小图标大小
+ private const int MAX_ICON_SIZE = 256; // 增加最大图标大小到256
+ private const int ICON_SIZE_STEP = 16; // 增加每次缩放的步长
+
+ // 用于保存设置的类
+ private class AppSettings
+ {
+ public string LastSelectedCategory { get; set; } = "";
+ public string SortMode { get; set; } = "Name"; // Name, DateAdded
+ public int IconSize { get; set; } = 48; // 保存图标大小
+ }
+
+ private AppSettings settings = new AppSettings();
+
+ public MainForm()
+ {
+ InitializeComponent();
+
+ // 配置工具提示 - 调整为更合适的值
+ toolTip1 = new ToolTip();
+ toolTip1.AutoPopDelay = 5000;
+ toolTip1.InitialDelay = 200; // 稍微增加初始延迟
+ toolTip1.ReshowDelay = 200; // 稍微增加重新显示延迟
+ toolTip1.ShowAlways = true;
+ toolTip1.UseFading = true;
+ toolTip1.IsBalloon = false; // 使用标准样式
+
+ SetupContextMenus();
+ SetupEventHandlers();
+ InitializeUI();
+ LoadSettings();
+ LoadData();
+ SelectDefaultCategory();
+ }
+
+ // 设置上下文菜单
+ private void SetupContextMenus()
+ {
+ // 分类右键菜单
+ categoryContextMenu = new ContextMenuStrip();
+ categoryContextMenu.Items.Add("添加新分类", null, (s, e) => AddCategory_Click(s, e));
+ categoryContextMenu.Items.Add("删除当前分类", null, (s, e) => DeleteCategory_Click(s, e));
+ categoryContextMenu.Items.Add("重命名分类", null, (s, e) => RenameCategory_Click(s, e));
+
+ // 右侧面板右键菜单
+ shortcutsPanelContextMenu = new ContextMenuStrip();
+ shortcutsPanelContextMenu.Items.Add("添加程序", null, (s, e) => AddButton_Click(s, e));
+ shortcutsPanelContextMenu.Items.Add("-"); // 分隔线
+ shortcutsPanelContextMenu.Items.Add("按名称排序", null, (s, e) => SortShortcuts("Name"));
+ shortcutsPanelContextMenu.Items.Add("按添加时间排序", null, (s, e) => SortShortcuts("DateAdded"));
+ shortcutsPanelContextMenu.Items.Add("按使用频率排序", null, (s, e) => SortShortcuts("UsageCount"));
+ shortcutsPanelContextMenu.Items.Add("-"); // 分隔线
+
+ // 添加图标大小调整菜单，增加更多选项
+ var sizeMenu = new ToolStripMenuItem("图标大小");
+ sizeMenu.DropDownItems.Add("超小图标 (24px)", null, (s, e) => { ResizeIcons(24); });
+ sizeMenu.DropDownItems.Add("小图标 (48px)", null, (s, e) => { ResizeIcons(48); });
+ sizeMenu.DropDownItems.Add("中图标 (64px)", null, (s, e) => { ResizeIcons(64); });
+ sizeMenu.DropDownItems.Add("大图标 (96px)", null, (s, e) => { ResizeIcons(96); });
+ sizeMenu.DropDownItems.Add("较大图标 (128px)", null, (s, e) => { ResizeIcons(128); });
+ sizeMenu.DropDownItems.Add("超大图标 (192px)", null, (s, e) => { ResizeIcons(192); });
+ sizeMenu.DropDownItems.Add("巨大图标 (256px)", null, (s, e) => { ResizeIcons(256); });
+ shortcutsPanelContextMenu.Items.Add(sizeMenu);
+
+ // 快捷方式项目右键菜单
+ shortcutItemContextMenu = new ContextMenuStrip();
+ shortcutItemContextMenu.Items.Add("启动", null, (s, e) =>
+ {
+ if (s is ToolStripMenuItem menuItem && menuItem.Tag is ShortcutItem item)
+ {
+ LaunchApplication(item.Path);
+ }
+ });
+ shortcutItemContextMenu.Items.Add("删除", null, (s, e) =>
+ {
+ if (s is ToolStripMenuItem menuItem && menuItem.Tag is ShortcutItem item)
+ {
+ DeleteShortcut(item);
+ }
+ });
+ shortcutItemContextMenu.Items.Add("重命名", null, (s, e) =>
+ {
+ if (s is ToolStripMenuItem menuItem && menuItem.Tag is ShortcutItem item)
+ {
+ RenameShortcut(item);
+ }
+ });
+ shortcutItemContextMenu.Items.Add("属性", null, (s, e) =>
+ {
+ if (s is ToolStripMenuItem menuItem && menuItem.Tag is ShortcutItem item)
+ {
+ ShowShortcutProperties(item);
+ }
+ });
+ }
+
+ // 调整图标大小
+ private void ResizeIcons(int newSize)
+ {
+ if (newSize >= MIN_ICON_SIZE && newSize <= MAX_ICON_SIZE)
+ {
+ iconSize = newSize;
+ settings.IconSize = iconSize;
+ SaveSettings();
+
+ if (!string.IsNullOrEmpty(currentCategory))
+ {
+ ShowCategoryItems(currentCategory);
+ }
+ }
+ }
+
+ // 处理鼠标滚轮事件
+ private void ShortcutsPanel_MouseWheel(object sender, MouseEventArgs e)
+ {
+ // 检查Ctrl键是否按下
+ if (ModifierKeys == Keys.Control)
+ {
+ // 向上滚动，放大图标
+ if (e.Delta > 0)
+ {
+ ResizeIcons(iconSize + ICON_SIZE_STEP);
+ }
+ // 向下滚动，缩小图标
+ else if (e.Delta < 0)
+ {
+ ResizeIcons(iconSize - ICON_SIZE_STEP);
+ }
+ }
+ }
+
+ // 重命名分类
+ private void RenameCategory_Click(object sender, EventArgs e)
+ {
+ if (string.IsNullOrEmpty(currentCategory))
+ {
+ MessageBox.Show("请先选择要重命名的分类", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
+ return;
+ }
+
+ using (var dialog = new Form())
+ {
+ dialog.Text = "重命名分类";
+ dialog.Size = new Size(350, 150);
+ dialog.StartPosition = FormStartPosition.CenterParent;
+ dialog.FormBorderStyle = FormBorderStyle.FixedDialog;
+ dialog.MaximizeBox = false;
+ dialog.MinimizeBox = false;
+
+ var label = new Label() { Text = "新名称:", Location = new Point(10, 20) };
+ var textBox = new TextBox() { Text = currentCategory, Location = new Point(120, 17), Width = 180 };
+ var button = new Button() { Text = "确定", DialogResult = DialogResult.OK, Location = new Point(110, 60) };
+
+ dialog.Controls.AddRange(new Control[] { label, textBox, button });
+ dialog.AcceptButton = button;
+
+ if (dialog.ShowDialog() == DialogResult.OK && !string.IsNullOrWhiteSpace(textBox.Text))
+ {
+ string newName = textBox.Text.Trim();
+ if (newName != currentCategory && !categories.ContainsKey(newName))
+ {
+ var items = categories[currentCategory];
+ categories.Remove(currentCategory);
+ categories[newName] = items;
+
+ string oldCategory = currentCategory;
+ currentCategory = newName;
+
+ SaveData();
+ RefreshCategoryList();
+ ShowCategoryItems(currentCategory);
+ }
+ else if (categories.ContainsKey(newName) && newName != currentCategory)
+ {
+ MessageBox.Show("该分类名称已存在", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
+ }
+ }
+ }
+ }
+
+ // 排序快捷方式
+ private void SortShortcuts(string sortMode)
+ {
+ if (string.IsNullOrEmpty(currentCategory) || !categories.ContainsKey(currentCategory))
+ return;
+
+ settings.SortMode = sortMode;
+ SaveSettings();
+
+ switch (sortMode)
+ {
+ case "Name":
+ categories[currentCategory] = categories[currentCategory].OrderBy(s => s.Name).ToList();
+ break;
+ case "DateAdded":
+ categories[currentCategory] = categories[currentCategory].OrderByDescending(s => s.DateAdded).ToList();
+ break;
+ case "UsageCount":
+ categories[currentCategory] = categories[currentCategory].OrderByDescending(s => s.UsageCount).ToList();
+ break;
+ }
+
+ SaveData();
+ ShowCategoryItems(currentCategory);
+ }
+
+ // 删除快捷方式
+ private void DeleteShortcut(ShortcutItem item)
+ {
+ if (string.IsNullOrEmpty(currentCategory) || !categories.ContainsKey(currentCategory))
+ return;
+
+ if (MessageBox.Show($"确定要删除 '{item.Name}' 吗？", "确认删除",
+ MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
+ {
+ categories[currentCategory].Remove(item);
+ SaveData();
+ ShowCategoryItems(currentCategory);
+ }
+ }
+
+ // 重命名快捷方式
+ private void RenameShortcut(ShortcutItem item)
+ {
+ using (var dialog = new Form())
+ {
+ dialog.Text = "重命名快捷方式";
+ dialog.Size = new Size(350, 150);
+ dialog.StartPosition = FormStartPosition.CenterParent;
+ dialog.FormBorderStyle = FormBorderStyle.FixedDialog;
+ dialog.MaximizeBox = false;
+ dialog.MinimizeBox = false;
+
+ var label = new Label() { Text = "新名称:", Location = new Point(10, 20) };
+ var textBox = new TextBox() { Text = item.Name, Location = new Point(120, 17), Width = 180 };
+ var button = new Button() { Text = "确定", DialogResult = DialogResult.OK, Location = new Point(110, 60) };
+
+ dialog.Controls.AddRange(new Control[] { label, textBox, button });
+ dialog.AcceptButton = button;
+
+ if (dialog.ShowDialog() == DialogResult.OK && !string.IsNullOrWhiteSpace(textBox.Text))
+ {
+ item.Name = textBox.Text.Trim();
+ SaveData();
+ ShowCategoryItems(currentCategory);
+ }
+ }
+ }
+
+ // 显示快捷方式属性
+ private void ShowShortcutProperties(ShortcutItem item)
+ {
+ using (var dialog = new Form())
+ {
+ dialog.Text = "快捷方式属性";
+ dialog.Size = new Size(400, 300);
+ dialog.StartPosition = FormStartPosition.CenterParent;
+ dialog.FormBorderStyle = FormBorderStyle.FixedDialog;
+ dialog.MaximizeBox = false;
+ dialog.MinimizeBox = false;
+
+ // 使用当前图标大小显示图标
+ var icon = new PictureBox
+ {
+ Size = new Size(Math.Min(64, iconSize), Math.Min(64, iconSize)), // 限制属性对话框中的图标大小
+ Location = new Point(20, 20),
+ Image = item.Icon ?? SystemIcons.Application.ToBitmap(),
+ SizeMode = PictureBoxSizeMode.StretchImage
+ };
+
+ var nameLabel = new Label() { Text = "名称:", Location = new Point(20, 80), AutoSize = true };
+ var nameValue = new Label() { Text = item.Name, Location = new Point(120, 80), AutoSize = true };
+
+ var pathLabel = new Label() { Text = "路径:", Location = new Point(20, 110), AutoSize = true };
+ var pathValue = new Label() { Text = item.Path, Location = new Point(120, 110), Width = 250, AutoEllipsis = true };
+
+ var dateLabel = new Label() { Text = "添加日期:", Location = new Point(20, 140), AutoSize = true };
+ var dateValue = new Label() { Text = item.DateAdded.ToString(), Location = new Point(120, 140), AutoSize = true };
+
+ var usageLabel = new Label() { Text = "使用次数:", Location = new Point(20, 170), AutoSize = true };
+ var usageValue = new Label() { Text = item.UsageCount.ToString(), Location = new Point(120, 170), AutoSize = true };
+
+ var button = new Button() { Text = "确定", DialogResult = DialogResult.OK, Location = new Point(150, 220) };
+
+ dialog.Controls.AddRange(new Control[] { icon, nameLabel, nameValue, pathLabel, pathValue,
+ dateLabel, dateValue, usageLabel, usageValue, button });
+ dialog.AcceptButton = button;
+
+ dialog.ShowDialog();
+ }
+ }
+
+ // 选择默认分类
+ private void SelectDefaultCategory()
+ {
+ // 如果没有分类，不做任何操作
+ if (categories.Count == 0)
+ return;
+
+ // 尝试选择上次选择的分类
+ if (!string.IsNullOrEmpty(settings.LastSelectedCategory) &&
+ categories.ContainsKey(settings.LastSelectedCategory))
+ {
+ currentCategory = settings.LastSelectedCategory;
+ ShowCategoryItems(currentCategory);
+ return;
+ }
+
+ // 如果没有上次选择的分类或该分类不存在，选择第一个分类
+ currentCategory = categories.Keys.First();
+ ShowCategoryItems(currentCategory);
+ }
+
+ // 保存设置
+ private void SaveSettings()
+ {
+ try
+ {
+ settings.LastSelectedCategory = currentCategory;
+ settings.IconSize = iconSize;
+ var options = new JsonSerializerOptions
+ {
+ WriteIndented = true
+ };
+ var data = JsonSerializer.Serialize(settings, options);
+ File.WriteAllText(settingsFilePath, data);
+ }
+ catch (Exception ex)
+ {
+ MessageBox.Show($"保存设置失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
+ }
+ }
+
+ // 加载设置
+ private void LoadSettings()
+ {
+ if (File.Exists(settingsFilePath))
+ {
+ try
+ {
+ var json = File.ReadAllText(settingsFilePath);
+ settings = JsonSerializer.Deserialize(json) ?? new AppSettings();
+ iconSize = settings.IconSize; // 加载保存的图标大小
+ }
+ catch
+ {
+ settings = new AppSettings();
+ }
+ }
+ }
+
+ private void SetupEventHandlers()
+ {
+ // 清除所有事件处理器 - 移除不存在的引用
+ addButton.Click -= AddButton_Click;
+ this.FormClosing -= MainForm_FormClosing;
+ shortcutsPanel.MouseWheel -= ShortcutsPanel_MouseWheel;
+
+ // 只为shortcutsPanel添加拖放支持
+ shortcutsPanel.AllowDrop = true;
+ shortcutsPanel.DragEnter += ShortcutsPanel_DragEnter;
+ shortcutsPanel.DragDrop += ShortcutsPanel_DragDrop;
+
+ // 添加鼠标滚轮事件处理
+ shortcutsPanel.MouseWheel += ShortcutsPanel_MouseWheel;
+
+ // 为shortcutsPanel添加鼠标移动事件，用于处理空白区域的工具提示
+ shortcutsPanel.MouseMove += ShortcutsPanel_MouseMove;
+
+ // 为shortcutsPanel添加右键菜单
+ shortcutsPanel.ContextMenuStrip = shortcutsPanelContextMenu;
+
+ // 绑定添加程序按钮事件
+ addButton.Click += AddButton_Click;
+
+ // 绑定窗体关闭事件，保存当前选择的分类
+ this.FormClosing += MainForm_FormClosing;
+ }
+
+ // 添加缺失的事件处理方法
+ private void ShortcutsPanel_DragEnter(object sender, DragEventArgs e)
+ {
+ Console.WriteLine("DragEnter triggered");
+ if (e.Data.GetDataPresent(DataFormats.FileDrop) && !string.IsNullOrEmpty(currentCategory))
+ {
+ e.Effect = DragDropEffects.Copy;
+ }
+ else
+ {
+ e.Effect = DragDropEffects.None;
+ }
+ }
+
+ private void ShortcutsPanel_DragDrop(object sender, DragEventArgs e)
+ {
+ Console.WriteLine("DragDrop triggered");
+ if (string.IsNullOrEmpty(currentCategory))
+ {
+ MessageBox.Show("请先选择一个分类", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
+ return;
+ }
+
+ if (e.Data.GetDataPresent(DataFormats.FileDrop))
+ {
+ string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
+ bool addedAny = false;
+ foreach (string file in files)
+ {
+ if (File.Exists(file))
+ {
+ AddNewShortcut(file, currentCategory);
+ addedAny = true;
+ }
+ }
+
+ if (!addedAny)
+ {
+ MessageBox.Show("没有找到有效的文件", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
+ }
+ }
+ }
+
+ private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
+ {
+ SaveSettings();
+ }
+
+ private void InitializeUI()
+ {
+ categories = new Dictionary>();
+ RefreshCategoryList();
+ }
+
+ private void AddCategory_Click(object sender, EventArgs e)
+ {
+ using (var dialog = new Form())
+ {
+ dialog.Text = "添加新分类";
+ dialog.Size = new Size(350, 150);
+ dialog.StartPosition = FormStartPosition.CenterParent;
+ dialog.FormBorderStyle = FormBorderStyle.FixedDialog;
+ dialog.MaximizeBox = false;
+ dialog.MinimizeBox = false;
+
+ var label = new Label() { Text = "分类名称:", Location = new Point(10, 20) };
+ var textBox = new TextBox() { Location = new Point(120, 17), Width = 180 };
+ var button = new Button() { Text = "确定", DialogResult = DialogResult.OK, Location = new Point(110, 60) };
+
+ dialog.Controls.AddRange(new Control[] { label, textBox, button });
+ dialog.AcceptButton = button;
+
+ if (dialog.ShowDialog() == DialogResult.OK && !string.IsNullOrWhiteSpace(textBox.Text))
+ {
+ string newCategory = textBox.Text.Trim();
+ if (!categories.ContainsKey(newCategory))
+ {
+ categories[newCategory] = new List();
+ SaveData();
+ RefreshCategoryList();
+
+ // 自动选择新创建的分类
+ currentCategory = newCategory;
+ ShowCategoryItems(currentCategory);
+ }
+ }
+ }
+ }
+
+ private void DeleteCategory_Click(object sender, EventArgs e)
+ {
+ if (string.IsNullOrEmpty(currentCategory))
+ {
+ MessageBox.Show("请先选择要删除的分类", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
+ return;
+ }
+
+ if (MessageBox.Show($"确定要删除分类 '{currentCategory}' 吗？", "确认删除",
+ MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
+ {
+ categories.Remove(currentCategory);
+ SaveData();
+ RefreshCategoryList();
+ shortcutsPanel.Controls.Clear();
+ currentCategory = "";
+
+ // 删除分类后，选择新的默认分类
+ if (categories.Count > 0)
+ {
+ currentCategory = categories.Keys.First();
+ ShowCategoryItems(currentCategory);
+ }
+ else
+ {
+ // 如果没有分类了，清空右侧面板和标签
+ shortcutsPanel.Controls.Clear();
+ categoryLabel.Text = "当前分类: 无";
+ }
+ }
+ }
+
+ private void RefreshCategoryList()
+ {
+ leftPanel.Controls.Clear();
+ int buttonY = 10;
+
+ foreach (var category in categories.Keys)
+ {
+ var categoryPanel = new Panel
+ {
+ Width = leftPanel.Width - 5,
+ Height = CATEGORY_BUTTON_HEIGHT,
+ Location = new Point(0, buttonY)
+ };
+
+ var btn = new Button
+ {
+ Text = category,
+ Width = leftPanel.Width - 20,
+ Height = CATEGORY_BUTTON_HEIGHT,
+ Location = new Point(10, 0),
+ FlatStyle = FlatStyle.Flat,
+ BackColor = Color.FromArgb(200, 255, 200),
+ Tag = category
+ };
+
+ // 移除旧的事件处理器
+ btn.Click -= null;
+ btn.Click += (s, e) =>
+ {
+ currentCategory = category;
+ ShowCategoryItems(category);
+ };
+
+ // 添加右键菜单
+ btn.ContextMenuStrip = categoryContextMenu;
+
+ categoryPanel.Controls.Add(btn);
+ categoryPanel.AllowDrop = true;
+
+ // 移除旧的事件处理器
+ categoryPanel.DragEnter -= null;
+ categoryPanel.DragDrop -= null;
+
+ categoryPanel.DragEnter += (s, e) =>
+ {
+ if (e.Data.GetDataPresent(DataFormats.FileDrop))
+ {
+ e.Effect = DragDropEffects.Copy;
+ }
+ };
+ categoryPanel.DragDrop += (s, e) =>
+ {
+ string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
+ foreach (string file in files)
+ {
+ if (File.Exists(file))
+ {
+ AddNewShortcut(file, category);
+ }
+ }
+ };
+
+ leftPanel.Controls.Add(categoryPanel);
+ buttonY += CATEGORY_BUTTON_HEIGHT + 5;
+ }
+ }
+
+ private void ShowCategoryItems(string category)
+ {
+ shortcutsPanel.Controls.Clear();
+ if (categories.ContainsKey(category))
+ {
+ // 更新顶部分类标签
+ categoryLabel.Text = $"当前分类: {category}";
+
+ // 根据设置的排序模式排序
+ List sortedItems = categories[category];
+ switch (settings.SortMode)
+ {
+ case "Name":
+ sortedItems = sortedItems.OrderBy(s => s.Name).ToList();
+ break;
+ case "DateAdded":
+ sortedItems = sortedItems.OrderByDescending(s => s.DateAdded).ToList();
+ break;
+ case "UsageCount":
+ sortedItems = sortedItems.OrderByDescending(s => s.UsageCount).ToList();
+ break;
+ }
+
+ foreach (var item in sortedItems)
+ {
+ AddShortcutControl(item, category);
+ }
+ }
+ }
+
+ private void AddShortcutControl(ShortcutItem item, string category)
+ {
+ // 根据当前图标大小调整面板大小
+ int panelWidth = Math.Max(80, iconSize + 10);
+ int panelHeight = iconSize + 60;
+
+ var panel = new Panel
+ {
+ Width = panelWidth,
+ Height = panelHeight,
+ Margin = new Padding(5),
+ Tag = item,
+ BackColor = Color.Transparent // 初始背景色为透明
+ };
+
+ var icon = new PictureBox
+ {
+ Size = new Size(iconSize, iconSize),
+ Location = new Point((panel.Width - iconSize) / 2, 5),
+ Image = item.Icon ?? SystemIcons.Application.ToBitmap(),
+ SizeMode = PictureBoxSizeMode.StretchImage,
+ Tag = item,
+ Cursor = Cursors.Hand // 鼠标悬停时显示手型光标
+ };
+
+ var label = new Label
+ {
+ Text = item.Name,
+ AutoSize = false,
+ TextAlign = ContentAlignment.MiddleCenter,
+ Width = panel.Width,
+ Height = 30,
+ Location = new Point(0, iconSize + 10),
+ Tag = item,
+ Cursor = Cursors.Hand // 鼠标悬停时显示手型光标
+ };
+
+ panel.Controls.Add(icon);
+ panel.Controls.Add(label);
+
+ // 设置右键菜单
+ panel.ContextMenuStrip = shortcutItemContextMenu;
+ icon.ContextMenuStrip = shortcutItemContextMenu;
+ label.ContextMenuStrip = shortcutItemContextMenu;
+
+ // 为右键菜单项设置Tag
+ foreach (ToolStripItem menuItem in shortcutItemContextMenu.Items)
+ {
+ if (menuItem is ToolStripMenuItem)
+ {
+ menuItem.Tag = item;
+ }
+ }
+
+ // 移除旧的事件处理器并重新绑定
+ panel.DoubleClick -= null;
+ icon.DoubleClick -= null;
+ label.DoubleClick -= null;
+
+ // 双击事件 - 启动应用程序
+ panel.DoubleClick += (s, e) => LaunchApplication(item.Path);
+ icon.DoubleClick += (s, e) => LaunchApplication(item.Path);
+ label.DoubleClick += (s, e) => LaunchApplication(item.Path);
+
+ // 添加鼠标悬停效果
+ panel.MouseEnter += Panel_MouseEnter;
+ panel.MouseLeave += Panel_MouseLeave;
+ icon.MouseEnter += Panel_MouseEnter;
+ icon.MouseLeave += Panel_MouseLeave;
+ label.MouseEnter += Panel_MouseEnter;
+ label.MouseLeave += Panel_MouseLeave;
+
+ // 移除鼠标移动事件，避免频繁触发
+ // panel.MouseMove += (s, e) => Panel_MouseEnter(s, e);
+ // icon.MouseMove += (s, e) => Panel_MouseEnter(s, e);
+ // label.MouseMove += (s, e) => Panel_MouseEnter(s, e);
+
+ // 添加鼠标点击效果
+ panel.MouseDown += Panel_MouseDown;
+ panel.MouseUp += Panel_MouseUp;
+ icon.MouseDown += Panel_MouseDown;
+ icon.MouseUp += Panel_MouseUp;
+ label.MouseDown += Panel_MouseDown;
+ label.MouseUp += Panel_MouseUp;
+
+ // 直接设置工具提示
+ string tipText = $"名称: {item.Name}\n路径: {item.Path}\n双击启动";
+ toolTip1.SetToolTip(panel, tipText);
+ toolTip1.SetToolTip(icon, tipText);
+ toolTip1.SetToolTip(label, tipText);
+
+ shortcutsPanel.Controls.Add(panel);
+ }
+
+ // 鼠标进入面板时的效果
+ private void Panel_MouseEnter(object sender, EventArgs e)
+ {
+ if (sender is Control control)
+ {
+ // 获取父面板
+ Panel panel = control as Panel;
+ if (panel == null && control.Parent is Panel)
+ {
+ panel = control.Parent as Panel;
+ }
+
+ if (panel != null)
+ {
+ // 高亮显示
+ panel.BackColor = Color.FromArgb(230, 230, 255); // 浅蓝色背景
+ panel.BorderStyle = BorderStyle.FixedSingle; // 显示边框
+
+ // 显示工具提示
+ if (panel.Tag is ShortcutItem item)
+ {
+ string tipText = $"名称: {item.Name}\n路径: {item.Path}\n双击启动";
+
+ // 为当前控件设置工具提示
+ if (control is PictureBox || control is Label)
+ {
+ toolTip1.SetToolTip(control, tipText);
+ }
+ else
+ {
+ toolTip1.SetToolTip(panel, tipText);
+ }
+ }
+ }
+ }
+ }
+
+ // 鼠标离开面板时的效果
+ private void Panel_MouseLeave(object sender, EventArgs e)
+ {
+ if (sender is Control control)
+ {
+ // 获取父面板
+ Panel panel = control as Panel;
+ if (panel == null && control.Parent is Panel)
+ {
+ panel = control.Parent as Panel;
+ }
+
+ if (panel != null)
+ {
+ // 恢复正常显示
+ panel.BackColor = Color.Transparent;
+ panel.BorderStyle = BorderStyle.None;
+ }
+ }
+ }
+
+ // 鼠标按下时的效果
+ private void Panel_MouseDown(object sender, MouseEventArgs e)
+ {
+ if (e.Button == MouseButtons.Left) // 只对左键点击响应
+ {
+ if (sender is Control control)
+ {
+ // 获取父面板
+ Panel panel = control as Panel;
+ if (panel == null && control.Parent is Panel)
+ {
+ panel = control.Parent as Panel;
+ }
+
+ if (panel != null)
+ {
+ // 点击效果 - 深色背景
+ panel.BackColor = Color.FromArgb(180, 180, 240); // 更深的蓝色
+ }
+ }
+ }
+ }
+
+ // 鼠标释放时的效果
+ private void Panel_MouseUp(object sender, MouseEventArgs e)
+ {
+ if (e.Button == MouseButtons.Left) // 只对左键点击响应
+ {
+ if (sender is Control control)
+ {
+ // 获取父面板
+ Panel panel = control as Panel;
+ if (panel == null && control.Parent is Panel)
+ {
+ panel = control.Parent as Panel;
+ }
+
+ if (panel != null)
+ {
+ // 恢复悬停效果
+ panel.BackColor = Color.FromArgb(230, 230, 255);
+ }
+ }
+ }
+ }
+
+ // 添加面板鼠标移动事件处理
+ private void ShortcutsPanel_MouseMove(object sender, MouseEventArgs e)
+ {
+ // 获取鼠标位置下的控件
+ Control control = shortcutsPanel.GetChildAtPoint(e.Location);
+
+ // 如果鼠标不在任何子控件上，则隐藏工具提示
+ if (control == null)
+ {
+ toolTip1.RemoveAll();
+ }
+ }
+
+ // 添加工具提示组件
+ private ToolTip toolTip1 = new ToolTip();
+
+ private void AddButton_Click(object sender, EventArgs e)
+ {
+ if (string.IsNullOrEmpty(currentCategory))
+ {
+ MessageBox.Show("请先选择一个分类", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
+ return;
+ }
+
+ using (OpenFileDialog dialog = new OpenFileDialog())
+ {
+ dialog.Filter = "应用程序|*.exe|所有文件|*.*";
+ if (dialog.ShowDialog() == DialogResult.OK)
+ {
+ AddNewShortcut(dialog.FileName, currentCategory);
+ }
+ }
+ }
+
+ private void AddNewShortcut(string filePath, string category)
+ {
+ // 放宽文件类型限制，允许任何文件类型
+ var item = new ShortcutItem
+ {
+ Name = Path.GetFileNameWithoutExtension(filePath),
+ Path = filePath,
+ DateAdded = DateTime.Now,
+ UsageCount = 0
+ };
+ item.LoadIcon();
+
+ categories[category].Add(item);
+ SaveData();
+ if (category == currentCategory)
+ {
+ ShowCategoryItems(category);
+ }
+ }
+
+ private void LaunchApplication(string path)
+ {
+ try
+ {
+ // 查找并更新使用次数
+ if (!string.IsNullOrEmpty(currentCategory) && categories.ContainsKey(currentCategory))
+ {
+ var item = categories[currentCategory].FirstOrDefault(i => i.Path == path);
+ if (item != null)
+ {
+ item.UsageCount++;
+ item.LastUsed = DateTime.Now;
+ SaveData();
+ }
+ }
+
+ var startInfo = new System.Diagnostics.ProcessStartInfo
+ {
+ FileName = path,
+ UseShellExecute = true
+ };
+ System.Diagnostics.Process.Start(startInfo);
+ }
+ catch (Exception ex)
+ {
+ MessageBox.Show($"启动程序失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
+ }
+ }
+
+ private void SaveData()
+ {
+ try
+ {
+ var options = new JsonSerializerOptions
+ {
+ WriteIndented = true
+ };
+ var data = JsonSerializer.Serialize(categories, options);
+ File.WriteAllText(dataFilePath, data);
+ }
+ catch (Exception ex)
+ {
+ MessageBox.Show($"保存配置失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
+ }
+ }
+
+ private void LoadData()
+ {
+ if (File.Exists(dataFilePath))
+ {
+ try
+ {
+ var json = File.ReadAllText(dataFilePath);
+ categories = JsonSerializer.Deserialize>>(json);
+
+ // 加载所有图标
+ foreach (var category in categories.Values)
+ {
+ foreach (var item in category)
+ {
+ item.LoadIcon();
+ }
+ }
+
+ RefreshCategoryList();
+ }
+ catch (Exception ex)
+ {
+ MessageBox.Show($"加载配置失败: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
+ categories = new Dictionary>();
+ }
+ }
+ else
+ {
+ // 如果没有数据文件，创建一个默认分类
+ categories = new Dictionary>();
+ categories["默认分类"] = new List();
+ SaveData();
+ RefreshCategoryList();
+ }
+ }
+ }
+
+ public class ShortcutItem
+ {
+ public string Name { get; set; }
+ public string Path { get; set; }
+ [System.Text.Json.Serialization.JsonIgnore]
+ public Bitmap Icon { get; set; }
+ public DateTime DateAdded { get; set; } = DateTime.Now;
+ public DateTime LastUsed { get; set; } = DateTime.MinValue;
+ public int UsageCount { get; set; } = 0;
+
+ // 用于序列化的构造函数
+ public ShortcutItem()
+ {
+ }
+
+ // 加载图标的方法
+ public void LoadIcon()
+ {
+ try
+ {
+ if (File.Exists(Path))
+ {
+ using (System.Drawing.Icon icon = System.Drawing.Icon.ExtractAssociatedIcon(Path))
+ {
+ if (icon != null)
+ {
+ Icon = icon.ToBitmap();
+ }
+ else
+ {
+ Icon = SystemIcons.Application.ToBitmap();
+ }
+ }
+ }
+ else
+ {
+ Icon = SystemIcons.Application.ToBitmap();
+ }
+ }
+ catch
+ {
+ Icon = SystemIcons.Application.ToBitmap();
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/MainForm.resx b/MainForm.resx
new file mode 100644
index 0000000..3fa4062
--- /dev/null
+++ b/MainForm.resx
@@ -0,0 +1,1508 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 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
+
+
+ 17, 17
+
+
+
+
+ AAABAAEAAAAAAAAAIAA7QwEAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAAARn
+ QU1BAACxjwv8YQUAAAABc1JHQgCuzhzpAAAAIGNIUk0AAHomAACAhAAA+gAAAIDoAAB1MAAA6mAAADqY
+ AAAXcJy6UTwAACAASURBVHic7J13nBbV9f/f987M08v2Aiy9FwsgKHYRxYIKGgu2GGNBQ7BGjcZuEmOJ
+ JUbFgsYWwIrEBtJBeu+9991l21Om3Pv744F8ja6I/IA1ZN+v1/6xr5m59/NMOXPn3HPOhXrqqaeeeuqp
+ p5566qmnnnrqqaeeeuqpp5566qmnnnrqqaeeeuqpp5566qmnnnrqqaeeeuqpp5566qnnvwmjrgXUU/cM
+ GzbMaN++vTF+/HhV11rqObTUG4B60Ib/zOHDh56TqKmZWtda6jm0yLoWUE/dM3vWrE6RcPSYutZRz6Gn
+ 3gDUg/LcIxxXtalrHfUceuoNQD04TrrNrsqqtlOmTAnWtZZ6Di31BuB/nGHDhvkqK6rbuXYy9OWXEzvU
+ tZ56Di31BuB/nKVLl7az7XQELfn400+Prms99Rxa6g3A/zhfjBrVUQiBLxCicteOE+taTz2HlnoDcJCZ
+ 9uQfW9e1hr2xaePmTtLwYQhBKpU4oq71/Bhz//FEuK41HE7UG4CDzMavPzt+dLPisWsfub1ZXWupDZ8p
+ O/gsH6CpTiRaDxkyNlDXmmpj0q8vP3HYkW0/2z5y9GV1raWeen4Ss8867ayvWjRdOff8My6say3fJT+/
+ aFU8t1jHc4q0LxDWj/3lmZ/VKEBrLb46rutTIwsLJiy8++6Wda2nnp8h9957b5O61vBjrHvg7uZjGhWv
+ nXX22SfVtZY9DB06ND8cirqxnCIdyynS/mBc9+hx8hV1rWsPM2fOtMa1bzNyQrt2r9S1lh/jmWeeaXzp
+ pZf2rmsd/5N0Pab7488//3xuXev4MeZdcvmJX8bjmxf/TLQOGnT7SYFgWMezMwYgHM/XTZu3eaGude1h
+ 3tGdnp1TUjJLz5xp1bWWH6Nlq5YfXXvttfUjlLrghBNOvrR58+ZP1LWOfeHzNm2mfd623ZN1rQOgyzHH
+ 3hgIRnTWbgMQyynSTZq2mFHXugCWX3FRrwUCPbXf2VfWtZYf4+KLL74wv7BwSl3r2B8OCyfg+eef+2lZ
+ WeW1Awfe26KutfwYBnqub83aG2a/9lp+XWsp3Vl+hLQCKAFaZxIBt20r7TT0iy9y6lgaYsacQT7Twtfy
+ yK11rWVvfPzxx9EvR339VCCcPaKutewPh4UBuPPOO2tiWVlzR4wY+mxda/kxAoboFCYdKX3jtTPqWotS
+ difLyoyutQalPLR2/Z+///FRdSyNaNruEgz4qZg85fi61rI3Hnjgod+nkk6TVi1bjKlrLfvDYWEAAHy+
+ 2Lh169ef0/vcc/vUtZYfYvYt15yetXXTcVGfSX5NeZ36AV5+eaZVUVHVVmqQGoRSGEg0BlMmTapzA+Ca
+ 8cUhyyJnzfIb1/8MRiS1cd9997VbuWb1bdGseGnLpg3n1LWe/eGwMQAnn3ra135/iGlTvvnrl19++bML
+ FqkY9WGuGPXZq1lhE22Fdob6nP5hXeopL5/QOplM5qEFlmUSjcZQSmFaPhw7VecGYEfHzvds9zy7Uaqm
+ sHTgLX+vaz218eZbbz3n8wd9ylPfDB482KlrPf/TDB06NBjLKq4OR/P0kUd2friu9XyX2Sd3HL2peUzP
+ bVm4Ze6vLu5Y13p6nnHWJYFATMdzG+rikqa656k9dSiaqyPxYt2wpPn0utYHMPmiay5aGo3Ym2NBPaXL
+ 0T+b2QmAk07r3ScQiuusvAJdXFxyS13rqQdo3LTZxJy8RjoczkldddW1P5uAlmmXnHHXltZZelHb/O3z
+ Hr/vZ5F337xl+0dDoXwdz22km7VooW8ZNFD7Q9k6Ei/SkVhR9ZAhQ34WEYGTz+x78/yApZcHfXpcj1N+
+ FjM9r7zySk48K29Ddl4DHcnK0506d+5c15rqAZq27vhAOJqr4znFuri44fRhw4bVecmziffddeSMBnE7
+ 2S5Hb/hV37vqWs8emrdoNSKaXaxjOQ300V2O0E8/9aT2+aM6Ei/Ulj+sf//7R38WN7XWWo5u2mLZynhc
+ zwlY+rPTel1b15patm77XCSep7PzGuic3Abb+S8urXfY+AAATjnphInK85CGQWVV6pjHH39yQF1rqh7x
+ 2b2NDNMiaBFM1Pxs8gGqqxPthRBorSkqLiAnJxfITAUKJKNHj/5ZpAYLIVQyGpvrCU1WJEZo5vSnJ9/7
+ SJ1Ffp7Xr99Jazdsutm0fABorb8BvLrS8//LYWUATj3xjHmmz29LIfEHgyxfufLR3/72rsZ1pWf58uWx
+ 1u2KTxXaRjsS36qFV2+868Y6f7Aef/75BhVVGWPk2mlKigtp1qgYjQbAsPzsKN3ys0kNNrxEsWFJHKlp
+ Znixsg/ee6oudAwZMiQwZdK0l6PhuNRCABpPuF/VhZYDxWFlAK6+ul9pPBpZCQIAafji73/w3qsHq7/J
+ f3+i4NOnHm1Y27Y1a9YE/Kr65dxBt+WJxrkox8ZKeQH/hE8+X/PwoHYHS9O+MObzUUejldRKoTyP9u3b
+ 0ahRLsrTgMYwDFzX/ll8Akz5zWXdCrau64EhMExBOmCSu2ldnzkvDml6qLU889xzv0+l7LZCCAQC27Zp
+ 1rzp5EOt40ByWBkAAF/Av8DzXIQQmKaPXbuqeh1/fK8bDkZflf986d3KZ56avXz5cv93t3m7tt6PUJcm
+ ixoTfeJ50mbmpomn3MLIiGHj11zau85GAkuWLjtaSAsNKKFo1bIJDYotwiEJQqNR7NxZ2fqjj8Zm1ZVG
+ gBm/v67Y/Hz00IJg0DAtEwC/NsmRyrdh8DN9D6WWO2+5s+vy5avuNvz+TOQkYFhWeeumTRcfSh0HmsPO
+ AOTm54y3bfvf/weDEebNn/WnBx74c6MD3Ve47RFPFnduf3/r1q3T390mq3aeaWmBlDbJZh0wrrsZZdeg
+ TZNYVOeH18yYvOKWyy/+qX1qrcVX157ZT2st9lu48jqYpoVAg+PSorFFIJSmSUEhe0ZPnpf2f/31Z532
+ t4sNz/6u0epB5523P8fqYcOM+Ree9KvgZ5/Mb+TzmhpBH4YpsSwLaQgCfhMqd7baX20/lTVr1gSGfzTs
+ TcMKWlprtNaZF4y0vhk+fLj94y38fDnsDEDvnr1mKs/JvMm0h6ddtDSy33hj8AEPJjlp8EdfnPbJ5Jdr
+ 22YtmhA3y3egtYX2XAK9z6Qy6CcdN/B8NtnZVjB3yqh3l17X7yclu3x27nE3d148/oOZ/U64fn91O7bd
+ QUoBCEIhQUnjINqtoVXTXDw34wQUWjJx8pgj96d9rbUwJw4fmbtizCcbBz/6k4KKll574RGrn797XtHS
+ +a8VKi/PZ2osU+MT4MfDLx1M5ZEMxSr2R9v+cMUVV9yybUdleyn/z9kvtQZPDTlUGg4Wh50B6Nix7cJA
+ OFylVcZSA5imwdbt2/uccMLp1x0qHX6nZn1g6Vh8FesxvRRC2iQCJs6tV1CVH0ZKiOUZRu6isa+tufXX
+ x+5ru7IynUXIjyGkuz+6hg4dGqxKpFohBEIa5OeGCAVAeynatG6A62aatXx+qqoqu+1PH7MGDzZNbYa1
+ lb0xEi9cv6/HzR7Y//zgrNFT87zyDmbIwOcXpEMKozBAMCDxBUD5TDZ6Dlk9e47cH20/ldtuu63tnHlz
+ 77P8fnb7SNFao5RKlJWlvjwUGg4mh50BuOSSS5LRcGDRnv8lAqkFoWCUuXNnPDlw4B2HJGPQl5v9lUht
+ xdq6GGvZ16S/fAWDBDpk4b9uECm3Bm165OZKK3vxlL9rrffpWpw1cc6j2y55oOPRH0x4fX90zV28slU6
+ mQpoQCFoURAC0gg3Tcc2xaDTIBTSktjp9H5FLHa94QbHuPGxrsZV93TJuuS6sn05ZvrDd7YJjv783dyo
+ GZSGJGiZpENJst96gdKW2ZgChBSknRpS7Vu9dOYzfzvozrfly5f7hw8f/i4yHNaeQisXPA0atGAylFYd
+ bA0Hm8POAAAYUq7yvMzUrFYKpTKmWxq+2PD3h76ltTYPtgY3nL/MSlYT2jwbc8xHyEkTkcIDmSDUpTPJ
+ iIU0DXTAIpDefHTFfb89fV/b7nD9bYuEEHp/dI0dO/ooIQ0E4DouDQuCkFK4WlHSNA+EQIjM50F5RWW7
+ YcOGRfann5xeF1dEL7xp+77u7xv/2e1Ns1XI8mt8PhBmJeYNJ40j98gXjAWrMWIWMuDBUSXTmz/xwG37
+ o+mnctNNN96xfXvZ0UiBrZIUB4IoXDIzgHr0odBwsDksDYDwBzambRdPCXJ9gpKIgesppDSorKw5rkeP
+ k+4+2BrMhsWb7MVrqfnXbNKLVmNUpQgeZZB1VB4y7OE0iEK2h/QLfLkCb+Ocy2trZ+zYsabW+oBFmpXu
+ 3HGiYVmARmuXRoV+vPQuDDTFBQZ4mdRggca17cDyNRvb7q292594Itz35ls6Xz5wYGx/NWmtjbBInu0v
+ DGBlGYiojTwluj37rG7XBP3rHo02DKatuMQ6oeXOkr+9cVbjHpck97evfeXmm2/uOmXKjAd8wRACTeNw
+ kGYxA0QmZ1IpMfFgazgUHJYGoFWrFqu0lwY0GysqGdCrK56TuWf8/iBz5sx7sF+/iw9anvmyF/7aznvq
+ xX/K5RVYO1KIBKSjKeKPHo0bDgCbkKe6cGYWXigBhkSrdEltbaXT/liffv33Oo15bM++vfNLmkwvatxs
+ Yq8+l562t33tZM1Rlm93hS3Po1F+FjpVhdKa7IhDwPCxx9klhGDShHE/WObqiONP7/f3v/x93ScvvzLr
+ gzf/ueLo7qf9YP7FqFGj4i3bdji3tm0bNmzwxXQqSqHGzXLQF7V837rjig4i+6G1InLu1uBlPaZ5MgWu
+ mV39wgvPlV/X+7GNvz7x2Q2vP35QZgI2bdoU+vjjj980raClNNjpNNcd25x5W0qRArQmUVW+efbB6PtQ
+ c1gagO7deyxWXiasVfrDTFq6gt/2PALHsdHKIxAMGuPGj3tz7Nix+zW8/TGkP5gllq5tptMelWkfZp4g
+ 3FlAMAtD5qNUkuy+/dHdC9D5DtoShIKRXbW1deaZx1UsWbjwrpEjJ2bXtn3QnQ+3WTXt6w8/yc065lxp
+ nDBp/ISPXn7nnbza9n3rrbdiO8sqOqFcMu94TV5xCO0lQAaISoewP3NLaDRIi9Ur1tT6UN9++xPhlYsW
+ vXK2lcod37EBhY4u2LF1ww/OtFx3/Y1/zituFaptW0lJSYpYeKtoHSJ9VLDS6vvAIBF7eieA1g/I0Jld
+ jcqcGNbGHYY1cfLl0WUrfp+1bcf1keLWByUFt++FF95fVl7ZXmuF0tC1aYzCLJMqHcx4/zWzge9N/f43
+ clgagJPOPG2h6Q/YWimENPlqznpuOrMtWaaNFgLlKeyU3eKGGwY8eDD697c/Ym5VLLrNc02qUhp1Xid0
+ UxNhHQN0xhTnAlfgFV+OahDAC3p4LVoPr60tIYSnlLfl/vsH/aa27R9+OvKsTn5fsOv2HVyCxFNmbNni
+ DbUuRvL1+MldPcf2CyHZkweQF/ehlULKEJalCQV8e5zdWD4fStu1BixNXTihadoROUdGApwgd3BdQYhE
+ 0mtRW3zChRde2GPt2nU3nNTztLU/8Bs1ufGxTkU1vl49vpLhCzb/37aHlL1uUrl77dnsCIIwDDQCN6vB
+ p9ln9a21vf8fLrvyyuPmzZ17h2UF0BrsRII/3XIqQycsQfpNBAJDcFi8/eEwNQC9unataFCYuxwhMFEk
+ zACz5yzi5euOJ11TgxYC0/KxZs3aW0487Yz9muraG4179Eg6jVoMS6skYZmk3GkI7Y9BGv0Rug1KF2Po
+ TpBogLTAjpXM39L39h8sEOKzrPTyFWtuf+qpF78Xdnxcl85Tt9agpguLD5MQD5kb+hzZfX5t7UyZMqWb
+ ELtLgKFAaGJhAy1MtLARQU1WyIcQAiEMhJDsqqg+auzYsd9zml712APLcyPG0qc22Ny1Mcjr202yY7lj
+ v+ucHLZwoW/ilCmDLSssCgKxH06aOf2yF6vW264VjC/87qZUsPsngUgxvrXbMTFIuCrtdev1yA+2tZ+s
+ X78+OGbUqDdNf9RQCDwEZx9XRCtdzYzNLlLYu88N3xzovuuKw9IAABhGaIrrekghsXxB3h+zknM653Lj
+ iU1w3DRSQSgYM+ZMm/b8wUgbzr/m5ofKDd83sahFcNIsVPx60M2QnkAqiSCBvfMjvJrCUq/jeRfVFk24
+ B2lqTyHjL778zHPf3TbsnZem5nfsevUAGV08JmiNPqPXcb1OvfjU6traUXayu+X/VtSyBimTmCKOlDaY
+ mty4ibk7fkIgqKqoLJo6dfb3chdu6NrVOev48/vmFTSa9Wq6KOkVxEbeNOD6741Snrj+2t9UVyU6CDSR
+ nPgPRs0VXnr7PLv5yY8lJoy9Su165T9KgIWkg/faX8mJFJL2PC/R5djbcwfes+CH2tpf+va98L6KqppW
+ QmQi/QyR4Nnf9WbcB9NI+CykEGjA87zvGal6fmac3ecXF/uCmYo38bxGuoU/qrc83FvXvNFXd22QpaPR
+ XJ0dy9fRSI4uadjk9wdDgwax84SSW+2rm5baT3bV6dmPay+xTHvplTq1+Q86Marryqp/3vijc+0dOh05
+ LpyTr61AWPc845xaZwv2hUaNGi+N5xbrPX9WMKZnvNJdq7WvaK/6I6233abP69ZO52Q30PGczD7+YEz3
+ Oq33XhcL+aFp1WeffTY/lpW1Iyu3SAeDOfqxJ4fsdUYBYNu7Fw2seP+COYllT5+oUl+1cpb8+qHUa00d
+ 7+qGurJXx82b+vU5KM7bnj3POcX0BVQ0u0BHswu0LxTVTzzwC+181l9fGc/SsexinZNdrLNyiiuBgz6N
+ fKg4bEcAfc7uN10IU6Mzb7IKy8+MURvxiRRDBnZDOGkcU2AYFtt27LyvVasOBzxDT4DOm7Thr6VesnFy
+ ZeVV6ZGD36z55MYvqybd/bazeOqVq8ubtY9e+tKPvk38Pl++0AaBcBYzp0979tGnnqo1A3FvfPzxx9GK
+ yj31CPaM0jXKY3fEpABpZoJcyGQFosE0/WzetGGvmYFCiFqjEl8a/NIjrkeeUhrDtNi8eYv6MZ2F/d9/
+ 3ivs88vkivV3VHz5xsiKb5b22bUkd8S2yrwb17dq17rhh58e8ACgoUOH5s+aM+MfwVCWAFAKurYr5JZf
+ tmPnFxuZm8ik/gJIwUJgv6Iw6zmEaK1lbmHJ5pzchjont6GOZRfpW0M52nnlUp1+7Qz9aL+jtT8U0bFY
+ jo7H83QoFJn2wAMP/Cwte+djui+KxAt1LKeBDkeLdJOmrX9yGOxNtw86yfKHdDyrSGfl5umcvCJt+EJ6
+ 5ovHam/Na9qrHKl16X36gm4tdSyngc7Nytc52QU6O7tYt2jRYtxP7e+aa244MhAM27GcIh3NKtTheKG+
+ +bYHfpYrJXc66sj3QtFcHc0q1NHsYh2PR/WKGX/R7pj++svGjXSDUJ6O5RTprJxinZVd/Fpd6z2QHDYj
+ gJkzZ1pNmjR55tlnn82HTCWZnHhkmdYKrTwEBvNdh7XTtyCEw23ntaBDtg+tBQIwDKvb4MGvPngoNR99
+ dv8mnfteV7xwofbtfU8ttAatNIZpsHXrjnNOO633TyqNNf6rcd2F3H25tSYnHMXzPHymB9IBaYPpEPAH
+ sO0UWeEIaZFxFFZUVHUeMWJErVN4tTFz5kzriy9GvuazgtaeBUf4kdzFsQsXRu545JHTz7zyyhsH3H13
+ 85/y2/5/6HvR5ectWbr8UtMMgjZIJSp57A/9aG5tomzaTqZvcaky1O4xkQbNf2X57x/isDEAgwf/o/vG
+ TVsG3f/Aw2MWLlwYAQhEwksdx0GLTIbbdjPIuK+XIINBLG8brw48ES+VwtNgGAa7dlX8Pjc399SDLjbW
+ qKW/uO20+VOmrV0wYdTmnme1XnnBZVce90O7e65nCAQWLi4QCvuZMXvGk4MG3dV0X7tUnnOS3/IBHrlZ
+ cQIBQBiEhAGeCyqBFkkCAYu0naJRfh6unRn2VlVXR6eMmdBjX/saMGDA78ora7poQ6I999/Pvud5tZqB
+ /ldddeovzjxn9fN/fmrUVx9+9uIrz/59li8cP+iVdl9+5528MeNG/S0UigEK5TqceUITburTErVzF/M/
+ W8tyn8axDAydySvRhlz0ow3/F3HYGIDi4uLNhgy4ju10vPKqX/4OoG27djNc10YAWtqUmYJZqyuoLA1g
+ J1yOaCW48ZTmuJ6NBvz+oEjWpN4qKSlpcLB0Nm7cONtIJ76mbEe3Ny5vQ5eQR2Vldck348a/N3OmrnUR
+ TNtzTdD4DUHX3DC2liB8WW+9+/YHU6ZMCX53f621GDBgwMlt27Z/taRJ0+mNShrP2bhx69lCgO04nHJ0
+ Cds3lWJamojfQ7gKnXbBcZB+ByEkAZKETYFCEQxEeO2ddz5o3rz5iPPOO+eivdUiOLdv386LFi3+g+UL
+ Ytsuxxfl49g2nquoTidr/X3Tv5n6qJty8wO+EHcc3ZiWsWCWYQX+agZjN+3/md47zz77mf8Pt98zXLmi
+ JPMYmAQCDi89cg7uthWI7Q7LZmxiq7AwhPx3IqCdSC07WJrqgsPGADz00D2rmzVr+jctDJav3vCbsWPH
+ Zp3Qres8U/oxhEBoQY0hqJIW8yeVETB9iIokf7iiPcWGy57gmGAo0rCqMjU6EMg6KIUnyyrdyzxJ4zbZ
+ Fle0qmFg+zh2OkVZeU3jKm9RrasFKdfTWmsqK9Pc3KMFMp1ACJN0yu48YMBNj3573z59+/Zu1qztzDfe
+ fHfclq2l11ZXucdUVztHCSElCPDS9DyhHWW2Q9wyiIdB4YA0EJ5LLBTCUJJKJ8Vx7UtQngIJylOxil3V
+ fUaPmjC8pKTp9Isvvvh7y5wPGzYsPnn8hGHC8vs1Dkfkm3TON1BGEDedoFOHVrWWGneVjqEFrWJB/nhO
+ Q/7eIxfXURhm4NGePXse8BWUzhkwIPuOe69+P5G2TzEMA4kgldjF47edSXEshVFayaZpW9melmxVGkNJ
+ EAIt2J5Mlm450HrqksPGAAB88MG7dxXnF73jVJVHSktL4z179lwQCka2Q2YmwENTZYSYN20VysqHpE3c
+ rOCxi9uTStvI3UbAssx2oXBguhmMda2tn8suu+xHp7N+CKXINhBsTWnmTJE8MbUaU4YIB02nS7vGtXqX
+ 03a6XADSF6Bs1xbuPrcVadvBtPwsXrL81vPPP/9MgMcee6zj6C+/HFFRWdU5EAxjWAYZb37Gy+94mv59
+ 2rFp4wqEzyIvK0ggYqJVKvOGcz0aNoygSTNv1QauO+s40unUbhUaISTBUJhEItF1xIhPx3do1+HlsWPH
+ /vuhfuChh55NO24LQxikEykeu7Ijs5evR0oDKQw2r11Tqx8hPydraSqdZF5pBb95dRGdCvMJCPAZInv2
+ /CX7tY5COBzu0KVLl1pHHPO++Oqf2WHrXMtnIaSB7XqcdVwhv7yoKWzfAZWwcMp60sLPNjPzCUmmDuBy
+ /m8K5bDgsDIAHTt2tFevXXLFh0PfbXvRRRet69ixox2Nh1d7WiBQCO2xxvCo3JigdJckna5Bp2q46MR8
+ js7x4wiTTK4nSEFBbnak1vnvxcuX5xYUF/9tfzQahjVbaEWlgmNHLmSlcIAENcmUr0v34z/5YsqU762D
+ Z2TePmDAnBnbue2SFpyYq/CUJBKJiwkTJ7z+0ksvFQ8f/v6NhhmwMlX9NHY6TTKRwMVDaY1jp+l9WltG
+ jVmIZQQpKYxA2EB7KYQG7dg0aVGIhyblQl5JATmmRGvQQlOTUmgv4zQNhbPYsHnL9dddd8O7AOf369dn
+ 5YpVVwvLwvVczu4S4SifzdYydi8+KNhVXv69B/KUU066d/6CJX2lYeATJq9vSdHj7SV4hokSVJv5WbVG
+ Ne6NaE7O1bFY7LRZs2bVmiuQnxUrVAoMrRHSoDDs8sojvRGpUpw1FVANmxZuYafwkRCZygm7rcCKn6rl
+ 585hZQD2cO5FF63+9z9KrtFaI8j82JXKwfNnM3b0cqQFKi2RIsUdvUtQqRSCTD6847iJrGjhX2prf96s
+ WZNrKitLc/ILxvbu3fsnLfPd+/RuX2vlzZFSYvhMXKeGrg2iKK1Zt3Z9j/7n9pnw9NMvFX/7GA1SCIH2
+ PNxEms1bUwy5qS1xXY1SAtfTDZ566q+jUynnStPMzGS6js3ll5zOO0/fQpb0UEphGBZ/fGocU1c62K5N
+ i6YFgEKr3Z56V1FQEkZgYJg+Xv9gEq0aZMqFOymHP1/SgSb+FI5r7I6wDLBt246+513Q54mJE8YPDkdy
+ kDpAdiDNC38+nnmvzyNp+tA4aBShcPjfcQCTJn0cbdmq5UfffDPzUcsXN/zaJjcq8BmajVam6qbQ3os7
+ Fi+uNarxBxB5RcV/SSft67ds2fL8D+2Um58/Pp3KZIumE0luu7wLOWon7vJyrKTNrlUVkNRswEWJPY+I
+ RmgOePRhXXNYGoBvo/zGJs/zMh5cwMVlLYI5k9ZBKA9VkUA4Hmcfl0+LMOjdSTKGaY1ZtmzO5h9qt2fP
+ nk+W7SztOGXK1Nmt2rXrvq96hg8fbudlB0/UrvOO1B6Wdri9WxOu6tUBrSGRVB0eefT+2f37X30UZHLl
+ XY8SgUAJiAb9zJyygUYNNH+7uAiVrME0TbbvLGu/bceOmJQSgQI3xe8uPJ2OBZWQclAIhCFZsClBWmmk
+ XUXbNkWQ8sBVIBTC0RRmR1DKxTIs3v5qOrM2bwOViYyX27fw5QO9ubZjIUkFCgMjGGbU15PusD1fkRIS
+ L1nJmw90w163gy1bICU1GoHCo0FOLA0wZMiQon79rh+7aUPpBT5/FDu5k3eGXMylzQK4ysPwFJblTLr9
+ 8cce3NfzWlTUMj+SnTcmmUzfqRC3723f3mecMdJTmTBxtKZTiYlIGqiFWxGWZuuMTVimyWKhkFqgVWbJ
+ FEd7h5UDEP4HDEBBYdFy5bl4EnzCwDANxtsJLDvC4pmVYKSgQuGzEgzs2YR02kaj04ENoQAAIABJREFU
+ MQ2rdG/tjhgxoioUDD1uu6rRpvWbJpU0a3brvmratm1bjad4FwRSWuz4fB7PPnouZ3aMoLQmlXKLPh35
+ yaTLr7rqMkCm0ymfkAKFANNi0eStKNfjgpMU952ejZPWGNKE3VXFhBD4QzGO7Xcn3a98hQorhtzttzcN
+ CUrhoWnaphAcB89TCAXaVWRlKaQyUFpjmiZogVIa1whwx9dbaXbrCD5dtg1TGuhMbjy+QAhpGiQTCR75
+ RUNO6VnEkqGrqSJAjQlCZ97ohfn5idtuu7n1nXfeOa2qMtFFGj6UV83gl/rSNbmTdVN2IqVAa8iJ5V37
+ 0A03JPblfMZyi46pSVXMktI4BYwRbrJq6t72N4xAWojMp43PSNC4OITeUorfAZWGXbO3MVf42B4Q//nF
+ L+XqH2z0v5TD3gB06nTEKq0VCIEBBLRgg6rCFX6++WIZVnExbnkNXk01F55SSAwXjYGdTJ7YpMnJe10g
+ s2nTkuc8z1lhmJZZtqP86azs/I+aN28e3xddpik8rTUppTFtg5VDJvPhp+fRp3sUR7soLcMfvv/B29cP
+ uGWAKS2N0GAoUkLhJNKUztzBlhUGF3VsRPuYQKnMp7bOlPPB05qE3yItNMlEGT5h06QwTuumRWgvjVLQ
+ pGkYpTRKO2htguOQ51fkREy0EPiCFt1O6EzLDi0pKspDSo0tDDbYoIXK9KUlWoGbTvHc5a0Z2Cub0plr
+ WDm6lLTpIVQgMwtjGBQ3adT49dffG5eodhprw0c0mmLcR2fR/4IIs24bzcZAAENamIZvx5o1S1fuy3mM
+ 5RQOVFpPEdIokQJtu4k/7G1/rbX5/kcfPBwORzJFUYMGjQrj6F0JiGjK1yjSKcFwBBighM58/muSVaWh
+ tfui6b+Jw94AtOrQZoPWmWG90hopJIZp8ZlIkV6bZvtqgRFMIWsg7t/FL49riOOksaxA8/LShXstJb54
+ 8WLbMOWDrutimiZKqQu2le2aE88r7vJjumxHlaLBE4qVgTDzhkzCrY7zztu/4Nwj8/E8jWWG5Ztvvv5s
+ VU3N7gU6BFppLKEoXZ/Fb5/dwhF/ncfSag9TmHieJpVI4tppurZvwh03/YLh773IgrmjWLd+HktWTqTv
+ uaeDkkg0jeLObu82GSepUpg+l9z8cCbtVSs+/Mdg5nwzhVXLFrBh9QI++fRdrr3mXOKhAInqChzbQWsB
+ wuBPQxfxi9uWMOMPmwj5/FSJjA/OQJKdnaPv+t0fPrZtrxhpkhNIM374KbQtqWbly+uwqw1WSQdDSjzX
+ W8iehQp/mGg0p+ifIJ4TSBPAcd0PnJqaWp2GTzzxRMFlv7zytsuuumLcmtVrTzbMjPe/99GNMB0HYXtQ
+ ksPOUWsYKyy2mxrDk4AAIQG9BlYeFkVAvs1hbwC6tW22xgxEyiTgCYE0AmihWEo1pZbJ0k9WQsMIIumg
+ d1VzU59m+D0QhkAY1jVHd+nym2AweH48nldrQkyHtm2HK9dd/u/FIgTNtJv6JhrP2esngZt0Vwq0Z0gf
+ C5SDPwUTn5qOSpbyzj+voHvrILbSBHwB5O5hqCEEs22XjxKao0Yv5zNPIAMRbNvGo4oex3fg5ReeYs3K
+ eYyeMJUHHvkbZ513IS0KE/g3vo2onszHH36ItKAgN0RuzEFgZDzcOp0Jd5UuzQojKA2VlTUsePtBKp84
+ GbV1AtHcKL1PO54Xnh3MqmVz+OqzT7joojOwDBs3WcUO5efzpOTa7dV8ICSrdZCUkQmiTafSYt2mLUIY
+ AXy6hk+f6EyjxAaU7MjKp6awURhUiQjoAEj26vmPx+NHRXMK5ghtXqKUQCgXJRS27T36A4f4/vDgn0Z+
+ /unXT039ZvbxWmQ+p0S6klsvPgJduhOCilQ6RNnScj7VHkJq4jqNRAISKcy1e73R/ks57A3Aqaee6sZj
+ gSVo0FKQb0AzNAKTD7VgwfyNeNVB8KUhbdAgmKBXuwY4rsbv87Fu9ebnDRn4uKqmptbCIbNmzXJ8Pvln
+ z1WA3D0EF5aApyOxnM8ikaIfmCWo2AVyjTQMFnqakPSz+M2p7FqSxls1h8//dhbnHJOD67lo5WWq9gCL
+ bI/Vhg/DslCeTbfurXn3vddZt24JI//1L/pf/Uuy87LQqRUIdy3am4W99A1S0z+kculclq/bgZAGjYqz
+ kVIBNp5KobWLkAbCqaFFkzjKdRHSYtrEpQQXrMLZuhwMB7fmRdzESwhvKqec3JU3Xn2ZDWuX8e67Qzj1
+ hA4YOkW50oxTkmFyT4VhEEJmqiDbu/jn71txVNEOdm10WPPuQlJlBnO1gWdmphuV9mb90PWMRrMGCWlO
+ R/tboJJEpYOWAq30p05i17zajsktavCXSDR2jGGYJJNJtNIk0x6/7N2apo0cdHUNsjjC1q9Xs0T5WGEG
+ yFUJzg6GcBG7nYXePn2S/Ldx2BsAAH/It85VCo1mu/L4ZXZjlGuz0TDY7AXZsjAFpoNwNLqynN5H5ZNK
+ p9FKowBpmgR9gbuAgtraLyw8/l0PscrTgpA08bsalRlan4VMzwuHc3vWKszHPFNIdkrJZtMikpQsGr2O
+ NR/Mxtw8g+GP96JZVgC1J91eCNAeTipJ3wt7Mm/+JEZ/+TkX9DmdSNDE82ykrGbX6F/gLP4NXno86GqC
+ PS4kdsWvWbO9kqQLnoLmTbLQXhlCGCCTKOWASINj06ZFDqjM+ooLt1VgH9sJq9VJmAgMmiDcHYj0R7gV
+ j6P1NgL+FBf0PZJ/ff4Wq1dM48mn76RN8zzcdBKwAIXWimQiyT8GHsXpzSvYOXoD0Tadmf3MRFIyxGKt
+ wBQo7WEKY8l3T1U4HC6IRfL/ZYrwM67wWyFpc36jHCqTGoREud5jtZ3iFq06XCW1GJTR4OG6Lp5SaLuG
+ Ab84Al3moWoEhBux9quVjBEGKRwGRvOYXaPwGSZSgNAs3a+b72fO/4QBCIQiK5y0A1qSNhQ1nqKLkUNC
+ OJSJIIsmbEZaFmiFW1FJl5YxcF1cz0NqUBosX6BpwB//LLdNm+h321+58os0nnrQU1BR4/KLpg1oFNA4
+ roMhKEbo0aFQ9nPAfywiakhrvJQGDpqFlkkQk7HDltC6dwEfv7OT7pe8xfqqNIawUVqRTlRz4fmnsmDe
+ FP7x2mu0LClC2YtAz6VmzdNgaJSuJvukX+A7+jrSFYrVX8xk1P1DeKbnn7jz8iFYlg/lerRpXoiuTKCl
+ RP47S1CglUPzjrmAwpDw6cxN3DnwG/58Wl/GP3Q3G2YGIHADMn4NMtgDT4GWlUhnBl71qxQWLOam6/sx
+ Z9ZI/vnG40SjDo6TiSb0BwLc+4+FfPmODVm5rPt4EV6FQVK7rLckpvKj8By/P+c/HrZIMN7XkOGFrmWe
+ ndRpCkI2r1/Ygc9XbcT0W3ie/jpZVTbtu9fl1DPP7FBeVvqCaRpkvuUzGZWu53FMy2xaFkrU+lJkPMSO
+ uWWUlqaZL6GYJC19FiulD6E1AoFSzqoDdT/+nPifMACtWrVco9TuKFvpY051OT3jOXiuzRbpsWppBcnV
+ UbSsxNA2rWMJmmeHQAqkpTn3yBbYnkswlNMluWnHxy1btvzeasCp1K6haHuZ8lt8tHQjjx3RnDvP6YSd
+ TOJqhdDewGAwNi8WjB2z5xjXTk2RCCxhsEA5aGlRsS3N2EkW93yTYGF5GCECJJMO3Tq3YcqkL3jzjVdp
+ 1TyC8naizRTa0HiJcsKN+2Iqh4ppYxj18Bc80O5WBjS5ibv7PMYbj41lzqRqdiRDYJogoEmzGMKu2u0A
+ BKEMUAI8k3aNYyjPQ2qBK02qdYjt0zfz6YNv8sxpl/HX/Ba8f949zH9jGW5ZOYI8HOtIMItQydngLUWr
+ uVxwUZxlC99g0PW98ZK7UJ7L+kSEa8ZVMXdDc1b9bQk+NFtNwU7pQ2gPQ3vLd+zIBP9EIuRHQgVDhRn8
+ EO3PT1VV079XHl/8uScPvzeNpC+Gp11MqR//7vUYeM89+QvnL/rU5/dHUqk0Vx7fGjfhorVFKqW4qFdT
+ qNyGV66QWVmsGbGEculjrbS5MORj5s4UbkAjpUbjoZTa5yXO/pv4nzAA3bofu1ztSWCTLmuVwzEIgtpk
+ s/LY4flY8NFOhBfMTFtVl3NuxwJsJUk6Nn+592yiykYIj1AgfFppWfUwvl8WynFd908BHLb7LF6dsIHj
+ c8NMff1aWsYErqcQQrTxhJgWisSfIScndkS7louV8hwDWCk0pUEfy/1B+j63nFI3jGcnaNkiyIgvB/P1
+ 159y5FGNQexEi+p/r+AjzRK0U8y6p1/lo46dmHvajWz980hqVlQT10EaECRX+wlrQVJ4gERpTYNiC+04
+ oBUikyZEZvkrTePCAHkxfyYk2NAkhUeFtEjIADuEoN+fbyTxr7G8P+AeHmvSjU+uvZqqebsQwesQoV/j
+ 6iLUznHIiokEjUn88S/9mTv7TU7p2gTXrSFl+Tn/7fn8w4yxxvAxzzRAaBwnxZFHdlwKmEFf1m+Vylmu
+ BBc7jkM0nGDkkBN44oZ2PH3TxyxRUbRho6WeXVm2fdS3L8SIESNCnw7/aKTnqWZaWRimyx9u6EzEEijh
+ gbI548gGuEtKsSyFU67YOXst8wwLodL0CuQwTjtkZl1Aa8+urvYdcgOgtRZDhgw5qEu0H3IDcMkll5Q8
+ 8dxzzQ5G22PHji2qLVX1hC5HrrR8IVsJAJNSyySdUrQOWGw2HKqkjx3rKkgtNhBpD71qE/3b+vBsheOY
+ rHVtTu9ciON5aATSkOdl5Tf4ODc39z8+B5xU1T8dbawypWC10IwbspDy+cuZ8VV/fntOA+yUjZdZeW9Q
+ xJZrlq/Y+IzUwhJaU4XHswZMDYUIhsMIqnnmiZuYMW0avU7oieclMIwUnrsRMDAMP9VLVzPu1jt4q3kv
+ Xr3/dUr69eIzLWgmgwSUC0pkwnCFgzYUtiEyEZFa06BAom2HPbeA1gZ4CXBTmL40zRvEQWdqX4WkS6Gy
+ MQT4Dcnwh4ewTcTw6Sx86RiLh0zmb5178cYJ3VkxdAym6oDMuQY3HUJUbIVdY2jezGHkmNcZ/GR/JCmU
+ 3+Bzw+b5sMVES2Lg4ZMwZ87sxqFI3jKfYT2rMbLSyQRXXtiWBdMu4NgGDq9c+jXj7BjK0Jjaj+d5T3/n
+ cov7H3zkvfLy8m4CiaNsjm+ZR9InqUwnUVrQqYFFi5CJ2OyAa7Bh/A7SjmIZLm18fpKVLmssC6kc0Brp
+ 6Q2wZZ+Ckg4kl11x9YXl5eXfyw05kBzwarg/xqJFiyoT1dUPbVi//osD3fbEidOavvjKm6MKGjQ9sWGL
+ Zkcd0aVbw76XXJbVqKS5/c3ECX2qqqpypAZHCuJph/axfKYkttFJBcgRJsVbkkS75UKNS6FlM2uzZlU6
+ StSr5vSTWvH+mCX4rQBSaqSQrW2HPpH8rBHJyso9i0R6vlDYE1qcXaY8WpgBdkxYgYhnceO9x3BafpRR
+ 09dTmfLwBYJBNF0yTnKBJzVJS+C4Ll06ZPHlF09xymndUI4fIWsQxi60djGM5mwZPZYvf3UzU+/5KxVT
+ lxG2TZKBEC9MnstJRoywl8YUHkUYNJIGTUwfeYEYXyuPpBRI7fDgTW0JpsoRysMOFmOGGiB2zUNoBaEg
+ oyeUs3B9GqTmGGlyuvBxhPbTWfsoSgq00KTwSCHwY+DDxN5QxuwPP2HKay9iiVwanvgbPKmRyZV4zmow
+ WnHUMZ3o3zfK1Mlr2bS5AsMfxBMg0QgBSoiGQohsW2migTRvv3wptw+Kk1yynncvm8H8dJipuJimgYBN
+ xflZN5aVlf273HjrNh0Hb1i/ub9hmmitSaaqeejWU1izYDXvTylDuSnuv/A4jtLlCE+BMJn2xTKqyz3e
+ NxSXBmJMt5PMtmQmgElplPYq/cFgaaOSJu2zc3O7BoLRk+J5uf2kNK5uWFwUKC8vP+BVgq//zfVtvx41
+ +pThw4Z9fKDb/jY/Uqjp4ODz+c7uftxxHSaOH//EgW47Hs85PW2rzzEMU3sOSmXSgMPBgN5d7RmBJOC4
+ PGE2477qpZxONp28JP2wiJ+ZTbSVwktUsMzfiOOHrAVLMOXFPvS4/mOMUBRD2GgMBILqZM2yLkd1P27S
+ pH+V71aQHY3G1iqdjGmtuVtEKa3ezhkDu3D29R3ZtXgTf317CW9M2kqZG8SwDDQKoQ2S1ZX84Z7T+P29
+ p4NbgbbyQBTg2Q5m8Dh0pcOkWwax6M2viQo/UkoCnkBIF6kVDYQkotJ4ws8qI8xUU7LA8FiBYJfjZgyM
+ oSmKw5ovToKN6xBemuqCo/HldMO3+i08w0Xm53L/X6v50z+W4vNnQnODrkEjz6WN9jgWgy4Y5GuPdUKw
+ wE3g4iOIgQKq8EjiYJXEueaF52l2dlfUtg/waIwU2zB2vYvMb8Nr7yS46+EvsG0fhmmAzqQN2ckEfbrk
+ 8reX+pIXW0/lol08f8UMGrgF3KerSVkglMZnibtLS7f9+/u/QZMmz5SXVgyyfP7d9R0kYaOCpZNu44Kz
+ /s7k7SZtiwJMve0UzPWrQDmoqhjvvTSOSgL8SaR5u6ARV+0spzzoRygPpEBIhVQS13ORBkhhYqdTNGpc
+ 9MyKZcv2OQR8X5k5c2aoV68zJw0YcGufP/7xvk0Huv1vc8hHAACe560o3Vn+p1NPPXvOqlVLtx3IttPp
+ 5OqCgsKNqbTdxx8MC8OysCwTjScMkQleFwiqhIEvbXOeiLLKSxDDpKUZoGzjTvK7NEakqyjwJdBWDqO2
+ KLasLKNHyzgztyTJtiRFYR87bRef35e3edvm41o2K3l3x44dHqRTgUCwQCCOU0ANAUq0pnzGFqbP3Uj3
+ k4s44ygf157VldI1KaZvKUdKk4BI8cHbv+Saq5uhk8tBOFAzF6xOyOA57Br7NRPPvYyyCaswrUAmtl8K
+ TOFS4rl0NPykDZOvCPGCGeQtUzLe8lhnpKk2Fdow0WiUVhzTPosr+kQQZZWgXdxIA4S/CFk6J/Mm1rC1
+ Jp8RY5Zj+qxMfL7UlPkEyyyTCRK+EDBDSUztcbq0aCg8ylFU4mIKMDAwKh2mv/dPKtatp3Wfe/Bnt8Fe
+ ey9+IaG6jM6dBVdd3ZO5c9axYm01QpqEZIoJL3Rn0HV5BLYtoGK+4pkbZtKsMsIXYcWS3Q59lKps17b5
+ VRs3bkwCNGjQ5NnyyupBpmllYg6EJG273HlpR1Jby3jik80EjCRf/fE88tavRCoLd10VO1elWLV2B1t1
+ iNygQbYneY9MCsDuRUAQgkwEqWFgSBOlPCJh/5Pr163da9LR/jJqzJgXQuHohhGfDHvvYLT/berEAAD4
+ fJF1W7eue/+uux56d/z4UT8l5fNHqaqqmFtQULChuipxfiahZffwEkXaTWMpRVthsMArZ7NwKDB9RDEo
+ 9ExiboKyKkX+0Q3RFVX0aBFjxqpyvtpgcFbbXOau3Ua163BW2xbMWrsNw5IIKZokUnZhsqZyJIAQvsVS
+ yhsNIa1dOk0jy0+1tCnernnt48W0ys9j2+pN3D96LS4BirNsxk+4ls7tXFTNKoTn4FVuRcYvxU10Ycpv
+ bmbZbX/BX2UgpCCobTwUha5LN2GQNGO8IBQPGZpPA7DZp3AMF2P3jSu1JDP80Xi2wyVnFnNKaxeR9IAU
+ TrgY098Qo3Q6eBIhBV6oIS8PW4pl+RFIpNDIzLJYCCFIG4KNPs03pmSUcokokzOsAI0DYbZ6KWwhCWhJ
+ EIsd85Yz7e3XKDm6E3ldfoVX8SXSsyGlici19O/fnhjZTJ6/hcoKRSSRoLsoZ8r4FP94dBV5qQiJgMl7
+ pkQIhfY8gkH/y8uXLf6offv2Pu35/pGy3V8LwwQhEQikNAmJBE/fdhKX3P4vKtI27zx4Dsf5tiNSCpFy
+ Sc61WbVqFzU1KWZrhybRCFuyJJe2iODTaSSgpCTtZe4fQcYQ2o59f0X5zvsO5D27h55n9Bw4b878u6+7
+ ecDlk8aPLzsYfXybOvkE2EMgGB0Ti8Win/3rk5O7du16wJ0sjZu2uG77jtKXLSsg9O6iGL/Ob8gpFQ6d
+ Ahax7Fzu3b6S17dtIC78XO7P4XciSGlyC9mnt6bJ8UHcbVtJBnPp894GVnhhOhSHmLG5nEYBSYOYn0mb
+ qvH5LAw0CGNw6bZ1NwI6EMh6yfL5b7Clpi0W3V1NF79NvhA8XFHFVsug2oiRqKlg8vg/0r3ZJFTpWoTP
+ D56NaPIbNk6QjL7mDmI7U6T8kqg2Cbg2YS9FGxFkl+HjSeATI0VVIIwlPPD4j6v6bZeo1ppEsoaRL5/K
+ GU02IWpctE5RXdQZf04PjAXPgxlARiKkYx1odOoIbMPKOMK+FZqvdWaUoNF40kFoC89TNE55XKo0lwYj
+ rHRSzHcUZmbyHYnEppJj7ryZ0x+6HmfNAKykg/YcdE2CDXSne78PKE9YaOmRJzyuIZtipxITk2HxINOl
+ IqDAcdL6gvPP7jB69Oia6lTqfUMEjxFS/t9bG0jYNnef15z163byzuTtvHzbsVx5hERv2IXwZeEN30Z6
+ XhnT3EqGk2a86/Ln4gLOCmezRdRQHs1iVlDw4cadTChPYBgGAu3ZTnpAorr8lQN9rwL07391l48+Gj4h
+ v7Bw3Pq1a845GH18lzobAWQIr7K99H2fffavxhW7yj860K1X7Cqf3aRpyeaysvJzDcMntBJ8U1HOemVD
+ yuPLjatoi59LYsXsVA5DU9sZ/v+YO894qaqz7f/X2mXq6edwOFRpIk0FRUBFikoUuxixEHuJxhKNiTFG
+ ExN79IkaY8GKxhpQVAQBlaKgINJ751BOb3Om7rLW+2EPap6YPJpXk9z85gMwe62ZPWutfZfrvi4/QWms
+ hKItbUg7RtHgckKNKc46sorV29pYlxYYvkFrStOr0KLYdtjd6mKaBlpxWCRa2D2bTrw9avgxbN+7+zzL
+ tGjUioOADlKRicR5O5ehVYQ4+tAQzz1yHqNPuh8nVcXoXgZ+cjtG/0v56A8rWXLl7ynLWjiWxNOSYq04
+ RBsUhqM8qQXXWfB5yEBZNjJQQAm6VwWIPKX3357xAvD5w7U9iKgkwlMI3yNrFWMVH4zYMx9hxsAqwqyM
+ MHdBLfua/fxT38jH1fuHCp6KEgMpNKaUpCyDj40IS7I5jhEm4yI29V6apA5hCBV4A4s/Y+uCz+kz6WfQ
+ PguZlewKD2PMxLcJF4S4+kej+OjTbXhGmFDY5Aqjgo8szTumh1SgfJ+BAwd+sGLt+mxbIj3NkuGeUko8
+ X9OpIkYmp0BDjBTXHz+Ah95dzZu/PoFTD8ogPB9SRfjP7KJ1eyN3eQl+76VoMAV3lHWjoCXLooYE77VL
+ 7kykebm2jl2Oh2kYCCXaPOmcmm5rmfpdr1OABx9/vPOUp5+en3X8kuPGHnvZunVrdn0f8/xv+48eAEpl
+ q+1Q/Mj2ZPLMwYcMZt++PQu+6zlampuXd+jYYVVbS9tJlh0KGdJgj4CVnk9Xswgz49CQznCijHFSQVc2
+ uUlezLWyCIW5LUPXpE3x0A5IP8VZQ0ro7GlW7svR7PtUJ3MMqogwaVR3Zq3cRygUAq0PtSOx06tr9p1n
+ 2XZc5Om8cgoc0+RPbW2kDItJJ1Xx8nNjOKBoN58tTfHMmysoLh/M4SeNYs7Ni9jx8AyqzDiW8NDCp6+v
+ 6C8NXtGCnyjN/JjEs03MfIyKkCityBcV8vQnwV/2E546rsvVJx7AqePioNy8XoKHa5Zhlg5A7J2HLCpB
+ hGMQ1yTNSt57fyemaX6B6We/atAXTPki+BOcP0jpUROCmfnOxR/JMJ1xqFUiIBDBxq2uZf20efQ84zCS
+ FQcz9rQ32LGnifvuPpkbrm6nvLALMz+oZqeENdJgk4AG6SNFQM3d0tLcrb09cUrItEJCGHiez/HDyhk3
+ fAALV1STS6d5+JIBlNbt444LD6d3aQoRDaHrLFIPbOLDbIYJrXvZLHxuiFUyXlrsam1D6yiLQ2H+EnJI
+ GB6GDGDACLFDee6YVFvz0u96fQJMmzatw0033Pih65g9iopC85csWfy772Oer7P/sAcAGJGtti0uq9lX
+ M/rQQwc31dTs/c5vcjKR2FhaUv5msj11omWbpaYQeKZgneXjGWH6epJqz2NftpHjjVJOscpo0S6vqDa2
+ 7Gmjal+WHiO6oUSaAVUG5/YxiPqKNfUe6xI5Bnex+NlFRzD9w3XkpI2F21GYVlzka+xSCBJotilwgAmj
+ S3j+T8MQu6sRluLE0WX44S7U18Spn/wJTTNWUC4ihLVBVnoc7kGlYXGtBU9FQ3jhL2NdLSSeYaAzGXx8
+ hGXkE1ci3+qbh3oIhedm+ctzN9PwxusUDe0HMgutaVy7GLPyCETzh1BWiNPxED5+fwtnnncyjz+0GEeC
+ FPs3PQTawgKhLUKuT7HWpMzg86h8rOxLySKpWUaI43zBUTLLLhTtSGxsShIuS3ZIHn5vM7F4hLPPHsBN
+ F6YRDZsZOtKmIFLB3Pl11BkGjdLDyIsO6wDOKw1pIoQknc5xzok9+O3t53PBtc+QcwX/c3l/zu7p0LtD
+ GaGCFLJXCSzMseChz7misYVn0s3cXt6dS+woy9pTJLSg0KrgNctjlp1CSwlSooUEpT/VbvK4VKrte3ki
+ z507t+ziSy/9IOv4Ax0nw7Ajjj5/27ZNu7+Pub7O/uMHgPIye0yr4IhwyO6zZ9+e8YceMqS+pmbvsu96
+ nkwm2dijx6ApjU2NfU3T7GcgkUh2Gz4JYdDTN3DwWO6naPV8zhMhzghVshqHv9bX07iijsOP6IdRKjCd
+ doZ3cRleVca0VQ0s3NzOuYNj/OK6E1mwaDN72zxM00Kr/eXpgF/f0T5jh4Z49ZEjMGq2IUNRVCaF1bM3
+ o/oewZt3vMy03Rn6CwsTj4xQDFYeUSvM5VowLxbClkGMG5DsaDwg7rbx/lkFnNo1zDsbHVypgo2/3x0A
+ EBppWrwzYwlX3PBDal58i9JjD4emOjwVw+oyEtrehX7XMZY0AAAgAElEQVQn8OI1sxneL879zyzlw3Wt
+ gQeQ3/xfKP0AoVwb06/oyLVHFvHC4hS+IQP4tBBIJIaAXcJjhoJe2uA0oWnWHo5hsbpbR+7buJ3qTdW8
+ fPPpnH/zGeR2TwuUiRMeI8aEEV4hH35Si2nlPRotAYVE4CtNJJxhyp9O5earBnDOpMlsqdOcc1QH7r6w
+ AlHTiqwoQBxQSOO0Gu58dBm/TrZzSEzyTIduLG5uYFG7oqMRY49t8YzMst32sPL3TSmNUjydTtRNcF23
+ ne/B1q5dG59w1sQ5yVRuiJAW0XB42to1yx78Pub6R/YfPwAAhBndIA1xhWWHRE1tzUmHDx2u9u7ZtfC7
+ nqelpSanVfY1ocNZDDkGKaQUkhrDY5dQdMGgUFlsQtEmQHjt9DFMetrFTG5v5qPFuzjmkAEU9vGRmQxd
+ KxxKjUJmb0vw2dp6rumT5PJfHE9RYTkffboBJcNIBFILfCU4vKfk3ReGYjdtB2mjPQdxwOG4yX7MOe4+
+ ujVYvKRd9pow2IbBTgbfjHC+YbMkbmHk97JGsX8fesApZRZXXFRMz8PD7Fns8llaYsq8Ty50PhcQXNmS
+ SvHZsl1cdlp/ds1eQYfjDySzL4XZ8wiI7WL7K1sZ2i/Mr57fwTMftGHbweaXfDUEAAfNxGKbq34cpqij
+ SebTEAuyOUL7+QUgHxxo0pZgmhRU6xBnWhbzoyYPNO4h5/lcKW2SM5YT6diZqnG/Jtf8AZaXg0yWY8ZF
+ yLWEWfR5O4Zp52c2cJwsJw4vZMZfJnKIXMKid/Zx21/30iEGb95/KPaeVoySEoxuYWbdsZkbX9/MMjwe
+ PagHY7G5Zu8e2pWkj2Hzjh3mAyuDMvjyYBVCKe3dmEnU38r/TUzyL9mnn35aeNoZZ73X0poYbpgmuWwm
+ d/TY487YunFdy/cx3z+y/4oDQLnpWjsU7SeEGGjbEfbu3TOmR88DujY1Nrx7xx13fOc87L6fWaSl9b5A
+ jAOKTGnQYkk2CZeIMOmpBHO1RkubjphoL8F5xZ1YoHI88+EaDi0sp+vQUlQiyZCecRZvSPFZc45Dyztx
+ wK5FjBjfidHHn8GLry1C2mE0Bp2K25nz2EHEWnYj7DC44FV0wRVDeXfMb8jtVRRIhy62wVSdodoIU27F
+ uAGfPREbi3xNGgi4/gUajSEVn7dliFZHaN8o+P2qVlSIPAfg/y7ySBCSbTVtxAsjHG604IcVsihKuPMh
+ OIvfo8JIM3d1jlvfbiYatRDIfGY9P3M+F2CjWZ4WFG016L4hxo0bG8kZdl594UsLavJgSM1ySzPDd/hA
+ eTj4nCPhSF9gARveXYwsLaTb8VfiNryP0C6iIcGYY0I0VPt8tsXDNCS+l+OyM8t4+okxOC+9QqxWcMlz
+ NexqyfH6LSM4WDWhCyK4fiEP3PAxD61s5dAKwdPD+lK7YS83NmXYh81JMszLls8O28szEO/PaogmtHFK
+ uq3u1e963e23uXPnlp31w3PntLXnhhuGgdI+dkg+sm7Fsu9tzn9k/zXNQG4292u0yGmlCIWj1NQ2Xtqp
+ 6wELn3rqte8FC+1lWxb36NavvyHlr3Kev9dS4Bk28y0XFQ5THJLMNLKs8B2KKGJLSysPHNCPY7ocwIlT
+ VvL487UYB3RHhJM88ZMBlBiKZ5fuI17aFTFnJSMG+Qzo3gFhCmzVxux7qyi3a9FGGFxNVjtQMI6px91O
+ brdEaBNfG1wWFfypqgfrch6/sgzqI2ECacrgQeRrjUKixBfxMBHL5tfrWpiwqBknHsbABG0ELrOWCIzg
+ JSRSmxi+5JHXN1BQEYVP9mIphdtaj92exAxrFs7fjdKaXM5FiiDLL2SQV3A9F41AY2FbJreuyzJmcSv1
+ IQMh/Hz8LP7mpUXAICz8LI2RCL5pcLtl85AO064VGotCIky74U+snbwCOl2LyOVQKoJoTfHHm4s4vjs4
+ nknEgN/dPojkzNkUWWXMW22zcFuCJy7ux7jienQkzN7Ps0y6ag4v7kzym9FduaV3FbM+3Mx7WYs1YZuD
+ zDAbrSg7LDB00FTla01B3FphhkOHp9r2zvs+1hzAgw8+2PuHZ5+7MJV1h0rTACSe49QPP/zwr+Uz+L7t
+ v+YAyOUSW7XWT+yvM1lWmGQyfeTPbrp6we9//0DX72PO9esXJBOte+859YSju5uWud4wDSIhSad4hH6x
+ EKmQZoatWCUEcRHlw/VbuLC4jN8OG8pNc7Zy+a2raFGd6BRv5q9XHMrq3bVkpMKIxfA+nsMlFw8hnclQ
+ YWcJ78miQzGMAnDbG7AHns/MHz5IeGsOQ3iYlsI3s5QWlLBmbxPRaARDOVQVFTD84INwPCdgG2J/HL6/
+ xCcQwsA2DCwZOOqOk0UpD/JkqBAw+6ZTCQYP6sjkyb/j+auG0rqhheIKG92WRFoaKbNQ38KJvQp46Ym7
+ uPjC8QhyODmFwCDnZPnlTyYSQeD6LlIIbNOgznKQ+uscteDfPM/nsN4lXH/GWDzHxTYMXnAU27EYHyrC
+ Q+FKSSkx3rjxt+xc5ONH+yMtE11WQF2uE9uaUiidZtIPiikwE5j1SeSBUaZurOeBs3txyQgT0bWM6dMb
+ OfF/PqfBErx10Qh6Vrex5JN6cnYJL0uFkB4H2hF26SSlwgo6KoGsk+Sc8yY+3Va3a+f3sdYAJkyYcOyd
+ d9+7xPWt/oi8foPnEY5FbpszZ873Dvr5OvuvOQAAkm3Je7TWiS8IPA0bJYyBj/zpgSXHHHvs4H913LcW
+ LOgx46OPSr7u/2Ss7Ly3Z859NZtuOdAQgs6RMioNQaUdJgS0WZplpqRea8IYfLx2E0Nch2kTTmTq9kaG
+ 3LyYpSskR/XP8rPxfdndHkYKF7m3iUt+EOKInhG2tQpG/HY3S2e7YCYQA8Yy77Z5NC1uCAQ2NHgqydiK
+ ztxa08qLUQNDaqQQ1NbXMurIw7nx+h+TSmXQHmjlo5SHUi4qr/y1PzTI+hnOOHkEi97+JU/cdwW5VAIn
+ k+KEUQfxycdT+XDBx5z3o2EMMlZSNbwEv0cxiQZJYs2nqBEnoLpUEa+SnHTaOP740J/Ztnkd11x6Ol6q
+ hWOGDuC6m65j5dKrOe3oHmRcF5/goFFf2f8i36oshEk61calF57CT684nUdfeZ9QyEQKRV00ziRDkDHC
+ DIuGMTQUIShWEV6adDNtqWNRhsmC+UUcceYnbGsxCYsUP/v1GPSSjUSK48hSi6HFNtdd0410hwjX3rqW
+ idM3M7x/R/563Xj2zljFlu0+2yNx7hUe7TZIT5EwJdfFu3O5WUG5svGlIBKO8+gjT/553Lgf/PlfXWf/
+ zIYMO/qKt2bMmuX6VqneT8IAgFrc1lg/+fuY85vYfxQJ+HUWipXdYdvm7ULsT08E9NPaz+aOGDH8px/O
+ nv3ENx1ryhtvlP365lun7t62a7RhSXfEsMN/+vHC+X/D9BuNFt6OFboDpTHNMLZlcZwwKRQhXko34eER
+ MyyuDHciWlONi4MExncqoeCkAZz113lsa83wwOguXHR+H+rXN9KtKof0I6QKfbLDxjDq7FfYtieJ7+RY
+ 9cYoxL4Yy675EFNaIDS+9vlBRYwnk3CfMALufukFO1tDMptm8jXncvCkH3PNVT9mxYq1hMLRAOIsg/sU
+ 1OElwlBoL8uGpX+ktKQDCz+uoc8hB9OlZ/+A+FMIENtRre/QPn8+3spWViyoRrblqBw5kMioU6g86myi
+ HQ5Ee2nARUjw0m1Y0WL8xKt88MqbnHnDp0QiMbT8Qk0NIb5EH3ieR3GxybPPPEpJ3XbGXng7VmEhEBzu
+ QvtktUWPtMF7haVsSDawN6fI4pIFrN7FTJp5P1V9f4gfjeKlXV6aPIHTD92L/flWRGmUJs/EK+tI7UbB
+ j25bwtZEhocuGsvxxRE2PfIJtcpkr9S8EhZUW5Ks52BoSREmh4Si7FU+9cLFBXwCAJGbbbkil8t9Z0i/
+ 3/zmj8VPPffI8w0NTaeZ4QhCf/nMFSjPcbJHuOm2Fd/VfN/W/iuSgF813w2vCNniEoSOfUWTDZDmti1b
+ Th4w4OCq1159+f0pU6Z8rZDmV23NmvX39m6qm3hzaRmLXGns2FN97FMvvvXCW9P+ktj/nuLiws+zaf9U
+ 05AdBAJHKnZ6PnvQOFphAPF4AWs8RZuXogsRqnWWQ3IhQlt3cPXFR7N9XzN/WFVHzdYsZ48sR/rtYApa
+ duao6NzAhVcfz+aV9Zxy5lEcN+IwZk58gTJVgI1Js/A4uiTKQj/ML5SHbQWlLvKClBqFYVqsWriUC0JN
+ /OyFV6jqWMJH8+eTdXykNL6Av4qAv572bJZYuIDRow+i+0Fxist7gjBRyRr2Tn+cdb+6i/r73qFzs8Pz
+ HzXToTxKfSJHzdIk6dc+YOfzj7B96jO07tlAuLwDBVW9MQwH5czDih/K1Lc2MH/pJgwrDwISXz5HpBCk
+ UknO/uHRvPXmm8RXzuaKy++gPlqMFBo//3sqLTCEpsm2WJbJcnVROY2ZFpQ2SCJoaE7jhnz6jhjE8s/X
+ 88qzJ3Hy8GZYuQVTR6EohMxIXnzf55zfL8G3DGb/8mJ67mlg8+sbaXVMWgzFUsvic1MSM4NDSSPISc0u
+ 4ZIQCiXy6seIlPKcc7KZ5Evf1Vq+5IqfjHjxhafmtSVSR5hWQLAi8uzRIBBKPZhNNr/4Xc33r9h/3QEA
+ 2Zxh2o7W8kSBzKdmA7FL07RpbKg7/J23Z50xYcLZC1atWt7wz0YqKetw2wnQ9eeiifVuAcsdx+zao/uM
+ pYvm7dj/nnQ67XTuVPFqLudXOY5zsG2EhCfBxUdIiRIay7bIugl2aQctLA7yLVpIcbzXAWfZVk4dfQBh
+ GeHhDfv4ZH2CUw7sgCn8IPmVayOqU5x+Xj9GjhvDjBMeIN5q4gDNhscw00PFizkvkcKP2F8023z5VA1E
+ zZqkSXbbVgZtfJeRN9zJpVdewrZVS1i3bV8epy4Aie+nuf7qifz056cSihlIu5i2Tz9g6203s+W6u2h4
+ Ywll6XZiVV24u9pjZUJwTJWkrrWdA48+gDs3tFIctjnIcTCXr2bnM8+x4Z3XoTRGhwETcJ3VjBw1hEz9
+ PpYs3YQwQ18cANrTmEaW556/m1tuuZU9T93Bsz97jOmiGDuA1H2lQqARSAyh2GF5bE1luK4gwqZMjjQG
+ WcNi9aLlXHL7udz2uyPoV7wUZ+kmwiVloAWN7Tbn/343f5qzm76VhXx49xXse+wtOjWXsb21DtdzaDYj
+ TDE8QlZwMGEIfB3Qq0spkULgOTmEYK30/eNSyeaPv4sVrLU21q3bdvv0N6c95/qiWBiBClFcSZz9IC1N
+ dTrhnguZ/6jWwH9VDmC/ZVKtj/m+Wqs1+GgKhKTAV6AMLCtMJpsdMP2tqZ+dcMIpV/yzcYoKKmdNqU3y
+ P34Zs70Qtiz5bMIJRy//3++rrq5uSSTqLxw2ZMQQL+dMRSlXCYUWClNK0pk0WghMO8QK28cTgkZf0qJd
+ Yl6I6W9u5KikxemxAubtzXLrjD1Y3YopOlARCVu42xoRRpTP75mOu8snLSx8YdJBuXQu7cKFzQm8WIiQ
+ /tuS85extCRkGTzbrFi9uJpNpx1LQSTKqzNncOcvz8FNtZHLZigtjvDZ0re4+54LKY77+AmTJefdwKqR
+ N2O8vhYhY2wtLeXubIRRK1t4brcmXmRQX9eCZ8Qwogq/soBbanx+sENxX0uEJrOYLlt2svlHP+WFY44k
+ 1dATZXTnzod/y+dLXuKAjiGy2QzpVJqxI3uyYtVsTjvzONbffSNbH/wrk/0YISsosKmAfBAlFGI/Dxma
+ MPCO6fKKq+kfsUlLMBSEZAG/v/h+zFB3kp9tJN6zJ8LWZGI2o2/ZzsztaboXxHnokIHcctNjbKzJYbk5
+ pOdRLENMx0WEBb4O5rMICFCFkCjHxxa+P3jggLv79u4+pL296TvR/Vu+fG3/UaOOWzj9rWm/FcI2EaBc
+ n35aBepN+900N3clNCf+zwG/Z/sv9AAAUKFI8XatvElC+mSVYJhdQMrJkjSCU0sIw9q0eeMpPXv26nfH
+ Hf8zb9as6Zn/Pcgniz5cOvnFhbVv1DszM6b8o5fZctuUKVP+Ydfhrt1bal039VdDWM9Ky8hoxOFSiLyk
+ ddD84kiDnIZ+PvTFoElJNpJmd1uKsAumEWZjQxtDstDtqCK0zuBLQa7yaBZe8TpShggpcIXDiFiM29KK
+ hWELa3/GPs+lbwgdwG/z6rQCkIbkoxaPa2MOW99+lbLTzuGoH5zAGeOHoHSWF16aTJcuGYSMUP/RKpaM
+ u4bwqlqMohBTjCh3ZRVTM4qNmGCGKbMEAyIuGDa7RJS49CmtKGLhlnZEOMx6oZiRkuxQgkG2xQF1rXz0
+ /JOEunehcsAplFYkuPSyyygvDPGTn5zDzbeeT6Qozob7H0b86U0ezBlsMoIsu8BEiwC/oMRXgUWBZyAN
+ g0VuiqsixTjZJG3aRqORKUWyuYZDzh+MSO1CxDN89onFzPkJEr7L1ZFOfLJhB56rafcdjunSg6bWBpYh
+ eTci9mP5MQm8KQ9wchn6HnjAoisunHTqlJdefKWmpub/G+yjtZbFxR1+8dMbrn1567adPS07gkbgulku
+ 7tqR3Ykk9ZbEDPAZr6TaG/+OyPQ/Yf91ScCvWjhcPMe0zeMRAuUo7uxYxYtN+1iHT0ibCASecrAss3b0
+ 2OMueuuN12d/l/MXFnbtJaX3ijKNoVaeS88XEPMEF7RrTkbh+hlsaVCnXBoNl1eU5pcnH0jrnNX0H9OR
+ AZcXogcexXvXr6Jp9nYsDBCSkMhBvIyL3RQ6YiD1/jg++ElMqRAi0PzTWuP7CqV80j7cUi652kiytUNX
+ Dp87HyvahpA+yvHQVgnbX3qWrZfcQZ9YIfOl4K6spM7U2Hnp8KBByaDchiNiWf4w/Rm8VBO3TLiBEUf2
+ 4Z7Z1SRcEdT+pcTRmpAnODOkmWQkqG/L0vGmCxlz16PgzwXZBc/biSEHsegPfyZ3/9NUlxZxXaMmbBlB
+ w5DSefffx1aSLEEsrGV+7ymJi+bEnMezZpQXkg5pEcJE0aZauGDWJLr3nMO69+P86XfV3H/BIM56fQOD
+ WuJc4MTpSpblXjMH9D6QxI5qfm+ZzA8rTD8YX0pJNp2hqrJk3yGD+t487Z2Zf/mu1smuXbsG/OrW26dM
+ m/rGYYYVwhASJSRetpU/DTuYGeureT/nYUjQUjS0u5kBJJP/NHz9d9l/ZQiw30pKiq7L5XI5AShLcM/u
+ fTza9UBOLS4h5wWIMyENXE93nDljxqxhw4985qN/UO77pqa1lnrePBMgkdi9rbW1ZnjEVRe7jtu6v/Le
+ bmr2Rkx8naFI2vwVg1/JMLcYMfoMiXPc+CTDxnZk+/sNLLivlmQyQmrOekwCTT6tHQ4rKOCJTBoZMrGU
+ +BKtG3wKTElAOib0l6e0EEQNzeM1bbTGS+iydTPbTxmJW+fg+iGk1Zddb7zBxkvuoHdpMY9qg5+mJY0h
+ m5CUCBVsBkFQYIgVWDww+w269O5P98NG8vPHbmXWun1UVgaEoCJoMsYSAj/k8boruKY9hltQjPPAC8y9
+ /mIwhqKz88CLsPn5l8ncPZlYWQH3NWos0+R/owMsLTmoMJb/ll+aAGwEcwyPz0zJaFtSqRRF2qQLBbz1
+ k6m0eSdwz8+38PuzuqGtPTx+QRcmp/ZwjLuZU5x6/urnqE2m2WsarDIElg7ITRCg/LQz5shBt9113929
+ v6vNr7W2//jwn393/LgTVr4x7c3DbDuKwERpA8NtY+YPR7Jm0w5mZRWmCPAaytfX/7dsfvg3eQC33Xbb
+ SFlevuqO66//1jFPSVnFXZl07leGaeFr6JRNM2vYEKYWO9w5ezXKLsCSPhqJ5zmYhjErlWod///zebXW
+ Qoi/3ZK9qno91pjNXIUh8IXgEN9kcnuW1UJzkdQQkoRyGdbefgClmWrUXpNP5qQYfttRfHTnMtp3G0jA
+ kpIyM0dztIwLVRbLyjNc7e8czOP+Qvm/K6HQSuFpgZ+XCMv5PuOKLK4yBSO9Jmq6mpRMeZWW6jTrz/wR
+ vUvL+UWbw1wtCefLdCpfVhVCgFL07VHKzPfepqw4iiYNhBFWhurlC7joovtZujWBtg2QAkProBqhFa6W
+ CF9xZdTjsGSSDr++lGNv/Rk7nrqV+LqVvPRyA594MWZ5HrZhsF/YcP/3EkoSkpKM8gL1pP0YBhGAm1yp
+ 6J/K8WFxdz6tbaNRWtSKLG1+G6c+PRJj1SZ6GoI0WYoqBDdOzfLkeh/bFJTlDD4o6sbDJHjWTxOSQS9C
+ znEYPfzQD2e+/8HXKzT9C/bya68d/+KUFx5/f+68XnYo9oXn5nkOA7taPP/jE3nhgZk80QpeWGL7IKR+
+ p6Wl4dR/dc7evXuHtm79bgVK/y0ewKBBg7a8+sTkW/6Va8847ZR7LdPaJaXElFAdiXH14lWcJA2W3H46
+ A+KajBdkl03TQmOeaIeLb/3/+bz5zW+ECwpGRGKRO0uKi2Y35RKXkkeNGVqzS2coKC1mtvQwLImhfM7o
+ H6V0TwMtH7s0bHMYeGYVDVsbSOx2yeKTExqh0vQvKuXeTCuWYSG+gqDzgVzOIeu4ZLRPTitcofHyXUD7
+ W3xtafBem8fvs0nE0SG6PHYjTbv2oHbNo9fQTtyW9PhAmEQN9WXJiSAGVp7HgH5dmPP+fEqKw8GsUqIN
+ F+1Juh18NM+/8gix2P5eQ48gY08QS+e5CB/OhJmOSddF77Lit9dSWZQgflQR/sldeSebwpQAGq0CaSWl
+ NVprPO3RqnKkfQ83m8VH/40nYPoGa0yTJxItdLU0aXwyyicmQix8cgW9Lx1JqrqWaEbTvKaZqwdYRHEx
+ hUG78HDiHViWzWFKgVYBhsS2LBYuXj22tKhqc4fyyqn9+x90Of9i/mvZsmXdzjn3nGk/vuLqOQvmL+4V
+ CgfejNKQTie54pTuzJtyLa/fN4MpzQptguWDFro5l0td+a/MCUA43LV7z56X/MvX/wP7txwAZ599dq1W
+ 6oDi4uJR3/baZ599tr1Pn55X5rJJpJCEBCyOh3n43Q3Ur97Lp385nbuPLcd0UmhPIoTGMo07o/GSRwh+
+ 5L/BXX1TM8zwau2ai5HxW10dHecraes84k0iaNaSd6JxFngWUkLOy3DRoWXougyGZSKkQ/nE/qx/YTMO
+ EQyCWL6LaTI3DRvDUSQ+aANfAEozrjXJp0WCx8Igc16A9ddBeU9LgZYCpA/CAkfx25v7Y/38MES/81l0
+ 84MsvelFSi84El0ssbQE7IDJBxNTS3wnx6hjDmf27LnE4wrw8UyN9iV+yz4Ehfjapku/Xnw492U6FkXQ
+ ORehgvo1WqKFQEiBVGmGHV7MDg+23LuIpHUAskxx+Q8PoFi6gcgnKog19psGJSHne1wc8ljXpwNnZx3C
+ aj+Vl8TQEDZNHlEpCiJRTKUp1DYhbZL+rJ20aSAr4uiUg+mE6RnPcnKVhaM1aUOxAIc9SucdiiAWV0Ii
+ QxauIfpkHDlh567myQUFHR/+Nuvh9ddfj5911jl3nnHm2ZvffHPmmUpZSGmD8HBchwFdLBZNn8Tdt4zi
+ mVMeYG5LhHbLCuQc0fjauzmdTtd823UIgdBJRUHRa+dNnPidsxH923IAo0cd/3Qmk3nx4INHfK3A5j+z
+ 5cs/m92xsvJZz3MxhMCQgvl2nA+mreGDJ9fz8xuGsfJ/xjK8sybrOGhASuPaeFH5onhx+dGA1lqLrxMN
+ +UcWi4ab5RfYepes6+EqhVIKX2ssafKbljraIgJTG/SImowo99B5QWndtYjWHS4tdaBxAqJKFD0LC5ns
+ JTHNwL32paLYlQxPJnkobtGvzOWCrg53mBql1BddeEIKfF9RVRYjakrKSwSjRndHDrqT9c88Q9fqPSyT
+ Me57YBH3TjgML5cNHktIfK1pTyf48RWTmP7GdCIhE6REWnFaPp3HxyeexCdHTaTu3TeRRgyhixgw6FBW
+ rFjKhRNPJJNpw3FcVHAjcX3FVX0KOH5AFb/4oIFu2Mz9xXTM/gMp6GRz2Zm9yGWzdKuIUxiPBnX3/Auh
+ OdN3eWxoMd27tfCnviX8rN3jOM8mpPZzDEkaQiav6Sz9I3a+hGdQJEw2vraJ6KhSzFiOaIVEuRl+PKII
+ z3WxTIsHmrbQbgelNoUgk8mSzWbzbEkBvNq2bIQQA77JOli2bJn1g/Hjr7v+pz/b/s47M25ta02GDDNQ
+ hvN8cLJpbr7kYD5+4zgOyiV5YsyLLG2xWW86CBl46wpmJdtanv7mK/5LW7t2rX3ppZe8VVhUtPrSSy/9
+ znMH/7YD4Kabrvk4Fi8K7d6zbephhx1mfdvrb7vt1p8bhqxV+aJSja1YasdY9OZKZjy8ie5dbd6/ZwRT
+ rhxMiZnDczRgDDOQC4uKOy4pLqs6Swgh/9khoOfpL+S+BvYf8o7jpXF9n0OrCjmrYwknHlhJzPNJpZJk
+ PHClxDMkGd9jwsHlmG1tZJXG0TmKzxrNhhfXYBDGwsCV0MvQLPTh84gFeGihkUATLv2NMJ3iAookRAvw
+ jXzff75W7vuaYw4uZ/ni61i79BcsmHURovMAnLRJzQOTqbXCvJz0eXFrE+VdY4ztW0o6k8H02jlySFfe
+ m/UCf/jD/SiyCMumefkSPj5tHGuO/zFF6+sobE6x8pzrWTD2ODI7NqNlmKLiOI8/+xzrln/ITy45gS5V
+ EaSfpHMh/OoPJ3LrrB1sEJppuNg7Uyx8vBZRqPnFvccy/aX7WLTsTY49rJKc+rJF2MQghYUfKkNYpQgr
+ ghsOs1ZpcoYAI+AdtAyL590cfYo7EtVpTCQhHWLnyxuxBvfGD7sQU5ixMEd0y9DbUghpUG+4uEKQzOXo
+ U+DwzIShvDHyIH4ctinP+mgUnu8QCql/+jRdtmyZNenCy64497wfbfvwg48eTqbdCjMUBaXxfUkum+Dk
+ I8tY9tb53HFtN1IrEzx94aleMaQAACAASURBVNtsaY/zVljhWgIIIYRs9h112bdd7wDz5s0zTz311Neb
+ WxLHDTtixDeGwH8b+7eWAQ88sO/ze/c1Xmha5l/aWup+9G2vHzX2+LMWfbzor+FIAWhJFjgza9PZaWHk
+ UT049YKuSFppj3Xmgbd28vCMDfhmGNPIx7+oHaCfTGTaXyab/ae0S8uWLYuOHfuDRb6Sh6J8Lo1FGdev
+ nJFjerI2mWLuijamrK6h0XdJZ1IsufIgDq1dR1LESKUzFP/hQt4+dDI6U4BC4ZFlfFEpZzk51sRCSKEg
+ Xx7zfIXvZPmlFWOwcNmuXB7yQ7RFBCqPA8hksjx84zAuvuFghFmBsg9BeT5bH3+ZxL1T+U1aM0+aKN/i
+ oSNjXP3ABdQagyjq2ItQSXeUB0JE0Jk2Pr9yEs70xZTFbJrtMHM8SUnIZLjvIFI56owc/e66kb5X/yrw
+ QkQCldmN4Tqk3Sx2QY737n2SM+5agGUKolryZChMwsgwcc2VhMp6Y1hV1KxdQvOODhxxzm+JRkN5sg2F
+ 9iyOdDUV2mWT8qiO2HhWoOSjtcbXCokipeBdoxOhRDPrXQ2kcWnn9LmnUfDJu9jtBsIxEAb8bqHJ/esl
+ hhGid5ngnjMHM9oSLH3lcz6pTfAeYZaHJFIKfM9bOvTwAUctWLDg7+Dkjz76aPz1qa9fsXP73htr62o7
+ W6EYUkqCBjXIZdo5YUQn7v3ZMPqXeniikdSmQiZf8z65bIwplqI2qoOyrpC4OBdmW5tf+LZr/fXXXzfu
+ uuuu1zZv2TEhFg3Pb2ysH/Ntx/gm9m89AC6++PJRL7/yyvxwuAAl/EfbW+qv/bZjHHBAn6dr6xsvtUw7
+ 31QCP8rFsNxWBh5UwkXXDMJI7kN2L2VHugPX/HEec7a0EwlFENLPx8T4BuIzIVikDL0Y31nS3Nz8dwos
+ p512YfG77039wAiFhxiexbUVhfRuq6F7maZ3eSXjN2fYh6TCTLLhvEqc7bWIgghNcRNv7HHMOed1CkQI
+ JQRhXDrGyjnBSBEyvtQV1Tpo51NC4aGJYWEYEu1rfKnx89lloT3KIiY/OryIm84qRp5wMzocZ8XIs2mo
+ g3Prc7gxC4lBF+2w+ucdMTqHsPqdAF2ORJUMwEm5fHTsqcR21BKRgpkywp8zHi34aC2pBK6ORTjKSJNK
+ t1MwegBDnnqaUFU5qXVv4G1YQqTYxVcug8+aR7WIYigfRyl+WRhnnN9G2YPH0ve0vuglaxlz3Vo+35Ug
+ FI4jZJDlFwTEpVIYWNL4oovRESJIFBKIlILGFYIzcor7jTLebmsDcpgk6HzBIEad6CI/3YrrGNiez9pM
+ B4b/tRFhhLntrCM5K93K5++sos6M86xIswETE7BMe+fAg/oe/emnH/7N792nT59+pmlf1tjUell7e7Iw
+ HI6hAR8f5Zs4mTbGHtaB315zDCN6aXQqBWHBvqVwzy2ziTklLIg6bLB0IK8mNEr5b7Unmk//tmtcay0P
+ HXzYy1u2bJ3oA506dTp5x5aN737bcb6J/VuRgCtXLq/uWNVxguvqDkrrIwqKSkoyqcS30gj85X33LFj0
+ wftno2UJaDwp2SkVA2WY6rp2Ni6r55CDe2I17aNEJzjv9D4c1buKHdXN7GpIoDEwpCmloIuQHCmQE5HW
+ T8PR+EWWFR5qmVbCdXM7ADZtWpUd0H/wzMbGpklYIra4PUesqITuyuKtuhzzlImP4swuIcYXJGhN+MRN
+ UMf2Z/F7O3FWpzCBZuFydCjMM8pkla3/Pu7Kw0MtJL7Q+EoFW0Xup9YKuHeTOUV7Osm5PVz0ISPJ7KtD
+ vPwWr7fAEgxsBFIbNGd9BnUoYKDYDi3r8JMbkKKaTybdBlvr8W3Jy57FI1mXbFgiTYktfdqlxfvZHK1S
+ MTImsPbWs3vqK0hzIea6xcSb92JmMrw0pZq/bFdYUgWEH1JiKJcJBVEyYY+Ow2yM2hyr9kVZsT2BYezv
+ bdhPURqAqgTgofHykb/Og4UCvEXw3mrlc1VBGTXttWQJQEWp+jYGXXgYavkmpGkjPEVlSDFtgyZhh/lo
+ zQ72bmyhTZq8IhU7TRMDQTQU3nrm8UeNnjF7xh6AcDjcNRoqvDASiT6cTufuaW1pH4EQIdMMBQlLBdlM
+ juEDo7z4hxO5ZWIfujjN6H0ZdCbLztkp7rhrLtIvZq9lsizkIYRGBgiqet9Lj3ddN/Xt9sjK2PHjxr2z
+ Y8fu02w7AkKuqd9XfeO3GePb2L8bCKQ7d+7ybCabQgqLTNq/vryy12P/92Vf2i+vvLKtZ9/eE7K5dFoL
+ gYGixfBYjEFUhthW73LHA5/S2NId1ZqFDZsYW7iHuXcfzOePnsB1x1RQptO0Z7JkfRm01CpfGlr1CJnG
+ +XY4PLektMOGsoqOV0WjxYesWbO0duDA/rOV62NZktfakkxqzPFwDnwtcByH4zqF8epSWK4g3ZbF7NKH
+ TXN3IIVJVhj0idhUdD+QGTqDFASY+L+7MxKlRZBpzzP+oIInZpAak2jDJG4HUtpWqCMNCxcSj0f4JOth
+ SCPPC6Cx7BDPLWkBGcFvTyGrKmj6eC2R9c1E7RArfIunPB87bBGWBrYWGDKESZaoLXnHFbyUjeJJm3g2
+ TYeIT2FVKVoJaDJ5cmEDdsgEaSKEgSEM1js+6ViExoV7wNRgewzpUYzvZ//ma6r891cSHK1wNPgIPKXw
+ 863Cev/70LRaghdxGNClMxgSJRWZmgStXg88rTG0g7A10k8xpqPAUTbYMWZEbZ6LhamJhJCGge/kOHbc
+ 8U99vGLjKKug5M/RgsrVZqhwlzKtRzwphwsFwjRwfUEmk8LNtvGDITEWvHoW8547hSOjKfTWvejqNkgo
+ Nr+X5NZHP8ZQFVgyzDIjSy7AG6MF+Fpenkql6r/V2r7nnpIfjD9t3q7ddeNsO4oK0OHfK0novx0K/Npr
+ r5VecumVuwwrHgeN1grDNKZ26lB4/vr1651vOk55x+7j29vappmWHUYDnuZYCuicTdEsLCIyye2Xj6Rb
+ hxqk14yrk1hFMXT/nnixzny8qpWX3t3KwrUN7Gt10cLDMEMYlo1hAErjKQ+lZYvnUCQtU+4njlNqf03e
+ wMwmWXtcjC7t7aR1mKaUQ/Kay/jV5Y9jWAZJHac1pPCVZItUiHwLrdRfDz/XX7SLBhgaJTW+7+O5QTPJ
+ 6N4mr020KfjpO3x40hg6p8IctTpFNhS400agUQRulu3XFVEk65DnnoG7O8WuaxeS8wu5uDbJ9njkCwxC
+ yLLp27GQHU1ttLSnEVpiei7PFHr07Zqj6/m9CI84Bj1vPjv3xBg6eScqav+N6lAmk+WFXkX0FgkGvzce
+ c/M+5m7syPjr38G2o1iWgZQGSPUlvagK6M2E/PtluF99SAG+49I7EiObdYl6PuXCZczZR3Btzz2IXY1o
+ 38NvzfJpMsIpn1qEQla+X0QgDPB8H6khk0qgTRtLBgSrSvsoLVBeDq1dItJk1JAyzjy5F6f+oDelIR+9
+ rRaxJ4HKhRC+D6EIn8/axx9mrsOUxXTSBotsyfqo+0W92ff9ye2Jhm9V8z/ooCFVDQ21cx1fDTBNM1h/
+ nre7skNBn+8a/PNVM//vt3y3NnHixOa+fftP372veZJpmkhDopQ6a199a9d4x46nJGtrv1Gpo7F218xI
+ YdlIlH4PTRkGvE+CiXaUgpxDSke5/sn3uW3iOIb01Zi+QDX7iI83syaUYdgxHRg7fgh+wmB3XZR1uzxW
+ r9/B55vr2bilkR11bQg7hsYokVYeBKyD0z0A1QUw2UgIHtns8kmDRZMnaVUW2aufJhONIaT8IuYVho9B
+ /vEng+vJ94f7WgdlNu0Ep4sOsuDFpUV06lTGgAF96N6tB6FwjGz1ErzkxygvQ5Hj8nnSJCEhrIODJUga
+ ahytWd5sMzbu4bdnMSrCFA6MsHOrYI8dypOH5A8jy6LdydG5oohURuH5HhkktaZkeLEgXZcg2rUnKvoR
+ izakyJoQgi8aepQQSMtkrSvobynSyRIKRD0RkeRXv7wWrTW7du2mrq6O5roWGpqaaUq04jhennQUMG3M
+ PI4+CBHUFy9pmmxxHBASbZn4wmb+q8u4V0iE4RH1JcW2Rf8iTZE0yGiFnycjRUiQ4PsaO1qA0hon3U6R
+ dOlREeLArkUccVA3ho7qzuCRHYlVlUCygcTWJravT9OzMYPXZGKaLsQtPvnLdh5cUo0lSqnUmu2Wz4aw
+ A1j5znW1wzS8X3ybPVFZWdljb92+uVIavaRhoHTAUqqE/9D3ufnhP3AAAIwde8Ljzzz3zCTTLPjiiaeU
+ Hma6Ykm8tPTkZHPz+m8yTibRtCwWqxyt8RdIRKkQkjlGjrPNCJ6XJEcxt7+ykMuH9+KM0RWI0gZEyODN
+ F7by2L3LGX9YOWeMP4iDDy3isEGa4SMG4YqOJNNR5ry9il8/NYOMq/LNM8HT/6vkF2hNk4jyx1oDJQOU
+ nLAUlgphCTfvLWh83wPl4YlAuE8BhoZ4LEZVZREH9u3HwYMO4cB+famqKqOyspLyigpKyyowhIsWDlpH
+ Atc4tZWGaw8j5jdTWSmZuSOJ9k20IQIV33wErWWMJZtcjhsSRtXU4Q8eTuEASWEqgrM7g/gKH56vFPUZ
+ AyPrIywTlI8vNbJAUdotQmvWQ5TGMUIhZmzcBSEToQNUYqAKJPBdl49a2riku4HcI3CcHIWVA/jNFRcg
+ KUTrKFIYYFhoJWlvTdDS3MTemr3s3VvHug1rWb1yOduq69i7p4629jRo9ZX7bQAhDMMIUH7hYnIKfKFo
+ N6Ded9jULLGkh1RBI5NWwf0I9lOQV9G+4rYJhzNxTAcKKxSRqI+fayeTbuPTGftY+Gkj8z5pYHl1koqo
+ wYabhmErF9w48yav4c+bGvGMUgqETythFtgplAiOQh/VJgx3fKKppe2b7oWSksoBWV/OkVJ20l+ApgQC
+ 3ZBq09+LBuFX7T/WDdi12wFLWxLpoVKY+YdrfqP5Oiml+lFbU/30bzpWJNJ5mGm6HyJE1EUy3JccmZZs
+ 1x4ZaVBPlvM7FHDpCSVYXevAKuT2yXu4Z6/O+9k634IbyGspKTANCzMcBREw8Upt5JuP8p4AMkjWaY1y
+ HcAFHLQviUQsqipKqagoonNVGRVlZXTt2IlOXbpQUVZBVWU5lZ0qKetYTiRu4zu1CKcZYRahvTTaa0bL
+ GJDDUCmc9q1YhX3RqhZhSpIfz8MYeBRq3ntsb+3EvPosny5dzYyFG5FmHITEk5oRJYJZQwT+UTbha28n
+ +/RdZDcUM/C5atLRQLNAyIAcwzQC3n3XzQbAp2yWyUdaXHAkpMs7Eb/qMvbc8CBHTW6gMVqEKRykMMhl
+ spx4VB+u/elptLe10nXxAiqO6EaHE89GFndH6wS+m+T/MXfecXZV5fr/rrL3PmXOmZJMek8IxISWUAIB
+ 6aCgUpSiCF4EBRVE/NnAQrOBIpaLBREponRCJwQSISGhpJAAgYSE9DaZTD1tl7XW7499JgEFL1evwsvn
+ wCcw7LP3nrXe9ZbnfR5ps0iVAVPGWQXCR4gAIQOEyiNkC8gcKJ+wUmLT5q1sbWujs7ODzq4OtrVvYc2a
+ NazdsoVNmzvZsraTtvYS1dCBjEDEIDIo5aOlQ0ovnZCsb82+Ypd1jrhWwSQJwkl8WQc3JeC0AguDMgnf
+ PHQAn9tNE/iO2roCjz+wgVtLJUKVpQlNXnvcp6vUtKqrJmsXieS4SueWR9/tum3sN/AwZ/V0hyjiEnYI
+ nEqBTcx3Sl1b/u1Mwe+ZA5g67fCzFy184QY/yO0YCxUiTbOtNXhK/Khze9u3eevQ2DtaPj/wFKXsHSlV
+ tuGTUQsy6qXTeXRLi3Sag7wKZx3SjwGDumFzxK/WO773ekxVB0hP7qg8CykQKJwUWByJNVgTowTklU9r
+ zjGw1WPYqOE0DxnOyBFDGT5iDEOHDmHosDyDBmbJF3LgJMZIBAFIC64bl1RxroQxJbzEksSbUEkNRIDK
+ DcCZ+knlApSXx6Eh24iLuxHKEkcVPJkj6tiIHnooykU4l2rYvfTcS3z05AvZUhL4xJAkLNt3AOWuDYyb
+ 9wPs8tnoJV1MvXg5y+Nsyj4kXUoXLlMZdWMi4sRQqda476QiH55Uxk47EjVhEtft/iO+W/JxWmAM9C8o
+ brnxGg46+uSUgBiwMsDFW9C6Nd2UrgpEIAzO1SBuB1dBuCouKuNsKf0ZEYPLYcmjpA8qixMCRwGEh/My
+ SBlgXIhyVRQd9HZ3s31bL5s2xyxbvYZXX17PmvVtrGvvoLe7Qk9Pja6uiFrkkA4CP0gXk03xBliHxeCc
+ wdkCmA7O26eByw8u0hTXEEE/1s6NeXr+ep4yghUZRf9YMtwrcI/ooawdRiqEdFjL18rdbe+6YFdobDlL
+ isz1FqEdFqijPqUE4Tp6t1fGQfe/XSTkPXMAs2fPbjj+xFNXOeQOaLBzDlGfHrPWYJ19enTz4FOXrV22
+ 5d1cs1js/z0h1eU40BZOiHMkoaFDJpSFptnBgaaHQ8dk2HPfLMJV2JTvxxXPdvGH13vwgxwqTUGp047Q
+ IBy7BYojCxmObwoYXkzIDWsmHD+IeNQETMMwRDaLyWeRWYnKWnRW4zUU0b6P8qqpY5M5UA4nHE6U0vBZ
+ tAB50nqCQtCNI4MgwBEgSEVFHALhfFxdcivtCYRY6tJjziJECFRZv2ojJx3/BZat6SC2lt9OaObALdtQ
+ PzqRcSePwi2exaU/7eHnT2wnyOj0fUuR6giQFj6dsVTLZZZeMorxLW24Ez/Juge28KOLHuN2D4R1HLF7
+ K7+7/WqaGxpx2kOIAkJk0/cm0nvG1nv/QiBlnNZOvPR7EEk98gtx9NRHjyMEPQiqOBviXFKXVzM4kaQp
+ hBVIG+CSABs7TKSIKz5JTwI9FXSo8IVEixKip43SynWsXN7FHxa9wZ1ruumJYwQOZ9IhJ+cgiqtMHpbh
+ dyeNZO/mbhAJtnMA8+7dzPI1Mc87x7KMoTERjNcNPKoqbNR9pCYCIdxNPZ1bznq3a7+xsd8VVvjfxaUU
+ ZZBGU0KIPod8Zff2zd97t9f7V+w9JQTZc+99L1++/PXveX4G5xyFQoHe7g5EnbjCOYdMkq2t/QZ8ctXa
+ 5e9KrKHYOHC6QBwPUDCS45MiHWGJLk+QCI+WKGGaq7JvwTDpQ0PJZbYhxg9i3haPs29byapQ4vkaadNC
+ lHWW2CT4Jqa/kwwzMMbzGaEko4jJaigDvWFCLQqJERip8aRFZRTCk0ip8IVA6VQvT0qBryTa99FZH601
+ Sgp8wMtIMr4ml9H4GYUVjsjUi4U2na6ziaEritBO4DtDbCzbw5ienoRylPCazjJ9e4RBsLdX455Wj6c9
+ xYkLr0S8fieL5uc48AtPk2vIIoVMKepdH9rNYB30lxVeu3Q4crCHO/xUHpn8Y2ZvynJzpkQLHmc2Sz7o
+ 92DihN4IKglYIwmNI0kcmQRMfQoQqUi0RGiN73uplDoCqSSeEEjpsFKSIImFpeagLBUWCF06E2EtxLHB
+ Jgk2svhRTEOckE9ifKto8DP4AmJr2KIkm9CsNhErTMA66agqH53xcU4gjCO2hiSqML7V52sfGsOn9mjA
+ K29Fi4Bt82o8OmMNxuR5TkhWZgzEgg94LSzUIS/TCzIVaFVOLu7q2jgN+DtGqrexoLFx0M0Ieaol/X2O
+ G1Zgr13HcdfMBXi+BkGPDXvHlkql9n9qU/0v7T11ALfddlv/c8/74iqhM0XnLIFWnH/eqVx9zY3oIFsf
+ 4FCEYdU2FgtfbW/b+D9OcDU2NjZbm10opRttcIy0WY4KC6w13VS9AGENo+Mak52lqrqYMm0s+02UkO0l
+ LI7i+hc6uH5+GyvKMUJJlEo55IRNR44tYIzB2SrWGhqUY6DUjNE+u2gYJj1akgSFRJsYmThq1qTDPCJA
+ YJAinY43CoQTWJdW/iUCadJ81bMC6SB2hkhYlJVEzqDIEImQhtYCr7S1k23IcExjjoYGRVs15qkK3BsL
+ tsk6tDau8cuCprWrkwn3XsSIvdbjVgkmfGI27bHE1Tny+sw5R5RYTp8i+e2ZGdykPdm4QPPC5+9neqaB
+ +RkYbOFgF3JQoyOrDXGS0BspapGiO0nfTxCmRK7WCUrS0akCmuKETB3pI+ojxg5IBDgn6yAgQVwHByWA
+ xAciAiR5KcgGWRqyChf4tPkBr0UVloeGrbFlewxdMgUXCaWQQqL7xFSVD4kljso0iQpHjWviM4eN5NBd
+ snhJJ8KzxK9a5ty1hQVbDZBlnXCs1yk79ASd5dUGxdy4hFfnM3TObRe4KV1dW9b+T+sym20ZqjP+A866
+ yUIojLEMG5znd7/4Kh878Ru4bEOdL9Be3dPR9s1/Yjv9U/aeU4LtudfkX654/Y0LlOeRGMuBewzh6p/+
+ jGNP/AzlSoQQKi3SxDEN+cytB06dct5DDz30jrx+ANliv309oZ5B4DkU+yZZJtQs67XDCEdNGibVDIeY
+ hDYRQqvPx4/flabGzagEXNDMq5sdt83ZxPWbBSVticMY3w/qvySwLkrVd0gwLgAM1iU4p2kUhqFSsYuf
+ YdfAZ1dpGeIsLcYihaqfaAlVY+hyhiixVAjoERYjBc5B4ASRM+RjRcY5EIaM1AhjWCEtu+3dzKRimT/O
+ 62Cda2CLDFgrHZ0pBW5acrAp1cdntOS4ru2IA4Zx3PQDkevKnP31ZfxlYU+qNvymzobDUS2F3PWVgXxk
+ Yi/i6NN48sDf07VOcbWM2ejlyZgqPo7A8xlMQrMOGSoDstUyw6wkMobQyD7QLz3CsF16+DbGcy4VNrVp
+ iiVc2oryqdGEIo8kqyQZrcloHyUUofLY7DlWm4hXEsdKDJsjqNi0iEm9ECeURdp0ArwPW+BEijrMKsGY
+ apULRnuccFyBxpFNOGcQeQGxYePtNZ6Ys542UyQjNJ0YVouYTukYRpbtxQKPJh1ItRM8K7DHdr6Lol+2
+ UNjfU9n7HHIwgDGWocObmPngTZx+0qdYurqW1oiELPVGveMol7f+b/bQv2LvuQP41a9u7vfNb160Qvqq
+ BSCsRfz6/EM54gtX8uHjTmXdhq1pgYr0ZJFKvrb/lANOmD37gX/I4losDr4YYX+IEFhrOSFpoSGO6HSO
+ kg+5JObQKGQYUBWC2CWMmzqYfQ7OIsMebM0iF/dw1RLDw62NXPSR/bnovnlsrUZpGG8TImuxLgbhUNSp
+ uUX9RBUW4+pgE2MInKBBeBSlpQXJECkZ5DtGkGEw0FpLR43LNmJo4uh2lkSkI62RdPjWkRGGFhnQbuHl
+ cQ1ceNEoyrNf5AP3GaoNzSgcup5z23p+ax0UrOG3JJR6yhz95NG09I+5/a6Iz/zsRbK53A6nBuCEoVYO
+ ef3qQQzasz/tq0ez8Mw/saqhkcuFrAuRiLT6IATGWqwzmMRxcWvMPrUqg3YZyVNz1tJPZsg7S9EpfE+Q
+ rUuYCWMpK0fiLE2NRZwO2CqgTfmsTSpsistsCi3rLGw0jm4MkXNI4aVRmRB1EJNAJhArAIcToIxLN79M
+ N/7ojMdBMsfAjl6akl5OGBkx7rzBOJ2FfI5obsLzM7ewsC2kJppRLiRSks0uol0YmoyHaC5yuyun4KE+
+ 5h8X/6i3s+2S/2l954tNX5LS+zlCaBzYWPCBvYfx0AN38MgVZ/H5618h62ucUAjBz3o6Nv+/f2Ib/dP2
+ nrMCP/ro9OrI0SOaurq6D0ZI0DlWLF3OmeO6OPdHf2TmzL+yZetWlPDqGGv6r1676rOjxu6yuXN724vv
+ dN0wLD2TyRaOFDBCCFhNmak00mAMEkNVA05jXUwnDqSmd0OZNxZ10lxoIu+FmJ6ESo/hum0dNNkePvuJ
+ adw9dzlaa4x1HNzczDCRJa812joil2DqlVwlQIt6nqs8pFZEGkpa06Z9ViNZ5CRPmYhHTY1HFMxWik2B
+ ZotTrNSOHjS9wqu3MiWv+xmeDQSRk4jtJfa/7FQa1DqeeSVmdUmgZaohAH16KimVV49x7OpnGROWiXEM
+ PriBXK6B39y5Gu0HO95ZylfvM7Ip5FuntiD2nMqzX36UQrvgTqtY4emdJ4agPl8PCokwEWeNUAwSNQaf
+ dgTi6TcYMmAApWIzmwLBSuXzqlK8KhSLHQihKORa+WpU4hemxp9qFaZXazwdJSxEslpKOoBEpzUUXcfz
+ q7oIihMC6wyeTWiwjpE6oD+C/Qp5upKYinPEScI3+7UydNNatinBKlvh2P2y5IfHiKSV9X/pYPqMjSwv
+ Z0jQSBLapeJ+FTFEKiKbMNbvz72iQk25OtAKcO7Zns4tZ/KPpcODYtOAG5SQl7g6B3ocRxx65BQemn43
+ 2/7yHb7xkyfp9htSMmipKkktOi2OK6V/aUP9L+09AQL9rZ31mTN/8f0fXvUlKVRRiIgVoeK+25/m44Wf
+ M2vW45x08qk8PXseykv7737g5zauXXvjiFGjj/rSd7597jfPOaf3bS7rnOd9RsTxiwLXUFWCh20Pn/Ua
+ ISmhjKHNg0LQQK+FYhLhx1VUFZY/toapH+jPIZMHM6m3nf6dNW5cvJFpRyiUMEhnMdJCZBgRJwz2fXxf
+ cmBTI9PbSqxPoFsrOkWMwaWLtt7ixIESFiFTgQohPRA+iXB0IJjvHPNyAsimQCKXYg36RD5DJB8n5DAT
+ sWmVY8y04/jC4lk89qeV+KoBW8dVCJt2CIQQeAoejSMObijQ9cxWEGMZO0Kx2yDFql6oM47hnKNKyP5j
+ 87DLQHrXG6IXNiOLRZ6NLdLFKbvOW2oGadsykDHThrdgjjicja9V2av/QPbr2MRmnUVKiRIalEiVhj2J
+ tBaSDtAe4Ag8D9/1aQekaYLrkyUXAonBSI8YRd5EDE4cBc/xudY8i0sJKxNFr7D41TB9yc6ATcjgMVdo
+ nhCW8xoUQ3bLY8MBPP2HTuZs6sGIAs5ZtkrwhGKDByNjgbUJE3WOxbkqbRi0kBggIemObe2TpFxpb2uF
+ O0Va5wAAIABJREFUQmEXITP3ALun0C9BWKnxX+eexq+v/RWrbvwav7tiOq/aJnzdRzVr/lCptP9TjEH/
+ ir3nEQDArFmzyuPG7pLf3tHxQaUVWikWbOzmrOZ1qBHDOecrl1OtVJjz9Fy08lPCCK0plcq7PzPrr6cd
+ csRR81e9/trfjfOGlZ7OXLZgHOIo5STbVIKSgr2cpmYNWSRzVMT9dLNUWmKnaUBSE5o3tpV4fXOZg6fu
+ StuadpbG8NeXV2C9PLauVDTAwFgHvgChLaOGKHR3DV3yGATskihaDWxNS/+klH7pRk4FKgR9EkBCpMtA
+ 9YmByHR2Xck05FUibZQZYFos2cPGrDXbmHj25xiT28z0R1bSY3I4AWFYS0NkmQJfwLElCTk2l8Hf1EPr
+ iePwizXWvxLzzBvhDgcAEFdCLj59CBMOGcdrVz9Py8sl5uiAGS5G6B1ICcKo3t5EkFjHp/bM8bEDFPnT
+ v8KSc68hVjmuTyKCTBZPKrRUeCm6IgVBSwF1KLKAHSIoafzS905SPEbfQds/jhlvYyYKyGuBMpYPj83S
+ Uo1o6w3ZJRF8QFgWE9PtUlbll2pV5mPY01S4dtwQ9NBduf3GDczdVgMB2kW8IgUP+JJnVER/YzjQOApo
+ qtkc94haSlLiBM4ZAiUv7O1sf/Kd1nIxP+B0Ib0HrXPDBSl0vFrq5rIffYerr/gxa+fezPpv/5BrOnNU
+ VOrYlXO1WiX8ZJLU/uNCIe8bWvBv/ujKawJPtgFI59ieZLnuRUFyx/+j2r6SK7//PWY8/iiFQgZrYqwV
+ aBVgrRg996mn5o8fv9v33o7tp7Nz8zUCtaiPafdJU6KrIWCI84lMyKG5ZrJOYwKPZ/KOx3yPSGgkmvXt
+ 8OtHlnLJgftzbNbSXevrvKdee5hL+BQxH7dVPl2NmLr3QCYNL9DgLLnIkTeSMbEjqIe8QmikSCWpkH/z
+ QQISl46S7ogWwO5g1k2r9ZJWLchKjzWPrcB2dCGHD+aS48dQrVpM2MF1P/o0x0/bhVpiEVairCJEszDn
+ 0SAN2xa044ThIx8bhw2rKay3/nUZYThkSgEjBfbeFQSFgJlJgvM8BBqHpFqrctkFJzJucA6bWIqiyqUn
+ tOJ/5ovM/839NJUybAxLOKV2sv6SKi31ST1K0sdydQUmm/If7Rio2VnEs3XqNMEoC5Ocouw7Sp4jMJbh
+ Y5vZq1nyCSE4WCWMl+DXC41CKDaaGofGCbc19SfYbTRX37KE57oiHIpuETA78HgoB7GnKEjLUSIg4wRN
+ mRx/kSWMTOXp6kHY4+3tm99JyTdbKPb7vdPuT0ADUmEAKWLuvOfPXPLVb9G96SWWnvMV7u4KWO9SrQLl
+ QCBuqtU6/yFBzb/L3jcO4KwTT+waO3bCpVFYxQmBCiTXL+qiVCuy6ZpPYuIKB31wHxYtfI4Ju43DJHH9
+ dBMoHcgNG7dcPmLE6Hmf/vQ5o//m0kYI9eVU5UKAr7k17qB/roHBKkcxCZmsCyQIPCnZkHc84xkiNLFT
+ rO/W3LVkOTcecTgXBgo/NEiZVpmFgAYvolXEDExqFAqw55iAKdTIS0dNhjgp08qxeGu1/e/N1f/6R+bQ
+ rsbQxJA1gmFVwcu/uhU1andOPGEo+w+1TL//x3z2i1MZE28Dq+r/FwTaZ2ZPjSDfyJYnNuGyhr0nZxmQ
+ 3XFpHIJ9R3k0jwiovNINnQlb8FniRJ1dtW9TeoyPVzD7icuZNjLLDz82iv4TsyReC12/vJdBSlJwmqzw
+ 3rHK7N7093cyseM9pw3DRhEwIHH0D2OO7oZTooSWoc14yjDQCgYg6B+kdQkhBAlwZAJ3NPdj8MRd+P2D
+ z9JeUTQQEQnBLM/wvAdKSoyJOSXbj/5xRKsKmOEnbNMGWSdstzbsGTdk2NtSezU2Nk7JN7UsdZJznAAr
+ LcbUaG4KePrpWXz0uI8APcy+4DN0lDLcUwJP1UepBKEx9j1TCXrfOACAH/zgpj8W8vmV1giUdUTK4+KZ
+ PQzo3cqLv/giUgUMGNjC3LlP84lTPkKtVqpPjBmk59He2TN1+gP3LT308GPPfvN1OzvXPSNQfxHOoRFs
+ xPC0ihnteWwwIZ8vthDU0pBZ43gjL1jmSaoioSQ0c7ZUuOn5l7l0/z05I0gQRqCtpCYFSI2xAisUpe29
+ NA/xOUA6jiFklE2n9HCGdCpwZ81IuLd+jNNUjcM6iXB9iMG/fUMC5bJ05wL+WsjQnG1g7XVPUdusUXvu
+ zR9/918cccQ0Zv7kj1w7px1fyx3z9+B4ORFs9gLM4u24WoZspsz+YwskdWGSJDIcPLkJkYPOeVvxvIDn
+ raVb1iMSUqoureCux1eRD9/gvhkXcNrhOdSwUWy8+DdMUj6zs5LRhQITXNCHVXxbkwhiZ4ltH+dB/Pbv
+ BzBCMBE42GmmRj57J47+ztIwxMeWahg/wdOWLCodZwb8JOEng4bRMmkYDz77Cq/FRRCaLpXnyYzgjWyK
+ F0iIOTzQ7F9K0EqzrSFgvojJpJx+JHFMc8H/8YJXFvzdKV1s6v9ti3xOOjWuT/o7DiMOmjaFBS88zwcm
+ 7oWUjmV3XId+5hVmVGv04qPquA/n7K3d3VvXvOtN8n9s7ysHcOyx48O99t7n+1FYBgRKwD2rQh5vz1Jc
+ eD+v3vZTpND4nuSmm27il7+6BmdrdWCOQ2mFkF7DM/OeuWH0uN2mX3zxxa07rx5fDLoGEl/6PGq7iIIG
+ RooGtlW7+a9CI1GcykcrFC9mHRWVynP4QvH01pDfLFrJ2cNHom0EUtAjDb7SGGOoOEltQxeZAVlyGvbz
+ fD6vPE50Ia3VsB6tvJ05Yuc4oNzFza0+H4wjwjow6O9PT4fWcJmI+aG03KwcuxifdedejWw9juFHnk7b
+ 43/mc1c8Bdl82gqEHWF3aAxLBQTbQrqXNWAqHUzbq5kkiVMuvrjGQVMGQ8Zj3XOb8HM55tYSpDY74NEO
+ R6AV9610fOu/bkVlPYL9RlBb0Unw4DJuUj5fqpY4tH0Lm2X1HSOAWDhUrcRX4ypX+R5NtSrKiXeMCVQC
+ +0jJcBMzRlgKUlIEdFNI1JUQSUfVGkKgZi1GOiYh2U3neGr+MuZGhoyTdPow27OsCUICm27CUSLPSbZA
+ mMQI32MBlh2sBQ48rVf915FHXvvm+ykWi+Myxeb51rnvC+SOMkq13MPXvnEBjz4yg5b+zQiqJN2b2fqT
+ n1FuKvJkTaccg4BzNrKJ/fE7PPJ/xN5XDgDgiccf+lNLU+PCdEwYdNbjJ/N7aG4s0vvnK+lctQThNBj4
+ 3OfPZemShey95x4pC7CTGBxeENDW1nH87/9w68uHHXncxwC6urasNc7clLLkC0rCslhGDFQ5IjIcIHMc
+ 5xfBpPp/VU8yP++TRxEISZNTLOywvLypQpMKcEqyLUrYWDOUrCKxAbW1VYLBTXjKoQJDo0o4vKXI/qk0
+ JdLtLHZJRwrvRXN4uYeH8pLTBpa4d1qOo0VC5Oow2p1HONSbfL7w0E6zVTsi7WiqrafzuRcwqx7DzLiF
+ s06eSK1cRjmXzsPX6wtK+cysRfQPMnTd8ToyyLHvHs1YE6Y/Yw3jRzrQBcqLtxMGeRYmFilkHamXUtQY
+ 5zGg6HHK7kXW/fomkoZJtM1fTeseRaK4gqczdAVZNgv5FuGTPkuAD0c1XlJ5rvA0X8zWuCFTwMW1v/tZ
+ 6oMyQRIy0YFxCS1JRAZLIBzKQk+PR5IYOhJHFBtil9KpnVRsZvrGVTwQevjOxynLK75hfSZBojFSopKI
+ s2UB4giXLbLUy/GsC1FKgkwZn8aPHnHJ5TffvOPmCoXmrxqhXpJCTEWkSYJJDNm84v777+GKSy/HuSSd
+ 8BABK3//XYphmTs6Y3q0BGyq9+DsbT0921b9n26g/6W97xyAEMLss/+Ub4XVtB3qi4RFvYYnNjcwukWw
+ 5mdnYE0FBPRs20CtZytznnqCC84/l2q5AogUUis1tdAOmDtn3v0Tdt/rxqtuuKpw/DFHXJckqW6AUoo/
+ R1183bTzE1HmC+FmliYxsk7JhZBs1hHbch6t1jJYSAZLxTO9vQgknoVNxqdfo0eziNluYzrXV/GaNMoZ
+ /EyGbhJKSReHNBfTKOVvnzVlquBsT+OZCrYi8Dra+MrAIjaM+2p/fe+l/oHYOI4cGvH4VSMYd9MU5E+O
+ 4vaTL+PRXz1B64Wn8J0LB3PD1Ydh4x5sXwzu0nbfSy6m18/Q++QbxLIfu4728Z1FOMGoZsWQoTl6VlbJ
+ boxYqQxbSJBJvTDnNEkkGZSv8fh/T2HyGY7sQZO4ZvwV6P6DyXyzie9+rZUPZpO6gAr1k+6tT544xxRd
+ ZIADkQSILsfeUcLgUL9tbcAiGGoEzVoQa0lW+zRogWxQxDXFVhMTOUvVGkpxQiLSKO+VSpVZRpHTgkjV
+ 6NCalUKnRC1SYoXggGwjq0yFG7yYq3WJm2U3ZV/skPFubAxeO+ajx9wNMHb4wIkN+cJzBnUNTmb63HJY
+ q7DfQZNZsngxxxx9GJYaUiYgHOHmRWy/+x42ZRt4vFvgiVTvUUoR67z/w39xu/zL9r5zAAAPP/DAE2PH
+ jbkxjkNAkdEZrnyuG4qt9Otaw7qbv4WQkrNO+yTfvfRycAlXXXUxDz94DwU/zdlSOmvIZHOsWb3xrKsu
+ ue7ll1atzGUz3kKUw6KItKSioewsJalYr6GqXCpX5RzCCeaohNf69eeeBsGdQcJ90rKddIFXpODFRPJo
+ VbHYSl6vWcpkaMgJpE0oKEUSOiZncnjGYKVEC4knJEqBqCsAL7FZbFBElBPc9maWbAGp+zq0lp14k5Q8
+ c1Q25JbfHkpw8tE8vzjgGx98gMHbBPf/cjb3XbMZN+YATj9lLPMe/SbDWixJLUbYVBy0M9S82hBQ7InZ
+ 9mJM6y45dmlMNQgnDvdRo1vYdP8ahubzzI8SnEw3oHGGSrWbU44cwLMzT2TsmO2sb5vET4+9i2Gxz68v
+ mc9TDzfTdEQTd13YnwOzJVyyM/p4s/lCcH8tpiPIQJIgaoLORBNLD89JlLL4AtJDWGCEYy9nUVYQSk0k
+ NDVh8QZoSl1lqtKyySqqKDY6R6g10sLtScjvXYX/FiELMk085cU4naBJnamWkrkm5Fad8Kon6dYCofSO
+ rki1UmPv3Xb73V//+ld/xKhxP9jSGS5Befulgq0CawRaOn513bXMfPQx+rW0YF0F5XoRrgdBN6t+fgH9
+ Cjnu3BxT89Jeb5pg1K7ftmHDyv/Mjnpne1/gAABOPfX0Q2ux/dbQoUO+2K918EdGjt0lWvPG6r2FUkIK
+ wbZQM7pZsUdrTGn5AvIHfJgPTNqHKfvsx7BRw7AuZty4kZxx5lm89OJSVr7+Op5KNeaVUmBs4/bObWd4
+ nt8cWRs4ly4uIURdhZcd/WhEX/7tqAjLkrDEVgw9EmrSYGSaRjgFfrdjXxdgLWREyMBDx1BYvx7ZlTa2
+ jIWB+SJ/KnVS84IU9SVEek+kFNJzjKNMkWbdxP21LD+oduLqqLs+7EDa7xCYai+PXj2RQQeM5bHj76Xz
+ jld4TTaR8QL2tTDvuRV0tEv2+NgH6dfUyec/dwK2VubZRa+RJBInHSN9j8ONYg0hw8/clSVPruP5N2qc
+ clCBQz++N69/ay7DVIbf9FZZKzxMYpg0SHHbz47iS+eOQdLJ6mWDuOrTdzGx5rHQg1dVAbm0i/a2fkw+
+ YxTTmhJum18mruMd3tIAcY7NAhYlCYdk8tSc5ntxzJKGDEJB1lN46HRmoj41d77LMiSJ6BUC6QQ54xHs
+ GxCbmM2LI+K6uOhGP+CvKJwLsSZCCEFVCbb4EPteilp8082IN6kWifq9ifr8QGtr/7gU9965/LU191RK
+ pY8qraStp6ZJnDDxAyOZ9cRMDjvkEBJbRUmHEg5r0xmW7vk30X3vHVSyOb6/NMJoL528do6Wpv4tTc3N
+ l2XzuVMzDY3ZSqlnIf8YWfhvsfeFA9hryl5nz5kz/95SubxPZ1fvLts7uietXrFisudnhKxXdT2peL2t
+ zDn7NqDCKm3rlrH7mVcwbMRgpIkBhcORzwd86oxPM3DQQGbOfAybGGSdqRWETqwLhEjBJSl9Xr3w1Ie4
+ g7dQfwlAYdPqPCEFTxNIH+EcQioUMZ8iQ9VEWHwYahm5axZ/aRljBE565AKPFyLLq55CC1OnqUtBNNY5
+ pHTMNxX+WOrlcVtDBl4KmBH1EJoUgx4mlm8enuXEL05i9kceRiyOmaEauD3IMkfEeCLH4cKydsFyFjz+
+ MhOO+gjZVsdhH2zmvJN2Idy6nUWvbCZS8PHGBtpXdzL0SxMJyoI/PbSCS87bg4EDm2m/diEtTQV+vr3K
+ 1iTia8c2c9sfjmPkrkVkv3E8e8tmpp93F1NtjmW+5iatWeNpKkoyfgM8u7yboy/6EC8/8RpLOxO0En+3
+ 6ZCS1RJurkb8ziQsblAoZck6iScloUs3v3ACG8dcrouE1QqhVkiXAnj6HzeaNQs2Ut4qkcKSFZJFwucl
+ LVDOkvEz4ByZfBZPKxQ7nf6bPw52kL/0rQHnDLWwJtvbO0+QSjUJpdL2tBBUKiW+cO45/PnPf6GpuYAj
+ hZdLkRKPCJnFJtvZfO0X8CXM3iR5YINFK4lAIaSiXKq0VKphtlaLBlfD6ENeJvsxTzY9liSld00n9n9h
+ 74sUQCk/q5RGqwApNJ7WeJlcWsN2pCcpMa92WxZsDRC+I1k2m55X7yYd/oxxLsQRYujBJhXO+ewZLF3y
+ Ivvut0/aLqSvj/33Ps85x+BBAwi8vupsH/CmDkNViqG+49xB4/n62P05ut9IlJZo4VghDJ1SESIIgXVP
+ b0AdthsmilPyDgvlUpljiq2IOCXB7IP4KinxAx8hBIH2yAQBGZVSle/AAVEv/TnHrsWQr507mQXHPsGS
+ V0K+pzS35AP8IEEGij/7CV+TgvXZ/jQu2cIvppzPnK8/QNiVpXmg5adXjOHLx49lWalElwxwnQkbZ/Vw
+ 4FEjmUjC/h/cjc5n19FPOGJPsTGqcsCYBq66/QKi5v14+X74094/455LZ3B4diAPB4rfaiAI8JViEY6f
+ RNvJLK7y8NcWctE3ToL4rZyWfZtOSYmnFLW8R7Xg49WRkomGionp4/JLhGOKkzTYhIpKYcPCQWhrZEcN
+ oO3lErFWKVmIkGwRDitCfO1z9LDhTBswgLzy6qQscsf3v9n6hqH+9r8554Tn+SJFZgqSuEZDIcODD07n
+ 2p9fjdIpDRwiQsp6q0VIQFN+4Rbytozv+zy0uoTnBXUwmCQKYxKTFlSlrI+cw14tLYUnL7300v/onnxf
+ OIDzPve5P3tabnlz0SsWkJiIMIwwImXX1Z7PHxZ3oTM5GooFNv/xG2jXiRPpDL1LeqBnE5TX4sJ2hg/x
+ mfXkdP74x9/TmM8Qh2Hai3cGkOB2Pn6tUuKW3/4CmVRIMVz1m5FpNauGx5qeTqhFjC804imNEY6qVizz
+ JAZLjKFteY3uYp6aFsTWR7mAUjXmqKYMxdikarVIrISaS4jilHegT/23bwG+OfNHSIKoxB2fnsrtn5vL
+ Rat9rig28lqDj1ZJiqaT4HuS9oYM13uOC7TH8Fyewi3z+PGEb/Pn859m9YKEgY2N9CQJa3xFv2yONTe/
+ TGHcUD6xSwuFCVPY8PRais0eG1GUrEX5mhvPv4dvD/8iL3/5Jk61BZYqw7EY7g4U2s8i0rEgpFJs0JIv
+ RT38as5yOu9ezZWnHUI1ilPIrxA4UUc7wk7UX/1jrSBKLImTJC7VCUiM4YuNA4jLMYlLSUacc9jAkWR9
+ ekOvvpFS6O9WZ9A2QHs+6yu9rIpjqqTzG9LZN71nhxDurU2Wuu2cjhQp+tEpkrDKV75yPsuWLeXII6aS
+ hB1IW0M5U4dSp2rLViic2Ub4wp1kBhYwgWRJl0IrgRSSQi7kR5cezde+OBVhetII0EmEU0Dy2uWXX/4f
+ TQPeFynAgw8+WD300KNffmP18lOV9pV1DhfHnHzUAZxzyoEsefFVSpFDScHW7iqf2sOnUo3R3d0Eu+2O
+ bvRBZxE0YKIutA7qJBMJzlTZfeJEPn/u50mimGfnzUMIVedeq+PQEfSWa5B08PNrf8kdd94BdZ1QR5rz
+ VSRsdgmbohqlxLIlLhFbh5HQaCQTEkGvsAiXIMc0M3hYlYZVls1RyPakxsimPC/FlmX14SDqsNf0cHc7
+ dsGOtfimP9fCGn84Zh/+MH0Rvyp5bG0I0DLtdiDf1CGobzJjEv7fqIDTW1u4smyZWBhI98sbuf2eFdyy
+ ZBsVT7B3Q5bdbci6VW0M//xhDOjXyYC9j2H1t25jVFaz2Oa4Y1svW9sq7PdSB3tki/zGxLgBPucOauK2
+ rdsgyO7IqYUg5SEApFSs1T7TV7zBGbuMY2BTngWb2lNFZCH/LgR/64ncl4al+Y928HxvN0J7FCRkrcN3
+ ksIeLfQWAtY+30agND4W5ynucgmxByrQVI2l20Y7MBVpFph+Vx9a0NUZfXe0Z990H9YaatUy++03gQem
+ 38epn/gIHhGKqB4dpqPfTqYzEkJmKb92HyrowF82Az8fUBzcwOwXq6yvaKKwwi2/PoEzvnA8hx3zId6Y
+ 8zSLV1dRUhDHca2lufW0rq62/5WYyL9q74sIAGDGjPtnHP7Bwz4dVXsS6cBqn6XPL2Jvt5EPTx2Psw7p
+ LJEJUK39ECrBa4Te15cStq1n8RkH0PPETQTNE3CZ4UhZADLgPLAR2SDhBz+8mAUL5jNlzwlEle7U9dcX
+ h1Zw212PI0treXruM/RrKWKtTQdxEHUmG8daW2J+bTNRvZinhWCJMFjlg4SiyLLwnpfIf3I/OrZtR0WC
+ oglItnRw9vDBmLAKNgUuvZ2lApo7/xw7y5EjR3DZ7Je4wxSwWQ+NTZGCauc1nHM4YYmE45S85IdNOR7Y
+ tJ3bKyEXdbVzm5ehsd8QxhebgCzLayHZbEArktf+vJBJ53yHnpdeZ2Clis56bKpFOKEYHxRoamnl/GqV
+ ZzN5fvzGdsY1Zbl78q6Y2IBUINSOU1QIVdf9s4S5PGdMn4uXKHJekEZcf/PYhrTrUn8KjDGEUa3OjZ+m
+ YFszPj+Rjs8qyec9zTcDw+/eCPn9rat5xG9gjcyhRMA2FdAjBKpeyQ/rnQPlIApDarUQF1u0lQjnIZxG
+ I1GkhUXpHFioVctEtQqHHbIvj864j9lPPs5uY/vh4g6Eq6YpmUipzAQaITJU31jMC585gjunnk73tgoU
+ A3ShiDfY8uVPjyEKa0jtMWfOehQDWfHCS8xd0o5SKcGqgC+tXv3SS/9H2+ld2z8Cp78ndtRRR508Z+6z
+ NwqVaUiEhFqCn1EoldJzH71ff353XETX8naUqNGx61EM2utjzPjY+Yzrbwj2H8PEi6+m4QMfJo570G+S
+ mhJCprP6qoEH7n2AS6+4gmXL1+L5OYR0GGM5dGyOR+Y9z+buhMMO/RDt27al3iE9tHdg051NiUaMMyhj
+ uTTMEEQ1FAnrXZXzl5yKPeJO6MiwQWeYheFhJXhRG7TWKWEF4Kytn/Rvh/tLi39+bIl9gTIpbwHsDFt3
+ Fq3qz+k8irUqhznJGlVjkUtZjBIE1iVombYSp2nDXcMa2NxR5rVdm/n4E/ey6Vf/j+ytC2ko+Hzn9Yhr
+ OixZfBJsKtrhQmIrmCwM1mtguZMYYRA47NsUsFMUoqNmI/I6hxQQRTG+56XTNbBj88t6XWTCbrsyZfJe
+ PPbYTDZs3IBEEGQCcGlHB2HTgq1VKCsQ2uA5wZ4WnNM8KyrowE+BPPX3EtZCPn3ih5k4ZR9eWfoya9du
+ oLuri2q1QmjT0V9HQhAEDB7cjw9/6DhOOOEERgwbiDE1hKnU8/cApCKlafFAapLOVbx21Td444+P4aSg
+ oyKYcu2XGT/geTK1CuQsW3Qru57wAiLrU4tgcLNla1sJoRuwUlicOC+stP3bNQDezt53DgDgg0ccsffS
+ RS/OiGNaVZ180QpLWKtyw2X7cmjnPCrlDM5ERHufwsipu/GXk37AMG1Q1mBtxKjPfJLdLvopLsghbLUO
+ qhFYmfZwpfBxQjPvmee55eYbuPPex4kTR1wt88RVH+fgi26mfft2Tj7lNJYsegWdzbxlVMdS33xWEFvH
+ qXGGI8qddKsc3Ukve/5yX4bOXM2Nj3dxG45eBUorPKFxUuKSGrvuNpae3hpbt7ajRFqm/Hv8f3qqpg7I
+ 1RlpLDuCt3odw70JdW9NqozjAyYxxHGM9nxwAistDhgSl3hhbD82t/eyvl+OY5bex9azjya3SpJrLHDi
+ vC4ei7yU1KSPaMQJEBaTljLxESmzF+zI63fec9+D1Ae2lE9Y7eGTZ5zO/XffQxwZlKrrIbIjGENZx/e/
+ 91XO+9IXWPnGZh6ZOZPpdz/AggVLSOJetPQJ/LSd2jff5Uh1Bq1zeKKuePSm1MIaS1Lu5qipkzjrzJM5
+ 4shDyQzdHfD+5k0bnEmwroYz5XpLMOU8kF7dSYs8jiwu2s7Km37Bsu9fRyYRuIxBANur0DVlVz73gwPR
+ q55DZA1iwBAmfPR5NkUanMLECc5EgG2LnPikCbtnvbud8X9v75sU4M329JNPLv7M58/ZL/DFQmOTHZvC
+ OMde/TLUaulv3hhLMHACXV3LOPbyg9lQDtGexs/7bLjtLzxxxGS6Fz8Fujm9gHA7/+mqYEsceNAkfnfD
+ zdxzyw+o1coIL8N11z9A7zM30tzcj8ceeYgzzzyN3t7et6sSU099eV6FKJUh62KEyPCb61/jS69F3OA5
+ wqwkqxWeEBhnCcs9nHbaxzjn9EN57MFbaW7M8T/54jS/f5v8+U0TcymjT9rT1tYSVkrsP3E4Hzl4Msa6
+ nZN11rHNSNptqmaUi2JctBW/PUFpCUrzam8N34k0RLYCaWU9TBb4DrRLaT3rqt//8M61kFR6tnPRhefx
+ u1/+jKdnz6KluUAcRVhnMTZJucusI5aCr17yQ07afxIDys/ylfPO4K+zHmYLtpYUAAAgAElEQVTD2le5
+ b/p0vvCVCxg9fji1sEy1WsIYk6ZqgCflO75Gmc3yyKJVnHDelRw56SDuP2EPXv/FF2h/aSaYSjoLYWJM
+ 0os1pZ2YECRKa6wsYmQRK3y2P38vd+23D4u+9TPyUmPyhry2FJVlm/a576/LYOBETJAgVAOIKhNGZ7Em
+ ASzalwwZNvi+QYP77fFebn54nzoAgF9cddWa3/721/uPGD70eSdASI/mgmaIbUcpH6mgFjkKQ8eRDbcx
+ fKKl37F7IoTClxo/l8V1dTH7mBN58TtfAuHV1WzffDJZIE/P0u8i19wNQuErwYyNmlf/eDVx91qkL/n5
+ L37GX266kaRWRjqb5oykQpxWpDTfG0TC5qxHyRM8lhXMXm1ZutWhdQZhNaCoVivsNmEUT815lB9cdilf
+ /vq1bFj2PDNnPkY+5/dFxW8xUT/xndvZo37rr60uKiEUAgVOUC53cfDBe/H4E/dyw623MHfpK3g6kzoQ
+ lzqRCoZNWqWTh9YS9QJhjIdjo9WsS+rfW8dQ9M3tp8XTFCcvhKhPtfEOTkCgUVSrXVz7859w+aWX4wyM
+ Hz+W556dx75T9iauVZDOYW2MszEiifB9xWMrapxy/AVs/OVJVJbcSqGo+PAxh/GTK7/Hgmfn8/KyJfz8
+ l7/gwGlTQUoqlTK1SohNFMKqHVV/meZFOBSeVGSzmgUuy2dnbeSGX9/O+gtPZtFpu7D+v88kfGMu0veR
+ ogEnFW7HmskhXQZRqzH362cz/ZgzCdpL5Jt8Qj+kEMDAvGaVX+Tn7RUO93w23bsAOXIfUBGEZQ6aPJgk
+ TEfYA09yxY+vvGT16tX/MfLPd7L3rQMAGDNmTLBx4/qxfSSXu4/IkXO9b+rnWppGDCGfVLG9VY67cHdm
+ 9Tj6txTIBCC8hEyTpu0Pt/LE4VOpbNiElEE63AIgA7Y/8xWy62eyZWPKjCOEoGZh1qoaW/98OUr4xDbi
+ +E98lLvu+Au1aqmOGnzrUWOV4nqV8LOsYnEmnVhUMq3MR3FIUMzw6xv+m2fnzWf/faZx83XfJ7Gayy69
+ mnEjW3jiyccoFrOY5B2ZpoC/x9XX/y0A1UovY8YMYtasGTx4/8NM/sBunHz8R+mtSqzty7brOTeK9caR
+ tRJXjTClGioGLX0WllLQi9iRbogd+HnYUaAnwRHqt9/7fZ0BrWMee/QhzvnsZ0lMAiIGYppb8jw+8xEu
+ vPB8Sr2dqTxbvcXnrCMQhjmdcMClz/DQZd+m65oD6X3mx8Tl9TjnGDZ8OGd/9kweePBe1q1ZwYzHZ/DD
+ H1/JMcccxMCBjdRqVUqlHuI4oY+FCeoKQUJQExmuXQ9fXSHxnUI8eSevXnQML3/9MErL5yB1MS30CQUy
+ oHPZC9w+bT9WXz+dxkIDOrBksjCk2WdYUz9+253lG2t6uHx0kYMGwxs334cdciDGVSCU7D+5P4lLR8K7
+ e3v55bW/+cS72wX/XntfO4D//s3vp4Vx1A8ccWQ4YEILYakT54ESMV6xET/r8DyDlIqc2Mzgk8bz45U1
+ mgoF+mc0ga+QhQB/zQYe3v9AXvz9dSCzoCTlJT+gqWc5Kt/KmnXb0GicFGhP8+T6CJ6dQXXtknqeGXPE
+ UYdxyde/TlSr1DEf6YKS9dnuTUqwXafClCiI4gpB4Pj/1J13nJ1Vtfe/uzzltOmZdBKS0DuXIlWKhaKA
+ oAhe4YoFsaKA5YooKHaxd4piQUBAkCZBegmhhEBCCCmkJzOZPnPK0/be7x/PmSQg11evjbs+n/nnJKc9
+ Z+/17LXWr1z69YtY+cIiznrHmQjnePGhn3LNr6/BKwQ8tGgdz956NbO2n80jj9zD4YftQ6M21hQKeuXz
+ 7EuTgCBLDaGf8eMff5sn5s/jNQfsh4mHuOK8k3j2xVqOkRAGhIGmLoEVkuXVBK0FBgNJA08KXFeR+zZX
+ m+Mx1zTVfOXRdD7+FuOmVlv4+wqBTTMmdRaZ9+gjHPyagxBkKJGr6uWTAgFkfOnSi7nzztspFX0y48gh
+ GDkMyheaYVHktDv6Of2n61n9y8sZ+/EhDN15Nm7w2fG+LGGxwGsPOYBzP/x+rv3tL1m8+BlWvvAcv7vm
+ V5zyluMohIqoOpbfga3F2VzbqKh95o8UOOL2zVy7uRUty7jFi1l8zok8fcGbMUM9OOCpb32B619zFNmK
+ IfyyoKXg6GrJmDWhyIp6gbctHOAHfRLlF9h9UogMHHYkYv1dT2AqeXm3xxyPknaAxPMKDPb3nPwP2CJ/
+ d7yqE8CjDz3wZqn8/Ic2NQ7ZuUw6XEOnDs8ogqmzEbVleEGYC1UmKZV2wTXrarzrqTqqcxLT2nyKXkYW
+ CloDxQMf+yw/O+pwbKOfYPBZpAqQUrFicwOldY7Tl7CiKvBbQl644mK0DHIhUNPg3PPPZfrECTmsdJuO
+ nXO51h02F7aqjo3wkXOOZfkL8/j4+8/Ga/bxquuf5oWbfsQLvQpt8+P0Mzf8CjO6gQldrdxy07X8/Gff
+ xaQJfxEa7kA4QRpHHH3Uf/DM0ws48z/fjjMxWvqs+fnHuX7uMpSvm13r3AUYkb+mcoLn6g2U74GxmLQP
+ V9CIzgrPDNbQQpJFMfvvuyM2bmxpiL28D/LyFCWFII4bHHzwnjz66KNMnz49/39CIqSHjYdJq5txjDsu
+ xxx11KE88/QCXnvI/mRxbrBjXd7zsZll58ntPLox4eCr1nDHym7aqk+RXv8GBu8+hwfP/xBDix5kXE3J
+ uRyL39ndwbFvPp6fXf5TVq5cym233cjb334coadJGnWSOMJYh5QNoqDIfy8wfHeFolwqUW4N8Jc8wtNf
+ fC/1JX+CK79OG4IqGZHTlEkoyw4ufN7wXytTlgdt+L6lXyguWwudJZ9SSbPmp7ejpuwKWYPWjoQ9ZhSw
+ LldF7Osb2fuqq36zw9+3Q/7+eNUmgPvuu08PDY2coL0AEGhl2bUjJak357VZg7Zd98HUViI9iVMWCiWe
+ enYI7ZV4Ji5x/MP9PK86mNwREPoKIyXlQoHqowsZG+rBJU1suNT0DcQ4tZUoUksMrhDCgrmMrnwE22yu
+ BYHiYx//MI1GTj0WQmwR+8hRXYJqdYxffP9EvnzefpRcL9aMIpXCJP1s/vkHea7fJ3VsqaOrNceGq7+C
+ UgXSyPC2t7+Fn/zoW9Sqo1sBLM1af7y2VVjitMG733kiN117Ix2tITRJKGPP38ayB+5lQZ9AioxxgcEc
+ 9SXJbIpzlqWNBnVtMBhEYxMiVLjAY81oDRyUK5o77ridp558jN13mUkaxU0QEy9JAnnk16A6OsinPnUu
+ t//hDlrKrQgyrIxACKpL/8SdRxzMnfvsSd8TDwIBOIXILJ2dBW6/81YuvfRzJI0qwhkkDitznP09330t
+ H3rPIbzvqoV8/8Eyhf2PoNIt0bdezpOnH8eCs/dm8L7vYWsb8j6FJEd8WoPy4MijjuDKy69k7fqV3Hnn
+ TXziE+ez+x5zcolT6/ADjzs3GtSsTmYc083s49qZPWuYYMoUdj6+yJEndSE9x2gkGe7cjretqHFz4qMK
+ AQiJwsMXHrdsdDwbFykJiV3Wx+C6GkYabGOU1+7ZTZrm04KxWlXMnzf/Lf+s/fPXxqs2AfzmuusOGh0d
+ nSGExCGY0xXQXhvOvd0QJAjCmTvD6Hqc8HNr50KRxcvH8PyQUMSM6oD/fHKQH/b5TG0N6W5LmNiuaC0J
+ 4kZ+bDVpAqmhZyTNUV3kGy4RDlEIaCsrNv3hhyipEVicyzjl1LdTDPPEtG0B7IAkE7zrbTtz2mEFWPsY
+ pvoYQjiU8tj0h4uZEFiWbRwE5YMQWCUZiCOye26kvmEFyg+I4xpvPe1UTj7hBLIkfYUaOxfP2muX7bjs
+ W98gSXpwoqmMbhsM3XkJjwyGWEXTvcg2obaOqD7GyW85hu22n8aKWsJa8vEggz3IQDGKT38tw2Qxb3vr
+ GzHpMDvOmcZDDz7IFz//GaxJSKI6dguQqTnPTy2ejrjplmu48MIL87u3Ais9tDO88P3zufuokyiMjFBW
+ GQ+96TgWfu+LW1CZAomzER+/4FweeuB+Jk3qwmQpngtYvlnxpSuf47xjfZ6dexa/vOcFfnBLhPVb2f+d
+ U5lzYAeluMrGKy5h6Qf2Z91XTmLk4V/hklEQGmMtxtYwtkagMo587UFcfMmneXTefdz3h8toRDFCxgwk
+ Fm/XGThrcDYEImSxjCpJuvaxnH3fh3lou4mc+kwvG3SRIhLJtrBmAaHmv5en1KlQqGgWfftp5JQiVAc5
+ ev8JWJPgnEBJnw3r15/yj985f1u8ahPA/fc/9G7l54qVmXHst12AiOpoTyEkeJ4jnLwzKhpFOA+swDUy
+ 1q8bQwqLRSNQ+MUiP9hg+fTKjPb2AjtNyZg9TWI2bca2TMQpHxtbRoZysU8nBE5KApHLk4vAI1l0LzYb
+ wZkMafuptAccsPceZCbDkCvdOpcTdoQd43Mffg3ZulUkGzeSrnsCoQJqL95F8OyfCFuLrOqp5eM2clag
+ cZpymLD2119E6SJOSSQZl3zxC5isgW3ChbdOAgRRbZSvfvlCRLwUj3UoM4hEMPj0lZRJ2BwZhPLyO1xi
+ SbMGBx24O3PvvInf/OJX7LnLLGIjWZilZJnFDI0i/AobqpaazXkNZ57xXpQIMa6GczU+dv45rFi2iC9c
+ dD577TqTjnIA1mDTGke8bm+efPIpjn3jCU1FXocUkmTTcu540+Gs/NLlTOgM6QoME1oksycWWXPpV7ju
+ zUeQjA7iRNhMArDfgf/BMwsX8P73nkGajREQc8eCXjYt94nn/4m5P9ybnWbNxkYBXkUzZ782ChNbaeue
+ TWclJFs4j7UXfZj5x+/EyisvgNFNeKIIRpE6Q2xjXLyR2lPvY/jZ3yCkQFuBsJZapvClj/ICfDKctYhK
+ J9YahFnDjntNJ5U5Rtvkxwe24jIkShh6pceH1xgiXab3T+vYtKiCGayzz3RLCQ+ExNc+y1ct3++BBx7Y
+ /t+zw2iuv1dhXH31TZ09G3tOVkrjrCWLGxyySye14TEEgsDzSMtFpPZwWQoCpB8wOKroGRunm26tVUNP
+ c2NU4LNLoLO1lZntkp6Hb8Dr2g4hYmoNy2Acb7n7IwS+b9EyI/UVpjpC1PscKIllBGdHOf74N1GP61ur
+ dAdZZjntjTsx1d+Iq6fYep2oUUGqdmoPXUZlSgteCQbqdsuFd0iUEkhfEc+7g3hwDUVdxlnD7DmzOPLI
+ IzEmy70ItqD+YN/dZ3PIgROQDCBNhLF1rEtg/V0Up04jtU26s3XstUsrvS/czV1z7+a1hx+Gsxl77rEX
+ CMvTYxGBVdDTQFYkz/eOgXSUtePaj55NrWc1yqvknAWb0N7mcf4F5/Hgw3P5xaUfoFqrMbXiuOIjBzOl
+ q23rKFNohhc9yJ2HHYK/ZCWdrZou37FMepT235m2TkP3JIVcsJCfHrQ/g889hpN+jtYUgqBY4LKvf5H/
+ fP3B1DODdIr1iWFqZ5n6s8+xz2yJtuC0xEnLaFeFA698njvXh3S2Fim3lSiEHhsv/zH3v2F3Fl16BvWV
+ C1C6jEhW0n/7CQT9i9E6aNK/c97HaE0hQr/JWHSYRj9uwna4gQzRv5k509vRJtsiGvJyrUdBLiy7OBWc
+ t8kRFtq576NPYeQM2opV9pguMMohJKxZ1yOffHLBif+0jfRXxL8tAZx88smvu+aaa6a8/PEnn3yyeNHF
+ 519unW1B5P1lqTIOnuCwqUN5IISF8nREox+p85EVssC6jQ0ilc+2c86/zMFrUhBquKGu+NSihFKpQnTP
+ PRghsVnM2EhKPRv3rVeAoqwlSuZdcKkk6eCa/IjnUpyrc9BBr8FkGaIJYHHOkUZjfOD9ByM2b0YLEMpS
+ H9VEmxdSqQ8gdYj0fGpxk42IxDkICwajLRUZM/ToNTipgVGwdd7//rNJohrONZF+wtJojPGus06DeDVp
+ /3KyeAMYQ7b5HkqehyoXkVLlICUtmL+4h4e+fha9938bhCZzMSedfApSOJY0EqQuoOsZQsGCNTWwkpOn
+ TeBQs5mb3ngoj3zpQySjYwgKWBQuqzFw47lc8umL8YKQ1cOKzXN/zbKL92dk+V0oJOvv/SW3HXYsbSKi
+ EAgmt2jujT3evSTl8N8uon7IIWy3Y4n2Dk13rcGVhx7JE9/7EsJanInpeeBy1n/zGB57Yj6e52GlpK/u
+ 8IsBYUsF0+iD4gQcBqEhaJH0Rpqz5w5y5tyUWvtUJk0wdE/yaG0rsu4P93DLcUfz/BWXYlbfwIQgQAUB
+ E1pzvUaXC8mxfrSBUn5zkuOgNojoriAnTyB9cTMzZhReohsAOZpxnNNgyDUlfQnLnOSz1QibeDx4xQZE
+ W4PD9i7hklzx2ZiUVavX/lvLgH9bAlj+wsoTzjnnQ2tnzJyzYaed93h4tz32//1OO+3z+2OPP+nFvr7R
+ tyjp4awjyRJOPqCTaf4QXmsBKRUmi/Fn7oqLVqNUkN/p/YBlyxoo5JbS/KXDslxp5uoBn48t9elOJWtv
+ ug/tFAMjGRkCIdSW51UKEqkThFRNLnjSZA/GWNtgx122p62yVVQ/lZZDD5rFvnNy/rvUBqUN5ekzEEPP
+ 4hV9ROhhfU2cZS/BElSKBYxKCNs8ak/cAjLvzDs7zFFHH0ZLSxnnxjvcDl8LTjllP1xjI6qjHVttIEWI
+ HFuEVy6jiiFSe9sw1hSjqovkT9/guR+ejIvq7LnnHuy4wyxWxTEutARZhIo1Czf2IYWH39bBHjtNZ0JH
+ C4M3/IGbDt6N9U/+kaRvBU+9+0B+/YUbeGQgxPc02tO0zphFVzlh+Den0+i7l87G1Rz3pT3JfEO/9fj4
+ qowL1hgoFRmQJQ79zkM8UJjE3vu1Umk1dEzyWPfTSxhbMZcN17+LwjM/YMq0MsbmeAIpNJt7IlQQopVG
+ 2WFEyxQo5P0f5fkI4Sj5knv6BYdes54vPBdSnNpBa7vDn6E55uyJTJw0gvan541CJBO6Mnzp8gQgfFZv
+ aiC8fKYghYBkEBG2o6YW8bpDprTmv8FfRj/mK04JwYsq5JLY8fxdm1m3qMhhR22PyBJwAu0VeWHpkoOe
+ eeyxads+cdKMSbtMnDjtNP4FUP1/WwL45Ke/8lmkWjdSbUzp3TxwyIb1G07a1LPppCjNJmqtULmmKl3F
+ lG+c2k1aH0HbGJWlmHpCZfb+xGPrQIc46YGnuOOuF5B+Medkv4xVNx6hp7mhT3LppoBowVKy1DA4EGNV
+ E1jefF5rIcfsCzRCCpQzuKaSkGeq+EXFvrvvlje7nMPU6nzq08dgR9YgAo0rCFylQGXWwaCGcK1lVAEi
+ WWQs0zkPvUmOawtEzhf3FaXR1eAinIxwDBP6CWe841RMEiGxkDmOfeN+dKg+GOil8dyjqAnbYXUZJUH5
+ RWTBz/sZ46cGJJGGjmltdA0tZPUPjyHddA/yxeVsNo5VMahySmPEsnw0J8VctWgFvxwuM2XmFPyix6TZ
+ 0L3jRp5/z+vQa2O+t0LihxJpc7/EYhu0dLYyYVI3KhrG72iltF3Ejl9+A6evHOMOW8ILQhQK30qM38a7
+ b1zPWfMidjtqAie9o50DTgrRrXWmlGpUutpRLYqin49m8SRre2oIP0D5PsLVcMUOXNGDgqIYKkIrMFIi
+ lcMGHlctTdnpyj5e3G03Dj0qxC840pH1uOIMTBLhLLQFDTpKTVa8kqzeFEMYkDs5gM2GcWFn7lQU+Ezo
+ Fng5NuqvCi0cm3zFd3SBGy5cxt57HQAyX9tSCZ56epGav3DBuccdd+Kndtllj9vau6b0plGwxFrn81ek
+ mb83/m0J4Iwzjhs9+NDXvr82NuLGUWfjSDOkIEXiuTGu+8guFNcuJbWONElJsxSLoDBrR7xoA1b7ON2J
+ K++D3zIHiW1y4//n3yjQgl/3CK5c5ZM8v55qnAM0nLXgJNZCZ0UisgzpKaSWuKaJJU3orDWjHPnGo0ij
+ BljBbjtN4A0HlJBxAxdmQIyYdRiiWERlGbpcQLYUSYoBcWpyrz8hAEWpYnIuutJYGmSmnsNtncOZHs44
+ 80zSJMFZRxQ3eO9Zx2L7n8YN9yMKk7GyDcRIrl3gh+AFSKW2nDAEudKOrhRQbRXagkF0sJIDujRYRZ/J
+ r/2awYgRq9HaUihovvHgYj725GYmzVLs/dFdWPuTnzB1oMB3XrRsVAWcANssoIVzeIFP4BcRIiOrRgSZ
+ ZOY0mNgabuNCu/WXCcOQBwYknQdPwQstkhCSDBsGqFIIxYBCWYDMVZw3jCSIIATpI9MM4VdyyzLPo1TS
+ aLV1Zwoh8LXEyTKrhgTa99E6JDQbEaUppFmdNKnheSnTOn2cU2ip2TBYxXkFsizDGIurjyCKFawFpKSj
+ TdNW0eNqDv/fGHdT3FhwfKca8PuLH+GEQ/bNe0cC6pnhQ+f+9wV33/fAV1dv6j/eIiakSXpzX9+GX/71
+ u+l/H//WJuAfb7tx7qyZs76bJo1ciRdwQpOmjtCNcsXZc9iltogkSZGxhciQjNTwj34vtjqCQuNad0B0
+ 7wt2Mt+94qvsNLOd1G1LntmGNedk3rUVlqJWfH+x5ZdPhkTDdbb68oFxgimtIc5moHKrJ8pTsK6Bcx4Y
+ gzR1Dtr/IJzNSKI6H/7I4TC2BCfztmA2YV/EpL2wqSS1MUIq8CSxK2C2sctxONoLGhUIVGBRpQpKS5zz
+ ESJCiCp77TmbffbcDSEkLW0+h+5fRER14tE6hZmHYOt9pEMbSOJaThf2fJTv5WVD8z2k1khfEwQKoSRp
+ fYgT9p8EONbaDJKAVX0C4xcRSqPwCTyPpzfUqcyGYGKR9PrlPNAQXD+Q4kmTq9iIphWX1AipkUIj0wRR
+ LOQ+iE7TWg62NGTHOQXjJ7SyzAiDAEGQ0wySGkoJnHQ4T9BWDLBYJIrReoTUZbSnc3MWHeA8DUpSDAQV
+ 3zYFXARWyNyqXcPSTRGiawKyHBKIIYQf4oUhWvlgYeaEAqnNcFj6qxYpA8hAOEkW1xGFTmQxL/eUzpjU
+ Hmy5NW8VY3lpjCsN2eb39JFsLigueHgR855ZgiAlF4WR6EIRr1DMsSLWDQY6/cA/Z8f9efzbpwBf/OJn
+ L/J1sNJag3WWLIk48cCdeO7Wt/H6fXtRs1oo7thGcd9uyq+bwYRP/BcdJ3wTWZ6NmHYsFHbA2RZAUBAb
+ ufXW7zOplBNWX4ljv22EhYAL7hpiIOvCkbHlzGAM3e0aW08QyiF9Qdg2jRX3/BRkGxBjspRdd9sVKTw6
+ On1OO7kbN1bDeYIMH7XDJ/ntl35FfRScy52OHNDITE7cbSYnJQVdlQDtO5RKSSoTyMaW5mITTa6rY5C3
+ v+MUatUGJ71+T/yoB2EEaetkaNuJtTf+jmjFSkRQQbicqiSb5pr5V3IEoY8OPFTRQxV9wOfwY3amICTP
+ Zil2IKMvMXm5IzVSSaTQhFbQcuBUVl/0DHV/Oz75Qh1ZCvO7/haikMi74iKXvcqM4JmH1kKlDZwjLHiY
+ /8EZySFwzpIqMJ7M6+vxE5xSlMshoFHSMBjFKK1Q2gN0Ph3xfJzy0L5PufBSVqXDoaXPC2tGoL2CHwRI
+ q0kbETbsRliBJWLWdkVsasA5ekbqaOEjdX6CymqjqEI7CNV85YSOluDPvoeUaou68Mv/xn8IJcAVAvqy
+ BMQ2IrRbPrAFk3yyr6+v5y8u3H9g/NsTwKmnnlr9j30Pfm9cH0MAnvK58cHFfOHDd2GemMiCJyo88USB
+ +26DP32nj+uP+BVPfOPL6NZ9sMEUJEmujKMULpNM6Wxw8++/jjRDOGma8FWZd3WF3aoBJyxCGFxY4vO3
+ vEghLG75TM4YprR7WAy+BeVrvNaJjPzu6pxNZzyQjgndbUyaMomPvu9QStFmckORDDHzPSy/9zFe+P5d
+ 1KoRIgPIobQjaS5sMY5jD5SlreIw2sf5Eldqo778BUZXPI2TXTipEFmN0049CWhw1llHwHAv8dgghdkn
+ 0ti4ms1XX4euDqNkjiFwLkUpsGL84O0IQo3VGqkV2vcQStE+BXab0sqKWkxtU41UAMI0eQi5gOWsKR5t
+ ywy158t8aEkvvYUA6bKt28zlklrOWlwW4YTB1nvY+4BdsI0IhCUM3BYm9st9AqLMEaWghEQrBaQY3wMF
+ zqa0hhLn8lPVWD1H0UmpUNLhogjltea6Yb6hFDbdC8c1B53ASXhqxRiZDXGeQhdi5MgGTHOCQJqwy4wS
+ zhpwMDCSEikf6WlwgmykAboL53k4qXE2orPNxwoFMnd7FkLinCFN4vzUg3zJ6TN3g1Y40XRLblKp3TbX
+ QRiHMMnd1ZH+K/8R++qvjX97AgC4554b799u+oxvp1mMc44w9Lh8heHb128m/X0/c69ezaO39LBwfkTf
+ kObhz3yBRVf8AF3eE5C5KpVLEDaCaJQ9dhBcc9VF2LERQI7LwL20JMgfARkzbMdrx5yJ5mxGd8UnSlKM
+ L3BBiNIelTX9jCx4BBuWc1itdVTKBT5wxp5kIxmudXsacntc5fXce94FzGyHJEmQUjEub9Wo17d9d8JA
+ UC5qlJT5UbrgoxoZK3/7a5zszI/0osrkaR28Zq9dOWAHicAjlgH+hIN57qufpLvDEY0NI5QPxiCcQSmB
+ teNm5rldGuQyVkorXCow0rDD1Ap9xrJ6KKaggi0jVCEEqZMcvl0bQ/clnNtreNZrwfuzFSNy62wHNstw
+ mYFaP6oswCuCc2itXgE6nEfDaGpGoZTMPfNcXq7kBxdLIdCMSybW6nmpKIRD+woRD+PK3TkQzDMUC3Jr
+ be4A4XBkDA0P83RfASFTPIowuhpjCzDawDVg+5ntWGdwzjE6mlGNxkFXElvbhPXacEqS1RKoDdDZHuKa
+ JQKAM46KBxd98FTq9VoT2Zivp23Xm2yKq2zbBxkPJ+xwFpuXmNr+K+JVkQAAvvKV3326FLbNz2yOGw98
+ +Npwyt0q5M1dBbYLJe2hoxCCLAZc85FPsenRp88w4U0AACAASURBVKE4B0hxxDgXgWmQDi3iDccfwi9/
+ diFpfShvQDWJLOPsvfGTgLIaLcyW38MKiRGKjkCAzd0GbLmVdGgd5WSU/tt+i9BTwHpkWYPzz9iVVkZw
+ rgsTTsab/n6e/sm3mTbai9JAUseKYi4BJmCs5rF1LwhaQkno2bzpJxy6tYy2ET133U1arSFowboEYYb5
+ xHsPQ2UxJo3RM95Ez6M3IRYuQFWKkNVweLneIOBrvWWBgkMrH2EN0jkkDmkNMo6Y3V3EAGuGE9pEhrJg
+ LVgnMWmDt8/emdMeWMczvsZrsgjtuLKv1Fsat9Y0FYOcwyQ1nF9EqvwuqqRo4iterhokyTJDNS3jBPn/
+ sza/+2NxJqNcLOT1tnA0IqjFCmyGwpEl/fkkQOX/HgQvNf2wqWBSW8Adt32fA495M2LnI3GlVqr9Kynu
+ /k4iHZD115ndaiiQC5bGLmWgoSBNkZkHI/0Q+LhahrASN1xn+pQC2HyLZ0nCnJndPHLXV/nUhUdy+edP
+ pCCqxI0qJgWHxkofJXKthiSOSeI/90B0qb0oiob+zH34nx2vmgRw6qm7J28/9cyTAq+0LsevQ6AU3x/L
+ +IUoslt7ganSUvJSWgqKXufz4FvPpNoryYIKzjUQIgWRonUBIbs56R3H8asfvos4aWzVAHhZOOd4qT6n
+ QGtJl5cipYe1dWjrJN64gkwoxh5/lHh0BCtLEK3m9JN3I0OgZryOzGqy+mR6fvw9Sl0e7b7ANUbz5APg
+ oFGrbb1zAB3lEGyWN+ysRbdOwCYjVMZqrPnTbTjKSBGCHeWNx++JSzNcaVf89tew5tsXMHFqEd+3JNU6
+ tpHgsgRshu+rvKbMvyTat1gT5boA1oFtIEyV6VPLAKwaSwlV0BQrzZuhxaDAuX94hkcpoVz2yrx/l3v9
+ GTOGIPdmSLI6QoQIkYHJ8s/xCj0AATiXMWTTLaWaNRE2ifLEYi0tpQLW5MfzJE2p1g0mVWBD7MgqRLkr
+ v5IiIwiay1kIkrjBiW85iKcX3s3rj5iBI8aUNNnep1HZ9z1seHIxxTd9CLvrHnSYUWZ2BghnURI2DmeI
+ yCBSi1drYLG4QphPIJRgysQQjKNRG+FdZ53Cw/d8jsnyPrJ1N/Nfb53Eyjs/xLVfO53/PHIHdplYYHqY
+ MaVNsP9e7Vx8/ml8691nkEbxlrLIWPtAo9b3g79lv/yj4lWTAAB+9KNLet507Jte7ynZ60xuDKEVXD0C
+ 36yHdFRCKtJnUphwSFfA7YMj3PO640l6KpgmcEjYCOkkWIOJI054Yytf/eBhmEaDnGz+EsX9l4TD4YSj
+ PRS06YhMCDKhCLsmYzc9hxYefuLouft3oFtyTHd5IqpjV6zSBC2vY+mX30+pCKGvqBQEOq7jtJ/rymWW
+ Wq3RvNsDQtAegnVpfiLB4YWTiUxCa6HEsl9dASIAWvI7TnkC1vfRM09nxS+/QVtjDBmqXNTSmLyLnkU5
+ Ldrf5pgpBKFuINMM17AktRSb1XCJoLu7DAhWVOuIQJBYcqFPJ4mlZoFwTSNNldfWzWmKFWAExEiO6tC0
+ KoitgTRGxgnGSlxaG397xk0xxv+clM1eTMDQWIr0cskyl0lcVgQ0MkvpKPsIl49nMwexFWAzSBzJ0CAy
+ bM1/TZvSVZI44xPVhvnSF87j2p//mBY/wZHgMoueci7DL3bzm/3exHVv+Bw//4//ZmBVF/7r9+T0o6aR
+ GYN0mp5NNaRxGCsgTUjrGTIsIztLiJYilYKmtc3x699eyQ8vOws9dANCN5O4MxT0ECceXeAnP3gjjz9y
+ EUtXXsOSFbdz89c+Q2He43zqp5fjhz5gcZaqiDnrn7mv/lK8qhIAwG9+85MXjjzihCO1cr2OHFUXSMEd
+ 9ZSvVkO6KyFlT7BbW0wjkHxz9Uaue+1bqQ1NxlVaGV23EBOvB7kcFXQQDWzm9LftR2BjRNpgfPNvEfJ4
+ WadWWo+pbRKflNR5JIkh6N6eaO0z4Ad4XoENv70eqTyU70NpMqK0I5aM2rPzCZ58EKcDvEDgBa55nrY5
+ dsBZ6iNjCJFLkzkEbRUPG9UAibUCGbaQ1aqkzscsXsLmpYtAlsm8FBkWcROOo7qxh+jmyxEdFRwy7zHY
+ LHcCTg3ESVMVtzkEdJaCjjH1CEFGqRQiEoeMDJViboKyKQbPL2NdPkqzTXLT+AIZ5yJs27kW5Kq+M8sd
+ eHWP4IRvkuzxPoY3D+Iyj7RWx6Upfwk1I5H0rh9DlyWeNGDqZKVucAaXZhRK43IjTTZjHOOswaQZYrQH
+ oUNsXIeswYSuCh0Vw913/IHzP/Y+MjuClb1Yq1CVNzPvsxfys6PewdiGMUphQNsSWHz6r7ji8LnIWINU
+ WB2wYk0/0GzY2Qwx2g+FMP/zA2bO3JXFzz7FKSccB9XH8TyJ1l6uXO1liJJFqFGyxhIM/cQDMfe/5zy+
+ d9C7+P4Dq9CFMtJm4Aw2iy6J495V/6j987fGqy4BANx885XPH3nkCUdqqXqtzXDO4AvLg5Hlk/0a7bVQ
+ DGLO2L7IGgH399X53eveRb1vEsVdzuK27z3GRedezuhwhqp0opzE4EiNxTkFTm3BWG3rDCNwJFh2nFjG
+ RjFGGUxqCVonEq1egvA9hFOky1cyuHwRyBD0JJAh2vYzdvnFKC9vEGotKWuJlhmYCJFm2GoNOxrh1DiR
+ xNJV8SCOcxdc41ClDpLhGFJLRTmWX38lQpQQtoT0u5CFfVjz3Q+wXXeFZQMeXljB94ooUQeX5Ycck6IF
+ WOnASZTnMdHWcZlDZJZGXAdTR2TQ4eUouE1RSlkqBBbhZBPks83yEFvFRIAtJ4FAWi5fNcRnrtzA0He+
+ QmH2/kw/6zr0nFOI0oB0cBTzCg3A8QTsfM2LL4ygq0XKbe0UXnyAtDyTRkFis5TOlq0QIglU6yAygcgM
+ YmQD+O0YK3AmY8dZE3nyqcc4/LX745zOBTm9nXHDc7j9kCN4/Nu30Oa1UVCCGcIxrU0yLyxx6dqUS/64
+ kkLoof2A1WtGc78DY1Eo3NB6rFfGeRlZ+SD2OelS2tvK4Bw2XY4QClssoSpzUKoVV5mEad8RPfVEFv94
+ JVfu9Daeu3o+9/tl+kPRdBISkJl5SX3osn/YxvlfxKsyAUCeBI4++pQjPO33WJvz2T0Jjyeaj/SFxEEL
+ h02KmRNIRqUh3FjjhjecRhpN5YSvz2XRgjUccMCR9CX7E0f9RElCmia0tYAxZkuXVr6kNJVgDAdPD0jS
+ JNcFyATepAJe73BT8UfgB5qVt14DqgSigCPF3vUj4udrGOGwJiNEUVISz4FrxKSbh1Gxa1Jl826wM5Yd
+ t+/EKgFCk2YOSp0YV2e07vBdkf4b76BR7UdSBDuZkWfn0rVuAXpChevWGFrbQnQInnGozCCMBZPi1dO8
+ 0pCC0Ne0RkOoJIM4QaQOF6c4rZjSktt19yYZJV0BbBN7wDaju5fGy+fX0lNc9vwYx161mkfPOYd4/tXo
+ lqmU3/xjKHVRoda8ui/rfAO+dMx7bpRPXDbA6Z8d4F1nz2PleRchJ+2Ce+3xHHrqa5lQyicYQghGqhEa
+ g80MqlqHsIgkY7g2kbM+92smdXeAszkgSXTRWLGBuw8/krHnN9LpK9qEYVcV4LTiM2Mp35YeI6GkEHjk
+ U5KMWj3JHaMdeT8h7ceWJ8DkN6HmnIN1GULEQAPXehR0vA3Z9RZE1+GI7oPBn0G2scjtB1/A4xdeQVdV
+ Mc/TzAtVLrMuBM6mjQlTO97DvwDu+5fiVZsAAG666WdLDzrodUc7lwzlTTJHQRiWJynvW+ax0Svy3h0K
+ GGegYBDrB7jzxFOwQvPr226ixdMcf8J5eFMPouQLPvrBU1j82E/YbbtWnMtyqJCQTXurcS5AxmASkjiN
+ tRJZCCkWyoQSdKEJJw181vz+VpwzONlBtvjnNP60FJv4CKtZU5cE2ss16m0NHTUQqwYx/VUKoql7h8XZ
+ lEntBcgkaWYQscVvbSWzPSwftAQYWoaGWHvXDU2Vmw5qt3yBMPCpyiLLhxO0lzMdBQ6Ccm5kkWVUx8ZQ
+ QiKEI8kcm4YKaCfwjMULQ2xaR0hJS2hoC316qzEF2QJkZCJvjI57DTgMoinaue2JyTVrc2kVRb/Is6LA
+ Z+4dYM23voJIVmKrj6Nnz6Cl2PLKisfkWPnHRuDnQwGPpo53XHwEO1/8enSlB7P6Ra785p/oS5tuPDgG
+ x2yO/nPkiEPbgt3hIFqOuQZVaMdgkUogvJC11/6AOw96PaI3oyQDJgjLDlJyK4b3OMfjZY1SDpzKWY4C
+ jJA44ZElCVZlhKFAugZi2rsxxTdCanNUpwwQIkT6xyGCQxhdrFny3T8w94RPEK14iodP/TwDi/rRSJ70
+ JHd4ClT+LYwxBL7/pTXLlz//L9lIfyFe1QkA4I9//M2Sww875swkruUWOs6hhWOl8TnhMcdeu0xmVy2R
+ KLTS1BYs4d4PvIfShGn88e5bUVmDL3znVt5/1nFc8rk3UnLPcsvtl9DW4gF+jmAbdwMGtOdz/byVLOrr
+ QHsesq2AG3EomRJUQtZVIZQ+8sWN9C5YhB26FR65lniJQckM33o8VreEvkP7DpeMYOojyEKASxrI8XEA
+ gNase/pFGkv7SDdkxHER1aqwfUMsTfLv2RYGrP7JtTgZUO95lPKGJcQpPN8jSIVDeRZUhspqiEIrQgpM
+ 3whpkiPbcALPDzjiy0s4/7ph4u4SurUMWYTzMrRK8DxB1UJW9Jt3fbG1f/g/WZhts6OdgEZ9lBnlGh+8
+ 7Ch2/vk3GHn6RpKbvo5YPJ8kzZDN/sGfnyocWWaY2FbjvnvP5g2nT0NPm83w1+/hwQ/dzHeuXYynKs3m
+ oWbzUIL0PXLB0hSbJsg5H8HaBJxDCYMZq7P4nLez+EOfQwdlEj9lti/Q2uOLzvITERB7GuUkTghsU+AD
+ l4N4No7G1AZi1j4/zIsLhxFZnLMtVQHhdyGlR33xApZ/7yvcdsJRXDVjF67e/w3c8pmr6HlsCXrizjy3
+ Zoxhp9kkPW4RFqsEnsm/rxLiqT322Olr/5gd8vfFqz4BAMyde+Nte+6+76fSuI7BYrB4ImKzU5z4xyHm
+ bN+GtQYpJdIr8eKv7+Spb32f9mkzeOD+K5h/770c+6b/oFhfhnSGScUV/PG2bxDICFD5pmwu6CzOOG+3
+ SbS92MPQhgaVSdNx1QZa+dhQc9uGhIJXodMvsXHe7ch4MaZXkjYEMnVkKJbFBp05lLKoJEHE+ZjL0wqT
+ JbjxusNYurpKKKHQaGJZQMkasm+AZXGCh0YJMM8vpbZ6JdET1+HXDZ7o5J5ldbLEYGp1hjenbFrZh3MV
+ krXrIHFNanPuhJw26nz2k0dy8XeOxusOiBKHajRwZHhk+FphpWJQS0rjY0C2tu7yjzuuScjLyqYc7HT1
+ t47muT++g+Pa17Px3rsprX6KYlhCoEgtOUdC2Hyk5uwWdJ9JBYfv087j17yd7mf+yOj19+Ke20jbaI0j
+ d/f50uHTSJMk/zzaY/NAA4IAjc11IWyCdiWUU2CHMb33kw70MHz7Q7R0ddPSavH3KPFVbTnHCh4IQ4TO
+ E5GDLajB/A0cCsGmGmxclTC0tE7iCgQzZuHSkM0P38+T57+bq3beie/sfSQ3n38Zq297ltqmCClLBCog
+ 2mkmy294loFEEAu4R2vWF33GaUFpmib777vPex944IG/rP/+L4r/EwkAYMHCed+cNHny74xJ8weEQAnH
+ ZgvXDkhKvo/L8kVV8H0evPDz9MxfROukXXl43lcoVVchvNxKmtSx6+TN3Df3MloKFpNtHZkJF7NrO7TL
+ BuXeGn7rRMzYRpxMqDnJrcNVMnyCIGDs0SeBDqInGhgbYGPJghHJ0tgwppqjvmgMq0vNmbwjjfPFbF3e
+ K5hYcKRJljvctLdiqyPYYctmZxh2ksBJvFgwOG8e0RMPIhMPmfjctWyQhlWsXzpC3+qYdFOKtfkClkoh
+ mqi63PEmY/eOCP/BezELe3HCR6RDyMwBGUoKlOexqrePQGi2CP+Td96N/cuO1cYYDir0MvLLn5EsfJ6C
+ SHISjLM4kSCVyKHCL3sdZy1p5jh6xzLBbVfjLV6BN2oRLV1khYxMx0ye5IGJ8oQhHb2DEfilpr2WyV9T
+ ehAPsuyctzP/uPcSTCwz+/NnM2Evx86nTeeYz+7NXm+ezkZh0E0gXk78yhmgW4g9SBTQ21CM+bDPj05l
+ 1seOY+2tN1Ob9xPqHzqVBT+4gReXj6BEkRYRMAWPaUKxo1VMNCmzDt+dp299kAoBK6TH40FudyYQxEmD
+ 7bef8bW7H7h74d+5Hf5h8X8mAQB8+tMXvN/3xFq5zfFTS3isZpgflCh64GNQwqPLGm5+y9sYWWchOJCd
+ j9odG3QjRAgE2Cxh1xkDPD7/Kg47YA5JXENgqXjQrSOsUqQKvAmTaKx/EWUVYyOwupqwIRJYKxA9vaQj
+ ffhjkiBWFBOPBwfGsKJA5BXIpCKqjSGVwKYRNklwRiFNjv121tIuDUlsSWxMMHE6tq8XzxXpbCnzmJG0
+ OscEQAwuorBpI1E9pb/hsaIuME7i+T5tXZpiwYCMEFrjpENKm8Oac9wfbmQMGYOHwPmtYLLc6cc6tAOl
+ PZ5YtpFYF4B0SxUwpS3EF2aL5v94iC0nAYdwGRs3RoS6iLIlRKIRpIg4hsiipG16AP75cpMaliztQxXa
+ SFWAzTIIW3GZxA81hVBimqNbJSSDI2PgpTibIZxFJIKBR+7mmeMPY+yOBQyuHOHRT3yQSWd+mtkfPZCp
+ J8xCFlIu+K+pHDe9gDGieedvNjrltp8p/9LCGrY/8zhevOIRNp5/A/6zy1ATp5BVDPtNDGgLLQVgBxEw
+ Q8OOStHhOYo4dtp9CmbBCowsc6eyzROGwDhDR3tp8TfOfveX/qGb4u+M/1MJ4IMf/ODQfvsd9LEoqm/z
+ qMBTkh/XY4bKbVSkJRAGoRUdw3VuOuYY0tEyfvkYcGMINQ5IEWAs3S0ruX3ur7jg7P8iimK6FZRMikBh
+ nUG3bIdZvZw01Qw0UiKX8fRITOoMotFAtlvUlE70UAxK8/BIhFQGkxkSY0niBg6FiFNcPaZar+eNNGeR
+ UtAmBWksMKmjPGMODK6kLSxSKXrc2DNGOShR0D7JwvkETuM2+Dy4KsP4Pr5Q+IFAa5c3vpxrdv5tE3NO
+ 82AjmtqJApfmpZLJTI5RMBbjQGmfx6pV6t74fCR/XkFHfO2jJ5Ak8Sv+Jtbm+gvDjZQ0VkRxRBbHOGPB
+ GKgneNv0WV4STdLRQN3lTU5nSeIEoXQTFegoqRRhm+KcOPpHIogFKnXoVEDcS/yLH9C3ZATdUmBCq8fI
+ L+5leP6t2B3fgk16MANjuPow5525G3HcyDc+W0ucl4dB8Py3biNYV4VKSDwyitc+CYNAly0f/vgO2N3b
+ uUxEfEwY3uGqvNMZLiWj3NNPay3kd9oxGHgI8mST2cS8Zr+D3nvcuee+8oX8C3HLLbdMfOtpbz3qb33e
+ XxP/0gRw+hlnHDp7zo4L33raO1//v32Ne+/94++nTp56/biFlhOAcBgt+eJwTLG1iw7pKElBpjR69QZu
+ fttbkHp7XOVQXNgGQQEXKqyKEcHhrPrNT7nhF5cT+pL2wGHSOllqiGKD6G6DzRtJG4b+hgPPY/lwgzjy
+ CaoWXVJEXhnGMjaZjLXOR5PzCSwCE2c4Y7Fxho0NtXqEQOCcw9MZLViccUS1FK99GtmGtZSDlJaCx9PV
+ lBVJiDSOoq4xvLGOrU3l971jOQhJCISV4BRi2/Z8k/QDdtwSAGkcadUQ1XLdBZ3Um/Dk/M4cOMWwcWRC
+ 5tz+/OrywoY6B8xucMqBU/O788tCCIVzChFLxvozopECSS1G4OHqBsYMgTCvuP/znaioxilKaYQFGaVY
+ 2Up9wJBFgmJWx6IZV2saHImRsUEkKbaeYut9YFO2830a1jJzYpEZ0yus+vDH0ZUDycRMVKTAeLxm3yJ7
+ dvm5/NfL2IkOyXgxkKYJQ6VcBUihMbUxZFHi/BDlCRrDA4Szy8z1YEFBs6JUYF2hxDpP0bhnLXODCgt1
+ Ayny6+/SlEmd3d+88Q83zv9b1vpDDz3Uvt8BB3zvne88Y82TTy784d/y3L82/qUJoK+3d5dqNdvr3nse
+ nLv/gYd/+7rrriv8/5/153H6O991nqfF4BbihxMoK9mofD41ElFuKdHqS4rKIbWi+ugz3HfhfyPlvrji
+ ztiyAk9g5Uks+cR5PPGLn7Mq0qQ4WrXD1SQu06SpxSuB1x+jMlhbt0jpszy2jKWOdNTAQB23eIw09Xhq
+ zJJpRUH6ZDHEqcbGGVm9QZykWGNoNMwWAYlAe4SRgcyQxRmyqwuxdiNO+PieTyIE1w1WiaIA62/H8/cb
+ hlraeThOmpZdYDLbrIdp2l5lOJuitfeSCbNvHNGgZXQwwqkCJs3A2CZJKd8EVWm3iIiMh8bj+ccW89Pz
+ 92ZKS9DkTbx8NzukkmRphogzTD0mSxSMArWUstS4P3sOTcHWlCixObc/s9gsxaCo9WZEQ4LQCv4fcW8d
+ Zld1/f+/9j5ydVyTTFyIkRAIJDiE4t7i7oVSChTXIC3uUDRIi7sUpzQJGgghSIQQd52MXTu21++PcxMo
+ 5fP90P4+pWueeeaZO3PPc+89e6+991pvSZV5HEaErq4Ikwe/M0eQKxGVP7uKVMgmfZp4tsMmYUHl+jwr
+ 770Y1fsQQukqC4Ws58RdmmOMx0Y35X8eX1pbrIsiXB0gEhB6drwLqKwi7YB0hfSvSYAx2JpYik0HhNrl
+ 4zlFnjU+KcflO39Ee/YWW4688l8a44cffsABBx44Z+aMGWdo7SYQlRD5MZG7/3/xsyaAHXbe+TOlNI7j
+ MufbuWf97qxzv9zvl4fs8K9e55prLl0+bMiwi4ulAgYpL3yKhIqYJpo7ixbdky4ZKyKpNcp2mX7zHcz+
+ 8wSM3hyltiH092PG2UdSufgrZpRSsQCGKLrZmlLoUwoEYyWxAh8JPLRjs7itiGM7zBMIBPJdRVjp4C3u
+ oqAUH+U9ElqhLEPCRJhA4xtBRQEmspDIZl3eYLRBi1DpCKEJKBYTBD6obJqoI4cq5ql1QGvhzXyBFeKw
+ 4u7lVNgVvFvwyGsDxiOvhCASjAdhKCg8lJdD42OpCCUKowTR4ARCqRhSKoSISqHDMilow6RXQmnDwV9i
+ MJAq03BXdxqqzHLuP2NropLHBohxHAalhFJHgPGsGM8Q+iipgAJQCKjRKq5HbGRcxj/LmzdyfrxDwRik
+ VIy1EkMFJQsnErSONtYc2v2AQq6AKYLlWeBHgMJSGlcJN65oY6Wup8t2WHbb84SSROq6o6MEqqA5dK9u
+ VOjSRj1GZQnqe22NDb4L7WFsN66MYBchXLEOXVuLZQlRvkjPVIAYwRgFEitTB4kEp61fTT5pl7n+mkBC
+ MpnEKc8991zxp47vPfba65Jnn3vxhcC3GhwngxGDUs4nSv1P0Kx/P37WBLBJv37fZDLZNlA4joMfyMC3
+ 3nh70pBNN7vjlVdeSf/vV/guPvj4vQmNdU1fxMUlVd5iahLa5ikv4qUoQ/dUgrS2SIhFTaKCD08/m7aP
+ JuGXuvPFuQdT2bYMXZlhxro8tm1hjKE+qTF5wY4EnalEdRSwjcKxbRZ1xivr+iggr22coiaaFVHoCOiK
+ hCmhg1iKhFg4kUH5Ma4+8EsQKSQUVhdkIx24xkohkSHwfAIjJBMaFrfjlDTpjI3CYa6y+AaLIBSqqtI8
+ s2IRtu2CGIIoIgw0kaeQQCAM0aHBFD1MFHsUxuIT4BYLiLGJQhO3PaN44kiZgSsmpvSqH1upga6V6/nF
+ uCqO3KYZE2w4RZf/LhqvM49lDBKERGF8XieMED/CKYsI/FBDPw4VO/iWuxWULIxlYkEOhEQQkRI2Gq94
+ gU2hMyQMI4IwQkodsWaDG6HDIv0zFdy+qkDCTmMCh6+u/CNqxN6YaA2RH1CZLXLctt0Jov/HXLIsVnfF
+ OoRiQCuhtHopqqEex3WJjKbBFTLyfc2pOHkW7Dhrxr4BgqvUbStXLv3gp4zpd955p27I4OHPvvu39/6Q
+ SlXEy5rS+EFIZV3TxJ9yjX81ftYEcOihhxYz6eTX3/e6T6bTauniZWccf+IZU8++cPyAn3otpVS043Zj
+ LwhKscSyUWojbi3pWFzTETI7laEqZUg6AlrhRRbv33MX61++lca1C9GOgrTDzNYSllIYY+he6RCaKHan
+ TFcjHTlsXGw7xTpfoUXjGchriwyK4JtVeAhrLZclBBBB1nYgiAUmbNvF8jyMEUyk6CiVcfooKh0LVQCJ
+ NNpOYmlFsD4gygdkbBdFhC+a+TpmMS43FUwtxJ55AMZYRKHChAG+H6GjIhR9VCixkw3xNNUodKiITICE
+ AskUEkVEBvxIk/PCWIJdlbuVsRXRxs/asi1kVQ6vQnPHBZvSp/I7Ywwt8UoX5v0YPRcajInvR3zU2aD0
+ 8x1+QAsbuQRahI7AEBiFeBJrP/o2kU4Q5gyJElRaFkZiqQ9PIvL5CPwAHThI24qYRyFCWCrSZBve7syz
+ xDhox2X5kx/SvjTA1LRgBQGqs8hvDuuL7XXG48jomNb4vbC0Yun6Asp2ML6BUFFaOI90SwMiEPkW1a6h
+ JqOIHRe/N43EiuneSoEyWInEsz9lPF900UUjDj/8yCnLlq04KJVKAVJWsYpZmHvtsddPSiL/avzsXQDX
+ Tf89CIKNv4sYLMfBD0tDH7rn7o932+vAPX7qtc4+7+yJtbVVK76nsFHOvmASLheuKmFVZKlwfdJ2SEaH
+ 9G1pgrWL0I6DVtAa2KzMxyufmIju6TRhYIEBu6EJ2tZjuQ5WMmJd0cQSUJbDLFNExMbr7KJKWcxJWoTi
+ gBGq7ABF3D+3LJewVESFmtAX1pfs+OWKUJ+M8PKC+DaJRBqrzcfqirA6474xKmbLzdCalCO81pWj4Fpl
+ YwpDEIWEkUvoa/xiw+g4KwAAIABJREFUiFfMxVvtIEBtkNEBtNIEuQhTAAkkRtJJDE3Je+AFDmJUvAso
+ b/8pn/VFCalUBhdFYfYyspkkT/5uS0K/FGMMjEJEof0IKQUEXlB2WS7fDMAPflxDV8r1+PZ8graiIO0R
+ oYDOF7CzKfwug+WFVDluXAMwIKLIdQWYgo8phnStXo3JpIh8i1LBkLUVvpXi2jUeKmGRzlTy4Sk3wIhj
+ 8Yp5JAzoW1vkgOGVSBTCj+x4lFKsKQTYVhJEIWKRX7Icq7kfJd9HWxrbMnSrTv3zszcccwQStjvz4AP3
+ mfrDfxk/frz9/d+PPOygve+994H3w8geoGyHwBhsy0bruFtVVV29YtSw3nP+t/nw78TPngDGjdv+DT8K
+ wdJEQNJx8YteTI+17PpJf3v79bFjd7zop1xr9OjRgZtKLhHUdzz1mGSOQ8BSSbK8ziKlDTWOT7NlqOvf
+ QrR2BcqyCS3FgpJNEMVVaksr6pUiDC1CPyTRux/hkgUktaFo27QG8dpracVUPyK0EuSWe6yzXN4pGWwH
+ AhWRdYWgCH5J0CqFVYq35EGgaStaGCX4SqizLOwuD+UrlFsJ6zuxiiFRWMAKQWGhbYs5kVDZrTvvBzls
+ Ox47oQWBEsR3EM9BFULEtvHa83HvXYKyPFYZ8JLLYZl4Sx5lGkArlONiqpuorrYIlU/sV6TYoFZnIkV9
+ Jey6SRLRgvfVLKT/Joys6eT8nZoJwzjRKDQFP5YxV6EhWZlBUUI0kHE4dr+eDKmO8MOwfGb+btgFAjUJ
+ n3XGoWpMbxK1VZi8wTTUIK7C+Ipq18PIhuJpRMd6kFbwfEW4Lo9bU8maxbB0saE+sgHDFD/kkzCBFYE3
+ J8dXj06EQduA7yHr1nH+r3qjPD+2KC9X6zecsBXCCk9hbI0VGXQkqI5OJNFIR1tIqSM+QTVUWkTyveYL
+ bFQ79sMCA4b1/+3999//3WpXju7duyuA8ePH61/us8+Fr7z2t78anaiMEKIwYosBLaSSCZRWaBVRUVE1
+ 5ZBDDol+eJ3/i/jZE8Ahh+w7vbKicoUiZqo1Vlqcd/J+lEolRCKSyayaPn36NS0tfZ696aab6v+36ykl
+ 4Q+LowIYralJ+Wxe61OMJMZ8G02mdwazdmEsWGHgm3V5jB1jwh3bImsifF/jFRSZHj2JViwhUoailaQr
+ KGvWCSyPQEma/KQOvpQMX/tRjL4zQmOqkkKubGVu1eAXC4gRvJJDLihhhQaJDHVWiqAUYPyAYrISkyug
+ dbxDMGWdQq0Ua8MCS7v3Zq4KY7PP8vY6FMFXBvyAUmsJSorcmhxBm0fCceJOgRhsbZEK80gYEiiLRPPm
+ mMCDbBN1dc1Me/ZkxvTMEISxVJUxUAojdtzE5vObR9NLLyEwQqojT7HLQzat5aK9k4zKBITlNqJXLGG3
+ Gyqa6qjdZWdMr+H4fivKydKjyvDR/bvxq5HV+N/b/QVByLj+EV/evyXDR2SI8hFqVQk/yNF8xh5UNCno
+ CqlTZRluiVNTa2tAuNZAm0X47Tp0VQOhhAgKx7FREmHbLreu8SBMoewkU65+kqDP7niWD6HP0KYce22S
+ JhL+CaOggPaSie93AESaqL0dY9fQtV4x79uIKJenLuP8aF0jiiKaa7OPfjJ58qQfG7O//vWvg2eeecZ9
+ 9eUXHnntnYnXKjerBIWJIrYb25vDdh1JVy4PSlHwPVpa+r3wv82Dfzd+9gQwevToIJNOv2vCCEtg7qpO
+ Rgxs4bzfHB5XdyXCSbi0rm876Oqrrpuxyy577vP/up5Gog2sNWCjWYVBMSwLTmcJX5eRe1aE3U3DmnYw
+ Cq0s5q7Px8UeNHWuRnsBvtHkcxEVvXoiy9ZhGcVaSeHjo8stvE4MnU4CzwuYL4rVTryKGDHU64hCV46g
+ BCabRq/PEUTQGoYUTYRlBImEeiek0OWDgWR1FaZrfezpp8EjFsJQWCjtcG/nOoq22ti3j41MFLZlsCMb
+ 6QTtVGBpB+N5pHVs+63FoRafmiH1VI3blqr9jiK/phnZ8Up84yP5PNXFubz94MHsNqqOwHh4QcBvdqzg
+ r1cMpbZjIQQGp9BFOLA3a5YkefHhFRSrann6T6Opk04MPrWZDNmj9uVd3YNL9rma+a2DUKfcTkEZTBiS
+ 8tbxxB3juPhX/SkWSxSLPucc0MJf7xpDddsSSp92ES4vkv79WZRKFdx34cvk9t0T+xctjOuWivn/5WNL
+ Z0FDh6G4MiBc0YlbXU0eIR8IVUFc2LQUrNSa5/wIFdr4ecMblzyAPWxvpC2HLF7BBb9sQeVi+/TvoE8G
+ jSEXKdb5DmHJYAILp7OLdEsNKQ3pZESxq0TPrP0jycNgAi/adovNL/+fxuyee+456PTTzpo6Z+7yo5Pp
+ KsQYfK/EjjsN5vEHruGeCS9gu0kAbCdRPO6Ifd7+tybbT4j/ChJwUL+Br5YKMUfcTVVy3dV3cvGZB3Pj
+ +NMpFnIAWJaDYDdNfn/yX7fccuvrx48f/6Ov1USh9WOPhyIMzEbkOzxM5CBKYads3FIB6QpxI4UbOSxu
+ LcVFKoFaK4lXUAS+RocRdkMSe30XURCyPkyiJYzx9Qp8cVjmxDuPKY5gVHz0MEbRnIrPgJ5vcLIZvLYc
+ qqgoRlbsVS+GKPJoSjlEkSHyfbKVNZg1K2JFWUvjBX7cYAZc1+W1FQvRTqasHqw21ghKRQgDm6IJkaRL
+ VMad22Vn5ULgc15lHWsmZbj7is+58ZS/cNWW2zLjYx9795vxTQnLB2f1LJ6+blt2HVLLGXt04+YTeyML
+ 5iPFgOKaVtj7CNbW7cmE/f/I8gnLeOuYD5h18yJ6V6VxEsJn3ya595z3mfbEPHLfOPzpsHN59LY3sY9/
+ Eb+mP1HHGmTtSq743Sbcd8Fu3H7WaK45qgH5Yg7rJ6+B2izJy89nxsvzeOjA39P2t1Ye//VzzHh+PelM
+ I1mx8XWsm7Cy1IlSFiXfJ+ow2BV12JaiwbVpcJIYiUApHK152oR4OkFaMsz/y3usM8MpplOomjQjKjy2
+ b9FEyuGHVYoIwxJPo6NY0Sla66GqSrgJocG16Got0pxw4u3SD8J2ElGfwYPbfmxcbrXVVke//8GHn3iB
+ P8J23Lh96Jc44sjtefn5J3j2oitZ7GeI6eKGxrrad0888cS1P2Ve/TvxX0kAhx6657taO0UxCouQBcU0
+ Lx3zW84693Ae+tOlBIXOjXW9dCrD1zNmnj9hwqMT77vv8X86Evh+WBGfKX+wFYsi+iYTdHQpbB0rZSXr
+ qwhXrUC1a/x8gCeaBW2xJHegoMGxkU4PwgCVskmUDCYXgrJYWRJQDtEGDLklLMNmjSt87YRoS8f+cRga
+ ChovSlMMbZzuTaQTgCg6PTt+frnI3i0w6NAhGQqJXi2EuXVYSsCyKJYMQgJRsfusAuzvDVJVLrKVigbH
+ KGxjoyoacZwIW7nU1aUIxUebgGtbO7nryzYS7RkyKk21l+aJ087h3euewBl3G6HlgdHYSxfywmVbcv1J
+ PTDFVnSkyJcqSP/2Qd55bB6PH3EjfQop6lTAdDvFiZ938WUuwEVze+s6XklkaUpUkqVIllq+emQyF43b
+ j9Loy5DhBxGuWIisWMNxu1qcuk+a4Nt1LPv7GjLbDMU97mImHT6Babe8QrXU0AtDs5PlguntnDxtPsVk
+ TNTRls26thBEk0zYpKMAu66GGg1p19CYINZpkNjZuWAbntUh1ZZF2q7h46vvw971NKI166FzFRfvXklQ
+ 8L7zUdzoIKVZ42ts4xCJxu/y0ZGPq4WlnT66YNFi2+X25D+6T4kRXSqV/iGjjD9zfHWfPv1enP7FrL9o
+ laqONQU0pWIHvzv7QB689xFm33EpDz4/E5JlHlmhwMjhI/4jCMAN8V9JAMcee2xrXW3V+4LBMuC5Fm9N
+ X8HnV93AUUfvyLN/uRyJvI3nM9d16ehs3eHii38//Vf7H7XNhus888wzlu8HPf5JcUpinH83x+BHYflI
+ IDCgGX/uQiSyMaWAti5YH5bVWcXQ24rQxZi+G2ZrsTo6oGQoFoUVHQWQVLlQFCPfvhXDVB3Rbn+3fti2
+ JtvRgRtpImNI9xmM0787tQMbyVQlMBLvABLYOK1dpHyf6j4VdDvmJDJHnUmxPokEEZmwjH5TCim3ub5r
+ XZfr51qRCX2yuSLp4b1I9N6E9K9OhmQFg+pCkrHWNp0W/FkVeTwh1LkZ6nBopo53b3mYl0+9FGvraygm
+ k1Bdi9Vci93cHyuEYrqB5OE38+SBFzLnwffppxyUCng0qbg/5dKZdbC1Bg2uEzLHibjH9vESWRqUoQFF
+ ZmYrZ207jnXZ/WGbs/Dz7eiB3dHr5tP19TK6/eYI9G6X8OpuF7DkvQWgUvRS0JbIcCmGSekYM6KUBSrm
+ COTzJSrCkFrVhrXNUNIjhlLf26bCUVQlAiyzYUFQOGjeiQq06QwpZTPrjTm0r4Ogb09USjG2ssS2tXFb
+ VspHgfizdViVD9EkCDyFl1fkPJcoZZN1wHQZGizNBhfh72tLGiN22+rVvTbcrZ233XbYLQ/dMXX12s4D
+ kslM+bVp8rk2rv3jaVx/9fUsfe0BJv/xJRa6CewwrjVVVlV+c/jhv3zn/3j6/UP818hA3Xq0POWVChhl
+ sLXwgaT49PaXWDl9BnvuM5QPXvw9NUm/3PKy0JZDEErLX9968f0RIza/5aWXXqpoSyYTXhBkRQVl2Fq8
+ HVM6dgJq1IaSpzBiSASG6n7dyM9eBlGMr5+TA5/4qWJC+mAR5QMkUlgNTURd7biWg92VYMG6IsresN1T
+ JAx8KUXeNw6irXiltjQtQO9iQOVQw+6vnkDGbSV9wr1EvSoZ2auS7rYQKKjVIT0tn/QvGqi77wEeOOpk
+ Pp80k+TdjxGMamKgXcAQsMHqYsP394thPUKffpRInX0svS46gyf2PRq12a+wTruI7iMb2WFgBh0ZFIYk
+ FrMduNOOCBMJWjBksJn8xMs8ctDvcDY7n7ChBWVXIL5QrNsEf9jRPLbtEQTTW6kWDVrxoGPzUSJNZMVc
+ /PjTUGhjY6mInA0PJApMdVwG2Al6IAxcnuOs7XdkeXEznL1uRJRPPmdIHXs6pfROPLXNUSydux6DTR9b
+ mJZIcgUB69IOVtlVBwXaEuwgz6/3HwoHNJK6/0b8wy7gs5deoOnZ36CHJRhsAlp0VFYviD87ox0eNTkS
+ TopaXcWfT7mdxC4n0fpKG9H0IpeOaiTwQkSCjXgDbWmW50Kw7LLqsEa1eVjpNEkd0VWIaFKGRJl0JRL3
+ /UXFy83s+YsGA2w6dOTpn3w+/ROFO8C24mJzKIpkwueVl+/gzLNPJrdoIp8dew0vShLPiZOX53nU1dY8
+ 8Z+q/m+I/1oCOP2041+zLDsvSiGRsExrFqka3jriKqKcYdMBPlNeP5VetUmMxJVjBbiplP52wYKzjz3+
+ xLnvPPPcQY5jb+w46w34bqVIa6E+in34tNZYEVT27YbMayPyLRJGszgXobQVk2OMZiCGzlDT5RnC7t3o
+ mjcfN5PEdYQl89YDcTKRskLuEpVnuurACsvn8VKJa4a49L58BJs/dg6v3vUZx22yP589/RTOMQ+R3G0g
+ x2zdjdArsUcztJzaDznsV9y50/F8+/bX3HrsRTx1xQT0eTey62+3po+UkB/cIhMZIhH8wOfk/lkyD13G
+ rNVrGb/n2bzw+mLGj/oV3368ErXH2dx0x4kQFYiZ7uAAa2zhGl1koZNlABkyVDBr8nQe2u9U6HEoUWML
+ pqkP+cQuPLfnhdSuUaQJyGrhfu0yK5WIHYzKXxsiBnfF98FWmpdSPvfrkAF2koHYjF0fcv64XVk6G6Ty
+ BDIHPUK+OJjXdjkaVneSImRQIs3DSnGrHRImLTRx0oG41eYHAZeeuRVDTupO4vLHmPLeCq7Z+UAe+s0E
+ 3rn/K6of/D1Vh/fm0jG98MMNkOWYAj1Ne8yzDanQo2Nmjg8f+5rUYbvgELFjd48tk4KY+JAlYnDEYmne
+ ixOJMWAJpWXLUXXVOLZLIbJpiAzV3xNP2dARULamPV84vG+vXrd+u2jxXXayMiNllHUUGZqbHD7+6EF2
+ GlON8Zfx6elXsYAkU0xcvIyPkuIduOe+f/m/nnc/jB8toP0c8eKLL+b79Om1SVdXcaSlNcYSgjBgbFuR
+ 1lxA3617UZmbyRHHbcO0j1ayYHk72orXQW1pjGVnv5kx+0Blu5YCJVqVLZli/nWj8Tm2xtDRrohQeKWA
+ /sdvS/TqJ3h+kkylzZNtAd94CkspHEJ+oxyCQolk5FO33wGkizkql84CJ8FMSTJ5lY9rKWLt3Ni80y+7
+ fnkScvYePTjrwROYtdzi8sMe5IupbaS9BF+9/iG5SW/Qe6+T2fHkcbz1yN95+N79mT5xJU+f9xqthTSi
+ UtRh0fnpLD577GU22flgNhvUzJMfzsTS1sbtqRJFYCm2SIZcd/IuvHDm/Ux7dykuVSQtRdilmfL828x/
+ 9yO22G8/apoaeOv9WTjaQimwRBEpzWRVAOWyjRKM0RRWrueL555n0MGn469u58l9z6MpnyJBgGsnuMnS
+ zEolUXYsIy4biALy/f3Jd98WwiLbMDcM2Nd2SUQuFaWAV554hAE7HUD47VI+OOBYUiUHgD7JLFfYRf6W
+ SmIRr5QbIrYdMxy3Q2+u2H8Tvn59GU+ffANTXppKlaTI4jL30/nM+XAhI845iDHbJPn2s1V83Rphq9i0
+ Uyyb1tBje2L7s5lTvmbbPx6P+XgSbkJRnc3y5IICtlYbk5tLxP4pKJY8LIlwNu9HIujEWtSOR0TPphR/
+ WZannRi2vAEgrZUily8O7iz4Y12n3MLUQhQJQzepYOJrp9MUvktYnMm691LMuelZnhWH5ToWuRERamsr
+ X3/1jVfu/U/Pw/9aAgA44YRTln388ZRTLCu2y1olwha2TcfHX9Jn3wNJedNIe2s44uDheH6Wv3+6DMeO
+ JbyUaLRlxXsvFctYq3IlXlB01wUOrjC0dgi+iVBeyIDfbkfx4Q/QtkMqneK+tQXWhDGPoLtSHG1CCAL8
+ 0KPnBefTsPvuFD55jkS1ITOoHxM+XYJju/GL3zg+BWNg5zHNXHvm3vz5hMd5876pNOWT9FGKFgWNVgWF
+ FZ1MnvAMC9+eyaguzbKnvmTtZ+tJ6yQtyqJZW6SUg7EtSnnFe6++h6zJs8bzWbeBSKMMWiISXokJTS28
+ +8L7FLtS1GqHJmVoNoZKZciSIb/M460JT9MjkaSjq8iyoo+GeGIpMLZiJj6dYhgnDoKh0KFY9clk8s9N
+ RFYJPRQYy+Ei3cWsdBa7/FyRWJ4x3i7/GMaPjWCiJZZmrQnZRSWIjE8mEqb97S1yb06ktjXGNdS4GcZL
+ wEcJFxc2+ukpiUVNQYgI2S1ymH33R6z4aAlhTpFBcMTCQlFBgvzyTt5+9iMG7bA1hxwykhdf/JwO45aN
+ SXxWWxH1uPT1IyTwWNuZZ/Dem8GcBQyoc3n+my7alAsbqTwRh2cgX8iRIEmpLkHzJi34n36NwaKhOsWL
+ azwWm9jkY+N7VzHdO4ZACxpF6IfssUszr9y7C5klUzELFqJSg/n0/OdZ0RHymC6biKLwSiXGjh1z6ty5
+ cxb93864H7tP/+Xo03/wO63r236BUoTGsHOU5tBCET2qmSOePgbmvhzn4yqLx/9ucfKVk7HSFYhyyqv9
+ d6HKtNYAxU52G7fWCt+uibfNWTy2e+1EVu3+F3RtFrcpyzbz19MmGQLgYAm5TPK0Fz2Sh++Le8SR9Bg8
+ kERdEn/aeehOw8jjP2SRlyh35+IbLkANAX/bektmvP0hHg4dtsMaI6ywFIuAeSpkzYbVsowVGCIJspGP
+ r4Quy1Awmk7LUCoX/fzy+dWxbLSyMRvqG0phjFDhhWjtYpXpOykJcYkToYfgWQ6ihILE5B9P4mLVhkRp
+ JAIxhAbGhPAbSbEmLLClZbE0CmghQcmF30U55mazJLHjMpmK33vEBi7Ahk9/wwTYcCaOj65KoBSFHBq4
+ HCwuH5kuttYRqUjhiMZP2FwiHjMSaRz9XTrZwBVRZe1AUeCFEbZR9DQ+PcWiVkGj1jSHCZIS4BCBKBar
+ PAefuisNLTVsc8Xr+Cl3QxmYTKC4OEiQDDpYTo5TXz+fqhcfJa087pqe5OyvPBJOhIWDbYW81d0hv2Y9
+ dujAyO6MOH0v1p73J3zHoU+vek5ZUODpNh0nxx+EECsz+aWQU44YyG0XDkYtWoAp+vhRRHu4D18ddiMT
+ EmnedhzirrLgJuyvV69aOuLfmU//avxXdwAAO+6wa9c338w+zLZj3PNSZdgah8KSpVSN3pWKpuXYQQFy
+ BTYdrBnYfQAv/H0B2klu7IVviA36AEFkOKBaGCY+7aWIiggyjWkadxhC4bmZkHTwEgnuafUQLKIw5PKE
+ RUtXnsShm+MftDPvHPg7pt7zAGsXL6Z6q1Oo2q4PuZXtvDt1CbYdZ3YRIRJBBT6vfruMGW4lU1yXN5Ti
+ TXH5PAGLHZdOCRGtEEfHP7ViuVIsdSKWWdDmuuStkNDRKMsGrbFQ5RUkrggb9R2jXqEougrfUZQ05JXQ
+ ZhnWurDegYKlKNqC7yjE0jH11RiM+U6iShEjDZVSLDUR043HtjpJmw751DgscJJcbXIsSiRwjAIVuyzH
+ XIGyxJcpA2jKzLd/9AsoO+wasLXNVzpgngmZJzaTVMAS22UGFveKH1e+y4ltw/0UEUxkNraD48q8RmxN
+ u3ZZoDWzlM+0KGKSDpmCYQaGRcpQsjJMm7qYzLwCw+u78W7HOiwdQ5wLliIANg1DkqKZ+dVCxpy5K9Gn
+ XzCodx0TvlxDZLtosYmMxwGVSYIODxMoHPHpceT2dD4/GWNbpF3NPFJMXO9jW/9cTlMoQi/krBM24aaz
+ WojmziNY14Fpb8fZ9ki++O2TrF8XcL+2EScGYXtegb79Bv5h1cqln/7fzbL/Of7rkmCDhvbHtst0XhFK
+ xvCFpUmT5bXLb8XqewKGHDgW0lnk0D001xwzEi8sxT3z7/nNQTz5x7g5jm4KMVFADTaRUdj961Czl2Nr
+ jYQRqyObooFIC73w2Ep8UoeO5dt+LTx5wHjagyQrvUq+/fM7vLXtIbw19CoGud1IOvZGzLgAlooIslVs
+ fepxFEcPZ4q3nqVhB809W9BeCYrr+cW+u/CL3fckDDz8Yhf9Bg5g5KhhiO9hiUL8kF5DB1Pf2Ej/wZtg
+ JAQDfhgycLMhjBo7itD3EBNvJeubG9h0xAiGDh9GQ2MTYbETZcLYGjwEMRorUoSRwfcLDN98M2oaG4lC
+ H8pquo3dG6mur6KhRz0DhgxgLhGXW3ke7NXIvH3HcquVZ5Xr0NLSjW79euCbPEU/ZNPRm9LUtzdhqZOm
+ bj3wfB8TBYS+x5CRQxg+ajP6DugXW3aFJu6OICjxyOwxFr3jCL5UhlfTMHvMJlRtNYIefXtQLJbKOgQh
+ IiFVlTUMHTYkVlGWiDCMaOnZTH1dNf3692Ts2E2pTmfZebedGD1mFI2DWgj7NZPfbDCvSYlnXcNxq5Zx
+ ++KFpGTDOqdwET6wfL51bDLKYt7Xq3j3rSWE3XpTkypyWJ8MvlEYZQiNTbtnCAOhqCNyazvRqQSOROgQ
+ gtAwtF5DGCA/oBcro4mCgCP2bOa6Uxph2QrsUogOAoKaStZ+lSA/fT5/x9DhlgVcCTHAPnvtNu1nmn7/
+ vTjppJMGNTY2T7FsV9KZaslU1ku2ukFStS0yOttHHrSa5WqS8tGd10s4ZS+Rt8dI9MZWEr06QqJ3dpWj
+ xvSVTGWDVNS0SEVND6mobRGnspsc0qda5u3XTWYOTctHDRmZWJmSVx1L5pyxvaw5ejNZWlkji5pr5YnB
+ A8VN1Esq1SB/bmqQ4KAt5bmxA+QPVMmtqk6uoEHutJrlqlR32SNTKz0zdZJI1kplZTeprOgmmcpGSVc0
+ SCpbI9naZlm3rk2uv/luQbuy6ciR8spr74pjJySZzsrqdevlplvuFNtNybOvvCWRiBgReWfSR1Jb1yhK
+ ufLhlzPEGCNBEMlXM2dJQ7cW0VZKHn32JXnr3ffEspPipurEdqtk/0OPFhGRjo4uESPyt0kfSfce/cRJ
+ ZsVNVUsiXS9Oqk62GLu9zJ67QPJFT4LQyO8vuFS0lZRBI0bJ9+Plv/5VlJUQx66UI044QUREdtt9d7Gc
+ rJx65lly6eXjxbaTUtvUIkEUyT77HSjKTcuMuQtkyzHbSiKZEtty5ZZ77hdjjESRkaIXyN77HyxuukEa
+ u/WS96d+JoWSL1EUyWdfzZC6piZp6+qUyIgYIzJx8seSzTZIMlsvTqpWDjz4UPnmm3mSTGQkma4Wx0nJ
+ fY8+KiIiYWTE80qy+Zaj5Ycxf/4CAS12pl7cikZJVHWXbGU3yVZ3k2xVo1RVdZeKqmZpcZvlFt1DrlFN
+ cjKuLL3rBCkcWStfnDhYkm6lZCqaxE03yL29u8tbKUdeyaTkVRspfXGPLG9xZGZLlSwZ0Sjf7jtAHCsh
+ bkWzpKqaJVvVTbKV3SSRbZFx2/aS0ge7Sftzg8V/ZqTkHhsiuXt7SH7akfLmlkPkVV0vI5KNUlnTTapr
+ mqWqulEqKuslna7qHDZss9/8HPPwv7ID2GabHTd75pnnP+rMFce4bhbP8ySIRJR2sICFdkRBQa1K8cGt
+ D0LPozHhatCCeB6yagl3n9mXftmYiaaVRakUcm6vgLuHgu5oo9Bp43eACiFpFBXDeqOWt5IUQwbNOt9C
+ tGEz8Tl42148995cFnzSToY0IQm8pM2jiYDrrQLvWZoOxyKZSoCtEEs2EnKUUpRyHUz5dBpbjBkDxues
+ M89j1523o6a+Oyf++lSSCZcbrr+eiy+5mHxnnprGFgYMHkGmMsNTTz+FiE+uPccVV19PVUMT+aLHnx9+
+ GBMVaW9dRRSZcpstwrJsJr3zFmEkjN5qWxq796Irn+ONt98AnDLKMKSxvoZ3336NP/3pXjIVDRxVoU4Y
+ AAAgAElEQVR6/DFcf+1VHHPcsbS35zAGttp6Z3YYtyunnfY7tJ0E2+LZJ55iwaIl7LPPAURBjiMPOYx9
+ 9t2fyITsvMuuLFiwhNdfe43d9zqAoQP6cNlllxKEsXX4wnmLmfjhVDJVdbzz3vtcceXl+IVWnnn6GdYs
+ X0dtfRO9+g3g6quuonX1ambO/Ib9jjyGYVttyeabD+fo448iCAJM5LHb7nuxySb9OfBXBxGFHiKG3Pou
+ Xn97IolUFUM225IvPvucvoOGctmV1/LF7DlsPW4cZ597Ltp2Y39DAxnXwSjwSgGe5xGYCEFYm1A84YQ0
+ KU1vleW+695A77orw9MFtqm1wYBSQt4oEiqMWRmi0I0NOBUWSSIKAVRGRaaeuwV7N2tKYRGRCCMOPep9
+ nr5+OGrdMtzAJuzyoBhbtOPVY6bOZ4ETscCx0KIRifkAQRDgOG7F/AXz/9TS0vfhhx9+OPmfnIs/ewI4
+ 7rjjBs74+ot3IqPrEFD40wYNG75pXWVm+ygMS7YoClr42tVoBLNgIbOnhgQ0oVWE9iK0L1R4y3nlilGk
+ TRtBscQdm8KlfQ2lDg+vzSLwFa5jiEo+3Q8bQmZoNVW7DCFdHVHrpFnr54mikEuHNvPZR0tYuaaSpLJY
+ lNA8lY643Q6YY2tsbeMqHesAfAfF+V4olLZ56ZWX2WbMKI4+ZTxHHnU42rU58oRjuHr8Zdx+x12sW7ea
+ U046mQcfuI98axsL583nggsu4BfjdqK+oRFLKwZvOpIhw0dRV13F3IWLAAiCf8SBGCP4QUgpikins7S3
+ rubSSy5lxNBBjBixGWIMYeCz5x67sGLlGu66/XZcy+HFJ17gw08/58gjj8JWgtZw/sUXc9ABh5FNZ8uk
+ FkMYCbfffjv7H/RLDj7qVLbZegxbjR7F4ceexCUXnsu9996NiXwuPPe3XHTlNey08w6MGrUFIoLvhVTX
+ VrPJ8GF0r6/n9TffZNDgoey4/RguvfgionyOVUuX8srzz6LReH7IuO22I8wFKKVY19qGMRFVFVl23WUn
+ zrjwUs495yyiMIb0RJHQu1dvrr3uRnbaZntE2SyZv5QlK1dhWzZTJk7i1b++gbac+D4J1NbVUleT4drr
+ r+fxJx6nb+9eoDS2EzIjGfGUJfRWdYTLCjz51FzEreKykY34QQlQ5HRENtTYXomBO/TFzqZI7rkVPVuS
+ VCQUYY3NiMolPH9KPVfu1EzJ93F1G6/fNIr0isWQh9LaHFYYokpFdK/+rHxmCRqL2VJ2JUIRhAGnnX46
+ ++69N2FkSCYraO/oOu7iiy9/8+abb/63tDN/SvysCWDixIn2G2+89aQoq973DJl04q6nnnpiB5f08kKh
+ 1Agoow3aEj5FSGqXDAneuvV+rAG/Jpq3jHBVIXbXNULv7HzuO7U/D22Z5OQeJTrWenidCfwOhSkJVr1m
+ y7+fQKlfb67f6SH+fPs02G8YppfFwnzIlrZFyxph6roKfFfxTMLioaTHt7bBtfRGC2/5XiFKRGEU5SJa
+ XKF2HJcXX3yBMPB46J7xfDJ1Gjfdeic3XD0ehXDbzTeilMK2LTbbbCSRBIgpMajfQNra2uns6CBSETtt
+ M5opk95k0oefcuZpv0ZrB8uysCwwJiIMSoShh9IKR2mQoAwsqcf3AxYumk+kLLBc5s6bS6+WHvTu04/A
+ FMikUvTt0YPW1naMipPK+jXLwQooBd5GboFtO/zlkUeoTCV5+i938+obb/D6m2/z+IP30KtHNx544AF2
+ 2GkcO2wzlj59++H7AVeMvxxjQmxL6N+zG8898yRWKs34C89nxfKldOVy7LP/vjFlt2zIgdKEXsDxxxzG
+ 1199xocffsazTz4NYjj9N6fiJhIU8x0MHzmC3XbbGYxFhIXjWAR+F0qBKAtRPplskp6NTVhWBmW7iLYw
+ aERZLFm+kjXr81xwwXkccdhhLFq2NG4UGwtb2byXsHnIKTLEqWXWm/OZNDPDjv1T7FihCI2Pqw09d+5L
+ /x1GMM+pYflrX1Nx5aWUjt6a2iFddB+kED+NLF3FJdsZxm9fx3UnDmEAi3ALisLCIqZdyK8pELTmsIfu
+ x7xHJmJ0ki+VHauhK0NoIoYOG8Ktt92yuEePbjN8P8RxXLpyhR3vuef+P/yn5uTPmgAuvfSiI9raOreI
+ omBd9+61e7a2rjnj2muvzc6YNWW+H5kXbNtOoECLsMy28VTc5mqb/DGrC4OIKntg12QRL4ilp/yQfTcr
+ cEBDgdwKgxRS+G0hQaei9hf1jHzjLCZd8T7vXT2FBlNHx5oULzw6i46gis+6uvhloo4POkM+SxluToV8
+ 6QZYyt6I6RYRlFYbC4yI4NjyVdq2fwdM+z4VtL19Pe+9/zFawW133MlLLzyHrRUTJjzM+vYujChuvPFG
+ brzhD9x+x31c/cfbueOWG7jwoovxfY9M0uWwww/ntLPO48SjD2X77XfEmIhUMkmffn059/yLeeDBR7jg
+ /Auoqa4m4WhGjh3LeZdexWOPPcZddz/A+rb1ZRSZ4r333ueV115lykeTue7qG/j7pIlUVmb4w1WX4zrx
+ rvKSiy7krDPPZNnKFRu9EhQWXfkib775NqIU111zDTfeeAMATz79PLnOdn79mzOYPXc+S+bP47W/vcM+
+ e+/J6DFjyNRW89U3c9hyi9FUJF1uufsBcl0d3HbbnVxz1XhOOPV3jNhsM84+5wKMhITKcMvNf+L3F13E
+ dtuOYYdx49Aajj3+eL6a/hWDBgxi+fLlXHLZ5USmSLoyyUfvv88lF13Agw89iNKxOEoikSCRSOAmEnFy
+ EQ1a49haLIWJwhAnmcBNV2zsKmxoHll2wMcJj/ttn352MxPfnMuCUpILt2vBFEOaxwxmVU09T/19HVPe
+ bueuw6/l/l+cg9nxDKxfn4xfyMWN2KRLsLaD87dLcVT3PJIPCHIFrLJNnM6HmJZ+rHp+BV57QKvtMCth
+ NrbhEsksvz7lZA454ui7b7v1htE9W3pcG3h+ScRi6bLlp5999oU/WS7vX4mfNQEsX77quGTSWbD9duO2
+ XLx4/psAp512Wj6dyhYcJwmiUSZ2m81pnyWOhYVFBS5THn0MvenRoASVcEB5UEphvgiJ2hSlTpeO9oBV
+ bT6VZ+1F9ysu5PE97mfxpDYcHBxlqFCQ7argmS/bCbOV5I3DvSrkFR3gWYLSThlxp+OVSse3xxiDH3od
+ VsIcv37typFr1y67s9LNnIiojQPK1gmefOIJJn84lZeee5apUz7l9Xf+zi233oxlu2jL4ZZbb+fQo46j
+ V/9ejB4zkqOPP4kJDz4M2GQTabbfYWcm3HULd9xxJ2+8+SrN3brhIRQLOQ497JcMHz6Q1etW0KtvL/LF
+ In+87GL22WtXbrvlVs477xwsOxEPRmWw7CTHHHkUEx57nK3GbcPn0z9n8823ZPbs2WTSGeYtXcbQYZui
+ rDRaufF71XELUjkpbr71JiZP/oApH33M5Inv88Fnn/HInyeQqKhkxx234bxzz+eGq6/gnDPOYObsb9hh
+ l91ZvWY1QcnDiObYo45mz1125KBDDufyyy7hD9dex3V/GM+777xNR1cHaId1nR001Tdw98038fGnn/LA
+ /XcxdOxYmpubufyyS7j4nHM44YTj2XrsGH6x1wF4vk+vXr0BC0s7sdYhNj6KOUsXgpOM0ROWwqBoqsl8
+ 8vuTTuzTp6X3FUnLWuoVPSKjic3mdbl+pLAsi2lJn/vcAkOtWl56YiajdxnAmO5ZrnzpKxb9dS21eOQo
+ EWAz55Nl3LDtoawNd0Cf9Ae8RB7s2JzWwYOOHFFXiJ/zYxJTPiBamye19S+ZPeF1LG3xkeWQ12V5NwUY
+ g6Vd6hqbpu+1117enDnTLz76mGMG9WhuuQMRXnzxmbP+E3PyZwUC9e3b98PhA4Yf9dd3/rrw+4/v8Itf
+ HfLxe397Op2t3PhYSUXsVNQc7BXpikKKzQnOnfky8tdjcC0bsYTS5zmSxQS5Ke3kC5qFy9rped+pRIkG
+ 3jjmZnQ+Q1g+s1cgVFguX9mKxxLCGlcwgcFYGksCNvjEbQjNBtcbobqyct2Qnr22e+ujiRt12fp169dr
+ bb5rgcFYceEt3jIGhRw4CazIIhIf7bgxAAcFEhGJQOCB0nGxSmsUQhh42I4NocSORK6LHxqIgvL5PD6j
+ YyewbAd8n8gEgBUjIu00EgXx/yirjE2PwHjE8D3QdgqIEGwkjLDSabTIRvzERp8FFH7oI6UOtE6BBhPm
+ UTrmvyv9nXawKvMiLMuO35sJQSVQtkZCD2U5KA3G99F2jLITpbCsBJGXx0lkMSiMKWFMhKVcJCqh7QxK
+ BxhCxDdYbiWCTTLhkPfCGGikFdpykMggfg6dTqMlbilHJmJA35bL58364mqA8ePHu5PenXrotC8/v0sU
+ lcYYbNtByrZnGoOnhIElh99LFQwSuu89nL1unEw9JS6zsnT6JdaKRgMuQmuqxFkP38Im26eQP18N7UWK
+ uSJubTWRD8oK8FYUoOjjV1rYp9zI5K1+i3ZrOccKWJVwy0fJOGzNt787445Nr7zyEP8f5sfoHUbNW7lw
+ worlS7f4N6fe/xg/KxCovb39oW8XfNv+w8cXL5g9c/iwYVVrWlu3tpwYZOOIog3Ywo/oBEyug+btd6DS
+ m4FVKhEsj51zS4vbkWLEyrUhfZ8/lyXTFvHmaQ+jgyoiBZGyySqDSWge0AWeSBDr6otB6Q0Ku2XHSL4D
+ tAjht+lsJp/L56v69Ox13gdTP3jz+6+5b9+WIW2dHSebcoFAiIU6Nxs1ihEjh9OjZ3f69OtNIZen0JUH
+ DLvusRebbjqUzbbYnEGDB7F44UL8KF4B6uu6cdIJxzH9y6+paajn6GOPYtbXM4gkCToBKuD0c85j5aJV
+ dHV2YmybE086mdmzZhFiUGHAvvvvy3Y77Uyfvi306t3CVmPHkkxlWbuqlb3235e6plp69+/D5lttxZ6/
+ PIipH0/+/9o77zgryuv/v59nZm7be7ew7LJ0BAUFpakoNiwgYokaTTSWJJoYYknU6NcSY4wmP2M0iUaN
+ LWpiiz1RY+yC2EClSW+C1F1Ytu/eMuU5vz/mLmInyu7GeN+vFy943XuZOXPvzJl5TvkcFNaHMhpgE4sq
+ Tp98FuMPnURReZKmhhYy6TSVvSo57Oij6dG7NzvsOJCdhgxhx8FDWLFyFSUlxRx59FGM2mN3hgzZkVRR
+ ERvWV6NVhAMnHMaB+x3AnLmz0VYUpSwCP8e3T/oOtRs3UlScZK99xlJV1Yuevaro168/th2lvmETgwYN
+ ZsguO9OrX2/69K8iFo+wuWYTYtn5rk8bZVnYkShahXWRSikck8udeOShZ749e3YDwLRp04LVa5bPi0bj
+ Y9wg2GXXXYe/Wb1hfd+IHUEIS5otNJutgBl2wD41cfYZ1I1VDfXMSQuveVmGOxG6iyEnOuyw9G2efPwJ
+ SisGMfCM7+IvmUKiLIrCw2zKoNOGoCEbzi44YF82zm6ledq7rIqU8Jgl2PqD9Ugu2xqMHjn61Hvv/d2y
+ j10fG1bXHDXhyOcjiUi6urr6sye1flUREbt3v51eSZb0kpJufaWktI8kS3vLqU4PuYoy+S223HXikZJ9
+ +TwJrthZWr7TS/zz+kju0L6yao/u0jb/9/Ly6XvKNaTkNt1DblG95WbVS+7TveXyeG+pjBRJLFUhyeIq
+ SZX2lOJuPaW4W5WkStv/9JJUaS9JlvTwUqVVvwXiw4fuMbUoVSFDh44c+lF7f7T77k638op58WQ3SaTK
+ JZEqFycSl9v/ek+Yq/YDMUaktbVNxuw1VpSy5Z6HHhURkZzvixGR+fMXSqq4VHQ0KfuOO1RERHr06C+7
+ jAjz2xMmTBJtl4qyS2T8YZOkpbVVUqli0XaZVPQeJA3NLXLMsd8WrIgoZcurb7wpIiImCHPrIiK333m3
+ OIkiaWhq3vJa4PtSvXGjOPGkRIoqJJqslGiyUmKpStHRhEx9fbosWr1enpj6ltTU1snDDz8ugBx3woli
+ jIhvjORynmQzOXl+6quCduSQwyaJiEhzW5ts2FgtRkTuvudeUcqSo48/UYyIDBs2SrSTEu0Uy6gxe4kR
+ kdGj95RvnRzWNZit8vnX3nCTgJLLfnH5h14XMfKdk78nxEpFF/USq7iPWCV9xU71FivZU3S0TOxoiT9y
+ t90+MY/eo8eg2yLxMtl1yKg9Ruw66rRkUfemktKeUlJaJSUlVVJaUiVFpT2kPNFTrigaIIuP+I7EIymJ
+ xsrEsZPy/WiZ/E6XyUWqTC6mTH5FsZxOXP521mkS1N8r3r3DxPy6t+R+3ksyP0pJ3cEJqT0gKi1TrpSH
+ Rw+VF51ucmiiUmLFfSRV0kuSJT0lkaqQvcYdcmZHX2OfRJdXArajlPJv+MONZ4v4COGd2Segl+VTrEBI
+ UTPlHayKPviL6nCSCbJL0tQ6Nj3v/QXPnnkLb9+9giKiaGOAgFLb8ISd5VrTRKOdQgI3v+jJT6oxAGHQ
+ SIkhULm3IlbbiJbGmkuBTGumDaV0S0VFyce88h2zZnn1dbWj/SB4eusK2HRLlrXVNZRV9mOX4aNwPZ8/
+ Xn89Ij5eLuDladNJdh/I8L0OoLyqBxdeeHFerFMwxpBzMyyZt4jZcxdz0slnIGSRIMNFF13K4/98gpbW
+ NozJcv55F1KUSHDxJReB8dFWlOO/9W2GDB3G9NmzuemWOykp78E5Z/4UL52hubWNe+57gO5VVZT1qKJv
+ /x0QbMir4SoMYjz232dvxu27N1f9+kaOOfggBg0czOk/PA2lLSw7go/Qf8hQyiq7U9K9gsMmTEBHEqh8
+ vGT8+EPp1XsHLrz8ck777qn84IzJPPOvJ1i7Zh0/+7+LMMbFmCw/O/9innv2WWbPnsWmumYEGDxiD3Ya
+ uis77TKMyy66GB2J8+68ebS1pRk6fA+GjhjFu4sX88c//I6oDht2lBgk8OiZshf1LUs+N6R32W9POGrC
+ 8Lnz59/ySedZPB6tQzRN6ebMuwvm/HXUsF1G+kEw0/dDFSEfhRJN2jZcTRt3vTGXH/fcFVcMloZ7gzQv
+ aY8qyyGcKWjRnxhv3/Iot3z/L1iHnweDK2ha24oVWFiBoS3nk0tWsWTuEjb7WX6SLMP20ogyYTWrEQb0
+ 6btg+15R20anO4BHHnnEuu6664o+6b3LLv/ZT5QRtAi+UgxLZ/mBE6VBXHJK8Dc1simbxQQukTaXdGWC
+ sivP4K9H/oaVrzeQwCGnDL6GUkdzK2086bgoy6HKtHBij94fU3EVACVZMf7P0g11e9fXty5qfy+bzSGi
+ Fk+bNu3jUzFD/P7di88z4kv7I7TWGm3p/Lpd4QU+ffv2ATTJoiISyWKG7joEJUWYwCceTyHGEIvHMH4Q
+ ztezbB568AGOOXYCpSUVHHz4MRx0wL5ce911YDuUl5fx4x+exGW/+n+MGj2KI4/6BoEW6mubWbZ4GZFI
+ hHRrK5mGRgIJW1WDIGDffffj//36Wu687S5OPOGksCglP6SlvY5/+fL3mDt3Hg/+5RoWr1jKBRdfSjxe
+ AiLYto2F4k/X38Dtt97Bn2/+MyUlZYgxpFJJAA474kjGjh3LxIPHYwQWLZ6Pl/P58623ctJ3jmPAwJ0Y
+ uNPOfPPYI/n9db9Ha4sgCNfhl//8Ks768Tl867gT8H0fBaTTGeLxOJ7nsWnjRiylKC0tJR6Phql+49Cr
+ PLX0DzdcN/z9tcsnLV658ucPPPbYok/5vYjHEw0Kg+v6bQCvvf3aqraWTXulksnrtp5XYSlN1La40Wtm
+ jp/mx8X9wPhELYdXVMDfyNAzEsECAqCEOCufWsJN3/wz/l4nUHrQcBpXu0Ri4Jd0p3pRC1nj8J7ASD/L
+ KdEonpF24SJmvfPOKZ913XQUne4ALr744lt/ecWv1k2YNGnfrV+/5x//KF+/vu5kKxpBlCbwXc5Ppgh8
+ lzoUWoQqoGHpJoKB3cjqDLFvTuK6I65l7SpwFNh4RJWDiUa5WqWZG09iicOBUYv7Bg/m5ZpNWLadT0Pn
+ p7fo4B1l2nZradl8/UdtdT0fhbz3WcezYu3alUpZTUpZgMKJRehVUUlD3XqWzJ9NTc1GzjrrJyil6Na9
+ nD1HDmHWq88x7+1nmf7mLH5x+f+B0qQS8XxWUbBsmzvv+gsiAVdd/Ruu++1V3P/3R1m0cDEYxbnnn0tp
+ cYpHH3uKJctX8MvLr0B5btimiyEejeAaCYtM8o0Lvh8QidpgBazZsJqFS+bn79reFiUlUGzatJndR49i
+ 3PhDeeHF5zj37B+xaMEc4oki2rJZFEL9pk2sW7uWVSuXkctlsUXh2BGMMZx1xg9449Up7DNmD/Y/YH9m
+ vPkWju1w66230tzUyO233c7vrvsDC+fNY8or09A6tqVzsDTl0KOqnF59q8Lgnlg0pVuxFCxZMJvqtWvY
+ eafBnHTyybS2ZdHKQyRHNJpatq3KOcniYiv8oq2tZ8ybmppVF/WsqDoE36sJY0Dh92HbPq+3VjM83cpT
+ VQOIBx7agiW24g+mmUQ0TpRQ2zKqfNa+uoY/TPwz7l6TKDpmBNmsR8XxxxB9bw0WQpN2eLtxEz9IpXDc
+ LGBwbIu62rrjrrji5uTWtg4YMOiP3bpXvjFx4sQh23JsX4ROdQBnn3322DXr1p8hyi5dMHfuhx7R7rjx
+ 1uMD30sioTDzzvjsbxRLcIigKNYRfEvR+M4C1OiBpBM78OTkJ1i72aGIGGiFoy2yMZvfk2N1rIicb/hx
+ nxS3DRvKj5a8R0M0Fk7MAVR4y/t1a/3GvZubm1d8kr1Kgeeb5Z91TKeccvwAY4JU+HlFIhGjubmZPfce
+ y8DBuzBit9149rnnQWlKS4p54OEn2HHwUKprN2MrjeuGkfuionBAqWWHQbnmplbuuONuzj7jVIYPG8y1
+ v7saZccp61bK2Wf9mOraWma++QKD+vdlz91HcthhE/MXkpAsKsLNhZkNrcOUl21bTH31Nf70hz9x9x13
+ kW5qA7G35NLD4GfAsF135sxzzmLunLn8/MILWf3++6SKUziROJlsFlGKu+75G7fddTf3PPA4Jd374IuQ
+ LCkFpRk+YiRX/Pr/EY3FiUVj+dyFprWljZtv/jMTDhrLcUeO5/rrb0CrUAwEHfbP/+S8n3DGGT/m/PMu
+ DF/W7WPBFeMOPpip06aRzeZYMH8+7fFrZSly6cb+23oOlqSS9SjxIdn20fdWrlk0pSpVOly5/gv4Bi3h
+ BRJFcaGkqWv1eGbQUBzPB8tjsxPhDyaL40RIYuFIKNxavSzDVYdejzf6QJIn7UJi1950nzOXHbAxRlhq
+ oH8mQz/RWwTt05ls+ex3Xt6v3ZYjJx45ds2adee3Nfn7zJk7945tPb7/lE51AFVVVRtsrbIm8DDGNG/9
+ 3oY1758QicfQYsjhcaxVjCcuz7tN9LU0NdqQJkr3FWtJz8xy253vUlrUj16BT1IpEqLYEIlwjcmwOQJZ
+ z+WSnYr5ee+eHDVrNmsTCWzxw4yYMes17N/SUP1LtlZy+AglJaURz7jvf9YxLXp36dEK2xJtgdIkk0VE
+ oxZLFy5g7ep14MTD6jQ0FWXFeJk23n9vOZde9kuOOeYwLr7oYjA+ZcVlaEsTjUQB0JEov//9ddQ3NPHw
+ Y0+xZOlSVOBx4SWXUlpczLj9D6Cysj+l3cpZvGIZV/36KlBCJJ6gtLSUIMiGRTGWwo5EKS0u4fsnncii
+ hXNZuGAuixbOo3tJyVZHEl6E3UrLuPTSy6jbuIHNm2oYNXI3fvWbX9PSksZS4VCUGa+8zPtLF7L2vYU8
+ eO8diJ+me2UFWsHgwTvxm1/9iulvvsljjz7GmDFjwipB5XDLLbfS3NLKogVLePjRR9COjVaCY4VOb+XS
+ xdRtqqGhbhP33Hs/JshQUhymhlOpJCd95xQ219XyzL+foUdFKUopLA3Vm+uHn3baGXttyzlYWVnRLEa1
+ bNw47xOn9a6oWVHbmt08USl+riScwa4AbWtOyzYyv6WBO0YOJXA1Svk02gF/ppWYY5HMazgEyie93uOK
+ Y26jrd/BqJaFqAXvcYhdhkVALZrVbS2Mc6xwsIpoHDvGwiVLtszA6FPR5z3LsusCSxDRHRb573RBkD32
+ 2OMbDQ0NB51zzjlXnn/++Y0ADzz1VPcfnPjdtdF4UUwkSom08ahO8nZbHa0B+B5kgYMHwPATRnPXdW8g
+ pgQPj77EiCjFdEe41/IgovBEOL5/Ob+tKOHYNxaxIJEiIuGgjUDkeQJ9Smtr9ebPs7Vn3yF/rl6/7jVM
+ 20Of9pkePXr8v7as9XNlaQIvwyGHjKdnVXce+PtD5HKhDoAirDH44Rmn0taa4cEHHkAhfH/yZJKxOH++
+ 6WbKyrtz6PgDeOpfL5LNuqG4pPEZtcdoNqzZQG1dAyI+w0YMI2pbvDtzHpYTIRCP3YbvSs+KbkyZ+gae
+ 5/HNY47i3fmLeO+998HSmCDgkIP2p7WtlUgkgmUpHCfCK6/MwA/8LZWPAIEfEAQu/Xfox8677ExjYyMz
+ p8/EcRxSqThDdxuK6+ZwIuHQT9fVvPnmXCp6xBm04yCWL1pOY1MLsaIYhx9xBI52eOD++7EsG0E4cMJE
+ Vi9fxqpVYSmIhUVRSYIx++yFl8vhRCIUJYqorannrbdnkih2OHbSRF6eOo2aTa306duNs886m2efncq0
+ adNQto3xA3pXlfxt1XsrTvu83/SMM86ZdO+9D/4hl6v7WGbno8RilWMjjnoEpfoQnjukA+G6gZVUK5eb
+ VmwkamnEROluXH5mHHJuljo80qHSLNEeMX5x1UHoNzZhP7iQv/suM5ViZwmoKKvgdM8latkoFImEvWDD
+ hvd3a9//7kOH7reupub/xuyxxwX/euGFT3xK/bJ0uSIQwD4HH3zK7Olz7ovGk3iB5nsJmOxpHnQb6OlZ
+ bMz49CrKcspvxvG3X75JQ1uSiAmI4zJCKV6wk9yYcIlYNiqAlMnwxEwr1vQAACAASURBVN7DOfmVuawt
+ TmIb0KLAuFc0Nm+6alvtSib775zJNA0OgsanPu0z8Xi3b0YSqccNJtQzyLYhRqEtFU7ozccGRGvCBxDB
+ ijgoCfDdHGBhOU5YbOOZD82q34JImPNWCp1fL+t8DENUuF+MIEbAUuHkbx0GJMWofIDPhI4IQSkbwQ8l
+ t4wQaPJ1AOF0o1CT0v5gHp+SUFBEBEvbYSGQ5Ldr/LyJ+b91PqOuw0YmEcGydajcRjgYRVv2lsCjUiYs
+ Q95SixFg8NE6HI4phHqAOt+bYUQI3AzaiYZDSNu1GbxM0y/OuWiHS6+59BMHcrRzzcXXlFxzy7VHN7bU
+ b5PgZopUuUom70ObSRCKk2Z9jyu6V/JMfQuzlYTKzcai3HW5VDSNXpp6wMNgCOhR7nDRDadS99P7afJT
+ /KGtBUtczimuYJzvkovY2GIIfNe/+JJLB/ziFxes3xbbtgddrggE4GjnN1mXIQoFgcs13Uqoa2nmpWwW
+ 2zNExOX7Z+/JS39/F7c6ghYfCOitFNMjDn9xJJwnL+GM+29XVnLlglVsTCWwDQjSaAUc19hSc+d/Ypfr
+ Nm0Wya4CPjXAdNxx3+o7f8GCU23HCS8IpfOjxsI7f3gB2fmqtbBoBfKPlZYVvqYUWun8SR5utz2joJTO
+ 9yO0V+uxxRmgVL70N+xTDPsALCzL2vKZdg3A/KxpbKXRhGvPQIWptGjeSRgTymaJzg8Jzf8/I2bL/1eE
+ 22xXYFbk1YDzUmOSPxYI7besUNJbkT/GfIxDt48Mt8LXt/Qi5Lez5bvLb2eLWJhSWE4EbWmCvEtTgJ/L
+ xrKmbcXqNatnf9Zv+tIbL+WybubdbT4HcDM5t/UBx0lklZGDRSllWRYvtrWxWyzFegklyC3lk9YOb+kc
+ B+kYGePjAq7WNGZc1KY6dpo0jLY3VvC+KNYgTKwoYVqrxyYn7Hx1czlt2c7UFSsWfyzt3FF0uQN4+OE3
+ 4w89fO/NKiwRo0ILFyccXmxoZVVgE7MiHL1POS0GVrzeAPjYCCVK8Xo0zt9igrKs8NSUcKzWnNYMbjRM
+ 0aD0ciwOampc/9YXNPEzo8va0tc1tqR3sS0L3w8I/ABjBI9wbRd2Exp0vu5c5aW1JP+IGE6xCWifT6dQ
+ RmvtoXSbKNWoUJsFamxktW3ppQYptTRxrSCi8+q5xoTlxtKukKS2jA+rIEapMfT0XLpZNnUmwIgw2mQ5
+ IBcwVIRJ3YsZH3UY4XmMFKGnb1ibV2ouCmC0F6HS2MREaLPz9et5/T7Xc9FKh5JlCiwUWoc6DZay2rUH
+ g9LS1AzbsjbYjspZlpWORpzabsXFszWWJ6jAUiptKyunjfFzxo1aKn9xi0KLwgoE0UFei1Bh+4YdjUeD
+ djDKI6KjpDPNA5qamm6/8sorv+BP/em4bvoNxyp6WWkmKayUo23e8738E1W+Y1QLWeUwxxj2shxM4KEk
+ 7D1YsmYj447YnQ3z3yOWiVOjAoodi6JYgmm+H+oBakUmnWlubKz993Y/gE/B/vyPdCzPPXffvrlcujgW
+ T+EJDLMhZ2Cj5zNeR+nmpNl5j5E8eP0bKJVABLorjynROP+I5wUuUWxRqQasfB5eB2aKqLbjmuubPlZ+
+ vD145pkZxSedcvREx7bxPY+De0Q5KlXJ7PdrSeU0GRWQlSxlnsM822Ga7aE1KJRRYv22W8J6uluPbl7v
+ 3r0zfbp3z0Ss4oxT6mSNMZmbbropX9gfksv/HS8uuxflnBpoRZ+SbiiBNU11KCMkk4n3mlvb5mptH6d0
+ KBAaN8LwjE1GBZTbRazMNuMqw1HRGPtkW8jqCHS36eV0Y8OyNqKOJpcq48VNtWA77G4UexpNtfIpTZRw
+ u9+MskMn5ns+++2/f/DGq69ZdtRCKY2twu9eVEDE0pQVpeb17dXzZ69Pn/7yR7+/jwRh1O233x4HnN/8
+ 5prnNm1u2FvZDuSXEOdFezKjeROboxFG+Zp1McNVxRF+1ZzmVXGwlEVdbePw7538vf2BVzvi927N1r6R
+ 0N13t7V+TLTsYylrS6t42G4hiGWo0za3GZcfUoSTy6DQtBDj73e9wokT96P2gdfZSUWY27yZCYN35epV
+ KxEngW1FSKfTB3WE7Z9GlzuAF16eeqC2Y4BFEBjGlkVZ2dJMiVb0MxnGnbAbz98/A6EIJUJCBbzpRHik
+ SKOF/Hz6rVDhUEWFvqOxecOZfEaU/8vyl7tvPjydbktEY0l8t5VrTxhH/SMz6OHbLPcD3jc+ZWKzPKZ5
+ U3tYjo0xfr1n1PFB0/qp64H1m9Yzf/78bd5nxIrOQyucfA2JS4CFwjUBfSvK7mluatmAw3FgUCI0IvSR
+ KIsjUXoqlxLtU2cCiuwYu0UjrMEhjRApc0hFIaYtVutw7HjM9dgnVkJd2lAiwkbt4VqC05470sK+I0ZM
+ fHv6609pVMLOLz1CMVCNFwQUxaKXf9LF/wnI5MmT0wDXX3/9pN9de8uU+qbaUdqKkvE97vI2MF6KcSXH
+ 8liM3dC0mGYu3bmc1+esx0TAjiZ4Y8b0H9FBDgAgnd5cDRyQTFbeYLSc0+4B2pcr7Z0hDdrib47DpdjU
+ 5JpoIcqrq5sZPy5KvNJhj0bNk65hpAT0Nop6Hd7E6pvqh5x/8cUjrv/d77Z5mfJl6PJSYAkyE5xI2JCh
+ MRygEyxoaKPUitO/Z4Ka9c1s3KyIkiOBz0Lb5tGojWU+GJn1sW1irmhu3DCZDrz4AebMmfWtSDSFKIt9
+ dqhgSHmOHXYtJ5fxWOd79BBDTcRhiq3CQJ+S98WKjg2a1k/9ovvUsMBCobQmk82SzmTzj6HCfvvs/UgE
+ M1PTHtTTpDVgacqNz0DRjHEcfK3IBDZFEUWlBcWBS8yxKRNNqRJaxEJ0guHK48Le3SnysuwihrbAC+MW
+ SqG0IhaPNuuEnl5SnHo9rK76cFehUtq0pNMz/9NjPP/88xvP/d7ph5QUFb9jTICtLWp1wIJYhl1dhx45
+ Q9L3GFhRyT67xjk4Gv7QlrbYuKnuG3/9619Lv+j3u40Era2bfoLJnYUEwYfPQYWocBbAZu1zOwGldhGl
+ 2MSJcP0/X2bYj79BqizCzk6Mhk2bmZQqxsuXpWtt8+LzL47vYPu30KUO4Lpbbqmsb2gbrfJa+VXap5fn
+ 0iQK7TfRa9TOvPHSShxxUBjWOzEeilu4dnt7LOFcvrzUttFGlMjk1sZtj/R/Uc4///x4fV3DBK1tcrlW
+ Thu7M36uHqnoxkqvhSpslsQiPBHxsbRCoxYi7OtuXvWlAjzGyNJ2z9fiZsi6YbtvKhZdetttty1tTDcu
+ sETVaQk1+40CLIuexqGX73FYSXeMeFQrg4rZxGyfuB9euxGtiUdtNmayKNPGKX17EmiPIuXRXTQZPx+M
+ FAWBIplILL/yyivTqVTJG77nfWhAplYKS9TStWvXbvgix3npNZc2XHDBWRPKiuJvinGJKotFxmVRzKM/
+ GeoDn1dX1KAjDv934EDIhUNefd9LPf74c4d/me94W8m0Nt6qAv/IwHMzlijav3MrX0CkFSyMCdN0hH5K
+ UY6mvjVg6svvsKQsRd/Aoa6pjn2Kiwj8MIsSicRpbmic0Bn2Qxc7gH8/8cz+YjxbxOApYTfboa25GTHC
+ sP5VLJu/mpwJq63Tdox7ogFZK/+g9dFbvxFXBeb4pobqDqua2poXp756kO/7KXRAN204ul8EL9KHl/86
+ m5Sd4t1EjGftACcMZs02nn9Apu6LXQxb09S0cbVG1QFbquS0gFZqWv4jgRI1U+UzA0hYiRfLp0IPLy+h
+ 2A+oFRc7Eg3LgUWwbY2lFUnlsMZvpUgcDigtRTyPUnGI2DaNOp9yJJQoS8RiSwHKy7vPNyKYrTKY4VOA
+ fNHAKwCXXHJJ0+W/vHhi99LSVyQIiFo2b6o0b0ddegWwvFnxxlt17L1zjFGJGIElxOIlLF26sNPq6tPp
+ hucG9ut9aSad3vLdbE1MNM87OZY5DuUqSh9J8O/XlzK27w5EVYaI5zLAjoTL1nw2paW1bc/bb7/d6Qz7
+ u9QBrFqx/DDLzpeLBoYRiSjrMy4x22Ngn34sWbUWo2xEax62YZOdH/SdnwAE5PPIQcYyHNHUVPOPzrJ9
+ XfXmYyKRKIExTOhTRrJXP6Ze8wIxVcz0IodndBOWEhQyzbay45qb19Vvp10bo2QR+QoyCJ+etGKLXoFo
+ 89oHHxc8ge5olKfom2nj1GSKmkCwrBgEBicICCSLpSBqK2oDixGOsFPMoHyfpGWhUWwkk2+mFLwgR2lZ
+ 6mWAkTsNWmHrMPjX3mwlKHwdTPmyB3vOOee0Xn75xUdUlJe+4JkcMeUwyxeet3P0sh0enbmRTWttTtmp
+ FOOFy5716zccdNtt9/X8svveVhYvnf+n/fbf84diPHdrL9j+XWlb85gVgA3leJQR5d8L5zFgxC7EJc7g
+ 5jRJAZEw7tvWmu62bNn7HVb/vzVd6gBymcyBlm1vuVMNtTSNns9+g4cwf9Z8HBKUiOE5WzM/HsdBg2yd
+ uTQQBK2Oow6tb9rwUiearo0JJiEaP+NxyrhdmPXgO6QzCZ5KGP5FBkdboOTphob1E2tra1u3585FgvnG
+ sFUxjfIDgi0XfRDIm+3/Vkpo1dA3sNgQ5Fi6ehMX6yIurSjFxHzEhAKrirDYB+1yQKXFH/cfgpsR5rS5
+ 9HAsmm2bhvwgMgEcbTFm91FvAuyyx4hVUSfSCuTbrMMlmoWzXabbTJ48OX3JZRce27tnz2dcN4etNXOU
+ zz12jl7RUm7+10IO7bsDTr7dW1CxO+/8y7e3x763lVemvHjXpAkTJkUcp0b8IF9HEf6xlKI5qng4qok6
+ UcqJsHJ9LXbfUgJH6KFchtgKPxxzi1KKaa+9Nqoz7O4yB3DznXf2r2toGtQ+VTVpB/Q3PgnbUCU26VaP
+ CLDCSvJ6XGOrLEZZWzrXwuK2oKWqT48JtdXVr3em7b0HDN/T9/w+Rgt9E4YRiQrenr6SO2z4p8lhacGg
+ /1FXX30sH2TwthtGWTM/PIpO5lRXf1DabNv+TGNMXlZK0aI9bFtxrTbc6mZJNWfYp6aJzIY2JAcShGPC
+ cm6Anwn4waAkO75by4XvVnPUxiYSsRQ52yKnrS2R7qJ44r2bb755KYR36Wg0OjeQD2KuBrOurm7Ddito
+ mTx5cnrZsvlH9ulZcVPOTRPR8K7l8aRO47sOC+et5ODSBL4xRCNxGhs3Hvn5W92+PPbPh6Z897vHjU4m
+ YzMD30Nt9TQQEcVqrXjNcai0HEqsIp6eMY/UoJ60taYZbTkEfqhRYTlxajdVT+wMm7vMATz698fGKoxS
+ eYnoAdqhLJNh8C5DWLNqMSVicO04f42Gun1KaciXrEoowtc2dp+xhy2ZP39GZ9ve2FB3lKM1Oc/l9JFD
+ eeGR13gglmK6HxALE/0PNTas+xbwaToCXw7XnQf5J4CwEvCVrd+uq6trAeZC2A1sK83suM/qqOJu2+JB
+ yyGTU9Q2Z2ndMnTUx3WFbCs0vFzHtDbhL8qlOebwaNBKLPLBk5cxhmQ8MYethiREbGt+EIQ1U+Hvw1tb
+ v7+dkGUrlvx0x/4Drs1l00Qsi1kqxxvRHNPWbOa70TICLyxf3ljbNPbFF18s+fxNbl9uuOGG6tNOO/PQ
+ 8vKymb7vsXVlt6NgmjYsTSQpE8P6jS6upfDTWcbGiwhMAIQipW3p9DgR6fDrs8scwJKly/ZQThxR4TTf
+ EVEw4hEpiWKlBcuOc5cttEQVNoIyDoiDwQHl5/bbe/jRzzzz5Jufv6cOQHNEAOggzYimgOsb08wmjW0r
+ jInc21hfcxIdmIJsatq8UEQyAIFALGF/bK0thrdAg29Raiue9nLYlkJiikv8Zt5IFKEiDoEYgrDpjQBF
+ TS4gKE5xbroJKxonYWse93yC4iSasCw58Hy6lZV8KNfes6pyoZ+v/RcECfxXOur4Fyyae/HAAf3PSafT
+ ErEcZvqGf8cc0rUeQ7FxLYXrukV33/PQAR1lw2dxzTWXNpx11unjK8pL3/SDLHqrU0Hb8IjkwElRBry4
+ tp5E91JGeS5Fvt4izNLc1NrnvPP+r8MnBHeZA1DG7GtHIuEtwghDcwFVuw+l+p1FRFSKh5TDnGgEqz3Y
+ pSRsfDFtwaTDDz3x6eee25biku1Oj8GDd0AY7inYO1nCLcs3sDASIWpZiDZ3NzWt+R7b/873UbIoPQ/R
+ aIWXaWn5pKegaWFkPsd6MaywrLCOHo2biPG7TDOObaFMgATBlmafYhzu9QI2xBPYykUri3orYLrvEg9X
+ tgiGUbvuMmfrne21316vbJkQLCC2TO/IL2DJkvl/3m3nHc9ws5nAtm2W+zluNk0cqGKICE48wZy5s07u
+ SBs+i0suuaTpzLN/eHhJquQtfyulIYBmO+Bh22CrItY251gfsRjgp9lBuR8MWVeaqVNf6nAH1iUO4Io/
+ /am4sTU3wsJCNESN4cDyMtavrsXPCm/aNk85AU6+vjz/oIt4LhMnHfrjB++//4musBugpTE7Aa11JDA0
+ 5hxewMNBE6Dvbq2r/kFn2WEM7yitUGLNbWr6eKmzUswEBG0xQ9IElkHlS1cdgXk2rFbhGPIgECJBlojy
+ ocjiAdeQsG0sFUO0he1Eeaa5JUxwiyYSjXhDRu76IdmtG264YWFpcdES0BhRDU2bN3d4JdvcebPu2mvM
+ yO8FbtqPKodZ2mOm51PmK2xlsalm88SpU6cmP39LHcMll1zS9N3vnXFEqij5XhC4oEKRkYgo3rYU78Ri
+ xFSc52rTFDkR9hUbLx/YtSNxmpubxnW0jV3iANYsWTLKeLk4CEqgDy6D4t1YvHQNLTrO7TpDLqohXx+I
+ sshlWhl/0AGXPfLgg/9RR9/2RqGPbh8PvtD42MpGib6rrW5tp138ABrrNYWFwvrEZVBjY81qYKUC2pTZ
+ IoYKNkpb+GJ4XQs24VwCx7gkdcCSwGdDRG2p9rOVxtKaTcrDVeFvkozH1lxwwQUfa7uNR5Mv+l6ABOYd
+ Oir+8RFee+2VBw7Yb59vIV5b1I7wdiIgoy1EhLbW1tK/3PPQIZ1hx6dxzTU/rzv2uGMPtS1rPfnqVQSi
+ wLM6TXMkwuZswHLJcURRAuMHoVCrVrSls9t9DsBH6RIH8Nqrb43UloUgBMbi4KJi3n1/DeUqyb+MZmUi
+ gSjB6PCUzWYzjBi52+3/fPLxq7vC3nZ69BheJL450CD4WFjKgDJ3tTWu/mHnW6NngBitzSuf9gnjqZmg
+ cEzYMSgixBG0FsR2mC+GjFL4YsAVtIowXTSWE6PCgvIgIDAGJSpsC9aCbzwS8eh0PmGZs+PgQa95XhbL
+ kg6rxf8kXnjh2SfGjNlzLMrdpAFfB4gYrEiUOTNnn9CZtnwSt956w8pDxh90lBE/VCFS7YNIFI8pnyqt
+ eCUn7BGLUuqHmhBKKdra/H5XXHFNv460rUscgJtNj7EjERRCgMdoK05TSyu12uOJCETxaS/187ws/fr2
+ ffmC8396dlfYujVpv+FgFQQJZYRQ/0P+mmlc3wUXPzQ0rFxjhGVp4Z1P+0wyFn9x6/WnUYqBRnFoxEbZ
+ AauNH5b2WBbZDLRZEVbk0mC5HG/DISqUJ1MqXJPaWLi5DEOHDvvEassJE8a9Fvh+rrJbVYeu/z+Jl19+
+ dv7+++43zhZTEwRhi7WlFQ2NDeOmytQub3p7/PGH5uy5554/yqY/kCJUClY68IKlqA7ipCyHYUoR5HO8
+ JvDUvHlzd/u0bW4PusYB5NxhWtsIFvHApVdOSCrNPWLRHAMj+XR/AMl4bMW5507+1raqvnYkRvgGKoxI
+ GGPuzTZXn96l9mB+n6lfV/1p71/2q/MeLkvGZweBu2X+UY32OCIRZTeibJCAtOVgtCJrWbQCtaKoRBhm
+ x9koFljhxCNE4XvZYJedBl/+5JOPv/ZJ+7voootqhg3d6Y5DJu77fscc8Wfz9NP/WDLpsPEHWOKvlSB0
+ 0ps21fWad+uaDr2ItpUpU567f9BO/W713LA0RKNwlOJFLWSAeW6G0XYEMXl1JB1h7tx39+xImzrdATz1
+ 1FOJ5pbcoHbp5QpLU+xlmKMdXndC+e/2u38QmMa999nviLPOOuszZZ46CW3ETCAwYMwDudbq73e1QU31
+ a+7iM9KN55xzTuv1N14xIRmNrWqvU69Bs9b3GZ+MUhsY6rBwjY0SCIyhVmCIFcNGsVAa0YTrsFyulUPH
+ jzvl3Xff+cxR1e/On/vTW2+9deX2PdJt58EH/7b80AkTxiHBKhMYbIR/Pvlkl6QDP4mzzrr8okTcWQJh
+ TUvUKDK2YkYkYE46zd7xFIEJ5yREHQchO6Yj7el0B7B48Xt9XTeTVCoUWRxiDMo3PGQEFQ0HT2gUnusz
+ sG+v7z/xxMOdJo/0Wex32FG7utlcf4GH0y01p9Lxqb7twgknnFG/y+CdbnJzGRSCFpsZWWFkJEpE2dTY
+ Cj8QbA888dgcuIzRFjUmx/ogLwcGJJOpugkTDvlUbcT/Jh577P5VY8bstn8QmMW2E6N63dpOqarbFs45
+ 59ut4w898KTAZLIQaihGsJnleyyx4ozUAQk/P8FKKVrbcv9bS4C33pq1i86n9QLjMVolmBIYlsVBdAAK
+ gsAlVRS5ev7iuU92tn2fxtJZCyeJ+P9Mt9ScxFfk4m/nOyd88ymUNohCaZjturQZYVdHscb2SGOwtKFJ
+ WWQkYFTUYbYvSCjnhzGGVHHq7XbBjq8CU6ZMWT9wYOV+xvdn1Gyo2e++++4r/vz/1Tk89NBDc3bdZeRl
+ 2Uwm1EvUEGjFk14Lds6mbxAu2BTQks72vummm3p1lC2d7gAWLl6wt7ZigEIFPoMjCR4gg7ZsrMBuF6V8
+ bWPthss727bPwrYzO5ts4wl0sMhIR/Djc899r6K8eHkYfRYalWZh1mdUtJhmA7m8onGjMlToKKXxbsxs
+ y+Co8PTwfZ+iWOKZLj6M/5hFixbVDxxUOa6pYdOUO+68/6Sutmdr3nrnlT9W9S5/0g9cAgwOinVicS8+
+ +6s4ngkAjfiemjNn8Y4dZUfnBwFNboRjOyBQoSyWZHO87+SlldFo0ZuNK9/hv+hCO/7447sNHz78SsD7
+ 3A//lxKLFc3xPW9LOcDSnM8gS5EjwBVQWNQbl+G2ps24rDStoeBoPlYzevSIL93a2xUsWrTIhdwx6dbt
+ 1Y29/TjpxNPOsLTaoPJxr5il+Ytfz6BoSSjzjqCUw/yFCwd2lA2d7gBa29wqrDDM30scHvVdIlYcpUK5
+ 6CDwf5jJ1HeaLvq28Nhjj9U///zz73e1HV+GyvKqqb7nA6Fc1TLjUxoJHzMNYaNVg+ewrx3lrWwzOR0+
+ paEUiUR808iRQz9zRuJ/O7NmvXNbV9vwUX7728tq9xi5+znZbAajDKIMm7XDOqMpMRaBpdB2lPqGhkEd
+ ZUOnOoAZM2YUt7RlhoXV5D4tWlPjBKFslVagua21ddN/zbr/f4lJR3zjNUPYr6+Modr3qbdsynSENhtc
+ MWQDn6QdZUZDMx/oNAjFqaK3zz333O3e1lwAprz63D/79an8lwkEpcC2baYFOcqJ4WuFZdv4nv+/MRz0
+ 2WffsEWUhVHYotmgA2if/iKsVtJ2SWfa83Xil788f3FFWenSvFodnoJ5AXRzNK0qwGhFFI2OxFjsB0Ty
+ 2Zic51NaWvJiV9v/v8yEIyddoMSklbKxlWJZwqPO8XGMRmmNH/jbPPz0P6VTHYBHZsdsJpPXjVQfqMgC
+ gXFPa2hoaOpMe75uJBLFU718ZaBlW8zJpElGYnhaCJJCCQFZ8dmsPyjj11ozdszeX1jFuMDnc/uNNy7f
+ cccdrs7l2oAAlNDWrr8oikwmt+MVV1zRIdWMneoAZs2cn9AWoXZ/XlzWECAS3NbWtLFwknUwo0aNeNYE
+ LmEcANZ5BuM4BGJBKkqZslihwdNOftKNontp0bru3YsXd7Hp//OcfvqVv+9WmpovBrSRcNKSDuMCWdct
+ o6ioe0fst1MdwIbqNR+byKo1G5Vpu6wz7fi6cuyxE1+L2NGwIUWgSQXUa49Ifv5gSWkpC02ApfLBwSCg
+ qCg55corr+yUzr6vM+eee3hu/CH7niV+EIQj3oD83EPP9VVTbW2fjthvpzqAbCbbV1lO/v4TEiAXNjc3
+ //flaP4HOfnkkxsqKopnKa1Q2kKUxfpAExWwNXQviTLf2zKhEM/16dm7z9NdbffXhfvue/D1HQb0vs/3
+ cygjKJMXfcWwYXVNeUfss1MdgPhebys/FVZECEzwaltdzf2dacPXnUgk9bKbyxLOC7FYlclRHAElhrqU
+ ZqPbRoBBxBCJ2O7B48Z2jeza15RvfGPSL6K2NH+41FTx/trVvTtif53qALQ2A3R+dpxCjBj3/M7cfwGY
+ MOGQF4PAR0RhiWaxeJTEIyRsw3KtEdHYKAIVUFpauuAXv/jFf1VNxv86V1999fq9xoy6x81mP3hRW7S2
+ tZZ1xP461QFkspmi9n8Hxr8z3bT5M2e5F9j+HH74wTNTycRmlVf3q8nZpGMOxZUxZjTWou3wlPA8j+Li
+ xPNdbO7XklNO+e5vK8vLN7cLhGrLwjX+V9sBiIiVzQb9RAxBELSIa67orH0X+IDDDz88V1JS8mpgDCLg
+ 6YAF2kJ1K2durcJWAkoIgoDho0Y929X2fh059dRTq3fdbegVufxTgFYKCcxX2wEsXLgw7rp+aSBCYMyN
+ 6XRtTWftu8CH6d6j5z98N2zs01aEN+sNaxJJ1mTdLbX/qWRR9QFj9+z0mQsFQo49+rC/VFSUzgsFAhUY
+ +Wo7gOXLl9ue72kxXkNUOX/srP0W+DhnfP+kaWLED1uAhHlNLos3+ijxUGiMD0WJxEuTJ0/+yjY/fdWZ
+ PHmyN2bP3S4jm0NpwRgd74j9dJoDSKfTVZmsq5VEb9yOgzILfAF+9KMfretR2W2mIChRNAQeb7+XRhwH
+ tMZzc/TuWUj/dTVPPP7E0z16VE5TgWCCaEqxWAAAAkFJREFUoEPkzTvNAaxY8X454jZmVMuNnbXPAp+O
+ HYm/5OVcLAxg8fTcdUStRDic0tJm3Lgxhcf//wJG7T78UuP7iO9XdbUtX4rvnn7GN1DWn7rajgIhP5h8
+ 7oFONCmpsj5SXN5XomV9JFXWV1Ld+khlzx3md7V9BT6gd88dX6yqGtAhMbPOiwEsXroLYhfu/v8lDD14
+ n7ei8eJmoxVGQVRrRAm+75MsLp7z+Vso0Fnsu/9el7e1Npddd911RZ//6f+MTnMAe+wx+AHIfaVFJf6X
+ uOCEEzLdS4tmSV7esL38PPBcdhw4oKDJ8F/EI488MKO8W8lLixcv3u79AJ3mAG666c51nbWvAtuIE3vL
+ ZHNoCSWqlbKIxKJtkw49sEsGrxb4dA6ZcPC5a9asyXS1HQX+hzjhu2ceGokVS6pbHyku7y/Jbn2l/8Cd
+ n+tquwp0Hl02HrxA1zPhmxOnO06sTakwDuDmslT16f2V0P4vsH0oOICvMT885piWivKy6SZfc44W/5hJ
+ 479y8t8FChT4gowcfeBPo0XlkirrL3377VjI/X/NKDwBfM35zqmnPO/7lrhulkhRUWH9X6DA142+A4bN
+ smKlcuaZP929q20pUKBAJ7Pj8AN/WdmjzzLaxzIX+NpQWAIU4Pjjj/x3PBF7lq/Y0NMCBQpsB0REdZTu
+ fIECBQoUKFCgQIECBQoUKFCgQIECBQoUKFCgQIECBQoUKFCgQIECBQoUKFCgQIECBQoUKFCgQIECBQoU
+ KFCgQIEvw/8HBeGfsMwkKhsAAAAASUVORK5CYII=
+
+
+
\ No newline at end of file
diff --git a/Program.cs b/Program.cs
new file mode 100644
index 0000000..74f1c3d
--- /dev/null
+++ b/Program.cs
@@ -0,0 +1,12 @@
+namespace QuickLauncher
+{
+ internal static class Program
+ {
+ [STAThread]
+ static void Main()
+ {
+ ApplicationConfiguration.Initialize();
+ Application.Run(new MainForm());
+ }
+ }
+}
\ No newline at end of file
diff --git a/QuickLauncher.csproj b/QuickLauncher.csproj
new file mode 100644
index 0000000..26744b0
--- /dev/null
+++ b/QuickLauncher.csproj
@@ -0,0 +1,17 @@
+
+
+
+
+ WinExe
+ net6.0-windows
+ enable
+ true
+ enable
+ Truice_Icon.ico
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/QuickLauncher.csproj.user b/QuickLauncher.csproj.user
new file mode 100644
index 0000000..6696a72
--- /dev/null
+++ b/QuickLauncher.csproj.user
@@ -0,0 +1,9 @@
+
+
+
+
+
+ Form
+
+
+
\ No newline at end of file
diff --git a/QuickLauncher.sln b/QuickLauncher.sln
new file mode 100644
index 0000000..69cb4c0
--- /dev/null
+++ b/QuickLauncher.sln
@@ -0,0 +1,24 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "QuickLauncher", "QuickLauncher.csproj", "{8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {8E5D0C31-935F-4C3B-8A56-8E8C1F9D9F5A}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {D2A9E0E7-9C1F-4B77-B6C4-9B2A5D3D2A1A}
+ EndGlobalSection
+EndGlobal
\ No newline at end of file
diff --git a/Truice_Icon.ico b/Truice_Icon.ico
new file mode 100644
index 0000000..cdebf76
Binary files /dev/null and b/Truice_Icon.ico differ
diff --git a/bin/Debug/net6.0-windows/QuickLauncher.deps.json b/bin/Debug/net6.0-windows/QuickLauncher.deps.json
new file mode 100644
index 0000000..022b848
--- /dev/null
+++ b/bin/Debug/net6.0-windows/QuickLauncher.deps.json
@@ -0,0 +1,23 @@
+{
+ "runtimeTarget": {
+ "name": ".NETCoreApp,Version=v6.0",
+ "signature": ""
+ },
+ "compilationOptions": {},
+ "targets": {
+ ".NETCoreApp,Version=v6.0": {
+ "QuickLauncher/1.0.0": {
+ "runtime": {
+ "QuickLauncher.dll": {}
+ }
+ }
+ }
+ },
+ "libraries": {
+ "QuickLauncher/1.0.0": {
+ "type": "project",
+ "serviceable": false,
+ "sha512": ""
+ }
+ }
+}
\ No newline at end of file
diff --git a/bin/Debug/net6.0-windows/QuickLauncher.dll b/bin/Debug/net6.0-windows/QuickLauncher.dll
new file mode 100644
index 0000000..c20e847
Binary files /dev/null and b/bin/Debug/net6.0-windows/QuickLauncher.dll differ
diff --git a/bin/Debug/net6.0-windows/QuickLauncher.exe b/bin/Debug/net6.0-windows/QuickLauncher.exe
new file mode 100644
index 0000000..53302a9
Binary files /dev/null and b/bin/Debug/net6.0-windows/QuickLauncher.exe differ
diff --git a/bin/Debug/net6.0-windows/QuickLauncher.pdb b/bin/Debug/net6.0-windows/QuickLauncher.pdb
new file mode 100644
index 0000000..0b20e50
Binary files /dev/null and b/bin/Debug/net6.0-windows/QuickLauncher.pdb differ
diff --git a/bin/Debug/net6.0-windows/QuickLauncher.runtimeconfig.json b/bin/Debug/net6.0-windows/QuickLauncher.runtimeconfig.json
new file mode 100644
index 0000000..f9988b2
--- /dev/null
+++ b/bin/Debug/net6.0-windows/QuickLauncher.runtimeconfig.json
@@ -0,0 +1,15 @@
+{
+ "runtimeOptions": {
+ "tfm": "net6.0",
+ "frameworks": [
+ {
+ "name": "Microsoft.NETCore.App",
+ "version": "6.0.0"
+ },
+ {
+ "name": "Microsoft.WindowsDesktop.App",
+ "version": "6.0.0"
+ }
+ ]
+ }
+}
\ No newline at end of file
diff --git a/bin/Debug/net6.0-windows/settings.json b/bin/Debug/net6.0-windows/settings.json
new file mode 100644
index 0000000..c88cc22
--- /dev/null
+++ b/bin/Debug/net6.0-windows/settings.json
@@ -0,0 +1,5 @@
+{
+ "LastSelectedCategory": "\u65B0AZ",
+ "SortMode": "UsageCount",
+ "IconSize": 256
+}
\ No newline at end of file
diff --git a/bin/Debug/net6.0-windows/shortcuts.json b/bin/Debug/net6.0-windows/shortcuts.json
new file mode 100644
index 0000000..ad4186c
--- /dev/null
+++ b/bin/Debug/net6.0-windows/shortcuts.json
@@ -0,0 +1,32 @@
+{
+ "\u65B0AZ": [
+ {
+ "Name": "4\u3001Game_wow335",
+ "Path": "I:\\Desktop\\Gitea\\4\u3001Game_wow335.lnk",
+ "DateAdded": "2025-03-12T13:58:03.3149744+08:00",
+ "LastUsed": "2025-03-12T13:58:39.6693652+08:00",
+ "UsageCount": 1
+ },
+ {
+ "Name": "1\u3001AzerothCore.sln",
+ "Path": "I:\\Desktop\\Gitea\\1\u3001AzerothCore.sln.lnk",
+ "DateAdded": "2025-03-12T13:58:03.3249607+08:00",
+ "LastUsed": "0001-01-01T00:00:00",
+ "UsageCount": 0
+ },
+ {
+ "Name": "2\u3001\u542F\u52A8MYSQL.bat",
+ "Path": "I:\\Desktop\\Gitea\\2\u3001\u542F\u52A8MYSQL.bat.lnk",
+ "DateAdded": "2025-03-12T13:58:03.2453763+08:00",
+ "LastUsed": "0001-01-01T00:00:00",
+ "UsageCount": 0
+ },
+ {
+ "Name": "3\u3001navicat.exe",
+ "Path": "I:\\Desktop\\Gitea\\3\u3001navicat.exe.lnk",
+ "DateAdded": "2025-03-12T13:58:03.3022567+08:00",
+ "LastUsed": "0001-01-01T00:00:00",
+ "UsageCount": 0
+ }
+ ]
+}
\ No newline at end of file
diff --git a/obj/Debug/net6.0-windows/.NETCoreApp,Version=v6.0.AssemblyAttributes.cs b/obj/Debug/net6.0-windows/.NETCoreApp,Version=v6.0.AssemblyAttributes.cs
new file mode 100644
index 0000000..ed92695
--- /dev/null
+++ b/obj/Debug/net6.0-windows/.NETCoreApp,Version=v6.0.AssemblyAttributes.cs
@@ -0,0 +1,4 @@
+//
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.AssemblyInfo.cs b/obj/Debug/net6.0-windows/QuickLauncher.AssemblyInfo.cs
new file mode 100644
index 0000000..e924174
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.AssemblyInfo.cs
@@ -0,0 +1,25 @@
+//------------------------------------------------------------------------------
+//
+// 此代码由工具生成。
+// 运行时版本:4.0.30319.42000
+//
+// 对此文件的更改可能会导致不正确的行为，并且如果
+// 重新生成代码，这些更改将会丢失。
+//
+//------------------------------------------------------------------------------
+
+using System;
+using System.Reflection;
+
+[assembly: System.Reflection.AssemblyCompanyAttribute("QuickLauncher")]
+[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")]
+[assembly: System.Reflection.AssemblyProductAttribute("QuickLauncher")]
+[assembly: System.Reflection.AssemblyTitleAttribute("QuickLauncher")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
+[assembly: System.Runtime.Versioning.TargetPlatformAttribute("Windows7.0")]
+[assembly: System.Runtime.Versioning.SupportedOSPlatformAttribute("Windows7.0")]
+
+// 由 MSBuild WriteCodeFragment 类生成。
+
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.AssemblyInfoInputs.cache b/obj/Debug/net6.0-windows/QuickLauncher.AssemblyInfoInputs.cache
new file mode 100644
index 0000000..ce1eb3e
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.AssemblyInfoInputs.cache
@@ -0,0 +1 @@
+c6eb8c2f43ebdcdca383a66315f5396dd3847e53f909e5e7ec32d85eac2a583a
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.GeneratedMSBuildEditorConfig.editorconfig b/obj/Debug/net6.0-windows/QuickLauncher.GeneratedMSBuildEditorConfig.editorconfig
new file mode 100644
index 0000000..7efe488
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.GeneratedMSBuildEditorConfig.editorconfig
@@ -0,0 +1,22 @@
+is_global = true
+build_property.ApplicationManifest =
+build_property.StartupObject =
+build_property.ApplicationDefaultFont =
+build_property.ApplicationHighDpiMode =
+build_property.ApplicationUseCompatibleTextRendering =
+build_property.ApplicationVisualStyles =
+build_property.TargetFramework = net6.0-windows
+build_property.TargetPlatformMinVersion = 7.0
+build_property.UsingMicrosoftNETSdkWeb =
+build_property.ProjectTypeGuids =
+build_property.InvariantGlobalization =
+build_property.PlatformNeutralAssembly =
+build_property.EnforceExtendedAnalyzerRules =
+build_property._SupportedPlatformList = Linux,macOS,Windows
+build_property.RootNamespace = QuickLauncher
+build_property.ProjectDir = I:\Desktop\CusserCore\ToolBox\
+build_property.EnableComHosting =
+build_property.EnableGeneratedComInterfaceComImportInterop =
+build_property.CsWinRTUseWindowsUIXamlProjections = false
+build_property.EffectiveAnalysisLevelStyle = 6.0
+build_property.EnableCodeStyleSeverity =
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.GlobalUsings.g.cs b/obj/Debug/net6.0-windows/QuickLauncher.GlobalUsings.g.cs
new file mode 100644
index 0000000..84bbb89
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.GlobalUsings.g.cs
@@ -0,0 +1,10 @@
+//
+global using global::System;
+global using global::System.Collections.Generic;
+global using global::System.Drawing;
+global using global::System.IO;
+global using global::System.Linq;
+global using global::System.Net.Http;
+global using global::System.Threading;
+global using global::System.Threading.Tasks;
+global using global::System.Windows.Forms;
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.MainForm.resources b/obj/Debug/net6.0-windows/QuickLauncher.MainForm.resources
new file mode 100644
index 0000000..6e1c9f9
Binary files /dev/null and b/obj/Debug/net6.0-windows/QuickLauncher.MainForm.resources differ
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.assets.cache b/obj/Debug/net6.0-windows/QuickLauncher.assets.cache
new file mode 100644
index 0000000..1c19310
Binary files /dev/null and b/obj/Debug/net6.0-windows/QuickLauncher.assets.cache differ
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.csproj.BuildWithSkipAnalyzers b/obj/Debug/net6.0-windows/QuickLauncher.csproj.BuildWithSkipAnalyzers
new file mode 100644
index 0000000..e69de29
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.csproj.CoreCompileInputs.cache b/obj/Debug/net6.0-windows/QuickLauncher.csproj.CoreCompileInputs.cache
new file mode 100644
index 0000000..4ccd164
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.csproj.CoreCompileInputs.cache
@@ -0,0 +1 @@
+fd6f5d7af075caae0ee3e406c17ceaf8b00770f0debf612bee014817e3f2459d
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.csproj.FileListAbsolute.txt b/obj/Debug/net6.0-windows/QuickLauncher.csproj.FileListAbsolute.txt
new file mode 100644
index 0000000..234f719
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.csproj.FileListAbsolute.txt
@@ -0,0 +1,32 @@
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.MainForm.resources
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.csproj.GenerateResource.cache
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.GeneratedMSBuildEditorConfig.editorconfig
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.AssemblyInfoInputs.cache
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.AssemblyInfo.cs
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.csproj.CoreCompileInputs.cache
+I:\Desktop\CusserCore\快捷启动工具箱\bin\Debug\net6.0-windows\QuickLauncher.exe
+I:\Desktop\CusserCore\快捷启动工具箱\bin\Debug\net6.0-windows\QuickLauncher.deps.json
+I:\Desktop\CusserCore\快捷启动工具箱\bin\Debug\net6.0-windows\QuickLauncher.runtimeconfig.json
+I:\Desktop\CusserCore\快捷启动工具箱\bin\Debug\net6.0-windows\QuickLauncher.dll
+I:\Desktop\CusserCore\快捷启动工具箱\bin\Debug\net6.0-windows\QuickLauncher.pdb
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.dll
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\refint\QuickLauncher.dll
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.pdb
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\QuickLauncher.genruntimeconfig.cache
+I:\Desktop\CusserCore\快捷启动工具箱\obj\Debug\net6.0-windows\ref\QuickLauncher.dll
+I:\Desktop\CusserCore\ToolBox\bin\Debug\net6.0-windows\QuickLauncher.exe
+I:\Desktop\CusserCore\ToolBox\bin\Debug\net6.0-windows\QuickLauncher.deps.json
+I:\Desktop\CusserCore\ToolBox\bin\Debug\net6.0-windows\QuickLauncher.runtimeconfig.json
+I:\Desktop\CusserCore\ToolBox\bin\Debug\net6.0-windows\QuickLauncher.dll
+I:\Desktop\CusserCore\ToolBox\bin\Debug\net6.0-windows\QuickLauncher.pdb
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.MainForm.resources
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.csproj.GenerateResource.cache
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.GeneratedMSBuildEditorConfig.editorconfig
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.AssemblyInfoInputs.cache
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.AssemblyInfo.cs
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.csproj.CoreCompileInputs.cache
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.dll
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\refint\QuickLauncher.dll
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.pdb
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\QuickLauncher.genruntimeconfig.cache
+I:\Desktop\CusserCore\ToolBox\obj\Debug\net6.0-windows\ref\QuickLauncher.dll
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.csproj.GenerateResource.cache b/obj/Debug/net6.0-windows/QuickLauncher.csproj.GenerateResource.cache
new file mode 100644
index 0000000..c4d350e
Binary files /dev/null and b/obj/Debug/net6.0-windows/QuickLauncher.csproj.GenerateResource.cache differ
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.designer.deps.json b/obj/Debug/net6.0-windows/QuickLauncher.designer.deps.json
new file mode 100644
index 0000000..706cdfa
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.designer.deps.json
@@ -0,0 +1,11 @@
+{
+ "runtimeTarget": {
+ "name": ".NETCoreApp,Version=v6.0",
+ "signature": ""
+ },
+ "compilationOptions": {},
+ "targets": {
+ ".NETCoreApp,Version=v6.0": {}
+ },
+ "libraries": {}
+}
\ No newline at end of file
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.designer.runtimeconfig.json b/obj/Debug/net6.0-windows/QuickLauncher.designer.runtimeconfig.json
new file mode 100644
index 0000000..ce90cc1
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.designer.runtimeconfig.json
@@ -0,0 +1,23 @@
+{
+ "runtimeOptions": {
+ "tfm": "net6.0",
+ "frameworks": [
+ {
+ "name": "Microsoft.NETCore.App",
+ "version": "6.0.0"
+ },
+ {
+ "name": "Microsoft.WindowsDesktop.App",
+ "version": "6.0.0"
+ }
+ ],
+ "additionalProbingPaths": [
+ "C:\\Users\\49009\\.dotnet\\store\\|arch|\\|tfm|",
+ "C:\\Users\\49009\\.nuget\\packages",
+ "D:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
+ ],
+ "configProperties": {
+ "Microsoft.NETCore.DotNetHostPolicy.SetAppPaths": true
+ }
+ }
+}
\ No newline at end of file
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.dll b/obj/Debug/net6.0-windows/QuickLauncher.dll
new file mode 100644
index 0000000..c20e847
Binary files /dev/null and b/obj/Debug/net6.0-windows/QuickLauncher.dll differ
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.genruntimeconfig.cache b/obj/Debug/net6.0-windows/QuickLauncher.genruntimeconfig.cache
new file mode 100644
index 0000000..0ed6f41
--- /dev/null
+++ b/obj/Debug/net6.0-windows/QuickLauncher.genruntimeconfig.cache
@@ -0,0 +1 @@
+52bd08125dfe992db22dbaeb725f74f6d2e3774dab2cc358f22d7767115f87c2
diff --git a/obj/Debug/net6.0-windows/QuickLauncher.pdb b/obj/Debug/net6.0-windows/QuickLauncher.pdb
new file mode 100644
index 0000000..0b20e50
Binary files /dev/null and b/obj/Debug/net6.0-windows/QuickLauncher.pdb differ
diff --git a/obj/Debug/net6.0-windows/apphost.exe b/obj/Debug/net6.0-windows/apphost.exe
new file mode 100644
index 0000000..53302a9
Binary files /dev/null and b/obj/Debug/net6.0-windows/apphost.exe differ
diff --git a/obj/Debug/net6.0-windows/ref/QuickLauncher.dll b/obj/Debug/net6.0-windows/ref/QuickLauncher.dll
new file mode 100644
index 0000000..2b15f51
Binary files /dev/null and b/obj/Debug/net6.0-windows/ref/QuickLauncher.dll differ
diff --git a/obj/Debug/net6.0-windows/refint/QuickLauncher.dll b/obj/Debug/net6.0-windows/refint/QuickLauncher.dll
new file mode 100644
index 0000000..2b15f51
Binary files /dev/null and b/obj/Debug/net6.0-windows/refint/QuickLauncher.dll differ
diff --git a/obj/QuickLauncher.csproj.nuget.dgspec.json b/obj/QuickLauncher.csproj.nuget.dgspec.json
new file mode 100644
index 0000000..62e491d
--- /dev/null
+++ b/obj/QuickLauncher.csproj.nuget.dgspec.json
@@ -0,0 +1,76 @@
+{
+ "format": 1,
+ "restore": {
+ "I:\\Desktop\\CusserCore\\ToolBox\\QuickLauncher.csproj": {}
+ },
+ "projects": {
+ "I:\\Desktop\\CusserCore\\ToolBox\\QuickLauncher.csproj": {
+ "version": "1.0.0",
+ "restore": {
+ "projectUniqueName": "I:\\Desktop\\CusserCore\\ToolBox\\QuickLauncher.csproj",
+ "projectName": "QuickLauncher",
+ "projectPath": "I:\\Desktop\\CusserCore\\ToolBox\\QuickLauncher.csproj",
+ "packagesPath": "C:\\Users\\49009\\.nuget\\packages\\",
+ "outputPath": "I:\\Desktop\\CusserCore\\ToolBox\\obj\\",
+ "projectStyle": "PackageReference",
+ "fallbackFolders": [
+ "D:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
+ ],
+ "configFilePaths": [
+ "C:\\Users\\49009\\AppData\\Roaming\\NuGet\\NuGet.Config",
+ "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.FallbackLocation.config",
+ "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+ ],
+ "originalTargetFrameworks": [
+ "net6.0-windows"
+ ],
+ "sources": {
+ "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+ "https://api.nuget.org/v3/index.json": {}
+ },
+ "frameworks": {
+ "net6.0-windows7.0": {
+ "targetAlias": "net6.0-windows",
+ "projectReferences": {}
+ }
+ },
+ "warningProperties": {
+ "warnAsError": [
+ "NU1605"
+ ]
+ },
+ "restoreAuditProperties": {
+ "enableAudit": "true",
+ "auditLevel": "low",
+ "auditMode": "direct"
+ },
+ "SdkAnalysisLevel": "9.0.200"
+ },
+ "frameworks": {
+ "net6.0-windows7.0": {
+ "targetAlias": "net6.0-windows",
+ "imports": [
+ "net461",
+ "net462",
+ "net47",
+ "net471",
+ "net472",
+ "net48",
+ "net481"
+ ],
+ "assetTargetFallback": true,
+ "warn": true,
+ "frameworkReferences": {
+ "Microsoft.NETCore.App": {
+ "privateAssets": "all"
+ },
+ "Microsoft.WindowsDesktop.App.WindowsForms": {
+ "privateAssets": "none"
+ }
+ },
+ "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.201\\RuntimeIdentifierGraph.json"
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/obj/QuickLauncher.csproj.nuget.g.props b/obj/QuickLauncher.csproj.nuget.g.props
new file mode 100644
index 0000000..f582244
--- /dev/null
+++ b/obj/QuickLauncher.csproj.nuget.g.props
@@ -0,0 +1,16 @@
+
+
+
+ True
+ NuGet
+ $(MSBuildThisFileDirectory)project.assets.json
+ $(UserProfile)\.nuget\packages\
+ C:\Users\49009\.nuget\packages\;D:\Program Files (x86)\Microsoft Visual Studio\Shared\NuGetPackages
+ PackageReference
+ 6.13.2
+
+
+
+
+
+
\ No newline at end of file
diff --git a/obj/QuickLauncher.csproj.nuget.g.targets b/obj/QuickLauncher.csproj.nuget.g.targets
new file mode 100644
index 0000000..3dc06ef
--- /dev/null
+++ b/obj/QuickLauncher.csproj.nuget.g.targets
@@ -0,0 +1,2 @@
+
+
\ No newline at end of file
diff --git a/obj/project.assets.json b/obj/project.assets.json
new file mode 100644
index 0000000..9f88d08
--- /dev/null
+++ b/obj/project.assets.json
@@ -0,0 +1,82 @@
+{
+ "version": 3,
+ "targets": {
+ "net6.0-windows7.0": {}
+ },
+ "libraries": {},
+ "projectFileDependencyGroups": {
+ "net6.0-windows7.0": []
+ },
+ "packageFolders": {
+ "C:\\Users\\49009\\.nuget\\packages\\": {},
+ "D:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages": {}
+ },
+ "project": {
+ "version": "1.0.0",
+ "restore": {
+ "projectUniqueName": "I:\\Desktop\\CusserCore\\ToolBox\\QuickLauncher.csproj",
+ "projectName": "QuickLauncher",
+ "projectPath": "I:\\Desktop\\CusserCore\\ToolBox\\QuickLauncher.csproj",
+ "packagesPath": "C:\\Users\\49009\\.nuget\\packages\\",
+ "outputPath": "I:\\Desktop\\CusserCore\\ToolBox\\obj\\",
+ "projectStyle": "PackageReference",
+ "fallbackFolders": [
+ "D:\\Program Files (x86)\\Microsoft Visual Studio\\Shared\\NuGetPackages"
+ ],
+ "configFilePaths": [
+ "C:\\Users\\49009\\AppData\\Roaming\\NuGet\\NuGet.Config",
+ "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.FallbackLocation.config",
+ "C:\\Program Files (x86)\\NuGet\\Config\\Microsoft.VisualStudio.Offline.config"
+ ],
+ "originalTargetFrameworks": [
+ "net6.0-windows"
+ ],
+ "sources": {
+ "C:\\Program Files (x86)\\Microsoft SDKs\\NuGetPackages\\": {},
+ "https://api.nuget.org/v3/index.json": {}
+ },
+ "frameworks": {
+ "net6.0-windows7.0": {
+ "targetAlias": "net6.0-windows",
+ "projectReferences": {}
+ }
+ },
+ "warningProperties": {
+ "warnAsError": [
+ "NU1605"
+ ]
+ },
+ "restoreAuditProperties": {
+ "enableAudit": "true",
+ "auditLevel": "low",
+ "auditMode": "direct"
+ },
+ "SdkAnalysisLevel": "9.0.200"
+ },
+ "frameworks": {
+ "net6.0-windows7.0": {
+ "targetAlias": "net6.0-windows",
+ "imports": [
+ "net461",
+ "net462",
+ "net47",
+ "net471",
+ "net472",
+ "net48",
+ "net481"
+ ],
+ "assetTargetFallback": true,
+ "warn": true,
+ "frameworkReferences": {
+ "Microsoft.NETCore.App": {
+ "privateAssets": "all"
+ },
+ "Microsoft.WindowsDesktop.App.WindowsForms": {
+ "privateAssets": "none"
+ }
+ },
+ "runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.201\\RuntimeIdentifierGraph.json"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/obj/project.nuget.cache b/obj/project.nuget.cache
new file mode 100644
index 0000000..63bf998
--- /dev/null
+++ b/obj/project.nuget.cache
@@ -0,0 +1,8 @@
+{
+ "version": 2,
+ "dgSpecHash": "vj/spU1Q8XY=",
+ "success": true,
+ "projectFilePath": "I:\\Desktop\\CusserCore\\ToolBox\\QuickLauncher.csproj",
+ "expectedPackageFiles": [],
+ "logs": []
+}
\ No newline at end of file