diff --git a/mods.json b/mods.json index b2360d0..a7058b2 100644 --- a/mods.json +++ b/mods.json @@ -3,7 +3,7 @@ "mods": [ { "id": "backpack", "name": "Extra Backpack", "description": "An optional native 20-slot extra backpack for every character class.", "author": "zj1022", "version": "1.0.3", "compatibleClientVersions": ["0.5.1-beta", "0.5.2-beta"], "kind": "feature", "type": "script", "path": "mods/backpack", "depends": [], "settings": false }, { "id": "fastcampaign", "name": "Fast Campaign", "description": "A faster campaign: 5x kill experience, +50% movement speed, and /fast lists the commands that skip ahead.", "author": "LocalExile", "version": "1.1.4", "compatibleClientVersions": ["0.4.3-beta", "0.5.0-beta", "0.5.1-beta", "0.5.2-beta"], "kind": "feature", "type": "project", "path": "mods/fastcampaign", "depends": [], "settings": true }, - { "id": "globalchat", "name": "Global Chat", "description": "Talk to other LocalExile players: global, trade and whisper chat go through the LocalExile global chat server.", "author": "JetStream", "version": "1.1.4", "compatibleClientVersions": ["0.4.3-beta", "0.5.0-beta", "0.5.1-beta", "0.5.2-beta"], "kind": "feature", "type": "project", "path": "mods/globalchat", "depends": [], "settings": true }, + { "id": "globalchat", "name": "Global Chat", "description": "Talk to other LocalExile players through a shared chat server, with optional Discord and simulated chat routes.", "author": "JetStream", "version": "1.2.16", "compatibleClientVersions": ["0.5.2-beta"], "kind": "feature", "type": "project", "path": "mods/globalchat", "depends": [], "settings": true }, { "id": "gm-commands", "name": "GM Commands", "description": "The development and testing chat commands: teleport, items, monsters, experience, quest flags, test hits and protocol probes.", "author": "LocalExile", "version": "1.5.0", "compatibleClientVersions": ["0.5.2-beta"], "kind": "feature", "type": "project", "path": "mods/gm-commands", "depends": ["Game"], "settings": false }, { "id": "itemquantity", "name": "Item Quantity", "description": "10 times as many item drops from every kill.", "author": "LocalExile", "version": "1.1.4", "compatibleClientVersions": ["0.4.3-beta", "0.5.0-beta", "0.5.1-beta", "0.5.2-beta"], "kind": "feature", "type": "project", "path": "mods/itemquantity", "depends": [], "settings": true }, { "id": "itemrarity", "name": "Item Rarity", "description": "10 times the chance of magic, rare and unique equipment.", "author": "LocalExile", "version": "1.1.4", "compatibleClientVersions": ["0.4.3-beta", "0.5.0-beta", "0.5.1-beta", "0.5.2-beta"], "kind": "feature", "type": "project", "path": "mods/itemrarity", "depends": [], "settings": true }, diff --git a/mods/globalchat/ChatChannelRouting.cs b/mods/globalchat/ChatChannelRouting.cs new file mode 100644 index 0000000..852d822 --- /dev/null +++ b/mods/globalchat/ChatChannelRouting.cs @@ -0,0 +1,139 @@ +using System.Globalization; +using System.Text.Json.Nodes; +using GameServer.Core.Protocol.Instance; + +namespace GlobalChat; + +enum ChatChannelRouteType { Blank, Server, Discord, Fake } + +sealed record ChannelChoice(JsonNode? Type, JsonNode? DiscordChannelId, JsonNode? Address, JsonNode? Port, JsonNode? SendToDiscord = null); +sealed record ChatChoices(Dictionary? GlobalChannels, Dictionary? TradeChannels, + ChannelChoice? FallbackRoute = null, string? DiscordBotToken = null); + +readonly record struct ChatRoom(ChatChannelKind Kind, ushort Channel, byte Language) +{ + internal TypedChannel TypedChannel => Kind == ChatChannelKind.Trade ? TypedChannel.Trade : TypedChannel.Global; + internal static ChatRoom? Of(ClientState conn, ChatChannelKind kind) => + ChatRoutes.Membership(Program.CharacterName(conn), kind) is { } channel + ? new(kind, channel.Channel, channel.Language) : null; + internal static bool IsListener(ClientState conn) => + conn is { Controlled: false, Closed: false, LeavingArea: false, PlayerSent: true, Outbox: not null }; + public override string ToString() => $"{Kind} {Channel}"; +} + +sealed record DiscordRoute(ushort Channel, string ChannelId, bool SendToDiscord, ChatChannelKind Kind, bool IsFallback = false); + +sealed class ChatChannelRouting +{ + internal sealed record Route(ChatChannelRouteType Type, string DiscordId = "", (string Host, int Port)? Server = null, bool SendToDiscord = true); + + readonly Dictionary<(ChatChannelKind Kind, ushort Channel), Route> routes = []; + readonly Route fallback; + + internal ChatChannelRouting(ChatChoices settings, Action log) + { + Apply(ChatChannelKind.Global, settings.GlobalChannels, log); + Apply(ChatChannelKind.Trade, settings.TradeChannels, log); + fallback = settings.FallbackRoute is { } choice ? ParseRoute(choice, "Fallback route", log, defaultForward: false) + : new(ChatChannelRouteType.Blank); + HasFakeChat = fallback.Type == ChatChannelRouteType.Fake || routes.Values.Any(route => route.Type == ChatChannelRouteType.Fake); + } + + internal Dictionary<(ChatChannelKind Kind, ushort Channel), (string Host, int Port)?> ChannelServers() => + routes.OrderBy(pair => pair.Key.Kind).ThenBy(pair => pair.Key.Channel) + .ToDictionary(pair => pair.Key, pair => pair.Value.Server); + + internal (string Host, int Port)? FallbackServer => fallback.Server; + + static bool ValidServer(string? host, int port) => + !string.IsNullOrWhiteSpace(host) && Uri.CheckHostName(host) != UriHostNameType.Unknown && port is >= 1 and <= 65535; + + internal bool HasFakeChat { get; } + internal bool IsDefined(ChatChannelKind kind, ushort channel) => routes.ContainsKey((kind, channel)); + internal Route? Find(ChatChannelKind kind, ushort channel) => routes.GetValueOrDefault((kind, channel)) + ?? (fallback.Type == ChatChannelRouteType.Blank ? null : fallback); + + void Apply(ChatChannelKind kind, Dictionary? choices, Action log) + { + if (choices is null) return; + foreach (var (number, choice) in choices) + { + if (!ushort.TryParse(number, NumberStyles.None, CultureInfo.InvariantCulture, out ushort channel) + || channel is 0 or InstanceChat.AnyChannel || number != channel.ToString(CultureInfo.InvariantCulture)) + { + log($"Ignoring {kind} chat route '{number}'. Use a channel number from 1 to 65534."); + continue; + } + routes[(kind, channel)] = ParseRoute(choice, $"{kind} {channel}", log, defaultForward: true); + } + } + + static Route ParseRoute(ChannelChoice choice, string label, Action log, bool defaultForward) + { + string? routeType = choice.Type is JsonValue value && value.TryGetValue(out string? name) + ? name : choice.Type is null ? "blank" : null; + var type = routeType?.Trim().ToLowerInvariant() switch + { + "server" => ChatChannelRouteType.Server, + "discord" => ChatChannelRouteType.Discord, + "fake" => ChatChannelRouteType.Fake, + "blank" or "none" or "" => ChatChannelRouteType.Blank, + _ => (ChatChannelRouteType?)null + }; + if (type is null) log($"Unknown route type for {label}. Using local chat."); + + string? discordId = null; + if (type == ChatChannelRouteType.Discord && choice.DiscordChannelId is { } configuredId + && (configuredId is not JsonValue text || !text.TryGetValue(out discordId))) + { + log($"{label}: discordChannelId must be quoted. Skipping this mapping."); + type = ChatChannelRouteType.Blank; + } + + (string Host, int Port)? server = null; + if (type == ChatChannelRouteType.Server) + { + string? host = choice.Address is JsonValue address && address.TryGetValue(out string? textAddress) + ? textAddress?.Trim() : null; + int port = choice.Port is JsonValue portValue && portValue.TryGetValue(out int numberPort) ? numberPort + : choice.Port is null ? 0 : -1; + if (port == 0) port = 6113; + if (ValidServer(host, port)) server = (host!.ToLowerInvariant(), port); + else + { + log($"{label}: invalid server address or port. Using local chat."); + type = ChatChannelRouteType.Blank; + } + } + + bool sendToDiscord = choice.SendToDiscord is null ? defaultForward + : choice.SendToDiscord is JsonValue outbound && outbound.TryGetValue(out bool send) && send; + return new(type ?? ChatChannelRouteType.Blank, discordId ?? "", server, sendToDiscord); + } + + internal IEnumerable DiscordRoutes(Action log) + { + var used = new HashSet(); + foreach (var ((kind, channel), route) in routes.OrderBy(pair => pair.Key.Kind).ThenBy(pair => pair.Key.Channel)) + if (RegisterDiscordId(route, $"Discord {kind} {channel}") is { } id) + yield return new(channel, id, route.SendToDiscord, kind); + if (RegisterDiscordId(fallback, "Discord fallback") is { } fallbackId) + yield return new(0, fallbackId, fallback.SendToDiscord, ChatChannelKind.Global, IsFallback: true); + + string? RegisterDiscordId(Route route, string label) + { + if (route.Type != ChatChannelRouteType.Discord || string.IsNullOrWhiteSpace(route.DiscordId)) return null; + if (!ulong.TryParse(route.DiscordId.Trim(), NumberStyles.None, CultureInfo.InvariantCulture, out ulong id) || id == 0) + { + log($"{label}: discordChannelId must be a quoted numeric channel ID; skipping this mapping."); + return null; + } + if (!used.Add(id)) + { + log($"{label}: discordChannelId repeats an earlier channel ID; skipping this mapping."); + return null; + } + return id.ToString(CultureInfo.InvariantCulture); + } + } +} diff --git a/mods/globalchat/DiscordApi.cs b/mods/globalchat/DiscordApi.cs new file mode 100644 index 0000000..5e4cbc2 --- /dev/null +++ b/mods/globalchat/DiscordApi.cs @@ -0,0 +1,65 @@ +using System.Globalization; +using System.Net; +using System.Net.Http.Headers; +using System.Text; +using System.Text.Json; + +namespace GlobalChat; + +sealed class DiscordApiException(int status) : Exception($"Discord HTTP {status}") +{ + internal int Status => status; +} + +/// One worker uses the client serially, sharing Discord's rate-limit cooldown across both directions. +sealed class DiscordApi +{ + readonly HttpClient http; + readonly Func wait; + readonly TimeProvider time; + DateTimeOffset nextRequest; + + internal DiscordApi(HttpClient http, string token, Func? wait = null, TimeProvider? time = null) + { + this.http = http; + this.wait = wait ?? ((delay, cancel) => Task.Delay(delay, cancel)); + this.time = time ?? TimeProvider.System; + http.BaseAddress ??= new Uri("https://discord.com/api/v10/"); + http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bot", token); + http.DefaultRequestHeaders.UserAgent.ParseAdd("DiscordBot (https://github.com/LocalExile/LocalExile-Mods, 1.2.16)"); + } + + internal async Task Request(HttpMethod method, string path, string? body, CancellationToken cancel) + { + for (int attempt = 0; ; attempt++) + { + var cooldown = nextRequest - time.GetUtcNow(); + if (cooldown > TimeSpan.Zero) await wait(cooldown, cancel).ConfigureAwait(false); + using var request = new HttpRequestMessage(method, path); + if (body is not null) request.Content = new StringContent(body, Encoding.UTF8, "application/json"); + using var response = await http.SendAsync(request, cancel).ConfigureAwait(false); + string content = await response.Content.ReadAsStringAsync(cancel).ConfigureAwait(false); + if (response.StatusCode == HttpStatusCode.TooManyRequests) + { + using var limited = JsonDocument.Parse(content); + double seconds = limited.RootElement.GetProperty("retry_after").GetDouble(); + if (!double.IsFinite(seconds) || seconds < 0 || seconds > 86400) throw new InvalidDataException("Invalid Discord cooldown."); + nextRequest = time.GetUtcNow().AddSeconds(Math.Max(.1, seconds)); + if (attempt < 3) continue; + } + if ((int)response.StatusCode >= 500 && attempt < 3) + { + nextRequest = time.GetUtcNow().AddSeconds(1 << attempt); + continue; + } + if (!response.IsSuccessStatusCode) throw new DiscordApiException((int)response.StatusCode); + if (response.Headers.TryGetValues("X-RateLimit-Remaining", out var remaining) && remaining.FirstOrDefault() == "0" + && response.Headers.TryGetValues("X-RateLimit-Reset-After", out var reset) + && double.TryParse(reset.FirstOrDefault(), CultureInfo.InvariantCulture, out double delay) + && double.IsFinite(delay) && delay is >= 0 and <= 86400) + nextRequest = time.GetUtcNow().AddSeconds(delay); + using var document = JsonDocument.Parse(content); + return document.RootElement.Clone(); + } + } +} diff --git a/mods/globalchat/DiscordBridge.cs b/mods/globalchat/DiscordBridge.cs new file mode 100644 index 0000000..26a3858 --- /dev/null +++ b/mods/globalchat/DiscordBridge.cs @@ -0,0 +1,214 @@ +using System.Collections.Concurrent; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Threading.Channels; +using GameServer.Core.Chat; +using GameServer.Core.Protocol.Instance; + +namespace GlobalChat; + +sealed class DiscordBridge : IDisposable +{ + sealed record Pending(string Text, string Nonce, DateTimeOffset Created); + const string CursorKey = "LocalExile.DiscordChat.Cursors"; + readonly DiscordRoute route; + readonly DiscordApi api; + readonly HttpClient http; + readonly Func deliver; + readonly Func audience; + readonly Action log; + readonly TimeProvider time; + readonly ConcurrentDictionary cursors; + readonly string key; + readonly Channel outgoing = Channel.CreateBounded(new BoundedChannelOptions(128) + { SingleReader = true, FullMode = BoundedChannelFullMode.Wait }); + readonly CancellationTokenSource stop = new(); + Task? running; + int disposed; + int sendingDenied; + bool warnedEmptyContent; + + internal DiscordBridge(DiscordRoute route, string token, Func deliver, + Func audience, Action log, HttpClient? http = null, ConcurrentDictionary? cursors = null, + Func? wait = null, TimeProvider? time = null) + { + this.route = route; this.deliver = deliver; this.audience = audience; this.log = log; + this.time = time ?? TimeProvider.System; + this.http = http ?? new HttpClient(new HttpClientHandler { AllowAutoRedirect = false }) { Timeout = TimeSpan.FromSeconds(15) }; + api = new(this.http, token, wait, this.time); + this.cursors = cursors ?? SharedCursors(); + key = route.ChannelId; + } + + static ConcurrentDictionary SharedCursors() + { + if (AppContext.GetData(CursorKey) is ConcurrentDictionary saved) return saved; + var created = new ConcurrentDictionary(); + AppContext.SetData(CursorKey, created); + return created; + } + + internal bool Enqueue(ChatFrame line) + { + if (!route.SendToDiscord || Volatile.Read(ref disposed) != 0 || Volatile.Read(ref sendingDenied) != 0 + || line is not { Type: ChatFrame.Line, Kind: ChatChannelKind.Global or ChatChannelKind.Trade, Channel: not null } + || (!route.IsFallback && (line.Kind != route.Kind || line.Channel != route.Channel)) + || !ChatWire.ValidMember(line.Name)) return false; + string text = ChatWire.Clean(line.Text); + if (string.IsNullOrWhiteSpace(text)) return false; + return outgoing.Writer.TryWrite(new($"[Game] {line.Name}: {text}", Guid.NewGuid().ToString("N")[..24], time.GetUtcNow())); + } + + internal void Start() => running ??= Task.Run(Run); + + async Task Run() + { + while (!stop.IsCancellationRequested) + { + try + { + if (audience()) await PollOnce(stop.Token).ConfigureAwait(false); + else cursors.TryRemove(key, out _); + await SendQueued(stop.Token).ConfigureAwait(false); + } + catch (OperationCanceledException) when (stop.IsCancellationRequested) { break; } + catch (DiscordApiException error) when (error.Status is 401 or 403 or 404) + { + log(error.Status switch + { + 401 => "Discord route stopped (HTTP 401). Verify the configured bot token and any LOCALEXILE_DISCORD_BOT_TOKEN override.", + 403 => $"Discord route stopped (HTTP 403). Verify the bot is installed and has View Channel and Read Message History for channel {route.ChannelId}.", + _ => $"Discord route stopped (HTTP 404). Check channel ID {route.ChannelId} and the bot's visibility of that channel." + }); + break; + } + catch (Exception error) when (error is HttpRequestException or TaskCanceledException or DiscordApiException + or JsonException or InvalidDataException or InvalidOperationException or KeyNotFoundException or FormatException) + { log($"Discord bridge will retry ({error.GetType().Name}); local chat is unaffected."); } + try { await Task.Delay(TimeSpan.FromSeconds(2), stop.Token).ConfigureAwait(false); } + catch (OperationCanceledException) when (stop.IsCancellationRequested) { break; } + } + outgoing.Writer.TryComplete(); + } + + internal async Task PollOnce(CancellationToken cancel = default) + { + if (!cursors.TryGetValue(key, out ulong since)) + { + // Establish the live boundary from Discord, not the machine clock, and never dump old history on entry. + var latest = await api.Request(HttpMethod.Get, $"channels/{route.ChannelId}/messages?limit=1", null, cancel).ConfigureAwait(false); + if (latest.ValueKind != JsonValueKind.Array) throw new InvalidDataException("Invalid Discord message list."); + ulong newest = 0; + foreach (var row in latest.EnumerateArray()) + if (TryReadMessageId(row, out ulong id)) newest = Math.Max(newest, id); + cursors[key] = newest; + return; + } + var messages = new Dictionary(); + string query = "after=" + since; + // Fetch older pages too when the API returns the newest page first. Bound reconnect catch-up to 1,000 lines. + for (int page = 0; page < 10; page++) + { + var rows = await api.Request(HttpMethod.Get, $"channels/{route.ChannelId}/messages?{query}&limit=100", null, cancel).ConfigureAwait(false); + if (rows.ValueKind != JsonValueKind.Array) throw new InvalidDataException("Invalid Discord message list."); + ulong oldest = ulong.MaxValue; + foreach (var row in rows.EnumerateArray()) + { + if (!TryReadMessageId(row, out ulong id)) continue; + oldest = Math.Min(oldest, id); + if (id > since) messages.TryAdd(id, row); + } + if (rows.GetArrayLength() < 100 || oldest <= since || oldest == ulong.MaxValue) break; + query = "before=" + oldest; + } + foreach (var (id, message) in messages.OrderBy(m => m.Key)) + { + var author = message.GetProperty("author"); + if (!(author.TryGetProperty("bot", out var bot) && bot.ValueKind == JsonValueKind.True) + && !message.TryGetProperty("webhook_id", out _)) + { + string text = IncomingText(message); + if (!string.IsNullOrWhiteSpace(text)) + await deliver(IncomingName(author), text).ConfigureAwait(false); + else if (!warnedEmptyContent) + { + warnedEmptyContent = true; + log("Discord returned a human message without readable text. If it contained text, enable Message Content Intent under Developer Portal > Bot, then send a new message."); + } + } + cursors[key] = id; + } + } + + bool TryReadMessageId(JsonElement row, out ulong id) + { + id = 0; + return (!row.TryGetProperty("channel_id", out var channel) + || channel.ValueKind == JsonValueKind.String && channel.GetString() == route.ChannelId) + && row.TryGetProperty("id", out var value) && value.ValueKind == JsonValueKind.String + && ulong.TryParse(value.GetString(), out id) && id != 0; + } + + internal async Task SendQueued(CancellationToken cancel = default) + { + for (int i = 0; i < 5 && outgoing.Reader.TryPeek(out var item); i++) + { + if (time.GetUtcNow() - item.Created > TimeSpan.FromMinutes(5)) { outgoing.Reader.TryRead(out _); continue; } + string body = new JsonObject + { + ["content"] = item.Text, + ["nonce"] = item.Nonce, + ["enforce_nonce"] = true, + ["allowed_mentions"] = new JsonObject { ["parse"] = new JsonArray() } + }.ToJsonString(); + try { await api.Request(HttpMethod.Post, $"channels/{route.ChannelId}/messages", body, cancel).ConfigureAwait(false); } + catch (DiscordApiException error) when (error.Status == 403) + { + Volatile.Write(ref sendingDenied, 1); + outgoing.Writer.TryComplete(); + while (outgoing.Reader.TryRead(out _)) { } + log($"Discord posting disabled (HTTP 403) for channel {route.ChannelId}. Incoming relay remains enabled. Check Send Messages or Send Messages in Threads, then reload the module."); + return; + } + catch (DiscordApiException error) when (error.Status == 400) + { log("Discord rejected a message; it was discarded without affecting game chat."); } + outgoing.Reader.TryRead(out _); + } + } + + static string IncomingName(JsonElement author) + { + static string SenderName(string? name) => string.Concat((name ?? "") + .Where(c => char.IsAsciiLetterOrDigit(c) || c is '_' or '-').Take(23)); + if (author.TryGetProperty("global_name", out var display) && display.ValueKind == JsonValueKind.String + && SenderName(display.GetString()) is { Length: >= 3 } displayName) + return displayName; + string username = SenderName(author.GetProperty("username").GetString()); + return username.Length >= 3 ? username : "DiscordUser"; + } + + static string IncomingText(JsonElement message) + { + string text = message.TryGetProperty("content", out var content) ? content.GetString() ?? "" : ""; + if (message.TryGetProperty("mentions", out var mentions)) + foreach (var mention in mentions.EnumerateArray()) + { + string? id = mention.GetProperty("id").GetString(); + string name = mention.GetProperty("username").GetString() ?? "user"; + text = text.Replace("<@" + id + ">", "@" + name).Replace("<@!" + id + ">", "@" + name); + } + if (message.TryGetProperty("attachments", out var attachments)) + foreach (var attachment in attachments.EnumerateArray().Take(3)) + if (attachment.TryGetProperty("url", out var url) && Uri.TryCreate(url.GetString(), UriKind.Absolute, out var uri) && uri.Scheme == "https") + text += " " + uri.AbsoluteUri; + return ChatWire.Clean(text.Replace('\n', ' ').Replace('\r', ' ')); + } + + public void Dispose() + { + if (Interlocked.Exchange(ref disposed, 1) != 0) return; + stop.Cancel(); outgoing.Writer.TryComplete(); + running?.GetAwaiter().GetResult(); + http.Dispose(); stop.Dispose(); + } +} diff --git a/mods/globalchat/GlobalChat.csproj b/mods/globalchat/GlobalChat.csproj index 00be0d9..dc9e754 100644 --- a/mods/globalchat/GlobalChat.csproj +++ b/mods/globalchat/GlobalChat.csproj @@ -3,6 +3,7 @@ + diff --git a/mods/globalchat/GlobalChatMod.cs b/mods/globalchat/GlobalChatMod.cs index dffbf9b..303838a 100644 --- a/mods/globalchat/GlobalChatMod.cs +++ b/mods/globalchat/GlobalChatMod.cs @@ -1,16 +1,144 @@ +using System.Text.Json; +using System.Text.Json.Nodes; +using GameServer.Core.Chat; +using GameServer.Core.Protocol.Instance; using GameServer.Modding; namespace GlobalChat; -/// Moves chat to the global chat server while the mod is on; off, the Gateway's local chat server has it again. public sealed class GlobalChatMod : IMod { - sealed record Choices(string Host, int Port); + // The channel prefix alone carries no player name. Neutralize markup in the displayed text. + internal static byte[] IncomingLine(string name, string text, TypedChannel channel = TypedChannel.Global) => + InstanceChat.ChatLine(ChatWire.Clean($"[Discord] {name} : {text.Replace('<', '<')}"), InstanceChat.Sender(channel, "")); + + internal static ChatChoices ReadSettings(IModContext mod) + { + string path = Path.Combine(mod.Folder, "globalchat.json"); + if (!File.Exists(path)) return mod.Settings(); + + var schema = ModSettings.Parse(File.ReadAllText(Path.Combine(mod.Folder, ModSettings.FileName))); + // The editor declares each field. Validate individual routes separately when reading a hand-edited file. + var declarations = schema.Settings.ToDictionary(); + foreach (string name in new[] { "globalChannels", "tradeChannels" }) + { + var map = declarations[name]; + declarations[name] = map with { Value = map.Value! with { Settings = new Dictionary() } }; + } + string json = File.ReadAllText(path); + try + { + if (JsonNode.Parse(json, documentOptions: new() { CommentHandling = JsonCommentHandling.Skip, AllowTrailingCommas = true }) + is JsonObject values) + { + if (values["sendToDiscord"] is JsonValue legacy && legacy.TryGetValue(out bool forward)) + foreach (string name in new[] { "globalChannels", "tradeChannels" }) + if (values[name] is JsonObject channels) + foreach (var (_, route) in channels) + if (route is JsonObject entry && !entry.ContainsKey("sendToDiscord") + && entry["type"] is JsonValue kind && kind.TryGetValue(out string? nameOfType) + && string.Equals(nameOfType, "discord", StringComparison.OrdinalIgnoreCase)) + entry["sendToDiscord"] = forward; + if (values["fallbackRoute"] is JsonObject fallback && fallback["type"]?.ToJsonString() == "\"none\"") + fallback["type"] = "blank"; + values.Remove("sendToDiscord"); + values.Remove("useSharedServer"); + values.Remove("enableDiscord"); + values.Remove("enableFakeChats"); + values.Remove("host"); + values.Remove("port"); + values.Remove("globalChatSeconds"); + values.Remove("language"); + json = values.ToJsonString(); + } + } + catch (JsonException) { } // The host settings merger reports invalid JSON. + return ModSettings.Bound(ModSettings.Merge(schema with { Settings = declarations }, json, mod.Log)); + } - /// public void Load(IModContext mod) { - var server = mod.Settings(); - ChatRoutes.Use(mod.Manifest.Id, server.Host, server.Port); + var settings = ReadSettings(mod); + string owner = mod.Manifest.Id; + var routing = new ChatChannelRouting(settings, mod.Log); + var endpoints = routing.ChannelServers(); + var whisperServer = endpoints.Values.FirstOrDefault(endpoint => endpoint is not null); + if (whisperServer is not null || routing.FallbackServer is not null) + ChatRoutes.Use(owner, whisperServer, endpoints, routing.FallbackServer); + + if (routing.HasFakeChat) + { + var simulation = new SimulatedChat(routing, mod.Log); + mod.Lifetime.Own(simulation); + GameEvents.ChatPosted.Add(owner, simulation.OnPlayerChat); + simulation.Start(); + } + + var routes = routing.DiscordRoutes(mod.Log).ToArray(); + if (routes.Length == 0) return; + string? token = Environment.GetEnvironmentVariable("LOCALEXILE_DISCORD_BOT_TOKEN")?.Trim(); + if (string.IsNullOrEmpty(token)) token = settings.DiscordBotToken?.Trim(); + if (string.IsNullOrWhiteSpace(token) + || token.Any(c => !char.IsAsciiLetterOrDigit(c) && c is not ('.' or '_' or '-'))) + { + mod.Log("Discord bridge needs a valid Discord bot token in globalchat.json or LOCALEXILE_DISCORD_BOT_TOKEN."); + return; + } + + var bridges = new Dictionary<(ChatChannelKind Kind, ushort Channel), DiscordBridge>(routes.Length); + DiscordBridge? fallback = null; + foreach (var route in routes) + { + var bridge = StartRoute(mod, route, routing, token); + if (route.IsFallback) fallback = bridge; + else bridges.Add((route.Kind, route.Channel), bridge); + } + + if (routes.Any(route => route.SendToDiscord)) + GameEvents.ChatPosted.Add(owner, (_, line) => + { + if (line is not { Kind: { } kind, Channel: { } channel }) return; + if (bridges.TryGetValue((kind, channel), out var bridge)) bridge.Enqueue(line); + else if (!routing.IsDefined(kind, channel)) fallback?.Enqueue(line); + }); + } + + static DiscordBridge StartRoute(IModContext mod, DiscordRoute route, ChatChannelRouting routing, string token) + { + string room = route.IsFallback ? "fallback" : $"{route.Kind} {route.Channel}"; + string packetLabel = $"0x0017 Discord {room}"; + ChatChannelKind[] kinds = route.IsFallback ? [ChatChannelKind.Global, ChatChannelKind.Trade] : [route.Kind]; + + bool Eligible(ClientState conn, ChatChannelKind kind) => ChatRoom.IsListener(conn) + && ChatRoutes.Membership(Program.CharacterName(conn), kind) is { } membership + && (route.IsFallback ? !routing.IsDefined(kind, membership.Channel) : membership.Channel == route.Channel); + + bool HasAudience() + { + foreach (var player in Program.InGame) + if (kinds.Any(kind => Eligible(player.Key, kind))) return true; + return false; + } + async Task Deliver(string name, string text) + { + foreach (var player in Program.InGame) + { + var conn = player.Key; + if (conn.Outbox is not { } output) continue; + foreach (var kind in kinds) + { + if (!Eligible(conn, kind)) continue; + var channel = kind == ChatChannelKind.Trade ? TypedChannel.Trade : TypedChannel.Global; + try { await output(IncomingLine(name, text, channel), packetLabel); } + catch (Exception error) when (error is IOException or ObjectDisposedException) { } + } + } + } + var bridge = new DiscordBridge(route, token, Deliver, HasAudience, + message => mod.Log($"{room}: {message}")); + mod.Lifetime.Own(bridge); + bridge.Start(); + mod.Log($"Discord bridge enabled for {room}."); + return bridge; } } diff --git a/mods/globalchat/README.md b/mods/globalchat/README.md index f08fc33..675de9e 100644 --- a/mods/globalchat/README.md +++ b/mods/globalchat/README.md @@ -1,25 +1,115 @@ # Global Chat -Talk to other LocalExile players, whichever server they run. While this mod is on, global, trade and whisper chat go -through the LocalExile global chat server. Turn it off and chat is back on your own local chat server, without a restart. -Local chat stays between the players in your area. +GlobalChat connects selected Global and Trade channels to shared LocalExile servers, Discord, or simulated chat. Ordinary +area chat stays within the area. -If the server cannot be reached, chat says so and stays local, and tries again at an area change a minute later. -Lines and character names pass through that server unencrypted; it stores nothing. +## Defaults -## Settings +| Channel | Route | +| --- | --- | +| Global 1 | Shared server at `localexile-chat.duckdns.org:6113` | +| Global 2 | Discord, active once the route has a channel ID and the Gateway has a bot token | +| Global 8 | Simulated chat | +| Undefined Global and Trade channels | Local chat | -| Setting | Default | What it is | -|---|---|---| -| Address | `localexile-chat.duckdns.org` | the IP or host name of the chat server | -| Port | `6113` | its port | +## Configure channels -Anyone can run a chat server for their own group (`src/GameServer.Chat` in LocalExile) and put its address here. +In a Waypoint build that supports mod-folder settings, open **Mods → GlobalChat → Settings**. Use **Add entry** or +**Remove** under Global and Trade channel routes. Choose a route type to show its settings. -## Chat commands +For manual setup, save `globalchat.json` beside `mod.json` in `Mods/Binaries/globalchat/`. When that file is absent, the +mod reads `data/mods/globalchat.json`. The Gateway reloads the mod after either file changes. -None. +| Route | JSON type | Settings | +| --- | --- | --- | +| Local chat | `blank` | Uses the Gateway’s local chat server | +| Shared server | `server` | `address` and `port` | +| Discord | `discord` | A quoted `discordChannelId` and optional `sendToDiscord` | +| Simulated chat | `fake` | Starts when a local player listens in the room | -## LocalExile versions +```json +{ + "discordBotToken": "", + "fallbackRoute": { "type": "blank" }, + "globalChannels": { + "1": { "type": "server", "address": "localexile-chat.duckdns.org", "port": 6113 }, + "2": { "type": "discord", "discordChannelId": "111111111111111111", "sendToDiscord": false }, + "8": { "type": "fake" } + }, + "tradeChannels": { + "2": { "type": "server", "address": "chat.example.net", "port": 6114 } + } +} +``` -1.1.4 works with LocalExile v0.4.3-beta, v0.5.0-beta, v0.5.1-beta and v0.5.2-beta (the same code as 1.1.2); 1.1.1 with v0.4.2-beta; 1.1.0 with v0.4.1-beta, the first with the one hook system (`GameEvents`). Its 1.0.x versions work with v0.2.0-beta to v0.4.0-beta. Needs a LocalExile with the Chat module (`ChatRoutes.Use`). +Use channel numbers 1–65534. An explicit `globalChannels` or `tradeChannels` map replaces its defaults. Removing a row +makes that channel use the fallback. An explicit `blank` row keeps that channel local regardless of the fallback. + +### Fallback for undefined channels + +`fallbackRoute` accepts all four route types. **Local chat** is the default. A shared fallback uses one endpoint for +undefined rooms, with their channel numbers and languages kept separate. A simulated fallback simulates each room while +it has a local listener. A Discord fallback connects all undefined Global and Trade rooms to one Discord channel. +It is receive-only by default. Setting `sendToDiscord` to `true` forwards player messages from those rooms to that same +Discord channel. Give the fallback its own Discord channel ID, distinct from any explicit route. + +### Shared servers and whispers + +Each shared route can use a separate endpoint. Players on the same endpoint, channel number, channel kind, and chat +language share a room. Whispers use the endpoint of the first explicitly configured shared Global channel by number, +then the first shared Trade channel. With no explicit shared route, whispers stay local. + +If a shared server becomes unavailable, its rooms use local chat. The Gateway retries after a one-minute cooldown on +a later area change or channel join. Chat lines and character names travel unencrypted to the shared server. You can +run the chat server for your own group from `src/GameServer.Chat` in LocalExile. + +### Discord setup + +**Set up your own Discord bot.** Create a Discord app, enable **Message Content Intent** on its **Bot** page, and install the +bot in your server using a Server Install link with the `bot` scope. Copy the token from the **Bot** page and paste it +into **Discord bot token** in Waypoint's GlobalChat settings, or set `discordBotToken` in your local `globalchat.json`. +The input is masked in Waypoint. The local JSON file and its configuration backups store the value as plain text, +so keep them private and out of Git. The shipped default is empty. +See [Discord's bot setup guide](https://docs.discord.com/developers/quick-start/getting-started). + +Give the bot **View Channel** and **Read Message History** on the mapped channels. For two-way chat, +also grant **Send Messages**, or **Send Messages in Threads** for a thread, and set that route's `sendToDiscord` to `true`. +Set `discordChannelId` on the Gateway route to the channel or thread ID. + +Set `LOCALEXILE_DISCORD_BOT_TOKEN` in the Gateway's launch environment to override the saved value or keep the token +out of the mod config. On Windows, open PowerShell in the LocalExile checkout and run this for a session-only token. + +```powershell +$secret = Read-Host 'Discord bot token' -AsSecureString +$previousToken = $env:LOCALEXILE_DISCORD_BOT_TOKEN +try { + $env:LOCALEXILE_DISCORD_BOT_TOKEN = ([PSCredential]::new('DiscordBot', $secret)).GetNetworkCredential().Password + .\scripts\dev\live.ps1 +} +finally { + $env:LOCALEXILE_DISCORD_BOT_TOKEN = $previousToken + $secret.Dispose() +} +``` + +If you use Waypoint, launch a fresh Waypoint process from that PowerShell session in place of `live.ps1` and +restart the Gateway from Waypoint. For a service-managed Gateway, set the same variable in the service's private +environment and restart the service. + +Each explicit Discord route uses a distinct channel or thread ID. Discord messages appear for local players listening +to the mapped room in any game chat language. The bridge ignores bot and webhook messages. Game-to-Discord forwards +accepted player messages only, so the chat server must include channel metadata in its accepted lines. + +## Simulated chat + +Simulated chat starts automatically when a player listens in a room configured with the `fake` route. The mod unloads +its embedded chat library once all simulated rooms are empty. To disable simulation for a channel, change that +channel's route in the mod settings. + +## Compatibility + +- **Required** — Merge the LocalExile server PR from `pr/globalchat-hooks` before the GlobalChat expansion PR. +- **Optional** — Waypoint's `pr/mod-channel-settings` PR adds the channel controls in **Mods → GlobalChat → Settings**. + You can also edit `globalchat.json` directly. + +GlobalChat 1.1.4 supports LocalExile v0.4.3-beta through v0.5.2-beta. diff --git a/mods/globalchat/SimulatedChat.cs b/mods/globalchat/SimulatedChat.cs new file mode 100644 index 0000000..5fa4dd8 --- /dev/null +++ b/mods/globalchat/SimulatedChat.cs @@ -0,0 +1,421 @@ +using System.Text.Json; +using System.Text.Json.Serialization; +using System.Text.RegularExpressions; +using System.IO.Compression; +using GameServer.Core.Chat; +using GameServer.Core.Protocol.Instance; + +namespace GlobalChat; + +sealed record GlobalChatGroup(string Id, double Weight, string[] Messages); +sealed record GlobalChatLibrary(GlobalChatGroup[] Groups, GlobalChatBurst[] Bursts); + +sealed record GlobalChatBurstLine( + [property: JsonPropertyName("speaker")] int Speaker, + [property: JsonPropertyName("delay_s")] int DelaySeconds, + [property: JsonPropertyName("group")] string Group, + [property: JsonPropertyName("text")] string Text); + +sealed record GlobalChatBurst( + [property: JsonPropertyName("lines")] GlobalChatBurstLine[] Lines); + +[JsonSerializable(typeof(GlobalChatLibrary))] +sealed partial class SimulatedChatJsonContext : JsonSerializerContext; + +/// Fake chat simulation for configured rooms with listeners. +sealed class SimulatedChat(ChatChannelRouting routing, Action log) : IDisposable +{ + sealed class FakeChatRoom(DateTime now) + { + internal readonly List<(DateTime DueUtc, string Speaker, string Group, string Text)> Pending = []; + internal DateTime NextChat = now.AddSeconds(3); + internal long LastSeenTick; + } + + readonly Dictionary _fakeRooms = []; + long _chatTick; + readonly Queue _recentChatMessages = new(); + readonly Queue _recentChatSpeakers = new(); + GlobalChatGroup[] _chatGroups = []; + Dictionary _chatGroupById = new(StringComparer.OrdinalIgnoreCase); + Dictionary> _chatKeywordIndex = new(StringComparer.OrdinalIgnoreCase); + double[] _chatGroupCumulative = []; + GlobalChatBurst[] _chatBursts = []; + readonly Lock gate = new(); + readonly Random _random = new(); + readonly CancellationTokenSource stop = new(); + Task? running; + bool _chatLoadAttempted; + + static readonly HashSet ChatStopWords = new( + [ + "what", "where", "when", "which", "that", "this", "with", "from", "have", "does", "your", "they", + "them", "then", "than", "there", "their", "would", "could", "should", "about", "into", "just", + "like", "some", "more", "only", "very", "much", "many", "also", "even", "still", "here", "good", + "best", "make", "made", "need", "want", "know", "think", "league", "anyone", "someone", "how" + ], StringComparer.OrdinalIgnoreCase); + + internal void Start() => running = Task.Run(Run); + + async Task Run() + { + using var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(250)); + try + { + while (await timer.WaitForNextTickAsync(stop.Token).ConfigureAwait(false)) + lock (gate) TickGlobalChat(); + } + catch (OperationCanceledException) when (stop.IsCancellationRequested) { } + } + + public void Dispose() + { + stop.Cancel(); + running?.GetAwaiter().GetResult(); + lock (gate) UnloadGlobalChat(); + stop.Dispose(); + } + + bool EnsureGlobalChatLoaded() + { + if (_chatLoadAttempted) return _chatGroups.Length > 0; + _chatLoadAttempted = true; + var (groups, bursts) = LoadGlobalChatLibrary(log); + if (groups.Length == 0) return false; + _chatGroups = groups; + _chatBursts = bursts; + _chatGroupById = groups.ToDictionary(g => g.Id, StringComparer.OrdinalIgnoreCase); + _chatGroupCumulative = new double[groups.Length]; + double sum = 0; + for (int i = 0; i < groups.Length; i++) + _chatGroupCumulative[i] = sum += Math.Max(0.001, groups[i].Weight); + + foreach (var g in groups) + { + if (g.Id is "questions_help" or "item_showcase" or "lfg_sharing") continue; + foreach (string msg in g.Messages) + { + if (msg.EndsWith('?')) continue; + string lower = msg.ToLowerInvariant(); + foreach (var match in Regex.EnumerateMatches(lower, "[a-z0-9]{4,}")) + { + string w = lower.Substring(match.Index, match.Length); + if (ChatStopWords.Contains(w)) continue; + if (!_chatKeywordIndex.TryGetValue(w, out var list)) _chatKeywordIndex[w] = list = []; + list.Add((g.Id, msg)); + } + } + } + + log($"loaded simulated chat ({groups.Length} groups, {groups.Sum(g => g.Messages.Length)} messages, {bursts.Length} conversation bursts)"); + return true; + } + + void UnloadGlobalChat() + { + _fakeRooms.Clear(); + if (!_chatLoadAttempted) return; + _chatLoadAttempted = false; + _recentChatMessages.Clear(); + _recentChatSpeakers.Clear(); + _chatGroups = []; + _chatBursts = []; + _chatGroupCumulative = []; + _chatGroupById = new(StringComparer.OrdinalIgnoreCase); + _chatKeywordIndex = new(StringComparer.OrdinalIgnoreCase); + } + + internal void OnPlayerChat(ClientState conn, ChatFrame line) + { + lock (gate) + { + if (stop.IsCancellationRequested || !IsChatListener(conn) + || line is not { Kind: { } kind, Channel: { } channel, Language: { } language, Text: { Length: > 0 } text } + || FakeChatRoomOf(conn, kind) != new ChatRoom(kind, channel, language) + || !EnsureGlobalChatLoaded()) return; + var now = DateTime.UtcNow; + EnqueueRepliesToPlayerLocked(Room(new(kind, channel, language), now), now, Program.CharacterName(conn), text); + } + } + + void EnqueueRepliesToPlayerLocked(FakeChatRoom room, DateTime now, string playerName, string userMessage) + { + var used = new HashSet(StringComparer.OrdinalIgnoreCase) { playerName }; + string lower = userMessage.ToLowerInvariant(); + + if (Regex.IsMatch(lower, @"^(hi|hey|hello|yo|sup|morning|gm|o/|glhf)\b")) + { + if (_chatGroupById.TryGetValue("greetings_parting", out var fg) && PickGroupMessage(fg) is { } msg) + room.Pending.Add((now.AddSeconds(1.5 + _random.NextDouble() * 2.5), PickChatSpeaker(used), fg.Id, msg)); + return; + } + if (Regex.IsMatch(lower, @"\b(dropped|got a|first|found a)\b.*\b(mirror|mageblood|mb|headhunter|hh|divine|div|apothecary)\b") && !lower.EndsWith('?')) + { + int count = 2 + _random.Next(2); + double delay = 1.5 + _random.NextDouble() * 2; + for (int i = 0; i < count; i++) + { + string grpId = i == count - 1 && _random.NextDouble() < 0.4 ? "vaal_gambling" : "reactions_gratz"; + if (_chatGroupById.TryGetValue(grpId, out var fg) && PickGroupMessage(fg) is { } msg) + { + room.Pending.Add((now.AddSeconds(delay), PickChatSpeaker(used), fg.Id, msg)); + delay += 1.5 + _random.NextDouble() * 2.5; + } + } + return; + } + if (Regex.IsMatch(lower, @"\b(bricked|poofed|ripped|died|lost my)\b")) + { + string grpId = _random.NextDouble() < 0.65 ? "reactions_sympathy" : "reactions_humor"; + if (_chatGroupById.TryGetValue(grpId, out var fg) && PickGroupMessage(fg) is { } msg) + room.Pending.Add((now.AddSeconds(1.5 + _random.NextDouble() * 2.5), PickChatSpeaker(used), fg.Id, msg)); + return; + } + + var words = Regex.Matches(lower, "[a-z0-9]{4,}") + .Select(m => m.Value) + .Where(w => !ChatStopWords.Contains(w) && _chatKeywordIndex.ContainsKey(w)) + .Distinct(StringComparer.OrdinalIgnoreCase) + .OrderBy(w => _chatKeywordIndex[w].Count) + .ToArray(); + + if (words.Length > 0) + { + var matches = new List<(string Group, string Text)>(); + foreach (string w in words) + matches.AddRange(_chatKeywordIndex[w].Where(m => !string.Equals(m.Text, userMessage, StringComparison.OrdinalIgnoreCase))); + if (matches.Count > 0) + { + var pick = matches[_random.Next(Math.Min(matches.Count, 15))]; + room.Pending.Add((now.AddSeconds(2 + _random.NextDouble() * 3.5), PickChatSpeaker(used), pick.Group, pick.Text)); + return; + } + } + + if (_random.NextDouble() < 0.6) + { + string fbId = lower.EndsWith('?') ? "answers_advice" : "reactions_humor"; + if (_chatGroupById.TryGetValue(fbId, out var fb) && PickGroupMessage(fb) is { } msg) + room.Pending.Add((now.AddSeconds(2 + _random.NextDouble() * 3), PickChatSpeaker(used), fb.Id, msg)); + } + } + + ChatRoom? FakeChatRoomOf(ClientState conn, ChatChannelKind kind) => + ChatRoom.Of(conn, kind) is { } room + && routing.Find(kind, room.Channel)?.Type == ChatChannelRouteType.Fake ? room : null; + + static bool IsChatListener(ClientState conn) => ChatRoom.IsListener(conn); + + FakeChatRoom Room(ChatRoom key, DateTime now) + { + if (!_fakeRooms.TryGetValue(key, out var room)) _fakeRooms.Add(key, room = new(now)); + return room; + } + + double NextGlobalChatGapSeconds() => 12 + _random.NextDouble() * 26; + + void TickGlobalChat() + { + if (!routing.HasFakeChat) + { + UnloadGlobalChat(); + return; + } + var now = DateTime.UtcNow; + long tick = ++_chatTick; + foreach (var (conn, _) in Program.InGame) + { + if (!IsChatListener(conn)) continue; + if (FakeChatRoomOf(conn, ChatChannelKind.Global) is { } global) Room(global, now).LastSeenTick = tick; + if (FakeChatRoomOf(conn, ChatChannelKind.Trade) is { } trade) Room(trade, now).LastSeenTick = tick; + } + foreach (var (key, room) in _fakeRooms) + { + if (room.LastSeenTick != tick) { _fakeRooms.Remove(key); continue; } + if (EnsureGlobalChatLoaded()) TickChatRoom(key, room, now); + } + if (_fakeRooms.Count == 0) UnloadGlobalChat(); + } + + void TickChatRoom(ChatRoom key, FakeChatRoom room, DateTime now) + { + if (room.Pending.Count == 0 && now >= room.NextChat) + { + EnqueueChatEventLocked(room, now); + room.NextChat = now.AddSeconds(NextGlobalChatGapSeconds()); + } + List<(DateTime DueUtc, string Speaker, string Group, string Text)>? due = null; + for (int i = room.Pending.Count - 1; i >= 0; i--) + { + if (room.Pending[i].DueUtc > now) continue; + (due ??= []).Add(room.Pending[i]); + room.Pending.RemoveAt(i); + } + if (due is null) return; + var listeners = new List(); + foreach (var player in Program.InGame) + if (IsChatListener(player.Key) && FakeChatRoomOf(player.Key, key.Kind) == key) listeners.Add(player.Key); + due.Sort((a, b) => a.DueUtc.CompareTo(b.DueUtc)); + foreach (var item in due) + _ = BroadcastChatAsync(key, listeners, item.Speaker, item.Text); + } + + async Task BroadcastChatAsync(ChatRoom room, IReadOnlyList listeners, string speaker, string text) + { + string senderTag = InstanceChat.Sender(room.TypedChannel, speaker); + foreach (var conn in listeners) + { + if (stop.IsCancellationRequested || !IsChatListener(conn) || FakeChatRoomOf(conn, room.Kind) != room || conn.Outbox is not { } outbox) continue; + // Allocate per recipient because Outbox encrypts the buffer in place. + byte[] packet = InstanceChat.ChatLine(text, senderTag); + try { await outbox(packet, $"0x0017 {room} fake chat from {speaker}"); } + catch (Exception e) when (e is IOException or ObjectDisposedException) { } + } + } + + static readonly string[] GivenNames = ["Nyx", "Brynn", "Sigrid", "Corvin", "Dorian", "Maelis", + "Riven", "Thalia", "Vesper", "Ivara", "Kaelen", "Neris", "Sylas", "Veyra"]; + static readonly string[] Epithets = ["Ash", "Grimm", "Ironwood", "Hollow", "Rook", "Moonveil", + "Grey", "Blackthorn", "Storm", "Wren", "Ember", "Barrow"]; + static readonly string[] ChineseNames = ["星河旅人", "山间拾梦", "听雨归人", "云上青舟", "月下寻风", + "雾海微光", "长夜有灯", "暮色归舟", "青山旧客", "清风问月", "独行山海", "流萤照野"]; + + string PickChatSpeaker(HashSet? usedInBurst = null) + { + string name; + int attempt = 0; + do + { + name = _random.NextDouble() < 0.72 + ? $"{GivenNames[_random.Next(GivenNames.Length)]}_{Epithets[_random.Next(Epithets.Length)]}" + : ChineseNames[_random.Next(ChineseNames.Length)]; + if (++attempt > 20) name += "_" + new string(_random.GetItems("abcdefghijklmnopqrstuvwxyz".AsSpan(), 3)); + } + while (usedInBurst?.Contains(name) == true || _recentChatSpeakers.Contains(name) + || Program.InGame.Keys.Any(conn => string.Equals(Program.CharacterName(conn), name, StringComparison.OrdinalIgnoreCase))); + RememberSpeaker(name); + usedInBurst?.Add(name); + return name; + } + + void RememberSpeaker(string name) + { + _recentChatSpeakers.Enqueue(name); + while (_recentChatSpeakers.Count > 8) _recentChatSpeakers.Dequeue(); + } + + string? PickGroupMessage(GlobalChatGroup group) + { + if (group.Messages.Length == 0) return null; + string pick = group.Messages[_random.Next(group.Messages.Length)]; + for (int attempt = 0; attempt < 8; attempt++) + { + string cand = group.Messages[_random.Next(group.Messages.Length)]; + if (!_recentChatMessages.Contains(cand)) { pick = cand; break; } + } + _recentChatMessages.Enqueue(pick); + while (_recentChatMessages.Count > 64) _recentChatMessages.Dequeue(); + return pick; + } + + void EnqueueChatEventLocked(FakeChatRoom room, DateTime now) + { + var usedSpeakers = new HashSet(StringComparer.OrdinalIgnoreCase); + + if (_chatBursts.Length > 0 && _random.NextDouble() < 0.58) + { + var burst = _chatBursts[_random.Next(_chatBursts.Length)]; + var speakerMap = new Dictionary(); + foreach (var line in burst.Lines) + { + if (!speakerMap.TryGetValue(line.Speaker, out string? spk)) + speakerMap[line.Speaker] = spk = PickChatSpeaker(usedSpeakers); + room.Pending.Add((now.AddSeconds(Math.Clamp(line.DelaySeconds, 0, 45)), spk, line.Group, line.Text)); + } + return; + } + double pick = _random.NextDouble() * _chatGroupCumulative[^1]; + int idx = Array.BinarySearch(_chatGroupCumulative, pick); + var group = _chatGroups[Math.Min(idx < 0 ? ~idx : idx, _chatGroups.Length - 1)]; + + if (PickGroupMessage(group) is not { } msg) return; + string speaker = PickChatSpeaker(usedSpeakers); + room.Pending.Add((now, speaker, group.Id, msg)); + + bool isGoodLuck = !msg.EndsWith('?') && !Regex.IsMatch(msg, @"\b(can i have|give me|free|beg|poor|broke|never|0 )\b", RegexOptions.IgnoreCase) + && (group.Id == "loot_drops" || Regex.IsMatch(msg, @"\b(first ever|finally|just got|just dropped|dropped a|dropped my|6 linked|six linked|lucky|thank god|sold my|500div|mageblood|mirror|headhunter)\b", RegexOptions.IgnoreCase)); + bool isBadLuck = Regex.IsMatch(msg, @"\b(bricked|poofed|ripped|died|deaths|unlucky|cursed|scam|worst|broke|poor|lag|crash)\b", RegexOptions.IgnoreCase); + bool isNewsOrMeme = group.Id == "memes_banter" || Regex.IsMatch(msg, @"\b(just released|remake|patch|update|poe2|d4|diablo|twitch|nerf|buff|league|reddit)\b", RegexOptions.IgnoreCase); + + if (isGoodLuck) + { + if (_random.NextDouble() < 0.70) + { + int replies = 1 + _random.Next(3); + int delay = 2 + _random.Next(3); + for (int r = 0; r < replies; r++) + { + string followGroupId = r == replies - 1 && _random.NextDouble() < 0.25 ? "vaal_gambling" : "reactions_gratz"; + if (_chatGroupById.TryGetValue(followGroupId, out var fg)) + { + string fmsg = followGroupId == "vaal_gambling" ? "don't forget to vaal" : PickGroupMessage(fg) ?? "gz"; + room.Pending.Add((now.AddSeconds(delay), PickChatSpeaker(usedSpeakers), fg.Id, fmsg)); + delay += 2 + _random.Next(3); + } + } + } + return; + } + if (isBadLuck) + { + if (_random.NextDouble() < 0.65) + { + int replies = 1 + (_random.NextDouble() < 0.45 ? 1 : 0); + int delay = 2 + _random.Next(3); + for (int r = 0; r < replies; r++) + { + string followGroupId = r == 0 && _random.NextDouble() < 0.65 ? "reactions_sympathy" : "reactions_humor"; + if (_chatGroupById.TryGetValue(followGroupId, out var fg) && PickGroupMessage(fg) is { } fmsg) + { + room.Pending.Add((now.AddSeconds(delay), PickChatSpeaker(usedSpeakers), fg.Id, fmsg)); + delay += 2 + _random.Next(3); + } + } + } + return; + } + if (isNewsOrMeme) + { + if (_random.NextDouble() < 0.65) + { + int delay = 2 + _random.Next(3); + if (_chatGroupById.TryGetValue("reactions_humor", out var fg) && PickGroupMessage(fg) is { } fmsg) + room.Pending.Add((now.AddSeconds(delay), PickChatSpeaker(usedSpeakers), fg.Id, fmsg)); + if (_random.NextDouble() < 0.50) + EnqueueRepliesToPlayerLocked(room, now.AddSeconds(delay + 1), speaker, msg); + } + return; + } + if (_random.NextDouble() < 0.60) + EnqueueRepliesToPlayerLocked(room, now, speaker, msg); + } + + internal static (GlobalChatGroup[] Groups, GlobalChatBurst[] Bursts) LoadGlobalChatLibrary(Action log) + { + try + { + using var resource = typeof(SimulatedChat).Assembly.GetManifestResourceStream("GlobalChat.SimulatedChat") + ?? throw new InvalidDataException("The simulated chat library is missing."); + using var text = new StreamReader(resource); + using var compressed = new MemoryStream(Convert.FromBase64String(text.ReadToEnd())); + using var stream = new BrotliStream(compressed, CompressionMode.Decompress); + var library = JsonSerializer.Deserialize(stream, SimulatedChatJsonContext.Default.GlobalChatLibrary); + return library is null ? ([], []) : (library.Groups, library.Bursts); + } + catch (Exception error) when (error is IOException or InvalidDataException or JsonException or FormatException) + { + log($"failed to load simulated chat: {error.Message}"); + return ([], []); + } + } +} diff --git a/mods/globalchat/mod.json b/mods/globalchat/mod.json index 4845804..fe49478 100644 --- a/mods/globalchat/mod.json +++ b/mods/globalchat/mod.json @@ -1,10 +1,11 @@ { "id": "globalchat", "name": "Global Chat", - "description": "Talk to other LocalExile players: global, trade and whisper chat go through the LocalExile global chat server.", + "description": "Talk to other LocalExile players through a shared chat server, with optional Discord and simulated chat routes.", "author": "JetStream", - "version": "1.1.4", - "compatibleClientVersions": ["0.4.3-beta", "0.5.0-beta", "0.5.1-beta", "0.5.2-beta"], + "version": "1.2.16", + "compatibleClientVersions": ["0.5.2-beta"], "kind": "feature", + "userSettingsFile": "globalchat.json", "depends": [] } diff --git a/mods/globalchat/settings.json b/mods/globalchat/settings.json index 99335e8..30c6be1 100644 --- a/mods/globalchat/settings.json +++ b/mods/globalchat/settings.json @@ -1,15 +1,236 @@ { - "version": 1, + "version": 7, "settings": { - "host": { - "type": "text", "default": "localexile-chat.duckdns.org", "minLength": 1, - "label": "Address", - "description": "The IP or host name of the chat server." + "discordBotToken": { + "type": "text", + "format": "password", + "default": "", + "label": "Discord bot token", + "description": "Saved in local globalchat.json. LOCALEXILE_DISCORD_BOT_TOKEN overrides this value." }, - "port": { - "type": "integer", "default": 6113, "min": 1, "max": 65535, - "label": "Port", - "description": "The port of the chat server." + "globalChannels": { + "type": "map", + "default": { + "1": { + "type": "server", + "address": "localexile-chat.duckdns.org", + "port": 6113, + "discordChannelId": "", + "sendToDiscord": true + }, + "2": { + "type": "discord", + "address": "", + "port": 6113, + "discordChannelId": "", + "sendToDiscord": true + }, + "8": { + "type": "fake", + "address": "", + "port": 6113, + "discordChannelId": "", + "sendToDiscord": true + } + }, + "label": "Global channel routes", + "description": "Add or remove numbered channel routes. Use channel numbers from 1 to 65534.", + "value": { + "type": "group", + "settings": { + "type": { + "type": "choice", + "default": "blank", + "label": "Route type", + "options": [ + { + "value": "server", + "label": "Shared server" + }, + { + "value": "discord", + "label": "Discord" + }, + { + "value": "fake", + "label": "Simulated chat" + }, + { + "value": "blank", + "label": "Local chat" + } + ] + }, + "address": { + "type": "text", + "default": "", + "label": "Server address", + "when": { + "type": "server" + } + }, + "port": { + "type": "integer", + "default": 6113, + "min": 1, + "max": 65535, + "label": "Server port", + "when": { + "type": "server" + } + }, + "discordChannelId": { + "type": "text", + "default": "", + "label": "Discord channel ID", + "when": { + "type": "discord" + } + }, + "sendToDiscord": { + "type": "bool", + "default": true, + "label": "Forward game messages to Discord", + "when": { + "type": "discord" + } + } + } + }, + "pattern": "^(?:[1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-4])$" + }, + "tradeChannels": { + "type": "map", + "default": {}, + "label": "Trade channel routes", + "description": "Add or remove numbered channel routes. Use channel numbers from 1 to 65534.", + "value": { + "type": "group", + "settings": { + "type": { + "type": "choice", + "default": "blank", + "label": "Route type", + "options": [ + { + "value": "server", + "label": "Shared server" + }, + { + "value": "discord", + "label": "Discord" + }, + { + "value": "fake", + "label": "Simulated chat" + }, + { + "value": "blank", + "label": "Local chat" + } + ] + }, + "address": { + "type": "text", + "default": "", + "label": "Server address", + "when": { + "type": "server" + } + }, + "port": { + "type": "integer", + "default": 6113, + "min": 1, + "max": 65535, + "label": "Server port", + "when": { + "type": "server" + } + }, + "discordChannelId": { + "type": "text", + "default": "", + "label": "Discord channel ID", + "when": { + "type": "discord" + } + }, + "sendToDiscord": { + "type": "bool", + "default": true, + "label": "Forward game messages to Discord", + "when": { + "type": "discord" + } + } + } + }, + "pattern": "^(?:[1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-4])$" + }, + "fallbackRoute": { + "type": "group", + "label": "Fallback channel route", + "description": "Apply this route to Global and Trade channels without an explicit route.", + "settings": { + "type": { + "type": "choice", + "default": "blank", + "label": "Route type", + "options": [ + { + "value": "server", + "label": "Shared server" + }, + { + "value": "discord", + "label": "Discord" + }, + { + "value": "fake", + "label": "Simulated chat" + }, + { + "value": "blank", + "label": "Local chat" + } + ] + }, + "address": { + "type": "text", + "default": "", + "label": "Server address", + "when": { + "type": "server" + } + }, + "port": { + "type": "integer", + "default": 6113, + "min": 1, + "max": 65535, + "label": "Server port", + "when": { + "type": "server" + } + }, + "discordChannelId": { + "type": "text", + "default": "", + "label": "Discord channel ID", + "when": { + "type": "discord" + } + }, + "sendToDiscord": { + "type": "bool", + "default": false, + "label": "Forward game messages to Discord", + "when": { + "type": "discord" + } + } + } } } } diff --git a/mods/globalchat/simulated-chat.br.txt b/mods/globalchat/simulated-chat.br.txt new file mode 100644 index 0000000..9f18dda --- /dev/null +++ b/mods/globalchat/simulated-chat.br.txt @@ -0,0 +1,1089 @@ +W4inF0VuBwz+VWm+RyGwcQAgEO2LMABUGbVvsXUj9FigjuFpD6rmizyCFFltxE7r5jjXbC1kY+sa1ftLw4+bt0pm83SyCZJwrgj5xKRcThO2WgzSKTMMLwHG +sQh8SKVaHNzD98UOAo6psmnUmHsS7nIAdMB7f2l+/fa4s2kDPvY4sUlAXYPd4A3r3gMSaGJJQxkRmfdqYTN9fUktXFpdwYLWBoYml67EipHbuuESv/xKra/v +uWRFtCkJVV3NY1amqLtt0eKI9FzLPR6AKiDZABKDTLDY2sPCXOjrOwGVbMuzWpBUugLRzwoqTri9NstUn234D9Psv1bbo3aa+g+Vauc5xhn1aCKJm2Q8goxs +BlgqaL8dyNEilV/3qpkE4DCuvu87679+72JmlqlHiWXHp6aVlKbuEj7qPGD+oZ2kL68vmvCS3SQZpGTZv1HKzL7DXMfvWVlkuR+A0bG+b1pVpyvqlGOis6dq +1vhYezTuaCmCotQCPrkfUCiU7y1UZGmVpELb52UPd/dOen7tBNkBOhA+rILVBSrIyfG/96uynNGy0D1jwMyudTeXTVoXlYRRolEUEPee8w7hf/Fp//+7N8K/ +u89kuEfYZEZkGjOWNFZVVt33I6fNI7vbzCPQY/RMcIkEtwSkKjSXQnMHqlCzoZVZVok6ReoYctdmKFETKYj0v/f9vbaOqSxxuOqkrve7Z7+twIOZDw+UEEpI +DiGcsNZZIHMBe/gKCY0Hh5Dr1nW5368YV5S/VGn/e9/SysVKZba3lgkY2W110LP7v3v/2UDlr9xG5c/aYSGrIhqiRhDkKDZ29Xsf7/yTAJmVVVgistBLRBY7 +GlHDHgG2GozS3q6lPFcow1LeWu77sIC2QA/jYYXyaK5vttmxoyehem22ZTKc7V0QDVDqwGUm4qz/R/Txrk3TNGCQZcFI2UWcCu927jGJCSKTwIu4ygoHBfrv +TsgxyAJyZmshKmZJ3r5WLbGJBFF2+4B+E8lK88oj2V6H+LrvwM5sBhBAFc739/rZeUn3zO58pWBMaQIJS9eBkvB6QKnw0GW2pjKD77XSXtsrv9QAIUBIdewZ +v/b3pRTEH/vLfvqLF/K3/tK+1dKx5MdF7I7lt4rAQ3zD/HuzE55x+B15CHH5LwuZtrrfzdBn1HnABZgsML+54zcv4xkdufE+vA/0981IltvHosmewu4+sH5h +sySLzauXb/86+KTvrEfrWIVlhK709P/Bf0OauCAaryTMqYsSNWIHevVQ8b5/XA/qYbuMYLXjmW9o8VV+qkf6VSTrJdyKV+U+Vg6c05F/wSQoOVV0YIfHLQOz +vECD4q/y39/vG7fZqRqXNco6/2BN3BbQLmhi/zIZ8yDwcwXJiT6I/Q+EOc8Ue+FSI6pIPv5yN3sRcFmp8CGqqpvd2M9wSRolDpo0yPkRTwfn3IRE0LUnVOVD +SPFr1LvvsJqHJlScqvc0k948oMgH3gInmjlV5oU9/sw9/TEJDx+xAPkR3SQ4iUl9Nwxl+LO1m8JHDoJTd/qm2Wuz+nezgQ228x53PrkzU4u9CDad9EcPg6V5 +7TyPz5qrzT5Ni2cV+vnMbp/3PX0Z/wJPZYEyCa74cTsP2dOC/2bjcb2jZbEbenTrdeV0iVGJLv3H6fiuijVweXJuXlnDsQatznBBDqPkXdKwlacceXHTLNPf +NVTjfYRBY22VvlMxS5Krdt8WKgVV/wuomNvKdooExnxPvnwhh2fQuKt5QexgI5iPtDd1k29ifWaQxMX4Q2usUKnSKnPAxytbJWU0xbWzRlpUESvAyUPZL9Xs +EGOA+PDsAmO+HzTV3jvRsgJXzHfTKlUOldHiivs/l9yr9CYWw+N6ibWUZ7A4n1vHJPQ1X7zKHaTaq/zsG2UIbf+5mguP7HETcLMJjX2n+jnaiqgEq5wdZksD +0rOWSAjUXq/rwVZ8JFhTTLs9Ax1Bu7fdJdbD2QWb+8y7IT4kILD6X2GOSMBiSj1pUetb+zGK4F5BLXrvoxyxPnu3ipwWq0z64A+GqrY/ctKuTGvqzycoYUZY +pS3Dtadi+uKInKtIXcc0e7zdyp558NrtsEfzNtWKf8fPq8tO/U4k+roWAwn129hiVGCLHi43Y9cdUWt8mkq+W5ImvHlMpX1XRejEAYTeBKiAOgR6wcYM7XPR +lVsbWa0q1mOKrztAsTKX8NIOly/nfrJgW/Ym3+0Jlj3GnOWZf5WDX1DeXSDI700sBEwiT79DFOmElfnmrL1tffy1/nGHeb3OCUJab9UzbTs9yt2hZCPCe+Sg +1chdW3bCI9e2jqXV00cteEEqUhy77OHo2T8Wp0GAGnDVMmkon2+ffb+VN6Zi7JXHycUpEFswUPaP4UmdBI15CNmDHk5ogCokrHvL3TanP8/mf/ORU2GbB51A +A54/H0RtNpl1suZtNgfETzsec+mT6F90IPF9YQNUxOgQPzx9182dx3GOuY+zBVYS1lVKDeOCAAzocikV5Ise/SY5whnnn02yee4UkRciVDYo3FfAgeUuYlJK +fdlpkodjVQkoetIc6u+WBr67t3j59fFEjhnaOQH6s4ogmT9ueo46r/z78Bwst/kRhbqneVJajY3wuTX5rLuU7FsqxvjculmSF5Nu+MyqfDJQTB3G/nrBKncD +NLi38cGVxLxw7JUGUO+C3vnOHu7veYEffBzfTXz0dmeTOEnsBameCa9x/DgC+sPo1Ph5lWtowTB9BaujFyQeypd1yxcvB6AP9zzzhYeV9qN7Er5yZraGPafQ +55/S7P3I6i0r71IkQp7WAxLnYHCAT135zEL4WOPQG5pRGo+v5bQvsSQu0fecarnMOKZde2JlnMQ4PR+tqVutn0We015OOnhv+fFq1NMtIWM99u9WTtMGInot +PBZM41FyqyuEEk99jQzyRd3y+4Xffrmf9j++T3/E/7zO7ZYfj5yzF8wTvZ8sCNzmn8j5uBCo4g+GrLNgrj6qGLgybTYJ424MfNV5RMvIs+YDlSYDVF/vHZ1T +C+a1/vs3GVRG8PE5a8zr9GuxOD7qZZSmaMa1srYmogFkO7PaXPzdkGSJ8P1d37Nuy69vduh5npHfPZWJyMDfX0e8Qdr+106aIlg1ljDAqA7wrWanw+n69Cd6 +skOeDKgzsATQRoMxTgIK/Ix7Gwkb7PnEsVcdpaP9AlsvO783vlJafG+bnM74F/TLJWh2aP5/Hcd/615C8Ss3QN7l6LLdSji9f/2tH7RfxKzNlJ34fct1/Pqt +e2m1qrb9alTpZEw6n9Aobw/3e++ayQSwSTE+MAjO6QVL3WXJvgZieDbvplycqAc+Omdpxdd3/9i1Bwn/Fk5t/uAvfeLxwrrXg/Sr/tEL+S/622At11eQc/ni +L8/s/NTXfP2PNAX7j1+nHPLQSc5Z+sUlhv6iY+qPhslDg2kxGq1duKZcm91G6z08+/i0wqSmqDD6HObui35ULGpKj5q+tp0q/9V+c9P49uPBXVx+IW3Cef8h +y6W+RRoLk30Ridcja7v8Qfb3nLRxhuMT1KMPc69N0z4oN5YvR4/O/f5Fn/n3QSeDiOXST3Zn9MvcBPILh3ZRDQxt0s/+o7d/r52OJsIt44aqc9XmBbKPS76v +9ow3XX6rENWnA8HWsxZKg2lYuJnf8VLm/MlxKm0+KsbnbPRdSs+x/LX+4GTGP9558GDFrV09CHiW7kz+69CgaiRAskc3vZxJoNXPzLLmLGeBeYEavGILm0XJ +Tgev7/tLrHt+noQpFLqaeiUxl+LvoAZLNOhR4bj6AD+yXA2NcWCYWfueubW0eeuZKP5Q6OivH4gsc3rFdPMr+WU/+oRZuklKeNAdibKWx4d7tHLQbH4h+h8U +BpRNvzoa5gLi/scYQMkbJHJeIGynPi9H7pGBsVhMhewy9BtdBFFQ7TWeWv/SrElGs2C4X30boHenq3fWqxmNKD9aS4I0C7T1rARS1jKJUho4dHJmzLJGVHNB +K60Y3g17ihn/4yHj2r4Gel3P+eF+WiR20l1LqbZNbE1WGNseZ7bc8myi6bgeKPnjLWgRSTgOB8wTNxjdDwPJ9NVXtQegVuEhKCwUX/wWwqMnz2UL595NNuIb +2vpTN0VYvZmpFw2zvB75cPuMshWTJX20ZFLLrsi2ef8BumNHvSyb2nbXWQWw5CuYSj7kEFlHX7E1EhHmUArlGss9uBzTfd64irp58o8tUAEfeyohMTCa5xCq +CH4ga2tSyJYpVDWjQdj9+MbFxQmOi8rM8WHMhJ8F7ng6QMrl9R84OrpY7cpsnjgQrdV6gSOSALDUvcgWTxhlgOAgVys0ay2/2MAl1xL2isE5YioVE+ux8aM4 +Hb6B+E8Ts5Vm7s2mlYlTaIAPdzjTx0loDCZDxB00k4/U79/i6ICASYJV7HkR5n45g2PS0Z3fzEJnF0wBp+7ZtTye4siiknZALzl3NOCtLyYZhPk1GNkuwrXO +21dOecDSnjBkUBs6gTpbAUpPIWeBeXUyacZiPuxqnHurV44/GaknGeUxUUuXpLBASpmU6XJ8Ofxd4DDte0JXXIl9b9nNAfsu0mE3VIdZXEcnC2V47NtnC9Qw +KYwxKXOY/LRVN9HS9v6qF+Ww0EvPki9I9zYv5DhU9xqphLGfto58ng1LITSO4MWPzgt8JHXLPxApek9RsT7dQ6lB8vlJgRZUPnpcg1ce0cC1kW0gwVT9V83l +2QPwImCVDcjD4QCwkY3OibVhn/ODRQN4m8tnxHog1ADo+4wDqmeH+KNJtPKF21jMPI54AO8GkqHCllox8zVimQx2YRKP61fzJYtfdo2r1VzccvgrgYdJtOaS +tzRkHdPliJR4jHxOzr4ftGRvEtbmuc9rkmQjD03E/5ehmpp5Ear5Y9YBO4dvCTzZArgtGrPoT+BKD8t+wf4f1kkYCf1uyvk7SZAE3CaGg7ogdFExbQw+d8K8 +2yzYts0ppPpwshwHqKp0jZ2PFq6JXLMPD/BkDA6+B5OmBZVfrRHEZ4NIYOmHBg3mVF+Jqb4aS6v17iNYcwvbUUQKipDepFeF4Sf8gfTV/pDw/PtIjKuxQ1un +tU1SdAbIys3XSKBqnWCFPX9K9CbJyjMAhZ+31rjITwc1FXVtpxLwZikxn8syoDgtcbcA891IjmKRvalodi0wo4PssGVzhNeXpM8lYIM6c+k3hCh22WWhE+yC +o7sEeJdmjShhd9CH7n44bZJG3FTL6kb/dogszSDsSHojxzFB9Aj/2VNOLHfu5kyNy16LgSp9IVXCXfmDyf1MHJ3DPF4IVQuINeAC249afJaFB72jG0Rc6Xqv +IEVnKxznURmupsQZAQ6pRbeIXJzniwNwxA0OVH6nUYoLhoXanxtsrkTf/xZffxSXyXMv5PXRiIs4B2sdVP3dxe9e6mlelnHawbHpHoG5QG+TuNRqGexnfe8r +8DDJl7ZK38Zy7mITdf3RwvNtdAxM9XEWV0Z5B837NHo2yVbrNhomTJ320JzHi/oXQpUvHAA7clU1ugramko0MU2cw/4OWpHi+AR7DqnsURzjFTgD5QJxh3cV +6kbWCAHwQ7z6ecrptQFFeUIE5GYPDgcqWxVTRzkMZKa5ThOPxNMp/s58uWndYA45mD62AIiYXEErLRlTa4mNKBTm6fngxtLrDd42Y8w953F0r2Xze0MfdO8C +hQ61NNXciVFLFNrgjcyiczfZjZBuHfWIscJN/mEcAb+lZoa1bRGjdEiX1FfQG7mza304HclhleCZNv4w2ig8aE8Pf8TWAhmm/Z86LsjMFkft5NX8CeDdIZTT +Jq46V1spdAd1/IJYp964GH/Wle/dR1kNDWxxg9XmB9Pz3DqVm1FymA90E3n6+mgLoQabqJ2VmVgBBaF/swwSTYwGPdImwDZSnTTa9lYvV9rmAOa/1h8YgmBz +5dFDJE8PqjkWG2W655rUz+jfHeN91eKyE8Y/1ThoIfHLrJ6XD9CvBv8vO+CBKGEvo25g2fuPJhPE+1RUrQDv4iW4aG9av1wpMoMWsCN60B+CmvUq1HHxdz6v +7F5pXk+rPTjBrwf2/MTXqsFos8VB3KwYGaZv30rQrv8ZlbfGqIyQ/BDxH7UIgAkFPhMHTWiLmMQ1IE6fSBLUkK9TKESx179YdSc2faIJqS1mp6ZxDqs9SuL4 +YCakzuw8kQ8lQoJuXPhIPBnwgg2+1NhIXmkuZj6ZTx9I1CsQtLfRdxeVUJLqMJVBViPZa8OQ8hO59uFk2kgZg6sjaQ5v3X6iDfjQTXx/JdhgFx12kOM7qc7n +x4srtF6Li6qzq8MwASvK1euhaecjp7AB/dC7blNw+LxXBP7NtHqsxsNT9Y8plm3dw0xSVX7121ifDx6zqplA01Lkugz20/rtLewhWQ+RzgzLMJKmocgWsS+i +GlnDFg4N1ObqENqzo/wMEwCOE1KgwtlV9gMQW7XO+jG/qKwQfezpJfv3L42iaBloX7PnETHx1N61Go2yx6nQEMCaZhQfAgdDU0qGPxT274URManLiOdUsJrc ++S5IK72KUVL8kmRXxJRgFfIZ81dy0uOm9u3IYyzV0fb2zWIhdxmRet6XUqpqPy230xeDTHQeP0/EiSEb3NNL6IMhMjbMLDkrSMgh6SSA2uDbT18Vyw1wU6iS +ZXkhLT8aqiv++ssv/wYpojNSa9/T/oieu7Dc6j5mLjpJCavbB2FbCeMM2rzvHxUHYcO/i9zdQmFnBpgUumeAQWuxPFyefahLREtMV/4ejnIxWDtWqRx65bJu +iaxzEGxMR6yyObnA02H2sYkKgDhC2Wvxxhk9kPMXWJPZq7hvCGkPn8FUh7fKSAj9OfHFqFTNsHRn57tE7vhOjj3I6HnMFAmvSwu7nuYGw49P2PypU0jVhgZC +YDiEjxZUdvUsLPWxCxIAoMcAs5xWwqwm1Kmzy1d+Njcl46HD4XGd/iPAnTNjpUqjJX16Qw7mGNV3fqCf1DkSwGEW0YSp/aq4pTFueCtvvG8Ab04GOsEjunlt +i6LShzWtgeYU0iFiGkKj20qoFca5XowYOR6fZvVaowLB8NcebT4kgABahmAHerNgj6P9oeLgFN8xQx5LNvqpXytG49Q48n30ZQCvppB55nTMWXN1mNe39XhH +9d4o/PDg9F0URSNwQzl7q/N0+TpYVGHLVTcVZTVm7mHxxto4Hl/+iogrsKdcDft8risbARH1Mn54mmEmSwDgDh63O6GxBVqWWAekICvqBvXLMTgkLeIdXMzE +0UX2MnWViNsA8Q5OxXA8sGx0+GPegpSESg4rJ1CD4Vt1qU9nAyDeGjASsuIJbSAPH8r0OMm9GAekkd9dDFZtPY7oBF6xhte6dVw3g4jFqfIG6Pldf4fFC1nF +As41c5PXaVxlfq4IA+8vuB7wYtEZ/QoE1EcnrII3crMVWUYzLheyRTTMVTSlogonii9S/mmVkfQXRm+5k2+k/BlVfmjH9oNrEKhMs8gOMzzvf6bsxLkIdc10 +jrwA4y1xRwlg0lrtxfeKDgZioKGlRvhCHK95Eb2IGugWT+524RQZ95toxuLIuRcsQxLRtYhJDx/stReFZwVdGVOGFF7Rs0Lf7g+VDgDhw9jKycYGtBoRF1Q6 +Wc2JAOloIj8hGMYDL8fjk+ny8nlgphvtg/6V3Siydyc5Wdz/Chxc95tI8jrDxl2HBQ+qznzngxJUfY2YlwfbDQh3qIN1QeBQArYbYgd7sYYuUmZN8O5n/cfk +u0Eg8QOLJtZ+iTlKemmFbjwdsOyEC3cPW74N/IUtkOHOXkHeLTCuyPcFbTuXzehZCrLN35gv2GgM+m3WUncKZM0mgdietG3jJvQZ+9/fFTJLokinqcSKlsT8 +8VxeNJywrcdJbAKmk+yS/FjfShMdl0y96weCCe41QqFsNXKQFS63WgDMdi8U6eT1rYnesPlaSgW/bGOBVuXxvbRYDXs6xqkK4TPlIBwgXrke4Fnwn1cwrWs4 ++hAR4sDWWrzCvD98vyOKeXw6H1D0+NKjNeAij03DG5AbFD/L1xrWHxgr9HLSF2QOaSh3hOlWoy0hmu8aPYupQENuyEdnQCRkeuM65vRNy1YcR5toK4Ce2T5F +CQKnducyivfmED2TQbnvZ/JZ/cWLMktzV7gY19HbWCMyP12fF01iPYbvCkqHedmGAbEdJIBT4OLMrm5DnS+6ZmFimWLimdqBky9Eda32p9inw6z9/VOgmgNu +VjxmBnwC6E6T74KR0M9kQeEHIK1u4EDuSp+E02QwtZw0kybpiUdoSpkH/uuNySh1HciVYdJhn16W/23OefBaEp9x4rjHOgFBJuUDl8wzvhzrEYUVVMTJIQ53 +dGZjp1fqmoWq1l99CXy472tt4E1/cWWuC1v9Dy9J96ANFvftKsKjiOFMkmNhvI14ay78vUbRIZ7gNGThjDaXHNnU46ZOC9fnp36ZjfwUmZqk4Cs76YkhO63g +l5i5gFlWSJKhYUHhi4Oowc60VQ4buBsXiFthy59R6KdMpzbtRfNQhOTWQCcb72aHRDaDn7VlKDmd2ixyVlCB+MSNJuL0ENhQ0R64SmBsQtJG/wa26EICLW0r +KB/kbRBHERMVU1dwFbhymgXmWdOlascoHJ+i5xUAL1KoKnpRI0HuJs9Y2eFw/n32Vy0Al6fgYBDjaP41QARlkohAukmOK9vS7V32MKRTDcJhHWApEYZ1/B0N +mnM2En4gqvVy4NRG95M1pWXkNKFML5LJMgioX0GsI4kTHHzYF8KKwtAEJB+agFx0NgAUSalsa2IOQBQnOBkFrMOzsSvXWEh7qfIbdTR08wrEKaupQ4xotoxB +x5izCB4M8WT7n0YFhSUNqGvUROPo4JEo064cWpdJa8LLwdn/Vdad6KLrhS5Ocqsm0fJA0+teG8zaet+hDUuTKiEgTTU+kRYKiFUKvtfxBGnOKO8SymbYzBXu +giMgbh97uJum4tkPmA7j8twMBTVtCUvJpCcuns3oLz5FRTJ7WQLjjJu9y/howc4gurbwZ8/I0GCT9O2M8ZJwWhb8MnLQU8KrI6ggorCCSOotuzT82NOChUvz +cdOzwP7oNoK1NsdLNB6QLqpe9/Iz7NFH566n57ySBWJXODHTTaTsM/nI/bzDjJlD7qKZ2wc0tH81CnEeA2/7kTBG6kscBz49uJj/lPhBHgN22Bhaa7+d3R7l +1fIV6yjL6PxsKCsUgJdGJEvOHEqUwalVyQZfS74FoKtYotRYJGkrXq1PyFd2Ik5ZTR0hjhX34hMV3JI/W0s0xSWZMUIezZ42Cch31B74Rk80A3/36M6cCwzG +RZb6zHyciD7R0bu2nQiTGXYs96qKBaQ/kz1s47AlsGC6z9a+kaexaT9dKcoBPknq/LjU549vNrNkGZx3MWQGtEXdA/c2Wz8zD5LmrCUKKF7s9MPXUWDTxCmV +pe6vSp8z6Q4lMrWpMLlfjtkRcjHd1JuEwhd2S/qsx51/TMyiXcCiStAxf2QY+XFmO//6hZ2OHKXfpjyLt/4f+eOx3j/6DFR3X8wkZoklWCUtVmtfuMxNnNQu +Jt7faC+CjbbEp3C6LxeabzWRCYHf/3oc6+14rRimJGkamTGk2N2HFrXjJuDUXnyCcRIoRZjETvWii2sWHBGArG8Iwecc8kviyPyFhoShowsKDzzJ5P5wiPdo +D/Nb+ha7+8hvNo30cRf3PbfxG+p0IXqBZXcFyn5HtcQeb8GbJitavY3pkbjZ+skrN73J07/AQA8zjQKdt/R2qRcqFsOUfI6WEtIbLlLMQZ7mM1XjLWf3F51r +tWoNGKLSdwGT++vKO/n6+qCKEF1MfeHSurg24KEIqq+OzHVnemYuF8AujOEoIN76ONuFf2Hk620n5z0e/GvyJ5btWqwWy5otIRK8w1lk8TYvy2YTCn99nc1Z +nLnNl4oi0p9rKKxXGpyuGfCuxWyK8dpNmJ/QzcH4YcDwCqiNvPWbYs29hL/Phf3dW6xgpqwmfR4mxTnmB5PelfqQfJ5UJwtArubFoJKA3w5/+eR4VR7f/2xA +OB80tAyKH0sZq+93wGESuEXbrbhWrWv2f05LmgNF3l3PssNfm5v5aNksrIRNbVPw5LbKKINBZUIRccxjMpvmdaAJOjl5elAKYUJBX8v0k0QeIeTjs/0g2dwE +snvBAFFz2HRF/uKtSqlYi4VpumnQzaujgn+ICqbOkMOdX1DX52dxfaWFhERpHcOM9Zxt84pYnXtydy8/hpMuJ98+8iD62930DaKJpxi3R0wY2GGOod3rUQGP +wqrf6zaMNJiMeilRzVBtNBRY5eqEBRzoL9XUYNCGIGblrplOlYzKXMvruV2hrmqR+/H4f32fKoFr98FFeE3y1ZTEQeF8LlVhD9oxL1xzcgO/ucvesLctPngp +kFD8BaeVpUuffc8yl5DrJEsbY/f+ZNh1t+J2TPn2fTydJu8EE+FfP29IUko+fF6UTPhGTpMIt+PrktLlEf0UlCo4jXOiZsNdc7+/DgbucIhVRLcdVwsysEIy +J61Wa+KlfNVf/ryH15WgCmO5JkyebGq1LhZpPbH2uhjvZn7k7NR5Qnl9gGjPvMpoSlUE6N6RrYnKIudDi4ehMPhWTTPx4hkaqdGkj3kzfPNQvLD/INo2F7au +V7ONHyo6zPZH1MBJAGKGTpdSDM8vjVUW02aaQx7r99UlBhUlEQWZ+abfeQYwiFRJIY/7maTJWLjiJSINYtJGqYcPNNzWcoH23jrS4NmJm1tdvX5LDM3k6ayB +LR2t221mm5+zddiW8Vpo12xWyrQzjU5/nr0qZ0ru36BiueiO9Q8WUbuUQ8+fH8hUkVrMkb2VamrKPiKaUnbRd+oMmLis8gBuWhNrStEpyJVa7DaUenx3C42B +/N/nKDu3+4qCi9vEINeAzWdbAx6MiG1qS6oUo6J2xVp9NFHqJdKgsfbOUfPAwrruYpLoqPYvsCVhY/gjIW5WvOHPi4Wd9ZF4hoIbpcEYaVe3k9sIwBMjCH9O +qMiwHBgKi8TFUVhY7b1L7I7gvrHpRJNbRi4vIf7oJTKgT2TKF39vFfsvMF8YlBIKyFu65ZVivjn6IYuiScfwAyPQ/5DJBjz9m3Lic7l+dJOYe39gu4eFK1KW +OTKcrCaKF8rR1yRr449kArDClBC/66DV4hWI1WINx0mnmRAavNr2rfUUSK730K0BfP7a1OkwJ0u+4dDmhkzQXEsdsu2Cxu749uPQvB5yhVBSfo6ju1VdDqoa +JnkO1x10pmN1ae15lP0LOCDDdDgSvwdGZjmnI2HU7v+A4PqOs9k2V1gD25Xh5MGXGa00ZUa0gpfB2PwbmZJUSHc8+ZycJ/nKVRcT/zDYjOn/wS7SpCk2H9bz +m1F5QmsE9XvPHYJ8xeTjo0aZEx2oGg8AHw+b3T/n39+aweV5WqIxw2dotgj9l7T1dCQmZgRRNPiyXSCJAmpBM66ukv4uBVSfihzeQc5GK5CEQdq1fsLgxhGs +zCIMdcy7c8eXf2IeOIJtGm2hcz5bXMiWTkx9IWdpHjH/PJ1J/fFSCILJY6fPqHyGqD/KnDF6zOnBBxvvhL9ZG34HNJKjbiBMUa+/iTuf3GCFWed/9s7zASgY +xinG2AWXxpGs8ty2M2X4OC8AO9HGICZ/duUYFkr6RjCjjTOHaV+rf/vkC7GtNgGUgthis1+pHdaG9ukzTDzbMfk3epBp7e9FyXcRN9A2Xi6WmPxkgJX3fdTT +7sEj+zHCOkAhHSmep30674ghozniIn/pWmuR3L70E2sr+5DDePguwJKjYj6+zCyLZWnSKOqcyUp+FyyyvyrJd6rbTLolJe4xKWTBpSgMwFpLbiP18VzUgUMs +RL/gECi9enQRrN3ge8Yf946yNp6Qg6NzYmh9OreW9xtySiyqi5wbMUbq7s5UQxmewbzlXY33j2xXG8WHPwy8UNGt7xBNIxwAbEohauy0uw81kAb7dEeJflUO +RtaGB7ppRynGluBDFAMtANCSl9m9nYI7CxOLyAchxute7EeIR7+9G+jiGfaq1vLVGxRsf/gKLpAlT5/cO0LIB7kPDj2X5D9WtH2Exy823i+3JoWvLlZyGjJC +6mqgAXMCb0GQkdqyfDQJ9DM7H2U6m4SSr8nZOMhWfWic2Bb8gwXPr8kJzARiNmdj6WWqc3DsdykBD1iC/1dXsQUr3qsXzBJeeEd3jGna2hcMnvjJf+eB0a0Q +j75aE19DzcHFrwP8vlHcl20u83qK9CDyrHfYSkZ98eliaKGltQ2uqbX7MQBKCu6k+Qep2WnsIYIImadVIykOZ4JVHu1nkle05PzW5cW5q8OB3r5LLRIP/zYn +JV2ti4Is4m20+gVAEkl/ZkdbjxfeWXm4afQFB5mhniaUUlAv1d9u98xrMg3GGBhoNH4pJ/A7y5udY0NeTfxG4Lzg+GazXJkch5QK/DRqkKOHzMUAoLCgash4 +7Xv7cc7xXn0ab/Qf+xsb4LreX2pa7JzDxXGdeWqe8gtlD/d1EqUggFKbr3O9u+qh7FfS2dxBcSP57U99juQABsJOmHqXB203ZXYnwo7yF3zygyNJ4w7j+MZD +H3dZt2rh51VujZurAk4fLBIMxAp6VeFNLxmRY2+jzNEh+7JM62ygi2w4VxCMiVxWZ8VyzukpiV+5v2aw9qb8QzqOGIc+ywersVqSoRY1wYPBnJ/vcb7+UqU5 +MTxYHxRqvw/y/ZqAnPUixFQe+iZ2k7Wusp2E+G67pyo/m9f+V/E0PSVyCx57Fthjhng+IbzKUbbYGblZ0kU3qdLd5GHRovO5irAm+seN5a5xSdbo8CUo8yBa +y4eld90op9ehzUzlAeMl98tpwLQF1hz1QrYMkP4czD4KqFgy7x+LQr6cLj6RpGr7eGo+XfJgk2IrgJEr3ZSAyUvVys3/k0qz5dTUApcD3/Dqu/sNZUKNranK +39Q4mfhn3Xv41ZS+UL6pQBXpRxc/Yd1tacPy/W9/DAHMI5rVtr8od57OVWqH5c/bxpSuHXPkSy5NNi9Jn5CSbsrCA6eCWC0OLFKW6GZqt4bCIqdvPR4/hlHf +dGWCIWo0UbpGvb6mMyfMAkWA/4sJgUqh94k5nzn7UO+OZNganD1ntFGe8kBU1925Tl4+drXKFBQ9JPWmW2IpSxFpESiGn31gtBi/ltx7UPGDaCyJ3+2CluWC +AzWaXMg7olfdYmyVygL8mvFSfjgX2pyTakHhCDH59y2BUGBqteYhC1YQmQ3lEoxiEl0GaPBipXvWzOG6RDv3z6mxydcbtNPmkA2C2PYQ5MrFvi3ZUxzBXjb9 +wGRvFZ0ompa0kSxPYuY/otkvvJ8qYje/yZIkKD5LjlJaZUliMFJiUezY+i4WDXcH8OK5zB/eq+sb8Sy7EzBxxlvqqCQ9APsT46EEzc35o3l0mqr7FXozI8yI +QA3nJYfN5IDKR5FX5uYrfF7TNYAw5qRBbghWTtIBaR6LfRmdIdapCk2lfd/8Cd0Erpok9RlNQdwYsxM8jhpXWD0/L/XVCQ3GvoEzY5lDXlSXCP9gm2kbKBKP +yqb8o8vXLLXEi58XrqGp1+aCJOGI9ikeVfZ7lu2DNUtffDELLPkbIl0W1amvYfRarrGwV/UBg06YcZV+KrNrp7GY1RDkjDoa+auB2/0b2aJvlKHTKXRCbhuK +IO+aCKialKurTPQ+LUDlEqVQyHP6hKZDEO7LvpgxZgsCPv5UHhjelxZwTE+3PyKzZkKZ+2tzTTW0n+jqFOTYtXzU/NDs7uUzK3kwj98DHsuh9Rcj7L3oyu7L +zHn4Z7UBaX/YMDk7OeejHz5/4NK2ewu9tbEHy1/4KEqOkUwWV+V+C2hof8gIkzRVdE4+FRsLcB6KtKIx0U55OVr3wBg+d4VCDGHDW90N+YeDRMsk1hXXTWr6 +0jDX7wLOANwIXWfe5P3KRhyh6uWlTf3glwcatSO6sfGAbkZxBI0plLOn7htzABwdUcQIYIFKei+kHQyZVme2dakO9HTL3Rj/7oV8Zc5MXMo2WbXesjH2FufI +Wb66fxvhwUXdvm6CelJczPde5LoNj55OzvT2HrO/6fc6EkYMTgnRSbCUSYglXLdpSLP2TqmKAKcCkFfFHxxpQYrtPF5rQBCjNobGsRreQF572YEYvhBMXLl/ +UpD1NXwWG0bRc2iUYKqZ3bpCUe+4aGtPhOfbemYdawMUbnMrX/1LYvkzHBeUVZDFYA54oSArPF1DGGv/pr5ykY9Tg8GbP6CO7vWy/gTtVhupTcnG0g0cyKCo +VFJ6g9fgPNcjQtCjTcuFCtZmfXKKuLTcMs8YRAk3ywTCaU19g4Pjlukr4aGO5OwuzExQ+NoMARQPVINrU/xRp1+aflVVj0a4d2+1w8kF6x6Q/b+2L87Rp9OD +Mn9VIbjzZYX8mJ9mLvy+mX6zYb2u2VO4BPXWEkGeN95vfN/AzEOCodY/3d19aN9FyjGmqQJ2f0mr82ZWmiu7/a8OnD3YzRJbHADQ1zmTNa7J8DNGsOopRdWO +CczEjPbNF/4J8A7nPdlMbEvgJV8NmqnthCaLFgbpfsDhYPjgDYZ3IAAzZrvOeO2xXDDO+bsYSPRSROrBt0haqBvYTxlWjNah3VA22N00lH7eqhiVh2AglNjZ +q2/0pMT2RJL7Yj9w9V641ndJOmPjn89SYaVrVHXL9OZzE0sxlBg++zCQ7RXu5OTpLMuFjYdRYcRJwvJvvB5vq0kSEAOQ+IdbeMZFNsZOVgo1Kmd6UX8+n3gZ +ik9DYjEV8LQvM/kXGOW3BIOilvJcN/r6DBW7ZHTJqXlz5dC442XqicFjVmjUhnfCnrEtgf98T7apcZn2C68LZbSAW5t+JV8/nAxRzcYzX/xyNNiKTofkimEL +iE9X+dx3jB3MTi1s3a/IRGjkUlv/A9noVM3n4ZFRDi8nlgqjsUhsrlaZxyDb6Txf1mhFnB38FNvssauoQX8/no8lyX1dao5dcS8EC0fSlM6Pvl7jZdWv9Zp4 +5+koNT7sEK24qnM1trWyOkFydDoar4Ev/QVTGoTUxwmhOmNfj/rOScD77sfahX9X202jgnJs8SydjZfWdqbiu5/Tn+yJLfNreIu1Yl+/tOBkWhUzClRKOXjY +o/A1Iyf3Rwt0t08nyzvkspg9wc7myn3gVrpzLBksOZQtVjY8NS5zk5cFcqr8UsvA8OmtEOzen4HhWqhboAbDz8eBqLE7C0JI+KFbFS5bFzOIh6d86/vHmwgS +1l/Hjn1TfecoEWg8/H7BOilsBIeiHqcfqacexWkbUKttVuKsd8QtfoLryCyNoefl0CJJaOfaeUZqn832Q+mfk9P4Q7ytEgod1fB//EjKm51/bcx0FM3JwopM +o2EqegMSTwVZJLR57XHQYNS5tpT0rEqLowbMjXzocQx0bwxH8kTF7KRDjfzjaWOE7vPlJhh9yNFl63GXiNR23tPAeew6uuDk6xXuww/sRIA6KSq5Vu1G0k5m +Qn7Rc/IoK56bQ6u2WbxMX8BUoHlBADhpekgtIgVSg+g1JIEwj/t+c+PSr5aM2itugaTxqIegxoT8WzmXl88b7yMWAo7LJB0ePLIgLwlMuJi1qCpribLaXrMB +/bDMoylKJJ/rtOzvrB9a/Rnf4qSlp8finWaO9CL6R5C40SmZHJJp36CKAZQTYRQjdOSubVSGrhuU1RlaEQmGoioV8Ke0+Ycc0Q1+NfhsMzS7TS1a1xfa1X74 +aYh3ieMms5jdDkK+S0nLeJV3lxNeV6dZ8mJ2O3WzJbZvvrkV96VLZMxuEHAOJeMgWM1Sva+xSz8J3tZWhDzbOJZ665RQZZdCFD8D+FYLYbaVMgH7d/oPwRem ++fT9K7pPBfv0T8fuz5S+/cxVcbQ/HAL0nxQBrZy6zqNuyW3a/gzvB35UFTybR9DHcMrul6dBK3H8dkX4VVlcMRnB0nrTh/bi/Ionb8IsFp3TBmP+VtnJiyLt +nGOlGKkskAWyYXtinuNXflWogMEaor30uAdh+iQw2G5elB8wbPFSuOcjXiy2dEXTsTykg3Fb7J3rBJa+pUocOMyQzIcTBYeQ9xmF2/9oXHq6nLS7dvBJSWkF +YPKEO63yzR1sFBP9HXFc0l3xQ4NicAv5ptOHYaOruinLoQtEMY6hdZPg70zQJbqM9IQL5frZxLUnfl+oZgAFnIKwi5IEOkssmqz8ty8N1dyLhKC9meMAXLBP +Zbkvp939u7KKSVRx1umJBBk+L+E34wVYOkH5AJIoBOkMxjzPahAoyMyOdisXf3aGw8Qrz3sy34olgP5FFpRKIaXPHkxwvEol3IF4w9TMxkRLDyhe0CxgxDlB +6tEKZKiMRxI0X3QpNU89uAJGnocOv/k+WbLVUwiGfAdjO3SBNAiMXwo4m1lUSKXThJDeaoUpZs2kvIv7+vbH5ZBYNjkvZsEEBhPaI2xfL0vu3r6IibpPDpsq +z2NnZnU77sx1j/z/s5gykbHnelERs9O3A8lywEBB7wMnVROqQyyhAiegRn4EaKRiGiKQyJArXKmq7AoiGv5or127tBqNIuK8bgjgfHLFjF5DFuLMUOVtOQMe +6kHxwMMNb+EpDoNUlzzJ/gD+NDy+pqfYU+e3w1+0Z/c1hJ8HshYtuiNGE10LkYEf0F1yr+1Q++4bdSBfbd7Mxs6yucxa96aYh/0zmdkctSm+zjNJN5EHN/TJ +TUDJfVmCo4osKoEsgv4BpjunFOQ/0WdA2F0eeAK748vQ8rDk6vACjduAq1PzDwiLu8vvrQDmZOhsKSC1GTOvhSANsGhMjO18tXbADC0JxWAWJiTEA9yORCcp +Kks34sQuSVYPLZ4FhaG+hMOv2UT2uyZAy7iVxDPHIYdOlICQL+mpXT1zj4u3JH6OuPBcShXB1u7t3JJukhzW2AIuTHNxk0NoiazCBLPNr9kRTyuH3B2KGx2H +7KzWjqLfavzRNEZp4QZSlYhNEdzSMSaC4Lcht9Hm5Yzyk+TUhFgTbE1lL8eqcGaiUUwlRUSRZ35wfu4qEtcDefSlrHOHTBE5PMqAFfk+iB7kHX8x0Gezti7z +TKLoba46VqWBN6Gpde2PdqlMm/AGv8c1HhP1Yi/mmoKrMSrSDFqzh1XJiEsajtupG/MNaI8uUsF96G5CyJO35QUtvAXD697EgBMXEQipzWSmgF3FxYNDsi+j +GxZf3Ppgc8ghRM40KeEjmcZSja+1g/yH+qlWeuQMTLApIhvalOxSKUOvIV4nmgiAxUQZOf6Jvls8eXfncNRdGkHRW2K2PXt7X8T5s3q7NvmqHPGu38uN7Vn5 +dXTW0GnuUkIUiqPi/R8Mr00vAJompGZkpMjWWeIwXsLqSk3yDFEgF8V8SMhBQJuftAdDZLFYPK8aufIqFFaQq3zHMgyyP8ktAMcpGmXPdprBE5NlEpZ/e/yY +dqTlOmr8ma1DGaZo8CQHXcqbNJNYHuZVq0vBqP79VDGJsWRt/0L9yHrgxjNajoXfFxWM4DnYVDAH6VJU+9l7SuEpq2MnXJzycDhXkNFJAi1LHBacAeo1c22u +eCASHAnSMd8fYywgwAN3kd8EzhgUqXqw/ZmnK17KvIhRBSNDvCROU9TCaYxPDDxzfLBVZuuQYZzKoVO0qEBixAlg/TXu+yq4AY1gNbQ7SjAOqUQSig/tEf+J +fGrJZfMyeb5wPFWvPVjtdGj7qWdOvFmIHeQ3bI06qdPcLUw5CQ0pP/MSU8pLfLfwNIBL3kNsmjKYDbo6DUZIrelNJn+ZsW18FAuX0WRohlAEbC4FdSzIvQ3U +EiWv37btI8QhRxfrT6uUU5vXebZY+OiCmYNNaqRNCkwKjBXcySVPoNG4QgJVVmr/bnUJ7CfmHSN3HHMusXWRUUz0HfWwddlhyZaLAARgHOgNozaeSZlLpLAR +N78kA5K7a0xQ7TuruPEuFlwMmuys9lx1ePWEkMzWIztBKozkPCKjPcBOJGuEgruYOjFIaNGiOtW2FprbBkVuNeuR6pGGhaIW1lwsy3zknX0rJy6xjoRsIYuJ +Ab0i9Ajq8wHiZvsBwzlzEyIxqXJfPalrDCwr9IVAmWjcuEeIfXH9CJQ/LmkIw+j/yeogkY2hjKrOYENT0LJdUBKHbmMwZ1IKtxRBUvyeMtSZimNy6P8LKLlJ +6QbwWvNb9YN6HAm6Vjq2d/K1c3NRP3Ri4v9PUJUmlmnYdKhnFOYySkJEkrzdGvPY6LX0t/LbcNd5HTk0iywwTDX8ZGnTzQ4ngPkFqAhPX71+ugPHlBHh9DEL +NONhqoAdAEfy0Wts5/esZEjgNkdHSDj0h1ZJGP37x6DlqY8tHoEUV4zDsUvH9Zpw0nkTPWYQvekNEy6cFrZTZ+GMmqUKgpJHLkKFRB2epEhWALs2jy3kRSzJ +Y0jTHYWAlGWKObyVMiD0oDRPC+rC4ckWXVVeT6cUsxiHvhXx7u3OSKQGYm0w/JF5DIt8IX6ZFEquyL4AxDSX3uU9nbqscY0V4j/ckfcfLeOup8mGSh/mYvJt +9SdP5xGRf4WclxQjgWBCN3HRgi27l16uYVxDMz7TNaUpZXQbCRozNN8hOdD0Ix3/4tX/pzcrJnacXIAuMzqPkEeiM/ZCcfYAMZPpzuFvP0Ks+8PmeLXoDVjG +U9OqXkzGPX49lGXz/pDhWvsbLaVYZAFDqPodN9rBDB9J8v7I7jUVxIp5nH5nhMg7IXzJe33iFpcoDVNPMY8Q8CMqzymQ5BLcwWOJdKjpqpCTEOWJpMmZT4Er +q2woKWhMQ1ziVYezJXqj5Lh0zkzwzjlBXhMUEDExpTBPMf00PI1VEE+JaVCiqazctREFBS8GrTajqEbzeKJB1HMUNiiiUbOfgvmm4f7jC94t1mJou3lqj+9D +1ztLThxQFBCdcKpNV64lRM2z1uU5oYQwGG07dLBznV0sEf4wxiaXHRPjBlgObxK7aNYU3QB4zzwZMPLj+VJXNYZ4ZugztGWyBMH72zrEriYPnShEOQi4O7Pv +jroWmppfYE47hbrw9rEPUpFW/Np3H5pKnCOL5nUoTYIzTDDYIuLvUdLZOQ8CJk29xc5oNg2eKR0yHpJxuax0HiqeAUtGyGqXczGv7I98GecA2qHFxzkIthfM +lavjcZnen3iuc0hk8Gt/zkUZst1t1YNuqNgDTQWqoxEfcXNY9qaM0LqnD69x8hIYXfspuxSOkEWiLxR7KQi12hXLGDSsJnHswmhoA+1E25OwmLz28TotwQTn +SuvD34wO1W5cR9nB1anjQ/ZZaFklpGGIn2rJ+x0ty4J3qE2yI4qJcQWFaklrLrZjjXGwcRy0FlLK10UsW+dzIjE9uaGt0Khqiu58zEdD4r0vqDS904UmBJUf +WNSliVTcwjCuWjfQ4pMO8WxXeC6efM6RQbj6EyQ/KFeg6egIDx1waI8Y1nMvo+nmory/n2x6lBElH6R4mqWvySJSk/VQa3HeHdea39LXFQS1tmspY1SUegQq +R1Jrw7NQYnIRh0OuSw6zYCZdyX8pgB9T5GH60uYeJs9Go7qLGih6Y5PjwdqcrfAcUtcMzwMhHeydxxNZWEd1dkl6JgQPXqiqyyVgpd0Op7dq9EipPHFT9Xar +DetxwRU8wAcHwwwNkvt5jb4+CTXbvL0EfHFeQHucpG5J7DJGtj8PyDPUMkGbkieV0qslCV3BfzkenzLyFqJpekxrJ88LMeeveus1VFIJ5UJ5rXEj5S2rRGjJ +7oh3uq2vLAe3d6sxuCob8ZP9TqnttbVF/eSnKmxjGqL1IDi4S9CVN/msABqBkmQvuZYVzXo2xUo4i9l/ka0y6YUKa5LslyLY+o/8gJyXDUSQOBme/im/dlO0 +vatcb0YkVZEAJg3NPU+13EG92eGlru9Zbx7CG+M/Fv+itWxhzWY5e2x0o4vpotsMm9iH6ETv5iQKarP93JuGeBC/XbYdv3kXNYDAOJsmHOIWQQpZiUPsOQMv +8R3wKpDyU+YE2t/1EFVSX6DRufVn9ny+Dk6uf0HJeCmRXk8MeHXOFCT+W6snc+ayAa3fBe8AJ9RYcxtwX9fLR9CdDd17U3LvDxPa5uI10wBpFGk7c48pWQvS +fgq9hTekVRaE1Sr/8EYFJWTWN5YWyIleGBCVgZ/Rea3mLItgZJpR37F7qm0RywwPJMxlGs42V0wPLk2+keJG5WjVLyn5g6iGs0HsVDab3tYnNSjJgi4qAvnG +KGovTMW8BBShYynLNugj9VhOW+G0cjrECkq3xrlOvipP65bQbSFofjLK3V7d5NoTzgZYOPnFKRZliK0xntJyZt5OhG98OmY5OAisq5tlOjsuyaYWt+SP21uW +icc088Rks9EcXuzxSJ/ajEOtm3oM3GrcGhCfAxhYlgpSYnyOickM9CMhSrME8vBOVGCIBJGBKseu1ti5fVWMIBc17WbMjpXkniBoOJLUVQZKRrlULPUJ8yVK +bjj/Pa2KLtENVek+WGmfN/jVHuHPFKmTNlaUK6YF+AZxm/82lCmRwik+dQk7Ij89AGP1q+JbHMdP+QfE0Eo5nA/3AuTA7a9Ng9cAEYKzS0gokdhwhO60ltgL +LoeH6A4IGTK/QSH+vLP9on1VO1AK6Y2v78qyKyRo7hnBjajF6Eklg5xZASYOOnqHW2RvTCJcZ6vn34MHvJxJsu6BkOM/bjTxQLlnUuagf6RGYf2K80MnvEl9 +IdtE8Iu0Gq4R276i7E+AE3nKLeuFXo527ZeQ/oqookCW7irD+U+ZbGbhmEyB7q60TPkv4Iwn31XiQ5g29U8oIe+a2VYdhVidjU8i3UaaKmE5O4jHWeEXDfH8 +BLgEPOCL8GPXuCjz2A3AYUCBD5nstn/+fElSEHTYvxXXlbfWmVCBmtlrmQdYNMC6N+lR+/HjC5HaDD5JDyAd1omh/C1Rf5T456MNkopk6njihcPALttz+y1P +mrkvTy2eAgP9hJYKe0dGbLYFRqodhjYK1FWdhXuDoXxPocqzybRLgiExQ5WfSioxi9V87GBr0SqTuni/dhLV41mS3rWD3h4IsabXI1Gh0n5IYlPDN5PbKrAp +YfeykNrWeC1mw7I95ZK6H5z8YHZUGpZ8NndFXVdW258RdSQ9FYRrKAk+9dXFo5lbqT84h+RtKGiasoCav4alYRAFGChEfBHwbq4/iFpvmSq1oOq3o3ADmHUE +1MS9g0mVhtoVixZtcEZsmsmeIZPvmukvFpDNkBGYTc0ObDjBVCQJitCSVo6l7LwwZk4ZyV42TE/QaHBVt867TSdI5v7z28Fbu+/sKSndfNvkaX2lj4bXy+CF +Ta/3RK/9K7qT6IGQ1ugrF5rGENxJNugIambIvQSqrGj9G9PQTP1nu+TtR06jTEI22oPafWAD0hk2mQNS7/flS6D2q6RiPXTL1nC/qlAnUVz7YMlS6Sj0YVNa +OpINNWKzRC5e0p1ZWClhogwFmWtpPVIV1F3L/ZsDilYMyymN0tZqitJPKNiVa+31CltbTjIjFt98MNdEerqaq1xd5EnnVFubDrMoZL7TFPMAmBeF53+cE1nT +5U7oqFQJEqP6ro9IXc4TAr6VLbifbie7Qg1KJxRGUp8mMFD3wwOXy3tbxNo5gPEMfmzLj/vS2Z7V/kHScRQZwTd+IVxE+UlW8F4ydFWFsye0ocqEfjz1Ev0b +PAJLszVIEF9tbB0QqJUKF4zbngmcOmZnYQHj7Wl80DQTVhaGXlwP/hoUwqTmTLvZ79L8ZX7RHaqgHpqrQcit+Loah5+AMYSMGL4JB4nlm299agYtzW5Jr9Ga +A/dllPLBuXF1Pyh1SufgaJGqFF9g8Ajvf2l9PLIQMMiL3cYilWumaCP5XZE9DsXZyHZ7lMjhwA8ap8t98TzaQKsUwM8hHX1rxftXSoMxyuQFiK2XR8Y49v/c +jkHysx8mnW1wzrE1jtZn/0yPKBz0mvQwDisF+kHhqKOpfAL0mLEcgR9vxNtZBMuiykC3rLtHd0cz5nMZi2MN9vRFwLYnb6gshTUPmrrw4nChWz1tRmiRKCJ+ +ibZ2qDi6KRhfss7b5Rom7fGgodJLro7klHp6lrRmIfcNfn8LI8mf1chZ7XqVJsMAZoEL9VWp3DphzErpw3P78Gkjp4/wgpcwvnKMYPTjvBbJs94l2JG1ntlo +GIsYKuPXKD+DXFB8bd1HviBepN1i+RT8t3Qw8wVITAeS//3QPwM8V3a8aTobf/q2Q4hz10gOol79tDoAZoiEQhMfraLX45OYgE+lLPe3lO9q/ZFCZ/wtvRcm +RtqPDa7+bfhlnI6+/vl12hhTE5tS/A+lK7H+sfpX3C2tyhSuz1fhAEcCD2+dM5S0/Un9Ka1gvjMPY8mPYj6wkY19/reRBTvy41MTmWachFac3/jKLG7qWbPu +CDZd8l8Zk4DsRL/Dq0tfFbgPSYohwLNL3PKkWAk4CsS1J9cDv83AsjZLq+UgiMjbkTqssG31IAxDhWzDVZBBdzMhVTvoKUzImeVt/QLIxYTpcAOfwPq5xX6P +uzP1h4FyfF0kLatP8HRqMWcQj+anf4kOGNgRldKcV2hIB9pMbcgOQQkBj75rrqUOUJ7rBJF54bcXopCUUKFCwpDqaLtRi6K55d8b1vSdGFZujfdL4GnDBQGE +vQwr6kB6BNSxut07NVymETt9nuLmOov43+g/C1lwj+iYU9/T6L/rnK5Svh46qU2Exh+3X9+VprBuwign/PPV+J6oPsyxirIaUh6W0ytjNOB+XNKAHny1/E3E +vVf8djozxMcT5YNRMCeo06DKW/8BA5nZKOYXI89PWtN83HKm070RYOqRys+TSfj0/KEs2qkirxzwwYcqchT9oUk1YLle1TjNuj7MbNt5BRGs9G0OwPCclVZv +soMxkG805KHGSZOM5czkgW5unZ3fNL/vYFzI/t4MoI0PD6M6jGaR27g5S4AlPeYV9xyBFIe3VcEAhJoX3qOBZskp5H3lW2y/XYMWS+mSVY+tQgcrzZ9L1Ehf +e+ys+m3wr/44/Uylkq6Xa/NHX7iuzJfMlz2L0aT02rSo1GzcAcUF9GqDa5lqOROH7ivOU9EF4w495OSmp9VCs1WykLwAvpoOAYnszf+6J1QP5Yuua+7ZUOTF +sDKDlxMuyGebGuCjByvkmFfJw2JMpB4XAXsv0fRqJ1nIeXEnhs77fFhKqP0czGeXXVVp7GpiUdkROPwQknT8+UjPGGCqshwt4R8fH4Zb77PmCb4I17xY2yCJ +/jljbDGoD/m20MFJn7LM9vlgJKE2qIYXp9zLHndckVcJX/Ck6el+CwwxKLRhkriZEw3ysW7i1HZdz0ds6YmamCSWffN6CvHz4Ku1PZTQCbZvlbocPjvMu4IW +0AeuvVldbXcKf7oYEmaENlwIYV/H4ieHMqKiGZ669ssefHDwM8kFqduPT+ovvutlyu2hqgKcF5rMDsWaj+Kvj3ZIH+XYacO4hpljFd+4+sksF+yVIXBMxU8L +/3RX2LeNypMmAR8FL97N9jBrvtsQglFFArOYGkApn3v1wYaSo3/Vh2HdvT9DIPwiVeirBpjaU0atKTkEpxprWk0KjwP5ZdX4XOrm3xhie+y/fW3hp66vZl1v +WRhdfCqtP4NVAdLB0ZOe9MVx8KQ7Clb01CeWK7WhpTDaIcz8sDuzGRv01lCPP4jwp2XzW/Muqlv4KFwuK9FbbaWPrM2QdYZGiaGeWu8eB08aOiq6DNXUM+Rc +TKM6u1zmVeD1uqWkGGdagXpvyLGyOS/jdm1Y3JJwHtnTrObmYHbx5J6YFT3SgZ3NxKX/AFcgq6Gc5QBrCYICEE+YP+9Yxzc2Afc1GBH2yLalLMShi+PHlvI3 +HgTHaws/9SUpM55GGeNlzxbFuJ279MxrVANPcc6Xg3vDhHRplkXSZTwcuIEE/5voVkHhpFa2aB/PC7TT5KGzeFIKTIKdHlilhjiN1W3IIqCFM/sZiucdqagw +QUfbKxmpTIlnX8sXGAawV0deYq91oYMMx7ldO1wxVi8ekvYywb65TpS2blBXawX4fh5R4Mliiky+siNhuqh03LFIPXiaSiHj4U1s6W1VWwcx0qqj9Qh9TLTC +rl6xRo1iruFOBN7MgvfDqY5Pp8IT8ZBOqXBhrdYp9/Pl/ddTKMdq4CJdwtCAckF77n0sSwsSx683XcwuXOhKBBeAtzG5eaaMJjl3tQMNG6IHwIitVq0dtvEW +qlOOZwOG65KcgSxwe0RGoIwIkZb5JvsbngYiH7LN7kSfg2HbA7OUfO8V/9M+6LiPnQfX1YzvF/+rX1s4FcvNZBXzyy4TlzabiZynVpOYhcji0p6uoZe4ovuD +YARmDSSOjlPlg7BLNCIT1+DBWqXue3JoCsau0n+GwmYhB0A5Awnbw1XNbWJ9y56tvStT5mMkH3BZ+heDcLavJ5HEMdH2V3wZq8PsFTnROdziOicPlwaYVIbf +sNBuWvmOQswokD/tDnxNYNu1I99B7uS0Hs3NPYpTaQnTlKYKYRZVkaimNov2CCl1LtH3MHCY5ZXpt25O0xMpGcUOGD9xX6a8HyMJyGaoEZRoHuyuYS20WyZv +KS99BvjVpX1blXe+qFuO/T+lQ1qyskAbK8Y9Fgs33Kkb9SnwbWz7SUHm5ma+hCe6dkVumv30EHYQjkVxXJHufgic+sJBlrweA67cSVzIY71lbQAd8+NIDzkH +OnyaRgZAk5RSN8tmF8b3Qufhb1ua7dgL5z33BFowiGwr464ZYwWlk5WP4Ve/Lv2NJvTSIoiPTUNiSD5ZpWRHVP4CQz7z6jYx/uX6L3vu6kWjfkby2uMl7oNR +h3rqLxDSsHtRgZsXRTElG8sMH2D/M8eoT9nrAKshIZQrv8rLcVHRN8K9yIOFT4f6w+xN/Ndis6kqD1eufPa2juV//OuIbSQtcjAwP+dbNGS1MyqPlk98gnG8 +i1fepdr2BOWJaBr+Bq8qULTnCcmd8kXF7ddTgeOmkMh2MTrjJPpTgmrbPXdgACSQnF27+zmXwdWhy3aCSqPzLoSerDPN0xnZDVVUrpbrKi/lY8E46mEIsS0R +Zj6xjJ9JUtrBSmfab/BW6YkhuUuucpSuPQt99eLaynlVbLLeRPU3pIfOLABmbsWyQP6LUyyw1qJinmYWxZKLU4d5/ua2XvI3v3X43JtfJDmKoUK1/wi38Jkr +PjG8LTLqrtKXQpHtfKkLVMJ7Ueg/MxRj1App5Cn/V1hYvQCfpjyPH1dSsH0Lf0/z3zZY52Z90oKa6t13rpzgrW47HNLYSRq9HYXNVNEBxaI3q4XHaqh9YzL6 +3abF13ymjO8B0HZbl444/uUMbjDCOW/38SWKdf1jasLGLigj5ZWDuBVffOavJSWCj0ZcP81aVy+eYLcZQ4pX87hGvm0i+UjG2jIqrMZ02iNTOUOcLYJzcVuM +ATyJtJBd8GYwdqLs8WavuDeL2z/XemOEJE1m2X9qYfc3nUpmZFtqJRussn8C2hbrBUskOcNhBwzftMDtlP9+xnq+QxlCFXrxBJFJTx+U2ns5McGqzCj+hFdS +no9YkkDKSDgJLsLa9qNH4zzi8FGYXX/jyjE5N/qbMuFOwor0FycYugs/hGTM5s1q85szUKXyYlPWoVBs88dKGrDjeqJa/E3nw7IzmZTIH/l57n9ZPOxM7GL/ +7bD0M7C+lTC3+mOkwiRjuIfgOoll+cvvZEgKzCyQYdrHcF3JhfsROLSKn89mQcfhKe86f5FWOoHlXQzTTzfs8Dg/9IllOXLfe33E0GoEHPFXuViBnzanQN2P +03R6cDY4t95DtzEZ1tPbUb0ZUlRGXRn/QJrmqcfNHtUa/Dscvgv9236Rvs+GfPRV1MvZIq7KhJpLT1hHLoJ5KhAh1fZetgYyCe9QyFDfEUg3DCw/squlFOPK +GDsobWjTYqnY2Cod/CtTCcN+uecsZT6g5FH8aDOyV9zrNk9VhYzWTTylvgwE1v8duNADryTfNitcooIO+MlGC0s4wYLOfQFLfJxz0JtCbbqaebV1FKrQM4Nb +XyJSY+e80RfagpEU8nmGWCmMvllU5giYxazWoMD7OAHflTJ5c55Vmi2r+uJ2UWKyKAoXlJSl+7OgfRwXviSFhMRS1V7L5vykE9GjMIkAmZa8ChxNNL0UwThV +RuxoxmrrekKF5sItsiiGj912cQh373HDMWVspBWhkyrSNC4mAzzls6/zwAhQmYS2XvqplHL5CboDo6+4SGuaRbddh848YTfeb9nFH/k+SCipSqbkcTCexZ0x +N97ukNt1e/7Pp8ME5luBVy6rmNpD2ESGzCl0xoX5rD0C3lr+bAzaCLvcVjHW6ymqP4MnJu2w1kOdrWixF44tuIP9lz/2q+DtBNuuS/KfGmwJKFAx7/S+ANou +pEzWMgB/aOIDn3z5WZuIOWLlyLA6YV1zWMF1fyb5Mru3jTSSUtRichpcjp+xMwwjlJ9MV0fzxyj6aqwtKIIWDVwfVgqZt+eQ7hpatwW8eVyQOh885QXdrAfY +mLVQXH9WIwvt4TUqucdXJK49Rx+dfjUuJIWxO5J3dDlGp/JGB2X0oQ47uO8SxlJa3Y0bacdUdz/pTGRQwTJWWe/rWW35FKVgSEeo9UXdkkNiNZqEgneaud3Q +9ZSm1czpH81YUzvk/10XH7wnjGP4MOeJz9OBcyge0zw5DV14Dwa4CN6al6pPU+SUyy4M50c1ObB3DP4zvGQQmvogrkCZ5cXqPH31U1QjpJQ/XI8xVIcTquyj +WYS+1hrKJhz+Mi6ZvORlBLq7kfT2BJpDurGt2uW+57YBROfFpHpIfJQl1OY1s32syWt4Gy7r33gJoqumjCSVxeru5j9NKCdtvfen5ww4t9OXNZbzCKKz5LS4 +MLHiHmbBzm6p+3z/Qn9Te6vlDZBo72XAIyOmfrzrMIxjD3f+oXuHwGoDhAdekNkkLaYDe/ha42A+rjoJJ0uh43ockQ8rHWzSU9q1toIC6iQ7ZoSiCLjixewM +ksqBKQSzB8zOPmsyFR6/gLAzuSIlbULTQPqPY/TBwSLFXw5cCySTw8wUQff9cO0cLG55TzhWBPHZKp6G1St6tz2DZrTy6SjL5NSj8r1vbGVbzJ/nCi/KSw5A +fAMNPEEKEPV2ZnRTjgZiD/i7nfDomEb2XWti0AJTNfklT4bUNwTFucX5sRaNodfPdVEmv8+v6ng8B0R7piCPwMWTgPas8nDrhTOCrNl8KOXM5UvvDEn4eJX5 +O+/AaWDPYF5wTfwh3Hy7Aye6SEkO1xAeVgc3nVw7VXqCsP44NC4B9e3MJXIlVtHMjllnCTS2eHw9e1CZBePMPmZ7ynmL1Gh+jMscitmjDRxbgXkSF7v2Pa/Q +bpfveXJaFK8cyZqdpS9NTGJGPpTKB3Ebl64/aZYGaY7kYdLO+c3YdU1xNOkJmG3ezp8wp+yua3mRzf3qx/m+p/JU+wKjf/FpzV7EpwUEr3IBu04ACOPc5n0g +Rl4uVcerjisKa2m+FR1w61vTvW13CIzpY52E2dHOF6sZjsrSEYnDut7M1B9ewOsVaXo63oWQPwlbb2pLLWkvuupIuPRkYQHnRB1GBWD6gaaJjLB4F3pmPL6k +MSK9DHeRNIWNi/Wg5YG4FcEs5FoMlHzRwJO9ukA8mH9CpFWveHJJ+NvTxtlCsiXnLFCs3XObDK4PgGKVN+VRfp59wUHCoU8LWjRBF/2U2QR0RAYuPsj2+DXa +6gs4VjUksEzB3d28b44goA1lV5FE4YTmsqg9/s3t0kwfvALfBko9YkkLyxLxG7RsJZSETUF0lib7xe6zwJfnpAUS4/wnWNuryOikoMIw92OC4p5UrCt5uT/m +m3Qz8Z7ZD/YgNURI59xqKMBvuOiFooAWRmpsahTUfghXwpYx5nc8wOnpLz9XIiPBQ3S2pbC1EKTIvAOnntvJOu4Up5vKEYJhUxTbRUmUvUmHTvTqKXmpMNt2 +FBTL2CsFZmAJiJwzP5ICVjJOSKTNLCp4t9DF+oaAgO4k84jMU15n9JMY14UzSbeebRNloorEgZFhgXyibftKKRxlcZZnwAqG5AM1r5cI0cDfQ32ji/7u7qGT +vNf/SJDva7nEaa5E87kb/dvXqGPQylsxk6Zfvvt0T8c50TP6qClqm9rp6aYC6MQ9+3MmfBXPxOpolEj+yNEK4DF0Adgnu5HZthhUpTROzJ4M1j31h7lbl5dZ +4tQTzo0P92XX4wZuMfp5aCHCi5qOdCr8fe3mqNIVDBnMR0rxj89pJLJhC7eCQa1k4Iy74tc1Mtq2ShDCUKERrP3Pm+m2G74FFkx61Dq3+RG0GMuW5ePmtNP+ +XEVbZkmxcC2wWHw9q42E8WxW0KP+jO+FYTyJlZQ7IqYdCVfEB+c1s75pXBe6XRjAp2WQs8tiMn/1OYpVnPIik+++bsUsn52W6BNNSxjBV9mUzEIEWIj4mLBW +2ookd3LOk4iMyAr+eUtwgKXVeJmZA0dHtr2f//T7+PefxVn0Q2sQldCGuBfakXkZjgWehHfidewFjXN5Pd63La5GT9wYeuMFC5Cngpay8Bkw4o03Xla9Jvsp +k9OVZlqF5ePtK3PLEgKBYKTUhg1Lq/OHPiqLstmdBtbcs/Mv1e1LVzLQBq9n9IVvZWAhIg2VP42Qep8OCG2tEek38S5llRMkbo9xBXwHaCnm6MYb2QvhKREH +p64EcOA4vr2GbdpWhQgjsyN8AawbijSuzzbYRklbTES2iBDiXPXVrsmCWD7UPrKoLIClgOUpFTZ9LygQ85EYuWtEnksYSNivOugdESeby70y2ORjXV44wvma +VTe4ZQJPZlujj+WYvfOI3gQ1+mCXmbP7S0XWJjxKT88vTB/Td5dJjgBXN8Vv+p64YSHY5bPFqFSauEnhKrH75fNwZcYANtcSphXG0QxjVzIP5Oj0RC3WjDds +RZHpYBD77mh2vrqgsZpHzqJzoiOwXGmJb9MyP+ZV90kVMfl9Ef3eTEWkPiRlOD8dWgR+x0jY5uoX4uKFZohrM4UlLnFQa9o3c5P2AGS15czPbCNPn9JBkI8c +jdPjVZaAQ6sZ16EiIfDH+M4/8r83/mcFk2mW5PbJ2KMj9NXLSU9lqu/S1WLtNkp9iHfdwRY8IFOPgD96CoO4C1VquNpJGJUZa9ufWTZzCZMspjg4QgtHttLI +FPG33fd+YOc6TQn1VbFQ9ZOfuuEytXuFqIcn42zr67Ouo2CZSvqb6epdOkXbolv6jSYCU5njQ5USqXr/MxnldYgCRqDoJJ0qVlGu5G3pFHWqqzC56fLCRGQg +H45u3UhMz4CotmV4cU2Nfi7KoQyWfmgXc33zST5JdpponxwwE1H2Dc5oO3j1VRt3thOiAwI0NElvA6cJGmz+XBcqvHYU7FMg0rAgdmJ5UzuxZ3Cy/x9RYGuS +Oisb8IkowBbixpbizG9P7AW7/VlTQaV/5uUoajSInJgpmVf1GiXTcx0/PhpYfWWU2M0TUhkIbjYBYsS9iThGo6zklnnlZkmZeUU5ZPYdwKTv/JGwcZ5X8aOB +p4/TJV3K/hPzuaIoSPo9LuDxL6rIuJIbvO7XZv8fOs2mujYr9ZKTRigIDL3yJREvtr7gQKZNE4JjviqXQXBlxOVingaCnC/wmWhLRz5G170FKKUgN4250AxI +EaePL7mkf2iTTXw3S8OOc5swOLmS69NzFR0ykB5uXAdwEUvlj8QXWILwUBTjShoUvT71yTSfmIyPGIs7hoH39/Qi3Saw9HgOrIkyvWaMwu/MEcyDlaWh7lZo +WhXxmQeWlm6/diVcN09evTDYN5aaXKxsPyHzyx2dAoNgLXXvf3PNKS2DWGztPU3ONGdZk/cNVkQZFq5MedBM8epmHOfx1iN8faqPq4ryQPVp3i9R+DpqM36C +Vpp8JIe5Hv3mI+bPLqd/WpGG+NFLGN4vPBlV4hpFJ1PdEZfkI8FceQ4yr7gfSHdK5a3p1kPSGiAWkzkxJ//mew6JnPzSUnVnZdOsJllGprWO2nq0Tr62/PTR +3vzznI18lkoOlclho85HHHro2KGyvYUPcDyAtcK7a7NIPiQfmU6RBr6BimhN+vFmvVANXUMxyf3AicGxnetoyqC/tWrVyxM/dNoJUVEAqM+U31jg6vxmAM6U +Jwzhkvy2L1D+szeL5yofk7pHtmmX118fP2i/F/mqbzMmz71Ub9m6W3VMGIJ5QhYf1VeUXE1Ie5ZMS1hNyeL+E96tOsMVe/5DLQEN8DET1OeuLrD7OpqgG97e +tfEBHgGB0nqw4ib335mWTAmLqOruzSvFI3ySROZpc3iANEMwG1DYTjHAZnPUG2cayFRFEfHKW8vRjCkyQYkiGPAJLBDBCOtl83feeLpRTegm0bYJQWWBXqdE +diNXsWYZUDlkfphXQLHzRxX4N710S6pIh2IAqM5nYA7gWlL0xxgkihR1X5h7Y+4DDKjQQm7mOUQKNHFlK7L1XrsnFWnl2svS87W/AacNjMzM3sXO3A9HW1a+ +Y5hzzatWrNzw1AVkzAI+v3owuIcbRrHeN99lXtkzkX+3w3xdxtla4n6zq/nzzGKTvHE2SPTi5fwdk/YVugkx3RNxL7pzsXOSJalJ3TlUK6874S/U+5sYZfdY +/Nb4Z9T4/f58hjoz3aMvu1rP/o1QhnoGmps3Y0wFU55Cv1c+HZk3gLcGQDL8JcYUzF5SIXvQT/UvScV1KaBoiOuBqF0vzxbJVYVn491V1o177jGVQcTamcLX +6wSuxc0koC7e/B15xI5xCRwLstdyo7dz1ducl08J7V4jDS94mc/9AX3waIl8k826XkH2pUQRAcGiPu40OYUNFxvnKOH6a8OOg2+rVv1J9fNkJ/o0hgVs1RCp +5UrBYxrgKygt8HkZqMS9CZTMmhNzAdj06cjt6LIVT+sKBRo6o/kwWL6//E5a4pbME9dEFoPVsL9rShK3EDXxRkzN86YoyooJ0x4r67PvFm15N5OSnmkEffsN +PKWYIRCYo7wWMz/nGWOxJrjNuJMKCB3pG7sgpL74wxctuxhg1gGM7HANSWo/UaCEIHRoqST8lGBrbngeoMyXyuCoRdIIY64a3CfqOilLlhQV4cZi3UkLruv2 +GauTrQVuAIoAsWFCMoNqs/ANZdZZVazzeeKagyts8VBtb94KlWClZnz9Tsp9JQnp8JlD7shAeKijciHscJg6xSFS3sMAgetgrBTzq3zzyM0IlN4Tp4Y0oq81 +GuWMFfq9JXUVC5JkH3+v1MEQV1b/JkpGdhT7JfPD1hyuoW53g8LI2PQkjw71O1InVjXdRXLx/Fm3PD3vaP8Yz5L559HA7NXWp5M6pKRARvT98uIkIS6yhOZP +czmFUpFqFi2I5gVIraZSR2vQaOHLfJNsdcepMmeP5oNIZq8ra6WMvO+b3/yo+DT8JZoNEu9XHC2XLWDXWkZz0RQ/YD57fORYEMYEcGY53icRSY+f/1RU0lKk +uPIWsOkBdJkXhW7gnSTZiyn6xg4FzbGLOEKC06+RaYtECNPFaM2z/HoGPOWltx+GGCyHTZ/WUwnIVoV3GFKl9UXZ62SjzXZopDH7bpsG3fyNcJzrxEuy8lZ0 +SXql3aEIL0wYIhg9GYMx8etlRSnFX+GsTYPg9n8+ByVNYvL6RZKf3kRX20KqfrHD5UUOtMT9Kr8kudWVkib+Vy9mUtJkTXMOaxNCltc8HTgkIDgCFlSKaoMO +l1L8ip29uot5a7k0TUdHMWvZDDGaYaizFRsWnz/f3B5EXwQEFlq9gPi51P03Vjt4KwkOrjmFeds4lNvZPsieeAg5S9QiBhrAoAQ1tOb8SPyOS6LTnGZe0gdq +UsG1yirCb+9P5t3dzdKSiiRkJAY22H+U/pf045amppqSMGPN9psUBN+an8zbIrL1W87UIIK1RR/vV+r2k1l7IYsWsZ4rIdcrPkpkk1twiueIeZ2BtVrF3pf9 +sDtqki3pe82rccH9yRTyixAHO/MHBBthGeO/ePB2iEniJkyMtbPVFJ3IHFTGIcZSXIW9J86T2iSGyla/XRPmbdxoKNm6l4WZD5u2bbHOY0M3/aiHDbpxNrFl +WfIhJGIUHrBsZNFB64brt4P7Fq/rrovXqBJ9Y6LX13tbka4tAQEFYSfdDezQ1NxYxjctnzXyymvYy42TZLbpp9TXuNR1I5vVBGoDRNGwZRa7vEGr/Byi7T0r +qarMejoXY1aUJZ/C9T02v8K3JJNTVgXU7veheqEfCRswvrz0mITcH7mtwL8rJ96XWAOD9DR6/rT01TjTNc+/Oyz5iinI/1yY8Fnc90zbk0+mI1ucbMpsjJ/Q +jMtdf6TQa+rjmuXTxhIciQ+XguFL76VM51KdYLQoUJxMcagaiMw/6GK6A+SMa7DTdI4Xd0oKzJkfVfhG2IllCg/Uyx/Ac2KdKO4FmazCeAKH7hRhW2SizjbY +RSxBAcpzpq6fYtk/UkVfepeXPApdBN1H4azO7pVPNPEW2XEg+c8k+kHZcW4qPRxIWKKeHM1STJp2mWTttt1yywtGZuHP0rAwT7f4Ib1QTe7AMBeOsETJ8OMP +ujYmwcQpKWd/tjfohSipJqTfrxRyjljgiiVDG6Bxjp6fwrdimiG2bsfrl/98dhKBEBhOe+pAgo1jqd6LOLzGPSGr7x3pmPyOtN+DDQCZFSh8vJFXnIK5WeIK +j4+gUZkalFrQcHeLu72sJp1w3g3BGHcQF1aM5M9GA/hHwd7Nn1lEzVP+5X3+tAIhAeyrcr0gz1LS1rQFmVWqJkt09Kxe/DDIx+6alE8YMNGmoDozPtVJsico +tasouqJW4GnA5AREVUf01NTkBZZF0u57GuxQsnDpnd2YYrE5rtqVvHaF/LFAkZn3vZpNRe5LzadhfAqKQaLEdkp2Ibc9lFrUMZA60n1xocLThmCC4aSXT5fY +t24nsNQy+Raw7JdHt69lFn5f7PVTj6SqpPukjUAlEd7sj0XRphZ7SWWPyRblYWq8i35vqDeULAnVq5ALtzPqXXWLYuyItzjUlLnt0OoQB7ILAr7AloBYFNxw +CzMuuMAIPiK+CqkKqGZNjViC9ArVPvitncInwiVL9pRkUDcKdSxLMMvPVXDqQIlApPrYh/2XbFMiIaP4/sQbc8eDl++wkE48yLXyGosAqKThA246KA2iGReq +h5LZwjC/NlHDvBNvN22VJ9+bqrlE3BE/gSSDhIYkpSImrLUuDovT6+6LaGYU0SW9y6RUV3edTTLoAST7KIv0Sze18h4isbidmeB3+Skl9ixibNenhBv01QNC +YNH01xrONMRpupwRpZ4WPMubMt+8RokVszeiWs4aTbz1gc8V8BPV2+xpYbH6JKRf/uVGtduno8J7Ozcng0EZihyajkEKBzTvZM+c/WUYkXRWgra5EKYBxSKf +ezNGDXd+N52Wkc7+w+/3cQOF39jWHvrkgIgLyiBpFLHDYt4tHWE93w9OYU56wUThC5gyBuHSxtzPvDwOV0UTJTc/sYRXTAKZ5jgtBMnQQEar0/+VkLYx2sHc +Xm0EykBh95miY3XRErH0Io9XbglWIZ9Seg4ZWErTLNuQIgTglB4LFncOux3ROOEZ7wl0lTRm4ABRhOm0/aXniV1Q2bnHIQDaDPdNGuOBxqL4VjWEyvvtxqWw +bNCDlqTjN8Nr49P0hzgnZBNyVQMWZ7FyNrL1BUOAkmY3fRv5Q0wh4fwx2sVkhtDmSbBfuw9UIEJmzUHivV587XR6A6TmkUduYLIgBOwynkIyBIxMZnZMKI5k +9o1U9IU/kuE4ds8etKKYYejB1Pi39L5+xMTf+whFe7wBlsJhCsZLipN0YFbmoyMBvY+cu59xSDstnixKIkaOpwG68aHwfpdTv8ef6QBeaaJpV07X7EJ0cCp3 +DUR/LXPZVt03NSnfljOCG0/JE0LOSO1C/UobcyqkbnfQNadcKrr5eHvoLa84ftOvBx8sz8KVw+GNHyi//SlXphQuEv30flEsPia2mGI+/W6fyZDitxBMU3nx +rD5MdsX/jZJTR0XhM0z5fhuNlFmqr1M2iRt/QEaFwhmEKyWpZ5xC+ZjrmDQyH2omxnLzUsWAFGohJ7HNNQCrxnH+ZiZIMeTwCGrfxFKXKIpU0eDoityMtly3 +swm8b/ypmJxoLSE/WRQiXt7HEACf920uHx6y0kACTcUCGGmcFVi1151ii56zsxoN78x+JAsN3iS3Cldy5adb/l0atd2I3eYZhV6b5xnim1gL675EEd3dDLm+ +eYSQZrqZn+9yIaCZHJSuJhMxKuabmPqTvc3Mm/mxuMkWmQVNS69Bz5gv+7u0XlkZqLMbYQzgTECXq/Axva5wHEsTrs0tv8QfmKU1ZdUU9ysG0a9pRU4XMul9 +2HD3FPYP0+4m4MQL0oNBmU8vGj8951nzR0TL5wynSj9enP331z7Q44wO6EfjQOYwpX4HW8YdiHFPIVEwVAjuB3BG+TmMw16gBfezEQDQtW8VGVpjxumTQ2g1 +/hW/PimOQG0/14eTcA2r5OXMr6ZVaPOc/tkfUz1Aflsv5YbrVRtqntTkYDQCx4G4GXdYqcjzShgXoKpMSl9ZCOzDrJ8nf+OlRAG2IupeRRwZlpoXcrcfLqxy +3S3l5pCSdg6fOGkDkKOyjawFIduFavcOhoK5z2ceEYXoB1L4LJd4gMa/LXhz2luOoodpjo+ISkNpAVHmUvZtLLD8ejyRAQTrFu1FWOCZAB+q5a6U3XyTDGNS +jdDmUEh5l61A9V/A42q7FnGCOaMDbCb+tX0Va+VqN5fLu0VgblCBeBUngQx0P2JxOvh2tQSJGeP83no1Uhwhn8LSkSsubvpowAuTrcwAlZb47hFT0ZK9DMoW +MFtdU/6AYWlQa/khraqa1VK5g8wlslfIkpnwMpqd91eUHOu8vOBFfsFglYZ7uV68JnuMnAVZTMCB6q0NXvPPZIcFJU/cJhKbTcFeZCGiUzt2QSZf1gaQrwzm +4W8WQYpk0qfqCCPK2oP+VSq1c8fIqrQNMRAzkFEw1LWR2zlicXWcdnplDmSuz6t/k8aX13lovkFs3Ah9NGMYLloHx10KWzLQtMzvbPPP1UL3uoGjIaA9pLVg +Ue7RTUVleHbMoZDv06Ards9ioV1dxnhOhXMX3w8hKsDf2NPvY4c1sisJWFUu2mhfPZqLn2JET7vNLLTnaPAYszUJZDvie2vdmwGLp6u89778RLhRBvtmnjxz +vMtjTky0wgONUA4jcyGzW/XubSokJVs65mAlYDoUasZierleK/mkThx475x4NEf+K5VnSb80KPaWrcwYeHAXfuw28grIzsnSZUBO4DecRsITo7V41CFgXg1c +rq9A6qK26xUz9pxTM8IF5v19VjyhemUkxqYBilK5389LMb57Vzja8UD8R2NU6sEACV+lNaPkQbRCWpQtqB8NyE4OTqDkTS8llgHATW0UQAyY2zSqTcNtIH4q +VMtpP8Yj6oPJj4d7lBb+CA89nKpOucNVuF/GnulkEz2o1f0tG/aoQlymGBWTuJgS5SBuguoUwwSoMRHN0fAIfhFOnjGi4Ju6B+zz61O1yEMKxhLNQbWuXjcz +MTER9Zketw7piuh6wL0CA0tQNKj3Q3mD9qJdOJKsCZARpkgmfQqZBDpoAwtO371Qx/AcreXCLZPChggHauPpg5fkiNcQdOL6grJQcHj1ZK+q6tkXSU8XCA2t +q3LVDLE2DURKZUGBXzY/FYWBUyWi9Kq4YXrTyE/mParivExInbRVoPAjOsItyZ8ysz+4oXmmXbAd+BJF8WRAXFDquCcQymAyVTbfK0Xk9iC3wdtCNjtQEZsY +uZc+Gsm6/6Eyx+AgTBPZzLBrCOU2fJdQg5kBdfO2UOCGHEiVCwsDbBvaP5TQ30rf6hgzUbpRvdAGLPVAv1q7w9NNCcfeZg6YHmCEeDqs93a1TP9Q2hqe09ts +8rY0T5G4F+kvSTlFeJmw23F7qDGNcMCLuTPp+SRolN+4V+f7oqCfT5VT9aJIjucOfDlpaEXTr6ztMzVzVOClWJn13x0XZza9aYpmYMJq5FsVVZTpiL1TL/LG +pwWiJSWLlJZkBJtvNPfwwkc/OOl5EiNf5c6kyWN8WzFEKHJIvQvFMziQt1eMg62z8LNQWqdCCALashNXs2DOKRS9IwlGUJ1ZhVzZrCcBignAoDomDpDtMtpX +jLMOVEbUHJFRiaGUgPQUWyNLn8Vstf260ltwu7g6+I42EoUdAyglaq+hVsmSKvrqjakHXwKTLpM+1WusezwKSlwyu8MUHh+775/Z80q5BMKRUne0iobkumFp +bjtJYMBRklyUOJaeQGvy/7ufE6nSwySzYNVN4+SHNq/cz+v6fl/JUCpmtqE1msAPE74+sp3I/BV/MW3CN+Qih5MbzSVI6P9wnujfF0iW1duVtK7K53v77k9j +jwqLK8lfaXTKFP3xIEZ5nZb3vnhqOx36gbEJSO6ZVwNtVKk24hbz+phzSBTDBxRNOb7sZQMajRN0puIps0G5DD1t6zmllaJ6TpZEIGtz4WDg3adbG8vfXmKF +8Q9/1n4rnujG2LKm5fy5ZT7MGL6mfDd4g3vywKEYJtKgDnd2Sqdk74/PvN6AeFQsPtCHAvGKF/xE+2o768mkSJB0+ayjhLoFE0bGivQEAp5YEKFZ/6Lhru2z +O8HUY0VFkMBxRX+JbAA6Uqw/kSr9tGQGW+dtE6kreDWA1SKZ6CJkLugM8AONmKwkBBxQr0y9xi9D14uJqFtNH2UAHwlVh7luRT4OhqjvHVSM8mi2AjTY9wL1 +Q9wtoUprnC4k64+4TLcKfeAh8xm/dq4TzWWQ9+C1rNMGpQjGYPbiqgdW2LDIOOaVZuboDfeLLfM5QI0fhKYt4snakikES/ZdytJpIT9SzVPlf85CNVVN7Urf +/NInLrLs5uwMZRM0ZxYbG9Oj2CWQMu7Wz4Ov8i3KK+YzmTDRgwA5aX/+2GCUjmrt4FYl14+NQ4rENAkbdqPI44+vsJeRZeRfPZ9t/oVjkYlyf90ugTIkW9ZC +QAHYn0ukaRSrZE062OTFkrxf6qTm4leJ6jNVGwWtAzLKIolfm/sjk7Ze8pJdW75PCOvOJFEfF4TlXbNnDDakDBq0JUXqo6PzOmUJEBUZn3W+aO70FUcrrRFb +En5jyfumhj732NcJZqo3Hi4HUWW6GZg23L08RBSUFHTxRdfuGeAaUNTioZXe2HMcV2InxhEVgchyhtFTQLCrzeuDUphgnNkt3EfpX5Pkiw4aOXT2/rsm4lON +1Wjqd1Yva3RUOTcXUUbnMLVyE7Mp5h+j97Qq4wP4HwxjTG3N6KIdAqXZICQpsShevhAY7A4FvUEEYFVUg06+V36+NNApSnqun57c7WzfolqX8pJJIuOTvKvd +UmbE7Blj4J5Fb88lwcyuCPv9SOPc8zBBmtmE5ZZtt+ikcDIbe1qWHXlP8WWj4BENpifyfkvFASUhijYo9Slih7Py1we1mmt97kvUlQ3tBZLQCK4jwa/ISVYc +/9GmPBFtAn06bXGXV0Rofjss/L6YE4uQIZVAHbqcu36gLbUKsHhg9+w2flreeUSzh0hYI3VpXTQS8meg4YI2M2OR322zY/7/qCox2J2h5G2XE5GkpDNSoWiI +f3deOLq33uR38M51pDOT4d6hvtUv6P/HEYFr6Df8JxHH7z28w/uOgHkUimdhpMQ3zZkqpA7flPUNEmwTUzXFgAZzf6chcPtB6IOxIJS3NB295PBy7clpi8lj +QpPXhoxrZ8+5spxCVZeHvUhENU7zghirul2W+1v4v9VmXJfge3itZ9ekU/hJtiMycycRPrVMdfnJ26ZpOZBmNt2AzjUe1KVx2HtdSF49wUTKgXwPuEzD6rFe +5oOSzYxCZbRBoxrz94we/JmIQcA0oBadkeAtVuAKvaluGYNR5NWgfgiglJEwP6OSbHH3HxwmydyCwaZhgWAc7VY8bOrZ3a/cbEqVrAyCiEXl9Q3nGJ3hlsmg +mYUfaGV+HCSG47VqQ1zrFLa/4p7abMBruDGFRnwP/cOWrdbvF8P1k0geWwJfGJjyDnyGS5tvv7YRbtl4XpXsYSyL6IgZFSYknRSD53zkabfAxF3H1UZYOw5r +EMi2XRpqKtE8ZDmimrcauQ3Ro3jcPkHyRjoTNLMo26aS7nAbc3XSSH4B3Y0gIppmnY/xoOSsuuKgopp+wRWNxXhEqGha07eQ9znG492m2zIH/sHBdtQtqFPZ +sQqABK6ULzuP3vcynujhVqMLW7pdgBJRlS3PCuK59YTngJKvK8hd7QTrqQOY2sbaXnE4lWChZRb1N3RPpw/db73KMtBJAbWxt+Mo1ltQDjKysO1fmwDmLF5m +/yCXV6iYtQNBFwZh0HzEToi/wMKoUCYHzgw5Q+8xzjmbxxpoIRO2kDpI4nl0/TbtEvHLqW6efBy3KJMtZwBi8WfHxPrLUFzQ7mKbbNKtkueHRwYVKaqVtxM9 +Lpl4thmncVRNTgjNmbBZzoiOy+tjkx6xGXQ6vsLgY5Cf6ujhaiPInnm6R9sqjfHgU29HUHJV9Jk9Zke1xHffzZcCq/lI/TZQQOTq0ly2hGMxG/MIGUQK33Jr +0Qzf9GHMS0qf9FOR9Pl7VWcQn/2816ThiVa1fTQVFnZQKffoUjbRORs950jVxFv6VM6YybgaF2lEraItIDn2iRLrph/q7EdsO0gm/zVM41yiCeGMyEI9TY+1 +8SgRZKC3bgst1HAU7R7oO9y3z6rxRiD0+8C2ux2Is8NsdCYeuegopNEXREG5gXrE1AiiJH0baFAxUD3v5exHVZFkghk3plyn/2AOUvyfLH4xmLmPJwoYKqmG +LEfnK4QsqHIdSkaka5mcmE9+lQXdkXJ+dS4hNbnRzu3yr6IZ6g7wU+YqFrOVyEOADJ4HUW7aTlWiES2UsUeuQY+9H4gnkxdsbT/UoOl4ergW2HvAB5SsEHcq +Q8+63ZMCezVMdih4KXRztvMra9f+7b0RTqMr4iRvpDONuk7iFe5GDHUJSUgnILurlwFG8dwjAiKE9UrRJThaboq+yh/fOUaoiA+M8TE68V8Iws1GEc4Hbta6 +H2Nnv53vRu25SuQw93LWNYFcc4z5n7XeqnDxE+AF4n6H2YHZkMoT1XQ+8rQgbEva7Xpizp1miaBjUPxzDDS937Y7QXJKTezepRGWcehh34NGXwqMavNS6RHw +ixsndMimUiodx7fTlpvAi9L9va9Tkalc9mBMQ9vgMudygOt95HwLgYWEu5/KvTHSnv6wqz+t+BF4AmU3y9zRMYdHLQcu5qYIgeJXL+5heP96p3E621uREORh +XlH+SvFNk8fiHh2m4BwS3zBjAjYqdfoyG8JVrt0tqEYzIjYagxmS7o99EjA7m/FPSA44uhkmJUXxi+YrVLHSf0iuu3NGVSdVdiiewg6ydngryh6Pfzrhunfr +6WNRLMYFzmoCirNEYsAzVoczM/IF6apXThwzicG+CRNv8w27KEYZ9YqJnnkzZb00emtl0mWlThcWMG+B1EJyZh6jlc7aPmz761AKvGtPSZsK9TUndLOIHbua +zaIqMCVMe05KT+HpPWKNNQzSwKymv2JdykikH7B8MWBuC2MvW63nY8nBNOlzcM9/K4rWJkJit0pQvSQLVo59MONSvu8Iu+dIcRmZcjmHEpAIICOH9NJnMv0J +JO2DypX2QX0rXX1PQ/KyrENchg+JBt/okBYX11bBQyHUaCpMNqWXnw6C3WoXaoAFqHyZO18Br1vv3s3P6IDtp+SN3smaN+BmJyGb6cBaTcb+MOgrFm/XG3bz +QM0zIkFtmES1iQR041CWuUefEj6vkHNidvrXR7xm9LQBdBSiTr7Z3UsRljS+B/rx84JhWZG5fiJt2I6HPOwRCF+dpBCAosT6iplZ2Zn1cPeZhQ6cUy7FgCaW +Uekj80s3V8UaF0eXdM+SCebmJjvnLANt8pCU3bahl4uaLJV0sgWex8AICsKrr5NsujnEjBT7Yn7AYvPkQBNG6ipFjqQZMXAkuGaywxhgmEHf65cM2pryWvUi +Qh1/mg2CezNzsG8ySY75jRCBNrpr4I5RRFm6+LaDYhg7ZsT3poTJg5R8EqzAvoK7yg0yeR1WD6Qh87w4+T3f10/MkhGusYBlDgEtEAmc0qrJ1C/CVvcRkr2P +iYqqih8cjq04xPVSVRqQMpzqpDp47PB8Fd57gnx4AHfxzLXNm6jImKj17iAfzkmBw+1XsVvpzg+aYHnf59M1O4UFOKQXyNTKlYcCpLKQ81JChTnACHd41qxK +7SSbUQryYLfvIKGj9Vkx+nlCB7v09C6P4btiPHVZMgu59vLwQkJSyUTrPKlufwTuZ5gt8nBVdrVa6TI7itww2CE70wohKNNR8WG7A4LT9SdabvRdCHl01NdO +JHp4D5+iXlO2GV8GkYxK6Qw0FJ8shWx3I0Ox0w3E0XhGSKQMgbLhdDJXk85TqyWyyOsnFiu+AkXcT1kbBJGplGDiMX7fm/3ZFDrLhdtwAPRmG9V024BLmxCW +d4A5FwOfjuD3xsgwHFaNKlrEx1AFqNOiLpaiTMonRaaEYiSgxjVYdhe/h37GM8pmHx2/zLIHsBWDxOBylx74vNeK2SmjmTl1KyujlFC0WWgz00/bJNthsjY0 +G1C4rugxKrXvbk3qV1xCq2WBFdOijjYyEzSRElFDUr13D9yYnFntMbrZ3hsrn/nT+g0RDiUkkOLAG0jeBIRkR4IKSdJfMNUUDSVF6bMUSIMk2IXo+geEvRn3 +18PcyM0sexs4ZU9e2mbJRAZxFO4roFAcJmXnieWkJiqfTZDp/oxGNvvyHHJu7dW7/WzlQkmp2qSA9GQ24C9ASMB0qn2af1OMYkp999LXn7PCpTECvsS7EnWH +5KCKD4A8UgxRPDN0hH/90wkUFW5lCbs/vMRL2SK7AwVNRskZ8PlyGNXFMHQSzE98e0V8iQlVeOVYR6qU0a1a/EQouxm/HE0qGy0qgvChkPX1hlSC+jbY8HgW +a2TS7Gzf4gWivI9oQjMTQXWTdqiESWuhPoFzARoUxH+GKJKVI7DALyHIniCzYEW2fnlDRf+f2wKtn8FQCFO89NsJ2fkgRU2c8TolXbOsAfSO5Tv+42ru2vtL +FP0nzcX23jc5397XjNN7tB8cWDFNV+f9vjOOzbLuoYU25cGxpuT5nsr8Cn/Smwe0GO8D51pKsk6D+7p7Dfk29RiDDL0Drb+rKyrzLSgvuanKocanD2Q7K7UQ +HopDwVk/f3oqUjCqx/PVfq32rNIRcRcssMiR0qBl5tVMebTAryybCrT0ZkK3kUKA9XP9PFLIJZ+ZGpfDj0jWyDDRBT/9gNxn5BpLOX4H5uJpX7J+m3SdV3by +priqqVuTeq9goMbOZXzXgVNkIyVi01sG0Gap+Jy3NYLPo7XrvFM8MXkJr3QdvtO926+r//RZz3SliArtgyn2Y2cQBMQbN7mlGhPrhM+R3r0l7ylKn6TMriox +Vt5vvb291T83xbBzuyeeltQ6iCTzwnV5M1ztrwl6SsF3o0pQ6OFKp9pfVHz1fpyZRywfFoxT98GvO0RWFah5yvec4w/8fy2HLOkHP2WBTulfiMnb6fgz2eYR +OPu+yJOrOiy1k5vU0NHqupIrFWfZrB+NeHEN4fbGkkxntBwvEuPQXg7/wKywlPylI4IcTTeSYK5hb+nipI2WGwMAosruY/ubhWt+IFaH3rNBEyeTzIEPGrsu +mScaFjDimste7NsPlM1zgsNzhxbs86DZDrsgrWGFcXCic9Q3qQqhpInSggyUtspXfLfbkxkJhuVTfkz1cviVMxsInLvLZ/j5D4SW+HWC2XR2EpAbHUtm8dH5 +8gXMxwA/b5YhqBgEDlZXL2Xr7AIaAMOVwdNfWSWvY17DOxsuKbxzFPYEM4ge/bmI+YWlwf7V9oQBZXz4ixYseGHhMSFiAOxMrPUQqqOUT4EbENPR5LKsLVvN +cmaMdUghSD9X7+05u4w2zGdRFHaPWPe7sL5ZfCChQG1+z+r7XUH2YndNsgttXjAIR1hMR6+WhHJyt1hmyK8bxzw9OuppZc1H6iJM1VwQwX7+zPds1OCSTjTO +QOR367Wq+KuTlBKyaFY+hevAOW2AEFGdwj5nYmits5Ee1KJeRWim4IkMEZEX9XGIfEetbkQoDZRvJm7BvcauVsuUJbQF58Ub1ysoINmm+bAzVKIJk4HrEeeQ +ZlZvu/BnlmCebDIV88mmhksWNvIs9m3nhYwF4Euy9n5qF8tm6Q5jTzrFyC8h02980bId1M0iJw5L5DiruLhLgsLWSKlLxgXc2i7Nr+BFjpBoeZU5XLGnt/AU +HJlG8Hq8nN1EMwyyyIqUhWspgsmmwrIJlib9LECjW0cshf7Unb86ZF8BCU6dxQjvFnHM0NZo0U269lw1gmRvocmx6AvIrLshzxGEbukB+BwiVCBkJHLki8d/ +OUHZ2rHG0t+/40rMJan5et4hVjQeTHhgosq5kXw8DCJXOLqIXWAo4og9ECkmRmRUpHUawho3SzCIRQlFXs6v5SbTwe7r/HrIpc6EaOaMkbeEH18V/sJgQlGU +u2dVfc+xQ1haS8WkvU93ffirS4IY1o2K+zbqksOxE97Li9N6qJMYcZynbqCGFwNLX2EEYx4Q7FdDXF2ZOybMpP38j/1Sx5x8oqgNVmVK+yUKGEdiKiNng995 +f52HzHw90bT063KMXh+0oXEF5TPkBXi0+tHjL3qZjNQb2xNBK2/Sir2lOj+yzq38p3VGzzmwnilznQ4OlBjkcVkKcWisfWa1W6ObyGJQrQmwBR+QwdDpll9F +XCRWNVPCGXhkO0Ska1OFdIFNTnSNOS6pX/DRH3zY4+em28r6DJXjwAIz9i1HRX8SGXDkw+9+JjjFytmxthiqVCHaDPZqwBVSELlm5wxmq+EF3wQUn5Nnjr1t +IhtoRfOGCoNw83LQYW2DNNXEluBVZLT1KCR5AlHh1vK8UsOEukApB8cLb91JVvUvx4qyQXEm4xXBoq3jlrh6nZlhtwxIXKrO7SfyOGIu9a+a2meKzdgHqtPC +9vzPdhirUQfYSYEXjPeAVLFw1hQ9/ljDfjYZ5CwHHohCVMl4DnGHV5w0anoXzT+FkvTOoORRP1S3NmwHsJjb+1QGOIWpd9D8Fg9ea03JIX4wqO7zz7fHdqpW ++Wag+sP2L01Ceh/Sa6CY2x4/cGmSU19UE340O6ZcrYNjGn+HIlLRZqi0u8zf+U3exUKq1u84WuLjvFX6qUXPVBZgZFPzu6Du1RuD++opOlOyxduOBzhsq1oS +7HaycqmYYL2qefQ3vxCy7je20N8x0dCMrQbMf0tehMtrazTBuvjVvNBg6xKowKDj/Ed39RjIt4noUKnX3tH4MGG9tTXsRNxKSTaiR032pQjLzDrKPlGEg/1k +P5joRSxS6Kv7mn8XAdGKzuIBXRShlkyGVeD2pR4tLht/2xEPTkGKo5ulZTDtVmccfaqPuTo9OiCsovpQHE5flUX/zYg/Cp5oRstLpJudsk8wG61GTxJCde+g +K8GCLOTDQvrymQ3dS6J6+oq8wpPCQDmRPuXg7JO6XMrEd5kfWc6zsul2//P0eM4Q34PXdvnB0HIt5nV64RAFTKAM/XS799DXuHjcYZhHNGdUKxDO7VXlPXNF +96315cVkszufHdx81HjA8cW+ClwtBiINTimRN8jiNuwEiCu0VWUlF6IfNp2c04DU7Hf0CFPGn4wAwrpl9PDFr+AXGXE2IWqCPblFDpVTcm7rJZI3khzUcPNb +oxu2LmDK55QisMyeEilfbKl4IiSaTyTDH4ZSC4Cz4Lyms1BbXO+qOEljqoxF3xEDGEf1UGLfd4TwD//DJudwnudx4gD1Xb9RMdde4enP0PZbwMURgVfxbOde +eX3xRxPD/i1nL55XLQpyldOsYzYb6j+1j4KFAS0XvHT8UKsMWEsKex5dRgs19sjfO610wE3uwbY8VyS2IzeFdCTHIXX9YIQ7wIoRtEFBQqYlh9MsFRyOQWnD +f7+7r/XEZL9/Cl2NoSwt2VSKfORotJhqzr7xxrtNSD9gYc2MHd3P9f1fPT4GXAVUK1ODdtGXE0+fnyC3NaeFP85JfqIbvAKoOsdFOW+C7DBW1ASU2QIwcFJW +XLRBL5m9GaJwYK5a/wJROxO3sYRbmRojphmsyhUbZkKcspA1Hhnc8eB0swBEsMnkziWQFfUycms7bd31STQf/8fRTspGYJ3dddS5vHIhw78ZkkmBpGQhy5HQ +NdkuhpHo9VI2vnTykQmmjGuV6d550rgvpgoWJy0JJJ1768fYAwQbRuAFH2D2tTlRtGqCEtTFhSImDughbU7vZuBqvXR0qdiQxJOyC/j06CAMFsyO9Gz4GoRk +FQmGTDn3mioBuQuOB0KDT5+8ftfOjm4q0pAdH/pzlt1J8ERpu6v+ZieLMtkn98RWO4TpL4XuXwBSe5PDpIpYdZ2Ob7BjpesbYaQmr+DTW+p6KPK2zeD2w7Gi +5tBdRRihQSW9v3Jh2ysGlxnewIZSntMmwTPc2PCcAh3V7t1NoWtP0a+QWKpIXsyvA5RpbIrJfBJ18HIC4qWVMncu9+8Y5+Cme/wJaDEB8BZYzfnYIizZZxlG +UACYJzeAV1X1+A36GNeLBknbPrkt8G03cEMr6+KQJMV7dVmeLrqE7QqFz71d1lJJOX0ZyaqlqI0AAvRjPkLsjr5qBEe5MHSr9XI7R3XlRutv6vSBmMQsufbm +cwR8UG9pSSt0nr+qamJ+2LWpNIJsunlC1bJhfB/hjrTr/H3InZnIG7q8SgOa9OoAhD0WVJ1Bwr1sXuJ90xopxwj5hX5ptfqhJ4bhLfLEYA0miPi2nVVat5oD +Y5tHAxaQ4WaKJtPrkd1eOSuoCWZoAOv+KAk1JQq0sMJnBDTP5VsskpMoGR7wWqf8Y8ZN8Gw1AVeGs1IPXF2wCTbgHHEepax67Gc7TKtT956YxQ3lW/hHFalE +PeoqBgL80kaHqPjWPvaaXe3AyYkC09DL9REwLtYw12nszLPNE9j2WwLrl9qOcig7PaGJZm5KIwtmAyPAzmAeNaN/Uft/E51s3jofU9lmN8l7yr6KUqRCyWEV +9qMWrPsvM4X+St6apo3y0iXrQUnZYffnVwW78cuPb4rQPem3hp3/tQUNTdpeMg4ld2zmdEq4hAxMtA1BdbQW7/VjfmpajuUlI8X9bg1vWlbUVUxjoOYgsMdn +XS0GkY6C/kqTHuAdTLYzUoMtj30cxjofXhjYiv80qg1bkn4Upn2vmoQGB8FHEz9E0qiGgWVa2V+y72nBrfJ1Bi2NhMgey2mZ6wU03xqt5dAVHItjd6neMBSK +NjswFdXYCXtvslVp3l1ay23KIeBxmscpww09grxOBhZ71fRF4VonnNwIlZL63kO8xr4IUcxTaNJU9HxS+pHDEXaxY3mk+khKda2b/7L3jd528ZHkB2lrlDkE +p0pWtQKuZ5szJg/XfJndu9UPiVxFs291jLp0rFvEifJdO97luuxbjC1MEl9g5CjenzupA/I9v6vYCrDKIzEHP5I9BvXsLRozwYvczfLo3D+ya+9RCHqz2SBt +ILsKP3HggDdVXOYdy7CnRI7aL1mf+9r8FVo/uBzfPP8BK690cqVERES2c5nMlZY6TIFLtVeJyPkL438VFl2gvk2SP7ExIF0uC603VJtv81/zGCj0kDjLlEJl +LZWHeGuPveXzaGgZR/QfZRxK+WSqyfVyDkDlFX8xbo6J1uKKgCAmYzWRvMkhYKv0SeC5kH2EJPW8OxRqqY/4hNDnNeS38v/ZLH3EjaJXFazPJN7IUVmr+wQr +DCsFTYiA/VDjg6gKGoDFaSGh52OKecIW7g9OGt6bUwTY9R6e8ICb+z2tUz3F8cO3g84YXZu0XHPaQ6ilfybQ3A24IqvbHb9Yk0c43ZSmThO9pvfUU8AP7ghK +FlcevXAlc31TDFm4XpvLz02dybQiBVHFA7Z7enL8eEAfY9YvDsI4vHvIuVSVWP1hSYYy3Wy++i0/GaMYtAcfpW2jgTEgiNo9xwBOvgURWOFhzSYTpvg15fVa +atfXma5GV347nuay+luPLzYP38fXf0bTw0p8JVUHMctVtygt5egOKfJqYbvQ5oV6oMQtqMW+Q2PQkl3ir6nFzUz3Q+6TmwBEAdWcfN/ML5lu92SDGKO30xEo +HefCHhm2pch9qGDnGXVmgMY9Xrz2tlivZbhwdKdS+CdkKtRUjZP4Tw9gtQmvu0iSzU47ShQF3t+PvFdvVsEsFRxuOSXTTpY1GjoFolqNi+xxtF6xMtnSOVmI +a62Sow3t82tN5ZNYV3bEhN+7tqfOPjqrRizegJixTa8sVnL2Hprs4J0skRSfnAQ78t6dg4I6GF5Kx9mHTgn/EwPJbb76wiK20d1OeqJgpCWaD+vdwjKDxgzI +SlbFuOaxBfin21xJC7QjCmguUvo9jxXrrNANhPHyFk0phqFVv5TTvAj6LiPUUIDBH/UthuFHNm1jRjRwutDapUkht60F86MQ2l8utP+5vEIsoqfTGF4G/5xp +JmPF0ZrW3feMRa9OHAwgCTuGAypobbe2wcP2v/w4bvfK5MWoYAt1SRtbgplpTE0G1kdWFtM8KiRJyqdcxxpN4q6PuXE0n0MK0Lw2yWVH/Ogbc9wLUPzbUcqu +KGp0gpz1mpvCt6VELfvxKDip54AqVX0uC8T+gab2yMkdX7vJjMMusBzm0c/rOZgp8ZX/JUj1uxnXGIRkAQy1358cGqH9YktsBbEGcUbSHBO3/dzXo/TV2OY0 +Z73jyft8xeDYbtb4UTNc2kl7BEjK7IJ5EdalzRNhljSNANwbIepaBUUF+7RvWzjiP9gHVZjhTmNH1hKYxtniQfVlID2eKk9QBvFFdh4PsxSM719bwvzGbidJ +hWrseDj/Ad9/Z83oXCcuGHcMVDQJ4mXXj5IP9JzknAlG43BWhWq2BHB0EoleFS6Bn7pRMt7Jgs9Mqv0x7FC6mwNZb6g6J32L9Yr3L2sVsJmOJOck1yey5qtC +a9IBaIeAN220Ll6cSoEnCYlLMjb5MS3Hs0snj9UGrPzlmw0wXZOLPY6bEoS6JHtAZ3KPIYwtXXV2UpoP20kX6MiTDdwirbvSEgsJV5pg+va2jbIHMwrS8kJe +0y8lSyzLviLRxfRLnzWMG0CYGCjRSo5zrosJz3ae2HUPgXtqBkTNWdlg2i70L8cnYBiys97TW5bo15yZa02j4JfMKXj7CFPzapknCJl+NkF45Zgu4lqzPrih +ACu2BTbhWQp3EKlDQYvEb5ZoNqEvMSADyFboStuNGa3IJbEbNlIXNjDDqx9SJqkGT5Y8UsJj7sxNJJ8slOt3AteNRE/7mbhT6hPvGxbuYi4XANHdnecFM+Tj +G+YmUYuQzL7aGyRc9svyVtLDCrHwLkJMtPYQpk/FtzZ6xKuPjl/yC93Mv/hxMgWKXMUtzAHXzFKoY1Tyq+nWIzrrUK5ADIWKdsDYo5XAmXBoOHFtkSB8UqRk +soTGlGSm1Rgbj46iGjtiF0xwKtgklDfrPjZzZ2jBnttyq3T8ySwnK3skCH2UEhs05S/elDPRNQfTRRet9s0fgA1Inj/6QmaRMP3F8bPvtvFC8vqyv8zAahdj +TUTHBjXjOsm2RDuZDF2QMExKfGkmg3GLt59cE0t4zKNVfQqItN8hxI+59QiPjml3/kD0g1RvxbYNziAdYRGE2J7i3CW9i50oqJwv6ubeL2ZOCsBC8EfQ4cAC +kWl5DuxnqpBRklZ0MolXC0XhdgoZnjQvCDR9/16oTu5b1iou5Ldr+NXERyRkh3y/gcbE6NnlCiCyLbMTRksWeOw9oHSkxJ0oTS7B43MgmExgHaCMblE0W1cB +uM1XbwI9DhEGooxfeYh+KS0P4mlC8E7s4IjZSSkVaMKLQB+RnR3TGK+lVr9RzF4Vn3R+HS+lZGLtQSxaId2sYTVoGUGA2YzjGB9+scWe7/H/2zqXpApymQRA +wsmkxWsqI9t8vaNaZna/sjSpp8E5LvvTPQOVvRQpDaUehjYyufV5ehx4BHMD7L0NbETZ5Rx7pHOAbowcCvcgmQ/t74u5TEK9tM3fGXGiMYiLuhAxVKOOghPC +EJFYMTgqjyw10O2ATpjMlM+tZXYWuxBBvdenT24MbMDlrp2EdkwTM9UyrEIWhXhMCIBh/euqRZQuGSdL9f7ywZmtLVUJQNToLv/rm+B6InvhWc5Xzx637EBu +kgQ3u4oo3phIk80wfKKt2FZSAiBwSheBWMwf+ghBpsdgG1nxcPLHMvwEF/flYzYL4ld+N7WyxW1NQPSO7/iflnFOB+JElJxCgj1Iihm2OV+pXUoswZqD5tWR +MxdJcBut2RLOHemNheboPzVGNc5KWdqvu4PIDbjsr2/S5JyWPULjxtwVP7XHPcAYnN4Wp/6DCmeQ3JIdKNXq1CmKmBVv/XzUR0zzyXgYkxnAJ3qgHGEdR04E +20u7DbFvithcrwsQcXSqL1lwxpm3UIDSzWZarvaudS6tBwID66oDGZQm37WamCkwQnrMFkno6r9knFKdpjfmKEMqZ9tbe+gCjLD2Cirs61H1xWruVDbNblS5 +eKZXYFjxVBVyugV0p1/oEIauP67xgEz6tUWEfqZ9WX7RJqO+Kee6RRfyvpZkMsdxkVWLbr8sk6FQzNBDuk1nQKGvbNz1mpe9d8VJjIsmyEJzJHt0eI4FmZJl +dCI6h/q0L3GF2r82N32/W3j+niog3+5iKnOUv+3NmLTW6JDqSVBJXmy+wBLaFiilAnhZ3964vYiXleWvJCm+jAG8HFK7P4262cmrYqogPpVAqKeydb/eFk8G +9LILYeTv9N1KdRJTafl9azuip5Wyg0H2oOyqbJ9QrRObOOHNGefHv3fteXks3bUjwWQwjf7qdTmVsbhX5FvpcD7tQUuffP84W2AufPvrLLRiKm39t5MGwNmr +MLPd3uNFM2jnIiAOP9Cw6SYtKhrrg7+/1tkzVaxgDwzJ+COOTGXu+jlPoIpqUlolhTh9pmqZ/fyTB/HaR45xPsXQfKm8ir9jITpV6oVvJ5VOkgVq3xl1hTAH +RxHMHZtpVu55o633uS1tQkZlOHImPtYNQSo+nXpogMwqbNsJwD1+3ouoQ5TzCZ9pac0kTRsgdKTpxKjW1FTKP/sQXV+l5RK/VOtIbjDvRd0f192zNO5fHGrV +l74Dr/fSPWhFsd9xI0JtJ1h1u0+gEeVE1cinGlbW+ACM8wUGE6HtPOLVKb1Jv0sTZa/iZRaWmC3OljJV1QQdxRkzwla1I/hRokXEvZ5sF7RUkM26ankXfj1m +BWY4rjLpg4VHeuv48dIjQj4pCjhGEn0y0FdrMXjEG1r4cplMkGnZe+kLF13uyK/AeNJp4tiC2DMEHCF2lIxTd7pa9pYp5bY9guDFcwhFZdR93AeeVgZsR4YO +umc+tyDJ+Z773IMlmIcxq0peTYezc+RHaVIxphXWYlbpGpj5pUTX1aphWjquuzXYAxqvn9Xp/VVavJX9wGY+8biO12FtNxE2pMRQvyjOCkX4urW/m4ajWpM8 +tsn00RKYa9UwJoLvFhy3WZ2wT7iwulVQXMMRiq4vyRwVPyRuySlY8UdUPa8FqLmQBuYpG0M8rRbcsZGQvxkUfVhkRyrPetNMNlGnQ0YfcxdU3JYkPh7heWo/ +fcVGfULeU4eEKMi0ftmeDKCDmsG7jfFK5eGykUnJdEk+ScJh8G+sPuIy5YWtHnZkv3jEDzQFGsO/5es73GBSGG0oMAR8wHhEeVudG2jIr4oSq8ef90i6I432 +TIJWLpBEITofQj5lh0uM7d9bmAfwsmd2oDqS78kTAn+H0mAt7F6M9xHL+nGdLmdcR0DtsTuOW7+vGLVljdBxGLPF8PmAR8zQRMW+p2/Dp1OpWGPu+6732Pf6 +JwkWfbw4ZkUas0zU1HoXt1MAMwY4Eojr1QVSdTxe2nid2d/fESxw6joN5uXFPFTTKVZ+STGWlthX/LGLeHpF08WJtbFrRXvsV92UjDi/L9Wxfn513OV94qqn +oqtCutV9Ldib/6GhHz4NOJ8YHWAGTl4+XhDYA9t5Mz9Wd+YxaKYEnepHJuLOM5md042cwXraGXDwbs6Za89qwptJdcyWpfo+fTiql5OAMP+0+6N6mhBQxIRm +qryfD6BcbLLDlha/yLYPdWgWw9xTLrMmRNoQnm/Pn0MG8hol56kE5n+7KTZo5FpQX6qH6I2SN+Mz1xz//GIphvy7c7rVk3uDqf6zYIbaQHZyXlWu9P+NXbxE +XxarxmmY8eethAGl4FKxVRZWQS+14wd33Nm/ltbvp1+6jLvLE9pCviF+s2dalK/vRENGgyNH1LaKEA8801XhUvSnjfqO5SelCtntRIcH87N0ZiU8fSw7vdZp +FBSBXwyXlTy7Sp0eVSppyp5IJuH81Q1+XCav9Bubt7Su6ksVU8581L83li5Ka1gCmyyWCkQQVfsrda6L25crSUu1+DIDo5cfBh05NQaMM/tFn+Gl11HFRXcp +ZC7S1KAS2B3egGzl/UfGrf9xuQ/5UNDZPbQnQB/5TQ8ODznr49R1vHb2MpdjtdzvKtuDXZDn0E+H2sZPxr4WsknW6SAn+aFnNt8VdB9sE2nJlr+eYdCcbj04 +URNvCDWoef/IwffdeTuWiGdaOcvseMQ2slCrW5JslmYy5qWSr1wGBOiYdxmLZ6grqJZtaqjZaOhR+F1JgCOtOo3zNt6SJqqGGQ3NGvw++Gz1Vd+9Rl/4a4iU +cXcGcwHyYyWHTu6ti9kn9Dc4lTpyKk5rVH3qZi2eLj2PxIUAmzHZEQJjn/mb21Fgw9prYgBRY+Sh/ErvfOTlrS3kKOzGuTYOE0dYLzNJMZiJrBwULE4ALNnm +6wneNPrBNfu+ll5TTzCGbVWRksp05z34Tlz1tAAq5YXzjAzLfFeMdbsGxzbe0kA32x0iQnFqaX0XisR3LgqzCuyx7IzPjvU0VOSNrXeQtVWRcEcfATMHUqvU +txbk2nRFJAYagVXE+hIJoeTfFWt5+v85X/JnuApU+AC+IYdFbmLeOoz02ef2OL1Bb+h7+ssatTa+76CL38fRyZQ2g8Q0aDwEcgG97pSXMfJRWOk/etuc4g3C +Ty+32FI4lw1RZ8zs6N0hF8Edt9CxqmI/B09N4WoP8AHWDlza52JuDam8+MrJDeOmkQYuZ2PV4De83qnDsqpbFjuZCiXhH+u57imIq0yrfwh1qEte2WPckkPW +MTHj22EifBR5AbJCxjmAkFJTujesPbA5olv6ssy0SIhOwM7Z2e38Om+Zp+IXSqr8lKfZ8uH1GEbZWyQBMxVD0mQ34KYkuqUq2DayFh1Z934bwBf8BKb/a1Hx +xc0afdy4lkuGzG3NCL/mzGq9WsWVyg92RdsPn5WnZWaTQnePwWWtDqfGVIgk7wsCWs0PNqUsZIhkyFu8GOdAcDfxni20rwe3ZhHQyVfhcPcmYVMmP8FmbHdv +DhuF8c5ImS8k0SNpaWqrcHpUULIlEdEv2kGWKtppDdmyW4GVZquMoKj3ulNRvVxhLFY3pgPj3nRjVhvLki7s3uoOQU1w7ds3UTnbJ6ZO8fOyx5sEB8+WAW8D +bxwKNsfZ8NUfTcLd7E017QIY6MMaZPRT5x3jh+AdfbgOm2kBdIMtXPdo54Gdce+ZbLLT5MOqSaogj2DOniHCM7KzYvDP5EKIVB2Cz9lZNk/qnVnrhZc/Zr2i +fisgvw1bshPJ7eNfjbZ+0JOkrqLOqu2yj4qS+pKF9q+tZnSrlwff3uVa3wZbC3M9bd2fRXI3kOJPfN0pMSjZ22k8jebOmj5ykdVkiYerPUN70eYP7bMlF51j +AZ/7wxxGH7yXC14h/+EXu4/ffeA+o15gI4M1Skjz3ajDuLGWzhF+jZkMOC5f9XDnk8mr+JP/hfoyMo8c3XjJAMjB8dU/j/8Gni2ZcT8hmtGCt7cP7nDvzTfO +PvVfQsaJRyGLBW8xYh+nL8olhtRZ3kUGQJLVE6TK9HHRCSnAp25u3tOz98g3DG+3qEn3ngF+VslOxfvZ4Eraydc7Xea5uLcx6FD9o1HzNQ6k3VXtK4hh3VR0 +pjA37n+1wOIdzzsFiDluSMzecSs0sn35cVSFB/7LSMA0q+kK3tuncYIeS1RB29B6PHOvNwZCVh1OR/IUcD+KDGXZsHFPBvNPrIICfvNXAdwVXd+fL+VzMPdT +JdfplAe8xxV90TRBHCy6mr9om9iw/9gvC27cjgW17k8yLZOVgQOWnGl7oSDFV/BWdZDzvS4m6CCoc0b2ScoDUZR6lV3au+Z5XfBXg/poNs08/at9+TQ7jWZV +4D/QbDUTZShf3ZLXww5J5X8cFsYHNzwF+n/XGotxQkWWHTSRAI87qGVVLaZXkWw2lDQNOkWWkEyy8/acXnYL74vgOz/+Yj/NIYZ63tnSz9C6lwaY9hI9UaHm +Xs0p44RvN2id01iNIJ72WE183zE+zfbHJ3iSpMS80jyirIGVS5a0Cl2YrC1SzCsIchbXZQGaBZIDZ2JqYjC2EjlAC5Hri8xksNiBbs1FF9QZtZoU8Ttuuhxo +jRf77yX5pPFbgXXR29sNfOiqg0dJE3asqKeSSnxanVe8iujT5XDloK3BCDWHm1M7LbCPiQ9JQxC7gvp+qd87If11FgzaMRnljuhMRTEin1PzKzD3gaE5XgcH +tCfekYqX1DJ8OFGjW21jZ5gYE9B44jYyRHMyRtRUiWFWlsFiOgets4SQcnX8spUiXePpbWoKVe0iwBApZ1R1f09ScS4pFR7azwr40O03LdYThvKY/gA3JdFQ +2A+6y/6CkcVBc+Kxl76Gsh3uSHm5H9CG8GLuU1x5NBHBsq3ZR0XDnTYT+rJH6E0d784NTaBe4QqFgpDMS7hEL7TlHy9buXTA2kwT9xKlf+PSjNzk1y6HI5H+ +nV5lr6xvMMAPoo2J8muHxLSEKUIsz625S0RPYJyd7GauQotGTjrP3QcqGjmitjgnt0oX4XBP/zzrJ4R2EingUPIoM8UiP7JsipWDeQ5Ty5c4m3Pfhpc0kTfR +GKTsGKUxY9K05iJBlxPpeYBgozbczXkSM3Cn2tS4CnMCLBMpTygjga8rFxnS3v5WT0q5l+//tjmZmuf1IPDZLQEk4LhHRbFUAOjOXsJXyOf27cY9VTFGD+6F +R2w2hCT/5kCPn6qHis1q09bW7k6IuTHm+h1dFPmkcL61UOwmwiT0QqTZ7Qmu/5hveZ2DhrnY1+pvUmHk5LWKFXUD5hL4hBRUf2BMrZBu/gLpiNkBIoQ+a52n +3YBJZ743zxaqcorT5ZnLxi6txbQFg780PHGe7yNTd9TbmIAQR9CYadRFhOqDSHLSN4XQeV8T+u7qVXHIpY+SD7uKjyAvzJSpp6jqpCxGRmBhrMZ0pznjsrfp +lU9jZDU4MTROjfeu3CgTfWq4xBQ/zpVOm+NQ48sdpLGUvO4WVocTPgVL0ZgcknKTF1nosDedAva1eSHpEilg9pwZhcYnMXW+PH1ApQF0pWaMWoJ9Vu/x4Dji +MQhq4uh86w5ZDmWCmYdzB/Ie/DPJ3RhqIf6DcXy/Jssmhn1mKvlUAvOfFf9M8X8q7RgUzpRcFSbdmorgDTlr9agDpxft5rXCCIgGyVWr/ctuA7RAxKVjV1Va +J6ocWwS7o2QZVYI3W84mC1akG+FnGi64WbQMw1IChO+O11E9zZWdOky7khZnAb0Osw+uDwqGqJsQPUCajxEavOPCdvD0ou5SgTcqXFSCubOYCRwknJN95nyu +Z5zK58J8USw7pglNFAX7gPNzm8wWZ6qMwQGVK1Gj1Y750IqABxLoQPJ5yDaZgIleDyINMyS6rXwAHG7tXSzuOCT7bKof7ncpTA8SiEDEWkvJ4/tm8Uf/Rh3I +Td6F3p2wsX4laXqFWLRygOl234g30zbaV0z6AL5Z1yDnr+YcT0VAk4alJ1k6OFWsta8C5+db4r6z711neC6DM1yTFjTQQy68NiIviTpS9ebnXMuAz6TiN7RS +D4LxCYhTaV5mPZ3pIuh0fv5x3y8dEsWt3feRfts1MlmppkroTC5kTXugZzFWCscTe7V0OiItPh8e8d2j7T0EOTu9Y/NXfxK0ukmst7MF7OTCMvUmsc+RBYMJ +k3nA1yW2I3m+jJuxayPjZKSNRBT7jcBBmEKgMglTi4bAAOZKGVEDp+ER6CdZq38nxcriXRk8jb25XUoNJAnBGeWHIYsuJuV3w+geQkteMT90c5wsYjhwvrTc +Cg/yHzOSbR6ETx3lhUeopqBj3YVhAN7QI9zerNV67IXtY+wUVFgJOytcEHCr/j3raHJno5q5qOjbU6tUZVDTFkub1WJvBCYZ3iRRqp6Er8PcvLZm2IT2+ALI +uYoZ4cB1qLqNhpKcSN1ZA4h40OhWmwFdO1gk8yeSSwrCPzXHumztjF4/8gpTJZFCHRgQiVnSAwi7tCPLxUKbhckSMWiP4SDFgqbICv3WoFuzZ+hLnqBkD7i5 +fHJvNhuWEHJSvE/TXdKYEhU8GFyZ63dEhpATH9/pC/PaUZKtc+to200jqwGwUJ9RdmJc+z2fabtOBwoUeUuCsVzopyybLXdxsehilYIrXvzkIltO+bE5zZt7 +u/Q/FX36s00ZoyTx98kjDJSEjb4MMM8rxUhjLJP4y9Ue68xcepVnMFYER5dhXVt0KRwOSXCidEuZzusjiVbhvdjkEEICZ40VWko++Hq4iS1j4iO5pdojn6GS +sCLLdqTfDy+ClxqvvICwyMKPpQhal9/P51Mc78hnZNgXwqOVXtoFRQ+Dk0fwpLQmMXCJDdoqCvLIuiLu+nQePFB5TtGhgGNCYa0oTctBFoLGHznreGC8li0h +jvRHc+0ZS+sBFoKuzbaC56AK9xnKmXRceTGSpJBPUN6HjhSZ+i3wCTtH2u98EBXWjtcuGsMtb208Vq4QLWBhBnJemafkkBFQR3dx8QvbetjEFh84jH+BYrzK +TUiz23l0s2GvdGJGQAc+eOyJc/gpZzUU/WUkd7e66/flItXdUU8ERdqdGDAGLIfRR1kNVIWiHcCOPuUq/Uo0Hm6cEvEuyOtBG9ukZPNl/ngXb5pGxE3SeTzA +4LJfrDRJWs7Er8AJ03Wz1eOKt6DZH16D2NjiNAxFykAN12d1ygTT7Xrnv++fCdMpzzmpM2qg+pf2oyyEkEJatfI1Zag9s+F7P56+APwcTO5liRJ/r1sCJelG +hNpgOCuOtBFrUS7PM2Em3g7KRj4ju7cA6VQlKxykg2s8LU42DIykCbsqyGHLYQis5Jcvg8UMp5d4TO5arRV1oMSBX0F3pFa/McUOvK90wupySiF2pamKNwjA +qUHfjtgsmTsmGYteoH0y78MHchZZQ3djEhaL9+2knOzOxZn+fNoO2UP3NcwUkXHcwCyxwgFDCZICHDhEo78DtbsSKctSEMgO4EDraw/Snq6HU4ohxLF3hTVI +GrlBfoLbzL9v8VBMokg0zfdC8kfdP3pbJaKEBULHm1cxJKJBCiJjHj8GH0ok0sxQz2xApmNt/iYtTSwgI47ghudHAyi4kXagTctawpiIOc/757qJLhPUFnbs +7dWYCzIC0HC7k8+KrpGezEKcj9GDGveP0a//Q3WtajmwI7A+9W5lVV0KWd5kf7ByuC7YHYfxD6JgoTis98CPvf4gFPqQ0vZJ+DX1j2Aikbi5wjbAZ47oA2Cc +FeseaF8WsWUAT5MDld8muVMxHJ1i3KcKbHFGsyjYoghjOjKwZcAyLQkiIo5dN6brQGLvh9fLYKr5wfnYqR2Qmwe3jdbj2Z9emQWpbynF9PHoUae10c/Wvyzl +hFBisUlarrq/UnaGkPxwHnw/68Mxni0DQEju8ggrfuAmM0S82LkXqq1z57Xnu6TOOZZ2vxiwUvDrqiLJNSkkLB7HtqOEaG20pBx2wsxh8f131iwuEqTV9Eff +/HB0Gyvd3ihifONljJTn3qgX3qMnfJ7hPOas9gf9cm1C3RoWieZcRNNP9aXrShvHzi1GKVaA9/O+GFtisuAh9ssgupKBfzBFzejf8xArcl3BL5ORWDfClmcX +WdQBP3mDvSDP/La6EVNHXWTVPkhmJKpd2cGWKTqXVO9WjnCb63rEpPF/x8Mca8uck/N4YkkkOIlpEcfq0PHAGGnyYakcAxiySVYOJM46p19MoLe7eGB91Mwf +X+Z3QtvgWv3VmxR0niRv51+vqKVFQrQoB/KTJs9/KCrY1ElHXXk9mxKNkuvpld+XXFZy2sM9PI44j2c7F84KAjSQV8G+LSaJG+PH3lw+7c1lQ0KFKZnxhfoq +3XW3eDMGDnFGm0AklLicH8VXHEucjRGfj2Lsp5hVNW/rd/xAsjcDk+8uyc0HyGtYZPBr8H4SZ43YZawCm4CNEPofeUcHFrUkC9qWqqNGxMrBdMJ9prG7HCKn +Y2uBVRs/jeBukjSvD4fofSqPoiU9H6BrpMnCFpDbIEPZKZjedrTEZY6Ou0j4bQSkQ7IJIw9L0vo7p9jxSnczmrWJZlELxGQVGMRxbYq4NgK+Rv4AMmXAFNaa +QBi+0QdO71x6wgZFhA/0Uw6J/P4+u4+rAdE4TCo8Ch2vdJmArn2OW9NaYObwsBFGnvw6T/JGqTZyx4VVfRjOHTxLu6bn3ZfDBtkZGAr36YCv7OR8nQ2k5Ju8 +XFugVCFGoBbxNWp8oKfDgyXg2ghV08akWuBZKHCoVHynMNISiv7Y5sNIBM4HsVbw0AWmrtNDaK8a2uTeg6KIBNANrsFmMHBTrJqNXujKjWMMnGT4r+KTJ+xw +terIo5OUVxs3TIObGePcHP+VahoA5Oeg0th8ZXqt1EUOrIQST2+zQpn5nZN0Mm4kod8QjOOeqAshLp1som79zCRnMI1hS0IURgLLdg9nT332ctmXz3zP80mh +9tPBmrFnVkI/SpOJx5MKyBsDL/W4mmD5yhAXk5di3nHIw/b4w69jbLr/w+/3RclyBI01pH0ohpxcmHiE5CzDnOI2SzIiK2FMUL5vzdHPcwngYByJvT1oqJhp +/ftAPdvUDynQYDRTGpitBohG89kyOMyh2OhJyiVhoO/H9d7fSJ0r6bl4KWx+2r9ZS+C8jW310r+XuZsLJs5tF0T4Xd0cAo3VH4P4ThgyQ3Sdb6TtAgzpZ/2B +JrV+ZOzNGfPv32WDev7yssHq0ivuwflQ0gMw9LiMG8NAI3nUYFRniMpoCK61Py0hugWdSEP7HOACCMvI9hEKcaHyb9voJJtrKnxj7EwJg3FfHpnXb273gdbY +NyflknU3C8WXfKc4lwTNUBs71U74r8cz8wN1XlLGjMOPVZvGgtgAIXWF5mk7NZdsb/URiiuZYjPAyIyPR/sz0v5S2IyqfBLTpuTA6bejLI3n/IROyUWws8qm +aL3uyCvtSeKxk2NvOz+o7UvoX0gmz2hw6b5o1aHtLbfM/o2dry/dahHLNpwdci0s4qD9Bnh3GjVCx+QzkuBCkkKJdElz9DhIecFwDsYM+bjpK+BGXrwk/lHi +BsmyIXC1QSg3HHyd6rfal7EiMUCYwjUwYC3pA7K7PaAa33AQRdMLQB6ZUF7kSTakArRjFr9Rz/5TMkN65S/mRGKkyv8jOaFJB8oWASmMx0RMqFgsNc/mybVi +J7awfA3ADYXNkmIYSk+flqlbm5/NSCRrpGqPFsgpa/QZUlZw3XNNHCPdL1w2gN6JVlO0x7r7IekRyKhudxZCEj7VFtmtXaUDdDBhki+kEvvljViVTLYTa1J/ +vXovEKOlzr93WUrh6DarjuZe6bfTvPozKBDY5GEIFeTMWXsmYeocUpir8SFnQltqKWK2VslJATSH3PavrhZk181ce+zmV3wWUbzG9TO/403vaDsaS0Ibytyz +Tnazm2jsxqlTmgrDIQ2ntm+CJ2jBA7CRqJiXAryCh2XRfFpN4yy5lhntpLJ4NywnFzcqbPYv0gHZneiEQ4O7Am0rdD4LrVce6oTPT1dSqIYkXOmrt/qipDt0 +PUaOd2bBo0mRYrG1QmL4uSuPwTOJxUmuyQiiBI5/YzXs5fWuDN1PvSMJRpULvCxdq8h3rGsCU1sSYpx83Ic+v5kFJSNh1Uuz8rG/tKJcuBD8xpcf4VEFvL/h +T/tV4uDYnWLWfEovEXJX65WxQN9RAmRVk0RVkaXE/J4MJ9Ux0iSngSHAoWukjZHkVf58s/vkJs0Ko5siZvdg4Nfwfa46t5lmbBBJYwnO2F+vspQ6kUwyLF7D +iM7WQebX8adLpZCNjxD5Mo8nM0V/54GIpfWJ+sgo+5XQDxCvK+HWdvD/+IJ9rRBiHZ97HveKKYtpMOwAmWmwRcDUx2Nh4EVOGUUyezx/ydE6piL3RCQo8DvE +6JIGLanVjO1Car5Um1AvltCbPP1NTNAGOFF0Xo3TxxDZJ9WyObFt0a1a33u0UOghV/uuc0IRkY4dCvTYoRPsvDXZ9GXKVa7gG4TnVGPS9aux3/mm95EUWHFD +EI0oeKj2SZs4GHo7xrLW14n5RvwRxWQehXJant0ntiaXszhlx8Yiw7W0hZgOk3wWoXGPOgXuVCarMDYHBBZx2+VgOSM6uZtsrH5lLU5UJU4EYcDgEyugeF7O +PLyQaiTkJvSo0NJIf2b387CD76dNVT/HahQZszPbhvCvMewDUayl/GYc4WeUJmLpVy01oFP1YyF5rPMOqpjqZYmOSDeLIW/TiSYLEnNFvjXjNERvGT0Y7kbk +R1kT7BcysrUo3oocaKR9plAtg8M9D6Qo+es9w0IfPAj7SMtgSMk2vlketDFrlD6e4ahyszZD2kZidzklDWvG0pBXhPZemLYyuwoq4wbcHzacQk5jBGK3uPZW +eF0V95reMTFz36WFr4efnU8NbKvSIxA2MTVZaqU9xepL0nFyZPQ4yv7HNe2p5vWg61LFUr4NiCeFQt6I4n85cCGMJAtw32ztqy0Wz0I4SJs3z+WaWXvCFr+q +fDfFq1dameU1gQdm8kahhciAFo4MrsJaeFu5BboMfVfSVzLb90S2kVgGoJChnhMainQb+GGF6dLB8QLXrsCRusNh/dQO0utH7ZFUpciK8ehvBtFAeUPSUnzv +RPl6wmz740ISeML+wMmRfhk5qh5rZebyFgtNKS+jbICiM38lNNaO0AEjfV+Sb1ipR0PM4nQpvSZGtDbYQXtb/AQsurSxKUVwLO9CpSGIwhTyMyrADmxVppIi +HrTE+oJvk8+hbGCoVx0FaLFnyEZnbdDxpkIxHQVZrIvqiO/lK4OUztncPNfJLoqm2RRSbRAG/yrm2DMIt9IZmhbLCDayJPVoAGKviRTneENjX9HGcRYE12ZV +uPZPBCFn8Slhcg61Hg7/KRTDVNvdvSIo5hEIDfUIn49CjTPrR8qhkVJ3sROrmSy6zSILu32gSd/QhHId89iJQbX3zPbRXU+ODNbeK0AVZtaF6DDP6cgMuxKK +URsDn6diNEZFknxS247EIcW1oSQ88+FeaxK4qtHyGKdYxSHITkLoZmps36TFQAoMmA47SlYBGRst+0S7L3k9VNGlGS0UsVym1rKFF/vUASNVqidvNDdTaEqS +u+uovVhE64LD8FpSMWN4GWFmu8XG8IP5MfA8QaIAMV3ukuwUwLRSSBlDyPfZlqIAoYp2RcooAG9l07FE1WhlA5yhO4EqiTe62I/mLbrTkjtMwPpFkjB8miRP +8sVf+PvgiW4rT3j6KDFzY6tG4qwtIDiDrLX2i7RXX0zpzmLtJ3O5n3i+hPDjkOGxevPOch9JiBqpUb7DVnhGAF89Rt57zHwh/Cw0yMVxGWuA55LT7l9jFu9J +FIT5lmOqCbHsuEof1gBMiiPIWFLYq+cynD/9inDVnd0j6ffULKsULO6skY/ZZOyBW75KRty+oNhiidmcbD35bxnNBtlhg4F1OxGsOq38h0J/TZccQ6SivYus +GAXm7RJ64pqyaQu6jArrAgFvYIB3ZZangbKZNaSsbMcps1qzAmH5IDyZWs+roSmVZCt0q/8o+b5zyMPwgnf7jcj6JnGTdEmbybg1Q1jrXhsx1CaYWxmik7V2 +afeXPqoq64a/PQeP7MbEp1VinD4akkPnUZl+5gCLgneg3eWBtDgHcNPt7ymGVCCYhrG3Krd3Ng6M50AMDlc/cfcgHNRUI+3a6Wd4Dla/nLjW51/fd89fsiYN +PS2c1nXwINVScmAhr57HXRGoRgps7MzrTXqzdcwtCINOr0dAOh17n9oHSuzAzjoPr+ZS4qyMbpb282R3jHD7g8yxnBIkT2FeVb4rG6rDFfG4ICL+Z58viaqG +WFvrUhIfhe4MuUh7ihLWl8j9+oRiTN41OBgi5miZtctnPOPtLeGhKAR23sUR0KgM9jmir3Yj+NKnNK233OfCs2Wz6koxAVKMuiCU/rnB2+5TZ6DndlvvsD3m +tCsyntxKBiyChkcyzMtbE7s4DHoKMwLS5vPYHA0CaBZPa6qIHEYuE1jZZUQjlgs81JX44qRkY072HjwB9+fCrsEng8uJ7uXmJ7WKSdaBuJPGbMHgb0P4zGop +Zirqos+Ghcbf0S8VipSMx37yfxmqeFUY0sfqkRlB9MLE/Jz/lo2uGx7B5QPNUJeAV0zLp0NZ2SZ1GYNFdEnIZlUe6eDomBkYDZ/NqzOUFCLd8FLDs7KuRalJ +IO8a4pUXlO51zBO9Mxtb/DBfQ+IbRJE5PycrcsAgJutBXuzZsnKsKXG7SdVoLC6ierav4uaZpjNYatC+h+vhgZCL6yrGIujgiu/fTnHYq1SSxy1xknzeawVs +LrJTaVG4XPrgqidbn/4xIixqeHbkqKlGEL+cJgK6CwTPLkX3WP7c5NLihocPUmRA0/XZ5aF+V7CrVSYpjho4ydBdwxghaHF9Ev5YowINnepOuTbKs/eSf7qP +7yfFQah/iIHeU5UGtQ/VqYaH0h0w2sxdvFAZysHf+4vntbf6ZSvlV36JEacZLLw4/foSiXeypJGTTjbxeEDV7wIRvk/cfBqHXQmVpqjwIOhS8PdERZiMTXnL +7Da2G9V/jBY7697EY41jgU2zlKDwiFD+yG7fDcs4PCHVs2eJ6PCZIV7d/t7x+rQBtue47g03AobjaHRnjurOsWXiYkr1dnYudzu3MjiOvg318+gw/3c80BhY +xQQw/fVx+vrP7wPUWeNfyXk7yvdDvqBA7yWbLZEQpekOdmO4DX+u0swWCLCS2IRSLyYFvERQwzEzbcr4t/9zhUSohbDOrzo1uIW7FycbiNVMCXuWM+BXdu59 +6o8q7HRxquLKG5CL4u7UluJncPxdMOta1EbYgO4h42efnEuJLxWjWfWizEgFsjD8cshbQeGMMd3nbxwEvYaXQtu745H9IH9NhmpxzixPWUyeLp61MvX4V7y9 +nB4D1SebkqVWDMZ6TFPc0Pou3ksSqIBVbzxFItyOq9iKJavtCoMGUAMLL1Gs+YQ3EbWBYx15naPWa/jtgnNv3kk/M8xelf1icurORji5SmCqKepdi2qePWZV +my9ex22yQCn4h0mk9Qrd2s+kkvIFBMpTkTPXkjCyNKna2UIz5KTr8pqkaIknerIqrNyNUYBsqrJfnQPM5ExuymoVqnehUcZp4KTwJqqPIbzD0KPwJk+3NGmw +5F+lvLyQ2vrHrtLAE12T94CIzrDYL5yVsBxLxkuctpohLPLKsxWCz6iQMo2HpTcYIacECk0Ok3Vz9ZJXJ9AhdjWbHQqwDSgdh0cDG8PRYgsNb9lD4qrXesdH +SxRe6sc3DmiFRrYZsaOjTJYYepmJSLN1fAttAKcfhb79W7Xsa5h+YABAFqCqz0lojhS7kk+xixdNP1LEQLWjcl5f2zb0AZoBmMu9GHwxyOpPb6EwXENnJf1w +n/uliKViCqHaXGrFgbmVbRKFjA/Xd6LbTnayqhMYV3kiak1s3hF9fgWDSrCiYpyGwjWpkKPyeD7bUgJi3FFd86hy3siEWuUMlIVAyZl9QRkcER7JzVPDgmig +pGbqgrjoO2qW9n4ar3yBRMege+aMOvL0JqBLeB2E83KKXqR+uea/YYzUc4WmL/iNHDGOmjJ3yaJR+MOIEI5TWeKhH6fjkWr1FqqmytMeAmrsEPhDPD/FDdfL +t0Vezj0tHOomkuiRFOzSCkIkgpg+ibqnrJ8H2TE4isoVYH30iiaBVILfOnRGUxXqVDM9xGoxzNugnBqY5kWtUjPAHMQTJx9R85j6h7SVTLX39s+QTOWUvKcc +sSfQfajz8xFOBu3GT/8Pi98QGD2Phihgy5yAyjtc5BnTJw7+KKlELjMtfYeHIiuvm2Zva0D/9s+z/XIvXzs7HkS+31rXhzVhKYX04xxjDFGTF/AtJ6TED8jo +9POzxLFtT/lQRfgvnvScyP9ZbhkiOivhyR5jF6+pV8dnMJqUWhXnbXt6rJVFhl7xiYSVI4EpIgHJfj5ut6c8qGFzckoxhpnZLqkEKKVU0omfjLoFux42YKJ1 +DjfDkGtNOb3YO2ePpKJuQBAj5WOQGRljja/zmU8Ph+l2lCKzJpJB3xWFtBlydIv+YF/XgrPvao5xSpNiu8OTLESSnQVsU/i/g1nZO9IyLAsiNe8PNNsidpru +kWOScALDpagc+AnVYfnYQ+vX6Jt09JzuIEtzx4hn8Hd0PerTpLT4tiVv736HHksWNXVpZ4S2xXAz0ZeHT42vQx+RGnxnqH6Ycl2+dkE9+XsN1IM5/ViEsTsV +fyI0PRkD1X52X7OIZJ69zAoUTK13DxqeV6VULlMriUn7YhGP/m0Ep+M11r25kb8018DJIeWXqLwuZHwfr3mM43162YO6bxmpgpFfJC5E7v8G1/FUmwoUIUQo +Ygti8QOYMD2P37//RQjbSE39CoBczoZGrEV4ctXOkAyYveILzThruv6IybI19s3TAaM4BiVteX3hujCFvmZsGFJZAw8UrydIZdUAqdH1TpxWLuXpwoEMEv/S +hWGvcZl1GmResHwP1gdi5L2Vc6WL1dTzQgcDoPmw1TX8TN4GhL85NG1b5PbK5206W/iZKEG0GuPftwrB+g7ZQHD74/br0X0TrmWKHiBw3ep5wzcw8efruFdu +Dfe2UbTW8anZmUtoHcGNvRfDwsVeWhdaDBoQ2TUhzgE8HMXBwN2dbKn0FYmvyAntm/60P6pyynRc1yPRiVF5vr7+BEPHdOIJer203utgmGEVIXWFl+OeE9jW +pdwpRjs5qY99+6Tu6fUgz/n8x7GcOW9HWe6k0A7OdxJ2U6EjySaauCoXhZQwSV4ZsQHgW+uLloytYwm1wfAxbDrt5A0HaQEAAdsBb5+r+gt1b6uHcFCpca2H +6Koewn0nr5YAl0ANw8ZToaJe4LxOuTmpXBn9KZPw05PutYU4xfopE2alTOUaoKgTNqfQd32MCo+Fml1kPVg9xaRjaV34gXCmi0Sc+lOkAcrmVJqHGoQ7zWtr +W4mkCzUfTTerCUMI4jRUrxCSlvkA03oyQai5GySMBBJI4HYtAxXhZ/4hFucp1rLcEn92RtimDD3py5RK8U8O/BT7s0hakO+1MofbhYC/r4vjGkECGwrz1Wze +KjiSnP5QXBlEYkZySkRKW2EcHKJJw2n1iV1w3eke3PmAIrbcjgk+nc2V+ZIBICe2OTlnEwICkyY2yxL6uxmgVM8y+a8Eg8OAeExPfBc/C58k0eFD98gWglhh +5PKtcBOgWaz/o7cryPKFCyXsgh6MIPJ2ARSYXhwZPMItIL/cL5+BcN723iNh+rYkdfOfsTAC3C7tC1gukDEr7YLuXDwOwCL7prxIZOKa+VF2TsfAXLSN5a3R +2j+986f6vlrXo1WI4Eu3HBNakvtP0cheKj63OePlnREtGZ2LkpU84yi90n98EHfbiR4irG70MB969pU2SKePxQ2YN1FSaDdP8VVwFoXJ2ZtNOB9lB34qcDsE +6ZtqE3BxCX+uQVhPOAoVfZeNvHISip2y4aGyusDTFbQMNHmYx2ZZIKizGruZegVBicdcB3K2UMSKQ8H+RNlEhQpNRu4q24U27rZLSgtAr+DU6/CrMvg0D5bu +4n7cQ2kJIYPptqRmwycKdf+pUSPciU1x8nO105d7DHPZ8NGeNicDeQzOefSlpzFL5c7i+grGxlFy7GoZAa/X+Js78ATy684Q8pFk/XZxnsqKpzkLWhIQ6D1t +f+T0I0HCkh51S9/s2t1FJsDqUOTOlx9PV7T9TYQmZpLjZHpunsNzdAw3Z5iOFhuRwCktCaIsu82tLfS4CM9/zxqrP7dLZ2sJCTSliTJhkhXMZuP5tsdLQKsa +PlgKc4bhTehVWTImsVIaRcdVyuThx+uOsEmQ4KD4W+wJg4O83NCkUgWZKRHdDx3IwsGpZ2keBXz8yqE60M2IPhQMaPK14bpzpgu7b1Jy+cPG5+4b9VkSFzVj +IO++IQmhxpqsG+VNYBJtiDicsIclxOfD7JYQp0WhdJS0C3Vt0A/33KNRfDD7OPG2IWuqE+3ncZVRzrFwXwOfCyRXeFMqXOQQHS1HGApFFCRKvjPvqKupD0pp +C6ZoDbL3ofBS2VkjIIe8bpLTlWwZY2bFV2als0W/mqZ6VDNeJ+jHEpNObP+qcEGP6EUo7y1C2kJhaazveL+kYkwxqkQgfyezjmnLhw+5NxPkKDsrofyiEpLm +uSznnfHo7Q/5umV27INcSdoJzfelQcOTSbMNiXTLb00YP/capiO3l8F9myROV+XQcixpO4Z52EQ8KmOr1qdlP4aOocg/t5RRxzyw85uJkjyZQSYn2w8ZoYWq +sHmj5cutMx2Bjm90qx325lKJkU/xekBQ+rlfV6KLtNmcWn5OHZ5lFbix7562X/6kMm81iOEDjdPHJcnWkrREIHUQOIhS3K7PLlqGP602+YipPan8HIBkuKt4 +4Fw8AUB+mqnfqm3fX8DqPcUFP4S+6/D9rPCK3PNJc4OtsXXGzyDMgjoNADgjm0pjikyfkiNokfIkoN8NR8Rcj0JLEqRSgqXIcpaUn1ZmT4PX/wPzi+x+PC69 +yNpHb7JpJaorB1I2rpWyHLMmNjvHg2mRhI+tsbzHP/7RitwxboPTEMhfaKXgxAzjvD+HI5fG1otkfc8CU0tcrGGmmgsfYuCFr9KDRDysnbwWEW8PtTaQMweN +4Pi5gBYqOZdxOQVzEdAXo9q2VXK4DIjNQGXAoBE2sR4RSHpGg1+Hppdl/I89TC4adAN6HUb/V+qLhUW0Ji2dyKP/FKCjZ0HlwIC6OUdP4kvaWJ4bT3vybym5 +evUmRWIFr79KwlyHF34JYEUjT2Edyg6VFYCKGeSNlPEiUGRLtS4nnYS3saXp2LPYEVfj7plACXmG3fhHXDKyQ8H+b5XfeFQoiWTadpI9r8lIKBa7iej+QoKC +Jz4jddIpjGhliMXyxtg8U/89Ss1ur7b23cjDPBwQ3yFo7qCSUPYiSfbK8pbcmYDpC12NocBKO1thVOPfGC0ywiLzcDSP+3OcwhHBg/7HwlAmX+YSDrp7s7xi ++e4XLkSX8QpOgzIM5FlKY30wZ+u1OTT+dUa+IbEC47VFJOO3YzCtDXIs7NzXl7GSVXkn/sdzID9jTaEWLKylZDZfcG5eGe7k132PcMeK3OKP65HBpmlu8WmX +h/OU3t8+L3W+vprc+uP1w7AR08xpHlIK1PcTk2eyZzQQ9PYSkg724kMnB5fi1N/b5mKEl8hWJvyFO3x3jFSf+o8eJbt9niCMhbFr4SndfaR+cgxXSIAAboAv +3zHYJxpjHIcPcNvHwCE+cCU5hDkskjD0zpKhA4wrWDLRXfoz5ptw98SAFENsaqN2cXUC0QWR6A7PqQyP8tmnZ1ZFEyPsLm2uud7ODpDn8rbdFclW9uGl1KMe +WspnDVRh2547w+OWK3JTn/SHkGvhmhDv76lekhPbwTrEX48+fA5F48DMgrv1HIBf0B8KzESC1Bh7X3wJGzCNnpPIOHEglwscA7P+GCMEPcbU4/qHaXz7odA4 +EooEfC22h5Mv5gtcQYDWjdbwQu4Bz4clJLCSR+eDSogU2tk1/D4aeJqpR+rDQk7jhjvTbl/ctQQswTkZhqY78gnGbaAXrKJl1VLl+LgTknSaB8dAcQ7Fm/O1 +GxDLZ6YUV9ASCrNU5l1r9zK/LIiItZZRLuP03pWBUsFJsyjD1R97LhhaTf0VwbSNSbS9V7vayK+PxV8qq5DrFJtoLULfi15qkfNqTOFm97ocpR5vbQg3fmjM +NgoRUxfpRd6lAElKUiUSsMfo+yikqYo6LreG1xe9rYz5BzJtHj8ajN8by43EsIncXAwg+S4gFSiJ6jTFgstYU5Ff2a2nn3uXSpPTg1qdvrTJe4UH4Z07gVw7 +xiXoOwvOWN8+/Dcs0xKAm5F2kI/9MvCW27ny6EbtVOoJ/56/vYYpnnbb4QP6ThekXIy8rZ/iiZZKYnJNSgQ9RuHSUOx/D23bdtMioYgYoj3fsHa3WhLg9BJ8 +n6Ak0ym1jKQLYEuTYZVomYQ98zCcJq1tLEdoWNF/K9+UFdPr6kGwmALlP3LQFMCsAkS3tNPSABsM2CHLtQt3woIomItdh+GVJs+PgF5XSMG1Ox5v/j1d0RnG +ZI9xfes4kR6bTRMPzhR0rBHLmPwiZ+z0d14ydKxT7HObCD/QAIH0T+RKWNSZz8Ek+wEfPGI3BjMtpN6UpZpiX4vCB5by2CkFdLQEz27evf57Rlxd+iJu/H4K +Rn1d/kOS6euOBJdGTU+1fVOuo3RLx6+Kqr7QqlNLz/cRunWveyQlHsuWKVd9c9zmRn7sbHcGBptnawisayI/ZxZ9nHINOo6MuhvXn/wxE7r4j62I/LAIrnfk +/8nCYLNg9vfXqTsODePKcQ9FKDuJWeCUKzCZ0DSLcRywok/8kltYlkGrcYrbyJ+CB7PdkBnowBaMhRkR0/e1rEeHhk/x4OT7+zJs+t/275gxkDqy9TuB43n5 +9MXV3/kr7/FClDfkl80X+Vb6bpUPPq6/3IbMVLWz+MD97VfvwSuPZjpe9lzHchr779r/lF10ij5tasLPls/8rzg9tFsr4qCCZIqlCRsReNZLywRSNSYwVhqz +bNot0eX+rDKWAmKgTNXeciIUB2pzo/9whz8zuUnGFE2gpxTp9Fe4Skoki7yumcbSc/z58IHF2dLHmqWMsqYG+QqstfWL0GYy0qifKLCNjQKo6CQAgunvLTGw +36abuvJrkax0+z2IWoanOJGCCFGzNQFSGoeZ+U3eaNMzvVBfPg4JcYiXz1F/ee9b2NasYKKH3BBJYQHtnbtdJhtWNhlVvjDuF18JrhInK/nUejPISwReIHh7 +OtRAFPh4mq3kS1Bkg4Xbnl3PbxNY/b7OYRH2ADcmqgbl3BZepyF7vSCNPXPWOBfFhH2b0lR+izBr1bytWl8WMc69WN/4pmbxJrEOtwKDJT5QBGCX3YJ+Thkj +AtPlNJZJkX5E/oVS7P5Vl38r8B683FLaP9nSDGVux+zNVr6fPQLzZ4rOuGXfdCZMlVPgrIbkV6kgYuSVuHowUWEkU9AC9enQOBmUSPot/q6iJiOwT2UPS+EG +b+N+4zuRiCNh8CldXLgk13Hn0X8nj46XI0rHOL5GjeBoXvoWUvPeMux8AW97iIhy8zP1YzReG0uqjkyUfoevOWsoM2DtjlrG3ORPw0JAjg7lEro+8UlQVLvy +t7YxOayCTal5t5ZeTWBDnuekwm0jGzSL+91Mg8xmGH0XGWvrxkKfacW7u874aI45YhEDSX7rhwSy54Hn1MQOwjDdte+1Yc6oyJpRDW14EYM0yiGeSGAGyNNK +j+emor201YWXKs8pt4yjXTE3wBx2H2NCSU5G++7pdZKG5F4pn8umjnFVrb7JEkRen0L2fd/NDTOjbR+qn7t4u/5a2g5A5HBtszToMZEdT0RqvlbzzKrBxllB +f/49CIbHrY6ydmaIZaCuKl3C111f6yzHuybDOyh2M0kanrbux5aSfIAN3FGs5mgTqO1YwYId4by9rfuI7vj3TYlIkG1fBYic/J29f196Tn/EqFSZCJbUmU7N +gSmIehUq5ZEVrtwqQcsoZZQMMUEk3LA5bBFM52FtmHGiSBc06xMOY8KWYJDqOVAdVLCVt8vl2pWQ6bspoSnVh0o3xv5njiDe4jtsFqsV8GftXhuvvMAkSHLh +3JQHXs3eDP5uveIsZx8ypdFWDP5vb+jvkGHgu5HX46YJgLfGXaHVkckH39082raBYSBNRpUMfhkNnq7Zoin3Pi6NH2YgNxid4evsY1+/8uFfN6VFiHOXfNIR +A9wePAspqcaif+1iLjhpEn8Lz2EcErMvQ3xkVC8FK1SkqJ+ooduDF2qZM2zaxYtmEuEH7miKinvxKFVTU0MnEcuBFqooTXB5oQAqLL72trhKfYqk5jCXJxc4 +y8q84Z9EgVNMTxLB2Pj3CY5w3GKWQ81AoCEg5gklI96BACU0PDpQTP0XTQRCgbRopN/+eYvayZmUQpHirbIdZqdtDhVSY9H6qYZAMGwGk2RtZBlc6QHyTJvL +GIdmLDzrK9cCKyR3jaVkvVJm477ZaMpclywjFzeV6KafhZSdjuXY3jJg+v2qwIitaooek9D2mCIX4dPRRJguCXHWG5gsLur0Ngr7zltP17hU6ZDdkYqtoDi5 +q5sxdSfMrDo2kskW736RMo8rQDn9pcoQ2a6+eKyQ2nF2s89pONcGF8OPjYVxD0uCkJ0jNjPTKGi4sPkIvVVphRVPY+fpvElIVKDErgROILQ2xmnFsePLG+6W +u5TU9qKENboO7qpLUVHdqI7obWsozrs7KV3fzBrbrO/MUHKdaJC5VOWhbJ3pvsx8v3EuLLk2xLyziMwli+/nJJONBqfCYz5W80FY2V6lVdEBPG6P5zep77Fs +2CNY5MNOcz6AyAt3xacRzKviVVAsJuBs1g4qDZd1OvZiaN7qouTV84WvcVmd+FZxx7x/I7lYsubnvozde/qSM6PppTV2Q3y0v9v1AYXiSkI/cDlfk0Myi+L3 +uCtPHoE3UnJG/9/UT2/ldeaQywW3Weia/4Z9BO9jYmNKi22m/2rudoIzA3imkLWT6t9jmh79VnzR9LmKZp+RZeNPyYLnPdYjX8IXd+jBsg4REPRX7HbxHK9V +IJWkmhba4EiL9L9PmpClO2tubcqoqXQdQdJo8qSEKb12fr7UNXL9mTkfQ0VWSPCI1t6ZqzGTpmYlXq6tPeCGEovcEoghElfaduAerXJKC2BuSz3ZYMOUF3WS +uC50Cyn6C1k/OI7zea9bgy2z5s7Tb/h2tcbAOJAuwdZX11BHbfmTnbnUMklr3qEfYDEYH5MfZmnooLLkcP6C0hRjs90IlyPBlCA2nqCr4T0GaF1qxgv8aN8j +Irqf3+dYZ0WdOg6SQVEzAh6mtPId0zOBSwSUZGDuIXpgxgMKXd+Qyzp1kMCsV9InZLMEKdJx3Vf73KzlFVNekaeDX5e1yZqx5cUSijE2ojTyo7YjRAxJNQ6Y +x1T6RWF3yWnBqEUguiHV+p+GpGPGrb+essas7SZ6+exv+N9o/Zy44SbYAjvcTNceRGUO4R4sboXJyEC7aqydDqTxF44yfcidZrizFb9z/v4GR+LMvwvb6I5A +LpwDoePdObNGHKmgsCvpPCEXGlM09m3eKR/AfWbpN7ii34GCbV5LiwF5fj5eOeRLmSr8Lm+Jvl5vhTkjwd/dAnJ3DzzE9MhkBHgxL5TdlO29+hKhkitkBK36 +oNoOZqrLwKcoP4n0WBJbuyOcxeeCJD9SlN0qKhX3ZY5UkH7xs/l3zE7eLE2bNwTr9/RwL0zXMGvFooucFwZuvh+52AJuEzoGttDv0MDPRL4RFBhsQGkZydRL +4dB32t19+MKdXR4ZfxbTWeQL573IOMIFRK6lHlwXjeeOJ3at1n8Qo6V9O/1nZHeOdBl45qLb2OMmqqrRL1uS5C2mfCix3scOpxxIR3Zkl8UMvgM3i7EcA9uU +VH18tuLwDvvwVmkvYy0Pav17bjPwtIdLyy2sQjhWtwny2rCjV/yb7rWcJOTPCa/oKHb6V6Kii40/qmItzHTwMvvIcTRLMvlWuVl//r9WbpkH8xAugeodirc4 +d2WsAJ4iRQvfL3/8+uBHZEa2CNTPphTLrLrwV62eH8YijnxQJfR40pya+K71j/NN3CLn3HZhG78bNucNXXUK3/ti0U74NbtogBiFVXQeDsvTm4I6uCneMFPp +rSLpZJfxsUBCxqnjpQTdl+NxQInAk5EmoqPhyPzfib3YU48uashzBXED4qhopyUfw1MXOIT4Y1bM9T2EJjRrKDFfanryXNYaAsKQTFzkCZrgtn3fc7zhQcOA +XrUdUaPhpKZmd9V528EtFmW40KRZAzOy5yuMX4Ee0SbI6pUSTivph18nX61XhkRpNa/fPWj7cQEayODL5TvW7oPjJYEZLKaMkZ/UJFDrP9etFYUD/R/dTqP1 +1Cg0G7NUNlosvpLcoKVa806JeTDPfCp16o80mZeC5ptsKaDYeb1LYSg4w8q3lEczwXdNDN0FacQ8hzjMUvz50OP39P2fmycW5ooohXuEDRYLkSUOY8kS6d9C +OnrCumqL+oOLM+a7Tl+Pq8gLLbmpRa0QS39y0khoexfxO3bmkRCgcQsJHhn53d3evkwi2hKbLSO1Fj7QcqJTyllKIW3c8MfYBFruvGKn2i0LZ8b+rqtLfawl +suKJ8QS/QzowgM8ZonERN06P+6EQqg2N0MamXU0+8jBzP3fUqOoEuNPWXFLXpbQCx4OxCL1NtWlIlBagGvOUYHiPlH4ehv1RbCSm58Fd+T6QW5P7Y2Bb0LTu +0GE1xui893j0YY2Dq8w3QBK37KOuvsvpTfbsl+xMhqiq42nZSMemHOihpivVuLIqsmKuwomAkeX/gtbKtPQgQVmkspQyWiGo7bj3cj8KoG5X+HHRqCFW4KrR +korlsbLeSwk+5Lc92Uf8z44D4soEfeAnvx2o29siL9Ct1yXLLb8jzKabk3grL2zWxLOKs3ULlIMVU34FJIklaXKr7GLi2pVWd4CbACAKtIF3JGdORCMH+4ZY +X3jqsWFo0DJSewak4hWau4pps6+0ibIm8ngP+vAAvT4qu75cPIa7YQaGPdXkjr1rlEkGEb4bmJxeGR4sJ+ropF0+B4K1n3esD4YGdLaQQwcfijGjj5OCPR4q +JJj4VbkjsNiw27gE0uZCqBjI06p7kwaUQ9MaCm0oNx8eZEr7jL43cUBIJLCFWF/17Ha9nnWE1xFry3Y5tiWzakIDtgH3XPJSY72QAsADmQ95Ra7BWwM/llzA +C0OPuqaiuCBsvWoifGry+VraxmgnWD/WtuNzktptu3LNhO178db7WKbPDj7JXKy8ympOZbFwf3S2VbhURb1BUsOVGx16gq7KiBv3BFou5rOUrsJaC3fae4Yn +xe6gzGMyaZEtmZ9+B3NRrRYhy1AqY0YN5eTVt4rhKjc9iSzL5F3N/DuizSL6oILytGK2ZTjKLjF/pkEuNbELWOvxs/hlcB2VAhuAvxjmTg7AKQdlOOCU5v9u +3r9/PXjTXld1tymqg+cva6CcwDO8fZSkKGa+XUjKpxmlu6HyZSCbk7BA7JVggPmH8RPLcPHJ2+hZxvOMkrpn19V9q/T5r8mGK0P01l5Uzgc6cXJRY3QhVOvK +zGBhJkVWAWqJVAx3Q+kR0rEZ53SHiSRC6ENufa9hu2wElLOinHDPo3SJAkru86ktu317Rzm5hk1U5iYZEFhXMmRPEdBv2Cfd0dteCq/gL78/VqP+Cto85nk1 +CfLQ7nD38N4UWmEyn3kE9cNW8Bnf/6eHxQOpnEXJbSmEqdfQM33TWfKIz4ttZCVTQZQoPS4Ocz8/epzSdJRdGfCwqRWE3vNzeItMdOU+BClZzNzW6Ux2BmyX +AlZiBuNMrpBjzcrZgtdF8VomBWW9VNm3VWuUIdG1JEiW9T+snX2plpFM7+YAzers2zuN+/LnT/8ypidY78UnpqBldK0U1vb9HTAYxwgdDd1v9Xvqqd7O+++5 +WbAQk9U59hayUHeFyYNnzZmujrfXsNI+ewqzXjmmLLKrvIbPioyyOFcvye/OtCBwmGOoYXM0o1aPouigPEx1kFM+lqmtCSspDfL9pTXnSP+RDnJbSJ6LtJKz +8NkTyJ4+LyA8SyflY2syubpCIHtwfihq7tr3UXWlklBbdZGfno2O6cN6GoX1+fxJ3uMSWQN/KmVt5kGUgV4o2+7QssAFTZKLSBRx0CXfeYf4cWywoUYH1sNI +U5ATgxn9p968RnvbzIzyMwXpiS4YrvBtihxtIjgMJsbzJ3prEWrADNale7FoK8ZNmy5EWkdtvS7TgwmULCiW8EYoVNe/I4jsy9EC1BhgaknrziF8lCfZK3+M +LCEMtTNfQDuk7/9pMD8IQs5Lp4PGcCbc9S4PxzB1QmEhLJAzV7EHwwFgTxBD1Yus+WpuO99EpGl58oRRjUDJ0ihWmq/0xuZVN3BlIigzy9PoRnCKmxT/Y/6Z +nictzwdQkyBd9G8tckIe/rlgtFXeagHmzfPTH/AVjCp/CFcnUj9kXhixHJt/YUm/APBhR7LTnMX7mhkCazofBCwAfZFo1A3yvmeNS5tRnXhU/2L5zeyPwu/P +3Ao1v7lsce9CTx3CM6m4fhOjIdqOiZvzkn3+NcOn4X42mYWBmEbRaK+RxbxolBSgvbgZq9lwYvulmQKHuTBzcM6tJJiwh0aVOCCXmjSlHIjxzwk5foLF67z6 +kSRnAgEoiMfL8V9FkkTDpy2jrU2G+u1kVind2/ydT3xo7eIPFcsKTlUmxaIxiRjPSuGRU6KAFH9aIsxLHBfq5vqmcnGT/BTz90h/qIsnQnSrZfApbB2j1Q/7 +nkpFTockzjz5WbmC/eM6+8xfkGRBWSrYbcz4y3IvmYpCTEEpNOigkyklxIxGqw5k9DpXa4Klhplo6NNV2bCXKCyOyEY/uah1M/eyUuOq8n4JO6ZGc/1/390S +Rz/HujJJX62x8OUr2bE36IC4c8InevLDNvNIJMNd+oFv/n6fn3YLLRp/A3JpS4jgBKMLEJTSRS+IZafrombac+cufO5+o9rS8Ppsm01I2KWOKM7ITWab8Del +V1k1bPCNpAzCzKrW7Cw0ctAcsx8Jb+XvRYkrVS7NRSsgcYXKYVPekwe/uvEUnGXdwhIeU8Dwqpc1JWmf45JPbOz9IInmPFA3KG1Pfs3kvzfnfEdIwhrO+o7I +1BbyX7hKTas96Mnm8Pfj3YIyqSeqWl+0fLVkIKQJshUE/dpx/ProVQ67aYYCd3wT/7s6Ne8uOcaVC6c1IT1l0GaMqC9jWci5319JwS4czqMQfpIXu5kVz5WU +L00VfwqLc9AAyR4fzbn1X7CMgGSvbmzJqF79Vr/6TRE9TMnh4W+D3SCGKkU/idGFTqYUrD4crGb5cnNI9QxvGmHvfqp+ZRuTR4X4cEBSwxw9NBVT6SMgMzFp +7RX+IK0fldCsy9O6w0WQwB7Fkovl1szB6yPUW60FJrtrNPh/f+nwfcUUEYRlGiNW2tI8AEyPDzrM4aRf+yqBAp8M/3DVBZ7BP5+VwMjExRmQopVkiC3qSprY +D6Y8wrndgdDguA6RbxBGwyLEe68K15rzpIvIvRbrGZ2xB8N39ZQ4E8v99cRF7U+OrRe1tZJU4b6ZBeCXnez7jpyOzfUOxygT6yJv1UVSxkqoRklWtZcDyThf +HR8f/X061+2OxO6M9rQTwKQWPbCBmcseNQIqKc/iBTzFM7q5u/mvQh/ZzGluawJd0KzAaAxrdp3fvLuThbfoNfNCk2UReeq47BKw55Jar3i0iE6ZOfefqAdV +pISKZ1juwcETw809viKagU0MuyVmn2OBb1JGPx+45DwoOHm8iqBw5mc2LLvg9PyZn7nwuAT3Aj4IfFunpVoJhaRe6tKv1cmY2c1cfYrVoJXaX6sHjmgFFn9z +TWaO8PkmEnoAqY70z7qZxLUWCC5aG72AKVdDU1CUqUq0IS3pKAfZj3ITKcCEBf3b2tTnOm+qojeJ1y/eLlGSaXu3VnjzuZ8QFUUtIqQV5KxgVQehWxREvgwW +8K7ADQzpp6um7qOPonsz0LOaZhoW7d7O31WHsmAGpdy5mCY74ndXv1VenYRYN8HrNjdh/XF3AwJ6AAo6k9FJgDSnMmX+3zyDcQC9+6gy+WulPvdZR9Nc5q1h +Wdw7/Tzb2axlU+OoRB2FaH7RBoeKXlpjN9zOGS/ckET09YG0FEnRcWQ1kK4GWvR35Ov4ecZuLcP2PsaLIohTYGF2+bqgJeXsFbqy1VfyopSYViSjhJfSZKDg +aAwpnu+E437hFIabejonL8DinUTZS13v5HV6u/yW9M2WEu2BFO2PKfGkD7+k79eJ5OOyY17M3p2O5mCxfmxPj2+7oZXJ7BwsusooPF2jdPxK+5GcBQuMhwWK +U1Bliytt1hee/k8m1q/sgrYjw6nll021/sdMnPMynQX84u7zVQMjP0+LqwOl2n/tFWSpYpRYp9I23u3CBicO8TVLEiP5Y5vfKgnrZMRCtKuMP944lz5OdtJN ++NBQWgoELLvan3iYCN9wXaM3mmv0gqOqTJ83goZ5ygz48mHoU8U9iHSz4w/gNl8/7tlxrtAOx8Xv2eenfByvkqaZlQHlEbUMJYwcFJwO4znVtPABU2x2GvzX +GxQjnURshoyS0Wv8ZdhXMgLDufFWvnIKrRU5KfaoO3s89qDukiEC1twcjl6zNFKCn/Sy3kJXY01EXccvJMAZfkiE6tFoB6z/+xajUyzXnECTvnq8HC5ca/ae +GLai8vQC80zJk4p8UWaVLw3oVizn1K6B5j5fWbFZmBu/mySQ+Mc0+DglRcO4qZOSG+WLVdrf+2O/QAi05JOch9VZ7ji1sit3Uiu93+mOWeBP8l69QZePUycG +rqhKs70aikObgf+gu6JEPzlK1f8jTzOCPi2N4GzvXjmxCyNqm36s68Z00SDZBGkRFs4gCVLv+KN/JpfP65c70NklX+XmOk+XRUaspQ/cEEecpNQUkJTMzbkp +inb18MQ0Z+A/ls7z3NZPtdZa1bPRwn0P+3F36dONQyewZ4opJvhRaT2TWcyPe9PT6VcMfJX569y+v5t20sp38heik2PC4cVy6cZne/xO1xkUfIpd87eKX4AO +JsLmUkQ5POodLHZUvnwXOh2yaQl+pb+T8R4FlzLGo/AAyB3cxp0TzMwo5S8fXrTPE2GJlnCLFx3LaXLQfs7kj4nDy06p8viQmBOefuDbPmUdzXJaze87Ep/c +79o56+b/mdgLJ9/qf49BY+lfnYPYCD35G8nKdunpo97zyFYc7+GkFJ1sYQwJYjggF13UEWZaiIaO5Ym2CQArVvSSXVBs1Q4V2DX1w8OCjIl/IsLPsHNCJerw +Hm23IsTC4ke/HLvBZu3FGjidboimrxgLche9TQv5mm7IGK88acPT5u+v1Q/7/EDILHk63P1bRI7O/z9PSjbo2Uh2QqohNEHeysTWxIPq+pdKIVQGThT0UqRZ +j9X2TCuCpU50PbNFol+hvfSgKKyl83E+H5ccZe3YbYqi5xnEBfZqi38gDhFW5fWEFX8pw3yONEwBzsnrR6MPv0sq0MDxWze4Y94mf5CAvIQEfoF2jD0qware +zNrqEHTSqpqNe6+1qqEWasoqrx4WPQz3VrBf+TA3Vs3+sreIitq0i2FNNel5KMLG/+SJtH2xQVu4fYB0rJmpCzelBJbOkJ3HTy2dbHQPWci8ZBHc73AQgJFz +S9pcUmb6Weg/zOHy2+Fojf/tleWT10v641QduAgN/fH3iT5N73Ig2WoTsSFcet5asf4221ZVA8pzhWhFGp0z6Ch7/XtWC5H4YMecunUIf3xOM6G0dDh02/V/ +OEo1f4gXtsrJv9B/2x3/Z8t4WyLja/ah13gX0zBsu9qCC1wzmZizwbvG9/8ZNpF3t2bbyyqtS9G8jGpoLPdLytcN/H/aQG+wf8z33eAF2pfVD6eY0j9fVuKg +7OtrjFu5W1956CxC5VKhwZEQmuDlRV8x6YmMK9Y7YRgul/6tp/8tLj0tQKOTedVHISJfe/CMxB6FBAMfoEJ/He17JOtxo2mUaK0PyP+RPUdkZtzcg0dwwrDB +HCKWoOtMXLSqYGXeICJ0xaTI40jjCsEJgyg+XzzC0wp2mJjFGZJTEbcY2Ri/k778BWrB7NfMPS44cQSknmJedNwmI0A3Q8nrU/zzQu4oTGW7ChokxAEeXeCy +41fINEmaQ6+dszrawjepq75mBfGaWpZpDV0WgJ50qaH9VsfRiwCC9ihRBrgSrb3eFHGOFWfqCI0Y/lgwWMrhZBHgLj4LPoxKf1nKJxnnB3fGpcI/j0O+Si+p +jcmWJjuVXuS34gcp4NI1QEAga5csPWS1EYdLSP1NAYczNsBVMHc6uh65t0esofKTh8Q6PMYzawd1XEt3Dyj8skKRQp0m5siS19LAi1UaC0bb7bjjajMpXHJJ +AZncvHkt2OdIQIWk0FsT67iZpHFUeQefK2icDNspJ73lwPdgHW/liqnKyvLMcuVoUc/Ab/tOrk6foAlldfm/KWlyBy544oxMpNcNK4eTU2Ff3UK1RW1MBuXE +1ZCr/Xac4zwY0myGSwoEGz1tU0KykDLgAU2/PKhrNOZmnXND5d4YnUDdWKFzS9fGeRKH0YEgQ8V87ozDDTeP7XYRC0FaXi5iOxpHsjJavtEPAP96cWWTwe53 +uhZHxwLM27+5d8EkhToTt/4YEQAaHyPluGjOz1qeQ8yZRGG5nTYNTy8ad4jM+MH5zfvxutNyJRRoZ/qow84fmkBMKRtUFDvElRU0Dw/ZzCwAWpJzwzq//UU+ +zfBF6vjhehVLN1XLpsGhmoOK/AhnerirVhJEPipBd5Vo6idvmg1EM1/m1lUY3ok5/WlfWDHLUkb370MZ6gnLNOeB5RZy5FcS+pX0Epi3V11jS0YTGw7RMZwq +eZPDUEna8VKT4JWM3y4FksM7/HhAOYS6YzlStmKB4jXKHTLGaRNlvqPypU44a8pKGKjyqYZVXzGtNfPHIeCMOzomSCwlvNIkUIqgwQ6iifUiaOeQAS0hzSnx +vSJGZj8gsCPxSHTnvg2Qos260iip6rHW0shhmidJLzwxIMVEl5mtDNehUJoywY9tViGux6SeyAe60qSyI3T2RYNOtDcV8u/X0U0DDj6VEL3QhMn4Snh+hGON +4Si9DMcxnmhxXywRZ6DLis90PZMArHEHIEz/44bKbuHqssZUszBF/11BZ+bimnKaTPbiXbFk2RPoOi9zbpKtaNW1HNnk44k8Z1BzkCR3DCnhg+5XmZI2XAui +KD49R2v0SI/bqEaVwh4QBu4mMT5YY4cbdns4tRcV9tuX80sueJo9zrFB8GDSFBD5++5WUrzMyiJ0EIUY5Hg/VRsbAH9Dgz2SdZbyPENeON843xDKPqAAg8tm +AT+8TbxIJ1a4S5eU2QLg7kbmdCldLfH8UOyIaIeutC8w02k2TYDsLorZRXnOoZxtzPQ/T8nKT0igBpIGo4TpNrrB+y8RU/AcnjefPoFsUEeEyvMAtPMV2xGb +L7uWshpHY4kOEzC9kC8f0C7dWwKXF6IHYtvlux2r3DpmdzWUaEbbBeWAmFNRkCV/6TbOWTF8BuFP07kNx07lc9eeykBj4PVGOP/yYCrKP47dbFT45LjeMAKf +ypbAKluiYWrzoO0sEhcu7TFmM57GLsngeA7phAJlyYhdOgX07Re+3fcLr4JwqxEP+q9Hv/v+yvc/d+srTypoUCpejhxHhajIv/Sx4/043WvRbw0S5FFYWHWe +Z0U4kfcJEPggxc0f1OKhf3U6kvZUMgBgCV/VfCiPqQSHOx4MRySzlJJ+76JmHJDUyuufPAg2cDkGSXY+vilI14tBjq6bK28lpBihlssmXa4Cq3d1BU34joJZ +aeB56iIeOIR/gNf1Rl6zSpzvYtkmSkXrCKl4jzPNblsWAuGSxjdFh1bZ5SMZHNz79Xfni82SJBAQXTRUFmjZ0koqCoheMDdseX7S9o+w0a8QMpMsOOyg40SP +fCUd74WMJ3Wi4jTatHyJsRlTZlxMsyqgj7lr1tmlXyCNTcek+7tAd7XywAfDM47wyYDRaufNQbrO77UbiFu6znLy8Q20XUkxoXDVatHeIVfYvlNwlllLFJm/ +Q4TCrvjlG9K6G44DO6ibaHF6e9XTTtksdtvFWECCCALhM/7fuKnaTKWL2YTCnc9Ur+XWo0bOHd/heeI00U7gsNafJS88PYFze1dRmhOFF30Kz1XhaDsIl3Xq +2iL/uLg8r/Mnrnt3t8lusz1GPFUnZ9fj5VgZ0efzmjRLmyd0V47qWGvZy6S8xBpWvcbUqYuawabwMwIjqvkLORGBWWKMzjWr+GCgBF0dIH8BWRSkhQBvvccu +WBarQu4e4SrRnE6lFqlUA1NoJfsk9Uowqjf5fRknP9qIsYdjxm7T0DpULkF3qZMnhVaetBbXAdB+oi+pnTWjp19ji9WDAOYQH3zRR1yKLwpjecbL0kDp7nb8 +ZXPRxYDTkBeIlJx74Y0ZIFsbJFqLYo6RBKbPyaFIL7rRJUjX7pbJ+LezRaf1YRySDMqTyWXV6HwsTz5lwMDoiy25nWN1uUS7Kljg9b+tZCXysDF+AstMMmOM +yxz1UfIlKPte0tepAr9bRPxqMgKJGlPp8SEMlyUKXDdeP5fvJNpsgwWz3LZEMZVBv4oNh+EyicQwH2PsH5z482yJ3A298xNlit1TZQ9iBGRihLw3oAs+r4rH +aLExbFdRHxxvUcKs4i29+QNLWXMtR1jKspGHV0VUq2z47TVtK9QnfgtIxbFVbOzKxWLrOGlM85Ex4aNsiYnOHmCVJ82QKq06KUmyjBkVMJbHk6UtsCQXXMEg +Pnju0L+Mw3rXMHaUN5yMs51C+W3GbCK23sn3+CM98EP+1G8+nx72gAmApxZrgaUFnzTHpVaFGt69t8YtZDDIfBgPxdr1quL4rcSh8tn5EFzfKbXC58lOWHoe +BUqMNmOgZLnyqS/2GsUgRXjAk+9+BTeYr4CSxmPiRpTq1VfD2/At2J4a2eOwYtinDzEVCzFHENt9tm3TVZm6wNDFtLc/6g+f9cNT98GjfQ2zOeTDm38c9yNK +uKyJd6NrKyfZcmY/bmSmMSIsSLcUfNKbA94fPztEq7z0w10w7uzo5CrJNTRspYfs3DsS3C6ZgPiRqRT0CsWrQGFLg+tYe5+ORMmKdzGQgVM1QV6SccoEpejb +NFuHF/mXe6a5Q9Im1qbQ/ksyUwW7P2JVQ8tRWI2PJ4tyZ1RZG24sjsIpzhzF5V6ItsUzJU0uB2Rli2/U40SxLIX7qMnMDvZQKmtsPGx45R7MmfTMVTT1uT3M +UyCqWJW8xdNFr7x9hIw/B3w++HFUHm78oznSmvdzKAy78PXJsVjkvM3AzeTi92D2tBEjlO+H5i/uv/8Kqhyz2lCi5HhWsmpGXKOn6eGNG7qPOHdw8huilZlJ +KLb3bUBNEWN8I3G8y1izcMTHtbi30gTXRRR3dRigAU/tQO7OsnKy54XsIYU7iq3GkBVS0pYLqPxm2PbEpqVOmTzMkUSdmrBqwXEiVAnaMX6op2ZtBR/Plxh+ +7bnkHPybJxtnj48f5rfwDWT8jOR57iQhNqia5SuaL6Jp+1uPoKjaPTNLAlYZ6vLZr24VJLgpDQyAjd0xetxyziTWvczuWyke8XR0RaU9jpSgnhadWfQW/2TH +3MhtbL1tLL5t5aqfpxhsLywvh73Bc0PPwCLe4ey4a88pbDo3a5sQsVmo2VTAuoUHmVNvP4Pcw9R+r5Hz47CG+6u9V71nT+m7X/ypFd79wqq7x7czuC/Ufh7P +RDxO1NZccloVELo6te5LGVn8fu949/rnJM3lAb2sK3MxBUljExiY8aIVt/g9jFGc6wqwsxUaDyhLnpCk5iMyXyVoMXHVNL5bjJ2iaNnYeS9/BI12W0lhVki2 +dIJsPMMxoptYXlhGxjuNLPYwX5IIh+ijMkx8Qx0EUNA3kInFaGAN5vcPrRVfwbKk7OEZlCxcjrzwV6u40mikbsedNaHnOx/9ETt0jmSK9GbodtFeD1EwsF65 +xE3XMT+kUaTY8UaEJU0f4417AgG3x12hzSeA0v9ZVCL7lUt9zCO+x6fRzW/jmjeEqZ3i1z2dzfS7NrOSr1SUk54POtzU6zcZdnZrmE9Z52pf099cDOqk28cL +idcyN0hPUjSDJVRAWsLZESIpakqHDdY4PcGqyNP7HSmdbbk68xYC0HFHGUQxI28qeY5E1ruKofpN69Agw4TOR7xfE01ZMCRO0lW4T3NyWWSYoL7h/qBORBn2 +mvcNfODHc085DyBj+yWtjF0cpOz+olVEZmUoWY+shy+cZ10FKARy27tDniY7QGrH8R2OJmAeNtgp39lDVjHtsfTNJ53HjDv1N8wFB4qAlSaou1l4h1SGNUDL +2FV5XzkSPq4IFgX3zvfoYV9ZJJz2kYs7C8OY+rCN4Sj6H1ESrFjZvPU1eCTNL2GREFASlveAGcyJceZwr+56nAKFBPssePe24+uTpk2X2krl7TJtlHF0Z7fK +XzU2NdHHJogUfHY0x7dSe8xaJOSl3BFFuY6DbFFuTS81AFwZu2R3ZTo04sE8rmhcv3bLm64mVmM8vKwSMeR67ry6/Z8JMbPsfWE+qR/jizMTHta7rId4QQby +3HOz3fLqlOA3NuQ/XG8ngyWKHsn3uii/AxMfvJHJ8Vulgv9mEfuswoEseiGz2t1ccX0PJHoYdqLhJ/lKQpetqRXB7w4acJlokzLO47Ywkc9KQvB5Krxcuz0/ +xU5hleR3dS7mXwH0nYyR18e9EXCBb2R/mk5Wtktj9I/8KxUKsr/LxBBkvOb1zXONd+q8Md84OGj9DfzW/cG/8lyH/wxsApa3vnqyoibVoo9ENz+kuur1sxKY +esFIWTyJu8enyq7lmwKZiVR6lsUvokcjQmuv2iY6SBqbmEG8RAqE/HS7OgzrrB1lKMjPX1J4f46IdTPnYIzDmyBfvhRLqJVUOBH9XXCf0kODuqWRy7vJ56oM +lvbOiRM1pDF2kcbzWXlNtlRN53PMgK+1FS2r7RdruizFzxPkcgUfkmBcMO0HFRvOUgM9Y+xaJtZzkWDxeZ5Pis6P1+R7QpjGIoP7OsppG+noXi/3u7Wd+wYi +n7ZeN6YTiDbN0LKCXph3q7ulnqH31EZhgs31vHHPt8/NquoYBO3kCPeVey//ObjJ6W0pRdPzg6rjQRsGDj/PWcJoJz/ZGr+aOyjOlbs1d4Nklhd6OvQskWFt +1YaI/DirG5Rsaf6ezC1eFqREkLP7QMyYwk0UxdSSXxNdrv/5+UeuwjJnKpHnJsm76gdL0UCIJWvsriTk8lMl/YnH7hwk/TrySJhsZRxX7s4pSi1SSSr7L5H5 +QB/a9x08cy2lUuJN2qJLxZlgI6XmxXmHk0bKzHx+tKAhSxdd5+tDEtEKeZPB3sOSktbqoMrJE92gkhkBhdHa2cEUISUDT7iK8sOhtQz0PRZ9fmsRKYml/MuB +iyh/NAnKnMDB4JB9mc2542ZjckE37LhO+RfCNaDrgiqCqoFNO+RdZa+tIznuBl7GBMby2VKo9C4WzeR1Pn1y5MFtn0A80v0AL3KnY4wBZ+4Zi0Lpwk9Z4FnV +ublvwS3JpEW5xEuw7Zo6lJWwDh42shD/cDffjJmiZ1Dxrq6zc3WFBzOulbKC6VDNgqmoHDZuv1hGxA72F31vTa/2LbCBmGWnNAdi9uavRvLGY6JUm9U7P7eN +CUL3cgzJZ1ru5QjJ98QYsvKc4WP//H3nzcvFv9X+Lz1rnU5zNUP4Tg7xsH/GGRj9qWYWkzCbpy/Nv2BtDdwZtow2ambdAeDZHJXYpeJ9JocuAuFAtG2GJhmA +rMDPlTBBQs3A3gLwUCtXDqdl0nXT59yl7emKFBdCO6Y6jnjILQW638uufgd8utOQ5bCzvAn2uHWy76V9ViMre+DUCmARHZar5HSFmxDREVxixpdGYNniIDzN +JYFJ6P3yW8oOx81+0eV4+Hu1NIp6/Gn+RSSGt+907Zf/vx0tQ4pF0/vVzp4TP7UxkCwNtls0+MxEesHxlI8/zbnTIYACPxVhYcQy3cAsGfgWIJcwVy1/2L+f +yNr456HF9CEHfTcvJUsnmIrmqFCNUJdvs9lMa0cglbmFWnw8HcU1mamrpg/NOb/XyLisifzV+OHKkgAA0UmbiB7o3Ir8yTEYndF4zOd3RLeUqRgCIxisNGSe +YATuBLqgInF1Dbdfhc89lbDfXGlnmeKcHa7A95Ra3lNFyDzCoiOVs0MEfQwE9uSoJ9fMopU/WpskPv30Wt1Ml77ii2hMb2LI3m1U/UP4gUEjAfBhqOCxcbUJ +eKGoXsfexWj/5bK8J4bLgvfdyCLGbYPq7S0/HgW18COKRAlPKOu043tn0KEGr12V2ukcamqUdz5DGKJl/KaHZpuKQbJaTUDqTkkMYsrboRIVQIUckp36EHSh +R4Y5y0c+sIE4k1DW0Wz+jWnqAArOUwhqTNBrJRMn0UUHhfis0IoiEO+ssrJ/TE/WTg4w5gbPPVjavC4UqpAKZiJvTqFsDgt0Jea+KPVu0dHLlKER4Ew+3l1x +BzNmCwwDm7zqwlusXOZpr6tRRD/jyefpIaXTLLKg2AuTlTssTam+7REafIIcgfbmzSMcI5pHl+LrF2ErHKNVTQ9t7bO8WW0zjbynZQJzPTVakbNZ+FlvFR8l +8+hb1BiTiGp8o9wfIjAi24pRGrwEIXWZVa5eNeBeUQHUXeM7h+neXxz+/9tTLPxrMbZxBrlkJ3GsGCcYOC5u1TGbffsCco4FclBN/jqvqBsIkkdYH6+TZSZE +loVRtN2VCvP1/kr5fDdUv+YcyhdlIca/bRHu80Dd45siDrwem5gfpQnsx2Uh1ykJtdlIOBoaCvaVTU+aXmXYFY7mFmL3/aokSQYh+uLNKEBiEypWQkixPDqY +opbVbOyR1FwJxqnwecyp2g16Irwq7IlV5znQb/KMWKD1KA5rNxO/vGTBl0Mnxi/1kl9FxYDcF8/Dx75SNxCNLkwSP1pr7Y9UpQ3VkfMDg+1faVKmTF+XLUSH +Bb3sNXEhyrbbK5MQlznmAVi1D4Exj2o/cnhedW4K9y7GNpe10Fah6tUjEuPiX9mGU8e2jDUWVKnC3Z807dGZhy+B9oaqR+tXDmrJfxACyhyjeFIlvRAma5J2 +cdIWOROoPcatBpvPLHnC3s75lH9N2c3DT0dvYDmEpGRWKuNnBByUAFc9F26lc0oC1x7PWRbwmnmAV8gElBk5aCOwgxJCshcFxAtua8JGb/vQYIooZWnrSCm8 +yHxC44SpQm8U+LPVHkhIt4ef22s8827X7THucVP4wLnZY7IrVRLRs1hQcdck4D2YCRXUyZbDd3gD0EHJIq+YtHorRs6bpWxKqNLqWgmyiGnxFm5KrEJo4hEw +87YOXab5eNyFWcNF+5Pe7asElN0oVkRGMrLL8uLdUmFKjNTc/8C//vMf2LGLW+65qgxrJW+JVFce56BO10MAcKoe4no2jBLBHDV/piffJuDJ3pn1I4/Q7fsd +3u7S4KrbSR8Qqwj/J1BllSSFwhhYTd2rBrbJKS+z6tCucP5c84eINEN16hRC9cDgaE9fEzdR9lBty63oPO2pFPVt4/Ww4II5n7z2b6N/prSl7Luedpz5otcC +zXFas7DRHrAFdnE7R+uCkwk0tQL51Fcv50ve/JSQmNTxOUBDEMDxkEDoSAkfeaXVHhariGjuya1E8tmme05Nm5mnwFf6IGhgqdnwcp9poXwyFYvZ7NqN7Wgb +zcjMy2BpmwnVvk34rPQr+zRTcmuritocOJdRwliCg2HR9arsmDYW7PikhdOCyr1aAzpYGjHxczc1xTOLeQSNC2ceyw8dSKaglz04tO385/oZFfNpBjabFEoW +cFBM1iGO3W0Il51ZfKazclzGi7VCvE84Mi0QkthaZhX+zsMBJUIN6y2GkoS5T9BQHpMU6CPZte4c3RllrwVnmmrstWeJM/k8kg/gTaxUwcdmSR6CRC57i9ph +WzQI6rfPz6JqWssFe21kxdzEmyXjEfyD5gtFvLPzZOBTDD/6VqTlGI6ZcjaGGfaK39mLI8xgwZFZTmZar3SZSpzwaq89ZkUcqmcEsYfTpyKPCbgoxcuWiWVh +65lO24MW6AtHa7QqFLdJttcjuskc46KArmQs3c+JcJUTt19IYOEI5UcfSMYeV9EI5J5ll08AN9hz8rjeJ/nUW+ZpEXh3TeyVyePo6xsC3lfJyYXsG3j6Nliz +Rqp/+Iigo0Umq5GusO/EbLtMs5KkfFSPyx3/DO20pG/nNoPX0UAEC499Wua5IaebCkgovwR/SjJ0bVaL9uY1oN4FWQ9/vyoy/mXDATKdCn7J4K/fn5TXO7Lk +PfeqauCTWDaquxtEq0hgddqZo46Ga1r3zJ4erJ40rYMJubY2gZbgzYfU/Jmg9j+y++P+XU881sFXGhDx95cT/7N8XJs9gdov8bOtZc3WMPPppzToe5aurPXQ +c9R8Vlxam5tEvibEfd77/82xeNiWUNrs91H+Zf/oBKZNOmBLjuV+lrEF6i7UvbmDfa3rdsXfXmao4YUNB2d9A7N+UNuQRd2fEBdonNNBNw7FgyU/HX+n2OKA +ryHJmbmDMXATJe5ATODzpFmHBGzX5Fl3wD2A4QOWTpHlvo38rbX9IjR9ThaP5lCFBb12E7SwBpna1z3o6XOAN5nhoylqWsmL/VQfkyeSKmyJ+iWQ8i+7b1YH +e0RgLEzZDN6ZVxGaiKbY+foxOYocRRHAWiSqeV7u7Pg2hQ6c16+oGFIjcHECPXFnrH3ZP+XpoV4CsG9s4RFfOTdgqFHR1puHlSyz4syv0EJ/gDSlhMSO3k6q +ylHV3LUNkvHB3w6lmvgTsLU/3dU/hkxcsP1/M26X23vvZ+AJJ6WdUJf+EjvN1JTQIyrm61Jl4FJ/gLk0mtghEFjlPqLmCsPGDc513GXTagDKg75qEPx+R/mX +/ehk4noySdZ1+u0fEj128ym3HXEoG5vgqbmzKoNElTTJPwdNpFNK/ncZNGCVcDN0P/ZiuoNW8tMi3HFdEIGO37korEYidBRhCsOmI4OhMtmWdST/jleu+YYI +6bTYxoOsp8jjZnhmwn1JwoHA1DZEaE5FwQsApXKO0Ejgzo6p7QgN1yFFwEtJWDPmKkaCG/6M57XcnNDeJhkddc0oocUQVaGJmUrxI6bt08PcqLT5KUxAntpe +C9raoArQ6g4y0dTPNN5dylfY8r66vU1V/9O3xckX23Wg3PqHbeZVeOUK/67lxOpLedE96ViGEd3Q+YdTK5Som9mWi9YOF35wEZKnhuZMshDGVCYF1yuMX128 +G+rKkHCxcOh4CNWwXgl+Y7GTKaSeKlXyrMvQazvGt394hmloOqXavC7ADylT+CSVy/rLI6zeIWdfXF8+jhL3RbW5ikEdmh4maFBjggxRVwe4yTyEGw1srTSu +w2y6wifDmmzFuPUwtHletIXaPwjWiomFurRJRdFTD0vQUwMuCUsFa9MBVheHGbwUx/XvBQbpkD6vo3AdUm7vImzX3k01YODVMFFaFY0pouDWRGrCBQ939azC +wmLHgEDXYtiFUzWtyR/lq5B2AUhsEFpVkeSSQ9FRC6q5AzJW1A3N9tFaGep7Zp5QWyIsPKunt4vSBK3PVHjthJN6+sJLAi59ucuZKUhMRTWQsPFUkssiB2MZ +ZTEDoYy4Xg3cqpRjNAapDFmXfYx2dYcQ5ssaO1dG0VCbpmGJyWrm24jtYA3FSzaPiappQPsd5V/2o2XiTbRKIsLTxFvjJCrcP5FMyxm4v1XfYzzf5247B+1N +XjW5pC6SW0Xs6cs3l6fttM/Wl+EumFfXpKZTEP9PqF8Onjzdjp5Swnnw5k8gzdiJhpY68a9VTXTEmdWiTlNdlNva2JbG5MhsRnMR51IdPLhgpA05ATtctP6c +FA1BFkUd6HDuEG2LzEeJx0PIsP1FHR9SOX7BZXIslyHxb9wKJvr2BWXz1qIaBwVuv3FeC2tXlMjNuV5Gb8XjDj9Py1quqrmEAn7CFpKx1n5CaCiVLvDUpclg +pmhB+4xDRMw8OP6sFuOSB0Yd1YD2DR2AsTft8w2o48IyHMrA5t/xWBIw7kVJCSyZ6LgXospJrxNHM/TOvp378/6gGvmqIjS7dO9o5VlZiPgQD94zofVWg7aD +BjDf0UPkKimEDXVVFRZoa13d3O0F9+Zf+DlyeNbMyMt3xNr+txSuoHM1uWBPeaGv4AUWz2I7doP3FnMbrliw8mXqRYXzMYrZixF2+zx8a4LgfB27qdBN4ZKi +DOeMp09tH9ZA+VtHp82sDNRUwLAeEpN4f1DbbkbxoHPD+9itlqAaYiDL8MgR1h9fK3j7D6+ZJGZGhldNUKeFDZKMNiUnmdO0KZPbgcUXeRSv8Har00n0OOuD +kMAwjMaxIb7P8QIbz0AxcOYCF/iUP1iEuqgW7F9f60IofjBe3f1y57CYo1AqIN2K6OAziB1mlo9G/ufLUtrc02hZPSjEhqJWrVLIQmlEC9ANhCG8oQX4NG+N +wioqRf3K0W9wGQ6l00ebfxgXA7yNrfU94vipoD4+KD7KMv+KSFyVWfEK6At8I1NvWCWpwvMt2RTC23cbzbrchBXEMtzopASqdvZk9STej4vhvjAjBQypsnaJ +dZzsfYFJzjRHHQGo/sGymcuaXU0HjlOpqfOFMDp47AVQUquFtYOJT6YCa4oj5+QbSb3sME639tutSR48wWg5O0gD2Yccych8Mu9lWXJloRo/bq/sfvlfcF+8 +fNa/0LHoKSVAcewQo1mEqquOeIw+zJtQcaeltm4mE3zjZy+c0mOpXV1YlmqtcCS5WJBneAIto7K22DVlWFu3oQmeGnTpClegdtLiiyjQuu+qGZ57swvL6djE +J04pwyrO55u4pON/HkfLw7HDtJ8Ki9FULg/ficf2bYLWinhZ2FM0HV/Utc+18jLt0Ngi1zfPU+dOoRCKPPJNwq9IlLXvi91LP1QTLjkRgZEnuffFBr9olR8u +yk01+n87I34QxkCohKrS0Nhm9w2OuoMwFRb3ZxWyoTCfFirvBMYkEtqDpsrbjjL1Ytd0pIqgdQwOuykXGo1xntHXNccCrK3MaFGZAossRBzmB4OqGA4QEXeT +bEJb2JwkYsHr/plL7iMxER66oU7DS1NEOY1zpAAWDwNgMA1KFymPsbuFPWyPKMoAjJRKuEigaoCgEG8K1+aL73fV3AcGnE5wYUXOk821ZKLixGntkEu7UpRR +VGMsRweZeIaw/uKvgp06/Q7Du4iCtganV4dMod/o4qIeHvp9o1D3OEPoxCpxPOS0bbLAXJ0124g6OCTuzQageb05t1mCajFcRcDVQ0VBNfk5hkxhFcuccHKG +VVNJ+wooRhuVQ9r2/vz4IxpuB4572mKayOFzvRo1I1ftsYFaJZmb7lSlfALluYVKgLpaCDBWKhaJae/Qu3l5c2SacVovo/MPOzJKIke9HPZWqtKWAamDauRP +JCEaXuHD1WmxtMzOF2XtQMDlXEeeFBAOWxCqlCYEJQSUJvguRFOzQpGzdQslWbJhsh76dle1eXgx4Aqu2H6Gy6I9jiFiKt1GsyRLZEwdYzzE+HmYc7OCo7Pk +SKG1H2XkgqAPgCdUNEprrP2GbvbtfhEUlO6CfkcbIb+zNIYrcOriWThSqJL0HzXRVPoPbgwWQzpF21m+5bzE3DRl4qWODpJO0tSp/aEPgJLBmezgqeV+oElj +iFyk+9rpFM94obj1I9WvpwH66bd74H11w5mBIL177hQU3e6CK5cm9rAZqDEp1Uj0mcQ55gOqRv47CD76F6nDhtZweek8pJC2Os8FYa9S+YfsKX+mF0N3TKXQ +DhORj39yxxC9UbNh0RU4WyizlvhiuBnZ8zC7Hm6WyDom1zk8Cj8hjjU0a9VtB/pjSh6ljaWYBoOYuxYBoDZgljlcpJ7xr9AVnsHf9QWJ32qEdj4ZbIYeM9f1 +xEPxwr2g/YeSQ2nGxoW56OThfrjgUPEUHK84myK1GLbAhTrKVR4OrkJ7dMN+Y3aYvQ+8EGpLe1jYntOKRUJDmdGixkU5X1l71Hnd6F/1QTfNSyVf/PRKzgSf +TlyFUMZtWz5JeppyfRMsor2SnwfGQ//0TI/zdss5JisrlR9QPPGDyl0UXBy5gm7DJg2vdPEZVgrMGsNNZuoiekI8DT0blV3n6pa4dBNFAqY8zWFMDe16cSGC +oFMNni9CuarHtVpwSmRpqQmqUNYHohd18V9oqhvEvphiQ89HTrP0vA0PR0zqLgmQq4yWy9zSQBQ/JXFK4vhpZK2u8HwpT3cK31FnwRf7Vaeoq15wq4IctRnv +2U8lPPS8jhJ+kHDggVMmf60XVHQjGPQoKtqk46B8+Yps+OCXxXvIe/ar/L2DwNCThw7JNkjjVJPyQHTHyToos7fChlyyjDXgdl4wPEr/a+T7/aD069/vuScF ++1ecxXWynvpTjrGP/zBGkjtab/kInGH+NEsuus0SuGtBFYwobKPRYoJboXfNJwV+8AYu0dFBS9OYqJbTbCaPZ5M/gJUSWTU+vPbVFcTm9aJ/aBoqGabf8Inf +Ab4FYPGkdtmZPBs+EU1xuYJpktRJ17OLWNDD7fcETXw+716FZ346abPfuFLs9NXRtijCzRRtQ3NFktOyQWi7RYH9zoB73V6wX4ZZMfRGVhWdISPlPIWlgWU7 +JBXwHdyoILeTDSUW0KMuYUkHrzfxNI/L/7zOumr3INC+Ey7T3vhUh0HmrmoE0AVKqWbZjbtwNhk7aHT6Bx7SkTCPF7xY01v1RTR8/Ud99Uvi73M2uIuo2xMm +8rh+HATQqAjCmQHSt5inP96VE5JURfcbYqbmRISL8jVL/rwoXz+5TW47rkImeXgH1/gZvyzJ0E9cGigcSDguYe3DJbLhcb0NNajXIDA6v8PGM5Qy2G2Xx2nc +O3s+BLOn7CnXCgskHZHntLdF29q/2xtda/NyO9yDfu4iogQtJTi/cDbAj8nUFnokGURE9ON3y0q49vXcFOePPx0FbvIy2HXPZjBDNmHS3fX4ULjNf/91L9s9 +6qXcCjmi+sU35vkbGzbDt8M1tvv6g14rd7djd4U+3lX8uHYLbj9zibSb8fhjxwBp6x1VzeV24dmDtH32Q5wAKWv5tkBX8/NASYLnmfREpHNW1WIpnw0t5Lhc +fbBdsebFZGPnURP78HojTgTu/3Wlpk5xEEOHRznvwW01ZFaI1+0OibSBT2AWdnV9pAkF4Vxea7Mcxe9/A2ZWzlyTQplqqASyKf2kXbSwBrIAf4OJs/RR35ps +blVhjNVxCGTLeXhNI/PfyeFhrprC0QlX5pIc610xeEow5VMVpM2VUREyDMsSlD/gOIj6it2I0RkgSTfCJZM95nvKNywJb2UpQe1KVOxxlq/+OPNelEibKute +yzqRxypb0FJU0SDbmFRUUW4W/hlPm1E4QwJFjaooigmF9TKqSrPjdnsv/6q/8xawFW2nYTTbzAUN5lqu0j+zUl3TRKAEnj23lzui98qO8W7+gyfUZPcbqhQ4 +KC6HbiAqNPs66mm7xkbdAfcig+dZOBPRZ+gLBlqZoM0zbL2Ku3WnVLMu78NdXxq1HE0GZCezbXUq4SZmcINVwZ1Asj75slNNXBmm2trBSedEdnOGs2u4aoWe +qRXHLZb2Hyridq9WKnh5TJSJXHjgFYYilFBXT6ZtG9R0Rec7eEfTIlzk+lJItzjSb8xt5jnqnSB3/sQRebsZhNkAEQxRojeKI2vIh1jrGHhwIhduwa12qPEd +HQhm8qqVm9+njQVkeBEmR4kEcTAJE2VYzsiu2L+ntSvP6xa8/bEpHuR3OWxxB1hWS5WKqu0P2kCFbnqh7//ztYKLkmRXZZMYc0AT7Oq+sfxFbADomaAhraRs +UdcfkSv41UzenN/c2OuZOfPw4wrB8gmN0FtdbKi2QTK2Hj7thPIYmc4SZbweG0QQbADUZhrmSnpcRv/nZ2gOYbmX679jIHJqJwNthb1NbieAOeJRvjYv2p2v +7dc09Wa68QMB7/KNKnPSsLNj3CLQdiDXAe6MUszI/ftI2MYU5UxXG+r3wlNznP7vMeWfAvZ86Sa/tmbXKGactidg/iV6zNeiP4d+l0OBW5ZNts2YPijPRNsK +XPncD8NUKOtMLiKLqHFd0rt6KA1SW9c7sAShO841VasSBGirkk4kffEj50TPeTtzaWm9UIMsDDwoxoVnCf/N4Av/cPPICYuZBNCj0gYoZgU6/3VDjaj/mnFN +NuVvF4K+k0oxTu3dNHzNIitV12Z7mdzl9ZTwZg9H3gyom4n76aVjis4rlXA5rF/BCYdq48dXVyjqRY5kfa3JwXMSJZ8yklEXI+HJeq485j4jByQF6E/0nV6o +95xp4z+yreKmUUzzwJmdcUS8lZzylB4hVFdkHhSX/NgmYsU9eHEtJ0Pn9Tww1vgPh5ZQFQFLCbNQtKk4iDKAhqLpkbvqVYF2KNr25EJIAwpRWF4+VYdKgPCF +XuugRkFYFO2hDio9wC8qz/arn+jI0kAfFfWNQ98CX7HATKoKcB0KStHYGGY8fkpFa/VquCtFCweOKn4YWWu7jCxTlsPDjZUuZSv1jMN3su1srh2vfZdos9vt +lpyM1g/UI/zIgJP0zKiOuW5v94MzhbDUz/a8/t5P3U7wfixn0kb0Qx+iKkppUrN5BSvtiI9551SrmhUnboNq+jFbZGKpbdddQuN4+GzxTFRnx65sxHhLPQfl +i5ryp2mWlP9E9cQ5+9M2SQo/+PnPvVmFp9qbrN55OXpiEZc7az8pRkddyMLT3mHltoDe9LgOPK1r/OhTNVOIQh4Juvi4/byUkU0o9BnE+R+HSsnCBV0ECl6e +k+bbZpwcd73zc/jndjdDg7xjnH6djp9S8TJafE8YdlToH5vxI0LVscoGzX7ZWTlM8iBNz0/f7+cDqX8Qzh8N4vPdgWL8bRz05dwIkjAI90d+V+2K61jwkMmi +VMaepPDtgA4+vilKY7/+tE1cKurJ0Q7RBJnT9JgJQ4QMdFe4Nj1Wdm25pWUHcWTGJjz0FjooepMzQ/U6MzaB+tJap6qX0FVL96sFdtvK0Td8fXyVE5NE+d3F +UDX+ToFoo0vPnfpR0dqP6Btw6qO2JaMIB9pCjMukqMnFUe7AB9WgDtKSQ3m5RD215Y0/+g8v9o3/qXfUFn3gZt2SJTbwUv31IrkHmqbJZRwdZS3iOeIHPJGh +WxjU9qLyjWt62l/hAgEQK8jYzrf7/NgSU3kVhTvPV3DPVL0yWvzhZ/HWf9A3Xb6rXhiErMsWrLhnib7+ORFGHTKnLspaokXq4SlqrvXRL1lRsGpMJnF9Tyby +7UC/qdBx3xPUv6pKVgEagGXiNiA4Ag5dzGh0MERjiw9FJ2r2OqBd2bhMT5VMfmE2uLTaWVsOXNwn0WoS0kT2oKPG/efyzjjHTdDc2yCPw44T/dnXx0NZSLY6 +P7hEjRvGjUWlUuBejpc+XNgendQ6Ykwv/2g8UHtR1de+SrqKBP/L1AB3q/kUhoxA73gpKjqfNA/TjW/etNgP9+zhA6nrwV+12JKKen+ixr7vP5qlDRUBPUT1 +4e5MfAQKxx55mNZ5sRSbxYqG8xnyz/vhZbIb0roZSAAtGJ7qfUh9z7+UoB0LvljQVHgSNm31M+sAmgK5OoiOlo7GO+TiuVgJpJUjZ3NrdIUU3UkXBYwZVaNW +z2HnpiqWduPlJjUrXO/2rQ5rpY1ZLZ2uYi8sJ04loFmOvo9kYQ4/ar+gNrGM5vla0s0YarFPUjdrXqtKHSphzWWxdpTDyOZfddNA1qV8jz0WeC/cVYkkRDlo +t9lRU7ZrFyQKZf2tXObLbEGKZ6V0ipwr+OLLHaqcU5yrJUGgbriylkt2nUy6rZpKylVufzZ6c8mgjqare28CI7/M9IfM/EP/UwpRcHuH8xFnItN5q+LQgt48 +0MRt4RFTnJMn/gO1/bQwu0vqNWhG2IYHwOTaqQW1K23kchMdvXDQ08yJsBDDDFd81Wh7mEkB3lgiDzwUDyCWqrEg6siyRC+5IWLArkwTyP/dlxhk4JXb/Tr9 +61BuKZMzuQs+LtEGGdxIlQZVxn3IMXbcUWXMnU4aqZdou2Quk/2Zv7liAfStT5M5p2hso/kplNeO/PhUlwKGX0yRtNVmfbRZJjZP9EdqGYLf0RxKmbphNTgQ +Zoav4QKOgf8XR15QOA9Bhc/THhTdBjVYX2lCE5lUCMd+tUg1ehk61+jsYh59dJYjPKh+fAmQ//CHIP+RCQ/7An9d220ms2U8YPlOVYuqCsPoIp9sIQtIhfOW +WA9qTWs6BceFQkfq7Mzj2uNbGsagKXmQGvvVFDehvu5J38YTqEwI0c5oAZVJHLJtlwDfDpahr2qusRsxt1x816uZk9Jx/MJDn+dcWV8L+mjw+eGCxFCTpita +62LBf9k/5tqeXB9xEWDDA7yTnLZoVnD01OUWm3Cwt547+yAF5D78nHiIeWAmmHaO5CCTZvT5nyZ12DrjJNG7Ftdyc4P0oWLJPd/wW4HW0Z6A1jzc5uTbDa2O +vABRHdcY0i/vscQY4Zv+JS0IVtfDdYdxYLx2aDTFjsgmVgV0hVRt6+5R2Qd+en8POPJrMYUk07BLXMb3TYJf09jpqIaJAd1kTWZwg2KMTija+BZgNCDfZJ1f +XxRQBxFPjbgN/aEivaVcGkU8KS0ro/5uiGl75u7Kg3gv5Kr1loImGU0rv5Evyu7wSxUlw+eNVq3yLud12iBdnokDc5xMGtTDuOTLtNOHaL0c2xRDqPIDR7bz +pkZowci1Kv0oCSUTO3wzleukaxqR9C98Y+CI32kPwfYWvISaCKYOIkd/TH5HqVp4dyeGlGgUoE/wZs4heqGzJzDHOwJffNzenZ/UtK2roPmfYODjS8JEvi2r +oeiqKnToi2FX1Uho38JCzX7GMjYuyrrOb7LtyTo0637MZUQPfujRGipfudyCPrRhYcHEzniySF9QNal4QTtfBiQYt+XhwtVXeKsH2hT0aG0WK4rxjkdU2Fq3 +yICHVNd4+P61f8EI9ysOiRQ3J5PP52ltamLo9WAA8UZqy2u7j3lgR8dv90h6ftfsWGpneOz87Za/ckrVjN4mIrQYjCDG6PFWc3iwMDjpVfMGbU7CBB8eRik3 +3UxDYfMTmPTGS71MoJNASKsP3NzdjfHFJ4l2MF2M+IXmX6g9rVr/SzZauACT9mCKIJspJ2G7j4yVg9za4ec/ZCDmN4SOnLrRw/AppZhQeWuJga1WJtX57Glm +sdjP6pWDuQT68Nef8/Jf8h8/XIj+g452TyXeFbbHGbxGPK6obsZ0EzOmb2aVywM5rwTW9L3mK3Z5D/e5vJFunY6C0LU37m0WNTTc5MHEfKKs/jnAL6zV/8lm ++9+zwgBgNtj+9h7Ijj/zeTNllitl0Uz/NUYyOggJdVpj2JgNvba553YQRPijglwM6T1N5Ka92OKfGPqy0ceIrETTNSJphe0ljb5NNbpxY1xj7Djps96NJCcb +W3VR2uds/X4yt/aupz+NRkOxj2ZeNY0151RzpX2ZHAdrStz170cNPHAe17++bVY6NK8+LcpXegNbgW/s0D4E2Px1wotFHXdlOzSyiV/icLSmAN1MbPYfFtq9 +2nUMmYBbDU8lvcuXZiyZiqrnWKR6l60NO1xOle46TG2rmWmFTvH3CUYXqZpGM+VPJFeEf1QNvvtakk8mm3tkNBavgmQaGrLkSEVjs5aCqbfnvDnentS1/Msl +1+4U1K78wNFFlcq2MSnWvVhMAnTZFqwhDozUVi7ulQuZJFB0zdq6AJN1xNErbkjpZBLB2qXWWdz5uJGMmGtQNUeN34IeZvbkbIb3s8nU/fVa0xvCezHHjRzS +JoXgMVAZP8wEhWDUD/pK8/OZScHduMaqWX1MUKpfHlqu1uGSj9HStIaibie+As3Tiuz8V91kR9BOocUXQ/rqWQhReAFIz1gZoC6y13Lr+aoy87gNF1U/V/78 +ousOGEi+fBOKLtB1RveYlXTCcnizPzIGHQaQitJbj9Ebxa2M9KdI1uLYA3zKlYXO/OHCNK4gYvWhsqGajHTPYFeXqO9sso3xVa5SWtjikmiRiDgKTuT7qgRq +dtP2lPMKjzs3RwVd1pfn5e593VoPsUWXXq/xLdyfFNsU9VPOHpQPC45LN5K3FQaZavOTD/fa2J6z0jaz6L2SlNtRi29PmajpNMiptYN7BY8F0ZBf/+SmbSOc +jzbzwwoHMFDZWqe7wMdaqYs001PfYibqL3IuzEKOyTX/dgNCCHo90SOFWglWhhXJMXyzIJoN6KFM0mFTxNXc6KynPP0HTRnDpBewRVSl2KZWVBPnZa5JWNmS +0PVoy1ZmSOPvpqqE6UkZPRRfWiDyZcPAo2CnNtkDxLpj2Bx1iubvPmST4c/5Uwr4KfS17OZ4uMEYnJsqKk3pbBpcgbsrURsY99ClznGgLPjUTIZ7wc92Srr2 +I1S6g3rEIdraPnbnHUiBeCNg3FR9O46/qzJV3dziUHyqGSvHePAMX7ZcJ4yeWPDm2iLwW+NR5I1+ppZJCX9i/LR7AIjnzZy2PXle9ACaFteql4oLDB3fygdT +pNPNF97rf5p3cP8RLdp1H2IODMVH1g0maRq2ABGiQ9bHVW+uun7ycyVra9/AfPbokRp+SGZJQ+N92oArRGKN2wunoImJaL3wCL9MVDrb+RH8t4fiMqbJrw69 +IGiPukwBvjgPbK5r0cwHythL8E9MKq71yPSg4olMIVNbKG5DyePG13FBqN2QOAAZP1CEyTxg3K6V9Ismvbgf9MY6KD6lUH/BDSYfkuY2N6N1S2UCbxlNzKw5 +MI85u/zvK4I1m1UdUtt2h2ay/V85oFTMXEAqIS+NjrBmgN4X1KOhkXp0eF9PJS49smVKajw6aVTdo4NQ8N1NloxRldx46nb00+VldSVnVkK/9QfHNbrskj2T +mdBGa/H/Vz6TvpEzuFv1de5XFnYm/v+8WBZGbvgNymHcqr5QnNSoFue8HTG+oFD4xV2yaEWSrc2qL5lb0DKHIeajEfoY16eLSQ3kUSiYdlT14xsE8h/RTMXl +YOq+zIhkXaG0oVIfW/dZT6Vy1qM7a5nARzka/bdNOUu5qx1YLtCCNXN2l6nmsGI9o8WYDVWyPB05Iy+ZcdqJUiEOL7lgPE+tW0gJPyblkDyrFp9rUX+VK2wq +Ycc0ejyHh6nbbcAMw5Q8cMLoMsoOfGK2F7xKVw3PbzoyEvtauukQ0v9ScVYgcVckEfgm8mTPKRIOHS7/2KuD3omQipk5zCbAeGM/egiQPulEJ2Th/SSbP7x1 +sf7eg7GXbmnmda7IuqF8M2ylFfYkN22P1La2U+ZW0IuyORL+KLb1mYlpOarVnxxCKTIDw3lVNKVbfpn9Gt9b4AIACtVxFPf6dmqvMTOqwzwVhCSEoZIc/lSJ +TwvDzrt4vSbQzXXrngtM3UsOt6wRLYOrpQMdGI7BW2L0AWLHrf+NG63JfDQJwOTj2M9JTFv4x6zvlTmWonqZ1Rjk+BNCMgGVpBuZkqLkkpZeOJajWoZgLjlz +iIqjPlVjcnQM4tNNCx3ZHam5O6lb5hAkQL63sNRrj8kujIcEjpyNe4RnZ4q5otxsNuuUnICEVNkRpSqaYzuaHp5uHkd/ooQ9l6W1npi+Q8w1Rd2ZHDgQ22zo +ZlCcWySXJ4hXHuJABBzkKVX6fy38MrUCSonSWMVKFg+ozDkWyudCtkyohfKJX6oaH2USk5FwD1xwGez/I52oM+UQ0ZRoti5QaHBaFkEks55osF1sy/hyzQIv +KbNG14iKDBb+385W+eePiNPJhp5TG52ohmSn7H3MRrHJgY1NYsFs10aTxRDRGJPVsp6qD4UbOYtabALXi7bkPE8eCYZkL+c5+NlSNQjZRm6qItt9NgtGy5i9 +qHkgRGEwEx13YP2Qbrl9ZfCFKDM7PVLkMo2ISJ1EyH1wlCjzhIyWTHYTKa+KIZ66S1B9CckHC/tdnDcIVZVc/Wn0XQ+h4mUDpYEXRznnh+81nZrEv+RK7JR6 +Bqoh13vhrIFqavG2iojies4l+ExvNIMVtWVMD0o2wtiUDqBHRGgIn0lXf1r2svm7MXciknkuZVfhEt7FMjN7A5XLqdIbLALnKE54zg8tGwnxNqZbS4sSqWMy +UVlg5Gh3oTCGKNwftH23DA6KXNeyuOtKpqZCGBXdfK9VmTCvDtn36eE/B0oi+oLqLdCsbHA8Y2fSZmTH8zi2AUcgU1s4enszmQg3xEhUHiJ7N1z8O1Cz4Poi +cEXZHg6po7VwCc8a763t+tAz4TUe6mjtQIOvu6vOACT1Sq4hI9xMg0y/mO5tJVT356et1rIVq35mbf/APHXtJpAu95G9otb61Z/VlmW49Ht/N9jQhEuvXGFY +nGkGztFE3QTztUyyNPqWR0Umxrhh6mT5nD8OsTZxQf78XKSiBLrsfzjugKdKTJWSuYFnghKKusCsJsrN5axd7cgYuyvdnY+QAXnIVBJv6dDEkPsGO1L0x0sq +1fpp9ptJ/kzlvtCS/Us4JLMRYzUxG8gAQZu+AEZ/ErI7rUt+6dNSEEkqMVC3umwMIWMYNbSxEksPMt0PLy5P2+Qc5SCJbeVw41nb/x0tQddHkKrfdPZbk/R2 +q2qT70WN6l/nVXXL1vfItQvB0K0Zm5ojYAsHwUuS7GYDo/11unspu7tzUyO1b36MPnjfxuDsLuSI1LJhQc+ubo1bf7lBUw/hTi+LkJt4R6ng1PpL7lVqKxaT +cqqXTAePzRQmiK1JSAoQDDHeYtjWPJkgn5CxVf51noHyhE5rJ/60sud0YyCSMc4u1eaKGxtYnKw1MfuM8kg1TUgcpeLbWKlPcU9BYK5h1WqrUkZTBISA2Plg +PcLJ9MsADGw+P1/vyeT1I0dkHXE76/cgjo5OirXnD7EZMiLX+nJwwll1NiXfhjJQaKdZGuUjGFvzTeUKdNi8x5Ni3T3npl3ZLLNCykM02xtX8LOiBcTlvRVz +7Uah1aRSEpsqdopOVOgfJMpuuSWoIHIdFIuO2QMUJTWoR4Lac6AjfF2q2S2bdR5v2FnuqjOQCVQAyD8kq5m/lY0ebi0jlJ5ux17cszBgcXdvoOkqJwv/t6pu +ClAOzG8yPLiqaN77wm7+FazehzLDoEoYAwhaan6Q7XUWBoqPKReEkfnPUf3BXNbTwSvjj2cMiUzZnwnXSDJC4ht5ve6kXMvoh1GPrtI/e5VezZTFhtaIauQ5 +N8O6shcWMHrvLsY6qrWgs7mErb0Oq7pINZ30LSRvw15BYmoIPwApD0Rdz7cRAZ9tzJjLt6rPg9p04QYsebrgFCKD67gCjYPrk1GphDH1xhoHEVpMcOkT0fRK +KE/VCuu3Mxn7DPgEttnJlqnw9cIrgO4vJ0v9DN6Blqg6nUeLiNyQ65EmoUqK/3C5iJdiO+R32Swzhu+Uoaexlf1uXbO7KC4RzKUHC87+qBnesl+EF5OqJMBB +RXWC4u303OLYrY4ZBiN2EQXw8KeqOahrN3bDfVuPcGUq5TOIHy+83GeTJ/uSCzGtuDI3EWsDGemc4SplN6MqA6lLwtzVg/SPFqBU3f4SZftO6l0MPiBE1tQa +1HJT1aG58xQxN5ZS9o0JIAiFYxW6KnlZlw1OB8HvnjfH/+zWUkm4Gg3Ss5njc/Aqavo7tIkFGyF4youdEwsmxFzZt+HlbO/drmeXAXaX6txjR5jWG284kW2r +7AfDtlyIx1+17lBjOeuzF/NMFrsA1ucwf+6mgppXcLvIFx4ltwbMjnF8aqiXHeuCON8aaaoSSRacEoJ02x4pmhLiWQqUg405iL2ocDd+uXHPy1rk2mDxAdrP +a9GhW8xj3NGWK+cZDd9dCxWHw1zV7yYsvVa1lB2odW5SX167EhW+VrIEHbQxzpXXtEfJrGuIelWzlUrHDt29fNIM/nePP91XqW7glzvarFLDAi9+5ce+r31l +DCB4mvORIP2qQ3trQQ3PJJDVR2mBkx7ZBs1WQhlaHPqaMMNTOSLpYUlEP7sIKq2GzzGJvEuzl9KTKYwfTXsv/reWE54vENf8ZTo3gM3OoF+z11D+UPtTvKBD +pNZVxY3Q9JCsmck+ZDf1Hj5agZifh5+OyWVm3j9q2sZeNv5N8ukmoma/T0e70EDZxDBfaBwGcRUL6LVPL+hLjxDDmEnNfO0CM1grEcr77FU1y+pXbXR0EThl +qmzcXqOA51bIeJM7AAYwwgd0d7fBgF5IVObp7J8GNfvTnm8CK65Cd7+bu2LAoohv0Fqnseyf4l6DvSuKNxX1FyxTRybRRxBx62cPBL1FEzva1XM0oNsaEL0c +ToOo9rpA/IOoa7EbgiBys2aGQIGqsXc7My8QvREMsKAOuYGozkV3i/fjDTEvfp2HcyDO+6qfiRNS6ujuJx2IZwW6vT7u1QE5Il5ELZ6dhKrG5ikfWyUatiyx +xjpHggHthBHIJ7jInutBtgx8CVsNZZqLKB02hzORrrzpyMTYdAwDxUyfq+kEIcBE+D/I30n3BTiPqKz1uzCDrem6E98SZSpEWESADrHK75KoAuPLJTFhKnrC +1f4rQqXGqMVSgBL9R3+aJBWZhhKcrS2DauEkCAmdV1hgnVRK6ANmgOo8jQRRQIlu+dJ1GA5KQqi1VIB73LdjDsJpc9aW2y70xCju9cP8pWXx2h9RbcvLji7r +FdrSiqVImz/dmXx+7M3VYNA6qaXzsLxu0+BVKOPJ3fRIcXIK7DlHJMsttDCI8fwTxHnud9SIo5JEC0bZLusrb4MVqYxXZNm0sicq7pPwG6pnE1Bo5yKLn2KE +VsaulfsJKz8xv1yiYWXZWDROM8TgS6OavYIbdmkhmlQlacxY/HmrTNRVcjakXHJMClWaYXOyubdYrb0ayMMvEc/rmypcGo61XOQ20uCmlnl353IHKrTfVCe1 +ehIcPZ9JAS9p8L5JOYHx0w5elcvYintcF5OCcmqljy52bwN6kC3TGkfB+SWMWOwve9mWGo8l57gKeE/uPI0psMRt4V+W6wApQCaid3UNRABVMzD0DwN+NXU2 +Z+mNPiGyLmhwmVdGyeN7KCFMSEAtWJ94Y1oxOsBkwgA+iBRWnXSL9m3s0yENAdRfsF9IGovUh5Ox37wAoxQupTJC52UXzQW0lL5zu/6g0o/mJ8oMIOT0r+u7 +XDpz6jRbvrnLbk1wWsHdiegJ0HeNfknmfRFrz1HlHlloVaGRrZ/7OcBPGs01BF7EzXYQatP5iHUhlhpVN2pDKX5lU9O3GKuXvu69mMGVRQph/bu4jBuPr8P8 +I4/nlS52tLzgsvbtkowSnjgDbxoIEy1QxjcJctC+3xRmlTqquRVCKbnfSh4A/ERJrgLrJpZNrPq3W5Ih/j8uM2oEyRfk4G50iHsYnQM3Ogqr+nMfzo7CHsNv +kNAR3BdTZT66eJeXlpeqWQq/Q3Vsklgqg2rplstSfG+Qtad1RVtgKLVUZOYwZ9C++4amXZYK22UaSaoCWYBqaYSb6O2vfDhtHopiqIT/i2lb4WltJJDlUqrr +bFPeNHWaosExth5DrlUlM96musfZc/3l7frU9gcoL91oi2Y2+2iLK3uqNQ6tDaGxnSTw3ErTz0PIZr+DdkTcyRztmzU0GmAKHFuPRH7t7PJ5Xe5kblgI26xE +pFJLpcP59AF0z9tNatDFAQ3yHLf703BgDiYSeVcOjzDZFHIGm+u2uAGt/ZKfE60Hx13z0nfnUQagQ2H5Vo+wnrIYFNO8eUsju1Cmy5AqtuIdMmYsA7GAD0C8 +JfD3Fy+KC/92MMUIRa3g+kETGAG93++vE8tH0WGKOKrLMk5BIuQAk8vJ0fHy8j5bMTVWTHZZf57JK1//U1VE+EZ8jZPEY5DoP/uTl5HCBSYavaojbXy0P/fX +NFIzw9B2kcFhIhFlRhlvSOItpQ54t7EEoQUCYsDal1sRPr1QUJmpql/NAb1ORltPoLLjRkziBGBnZprAqSojPYXeLKVFseGY3MdmbEQ6KfynOzBvNanJuD/C +7KKOSHYgvgqma64Lpd0UN2Wg4iyrjfXshE8N5jfuGiJZDnXSmOcDFgr+X/YCajeX3F0eqcVSdvgK6Nxp/ycDAiUZmimvJ40fhyEuLPcxx9VC90hiWGGVeEn7 +o2qw3TMVY2XCBLEkjiVmjuFfwPRnp/xIW/V+5bZzKHfCvlI91oOocUcC1UqANQM79PQ169sqNNvgQ4CKfMYtY/6Z11oONRMMlkhROtmj/lbHVfkjt0KXr3vC +46k2Rai19oJSiNrC/GWydQmyDKsr3lYnAVwXDiuRajlvxRnHTSE2soYbFi7WQujr3pMkZJRlnnEMA2XYrNlNaY4BYZ1/OR5DM+x0Akx6UHcLnpPRf+BsPjG8 +S+jfVifywLI5kzjcJSajNZPGAurLDTvlts44miLT6N6yXRe58Szm8kJ0tq+0nD0iNX4S/sNfq6nvhUyhRrXSn+lVItjCJRL8I/si0n+YS6bMj6oS9QDO7oow +YHa/e17Y8qzYi0Nm12PgwqLrxoZ4/PpUV/n/YjevF5Mbn0DmX7VefbxtOtott5VyvrDIvNnmQl/Fna7gzo8qu2b+iqE+qWjGczgQ452Cm25eJZPRedG2rqqZ +fEQp7zzJSyRRbgZ7+C6bQpUV/ysO8QmE/si6pY26BB02BNASzcBP/J3xhn3XUZyiFNal/UuK683+eyHcExYcDoFMhr2wHe8JeCO9RSfXcXdziP6HkKXYxVsB +8xEpMhFUBVQniEjx2ppTr+sj301vYOZiEXQ07XWxjIvbAz3jEZrdE1rzvFNkvBYoIuWkPs74r/Be3ZBeXMyttwDjCS4J79rWZHyuyqpxPiyBAMV7j45zpw/D +Z4/iMIKp8NFbbNS9YP5+P5hvjIb/BhCsrP+Ps+A/ELuuuGg1atPg2kJpr0xKkWOeObSDFuXDN6nzsBqHsHX7c7JiIFkbyKvdJ+j9MZYUr3MKL8oABWz3ISWe +iswAbCi7+ZdIE2OZyTRnLUgf8JUTtA/ngHA9D/2C1Zacw3S7/Hda0Ecea1FY6d8q17DW4+dHiB+Qx2UCNodia+yvUCJBprCn1kmlDxBOON96ZZr8sp4e4A6Z +jx1iKRwy2B0sEOij5Z/t5lWL2e52eg0luAZ9yv+AITuhDIvN3+PUMzzT47Bx0L2bcYXM4RmfMPt2v19iCk4FnRYsyuAvJKp4VQ38mXLzZGMKZZcbEqEN3Twt +l27ouAZDjjo4RvJ0yWmZ777n7TTbEwjUPp9W4GdDpyXS1vL8z7rebcCDLEjf0pIIj/xhYOKO17MSMMQz5bu3KchvObt0JoaLbRT+kouldksJvKxaB3Tz4Amh +ptFv8Dq0ilY0CELVeAZnE8ciGRDbnJOBTtLzY+en7URbxheabWpbaEkbW9/INC+SCD7P30pHSnYjHarnuXtjr5TBWyGyZ/gHH53fomJ/B98PYwXfIqnYC0o6 +y+Y3SkDlCdGgE3+wsN+iLM7wSoJQ09rZ41UP5oOr/Bv/yb8mpEBh2gLyeG4YaAUDoDGtEdmDZYYRMVOuCXLoDVigQEmPXItJnXaH7sucMJcR74omFF/3W7xw +HlFPkdJ2ySTidk6Q5kiGEy+D+GoEbr+m931/G1f2gDTqblYWZHfNifPdJ++W26niubBen4keLu1OlA6h3VGbgDnciOAtxZB5yq17IQdfKYmWYAOZN64xUKcb +saXnwa4EJsGdWnNS0yQsPgDZmJQZ9KAmeuTyTRgQdOwhYH6TRb+fFjk1zd8OkDrxCY6udmtzXwKnlSo+LvR8qBZb5W1YV2Ju20jq2x8nrWUqU+yRYdYyjULE +wTsaoaeju+OQK8mU9iHsiC+vnx33UhwpGD4+vmyzH0Tnkr5aDSzZZ17c5KwauYg4zz2X3HGqSIadm1jZMuTUJTDE7I2cWKCE4wzQYmLot1XyzOEy11wlWj8x +iYhKorpKZZI+fnCj4jiRVvqkYTcVXUBMPC9QsBLPDm0wt7dQ3+9TnoWqyMN+vdQ5I84pOLxNDIpAaUTTwtaBuwDKA73SPaoHFTQR6GzFLBO0m+2y/gVs52/M +YArfBRQY7hwXRxlppHlmr6l0vrsWR4esVK/17AEvV9kBKDwDrPZxn+dxGkaE2qKylPp4X5XU9D2CBBFFvKAzkaAiihtRZ8VsuheOuREtJpmF1R0ff8Antdf5 +3t16zfMY5NTauVlVO7Wt18HLtKplS+VVNUxfTk4sXxtmbxQl+AUmouqEnF489+89zG9efFQpE+XqHvZuS2CUPCRFFoF1K+AulLMdarXTqkQJ0at44xBDbvdD +5k68iqcugsS9osoxSFudMbuRXvOpm0XqWzZm0GIrIVkmkxS6AbSsk48WpLyr3a8gDJBuj7L8pkpSlEjw9X4fC0H9o/EhzwtmX8IYDrF2nWxrnF+CuIBYk99V +m+rlXW1GEseQ4lz8NhvxP0PMUDhfHOEGqDDDKbgfYB53VkWdamwNgBa0NaRdVcr6kjJ4tdCR+WXObUg1ffnEUaQr2zLUvHxJ3MoZiCiQeechoraA3jDv1IeK +ft/3P5JwNOfkhbaXjQgGivdUNofaI+eXc0mBGIdmM7zXyIEKHqVkFtM0tVZdwYn7BvSjr1fY5f7awu7Wbh/E2qf/O3EK9TUmUXsaL4kWm0n2VLb4aeIo3fao +x2q8iYkFiCtS4L2JcmKDt9xt8cR+JZ6PRM6UcShgJT8pQEhYlbVjBUyGlXXmJjgQSzQroWNEz57Yskt1sijgpxoQpEyGu6vaaICzfrWpVq1jq05SrZ0P37EU +1O3hcSCrwPYnBcpiYuLGlZ0ceib9H58T1J+SdWGRJ+sR7S3OY7VxfRtUKe2Bh44rVLCSdBFfwnHJVjnmgGgezzeZo9bA3rKyzQjLCcO7Dd3tkAPlZxiMA6Cb +d3n/lAl8z0vR6bEs+gjqFpzIEk9QV7DTO6S1c7dJ6qGEYGlBZuridWObKLVJZeMeZ+OgO1GuA3JGSQXlXai4yl2BYsYme1rs6jYdwO3NPMPaeDIbVcaI+6Wn +hLRmXPgTKLVOdPKIJC38qAqf3vQIZ0sT0MmJZDfz/twlZ8xVtNuVmaPWQxVaVA7ACK2x7wqv/pR4mDiV8kJTXBpWkLJ0wdQvO5gEP+jTL8UXXwS1GP+/RHSX +YB5e2YRHzB04eEReVyVG9CHbaD6L6EJmC9ZEquxIRsNEaTlg+WeVuDxEP11XvHoxgt9IpJd/8VqeZl14jczAz0JGABdex2MQZLKJi1Y59TFvhnc6ebuMfXJA +Paw+ksgbIIKuMXEG/hi7D8kgX5+Wo1a400+kyR97pSYPWTv/fTeFslS376QASwRA8wLVHP0sqf6V1eA9n1idfjZlrX7SSgJzvRmAsCyxwgRyXTq5TgZH2utQ +tHFVXysfOSi5+GcKmp32M3QSnSdYXo/lp/B5GeTpDmuIiVcvCzeDbelmFgrUzagCBZsD0DH+rmAmf7S9Vs2StI7l1DoBJIibbWdZqfctkL3eGpy/TdVPk+kf +LfwUKZd98yizpzqDSURMOBNDknSBp0LBtxjSLbCpBDefm6zSFBJCoRE7meuT2HITKZn3TdhAWfDDskcyIsvksYbCqIBhApB9SyfM7spk/8tukiQTtwcivGwi +JSvPpPJQ0myM7CczvD5LG2VZjVse4ZSJ8UiJcPujqnLRrQ/69JAEsiHNAXR/rEzFOTEoVuDaDghY1j/afF5tE1zfvDmVPrgwGeVFp0lxbMzrf6r7pi0R8QF2 +vHkyxdTdeJnX6QOS53jzMCwrtX94xqAlY0WiqzOAwcaaVw2sfsMP69p7xz83UllX6ZrOC8gG3OR5tY36BoFA0BkQSiDaXRddZ9kHmzlVqWhH75B9U1ohGmOa +KH5c1kJSEVo1arJzXgEPpuQLo45ND2Qj2Nm2vYe8gvZvPhFni+5V3xFyiHvKZLOJIYK/fdtm5JsAczp8/KIPJH1SEEeZ+luXbXXVYL0UOFUGhnWqWFtZ85Qc +UVyXFbBFNqbkq82mtuj9iowFrEqsN690vVZjiZ2jFCsCOldvVvMipGFJ7wqafe/y6R97BaO6crdEf28bmxuSrC3DN4ipAq6Jqk24OWYaLxEQgix/09Tls3fO +4ol/Koc74BD5CVQXhIQWMllFVNIsLETcIRMLmXhJtahPdjdMqQ/lpdz85gyyG5Ip/pkzxuTKdTsNQUb1vmmERSWdqXmufat7Bhb2gAK+NFbWh7NRr8UwTL3Y +za4qe+JeABrj3BFpp7SbjO10yhnsAxiosoKkzYDzEBRyjyU5aobKLfDTYPBdpKqO26xZhWHdW+VKPpUIGKlIpx9AnsqKdE1Yy8HdIitN0SsLF6nGyI9hgblj +603rNt/Cb/qBq1XRGPfQtqFGCgvcOhOeCDJKOGCu1zWPWKE/ME9k7gB5YvtLb8TpoKoU0iPjOsgMVcNwtQMt1TOzr2GFkAcNR6WMvZIN0vkbV8FWv9vdFeko +r8s/XvMMbbAMloGDJuNdWy0t/3QSFJzx73tRsGqkeYQQRLLqiOph0GMIGGn7AMm47B1Y7/AaV8i3gBk+STK8TyDl7huqLo2Lpz4IWSZPzGCKNsmICjNbJmK7 +1LrLW2PtfNeEWyFWlkVTwPE3d6SvoPbeHbl5SmSH4or/vpgiRg0pH8mPJHo5Jba5nmsiyj0e9IvJX2Z5Yb8OC1eh727TQMAeCAh6YOWTDTw493ZggnR8rnMz +0S3T+dFG8QiFVIe1cHtN75oa1QolxQuKwS+6LE+2Mzt86plsjNDUud0upqpK6db2Eez5OZJt0hYBXtbNPczU95zE/czRAFpELhHemKBdUsvvHsx9WA4ive6j +T0Qic/wqmKqe1h4+bL2yqWRT8CbvxT0Tw1VB6Tb4XtKWmgfgSuFCe20gmZsl9CAjxi0zn+8cgs7EZp/2JiHm2h8amYKrslVJrHu/n4EtCdnYi4GYvayFPEIr +/ySy8jSM8bXbBqGF41YzzqFE3ulHsgt0BCfTEkpZnEWRW21x5AY9jTUF/EfWD7y6xqJ6h+ntfpxFeLtsGMVuazsHIJa1H+J9YMGJ7TLnMHJDf023uWesV+gw +VSbQUczUXw1wEj/gXi4+xTVYICTgT3Zc3LaRmYAJRfoGOH6c9I1OKs8R8I2iHSwQIMoA/zx3sn1UdWT1f3kaqt0qs6YABa96Hs1FIrzM5Ub6wjA80es2MScC +/fAq8QS9WWxnb0dKOm/uRYuZ5Gk/vTbqU3Fw/P1rpHFcGZ1PSY/xeiADyu+9DCrksu4ht1V7N1UEYjfnXbS04WTIhIJIODFgoTWu5ljUsP4h/mX6tI6cJ4xp +F4mnZOLSnU30FzKt+ExBuKjIl3+xqSsGXlz+waS96vCm9yiHvKKIx3EuiwAradT/OBGQ1QqXCngSWgpGTkKuGmL1+2LaKOV7ruFsCOJwlSeKdtBtwB6gQ+4w +sZmQozL4xhsWhL6YHagOraJww2Z35ofpEZvLrp2kaOud8QoO0oYTPLFKqfLW3MHG/H7RjnJinMfkuN1whluVG4Y6pPn3ZGD0qOzAtw9Z9qs+OfCNFXVN8X4v +gaDzqmJ3OQidcIy8fHaB9JnAmSan+tZp4bkF7VCqKsFDG8QVjDiK+uMcKmIkHcRaqKhyo8RMXH0ivwj7ea7vI9M7bmLbvey70qOrN7o51MhBPKcw92sgJ5uM +Gze7Z5MNShj2bQWJZH6NGN+r1kUZWFLWBa/8rkGxgv52rYJ29wa7p5Hhu670bsDX7VXhuAMA7LMpEgZzRIA4gRrej+JWrXiHqmkhA5BSaoWjBNnfbdfiWU6G +IwApwc+tykL8g0PJP1H5lZd8BnlUdoG3TVkXAbRf7LcaAhkHQ91K36FRnXvkOcTaNrYbyQ8Zk+9SeAnubItOJm99c658GGcpxX9SruFcABW4GzeMwxQ9avHS +md5DkDkw0A0ty2AI04mIr67DR1femwVDOsJkJpRPmh+qbmP+Q7bPz8EvvvHxpR/KnZ7Kmcf6/5yMAuOimUs5VWa3dCponv5IsJwzLFdcaNNfSvaTkwzUJosz +5VSDevrRPgVd+4L+jlZEjb5Gubd+o/kUP85FBnvUanR38XJWn0m5Z9BnJreEqIo+KUkphHi44CpDyEiPSKKzJTQ41fJi9aBF1/mwnTwxTAovBEEMC5MTkKM1 +IsHEiP7HkL8fMwyrl9rDuimqBdTeAo8r69hfQf6R5yy8oJXbECT97jOhiaJkO86CXQwy5dusYwzouXJF5uStVNsP4RXpa/WUskR5VyV6TjryLlKVGgFN9ztO +jTKOjkvElcMT0dJIyfnyPZJgl6yU3X0oiIB9vBvWbe9kIpcAmQBMQdCXBl8dTuDanDtdrt2q8kglUvYmtqHBPH0l7TZonTsN20MMoY9BVr4brzroLMw1V2+/ +fC3t0V1nyXcnJVMwSWZaybaArINhaPdwm7pVMQaYGf/ICa9x+XN9fSpRe9VuNPlms8/VizDrTHtVPq56m4ujPH3ctRd60BSXq80ZtlhEXf5pXgNn/QSksBTC +32zIp2g+Fzs60TcEq4bh9h6q5lKNo8PdlfesDKWQnx3UHEo+Z/MsBEY4vAGVVfkeax7D8QJOkv47NxQTZcqQOVLzC/lxnIK62I+S/I+NJcwzrXzZgakZV55d +Ki4LTjTbZFA282fRSDVQNQBYTnjX1d6RKy8Gdy3cucH6xdn1ACPjE+hIGttmVikykQ8w6cKrsNHaV6yWscs9Urg6mL2QXljxLTGtUeozd2u6/Odv5i1sS9wH +FdmDRopUZ/jpLH3rb6cXchXb3jtPu3ei5izuBIUL4r4/c3l7pMY9qsIGX034BZ6aHlutTdaxbH+9yk36murJ11LWAPeJsrl/1dos/TaFJt8UmQk2E9pOIVae +d4VOBp5ChG1GmclnIVtIVvGgd4ZSIczkxsxy+NymIq3GIN4TyBxb/TduOsv6Ii66z76v3OORS7RnITeuDKOZ04fnTuixuXOazqTlDcYibjTGR9eFBkDgJRMO +teCZYGv28zUzlucO4FhwOQRU0rWBh5LqUbUF11tc36P5T9eubpi/3/eAlzTR/Rj4asE17vX6M7O29s4fgIxpa3Iym/HCTyQWqLpK7IgWk8VFu70kjWCzipKH +OD1Sqw7J71tmRkt8M8oym1HiIvPAfj2WQLKCMyElgMtC9zUaT/fpenGQ/EeBUtSFN5EUph3lTIC8xHyTnNd8X6TgZKforK3rnJGllKOj80DM/mUisCt1J1st +hADyUvEHUM2gfteyW64aGAksxIqCKUNy87azqQTgqQs8H0QRLpsyG5OImrzcitZR5VsKn9HnT3T9aIddwTISqsp5CnqSkBVk+pf6aODhYRpCozHYA2NdocFn +b2RjAE37ncYD4veEj13+BaKSAOnIUWExWvLFTTfQhg17L3c78E58qioCg0V6v15K4GjadFQVQSKa4wsJqtN2ci7O7mVWUvQp4pUq+ohJsAts+bIp+4hlzJZ3 +sFX4vYJ3oKhtfk6WfIJbH+U3r/ca/kv11whFK7JOeRuUXQP3NpXNuuCoa9M4QFo6u2cusun0ooGkL2uuIgzVoG6gzWd8hgy4cvaVl/OsM2yYaTqvNO5arjHa +FKzJUmtD4ip345f7bVF1gLFnHFfFsFaqtpYnUsUnrunqCyw417dY4gcVDnaLrNXNF+aVijsOaUHsxt+tkmi2owgl8XS2Mb7PCuzm7H9bsmdeM3mzq2CrEIKI +c15i5A8EuRMaJWbaCgAeht9g/RIeGXwvDr1bIOx/a6Ka9yn/s7sESd5COmQ8VGryWZtfOvJuhEaFoq7r9+2kIxCvMU3RE0u+DoyqxejSs7/XaVrmi08NZyZm +rj13UB6OWHMLWT8R+xv9sBQ6yZZgIwcHFNbUa0dVeS3B6dkBre21YbdJcDTc69mFxPRC1FjQnH2KtYUCj5pDoqd2rrCXFwb0HfigfJq7svUp/AxknYUlzcxb +Gu6cUosZK2Qn3PCP4HH5+7pyKptrEwFor+aBAZspif4ckBVSVtsz+jR53vyH7yf1cbWmO2n2gqS35ucEh3V3IA3wntaR8GMog+4r+k587+3Pl8Df3WJsOuco +Ztiqs35zd+hdlFpeFy5N+5/CLl7N9Vxo5fCU7Rm6Ig26i3RiULBBeTTZTeFEAN0LoGY5kdf2eqCjB/zJqxoMsvXWGccWf4QOBP+/xawoPQ/nY3g5kVMl23Pt +Hbp5Oroe4lWHM6HG4JdxpI7E27tjTpfMiA1edPjTUHXTMkdLFmd3d4gHab+UnPFDcCeBqETNTbg+QehYGwLEbWPKGO/UQAjqh3gR+gxa0Es8WuPpQUffo+/w +k4vamYe/nMTxod+msqvQfWRYd7YmjGy/CYIYILFiTWvvrf6DWiUuStxmHqp/GFNIQGvvrEE3ayb1vbXs7L0xdxE57y6HbiAEomBjI//pylUBsfOKc5SxtZ9K +HATXIN9aj8NfHq/UVGMsfsXv/OEphYVBO0038G33M+9TbTA7ogIusYZZKFMTGZUQ966hXJqy3dvE/972rTQXnmh7gFlrCj5rhLGbqBn0grw1cnaclIK9cj6I +8uV5UUukk+Pn1Kro4uQ0bxHVcuxbBbYUtenIG+FVsiaeE6/ZMZ5Uv4AfehCc+Ds+fY93c/inIzz0DwuGWYAbGnwLqtRFYHB9DJuOPlv60BRzU5bCjtbfZD9k +PfUh7/uEXJ2b6mlpYwUS2xIoXRlR+C/87+5wppS2SRfCFZM3VsiuRUI9uPoa6bcH07zwNOCvDoZrEEP6EbjNy4FeF8hbWNDQp/f2UDNpxepsE1+WeH50aqUL +lyiLHQJWDtAWPgxi2q0qtXcI3Kec0K+NqCnnmJhBX++/+YU7OOPp9kfVJoeAp39kJ5hObOg+fMgoiMn1mRzy1ML6FltXB4LfKt7r+KVY6Q9JdvWqyTsTQ3ld +2cvrnkPjyIKzToKucJZ9v0lgGhFdZT8nPbgj9QvP5Uxd+cEp4ORWVFjscKQr+V2BiTtMM+X4qnUdrkW904X20nOqMcm724Z7G3tCD6yCLmCHfMHj5JmlhIDr +Q5m+rzZLVfY8JHYQUt1GNBXCcEFRxXNXRqVJrrRjWY30iG2D7p5WfwvHgS1T672AEIWI8lPETNVUKqTQ1h2O+3fzmuHrD9bYcBdZV+7Pw11zLt019DIkq9rZ +GzEN5Zbd5dZvgJQ2pFDxGmSsu2t7NCv3vzL3AMFeJ/gW+M3D8L8u4fNbBnzbMEp+7v3GRSuww4sLU2b5pj5ZfVN0pY+RGwK8MLQsRA3FPsomKkB7FR1yLqcE +XeObAgKVhvgyBwL9hiZIqqIjJjik0JBdybmVfXG/iqpuTw5prMi6fC6RblZ05i/FXnkIHWZJdi37OYUbO54tbVlrIx+rlP9zRrW20V1Z2UOe1lGrkeh5aUeh +A8bN8fQhf8AxDCe5vU+fHt91bScvsehcLs/bw48go+R00oDki0HkdMundhv1y2IHo69p2vQbflu7tKxJyqxKQfKVmMURdVdSSpHnbr3jaWvp6xZAltGyIEBD +1cnmb3+0qHbdeGSNRC4L2WZqnxQER+zWxN2OgIlyS98F3LWpPnDzJqc1L4vhD/nUFCNq2cXeHsqmmqP6pS9QxMaBMmN5XKYBfAwA/GwEeh259XYUjM+jb8ms +jzeiSSxd35K3tAXBVQH+YNee/uWx85gyJiJnjmnQTnugVKkivfybTFSIX7azc2lwynciTrI3s9MLp7nAY1gawPQg6gvCXT41yGd/TZUg5PDD12vfKkfshHi0 +xul2toxJZGWJdOI4tsp74TsWbN451S/2mv4mzXWOnMzN2SBH3r3k3aVuR3wUCE+9RCl1Xp7fEH5rfvQ2BS3vm20YdIfCGTchGf1VpnUl0R9jc6tnl7zNy+q1 ++PXeymrCFYrfYMSOUWWT8tf5KxzCowFDzw6a0DkXzWKrPODK3EB0hl5kxCaqOjYPTA4qfBUKho3pwB995zlB6W7IoL3SaRypkfW0M4I0snM7PqXHxhcTPn8z +XYgPC+MbEz9gD+nJbw2llJmLoiEiUtHzFZhj9lbBfB3yzvq+6nv0DPoi9X2vK50P6tFKx5z8qlRF+kOMdn8UXavZI4r40IKhhSXztuTHGV+b3ibWJ0mpDObH +Ap0g2UcJ0cdMuSROWtZFceCb8UWbz6cU/YNM7oeU2z13hL8QQ7AQmeF5yW7OK5ekvwXiE6rapwL2JztpFNVdZnx82wwdKCvZjr2KJAgnbtKc2jc8vkgwt1i6 +x4P2Ms/lAoY1Fb3nkXDak1Dw0Lrv6pmHFTwjCsuaTWRtzY4GHbdKvuC1qOuRFvnwvpQNgRfnZZbSKAJGgZEH+Xw337iuRHw4BmwUJD4PZffLH8H36YBeSyX9 +Cd8Lp0OX2Rg8CSsq9MjaDWXXVmOp9EPhsJ+dtIIqs6dWJtvZqB4HPsql8Ap9B3+TqqEFQ1LSSWjS4fKolRy2uFR6rvbzhkFZmUornm+TqvlD3HXf5nyh/dm9 +tmqzeFXE84eU6h1wmLTbDMpASIRThxE3NhC4uSE5fexbuHzU80ROnrvaXczV4N7IUKNarFINae0mWAa11G3sJdbKLIzspLIbtWBWDe5GoPBWje2ZUwZzW+8Z +pdUb86WQemM6/OQ/ql1z4eN9UrHHBrn8074awX5bW4EA3MKFjrU4e1WRUKaxv4xxcm7Uff9b1x6SqKcTlGaoa+GgKlgDGYtMRh9C9qolCUBC4Pow1jYWShmJ +GglGol9b3OwvMR03Xu34ZdaDGHjvjaYUK7uLrodjq3gfa/pKa/EwiHC3OUsa5EyA32aR5I/vGLIbfpwd9dIyr097CLQiw9m9++JPq6a2khlCng+8KL4hrFju +R0ax9DLs4+Z8Fjem2DxbMnH7GzTNIzzRYQG6UvUKuhtI2CgskNn8KfEsafDkZKinLZ0B+tz8eyZOkBMhmVUSj+70Jq9Ry9xa431ocdlHvLEQjJVZc+PXa7vS +gU4fWTWtfyoHNMIk2m955+gSfVGzddJDbdUYBjNl7Yn6FbpYfX0UjR+hFYjEx352hQgn/Z3C0EY9/z9DMEmoyvkefzq+UriU8HX/tsIULd/a+yTROCIk3vzG +BvT809qf0fMlwWPwaJkk4SNqBQw06SM05TSIPa+2xLkJuFOLmlyDaCw735BN+u0yzOc6AleUbAoXPYHEyuwR3xsbo8jKVXp7gE9mvrCvsufD1NWVPLo4/egb +jupVF4e5XUQYTGN2blWDK8iVLG2/KZoBZFVDxwWGblBgjelJmpcb/tOQ/df9w33j4itvJ0HYwW2OkXVuXEvzJjTf2q68wqR5ggYSNWoJL9MKdYNdWxFl7tY5 +lDMrVLXixrQ3nfiPH/tNcuaWfRGgCpiuDRr+/HB+Ra8FwgKKwpyd6tebeQovWnLpH/QQWaVoj2Tok6GEVEc4zJCLfLRzuRlHU9kYpmmF8fngSjIq3bGcBa2J +NZ5WQR2LSvytqK6dKsc3bdjB6+VrvCfczaN+07btonvnDgL2SKreX3z/iSQ5HYKYFBRzHyr9Foyg/UPivT83fYY0EGXDQsomzU5Zc3y1PLvTQnNklZgVVs9b +Cp+EVYHqKqmFXxsMPfOdhGqzMUbXgp2ZbbZYr3/Nh/V/dJcH9M7VDUxiFO0Q3fyniOYImfFoZbpGWq30n+J1zC1pqtOzHpnD3Q9cx4mNrN0Mwr/uriJ0NihI +DvBEcAgNB6AGPwYnHdQidWPA05BRbh4et0I1vRRBbALgx6XkGuR5FDmde5WWDgucW64+yHla5xf1lW+OXR5YF1G5HqxxpdL1WhRhgzJL2m9+ZLcEY1CL9AI+ +N153v8JPX3cgz9glVonq2EIPC0KySZ1zEEAJIWtpHeI3k7euM87Ve/UGU08Fp6erOD7jPwHxQJ27iZlkp3pjYBuZTPG7IcbJ4vs0I8dp1k3EAPamsBZsXF9b +Vr8w2eXyuQucDgbqSnUj3aeLItHhFL0t11zqVqJltex8ODM+sajRgr/2R8oaHT3dTJLWhMex3bVdNOlxfVLwXVDmyOefBB8BtrVIOGtOvud6PFVCSw7Xurfi +M1ypldLn63xD5mSea6r2qDcH5FLZiv+1GXtXbHgVRhlaPZ6nw2KExIFS4qaKVrdXFcXcDiYvZkcJa5K32GzvcOvqoTzVNNFVlj7waZTuCgxmaAOPQo/AcMuX +INQYi+ek3WFPnORZf1Uv3TTB7gjwkMo7zpMq6jFKpPb6hfWRis2Q7JHWmFRCXPfHh0yyEXzzTMqkOgfMIgm5kBubXYaIVwabM+mEAnAIee5FM70ATxu3rf4x +I6mnMYcr/Nstu/fpkSzkOSGpQjhoeYdLQnuRl50WHzjlbzvqAqxPD5UqBfohCSfFeQ/tk6YUCFJyEWcRVZ+pKrvlcPyZqlzg663S3cmdBKSLqhKLNpetUUWv +T2ENERhpM6yZTGJYV2Pe7vFKynqQffWyM7DQoheRrtNR8VY1jLN6oXYLea3AgdyVzjbAlxoTx9cIEfNoX0v0PSHyml8siqnjCagKIewuxtrc/OPiS1yPkg+M +3lhDlbitJeZE0I2qoKXIVFqFHeELVLZjD5KdyvYJKP0hlF0Aajk3hVv3+QqfgCKxwZycG2Okw/xrHdLfA4Kng2XDQtkrNQkuU6bJ/oGDgl/19HyCyOglhPxN +DCAL4HNng3gJXzajXQoOF3PAYPusiX5nA4fA3yYuW6ry1k0hutEA1Pv2OS2k164KsOev0vLAL0cbgVj5kYiNptuXZ7WmQCz9Hyu3DPrphS/J9CNM8FQnqvic +yzX/vPVTzVdjRwTOyKronpnLlRt1fDLWlRftI17BP7F7/VEGxAicMno2xesmLWMtSIYdkrU1r9/D57c/HmKR/MZy82lYH3MJS1mmcqKVpXsTNV3GDgQTmoxz +YZvVrREXEwH7OoMb+xClYga6n7pu9dheVc88GHdx6qOy9zeyGg1faZX2LPMYFS+Rf1HYxRp61rDyt0D3TYxy7LuDhbSd0/YjFusP10GVgtb3rdA72yMkLV5I +xckgMaGl38Yil5xJ0slXVbrGuLuJrkp1hfFkfcru1HaDjFc2kRpn1+iqlRD5gSsK0hsrVxHN1xGzEvF5VeYKjhYxE1jlXnD6MFl4Kxz98PPPmkhMS+hlU795 +BUeM8lujKXn9F1GEW/mlNFO7twlrbyuC10pV0VB5dad5U9unAGPn07Lnlagg+lO1ZOVLr/rx9I6DhJ/9HKQl+OCLppOuZbSoRc3jhYIz7rKs+GI/RCY7ubsC +d1OGOtFSbCj+iRFWBbmRsj0Z82DkcM2Y/T5Jyx/AOOnQMwvr5886REfGMn2wLFfC7Q+OlbHKVWDRnTDkq5PAJ3D7u6qc7PVjZDSF5hHnYRz69IgY/lxWVtYb +bKqjv8YZdANRf3MCFTg0kE9o7qa2pPK6S/gclFQ34s0lIrj3ysvNqpqqXuzY2z589W+Ge8piP94VHXkawLp/bon5lc0j6kjyLqeNvCorPgRpCQX5quRyjVQT +yuT3Xr+uPuiiTvPCSCIrUvvuyhoGKFdDW6NpcDoZkSx//9erFFuVw/CYF7tr51tBNydnECf5/k7waW/M8dSZRRmkeyQrugZznEbO/22ZnxFY1JNk8DRqPj4n +IbEtby72nTmBVpY9gN2FfO/h9xGVat7dSrz0885FSE3HKf3N1jAi1f1A4f8eYcPCD3K64a95/t8SJbsw/Qq0MZCMonzMoPjeCboTPN86RtKTTVbpOqi14LoE +/Tm/h9vaWJ9cgV3/385BF1VOxsx05+EpKCav/rAd8XIm7sva8f/vwvzXzZtZoOaZaXEiWtl2UkQpEW9+2Dp1CUfHf4kSKYkQYYFSseLw3VMujus2WRbZVBfx +LZsSLfbFBeeZ1KwUdWtivdXm68B5aE/n4fkJr2kY4TjgYwJg8Jida3G3JJxxZD1sADOTlSpefLQmB++ayJ6qavTx1izeNsUtlEab4iidbaWH4eq12zU65X60 +WiVm38baugbRsyvF1P40IFHtiihifqrybYvVVSa/uv3bWpMooJObh5W2MQFc42FHQCB6DLAIDwS9KqHUxz59/+nHvFISwkEuaC1w54406Wc/ISy6h3Y7IMaD +9xqEaBLwVnFhPk6/roci1W/LaUX9/8PoTW5oSOp5huCGWVZ6bQhcrCerDHoQR28Jq6koTAR1lJdUpHD4SXTkwJbIAh3tybwAmTqHBHP2hrKmJW5iFMWkKmdZ +WQ/pCf4IpbjzHSdYxbT1u62YXUQx0U/saHhsD/1woQHUwNgDTq4HSrApPGDk3HcjunDINlF0I6hzFMKhN3WWITe6QSjeFH03XxftDhJIKAYdMdtV3TCb6bzp +30FiIGsOP4x11azqX7lW3HSeMltwHaBgbCO4agDOWqBn/9bMoQ6xjkpldeiE1QgcpsU26tDfR3yefReL1I6gKDhLx2L7+W1hVSNMjUQ3/NoS8rfetkBHM9SN +fRodyH5uMPbuKXu/TKgo/b3horEUmXGnC8lr03cvNhdDH4HP59SG0PcZXacjsV3CbhehmxCCRFY1lXmrJxf+7If2/0DAc+wy/BvS4gmUTNVN+OCol0zmUgjF +kjaZ8sXo4HcGwa46zG9BZaFn9vfwEzu9RAz2S7UP6KjTrPDtzNK/mWCz6Ndf1SxEkMmpuVuHqF6SMRw3zTy9Zpf7ocHWFdhcdpRQEtoN4OQK6J3yzkquo9Mj +QQ6raqwNnlmHdb7M1wcnD0u1SDwTVOlrncXau61kphNCjrKlQ4L1rwQ6B6XuPPokeYH2o+re/ZSVkrUOpD/7jJc9Rq7qDYYrMH9sBvsvpGYCqrXYiqGWOSGO +RehA2gaJjZonjithcgB4TWsE1mqNVUw3/87Aw63M675Nv6PGlThp4OZ4ndNu42rJkpGaCqJW3543W4gKJg4/1faVZkSAsmim/hbOMdBvB43mXQysm+Pz9Ox3 +NIhXj0X2NAxGe+d5kinyVb6E/cxhcDXNIMEhApcFHeQ00Io4FXy7Y6aCD7JNwX0X/OLMuZ3OnM06l5e+Z2W4qQUlqvKAebZv1/QdpzA1Zced+YyPHfcZaJyI +A/pO18G+BxPMMSxQk8jqbUx9xaYqwB4ZZxpZrT04FlrN9Hn3XsIBx10E9x1Vs9RXaDX7fP95UUmC3Q9ErxMwYZmDsRnCe8t/9RJr9u6+UpfhafCeM+ZXIkOS +VSaInDM2VBUInd/6nZ8Ya57vk/WW93TRVtD/13ZhqmBRJ2s724q+hHguEoeJiF8m60bcXI/cDwnEj57VyTWvvqnnAfnTX9VTvfPgpuuRutxCC2IYsBMHgyDt +uKLD/JemghEGDwhI0k4+Pg4Jy4jxeFfWd1sYb+1sX02iHsLabEhqtMtQWsQJiNj1z030l+qwYA4hTI+4EnZOrP/3rPHy/ZPm7ZVo0xz8EjyDlsERF0IqmNKV +WcgxX5fS7yqc435arqxfzxBDyEphnCj5SDiMS0dO9RSHSsLhpuV11JWAOKzTTsWMhBtxukhv6UPjM9h2skFchl48VCIQzH0Jv6U+aKoL7lCxK409C80Dm8SQ +wFzWTVLNqqzEfhmvWa1zIJ7wPZQ5biWveprM4m8+hbkG2gcVWQV0dj04zunNO9PVLAkb9QS4+7aFfHjJjRkT0WFA0PGjb44uIvgmqjIRy5nGqAGiMBQxsYzo +NpC7543kOXFxQCXj6HYrgHyQcfK8Cs4h5+jPfdpWjo6BdLSykil5WJR9/5BBiWGq2163ytejhJrWKBf4Er/gc7WUX6FVl8dcYobW2kbsUURYwiNgZD+Jgn/f +mfggVn2NESNP1izm0UUs3NzYV1C2l8Pf9nPYIbLrp+om+1tYrAtONNuWlBNPHD+UX0hMBoD77JTXOlGEnKMJv2s1EhwOl50r182ZETpT3yLCQBB2FWVVJ1by +nnNQR6PMEVDG3225wMYi9cZXYhKNZjnlIg7WkGqgpIV1de1aLrDTSRKUBNb0OasZtKl11vyy81qrlSbJQSkmaDPh/fJ4FXjxOyqnEIK35lvrvk6y3s63q7Uy +k6qr2O9UNQ7uPiCwXdifal0dBkLaWc89IveWkZUHxpQ289GkdwKpnctpfasVftjfiRQnZKfOay7IzmMOkrZev8mAE2V47F5OIEQg7juZ9S+L+yeKzTbVsBmA +rl2QEMQiRGedl163oOVoKc+1d/G1BrBFqEyKgweBpQFvl1bZ8DbS1fH/upWDmBCaQKMSnsp0Dol+dUzIjO/FSRNLNkhE70sqnz692bnlMsp3KH2CX0K5n/TS +ovxewX3KdNjqsQcx5grdZecgTI5UjfpAp5GxtVC1U+VtNH/CFsWnCDu2KrI3UFtu6kKIaaW/p47RbK/q6fWB6PApHVI4Q/hDa3MrmEfVE+JB0K6TBzsE6wj+ +V78QDzQPIWuH7drv6ndyUbnJp93k23Qt6TpA4Va8oC1ui6AYtDweGHV2OrffRlk8otu+AzqMFiKqevqGGvwK049oZfGbxSQ7mnJSldIIc5lCYdLMz7hlJyvw +i/N0rSaEYcDnM7PLJl+oiWrFWMeaKVKyaNxB2yS58aXTMrIwg1gVdfG8tJ25byZ4Og2RSvzATnol54yyn8HkVJ6hKiiLkoFToTiQ0tLi3qZ4lifIlCJ04oEb +sUHaI1OfEJgGO4S5S1dWJTxRob6p3t3iHotkSws3uokMfdSAnZJe9bpFX4PGNGUehzQ2JGuC6qWTCxy76m4mJriVw8ZFG0S+jGWKsiGgn3rRrpvOCFS1+Vfc +9pSNekKJV9dqbzTMLYQ4mIQxn+jKifxioXSpFbj1wWiqTqVTmVXKcqnFI0zHKiqqcpENq7/T7xm2Uzr2A+9wfxtafG2Z9bZsnDce36nCbzWXAr3uzJlPJTXX +/y7eTnBt4i/Mz74ZZ0nXeIFHpasVBksbfjpgs4YEKPTKYvilx5iUC3FsI8RRPZdUNmw2qgKAhzREiZut7LfD2awEJ3OlMQqGeEdyEynflOk1V05dwOQ09qWc +I0VedIfjYBhZL11g52cohP+8FOlFqsHkMCH8x0g9A6rpYHy2gpRQ+Rcax5FqG8Tb93xzaGuGW3DAk5FVywHzEu6b3UQW6ObDKh/ibn5+zkipx4X530JKC9Bt +9hd7RoSZaBifkBRobAlNAxgvzR0/k22PVT3K/SZ7H+OdzXb3SfsH49L0H9Plz/Ut98VNP7TPIDp/R9TvtSbsHN5EE1JaW/bVDufjqblY8gkRbQnwaj1/IuYR +5nB0jLqgR2IxLD+vrOnhz+GC+Q6qSF8g1K0xCNWrSrfbEu1BigRrbWO63HBSkHnZH7ztj+idHliTI5q+5wVHPOiUmsi58V7R2zGOVyZb8Ss6zlcUYzPQrmC1 +Y8YxtJH8fEazvaLoAKRnHiPXDeQVySaRMSiFE9gsuimEVjaZlmtjY4xf10iH3q+SwBiiwmwpuNMuZSxC+7xtFfqtTG4EuluWzltsT/iyn/N6o3w7Wc8ENFnc +KW4qUMIp92996IzZH01Qf8DH/3EP6STvBtK9BhtMmBdgpqrgSlPJ89wxYvP9VcGWFsVLHZNSgM/UU7IwvEAX9JoCcXprvZE+wq7ecMGBIpOv5Gof3bFlQ2Vp +iuygtEGc6FlzYaj6cvmhkxOqFIMe1iQEtELfDwRViU+71OCv8IfDba4eghy8Vo5K6iyH6Ez3HfNDyiBZhpmLVaWACIAMG2yt+5ThYZ7rPZXFBtHLMkvjBohq +0I+VUfDlAFx4cTAokJo7LGjxaRwlGlcS5zP9Gc2iXOP7zWjU9TTYT2eM3+DFPEpniv46khZqnvwIRd5byqHYGklwxmu+ugklEbJxKZvnUE/vPcV2oyqj+/si +t6CjyktWw7StyHAI4UuPx0M1XsKXz4i8PMYeMKDSG0LtdLTQutiNtFd85RrpnkkABGtnvgZo92tn5/otFJJaSjRJd6NqV0LVl3n/ChR2tyD0VHBPHiHulKXT +SNaYiEMnVTSO2knBDghcwWhHsDXIUcsqjQWXvIKtJGInLN+G36wkdPJwt9T3X//hiO8jk04rji4zfmJ21JC6kSSr5A6hfq4O2CWph9nU/4+pBfNrA12B9qEb +9L46AHOaTFsoQvXgZkY2PBBjDBRqA6Z3Et1OdfHinj3RwtZWCf8PCPOpan6WgsovraOPDFNC63JhMEkTIVNp+WyvYOY90wG2LZ2WLFpZusF9qi+pGJuoiY7w +akPI4K2Z25SPuBxTBemha9dk9OnumO5x52QqoTcR6TACTe4oawYUuU5SLThcwvKyoDC4V0ogv95Hmi1x4iOWBafcX8EPH18NvSUg1F7zR8AZDtNegN8buIAU +AVfa2EXqABXVfWL4UjZl+8Izi21TjtONLNdM1z34JBdBdj26n12niUUioYqZFgndg2jOrgxSfx0HAWTPA86TKLhqdJ6wwvVLAncqOLf/ZOOSXi0Q8Oapkk/H +McqG/TfcnftTV0QSn086Ogka2R0KSUpe7xLiLEnm30hlxedymKDK2ybC63pfwK/mpClYyxqc19KP08CDfz2vWfbLg564W1D3NxnrC6oa06h7n7AZqzT55E2d +J8RkS7SfQY5h5kKCOd13GGNRv77FUOtUtscIHitvIahyAo9o29wCPmuyjUQ2zG4YWLpvFk8x/e5X/o6R7pGq70v4PFNQRSlvM5T+XcmNcMjGfvPIs0/IX058 +8jkEneCnbZ+5bG6E6l5bItKRjx0k735KjFR2isbzp85KzaRDO0urYDYGxt2rFhhq+HlPlhtoiWx/kaPbp+5RU1XSOEwwVbWV6IXdK8z7WmQtk3tAdFpLv1Ai +Yi49RGXH7nlora4BxA33chR98DK3mS6ZDkFk7U5QJEVDCKZNrPpwmBhEuCsOeCMqzal/j7RE1nSWzkaxENTESQJowb0BDyt2KsMICeZinIQtpfLn6nuge9K1 +HisnU67cdNa6eDiG2rVCYzPx6ojYOQZP/yHF7v3DX0fVIeKRcGyHmrnrWNRn+NDEzkuSMcZ5f+8L409WTm05+SuxEw4Eh0J2eCW9rmv6vVIud4rkTniUSpCu +iMgzP3thaxGZegbv7eeCGWQrX3D5JmbqPV47gWpwEfUaZ4xiXnwk6hP/Ykr5XGz15+J8npHJqw3t4dqU8WdW08cMtKRskg2YrduCWQJia5xbDspmzrxY4RMF +OielAAW7NBv/x6n4TyABxPta/U+PQLqNI9jR1d8X+w2HF+uNRlU7Ljq1xMir8SIiDR5DvnavbsJOfBnsVKIDr25Vz839g7cWApbO/5wjkwt/J8DwbQlh9G9i +4j0SdUnuDkS+A+siNafKjVlswoCrhP3uO7T2DmMc1ojGt2WGGDRhnkq9nbc+dN53Ftf7oL5f4LDKyjB7HmgKlbvaBzhqGt201tW/Osoen3bXZ0e3kjZi8enT +RnecbVgc6iGaIk2T8o4//c5zMS/0fIgbmGfg98V5I/FcNdTSglo2eeRfPtmkQ7ucifO616Xoz5+ZBXUzGqzyU/arh74J9VFW0RMv1TeIYgUd16r4YtSBA+cj +7kCwHXa5E4tTyQkESpUUJ0gRuhCmWB15AGzN1LCNioKhneeb4s5Szj+t4U7LjgAVG8D3IUofuNtTp8V6DK8oOoGrGbfriTYU77ADdIOI3yNii+Jel8Mr78g3 +QzoXB/z+D9BC/fS6zqde8ufG+hkZUNceEtCh+KZtultIl94hk7/VdHpaXW97DvLOpyYb92iJZEOauVAj9VyaIi2/ehzW2Qvse4pQ22vQ6XwJX6BSbnG+VIN9 ++8P8hfJFHTslsRnNZOfaqbU5pEQnGfNo2brK0cQCZCDSOV9qSkN3OoFxxi+yx0qDGYuDvcf+1kjoEPBgvdveS353j0BobCdk0UwjNceZDerC2uncoO7qdXKe +Pp8SIa7sIGEacbjQb0hded/vJHC+qseoms6Pba3U8f3QTVIAFKc4c8GGlSq/Fhv4rnTGqrsjKEOQkzhHreHk2d5PA5qc34E74vuLw15/9hKL5B+TGDJNJssm +iNU+RbUipl7LzRbiLaSfkqw86cZWqw7d/u5Ov9//s/7RXkx1/PPkx29Ih/qmDqt/pDgWD/plS/SmEmnQzXk/775OlwsZJ4PeswAPz1l2XXDYTEMsL6sKb3eu +xaILePuC4iEmvhIg5nG40Cq10qzaI8gHkh4/cvmb52KG8SHaRqBycI5NJjYttT2PjD8orKw+jlMn+mt4MAE6b45L/Pcq4VX1SYH532FCFjKmZu/eIBNNyQ89 +d4weOlpvDBS1oDFDz+gpv8/ZykXvLdD0q+Tc8BgZQKBPc+mbTvPjr6J7NWdchCsRd6GsoqYWBC5EsESDoZrw8s44Mwp+UjrJwDpKRucL02qMC/8/dySGl20t +LR+TUcGlRJ7mJUuI2l8OZSukOt0HFyIKFsV48wWqsOfyo/iEg9P0JVGR38eTyJlLqYxUb2/3ALYnF1L7/2pYnf2M1WdY41ECHzqJvi+oaOv+HbHOJn+i3Zjv +y0EjXelCaV8KMnsmZsR/HqJ7/OE3jpjDBkniXDaln8uBvNbRAa2gVRL09SUTozTh4YrYq0IfoTnQqsNq3BScm1T4xsbctFoXVOWpbKzV1NNBqhy88jUmB6UM +GKrNHsPStwuyaY+QEcRo5CYs0JtHzvG67PW+5w9Fc0v0FE9EHI3xn7ULVO5+ehnOq7xXIIc//B8t1nFAeKWrQKUSyFphYyk2cvjVfM4FQF1ujLr5dNP16sTq +oIQitHReq4w57bYI8YTOS55rq3IjmDBhYzJydzPBX3MV4tsuCW1HKse52JOxEpazT5TNJnG4KsQKUHflP1qT90kNWl/m3OTcIUkGVpafD3aCFT2ZNUlVLlk6 +KJb0Yo1qVXP181DmWBzOoR46pwUBTugSUn7RDb8qg1tiCy9t0E3RnqobazcWifvC5zs3KBnUDkD9VUTak85R4KY0k72brmPqmReCxNLVrYjsHkXjTc6zl5tb +j4F5LAHrfcqE75+7r70ijOsN3WZEKHF4SRs0pD+acxLa6DeL8j/1d6Plr6bmIzqhN712jKp4LLN7rBJjmorQDrwbdKmgyAKXUlsMYRv/Sl8eCeGsrGoyAfxP +FUUmVEQQJsQphZiQ82LE/VP88widWxdYCKrgusiYk848uwRdQokeWFq7NrOuVP1EpDfpjNV8MsUUPNBzwusfTSG6u9Ju/0c4seVT0o25ILZDyXrkCVEk3lkb +xb2pElh/3Zk83xmeKq86PHaJE37ph+mairM/LSWc/KMeC8ZOHIquIDYD2eVyKPeLKQl0OxjrxvS0lHyjpqYW6XaIzuUOfgIY8OcZ5wIadlee6A050S/y9AOR +G89D0c27ac0G4d5kYGy2ON2g5Vplgab0qj9yNvuQUQokG1VrErh1beqVwY8wtxhJXNnjzQPMzgMjTULinAPyLdc+BzUsvCSCEW1Poxm9papbI44GQlRfcvlX +XQFuq1+E3IfIV8r0YMA2p215iH9HtnwK+TsE1W+Zj+fI6ay07OfQXsixVGbhLkHgSVJJeKEOWUmyl0gNMNArcKuo87a9A70kz5L/bFnFXEPX1tTK+y3cZTPX +eevkbIgiubzw/ZOLPjd1r4LgoudZcdeSgvBrOo3LT3zZnPallC89B7abXKwV5nMxL9z3ednwDfrsV0Sm6jLTwJ+k3O388Ne16EMQcXWJKM6qUrngUZ1e95g3 +ZTym7suvPgIO4428nXwH629pkC9zTdvc4UceTpCGTtt2Ah7i1Tq0ep7qvRomKmvDyEfCHocajok5YecUNM2DOg0RrkyGSSssimjIQMmSG380VAZRT7kDCIfj +MNwYBEsg2Lcy10LIrwI3zis6mgPh6ZxT2Uh41H6XagSH58Z7XRu++qcbNb2RxxduslkkPEteV5dXsJT8DrFICvRVvX0tgjt9hSP5j+IvJ2K/2FD0lw1jmviw +IBJV9wC9LpWa36U8xrr9nIbXw0mogq2mmifVIZu6paiq1Jf5fTLlhuP8VESq0kav9Ll/6wXo9yXfW3HBFUpWfdmitJizR4tT7qntXDsucwszUTXM7ByTjKkZ +8D5WJ+tWf5VnSMzC1jwHeiKTVEhBUabelcZwuidLiKZd1/W6U5J5MslNUhhsRIcrXwAVXa+6YO+vgi+Jhg9cfA1irCDgQPjvrsMq1uLQP4YqRS/jaKqYiTPh +GnvN4NfnfDwt3KsGBq8A2jpVdSXHGpPh0LwGA1FhtspF0U/7jhXMmC7JGqLwtgv5qu0SZB4qJiSzxF9QZr/M4P4htizGh7VKDJ7W4ysRDCrX+BFppyRgfaFP +reMl8bwylHxR9Lvhmn7OdTmCoxBsqCSJGCI9XeFGOJp6ZQxySw4vmGHReTsUcIhI+MyjlNwpwRH5eDwnANN/1aNTNKIhlAwJTx5UdmSKsoTr8bzLVVDxsJAC +tgMoxnZCW6vKVNfOJAfVXeGAx8cYbL6JIF+nOsPOR/q6N0UF9CKR0wHGWOfAvDgs6iDJ5zER/gdlmewehbibV1vJHW1hY3NmvRnd8susuRqhrUaGR/cenZQC +lyRFjTaVTwAJK6GGwzRtV/wjVUdAMpHdJlv13GSC0VA8E99YjWhdQdg5xJWhoRfviZkhNx8DTfXsf8b7lXQskrQgfs0uCVGwO1/6I9BEKOREUuNRdOfc5HwP +J6PTAP2qJuP6rGu2nxpPiRvyAAqfFOde2UZpRQOxEfKrm76r4IZhYJFYDz6BYD10d1BjGIC49t/WU8qICxbO6aQyv4m6rkpdFwY32bJhw0HTxeF6YT8dvvCH +hCQ+ud1sLhq5ElaXGHVm6aZOZhepTxCiXzvBUT6xvMBhjflAcVanooL3/q9dhaobGeelWGtDn1aGtm156w6kQy96UxF1I1ZqyWdzA90AhOMVRcgPkN2mClTi +IKBkqfrOv7IhQuYUvRmxsEI186zt8p+lQKHnlNPLAD6q/y0X/QNxH5+HJvwljNO+bl6o0xKax+TtIdiG/u6KVjFPBhsoC6vEOFmnAjL6GHCQj+BYWGM1SN7T +omn6TWbAZ4rylEXMeIBhgyxDdenlYhSJpRciTePYKRjoTWhgpgVxR5v6/yuYzTjWozM6ldtlFkRTUAMi02FqKKbsK0epfJLaZ8ogn+VSt6t+M2h2Af6bul8o +/0uHYLhmwR9ikBrZGrtut84Y92kDuShdqsPpWYwj/qZ7CIO5D4A3YIO09tmVrf66/RYEN4YbOGklmVwE5M2peiNEKwoLTyS9Jyc2pBX26q0FflmUy+dJ9lKr +5KLuYjbeh7Yd0agBkQnlMK1qH9UI3pbBv3u6NzfbNrINyQBxtqkVWvVteouFtW+mbAp090e/T9Me2+dp840/od/nL9Kk84Ch6i26rcigJWMj1gG0sCZNBR9D +sVq3P5Cn3KaaxLGUdPcGHzv6iI1SGiZtcWJS113pfKLtvfrt8IVa/AON2a/vP/UpW9c8RKpi7bGTkFDJslWVHM1Y5PL9qWrVt3ToxkyG963ceMySu3RfyMZX +XgBZHaKoA4hYUOUT4KmnihzULanVNeYT2VufxC84OUTRZwf4w972aMHfrwdJYDO7UOIlwMOgwtQ199RL3gHuMmkG9p4bxNKapAUwLOjERrDNb7C7P/JvnOqo +iojzLTLr6Cas1JkkxXECnb12ZOzQCEO4sZc+ZRgKfUwOQKF5rsPyreWysjlYjdEXcjkntwvnu0rL64bzVtnAlg5SNSGVROL+kNR+MOb/Toxj1/SDENclPYCU +DAYGVL1RCtf02KyGgyhRDVjAXpE3hIxW7R3HMGKpTILU1O7zlJcsc8vqeCRGIX4hTiJUfH/RdYS3sLoVBoaXjDXtBg1tfXaGwhcWHClgwkX1gX5tCn7y98fL +AUi0X1TYa4iDEd6ilbVEqgF19BmqYWTmODmVQ1fs89qg3DDhpmh7sY+Y3zhZlIaZ89YIrNkCVbxLXXql+7Z7LoRaRIhNlEbGmNxpjdT4mBojPdsWmFAr3tUT +qh6xK9DICN8A/UMZRm/xOEP28mhqgP/IpLorKBdmKgqLGb/WCgXYz+nYoJKPjrAyJe55+nRfWX3eEETWKNOZ8DH2icmu+v81NSjXWH9NXqyT67XwYjvk5ZMP +Rb6b81Jq5TBrQhvRtgzWNVqHu/80Q36+mfvsSO5XXbCfKX13xnb58zfRZwWoCA+d7c7fJjG2Zlo47NNV5kIc4Kpk9NmScpOX6H1Y8w0yy0NabRVKGLPMtRDU +EH0PviqzROc+1f1D83NyO8Bj83bhUQz8+nH/Q9AbIejHhEe5ifl67l0Puoo+TT2Gmj8hUa1tpza3Q45DYmatgjKLk5a52so7iqZpmVQcNkzduTeu+CaRZxcz +JhMXRvfWt7X7jUMe/NzRhWvEmCkLnc9cn9i4N7pwwW8pSTGrrPTkW6T2uVTxXwVeiNXdItVi4pGg8cOAi4oQPIJP++NzsaFAR/PMov/bMky/p+0XpsatrF9T +2WsC6LCu1t9DLOwLTPWmGWIFhlnm+6d71PP0uPy+7HLLt4o2zGGvMdZG9VYnDs42s2T9LDWavqaB0pSnkwbwCBUpymJS/AK6jiKGFx426FU2rfEIQx9sTP8E +5TROTZFu/bpgv9kktK8Pz1V2JlvHd4kV46J4oLVx9V/3D1SeVxMthz6AaKRr4ue9gjGCzdL/qRgYnqIG0gMEqm5kNC+8bPnSbDX+w96EDb6dnJC34TzZnKp6 +MWTXZMeqZJjUcVkw/itqfZ3gnZQjkU5SchbmyEr92tOkaEbYRIA7xdlkEoM4qvwj+hqKiHj26jAdd4FfUxO8HydzcflWwqF/zhhUFfBTPNvDXmqtMTNzZNit +Glx6J4t2ywbp3k2/3UOxna69j7sQtSEO17UwAqjvicbGGH/iVdZzjDATrZG1kZEumuxl3PUo1xnjD+4ueGmxcRkaib9h/Mv+kFb25ggHXvCwlfGxeAQHATyH +9RXVWTlvb3aJoRki5wmsuqwOKshUBWrQIxqUpLCA9HtQLqhkXCTJLtRUjtr5N2rGubMGUvgYg+dmt0yI8M4905EJXmU8C1SG/rq4Tv13ZPT4f2pwjDVId1ww +vTvHawK8sQG3Zw3ezXeV5/JDSBLcocMpJnb6AKi50xnR9ybqa1AkQfBUnFEIXHT3TFPEtav213xF8ywr9uzGQGiTiHhm9722aGv9C0rnD307fr+tf3DS1n+p +HjUe8xjsVRhjtAZTiL0JlcoI/z0w0+SDbnbL0rQWWNCc/PooFrHfuk/pb8BknVPiRThFGy3lHQ76dNIcAum3ZpQf+NJ18pxQXp8ZKuVrhYrvRn4LecfzRtYK +8I6SRDJQNHEMkFW61nREu/KQWD2NvidojKhceW9YKmkTtVe8VT+UCM1h4UEoUEggFcsw1x2ol2TZtpl3XxcNUk5vaVHbBxhoVZGX2D3dSdLNwX4zmxGOxFMy +114cNadxSXn0qnqx+767kL+fJJyttZho5iXjLQ0XRNBqRNQude3d7QeQKR+KIESDr5fpkKr8RJFo/7y/qPClKvTqWlL2CQ4BVbRwgbHF4hQCtoLuehBKv2yJ +Q1dLFRGwzFnNAzl3q0P/6FOOKFNHNxgwFKAWnMyK0Tse/LOJv1KD8UEYRRRl7roWUH3pZNhYXMBY5Pa2ncjhHTaFpzO0eFfpJfBd4IToiULZzK1X5GrRl0ck +8eiX9U5V4dBogR6j5Gr7MXMzS/KkdeG1s8PNfDMJnpCGKIg78PnLCuQ9T4ouXKg4u6caq0qlmOc7EGS/ZE5tPFiJno+6EvMSf0GFL8DHfxH6vCQWtLeoyacS +ttAeTtdpfbsXukKXqI+P0JeWNke+uHP4NqCGMnVH2aO/dd9QW8p142eXhgk82DQtLGHUSCEoOHoctX91MVXstYa1pVeZLDBM5mXO3tN6Ch5+qhGq9Bd1/JQm +/HISUSjU5BPKeFBGpCQ5WEGfX0xkR3tptzRt9cHkPBu8xBjlDtRfhPUzCZw+8RNwmG4ak7CIo7OZN7zv+4Ae8418mLKNomTXvVnz41QdLjNTatQ2Zco2mY7D +3lSULpXIeeDKjbClys3ASwjcTlXgr5v47VSyzVKMcSdMEuX8hZpsOa2ckqkbeUbEgEREkvrwp8JNAfWMshZCo5Npsoej2rmfQuVnOAmcl4r3D6I4JihMHDiE +hP3MvOegwgj/o6rxBzBSPo1oOF5aOpOyKfGTv4z29CS+Q+HTQxDTAl20OlC9ZHB/PlkGFJS1ZTs/n6m0MaEYrvZRzHOuUkhjTHWBh43h6124S8RjS55R2Ubb +cD6Iou0H8zYdeNqPlmm81pMOYweNlqC1+bhDRJ+cEAqawh/ESs+5wUhBH/SE8M2Qxgp1v1x6QBtU+YA82kmWHa+nZapejR9jaDzcFJja44x4mlKGqHeqMi0J +gXbD32SXoPikErBK0zhzj/rikbVle3OLReZYu4PnTtW8+/qZ/SGJywg7MnInqc0VXrXtZ9dnfgt8tYPL3rxzmSxcIXMzxuQ9E7SOHR668v4MZFVJxPqslabw +Wr+t5BW2w1Z4cCFNqBbylBwWrSLiIELbEFx43TouLSugNVmf9EqAAWK20Jm0rt6PMwqTxrAIeFMIJWI195YbD2DVaiWkaRwbhlzURZGRx9uTkpI9KrXEhL0q +AwRLOk6x5G59KDWorCHbxI3N7WZwxjBcqD7jYHM9g6t6YmLu+48B4we0NovqZcv6q7WPpw9iCQVU8aextQ/MhvqDOO/DkHTWg0AT4lqZx1cQrafL6WzhMbzt +Dv1VNhXr1NDhPdNuQqyxBU8lZPdFYSP0nGIyX6Q6s/994MdVGJHashlM/qfz+2ZPGyNLaOOgzEodwJOxae/qEveF/cG+5gC99SXVqOMwoqsl3TU6rFT90To4 +VCl025fCs3Re8WXwXrnSOmgjANnbgj7O8DU8WSHYw+KOd1PSNNxvqYE74Sf6T+UZisK65XXFGGEkLHjuNEdsX499uEU6XoypR9K57dC2JxCZ70p/gRt1xT63 +auZBndbkxYLwpS8NDg/gg5Ey3VsiNylei4rj5WFNVKPbmKRrTiFkbBTNpRlBomkkYsID4CdBwu8AiYXsj9gEc+/eRlHwg7YVbDK++K41pDaYYaeDHmC3sFaJ +JixBx9UJb/w98nfEbCWk2cOI4iSD/6LfR+q/FKJacl8qb2CsfmT7n4QCvuLEys6hvK0QSiDMFYGfuzGL9kEbQFy8Uw6gFGd7V7zTDw/Clfp7q8a/b/xQeTUi +Be0SNjYBAzV1hAIdlegxD/Dqv9dTtmztyvJXfmNS5hTRVJ32ytvRbriWaFWsjnwAmJH+Ih9wHz92ng9r3deG97ReOwe7VGhDuOB5bljiR3xj6XifGAv5KFWH +n6KteZbYsOewhEkavixbCtrCwUdJhadZKW7JvOsIzXKVtfl9QqAVlVoOXvp1Re3+oKmQXZTskSnnZ9ZLK/jGFMFysJoW0gCkrxt1tiSEV51lyOf2NRaq6MIb +kLQIkC32Nwr1lj+5wPYW/vv5AehxS4A4d2B/U2mVZF1+lade8BGXVNZIFKiRfk+RELtbhzudJsll3OLU6RBatvNQxX6QF1Sm/Wd0NiW8LqR31E3wc9n5t01c +xs8RfxAYN7yALqxaErdNxj/x+KyQ1zW2kwX881NSKtFcwroOLNsYSEeo3worGmFysWv2OqRlHxg2lX5kt0Helx8UTHVsnZbP82oNDK2bBIg0Qx/7xPLVKL6G +nPU8twOpMlEoQsfP+SFuIudFrzhgB/HryzzR99CRrKsV6Q3/S9UhmaVa/Sy/I81CVX/eJQ79+4l+OtKrAggzrkJkNg4Wc7p60yJb+bAqugTwZxkqP8F/4ApQ +exmXA9dH6b2iO11QBaQvVQl2DAPWA4tsVDNgH+4KhpPp9LC0YPlVZlWCvLDHp3UtMNztQrHMYc+rLUIxG66KlvWRvIVPHf9VNS6kTsdqPg1DpjDBmK/wq0TY +Y6b61zyguGVpH4gJ3GxnhfkFCQnQapjoeOglWoPJBo08ddhQo44beAtE+7BMqyxfYm5NMkNJmErtFo7xpbXJEWq95n47VevX/hL18xG9v19Fz69A6LIhim0Y +q+K/ozaW/USgI0wbPZUl0BmRaSYpNvCQh78URjYcHiw9tdfdYJKd/d1VHS0TzeBc8MKX76qlgh5mW0CIgERGqSA9JQqdBL3z3X0RMPc0OyXbRVVIlF31+6n/ +cb75Xd1Rq7StrzOmjZ9Bav8v/uWF0z5PRWdPDy/TAuLcuFdQ/9zaKNCMaI3BU8gM7H7WlxAj/OpAdndCICb4iGAcYoo8Lb0PT3AQqu3XCGeRh649O5H3zgz2 +O3dZOd49f/UQlQis87R+ryfLwMGgAFHTNtuBdkM8sw8/syt41ypWoYJDJ3YC3e/v1rMZJCzhL0jm7eZbxXWjpyH9h35Jc6DYUveFvCYyUq4vsfaPdS0Zeuq0 +ZMYqxWGvkJ7PpmHGnlvP6xdzuGFaS3nfK+dHDy8tzSVISfYmmf9WDcwQX9RbMv5LyVtKK/uMoIviX88FHtWev8YfG0StHVgVfjZwcOQMMLfT814PX2l2zdA5 +jYdbXcyhkutf1Sg7KsHSX00MGzPTNqcI2Mw3tU3B17H7GhzJdI6ivjkklpffBqW0W8RwXpgg671By6kfhsilZRHXXN8kUAJrN5jmyib3IE/yn2SgLT2l9123 +M+DfZH0/uvptoTNQK5i53ERS/H08Fdjh0u4dN6BDrysjE7Dk93XDjzMPqnw2RF3bm75jchSZL3/jfmtSI2v+e37ZQvrqjWt98t4VIWQs4DqnVlBOr2zUfrut +WNTQbZ2BFPCfCqmdzQHTIvcpj3Vrn1vzE/446+zW6K7UzDSeSpfBtoRz0rlGkhHuzM4VqSL0jMYavgJhfauMM5s+IS6WzF6ZR9d/Y9quJqfFB0Yume4mZ1aM +sP4QaR4K0HTWC1dVng5yy51XD6bxdbYRaf1hGYfgehtOSGi3lTV3i7gBYt6L9nEuQYfh1DPMl3BfA1X3dSTRZKr0VWvMvNbBv59QJI7MLhVmm1Yv1Wy7j7O4 +d9Y3X1W+9u4ZYFE2FOl+KmRWJUN7wkFltDl3VeiWgCt7kA8Dp/NXUQ769iIw84Y0Ijykj0oMnlRgVYVBQ+Mvssa2Ug61nCAQYGzMkoqH2/ZpqUyN8Vq7bKbZ +n0KjnZvoxNgfbW5q3aXJn5Ody7jXdhW11IGF/ymJa9OdlEBNFhwHwU2MuUYpOZrLCiZvJRdjp0N7qc56/a3HjhfTMcoz83nqZNwvLh4HMC2KEMtUTigPUDVE +soiUp3x+gdFddX7mKCkto6+gwcdCOKJ4FitIJ1hm2sgleZfCDr94gVjwZWH4KUnkgei/5ZWbvoNuyVUEqBUGvTF+E2jTnt/ZmiTJRZ+590hSR9NY2UyDL5Vx +0M4XAcAT3arkpxPPrp/CTaVfCtG9U5HEAKrCx8mnpt+UP5vQtHLCv2OuWe4opHWdYhSU5VQFqhP/AyEwW0uToQ0T/eZkih8G/76UfPnoO+jP5aVZoR/q42RX +OwhGhfpjdJwI1sRjouxrc/4gsDcLSJvzyVUO3SYGrzoPKzxww3iUxgdXYFeRVpXpt+l8rVX5EbyBlpiycBpJ3eSqWr9O8XwqceQuZx0vDaU3cLIdWW6gkXA/ +GcKoZzWrXzSmNgLcn8EuTD8HmBE5/aJXd+BEXm4UNoq7glSZ9jYM9iHGOh4E5/q86paT4HSug9PwcxODHflq6WEHG9zM3T2HXZl1d6G4Au88UlhF9qnyfjuW +a8T/Aw1jDKn+qy87akJ/KR2j2kuBgaDq/yU/Zc0LsKux5ePzi5j8deDhPeiQHvgbZeAKmAFU1WHPQUu0NQyv3tFIu14zH+/i8lUTWbHGRgxe2s4lh1V82dc/ +abnPD22w7/YZKyQP4zuYcJx2c1eVSgzakaIy1dyJsJx9Bc7tvo0hnz8Z4r5eudIv/ahiDZrBJA3tt7wLryRxKHpT7vY8zg4Y8Q9RTzSwBvY5a3mo+icZ6lKk +NmeZGeiaUNISwdQH5AJCKiWI1NaxmOcGHVN2T1MP6axrynaJLhwDZg2GYPDEF94OmOXnEfPoN1q1Z4Es6vn6yO9JiOGxNW1bGhaYZU7lMPV3jwPwnyzBeL/o +qrZmwiSuy2seYUfx2cuAQhffwgol2sPU+Y72VG6+p7vLLcfYtDcndKix1t9lu3eLre0GXkeCTPPHdsTuJ+0a8HZbTe3fUrCmvRAPk9diBXyshlt8sY6jUuk9 +iAQ7xHlctdlkGrfUfxNVS9gv+lmMBj1NKDwjM83Flo7s4vGbBbCrusgG164ZrGWM5mzPeITUIxy+I9npTU0SY/0pG+RhRyqrfmbHIzclzo5jIeerta33pfdN +Jq9gVqqFeU/TRQbVJ8jb47W+sw9lPpGLiOlu+r1Uv+rPcVDAkJhXrmvbRjQCfRa3nuGtdXVYKMo9ELyhsE2NNmntVb3O3cZ8UcGd5c6K1XdYvydF3+/W9zWj +VSWue0DYqYnbeUsJInC5S8NdtRCemGNO9PkH8mJudRFYdNFlF9yzCIRDh94k6mZT0ZNRhtC607XEiU3sRSgLP4/bR6TjgfqMgdsjVKUiu7imVQTg3zyOahV1 +CQN55xAXsB6Q0gQZj+2EjKfJ/lR+gPfPx4XF5JFyyRVtqm9w3QQxt+W6xhkgOH3vvyoBemQNUA2KKFyFr2aV8xft0Fp2c1V1cDkkWnTN2sP43vdSwLHeeg2X +j1GZKBHETBhtNcP2F1Gq2NFSJ0iYhu/ISaiKylsCHhgW4spK+oRL99nSvwWiNOBLlJn+ALEVqSRvfHqOdnQyuSnBdJp3xM7eFPjvTOR55R5JWe6ZxMg2qbho +U3YjHMmAzBLW/UmjrNmfTuB6zkqpcN5GQQRQPd2ABULNRNSP6+AbhTlajmQRwWZeSVk+/mLqRhcv2yyo0lvZg4xAjTrkSUHbITIF+ntob78hp3VXHTidNU1t +bQ5IIbNU89+jDu+Orv5cU5PbIogq3LV3cA4azyDMcNsPTrsjOJnci5y5olK79biR1kp25+24NI/W+xTcwvBSdw5DhK7Zxi4eTcyuDc17VpOt+4yxzwmmrQP7 +xi9RZxTvXgHrepIxQ4Xz3ZfP7wBykS2XYjlq26s6q/4BWPXw1j1/gCCc/KmZgcCQkLqOfv2XxMHrqwWk78qeFkU45XiMfHQuJqcLrVFBaT7KQmPFJfQK+yMT +aX5t26pRlVWtGxxCBEYqpfsNJIeqEY1FOhUzuoJwV+e+MvwH