From cbe1896d5646e4bd2e13b4868e2ece4356557e23 Mon Sep 17 00:00:00 2001 From: liyunze <50455574+liyunze-coding@users.noreply.github.com> Date: Wed, 17 Jun 2026 12:52:57 +1000 Subject: [PATCH] customisable responses --- Code.cs | 225 +++++++++++++++++++++++++++++++---------------- RythonTaskBot.sb | 2 +- 2 files changed, 152 insertions(+), 75 deletions(-) diff --git a/Code.cs b/Code.cs index 857a31e..08dbf28 100644 --- a/Code.cs +++ b/Code.cs @@ -178,7 +178,7 @@ public static class TaskHelpers validEditInput = false; if (!hasFocusedTask) { - return new Response<(int, string)>(false, default, "❌ Error: Not enough arguments, try !edit "); + return new Response<(int, string)>(false, default, BotResponses.EditNotEnoughArguments); } } @@ -189,7 +189,7 @@ public static class TaskHelpers validEditInput = false; if (!hasFocusedTask) { - return new Response<(int, string)>(false, default, "❌ Error: Not a valid argument, try !edit "); + return new Response<(int, string)>(false, default, BotResponses.EditInvalidArgument); } } @@ -202,14 +202,91 @@ public static class TaskHelpers } } +#region Response Text +public static class BotResponses +{ + // Customize chat-facing text in this section when translating the bot. + public const string Help = "📝 Rython Task Bot Commands: !task !edit !remove !done. For mods, you can do !adel @user. More commmands here: https://github.com/liyunze-coding/rython-task-bot-v2#usage"; + public const string EditNotEnoughArguments = "❌ Error: Not enough arguments, try !edit "; + public const string EditInvalidArgument = "❌ Error: Not a valid argument, try !edit "; + public const string TaskCannotBeEmpty = "❌ Error: Task cannot be empty"; + public const string TaskCannotBeNumber = "❌ Error: Task cannot be a number"; + public const string ReservedAllKeyword = "❌ Error: 'All' is a reserved keyword"; + public const string TasksNotFound = "❌ Error 404: Tasks not found"; + public const string TasksNotFoundShort = "❌ 404 Tasks not found"; + public const string InvalidTaskNumber = "❌ Error: Invalid task number"; + public const string TaskAlreadyExists = "❌ Error: Task already exists"; + public const string CannotFocusMultipleTasks = "❌ Cannot focus on multiple tasks"; + public const string IndexOutOfRange = "❌ Error: Index out of range."; + public const string CannotFocusCompletedTask = "❌ Error: Cannot focus on completed task."; + public const string CannotFocusCompletedTaskShort = "❌ Cannot focus on completed task."; + public const string NoTasksProvided = "❌ No tasks provided"; + public const string NoTasksProvidedWithError = "❌ Error: No tasks provided"; + public const string NoFocusedTask = "❌ You do not have a focused task."; + public const string NextNeedsFocusedTask = "❌ Can't use !next command, select a task to complete using !done and/or add another task"; + public const string UserNotFound = "❌ User not found"; + public const string InvalidInput = "❌ Error: Invalid input"; + public const string AdminDeleteUserNotFound = "❌ Error: Unable to find user with that username on the task list"; + public const string AdminDeleteSuccess = "All of the user's tasks have been deleted"; + public const string Unfocused = "📝 Task have been unfocused!"; + public const string ClearAll = "📝 All tasks have been cleared!"; + public const string ClearMyDone = "📝 All of your completed tasks have been cleared!"; + public const string ClearDone = "📝 All completed tasks have been cleared!"; + public const string ClearNotStreamer = "📝 All tasks (excluding the streamer's) have been cleared!"; + public const string AddSuccessShort = "Task List Update ♡ → Your task(s) have been added! Good luck! 🍀"; + public const string AddFailedShort = "❌ Failed to add your task(s)"; + public const string AddPartialShort = "Task List Update ♡ → some tasks were successful but some failed :p"; + public const string NoTasksToAdd = "No tasks to add"; + public const string LogSuccessShort = "Task List Update ♡ → Your task(s) have been logged! Good job! 🍀"; + public const string LogFailedShort = "❌ Failed to logged your task(s)"; + public const string LogPartialShort = "Task List Update ♡ → some tasks were logged successfully but some failed :p"; + public const string NoTasksToLog = "No tasks to log"; + public const string RemoveAllSuccess = "Tasklist Update 🚮 → All your tasks have been removed!"; + public const string RemoveMultipleSuccess = "Tasklist Update 🚮 → Tasks removed successfully!"; + public const string CompleteAllSuccess = "Task list updated! 🎉 Good job on completing all your tasks!"; + public const string CompleteMultipleSuccess = "Task list updated! 🎉 Good job on finishing your tasks!"; + public const string UndoneMultipleSuccess = "Task list updated 📝 — Tasks marked as incomplete"; + public const string FocusedMarker = "(ongoing) "; + + public static string TaskAlreadyExistsWithName(string taskName) => $"❌ Error: Task '{taskName}' already exists"; + public static string AddSuccess(string addedTasks) => $"Task List Update ♡ → The task(s): \"{addedTasks}\" have been added! Good luck! 🍀"; + public static string AddFailed(string failedTasks) => $"❌ Failed to add your task(s) {failedTasks}"; + public static string AddPartial(string addedTasks, string failedTasks) => $"Task List Update ♡ → Task(s) added: \"{addedTasks}\" | Failed: {failedTasks}"; + public static string LogSuccess(string loggedTasks) => $"Task List Update ♡ → The task(s) {loggedTasks} have been logged! Good job! 🍀"; + public static string LogFailed(string failedTasks) => $"❌ Failed to logged your task(s) {failedTasks}"; + public static string LogPartial(string loggedTasks, string failedTasks) => $"Task List Update ♡ → Task(s) logged: {loggedTasks} | Failed: {failedTasks}"; + public static string RemoveSingleSuccess(string taskName) => $"Tasklist Update 🚮 → Task '{taskName}' has been deleted successfully!"; + public static string RemoveFailed(string failedTasks) => $"Failed to remove: {failedTasks}"; + public static string CompleteSingleSuccess(string taskName) => $"Task list updated! 🎉 Good job on finishing the task '{taskName}'!"; + public static string CompleteFailed(string failedTasks) => $"❌ Failed to complete: {failedTasks}"; + public static string UndoneSingleSuccess(string taskName) => $"Task list updated 📝 — Task {taskName} marked as incomplete!"; + public static string UndoneFailed(string failedTasks) => $"❌ Failed to mark as incomplete: {failedTasks}"; + public static string FocusedTask(int taskNumber, string taskName) => $"✅ Current focused task: {taskNumber}. {taskName}"; + public static string NextSuccess(string completedTaskName, int nextTaskNumber, string nextTaskName) => $"✅ Good job on completing '{completedTaskName}'! Moving onto '({nextTaskNumber}) {nextTaskName}'"; + public static string EditSuccess(string oldTaskName, string newTaskName) => $"📝 Task '{oldTaskName}' has been edited to '{newTaskName}'"; + public static string PendingTaskItem(int taskNumber, string taskName, bool focused) => $"{taskNumber}. {(focused ? FocusedMarker : "")}{taskName}"; + public static string PendingTasks(int count, string tasks) => $"Task(s) pending ({count}): {tasks}"; + public static string OtherUserPendingTasks(string username, int count, string tasks) => $"{username}'s task(s) ({count}): {tasks}"; + public static string CompletedTaskItem(int taskNumber, string taskName) => $"{taskNumber}. {taskName}"; + public static string CompletedTasks(int count, string tasks) => $"Completed {count} tasks: {tasks}"; + public static string OtherUserCompletedTasks(string username, int count, string tasks) => $"{username}'s tasks ({count}): {tasks}"; + public static string FailedToRemoveTasks(string failedTasks) => $"❌ Failed to remove task(s): {failedTasks}"; + public static string FailedToCompleteTasks(string failedTasks) => $"❌ Failed to complete task(s): {failedTasks}"; + public static string FailedToUndoneTasks(string failedTasks) => $"❌ Failed to un-done task(s): {failedTasks}"; + public static string OtherUserCount(string username, int completedCount) => $"{username} has completed {completedCount} task(s) so far!"; + public static string MyCount(int completedCount) => $"You have completed {completedCount} task(s) so far!"; +} + +#endregion + public static class MessageBuilder { public static string BuildAddResponseMessage(List added, List<(string, string)> failed) { if (added.Count > 0 && failed.Count == 0) { - string response = $"Task List Update ♡ → The task(s): \"{String.Join("\", \"", added)}\" have been added! Good luck! 🍀"; - return response.Length > TaskHelpers.CharacterLimit ? "Task List Update ♡ → Your task(s) have been added! Good luck! 🍀" : response; + string response = BotResponses.AddSuccess(String.Join("\", \"", added)); + return response.Length > TaskHelpers.CharacterLimit ? BotResponses.AddSuccessShort : response; } if (added.Count == 0 && failed.Count == 1) @@ -219,25 +296,25 @@ public static class MessageBuilder if (added.Count == 0 && failed.Count > 1) { - string response = $"❌ Failed to add your task(s) {String.Join(", ", failed.Select(f => f.Item1))}"; - return response.Length > TaskHelpers.CharacterLimit ? "❌ Failed to add your task(s)" : response; + string response = BotResponses.AddFailed(String.Join(", ", failed.Select(f => f.Item1))); + return response.Length > TaskHelpers.CharacterLimit ? BotResponses.AddFailedShort : response; } if (added.Count > 0 && failed.Count > 0) { - string response = $"Task List Update ♡ → Task(s) added: \"{String.Join("\", \"", added)}\" | Failed: {String.Join(", ", failed.Select(f => f.Item1))}"; - return response.Length > TaskHelpers.CharacterLimit ? "Task List Update ♡ → some tasks were successful but some failed :p" : response; + string response = BotResponses.AddPartial(String.Join("\", \"", added), String.Join(", ", failed.Select(f => f.Item1))); + return response.Length > TaskHelpers.CharacterLimit ? BotResponses.AddPartialShort : response; } - return "No tasks to add"; + return BotResponses.NoTasksToAdd; } public static string BuildLogResponseMessage(List logged, List<(string, string)> failed) { if (logged.Count > 0 && failed.Count == 0) { - string response = $"Task List Update ♡ → The task(s) {String.Join(", ", logged)} have been logged! Good job! 🍀"; - return response.Length > TaskHelpers.CharacterLimit ? "Task List Update ♡ → Your task(s) have been logged! Good job! 🍀" : response; + string response = BotResponses.LogSuccess(String.Join(", ", logged)); + return response.Length > TaskHelpers.CharacterLimit ? BotResponses.LogSuccessShort : response; } if (logged.Count == 0 && failed.Count == 1) @@ -247,72 +324,72 @@ public static class MessageBuilder if (logged.Count == 0 && failed.Count > 1) { - string response = $"❌ Failed to logged your task(s) {String.Join(", ", failed.Select(f => f.Item1))}"; - return response.Length > TaskHelpers.CharacterLimit ? "❌ Failed to logged your task(s)" : response; + string response = BotResponses.LogFailed(String.Join(", ", failed.Select(f => f.Item1))); + return response.Length > TaskHelpers.CharacterLimit ? BotResponses.LogFailedShort : response; } if (logged.Count > 0 && failed.Count > 0) { - string response = $"Task List Update ♡ → Task(s) logged: {String.Join(" | ", logged)} | Failed: {String.Join(", ", failed.Select(f => f.Item1))}"; - return response.Length > TaskHelpers.CharacterLimit ? "Task List Update ♡ → some tasks were logged successfully but some failed :p" : response; + string response = BotResponses.LogPartial(String.Join(" | ", logged), String.Join(", ", failed.Select(f => f.Item1))); + return response.Length > TaskHelpers.CharacterLimit ? BotResponses.LogPartialShort : response; } - return "No tasks to log"; + return BotResponses.NoTasksToLog; } public static string BuildRemoveMessage(List tasksRemoved, List tasksFailedToRemove, bool allTasks) { if (allTasks) { - return "Tasklist Update 🚮 → All your tasks have been removed!"; + return BotResponses.RemoveAllSuccess; } if (tasksFailedToRemove.Count == 0 && tasksRemoved.Count == 1) { - return $"Tasklist Update 🚮 → Task '{tasksRemoved[0]}' has been deleted successfully!"; + return BotResponses.RemoveSingleSuccess(tasksRemoved[0]); } if (tasksFailedToRemove.Count == 0) { - return "Tasklist Update 🚮 → Tasks removed successfully!"; + return BotResponses.RemoveMultipleSuccess; } - return $"Failed to remove: {String.Join(", ", tasksFailedToRemove)}"; + return BotResponses.RemoveFailed(String.Join(", ", tasksFailedToRemove)); } public static string BuildCompletedMessage(List tasksCompleted, List tasksFailedToComplete, bool allTasks) { if (allTasks) { - return "Task list updated! 🎉 Good job on completing all your tasks!"; + return BotResponses.CompleteAllSuccess; } if (tasksFailedToComplete.Count == 0 && tasksCompleted.Count == 1) { - return $"Task list updated! 🎉 Good job on finishing the task '{tasksCompleted[0]}'!"; + return BotResponses.CompleteSingleSuccess(tasksCompleted[0]); } if (tasksFailedToComplete.Count == 0) { - return "Task list updated! 🎉 Good job on finishing your tasks!"; + return BotResponses.CompleteMultipleSuccess; } - return $"❌ Failed to complete: {String.Join(", ", tasksFailedToComplete)}"; + return BotResponses.CompleteFailed(String.Join(", ", tasksFailedToComplete)); } public static string BuildUndoneMessage(List tasksIncomplete, List tasksFailedToComplete) { if (tasksFailedToComplete.Count == 0 && tasksIncomplete.Count == 1) { - return $"Task list updated 📝 — Task {tasksIncomplete[0]} marked as incomplete!"; + return BotResponses.UndoneSingleSuccess(tasksIncomplete[0]); } if (tasksFailedToComplete.Count == 0) { - return "Task list updated 📝 — Tasks marked as incomplete"; + return BotResponses.UndoneMultipleSuccess; } - return $"❌ Failed to mark as incomplete: {String.Join(", ", tasksFailedToComplete)}"; + return BotResponses.UndoneFailed(String.Join(", ", tasksFailedToComplete)); } } @@ -363,11 +440,11 @@ public class TaskOperations { taskName = taskName.Trim(); if (string.IsNullOrEmpty(taskName)) - return new Response<(int, string)>(false, default, "❌ Error: Task cannot be empty"); + return new Response<(int, string)>(false, default, BotResponses.TaskCannotBeEmpty); if (int.TryParse(taskName, out _)) - return new Response<(int, string)>(false, default, $"❌ Error: Task cannot be a number"); + return new Response<(int, string)>(false, default, BotResponses.TaskCannotBeNumber); if (taskName.Equals("all", StringComparison.OrdinalIgnoreCase)) - return new Response<(int, string)>(false, default, $"❌ Error: 'All' is a reserved keyword"); + return new Response<(int, string)>(false, default, BotResponses.ReservedAllKeyword); string key = getKey(); if (!taskData.ContainsKey(key)) { @@ -376,7 +453,7 @@ public class TaskOperations } if (taskData[key].Tasks.Any(t => t.Name.Equals(taskName, StringComparison.OrdinalIgnoreCase) && !t.Completed)) - return new Response<(int, string)>(false, default, $"❌ Error: Task '{taskName}' already exists"); + return new Response<(int, string)>(false, default, BotResponses.TaskAlreadyExistsWithName(taskName)); if (focused) Unfocus(); taskData[key].Username = getUsername(); @@ -395,12 +472,12 @@ public class TaskOperations { var userTasks = ListUserTasks(); if (userTasks.Count == 0) - return new Response<(string, string)>(false, default, "❌ Error 404: Tasks not found"); + return new Response<(string, string)>(false, default, BotResponses.TasksNotFound); if (index >= userTasks.Count || index < 0) - return new Response<(string, string)>(false, default, "❌ Error: Invalid task number"); + return new Response<(string, string)>(false, default, BotResponses.InvalidTaskNumber); bool taskAlreadyExists = userTasks.FindIndex(t => t.Name.Equals(newTask, StringComparison.OrdinalIgnoreCase)) > -1; if (taskAlreadyExists) - return new Response<(string, string)>(false, default, "❌ Error: Task already exists"); + return new Response<(string, string)>(false, default, BotResponses.TaskAlreadyExists); string oldName = userTasks[index].Name; userTasks[index].Name = newTask; SaveIntoTasks(userTasks); @@ -412,16 +489,16 @@ public class TaskOperations { bool containsSeparators = rawInput.IndexOfAny(TaskHelpers.Separators) >= 0; if (containsSeparators) - return new Response<(int, string)>(false, default, "❌ Cannot focus on multiple tasks"); + return new Response<(int, string)>(false, default, BotResponses.CannotFocusMultipleTasks); var tasks = ListUserTasks(); int indexByName = tasks.FindIndex(t => t.Name.Equals(rawInput, StringComparison.OrdinalIgnoreCase)); if (int.TryParse(rawInput, out int n)) { n = n - 1; if (n < 0 || n >= tasks.Count) - return new Response<(int, string)>(false, default, "❌ Error: Index out of range."); + return new Response<(int, string)>(false, default, BotResponses.IndexOutOfRange); if (tasks[n].Completed) - return new Response<(int, string)>(false, default, "❌ Error: Cannot focus on completed task."); + return new Response<(int, string)>(false, default, BotResponses.CannotFocusCompletedTask); UnfocusAll(tasks); tasks[n].Focused = true; SaveIntoTasks(tasks); @@ -432,7 +509,7 @@ public class TaskOperations { n = indexByName; if (tasks[n].Completed) - return new Response<(int, string)>(false, default, "❌ Cannot focus on completed task."); + return new Response<(int, string)>(false, default, BotResponses.CannotFocusCompletedTaskShort); UnfocusAll(tasks); tasks[n].Focused = true; SaveIntoTasks(tasks); @@ -664,7 +741,7 @@ public class CPHInline #region Commands public bool HelpCommand() { - Respond("📝 Rython Task Bot Commands: !task !edit !remove !done. For mods, you can do !adel @user. More commmands here: https://github.com/liyunze-coding/rython-task-bot-v2#usage"); + Respond(BotResponses.Help); return true; } @@ -674,7 +751,7 @@ public class CPHInline var taskStrings = TaskHelpers.SplitTasks(rawInput); if (taskStrings.Count == 0) { - Respond("❌ No tasks provided"); + Respond(BotResponses.NoTasksProvided); return false; } @@ -701,7 +778,7 @@ public class CPHInline var taskStrings = TaskHelpers.SplitTasks(rawInput); if (taskStrings.Count == 0) { - Respond("❌ Error: No tasks provided"); + Respond(BotResponses.NoTasksProvidedWithError); return false; } @@ -729,7 +806,7 @@ public class CPHInline if (!response.Success) Respond(response.ErrorMsg); else - Respond($"✅ Current focused task: {response.Data.Item1 + 1}. {response.Data.Item2}"); + Respond(BotResponses.FocusedTask(response.Data.Item1 + 1, response.Data.Item2)); SaveTasks(); return true; } @@ -740,11 +817,11 @@ public class CPHInline int focusedTaskIndex = operations.GetFocusedTask(); if (focusedTaskIndex == -1) { - Respond("❌ You do not have a focused task."); + Respond(BotResponses.NoFocusedTask); return true; } - Respond($"✅ Current focused task: {focusedTaskIndex + 1}. {userTasks[focusedTaskIndex].Name}"); + Respond(BotResponses.FocusedTask(focusedTaskIndex + 1, userTasks[focusedTaskIndex].Name)); return true; } @@ -754,7 +831,7 @@ public class CPHInline int focusedTaskIndex = operations.GetFocusedTask(); if (focusedTaskIndex == -1) { - Respond("❌ Can't use !next command, select a task to complete using !done and/or add another task"); + Respond(BotResponses.NextNeedsFocusedTask); return false; } @@ -772,7 +849,7 @@ public class CPHInline Broadcast(new { mode = "done", index = focusedTaskIndex }, null); operations.SaveIntoTasks(userTasks); SaveTasks(); - Respond($"✅ Good job on completing '{completedTaskName}'! Moving onto '({focusResponse.Data.Item1 + 1}) {focusResponse.Data.Item2}'"); + Respond(BotResponses.NextSuccess(completedTaskName, focusResponse.Data.Item1 + 1, focusResponse.Data.Item2)); return true; } @@ -787,7 +864,7 @@ public class CPHInline } var result = operations.EditTask(editData.Data.Item1, editData.Data.Item2); - Respond(result.Success ? $"📝 Task '{result.Data.Item1}' has been edited to '{result.Data.Item2}'" : result.ErrorMsg); + Respond(result.Success ? BotResponses.EditSuccess(result.Data.Item1, result.Data.Item2) : result.ErrorMsg); SaveTasks(); return true; } @@ -803,7 +880,7 @@ public class CPHInline key = GetKey(rawInput); if (key == "") { - Respond("❌ User not found"); + Respond(BotResponses.UserNotFound); return false; } @@ -813,13 +890,13 @@ public class CPHInline var userTasks = operations.ListUserTasks(key); if (userTasks.Count == 0) { - Respond("❌ 404 Tasks not found"); + Respond(BotResponses.TasksNotFoundShort); return false; } var incompleteTasks = userTasks.Select((t, index) => new { t, index }).Where(x => !x.t.Completed); - string message = String.Join(" | ", incompleteTasks.Select(x => $"{x.index + 1}. {(x.t.Focused ? "(ongoing) " : "")}{x.t.Name}")); - message = someoneElse ? $"{GetUsername(key)}'s task(s) ({incompleteTasks.Count()}): {message}" : $"Task(s) pending ({incompleteTasks.Count()}): {message}"; + string message = String.Join(" | ", incompleteTasks.Select(x => BotResponses.PendingTaskItem(x.index + 1, x.t.Name, x.t.Focused))); + message = someoneElse ? BotResponses.OtherUserPendingTasks(GetUsername(key), incompleteTasks.Count(), message) : BotResponses.PendingTasks(incompleteTasks.Count(), message); Respond(message); return true; } @@ -835,7 +912,7 @@ public class CPHInline key = GetKey(rawInput); if (key == "") { - Respond("❌ User not found"); + Respond(BotResponses.UserNotFound); return false; } @@ -845,13 +922,13 @@ public class CPHInline var userTasks = operations.ListUserTasks(key); if (userTasks.Count == 0) { - Respond("❌ 404 Tasks not found"); + Respond(BotResponses.TasksNotFoundShort); return false; } var completedTasks = userTasks.Select((t, index) => new { t, index }).Where(x => x.t.Completed); - string message = String.Join(" | ", completedTasks.Select(x => $"{x.index + 1}. {x.t.Name}")); - message = someoneElse ? $"{GetUsername(key)}'s tasks ({completedTasks.Count()}): {message}" : $"Completed {completedTasks.Count()} tasks: {message}"; + string message = String.Join(" | ", completedTasks.Select(x => BotResponses.CompletedTaskItem(x.index + 1, x.t.Name))); + message = someoneElse ? BotResponses.OtherUserCompletedTasks(GetUsername(key), completedTasks.Count(), message) : BotResponses.CompletedTasks(completedTasks.Count(), message); Respond(message); return true; } @@ -875,14 +952,14 @@ public class CPHInline var userTasks = operations.ListUserTasks(); if (userTasks.Count == 0) { - Respond("❌ Error 404: Tasks not found"); + Respond(BotResponses.TasksNotFound); return false; } var tasksToBeRemoved = TaskHelpers.ParseTasksInput(rawInput, operations.GetFocusedTask); if (tasksToBeRemoved.Count == 0) { - Respond("❌ Error: Invalid input"); + Respond(BotResponses.InvalidInput); return false; } @@ -908,7 +985,7 @@ public class CPHInline if (taskIndices.Count == 0) { - Respond($"❌ Failed to remove task(s): {String.Join(", ", tasksFailedToRemove)}"); + Respond(BotResponses.FailedToRemoveTasks(String.Join(", ", tasksFailedToRemove))); return false; } } @@ -940,13 +1017,13 @@ public class CPHInline string key = GetKey(user); if (key == "") { - Respond("❌ Error: Unable to find user with that username on the task list"); + Respond(BotResponses.AdminDeleteUserNotFound); return false; } operations.RemoveUser(key); SaveTasks(); - Respond("All of the user's tasks have been deleted"); + Respond(BotResponses.AdminDeleteSuccess); Broadcast(new { mode = "admindelete", id = key }, null); return true; } @@ -958,14 +1035,14 @@ public class CPHInline var userTasks = operations.ListUserTasks(); if (userTasks.Count == 0) { - Respond("❌ Error 404: Tasks not found"); + Respond(BotResponses.TasksNotFound); return false; } var tasksToBeCompleted = TaskHelpers.ParseTasksInput(rawInput, operations.GetFocusedTask); if (tasksToBeCompleted.Count == 0) { - Respond("❌ Error: Invalid input"); + Respond(BotResponses.InvalidInput); return false; } @@ -996,7 +1073,7 @@ public class CPHInline if (taskIndices.Count == 0) { - Respond($"❌ Failed to complete task(s): {String.Join(", ", tasksFailedToComplete)}"); + Respond(BotResponses.FailedToCompleteTasks(String.Join(", ", tasksFailedToComplete))); return false; } @@ -1018,7 +1095,7 @@ public class CPHInline { operations.Unfocus(); SaveTasks(); - Respond("📝 Task have been unfocused!"); + Respond(BotResponses.Unfocused); Broadcast(new { mode = "unfocus" }, null); return true; } @@ -1029,14 +1106,14 @@ public class CPHInline var userTasks = operations.ListUserTasks(); if (userTasks.Count == 0) { - Respond("❌ Error 404: Tasks not found"); + Respond(BotResponses.TasksNotFound); return false; } var tasksToBeCompleted = TaskHelpers.ParseUndoneInput(rawInput, userTasks); if (tasksToBeCompleted.Count == 0) { - Respond("❌ Error: Invalid input"); + Respond(BotResponses.InvalidInput); return false; } @@ -1059,7 +1136,7 @@ public class CPHInline if (taskIndices.Count == 0) { - Respond($"❌ Failed to un-done task(s): {String.Join(", ", tasksFailedToComplete)}"); + Respond(BotResponses.FailedToUndoneTasks(String.Join(", ", tasksFailedToComplete))); return false; } @@ -1082,7 +1159,7 @@ public class CPHInline operations.Cleanup(false); SaveTasks(); Broadcast(new { mode = "clearall" }, null); - Respond("📝 All tasks have been cleared!"); + Respond(BotResponses.ClearAll); return true; } @@ -1093,7 +1170,7 @@ public class CPHInline operations.Cleanup(false); SaveTasks(); Broadcast(new { mode = "clearmydone" }, null); - Respond("📝 All of your completed tasks have been cleared!"); + Respond(BotResponses.ClearMyDone); return true; } @@ -1103,7 +1180,7 @@ public class CPHInline operations.Cleanup(false); SaveTasks(); Broadcast(new { mode = "cleardone" }, null); - Respond("📝 All completed tasks have been cleared!"); + Respond(BotResponses.ClearDone); return true; } @@ -1113,7 +1190,7 @@ public class CPHInline operations.Cleanup(false); SaveTasks(); Broadcast(new { mode = "clearns" }, null); - Respond("📝 All tasks (excluding the streamer's) have been cleared!"); + Respond(BotResponses.ClearNotStreamer); return true; } @@ -1128,7 +1205,7 @@ public class CPHInline key = GetKey(rawInput); if (key == "") { - Respond("❌ User not found"); + Respond(BotResponses.UserNotFound); return false; } @@ -1139,11 +1216,11 @@ public class CPHInline if (someoneElse) { string username = GetUsername(key); - Respond($"{username} has completed {completedCount} task(s) so far!"); + Respond(BotResponses.OtherUserCount(username, completedCount)); } else { - Respond($"You have completed {completedCount} task(s) so far!"); + Respond(BotResponses.MyCount(completedCount)); } return true; diff --git a/RythonTaskBot.sb b/RythonTaskBot.sb index 19a7e9d..90b0e2c 100644 --- a/RythonTaskBot.sb +++ b/RythonTaskBot.sb @@ -1 +1 @@ -U0JBRR+LCAAAAAAABADtfVd320qy7vtZ6/wHH9/HPfBBJIDzJlJiUrBFinH2PCCSEMEwDJKoWfPfb1U3QgNoMMjeHlu21/LespC6u6q+Cl1V/a///q8PHz7Ova318f8+/Av/Af9cWHMP/vmxs99Ol4sPD9Zm9qG63H54kj/+LbrF2sGlNd60Jje53lNy7clbb4LlAi+Kn+RPSnLB9TbOOlhto4vJe/3l+kNtKTwv17NgMfmw2a49GMF68wE//hxsnenfPoyWu4ed7X2wFu6H68CZfWKHsuzsFhdO9N7FLgzja/NgEcx3834yIryI1/5N7vjoWpmJW+QdG/jN3+lvPsSXyOXAxWE7jq2KvqwInmH5gqpbumBJoiG4mmZpvma5nlqJB0ce++fO25H1FKM/Auc/8Z/Mk97CskMPv7pd77zMlRcn3Llefb2cN4PNdrnew02+FW7K7vriLVxYXN5dMbkvXJfQOjOEyXq5W+HVv1NuuPSe/pFwROZOK3y29hugBO8ba6Dbcp7QqHDdWS6c3XrtLba8q9t1MJkADVnC5IgTvWU+hw+1CJ0U2ZB1TzEFTTUVQZWATqYvW4JtirZjO6JoyBo7AYbEmi97umaLguPLrqBWPEmwNNUSTLfi+aat+5JfKTy63a9wGVVRyl8pJWNKpE3Md/9gr/47/cc/2PXY7OyLIqvyVsR78Zzd1qstXa8VTU2SfdPUBMOD/6iyqwiWCvMz7Iqta47rqrJTmBrgw3TpRjxSo4tcuGm9W3xe9IKHKUivy6EiHbn15HW8zS7cPiz71jrAhTl0b+YuRrJzBHNVzxJt0xAsVwRaV8yKYFqWIVSAkL5jVzRJswoDfvaCyRT5TfwklhDThD9G/trKQj4ly8kb0WFqBwCVL/jNU+jsLMPQWm08t4FSmOWPfyc3FiFK1RXT011TUBXLAogyRMF25IqgeZ6muoaiqo72U0KU+Ilgz+YDMvTPi1NPEU/jjf/6N5+lK6orWZIsCrooAyFV1RMMw1YF1ddlvwLoVNGNMgyCR34gDIqJl6dZtKAhsSN4kkSJUQoPpQPgDII88WSFlMu/rJeO57kftssPnhtsP4CNMf3ggCGBVP8b58l4lB//Xx3+ZEUguYnSTbf9iuIquuCaBIo0EbAVdI8MWKTaumGZms19/AAckesRbSVRNHmXGVT66LqVSkWWVMExNTBRPBlUn+b7MBBP8ioVV9MtnzuGg1xCJ8nDL/yTZ2M+CWJeSGw/+RN/MbO2Ioc7yF1rz/dg2o7H5QFyS+3//vxzAKNePm/+/PM2cNbLzdLffrq7evjzz/oahoNmZ0X9888n9ZP4SREVyfzzz/nGWa7DwP7khiFveG99b3e/2Xrzv+itteXaO/DqT3BjZFl/spfbT6jHl4szHvgS7ibB4lNrsfXWvuUc+dad97wF2cTRtzcHv/M1cwYY3wZz71PXA0QNg1cLGebInKInPT/0CH58ugX3Bz2Bk5578F62n64WzhJ11ebTwKNMUnzqHzyGtffUGEMZuNkbk/thX7Qa5v5zUN17w87SlrXZeDia3NSqS7fZeXZel083Skexhp1Hq6aJbmAeuG+yG8nm9kZpa25j+mTPO6EbPE+sZkd0mreVm725tvfS3Opqj7YsPjmLEL+9u7yHZ/fVS3inOBrcidmxjC/GsjS1Bs/k3a3a88RWWhNbVifwjbDVqAe2Mob/S6G96KzgmXBcq77a8t1qNIB7B/2ZNbii33gWr3HO/cZ05eyrMIYOPBe+thovq5Hc3zlyf9Zq9nfjRn/fanaW4261+RD2Jh24Nh62p3ateu8O2htrcDt5aISP44H2CvcM4NqrNTB3rcvbyfWVe//QHL1ed9W7WmA8tS6Sb4at6Br95tVkvGiH8DyMdSy6cn0PP8O772AedyF+fzS8n+A33GE7hPGG9vx+4g7vQmdxO7EadRnuh/Xr0fcMOk82/NveV/fuQN1Ea/rqNvszr/s8ceTp1Jn3NrBeO1ifLcx9NV7M6Bo2757Gi44ygu/cBNWb8XA2cZrtJ3ceknnBt1f2/G7jDjrh5wmdD33/xbZ1dffkNMPNeDBGut2R985DpIEcrws8/zQO6FiBhjMY9xbmIcJYNo5sTEbz3sSO13MAcxwg3Vt0bNGa3UTfvelWH2ylvx/Jvck9vuthORkMTAnoLznKfTxu/MZ0JMNaKbfwHiOZJ6zlI1yjtG+6y/FAnYyBHm6zvRotQBYG2iKiPUOXiJY1cXKvwFo3Qpzr2FZg3MP+q1urPjpz4DOgF+VJc28NXFizOq63hLLgBOkaOLI5d5tuRI+2xvAuPOMAzVEugAcbd0/w++kI5jXuStvRINzgu8n4BuEe5zOSQ+TLLdB/NWLG+TAHnoOxO/P6zm3OKq16fk5VlIFnZ27KFtB1XLsIRsPbrTW83bSCKsr7EtZZbOE4F8D7iw6M05wj/3jd6hrWaXaT4YVqg8jlwMR3A/06ILMvr4APQNMeiwFgnDi7saxJN3O4d28mPO/szYXTeN7e7tXnm3l/dzOfijbI/eX9SnLkcDfeVx+ATuFoIIVOoIHc3+96jRdpDNduZmDFw5qN5/XH8cPmrrbovxJa1u9EoM0UcGB/MwfeqGn3drO/sAbqrjvQRODROWBOeDOTnkDuN58BI4A3CR16Smc/HtS3wIu70dwUb8IqyADQNdDasB6hMx8Dj/V2nYEm2cNb/dA4gVe3sDYwzr4MfC46r5kxao7SCe0Hzu+6GuDiC8jXnUhlSWvC8/Dt8DE7VuDhRn97E3ZCr3mfGYsHsjYeiLt+o6/C/LvjgSvZjfq+M5wC/fuvcB/w2S33GcC5ncMfF7xnnIyLHcvDvK+4gOuEz2vaNfz/6PWb2cvKXlzBGJbAw3ew7rDOgPGdRl0cdQmuhHbzFsZRlUZzwGvE70b9FXi4NxrerWHs+OykVbsADOgHiCcgH0B7Mp/PSAscA15vNZN3BLZsbhDD7GF1Azwbji9hrgHcU6s+x1gPtH8CGWuATpFQR3DeczWCZ/uNcAu8Xx034D11kOdBrzimq84U6NSzYDytev95DPMD2SX/PvjeBwPxbus0XkJ4fkZ/VxxrH9bE2k8JntG1Bv4F/I/mALwkPduNvog4+6VbBd5/eWWuJ3NsXYoTkCXA594qnoMXj4/8RSwLX29mGshWD9+VXePMPcz61i5M/nrTvy7RzVpmHJ25+Yh6r+Redr1xHAwttM+24iQ0oGvbWQLG7frD6gzvO+U5/168xr/AYylPyC9T1C191MczpOkV8GaRHiAreyo3/VfAml0JH95aIG9f6p2pI2/+aJH/b18594GM3AONTbCTXhhadi4Bq3cuh3eZ8S0fUM9dvhB5+QK6CP/v7J/TMTbTMV7fx9/mrnkfaLO3CW8BPZucubH0D+l8kJYu8qdyy6dJ2byQZy4vTqJHD/GMYEuPS4+Izx/cwd3jeHj3CvObjOW++BlspfHwXm81xXIaXvVBn5r7h+HdgvvcpECvLnzjGfQ6yNiUYk39Torskg2DT3XQsU/OTHod72GuDdAnjefDchcm70HeTebDlz9m3ChPw/beVtp3jnwajzNravQv1QnYPum84BmvyKc9inNXE29fXdD1uQuBPyf0GzlMrIN9q1Sf0Aa4brSfbBl5sv8INvkr8me/RmR1SjCp0Z+Phv2NW5v2rrsM7zayc7QX/Y1dm+FYwa6B9zaZdWfuPcLnV+l3QQ+leGvCOpmRrgK7vBPrq4zu6oI94aAdd3W3gTEAn2T0F+jrupjBEpQNcQp6roo2fhmewLqibkP7Amz++QvYZXfgK7TtIfDBeFgFu7IuAn1R3uLns/JWc432/jkzX/j34uaC5Z2Lxee9k8yXg0WPSH+wfQkm3RP/ov6INhjgzBZt4S/dC/Hu4YKrl2FdU9yL5eBVBTsGfKBhp0exKdVjEW6UycQedInkzNX4vh19z/2yJ/efYW1gzcw98lIv4pfoO1+cJrG7QZ7aIdhn8rjX38LvtA7aaODHOPvZDt5B7JzrJszpAb5R03pwbXtdm60A254IrtYmq3SNGCyogT0OtAI/bG8D5jqLPvqc6GOqB9aFrCn4nSLlCXr/9dXLCnwcg/zuNZkriyPwXFVyazM+3RvhvFWb4rt3/WZb64ENCDK9hPV4dof36FtIMT3tYLbKYnRWPqL37cj94Od7iNENFfyzi5csBtG/YGeK4HvtyPfp/X8Afzy3aqN5vB6ty+eEfmDrSDCOVevSmFjEH5yALF9sbx+y42DxhI4zXWvKQ1oDn+/SdyxRl6Dui+yWXWdYl9AGukY7t9kXb2rEdocxukQPAe+sqH0KvgrcA/e2wXd5gvlcElzpzjIYehavk/XvU14X6fevC7R8nnQW/d3oFe3j+z9aDTd0r8ZPIwV07oDKSRmGRXRF/RC9K+HbEr7Ae2B9uuALDl7AD5xl3ucdomtDC939JMszNR72MH/BvrRrrSJfNcWcfcDKE3lnZLeHryDH4IP1E9yDNUHfjNgaoLdA90x23eHd3YjEr6bJmt7X2t6wcb++rgPtpZfZ9X72z3attcrpz9U4uFjC8w9OA/zKPugPoBmxG6+A95u3x2Uk5ceYBvCulxXgxaJVc/j4UYt1zDKrk+Z19PnBNgpF9AG6RfpG755m9ADD0/T6lfkMOgR9vh2s0RbjZ52B9Ow2wzqsHeBj//W6qz2MBy/hSLlPZSbEa+ISeB5tNcLPJbz0Sr7TpOtE5Ap8ABcwFeiCttyp2DKP/QAWB4k+BmxM/AJqN8O4LtatyysOv6X6wQbfsxXhaGw7fJkU+ZrH63RcWdmLcAXXI1pjZ5nII/PXPx23CmvH1SvNoh0R2fexzgQ/AngAbKo+jBHjohG/LFObKcG8rP9B7flIB5fqEvIs0iLCGdQpK7tb4OPfsvreZbU5njoB2oOJ3xbxTuIbRv/WhhjXBF8I3w18RuNicUzj+oGLAzhGzru1yDecrOg4r87SPRbOr3n3ZDfMy/y7I5lGWiH27PuRTdJBvXwV2WKpLcjGVFat2maSt1G+BodK15zVwSBftsjEVGj8oE3tLK1nS7FNwdPPfHxK8CaHWcxcwE+5C8+QqXJcK5GhrG1RsJ+W1xl/bFnuKzH+5Rdq/zI28yzByc6gA/JWsMMAQ9x2jEWEb/g6oMw3ofgHMgJYMGO/QeIhzbY0zq09YIHC4AXz/TL7jfrMFvBpTieSGB9fh4Kt/pDTlfGcpa2L2IVx8dR/orE4ZmyJj4W8PJBE8PUvECcnPvjlt0EZ1uSwuabdjoH33QbIW+1in9WdPPmtymCbrsZXuN/Sacc2K9BkivzI8z2swWhyXauDj3zXyKzFfsbh1xNl9whPXUfjATyfjQfjqTt4AT17Eagr+TaOI30Oqp9thezxAd66yxasyVjpb8n+APiqwBtaq1Yn+02ty5edO5CC8bD1B/48HkY+8asacHGTI7tcWu+r0Xvbsf2CPFOkU33zPMzzaWJHgHxKCb8dpnFw8YI+nVO0BezbvojxmpTfL/P+DKFjwX+1F/3taN7fx749rPkTyg6V1Qivu8d9GdDZgBudOq43I380Rl6qmyZTjtydpYtyOJfG1h6e0TdH+yy26VZfgmkSs09jYc+T1u7afYR30dheq9K6Ap6qVacx7rC8Be8TncVs0hrQPcsvGG8cAD8/qvgzjkGkMeK8jcXVAwXcJnTi4N0Jsn2ejDU7e3fQ2zAxhS3YARuGH1cwV+Dvl01eRg7Y30S22JjnNfFF0ljj9YO6JLgNNLjm6wIYJ2Bm7NPDfVE88mC8NdFXDRovbF1JMP+7Kfg6NXcQbjAvoWyfK4oxJPGy+0V/ZTc6uDeS8lMvfl9vWfAVGvUZvH+W+AK1JPaW1ZWAaxbYmuPDMaYp2ZOpxTbaBWDWxaQdjHBPCcYF3znbxkz1cRpTB9yv3QcUy+m4kz217mUwt64m6tLqRnvfhKevwQ8AjHFai22Md7vu3FzZwSQY1lqbVv05aAXPk9GgM0N7zu/DvxvTqTvvTQBjQuCPaG5Xk45sPo1ruCd8t251L58XqnzRejxoAzFjZzGR7mHG8WK0bS3EzsEd7k/fWgMJ/ISL/23VqB0d2Y2TeA+r9fl6vIT5TletSaseAva1qG7YT8E3qILew/wYzBFR43lNW1cu2Az3E7vZf7T2VxOj/cfdpNYi+JvizxGZ4dPaTON6Ma9krr2cgwMxvwxeq+7NLMQ96f0xu5HgT8zPWT4r4UF1cnuCfkj3yVJcQpuoXbsJFqPnSSd6b6vZeSLyVKtqmKsC/ybxCfClJ15ii2vXthzurpHn8G+6VokvB/4s+nLzaN4v193Q/Gv56+R5BK3L5cRJMfJYvI745hHvxbFdtAXK+OSP74AJCU2icVVQ9ov0aTuIB4ANAWBjxOuhCf+e+LVqA3NyyLPNIp6gvQfPzKN70n2Exoj4juNAa2POBvDeyu+2DsoBs9a7h0Z/N1Y6S+Tb3J7RjrsPs784vh7oCw96cfx94srop4M+ifYVx6C/AENwf+AV/N0wpdlFxTkXNxJ+vQgwTyn5ZsMgtEh5/Ihfl9Kf6serl6exlMrmwwBzW+qLcXdaiL2D378Avfqt9N3Glt3FibxN8PEEDEx0OUN73FObtUJqa9NYVLXvNHA9ehN1NZ+CLmjMQN4xz4zRAXpiG89WT9ZAXSJP4994Ha6HYpxTGIwHfbBFYS1ll9Vz/7Tl1rT1peY/ji6Cg3s8DD7ezF5Ce+6KFso0jUu0AN+eMTcQ8Bf3LacjpRM6mP8zQD/HmByf3wXJ+XOCVKfndHRMj0TPWXMzSHR0cFFhx3iaPonX40fTc2eN649CnOxMXKX+a/xekm8ar/XEy9PkB8fEs+bybXjmgB0MNkjta2yQ47ZhP8WDeJ5cvdVqFrHhF9B1Ce2T3BN5LNkNzK/46/UervWb9V49zl044N81aQ5WvIcwBn+27J7Y/us3zO54ID25NE+ZxBhxX7h/OBcjsvWK95XjTbou5Bk5x8Ogc+b/VCntrnDPmLVHt6857N/TMYP9muezEruU0uEu4u9Oz5ai9exyMLWwjm/H/Fhm7ZyeA1/MWgeszF4sPCX3XYzHDcUFzt3Zxzq7E8a5nQUe/sZrcc48qT7fbnLy+LzQ/rmL7RW6p8PQLsnXuptj/MbrXgUn7xeAnsr4MM1oDg/Lcv+rnPczeHUkxyMff2H3lu7Qjh4N3PA6v+8T56qwezinyWf6/jSHdwr0PrZ3S/z24n0H9E6ytpGeaVAZdeM82hqJIXwOutWmLZuzVmP1NApAPzH7gjRWzJHft/Ims148Pz+6n92fS+3zB/E0n5/hqUivUD5uxrnb99QmXs5YO5nUJ42Bz+DeJVNTQujcqrl6cWwd+7Yume39cT6n8dVDvPC1srqZRJgkUUxCLEXbudLO2NOgo0EfAm+Gr1aD6KNz6cpgIS/2kNIX9GypD3OIL8B2CU7Nn0jzfNsS6PhZnDdxyI+Mvt225wwv1oq5XgfHWJq/dR6dWf3UHWiPJfe9SUcV5R3x+7ML+H0R1ih+g10oxrlso3Rfn/B1qyGBrbZFO3sa1ZMl8/8L5P98m6Mo14hnDwuwGyft+0lky0zsQX1vYV0C/Bv3ltJ59s7STxzfYwu+8Jrz3kP2drTe0Xvqnac0n6KotyLdhXV2MxjLAut28N/xz1FMbPKggH09r9N6I5hToufifQnqx3/BWCLqPbR9s/sS7ZWLe3rd6pUV1QfB3LREHjCnO61LiPUaybVm8oz31nBM7CGs3xoD1tjN2eQ+et+XhhlY8/4juy8DejRw5ibcezcFXuWNB+u5UKbBnqg2gF8eWRnFnLKu3NeOjSHKxyzGi5h33C/CtEaCqdOB+2Ri07L521dgo81vWXtgATzNfT5T5yOaGEeZRvlByw7QiPw8r++9B2Z8tPaErG9sa9C6qudz1nNTMk6sFy1cY/Yso5zVbej12hqh+5zk3pa9j6ktKbFfonoRggcirTP40mXmlfPDolx+di54P5dX2PfHtIzzDTO8QWWc1lfMufPDb0TrE9a8/pEaGXwHUyMUf5N53xEbdAw68X7SS3LGac3PiTxB6iuuuzR3jIxnkcokp/4h4cMT398cRzn9lO9IztYfHDpy6uWyOe/EJq6zOWVMjQDBFKBD92gNDchgazKmeXQ0ToA1I0xOVvS9ZX7fmNHJ8drE35r4zcgWoXPJ2po1Xq5Jsm8Tgh4TvR75Nj8nZ19dY112nJNG+dL430S2inmXRGe2hulYMSfQ6yGfYW5KP7xu4HNYT491viSHj7yb0mjGy2FI45XM2uW+m9ZipBi/i3PosmtyAeOn9RY01osxtnS8AxnG1xfjZw/zP80XRj7L5fiU5mURHiBjZOrTivxVWFfynMXaV32mvo15303oLuE9YZwr2BoeznekMcOM7XRaruPhvLujOYzHxnUgV+KU/MiEHsfy9Y7kXICu6szy9a1U3iJ9EseomLkwdazJ9XGcq8PkjZXXgSXvT3QMrak9WEvxmthrw7vPGL94UNp1IuPdKfOOwzL2DfPMIhv+bmrPSV5QALYQxZwuP4+a5B0hXvRpbmSEeaTGN86vGu7/svHPaD5TVBf5uIziYNXH0UDbYc4c9owYdePctVYhB47BaTrmWf/FHQAf7CdRbUtaC0Z5H+z6IfgTgfbFmXdI74buwIVvtcN7uf76F9KqMNe2iDESZwK6EeeI8eXQWWCsEXVAqMCYZq18fmVRT8S2GV+H1eqMHahFvVfCnSOiTpjiO1bn7FG6RbuHsePyGMrKVqQrQbYTfUTWMrUfrtn836hGAeRuk6lX7ubX44APSb5Zt8GP04YgxxHGVu3FrLw+LMv/Z9aIXczbwcU0nyvOqxP5FrmASSwlzgWM/Lq2sk2xh8SOQR7QrwGfZjwEG1npvBb4iuJZkkPMG3N/oNHrRV2Z8lh/i7zr3oQHbdwCrx6i17hBc4/jXI6sLsjGUlPMn3HxjtUZJ/A9Z16dJ/j+htWjka2zvn49mkeFtstujHmvcS1luR2U2FDFWsuMT0PXprnBniwzun/bhmv3SdwgqcfnrhnqxrI1JHozynu8J/ne+fzGnJ1wZk4l8H6Upx6PNdKXm9iuPxLTy8gNxycF2amSPN/IniA1r1aSu5nmRgNNDtZY0jof1l7E/hZox1P8i2hW4kdkamMOxGyPYwN/jodyhSN9E1yIt5f3lbjnBLz7idTdwVjGJTVWcT3ul8ecvRvH4JovBlvTe8T3KfIGEydi+SO144Af53XJboJ+zWMd1nqRPO77KP+l3EaI9ksIf90PXkhsyOv1VdQznNqlE+uIk9zjDe09BPOgccop/Pxqy+oObMEZvGtqX4ULG3sg9UBe5d4K9MQfrZqYl2lGb8V4HdY90rPq9lybhJvjdJ4NeYLOSOXnyW50PsdYz/LKQKb8AXjO6xvD+BV3NuW3qcv0mknkMvfcA+a6Yl8nW6LfycpYoW5mb8v12QjsO7c2JXzo7UlvNDLeFu3phXjJ1LhncSmOG0T2qVmWb/4G2SW9AoAOS1t+mcV9fNJvvQ0LizZE1PNHNHd534qp9Tlc2xT1KYN3v2b7LaAMpXnw2KML1+5BHhNbK5/PkX12RvDlllcDUvq9M3GGo4MOYQz4ATuQ16T+i+5/SXBPZ4U6P9n3KsgDia2I5+mHtHblfhGmMnTY1875OtNM7dq5/s5pfiFD30zdjXqK/7Aj8hOQug3edfJNuG7gni7G1+DnP2I/PNWZHLr/db50ZKPRudryCOVkN5Z7uwLd8/gNWGaHYjbWwtHz35pvU92Y+P+RvZ7dnx8nOrOkpqwONgG1AauAO8u4J0upbxfNt8PajbRmh7dOHOyO/s+tvTqG3ZGMBs9J/xDUG4CRRdx8u/+VYnS6D03mXGqv0rmaWT3UR9ol8b+szJM6zRP6Jai0thx586qtPWT2jdj7iD9H5Ufa7obdrE/619eoVS/jGA7lpVuSK5GJ2dE6gzJ56tsRbe9Rzx7ikWZsa2hgO6T+CuIH0o1H/55cl8c97CVpxvsLItd2OM3fiuQM6zvS3hUgc6V2wtf5TeomO2diLx2sgWPmcmI9N9Fl2bzgq/os7sHB2AybVoqnZL0P1PezdStJLzMeNpb35XgTHrDfpXskUa3NMZz4Gjqx+a3xPizXf06x4q+xazJ5+kxPtDI+4duXsi2Hs1Q33C4P+8pn7bWkNtNJuucUHZLde0j243P7jElMi8Rip7n+KNE7S+YJ49xHfbYmVpf2Lmw1wJ6t5eyWyw1c36x5fB7rEquf05/cOvdC/7MT94oLWHfWPNP673jPtXQv8i+MAyaxstcjfhDl06u7Dfj5O3d4sYz8f+JrPpCckOP7QUzc5gvmbpzUr+BN+4yF750cJyrFyNQvZ/aQ09yGwl5Wnh+jWH2cgxyNC/cYTq0Tz9s8p9Tk7wl/De+YXORsfDTZZ20Q7Ca+kDUkPYoHYIdI4zRmnF07pm8OvZ/EdFakjzLJIzjQO4fOaY7+0mhwt2T2/CbIn6jvi+Mu9VPYvZg473iJ73kbFkffIzknrWVWTktzapj1jMdL94HOkKv9fZr3X6oHEB/h3kcL7GZKX0o3a6Bm+Ax5EmjWs0WCzct8D4f8uAcyvkdy2X6zh3M6+PvQ7txcjbFXcqM/dWaFvjqv16W1gGPc85mO5Anpf+BEvER4gV1f5C3a7zbmLV4cj8VM8h4O5nHnfTTvoMus6TlrQTG70C+JzcEhPHtwL/0ghnP3O/ryFPRCL4q5FvfRjvbgLPDqeGU3O4jHT2mP9/YrJy//Nenjzuir0rz6bF5QhpfjOVjK+JnmPqV96VO913+9mWF//elreg+pVag7Q7i3ebvEvjD4jpuQ5vCwevQNvSvJ2mVyuEDm3cUFxVD8zozuySbjbmxlpxbjKq+fxYH80is8x0Od0F745ByK1ghzrGlfi0Lf4Xup2gJbDn6nhd8qvzTFhM5qpJDc1amzmLF5i/0kB+ohgxWprcjJf201MrmYnB4d1OaC+WA/ubJ4ai6vhcgK25fnsnc12WFf2I788jQCm74PNGN7YrUW0dkrgUTw42aAZx6Q+haMu6xIzlitrRdq8HJr1F0A7iH2Lcahs7gHP4Xw2Qp7L3nz/pfRfIV60zgp/+9RXXLmk7cRnzLrGdOJs9Zs/h3Qq5bJUa1FuYVXqS2K8RkmPyF3fSox+abZ55l8zOvivnFmvDez1K6M++bzfJNivDfG3bRvdK/xAuuEukRMekg7nJzkCJtrmRiE3P4n1l1irtO4Odvk8kKO8p2FdA/Qp1+9wrwwLwTPcRFvQly/EHv6VMa9OFc48bNf4zNZsHdsfK7PDck93Gzx7Azqd5PYC81PeTVIf+PI7txE4yV5ueCzazeRXZ70mC/SY+Lncz6u7u67NW04HrTx/B/4TodZmw45Z+K6gfNSy/REsraF2ivyfT5ml9oD9ejcJDruNsatQM7o7zB2PzcSme43XdDxd0tck/tF+2k06DyO8AwOsN8KvhDxo7HPSwf0Wp++F+QF8fImhN/3ye+bufmHTlDwy87oR8jPg3DB9hjJUzKGSBfRPYgLjl8yMCUX8BB9Tpj7jmI0kcmsjXvMV095upnNM8rZ4Gkf+EN1cA8HcvVOzYOKaNjWCP2G7cV1rU34l9RRk/zarO8V4c3B2huXk/td4Nn8M0Ubi1dHcMq6ktwx3tkQp63rZJrWa4WvD3j/lbmnvUtnGTw+YX3pHkoqc/ZtXSQ5xG3xYlG+h5IdM/PNXU/pB0l87PKK67+e6Kec2XeUxPjpeTygJ0An75i4B5Nv9lV23eF+oUksn46jWNeQ+poHawWDo3VbpXLRb4bP424r7jmf7jmnui+PVaXv6g7IHj3Zj8vxa3tcmpN0MWsttuBDgB0JdLaH4tZTomeapTWDed2LdX9Ys4znd11hrWCUm7Wke6BJTRpTa5r3GQp5m82yvE2e/2QrnanNnqdzFX2ztjHj7584l6x9ctSHIzU3ORsIdWRqmxViJulcGd82/t3JNgcTK+Hq/wdYh6bdMDHPdzAC/XnAJk7GyvSOzO1VlGBlWm8QxZQS3fO/aTz0YA0KwbRDGEl86RNqlGNd1ymL452nL0p56kQ+ivcGZ0wP3W1S+15+VoGINaLeFekJROz/u4eLZ/wmh8Y9sDFx7avO3AH60vioN6yGHH2bynieX6j+Z67Tsw8SO6XbWvH3WrPjvH2k42TWNxvrvODZ2i6e10JyuUn8o5H07kj66rb3F4W9mDSWh2OMet/WWvnaU25c0pVBX2AuUxB/9wTeIrniU7Q1ST/U6/1FAN+D/9N3XGf7zG1HwynpLcfPxSntrfuAMQOmzjr+XtJTHuSynI7MX6R90lsZ53tZ+k2qT+Q6+uMvt5cXJ8SwI7sA97bP2ptMaLUG/krzvTgyH4//uov9+Fqkz14ruAjI2QZNF/Tifdke4SF5j2rBknhS2xERm16+ODNaf3WdjPGEc1/q5MyjtJ9F8mxSEwPYWt0ATiIfbk+MYRf0UY4nEj62k9+xZ5el3yP7vYv4zNpWuc9LfBeM1TJjPW6Lol8WtmrtyPeZBJ/L+rbzsGouvY7FcMbBqdiXunNkt2i3MH+pnxf7lu0QbCat3zAZeiRYskn9Tfpd7h48nVeAvq31ysM7kp8Kaxr7nL3z5kzwuVW00ephj9i+3DwPdq6E38awXj130Gb6MUxmrVlVH/SpD+h3q3rCG0ORn8N06lzn29VI3nybeTbwXVsyxgNj4tm3W8oLRTvZksNHSzxKU/LOLt4rcfikdh/cN7dra3C3JnRYiBNPTnoOmyRmc9p3Dqxnkm9QKaPxaIG6alO0WbLxsdJz1pJ4Mp4Pmtu/iPZ4Sc/BNO5cGn9NbZfaDe1vUY9txyj/+QptR3KO5hZj184rvIfGuZJ+2q1hsk9JegaMuyqeYQn+o/QEY9yQ2E0Xa9nw7GEDnqvPxoPnyT3xWVoYJwecJ2clw3ilKcwbe1zh/kEF/i8C1r5+DoynMeCFBXbKDfbS6JpgM4Tge6zCm8Hd05j0Y4nP6la3NK9PwrNot+5jC/MJEB8KMpL2cMzm6fFrbmk9JdZunbC2PP5m8lM5viCTf8yrwSVzivs50XMQ831u6Rkq8b4d25O7vF4w9rVfz+4pEueXzu+XUa7bZ3sf53ywZy3z+6qnfjk3x4N/xkzU5zi/15nuYfHrl+P+g/nnymov8uvFxkZSHcyun5PGSVIanXqWTDa/LLu3smPqgMna9pJxfn1+GX0m7h2NvY8nGCcozxPD816G4i7ufZP4c/H5O2V6iJP/wNAo6aNI6iJr2Xne1DJ5a8zZoYU9ihN7Yxd7T1J+vpu6835ZblaKlZw+9Tcz2kMJx5/mpvUZGyXpNx/PdfUtsOihYS5+YxEXi5L6Yrb3pNMEfTYPsf91yTkiSZ4h9xyMYm8AIr9JL01aq+MU9lOKMQryXMwLuefKamQKPMn3e1na7In/m5GnU/xguueS7blqs32S6DnUtFYwi4Px3muSD/vtcCrpL0tqYdu1tl7MLY37ruLZeHXzJqjq2fWIfbbQLMm3LuYFM3/TPrYEK5fZd+dyXdNzhwuyXnK2ALevNm89SC5jP8nPye3DpbKQ+A49ik9ob0W9Gm/hW9yzMphe4d8Uq6K8zsSWLN1H5PoaKX5wfEkGy7hydlC/RuP6YoeFnO6SHjNMHnF6LjVvX4SJDZ6We1wWa4l1CtHPu2tn2q1ewvrvx5nzuaJ6FrDRPYX9XpRfhjl/D1cY03rxwUYvv6ddlI3DujGNr2bO9+LnWEU+StIn5QT9xc0pzeERyS3rM/dwepUcPGMz9z5ubx0eP4wzZyFtk5r2L92L7Sk9Nxna0tqrOvGXZmBLk7qRqE/9tEDnsrql3PnLx2yks3lL5p4BxPAVk78rbbnrHdfB+sV+LG/hpc/j4VT8zUc5PsL6t8AVyd4g+Obg96gw7scYf9G2iPKBse8Kre/N9SHFZ4mvUyN9BEPwFeD95pNDzgWC5/AsN/TVIxujRKeyff83J5yf8s3t1Whtu99UDwyoHDC1KLjPTvtQn2BjpfSK+o1Ip+mIt9mpia4snC36EOccNU+X20P161w+rmfrQMvOgszWzPNwZpqvbePOn80pivrp6CQe1aA5WzROla1T48tfee1aTs7Pq8U/1dckvVP39WIf4kRGCf+3lS2frtj3plu9s5Ux3UuQYXy4z9bccniOZyfMErzvldnaC/hGoQa8RAfx85SjM5PJGZf/CfuQnDlJ54S1V7lzW0LeeanZOvBCXkD+zPqSPjw0htqJ6hBKbMkj/u6YjIvSjvU5vlnMjdiuWNPKwUz8dlQLmRlHxhd7npReK9iZ6bzQlyI16em64HkXs9ZTzZ9pInNWQDy+bKzK7zrkjNj4LDgyhrjXds3Vk/fnbN/2PjnnAuP4B9a0LMf17T7SvTwNR/L2O8sA81zuzNuSM875eYe5vefINiPniKDt0CE10qU1fVQe+pw929Al9Ur0PPVeRi+fsH9ZyDMq1+v0L40Z0pwW1BWAbefs7bN7KqQfAd3zq8Y14BLw9qG9usO2UomcRjr+yR70QXb6dVzfMh1bEsNie1tycp2KPTx49Vrn1e9x6VVYv7vLC/G0fk1fgXHcPqSFnkhJ/dw11hMnZ+2SOro4N1xM++dUzetucga8SvLsa3X1ZnG4/2i6j5rEZJAepecW8Xqzkj3kBskfi757H3jKZGflfbX9lIyHqbnFPIwlrP8CzwsZ72cTchZUrRVcDyXdq2lRDyjcLy3otCTvieAIzHEMttG4R/s9EOxebPM5zCTn2O+6r+y5kWCfZHrm53rB4T4Dnmua2f/G3JG4fz89j6uKe6gEp97yvlKbLKXLt/Bd2fqy37j/G/d/4/53xf1ivWuxr3WMpdgHL+mnQeumYt+S0Qfg46zSmtQJqS2kuMn2lyzNFc5gaPEMmKpBz88tjvtkzIffxb2zMP5W8GuTfCPUf3neMhBj9U6ufwHhCfA1nWT//2LpyZwxRvt6uP9yjedTZfJvUM/cB5k4QbPo17L9wf24N9Zr7l25c4OZWEuam/tN9l/DVxdzh0neyn1pHnmUw0b70V/V9+P9JGDwiJPPX75fyjxHerqk+F7SozvlLZBP7MtYF22lReIgn/f5s00pHrO6ID2TkPRiJ2dNwfpu/FoL9SeeZ7DC8zjK8TkaN9O7LjrDUU+f6WBeL883Pxuf3mZPTdm12eTsvtiGEyMbLi/L6fmPud50hT7NjH+bytk3iJ0kZyJ+X17k9oPNxQhO6HuT1jvle6t+7f7/Wf1ev0KPRD1Z+g2zNu5HtKDxyXxexD3m0cd2erTmuT5SuRgL1j9nYpMb/vrR+GvPFtthyXmNb9LDvF6zVsQr3yQ2XTxrMzl7wJE6T/fzfjc+JzHLF1fsuXfZeeN5kZEdR/rfP/L4Nn+2JalhSXuvM3XmfL4vPUPx3DwQMY5vWwOQgX1uHLjfdFlyNkutfta5huV5bJs0f63AQ2fZwWxvaR7/J2fjJL2FWbmP+oAcsJOzPZkD3BuL+s0n+xTh43h4m9FNsc1WXjtZ9r2I3vl3k/79kf9fOlbmWeWO4WHMHZke6vl7oAebWLYuB/NWSms16LOFc9Vi2kdjPUYT82RfhenHmPL7V/R4YnCfe6ZifBZqNz3b+qyzFZNeRmX5QqfojBT3Stfs1P5QWT5E+aqDD479XKZgD4Q3YRt0P9i2lxd5GybuHVve46m4D8vml0X93dJ8MoZ+2FM3dGZtDftmjOT+juZjT3fURzqpN27mbJ2Y/+5BN1r8uvHakV6U0dm6vVw/69mB/v2F+WdtzZDs2YGt3XmKbU0Wu47sD5KeQvDd5+uoN8k5ewmM/5LklEZ5XKETaKXnYhew55CsZ8/S/Raxreq4Ia3sWXROc/e75Key9YawZvXHcR9o1KjvR/E5D+zeXQi2TiOke8TS1kUewjpE0g/zkn8egEPiUf2H2F/AfL2sj3Rx+Cwxbg5Etl8CiccVvoNn5oon11O7vFojir/03gcRa9q/Kre2P9AI7tC8Edxjvqexk6CKdVhLPPNuNLzPnJeDNSyYMxLbHfTs3W9ji+dkLuZ7WotE+8G9cR++jX04Sf9rOnZSu8LEO6pLlN9krxHwnPqGBR46hltTIjPzWGZIjgLJlyAx19I+rW+Sz7iG/3vmjzPP5WUxqiH47WMe9zF7ubNrSnIW+vF5zWS9s/3xj+epcbGD9cvKzxqvvSVfjek5vxhjH4QZxlTpvsY3ySuLzm+ob2w21sv4PGzs8Zivyd47eK265D6QX5DNfEwtrZnIns/+Jj+x5Pzjd+FzHjsroLzmnORkpnZeXh7SXh1RXhfrf91GvTHycZXM++fEBqbv/wPPrSHnj0fnymV8mfhsuX18/4zGTIeZ/LoVLy/uP+ifZmUZn2/yx/tQ2suJ/uX1EKBreLAGrPR9dP4Hz4Un9SAuD7OOjOsn9MmY85EysY63Ym98HmMjrkVyGwZzPkEvyjWfvpL9mrSO5hrzA65R96e9ZUroU1prcy5+n+iPnlDflD2byc3G8w+e25GN25zUr5z+fUtOKsyvNP+0EEe9CncjBX1A4KkrPGu9H/fqKYm35PV71qbi9EtnMfPb+6+ZHjwFH5bFpyP8loklf5PapbQ//vH9lZxdlZzfUazTOtX3iGvzI51J60GCMdAZ8GSXnlN4VYjHH+M5NznLsnXKuYZn7EdhDAhzf37vR/00vgL2JgZ/kLsndfBcuZ/eL3g39vm3sbX5PSn/sn2db2Bbl5y1eOSsp3Kb8232dEx/Vt4i2/TAWZD8PVTOPk+Z/Vy+F3eIHyMbv9zv4djGZXX76FOtsO7pa3CSv3/T390M0Jb5Re3QA/Zk8dnjdVHk79WRs6MWke7+Glv0P21LJvbH19iR32QPJDpXo76xT8gT4+0ZkWfTszgO2uz38gvwpSY5tfhMurNszmOx6UcynjmeEXXAXmRtn6hWB89JSc7CakynmCMxmvdDch4jeSfI+7epBY7WTNI6J9qfhXOdrkrPdeL1wKe90XnnpvD2G/4j9JK0SJ7Pp1nDnNPe6y3OmYXfi5aRL3ssN563ttzzW06i6xvONqB/j/lcIzouWk994GxE1g422n88LLpVsgf1n6MD+CrMmQAn7Bvl1rXsHJqDZw38CLTaHfSPj+FdbRp6jbuNO+hE/XmmIXseThv0319OP4z3/Dx5yvFeNpGL3PxpfIFT88C13Q705u/LU6wHfSA5Al12b+yEnrAFXTEtr7Oh46Z5a7RuhvQwfmueUxRPIHvap8QP6BwO52Ty7dyIjvk6Lu55sjz/gPaEL/Rqj3p3J73jS+tJsjQ+wUdNe2Ax+QZRTkSh5ox7Hi4bF19s07MrhmJUS8za51WdxWI6n47J1rE5soF8uefI8Zv2GjLjC0mfmCjv4JuO6+R4aQtzvYC3xjLo3Ak9Eyv/u49/++//+pD783G19pzlfBWE3sf/++Bb4cbj3eV6obXvbq319tBdG+vJ63ibXbh9WPatdWDZh9+K92fuXOzCkHdj4MLFj5ovyb5paoLhwX9U2VUES/UkwbArtq45rqvKDneOz14wmeLIxU8i7/p2v8Kvm/iHu0bW2ltsW2QQrlupVGRJFRxT8wXVk3UBfvBhEJ7kVSqupls+dxDeAieJ79iud9zlCBau9wLXpfy1f2d/8Y/cw9HyvGVkh5aGWRaxcI1ZEg7RDk82majI/p6ZJDvBj84yDK3VxnMb6+VutYHH/v6P+PK/kxv/xTwRcYuouYos24JuG7agupohGJJnCpbo2ZZj+q5ckdjl+PjPnbfD+X4Uoz8C5z/xn8yTpbP96L044Gt79fVy3gw22+V6z5EH9q4v3sINFhPeXQtrToZXm3rO7MODtZllBjHB5cHrf+/st9Pl4tJ7+ge560N1uc3caYXP1n7T2S14X1lbC3c5v3C2wZJ73VkunN0aic+7ul0Hk4m3JlRiifuvHAcA5MzhQ1SkNFnSDNVVBc2UXUE1dWBcpaIJkq2ZFdESLcnRCoxLiWx5tm0ZqiT4ji8LakUSBdMB7jekiqRaXsW1VLfwaMTXqiidx7aETBtYlywT4p8y5t3sbLqUR1fEe/Gc3darLV2v9Wa0+zj3gPRuwiU1usyF29a7xedFL3iYrj3LLUHoc9D8JCSPSOaJqmvYsidYdkUEuTQqgglkFBRPtF3L1Azds98IU6bx88GU7OvA+pYnSJ6iAmr7GiCUqwmyBCRWDN+UFfenhKmON18+ee8Jp1RHkj3dMoWKZjmCasuWYLquIUiya/qeDsQyrBKcAs5WPMXRBdcGtaxaki7YjmYKouw6huPYnu+bvyZOUTb5EYEKTAbTMhVN0ESwolTZcEC3gG4yJFtSK5qhaHZRLb1foNIsSzQd1RZcz5dASxs+cH/FFRTZUyVLEQ3JkH9KoKovnd3mPeFUxTZFyVZFwQG4AqNIB8Z1fdCwvqmKnmYYjleUSEpkx3GBqIoiSL4FRJZkQwBsUgVZlwwDnvV8R/o1cYpwyY8IU3ZFknS3ogqW7uO8QCRtoBYoGaNiiaBzPKXyC8GUIQPXVhRPkGUfnAkAcMHQFV2QXFX3DIAqRf05YerKDbbvCaUkxTENT1YE2wBrSNUNBVAKnAFbsWzPUH3T1osmUYRSvuRKtucIhqybwPKAV5btm4IMsAe+hQGcK/+aKIVM8iOCFNBJUTSAJtPXPUFVQTRNT3UFx7BcyTTBqtbVXwikfE0TKxXXEgzL0BGzfcEAb0+omKBmbRdIrVg/JUjVg0Wwmb4nmLIkQ5IU0CcOeGpAKhEAq2JY4ANKkua5tl7Ri1gTBadUxZBUkRhe8KgLFpUhWr4g27bom4rvO473a8LU5XLxQ7p8mqipko5BYsu00OWDn4CI8B+QU0fULICwXwimbKviaqLtCIoD0A3+MOI3rIlsq07FdkRd93/O2NSFOw8WHy690Nu+qwiVZAK+uCJIZAVopcq2J9i+pgiapJuWCEgle0YJWJmy7nmiagqeAjaZ6lVMwRQ9X3AVT3QUUa9Izi8aoSLMQnnlhwIrcO7A1FVkQbTBuVcVXRRsuSIJuuJLkuHrlmYovxBYgYnpVSpgWNqS7AgA475ga5Yh+OAFa44KOK4ZPyVY1ULPWn+4CEOCQZt3AlW+Zqsmdf9kULUuRpoUSxYqumbYvl8xfbcsmC6C6yA6EqglFwOznq8Lll7RBF+yKroja3rOxaeD/BWgirAKcMqPaFtJGH70RR98Ph8I7oBdbCqOIuiWo6i+Z5qS9Su5gJInKhVwAgTPtiuA3rIrYIBdAFdYq3gVzQM9/BPDFVr47wSpRLClbAugSdRtcNY9xQHMUj1Br3g6AJCqiq5YglSGrlmO6HmCq6ogzqKJHr9p496hasmaYlrGLxpOJ1zyo7qBnlxxHNlUBU0zML4o+YIFLpCgGY5vG5Zm6+KvBFWGakmup7iCIYsAVbopC6btK4JsOqZm2oZjqz+nZXXnvbyrkLrq6K7mgM2raKhidU8UDA0I5fiSI4NxBJeLGYARy1uaZcqmKYiW5gE+6Tp4juBWOKZqm27Fs0y/KM6/BFIhk/yIIGXqqonqRRAlDfwdpVIRbNMB0RQ1SVQ1oLleNKDfL0ipYEZptucKGOkA3ge/2LJ0RfBFx3BFTa9Ynv9TgtTNcvKeMMqv2KqjmY6g67aNyZ6+AK4eYJQOfCyLlg0eXAlGgVnsmrIEhrKuIkaJCjwq2YKmOo5TkQ3JcosJOb8ERgGP/IgQJTqKIRuaJoCvDxBlug6gE2gWXTFMxzXAW1d/pdQEuaK6pqiqgqGgWemiWekaoiCpPihocIDNnzSD6gZe9J4wSrUNwBUJFKrkYBaUqguWUfEF3VUcSdd0W6yUeXyWrCqmoRuCbWuGoBq6JNi6bAuWI/uGBN6D7/+ie37IJD8iSLng1RmYlSCaDigk0VPAjpJNAZwby/AsjNH8SiBVkURT1mRNAPsSlqPigH42VSC64juyJikV8H9/SpCicanb/XsKTRmaqoheRRTAS3MBbTRw+BTbFHTfdlQVCwgqemnljGm6Cu5tSxLYy54IZpXsVwRPMhRTl0VX/VUz0gmj3O5/1OBURXZFXwUryvGdCuCVBPN0LE/QDOAGyfIUMJN/IbxSXMn1TB+MKhsrwBwJM5YdVXBUx3BMR/UdxfyJ8epuuf3Q3QKbzb31OwEt4E/bU11RqOiuDhRTwQy2HANrYXzDN+2KwqlTjSKRhuL5FjqPKqhpVUETTYV/WoqluobuyyonMPvrgBYwS8wrPyJyuWZFcWVfFHRLBMLb4MmDqHqCr1iyp8mKpxhvLVD+GZHLsSuWLcFy2KoBzCyC3rZcTDRUXV3zAb80++cMqxMUanrh6r0AFq6ngRUWigwa18Mgqyo5guSomquB26BpRY2bJPo6umJLgucAt6uiLoK9ZWN+lqg5vuJhhfqvCVjIHz8iSBmuLuquIYF5JYMDX7EtwdI08IQ0xRRt1fLEX8q80nzDVBxLE3zVNIGBRXQYHAvTFERD0V3VEn9Od5DUc3nuewpbeaJYMWULyKRikbFmAq1IFxATHEHJlRzdLspatJmkSpJiI8PbHkAcvAbDVq5QcQ3P8/SKX7GKXP9L4FTEJz8iVPmypsmiqQoVzcXWARVZsHTTEzwwhk1N8l3PKHr/7xeqTEl0bBE0tOmIFgbywBPExgqeaGg+WJ6Wb/+kDV+W8xVmH78rsHI8TQEelQRFNURM1wWjSnZBLDXFs1VZrohysQ1IlDqH3V181QYvEBFLAxVtqGg4O46r2K5V8cxfNMaecMoPCVegVjzfwboC3RFIKqjt+yCkhiE7QHtF8Yq7Ku8XrmyAKUXH/lymh/nqWgVWwqqg3tYtX1ZBY/+c7l9tuVts31Wuuu06HjgCluATL87E1GUNY4waSKhX0RRdLzOsKpqsGjYYzGA5Y5Wz44H9jJ1EzIpjYZ1yxf5F86oIm/yQOCU6kqdoimB6Mm7T2zpu5oJtJWlgX+uWCS7/e8Mp+kN8P4Uaekv8q0ggMmzCgtrKW8+DLaie3iYSr8zXk8vM19nrUTBfNmTdU0xBU00FMNEC58WXLcEGkXNsB2RIznqbaUGf+4HDS8z6FZAgWBBQ412aL8nvxezy0bfDx/7Hct0/138u/mcL4MX+TH7IFm6vvYn3cvWyCgMn2Nas1Xa35n4yXDpWhGiZzwaTxXLtAUBeOA4KDAfD6S2txdZbL6yQc8NmuVs7hJzgLRiSrucIsyE78zt8AW9o0R1I1wN3OdbG63qLTbANnrgznIRL2wpry2XoLp8L89yRt/OvJYojVhYf5E9iTrVYi+0DFbNEGPjK95vw6bkdC3O9G78fpzr4PcKWDv0v/htZdUP+aVvOLFxOfnPsu+fYc3vX5dv4Od+NZdfkg4Q9XVJ0G/9I/0/+u57/Ztl3z7LntjHLNXT7fiDr4/cIXy6Wz78Z890z5rmdq7ItvL4fX3rwOcKW+ENin3q/OfTdc+i5TYvy/ZtqsbP31zOpu1xQDe+TT9Mfqa0aBTN/8+v74tf0Kly/BfZYW9slPJr+noe5Z3a24bf6+Z4hgshgtfD7bqF7zG9GTpntl2Lkc/ue5PJBSVj9ewYQ8KtWSHmZ/GNbCOz/ZuWE3X4pVj63MQanRcj35mQ3X/vxn+Ddwst/M++3NoDP7YSQbQnx/ZhyAZ+jkYP/OFf+RtS/minPLX3PtAD4fjwZLieEJeH/23y+0W/GfI+MeW69c7bw+ztyJnyOsuZvpnz3THlubSu/0Pd7G5jz/Q9hYv5mz2/Knm9yj86tczxQ+fm9uXixSf39xXK74RWg/mbrhPV+VrbmMe2ZtW7For/vyKtonk7hk4RZkx/S9Bb8CW2G33z77vn23NqnQh3Yd04X8NzfTPnumfLcGpeEKb+35RqXjfzmSY8ziPfEkueWMuSqOr4nTyLL/ObHHwMj6Q9JMcCzZ2+Wzszbdr31U44Z04u1MPAW2+zFbTCP78ffUE7/iO+gFJMV+hvvZbVcAzNjzRGOV/okfopau3ycB4tgvpv3k4fIVVGwwtXU+iSBV/bv/w/8A7uz318BAA== \ No newline at end of file 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 \ No newline at end of file