diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce .hgignore --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.hgignore Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,8 @@ +# Ignore Visual Studio 2008 files + +syntax: glob + +*.suo +*.cachefile +bin/ +obj/ diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d.sln --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d.sln Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,24 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gleed2d", "gleed2d\gleed2d.csproj", "{48A02BD1-0377-4FEA-A8D8-5586A60789F1}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gleed2dContent", "gleed2d\Content\gleed2dContent.contentproj", "{3BADB268-2C1F-48EC-947B-EA7F16B1FA1B}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {48A02BD1-0377-4FEA-A8D8-5586A60789F1}.Debug|x86.ActiveCfg = Debug|x86 + {48A02BD1-0377-4FEA-A8D8-5586A60789F1}.Debug|x86.Build.0 = Debug|x86 + {48A02BD1-0377-4FEA-A8D8-5586A60789F1}.Release|x86.ActiveCfg = Release|x86 + {48A02BD1-0377-4FEA-A8D8-5586A60789F1}.Release|x86.Build.0 = Release|x86 + {3BADB268-2C1F-48EC-947B-EA7F16B1FA1B}.Debug|x86.ActiveCfg = Debug|x86 + {3BADB268-2C1F-48EC-947B-EA7F16B1FA1B}.Release|x86.ActiveCfg = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/ClassDiagram1.cd --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/ClassDiagram1.cd Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,70 @@ + + + + + + + + + + EBAAAIBQAIAAgACkARIAAAQAAgAAAgAIAAACNAQQAQg= + src\Item.cs + + + + + + + EAAAAAAAAAAACAAEAAIAAgQKAAFAAABIIAAEkAACAAE= + src\Layer.cs + + + + + + + + + src\Level.Editable.cs + + + + + EQAAAAAAACAEAAAAAAAAAAQAAARAAAAEAAAAAAAAQAA= + src\Level.cs + + + + + + ABAIAIAAAAAAAAAEAAIIAgAIAAAAAABAAAEEEAwCAQA= + src\Items\CircleItem.cs + + + + + + + ARAABIIAAAAAAAAEQAIIAgAoAAAAAABAAAAEEAQCgQA= + src\Items\PathItem.cs + + + + + + + ABAAAIAABAAAAAAEAAIIAkAIAAAggABAQAAEEAwCAQA= + src\Items\RectangleItem.cs + + + + + + + ABBQIKAQAIAAAIAEAgIBAkAIAEAkIwhAAAAEEAwCAQg= + src\Items\TextureItem.cs + + + + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Content/gleed2dContent.contentproj --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/Content/gleed2dContent.contentproj Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,77 @@ + + + + {3BADB268-2C1F-48EC-947B-EA7F16B1FA1B} + {96E2B04D-8817-42c6-938A-82C39BA4D311};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Debug + x86 + Library + Properties + v4.0 + v4.0 + x86 + bin\$(Platform)\$(Configuration) + Content + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + Windows + AllRules.ruleset + + + Windows + AllRules.ruleset + + + + + + + + + + + + + + False + Microsoft .NET Framework 4 %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + false + + + False + Windows Installer 3.1 + true + + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Game.ico Binary file gleed2d/Game.ico has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/GameThumbnail.png Binary file gleed2d/GameThumbnail.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Properties/AssemblyInfo.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/Properties/AssemblyInfo.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,33 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("GLEED2D")] +[assembly: AssemblyProduct("GLEED2D")] +[assembly: AssemblyDescription("Generic Level Editor 2D")] +[assembly: AssemblyCompany("")] + +[assembly: AssemblyCopyright("")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("2120b56c-7ac2-4732-a320-1b0f6128f6da")] + + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +[assembly: AssemblyVersion("1.3.0.0")] diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Properties/Resources.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/Properties/Resources.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,133 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.261 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace GLEED2D.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("GLEED2D.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to (Left Click) = start new circle (Right Click) = exit circle draw mode. + /// + internal static string Circle_Entered { + get { + return ResourceManager.GetString("Circle_Entered", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to (Left Click) = add circle to level (Right Click) = cancel circle. + /// + internal static string Circle_Started { + get { + return ResourceManager.GetString("Circle_Started", resourceCulture); + } + } + + internal static System.Drawing.Bitmap folder { + get { + object obj = ResourceManager.GetObject("folder", resourceCulture); + return ((System.Drawing.Bitmap)(obj)); + } + } + + /// + /// Looks up a localized string similar to There is no layer in the level. Please add a new layer before adding items.. + /// + internal static string No_Layer { + get { + return ResourceManager.GetString("No_Layer", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to (Left Click) = start new path (Right Click) = exit path draw mode. + /// + internal static string Path_Entered { + get { + return ResourceManager.GetString("Path_Entered", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to (Left Click) = next point (BackSpace) = delete last point (Middle Click) = add path to level (Right Click) = cancel path. + /// + internal static string Path_Started { + get { + return ResourceManager.GetString("Path_Started", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to (Left Click) = start new rectangle (Right Click) = exit rectangle draw mode. + /// + internal static string Rectangle_Entered { + get { + return ResourceManager.GetString("Rectangle_Entered", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to (Left Click) = add rectangle to level (LeftCtrl) = make square (Right Click) = cancel rectangle. + /// + internal static string Rectangle_Started { + get { + return ResourceManager.GetString("Rectangle_Started", resourceCulture); + } + } + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Properties/Resources.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/Properties/Resources.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,145 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + (Left Click) = start new circle (Right Click) = exit circle draw mode + + + (Left Click) = add circle to level (Right Click) = cancel circle + + + + ..\Resources\folder.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + There is no layer in the level. Please add a new layer before adding items. + + + (Left Click) = start new path (Right Click) = exit path draw mode + + + (Left Click) = next point (BackSpace) = delete last point (Middle Click) = add path to level (Right Click) = cancel path + + + (Left Click) = start new rectangle (Right Click) = exit rectangle draw mode + + + (Left Click) = add rectangle to level (LeftCtrl) = make square (Right Click) = cancel rectangle + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/Cursors/dragcopy.cur Binary file gleed2d/Resources/Cursors/dragcopy.cur has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/Cursors/rotate.cur Binary file gleed2d/Resources/Cursors/rotate.cur has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/Cursors/scale.cur Binary file gleed2d/Resources/Cursors/scale.cur has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/circle.png Binary file gleed2d/Resources/circle.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/folder.png Binary file gleed2d/Resources/folder.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/icon_circle_item.png Binary file gleed2d/Resources/icon_circle_item.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/icon_layer.png Binary file gleed2d/Resources/icon_layer.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/icon_level.png Binary file gleed2d/Resources/icon_level.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/icon_path_item.png Binary file gleed2d/Resources/icon_path_item.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/icon_rectangle_item.png Binary file gleed2d/Resources/icon_rectangle_item.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/icon_texture_item.png Binary file gleed2d/Resources/icon_texture_item.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/primitive_circle.png Binary file gleed2d/Resources/primitive_circle.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/primitive_path.png Binary file gleed2d/Resources/primitive_path.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/Resources/primitive_rectangle.png Binary file gleed2d/Resources/primitive_rectangle.png has changed diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/app.config --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/app.config Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,3 @@ + + + diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/gleed2d.csproj --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/gleed2d.csproj Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,346 @@ + + + + {48A02BD1-0377-4FEA-A8D8-5586A60789F1} + {6D335F3A-9D43-41b4-9D22-F6F17C4BE596};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Debug + x86 + WinExe + Properties + GLEED2D + gleed2d + v4.0 + v4.0 + Windows + fb223a6f-16a5-453e-a9f3-69c261632486 + Game.ico + GameThumbnail.png + false + 4801E1B2BE8D41150A4728130A5ECE8009241BFC + MyEditor_TemporaryKey.pfx + false + false + LocalIntranet + + + Game + Reach + + + + + + + 3.5 + publish2\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 2 + 1.0.0.%2a + false + true + + + true + full + false + bin\x86\Debug\ + DEBUG;TRACE;WINDOWS + prompt + 4 + true + false + x86 + false + AllRules.ruleset + + + pdbonly + true + bin\x86\Release + TRACE;WINDOWS + prompt + 4 + true + false + x86 + True + AllRules.ruleset + + + + False + + + False + + + False + + + False + + + False + + + + + False + + + False + + + + + + + + False + + + False + + + False + + + + + + Form + + + LinkItemsForm.cs + + + Form + + + QuickGuide.cs + + + + + True + True + Resources.resx + + + + + + + UserControl + + + ItemSelector.cs + + + UserControl + + + + Form + + + Form + + + LayerSelectForm.cs + + + + + + + Form + + + AddCustomProperty.cs + + + + + + + + + + + Form + + + About.cs + + + Form + + + AddLayer.cs + + + + + Form + + + SettingsForm.cs + + + + Form + + + MainForm.cs + + + PreserveNewest + + + + + + + + + + + + + + + + + + + + + + + + + + + 3badb268-2c1f-48ec-947b-ea7f16b1fa1b + False + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 2.0 %28x86%29 + false + + + False + .NET Framework 3.0 %28x86%29 + false + + + False + .NET Framework 3.5 + true + + + False + .NET Framework 3.5 SP1 + false + + + False + Windows Installer 3.1 + true + + + False + Microsoft XNA Framework Redistributable 3.1 + true + + + False + Microsoft XNA Framework Redistributable 4.0 + true + + + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + ItemSelector.cs + Designer + + + Vector2UITypeEditor.cs + Designer + + + About.cs + Designer + + + AddCustomProperty.cs + Designer + + + AddLayer.cs + Designer + + + LayerSelectForm.cs + Designer + + + LinkItemsForm.cs + Designer + + + MainForm.cs + Designer + + + QuickGuide.cs + Designer + + + SettingsForm.cs + Designer + + + + + + + + + {3BADB268-2C1F-48EC-947B-EA7F16B1FA1B} + gleed2dContent %28Content%29 + Content + + + + + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/gleed2d.csproj.user --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/gleed2d.csproj.user Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,23 @@ + + + + publish2\|publish\ + + + + + + + + + en-US + false + false + + + + + + false + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Brush.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Brush.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,32 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Audio; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.GamerServices; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Media; +using Microsoft.Xna.Framework.Net; +using Microsoft.Xna.Framework.Storage; + +namespace GLEED2D +{ + + class Brush + { + public String fullpath; + public Texture2D texture; + + public Brush(String fullpath) + { + this.fullpath = fullpath; + this.texture = TextureLoader.Instance.FromFile(Game1.Instance.GraphicsDevice, fullpath); + } + } + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Camera.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Camera.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,76 @@ +using Microsoft.Xna.Framework; + +namespace GLEED2D +{ + public class Camera + { + Vector2 position; + public Vector2 Position + { + get { + return position; + } + set { + position = value; + updatematrix(); + } + } + + float rotation; + public float Rotation + { + get + { + return rotation; + } + set + { + rotation = value; + updatematrix(); + } + } + + float scale; + public float Scale + { + get + { + return scale; + } + set + { + scale = value; + updatematrix(); + } + } + + public Matrix matrix; + Vector2 viewport; //width and height of the viewport + + + public Camera(float width, float height) + { + position = Vector2.Zero; + rotation = 0; + scale = 1.0f; + viewport = new Vector2(width, height); + updatematrix(); + } + + void updatematrix() + { + matrix = Matrix.CreateTranslation(-position.X, -position.Y, 0.0f) * + Matrix.CreateRotationZ(rotation) * + Matrix.CreateScale(scale) * + Matrix.CreateTranslation(viewport.X / 2, viewport.Y / 2, 0.0f); + } + + public void updateviewport(float width, float height) + { + viewport.X = width; + viewport.Y = height; + updatematrix(); + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Command.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Command.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,57 @@ +using System; +using System.Collections.Generic; + +namespace GLEED2D +{ + enum CommandType + { + Transform, Add, Delete, NameChange, OrderChange, WholeLevel + } + + class Command + { + public String Description; + public CommandType ComType; + public List ObjectsBefore = new List(); + public List ObjectsAfter = new List(); + + public Command(string description) + { + ComType = CommandType.WholeLevel; + Description = description; + ObjectsBefore.Add(Editor.Instance.level.cloneforundo()); + } + + public List Undo() + { + switch (ComType) + { + case CommandType.WholeLevel: + Editor.Instance.level = (Level)ObjectsBefore[0]; + Editor.Instance.getSelectionFromLevel(); + Editor.Instance.updatetreeview(); + break; + } + return null; + } + + public List Redo() + { + switch (ComType) + { + case CommandType.WholeLevel: + Editor.Instance.level = (Level)ObjectsAfter[0]; + Editor.Instance.getSelectionFromLevel(); + Editor.Instance.updatetreeview(); + break; + } + return null; + } + + public void saveAfterState() + { + ObjectsAfter.Add(Editor.Instance.level.cloneforundo()); + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Constants.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Constants.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,166 @@ +using System.ComponentModel; +using System.IO; +using System.Xml.Serialization; +using CustomUITypeEditors; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework; + +namespace GLEED2D +{ + public enum TextureOriginMethodEnum + { + TextureCenter, Centroid, TopLeft, TopRight, BottomLeft, BottomRight + } + + public class Constants + { + private static Constants instance; + public static Constants Instance + { + get + { + if (instance == null) instance = new Constants(); + return instance; + } + } + + public Constants() + { + //initialize all settings with default values + ColorSelectionFirst = new Color(255, 255, 0, 255); + ColorSelectionRest = new Color(255, 128, 0, 255); + EnableHighlightOnMouseOver = true; + ColorHighlight = new Color(255, 0, 0, 228); + ColorBackground = new Color(100, 149, 237, 255); + ColorSelectionBox = new Color(255, 255, 255, 109); + ColorPrimitives = new Color(192, 0, 192, 145); + ColorTextureTransparent = new Color(255, 0, 255, 255); + DefaultPathItemLineWidth = 4; + DefaultContentRootFolder = "C:\\"; + CameraSpeed = 500; + CameraFastSpeed = 2000; + DefaultTextureOriginMethod = TextureOriginMethodEnum.TextureCenter; + WorldOriginColor = new Color(255, 255, 255, 255); + WorldOriginLineThickness = 2; + GridColor = new Color(192, 192, 192, 120); + GridLineThickness = 1; + GridNumberOfGridLines = 500; + GridSpacing = new Microsoft.Xna.Framework.Vector2(64, 64); + + } + + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("The color used for the frame around the first selected item.")] + public Color ColorSelectionFirst {get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("The color used for the frame around all selected items but the first.")] + public Color ColorSelectionRest {get; set; } + + [Category("General"), Description("If enabled, items are tinted in 'ColorHighlight' when the mouse is over them.")] + public bool EnableHighlightOnMouseOver { get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("The color used when hovering over an item. Only relevant if 'EnableHighlightOnMouseOver' is set to true.")] + public Color ColorHighlight {get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("The background color for the editor.")] + public Color ColorBackground {get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("The color used when selecting multiple items by holding down the left mouse button.")] + public Color ColorSelectionBox {get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("The default color each new Primitive gets when added to the level.")] + public Color ColorPrimitives {get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("The color for colorkeying. When a texture is loaded, this color is made fully transparent.")] + public Color ColorTextureTransparent { get; set; } + + [Category("General"), Description("The default LineWidth of each new PathItem added to the level.")] + public int DefaultPathItemLineWidth { get; set; } + + + [EditorAttribute(typeof(FolderUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("General"), Description("When a new level is created, its ContentRootFolder will be initially set to this.")] + public string DefaultContentRootFolder { get; set; } + + [Category("General"), Description("The speed of the camera when moved with the W,A,S,D-Keys in WorldUnits/sec.")] + public float CameraSpeed { get; set; } + + [Category("General"), Description("The speed of the camera when moved via holding down Shift + W,A,S,D-Keys in WorldUnits/sec.")] + public float CameraFastSpeed { get; set; } + + [Category("General"), Description("The method for calculating the origin of each new texture.\n" + + "\"TextureCenter\" means the origin is calculated as Vector2(texture.Width/2, texture.Height/2).\n"+ + "\"Centroid\" is Farseer's way of calculating the Centroid of a polygon created from the texture.\n"+ + "\"TopLeft\",\"TopRight\",\"BottomLeft\" and \"BottomRight\" are the corresponding corners of the texture.")] + public TextureOriginMethodEnum DefaultTextureOriginMethod { get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("World Origin"), Description("The color of the world origin cross.")] + public Color WorldOriginColor { get; set; } + + [Category("World Origin"), Description("The thickness of the world origin cross in pixels.")] + public int WorldOriginLineThickness { get; set; } + + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Category("Grid"), Description("The color of the grid lines.")] + public Color GridColor { get; set; } + + [Category("Grid"), Description("The thickness of the grid lines in pixels.")] + public int GridLineThickness { get; set; } + + [Category("Grid"), Description("How many grid lines should be drawn in either X or Y direction?")] + public int GridNumberOfGridLines { get; set; } + + [Category("Grid"), Description("The grid spacing in X and Y direction in WorldUnits.")] + public Microsoft.Xna.Framework.Vector2 GridSpacing { get; set; } + + + + + public bool RunLevelStartApplication; + public string RunLevelApplicationToStart; + public bool RunLevelAppendLevelFilename; + + + public bool SaveLevelStartApplication; + public string SaveLevelApplicationToStart; + public bool SaveLevelAppendLevelFilename; + + + public bool ShowGrid; + public bool SnapToGrid; + public bool ShowWorldOrigin; + + + + + //XML import and export + public void export(string filename) + { + string path = System.Windows.Forms.Application.StartupPath + "\\" + filename; + FileStream stream = File.Open(path, FileMode.Create); + XmlSerializer serializer = new XmlSerializer(typeof(Constants)); + serializer.Serialize(stream, this); + stream.Close(); + } + public void import(string filename) + { + string path = System.Windows.Forms.Application.StartupPath + "\\" + filename; + if (!File.Exists(path)) return; + FileStream stream = File.Open(path, FileMode.Open); + XmlSerializer serializer = new XmlSerializer(typeof(Constants)); + instance = (Constants)serializer.Deserialize(stream); + stream.Close(); + } + + + } + +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/CustomUITypeEditors/FolderUITypeEditor.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/CustomUITypeEditors/FolderUITypeEditor.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,39 @@ +using System; +using System.ComponentModel; +using System.Drawing.Design; +using System.Reflection; +using System.Windows.Forms; +using System.Windows.Forms.Design; +using Microsoft.Xna.Framework.Graphics; + + +namespace CustomUITypeEditors +{ + + /// + /// A FolderEditor that always starts at the currently selected folder. For use on a property of type: string. + /// + public class FolderUITypeEditor : UITypeEditor + { + public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) + { + return UITypeEditorEditStyle.Modal; + } + + public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) + { + string path = Convert.ToString(value); + using (FolderBrowserDialog dlg = new FolderBrowserDialog()) + { + dlg.SelectedPath = path; + if (dlg.ShowDialog() == DialogResult.OK) + { + path = dlg.SelectedPath; + } + } + return path; + } + } + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/CustomUITypeEditors/ItemSelector.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/CustomUITypeEditors/ItemSelector.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,61 @@ +namespace CustomUITypeEditors +{ + partial class ItemSelector + { + /// + /// Erforderliche Designervariable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Verwendete Ressourcen bereinigen. + /// + /// True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Vom Komponenten-Designer generierter Code + + /// + /// Erforderliche Methode für die Designerunterstützung. + /// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden. + /// + private void InitializeComponent() + { + this.treeView1 = new System.Windows.Forms.TreeView(); + this.SuspendLayout(); + // + // treeView1 + // + this.treeView1.Dock = System.Windows.Forms.DockStyle.Fill; + this.treeView1.Location = new System.Drawing.Point(0, 0); + this.treeView1.Name = "treeView1"; + this.treeView1.Size = new System.Drawing.Size(208, 260); + this.treeView1.TabIndex = 0; + this.treeView1.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.treeView1_AfterSelect); + // + // ItemSelector + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.Control; + this.Controls.Add(this.treeView1); + this.Name = "ItemSelector"; + this.Size = new System.Drawing.Size(208, 260); + this.Load += new System.EventHandler(this.ItemSelector_Load); + this.ResumeLayout(false); + + } + + #endregion + + public System.Windows.Forms.TreeView treeView1; + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/CustomUITypeEditors/ItemSelector.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/CustomUITypeEditors/ItemSelector.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,86 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Data; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using System.Drawing.Design; +using System.Windows.Forms.Design; +using GLEED2D; + +namespace CustomUITypeEditors +{ + public partial class ItemSelector : UserControl + { + public Item Value; + + public ItemSelector(Item item) + { + InitializeComponent(); + Value = item; + } + + private void ItemSelector_Load(object sender, EventArgs e) + { + treeView1.Nodes.Add((TreeNode)MainForm.Instance.treeView1.Nodes[0].Clone()); + treeView1.ImageList = MainForm.Instance.treeView1.ImageList; + treeView1.ImageIndex = treeView1.SelectedImageIndex = 5; + treeView1.Nodes[0].Expand(); + if (Value != null) + { + TreeNode[] nodes = treeView1.Nodes.Find(Value.Name, true); + if (nodes.Length > 0) + { + treeView1.SelectedNode = nodes[0]; + } + else + { + Value = null; + } + } + } + + private void treeView1_AfterSelect(object sender, TreeViewEventArgs e) + { + if (e.Node.Tag is Item) Value = (Item)e.Node.Tag; + } + + } + + + public class ItemUITypeEditor : UITypeEditor + { + public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) + { + return UITypeEditorEditStyle.DropDown; + } + + public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) + { + IWindowsFormsEditorService wfes = + provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; + + if (wfes != null) + { + ItemSelector uc1 = new ItemSelector((Item)value); + wfes.DropDownControl(uc1); + value = uc1.Value; + } + return value; + } + + public override bool IsDropDownResizable + { + get + { + return true; + } + } + + + } + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/CustomUITypeEditors/ItemSelector.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/CustomUITypeEditors/ItemSelector.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/CustomUITypeEditors/Vector2UITypeEditor.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/CustomUITypeEditors/Vector2UITypeEditor.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,296 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Drawing.Design; +using System.Windows.Forms; +using System.Windows.Forms.Design; +using Microsoft.Xna.Framework; + +namespace CustomUITypeEditors +{ + + + + class Vector2EditorControl : UserControl + { + public Vector2 Value; + double angle; + double length; + Vector2 center = new Vector2(70, 70); + float radius = 65; + string format = "####0.###"; + int precision = 3; + + public Vector2EditorControl(Vector2 initialvalue) + { + InitializeComponent(); + Value = initialvalue; + tbX.Text = Value.X.ToString(format); + tbY.Text = Value.Y.ToString(format); + onValueUpdated(); + } + + private void pictureBox1_Paint(object sender, PaintEventArgs e) + { + Graphics g = e.Graphics; + g.DrawEllipse(new Pen(System.Drawing.Color.Black, 3), center.X - radius, center.Y - radius, 2 * radius, 2 * radius); + + if (Value == Vector2.Zero) return; + + //draw blue arc to visualize angle + g.DrawLine(new Pen(System.Drawing.Color.Blue, 1), center.X, center.Y, center.X + radius, center.Y); + g.DrawArc(new Pen(System.Drawing.Color.Blue, 1), center.X - 20, center.Y - 20, 40, 40, 0, (int)MathHelper.ToDegrees((float)angle)); + + //draw black arrow + Vector2 newpos = Vector2.Transform(Vector2.UnitX * radius, Matrix.CreateRotationZ((float)angle)); + Vector2 arrowpos1 = Vector2.Transform((Vector2.UnitX + new Vector2(-0.3f, -0.1f)) * radius, Matrix.CreateRotationZ((float)angle)); + Vector2 arrowpos2 = Vector2.Transform((Vector2.UnitX + new Vector2(-0.3f, +0.1f)) * radius, Matrix.CreateRotationZ((float)angle)); + g.DrawLine(new Pen(System.Drawing.Color.Black, 3), center.X, center.Y, center.X + newpos.X, center.Y + newpos.Y); + g.DrawLine(new Pen(System.Drawing.Color.Black, 3), center.X + newpos.X, center.Y + newpos.Y, center.X + arrowpos1.X, center.Y + arrowpos1.Y); + g.DrawLine(new Pen(System.Drawing.Color.Black, 3), center.X + newpos.X, center.Y + newpos.Y, center.X + arrowpos2.X, center.Y + arrowpos2.Y); + } + + private void onValueUpdated() + { + length = Value.Length(); + tbLength.Text = length.ToString(format); + angle = Math.Atan2(Value.Y, Value.X); + tbAngle.Text = MathHelper.ToDegrees((float)angle).ToString(format); + pictureBox1.Invalidate(); + } + + private void onAngleOrLengthUpdated() + { + Value.X = (float)Math.Round(Math.Cos(angle) * length, precision); + tbX.Text = Value.X.ToString(format); + Value.Y = (float)Math.Round(Math.Sin(angle) * length, precision); + tbY.Text = Value.Y.ToString(format); + pictureBox1.Invalidate(); + } + + private void pictureBox1_MouseMove(object sender, MouseEventArgs e) + { + if (e.Button == MouseButtons.Left) + { + Vector2 mousepos = new Vector2(e.X, e.Y) - center; + angle = Math.Atan2(mousepos.Y, mousepos.X); + onAngleOrLengthUpdated(); + onValueUpdated(); + } + } + + private void tbX_KeyUp(object sender, KeyEventArgs e) + { + try + { + Value.X = (float)Convert.ToDouble(tbX.Text); + onValueUpdated(); + } + catch + { + } + } + + private void tbY_KeyUp(object sender, KeyEventArgs e) + { + try + { + Value.Y = (float)Convert.ToDouble(tbY.Text); + onValueUpdated(); + } + catch + { + } + } + + private void tbAngle_KeyUp(object sender, KeyEventArgs e) + { + try + { + angle = MathHelper.ToRadians((float)Convert.ToDouble(tbAngle.Text)); + onAngleOrLengthUpdated(); + } + catch + { + } + } + + private void tbLength_KeyUp(object sender, KeyEventArgs e) + { + try + { + length = Convert.ToDouble(tbLength.Text); + onAngleOrLengthUpdated(); + } + catch + { + } + } + + + + + private System.ComponentModel.IContainer components = null; + + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.tbX = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.tbY = new System.Windows.Forms.TextBox(); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.tbLength = new System.Windows.Forms.TextBox(); + this.label3 = new System.Windows.Forms.Label(); + this.tbAngle = new System.Windows.Forms.TextBox(); + this.label5 = new System.Windows.Forms.Label(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.SuspendLayout(); + // + // tbX + // + this.tbX.Location = new System.Drawing.Point(26, 6); + this.tbX.Name = "tbX"; + this.tbX.Size = new System.Drawing.Size(68, 20); + this.tbX.TabIndex = 1; + this.tbX.KeyUp += new System.Windows.Forms.KeyEventHandler(this.tbX_KeyUp); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(3, 9); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(17, 13); + this.label1.TabIndex = 2; + this.label1.Text = "X:"; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(129, 9); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(17, 13); + this.label2.TabIndex = 4; + this.label2.Text = "Y:"; + // + // tbY + // + this.tbY.Location = new System.Drawing.Point(152, 6); + this.tbY.Name = "tbY"; + this.tbY.Size = new System.Drawing.Size(68, 20); + this.tbY.TabIndex = 2; + this.tbY.KeyUp += new System.Windows.Forms.KeyEventHandler(this.tbY_KeyUp); + // + // pictureBox1 + // + this.pictureBox1.Location = new System.Drawing.Point(6, 35); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(140, 140); + this.pictureBox1.TabIndex = 6; + this.pictureBox1.TabStop = false; + this.pictureBox1.MouseMove += new System.Windows.Forms.MouseEventHandler(this.pictureBox1_MouseMove); + this.pictureBox1.Paint += new System.Windows.Forms.PaintEventHandler(this.pictureBox1_Paint); + // + // tbLength + // + this.tbLength.Location = new System.Drawing.Point(152, 155); + this.tbLength.Name = "tbLength"; + this.tbLength.Size = new System.Drawing.Size(68, 20); + this.tbLength.TabIndex = 4; + this.tbLength.KeyUp += new System.Windows.Forms.KeyEventHandler(this.tbLength_KeyUp); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(177, 137); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(43, 13); + this.label3.TabIndex = 8; + this.label3.Text = "Length:"; + // + // tbAngle + // + this.tbAngle.Location = new System.Drawing.Point(152, 107); + this.tbAngle.Name = "tbAngle"; + this.tbAngle.Size = new System.Drawing.Size(68, 20); + this.tbAngle.TabIndex = 3; + this.tbAngle.KeyUp += new System.Windows.Forms.KeyEventHandler(this.tbAngle_KeyUp); + // + // label5 + // + this.label5.AutoSize = true; + this.label5.Location = new System.Drawing.Point(183, 89); + this.label5.Name = "label5"; + this.label5.Size = new System.Drawing.Size(37, 13); + this.label5.TabIndex = 8; + this.label5.Text = "Angle:"; + // + // Vector2EditorControl + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.Control; + this.Controls.Add(this.tbAngle); + this.Controls.Add(this.label5); + this.Controls.Add(this.label3); + this.Controls.Add(this.tbLength); + this.Controls.Add(this.pictureBox1); + this.Controls.Add(this.label2); + this.Controls.Add(this.tbY); + this.Controls.Add(this.label1); + this.Controls.Add(this.tbX); + this.Name = "Vector2EditorControl"; + this.Size = new System.Drawing.Size(223, 180); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + private System.Windows.Forms.TextBox tbX; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.TextBox tbY; + private System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.TextBox tbLength; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.TextBox tbAngle; + private System.Windows.Forms.Label label5; + } + + + + public class Vector2UITypeEditor : UITypeEditor + { + public override UITypeEditorEditStyle GetEditStyle(ITypeDescriptorContext context) + { + return UITypeEditorEditStyle.DropDown; + } + + public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) + { + IWindowsFormsEditorService wfes = + provider.GetService(typeof(IWindowsFormsEditorService)) as IWindowsFormsEditorService; + + if (wfes != null) + { + Vector2EditorControl uc1 = new Vector2EditorControl((Vector2)value); + wfes.DropDownControl(uc1); + value = uc1.Value; + } + return value; + } + } + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/CustomUITypeEditors/Vector2UITypeEditor.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/CustomUITypeEditors/Vector2UITypeEditor.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/CustomUITypeEditors/XNAColorUITypeEditors.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/CustomUITypeEditors/XNAColorUITypeEditors.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,227 @@ +using System; +using System.ComponentModel; +using System.Drawing.Design; +using System.Reflection; +using System.Windows.Forms; +using System.Windows.Forms.Design; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework; + + +namespace CustomUITypeEditors +{ + + /// + /// Class extending the which adds the capability to change the + /// alpha value of the color. For use on a property of type: Microsoft.Xna.Framework.Graphics.Color. + /// + public class XNAColorUITypeEditor : ColorEditor + { + /// + /// Wrapper for the private ColorUI class nested within . + /// It publishes its internals via reflection and adds a to + /// adjust the alpha value. + /// + public class ColorUIWrapper + { + private Control _control; + private MethodInfo _startMethodInfo; + private MethodInfo _endMethodInfo; + private PropertyInfo _valuePropertyInfo; + private TrackBar _tbAlpha; + private Label _lblAlpha; + private bool _inSizeChange = false; + + /// + /// Creates a new instance. + /// + /// The editor this instance belongs to. + public ColorUIWrapper(XNAColorUITypeEditor colorEditor) + { + Type colorUiType = typeof(ColorEditor).GetNestedType("ColorUI", BindingFlags.CreateInstance | BindingFlags.NonPublic); + ConstructorInfo constructorInfo = colorUiType.GetConstructor(new Type[] { typeof(ColorEditor) }); + _control = (Control)constructorInfo.Invoke(new object[] { colorEditor }); + + _control.BackColor = System.Drawing.SystemColors.Control; + + Panel alphaPanel = new Panel(); + alphaPanel.BackColor = System.Drawing.SystemColors.Control; + alphaPanel.Dock = DockStyle.Right; + alphaPanel.Width = 28; + _control.Controls.Add(alphaPanel); + + _tbAlpha = new TrackBar(); + _tbAlpha.Orientation = Orientation.Vertical; + _tbAlpha.Dock = DockStyle.Fill; + _tbAlpha.TickStyle = TickStyle.None; + _tbAlpha.Maximum = byte.MaxValue; + _tbAlpha.Minimum = byte.MinValue; + _tbAlpha.ValueChanged += new EventHandler(OnTrackBarAlphaValueChanged); + alphaPanel.Controls.Add(_tbAlpha); + + _lblAlpha = new Label(); + _lblAlpha.Text = "0"; + _lblAlpha.Dock = DockStyle.Bottom; + _lblAlpha.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + alphaPanel.Controls.Add(_lblAlpha); + + _startMethodInfo = _control.GetType().GetMethod("Start"); + _endMethodInfo = _control.GetType().GetMethod("End"); + _valuePropertyInfo = _control.GetType().GetProperty("Value"); + + _control.SizeChanged += new EventHandler(OnControlSizeChanged); + } + + /// + /// The control to be shown when a color is edited. + /// The concrete type is ColorUI which is privately hidden + /// within System.Drawing.Design. + /// + public Control Control + { + get { return _control; } + } + + /// + /// Gets the edited color with applied alpha value. + /// + public object Value + { + get + { + object result = _valuePropertyInfo.GetValue(_control, new object[0]); + if (result is System.Drawing.Color) result = System.Drawing.Color.FromArgb(_tbAlpha.Value, (System.Drawing.Color)result); + return result; + } + } + + public void Start(IWindowsFormsEditorService service, object value) + { + if (value is System.Drawing.Color) _tbAlpha.Value = ((System.Drawing.Color)value).A; + _startMethodInfo.Invoke(_control, new object[] { service, value }); + } + + public void End() + { + _endMethodInfo.Invoke(_control, new object[0]); + } + + private void OnControlSizeChanged(object sender, EventArgs e) + { + if (_inSizeChange) return; + try + { + _inSizeChange = true; + TabControl tabControl = (TabControl)_control.Controls[0]; + System.Drawing.Size size = tabControl.TabPages[0].Controls[0].Size; + //Rectangle rectangle = tabControl.GetTabRect(0); + _control.Size = new System.Drawing.Size(_tbAlpha.Width + size.Width, size.Height + tabControl.GetTabRect(0).Height); + } + finally + { + _inSizeChange = false; + } + } + + private void OnTrackBarAlphaValueChanged(object sender, EventArgs e) + { + _lblAlpha.Text = _tbAlpha.Value.ToString(); + } + } + + private ColorUIWrapper _colorUI; + + public XNAColorUITypeEditor() + { + } + + /// + /// Edits the given value. + /// + /// Context infromation. + /// Service provider. + /// Value to be edited. + /// An edited value. + public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value) + { + if (provider != null) + { + IWindowsFormsEditorService service = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)); + if (service == null) return value; + + if (_colorUI == null) _colorUI = new ColorUIWrapper(this); + + Color xnacolor = (Color)value; + _colorUI.Start(service, System.Drawing.Color.FromArgb(xnacolor.A, xnacolor.R, xnacolor.G, xnacolor.B)); + + service.DropDownControl(_colorUI.Control); + if ((_colorUI.Value != null) /*&& (((Color)_colorUI.Value) != Color.Empty)*/) + { + //value = _colorUI.Value; + System.Drawing.Color rescolor = (System.Drawing.Color)_colorUI.Value; + value = new Color(rescolor.R, rescolor.G, rescolor.B, rescolor.A); + } + _colorUI.End(); + } + return value; + } + + + public override void PaintValue(PaintValueEventArgs e) + { + if (e.Value is Color && ((Color)e.Value).A <= byte.MaxValue) + { + Color xnacolor = (Color)e.Value; + System.Drawing.Color syscolor = System.Drawing.Color.FromArgb(xnacolor.A, xnacolor.R, xnacolor.G, xnacolor.B); + + int oneThird = e.Bounds.Width / 3; + using (System.Drawing.SolidBrush brush = new System.Drawing.SolidBrush(System.Drawing.Color.DarkGray)) + { + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 1, e.Bounds.Y + 1, 4, 4)); + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 9, e.Bounds.Y + 1, 4, 4)); + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 17, e.Bounds.Y + 1, 2, 4)); + + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 5, e.Bounds.Y + 5, 4, 4)); + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 13, e.Bounds.Y + 5, 4, 4)); + + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 1, e.Bounds.Y + 9, 4, 3)); + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 9, e.Bounds.Y + 9, 4, 3)); + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X + 17, e.Bounds.Y + 9, 2, 3)); + + } + using (System.Drawing.SolidBrush brush = new System.Drawing.SolidBrush(syscolor)) + { + e.Graphics.FillRectangle(brush, new System.Drawing.Rectangle(e.Bounds.X, e.Bounds.Y, e.Bounds.Width, e.Bounds.Height - 1)); + } + } + + if (e.Value is System.Drawing.Color) + { + base.PaintValue(e); + } + + } + + } + + + + + + + + + + + + + + + + + + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Editor.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Editor.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,1285 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Reflection; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using GLEED2D.Properties; +using Forms = System.Windows.Forms; + + +namespace GLEED2D +{ + enum EditorState + { + idle, + brush, //"stamp mode": user double clicked on an item to add multiple instances of it + cameramoving, //user is moving the camera + moving, //user is moving an item + rotating, //user is rotating an item + scaling, //user is scaling an item + selecting, //user has opened a select box by dragging the mouse (windows style) + brush_primitive //use is adding a primitive item + } + + enum PrimitiveType + { + Rectangle, Circle, Path + } + + class Editor + { + public static Editor Instance; + EditorState state; + Brush currentbrush; + PrimitiveType currentprimitive; + bool primitivestarted; + List clickedPoints = new List(); + Layer selectedlayer; + public Layer SelectedLayer + { + get { return selectedlayer; } + set { + selectedlayer = value; + if (value==null) MainForm.Instance.toolStripStatusLabel2.Text = "Layer: (none)"; + else MainForm.Instance.toolStripStatusLabel2.Text = "Layer: " + selectedlayer.Name; + } + } + Item lastitem; + public List SelectedItems; + Rectangle selectionrectangle = new Rectangle(); + Vector2 mouseworldpos, grabbedpoint, initialcampos, newPosition; + List initialpos; //position before user interaction + List initialrot; //rotation before user interaction + List initialscale; //scale before user interaction + public Level level; + public Camera camera; + KeyboardState kstate, oldkstate; + MouseState mstate, oldmstate; + Forms.Cursor cursorRot, cursorScale, cursorDup; + Stack undoBuffer = new Stack(); + Stack redoBuffer = new Stack(); + bool commandInProgress = false; + public Texture2D dummytexture; + bool drawSnappedPoint = false; + Vector2 posSnappedPoint = Vector2.Zero; + public string Version; + + + public Editor() + { + Logger.Instance.log("Editor creation started."); + + Instance = this; + state = EditorState.idle; + + SelectedItems = new List(); + initialpos = new List(); + initialrot = new List(); + initialscale = new List(); + + Version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(); + + Logger.Instance.log("Loading Resources."); + Stream resStream; + resStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("GLEED2D.Resources.cursors.dragcopy.cur"); + cursorDup = new Forms.Cursor(resStream); + resStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("GLEED2D.Resources.cursors.rotate.cur"); + cursorRot = new Forms.Cursor(resStream); + resStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("GLEED2D.Resources.cursors.scale.cur"); + cursorScale = new Forms.Cursor(resStream); + resStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("GLEED2D.Resources.circle.png"); + dummytexture = Texture2D.FromStream(Game1.Instance.GraphicsDevice, resStream); + //dummytexture = Texture2D.FromFile(Game1.Instance.GraphicsDevice, resStream); + Logger.Instance.log("Resources loaded."); + + Logger.Instance.log("Loading Settings."); + Constants.Instance.import("settings.xml"); + MainForm.Instance.ViewGrid.Checked = Constants.Instance.ShowGrid; + MainForm.Instance.ViewSnapToGrid.Checked = Constants.Instance.SnapToGrid; + MainForm.Instance.ViewWorldOrigin.Checked = Constants.Instance.ShowWorldOrigin; + Logger.Instance.log("Settings loaded."); + + Logger.Instance.log("Creating new level."); + MainForm.Instance.newLevel(); + Logger.Instance.log("New level created."); + + Logger.Instance.log("Editor creation ended."); + } + + + public void getSelectionFromLevel() + { + SelectedItems.Clear(); + SelectedLayer = null; + string[] itemnames = level.selecteditems.Split(';'); + foreach (string itemname in itemnames) + { + if (itemname.Length>0) SelectedItems.Add(level.getItemByName(itemname)); + } + SelectedLayer = level.getLayerByName(level.selectedlayers); + } + + public void selectlevel() + { + MainForm.Instance.propertyGrid1.SelectedObject = level; + } + + public void addLayer(Layer l) + { + l.level = level; + if (!l.level.Layers.Contains(l)) l.level.Layers.Add(l); + } + + public void deleteLayer(Layer l) + { + if (level.Layers.Count > 0) + { + Editor.Instance.beginCommand("Delete Layer \"" + l.Name + "\""); + level.Layers.Remove(l); + Editor.Instance.endCommand(); + } + if (level.Layers.Count > 0) SelectedLayer = level.Layers.Last(); + else SelectedLayer = null; + selectitem(null); + updatetreeview(); + } + + public void moveLayerUp(Layer l) + { + int index = level.Layers.IndexOf(l); + level.Layers[index] = level.Layers[index - 1]; + level.Layers[index - 1] = l; + selectlayer(l); + } + + public void moveLayerDown(Layer l) + { + int index = level.Layers.IndexOf(l); + level.Layers[index] = level.Layers[index + 1]; + level.Layers[index + 1] = l; + selectlayer(l); + } + + public void selectlayer(Layer l) + { + if (SelectedItems.Count > 0) selectitem(null); + SelectedLayer = l; + updatetreeviewselection(); + MainForm.Instance.propertyGrid1.SelectedObject = l; + } + + public void addItem(Item i) + { + if (!i.layer.Items.Contains(i)) i.layer.Items.Add(i); + } + + public void deleteSelectedItems() + { + beginCommand("Delete Item(s)"); + List selecteditemscopy = new List(SelectedItems); + + List itemsaffected = new List(); + + foreach (Item selitem in selecteditemscopy) { + + foreach (Layer l in level.Layers) + foreach (Item i in l.Items) + foreach (CustomProperty cp in i.CustomProperties.Values) + { + if (cp.type == typeof(Item) && cp.value == selitem) + { + cp.value = null; + itemsaffected.Add(i); + } + } + + selitem.layer.Items.Remove(selitem); + } + endCommand(); + selectitem(null); + updatetreeview(); + + if (itemsaffected.Count > 0) + { + string message = ""; + foreach (Item item in itemsaffected) message += item.Name + " (Layer: " + item.layer.Name + ")\n"; + Forms.MessageBox.Show("The following Items have Custom Properties of Type \"Item\" that refered to items that have just been deleted:\n\n" + + message + "\nThe corresponding Custom Properties have been set to NULL, since the Item referred to doesn't exist anymore."); + } + + } + + public void moveItemUp(Item i) + { + int index = i.layer.Items.IndexOf(i); + i.layer.Items[index] = i.layer.Items[index - 1]; + i.layer.Items[index - 1] = i; + //updatetreeview(); + } + + public void moveItemDown(Item i) + { + int index = i.layer.Items.IndexOf(i); + i.layer.Items[index] = i.layer.Items[index + 1]; + i.layer.Items[index + 1] = i; + selectitem(i); + //updatetreeview(); + } + + public void selectitem(Item i) + { + SelectedItems.Clear(); + if (i != null) + { + SelectedItems.Add(i); + SelectedLayer = i.layer; + updatetreeviewselection(); + MainForm.Instance.propertyGrid1.SelectedObject = i; + } + else + { + selectlayer(SelectedLayer); + } + } + + public void selectAll() + { + if (SelectedLayer == null) return; + //if (SelectedLayer.Items.Count == 0) return; + SelectedItems.Clear(); + foreach (Item i in SelectedLayer.Items) + { + SelectedItems.Add(i); + } + updatetreeviewselection(); + } + + public void moveItemToLayer(Item i1, Layer l2, Item i2) + { + int index2 = i2 == null ? 0 : l2.Items.IndexOf(i2); + i1.layer.Items.Remove(i1); + l2.Items.Insert(index2, i1); + i1.layer = l2; + } + public void moveSelectedItemsToLayer(Layer chosenlayer) + { + if (chosenlayer == SelectedLayer) return; + beginCommand("Move Item(s) To Layer \"" + chosenlayer.Name + "\""); + List selecteditemscopy = new List(SelectedItems); + foreach (Item i in selecteditemscopy) + { + moveItemToLayer(i, chosenlayer, null); + } + endCommand(); + SelectedItems.Clear(); + updatetreeview(); + } + public void copySelectedItemsToLayer(Layer chosenlayer) + { + //if (chosenlayer == SelectedLayer) return; + beginCommand("Copy Item(s) To Layer \"" + chosenlayer.Name + "\""); + List selecteditemscopy = new List(SelectedItems); + foreach (Item i in selecteditemscopy) + { + Item copy = i.clone(); + copy.layer = chosenlayer; + copy.Name = MainForm.Instance.getUniqueNameBasedOn(copy.Name); + addItem(copy); + } + endCommand(); + SelectedItems.Clear(); + updatetreeview(); + } + public void createTextureBrush(string fullpath) + { + state = EditorState.brush; + currentbrush = new Brush(fullpath); + } + + public void destroyTextureBrush() + { + state = EditorState.idle; + currentbrush = null; + } + + public void paintTextureBrush(bool continueAfterPaint) + { + if (SelectedLayer == null) + { + System.Windows.Forms.MessageBox.Show(Resources.No_Layer); + destroyTextureBrush(); + return; + } + Item i = new TextureItem(currentbrush.fullpath, new Vector2((int)mouseworldpos.X, (int)mouseworldpos.Y)); + i.Name = i.getNamePrefix() + level.getNextItemNumber(); + i.layer = SelectedLayer; + beginCommand("Add Item \"" + i.Name + "\""); + addItem(i); + endCommand(); + updatetreeview(); + if (!continueAfterPaint) destroyTextureBrush(); + } + + public void createPrimitiveBrush(PrimitiveType primitiveType) + { + if (SelectedLayer == null) + { + System.Windows.Forms.MessageBox.Show(Resources.No_Layer); + return; + } + + state = EditorState.brush_primitive; + primitivestarted = false; + clickedPoints.Clear(); + currentprimitive = primitiveType; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.Cross; + MainForm.Instance.listView2.Cursor = Forms.Cursors.Cross; + switch (primitiveType) + { + case PrimitiveType.Rectangle: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Rectangle_Entered; + break; + case PrimitiveType.Circle: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Circle_Entered; + break; + case PrimitiveType.Path: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Path_Entered; + break; + + } + } + + public void destroyPrimitiveBrush() + { + state = EditorState.idle; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.Default; + MainForm.Instance.listView2.Cursor = Forms.Cursors.Default; + } + + public void paintPrimitiveBrush() + { + switch (currentprimitive) + { + case PrimitiveType.Rectangle: + Item ri = new RectangleItem(Extensions.RectangleFromVectors(clickedPoints[0], clickedPoints[1])); + ri.Name = ri.getNamePrefix() + level.getNextItemNumber(); + ri.layer = SelectedLayer; + beginCommand("Add Item \"" + ri.Name + "\""); + addItem(ri); + endCommand(); + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Rectangle_Entered; + break; + case PrimitiveType.Circle: + Item ci = new CircleItem(clickedPoints[0], (mouseworldpos - clickedPoints[0]).Length()); + ci.Name = ci.getNamePrefix() + level.getNextItemNumber(); + ci.layer = SelectedLayer; + beginCommand("Add Item \"" + ci.Name + "\""); + addItem(ci); + endCommand(); + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Circle_Entered; + break; + case PrimitiveType.Path: + Item pi = new PathItem(clickedPoints.ToArray()); + pi.Name = pi.getNamePrefix() + level.getNextItemNumber(); + pi.layer = SelectedLayer; + beginCommand("Add Item \"" + pi.Name + "\""); + addItem(pi); + endCommand(); + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Path_Entered; + break; + } + updatetreeview(); + } + + + public void startMoving() + { + grabbedpoint = mouseworldpos; + + //save the distance to mouse for each item + initialpos.Clear(); + foreach (Item selitem in SelectedItems) + { + initialpos.Add(selitem.pPosition); + } + + state = EditorState.moving; + //MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.SizeAll; + } + + public void setmousepos(int screenx, int screeny) + { + Vector2 maincameraposition = camera.Position; + if (SelectedLayer != null) camera.Position *= SelectedLayer.ScrollSpeed; + mouseworldpos = Vector2.Transform(new Vector2(screenx, screeny), Matrix.Invert(camera.matrix)); + if (Constants.Instance.SnapToGrid || kstate.IsKeyDown(Keys.G)) + { + mouseworldpos = snapToGrid(mouseworldpos); + } + camera.Position = maincameraposition; + } + + public Item getItemAtPos(Vector2 mouseworldpos) + { + if (SelectedLayer==null) return null; + return SelectedLayer.getItemAtPos(mouseworldpos); + /*if (level.Layers.Count == 0) return null; + for (int i = level.Layers.Count - 1; i >= 0; i--) + { + Item item = level.Layers[i].getItemAtPos(mouseworldpos); + if (item != null) return item; + } + return null;*/ + } + + public void loadLevel(Level l) + { + if (l.ContentRootFolder == null) + { + l.ContentRootFolder = Constants.Instance.DefaultContentRootFolder; + if (!Directory.Exists(l.ContentRootFolder)) + { + Forms.DialogResult dr = Forms.MessageBox.Show( + "The DefaultContentRootFolder \"" + l.ContentRootFolder + "\" (as set in the Settings Dialog) doesn't exist!\n" + + "The ContentRootFolder of the new level will be set to the Editor's work directory (" + Forms.Application.StartupPath + ").\n" + + "Please adjust the DefaultContentRootFolder in the Settings Dialog.\n" + + "Do you want to open the Settings Dialog now?", "Error", + Forms.MessageBoxButtons.YesNo, Forms.MessageBoxIcon.Exclamation); + if (dr == Forms.DialogResult.Yes) new SettingsForm().ShowDialog(); + l.ContentRootFolder = Forms.Application.StartupPath; + } + } + else + { + if (!Directory.Exists(l.ContentRootFolder)) + { + Forms.MessageBox.Show("The directory \"" + l.ContentRootFolder + "\" doesn't exist! " + + "Please adjust the XML file before trying again."); + return; + } + } + + TextureLoader.Instance.Clear(); + + foreach (Layer layer in l.Layers) + { + layer.level = l; + foreach (Item item in layer.Items) + { + item.layer = layer; + if (!item.loadIntoEditor()) return; + } + } + + level = l; + MainForm.Instance.loadfolder(level.ContentRootFolder); + if (level.Name == null) level.Name = "Level_01"; + + + SelectedLayer = null; + if (level.Layers.Count > 0) SelectedLayer = level.Layers[0]; + SelectedItems.Clear(); + + + + camera = new Camera(MainForm.Instance.pictureBox1.Width, MainForm.Instance.pictureBox1.Height); + camera.Position = level.EditorRelated.CameraPosition; + MainForm.Instance.zoomcombo.Text = "100%"; + undoBuffer.Clear(); + redoBuffer.Clear(); + MainForm.Instance.undoButton.DropDownItems.Clear(); + MainForm.Instance.redoButton.DropDownItems.Clear(); + MainForm.Instance.undoButton.Enabled = MainForm.Instance.undoMenuItem.Enabled = undoBuffer.Count > 0; + MainForm.Instance.redoButton.Enabled = MainForm.Instance.redoMenuItem.Enabled = redoBuffer.Count > 0; + commandInProgress = false; + + updatetreeview(); + } + + public void updatetreeview() + { + MainForm.Instance.treeView1.Nodes.Clear(); + level.treenode = MainForm.Instance.treeView1.Nodes.Add(level.Name); + level.treenode.Tag = level; + level.treenode.Checked = level.Visible; + level.treenode.ContextMenuStrip = MainForm.Instance.LevelContextMenu; + + foreach (Layer layer in level.Layers) + { + Forms.TreeNode layernode = level.treenode.Nodes.Add(layer.Name, layer.Name); + layernode.Tag = layer; + layernode.Checked = layer.Visible; + layernode.ContextMenuStrip = MainForm.Instance.LayerContextMenu; + layernode.ImageIndex = layernode.SelectedImageIndex = 0; + + foreach (Item item in layer.Items) + { + Forms.TreeNode itemnode = layernode.Nodes.Add(item.Name, item.Name); + itemnode.Tag = item; + itemnode.Checked = true; + itemnode.ContextMenuStrip = MainForm.Instance.ItemContextMenu; + int imageindex = 0; + if (item is TextureItem) imageindex = 1; + if (item is RectangleItem) imageindex = 2; + if (item is CircleItem) imageindex = 3; + if (item is PathItem) imageindex = 4; + itemnode.ImageIndex = itemnode.SelectedImageIndex = imageindex; + } + layernode.Expand(); + } + level.treenode.Expand(); + + updatetreeviewselection(); + } + + public void updatetreeviewselection() + { + MainForm.Instance.propertyGrid1.SelectedObject = null; + if (SelectedItems.Count > 0) + { + Forms.TreeNode[] nodes = MainForm.Instance.treeView1.Nodes.Find(SelectedItems[0].Name, true); + if (nodes.Length > 0) + { + List selecteditemscopy = new List(SelectedItems); + MainForm.Instance.propertyGrid1.SelectedObject = SelectedItems[0]; + MainForm.Instance.treeView1.SelectedNode = nodes[0]; + MainForm.Instance.treeView1.SelectedNode.EnsureVisible(); + SelectedItems = selecteditemscopy; + } + } + else if (SelectedLayer != null) + { + Forms.TreeNode[] nodes = MainForm.Instance.treeView1.Nodes[0].Nodes.Find(SelectedLayer.Name, false); + if (nodes.Length > 0) + { + MainForm.Instance.treeView1.SelectedNode = nodes[0]; + MainForm.Instance.treeView1.SelectedNode.EnsureVisible(); + } + } + } + + public void saveLevel(string filename) + { + level.EditorRelated.CameraPosition = camera.Position; + level.EditorRelated.Version = Version; + level.export(filename); + } + + public void alignHorizontally() + { + beginCommand("Align Horizontally"); + foreach (Item i in SelectedItems) + { + i.pPosition = new Vector2(i.pPosition.X, SelectedItems[0].pPosition.Y); + } + endCommand(); + } + + public void alignVertically() + { + beginCommand("Align Vertically"); + foreach (Item i in SelectedItems) + { + i.pPosition = new Vector2(SelectedItems[0].pPosition.X, i.pPosition.Y); + } + endCommand(); + } + + public void alignRotation() + { + beginCommand("Align Rotation"); + foreach (TextureItem i in SelectedItems) + { + i.pRotation = ((TextureItem)SelectedItems[0]).pRotation; + } + endCommand(); + } + + public void alignScale() + { + beginCommand("Align Scale"); + foreach (TextureItem i in SelectedItems) + { + i.pScale = ((TextureItem)SelectedItems[0]).pScale; + } + endCommand(); + } + + + + + + + public void beginCommand(string description) + { + //System.Diagnostics.Debug.WriteLine(System.DateTime.Now.ToString() + ": beginCommand(" + description + ")"); + if (commandInProgress) + { + undoBuffer.Pop(); + } + undoBuffer.Push(new Command(description)); + commandInProgress = true; + } + public void endCommand() + { + if (!commandInProgress) return; + //System.Diagnostics.Debug.WriteLine(System.DateTime.Now.ToString() + ": endCommand()"); + undoBuffer.Peek().saveAfterState(); + redoBuffer.Clear(); + MainForm.Instance.redoButton.DropDownItems.Clear(); + MainForm.Instance.DirtyFlag = true; + MainForm.Instance.undoButton.Enabled = MainForm.Instance.undoMenuItem.Enabled = undoBuffer.Count > 0; + MainForm.Instance.redoButton.Enabled = MainForm.Instance.redoMenuItem.Enabled = redoBuffer.Count > 0; + + Forms.ToolStripMenuItem item = new Forms.ToolStripMenuItem(undoBuffer.Peek().Description); + item.Tag = undoBuffer.Peek(); + MainForm.Instance.undoButton.DropDownItems.Insert(0, item); + commandInProgress = false; + } + public void abortCommand() + { + if (!commandInProgress) return; + undoBuffer.Pop(); + commandInProgress = false; + } + public void undo() + { + if (commandInProgress) + { + undoBuffer.Pop(); + commandInProgress = false; + } + if (undoBuffer.Count == 0) return; + undoBuffer.Peek().Undo(); + redoBuffer.Push(undoBuffer.Pop()); + MainForm.Instance.propertyGrid1.Refresh(); + MainForm.Instance.DirtyFlag = true; + MainForm.Instance.undoButton.Enabled = MainForm.Instance.undoMenuItem.Enabled = undoBuffer.Count > 0; + MainForm.Instance.redoButton.Enabled = MainForm.Instance.redoMenuItem.Enabled = redoBuffer.Count > 0; + MainForm.Instance.redoButton.DropDownItems.Insert(0, MainForm.Instance.undoButton.DropDownItems[0]); + } + public void undoMany(Command c) + { + while (redoBuffer.Count==0 || redoBuffer.Peek() != c) undo(); + } + public void redo() + { + if (commandInProgress) + { + undoBuffer.Pop(); + commandInProgress = false; + } + if (redoBuffer.Count == 0) return; + redoBuffer.Peek().Redo(); + undoBuffer.Push(redoBuffer.Pop()); + MainForm.Instance.propertyGrid1.Refresh(); + MainForm.Instance.DirtyFlag = true; + MainForm.Instance.undoButton.Enabled = MainForm.Instance.undoMenuItem.Enabled = undoBuffer.Count > 0; + MainForm.Instance.redoButton.Enabled = MainForm.Instance.redoMenuItem.Enabled = redoBuffer.Count > 0; + MainForm.Instance.undoButton.DropDownItems.Insert(0, MainForm.Instance.redoButton.DropDownItems[0]); + } + public void redoMany(Command c) + { + while (undoBuffer.Count == 0 || undoBuffer.Peek() != c) redo(); + } + + + public Vector2 snapToGrid(Vector2 input) + { + + Vector2 result = input; + result.X = Constants.Instance.GridSpacing.X * (int)Math.Round(result.X / Constants.Instance.GridSpacing.X); + result.Y = Constants.Instance.GridSpacing.Y * (int)Math.Round(result.Y / Constants.Instance.GridSpacing.Y); + posSnappedPoint = result; + drawSnappedPoint = true; + return result; + } + + public void update(GameTime gt) + { + if (level == null) return; + + oldkstate = kstate; + oldmstate = mstate; + kstate = Keyboard.GetState(); + mstate = Mouse.GetState(); + int mwheeldelta = mstate.ScrollWheelValue - oldmstate.ScrollWheelValue; + if (mwheeldelta > 0 /* && kstate.IsKeyDown(Keys.LeftControl)*/) + { + float zoom = (float)Math.Round(camera.Scale * 10) * 10.0f + 10.0f; + MainForm.Instance.zoomcombo.Text = zoom.ToString() + "%"; + camera.Scale = zoom / 100.0f; + } + if (mwheeldelta < 0 /* && kstate.IsKeyDown(Keys.LeftControl)*/) + { + float zoom = (float)Math.Round(camera.Scale * 10) * 10.0f - 10.0f; + if (zoom <= 0.0f) return; + MainForm.Instance.zoomcombo.Text = zoom.ToString() + "%"; + camera.Scale = zoom / 100.0f; + } + + //Camera movement + float delta; + if (kstate.IsKeyDown(Keys.LeftShift)) delta = Constants.Instance.CameraFastSpeed * (float)gt.ElapsedGameTime.TotalSeconds; + else delta = Constants.Instance.CameraSpeed * (float)gt.ElapsedGameTime.TotalSeconds; + if (kstate.IsKeyDown(Keys.W) && kstate.IsKeyUp(Keys.LeftControl)) camera.Position += (new Vector2(0, -delta)); + if (kstate.IsKeyDown(Keys.S) && kstate.IsKeyUp(Keys.LeftControl)) camera.Position += (new Vector2(0, +delta)); + if (kstate.IsKeyDown(Keys.A) && kstate.IsKeyUp(Keys.LeftControl)) camera.Position += (new Vector2(-delta, 0)); + if (kstate.IsKeyDown(Keys.D) && kstate.IsKeyUp(Keys.LeftControl)) camera.Position += (new Vector2(+delta, 0)); + + + if (kstate.IsKeyDown(Keys.Subtract)) + { + float zoom = (float)(camera.Scale * 0.995); + MainForm.Instance.zoomcombo.Text = (zoom * 100).ToString("###0.0") + "%"; + camera.Scale = zoom; + } + if (kstate.IsKeyDown(Keys.Add)) + { + float zoom = (float)(camera.Scale * 1.005); + MainForm.Instance.zoomcombo.Text = (zoom * 100).ToString("###0.0") + "%"; + camera.Scale = zoom; + } + + //get mouse world position considering the ScrollSpeed of the current layer + Vector2 maincameraposition = camera.Position; + if (SelectedLayer != null) camera.Position *= SelectedLayer.ScrollSpeed; + mouseworldpos = Vector2.Transform(new Vector2(mstate.X, mstate.Y), Matrix.Invert(camera.matrix)); + mouseworldpos = mouseworldpos.Round(); + MainForm.Instance.toolStripStatusLabel3.Text = "Mouse: (" + mouseworldpos.X + ", " + mouseworldpos.Y + ")"; + camera.Position = maincameraposition; + + + if (state == EditorState.idle) + { + //get item under mouse cursor + Item item = getItemAtPos(mouseworldpos); + if (item != null) + { + MainForm.Instance.toolStripStatusLabel1.Text = item.Name; + item.onMouseOver(mouseworldpos); + if (kstate.IsKeyDown(Keys.LeftControl)) MainForm.Instance.pictureBox1.Cursor = cursorDup; + } + else + { + MainForm.Instance.toolStripStatusLabel1.Text = ""; + } + if (item != lastitem && lastitem != null) lastitem.onMouseOut(); + lastitem = item; + + //LEFT MOUSE BUTTON CLICK + if ((mstate.LeftButton == ButtonState.Pressed && oldmstate.LeftButton == ButtonState.Released) || + (kstate.IsKeyDown(Keys.D1) && oldkstate.IsKeyUp(Keys.D1))) + { + if (item != null) item.onMouseButtonDown(mouseworldpos); + if (kstate.IsKeyDown(Keys.LeftControl) && item != null) + { + if (!SelectedItems.Contains(item)) selectitem(item); + + beginCommand("Add Item(s)"); + + List selecteditemscopy = new List(); + foreach (Item selitem in SelectedItems) + { + Item i2 = (Item)selitem.clone(); + selecteditemscopy.Add(i2); + } + foreach (Item selitem in selecteditemscopy) + { + selitem.Name = selitem.getNamePrefix() + level.getNextItemNumber(); + addItem(selitem); + } + selectitem(selecteditemscopy[0]); + updatetreeview(); + for (int i = 1; i < selecteditemscopy.Count; i++) SelectedItems.Add(selecteditemscopy[i]); + startMoving(); + } + else if (kstate.IsKeyDown(Keys.LeftShift) && item != null) + { + if (SelectedItems.Contains(item)) SelectedItems.Remove(item); + else SelectedItems.Add(item); + } + else if (SelectedItems.Contains(item)) + { + beginCommand("Change Item(s)"); + startMoving(); + } + else if (!SelectedItems.Contains(item)) + { + selectitem(item); + if (item != null) + { + beginCommand("Change Item(s)"); + startMoving(); + } + else + { + grabbedpoint = mouseworldpos; + selectionrectangle = Rectangle.Empty; + state = EditorState.selecting; + } + + } + } + + //MIDDLE MOUSE BUTTON CLICK + if ((mstate.MiddleButton == ButtonState.Pressed && oldmstate.MiddleButton == ButtonState.Released) || + (kstate.IsKeyDown(Keys.D2) && oldkstate.IsKeyUp(Keys.D2))) + { + if (item != null) item.onMouseOut(); + if (kstate.IsKeyDown(Keys.LeftControl)) + { + grabbedpoint = new Vector2(mstate.X, mstate.Y); + initialcampos = camera.Position; + state = EditorState.cameramoving; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.SizeAll; + } + else + { + if (SelectedItems.Count > 0) + { + grabbedpoint = mouseworldpos - SelectedItems[0].pPosition; + + //save the initial rotation for each item + initialrot.Clear(); + foreach (Item selitem in SelectedItems) + { + if (selitem.CanRotate()) + { + initialrot.Add(selitem.getRotation()); + } + } + + state = EditorState.rotating; + MainForm.Instance.pictureBox1.Cursor = cursorRot; + + beginCommand("Rotate Item(s)"); + } + } + } + + //RIGHT MOUSE BUTTON CLICK + if ((mstate.RightButton == ButtonState.Pressed && oldmstate.RightButton == ButtonState.Released) || + (kstate.IsKeyDown(Keys.D3) && oldkstate.IsKeyUp(Keys.D3))) + + { + if (item != null) item.onMouseOut(); + if (SelectedItems.Count > 0) + { + grabbedpoint = mouseworldpos - SelectedItems[0].pPosition; + + //save the initial scale for each item + initialscale.Clear(); + foreach (Item selitem in SelectedItems) + { + if (selitem.CanScale()) + { + initialscale.Add(selitem.getScale()); + } + } + + state = EditorState.scaling; + MainForm.Instance.pictureBox1.Cursor = cursorScale; + + beginCommand("Scale Item(s)"); + } + } + + if (kstate.IsKeyDown(Keys.H) && oldkstate.GetPressedKeys().Length == 0 && SelectedItems.Count > 0) + { + beginCommand("Flip Item(s) Horizontally"); + foreach (Item selitem in SelectedItems) + { + if (selitem is TextureItem) + { + TextureItem ti = (TextureItem)selitem; + ti.FlipHorizontally = !ti.FlipHorizontally; + } + } + MainForm.Instance.propertyGrid1.Refresh(); + endCommand(); + } + if (kstate.IsKeyDown(Keys.V) && oldkstate.GetPressedKeys().Length == 0 && SelectedItems.Count > 0) + { + beginCommand("Flip Item(s) Vertically"); + foreach (Item selitem in SelectedItems) + { + if (selitem is TextureItem) + { + TextureItem ti = (TextureItem)selitem; + ti.FlipVertically = !ti.FlipVertically; + } + } + MainForm.Instance.propertyGrid1.Refresh(); + endCommand(); + } + } + + if (state == EditorState.moving) + { + int i = 0; + foreach (Item selitem in SelectedItems) + { + newPosition = initialpos[i] + mouseworldpos - grabbedpoint; + if (Constants.Instance.SnapToGrid || kstate.IsKeyDown(Keys.G)) newPosition = snapToGrid(newPosition); + drawSnappedPoint = false; + selitem.setPosition(newPosition); + i++; + } + MainForm.Instance.propertyGrid1.Refresh(); + if ((mstate.LeftButton == ButtonState.Released && oldmstate.LeftButton == ButtonState.Pressed) || + (kstate.IsKeyUp(Keys.D1) && oldkstate.IsKeyDown(Keys.D1))) + { + + foreach (Item selitem in SelectedItems) selitem.onMouseButtonUp(mouseworldpos); + + state = EditorState.idle; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.Default; + if (mouseworldpos != grabbedpoint) endCommand(); else abortCommand(); + } + } + + if (state == EditorState.rotating) + { + Vector2 newpos = mouseworldpos - SelectedItems[0].pPosition; + float deltatheta = (float)Math.Atan2(grabbedpoint.Y, grabbedpoint.X) - (float)Math.Atan2(newpos.Y, newpos.X); + int i = 0; + foreach (Item selitem in SelectedItems) + { + if (selitem.CanRotate()) + { + selitem.setRotation(initialrot[i] - deltatheta); + if (kstate.IsKeyDown(Keys.LeftControl)) + { + selitem.setRotation((float)Math.Round(selitem.getRotation() / MathHelper.PiOver4) * MathHelper.PiOver4); + } + i++; + } + } + MainForm.Instance.propertyGrid1.Refresh(); + if ((mstate.MiddleButton == ButtonState.Released && oldmstate.MiddleButton == ButtonState.Pressed) || + (kstate.IsKeyUp(Keys.D2) && oldkstate.IsKeyDown(Keys.D2))) + { + state = EditorState.idle; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.Default; + endCommand(); + } + } + + if (state == EditorState.scaling) + { + Vector2 newdistance = mouseworldpos - SelectedItems[0].pPosition; + float factor = newdistance.Length() / grabbedpoint.Length(); + int i = 0; + foreach (Item selitem in SelectedItems) + { + if (selitem.CanScale()) + { + if (selitem is TextureItem) + { + MainForm.Instance.toolStripStatusLabel1.Text = "Hold down [X] or [Y] to limit scaling to the according dimension."; + } + + Vector2 newscale = initialscale[i]; + if (!kstate.IsKeyDown(Keys.Y)) newscale.X = initialscale[i].X * (((factor - 1.0f) * 0.5f) + 1.0f); + if (!kstate.IsKeyDown(Keys.X)) newscale.Y = initialscale[i].Y * (((factor - 1.0f) * 0.5f) + 1.0f); + selitem.setScale(newscale); + + if (kstate.IsKeyDown(Keys.LeftControl)) + { + Vector2 scale; + scale.X = (float)Math.Round(selitem.getScale().X * 10) / 10; + scale.Y = (float)Math.Round(selitem.getScale().Y * 10) / 10; + selitem.setScale(scale); + } + i++; + } + } + MainForm.Instance.propertyGrid1.Refresh(); + if ((mstate.RightButton == ButtonState.Released && oldmstate.RightButton == ButtonState.Pressed) || + (kstate.IsKeyUp(Keys.D3) && oldkstate.IsKeyDown(Keys.D3))) + { + state = EditorState.idle; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.Default; + endCommand(); + } + } + + if (state == EditorState.cameramoving) + { + Vector2 newpos = new Vector2(mstate.X, mstate.Y); + Vector2 distance = (newpos - grabbedpoint) / camera.Scale; + if (distance.Length() > 0) + { + camera.Position = initialcampos - distance; + } + if (mstate.MiddleButton == ButtonState.Released) + { + state = EditorState.idle; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.Default; + } + } + + if (state == EditorState.selecting) + { + if (SelectedLayer == null) return; + Vector2 distance = mouseworldpos - grabbedpoint; + if (distance.Length() > 0) + { + SelectedItems.Clear(); + selectionrectangle = Extensions.RectangleFromVectors(grabbedpoint, mouseworldpos); + foreach (Item i in SelectedLayer.Items) + { + if (i.Visible && selectionrectangle.Contains((int)i.pPosition.X, (int)i.pPosition.Y)) SelectedItems.Add(i); + } + updatetreeviewselection(); + } + if (mstate.LeftButton == ButtonState.Released) + { + state = EditorState.idle; + MainForm.Instance.pictureBox1.Cursor = Forms.Cursors.Default; + } + } + + if (state == EditorState.brush) + { + if (Constants.Instance.SnapToGrid || kstate.IsKeyDown(Keys.G)) + { + mouseworldpos = snapToGrid(mouseworldpos); + } + if (mstate.RightButton == ButtonState.Pressed && oldmstate.RightButton == ButtonState.Released) state = EditorState.idle; + if (mstate.LeftButton == ButtonState.Pressed && oldmstate.LeftButton == ButtonState.Released) paintTextureBrush(true); + } + + + if (state == EditorState.brush_primitive) + { + + if (Constants.Instance.SnapToGrid || kstate.IsKeyDown(Keys.G)) mouseworldpos = snapToGrid(mouseworldpos); + + if (kstate.IsKeyDown(Keys.LeftControl) && primitivestarted && currentprimitive == PrimitiveType.Rectangle) + { + Vector2 distance = mouseworldpos - clickedPoints[0]; + float squareside = Math.Max(distance.X, distance.Y); + mouseworldpos = clickedPoints[0] + new Vector2(squareside, squareside); + } + if ((mstate.LeftButton == ButtonState.Pressed && oldmstate.LeftButton == ButtonState.Released) || + (kstate.IsKeyDown(Keys.D1) && oldkstate.IsKeyUp(Keys.D1))) + { + clickedPoints.Add(mouseworldpos); + if (primitivestarted == false) + { + primitivestarted = true; + switch (currentprimitive) + { + case PrimitiveType.Rectangle: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Rectangle_Started; + break; + case PrimitiveType.Circle: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Circle_Started; + break; + case PrimitiveType.Path: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Path_Started; + break; + } + } + else + { + if (currentprimitive != PrimitiveType.Path) + { + paintPrimitiveBrush(); + clickedPoints.Clear(); + primitivestarted = false; + } + } + } + if (kstate.IsKeyDown(Keys.Back) && oldkstate.IsKeyUp(Keys.Back)) + { + if (currentprimitive == PrimitiveType.Path && clickedPoints.Count > 1) + { + clickedPoints.RemoveAt(clickedPoints.Count-1); + } + } + + if ((mstate.MiddleButton == ButtonState.Pressed && oldmstate.MiddleButton == ButtonState.Released) || + (kstate.IsKeyDown(Keys.D2) && oldkstate.IsKeyUp(Keys.D2))) + { + if (currentprimitive == PrimitiveType.Path && primitivestarted) + { + paintPrimitiveBrush(); + clickedPoints.Clear(); + primitivestarted = false; + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Path_Entered; + } + } + if ((mstate.RightButton == ButtonState.Pressed && oldmstate.RightButton == ButtonState.Released) || + (kstate.IsKeyDown(Keys.D3) && oldkstate.IsKeyUp(Keys.D3))) + { + if (primitivestarted) + { + clickedPoints.Clear(); + primitivestarted = false; + switch (currentprimitive) + { + case PrimitiveType.Rectangle: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Rectangle_Entered; + break; + case PrimitiveType.Circle: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Circle_Entered; + break; + case PrimitiveType.Path: + MainForm.Instance.toolStripStatusLabel1.Text = Resources.Path_Entered; + break; + } + } + else + { + destroyPrimitiveBrush(); + clickedPoints.Clear(); + primitivestarted = false; + } + } + } + + } + + public void draw(SpriteBatch sb) + { + Game1.Instance.GraphicsDevice.Clear(Constants.Instance.ColorBackground); + if (level == null || !level.Visible) return; + foreach (Layer l in level.Layers) + { + Vector2 maincameraposition = camera.Position; + camera.Position *= l.ScrollSpeed; + //sb.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.None, camera.matrix); + sb.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, null, null, null, null, camera.matrix); + + l.drawInEditor(sb); + if (l == SelectedLayer && state == EditorState.selecting) + { + Primitives.Instance.drawBoxFilled(sb, selectionrectangle, Constants.Instance.ColorSelectionBox); + } + if (l == SelectedLayer && state == EditorState.brush) + { + sb.Draw(currentbrush.texture, new Vector2(mouseworldpos.X, mouseworldpos.Y), null, new Color(1f, 1f, 1f, 0.7f), + 0, new Vector2(currentbrush.texture.Width / 2, currentbrush.texture.Height / 2), 1, SpriteEffects.None, 0); + } + if (l == SelectedLayer && state == EditorState.brush_primitive && primitivestarted) + { + switch (currentprimitive) + { + case PrimitiveType.Rectangle: + Rectangle rect = Extensions.RectangleFromVectors(clickedPoints[0], mouseworldpos); + Primitives.Instance.drawBoxFilled(sb, rect, Constants.Instance.ColorPrimitives); + break; + case PrimitiveType.Circle: + Primitives.Instance.drawCircleFilled(sb, clickedPoints[0], (mouseworldpos - clickedPoints[0]).Length(), Constants.Instance.ColorPrimitives); + break; + case PrimitiveType.Path: + Primitives.Instance.drawPath(sb, clickedPoints.ToArray(), Constants.Instance.ColorPrimitives, Constants.Instance.DefaultPathItemLineWidth); + Primitives.Instance.drawLine(sb, clickedPoints.Last(), mouseworldpos, Constants.Instance.ColorPrimitives, Constants.Instance.DefaultPathItemLineWidth); + break; + + } + } + sb.End(); + //restore main camera position + camera.Position = maincameraposition; + } + + + //draw selection frames around selected items + if (SelectedItems.Count > 0) + { + Vector2 maincameraposition = camera.Position; + camera.Position *= SelectedItems[0].layer.ScrollSpeed; + sb.Begin(); + int i = 0; + foreach (Item item in SelectedItems) + { + if (item.Visible && item.layer.Visible && kstate.IsKeyUp(Keys.Space)) + { + Color color = i == 0 ? Constants.Instance.ColorSelectionFirst : Constants.Instance.ColorSelectionRest; + item.drawSelectionFrame(sb, camera.matrix, color); + if (i == 0 && (state == EditorState.rotating || state == EditorState.scaling)) + { + Vector2 center = Vector2.Transform(item.Position, camera.matrix); + Vector2 mouse = Vector2.Transform(mouseworldpos, camera.matrix); + Primitives.Instance.drawLine(sb, center, mouse, Constants.Instance.ColorSelectionFirst, 1); + } + } + i++; + } + sb.End(); + //restore main camera position + camera.Position = maincameraposition; + + } + + if (Constants.Instance.ShowGrid) + { + sb.Begin(); + int max = Constants.Instance.GridNumberOfGridLines/2; + for(int x=0; x<=max; x++) + { + Vector2 start = Vector2.Transform(new Vector2(x, -max) * Constants.Instance.GridSpacing.X, camera.matrix); + Vector2 end = Vector2.Transform(new Vector2(x, max) * Constants.Instance.GridSpacing.X, camera.matrix); + Primitives.Instance.drawLine(sb, start, end, Constants.Instance.GridColor, Constants.Instance.GridLineThickness); + start = Vector2.Transform(new Vector2(-x, -max) * Constants.Instance.GridSpacing.X, camera.matrix); + end = Vector2.Transform(new Vector2(-x, max) * Constants.Instance.GridSpacing.X, camera.matrix); + Primitives.Instance.drawLine(sb, start, end, Constants.Instance.GridColor, Constants.Instance.GridLineThickness); + } + for (int y = 0; y <= max; y++) + { + Vector2 start = Vector2.Transform(new Vector2(-max, y) * Constants.Instance.GridSpacing.Y, camera.matrix); + Vector2 end = Vector2.Transform(new Vector2(max, y) * Constants.Instance.GridSpacing.Y, camera.matrix); + Primitives.Instance.drawLine(sb, start, end, Constants.Instance.GridColor, Constants.Instance.GridLineThickness); + start = Vector2.Transform(new Vector2(-max, -y) * Constants.Instance.GridSpacing.Y, camera.matrix); + end = Vector2.Transform(new Vector2(max, -y) * Constants.Instance.GridSpacing.Y, camera.matrix); + Primitives.Instance.drawLine(sb, start, end, Constants.Instance.GridColor, Constants.Instance.GridLineThickness); + } + sb.End(); + } + if (Constants.Instance.ShowWorldOrigin) + { + sb.Begin(); + Vector2 worldOrigin = Vector2.Transform(Vector2.Zero, camera.matrix); + Primitives.Instance.drawLine(sb, worldOrigin + new Vector2(-20, 0), worldOrigin + new Vector2(+20, 0), Constants.Instance.WorldOriginColor, Constants.Instance.WorldOriginLineThickness); + Primitives.Instance.drawLine(sb, worldOrigin + new Vector2(0, -20), worldOrigin + new Vector2(0, 20), Constants.Instance.WorldOriginColor, Constants.Instance.WorldOriginLineThickness); + sb.End(); + } + + if (drawSnappedPoint) + { + sb.Begin(); + posSnappedPoint = Vector2.Transform(posSnappedPoint, camera.matrix); + Primitives.Instance.drawBoxFilled(sb, posSnappedPoint.X - 5, posSnappedPoint.Y - 5, 10, 10, Constants.Instance.ColorSelectionFirst); + sb.End(); + + } + + drawSnappedPoint = false; + + } + + + + + + + + + + + + + + + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Extensions.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Extensions.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,110 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Audio; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.GamerServices; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Media; +using Microsoft.Xna.Framework.Net; +using Microsoft.Xna.Framework.Storage; +using System.Drawing.Design; +using System.ComponentModel; +using System.Windows.Forms; +using System.IO; +using System.Windows.Forms.Design; +using System.Reflection; + + +namespace GLEED2D +{ + static class Extensions + { + + + public static Vector2 Round(this Vector2 v) + { + //v.X = (float)Math.Round(v.X); + //v.Y = (float)Math.Round(v.Y); + //return v; + return new Vector2((float)Math.Round(v.X), (float)Math.Round(v.Y)); + } + + public static Point ToPoint(this Vector2 v) + { + return new Point((int)Math.Round(v.X), (int)Math.Round(v.Y)); + } + + public static Vector2 ToVector2(this Point p) + { + return new Vector2(p.X, p.Y); + } + + public static float DistanceTo(this Vector2 v0, Vector2 v) + { + return (v - v0).Length(); + } + + public static float DistanceToLineSegment(this Vector2 v, Vector2 a, Vector2 b) + { + Vector2 x = b - a; + x.Normalize(); + float t = Vector2.Dot(x, v - a); + if (t < 0) return (a - v).Length(); + float d = (b - a).Length(); + if (t > d) return (b - v).Length(); + return (a + x * t - v).Length(); + + } + + public static Rectangle Transform(this Rectangle r, Matrix m) + { + Vector2[] poly = new Vector2[2]; + poly[0] = new Vector2(r.Left, r.Top); + poly[1] = new Vector2(r.Right, r.Bottom); + Vector2[] newpoly = new Vector2[2]; + Vector2.Transform(poly, ref m, newpoly); + + Rectangle result = new Rectangle(); + result.Location = newpoly[0].ToPoint(); + result.Width = (int)(newpoly[1].X - newpoly[0].X); + result.Height = (int)(newpoly[1].Y - newpoly[0].Y); + return result; + } + + /// + /// Convert the Rectangle to an array of Vector2 containing its 4 corners. + /// + /// + /// + /// An array of Vector2 representing the rectangle's corners starting from top/left and going clockwise. + public static Vector2[] ToPolygon(this Rectangle r) + { + Vector2[] poly = new Vector2[4]; + poly[0] = new Vector2(r.Left, r.Top); + poly[1] = new Vector2(r.Right, r.Top); + poly[2] = new Vector2(r.Right, r.Bottom); + poly[3] = new Vector2(r.Left, r.Bottom); + return poly; + } + + public static Rectangle RectangleFromVectors(Vector2 v1, Vector2 v2) + { + Vector2 distance = v2 - v1; + Rectangle result = new Rectangle(); + result.X = (int)Math.Min(v1.X, v2.X); + result.Y = (int)Math.Min(v1.Y, v2.Y); + result.Width = (int)Math.Abs(distance.X); + result.Height = (int)Math.Abs(distance.Y); + return result; + } + + } + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/About.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/About.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,96 @@ +namespace GLEED2D +{ + partial class AboutForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.button1 = new System.Windows.Forms.Button(); + this.textBox1 = new System.Windows.Forms.TextBox(); + this.linkLabel1 = new System.Windows.Forms.LinkLabel(); + this.SuspendLayout(); + // + // button1 + // + this.button1.DialogResult = System.Windows.Forms.DialogResult.OK; + this.button1.Location = new System.Drawing.Point(109, 240); + this.button1.Name = "button1"; + this.button1.Size = new System.Drawing.Size(75, 23); + this.button1.TabIndex = 0; + this.button1.Text = "OK"; + this.button1.UseVisualStyleBackColor = true; + this.button1.Click += new System.EventHandler(this.button1_Click); + // + // textBox1 + // + this.textBox1.BackColor = System.Drawing.SystemColors.Control; + this.textBox1.BorderStyle = System.Windows.Forms.BorderStyle.None; + this.textBox1.Location = new System.Drawing.Point(13, 13); + this.textBox1.Multiline = true; + this.textBox1.Name = "textBox1"; + this.textBox1.Size = new System.Drawing.Size(267, 112); + this.textBox1.TabIndex = 1; + this.textBox1.Text = "GLEED2D \r\n\r\nGeneric Level Editor 2D\r\n\r\nVersion {v}\r\n\r\nby zissakos (Zissis Siantid" + + "is)"; + this.textBox1.TextAlign = System.Windows.Forms.HorizontalAlignment.Center; + // + // linkLabel1 + // + this.linkLabel1.Location = new System.Drawing.Point(13, 132); + this.linkLabel1.Name = "linkLabel1"; + this.linkLabel1.Size = new System.Drawing.Size(267, 23); + this.linkLabel1.TabIndex = 2; + this.linkLabel1.TabStop = true; + this.linkLabel1.Text = "gleed2d.codeplex.com"; + this.linkLabel1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter; + this.linkLabel1.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel1_LinkClicked); + // + // AboutForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(292, 273); + this.ControlBox = false; + this.Controls.Add(this.linkLabel1); + this.Controls.Add(this.textBox1); + this.Controls.Add(this.button1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Name = "AboutForm"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "About"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button button1; + private System.Windows.Forms.TextBox textBox1; + private System.Windows.Forms.LinkLabel linkLabel1; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/About.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/About.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class AboutForm : Form + { + public AboutForm() + { + InitializeComponent(); + textBox1.Text = textBox1.Text.Replace("{v}", Editor.Instance.Version); + } + + private void button1_Click(object sender, EventArgs e) + { + Close(); + } + + private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) + { + System.Diagnostics.Process.Start("http://gleed2d.codeplex.com"); + } + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/About.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/About.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/AddCustomProperty.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/AddCustomProperty.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,208 @@ +namespace GLEED2D +{ + partial class AddCustomProperty + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.label1 = new System.Windows.Forms.Label(); + this.textBox1 = new System.Windows.Forms.TextBox(); + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonOK = new System.Windows.Forms.Button(); + this.label2 = new System.Windows.Forms.Label(); + this.textBox2 = new System.Windows.Forms.TextBox(); + this.label3 = new System.Windows.Forms.Label(); + this.radioButton1 = new System.Windows.Forms.RadioButton(); + this.radioButton2 = new System.Windows.Forms.RadioButton(); + this.radioButton3 = new System.Windows.Forms.RadioButton(); + this.radioButton4 = new System.Windows.Forms.RadioButton(); + this.radioButton5 = new System.Windows.Forms.RadioButton(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(13, 13); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(35, 13); + this.label1.TabIndex = 0; + this.label1.Text = "Name"; + // + // textBox1 + // + this.textBox1.Location = new System.Drawing.Point(96, 10); + this.textBox1.Name = "textBox1"; + this.textBox1.Size = new System.Drawing.Size(184, 20); + this.textBox1.TabIndex = 1; + // + // buttonCancel + // + this.buttonCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCancel.Location = new System.Drawing.Point(205, 235); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(75, 23); + this.buttonCancel.TabIndex = 9; + this.buttonCancel.Text = "Cancel"; + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.buttonCancel_Click); + // + // buttonOK + // + this.buttonOK.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonOK.Location = new System.Drawing.Point(124, 235); + this.buttonOK.Name = "buttonOK"; + this.buttonOK.Size = new System.Drawing.Size(75, 23); + this.buttonOK.TabIndex = 8; + this.buttonOK.Text = "OK"; + this.buttonOK.UseVisualStyleBackColor = true; + this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(13, 39); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(60, 13); + this.label2.TabIndex = 3; + this.label2.Text = "Description"; + // + // textBox2 + // + this.textBox2.Location = new System.Drawing.Point(96, 36); + this.textBox2.Multiline = true; + this.textBox2.Name = "textBox2"; + this.textBox2.Size = new System.Drawing.Size(184, 70); + this.textBox2.TabIndex = 2; + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(13, 114); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(31, 13); + this.label3.TabIndex = 5; + this.label3.Text = "Type"; + // + // radioButton1 + // + this.radioButton1.AutoSize = true; + this.radioButton1.Checked = true; + this.radioButton1.Location = new System.Drawing.Point(96, 112); + this.radioButton1.Name = "radioButton1"; + this.radioButton1.Size = new System.Drawing.Size(66, 17); + this.radioButton1.TabIndex = 3; + this.radioButton1.TabStop = true; + this.radioButton1.Text = "Free text"; + this.radioButton1.UseVisualStyleBackColor = true; + this.radioButton1.CheckedChanged += new System.EventHandler(this.radioButton1_CheckedChanged); + // + // radioButton2 + // + this.radioButton2.AutoSize = true; + this.radioButton2.Location = new System.Drawing.Point(96, 135); + this.radioButton2.Name = "radioButton2"; + this.radioButton2.Size = new System.Drawing.Size(64, 17); + this.radioButton2.TabIndex = 4; + this.radioButton2.Text = "Boolean"; + this.radioButton2.UseVisualStyleBackColor = true; + // + // radioButton3 + // + this.radioButton3.AutoSize = true; + this.radioButton3.Location = new System.Drawing.Point(96, 158); + this.radioButton3.Name = "radioButton3"; + this.radioButton3.Size = new System.Drawing.Size(62, 17); + this.radioButton3.TabIndex = 5; + this.radioButton3.Text = "Vector2"; + this.radioButton3.UseVisualStyleBackColor = true; + // + // radioButton4 + // + this.radioButton4.AutoSize = true; + this.radioButton4.Location = new System.Drawing.Point(96, 181); + this.radioButton4.Name = "radioButton4"; + this.radioButton4.Size = new System.Drawing.Size(49, 17); + this.radioButton4.TabIndex = 6; + this.radioButton4.Text = "Color"; + this.radioButton4.UseVisualStyleBackColor = true; + // + // radioButton5 + // + this.radioButton5.AutoSize = true; + this.radioButton5.Location = new System.Drawing.Point(96, 204); + this.radioButton5.Name = "radioButton5"; + this.radioButton5.Size = new System.Drawing.Size(45, 17); + this.radioButton5.TabIndex = 7; + this.radioButton5.Text = "Item"; + this.radioButton5.UseVisualStyleBackColor = true; + // + // AddCustomProperty + // + this.AcceptButton = this.buttonOK; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.buttonCancel; + this.ClientSize = new System.Drawing.Size(292, 270); + this.ControlBox = false; + this.Controls.Add(this.radioButton5); + this.Controls.Add(this.radioButton4); + this.Controls.Add(this.radioButton3); + this.Controls.Add(this.radioButton2); + this.Controls.Add(this.radioButton1); + this.Controls.Add(this.label3); + this.Controls.Add(this.textBox2); + this.Controls.Add(this.label2); + this.Controls.Add(this.buttonOK); + this.Controls.Add(this.buttonCancel); + this.Controls.Add(this.textBox1); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Name = "AddCustomProperty"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Add Custom Property"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox textBox1; + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonOK; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.TextBox textBox2; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.RadioButton radioButton1; + private System.Windows.Forms.RadioButton radioButton2; + private System.Windows.Forms.RadioButton radioButton3; + private System.Windows.Forms.RadioButton radioButton4; + private System.Windows.Forms.RadioButton radioButton5; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/AddCustomProperty.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/AddCustomProperty.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,81 @@ +using System; +using System.Windows.Forms; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace GLEED2D +{ + public partial class AddCustomProperty : Form + { + public CustomProperty cp = new CustomProperty(); + + SerializableDictionary customproperties; + + + public AddCustomProperty(SerializableDictionary currentproperties) + { + InitializeComponent(); + customproperties = currentproperties; + } + + private void buttonOK_Click(object sender, EventArgs e) + { + + if (customproperties.ContainsKey(textBox1.Text)) + { + MessageBox.Show("A Custom Property with that name already exists."); + return; + } + + if (textBox1.Text.Length==0) + { + MessageBox.Show("Please enter a Property Name."); + return; + } + + //CustomProperty cp = new CustomProperty(); + cp.name = textBox1.Text; + cp.description = textBox2.Text; + if (radioButton1.Checked) + { + cp.type = typeof(string); + cp.value = ""; + } + if (radioButton2.Checked) + { + cp.type = typeof(bool); + cp.value = false; + } + if (radioButton3.Checked) + { + cp.type = typeof(Vector2); + cp.value = new Vector2(1, 1); + } + if (radioButton4.Checked) + { + cp.type = typeof(Color); + cp.value = Color.White; + } + if (radioButton5.Checked) + { + cp.type = typeof(Item); + cp.value = null; + } + + customproperties[cp.name] = cp; + this.Close(); + } + + private void buttonCancel_Click(object sender, EventArgs e) + { + this.Close(); + } + + private void radioButton1_CheckedChanged(object sender, EventArgs e) + { + + } + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/AddCustomProperty.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/AddCustomProperty.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/AddLayer.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/AddLayer.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,103 @@ +namespace GLEED2D +{ + partial class AddLayer + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.label1 = new System.Windows.Forms.Label(); + this.textBox1 = new System.Windows.Forms.TextBox(); + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonOK = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(13, 13); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(64, 13); + this.label1.TabIndex = 0; + this.label1.Text = "Layer Name"; + // + // textBox1 + // + this.textBox1.Location = new System.Drawing.Point(83, 10); + this.textBox1.Name = "textBox1"; + this.textBox1.Size = new System.Drawing.Size(197, 20); + this.textBox1.TabIndex = 0; + // + // buttonCancel + // + this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCancel.Location = new System.Drawing.Point(205, 36); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(75, 23); + this.buttonCancel.TabIndex = 2; + this.buttonCancel.Text = "Cancel"; + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.buttonCancel_Click); + // + // buttonOK + // + this.buttonOK.Location = new System.Drawing.Point(124, 36); + this.buttonOK.Name = "buttonOK"; + this.buttonOK.Size = new System.Drawing.Size(75, 23); + this.buttonOK.TabIndex = 1; + this.buttonOK.Text = "OK"; + this.buttonOK.UseVisualStyleBackColor = true; + this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click); + // + // AddLayer + // + this.AcceptButton = this.buttonOK; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.buttonCancel; + this.ClientSize = new System.Drawing.Size(292, 72); + this.ControlBox = false; + this.Controls.Add(this.buttonOK); + this.Controls.Add(this.buttonCancel); + this.Controls.Add(this.textBox1); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Name = "AddLayer"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Add Layer"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox textBox1; + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonOK; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/AddLayer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/AddLayer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,43 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class AddLayer : Form + { + + public AddLayer(MainForm main) + { + InitializeComponent(); + } + + private void buttonOK_Click(object sender, EventArgs e) + { + + TreeNode[] nodes = MainForm.Instance.treeView1.Nodes.Find(textBox1.Text, true); + if (nodes.Length > 0) + { + MessageBox.Show("A layer or item with the name \"" + textBox1.Text + "\" already exists in the level. Please use another name!"); + return; + } + Layer l = new Layer(textBox1.Text); + Editor.Instance.beginCommand("Add Layer \"" + l.Name + "\""); + Editor.Instance.addLayer(l); + Editor.Instance.endCommand(); + Editor.Instance.SelectedLayer = l; + Editor.Instance.updatetreeview(); + this.Close(); + } + + private void buttonCancel_Click(object sender, EventArgs e) + { + this.Close(); + } + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/AddLayer.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/AddLayer.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/LayerSelectForm.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/LayerSelectForm.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,96 @@ +namespace GLEED2D +{ + partial class LayerSelectForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonOK = new System.Windows.Forms.Button(); + this.treeView1 = new System.Windows.Forms.TreeView(); + this.SuspendLayout(); + // + // buttonCancel + // + this.buttonCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCancel.Location = new System.Drawing.Point(285, 333); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(75, 23); + this.buttonCancel.TabIndex = 3; + this.buttonCancel.Text = "Cancel"; + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.buttonCancel_Click); + // + // buttonOK + // + this.buttonOK.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonOK.Location = new System.Drawing.Point(204, 333); + this.buttonOK.Name = "buttonOK"; + this.buttonOK.Size = new System.Drawing.Size(75, 23); + this.buttonOK.TabIndex = 2; + this.buttonOK.Text = "OK"; + this.buttonOK.UseVisualStyleBackColor = true; + this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click); + // + // treeView1 + // + this.treeView1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.treeView1.Location = new System.Drawing.Point(13, 13); + this.treeView1.Name = "treeView1"; + this.treeView1.Size = new System.Drawing.Size(347, 314); + this.treeView1.TabIndex = 4; + // + // LayerSelectForm + // + this.AcceptButton = this.buttonOK; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.buttonCancel; + this.ClientSize = new System.Drawing.Size(372, 368); + this.ControlBox = false; + this.Controls.Add(this.treeView1); + this.Controls.Add(this.buttonOK); + this.Controls.Add(this.buttonCancel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Name = "LayerSelectForm"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Select Layer"; + this.Load += new System.EventHandler(this.LayerSelectForm_Load); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonOK; + public System.Windows.Forms.TreeView treeView1; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/LayerSelectForm.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/LayerSelectForm.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,49 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class LayerSelectForm : Form + { + public LayerSelectForm() + { + InitializeComponent(); + } + + private void LayerSelectForm_Load(object sender, EventArgs e) + { + treeView1.ImageList = MainForm.Instance.treeView1.ImageList; + treeView1.ImageIndex = treeView1.SelectedImageIndex = 5; + TreeNode rootnode = treeView1.Nodes.Add(Editor.Instance.level.Name); + foreach (Layer l in Editor.Instance.level.Layers) + { + TreeNode node = rootnode.Nodes.Add(l.Name); + node.Tag = l; + node.ImageIndex = node.SelectedImageIndex = 0; + } + rootnode.Expand(); + } + + private void buttonCancel_Click(object sender, EventArgs e) + { + Close(); + DialogResult = DialogResult.Cancel; + } + + private void buttonOK_Click(object sender, EventArgs e) + { + Close(); + DialogResult = DialogResult.OK; + } + + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/LayerSelectForm.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/LayerSelectForm.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/LinkItemsForm.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/LinkItemsForm.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,191 @@ +namespace GLEED2D +{ + partial class LinkItemsForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonOK = new System.Windows.Forms.Button(); + this.label1 = new System.Windows.Forms.Label(); + this.textBox1 = new System.Windows.Forms.TextBox(); + this.checkBox1 = new System.Windows.Forms.CheckBox(); + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.groupBox2 = new System.Windows.Forms.GroupBox(); + this.checkBox2 = new System.Windows.Forms.CheckBox(); + this.textBox2 = new System.Windows.Forms.TextBox(); + this.label2 = new System.Windows.Forms.Label(); + this.groupBox1.SuspendLayout(); + this.groupBox2.SuspendLayout(); + this.SuspendLayout(); + // + // buttonCancel + // + this.buttonCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCancel.Location = new System.Drawing.Point(241, 213); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(75, 23); + this.buttonCancel.TabIndex = 0; + this.buttonCancel.Text = "Cancel"; + this.buttonCancel.UseVisualStyleBackColor = true; + // + // buttonOK + // + this.buttonOK.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonOK.Location = new System.Drawing.Point(160, 213); + this.buttonOK.Name = "buttonOK"; + this.buttonOK.Size = new System.Drawing.Size(75, 23); + this.buttonOK.TabIndex = 1; + this.buttonOK.Text = "OK"; + this.buttonOK.UseVisualStyleBackColor = true; + this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(6, 27); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(118, 13); + this.label1.TabIndex = 2; + this.label1.Text = "Custom Property Name:"; + // + // textBox1 + // + this.textBox1.Location = new System.Drawing.Point(130, 24); + this.textBox1.Name = "textBox1"; + this.textBox1.Size = new System.Drawing.Size(167, 20); + this.textBox1.TabIndex = 3; + this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged); + // + // checkBox1 + // + this.checkBox1.AutoSize = true; + this.checkBox1.Location = new System.Drawing.Point(12, 94); + this.checkBox1.Name = "checkBox1"; + this.checkBox1.Size = new System.Drawing.Size(188, 17); + this.checkBox1.TabIndex = 4; + this.checkBox1.Text = "Link second Item back to first Item"; + this.checkBox1.UseVisualStyleBackColor = true; + this.checkBox1.CheckedChanged += new System.EventHandler(this.checkBox1_CheckedChanged); + // + // groupBox1 + // + this.groupBox1.Controls.Add(this.textBox1); + this.groupBox1.Controls.Add(this.label1); + this.groupBox1.Location = new System.Drawing.Point(12, 12); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(304, 76); + this.groupBox1.TabIndex = 7; + this.groupBox1.TabStop = false; + this.groupBox1.Text = "First Item ($f)"; + // + // groupBox2 + // + this.groupBox2.Controls.Add(this.checkBox2); + this.groupBox2.Controls.Add(this.textBox2); + this.groupBox2.Controls.Add(this.label2); + this.groupBox2.Location = new System.Drawing.Point(12, 117); + this.groupBox2.Name = "groupBox2"; + this.groupBox2.Size = new System.Drawing.Size(304, 80); + this.groupBox2.TabIndex = 7; + this.groupBox2.TabStop = false; + this.groupBox2.Text = "Second Item ($s)"; + // + // checkBox2 + // + this.checkBox2.AutoSize = true; + this.checkBox2.Checked = true; + this.checkBox2.CheckState = System.Windows.Forms.CheckState.Checked; + this.checkBox2.Enabled = false; + this.checkBox2.Location = new System.Drawing.Point(130, 52); + this.checkBox2.Name = "checkBox2"; + this.checkBox2.Size = new System.Drawing.Size(107, 17); + this.checkBox2.TabIndex = 4; + this.checkBox2.Text = "same as first Item"; + this.checkBox2.UseVisualStyleBackColor = true; + this.checkBox2.CheckedChanged += new System.EventHandler(this.checkBox2_CheckedChanged); + // + // textBox2 + // + this.textBox2.Enabled = false; + this.textBox2.Location = new System.Drawing.Point(130, 25); + this.textBox2.Name = "textBox2"; + this.textBox2.Size = new System.Drawing.Size(167, 20); + this.textBox2.TabIndex = 3; + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Enabled = false; + this.label2.Location = new System.Drawing.Point(6, 28); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(118, 13); + this.label2.TabIndex = 2; + this.label2.Text = "Custom Property Name:"; + // + // LinkItemsForm + // + this.AcceptButton = this.buttonOK; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.buttonCancel; + this.ClientSize = new System.Drawing.Size(328, 248); + this.ControlBox = false; + this.Controls.Add(this.groupBox2); + this.Controls.Add(this.groupBox1); + this.Controls.Add(this.checkBox1); + this.Controls.Add(this.buttonOK); + this.Controls.Add(this.buttonCancel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Name = "LinkItemsForm"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Link Items by a Custom Property"; + this.VisibleChanged += new System.EventHandler(this.LinkItemsForm_VisibleChanged); + this.groupBox1.ResumeLayout(false); + this.groupBox1.PerformLayout(); + this.groupBox2.ResumeLayout(false); + this.groupBox2.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonOK; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox textBox1; + private System.Windows.Forms.CheckBox checkBox1; + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.GroupBox groupBox2; + private System.Windows.Forms.TextBox textBox2; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.CheckBox checkBox2; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/LinkItemsForm.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/LinkItemsForm.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,98 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class LinkItemsForm : Form + { + public LinkItemsForm() + { + InitializeComponent(); + } + + private void checkBox1_CheckedChanged(object sender, EventArgs e) + { + label2.Enabled = checkBox2.Enabled = checkBox1.Checked; + + textBox2.Text = ""; + updateSecondItem(); + } + + private void textBox1_TextChanged(object sender, EventArgs e) + { + updateSecondItem(); + } + + private void updateSecondItem() + { + textBox2.Enabled = checkBox1.Checked && !checkBox2.Checked; + if (!checkBox1.Checked) return; + if (checkBox2.Checked) textBox2.Text = textBox1.Text; + + } + + private void buttonOK_Click(object sender, EventArgs e) + { + if (textBox1.Text=="") + { + MessageBox.Show("Please specify a name for the Custom Property that is to be added to the first Item!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + if (checkBox1.Checked && textBox2.Text=="") + { + MessageBox.Show("Please specify a name for the Custom Property that is to be added to the second Item!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + if (Editor.Instance.SelectedItems[0].CustomProperties.ContainsKey(textBox1.Text)) + { + MessageBox.Show("The first Item (" + Editor.Instance.SelectedItems[0].Name + ") "+ + "already has a Custom Property named \"" + textBox1.Text + "\". Please use another name!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + CustomProperty cp = new CustomProperty(); + cp.name = textBox1.Text; + cp.type = typeof(Item); + cp.value = Editor.Instance.SelectedItems[1]; + Editor.Instance.SelectedItems[0].CustomProperties.Add(cp.name, cp); + + if (checkBox1.Checked) + { + if (Editor.Instance.SelectedItems[1].CustomProperties.ContainsKey(textBox2.Text)) + { + MessageBox.Show("The second Item (" + Editor.Instance.SelectedItems[1].Name + ") " + + "already has a Custom Property named \"" + textBox2.Text + "\". Please use another name!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + Editor.Instance.SelectedItems[0].CustomProperties.Remove(cp.name); + return; + } + cp = new CustomProperty(); + cp.name = textBox2.Text; + cp.type = typeof(Item); + cp.value = Editor.Instance.SelectedItems[0]; + Editor.Instance.SelectedItems[1].CustomProperties.Add(cp.name, cp); + } + + MainForm.Instance.propertyGrid1.Refresh(); + this.Hide(); + } + + private void LinkItemsForm_VisibleChanged(object sender, EventArgs e) + { + groupBox1.Text = groupBox1.Text.Replace("$f", Editor.Instance.SelectedItems[0].Name); + groupBox2.Text = groupBox2.Text.Replace("$s", Editor.Instance.SelectedItems[1].Name); + } + + private void checkBox2_CheckedChanged(object sender, EventArgs e) + { + updateSecondItem(); + } + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/LinkItemsForm.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/LinkItemsForm.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/MainForm.BackgroundWorker.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/MainForm.BackgroundWorker.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,177 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.IO; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using System.Reflection; +using System.Runtime.InteropServices; +using GLEED2D.Properties; +using System.Threading; + +namespace GLEED2D +{ + public partial class MainForm : Form + { + + public void loadfolder_background(string path) + { + if (backgroundWorker1.IsBusy) backgroundWorker1.CancelAsync(); + while (backgroundWorker1.IsBusy) + { + Application.DoEvents(); + Thread.Sleep(50); + } + imageList48.Images.Clear(); + imageList64.Images.Clear(); + imageList96.Images.Clear(); + imageList128.Images.Clear(); + imageList256.Images.Clear(); + listView1.Clear(); + + DirectoryInfo di = new DirectoryInfo(path); + textBox1.Text = di.FullName; + + DirectoryInfo[] folders = di.GetDirectories(); + foreach (DirectoryInfo folder in folders) + { + Image img = Resources.folder; + + imageList48.Images.Add(folder.Name, img); + imageList64.Images.Add(folder.Name, img); + imageList96.Images.Add(folder.Name, img); + imageList128.Images.Add(folder.Name, img); + imageList256.Images.Add(folder.Name, img); + + ListViewItem lvi = new ListViewItem(); + lvi.Text = folder.Name; + lvi.ToolTipText = folder.Name; + lvi.ImageIndex = imageList128.Images.IndexOfKey(folder.Name); + lvi.Tag = "folder"; + lvi.Name = folder.FullName; + listView1.Items.Add(lvi); + } + + string filters = "*.jpg;*.png;*.gif;*.bmp;*.tga"; + List fileList = new List(); + string[] extensions = filters.Split(';'); + foreach (string filter in extensions) fileList.AddRange(di.GetFiles(filter)); + FileInfo[] files = fileList.ToArray(); + + Bitmap bmp = new Bitmap(1, 1); + bmp.SetPixel(0, 0, Color.Azure); + imageList48.Images.Add("default", bmp); + imageList64.Images.Add("default", bmp); + imageList96.Images.Add("default", bmp); + imageList128.Images.Add("default", bmp); + imageList256.Images.Add("default", bmp); + foreach (FileInfo file in files) + { + ListViewItem lvi = new ListViewItem(); + lvi.Name = file.FullName; + lvi.Text = file.Name; + lvi.ImageKey = "default"; + lvi.Tag = "file"; + listView1.Items.Add(lvi); + } + + sw.Start(); + backgroundWorker1.RunWorkerAsync(files); + + } + + System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); + + public class PassedObject //for passing to background worker + { + public Bitmap bmp; + public FileInfo fileinfo; + public PassedObject() + { + } + } + + private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) + { + FileInfo[] files = (FileInfo[])e.Argument; + BackgroundWorker worker = (BackgroundWorker)sender; + int filesprogressed = 0; + foreach (FileInfo file in files) + { + try + { + PassedObject po = new PassedObject(); + po.bmp = new Bitmap(file.FullName); + po.fileinfo = file; + if (worker.CancellationPending) + { + e.Cancel = true; + return; + } + filesprogressed++; + worker.ReportProgress(filesprogressed, po); + } + catch (Exception exc) + { + MessageBox.Show(exc.Message); + } + } + } + + private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) + { + PassedObject po = (PassedObject)e.UserState; + + imageList48.Images.Add(po.fileinfo.FullName, getThumbNail(po.bmp, 48, 48)); + imageList64.Images.Add(po.fileinfo.FullName, getThumbNail(po.bmp, 64, 64)); + imageList96.Images.Add(po.fileinfo.FullName, getThumbNail(po.bmp, 96, 96)); + imageList128.Images.Add(po.fileinfo.FullName, getThumbNail(po.bmp, 128, 128)); + imageList256.Images.Add(po.fileinfo.FullName, getThumbNail(po.bmp, 256, 256)); + + listView1.Items[po.fileinfo.FullName].ImageKey = po.fileinfo.FullName; + listView1.Items[po.fileinfo.FullName].ToolTipText = po.fileinfo.Name + " (" + po.bmp.Width.ToString() + " x " + po.bmp.Height.ToString() + ")"; + + /*ListViewItem lvi = new ListViewItem(); + lvi.Name = po.fileinfo.FullName; + lvi.Text = po.fileinfo.Name; + lvi.ImageKey = po.fileinfo.FullName; + lvi.Tag = "file"; + lvi.ToolTipText = po.fileinfo.Name + " (" + po.bmp.Width + " x " + po.bmp.Height + ")"; + listView1.Items.Add(lvi); + * */ + + toolStripStatusLabel1.Text = e.ProgressPercentage.ToString(); + } + + + + private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) + { + sw.Stop(); + toolStripStatusLabel1.Text = "Time: " + sw.Elapsed.TotalSeconds.ToString(); + sw.Reset(); + } + + + + + + + + + + + + + + + + + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/MainForm.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/MainForm.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,992 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.IO; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using System.Reflection; +using System.Runtime.InteropServices; +using GLEED2D.Properties; +using System.Threading; +using System.Xml; +using System.Text.RegularExpressions; +using System.Diagnostics; + +namespace GLEED2D +{ + public partial class MainForm : Form + { + public static MainForm Instance; + String levelfilename; + //BackgroundWorker bgw = new BackgroundWorker(); + + + bool dirtyflag; + public bool DirtyFlag + { + get { return dirtyflag; } + set { dirtyflag = value; updatetitlebar(); } + } + + Cursor dragcursor; + LinkItemsForm linkItemsForm; + + [DllImport("User32.dll")] + private static extern int SendMessage(int Handle, int wMsg, int wParam, int lParam); + + public static void SetListViewSpacing(ListView lst, int x, int y) + { + SendMessage((int)lst.Handle, 0x1000 + 53, 0, y * 65536 + x); + } + + + public MainForm() + { + Instance = this; + InitializeComponent(); + + + } + public IntPtr getHandle() + { + return pictureBox1.Handle; + } + public void updatetitlebar() + { + Text = "GLEED2D - " + levelfilename + (DirtyFlag ? "*" : ""); + } + + public static Image getThumbNail(Bitmap bmp, int imgWidth, int imgHeight) + { + Bitmap retBmp = new Bitmap(imgWidth, imgHeight, System.Drawing.Imaging.PixelFormat.Format64bppPArgb); + Graphics grp = Graphics.FromImage(retBmp); + int tnWidth = imgWidth, tnHeight = imgHeight; + if (bmp.Width > bmp.Height) + tnHeight = (int)(((float)bmp.Height / (float)bmp.Width) * tnWidth); + else if (bmp.Width < bmp.Height) + tnWidth = (int)(((float)bmp.Width / (float)bmp.Height) * tnHeight); + int iLeft = (imgWidth / 2) - (tnWidth / 2); + int iTop = (imgHeight / 2) - (tnHeight / 2); + grp.DrawImage(bmp, iLeft, iTop, tnWidth, tnHeight); + retBmp.Tag = bmp; + return retBmp; + } + + private void MainForm_Load(object sender, EventArgs e) + { + //this.SetDesktopLocation(1300, 20); + linkItemsForm = new LinkItemsForm(); + + //fill zoom combobox + for (int i = 25; i <= 200; i += 25) + { + zoomcombo.Items.Add(i.ToString() + "%"); + } + zoomcombo.SelectedText = "100%"; + + comboBox1.Items.Add("48x48"); + comboBox1.Items.Add("64x64"); + comboBox1.Items.Add("96x96"); + comboBox1.Items.Add("128x128"); + comboBox1.Items.Add("256x256"); + comboBox1.SelectedIndex = 1; + + SetListViewSpacing(listView2, 128 + 8, 128 + 32); + + pictureBox1.AllowDrop = true; + + } + private void MainForm_FormClosed(object sender, FormClosedEventArgs e) + { + Constants.Instance.export("settings.xml"); + Game1.Instance.Exit(); + } + + private void MainForm_FormClosing(object sender, FormClosingEventArgs e) + { + if (checkCurrentLevelAndSaveEventually() == DialogResult.Cancel) e.Cancel = true; + } + + //TREEVIEW + private void treeView1_KeyDown(object sender, KeyEventArgs e) + { + if (e.KeyCode == Keys.N) ActionNewLayer(sender, e); + if (e.KeyCode == Keys.Delete) ActionDelete(sender, e); + if (e.KeyCode == Keys.F7) ActionMoveUp(sender, e); + if (e.KeyCode == Keys.F8) ActionMoveDown(sender, e); + if (e.KeyCode == Keys.F4) ActionCenterView(sender, e); + if (e.KeyCode == Keys.F2) treeView1.SelectedNode.BeginEdit(); + if (e.KeyCode == Keys.D && e.Control) ActionDuplicate(sender, e); + } + private void treeView1_AfterLabelEdit(object sender, NodeLabelEditEventArgs e) + { + if (e.Label == null) return; + + TreeNode[] nodes = treeView1.Nodes.Find(e.Label, true); + if (nodes.Length > 0) + { + MessageBox.Show("A layer or item with the name \"" + e.Label + "\" already exists in the level. Please use another name!"); + e.CancelEdit = true; + return; + } + if (e.Node.Tag is Level) + { + Level l = (Level)e.Node.Tag; + Editor.Instance.beginCommand("Rename Level (\"" + l.Name + "\" -> \"" + e.Label + "\")"); + l.Name = e.Label; + e.Node.Name = e.Label; + Editor.Instance.endCommand(); + } + if (e.Node.Tag is Layer) + { + Layer l = (Layer)e.Node.Tag; + Editor.Instance.beginCommand("Rename Layer (\"" + l.Name + "\" -> \"" + e.Label + "\")"); + l.Name = e.Label; + e.Node.Name = e.Label; + Editor.Instance.endCommand(); + } + if (e.Node.Tag is Item) + { + Item i = (Item)e.Node.Tag; + Editor.Instance.beginCommand("Rename Item (\"" + i.Name + "\" -> \"" + e.Label + "\")"); + i.Name = e.Label; + e.Node.Name = e.Label; + Editor.Instance.endCommand(); + } + propertyGrid1.Refresh(); + pictureBox1.Select(); + } + private void treeView1_AfterCheck(object sender, TreeViewEventArgs e) + { + if (e.Node.Tag is Level) + { + Editor.Instance.level.Visible = e.Node.Checked; + } + if (e.Node.Tag is Layer) + { + Layer l = (Layer)e.Node.Tag; + l.Visible = e.Node.Checked; + } + if (e.Node.Tag is Item) + { + Item i = (Item)e.Node.Tag; + i.Visible = e.Node.Checked; + } + } + private void treeView1_AfterSelect(object sender, TreeViewEventArgs e) + { + if (e.Node.Tag is Level) + { + Editor.Instance.selectlevel(); + } + if (e.Node.Tag is Layer) + { + Layer l = (Layer)e.Node.Tag; + Editor.Instance.selectlayer(l); + } + if (e.Node.Tag is Item) + { + Item i = (Item)e.Node.Tag; + Editor.Instance.selectitem(i); + } + } + private void treeView1_MouseDown(object sender, MouseEventArgs e) + { + if (e.Button == MouseButtons.Right) + { + treeView1.SelectedNode = treeView1.GetNodeAt(e.X, e.Y); + } + } + private void treeView1_ItemDrag(object sender, ItemDragEventArgs e) + { + if (((TreeNode)e.Item).Tag is Layer) return; + if (((TreeNode)e.Item).Tag is Level) return; + Editor.Instance.beginCommand("Drag Item"); + DoDragDrop(e.Item, DragDropEffects.Move); + } + private void treeView1_DragOver(object sender, DragEventArgs e) + { + //get source node + TreeNode sourcenode = (TreeNode)e.Data.GetData(typeof(TreeNode)); + + if (sourcenode == null) + { + e.Effect = DragDropEffects.None; + return; + } + else e.Effect = DragDropEffects.Move; + + //get destination node and select it + Point p = treeView1.PointToClient(new Point(e.X, e.Y)); + TreeNode destnode = treeView1.GetNodeAt(p); + if (destnode.Tag is Level) return; + treeView1.SelectedNode = destnode; + + if (destnode != sourcenode) + { + Item i1 = (Item)sourcenode.Tag; + if (destnode.Tag is Item) + { + Item i2 = (Item)destnode.Tag; + Editor.Instance.moveItemToLayer(i1, i2.layer, i2); + int delta = 0; + if (destnode.Index > sourcenode.Index && i1.layer == i2.layer) delta = 1; + sourcenode.Remove(); + destnode.Parent.Nodes.Insert(destnode.Index + delta, sourcenode); + } + if (destnode.Tag is Layer) + { + Layer l2 = (Layer)destnode.Tag; + Editor.Instance.moveItemToLayer(i1, l2, null); + sourcenode.Remove(); + destnode.Nodes.Insert(0, sourcenode); + } + Editor.Instance.selectitem(i1); + Editor.Instance.draw(Game1.Instance.spriteBatch); + Game1.Instance.GraphicsDevice.Present(); + Application.DoEvents(); + } + } + private void treeView1_DragDrop(object sender, DragEventArgs e) + { + Editor.Instance.endCommand(); + } + + + + //PICTURE BOX + private void pictureBox1_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e) + { + KeyEventArgs kea = new KeyEventArgs(e.KeyData); + treeView1_KeyDown(sender, kea); + } + private void pictureBox1_Resize(object sender, EventArgs e) + { + Logger.Instance.log("pictureBox1_Resize()."); + if (Game1.Instance != null) Game1.Instance.resizebackbuffer(pictureBox1.Width, pictureBox1.Height); + if (Editor.Instance != null) Editor.Instance.camera.updateviewport(pictureBox1.Width, pictureBox1.Height); + } + private void pictureBox1_MouseEnter(object sender, EventArgs e) + { + pictureBox1.Select(); + } + private void pictureBox1_MouseLeave(object sender, EventArgs e) + { + menuStrip1.Select(); + + } + private void pictureBox1_DragEnter(object sender, DragEventArgs e) + { + e.Effect = DragDropEffects.Move; + ListViewItem lvi = (ListViewItem)e.Data.GetData(typeof(ListViewItem)); + Editor.Instance.createTextureBrush(lvi.Name); + + } + private void pictureBox1_DragOver(object sender, DragEventArgs e) + { + e.Effect = DragDropEffects.Move; + Point p = pictureBox1.PointToClient(new Point(e.X, e.Y)); + Editor.Instance.setmousepos(p.X, p.Y); + Editor.Instance.draw(Game1.Instance.spriteBatch); + Game1.Instance.GraphicsDevice.Present(); + } + private void pictureBox1_DragLeave(object sender, EventArgs e) + { + Editor.Instance.destroyTextureBrush(); + Editor.Instance.draw(Game1.Instance.spriteBatch); + Game1.Instance.GraphicsDevice.Present(); + } + private void pictureBox1_DragDrop(object sender, DragEventArgs e) + { + Editor.Instance.paintTextureBrush(false); + listView1.Cursor = Cursors.Default; + pictureBox1.Cursor = Cursors.Default; + } + + + + + // ACTIONS + private void ActionDuplicate(object sender, EventArgs e) + { + if (treeView1.SelectedNode.Tag is Layer) + { + Layer l = (Layer)treeView1.SelectedNode.Tag; + Layer layercopy = l.clone(); + layercopy.Name = getUniqueNameBasedOn(layercopy.Name); + for (int i = 0; i < layercopy.Items.Count; i++) + { + layercopy.Items[i].Name = getUniqueNameBasedOn(layercopy.Items[i].Name); + } + Editor.Instance.beginCommand("Duplicate Layer \"" + l.Name + "\""); + Editor.Instance.addLayer(layercopy); + Editor.Instance.endCommand(); + Editor.Instance.updatetreeview(); + } + } + private void ActionCenterView(object sender, EventArgs e) + { + if (treeView1.SelectedNode.Tag is Level) + { + Editor.Instance.camera.Position = Microsoft.Xna.Framework.Vector2.Zero; + } + if (treeView1.SelectedNode.Tag is Item) + { + Item i = (Item)treeView1.SelectedNode.Tag; + Editor.Instance.camera.Position = i.pPosition; + } + } + private void ActionRename(object sender, EventArgs e) + { + treeView1.SelectedNode.BeginEdit(); + } + private void ActionNewLayer(object sender, EventArgs e) + { + AddLayer f = new AddLayer(this); + f.ShowDialog(); + } + private void ActionDelete(object sender, EventArgs e) + { + if (treeView1.SelectedNode == null) return; + if (treeView1.SelectedNode.Tag is Layer) + { + Layer l = (Layer)treeView1.SelectedNode.Tag; + Editor.Instance.deleteLayer(l); + } + else if (treeView1.SelectedNode.Tag is Item) + { + Editor.Instance.deleteSelectedItems(); + } + } + private void ActionMoveUp(object sender, EventArgs e) + { + if (treeView1.SelectedNode.Tag is Layer) + { + Layer l = (Layer)treeView1.SelectedNode.Tag; + if (l.level.Layers.IndexOf(l) > 0) + { + Editor.Instance.beginCommand("Move Up Layer \"" + l.Name + "\""); + Editor.Instance.moveLayerUp(l); + Editor.Instance.endCommand(); + Editor.Instance.updatetreeview(); + } + } + if (treeView1.SelectedNode.Tag is Item) + { + Item i = (Item)treeView1.SelectedNode.Tag; + if (i.layer.Items.IndexOf(i) > 0) + { + Editor.Instance.beginCommand("Move Up Item \"" + i.Name + "\""); + Editor.Instance.moveItemUp(i); + Editor.Instance.endCommand(); + Editor.Instance.updatetreeview(); + } + } + } + private void ActionMoveDown(object sender, EventArgs e) + { + if (treeView1.SelectedNode.Tag is Layer) + { + Layer l = (Layer)treeView1.SelectedNode.Tag; + if (l.level.Layers.IndexOf(l) < l.level.Layers.Count - 1) + { + Editor.Instance.beginCommand("Move Down Layer \"" + l.Name + "\""); + Editor.Instance.moveLayerDown(l); + Editor.Instance.endCommand(); + Editor.Instance.updatetreeview(); + } + } + if (treeView1.SelectedNode.Tag is Item) + { + Item i = (Item)treeView1.SelectedNode.Tag; + if (i.layer.Items.IndexOf(i) < i.layer.Items.Count - 1) + { + Editor.Instance.beginCommand("Move Down Item \"" + i.Name + "\""); + Editor.Instance.moveItemDown(i); + Editor.Instance.endCommand(); + Editor.Instance.updatetreeview(); + } + } + } + private void ActionAddCustomProperty(object sender, EventArgs e) + { + if (treeView1.SelectedNode.Tag is Item) + { + Item i = (Item)treeView1.SelectedNode.Tag; + AddCustomProperty form = new AddCustomProperty(i.CustomProperties); + form.ShowDialog(); + } + if (treeView1.SelectedNode.Tag is Level) + { + Level l = (Level)treeView1.SelectedNode.Tag; + AddCustomProperty form = new AddCustomProperty(l.CustomProperties); + form.ShowDialog(); + } + if (treeView1.SelectedNode.Tag is Layer) + { + Layer l = (Layer)treeView1.SelectedNode.Tag; + AddCustomProperty form = new AddCustomProperty(l.CustomProperties); + form.ShowDialog(); + } + propertyGrid1.Refresh(); + } + + + + + + + + //MENU + public void newLevel() + { + Application.DoEvents(); + Level newlevel = new Level(); + newlevel.EditorRelated.Version = Editor.Instance.Version; + Editor.Instance.loadLevel(newlevel); + levelfilename = "untitled"; + DirtyFlag = false; + } + public void saveLevel(String filename) + { + Editor.Instance.saveLevel(filename); + levelfilename = filename; + DirtyFlag = false; + + if (Constants.Instance.SaveLevelStartApplication) + { + if (!File.Exists(Constants.Instance.SaveLevelApplicationToStart)) + { + MessageBox.Show("The file \"" + Constants.Instance.SaveLevelApplicationToStart + "\" doesn't exist!\nPlease provide a valid application executable in Tools -> Settings -> Save Level!\nLevel was saved.", + "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); + return; + } + + if (Constants.Instance.SaveLevelAppendLevelFilename) + { + Process.Start(Constants.Instance.SaveLevelApplicationToStart, "\"" + levelfilename + "\""); + } + else + { + Process.Start(Constants.Instance.SaveLevelApplicationToStart); + } + } + + } + public void loadLevel(String filename) + { + Level level = Level.FromFile(filename, Game1.Instance.Content); + + + if (level.EditorRelated.Version == null || level.EditorRelated.Version.CompareTo("1.3") < 0) + { + DialogResult dr = MessageBox.Show( + "This file was created with a version of GLEED2D less than 1.3.\n" + + "In version 1.3 the datatype of 'Scale' changed from 'float' to 'Vector2'.\n" + + "The file you tried to open should therefore be converted accordingly.\n" + + "GLEED2D can do that automatically for you.\n\n"+ + "(Basically, all that's done is convert \n"+ + "1.234 to \n"+ + "1.2341.234)\n\n" + + "Do you want the file to be converted before opening?", + "Convert?", MessageBoxButtons.OKCancel, MessageBoxIcon.Question); + if (dr == DialogResult.OK) + { + //Convert the file, save it and open it + XmlDocument doc = new XmlDocument(); + doc.Load(filename); + //change Scale from float to Vector2 with X = Y = previous scale factor + doc.InnerXml = Regex.Replace(doc.InnerXml, @"(\d+\.?\d*)", "$1$1"); + + //update/insert tag + if (doc.GetElementsByTagName("Version").Count > 0) // tag exists and must be updated + { + doc.InnerXml = Regex.Replace(doc.InnerXml, @"(\d+\.?\d*\.?\d*\.?\d*)", "" + Editor.Instance.Version); + } + else //level files prior to 1.3 didn't have a version tag so insert one + { + doc.GetElementsByTagName("EditorRelated").Item(0).InnerXml += "" + Editor.Instance.Version + ""; + } + //save the changes... + doc.Save(filename); + + //...and load it again + level = Level.FromFile(filename, Game1.Instance.Content); + } + else + { + return; + } + } + + + Editor.Instance.loadLevel(level); + levelfilename = filename; + DirtyFlag = false; + } + public DialogResult checkCurrentLevelAndSaveEventually() + { + if (DirtyFlag) + { + DialogResult dr = MessageBox.Show("The current level has not been saved. Do you want to save now?", "Save?", + MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question); + if (dr == DialogResult.Yes) + { + if (levelfilename == "untitled") + { + SaveFileDialog dialog = new SaveFileDialog(); + dialog.Filter = "XML Files (*.xml)|*.xml"; + if (dialog.ShowDialog() == DialogResult.OK) saveLevel(dialog.FileName); + else return DialogResult.Cancel; + } + else + { + saveLevel(levelfilename); + } + } + if (dr == DialogResult.Cancel) return DialogResult.Cancel; + } + return DialogResult.OK; + } + + private void FileNew(object sender, EventArgs e) + { + if (checkCurrentLevelAndSaveEventually() == DialogResult.Cancel) return; + newLevel(); + } + private void FileOpen(object sender, EventArgs e) + { + if (checkCurrentLevelAndSaveEventually() == DialogResult.Cancel) return; + OpenFileDialog opendialog = new OpenFileDialog(); + opendialog.Filter = "XML Files (*.xml)|*.xml"; + if (opendialog.ShowDialog() == DialogResult.OK) loadLevel(opendialog.FileName); + } + private void FileSave(object sender, EventArgs e) + { + if (levelfilename == "untitled") FileSaveAs(sender, e); + else saveLevel(levelfilename); + + } + private void FileSaveAs(object sender, EventArgs e) + { + SaveFileDialog dialog = new SaveFileDialog(); + dialog.Filter = "XML Files (*.xml)|*.xml"; + if (dialog.ShowDialog() == DialogResult.OK) saveLevel(dialog.FileName); + } + private void FileExit(object sender, EventArgs e) + { + Close(); + } + + + + private void EditUndo(object sender, EventArgs e) + { + Editor.Instance.undo(); + } + + private void EditRedo(object sender, EventArgs e) + { + Editor.Instance.redo(); + } + + private void EditSelectAll(object sender, EventArgs e) + { + Editor.Instance.selectAll(); + } + + private void zoomcombo_TextChanged(object sender, EventArgs e) + { + toolStripStatusLabel1.Text = zoomcombo.SelectedText; + if (zoomcombo.Text.Length > 0 && Editor.Instance != null) + { + float zoom = float.Parse(zoomcombo.Text.Substring(0, zoomcombo.Text.Length - 1)); + Editor.Instance.camera.Scale = zoom / 100; + } + } + + private void HelpQuickGuide(object sender, EventArgs e) + { + new QuickGuide().Show(); + } + + private void HelpAbout(object sender, EventArgs e) + { + new AboutForm().ShowDialog(); + } + + + private void ToolsMenu_MouseEnter(object sender, EventArgs e) + { + moveSelectedItemsToLayerToolStripMenuItem.Enabled = + copySelectedItemsToLayerToolStripMenuItem.Enabled = Editor.Instance.SelectedItems.Count > 0; + alignHorizontallyToolStripMenuItem.Enabled = + alignVerticallyToolStripMenuItem.Enabled = + alignRotationToolStripMenuItem.Enabled = + alignScaleToolStripMenuItem.Enabled = Editor.Instance.SelectedItems.Count > 1; + + linkItemsByACustomPropertyToolStripMenuItem.Enabled = Editor.Instance.SelectedItems.Count == 2; + + } + private void ToolsMenu_Click(object sender, EventArgs e) + { + } + private void ToolsMoveToLayer(object sender, EventArgs e) + { + LayerSelectForm f = new LayerSelectForm(); + if (f.ShowDialog() == DialogResult.OK) + { + Layer chosenlayer = (Layer)f.treeView1.SelectedNode.Tag; + Editor.Instance.moveSelectedItemsToLayer(chosenlayer); + } + + } + private void ToolsCopyToLayer(object sender, EventArgs e) + { + LayerSelectForm f = new LayerSelectForm(); + if (f.ShowDialog() == DialogResult.OK) + { + Layer chosenlayer = (Layer)f.treeView1.SelectedNode.Tag; + Editor.Instance.copySelectedItemsToLayer(chosenlayer); + } + } + private void ToolsLinkItems(object sender, EventArgs e) + { + linkItemsForm.ShowDialog(); + } + private void ToolsAlignHorizontally(object sender, EventArgs e) + { + Editor.Instance.alignHorizontally(); + } + private void ToolsAlignVertically(object sender, EventArgs e) + { + Editor.Instance.alignVertically(); + } + private void ToolsAlignRotation(object sender, EventArgs e) + { + Editor.Instance.alignRotation(); + } + private void ToolsAlignScale(object sender, EventArgs e) + { + Editor.Instance.alignScale(); + } + private void ToolsSettings(object sender, EventArgs e) + { + SettingsForm f = new SettingsForm(); + f.ShowDialog(); + } + + private void MainForm_Resize(object sender, EventArgs e) + { + Editor.Instance.draw(Game1.Instance.spriteBatch); + Game1.Instance.GraphicsDevice.Present(); + Application.DoEvents(); + } + + + private void propertyGrid1_Enter(object sender, EventArgs e) + { + Editor.Instance.beginCommand("Edit in PropertyGrid"); + } + private void propertyGrid1_PropertyValueChanged(object s, PropertyValueChangedEventArgs e) + { + Editor.Instance.endCommand(); + Editor.Instance.beginCommand("Edit in PropertyGrid"); + } + + public void UndoManyCommands(object sender, ToolStripItemClickedEventArgs e) + { + Command c = (Command)e.ClickedItem.Tag; + Editor.Instance.undoMany(c); + } + + private void RedoManyCommands(object sender, ToolStripItemClickedEventArgs e) + { + Command c = (Command)e.ClickedItem.Tag; + Editor.Instance.redoMany(c); + } + + + + + + + private void comboSize_SelectedIndexChanged(object sender, EventArgs e) + { + switch (comboBox1.SelectedIndex) + { + case 0: + listView1.LargeImageList = imageList48; + SetListViewSpacing(listView1, 48 + 8, 48 + 32); + break; + case 1: + listView1.LargeImageList = imageList64; + SetListViewSpacing(listView1, 64 + 8, 64 + 32); + break; + case 2: + listView1.LargeImageList = imageList96; + SetListViewSpacing(listView1, 96 + 8, 96 + 32); + break; + case 3: + listView1.LargeImageList = imageList128; + SetListViewSpacing(listView1, 128 + 8, 128 + 32); + break; + case 4: + listView1.LargeImageList = imageList256; + SetListViewSpacing(listView1, 256 + 8, 256 + 32); + break; + } + } + + private void buttonFolderUp_Click(object sender, EventArgs e) + { + DirectoryInfo di = Directory.GetParent(textBox1.Text); + if (di == null) return; + loadfolder(di.FullName); + /*textBox1.Text = Directory.GetParent(textBox1.Text).FullName; + loadfolder(textBox1.Text);*/ + } + private void chooseFolder_Click(object sender, EventArgs e) + { + FolderBrowserDialog d = new FolderBrowserDialog(); + d.SelectedPath = textBox1.Text; + if (d.ShowDialog() == DialogResult.OK) loadfolder(d.SelectedPath); + } + private void listView1_Click(object sender, EventArgs e) + { + toolStripStatusLabel1.Text = listView1.FocusedItem.ToolTipText; + } + private void listView1_MouseDoubleClick(object sender, MouseEventArgs e) + { + string itemtype = listView1.FocusedItem.Tag.ToString(); + if (itemtype == "folder") + { + loadfolder(listView1.FocusedItem.Name); + } + if (itemtype == "file") + { + Editor.Instance.createTextureBrush(listView1.FocusedItem.Name); + } + + } + private void listView1_ItemDrag(object sender, ItemDragEventArgs e) + { + ListViewItem lvi = (ListViewItem)e.Item; + if (lvi.Tag.ToString() == "folder") return; + toolStripStatusLabel1.Text = lvi.ToolTipText; + Bitmap bmp = new Bitmap(listView1.LargeImageList.Images[lvi.ImageKey]); + dragcursor = new Cursor(bmp.GetHicon()); + listView1.DoDragDrop(e.Item, DragDropEffects.Move); + } + private void listView1_DragOver(object sender, DragEventArgs e) + { + e.Effect = DragDropEffects.Move; + } + private void listView1_GiveFeedback(object sender, GiveFeedbackEventArgs e) + { + if (e.Effect == DragDropEffects.Move) + { + e.UseDefaultCursors = false; + listView1.Cursor = dragcursor; + pictureBox1.Cursor = Cursors.Default; + } + else + { + e.UseDefaultCursors = true; + listView1.Cursor = Cursors.Default; + pictureBox1.Cursor = Cursors.Default; + } + } + private void listView1_DragDrop(object sender, DragEventArgs e) + { + listView1.Cursor = Cursors.Default; + pictureBox1.Cursor = Cursors.Default; + } + + + + + + + + + + public string getUniqueNameBasedOn(string name) + { + int i=0; + string newname = "Copy of " + name; + while (treeView1.Nodes.Find(newname, true).Length>0) + { + newname = "Copy(" + i++.ToString() + ") of " + name; + } + return newname; + } + + + + + public void loadfolder(string path) + { + //loadfolder_background(path); + loadfolder_foreground(path); + } + + + public void loadfolder_foreground(string path) + { + imageList48.Images.Clear(); + imageList64.Images.Clear(); + imageList96.Images.Clear(); + imageList128.Images.Clear(); + imageList256.Images.Clear(); + + Image img = Resources.folder; + imageList48.Images.Add(img); + imageList64.Images.Add(img); + imageList96.Images.Add(img); + imageList128.Images.Add(img); + imageList256.Images.Add(img); + + listView1.Clear(); + + DirectoryInfo di = new DirectoryInfo(path); + textBox1.Text = di.FullName; + DirectoryInfo[] folders = di.GetDirectories(); + foreach (DirectoryInfo folder in folders) + { + ListViewItem lvi = new ListViewItem(); + lvi.Text = folder.Name; + lvi.ToolTipText = folder.Name; + lvi.ImageIndex = 0; + lvi.Tag = "folder"; + lvi.Name = folder.FullName; + listView1.Items.Add(lvi); + } + + string filters = "*.jpg;*.png;*.bmp;"; + List fileList = new List(); + string[] extensions = filters.Split(';'); + foreach (string filter in extensions) fileList.AddRange(di.GetFiles(filter)); + FileInfo[] files = fileList.ToArray(); + + foreach (FileInfo file in files) + { + Bitmap bmp = new Bitmap(file.FullName); + imageList48.Images.Add(file.FullName, getThumbNail(bmp, 48, 48)); + imageList64.Images.Add(file.FullName, getThumbNail(bmp, 64, 64)); + imageList96.Images.Add(file.FullName, getThumbNail(bmp, 96, 96)); + imageList128.Images.Add(file.FullName, getThumbNail(bmp, 128, 128)); + imageList256.Images.Add(file.FullName, getThumbNail(bmp, 256, 256)); + + ListViewItem lvi = new ListViewItem(); + lvi.Name = file.FullName; + lvi.Text = file.Name; + lvi.ImageKey = file.FullName; + lvi.Tag = "file"; + lvi.ToolTipText = file.Name + " (" + bmp.Width.ToString() + " x " + bmp.Height.ToString() + ")"; + + listView1.Items.Add(lvi); + } + } + + + + + + + private void listView2_MouseDoubleClick(object sender, MouseEventArgs e) + { + if (listView2.FocusedItem.Text == "Rectangle") + { + Editor.Instance.createPrimitiveBrush(PrimitiveType.Rectangle); + } + if (listView2.FocusedItem.Text == "Circle") + { + Editor.Instance.createPrimitiveBrush(PrimitiveType.Circle); + } + if (listView2.FocusedItem.Text == "Path") + { + Editor.Instance.createPrimitiveBrush(PrimitiveType.Path); + } + + } + + + + private void RunLevel(object sender, EventArgs e) + { + if (Constants.Instance.RunLevelStartApplication) + { + if (!System.IO.File.Exists(Constants.Instance.RunLevelApplicationToStart)) + { + MessageBox.Show("The file \"" + Constants.Instance.RunLevelApplicationToStart + "\" doesn't exist!\nPlease provide a valid application executable in Tools -> Settings -> Run Level!", + "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + + FileSave(sender, e); + if (Constants.Instance.RunLevelAppendLevelFilename) + { + System.Diagnostics.Process.Start(Constants.Instance.RunLevelApplicationToStart, "\"" + levelfilename + "\""); + } + else + { + System.Diagnostics.Process.Start(Constants.Instance.RunLevelApplicationToStart); + } + } + } + + private void CustomPropertyContextMenu_Opening(object sender, CancelEventArgs e) + { + if (propertyGrid1.SelectedGridItem.Parent.Label != "Custom Properties") e.Cancel = true; + } + + private void deleteCustomProperty(object sender, EventArgs e) + { + Editor.Instance.beginCommand("Delete Custom Property"); + DictionaryPropertyDescriptor dpd = (DictionaryPropertyDescriptor)propertyGrid1.SelectedGridItem.PropertyDescriptor; + dpd.sdict.Remove(dpd.Name); + propertyGrid1.Refresh(); + Editor.Instance.endCommand(); + } + + private void ViewGrid_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.ShowGrid = ShowGridButton.Checked = ViewGrid.Checked; + } + + private void ViewWorldOrigin_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.ShowWorldOrigin = ShowWorldOriginButton.Checked = ViewWorldOrigin.Checked; + } + + private void ShowGridButton_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.ShowGrid = ViewGrid.Checked = ShowGridButton.Checked; + } + + private void ShowWorldOriginButton_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.ShowWorldOrigin = ViewWorldOrigin.Checked = ShowWorldOriginButton.Checked; + } + + private void SnapToGridButton_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.SnapToGrid = ViewSnapToGrid.Checked = SnapToGridButton.Checked; + } + + private void ViewSnapToGrid_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.SnapToGrid = SnapToGridButton.Checked = ViewSnapToGrid.Checked; + } + + + + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/MainForm.designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/MainForm.designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,1545 @@ +namespace GLEED2D +{ + 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() + { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); + System.Windows.Forms.ListViewItem listViewItem1 = new System.Windows.Forms.ListViewItem("Rectangle", 0); + System.Windows.Forms.ListViewItem listViewItem2 = new System.Windows.Forms.ListViewItem("Circle", 1); + System.Windows.Forms.ListViewItem listViewItem3 = new System.Windows.Forms.ListViewItem("Path", 2); + this.pictureBox1 = new System.Windows.Forms.PictureBox(); + this.statusStrip1 = new System.Windows.Forms.StatusStrip(); + this.toolStripStatusLabel1 = new System.Windows.Forms.ToolStripStatusLabel(); + this.toolStripStatusLabel2 = new System.Windows.Forms.ToolStripStatusLabel(); + this.toolStripStatusLabel3 = new System.Windows.Forms.ToolStripStatusLabel(); + this.toolStripStatusLabel4 = new System.Windows.Forms.ToolStripStatusLabel(); + this.treeView1 = new System.Windows.Forms.TreeView(); + this.imageList2 = new System.Windows.Forms.ImageList(this.components); + this.propertyGrid1 = new System.Windows.Forms.PropertyGrid(); + this.CustomPropertyContextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.deleteCustomPropertyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.ItemContextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.ItemCenterViewEntry = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator5 = new System.Windows.Forms.ToolStripSeparator(); + this.renameToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.deleteToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator(); + this.moveUpToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.moveDownToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator10 = new System.Windows.Forms.ToolStripSeparator(); + this.addCustomPropertyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.menuStrip1 = new System.Windows.Forms.MenuStrip(); + this.fileToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.newToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.openToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.saveToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.saveAsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator(); + this.exitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.editToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.undoMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.redoMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator9 = new System.Windows.Forms.ToolStripSeparator(); + this.selectAllToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.viewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.ViewGrid = new System.Windows.Forms.ToolStripMenuItem(); + this.ViewSnapToGrid = new System.Windows.Forms.ToolStripMenuItem(); + this.ViewWorldOrigin = new System.Windows.Forms.ToolStripMenuItem(); + this.runToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.runLevelInYourOwnApplicationToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.ToolsMenu = new System.Windows.Forms.ToolStripMenuItem(); + this.moveSelectedItemsToLayerToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.copySelectedItemsToLayerToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator7 = new System.Windows.Forms.ToolStripSeparator(); + this.linkItemsByACustomPropertyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator16 = new System.Windows.Forms.ToolStripSeparator(); + this.alignHorizontallyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.alignVerticallyToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.alignRotationToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.alignScaleToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator6 = new System.Windows.Forms.ToolStripSeparator(); + this.settingsToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.helpToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.quickGuideToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStrip1 = new System.Windows.Forms.ToolStrip(); + this.newToolStripButton = new System.Windows.Forms.ToolStripButton(); + this.openToolStripButton = new System.Windows.Forms.ToolStripButton(); + this.saveToolStripButton = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator = new System.Windows.Forms.ToolStripSeparator(); + this.undoButton = new System.Windows.Forms.ToolStripSplitButton(); + this.redoButton = new System.Windows.Forms.ToolStripSplitButton(); + this.toolStripSeparator8 = new System.Windows.Forms.ToolStripSeparator(); + this.toolStripLabel1 = new System.Windows.Forms.ToolStripLabel(); + this.zoomcombo = new System.Windows.Forms.ToolStripComboBox(); + this.toolStripSeparator17 = new System.Windows.Forms.ToolStripSeparator(); + this.ShowGridButton = new System.Windows.Forms.ToolStripButton(); + this.SnapToGridButton = new System.Windows.Forms.ToolStripButton(); + this.ShowWorldOriginButton = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator12 = new System.Windows.Forms.ToolStripSeparator(); + this.toolStripButton2 = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator14 = new System.Windows.Forms.ToolStripSeparator(); + this.toolStripButton3 = new System.Windows.Forms.ToolStripButton(); + this.LayerContextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.duplicateToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator11 = new System.Windows.Forms.ToolStripSeparator(); + this.renameToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.deleteToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator(); + this.LayerMoveUpEntry = new System.Windows.Forms.ToolStripMenuItem(); + this.LayerMoveDownEntry = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.splitContainer1 = new System.Windows.Forms.SplitContainer(); + this.splitContainer3 = new System.Windows.Forms.SplitContainer(); + this.toolStripContainer1 = new System.Windows.Forms.ToolStripContainer(); + this.treetools = new System.Windows.Forms.ToolStrip(); + this.toolStripButton1 = new System.Windows.Forms.ToolStripButton(); + this.buttonDelete = new System.Windows.Forms.ToolStripButton(); + this.toolStripSeparator4 = new System.Windows.Forms.ToolStripSeparator(); + this.butonMoveUp = new System.Windows.Forms.ToolStripButton(); + this.buttonMoveDown = new System.Windows.Forms.ToolStripButton(); + this.splitContainer2 = new System.Windows.Forms.SplitContainer(); + this.tabControl1 = new System.Windows.Forms.TabControl(); + this.tabPage1 = new System.Windows.Forms.TabPage(); + this.listView1 = new System.Windows.Forms.ListView(); + this.imageList96 = new System.Windows.Forms.ImageList(this.components); + this.chooseFolder = new System.Windows.Forms.Button(); + this.buttonFolderUp = new System.Windows.Forms.Button(); + this.label2 = new System.Windows.Forms.Label(); + this.comboBox1 = new System.Windows.Forms.ComboBox(); + this.textBox1 = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.tabPage2 = new System.Windows.Forms.TabPage(); + this.listView2 = new System.Windows.Forms.ListView(); + this.imageList1 = new System.Windows.Forms.ImageList(this.components); + this.imageList48 = new System.Windows.Forms.ImageList(this.components); + this.imageList64 = new System.Windows.Forms.ImageList(this.components); + this.imageList128 = new System.Windows.Forms.ImageList(this.components); + this.imageList256 = new System.Windows.Forms.ImageList(this.components); + this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker(); + this.LevelContextMenu = new System.Windows.Forms.ContextMenuStrip(this.components); + this.centerViewToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.addLayerToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator13 = new System.Windows.Forms.ToolStripSeparator(); + this.toolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator15 = new System.Windows.Forms.ToolStripSeparator(); + this.toolStripMenuItem6 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator18 = new System.Windows.Forms.ToolStripSeparator(); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).BeginInit(); + this.statusStrip1.SuspendLayout(); + this.CustomPropertyContextMenu.SuspendLayout(); + this.ItemContextMenu.SuspendLayout(); + this.menuStrip1.SuspendLayout(); + this.toolStrip1.SuspendLayout(); + this.LayerContextMenu.SuspendLayout(); + this.splitContainer1.Panel1.SuspendLayout(); + this.splitContainer1.Panel2.SuspendLayout(); + this.splitContainer1.SuspendLayout(); + this.splitContainer3.Panel1.SuspendLayout(); + this.splitContainer3.Panel2.SuspendLayout(); + this.splitContainer3.SuspendLayout(); + this.toolStripContainer1.ContentPanel.SuspendLayout(); + this.toolStripContainer1.TopToolStripPanel.SuspendLayout(); + this.toolStripContainer1.SuspendLayout(); + this.treetools.SuspendLayout(); + this.splitContainer2.Panel1.SuspendLayout(); + this.splitContainer2.Panel2.SuspendLayout(); + this.splitContainer2.SuspendLayout(); + this.tabControl1.SuspendLayout(); + this.tabPage1.SuspendLayout(); + this.tabPage2.SuspendLayout(); + this.LevelContextMenu.SuspendLayout(); + this.SuspendLayout(); + // + // pictureBox1 + // + this.pictureBox1.Dock = System.Windows.Forms.DockStyle.Fill; + this.pictureBox1.Location = new System.Drawing.Point(0, 0); + this.pictureBox1.Margin = new System.Windows.Forms.Padding(0); + this.pictureBox1.Name = "pictureBox1"; + this.pictureBox1.Size = new System.Drawing.Size(751, 440); + this.pictureBox1.TabIndex = 0; + this.pictureBox1.TabStop = false; + this.pictureBox1.MouseLeave += new System.EventHandler(this.pictureBox1_MouseLeave); + this.pictureBox1.PreviewKeyDown += new System.Windows.Forms.PreviewKeyDownEventHandler(this.pictureBox1_PreviewKeyDown); + this.pictureBox1.DragOver += new System.Windows.Forms.DragEventHandler(this.pictureBox1_DragOver); + this.pictureBox1.DragDrop += new System.Windows.Forms.DragEventHandler(this.pictureBox1_DragDrop); + this.pictureBox1.Resize += new System.EventHandler(this.pictureBox1_Resize); + this.pictureBox1.DragLeave += new System.EventHandler(this.pictureBox1_DragLeave); + this.pictureBox1.DragEnter += new System.Windows.Forms.DragEventHandler(this.pictureBox1_DragEnter); + this.pictureBox1.MouseEnter += new System.EventHandler(this.pictureBox1_MouseEnter); + // + // statusStrip1 + // + this.statusStrip1.GripStyle = System.Windows.Forms.ToolStripGripStyle.Visible; + this.statusStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripStatusLabel1, + this.toolStripStatusLabel2, + this.toolStripStatusLabel3, + this.toolStripStatusLabel4}); + this.statusStrip1.Location = new System.Drawing.Point(0, 694); + this.statusStrip1.Name = "statusStrip1"; + this.statusStrip1.RenderMode = System.Windows.Forms.ToolStripRenderMode.Professional; + this.statusStrip1.Size = new System.Drawing.Size(1002, 22); + this.statusStrip1.TabIndex = 1; + this.statusStrip1.Text = "statusStrip1"; + // + // toolStripStatusLabel1 + // + this.toolStripStatusLabel1.AutoSize = false; + this.toolStripStatusLabel1.BorderSides = ((System.Windows.Forms.ToolStripStatusLabelBorderSides)((((System.Windows.Forms.ToolStripStatusLabelBorderSides.Left | System.Windows.Forms.ToolStripStatusLabelBorderSides.Top) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Right) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Bottom))); + this.toolStripStatusLabel1.BorderStyle = System.Windows.Forms.Border3DStyle.SunkenOuter; + this.toolStripStatusLabel1.Name = "toolStripStatusLabel1"; + this.toolStripStatusLabel1.Size = new System.Drawing.Size(650, 17); + this.toolStripStatusLabel1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // toolStripStatusLabel2 + // + this.toolStripStatusLabel2.AutoSize = false; + this.toolStripStatusLabel2.BorderSides = ((System.Windows.Forms.ToolStripStatusLabelBorderSides)((((System.Windows.Forms.ToolStripStatusLabelBorderSides.Left | System.Windows.Forms.ToolStripStatusLabelBorderSides.Top) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Right) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Bottom))); + this.toolStripStatusLabel2.BorderStyle = System.Windows.Forms.Border3DStyle.SunkenOuter; + this.toolStripStatusLabel2.Name = "toolStripStatusLabel2"; + this.toolStripStatusLabel2.Size = new System.Drawing.Size(113, 17); + this.toolStripStatusLabel2.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // toolStripStatusLabel3 + // + this.toolStripStatusLabel3.AutoSize = false; + this.toolStripStatusLabel3.BorderSides = ((System.Windows.Forms.ToolStripStatusLabelBorderSides)((((System.Windows.Forms.ToolStripStatusLabelBorderSides.Left | System.Windows.Forms.ToolStripStatusLabelBorderSides.Top) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Right) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Bottom))); + this.toolStripStatusLabel3.BorderStyle = System.Windows.Forms.Border3DStyle.SunkenOuter; + this.toolStripStatusLabel3.Name = "toolStripStatusLabel3"; + this.toolStripStatusLabel3.Size = new System.Drawing.Size(109, 17); + this.toolStripStatusLabel3.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // toolStripStatusLabel4 + // + this.toolStripStatusLabel4.AutoSize = false; + this.toolStripStatusLabel4.BorderSides = ((System.Windows.Forms.ToolStripStatusLabelBorderSides)((((System.Windows.Forms.ToolStripStatusLabelBorderSides.Left | System.Windows.Forms.ToolStripStatusLabelBorderSides.Top) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Right) + | System.Windows.Forms.ToolStripStatusLabelBorderSides.Bottom))); + this.toolStripStatusLabel4.BorderStyle = System.Windows.Forms.Border3DStyle.SunkenOuter; + this.toolStripStatusLabel4.Name = "toolStripStatusLabel4"; + this.toolStripStatusLabel4.Size = new System.Drawing.Size(60, 17); + this.toolStripStatusLabel4.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // treeView1 + // + this.treeView1.AllowDrop = true; + this.treeView1.CheckBoxes = true; + this.treeView1.Dock = System.Windows.Forms.DockStyle.Fill; + this.treeView1.HideSelection = false; + this.treeView1.ImageIndex = 5; + this.treeView1.ImageList = this.imageList2; + this.treeView1.LabelEdit = true; + this.treeView1.Location = new System.Drawing.Point(0, 0); + this.treeView1.Name = "treeView1"; + this.treeView1.SelectedImageIndex = 5; + this.treeView1.Size = new System.Drawing.Size(239, 369); + this.treeView1.TabIndex = 2; + this.treeView1.AfterCheck += new System.Windows.Forms.TreeViewEventHandler(this.treeView1_AfterCheck); + this.treeView1.AfterLabelEdit += new System.Windows.Forms.NodeLabelEditEventHandler(this.treeView1_AfterLabelEdit); + this.treeView1.DragDrop += new System.Windows.Forms.DragEventHandler(this.treeView1_DragDrop); + this.treeView1.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.treeView1_AfterSelect); + this.treeView1.MouseDown += new System.Windows.Forms.MouseEventHandler(this.treeView1_MouseDown); + this.treeView1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.treeView1_KeyDown); + this.treeView1.ItemDrag += new System.Windows.Forms.ItemDragEventHandler(this.treeView1_ItemDrag); + this.treeView1.DragOver += new System.Windows.Forms.DragEventHandler(this.treeView1_DragOver); + // + // imageList2 + // + this.imageList2.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList2.ImageStream"))); + this.imageList2.TransparentColor = System.Drawing.Color.Transparent; + this.imageList2.Images.SetKeyName(0, "icon_layer.png"); + this.imageList2.Images.SetKeyName(1, "icon_texture_item.png"); + this.imageList2.Images.SetKeyName(2, "icon_rectangle_item.png"); + this.imageList2.Images.SetKeyName(3, "icon_circle_item.png"); + this.imageList2.Images.SetKeyName(4, "icon_path_item.png"); + this.imageList2.Images.SetKeyName(5, "icon_level.png"); + // + // propertyGrid1 + // + this.propertyGrid1.ContextMenuStrip = this.CustomPropertyContextMenu; + this.propertyGrid1.Dock = System.Windows.Forms.DockStyle.Fill; + this.propertyGrid1.Location = new System.Drawing.Point(0, 0); + this.propertyGrid1.Name = "propertyGrid1"; + this.propertyGrid1.PropertySort = System.Windows.Forms.PropertySort.Categorized; + this.propertyGrid1.Size = new System.Drawing.Size(239, 239); + this.propertyGrid1.TabIndex = 3; + this.propertyGrid1.ToolbarVisible = false; + this.propertyGrid1.Enter += new System.EventHandler(this.propertyGrid1_Enter); + this.propertyGrid1.PropertyValueChanged += new System.Windows.Forms.PropertyValueChangedEventHandler(this.propertyGrid1_PropertyValueChanged); + // + // CustomPropertyContextMenu + // + this.CustomPropertyContextMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.deleteCustomPropertyToolStripMenuItem}); + this.CustomPropertyContextMenu.Name = "CustomPropertyContextMenu"; + this.CustomPropertyContextMenu.Size = new System.Drawing.Size(201, 26); + this.CustomPropertyContextMenu.Opening += new System.ComponentModel.CancelEventHandler(this.CustomPropertyContextMenu_Opening); + // + // deleteCustomPropertyToolStripMenuItem + // + this.deleteCustomPropertyToolStripMenuItem.Name = "deleteCustomPropertyToolStripMenuItem"; + this.deleteCustomPropertyToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + this.deleteCustomPropertyToolStripMenuItem.Text = "Delete Custom Property"; + this.deleteCustomPropertyToolStripMenuItem.Click += new System.EventHandler(this.deleteCustomProperty); + // + // ItemContextMenu + // + this.ItemContextMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.ItemCenterViewEntry, + this.toolStripSeparator5, + this.renameToolStripMenuItem1, + this.deleteToolStripMenuItem1, + this.toolStripSeparator3, + this.moveUpToolStripMenuItem1, + this.moveDownToolStripMenuItem1, + this.toolStripSeparator10, + this.addCustomPropertyToolStripMenuItem}); + this.ItemContextMenu.Name = "ItemContextMenu"; + this.ItemContextMenu.Size = new System.Drawing.Size(189, 154); + // + // ItemCenterViewEntry + // + this.ItemCenterViewEntry.Name = "ItemCenterViewEntry"; + this.ItemCenterViewEntry.ShortcutKeys = System.Windows.Forms.Keys.F4; + this.ItemCenterViewEntry.Size = new System.Drawing.Size(188, 22); + this.ItemCenterViewEntry.Text = "Center View"; + this.ItemCenterViewEntry.Click += new System.EventHandler(this.ActionCenterView); + // + // toolStripSeparator5 + // + this.toolStripSeparator5.Name = "toolStripSeparator5"; + this.toolStripSeparator5.Size = new System.Drawing.Size(185, 6); + // + // renameToolStripMenuItem1 + // + this.renameToolStripMenuItem1.Name = "renameToolStripMenuItem1"; + this.renameToolStripMenuItem1.ShortcutKeys = System.Windows.Forms.Keys.F2; + this.renameToolStripMenuItem1.Size = new System.Drawing.Size(188, 22); + this.renameToolStripMenuItem1.Text = "Rename"; + this.renameToolStripMenuItem1.Click += new System.EventHandler(this.ActionRename); + // + // deleteToolStripMenuItem1 + // + this.deleteToolStripMenuItem1.Name = "deleteToolStripMenuItem1"; + this.deleteToolStripMenuItem1.ShortcutKeys = System.Windows.Forms.Keys.Delete; + this.deleteToolStripMenuItem1.Size = new System.Drawing.Size(188, 22); + this.deleteToolStripMenuItem1.Text = "Delete"; + this.deleteToolStripMenuItem1.Click += new System.EventHandler(this.ActionDelete); + // + // toolStripSeparator3 + // + this.toolStripSeparator3.Name = "toolStripSeparator3"; + this.toolStripSeparator3.Size = new System.Drawing.Size(185, 6); + // + // moveUpToolStripMenuItem1 + // + this.moveUpToolStripMenuItem1.Name = "moveUpToolStripMenuItem1"; + this.moveUpToolStripMenuItem1.ShortcutKeyDisplayString = ""; + this.moveUpToolStripMenuItem1.ShortcutKeys = System.Windows.Forms.Keys.F7; + this.moveUpToolStripMenuItem1.Size = new System.Drawing.Size(188, 22); + this.moveUpToolStripMenuItem1.Text = "Move Up"; + this.moveUpToolStripMenuItem1.Click += new System.EventHandler(this.ActionMoveUp); + // + // moveDownToolStripMenuItem1 + // + this.moveDownToolStripMenuItem1.Name = "moveDownToolStripMenuItem1"; + this.moveDownToolStripMenuItem1.ShortcutKeys = System.Windows.Forms.Keys.F8; + this.moveDownToolStripMenuItem1.Size = new System.Drawing.Size(188, 22); + this.moveDownToolStripMenuItem1.Text = "Move Down"; + this.moveDownToolStripMenuItem1.Click += new System.EventHandler(this.ActionMoveDown); + // + // toolStripSeparator10 + // + this.toolStripSeparator10.Name = "toolStripSeparator10"; + this.toolStripSeparator10.Size = new System.Drawing.Size(185, 6); + // + // addCustomPropertyToolStripMenuItem + // + this.addCustomPropertyToolStripMenuItem.Name = "addCustomPropertyToolStripMenuItem"; + this.addCustomPropertyToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + this.addCustomPropertyToolStripMenuItem.Text = "Add Custom Property"; + this.addCustomPropertyToolStripMenuItem.Click += new System.EventHandler(this.ActionAddCustomProperty); + // + // menuStrip1 + // + this.menuStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.fileToolStripMenuItem, + this.editToolStripMenuItem, + this.viewToolStripMenuItem, + this.runToolStripMenuItem, + this.ToolsMenu, + this.helpToolStripMenuItem}); + this.menuStrip1.Location = new System.Drawing.Point(0, 0); + this.menuStrip1.Name = "menuStrip1"; + this.menuStrip1.RenderMode = System.Windows.Forms.ToolStripRenderMode.Professional; + this.menuStrip1.Size = new System.Drawing.Size(1002, 24); + this.menuStrip1.TabIndex = 4; + this.menuStrip1.Text = "menuStrip1"; + // + // fileToolStripMenuItem + // + this.fileToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.newToolStripMenuItem, + this.openToolStripMenuItem, + this.saveToolStripMenuItem, + this.saveAsToolStripMenuItem, + this.toolStripSeparator1, + this.exitToolStripMenuItem}); + this.fileToolStripMenuItem.Name = "fileToolStripMenuItem"; + this.fileToolStripMenuItem.Size = new System.Drawing.Size(35, 20); + this.fileToolStripMenuItem.Text = "File"; + // + // newToolStripMenuItem + // + this.newToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("newToolStripMenuItem.Image"))); + this.newToolStripMenuItem.Name = "newToolStripMenuItem"; + this.newToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.N))); + this.newToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.newToolStripMenuItem.Text = "New"; + this.newToolStripMenuItem.Click += new System.EventHandler(this.FileNew); + // + // openToolStripMenuItem + // + this.openToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("openToolStripMenuItem.Image"))); + this.openToolStripMenuItem.Name = "openToolStripMenuItem"; + this.openToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.O))); + this.openToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.openToolStripMenuItem.Text = "Open"; + this.openToolStripMenuItem.Click += new System.EventHandler(this.FileOpen); + // + // saveToolStripMenuItem + // + this.saveToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("saveToolStripMenuItem.Image"))); + this.saveToolStripMenuItem.Name = "saveToolStripMenuItem"; + this.saveToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.S))); + this.saveToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.saveToolStripMenuItem.Text = "Save"; + this.saveToolStripMenuItem.Click += new System.EventHandler(this.FileSave); + // + // saveAsToolStripMenuItem + // + this.saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem"; + this.saveAsToolStripMenuItem.ShortcutKeys = System.Windows.Forms.Keys.F12; + this.saveAsToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.saveAsToolStripMenuItem.Text = "Save As..."; + this.saveAsToolStripMenuItem.Click += new System.EventHandler(this.FileSaveAs); + // + // toolStripSeparator1 + // + this.toolStripSeparator1.Name = "toolStripSeparator1"; + this.toolStripSeparator1.Size = new System.Drawing.Size(158, 6); + // + // exitToolStripMenuItem + // + this.exitToolStripMenuItem.Name = "exitToolStripMenuItem"; + this.exitToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.E))); + this.exitToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + this.exitToolStripMenuItem.Text = "Exit"; + this.exitToolStripMenuItem.Click += new System.EventHandler(this.FileExit); + // + // editToolStripMenuItem + // + this.editToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.undoMenuItem, + this.redoMenuItem, + this.toolStripSeparator9, + this.selectAllToolStripMenuItem}); + this.editToolStripMenuItem.Name = "editToolStripMenuItem"; + this.editToolStripMenuItem.Size = new System.Drawing.Size(37, 20); + this.editToolStripMenuItem.Text = "Edit"; + // + // undoMenuItem + // + this.undoMenuItem.Enabled = false; + this.undoMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("undoMenuItem.Image"))); + this.undoMenuItem.Name = "undoMenuItem"; + this.undoMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Z))); + this.undoMenuItem.Size = new System.Drawing.Size(167, 22); + this.undoMenuItem.Text = "Undo"; + this.undoMenuItem.Click += new System.EventHandler(this.EditUndo); + // + // redoMenuItem + // + this.redoMenuItem.Enabled = false; + this.redoMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("redoMenuItem.Image"))); + this.redoMenuItem.Name = "redoMenuItem"; + this.redoMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.R))); + this.redoMenuItem.Size = new System.Drawing.Size(167, 22); + this.redoMenuItem.Text = "Redo"; + this.redoMenuItem.Click += new System.EventHandler(this.EditRedo); + // + // toolStripSeparator9 + // + this.toolStripSeparator9.Name = "toolStripSeparator9"; + this.toolStripSeparator9.Size = new System.Drawing.Size(164, 6); + // + // selectAllToolStripMenuItem + // + this.selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem"; + this.selectAllToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.A))); + this.selectAllToolStripMenuItem.Size = new System.Drawing.Size(167, 22); + this.selectAllToolStripMenuItem.Text = "Select All"; + this.selectAllToolStripMenuItem.Click += new System.EventHandler(this.EditSelectAll); + // + // viewToolStripMenuItem + // + this.viewToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.ViewGrid, + this.ViewSnapToGrid, + this.ViewWorldOrigin}); + this.viewToolStripMenuItem.Name = "viewToolStripMenuItem"; + this.viewToolStripMenuItem.Size = new System.Drawing.Size(41, 20); + this.viewToolStripMenuItem.Text = "View"; + // + // ViewGrid + // + this.ViewGrid.CheckOnClick = true; + this.ViewGrid.Image = ((System.Drawing.Image)(resources.GetObject("ViewGrid.Image"))); + this.ViewGrid.Name = "ViewGrid"; + this.ViewGrid.Size = new System.Drawing.Size(144, 22); + this.ViewGrid.Text = "Grid"; + this.ViewGrid.CheckedChanged += new System.EventHandler(this.ViewGrid_CheckedChanged); + // + // ViewSnapToGrid + // + this.ViewSnapToGrid.CheckOnClick = true; + this.ViewSnapToGrid.Image = ((System.Drawing.Image)(resources.GetObject("ViewSnapToGrid.Image"))); + this.ViewSnapToGrid.Name = "ViewSnapToGrid"; + this.ViewSnapToGrid.Size = new System.Drawing.Size(144, 22); + this.ViewSnapToGrid.Text = "Snap to Grid"; + this.ViewSnapToGrid.CheckedChanged += new System.EventHandler(this.ViewSnapToGrid_CheckedChanged); + // + // ViewWorldOrigin + // + this.ViewWorldOrigin.CheckOnClick = true; + this.ViewWorldOrigin.Image = ((System.Drawing.Image)(resources.GetObject("ViewWorldOrigin.Image"))); + this.ViewWorldOrigin.Name = "ViewWorldOrigin"; + this.ViewWorldOrigin.Size = new System.Drawing.Size(144, 22); + this.ViewWorldOrigin.Text = "World Origin"; + this.ViewWorldOrigin.CheckedChanged += new System.EventHandler(this.ViewWorldOrigin_CheckedChanged); + // + // runToolStripMenuItem + // + this.runToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.runLevelInYourOwnApplicationToolStripMenuItem}); + this.runToolStripMenuItem.Name = "runToolStripMenuItem"; + this.runToolStripMenuItem.Size = new System.Drawing.Size(38, 20); + this.runToolStripMenuItem.Text = "Run"; + // + // runLevelInYourOwnApplicationToolStripMenuItem + // + this.runLevelInYourOwnApplicationToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("runLevelInYourOwnApplicationToolStripMenuItem.Image"))); + this.runLevelInYourOwnApplicationToolStripMenuItem.Name = "runLevelInYourOwnApplicationToolStripMenuItem"; + this.runLevelInYourOwnApplicationToolStripMenuItem.ShortcutKeys = System.Windows.Forms.Keys.F5; + this.runLevelInYourOwnApplicationToolStripMenuItem.Size = new System.Drawing.Size(151, 22); + this.runLevelInYourOwnApplicationToolStripMenuItem.Text = "Run Level"; + this.runLevelInYourOwnApplicationToolStripMenuItem.ToolTipText = "Run Level in your own application. To use this, define the appropriate settings i" + + "n the Tools->Settings dialog."; + this.runLevelInYourOwnApplicationToolStripMenuItem.Click += new System.EventHandler(this.RunLevel); + // + // ToolsMenu + // + this.ToolsMenu.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.moveSelectedItemsToLayerToolStripMenuItem, + this.copySelectedItemsToLayerToolStripMenuItem, + this.toolStripSeparator7, + this.linkItemsByACustomPropertyToolStripMenuItem, + this.toolStripSeparator16, + this.alignHorizontallyToolStripMenuItem, + this.alignVerticallyToolStripMenuItem, + this.alignRotationToolStripMenuItem, + this.alignScaleToolStripMenuItem, + this.toolStripSeparator6, + this.settingsToolStripMenuItem1}); + this.ToolsMenu.Name = "ToolsMenu"; + this.ToolsMenu.Size = new System.Drawing.Size(44, 20); + this.ToolsMenu.Text = "Tools"; + this.ToolsMenu.MouseEnter += new System.EventHandler(this.ToolsMenu_MouseEnter); + this.ToolsMenu.Click += new System.EventHandler(this.ToolsMenu_Click); + // + // moveSelectedItemsToLayerToolStripMenuItem + // + this.moveSelectedItemsToLayerToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("moveSelectedItemsToLayerToolStripMenuItem.Image"))); + this.moveSelectedItemsToLayerToolStripMenuItem.Name = "moveSelectedItemsToLayerToolStripMenuItem"; + this.moveSelectedItemsToLayerToolStripMenuItem.Size = new System.Drawing.Size(349, 22); + this.moveSelectedItemsToLayerToolStripMenuItem.Text = "Move Selected Items to Layer..."; + this.moveSelectedItemsToLayerToolStripMenuItem.ToolTipText = "Moves the selected Items to another existing layer."; + this.moveSelectedItemsToLayerToolStripMenuItem.Click += new System.EventHandler(this.ToolsMoveToLayer); + // + // copySelectedItemsToLayerToolStripMenuItem + // + this.copySelectedItemsToLayerToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("copySelectedItemsToLayerToolStripMenuItem.Image"))); + this.copySelectedItemsToLayerToolStripMenuItem.Name = "copySelectedItemsToLayerToolStripMenuItem"; + this.copySelectedItemsToLayerToolStripMenuItem.Size = new System.Drawing.Size(349, 22); + this.copySelectedItemsToLayerToolStripMenuItem.Text = "Copy Selected Items to Layer..."; + this.copySelectedItemsToLayerToolStripMenuItem.ToolTipText = "Copies the selected Items to another existing layer."; + this.copySelectedItemsToLayerToolStripMenuItem.Click += new System.EventHandler(this.ToolsCopyToLayer); + // + // toolStripSeparator7 + // + this.toolStripSeparator7.Name = "toolStripSeparator7"; + this.toolStripSeparator7.Size = new System.Drawing.Size(346, 6); + // + // linkItemsByACustomPropertyToolStripMenuItem + // + this.linkItemsByACustomPropertyToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("linkItemsByACustomPropertyToolStripMenuItem.Image"))); + this.linkItemsByACustomPropertyToolStripMenuItem.Name = "linkItemsByACustomPropertyToolStripMenuItem"; + this.linkItemsByACustomPropertyToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Shift) + | System.Windows.Forms.Keys.L))); + this.linkItemsByACustomPropertyToolStripMenuItem.Size = new System.Drawing.Size(349, 22); + this.linkItemsByACustomPropertyToolStripMenuItem.Text = "Link Selected Items by a CustomProperty"; + this.linkItemsByACustomPropertyToolStripMenuItem.ToolTipText = "Only active if exactly two Items are selected. Adds a Custom Property of type \"It" + + "em\" resulting in the first Item referring to the Second one. \r\nTwo-way linking a" + + "lso possible."; + this.linkItemsByACustomPropertyToolStripMenuItem.Click += new System.EventHandler(this.ToolsLinkItems); + // + // toolStripSeparator16 + // + this.toolStripSeparator16.Name = "toolStripSeparator16"; + this.toolStripSeparator16.Size = new System.Drawing.Size(346, 6); + // + // alignHorizontallyToolStripMenuItem + // + this.alignHorizontallyToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("alignHorizontallyToolStripMenuItem.Image"))); + this.alignHorizontallyToolStripMenuItem.Name = "alignHorizontallyToolStripMenuItem"; + this.alignHorizontallyToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Shift) + | System.Windows.Forms.Keys.H))); + this.alignHorizontallyToolStripMenuItem.Size = new System.Drawing.Size(349, 22); + this.alignHorizontallyToolStripMenuItem.Text = "Align Horizontally"; + this.alignHorizontallyToolStripMenuItem.ToolTipText = "Adjust the Y-Coordinate of all selected items to be the same as the first selecte" + + "d item."; + this.alignHorizontallyToolStripMenuItem.Click += new System.EventHandler(this.ToolsAlignHorizontally); + // + // alignVerticallyToolStripMenuItem + // + this.alignVerticallyToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("alignVerticallyToolStripMenuItem.Image"))); + this.alignVerticallyToolStripMenuItem.Name = "alignVerticallyToolStripMenuItem"; + this.alignVerticallyToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Shift) + | System.Windows.Forms.Keys.V))); + this.alignVerticallyToolStripMenuItem.Size = new System.Drawing.Size(349, 22); + this.alignVerticallyToolStripMenuItem.Text = "Align Vertically"; + this.alignVerticallyToolStripMenuItem.ToolTipText = "Adjust the X-Coordinate of all selected items to be the same as the first selecte" + + "d item."; + this.alignVerticallyToolStripMenuItem.Click += new System.EventHandler(this.ToolsAlignVertically); + // + // alignRotationToolStripMenuItem + // + this.alignRotationToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("alignRotationToolStripMenuItem.Image"))); + this.alignRotationToolStripMenuItem.Name = "alignRotationToolStripMenuItem"; + this.alignRotationToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Shift) + | System.Windows.Forms.Keys.R))); + this.alignRotationToolStripMenuItem.Size = new System.Drawing.Size(349, 22); + this.alignRotationToolStripMenuItem.Text = "Align Rotation"; + this.alignRotationToolStripMenuItem.ToolTipText = "Adjust the rotation of all selected items to be the same as the first selected it" + + "em."; + this.alignRotationToolStripMenuItem.Click += new System.EventHandler(this.ToolsAlignRotation); + // + // alignScaleToolStripMenuItem + // + this.alignScaleToolStripMenuItem.Image = ((System.Drawing.Image)(resources.GetObject("alignScaleToolStripMenuItem.Image"))); + this.alignScaleToolStripMenuItem.Name = "alignScaleToolStripMenuItem"; + this.alignScaleToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)(((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.Shift) + | System.Windows.Forms.Keys.S))); + this.alignScaleToolStripMenuItem.Size = new System.Drawing.Size(349, 22); + this.alignScaleToolStripMenuItem.Text = "Align Scale"; + this.alignScaleToolStripMenuItem.ToolTipText = "Adjust the Scale of all selected items to be the same as the first selected item." + + ""; + this.alignScaleToolStripMenuItem.Click += new System.EventHandler(this.ToolsAlignScale); + // + // toolStripSeparator6 + // + this.toolStripSeparator6.Name = "toolStripSeparator6"; + this.toolStripSeparator6.Size = new System.Drawing.Size(346, 6); + // + // settingsToolStripMenuItem1 + // + this.settingsToolStripMenuItem1.Image = ((System.Drawing.Image)(resources.GetObject("settingsToolStripMenuItem1.Image"))); + this.settingsToolStripMenuItem1.Name = "settingsToolStripMenuItem1"; + this.settingsToolStripMenuItem1.ShortcutKeys = System.Windows.Forms.Keys.F9; + this.settingsToolStripMenuItem1.Size = new System.Drawing.Size(349, 22); + this.settingsToolStripMenuItem1.Text = "Settings"; + this.settingsToolStripMenuItem1.ToolTipText = "The Settings Dialog."; + this.settingsToolStripMenuItem1.Click += new System.EventHandler(this.ToolsSettings); + // + // helpToolStripMenuItem + // + this.helpToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.quickGuideToolStripMenuItem, + this.aboutToolStripMenuItem}); + this.helpToolStripMenuItem.Name = "helpToolStripMenuItem"; + this.helpToolStripMenuItem.Size = new System.Drawing.Size(40, 20); + this.helpToolStripMenuItem.Text = "Help"; + // + // quickGuideToolStripMenuItem + // + this.quickGuideToolStripMenuItem.Name = "quickGuideToolStripMenuItem"; + this.quickGuideToolStripMenuItem.Size = new System.Drawing.Size(138, 22); + this.quickGuideToolStripMenuItem.Text = "QuickGuide"; + this.quickGuideToolStripMenuItem.Click += new System.EventHandler(this.HelpQuickGuide); + // + // aboutToolStripMenuItem + // + this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + this.aboutToolStripMenuItem.ShortcutKeys = System.Windows.Forms.Keys.F1; + this.aboutToolStripMenuItem.Size = new System.Drawing.Size(138, 22); + this.aboutToolStripMenuItem.Text = "About"; + this.aboutToolStripMenuItem.Click += new System.EventHandler(this.HelpAbout); + // + // toolStrip1 + // + this.toolStrip1.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden; + this.toolStrip1.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.newToolStripButton, + this.openToolStripButton, + this.saveToolStripButton, + this.toolStripSeparator, + this.undoButton, + this.redoButton, + this.toolStripSeparator8, + this.toolStripLabel1, + this.zoomcombo, + this.toolStripSeparator17, + this.ShowGridButton, + this.SnapToGridButton, + this.ShowWorldOriginButton, + this.toolStripSeparator12, + this.toolStripButton2, + this.toolStripSeparator14, + this.toolStripButton3}); + this.toolStrip1.Location = new System.Drawing.Point(0, 24); + this.toolStrip1.Name = "toolStrip1"; + this.toolStrip1.RenderMode = System.Windows.Forms.ToolStripRenderMode.Professional; + this.toolStrip1.Size = new System.Drawing.Size(1002, 25); + this.toolStrip1.Stretch = true; + this.toolStrip1.TabIndex = 5; + this.toolStrip1.Text = "toolStrip1"; + // + // newToolStripButton + // + this.newToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.newToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("newToolStripButton.Image"))); + this.newToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.newToolStripButton.Name = "newToolStripButton"; + this.newToolStripButton.Size = new System.Drawing.Size(23, 22); + this.newToolStripButton.Text = "&New"; + this.newToolStripButton.Click += new System.EventHandler(this.FileNew); + // + // openToolStripButton + // + this.openToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.openToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("openToolStripButton.Image"))); + this.openToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.openToolStripButton.Name = "openToolStripButton"; + this.openToolStripButton.Size = new System.Drawing.Size(23, 22); + this.openToolStripButton.Text = "&Open"; + this.openToolStripButton.Click += new System.EventHandler(this.FileOpen); + // + // saveToolStripButton + // + this.saveToolStripButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.saveToolStripButton.Image = ((System.Drawing.Image)(resources.GetObject("saveToolStripButton.Image"))); + this.saveToolStripButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.saveToolStripButton.Name = "saveToolStripButton"; + this.saveToolStripButton.Size = new System.Drawing.Size(23, 22); + this.saveToolStripButton.Text = "&Save"; + this.saveToolStripButton.ToolTipText = "Save"; + this.saveToolStripButton.Click += new System.EventHandler(this.FileSave); + // + // toolStripSeparator + // + this.toolStripSeparator.Name = "toolStripSeparator"; + this.toolStripSeparator.Size = new System.Drawing.Size(6, 25); + // + // undoButton + // + this.undoButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.undoButton.Image = ((System.Drawing.Image)(resources.GetObject("undoButton.Image"))); + this.undoButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.undoButton.Name = "undoButton"; + this.undoButton.Size = new System.Drawing.Size(32, 22); + this.undoButton.Text = "toolStripButton2"; + this.undoButton.ToolTipText = "Undo"; + this.undoButton.ButtonClick += new System.EventHandler(this.EditUndo); + this.undoButton.DropDownItemClicked += new System.Windows.Forms.ToolStripItemClickedEventHandler(this.UndoManyCommands); + // + // redoButton + // + this.redoButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.redoButton.Enabled = false; + this.redoButton.Image = ((System.Drawing.Image)(resources.GetObject("redoButton.Image"))); + this.redoButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.redoButton.Name = "redoButton"; + this.redoButton.Size = new System.Drawing.Size(32, 22); + this.redoButton.Text = "toolStripButton3"; + this.redoButton.ToolTipText = "Redo"; + this.redoButton.ButtonClick += new System.EventHandler(this.EditRedo); + this.redoButton.DropDownItemClicked += new System.Windows.Forms.ToolStripItemClickedEventHandler(this.RedoManyCommands); + // + // toolStripSeparator8 + // + this.toolStripSeparator8.Name = "toolStripSeparator8"; + this.toolStripSeparator8.Size = new System.Drawing.Size(6, 25); + // + // toolStripLabel1 + // + this.toolStripLabel1.Name = "toolStripLabel1"; + this.toolStripLabel1.Size = new System.Drawing.Size(37, 22); + this.toolStripLabel1.Text = "Zoom:"; + // + // zoomcombo + // + this.zoomcombo.FlatStyle = System.Windows.Forms.FlatStyle.Standard; + this.zoomcombo.Name = "zoomcombo"; + this.zoomcombo.Size = new System.Drawing.Size(75, 25); + this.zoomcombo.TextChanged += new System.EventHandler(this.zoomcombo_TextChanged); + // + // toolStripSeparator17 + // + this.toolStripSeparator17.Name = "toolStripSeparator17"; + this.toolStripSeparator17.Size = new System.Drawing.Size(6, 25); + // + // ShowGridButton + // + this.ShowGridButton.CheckOnClick = true; + this.ShowGridButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.ShowGridButton.Image = ((System.Drawing.Image)(resources.GetObject("ShowGridButton.Image"))); + this.ShowGridButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.ShowGridButton.Name = "ShowGridButton"; + this.ShowGridButton.Size = new System.Drawing.Size(23, 22); + this.ShowGridButton.Text = "toolStripButton4"; + this.ShowGridButton.ToolTipText = "Show Grid"; + this.ShowGridButton.CheckedChanged += new System.EventHandler(this.ShowGridButton_CheckedChanged); + // + // SnapToGridButton + // + this.SnapToGridButton.CheckOnClick = true; + this.SnapToGridButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.SnapToGridButton.Image = ((System.Drawing.Image)(resources.GetObject("SnapToGridButton.Image"))); + this.SnapToGridButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.SnapToGridButton.Name = "SnapToGridButton"; + this.SnapToGridButton.Size = new System.Drawing.Size(23, 22); + this.SnapToGridButton.Text = "toolStripButton4"; + this.SnapToGridButton.ToolTipText = "Snap to Grid"; + this.SnapToGridButton.CheckedChanged += new System.EventHandler(this.SnapToGridButton_CheckedChanged); + // + // ShowWorldOriginButton + // + this.ShowWorldOriginButton.CheckOnClick = true; + this.ShowWorldOriginButton.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.ShowWorldOriginButton.Image = ((System.Drawing.Image)(resources.GetObject("ShowWorldOriginButton.Image"))); + this.ShowWorldOriginButton.ImageTransparentColor = System.Drawing.Color.Magenta; + this.ShowWorldOriginButton.Name = "ShowWorldOriginButton"; + this.ShowWorldOriginButton.Size = new System.Drawing.Size(23, 22); + this.ShowWorldOriginButton.Text = "toolStripButton4"; + this.ShowWorldOriginButton.ToolTipText = "Show World Origin"; + this.ShowWorldOriginButton.CheckedChanged += new System.EventHandler(this.ShowWorldOriginButton_CheckedChanged); + // + // toolStripSeparator12 + // + this.toolStripSeparator12.Name = "toolStripSeparator12"; + this.toolStripSeparator12.Size = new System.Drawing.Size(6, 25); + // + // toolStripButton2 + // + this.toolStripButton2.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButton2.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButton2.Image"))); + this.toolStripButton2.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButton2.Name = "toolStripButton2"; + this.toolStripButton2.Size = new System.Drawing.Size(23, 22); + this.toolStripButton2.Text = "Run Level"; + this.toolStripButton2.ToolTipText = "Run Level in your own application. To use this, define the appropriate settings i" + + "n the Tools->Settings dialog."; + this.toolStripButton2.Click += new System.EventHandler(this.RunLevel); + // + // toolStripSeparator14 + // + this.toolStripSeparator14.Name = "toolStripSeparator14"; + this.toolStripSeparator14.Size = new System.Drawing.Size(6, 25); + // + // toolStripButton3 + // + this.toolStripButton3.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButton3.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButton3.Image"))); + this.toolStripButton3.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButton3.Name = "toolStripButton3"; + this.toolStripButton3.Size = new System.Drawing.Size(23, 22); + this.toolStripButton3.Text = "Settings"; + this.toolStripButton3.Click += new System.EventHandler(this.ToolsSettings); + // + // LayerContextMenu + // + this.LayerContextMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.duplicateToolStripMenuItem, + this.toolStripSeparator11, + this.renameToolStripMenuItem, + this.deleteToolStripMenuItem, + this.toolStripSeparator2, + this.LayerMoveUpEntry, + this.LayerMoveDownEntry, + this.toolStripSeparator18, + this.toolStripMenuItem1}); + this.LayerContextMenu.Name = "LayerContextMenu"; + this.LayerContextMenu.Size = new System.Drawing.Size(189, 154); + // + // duplicateToolStripMenuItem + // + this.duplicateToolStripMenuItem.Name = "duplicateToolStripMenuItem"; + this.duplicateToolStripMenuItem.ShortcutKeyDisplayString = ""; + this.duplicateToolStripMenuItem.ShortcutKeys = ((System.Windows.Forms.Keys)((System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.D))); + this.duplicateToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + this.duplicateToolStripMenuItem.Text = "Duplicate"; + this.duplicateToolStripMenuItem.Click += new System.EventHandler(this.ActionDuplicate); + // + // toolStripSeparator11 + // + this.toolStripSeparator11.Name = "toolStripSeparator11"; + this.toolStripSeparator11.Size = new System.Drawing.Size(185, 6); + // + // renameToolStripMenuItem + // + this.renameToolStripMenuItem.Name = "renameToolStripMenuItem"; + this.renameToolStripMenuItem.ShortcutKeys = System.Windows.Forms.Keys.F2; + this.renameToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + this.renameToolStripMenuItem.Text = "Rename"; + this.renameToolStripMenuItem.Click += new System.EventHandler(this.ActionRename); + // + // deleteToolStripMenuItem + // + this.deleteToolStripMenuItem.Name = "deleteToolStripMenuItem"; + this.deleteToolStripMenuItem.ShortcutKeys = System.Windows.Forms.Keys.Delete; + this.deleteToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + this.deleteToolStripMenuItem.Text = "Delete"; + this.deleteToolStripMenuItem.Click += new System.EventHandler(this.ActionDelete); + // + // toolStripSeparator2 + // + this.toolStripSeparator2.Name = "toolStripSeparator2"; + this.toolStripSeparator2.Size = new System.Drawing.Size(185, 6); + // + // LayerMoveUpEntry + // + this.LayerMoveUpEntry.Name = "LayerMoveUpEntry"; + this.LayerMoveUpEntry.ShortcutKeys = System.Windows.Forms.Keys.F7; + this.LayerMoveUpEntry.Size = new System.Drawing.Size(188, 22); + this.LayerMoveUpEntry.Text = "Move Up"; + this.LayerMoveUpEntry.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + this.LayerMoveUpEntry.Click += new System.EventHandler(this.ActionMoveUp); + // + // LayerMoveDownEntry + // + this.LayerMoveDownEntry.Name = "LayerMoveDownEntry"; + this.LayerMoveDownEntry.ShortcutKeys = System.Windows.Forms.Keys.F8; + this.LayerMoveDownEntry.Size = new System.Drawing.Size(188, 22); + this.LayerMoveDownEntry.Text = "Move Down"; + this.LayerMoveDownEntry.Click += new System.EventHandler(this.ActionMoveDown); + // + // toolStripMenuItem1 + // + this.toolStripMenuItem1.Name = "toolStripMenuItem1"; + this.toolStripMenuItem1.Size = new System.Drawing.Size(188, 22); + this.toolStripMenuItem1.Text = "Add Custom Property"; + this.toolStripMenuItem1.Click += new System.EventHandler(this.ActionAddCustomProperty); + // + // splitContainer1 + // + this.splitContainer1.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainer1.FixedPanel = System.Windows.Forms.FixedPanel.Panel1; + this.splitContainer1.Location = new System.Drawing.Point(0, 49); + this.splitContainer1.Name = "splitContainer1"; + // + // splitContainer1.Panel1 + // + this.splitContainer1.Panel1.Controls.Add(this.splitContainer3); + // + // splitContainer1.Panel2 + // + this.splitContainer1.Panel2.Controls.Add(this.splitContainer2); + this.splitContainer1.Size = new System.Drawing.Size(1002, 645); + this.splitContainer1.SplitterDistance = 243; + this.splitContainer1.TabIndex = 6; + // + // splitContainer3 + // + this.splitContainer3.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.splitContainer3.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainer3.FixedPanel = System.Windows.Forms.FixedPanel.Panel2; + this.splitContainer3.Location = new System.Drawing.Point(0, 0); + this.splitContainer3.Name = "splitContainer3"; + this.splitContainer3.Orientation = System.Windows.Forms.Orientation.Horizontal; + // + // splitContainer3.Panel1 + // + this.splitContainer3.Panel1.Controls.Add(this.toolStripContainer1); + // + // splitContainer3.Panel2 + // + this.splitContainer3.Panel2.Controls.Add(this.propertyGrid1); + this.splitContainer3.Size = new System.Drawing.Size(243, 645); + this.splitContainer3.SplitterDistance = 398; + this.splitContainer3.TabIndex = 0; + // + // toolStripContainer1 + // + // + // toolStripContainer1.ContentPanel + // + this.toolStripContainer1.ContentPanel.Controls.Add(this.treeView1); + this.toolStripContainer1.ContentPanel.Size = new System.Drawing.Size(239, 369); + this.toolStripContainer1.Dock = System.Windows.Forms.DockStyle.Fill; + this.toolStripContainer1.Location = new System.Drawing.Point(0, 0); + this.toolStripContainer1.Name = "toolStripContainer1"; + this.toolStripContainer1.Size = new System.Drawing.Size(239, 394); + this.toolStripContainer1.TabIndex = 0; + this.toolStripContainer1.Text = "toolStripContainer1"; + // + // toolStripContainer1.TopToolStripPanel + // + this.toolStripContainer1.TopToolStripPanel.Controls.Add(this.treetools); + this.toolStripContainer1.TopToolStripPanel.RenderMode = System.Windows.Forms.ToolStripRenderMode.System; + // + // treetools + // + this.treetools.Dock = System.Windows.Forms.DockStyle.None; + this.treetools.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden; + this.treetools.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripButton1, + this.buttonDelete, + this.toolStripSeparator4, + this.butonMoveUp, + this.buttonMoveDown}); + this.treetools.Location = new System.Drawing.Point(3, 0); + this.treetools.Name = "treetools"; + this.treetools.Size = new System.Drawing.Size(101, 25); + this.treetools.TabIndex = 0; + // + // toolStripButton1 + // + this.toolStripButton1.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.toolStripButton1.Image = ((System.Drawing.Image)(resources.GetObject("toolStripButton1.Image"))); + this.toolStripButton1.ImageTransparentColor = System.Drawing.Color.Magenta; + this.toolStripButton1.Name = "toolStripButton1"; + this.toolStripButton1.Size = new System.Drawing.Size(23, 22); + this.toolStripButton1.Text = "toolStripButton1"; + this.toolStripButton1.ToolTipText = "New Layer (N)"; + this.toolStripButton1.Click += new System.EventHandler(this.ActionNewLayer); + // + // buttonDelete + // + this.buttonDelete.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.buttonDelete.Image = ((System.Drawing.Image)(resources.GetObject("buttonDelete.Image"))); + this.buttonDelete.ImageTransparentColor = System.Drawing.Color.Magenta; + this.buttonDelete.Name = "buttonDelete"; + this.buttonDelete.Size = new System.Drawing.Size(23, 22); + this.buttonDelete.Text = "Delete"; + this.buttonDelete.ToolTipText = "Delete (Del)"; + this.buttonDelete.Click += new System.EventHandler(this.ActionDelete); + // + // toolStripSeparator4 + // + this.toolStripSeparator4.Name = "toolStripSeparator4"; + this.toolStripSeparator4.Size = new System.Drawing.Size(6, 25); + // + // butonMoveUp + // + this.butonMoveUp.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.butonMoveUp.Image = ((System.Drawing.Image)(resources.GetObject("butonMoveUp.Image"))); + this.butonMoveUp.ImageTransparentColor = System.Drawing.Color.Magenta; + this.butonMoveUp.Name = "butonMoveUp"; + this.butonMoveUp.Size = new System.Drawing.Size(23, 22); + this.butonMoveUp.Text = "toolStripButton3"; + this.butonMoveUp.ToolTipText = "Move Up (F7)"; + this.butonMoveUp.Click += new System.EventHandler(this.ActionMoveUp); + // + // buttonMoveDown + // + this.buttonMoveDown.DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.Image; + this.buttonMoveDown.Image = ((System.Drawing.Image)(resources.GetObject("buttonMoveDown.Image"))); + this.buttonMoveDown.ImageTransparentColor = System.Drawing.Color.Magenta; + this.buttonMoveDown.Name = "buttonMoveDown"; + this.buttonMoveDown.Size = new System.Drawing.Size(23, 22); + this.buttonMoveDown.Text = "toolStripButton4"; + this.buttonMoveDown.ToolTipText = "Move Down (F8)"; + this.buttonMoveDown.Click += new System.EventHandler(this.ActionMoveDown); + // + // splitContainer2 + // + this.splitContainer2.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; + this.splitContainer2.Dock = System.Windows.Forms.DockStyle.Fill; + this.splitContainer2.FixedPanel = System.Windows.Forms.FixedPanel.Panel2; + this.splitContainer2.Location = new System.Drawing.Point(0, 0); + this.splitContainer2.Name = "splitContainer2"; + this.splitContainer2.Orientation = System.Windows.Forms.Orientation.Horizontal; + // + // splitContainer2.Panel1 + // + this.splitContainer2.Panel1.BackColor = System.Drawing.SystemColors.Control; + this.splitContainer2.Panel1.Controls.Add(this.pictureBox1); + // + // splitContainer2.Panel2 + // + this.splitContainer2.Panel2.BackColor = System.Drawing.SystemColors.Control; + this.splitContainer2.Panel2.Controls.Add(this.tabControl1); + this.splitContainer2.Size = new System.Drawing.Size(755, 645); + this.splitContainer2.SplitterDistance = 444; + this.splitContainer2.TabIndex = 0; + // + // tabControl1 + // + this.tabControl1.Controls.Add(this.tabPage1); + this.tabControl1.Controls.Add(this.tabPage2); + this.tabControl1.Dock = System.Windows.Forms.DockStyle.Fill; + this.tabControl1.HotTrack = true; + this.tabControl1.Location = new System.Drawing.Point(0, 0); + this.tabControl1.Name = "tabControl1"; + this.tabControl1.SelectedIndex = 0; + this.tabControl1.Size = new System.Drawing.Size(751, 193); + this.tabControl1.TabIndex = 0; + // + // tabPage1 + // + this.tabPage1.Controls.Add(this.listView1); + this.tabPage1.Controls.Add(this.chooseFolder); + this.tabPage1.Controls.Add(this.buttonFolderUp); + this.tabPage1.Controls.Add(this.label2); + this.tabPage1.Controls.Add(this.comboBox1); + this.tabPage1.Controls.Add(this.textBox1); + this.tabPage1.Controls.Add(this.label1); + this.tabPage1.Location = new System.Drawing.Point(4, 22); + this.tabPage1.Name = "tabPage1"; + this.tabPage1.Padding = new System.Windows.Forms.Padding(3); + this.tabPage1.Size = new System.Drawing.Size(743, 167); + this.tabPage1.TabIndex = 0; + this.tabPage1.Text = "Textures"; + this.tabPage1.UseVisualStyleBackColor = true; + // + // listView1 + // + this.listView1.AllowDrop = true; + this.listView1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.listView1.HideSelection = false; + this.listView1.LargeImageList = this.imageList96; + this.listView1.Location = new System.Drawing.Point(9, 34); + this.listView1.MultiSelect = false; + this.listView1.Name = "listView1"; + this.listView1.ShowItemToolTips = true; + this.listView1.Size = new System.Drawing.Size(728, 127); + this.listView1.TabIndex = 6; + this.listView1.UseCompatibleStateImageBehavior = false; + this.listView1.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(this.listView1_MouseDoubleClick); + this.listView1.DragDrop += new System.Windows.Forms.DragEventHandler(this.listView1_DragDrop); + this.listView1.GiveFeedback += new System.Windows.Forms.GiveFeedbackEventHandler(this.listView1_GiveFeedback); + this.listView1.ItemDrag += new System.Windows.Forms.ItemDragEventHandler(this.listView1_ItemDrag); + this.listView1.DragOver += new System.Windows.Forms.DragEventHandler(this.listView1_DragOver); + this.listView1.Click += new System.EventHandler(this.listView1_Click); + // + // imageList96 + // + this.imageList96.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit; + this.imageList96.ImageSize = new System.Drawing.Size(96, 96); + this.imageList96.TransparentColor = System.Drawing.Color.Transparent; + // + // chooseFolder + // + this.chooseFolder.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.chooseFolder.Location = new System.Drawing.Point(525, 6); + this.chooseFolder.Name = "chooseFolder"; + this.chooseFolder.Size = new System.Drawing.Size(60, 23); + this.chooseFolder.TabIndex = 5; + this.chooseFolder.Text = "Choose..."; + this.chooseFolder.UseVisualStyleBackColor = true; + this.chooseFolder.Click += new System.EventHandler(this.chooseFolder_Click); + // + // buttonFolderUp + // + this.buttonFolderUp.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.buttonFolderUp.Image = ((System.Drawing.Image)(resources.GetObject("buttonFolderUp.Image"))); + this.buttonFolderUp.Location = new System.Drawing.Point(487, 6); + this.buttonFolderUp.Name = "buttonFolderUp"; + this.buttonFolderUp.Size = new System.Drawing.Size(32, 23); + this.buttonFolderUp.TabIndex = 4; + this.buttonFolderUp.UseVisualStyleBackColor = true; + this.buttonFolderUp.Click += new System.EventHandler(this.buttonFolderUp_Click); + // + // label2 + // + this.label2.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(633, 11); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(30, 13); + this.label2.TabIndex = 3; + this.label2.Text = "Size:"; + // + // comboBox1 + // + this.comboBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.comboBox1.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboBox1.FormattingEnabled = true; + this.comboBox1.Location = new System.Drawing.Point(663, 8); + this.comboBox1.Name = "comboBox1"; + this.comboBox1.Size = new System.Drawing.Size(74, 21); + this.comboBox1.TabIndex = 2; + this.comboBox1.SelectedIndexChanged += new System.EventHandler(this.comboSize_SelectedIndexChanged); + // + // textBox1 + // + this.textBox1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.textBox1.Location = new System.Drawing.Point(51, 8); + this.textBox1.Name = "textBox1"; + this.textBox1.ReadOnly = true; + this.textBox1.Size = new System.Drawing.Size(430, 20); + this.textBox1.TabIndex = 1; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(6, 11); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(39, 13); + this.label1.TabIndex = 0; + this.label1.Text = "Folder:"; + // + // tabPage2 + // + this.tabPage2.Controls.Add(this.listView2); + this.tabPage2.Location = new System.Drawing.Point(4, 22); + this.tabPage2.Name = "tabPage2"; + this.tabPage2.Padding = new System.Windows.Forms.Padding(3); + this.tabPage2.Size = new System.Drawing.Size(739, 167); + this.tabPage2.TabIndex = 1; + this.tabPage2.Text = "Primitives"; + this.tabPage2.UseVisualStyleBackColor = true; + // + // listView2 + // + this.listView2.Dock = System.Windows.Forms.DockStyle.Fill; + this.listView2.HideSelection = false; + listViewItem1.ToolTipText = "A simple rectangle defined by position, width and height. Rectangle Primitives ca" + + "n be scaled but not rotated."; + listViewItem2.ToolTipText = "A simple circle defined by position and radius. Circle Primitives can be scaled b" + + "ut not rotated."; + listViewItem3.ToolTipText = "A Path is an array of Vector2. Path Primitives can be rotated and scaled."; + this.listView2.Items.AddRange(new System.Windows.Forms.ListViewItem[] { + listViewItem1, + listViewItem2, + listViewItem3}); + this.listView2.LargeImageList = this.imageList1; + this.listView2.Location = new System.Drawing.Point(3, 3); + this.listView2.MultiSelect = false; + this.listView2.Name = "listView2"; + this.listView2.ShowItemToolTips = true; + this.listView2.Size = new System.Drawing.Size(733, 161); + this.listView2.TabIndex = 0; + this.listView2.UseCompatibleStateImageBehavior = false; + this.listView2.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(this.listView2_MouseDoubleClick); + // + // imageList1 + // + this.imageList1.ImageStream = ((System.Windows.Forms.ImageListStreamer)(resources.GetObject("imageList1.ImageStream"))); + this.imageList1.TransparentColor = System.Drawing.Color.Transparent; + this.imageList1.Images.SetKeyName(0, "primitive_rectangle.png"); + this.imageList1.Images.SetKeyName(1, "primitive_circle.png"); + this.imageList1.Images.SetKeyName(2, "primitive_path.png"); + // + // imageList48 + // + this.imageList48.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit; + this.imageList48.ImageSize = new System.Drawing.Size(48, 48); + this.imageList48.TransparentColor = System.Drawing.Color.Transparent; + // + // imageList64 + // + this.imageList64.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit; + this.imageList64.ImageSize = new System.Drawing.Size(64, 64); + this.imageList64.TransparentColor = System.Drawing.Color.Transparent; + // + // imageList128 + // + this.imageList128.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit; + this.imageList128.ImageSize = new System.Drawing.Size(128, 128); + this.imageList128.TransparentColor = System.Drawing.Color.Transparent; + // + // imageList256 + // + this.imageList256.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit; + this.imageList256.ImageSize = new System.Drawing.Size(256, 256); + this.imageList256.TransparentColor = System.Drawing.Color.Transparent; + // + // backgroundWorker1 + // + this.backgroundWorker1.WorkerReportsProgress = true; + this.backgroundWorker1.WorkerSupportsCancellation = true; + this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork); + this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted); + this.backgroundWorker1.ProgressChanged += new System.ComponentModel.ProgressChangedEventHandler(this.backgroundWorker1_ProgressChanged); + // + // LevelContextMenu + // + this.LevelContextMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.centerViewToolStripMenuItem, + this.addLayerToolStripMenuItem, + this.toolStripSeparator13, + this.toolStripMenuItem2, + this.toolStripSeparator15, + this.toolStripMenuItem6}); + this.LevelContextMenu.Name = "ItemContextMenu"; + this.LevelContextMenu.RenderMode = System.Windows.Forms.ToolStripRenderMode.Professional; + this.LevelContextMenu.Size = new System.Drawing.Size(189, 104); + // + // centerViewToolStripMenuItem + // + this.centerViewToolStripMenuItem.Name = "centerViewToolStripMenuItem"; + this.centerViewToolStripMenuItem.ShortcutKeys = System.Windows.Forms.Keys.F4; + this.centerViewToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + this.centerViewToolStripMenuItem.Text = "Center View"; + this.centerViewToolStripMenuItem.Click += new System.EventHandler(this.ActionCenterView); + // + // addLayerToolStripMenuItem + // + this.addLayerToolStripMenuItem.Name = "addLayerToolStripMenuItem"; + this.addLayerToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + this.addLayerToolStripMenuItem.Text = "Add Layer"; + this.addLayerToolStripMenuItem.Click += new System.EventHandler(this.ActionNewLayer); + // + // toolStripSeparator13 + // + this.toolStripSeparator13.Name = "toolStripSeparator13"; + this.toolStripSeparator13.Size = new System.Drawing.Size(185, 6); + // + // toolStripMenuItem2 + // + this.toolStripMenuItem2.Name = "toolStripMenuItem2"; + this.toolStripMenuItem2.ShortcutKeys = System.Windows.Forms.Keys.F2; + this.toolStripMenuItem2.Size = new System.Drawing.Size(188, 22); + this.toolStripMenuItem2.Text = "Rename"; + this.toolStripMenuItem2.Click += new System.EventHandler(this.ActionRename); + // + // toolStripSeparator15 + // + this.toolStripSeparator15.Name = "toolStripSeparator15"; + this.toolStripSeparator15.Size = new System.Drawing.Size(185, 6); + // + // toolStripMenuItem6 + // + this.toolStripMenuItem6.Name = "toolStripMenuItem6"; + this.toolStripMenuItem6.Size = new System.Drawing.Size(188, 22); + this.toolStripMenuItem6.Text = "Add Custom Property"; + this.toolStripMenuItem6.Click += new System.EventHandler(this.ActionAddCustomProperty); + // + // toolStripSeparator18 + // + this.toolStripSeparator18.Name = "toolStripSeparator18"; + this.toolStripSeparator18.Size = new System.Drawing.Size(185, 6); + // + // MainForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(1002, 716); + this.Controls.Add(this.splitContainer1); + this.Controls.Add(this.toolStrip1); + this.Controls.Add(this.statusStrip1); + this.Controls.Add(this.menuStrip1); + this.Location = new System.Drawing.Point(10, 10); + this.MainMenuStrip = this.menuStrip1; + this.Name = "MainForm"; + this.Text = "GLEED2D"; + this.Load += new System.EventHandler(this.MainForm_Load); + this.FormClosed += new System.Windows.Forms.FormClosedEventHandler(this.MainForm_FormClosed); + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing); + ((System.ComponentModel.ISupportInitialize)(this.pictureBox1)).EndInit(); + this.statusStrip1.ResumeLayout(false); + this.statusStrip1.PerformLayout(); + this.CustomPropertyContextMenu.ResumeLayout(false); + this.ItemContextMenu.ResumeLayout(false); + this.menuStrip1.ResumeLayout(false); + this.menuStrip1.PerformLayout(); + this.toolStrip1.ResumeLayout(false); + this.toolStrip1.PerformLayout(); + this.LayerContextMenu.ResumeLayout(false); + this.splitContainer1.Panel1.ResumeLayout(false); + this.splitContainer1.Panel2.ResumeLayout(false); + this.splitContainer1.ResumeLayout(false); + this.splitContainer3.Panel1.ResumeLayout(false); + this.splitContainer3.Panel2.ResumeLayout(false); + this.splitContainer3.ResumeLayout(false); + this.toolStripContainer1.ContentPanel.ResumeLayout(false); + this.toolStripContainer1.TopToolStripPanel.ResumeLayout(false); + this.toolStripContainer1.TopToolStripPanel.PerformLayout(); + this.toolStripContainer1.ResumeLayout(false); + this.toolStripContainer1.PerformLayout(); + this.treetools.ResumeLayout(false); + this.treetools.PerformLayout(); + this.splitContainer2.Panel1.ResumeLayout(false); + this.splitContainer2.Panel2.ResumeLayout(false); + this.splitContainer2.ResumeLayout(false); + this.tabControl1.ResumeLayout(false); + this.tabPage1.ResumeLayout(false); + this.tabPage1.PerformLayout(); + this.tabPage2.ResumeLayout(false); + this.LevelContextMenu.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.StatusStrip statusStrip1; + private System.Windows.Forms.MenuStrip menuStrip1; + private System.Windows.Forms.ToolStrip toolStrip1; + private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem exitToolStripMenuItem; + public System.Windows.Forms.PropertyGrid propertyGrid1; + private System.Windows.Forms.ToolStripButton newToolStripButton; + private System.Windows.Forms.ToolStripButton openToolStripButton; + private System.Windows.Forms.ToolStripButton saveToolStripButton; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator; + public System.Windows.Forms.TreeView treeView1; + public System.Windows.Forms.PictureBox pictureBox1; + private System.Windows.Forms.ToolStripMenuItem renameToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem deleteToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator2; + private System.Windows.Forms.ToolStripMenuItem LayerMoveUpEntry; + private System.Windows.Forms.ToolStripMenuItem LayerMoveDownEntry; + public System.Windows.Forms.ContextMenuStrip LayerContextMenu; + public System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel1; + private System.Windows.Forms.SplitContainer splitContainer1; + private System.Windows.Forms.SplitContainer splitContainer3; + private System.Windows.Forms.SplitContainer splitContainer2; + public System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel2; + public System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel3; + public System.Windows.Forms.ToolStripStatusLabel toolStripStatusLabel4; + private System.Windows.Forms.ToolStripMenuItem helpToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem; + private System.Windows.Forms.ToolStripLabel toolStripLabel1; + public System.Windows.Forms.ToolStripComboBox zoomcombo; + private System.Windows.Forms.ToolStripMenuItem newToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem openToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem saveToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem saveAsToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator1; + private System.Windows.Forms.ToolStripMenuItem renameToolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem deleteToolStripMenuItem1; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator3; + private System.Windows.Forms.ToolStripMenuItem moveUpToolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem moveDownToolStripMenuItem1; + public System.Windows.Forms.ContextMenuStrip ItemContextMenu; + private System.Windows.Forms.ToolStripContainer toolStripContainer1; + private System.Windows.Forms.ToolStrip treetools; + private System.Windows.Forms.ToolStripButton toolStripButton1; + private System.Windows.Forms.ToolStripButton buttonDelete; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator4; + private System.Windows.Forms.ToolStripButton butonMoveUp; + private System.Windows.Forms.ToolStripButton buttonMoveDown; + private System.Windows.Forms.ToolStripMenuItem ItemCenterViewEntry; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator5; + private System.Windows.Forms.ToolStripMenuItem ToolsMenu; + private System.Windows.Forms.ToolStripMenuItem settingsToolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem alignHorizontallyToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem alignVerticallyToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem alignRotationToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem alignScaleToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator6; + private System.Windows.Forms.ToolStripMenuItem moveSelectedItemsToLayerToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator7; + private System.Windows.Forms.ToolStripMenuItem copySelectedItemsToLayerToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem editToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator8; + public System.Windows.Forms.ToolStripMenuItem undoMenuItem; + public System.Windows.Forms.ToolStripMenuItem redoMenuItem; + public System.Windows.Forms.ToolStripSplitButton undoButton; + public System.Windows.Forms.ToolStripSplitButton redoButton; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator9; + private System.Windows.Forms.ToolStripMenuItem selectAllToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator10; + private System.Windows.Forms.ToolStripMenuItem addCustomPropertyToolStripMenuItem; + private System.Windows.Forms.TabControl tabControl1; + private System.Windows.Forms.TabPage tabPage1; + private System.Windows.Forms.Button chooseFolder; + private System.Windows.Forms.Button buttonFolderUp; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.ComboBox comboBox1; + private System.Windows.Forms.TextBox textBox1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.ListView listView1; + private System.Windows.Forms.ImageList imageList48; + private System.Windows.Forms.ImageList imageList96; + private System.Windows.Forms.ImageList imageList64; + private System.Windows.Forms.ImageList imageList128; + private System.Windows.Forms.ImageList imageList256; + private System.ComponentModel.BackgroundWorker backgroundWorker1; + private System.Windows.Forms.TabPage tabPage2; + public System.Windows.Forms.ListView listView2; + private System.Windows.Forms.ToolStripMenuItem duplicateToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator11; + private System.Windows.Forms.ToolStripMenuItem runToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem runLevelInYourOwnApplicationToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator12; + private System.Windows.Forms.ToolStripButton toolStripButton2; + public System.Windows.Forms.ContextMenuStrip LevelContextMenu; + private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem2; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator15; + private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem6; + public System.Windows.Forms.ImageList imageList2; + private System.Windows.Forms.ToolStripMenuItem addLayerToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator13; + private System.Windows.Forms.ContextMenuStrip CustomPropertyContextMenu; + private System.Windows.Forms.ToolStripMenuItem deleteCustomPropertyToolStripMenuItem; + private System.Windows.Forms.ToolStripButton toolStripButton3; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator14; + private System.Windows.Forms.ToolStripMenuItem viewToolStripMenuItem; + public System.Windows.Forms.ToolStripMenuItem ViewGrid; + public System.Windows.Forms.ToolStripMenuItem ViewWorldOrigin; + private System.Windows.Forms.ToolStripMenuItem centerViewToolStripMenuItem; + private System.Windows.Forms.ToolStripButton ShowGridButton; + private System.Windows.Forms.ToolStripButton ShowWorldOriginButton; + private System.Windows.Forms.ToolStripMenuItem linkItemsByACustomPropertyToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator16; + private System.Windows.Forms.ImageList imageList1; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator17; + private System.Windows.Forms.ToolStripMenuItem quickGuideToolStripMenuItem; + private System.Windows.Forms.ToolStripButton SnapToGridButton; + public System.Windows.Forms.ToolStripMenuItem ViewSnapToGrid; + private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem1; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator18; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/MainForm.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/MainForm.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,4053 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 223, 21 + + + 122, 58 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAACK + GAAAAk1TRnQBSQFMAgEBBgEAAQkBAAEEAQABEAEAARABAAT/ASEBAAj/AUIBTQE2BwABNgMAASgDAAFA + AwABIAMAAQEBAAEgBgABIBIAgP+AAAj/AsABDQH/AsABDQH/AsABDQH/AsABDQH/AsABDQH/AsABDQH/ + AsABDQH/AsABDQH/AsABDQH/AsABDQH/AsABDQH/AsABDRH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQn/gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLA + AQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAE/wLAAQ0B/wLA + AQ0B/wLAAQ0J/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLA + AQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/ + gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0J/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLA + AQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/ + Aw0B/wMNAf8DDQX/gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0J/wLIASwB/wLHASgB/wLAAQ0B/wLAAQ0B/wLA + AQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0R/wL8AfMB/wLqAasB/wLK + ATQB/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0J/wLCARQB/wLIASwB/wLR + AVAB/wL3Ad8B/wL8AfMB/wLIASwB/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0J/wLA + AQ0B/wLAAQ0B/wLAAQ0B/wLVAWAF/wLoAaMB/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/Aw0B/wMN + Af8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAE/wLAAQ0B/wLAAQ0B/wLA + AQ0J/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLEARwF/wL0AdMB/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAE/wLAAQ0B/wLA + AQ0B/wLAAQ0J/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLQAUwF/wLrAa8B/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMN + Af8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAE/wLA + AQ0B/wLAAQ0B/wLAAQ0J/wLIASwB/wLIASwB/wLQAUwB/wL1AdcF/wLSAVQB/wLAAQ0B/wLAAQ0B/wLA + AQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/ + gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0R/wL8AfMB/wLzAc8B/wLVAWQB/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLA + AQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/ + gAAE/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLA + AQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0J/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQX/gAAI/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLA + AQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0B/wLAAQ0R/wMNAf8DDQH/Aw0B/wMNAf8DDQH/ + Aw0B/wMNAf8DDQH/Aw0B/wMNAf8DDQH/Aw0J/4AAgP+AAP//Cf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHA + AQ0BwAH/AcABDQHAEf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAIN + Af8BwAINAf8BwAINAf8BwAINAf8BwAINEf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQEN + Ef8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINDv8BwAENAcAB/wHA + AQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAn/AcACDQH/AcACDQH/AcACDQH/ + AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/ + AcACDQn/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQEN + Af8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0J/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQr/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAHf8BwAENAcAB/wHAAQ0BwAH/AcABDQHACf8BwAINAf8BwAIN + Af8BwAINAf8BwAINAf8BwAINAf8BwAINCf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAIN + Cf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENCf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wE8 + AZcBPAH/AfMB+QHzAf8BlwHLAZcB/wENAYEBDQH/AQ0BgQENCf8CDQL/Ag0C/wINAv8CDQL/AmgC/wLL + Av8C9wb/AvMC/wK3Av8CcAL/Ag0C/wINAv8CDQr/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Cf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHA + AQ0BwAn/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQn/AcACDQH/AcACDQH/AcACDQH/ + AcACDQH/AcACDQH/AcACDQn/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQn/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDQH/ATQBkwE0Af8B5wHzAecB/wHTAekB0wH/ARQBgwEUAf8BDQGBAQ0B/wENAYEBDQn/Ag0C/wIN + Av8CDQL/ArcC/wL7Av8CjwL/AjQC/wIYAv8CbAr/Ag0C/wINAv8CDQr/AcABDQHAAf8BwAENAcAB/wHA + AQ0BwAH/AcABDQHACf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAn/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQn/AcACDQH/ + AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQn/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQn/AQ0BgQEN + Af8BDQGBAQ0B/wEkAYsBJAH/AdcB6wHXAf8B8wH5AfMB/wE4AZUBOAH/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDQn/Ag0C/wINAv8CgAb/ApcC/wINAv8CDQL/Ag0C/wINAv8CuwL/AscC/wINAv8CDQL/Ag0K/wHA + AQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAn/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAJ/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHA + Ag0B/wHAAg0J/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0J/wENAYEBDQH/AQ0BgQEN + Af8BDQGBAQ0J/wEsAY8BLAH/ATABkQEwAf8BywHlAcsF/wF0AbMBdAH/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDQH/AQ0BgQENCf8CDQL/Ag0C/wLTBv8CPAL/Ag0C/wINAv8CDQL/Ag0C/wIcAv8CDQL/Ag0C/wIN + Av8CDQr/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHACf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAn/AcACDQH/AcACDQH/AcACDQH/ + AcACDQH/AcACDQH/AcACDQn/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQH/AcACDQn/AQ0BgQEN + Af8BDQGBAQ0B/wENAYEBDRX/AdsB7QHbAf8BFAGDARQB/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDQn/Ag0C/wINAv8C8wb/AhwC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0K/wHA + AQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAn/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAJ/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHA + Ag0B/wHAAg0J/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0J/wENAYEBDQH/AQ0BgQEN + Af8BDQGBAQ0J/wENAYEBDQH/ARQBgwEUAf8BPAGXATwB/wG/Ad8BvwH/AdsB7QHbAf8BPAGXATwB/wEN + AYEBDQH/AQ0BgQENAf8BDQGBAQ0J/wINAv8CDQL/Au8G/wIgAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINCv8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAJ/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHACf8BwAINAf8BwAIN + Af8BwAINAf8BwAINAf8BwAINAf8BwAINCf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAIN + Cf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENCf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BQAGZAUAF/wG3 + AdsBtwH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQn/Ag0C/wINAv8Czwb/AkQC/wINAv8CDQL/Ag0C/wIN + Av8CMAL/AhgC/wINAv8CDQL/Ag0K/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAn/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAJ/wHA + Ag0B/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0J/wHAAg0B/wHAAg0B/wHAAg0B/wHAAg0B/wHA + Ag0B/wHAAg0J/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0J/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wEk + AYsBJAX/AesB9QHrAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENCf8CDQL/Ag0C/wKABv8CpwL/Ag0C/wIN + Av8CDQL/AhQC/wLXAv8CzwL/Ag0C/wINAv8CDQr/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Cf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHA + AQ0BwAn/AcACDQH/AcACDQH/AcACDQH/AcgCLAH/AcgCLAH/AcgCLAn/AcgCLAH/AcgCLAH/AcgCLAH/ + AcACDQH/AcACDQH/AcACDQn/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQn/ASwBjwEsAf8BLAGPASwB/wE0 + AZMBNAH/AZ8BzwGfBf8BowHRAaMB/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0J/wINAv8CDQL/Ag0C/wK3 + Bv8CjwL/AjwC/wIwAv8CgQr/Ag0C/wINAv8CDQr/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Cf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHA + AQ0BwAn/AcACDQH/AcACDQH/AcACDSH/AcACDQH/AcACDQH/AcACDQn/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDRX/AfcB+wH3Af8BiwHFAYsB/wEUAYMBFAH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQn/Ag0C/wIN + Av8CDQL/Ag0C/wJoAv8CwwL/AucG/wL7Av8CzwL/AoEC/wINAv8CDQL/Ag0K/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHA + AQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHACf8BwAINAf8BwAINAf8BwAINAf8BwAIN + Af8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAIN + Cf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQn/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINDv8BwAENAcAB/wHA + AQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHAAf8BwAENAcAB/wHAAQ0BwAH/AcABDQHA + Af8BwAENAcAB/wHAAQ0BwAH/AcABDQHAEf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAIN + Af8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINAf8BwAINEf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQEN + Af8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wENAYEBDQH/AQ0BgQENAf8BDQGBAQ0B/wEN + AYEBDQH/AQ0BgQENEf8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + //8L/wFCAU0BPgcAAT4DAAEoAwABQAMAASADAAEBAQABAQYAAQEWAAP//wACAAs= + + + + 476, 21 + + + 817, 21 + + + 17, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAR9JREFUOE+l021LwlAUB3D9UPod6mvUt7F3YS8ieqFGiGBgUGik4QNkBiI60B6QYSm6 + fHbOh7l/3sEdI8+dgw4c7hjn/rj3nM0LwPOvYADLRLaOvxlP1xBNlhG5LbIM8Fr7am7mwHYl4yL2BP/h + MYlYwE1GEu1HMJJEqlDjyAl5gthDRQichu7NzTxJ4PruVQis9Q0YwiESCCeeScAwDKjaCt2+agK+gyNW + Z13deriM50hgudIxGGuQO2Nn4Dya3gH0jYGJukRbmeFNHjgDZ1epHUBbrKEM52h+j1B9V5wBdj97sMaN + pgu0uhPUm32UpI57wN64j9YQlUYP+fKXe8DeOOnzB8VqG48vsjuAz1u0CsfIZ8wK9iX5HVB/mpt3vxo9 + AUzkuRFtAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAn9JREFUOE+lk2tI01EYxhf0oU8WqVEIRpaIBWJgSPUhROmippS3QkkTylsXDMW8ts3b + 1G06daVibuqaOq0sxbBCKBSJ0PJCialZUFSKqaGSt1//TbIsww8deOBwznl+5zkv71kHiP5rGAFrKb1Q + 5ypR6bmaVU6m2kCiXJv007Om2XgwJEaNT4QiyDi/GF9mKRVgsWkav+CYQkR1utwAQfypphqZ4l/JIhOL + jvtGKfCOyDMB6O/WMjNea9L3MT1zIxoM5QrqdWnS1SA+kUq8w1V4hhUgqq1QMj1WtcK88KmIud5oqsqy + qCzOQFMopSQvhRvyBApkcQLzV91E1docpr9ol29eFMz0J0Bv2Kr6C3CrVMa3jyWm2EZzc12OSQ8M2TTo + ZdytzMCgSUVfIqFcfY2bqiSKlQmoc+JNaUSVJRlMvsvHGHuoVUx9lZKFIQkMp63UW2FtMBH6YuBVFF01 + /lwO9aoQadSpTAxkwXs596oVtD+ULx36/Qkvg6HDl/k2D2YeufCmwoELZ45MCIA9olKVmK+vJQy3JVOv + l7M4KIae8CVAV6hgPMV8uxczLYeZbDrIaN1eJBG2nHazyDN1cZEymdHueG7rcuh8KiTpixYA56AziMVn + J5h9coyp5kOM1TvxudqejvRNBHrY4GRnZmcCqLMT6GlJ4Y4uGwZS4IUQ97kfs62eTD12YbzBmRGDAx+0 + u+iVmyMO24njbqvG5VbOz4yjtjyL3vuRdOSKltUuX0+LbAON0o3UJFmiibPi+pXtBLrvWHR2tHZfBuSm + xZIrPk9mfAiJlwKMleWsvxsnj+7H9YAD+xxssbexwnqbBVs2m7HV3GxlI631E9fa/wGRpaRpa3TTbQAA + AABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAjJJREFUOE+lk91L01EYx/NP6L4boYtua2oM52Q5+JVzKMuGYUWk9os0S9NlmqhYmUYt + XyCd4tJJq9UknFTkC5giJWIsJfMtp7jE4Ss6EQy+necEO66sizzw/C4OfD7PeV5+IQD27emQ4M1rPyhc + betoda7hmX0ZzU0+1FvmUVM9B/NDD+6VTaGkeBwF+V+QmzOMa1fdDGXJ6UNgdxdQXbVFl389m1vb0CV1 + 43TSKx4BgfPlKhdUlK/8E/YtbyLa8BYKhQzjKYcQ2J8ucUFJ8fddBZSZ4G/eVYTpXci/OY2ThhYhsDYu + cMEN0+Qfgp3w5wkfDklOZGeNIiHeKgS1j71ckHllOEjwO9zv9uKAxg5ZHoRebxGCqspZLpAvDgYEu8Fd + AzPYH9mEM2ffIza2RgjuV0yjswNslMD5lI8wnuvj3aaGUc30bMr8C+5BovEdJMksBLdLJ9DuAtsBoMX2 + g819A2V3F3lTqWFUc0a6OwDHJbRBqy0XglsFo3A8B55Yt9ni+KFLzgoKwwUTki8X8sxx8Qw+4YBGUyoE + ptwRBgOVj/w8MwnYeiNMJWFobAEjU4uQc+4gRtfKYdUxG9TqQiGgtbTUIfBsEhB8Ke8BvnqW4Jlfw/Ui + M8I1NgY3IzyqAarIPCHISP/E6l7nNR/UOhB6RMKL9l64OvrR2TOAvg9DOK43QqFuRASDDytroVRmBwkS + 01J7+XrShtGS0JxpVNRtahjVTFkpCD4akSkE9FP8b/wEuMDBOdcQbKsAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAfRJREFUOE9j/P//PwNFAGQALjx5y7eYyZu/7pi3++uj5Qe/Hll58OuUVYe+SiGrx6m5 + b8PXHUD8p3vd1+eNK748rl/y5c7cnV8fAw34hGwI3IDuVa/+Lzvx1QBkOlDTsv6N336nTnr3xqXgxG/r + 1O1/zBO2fHevuPtx5vavb4AG3IS5AmwAUICzccnL//MOfL1av+Jrw4RN3/7E9Tz/51pw/L9dxu5fprFr + jrvkb31oGb/8T1jHu59LD3y9j2IAiFM88/n/rFmf/xfO+fI/sufjC6vkLX8tEjf8MI1dmQ+SD6jdrmIY + sfiFa/nt9w1Lv+zBMCCp79l/76Y3/6N7P/8vm/Pmv4b3pNUmMSscYQoVHOqY7bIO/XYtu/O6YeWXQxgG + BDU//W9WfP+/Z9MrsEsSex79r1v81hLJAFa7zEN/veqefWte+WULhgFOFY//OxRd+2+Vefy/Sfy2/4ZR + a/9r+EwFqoNEs1nceiXbzIP/Alpe/y2Y/rgUwwD0tAAKWGQxda9J7q5lt/+kTX7/r3fDVzaCBqAbaJGy + 72JIx4d/YXXnc4lKSDBFcX3vlRzyL8T4t3z451d55ZtWwGxGkgzwqH7s7N/y6ZdHycWfxlGrvNBdhjMp + wxRG9X6OdC651mgas04UW54haAC+zAbOyYQUEJIHAEKin9SFT4mZAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAeBJREFUOE9j/P//PwNFAGQACK869FVq5cGvU5Yf/Hpk3u6vj3rWf0mpXPiFEyaPi4Zr + Bhrwae7Or4/rl3y507jiy+PWVV/uVCz68rly0ZdUfIbADLg5c/vXN+6VD96bJ2z5bpWy7Y9D7vGvKZM/ + vyic8+VF4dwvYSBDlp34auBQdA3IhLga7H0QsfTA1/thHe9+mkXP/+2St/6maeyaY0D8xSx+8+/kyZ// + ps/8/Cx77pfIeQe+XrXOPP4f6Fq418AGNCz9sse1/M57da+eWwG121VAYqaxK/ONo5d/1QmY/Su08+Nz + oEv+Z836/N8kfiumCxpWfjnkWn7vlZpn32EFhzpmmPNMYlY4anhPWl02583/6N7P/72b3vzXC12MaUDz + yi9bvOtffNXwnnwTaAArzIApW7/qAjHYZs+mV//Niu//1/CZimlAwfTHpYGtb/4aRa75BTSAG2YAKMCs + gH42id/2Xy9kCVizqlsXpgG9G76ypU1+/8+17PYfda9J7sihjBxg2KITHh1hdedzQzo+/LNI2XeRUOLB + iEaQgFbAbEb/6msv/Vs+/HXIvxAT1/deiRiD4C6AGsLnU3nzVEDr568e1Y+dSTYApsG74VVoVO/nSLIN + IEYjSlImRQO6WgCDbJeeDo3KmQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAWtJREFUOE9j/P//PwNFAGQADOfNvg9kQvhZ02/D2fF9l+DskMaTcDbYclwGpE2+CVcY + 03kezg6oPYppAMhmEM6ece9/BtDm9Ck3/qdMvPo/EWhzbNe5/xGtp/+DbAZp9qk8+N+jdO9/l8LtYINQ + XJA1FeFskGaY60Kaj8PZHqW7cXsBZDNME7KzA2uPwMVdCndiGgBydgaSs0GaI9pBzj4OdPZhsLPdQM4u + 2P7fLnfrf5vMjf8t09ZhegHF2UDNMNcgOxukGTngUcIAFGAwSZDNMLYTkrMt0tdiGhDfc+U/2Nng0EY4 + G2QzyM8O2Vv/W2du+m+euu6/adKq/4bxK/4bRC/F9AJyaIP8DHMBsrNBmnF6IQjJ2cihDQswkEa9GIjN + MAxmIJy9H5xIQH52gIa2OTC0TZJWg52tF73sv07U4v9aEQvBGCMhoYR2NiK0jeKXw22FaURxAYyD7GyL + VERoIzsbrwHIfiOWDQC8F6MA2SYGaAAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAZJJREFUOE9j+P//PwMM582+D2T+ZzAOmf4fhFXdusB8GE7ovYTCB4nDJUEcmAEgNrpm + kBhJBiDbDGNHd5zDdAHIVhiuqu/4X9PQCcaVQFxe2/E/p6zzv56h6f/ojrP/w5pP/g+qP/rft+ogGGN4 + oaah4/+7L3/+v/n05/+L97/+P3z18//m/df+m1rYgxUH1h3FdAEosGBOBNkM0vzs7a//91/++H/j8df/ + 89ed/q+pYwRW41N5ALsBsAADOfv5O6DmFxDNF+99+T9jxYn/0nLKYI1uJbsxDUAO7bLazv8PgDbffPwN + rPnMzU//Jy4+/l9IRAKs0TF/G/5oBAXYmp0X/89ee+r/VKDNE4Caexcc/8/Kxg7WaJO1Cb8B5pZ2/60d + PP7rG1n+l1fW+C8iLg3WzABOLsAElrgKvwGgaMIW/zAxg7hlmAZEtZ/9D8IgzaBo8qk68N+jdM9/58Id + /+1ztvy3ytjw3zhh5X/92GX/daIW/9eKWAjHGOkAWzQhuwikGd2FKHkBWzTR1wB8AYhLDgDUwtLm00DQ + 8QAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAQdJREFUOE9jdImq/c8ABbuXNjHC2IZ2QQyszEwMv//+Yzh/aB1MGEy7RtfB9TCADAAC + BnRs6hDMcPfFDwZza3sMOZhasOUgwsA2kAGkAUTDJEFskGYQQBZDVgc2ACRJjG3Y1MFNx2YbSAO699DV + oTgPOQyAGsEugxkA46OHE9gAbP4HKbQLKQfh/yAaWSOyerAB6P4H2WofWgHS+F/fPf2/qn38f3mL8P+S + JkHg2EJWD3cBemiDFJr7FzCANAMxhgtg6nGGAdAFYE0KlhFgW4EuwJoWUGIBPR2ANMKcjSsdwA2gSTog + JnWCXYDuTJhziXEVSC9OA3ClTuQ0ATcAxABziAQw9SAaAOUT3ITyrFIdAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAALZJREFUOE9j/P//PwNFAGQAOi7bn+2GTRybGIZmkKKEGRH/iTUEpwGWZfpEGYLVgKgp + Qf833Fr8nxhDsBoQPMEbZDtRhmA1wKfLGWwACEctCsDrEqwGODZb/M/YEAvWbNus/1+nWOG/RBo3iFZD + jwmsBpjX6KFo5k9gwaoZnIawxa1eqTLcZnyacRqgki8FdjYhzTgNkM4QJEozTgNEkjlx+pmoQMQW2rjy + BtZAJDYj4fQCKQYAAPmEmBfWSTCRAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAAewQAA + HsEBw2lUUwAAAHZJREFUOE/dk0EOwCAIBPXn/LwVEsiGIsu5JsSDOsKgW0SeRcbZs69bFNANesHPAEeU + Cg0lWh6LhQ4qABVcATwLX8OsEGgdyl3ALBBQQVqAHsiADAlAFuVZ3GYvgz0y60gVU0D4QchHYvePRhKn + gOo9MAdWAosXUycHaVBfr4kAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAAewQAA + HsEBw2lUUwAAAHtJREFUOE/dk1EKACEIBevm3nw3BeVh1vO7IPqoJht1isg3yFhn5vGIAm6DPvAYYIlS + oaFEv8fmQAcVgAquAB6F72FUCLQM5SxgFAioIFeAXsiADAlAFuVRnFb/Ri6yXNKWkWp2AeEHIZvEwyvW + Oy2J0GVbV7bSyACsEn+8EhBgkQllUQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAAbpJREFUOE+Nks0vA1EUxW9tbP01IiqCCPFdjTC6FYtuxMKGxEYiNkUlFtou7KuR+BMk + 7IQNkkak1ca3CVXVmfTNHPeNzjMNkbl57+Ut3j1z5ndPYHv3GIa4Jb3STDePLVSp6mSUBVUrr2QRKNDU + RPjI09HBaoALXAHy1mYijdVMDbNbOiZXChhbzqFv4Qpdc1m0Rc/RGs2ie2gK3ONsLnmoTRupPdi2DfBy + S15NPt5MgZJlq+a/RCiW2FPN/BaGyY1lgTtd4PrBQk7HLwdeJ7SeTKsvmzXg/dPGS0mg8CJwWTRxcW87 + AkFtR/45gqNLjn1XhOI7GeX+w7ChvwPFZ4HsncBpXuCs8O2AeRDzIL43CqwnM3UHFqoWoBtAvmTj4snC + yS0LPH0LMA9iHkrAdUHLa1sIhcIYn5jGSFjDQEhD/6iG3uEpdA1OomdYQ3v3kORBzOO3gBcI81DjkfmI + pdJYjB8gsniIsfl99M+k0aklJA90RJKSxw8MaYl5EA/CEfGdDy9R5lF3YPnKhxMwrwDzcMbDPPznw42l + mms9sn7z0ZjrerMbWTfd/+WjQUDNloX85uNPASnkNx9f9Za170nfEBcAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAAewQAA + HsEBw2lUUwAAAFhJREFUOE9jYKAD+A+0Axsm2ur/f9s1UTDUQOobgO5MmA1Eu+D///8MYIzmRNobAHc6 + mgvg4jgCEe5Sig2AB9aAhQHcBWgpjuRoxJWyiI5G2hlAaWbCm2kAkd7n2eHVasYAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAAewQAA + HsEBw2lUUwAAAFJJREFUOE9jYMAP/gOlQZhsQJYBME24aIKu+f//PwNWTKx3KDcAahPZXkD2I1mBSJYB + hEKeoHf+/23XJAmjxwhJmkGWDUIDCMQ9wUDElb5pnw4AW9Xn2ajicy4AAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAAewQAA + HsEBw2lUUwAAATxJREFUOE9jYMANUoBS/4FYG48anFLtcnIM/2fMABsAwkrEGqIIVLjS2prh/40bDP// + /2f4v3gx3BCCZjgDVZwIDWX4//YtRPO+fXDNBoR0g/z7JC8PohGEt22Da7YkpBkk/9/SkuH/o0cQzevX + wzU7EqMZpCYB5HwLC4b/xcVwzZ7EaoapUwUy+qChHoCmWR7I74HKuZNqsD5QwzxhLub/zircoCjdT4oB + DkDFG9VF2f4vDpf6/7dd87+jEhfIkHJiDAkCKjpio8D5f0eSLFgzCNc5i8ASF14zkoGy1wO1ef+fz1NE + 13wPKGeMT3cpUPJ1qpnA/+fVqmDNP1o0/scb84Ns3gPEfISc/99RmQtu6+1S5f8OEH/PIqQRJm8AZOzw + UOP+vzxS+r+CICtIcxmxmpHVpUPjHRSYOAEAem2I0ONQwZQAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAAewQAA + HsEBw2lUUwAAAFJJREFUOE9jYBgs4D/QIciYZHf9/9uuCcZQg2hmAE6XEusCnOpoYgA25+J2AZZY+P// + PwMYIwUssS4FRwJtDCAlvWBzAUnpg3IDSHEuSU6jqmIA9g2JHe1dhDsAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEAAA + CxABrSO9dQAABalJREFUWEe1V1lQk1cUJjN9qHWjYmutxjJKs6C1GTut45uvTH1oOzriDM5krA+ORQe1 + M1hcqixlkc1AJCwhCAoEhISyKSIEhBEwBqRsAU0CIjskIALaga/nBjckFCP4z3z5///ce8757rnnnPuH + 42DjKiy848jhcCI4HIedDg4cZyenFdZZg4Mj9AsT4KAGcNHNbYfJlv6CZQUFlc55ebfNjY0G8jPzGhkZ + xf37baBx5OaWn1uws7kMqNUakUpVam5v755FggkslicoKdEiO7tE8cFIZGYWi5TKm2aj8bFNEs+f/4sb + N6qQnl4U8cFIXL1aKEpJKTA/ePDIJonx8WdQKouQnJxP+fKBLoUiV5SY+LdZr2/H1NTUDCLsvbnZCLk8 + p/S93MfEZHkRxPMpx8WpRDJZNrq7B2ZFYnh4FEQQZMd5PjuzxqOilMa4uGxIJOn/S4LGFbGx2RgYsGBy + cnIGxsYmQAkLsjXvQmYRCA+/iq6ufkRHZyA09IpNA2FhVxRJSblgFTEx8XwWRkfHUFRUDbJlf1kmJKjx + 9Ok4TKZuZgCBgYoZJOhdER+vQm/vIJgjWzCbR6x9ISgoyX4CkZFpGB5+Yq3rtrYOBAdfxvnz8VYSvr7x + Cqk0A52dfdbxudDXN4SsrBL4+ibYT+DMGRn6+83WvWVg3c/fX47Tp2NKIyNTwXrAy7G37/39FtK1wGB4 + zHIIZOsnu5Pw5Mno2vLyWmt29/RMo7ZWTxl9Da2t7Vb5fGhqMoDswMdH6mg3gePHI7xYFRiNXXj0qPcV + TKaZ72+Ovfnc0mICa1Isl44dC7e/LR89Guro6XnBzFrqw4ed1pDPBxZyBp2uBTk5GhQWVoIRkcem4m7Y + dnNrlCtaJK7vXpKHDgWKjxy5gIqKOuj1Jgp9x7xgzhnpW7fuoqxMhzvld9Ao34WHKVsxeO8HNES44p/w + uUlQN5u5XQcO+CoYCTqAoNU2o6nJaAMGkhlQX98GljeVlfWoqWnAvWotdJfcoE/cAnOZAL3p6zGk+x61 + F4TQhQjfPRL795/18vA4i4CARNAhhOvXq6yOKiruQ6PRsfMfxcU1qKtrtYaffRc01NVDK/0RDXFbYNHw + 8dhvKYYDl2Agk4uBqm2oCRSi+i87SOzbd8rZ3d1HsXfvHzh40A9eXmHw9pbg8OEgUJTA5Kwr6nR66Bub + UB21C3XSzbAUbUJP6EpMxiwHZMsxKlmBoWwu+spEqPAT4ravHSReltLu3d47CV6EcwTxi3cR3c0JslSU + hbpBe9EVg2y10lWYvOwEJL/GWIIThnO46Lm5FZo/hSg9+x4kbNX1kf2/7kw7sR1VoUKYaZVmxWpMZa4F + rr2FrLUYT12DJ3lcdOVvxs1TAhT5CN49J+ZqKgUnBaICbwGMGUKMF27AVMFXQOHceKZejzGa16kWgunl + ey8CiZzfBWICOjL5QMXXQDlvNjQkv7UJKN6IyRvOmNJsQoeSB6anPrEIJK55CcQEmK64ANUC4N6W16hx + Ba7biArJTCkuYHoZRwUiu1v32wppngJxmicfBsVGck5OW76bRimRylkPqNYBsSsAySf0T2IJkP0lkM9F + VYgLUn/jqxZMgBlIPsQXE/BA5gzUfQN07CDH5IglZdrn044THAH5p0DkxwAl51AaF0xnUQgwI/KDfDEB + rVFcoOFbIPWzabAc8OOQYyLByjToIyJFctUasPmLRoAZihXzxTIxHy1hFHbmPIkcaikvopYC/kQimu5S + QooTnqWsBpu7qASYsWgPvjjKg4+mgC+A+JWAkrageRvt+wYg84VMsRJ1vmtB84yLToAZjHDnicPdeWg8 + R84vLaNVvwB7li1DX9gqSD1cQHMW3pTmWkHIHp44eDcPeZ7rYAmh80GyBBPhS3H7xBpEursgeA/P/o8X + e8MV8AtP5P8zT0XAGzCS/NXK/wPEN69yrw+tBQAAAABJRU5ErkJggg== + + + + 126, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQ9JREFUOE+t09lq + wkAUBmBfyr5DfY32jaReSOmFCyKCgkKLFrVUBZeKiEbshqRuaNw1xiXmLxMJBJ0Zc+GBw9zMfDPnHMZm + u1ZE35s4zXCqjmC8Al+sgHLjD9y7yGFWPIbecOO45yORtMAEHnxxJHL1IyKI9JeEXqtMwOl50Q8bSS0l + 8PzBBPbqAQQxICrgjeapgKZpkJUdBmNZB+y3d/QSnsIZKrDdqZjMFYj9OR9wB1NngHrQsJC36EkrfIkT + PuDyJ84AZbOHNF2j1Z2h9i3xAVKfOUjjZssN2oMFmq0xSkLfOmBu3E97iurnENlKxzpgbpzwO0Kh1kOy + KFoDjHmzVuYYjRmTDZfyWh9Yd/4B2Mz2w1z7EGUAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAlpJREFUOE+tk21I + k1EYhif0oyA0sqIQCix/+GcQFFH9CCmiUBTLLEjShJofVBgL2fxoU9Pp5ubUlS5rU9f8rCyjsA+pUCRC + TR1ppmVFUSlmhq78unrnQF1KGHTg/nEOz30993PO+7qJFrmUeiv2n+Mij+XLRLLYULdF2pxlEVIDcw0p + AsyxD5fmI/rQ94pqi26eOlsfuZj+7BgSm01QdA4ih7m73Yx9qGpavwatjPebqCzOprPt8YKQgzFagqL0 + BEjyEFWVaBkdLHMxT34uYNwWR9nVTEoL0zHlp2DMSeaSRk6eKt4VWm5WM/rVPNN5SjDTLQebZEHNA1wr + UvHjk3E6tsNcV62e1r3KLGqtKm6WplNpSsVqVFJsOM8VfSKFWjkGtcyZptSYzvC7XByx3zQoqCnTMvlG + CX1prnornPUmQJcUXsbSVhGK5bIOkcmQyveeTHiv4VZ5Nk33Nc6iuSO8CIfmECYa/bE/8ON1iRipJNh5 + F0V6Bd86lfQ1JlFj1TDVq4COKCegLVIwHmGiKRB7/V6G7+5koHozymgfYRy5E1CgTWKgXcZ1i5qWp0KS + rjgBcAJawph6FszYk/2M1O1isGYLX8p9ab6wgqP+3rMvYciS01GfzA1LFvQkQ6sQ9/khxhoCGHnox1Dt + NvorxXw0b8Km8UQh2cip6GOzgNyMeKqKM7HdjqFZJ5pRk2YJ9aql3EnxoCJxNaZ4Ly6e3UDY3O6OEXRp + 59ApTpIhiyDh9GHORAZyPHQPB/ZtZ/cOMVvFPvh6e7F+3SrWrHRnraf7Xz/xf/rJ/kvxb84I3U1y+9/W + AAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAixJREFUOE+tk91L + k3EUx/cvdN9N0EW3NTWGa7EaPOUcyqphWBG9PZEv5dJlmqhYmUYtXyBb4dJJy+kknFT4BqZIjaFMJUsz + V7TEoabYRDD49ju/6Pm1Mi+iH5zLz+c855zvo1L9j/fsaRRUvvZltHmX8Ni9gMaGCO47ZlBb8wn22yHc + KJ9CackECgteIy93FBfOB6H0JrC3B6ipXsVGb2V1Dca0XhxOe8JLEXhbF7mgsuLLX3mCIwsr2G1+DrVa + huWQRwjcj+a5oLTk87qCn/D78CLiTD4UXJ7GAXOTEDjrZ7ngku3dH4Jf4ZHJCLZJXlhzxpGa4hSCurth + LsjOGo0R/A4PBsPYrHdDlgMwmRxCUF31kQvkMwFFsB7c4/+ATYkNOHL0BZKSaoXgZuU0urvATgkcP/kK + lmMDfNu0MJqZPps6/4D7cNDSCUmyC8HVskl0+MAyADS5vrG7f0X59Tm+VFoYzZyZEVTg5NR2GAwVQnCl + cByeZuChc40FJwpjek5MmU/YkH6uiHdOTmHwfg/0+jIhsOWNMRiouhPlnUnAQoI4rYSht7MYm5qDnHsN + e41tHNbucUGnKxICiqXjHpTPJgHBZ/Nv4U1oHqGZJVwstiNe72JwI+J3PYA2MV8IMjOG2dzLfOatBg+2 + 7JDQ0tEPX9cguvv8GHg5hH0mC9S6eiQweLumDhqNVQgo06dP9fN4UsIoJHRnOhVtmxZGM1NXKoJ3JmTH + Cv71r/4OTrQ4xWMwWlcAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAdlJREFUOE9jYKAl + mLTlW8zEjV93zNz98dGyA1+OrNj/ZcqyI1+liLKzd8PXHfUbrvzpXvf1eeOKj4/rF3+5M3fnx8fLdn39 + hNWQ7lWv/i85+cUAZHrX2i/L+uff/53S8+qNS/yJ31qp2//oJ6z/bl929+PMrV/frNr/5SaKK1Ye+8fZ + uOTl/3n7v16tX/61oX7TlT9x9ZP/uRYc/2+XsemXSeyq4/b5Wx9qxdf/Cet4+XPxgc/3MbxRPPP5/6xZ + n/8XzvnyP7Lr3Qsr+y1/zaIX/zCJXpkPUuxbv0PFMHjBC9fy6+/rl37Zg2FAUt+z/95Nb/5H937+Xzbn + zX8Nr0mrjaJWOMIVhoYyy8cf+u1adud1/covhzAMCGp++t+s+P5/z6ZXYJck9jz6X7vwrSVMobFxGqud + /f6/bnXPvjWt+LwFwwCnisf/HYqu/bfKPP7fJH7bf8Ootf81fKb+hyk0SVyjZJtZ/8++Zf/f/GmPSglG + JShgkRWpe0921yq78ietfva/+lX/2QgagK7AImXfxZD6Of/C6s7mkqQ5se+Dkn3e+Rh/oGa3yivfGBj+ + M5JkgEflE2ef+qe/7LP2/zSOXOFFkmaQ4oiez5HOJVcbDRJXipKsmS4aAAyI8o0B7uJCAAAAAElFTkSu + QmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAcpJREFUOE9jYKAW + WHbkq9SK/V+mLDvw5cjM3R8f9az/klK48h8nUeaDNC/b9fXT3J0fH9cv/nKnccXHx62rvtwpmf/lc+XC + L6kEDVm1/8vNmVu/vnEvf/BeP2H9d62UbX/sc/d/TZn87kXhnC8vCuZ+DgMZsuTkFwOHomv/MQxcfODz + /bCOlz/lo+f/dslbf9M4es0x09g1X+Tj5/+2n7z/b/rk98+y5n6OnLf/61XrzOP/Vx5D81r90i97XMuv + v1f16LnlW79DBWSDSfTKfLXIpV8lfWb/8m95/xzokv9Zsz7/N4nfiumC+pVfDjkV33ul4tl3mCE0lBnm + RKOoFY4aXpNWl8158z+69/N/76Y3//VCF2Ma0LTi8xb7ohdfVbwn3DQ2TmOFGTB562fdKVu/gm32bHr1 + 36z4/n8Nn6mYBuRPe1Rq37r/r6TPml/irsXcMANAAWYF9LNJ/Lb/eiFLwJpV3bqweGHVf7a0+tn/tMqu + /FH3nuyOHMoYAYYrTsPqzuaG1M/5Z5Gy7yLBeMeu4D+jd+W1l/Yt+//a552PSez7oESyQSoei/m8Km+e + Cmj99NWj8okzyQbANHg3vgqN6PkcSbYBdNUIAPBq6KagTglpAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAVZJREFUOE9jYKAm + yJt9/z/MvKzpt+Hs+L5LcHZI40k4G8NuZAPSJt+EK4zpPA9nB9QexTQApBGEs2fc+58BtDl9yo3/KROv + /k8E2hzbde5/ROvp/yCbQZp9Kg/+9yjd+9+lcDumQVlTEc4GaYY5MaT5OJztUbobtxdANsM0ITs7sPYI + XNylcCemASBnZyA5G6Q5oh3k7ONAZx8GO9sN5OyC7f/tcrf+t8nc+N8ybR2mQSjOBmqGuQbZ2SDNOGMe + FGAwSZDNMLYTkrMt0tdiGhDfc+U/2Nng0EY4G2QzyM8O2Vv/W2du+m+euu6/adKq/4bxK/4bRC/FNAg5 + tEF+hrkA2dkgzTi9EITkbOTQRg4wvRhsNsOdvR+cSEB+doCGtjkwtE2SVoOdrRe97L9O1OL/WhELwRjD + JSihnY0IbaP45XDFWDXCTEJ2tkUqIrSRnY3XAHJyNgCOffGUI9q5jwAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAYVJREFUOE9jYEAC + ebPv/wdxjUOm/wdhVbcuMB8GEnovofCR5cBsmAEgNrpmkBhJBmCYDhSI7jiH6QKQrTBcVd/xv6ahE4wr + gbi8tuN/Tlnnfz1D0//RHWf/hzWf/B9Uf/S/b9VBMMawpKah4/+7L3/+v/n05/+L97/+P3z18//m/df+ + m1rYgxUH1h3F1AQKLJhJIJtBmp+9/fX//ssf/288/vp//rrT/zV1jMBqfCoPYDcAFmAgZz9/B9T8AqL5 + 4r0v/2esOPFfWk4ZrNGtZDemAcihXVbb+f8B0Oabj7+BNZ+5+en/xMXH/wuJSIA1OuZvwx+NoABbs/Pi + /9lrT/2fCrR5AlBz74Lj/1nZ2MEabbI24TfA3NLuv7WDx399I8v/8soa/0XEpWGaIQkscRV+A0DRhC3+ + YWIGccsw5aPaz/4HYZBmUDT5VB3471G6579z4Y7/9jlb/ltlbPhvnLDyv37ssv86UYv/a0UshGMMy7BG + E5IqkGZ8LsQeTXQ1AK/zcEgCAIxjAKs2RzKNAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAHdJREFUOE9jdImq + /c8ABXuWNTPC2PhoZD0MKBxidCOpAeul2AASLSVNOSWuA9tEsQF2IeXwGCLa7SBb7UMr/oM067un/1e1 + j/8vbxH+X9IkiHTDQJqJthmbQgXLCMoMIMvZFDmZLM2UOBOslyoGgAwhxSCYehANAAapNxKN0u50AAAA + AElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAJVJREFUOE9jYKAF + KNmb6UaRuQkzIv5TZAjIAMsyffINiZoS9H/DrcXkGxI8wft/2f5s8g3x6XIGGwDCUYsCSHeJY7PF/4wN + sWDNts36/3WKFf5LpHH/1ytSVCMqdsxr9FA08yewEK8ZZINeqTLcZpI1gwxQyZcCO5sszSADpDMEydcM + MkAkmZM0P6OHLNGhTVSU0FoRAOGcWiLZO+vqAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAABcFJREFUWEe1lntM + U1ccxyHZH2O+mLg5p3VEHhfQucZlM/7nv2QmmxMCiZjdOBIXpwGnWZ3TiVBFEWillJZn1QLlXZBqBUEe + YngMyyO8CkoLIm9oQQR0ge/OKToFyrAKN/n23nvO+f1+n3PO7/xura3MXEplka2NjY3A2tpqt5WVtb2d + 3WrTqKGhUfIL/fQ0ssnDFXf3XXpz9u/dplaX26tU9wyNje2Ye42OjqGurg2kH7m5JQHvHWwhB2QVuAqF + 2tDR0TMPgjYYjU9x9241MjMLZcsGkZaWZ4LQ6Z6YhXjx4h/k5VVAocgTLBtEYqKKK5ffMjx8+NgsxMTE + c6Sm5kMuzyX5skyXTKbiSiQ3DFptB6ZJBr550ffmZh3i43OK3il8VFSmv0SSwS5mHBOj5EqlWejpGZy3 + EiMjY0hIuAGJRGm/mJ95/SJRqi4mJgsREYr/hRAKU2TR0VkYHDRiampqlsbHJ0GSlvhIW3Qi8wDCw5PQ + 3T2AyMg0hIYmmnUQFiaXXb2aC3oiJidfzNPY2Djy8ysRFpZk+bGMi8vGs2cT0Ot7QGGCg2WzIC5cSJDF + xirR1zcEGsicDIZRU10gtpYDCIUKjIw8NZ3rtrZOXLp0DYGBMSaIgIBYmVichq6uflP/QurvHyb14C7O + nYu1HODMGSkGBgymvaWi1Y/Pj8fp0+IioTAZtAa86pt7HxgwElsj2tufkP1PITbRP1ichDxeRE1paY0p + u3t7Z1RToyUZnYHW1g5T+2JqamrHyZOROHtWYGsxwLFjAn96CnS6bjx+3Pef9PrZ72/2vfnc0qIHLVI0 + l/z9wy0vy35+AttDh4INtKQ+etRlWvLFRJecSqNpQU5OMdTq+6Ag8dHJKA/eaWgVuaE5wu3tjyQBYI8e + vYyyslpotXqy9J2Ligan0IWFf6OkRIPy0nI0xu/BI/l2DD34Fg0CN9SFLgxBqtns7WLZABmFSE8vQHV1 + M5qadGbUTtraUV/fBpo39+/Xo6qqAQ8qq6GJcoc2YRsMJS7oS9mEYc03qLnsipoQ5u1X4sCBM/4+Pn/h + /PkEJCWpcft2hSlQWVkdios15PtfioKCKtTWtpqWn/4vaKitR7X4OzTEbIOxmMGToBUYCbbBYDoHgxU7 + UBXsikq+BRBeXjx7b++TMi+vP+DrG0QSKwzkpODw4Ys4eDAQtJ1WRY1GC21jEypFe1Ar3gpjvgN6Q9dg + SrIKkK7CWMRqDGdx0F/CRVmQK0oCLYB4dZT27ePt9vD43Z/cAzw9eSx99/Q8wfXw4BnipMkoCXVH9RU3 + DNHZitdi6podcP21xuPsMJLDQe+d7Sg+64qi0+8AYe5c/7r/592K4ztREeoKA5mlQbYO0+kbgIw5ytyA + ieT1eKrioPvmVtz50wV5p5YAQnXKjXuL5wJdmism1JsxfesLQL2wnmdvwjgZ15XtCmqn4i0BRM4Jhs05 + 4YLOdAYocwJKneermLQXOgAFWzCVZ4/pYgd0pjqD2il/WwKIDD+GzfB3gT7REah0AR5se60qN+C2mVUh + bXq5I6hdmp8b1+LSPddAcYRhidAu20KCk6AtX8+oiEDlbAKUG4Ho1UDER8AVGyDrc+AmBxUhjkg+zCjf + G4A6uH6IYa//wuCh1B6o/RLo3EUCk0A0KRWfzgSOswXiPwaEHwIkOYcVHFCbJQGgTuJ8GTbel0GriAM0 + fAUkfzIjmgNB1iQwgaDH9OIHBIq0K9eDjl8yAOoo5ieGlbIMWsLIstPgV0nAapIXohUAn0BEkruYSG6H + 5/J1oGOXFIA6i/RhWJEPg6bznwGxa4BUsgXNO8i+bwbSX7bJ1qA2cANE+x10Sw5AHQq8nNhwb2c0BpDg + USvJrF+KPktXoj9sLcQ+jggl45YFgDoN8XRiL3k4Q3VkI4wh5PsQYYPJ8BW4d3w9hN6OuLjP2fI/L5bS + 8r934vL3Oir5e53xSkF7HXT8H1/P/F8T86yx6qCSJwAAAABJRU5ErkJggg== + + + + 673, 21 + + + 379, 58 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAaBJREFUOE+NkstL + AlEUxoeglbRqG/QHtGpRm6h95aZ1y/ongqBNu9xUKGQWYQY9QMiCKMiKCjIJCSvGtER8RPnMNG1eX/eO + znXCmrxwOJc79/ude74zHFdfmcx4VRTHeCxzQJCDKI5Gk0mzoH03zDJv8ghTRAgrsE/yQ22vnpUGt/+F + SLzphgnWiGiXq4kJpBAagNt7h63DAFx7Pqzv+eaagIKFXLaSmKciujZrL7GT2NTOAMfOKfpHJpsh0QdO + dMx2Klio9Y/nduCE5GovEO+qQ0kN1yGOLu9UiNNzZWEvkSSzn7VAK5LqzBPMMMCi80AVa9EAlIbOmGCF + ACJtDROxxACiJINCNNAPL5RMz7Qc7rDBTQCJbiA7RSawzMSKoqBcEfCaLauAvuEJ/DqdVfc5E+k3X4KE + 3HsFsZd3Y4B9y9sEkGQFxfIXUukSHmM5Y4Bt46gJUKmKSOc/EU0WEAynjQG0P/2ixhU+qoi/FsFHs/Df + v7QO0BsXiedxG3rDRSDROkBv3P1TBr5gCsfXsdYA2rz/yn+OUZsxvfBf0P/gG7YANslA9wapAAAAAElF + TkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAYNJREFUOE9jeChg + 9v+hju9/BnLAA1nH//cZNP8f1nQj3YAX+479PyNuCTZgm1sUTgPe108Bq3l26jyqmuM7d8MN2J5chGHA + c4f4//f5TP9vyav+39nZ+f/27duoai4fPfH/rIQV2PQdDV1wyUfyzv/vanj9n1NU9b+mpub/5s2bsbsO + ZsANdr3/Z2IK/j/gN/t/zTbyf0dV7f/W1tb/hw8fxh8uIANucuiDXXBE2/1/SUnJ/4kTJ/6/evUq4QB9 + FV8J1nidTef/NVbt/z1JWf9v3bpFWOPrhCpItJkH/o8LCP5/XMgYbMixOUvwa4ZrtAj6n5KS8n/SpEn/ + D23ZDg5EUBjgNOBtQTvYxksytv/j4+P/T5ky5f/Dhw/BtiEHIoYBX9fvAWu8zWXwP8sv+H99ff3/u3fv + ojgTZAAoBYLUnc2uRci9qZkIFlymYf8/NTX1/8mTJ7H6DxTamwKSwF5Yvnw5Qs2GDRv+5+Xl/Z89ezbe + gHny5AlY44QJEwiHPqGMBgCKFAb9AMf79gAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQNJREFUOE9jYBi0 + QDti3X8QVvGc9p9kR8I0O+Yd+28Ytog0Q/SjN4JtDmx++t+n+sZ/p7wj/7UCFhBnSGzz+f9+ZUf/Z8/6 + /j9/7o//wS1P/3uUXfxvn7X/v4bfXMKGlM158b945tP/WRNu/29c/f9/ZM+n//719/5rhqz+r+pLhAGw + wIpvvfi/ff2//3ETvvwP63jzX91/EWkBCTKgb/O//6lTv5FvwJTt//7nzPlJvgGzdv/9X7zwN3kGZPTd + +j9v39//FUv//o+Z8P2/qvcs0sKgYNqj/8sO//4/feef/50b/v5Xdp9EmgGg6Cya8eR/zqR7/1O7r/8H + pQ+SkzPdNAAAi82yo6RtOqUAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAQhJREFUOE9jYBiU + oGzOi/9FM578z5l0739q9/X/sc3n/5Pk0IJpj/4vO/z7//Sdf/53bvj7X9l9EmkGZPTd+j9v39//FUv/ + /o+Z8P2/qvcs0gyIb734f9buv/+LF/7+H9bx5r+6/yLSDZiy/d//nDk/yTegb/O//6lTv5FvQPv6f//j + JnwhzQBQ9BXPfPo/a8Lt/42r//+P7Pn037/+3n/NkNX/VX3n/lfxnIY/LEDx7Vd29H/2rO//8+f++B/c + 8vS/R9nF//ZZ+/9r+BFhACix6Edv/K8dse5/YPPT/z7VN/475R35rxWwgLDtyCkNZAAIO+Yd+28Ytog0 + zTCDYIYQ9DdJaZwWigFfl7KjzkB4uQAAAABJRU5ErkJggg== + + + + 696, 58 + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8 + YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAlwSFlzAAALEwAA + CxMBAJqcGAAAApRJREFUOE+lk1tIk2EYx3fTnUQQ00lqM/VLd/xm0yJvyigxJZIMb7QCwaKDmrIsMTU1 + W/OwshzTzOmch28Ts/AQEeqdVx2ISiJreMhTU9aBufYN/r3fN7SSYhdd/K/e9/d73ufheQUABP4iaZJs + 2jWsPvK3e35hDlJ0K5JkZhnofrpwo0TwfPAM3WvRY2OGGO0h7nKUNup09J1oqEfioGAUoB+qcn+XCDjQ + MfsI7pUhPi4Hg29TDbC21yGz7vBgxLUI8IJRNdRP4iFrl0HZq8xbkwhs5nqsh0BMWy16TDXovq+DMFUI + UYYI4ZfDIW2VQjWoQowhBvIuOfRVmkxOIuhpq8EP58gfcX8dALtsA7vYBu+nRoTkhEDZp4TCqsCDsXR8 + GctCcX424Ymgs0XLw2strDpt8DjMYOfuwjulhXeyBGKNmPROgxvk9OMkvGgK/iXoaK5eF3hW+uH5bAE7 + b4B3+iaBS+F6nQdKRyF2OJZ/+jwTh3F9AM5lZ/heYGqs5AVcZdbRSWAjgWvAfiiD581FlJr3gewBqDoK + BXoZZiwyjOoCkHks2SdouV0O9/IwgRmwC/fgndETuJzAhajtPIiw3DBEVkViTzWFCTON6dZIDFRsQcqB + BJ/AWH8VrqV+MjATvLMNYD9WwPNWgxSNFIFpgQg6HoSTVygsWNWY65Bg0hAKpkSIBLXcJ2jUFcO1YOWn + zdqr4Jm4hNWXZ/F9/AScI0fhGEjEoi0ecxYp7M1iTNwKhKloG+Q7xT5Bw40iOO1mLD3LJxNOxvu+3XjH + yPGqncK4MRxP68XoqwyDrSyYr8zBhoLtEIcIfQKyELhefB5FF04hJysN6amJ2L9XBVoSgR2hQRBt3fzP + 8AJ/P9Hf+X8LfgIyvrCLoy7MeAAAAABJRU5ErkJggg== + + + + 17, 58 + + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4w + LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0 + ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAAO + CwMAAk1TRnQBSQFMAgEBAwEAAQQBAAEEAQABgAEAAYABAAT/ASEBAAj/AUIBTQE2BwABNgMAASgEAAEC + AgABgAMAAQEBAAEgBwABBBEAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIA + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + /wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/AcICuwH/AdICiwH/Ad8CbQH/Ad8CbQH/AdACkQH/AcECvgH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8B0gKLAf8B9wIlAv8CDQL/Ag0C/wINAv8CDQH/AfMCMQH/Ac4ClwH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdMCiAL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0B/wH+AhAB/wHLAqAB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7Af8B9wIlAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0B/wHxAjcB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8BxgKvAf8B0AKRAf8B1QKBAf8B1wKBAf8B3wJtAf8B4QJnAf8B5wJV + Af8B4QJnAf8B3gJwAf8B1wKBAf8B1QKCAf8BzwKUAf8BxQKyAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHQApEC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8BygKjAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8BwwK4Af8B0gKLAf8B3wJtAf8B6QJPAf8B8wIxAf8B/AIWAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfsCGQH/AfICNAH/AegCUgH/Ad0CcwH/ + AdACkQH/AcICuwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHCArsB/wHt + AkUC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B2QJ/Af8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wHBAr4B/wHSAosB/wHjAmEB/wHzAjEB/wH+AhAC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQH/Af0CEwH/AfECNwH/AeECZwH/AdACkQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7Af8B2wJ5 + Af8B+QIfAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHXAoEB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wHLAqAB/wHiAmQB/wH5Ah8C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B9wIlAf8B3wJtAf8ByAKpAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B1wKBAf8B+AIi + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AcoCowH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcECvgH/ + AdcCgQH/AfICNAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHvAj0B/wHUAoUB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHWAoEB/wH2AigC/wINAv8CDQL/ + Ag0C/wINAf8B+QIeAf8B+gIcAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHxAjcB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcECvgH/AdcCgQH/ + AfYCKAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B8wIxAf8B1AKF + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHUAoUB/wHzAjEC/wINAv8CDQL/Ag0C/wIN + Af8B+QIfAf8B2wJ5Af8BwgK7Af8B0wKIAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag4B/wHL + AqAB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B1wKBAf8B9gIo + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Af8B8wIxAf8B0wKIAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdACkQH/AfECNwL/Ag0C/wINAv8CDQL/Ag0B/wH7 + AhkB/wHfAm0B/wHEArUB/wPAAf8DwAH/A8AB/wHTAogB/wH3AiUC/wINAv8CDQL/Ag0C/wINAv8CDQH/ + Af4CEgH/AcMCuAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BzAKdAf8B8QI3 + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQH/Ae0CQwH/AcgCqQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/Ac4ClwH/Ae8CPQL/Ag0C/wINAv8CDQL/Ag0B/wH9 + AhMB/wHhAmcB/wHEArUB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHCArsB/wHQApEB/wHaAnwB/wHZ + An8B/wH2AioC/wINAv8CDQH/AdUCgQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcQCtQH/ + AeMCYQH/Af4CEAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/Af0CEwH/Ad4CcAH/AcICuwH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BzAKdAf8B6wJJAv8CDQL/Ag0C/wIN + Av8CDQH/Af0CEwH/AeMCYQH/AcYCrwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/Ad8CbQL/Ag0C/wINAf8B6AJSAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + /wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHP + ApQB/wH4AiIC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B9AIuAf8BywKg + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHJAqYB/wHoAlIC/wINAv8CDQL/Ag0C/wIN + Af8B/gIQAf8B5wJVAf8ByQKmAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wHMAp0C/wINAv8CDQH/AfwCFgH/AcICuwH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + Ad0CcwH/Af4CEAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + AfwCFgH/AdcCgQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BxwKsAf8B5wJVAf8B/gIQAv8CDQL/Ag0C/wIN + Av8CDQH/AeoCTAH/AckCpgH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B9gIoAv8CDQL/Ag0B/wHRAo4B/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BxQKy + Af8B7QJDAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/AecCVQH/AcMCuAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHGAq8B/wHjAmEB/wH9AhMC/wINAv8CDQL/Ag0C/wIN + Af8B6wJJAf8BzAKdAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AeMCYQL/Ag0C/wINAf8B5gJYAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8ByAKp + Af8B9QIrAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAf8B8AI6Af8BxQKyAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcQCtQH/Ad8CbQH/Af0CEwL/Ag0C/wINAv8CDQL/Ag0B/wHv + Aj0B/wHQApEB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHPApQC/wINAv8CDQH/AfkCHwH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BygKj + Af8B+QIfAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wH1AisB/wHGAq8B/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7Af8B3wJtAf8B+wIZAv8CDQL/Ag0C/wINAv8CDQH/AfMCMQH/ + AdACkQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AfoCHAL/Ag0C/wINAf8BzwKU + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BzwKU + Af8B+QIfAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfYCKAH/AcoCowH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wHCArsB/wHbAnkB/wH5Ah8C/wINAv8CDQL/Ag0C/wINAf8B8wIxAf8B1AKF + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHmAlgC/wINAv8CDQH/ + AeECZwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BzwKU + Af8B/AIWAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B+QIfAf8BygKjAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/AcECvgH/AdcCgQH/AfgCIgL/Ag0C/wINAv8CDQL/Ag0B/wH2AigB/wHXAoEB/wHB + Ar4B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHTAogC/wIN + Av8CDQH/AfYCKAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHK + AqMB/wH6AhwC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfUCKwH/ + AcYCrwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8B1gKBAf8B9gIoAv8CDQL/Ag0C/wINAv8CDQH/AfkCHwH/AdgCgQH/AcECvgH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7 + Af8B/AIWAv8CDQL/Ag0B/wHLAqAB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + AckCpgH/AfkCHwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0B/wH1AisB/wHEArUB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/AdQChQH/AfMCMQL/Ag0C/wINAv8CDQL/Ag0B/wH5Ah8B/wHbAnkB/wHCArsB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AekCTwL/Ag0C/wINAf8B3gJwAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + AcUCsgH/AfUCKwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/AfACOgH/AcICuwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7Af8B0gKLAf8B3wJtAf8B3wJtAf8B0AKR + Af8BwQK+Af8DwAH/A8AB/wPAAf8B0AKRAf8B8QI3Av8CDQL/Ag0C/wINAv8CDQH/AfsCGQH/Ad8CbQH/ + AcQCtQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHWAoEC/wINAv8CDQH/AfMCMQH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A + /wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wHtAkMC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AeUCWwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHSAosB/wH3AiUC/wINAv8CDQL/ + Ag0C/wINAf8B8wIxAf8BzgKXAf8BzgKXAf8B7wI9Av8CDQL/Ag0C/wINAv8CDQH/Af0CEwH/AeECZwH/ + AcQCtQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcMCuAH/Af0CEwL/Ag0C/wINAf8BxwKsAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHdAnMC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B1QKBAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHTAogC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDgL/Ag0C/wINAv8CDQL/Ag0B/wH9AhMB/wHjAmEB/wHGAq8B/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHuAkAC/wINAv8CDQH/AdsCeQH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wHPApQB/wH+AhAC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B/AIWAf8ByQKmAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7Af8B9wIlAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/Af4CEAH/AecCVQH/AckCpgH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B2AKBAv8CDQL/Ag0B/wHvAj0B/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wHEArUB/wH4AiIC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHzAjEB/wHB + Ar4B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdACkQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHtAkIB/wHJAqYB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BxgKvAv8CDQL/Ag0B/wH+AhAB/wHF + ArIB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/AeMCYQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B2wJ5 + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHaAnwC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B2QJ/Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B8AI6Av8CDQL/Ag0B/wHXAoEB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8BzAKdAf8B/gIQAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wH7AhkB/wHH + AqwB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B2gJ8Av8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AdkCfwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/Ad0CcwL/Ag0C/wINAf8B6wJJAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AfECNwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHpAk8B/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B0AKRAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AcoCowH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AckCpgL/Ag0C/wINAf8B/QITAf8BwwK4Af8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + /wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHX + AoEC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHQApEB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHCArsB/wH3AiUC/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQH/AfECNwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B9AIuAv8CDQL/Ag0B/wHUAoUB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8A + AgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B9gIo + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B7wI9Af8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdMCiAL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0B/wH+AhAB/wHLAqAB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AeACagL/Ag0C/wINAf8B6AJSAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIA + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdcCgQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B0AKRAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdMCiAH/AfcCJQL/Ag0C/wINAv8CDQL/ + Ag0B/wH0Ai4B/wHOApcB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHMAp0C/wINAv8CDQH/AfsCGQH/AcECvgH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIA + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B9gIoAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHvAj0B/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcICuwH/AdICiwH/AeECZwH/ + Ad0CcwH/AdACkQH/AcECvgH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B+AIiAv8CDQL/Ag0B/wHRAo4B/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A + /wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdcCgQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHQ + ApEB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHjAmEC/wINAv8CDQH/AeUCWwH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B8gI0Av8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AeoCTAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/AdACkQL/Ag0C/wINAf8B+AIiAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcsCoAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B/QITAf8BxQKyAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHBAr4B/wH6AhwC/wINAv8CDQH/Ac4ClwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/AeICZAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AdoCfAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AecCVQL/Ag0C/wINAf8B4AJqAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wHBAr4B/wH5Ah8C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHyAjQB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHU + AoUC/wINAv8CDQH/AfYCKAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B0gKL + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHKAqMB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcICuwH/AfwCFgL/ + Ag0C/wINAf8ByQKmAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AeMCYQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAf8B2wJ5Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B6wJJAv8CDQL/Ag0B/wHe + AnAB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8A + AgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B8wIxAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0B/wHrAkkB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHWAoEC/wINAv8CDQH/AfECNwH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcMCuAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfkCHwH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcQCtQH/Af4CEAL/Ag0C/wINAf8BxwKsAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wHSAosC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8BygKjAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8B7gJAAv8CDQL/Ag0B/wHaAnwB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/Ad8CbQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHXAoEB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHZAn8C/wINAv8CDQH/Ae4CQAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B6gJM + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AeECZwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + AccCrAL/Ag0C/wINAf8B/gIQAf8BxAK1Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AfMCMQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHrAkkB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B8QI3 + Av8CDQL/Ag0B/wHWAoEB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + /wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B/AIWAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/AfQCLgH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHeAnAC/wINAv8CDQH/ + AesCSQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AccCrAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Af8B/QITAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AckCpgL/Ag0C/wINAf8B/AIWAf8BwgK7 + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wHQApEC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHI + AqkB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B9gIoAv8CDQL/Ag0B/wHUAoUB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AdMCiAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/Ac4ClwH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHgAmoC/wINAv8CDQH/AecCVQH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B1wKB + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B0AKRAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/Ac4ClwL/Ag0C/wINAf8B+gIcAf8BwQK+Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdcCgQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AdcCgQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8B+AIiAv8CDQL/Ag0B/wHRAo4B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B3gJwAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAf8B2gJ8Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHk + Al4C/wINAv8CDQH/AeMCYQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIA + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHfAm0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0B/wHfAm0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdECjgL/Ag0C/wIN + Af8B+AIiAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/Ad0CcwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + AdoCfAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B+wIZAv8CDQL/Ag0B/wHM + Ap0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHXAoEC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHXAoEB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHoAlIC/wINAv8CDQH/AeACagH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + AdcCgQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AdACkQH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdQChQL/Ag0C/wINAf8B9AIuAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B0gKLAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8BzgKXAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8BwwK4Af8B/QITAv8CDQL/Ag0B/wHJAqYB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdACkQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AcgCqQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHrAkkC/wINAv8CDQH/Ad0CcwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A + /wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BxwKsAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0B/wH9AhMB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + AdcCgQL/Ag0C/wINAf8B8AI6Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B/AIWAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + AfQCLgH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BxQKyAf8B/gIQ + Av8CDQL/Ag0B/wHHAqwB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/AfMCMQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHrAkkB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHuAkAC/wINAv8CDQH/ + AdgCgQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8B6gJMAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AeECZwH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wHCArsB/wHSAosB/wHfAm0B/wHfAm0B/wHQApEB/wHBAr4B/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdsCeQL/Ag0C/wIN + Af8B7gJAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHfAm0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B1wKBAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8B0gKLAf8B9wIlAv8CDQL/Ag0C/wINAv8CDQH/AfMCMQH/Ac4ClwH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHHAqwC/wINAv8CDQH/ + Af0CEwH/AcMCuAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHSAosC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8BygKjAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHT + AogC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B/gIQAf8BywKgAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AfMCMQL/Ag0C/wIN + Af8B1gKBAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AcMCuAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfkCHwH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7Af8B9wIl + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHxAjcB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B3gJwAv8CDQL/Ag0B/wHp + Ak8B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AfMCMQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B6wJJAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHQApEC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B2gJ9Af8BywKgAf8BwQK+Af8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcsCoAL/Ag0C/wINAf8B/AIW + Af8BwgK7Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AeMCYQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B2wJ5Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHaAnwC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B9QIrAf8B6wJJAf8B4gJk + Af8B2AKBAf8BzgKXAf8BxQKyAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wH2AigC/wIN + Av8CDQH/AdMCiAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHSAosC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AcoCowH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B2gJ8Av8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/AfoCHAH/AfACOgH/AeUCWwH/AdwCdgH/AdMCiAH/AcoCowH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B4QJn + Av8CDQL/Ag0B/wHmAlgB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8BwQK+Af8B+QIfAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B8gI0Af8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B0AKR + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfACOwH/AfcCJQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wH9AhMB/wH0Ai4B/wHq + AkwB/wHhAmcB/wHWAoEB/wHNApoB/wHDArgB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8BzwKUAv8CDQL/Ag0B/wH6AhwB/wHBAr4B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B4gJkAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B2gJ8Af8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8BwgK4Af8B/QIUAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHxAjcB/wPA + Af8DwAH/AcICuwH/AcwCnQH/AdUCgQH/Ad8CbQH/AekCTwH/AfMCMQH/AfwCFgL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wH5Ah8B/wHuAkAB/wHkAl4B/wHb + AnkB/wHSAosB/wHHAqwB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AfgCIQL/Ag0C/wINAf8B5wJXAf8B0AKR + Af8BwQK+Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHL + AqAC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQH/Af0CEwH/AcUCsgH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B6gJMAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0B/wH+AhAB/wHLAqAB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wHIAqkB/wHSAosB/wHbAnkB/wHkAl4B/wHuAkAB/wH5Ah8C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B/AIWAf8B8wIxAf8B6QJPAf8B3wJtAf8B1QKC + Af8BzAKdAf8BwgK7Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8B0gKLAf8B/AIXAv8CDQL/Ag0C/wINAv8CDQH/AfMCMQH/Ac4ClwH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B8gI0Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AeoCTAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + AeQCXgL/Ag0C/wINAv8CDQH/AfsCGgL/Ag0C/wINAv8CDQL/Ag0B/wH0Ai4B/wHOApcB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BxAK1 + Af8BzQKaAf8B1gKBAf8B4QJnAf8B6gJMAf8B9AIuAf8B/gIQAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfcCJQH/Ae0CQwH/AeMCYQH/AdkCfwH/AdACkQH/ + AcYCrwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B0wKIAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + Af4CEAH/AcsCoAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHX + AoEC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAf8B0AKRAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHhAmcC/wINAv8CDQL/Ag0B/wHjAmEB/wHCArsB/wHQApEB/wHa + AnwB/wHZAn8B/wHOApcB/wHBAr4B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHK + AqMB/wHTAogB/wHcAnYB/wHlAlsB/wHxAjcB/wH6AhwC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B+wIZAf8B8gI0Af8B5wJVAf8B3QJzAf8B1QKBAf8B+AIh + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHxAjcB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B9gIoAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHvAj0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdsCeQL/Ag0C/wIN + Av8CDQH/AekCTwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHFArIB/wHOApcB/wHYAoEB/wHi + AmQB/wHsAkYB/wH1AisC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8BygKjAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdcCgQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B0AKRAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdcCgQL/Ag0C/wIN + Av8CDQH/AesCSQH/AcECvgH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHBAr4B/wHLAqAB/wHUAoUB/wHdAnMB/wHoAlIB/wHyAjQB/wH7AhkC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHZAn8B/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B9gIoAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B7wI9Af8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdUCggH/ + Af4CEAL/Ag0C/wINAf8B8AI6Af8BwwK4Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BxgKvAf8B0AKR + Af8B2gJ8Af8B4wJhAf8B9QItAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + AdkCfwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A + /wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B1wKB + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B0AKRAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BzwKU + Af8B/QITAv8CDQL/Ag0B/wHzAjEB/wHDArgB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/AdACkQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHK + AqMB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8A + AgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHx + AjcC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B6QJPAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BzQKaAf8B/AIW + Av8CDQL/Ag0B/wH1AisB/wHGAq8B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHCArsB/wH3AiUC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfECNwH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8A + AgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHM + Ap0B/wH+AhAC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfsCGQH/AccCrAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BygKjAf8B+QIf + Av8CDQL/Ag0B/wH5Ah8B/wHIAqkB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/AdMCiAL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wH+AhAB/wHL + AqAB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + /wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AeMCYQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B2wJ5Af8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHGAq8B/wH4AiIC/wIN + Av8CDQH/AfoCHAH/AcoCowH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHTAogB/wH3AiUC/wINAv8CDQL/Ag0C/wINAf8B9AIuAf8BzgKX + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8BxAK1Af8B+AIiAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B8wIxAf8BwQK+Af8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcYCrwH/AfUCKwL/ + Ag0C/wINAf8B/AIWAf8BzwKUAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwgK7Af8B0AKRAf8B2gJ8Af8B2QJ/Af8BzgKX + Af8BwQK+Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AC/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHPApQB/wH+AhAC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B/AIWAf8ByQKm + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcMCuAH/ + AfECNwL/Ag0C/wINAf8B/gIQAf8B0QKOAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/Ad0CcwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHVAoEB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B8AI6Av8CDQL/ + Ag0B/wH+AhAB/wHVAoIB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHtAkMC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AeUCWwH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHBAr4B/wHqAkwC/wINAv8CDQL/Ag0B/wHZ + An8B/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8A + AgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8BxQKyAf8B9QIrAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B8AI6Af8BwgK7Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AeYCWAL/Ag0C/wINAv8CDQH/AdwCdgH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/AckCpgH/AfkCHwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0B/wH1AisB/wHEArUB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8B4wJhAv8CDQL/Ag0C/wINAf8B4wJhAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHKAqMB/wH6AhwC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQH/AfUCKwH/AcYCrwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHbAnkC/wINAv8CDQL/Ag0B/wHnAlUB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8BzwKUAf8B/AIWAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B+QIf + Af8BygKjAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + AdkCfwL/Ag0C/wINAv8CDQH/AeoCTAH/AcECvgH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8BzwKUAf8B+gIcAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfcCJQH/AcoCowH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHVAoIB/wH+ + AhAC/wINAv8CDQH/AfACOgH/AcICuwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wHKAqMB/wH5Ah8C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfUCKwH/AcYCrwH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHQApEB/wH+AhAC/wIN + Av8CDQH/AfECNwH/AcMCuAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/AckCpgH/AfUCKwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfACOgH/AcYCrwH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHPApQB/wH8AhYC/wINAv8CDQH/ + AfUCKwH/AcYCrwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8BxQKyAf8B7QJDAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AecCVQH/AcMCuAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHKAqMB/wH5Ah8C/wINAv8CDQH/AfkCHwH/ + AcYCrwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8B3QJzAf8B/gIQAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAf8B/AIWAf8B1wKBAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHIAqkB/wH5Ah8C/wINAv8CDQH/AfkCHwH/AcoCowH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHPApQB/wH4AiIC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAf8B9AIuAf8BywKgAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wHGAq8B/wH1AisC/wINAv8CDQH/AfwCFgH/Ac4ClwH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcQCtQH/AeMCYQH/Af4CEAL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQH/Af0CEwH/Ad4CcAH/AcICuwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8BwwK4Af8B8wIxAv8CDQL/Ag0B/wH9AhMB/wHPApQB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHMAp0B/wHxAjcC/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Af8B7QJDAf8ByAKpAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8BwwK4Af8B8AI6Av8CDQL/Ag0B/wH+AhAB/wHVAoIB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHXAoEB/wH2AigC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHzAjEB/wHT + AogB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcICuwH/AdICiwH/ + Ad8CbQH/Ad8CbQH/AdACkQH/AcECuwH/AeoCTAL/Ag0C/wINAv8CDQH/AdcCgQH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwQK+Af8B1wKB + Af8B9gIoAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHzAjEB/wHU + AoUB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHSAosB/wH3 + AiUC/wINAv8CDQL/Ag0C/wINAf8B+wIaAv8CDQL/Ag0C/wINAf8B2wJ5Af8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHB + Ar4B/wHXAoEB/wHyAjQC/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B7wI9Af8B1AKFAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdMCiAL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AeICZAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AcsCoAH/AeICZAH/AfkCHwL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wH3AiUB/wHfAm0B/wHIAqkB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AcICuwH/AfcCJQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8B+QIeAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8BwQK+Af8B0gKLAf8B4wJhAf8B8wIxAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQL/Ag0C/wINAf8B/gIQAf8B8QI3Af8B4QJnAf8B0AKRAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHQApEC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAf8BygKjAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf//AP8AAgADwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8BwwK4Af8B0gKLAf8B3wJtAf8B6gJMAf8B8wIx + Af8B/AIWAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/ + AfsCGQH/AfICNAH/AekCTwH/Ad0CcwH/AdACkQH/AcICuwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B2gJ8 + Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AdkCfwH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/AccCrAH/AdACkQH/AdMCiAH/AdcCgQH/AdcCgQH/Ad4CcAH/Ad8CbQH/AdwCdgH/AdcCgQH/ + AdcCgQH/AdECjgH/Ac8ClAH/AcYCrwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8B2gJ8Av8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AdkCfwH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdACkQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQL/Ag0B/wHKAqMB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wHCArsB/wH3AiUC/wINAv8CDQL/ + Ag0C/wINAv8CDQL/Ag0C/wINAv8CDQH/AfECNwH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8B0wKIAv8CDQL/Ag0C/wINAv8CDQL/Ag0C/wIN + Av8CDQH/Af4CEAH/AcsCoAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB//8A/wACAAPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/AdMCiAH/AfcCJQL/Ag0C/wINAv8CDQL/Ag0B/wH0Ai4B/wHO + ApcB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + /wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/AcICuwH/AdACkQH/AdoCfAH/AdkCfwH/Ac4ClwH/AcECvgH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIA + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + /wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPA + Af8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH//wD/AAIAA8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/A8AB/wPAAf8DwAH/ + A8AB/wPAAf8DwAH//wD/AAIAAUIBTQE+BwABPgMAASgEAAECAgABgAMAAQEBAAEBBgABIBYAA///AP8A + /wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A/wD/AP8A + IQAL + + + + 474, 58 + + + 585, 58 + + + 807, 58 + + + 17, 95 + + + 227, 58 + + + 333, 21 + + + 89 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/QuickGuide.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/QuickGuide.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,117 @@ +namespace GLEED2D +{ + partial class QuickGuide + { + /// + /// 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(QuickGuide)); + this.label1 = new System.Windows.Forms.Label(); + this.label2 = new System.Windows.Forms.Label(); + this.label3 = new System.Windows.Forms.Label(); + this.button1 = new System.Windows.Forms.Button(); + this.label4 = new System.Windows.Forms.Label(); + this.SuspendLayout(); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(12, 9); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(139, 260); + this.label1.TabIndex = 0; + this.label1.Text = resources.GetString("label1.Text"); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.BackColor = System.Drawing.Color.Transparent; + this.label2.Location = new System.Drawing.Point(171, 9); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(164, 260); + this.label2.TabIndex = 1; + this.label2.Text = resources.GetString("label2.Text"); + // + // label3 + // + this.label3.AutoSize = true; + this.label3.Location = new System.Drawing.Point(374, 9); + this.label3.Name = "label3"; + this.label3.Size = new System.Drawing.Size(167, 195); + this.label3.TabIndex = 1; + this.label3.Text = "KEYBOARD\r\n\r\n\r\nW, A, S, D\r\nW, A, S, D + LeftShift\r\nF4\r\nKeys \"NUMPAD+\" / \"NUMPAD-\"\r" + + "\n\r\n\r\n1\r\n2\r\n3\r\nLeftControl + move item\r\nH\r\nV"; + // + // button1 + // + this.button1.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.button1.Location = new System.Drawing.Point(297, 369); + this.button1.Name = "button1"; + this.button1.Size = new System.Drawing.Size(75, 23); + this.button1.TabIndex = 2; + this.button1.Text = "Close"; + this.button1.UseVisualStyleBackColor = true; + this.button1.Click += new System.EventHandler(this.button1_Click); + // + // label4 + // + this.label4.AutoSize = true; + this.label4.Location = new System.Drawing.Point(12, 307); + this.label4.Name = "label4"; + this.label4.Size = new System.Drawing.Size(613, 26); + this.label4.TabIndex = 1; + this.label4.Text = "* holding down LeftControl snaps rotation to multiples of 45°\r\n** holding down Le" + + "ftControl snaps scale factor to multiples of 0.1, holding down [X] or [Y] limits" + + " scaling to the according dimension"; + // + // QuickGuide + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.button1; + this.ClientSize = new System.Drawing.Size(668, 402); + this.Controls.Add(this.button1); + this.Controls.Add(this.label4); + this.Controls.Add(this.label3); + this.Controls.Add(this.label2); + this.Controls.Add(this.label1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.Name = "QuickGuide"; + this.Text = "GLEED2D QuickGuide"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Label label2; + private System.Windows.Forms.Label label3; + private System.Windows.Forms.Button button1; + private System.Windows.Forms.Label label4; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/QuickGuide.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/QuickGuide.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class QuickGuide : Form + { + public QuickGuide() + { + InitializeComponent(); + } + + private void button1_Click(object sender, EventArgs e) + { + Close(); + } + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/QuickGuide.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/QuickGuide.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,164 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + +CAMERA +move +move fast +center view at selected item +zoom + +ITEMS +move +rotate* +scale** +copy +flip horizontally +flip vertically + +SELECTION +select item +add item to selection +select multiple items + + + MOUSE + + +LeftControl + MiddleMouseButton + + +MouseWheel + + +LeftMouseButton +MiddleMouseButton +RightMouseButton +LeftControl + move item + + + + +click on item +LeftShift + click on item +LeftClick + Drag (Windows style) + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/SettingsForm.Designer.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/SettingsForm.Designer.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,293 @@ +namespace GLEED2D +{ + partial class SettingsForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + this.propertyGrid1 = new System.Windows.Forms.PropertyGrid(); + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonOK = new System.Windows.Forms.Button(); + this.tabControl1 = new System.Windows.Forms.TabControl(); + this.tabPage1 = new System.Windows.Forms.TabPage(); + this.tabPage2 = new System.Windows.Forms.TabPage(); + this.buttonBrowse = new System.Windows.Forms.Button(); + this.textBox1 = new System.Windows.Forms.TextBox(); + this.checkBox2 = new System.Windows.Forms.CheckBox(); + this.checkBox1 = new System.Windows.Forms.CheckBox(); + this.label1 = new System.Windows.Forms.Label(); + this.tabPage3 = new System.Windows.Forms.TabPage(); + this.button1 = new System.Windows.Forms.Button(); + this.textBox2 = new System.Windows.Forms.TextBox(); + this.checkBox3 = new System.Windows.Forms.CheckBox(); + this.checkBox4 = new System.Windows.Forms.CheckBox(); + this.label2 = new System.Windows.Forms.Label(); + this.tabControl1.SuspendLayout(); + this.tabPage1.SuspendLayout(); + this.tabPage2.SuspendLayout(); + this.tabPage3.SuspendLayout(); + this.SuspendLayout(); + // + // propertyGrid1 + // + this.propertyGrid1.Dock = System.Windows.Forms.DockStyle.Fill; + this.propertyGrid1.Location = new System.Drawing.Point(3, 3); + this.propertyGrid1.Name = "propertyGrid1"; + this.propertyGrid1.Size = new System.Drawing.Size(567, 451); + this.propertyGrid1.TabIndex = 0; + this.propertyGrid1.ToolbarVisible = false; + // + // buttonCancel + // + this.buttonCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel; + this.buttonCancel.Location = new System.Drawing.Point(518, 501); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(75, 23); + this.buttonCancel.TabIndex = 3; + this.buttonCancel.Text = "Cancel"; + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.buttonCancel_Click); + // + // buttonOK + // + this.buttonOK.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonOK.DialogResult = System.Windows.Forms.DialogResult.OK; + this.buttonOK.Location = new System.Drawing.Point(437, 501); + this.buttonOK.Name = "buttonOK"; + this.buttonOK.Size = new System.Drawing.Size(75, 23); + this.buttonOK.TabIndex = 2; + this.buttonOK.Text = "Apply"; + this.buttonOK.UseVisualStyleBackColor = true; + this.buttonOK.Click += new System.EventHandler(this.buttonOK_Click); + // + // tabControl1 + // + this.tabControl1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.tabControl1.Controls.Add(this.tabPage1); + this.tabControl1.Controls.Add(this.tabPage2); + this.tabControl1.Controls.Add(this.tabPage3); + this.tabControl1.Location = new System.Drawing.Point(12, 12); + this.tabControl1.Name = "tabControl1"; + this.tabControl1.SelectedIndex = 0; + this.tabControl1.Size = new System.Drawing.Size(581, 483); + this.tabControl1.TabIndex = 1; + // + // tabPage1 + // + this.tabPage1.Controls.Add(this.propertyGrid1); + this.tabPage1.Location = new System.Drawing.Point(4, 22); + this.tabPage1.Name = "tabPage1"; + this.tabPage1.Padding = new System.Windows.Forms.Padding(3); + this.tabPage1.Size = new System.Drawing.Size(573, 457); + this.tabPage1.TabIndex = 0; + this.tabPage1.Text = "General"; + this.tabPage1.UseVisualStyleBackColor = true; + // + // tabPage2 + // + this.tabPage2.BackColor = System.Drawing.Color.Transparent; + this.tabPage2.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None; + this.tabPage2.Controls.Add(this.buttonBrowse); + this.tabPage2.Controls.Add(this.textBox1); + this.tabPage2.Controls.Add(this.checkBox2); + this.tabPage2.Controls.Add(this.checkBox1); + this.tabPage2.Controls.Add(this.label1); + this.tabPage2.Location = new System.Drawing.Point(4, 22); + this.tabPage2.Name = "tabPage2"; + this.tabPage2.Padding = new System.Windows.Forms.Padding(3); + this.tabPage2.Size = new System.Drawing.Size(573, 457); + this.tabPage2.TabIndex = 1; + this.tabPage2.Text = "Run Level"; + this.tabPage2.UseVisualStyleBackColor = true; + // + // buttonBrowse + // + this.buttonBrowse.Enabled = false; + this.buttonBrowse.Location = new System.Drawing.Point(506, 80); + this.buttonBrowse.Name = "buttonBrowse"; + this.buttonBrowse.Size = new System.Drawing.Size(61, 23); + this.buttonBrowse.TabIndex = 3; + this.buttonBrowse.Text = "Browse..."; + this.buttonBrowse.UseVisualStyleBackColor = true; + this.buttonBrowse.Click += new System.EventHandler(this.buttonBrowse_Click); + // + // textBox1 + // + this.textBox1.Enabled = false; + this.textBox1.Location = new System.Drawing.Point(30, 83); + this.textBox1.Name = "textBox1"; + this.textBox1.Size = new System.Drawing.Size(470, 20); + this.textBox1.TabIndex = 2; + // + // checkBox2 + // + this.checkBox2.AutoSize = true; + this.checkBox2.Enabled = false; + this.checkBox2.Location = new System.Drawing.Point(30, 109); + this.checkBox2.Name = "checkBox2"; + this.checkBox2.Size = new System.Drawing.Size(332, 17); + this.checkBox2.TabIndex = 1; + this.checkBox2.Text = "append the full path of the level file as a command line parameter"; + this.checkBox2.UseVisualStyleBackColor = true; + this.checkBox2.CheckedChanged += new System.EventHandler(this.checkBox2_CheckedChanged); + // + // checkBox1 + // + this.checkBox1.AutoSize = true; + this.checkBox1.Location = new System.Drawing.Point(10, 60); + this.checkBox1.Name = "checkBox1"; + this.checkBox1.Size = new System.Drawing.Size(255, 17); + this.checkBox1.TabIndex = 1; + this.checkBox1.Text = "save the level and start the following application:"; + this.checkBox1.UseVisualStyleBackColor = true; + this.checkBox1.CheckedChanged += new System.EventHandler(this.checkBox1_CheckedChanged); + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(7, 25); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(158, 13); + this.label1.TabIndex = 0; + this.label1.Text = "When clicking on \"Run Level\", "; + // + // tabPage3 + // + this.tabPage3.Controls.Add(this.button1); + this.tabPage3.Controls.Add(this.textBox2); + this.tabPage3.Controls.Add(this.checkBox3); + this.tabPage3.Controls.Add(this.checkBox4); + this.tabPage3.Controls.Add(this.label2); + this.tabPage3.Location = new System.Drawing.Point(4, 22); + this.tabPage3.Name = "tabPage3"; + this.tabPage3.Padding = new System.Windows.Forms.Padding(3); + this.tabPage3.Size = new System.Drawing.Size(573, 457); + this.tabPage3.TabIndex = 2; + this.tabPage3.Text = "Save Level"; + this.tabPage3.UseVisualStyleBackColor = true; + // + // button1 + // + this.button1.Enabled = false; + this.button1.Location = new System.Drawing.Point(505, 79); + this.button1.Name = "button1"; + this.button1.Size = new System.Drawing.Size(61, 23); + this.button1.TabIndex = 8; + this.button1.Text = "Browse..."; + this.button1.UseVisualStyleBackColor = true; + this.button1.Click += new System.EventHandler(this.button1_Click); + // + // textBox2 + // + this.textBox2.Enabled = false; + this.textBox2.Location = new System.Drawing.Point(29, 82); + this.textBox2.Name = "textBox2"; + this.textBox2.Size = new System.Drawing.Size(470, 20); + this.textBox2.TabIndex = 7; + // + // checkBox3 + // + this.checkBox3.AutoSize = true; + this.checkBox3.Enabled = false; + this.checkBox3.Location = new System.Drawing.Point(29, 108); + this.checkBox3.Name = "checkBox3"; + this.checkBox3.Size = new System.Drawing.Size(332, 17); + this.checkBox3.TabIndex = 6; + this.checkBox3.Text = "append the full path of the level file as a command line parameter"; + this.checkBox3.UseVisualStyleBackColor = true; + this.checkBox3.CheckedChanged += new System.EventHandler(this.checkBox3_CheckedChanged); + // + // checkBox4 + // + this.checkBox4.AutoSize = true; + this.checkBox4.Location = new System.Drawing.Point(9, 59); + this.checkBox4.Name = "checkBox4"; + this.checkBox4.Size = new System.Drawing.Size(165, 17); + this.checkBox4.TabIndex = 5; + this.checkBox4.Text = "start the following application:"; + this.checkBox4.UseVisualStyleBackColor = true; + this.checkBox4.CheckedChanged += new System.EventHandler(this.checkBox4_CheckedChanged); + // + // label2 + // + this.label2.AutoSize = true; + this.label2.Location = new System.Drawing.Point(6, 24); + this.label2.Name = "label2"; + this.label2.Size = new System.Drawing.Size(145, 13); + this.label2.TabIndex = 4; + this.label2.Text = "Each time the level is saved, "; + // + // SettingsForm + // + this.AcceptButton = this.buttonOK; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.CancelButton = this.buttonCancel; + this.ClientSize = new System.Drawing.Size(605, 536); + this.ControlBox = false; + this.Controls.Add(this.tabControl1); + this.Controls.Add(this.buttonOK); + this.Controls.Add(this.buttonCancel); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Name = "SettingsForm"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "Settings"; + this.Load += new System.EventHandler(this.SettingsForm_Load); + this.tabControl1.ResumeLayout(false); + this.tabPage1.ResumeLayout(false); + this.tabPage2.ResumeLayout(false); + this.tabPage2.PerformLayout(); + this.tabPage3.ResumeLayout(false); + this.tabPage3.PerformLayout(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.PropertyGrid propertyGrid1; + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonOK; + private System.Windows.Forms.TabControl tabControl1; + private System.Windows.Forms.TabPage tabPage1; + private System.Windows.Forms.TabPage tabPage2; + private System.Windows.Forms.TextBox textBox1; + private System.Windows.Forms.CheckBox checkBox2; + private System.Windows.Forms.CheckBox checkBox1; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.Button buttonBrowse; + private System.Windows.Forms.TabPage tabPage3; + private System.Windows.Forms.Button button1; + private System.Windows.Forms.TextBox textBox2; + private System.Windows.Forms.CheckBox checkBox3; + private System.Windows.Forms.CheckBox checkBox4; + private System.Windows.Forms.Label label2; + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/SettingsForm.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/SettingsForm.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,97 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class SettingsForm : Form + { + public SettingsForm() + { + InitializeComponent(); + } + + private void SettingsForm_Load(object sender, EventArgs e) + { + Constants.Instance.export("settings.xml"); + propertyGrid1.SelectedObject = Constants.Instance; + + //Run Level tab + checkBox1.Checked = Constants.Instance.RunLevelStartApplication; + textBox1.Text = Constants.Instance.RunLevelApplicationToStart; + checkBox2.Checked = Constants.Instance.RunLevelAppendLevelFilename; + + //Save Level tab + checkBox4.Checked = Constants.Instance.SaveLevelStartApplication; + textBox2.Text = Constants.Instance.SaveLevelApplicationToStart; + checkBox3.Checked = Constants.Instance.SaveLevelAppendLevelFilename; + + + } + + private void buttonOK_Click(object sender, EventArgs e) + { + Constants.Instance.RunLevelApplicationToStart = textBox1.Text; + Constants.Instance.SaveLevelApplicationToStart = textBox2.Text; + Constants.Instance.export("settings.xml"); + Close(); + } + + private void buttonCancel_Click(object sender, EventArgs e) + { + Constants.Instance.import("settings.xml"); + Close(); + } + + + //Run Level tab + private void checkBox1_CheckedChanged(object sender, EventArgs e) + { + textBox1.Enabled = buttonBrowse.Enabled = checkBox2.Enabled = checkBox1.Checked; + Constants.Instance.RunLevelStartApplication = checkBox1.Checked; + } + private void checkBox2_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.RunLevelAppendLevelFilename = checkBox2.Checked; + } + private void buttonBrowse_Click(object sender, EventArgs e) + { + OpenFileDialog f = new OpenFileDialog(); + f.FileName = textBox1.Text; + f.Filter = "Executable Files (*.exe, *.bat)|*.exe;*.bat"; + if (f.ShowDialog() == DialogResult.OK) + { + textBox1.Text = f.FileName; + } + } + + + //Save Level tab + private void checkBox4_CheckedChanged(object sender, EventArgs e) + { + textBox2.Enabled = button1.Enabled = checkBox3.Enabled = checkBox4.Checked; + Constants.Instance.SaveLevelStartApplication = checkBox4.Checked; + } + private void checkBox3_CheckedChanged(object sender, EventArgs e) + { + Constants.Instance.SaveLevelAppendLevelFilename = checkBox3.Checked; + } + private void button1_Click(object sender, EventArgs e) + { + OpenFileDialog f = new OpenFileDialog(); + f.FileName = textBox2.Text; + f.Filter = "Executable Files (*.exe, *.bat)|*.exe;*.bat"; + if (f.ShowDialog() == DialogResult.OK) + { + textBox2.Text = f.FileName; + } + } + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Forms/SettingsForm.resx --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Forms/SettingsForm.resx Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Game1.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Game1.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,155 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Forms = System.Windows.Forms; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Audio; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.GamerServices; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Media; +using Microsoft.Xna.Framework.Net; +using Microsoft.Xna.Framework.Storage; + +namespace GLEED2D +{ + /// + /// This is the main type for your game + /// + public class Game1 : Microsoft.Xna.Framework.Game + { + GraphicsDeviceManager graphics; + public SpriteBatch spriteBatch; + GamePadState gamepadstate, oldgamepadstate; + KeyboardState keyboardstate, oldkeyboardstate; + public Forms.Form winform; + private IntPtr drawSurface; + + + public static Game1 Instance; + + public Game1(IntPtr drawSurface) + { + Logger.Instance.log("Game1 creation started."); + + Instance = this; + + graphics = new GraphicsDeviceManager(this); + graphics.PreferredBackBufferWidth = 800; + graphics.PreferredBackBufferHeight = 600; + + Content.RootDirectory = "Content"; + + Logger.Instance.log("Creating Winform."); + this.drawSurface = drawSurface; + graphics.PreparingDeviceSettings += new EventHandler(graphics_PreparingDeviceSettings); + winform = (Forms.Form)Forms.Form.FromHandle(Window.Handle); + winform.VisibleChanged += new EventHandler(Game1_VisibleChanged); + winform.Size = new System.Drawing.Size(10, 10); + Mouse.WindowHandle = drawSurface; + resizebackbuffer(MainForm.Instance.pictureBox1.Width, MainForm.Instance.pictureBox1.Height); + winform.Hide(); + Logger.Instance.log("Winform created."); + + Logger.Instance.log("Game1 creation ended."); + } + + void graphics_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs e) + { + e.GraphicsDeviceInformation.PresentationParameters.DeviceWindowHandle = drawSurface; + } + private void Game1_VisibleChanged(object sender, EventArgs e) + { + winform.Hide(); + winform.Size = new System.Drawing.Size(10, 10); + winform.Visible = false; + } + + + /// + /// Allows the game to perform any initialization it needs to before starting to run. + /// This is where it can query for any required services and load any non-graphic + /// related content. Calling base.Initialize will enumerate through any components + /// and initialize them as well. + /// + protected override void Initialize() + { + Logger.Instance.log("Creating Editor object."); + + new Editor(); + + base.Initialize(); + } + + /// + /// LoadContent will be called once per game and is the place to load + /// all of your content. + /// + protected override void LoadContent() + { + // Create a new SpriteBatch, which can be used to draw textures. + spriteBatch = new SpriteBatch(GraphicsDevice); + } + + public void resizebackbuffer(int width, int height) + { + graphics.PreferredBackBufferWidth = width; + graphics.PreferredBackBufferHeight = height; + graphics.ApplyChanges(); + } + + + /// + /// UnloadContent will be called once per game and is the place to unload + /// all content. + /// + protected override void UnloadContent() + { + + } + + /// + /// Allows the game to run logic such as updating the world, + /// checking for collisions, gathering input, and playing audio. + /// + /// Provides a snapshot of timing values. + protected override void Update(GameTime gameTime) + { + if (!MainForm.Instance.pictureBox1.ContainsFocus) return; + + gamepadstate = GamePad.GetState(PlayerIndex.One); + if (gamepadstate.IsConnected) + { + if (gamepadstate.Buttons.Back == ButtonState.Pressed) this.Exit(); + + } + keyboardstate = Keyboard.GetState(); + + + Editor.Instance.update(gameTime); + + oldgamepadstate = gamepadstate; + oldkeyboardstate = keyboardstate; + base.Update(gameTime); + } + + + /// + /// This is called when the game should draw itself. + /// + /// Provides a snapshot of timing values. + protected override void Draw(GameTime gameTime) + { + float fps = 1 / (float)gameTime.ElapsedGameTime.TotalSeconds; + MainForm.Instance.toolStripStatusLabel4.Text = "FPS: " + fps.ToString("#0.00"); + + + Editor.Instance.draw(spriteBatch); + + base.Draw(gameTime); + + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/IUndoable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/IUndoable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,12 @@ +using System; +namespace GLEED2D +{ + public interface IUndoable + { + + IUndoable cloneforundo(); + + void makelike(IUndoable other); + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Item.Editable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Item.Editable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,134 @@ +using System.ComponentModel; +using System.Drawing.Design; +using System.Xml.Serialization; +using CustomUITypeEditors; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using Forms = System.Windows.Forms; +using System.Windows.Forms; + +namespace GLEED2D +{ + public class ItemTypeConverter : TypeConverter + { + public override bool CanConvertTo(ITypeDescriptorContext context, System.Type destinationType) + { + if (destinationType == typeof(Item)) return true; + + return base.CanConvertTo(context, destinationType); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, System.Type destinationType) + { + if (destinationType == typeof(string) && value is Item) + { + Item result = (Item)value; + return result.Name; + } + return base.ConvertTo(context, culture, value, destinationType); + } + + } + + [TypeConverter(typeof(ItemTypeConverter))] + public abstract partial class Item + { + [XmlIgnore()] + public Layer layer; + + protected bool hovering; + + [XmlIgnore()] + [DisplayName("Position"), Category(" General")] + [Description("The item's position in world space.")] + public Vector2 pPosition + { + get + { + return Position; + } + set + { + Position = value; + OnTransformed(); + } + } + + public virtual string getNamePrefix() + { + return "Item_"; + } + + public virtual void OnTransformed() + { + } + + public abstract Item clone(); + + public virtual bool loadIntoEditor() + { + OnTransformed(); + return true; + } + + public abstract void drawInEditor(SpriteBatch sb); + + public abstract void drawSelectionFrame(SpriteBatch sb, Matrix matrix, Color color); + + public virtual void onMouseOver(Vector2 mouseworldpos) + { + hovering = true; + } + + public virtual void onMouseOut() + { + hovering = false; + MainForm.Instance.pictureBox1.Cursor = Cursors.Default; + } + + public virtual void onMouseButtonDown(Vector2 mouseworldpos) + { + } + + public virtual void onMouseButtonUp(Vector2 mouseworldpos) + { + } + + + + public virtual void setPosition(Vector2 pos) + { + pPosition = pos; + } + + public virtual bool CanRotate() + { + return false; + } + public virtual float getRotation() + { + return 0; + } + public virtual void setRotation(float rotation) + { + } + + public virtual bool CanScale() + { + return false; + } + public virtual Vector2 getScale() + { + return Vector2.One; + } + public virtual void setScale(Vector2 scale) + { + } + + + public abstract bool contains(Vector2 worldpos); + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Item.ICustomTypeDescriptor.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Item.ICustomTypeDescriptor.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,94 @@ +using System; +using System.ComponentModel; +using CustomUITypeEditors; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace GLEED2D +{ + + public partial class Item : ICustomTypeDescriptor + { + + AttributeCollection ICustomTypeDescriptor.GetAttributes() + { + return TypeDescriptor.GetAttributes(this, true); + } + + string ICustomTypeDescriptor.GetClassName() + { + return TypeDescriptor.GetClassName(this, true); + } + + string ICustomTypeDescriptor.GetComponentName() + { + return TypeDescriptor.GetComponentName(this, true); + } + + TypeConverter ICustomTypeDescriptor.GetConverter() + { + return TypeDescriptor.GetConverter(this, true); + } + + EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() + { + return TypeDescriptor.GetDefaultEvent(this, true); + } + + PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() + { + return TypeDescriptor.GetDefaultProperty(this, true); + } + + object ICustomTypeDescriptor.GetEditor(Type editorBaseType) + { + return TypeDescriptor.GetEditor(this, editorBaseType, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) + { + return TypeDescriptor.GetEvents(this, attributes, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents() + { + return TypeDescriptor.GetEvents(this, true); + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) + { + PropertyDescriptorCollection pdc = new PropertyDescriptorCollection(new PropertyDescriptor[0]); + foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(this)) + { + pdc.Add(pd); + } + + //put Position property on top + PropertyDescriptor posd = pdc["pPosition"]; + pdc.Remove(posd); + pdc.Insert(0, posd); + + foreach (String key in CustomProperties.Keys) + { + pdc.Add(new DictionaryPropertyDescriptor(CustomProperties, key, attributes)); + } + return pdc; + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() + { + return TypeDescriptor.GetProperties(this, true); + } + + object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) + { + return this; + } + + } + + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Items/CircleItem.Editable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Items/CircleItem.Editable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,113 @@ +using System.ComponentModel; +using System.Drawing.Design; +using System.Xml.Serialization; +using CustomUITypeEditors; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using System; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class CircleItem + { + + [DisplayName("Radius"), Category(" General")] + [XmlIgnore()] + public float pRadius { get { return Radius; } set { Radius = value; } } + + [DisplayName("FillColor"), Category(" General")] + [Editor(typeof(XNAColorUITypeEditor), typeof(UITypeEditor))] + [XmlIgnore()] + public Color pFillColor { get { return FillColor; } set { FillColor = value; } } + + + public CircleItem(Vector2 startpos, float radius) + : base() + { + this.Position = startpos; + this.Radius = radius; + this.FillColor = Constants.Instance.ColorPrimitives; + } + + public override Item clone() + { + CircleItem result = (CircleItem)this.MemberwiseClone(); + result.CustomProperties = new SerializableDictionary(CustomProperties); + result.hovering = false; + return result; + } + + public override string getNamePrefix() + { + return "Circle_"; + } + + public override bool contains(Vector2 worldpos) + { + return (worldpos - Position).Length() <= Radius; + } + + + public override void OnTransformed() + { + } + + + public override void onMouseButtonDown(Vector2 mouseworldpos) + { + hovering = false; + MainForm.Instance.pictureBox1.Cursor = Cursors.SizeAll; + base.onMouseButtonDown(mouseworldpos); + } + + + public override bool CanScale() + { + return true; + } + + public override Vector2 getScale() + { + return new Vector2(pRadius, pRadius); + } + + public override void setScale(Vector2 scale) + { + pRadius = (float)Math.Round(scale.X); + } + + public override void drawInEditor(SpriteBatch sb) + { + if (!Visible) return; + Color c = FillColor; + if (hovering && Constants.Instance.EnableHighlightOnMouseOver) c = Constants.Instance.ColorHighlight; + Primitives.Instance.drawCircleFilled(sb, Position, Radius, c); + } + + + public override void drawSelectionFrame(SpriteBatch sb, Matrix matrix, Color color) + { + + Vector2 transformedPosition = Vector2.Transform(Position, matrix); + Vector2 transformedRadius = Vector2.TransformNormal(Vector2.UnitX * Radius, matrix); + Primitives.Instance.drawCircle(sb, transformedPosition, transformedRadius.Length(), color, 2); + + Vector2[] extents = new Vector2[4]; + extents[0] = transformedPosition + Vector2.UnitX * transformedRadius.Length(); + extents[1] = transformedPosition + Vector2.UnitY * transformedRadius.Length(); + extents[2] = transformedPosition - Vector2.UnitX * transformedRadius.Length(); + extents[3] = transformedPosition - Vector2.UnitY * transformedRadius.Length(); + + foreach (Vector2 p in extents) + { + Primitives.Instance.drawCircleFilled(sb, p, 4, color); + } + + Vector2 origin = Vector2.Transform(pPosition, matrix); + Primitives.Instance.drawBoxFilled(sb, origin.X - 5, origin.Y - 5, 10, 10, color); + + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Items/PathItem.Editable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Items/PathItem.Editable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,226 @@ +using System.ComponentModel; +using System.Drawing.Design; +using System.Xml.Serialization; +using CustomUITypeEditors; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using System.Windows.Forms; +using System; + +namespace GLEED2D +{ + public partial class PathItem + { + [DisplayName("IsPolygon"), Category(" General")] + [Description("If true, the Path will be drawn as a polygon (last and first point will be connected).")] + [XmlIgnore()] + public bool pIsPolygon { get { return IsPolygon; } set { IsPolygon = value; } } + + [DisplayName("LineWidth"), Category(" General")] + [Description("The line width of this path. Can be used for rendering.")] + [XmlIgnore()] + public int pLineWidth { get { return LineWidth; } set { LineWidth = value; } } + + [DisplayName("LineColor"), Category(" General")] + [Description("The line color of this path. Can be used for rendering.")] + [Editor(typeof(XNAColorUITypeEditor), typeof(UITypeEditor))] + [XmlIgnore()] + public Color pLineColor { get { return LineColor; } set { LineColor = value; } } + + + + int pointundermouse = -1; + int pointgrabbed = -1; + Vector2 initialpos; + + public PathItem(Vector2[] points) + : base() + { + Position = points[0]; + WorldPoints = points; + LocalPoints = (Vector2[])points.Clone(); + for (int i = 0; i < LocalPoints.Length; i++) LocalPoints[i] -= Position; + LineWidth = Constants.Instance.DefaultPathItemLineWidth; + LineColor = Constants.Instance.ColorPrimitives; + } + + public override Item clone() + { + PathItem result = (PathItem)this.MemberwiseClone(); + result.CustomProperties = new SerializableDictionary(CustomProperties); + result.LocalPoints = (Vector2[])this.LocalPoints.Clone(); + result.WorldPoints = (Vector2[])this.WorldPoints.Clone(); + result.hovering = false; + return result; + } + + public override string getNamePrefix() + { + return "Path_"; + } + + public override bool contains(Vector2 worldpos) + { + for (int i = 1; i < WorldPoints.Length; i++) + { + if (worldpos.DistanceToLineSegment(WorldPoints[i], WorldPoints[i-1]) <= LineWidth) return true; + } + if (IsPolygon) + if (worldpos.DistanceToLineSegment(WorldPoints[0], WorldPoints[WorldPoints.Length-1]) <= LineWidth) return true; + return false; + } + + /// + /// Calculates the WorldPoints based on Position and LocalPoints + /// + public override void OnTransformed() + { + for (int i = 0; i < WorldPoints.Length; i++) WorldPoints[i] = LocalPoints[i] + Position; + } + + + public override void onMouseOver(Vector2 mouseworldpos) + { + pointundermouse = -1; + for (int i = 0; i < WorldPoints.Length; i++) + { + if (mouseworldpos.DistanceTo(WorldPoints[i]) <= 5) + { + pointundermouse = i; + MainForm.Instance.pictureBox1.Cursor = Cursors.Hand; + MainForm.Instance.toolStripStatusLabel1.Text = Name + " (Point " + i.ToString() + ": " + WorldPoints[i].ToString() + ")"; + } + } + if (pointundermouse == -1) MainForm.Instance.pictureBox1.Cursor = Cursors.Default; + base.onMouseOver(mouseworldpos); + } + + public override void onMouseOut() + { + base.onMouseOut(); + } + + public override void onMouseButtonDown(Vector2 mouseworldpos) + { + hovering = false; + if (pointundermouse >= 0) + { + pointgrabbed = pointundermouse; + initialpos = WorldPoints[pointundermouse]; + } + else MainForm.Instance.pictureBox1.Cursor = Cursors.SizeAll; + base.onMouseButtonDown(mouseworldpos); + } + + public override void onMouseButtonUp(Vector2 mouseworldpos) + { + if (pointgrabbed == 0) + { + LocalPoints[0] = Vector2.Zero; + for (int i = 1; i < LocalPoints.Length; i++) + { + LocalPoints[i] = WorldPoints[i] - WorldPoints[0]; + } + Position = WorldPoints[0]; + OnTransformed(); + MainForm.Instance.propertyGrid1.Refresh(); + } + + pointgrabbed = -1; + base.onMouseButtonUp(mouseworldpos); + } + + public override void setPosition(Vector2 pos) + { + if (pointgrabbed >= 0) + { + LocalPoints[pointgrabbed] = initialpos + pos - Position * 2; + OnTransformed(); + MainForm.Instance.toolStripStatusLabel1.Text = Name + " (Point " + pointgrabbed.ToString() + ": " + WorldPoints[pointgrabbed].ToString() + ")"; + } + else base.setPosition(pos); + } + + + public override bool CanRotate() + { + return true; + } + + public override float getRotation() + { + return (float)Math.Atan2(LocalPoints[1].Y, LocalPoints[1].X); + } + + public override void setRotation(float rotation) + { + float current = (float)Math.Atan2(LocalPoints[1].Y, LocalPoints[1].X); + float delta = rotation - current; + + Matrix matrix = Matrix.CreateRotationZ(delta); + + for (int i = 1; i < LocalPoints.Length; i++) + { + LocalPoints[i] = Vector2.Transform(LocalPoints[i], matrix); + } + OnTransformed(); + } + + + public override bool CanScale() + { + return true; + } + + public override Vector2 getScale() + { + float length = (LocalPoints[1] - LocalPoints[0]).Length(); + return new Vector2(length, length); + } + + public override void setScale(Vector2 scale) + { + float factor = scale.X / (LocalPoints[1] - LocalPoints[0]).Length(); + for (int i = 1; i < LocalPoints.Length; i++) + { + Vector2 olddistance = LocalPoints[i] - LocalPoints[0]; + LocalPoints[i] = LocalPoints[0] + olddistance * factor; + } + OnTransformed(); + } + + public override void drawInEditor(SpriteBatch sb) + { + if (!Visible) return; + Color c = LineColor; + if (hovering && Constants.Instance.EnableHighlightOnMouseOver) c = Constants.Instance.ColorHighlight; + + if (IsPolygon) + Primitives.Instance.drawPolygon(sb, WorldPoints, c, LineWidth); + else + Primitives.Instance.drawPath(sb, WorldPoints, c, LineWidth); + + } + + public override void drawSelectionFrame(SpriteBatch sb, Matrix matrix, Color color) + { + Vector2[] transformedPoints = new Vector2[WorldPoints.Length]; + Vector2.Transform(WorldPoints, ref matrix, transformedPoints); + + if (IsPolygon) + Primitives.Instance.drawPolygon(sb, transformedPoints, color, 2); + else + Primitives.Instance.drawPath(sb, transformedPoints, color, 2); + + foreach (Vector2 p in transformedPoints) + { + Primitives.Instance.drawCircleFilled(sb, p, 4, color); + } + + Primitives.Instance.drawBoxFilled(sb, transformedPoints[0].X - 5, transformedPoints[0].Y - 5, 10, 10, color); + + + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Items/RectangleItem.Editable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Items/RectangleItem.Editable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,233 @@ +using System; +using System.ComponentModel; +using System.Xml; +using System.Xml.Schema; +using System.Xml.Serialization; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using System.Collections.Generic; +using CustomUITypeEditors; +using System.Drawing.Design; +using System.Windows.Forms; + +namespace GLEED2D +{ + public partial class RectangleItem + { + enum EdgeEnum + { + none, left, right, top, bottom + } + + EdgeEnum edgeundermouse, edgegrabbed; + + [DisplayName("Width"), Category(" General")] + [XmlIgnore()] + public float pWidth + { + get + { + return Width; + } + set + { + Width = value; + OnTransformed(); + } + } + + [DisplayName("Height"), Category(" General")] + [XmlIgnore()] + public float pHeight + { + get + { + return Height; + } + set + { + Height = value; + OnTransformed(); + } + } + + [DisplayName("FillColor"), Category(" General")] + [Editor(typeof(XNAColorUITypeEditor), typeof(UITypeEditor))] + [XmlIgnore()] + public Color pFillColor { get { return FillColor; } set { FillColor = value; } } + + Rectangle Rectangle; + int initialwidth, initialheight; + + public RectangleItem(Rectangle rect) : base() + { + Position = rect.Location.ToVector2(); + Width = rect.Width; + Height = rect.Height; + OnTransformed(); + FillColor = Constants.Instance.ColorPrimitives; + + } + + public override Item clone() + { + RectangleItem result = (RectangleItem)this.MemberwiseClone(); + result.CustomProperties = new SerializableDictionary(CustomProperties); + result.hovering = false; + return result; + } + + public override string getNamePrefix() + { + return "Rectangle_"; + } + + public override bool contains(Vector2 worldpos) + { + return Rectangle.Contains(new Point((int)worldpos.X, (int)worldpos.Y)); + } + + + public override void OnTransformed() + { + Rectangle.Location = Position.ToPoint(); + Rectangle.Width = (int)Width; + Rectangle.Height = (int)Height; + } + + public override void onMouseOver(Vector2 mouseworldpos) + { + //System.Diagnostics.Debug.WriteLine(System.DateTime.Now.ToString() + "RectangleItem.onMouseOver()"); + + int edgewidth = 10; + if (Math.Abs(mouseworldpos.X - Rectangle.Left) <= edgewidth) + { + MainForm.Instance.pictureBox1.Cursor = Cursors.SizeWE; + edgeundermouse = EdgeEnum.left; + } + else if (Math.Abs(mouseworldpos.X - Rectangle.Right) <= edgewidth) + { + MainForm.Instance.pictureBox1.Cursor = Cursors.SizeWE; + edgeundermouse = EdgeEnum.right; + } + else if (Math.Abs(mouseworldpos.Y - Rectangle.Top) <= edgewidth) + { + MainForm.Instance.pictureBox1.Cursor = Cursors.SizeNS; + edgeundermouse = EdgeEnum.top; + } + else if (Math.Abs(mouseworldpos.Y - Rectangle.Bottom) <= edgewidth) + { + MainForm.Instance.pictureBox1.Cursor = Cursors.SizeNS; + edgeundermouse = EdgeEnum.bottom; + } + else + { + MainForm.Instance.pictureBox1.Cursor = Cursors.Default; + edgeundermouse = EdgeEnum.none; + } + base.onMouseOver(mouseworldpos); + } + + public override void onMouseOut() + { + //System.Diagnostics.Debug.WriteLine(System.DateTime.Now.ToString() + "RectangleItem.onMouseOut()"); + base.onMouseOut(); + } + + public override void onMouseButtonDown(Vector2 mouseworldpos) + { + hovering = false; + if (edgeundermouse != EdgeEnum.none) + { + edgegrabbed = edgeundermouse; + initialwidth = Rectangle.Width; + initialheight = Rectangle.Height; + } + else MainForm.Instance.pictureBox1.Cursor = Cursors.SizeAll; + base.onMouseButtonDown(mouseworldpos); + } + + public override void onMouseButtonUp(Vector2 mouseworldpos) + { + edgegrabbed = EdgeEnum.none; + base.onMouseButtonUp(mouseworldpos); + } + + public override void setPosition(Vector2 pos) + { + Vector2 delta = pos - Position; + if (pos == Position) return; + switch (edgegrabbed) + { + case EdgeEnum.left: + Position.X = pos.X; + Width -= (int)delta.X; + OnTransformed(); + break; + case EdgeEnum.right: + Width = initialwidth + (int)delta.X; + OnTransformed(); + break; + case EdgeEnum.top: + Position.Y = pos.Y; + Height -= (int)delta.Y; + OnTransformed(); + break; + case EdgeEnum.bottom: + Height = initialheight + (int)delta.Y; + OnTransformed(); + break; + case EdgeEnum.none: + base.setPosition(pos); + break; + } + } + + public override bool CanScale() + { + return true; + } + + public override Vector2 getScale() + { + return new Vector2(pWidth, pWidth); + } + + public override void setScale(Vector2 scale) + { + float factor = scale.X / pWidth; + Width = (float)Math.Round(scale.X); + Height = (float)Math.Round(Height * factor); + OnTransformed(); + } + + public override void drawInEditor(SpriteBatch sb) + { + if (!Visible) return; + + Color c = FillColor; + if (hovering && Constants.Instance.EnableHighlightOnMouseOver) c = Constants.Instance.ColorHighlight; + Primitives.Instance.drawBoxFilled(sb, Rectangle, c); + } + + + public override void drawSelectionFrame(SpriteBatch sb, Matrix matrix, Color color) + { + + Primitives.Instance.drawBox(sb, this.Rectangle.Transform(matrix), color, 2); + + Vector2[] poly = Rectangle.Transform(matrix).ToPolygon(); + + foreach (Vector2 p in poly) + { + Primitives.Instance.drawCircleFilled(sb, p, 4, color); + } + + Primitives.Instance.drawBoxFilled(sb, poly[0].X - 5, poly[0].Y - 5, 10, 10, color); + + + + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Items/TextureItem.Editable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Items/TextureItem.Editable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,353 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Xml; +using System.Xml.Serialization; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Audio; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.GamerServices; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Media; +using Microsoft.Xna.Framework.Net; +using Microsoft.Xna.Framework.Storage; +using Forms = System.Windows.Forms; +using CustomUITypeEditors; +using System.Windows.Forms; +using System.IO; + +namespace GLEED2D +{ + + public partial class TextureItem + { + //for per-pixel-collision + Color[] coldata; + Matrix transform; + Rectangle boundingrectangle; //bounding rectangle in world space, for collision broadphase + + Vector2[] polygon; //selection box: drawn when selected + + [XmlIgnore()] + public string texture_fullpath; + + [XmlIgnore()] + [DisplayName("Origin"), Category(" General")] + [Description("The item's origin in texture space ([0,0] is upper left corner).")] + public Vector2 pOrigin + { + get + { + return Origin; + } + set + { + Origin = value; + OnTransformed(); + } + } + + [XmlIgnore()] + [DisplayName("Rotation"), Category(" General")] + [Description("The item's rotation in radians.")] + public float pRotation + { + get + { + return Rotation; + } + set + { + Rotation = value; + OnTransformed(); + } + } + + [XmlIgnore()] + [DisplayName("Scale"), Category(" General")] + [Description("The item's scale vector.")] + public Vector2 pScale + { + get + { + return Scale; + } + set + { + Scale = value; + OnTransformed(); + } + } + + [XmlIgnore()] + [DisplayName("TintColor"), Category(" General")] + [Editor(typeof(XNAColorUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + [Description("The Color to tint the texture with. Use white for no tint.")] + public Color pTintColor + { + get + { + return TintColor; + } + set + { + TintColor = value; + } + } + + [XmlIgnore()] + [DisplayName("FlipHorizontally"), Category(" General")] + [Description("If true, the texture is flipped horizontally when drawn.")] + public bool pFlipHorizontally { + get { return FlipHorizontally; } + set { FlipHorizontally = value; } + } + + [XmlIgnore()] + [DisplayName("FlipVertically"), Category(" General")] + [Description("If true, the texture is flipped vertically when drawn.")] + public bool pFlipVertically { + get { return FlipVertically; } + set { FlipVertically = value; } + } + + public TextureItem(String fullpath, Vector2 position) : base() + { + this.texture_fullpath = fullpath; + this.Position = position; + this.Rotation = 0; + this.Scale = Vector2.One; + this.TintColor = Microsoft.Xna.Framework.Color.White; + FlipHorizontally = FlipVertically = false; + loadIntoEditor(); + this.Origin = getTextureOrigin(texture); + + //compensate for origins that are not at the center of the texture + Vector2 center = new Vector2(texture.Width / 2, texture.Height / 2); + this.Position -= (center - Origin); + + + OnTransformed(); + } + + public override bool loadIntoEditor() + { + if (layer != null) this.texture_fullpath = System.IO.Path.Combine(layer.level.ContentRootFolder + "\\", texture_filename); + + if (!File.Exists(texture_fullpath)) + { + DialogResult dr = Forms.MessageBox.Show("The file \"" + texture_fullpath + "\" doesn't exist!\n" + + "The texture path is a combination of the Level's ContentRootFolder and the TextureItem's relative path.\n" + + "Please adjust the XML file before trying to load this level again.\n" + + "For now, a dummy texture will be used. Continue loading the level?", "Error loading texture file", + MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Error); + if (dr == DialogResult.No) return false; + texture = Editor.Instance.dummytexture; + } + else + { + texture = TextureLoader.Instance.FromFile(Game1.Instance.GraphicsDevice, texture_fullpath); + } + + //for per-pixel-collision + coldata = new Color[texture.Width * texture.Height]; + texture.GetData(coldata); + + polygon = new Vector2[4]; + + OnTransformed(); + return true; + } + + public override Item clone() + { + TextureItem result = (TextureItem)this.MemberwiseClone(); + result.CustomProperties = new SerializableDictionary(CustomProperties); + result.polygon = (Vector2[])polygon.Clone(); + result.hovering = false; + return result; + } + + public override string getNamePrefix() + { + return "Texture_"; + } + + public override void OnTransformed() + { + transform = + Matrix.CreateTranslation(new Vector3(-Origin.X, -Origin.Y, 0.0f)) * + Matrix.CreateScale(Scale.X, Scale.Y, 1) * + Matrix.CreateRotationZ(Rotation) * + Matrix.CreateTranslation(new Vector3(Position, 0.0f)); + + Vector2 leftTop = new Vector2(0, 0); + Vector2 rightTop = new Vector2(texture.Width, 0); + Vector2 leftBottom = new Vector2(0, texture.Height); + Vector2 rightBottom = new Vector2(texture.Width, texture.Height); + + // Transform all four corners into work space + Vector2.Transform(ref leftTop, ref transform, out leftTop); + Vector2.Transform(ref rightTop, ref transform, out rightTop); + Vector2.Transform(ref leftBottom, ref transform, out leftBottom); + Vector2.Transform(ref rightBottom, ref transform, out rightBottom); + + polygon[0] = leftTop; + polygon[1] = rightTop; + polygon[3] = leftBottom; + polygon[2] = rightBottom; + + // Find the minimum and maximum extents of the rectangle in world space + Vector2 min = Vector2.Min(Vector2.Min(leftTop, rightTop), + Vector2.Min(leftBottom, rightBottom)); + Vector2 max = Vector2.Max(Vector2.Max(leftTop, rightTop), + Vector2.Max(leftBottom, rightBottom)); + + // Return as a rectangle + boundingrectangle = new Rectangle((int)min.X, (int)min.Y, + (int)(max.X - min.X), (int)(max.Y - min.Y)); + } + + + public override void onMouseButtonDown(Vector2 mouseworldpos) + { + hovering = false; + MainForm.Instance.pictureBox1.Cursor = Cursors.SizeAll; + base.onMouseButtonDown(mouseworldpos); + } + + + public override bool CanRotate() + { + return true; + } + + public override float getRotation() + { + return pRotation; + } + + public override void setRotation(float rotation) + { + pRotation = rotation; + } + + + public override bool CanScale() + { + return true; + } + + public override Vector2 getScale() + { + return pScale; + } + + public override void setScale(Vector2 scale) + { + pScale = scale; + } + + + public override void drawInEditor(SpriteBatch sb) + { + if (!Visible) return; + + SpriteEffects se = SpriteEffects.None; + if (pFlipHorizontally) se |= SpriteEffects.FlipHorizontally; + if (pFlipVertically) se |= SpriteEffects.FlipVertically; + Color c = TintColor; + if (hovering && Constants.Instance.EnableHighlightOnMouseOver) c = Constants.Instance.ColorHighlight; + sb.Draw(texture, Position, null, c, Rotation, Origin, Scale, se, 0); + } + + public override void drawSelectionFrame(SpriteBatch sb, Matrix matrix, Color color) + { + Vector2[] poly = new Vector2[4]; + Vector2.Transform(polygon, ref matrix, poly); + + Primitives.Instance.drawPolygon(sb, poly, color, 2); + foreach (Vector2 p in poly) + { + Primitives.Instance.drawCircleFilled(sb, p, 4, color); + } + Vector2 origin = Vector2.Transform(pPosition, matrix); + Primitives.Instance.drawBoxFilled(sb, origin.X - 5, origin.Y - 5, 10, 10, color); + } + + public override bool contains(Vector2 worldpos) + { + if (boundingrectangle.Contains((int)worldpos.X, (int)worldpos.Y)) + { + return intersectpixels(worldpos); + } + return false; + } + + public bool intersectpixels(Vector2 worldpos) + { + Vector2 positionInB = Vector2.Transform(worldpos, Matrix.Invert(transform)); + int xB = (int)Math.Round(positionInB.X); + int yB = (int)Math.Round(positionInB.Y); + + if (FlipHorizontally) xB = texture.Width - xB; + if (FlipVertically) yB = texture.Height - yB; + + // If the pixel lies within the bounds of B + if (0 <= xB && xB < texture.Width && 0 <= yB && yB < texture.Height) + { + Color colorB = coldata[xB + yB * texture.Width]; + if (colorB.A != 0) + { + return true; + } + } + return false; + } + + + + public Vector2 getTextureOrigin(Texture2D texture) + { + switch (Constants.Instance.DefaultTextureOriginMethod) + { + case TextureOriginMethodEnum.TextureCenter: + return new Vector2(texture.Width / 2, texture.Height / 2); + case TextureOriginMethodEnum.Centroid: + uint[] data = new uint[texture.Width * texture.Height]; + texture.GetData(data); + Vertices verts = Vertices.CreatePolygon(data, texture.Width, texture.Height); + return verts.GetCentroid(); + case TextureOriginMethodEnum.TopLeft: + return new Vector2(0, 0); + case TextureOriginMethodEnum.TopRight: + return new Vector2(texture.Width, 0); + case TextureOriginMethodEnum.BottomLeft: + return new Vector2(0, texture.Height); + case TextureOriginMethodEnum.BottomRight: + return new Vector2(texture.Width, texture.Height); + } + return Vector2.Zero; + } + + + + + + + } + + + + + + + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Kopie von SerializableDictionary.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Kopie von SerializableDictionary.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,85 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Xml.Serialization; + +namespace MyEditor.src +{ + + [XmlRoot("dictionary")] + public class SerializableDictionary : Dictionary, IXmlSerializable + { + public System.Xml.Schema.XmlSchema GetSchema() + { + return null; + } + + public void ReadXml(System.Xml.XmlReader reader) + { + XmlSerializer keySerializer = new XmlSerializer(typeof(TKey)); + XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue)); + + bool wasEmpty = reader.IsEmptyElement; + reader.Read(); + + if (wasEmpty) + return; + + while (reader.NodeType != System.Xml.XmlNodeType.EndElement) + { + /* + reader.ReadStartElement("item"); + + reader.ReadStartElement("key"); + TKey key = (TKey)keySerializer.Deserialize(reader); + reader.ReadEndElement(); + + reader.ReadStartElement("value"); + TValue value = (TValue)valueSerializer.Deserialize(reader); + reader.ReadEndElement(); + + reader.ReadEndElement(); + + this.Add(key, value); + */ + int i = 0; + TKey key = (TKey)keySerializer.Deserialize(reader); /*reader.Name as TKey;*/ + TValue value = (TValue)reader.ReadInnerXml(); + this.Add(reader.Name, value); + + + reader.MoveToContent(); + } + reader.ReadEndElement(); + } + + public void WriteXml(System.Xml.XmlWriter writer) + { + //XmlSerializer keySerializer = new XmlSerializer(typeof(TKey)); + //XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue)); + + foreach (TKey key in this.Keys) + { + /*writer.WriteStartElement("item"); + + writer.WriteStartElement("key"); + keySerializer.Serialize(writer, key); + writer.WriteEndElement(); + + writer.WriteStartElement("value"); + TValue value = this[key]; + valueSerializer.Serialize(writer, value); + writer.WriteEndElement(); + + writer.WriteEndElement();*/ + + writer.WriteStartElement(key.ToString()); + writer.WriteString(this[key].ToString()); + writer.WriteEndElement(); + } + } + + + } +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Layer.Editable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Layer.Editable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,76 @@ +using System; +using System.IO; +using System.Collections.Generic; +using System.Xml.Serialization; +using System.Windows.Forms; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using System.Xml; +using System.Text; +using System.ComponentModel; + + +namespace GLEED2D +{ + public partial class Layer + { + + [XmlIgnore()] + [DisplayName("ScrollSpeed"), Category(" General")] + [Description("The Scroll Speed relative to the main camera. The X and Y components are interpreted as factors, " + + "so Vector2.One means same scrolling speed as the main camera. To be used for parallax scrolling.")] + public Vector2 pScrollSpeed + { + get + { + return ScrollSpeed; + } + set + { + ScrollSpeed = value; + } + } + + + [XmlIgnore] + public Level level; + + public Layer(String name) : this() + { + this.Name = name; + this.Visible = true; + } + + public Layer clone() + { + Layer result = (Layer)this.MemberwiseClone(); + result.Items = new List(Items); + for (int i = 0; i < result.Items.Count; i++) + { + result.Items[i] = result.Items[i].clone(); + result.Items[i].layer = result; + } + return result; + } + + + + public Item getItemAtPos(Vector2 mouseworldpos) + { + for (int i = Items.Count - 1; i >= 0; i--) + { + if (Items[i].contains(mouseworldpos) && Items[i].Visible) return Items[i]; + } + return null; + } + + public void drawInEditor(SpriteBatch sb) + { + if (!Visible) return; + foreach (Item item in Items) item.drawInEditor(sb); + } + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Layer.ICustomTypeDescriptor.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Layer.ICustomTypeDescriptor.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,88 @@ +using System; +using System.ComponentModel; +using CustomUITypeEditors; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace GLEED2D +{ + + public partial class Layer : ICustomTypeDescriptor + { + + AttributeCollection ICustomTypeDescriptor.GetAttributes() + { + return TypeDescriptor.GetAttributes(this, true); + } + + string ICustomTypeDescriptor.GetClassName() + { + return TypeDescriptor.GetClassName(this, true); + } + + string ICustomTypeDescriptor.GetComponentName() + { + return TypeDescriptor.GetComponentName(this, true); + } + + TypeConverter ICustomTypeDescriptor.GetConverter() + { + return TypeDescriptor.GetConverter(this, true); + } + + EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() + { + return TypeDescriptor.GetDefaultEvent(this, true); + } + + PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() + { + return TypeDescriptor.GetDefaultProperty(this, true); + } + + object ICustomTypeDescriptor.GetEditor(Type editorBaseType) + { + return TypeDescriptor.GetEditor(this, editorBaseType, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) + { + return TypeDescriptor.GetEvents(this, attributes, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents() + { + return TypeDescriptor.GetEvents(this, true); + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) + { + PropertyDescriptorCollection pdc = new PropertyDescriptorCollection(new PropertyDescriptor[0]); + foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(this)) + { + pdc.Add(pd); + } + foreach (String key in CustomProperties.Keys) + { + pdc.Add(new DictionaryPropertyDescriptor(CustomProperties, key, attributes)); + } + return pdc; + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() + { + return TypeDescriptor.GetProperties(this, true); + } + + object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) + { + return this; + } + + } + + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Level.Editable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Level.Editable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,157 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; +using System.Xml.Serialization; +using Forms = System.Windows.Forms; +using System.ComponentModel; +using System.Text; +using System.Drawing.Design; +using System.Windows.Forms; +using CustomUITypeEditors; +using Microsoft.Xna.Framework; + +namespace GLEED2D +{ + public partial class Level + { + [XmlIgnore()] + public string selectedlayers; + [XmlIgnore()] + public string selecteditems; + + public class EditorVars + { + public int NextItemNumber; + public string ContentRootFolder; + public Vector2 CameraPosition; + public string Version; + } + + [XmlIgnore()] + [Category(" General")] + [Description("When the level is saved, each texture is saved with a path relative to this folder." + + "You should set this to the \"Content.RootDirectory\" of your game project.")] + [EditorAttribute(typeof(FolderUITypeEditor), typeof(System.Drawing.Design.UITypeEditor))] + public String ContentRootFolder + { + get + { + return EditorRelated.ContentRootFolder; + } + set + { + EditorRelated.ContentRootFolder = value; + } + } + + EditorVars editorrelated = new EditorVars(); + [Browsable(false)] + public EditorVars EditorRelated + { + get + { + return editorrelated; + } + set + { + editorrelated = value; + } + } + + [XmlIgnore()] + public Forms.TreeNode treenode; + + + public string getNextItemNumber() + { + return (++EditorRelated.NextItemNumber).ToString("0000"); + } + + + public void export(string filename) + { + foreach (Layer l in Layers) + { + foreach (Item i in l.Items) + { + if (i is TextureItem) + { + TextureItem ti = (TextureItem)i; + ti.texture_filename = RelativePath(ContentRootFolder, ti.texture_fullpath); + ti.asset_name = ti.texture_filename.Substring(0, ti.texture_filename.LastIndexOf('.')); + } + } + } + + + XmlTextWriter writer = new XmlTextWriter(filename, null); + writer.Formatting = Formatting.Indented; + writer.Indentation = 4; + + XmlSerializer serializer = new XmlSerializer(typeof(Level)); + serializer.Serialize(writer, this); + + writer.Close(); + + } + + + + public string RelativePath(string relativeTo, string pathToTranslate) + { + string[] absoluteDirectories = relativeTo.Split('\\'); + string[] relativeDirectories = pathToTranslate.Split('\\'); + + //Get the shortest of the two paths + int length = absoluteDirectories.Length < relativeDirectories.Length ? absoluteDirectories.Length : relativeDirectories.Length; + + //Use to determine where in the loop we exited + int lastCommonRoot = -1; + int index; + + //Find common root + for (index = 0; index < length; index++) + if (absoluteDirectories[index] == relativeDirectories[index]) + lastCommonRoot = index; + else + break; + + //If we didn't find a common prefix then throw + if (lastCommonRoot == -1) + // throw new ArgumentException("Paths do not have a common base"); + return pathToTranslate; + + //Build up the relative path + StringBuilder relativePath = new StringBuilder(); + + //Add on the .. + for (index = lastCommonRoot + 1; index < absoluteDirectories.Length; index++) + if (absoluteDirectories[index].Length > 0) relativePath.Append("..\\"); + + //Add on the folders + for (index = lastCommonRoot + 1; index < relativeDirectories.Length - 1; index++) + relativePath.Append(relativeDirectories[index] + "\\"); + + relativePath.Append(relativeDirectories[relativeDirectories.Length - 1]); + + return relativePath.ToString(); + } + + + + + + + + + } + + + + + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Level.ICustomTypeDescriptor.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Level.ICustomTypeDescriptor.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,169 @@ +using System; +using System.ComponentModel; +using CustomUITypeEditors; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace GLEED2D +{ + + + public partial class Level : ICustomTypeDescriptor + { + + AttributeCollection ICustomTypeDescriptor.GetAttributes() + { + return TypeDescriptor.GetAttributes(this, true); + } + + string ICustomTypeDescriptor.GetClassName() + { + return TypeDescriptor.GetClassName(this, true); + } + + string ICustomTypeDescriptor.GetComponentName() + { + return TypeDescriptor.GetComponentName(this, true); + } + + TypeConverter ICustomTypeDescriptor.GetConverter() + { + return TypeDescriptor.GetConverter(this, true); + } + + EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() + { + return TypeDescriptor.GetDefaultEvent(this, true); + } + + PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() + { + return TypeDescriptor.GetDefaultProperty(this, true); + } + + object ICustomTypeDescriptor.GetEditor(Type editorBaseType) + { + return TypeDescriptor.GetEditor(this, editorBaseType, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) + { + return TypeDescriptor.GetEvents(this, attributes, true); + } + + EventDescriptorCollection ICustomTypeDescriptor.GetEvents() + { + return TypeDescriptor.GetEvents(this, true); + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) + { + PropertyDescriptorCollection pdc = new PropertyDescriptorCollection(new PropertyDescriptor[0]); + foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(this)) + { + pdc.Add(pd); + } + foreach (String key in CustomProperties.Keys) + { + pdc.Add(new DictionaryPropertyDescriptor(CustomProperties, key, attributes)); + } + return pdc; + } + + PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() + { + return TypeDescriptor.GetProperties(this, true); + } + + object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) + { + return this; + } + + } + + + + public class DictionaryPropertyDescriptor : PropertyDescriptor + { + String key; + public SerializableDictionary sdict; + + + public DictionaryPropertyDescriptor(SerializableDictionary dict, String key, Attribute[] attrs) + : base(key, attrs) + { + this.key = key; + this.sdict = dict; + } + + public override bool CanResetValue(object component) + { + return false; + } + + public override Type ComponentType + { + get { return null; } + } + + public override object GetValue(object component) + { + return sdict[key].value; + } + + public override string Description + { + get { return sdict[key].description; } + } + + public override string Category + { + get { return "Custom Properties"; } + } + + public override string DisplayName + { + get { return key; } + } + + public override bool IsReadOnly + { + get { return false; } + } + + public override void ResetValue(object component) + { + //Have to implement + } + + public override bool ShouldSerializeValue(object component) + { + return false; + } + + public override void SetValue(object component, object value) + { + sdict[key].value = value; + } + + public override Type PropertyType + { + get { return sdict[key].type; } + } + + public override object GetEditor(Type editorBaseType) + { + if (sdict[key].type == typeof(Vector2)) return new Vector2UITypeEditor(); + if (sdict[key].type == typeof(Color)) return new XNAColorUITypeEditor(); + if (sdict[key].type == typeof(Item)) return new ItemUITypeEditor(); + + return base.GetEditor(editorBaseType); + } + + } + + + + +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Level.IUndoable.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Level.IUndoable.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,73 @@ +using System; +using System.Collections.Generic; +using System.Xml; +using System.Xml.Serialization; +using System.Diagnostics; +using System.Windows.Forms; + + +namespace GLEED2D +{ + [DebuggerDisplay("Name: {Name}, Address: {&Name}")] + public partial class Level : IUndoable + { + + public void add() + { + } + + public void remove() + { + } + + public IUndoable cloneforundo() + { + selecteditems = ""; + foreach (Item i in Editor.Instance.SelectedItems) selecteditems += i.Name + ";"; + if (Editor.Instance.SelectedLayer != null) selectedlayers = Editor.Instance.SelectedLayer.Name; + + + Level result = (Level)this.MemberwiseClone(); + result.Layers = new List(Layers); + for (int i = 0; i < result.Layers.Count; i++) + { + result.Layers[i] = result.Layers[i].clone(); + result.Layers[i].level = result; + } + return (IUndoable)result; + } + + public void makelike(IUndoable other) + { + /*Layer l2 = (Layer)other; + Items = l2.Items; + treenode.Nodes.Clear(); + foreach (Item i in Items) + { + Editor.Instance.addItem(i); + }*/ + + + Level l2 = (Level)other; + Layers = l2.Layers; + treenode.Nodes.Clear(); + foreach (Layer l in Layers) + { + Editor.Instance.addLayer(l); + //TODO add all items + } + } + + public string getName() + { + return Name; + } + + public void setName(string name) + { + Name = name; + treenode.Text = name; + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Level.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Level.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,459 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Xml; +using System.Xml.Serialization; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Content; + + +namespace GLEED2D +{ + public partial class Level + { + /// + /// The name of the level. + /// + [XmlAttribute()] + public String Name; + + [XmlAttribute()] + public bool Visible; + + /// + /// A Level contains several Layers. Each Layer contains several Items. + /// + public List Layers; + + /// + /// A Dictionary containing any user-defined Properties. + /// + public SerializableDictionary CustomProperties; + + + public Level() + { + Visible = true; + Layers = new List(); + CustomProperties = new SerializableDictionary(); + } + + public static Level FromFile(string filename, ContentManager cm) + { + FileStream stream = File.Open(filename, FileMode.Open); + XmlSerializer serializer = new XmlSerializer(typeof(Level)); + Level level = (Level)serializer.Deserialize(stream); + stream.Close(); + + foreach (Layer layer in level.Layers) + { + foreach (Item item in layer.Items) + { + item.CustomProperties.RestoreItemAssociations(level); + item.load(cm); + } + } + + return level; + } + + public Item getItemByName(string name) + { + foreach (Layer layer in Layers) + { + foreach (Item item in layer.Items) + { + if (item.Name == name) return item; + } + } + return null; + } + + public Layer getLayerByName(string name) + { + foreach (Layer layer in Layers) + { + if (layer.Name == name) return layer; + } + return null; + } + + public void draw(SpriteBatch sb) + { + foreach (Layer layer in Layers) layer.draw(sb); + } + + + } + + + public partial class Layer + { + /// + /// The name of the layer. + /// + [XmlAttribute()] + public String Name; + + /// + /// Should this layer be visible? + /// + [XmlAttribute()] + public bool Visible; + + /// + /// The list of the items in this layer. + /// + public List Items; + + /// + /// The Scroll Speed relative to the main camera. The X and Y components are + /// interpreted as factors, so (1;1) means the same scrolling speed as the main camera. + /// Enables parallax scrolling. + /// + public Vector2 ScrollSpeed; + + /// + /// A Dictionary containing any user-defined Properties. + /// + public SerializableDictionary CustomProperties; + + + public Layer() + { + Items = new List(); + ScrollSpeed = Vector2.One; + CustomProperties = new SerializableDictionary(); + } + + public void draw(SpriteBatch sb) + { + if (!Visible) return; + foreach (Item item in Items) item.draw(sb); + } + + } + + + [XmlInclude(typeof(TextureItem))] + [XmlInclude(typeof(RectangleItem))] + [XmlInclude(typeof(CircleItem))] + [XmlInclude(typeof(PathItem))] + public partial class Item + { + /// + /// The name of this item. + /// + [XmlAttribute()] + public String Name; + + /// + /// Should this item be visible? + /// + [XmlAttribute()] + public bool Visible; + + /// + /// The item's position in world space. + /// + public Vector2 Position; + + /// + /// A Dictionary containing any user-defined Properties. + /// + public SerializableDictionary CustomProperties; + + + public Item() + { + CustomProperties = new SerializableDictionary(); + } + + /// + /// Called by Level.FromFile(filename) on each Item after the deserialization process. + /// Should be overriden and can be used to load anything needed by the Item (e.g. a texture). + /// + public virtual void load(ContentManager cm) + { + } + + public virtual void draw(SpriteBatch sb) + { + } + } + + + public partial class TextureItem : Item + { + /// + /// The item's rotation in radians. + /// + public float Rotation; + + /// + /// The item's scale vector. + /// + public Vector2 Scale; + + /// + /// The color to tint the item's texture with (use white for no tint). + /// + public Color TintColor; + + /// + /// If true, the texture is flipped horizontally when drawn. + /// + public bool FlipHorizontally; + + /// + /// If true, the texture is flipped vertically when drawn. + /// + public bool FlipVertically; + + /// + /// The path to the texture's filename (including the extension) relative to ContentRootFolder. + /// + public String texture_filename; + + /// + /// The texture_filename without extension. For using in Content.Load(). + /// + public String asset_name; + + /// + /// The XNA texture to be drawn. Can be loaded either from file (using "texture_filename") + /// or via the Content Pipeline (using "asset_name") - then you must ensure that the texture + /// exists as an asset in your project. + /// Loading is done in the Item's load() method. + /// + Texture2D texture; + + /// + /// The item's origin relative to the upper left corner of the texture. Usually the middle of the texture. + /// Used for placing and rotating the texture when drawn. + /// + public Vector2 Origin; + + + public TextureItem() + { + } + + /// + /// Called by Level.FromFile(filename) on each Item after the deserialization process. + /// Loads all assets needed by the TextureItem, especially the Texture2D. + /// You must provide your own implementation. However, you can rely on all public fields being + /// filled by the level deserialization process. + /// + public override void load(ContentManager cm) + { + //throw new NotImplementedException(); + + //TODO: provide your own implementation of how a TextureItem loads its assets + //for example: + //this.texture = Texture2D.FromFile(, texture_filename); + //or by using the Content Pipeline: + //this.texture = cm.Load(asset_name); + + } + + public override void draw(SpriteBatch sb) + { + if (!Visible) return; + SpriteEffects effects = SpriteEffects.None; + if (FlipHorizontally) effects |= SpriteEffects.FlipHorizontally; + if (FlipVertically) effects |= SpriteEffects.FlipVertically; + sb.Draw(texture, Position, null, TintColor, Rotation, Origin, Scale, effects, 0); + } + } + + + public partial class RectangleItem : Item + { + public float Width; + public float Height; + public Color FillColor; + + public RectangleItem() + { + } + } + + + public partial class CircleItem : Item + { + public float Radius; + public Color FillColor; + + public CircleItem() + { + } + } + + + public partial class PathItem : Item + { + public Vector2[] LocalPoints; + public Vector2[] WorldPoints; + public bool IsPolygon; + public int LineWidth; + public Color LineColor; + + public PathItem() + { + } + } + + + /////////////////////////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////////////////////////// + // + // NEEDED FOR SERIALIZATION. YOU SHOULDN'T CHANGE ANYTHING BELOW! + // + /////////////////////////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////////////////////////// + + + public class CustomProperty + { + public string name; + public object value; + public Type type; + public string description; + + public CustomProperty() + { + } + + public CustomProperty(string n, object v, Type t, string d) + { + name = n; + value = v; + type = t; + description = d; + } + + public CustomProperty clone() + { + CustomProperty result = new CustomProperty(name, value, type, description); + return result; + } + } + + + public class SerializableDictionary : Dictionary, IXmlSerializable + { + + public SerializableDictionary() + : base() + { + + } + + public SerializableDictionary(SerializableDictionary copyfrom) + : base(copyfrom) + { + string[] keyscopy = new string[Keys.Count]; + Keys.CopyTo(keyscopy, 0); + foreach (string key in keyscopy) + { + this[key] = this[key].clone(); + } + } + + public System.Xml.Schema.XmlSchema GetSchema() + { + return null; + } + + public void ReadXml(System.Xml.XmlReader reader) + { + + bool wasEmpty = reader.IsEmptyElement; + reader.Read(); + + if (wasEmpty) return; + + while (reader.NodeType != System.Xml.XmlNodeType.EndElement) + { + CustomProperty cp = new CustomProperty(); + cp.name = reader.GetAttribute("Name"); + cp.description = reader.GetAttribute("Description"); + + string type = reader.GetAttribute("Type"); + if (type == "string") cp.type = typeof(string); + if (type == "bool") cp.type = typeof(bool); + if (type == "Vector2") cp.type = typeof(Vector2); + if (type == "Color") cp.type = typeof(Color); + if (type == "Item") cp.type = typeof(Item); + + if (cp.type == typeof(Item)) + { + cp.value = reader.ReadInnerXml(); + this.Add(cp.name, cp); + } + else + { + reader.ReadStartElement("Property"); + XmlSerializer valueSerializer = new XmlSerializer(cp.type); + object obj = valueSerializer.Deserialize(reader); + cp.value = Convert.ChangeType(obj, cp.type); + this.Add(cp.name, cp); + reader.ReadEndElement(); + } + + reader.MoveToContent(); + } + reader.ReadEndElement(); + } + + public void WriteXml(System.Xml.XmlWriter writer) + { + foreach (String key in this.Keys) + { + writer.WriteStartElement("Property"); + writer.WriteAttributeString("Name", this[key].name); + if (this[key].type == typeof(string)) writer.WriteAttributeString("Type", "string"); + if (this[key].type == typeof(bool)) writer.WriteAttributeString("Type", "bool"); + if (this[key].type == typeof(Vector2)) writer.WriteAttributeString("Type", "Vector2"); + if (this[key].type == typeof(Color)) writer.WriteAttributeString("Type", "Color"); + if (this[key].type == typeof(Item)) writer.WriteAttributeString("Type", "Item"); + writer.WriteAttributeString("Description", this[key].description); + + if (this[key].type == typeof(Item)) + { + Item item = (Item)this[key].value; + if (item != null) writer.WriteString(item.Name); + else writer.WriteString("$null$"); + } + else + { + XmlSerializer valueSerializer = new XmlSerializer(this[key].type); + valueSerializer.Serialize(writer, this[key].value); + } + writer.WriteEndElement(); + } + } + + /// + /// Must be called after all Items have been deserialized. + /// Restores the Item references in CustomProperties of type Item. + /// + public void RestoreItemAssociations(Level level) + { + foreach (CustomProperty cp in Values) + { + if (cp.type == typeof(Item)) cp.value = level.getItemByName((string)cp.value); + } + } + + + } + + + + + + +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Logger.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Logger.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,48 @@ +// +// provides a convenient way to have a log file +// +using System; +using System.IO; + +namespace GLEED2D +{ + + public class Logger + { + private static Logger instance; + public static Logger Instance + { + get + { + if (instance == null) instance = new Logger(); + return instance; + } + } + + string logfilename = System.Windows.Forms.Application.StartupPath + "\\log.txt"; + StreamWriter sw; + + public Logger() + { + sw = new StreamWriter(logfilename, false); + sw.WriteLine(box("Log File created.")); + sw.Close(); + } + + + public void log(string message) + { + + sw = new StreamWriter(logfilename, true); + sw.WriteLine(box(message)); + sw.Close(); + } + + string box(string message) + { + return DateTime.Now + "." + DateTime.Now.Millisecond.ToString("000") + " - " + message; + } + + } + +} \ No newline at end of file diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Primitives.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Primitives.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,187 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Audio; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.GamerServices; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; +using Microsoft.Xna.Framework.Media; +using Microsoft.Xna.Framework.Net; +using Microsoft.Xna.Framework.Storage; + +namespace GLEED2D +{ + class Primitives + { + private static Primitives instance; + public static Primitives Instance + { + get + { + if (instance == null) instance = new Primitives(); + return instance; + } + } + + Texture2D pixel; + Texture2D circle; + const int circleTextureRadius = 512; + + + public Primitives() + { + pixel = new Texture2D(Game1.Instance.GraphicsDevice, 1, 1); + pixel.SetData(new[] { Color.White }); + circle = CreateCircleTexture(Game1.Instance.GraphicsDevice, circleTextureRadius, 0, 1, 1, Color.White, Color.White); + } + + public Texture2D CreateCircleTexture(GraphicsDevice graphicsDevice, int radius, int borderWidth, + int borderInnerTransitionWidth, int borderOuterTransitionWidth, + Color color, Color borderColor) + { + int diameter = radius * 2; + Vector2 center = new Vector2(radius, radius); + + Texture2D circle = new Texture2D(graphicsDevice, diameter, diameter, true, SurfaceFormat.Color); + //Texture2D circle = new Texture2D(graphicsDevice, diameter, diameter, 1, TextureUsage.None, SurfaceFormat.Color); + Color[] colors = new Color[diameter * diameter]; + int y = -1; + for (int i = 0; i < colors.Length; i++) + { + int x = i % diameter; + + if (x == 0) + { + y += 1; + } + + Vector2 diff = new Vector2(x, y) - center; + float length = diff.Length(); // distance.Length(); + + if (length > radius) + { + colors[i] = Color.Transparent; + } + else if (length >= radius - borderOuterTransitionWidth) + { + float transitionAmount = (length - (radius - borderOuterTransitionWidth)) / borderOuterTransitionWidth; + transitionAmount = 255 * (1 - transitionAmount); + colors[i] = new Color(borderColor.R, borderColor.G, borderColor.B, (byte)transitionAmount); + } + else if (length > radius - (borderWidth + borderOuterTransitionWidth)) + { + colors[i] = borderColor; + } + else if (length >= radius - (borderWidth + borderOuterTransitionWidth + borderInnerTransitionWidth)) + { + float transitionAmount = (length - + (radius - + (borderWidth + borderOuterTransitionWidth + borderInnerTransitionWidth))) / + (borderInnerTransitionWidth + 1); + colors[i] = new Color((byte)MathHelper.Lerp(color.R, borderColor.R, transitionAmount), + (byte)MathHelper.Lerp(color.G, borderColor.G, transitionAmount), + (byte)MathHelper.Lerp(color.B, borderColor.B, transitionAmount)); + } + else + { + colors[i] = color; + } + } + circle.SetData(colors); + return circle; + } + + + + + public void drawPixel(SpriteBatch sb, int x, int y, Color c) + { + sb.Draw(pixel, new Vector2(x, y), c); + } + + + public void drawBox(SpriteBatch sb, Rectangle r, Color c, int linewidth) + { + drawLine(sb, r.Left, r.Top, r.Right, r.Top, c, linewidth); + drawLine(sb, r.Right, r.Y, r.Right, r.Bottom, c, linewidth); + drawLine(sb, r.Right, r.Bottom, r.Left, r.Bottom, c, linewidth); + drawLine(sb, r.Left, r.Bottom, r.Left, r.Top, c, linewidth); + } + + + public void drawBoxFilled(SpriteBatch sb, float x, float y, float w, float h, Color c) + { + sb.Draw(pixel, new Rectangle((int)x, (int)y, (int)w, (int)h), c); + } + + public void drawBoxFilled(SpriteBatch sb, Vector2 upperLeft, Vector2 lowerRight, Color c) + { + Rectangle r = Extensions.RectangleFromVectors(upperLeft, lowerRight); + sb.Draw(pixel, r, c); + } + + public void drawBoxFilled(SpriteBatch sb, Rectangle r, Color c) + { + sb.Draw(pixel, r, c); + } + + public void drawCircle(SpriteBatch sb, Vector2 position, float radius, Color c, int linewidth) + { + drawPolygon(sb, makeCircle(position, radius, 32), c, linewidth); + } + + public void drawCircleFilled(SpriteBatch sb, Vector2 position, float radius, Color c) + { + sb.Draw(circle, position, null, c, 0, new Vector2(circleTextureRadius, circleTextureRadius), radius / circleTextureRadius, SpriteEffects.None, 0); + } + + + public void drawLine(SpriteBatch sb, float x1, float y1, float x2, float y2, Color c, int linewidth) + { + Vector2 v = new Vector2(x2 - x1, y2 - y1); + float rot = (float)Math.Atan2(y2 - y1, x2 - x1); + sb.Draw(pixel, new Vector2(x1, y1), new Rectangle(1, 1, 1, linewidth), c, rot, + new Vector2(0, linewidth / 2), new Vector2(v.Length(), 1), SpriteEffects.None, 0); + } + public void drawLine(SpriteBatch sb, Vector2 startpos, Vector2 endpos, Color c, int linewidth) + { + drawLine(sb, startpos.X, startpos.Y, endpos.X, endpos.Y, c, linewidth); + } + + + public void drawPath(SpriteBatch sb, Vector2[] points, Color c, int linewidth) + { + for (int i = 0; i < points.Length - 1; i++) + { + drawLine(sb, points[i], points[i + 1], c, linewidth); + } + } + + public void drawPolygon(SpriteBatch sb, Vector2[] points, Color c, int linewidth) + { + drawPath(sb, points, c, linewidth); + drawLine(sb, points[points.Length-1], points[0], c, linewidth); + } + + + public Vector2[] makeCircle(Vector2 position, float radius, int numpoints) + { + Vector2[] polygon = new Vector2[numpoints]; + float angle = 0; + for (int i = 0; i < numpoints; i++) + { + float x = (float)Math.Cos(angle) * radius; + float y = (float)Math.Sin(angle) * radius; + polygon[i] = position + new Vector2(x, y); + angle += MathHelper.TwoPi / (float)numpoints; + } + return polygon; + } + + + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Program.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Program.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,44 @@ +using System; +using System.Windows.Forms; + +namespace GLEED2D +{ + static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main(string[] args) + { + Logger.Instance.log("Application started."); + + try + { + Application.EnableVisualStyles(); + + MainForm form = new MainForm(); + form.Show(); + + Logger.Instance.log("Creating Game1 object."); + using (Game1 game = new Game1(form.getHandle())) + { + game.Run(); + } + } + catch (Exception e) + { + Logger.Instance.log("Exception caught: \n\n " + e.Message + "\n\n" + e.StackTrace); + if (e.InnerException != null) Logger.Instance.log("Inner Exception: " + e.InnerException.Message); + MessageBox.Show("An exception was caught. Application will end. Please check the file log.txt."); + } + finally + { + Logger.Instance.log("Application ended."); + } + + + } + } +} + diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/TextureLoader.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/TextureLoader.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,69 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework; +using System.IO; + +namespace GLEED2D +{ + //Copied from http://forums.create.msdn.com/forums/t/72423.aspx + public static class ExtensionMethods + { + public static Texture2D ConvertToPreMultipliedAlpha(this Texture2D texture) + { + Color[] data = new Color[texture.Width * texture.Height]; + texture.GetData(data, 0, data.Length); + for (int i = 0; i < data.Length; i++) + { + data[i] = new Color(new Vector4(data[i].ToVector3() * (data[i].A / 255f), (data[i].A / 255f))); + } + texture.SetData(data, 0, data.Length); + + return texture; + } + } + class TextureLoader + { + + private static TextureLoader instance; + public static TextureLoader Instance + { + get + { + if (instance == null) instance = new TextureLoader(); + return instance; + } + } + + Dictionary textures = new Dictionary(); + + + + public Texture2D FromFile(GraphicsDevice gd, string filename) + { + if (!textures.ContainsKey(filename)) + { + //TextureCreationParameters tcp = TextureCreationParameters.Default; + //tcp.Format = SurfaceFormat.Color; + //tcp.ColorKey = Constants.Instance.ColorTextureTransparent; + //textures[filename] = Texture2D.FromFile(gd, filename, tcp); + //using (Stream stream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.None)) + //{ + StreamReader stream = new StreamReader(filename); + + textures[filename] = Texture2D.FromStream(gd, stream.BaseStream).ConvertToPreMultipliedAlpha(); + stream.Close(); + //} + } + return textures[filename]; + } + + public void Clear() + { + textures.Clear(); + } + + } +} diff -r 0000000000000000000000000000000000000000 -r 8975e8949565d9d6887726b9e31117498dabb0ce gleed2d/src/Vertices.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gleed2d/src/Vertices.cs Wed May 09 22:51:52 2012 -0500 @@ -0,0 +1,4785 @@ +// +// this code is from the great farseer project +// http://farseerphysics.codeplex.com/ +// +// it is used for the calculation of the origin of a texture, +// when DefaultTextureOriginMethod "Centroid" is set in the Settings. +// +using System; +using System.Collections.Generic; +using System.Text; +using Microsoft.Xna.Framework; + + +namespace GLEED2D +{ + /// + /// Provides an implementation of a strongly typed List with Vector2 + /// + public class Vertices : List + { + private Vector2 _res; + private Vector2 _vectorTemp1 = Vector2.Zero; + private Vector2 _vectorTemp2 = Vector2.Zero; + private Vector2 _vectorTemp3 = Vector2.Zero; + private Vector2 _vectorTemp4 = Vector2.Zero; + private Vector2 _vectorTemp5 = Vector2.Zero; + + public Vertices() + { + } + + public Vertices(Vector2[] vector2) + { + for (int i = 0; i < vector2.Length; i++) + { + Add(vector2[i]); + } + } + + public Vertices(Vertices vertices) + { + for (int i = 0; i < vertices.Count; i++) + { + Add(vertices[i]); + } + } + + /// + /// Gets an array of vertices. + /// + /// + public Vector2[] GetVerticesArray() + { + return ToArray(); + } + + /// + /// Gets the next index. + /// + /// The index. + /// + public int NextIndex(int index) + { + if (index == Count - 1) + { + return 0; + } + return index + 1; + } + + /// + /// Gets the previous index. + /// + /// The index. + /// + public int PreviousIndex(int index) + { + if (index == 0) + { + return Count - 1; + } + return index - 1; + } + + /// + /// Gets the edge. + /// + /// The index. + /// + public Vector2 GetEdge(int index) + { + int nextIndex = NextIndex(index); + _vectorTemp2 = this[nextIndex]; + _vectorTemp3 = this[index]; + Vector2.Subtract(ref _vectorTemp2, ref _vectorTemp3, out _vectorTemp1); + return _vectorTemp1; + } + + /// + /// Gets the edge. + /// + /// The index. + /// The edge. + public void GetEdge(int index, out Vector2 edge) + { + int nextIndex = NextIndex(index); + _vectorTemp2 = this[nextIndex]; + _vectorTemp3 = this[index]; + Vector2.Subtract(ref _vectorTemp2, ref _vectorTemp3, out edge); + } + + /// + /// Gets the edge mid point. + /// + /// The index. + /// + public Vector2 GetEdgeMidPoint(int index) + { + GetEdge(index, out _vectorTemp1); + Vector2.Multiply(ref _vectorTemp1, .5f, out _vectorTemp2); + + _vectorTemp3 = this[index]; + Vector2.Add(ref _vectorTemp3, ref _vectorTemp2, out _vectorTemp1); + + return _vectorTemp1; + } + + /// + /// Gets the edge mid point. + /// + /// The index. + /// The mid point. + public void GetEdgeMidPoint(int index, out Vector2 midPoint) + { + GetEdge(index, out _vectorTemp1); + Vector2.Multiply(ref _vectorTemp1, .5f, out _vectorTemp2); + _vectorTemp3 = this[index]; + Vector2.Add(ref _vectorTemp3, ref _vectorTemp2, out midPoint); + } + + /// + /// Gets the edge normal. + /// + /// The index. + /// + public Vector2 GetEdgeNormal(int index) + { + GetEdge(index, out _vectorTemp1); + + _vectorTemp2.X = -_vectorTemp1.Y; + _vectorTemp2.Y = _vectorTemp1.X; + + Vector2.Normalize(ref _vectorTemp2, out _vectorTemp3); + + return _vectorTemp3; + } + + /// + /// Gets the edge normal. + /// + /// The index. + /// The edge normal. + public void GetEdgeNormal(int index, out Vector2 edgeNormal) + { + GetEdge(index, out _vectorTemp4); + _vectorTemp5.X = -_vectorTemp4.Y; + _vectorTemp5.Y = _vectorTemp4.X; + Vector2.Normalize(ref _vectorTemp5, out edgeNormal); + } + + /// + /// Gets the vertex normal. + /// + /// The index. + /// + public Vector2 GetVertexNormal(int index) + { + GetEdgeNormal(index, out _vectorTemp1); + + int prevIndex = PreviousIndex(index); + GetEdgeNormal(prevIndex, out _vectorTemp2); + + Vector2.Add(ref _vectorTemp1, ref _vectorTemp2, out _vectorTemp3); + + Vector2.Normalize(ref _vectorTemp3, out _vectorTemp1); + + return _vectorTemp1; + } + + /// + /// Gets the vertex normal. + /// + /// The index. + /// The vertex normal. + public void GetVertexNormal(int index, out Vector2 vertexNormal) + { + GetEdgeNormal(index, out _vectorTemp1); + int prevIndex = PreviousIndex(index); + GetEdgeNormal(prevIndex, out _vectorTemp2); + Vector2.Add(ref _vectorTemp1, ref _vectorTemp2, out _vectorTemp3); + Vector2.Normalize(ref _vectorTemp3, out vertexNormal); + } + + /// + /// Finds the shortest edge. + /// + /// + public float GetShortestEdge() + { + float shortestEdge = float.MaxValue; + for (int i = 0; i < Count; i++) + { + GetEdge(i, out _vectorTemp1); + float length = _vectorTemp1.Length(); + if (length < shortestEdge) + { + shortestEdge = length; + } + } + return shortestEdge; + } + + /// + /// Divides the edges up into the specified length. + /// + /// Length of the max edge. + public void SubDivideEdges(float maxEdgeLength) + { + Vertices verticesTemp = new Vertices(); + for (int i = 0; i < Count; i++) + { + Vector2 vertA = this[i]; + Vector2 vertB = this[NextIndex(i)]; + Vector2 edge; + Vector2.Subtract(ref vertA, ref vertB, out edge); + float edgeLength = edge.Length(); + + verticesTemp.Add(vertA); + if (edgeLength > maxEdgeLength) //need to subdivide + { + double edgeCount = Math.Ceiling(edgeLength / (double)maxEdgeLength); + + for (int j = 0; j < edgeCount - 1; j++) + { + Vector2 vert = Vector2.Lerp(vertA, vertB, (j + 1) / (float)edgeCount); + verticesTemp.Add(vert); + } + } + } + + Clear(); + for (int k = 0; k < verticesTemp.Count; k++) + { + Add(verticesTemp[k]); + } + } + + /// + /// Forces counter clock wise order. + /// + public void ForceCounterClockWiseOrder() + { + // the sign of the 'area' of the polygon is all + // we are interested in. + float area = GetSignedArea(); + if (area > 0) + { + Reverse(); + } + } + + /// + /// Gets the signed area. + /// + /// + private float GetSignedArea() + { + int i; + float area = 0; + + for (i = 0; i < Count; i++) + { + int j = (i + 1) % Count; + area += this[i].X * this[j].Y; + area -= this[i].Y * this[j].X; + } + area /= 2.0f; + return area; + } + + /// + /// Gets the area. + /// + /// + public float GetArea() + { + int i; + float area = 0; + + for (i = 0; i < Count; i++) + { + int j = (i + 1) % Count; + area += this[i].X * this[j].Y; + area -= this[i].Y * this[j].X; + } + area /= 2.0f; + return (area < 0 ? -area : area); + } + + /// + /// Gets the centroid. + /// + /// + public Vector2 GetCentroid() + { + float area = GetArea(); + return GetCentroid(area); + } + + /// + /// Gets the centroid. + /// + /// The area. + /// + public Vector2 GetCentroid(float area) + { + //calc centroid on counter clockwise verts. + Vertices verts = new Vertices(this); + verts.ForceCounterClockWiseOrder(); + + float cx = 0, cy = 0; + int i; + + float factor; + for (i = 0; i < Count; i++) + { + int j = (i + 1) % Count; + + factor = -(verts[i].X * verts[j].Y - verts[j].X * verts[i].Y); + cx += (verts[i].X + verts[j].X) * factor; + cy += (verts[i].Y + verts[j].Y) * factor; + } + area *= 6.0f; + factor = 1 / area; + cx *= factor; + cy *= factor; + _res.X = cx; + _res.Y = cy; + return _res; + } + + /// + /// Gets the moment of inertia from the vertices + /// + /// + /// Can't calculate MOI on zero vertices + public float GetMomentOfInertia() + { + Vertices verts = new Vertices(this); + + //Make sure that the vertices are in counter clockwise order. + verts.ForceCounterClockWiseOrder(); + + //Get the centroid and center the vertices around the centroid. + Vector2 centroid = verts.GetCentroid(); + + Vector2.Multiply(ref centroid, -1, out centroid); + + verts.Translate(ref centroid); + + if (verts.Count == 0) + throw new ArgumentException("Can't calculate MOI on zero vertices"); + + if (verts.Count == 1) + return 0; + + float denom = 0; + float numer = 0; + Vector2 v2; + Vector2 v1 = verts[verts.Count - 1]; + for (int index = 0; index < verts.Count; index++, v1 = v2) + { + v2 = verts[index]; + float a; + Vector2.Dot(ref v2, ref v2, out a); + float b; + Vector2.Dot(ref v2, ref v1, out b); + float c; + Vector2.Dot(ref v1, ref v1, out c); + //Vector2.Cross(ref v1, ref v2, out d); + float d; + Calculator.Cross(ref v1, ref v2, out d); + d = Math.Abs(d); + numer += d; + denom += (a + b + c) * d; + } + return denom / (numer * 6); + } + + /// + /// Projects to axis. + /// + /// The axis. + /// The min. + /// The max. + public void ProjectToAxis(ref Vector2 axis, out float min, out float max) + { + // To project a point on an axis use the dot product + float dotProduct = Vector2.Dot(axis, this[0]); + min = dotProduct; + max = dotProduct; + + for (int i = 0; i < Count; i++) + { + dotProduct = Vector2.Dot(this[i], axis); + if (dotProduct < min) + { + min = dotProduct; + } + else + { + if (dotProduct > max) + { + max = dotProduct; + } + } + } + } + + /// + /// Translates the vertices with the specified vector. + /// + /// The vector. + public void Translate(ref Vector2 vector) + { + for (int i = 0; i < Count; i++) + this[i] = Vector2.Add(this[i], vector); + } + + /// + /// Scales the vertices with the specified vector. + /// + /// The Value. + public void Scale(ref Vector2 value) + { + for (int i = 0; i < Count; i++) + this[i] = Vector2.Multiply(this[i], value); + } + + /// + /// Rotate the vertices with the defined value in radians. + /// + /// The amount to rotate by in radians. + public void Rotate(float value) + { + Matrix rotationMatrix; + Matrix.CreateRotationZ(value, out rotationMatrix); + + for (int i = 0; i < Count; i++) + this[i] = Vector2.Transform(this[i], rotationMatrix); + } + + /// + /// Determines whether this instance is convex. + /// + /// + /// true if this instance is convex; otherwise, false. + /// + public bool IsConvex() + { + bool isPositive = false; + for (int i = 0; i < Count; ++i) + { + int lower = (i == 0) ? (Count - 1) : (i - 1); + int middle = i; + int upper = (i == Count - 1) ? (0) : (i + 1); + + float dx0 = this[middle].X - this[lower].X; + float dy0 = this[middle].Y - this[lower].Y; + float dx1 = this[upper].X - this[middle].X; + float dy1 = this[upper].Y - this[middle].Y; + + float cross = dx0 * dy1 - dx1 * dy0; + // Cross product should have same sign + // for each vertex if poly is convex. + bool newIsP = (cross >= 0) ? true : false; + if (i == 0) + { + isPositive = newIsP; + } + else if (isPositive != newIsP) + { + return false; + } + } + return true; + } + + /// + /// Creates a rectangle with the specified width and height + /// with automatic subdivsion. + /// + /// The width. + /// The height. + /// The vertices that define a rectangle + public static Vertices CreateRectangle(float width, float height) + { + //Note: The rectangle has vertices along the edges. This is to support the distance grid better. + Vertices vertices = new Vertices(); + vertices.Add(new Vector2(-width * .5f, -height * .5f)); + vertices.Add(new Vector2(-width * .5f, -height * .25f)); + vertices.Add(new Vector2(-width * .5f, 0)); + vertices.Add(new Vector2(-width * .5f, height * .25f)); + vertices.Add(new Vector2(-width * .5f, height * .5f)); + vertices.Add(new Vector2(-width * .25f, height * .5f)); + vertices.Add(new Vector2(0, height * .5f)); + vertices.Add(new Vector2(width * .25f, height * .5f)); + vertices.Add(new Vector2(width * .5f, height * .5f)); + vertices.Add(new Vector2(width * .5f, height * .25f)); + vertices.Add(new Vector2(width * .5f, 0)); + vertices.Add(new Vector2(width * .5f, -height * .25f)); + vertices.Add(new Vector2(width * .5f, -height * .5f)); + vertices.Add(new Vector2(width * .25f, -height * .5f)); + vertices.Add(new Vector2(0, -height * .5f)); + vertices.Add(new Vector2(-width * .25f, -height * .5f)); + + return vertices; + } + + /// + /// Creates a rectangle with the specified width and height + /// with no subdivision. + /// + /// The width. + /// The height. + /// The vertices that define a rectangle + public static Vertices CreateSimpleRectangle(float width, float height) + { + Vertices vertices = new Vertices(); + vertices.Add(new Vector2(-width * .5f, -height * .5f)); + vertices.Add(new Vector2(-width * .5f, height * .5f)); + vertices.Add(new Vector2(width * .5f, height * .5f)); + vertices.Add(new Vector2(width * .5f, -height * .5f)); + + return vertices; + } + + /// + /// Creates a circle with the specified radius and number of edges. + /// + /// The radius. + /// The number of edges. The more edges, the more it resembles a circle + /// + public static Vertices CreateCircle(float radius, int numberOfEdges) + { + return CreateEllipse(radius, radius, numberOfEdges); + } + + /// + /// Creates a ellipse with the specified width, height and number of edges. + /// + /// Width of the ellipse. + /// Height of the ellipse. + /// The number of edges. The more edges, the more it resembles an ellipse + /// + public static Vertices CreateEllipse(float xRadius, float yRadius, int numberOfEdges) + { + Vertices vertices = new Vertices(); + + float stepSize = MathHelper.TwoPi / numberOfEdges; + + vertices.Add(new Vector2(xRadius, 0)); + for (int i = 1; i < numberOfEdges; i++) + vertices.Add(new Vector2(xRadius * Calculator.Cos(stepSize * i), -yRadius * Calculator.Sin(stepSize * i))); + + return vertices; + } + + /// + /// Creates a gear shape with the specified radius and number of teeth. + /// + /// The radius. + /// The number of teeth. + /// The tip percentage. + /// Height of the tooth. + /// + public static Vertices CreateGear(float radius, int numberOfTeeth, float tipPercentage, float toothHeight) + { + Vertices vertices = new Vertices(); + + float stepSize = MathHelper.TwoPi / numberOfTeeth; + + float toothTipStepSize = (stepSize / 2f) * tipPercentage; + + float toothAngleStepSize = (stepSize - (toothTipStepSize * 2f)) / 2f; + + for (int i = 0; i < numberOfTeeth; i++) + { + vertices.Add(new Vector2((radius) * Calculator.Cos(stepSize * i), + -(radius) * Calculator.Sin(stepSize * i))); + + vertices.Add(new Vector2((radius + toothHeight) * Calculator.Cos((stepSize * i) + toothAngleStepSize), + -(radius + toothHeight) * Calculator.Sin((stepSize * i) + toothAngleStepSize))); + + vertices.Add(new Vector2((radius + toothHeight) * Calculator.Cos((stepSize * i) + toothAngleStepSize + toothTipStepSize), + -(radius + toothHeight) * Calculator.Sin((stepSize * i) + toothAngleStepSize + toothTipStepSize))); + + vertices.Add(new Vector2((radius) * Calculator.Cos((stepSize * i) + (toothAngleStepSize * 2f) + toothTipStepSize), + -(radius) * Calculator.Sin((stepSize * i) + (toothAngleStepSize * 2f) + toothTipStepSize))); + } + + return vertices; + } + + public override string ToString() + { + StringBuilder builder = new StringBuilder(); + for (int i = 0; i < Count; i++) + { + builder.Append(this[i].ToString()); + if (i < Count - 1) + { + builder.Append(" "); + } + } + return builder.ToString(); + } + + #region Sickbattery's Extension + + /// + /// TODO: + /// 1.) Das Array welches ich bekomme am besten in einen bool array verwandeln. Würde die Geschwindigkeit verbessern + /// + private static readonly int[,] _closePixels = new int[8, 2] { { -1, -1 }, { 0, -1 }, { 1, -1 }, { 1, 0 }, { 1, 1 }, { 0, 1 }, { -1, 1 }, { -1, 0 } }; + + /// + /// Creates vertices from the texture data. + /// + /// The data. + /// The width. + /// The height. + /// + public static Vertices CreatePolygon(uint[] data, int width, int height) + { + PolygonCreationAssistance pca = new PolygonCreationAssistance(data, width, height); + List verts = CreatePolygon(ref pca); + + return verts[0]; + } + + /// + /// Creates a list of vertices from the texture data. + /// + /// The data. + /// The width. + /// The height. + /// The hull tolerance. This argument controls the amount of details found in the detection. + /// The alpha tolerance. + /// if set to true [multi part detection]. + /// if set to true [hole detection]. + /// + public static List CreatePolygon(uint[] data, int width, int height, float hullTolerance, byte alphaTolerance, bool multiPartDetection, bool holeDetection) + { + PolygonCreationAssistance pca = new PolygonCreationAssistance(data, width, height); + pca.HullTolerance = hullTolerance; + pca.AlphaTolerance = alphaTolerance; + pca.MultipartDetection = multiPartDetection; + pca.HoleDetection = holeDetection; + return CreatePolygon(ref pca); + } + + /// + /// Creates a list of vertices. Create a PolygonCreationAssistance that contains all the data needed for detection. + /// + /// The pca. + /// + public static List CreatePolygon(ref PolygonCreationAssistance pca) + { + List polygons = new List(); + + Vertices polygon; + Vertices holePolygon; + + int vertex1Index; + int vertex2Index; + + Vector2? holeEntrance = null; + Vector2? polygonEntrance = null; + + List blackList = new List(); + + bool inPolygon; + bool searchOn; + + // First of all: Check the array you just got. + if (pca.IsValid()) + { + do + { + if (polygons.Count == 0) + { + polygon = CreateSimplePolygon(ref pca, Vector2.Zero, Vector2.Zero); + + if (polygon != null && polygon.Count > 2) + { + polygonEntrance = GetTopMostVertex(ref polygon); + } + } + else if (polygonEntrance.HasValue) + { + polygon = CreateSimplePolygon(ref pca, polygonEntrance.Value, new Vector2(polygonEntrance.Value.X - 1f, polygonEntrance.Value.Y)); + } + else + { + break; + } + + searchOn = false; + + if (polygon != null && polygon.Count > 2) + { + if (pca.HoleDetection) + { + do + { + holeEntrance = GetHoleHullEntrance(ref pca, ref polygon, holeEntrance); + + if (holeEntrance.HasValue) + { + if (!blackList.Contains(holeEntrance.Value)) + { + blackList.Add(holeEntrance.Value); + holePolygon = CreateSimplePolygon(ref pca, holeEntrance.Value, new Vector2(holeEntrance.Value.X + 1, holeEntrance.Value.Y)); + + if (holePolygon != null && holePolygon.Count > 2) + { + holePolygon.Add(holePolygon[0]); + + if (SplitPolygonEdge(ref polygon, EdgeAlignment.Vertical, holeEntrance.Value, out vertex1Index, out vertex2Index)) + { + polygon.InsertRange(vertex2Index, holePolygon); + } + } + } + else + { + break; + } + } + else + { + break; + } + + } while (true); + } + + polygons.Add(polygon); + + if (pca.MultipartDetection) + { + /// 1: 95 / 151 + /// 2: 232 / 252 + /// + while (GetNextHullEntrance(ref pca, polygonEntrance.Value, out polygonEntrance)) + { + inPolygon = false; + + for (int i = 0; i < polygons.Count; i++) + { + polygon = polygons[i]; + + if (InPolygon(ref pca, ref polygon, polygonEntrance.Value)) + { + inPolygon = true; + break; + } + } + + if (!inPolygon) + { + searchOn = true; + break; + } + } + } + } + + } while (searchOn); + } + else + { + throw new Exception("Sizes don't match: Color array must contain texture width * texture height elements."); + } + + return polygons; + } + + private static Vector2? GetHoleHullEntrance(ref PolygonCreationAssistance pca, ref Vertices polygon, Vector2? startVertex) + { + List edges = new List(); + Vector2? entrance; + + int startLine; + int endLine; + + int lastSolid = 0; + bool foundSolid; + bool foundTransparent; + + if (polygon != null && polygon.Count > 0) + { + if (startVertex.HasValue) + { + startLine = (int)startVertex.Value.Y; + } + else + { + startLine = (int)GetTopMostCoord(ref polygon); + } + endLine = (int)GetBottomMostCoord(ref polygon); + + if (startLine > 0 && startLine < pca.Height && endLine > 0 && endLine < pca.Height) + { + // go from top to bottom of the polygon + for (int y = startLine; y <= endLine; y += pca.HoleDetectionLineStepSize) + { + // get x-coord of every polygon edge which crosses y + edges = GetCrossingEdges(ref polygon, EdgeAlignment.Vertical, y); + + // we need an even number of crossing edges + if (edges.Count > 1 && edges.Count % 2 == 0) + { + for (int i = 0; i < edges.Count; i += 2) + { + foundSolid = false; + foundTransparent = false; + + for (int x = (int)edges[i].CrossingPoint.X; x <= (int)edges[i + 1].CrossingPoint.X; x++) + { + if (pca.IsSolid(x, y)) + { + if (!foundTransparent) + { + foundSolid = true; + lastSolid = x; + } + + if (foundSolid && foundTransparent) + { + entrance = new Vector2(lastSolid, y); + + if (DistanceToHullAcceptable(ref pca, ref polygon, entrance.Value, true)) + { + return entrance; + } + entrance = null; + break; + } + } + else + { + if (foundSolid) + { + foundTransparent = true; + } + } + } + } + } + } + } + } + + return null; + } + + private static bool DistanceToHullAcceptable(ref PolygonCreationAssistance pca, ref Vertices polygon, Vector2 point, bool higherDetail) + { + Vector2 edgeVertex1; + Vector2 edgeVertex2; + + if (polygon != null && polygon.Count > 2) + { + edgeVertex2 = polygon[polygon.Count - 1]; + + if (higherDetail) + { + for (int i = 0; i < polygon.Count; i++) + { + edgeVertex1 = polygon[i]; + + if (Calculator.DistanceBetweenPointAndLineSegment(point, edgeVertex1, edgeVertex2) <= pca.HullTolerance || + Calculator.DistanceBetweenPointAndPoint(ref point, ref edgeVertex1) <= pca.HullTolerance) + { + return false; + } + + edgeVertex2 = polygon[i]; + } + + return true; + } + else + { + for (int i = 0; i < polygon.Count; i++) + { + edgeVertex1 = polygon[i]; + + if (Calculator.DistanceBetweenPointAndLineSegment(point, edgeVertex1, edgeVertex2) <= pca.HullTolerance) + { + return false; + } + + edgeVertex2 = polygon[i]; + } + + return true; + } + } + + return false; + } + + private static bool InPolygon(ref PolygonCreationAssistance pca, ref Vertices polygon, Vector2 point) + { + bool inPolygon = !DistanceToHullAcceptable(ref pca, ref polygon, point, true); + + if (!inPolygon) + { + List edges = GetCrossingEdges(ref polygon, EdgeAlignment.Vertical, (int)point.Y); + + if (edges.Count > 0 && edges.Count % 2 == 0) + { + for (int i = 0; i < edges.Count; i += 2) + { + if (edges[i].CrossingPoint.X <= point.X && edges[i + 1].CrossingPoint.X >= point.X) + { + return true; + } + } + + return false; + } + return false; + } + + return inPolygon; + } + + private static Vector2? GetTopMostVertex(ref Vertices vertices) + { + float topMostValue = float.MaxValue; + Vector2? topMost = null; + + for (int i = 0; i < vertices.Count; i++) + { + if (topMostValue > vertices[i].Y) + { + topMostValue = vertices[i].Y; + topMost = vertices[i]; + } + } + + return topMost; + } + + private static float GetTopMostCoord(ref Vertices vertices) + { + float returnValue = float.MaxValue; + + for (int i = 0; i < vertices.Count; i++) + { + if (returnValue > vertices[i].Y) + { + returnValue = vertices[i].Y; + } + } + + return returnValue; + } + + private static float GetBottomMostCoord(ref Vertices vertices) + { + float returnValue = float.MinValue; + + for (int i = 0; i < vertices.Count; i++) + { + if (returnValue < vertices[i].Y) + { + returnValue = vertices[i].Y; + } + } + + return returnValue; + } + + private static List GetCrossingEdges(ref Vertices polygon, EdgeAlignment edgeAlign, int checkLine) + { + List edges = new List(); + + Vector2 slope; + Vector2 edgeVertex1; + Vector2 edgeVertex2; + + Vector2 slopePreview; + Vector2 edgeVertexPreview; + + Vector2 crossingPoint; + bool addCrossingPoint; + + if (polygon.Count > 1) + { + edgeVertex2 = polygon[polygon.Count - 1]; + + switch (edgeAlign) + { + case EdgeAlignment.Vertical: + for (int i = 0; i < polygon.Count; i++) + { + edgeVertex1 = polygon[i]; + + if ((edgeVertex1.Y >= checkLine && edgeVertex2.Y <= checkLine) || (edgeVertex1.Y <= checkLine && edgeVertex2.Y >= checkLine)) + { + if (edgeVertex1.Y != edgeVertex2.Y) + { + addCrossingPoint = true; + slope = edgeVertex2 - edgeVertex1; + + if (edgeVertex1.Y == checkLine) + { + edgeVertexPreview = polygon[(i + 1) % polygon.Count]; + slopePreview = edgeVertex1 - edgeVertexPreview; + + if (slope.Y > 0) + { + addCrossingPoint = (slopePreview.Y <= 0); + } + else + { + addCrossingPoint = (slopePreview.Y >= 0); + } + } + + if (addCrossingPoint) + { + crossingPoint = new Vector2((checkLine - edgeVertex1.Y) / slope.Y * slope.X + edgeVertex1.X, (float)checkLine); + edges.Add(new CrossingEdgeInfo(edgeVertex1, edgeVertex2, crossingPoint, edgeAlign)); + } + } + } + edgeVertex2 = edgeVertex1; + } + break; + + case EdgeAlignment.Horizontal: + throw new Exception("EdgeAlignment.Horizontal isn't implemented yet. Sorry."); + } + } + + edges.Sort(); + return edges; + } + + private static bool SplitPolygonEdge(ref Vertices polygon, EdgeAlignment edgeAlign, Vector2 coordInsideThePolygon, out int vertex1Index, out int vertex2Index) + { + List edges = new List(); + + Vector2 slope; + int edgeVertex1Index; + int edgeVertex2Index; + int nearestEdgeVertex1Index = 0; + int nearestEdgeVertex2Index = 0; + bool edgeFound = false; + + float distance; + float shortestDistance = float.MaxValue; + + bool edgeCoordFound = false; + Vector2 foundEdgeCoord = Vector2.Zero; + + vertex1Index = 0; + vertex2Index = 0; + + switch (edgeAlign) + { + case EdgeAlignment.Vertical: + edges = GetCrossingEdges(ref polygon, EdgeAlignment.Vertical, (int)coordInsideThePolygon.Y); + + foundEdgeCoord.Y = coordInsideThePolygon.Y; + + if (edges != null && edges.Count > 1 && edges.Count % 2 == 0) + { + for (int i = 0; i < edges.Count; i++) + { + if (edges[i].CrossingPoint.X < coordInsideThePolygon.X) + { + distance = coordInsideThePolygon.X - edges[i].CrossingPoint.X; + + if (distance < shortestDistance) + { + shortestDistance = distance; + foundEdgeCoord.X = edges[i].CrossingPoint.X; + + edgeCoordFound = true; + } + } + } + + if (edgeCoordFound) + { + shortestDistance = float.MaxValue; + + edgeVertex2Index = polygon.Count - 1; + + for (edgeVertex1Index = 0; edgeVertex1Index < polygon.Count; edgeVertex1Index++) + { + distance = Calculator.DistanceBetweenPointAndLineSegment(foundEdgeCoord, + polygon[edgeVertex1Index], + polygon[edgeVertex2Index]); + if (distance < shortestDistance) + { + shortestDistance = distance; + + nearestEdgeVertex1Index = edgeVertex1Index; + nearestEdgeVertex2Index = edgeVertex2Index; + + edgeFound = true; + } + + edgeVertex2Index = edgeVertex1Index; + } + + if (edgeFound) + { + slope = polygon[nearestEdgeVertex2Index] - polygon[nearestEdgeVertex1Index]; + slope.Normalize(); + + distance = Calculator.DistanceBetweenPointAndPoint(polygon[nearestEdgeVertex1Index], + foundEdgeCoord); + + vertex1Index = nearestEdgeVertex1Index; + vertex2Index = nearestEdgeVertex1Index + 1; + + polygon.Insert(nearestEdgeVertex1Index, distance * slope + polygon[vertex1Index]); + polygon.Insert(nearestEdgeVertex1Index, distance * slope + polygon[vertex2Index]); + + return true; + } + } + } + break; + + case EdgeAlignment.Horizontal: + throw new Exception("EdgeAlignment.Horizontal isn't implemented yet. Sorry."); + } + + return false; + } + + private static Vertices CreateSimplePolygon(ref PolygonCreationAssistance pca, Vector2 entrance, Vector2 last) + { + bool entranceFound = false; + + Vertices polygon = new Vertices(); + Vertices hullArea = new Vertices(); + + Vector2 current = Vector2.Zero; + Vector2 next; + + #region Entrance check + // Get the entrance point. //todo: alle möglichkeiten testen + if (entrance == Vector2.Zero || !pca.InBounds(entrance)) + { + entranceFound = GetHullEntrance(ref pca, out entrance); + + if (entranceFound) + { + current = new Vector2(entrance.X - 1f, entrance.Y); + } + } + else + { + if (pca.IsSolid(entrance)) + { + if (IsNearPixel(ref pca, entrance, last)) + { + current = last; + entranceFound = true; + } + else + { + Vector2 temp; + if (SearchNearPixels(ref pca, false, entrance, out temp)) + { + current = temp; + entranceFound = true; + } + else + { + entranceFound = false; + } + } + } + } + #endregion + + if (entranceFound) + { + + // next has to be set to entrance so it'll be added as the + // first point in the list. + next = entrance; + + // Fast bugfix XD. The entrance point of course has to be added first to the polygon XD. Damn I forgot that! + polygon.Add(entrance); + + do + { + Vector2 outstanding; + + // Add the vertex to a hull pre vision list. + hullArea.Add(next); + + // Search in the pre vision list for an outstanding point. + if (SearchForOutstandingVertex(ref hullArea, pca.HullTolerance, out outstanding)) + { + // Add it and remove all vertices that don't matter anymore + // (all the vertices before the outstanding). + polygon.Add(outstanding); + hullArea.RemoveRange(0, hullArea.IndexOf(outstanding)); + } + + // Last point gets current and current gets next. Our little spider is moving forward on the hull ;). + last = current; + current = next; + + // Get the next point on hull. + if (!GetNextHullPoint(ref pca, ref last, ref current, out next)) + { + next = entrance; + } + } // Exit loop if next piont is the entrance point. The hull is complete now! + while (next != entrance); + } + + return polygon; + } + + private static bool SearchNearPixels(ref PolygonCreationAssistance pca, bool searchingForSolidPixel, Vector2 current, out Vector2 foundPixel) + { + int x; + int y; + + for (int i = 0; i < 8; i++) + { + x = (int)current.X + _closePixels[i, 0]; + y = (int)current.Y + _closePixels[i, 1]; + + if (!searchingForSolidPixel ^ pca.IsSolid(x, y)) + { + foundPixel = new Vector2(x, y); + return true; + } + } + + // Nothing found. + foundPixel = Vector2.Zero; + return false; + } + + private static bool IsNearPixel(ref PolygonCreationAssistance pca, Vector2 current, Vector2 near) + { + for (int i = 0; i < 8; i++) + { + int x = (int)current.X + _closePixels[i, 0]; + int y = (int)current.Y + _closePixels[i, 1]; + + if (x >= 0 && x <= pca.Width && y >= 0 && y <= pca.Height) + { + if (x == (int)near.X && y == (int)near.Y) + { + return true; + } + } + } + + return false; + } + + private static bool GetHullEntrance(ref PolygonCreationAssistance pca, out Vector2 entrance) + { + // Search for first solid pixel. + for (int y = 0; y <= pca.Height; y++) + { + for (int x = 0; x <= pca.Width; x++) + { + if (pca.IsSolid(x, y)) + { + entrance = new Vector2(x, y); + return true; + } + } + } + + // If there are no solid pixels. + entrance = Vector2.Zero; + return false; + } + + private static bool GetNextHullEntrance(ref PolygonCreationAssistance pca, Vector2 start, out Vector2? entrance) + { + // Search for first solid pixel. + int size = pca.Height * pca.Width; + int x; + + bool foundTransparent = false; + + for (int i = (int)start.X + (int)start.Y * pca.Width; i <= size; i++) + { + if (pca.IsSolid(i)) + { + if (foundTransparent) + { + x = i % pca.Width; + + entrance = new Vector2(x, (i - x) / pca.Width); + return true; + } + } + else + { + foundTransparent = true; + } + } + + // If there are no solid pixels. + entrance = null; + return false; + } + + private static bool GetNextHullPoint(ref PolygonCreationAssistance pca, ref Vector2 last, ref Vector2 current, out Vector2 next) + { + int x; + int y; + + int indexOfFirstPixelToCheck = GetIndexOfFirstPixelToCheck(last, current); + int indexOfPixelToCheck; + + const int pixelsToCheck = 8;// _closePixels.Length; + + for (int i = 0; i < pixelsToCheck; i++) + { + indexOfPixelToCheck = (indexOfFirstPixelToCheck + i) % pixelsToCheck; + + x = (int)current.X + _closePixels[indexOfPixelToCheck, 0]; + y = (int)current.Y + _closePixels[indexOfPixelToCheck, 1]; + + if (x >= 0 && x < pca.Width && y >= 0 && y <= pca.Height) + { + if (pca.IsSolid(x, y)) //todo + { + next = new Vector2(x, y); + return true; + } + } + } + + next = Vector2.Zero; + return false; + } + + private static bool SearchForOutstandingVertex(ref Vertices hullArea, float hullTolerance, out Vector2 outstanding) + { + int hullAreaLastPoint = hullArea.Count - 1; + + Vector2 outstandingResult = Vector2.Zero; + bool found = false; + + // Search between the first and last hull point. + for (int i = 1; i < hullAreaLastPoint; i++) + { + // Check if the distance is over the one that's tolerable. + if (Calculator.DistanceBetweenPointAndLineSegment(hullArea[i], hullArea[0], hullArea[hullAreaLastPoint]) >= hullTolerance) + { + outstandingResult = hullArea[i]; + found = true; + break; + } + } + + outstanding = outstandingResult; + return found; + } + + private static int GetIndexOfFirstPixelToCheck(Vector2 last, Vector2 current) + { + /// .: pixel + /// l: last position + /// c: current position + /// f: first pixel for next search + + /// f . . + /// l c . + /// . . . + + //Calculate in which direction the last move went and decide over the next first pixel. + switch ((int)(current.X - last.X)) + { + case 1: + switch ((int)(current.Y - last.Y)) + { + case 1: + return 1; + + case 0: + return 0; + + case -1: + return 7; + } + break; + + case 0: + switch ((int)(current.Y - last.Y)) + { + case 1: + return 2; + + case -1: + return 6; + } + break; + + case -1: + switch ((int)(current.Y - last.Y)) + { + case 1: + return 3; + + case 0: + return 4; + + case -1: + return 5; + } + break; + } + + return 0; + } + #endregion + + #region DrDeth's Extension + + /// + /// Merges two polygons, given that they intersect. + /// + /// The first polygon. + /// The second polygon. + /// The error returned from union + /// The union of the two polygons, or null if there was an error. + public static Vertices Union(Vertices polygon1, Vertices polygon2, out PolyUnionError error) + { + Vertices poly1; + Vertices poly2; + List intersections; + + int startingIndex = PreparePolygons(polygon1, polygon2, out poly1, out poly2, out intersections, out error); + + if (startingIndex == -1) + { + switch (error) + { + case PolyUnionError.NoIntersections: + return null; + + case PolyUnionError.Poly1InsidePoly2: + return polygon2; + } + } + + Vertices union = new Vertices(); + Vertices currentPoly = poly1; + Vertices otherPoly = poly2; + + // Store the starting vertex so we can refer to it later. + Vector2 startingVertex = poly1[startingIndex]; + int currentIndex = startingIndex; + + do + { + // Add the current vertex to the final union + union.Add(currentPoly[currentIndex]); + + foreach (EdgeIntersectInfo intersect in intersections) + { + // If the current point is an intersection point + if (currentPoly[currentIndex] == intersect.IntersectionPoint) + { + // Make sure we want to swap polygons here. + int otherIndex = otherPoly.IndexOf(intersect.IntersectionPoint); + + // If the next vertex, if we do swap, is not inside the current polygon, + // then its safe to swap, otherwise, just carry on with the current poly. + if (!PointInPolygonAngle(otherPoly[otherPoly.NextIndex(otherIndex)], currentPoly)) + { + // switch polygons + if (currentPoly == poly1) + { + currentPoly = poly2; + otherPoly = poly1; + } + else + { + currentPoly = poly1; + otherPoly = poly2; + } + + // set currentIndex + currentIndex = otherIndex; + + // Stop checking intersections for this point. + break; + } + } + } + + // Move to next index + currentIndex = currentPoly.NextIndex(currentIndex); + } while ((currentPoly[currentIndex] != startingVertex) && (union.Count <= (poly1.Count + poly2.Count))); + + + // If the number of vertices in the union is more than the combined vertices + // of the input polygons, then something is wrong and the algorithm will + // loop forever. Luckily, we check for that. + if (union.Count > (poly1.Count + poly2.Count)) + { + error = PolyUnionError.InfiniteLoop; + } + + return union; + } + + /// + /// Subtracts one polygon from another. + /// + /// The base polygon. + /// The polygon to subtract from the base. + /// The error. + /// + /// The result of the polygon subtraction, or null if there was an error. + /// + public static Vertices Subtract(Vertices polygon1, Vertices polygon2, out PolyUnionError error) + { + Vertices poly1; + Vertices poly2; + List intersections; + + int startingIndex = PreparePolygons(polygon1, polygon2, out poly1, out poly2, out intersections, out error); + + if (startingIndex == -1) + { + switch (error) + { + case PolyUnionError.NoIntersections: + return null; + + case PolyUnionError.Poly1InsidePoly2: + return null; + } + } + + Vertices subtract = new Vertices(); + Vertices currentPoly = poly1; + Vertices otherPoly = poly2; + + // Store the starting vertex so we can refer to it later. + Vector2 startingVertex = poly1[startingIndex]; + int currentIndex = startingIndex; + + // Trace direction + bool forward = true; + + do + { + // Add the current vertex to the final union + subtract.Add(currentPoly[currentIndex]); + + foreach (EdgeIntersectInfo intersect in intersections) + { + // If the current point is an intersection point + if (currentPoly[currentIndex] == intersect.IntersectionPoint) + { + // Make sure we want to swap polygons here. + int otherIndex = otherPoly.IndexOf(intersect.IntersectionPoint); + + Vector2 otherVertex; + if (forward) + { + otherVertex = otherPoly[otherPoly.PreviousIndex(otherIndex)]; + + // If the next vertex, if we do swap, is inside the current polygon, + // then its safe to swap, otherwise, just carry on with the current poly. + if (PointInPolygonAngle(otherVertex, currentPoly)) + { + // switch polygons + if (currentPoly == poly1) + { + currentPoly = poly2; + otherPoly = poly1; + } + else + { + currentPoly = poly1; + otherPoly = poly2; + } + + // set currentIndex + currentIndex = otherIndex; + + // Reverse direction + forward = !forward; + + // Stop checking intersections for this point. + break; + } + } + else + { + otherVertex = otherPoly[otherPoly.NextIndex(otherIndex)]; + + // If the next vertex, if we do swap, is outside the current polygon, + // then its safe to swap, otherwise, just carry on with the current poly. + if (!PointInPolygonAngle(otherVertex, currentPoly)) + { + // switch polygons + if (currentPoly == poly1) + { + currentPoly = poly2; + otherPoly = poly1; + } + else + { + currentPoly = poly1; + otherPoly = poly2; + } + + // set currentIndex + currentIndex = otherIndex; + + // Reverse direction + forward = !forward; + + // Stop checking intersections for this point. + break; + } + } + } + } + + if (forward) + { + // Move to next index + currentIndex = currentPoly.NextIndex(currentIndex); + } + else + { + currentIndex = currentPoly.PreviousIndex(currentIndex); + } + } while ((currentPoly[currentIndex] != startingVertex) && + (subtract.Count <= (poly1.Count + poly2.Count))); + + + // If the number of vertices in the union is more than the combined vertices + // of the input polygons, then something is wrong and the algorithm will + // loop forever. Luckily, we check for that. + if (subtract.Count > (poly1.Count + poly2.Count)) + { + error = PolyUnionError.InfiniteLoop; + } + + return subtract; + } + + /// + /// Finds the intersection between two polygons. + /// + /// The first polygon. + /// The second polygon. + /// The error. + /// + /// The intersection of the two polygons, or null if there was an error. + /// + public static Vertices Intersect(Vertices polygon1, Vertices polygon2, out PolyUnionError error) + { + error = PolyUnionError.None; + + Vertices poly1; + Vertices poly2; + List intersections; + + PolyUnionError gotError; + int startingIndex = PreparePolygons(polygon1, polygon2, out poly1, out poly2, out intersections, out gotError); + + if (startingIndex == -1) + { + switch (gotError) + { + case PolyUnionError.NoIntersections: + return null; + + case PolyUnionError.Poly1InsidePoly2: + return polygon2; + } + } + + Vertices intersectOut = new Vertices(); + Vertices currentPoly = poly1; + Vertices otherPoly = poly2; + + // Store the starting vertex so we can refer to it later. + int currentIndex = poly1.IndexOf(intersections[0].IntersectionPoint); + Vector2 startingVertex = poly1[currentIndex]; + + do + { + // Add the current vertex to the final union + intersectOut.Add(currentPoly[currentIndex]); + + foreach (EdgeIntersectInfo intersect in intersections) + { + // If the current point is an intersection point + if (currentPoly[currentIndex] == intersect.IntersectionPoint) + { + // Make sure we want to swap polygons here. + int otherIndex = otherPoly.IndexOf(intersect.IntersectionPoint); + + // If the next vertex, if we do swap, is inside the current polygon, + // then its safe to swap, otherwise, just carry on with the current poly. + if (PointInPolygonAngle(otherPoly[otherPoly.NextIndex(otherIndex)], currentPoly)) + { + // switch polygons + if (currentPoly == poly1) + { + currentPoly = poly2; + otherPoly = poly1; + } + else + { + currentPoly = poly1; + otherPoly = poly2; + } + + // set currentIndex + currentIndex = otherIndex; + + // Stop checking intersections for this point. + break; + } + } + } + + // Move to next index + currentIndex = currentPoly.NextIndex(currentIndex); + } while ((currentPoly[currentIndex] != startingVertex) && + (intersectOut.Count <= (poly1.Count + poly2.Count))); + + + // If the number of vertices in the union is more than the combined vertices + // of the input polygons, then something is wrong and the algorithm will + // loop forever. Luckily, we check for that. + if (intersectOut.Count > (poly1.Count + poly2.Count)) + { + error = PolyUnionError.InfiniteLoop; + } + + return intersectOut; + } + + /// + /// Prepares the polygons. + /// + /// The polygon1. + /// The polygon2. + /// The poly1. + /// The poly2. + /// The intersections. + /// The error. + /// + private static int PreparePolygons(Vertices polygon1, Vertices polygon2, out Vertices poly1, out Vertices poly2, + out List intersections, out PolyUnionError error) + { + error = PolyUnionError.None; + + // Make a copy of the polygons so that we dont modify the originals, and + // force vertices to integer (pixel) values. + poly1 = Round(polygon1); + + poly2 = Round(polygon2); + + // Find intersection points + intersections = new List(); + if (!VerticesIntersect(poly1, poly2, ref intersections)) + { + // No intersections found - polygons do not overlap. + error = PolyUnionError.NoIntersections; + return -1; + } + + // Add intersection points to original polygons, ignoring existing points. + foreach (EdgeIntersectInfo intersect in intersections) + { + if (!poly1.Contains(intersect.IntersectionPoint)) + { + poly1.Insert(poly1.IndexOf(intersect.EdgeOne.EdgeStart) + 1, intersect.IntersectionPoint); + } + + if (!poly2.Contains(intersect.IntersectionPoint)) + { + poly2.Insert(poly2.IndexOf(intersect.EdgeTwo.EdgeStart) + 1, intersect.IntersectionPoint); + } + } + + // Find starting point on the edge of polygon1 + // that is outside of the intersected area + // to begin polygon trace. + int startingIndex = -1; + int currentIndex = 0; + do + { + if (!PointInPolygonAngle(poly1[currentIndex], poly2)) + { + startingIndex = currentIndex; + break; + } + currentIndex = poly1.NextIndex(currentIndex); + } while (currentIndex != 0); + + // If we dont find a point on polygon1 thats outside of the + // intersect area, the polygon1 must be inside of polygon2, + // in which case, polygon2 IS the union of the two. + if (startingIndex == -1) + { + error = PolyUnionError.Poly1InsidePoly2; + } + + return startingIndex; + } + + /// + /// Check and return polygon intersections + /// + /// + /// + /// + /// + private static bool VerticesIntersect(Vertices polygon1, Vertices polygon2, + ref List intersections) + { + // Make sure the output is clear before we start. + intersections.Clear(); + + // Iterate through polygon1's edges + for (int i = 0; i < polygon1.Count; i++) + { + // Get edge vertices + Vector2 p1 = polygon1[i]; + Vector2 p2 = polygon1[polygon1.NextIndex(i)]; + + // Get intersections between this edge and polygon2 + for (int j = 0; j < polygon2.Count; j++) + { + Vector2 point = Vector2.Zero; + + Vector2 p3 = polygon2[j]; + Vector2 p4 = polygon2[polygon2.NextIndex(j)]; + + // _defaultFloatTolerance = .00001f (Perhaps this should be made available publically from CollisionHelper? + + // Check if the edges intersect + if (true) //(CollisionHelper.LineIntersect(p1, p2, p3, p4, true, true, 0.00001f, out point)) + { + + //throw new NotImplementedException("Commented out"); + + // Here, we round the returned intersection point to its nearest whole number. + // This prevents floating point anomolies where 99.9999-> is returned instead of 100. + point = new Vector2((float)Math.Round(point.X, 0), (float)Math.Round(point.Y, 0)); + // Record the intersection + intersections.Add(new EdgeIntersectInfo(new Edge(p1, p2), new Edge(p3, p4), point)); + } + } + } + + // true if any intersections were found. + return (intersections.Count > 0); + } + + /// + /// * ref: http://ozviz.wasp.uwa.edu.au/~pbourke/geometry/insidepoly/ - Solution 2 + /// * Compute the sum of the angles made between the test point and each pair of points making up the polygon. + /// * If this sum is 2pi then the point is an interior point, if 0 then the point is an exterior point. + /// + private static bool PointInPolygonAngle(Vector2 point, Vertices polygon) + { + double angle = 0; + + // Iterate through polygon's edges + for (int i = 0; i < polygon.Count; i++) + { + /* + p1.h = polygon[i].h - p.h; + p1.v = polygon[i].v - p.v; + p2.h = polygon[(i + 1) % n].h - p.h; + p2.v = polygon[(i + 1) % n].v - p.v; + */ + // Get points + Vector2 p1 = polygon[i] - point; + Vector2 p2 = polygon[polygon.NextIndex(i)] - point; + + angle += VectorAngle(p1, p2); + } + + if (Math.Abs(angle) < Math.PI) + { + return false; + } + + return true; + } + + /// + /// Return the angle between two vectors on a plane + /// The angle is from vector 1 to vector 2, positive anticlockwise + /// The result is between -pi -> pi + /// + private static double VectorAngle(Vector2 p1, Vector2 p2) + { + double theta1 = Math.Atan2(p1.Y, p1.X); + double theta2 = Math.Atan2(p2.Y, p2.X); + double dtheta = theta2 - theta1; + while (dtheta > Math.PI) + dtheta -= (2 * Math.PI); + while (dtheta < -Math.PI) + dtheta += (2 * Math.PI); + + return (dtheta); + } + + /// + /// Rounds vertices X and Y values to whole numbers. + /// + /// The polygon whose vertices should be rounded. + /// A new polygon with rounded vertices. + public static Vertices Round(Vertices polygon) + { + Vertices returnPoly = new Vertices(); + for (int i = 0; i < polygon.Count; i++) + returnPoly.Add(new Vector2((float)Math.Round(polygon[i].X, 0), (float)Math.Round(polygon[i].Y, 0))); + + return returnPoly; + } + + /// + /// Determines if three vertices are collinear (ie. on a straight line) + /// + /// Vertex 1 + /// Vertex 2 + /// Vertex 3 + /// + private static bool VerticesAreCollinear(Vector2 p1, Vector2 p2, Vector2 p3) + { + double collinearity = (p3.X - p1.X) * (p2.Y - p1.Y) + (p3.Y - p1.Y) * (p1.X - p2.X); + return (collinearity == 0); + } + + /// + /// Simple polygon simplification. + /// + /// The polygon that needs simplification. + /// The distance bias (in pixels) between points. Points closer than this will be 'joined'. + /// A simplified polygon. + public static Vertices Simplify(Vertices polygon, int bias) + { + //We can't simplify polygons under 3 vertices + if (polygon.Count < 3) + return polygon; + + Vertices simplified = new Vertices(); + Vertices roundPolygon = Round(polygon); + + for (int curr = 0; curr < roundPolygon.Count; curr++) + { + int prev = roundPolygon.PreviousIndex(curr); + int next = roundPolygon.NextIndex(curr); + + if ((roundPolygon[prev] - roundPolygon[curr]).Length() <= bias) + continue; + + if (!VerticesAreCollinear(roundPolygon[prev], roundPolygon[curr], roundPolygon[next])) + simplified.Add(roundPolygon[curr]); + } + + return simplified; + } + + /// + /// Simple polygon simplification. + /// + /// The polygon that needs simplification. + /// A simplified polygon. + public static Vertices Simplify(Vertices polygon) + { + return Simplify(polygon, 0); + } + + #endregion + + #region Yobiv's Extension + /// + /// Creates an capsule with the specified height, radius and number of edges. + /// A capsule has the same form as a pill capsule. + /// + /// Height (inner height + 2 * radius) of the capsule. + /// Radius of the capsule ends. + /// The number of edges of the capsule ends. The more edges, the more it resembles an capsule + /// + public static Vertices CreateCapsule(float height, float endRadius, int edges) + { + if (endRadius >= height / 2) + throw new ArgumentException("The radius must be lower than height / 2. Higher values of radius would create a circle, and not a half circle.", "endRadius"); + + return CreateCapsule(height, endRadius, edges, endRadius, edges); + } + + /// + /// Creates an capsule with the specified height, radius and number of edges. + /// A capsule has the same form as a pill capsule. + /// + /// Height (inner height + radii) of the capsule. + /// Radius of the top. + /// The number of edges of the top. The more edges, the more it resembles an capsule + /// Radius of bottom. + /// The number of edges of the bottom. The more edges, the more it resembles an capsule + /// + public static Vertices CreateCapsule(float height, float topRadius, int topEdges, float bottomRadius, int bottomEdges) + { + if (height <= 0) + throw new ArgumentException("Height must be longer than 0", "height"); + + if (topRadius <= 0) + throw new ArgumentException("The top radius must be more than 0", "topRadius"); + + if (topEdges <= 0) + throw new ArgumentException("Top edges must be more than 0", "topEdges"); + + if (bottomRadius <= 0) + throw new ArgumentException("The bottom radius must be more than 0", "bottomRadius"); + + if (bottomEdges <= 0) + throw new ArgumentException("Bottom edges must be more than 0", "bottomEdges"); + + if (topRadius >= height / 2) + throw new ArgumentException("The top radius must be lower than height / 2. Higher values of top radius would create a circle, and not a half circle.", "topRadius"); + + if (bottomRadius >= height / 2) + throw new ArgumentException("The bottom radius must be lower than height / 2. Higher values of bottom radius would create a circle, and not a half circle.", "bottomRadius"); + + Vertices vertices = new Vertices(); + + float newHeight = (height - topRadius - bottomRadius) * 0.5f; + + // top + vertices.Add(new Vector2(topRadius, newHeight)); + + float stepSize = MathHelper.Pi / topEdges; + for (int i = 1; i < topEdges; i++) + { + vertices.Add(new Vector2(topRadius * Calculator.Cos(stepSize * i), topRadius * Calculator.Sin(stepSize * i) + newHeight)); + } + + vertices.Add(new Vector2(-topRadius, newHeight)); + + // bottom + vertices.Add(new Vector2(-bottomRadius, -newHeight)); + + stepSize = MathHelper.Pi / bottomEdges; + for (int i = 1; i < bottomEdges; i++) + { + vertices.Add(new Vector2(-bottomRadius * Calculator.Cos(stepSize * i), -bottomRadius * Calculator.Sin(stepSize * i) - newHeight)); + } + + vertices.Add(new Vector2(bottomRadius, -newHeight)); + + return vertices; + } + #endregion + + #region Matt Bettcher's Extension + + #region Fields + + static readonly IndexableCyclicalLinkedList polygonVertices = new IndexableCyclicalLinkedList(); + static readonly IndexableCyclicalLinkedList earVertices = new IndexableCyclicalLinkedList(); + static readonly CyclicalList convexVertices = new CyclicalList(); + static readonly CyclicalList reflexVertices = new CyclicalList(); + + #endregion + + #region Vertex + + struct Vertex + { + public readonly Vector2 Position; + public readonly short Index; + + public Vertex(Vector2 position, short index) + { + Position = position; + Index = index; + } + + public override bool Equals(object obj) + { + if (obj.GetType() != typeof(Vertex)) + return false; + return Equals((Vertex)obj); + } + + public bool Equals(Vertex obj) + { + return obj.Position.Equals(Position) && obj.Index == Index; + } + + public override int GetHashCode() + { + unchecked + { + return (Position.GetHashCode() * 397) ^ Index; + } + } + + public override string ToString() + { + return string.Format("{0} ({1})", Position, Index); + } + } + #endregion + + #region LineSegment + + struct LineSegment + { + public Vertex A; + public Vertex B; + + public LineSegment(Vertex a, Vertex b) + { + A = a; + B = b; + } + + public float? IntersectsWithRay(Vector2 origin, Vector2 direction) + { + float largestDistance = MathHelper.Max(A.Position.X - origin.X, B.Position.X - origin.X) * 2f; + LineSegment raySegment = new LineSegment(new Vertex(origin, 0), new Vertex(origin + (direction * largestDistance), 0)); + + Vector2? intersection = FindIntersection(this, raySegment); + float? value = null; + + if (intersection != null) + value = Vector2.Distance(origin, intersection.Value); + + return value; + } + + public static Vector2? FindIntersection(LineSegment a, LineSegment b) + { + float x1 = a.A.Position.X; + float y1 = a.A.Position.Y; + float x2 = a.B.Position.X; + float y2 = a.B.Position.Y; + float x3 = b.A.Position.X; + float y3 = b.A.Position.Y; + float x4 = b.B.Position.X; + float y4 = b.B.Position.Y; + + float denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); + + float uaNum = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3); + float ubNum = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3); + + float ua = uaNum / denom; + float ub = ubNum / denom; + + if (MathHelper.Clamp(ua, 0f, 1f) != ua || MathHelper.Clamp(ub, 0f, 1f) != ub) + return null; + + return a.A.Position + (a.B.Position - a.A.Position) * ua; + } + } + + #endregion + + #region Triangle + + /// + /// A basic triangle structure that holds the three vertices that make up a given triangle. + /// + struct Triangle + { + public readonly Vertex A; + public readonly Vertex B; + public readonly Vertex C; + + public Triangle(Vertex a, Vertex b, Vertex c) + { + A = a; + B = b; + C = c; + } + + public bool ContainsPoint(Vertex point) + { + //return true if the point to test is one of the vertices + if (point.Equals(A) || point.Equals(B) || point.Equals(C)) + return true; + + bool oddNodes = false; + + if (checkPointToSegment(C, A, point)) + oddNodes = !oddNodes; + if (checkPointToSegment(A, B, point)) + oddNodes = !oddNodes; + if (checkPointToSegment(B, C, point)) + oddNodes = !oddNodes; + + return oddNodes; + } + + public static bool ContainsPoint(Vertex a, Vertex b, Vertex c, Vertex point) + { + return new Triangle(a, b, c).ContainsPoint(point); + } + + static bool checkPointToSegment(Vertex sA, Vertex sB, Vertex point) + { + if ((sA.Position.Y < point.Position.Y && sB.Position.Y >= point.Position.Y) || + (sB.Position.Y < point.Position.Y && sA.Position.Y >= point.Position.Y)) + { + float x = + sA.Position.X + + (point.Position.Y - sA.Position.Y) / + (sB.Position.Y - sA.Position.Y) * + (sB.Position.X - sA.Position.X); + + if (x < point.Position.X) + return true; + } + + return false; + } + + public override bool Equals(object obj) + { + if (obj.GetType() != typeof(Triangle)) + return false; + return Equals((Triangle)obj); + } + + public bool Equals(Triangle obj) + { + return obj.A.Equals(A) && obj.B.Equals(B) && obj.C.Equals(C); + } + + public override int GetHashCode() + { + unchecked + { + int result = A.GetHashCode(); + result = (result * 397) ^ B.GetHashCode(); + result = (result * 397) ^ C.GetHashCode(); + return result; + } + } + } + #endregion + + #region CyclicalList + /// + /// Implements a List structure as a cyclical list where indices are wrapped. + /// + /// The Type to hold in the list. + class CyclicalList : List + { + public new T this[int index] + { + get + { + //perform the index wrapping + while (index < 0) + index = Count + index; + if (index >= Count) + index %= Count; + + return base[index]; + } + set + { + //perform the index wrapping + while (index < 0) + index = Count + index; + if (index >= Count) + index %= Count; + + base[index] = value; + } + } + + public CyclicalList() { } + + public CyclicalList(IEnumerable collection) + : base(collection) + { + } + + public new void RemoveAt(int index) + { + Remove(this[index]); + } + } + #endregion + + #region IndexableCyclicalLinkedList + /// + /// Implements a LinkedList that is both indexable as well as cyclical. Thus + /// indexing into the list with an out-of-bounds index will automatically cycle + /// around the list to find a valid node. + /// + class IndexableCyclicalLinkedList : LinkedList + { + /// + /// Gets the LinkedListNode at a particular index. + /// + /// The index of the node to retrieve. + /// The LinkedListNode found at the index given. + public LinkedListNode this[int index] + { + get + { + //perform the index wrapping + while (index < 0) + index = Count + index; + if (index >= Count) + index %= Count; + + //find the proper node + LinkedListNode node = First; + for (int i = 0; i < index; i++) + node = node.Next; + + return node; + } + } + + /// + /// Removes the node at a given index. + /// + /// The index of the node to remove. + public void RemoveAt(int index) + { + Remove(this[index]); + } + + /// + /// Finds the index of a given item. + /// + /// The item to find. + /// The index of the item if found; -1 if the item is not found. + public int IndexOf(T item) + { + for (int i = 0; i < Count; i++) + if (this[i].Value.Equals(item)) + return i; + + return -1; + } + } + #endregion + + #region Public Methods + + #region Triangulate + + /// + /// Triangulates a 2D polygon produced the indexes required to render the points as a triangle list. + /// + /// The polygon vertices in counter-clockwise winding order. + /// The desired output winding order. + /// The resulting vertices that include any reversals of winding order and holes. + /// The resulting indices for rendering the shape as a triangle list. + public static void Triangulate( + Vector2[] inputVertices, + WindingOrder desiredWindingOrder, + out Vector2[] outputVertices, + out short[] indices) + { + //Log("\nBeginning triangulation..."); + + List triangles = new List(); + + //make sure we have our vertices wound properly + if (DetermineWindingOrder(inputVertices) == WindingOrder.Clockwise) + outputVertices = ReverseWindingOrder(inputVertices); + else + outputVertices = (Vector2[])inputVertices.Clone(); + + //clear all of the lists + polygonVertices.Clear(); + earVertices.Clear(); + convexVertices.Clear(); + reflexVertices.Clear(); + + //generate the cyclical list of vertices in the polygon + for (int i = 0; i < outputVertices.Length; i++) + polygonVertices.AddLast(new Vertex(outputVertices[i], (short)i)); + + //categorize all of the vertices as convex, reflex, and ear + FindConvexAndReflexVertices(); + FindEarVertices(); + + //clip all the ear vertices + while (polygonVertices.Count > 3 && earVertices.Count > 0) + ClipNextEar(triangles); + + //if there are still three points, use that for the last triangle + if (polygonVertices.Count == 3) + triangles.Add(new Triangle( + polygonVertices[0].Value, + polygonVertices[1].Value, + polygonVertices[2].Value)); + + //add all of the triangle indices to the output array + indices = new short[triangles.Count * 3]; + + //move the if statement out of the loop to prevent all the + //redundant comparisons + if (desiredWindingOrder == WindingOrder.CounterClockwise) + { + for (int i = 0; i < triangles.Count; i++) + { + indices[(i * 3)] = triangles[i].A.Index; + indices[(i * 3) + 1] = triangles[i].B.Index; + indices[(i * 3) + 2] = triangles[i].C.Index; + } + } + else + { + for (int i = 0; i < triangles.Count; i++) + { + indices[(i * 3)] = triangles[i].C.Index; + indices[(i * 3) + 1] = triangles[i].B.Index; + indices[(i * 3) + 2] = triangles[i].A.Index; + } + } + } + + #endregion + + #region CutHoleInShape + + /// + /// Cuts a hole into a shape. + /// + /// An array of vertices for the primary shape. + /// An array of vertices for the hole to be cut. It is assumed that these vertices lie completely within the shape verts. + /// The new array of vertices that can be passed to Triangulate to properly triangulate the shape with the hole. + public static Vector2[] CutHoleInShape(Vector2[] shapeVerts, Vector2[] holeVerts) + { + Log("\nCutting hole into shape..."); + + //make sure the shape vertices are wound counter clockwise and the hole vertices clockwise + shapeVerts = EnsureWindingOrder(shapeVerts, WindingOrder.CounterClockwise); + holeVerts = EnsureWindingOrder(holeVerts, WindingOrder.Clockwise); + + //clear all of the lists + polygonVertices.Clear(); + earVertices.Clear(); + convexVertices.Clear(); + reflexVertices.Clear(); + + //generate the cyclical list of vertices in the polygon + for (int i = 0; i < shapeVerts.Length; i++) + polygonVertices.AddLast(new Vertex(shapeVerts[i], (short)i)); + + CyclicalList holePolygon = new CyclicalList(); + for (int i = 0; i < holeVerts.Length; i++) + holePolygon.Add(new Vertex(holeVerts[i], (short)(i + polygonVertices.Count))); + +#if DEBUG + StringBuilder vString = new StringBuilder(); + foreach (Vertex v in polygonVertices) + vString.Append(string.Format("{0}, ", v)); + Log("Shape Vertices: {0}", vString); + + vString = new StringBuilder(); + foreach (Vertex v in holePolygon) + vString.Append(string.Format("{0}, ", v)); + Log("Hole Vertices: {0}", vString); +#endif + + FindConvexAndReflexVertices(); + FindEarVertices(); + + //find the hole vertex with the largest X value + Vertex rightMostHoleVertex = holePolygon[0]; + foreach (Vertex v in holePolygon) + if (v.Position.X > rightMostHoleVertex.Position.X) + rightMostHoleVertex = v; + + //construct a list of all line segments where at least one vertex + //is to the right of the rightmost hole vertex with one vertex + //above the hole vertex and one below + List segmentsToTest = new List(); + for (int i = 0; i < polygonVertices.Count; i++) + { + Vertex a = polygonVertices[i].Value; + Vertex b = polygonVertices[i + 1].Value; + + if ((a.Position.X > rightMostHoleVertex.Position.X || b.Position.X > rightMostHoleVertex.Position.X) && + ((a.Position.Y >= rightMostHoleVertex.Position.Y && b.Position.Y <= rightMostHoleVertex.Position.Y) || + (a.Position.Y <= rightMostHoleVertex.Position.Y && b.Position.Y >= rightMostHoleVertex.Position.Y))) + segmentsToTest.Add(new LineSegment(a, b)); + } + + //now we try to find the closest intersection point heading to the right from + //our hole vertex. + float? closestPoint = null; + LineSegment closestSegment = new LineSegment(); + foreach (LineSegment segment in segmentsToTest) + { + float? intersection = segment.IntersectsWithRay(rightMostHoleVertex.Position, Vector2.UnitX); + if (intersection != null) + { + if (closestPoint == null || closestPoint.Value > intersection.Value) + { + closestPoint = intersection; + closestSegment = segment; + } + } + } + + //if closestPoint is null, there were no collisions (likely from improper input data), + //but we'll just return without doing anything else + if (closestPoint == null) + return shapeVerts; + + //otherwise we can find our mutually visible vertex to split the polygon + Vector2 I = rightMostHoleVertex.Position + Vector2.UnitX * closestPoint.Value; + Vertex P = (closestSegment.A.Position.X > closestSegment.B.Position.X) + ? closestSegment.A + : closestSegment.B; + + //construct triangle MIP + Triangle mip = new Triangle(rightMostHoleVertex, new Vertex(I, 1), P); + + //see if any of the reflex vertices lie inside of the MIP triangle + List interiorReflexVertices = new List(); + foreach (Vertex v in reflexVertices) + if (mip.ContainsPoint(v)) + interiorReflexVertices.Add(v); + + //if there are any interior reflex vertices, find the one that, when connected + //to our rightMostHoleVertex, forms the line closest to Vector2.UnitX + if (interiorReflexVertices.Count > 0) + { + float closestDot = -1f; + foreach (Vertex v in interiorReflexVertices) + { + //compute the dot product of the vector against the UnitX + Vector2 d = Vector2.Normalize(v.Position - rightMostHoleVertex.Position); + float dot = Vector2.Dot(Vector2.UnitX, d); + + //if this line is the closest we've found + if (dot > closestDot) + { + //save the value and save the vertex as P + closestDot = dot; + P = v; + } + } + } + + //now we just form our output array by injecting the hole vertices into place + //we know we have to inject the hole into the main array after point P going from + //rightMostHoleVertex around and then back to P. + int mIndex = holePolygon.IndexOf(rightMostHoleVertex); + int injectPoint = polygonVertices.IndexOf(P); + + Log("Inserting hole at injection point {0} starting at hole vertex {1}.", + P, + rightMostHoleVertex); + for (int i = mIndex; i <= mIndex + holePolygon.Count; i++) + { + Log("Inserting vertex {0} after vertex {1}.", holePolygon[i], polygonVertices[injectPoint].Value); + polygonVertices.AddAfter(polygonVertices[injectPoint++], holePolygon[i]); + } + polygonVertices.AddAfter(polygonVertices[injectPoint], P); + +#if DEBUG + vString = new StringBuilder(); + foreach (Vertex v in polygonVertices) + vString.Append(string.Format("{0}, ", v)); + Log("New Shape Vertices: {0}\n", vString); +#endif + + //finally we write out the new polygon vertices and return them out + Vector2[] newShapeVerts = new Vector2[polygonVertices.Count]; + for (int i = 0; i < polygonVertices.Count; i++) + newShapeVerts[i] = polygonVertices[i].Value.Position; + + return newShapeVerts; + } + + #endregion + + #region EnsureWindingOrder + + /// + /// Ensures that a set of vertices are wound in a particular order, reversing them if necessary. + /// + /// The vertices of the polygon. + /// The desired winding order. + /// A new set of vertices if the winding order didn't match; otherwise the original set. + public static Vector2[] EnsureWindingOrder(Vector2[] vertices, WindingOrder windingOrder) + { + //Log("\nEnsuring winding order of {0}...", windingOrder); + if (DetermineWindingOrder(vertices) != windingOrder) + { + //Log("Reversing vertices..."); + return ReverseWindingOrder(vertices); + } + + //Log("No reversal needed."); + return vertices; + } + + #endregion + + #region ReverseWindingOrder + + /// + /// Reverses the winding order for a set of vertices. + /// + /// The vertices of the polygon. + /// The new vertices for the polygon with the opposite winding order. + public static Vector2[] ReverseWindingOrder(Vector2[] vertices) + { + //Log("\nReversing winding order..."); + Vector2[] newVerts = new Vector2[vertices.Length]; + +#if DEBUG + //StringBuilder vString = new StringBuilder(); + //foreach (Vector2 v in vertices) + // vString.Append(string.Format("{0}, ", v)); + //Log("Original Vertices: {0}", vString); +#endif + + newVerts[0] = vertices[0]; + for (int i = 1; i < newVerts.Length; i++) + newVerts[i] = vertices[vertices.Length - i]; + +#if DEBUG + //vString = new StringBuilder(); + //foreach (Vector2 v in newVerts) + // vString.Append(string.Format("{0}, ", v)); + //Log("New Vertices After Reversal: {0}\n", vString); +#endif + + return newVerts; + } + + #endregion + + #region DetermineWindingOrder + + /// + /// Determines the winding order of a polygon given a set of vertices. + /// + /// The vertices of the polygon. + /// The calculated winding order of the polygon. + public static WindingOrder DetermineWindingOrder(Vector2[] vertices) + { + int clockWiseCount = 0; + int counterClockWiseCount = 0; + Vector2 p1 = vertices[0]; + + for (int i = 1; i < vertices.Length; i++) + { + Vector2 p2 = vertices[i]; + Vector2 p3 = vertices[(i + 1) % vertices.Length]; + + Vector2 e1 = p1 - p2; + Vector2 e2 = p3 - p2; + + if (e1.X * e2.Y - e1.Y * e2.X >= 0) + clockWiseCount++; + else + counterClockWiseCount++; + + p1 = p2; + } + + return (clockWiseCount > counterClockWiseCount) + ? WindingOrder.Clockwise + : WindingOrder.CounterClockwise; + } + + #endregion + + #endregion + + #region Private Methods + + #region ClipNextEar + + private static void ClipNextEar(ICollection triangles) + { + //find the triangle + Vertex ear = earVertices[0].Value; + Vertex prev = polygonVertices[polygonVertices.IndexOf(ear) - 1].Value; + Vertex next = polygonVertices[polygonVertices.IndexOf(ear) + 1].Value; + triangles.Add(new Triangle(ear, next, prev)); + + //remove the ear from the shape + earVertices.RemoveAt(0); + polygonVertices.RemoveAt(polygonVertices.IndexOf(ear)); + //Log("\nRemoved Ear: {0}", ear); + + //validate the neighboring vertices + ValidateAdjacentVertex(prev); + ValidateAdjacentVertex(next); + + //write out the states of each of the lists +#if DEBUG + /*StringBuilder rString = new StringBuilder(); + foreach (Vertex v in reflexVertices) + rString.Append(string.Format("{0}, ", v.Index)); + Log("Reflex Vertices: {0}", rString); + + StringBuilder cString = new StringBuilder(); + foreach (Vertex v in convexVertices) + cString.Append(string.Format("{0}, ", v.Index)); + Log("Convex Vertices: {0}", cString); + + StringBuilder eString = new StringBuilder(); + foreach (Vertex v in earVertices) + eString.Append(string.Format("{0}, ", v.Index)); + Log("Ear Vertices: {0}", eString);*/ +#endif + } + + #endregion + + #region ValidateAdjacentVertex + + private static void ValidateAdjacentVertex(Vertex vertex) + { + //Log("Validating: {0}...", vertex); + + if (reflexVertices.Contains(vertex)) + { + if (IsConvex(vertex)) + { + reflexVertices.Remove(vertex); + convexVertices.Add(vertex); + //Log("Vertex: {0} now convex", vertex); + } + else + { + //Log("Vertex: {0} still reflex", vertex); + } + } + + if (convexVertices.Contains(vertex)) + { + bool wasEar = earVertices.Contains(vertex); + bool isEar = IsEar(vertex); + + if (wasEar && !isEar) + { + earVertices.Remove(vertex); + //Log("Vertex: {0} no longer ear", vertex); + } + else if (!wasEar && isEar) + { + earVertices.AddFirst(vertex); + //Log("Vertex: {0} now ear", vertex); + } + else + { + //Log("Vertex: {0} still ear", vertex); + } + } + } + + #endregion + + #region FindConvexAndReflexVertices + + private static void FindConvexAndReflexVertices() + { + for (int i = 0; i < polygonVertices.Count; i++) + { + Vertex v = polygonVertices[i].Value; + + if (IsConvex(v)) + { + convexVertices.Add(v); + //Log("Convex: {0}", v); + } + else + { + reflexVertices.Add(v); + //Log("Reflex: {0}", v); + } + } + } + + #endregion + + #region FindEarVertices + + private static void FindEarVertices() + { + for (int i = 0; i < convexVertices.Count; i++) + { + Vertex c = convexVertices[i]; + + if (IsEar(c)) + { + earVertices.AddLast(c); + //Log("Ear: {0}", c); + } + } + } + + #endregion + + #region IsEar + + private static bool IsEar(Vertex c) + { + Vertex p = polygonVertices[polygonVertices.IndexOf(c) - 1].Value; + Vertex n = polygonVertices[polygonVertices.IndexOf(c) + 1].Value; + + //Log("Testing vertex {0} as ear with triangle {1}, {0}, {2}...", c, p, n); + + foreach (Vertex t in reflexVertices) + { + if (t.Equals(p) || t.Equals(c) || t.Equals(n)) + continue; + + if (Triangle.ContainsPoint(p, c, n, t)) + { + //Log("\tTriangle contains vertex {0}...", t); + return false; + } + } + + return true; + } + + #endregion + + #region IsConvex + + private static bool IsConvex(Vertex c) + { + Vertex p = polygonVertices[polygonVertices.IndexOf(c) - 1].Value; + Vertex n = polygonVertices[polygonVertices.IndexOf(c) + 1].Value; + + Vector2 d1 = Vector2.Normalize(c.Position - p.Position); + Vector2 d2 = Vector2.Normalize(n.Position - c.Position); + Vector2 n2 = new Vector2(-d2.Y, d2.X); + + return (Vector2.Dot(d1, n2) <= 0f); + } + + #endregion + + #region IsReflex + + private static bool IsReflex(Vertex c) + { + return !IsConvex(c); + } + + #endregion + + #region Log + + //[Conditional("DEBUG")] + private static void Log(string format, params object[] parameters) + { + Console.WriteLine(format, parameters); + } + + #endregion + + #endregion + + #region WindingOrder + + /// + /// Specifies a desired winding order for the shape vertices. + /// + public enum WindingOrder + { + Clockwise, + CounterClockwise + } + + #endregion + + #endregion + + #region SAT Extensions + + /// + /// Decomposes a set of vertices into a set of Geoms all + /// attached to one body. + /// + /// Vertices to decompose. + /// Body to attach too. + /// Maximum Geoms to return. + /// A list of Geoms. + //public static List DecomposeGeom(Vertices vertices, Body body, int maxPolysToFind) + //{ + // Vertices[] verts = Polygon.DecomposeVertices(vertices, maxPolysToFind); + + // List geomList = new List(); + + // Vector2 mainCentroid = vertices.GetCentroid(); + + // foreach (Vertices v in verts) + // { + // //Vector2 subCentroid = v.GetCentroid(); + // geomList.Add(new Geom(body, v, -mainCentroid, 0, 1.0f)); + // } + + // return geomList; + //} + + #endregion + } + + #region Sickbattery's Extension - Enums & Classes + public enum EdgeAlignment + { + Vertical = 0, + Horizontal = 1 + } + + public class CrossingEdgeInfo : IComparable + { + #region Attributes + private Vector2 _egdeVertex1; + private Vector2 _edgeVertex2; + + private EdgeAlignment _alignment; + private Vector2 _crossingPoint; + #endregion + + #region Properties + public Vector2 EdgeVertex1 + { + get { return _egdeVertex1; } + set { _egdeVertex1 = value; } + } + + public Vector2 EdgeVertex2 + { + get { return _edgeVertex2; } + set { _edgeVertex2 = value; } + } + + public EdgeAlignment CheckLineAlignment + { + get { return _alignment; } + set { _alignment = value; } + } + + public Vector2 CrossingPoint + { + get { return _crossingPoint; } + set { _crossingPoint = value; } + } + #endregion + + #region Constructor + public CrossingEdgeInfo(Vector2 edgeVertex1, Vector2 edgeVertex2, Vector2 crossingPoint, EdgeAlignment checkLineAlignment) + { + _egdeVertex1 = edgeVertex1; + _edgeVertex2 = edgeVertex2; + + _alignment = checkLineAlignment; + _crossingPoint = crossingPoint; + } + #endregion + + #region IComparable Member + public int CompareTo(object obj) + { + CrossingEdgeInfo cei = (CrossingEdgeInfo)obj; + int result = 0; + + switch (_alignment) + { + case EdgeAlignment.Vertical: + if (_crossingPoint.X < cei.CrossingPoint.X) + { + result = -1; + } + else if (_crossingPoint.X > cei.CrossingPoint.X) + { + result = 1; + } + break; + + case EdgeAlignment.Horizontal: + if (_crossingPoint.Y < cei.CrossingPoint.Y) + { + result = -1; + } + else if (_crossingPoint.Y > cei.CrossingPoint.Y) + { + result = 1; + } + break; + } + + return result; + } + #endregion + } + + /// + /// Class used as a data container and helper for the texture-to-vertices code. + /// + public class PolygonCreationAssistance + { + private uint[] _data; + private int _width; + private int _height; + private byte _alphaTolerance; + private uint _alphaToleranceRealValue; + private float _hullTolerance; + private int _holeDetectionLineStepSize; + private bool _holeDetection; + private bool _multipartDetection; + + public uint[] Data + { + get { return _data; } + } + + public int Width + { + get { return _width; } + } + + public int Height + { + get { return _height; } + } + + public byte AlphaTolerance + { + get { return _alphaTolerance; } + set + { + _alphaTolerance = value; + _alphaToleranceRealValue = (uint)value << 24; + } + } + + public float HullTolerance + { + get { return _hullTolerance; } + set + { + float hullTolerance = value; + + if (hullTolerance > 4f) hullTolerance = 4f; + if (hullTolerance < 0.9f) hullTolerance = 0.9f; + + _hullTolerance = hullTolerance; + } + } + + public int HoleDetectionLineStepSize + { + get { return _holeDetectionLineStepSize; } + set + { + if (value < 1) + { + _holeDetectionLineStepSize = 1; + } + else + { + if (value > 10) + { + _holeDetectionLineStepSize = 10; + } + else + { + _holeDetectionLineStepSize = value; + } + } + } + } + + public bool HoleDetection + { + get { return _holeDetection; } + set { _holeDetection = value; } + } + + public bool MultipartDetection + { + get { return _multipartDetection; } + set { _multipartDetection = value; } + } + + public PolygonCreationAssistance(uint[] data, int width, int height) + { + _data = data; + _width = width; + _height = height; + + AlphaTolerance = 20; + HullTolerance = 1.5f; + + HoleDetectionLineStepSize = 1; + + _holeDetection = false; + _multipartDetection = false; + } + + public bool IsSolid(Vector2 pixel) + { + return IsSolid((int)pixel.X, (int)pixel.Y); + } + + public bool IsSolid(int x, int y) + { + if (x >= 0 && x < _width && y >= 0 && y < _height) + return ((_data[x + y * _width] & 0xFF000000) >= _alphaToleranceRealValue); + + return false; + } + + public bool IsSolid(int index) + { + if (index >= 0 && index < _width * _height) + return ((_data[index] & 0xFF000000) >= _alphaToleranceRealValue); + + return false; + } + + public bool InBounds(Vector2 coord) + { + return (coord.X >= 0f && coord.X < _width && coord.Y >= 0f && coord.Y < _height); + } + + public bool IsValid() + { + if (_data != null && _data.Length > 0) + return _data.Length == _width * _height; + + return false; + } + + ~PolygonCreationAssistance() + { + _data = null; + } + } + #endregion + + #region SAT Extensions + + /* + * C# Version Ported by Matt Bettcher 2009 + * + * Original C++ Version Copyright (c) 2007 Eric Jordan + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + */ + + internal class Triangle + { + public float[] x; + public float[] y; + + //Constructor automatically fixes orientation to ccw + public Triangle(float x1, float y1, float x2, float y2, float x3, float y3) + { + x = new float[3]; + y = new float[3]; + float dx1 = x2 - x1; + float dx2 = x3 - x1; + float dy1 = y2 - y1; + float dy2 = y3 - y1; + float cross = dx1 * dy2 - dx2 * dy1; + bool ccw = (cross > 0); + if (ccw) + { + x[0] = x1; x[1] = x2; x[2] = x3; + y[0] = y1; y[1] = y2; y[2] = y3; + } + else + { + x[0] = x1; x[1] = x3; x[2] = x2; + y[0] = y1; y[1] = y3; y[2] = y2; + } + } + + //public Triangle() + //{ + // x = new float[3]; + // y = new float[3]; + //} + + public Triangle(Triangle t) + { + x = new float[3]; + y = new float[3]; + + x[0] = t.x[0]; x[1] = t.x[1]; x[2] = t.x[2]; + y[0] = t.y[0]; y[1] = t.y[1]; y[2] = t.y[2]; + } + + //public void Set(ref Triangle toMe) + //{ + // for (int i = 0; i < 3; ++i) + // { + // x[i] = toMe.x[i]; + // y[i] = toMe.y[i]; + // } + //} + + public bool IsInside(float _x, float _y) + { + if (_x < x[0] && _x < x[1] && _x < x[2]) return false; + if (_x > x[0] && _x > x[1] && _x > x[2]) return false; + if (_y < y[0] && _y < y[1] && _y < y[2]) return false; + if (_y > y[0] && _y > y[1] && _y > y[2]) return false; + + float vx2 = _x - x[0]; float vy2 = _y - y[0]; + float vx1 = x[1] - x[0]; float vy1 = y[1] - y[0]; + float vx0 = x[2] - x[0]; float vy0 = y[2] - y[0]; + + float dot00 = vx0 * vx0 + vy0 * vy0; + float dot01 = vx0 * vx1 + vy0 * vy1; + float dot02 = vx0 * vx2 + vy0 * vy2; + float dot11 = vx1 * vx1 + vy1 * vy1; + float dot12 = vx1 * vx2 + vy1 * vy2; + float invDenom = 1.0f / (dot00 * dot11 - dot01 * dot01); + float u = (dot11 * dot02 - dot01 * dot12) * invDenom; + float v = (dot00 * dot12 - dot01 * dot02) * invDenom; + + return ((u > 0) && (v > 0) && (u + v < 1)); + } + } + + internal class Polygon + { + private const int maxVerticesPerPolygon = 32; + //private static readonly float linearSlop = 0.005f; // 0.5 cm + private const float angularSlop = 1.0f / 180.0f * (float)Math.PI; // 1 degrees + + private float[] x; //vertex arrays + private float[] y; + private int nVertices; + private bool areaIsSet; + private float area; + + /// + /// Check if the lines a0->a1 and b0->b1 cross. + /// If they do, intersectionPoint will be filled + /// with the point of crossing. + /// + /// Grazing lines should not return true. + /// + /// The a0. + /// The a1. + /// The b0. + /// The b1. + /// The intersection point. + /// + //private bool Intersect(Vector2 a0, Vector2 a1, Vector2 b0, Vector2 b1, out Vector2 intersectionPoint) + //{ + // intersectionPoint = Vector2.Zero; + + // if (a0 == b0 || a0 == b1 || a1 == b0 || a1 == b1) + // return false; + + // float x1 = a0.X; float y1 = a0.Y; + // float x2 = a1.X; float y2 = a1.Y; + // float x3 = b0.X; float y3 = b0.Y; + // float x4 = b1.X; float y4 = b1.Y; + + // //AABB early exit + // if (Math.Max(x1, x2) < Math.Min(x3, x4) || Math.Max(x3, x4) < Math.Min(x1, x2)) return false; + // if (Math.Max(y1, y2) < Math.Min(y3, y4) || Math.Max(y3, y4) < Math.Min(y1, y2)) return false; + + // float ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)); + // float ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)); + // float denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1); + // if (Math.Abs(denom) < float.Epsilon) + // { + // //Lines are too close to parallel to call + // return false; + // } + // ua /= denom; + // ub /= denom; + + // if ((0 < ua) && (ua < 1) && (0 < ub) && (ub < 1)) + // { + // intersectionPoint.X = (x1 + ua * (x2 - x1)); + // intersectionPoint.Y = (y1 + ua * (y2 - y1)); + // return true; + // } + + // return false; + //} + + /// + /// True if line from a0->a1 intersects b0->b1 + /// + /// The a0. + /// The a1. + /// The b0. + /// The b1. + /// + //private bool Intersect(Vector2 a0, Vector2 a1, Vector2 b0, Vector2 b1) + //{ + // Vector2 temp; + // return Intersect(a0, a1, b0, b1, out temp); + //} + + private Polygon(float[] _x, float[] _y, int nVert) + { + nVertices = nVert; + x = new float[nVertices]; + y = new float[nVertices]; + for (int i = 0; i < nVertices; ++i) + { + x[i] = _x[i]; + y[i] = _y[i]; + } + areaIsSet = false; + } + + private Polygon(Vector2[] v, int nVert) + { + nVertices = nVert; + x = new float[nVertices]; + y = new float[nVertices]; + for (int i = 0; i < nVertices; ++i) + { + x[i] = v[i].X; + y[i] = v[i].Y; + + } + areaIsSet = false; + } + + private Polygon() + { + x = null; + y = null; + nVertices = 0; + areaIsSet = false; + } + + private float GetArea() + { + // TODO: fix up the areaIsSet caching so that it can be used + //if (areaIsSet) return area; + area = 0.0f; + + //First do wraparound + area += x[nVertices - 1] * y[0] - x[0] * y[nVertices - 1]; + for (int i = 0; i < nVertices - 1; ++i) + { + area += x[i] * y[i + 1] - x[i + 1] * y[i]; + } + area *= .5f; + areaIsSet = true; + if (areaIsSet) areaIsSet = true; + return area; + } + + private bool IsCCW() + { + return (GetArea() > 0.0f); + } + + private void MergeParallelEdges(float tolerance) + { + if (nVertices <= 3) return; //Can't do anything useful here to a triangle + bool[] mergeMe = new bool[nVertices]; + int newNVertices = nVertices; + for (int i = 0; i < nVertices; ++i) + { + int lower = (i == 0) ? (nVertices - 1) : (i - 1); + int middle = i; + int upper = (i == nVertices - 1) ? (0) : (i + 1); + float dx0 = x[middle] - x[lower]; + float dy0 = y[middle] - y[lower]; + float dx1 = x[upper] - x[middle]; + float dy1 = y[upper] - y[middle]; + float norm0 = (float)Math.Sqrt(dx0 * dx0 + dy0 * dy0); + float norm1 = (float)Math.Sqrt(dx1 * dx1 + dy1 * dy1); + if (!(norm0 > 0.0f && norm1 > 0.0f) && newNVertices > 3) + { + //Merge identical points + mergeMe[i] = true; + --newNVertices; + } + dx0 /= norm0; dy0 /= norm0; + dx1 /= norm1; dy1 /= norm1; + float cross = dx0 * dy1 - dx1 * dy0; + float dot = dx0 * dx1 + dy0 * dy1; + if (Math.Abs(cross) < tolerance && dot > 0 && newNVertices > 3) + { + mergeMe[i] = true; + --newNVertices; + } + else + { + mergeMe[i] = false; + } + } + if (newNVertices == nVertices || newNVertices == 0) + { + return; + } + float[] newx = new float[newNVertices]; + float[] newy = new float[newNVertices]; + int currIndex = 0; + for (int i = 0; i < nVertices; ++i) + { + if (mergeMe[i] || newNVertices == 0 || currIndex == newNVertices) continue; + + //b2Assert(currIndex < newNVertices); + newx[currIndex] = x[i]; + newy[currIndex] = y[i]; + ++currIndex; + } + + x = newx; + y = newy; + nVertices = newNVertices; + // printf("%d \n", newNVertices); + } + + /// + /// Allocates and returns pointer to vector vertex array. + /// Length of array is nVertices. + /// + /// + //public Vector2[] GetVertexVecs() + //{ + // Vector2[] output = new Vector2[nVertices]; + // for (int i = 0; i < nVertices; ++i) + // { + // output[i] = new Vector2(x[i], y[i]); + // } + // return output; + //} + + private Polygon(Triangle t) + { + nVertices = 3; + x = new float[nVertices]; + y = new float[nVertices]; + for (int i = 0; i < nVertices; ++i) + { + x[i] = t.x[i]; + y[i] = t.y[i]; + } + } + + private Polygon(Polygon p) + { + nVertices = p.nVertices; + x = new float[nVertices]; + y = new float[nVertices]; + for (int i = 0; i < nVertices; ++i) + { + x[i] = p.x[i]; + y[i] = p.y[i]; + } + } + + private void Set(Polygon p) + { + if (nVertices != p.nVertices) + { + nVertices = p.nVertices; + + x = new float[nVertices]; + y = new float[nVertices]; + } + + for (int i = 0; i < nVertices; ++i) + { + x[i] = p.x[i]; + y[i] = p.y[i]; + } + areaIsSet = false; + } + + /// + /// Assuming the polygon is simple, checks if it is convex. + /// + /// + /// true if this instance is convex; otherwise, false. + /// + private bool IsConvex() + { + bool isPositive = false; + for (int i = 0; i < nVertices; ++i) + { + int lower = (i == 0) ? (nVertices - 1) : (i - 1); + int middle = i; + int upper = (i == nVertices - 1) ? (0) : (i + 1); + float dx0 = x[middle] - x[lower]; + float dy0 = y[middle] - y[lower]; + float dx1 = x[upper] - x[middle]; + float dy1 = y[upper] - y[middle]; + float cross = dx0 * dy1 - dx1 * dy0; + // Cross product should have same sign + // for each vertex if poly is convex. + bool newIsP = (cross >= 0) ? true : false; + if (i == 0) + { + isPositive = newIsP; + } + else if (isPositive != newIsP) + { + return false; + } + } + return true; + } + + // Pulled from b2Shape.cpp, assertions removed + //private static Vector2 PolyCentroid(Vector2[] vs, int count) + //{ + // Vector2 c = new Vector2(0.0f, 0.0f); + // float area = 0.0f; + + // float inv3 = 1.0f / 3.0f; + // Vector2 pRef = new Vector2(0.0f, 0.0f); + // for (int i = 0; i < count; ++i) + // { + // // Triangle vertices. + // Vector2 p1 = pRef; + // Vector2 p2 = vs[i]; + // Vector2 p3 = i + 1 < count ? vs[i + 1] : vs[0]; + + // Vector2 e1 = p2 - p1; + // Vector2 e2 = p3 - p1; + + // float D = Calculator.Cross(e1, e2); + + // float triangleArea = 0.5f * D; + // area += triangleArea; + + // // Area weighted centroid + // c += triangleArea * inv3 * (p1 + p2 + p3); + // } + + // // Centroid + // c *= 1.0f / area; + // return c; + //} + + /// + /// Checks if polygon is valid for use in Box2d engine. + /// Last ditch effort to ensure no invalid polygons are + /// added to world geometry. + /// + /// Performs a full check, for simplicity, convexity, + /// orientation, minimum angle, and volume. This won't + /// be very efficient, and a lot of it is redundant when + /// other tools in this section are used. + /// + /// if set to true [print errors]. + /// + /// true if the specified print errors is usable; otherwise, false. + /// + //private bool IsUsable(bool printErrors) + //{ + // int error = -1; + // bool noError = true; + // if (nVertices < 3 || nVertices > maxVerticesPerPolygon) { noError = false; error = 0; } + // if (!IsConvex()) { noError = false; error = 1; } + // if (!IsSimple()) { noError = false; error = 2; } + // if (GetArea() < float.Epsilon) { noError = false; error = 3; } + + // //Compute normals + // Vector2[] normals = new Vector2[nVertices]; + // Vector2[] vertices = new Vector2[nVertices]; + // for (int i = 0; i < nVertices; ++i) + // { + // vertices[i] = new Vector2(x[i], y[i]); + // int i1 = i; + // int i2 = i + 1 < nVertices ? i + 1 : 0; + // Vector2 edge = new Vector2(x[i2] - x[i1], y[i2] - y[i1]); + // normals[i] = Calculator.Cross(edge, 1.0f); + // normals[i].Normalize(); + // } + + // //Required side checks + // for (int i = 0; i < nVertices; ++i) + // { + // int iminus = (i == 0) ? nVertices - 1 : i - 1; + // //int32 iplus = (i==nVertices-1)?0:i+1; + + // //Parallel sides check + // float cross = Calculator.Cross(normals[iminus], normals[i]); + // cross = Calculator.Clamp(cross, -1.0f, 1.0f); + // float angle = (float)Math.Asin(cross); + // if (angle <= angularSlop) + // { + // noError = false; + // error = 4; + // break; + // } + + // //Too skinny check + // for (int j = 0; j < nVertices; ++j) + // { + // if (j == i || j == (i + 1) % nVertices) + // { + // continue; + // } + // float s = Vector2.Dot(normals[i], vertices[j] - vertices[i]); + // if (s >= -linearSlop) + // { + // noError = false; + // error = 5; + // } + // } + + + // Vector2 centroid = PolyCentroid(vertices, nVertices); + // Vector2 n1 = normals[iminus]; + // Vector2 n2 = normals[i]; + // Vector2 v = vertices[i] - centroid; ; + + // Vector2 d; + // d.X = Vector2.Dot(n1, v) - 0.0f; + // d.Y = Vector2.Dot(n2, v) - 0.0f; + + // // Shifting the edge inward by b2_0.0f should + // // not cause the plane to pass the centroid. + // if ((d.X < 0.0f) || (d.Y < 0.0f)) + // { + // noError = false; + // error = 6; + // } + + // } + + // if (!noError && printErrors) + // { + // //printf("Found invalid polygon, "); + // switch (error) + // { + // case 0: + // //printf("must have between 3 and %d vertices.\n",b2_maxPolygonVertices); + // break; + // case 1: + // //printf("must be convex.\n"); + // break; + // case 2: + // //printf("must be simple (cannot intersect itself).\n"); + // break; + // case 3: + // //printf("area is too small.\n"); + // break; + // case 4: + // //printf("sides are too close to parallel.\n"); + // break; + // case 5: + // //printf("polygon is too thin.\n"); + // break; + // case 6: + // //printf("core shape generation would move edge past centroid (too thin).\n"); + // break; + // default: + // //printf("don't know why.\n"); + // break; + // } + // } + // return noError; + //} + + //public bool IsUsable() + //{ + // return IsUsable(false); + //} + + //Check for edge crossings + //private bool IsSimple() + //{ + // for (int i = 0; i < nVertices; ++i) + // { + // int iplus = (i + 1 > nVertices - 1) ? 0 : i + 1; + // Vector2 a1 = new Vector2(x[i], y[i]); + // Vector2 a2 = new Vector2(x[iplus], y[iplus]); + // for (int j = i + 1; j < nVertices; ++j) + // { + // int jplus = (j + 1 > nVertices - 1) ? 0 : j + 1; + // Vector2 b1 = new Vector2(x[j], y[j]); + // Vector2 b2 = new Vector2(x[jplus], y[jplus]); + // if (Intersect(a1, a2, b1, b2)) + // { + // return false; + // } + // } + // } + // return true; + //} + + /// + /// Tries to add a triangle to the polygon. Returns null if it can't connect + /// properly, otherwise returns a pointer to the new Polygon. Assumes bitwise + /// equality of joined vertex positions. + /// + /// Remember to delete the pointer afterwards. + /// Todo: Make this return a b2Polygon instead + /// of a pointer to a heap-allocated one. + /// + /// For internal use. + /// + /// The triangle to add. + /// + private Polygon Add(Triangle t) + { + // float32 equalTol = .001f; + // First, find vertices that connect + int firstP = -1; + int firstT = -1; + int secondP = -1; + int secondT = -1; + for (int i = 0; i < nVertices; i++) + { + if (t.x[0] == x[i] && t.y[0] == y[i]) + { + if (firstP == -1) + { + firstP = i; + firstT = 0; + } + else + { + secondP = i; + secondT = 0; + } + } + else if (t.x[1] == x[i] && t.y[1] == y[i]) + { + if (firstP == -1) + { + firstP = i; + firstT = 1; + } + else + { + secondP = i; + secondT = 1; + } + } + else if (t.x[2] == x[i] && t.y[2] == y[i]) + { + if (firstP == -1) + { + firstP = i; + firstT = 2; + } + else + { + secondP = i; + secondT = 2; + } + } + } + // Fix ordering if first should be last vertex of poly + if (firstP == 0 && secondP == nVertices - 1) + { + firstP = nVertices - 1; + secondP = 0; + } + + // Didn't find it + if (secondP == -1) + { + return null; + } + + // Find tip index on triangle + int tipT = 0; + if (tipT == firstT || tipT == secondT) + tipT = 1; + if (tipT == firstT || tipT == secondT) + tipT = 2; + + float[] newx = new float[nVertices + 1]; + float[] newy = new float[nVertices + 1]; + int currOut = 0; + for (int i = 0; i < nVertices; i++) + { + newx[currOut] = x[i]; + newy[currOut] = y[i]; + if (i == firstP) + { + ++currOut; + newx[currOut] = t.x[tipT]; + newy[currOut] = t.y[tipT]; + } + ++currOut; + } + Polygon result = new Polygon(newx, newy, nVertices + 1); + + return result; + } + + /// + /// Finds and fixes "pinch points," points where two polygon + /// vertices are at the same point. + /// If a pinch point is found, pin is broken up into poutA and poutB + /// and true is returned; otherwise, returns false. + /// Mostly for internal use. + /// + /// The pin. + /// The pout A. + /// The pout B. + /// + private static bool ResolvePinchPoint(Polygon pin, out Polygon poutA, out Polygon poutB) + { + poutA = new Polygon(); + poutB = new Polygon(); + + if (pin.nVertices < 3) return false; + const float tol = .001f; + bool hasPinchPoint = false; + int pinchIndexA = -1; + int pinchIndexB = -1; + for (int i = 0; i < pin.nVertices; ++i) + { + for (int j = i + 1; j < pin.nVertices; ++j) + { + //Don't worry about pinch points where the points + //are actually just dupe neighbors + if (Math.Abs(pin.x[i] - pin.x[j]) < tol && Math.Abs(pin.y[i] - pin.y[j]) < tol && j != i + 1) + { + pinchIndexA = i; + pinchIndexB = j; + //printf("pinch: %f, %f == %f, %f\n",pin.x[i],pin.y[i],pin.x[j],pin.y[j]); + //printf("at indexes %d, %d\n",i,j); + hasPinchPoint = true; + break; + } + } + if (hasPinchPoint) break; + } + if (hasPinchPoint) + { + //printf("Found pinch point\n"); + int sizeA = pinchIndexB - pinchIndexA; + if (sizeA == pin.nVertices) return false;//has dupe points at wraparound, not a problem here + float[] xA = new float[sizeA]; + float[] yA = new float[sizeA]; + for (int i = 0; i < sizeA; ++i) + { + int ind = Remainder(pinchIndexA + i, pin.nVertices); // is this right + xA[i] = pin.x[ind]; + yA[i] = pin.y[ind]; + } + Polygon tempA = new Polygon(xA, yA, sizeA); + poutA.Set(tempA); + + int sizeB = pin.nVertices - sizeA; + float[] xB = new float[sizeB]; + float[] yB = new float[sizeB]; + for (int i = 0; i < sizeB; ++i) + { + int ind = Remainder(pinchIndexB + i, pin.nVertices); // is this right + xB[i] = pin.x[ind]; + yB[i] = pin.y[ind]; + } + Polygon tempB = new Polygon(xB, yB, sizeB); + poutB.Set(tempB); + //printf("Size of a: %d, size of b: %d\n",sizeA,sizeB); + } + return hasPinchPoint; + } + + /// + /// Triangulates a polygon using simple ear-clipping algorithm. Returns + /// size of Triangle array unless the polygon can't be triangulated. + /// This should only happen if the polygon self-intersects, + /// though it will not _always_ return null for a bad polygon - it is the + /// caller's responsibility to check for self-intersection, and if it + /// doesn't, it should at least check that the return value is non-null + /// before using. You're warned! + /// + /// Triangles may be degenerate, especially if you have identical points + /// in the input to the algorithm. Check this before you use them. + /// + /// This is totally unoptimized, so for large polygons it should not be part + /// of the simulation loop. + /// + /// Returns: + /// -1 if algorithm fails (self-intersection most likely) + /// 0 if there are not enough vertices to triangulate anything. + /// Number of triangles if triangulation was successful. + /// + /// results will be filled with results - ear clipping always creates vNum - 2 + /// or fewer (due to pinch point polygon snipping), so allocate an array of + /// this size. + /// + /// The xv. + /// The yv. + /// The v num. + /// The results. + /// + private static int TriangulatePolygon(float[] xv, float[] yv, int vNum, out Triangle[] results) + { + results = new Triangle[175]; + + if (vNum < 3) + return 0; + + //Recurse and split on pinch points + Polygon pA, pB; + Polygon pin = new Polygon(xv, yv, vNum); + if (ResolvePinchPoint(pin, out pA, out pB)) + { + Triangle[] mergeA = new Triangle[pA.nVertices]; + Triangle[] mergeB = new Triangle[pB.nVertices]; + int nA = TriangulatePolygon(pA.x, pA.y, pA.nVertices, out mergeA); + int nB = TriangulatePolygon(pB.x, pB.y, pB.nVertices, out mergeB); + if (nA == -1 || nB == -1) + { + return -1; + } + for (int i = 0; i < nA; ++i) + { + results[i] = new Triangle(mergeA[i]); + } + for (int i = 0; i < nB; ++i) + { + results[nA + i] = new Triangle(mergeB[i]); + } + return (nA + nB); + } + + Triangle[] buffer = new Triangle[vNum - 2]; + int bufferSize = 0; + float[] xrem = new float[vNum]; + float[] yrem = new float[vNum]; + for (int i = 0; i < vNum; ++i) + { + xrem[i] = xv[i]; + yrem[i] = yv[i]; + } + + while (vNum > 3) + { + // Find an ear + int earIndex = -1; + //float32 earVolume = -1.0f; + float earMaxMinCross = -10.0f; + for (int i = 0; i < vNum; ++i) + { + if (IsEar(i, xrem, yrem, vNum)) + { + int lower = Remainder(i - 1, vNum); + int upper = Remainder(i + 1, vNum); + Vector2 d1 = new Vector2(xrem[upper] - xrem[i], yrem[upper] - yrem[i]); + Vector2 d2 = new Vector2(xrem[i] - xrem[lower], yrem[i] - yrem[lower]); + Vector2 d3 = new Vector2(xrem[lower] - xrem[upper], yrem[lower] - yrem[upper]); + + d1.Normalize(); + d2.Normalize(); + d3.Normalize(); + float cross12 = Math.Abs(Calculator.Cross(d1, d2)); + float cross23 = Math.Abs(Calculator.Cross(d2, d3)); + float cross31 = Math.Abs(Calculator.Cross(d3, d1)); + //Find the maximum minimum angle + float minCross = Math.Min(cross12, Math.Min(cross23, cross31)); + if (minCross > earMaxMinCross) + { + earIndex = i; + earMaxMinCross = minCross; + } + + /*//This bit chooses the ear with greatest volume first + float32 testVol = b2Abs( d1.x*d2.y-d2.x*d1.y ); + if (testVol > earVolume){ + earIndex = i; + earVolume = testVol; + }*/ + } + } + + // If we still haven't found an ear, we're screwed. + // Note: sometimes this is happening because the + // remaining points are collinear. Really these + // should just be thrown out without halting triangulation. + if (earIndex == -1) + { + for (int i = 0; i < bufferSize; i++) + { + results[i] = new Triangle(buffer[i]); + } + + if (bufferSize > 0) + return bufferSize; + + return -1; + } + + // Clip off the ear: + // - remove the ear tip from the list + + --vNum; + float[] newx = new float[vNum]; + float[] newy = new float[vNum]; + int currDest = 0; + for (int i = 0; i < vNum; ++i) + { + if (currDest == earIndex) ++currDest; + newx[i] = xrem[currDest]; + newy[i] = yrem[currDest]; + ++currDest; + } + + // - add the clipped triangle to the triangle list + int under = (earIndex == 0) ? (vNum) : (earIndex - 1); + int over = (earIndex == vNum) ? 0 : (earIndex + 1); + Triangle toAdd = new Triangle(xrem[earIndex], yrem[earIndex], xrem[over], yrem[over], xrem[under], yrem[under]); + buffer[bufferSize] = new Triangle(toAdd); + ++bufferSize; + + // - replace the old list with the new one + xrem = newx; + yrem = newy; + } + + Triangle tooAdd = new Triangle(xrem[1], yrem[1], xrem[2], yrem[2], + xrem[0], yrem[0]); + buffer[bufferSize] = new Triangle(tooAdd); + ++bufferSize; + + //b2Assert(bufferSize == xremLength-2); + + for (int i = 0; i < bufferSize; i++) + { + results[i] = new Triangle(buffer[i]); + } + + return bufferSize; + } + + /// + /// Fix for obnoxious behavior for the % operator for negative numbers... + /// + /// The x. + /// The modulus. + /// + private static int Remainder(int x, int modulus) + { + int rem = x % modulus; + while (rem < 0) + { + rem += modulus; + } + return rem; + } + + /// + /// Turns a list of triangles into a list of convex polygons. Very simple + /// method - start with a seed triangle, keep adding triangles to it until + /// you can't add any more without making the polygon non-convex. + /// + /// Returns an integer telling how many polygons were created. Will fill + /// polys array up to polysLength entries, which may be smaller or larger + /// than the return value. + /// + /// Takes O(N///P) where P is the number of resultant polygons, N is triangle + /// count. + /// + /// The final polygon list will not necessarily be minimal, though in + /// practice it works fairly well. + /// + /// The triangulated. + /// Length of the triangulated. + /// The polys. + /// Length of the polys. + /// + private static int PolygonizeTriangles(Triangle[] triangulated, int triangulatedLength, out Polygon[] polys, int polysLength) + { + int polyIndex = 0; + polys = new Polygon[50]; + + if (triangulatedLength <= 0) + { + return 0; + } + bool[] covered = new bool[triangulatedLength]; + for (int i = 0; i < triangulatedLength; ++i) + { + covered[i] = false; + //Check here for degenerate triangles + if (((triangulated[i].x[0] == triangulated[i].x[1]) && (triangulated[i].y[0] == triangulated[i].y[1])) + || ((triangulated[i].x[1] == triangulated[i].x[2]) && (triangulated[i].y[1] == triangulated[i].y[2])) + || ((triangulated[i].x[0] == triangulated[i].x[2]) && (triangulated[i].y[0] == triangulated[i].y[2]))) + { + covered[i] = true; + } + } + + bool notDone = true; + while (notDone) + { + int currTri = -1; + for (int i = 0; i < triangulatedLength; ++i) + { + if (covered[i]) + continue; + currTri = i; + break; + } + if (currTri == -1) + { + notDone = false; + } + else + { + Polygon poly = new Polygon(triangulated[currTri]); + covered[currTri] = true; + int index = 0; + for (int i = 0; i < 2 * triangulatedLength; ++i, ++index) + { + while (index >= triangulatedLength) index -= triangulatedLength; + if (covered[index]) + { + continue; + } + Polygon newP = poly.Add(triangulated[index]); + if (newP == null) + { // is this right + continue; + } + if (newP.nVertices > maxVerticesPerPolygon) + { + newP = null; + continue; + } + if (newP.IsConvex()) + { //Or should it be IsUsable? Maybe re-write IsConvex to apply the angle threshold from Box2d + poly = new Polygon(newP); + newP = null; + covered[index] = true; + } + else + { + newP = null; + } + } + if (polyIndex < polysLength) + { + poly.MergeParallelEdges(angularSlop); + //If identical points are present, a triangle gets + //borked by the MergeParallelEdges function, hence + //the vertex number check + if (poly.nVertices >= 3) polys[polyIndex] = new Polygon(poly); + //else printf("Skipping corrupt poly\n"); + } + if (poly.nVertices >= 3) polyIndex++; //Must be outside (polyIndex < polysLength) test + } + } + return polyIndex; + } + + /// + /// Checks if vertex i is the tip of an ear in polygon defined by xv[] and + /// yv[]. + /// + /// Assumes clockwise orientation of polygon...ick + /// + /// The i. + /// The xv. + /// The yv. + /// Length of the xv. + /// + /// true if the specified i is ear; otherwise, false. + /// + private static bool IsEar(int i, float[] xv, float[] yv, int xvLength) + { + float dx0, dy0, dx1, dy1; + if (i >= xvLength || i < 0 || xvLength < 3) + { + return false; + } + int upper = i + 1; + int lower = i - 1; + if (i == 0) + { + dx0 = xv[0] - xv[xvLength - 1]; + dy0 = yv[0] - yv[xvLength - 1]; + dx1 = xv[1] - xv[0]; + dy1 = yv[1] - yv[0]; + lower = xvLength - 1; + } + else if (i == xvLength - 1) + { + dx0 = xv[i] - xv[i - 1]; + dy0 = yv[i] - yv[i - 1]; + dx1 = xv[0] - xv[i]; + dy1 = yv[0] - yv[i]; + upper = 0; + } + else + { + dx0 = xv[i] - xv[i - 1]; + dy0 = yv[i] - yv[i - 1]; + dx1 = xv[i + 1] - xv[i]; + dy1 = yv[i + 1] - yv[i]; + } + float cross = dx0 * dy1 - dx1 * dy0; + if (cross > 0) + return false; + Triangle myTri = new Triangle(xv[i], yv[i], xv[upper], yv[upper], + xv[lower], yv[lower]); + for (int j = 0; j < xvLength; ++j) + { + if (j == i || j == lower || j == upper) + continue; + if (myTri.IsInside(xv[j], yv[j])) + return false; + } + return true; + } + + private static void ReversePolygon(float[] x, float[] y, int n) + { + if (n == 1) + return; + int low = 0; + int high = n - 1; + while (low < high) + { + float buffer = x[low]; + x[low] = x[high]; + x[high] = buffer; + buffer = y[low]; + y[low] = y[high]; + y[high] = buffer; + ++low; + --high; + } + } + + /// + /// Decomposes a non-convex polygon into a number of convex polygons, up + /// to maxPolys (remaining pieces are thrown out, but the total number + /// is returned, so the return value can be greater than maxPolys). + /// + /// Each resulting polygon will have no more than maxVerticesPerPolygon + /// vertices (set to b2MaxPolyVertices by default, though you can change + /// this). + /// + /// Returns -1 if operation fails (usually due to self-intersection of + /// polygon). + /// + /// The p. + /// The results. + /// The max polys. + /// + private static int DecomposeConvex(Polygon p, out Polygon[] results, int maxPolys) + { + results = new Polygon[1]; + + if (p.nVertices < 3) return 0; + + Triangle[] triangulated = new Triangle[p.nVertices - 2]; + int nTri; + if (p.IsCCW()) + { + //printf("It is ccw \n"); + Polygon tempP = new Polygon(p); + ReversePolygon(tempP.x, tempP.y, tempP.nVertices); + nTri = TriangulatePolygon(tempP.x, tempP.y, tempP.nVertices, out triangulated); + // ReversePolygon(p->x, p->y, p->nVertices); //reset orientation + } + else + { + //printf("It is not ccw \n"); + nTri = TriangulatePolygon(p.x, p.y, p.nVertices, out triangulated); + } + if (nTri < 1) + { + //Still no luck? Oh well... + return -1; + } + int nPolys = PolygonizeTriangles(triangulated, nTri, out results, maxPolys); + return nPolys; + } + + public static Vertices[] DecomposeVertices(Vertices v, int max) + { + Polygon p = new Polygon(v.ToArray(), v.Count); // convert the vertices to a polygon + + Polygon[] output; + + DecomposeConvex(p, out output, max); + + Vertices[] verticesOut = new Vertices[output.Length]; + + int i; + + for (i = 0; i < output.Length; i++) + { + if (output[i] != null) + { + verticesOut[i] = new Vertices(); + + for (int j = 0; j < output[i].nVertices; j++) + verticesOut[i].Add(new Vector2(output[i].x[j], output[i].y[j])); + } + else + break; + } + + Vertices[] verts = new Vertices[i]; + for (int k = 0; k < i; k++) + { + verts[k] = new Vertices(verticesOut[k]); + } + + return verts; + } + } + + #endregion + + #region DrDeth's Extension + /// + /// Enumerator to specify errors with Polygon functions. + /// + public enum PolyUnionError + { + None, + NoIntersections, + Poly1InsidePoly2, + InfiniteLoop + } + + public class Edge + { + public Edge(Vector2 edgeStart, Vector2 edgeEnd) + { + EdgeStart = edgeStart; + EdgeEnd = edgeEnd; + } + + public Vector2 EdgeStart { get; private set; } + public Vector2 EdgeEnd { get; private set; } + } + + public class EdgeIntersectInfo + { + public EdgeIntersectInfo(Edge edgeOne, Edge edgeTwo, Vector2 intersectionPoint) + { + EdgeOne = edgeOne; + EdgeTwo = edgeTwo; + IntersectionPoint = intersectionPoint; + } + + public Edge EdgeOne { get; private set; } + public Edge EdgeTwo { get; private set; } + public Vector2 IntersectionPoint { get; private set; } + } + #endregion + + + + + + + + + + + + public static class Calculator + { + public const float DegreesToRadiansRatio = 57.29577957855f; + public const float RadiansToDegreesRatio = 1f / 57.29577957855f; + //NOTE: Commented line, use MathHelper.TwoPi instead + //public const float TwoPi = 6.28318531f; + private static Vector2 _curveEnd; + private static Random _random = new Random(); + private static Vector2 _startCurve; + private static Vector2 _temp; + + /// Temp variables to speed up the following code. + private static float _tPow2; + + private static float _wayToGo; + private static float _wayToGoPow2; + + public static float Sin(float angle) + { + return (float)Math.Sin(angle); + } + + public static float Cos(float angle) + { + return (float)Math.Cos(angle); + } + + public static float ACos(float value) + { + return (float)Math.Acos(value); + } + + public static float ATan2(float y, float x) + { + return (float)Math.Atan2(y, x); + } + + //performs bilinear interpolation of a point + public static float BiLerp(Vector2 point, Vector2 min, Vector2 max, float value1, float value2, float value3, + float value4, float minValue, float maxValue) + { + float x = point.X; + float y = point.Y; + + x = MathHelper.Clamp(x, min.X, max.X); + y = MathHelper.Clamp(y, min.Y, max.Y); + + float xRatio = (x - min.X) / (max.X - min.X); + float yRatio = (y - min.Y) / (max.Y - min.Y); + + float top = MathHelper.Lerp(value1, value4, xRatio); + float bottom = MathHelper.Lerp(value2, value3, xRatio); + + float value = MathHelper.Lerp(top, bottom, yRatio); + value = MathHelper.Clamp(value, minValue, maxValue); + return value; + } + + public static float Clamp(float value, float low, float high) + { + return Math.Max(low, Math.Min(value, high)); + } + + public static float DistanceBetweenPointAndPoint(Vector2 point1, Vector2 point2) + { + Vector2 v = Vector2.Subtract(point1, point2); + return v.Length(); + } + + public static float DistanceBetweenPointAndPoint(ref Vector2 point1, ref Vector2 point2) + { + Vector2 v; + Vector2.Subtract(ref point1, ref point2, out v); + return v.Length(); + } + + public static float DistanceBetweenPointAndLineSegment(Vector2 point, Vector2 lineEndPoint1, + Vector2 lineEndPoint2) + { + Vector2 v = Vector2.Subtract(lineEndPoint2, lineEndPoint1); + Vector2 w = Vector2.Subtract(point, lineEndPoint1); + + float c1 = Vector2.Dot(w, v); + if (c1 <= 0) return DistanceBetweenPointAndPoint(point, lineEndPoint1); + + float c2 = Vector2.Dot(v, v); + if (c2 <= c1) return DistanceBetweenPointAndPoint(point, lineEndPoint2); + + float b = c1 / c2; + Vector2 pointOnLine = Vector2.Add(lineEndPoint1, Vector2.Multiply(v, b)); + return DistanceBetweenPointAndPoint(point, pointOnLine); + } + + public static float Cross(Vector2 value1, Vector2 value2) + { + return value1.X * value2.Y - value1.Y * value2.X; + } + + public static Vector2 Cross(Vector2 value1, float value2) + { + return new Vector2(value2 * value1.Y, -value2 * value1.X); + } + + public static Vector2 Cross(float value2, Vector2 value1) + { + return new Vector2(-value2 * value1.Y, value2 * value1.X); + } + + public static void Cross(ref Vector2 value1, ref Vector2 value2, out float ret) + { + ret = value1.X * value2.Y - value1.Y * value2.X; + } + + public static void Cross(ref Vector2 value1, ref float value2, out Vector2 ret) + { + ret = value1; //necassary to get past a compile error on 360 + ret.X = value2 * value1.Y; + ret.Y = -value2 * value1.X; + } + + public static void Cross(ref float value2, ref Vector2 value1, out Vector2 ret) + { + ret = value1; //necassary to get past a compile error on 360 + ret.X = -value2 * value1.Y; + ret.Y = value2 * value1.X; + } + + public static Vector2 Project(Vector2 projectVector, Vector2 onToVector) + { + float multiplier = 0; + float numerator = (onToVector.X * projectVector.X + onToVector.Y * projectVector.Y); + float denominator = (onToVector.X * onToVector.X + onToVector.Y * onToVector.Y); + + if (denominator != 0) + { + multiplier = numerator / denominator; + } + + return Vector2.Multiply(onToVector, multiplier); + } + + public static void Truncate(ref Vector2 vector, float maxLength, out Vector2 truncatedVector) + { + float length = vector.Length(); + length = Math.Min(length, maxLength); + if (length > 0) + { + vector.Normalize(); + } + Vector2.Multiply(ref vector, length, out truncatedVector); + } + + public static float DegreesToRadians(float degrees) + { + return degrees * RadiansToDegreesRatio; + } + + public static float RandomNumber(float min, float max) + { + return (float)((max - min) * _random.NextDouble() + min); + } + + public static bool IsBetweenNonInclusive(float number, float min, float max) + { + if (number > min && number < max) + { + return true; + } + return false; + } + + public static float VectorToRadians(Vector2 vector) + { + return (float)Math.Atan2(vector.X, -(double)vector.Y); + } + + public static Vector2 RadiansToVector(float radians) + { + return new Vector2((float)Math.Sin(radians), -(float)Math.Cos(radians)); + } + + public static void RadiansToVector(float radians, ref Vector2 vector) + { + vector.X = (float)Math.Sin(radians); + vector.Y = -(float)Math.Cos(radians); + } + + public static void RotateVector(ref Vector2 vector, float radians) + { + float length = vector.Length(); + float newRadians = (float)Math.Atan2(vector.X, -(double)vector.Y) + radians; + + vector.X = (float)Math.Sin(newRadians) * length; + vector.Y = -(float)Math.Cos(newRadians) * length; + } + + /// + /// + /// + /// + /// + /// Value between 0.0f and 1.0f. + /// + public static Vector2 LinearBezierCurve(Vector2 start, Vector2 end, float t) + { + return start + (end - start) * t; + } + + /// + /// + /// + /// + /// + /// + /// Value between 0.0f and 1.0f. + /// + public static Vector2 QuadraticBezierCurve(Vector2 start, Vector2 curve, Vector2 end, float t) + { + _wayToGo = 1.0f - t; + + return _wayToGo * _wayToGo * start + + 2.0f * t * _wayToGo * curve + + t * t * end; + } + + public static Vector2 QuadraticBezierCurve(Vector2 start, Vector2 curve, Vector2 end, float t, ref float radians) + { + _startCurve = start + (curve - start) * t; + _curveEnd = curve + (end - curve) * t; + _temp = _curveEnd - _startCurve; + + radians = (float)Math.Atan2(_temp.X, -(double)_temp.Y); + return _startCurve + _temp * t; + } + + public static Vector2 CubicBezierCurve2(Vector2 start, Vector2 startPointsTo, Vector2 end, Vector2 endPointsTo, + float t) + { + return CubicBezierCurve(start, start + startPointsTo, end + endPointsTo, end, t); + } + + public static Vector2 CubicBezierCurve2(Vector2 start, Vector2 startPointsTo, Vector2 end, Vector2 endPointsTo, + float t, ref float radians) + { + return CubicBezierCurve(start, start + startPointsTo, end + endPointsTo, end, t, ref radians); + } + + public static Vector2 CubicBezierCurve2(Vector2 start, float startPointDirection, float startPointLength, + Vector2 end, float endPointDirection, float endPointLength, + float t, ref float radians) + { + return CubicBezierCurve(start, + RadiansToVector(startPointDirection) * startPointLength, + RadiansToVector(endPointDirection) * endPointLength, + end, + t, + ref radians); + } + + public static Vector2 CubicBezierCurve(Vector2 start, Vector2 curve1, Vector2 curve2, Vector2 end, float t) + { + _tPow2 = t * t; + _wayToGo = 1.0f - t; + _wayToGoPow2 = _wayToGo * _wayToGo; + + return _wayToGo * _wayToGoPow2 * start + + 3.0f * t * _wayToGoPow2 * curve1 + + 3.0f * _tPow2 * _wayToGo * curve2 + + t * _tPow2 * end; + } + + public static Vector2 CubicBezierCurve(Vector2 start, Vector2 curve1, Vector2 curve2, Vector2 end, float t, + ref float radians) + { + return QuadraticBezierCurve(start + (curve1 - start) * t, + curve1 + (curve2 - curve1) * t, + curve2 + (end - curve2) * t, + t, + ref radians); + } + + //Interpolate normal vectors ... + public static Vector2 InterpolateNormal(Vector2 vector1, Vector2 vector2, float t) + { + vector1 += (vector2 - vector1) * t; + vector1.Normalize(); + + return vector1; + } + + public static void InterpolateNormal(Vector2 vector1, Vector2 vector2, float t, out Vector2 vector) + { + vector = vector1 + (vector2 - vector1) * t; + vector.Normalize(); + } + + public static void InterpolateNormal(ref Vector2 vector1, Vector2 vector2, float t) + { + vector1 += (vector2 - vector1) * t; + vector1.Normalize(); + } + + public static float InterpolateRotation(float radians1, float radians2, float t) + { + Vector2 vector1 = new Vector2((float)Math.Sin(radians1), -(float)Math.Cos(radians1)); + Vector2 vector2 = new Vector2((float)Math.Sin(radians2), -(float)Math.Cos(radians2)); + + vector1 += (vector2 - vector1) * t; + vector1.Normalize(); + + return (float)Math.Atan2(vector1.X, -(double)vector1.Y); + } + + public static void ProjectToAxis(ref Vector2[] points, ref Vector2 axis, out float min, out float max) + { + // To project a point on an axis use the dot product + axis.Normalize(); + float dotProduct = Vector2.Dot(axis, points[0]); + min = dotProduct; + max = dotProduct; + + for (int i = 0; i < points.Length; i++) + { + dotProduct = Vector2.Dot(points[i], axis); + if (dotProduct < min) + { + min = dotProduct; + } + else + { + if (dotProduct > max) + { + max = dotProduct; + } + } + } + } + } + + + + + + + + + + + + + + + +}