From eed42ea361b306aef486ff669f32c0e95b89ec3c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A1=D0=BB=D0=B0=D0=B2=D0=B0?= Date: Mon, 3 Jun 2024 02:56:28 +0400 Subject: [PATCH] s --- .../AbstractCompany.cs | 123 ++ .../CollectionType.cs | 18 + .../CruiserDockingService.cs | 69 + .../ICollectionGenericObjects.cs | 61 + .../ListGenericObjects.cs | 91 + .../MassiveGenericObjects.cs | 147 ++ .../StorageCollection.cs | 218 +++ ProjectPlane/ProjectPlane/CruiserDelegate.cs | 10 + .../ProjectPlane/Drawnings/DirectionType.cs | 27 + .../ProjectPlane/Drawnings/DrawningCruiser.cs | 230 +++ .../Drawnings/DrawningMilitaryCruiser.cs | 75 + .../Drawnings/ExtentionDrawningCruiser.cs | 50 + .../ProjectPlane/Entities/EntityCruiser.cs | 69 + .../Entities/EntityMilitaryCruiser.cs | 62 + .../Exceptions/CollectionOverflowException.cs | 25 + .../Exceptions/ObjectNotFoundException.cs | 27 + .../PositionOutOfCollectionException.cs | 26 + .../ProjectPlane/FormCruiser.Designer.cs | 151 ++ ProjectPlane/ProjectPlane/FormCruiser.cs | 139 ++ ProjectPlane/ProjectPlane/FormCruiser.resx | 1540 +++++++++++++++++ .../FormCruiserConfing.Designer.cs | 370 ++++ .../ProjectPlane/FormCruiserConfing.cs | 176 ++ .../ProjectPlane/FormCruiserConfing.resx | 120 ++ .../FormCruisersCollection.Designer.cs | 346 ++++ .../ProjectPlane/FormCruisersCollection.cs | 306 ++++ .../ProjectPlane/FormCruisersCollection.resx | 132 ++ .../MovementStrategy/AbstractStrategy.cs | 123 ++ .../MovementStrategy/IMoveableObject.cs | 24 + .../MovementStrategy/MoveToBorder.cs | 53 + .../MovementStrategy/MoveToCenter.cs | 53 + .../MovementStrategy/MoveableCruiser.cs | 62 + .../MovementStrategy/MovementDirection.cs | 26 + .../MovementStrategy/ObjectParameters.cs | 64 + .../MovementStrategy/StrategyStatus.cs | 22 + ProjectPlane/ProjectPlane/Program.cs | 45 + ProjectPlane/ProjectPlane/nlog.config | 14 + ProjectPlane/ProjectPlane/serilogConfig.json | 20 + 37 files changed, 5114 insertions(+) create mode 100644 ProjectPlane/ProjectPlane/CollectionGenericObjects/AbstractCompany.cs create mode 100644 ProjectPlane/ProjectPlane/CollectionGenericObjects/CollectionType.cs create mode 100644 ProjectPlane/ProjectPlane/CollectionGenericObjects/CruiserDockingService.cs create mode 100644 ProjectPlane/ProjectPlane/CollectionGenericObjects/ICollectionGenericObjects.cs create mode 100644 ProjectPlane/ProjectPlane/CollectionGenericObjects/ListGenericObjects.cs create mode 100644 ProjectPlane/ProjectPlane/CollectionGenericObjects/MassiveGenericObjects.cs create mode 100644 ProjectPlane/ProjectPlane/CollectionGenericObjects/StorageCollection.cs create mode 100644 ProjectPlane/ProjectPlane/CruiserDelegate.cs create mode 100644 ProjectPlane/ProjectPlane/Drawnings/DirectionType.cs create mode 100644 ProjectPlane/ProjectPlane/Drawnings/DrawningCruiser.cs create mode 100644 ProjectPlane/ProjectPlane/Drawnings/DrawningMilitaryCruiser.cs create mode 100644 ProjectPlane/ProjectPlane/Drawnings/ExtentionDrawningCruiser.cs create mode 100644 ProjectPlane/ProjectPlane/Entities/EntityCruiser.cs create mode 100644 ProjectPlane/ProjectPlane/Entities/EntityMilitaryCruiser.cs create mode 100644 ProjectPlane/ProjectPlane/Exceptions/CollectionOverflowException.cs create mode 100644 ProjectPlane/ProjectPlane/Exceptions/ObjectNotFoundException.cs create mode 100644 ProjectPlane/ProjectPlane/Exceptions/PositionOutOfCollectionException.cs create mode 100644 ProjectPlane/ProjectPlane/FormCruiser.Designer.cs create mode 100644 ProjectPlane/ProjectPlane/FormCruiser.cs create mode 100644 ProjectPlane/ProjectPlane/FormCruiser.resx create mode 100644 ProjectPlane/ProjectPlane/FormCruiserConfing.Designer.cs create mode 100644 ProjectPlane/ProjectPlane/FormCruiserConfing.cs create mode 100644 ProjectPlane/ProjectPlane/FormCruiserConfing.resx create mode 100644 ProjectPlane/ProjectPlane/FormCruisersCollection.Designer.cs create mode 100644 ProjectPlane/ProjectPlane/FormCruisersCollection.cs create mode 100644 ProjectPlane/ProjectPlane/FormCruisersCollection.resx create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/AbstractStrategy.cs create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/IMoveableObject.cs create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/MoveToBorder.cs create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/MoveToCenter.cs create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/MoveableCruiser.cs create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/MovementDirection.cs create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/ObjectParameters.cs create mode 100644 ProjectPlane/ProjectPlane/MovementStrategy/StrategyStatus.cs create mode 100644 ProjectPlane/ProjectPlane/Program.cs create mode 100644 ProjectPlane/ProjectPlane/nlog.config create mode 100644 ProjectPlane/ProjectPlane/serilogConfig.json diff --git a/ProjectPlane/ProjectPlane/CollectionGenericObjects/AbstractCompany.cs b/ProjectPlane/ProjectPlane/CollectionGenericObjects/AbstractCompany.cs new file mode 100644 index 0000000..079c3fa --- /dev/null +++ b/ProjectPlane/ProjectPlane/CollectionGenericObjects/AbstractCompany.cs @@ -0,0 +1,123 @@ +using ProjectCruiser.Drawnings; +using ProjectCruiser.Exceptions; + +namespace ProjectCruiser.CollectionGenericObjects +{ + /// + /// Абстракция компании, хранящий коллекцию автомобилей + /// + public abstract class AbstractCompany + { + /// + /// Размер места (ширина) + /// + protected readonly int _placeSizeWidth = 180; + + /// + /// Размер места (высота) + /// + protected readonly int _placeSizeHeight = 70; + + /// + /// Ширина окна + /// + protected readonly int _pictureWidth; + + /// + /// Высота окна + /// + protected readonly int _pictureHeight; + + /// + /// Коллекция крейсеров + /// + protected ICollectionGenericObjects? _collection = null; + + /// + /// Вычисление максимального количества элементов, который можно разместить в окне + /// + private int GetMaxCount => (_pictureWidth / _placeSizeWidth) * (_pictureHeight / _placeSizeHeight); + + /// + /// Конструктор + /// + /// Ширина окна + /// Высота окна + /// Коллекция автомобилей + public AbstractCompany(int picWidth, int picHeight, + ICollectionGenericObjects collection) + { + _pictureWidth = picWidth; + _pictureHeight = picHeight; + _collection = collection; + _collection.MaxCount = GetMaxCount; + } + + /// + /// Перегрузка оператора сложения для класса + /// + /// Компания + /// Добавляемый объект + /// + public static int operator +(AbstractCompany company, DrawningCruiser сruiser) + { + return company._collection.Insert(сruiser); + } + + /// + /// Перегрузка оператора удаления для класса + /// + /// Компания + /// Номер удаляемого объекта + /// + public static DrawningCruiser operator -(AbstractCompany company, int position) + { + return company._collection?.Remove(position); + } + + /// + /// Получение случайного объекта из коллекции + /// + /// + public DrawningCruiser? GetRandomObject() + { + Random rnd = new(); + return _collection?.Get(rnd.Next(GetMaxCount)); + } + + /// + /// Вывод всей коллекции + /// + /// + public Bitmap? Show() + { + Bitmap bitmap = new(_pictureWidth, _pictureHeight); + Graphics graphics = Graphics.FromImage(bitmap); + DrawBackgound(graphics); + SetObjectsPosition(); + for (int i = 0; i < (_collection?.Count ?? 0); ++i) + { + try + { + DrawningCruiser? obj = _collection?.Get(i); + obj?.DrawTransport(graphics); + } + catch (ObjectNotFoundException e) + { } + catch (PositionOutOfCollectionException e) + { } + } + return bitmap; + } + /// + /// Вывод заднего фона + /// + /// + protected abstract void DrawBackgound(Graphics g); + + /// + /// Расстановка объектов + /// + protected abstract void SetObjectsPosition(); + } +} diff --git a/ProjectPlane/ProjectPlane/CollectionGenericObjects/CollectionType.cs b/ProjectPlane/ProjectPlane/CollectionGenericObjects/CollectionType.cs new file mode 100644 index 0000000..ddde682 --- /dev/null +++ b/ProjectPlane/ProjectPlane/CollectionGenericObjects/CollectionType.cs @@ -0,0 +1,18 @@ +namespace ProjectCruiser.CollectionGenericObjects +{ + public enum CollectionType + { + /// + /// Неопределено + /// + None = 0, + /// + /// Массив + /// + Massive = 1, + /// + /// Список + /// + List = 2 + } +} diff --git a/ProjectPlane/ProjectPlane/CollectionGenericObjects/CruiserDockingService.cs b/ProjectPlane/ProjectPlane/CollectionGenericObjects/CruiserDockingService.cs new file mode 100644 index 0000000..7fac20c --- /dev/null +++ b/ProjectPlane/ProjectPlane/CollectionGenericObjects/CruiserDockingService.cs @@ -0,0 +1,69 @@ +using ProjectCruiser.Drawnings; +using ProjectCruiser.Exceptions; + +namespace ProjectCruiser.CollectionGenericObjects +{ + /// + /// Реализация абстрактной компании - каршеринг + /// + public class CruiserDockingService : AbstractCompany + { + /// + /// Конструктор + /// + /// + /// + /// + public CruiserDockingService(int picWidth, int picHeight, + ICollectionGenericObjects collection) : base(picWidth, picHeight, collection) + { + } + protected override void DrawBackgound(Graphics g) + { + int width = _pictureWidth / _placeSizeWidth; + int height = _pictureHeight / _placeSizeHeight; + Pen pen = new(Color.Black, 2); + for (int i = 0; i < width; i++) + { + for (int j = 0; j < height + 1; ++j) + { + g.DrawLine(pen, i * _placeSizeWidth, j * _placeSizeHeight, i * _placeSizeWidth + _placeSizeWidth - 20, j * _placeSizeHeight); + g.DrawLine(pen, i * _placeSizeWidth + _placeSizeWidth - 20, j * _placeSizeHeight, i * _placeSizeWidth + _placeSizeWidth - 20, j * _placeSizeHeight + _placeSizeHeight); + } + } + } + protected override void SetObjectsPosition() + { + int width = _pictureWidth / _placeSizeWidth; + int height = _pictureHeight / _placeSizeHeight; + + int curWidth = 0; + int curHeight = 0; + + for (int i = 0; i < (_collection?.Count ?? 0); i++) + { + + try + { + _collection.Get(i).SetPictureSize(_pictureWidth, _pictureHeight); + _collection.Get(i).SetPosition(_placeSizeWidth * curWidth + 10, curHeight * _placeSizeHeight + 10); + } + catch (ObjectNotFoundException) { } + catch(PositionOutOfCollectionException e) { } + + if (curWidth < width - 1) + curWidth++; + else + { + curWidth = 0; + curHeight ++; + } + + if (curHeight >= height) + { + return; + } + } + } + } +} diff --git a/ProjectPlane/ProjectPlane/CollectionGenericObjects/ICollectionGenericObjects.cs b/ProjectPlane/ProjectPlane/CollectionGenericObjects/ICollectionGenericObjects.cs new file mode 100644 index 0000000..d92a50c --- /dev/null +++ b/ProjectPlane/ProjectPlane/CollectionGenericObjects/ICollectionGenericObjects.cs @@ -0,0 +1,61 @@ +namespace ProjectCruiser.CollectionGenericObjects +{ + /// + /// Интерфейс описания действий для набора хранимых объектов + /// + /// Параметр: ограничение - ссылочный тип + public interface ICollectionGenericObjects + where T : class + { + /// + /// Количество объектов в коллекции + /// + int Count { get; } + + /// + /// Установка максимального количества элементов + /// + int MaxCount { get; set; } + + /// + /// Добавление объекта в коллекцию + /// + /// Добавляемый объект + /// true - вставка прошла удачно, false - вставка не удалась + int Insert(T obj); + + /// + /// Добавление объекта в коллекцию на конкретную позицию + /// + /// Добавляемый объект + /// Позиция + /// true - вставка прошла удачно, false - вставка не удалась + int Insert(T obj, int position); + + /// + /// Удаление объекта из коллекции с конкретной позиции + /// + /// Позиция + /// true - удаление прошло удачно, false - удаление не удалось + T? Remove(int position); + + /// + /// Получение объекта по позиции + /// + /// Позиция + /// Объект + T? Get(int position); + + /// + /// Получение типа коллекции + /// + CollectionType GetCollectionType { get; } + /// + /// Получение объектов коллекции по одному + /// + /// Поэлементый вывод элементов коллекции + IEnumerable GetItems(); + + } + +} diff --git a/ProjectPlane/ProjectPlane/CollectionGenericObjects/ListGenericObjects.cs b/ProjectPlane/ProjectPlane/CollectionGenericObjects/ListGenericObjects.cs new file mode 100644 index 0000000..b905497 --- /dev/null +++ b/ProjectPlane/ProjectPlane/CollectionGenericObjects/ListGenericObjects.cs @@ -0,0 +1,91 @@ +using ProjectCruiser.Exceptions; + +namespace ProjectCruiser.CollectionGenericObjects +{ + /// + /// Параметризованный набор объектов + /// + /// Параметр: ограничение - ссылочный тип + public class ListGenericObjects : ICollectionGenericObjects + where T : class + { + /// + /// Список объектов, которые храним + /// + private readonly List _collection; + /// + /// Максимально допустимое число объектов в списке + /// + private int _maxCount; + public int Count => _collection.Count; + public int MaxCount + { + get => _maxCount; + set + { + if (value > 0) + { + _maxCount = value; + } + } + } + + public CollectionType GetCollectionType => CollectionType.List; + + /// + /// Конструктор + /// + public ListGenericObjects() + { + _collection = new(); + } + public T? Get(int position) + { + // TODO проверка позиции + // TODO выброc позиций, если выход за границы массива + if (position >= Count || position < 0) throw new PositionOutOfCollectionException(position); + return _collection[position]; + } + + public int Insert(T obj) + { + // TODO проверка, что не превышено максимальное количество элементов + // TODO выбром позиций, если переполнение + // TODO вставка в конец набора + if (Count == _maxCount) throw new CollectionOverflowException(Count); + _collection.Add(obj); + return Count; + } + + public int Insert(T obj, int position) + { + // TODO проверка, что не превышено максимальное количество элементов + // TODO проверка позиции + // TODO вставка по позиции + if (Count == _maxCount) throw new CollectionOverflowException(Count); + if (position >= Count || position < 0) throw new PositionOutOfCollectionException(position); + _collection.Insert(position, obj); + return position; + + } + + public T Remove(int position) + { + // TODO проверка позиции + // TODO удаление объекта из списка + // TODO выбром позиций, если выход за границы массива + if (position >= _collection.Count || position < 0) throw new PositionOutOfCollectionException(position); + T obj = _collection[position]; + _collection.RemoveAt(position); + return obj; + } + + public IEnumerable GetItems() + { + for (int i = 0; i < _collection.Count; ++i) + { + yield return _collection[i]; + } + } + } +} diff --git a/ProjectPlane/ProjectPlane/CollectionGenericObjects/MassiveGenericObjects.cs b/ProjectPlane/ProjectPlane/CollectionGenericObjects/MassiveGenericObjects.cs new file mode 100644 index 0000000..b428c38 --- /dev/null +++ b/ProjectPlane/ProjectPlane/CollectionGenericObjects/MassiveGenericObjects.cs @@ -0,0 +1,147 @@ +using ProjectCruiser.Exceptions; + +namespace ProjectCruiser.CollectionGenericObjects +{ + /// + /// Параметризованный набор объектов + /// + /// Параметр: ограничение - ссылочный тип + public class MassiveGenericObjects : ICollectionGenericObjects + where T : class + { + /// + /// Массив объектов, которые храним + /// + private T?[] _collection; + public int Count => _collection.Length; + public int MaxCount + { + get + { + return _collection.Length; + } + set + { + if (value > 0) + { + if (_collection.Length > 0) + { + Array.Resize(ref _collection, value); + } + else + { + _collection = new T?[value]; + } + } + } + } + + public CollectionType GetCollectionType => CollectionType.Massive; + + /// + /// Конструктор + /// + public MassiveGenericObjects() + { + _collection = Array.Empty(); + } + public T? Get(int position) + { + // TODO проверка позиции + // TODO выбром позиций, если выход за границы массива + // TODO выбром позиций, если объект пустой + if (position < 0 || position >= Count) throw new PositionOutOfCollectionException(position); + if (_collection[position] == null) throw new ObjectNotFoundException(position); + return _collection[position]; + } + + public int Insert(T obj) + { + // TODO вставка в свободное место набора + // TODO выброc позиций, если переполнение + int index = 0; + while (index < Count && _collection[index] != null) + { + index++; + } + + if (index < Count) + { + _collection[index] = obj; + return index; + } + + throw new CollectionOverflowException(Count); + } + + public int Insert(T obj, int position) + { + // TODO проверка позиции + // TODO проверка, что элемент массива по этой позиции пустой, если нет, то + // ищется свободное место после этой позиции и идет вставка туда + // если нет после, ищем до + // TODO вставка + // TODO выбром позиций, если переполнение + // TODO выбром позиций, если выход за границы массива + if (position < 0 || position >= Count) throw new PositionOutOfCollectionException(position); + + if (_collection[position] != null) + { + bool pushed = false; + for (int index = position + 1; index < Count; index++) + { + if (_collection[index] == null) + { + position = index; + pushed = true; + break; + } + } + + if (!pushed) + { + for (int index = position - 1; index >= 0; index--) + { + if (_collection[index] == null) + { + position = index; + pushed = true; + break; + } + } + } + + if (!pushed) + { + throw new CollectionOverflowException(Count); + } + } + + _collection[position] = obj; + return position; + } + + public T Remove(int position) + { + // TODO проверка позиции + // TODO удаление объекта из массива, присвоив элементу массива значение null + // TODO выбром позиций, если выход за границы массива + // TODO выбром позиций, если объект пустой + if (position < 0 || position >= Count) throw new PositionOutOfCollectionException(position); + + if (_collection[position] == null) throw new ObjectNotFoundException(position); + + T? temp = _collection[position]; + _collection[position] = null; + return temp; + } + + public IEnumerable GetItems() + { + for (int i = 0; i < _collection.Length; ++i) + { + yield return _collection[i]; + } + } + } +} diff --git a/ProjectPlane/ProjectPlane/CollectionGenericObjects/StorageCollection.cs b/ProjectPlane/ProjectPlane/CollectionGenericObjects/StorageCollection.cs new file mode 100644 index 0000000..799e711 --- /dev/null +++ b/ProjectPlane/ProjectPlane/CollectionGenericObjects/StorageCollection.cs @@ -0,0 +1,218 @@ +using ProjectCruiser.Drawnings; +using ProjectCruiser.Exceptions; +using System.Text; + +namespace ProjectCruiser.CollectionGenericObjects +{ + // Класс-хранилище коллекций + /// + /// + public class StorageCollection + where T : DrawningCruiser + { + /// + /// Словарь (хранилище) с коллекциями + /// + readonly Dictionary> _storages; + + /// + /// Возвращение списка названий коллекций + /// + public List Keys => _storages.Keys.ToList(); + + /// + /// Ключевое слово, с которого должен начинаться файл + /// + private readonly string _collectionKey = "CollectionsStorage"; + + /// + /// Разделитель для записи ключа и значения элемента словаря + /// + private readonly string _separatorForKeyValue = "|"; + + /// + /// Разделитель для записей коллекции данных в файл + /// + private readonly string _separatorItems = ";"; + + /// + /// Конструктор + /// + public StorageCollection() + { + _storages = new Dictionary>(); + } + + /// + /// Добавление коллекции в хранилище + /// + /// Название коллекции + /// тип коллекции + public void AddCollection(string name, CollectionType collectionType) + { + // TODO проверка, что name не пустой и нет в словаре записи с таким ключом + // TODO Прописать логику для добавления + + if (_storages.ContainsKey(name)) return; + + if (collectionType == CollectionType.None) return; + else if (collectionType == CollectionType.Massive) + _storages[name] = new MassiveGenericObjects(); + else if (collectionType == CollectionType.List) + _storages[name] = new ListGenericObjects(); + } + + /// + /// Удаление коллекции + /// + /// Название коллекции + public void DelCollection(string name) + { + // TODO Прописать логику для удаления коллекции + if (_storages.ContainsKey(name)) + _storages.Remove(name); + } + + /// + /// Доступ к коллекции + /// + /// Название коллекции + /// + public ICollectionGenericObjects? this[string name] + { + get + { + // TODO Продумать логику получения объекта + if (_storages.ContainsKey(name)) + return _storages[name]; + return null; + } + } + + /// + /// Сохранение информации по самолетам в хранилище в файл + /// + /// Путь и имя файла + /// true - сохранение прошло успешно, false - ошибка при сохранении данных + public void SaveData(string filename) + { + if (_storages.Count == 0) + { + throw new Exception("В хранилище отсутствуют коллекции для сохранения"); + } + + + if (File.Exists(filename)) + { + File.Delete(filename); + } + + using FileStream fs = new(filename, FileMode.Create); + using StreamWriter streamWriter = new StreamWriter(fs); + streamWriter.Write(_collectionKey); + + foreach (KeyValuePair> value in _storages) + { + streamWriter.Write(Environment.NewLine); + + if (value.Value.Count == 0) + { + continue; + } + + streamWriter.Write(value.Key); + streamWriter.Write(_separatorForKeyValue); + streamWriter.Write(value.Value.GetCollectionType); + streamWriter.Write(_separatorForKeyValue); + streamWriter.Write(value.Value.MaxCount); + streamWriter.Write(_separatorForKeyValue); + + + foreach (T? item in value.Value.GetItems()) + { + string data = item?.GetDataForSave() ?? string.Empty; + if (string.IsNullOrEmpty(data)) + { + continue; + } + + + streamWriter.Write(data); + streamWriter.Write(_separatorItems); + + } + } + } + /// + /// Загрузка информации по кораблям в хранилище из файла + /// + /// + public void LoadData(string filename) + { + if (!File.Exists(filename)) + { + throw new FileNotFoundException("Файл не существует"); + } + + using (StreamReader sr = new StreamReader(filename)) + { + string? str; + str = sr.ReadLine(); + if (str != _collectionKey.ToString()) + throw new FormatException("В файле неверные данные"); + _storages.Clear(); + while ((str = sr.ReadLine()) != null) + { + string[] record = str.Split(_separatorForKeyValue); + if (record.Length != 4) + { + continue; + } + CollectionType collectionType = (CollectionType)Enum.Parse(typeof(CollectionType), record[1]); + ICollectionGenericObjects? collection = StorageCollection.CreateCollection(collectionType); + if (collection == null) + { + throw new InvalidOperationException("Не удалось определить тип коллекции:" + record[1]); + } + + collection.MaxCount = Convert.ToInt32(record[2]); + + string[] set = record[3].Split(_separatorItems, StringSplitOptions.RemoveEmptyEntries); + foreach (string elem in set) + { + if (elem?.CreateDrawningCruiser() is T aircraft) + { + try + { + if (collection.Insert(aircraft) == -1) + { + throw new InvalidOperationException("Объект не удалось добавить в коллекцию: " + record[3]); + } + } + catch (CollectionOverflowException ex) + { + throw new CollectionOverflowException("Коллекция переполнена", ex); + } + } + } + _storages.Add(record[0], collection); + } + } + } + + /// + /// Создание коллекции по типу + /// + /// + /// + private static ICollectionGenericObjects? CreateCollection(CollectionType collectionType) + { + return collectionType switch + { + CollectionType.Massive => new MassiveGenericObjects(), + CollectionType.List => new ListGenericObjects(), + _ => null, + }; + } + } +} diff --git a/ProjectPlane/ProjectPlane/CruiserDelegate.cs b/ProjectPlane/ProjectPlane/CruiserDelegate.cs new file mode 100644 index 0000000..bf1a09d --- /dev/null +++ b/ProjectPlane/ProjectPlane/CruiserDelegate.cs @@ -0,0 +1,10 @@ +using ProjectCruiser.Drawnings; + +namespace ProjectCruiser; + +/// +/// Делегат передачи объекта класса-прорисвоки +/// +/// +public delegate void CruiserDelegate(DrawningCruiser cruiser); + diff --git a/ProjectPlane/ProjectPlane/Drawnings/DirectionType.cs b/ProjectPlane/ProjectPlane/Drawnings/DirectionType.cs new file mode 100644 index 0000000..1ef4846 --- /dev/null +++ b/ProjectPlane/ProjectPlane/Drawnings/DirectionType.cs @@ -0,0 +1,27 @@ +namespace ProjectCruiser.Drawnings; +/// +/// +/// +public enum DirectionType +{ + /// + /// + /// + Unknow = -1, + /// + /// + /// + Up = 1, + /// + /// + /// + Down = 2, + /// + /// + /// + Left = 3, + /// + /// + /// + Right = 4 +} \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/Drawnings/DrawningCruiser.cs b/ProjectPlane/ProjectPlane/Drawnings/DrawningCruiser.cs new file mode 100644 index 0000000..ece51ce --- /dev/null +++ b/ProjectPlane/ProjectPlane/Drawnings/DrawningCruiser.cs @@ -0,0 +1,230 @@ +using ProjectCruiser.Entities; + +namespace ProjectCruiser.Drawnings; +/// +/// Класс, отвечающий за прорисовку и перемещение объекта-сущности +/// +public class DrawningCruiser +{ + /// + /// Класс-сущность + /// + public EntityCruiser? EntityCruiser { get; protected set; } + /// + /// Ширина окна + /// + private int? _pictureWidth; + /// + /// Высота окна + /// + private int? _pictureHeight; + /// + /// Левая координата прорисовки крейсера + /// + protected int? _startPosX; + /// + /// Верхняя кооридната прорисовки крейсера + /// + protected int? _startPosY; + + /// + /// Ширина прорисовки крейсера + /// + private readonly int _drawningCruiserWidth = 150; + /// + /// Высота прорисовки крейсера + /// + private readonly int _drawningCruiserHeight = 50; + private readonly int _drawningEnginesWidth = 3; + + /// + /// Координата X объекта + /// + public int? GetPosX => _startPosX; + /// + /// Координата Y объекта + /// + public int? GetPosY => _startPosY; + /// + /// Ширина объекта + /// + public int GetWidth => _drawningCruiserWidth; + /// + /// Высота объекта + /// + public int GetHeight => _drawningCruiserHeight; + + /// + /// Пустой онструктор + /// + public DrawningCruiser() + { + _pictureWidth = null; + _pictureHeight = null; + _startPosX = null; + _startPosY = null; + } + + /// + /// Конструктор + /// + /// Скорость + /// Вес + /// Основной цвет + public DrawningCruiser(int speed, double weight, Color bodyColor) : this() + { + EntityCruiser = new EntityCruiser(speed, weight, bodyColor); + } + /// + /// Конструктор для наследников + /// + /// Ширина прорисовки автомобиля + /// Высота прорисовки автомобиля + protected DrawningCruiser(int drawningCarWidth, int drawningCarHeight) : this() + { + _drawningCruiserWidth = drawningCarWidth; + _pictureHeight = drawningCarHeight; + } + + /// + /// конструктор + /// + /// + public DrawningCruiser(EntityCruiser entityCruiser) + { + EntityCruiser = entityCruiser; + } + + /// + /// Установка границ поля + /// + /// Ширина поля + /// Высота поля + /// true - границы заданы, false - проверка не пройдена, нельзя разместить объект в этих размерах + public bool SetPictureSize(int width, int height) + { + // TODO проверка, что объект "влезает" в размеры поля + // если влезает, сохраняем границы и корректируем позицию объекта,если она была уже установлена + + if (_drawningCruiserHeight > height || _drawningCruiserWidth > width) + { + return false; + + } + + _pictureWidth = width; + _pictureHeight = height; + + if (_startPosX.HasValue && _startPosY.HasValue) + { + SetPosition(_startPosX.Value, _startPosY.Value); + } + + return true; + } + /// + /// Установка позиции + /// + /// Координата X + /// Координата Y + public void SetPosition(int x, int y) + { + if (!_pictureHeight.HasValue || !_pictureWidth.HasValue) + { + return; + } + + if (x < 0 || x + _drawningCruiserWidth > _pictureWidth || y < 0 || y + _drawningCruiserHeight > _pictureHeight) + { + _startPosX = _pictureWidth - _drawningCruiserWidth; + _startPosY = _pictureHeight - _drawningCruiserHeight; + } + else + { + _startPosX = x; + _startPosY = y; + } + + } + /// + /// Изменение направления перемещения + /// + /// Направление + /// true - перемещене выполнено, false - перемещение невозможно + public bool MoveTransport(DirectionType direction) + { + if (EntityCruiser == null || !_startPosX.HasValue || !_startPosY.HasValue) + { + return false; + } + switch (direction) + { + //влево + case DirectionType.Left: + if (_startPosX.Value - EntityCruiser.Step - _drawningEnginesWidth > 0) + { + _startPosX -= (int)EntityCruiser.Step; + } + return true; + //вверх + case DirectionType.Up: + if (_startPosY.Value - EntityCruiser.Step > 0) + { + _startPosY -= (int)EntityCruiser.Step; + } + return true; + // вправо + case DirectionType.Right: + //TODO прописать логику сдвига в право + if (_startPosX.Value + EntityCruiser.Step + _drawningCruiserWidth < _pictureWidth) + { + _startPosX += (int)EntityCruiser.Step; + } + return true; + //вниз + case DirectionType.Down: + if (_startPosY.Value + EntityCruiser.Step + _drawningCruiserHeight < _pictureHeight) + { + _startPosY += (int)EntityCruiser.Step; + } + return true; + default: + return false; + } + } + + /// + /// Прорисовка объекта + /// + /// + public virtual void DrawTransport(Graphics g) + { + if (EntityCruiser == null || !_startPosX.HasValue || + !_startPosY.HasValue) + { + return; + } + Pen pen = new(EntityCruiser.BodyColor, 2); + Brush additionalBrush = new SolidBrush(Color.Black); + + //границы круисера + g.DrawLine(pen, _startPosX.Value, _startPosY.Value, _startPosX.Value + 105, _startPosY.Value); + g.DrawLine(pen, _startPosX.Value + 105, _startPosY.Value, _startPosX.Value + 147, _startPosY.Value + 24); + + g.DrawLine(pen, _startPosX.Value, _startPosY.Value + 49, _startPosX.Value + 105, _startPosY.Value + 49); + g.DrawLine(pen, _startPosX.Value + 105, _startPosY.Value + 49, _startPosX.Value + 147, _startPosY.Value + 24); + + g.DrawLine(pen, _startPosX.Value, _startPosY.Value, _startPosX.Value, _startPosY.Value + 49); + + //внутренности круисера + g.DrawEllipse(pen, _startPosX.Value + 94, _startPosY.Value + 14, 19, 19); + + g.DrawRectangle(pen, _startPosX.Value + 63, _startPosY.Value + 11, 21, 28); + g.DrawRectangle(pen, _startPosX.Value + 35, _startPosY.Value + 17, 28, 14); + + //зад + g.FillRectangle(additionalBrush, _startPosX.Value - 3, _startPosY.Value + 7, 3, 14); + g.FillRectangle(additionalBrush, _startPosX.Value - 3, _startPosY.Value + 26, 3, 14); + + } +} \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/Drawnings/DrawningMilitaryCruiser.cs b/ProjectPlane/ProjectPlane/Drawnings/DrawningMilitaryCruiser.cs new file mode 100644 index 0000000..efd9cce --- /dev/null +++ b/ProjectPlane/ProjectPlane/Drawnings/DrawningMilitaryCruiser.cs @@ -0,0 +1,75 @@ +using System.Drawing.Drawing2D; +using ProjectCruiser.Entities; + +namespace ProjectCruiser.Drawnings +{ + public class DrawningMilitaryCruiser : DrawningCruiser + { + /// + /// Конструктор + /// + /// Скорость + /// Вес + /// Основной цвет + /// Дополнительный цвет + /// Признак наличия вертолетной площадки + /// Признак наличия шлюпок + /// Признак наличия пушки + + public DrawningMilitaryCruiser(int speed, double weight, Color bodyColor, Color additionalColor, bool helicopterArea, bool boat, bool weapon) + : base(150, 50) + { + EntityCruiser = new EntityMilitaryCruiser(speed, weight, bodyColor, additionalColor, helicopterArea, boat, weapon); + } + + public DrawningMilitaryCruiser(EntityCruiser entityCruiser) + { + if (entityCruiser != null) + { + EntityCruiser = entityCruiser; + } + } + + public override void DrawTransport(Graphics g) + { + if (EntityCruiser == null || EntityCruiser is not EntityMilitaryCruiser entityMilitaryCruiser || !_startPosX.HasValue || + !_startPosY.HasValue) + { + return; + } + + Pen pen = new(entityMilitaryCruiser.BodyColor, 2); + Brush additionalBrush = new SolidBrush(Color.Black); + Brush weaponBrush = new SolidBrush(Color.Black); + Brush weaponBrush2 = new SolidBrush(entityMilitaryCruiser.AdditionalColor); + Brush helicopterAreaBrush = new HatchBrush(HatchStyle.ZigZag, entityMilitaryCruiser.AdditionalColor, Color.FromArgb(163, 163, 163)); + Brush boatBrush = new SolidBrush(entityMilitaryCruiser.AdditionalColor); + + base.DrawTransport(g); + + if (entityMilitaryCruiser.HelicopterArea) + { + g.FillEllipse(helicopterAreaBrush, _startPosX.Value + 5, _startPosY.Value + 9, 25, 30); + g.DrawEllipse(pen, _startPosX.Value + 5, _startPosY.Value + 9, 25, 30); + } + + if (entityMilitaryCruiser.Boat) + { + g.DrawEllipse(pen, _startPosX.Value + 34, _startPosY.Value + 2, 30, 7); + g.FillEllipse(boatBrush, _startPosX.Value + 34, _startPosY.Value + 2, 30, 7); + + g.DrawEllipse(pen, _startPosX.Value + 34, _startPosY.Value + 39, 30, 7); + g.FillEllipse(boatBrush, _startPosX.Value + 34, _startPosY.Value + 39, 30, 7); + } + + if (entityMilitaryCruiser.Weapon) + { + g.DrawEllipse(pen, _startPosX.Value + 97, _startPosY.Value + 36, 10, 10); + g.FillEllipse(weaponBrush2, _startPosX.Value + 97, _startPosY.Value + 36, 10, 10); + + g.FillRectangle(weaponBrush, _startPosX.Value + 107, _startPosY.Value + 40, 15, 5); + } + + } + } +} diff --git a/ProjectPlane/ProjectPlane/Drawnings/ExtentionDrawningCruiser.cs b/ProjectPlane/ProjectPlane/Drawnings/ExtentionDrawningCruiser.cs new file mode 100644 index 0000000..4be9fa2 --- /dev/null +++ b/ProjectPlane/ProjectPlane/Drawnings/ExtentionDrawningCruiser.cs @@ -0,0 +1,50 @@ +using ProjectCruiser.Entities; + +namespace ProjectCruiser.Drawnings +{ + public static class ExtentionDrawningCruiser + { + /// + /// Разделитель для записи информации по объекту в файл + /// + private static readonly string _separatorForObject = ":"; + + /// + /// Создание объекта из строки + /// + /// Строка с данными для создания объекта + /// Объект + public static DrawningCruiser? CreateDrawningCruiser(this string info) + { + string[] strs = info.Split(_separatorForObject); + EntityCruiser? cruiser = EntityMilitaryCruiser.CreateEntityMilitaryCruiser(strs); + if (cruiser != null) + { + return new DrawningMilitaryCruiser(cruiser); + } + + cruiser = EntityCruiser.CreateEntityCruiser(strs); + if (cruiser != null) + { + return new DrawningCruiser(cruiser); + } + return null; + } + + /// + /// Получение данных для сохранения в файл + /// + /// Сохраняемый объект + /// Строка с данными по объекту + public static string GetDataForSave(this DrawningCruiser drawningCrusier) + { + string[]? array = drawningCrusier?.EntityCruiser?.GetStringRepresentation(); + if (array == null) + { + return string.Empty; + } + return string.Join(_separatorForObject, array); + } + + } +} diff --git a/ProjectPlane/ProjectPlane/Entities/EntityCruiser.cs b/ProjectPlane/ProjectPlane/Entities/EntityCruiser.cs new file mode 100644 index 0000000..3c9c942 --- /dev/null +++ b/ProjectPlane/ProjectPlane/Entities/EntityCruiser.cs @@ -0,0 +1,69 @@ +namespace ProjectCruiser.Entities; + +/// +/// Класс-сущность "крейсер" +/// +public class EntityCruiser +{ + //свойства + /// + /// Скорость + /// + public int Speed { get; private set; } + + /// + /// Вес + /// + public double Weight { get; private set; } + + /// + /// Основной цвет + /// + public Color BodyColor { get; private set; } + public void setBodyColor(Color color) + { + BodyColor = color; + } + + /// + /// Шаг перемещения автомобиля + /// + public double Step => Speed * 100 / Weight; + + /// + /// Инициализация полей объекта-класса крейсера + /// + /// скорость + /// вес + /// основной цвет + public EntityCruiser(int speed, double weight, Color bodyColor) + { + Speed = speed; + Weight = weight; + BodyColor = bodyColor; + } + + /// + /// Получение строк со значениями свойств объекта класса-сущности + /// + /// + public virtual string[] GetStringRepresentation() + { + return new[] { nameof(EntityCruiser), Speed.ToString(), Weight.ToString(), BodyColor.Name }; + } + + /// + /// Создание объекта из массива строк + /// + /// + /// + public static EntityCruiser? CreateEntityCruiser(string[] strs) + { + if (strs.Length != 4 || strs[0] != nameof(EntityCruiser)) + { + return null; + } + + return new EntityCruiser(Convert.ToInt32(strs[1]), Convert.ToDouble(strs[2]), Color.FromName(strs[3])); + } +} diff --git a/ProjectPlane/ProjectPlane/Entities/EntityMilitaryCruiser.cs b/ProjectPlane/ProjectPlane/Entities/EntityMilitaryCruiser.cs new file mode 100644 index 0000000..b833355 --- /dev/null +++ b/ProjectPlane/ProjectPlane/Entities/EntityMilitaryCruiser.cs @@ -0,0 +1,62 @@ +namespace ProjectCruiser.Entities +{ + internal class EntityMilitaryCruiser : EntityCruiser + { + /// + /// Признак (опция) наличие вертолетной площадки + /// + public bool HelicopterArea { get; private set; } + + /// + /// Признак (опция) наличие шлюпок + /// + public bool Boat { get; private set; } + + /// + /// Признак (опция) наличие пушки + /// + public bool Weapon { get; private set; } + + /// + /// Дополнительный цвет (для опциональных элементов) + /// + public Color AdditionalColor { get; private set; } + public void setAdditionalColor(Color color) + { + AdditionalColor = color; + } + + public EntityMilitaryCruiser(int speed, double weight, Color bodyColor, Color additionalColor, bool helicopterArea, bool boat, bool weapon) : base(speed, weight, bodyColor) + { + AdditionalColor = additionalColor; + HelicopterArea = helicopterArea; + Boat = boat; + Weapon = weapon; + } + + /// + /// Получение строк со значениями свойств объекта класса-сущности + /// + /// + public override string[] GetStringRepresentation() + { + return new[] { nameof(EntityCruiser), Speed.ToString(), Weight.ToString(), BodyColor.Name, AdditionalColor.Name, + HelicopterArea.ToString(), Boat.ToString(), Weapon.ToString() }; + } + + /// + /// Создание объекта из массива строк + /// + /// + /// + public static EntityCruiser? CreateEntityMilitaryCruiser(string[] strs) + { + if (strs.Length != 8 || strs[0] != nameof(EntityCruiser)) + { + return null; + } + return new EntityMilitaryCruiser(Convert.ToInt32(strs[1]), Convert.ToDouble(strs[2]), Color.FromName(strs[3]), Color.FromName(strs[4]), + Convert.ToBoolean(strs[5]), Convert.ToBoolean(strs[6]), Convert.ToBoolean(strs[7])); + } + } +} diff --git a/ProjectPlane/ProjectPlane/Exceptions/CollectionOverflowException.cs b/ProjectPlane/ProjectPlane/Exceptions/CollectionOverflowException.cs new file mode 100644 index 0000000..3027976 --- /dev/null +++ b/ProjectPlane/ProjectPlane/Exceptions/CollectionOverflowException.cs @@ -0,0 +1,25 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.Serialization; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectCruiser.Exceptions; + +/// +/// Класс, описывающий ошибку переполнения коллекции +/// +[Serializable] +internal class CollectionOverflowException : ApplicationException +{ + public CollectionOverflowException(int count) : base("В коллекции превышено допустимое количество: " + count) { } + + public CollectionOverflowException() : base() { } + + public CollectionOverflowException(string message) : base(message) { } + + public CollectionOverflowException(string message, Exception exception) : base(message, exception) { } + + protected CollectionOverflowException(SerializationInfo info, StreamingContext contex) : base(info, contex) { } +} diff --git a/ProjectPlane/ProjectPlane/Exceptions/ObjectNotFoundException.cs b/ProjectPlane/ProjectPlane/Exceptions/ObjectNotFoundException.cs new file mode 100644 index 0000000..0d20713 --- /dev/null +++ b/ProjectPlane/ProjectPlane/Exceptions/ObjectNotFoundException.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.Serialization; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectCruiser.Exceptions; + +/// +/// Класс, описывающий ошибку, что по указанной позиции нет элемента +/// +[Serializable] +internal class ObjectNotFoundException : ApplicationException +{ + public ObjectNotFoundException(int i) : base("Не найден объект по позиции " + i) { } + + public ObjectNotFoundException() : base() { } + + public ObjectNotFoundException(string message) : base(message) { } + + public ObjectNotFoundException(string message, Exception exception) : base(message, exception) { } + + protected ObjectNotFoundException(SerializationInfo info, StreamingContext contex) : base(info, contex) { } +} + + diff --git a/ProjectPlane/ProjectPlane/Exceptions/PositionOutOfCollectionException.cs b/ProjectPlane/ProjectPlane/Exceptions/PositionOutOfCollectionException.cs new file mode 100644 index 0000000..7f6441c --- /dev/null +++ b/ProjectPlane/ProjectPlane/Exceptions/PositionOutOfCollectionException.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.Serialization; +using System.Text; +using System.Threading.Tasks; + +namespace ProjectCruiser.Exceptions; + +/// +/// Класс, описывающий ошибку выхода за границы коллекции +/// +[Serializable] +internal class PositionOutOfCollectionException : ApplicationException +{ + public PositionOutOfCollectionException(int i) : base("Выход за границы коллекции.Позиция " + i) { } + + public PositionOutOfCollectionException() : base() { } + + public PositionOutOfCollectionException(string message) : base(message) { } + + public PositionOutOfCollectionException(string message, Exception exception) : base(message, exception) { } + + protected PositionOutOfCollectionException(SerializationInfo info, StreamingContext contex) : base(info, contex) { } +} + diff --git a/ProjectPlane/ProjectPlane/FormCruiser.Designer.cs b/ProjectPlane/ProjectPlane/FormCruiser.Designer.cs new file mode 100644 index 0000000..af134a6 --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruiser.Designer.cs @@ -0,0 +1,151 @@ +namespace ProjectCruiser +{ + partial class FormCruiser + { + /// + /// 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(FormCruiser)); + pictureBoxCruiser = new PictureBox(); + buttonUp = new Button(); + buttonDown = new Button(); + buttonRight = new Button(); + buttonLeft = new Button(); + comboBoxStrategy = new ComboBox(); + buttonStrategyStep = new Button(); + ((System.ComponentModel.ISupportInitialize)pictureBoxCruiser).BeginInit(); + SuspendLayout(); + // + // pictureBoxCruiser + // + pictureBoxCruiser.Dock = DockStyle.Fill; + pictureBoxCruiser.Location = new Point(0, 0); + pictureBoxCruiser.Name = "pictureBoxCruiser"; + pictureBoxCruiser.Size = new Size(800, 450); + pictureBoxCruiser.SizeMode = PictureBoxSizeMode.AutoSize; + pictureBoxCruiser.TabIndex = 0; + pictureBoxCruiser.TabStop = false; + // + // buttonUp + // + buttonUp.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonUp.BackgroundImage = (Image)resources.GetObject("buttonUp.BackgroundImage"); + buttonUp.BackgroundImageLayout = ImageLayout.Zoom; + buttonUp.Location = new Point(722, 373); + buttonUp.Name = "buttonUp"; + buttonUp.Size = new Size(30, 30); + buttonUp.TabIndex = 2; + buttonUp.UseVisualStyleBackColor = true; + buttonUp.Click += ButtonMove_Click; + // + // buttonDown + // + buttonDown.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonDown.BackgroundImage = (Image)resources.GetObject("buttonDown.BackgroundImage"); + buttonDown.BackgroundImageLayout = ImageLayout.Zoom; + buttonDown.Location = new Point(722, 409); + buttonDown.Name = "buttonDown"; + buttonDown.Size = new Size(30, 30); + buttonDown.TabIndex = 3; + buttonDown.UseVisualStyleBackColor = true; + buttonDown.Click += ButtonMove_Click; + // + // buttonRight + // + buttonRight.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonRight.BackgroundImage = (Image)resources.GetObject("buttonRight.BackgroundImage"); + buttonRight.BackgroundImageLayout = ImageLayout.Zoom; + buttonRight.Location = new Point(758, 409); + buttonRight.Name = "buttonRight"; + buttonRight.Size = new Size(30, 30); + buttonRight.TabIndex = 4; + buttonRight.UseVisualStyleBackColor = true; + buttonRight.Click += ButtonMove_Click; + // + // buttonLeft + // + buttonLeft.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonLeft.BackgroundImage = (Image)resources.GetObject("buttonLeft.BackgroundImage"); + buttonLeft.BackgroundImageLayout = ImageLayout.Zoom; + buttonLeft.Location = new Point(686, 409); + buttonLeft.Name = "buttonLeft"; + buttonLeft.Size = new Size(30, 30); + buttonLeft.TabIndex = 5; + buttonLeft.UseVisualStyleBackColor = true; + buttonLeft.Click += ButtonMove_Click; + // + // comboBoxStrategy + // + comboBoxStrategy.Anchor = AnchorStyles.Top | AnchorStyles.Right; + comboBoxStrategy.DropDownStyle = ComboBoxStyle.DropDownList; + comboBoxStrategy.FormattingEnabled = true; + comboBoxStrategy.Items.AddRange(new object[] { "к центру", "к краю" }); + comboBoxStrategy.Location = new Point(637, 12); + comboBoxStrategy.Name = "comboBoxStrategy"; + comboBoxStrategy.Size = new Size(151, 28); + comboBoxStrategy.TabIndex = 6; + // + // buttonStrategyStep + // + buttonStrategyStep.Location = new Point(694, 46); + buttonStrategyStep.Name = "buttonStrategyStep"; + buttonStrategyStep.Size = new Size(94, 29); + buttonStrategyStep.TabIndex = 8; + buttonStrategyStep.Text = "шаг"; + buttonStrategyStep.UseVisualStyleBackColor = true; + buttonStrategyStep.Click += ButtonStrategyStep_Click; + // + // FormCruiser + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(800, 450); + Controls.Add(buttonStrategyStep); + Controls.Add(comboBoxStrategy); + Controls.Add(buttonLeft); + Controls.Add(buttonRight); + Controls.Add(buttonDown); + Controls.Add(buttonUp); + Controls.Add(pictureBoxCruiser); + Name = "FormCruiser"; + Text = "FormCruiser"; + Click += ButtonMove_Click; + ((System.ComponentModel.ISupportInitialize)pictureBoxCruiser).EndInit(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private PictureBox pictureBoxCruiser; + private Button buttonUp; + private Button buttonDown; + private Button buttonRight; + private Button buttonLeft; + private ComboBox comboBoxStrategy; + private Button buttonStrategyStep; + } +} \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/FormCruiser.cs b/ProjectPlane/ProjectPlane/FormCruiser.cs new file mode 100644 index 0000000..544737c --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruiser.cs @@ -0,0 +1,139 @@ +using ProjectCruiser.Drawnings; +using ProjectCruiser.MovementStrategy; + +namespace ProjectCruiser +{ + public partial class FormCruiser : Form + { + /// + /// Поле-объект для прорисовки объекта + /// + private DrawningCruiser? _drawningCruiser; + + /// + /// Стратегия перемещения + /// + private AbstractStrategy? _strategy; + + /// + /// Получение объекта + /// + public DrawningCruiser SetCruiser + { + set + { + _drawningCruiser = value; + _drawningCruiser.SetPictureSize(pictureBoxCruiser.Width, + pictureBoxCruiser.Height); + comboBoxStrategy.Enabled = true; + _strategy = null; + Draw(); + } + } + + /// + /// Конструктор формы + /// + public FormCruiser() + { + InitializeComponent(); + _strategy = null; + } + + /// + /// Метод прорисовки круисера + /// + private void Draw() + { + if (_drawningCruiser == null) + { + return; + } + Bitmap bmp = new(pictureBoxCruiser.Width, + pictureBoxCruiser.Height); + Graphics gr = Graphics.FromImage(bmp); + _drawningCruiser.DrawTransport(gr); + pictureBoxCruiser.Image = bmp; + } + + /// + /// Перемещение объекта по форме (нажатие кнопок навигации) + /// + /// + /// + private void ButtonMove_Click(object sender, EventArgs e) + { + if (_drawningCruiser == null) + { + return; + } + string name = ((Button)sender)?.Name ?? string.Empty; + bool result = false; + switch (name) + { + case "buttonUp": + result = _drawningCruiser.MoveTransport(DirectionType.Up); + break; + case "buttonDown": + result = _drawningCruiser.MoveTransport(DirectionType.Down); + break; + case "buttonLeft": + result = _drawningCruiser.MoveTransport(DirectionType.Left); + break; + case "buttonRight": + result = + _drawningCruiser.MoveTransport(DirectionType.Right); + break; + } + if (result) + { + Draw(); + } + } + + /// + /// обработка нажатия кнопки шаг + /// + /// + /// + private void ButtonStrategyStep_Click(object sender, EventArgs e) + { + if (_drawningCruiser == null) + { + return; + } + + if (comboBoxStrategy.Enabled) + { + _strategy = comboBoxStrategy.SelectedIndex switch + { + 0 => new MoveToCenter(), + 1 => new MoveToBorder(), + _ => null, + }; + + if (_strategy == null) + { + return; + } + _strategy.SetData(new MoveableCruiser(_drawningCruiser), pictureBoxCruiser.Width, pictureBoxCruiser.Height); + } + + if (_strategy == null) + { + return; + } + + comboBoxStrategy.Enabled = false; + _strategy.MakeStep(); + Draw(); + + if (_strategy.GetStatus() == StrategyStatus.Finish) + { + comboBoxStrategy.Enabled = true; + _strategy = null; + } + } + + } +} diff --git a/ProjectPlane/ProjectPlane/FormCruiser.resx b/ProjectPlane/ProjectPlane/FormCruiser.resx new file mode 100644 index 0000000..8a26dc4 --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruiser.resx @@ -0,0 +1,1540 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + iVBORw0KGgoAAAANSUhEUgAABGsAAAZACAYAAADO3c9BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAVu1JREFUeF7s3XHE5XXe//HcstZKkiRJMpIkSZIkSZJkJUmSlSRZK1lJxkokK0mS + JGtkJUmSJEkykiRJMpIkyRgjY4wxxhhjjN/v9dnd7rutz3xmrus61/uc8z2PJw+/2++/na7rnO/3dZ3z + +Z4iSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZLW123xl3//n5Ik + SZIkSZpnV8X2+Dpub/8fkiRJkiRJmk9nxXNxLP5fvBMXhyRJkiRJkubQvXEo2lDTHIlnQpIkSZIkScW1 + rz/9GD8PNT/bGw+EJEmSJEmSijo73otfDzU/+yJuCEmSJEmSJBX01+iNNL+0LdqZNpIkSZIkSdrErone + ONPzSEiSJEmSJGmT+n3sid4w07M/PM5bkiRJkiRpk3o7eqPMyKdxSUiSJEmSJGmGPRy9MeZkvBSSJEmS + JEmaUX+Mw9EbYk7WgyFJkiRJkqQNdmF8Hb0BZi32xVUhSZIkSZKkDfRGHIveALNW7fwaSZIkSZIkrbMn + YqNff/q1bSFJkiRJkqQ1dnfsjN7gshFt/HF+jSRJkiRJ0hq6ND6J3tgyCz/ENSFJkiRJkqST6NU4Er2h + ZVbaGCRJkiRJkqQT9Hi0Jzf1BpZZamPQyyFJkiRJkqTjdEd8E71xZTPsiYdCkiRJkiRJv+rCeDd6o8pm + 2hFXhCRJkiRJkn7Rc9EbUyq8F5IkSZIkSfpP7atIB6I3pFRoj/N+MSRJkiRJkla+m+Or6I0olXbGAyFJ + kiRJkrSynR+vRW88mYdP46qQJEmSJElayZ6M3mgyT2/EOSFJkiRJkrRS3R37ojeYzNPBaCOSJEmSJEnS + ynRZfB69sWQRfBd3hiRJkiRJ0kq0SOfUHM/2uDwkSZIkSZIm3d+iN44som1xdkiSJEmSJE2y62MRz6k5 + nnZ+zYMhSZIkSZI0yb6K3iiyyH6Mq0OSJEmSJGlSLcM5NcfzSUiSJEmSJE2mR+Nw9IaQZfFSSJIkSZIk + LX1Xxa7oDSDL5GjcEpIkSZIkSUvd59EbP5bR3pAkSZIkSVra2jk1R6I3fCyrT0OSJEmSJGnpao+8bp9E + 6Q0ey+xY/D0kSZIkSZKWpiviu+iNHVPQDku+ISRJkiRJkpaij6M3ckzJzjgtJEmSJEmSFrptseyP6T4Z + 7etQH4QkSZIkSdLC9pdonzjpjRtTdCCcXyNJkiRJkhay6+OL6I0aU7Yr7gxJkiRJkqSF6cJ4K3pjxipo + I9VVIUmSJEmSNPfaIbtPxcHoDRmr4Ei8FueGJEmSJEnSXLs7fozeiLFK9sZjIUmSJEmSNLfaV38+jd54 + sYq+j7tCkiRJkiSpvPaVn1eiN1qssu1xdUiSJEmSJJX2UByK3mCxytr5NS/E2SFJkiRJklTSlfFT9MYK + TjllfzwQkiRJkiRJJbVHVfdGCv5PO7/m+pAkSZIkSdrUtkVvnOC33ostIUmSJEmStCm1T4r0RgmO79GQ + JEmSJEnalA5Hb5BgzNOhJEmSJEnSzPsqekMEJ9YOY/5DSJIkSZIkzaTnojdCcPLeDkmSJEmSpA13exyJ + 3gDB2vw5JEmSJEmS1t1lsSt6wwNrdyyuCUmSJEmSpDV3RnwQbWDoDQ+sz7dxTkiSJEmSJK2pZ+Jg9AYH + Nua1kCRJkiRJOunui/YEo97QwMYdja0hSZIkSZJ0wm6IL6M3MjA7u6Md3ixJkiRJknTczo83wtOfNl87 + C+jTuCQkSZIkSZK6PRn7ozcuMHttFHs1JEmSJEmSftM98UP0RgU2z754PCRJkiRJkv63a+Oj6I0JbL72 + OO87Q5IkSZIk6ZSz48VoZ6j0hgRqvB8XhSRJkiRJWvH+HIejNyBQpz3O+4WQJEmSJEkr3I2xK3rjAfX2 + xl9DkiRJkiStYBfEu9EbDZifL6KNaJIkSZIkacV6LHpjAfP3WpwbkiRJkiRpRboteiMBi+PJkCRJkiRJ + K9DF4Zyaxbcv/hSSJEmSJGniOadmeXwWV4YkSZIkSZpoW6M3CrC4/hmnhyRJkiRJmljtnJoj0RsEWGyP + hiRJkiRJmlDtnJpvojcEsPj2hsd5S5IkSZI0od6O3gjA8vgiJEmSJEnSBHoqfP1pGl4JSZIkSZK0xN0T + u6N348/yORoPhyRJkiRJWsLaOTWfR++mn+W1KzzOW5IkSZKkJeyNaJ/E6N3ws9zaCCdJkiRJkpaov8f+ + 6N3os/zaCPdaSJIkSZKkJejO+DZ6N/lMx754MCRJkiRJ0gJ3fnwYvZt7pue7uDQkSZIkSdKCti16N/VM + 18chSZIkSZIWsL/Fgejd0DNdR+LlkCRJkiRJC9QfY0f0buaZvvY47z+HJEmSJElagC6Kt6N3E8/q+DKu + CUmSJEmSNMdOi2ejd/PO6nknzgtJkiRJkjSn7o+90btxZ/UcjKfj9yFJkiRJkoq7OtpXX3o37ayuH+Ke + kCRJkiRJhZ0eb0bvZh0+iTbmSZIkSZKkop6M3k06/OyVOD8kSZIkSdImd3Psi94NOvysnV/zSJwakiRJ + kiRpE/s2ejfn8Gs744aQJEmSJEmb1FvRuymH4/kszgpJkiRJkjTjtsbR6N2Qw8g/QpIkSZIkzbDLYm/0 + bsThRI7FbSFJkiRJkmbUN9G7CYeT1Q4cliRJkiRJM6idU9M+GdG7AYe1+CIkSZIkSdIG+msciN6NN6zH + UyFJkiRJktbRlbErejfcsBEe5y1JkiRJ0ho7LT6P3o02bNRPcXZIkiRJkqST7J9xOHo32rBR7QykD0OS + JEmSJJ1ED8Xu6N1kw6wciqdDkiRJkiQNuil2RO/mGmZtT9wdkiRJkiSp0yXxbvRuqmGztHHwmpAkSZIk + Sb/ojHg2Dkbvhho2y5F4M84NSZIkSZL0n+6LndG7mYbNtj/+HpIkSZIkKV0XHtPNvP0Q94QkSZIkSSvd + lng9ejfPUO3juDYkSZIkSVrJTo1H43D0bpyh2tH4R5wTkiRJkiStXNfH3ujdNMO8HIi/hiRJkiRJK9VZ + 8VX0bpZh3tr5NX8MSZIkSZJWpvZVk95NMiyK9+KSkCRJkiRp8t0UvZtjWDR/C0mSJEmSJl/vphgWla9D + SZIkSZIm3Y7o3RDDotodvg4lSZIkSZpkz0XvZhgW3dshSZIkSdKkujN6N8GwLB4NSZIkSZIm0ZXRvkrS + uwGGZXJDSJIkSZK01J0d2+NY9G5+YZl8F+eFJEmSJElL2wtxOHo3vrCM3ghJkiRJkpayP8fe6N3wwrJq + nxJ7PCRJkiRJWqpuCo/pZqr2RDs0W5IkSZKkpaid6dEedXw0eje6MAWfx0UhSZIkSdLC93QciN4NLkxF + GyOdXyNJkiRJWvgeiJ3Ru7mFqWmj5N9DkiRJkqSF7Lr4JHo3tTBV7XHezq+RJEmSJC1cZ8a26N3MwtRt + jwtCkiRJkqSF6ZE4Er0bWZi6dn7NyyFJkiRJ0kJ0a+yK3k0srIp98WhIkiRJkjTXLon3o3fzCqvmq7gl + JEmSJEmaS7+PZ6J30wqr6u04PyRJkiRJKu/e6N2swqp7NiRJkiRJKu2a2Bm9G1VYdXvjgZAkSZIkqaT2 + 9af3oneTCvzb53FtSJIkSZK06T0VvZtT4L+9FueEJEmSJEmb1u1xLHo3psB/a78rj4ckSZIkSZvShfFd + 9G5Kgb49cWtIkiRJkjTznFMD6/NVnBGSJEmSJM2s9ihiX3+C9XszJEmSJEmaSfdG+ypH7wYUOHkPhyRJ + kiRJG2pLtK9w9G48gbXZG5eGJEmSJEnr7t3w9SeYnR0hSZIkSdK6aufUHIzeDSewfs6vkSRJkiStuTvi + ++jdaAIbcyD+EpIkSZIknVRnxSfRu8kEZmNXXBCSJEmSJJ2wN6J3cwnM1pchSZIkSdKwJ2J/9G4sgdk6 + HK+EJEmSJEndbouvo3dTCWyOn8L5NZIkSZKk33RJvB+9m0lgc7WR9LqQJEmSJOlfnRkvRu8mEqjRxtIt + IUmSJEnSKQ/G3ujdQAI1DsZzcVpIkiRJkla46+Or6N08ArV2xv0hSZIkSVrRzot3onfTCMzHZ+H8GkmS + JEla0Z6OY9G7YQTmo/1Ovh4XhiRJkiRphbo19kXvZhGYr3Z+zdb4XUiSJEmSVqTvoneTCCyGXXFLSJIk + SZJWoPaI4N7NIbBYPg9fh5IkSZKkifdI9G4KgcW0LU4NSZIkSdIEuyDaWRi9G0Jgcd0RkiRJkqQJ9mP0 + bgSBxXYoJEmSJEkT6+3o3QQCy2FHSJIkSZIm0sNxOHo3gMDyeDokSZIkSUveVbE3ejd+wPK5MSRJkiRJ + S9o58WX0bviA5dTG1/NDkiRJkrSEvRq+/gTTsz3+JyRJkiRJS1Q7p2ZP9G70gOV2JJ4NSZIkSdKS9Mf4 + Nno3ecA07It7Q5IkSZK04F0WH0Tv5g6Ylm/iupAkSZIkLWinxwtxKHo3dsC0HI23ox0mLkmSJElawP4c + u6N3UwdM04F4OiRJkiRJC9ZN8VX0buaAadsZD4QkSZIkaUG6KN6I3k0csBo+ietDkiRJkjTnTo2/RXuU + b+8GDlgN7fyaf8ZZIUmSJEmaY+0x3e0Rvr2bN2C1HIytIUmSJEmaU+3rTzuid9MGrKYf4o6QJEmSJM2h + f0TvZg1Ybe/FZSFJkiRJKuz26N2kATRPhiRJkiSpqLOjd3MG8Ev3hiRJkiSpoK+jd2MG8Es749qQJEmS + JG1iz0fvpgyg5+1on8aTJEmSJG1Cd0fvZgxg5ImQJEmSJM24q2NP9G7EAEaOhsd5S5IkSdIMa19h+Dh6 + N2EAJ+OHOC8kSZIkSTPopWh/Ge/dgAGcrHZ+jSRJkiRpgz0U+6N34wWwVn8PSZIkSdI6uyW+id4NF8B6 + 7Iu7QpIkSZK0xto5Ne+Frz8Bs/ZVXBCSJEmSpDX0fByK3o0WwEYcC+fXSJIkSdIaejB2R+8mC2AWDsYz + IUmSJEk6QdfHp9G7uQKYpfY47ztCkiRJknSc/hCvRO+mCmAztHH4nJAkSZIkdXo8HCgMVGrn17wekiRJ + kqRf1R6luyt6N1MAm6k9zvuxkCRJkiT9pyviw+jdRAFU+CZuDUmSJEla+U6PF6N38wRQ6f3YEpIkSZK0 + 0rXHdLczI3o3TgDVXorfhyRJkiStZDfFzujdMAHMw554KCRJkiRp5To3PojezRLAPH0ZN4YkSZIkrVTP + Re8mCWARvBUXhCRJkiStRPfG0ejdIAEsgvYa9VT8ISRJkiRp0rW/VDunBlgG7fyaO0OSJEmSJp1zaoBl + siPOD0mSJEmaZM9H72YIYJG9E5IkSZI0ue6JfdG7EQJYdH8LSZIkSZpM58S30bsBAlgGB2NLSJIkSdIk + +jB6Nz8Ay+S7kCRJkqSlr51Tcyh6Nz4Ay+atkCRJkqSl7Y7wmG5gSg7HAyFJkiRJS9dZ8WX0bnYAllk7 + LP2CkCRJkqSlqj3qtneTAzAFX4ckSZIkLU1Pxf7o3eAATMGReDUkSZIkaeG7MzymG1gFe+OhkCRJkqSF + 7fLYHr2bGoApao/zvjEkSZIkaeE6J16OY9G7oQGYqg/jopAkSZKkherhaF8J6N3IAEzZwXghTgtJkiRJ + WohujvZklN5NDMAq2BV/CUmSJEmae+2j/+9H7+YFYJV8GW28liRJkqS51T7y/2w4pwbg396Mi0OSJEmS + 5lJ7TPf+6N2wAKyiQ/F4nBqSJEmSVNq58UP0blYAVtnuuCMkSZIkqbT2qNreTQoAp5zyRVwekiRJklTS + 1ujdnADwf7bFmSFJkiRJm9rZ0bspAeC3/hSSJEmStKm1sxh6NyQA/FY7cPi8kCRJkqRN6d3o3YwAcHw7 + QpIkSZJm3iNxLHo3IgCMPReSJEmSNLOuif3RuwEB4OTcHJIkSZK04c6Pr6N34wHAydsXF4UkSZIkbajX + 40j0bjwAWJtP4vchSZIkSetqa7S/BPduOABYu3b21/MhSZIkSWvutvg+ejcbAKzfgbg/JEmSJOmkuzI+ + it5NBgAb911cH5IkSZJ0wk6Ll+JQ9G4wANi4o/FenBWSJEmSNOyh+Cl6NxcAzE4bxZ8LSZIkSTput4bH + dAPU2R0PhiRJkiT9pkvirejdTACweT4L59dIkiRJ+k1PxJHo3UgAsHna47xfi9NDkiRJkv7VnbE/ejcR + AGy+dn7NkyFJkiRJ/3pM947o3TwAUOfH+FNIkiRJWuHaR+7/Eb2bBgDqvR+XhyRJkqQV7f7o3SwAMD8v + xP+EJEmSpBXrqjgavRsFAOanHTj8UEiSJElaof4Q30TvJgGA+Wvn19wckiRJklYk59QALL73YktIkiRJ + mnj3RO+mAIDF83RIkiRJmnDXxt7o3RAAsHiOxL0hSZIkaYKdGZ9G72YAgMXVzq+5JCRJkiRNrG3RnjDS + uxEAYLG9H5IkSZIm1MNxMHo3AAAsh2dCkiRJ0gS6Jb6L3oU/AMvjQNwZkiRJkpa40+PD8PUngGn4Js4J + SZIkSUtaO6fmcPQu+AFYTs6vkSRJkpa0dk7NT9G70AdgebUR/rmQJEmStERdH19E7yIfgOW3K24PSZIk + SUvSm9G7uAdgOr6MdjaZJEmSpAXvqTgavQt7AKajHR7/dkiSJEla4O6P3dG7qAdgevZHG+klSZIkLWDX + xMfRu5gHYLq+C+fXSJIkSQvW2fFy9C7iAZi+j+LikCRJkrQgbQ3n1ACsrnZ+zT/jjJAkSZI0526LndG7 + eAdgdeyJR0KSJEnSHLswPozeRTsAq+eruCUkSZIkzamXonexDsDqejcuCUmSJEnF/TmORO9CHYDV1c4w + ezbODEmSJElFtb+Y7oreRToA7I0/hSRJkqSiPonexTkA/OzruDQkSZIkbXIvRu+iHAB+rZ1fI0mSJGkT + ax9pPxi9C3IA+LVj8VhIkiRJ2oROjx+jdzEOAMdzODwdSpIkSdqEnFMDwHrtDEmSJEkz7IVofxntXYAD + wMl4OyRJkiTNoNvjp+hdeAPAWtwXkiRJkjbQufFt9C64AWCt2qc0LwpJkiRJ6+z96F1sA8B6tT8CSJIk + SVpHz8SB6F1oA8B6HY3XQ5IkSdIauju+j95FNgBs1P54OCRJkiSdRFeFx3QDsNl+jJtDkiRJ0qDz4tVo + H1HvXVgDwCx9HJeEJEmSpOO0NfZG74IaAGbtUPwjfh+SJEmSftWt4THdAFT7Kf4akiRJkn7R5fFh9C6i + AWCzfR3tjwaSJEmS0lnxfByL3gU0AFR4Oy4NSZIkaeX7UxyI3oUzAFRp59f8PSRJkqSVrj2Boz06tXfR + DADV9sQ9IUmSJK1szqkBYNF8GdeEJEmStHL9LXoXyQAwby/HuSFJkiStTBdG7+IYABbF/SFJkiStTPui + d2EMAIuiHTh8RUiSJEmTzzk1ACyLHXFmSJIkSZPt0ehdDAPAonoxJEmSpEl2fbSPlPcuhAFgkd0ZkiRJ + 0qTaEt9G7wIYABbdgbg0JEmSpMn0ZhyN3gUwACyDT+N3IUmSJC19j0X7i2TvwhcAlskLIUmSJC117Tv+ + O6N3wQsAy+Zw/CUkSZKkpezK+CR6F7sAsKx+iBtCkiRJWqr+J16O9hfI3oUuACyrY/FBnB6SJEnS0rQ1 + 9kbvIhcAll37Y8RLIUmSJC1Fd8Q30bu4BYCp+Cn+GpIkSdJCd1m8E72LWgCYmi/iupAkSZIWtqejfZe/ + d0ELAFP0VvwuJEmSpIXrvtgfvQtZAJiqdn7NMyFJkiQtVO0j4DuidxELAFP3Y7Q/WkiSJEkL0TnxSvQu + XgFgVXwUV4YkSZI09x6O3kUrAKyal+MPIUmSJM2tm6N9V793wQoAq+ZIbA1JkiRpLl0YX0fvYhUAVtUP + cXtIkiRJ5f0zehepALDq3o9LQpIkSSrrwehdnAIA//ZC/D4kSZKkTa89pvtA9C5MAYB/a2e6/TkkSZKk + Te2M+Cx6F6UAwH9r59d4nLckSZI2tVeidzEKAPRtD0mSJGlTejQORe9CFAA4vudDkiRJmmk3R/sod+8C + FAAYa3/suDMkSZKkmXRqfBy9i08A4OS0P3q0s98kSZKkDdfOqTkSvQtPAODkOb9GkiRJG66dU7Mnehec + AMDatD9+OL9GkiRJ6+76+Cp6F5sAwPq0P4LcFpIkSdKaezd6F5kAwMZ8E5IkSdKaejGORu8CEwDYuPdD + kiRJOqkejN3Ru7AEAGbjQDwTkiRJ0rDr4tPoXVQCALP1Y9wZkiRJUrfz4rXoXUwCAJuj/ZHk0pAkSZL+ + q9/Fk9EeKdq7kAQANsexaH8sOSskSZKk/+2uaB/F7l1EAgCba2/8LSRJkqR/dVl8FL2LRwCgRnuc920h + SZKkFe+0+Gf0LhoBgFofxOUhSZKkFe6hcE4NACyGo/FCnBOSJElawa6MXdG7WAQA5qOdX3NfSJIkaQX7 + InoXiQDAfH0bV4ckSZJWqJejd3EIACyG98LjvCVJklakO8M5NQCw+B4PSZIkTbxTY0/0LggBgMXSDhy+ + KiRJkjThPo/exSAAsJh2hyRJkibai9H+Qte7EAQAFte7IUmSpIl1V+yP3gUgALD4HghJkiRNpPPjx+hd + +AEAy+PikCRJ0gTaHr0LPgBguXwX7WEBkiRJWuKeiwPRu+ADAJbLsXgjJEmStKTdEzujd7EHACynQ/Fo + SJIkacm6JjymGwCmaVfcGpIkSVqSLoj2EWmP6QaA6fo0Lg1JkiQtQY/Hvuhd2AEA09C+DvVySJIkacG7 + K76P3kUdADAte8P5NZIkSQvc1fFx9C7mAIBp+jbuCEmSJC1Y58SL4ZwaAFgt7XHe74bzayRJkhas++Ng + 9C7iAIBpOxzPhiRJkhak9vWnndG7eAMAVkM7v+aBkCRJ0pw7K7ZH76INAFgtX8UNIUmSpDnWHtPdu1gD + AFbTK3F+SJIkaQ5dHr2LNABgtT0YkiRJmkMOFAYAeg7FzSFJkqTCnFMDAIy082suDkmSJBX0aPQuygAA + fukfIUmSpE3upjgSvQsyAIBf8zhvSZKkTeyi+C56F2IAAD3tjLurQpIkSZvQW3EsehdiAADH81lIkiRp + xj0R7ckOvQswAIATeSkkSZI0o+6O3dG78AIAOBlH46GQJEnSBrsy2keXexddAABr8WNcH5IkSdpAr4an + PwEAs/JR/C4kSZK0jh6P/dG70AIAWI/2R6CXQ5IkSWusnVPjMd0AwGbYG4+EJEmSTrLL4v3oXVwBAMzC + jrguJEmSdBI9H8eid2EFADAr74UkSZJO0INxIHoXVAAAs3Q4XghJkiQdp5vi6+hdTAEAbIad8UBIkiTp + V10Qr0fvIgoAYDN9FteGJEmSflF7THfv4gkAoEL7o9EZIUmSpHRXHIrehRMAQIV2fs2TIUmStPJdHu3R + mb2LJgCASj/G3SFJkrTSvRq9iyUAgHnYHleEJEnSSrY1ehdJAADztC3OCkmSpJXqhjgYvQskAIB5amfp + /TUkSZJWqi+jd3EEALAI2vk1HuctSZJWpvZozN5FEQDAIvk4JEmSJt9jcSR6F0QAAIvmHyFJkjTZboxd + 0bsQAgBYRO2PTHeGJEnSJPs8ehdBAACL7KeQJEmaXO2cmqPRuwACAFh0n4QkSdJk2hr7onfhAwCwDNof + nV4ISZKkpe/6+DZ6Fz0AAMtkf9wakiRJS9326F3sAAAsox9DkiRpaftnOKcGAJiaj0OSJGnpejjakxN6 + FzgAAMvsYDwbkiRJS9MN8UX0Lm4AAKZgV9wVkiRJC98F8Vb0LmoAAKbky7giJEmSFrbT4pk4HL0LGgCA + KWln870Z54QkSdJCdk/sjN7FDADAFO2Nx0OSJGnhuio+jd5FDADAlH0Xzq+RJEkL1bnxWvQuXgAAVsFH + cXVIkiQtRI+Ec2oAgFV2JF6K9kcsSZKkuXZd7I7eRQsAwCrZF38JSZKkudYeWdm7WAEAWEXfxw0hSZI0 + l16N3kUKAMAq+yC2hCRJUml3Ru/iBACAU055Mv4nJEmSyjoQvQsTAABOOeVoXB+SJEklfRW9ixIAAP5P + ewiDJEnSprctehcjAAD81vshSZK0ad0Vh6N3IQIAQJ/HeUuSpE3pwtgVvQsQAADGLgtJkqSZ9Yf4OHoX + HgAAnNgPcUZIkiTNpOfjYPQuPAAAODlvhCRJ0oa7L9qTDHoXHAAAnLwjsTUkSZLW3fXhMd0AALOzJ24P + SZKkNbcl3oqj0bvQAABgfT4PBw5LkqQ19/fYH70LDAAA1u9wvBqSJEkn3T3xY/QuLgAA2Lh98VhIkiSd + sOvik+hdVAAAMDvfxV0hSZJ03M6LbeGcGgCAGu+H82skSdJxezAORe9CAgCA2WuP834xJEmSftONsSt6 + FxEAAGyevfHXkCRJ+t8ujI+id/EAAMDm+ypuCUmSpH/1RPQuGgAAqPNanB+SJGnFa19/6l0sAABQ728h + SZJWuLNjf/QuFAAAqHcwPM5bkqQVbnv0LhIAAJifdn7NVSFJklasrdG7OAAAYP5ejtNDkiStSO1JA72L + AgAAFsfDIUmSVqCL44foXRAAALA4DsRNIUmSJt7b0bsYAABg8XwZkiRpwj0VR6N3IQAAwGJq59dIkqQJ + dm/sid4FAAAAi835NZIkTawr44vovfEDALD4dsV1IUmSJtKb4etPAADL7bOQJEkTqJ1T054k0HvDBwBg + eRyLV0OSJC1x98T30XuzBwBg+eyLrSFJkpawy2N79N7kAQBYXt+G82skSVrC/hG9N3cAAJZf+6OcJEla + oh4J59QAAEzX4dgWkiRpCbot2kdje2/qAABMx+54KCRJ0gJ3UbwdvTdzAACm58u4NiRJ0gJ2ajwdvTdx + AACmq/2x7uyQJEkL1v1xMHpv4AAATNeReDYkSdIC1T76uiN6b94AAEzfj3FvSJKkBeiMeCN6b9oAAKyO + j+PqkCRJc+7J6L1ZAwCwel6N80KSJM2pW+NA9N6oAQBYPYfi0WgPn5AkSXPom+i9SQMAsLra+TU3hSRJ + Ku6t6L05AwDAp+Fx3pIkFfZ4HIveGzMAADQvhyRJKuiG2BO9N2QAAPjZkfA4b0mSCtoRvTdjAAD4tf0h + SZI2sbfD158AAFiLz0OSJG1C7Zwaj+kGAGA9XgxJkjTDrokfovfGCwAAJ3I4PM5bkqQZ9ln03nQBAOBk + tYdUSJKkGfRaHI3eGy4AAKzFpyFJkjbQI/FT9N5oAQBgrQ7FcyFJktZR+06xx3QDADBr7etQd4ckSVpD + F8V70XtzBQCAjfo6rgpJknQSnRHPR/uIau+NFQAANqqdifh2nBuSJOkE3R+7ovemCgAAs7Iv/h6SJGnQ + dfFF9N5MAQBg1n6Ie0KSJHXaEm9G700UAAA2yyfR/mgoSZJ+0e/jsTgcvTdQAADYLO38mpfjvJAkSf+p + Paa7PUKx9+YJAACbbX88HJIkKZ0ZO6L3pgkAAFXa+TV/DEmSVr7XovdmCQAA1T6MS0OSpJXtT9F7kwQA + gHl5Kv4QkiStZO0wt94bJAAAzMuxuCUkSVq5vonemyMAAMzbT3FWSJK0MrVHI/beFAEAYFG082skSVqJ + 7or20dLeGyIAACySR0KSpEl3SeyJ3hshAAAsoitCkqRJdkZ8Gr03QAAAWFQ74+yQJGlyvRCHo/cGCAAA + i+ytkCRpUv059kbvjQ8AAJbBYyFJ0iS6MTymGwCAZbcv7gxJkpa6LfFOHI3eGx4AACyTL+PSkCRpaXsm + DkTvjQ4AAJZN+yPkGyFJ0lL2QOyK3pscAAAsq/bHyCdDkqSlqp1T81n03twAAGDZ/RB/CkmSlqIL4pU4 + Fr03NgAAmILtcVlIkrTwPRKHo/eGBgAAU9HOr9kWkiQtdLfF7ui9mQEAwNS0x3lvDUmSFrL2EdCPovcm + BgAAU/V1tD9aSpK0UJ0aT0XvzQsAAKbuzTgvJElamO6K3psWAACsiqdDkqSF6Ipo39XtvWEBAMCqOBAP + hCRJc+138WH03qwAAGDVfBnXhSRJc+vJ6L1JAQDAqno1zglJksprJ9733pwAAGDVPRaSJJV2cfwYvTcm + AABYde1MR4/zliSV9l703pQAAIB/+yp8HUqSVNKz0XszAgAA/tsbIUnSpnZ/eEw3AACcvEdCkqRN6YrY + Eb03IAAAoG9PXBuSJM28d+JY9N6AAACA4/syJEmaae2cmoPRe+MBAABOzPk1kqSZdV94TDcAAGzMgfhb + SJK0oS6NT6L3ZgMAAKxN+yPo1SFJ0rp7JXpvMgAAwPp8GpIkrasnwjk1AAAwW0fi1ZAkaU3dGd9F780F + AADYmPY474dDkqST6pJ4L3pvKgAAwGx8HdeFJEnDTosXo/dmAgAAzNb7cV5IknTcHor90XsjAQAAZutw + vBC/C0mSftON0T6K2XsTAQAANsfOeCAkSfqv2kcv34nemwcAALC5Pgvn10iS/qtnovemAQAA1Hg9toQk + Sf96TLdzagAAYL4OxuPRHvohSVrhzopvo/dmAQAA1Grn19wakqQVrj0qsPcmAQAAzMfncWFIklawJ6L3 + 5gAAAMzXKyFJWrGuDefUAADAYjoa94ckaYX6LnpvCgAAwGI4EGeEJGkFei96bwYAAMBi+TokSRPvsWiP + BOy9EQAAAIvnxZAkTbSr4qfovQEAAACL64aQJE2wHdF74QcAABZbO7/m1JAkTag3o50o33vhBwAAFt/n + IUmaSI/Gnui94AMAAMvhSDwXkqQl75b4Nnov9gAAwHLZH/eEJGlJuzS2R+9FHgAAWE7fxbUhSVqyzoz2 + iL9D0XuBBwAAllM7i/LdOC8kSUvUg7E7ei/uAADAcmtPh3omJElL0k3xVfRe1AEAgGnYFfeHJGnBuzje + jt6LOQAAMC2fxY0hSVrQTo8n43D0XsgBAIBpaefXvBrnhyRpAbst9kbvRRwAAJimdn7N1pAkLVgXxdfR + e/EGAACm7ce4IyRJC9Tr0XvRBgAAVsP2uDIkSQvQvdF7sQYAAFZLe5x3O8tSkjTnjkXvhRoAAFg9d4Yk + aY6176b2XqABAIDVtCeuCEnSHNoWvRdnAABgtX0QZ4YkqbC7oveiDAAA0DwWkqSiLo/90XtBBgAA+Nkt + IUna5NpHGT+P3gsxAADAL+2Kc0OStIm9FEei90IMAADwa2+HJGmTeigORO8FGAAA4HieCEnSjGvfNf0u + ei+8AAAAI+2PvneHJGlGXRjvx9HovfACAACcyI64NCRJM+iFOBi9F1wAAICTcSycXyNJM6idU7M7ei+2 + AAAAa3Eong5J0jq7Ob6I3ossAADAevwY94YkaY2dH69F+6hi7wUWAABgvT6JS0KStIYej8PRe2EFAADY + iPbwkldDknSStUfq/RS9F1UAAIBZ2B9PhCTpBF0ZH0XvxRQAAGCWvo7bQpJ0nE6P56P3IgoAALAZ3ost + IUnq9OfovXgCAABsphdDkvSrbow90XvhBAAA2Ezt/JqHQpL0n86L7dF70QQAAKjwVdwUkqT0bPReLAEA + ACq9GReEJK1090TvRRIAAGAenopTQ5JWsotjd/ReIAEAAOZhb9wdkrSSfRC9F0cAAIB52hEXhSStVM9H + 70URAABgEbwdkrQyPRAHoveCCAAAsCgeD0mafJfFN9F7IQQAAFgk++OakKRJ186pORa9F0IAAIBF0/7Y + LEmT7cU4FL0XQAAAgEXl/BpJk+z+2BW9Fz4AAIBF1v7ovDUkaTK1R959Hr0XPQAAgGWwOy4PSZpEb0bv + xQ4AAGCZfBWStPQ9G86pAQAApuBovBWStLTdHd9F70UOAABgGe2Nh0OSlq7LYnv0XtwAAACWWfuj9A0h + SUvTWfFy9F7UAAAApuCj2BKStBQ9Evuj94IGAAAwBe1szpfiDyFJC90f45vovZgBAABMya54MCRpYbso + 3o/eixgAAMAUfRk3hSQtXO2jf89H78ULAABgytrjvC8JSVqo7g3n1AAAAKvoYPw9zghJWogujO+j96IF + AACwCnbHnSFJC9GH0XuxAgAAWCVfxOUhSXPt6ei9SAEAAKyi1+KskKS5dGUcjt4LFAAAwCo6Gg+EJM2l + ndF7cQIAAFhl7cDhLSFJpTmnBgAA4Pi+CUkqa2scid4LEgAAAP/2YkjSpnd1HIjeCxEAAAD/7YaQpE3r + 9Pg2ei9AAAAA/Fb7VsKZIUmb0tvRTjbvvQABAADQ93lI0sz7W+yL3gsPAAAAx3csng9Jmlm3xQ/Re9EB + AADgxA7FfSFJG+6K+Dh6LzYAAACcvPZH8OtDktbdWbEtDkfvhQYAAICT184AfT/OC0laVw/HT9F7kQEA + AGDtDobzayStq1vj6+i9uAAAALB+u+MvIUkn3eXxbvReVAAAANi4L+LmkKQTdkY8Fc6pAQAA2Dzt/JrX + w/k1kk7YXbEvei8mAAAAzE47v+aJkKTjdmV8E70XEQAAAGZvZ9wTkvSb2mO620fwei8eAAAAbJ6P4uqQ + pP/q/ui9aAAAALD5nos/hCT9qwui92IBAABAnfZHdEn6Vz9G74UCAACAOj/FjSFpxXslei8SAAAA1Psg + toSkFe1P0XtxAAAAYH7+HpJWsKviQPReGAAAAJivu0PSCnV2fBG9FwQAAADmb1dcEpJWpG1xLHovCAAA + ACyG90PSCvRwHIreCwEAAACL5amQNOFujR+i9wIAAADA4jkY7eEwkibYBfFh+PoTAADAcvkmLg5JE+sf + cTh6v/gAAAAstvdC0oR6JPZE7xceAACAxdf++P5cSJpAf4yvovfLDgAAwPJoj/O+NyQtcefGm9H7JQcA + AGD5fB4XhqQlrT3i7Uj0fsEBAABYPu2hMW+FpCXsvvgper/cAAAALK8D8XRIWqKuiY+j90sNAADA8vs2 + 7ghJS9CZsS16v8wAAABMx0fh/BppCXo0er/EAAAATM8/Q9ICd1vsjt4vMAAAANOzL9of7SUtYBdH+whc + 75cXAACA6doRfwxJC9aL0fulBQAAYPrejfZHfEkL0l+i98sKAADA6nguzghJc+6qcE4NAAAAe+O+kDTn + PoneLykAAACr5+u4PCTNqZei98sJAADA6mrn10iaQ3+Og9H7xQQAAGC1PRWSCmsnfP8QvV9IAAAAaH/c + vzYkFfVx9H4ZAQAA4Gftj/ySCtoWR6L3iwgAAAC/9F5I2sTaI9h+it4vIAAAAPza0XgkJG1C58WO6P3y + AQAAwPHsjwtD0ox7P3q/dAAAAHAi34WkGfZ8HIreLxwAAACcyLF4JyTNoD+Fx3QDAACwUe3rUM6vkTbY + lfFp9H7JAAAAYK12xk0haR2dE69F75cLAAAA1qt9KOCikLSGTo3HYl/0frEAAABgvdqZqC/HaSHpJLs9 + vo3eLxUAAABs1E/xcEg6iS6LD6P3ywQAAACz8nX8MSQNOjteit4vEQAAAMzau9E+NCDpOD0Q7VFqvV8g + AAAAmLV2fs3TcUZI+lVtyfwher88AAAAsFna+TX3hKRf9VH0fmkAAABgs30V14ak//RM9H5ZAAAAoMpr + cV5IK99VcSx6vygAAABQpd2bPhjSyrc3er8kAAAAUK0dOHxFSCvb9uj9cgAAAMC8fB3SSvZ49H4pAAAA + YN62hbRStRO2j0TvFwIAAAAWwa0hrURnx/fR+0UAAACARXE0PB1KK9E70X7ge78IAAAAsEi+CGnStXNq + DkTvFwAAAAAW0YshTbI7Ylf0fvABAABgUbUzVx8IaVJdFZ9F74ceAAAAFt2PcWNIk+iseCUOR+8HHgAA + ABbdsdge54a09G2NvdH7YQcAAIBl0T6E4PwaLX13xrfR+yEHAACAZbMn/hrSUnZlvB+9H24AAABYVl/F + LSEtVafHs9FOzO79YAMAAMCyaufXvBXnhLQ03Rf7o/dDDQAAAMvuUDwd0lJ0XXwTvR9mAAAAmIpd8UBI + C9158Xr0fogBAABgaj6Oa0Ja2P4SvR9eAAAAmCqP89bC1r7+1PuhBQAAgKl7NKSFqp2A/X30fmABAABg + 6tr5NbeHtDC9Fr0fVgAAAFgVH8alIc29dvJ174cUAAAAVs1z8buQ5lY78fpw9H5AAQAAYNUcC4/z1tw6 + N76M3g8nAAAArKqd4XHemkuvRu+HEgAAAFbd9pBK2xq+/gQAAADH186vkUq6LdpHuno/iAAAAMC/tQ85 + 3BvSpnZefBy9H0IAAADgv30fW0LatP4ZR6L3AwgAAAD81ochbUp/i73R+8EDAAAA+tqHHl4Maab9MXZE + 74cOAAAAGPsp7glpJp0Z70bvhw0AAAA4Oe1DEOeGtOGej6PR+0EDAAAATt57IW2ov8Se6P2AAQAAAGtz + MJ4NaV1dH59F74cLAAAAWJ8f4q6Q1lT7Dt1r0fuhAgAAADamfTji4pBOuiei98MEAAAAzMbrcVpIJ+zu + 2B29HyQAAABgNvbH4yENuzw+id4PEQAAADBb38TtIXX7Q7wcvR8eAAAAYHN8EJeF9JseiWPR+8EBAAAA + Nke7F38xzg7pf2uP6XZODQAAAMzH3vhzSP/b59H7YQEAAABqtPNrrgnplH9G74cEAAAAqPV+nBla4R6I + I9H7AQEAAADqPR1a0bbEruj9YAAAAADzcShuDK1gzqkBAACAxdQeAqQVq51TczR6PxAAAADA/H0QWpHu + ifZIsN4PAgAAALA4Hg5NvLPj++j9AAAAAACLpX0r5rzQhPs4ev/xAQAAgMW0MzTRXox2onTvPzwAAACw + mI7FO6GJdV+0Ja73Hx0AAABYbAfj0dBEujq+iN5/bAAAAGA5tMd53xJa8i6IN6P3HxkAAABYLp/HpaEl + 7dR4MvZH7z8wAAAAsFwOxytxWmgJuzs8phsAAACmZU84v2YJa+fUeEw3AAAATNO3cXtoSTovtkV7tFfv + PygAAACw/N6PK0JL0INxIHr/IQEAAIBpaOfXPBfOr1nwro0fo/cfEQAAAJiWdn7NA6EF7axwTg0AAACs + lh1xY2gBeyZ6/9EAAACAaXs9toQWqPb1p95/LAAAAGA1/DW0QB2K3n8oAAAAYDW0A4dvCC1AzqkBAAAA + mq/j3NAcezx6/3EAAACA1fRyaE5dF73/KAAAAMBquzdU3PmxM3r/QQAAAIDVdjQuCRX2XhyL3n8QAAAA + gC/j96GCngxPfwIAAABOZFtok7s7forefwAAAACAX2rfynkwtEldE19E7x8fAAAAoGdX3BSacWfE63Ek + ev/wAAAAAMfzcZwdmmGPx77o/YMDAAAAjLQPfzi/Zob9Kb6P3j82AAAAwMloHwJ5NLTBrooPo/ePDAAA + ALAWX8ctoXXWnoX+QhyN3j8wAAAAwFq0p0O9G+1sXK2j9mitA9H7xwUAAABYj8PRPhyiNdY+kvRd9P5R + AQAAADZid7QPiegk2xJvRO8fEwAAAGAWPolrQifR1uj9IwIAAADM0qtxamjQ7dH7xwMAAADYDE+GjtNl + 4ZwaAAAAoNKu+FOok3NqAAAAgHn4KK4M/aJHovePBQAAAFDhH3FGKN0QR6L3DwUAAABQ4Wj8NVa+c2JH + 9P6RAAAAACrtjBtjpXstev84AAAAAPPwcazs47wfi/YRo94/DAAAAMC8tPNrVq7bYnf0/kEAAAAA5ql9 + uOTeWJnOis+i948BAAAAsAja+TXtrN2V6PXw9ScAAABg0X0Sk++J2B+9fwAAAACARXIsJn1+zS3xTfT+ + xwMAAAAson1xd0yuP8SH0fsfDQAAALDIvo8zYlK1jww5pwYAAABYVttjMj0ae6P3PxQAAABgGRyOF2Pp + uyF+fkx3+2QNwCz9+sUTAOBn7VDQ3vUDwHq115Yf4s5Y6rbENXE5wAxdErfFry/KAAB+9ni064bL/vP/ + AszCVdFeVyRJnc6K3oUZAEBzb0iSJKmw86J3YQYA0NwXkiRJKsxYAwCMGGskSZKKM9YAACPGGkmSpOKM + NQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyR + JEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YA + ACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIk + qThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCM + GGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTi + jDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKs + kSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPW + AAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaS + JKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMA + jBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk + 4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBi + rJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz + 1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFG + kiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgD + AIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmS + pOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAw + YqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKK + M9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIix + RpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5Y + AwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJ + kqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0A + MGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmS + ijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCI + sUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrO + WAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8Ya + SZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMN + ADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJ + kooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDA + iLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkq + zlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPG + GkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThj + DQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGsk + SZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUA + wIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJ + Ks5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAj + xhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4 + Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhr + JEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1 + AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEk + SSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAA + I8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSp + OGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwY + ayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKM + NQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyR + JEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YA + ACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIk + qThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCM + GGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTi + jDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKs + kSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPW + AAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaS + JKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMA + jBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk + 4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBi + rJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz + 1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFG + kiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgD + AIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmS + pOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAw + YqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKK + M9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIix + RpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5Y + AwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJ + kqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0A + MGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmS + ijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCI + sUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrO + WAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8Ya + SZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMN + ADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJ + kooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDA + iLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkq + zlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPG + GkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThj + DQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGsk + SZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUA + wIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJ + Ks5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAj + xhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4 + Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhr + JEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1 + AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEk + SSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAA + I8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSp + OGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwY + ayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKM + NQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyR + JEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YA + ACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIk + qThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCM + GGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTi + jDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKs + kSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPW + AAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaS + JKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMA + jBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk + 4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBi + rJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz + 1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFG + kiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgD + AIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmS + pOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAw + YqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKK + M9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIix + RpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5Y + AwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJ + kqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0A + MGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmS + ijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCI + sUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrO + WAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8Ya + SZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMN + ADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJ + kooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDA + iLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkq + zlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPG + GkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThj + DQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGsk + SZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAjxhpJkqTijDUA + wIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4Yw0AMGKskSRJ + Ks5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhrJEmSijPWAAAj + xhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1AMCIsUaSJKk4 + Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFGkiSpOGMNADBirJEkSSrOWAMAjBhr + JEmSijPWAAAjxhpJkqTijDUAwIixRpIkqThjDQAwYqyRJEkqzlgDAIwYayRJkooz1gAAI8YaSZKk4ow1 + AMCIsUaSJKk4Yw0AMGKskSRJKs5YAwCMGGskSZKKM9YAACPGGkmSpOKMNQDAiLFG+v/t2LGJAlAAREGr + MLQiy7BTI7mm7puKLJi8aAZeD8sCQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLW + AADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aSJK2c + NQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkr + Zw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiDlrJEnS + ylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmS + tHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aS + JK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyR + JEkrZw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiDlr + JEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLO + GkmStHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4aAICY + s0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg + 5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEA + iDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsA + AGLOGkmStHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4a + AICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWz + BgAg5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnl + rAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mSVs4aAICYs0aSJK2cNQAAMWeNJEla + OWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiDlrJEnSylkDABBz1kiSpJWzBgAg5qyRJEkrZw0AQMxZI0mS + Vs4aAICYs0aSJK2cNQAAMWeNJElaOWsAAGLOGkmStHLWAADEnDWSJGnlrAEAiN1O34aZJEnSu8cJAIDQ + 9fR3ekqSJH30Ot1PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADAby6Xf9U585g5rwp9AAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAABGsAAAZACAYAAADO3c9BAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAVmJJREFUeF7s3XGk5nX+//98ZK2VJEkykpEkSZKsJEmyspIkyUqSrJWsJGMlkpUk + SZKVrCRZSVYyVpIkSZKRJEnGGBljjDHGGGP8fo/37mc/36199WzOnHOe531d1+3Ozf69zTnX9X4/znW9 + 3qdJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ + kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJ + kiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJkiRJOrV+G5/EhwAAP/Jp + nBuSJElq7L74/wAAfsIFIUmSpMbujdGFGQDAZFtIkiSpMWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTm + jDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFG + kiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoA + oGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLU + nLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHW + SJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgD + AFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmS + mjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrG + GkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlr + AICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCoGGskSZKaM9YAABVjjSRJ + UnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVnrAEAKsYaSZKk5ow1AEDF + WCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWSJEnNGWsAgIqxRpIkqTlj + DQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAAFWONJElSc8YaAKBirJEk + SWrOWAMAVIw1kiRJzRlrAICKsUaSJKk5Yw0AUDHWSJIkNWesAQAqxhpJkqTmjDUAQMVYI0mS1JyxBgCo + GGskSZKaM9YAABVjjSRJUnPGGgCgYqyRJElqzlgDAFSMNZIkSc0ZawCAirFGkiSpOWMNAFAx1kiSJDVn + rAEAKsYaSZKk5ow1AEDFWCNJktScsQYAqBhrJEmSmjPWAAAVY40kSVJzxhoAoGKskSRJas5YAwBUjDWS + JEnNGWsAgIqxRpIkqTljDQBQMdZIkiQ1Z6wBACrGGkmSpOaMNQBAxVgjSZLUnLEGAKgYayRJkpoz1gAA + FWONJElSc8YaAKBirJEkSWrOWAMAVIw1kiRJzRlrAICKsUaSJKm5e2J0YQYAMDknJEmDLo+r4wqADTK9 + rkz/+1iMLswAACa3xqXx42sJgPW4JrbHQndHfBvTi+VxgA10In58UQYA8G+j6weA9ZheWz6OG2LheyGO + xo9fPAEAAAAWxf54JJam92L0fxQAAABg7qZP1vwllqqz4psY/R8GAAAAmLN341exdN0VB2L0fxoAAABg + jr6Mm2Npmz4y5FBQAAAAYBEcjMdj6fswRv8BAAAAAOZiOqfm9ViJzovdMfoPAQAAADAH02O6z4mV6Z74 + 9zPKAQAAAOZkb9waK9d0fs3oPwgAAADAVpk+XPJorGSnxwcx+g8DAAAAsBVei5XuxnB+DQAAADAHu2I6 + a3fl+2M4vwYAAADYSsfihlA6K5xfAwAAAGylh0P/0VXxfoz+YwEAAABspr+FBv0u9sToPxoAAADAZvg6 + Lg/9RE/E6D8cAAAAwGa4LVQ0Pc771Rj9xwMAAADYSDtCJ9E18WGM/iMCAAAAbITpnJrtoZPsgdgbo/+Y + AAAAAOsxnVNzc2iNPR9HY/QfFQAAAOBUHIrpQyI6hc6Kt+NEjP7jAgAAAKzF8Zg+HPLL0Ck2fSTpixj9 + BwYAAABYi3fj6tA6eyQOxOg/MgAAAMDJ+CZ+F9qgXopjMfqPDQAAAFCZPgTyWGgDOzc+iNF/cAAAAICf + Mn344/WYzsbVBndT7InRf3gAAACAkU/jmtAmNT1ay9OhAAAAgJPxfdwV2uSm82tG/wAAAAAA/3Ykngg1 + ND0L/bMY/UMAAAAATN/KeSfU2KVxPEb/IAAAAMBq2x0XhJq7J0b/IAAAAMBquy60Rb0co38UAAAAYDU9 + FtrCzo8vYvSPAwAAAKyWD0Iz6IY4GqN/JAAAAGA1TE9/0oz6Y4z+oQAAAIDVcG1oRm2P12P0jwUAAAAs + t6dDM+zG2BWjfzQAAABgOU3n1JwTmmn3x74Y/eMBAAAAy+W78PWnmXdGPBsOHAYAAIDldigeCC1AV8bO + GP1DAgAAAIvvRLwU20IL0m3xVYz+QQEAAIDFNp1T8+vQgvVIOL8GAAAAlss3cVdoAZvOr3klnF8DAAAA + y+FgPBGnhxa0y+KTGP0DAwAAAIvljbgwtODdHHtj9I8MAAAALIZPwzk1S9R0fs3hGP1jAwAAAPO2O+4N + LVl/j+nRXqN/dAAAAGCejsQLoSVtWuJG//AAAADAPE2P6dYSty2Ox+gfHwAAAJiX6THd54aWvIdi9AMA + AAAAzMf+uDu0Iv0jRj8IAAAAwNabvhXz19CK5XHeAAAAME+fhFawG2M6UXr0QwEAAABsjT2xPbSiPRWj + HwwAAACg37G4P7TCnR07Y/QDAgAAAPRyTo3+2TXxZYx+SAAAAIAezqnRD/p9TI8EG/2wAAAAAJtregjQ + 9SH9X+fGC3EiRj80AAAAwOaY7sUfDum/ujz+EaMfHAAAAGBzvBy/CmnYbeH8GgAAAOjxYVwRUtljcTBG + P0QAAADAxpjOqbkrpJ/tjHg9Rj9IAAAAwMZ4PKST7pL4OEY/TAAAAMD6vBbnh7Sm7oxvY/RDBQAAAJya + 6cMRHtOtU+6ZOByjHy4AAABgbfbFH0JaV+/E6AcMAAAAOHnH47mQ1t30HbpdMfpBAwAAAE7O23F2SBvS + 3fF9jH7YAAAAgNr0IYjfhrShvRDHYvRDBwAAAIztjz+FtCm9G6MfPAAAAOC/TR96+GtIm9b2+CZGP4AA + AADAD30Q20La1O6JozH6IQQAAAD+ZXfcGlJLz8boBxEAAAD414ccdoTU2nsx+oEEAACAVfdqSO1dE9NH + ukY/lAAAALCqPovzQ9qS7o8TMfrhBAAAgFUzff1p+nCDtGX9IpxfAwAAAP8yfahB2vIui3dj9EMKAAAA + q+K1kGbTbbEnRj+sAAAAsOy+ifNCmlWPxOgHFgAAAJbddSHNshdi9EMLAAAAy+oPIc226cTrD2L0wwsA + AADL5vXYFtKsm06+dn4NAAAAy+7L8PUnLUxPxZEY/TADAADAojsY94a0ME0nYL8ZJ2L0Qw0AAACL6lg8 + E2eGtFDdHJ/H6AcbAAAAFtXOuCqkheyPsS9GP9wAAACwaL6KO0Ja6KbHeR+N0Q85AAAALIr9sSOkhe/8 + eC+cXwMAAMCimj6E8EqcE9JSdGN8F6MfeAAAAJi7j+PqkJaq+2M6MXv0Qw8AAABztSduD2kpm86vGf3g + AwAAwBwdisdCWuo+jdEvAAAAAMzJ8fh7SEvftph+4Ee/CAAAADAX38S5Ia1Et8ToFwEAAADmYDpz9dqQ + VqqXYvQLAQAAAFvNOTVa2b6I0S8FAAAAbJX3QlrZrowjMfrlAAAAgG77Q1r5HogTMfolAQAAgC7TvenV + Ia1809OhXovRLwoAAAB0eTok/W/TCdufx+iXBQAAADbb+yHpR90d38folwYAAAA2y7dxeUj6UWfFU+HA + YQAAALocjPtD0k80LZlvx+gXCAAAADbai3FuSCr6bXwRo18iAAAA2Cjvhq8/SSfZQ+H8GgAAADbLV3Fb + SDrJzoiXw/k1AAAAbLQD8WicHpLW0MXxUYx+sQAAAOBUvRbnhaRT6KbYHaNfLgAAAFir6UMBV4WkdfRw + TI9SG/2SAQAAwMn6Nn4Xkjagv8eJGP2yAQAAwM+ZzkR9LiRtYF/H6BcOAAAAfs7OkLTBXRS+DgUAAMBa + 7YptIWkTms6vOR6jXz4AAAD4se/j3pC0ib0To19AAAAA+E/H4qWQ1NB0gvfoFxEAAAD+7YOQ1NS1cThG + v4wAAAAw/ZH/kpDU2JMx+oUEAABgtU1/3P99SNqC3o7RLyYAAACr68WQtEVdEV/E6JcTAACA1fNhSNri + pkew7Y/RLykAAACrY29cHZK2uLPi2Rj9ogIAALA6/hCSZtJ0wrfzawAAAFbXCyFpZv02dsXolxYAAIDl + 9X54TLc00x6JAzH65QUAAGD5TOfU3BqSZtxfY/QLDAAAwPKZ/mgvaeZdFNNH4Ea/xAAAACyPl+LskLQA + 3R5fxeiXGQAAgMX3QVwTkhaop+JQjH6pAQAAWFzfx70haQF7M07E6JcbAACAxXMsngxJC9p0fs0nMfoF + BwAAYPG8EeeHpAXuntgTo19yAAAAFsfn8duQtAQ9G0dj9MsOAADA/O2Lh0PSEvVOjH7hAQAAmLfpj+9/ + CUlL1iXxZYx+8QEAAJin6aEx78aFIWkJ+10cjtELAAAAAPPzbdwSkpa46RFvoxcAAAAA5uVIPBSSVqCd + MXohAAAAYB6mrz+9FJJWpEvD47wBAADm69M4NyStUHfF6AUBAACArXUorg5JK9ifY/TCAAAAwNaZHg4j + aUXbHv+I0YsDAAAA/V4JSSvejfF9jF4kAAAA6PNdSNI/uy9GLxQAAAD0uTAk6Z/9Kp6N0YsFAAAAm2/6 + I7ok/aBfx/sxetEAAABg87we54Qk/Vd3x+4YvXgAAACw8b6Mq0KSfrLH43CMXkQAAADYOAfizpCksm0x + fQTveIxeTAAAAFi/o/FknBWS9LP9Jj6N0QsKAAAA6/d2XBGSdNL9IfbG6EUFAACAU/dF3BKStOaeC+fX + AAAAbJzv46GQpFNqOr9mZzi/BgAAYP2mc2peCo/plrSuro9vY/RCAwAAwMn7IK4MSVp398aRGL3YAAAA + 8POmP4LfGpK0YU3n15yI0YsOAAAAP+1A/CkkacP7JEYvPAAAAIxNZ4C+FZK0KZ0dx2L0AgQAAMB/+yrO + DEnatG6I0QsQAAAAP3Qofh2StOm9EKMXIgAAAP5l+lbCjpCktr6M0QsSAAAAp532bkhSa9vjcIxelAAA + AFbZ7pCkLen+mE42H704AQAArKKjcVVI0pZ0TrwWoxcoAACAVfRUSNKWdkV8GqMXKQAAgFXinBpJs+mO + 2BujFysAAIBV8E1cFJI0i86KP4cDhwEAgFV0MO4JSZpVl8abMXrhAgAAWGbPxa9CkmbXTfFZjF68AAAA + ltHOuDgkabY9EHti9CIGAACwTL6M34Ykzbrpo38vxpEYvZgBAAAsg+mcmodDkhai7fF+jF7QAAAAlsHL + cU5I0sJ0Q3wdoxc1AACARfZeXB6StHA9FPtj9OIGAACwiKY/St8VkrSwTY/zPh6jFzkAAIBFMp3N+UxI + 0sL3eYxe6AAAABbJGyFJS9EVsTdGL3YAAACL4JO4OCRpadoRHucNAAAsoj1xX0jS0vVWjF74AAAA5mr6 + o/MLIUlL25cxegEEAACYmxPxj5Ckpe6aOBijF0IAAIA5mf7YfHlI0tL3WIxeCAEAAObiUNwfkrQyOb8G + AACYs+dCklaq6ZF3u2L0oggAALCVnFMjaWW7K/bH6MURAABgK+yNS0KSVrLT48kYvUACAABshbtDkla6 + C+ONGL1IAgAAdHomJEnppvg8Ri+WAAAAHd6LbSFJ+t8ejIMxetEEAADYTPvixpAk/agXYvTCCQAAsJl+ + H5KkQdvjnRi9eAIAAGyG5+LMkCT9RLfGFzF6EQUAANhI78dVIUn6mR4P59cAAACb6fu4KyRJJ9mrcTxG + L6oAAADrcTQeC0nSGro0PozRCysAAMCpOhGvxQUhSVpj98R3MXqBBQAAOBWfxm9CknSKPRVHYvQiCwAA + sBZ748GQJK2zt2L6qOLoxRYAAOBkHI7nQ5K0AV0Wu2L0ggsAAPBzpoeX7IyLQpK0QU2P1DsUoxdeAACA + ytdxc0iSNrjHY/TCCwAA8FOmP/o6p0aSNrHp/JrRCzAAAMCPHYsXQ5K0iZ0fe2L0QgwAAPCfPomzQ5K0 + yU3fNR29EAMAAPzbwbgiJElNPRqjF2QAAIDJnSFJamz6KOM/YvSiDAAArLaXQpK0BV0Z+2L04gwAAKym + 70KStIXdEaMXaAAAYPWcCEnSFndmPB2jF2oAAGC13BOSpBl0VbwXoxdrAABgNbwekqQZdXtM300dvWgD + AADL7Yu4OCRJM2tHHIrRizcAALCc9setIUmaYRfEq3E8Ri/iAADAcjkaT8R0lqUkaabdGB/H6IUcAABY + Lm/FJSFJmnn3xZ4YvZgDAADL4fO4KSRJC9L0OG/n1wAAwHLaGw+EJGmB2hZvh/NrAABguRyJF+LskCQt + WNfG1zF6gQcAABbTe3FZSJIWtLvjYIxe5AEAgMXyVdwckqQF79k4FqMXewAAYDHsi0dCkrQkfRKjF3wA + AGD+prMo3whJ0hJ1eng6FAAALKZdIUlawm6I0Qs/AAAwX9/H1SFJWtKmR/yN3gAAAID5ORyPhiRpyfsi + Rm8EAADAvLwTkqQV6Kxwfg0AAMzb1yFJWqHui+lE+dGbAgAAsLUOxrUhSVqxXonRGwMAALC1Hg9J0gp2 + UXwSozcHAABga+wMSdIKd0vsjtGbBAAA0OurOCckSSvcGfFYTI8EHL1ZAAAAPaZzau4ISZJO2x6vx+gN + AwAA6PF0SJL0f10XH8foTQMAANhcf49tIUnSD7o/nF8DAAC9vogbQ5Kk/+oX8XwcjdGbCAAAsLGmc2oe + DEmSfrLpo5fTowJHbyQAAMDGeiGmh35IklQ2nV8zfRRz9GYCAABsjHfi0pAk6aR6KPbF6E0FAABYn6/D + Y7olSWvu1TgWozcXAADg1ByOx0OSpFPqoxi9wQAAAKfmlZAk6ZT7dXwXozcZAABgbT6My0KSpHX1pzgU + ozcbAADg5Ex/BL03JEnakP4WozccAADg503n1DwTkiRtaJ/F6I0HAAD4aSfi7yFJ0oZ3bXicNwAArM2u + uDIkSdqUHo7RGxAAAPDfDsR9IUnSpub8GgAAODnOqZEktXRefB6jNyMAAOBf3glJktq6NaaPdI7elAAA + YNVNj+m+JCRJau3RGL0xAQDAqpv+uClJUnvT16FejdGbEwAArKonQpKkLeu6+CxGb1IAALBq3o1fhCRJ + W9r9cShGb1YAALAqpjMdrwxJkmbRUzF6wwIAgFVxZ0iSNJu2xRsxetMCAIBl92ScHpIkzarpxPsvYvTm + BQAAy+r9uDwkSZplO2L6ru7oTQwAAJbN3vCYbknS7HspjsfozQwAAJbF0Xg4JEmafdNHQN+L0RsaAAAs + gxPxSlwYkiQtRL+Lb2P0xgYAAIvu47gxJElaqJ6IQzF6cwMAgEW1J+4PSZIWsr+F82sAAFgW0x8jnw5J + kha2y+KzGL3RAQDAIpn+CPn32B6SJC10d4THeQMAsOi+DOfUSJKWpkdj9IYHAACLYH/8PiRJWqrejNEb + HwAAzNnReD4kSVq6zo3dMXoDBACAufoozgpJkpayK2P0BggAAHO0Ly4NSZKWuodj9EYIAABzciLuDEmS + VqJ3Y/SGCAAAc/FySJK0Mp0T38foTREAALba9JhuSZJWrptj+mjp6M0RAAC2yvGQJGkl+1U8GaM3SAAA + 2Cq/C0mSVrbLwvk1AADMxWshSdLK99v4NkZvlgAA0GVXnB2SJCk9FAdj9KYJAACbbV/cFJIk6X/bFtOj + EafD3EZvngAAsFmOxqPxy5AkSf/RdfFhjN5AAQBgs7wR20OSJA26O5xfAwBAl09j+qOhJEkq+nMciNGb + KQAAbJQ9cV9IkqSf6fx4K5xfAwDAZjkSz8VZIUmSTqKr44sYvbECAMB6vRMXhyRJWkN3xfQIxdGbKwAA + nKpd4THdkiSdYs/G9BHV0ZssAACs1ffxcEiSpHX0UYzeaAEAYC2mMxFfC0mStAH5OhQAAOv1cUiSpA1q + +k7x0Ri96QIAwM/5Nq4JSZK0gb0QozdeAACoHIrHQpIkbUKfxOgNGAAARk7EWyFJkjaxgzF6IwYAgB+b + HtMtSZI2uXviWIzejAEA4N+mh1TcEJIkqaGXY/SGDAAAk+nrT86pkSSpsXPjoxi9MQMAwJshSZKamx7n + /V2M3pwBAFhdX4YkSdqCTo9H4kiM3qQBAFg902O6bwlJkrRFbYtXY/RGDQDA6nkiJEnSFvfr+CBGb9YA + AKyOv8VZIUmSZtD0OG/n1wAArK5dcW1IkqQZ9Uwci9GbNwAAy+tw3BeSJGlmTY/zfitGb+AAACyvp2J6 + +IQkSZph00dfP4vRmzgAAMtn+mPdxSFJkmbcg7E3Rm/mAAAsj6/i1pAkSQvQS3E0Rm/qAAAsvkPxcEiS + pAXqvRi9sQMAsPj+EpIkacG6LqaPxo7e3AEAWFzTH+WuCEmStIDtiAMxepMHAGDxfBN3hyRJWuBejRMx + erMHAGBxTOfUPBmSJGkJ+jhGb/gAACyG4/FGSJKkJWk6v2ZPjN74AQCYv0/jqpAkSUvUQzF64wcAYN72 + xT0hSZKWsJdjdAEAAMA8TV9/ck6NJElL3mcxuhAAAGB+3gpJkrTk3RTTkwRGFwMAAMzHt3FJSJKkFcj5 + NQAA83dzSJKkFenMcH4NAMB87QhJkrRiXR2fx+jiAACArfNeSJKkFe3OOByjiwQAAPodjHNDkiStcH+K + 0YUCAAD9bgxJkrTiXRCvxehiAQCAPo+HJEnSP5ueNOD8GgCArfN+XBSSJEn/1x9jf4wuHgAA2Dx7wtef + JEnSsBfiWIwuIgAA2HhH4oGQJEkadnnsjNGFBAAAG+t4vBTbQpIk6SebHuf9dYwuKAAA2DgfxnUhSZL0 + sz0aB2J0UQEAwPp9F3eHJEnSSfdqHI3RxQUAAKfuYPw5JEmS1tR0fs0nMbrAAADg1Ezn1LwZ20OSJGnN + 3Rb7YnShAQDA2n0e14ckSdIptyM8zhsAYP32xr0hSZK07v4WowsOAABOzuF4LiRJkjaks+LbGF14AADw + 8z6IX4UkSdKGNR04PLrwAACgticuCkmSpA3vDzG6AAEAYOxo3BmSJEmb1s4YXYgAAPDfXgpJkqRNb3qS + wehiBACA/2d6TLckSVJL18fxGF2UAABw2mmHQpIkqa3/iSdidGECAMBpp90RkiRJrW2Pf8To4gQAYJW9 + GpIkSVvSDfFNjC5SAABW0WchSZK0pU2P8z4Qo4sVAIBVMj2E4bqQJEna0s6PF+NYjC5aAABWwdF4OCRJ + kmbRr+P9GF24AACsgtdi+iOWJEnSbLozvo7RxQsAwDL7KK4OSZKk2fVY7I/RRQwAwDLaHXeHJEnSLDsv + 3ojjMbqYAQBYJtM5NU/HGSFJkjTbrozpkZWjCxoAgGXyZlwYkiRJs286v2ZPjC5qAACWwadxQ0iSJC1M + z8ThGF3cAAAssu/joZAkSVq4PojRBQ4AwKKazub7a0iSJC1s38XoQgcAYBG9F5IkSQvdLXEwRhc7AACL + 5Ku4PiRJkha+58PjvAGARXYgdoQkSdLS9GGMLnwAAOZu+qPT6yFJkrR0TU9OGF0AAQDM2SchSZK0lN0R + x2J0EQQAMEd74saQJEla2v4SowshAIC5mf7I9GhIkiQtfR/E6IIIAGBOnFMjSZJWpmvjuxhdFAEAzMFn + IUmStFL9MY7E6OIIAGArHY4bQpIkaaU6J16K0QUSAMBW2hGSJEkr2ZXxXowukgAAtsKrIUmStNLdFc6v + AQDmYFdcEZIkSSvfE3E0RhdNAAAdprP07gxJkiSls2J6NObowgkAoMNjIUmSpP9oepz3xzG6eAIA2EzT + H40uDEmSJP2o+2N3jC6iAAA2wxdxU0iSJOknej6cXwMAdDgUD4QkSZJ+pndidEEFALBRTsRzIUmSpJPo + upgenTm6sAIA2Ag74/KQJEnSSfZw7I/RxRUAwHp8HXeFJEmS1tjLcSxGF1kAAKfiYHhMtyRJ0in2i3g/ + RhdaAABrNf0R6NWQJEnSOro+vovRBRcAwFp8HFeFJEmS1tmDcTxGF10AACdjbzinRpIkaQN7MUYXXgAA + P+dIPB6SJEna4KaPLo8uwAAAfsqJeDMkSZK0CV0dh2N0IQYAMDI9pvvikCRJ0iZ1f4wuxAAAfmx6+tNN + IUmSpE3uLzG6IAMA+E+PhCRJkhq6JD6P0UUZAMDkvZAkSVJjv4npyQ6jizMAYLVNZ9xJkiRpC3ogRhdo + AMBquyIkSZK0BV0Qr8ToIg0AWE2PhSRJkrawG8L5NQDAZDqn5pyQJEnSFjc9znt/jC7aAIDVsDt+HZIk + SZpJz8TRGF28AQDLbTpQ+L6QJEnSjLos3o4TMbqIAwCW0/F4Ic4LSZIkzazb46sYXcgBAMvpg/D1J0mS + pBn3SDi/BgBWwzdxZ0iSJGnmvRxHYnRRBwAshwPhMd2SJEkL0nR+zUcxurADABbfdE7N3+LCkCRJ0oJ0 + S+yJ0QUeALDYPolrQpIkSQvWdH6Nr0MBwHLZHXeHJEmSFrTpI9Ie5w0Ay+FQPBuSJEla4E6Pr2N0wQcA + LJb3QpIkSUvQJTG64AMAFsd3cUFIkiRpSbo/Rhd+AMD8HYw7Q5IkSUvW2zG6AAQA5mt6TPcLIUmSpCVt + b4wuBAGAeZoe0y1JkqQl7uqY/kI3uhgEAOZlX0wPC5AkSdKS91iMLggBgPk4FneEJEmSVqBz4p0YXRgC + APPwckiSJGmF+nV8FaOLQwBga30akiRJWsHujf0xukgEALbGnrgqJEmStIKdF8+HA4cBYB6mc2oeDEmS + JK1wV8Q/YnTBCAD0+mucEZIkSVrxbo0vY3TRCAD0eD8uD0mSJOmf/SmcXwMAW+O7uDMkSZKk/2t6nPdr + cSJGF5EAwOaYzql5In4RkiRJ0g+6LD6K0YUkALA5pj+WbAtJkiRp2B0xfRR7dDEJAGys6Y8k14UkSZJU + 9nQcitFFJQCwMfbGAyFJkiSdVDtjdGEJAKzf8XghJEmSpDXlcd4AsDneDkmSJGnN3Rr7YnSRCQCcms/j + +pAkSZJOqedieqTo6GITAFib6Y8gj4QkSZK0rt6L0QUnAHDypj9+vBKSJEnSujsrvo3RhScAcHI+iNND + kiRJ2pDuiCMxuvgEAGrTHz1+E5IkSdKGNp1fM7oABQB+2vTHDufUSJIkadNyfg0ArI1zaiRJkrSpXRXO + rwGAk/NxTGe/SZIkSZva7+NojC5KAYB/ORTXhSRJkrTp/TKej9GFKQDwLw+EJEmS1NalsTNGF6cAsOr+ + GpIkSVJ7t4XzawDgh76Ii0KSJEnaknbEsRhdrALAqpnOdPtNSJIkSVvWr+LlGF2wAsCqeSgkSZKkLW96 + nPf7MbpoBYBV8UqcF5IkSdIsuje+i9HFKwAsu13hMd2SJEmaXU/H9F390UUsACyrgzH90UKSJEmaXb+I + N2N0IQsAy+hEPBWSJEnSbJs+Av5pjC5oAWDZ/D0uD0mSJGnW/TG+j9FFLQAsiy/j9pAkSZIWohfD+TUA + LKv9sSMkSZKkhenM+EdM3+UfXeQCwKKa/hjxcvxPSJIkSQvVDfFtjC50AWBRfRhXhSRJkrSQ/SF8HQqA + ZbE77ghJkiRpoXs+Rhe8ALBIDsWjIUmSJC18v4iPYnThCwCL4Hi8EZIkSdLSdFlMf5EcXQADwNx9FdtD + kiRJWqqm7/iPLoABYM6OxPUhSZIkLWUvxOhCGADm6pGQJEmSlrazY1eMLoYBYG7eDUmSJGnpuzKmj5SP + LooBYC4OhCRJkrQy3RejC2MAmIuLQpIkSVqZzo+XY3RxDABb7U8hSZIkrVzXxGcxukgGgK3inBpJkiSt + dHfHvhhdLANAt+/i0pAkSZJWuj+HA4cB2GqH4nchSZIkrXyXxVsxunAGgA4n4rk4JyRJkiSlW+KLGF1A + A8Bmm86puSIkSZIk/Ud/jO9jdBENAJvlq5j+aCBJkiTpR/0y/hLOrwGgy/7YEZIkSZJ+oukJHB/E6IIa + ADbS8Xg1toUkSZKkot/E9OjU0YU1AGyUD+PqkCRJknQSPRQHY3RxDQDr9U3cFZIkSZLW0OsxfUR9dJEN + AKfqUDwdkiRJkk6h6QkdowttADhVO0OSJEnSKXZxHI3RxTYArNX0R4DzQ5IkSdI6ujdGF9wAsBbfx20h + SZIkaQN6K0YX3gBwMqZPaT4fkiRJkjaw3TG6AAeAnzM9pluSJEnSBndpOL8GgLX6Ls4MSZIkSZvQo3Ei + RhfjAPBjh+N3IUmSJGkTeztGF+QA8GMvhCRJkqRN7rL4IkYX5QDwb86pkSRJkhqbPtK+P0YX5wCwJ6az + ziRJkiQ1dXY8E8djdJEOwOo6Fr8PSZIkSc1NfzF1fg0AP/ZiSJIkSdqibo7PY3SxDsDqeTcuCkmSJElb + 2MOxL0YX7QCsjt1xa0iSJEna4s6Kv8aJGF28A7D8pjPMdoQkSZKkmXRJvB+jC3gAlt/LcW5IkiRJmlG3 + xdcxuogHYHl9ENeEJEmSpBn2ZByM0cU8AMtnb9wXkiRJkmbcW+H8GoDlN51TM430kiRJkmbemfFZjC7s + AVgeb4QkSZKkBWk6v2ZPjC7uAVh8n8b1IUmSJGmBejaOxugiH4DF9X08FJIkSZIWsJ0xutAHYDFNI/xL + IUmSJGlBOy++jNEFPwCLZTo8/t2YziaTJEmStMDdEYdidOEPwOL4Om4OSZIkSUvQ0zG68AdgMRwO59RI + kiRJS5bzawAW0/T1J+fUSJIkSUvYpfFdjG4EAJivj+LskCRJkrSE3RPHYnQzAMD87I9rQ5IkSdIS91SM + bggAmJ+7Q5IkSdKStz3eidFNAQDz8ZeQJEmStCL9JpxfAzBfX8avQpIkSdIK9WBMTxgZ3SQAsHWOx9Uh + SZIkacX6n3g+RjcKAGyd+0KSJEnSinZF7IzRzQIA/aZzas4MSZIkSSvc78L5NQBbb1dcFZIkSZJ02hNx + JEY3DwBsvoNxR0iSJEnSP5s+cv9aOHAYoN+xeDwkSZIk6QddHx/H6EYCgM3zZlwakiRJkvRfPRB7Y3Qz + AcDG+yJuCUmSJEn6yZ4N59cAbL7v48GQJEmSpLJz4p04HqObCwDWbxrFX4wzQpIkSZJ+tun8mq9jdIMB + wPq9Hx7TLUmSJGlN3ReHYnSTAcCp+yZuDUmSJElac8+Fx3kDbJwDsSMkSZIk6ZT6ZXwYoxsOANbmWLwe + kiRJkrSuLo7pL8GjGw8ATt70mO4LQpIkSZLW3W9idOMBwMk5GNeEJEmSJG1Yz8boBgSA2nT218MhSZIk + SRverhjdiADw094OSZIkSdqUtsWRGN2MAPDf9oYkSZIkbWq/i9ENCQD/7dyQJEmSpE3t7HgpRjclAPw/ + O0KSJEmSWroiPo3RzQkAp532bkiSJElSa7fHdBbD6CYFYJV9G+eHJEmSJLV2ejwWDhwG+H8Oxh0hSZIk + SVvSJfFGjG5YAFbNiXgmzghJkiRJ2rJ+E5/F6MYFYJXsjItDkiRJkra8P8SeGN28AKyCL2IaryVJkiRp + Fk0f+X8+DsfoJgZgme2Ph0KSJEmSZtX00f/pUbWjGxmAZTWdU/NynBeSJEmSNLtujK9jdEMDsIzeiytC + kiRJkmbbgzF9JWB0UwOwTL4Kj+mWJEmStBC9GsdidHMDsAwOxpMhSZIkSQvT9GSU0Q0OwDL4e0iSJEnS + QnVhHIjRTQ7AIvsszglJkiRJWrjuj6MxutkBWES74/aQJEmSpIXtzRjd8AAsmiPxXEiSJEnSwudx3sAy + eDckSZIkaSnaHodjdPMDsAimx3SfF5IkSZK0NP0pRjdAAHM3HZZ+d0iSJEnS0jU96nZ0IwQwZ86pkSRJ + krS0XRC7YnQzBDBH/whJkiRJWuruiH0xuikCmJPpMd0XhiRJkiQtdb+KJ+N4jG6OAOZgeo26JyRJkiRp + JZr+Uv1mjG6QAObg2ZAkSZKklerG+CxGN0kAW2k6p+b8kCRJkqSV68Fwfg0wJ9M5NTeFJEmSJK1kv4wX + Y3TDBNDtRDwQkiRJkrTSbY+dMbpxAuj0QpwZkiRJkrTy3RJfxujmCaDDu3FlSJIkSZL+t0fjQIxuogA2 + 0564MyRJkiRJP+r1mM6MGN1MAWyG4/FYSJIkSZIGnRcfxeiGCmAzvBK/CkmSJEnST3R7fBujmyqAjTSN + w9eHJEmSJOlnejoOx+jmCmAj7A2P6ZYkSZKkNfRWOL8G2AxH4rmQJEmSJK2hC+PzGN1oAZyq6UDhd+Lc + kCRJkiStselRuh7nDWykL+PmkCRJkiSdYn+O0Q0XwFodjAdDkiRJkrTOpvNrRjdeACdr+vrTiyFJkiRJ + 2oC2hcd5A+vxQTinRpIkSZI2sNtj+sv46CYMoLIvfh2SJEmSpA3u8RjdiAFU7gpJkiRJ0iY0fYXB+TXA + WjwXkiRJkqRN7NrYHaObMoD/9EVIkiRJkhq6J0Y3ZgD/yYHCkiRJktTYEzG6OQOY3BaSJEmSpMYuj3di + dJMGrLa/hCRJkiRpC5oe5/1tjG7WgNW0Ky4OSZIkSdIWtSMOx+imDVgtB+K3IUmSJEnaws6Jv8bxGN28 + AavhWPwpTg9JkiRJ0hZ3fXwYoxs4YDX8LXz9SZIkSZJm1P2xO0Y3ccBy+zxuCkmSJEnSzHoqDsXoZg5Y + Tnvj9yFJkiRJmmHnxVvh/BpYDUfi+TgzJEmSJEkz7br4MkY3dsBy+UdcHpIkSZKkmXdPTI/wHd3cAcvh + q/CYbkmSJElaoJ6J6VG+o5s8YLHti4dCkiRJkrRA/U+8F6MbPWBxHY1XQ5IkSZK0gF0Q+2N0wwcsps9i + OkxckiRJkrSg3RijGz5g8Uzj69UhSZIkSVrwnorRjR+wOKavPzmnRpIkSZKWqF0xugEEFsNbIUmSJEla + so7E6CYQmLfvQpIkSZK0hN0eoxtBYL4Ox4UhSZIkSVrCTo+XYnRDCMzTwyFJkiRJWuIuik9idFMIzMvO + kCRJkiStQDfHnhjdHALz8HVIkiRJklakX8SOmM7CGN0kAlvrQNwSkiRJkqQVavo61OtxIkY3i8DWmH4n + nwpJkiRJ0gp2XXwcoxtGYGv8PbaFJEmSJGlFuy92x+imEej1eVwfkiRJkqQV7ox4NpxfA1trfzwQkiRJ + kiSdtj2mRwSPbiCBHi/E2SFJkiRJ0j+bzq/5IkY3kcDmmsbSS0OSJEmSpB/0h/g+RjeTwOaYRtJbQ5Ik + SZKkYa/E0RjdVAIb62A8HpIkSZIklX0WoxtLYGP9LSRJkiRJ+tkujD0xurkENsaHcU5IkiRJknRSTefX + HIrRTSawPt/E7SFJkiRJ0pp6I0Y3msCpOxzPhCRJkiRJp9SuGN1wAmt3It4OSZIkSZJOuctif4xuPIG1 + +Ty2hyRJkiRJ6+qhGN14AidvX9wTkiRJkiRtSM6vgVM3ff3JOTWSJEmSpA3trJi+wjG6EQVq74QkSZIk + SRveLTF9lWN0MwqMfR0XhSRJkiRJm9JjMX2lY3RTCvzQ9LtyW0iSJEmStGmdF6/F6MYU+KEnQ5IkSZKk + Te/a+CRGN6fAv0zn1PwyJEmSJElq6f7YH6ObVFh1u+OakCRJkiSptelRxKMbVVh194QkSZIkSe1dEG/F + 6GYVVtXT4etPkiRJkqQt6+b4PEY3rbBqdsalIUmSJEnSlvZIHIjRzSusij1xS0iSJEmSNItejuMxuomF + ZXcsHg5JkiRJkmbThfFejG5kYdm9FGeHJEmSJEmz6o74OkY3s7CsPozrQpIkSZKkWfbnOBSjm1pYNrvj + /pAkSZIkadb9LZxfw7KbRsmnQpIkSZKk2XdxfBKjG1xYBtMY+VZsC0mSJEmSFqLp/Jp9MbrRhUW3K24K + SZIkSZIWqsfiRIxudmFR7Y/fhyRJkiRJC9l0fs3ohhcW0dF4PiRJkiRJWtimMz08zptlMH1K7L04NyRJ + kiRJWuhuiNHNLyySvXFVSJIkSZK0FD0SoxtgWBTTodmSJEmSJC1V06OORzfBMHfPhiRJkiRJS9elMX2V + ZHQzDHM1PaZbkiRJkqSl7bcxuiGGuZIkSZIkaen7U4xuimFubgpJkiRJkpa+6etQ78To5hjm4i8hSZIk + SdLKNH0d6tsY3STDVvs8zglJkiRJklaqP8ahGN0sw1bZH9eHJEmSJEkr13kxfdXkeIxumqHb0XgkTg9J + kiRJklaya+ODGN04Q7fXY3tIkiRJkrTS3R3Or2GrfRLXhSRJkiRJSn+OgzG6iYbNtjvuDUmSJEmS9L+d + H2/EsRjdTMNmORzPxFkhSZIkSZL+o2tiV4xuqGGzvB2XhiRJkiRJGnRX7IvRTTVstGkcvCkkSZIkSVLR + U3EkRjfXsFH2xoMhSZIkSZJOonfjRIxusmG9jsZfQ5IkSZIknWTnxvcxutGG9Zoe031GSJIkSZKkNXRD + jG60YT32xFUhSZIkSZJOoSdjdMMNp+JQ/DEkSZIkSdI6+jRGN96wFtMZSG+GJEmSJEnagA7H6AYcTtaX + IUmSJEmSNqhbw9OhOFX74/KQJEmSJEkb2F9idCMOleOxIyRJkiRJ0gZ3Tnwcoxty+CnOqZEkSZIkaROb + Hue9O0Y35fBjX4UkSZIkSdrETo+Hw4HD/JwD8ZuQJEmSJEmb3AXxSoxu0OHfnghJkiRJktTUr+PDGN2k + wxtxZkiSJEmSpMbujm9jdLPO6vospjFPkiRJkiQ198t4Kpxfw7/tj/tCkiRJkiRtUdvi7zG6cWf1PBNn + hCRJkiRJ2sKuiemrL6Obd1bHW3FxSJIkSZKkGfT72BOjm3iW3674bUiSJEmSpBn1chyL0c08y+tQ/Ckk + SZIkSdIM+yBGN/Qsr5dCkiRJkiTNtMvi6xjd1LN83o0LQpIkSZIkzbgH4kCMbu5ZHl/FHSFJkiRJkhag + 1+J4jG7yWXwH488hSZKk/7+9u/v4u47jOL7DJOkgkw6STJIkySXTwUwHSQeTTCaTDiYzk2QmiUw66GAH + SQeXJNnBDjLJpINJ5pKZTJIkMzPJXGZmZi4ZvT66m3qvXdf2u/nePB48uf6F6+X3fX8AoEeOpeofffW7 + NsIdTAAAAEDPPJY85z282gj3QAIAAAB66NXkc6jh9EvangAAAIAe+zhV//irX62kdxIAAAAwAMdTNQCo + Px1KAAAAwEA8mZZTNQKo+/2Q3KkBAACAgdmTqiFA3a59/rQlAQAAAANze/ooVYOAutveBAAAAAxUe877 + m1SNAupenycAAABg4F5I51I1Dqg7nUnu1AAAAMBI7EvVQKDu5E4NAAAAjMjd6UCqRgLNvzcSAAAAMDLt + Oe/jqRoLNL/anZp7EwAAADBCr6TlVI0Gmn3tTk0b0QAAAIARey/9lqrxQLPrcno5AQAAACN3f/oiVQOC + ZtOV9H5anwAAAADWbU0/pmpI0PT7Kj2RAAAAAP72ZjqXqjFB0+tk2p4AAAAA/uOTtJKqUUGT73zalwAA + AABKD6al1G6oVOOCJlcbxQ6mexIAAADANT2bfknVwKDJ9W3anAAAAACua2/ynPf0+jW9lAAAAABW7UCq + hgbdXBfTuwkAAABgTe5KnvOebO0W0JfpjgQAAACwZhuTY8OT60x6OAEAAADcsJdTNTxobbXXn9rxZgAA + AICbdihVA4RW3/4EAAAAMBG3pvaCUTVC6PqdSAAAAAAT9Xiqhgj9f5cTAAAAwFTsSdUgoWu3KQEAAABM + xX3pcKpGCf23xQQAAAAwVe2XIj+napzQPx1PAAAAADOxI51P1UihP44xP5YAAAAAZmJ9ei+tpGqsGHOX + 0u4EAAAAMFPtdagjqRosxtzH6e4EAAAAMHPPJ/dr/mkpLSQAAACAuXkjLadqvBhTp9K2BAAAADBX7ZOf + A2nM92supnfSbQkAAABg7tqnP+2p6mrIGEOfpg0JAAAAoDO2pjOpGjOGXBupNiUAAACAznk7XUjVqDHE + TqedCQAAAKCzvkxXUjVuDKnLaTEBAAAAdFo7stt+cVINHEPq6wQAAADQC5tT++VJNXIMoZ/SowkAAACg + N9r9miF+DrWcdiUAAACA3llK1eDR11bSgQQAAADQW+2XKNXw0ceOJQAAAIBeezr9lqrxo0+dSQsJAAAA + oPc+SNUA0pfaseQ9CQAAAGAwjqZqCOlD7tQAAAAAg/N4OpWqMaTLnUgAAAAAg9SevL6YqlGki51LmxIA + AADAIK1Pi6kaRrrY6wkAAABg0B5JR1I1jnQpd2oAAACA0diafkrVSNKFjqWHEwAAAMBo7EtdvF/T7tRs + SwAAAACjclc6mKrBZJ61EQkAAABglBbSUqpGk3nU7tTckwAAAABGa0c6narxZJadSE8lAAAAgNF7P11O + 1Ygyiy6k3QkAAACAPx1O1ZAyi/YnAAAAAK7yaPouVWPKNPs8bUgAAAAA/Ev7FOlsqkaVafRDei4BAAAA + cA0fppVUjSuT7Fx6MwEAAABwHUdTNbBMqjYGfZIAAAAAWIWN6WSqhpZJ1MaghxIAAAAAq7QrTeM579Np + WwIAAABgjRZTNbjcaG38eSsBAAAAcIOWUjW8rLUr6WACAAAA4CYspPZyUzXArKXv04YEAAAAwE1q92uq + AWa1tc+fnkkAAAAATMgHqRpiVtOrCQAAAIAJejDdyP2aQwkAAACAKXg2nU/VKFN1Nt2SAAAAAJiS11I1 + zFRtTAAAAABM0Z1pMVXjzNW9kgAAAACYgc3peKpGmtbhtD4BAAAAMCM70nL691BzKi0kAAAAAGbs3bSS + /hpqLqUXEwAAAABz8ED6LLWh5kran9pNGwAAAADmpD3n/X06knz+BAAAANABO9OWP/4EAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1mDdut8Bti/zmKeQzHYAAAAA + SUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAABkAAAARrCAYAAADb+Gp7AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAASClJREFUeF7s3Q+k3vX///F85SNJJjMzk0ySyXwkk8nMJEkyyWQySSaZZGYmGUmS + ZJJJZpLMJJlkJjOZj5mZmZmZyczMzBwzxxzHMcfv93hXq7ad/+d9Xdf7/Xrf7tx8vt+vjy/V2RXn4Xq+ + 7pMkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkqbiWxdo//0dJkiRJkiRJkqQyWhXHYtsf/5skSZIk + SZIkSVIB/Tf+XwzFN/FgSJIkSZIkSZIktbpqALkV1QhS/eeheCkkSZIkSZIkSZJa278HkNvOxkchSZIk + SZIkSZLUyiYaQCo3Yl8sDEmSJEmSJEmSpFY12QBSqf7v1QPp60KSJEmSJEmSJKk1TTWA3HYlPgxJkiRJ + kiRJkqRWNJMBpFL9d/bG4pAkSZIkSZIkSWp0Mx1Abjsda0OSJEmSJEmSJKmxzXYAqYzF1pAkSZIkSZIk + SWpkcxlAbvshVoQkSZIkSZIkSVKjms8AUjkfr4YkSZIkSZIkSVJjmu8Actv2WBaSJEmSJEmSJEkDr64B + pFKdxHopJEmSJEmSJEmSBlqdA0ilOom1OR4ISZIkSZIkSZKkgVT3AFIZjq9iZUiSJEmSJEmSJPW9Xgwg + ler/56F4IyRJkiRJkiRJkvparwaQ236PHbEgJEmSJEmSJEmS+lKvB5DK9dgXq0KSJEmSJEmSJKnn9WMA + qYzFidgQkiRJkiRJkiRJPa1fA8htV+PjkCRJkiRJkiRJ6ln9HkAqI3EgHg1JkiRJkiRJkqTaG8QAUhmP + S7E6JEmSJEmSJEmSam1QA8i/7QhJkiRJkiRJkqTaasIAUjkSkiRJkiRJkiRJtdSUAaRSvQ3yXEiSJEmS + JEmSJM2rJg0gt30eC0OSJEmSJEmSJGlONXEAqVQnsXwbRJIkSZIkSZIkzammDiCVi7E5loYkSZIkSZIk + SdKMa/IAUhmO3fFsSJIkSZIkSZIkzaimDyCV8ahOYm2I+0OSJEmSJEmSJGnK2jCA3PZ7fByPhSRJkiRJ + kiRJ0qS1aQCp3Igfw0ksSZIkSZIkSZI0aW0bQG47EW+FJEmSJEmSJEnSPbV1AKlcil0hSZIkSZIkSZJ0 + R20eQCojUT2QvigkSZIkSZIkSZL+qO0DyG3VA+kbQ5IkSZIkSZIkqZgBpDIU34YkSZIkSZIkSep4JQ0g + leqv5XgsC0mSJEmSJEmS1NFKG0BuuxybQpIkSZIkSZIkdbBSB5DKWDiJJUmSJEmSJElSByt5ALmtOom1 + JiRJkiRJkiRJUkfqwgBSuRJb48GQJEmSJEmSJEmF15UBpDIee6L6a5YkSZIkSZIkSQXXpQHktv/FhpAk + SZIkSZIkSYXWxQGkUp3E+iiWhCRJkiRJkiRJKqyuDiC37Q0PpEuSJEmSJEmSVFhdH0Aqx+LdkCRJkiRJ + kiRJhWQA+dO1+DIeCUmSJEmSJEmS1PIMIP+o/j78Ei+HJEmSJEmSJElqcQaQe52OD0KSJEmSJEmSJLU0 + A8jEhuLbWBqSJEmSJEmSJKllGUAmNxZHYl1IkiRJkiRJkqQWZQCZ3qXYHpIkSZIkSZIkqSUZQGZmNL6P + JSFJkiRJkiRJkhqeAWR2TsaqkCRJkiRJkiRJDc4AMnvVt0E2hSRJkiRJkiRJamgGkLnbG4tDkiRJkiRJ + kiQ1LAPI/Pweq0OSJEmSJEmSJDUoA0g93o2lIUmSJEmSJEmSGpABpD77wrdBJEmSJEmSJElqQAaQep2N + t+LhkCRJkiRJkiRJA8oAUr8b8UU8E5IkSZIkSZIkaQAZQHpjLA7G+pAkSZIkSZIkSX3OANJb52J7LAxJ + kiRJkiRJktSnDCC9NxTfxcqQJEmSJEmSJEl9yADSH6NxLF4LSZIkSZIkSZLU4wwg/XU5doQkSZIkSZIk + SephBpD+G46fY1FIkiRJkiRJkqQeZAAZjOrv+e/xXEiSJEmSJEmSpJozgAzWWDiJJUmSJEmSJElSzRlA + muFwSJIkSZIkSZKkmjKANMdQrAxJkiRJkiRJkjTPDCDNMh6fhyRJkiRJkiRJmkcGkGb6LVaEJEmSJEmS + JEmaQwaQ5roQm2JRSJIkSZIkSZKkWWQAabYb8XX4NogkSZIkSZIkSbPIANIOh+LVuD8kSZIkSZIkSdI0 + GUDa41x8GItDkiRJkiRJkiRNkQGkXa7H3ngmJEmSJEmSJEnSJBlA2ulovBGSJEmSJEmSJGmCDCDtdSG+ + DEmSJEmSJEmSdFcGkHYbiYOxNCRJkiRJkiRJ0l8ZQMpwOt4KSZIkSZIkSZKUDCDluBq7Q5IkSZIkSZKk + zmcAKctYHIknQ5IkSZIkSZKkzmYAKVP1QPo7IUmSJEmSJElSJzOAlOtmfB2SJEmSJEmSJHUuA0j5/hcr + Q5IkSZIkSZKkzmQA6YYr8W5IkiRJkiRJktSJDCDdsis8kC5JkiRJkiRJKj4DSPf8FutCkiRJkiRJkqRi + M4B0U3USa1s8EpIkSZIkSZIkFZcBpNt2x6qQJEmSJEmSJKmoDCAcibdCkiRJkiRJkqRiMoBQuRqfxpKQ + JEmSJEmSJKn1GUC4bSx+jJdDkiRJkiRJkqRWZwDhbqdia0iSJEmSJEmS1NoMIEzkWnwTj4UkSZIkSZIk + Sa3LAMJkRuNQvBKSJEmSJEmSJLUqAwhTGY8LsSUkSZIkSZIkSWpNBhBmYiR2x6KQJEmSJEmSJKnxGUCY + qerbICdiZUiSJEmSJEmS1OgMIMzWcLwRkiRJkiRJkiQ1NgMIc/VdSJIkSZIkSZLUyAwgzMfFeCwkSZIk + SZIkSWpUBhDq8HYsDEmSJEmSJEmSGpEBhLrsi2dCkiRJkiRJkqSBZwChTmfj9VgQkiRJkiRJkiQNLAMI + dbsen0b1syVJkiRJkiRJ0kAygNALo/FLvBKSJEmSJEmSJPU9Awi9dCa2hAfSJUmSJEmSJEl9zQBCr12N + 3fF0SJIkSZIkSZLUlwwg9EN1EutIrAtJkiRJkiRJknqeAYR+uhAfhCRJkiRJkiRJPc0AQr9dj/3xcEiS + JEmSJEmS1JMMIAxC9TN3Lp4NSZIkSZIkSZJqzwDCIA3H9pAkSZIkSZIkqdYMIAzaWBwKSZIkSZIkSZJq + ywBCU1yKZ0KSJEmSJEmSpHlnAKFJRuOzkCRJkiRJkiRpXhlAaKLqJNbjIUmSJEmSJEnSnDKA0FS/x5vx + YEiSJEmSJEmSNKsMIDTZjfgynghJkiRJkiRJkmacAYQ2OBgvhyRJkiRJkiRJM8oAQlucja2xMCRJkiRJ + kiRJmjIDCG1SncTaEytCkiRJkiRJkqRJM4DQRodjQ0iSJEmSJEmSNGEGENrqfHwRkiRJkiRJkiTdkwGE + NhuJH+OJkCRJkiRJkiTp7wwglOB4vB2SJEmSJEmSJP2RAYRSXI5dIUmSJEmSJEmSAYSiVCexfo0VIUmS + JEmSJEnqcAYQSjMeZ2NTSJIkSZIkSZI6mgGEUg3HlyFJkiRJkiRJ6mAGEEpXncR6MiRJkiRJkiRJHcoA + QhdciY0hSZIkSZIkSepIBhC65ItYGpIkSZIkSZKkwjOA0DWH4/mQJEmSJEmSJBWcAYQuuhbvxMMhSZIk + SZIkSSowAwhd9mU8E5IkSZIkSZKkwjKA0HW/xYaQJEmSJEmSJBWUAQTuu+9q7IhHQ5IkSZIkSZJUQAYQ + +NNo7I0XQ5IkSZIkSZLU8gwg8I/xOBHvhSRJkiRJkiSpxRlA4F5X4qt4PCRJkiRJkiRJLcwAAhO7GQfj + pZAkSZIkSZIktSwDCEyu+rNxPpzEkiRJkiRJkqSWZQCB6Q3H1/FISJIkSZIkSZJakAEEZmYsjkf1Z0aS + JEmSJEmS1PAMIDA7N+L1kCRJkiRJkiQ1OAMIzM3ukCRJkiRJkiQ1NAMIzN3FkCRJkiRJkiQ1MAMIzM94 + vBmSJEmSJEmSpAZlAIF67IsnQpIkSZIkSZLUgAwgUJ8zsS4eDkmSJEmSJEnSADOAQL2G4uN4MiRJkiRJ + kiRJA8oAAvUbjf3xQkiSJEmSJEmSBpABBHrnVGyOR0KSJEmSJEmS1McMINBbV2JXPBWSJEmSJEmSpD5l + AIHeG4nD8VJIkiRJkiRJkvqQAQT651xsC0mSJEmSJElSjzOAQH9dix9DkiRJkiRJktTDDCDQf9WfudOx + MiRJkiRJkiRJPcgAAoNzNT4MSZIkSZIkSVLNGUBgsG7GgZAkSZIkSZIk1ZgBBJrhfDwXkiRJkiRJkqQa + MoBAc9yIj0KSJEmSJEmSNM8MINA8B2NhSJIkSZIkSZLmmAEEmulcrA9JkiRJkiRJ0hwygEBzVSexPo+l + IUmSJEmSJEmaRQYQaL6f4/mQJEmSJEmSJM0wAwi0w5l4Lx4KSZIkSZIkSdI0GUCgPaqTWLtieUiSJEmS + JEmSpsgAAu1zIDyQLkmSJEmSJElTZACBdjofH4UkSZIkSZIkaYIMINBeN+O7eCokSZIkSZIkSf/KAALt + 9794KyRJkiRJkiRJf2UAgTJcjC9CkiRJkiRJkpQMIFCO6iTWz/F0SJIkSZIkSVKnM4BAWcbjdLwdkiRJ + kiRJktTZDCBQpuvhJJYkSZIkSZKkzmYAgbIdiCdDkiRJkiRJkjqVAQTKVz2Qvi4kSZIkSZIkqTMZQKA7 + Po7/hCRJkiRJkiQVnwEEuuVQPB2SJEmSJEmSVHQGEOie6oH01+P+kCRJkiRJkqQiM4BAd30aK0KSJEmS + JEmSissAAt32W3ggXZIkSZIkSVJxGUCAK7E1HgtJkiRJkiRJKiIDCFAZje/i+ZAkSZIkSZKk1mcAAW4b + j2OxKSRJkiRJkiSp1RlAgLtdjs9jWUiSJEmSJElSKzOAABMZjp/DSSxJkiRJkiRJrcwAAkym+mw4G++E + JEmSJEmSJLUqAwgwnaH4KhaEJEmSJEmSJLUiAwgwE6NxNJaHJEmSJEmSJDU+AwgwG9fi9ZAkSZIkSZKk + RmcAAWZrPPaEJEmSJEmSJDU2AwgwV9UD6ZIkSZIkSZLUyAwgwHxUnx9vhCRJkiRJkiQ1KgMIUIe98UhI + kiRJkiRJUiMygAB1OR0vxAMhSZIkSZIkSQPNAALU6Vp8GMtCkiRJkiRJkgaWAQSo22j8GKtDkiRJkiRJ + kgaSAQTolRPxdiwISZIkSZIkSeprBhCgly7Hl/FESJIkSZIkSVLfMoAAvTYSB6J6IF2SJEmSJEmS+pIB + BOiX07E1JEmSJEmSJKnnGUCAfroae0OSJEmSJEmSepoBBOi36jPnWKwKSZIkSZIkSepJBhBgUC7EjpAk + SZIkSZKk2jOAAIM0HPtDkiRJkiRJkmrNAAIM2nhUD6SvDUmSJEmSJEmqJQMI0BTXwkksSZIkSZIkSbVk + AAGapPo2yE8hSZIkSZIkSfPKAAI00dl4JSRJkiRJkiRpThlAgKaqHkj/OBaEJEmSJEmSJM0qAwjQdD/E + cyFJkiRJkiRJM84AArTB6Xg77g9JkiRJkiRJmjYDCNAWN+OzeCIkSZIkSZIkacoMIEDb7I91IUmSJEmS + JEmTZgAB2uhcbA1JkiRJkiRJmjADCNBWw/FNVJ9jkiRJkiRJknRHBhCg7Q7HxpAkSZIkSZKkvzOAACX4 + PT4NSZIkSZIkSfojAwhQiuok1o/xTEiSJEmSJEnqeAYQoCTV59mJeDMkSZIkSZIkdTgDCFCia+EkliRJ + kiRJktThDCBAqarPtv3xZEiSJEmSJEnqWAYQoHQX4qWQJEmSJEmS1KEMIEBXbA9JkiRJkiRJHckAAnTJ + 4VgUkiRJkiRJkgrPAAJ0zY14PiRJkiRJkiQVnAEE6KqP4vGQJEmSJEmSVGAGEKDLfgvfBpEkSZIkSZIK + zAACdN3l2BxLQ5IkSZIkSVIhGUAA7rtvJHbH6pAkSZIkSZJUQAYQgD9Vn4X/i40hSZIkSZIkqeUZQADu + dDE+iWUhSZIkSZIkqaUZQADudSN+ijUhSZIkSZIkqYUZQAAmVn02noq3QpIkSZIkSVLLMoAATO1KfBkP + hiRJkiRJkqSWZAABmN7NOBKPhyRJkiRJkqQWZAABmLnL8XpIkiRJkiRJangGEIDZGY3dIUmSJEmSJKnB + GUAA5qZ6IF2SJEmSJElSQzOAAMzdcKwPSZIkSZIkSQ3LAAIwf9+HJEmSJEmSpAZlAAGox8lYHZIkSZIk + SZIakAEEoD5XYmssCUmSJEmSJEkDzAACUK/R2BsrQ5IkSZIkSdKAMoAA9MbR2BgPhSRJkiRJkqQ+ZwAB + 6J1L8Xk8FpIkSZIkSZL6mAEEoLeqk1g/xdqQJEmSJEmS1KcMIAD9cSK2hCRJkiRJkqQ+ZAAB6J+r8W1I + kiRJkiRJ6nEGEID+qj5zD8eakCRJkiRJktSjDCAAg3EutockSZIkSZKkHmQAARic67EvJEmSJEmSJNWc + AQRgsKrP4OPxfEiSJEmSJEmqKQMIQDNcjg9DkiRJkiRJUg0ZQACaYyycxJIkSZIkSZJqyAAC0DwnY21I + kiRJkiRJmmMGEIBmuhnbQ5IkSZIkSdIcMoAANNv3UX1WS5IkSZIkSZpFBhCA5jsdr4ckSZIkSZKkGWYA + AWiHkdgRj4UkSZIkSZKkaTKAALTLvnghJEmSJEmSJE2RAQSgfc7E5pAkSZIkSZI0SQYQgHYaji9jRUiS + JEmSJEm6KwMIQHuNx8HYEJIkSZIkSZL+lQEEoP3OR/VAuiRJkiRJkqS/MoAAlOFGfB/PhCRJkiRJktT5 + DCAA5RiLY+EkliRJkiRJkjqfAQSgPFfio5AkSZIkSZI6mwEEoEwj8VM8EZIkSZIkSVLnMoAAlGs8qgfS + XwhJkiRJkiSpUy0PAwhA2aq3QbaFJEm1tygejaUAAAANsjDWhQEEoBsOhyRJtXYiJvqXDgAAAAD0082o + zh9KklRL/4uJ/oUDAAAAAIOwI6pvAkqSNK8MIAAAAAA0TXUS69mQJGnOGUAAAAAAaKJL8XYsDkmSZp0B + BAAAAICmqt4F2RW+DSJJmnUGEAAAAACa7FYciddDkqQZZwABAAAAoA1+j+qB9MdCkqRpM4AAAAAA0BbX + 44dYFZIkTZkBBAAAAIA2qU5iHY+NIUnSpBlAAAAAAGijS7EzJEmaMAMIAAAAAG01HIfj0ZAk6Y4MIAAA + AAC03cV4PSRJ+jsDCAAAAAAluBG7QpKkPzKAAAAAAFCK2w+k3x+SpI5nAAEAAACgNNdifUiSOpwBBAAA + AIASjcWekCR1NAMIAAAAACU7Ec+EJKljGUAAAAAAKN3leC8eCklSRzKAAAAAANAF1Umsb2NFSJI6kAEE + AAAAgC75LV6P/4QkqeAMIAAAAAB0zcX4OJaGJKnQDCAAAAAAdFF1EmtvrA5JUoEZQAAAAADosqOxOSRJ + hWUAAQAAAKDrrsSukCQVlAEEAAAAAO6771b8EmtCklRABhAAAAAA+Mep2BaSpJZnAAEAAACAO12L7+L+ + kCS1NAMIAAAAANxrLI7EiyFJamEGEAAAAACY3IVwEkuSWpgBBAAAAACmNhLVSawFIUlqSQYQAAAAAJiZ + Y7E6JEktyAACAAAAADM3HJtDktTwDCAAAAAAMHvfxuMhSWpoBhAAAAAAmJsz8WJIkhqYAQQAAAAA5m40 + tsTikCQ1KAMIAAAAAMzfd+GBdElqUAYQAAAAAKjH6XgrJEkNyAACAAAAAPW5EZ/FipAkDTADCAAAAADU + azx+jtdCkjSgDCAAAAAA0BtnY3v8X0iS+pwBBAAAAAB6Zyj2xDMhSepjBhAAAAAA6K3RqH4Ptz4kSX3K + AAIAAAAA/XEpPgxJUh8ygAAAAABA/wzHj7EsJEk9zAACAAAAAP11K87FmpAk9SgDCAAAAAAMxkhsC0lS + DzKAAAAAAMBgHQpJUs0ZQAAAAABg8K7H4yFJqikDCAAAAAA0xwchSaohAwgAAAAANEt1Emt5SJLmkQEE + AAAAAJrnYrwRC0OSNIcMIAAAAADQTMPxZfw3JEmzzAACAAAAAM01HtVJrFdCkjSLDCAAAAAA0HznYnss + DUnSDDKAAAAAAEA7DMX3sTIkSdNkAAEAAACA9rgV1e/0NoQkaYoMIAAAAADQPr/H5yFJmiQDCAAAAAC0 + 03AcjCUhSborAwgAAAAAtFv1QPqrIUn6VwYQAAAAAGi/q/FVSJL+ygACAAAAAGUYjer3fQ+HJHU+AwgA + AAAAlOVivBGS1OkMIAAAAABQnpuxKySpsxlAAAAAAKBc1e//lockdS4DCAAAAACU7XK8E5LUqQwgAAAA + AFC+sfg6Hg9J6kQGEAAAAADojkOxLiSp+AwgAAAAANAtl2J7LApJKjYDCAAAAAB0z63YE6tCkorMAAIA + AAAA3XUk3g5JKi4DCAAAAAB025X4NCSpqAwgAAAAAEB1EuvHWBOSVEQGEAAAAADgthOxJSSp9RlAAAAA + AIB/uxq74+GQpNZmAAEAAAAA7jYah+KlkKRWZgABAAAAACYyHufDSSxJrcwAAgAAAABM5WZUJ7EeCUlq + TQYQAAAAAGA61bdBjsZzIUmtyAACAAAAAMzUUGwMSWp8BhAAAAAAYLa+iQdDkhqbAQQAAAAAmIuzsTIk + qZEZQAAAAACAuboVb8fDIUmNygACAAAAAMxXdRLrmZCkxmQAAQAAAADqcDrWhyQ1IgMIAAAAAFCXG/FR + LA9JGmgGEAAAAACgTmPxU7wSkjSwDCAAAAAAQC+ciffioZCkvmcAAQAAAAB65Wp8HR5Il9T3DCAAAAAA + QC+NxG+xLiSpbxlAAAAAAIB++D22hyT1JQMIAAAAANAv12NfPBqS1NMMIAAAAABAP41F9UD6qpCknmUA + AQAAAAAG4UZsDUnqSQYQAAAAAGBQxuOXkKTaM4AAAAAAAIN2JRaFJNWWAQQAAAAAaIrtIUm1ZAABAAAA + AJrkUCwJSZpXBhAAAAAAoGkuxPp4KCRpThlAAAAAAIAmuhFfxBMhSbPOAAIAAAAANNV4HIwXQ5JmlQEE + AAAAAGi6M7ElFockzSgDCAAAAADQBkOxJ/4bkjRtBhAAAAAAoC2qk1iHo3ogXZKmzAACAAAAALTNufg0 + JGnSDCAAAAAAQBvdiJ9jYUjSPRlAAAAAAIA2OxmvhSTdkQEEAAAAAGi7S/FlSNLfGUAAAAAAgBKMxKFY + HJJkAAEAAAAAilI9kL4xJHU8AwgAAAAAUJrr4SSW1PEMIAAAAABAqX6Nx0JSBzOAAAAAAAAlqx5IfzMk + dSwDCAAAAABQuluxM5aEpI5kAAEAAAAAuqI6ifVCSOpABhAAAAAAoEuqk1ib4+GQVHAGEAAAAACga8Zj + VzwdkgrNAAIAAAAAdNWheD0kFZgBBAAAAADossuxIx4MSQVlAAEAAAAAuu5WfBdrQlIhGUAAAAAAAP50 + NKoH0iUVkAEEAAAAAOAfV+LLWBSSWpwBBAAAAADgTiNxIF4KSS3NAAIAAAAAcK/qXZCz8V5IamEGEAAA + AACAyd2Ir8NJLKllGUAAAAAAAKZWfRvkSDwbklqSAQQAAAAAYGauxYaQ1IIMIAAAAAAAs/NlSGp4BhAA + AAAAgNk7E94FkRqcAQQAAAAAYO5eDUkNzAACAAAAADA/38QTIalBGUAAAAAAAObvdLwc94ekBmQAAQAA + AACox/X4IHwbRGpABhAAAAAAgPqMxQ/xQkgaYAYQAAAAAID6nYp34uGQNIAMIAAAAAAAvXElvooVIanP + GUAAAAAAAHpnJH6N6oF0SX3MAAIAAAAA0HvnYktI6lMGEAAAAACA/rgW38fikNTjDCAAAAAAAP0zGidj + ZUjqYQYQAAAAAID+GwonsaQeZgABAAAAABiM6tsg+0NSDzKAAAAAAAAM1sV4LCTVmAEEAAAAAGDwbsbW + kFRTBhAAAAAAgOY4GJJqyAACAAAAANAs5+OVkDSPDCAAAAAAAM1zPT6LpSFpDhlAAAAAAACaaTx+jjUh + aZYZQAAAAAAAmu1UbI5HQtIMM4AAAAAAADTfUOyK5SFpBhlAAAAAAADa42CsC0nTZAABAAAAAGiXM/FR + SJoiAwgAAAAAQPvciB9iYUiaIAMIAAAAAEB7Vb/jfS0k3ZUBBAAAAACg3X6PL0LSvzKAAAAAAAC03834 + JZaFpGQAAQAAAAAow3icijdD6nwGEAAAAACAslwLJ7HU+QwgAAAAAADlqb4NciAeD6mTGUAAAAAAAMp1 + Pl4NqXMZQAAAAAAAylZ9G+TTeCCkzmQAAQAAAADohuok1qqQOpEBBAAAAACgOy7Fm+HbICo+AwgAAAAA + QPd8HstDKjYDCAAAAABANx2MV0IqMgMIAAAAAEB3XY6t8UhIRWUAAQAAAADotrHYHatDKiYDCAAAAAAA + ler3xZtCKiIDCAAAAAAAt12Kz2JpSK3OAAIAAAAAwL8Nx/54IaTWZgABAAAAAOBut+J0vBNSKzOAAAAA + AAAwmaH4KhaF1KoMIAAAAAAATGU0DsczIbUmAwgAAAAAANMZjyuxPqRWZAABAAAAAGA2dobU+AwgAAAA + AADMVvVAutToDCAAAAAAAMzVCyE1MgMIAAAAAADz8U0sDKlRGUAAAAAAAJivU7Em7g+pERlAAAAAAACo + w1Bsi2UhDTwDCAAAAAAAdRmNfbE6pIFmAAEAAAAAoG7H461YENJAMoAAAAAAANALl+KLWB5S3zOAAAAA + AADQKzfjl3ghpL5mAAEAAAAAoNdOx3sh9S0DCAAAAAAA/XAlvo2HQup5BhAAAAAAAPplNKoH0p8JqacZ + QAAAAAAA6LfL8X5IPcsAAgAAAADAIAzHTyH1JAMIAAAAAACDMh5nY0VItWYAAQAAAABg0IZie0i1ZQAB + AAAAAKAJboWTWKotAwgAAAAAAE1yLl4MaV4ZQAAAAAAAaJrr8XE8HNKcMoAAAAAAANBUP8azIc06AwgA + AAAAAE12Mt6Oh0KacQYQAAAAAACabii+iCdCmlEGEAAAAAAA2mJ/vBzStBlAAAAAAABok9PxQUhTZgAB + AAAAAKBthmN3PBrShBlAAAAAAABoq0OxPqR7MoAAAAAAANBm5+KTkO7IAAIAAAAAQNvdiB/iyZD+yAAC + AAAAAEAJbsXx2BiSAQQAAAAAgKJciU9DHc8AAgAAAABAacZifziJ1eEMIAAAAAAAlOpsrAt1MAMIAAAA + AAAlq74Nsj3UsQwgAAAAAAB0wS/hJFaHMoAAAAAAANAVl8NJrI5kAAEAAAAAoGs+jMdCBWcAAQAAAACg + i6qTWM+HCs0AAgAAAABAV1Unsd6JRaHCMoAAAAAAANBlo7ErngsVlAEEAAAAAICuG4/fYmOokAwgAAAA + AADwpwvxcTwaankGEAAAAAAA+MeN+CHWhlqcAQQAAAAAAO40FifjrVBLM4AAAAAAAMDErsbnsSDUsgwg + AAAAAAAwuZvxa6wItSgDCAAAAAAATG08LseroZZkAAEAAAAAgJmp3gbZGWpBBhAAAAAAAJidU6GGZwAB + AAAAAIDZG401oYZmAAEAAAAAgLnbHWpgBhAAAAAAAJifE/FMqEEZQAAAAAAAYP6uxnuxJNSADCAAAAAA + AFCPkfguVoYGnAEEAAAAAADqdTQ2xEOhAWUAAQAAAACA+l2MT+Px0AAygAAAAAAAQG/cjJ9iTajPGUAA + AAAAAKC3TsS7oT5mAAEAAAAAgN67FLtDfcoAAgAAAAAA/TEaR+LpUI8zgAAAAAAAQH+dj82hHmYAAQAA + AACA/huKvaEeZQABAAAAAIDBGIvjsTJUcwYQAAAAAAAYrMuxLVRjBhAAAAAAABi86oF0J7FqzAACAAAA + AADNcSrWhOaZAQQAAAAAAJrlenwQmkcGEAAAAAAAaKbqJNaK0BwygAAAAAAAQHMdjw2hWWYAAQAAAACA + ZqtOYn0cj4ZmmAEEAAAAAADaoTqJ9WJoBhlAAAAAAACgPU7Fe6FpMoAAAAAAAEC7DMfOeDw0SQYQAAAA + AABop1/itdAEGUAAAAAAAKC9zsaO0F0ZQAAAAAAAoN2ux/fxVOivDCAAAAAAANB+Y1H9zn9DKBlAAAAA + AACgHJfio+h8BhAAAAAAACjLaPwQj0dnM4AAAAAAAEB5xuNMvBydzAACAAAAAADlqr4NsiU6lwEEAAAA + AADKtz8eiM5kAAEAAAAAgG64FquiExlAAAAAAACgW96PRVF0BhAAAAAAAOieA7Eyis0AAgAAAAAA3XQx + 3oyFUVwGEAAAAAAA6K6R2BnFfRvEAAIAAAAAAN02HodjXRSTAQQAAAAAADgT70YxGUAAAAAAAKC7xuLn + eDWKygACAAAAAADdNBSfx5NRXAYQAAAAAADonhOxKYrNAAIAAAAAAN2yO9ZG0RlAAAAAAACgG27E1lgY + xWcAAQAAAACA8h2N4h46nyoDCAAAAAAAlO3rWB6dygACAAAAAABluh6bo5MZQAAAAAAAoDzVyauV0dkM + IAAAAAAAUI7R2B2dzwACAAAAAABluBCdPXl1dwYQAAAAAABot7Goft+/KvRXBhAAAAAAAGiva7EndFcG + EAAAAAAAaKfT8V5oggwgAAAAAADQLtVD5wfi6dAkGUAAAAAAAKA9LsWu0DQZQAAAAAAAoB2OxqbQDDKA + AAAAAABAs92MH2JlaIYZQAAAAAAAoLnOx8exODSLDCAAAAAAANBMh2N9aA4ZQAAAAAAAoFmqk1e747+h + OWYAAQAAAACA5rgYm2NRaB4ZQAAAAAAAoBmq39k/G6ohAwgAAAAAAAzWrfg6VGMGEAAAAAAAGJyheClU + cwYQAAAAAADov/E4GupRBhAAAAAAAOiv0fgk1MMMIAAAAAAA0B/Vtz4uxdpQjzOAAAAAAABA7w3Hr/FQ + qA8ZQAAAAAAAoLcuh5NXfc4AAgAAAAAAvTEWJ2J9qM8ZQAAAAAAAoH5DsTdWhgaQAQQAAAAAAOr1e3wY + S0IDygACAAAAAAD1qE5eHY7XQwPOAAIAAAAAAPN3I76KZ0MNyAACAAAAAADzU5282hSLQg3JAAIAAAAA + AHN3INaEGpYBBAAAAAAA5mZbLAs1MAMIAAAAAADMztXw1kfDM4AAAAAAAMDM7Y8HQw3PAAIAAAAAANMb + j3dCLckAAgAAAAAAUzsXq0ItygACAAAAAAATuxV7Y3GoZRlAAAAAAADgTtW5qyuxPdTSDCAAAAAAAPCP + sTgar4ZanAEEAAAAAAD+dD2+j+WhlmcAAQAAAACAPx863xEqJAMIAAAAAABdVj10fjDWhwrKAAIAAAAA + QFcNxVfxRKiwDCAAAAAAAHTRiXg/VGgGEAAAAAAAumZvPB8qOAMIAAAAAABdcT0+jiWhwjOAAAAAAADQ + BcfijVBHMoAAAAAAAFC6b+OZUIcygAAAAAAAUKqh2BYPhzqWAQQAAAAAgBKdCA+ddzgDCAAAAAAAJbkV + 34U6ngEEAAAAAIBSXI4tIRlAAAAAAABovepbH8fDQ+f6OwMIAAAAAABtdj32hnRHBhAAAAAAANrqfGwO + 6Z4MIAAAAAAAtM1YHImnQpowAwgAAAAAAG1SPXS+J6QpM4AAAAAAANAWJ+OdkKbNAAIAAAAAQNPdjJ9j + VUgzygACAAAAAECTXYjPYmlIM84AAgAAAABAU1W/w94YD4Q0qwwgAAAAAAA0TXXy6rt4NqQ5ZQABAAAA + AKBJLsXWeDSkOWcAAQAAAACgKY7F2rg/pHllAAEAAAAAYNDG45tYGFItGUAAAAAAABik6r2PdSHVmgEE + AAAAAIBBORFSTzKAAAAAAAAwCJ+G1LMMIAAAAAAA9Ev11sfVqB46l3qaAQQAAAAAgH4YiUOxKKSeZwAB + AAAAAKDXrsVnIfUtAwgAAAAAAL0yFqdjQ0h9zQACAAAAAEAv3IgfY1VIfc8AAgAAAABA3S7EJ7EkpIFk + AAEAAAAAoC634khsDGmgGUAAAAAAAKjDcHwTz4U08AwgAAAAAADMV3Xy6v1YHFIjMoAAAAAAADAfB+Ll + kBqVAQQAAAAAgLn6IJaH1LgMIAAAAAAAzNaV8K0PNToDCAAAAAAAs7E/fOtDjc8AAgAAAADATG0LqRUZ + QAAAAAAAmM75WBtSazKAAAAAAAAwmfH4IZaG1KoMIAAAAAAATORa7AiplRlAAAAAAAD4t1txPNaH1NoM + IAAAAAAA3DYc1cmrJ0JqdQYQAAAAAAAq1UPnn4RURAYQAAAAAIBuq05eHQ4nr1RUBhAAAAAAgO66Hnvi + sZCKygACAAAAANBNp2JbSEVmAAEAAAAA6J798VJIxWYAAQAAAADojqH4Ih4NqegMIAAAAAAA3XA8NoXU + iQwgAAAAAABlG4+98VxInckAAgAAAABQrmuxIxaH1KkMIAAAAAAAZToVr4TUyQwgAAAAAADl+TEWhNTZ + DCAAAAAAAOUYii0hdT4DCAAAAABAGU7HUyEpGUAAAAAAANptOKqTV5L+lQEEAAAAAKC9Lse7IemuDCAA + AAAAAO0zGifjsZA0QQYQAAAAAIB2uRrfhaQpMoAAAAAAALTHmXDySppBBhAAAAAAgOa7GQdjdUiaQQYQ + AAAAAIBmuxQ7Y1lImmEGEAAAAACAZhqPY/F2PBSSZpEBBAAAAACgeaqTV/vCyStpjhlAAAAAAACa5XJs + j8dD0hwzgAAAAAAANMfxeCn+E5LmkQEEAAAAAKAZdodvfUg1ZQABAAAAABiskXgt7g9JNWUAAQAAAAAY + nNMhqQcZQAAAAAAABuOzkNSjDCAAAAAAAP01FM+HpB5mAAEAAAAA6I+xOByPhqQeZwABAAAAAOi96/FF + /F9I6kMGEAAAAACA3rkVZ+PNkNTHDCAAAAAAAL0xHPtjdUjqcwYQAAAAAID6XYrPYnFIGkAGEAAAAACA + +lQnr6rfu24KSQPMAAIAAAAAUI+b8W2sCUkDzgACAAAAADB/F2J7LAxJDcgAAgAAAAAwPwfitZDUoAwg + AAAAAABz93GsCEkNywACAAAAADB7l+LNkNTQDCAAAAAAALOzP54LSQ3OAAIAAAAAMDO34qNYFJIangEE + AAAAAGB6F8JD51KLMoAAAAAAAEytOnm1NCS1KAMIAAAAAMDErscnIamFGUAAAAAAAO40Hqfi9ZDU0gwg + AAAAAAD/uBnVyavHQlKLM4AAAAAAAPypeuj885BUQAYQAAAAAKDrqpNXR+O1kFRIBhAAAAAAoMuqh873 + xeKQVFAGEAAAAACgq87GhyGpwAwgAAAAAEAXHYxXQlKhGUAAAAAAgC65Fl/HspBUcAYQAAAAAKArTsZ7 + 8UBIKjwDCAAAAABQulvxUzwfkjqSAQQAAAAAKFl18urTeCwkdSgDCAAAAABQqtOxPh4MSR3LAAIAAAAA + lOjneDQkdTQDCAAAAABQkpvxQUjqeAYQAAAAAKAU52NZSJIBBAAAAABovdH4KSTp7wwgAAAAAECbXY9N + IUl3ZAABAAAAANpoLM7EYyFJ92QAAQAAAADaZii+D0maNAMIAAAAANAm1UPn74UkTZkBBAAAAABog5tx + KJ4PSZo2AwgAAAAA0HSX46t4IiRpRhlAAAAAAIAmOxnvxkMhSTPOAAIAAAAANNFI/BgvhiTNOgMIAAAA + ANA0V2JHPBmSNKcMIAAAAABAk5yI1+L+kKQ5ZwABAAAAAJpid/w3JGneGUAAAAAAgEGr3vt4Ix4JSaol + AwgAAAAAMEinY2lIUq0ZQAAAAACAQdkZktSTDCAAAAAAQL9djxdDknqWAQQAAAAA6JfxqH4n+URIUk8z + gAAAAAAA/TAcX8YDIUk9zwACAAAAAPTSrTgfb4ck9S0DCAAAAADQKyNxINaEJPU1AwgAAAAA0AtXYmcs + DEnqewYQAAAAAKBO1UPnx2JzSNLAMoAAAAAAAHWpTl7tDSevJA08AwgAAAAAUIeL8XE8HJI08AwgAAAA + AMB8HYw3QpIakwEEAAAAAJir6r2Pr+K/IUmNygACAAAAAMxFdfLqvfi/kKTGZQABAAAAAGbrQLwYktTY + DCAAAAAAwEyNxWexLCSp0RlAAAAAAICZqE5evRmS1IoMIAAAAADAdA7G8pCk1mQAAQAAAAAmMxyfhyS1 + LgMIAAAAADCRs7E+JKmVGUAAAAAAgH8bjerk1eKQpNZmAAEAAAAAbrscO0OSWp8BBAAAAAAYj5PxakhS + ERlAAAAAAKDbbsT+eDgkqZgMIAAAAADQXefj05Ck4jKAAAAAAED3VCevfgsnryQVmwEEAAAAALrlWnwb + T4YkFZsBBAAAAAC641RsjQUhSUVnAAEAAACA8t2KX+KlkKROZAABAAAAgLINxRexPCSpMxlAAAAAAKBc + Z+KNeCQkqVMZQAAAAACgPONRnbx6KiSpkxlAAAAAAKAso/FhSFKnM4AAAAAAQDkuhbc+JCkZQAAAAACg + DPtDkvRXBhAAAAAAaLfq5NVbIUn6VwYQAAAAAGinW3EunghJ0l0ZQAAAAACgfW7EvpAkTZIBBAAAAADa + 5WJsCUnSFBlAAAAAAKAdRuJIvBiSpGkygAAAAABA812Nb2J5SJJmkAEEAAAAAJrtTLwfD4QkaYYZQAAA + AACgmaqTV/vjlZAkzTIDCAAAAAA0z7X4JJ4KSdIcMoAAAAAAQLOcjI0hSZpHBhAAAAAAaI49sSokSfPM + AAIAAAAAg1e99/F2LAlJUg0ZQAAAAABgsE7H0yFJqjEDCAAAAAAMzq54JCRJNWcAAQAAAID+G471IUnq + UQYQAAAAAOivo/FUSJJ6mAEEAAAAAPpjNL6K/4QkqccZQAAAAACgt8bjQrwbkqQ+ZQABAAAAgN6pvvXx + a6wNSVIfM4AAAAAAQG9cja/j4ZAk9TkDCAAAAADU70S8H5KkAWUAAQAAAID6VCevforVIUkaYAYQAAAA + AKjHxfg8/hOSpAFnAAEAAACA+fst3gpJUkMygAAAAADA3I3FnngmJEkNygACAAAAAHNzIbbHgyFJalgG + EAAAAACYvYPxakiSGpoBBAAAAABmbjS+iuUhSWpwBhAAAAAAmJnq5NU78UBIkhqeAQQAAAAApnc4PHQu + SS3KAAIAAAAAkxuJL0OS1LIMIAAAAAAwserk1fqQJLUwAwgAAAAA3GksqpNXC0KS1NIMIAAAAADwj2vh + 5JUkFZABBAAAAAD+dDbWhSSpgAwgAAAAAHTdcBwMSVJBGUAAAAAA6LKL8XlIkgrLAAIAAABAF43H0Vgf + kqQCM4AAAAAA0DVDsTeeCklSoRlAAAAAAOiS6qHzD2JhSJIKzgACAAAAQBfcil9jXUiSOpABBAAAAIDS + VSevvor/hiSpIxlAAAAAACjZuXgrFockqUMZQAAAAAAo1YF4NiRJHcwAAgAAAEBpqvc+doSHziWpwxlA + AAAAACjJlVgZkqSOZwABAAAAoBS/hCRJf2QAAQAAAKAEm0KSpL8zgAAAAADQVuNxPp4MSZLuyAACAAAA + QBuNxA9xf0iSdE8GEAAAAADa5nJsC0mSJs0AAgAAAEBbVN/6OBqvhCRJU2YAAQAAAKANhmJPPBWSJE2b + AQQAAACAJqseOj8XTl5JkmaVAQQAAACAphqNX+K1kCRpVhlAAAAAAGii6uTVF+HklSRpThlAAAAAAGia + U7EpJEmacwYQAAAAAJrku1gbkiTNq+Mx0b9oAAAAAKCfRmJzPBqSJM27l+PteAsAAKBB3owdMR4T/ZIM + gLJUJ69eDEmSJEmSJKn4/hu3YqJflAFQjm/iyZAkSZIkSZI60YowgACU62Z46FySJEmSJEmdyzdAAMp1 + LFaGJEmSJEmS1LkMIADlqT7Xvw5JkiRJkiSpsxlAAMpyMd4LSZIkSZIkqdMZQADKMBa/xZqQJEmSJEmS + Op8BBKD9hmJP/CckSZIkSZIkJQMIQLudjq0hSZIkSZIk6V8ZQADaaTQOxOqQJEmSJEmSdFcGEID2uRRf + hSRJkiRJkqRJMoAAtMux2BSSJEmSJEmSpsgAAtAO1cmrffFcSJIkSZIkSZomAwhA812Mj2NBSJIkSZIk + SZpBBhCAZjscG0KSJEmSJEnSLDKAADTTSOyOp0OSJEmSJEnSLDOAADRPdfLq/VgYkiRJkiRJkuaQAQSg + WY6Eh84lSZIkSZKkeWYAAWiGsfgmJEmSJEmSJNWQAQRg8K7G+pAkSZIkSZJUUwYQgMGpPn//F5IkSZIk + SZJqzgACMBg34quQJEmSJEmS1IMMIAD9dzFeCUmSJEmSJEk9ygAC0D8340hIkiRJkiRJ6nEGEID+uBxf + hCRJkiRJkqQ+ZAAB6K3qM/ZkvB6SJEmSJEmS+pQBBKB3huLHeDokSZIkSZIk9TEDCEBvnI8dsTgkSZIk + SZIk9TkDCEC9xuK3cPJKkiRJkiRJGmAGEID6XI+v49mQJEmSJEmSNMAMIAD1+D3ejSUhSZIkSZIkacAZ + QADm79dYG5IkSZIkSZIakgEEYO6qz8+PY1lIkiRJkiRJalAGEIC5uRJr4v9CkiRJkiRJUsMygADM3sGQ + JEmSJEmS1OAMIACzUz10LkmSJEmSJKnhGUAAZuZCrAhJkiRJkiRJLcgAAjC1sfghFoQkSZIkSZKklmQA + AZjctdgekiRJkiRJklqWAQTgXqNxPF4NSZIkSZIkSS3MAAJwp+vxfXjvQ5IkSZIkSWpxBhCAf5yPD0OS + JEmSJElSyzOAAPz50PnBeD0kSZIkSZIkFZABBOi6odgVTl5JkiRJkiRJBWUAAbrsVLwfkiRJkiRJkgrL + AAJ01d54KSRJkiRJkiQVmAEE6Jqb8UE8GpIkSZIkSZIKzQACdEl18spD55IkSZIkSVIHMoAAXbEnVoYk + SZIkSZKkDmQAAUo3HFvi4ZAkSZIkSZLUkQwgQMlOxgshSZIkSZIkqWMZQIBSVSevJEmSJEmSJHU0AwhQ + mstRnbySJEmSJEmS1OEMIEApxuNYrA5JkiRJkiRJHc8AApTgenwfkiRJkiRJkvRHBhCg7c7F9pAkSZIk + SZKkvzOAAG01GofDyStJkiRJkiRJ92QAAdroSuwOSZIkSZIkSZowAwjQNifjvZAkSZIkSZKkSTOAAG0x + FvvjuZAkSZIkSZKkKTOAAG1wMb6IRSFJkiRJkiRJ02YAAZruSLwZkiRJkiRJkjTjDCBAU43E9/FsSJIk + SZIkSdKsMoAATVSdvNoWS0OSJEmSJEmSZp0BBGiao/FC3B+SJEmSJEmSNKcMIEBTjMWe8NC5JEmSJEmS + pHlnAAGa4EZ46FySJEmSJElSbRlAgEE7HpIkSZIkSZJUawYQYFBGY1dIkiRJkiRJUu0ZQIBBuBbVQ+eS + JEmSJEmS1JMMIEA/jcTRkCRJkiRJkqSeZgAB+qX61sfOkCRJkiRJkqSeZwABeq36jDkTG0KSJEmSJEmS + +pIBBOil67E/VoYkSZIkSZIk9S0DCNArF+KTWBKSJEmSJEmS1NcMIEDdqs+U/8XGkCRJkiRJkqSBZAAB + 6nQj9sTqkCRJkiRJkqSBZQAB6lKdvNoSS0OSJEmSJEmSBpoBBKjDoXg5JEmSJEmSJKkRGUCA+RiPT+Op + kCRJkiRJkqTGZAAB5upqvBQPhiRJkiRJkiQ1KgMIMBfVyauFIUmSJEmSJEmNzAACzNbWkCRJkiRJkqRG + ZwABZupSPB2SJEmSJEmS1PgMIMBM/BSLQpIkSZIkSZJakQEEmMr1+DAkSZIkSZIkqVUZQICJVJ8LJ2N9 + SJIkSZIkSVLrMoAAdxuOH+KpkCRJkiRJkqRWZgAB/u1CfBySJEmSJEmS1OoMIECl+hw4HG+EJEmSJEmS + JLU+AwhQPXS+O1aEJEmSJEmSJBWRAQS67UxsD0mSJEmSJEkqKgMIdNePsS4kSZIkSZIkqbgMINA9w/FZ + LA1JkiRJkiRJKjIDCHTLydgUkiRJkiRJklR0BhDoju9jdUiSJEmSJElS8RlAoHzX48NYHJIkSZIkSZLU + iQwgULZT4aFzSZIkSZIkSZ3LAALl+iF860OSJEmSJElSJzOAQHmuxdaQJEmSJEmSpM5mAIGynIznQpIk + SZIkSZI6nQEEyjAc1ckrSZIkSZIkSVIygED7XYwPQpIkSZIkSZL0VwYQaK+xOBrPhiRJkiRJkiTpXxlA + oJ2qh86/D0mSJEmSJEnSBBlAoH3OxJaQJEmSJEmSJE2SAQTaYzQOxuqQJEmSJEmSJE2RAQTa4VJ8FUtD + kiRJkiRJkjRNBhBovmOxKf4TkiRJkiRJkqQZZACB5roZ+8LJK0mSJEmSJEmaZQYQaKbq5NWOWBaSJEmS + JEmSpFlmAIHmOR6vxEMhSZIkSZIkSZpDBhBojurP4nfxeEiSJEmSJEmS5pEBBJphON4OSZIkSZIkSVIN + GUBg8M7EgpAkSZIkSZIk1ZQBBAZrV0iSJEmSJEmSas4AAoNRnbxaG5IkSZIkSZKkHmQAgf4ai+Nxf0iS + JEmSJEmSepQBBPrnRuwMSZIkSZIkSVKPM4BA71V/xs7HxpAkSZIkSZIk9SEDCPRW9dbHL/FcSJIkSZIk + SZL6lAEEeudyfB5LQ5IkSZIkSZLUxwwgUL/qz9SxeDskSZIkSZIkSQPIAAL1qk5efR/PhyRJkiRJkiRp + QBlAoD4XY3s8GpIkSZIkSZKkAWYAgXocjtdCkiRJkiRJktSADCAwf9VD58+EJEmSJEmSJKkhGUBg7q7F + +ng4JEmSJEmSJEkNygACc/NrPB2SJEmSJEmSpAZmAIHZ+zAeCUmSJEmSJElSQzOAwMxdjpdCkiRJkiRJ + ktTwDCAwM/tjSUiSJEmSJEmSWpABBKY2HB+FJEmSJEmSJKlFGUBgYuNxOjaEJEmSJEmSJKllGUDgXiNR + nbx6KiRJkiRJkiRJLcwAAne6GJ+FJEmSJEmSJKnFGUDgT9Wfg//FmyFJkiRJkiRJankGELjvvhvxfSwP + SZIkSZIkSVIBGUDoujPxUUiSJEmSJEmSCsoAQpcdiHUhSZIkSZIkSSosAwhdVJ282hXLQpIkSZIkSZJU + YAYQuuZUvBeSJEmSJEmSpIIzgNAlP8YLIUmSJEmSJEkqPAMIXTAUn8ZjIUmSJEmSJEnqQAYQSnc6NsT9 + IUmSJEmSJEnqSAYQSrY/nghJkiRJkiRJUscygFCiG7EjJEmSJEmSJEkdzQBCac7GqpAkSZIkSZIkdTgD + CKUYierklSRJkiRJkiRJBhCKcCW2hyRJkiRJkiRJf2QAoc2qn91TUf0cS5IkSZIkSZL0dwYQ2moofgpJ + kiRJkiRJku7JAEIbnY8tIUmSJEmSJEnShBlAaJPqofPfYm1IkiRJkiRJkjRpBhDa4nJ8HctCkiRJkiRJ + kqQpM4DQBidjczwYkiRJkiRJkiRNmwGEJrsZ1UPnL4QkSZIkSZIkSTPOAEJTXYlPYnlIkiRJkiRJkjSr + DCA00YlYHwtCkiRJkiRJkqRZZwChSaqfxb1R/VxKkiRJkiRJkjTnDCA0RfXex6ZYGJIkSZIkSZIkzSsD + CE1wNpaFJEmSJEmSJEm1ZABh0HaFJEmSJEmSJEm1ZgBhUMZibUiSJEmSJEmSVHsGEPptPI7HIyFJkiRJ + kiRJUk8ygNBPI/FlSJIkSZIkSZLU0wwg9EP1M3Yh3gpJkiRJkiRJknqeAYReuxkHY01IkiRJkiRJktSX + DCD00pWoTl4tDUmSJEmSJEmS+pYBhF6ofqZOxLshSZIkSZIkSVLfM4BQt+rk1b54MSRJkiRJkiRJGkgG + EOp0KT4KJ68kSZIkSZIkSQPNAEJdfouNIUmSJEmSJEnSwDOAUIed8WxIkiRJkiRJktSIDCDMx9V4Ox4M + SZIkSZIkSZIakwGEufo1ng9JkiRJkiRJkhqXAYS5+CSWhSRJkiRJkiRJjcwAwmxcjg0hSZIkSZIkSVKj + M4AwUwdjeUiSJEmSJEmS1PgMIEznZnwakiRJkiRJkiS1JgMIUzkbb4QkSZIkSZIkSa3KAMJERuNAPBmS + JEmSJEmSJLUuAwh3qx463xmSJEmSJEmSJLU2Awi3jcfxeDMkSZIkSZIkSWp1BhAqw/FTPB6SJEmSJEmS + JLU+Awjn4rOQJEmSJEmSJKmYDCDd9lu8FpIkSZIkSZIkFZUBpJuux7fh5JUkSZIkSZIkqcgMIN1zOraF + JEmSJEmSJEnFZgDpll/i5ZAkSZIkSZIkqegMIN0wFDvjyZAkSZIkSZIkqfgMIOU7E2/FgpAkSZIkSZIk + qRMZQMpWnbyq/hlLkiRJkiRJktSpDCBluhmfhiRJkiRJkiRJncwAUp4L8VxIkiRJkiRJktTZDCDlqP45 + HghJkiRJkiRJkjqfAaQMN2JrSJIkSZIkSZKkZABpt/E4H4+HJEmSJEmSJEn6KwNIe1Xf+vg5JEmSJEmS + JEnSXRlA2ulSOHklSZIkSZIkSdIkGUDaZSSOxgshSZIkSZIkSZImyQDSHldjTzwRkiRJkiRJkiRpigwg + 7XAmtsRDIUmSJEmSJEmSpskA0mzVyatf4uWQJEmSJEmSJEkzzADSXNXJq89iRUiSJEmSJEmSpFlkAGmm + U7ExFoQkSZIkSZIkSZplBpBmGY+98VxIkiRJkiRJkqQ5ZgBpjuq9j82xNCRJkiRJkiRJ0jwygDTDmXg6 + JEmSJEmSJElSDRlABm93SJIkSZIkSZKkGjOADE719/2VkCRJkiRJkiRJNWcAGYwT4a0PSZIkSZIkSZJ6 + lAGkv8ZiV0iSJEmSJEmSpB5mAOmP8bgYm0KSJEmSJEmSJPU4A0jvjcbheD4kSZIkSZIkSVIfMoD01rWo + Tl4tCUmSJEmSJEmS1KcMIL1Rnbw6Fe+HJEmSJEmSJEnqcwaQ+o3ET/FSSJIkSZIkSZKkAWQAqdfl+CwW + hyRJkiRJkiRJGlAGkPociU0hSZIkSZIkSZIGnAGkHtVD56tCkiRJkiRJkiQ1IAPI/FQnr7aFJEmSJEmS + JElqUAaQuTsUr4YkSZIkSZIkSWpYBpDZG4+d8VRIkiRJkiRJkqQGZgCZnUtRPXT+n5AkSZIkSZIkSQ3N + ADJzh8ND55IkSZIkSZIktSADyPRGozp5JUmSJEmSJEmSWpIBZGq/x5shSZIkSZIkSZJalAFkYmNxKJaF + JEmSJEmSJElqWQaQe12NXSFJkiRJkiRJklqaAeROp2NjSJIkSZIkSZKkFmcA+dPNOBBLQpIkSZIkSZIk + tTwDyH33XYgvQpIkSZIkSZIkFVLXB5Bj8XpIkiRJkiRJkqSC6uoAciP2xZMhSZIkSZIkSZIKq4sDyNnY + EQ+FJEmSJEmSJEkqsC4NIOPxa7wakiRJkiRJkiSp4LoygAzFrlgRkiRJkiRJkiSp8LowgFQnr96JRSFJ + kiRJkiRJkjpQ6QPIwVgVkiRJkiRJkiSpQ5U6gIzEZ/FISJIkSZIkSZKkjlXiAHIlng9JkiRJkiRJktTR + ShtAfg1JkiRJkiRJktTxShlAqr+GLSFJkiRJkiRJktT6AWQ8LsXSkCRJkiRJkiRJ+qM2DyA34+eQJEmS + JEmSJEm6o7YOINVD59tCkiRJkiRJkiTpnto2gIzG8XgpJEmSJEmSJEmSJqxNA8i1+C6eCkmSJEmSJEmS + pElrywByLqqTVw+FJEmSJEmSJEnSlDV9AKlOXh2MV0OSJEmSJEmSJGlGNXkAqU5e7YynQ5IkSZIkSZIk + acY1dQA5HZvCyStJkiRJkiRJkjTrmjiA7IvnQ5IkSZIkSZIkaU41aQCp3vt4P5aFJEmSJEmSJEnSnGvK + AHIm1oYkSZIkSZIkSdK8a8IAsieWhKT/3979okQQBmAc3mAwbhLPYDCJwSwGD2AQwx5gg8kLeAQxiNEj + mEVks8koBlmMmxfDgu+sWETRdeevPA/8YAYG5gAvfB8AAAAAAKVocgAp/jtIAAAAAAAApWpqALlPGwkA + AAAAAKB0dQ8gs3SZVhMAAAAAAEAl6hxAxmmYAAAAAAAAKlXHAPKa7tJeAgAAAAAAqFzVA8gkFUderSUA + AAAAAIBaVDWAFHd9PKSTBAAAAAAAUKsqBpBpuk77CQAAAAAAoHZlDyAv6Sz1EwAAAAAAQCPKHEBGaZgA + AAAAAAAaVdYAcpV2EgAAAAAAQOOWHUDG6TStJAAAAAAAgFZYZgC5TUcJAAAAAACgVf4ygBTfX6StBAAA + AAAA0DqLDiDP6Tj1EwAAAAAAQCstMoDcpd0EAAAAAADQar8ZQD6OvHLROQAAAAAA0Ak/DSDFkVeDBAAA + AAAA0BnfDSCzNErrCQAAAAAAoFO+GkAmqTjyCgAAAAAAoJM+DyCP6TABAAAAAAB0VjGAFMPHNN2kfgIA + AAAAAOi07fSUzudvAAAAAAAA/8BmOnh/BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACY6/XeAGiT85ii7WtUAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAABkAAAARrCAYAAADb+Gp7AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAUVNJREFUeF7s3X/E34X+//F85DiSTDKTSSbJJEcySZIkSZJkkiTJ5EiSZJJIkiRJ + JpkkSZJMMpNM5pjMzMzMTGZmZmZmZuZymcv3+3idTufU9tyuX+8frx+3OzfO+bPrer9fF8+Hvd9XSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIk + SZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkSZIkXdz6uOP3 + /ylJkiRJkiRJktT9NsXhWPfv/ydJkiRJkiRJktThVsT2mIn/F/8ISZIkSZIkSZKkzvZ0/BbN8NG4EAYQ + SZIkSZIkSZLU2T6L0/HH+GEAkSRJkiRJkiRJnW1V/Cvm4s/jhwFEkiRJkiRJkiR1sufiaFw8fPzBACJJ + kiRJkiRJkjrT1dF85FUzcFTDxx8MIJIkSZIkSZIkqRM9GDuiGjwuZgCRJEmSJEmSJEmtbkW8Elf6yKuL + GUAkSZIkSZIkSVJruysW8pFXFzOASJIkSZIkSZKkVvZM/BLVwDEfA4gkSZIkSZIkSWpVzRedvxPHoho3 + FsIAIkmSJEmSJEmSWtM98VVUo8ZiGEAkSZIkSZIkSVIrein+FdWgsVgGEEmSJEmSJEmSNNVWxCdxPKox + YykMIJIkSZIkSZIkaWo9Ej/GTFRDxlIZQCRJkiRJkiRJ0lR6PfbHXFQjxnIYQCRJkiRJkiRJ0kRbGZvj + dFTjxSgYQCRJkiRJkiRJ0sR6KHbEbFTDxagYQCRJkiRJkiRJ0kR6KY5FNViMmgFEkiRJkiRJkiSNtb9H + 85FX4/iuj8sxgEiSJEmSJEmSpLG1NvZENVKMkwFEkiRJkiRJkiSNpeeiGSKqgWLcDCCSJEmSJEmSJGmk + 3RifRzVMTIoBRJIkSZIkSZIkjawHYn9Uo8QkGUAkSZIkSZIkSdKyWxOvxExUg8SkGUAkSZIkSZIkSdKy + ejC+iWqImBYDiCRJkiRJkiRJWlLXxobYF9UIMU0GEEmSJEmSJEmStOjujI/iZFQDxLQZQCRJkiRJkiRJ + 0qJ6IrZFW77vo2IAkSRJkiRJkiRJC6r5yKvX42BUo0ObGEAkSZIkSZIkSdK83R5fRls/8upiBhBJkiRJ + kiRJknTFHold0eaPvLqYAUSSJEmSJEmSJF225iOvjkc1MrSZAUSSJEmSJEmSJJX9EOeiGhjazgAiSZIk + SZIkSZL+0uo4GnNRjQtdYACRJEmSJEmSJEn/7dVoxoNqVOgSA4gkSZIkSZIkSfp3P0U1JnSRAUSSJEmS + JEmSpIH3YHTxi86vxAAiSZIkSZIkSdJAuz7ej/NRjQhdZgCRJEmSJEmSJGmA3RPbohoP+sAAIkmSJEmS + JEnSgFoZL8aBqIaDvjCASJIkSZIkSZI0kO6ITXEqqtGgTwwgkiRJkiRJkiQNoCfip5iLajDoGwOIJEmS + JEmSJEk97tp4K/r+kVcXM4BIkiRJkiRJktTTbotv4kxUI0GfGUAkSZIkSZIkSephT8WvUY0DQ2AAkSRJ + kiRJkiSpZ30Yh6MaBobCACJJkiRJkiRJUk+6MbbGuahGgSExgEiSJEmSJEmS1IOejX1RjQFDZACRJEmS + JEmSJKnjbYoTUQ0BQ2UAkSRJkiRJkiSpo62Jn2M2qhFgyAwgkiRJkiRJkiR1sOfit6iO/xhAJEmSJEmS + JEnqXB/FTFSHf35nAJEkSZIkSZIkqSPdE9ujOvjzVwYQSZIkSZIkSZJa3t9iQxyN6tjPpQwgkiRJkiRJ + kiS1uNuj+ciruagO/dQMIJIkSZIkSZIktbQn4ueoDvxcmQFEkiRJkiRJkqQW9noci+q4z/wMIJIkSZIk + SZIktajmi843RXXUZ+EMIJIkSZIkSZIktaTmi853RHXQZ3EMIJIkSZIkSZIkTblV8X74yKvRMYBIkiRJ + kiRJkjTFHonv43xUh3yWxgAiSZIkSZIkSdKUeiX2xlxUR3yWzgAiSZIkSZIkSdKEuzGaLzo/GdXxnuUz + gEiSJEmSJEmSNMEejO0xE9XhntEwgEiSJEmSJEmSNKE2xJHwkVfjZwCRJEmSJEmSJGkCNR95NRvVsZ7R + M4BIkiRJkiRJkjTGVsfuqI70jI8BRJIkSZIkSZKkMfVYNIf46kDPeBlAJEmSJEmSJEkaQ5ujOswzGQYQ + SZIkSZIkSZJG2J2xP6qjPJNjAJEkSZIkSZIkaQQ13/XxUpyP6iDPZBlAJEmSJEmSJElaZvfG1zEX1TGe + yTOASJIkSZIkSZK0xFbEs7E3qiM802MAkSRJkiRJkiRpCd0R78eJqA7wTJcBRJIkSZIkSZKkRfZo/Bi+ + 76O9DCCSJEmSJEmSJC2wa+PV2B/V0Z32MIBIkiRJkiRJkrSAbo3Pw0dedYMBRJIkSZIkSZKkeXoodoaP + vOoOA4gkSZIkSZIkSVfotTga1ZGd9jKASJIkSZIkSZJ0mX6IM1Ed2Gk3A4gkSZIkSZIkSRd1SxyKuaiO + 67SfAUSSJEmSJEmSpD/VfOSVf/XRfQYQSZIkSZIkSZL+09ZoDufVQZ1uMYBIkiRJkiRJkgbfvXE4qkM6 + 3WQAkSRJkiRJkiQNuvfiXFRHdLrLACJJkiRJkiRJGmTNcfzHqI7ndJ8BRJIkSZIkSZI0qFbE87E/qsM5 + /WAAkSRJkiRJkiQNptviozgV1dGc/jCASJIkSZIkSZIG0aPhI6+GwwAiSZIkSZIkSep9r8e+qA7l9JMB + RJIkSZIkSZLU226JL+J0VEdy+ssAIkmSJEmSJEnqZU/GL1Edx+k/A4gkSZIkSZIkqXe9HwejOowzDAYQ + SZIkSZIkSVJvaj7y6vs4G9VRnOEwgEiSJEmSJEmSetFzsSvmojqIMywGEEmSJEmSJElS5/sojkV1CGeY + DCCSJEmSJEmSpM52W2yNmaiO4AyXAUSSJEmSJEmS1MmeiQNRHb/BACJJkiRJkiRJ6lzvxbmoDt/QMIBI + kiRJkiRJkjrT2tgW1cEb/swAIkmSJEmSJEnqRE+HLzpnoQwgkiRJkiRJkqRWtybejerIDZdjAJEkSZIk + SZIktbYH46eoDtxwJQYQSZIkSZIkSVLruiZeiBNRHbdhPgYQSZIkSZIkSVKrujs+iuqoDQtlAJEkSZIk + SZIktaZn45eoDtqwGAYQSZIkSZIkSdLUWx1vx9GojtmwWAYQSZIkSZIkSdJUezi+iXNRHbJhKQwgkiRJ + kiRJkqSp9c/YHc2xujpiw1IZQCRJkiRJkiRJE6/5yKuP43hUx2tYLgOIJEmSJEmSJGmi3R/bwkdeMU4G + EEmSJEmSJEnSxHo+DoePvGLcDCCSJEmSJEmSpInUfOTV+aiO1TBqBhBJkiRJkiRJ0li7PnbFXFSHahgH + A4gkSZIkSZIkaWw9ELNRHahhnAwgkiRJkiRJkqSxtCmqwzRMggFEkiRJkiRJkjTS1sSBqI7SMCkGEEmS + JEmSJEnSSLohNsS5qA7SMEkGEEmSJEmSJEnSsmsOzV9Hc3SujtEwaQYQSZIkSZIkSdKSWxHrY3dUR2iY + FgOIJEmSJEmSJGlJrY1343hUB2iYJgOIJEmSJEmSJGnRPRTfh+/7oK0MIJIkSZIkSZKkBXdNvBR7ojo6 + Q1sYQCRJkiRJkiRJC2pNfBrHojo4Q5sYQCRJkiRJkiRJ8/ZA/BLnozo2Q9sYQCRJkiRJkiRJV+zVOBTV + kRnaygAiSZIkSZIkSbpszRedn4rqwAxtZgCRJEmSJEmSJF1SczjeG80RuTouQ9sZQCRJkiRJkiRJf2lj + HI/qqAxdYQCRJEmSJEmSJP23LeGLzukDA4gkSZIkSZIk6ap74kBUh2ToIgOIJEmSJEmSJA28t+JMVEdk + 6CoDiCRJkiRJkiQNtFuj+cir6ngMXWcAkSRJkiRJkqSBdXU8HfuiOhxDHxhAJEmSJEmSJGlA3Rzvxamo + jsbQFwYQSZIkSZIkSRpID8V3UR2LoW8MIJIkSZIkSZI0gF6OvVEdiqGPDCCSJEmSJEmS1OPWxKY4E9WR + GPrKACJJkiRJkiRJPe3x2BrVcRj6zgAiSZIkSZIkST3s7dgf1WEYhsAAIkmSJEmSJEk9am18FT7yiqEz + gEiSJEmSJElST3ou/hXN4bc6CMOQGEAkSZIkSZIkqQe9H0eiOgTDEBlAJEmSJEmSJKnD3R5b4nxUR2AY + KgOIJEmSJEmSJHW0p2NfzEV1AIYhM4BIkiRJkiRJUgd7O85GdfgFDCCSJEmSJEmS1KlujOYjr6qDL/A/ + BhBJkiRJkiRJ6kiPxLGojr3AXxlAJEmSJEmSJKnlXR9vRnXkBWoGEEmSJEmSJElqcXfGT1EdeIHLM4BI + kiRJkiRJUgu7LtbHyaiOu8CVGUAkSZIkSZIkqWXdFR9EddQFFsYAIkmSJEmSJEkt6snYHtVBF1g4A4gk + SZIkSZIktaCbYmMcieqYCyyOAUSSJEmSJEmSptyD8VWcjeqQCyyeAUSSJEmSJEmSptgL8Ws0x9rqiAss + jQFEkiRJkiRJkqbQ6mi+6PxYVMdbYHkMIJIkSZIkSZI04e6NH8NHXsH4GEAkSZIkSZIkaYI9G4fCR17B + eBlAJEmSJEmSJGlCfRRnojrWAqNlAJEkSZIkSZKkMXd17IrZqA61wOgZQCRJkiRJkiRpjD0QvusDJs8A + IkmSJEmSJEljalNUh1lg/AwgkiRJkiRJkjTiVsT+qI6ywGQYQCRJkiRJkiRphL0QPvIKps8AIkmSJEmS + JEkj6Jb4Mpqja3WMBSbLACJJkiRJkiRJy+jaeCx2RXWEBabDACJJkiRJkiRJS2xNvBVHozrAAtNjAJEk + SZIkSZKkJXRffBPnojq+AtNlAJEkSZIkSZKkRfS32BC/RnV0BdrBACJJkiRJkiRJC2x1fBI+8grazwAi + SZIkSZIkSQuo+cirbTET1bEVaBcDiCRJkiRJkiTN06uxP6ojK9BOBhBJkiRJkiRJukJfxcmoDqxAexlA + JEmSJEmSJKno7tgZs1EdV4F2M4BIkiRJkiRJ0kW9EUeiOqoC3WAAkSRJkiRJkqQ/9W2cjeqgCnSHAUSS + JEmSJEmS0r2xJ6pDKtA9BhBJkiRJkiRJg++18EXn0C8GEEmSJEmSJEmDbVU0H3lVHU+BbjOASJIkSZIk + SRpkj8feqA6nQPcZQCRJkiRJkiQNquZffbwZp6M6mgL9YACRJEmSJEmSNJjui6+iOpYC/WIAkSRJkiRJ + kjSINsSeqA6lQP8YQCRJkiRJkiT1utXxfpyN6kgK9JMBRJIkSZIkSVJva77o/LuojqNAvxlAJEmSJEmS + JPWyjbE/qsMo0H8GEEmSJEmSJEm96o7YHKejOooCw2AAkSRJkiRJktSbnont0Rw+q4MoMBwGEEmSJEmS + JEm96J04HNUhFBgeA4gkSZIkSZKkTnd7fBtnozqCAsNkAJEkSZIkSZLU2dbHnvCRV8DFDCCSJEmSJEmS + Otmb4YvOgcsxgEiSJEmSJEnqVCvj+6gOngB/MIBIkiRJkiRJ6kx3xtGojp0Af2YAkSRJkiRJktSJXovq + yAlQMYBIkiRJkiRJanU3xM9RHTgBLscAIkmSJEmSJKmVXROPxImojpsAV2IAkSRJkiRJktS6bo/3Yi6q + wybAfAwgkiRJkiRJklrVo+Ejr4DlMoBIkiRJkiRJakWr49U4HNUxE2AxDCCSJEmSJEmSpt598XmcieqQ + CbBYBhBJkiRJkiRJU+3Z+Fc0x8rqiAmwFAYQSZIkSZIkSVPpxng3fOQVMA4GEEmSJEmSJEkTb11sidNR + HS4BlssAIkmSJEmSJGmiPR37w0deAeNkAJEkSZIkSZI0sT6Kk1EdKwFGyQAiSZIkSZIkaSLtjPNRHSoB + Rs0AIkmSJEmSJGmsPRT+1QcwaQYQSZIkSZIkSWNrU8xEdZwEGCcDiCRJkiRJkqSxtCuqoyTAJBhAJEmS + JEmSJI205+JMVAdJgEkxgEiSJEmSJEkaSSvj85iN6hgJMEkGEEmSJEmSJEnL6upovuh8Z1RHSIBpMIBI + kiRJkiRJWnKr4/U4EtUBEmBaDCCSJEmSJEmSltTd8VWcj+r4CDBNBhBJkiRJkiRJi675ovMdUR0dAdrA + ACJJkiRJkiRpwTVfdP5h+MgroO0MIJIkSZIkSZIW1L2xJWajOjYCtIkBRJIkSZIkSdK8vRx7ojoyArSR + AUSSJEmSJEnSFdscx6M6MAK0lQFEkiRJkiRJUtl9sT1mojouArSZAUSSJEmSJEnSJW2Mg1EdFQG6wAAi + SZIkSZIk6S99FaejOigCdIUBRJIkSZIkSdK/az7y6teYi+qYCNAlBhBJkiRJkiRJV70ax6I6IgJ0kQFE + kiRJkiRJGnifR3U8BOgyA4gkSZIkSZI00B6KPVEdDgG6zgAiSZIkSZIkDazrovnIq7NRHQ0B+sAAIkmS + JEmSJA2odeEjr4AhMIBIkiRJkiRJA+mp2BvVoRCgbwwgkiRJkiRJUs+7Kd6Ic1EdCQH6yAAiSZIkSZIk + 9bhH4uuojoMAfWYAkSRJkiRJknraK+Ejr4ChMoBIkiRJkiRJPeuO2BSnojoKAgyBAUSSJEmSJEnqUc0X + nW+L2agOggBDYQCRJEmSJEmSetKbcSiqQyDA0BhAJEmSJEmSpI7XfOTVV3E6qiMgwBAZQCRJkiRJkqQO + 90TsipmoDoAAQ2UAkSRJkiRJkjraxjgZ1eEPYOgMIJIkSZIkSVLHWhHfhi86B7g8A4gkSZIkSZLUoZrv + +zgc1bEPgP8xgEiSJEmSJEkd6Z9RHfkAuJQBRJIkSZIkSepA26I68AFQM4BIkiRJkiRJLe3/4v44HtVx + D4DLM4BIkiRJkiRJLWxNvBPNAa867AFwZQYQSZIkSZIkqWU9ED9FddADYGEMIJIkSZIkSVJLujGaLzr/ + LapjHgALZwCRJEmSJEmSWtDd8WmcjuqQB8DiGEAkSZIkSZKkKfdU/BKzUR3xAFg8A4gkSZIkSZI0pVbF + W3EoquMdAEtnAJEkSZIkSZKm0J3xXZyK6nAHwPIYQCRJkiRJkqQJ13zk1Z5ojnPV0Q6A5TOASJIkSZIk + SRPswzgW1bEOgNExgEiSJEmSJEkTakeci+pQB8BoGUAkSZIkSZKkMfdYHInqQAfAeBhAJEmSJEmSpDH2 + SZyJ6jgHwPgYQCRJkiRJkqQx9a9oDnDVYQ6A8TKASJIkSZIkSSNufZyI6iAHwGQYQCRJkiRJkqQR9lnM + RnWMA2ByDCCSJEmSJEnSCLo3dkR1hANg8gwgkiRJkiRJ0jK6IV6JI1Ed4ACYDgOIJEmSJEmStMTujM1x + PqrjGwDTYwCRJEmSJEmSltDTsT2qoxsA02cAkSRJkiRJkhbRingnfOQVQLsZQCRJkiRJkqQF1nzR+Tcx + E9WxDYD2MIBIkiRJkiRJC2hD/BrVkQ2A9jGASJIkSZIkSfP0SRyN6sAGQDsZQCRJkiRJkqTLdF9sDR95 + BdA9BhBJkiRJkiSp6LXYF9VRDYD2M4BIkiRJkiRJf+pv8XmciuqgBkA3GEAkSZIkSZKk/3R//BKzUR3T + AOgOA4gkSZIkSZKUXo4jUR3RAOgeA4gkSZIkSZIG36fRHMqqAxoA3WQAkSRJkiRJ0mBbF79GdTgDoNsM + IJIkSZIkSRpkG+JcVEczALqvGUDuCEmSJEmSJGkQ3RafRXUsA6A//AsQSZIkSZIkDaaHY29UhzIA+mUu + 3orn4nkAAIAWeSEeDUmSlt1N8VKcj+pIBgAAAACTtCskSVpWD8SXUf2hAQAAAIBp+FdIkrTkmi8695FX + AAAAALSNAUSStKRujw/jVFR/YAAAAABgmgwgkqRF92T8GDNR/XEBAAAAgGkzgEiSFtXrcTDmovrDAgAA + AABtYACRJC2o5iOvPg8feQUAAABAFxhAJEnz9ljsjPNR/TEBAAAAgLYxgEiSrljzkVfHovojAgAAAABt + ZQCRJJVdHd+Gf/UBAAAAQBcZQCRJl3RbHApfdA4AAABAVxlAJEl/aUNUfzAAAAAAoEsMIJKk//ZjVH8s + AAAAAKBrDCCSpKvWxfGo/lAAAAAAQBcZQCRpwN0Qb8WFqP5IAAAAAEBXGUAkaaDdHVuj+uMAAAAAAF1n + AJGkgbUqno+DUf1hAAAAAIA+MIBI0oD6R3wSp6L6owAAAAAAfWEAkaSB9Hj8FL7vAwAAAIAhMIBIUs9r + vuj8jTgQ1R8CAAAAAOgjA4gk9bjb4+vwkVcAAAAADI0BRJJ62vrYGXNR/QEAAAAAgD4zgEhSD/sgjkT1 + 4AcAAACAITCASFLP2hZno3roAwAAAMBQGEAkqSc9Hr7oHAAAAAB+ZwCRpB70cZyM6kEPAAAAAENkAJGk + DrcitsdsVA95AAAAABgqA4gkdbT1cTiqhzsAAAAADJ0BRJI6WPORV+ejerADAAAAAAYQSepUd0XzkVfV + Ax0AAAAA+B8DiCR1oL/Hi+EjrwAAAABgYQwgktTy1sYnMRPVgxwAAAAAuJQBRJJa3BOxLaoHOAAAAABw + eQYQSWph18TG8JFXAAAAALA0BhBJalnNF51/HrNRPbgBAAAAgPkZQCSpRT0fv0T1wAYAAAAAFs4AIkkt + 6G/xQRyJ6mENAAAAACyOAUSSptx98X3MRPWgBgAAAAAWzwAiSVPsldgd1QMaAAAAAFg6A4gkTaHr4tM4 + EdXDGQAAAABYHgOIJE24B+Kn8JFXAAAAADA+BhBJmmD/jMMxF9VDGQAAAAAYDQOIJE2gv8Un4V99AAAA + AMBkGEAkaczdHjujeggDAAAAAONhAJGkMbY+zkb1AAYAAAAAxscAIklj6PrYFNWDFwAAAAAYPwOIJI24 + O2NfVA9dAAAAAGAyDCCSNKJujBfifFQPXAAAAABgcgwgkjSC7onPo3rQAgAAAACTZwCRpGX2bOyJ6iEL + AAAAAEyHAUSSltjt8W6cjOoBCwAAAABMjwFEkpbQY7ElfN8HAAAAALSTAUSSFtHf45XYH9VDFQAAAABo + BwOIJC2wtfFZnIjqgQoAAAAAtIcBRJIW0MOxI3zkFQAAAAB0gwFEkubp1TgS1UMUAAAAAGgnA4gkXaFv + 4kxUD1AAAAAAoL0MIJJUdGscjAtRPTwBAAAAgHYzgEjSRT0fM1E9NAEAAACAbjCASNKf2hLVwxIAAAAA + 6BYDiCSltXE0qgclAAAAANA9BhBJg+/N8JFXAAAAANAvBhBJg+32+DHmonpAAgAAAADdZQCRNLiuj2di + f1QPRgAAAACg+wwgkgZV810fH8apqB6KAAAAAEA/GEAkDaZHovnIqwtRPRABAAAAgP4wgEjqfSvitdgb + 1YMQAAAAAOgfA4ikXndbfBEno3oIAgAAAAD9ZACR1NueiF9iLqoHIAAAAADQXwYQSb3svTgU1YMPAAAA + AOg/A4ikXnVdbIkzUT30AAAAAIBhMIBI6k3NR17tCR95BQAAAAAYQCT1oo/iWFQPOgAAAABgeAwgkjrd + qtgWM1E95AAAAACAYTKASOps6+NAVA83AAAAAGDYDCCSOtkHcTaqBxsAAAAAgAFEUqdaG81HXlUPNAAA + AACAPxhAJHWm5+JIVA8zAAAAAIA/M4BIan1r4v2YjepBBgAAAABwMQOIpFb3cGyN6gEGAAAAAHA5BhBJ + rez/4uXwkVcAAAAAwFIYQCS1rn/EJzEX1YMLAAAAAGA+BhBJreqZ2BbVAwsAAAAAYKEMIJJa0XXxTvjI + KwAAAABgFAwgkqbe/fF1nI/qQQUAAAAAsFgGEElT7aX4NXzfBwAAAAAwSgYQSVPphvgojkf1cAIAAAAA + WA4DiKSJ13zk1dbwkVcAAAAAwLgYQCRNtBfiUFyI6qEEAAAAADAKBhBJE+nv8XGcjephBAAAAAAwSgYQ + SWPv1mgeNr7oHAAAAACYFAOIpLH2cJyO6gEEAAAAADAuBhBJY+ujqB48AAAAAADjZgCRNPJWx76oHjoA + AAAAAJNgAJE0sq6PZ+J8VA8cAAAAAIBJMYBIGkn/iM1RPWgAAAAAACbNACJpWV0dT8buqB4yAAAAAADT + YACRtORui7fieFQPGAAAAACAaTGASFpSD8d34fs+AAAAAIA2MoBIWlTXxj9jT1QPFQAAAACANjCASFpw + t8YncSyqBwoAAAAAQFsYQCQtqAfj5zgX1cMEAAAAAKBNDCCS5u3lOBTVQwQAAAAAoI0MIJKu2FdxKqoH + CAAAAABAWxlAJJXdHPtjNqqHBwAAAABAmxlAJF3Shjgd1UMDAAAAAKALDCCS/tL3MRPVAwMAAAAAoCsM + IJL+3ZrwRecAAAAAQF8YQCRd9Uaci+ohAQAAAADQRQYQacDdFD9E9XAAAAAAAOgyA4g0wK6J9bEvqgcD + AAAAAEDXGUCkgXVzvBcno3ooAAAAAAD0gQFEGlAPxvdxIaoHAgAAAABAXxhApAH093g59kT1IAAAAAAA + 6BsDiNTz1sSn4SOvAAAAAIAhMYBIPe6x2BbVmx8AAAAAoM8MIFJPezMORPXGBwAAAADoOwOI1LNWxTdx + Oqo3PQAAAADAEBhApB71ZOyMuaje8AAAAAAAQ2EAkXrSB3E4qjc6AAAAAMDQGECkjndzbIlzUb3JAQAA + AACGyAAidbinYm/4yCsAAAAAgL8ygEgd7d3wRecAAAAAADUDiNSxVkfzkVfVGxoAAAAAgN8ZQKQO9WT4 + onMAAAAAgPkZQKQOtDLejgtRvZEBAAAAAPgrA4jU8u4NH3kFAAAAALA4BhCpxT0XR6N68wIAAAAAcHkG + EKmF3RHvRPWmBQAAAABgfgYQqWU1X3S+Nao3LAAAAAAAC2MAkVrSDbExDkf1ZgUAAAAAYOEMIFILuj++ + iHNRvVEBAAAAAFgcA4g05TZE80a8ENWbFAAAAACAxTOASFNqVbwfR6N6cwIAAAAAsHQGEGkK3Rdb4mxU + b0wAAAAAAJbHACJNuOfiQPjIKwAAAACA8TGASBPq/+LDOB3VmxEAAAAAgNExgEgT6KbYHrNRvREBAAAA + ABgtA4g05h6MU1G9AQEAAAAAGA8DiDTG3o/qjQcAAAAAwHgZQKQxtS+qNx0AAAAAAONnAJFG2NXxZJyP + 6g0HAAAAAMBkGECkEXVLbI7qjQYAAAAAwGQZQKRl9rd4JHZF9SYDAAAAAGDyDCDSMmr+1cfGOBbVGwwA + AAAAgOkwgEhL7L74Js5F9eYCAAAAAGB6DCDSIrs2XohfYy6qNxYAAAAAANNlAJEW0Zr4KI5G9YYCAAAA + AKAdDCDSAms+8mpb+MgrAAAAAID2M4BIC+ifsT+qNxEAAAAAAO1jAJHm6cs4EdUbCAAAAACAdjKASJfp + 5tgTM1G9eQAAAAAAaC8DiFTUfOTVsajeNAAAAAAAtJ8BRLqo7+JsVG8YAAAAAAC6wQAi/afbY19UbxQA + AAAAALrFACKlV+NUVG8SAAAAAAC6xwCiQbcimo+8qt4cAAAAAAB0lwFEg+2x2BvVGwMAAAAAgG4zgGhw + rYq34mRUbwoAAAAAALrPAKJBdW98HXNRvSEAAAAAAOgHA4gG04bYFdUbAQAAAACAfjGAqPfdFB/Gqaje + BAAAAAAA9I8BRL3ukdgS1YsfAAAAAID+MoCot70ee6N64QMAAAAA0G8GEPWum+PzOB3Vix4AAAAAgP4z + gKhXrY/tcSGqFzwAAAAAAMNgAFFvejcORfVCBwAAAABgWAwg6ny3xrdxNqoXOQAAAAAAw2MAUadrPvJq + V/jIKwAAAAAA/swAos72VpyM6oUNAAAAAMCwGUDUuVZH85FXc1G9qAEAAAAAwACiTvVA+KJzAAAAAADm + YwBRZ3o9qhcxAAAAAABczACi1rc2tkT1AgYAAAAAgIoBRK3u0Tge1YsXAAAAAAAuxwCiVtb8q483onrR + AgAAAADAfAwgal3Nv/rYGtULFgAAAAAAFsIAota0Kl6Jw1G9WAEAAAAAYKEMIGpF98ZncTaqFyoAAAAA + ACyGAURT79nYEReiepECAAAAAMBiGUA0tW6Md8NHXgEAAAAAMGoGEE2le+K7OBPVCxMAAAAAAJbDAKKJ + 93Tsi9moXpQAAAAAALBcBhBNtPfjZFQvRgAAAAAAGBUDiCbSyvg5zkf1QgQAAAAAgFEygGjsPRAnYi6q + FyEAAAAAAIyaAURj7b2oXngAAAAAADBOBhCNrd1RvegAAAAAAGDcDCAaeY/HuahecAAAAAAAMAkGEI2s + G+Kz8F0fAAAAAABMmwFEy+7qaL7o/NeoXmQAAAAAADBpBhAtq5vitTga1QsMAAAAAACmwQCiJXd3fBm+ + 7wMAAAAAgLYxgGjR/T2ejebFU72oAAAAAABg2gwgWlSr4/04HNULCgAAAAAA2sAAogV3T/wQPvIKAAAA + AIC2M4BoQb0Ye6J6EQEAAAAAQNsYQDRvn8exqF5AAAAAAADQRgYQXbbbY0fMRvXiAQAAAACAtjKAqOyl + OBTViwYAAAAAANrOAKJL+jpOR/WCAQAAAACALjCA6L/dFbviQlQvFgAAAAAA6AoDiP7dq+GLzgEAAAAA + 6AsDiK76MvyrDwAAAAAA+sQAMuAejN1RvTAAAAAAAKDLDCAD7Lp4PU5F9aIAAAAAAICuM4AMrOaLzr+I + 6sUAAAAAAAB9YQAZUM/Er1G9EAAAAAAAoE8MIAPoxngnTkf1IgAAAAAAgL4xgPS85ovOv47qlw8AAAAA + AH1lAOlxr8TuqH7xAAAAAADQZwaQHnZrfBKnovqlAwAAAABA3xlAetb62BYXovqFAwAAAADAEBhAetRb + cTCqXzQAAAAAAAyJAaQHrY2v4nRUv2QAAAAAABgaA0jHeyJ2xmxUv2AAAAAAABgiA0iH2xjHYy6qXy4A + AAAAAAyVAaSDrYqvwxedAwAAAABAzQDSse4JX3QOAAAAAABXZgDpUC+Gj7sCAAAAAID5GUA60DWxJapf + IAAAAAAAcCkDSMu7O05E9csDAAAAAABqBpCWtiZej+qXBgAAAAAAXJkBpIXdH1uj+oUBAAAAAADzM4C0 + qJWxIX6L6pcFAAAAAAAsjAGkJTXf9fFJnInqFwUAAAAAACycAaQFPRXbYzaqXxIAAAAAALA4BpApdmO8 + GT7yCgAAAAAARssAMqXWxddxKqpfDAAAAAAAsHQGkCm0PnaHj7wCAAAAAIDxMIBMuHfjWFS/DAAAAAAA + YDQMIBPq2vgpzkb1iwAAAAAAAEbHADKBHoijMRfVLwEAAAAAABgtA8iYaz7yaiaqHz4AAAAAADAeBpAx + tjP8qw8AAAAAAJg8A8gYeiRORfUDBwAAAAAAxs8AMuI+jQtR/bABAAAAAIDJMICMqLuj+WFWP2QAAAAA + AGCyDCDLbGW8FEei+gEDAAAAAACTZwBZRv+IzXEuqh8uAAAAAAAwHQaQJbY+tkf1QwUAAAAAAKbLALLI + VsU7cSiqHygAAAAAADB9BpBFtC6+DR95BQAAAAAA7WYAWWAbYmdUP0QAAAAAAKBdDCALaFMcjeoHCAAA + AAAAtI8B5ArdGVtjJqofHgAAAAAA0E4GkMv0cuyL6ocGAAAAAAC0mwGk6PM4GdUPDAAAAAAAaD8DyJ+6 + J5ofyGxUPywAAAAAAKAbDCD/6aU4HNUPCQAAAAAA6BYDSNocvugcAAAAAAD6Y9ADyLrYGdUPBgAAAAAA + 6K7BDiDNR16djuqHAgAAAAAAdNvgBpC18WlUPwwAAAAAAKAfBjWAPBE+8goAAAAAAPpvEAPIDfFanInq + hwAAAAAAAPRL7weQB2JzVP/xAAAAAABAP/V6ANkQu6P6DwcAAAAAAPqrlwPIbfFBnIrqPxoAAAAAAOi3 + 3g0gzRed/xCzUf0HAwAAAAAA/derAeSfsT+q/1AAAAAAAGA4ejWAPB7bYy6q/1gAAAAAAGAYevcRWOvi + ozgf1X8wAAAAAADQf738EvQb4rk4EtV/NAAAAAAA0G+9HED+qPnXIFuj+g8HAAAAAAD6q9cDSNPKeCWq + /3gAAAAAAKCfej+A/NE9cTKqHwIAAAAAANAvgxlAmv4eW6L6QQAAAAAAAP0xqAHkj16Nmah+IAAAAAAA + QPcNcgBpejT2x1xUPxgAAAAAAKC7BjuANN0S34Z/DQIAAAAAAP0y6AHkj96Oo1H9gAAAAAAAgO4xgPyn + p6P5YcxG9YMCAAAAAAC6wwDyp26Pr+J0VD8sAAAAAACgGwwgRW/Fgah+YAAAAAAAQPsZQC7Tk/FjVD80 + AAAAAACg3QwgV+iW+CjORvXDAwAAAAAA2skAsoBejr1R/QABAAAAAID2MYAssIfj66h+iAAAAAAAQLsY + QBbRTfFOnI7qhwkAAAAAALSDAWQJPR27ovqBAgAAAAAA02cAWWJ3hI/EAgAAAACAdjKALLM3wkdiAQAA + AABAuxhARtD9sTeqHzAAAAAAADB5BpAR1nwk1kxUP2gAAAAAAGByDCAj7vU4FtUPGwAAAAAAmAwDyBha + F7tiNqofOgAAAAAAMF4GkDHWfCTWqah+8AAAAAAAwPgYQMbcS3Eoqh8+AAAAAAAwHgaQCXRn7AhfkA4A + AAAAAJNhAJlgm+NoVL8IAAAAAABgdAwgE+6fsTuqXwYAAAAAADAaBpApdH98H+ei+qUAAAAAAADLYwCZ + UrfEe3Ekql8MAAAAAACwdAaQKXZtPB07o/rlAAAAAAAAS2MAaUHr4ss4H9UvCQAAAAAAWBwDSEu6MV6O + E1H9ogAAAAAAgIUzgLSsu2J3VL8sAAAAAABgYQwgLW1zVL8wAAAAAABgfgaQFnd/zET1iwMAAAAAAC7P + ANKB9kb1ywMAAAAAAGoGkI70UcxG9UsEAAAAAAD+ygDSoZ6IYzEX1S8TAAAAAAD4nQGkY90RP8W5qH6h + AAAAAACAAaSTrYgP4kRUv1QAAAAAABg6A0iHez72hO8GAQAAAACAvzKAdLwH4ts4E9UvGAAAAAAAhsgA + 0oNuinficFS/ZAAAAAAAGBoDSI96Nn6Juah+2QAAAAAAMBQGkJ51b2yKmah+4QAAAAAAMAQGkB62Ml6M + Y1H90gEAAAAAoO8MID3uwfgxql88AAAAAAD0mQGk590cb0b1ywcAAAAAgL4ygAykx8NHYgEAAAAAMBQG + kAF1W/hILAAAAAAAhsAAMsA2xmxULwgAAAAAAOgDA8hAaz4S60BULwoAAAAAAOg6A8iAaz4Sa0v41yAA + AAAAAPSNAURXvRfHo3qBAAAAAABAFxlA9O+ejV1xIaoXCgAAAAAAdIkBRP+t+Uisb+NMVC8WAAAAAADo + CgOILundOBjVCwYAAAAAALrAAKKy9fFzVC8aAAAAAABoOwOILttNsTnORvXiAQAAAACAtjKAaN7eiH1R + vYAAAAAAAKCNDCBaUI/GlqheRAAAAAAA0DYGEC24W+PDOBXViwkAAAAAANrCAKJFdW28EHuiekEBAAAA + AEAbGEC0pO6O76J6UQEAAAAAwLQZQLTkrot34nRULy4AAAAAAJgWA4iW3cNxMKoXGAAAAAAATIMBRCPr + +7gQ1QsNAAAAAAAmyQCikbYxTkX1YgMAAAAAgEkxgGjk3REHYi6qFx0AAAAAAIybAURjq/lIrLNRvfAA + AAAAAGCcDCAaa6/EsahefAAAAAAAMC4GEI29u2JXzET1IgQAAAAAgFEzgGgiXRtfxPGoXogAAAAAADBK + BhBNtJdjX1QvRgAAAAAAGBUDiCbeQ/FjnIvqRQkAAAAAAMtlANFUWhsfxtGoXpgAAAAAALAcBhBNrRXx + fDRfkF69OAEAAAAAYKkMIJp698U3MRPVixQAAAAAABbLAKJWtCZej1NRvVABAAAAAGAxDCBqTVfH/bE3 + qhcrAAAAAAAslAFEreuG+CyqFywAAAAAACyEAUSt7aGoXrQAAAAAADAfA4ha376oXrwAAAAAAHA5BhB1 + oo+iegEDAAAAAEDFAKLOtD6Ox1xUL2YAAAAAAPiDAUSd6q7YHjNRvaABAAAAAKBhAFHnWhmfxKmoXtQA + AAAAAGAAUWd7MZovSL8Q1YsbAAAAAIDhMoCo0z0UW+JsVC9wAAAAAACGyQCizrc63o+jUb3IAQAAAAAY + HgOIetOGaF7Q1QsdAAAAAIBhMYCoV90Xm2M2qhc8AAAAAADDYABR77o+XotjUb3oAQAAAADoPwOIettj + sS2qFz4AAAAAAP1mAFGvWxsfRPXiBwAAAACgvwwg6n1/j+fiaFRvAgAAAAAA+scAosF0T2yN6o0AAAAA + AEC/GEA0qJp/DfJezEX1hgAAAAAAoB8MIBpkT8ShqN4UAAAAAAB0nwFEg+2WaD4Sy78GAQAAAADoHwOI + Bt+HcTKqNwgAAAAAAN1kAJHSc7E3/GsQAAAAAIB+MIBI/2lN/BjnonqzAAAAAADQHQYQ6aKaj8T6Lao3 + DAAAAAAA3WAAkYqejObNUb1pAAAAAABoPwOIdJluiG/jTFRvHgAAAAAA2ssAIs3T27E/qjcQAAAAAADt + ZACRFtDjsS2qNxEAAAAAAO1jAJEW2NrYFKeiejMBAAAAANAeBhBpEV0fL8XeqN5QAAAAAAC0gwFEWkL3 + xw8xF9UbCwAAAACA6TKASEtsdbwfp6N6cwEAAAAAMD0GEGmZPRaHonqDAQAAAAAwHQYQaURti+pNBgAA + AADA5BlApBH2WpyL6s0GAAAAAMDkGECkEXdzHInqDQcAAAAAwGQYQKQxtSVmonrjAQAAAAAwXgYQaYy9 + GqeievMBAAAAADA+BhBpzK2LPeFfgwAAAAAATI4BRJpAq+KrOBnVGxEAAAAAgNEygEgTrPlIrINRvRkB + AAAAABgdA4g04R6Nn+J8VG9KAAAAAACWzwAiTaE74pM4HtUbEwAAAACA5TGASFPqungx9kb15gQAAAAA + YOkMINKUeyi+jdmo3qQAAAAAACyeAURqQbfGG3E6qjcqAAAAAACLYwCRWtLV0XxB+r6o3qwAAAAAACyc + AURqWc2/BvksqjcsAAAAAAALYwCRWtoTUb1pAQAAAACYnwFEanErY39Ub14AAAAAAC7PACJ1oI+jegMD + AAAAAFAzgEgd6ek4GdUbGQAAAACAvzKASB3q7tgRF6J6QwMAAAAA8DsDiNSxmu8F+TTORPWmBgAAAADA + ACJ1tpfjQPjXIAAAAAAAlzKASB3ukdga56N6gwMAAAAADJUBROp4zUdifRzHo3qTAwAAAAAMkQFE6kkv + xc6o3ugAAAAAAENjAJF61P3xZfheEAAAAABg6AwgUs+6Jt6KY1G96QEAAAAAhsAAIvW0p+LnqN74AAAA + AAB9ZwCRetydsSnmonoAAAAAAAD0lQFE6nnXRfMF6UejeggAAAAAAPSRAUQaSA/FT1E9CAAAAAAA+sYA + Ig2oG+OjuBDVAwEAAAAAoC8MINIAey58JBYAAAAA0GcGEGmg3Rw+EgsAAAAA6CsDiDTwPo7TUT0gAAAA + AAC6ygAi6apn42BUDwkAAAAAgC4ygEj6d6vi5zgf1cMCAAAAAKBLDCCS/lLzkVi+IB0AAAAA6DoDiKRL + ejL2RPXQAAAAAADoAgOIpLIb4oc4E9XDAwAAAACgzQwgkq7Ye+EL0gEAAACArjGASJq39bE95qJ6kAAA + AAAAtI0BRNKC+kd8HqeiepgAAAAAALSJAUTSglsVr8b+qB4oAAAAAABtYQCRtOgejm3hI7EAAAAAgLYy + gEhaUrfGh3EmqocLAAAAAMA0GUAkLblro/mC9MNRPWAAAAAAAKbFACJp2d0YP0f1kAEAAAAAmAYDiKSR + tTGqBw0AAAAAwKQZQCSNtJVxPKoHDgAAAADApBhAJI2lH2MuqgcPAAAAAMC4GUAkja3X4kxUDx8AAAAA + gHEygEgaa/fE/piN6iEEAAAAADAOBhBJY++m+CZOR/UgAgAAAAAYNQOIpIm1MX6L6mEEAAAAADBKBhBJ + E+3x+CXOR/VQAgAAAAAYBQOIpIl3V3waJ6J6MAEAAAAALJcBRNJUujZejuYL0quHEwAAAADAchhAJE21 + x+L7mI3qIQUAAAAAsBQGEElTb228HWeielABAAAAACyWAURSa1of+6J6WAEAAAAALIYBRFKrar4g/bOo + HlgAAAAAAAtlAJHUuq6LF+JCVA8uAAAAAID5GEAktbZ1cSCqhxcAAAAAwJUYQCS1umvCR2IBAAAAAItl + AJHUiZ6NU1E9yAAAAAAALmYAkdSZ7o2dMRfVAw0AAAAA4A8GEEmd6vrYHOeieqgBAAAAADQMIJI62atx + KPxrEAAAAACgYgCR1NkeiZ9jJqoHHAAAAAAwXAYQSZ3uumg+EutEVA85AAAAAGCYDCCSelHzkVi7o3rQ + AQAAAADDYwCR1Jvuj+/iQlQPPAAAAABgOAwgknrXe3E8qoceAAAAADAMBhBJveyF2BHVgw8AAAAA6D8D + iKTedk98Hj4SCwAAAACGxwAiqdetjI1xNKqHIAAAAADQTwYQSYPo8fg5qgchAAAAANA/BhBJg+mW+DRm + o3ogAgAAAAD9YQCRNLhejGNRPRQBAAAAgH4wgEgaZGujeQBWD0YAAAAAoPsMIJIG3aY4F9UDEgAAAADo + LgOIpMH3TByJ6iEJAAAAAHSTAUSS0nXRPBBnonpYAgAAAADdYgCRpD/1SZyI6oEJAAAAAHSHAUSSLuqJ + OBjVQxMAAAAA6AYDiCQV3Rjb4mxUD08AAAAAoN0MIJJ0hT6I36J6gAIAAAAA7WUAkaR5ejqah+WFqB6k + AAAAAED7GEAkaQGti6/iVFQPUwAAAACgXQwgkrTAVsfG8AXpAAAAANB+BhBJWmSPxc8xF9WDFQAAAACY + PgOIJC2hf8THcTaqhysAAAAAMF0GEElaYjfEM3EkqgcsAAAAADA9BhBJWmZro/lIrOohCwAAAABMhwFE + kkbUG1E9aAEAAACAyTOASNIIuyVOR/XABQAAAAAmxwAiSWPIR2IBAAAAwHQZQCRpTL0e56N6+AIAAAAA + 42UAkaQxdn8cjAtRPYQBAAAAgPEwgEjSmFsT38XZqB7EAAAAAMDoGUAkaUK9GUejehgDAAAAAKNlAJGk + CbY+mgfvTFQPZQAAAABgNAwgkjTh7orP41RUD2YAAAAAYPkMIJI0hf4vNsaBqB7OAAAAAMDyGEAkaYo9 + GT/EXFQPaQAAAABgaQwgkjTl7oj340xUD2oAAAAAYPEMIJLUkp6PfVE9rAEAAACAxTGASFKLui++jOqB + DQAAAAAsnAFEklrWqng1ZqJ6cAMAAAAA8zOASFJLezj2R/XwBgAAAACuzAAiSS3ulvgiqgc4AAAAAHB5 + BhBJ6kAvxdmoHuQAAAAAwKUMIJLUkZovSP81qoc5AAAAAPBXBhBJ6lAr4ss4H9VDHQAAAAD4nQFEkjrY + 63E4qgc7AAAAAGAAkaTO9nDsiNmoHvAAAAAAMGQGEEnqcFdH85FYJ6N6yAMAAADAUBlAJKkHNR+JtTeq + Bz0AAAAADJEBRJJ60v3xY1yI6oEPAAAAAENiAJGknrUpjkf10AcAAACAoTCASFIPeyl2RvXgBwAAAIAh + MIBIUk+7L76O2aj+AAAAAABAnxlAJKnHrY534khUfwQAAAAAoK8MIJLU8/4WT8UvUf0hAAAAAIA+MoBI + 0kC6I74IH4kFAAAAwBAYQCRpQF0bL8exqP4oAAAAAEBfGEAkaYDdFbuj+sMAAAAAAH1gAJGkAfd5+Egs + AAAAAPrIACJJA299nIzqjwQAAAAAdJUBRJJ01dWxKy5E9ccCAAAAALrGACJJ+m+b4kxUfzAAAAAAoEsM + IJKkv/RUHInqjwYAAAAAdIUBRJJ0STfF9jgb1R8PAAAAAGg7A4gk6bJ9FEej+gMCAAAAAG1mAJEkXbFn + wxekAwAAANA1BhBJ0rzdE9/G6aj+mAAAAABA2xhAJEkL6uZ4K36L6g8KAAAAALSJAUSStKieih3hI7EA + AAAAaDMDiCRp0d0dm+JcVH9cAAAAAGDaDCCSpCW1Kl6Io1H9gQEAAACAaTKASJKWVfOvQbZH9UcGAAAA + AKbFACJJWnY3RPMF6dUfGgAAAACYBgOIJGlk/SN8LwgAAAAAbbA7JEkaaT4SC2AYLsTj0fxLwNUAAAAt + clOsDEmSRt7rMRvVwQyAfmgGkLUhSZIkSZIkDaqH4lDMRXU4A6DbmgGk+fhDSZIkSZIkaXDdGt/H+aiO + ZwB0lwFEkiRJkiRJg+/tOB7VAQ2AbjKASJIkSZIkSenp+DV8NwhAPxhAJEmSJEmSpP90V3wVZ6I6pgHQ + HQYQSZIkSZIk6aLeiuYL0quDGgDdYACRJEmSJEmSipqPxNoWc1Ed1gBoNwOIJEmSJEmSdJnuiI/jbFTH + NQDaywAiSZIkSZIkzdNLsT+qAxsA7WQAkSRJkiRJkhbQQ/FNVEc2ANrHACJJkiRJkiQtsJuj+YL081Ed + 2wBoDwOIJEmSJEmStMiein1RHdwAaAcDiCRJkiRJkrSEmqPaV1Ed3QCYPgOIJEmSJEmStIw2xrmojm8A + TI8BRJIkSZIkSVpmD8SeqA5wAEyHAUSSJEmSJEkaUd/EbFSHOAAmywAiSZIkSZIkjbA341hUxzgAJscA + IkmSJEmSJI24B2NXNMe36igHwPgZQCRJkiRJkqQx1Xwk1umoDnMAjJcBRJIkSZIkSRpjG+NgVMc5AMbH + ACJJkiRJkiSNuftje/hILIDJMYBIkiRJkiRJE+qLOBHVoQ6A0TKASJIkSZIkSRPs1dgd1bEOgNExgEiS + JEmSJEkT7oH4PmaiOtoBsHwGEEmSJEmSJGkK3RwfxNGoDncALI8BRJIkSZIkSZpS18azsTOq4x0AS2cA + kSRJkiRJkqbcuvg6fCQWwOgYQCRJkiRJkqQWdGO8FsejOuQBsDgGEEmSJEmSJKlF3Rd7ojrmAbBwBhBJ + kiRJkiSphX0V1UEPgIUxgEiSJEmSJEktbX2cjeqwB8CVGUAkSZIkSZKklrc3quMeAJdnAJEkSZIkSZI6 + 0OaYierIB8ClDCCSJEmSJElSR3oqjkV16APgrwwgkiRJkiRJUoe6JXbEuagOfgD8zgAiSZIkSZIkdaxr + 4uM4HtXRDwADiCRJkiRJktTZno/mC9KbI191/AMYMgOIJEmSJEmS1OHuj+/jTFQHQIChMoBIkiRJkiRJ + HW9NvBtHojoCAgyRAUSSJEmSJEnqSc/Gv8JHYgEYQCRJkiRJkqRedV9sjvNRHQQBhsIAIkmSJEmSJPWs + 1fFSHIvqKAgwBAYQSZIkSZIkqac9GL9EdRgE6DsDiCRJkiRJktTjbom3ozoOAvSZAUSSJEmSJEkaQM2/ + BjkT1ZEQoI8MIJIkSZIkSdJAWhnbozoUAvSNAUSSJEmSJEkaWBujOhYC9IkBRJIkSZIkSRpgj8ThqI6G + AH1gAJEkSZIkSZIG2m2xJZojYXU8BOgyA4gkSZIkSZI08N6Lk1EdEAG6ygAiSZIkSZIk6arnYnf41yBA + XxhAJEmSJEmSJP27u+K7OBvVMRGgSwwgkiRJkiRJkv5S85FYv0V1UAToCgOIJEmSJEmSpEt6NrZHdVQE + 6AIDiCRJkiRJkqSy5nD4WfhILKCLDCCSJEmSJEmSrthrcTCqAyNAWxlAJEmSJEmSJM3b47ElqiMjQBsZ + QCRJkiRJkiQtqFvj/TgX1bERoE0MIJIkSZIkSZIW3NXxQuyL6uAI0BYGEEmSJEmSJEmL7t74NqqjI0Ab + GEAkSZIkSZIkLakV8U6cjer4CDBNBhBJkiRJkiRJy+qxOBDVARJgWgwgkiRJkiRJkkbS9zEX1SESYNIM + IJIkSZIkSZJG1ltxMqpjJMAkGUAkSZIkSZIkjbQHYl/41yDANBlAJEmSJEmSJI2lLeEL0oFpMYBIkiRJ + kiRJGlvNR2Idjuo4CTBOBhBJkiRJkiRJY+2e+DWaY2R1pAQYBwOIJEmSJEmSpIn0dZyI6lAJMGoGEEmS + JEmSJEkT67VoviC9OlYCjJIBRJIkSZIkSdJEeyi2xvmojpYAo2AAkSRJkiRJkjTxbo2P41hUh0uA5TKA + SJIkSZIkSZpKK+KF2B3V8RJgOQwgkiRJkiRJkqbaffFdzER1xARYCgOIJEmSJEmSpKm3Jt6Mk1EdMgEW + ywAiSZIkSZIkqRX9PZovSN8X1TETYDEMIJIkSZIkSZJa1fXxdVQHTYCFMoBIkiRJkiRJamXPRHPArA6b + APMxgEiSJEmSJElqdQeiOm4CXIkBRJIkSZIkSVLr+zzmojpyAlQMIJIkSZIkSZI60VNxMqpDJ8DFDCCS + JEmSJEmSOtPa2BkzUR08Af5gAJEkSZIkSZLUqVbEJ3EqqqMnQMMAIkmSJEmSJKmTvRjNF6Q3R87q+AkM + mwFEkiRJkiRJUmd7MH6Is1EdQIHhMoBIkiRJkiRJ6nRr4oM4FtURFBgmA4gkSZIkSZKkXrQhfo25qI6h + wLAYQCRJkiRJkiT1puYjsb6MmagOosBwGEAkSZIkSZIk9aqb47U4HtVRFBgGA4gkSZIkSZKkXvZ4/BLV + YRToPwOIJEmSJEmSpN52R7wX1XEU6DcDiCRJkiRJkqRed3U8FaejOpIC/WQAkSRJkiRJkjSI7oyfozqU + Av1jAJEkSZIkSZI0mP4W70R1LAX6xQAiSZIkSZIkaXA1X5B+JKqjKdAPBhBJkiRJkiRJg+y22BrV4RTo + PgOIJEmSJEmSpEH3YfiCdOgfA4gkSZIkSZKkwfdC7Iu5qA6pQPcYQCRJkiRJkiQp3Rk/xLmojqlAtxhA + JEmSJEmSJOlPNR+J5QvSofsMIJIkSZIkSZJ0Uc/Hv6I6qgLdYACRJEmSJEmSpKLb48vwkVjQTQYQSZIk + SZIkSbpCb8ehqA6sQHsZQCRJkiRJkiRpntbH1qiOrEA7GUAkSZIkSZIkaQGtjU1xJqpjK9AuBhBJkiRJ + kiRJWmDXxsuxP6qDK9AeBhBJkiRJkiRJWmQPxg9RHV2BdjCASJIkSZIkSdISWh0fhI/EgnYygEiSJEmS + JEnSMmq+IP1gVAdYYHoMIJIkSZIkSZK0zG6IbVEdYYHpMIBIkiRJkiRJ0oh6O3wkFrSDAUSSJEmSJEmS + Rti9cSiqgywwOQYQSZIkSZIkSRpDW+NcVIdZYPwMIJIkSZIkSZI0pt6ME1EdZ4HxMoBIkiRJkiRJ0hhb + F/uiOcZWR1pgPAwgkiRJkiRJkjSBvouTUR1qgdEzgEiSJEmSJEnShHo9DkZ1rAVGywAiSZIkSZIkSRPs + kdge56M62gKjYQCRJEmSJEmSpAl3e2yK41EdboHlM4BIkiRJkiRJ0hS6Pl6KvVEdb4HlMYBIkiRJkiRJ + 0hR7KLbETFRHXGBpDCCSJEmSJEmSNOVui3fiVFSHXGDxDCCSJEmSJEmS1IKui8djf1THXGBxDCCSJEmS + JEmS1KJujW+iOugCC2cAkSRJkiRJkqQW9lzMRXXYBeZnAJEkSZIkSZKkFnckquMucGUGEEmSJEmSJElq + eZujOvACl2cAkSRJkiRJkqQO9FScierQC1zKACJJkiRJkiRJHak55u6K2agOvsD/GEAkSZIkSZIkqUNd + H5/G2aiOvsDvDCCSJEmSJEmS1MFejkPRHHmr4y8MnQFEkiRJkiRJkjraI7EtzkV1AIYhM4BIkiRJkiRJ + Uoe7JT6J41EdgWGoDCCSJEmSJEmS1IOaj8TaHXNRHYNhaAwgkiRJkiRJktSTHo6vYyaqgzAMiQFEkiRJ + kiRJknrUTfFWnIjqKAxDYQCRJEmSJEmSpB72dPwS1WEYhsAAIkmSJEmSJEk97a74OKrjMPSdAUSSJEmS + JEmSetx18WKcjOpIDH1lAJEkSZIkSZKkAfRgbI/qUAx9ZACRJEmSJEmSpIG0Oj6M6lgMfWMAkSRJkiRJ + kqSB9Wwcj+poDH1hAJEkSZIkSZKkAXZb/BTV4Rj6wAAiSZIkSZIkSQPu4zgb1QEZuswAIkmSJEmSJEkD + b0MciLmoDsnQRQYQSZIkSZIkSdJVd0TzkVjnozomQ9cYQCRJkiRJkiRJ/21THIvqoAxdYgCRJEmSJEmS + JP2lF2JXVEdl6AoDiCRJkiRJkiTpkm6N78JHYtFVBhBJkiRJkiRJ0mX7MA5FdWCGNjOASJIkSZIkSZKu + 2NOxPaojM7SVAUSSJEmSJEmSNG93xOdxJqpjM7SNAUSSJEmSJEmStKBuiNfiQFQHZ2gTA4gkSZIkSZIk + aVE9GtuiOjpDWxhAJEmSJEmSJEmL7tb4OHwkFm1lAJEkSZIkSZIkLalr4rn4LaoDNEyTAUSSJEmSJEmS + tKxuiZ+jOkLDtBhAJEmSJEmSJEkj6f2YieoYDZNmAJEkSZIkSZIkjay74mhUB2mYJAOIJEmSJEmSJGnk + NR+JNRvVYRomwQAiSZIkSZIkSRpLG+NsVMdpGDcDiCRJkiRJkiRpbN0dB6M5RldHahgXA4gkSZIkSZIk + aaxdF1vidFSHahgHA4gkSZIkSZIkaSK9EYejOlbDqBlAJEmSJEmSJEkT6/HYETNRHa1hVAwgkiRJkiRJ + kqSJdmdsjhNRHa5hFAwgkiRJkiRJkqSJd0O8GvujOl7DchlAJEmSJEmSJElT67H4MXwkFqNmAJEkSZIk + SZIkTbXmSP1enI7qkA1LYQCRJEmSJEmSJE29FfFUHIjqmA2LZQCRJEmSJEmSJLWmu+KbqA7asBgGEEmS + JEmSJElSq2q+IP2FqI7asFAGEEmSJEmSJElSK7s5jkR13Ib5GEAkSZIkSZIkSa3uy6gO3HAlBhBJkiRJ + kiRJUut7Js5GdeiGigFEkiRJkiRJktSJ1sXumIvq4A1/ZgCRJEmSJEmSJHWmlbE5zkd19IY/GEAkSZIk + SZIkSZ3r1Tgc/jUIl2MAkSRJkiRJkiR1ssfi55iJ6gDOsBlAJEmSJEmSJEmd7eb4LE5GdQRnuAwgkiRJ + kiRJkqTO91rsjeoQzjAZQCRJkiRJkiRJvejR+C5mozqIMywGEEmSJEmSJElSb7ox3osTUR3FGQ4DiCRJ + kiRJkiSpdz0fO6I6jDMMBhBJkiRJkiRJUi+7JzZHdRyn/wwgkiRJkiRJkqTedn28HsejOpLTXwYQSZIk + SZIkSVLvezx+iepQTj8ZQCRJkiRJkiRJg+i22BTVsZz+MYBIkiRJkiRJkgbVP8NHYvWfAUSSJEmSJEmS + NLjWxb+iOpzTDwYQSZIkSZIkSdJg+zTORXVAp9sMIJIkSZIkSZKkQfdiHI7qiE53GUAkSZIkSZIkSYOv + +YL0HTEb1TGd7jGASJIkSZIkSZL0nzbHiagO6nSLAUSSJEmSJEmSpD/1fOyL6qhOdxhAJEmSJEmSJEm6 + qNWxLc5HdVyn/QwgkiRJkiRJkiRdpo/DF6R3kwFEkiRJkiRJkqQr9EzsjOrITnsZQCRJkiRJkiRJmqe7 + 4us4HdWxnfYxgEiSJEmSJEmStIBWxZtxMKqDO+1iAJEkSZIkSZIkaYFdHU/Ez1Ed3WkPA4gkSZIkSZIk + SYvsjvg0zkR1fGf6DCCSJEmSJEmSJC2hlbEhDkd1gGe6DCCSJEmSJEmSJC2j5l+D/BLVEZ7pMYBIkiRJ + kiRJkjSCPoi5qI7xTJ4BRJIkSZIkSZKkEbUuTkV1kGeyDCCSJEmSJEmSJI247VEd5ZkcA4gkSZIkSZIk + SWPorZiN6jjP+BlAJEmSJEmSJEkaU/fGb9Ec46sjPeNjAJEkSZIkSZIkaYytjB/ibFSHesbDACJJkiRJ + kiRJ0gRqPhLrWFTHekbPACJJkiRJkiRJ0oR6Mn6NmaiO9oyOAUSSJEmSJEmSpAm2Lr6MU1Ed7hkNA4gk + SZIkSZIkSRPuhtgYB6M63rN8BhBJkiRJkiRJkqbU+tgWs1Ed8Vk6A4gkSZIkSZIkSVPsrvgwzkR1yGdp + DCCSJEmSJEmSJE256+L5OBDVMZ/FM4BIkiRJkiRJktSS7otvojroszgGEEmSJEmSJEmSWtTq+GdUR30W + zgAiSZIkSZIkSVILa/41yG9RHfeZnwFEkiRJkiRJkqSWtiq+jurAz5UZQCRJkiRJkiRJankbYiaqQz81 + A4gkSZIkSZIkSR3ontgT1bGfSxlAJEmSJEmSJEnqSDfGV+Ffg8zPACJJkiRJkiRJUsfaGEejOvzzOwOI + JEmSJEmSJEkd7PHYEbNRDQBDZwCRJEmSJEmSJKmjrY4v4lRUI8CQGUAkSZIkSZIkSep4b8S+/9/e/bva + HMdxHDcYdCdJkiTdP8Ao3SQZZZDxJoPBIKNkkJLRJBkkmSQZZTLJIJkMBt1BkiRJhjvc4ZbX94qo98W9 + 9/z4/ng86lnn/Avn1Xl/UjUEDDUDCAAAAAAA9MCx9Cg1P/xXg8DQMoAAAAAAAEBPbEvX06dUjQJDygAC + AAAAAAA9czY9T9UwMJQMIAAAAAAA0EOH071UjQNDyAACAAAAAAA9tStdSR9SNRL0OQMIAAAAAAD03Hx6 + lqqhoK8ZQAAAAAAAYACaMeBOWk7VYNC3DCAAAAAAADAQM+l8GsJJLAMIAAAAAAAMTPNA+otUDQd9yQAC + AAAAAAADdTctpWpA6HoGEAAAAAAAGLAz6X2qRoQuZwABAAAAAICBm03NSaxmNKjGhC5mAAEAAAAAAFY0 + J7E+p2pQ6FoGEAAAAAAA4JdTaSFVo0KXMoAAAAAAAAB/2JGepsVUjQtdyAACAAAAAACUbqZ3qRoY2p4B + BAAAAAAAWNXp9DJVI0ObM4AAAAAAAAB/dSA9TF9TNTa0MQMIAAAAAADwT3vT1dSVB9INIAAAAAAAwH/Z + nOZT80D6cqqGh7ZkAAEAAAAAANakOYl1O31L1fjQhgwgAAAAAADAmu1O59LbVA0Q084AAgAAAAAArNvB + 1JzEqkaIaWYAAQAAAAAANmR7upaqIWJaGUAAAAAAAICRaP4NspiqQWLSGUAAAAAAAICRasNJLAMIAAAA + AAAwcpdTNUxMKgMIAAAAAAAwFofSu7ScqpFinBlAAAAAAACAsdmTHqdJvw1iAAEAAAAAAMbuavqYqrFi + HBlAAAAAAACAiZhPL9NSqkaLUWYAAQAAAAAAJmYu3U9fUjVcjCoDCAAAAAAAMFFb0+W0kKrxYhQZQAAA + AAAAgKk4mZ6kZqyoRoyNZAABAAAAAACmZn+6kb6lashYbwYQAAAAAABgqrakc+lNqsaM9WQAAQAAAAAA + WuFoepCqQWOtGUAAAAAAAIDWmE0XUzVqrCUDCAAAAAAA0Don0kZOYhlAAAAAAACAVtqX1nsSywACAAAA + AAC02vm0lKqhY7UMIAAAAAAAQOsdSa9SNXZUGUAAAAAAAIBO2JnupWbcqEaP3zOAAAAAAAAAnXIpfUjV + 8PEzAwgAAAAAANA5x9PztNq/QQwgAAAAAABAJ21P99PXZAABAAAAAAB65Up6nQwgAAAAAABArxxNT9LP + k1gGEAAAAAAAoBdm0q30OTUjiAEEAAAAAADojQupeSB9buUbAAAAAABATxxJsz8+AgAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAEA/bNr0HcFm85gTYsj0AAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/FormCruiserConfing.Designer.cs b/ProjectPlane/ProjectPlane/FormCruiserConfing.Designer.cs new file mode 100644 index 0000000..aee4338 --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruiserConfing.Designer.cs @@ -0,0 +1,370 @@ +namespace ProjectCruiser +{ + partial class FormCruiserConfing + { + /// + /// 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() + { + groupBoxConfing = new GroupBox(); + groupBoxColors = new GroupBox(); + panelPurple = new Panel(); + panelBlack = new Panel(); + panelGray = new Panel(); + panelWhite = new Panel(); + panelYellow = new Panel(); + panelBlue = new Panel(); + panelGreen = new Panel(); + panelRed = new Panel(); + checkBoxWeapon = new CheckBox(); + checkBoxBoat = new CheckBox(); + checkBoxHelicopterArea = new CheckBox(); + numericUpDownWeight = new NumericUpDown(); + labelWeight = new Label(); + numericUpDownSpeed = new NumericUpDown(); + labelSpeed = new Label(); + labelModifiedObject = new Label(); + labelSimpleObject = new Label(); + pictureBoxObject = new PictureBox(); + buttonAdd = new Button(); + buttonCancel = new Button(); + panelObject = new Panel(); + labelAdditionalColor = new Label(); + labelBodyColor = new Label(); + groupBoxConfing.SuspendLayout(); + groupBoxColors.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)numericUpDownWeight).BeginInit(); + ((System.ComponentModel.ISupportInitialize)numericUpDownSpeed).BeginInit(); + ((System.ComponentModel.ISupportInitialize)pictureBoxObject).BeginInit(); + panelObject.SuspendLayout(); + SuspendLayout(); + // + // groupBoxConfing + // + groupBoxConfing.Controls.Add(groupBoxColors); + groupBoxConfing.Controls.Add(checkBoxWeapon); + groupBoxConfing.Controls.Add(checkBoxBoat); + groupBoxConfing.Controls.Add(checkBoxHelicopterArea); + groupBoxConfing.Controls.Add(numericUpDownWeight); + groupBoxConfing.Controls.Add(labelWeight); + groupBoxConfing.Controls.Add(numericUpDownSpeed); + groupBoxConfing.Controls.Add(labelSpeed); + groupBoxConfing.Controls.Add(labelModifiedObject); + groupBoxConfing.Controls.Add(labelSimpleObject); + groupBoxConfing.Dock = DockStyle.Left; + groupBoxConfing.Location = new Point(0, 0); + groupBoxConfing.Name = "groupBoxConfing"; + groupBoxConfing.Size = new Size(626, 262); + groupBoxConfing.TabIndex = 0; + groupBoxConfing.TabStop = false; + groupBoxConfing.Text = "Параметры"; + // + // groupBoxColors + // + groupBoxColors.Controls.Add(panelPurple); + groupBoxColors.Controls.Add(panelBlack); + groupBoxColors.Controls.Add(panelGray); + groupBoxColors.Controls.Add(panelWhite); + groupBoxColors.Controls.Add(panelYellow); + groupBoxColors.Controls.Add(panelBlue); + groupBoxColors.Controls.Add(panelGreen); + groupBoxColors.Controls.Add(panelRed); + groupBoxColors.Location = new Point(327, 26); + groupBoxColors.Name = "groupBoxColors"; + groupBoxColors.Size = new Size(280, 154); + groupBoxColors.TabIndex = 9; + groupBoxColors.TabStop = false; + groupBoxColors.Text = "Цвета"; + // + // panelPurple + // + panelPurple.BackColor = Color.Purple; + panelPurple.Location = new Point(217, 96); + panelPurple.Name = "panelPurple"; + panelPurple.Size = new Size(48, 47); + panelPurple.TabIndex = 1; + // + // panelBlack + // + panelBlack.BackColor = Color.Black; + panelBlack.Location = new Point(149, 96); + panelBlack.Name = "panelBlack"; + panelBlack.Size = new Size(48, 47); + panelBlack.TabIndex = 1; + // + // panelGray + // + panelGray.BackColor = Color.Gray; + panelGray.Location = new Point(82, 96); + panelGray.Name = "panelGray"; + panelGray.Size = new Size(48, 47); + panelGray.TabIndex = 1; + // + // panelWhite + // + panelWhite.BackColor = Color.White; + panelWhite.Location = new Point(17, 96); + panelWhite.Name = "panelWhite"; + panelWhite.Size = new Size(48, 47); + panelWhite.TabIndex = 1; + // + // panelYellow + // + panelYellow.BackColor = Color.Yellow; + panelYellow.Location = new Point(217, 31); + panelYellow.Name = "panelYellow"; + panelYellow.Size = new Size(48, 47); + panelYellow.TabIndex = 1; + // + // panelBlue + // + panelBlue.BackColor = Color.Blue; + panelBlue.Location = new Point(149, 31); + panelBlue.Name = "panelBlue"; + panelBlue.Size = new Size(48, 47); + panelBlue.TabIndex = 1; + // + // panelGreen + // + panelGreen.BackColor = Color.Green; + panelGreen.Location = new Point(82, 31); + panelGreen.Name = "panelGreen"; + panelGreen.Size = new Size(48, 47); + panelGreen.TabIndex = 1; + // + // panelRed + // + panelRed.BackColor = Color.Red; + panelRed.Location = new Point(17, 31); + panelRed.Name = "panelRed"; + panelRed.Size = new Size(48, 47); + panelRed.TabIndex = 0; + // + // checkBoxWeapon + // + checkBoxWeapon.AutoSize = true; + checkBoxWeapon.Location = new Point(6, 217); + checkBoxWeapon.Name = "checkBoxWeapon"; + checkBoxWeapon.Size = new Size(202, 24); + checkBoxWeapon.TabIndex = 8; + checkBoxWeapon.Text = "Признак наличие пушки"; + checkBoxWeapon.UseVisualStyleBackColor = true; + // + // checkBoxBoat + // + checkBoxBoat.AutoSize = true; + checkBoxBoat.Location = new Point(6, 169); + checkBoxBoat.Name = "checkBoxBoat"; + checkBoxBoat.Size = new Size(215, 24); + checkBoxBoat.TabIndex = 7; + checkBoxBoat.Text = "Признак наличие шлюпок"; + checkBoxBoat.UseVisualStyleBackColor = true; + // + // checkBoxHelicopterArea + // + checkBoxHelicopterArea.AutoSize = true; + checkBoxHelicopterArea.Location = new Point(6, 123); + checkBoxHelicopterArea.Name = "checkBoxHelicopterArea"; + checkBoxHelicopterArea.Size = new Size(321, 24); + checkBoxHelicopterArea.TabIndex = 6; + checkBoxHelicopterArea.Text = "Признак наличие вертолетной площадки"; + checkBoxHelicopterArea.UseVisualStyleBackColor = true; + // + // numericUpDownWeight + // + numericUpDownWeight.Location = new Point(94, 68); + numericUpDownWeight.Maximum = new decimal(new int[] { 1000, 0, 0, 0 }); + numericUpDownWeight.Minimum = new decimal(new int[] { 100, 0, 0, 0 }); + numericUpDownWeight.Name = "numericUpDownWeight"; + numericUpDownWeight.Size = new Size(114, 27); + numericUpDownWeight.TabIndex = 5; + numericUpDownWeight.Value = new decimal(new int[] { 100, 0, 0, 0 }); + // + // labelWeight + // + labelWeight.AutoSize = true; + labelWeight.Location = new Point(27, 70); + labelWeight.Name = "labelWeight"; + labelWeight.Size = new Size(36, 20); + labelWeight.TabIndex = 4; + labelWeight.Text = "Вес:"; + // + // numericUpDownSpeed + // + numericUpDownSpeed.Location = new Point(94, 32); + numericUpDownSpeed.Maximum = new decimal(new int[] { 1000, 0, 0, 0 }); + numericUpDownSpeed.Minimum = new decimal(new int[] { 100, 0, 0, 0 }); + numericUpDownSpeed.Name = "numericUpDownSpeed"; + numericUpDownSpeed.Size = new Size(114, 27); + numericUpDownSpeed.TabIndex = 3; + numericUpDownSpeed.Value = new decimal(new int[] { 100, 0, 0, 0 }); + // + // labelSpeed + // + labelSpeed.AutoSize = true; + labelSpeed.Location = new Point(12, 32); + labelSpeed.Name = "labelSpeed"; + labelSpeed.Size = new Size(76, 20); + labelSpeed.TabIndex = 2; + labelSpeed.Text = "Скорость:"; + // + // labelModifiedObject + // + labelModifiedObject.BorderStyle = BorderStyle.FixedSingle; + labelModifiedObject.Location = new Point(476, 203); + labelModifiedObject.Name = "labelModifiedObject"; + labelModifiedObject.Size = new Size(131, 44); + labelModifiedObject.TabIndex = 1; + labelModifiedObject.Text = "Продвинутый"; + labelModifiedObject.TextAlign = ContentAlignment.MiddleCenter; + labelModifiedObject.MouseDown += labelObject_MouseDown; + // + // labelSimpleObject + // + labelSimpleObject.BorderStyle = BorderStyle.FixedSingle; + labelSimpleObject.Location = new Point(327, 203); + labelSimpleObject.Name = "labelSimpleObject"; + labelSimpleObject.Size = new Size(130, 44); + labelSimpleObject.TabIndex = 0; + labelSimpleObject.Text = "Простой"; + labelSimpleObject.TextAlign = ContentAlignment.MiddleCenter; + labelSimpleObject.MouseDown += labelObject_MouseDown; + // + // pictureBoxObject + // + pictureBoxObject.Location = new Point(11, 56); + pictureBoxObject.Name = "pictureBoxObject"; + pictureBoxObject.Size = new Size(183, 125); + pictureBoxObject.TabIndex = 1; + pictureBoxObject.TabStop = false; + // + // buttonAdd + // + buttonAdd.Location = new Point(632, 212); + buttonAdd.Name = "buttonAdd"; + buttonAdd.Size = new Size(94, 29); + buttonAdd.TabIndex = 2; + buttonAdd.Text = "Добавить"; + buttonAdd.UseVisualStyleBackColor = true; + buttonAdd.Click += buttonAdd_Click; + // + // buttonCancel + // + buttonCancel.Location = new Point(740, 212); + buttonCancel.Name = "buttonCancel"; + buttonCancel.Size = new Size(94, 29); + buttonCancel.TabIndex = 3; + buttonCancel.Text = "Отмена"; + buttonCancel.UseVisualStyleBackColor = true; + // + // panelObject + // + panelObject.AllowDrop = true; + panelObject.Controls.Add(labelAdditionalColor); + panelObject.Controls.Add(labelBodyColor); + panelObject.Controls.Add(pictureBoxObject); + panelObject.Location = new Point(632, 12); + panelObject.Name = "panelObject"; + panelObject.Size = new Size(205, 194); + panelObject.TabIndex = 4; + panelObject.DragDrop += PanelObject_DragDrop; + panelObject.DragEnter += PanelObject_DragEnter; + // + // labelAdditionalColor + // + labelAdditionalColor.AllowDrop = true; + labelAdditionalColor.BorderStyle = BorderStyle.FixedSingle; + labelAdditionalColor.Location = new Point(108, 11); + labelAdditionalColor.Name = "labelAdditionalColor"; + labelAdditionalColor.Size = new Size(83, 36); + labelAdditionalColor.TabIndex = 3; + labelAdditionalColor.Text = "Доп. цвет"; + labelAdditionalColor.TextAlign = ContentAlignment.MiddleCenter; + labelAdditionalColor.DragDrop += labelAdditionalColor_DragDrop; + labelAdditionalColor.DragEnter += labelAdditionalColor_DragEnter; + // + // labelBodyColor + // + labelBodyColor.AllowDrop = true; + labelBodyColor.BorderStyle = BorderStyle.FixedSingle; + labelBodyColor.Location = new Point(11, 11); + labelBodyColor.Name = "labelBodyColor"; + labelBodyColor.Size = new Size(83, 36); + labelBodyColor.TabIndex = 2; + labelBodyColor.Text = "Цвет"; + labelBodyColor.TextAlign = ContentAlignment.MiddleCenter; + labelBodyColor.DragDrop += labelBodyColor_DragDrop; + labelBodyColor.DragEnter += labelBodyColor_DragEnter; + // + // FormCruiserConfing + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(838, 262); + Controls.Add(panelObject); + Controls.Add(buttonCancel); + Controls.Add(buttonAdd); + Controls.Add(groupBoxConfing); + Name = "FormCruiserConfing"; + Text = "Создание объекта"; + groupBoxConfing.ResumeLayout(false); + groupBoxConfing.PerformLayout(); + groupBoxColors.ResumeLayout(false); + ((System.ComponentModel.ISupportInitialize)numericUpDownWeight).EndInit(); + ((System.ComponentModel.ISupportInitialize)numericUpDownSpeed).EndInit(); + ((System.ComponentModel.ISupportInitialize)pictureBoxObject).EndInit(); + panelObject.ResumeLayout(false); + ResumeLayout(false); + } + + #endregion + + private GroupBox groupBoxConfing; + private Label labelSimpleObject; + private Label labelModifiedObject; + private Label labelWeight; + private NumericUpDown numericUpDownSpeed; + private Label labelSpeed; + private NumericUpDown numericUpDownWeight; + private CheckBox checkBoxHelicopterArea; + private CheckBox checkBoxBoat; + private CheckBox checkBoxWeapon; + private GroupBox groupBoxColors; + private Panel panelPurple; + private Panel panelBlack; + private Panel panelGray; + private Panel panelWhite; + private Panel panelYellow; + private Panel panelBlue; + private Panel panelGreen; + private Panel panelRed; + private PictureBox pictureBoxObject; + private Button buttonAdd; + private Button buttonCancel; + private Panel panelObject; + private Label labelBodyColor; + private Label labelAdditionalColor; + } +} \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/FormCruiserConfing.cs b/ProjectPlane/ProjectPlane/FormCruiserConfing.cs new file mode 100644 index 0000000..fe9b6c1 --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruiserConfing.cs @@ -0,0 +1,176 @@ +using ProjectCruiser.Drawnings; +using ProjectCruiser.Entities; + +namespace ProjectCruiser +{ + /// + /// Форма конфигурации объекта + /// + public partial class FormCruiserConfing : Form + { + /// + /// Объект - прорисовка крейсера + /// + private DrawningCruiser _cruiser; + + /// + /// Событие для передачи объекта + /// + private event Action? CruiserDelegate; + + /// + /// Привязка внешнего метода к событию + /// + /// + public void AddEvent(Action cruiserDelegate) + { + CruiserDelegate += cruiserDelegate; + } + + /// + /// Конструктор + /// + public FormCruiserConfing() + { + InitializeComponent(); + + panelRed.MouseDown += Panel_MouseDown; + panelGreen.MouseDown += Panel_MouseDown; + panelBlue.MouseDown += Panel_MouseDown; + panelYellow.MouseDown += Panel_MouseDown; + panelWhite.MouseDown += Panel_MouseDown; + panelGray.MouseDown += Panel_MouseDown; + panelBlack.MouseDown += Panel_MouseDown; + panelPurple.MouseDown += Panel_MouseDown; + //TODO buttonCancel.Click with lambda с закрытием формы + buttonCancel.Click += (sender, e) => Close(); + } + + /// + /// Прорисовка объекта + /// + private void DrawObject() + { + Bitmap bmp = new(pictureBoxObject.Width, pictureBoxObject.Height); + Graphics gr = Graphics.FromImage(bmp); + _cruiser?.SetPictureSize(pictureBoxObject.Width, pictureBoxObject.Height); + _cruiser?.SetPosition(15, 15); + _cruiser?.DrawTransport(gr); + pictureBoxObject.Image = bmp; + } + + /// + /// Передаем информацию при нажатии на Label + /// + /// labelSimpleObject + /// labelSimpleObject + private void labelObject_MouseDown(object sender, MouseEventArgs e) + { + (sender as Label)?.DoDragDrop((sender as Label)?.Name ?? string.Empty, DragDropEffects.Move | DragDropEffects.Copy); + } + + /// + /// Проверка получаемой информации (ее типа на соответствие требуемому) + /// + /// + /// + private void PanelObject_DragEnter(object sender, DragEventArgs e) + { + e.Effect = e.Data?.GetDataPresent(DataFormats.Text) ?? false ? DragDropEffects.Copy : DragDropEffects.None; + + } + + /// + /// Действия при приеме перетаскиваемой информации + /// + /// + /// + private void PanelObject_DragDrop(object sender, DragEventArgs e) + { + switch (e.Data?.GetData(DataFormats.Text)?.ToString()) + { + case "labelSimpleObject": + _cruiser = new DrawningCruiser((int)numericUpDownSpeed.Value, (double)numericUpDownWeight.Value, Color.White); + break; + case "labelModifiedObject": + _cruiser = new + DrawningMilitaryCruiser((int)numericUpDownSpeed.Value, (double)numericUpDownWeight.Value, Color.White, + Color.Black, checkBoxHelicopterArea.Checked, checkBoxBoat.Checked, checkBoxWeapon.Checked); + break; + } + DrawObject(); + } + + /// + /// Передаем информацию при нажатии на Panel + /// + /// + /// + private void Panel_MouseDown(object sender, MouseEventArgs e) + { + //TODO отправка цвета в Drag&Drop + (sender as Control)?.DoDragDrop((sender as Control).BackColor, DragDropEffects.Move | DragDropEffects.Copy); + } + + // TODO Реализовать логику смены цветов: основного и дополнительного (для продвинутого объекта) + + private void labelBodyColor_DragEnter(object sender, DragEventArgs e) + { + if (e.Data.GetDataPresent(typeof(Color))) + { + e.Effect = DragDropEffects.Copy; + } + else + { + e.Effect = DragDropEffects.None; + } + } + + private void labelBodyColor_DragDrop(object sender, DragEventArgs e) + { + if (_cruiser != null) + { + _cruiser.EntityCruiser.setBodyColor((Color)e.Data.GetData(typeof(Color))); + DrawObject(); + } + } + + private void labelAdditionalColor_DragEnter(object sender, DragEventArgs e) + { + if (_cruiser is DrawningCruiser) + { + if (e.Data.GetDataPresent(typeof(Color))) + { + e.Effect = DragDropEffects.Copy; + } + else + { + e.Effect = DragDropEffects.None; + } + } + } + + private void labelAdditionalColor_DragDrop(object sender, DragEventArgs e) + { + if (_cruiser.EntityCruiser is EntityMilitaryCruiser militaryCruiser) + { + militaryCruiser.setAdditionalColor((Color)e.Data.GetData(typeof(Color))); + } + DrawObject(); + } + + /// + /// Передача объекта + /// + /// + /// + private void buttonAdd_Click(object sender, EventArgs e) + { + if (_cruiser != null) + { + CruiserDelegate?.Invoke(_cruiser); + Close(); + } + } + } +} diff --git a/ProjectPlane/ProjectPlane/FormCruiserConfing.resx b/ProjectPlane/ProjectPlane/FormCruiserConfing.resx new file mode 100644 index 0000000..af32865 --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruiserConfing.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/FormCruisersCollection.Designer.cs b/ProjectPlane/ProjectPlane/FormCruisersCollection.Designer.cs new file mode 100644 index 0000000..21dab30 --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruisersCollection.Designer.cs @@ -0,0 +1,346 @@ +namespace ProjectCruiser +{ + partial class FormCruisersCollection + { + /// + /// 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() + { + groupBoxTools = new GroupBox(); + buttonCreateCompany = new Button(); + panelStorage = new Panel(); + buttonCollectionDel = new Button(); + listBoxCollection = new ListBox(); + buttonCollecctionAdd = new Button(); + radioButtonList = new RadioButton(); + radioButtonMassive = new RadioButton(); + textBoxCollectionName = new TextBox(); + labelCollectionName = new Label(); + comboBoxSelectorCompany = new ComboBox(); + panelCompanyTools = new Panel(); + ButtonAddCruiser = new Button(); + buttonRefresh = new Button(); + ButtonRemoveCruiser = new Button(); + maskedTextBoxPosision = new MaskedTextBox(); + buttonGetToTest = new Button(); + pictureBoxCruiser = new PictureBox(); + menuStrip = new MenuStrip(); + файлToolStripMenuItem = new ToolStripMenuItem(); + saveToolStripMenuItem = new ToolStripMenuItem(); + loadToolStripMenuItem = new ToolStripMenuItem(); + saveFileDialog = new SaveFileDialog(); + openFileDialog = new OpenFileDialog(); + groupBoxTools.SuspendLayout(); + panelStorage.SuspendLayout(); + panelCompanyTools.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)pictureBoxCruiser).BeginInit(); + menuStrip.SuspendLayout(); + SuspendLayout(); + // + // groupBoxTools + // + groupBoxTools.Controls.Add(buttonCreateCompany); + groupBoxTools.Controls.Add(panelStorage); + groupBoxTools.Controls.Add(comboBoxSelectorCompany); + groupBoxTools.Controls.Add(panelCompanyTools); + groupBoxTools.Dock = DockStyle.Right; + groupBoxTools.Location = new Point(631, 28); + groupBoxTools.Name = "groupBoxTools"; + groupBoxTools.Size = new Size(222, 651); + groupBoxTools.TabIndex = 0; + groupBoxTools.TabStop = false; + groupBoxTools.Text = "инструменты"; + // + // buttonCreateCompany + // + buttonCreateCompany.Location = new Point(21, 345); + buttonCreateCompany.Name = "buttonCreateCompany"; + buttonCreateCompany.Size = new Size(186, 27); + buttonCreateCompany.TabIndex = 7; + buttonCreateCompany.Text = "Создать компанию"; + buttonCreateCompany.UseVisualStyleBackColor = true; + buttonCreateCompany.Click += ButtonCreateCompany_Click; + // + // panelStorage + // + panelStorage.Controls.Add(buttonCollectionDel); + panelStorage.Controls.Add(listBoxCollection); + panelStorage.Controls.Add(buttonCollecctionAdd); + panelStorage.Controls.Add(radioButtonList); + panelStorage.Controls.Add(radioButtonMassive); + panelStorage.Controls.Add(textBoxCollectionName); + panelStorage.Controls.Add(labelCollectionName); + panelStorage.Dock = DockStyle.Top; + panelStorage.Location = new Point(3, 23); + panelStorage.Name = "panelStorage"; + panelStorage.Size = new Size(216, 283); + panelStorage.TabIndex = 6; + // + // buttonCollectionDel + // + buttonCollectionDel.Location = new Point(17, 247); + buttonCollectionDel.Name = "buttonCollectionDel"; + buttonCollectionDel.Size = new Size(186, 27); + buttonCollectionDel.TabIndex = 6; + buttonCollectionDel.Text = "Удалить коллекцию"; + buttonCollectionDel.UseVisualStyleBackColor = true; + buttonCollectionDel.Click += ButtonCollectionDel_Click; + // + // listBoxCollection + // + listBoxCollection.FormattingEnabled = true; + listBoxCollection.ItemHeight = 20; + listBoxCollection.Location = new Point(17, 137); + listBoxCollection.Name = "listBoxCollection"; + listBoxCollection.Size = new Size(186, 104); + listBoxCollection.TabIndex = 5; + // + // buttonCollecctionAdd + // + buttonCollecctionAdd.Location = new Point(17, 104); + buttonCollecctionAdd.Name = "buttonCollecctionAdd"; + buttonCollecctionAdd.Size = new Size(186, 27); + buttonCollecctionAdd.TabIndex = 4; + buttonCollecctionAdd.Text = "Добавить коллекцию"; + buttonCollecctionAdd.UseVisualStyleBackColor = true; + buttonCollecctionAdd.Click += ButtonCollecctionAdd_Click; + // + // radioButtonList + // + radioButtonList.AutoSize = true; + radioButtonList.Location = new Point(123, 75); + radioButtonList.Name = "radioButtonList"; + radioButtonList.Size = new Size(80, 24); + radioButtonList.TabIndex = 3; + radioButtonList.TabStop = true; + radioButtonList.Text = "Список"; + radioButtonList.UseVisualStyleBackColor = true; + // + // radioButtonMassive + // + radioButtonMassive.AutoSize = true; + radioButtonMassive.Location = new Point(17, 75); + radioButtonMassive.Name = "radioButtonMassive"; + radioButtonMassive.Size = new Size(82, 24); + radioButtonMassive.TabIndex = 2; + radioButtonMassive.TabStop = true; + radioButtonMassive.Text = "Массив"; + radioButtonMassive.UseVisualStyleBackColor = true; + // + // textBoxCollectionName + // + textBoxCollectionName.Location = new Point(17, 32); + textBoxCollectionName.Name = "textBoxCollectionName"; + textBoxCollectionName.Size = new Size(186, 27); + textBoxCollectionName.TabIndex = 1; + // + // labelCollectionName + // + labelCollectionName.AutoSize = true; + labelCollectionName.Location = new Point(26, 9); + labelCollectionName.Name = "labelCollectionName"; + labelCollectionName.Size = new Size(155, 20); + labelCollectionName.TabIndex = 0; + labelCollectionName.Text = "Название коллекции"; + // + // comboBoxSelectorCompany + // + comboBoxSelectorCompany.DropDownStyle = ComboBoxStyle.DropDownList; + comboBoxSelectorCompany.FormattingEnabled = true; + comboBoxSelectorCompany.Items.AddRange(new object[] { "Хранилище" }); + comboBoxSelectorCompany.Location = new Point(21, 311); + comboBoxSelectorCompany.Name = "comboBoxSelectorCompany"; + comboBoxSelectorCompany.Size = new Size(186, 28); + comboBoxSelectorCompany.TabIndex = 0; + comboBoxSelectorCompany.SelectedIndexChanged += comboBoxSelectorCompany_SelectedIndexChanged_1; + // + // panelCompanyTools + // + panelCompanyTools.Controls.Add(ButtonAddCruiser); + panelCompanyTools.Controls.Add(buttonRefresh); + panelCompanyTools.Controls.Add(ButtonRemoveCruiser); + panelCompanyTools.Controls.Add(maskedTextBoxPosision); + panelCompanyTools.Controls.Add(buttonGetToTest); + panelCompanyTools.Enabled = false; + panelCompanyTools.Location = new Point(3, 379); + panelCompanyTools.Name = "panelCompanyTools"; + panelCompanyTools.Size = new Size(216, 274); + panelCompanyTools.TabIndex = 8; + // + // ButtonAddCruiser + // + ButtonAddCruiser.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right; + ButtonAddCruiser.BackgroundImageLayout = ImageLayout.Center; + ButtonAddCruiser.Location = new Point(18, 3); + ButtonAddCruiser.Name = "ButtonAddCruiser"; + ButtonAddCruiser.Size = new Size(186, 40); + ButtonAddCruiser.TabIndex = 1; + ButtonAddCruiser.Text = "добваление крейсера"; + ButtonAddCruiser.UseVisualStyleBackColor = true; + ButtonAddCruiser.Click += ButtonAddCruiser_Click; + // + // buttonRefresh + // + buttonRefresh.Anchor = AnchorStyles.Bottom | AnchorStyles.Right; + buttonRefresh.Location = new Point(18, 227); + buttonRefresh.Name = "buttonRefresh"; + buttonRefresh.Size = new Size(186, 41); + buttonRefresh.TabIndex = 5; + buttonRefresh.Text = "обновить"; + buttonRefresh.UseVisualStyleBackColor = true; + buttonRefresh.Click += ButtonRefresh_Click; + // + // ButtonRemoveCruiser + // + ButtonRemoveCruiser.Anchor = AnchorStyles.Right; + ButtonRemoveCruiser.Location = new Point(18, 138); + ButtonRemoveCruiser.Name = "ButtonRemoveCruiser"; + ButtonRemoveCruiser.Size = new Size(186, 40); + ButtonRemoveCruiser.TabIndex = 3; + ButtonRemoveCruiser.Text = "удалить крейсер"; + ButtonRemoveCruiser.UseVisualStyleBackColor = true; + ButtonRemoveCruiser.Click += ButtonRemoveCruiser_Click; + // + // maskedTextBoxPosision + // + maskedTextBoxPosision.Location = new Point(17, 105); + maskedTextBoxPosision.Mask = "00"; + maskedTextBoxPosision.Name = "maskedTextBoxPosision"; + maskedTextBoxPosision.Size = new Size(187, 27); + maskedTextBoxPosision.TabIndex = 2; + maskedTextBoxPosision.ValidatingType = typeof(int); + // + // buttonGetToTest + // + buttonGetToTest.Anchor = AnchorStyles.Right; + buttonGetToTest.Location = new Point(18, 184); + buttonGetToTest.Name = "buttonGetToTest"; + buttonGetToTest.Size = new Size(186, 40); + buttonGetToTest.TabIndex = 4; + buttonGetToTest.Text = "передать на тесты"; + buttonGetToTest.UseVisualStyleBackColor = true; + buttonGetToTest.Click += ButtonGetToTest_Click; + // + // pictureBoxCruiser + // + pictureBoxCruiser.Dock = DockStyle.Fill; + pictureBoxCruiser.Location = new Point(0, 28); + pictureBoxCruiser.Name = "pictureBoxCruiser"; + pictureBoxCruiser.Size = new Size(631, 651); + pictureBoxCruiser.TabIndex = 1; + pictureBoxCruiser.TabStop = false; + // + // menuStrip + // + menuStrip.ImageScalingSize = new Size(20, 20); + menuStrip.Items.AddRange(new ToolStripItem[] { файлToolStripMenuItem }); + menuStrip.Location = new Point(0, 0); + menuStrip.Name = "menuStrip"; + menuStrip.Size = new Size(853, 28); + menuStrip.TabIndex = 2; + menuStrip.Text = "menuStrip1"; + // + // файлToolStripMenuItem + // + файлToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { saveToolStripMenuItem, loadToolStripMenuItem }); + файлToolStripMenuItem.Name = "файлToolStripMenuItem"; + файлToolStripMenuItem.Size = new Size(59, 24); + файлToolStripMenuItem.Text = "Файл"; + // + // saveToolStripMenuItem + // + saveToolStripMenuItem.Name = "saveToolStripMenuItem"; + saveToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.S; + saveToolStripMenuItem.Size = new Size(227, 26); + saveToolStripMenuItem.Text = "Сохранение"; + saveToolStripMenuItem.Click += SaveToolStripMenuItem_Click; + // + // loadToolStripMenuItem + // + loadToolStripMenuItem.Name = "loadToolStripMenuItem"; + loadToolStripMenuItem.ShortcutKeys = Keys.Control | Keys.L; + loadToolStripMenuItem.Size = new Size(227, 26); + loadToolStripMenuItem.Text = "Загрузка"; + loadToolStripMenuItem.Click += LoadToolStripMenuItem_Click; + // + // saveFileDialog + // + saveFileDialog.Filter = "txt file|*.txt"; + // + // openFileDialog + // + openFileDialog.Filter = "txt file|*.txt"; + // + // FormCruisersCollection + // + AutoScaleDimensions = new SizeF(8F, 20F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new Size(853, 679); + Controls.Add(pictureBoxCruiser); + Controls.Add(groupBoxTools); + Controls.Add(menuStrip); + MainMenuStrip = menuStrip; + Name = "FormCruisersCollection"; + Text = "FormCruisersCollection"; + groupBoxTools.ResumeLayout(false); + panelStorage.ResumeLayout(false); + panelStorage.PerformLayout(); + panelCompanyTools.ResumeLayout(false); + panelCompanyTools.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)pictureBoxCruiser).EndInit(); + menuStrip.ResumeLayout(false); + menuStrip.PerformLayout(); + ResumeLayout(false); + PerformLayout(); + } + + #endregion + + private GroupBox groupBoxTools; + private ComboBox comboBoxSelectorCompany; + private Button ButtonAddCruiser; + private Button ButtonRemoveCruiser; + private Button buttonRefresh; + private Button buttonGetToTest; + private PictureBox pictureBoxCruiser; + private MaskedTextBox maskedTextBoxPosision; + private Panel panelStorage; + private TextBox textBoxCollectionName; + private Label labelCollectionName; + private ListBox listBoxCollection; + private Button buttonCollecctionAdd; + private RadioButton radioButtonList; + private RadioButton radioButtonMassive; + private Button buttonCreateCompany; + private Button buttonCollectionDel; + private Panel panelCompanyTools; + private MenuStrip menuStrip; + private ToolStripMenuItem файлToolStripMenuItem; + private ToolStripMenuItem saveToolStripMenuItem; + private ToolStripMenuItem loadToolStripMenuItem; + private SaveFileDialog saveFileDialog; + private OpenFileDialog openFileDialog; + } +} \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/FormCruisersCollection.cs b/ProjectPlane/ProjectPlane/FormCruisersCollection.cs new file mode 100644 index 0000000..0b1d358 --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruisersCollection.cs @@ -0,0 +1,306 @@ +using Microsoft.Extensions.Logging; +using ProjectCruiser.CollectionGenericObjects; +using ProjectCruiser.Drawnings; + +namespace ProjectCruiser +{ + public partial class FormCruisersCollection : Form + { + /// + /// Хранилише коллекций + /// + private readonly StorageCollection _storageCollection; + + /// + /// Компания + /// + private AbstractCompany? _company = null; + + /// + /// Логер + /// + private readonly ILogger _logger; + + /// + /// Конструктор + /// + public FormCruisersCollection(ILogger logger) + { + InitializeComponent(); + _storageCollection = new(); + _logger = logger; + } + + /// + /// + /// + /// + /// + private void comboBoxSelectorCompany_SelectedIndexChanged_1(object sender, EventArgs e) + { + panelCompanyTools.Enabled = false; + } + + /// + /// добавление крейсера + /// + /// + /// + private void ButtonAddCruiser_Click(object sender, EventArgs e) + { + FormCruiserConfing form = new(); + // TODO передать метод + + form.Show(); + form.AddEvent(SetCruiser); + } + + /// + /// Добавление крейсера в коллекцию + /// + /// + private void SetCruiser(DrawningCruiser? cruiser) + { + if (_company == null || cruiser == null) + { + return; + } + try + { + var res = _company + cruiser; + MessageBox.Show("Объект добавлен"); + _logger.LogInformation($"Объект добавлен под индексом {res}"); + pictureBoxCruiser.Image = _company.Show(); + } + catch (Exception ex) + { + MessageBox.Show($"Объект не добавлен: {ex.Message}", "Результат", MessageBoxButtons.OK, + MessageBoxIcon.Error); + _logger.LogError($"Ошибка: {ex.Message}", ex.Message); + } + } + + /// + /// Удаление объекта + /// + /// + /// + private void ButtonRemoveCruiser_Click(object sender, EventArgs e) + { + if (string.IsNullOrEmpty(maskedTextBoxPosision.Text) || _company == null) + { + return; + } + if (MessageBox.Show("удалить объект?", "удаление", + MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes) + { + return; + } + int pos = Convert.ToInt32(maskedTextBoxPosision.Text); + try + { + var res = _company - pos; + MessageBox.Show("Объект удален"); + _logger.LogInformation($"Объект удален под индексом {pos}"); + pictureBoxCruiser.Image = _company.Show(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Не удалось удалить объект", + MessageBoxButtons.OK, MessageBoxIcon.Error); + _logger.LogError($"Ошибка: {ex.Message}", ex.Message); + } + } + + private void ButtonGetToTest_Click(object sender, EventArgs e) + { + if (_company == null) + { + return; + } + + DrawningCruiser? cruiser = null; + int counter = 100; + while (cruiser == null) + { + cruiser = _company.GetRandomObject(); + counter--; + if (counter <= 0) + { + break; + } + } + if (cruiser == null) + { + return; + } + FormCruiser form = new() + { + SetCruiser = cruiser + }; + form.ShowDialog(); + + } + + private void ButtonRefresh_Click(object sender, EventArgs e) + { + if (_company == null) + { + return; + } + + pictureBoxCruiser.Image = _company.Show(); + } + + /// + /// Добавление коллекции + /// + /// + /// + private void ButtonCollecctionAdd_Click(object sender, EventArgs e) + { + if (string.IsNullOrEmpty(textBoxCollectionName.Text) || (!radioButtonList.Checked && !radioButtonMassive.Checked)) + { + MessageBox.Show("Не все данные заполнены", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + return; + } + CollectionType collectionType = CollectionType.None; + if (radioButtonMassive.Checked) + { + collectionType = CollectionType.Massive; + } + else if (radioButtonList.Checked) + { + collectionType = CollectionType.List; + } + + try + { + _storageCollection.AddCollection(textBoxCollectionName.Text, collectionType); + _logger.LogInformation("Добавление коллекции"); + RerfreshListBoxItems(); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error); + _logger.LogError($"Ошибка: {ex.Message}", ex.Message); + } + } + + /// + /// Удаленние коллекции + /// + /// + /// + private void ButtonCollectionDel_Click(object sender, EventArgs e) + { + if (listBoxCollection.SelectedIndex < 0 || listBoxCollection.SelectedItem == null) + { + MessageBox.Show("Коллекция не выбрана"); + return; + } + if (MessageBox.Show("Удалить коллекцию?", "Удаление", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) + { + return; + } + _storageCollection.DelCollection(listBoxCollection.SelectedItem.ToString()); + _logger.LogInformation("Коллекция удалена"); + RerfreshListBoxItems(); + } + + /// + /// Обновление списка в listBoxCollection + /// + private void RerfreshListBoxItems() + { + listBoxCollection.Items.Clear(); + for (int i = 0; i < _storageCollection.Keys?.Count; ++i) + { + string? colName = _storageCollection.Keys?[i]; + if (!string.IsNullOrEmpty(colName)) + { + listBoxCollection.Items.Add(colName); + } + } + } + + /// + /// Создание компании + /// + /// + /// + private void ButtonCreateCompany_Click(object sender, EventArgs e) + { + if (listBoxCollection.SelectedIndex < 0 || listBoxCollection.SelectedItem == null) + { + MessageBox.Show("Коллекция не выбрана"); + return; + } + + ICollectionGenericObjects? collection = + _storageCollection[listBoxCollection.SelectedItem.ToString() ?? string.Empty]; + if (collection == null) + { + MessageBox.Show("Коллекция не проинициализирована"); + return; + } + + switch (comboBoxSelectorCompany.Text) + { + case "Хранилище": + _company = new CruiserDockingService(pictureBoxCruiser.Width, pictureBoxCruiser.Height, collection); + _logger.LogInformation("Компания создана"); + break; + } + panelCompanyTools.Enabled = true; + + } + + /// + /// Обработка нажатия "Сохранение" + /// + /// + /// + private void SaveToolStripMenuItem_Click(object sender, EventArgs e) + { + if (saveFileDialog.ShowDialog() == DialogResult.OK) + { + try + { + _storageCollection.SaveData(saveFileDialog.FileName); + MessageBox.Show("Сохранение прошло успешно", "Результат", MessageBoxButtons.OK, MessageBoxIcon.Information); + _logger.LogInformation("Сохранение в файл: {filename}", saveFileDialog.FileName); + } + catch (Exception ex) + { + MessageBox.Show(ex.Message, "Результат", MessageBoxButtons.OK, MessageBoxIcon.Error); + _logger.LogError("Ошибка: {Message}", ex.Message); + } + } + } + + /// + /// Обработка нажатия "Загрузка" + /// + /// + /// + private void LoadToolStripMenuItem_Click(object sender, EventArgs e) + { + if (openFileDialog.ShowDialog() == DialogResult.OK) + { + try + { + _storageCollection.LoadData(openFileDialog.FileName); + RerfreshListBoxItems(); + MessageBox.Show("Загрузка прошло успешно", "Результат", MessageBoxButtons.OK, MessageBoxIcon.Information); + _logger.LogInformation("Загрузка из файла: {filename}", openFileDialog.FileName); + } + catch (Exception ex) + { + MessageBox.Show("Загрузка не выполнена", "Результат", MessageBoxButtons.OK, MessageBoxIcon.Error); + _logger.LogError("Ошибка: {Message}", ex.Message); + } + } + } + } +} diff --git a/ProjectPlane/ProjectPlane/FormCruisersCollection.resx b/ProjectPlane/ProjectPlane/FormCruisersCollection.resx new file mode 100644 index 0000000..b5b741b --- /dev/null +++ b/ProjectPlane/ProjectPlane/FormCruisersCollection.resx @@ -0,0 +1,132 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 1 + + + 145, 1 + + + 310, 1 + + + 25 + + \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/AbstractStrategy.cs b/ProjectPlane/ProjectPlane/MovementStrategy/AbstractStrategy.cs new file mode 100644 index 0000000..989cb90 --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/AbstractStrategy.cs @@ -0,0 +1,123 @@ +namespace ProjectCruiser.MovementStrategy +{ + /// + /// Класс-стратегия перемещения объекта + /// + public abstract class AbstractStrategy + { + /// + /// Перемещаемый объект + /// + private IMoveableObject? _moveableObject; + /// + /// Статус перемещения + /// + private StrategyStatus _state = StrategyStatus.NotInit; + /// + /// Ширина поля + /// + protected int FieldWidth { get; private set; } + /// + /// Высота поля + /// + protected int FieldHeight { get; private set; } + /// + /// Статус перемещения + /// + public StrategyStatus GetStatus() { return _state; } + /// + /// Установка данных + /// + /// Перемещаемый объект + /// Ширина поля + /// Высота поля + public void SetData(IMoveableObject moveableObject, int width, int height) + { + if (moveableObject == null) + { + _state = StrategyStatus.NotInit; + return; + } + _state = StrategyStatus.InProgress; + _moveableObject = moveableObject; + FieldWidth = width; + FieldHeight = height; + } + /// + /// Шаг перемещения + /// + public void MakeStep() + { + if (_state != StrategyStatus.InProgress) + { + return; + } + if (IsTargetDestinaion()) + { + _state = StrategyStatus.Finish; + return; + } + MoveToTarget(); + } + /// + /// Перемещение влево + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveLeft() => MoveTo(MovementDirection.Left); + /// + /// Перемещение вправо + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveRight() => MoveTo(MovementDirection.Right); + /// + /// Перемещение вверх + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveUp() => MoveTo(MovementDirection.Up); + /// + /// Перемещение вниз + /// + /// Результат перемещения (true - удалось переместиться, false - неудача) + protected bool MoveDown() => MoveTo(MovementDirection.Down); + /// + /// Параметры объекта + /// + protected ObjectParameters? GetObjectParameters => + _moveableObject?.GetObjectPosition; + /// + /// Шаг объекта + /// + /// + protected int? GetStep() + { + if (_state != StrategyStatus.InProgress) + { + return null; + } + return _moveableObject?.GetStep; + } + /// + /// Перемещение к цели + /// + protected abstract void MoveToTarget(); + /// + /// Достигнута ли цель + /// + /// + protected abstract bool IsTargetDestinaion(); + /// + /// Попытка перемещения в требуемом направлении + /// + /// Направление + /// Результат попытки (true - удалось переместиться, false - неудача) + private bool MoveTo(MovementDirection movementDirection) + { + if (_state != StrategyStatus.InProgress) + { + return false; + } + return _moveableObject?.TryMoveObject(movementDirection) ?? false; + } + } + +} diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/IMoveableObject.cs b/ProjectPlane/ProjectPlane/MovementStrategy/IMoveableObject.cs new file mode 100644 index 0000000..b6a27e5 --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/IMoveableObject.cs @@ -0,0 +1,24 @@ +namespace ProjectCruiser.MovementStrategy +{ + /// + /// Интерфейс для работы с перемещаемым объектом + /// + public interface IMoveableObject + { + /// + /// Получение координаты объекта + /// + ObjectParameters? GetObjectPosition { get; } + /// + /// Шаг объекта + /// + int GetStep { get; } + /// + /// Попытка переместить объект в указанном направлении + /// + /// Направление + /// true - объект перемещен, false - перемещение невозможно + bool TryMoveObject(MovementDirection direction); + } + +} diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/MoveToBorder.cs b/ProjectPlane/ProjectPlane/MovementStrategy/MoveToBorder.cs new file mode 100644 index 0000000..1e2d6ac --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/MoveToBorder.cs @@ -0,0 +1,53 @@ +namespace ProjectCruiser.MovementStrategy +{ + /// + /// Стратегия перемещения объекта к краю экрана + /// + internal class MoveToBorder : AbstractStrategy + { + protected override bool IsTargetDestinaion() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.RightBorder - GetStep() <= FieldWidth + && objParams.RightBorder + GetStep() >= FieldWidth && + objParams.DownBorder - GetStep() <= FieldHeight + && objParams.DownBorder + GetStep() >= FieldHeight; + } + protected override void MoveToTarget() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + int diffX = objParams.RightBorder - FieldWidth; + if (Math.Abs(diffX) > GetStep()) + { + if (diffX > 0) + { + MoveLeft(); + } + else + { + MoveRight(); + } + } + int diffY = objParams.DownBorder - FieldHeight; + if (Math.Abs(diffY) > GetStep()) + { + if (diffY > 0) + { + MoveUp(); + } + else + { + MoveDown(); + } + } + } + } +} diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/MoveToCenter.cs b/ProjectPlane/ProjectPlane/MovementStrategy/MoveToCenter.cs new file mode 100644 index 0000000..540208e --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/MoveToCenter.cs @@ -0,0 +1,53 @@ +namespace ProjectCruiser.MovementStrategy +{ + /// + /// Стратегия перемещения объекта в центр экрана + /// + public class MoveToCenter : AbstractStrategy + { + protected override bool IsTargetDestinaion() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return false; + } + return objParams.ObjectMiddleHorizontal - GetStep() <= FieldWidth / 2 + && objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth / 2 && + objParams.ObjectMiddleVertical - GetStep() <= FieldHeight / 2 + && objParams.ObjectMiddleVertical + GetStep() >= FieldHeight / 2; + } + protected override void MoveToTarget() + { + ObjectParameters? objParams = GetObjectParameters; + if (objParams == null) + { + return; + } + int diffX = objParams.ObjectMiddleHorizontal - FieldWidth / 2; + if (Math.Abs(diffX) > GetStep()) + { + if (diffX > 0) + { + MoveLeft(); + } + else + { + MoveRight(); + } + } + int diffY = objParams.ObjectMiddleVertical - FieldHeight / 2; + if (Math.Abs(diffY) > GetStep()) + { + if (diffY > 0) + { + MoveUp(); + } + else + { + MoveDown(); + } + } + } + } +} diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/MoveableCruiser.cs b/ProjectPlane/ProjectPlane/MovementStrategy/MoveableCruiser.cs new file mode 100644 index 0000000..766c933 --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/MoveableCruiser.cs @@ -0,0 +1,62 @@ +using ProjectCruiser.Drawnings; + +namespace ProjectCruiser.MovementStrategy +{ + /// + /// класс реалтзация для IMoveableObject с использованием DrawningCruiser + /// + public class MoveableCruiser : IMoveableObject + { + /// + /// Поле-объект класса DrawningCruiser или его наследника + /// + private readonly DrawningCruiser? _cruiser = null; + /// + /// Конструктор + /// + /// Объект класса DrawningCruiser + public MoveableCruiser(DrawningCruiser cruiser) + { + _cruiser = cruiser; + } + public ObjectParameters? GetObjectPosition + { + get + { + if (_cruiser == null || _cruiser.EntityCruiser == null || + !_cruiser.GetPosX.HasValue || !_cruiser.GetPosY.HasValue) + { + return null; + } + return new ObjectParameters(_cruiser.GetPosX.Value, + _cruiser.GetPosY.Value, _cruiser.GetWidth, _cruiser.GetHeight); + } + } + public int GetStep => (int)(_cruiser?.EntityCruiser?.Step ?? 0); + public bool TryMoveObject(MovementDirection direction) + { + if (_cruiser == null || _cruiser.EntityCruiser == null) + { + return false; + } + return _cruiser.MoveTransport(GetDirectionType(direction)); + } + /// + /// Конвертация из MovementDirection в DirectionType + /// + /// MovementDirection + /// DirectionType + private static DirectionType GetDirectionType(MovementDirection direction) + { + return direction switch + { + MovementDirection.Left => DirectionType.Left, + MovementDirection.Right => DirectionType.Right, + MovementDirection.Up => DirectionType.Up, + MovementDirection.Down => DirectionType.Down, + _ => DirectionType.Unknow, + }; + } + } +} + diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/MovementDirection.cs b/ProjectPlane/ProjectPlane/MovementStrategy/MovementDirection.cs new file mode 100644 index 0000000..d66685a --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/MovementDirection.cs @@ -0,0 +1,26 @@ +namespace ProjectCruiser.MovementStrategy +{ + /// + /// Направление перемещения + /// + public enum MovementDirection + { + /// + /// Вверх + /// + Up = 1, + /// + /// Вниз + /// + Down = 2, + /// + /// Влево + /// + Left = 3, + /// + /// Вправо + /// + Right = 4 + } + +} diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/ObjectParameters.cs b/ProjectPlane/ProjectPlane/MovementStrategy/ObjectParameters.cs new file mode 100644 index 0000000..ac6715e --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/ObjectParameters.cs @@ -0,0 +1,64 @@ +namespace ProjectCruiser.MovementStrategy +{ + /// + /// Параметры-координаты объекта + /// + public class ObjectParameters + { + /// + /// Координата X + /// + private readonly int _x; + /// + /// Координата Y + /// + private readonly int _y; + /// + /// Ширина объекта + /// + private readonly int _width; + /// + /// Высота объекта + /// + private readonly int _height; + /// + /// Левая граница + /// + public int LeftBorder => _x; + /// + /// Верхняя граница + /// + public int TopBorder => _y; + /// + /// Правая граница + /// + public int RightBorder => _x + _width; + /// + /// Нижняя граница + /// + public int DownBorder => _y + _height; + /// + /// Середина объекта + /// + public int ObjectMiddleHorizontal => _x + _width / 2; + /// + /// Середина объекта + /// + public int ObjectMiddleVertical => _y + _height / 2; + /// + /// Конструктор + /// + /// Координата X + /// Координата Y + /// Ширина объекта + /// Высота объекта + public ObjectParameters(int x, int y, int width, int height) + { + _x = x; + _y = y; + _width = width; + _height = height; + } + } + +} diff --git a/ProjectPlane/ProjectPlane/MovementStrategy/StrategyStatus.cs b/ProjectPlane/ProjectPlane/MovementStrategy/StrategyStatus.cs new file mode 100644 index 0000000..397e23e --- /dev/null +++ b/ProjectPlane/ProjectPlane/MovementStrategy/StrategyStatus.cs @@ -0,0 +1,22 @@ +namespace ProjectCruiser.MovementStrategy +{ + /// + /// Статус выполнения операции перемещения + /// + public enum StrategyStatus + { + /// + /// Все готово к началу + /// + NotInit, + /// + /// Выполняется + /// + InProgress, + /// + /// Завершено + /// + Finish + } + +} diff --git a/ProjectPlane/ProjectPlane/Program.cs b/ProjectPlane/ProjectPlane/Program.cs new file mode 100644 index 0000000..300ce3c --- /dev/null +++ b/ProjectPlane/ProjectPlane/Program.cs @@ -0,0 +1,45 @@ +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Serilog; + +namespace ProjectCruiser +{ + internal static class Program + { + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main() + { + // To customize application configuration such as set high DPI settings or default font, see https://aka.ms/applicationconfiguration. + ApplicationConfiguration.Initialize(); + ServiceCollection services = new(); + ConfigureServices(services); + using ServiceProvider serviceProvider = services.BuildServiceProvider(); + Application.Run(serviceProvider.GetRequiredService()); + } + + private static void ConfigureServices(ServiceCollection services) + { + services.AddSingleton().AddLogging(option => + { + string[] path = Directory.GetCurrentDirectory().Split('\\'); + string pathNeed = ""; + for (int i = 0; i < path.Length - 3; i++) + { + pathNeed += path[i] + "\\"; + } + + var configuration = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()) + .AddJsonFile(path: $"{pathNeed}serilogConfig.json", optional: false, reloadOnChange: true) + .Build(); + var logger = new LoggerConfiguration().ReadFrom.Configuration(configuration).CreateLogger(); + option.SetMinimumLevel(LogLevel.Information); + option.AddSerilog(logger); + }); + } + + } +} \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/nlog.config b/ProjectPlane/ProjectPlane/nlog.config new file mode 100644 index 0000000..aef17e8 --- /dev/null +++ b/ProjectPlane/ProjectPlane/nlog.config @@ -0,0 +1,14 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/ProjectPlane/ProjectPlane/serilogConfig.json b/ProjectPlane/ProjectPlane/serilogConfig.json new file mode 100644 index 0000000..9ec09e6 --- /dev/null +++ b/ProjectPlane/ProjectPlane/serilogConfig.json @@ -0,0 +1,20 @@ +{ + "Serilog": { + "Using": [ "Serilog.Sinks.File" ], + "MinimumLevel": "Information", + "WriteTo": [ + { + "Name": "File", + "Args": { + "path": "Logs/log_.log", + "rollingInterval": "Day", + "outputTemplate": "[{Timestamp:HH:mm:ss.fff}]{Level:u4}: {Message:lj}{NewLine}{Exception}" + } + } + ], + "Enrich": [ "FromLogContext", "WithMachineName", "WithThreadId" ], + "Properties": { + "Application": "cruiser" + } + } +} \ No newline at end of file