From 6bbae3fffe336830f64d5ffc37d6a61f6989ff26 Mon Sep 17 00:00:00 2001 From: Ian Gulliver Date: Fri, 23 Oct 2026 08:22:57 -0700 Subject: [PATCH] Add weighted random workflow steps and a random choice agent tool --- api/openapi.yaml | 16 +- internal/agents/kb/workflow-definitions.md | 15 +- internal/agents/lead.go | 2 +- internal/agents/manager.go | 4 +- internal/agents/random.go | 65 ++ internal/agents/workflows.go | 6 +- internal/api/api.gen.go | 696 +++++++++--------- internal/store/definition.go | 13 +- .../105-add-random-workflow-steps.sql | 17 + internal/store/workflow.go | 17 +- internal/workflow/workflow.go | 131 +++- mac/Sources/Byre/WorkflowEditor.swift | 79 +- 12 files changed, 673 insertions(+), 388 deletions(-) create mode 100644 internal/agents/random.go create mode 100644 internal/store/migrations/105-add-random-workflow-steps.sql diff --git a/api/openapi.yaml b/api/openapi.yaml index 354b558..c298e16 100644 --- a/api/openapi.yaml +++ b/api/openapi.yaml @@ -1817,8 +1817,9 @@ components: WorkflowStep: type: object description: > - Exactly one of stage (with its model or agents, and prompt), order or parallel. A stage gets the outputs of - the stages that end the step before it: the last stage of an order, every branch's last stage of a parallel. + Exactly one of stage (with its model or agents, and prompt), order, parallel or random. A stage gets the outputs + of the stages that end the step before it: the last stage of an order, every branch's last stage of a parallel, + the last stage of the step a random picked. properties: stage: { type: string, x-go-type-skip-optional-pointer: true, description: "The stage's name, one line of 1 to 100 characters, unique within the workflow." } model: { type: string, x-go-type-skip-optional-pointer: true, description: "The stage agent's model, which also picks its vendor: gpt-* models run on Codex, gemini-* models on Antigravity, every other model on Claude Code. Required without agents, refused with them." } @@ -1831,6 +1832,17 @@ components: type: array items: { $ref: "#/components/schemas/WorkflowStep" } description: Branches run at the same time, each getting the outputs of the step before the parallel. + random: + type: array + items: { $ref: "#/components/schemas/WorkflowStep" } + description: > + Steps of which one runs, picked at random when a run or review starts, each with its weight as the chance + of being picked. The run's definition holds the step it picked in place of the random. + weight: + type: number + format: double + x-go-type-skip-optional-pointer: true + description: "Its chance of being picked in the random it is directly in, from 0 to 1; the weights of a random's steps add up to 1, and a step without one has 0. Refused anywhere else." agents: type: array items: { $ref: "#/components/schemas/TeamMember" } diff --git a/internal/agents/kb/workflow-definitions.md b/internal/agents/kb/workflow-definitions.md index 366be28..bfeee27 100644 --- a/internal/agents/kb/workflow-definitions.md +++ b/internal/agents/kb/workflow-definitions.md @@ -11,8 +11,9 @@ Each step is exactly one of: | `stage` | A stage, by its name: one line, unique in the workflow. It runs as its own task, with `model` or `agents`, and `prompt`. | | `order` | A list of steps run one after another. | | `parallel` | A list of branches run at the same time, each a step (an `order` for a branch of several). | +| `random` | A list of steps of which one runs, picked when a run or review starts. Each step in it has a `weight` from 0 to 1, its chance of being picked, and the weights add up to 1. `weight` is refused anywhere else. | -A stage gets the outputs of the stages that end the step before it: the last stage of an `order`, or the last stage of every branch of a `parallel`. A stage with nothing before it starts from the brief. +A stage gets the outputs of the stages that end the step before it: the last stage of an `order`, or the last stage of every branch of a `parallel`. A stage with nothing before it starts from the brief. A run or review freezes the definition with each `random` replaced by the step it picked, so `read_workflow` with its `task_id` shows only what runs, and the stages of steps it didn't pick never appear in it. | Stage field | Meaning | |---|---| @@ -20,18 +21,22 @@ A stage gets the outputs of the stages that end the step before it: the last sta | `prompt` | The stage agent's instructions. | | `agents` | In place of `model`: a list of at least two, each with `name`, `model` and `prompt`, that runs the stage as a team. They work in the stage's one task and worktree and talk through a shared board; each gets the stage's `prompt` and then its own, and the first agent finishes the stage. | -Where a stage's task branches from follows from the shape. A stage after exactly one stage starts from the commit that stage finished at. A stage after a `parallel` starts from the default branch and is told the branches it can merge. A stage with nothing before it starts where the workflow was started. A run on a brief has a task of its own, with no agent, worktree or branch, and its stage tasks are that task's subtasks; it closes once they all have. A workflow is finished once every stage has finished; when it ends with a `parallel`, each branch's last stage keeps its task to merge, and the run's other stage tasks are discarded. A review is delivered to the task's agent, every stage's findings in one message, once every stage has reviewed. An `order` or `parallel` can't be empty. +Where a stage's task branches from follows from the shape. A stage after exactly one stage starts from the commit that stage finished at. A stage after a `parallel` starts from the default branch and is told the branches it can merge. A stage with nothing before it starts where the workflow was started. A run on a brief has a task of its own, with no agent, worktree or branch, and its stage tasks are that task's subtasks; it closes once they all have. A workflow is finished once every stage has finished; when it ends with a `parallel`, each branch's last stage keeps its task to merge, and the run's other stage tasks are discarded. A review is delivered to the task's agent, every stage's findings in one message, once every stage has reviewed. An `order`, `parallel` or `random` can't be empty. ```json { - "description": "Build a change, review and test it in parallel, then fix what they found.", + "description": "Build a change, review and test it in parallel, now and then auditing security in depth, then fix what they found.", "steps": [ {"stage": "Build", "model": "claude-opus-5-5", "prompt": "Implement the brief."}, {"parallel": [ {"stage": "Review", "model": "gpt-6.1-sol", "prompt": "Review the Build stage's work and list the problems."}, - {"stage": "Test", "model": "gemini-4-argon-high", "prompt": "Exercise the change and report what fails."} + {"stage": "Test", "model": "gemini-4-argon-high", "prompt": "Exercise the change and report what fails."}, + {"random": [ + {"weight": 0.8, "stage": "Security check", "model": "claude-sonnet-5-5", "prompt": "Check the change for security problems."}, + {"weight": 0.2, "stage": "Security audit", "model": "claude-fable-5-1", "prompt": "Audit the change thoroughly for security problems, tracing every input it touches."} + ]} ]}, - {"stage": "Fix", "prompt": "Merge the branches you are given and address both reports.", "agents": [ + {"stage": "Fix", "prompt": "Merge the branches you are given and address every report.", "agents": [ {"name": "fixer", "model": "claude-opus-5-5", "prompt": "Fix every problem the reports list."}, {"name": "checker", "model": "gpt-6.1-sol", "prompt": "Check each fix as the fixer lands it."} ]} diff --git a/internal/agents/lead.go b/internal/agents/lead.go index e854307..7e1c8a7 100644 --- a/internal/agents/lead.go +++ b/internal/agents/lead.go @@ -33,7 +33,7 @@ const leadGuidance = `You are the human's lead agent in byre, shown in the left - You can create tasks, start TODO items, message, interrupt and compact task agents, and merge or discard tasks. Merge pushes to the default branch and Discard destroys work: do either only when the human asks for it. - Setup: when the human asks you to set byre up, or about the tools or macOS permissions its agents need, read the setup knowledge-base article and walk them through it, running its checks and fixes yourself with your own Bash on this Mac and with list_clients and client_bash on their Macs. Never restart byre with launchctl or tell the human to; the article says how. - Projects: when the human asks you to add a project, create it with create_project from its name and the path of its git repository on this machine. When they only hint at where it is, find it yourself. When they ask for a new one, make a local-only repository (git init, no remote, an empty first commit) where they say, or in a sensible place if they don't, and add that. -- Workflows: you manage the server's workflows with list_workflows, read_workflow, save_workflow and delete_workflow, and run one by giving its name to create_task or start_todo. A workflow is a tree of steps run in order, each a stage, an order or a parallel; every stage runs as its own task on the stage's model once the step before it has finished, so stages fan out (a parallel after a stage) and fan in (a stage after a parallel); a stage's agent calls finish_stage to hand its output to the stages after it, signals tell you when a stage starts and when the workflow finishes, and the workflow finishes once every stage has; byre then discards the run's other stage tasks, leaving the task of each last stage (one per branch when it ends in a parallel) to merge. Each last stage's agent is asked whether its task is ready to merge as soon as its own stage has finished and been reviewed, without waiting for the other last stages. Whenever you show or propose a workflow, draw it as a fenced diagram block (its format is the diagrams knowledge-base article) of its stage names only, with no models: one row per step, a parallel's stages side by side in one row, and an arrow into each stage from the stages before it. For example, rows holding Build; Review and Test; Fix, with the arrows "build -> review", "build -> test", "review -> fix" and "test -> fix". +- Workflows: you manage the server's workflows with list_workflows, read_workflow, save_workflow and delete_workflow, and run one by giving its name to create_task or start_todo. A workflow is a tree of steps run in order, each a stage, an order, a parallel or a random (one of its weighted steps, picked when the run starts); every stage runs as its own task on the stage's model once the step before it has finished, so stages fan out (a parallel after a stage) and fan in (a stage after a parallel); a stage's agent calls finish_stage to hand its output to the stages after it, signals tell you when a stage starts and when the workflow finishes, and the workflow finishes once every stage has; byre then discards the run's other stage tasks, leaving the task of each last stage (one per branch when it ends in a parallel) to merge. Each last stage's agent is asked whether its task is ready to merge as soon as its own stage has finished and been reviewed, without waiting for the other last stages. Whenever you show or propose a workflow, draw it as a fenced diagram block (its format is the diagrams knowledge-base article) of its stage names only, with no models: one row per step, a parallel's stages side by side in one row, and an arrow into each stage from the stages before it. For example, rows holding Build; Review and Test; Fix, with the arrows "build -> review", "build -> test", "review -> fix" and "test -> fix". - Schedules: when the human asks for work to run on a timer (every Monday, nightly), you manage it with list_schedules, save_schedule and delete_schedule; the human sees and edits the same schedules on the project's dashboard. Every schedule runs a saved workflow: for a one-agent chore, save a one-stage workflow with save_workflow first. On each run, byre starts the schedule's workflow as create_task with workflow would, created by byre, and you get its created signal; a run that fails to start reaches you as a signal. - Whenever you name a task in a message, link it as a Markdown link to #/task/, for example [Fix login redirect](#/task/tskDa7e4K7305e). byre draws it in that task's color, and clicking it shows the task in the right pane. To also open one of its other views over the human's left pane, append it: #/task//, where view is changes, files, terminal or board. To show a project's dashboard in the right pane, link to #/project/. - Keep messages short; the human reads them in half the screen. Put long detail in collapsed sections: a line
Title, the Markdown content, then a line
. diff --git a/internal/agents/manager.go b/internal/agents/manager.go index cf286dc..e70aa54 100644 --- a/internal/agents/manager.go +++ b/internal/agents/manager.go @@ -867,7 +867,7 @@ func (m *Manager) startLive(ctx context.Context, sess api.AgentSession, task api if err != nil { return nil, err } - tools := append([]mcp.Tool{m.askTool(l), m.cancelQuestionTool(l), m.setTitlesTool(l), m.stopMergeTool(l), m.mergeToMainTool(l), m.setTaskSummaryTool(l), m.searchClosedTool(l), m.exposePortTool(l), m.takeSnapshotTool(l), m.terminalReadTool(l), m.terminalTypeTool(l), m.bashTool(l), m.readKnowledgeTool(), m.renderDiagramTool(), m.exportDiagramTool(l)}, append(append(m.fileTools(l), m.subtaskTools(l)...), m.clientTools(l)...)...) + tools := append([]mcp.Tool{m.askTool(l), m.cancelQuestionTool(l), m.setTitlesTool(l), m.stopMergeTool(l), m.mergeToMainTool(l), m.setTaskSummaryTool(l), m.searchClosedTool(l), m.exposePortTool(l), m.takeSnapshotTool(l), m.terminalReadTool(l), m.terminalTypeTool(l), m.bashTool(l), m.readKnowledgeTool(), m.renderDiagramTool(), m.exportDiagramTool(l), m.randomChoiceTool()}, append(append(m.fileTools(l), m.subtaskTools(l)...), m.clientTools(l)...)...) lead := true if sess.Role == api.Implementer { g += longTitleGuidance(task) @@ -937,7 +937,7 @@ func (m *Manager) startLive(ctx context.Context, sess api.AgentSession, task api return nil, err } l.notes = "\n\n" + notes - tools = append(append(m.leadTools(l), m.readKnowledgeTool(), m.renderDiagramTool(), m.exportDiagramTool(l)), m.clientShellTools()...) + tools = append(append(m.leadTools(l), m.readKnowledgeTool(), m.renderDiagramTool(), m.exportDiagramTool(l), m.randomChoiceTool()), m.clientShellTools()...) } env := git.IdentityEnv(l.gitName, l.gitEmail) servers := []*mcp.Server{{Name: "byre", Version: "0.0.0", Tools: tools}} diff --git a/internal/agents/random.go b/internal/agents/random.go new file mode 100644 index 0000000..b8c8b44 --- /dev/null +++ b/internal/agents/random.go @@ -0,0 +1,65 @@ +package agents + +import ( + "context" + "encoding/json" + "fmt" + + "g.fc.run/ai/byre/internal/mcp" + "g.fc.run/ai/byre/internal/workflow" +) + +func (m *Manager) randomChoiceTool() mcp.Tool { + return mcp.Tool{ + Name: "random_choice", + Description: "Pick one of several choices at random, each with its weight as the chance of being picked, and get back the one picked. " + + "When the weights add up to less than 1, the rest is the chance that none is picked, which comes back as \"No match\". " + + "Use it whenever you are told to choose by chance, rather than choosing yourself.", + InputSchema: json.RawMessage(`{ + "type": "object", + "properties": { + "choices": { + "type": "array", + "minItems": 1, + "items": { + "type": "object", + "properties": { + "choice": {"type": "string", "description": "What this choice is, returned as it is when it is picked."}, + "weight": {"type": "number", "minimum": 0, "maximum": 1, "description": "Its chance of being picked, from 0 to 1. The weights of all the choices add up to at most 1."} + }, + "required": ["choice", "weight"] + } + } + }, + "required": ["choices"] + }`), + Rich: func(ctx context.Context, raw json.RawMessage) mcp.Result { + args := struct { + Choices []struct { + Choice string `json:"choice"` + Weight float64 `json:"weight"` + } `json:"choices"` + }{} + err := json.Unmarshal(raw, &args) + if err != nil { + return mcp.TextResult(fmt.Sprintf("malformed random_choice call: %v", err), true) + } + if len(args.Choices) == 0 { + return mcp.TextResult("choices is empty", true) + } + weights := []float64{} + for _, c := range args.Choices { + weights = append(weights, c.Weight) + } + p := workflow.ChoiceWeightsProblem(weights) + if p != "" { + return mcp.TextResult(p, true) + } + i := workflow.Pick(weights, 1) + if i < 0 { + return mcp.TextResult("No match: none of the choices was picked.", false) + } + return mcp.TextResult(args.Choices[i].Choice, false) + }, + } +} diff --git a/internal/agents/workflows.go b/internal/agents/workflows.go index d34db32..0f220ef 100644 --- a/internal/agents/workflows.go +++ b/internal/agents/workflows.go @@ -773,14 +773,16 @@ const workflowDefinitionSchema = `{ const workflowSchemaDefs = `"$defs": { "step": { "type": "object", - "description": "Exactly one of stage (with model or agents, and prompt), order or parallel.", + "description": "Exactly one of stage (with model or agents, and prompt), order, parallel or random. A step directly in a random also has its weight.", "properties": { "stage": {"type": "string"}, "model": {"type": "string"}, "prompt": {"type": "string"}, "agents": {"type": "array", "items": {"$ref": "#/$defs/agent"}}, "order": {"type": "array", "items": {"$ref": "#/$defs/step"}}, - "parallel": {"type": "array", "items": {"$ref": "#/$defs/step"}} + "parallel": {"type": "array", "items": {"$ref": "#/$defs/step"}}, + "random": {"type": "array", "items": {"$ref": "#/$defs/step"}}, + "weight": {"type": "number", "minimum": 0, "maximum": 1} }, "additionalProperties": false }, diff --git a/internal/api/api.gen.go b/internal/api/api.gen.go index 7c21f9d..a2ec62e 100644 --- a/internal/api/api.gen.go +++ b/internal/api/api.gen.go @@ -1816,7 +1816,7 @@ type WorkflowRunStage struct { // WorkflowRunStageState waiting: no task yet. Otherwise the state of its latest finished attempt, or of its latest attempt when none has finished. type WorkflowRunStageState string -// WorkflowStep Exactly one of stage (with its model or agents, and prompt), order or parallel. A stage gets the outputs of the stages that end the step before it: the last stage of an order, every branch's last stage of a parallel. +// WorkflowStep Exactly one of stage (with its model or agents, and prompt), order, parallel or random. A stage gets the outputs of the stages that end the step before it: the last stage of an order, every branch's last stage of a parallel, the last stage of the step a random picked. type WorkflowStep struct { // Agents Runs the stage as a team: several agents in the stage's one task and worktree, each on its own model, sharing a board. The first agent finishes the stage. Agents *[]TeamMember `json:"agents,omitempty"` @@ -1833,8 +1833,14 @@ type WorkflowStep struct { // Prompt The stage agent's instructions; with agents, the instructions every agent of the team gets before its own. Prompt string `json:"prompt,omitempty"` + // Random Steps of which one runs, picked at random when a run or review starts, each with its weight as the chance of being picked. The run's definition holds the step it picked in place of the random. + Random *[]WorkflowStep `json:"random,omitempty"` + // Stage The stage's name, one line of 1 to 100 characters, unique within the workflow. Stage string `json:"stage,omitempty"` + + // Weight Its chance of being picked in the random it is directly in, from 0 to 1; the weights of a random's steps add up to 1, and a step without one has 0. Refused anywhere else. + Weight float64 `json:"weight,omitempty"` } // WorkflowSummary defines model for WorkflowSummary. @@ -5074,368 +5080,370 @@ func HandlerWithOptions(si ServerInterface, options StdHTTPServerOptions) http.H // const string: with thousands of chunks the chained `+` fold is several // times slower for the Go compiler than parsing a slice literal. var swaggerSpec = []string{ - "7L1rcxy5tSD4VxC1G0HpTpJU2+3ZvWTsB1nqtjW31a0R5enYtR1lsBKsgpkFVANIUWyF9rdPnAcemYWs", - "KlKiJD++SMVMJB4HBwfnfd7PFna9sUaZ4Gdn72dO+Y01XuEf3zlnHfxYWBOUCfBTbjadXsigrTn9u7cG", - "nvnFSq0l/Po/nbqanc3+j9Pc6ym99afU24cPH5pZq/zC6Q10MjujYU5m8ILbQldPl8qEV84ulMe/N85u", - "lAuaprZSsgsr+DXsy4d+cS3WShovpAi9M0J74XpjtFkKaVphrPDBKbkW6q0yQaykF9I5/Va14so6gT3M", - "5VVQbu7VwprWnwv1TgfVcr9hpcSGJgadL61RJ7Nmpky/np39eWavZw3NAx7ih7O/NrNwu1E4QafNctbM", - "3h3DB8dvpTNyDYv68+yPuKif4Dv6ecG90F/fcV8fmlknfZjj/OcybEPh55Uyg2lCe3HjbFBCik4bJYIV", - "OngGxayZXVm3hq5mrQzqOOi1mjUz68QNdKWD8EG6oNqT2Znpu268nA/NbKNbmAg/1yaopXLwwivvtTXz", - "wfv8nQ8yKHgjvbBG4LZf0CdpsOHq3qyU4E6PvKDvKxMK0l9PDfpWmda6yqsPzcypX3rtVAs7Usw9d5g+", - "p0XHJYx3pYlImjffXv5dLQJMoFzmNnYvnJJBtby31a3ZWlL85vK2uuIr665TjyNs0WEl+P2Vs+szRB1a", - "45EXuhX2Ch8hFoUVnCT4Ez4R10ptfCOkWCvv5RKfimed7FslntlWNfEY4nPbqncntdkXw29P8CkOdeTF", - "lXaeUVE45fu1gtOoPU82YkUjFn0QMoi06Eb0plVOSGHUDbee5809F/LSK4MfCBtWKnXlq7OdwKq1Wl8q", - "tz1/QFgJG37kBRx2oQ0ePkCoIy+CkutzodabcAsnQOJzcQO7Yg1/2SDtgul1SrYe/3LqrVY3ytXnuLat", - "6rbn8lr90iuPxAwaxHEzZUv73qor2XfhRDyNwBDWdLfC3+iwWCkvLlW4UYqWYm9M/hJ7rs/K3pgpCHV2", - "qY24WVmvcJG0cNpf7eNEAQQyQs5HOlGjR7L3qq0hE4I37gc2OxNr3R7TbRHEynYA4YALM+odYJzaiEd4", - "JyCMgrWdWMiuE9bRaukvbYDiLp3ygKtG+5Xyj8+FbjvVwMWDIyD60g7ymfHil171SvQm6I4Ruy0WdWlt", - "p6SBVTnbqe01RUw4E5KxIgNHPPJKidf49PH5Fuy86LQPAPC3eJiUV8L2obzQ9HrTqbUyQTkgckq2syYN", - "uX21lTQ9ddF2Cj6ie3jWINfRqcOvxpJeXkDvL6jHreev0xBbr57lMWGO/SXigN8G5x/tjVhLcxvpXsSV", - "9ImQTkWmohGXcnG9dLY3LZxXL7RZdH2rWlEgDGx8WMl0j8LTNfIeyrSDzS5uzuIGG3FMxVHAo7LrIOS7", - "btjJ97br7I0XQHNxkoTIId+u4kZ6wfcK0qMzsdyE4/+glshWAcFCqt6IpVpro/NbuMxN0Esn3+pw2wC7", - "5W6ZutJQ1pQ3RYlyC3yMeNKqd7NmJnNPs79OLnI+5DWG6y2GKk6HbhuxAJpjxOWtuLx16hwOdVhRy3ci", - "rBxAGG5BVy5ILKx5q5yXIXZDBIoOcQnF4taqEcURyzFiNYhgFiwH0fXaijMjglQi3UcD3qApmYvyFCSK", - "WWVXQpCL1ZplgBGzIhnClRux1XLpZOVK5xdnwtveLRScNCn+9re/8XNx2dnFdRWdlWnnwMHWmU29lssK", - "gcTHZ6KVQYo/vf6h2vG1Nm1Js640ArHVV1ez2HFeEe0RQNDIjV9ZAGbvuipybmRNVIH+z4RTG3vsVCeD", - "fqsEtDwRPFtp6JeAlnC3ICUh6n1j3XVwSjXAudiuDwrQM/WD3H11lSigbe/G1dWZWOqAtwcirZNmqao9", - "xAXvYOhd2LFFu/hygOBephw3qoqlN/J2Gz8lPx1fpqNesVmt19939rKC9SQSz6n5+2l+/BPy8FWg1cjH", - "YHLTx7+6Witd+8r68AzbbS88qHdh/zSwVa3/Z51WJnz3Ti0qMMV3de6Q3kUG2jox4trpAvNBOLVQJnS3", - "Qi7wKLB0vg1ru15LU7knXveGmO9f/UpILyRzpn6liMWDoVZ2rUSrnVoE6wCsOvPBUegGnmAzLTADEtg+", - "zNcVDuS/dNcNBHjsKzEU2ovOmmWNaxjtQ1zlYLjd+/Ja+b4Ld9udLCNSK+J1nDRTZAj0InO43Cd0BqFV", - "zg0OzuVtXcz3obV9OKDpGDK0nHIqqbM0gWlIvVab7nZC1NtshFem9Si+OWhICCUXC7UJqhVeBcAsb0Hc", - "80IT1mrgwKVwJKE1wlvkR8S1ATYNetAgHa7tOkEYIP5SLoQmNl4RQxpWyuDYV9rIrpiB7QNsyF/MrBkT", - "SZ7a9oouVCC5zxLmEzeDfTbiZqUXK+HlLcmOsHJeCXK4cS0o7ETO146QopBu4H6uSTeyndNtSRPogIFj", - "GudPhNdLQ69aBWwKAFgvjQy9UydiI5dqDjxK7+BOFa9+/EPE1SAvT2bNPrxpZirqQbchcxM1bXGlC9t3", - "rTkK4lKJhXROqzbKU7sPwbDvS+lXjVDv1KIp1gcfABxD7xtx/E1SzgGffq27TrXAxKJqgU57Xa7QbR1x", - "eQ2o86lL733Y9KE+2zNBh4f3Go6PCHapwkq5RshA1DmslHakSPrv34r/0r8vtw9+gXIJZWi5PvLcD+CZ", - "cgpX6nRQHpf4B9O/+gNDA3WanpQkYaVKin3kBU37RNiNMnPAh4awIshLzz+NfKuXMsQ3f/dn4iYeMMDq", - "Fhj8eM8gxzzBXUXaKdtWA3Rk96o4aMH1aqzOXEnT+rOkVzjy4uWzV+KZ7Lo31nZEjU9mFUKUieSwQ8Ca", - "MxK3srKOLwJWAgfLoD0I/zOJvedAjIl3I9C63Ul+EVUrykxQSspCx9MIFJPXysG+S38NNHZhjVGLoFqk", - "nsGK1jYCeQn7VjlxKjf6lC4If8ptT7Zpplv266hB+Jj9Th1Vt7lOIBKaQj+XtkVlhYTr5NYsxFVvFtAQ", - "lgZSehIeLlHltVTneIScQsXEW9n1SmjPhGyEcAewTJlaneFwd2SfGjHNPVWmUb8lkDJsXxOg741XxbnY", - "SAebHEfWilQ5zBOXtKg38Fu1iM86CNqPeOPFexfa0NUcuTWUXmEtIE0trLnSS2RZPVIPfLFZntBJEI+A", - "Im2WG0DRd7978p+PG9QjqlZI7kB2nefrcu8xbasHot90VrZnTEKRfLnFSr8F4FijhDLB3QpkV/rNUJzE", - "GxvONS7w/z89R5oI552RxSHWAC8gF6q9i6pct1VeMsOfwB7w7vDiL7Mfge3/S//kyW8Xai11hz/VX2YN", - "khi9REYq3cYv5eJosAWgaTNW9F65E75mrtVt/ZLblFoAQG1kEtVi1jAwZ82stTeGfyb2ZNYUSDhr6KDP", - "GlzUrJml2yf+5mbpKoq/410U//57esNszB2UDHGejUjTbETtqIhH1tENlz/B59al43L7ODKBRBt3Y8vg", - "vk0Lro2YXlaGbITMfwCawgjaiNM0F6/cW+WGcykVIRWtyUndXng5QWa3mINmxFUybW2A+4LfpgfFW2Yy", - "kDn3W/JqkJf4P7QToE4XfmVv/LQyeHt+0yCG9uJSed0qNqoEJw19m9gaHC/tyFnesUiR09SK/uO773Wn", - "PDLR+9mpOsT8NU8tQwDBFVYK5XcxodLeJTpvc87X9xammxnc0NtjFFc4SGjH+DdZhYJFol2fNmzAVc3+", - "FYk0goVbCd1Cb0sVSEU/YEpiI3/6Pv580X44SYe32tWmD+UFIIKtTpOVcBOIBjLUjboUsm3RzhUsYoZA", - "2dTQDgptfFASlQKk0hxgBU2u6ABmfKBm3G52cIUXt2YxKZMfedHJoHyIprlW6Ged7VuBLJPdKIe6/HxM", - "AeoyajRIr4+i+sa64KNiacQTTnlj6DzsyZS7xaGC58+rW+xP6k5lLRhefrauNLfX1WmhLQYVCWn1wveL", - "hVJt3QA52hF0dZlQJIK1TS4m1YgT5umX8DgRSECnZNO3RiiNMybTx4mAjbVdsn4JH+Cks4iIbKY0rb26", - "OhHPyZbt431QfBXt1XX8qyyLJYdnSR02XNhlr7t2FxJig3hFPNLBi2ff/743baf+l3K0VJjin4x+h2J8", - "FPDhu/C4IbSEz34PpOf32NtKyVa5aCNPbBCjLqKH2aUI1RN6PeKg4H26MtJUcCKAyoP5PKPWB09oSjua", - "JLTdDk5JLfyzurywi2sVsmx3+Dlr1Vu9UHUQgLUB6Bi1SWBwvUET5yMQA6wT+tXKGrW1Pc/pKwJHFfwr", - "6yeATyNGlfew3z9aH3b1OqXiefE8rWAtWyX6zdjDa3tHac/iYFMbhs5PEqXO6S1DfSa0zGrCpPCkE9uv", - "paGpsV1a+4Q12izowo1zHdK+iOGH7TlKpXUDFt8iu5wZi/umek1R77y7CcHSYWuYTIzwvEZHmXS9jPRy", - "gozuvjqpWbV77b4DCXC7a7001tU0wkAU6CVRWZQgz8TJUgd6nNRwZOxX79AfAllML9YyLFaAb9YNWHt5", - "ad+qSc0wHIH6Zulf1ZRtFVAY3gsNmBeUH2CHNuG/f1tl+vztutPmumY0jM23sVuGDAyhPUg24F8B4gr3", - "508IIGjZpXbE/a5VkGiaXkhjLKqOnQIBjECEuNMIT+TNOrHRm4G3RKsdLIzESRziQK+auPlvbjfqOXZS", - "PvmeOiwf/USdj9ELd4dHzODjzWkSJk3g3w/ag9y4jYEAI/6pg1r7fYcy4XK+uKVz8nZaPEYyW4iaO0TI", + "7L1rcxy5tSD4VxC1G0HpTpKU7PbsXjL2gyx125prdWtEeTp2bUcZrASrYGYB1QBSFK3Q/vaJ88Ajs5BV", + "RUqU5McXqZiJxOPg4OC8z4fZwq431igT/Ozsw8wpv7HGK/zje+esgx8La4IyAX7KzabTCxm0Nad/89bA", + "M79YqbWEX/+nU1ezs9n/cZp7PaW3/pR6+/jxYzNrlV84vYFOZmc0zMkMXnBb6OrZUpnw2tmF8vj3xtmN", + "ckHT1FZKdmEFv4Z9+dAvrsVaSeOFFKF3RmgvXG+MNkshTSuMFT44JddCvVMmiJX0Qjqn36lWXFknsIe5", + "vArKzb1aWNP6c6He66Ba7jeslNjQxKDzpTXqZNbMlOnXs7M/zez1rKF5wEP8cPaXZhZuNwon6LRZzprZ", + "+2P44PiddEauYVF/mv0eF/UTfEc/L7gX+ut77utjM+ukD3Oc/1yGbSj8vFJmME1oL26cDUpI0WmjRLBC", + "B8+gmDWzK+vW0NWslUEdB71Ws2ZmnbiBrnQQPkgXVHsyOzN9142X87GZbXQLE+Hn2gS1VA5eeOW9tmY+", + "eJ+/80EGBW+kF9YI3PYL+iQNNlzd25US3OmRF/R9ZUJB+uupQd8p01pXefWxmTn1S6+damFHirnnDtPn", + "tOi4hPGuNBFJ8+bby7+pRYAJlMvcxu6FUzKolve2ujVbS4rfXN5WV3xl3XXqcYQtOqwEv79ydn2GqENr", + "PPJCt8Je4SPEorCCkwR/wifiWqmNb4QUa+W9XOJT8byTfavEc9uqJh5DfG5b9f6kNvti+O0JPsOhjry4", + "0s4zKgqnfL9WcBq158lGrGjEog9CBpEW3YjetMoJKYy64dbzvLnnQl56ZfADYcNKpa58dbYTWLVW60vl", + "tucPCCthw4+8gMMutMHDBwh15EVQcn0u1HoTbuEESHwubmBXrOEvG6RdML1OydbjX0690+pGufoc17ZV", + "3fZc3qhfeuWRmEGDOG6mbGnfW3Ul+y6ciGcRGMKa7lb4Gx0WK+XFpQo3StFS7I3JX2LP9VnZGzMFoc4u", + "tRE3K+sVLpIWTvurfZwogEBGyPlIJ2r0SPZetTVkQvDG/cBmZ2Kt22O6LYJY2Q4gHHBhRr0HjFMb8Qjv", + "BIRRsLYTC9l1wjpaLf2lDVDcpVMecNVov1L+8bnQbacauHhwBERf2kE+M1780qteid4E3TFit8WiLq3t", + "lDSwKmc7tb2miAlnQjJWZOCIR14p8QafPj7fgp0XnfYBAP4OD5PyStg+lBeaXm86tVYmKAdETsl21qQh", + "t6+2kqanLtpOwUd0D88a5Do6dfjVWNLLC+j9JfW49fxNGmLr1fM8Jsyxv0Qc8Nvg/L29EWtpbiPdi7iS", + "PhHSqchUNOJSLq6XzvamhfPqhTaLrm9VKwqEgY0PK5nuUXi6Rt5DmXaw2cXNWdxgI46pOAp4VHYdhHzX", + "DTv5wXadvfECaC5OkhA55NtV3Egv+F5BenQmlptw/B/UEtkqIFhI1RuxVGttdH4Ll7kJeunkOx1uG2C3", + "3C1TVxrKmvKmKFFugY8RT1r1ftbMZO5p9pfJRc6HvMZwvcVQxenQbSMWQHOMuLwVl7dOncOhDitq+V6E", + "lQMIwy3oygWJhTXvlPMyxG6IQNEhLqFY3Fo1ojhiOUasBhHMguUgul5bcWZEkEqk+2jAGzQlc1GegkQx", + "q+xKCHKxWrMMMGJWJEO4ciO2Wi6drFzp/OJMeNu7hYKTJsVf//pXfi4uO7u4rqKzMu0cONg6s6nXclkh", + "kPj4TLQySPHHN3+odnytTVvSrCuNQGz11dUsdpxXRHsEEDRy41cWgNm7roqcG1kTVaD/M+HUxh471cmg", + "3ykBLU8Ez1Ya+iWgJdwtSEmIet9Ydx2cUg1wLrbrgwL0TP0gd19dJQpo27txdXUmljrg7YFI66RZqmoP", + "ccE7GHoXdmzRLr4cILiXKceNqmLpjbzdxk/JT8eX6ahXbFbr9bedvaxgPYnEc2r+YZof/4w8fBVoNfIx", + "mNz08a+u1krXvrY+PMd22wsP6n3YPw1sVev/eaeVCd+/V4sKTPFdnTukd5GBtk6MuHa6wHwQTi2UCd2t", + "kAs8Ciydb8PartfSVO6JN70h5vvvfiWkF5I5U79SxOLBUCu7VqLVTi2CdQBWnfngKHQDT7CZFpgBCWwf", + "5usKB/JfuusGAjz2lRgK7UVnzbLGNYz2Ia5yMNzufXmjfN+Fu+1OlhGpFfE6TpopMgR6kTlc7hM6g9Aq", + "5wYH5/K2Lub70No+HNB0DBlaTjmV1FmawDSk3qhNdzsh6m02wivTehTfHDQkhJKLhdoE1QqvAmCWtyDu", + "eaEJazVw4FI4ktAa4S3yI+LaAJsGPWiQDtd2nSAMEH8lF0ITG6+IIQ0rZXDsK21kV8zA9gE25M9m1oyJ", + "JE9te0UXKpDcZwnziZvBPhtxs9KLlfDylmRHWDmvBDncuBYUdiLna0dIUUg3cD/XpBvZzum2pAl0wMAx", + "jfMnwuuloVetAjYFAKyXRobeqROxkUs1Bx6ld3Cnitc//i7iapCXJ7NmH940MxX1oNuQuYmatrjShe27", + "1hwFcanEQjqnVRvlqd2HYNj3pfSrRqj3atEU64MPAI6h9404fpqUc8CnX+uuUy0wsahaoNNelyt0W0dc", + "XgPqfOrSex82fajP9kzQ4eG9huMjgl2qsFKuETIQdQ4rpR0pkv77d+K/9G/L7YNfoFxCGVqujzz3A3im", + "nMKVOh2UxyX+zvSvf8fQQJ2mJyVJWKmSYh95QdM+EXajzBzwoSGsCPLS808j3+mlDPHN3/yZuIkHDLC6", + "BQY/3jPIMU9wV5F2yrbVAB3ZvS4OWnC9GqszV9K0/izpFY68ePX8tXguu+6ttR1R45NZhRBlIjnsELDm", + "jMStrKzji4CVwMEyaA/C/0xi7zkQY+LdCLRud5JfRNWKMhOUkrLQ8TQCxeS1crDv0l8DjV1YY9QiqBap", + "Z7CitY1AXsK+U06cyo0+pQvCn3Lbk22a6Zb9OmoQPmW/U0fVba4TiISm0M+lbVFZIeE6uTULcdWbBTSE", + "pYGUnoSHS1R5LdU5HiGnUDHxTna9EtozIRsh3AEsU6ZWZzjcHdmnRkxzT5Vp1G8JpAzb1wToe+NVcS42", + "0sEmx5G1IlUO88QlLeoN/FYt4rMOgvYj3njx3oU2dDVHbg2lV1gLSFMLa670EllWj9QDX2yWJ3QSxCOg", + "SJvlBlD0/W+e/OfjBvWIqhWSO5Bd5/m63HtM2+qB6Dedle0Zk1AkX26x0u8AONYooUxwtwLZlX4zFCfx", + "xoZzjQv8/0/PkSbCeWdkcYg1wAvIhWrvoirXbZWXzPAnsAe8O7z48+xHYPv/3D958uuFWkvd4U/151mD", + "JEYvkZFKt/EruTgabAFo2owVvVfuhK+Za3Vbv+Q2pRYAUBuZRLWYNQzMWTNr7Y3hn4k9mTUFEs4aOuiz", + "Bhc1a2bp9om/uVm6iuLveBfFv/+W3jAbcwclQ5xnI9I0G1E7KuKRdXTD5U/wuXXpuNw+jkwg0cbd2DK4", + "b9OCayOml5UhGyHzH4CmMII24jTNxSv3TrnhXEpFSEVrclK3F15OkNkt5qAZcZVMWxvgvuC36UHxlpkM", + "ZM79lrwa5CX+D+0EqNOFX9kbP60M3p7fNIihvbhUXreKjSrBSUPfJrYGx0s7cpZ3LFLkNLWi//juB90p", + "j0z0fnaqDjF/zVPLEEBwhZVC+V1MqLR3ic7bnPP1vYXpZgY39PYYxRUOEtox/k1WoWCRaNenDRtwVbN/", + "RSKNYOFWQrfQ21IFUtEPmJLYyJ9+iD9fth9P0uGtdrXpQ3kBiGCr02Ql3ASigQx1oy6FbFu0cwWLmCFQ", + "NjW0g0IbH5REpQCpNAdYQZMrOoAZH6gZt5sdXOHFrVlMyuRHXnQyKB+iaa4V+nln+1Ygy2Q3yqEuPx9T", + "gLqMGg3S66OovrEu+KhYGvGEU94YOg97MuVucajg+fPqFvuTulNZC4aXn60rze11dVpoi0FFQlq98P1i", + "oVRbN0COdgRdXSYUiWBtk4tJNeKEefoVPE4EEtAp2fStEUrjjMn0cSJgY22XrF/CBzjpLCIimylNa6+u", + "TsQLsmX7eB8UX0V7dR3/KstiyeF5UocNF3bZ667dhYTYIF4Rj3Tw4vkPv+1N26n/pRwtFab4R6Pfoxgf", + "BXz4LjxuCC3hs98C6fkt9rZSslUu2sgTG8Soi+hhdilC9YRejzgoeJ+ujDQVnAig8mA+z6n1wROa0o4m", + "CW23g1NSC/+sLi/s4lqFLNsdfs5a9U4vVB0EYG0AOkZtEhhcb9DE+QjEAOuEfr2yRm1tzwv6isBRBf/K", + "+gng04hR5T3s9/fWh129Tql4Xr5IK1jLVol+M/bw2t5R2rM42NSGofOTRKlzestQnwkts5owKTzpxPZr", + "aWhqbJfWPmGNNgu6cONch7QvYvhhe45Sad2AxbfILmfG4r6pXlPUO+9uQrB02BomEyM8r9FRJl2vIr2c", + "IKO7r05qVu1eu+9BAtzuWi+NdTWNMBAFeklUFiXIM3Gy1IEeJzUcGfvVe/SHQBbTi7UMixXgm3UD1l5e", + "2ndqUjMMR6C+Wfrvasq2CigM74UGzAvKD7BDm/Dfv6syff523WlzXTMaxubb2C1DBobQHiQb8K8AcYX7", + "8ycEELTsUjviftcqSDRNL6QxFlXHToEARiBC3GmEJ/JmndjozcBbotUOFkbiJA5xoFdN3Py3txv1Ajsp", + "n/xAHZaPfqLOx+iFu8MjZvDx5jQJkybw7w/ag9y4jYEAI/6pg1r7fYcy4XK+uKVz8nZaPEYyW4iaO0TI", "KDsKZ20ovdG2Xk7w/r1ZyKqFZTAJ1FSs4RDx6oE/M+JGOcXquoM4M1xukyBYjl/bheTpPaIu5J92AH3h", - "htW+31b5JAnLrR5pVNvO97gN38e8Hj08DvVKJNNX9LGKXmDo4Ev+exIVSuCYahe9P+k3MDzLXqT1REn2", - "UoGACeKW+Aksachxw5dCe+KFwkqtJ7wYb1HNdPZ+G7AbZ+HnFIS8+mUAmml6N+2RseUO/cuMwdjwBuYp", - "7nUtQER4xfg0Oulvox79oIOOPdVOORycXZKOcgoVvkq6TisX9xKPGLIaIKcecLx4vjxgbbFAPJ+tpKmt", + "htW+31X5JAnLrR5pVNvO97gN38e8Hj08DvVKJNNX9LGKXmDo4Ev+exIVSuCYahe9P+k3MDzLXqT1REn2", + "UoGACeKW+Aksachxw5dCe+KFwkqtJ7wYb1HNdPZhG7AbZ+HnFIS8+mUAmml6N+2RseUO/cuMwdjwBuYp", + "7nUtQER4zfg0Ounvoh79oIOOPdVOORycXZKOcgoVvkq6TisX9xKPGLIaIKcecLx4vjxgbbFAPJ+vpKmt", "NtoKfN34famNdLf126dVndrxqe3aeZ3SOQVEmnETmohLdWVZI0wvJxCQeqv6ePa+VJXKtkX2cW1bfaXx", - "J04Xf/H4PMR8gaCpeH9OEDIerSlgVwIjAW1yK3IEy0hcS8DeJsqk7PJgzf3Tm++P/28BXi3n+C+cXLwC", - "6uzKNNSYXTnkVNYdbXZeJTg18l+2RGmYV44mb1jS4dcH398Mo3LkZtrDB8D9HJzmtmC9AdavuqQJeNVn", - "Rd3Uh0b98GsOYtqegVOSY5Ym2DfyOddetBYDhi7JZQJZsRtSu7Cr9KR/XR47exK+IxYMGSH4eRh7xsv5", - "Pn7Of79IvYwBlAZv4kp3QOkiOmmPWed3QCboWhpozwk2wYor/e6EJYD2TLTar7X3qiXze6euAljcI8a9", - "VG6pxI10YHMpuVYcqModHgYT/LgECTt2l8v706blRQ7xIDmo77plBnDaugrxaRW8wAtUkH9wWxeWgIEe", + "J04Xf/H4PMR8gaCpeH9OEDIerSlgVwIjAW1yK3IEy0hcS8DeJsqk7PJgzf3j2x+O/28BXi3n+C+cXLwC", + "6uzKNNSYXTnkVNYdbXZeJTg18l+2RGmYV44mb1jS4dcH398Mo3LkZtrDB8D9ApzmtmC9AdavuqQJeNVn", + "Rd3Uh0b98BsOYtqegVOSY5Ym2DfyOddetBYDhi7JZQJZsRtSu7Cr9KR/XR47exK+JxYMGSH4eRh7xsv5", + "IX7Of79MvYwBlAZv4kp3QOkiOmmPWef3QCboWhpozwk2wYor/f6EJYD2TLTar7X3qiXze6euAljcI8a9", + "Um6pxI10YHMpuVYcqModHgYT/LgECTt2l8v746blRQ7xIDmo77plBnDaugrxaRW8wAtUkH9wWxeWgIEe", "ZJsI8XdEp/VyFcRGGkWa+/Nye2JDUrbQlU4MRtgTHrU9KLysjtgkB5NsTHgkkf+96uwNEJtlmhE3db15", - "fC5GK26yUij3Tn/SOiACRfrVpZWuPVA398Jc2ncvgqqGEKGOQQM7ZxiTpb9WbaF1IB8tfz3HPyu63Yfi", - "Sye6Kni/4WLQnv0ugO7JXYPGP1ugFyurFxiDgFF+0ou/HYtH4jFeWn8Tp/jnf8Q/N3pxfWwNyjt/OxZ/", - "Fn8t2/353V/LdhAQgbEiyKI9bhJEwTQUMJTkkZKLFc8BA5veBbTtW9cq97gR674LegOmv+B6ChWLXT9u", - "hFOgHcF4CPEIFrOWEL4V13SE/T1uhEzO6J5c2e7KGTvlbff2jpuUPppwzh1Ezh7ExSK6pruqws0eRKWw", - "F6ZRd2DlUUtVwCl/WhHASiY/xhgMwgjy4v86dS5poW3tTv4owLGBAZh/bV7Q59+MYTlxT+6dbo2HKNDv", - "4BkX8ROVfb4PzWhVp98q92koDYYZVGyp4PoudOsH3EAknhSc4IUE4RbNzOw+hHAD8plAszXgGALQcuq0", - "MnEZwHpvhylIwUxfcOBfyM0is5L0OOSV64O1rfh778NQWqIloikETEyqHcAm3XVkMkw7RfwRq6rz0Ogx", - "Ki5hTtfKnNxRFmBt5MHHBbR48GHvlTuQSsTN4Y+Sno+xphmciL1agNrh/QxnbArFLfmnohdKoBhXIfOF", - "F++4M3EZzwLaJchgD+ej+VoOx2hdG5o2MwVemXhLQzYDuQjo0a04iDAxAsWdTmwBqiKLRiVQ7raMiMMV", - "+NM0A4bajoEZXe7WEhRppUExgtgpsdRvlTkRcdH0v+yEsUEx9cKdGDBKBUzqKtv7na3xEUqnB/vbeyTe", - "8KgpnQRBalKxH7+/GMfc2o0yGDnpb5QjbUyU1DDwb6OcV21VB9PMflCy/dHWjuanZHAHbNpu0cdg7orN", - "pkOVuB3IE5Leolo1N+GAU+6kvsNTZJU1uXdYZDWKE7ofcUpFzzVUQGn5e7kIfkJJIVmgtleFDxXeIB1q", + "fC5GK26yUij3Tn/SOiACRfrVpZWuPVA399Jc2vcvg6qGEKGOQQM7ZxiTpb9WbaF1IB8tfz3HPyu63Yfi", + "Sye6Kni/4WLQnv0+gO7JXYPGP1ugFyurFxiDgFF+0ou/HotH4jFeWn8Vp/jnf8Q/N3pxfWwNyjt/PRZ/", + "En8p2/3p/V/KdhAQgbEiyKI9bhJEwTQUMJTkkZKLFc8BA5veB7TtW9cq97gR674LegOmv+B6ChWLXT9u", + "hFOgHcF4CPEIFrOWEL4V13SE/T1uhEzO6J5c2e7KGTvlbffujpuUPppwzh1Ezh7ExSK6pruqws0eRKWw", + "F6ZRd2DlUUtVwCl/WhHASiY/xhgMwgjy4v8ydS5poW3tTv4kwLGBAZh/bV7S50/HsJy4J/dOt8ZDFOh3", + "8IyL+InKPt+HZrSq0++U+zyUBsMMKrZUcH0XuvUDbiASTwpO8EKCcItmZnYfQrgB+Uyg2RpwDAFoOXVa", + "mbgMYL23wxSkYKYvOPAv5GaRWUl6HPLK9cHaVvyt92EoLdES0RQCJibVDmCT7joyGaadIv6IVdV5aPQY", + "FZcwp2tlTu4oC7A28uDjAlo8+LD3yh1IJeLm8EdJz8dY0wxOxF4tQO3wfoEzNoXilvxT0QslUIyrkPnC", + "i3fcmbiMZwHtEmSwh/PRfCuHY7SuDU2bmQKvTLylIZuBXAT06FYcRJgYgeJOJ7YAVZFFoxIod1tGxOEK", + "/GmaAUNtx8CMLndrCYq00qAYQeyUWOp3ypyIuGj6X3bC2KCYeuFODBilAiZ1le39ztb4CKXTg/3tPRJv", + "edSUToIgNanYj99fjGNu7UYZjJz0N8qRNiZKahj4t1HOq7aqg2lmf1Cy/dHWjubnZHAHbNpu0cdg7orN", + "pkOVuB3IE5Leolo1N+GAU+6kvsNTZJU1uXdYZDWKE7ofcUpFzzVUQGn5B7kIfkJJIVmgtleFDxXeIB1q", "pE0rVvZGXEknNMhQl0qZmCmgJZcJH+BMY+IGtMPlwEL8HNnwTU9u9in0I2tKA5ipBCnwoMUjTvBAvnmN", - "kOlqa1I4enIObNgLBpQr1omVfAu/JDxt8RdjK3yKYhi4Z5BxoRlLh2QYFZdOGqAP9i0Pzzp5NFO2ygQM", + "kOlqa1I4enIObNgLBpQr1omVfAe/JDxt8RdjK3yKYhi4Z5BxoRlLh2QYFZdOGqAP9h0Pzzp5NFO2ygQM", "1oXparNMEfAn6BA+vwJQ0+Ka5IuGrG70hzbqRuRdaTiowwsWdQAKDSeWMSop9PmWJ7d4atXW4m42AJaF", - "3shqIPqbKJuyj3HOsjGMBi2FcRxeh6iukRl8CO8Ww0qBYDCsM3/COTIoRAMULo+z8Mb4ph3H/3CnkBwC", - "AYkUmIGCN0d0LaJ5YhsXFzHYGSme2WPZh5V1qj0GB0ondaccQeugm/9VBmLt4iEUnC9sPxW+xs449orR", + "3shqIPrbKJuyj3HOsjGMBi2FcRxeh6iukRl8CO8Ww0qBYDCsM3/COTIoRAMULo+z8Mb4ph3H/3CnkBwC", + "AYkUmIGCN0d0LaJ5YhsXFzHYGSme22PZh5V1qj0GB0ondaccQeugm/91BmLt4iEUnC9sPxW+xs449orR", "1eef84jMdcaMG5Er1rTlIZ2D7X7ZjWsi3QN3T6ejgiGso6pN+MhnR7e4LCKRToFKm/VuO9cVEzbca2E5", "8dLOxcX2E1uTk88E5UNmm3EppJyXmO9lY7UBaoRYjY7F101W5zw+F0+Syon81kceUcXqe4MI287JXaMC", "d3Jz8gPiyYSohDG/HpKqPWOim0RtpzvFGwjh2soViRvgQ3EpvWpEb6LnfMt0JyekmBo4Xg9slfE7LWhZ", - "RqJpFAkkeIuoO3nZKVE5PFMmhy2Yb4GkOtVtNBod+C1cHh/a7VPWDMly/Z5G+jclv+wVqD9CiACu4m6c", + "RqJpFAkkeIuoO3nZKVE5PFMmhy2Yb4GkOtVtNBod+C1cHh/a7VPWDMly/Z5G+jclv+wVqD9BiACu4m6c", "9wG+ltrTJY4afBmUAyruT0T0Xd3a65H3ZFM+LFMEJak53Vx0Q9ZTCyjTTnKDGBnDCanSpOGLJgda0nHD", - "KA9MqUMMEf4dx0+MTJ4ScDyu9TtZxBHo9gsje1nESQPajzboK86x98qpq+p5xCgkoDq8HgMf3RJQyLWA", + "KA9MqUMMEf4dx0+MTJ4ScDyu9TtZxBHo9gsje1nESQPajzboK86x99qpq+p5xCgkoDq8HgMf3RJQyLWA", "b165+OkCuOJtfXar/UK6CrSRP+K3c98vl5Qwikaq03L0VK5MNCamwfdxrpbsExNdEWO2cfayUzUH/4J7", "88FuNrzJxWNK3senunXUZtfso0BbGe1/xlfguwEWjZgWq9qRk0HNO12/MyIsciPVHgYSp2R7OwEJfLdz", "deywXjlVaOXpneF7RZk2smi+X6+luxWP4PUJ6eTxFb84E8H16nF9wGgNmtq8+H6e+JPp6Y8OTd6pvK6E", - "fUP4R7A1CdG3cKucau0kvpJGTZjzWievQpU1euN6iLjRnRKSdBrAbDMXA2Yu2mo20/eGKD8T9W1gomuR", - "aneOE5Jz+Y02rb1BJzL8MLlicjdCUSqvKN3k+Rz5s0gzstEPhQaM7IhMXuJ27EYZILlvmS1Auy98c8Au", + "fUP4R7A1CdG3cKucau0kvpZGTZjzWievQpU1eut6iLjRnRKSdBrAbDMXA2Yu2mo20/eGKD8T9W1gomuR", + "aneOE5Jz+Y02rb1BJzL8MLlicjdCUSqvKN3k+Rz5s0gzstEPhQaM7IhMXuJ27EYZILnvmC1Auy98c8Au", "xjU1GYx18Ge+fnsDtN908nY+6Rm61GGOoYKTb+OnteRayTqJxHQlkdH0KozEl3Py8MKMC0sVMMkbyy93", - "cToewYeaNcM1FnMuF1cFnHJrPZFbslWBYTLhAoE8XKvbwuWBOKWov5bIqNAdPxWhVQctKXX0W7m4FUsn", - "Qeb2/QLDhC8WTikjXuNVPBQZSv4ghLocBD2/Owbljzrxtz6o9capK+WUWSgPKZ8i7uKwR15cYCNxwT2O", - "Mbfm5zQcsTeLlVqAfTKhShgkgHC9yct72ge7pgAbeyV+cvCDzi79JkGmEJeiFg/nS25VsKPIv6ah97tP", - "Mbok9yne/QKUVfyhu/PTKP8mDyhQ76lUkHYDWfUENCkVHRTryblO4NZs6FErZBCrEDZnp6cUJAxhAqAZ", - "kbozKoiV9QFfqDN6Dz3Tg1O42VVMF1SQZknDo9INFncm1LuN9RiAGqPDDCs64Ku1Jb8gkjBPPs7VMltj", - "eQsRWnutK69IPba9c7JvdZjH664O9viWYiwwwoVvhJzikAwDrjcZLk1dzKXgezoSINGVPtPGCpxQned+", + "cToewYeaNcM1FnMuF1cFnHJrPZFbslWBYTLhAoE8XKvbwuWBOKWov5bIqNAdPxWhVQctKXX0O7m4FUsn", + "Qeb2/QLDhC8WTikj3uBVPBQZSv4ghLocBD2/Pwbljzrxtz6o9capK+WUWSgPKZ8i7uKwR15cYCNxwT2O", + "Mbfm5zQcsTeLlVqAfTKhShgkgHC9yct71ge7pgAbeyV+cvCDzi79JkGmEJeiFg/nS25VsKPIv6ah97tP", + "Mbok9yne/QKUVfyhu/PzKP8mDyhQ76lUkHYDWfUENCkVHRTryblO4NZs6FErZBCrEDZnp6cUJAxhAqAZ", + "kbozKoiV9QFfqDN6Dz3Tg1O42VVMF1SQZknDo9INFncm1PuN9RiAGqPDDCs64Ku1Jb8gkjBPPs3VMltj", + "eQsRWnutK69JPba9c7JvdZjH664O9viWYiwwwoVvhJzikAwDrjcZLk1dzKXgezoSINGVPtPGCpxQned+", "gNRZPLU5Te3w7Fo70NeptQ1TrzZ2PukDyIzp7r2gRnlLSDeJ7jU+viQF99iGmTWkyFGOwE6fHpqHkHEv", - "r2cLkgkOu7IMjlfcjNFxBypPidg79mUa+HXqmL/YMY+fi+0azmR6I58KL4E4xRbITpXbUb1zRpPcB6Rg", + "r2cLkgkOu7IMjlfcjNFxBypPidg79mUa+HXqmL/YMY+fi+0azmR6I58JL4E4xRbITpXbUb1zRpPcB6Rg", "F7abcOC/ywlyElcAqjRODk6qXkrTM+2gFh2NYkRXte/kdxm27/Td6cGr8T1xXNBx9l0nOmWWYTWI89mm", "vYcm/eZ2zTD7NyMyroOAxZPbuy2+lj2w35k3pubbPYpNoBz2AATOvdXKTVAu8x8b6TznUsC/nVrYpYFw", - "qO1AukZcq1vKHsXBtTW3KkqtV9+NIvceqo6aSPwRiU4OVuUP8PnDHj8eBmOaWW0r/mevF9eve7PnygMQ", - "UgznkRdPKXnOZR+CTQmbWTKGAVogsutNyAmnoqlSh3hvnotLG1aliigbiCrJhPa4rJU0Zo+TdO6o2U07", - "XicmbwiXnwxfNNs3yuhWarIzZVT9UQs075ms/4V8bauYUXS/V+XUdYjqP246iC3213qzmchAcx9uYiLw", + "qO1AukZcq1vKHsXBtTW3KkqtV9+NIvceqo6aSPwRiU4OVuUP8PnjHj8eBmOaWW0r/mevF9dverPnygMQ", + "UgznkRfPKHnOZR+CTQmbWTKGAVogsutNyAmnoqlSh3hvnotLG1aliigbiCrJhPa4rJU0Zo+TdO6o2U07", + "3iQmbwiXnwxfNNs3yuhWarIzZVT9UQs075ms/4V8bauYUXS/V+XUdYjqP246iC3213qzmchAcx9uYiLw", "nuQgyKVTTx3DGuT5wKVt6oQf4HpcOgdup6jecs2OxlMyw/FkCG9pRu082KjmLo68DoCwkOxYm5j/iVt5", - "ShTFmn0aAJQM9VRVcf3oI/ixi08+jfWVk88uJ5EYrfngtWXDs7GBxAo0/NqNMlMrRI3Vp3B/mFDLf3cY", + "ShTFmn0aAJQM9VRVcf3oI/ipi08+jfWVk88uJ5EYrfngtWXDs7GBxAo0/NqNMlMrRI3V53B/mFDLf38Y", "WudUc+OMP4YTbJRnpr9c68Aq0Zxv7Czr+aIr8WMqNMAQagispPkDdhMzeS9kUEsMmAw6dKoRJFU2FFcE", "38O1VIXf0C+vlvizmr+5whEf+ehsvtI+rVU4eThl8PUICP6EgFhQMB/UJtrygZVGqxSm6TR2MIFSfs9W", - "J9iYWTNLVice5sC4ByLWoxT3xcPn1Hvx5Ps4UPHsIo55cH2Ue+Dm7oTmBQbE7a56HG8lPI+Ox0SbRxLG", - "iPLUSHHtCrwA9vxZTms35tIm8t0ltpeYAW2CTb4iQbm1NhLy+mHKu7tkRZuQaXZIZnGK+xYHv3cucK3N", - "D8hEl97T2zPb2awuXe2c4mKl2r6rTK2Vt3N7NV9bU4tm/EYEK377DXt/YaPuVnjuLboMxhwdlBvahNUR", - "V0Jq5a3AlITWBaxGYMLKg4MAanNutJ/Q3qDAve/6imv6Dhtjho++cpSewBJ+89smqlhItQUztAvZoWIF", - "ZoQrNAL6KFa4K6/r9j2jTR/UxAx+95/nE2OQSZc+FhsAG94F0Ko+PJRKASv74Rfj3mowOKLrDSszhM71", - "KGRdd7SHjya+vT4kjXPptLpqyIibvQiRUJ0PnFCrw+OFWO8eXwFLjYui5QReTn0tN0pdt/J2Qt0NbzAX", - "l7oudi0ifSNeWgN4jvJXKi9U4vdBAtnPNIeaW8GBysS4hyxHYQTZRLjx3hiVWA2DwBwPZAEpPm0J6Zsh", - "IUkIUMy+QNxdJOq7ePbjzc4DtTJOAO8qM9Ai5b2M3dQJ8W5q95phQuImemRKyC2i2maCAgJs1/KdXsNU", - "f/sNgoP++ObT07U00G9+Wwz0pDZQJkXpo9/9576P8pmdPm57rq/pk7QftqMD9qlPzl1u1DHaj3F9p7jP", - "pZC+hMsS7eA9nZZ20PAHdSAaOAwVy9jhLrStioGJVjejcHq8T5QpWlTmfiVrSmd6i9obpxS0Sq7NrrD9", - "R0e+Iy/++N3T54Ns8uNYpI9Up7ylNf2yMxiLlQwE72RUTeYNmBarK2N2S6VysbZOSR/SukS/yUVwDki2", - "MMWQb0/4lfWo0Ri5YMdpes4A9w3FZjt1RSmSr/wpKFxPoTkk7SR56MMpfHf63ny4q7mwmcW9nXipl8sa", - "bxV6Z+bKtGec/5TtpMq0x/aKSuAR+pzEvGwAbjlUNNno8iFbjqKm5NYcXiOvVXabZqXR2SCMjp4V7oQc", - "ga2cqkXUnaA371lGisFsrrDKYxEOAZNA+wUgQrC2O8l+wOW6RXaVLc+D0AYplzT5MyQefIoiJ3qpVprV", - "v0PLZzNYKzvQxfz4NGdy2dVBaBMhRC7LlFcoDZvQCj0LDRD+IpojkqhHuWNOuw9uR7TQMo4r1S2E8G34", - "Yw5/4JBwdJ2Qm42SLgV95NGRHgDnFjPnYP46X2o6eDKzJuHYrJmlQWbNLK2Kq9G4WTNLOJYilei8Xh+o", - "Fol09A3h+8s0h9GLN70z35m28sLa7hnNb/Tmqb/+I892/A1PfvT4dbGWcV9xaaPn3+NK92hMKsoRMxvc", - "AQUxKIltJgN7/QYuQL55GoJabyp30lSKUKwcS9U1yqztMe0Mli5jDz9Z9/hl17xkuB/XJeO3iKKLTkmj", - "2nm/AUpgRX4LzgV4oGM+Nmw6VT6APtsT1vCcWpW3TjL2MAEAo9qis1614lZNeu/tqGtbZNrQcIch9HFE", - "+gzJ41bWcARsKobLX1VXqs2mnwor4u880zTaRF/kAcXBydtjoxwTExaDJZGqFUZJe67hd+QPZo0R217A", - "7Gqc31SVmTeriE9zNk9hwwwUz7PUQSzVOAw7J2D2d1EGs/72rAip0j6Viz3B2q5n7DzURN15niI7DhI7", - "lU5D/gB65WUQW0lk3UG4WEbws/wz3iopjO5kcC5yOwJFaoZlFPCMtFalPMik8sg+TEUJBaodNTjFnG5j", - "W7XN5V3j8qKjbTsrDjjQoDTRQ6u+EpKOC7sWT2MZ2OLR93kW5eOXcUblw+fF7Mrnz2imf9rs1ZQnCfRQ", - "d64ow0V1dkGO0omdpNB0ZmrpjJZ1Z5jDU/uxJj5+MDGFUPOFJmSew6cTvgt0hXH+/ZqUiUoFPl/cjLBV", - "Y3Tj4hpRGPAsFy4uw5oOyxAA3b+i3qt5OCi5fmV2rMIyGKK62ZC7PIkecIJr9YJyRupG2K4lPzh8k2rC", - "HjzxcdLxytzbyzm6vhyYXK4oVX94nkiIE51PFU1+Wu6d8mLRO0eFGLeDAIfKHUCvCbzZsDvIPMeXHOw9", - "4isBGfcxR/8JOcoPTQ0nUslzll17irQdOdMUScGxQaqRBa9iXT7OicVO2PQhfKK6Ky45MDC25VPJ4J1j", - "IEfl1oTHCXmNvUnoOKhPfDAuQn+v1VUNB71X8+IMVa277q66Ax/6xTWH9Hi1sKadqNiN+R1kWimKsqCv", - "X9oEYyk8uU2RjoGvUsxx32NOVy9wuDqq/mrXl7pGvC4iReKEVXEKMKwwVnRY2pdOBvEIcnRYkNRxjaK0", - "LdYdvCn/H05tr79UAf+CYmxRg+JUNkPiPtzjTDGHtGGMk+O4nPFtkEFb3+5tOlC9nciV4bWSFVPupO7J", - "q19SWEsOdYo6KPS5pX5JEoBwmYNUSpXMubVJvyH/9Jq/dljNq5VYYNYQ0IB3EBUgowQZrRI6RhXoIIxS", - "bSq/VjUAVWsRTEduxLd5OOQYSSLCZUSc3erYOs2BL8NuWfu0CmHjBTXKIdXY5XZZdRx5hZXlFspxqKQS", - "rV1Lbe7C2r/hzsDoJxfXimqUBnUmfrTIBTbiR4DhDwBA/v1SLlbaqKd9WDXigsIP4QeXvrJOvN667aY5", - "LmQA004X8E8Qq+OMv64hTKsnC0kMMmWwkA7qLfiG/vXNIJYd67Fjff8rqgOVXADpm2hpGEinhRxR3Ycc", - "RbA7wjwq2OIMjzxNxRXpJZkFI/Eq6yBlCMpAl+JWhTMgpzmjEYYDzq+sm5P2zTpBYaneYr6UR9gBxe1w", - "dMdtXH8e2D+mLCrABuYcKjnfKU6OA6AdEntKbamDWPch2xgqaS6L+qVKtmKpAl0Iemlk51My2rqm4VJ6", - "Nefq7tuQnw57IA3G7iorpFaVniVTcipmyenwihsL29V8il6wdx6LpH96EY39G9mpELBoJ9dilGwvxyRP", - "UmCHAKGt2B3yXbCGg7Fxf4A/QCfGpa3f7w8RdvIwuiYubcEXE3I62osbqZEIRUVRyQk18S8MQWgBMqMR", - "xKWCxk5BGFO7U5slp1SBhbaL9IEpe0dOCjJQcMkwLOFCBRuDNr1C+k4rxhkmFlqZiUQWd9C1wfp36dn2", - "UbIpT5ut8PNd286ZkQFw5Se7tjInW6mmRLGsqdkVWD+ly8W30enxl176dFFUo7vGpZ0cATSmPAqWaEUV", - "ekXqpX2MbZEPK31ImR2mKRbDFUNSWCMf47HLcD09oMOJvGmzTKhgzUIVGVY4EMC6oT//SnV3oIK0hkP8", - "hLZ3gla2ltfKFyUU6YPMIEWH/ODTgtmBN9C4fnJX9hCqDNmSTPElnJWbcEojUSrJTmSyBTHZ8G3U8dA6", - "seGmxx+s8qd4y7jWacQGaQPukDnZuHetYp0TqGl0jWZ04Kgn6mCEPynOg17ykvk61GHaAEAfzPdn2yZh", - "g/Yu+rglWhUV7TRXBCYxKwVDBA2S01X2mbsTXdubOBk4KFx1fSX4KiMh+WiTg/0W90UJZaQvicsZYPqm", - "U0FhOrvsp5CwQfmEDE26K7ixpuLzxJUNEhWciKfxlgE6YOzWdHCe/kS8CCltElpBY9RPSrXRiHp6lKZo", - "MwdNNzoVJTN43FLMp3Bp36UHKGqWdtQIASoOhus72Edctrd4Rp/lPsqHsbfdMpGl+J+gBuwBiEDXahNi", - "jVvKIhidV1EsdNJ4qgAH20qOkwRM8sXAVIEAJOodV17Lp8ccNhm4sqr1rMZ+Eo0mRuE8emxtn4ImWyIT", - "UQeZIj5tstIGMQSt5lus/4Cgqc4r1Eifi8zmnYMskrvRgSRVg1iYZJHzRORwMkxYj5hqwhfbFDJ+oUOk", - "lsnayrYcjMNNMI7tCcqII4WJ9vF5vOzi1RjzSmYKOaaI2mf1AecKvJG31JGawy2YVu3TVcF+GOkmil2X", - "d2/sYsAFDae1zSXlruF/eng+vYukmiptd5QPEYkqv+SPz4sgtjgLHtT1kD+X/phvuBr1pQo3ShlBeTDJ", - "mQa3Drcqx4+MUmHC+MRzcyjFOROlYLOAukVmsoEuUtiUdW1LuuWP5twJ10clSneeD0TkvGFxYquWA91L", - "Y6MmWTTPGf+NnbP3CXfFqkxUfMrliMDtshsOQZse0O/IoTQzRu6x+axqdYyTIw+UoiGi7KzKtTez4Vbk", - "LvNOHEiUQVszMmCmR2y9TH8Xpsv8Gc7oVQLI6MXo4csEovToVYJVevS8BNrgW9VW2g0f/mifMjjTo6cR", - "rsO+/kjwHT58CnB+HcFcrEa2t2/sS4b2eAoXGer12lOoAaijwN32qfdPY1/50RZoep9hgzMiWXx+kJ55", - "4O64rXXeSrOVUlemk2XUQUroyXiE70Y61YE/Hd0VOoylhmbof4cccuRiCitWPS7Ctnauq6VZtmSeNz89", - "/+lk3WKdkeFopWvKnfja6VCF76c4BlZgyHWaV2pE2V9+VaU+SjxaqgDYEfNEJO+Yhd3cPoZEubnvSB9j", - "gvPoeGgdS9fiEf2f381TbGVU9FEhO9jIx+dbjIp0qpQY2OykQ+ShIxOE3u6QhhnVbJHBwn1m7WdYqXXy", - "SHl6d5DPJ0I6vx/LL6hyLjdieweoNV9V52IoW0W35gzmO883Afpe9VPYsaMU8JPmddx/oa+NitEiS9N0", - "JpVoNMhX4dYFOJaEJy64kmINVPND/cyUAeJZThU7Kqgn/YRcEdVJjjy3Qc6RjmnHWVazHEMPA206nwk5", - "4WyL6SySgmEDK7T9gPOC8SYC9rs71J0pajrW6hs4VVu4U2kxg+oiVyQgkboMHZ8Ru9u0kP3zH6EkQp7n", - "EZc2uX33jQIBdppDPLDeRvbUHiQG57x4SLALpVSnr1MYRWuVPxE/Wr5n4sn/JKlt3xT8MTYhksYjW3dI", - "utbpYMEL0gNuXZxcXEL7qK8ZgKQZCMusWjoRP5eLb0QYBiLCN5tOLvKBALpy59BDmiV9K37mu1rn1GpR", - "tQkcQUip/rLL4zRLYJ24qa4AyTF2lotuFLH7GAH4F1NbyO64wngfyFFuJUBDHNb4oCSW7Ke7mVOR5NCA", - "ePGepamipU2mawjWbW9MszV//Jtgg+qKmIBAhghAHcSlWliCVqGw457+MqPsc/gn/lRngh5hX/ToL7Mm", - "jxkzzVhHGodyHn6MLqQ4SQWKtm/EGsQ/TNCINxzJXqESu8PXR6cFouATVRtc57iB0RlKD0J8EABT1vw7", - "OxHdrSzaVu69YsgpgvrzYcGwMhmzflWDgCu+5RsiHfgorFSlCmGrQFwOnNtzZwAiD/o8f3FwjgFeeDFY", - "deFKrl+q9aWq1Q4/kDLHYH3ZeYslhujkbKWhOiS3aOwYWqT4LCXZjR0zNtgrgckDvnnyBLSNTi6Ccr4R", - "vdG/9KRnKj6807XwBik/T8HeEClyPSpEPVlFnO2U2N1/fSNiEowdIYXxuEI5/e3tiGkpDud2BiRgn2dZ", - "7n7X1C44mds4uoRmtTtG2dmbva220oN1fsZf7pwWHO/J7BhVs83TEfFiigaRTnDhcAmadCXVqwVXCa9t", - "7fZU1Dvtw566DCMvH/KQirK0DIx/dsJOlVDiMNywrcVCq/vwgice+//rxIpj0daRKGEp67n0YrvSKXR4", - "RLmdTCARPPkuTOYq5I+ueodgA4rgq3cMuWlPcFMQXMcbbpR0ygexUrLlgtFvVZpfxUi+XXfkIA4uThwZ", - "Sph2dhyGfcW6rOh9yrXUInQ4TfV+OpPkVYsp0yMApjZs4siAMNr7mhey6krjdBHyKbEaA0Vz9d6n2cOp", - "Waxk8tKVhmUl7TH4cAKPp8PGDzW54+DBEiNyKOCqcGJP6Yoz6s7g7sMSM+2e1SBaMPMz/HlttuTmvjVX", - "p/6OkQc12nM7cFXHKOcezfU3WHsn5r6W0etdbtCkodA02YqFU60OvvAAYpMZujuBxoyz2cuI5Oi2CHxC", - "9teO86seqGEZtwnnNir+5EkG56iFw905aIq+7ta2UUidxFoRk8E3P1XUAhRbUTK79cGO3rhLP+OYe2lv", - "sfo8z8mt50RRE+GCmMoq3XYo8XD5BZKEUiBEPQIiEsLeK787yMFXMkSaoJdOvtXhdsKDUfZtPfxpYVv1", - "bv9p4R5i+2Yw5CTEeBu2jkwnL2uc78XKOpKkk1sX4kW9UIBeT3nz0k4e8XkYIKrtL5GIawP8bBgVSbyU", - "GPLem5BuSB6XjgBnFVTB7z4wOGtBLQ8/KDCh7U573zYi2GtlfBN1IuhhtVFugbV0verUgiy9a4k56+tH", - "vVoj4+kalivw5Q5ATcODgD0deDLcEMrjggOxt9BCAdhT//ssNs0MWYVrY28MfbNVGgKRi9fLUK1jaE0o", - "kzfytrazQHiD61VD7gYxPQOsIVVciSb05DunfeJzyeZADnP1ezmmDd8hFuKrWMskKlQwpR52P1Fp4hPW", - "ATm4XEczM0WNpvkmFmnaRbm3qzph4SG9uI4503Z9nbIYf0ypkOq0x1vTEJKUc5vCrz/hBbONZfeG+Ght", - "B9c7iamWCoPwGtN0hx4+vsGjElY9HE2nZ83MkzFlsLY8w4ripCIAFsrMrCaJ2gyKDS00/JfMqcN62H07", - "qI1vooCIPMEJRI9QBWpOQ1eoGck9w0ftJGsrozMT9lZEtIFJL7l4nBMbtiOPczGO9snfhWpi5oKuqPlE", - "ZSkMGVOB4Gf+KJUWqJQ5lX2w88l6Y3izSFZTFhZBzFQy9mJhEsV/JaU0SEJjr2mUMCrkCOz/S3sMT4/B", - "9+Y41os+xhqSys3OgBh+aGjeE/6Ou2c9csfhWeNvnDOZgNIssTLrhlMZw1POPZ5FJlCNqbaZWuz6o9Y5", - "WNn7irvEYd0gEh6sRIjH7CKoDSeHe0HffbM3jhHGqVIC7pMTvo/0CXCmpsqDfJRSNR603RqaSkqFNhIM", - "Fb1dXW/qN+jkLUXnryaBRL0Qz/TIM5k5OIVdhiamH6iaPQ9LgMB0PJvFNZq+C8AP/MB4TXu2+CJUZVa0", - "dE/IMdjvdtITIGpNUd0SEOxI+JXc3LFYf8yrMm2I42J7jksj+5AyOKF2h5OIWHdNxtbwOAVs3y1Qe5DS", - "pzLTXfhUcw1mgoNBdUjowOdd/JQ8QnkxIblcsoNTkQII54KmoGGTlPomhVVgATv+cJh1hKeRg4wfMP8I", - "ghDd0H5Oo+Zn2aEvP2OPvvygcOnLD5M7WX5Uutrlp8M8JLz0+ZRissjR45Opcwz+GKpwKErXzzEOVfij", - "FFMrzsCu44tUf9sx7Z1cBEw+hmjEhyNldCMRwTq6E9mriWwijxsibvB2I53sOtWBDom6SExLPPOlR1FR", - "/jIe/sxJnXGolQ+5KIZkfq1hJ/dU8GrULE+kxhNNJNJ43XNEN/WDnFtQcn1GGfhll3yZzSAfVDJyY5U+", - "djVpYkn2xDay0c2vpKPS+xh6Wnrcc1Y9wptiKneoyF4YBu/mtMFrPthAeCaWm3D8H9SSw4SNeAZqnEYs", - "FRiL8ltrxNOs2Imbx37phFlGPENdEHZxImJ22JxBgvEOVZ2Fa0DFknc424S4VHMzUZu4pHi42Y2et3VJ", - "RfxqiA2fEA7f+baP/Nh42yIyV7yDEP+Vj3XhckgIlofbN9fywHGQFZ2aTzbzHVm/hxhXmmzPaXfjlsPM", - "yteMPvg6rgTOKdGaRD/w1H0MduwoiRGPPhDle9m4S6er+83vwy4STy6GtRqkO8SNu/so5M5qFw7nRtlR", - "CHVr/GtNKQpGEQtzpgIxdQmRdPiV3rDdpapW2AxsOmVanPvag0YAwWmnGp/bsPiAOQGv0L7MbDtm4EDD", - "kPNcFeDkyckTGNZulJEbPTub/fbkyclvYbEyrBB0mO9KtmttTjep1Cy+2VhfO2eo1Y1VDjTkCuTC5INq", - "sJAHJ0XwwMSOIResPxJY7jTdA/46fk2BRfw1lvC5VUG0aqExj97PGCJEZiX6IKZi8Mw0ePEoV2bl1DwL", - "2NDo1Phc+etgN414bhdUMwd+3hjIgk3FlfWzzvateO40KFyAU3eQXZXyD/+G6yegnhyQDwd60c7OZs9g", - "Ta8K6DWz6LeFkPzNkyczdEIwgeNZobot6+5O/87l9IgCHixy5/EqjN6HplIIjMoMiY1yBOUT+PB3T55M", - "jZTWcMol3LDfAmFy7MaS8t4MwfIHFTjN3EfCY49oBCNUlnxBBWZXSnbsbo8GrZPtdeDz40VhNZtaz9C8", - "9oDLGg704cOenGWDXGQn1L6aePNC1c188VuEk1MyajzHzeSSM/MMQUPq423ooMXh9+z78VCAyXSTr9kv", - "tytvxq6QHg/Zt/c6ZJedvdxBiS+CdQoDUtEDGilo7xXVeGdHZZIFwBEkOZDKG2pPgSZAN+BVqwLa3rPe", - "BBOKITqsKQO2ePXjHxrxP15994dG/OHF98I6yIv46kQ8DVQy8nfipf49SRZj7IiVBnYiBU7rdKmvhhuS", - "DG2X2kislbB9ddKnf9+o5X2/3Zh7f3qjLjd3/fYAtP3mk6EtQn4KWwGLWgG4dmdUbWbffvPb+yL26Xv4", - "70X7YRe9TTiz80D/iyHO9iYCJI88HdkmJ81nEOEh58399g7bRWIiObzMzv78fqZhPI55Ir5+Rns4G2Nz", - "U6xpvIK/RjQYZVkt8GBsn0v5V4WFK52YR1KQkP6k91w88KVcnBU1uLAmiBeUa5WTupPTHxNIn0KRaDbJ", - "Xp6LJcr0+aa7HXyMCQ9uoySMUrJu0TUIA+7IDAj783tggP9o2blQuTKGH/uGPNwGjXRlYtmkwoaeV/C5", - "UxhBQp8ig4phmhWay3lmaerjI/TNk2+2wXxBic5SEFAGekzZ+BF3Wdxr9U4tpq+01xS2njxx4SbjfXkp", - "F0J6/mt+Kf0Ko46oss/fqAQEvjuGIf6G2T8obSLq/KzdQFwc+aeQIu5SSYe+W9cq2XqxHzIkGPH7//f1", - "d/M3P/3Xdz/iIIUFmMMWa3D/7p1aFED/9AwQdQ7DfG7uJ4/8GiWJKWoUt4/qd77TYb7AhJZeHH8TAyU8", - "6pNADXetu061Qkdx5LefbL4FIRtO8kdLDo2MWtrHU8chezrEQttyAf47nWo5FQ5vaNS7/EawN1H+zKeu", - "ot4Izuwt+jpVzoO/NXQeasz6a6pOJNi1MLmky83myEdpFXogZfUNRiDnugl6pFoOvS/I0bNI79ot8sRR", - "F7mXbYb/QjFpuYAFPCSm4wAHYfq3UxBU7SegXJgS50o5qPjDP4fMS63CQceZP5xaBAsaRsNlt0ZXEl5T", - "DdGl5a+YQkQE6dD3hAkOZWmJqn+MuRMo4sZULSV+jvLOwVeIhtsb+Ye4kW94UXeTamGyn4SFkW6x0m8f", - "ik3JO3Y3VmVCip7YXNGyOmm0u6jmurLu7hv8dLFQm8CZjpqP2uhXfW2jDzm199zj+x1Xpd+m4/rtPY4r", - "Jt7wk8eSlELH6EpLTU8EqlLwDyoopzngU/1yLloZZBSdv3vLhfH+x8VPP57Qn7FOyQ/Sh2N8cvziuXjE", - "NJje/dIrdysSkj7GUGXk5G7zLYH5deKMfqbaW6grbih5GZo1OfhX8chOCY/MI/KpnZLt/4MYHb+IHZYh", - "TVSXFqt9UTkuXgZ2AcbQG6OcWFruw9LAWEWvwu1cYA526mJWP4h0peSjOIDUrKlh1XQibu4TIZq7TBbs", - "j++qKG49SRUmPgWg1r5Lfj9ATvaQVpAuCIWPKb398NztpaSEovTpRxwiTGs3eYZewFuMrfEjfxbxve4C", - "8Q/OMdNijeITEOzAcREd2Rmjwduwhl8QAInDTSDXaAsGSTzuvIEfsffRd+IwxgZXhE4hByHFJzAW4IgT", - "UX5bSPRShgWLOWrtk11cuxSN7k/Ec/I0RusKJsTDxidbWHRKAvUxKo6nJb8/6Leky6Tmqk3O6nCtakgw", - "maVzsC2BV1XMoUdx+ZwDOJZlY/EwmrDjU6p+Vxb1g9eUol12cQCI2a4WL3wTS8OD8oFzDUBWoEhic4py", - "2aHfaF5QTikRwThOzZA8W3gWtdQTNIU035jSsTfB9iC9g6MD+TNQpEgCI9Jxyj4dp9RkgItWwQ008I9I", - "QKN5pqi9AZTJe6IqClOlvKe48Q8jISBav2Zoch6Uz6xbxQz+EzxtRJT7KFaffHun1v95Xyp/OoBM/XA+", - "ZZ1YWX+SaIMmhxbfX7It8kTExo5qo5cFhaFpVJ2htzsGCFIpKMAwUyR5LGJVnBK9iThbQzTCgDZeFA+M", - "ae1D6F0+PRUHBOSwwUSbv14sfA9T3GMMyMt/QCVXAeM6TGGiWcWeb8SHEVwJLPfTrw8he9pqD4cUj/mD", - "jNtMkI/nNLDaTp6b7xo83XSfkwoLXSAT8TCWaj441ulCCA5V0IUeWqduuJJHrOpoMId+155z1ykTSxS4", - "SU0mQ54LyDx9qNEXXkCmL18K93gL+USffK4jula7juVL9bCOEMpNKpqLFB1Dp4eadwLP8yFcElL83Gf3", - "R1BuH+1n4NxX/blWpzHSdNqh5KaIjCk3BQPQbuTtiaC4VPg9ikslL5PM7JvELlwn3XUtNLURQdFAlDYb", - "vImxMboiQHK67jZV40YbX+8MN7dmKiyWeXbMMz/h5PKUQiofApGw639KFKr4Vu0+zkd+5EdDpUu0Z8Mu", - "YBHrSL/jeEdHid84ERC5weTyUhhyqcNJcpKi7rEWAT9pFSWzYKVZiHlOeD7RoALZ6Chj5pTG4gK6/lRe", - "YocFCBUjHsocbvkpffiQb/CRMRlFq8EgD3MCyiHg9+eW5oZwPABun+ZYnL7nX8wBEyZu78NzfL61D/vU", - "6vRZ+0Asapr6PU0rNSL71aLak38gVLuv9netTjmPwHEK75m++8Mg3cOIhu/I/lDbdlYqvsRRH2bbB0P8", - "U961V3ax2yn7e2zwgOukASoL/TmmCxqhidPLVRAbaRS59e/yYI5OETnenio0Rjes3NdRqnXZcIYFJ4K8", - "rDozZJh8epQrwPH5cG1yDwqnT8SUz0lWwES2z0Jb4QThM+bKhganBuMyKULzZmU7qkmGBdWwAheaX2Op", - "Mv/fvjkKq7JIQ2EA4J9e/YLG2+INxzXHMsLKxJfac06mxyfiFUwCHcwuwdLrU6UznGYyLkP3MgaUTXGP", - "PyjZ7rSojmxP1NsnMn9ykefc1Vq+oxydv3vypNmdsfOvD4jOCJBXmLdgG6X/hAE6OHf+9xFfYOJ3Tx43", - "YtP1Hl0y4SWXzsnVhSo7elLD2+gxusMjH51Nk/N9NB3VsJnLRaQCQpIex4LhlSyTLEKnkrJl+SN4GAfl", - "KoZUrpYV75itBhxXEfkrePeSPv6BTNgPQQR5hLsYaX7z6QRrgDaXdp+iiQP4lwC9ASAGK6xLsMXa2B9z", - "RyNCGRvUNB2cuisz+nDpEaxpiPWE2U/wlpM2Dk3zaY2ppt5Ajb3GEO+YsGKpYMm28yeTJOpHSwXnH164", - "jaMdKtgiXE8mIX76Hv47SNJKI395KYvmfD9DQFw+Y/fd795YhpQ+H2PWU6r/QU7rseQhF7s0beT/KcXu", - "uzCNURfqM4ZPDknCgRoTnuAYt8pUbH6fphTczEEWSlrHop4hXl4NlTKnyAQng6LskHjU9dVtRclq2D0D", - "bSvkwg4X1ZSUtZ2+7mFI/vY4/5Ty1kYadZyErp0yS6knJ9lFU6FXVEybkfxCeuvim1tKBdcbvNcxEgVe", - "lbzBLZrLiy7BnpZ4BjrHC2kEZNcmVXh3G0deSB9rXeBNYm0naB2XNWS6UOGVNOohJafc/xd0AF+rU8yf", - "eMy5HXerQnIevlRnmKtSx7KM2jTszblNbfWrFZdsdcHnOulPibZSIrlzcWnDirPwErsLG3l1NXXeU8LJ", - "h9mkIp/lP8fp/ggBlytxHWME9c7AeGr4Gtt9JJBk22pK6PFqkBXjkJqC21kltku7oSMPVWWMBpXRDQSM", - "qEMCwyIWrU7YKyI+K71cUZjDL9hucIHy+ZgGF/AHr2Kjz5JagQY7hC142nXxgB9iQok9PxC5pN6/jCNc", - "Atq0LxwD6iNocQT16Xv+tcdlqIT3A5GhPeservlTSwUJCvcTDGrgPJV9q8NxWbnrwebR7LlMcSpFWTCs", - "IQH8LV+kpLpL9Q6FNZXyKUdoe1A+cNXC88HViUN4vD5FZNPinvEt0pRijDRxVqnoQNk5kEJwsYUcsKi1", - "id64qXl2gMc6UdZBWI9dx4lg2i3fxLKiSx0GlT+2WLCn8FmqWPWgdCWN8pkv+j0nLN7196Uu973uq4en", - "1W5SuoYcPDlajHE1ujPEF1r5qNsOqJpMbg4m4Ev4qxUngBjSKdGpqyBsH84BVfTSoGJfcVttvG7VCO2c", - "2livcQ6YjAn977D+/6LrY6l6LEBTdbbNVPW5dtsa6tFJ7qRfHXsFjegkXXrb9QH9iJ3qJDEVdnqKztp0", - "Yq0rqyDAJ7EIUjUYhCjUTvLzYDj7XDtgW3YEPCZMOPJxvx4cdb/UlQKxkjvSOzi17DvpOKSyPBcn4g1I", - "uRgzAfQaWPoNBRJ5/StrRs4FhSHi97ElEE/eyd1YDJVgPw8a70HUO92bD2c3hMK43NEE5gKY/2lRFTOz", - "TONqSrZUQVWYHNuQ7oEco/RKDSZXQlp88b/+0IjFynq6DtS7oAzGWuzE6xe4kMPC5j49Av6jpuTxb5f/", - "7d26++IZfQC/Ykaff9qzRlUmvg5RY1RGI9bFgod+dHJjWJzPGXrQuIrRS2YoXsQedskXVb7+NX74b8b+", - "a2HsYc5t36ndxrMCSWL7RnhrjfKBkATkO7abxSaFK3J6VPNFvoMDcprsZ3E+5tEONqPF2X1dSpGp8CVS", - "p3kh08RZSN/Sg6IkzxFKcii6p7M/3PRKLllyteZWD+X7yt1/ERfrhC3TisIEpC965NFb9cDjXqjHPVrE", - "O4vlf7CKENaQx7tiqQIEDJ/TCz7cKdlSVK7f8vmOWcniwb9SATTxEFBNrhvc3RQZeIqTeoPL+ByEgGKh", - "DyMCddA1UZtGJPIfij7EHTzyrHgcVG/IvEJe+VBPyeZe2FfKaB1VjilBAGYZwwbZyrhI1AmrC1wR45Lf", - "U3mcXNOKq/JH22I1dSB2iZv5MOQHuv6XjdbfR3S4aPgkzcGTCBtd1AOPqrCYhWIaxbSJiau4eNSW+IhV", - "yx+Q6cP+d8RWe8wZ6AHvvbiSnVdZd16pi25sBMQ/kIkFNjlfL1+Qo8EbhxKFRHSCPWiEQ3YlejHDs+hH", - "CnOfU6PCLJJo1LCqe+SSRilMslEEo0KpEMrAxLySPqc+xWDnavYp6UKqOf9AtCpVSP93YpFDCRsLvafv", - "6QdpgA1gkz99r02r3n04DO/j93dC+6aerQ/Hh5AQ69FbIvlb4RhHPjaJteOeJHXtcE44/0MmNHCM3xPK", - "Iss6+rJtuXqkjJOiElStNXG+GP/qlWlzBHRRkh9Khb0TFhMloU2IWtUjX2iEC85g9SABMMUQXyZQnrQp", - "U8eJQPrZ7v0k/56+jz+3vJFrrsWlCHrOzJwOzAEiJa7JmW10S27qwaSlpPllXZwzMD6Jau91zJWdoYYh", - "OFi7ir1rFcy6D6oIkYCinQdL6xyt+rVJ608+m7T+2SX16IN9+p5/7fEAii7eDwijQ6JLeLIPdXIiKO7H", - "o9Zgeso+/Ydd1PecwBSD+pRKqypKDcadH0UOk/hVSM9nr67Eo6WVXYOVojg6wQcZFDyRraC8yoOkQ+hw", - "3yn/GNymFSfGQ5MxNQ55uyg1OAU0kIJWkn6KX1uTmVRkW5kbTjxwnGQtk18TP2eaodpcE1N1XIXVdm1e", - "fz3PP25TieYPkImbBvl6g7cinHEbbyQrOe5xU92X5Z04QiZo06svcoaykJfyVSJfK6lyeUu5q7lSbVRc", - "DQJ9qLZ9TZdVqJB2qxtiVuFBv3TiInCY/c2HfGHNW+W8zDUwYBrKtFRZORWksjcm9QgpKR8PS9rzKRse", - "PcAPzBTqlWk5JBEThY4ye644mahq5wQ0zE4YH8kwFmELmsGJitARAAXahgnWYPWciDPCXQONWSsTYrYi", - "/GRQ4zRdIVUiQLB8WCpwjxDOf4vDU7RBw167fvNlLtjvYon6Re+cMhwYvIVXL+IkJ7moz0vmE9CQxqeU", - "tV+Wyg/iwj/3Rl7EvFd4BvD2S2mGUwBzVJ8WXA0wVikrG/MumX5BP9rHGPlmHF/+S696lUoFLmJlaU7c", - "hkkXcsQ5RJGBkRSNFzLHgU6g3EUmzP+qkegI/tUWE/MPQdY2svdfht95BSMnnXbWRds+ZLrB2rJHXilR", - "bsUJzrt9XCmbAS++EiEyZTel2X5ZsueU79fqy91ekqBwniu5xXSuQJvannWeW3mojb3Z3uXXuJivbZuZ", - "/saiq59pt6HitFFhpxESRWxQSkM0DvPi/J0wWG5/kOSTcm7CnZAKsbGSGwzUymEoMvnNGJucZhrhWau9", - "2QxEbagFt5BGeL2kpwbri+U8LgQ92Hh5mf10eYITbrNv6O2Dmj55iMm8FS3AEmF7MtwRf+1P38N/e7Rd", - "yWj/YCuY5sILDvyTl2/Cld9PuTUE3umlla49jGrdZ9TJ28l6qpUhRVBynRxFYDalK5lyZ2x7xRKF8PoE", - "eoyugDGtD7Pv8Ap6pSy6RDjYBwCGGSQYQraC5UrUq8UEHXhQqE1MHICvJhi52vmB5b2xv0fYPgzXhn3D", - "MHfh276dcNuyniQIx9kBIlTDV8pqjXCYvT8nKfR3RaVKU/olJQXOI4pWxFgW9A1qG9Eb+oXA6E1wcnEN", - "z2FeaoFIdJJizB5TKTPorKH0L0WJE0UqpuNL6VVCR+DKCl3Sbr1R9HPy2ixYgFnqt8qQmiYugy8etMjm", - "pO9cBgVraOUKJjgHWLqOCid+dYRhckHJdv9CqKguQC6tYWrmtD71Vtvel2PhHHBBPqgNzsb1avJO8tfP", - "eLP3hCg9jRMLNi6DJsKLi/uQF9RQEUzcR8yTECW8mK1uBZH64kcbhOw6exPBEhczFc6Eeza7k4X+aQkh", - "c8b5RyLWyJS8X5vh3gknOTeKJDzHKmoRPSYnyF/PdhrttyY5QKizIZCru036yvQX7Q94IEhXxjCSZtIa", - "9XhywkFtPray2Ed66zESVq7+V8odo0uZDzJ8bUVGPjNzAYWqdvLNvdFXGsQTfXUFJ9IaDiW7VOFGKQN3", - "vvR0LWev0eWAEpxMUYrnMPphKSOlV3f1qan1A1P8FP3cOQBtoh/btfMvGvYL0ZO4DVNezzIsVv/qZ+Qr", - "jZAf80h3i4mnA/hpA+LHM/p3LPy/ziFBw+znl1OpDmOBfCxTwsFULew/pykEHL1xOuSzE7M+NVFvHUu1", - "5JrvIwMEplrWhq0Xg9y3OmY3NYrsuugifKM9GnS9tSkAKyrJCg8OZMmMpW/ohWxJ3BFrJQ3abM9F6+yG", - "8gJjUlfkjM9jzr2xXwgkV8WCUzrwKE5BEj1fpx2mjcJO1EFD9yhkMyXJH2YzPIk33BkJp00EK37IEUNO", - "rUEjWDFCR9Mzj5bLUF4qGDyNhILKSkYbNVTwg0/9ORbHoW4odGQBLGa/EVdSdyQOEuUMq/RuomYWjFRX", - "SP3msymkGk73HE3xtCYGwxfxFBmd9AOyoTM+YA1zfMWqGSm8+mWcjJUykQ+TkHeSc6+R5pVrVkOYGjg0", - "DLseezARQpH4Re4PyJM2MQ+HafmSjIMl8TD6peIKo/gZ3466lEE8gq68FZaVVPiK/J7Ru+Ock7rzEbhW", - "ahPTnqLyGWv3TkXCAZrcJaf6J6wojSlK6inVv3ny4DnVD4rbQ8gcErhHidZxRXEfikzrTx5//erfrzIT", - "DWDnJ09DU2Me/52B5p+FQbx3mhryRnsp3XVrb7gZOcPTFzIEuVitYZmHZbQZ4dmny2MDp+LfSWz+ncTm", - "n+G4omzx+aW5lN2GDylOYx506NLxXVhzpR0oTPAx61SKnP1ocee4MpSkuJtjbZrsYBO80OatDniCoW9Q", - "hrMPO3ZcdbYXBhCr62JRUP9LL/1qQqbSJlgURKOhA7pth5zqaI3W7Iu478MK9UGXt4UJlvqU4pk9jg2O", - "oYEDEcghAUWnksK0hX7L3No3YtPjMjQXDoFi/Y24kj4cX1l3I2P9qjyxlIkx2Jiy3QwkzJpoWRElcfVt", - "8uzjyFp8pc0wHXkhJCbDUKpwEq1Gjwic5FUzR8dl4VV4XMb+orRsbO5BGxhl6ZT341Gj2YxhNlII1GqW", - "0E5CLLh+x8KHQJeR3gTd5ZVjxg2/FVu87czI6rI02yghw7rZbBgkVkAhQ03y3yYRGVPmE8j4SU74wDBV", - "LSErnArqY5QYgqF7RqDBFknVAjPyIBOFBNEgHtEGCH3Fzi2x9M/jnGc+zo8Akc5pG0vtl7PUZjj0H797", - "+jwmElCmjaYJezVsxsWVGG/msMg5L5DwIm+KeVz1kU8QG20L7IoO5XbwIGNInojvNOM07hF0UdeCVLQb", - "0YZrbwzvNAp68xhTC8cFxmTEvlXhrIzQETpqZVQ6GWUHg8Oxlq1qSEmlfSQsKcMHPqQlNNlBl7sZ0hUu", - "QJYkZ64W4pOaKwcuD42j2rPyoyhjxoEMI+ifF+o12gXQjW0idZWlgsDYUETwP/r2yX8+Fr3plPdlzrSi", - "c4Y0COxzDMR6xFsHOiw+TcZy4oASnI+bbUUkhnfwocbhcBd8LTsEkFynvO3ektrtFu+6Ti+CT4fGiE6a", - "NlNY4a24knwB8E1i5zhRvm7K6+VRMT1gpst32ovekKNGi7qLHCF266nAdKns4wwIS5SppVNEheNpKu/M", - "M9Z6JLdHJA28sQP0pXbwoT8RLwJq6xxAzweJGIO5+G/nV9bNcerjbWUSam5HGMnTLMgQ+T1gc11eLfVa", - "Y275sdll6iUPMFtIM9sUj97PSoza5pBwMkQhS2Xy8CDe4QQW3hbsaDq21TezdBK2p/NDJOYlMsKzqO4i", - "JIKPB2MBzc8x/ttDFpg54dCJnFf2UcCmZ3gJdBpL0QSqrP5//UYsVtLJRVAOb1tiUskKlc/1ybaM0Mzo", - "/fYE4APxqDjCj8/ihKzZSpw6POYnfC+cxcsyfVC5eM+R3Azvc5ipMqB/+zNOhKRNZcLsr+MlNLN3x9D0", - "+K10wK0DDx/RGVb2kj4vnrzinj7Ua218vriDXXpyAlyhC2+Q+jR4oQdLT4timvG2tE48Srj8GC9WLrD4", - "NYct1CSzY1zccUkk6okY4CZrnbwBKkqkY+vWivF9fPfeSI2uc1fWcaU9aHSeaHViGSupAKVZqA6HeQoD", - "cBKLL+TeG3kgwJMbBoP5+hW+UVb9/MJ3CmIfMDCJq99F1DIVK9wmJ7kZduJdKoPYY5aCf6qWFNEn4oKH", - "LqZThtbjWY4FLiYNsXtlq8nb/sUXjxxkmNfDw79yErUhmrEnFaV1oYJu6t0GE1EimaI/5tC0KdxmJMmE", - "qB9uB4EW0FKYHiuD5mCPMtCjERaM4psOrvA/vnnzqhnL5drXAs6nDHWv4lo/T50nTgt0aMpKmtvXT/RQ", - "JIBUW5s+7Ekt9EZeK8+G4Rg8FR2BH1EKjhyEj27C3Ajtf4/LStmFhAYqrJhgh0IZ8NPelB9nepL47zjy", - "CqtkK4OJHaABWOAqKBPv4zJi9JAIgDjOx11mX4nSuXlfz1OGm7+zp/1G7SkMc/LmXmbUhuq0x8wQ0TAq", - "YODCNgTIluxDZ0ICbXn5A9V6Z92V3GyOPLk7INuV1GDhtlN+pRSI+TStwr6FOtnOypYzPsRdEgvp0K1F", - "Ci9Ne2nfCbZBHl+oRe90uD1+ZTu9oKi0WHZ+o0zUSaJGh6Pa2KGtuxULiXkeFiGC4emrFzElBUxbuR3W", - "r9fy5p/JJPwfp//xb7PSJ6XzqL/ZmThO+7X2vgzQpwjDqv4HucB+uVQ+zPmmTjGY8S43VnTWLJXjj4PN", - "3/I3c+5DtefsSnZCbVEBlTyC4t1Qy0vI836N6/sCAk+EW/v13/WHMIfJoxCbNqjW2ShXhEcN7C5Vzuz1", - "Z2TMXt+JL/uHYcsq9dcrtRu+9irotVRR45rwX89W7EucMs5NNREwmcNudYii+3oTtrNLTVZ0eNDUTNz7", - "l0nNdIj8XTh4/2MI3ZE0HkRYU+OxATvK1jI6LbBFIeOVB5uuygG7N8qpFJJ7rQDFgnDqyp+C9F2b5el7", - "8+EwoZvMUM7eRA/ypNSVYbKUTILDZyklw6MdSosS4P8BiH+cKuzXKbg0P5hKsi4QmrsnrT40sSB51R+Q", - "KbAI86UDkVMEoj5yT57AQQfUdpAtkCKFfbA2lUUYBuNOJw/MCQBzHqxM1SlqfJTHXnjWquqwKxSDSsEU", - "af3ynKL9MOchwDXF/mXAHN4xqUntiH5v3fVFjmf+d/q9/YS9KNH/oEaBgzK+18voFxxIUU9fK88+5179", - "AtEbENIRcaTjiHlrVHKhSWjFCSOi0QnEMizJ77C5WmNsFsEFRbUGzkf2ikPd3bZmX7rrC/oI5LSH4myK", - "Ee6b8+M1w+GzJakeoVxQbq2N7PwX8ACNRp04hwkGl510gChL085122yhJ/A5WKiOGyFNvN1kZ7esxvUr", - "1XWcg6m9zS5qaRIBtc44AnV2RGG7245IFMx7AR1OlwCR/voNd/1QZUC4+y9WCiStb0oqi6D9wvFsCddP", - "38efeywQf5RmSYStWAYgG+75tjgF1+nWju8jAfjV/bQ5Ezrun9XlhV1cq8AhE+SxWXhNRgIeAYL2W/0r", - "tVvYDjSYyIwT60H6ceYwSNS8ibdE2ly6IRbKgG5547RBnW+I8bW2D5uehVIqOwcBoB084MCk6DVGY1Jh", - "OR4NDQaVpmzIgamjV2mAOKj0cmW7lnJHpSOif83e3pEWqHc6+pPTOtlL9YaoTqvEt0+ePEmEApoDJofe", - "pzhfJf3OWJECHw4IF4EN2Elid4blTcT6wW7ev9OxBv2bJ99sI97FjQ4R2QAsGQ03zga7sN2/hkq8LuNk", - "kvNJZLayMvGkDqAoGZw1rT2mLv81xb6jpZEjYpsioxEc3ehgnjpyfcoibl0kKcij5TJ+J+IHGZQTqtVs", - "32q5SEyhYsDeWgsmKGIBJ6QIPkGDasMPqHEf1huuGHgAciat4OuX7eNMT11v9hUMpbCI8SYBwpAUzUVA", - "tReafH3BN0gbrlkVCDhZmsRAFMILxpCgYqoAdxt7k3hLqfUmALsWpW7onB97Hp1uEE/dAubFXA4gwp+I", - "b598y8iaO46p7BFrJ7Ar7vjr/kGzq5bDTBkL8GzFffgaUasUFqbT+xWUhtJfZDajs0tt6N7FSA/Ai8jn", - "N7Sz/PFQWQlXNmBN3ncvrONsF1mC8Cfs1s52vHEAlkbJ4NJZ2S6kDzHnwkbegt095d/j1vHWBl3jZPR+", - "AslDEqZiIvuYbD9IzxoP8W67zs+p1edQpMbRWHw+RJ9KaBUXwwIZ3yypXfYbq0Lg9D28G7H7tbJj01fN", - "jrJj4o0kn0rJZBDoYZEIYmE3tx/D4k+Src9Bs54nKj+FfcXW5CvhgSgY/vcpNF5RW4zuKFyQbXDzJeey", - "Yk2kiwX00z7FIMCd+Y0IVnzz5MkgBqHAiqj5IuwYjDPGE1J4UC4TTBMO4/nRvILFacRC3OveYwCUuFSo", - "wjB0D8car4MAqJvY/eABLYoCN6qJdPsS6Q6QY2CE/Zm9Pr1CZAptP19pui0SN2EiChjgO2Imvxol9YcP", - "/3sA", + "J9iYWTNLVice5sC4ByLWoxT3xcMX1Hvx5Ic4UPHsIo55cH2Ue+Dm7oTmBQbE7a56HG8lPI+Ox0SbRxLG", + "iPLUSHHtCrwA9vx5Tms35tIm8t0ltpeYAW2CTb4iQbm1NhLy+mHKu7tkRZuQaXZIZnGK+xYHv3cucK3N", + "H5CJLr2nt2e2s1lduto5xcVKtX1XmVorb+f2ar62phbN+FQEK379lL2/sFF3Kzz3Fl0GY44Oyg1twuqI", + "KyG18lZgSkLrAlYjMGHlwUEAtTk32k9ob1Dg3nd9xTV9j40xw0dfOUpPYAm/+nUTVSyk2oIZ2oXsULEC", + "M8IVGgF9FCvcldd1+57Rpg9qYga/+c/ziTHIpEsfiw2ADe8CaFUfHkqlgJX98ItxbzUYHNH1hpUZQud6", + "FLKuO9rDRxPfXh+Sxrl0Wl01ZMTNXoRIqM4HTqjV4fFCrHePr4ClxkXRcgIvp76WG6WuW3k7oe6GN5iL", + "S10XuxaRvhGvrAE8R/krlRcq8fsggexnmkPNreBAZWLcQ5ajMIJsItx4b4xKrIZBYI4HsoAUn7aE9M2Q", + "kCQEKGZfIO4uEvV9PPvxZueBWhkngHeVGWiR8l7GbuqEeDe1e8MwIXETPTIl5BZRbTNBAQG2a/ler2Gq", + "v36K4KA/nn5+upYG+tWvi4Ge1AbKpCh99Jv/3PdRPrPTx23P9TV9kvbDdnTAPvfJucuNOkb7Ma7vFPe5", + "FNLXcFmiHbyn09IOGv6gDkQDh6FiGTvchbZVMTDR6mYUTo/3iTJFi8rcr2RN6UxvUXvjlIJWybXZFbb/", + "6Mh35MXvv3/2YpBNfhyL9InqlHe0pl92BmOxkoHgnYyqybwB02J1ZcxuqVQu1tYp6UNal+g3uQjOAckW", + "phjy7Qm/th41GiMX7DhNzxngnlJstlNXlCL5yp+CwvUUmkPSTpKHPp7Cd6cfzMe7mgubWdzbiZd6uazx", + "VqF3Zq5Me8b5T9lOqkx7bK+oBB6hz0nMywbglkNFk40uH7LlKGpKbs3hNfJaZbdpVhqdDcLo6FnhTsgR", + "2MqpWkTdCXrznmWkGMzmCqs8FuEQMAm0XwAiBGu7k+wHXK5bZFfZ8jwIbZBySZM/Q+LBpyhyopdqpVn9", + "O7R8NoO1sgNdzI9PcyaXXR2ENhFC5LJMeYXSsAmt0LPQAOEvojkiiXqUO+a0++B2RAst47hS3UII34Y/", + "5vAHDglH1wm52SjpUtBHHh3pAXBuMXMO5q/zpaaDJzNrEo7NmlkaZNbM0qq4Go2bNbOEYylSic7r9YFq", + "kUhH3xK+v0pzGL142zvzvWkrL6ztntP8Rm+e+evf82zH3/DkR4/fFGsZ9xWXNnr+A650j8akohwxs8Ed", + "UBCDkthmMrDXb+AC5JtnIaj1pnInTaUIxcqxVF2jzNoe085g6TL28JN1j192zUuG+3FdMn6LKLrolDSq", + "nfcboARW5LfgXIAHOuZjw6ZT5QPosz1hDS+oVXnrJGMPEwAwqi0661UrbtWk996OurZFpg0NdxhCH0ek", + "z5A8bmUNR8CmYrj8VXWl2mz6qbAi/s4zTaNN9EUeUBycvD02yjExYTFYEqlaYZS05xp+R/5g1hix7SXM", + "rsb5TVWZebuK+DRn8xQ2zEDxPEsdxFKNw7BzAmZ/F2Uw62/PipAq7VO52BOs7XrGzkNN1J3nKbLjILFT", + "6TTkD6BXXgaxlUTWHYSLZQQ/yz/jrZLC6E4G5yK3I1CkZlhGAc9Ia1XKg0wqj+zDVJRQoNpRg1PM6Ta2", + "Vdtc3jUuLzratrPigAMNShM9tOorIem4sGvxNJaBLR79kGdRPn4VZ1Q+fFHMrnz+nGb6x81eTXmSQA91", + "54oyXFRnF+QondhJCk1nppbOaFl3hjk8tR9r4uMHE1MINV9oQuY5fDrhu0BXGOffr0mZqFTg88XNCFs1", + "RjcurhGFAc9y4eIyrOmwDAHQ/WvqvZqHg5LrV2bHKiyDIaqbDbnLk+gBJ7hWLyhnpG6E7Vryg8M3qSbs", + "wRMfJx2vzL29nKPry4HJ5YpS9YfniYQ40flU0eRn5d4pLxa9c1SIcTsIcKjcAfSawJsNu4PMc3zJwd4j", + "vhKQcR9z9B+Ro/zY1HAilTxn2bWnSNuRM02RFBwbpBpZ8CrW5eOcWOyETR/CJ6q74pIDA2NbPpUM3jkG", + "clRuTXickNfYm4SOg/rEB+Mi9PdGXdVw0Hs1L85Q1brr7qo78KFfXHNIj1cLa9qJit2Y30GmlaIoC/r6", + "pU0wlsKT2xTpGPgqxRz3PeZ09QKHq6Pq3+36UteI10WkSJywKk4BhhXGig5L+9LJIB5Bjg4LkjquUZS2", + "xbqDN+X/w6nt9Zcq4F9QjC1qUJzKZkjch3ucKeaQNoxxchyXM74NMmjr271NB6q3E7kyvFGyYsqd1D15", + "9UsKa8mhTlEHhT631C9JAhAuc5BKqZI5tzbpt+SfXvPXDqt5tRILzBoCGvAOogJklCCjVULHqAIdhFGq", + "TeXXqgagai2C6ciN+DYPhxwjSUS4jIizWx1bpznwZdgta59WIWy8oEY5pBq73C6rjiOvsLLcQjkOlVSi", + "tWupzV1Y+7fcGRj95OJaUY3SoM7Ejxa5wEb8CDD8AwCQf7+Si5U26lkfVo24oPBD+MGlr6wTb7Zuu2mO", + "CxnAtNMF/BPE6jjjr2sI0+rJQhKDTBkspIN6C76hf30ziGXHeuxY3/+K6kAlF0D6JloaBtJpIUdU9yFH", + "EeyOMI8KtjjDI09TcUV6SWbBSLzKOkgZgjLQpbhV4QzIac5ohOGA8yvr5qR9s05QWKq3mC/lEXZAcTsc", + "3XEb158H9o8piwqwgTmHSs53ipPjAGiHxJ5SW+og1n3INoZKmsuifqmSrViqQBeCXhrZ+ZSMtq5puJRe", + "zbm6+zbkp8MeSIOxu8oKqVWlZ8mUnIpZcjq84sbCdjWfopfsncci6R9fRmP/RnYqBCzaybUYJdvLMcmT", + "FNghQGgrdod8F6zhYGzcH+AP0Ilxaev3+0OEnTyMrolLW/DFhJyO9uJGaiRCUVFUckJN/AtDEFqAzGgE", + "camgsVMQxtTu1GbJKVVgoe0ifWDK3pGTggwUXDIMS7hQwcagTa+QvtOKcYaJhVZmIpHFHXRtsP5derZ9", + "lGzK02Yr/HzXtnNmZABc+cmurczJVqopUSxranYF1k/pcvFtdHr8pZc+XRTV6K5xaSdHAI0pj4IlWlGF", + "XpF6aR9jW+TDSh9SZodpisVwxZAU1sjHeOwyXE8P6HAib9osEypYs1BFhhUOBLBu6M+/Ut0dqCCt4RA/", + "oe2doJWt5bXyRQlF+iAzSNEhP/i0YHbgDTSun9yVPYQqQ7YkU3wJZ+UmnNJIlEqyE5lsQUw2fBt1PLRO", + "bLjp8Qer/CneMq51GrFB2oA7ZE427l2rWOcEahpdoxkdOOqJOhjhT4rzoJe8ZL4OdZg2ANAH8/3ZtknY", + "oL2LPm6JVkVFO80VgUnMSsEQQYPkdJV95u5E1/YmTgYOClddXwm+ykhIPtrkYL/FfVFCGelL4nIGmL7p", + "VFCYzi77KSRsUD4hQ5PuCm6sqfg8cWWDRAUn4lm8ZYAOGLs1HZynPxEvQ0qbhFbQGPWTUm00op4epSna", + "zEHTjU5FyQwetxTzKVza9+kBipqlHTVCgIqD4foO9hGX7S2e0ee5j/Jh7G23TGQp/ieoAXsAItC12oRY", + "45ayCEbnVRQLnTSeKsDBtpLjJAGTfDEwVSAAiXrHldfy6TGHTQaurGo9q7GfRKOJUTiPHlvbp6DJlshE", + "1EGmiE+brLRBDEGr+RbrPyBoqvMKNdLnIrN55yCL5G50IEnVIBYmWeQ8ETmcDBPWI6aa8MU2hYxf6BCp", + "ZbK2si0H43ATjGN7gjLiSGGifXweL7t4Nca8kplCjimi9ll9wLkCb+QtdaTmcAumVft0VbAfRrqJYtfl", + "3Ru7GHBBw2ltc0m5a/ifHp5P7yKppkrbHeVDRKLKL/nj8yKILc6CB3U95M+lP+YbrkZ9qcKNUkZQHkxy", + "psGtw63K8SOjVJgwPvHcHEpxzkQp2CygbpGZbKCLFDZlXduSbvmjOXfC9VGJ0p3nAxE5b1ic2KrlQPfS", + "2KhJFs1zxn9j5+x9wl2xKhMVn3I5InC77IZD0KYH9DtyKM2MkXtsPqtaHePkyAOlaIgoO6ty7c1suBW5", + "y7wTBxJl0NaMDJjpEVsv09+F6TJ/hjN6nQAyejF6+CqBKD16nWCVHr0ogTb4VrWVdsOHP9pnDM706FmE", + "67Cv3xN8hw+fAZzfRDAXq5Ht7Vv7iqE9nsJFhnq99hRqAOoocLd96v2z2Fd+tAWa3mfY4IxIFp8fpGce", + "uDtua5230myl1JXpZBl1kBJ6Mh7h+5FOdeBPR3eFDmOpoRn63yGHHLmYwopVj4uwrZ3rammWLZnn7U8v", + "fjpZt1hnZDha6ZpyJ752OlThhymOgRUYcp3mlRpR9pe/q1IfJR4tVQDsiHkiknfMwm5uH0Oi3Nx3pI8x", + "wXl0PLSOpWvxiP7P7+YptjIq+qiQHWzk4/MtRkU6VUoMbHbSIfLQkQlCb3dIw4xqtshg4T6z9jOs1Dp5", + "pDy7O8jnEyGdP4zlF1Q5lxuxvQPUmq+qczGUraJbcwbzneebAH2v+ins2FEK+EnzOu6/0NdGxWiRpWk6", + "k0o0GuSrcOsCHEvCExdcSbEGqvmhfmbKAPE8p4odFdSTfkKuiOokR57bIOdIx7TjLKtZjqGHgTadz4Sc", + "cLbFdBZJwbCBFdp+wHnBeBMB+90d6s4UNR1r9Q2cqi3cqbSYQXWRKxKQSF2Gjs+I3W1ayP75j1ASIc/z", + "iEub3L77RoEAO80hHlhvI3tqDxKDc148JNiFUqrT1ymMorXKn4gfLd8z8eR/ltS2bwv+GJsQSeORrTsk", + "Xet0sOAF6QG3Lk4uLqF91NcMQNIMhGVWLZ2In8vFNyIMAxHhm00nF/lAAF25c+ghzZK+FT/zXa1zarWo", + "2gSOIKRUf9nlcZolsE7cVFeA5Bg7y0U3ith9jAD8s6ktZHdcYbwP5Ci3EqAhDmt8UBJL9tPdzKlIcmhA", + "vHjP0lTR0ibTNQTrtjem2Zo//k2wQXVFTEAgQwSgDuJSLSxBq1DYcU9/nlH2OfwTf6ozQY+wL3r051mT", + "x4yZZqwjjUM5Dz9GF1KcpAJF2zdiDeIfJ2jEW45kr1CJ3eHro9MCUfCJqg2uc9zA6AylByE+CIApa/6d", + "nYjuVhZtK/deMeQUQf35sGBYmYxZf1eDgCu+5RsiHfgorFSlCmGrQFwOnNtzZwAiD/oif3FwjgFeeDFY", + "deFKrl+p9aWq1Q4/kDLHYH3ZeYslhujkbKWhOiS3aOwYWqT4LCXZjR0zNtgrgckDnj55AtpGJxdBOd+I", + "3uhfetIzFR/e6Vp4i5Sfp2BviBS5HhWinqwiznZK7O6/vhExCcaOkMJ4XKGc/vZ2xLQUh3M7AxKwz7Ms", + "d79raheczG0cXUKz2h2j7OzN3lZb6cE6P+Mvd04Ljvdkdoyq2ebZiHgxRYNIJ7hwuARNupLq1YKrhNe2", + "dnsq6r32YU9dhpGXD3lIRVlaBsY/O2GnSihxGG7Y1mKh1X14wROP/f9lYsWxaOtIlLCU9Vx6sV3pFDo8", + "otxOJpAInnwXJnMV8kdXvUOwAUXw1TuG3LQnuCkIruMNN0o65YNYKdlyweh3Ks2vYiTfrjtyEAcXJ44M", + "JUw7Ow7DvmJdVvQ+5VpqETqcpno/nUnyqsWU6REAUxs2cWRAGO19zQtZdaVxugj5lFiNgaK5eu/T7OHU", + "LFYyeelKw7KS9hh8OIHH02Hjh5rccfBgiRE5FHBVOLGndMUZdWdw92GJmXbPahAtmPkZ/rw2W3Jz35qr", + "U3/DyIMa7bkduKpjlHOP5vobrL0Tc1/L6PUuN2jSUGiabMXCqVYHX3gAsckM3Z1AY8bZ7GVEcnRbBD4h", + "+2vH+VUP1LCM24RzGxV/8iSDc9TC4e4cNEVfd2vbKKROYq2IyeCbnypqAYqtKJnd+mBHb9yln3HMvbS3", + "WH2e5+TWc6KoiXBBTGWVbjuUeLj8AklCKRCiHgERCWHvld8d5OArGSJN0Esn3+lwO+HBKPu2Hv60sK16", + "v/+0cA+xfTMYchJivA1bR6aTlzXO92JlHUnSya0L8aJeKECvp7x5aSeP+DwMENX2l0jEtQF+NoyKJF5K", + "DHnvTUg3JI9LR4CzCqrgdx8YnLWglocfFJjQdqe9bxsR7LUyvok6EfSw2ii3wFq6XnVqQZbetcSc9fWj", + "Xq2R8WwNyxX4cgegpuFBwJ4OPBluCOVxwYHYW2ihAOyp/30Wm2aGrMK1sTeGvtkqDYHIxetlqNYxtCaU", + "yRt5W9tZILzB9aohd4OYngHWkCquRBN68p3TPvG5ZHMgh7n6vRzThu8QC/FVrGUSFSqYUg+7n6g08Rnr", + "gBxcrqOZmaJG03wTizTtotzbVZ2w8JBeXMecabu+TlmMP6VUSHXa461pCEnKuU3h1x/xgtnGsntDfLS2", + "g+udxFRLhUF4jWm6Qw8f3+BRCasejqbTs2bmyZgyWFueYUVxUhEAC2VmVpNEbQbFhhYa/kvm1GE97L4d", + "1MY3UUBEnuAEokeoAjWnoSvUjOSe4aN2krWV0ZkJeysi2sCkl1w8zokN25HHuRhH++TvQjUxc0FX1Hyi", + "shSGjKlA8DN/lEoLVMqcyj7Y+WS9MbxZJKspC4sgZioZe7EwieK/klIaJKGx1zRKGBVyBPb/pT2Gp8fg", + "e3Mc60UfYw1J5WZnQAw/NjTvCX/H3bMeuePwrPE3zplMQGmWWJl1w6mM4SnnHs8iE6jGVNtMLXb9Sesc", + "rOxDxV3isG4QCQ9WIsRjdhHUhpPDvaTvnu6NY4RxqpSA++SE7yN9ApypqfIgn6RUjQdtt4amklKhjQRD", + "RW9X15v6DTp5S9H5q0kgUS/EMz3yTGYOTmGXoYnpB6pmz8MSIDAdz2ZxjabvAvADPzBe054tvghVmRUt", + "3RNyDPa7nfQEiFpTVLcEBDsSfiU3dyzWH/OqTBviuNie49LIPqQMTqjd4SQi1l2TsTU8TgHbdwvUHqT0", + "qcx0Fz7VXIOZ4GBQHRI68HkXPyWPUF5MSC6X7OBUpADCuaApaNgkpb5JYRVYwI4/HGYd4WnkIOMHzD+C", + "IEQ3tJ/TqPlZdujLz9ijLz8oXPryw+ROlh+Vrnb56TAPCS99PqWYLHL0+GTqHIM/hiocitL1c4xDFf4o", + "xdSKM7Dr+CLV33ZMey8XAZOPIRrx4UgZ3UhEsI7uRPZqIpvI44aIWyM20smuo3ZOmtauQZdEXSXmJZ79", + "0rOoKIMZiUDmqM445MqHXBxDmjgmObunwlejZmlKTaWTNJTk2fJVX+WjJpJvvOk5Cpx6RW4vKLk+o6z9", + "skv+z2aQQyoZxrGyH7unNLGMe2I12VDnV9JRuX4MVy299DkTH+FaMZU7VHEvjIl3c/TgNR9sVDwTy004", + "/g9qyaHFRjwH1U8jlgoMTPmtNeJZVgbFjWZfdsJGI56j/gi7OBExo2zOOsG4iurRwp2gYv07nNVCvKu5", + "pqhNXFIkCOx6z9u6pMJ/tUMAnxC+35lDiDzceNsi4lc8ivCsKB9ryeUwEiwpt2+u5eHkwCwc6PPNfEem", + "8CHGlWbec9rduOUws/I1ow++jiuBc0p0KdEaPHWfgh1ESKbQw17x8eBSfr5hkiNkiDToJkk3SEaL0IVB", + "URAMOlNYL5a9USCEh9yVKLiBiZnIGdYzz8dictpPHcWcLbcnpuN/Np9re3cUGonEEa66e3kOlK5s991B", + "AmqFqQ9+AsSRtvMGoh1FtNopvFB1TGqAWf85Oy0N4umOou+4zokXsm05ie5TzlmDL0pPb+TSngDFI8Im", + "ze0NGjlV59VJVeE6VLAeCo6Pu/gI8mOtFbrdIdPe3REmd1bjajgBz45qu1vjX2vKgzEKi5kzgGN+HOIB", + "4Fd6w8a9qu5qMzAclrmX7mt0HAEEp50KyW7D4iMmnrxCJwaWDTHNC1ofnefSEydPTp7AsHajjNzo2dns", + "1ydPTn4Ni5VhhaDDpGqyXWtzukn1jPHNxvoaYUbTQSyloSEhJVe/H5QchmRLKUwMJnYMCYf9kcCauolx", + "8Nfxa4pe46+xTtStCqJVC43JGn/GODSyXdIHMd+HZ87Ui0e5/C+fpQVsaPScfaH8dbCbRrywCyrMBD9v", + "DKRapwre+nln+1a8cBq0eiAOOkjhS+fzV1ykA40xgHw40Mt2djZ7Dmt6XUCvmUXnQITkr548maGniwkc", + "NA0llFlBfPo3rtlINPVgvU4eryJNfGwq1eaolpXYKEdQPoEPf/PkydRIaQ2nXCcQ+y0QJgcILSm50hAs", + "v1OBcxl+Ijz2yN8wQmXJF1TFeKVkxzEdaDU92V4HPj9eFKbZqfUMbbgPuKzhQB8/7kmMN0h4d0Ltq9ld", + "L1Tdlhy/RTg5JaNafdxMLjn90xA0ZKPYhg6atX7LDkYPBZhMNyNf9tV25e3Y39bjIfvuXofssrOXOyjx", + "RbBOYdQzutkjBe09Oj7K6A1PDCF4GyUvZXlD7SmaCegGvGpVQAePrJzDrHWIDmtKsy5e//i7RvyP19//", + "rhG/e/mDsA6Sb74+Ec8C1SX9jXilf0vM4xg7YjmLnUiB0zpd6qvhhiT25lIbiQU5tq9O+vRvG7W877cb", + "c+9Pb9Tl5q7fHoC2Tz8b2iLkp7AVsKgVgGt3RtVm9t3TX98XsU8/wH8v24+76G3CmZ0H+l8McbY3ESB5", + "5OnINllkZBDhIefN/e4O20V6BfKqmp396cNMw3gcWEd8/Yz2cDbG5qZY03gFf4loMErlW+DB2AickvwK", + "C1c6MY+kUSOFW++5QuUruTgrCr1h4RkvKKEvVw4gz1ImkD7Fu9FsklNGFr5l+nzT3Q4+xqwat1F1gmoV", + "3aL/GUZ1kq0Z9ue3wAD/3rIHq3JlogjsG5K9G7QEl9mLk50Eel7B506hvE6fIoOKscAVmsvJjGnq4yP0", + "9MnTbTBfUDa9FGmWgR7zgn7CXRb3Wr1Xi+kr7Q3lRkju3nCT8b68kgshPf81v5R+haFtVD7qr1RnBN8d", + "wxB/xRQzlJsTdcHWbiD4kpygSHN7qaRDB8FrlRwKsB+yVhnx2//3zffztz/91/c/4iCFmwHHxtbg/v17", + "tSiA/vkZIOochvnS3E8e+Q1KElPUKG4fFYl9r8N8gVlTvTh+GqNxPCogQcNxrbtOtUJHceTXn22+BSEb", + "TvJHS16zjFrax1PHcaE6xGrucgFOYp1qOd8Sb2hUQ/1KsMta/synrqKiEc7sLTrUVc6DvzV0HmrM+hsq", + "gSXYfzXFPcjN5shHaRV6IFvHDYa55+IcemSLCL0vyNHzSO/aLfLEoT25l22G/0IxabmABTwkpuMAB2H6", + "d1MQVO1noFyYd+lKOSgrxT+HzEutjEbH6WWcWgQLKmnDtd1GVxJeUw3RpeXfMU+NCNKh5pYJDqUCirYi", + "DOwUKOLGfEAlfo6SG8JXiIbbG/m7uJFveVF3k2phsp+FhZFusdLvHopNyTt2N1ZlQoqe2FzRsjpptLuo", + "5rqy7u4b/GyxUJvA6bSaT9ro131tow85tffc4/sdV6XfpeP63T2OK2Z38ZPHkpRCx+ivTU1PBKpS8A+q", + "Wqg5qlj9ci5aGWQUnb9/x9UX/8fFTz+e0J+xGM4fpA/H+OT45QvxiGkwvfulV+5WJCR9jPHwyMnd5lsC", + "kzjFGf1MBd5QV9xQhjy0mXOEueKRnRIemUfkUzsl2/8HMTp+ETss4+ao+DGWlKOab7wM7AIs7TdGObG0", + "3IelgbFUY4XbucBE/9TFrH4Q6UrJR3EAqVlTw6rpbO/cJ0I0d5ncJD69q6KC+iRVmPgUgFr7LjmXATnZ", + "Q1pBuiAUPqYaCsNzt5eSEorSp59wiDB34uQZeglvMYDLj5ymxA+6C8Q/OMdMizWKT0CwA+9YjJZgjAa7", + "Zw2/IMoWh5tArtEWDDLF3HkDP2Hvo4POYYwNrgg9jw5Cis9gLMARJ0JJt5DolQwLFnPU2idHCu1SygN/", + "Il6QOztaVzDrIjY+2cKiUxKoj1FxPC35/U6/I10mNVdtioiAa1VDFtMsnYNtCVz3YqJGSv7AiaZj7T8W", + "D6PPQ3xKJRbLypHwmuoAyC4OcCN9vUIm5sbgYImY0AJST0USm/Pgyw6dk/OCct6SCMZx/o/kNsWzqOU3", + "oSmk+ca8ob0JtgfpPduJKRwpgRHpOKU4j1NqMsBFq+AGGjjUJKDRPFNo6ADK5G5TFYWpHOMz3PiHkRAQ", + "rd8wNDnZzhfWrWKZiAmeNiLKfRSrT767U+v/vC+VPx1Apn44n7FOrCxySrRBkweU7y/ZFnkiYmNHBfjL", + "qtXQNKrOMKSCvCew3hhgmCkyiRYBUU6J3kScrSEaYUAbL4oHxrT2IfQun5+KAwJybGqizd8uFn6AKe4x", + "BuTlP6CSq4BxHaYw0axizzfiwwiuBJb76deHkD1ttYdDisf8QcZtJsjHCxpYbWdozncNnm66z0mFhT6z", + "iXgYS4VFHOt0Ic6LyjRDD61TN1wuJpYONViooWvPueuU7icK3KQmkyHPBWSePtToCy8g05evhXu8hXyi", + "T77UEV2rXcfylXpYRwjlJhXNRR6YodNDzTuB5/kQLgkpSPOL+yMot4/2M3Duq/5cq9MYzjztUHJThF+V", + "m4JRjjfy9kRQ8DP8HgU/k5dJZvZNYheuk+66Fv/ciKBoIMrNDt6Z2BhdESADYnebSr6jja93hptbMxV7", + "zTw7FjOYcHJ5RnG7D4FI2PU/JQpVfKt2H+cjP/Kjofo42rNhF7CIdaTfc1Cto+yCnG2K3GByDTOM69Xh", + "JDlJUfdY8IKftIoyprDSLMRkOjyfaFCBlIeUlnVKY3EBXX8uL7HDotCKEQ9lDrf8lD5+zDf4yJiMotVg", + "kIc5AeUQ8PtLS3NDOB4At89zLE4/8C/mgAkTt/fhBT7f2od9anX6rH0gFjVN/Z6mlRqR/WZR7ck/EKrd", + "V/u7VqecrOI4xYNN3/1hkFNkRMN3pBipbTsrFV/hqA+z7YMh/inv2iu72O2U/QM2eMB10gCVhf4cc1KN", + "0MRhaNNGGkVu/bs8mKNTRE7qQGVAoxtW7usoFVRtOI2HE0FeVp0ZMkw+P8oV4PhyuDa5B4XTJ2LKlyQr", + "YCLbZ6GtcILwGXNlQ4NTg0G/FOB7s7IdFb7Dqn3WR/NrrIfn/9vTo7AqK4EUBgD+6dUvaLwt3nDwfKxV", + "rUx8qT0n/np8Il7DJNDB7BIsvT6V08NpJuMydC9jBOIU9/gHJdudFtWR7Yl6+0zmT64knrtay/eUCPY3", + "T540u9PC/uUB0RkB8hqTY2yj9B8xQAfnzv8+4gtM/ObJ40Zsut6jSya85PpMuYRVZUdPangbPUZ3eOSj", + "s2lyvo+moxo2c02SVKVK0uNYlb6SypRF6FS3uKyxBQ/joFwqk2ois+IdUyKB4yoifwXvXtHHfyAT9kMQ", + "QR7hLkaaX30+wRqgfaE4WqpOEwfwLwF6A0AMVliXYIsF2D/ljkaEMjaoaTo4dVdm9OH6Nlg4E4tWs5/g", + "LWcGHZrm0xpT4caBGnuNOQFiVpSlgiXbzp9MkqgfcfZfQriNox0q2CJcTyYhfvoB/jtI0kojf30pi+Z8", + "P0NAXD5j993v3ljrlj4fY9YzKjJDTuuxriZXVDVt5P8pj/P7MI1RF+oLhk8OScKBGhOe4Bi3ynx/fp+m", + "FNzMQRZKWseiaCZeXg3Vy6fIBCeDohSkeNT11W1FyWrYPQNtK+TCDhfVlJS1nSPxYUj+9jj/lPLWRhp1", + "nISunTJLqScn2UVTNWFUTJuR/EJ66+KbW8o32Bu81zESBV6VvMEtmsuLLsGelngGOscLaQSkcCdVOGYt", + "YKTysaAK3iTWdoLWcVlDpgsVXkujHlJyyv1/RQfwtTrFJJ3HnEB0tyokJ3tMxay59Hms/alNw96c29RW", + "v15xXWAXfC7G/4xoK2UrPBeXNqw41TOxu7CRV1dT5z1lNX2YTSqSpv5znO5PEHC53NsxRlDvDIynhm+w", + "3ScCSbatpoQerwdZMQ4pXLmdVWK7fiA68lDpz2hQGd1AwIg6JDAsYtHqhL0i4rPSyxWFOfyC7QYXKJ+P", + "aXABf/A6NvoiqRVosEPYgmddFw/4ISaU2PMDkUvq/es4wiWgTfvCMaA+gRZHUJ9+4F97XIZKeD8QGdqz", + "7uGaP7dUkKBwP8GgBs5T2bc6HJfl4R5sHs2eyxSnUtSew0IlwN/yRUqqu1RUU1hTqdFzhLYH5QOXxjwf", + "XJ04hMfrU0Q2Le4Z3yJNKcZIE2eVKluUnQMpBBdbSDSMWpvojZuaZwd4LEZmHYT12HWcCOZp802sXbvU", + "YVBeZosFewafpbJoD0pX0ihf+KLfc8LiXX9f6nLf6756eFrtJqVryMGTo8UYV6M7Q3yhlY+67YCqyeTm", + "YAK+hL9acQKIIZ0SnboKwvbhHFBFLw0q9hW31cbrVo3QzqmN9RrngMmY0P/OKaHNoutb9onAKkdVZ9tM", + "VV9ot62hHp3kTvrVsVfQiE7SpbddHxSlu+skMRV2eorO2nRirStLbcAnsdJWNRiEKNRO8vNgOPtCO2Bb", + "dgQ8Jkw48nG/Hhx1v9aVArGSO9I7OLXsO+k4pLI8FyfiLUi5GDMB9FrFbHlSeP131oycCwpDxO9jS2Fs", + "zH+xG4uh3PCXQeM9iHqne/Ph7IZQfZk7msBcAPM/LapiZpZpXE3JliqoCpNjG9I9kGOUXqnB5EpIiy/+", + "1+8asVhZT9eBeh+UwViLnXj9EhdyWNjc50fAf9SUPP7d8r+9X3dfPaMP4FfM6PNPe9Yo3+23IWqMarXE", + "4mvw0I9ObgyL8zlDDxpXrVHCmsiskHgRe9glX1T5+jf44b8Z+2+FsYc5t32ndhvPCiSJ7RvhrTXKB0IS", + "kO/YbhabFK7I6VHNF/kODshpsl/E+ZhHO9iMFmf3bSlFpsKXSJ3mhUwTZyF9Sw+KkjxHKMmh6J7O/nDT", + "K7lkydWaWz2U7yt3/1VcrBO2TCsKE5C+6pFHb9UDj3uhHvdoEe8s1pjCUlV2rfiuWKoAAcPn9IIPd0q2", + "FJXrt3y+Y1ayePCvVABNPARUk+sGdzdFBp7hpN7iMr4EIaBY6MOIQB10TdSmEYn8h6IPcQePPCseB+U+", + "Mq+QVz7UU7K5F/aVMlpHlWNKEIBZxrBBtjIuEnUCooRZCGQo3lMNplw4zVOv0bZYTR2IXeJmPgz5ga7/", + "ZaP19xEdrkw/SXPwJMJGF0XnoyosZqGYRjFtYuIqrlC2JT5iafwHZPqw/x2x1R5zBnrAey+uZOdV1p1X", + "iu8bGwHxD2RigU3O18tX5GjwxqFEIRGdYA8a4ZBdiV7M8Cz6kcLc59SoMIskGpXSxaSPsht0SmGSjSIY", + "FUqVcwYm5pX0OfUpBjtXs09Jh/iakgI8AK1KZfj/nVjkUMLGQu/pB/pBGmAD2ORPP2jTqvcfD8P7+P2d", + "0L6pZ+vD8SEkxHqqihP9rXCMIx+bxAKFT5K6djgnnP8hExo4xu8JZZGh8AmTbcslSmWcFNWOaa2J88X4", + "V69MmyOgc7aEYMWVfi8sJkpCmxC1qke+0AgXnMHqQQJgiiG+TqA8aVOmjhOB9Ivd+0n+Pf0Qf255I9dc", + "i0sR9JyZOR2YA0RKXJMz2+iW3NSDSUtJ8+u6OGdgfBbV3puYKztDDUNwsNgZe9cqmHUfVBEiAZVhD5bW", + "OVr1W5PWn3wxaf2LS+rRB/v0A//a4wEUXbwfEEaHRJfwZB/q5ERQ3I9HrcH0lH36D7uo7zmBKQb1GdXv", + "VZQajDs/ihwm8auQns9eXYlHSyu7BitFcXSCDzIoeCJbQXmVB0mH0OG+U/4xuE0rToyHJmNqHPJ2UWpw", + "CmhouTwb6qf4tTWZSUW2lbnhxAPHSdYy+TXxc6YZqs2FV1XHpX5t1+b11/P84zaVaP4AmbhpkG83eCvC", + "GbcR0jzhRtzjprovyztxhEzQpldf5QxlIS/lq0S+VlJ5/JZyV3M55Ki4GgT6nCHO1nRZhQppt7ohZhUe", + "9EsnLgKH2d98yBfWvFPOy1wDA6ahTEvlu1NBKntjUo+QkvIxzjHl0ORTNjx6gB+YKdQr03JIIiYKHWX2", + "XHEyUdXOCWiYnTA+kmEswhY0gxMVoSMACrQNE6zB6jkRZ4S7BhqzVibEbEX4yaAobrpCqkSAYPmwVOAe", + "IZz/FoenaIOGvXb95utcsN8bzqCw6J1ThgODt/DqZZzkJBf1Zcl8AhrS+JSy9utS+UFc+JfeyIuY9wrP", + "AN5+Kc1wCmCO6tOCqwHGKmVlY94l0y/oR/sYI9+M48t/6VWvUqnARSxFzonbMOlCjji3tkMjKRovZI4D", + "nUC5i0yY/1Uj0RH8qy0m5h+CrG1k778Ov/MaRk467ayLtn3IdIO1ZY+8UqLcihOcd/u4UjYDXnwjQmTK", + "bkqz/bpkzynfr9XXu70kQeE8V3KL6VyBNrU96zy38lAbe7O9y29wMd/aNjP9jUVXv9BuQ8Vpo8JOIySK", + "2Fga/dYp5sX5O2Fsq06GST4p5ybcCakQGyu5wUCtHIYik9+MsclpphGetdqbzUDUhlpwC2mE10t6arC+", + "WM7jQtCDjZeX2U+XJzjhNvuW3j6o6ZOHmMxb0SosDC/DsEoxqnpPP8B/e7RdyWj/YCuY5sILDvyzl2/C", + "ld9PuTUE3umlla49jGrdZ9TJ28l6qpUhRVBynRxFYDalK5lyZ2x7xRKF8PoEeoyugDGtD7Pv8Ap6pSy6", + "RDjYBwCGGSQYQraC5UrUq8UEHXhQqE1MHICvJhi52vmB5b21v0XYPgzXhn3DMHfh276bcNuyniQIx9kB", + "IlTDN8pqjXCYvT8nKfT3RaVKU/olJQXOI4pWxFgW9A1qG9Eb+oXA6E1wcnENz2FeaoFIdJJizB5TKTPo", + "rKH0L0WJE0UqpuNL6VVCR+DKCl3Sbr1R9HPy2ixYgFnqd8qQmiYugy8etMjmpO9cBgVraOUKJjgHWLqO", + "Cid+dYRhckHJdv9CqKguQC6tYWrmtD71Ttvel2PhHHBBPqgNzsb1avJO8tfPebP3hCg9ixMLNi6DJsKL", + "i/uQF9RQEUzcR8yTECW8mK1uBZH64kcbhOw6exPBEhczFc6Eeza7k4X+WQkhc8b5RyLWyJS8X5vh3gkn", + "OTeKJDzHKmoRPSYnyF/PdhrttyY5QKizIZCru036yvQX7Q94IEhXxjCSZtIa9XhywkFtPrWy2Cd66zES", + "Vq7+18odo0uZDzJ8a0VGvjBzAYWqdvLNvdFXGsQTfXUFJ9IaDiW7VOFGKQN3vvR0LWev0eWAEpxMUYoX", + "MPphKSOlV3f1qan1A1P8HP3cOQBtoh/btfOvGvYL0ZO4DVNezzIsVv/qZ+QbjZAf80h3i4mnA/h5A+LH", + "M/p3LPy/ziFBw+yXl1OpDmOBfCxTwsFULew/pykEHL1xOuSzE7M+NVFvHUu15JrvIwMEplrWhq0Xg9y3", + "OmY3NYrsuugifKM9GnS9tSkAKyrJCg8OZMmMpW/ohWxJ3BFrJQ3abM9F6+yG8gJjUlfkjM9jzr2xXwgk", + "V8WCUzrwKE5BEj1fpx2mjcJO1EFD9yhkMyXJH2YzPIk33BkJp00EK37IEUNOrUEjWDFCR9Mzj5bLUF4q", + "GDyNhILKSkYbNVTwg0/9ORbHoW4odGQBLGa/EVdSdyQOEuUMq/RuomYWjFRXSP3qiymkGk73HE3xtCYG", + "w1fxFBmd9AOyoTM+YA1zfMWqGSm8+mWcjJUykQ+TkHeSc6+R5pVrVkOYGjg0DLseezARQpH4Re4PyJM2", + "MQ+HafmSjIMl8TD6peIKo/gZ3466lEE8gq68FZaVVPiK/J7Ru+Ock7rzEbhWahPTnqLyGWv3TkXCAZrc", + "Jaf6Z6wojSlK6inVnz558JzqB8XtIWQOCdyjROu4orgPRab1J4+/ffXvN5mJBrDzs6ehqTGP/85A88/C", + "IN47TQ15o72S7rq1N9yMnOHpCxmCXKzWsMzDMtqM8Ozz5bGBU/HvJDb/TmLzz3BcUbb48tJcym7DhxSn", + "MQ86dOn4Lqy50g4UJviYdSpFzn60uHNcGUpS3M2xNk12sAleaPNOBzzB0Dcow9mHHTuuOtsLA4jVdbEo", + "qP+ll341IVNpEywKotHQAd22Q051tEZr9kXc92GF+qDL28IES31K8dwexwbH0MCBCOSQgKJTSWHaQr9l", + "bu0bselxGZoLh0Cx/kZcSR+Or6y7kbF+VZ5YysQYbEzZbgYSZk20rIiSuPo2efZxZC2+0maYjrwQEpNh", + "KFU4iVajRwRO8qqZo+Oy8Co8LmN/UVo2NvegDYyydMr78ajRbMYwGykEajVLaCchFly/Z+FDoMtIb4Lu", + "8sox44bfii3edmZkdVmabZSQYd1sNgwSK6CQoSb5b5OIjCnzCWT8JCd8YJiqlpAVTgX1MUoMwdA9I9Bg", + "i6RqgRl5kIlCgmgQj2gDhL5i55ZY+udxzjMf50eASOe0jaX2y1lqMxz6998/exETCSjTRtOEvRo24+JK", + "jDdzWOScF0h4kTfFPK76yCeIjbYFdkWHcjt4kDEkT8T3mnEa9wi6qGtBKtqNaMO1N4Z3GgW9eYypheMC", + "YzJi36pwVkboCB21MiqdjLKDweFYy1Y1pKTSPhKWlOEDH9ISmuygy90M6QoXIEuSM1cL8UnNlQOXh8ZR", + "7Vn5UZQx40CGEfTPC/Ua7QLoxjaRuspSQWBsKCL4H3335D8fi950yvsyZ1rROUMaBPY5BmI94q0DHRaf", + "JmM5cUAJzsfNtiISwzv4UONwuAu+lh0CSK5T3nbvSO12i3ddpxfBp0NjRCdNmyms8FZcSb4A+Caxc5wo", + "Xzfl9fKomB4w0+U77UVvyFGjRd1FjhC79VRgulT2cQaEJcrU0imiwvE0lXfmGWs9ktsjkgbe2AH6Ujv4", + "0J+IlwG1dQ6g54NEjMFc/LfzK+vmOPXxtjIJNbcjjORpFmSI/B6wuS6vlnqtMbf81Owy9ZIHmC2kmW2K", + "Rx9mJUZtc0g4GaKQpTJ5eBDvcAILbwt2NB3b6ptZOgnb0/lDJOYlMsKzqO4iJIKPB2MBzc8x/ttDFpg5", + "4dCJnFf2UcCmZ3gJdBpL0QSqrP5//UosVtLJRVAOb1tiUskKlc/1ybaM0Mzo/fYE4APxqDjCj8/ihKzZ", + "Spw6POYnfC+cxcsyfVC5eM+R3Azvc5ipMqB/+xNOhKRNZcLsL+MlNLP3x9D0+J10wK0DDx/RGVb2ij4v", + "nrzmnj7Wa218ubiDXXpyAlyhC2+Q+jR4oQdLT4timvG2tE48Srj8GC9WLrD4LYct1CSzY1zccUkk6okY", + "4CZrnbwBKkqkY+vWivF9fPfeSI2uc1fWcaU9aHSeaHViGSupAKVZqA6HeQYDcBKLr+TeG3kgwJMbBoP5", + "9hW+UVb98sJ3CmIfMDCJq99F1DIVK9wmJ7kZduJdKoPYY5aCf6qWFNEn4oKHLqZThtbjWY4FLiYNsXtl", + "q8nb/uVXjxxkmNfDw79xErUhmrEnFaV1oYJu6v0GE1EimaI/5tC0KdxmJMmEqB9uB4EW0FKYHiuD5mCP", + "MtCjERaM4psOrvDfv337uhnL5drXAs6nDHWv41q/TJ0nTgt0aMpKmtu3T/RQJIBUW5s+7Ekt9FZeK8+G", + "4Rg8FR2BH1EKjhyEj27C3Ajtf4/LStmFhAYqrJhgh0IZ8NPelB9nepL47zjyCqtkK4OJHaABWOAqKBPv", + "4zJi9JAIgBQa+0mX2TeidG4+1POU4ebv7Gm/UXsKw5y8uZcZtaE67TEzRDSMChi4sA0BsiX70JmQQFte", + "/YFqvbPuSm42R57cHZDtSmqwcNspv1IKxHyaVmHfQp1sZ2XLGR/iLomFdOjWIoWXpr207wXbII8v1KJ3", + "Otwev7adXlBUWiw7v1Em6iRRo8NRbezQ1t2KhcQ8D4sQwfDs9cuYkgKmrdwO69cbefPPZBL+j9P/+LdZ", + "6bPSedTf7Ewcp/1ae18G6FOEYVX/g1xgv1wqH+Z8U6cYzHiXGys6a5bK8cfB5m/5mzn3odpzdiU7obao", + "gEoeQfFuqOUl5Hm/wfV9BYEnwq399u/6Q5jD5FGITRtU62yUK8KjBnaXKmf25gsyZm/uxJf9w7Bllfrr", + "ldoN33oV9FqqqHFN+G9nK/YlThnnppoImMxhtzpE0X29CdvZpSYrOjxoaibu/eukZjpE/i4cvP8xhO5I", + "Gg8irKnx2IAdZWsZnRbYopDxyoNNV+WA3RvlVArJvVaAYkE4deVPQfquzfL0g/l4mNBNZihnb6IHeVLq", + "yjBZSibB4YuUkuHRDqVFCfD/AMQ/ThX26xRcmh9MJVkXCM3dk1YfmliQvOoPyBRYhPnSgcgpAlEfuSdP", + "4KADajvIFkiRwj5Ym8oiDINxp5MH5gSAOQ9WpuoUNT7KYy88a1V12BWKQaVgirR+eU7RfpjzEOCaYv8y", + "YA7vmNSkdkR/sO76Iscz/zv93n7CXpTof1CjwEEZ3+tl9AsOpKinr5Vnn3OvfoHoDQjpiDjSccS8NSq5", + "0CS04oQR0egEYhmW5HfYXK0xNovggqJaA+cje8Wh7m5bsy/d9QV9BHLaQ3E2xQj3zfnxhuHwxZJUj1Au", + "KLfWRnb+K3iARqNOnMMEg8tOOkCUpWnnum220BP4HCxUx42QJt5usrNbVuP6leo6zsHU3mYXtTSJgFpn", + "HIE6O6Kw3W1HJArmvYAOp0uASH/9lrt+qDIg3P1XKwWS1jcllUXQfuV4toTrpx/izz0WiN9LsyTCViwD", + "kA33fFucgut0a8f3kQD86n7anAkd98/q8sIurlXgkAny2Cy8JiMBjwBB+63+O7Vb2A40mMiME+tB+nHm", + "MEjUvIm3RNpcuiEWyoBueeO0QZ1viPG1tg+bnoVSKjsHAaAdPODApOg1RmNSYTkeDQ0GlaZsyIGpo1dp", + "gDio9HJlu5ZyR6Ujov+evb0jLVDvdfQnp3Wyl+oNUZ1Wie+ePHmSCAU0B0wOvU9xvkr6nbEiBT4cEC4C", + "G7CTxO4My5uI9YPdvH+nYw360ydPtxHv4kaHiGwAloyGG2eDXdjuX0MlXpdxMsn5LDJbWZl4UgdQlAzO", + "mtYeU5f/PcW+o6WRI2KbIqMRHN3oYJ46cn3KIm5dJCnIo+UyfifiDzIoJ1Sr2b7VcpGYQsWAvbUWTFDE", + "Ak5IEXyCBtWGH1DjPqw3XDHwAORMWsG3L9vHmZ663uwrGEphEeNNAoQhKZqLgGovNPn6gm+QNlyzKhBw", + "sjSJgSiEF4whQcVUAe429ibxllLrTQB2LUrd0Dk/9jw63SCeugXMi7kcQIQ/Ed89+Y6RNXccU9kj1k5g", + "V9zxN/2DZlcth5kyFuDZivvwLaJWKSxMp/crKA2lv8hsRmeX2tC9i5EegBeRz29oZ/njobISrmzAmrzv", + "XljH2S6yBOFP2K2d7XjjACyNksGls7JdSB9izoWNvAW7e8q/x63jrQ26xsno/QSShyRMxUT2Mdl+kJ41", + "HuLddp2fU6svoUiNo7H4fIg+ldAqLoYFMr5ZUrvsN1aFwOkHeDdi92tlx6avmh1lx8RbST6Vkskg0MMi", + "EcTCbm4/hcWfJFtfgma9SFR+CvuKrclXwgNRMPzvc2i8orYY3VG4INvg5kvOZcWaSBcL6Kd9ikGAO/Op", + "CFY8ffJkEINQYEXUfBF2DMYZ4wkpPCiXCaYJh/H8aF7B4jRiIe517zEASlwqVGEYuodjjddBANRN7H7w", + "gBZFgRvVRLp9iXQHyDEwwv7MXp9fITKFtl+uNN0WiZswEQUM8B0xk9+Mkvrjx/89AA==", } // decodeSpec returns the embedded OpenAPI spec as raw JSON bytes, diff --git a/internal/store/definition.go b/internal/store/definition.go index 8922876..b4ded9c 100644 --- a/internal/store/definition.go +++ b/internal/store/definition.go @@ -28,9 +28,11 @@ func insertDefinition(ctx context.Context, tx *sql.Tx, def api.WorkflowDefinitio kind, children = "order", s.Order case s.Parallel != nil: kind, children = "parallel", s.Parallel + case s.Random != nil: + kind, children = "random", s.Random } - _, err := tx.ExecContext(ctx, `INSERT INTO workflow_steps (definition_id, id, parent, position, kind, stage, model, prompt) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, - id, stepID, parent, pos, kind, s.Stage, s.Model, s.Prompt) + _, err := tx.ExecContext(ctx, `INSERT INTO workflow_steps (definition_id, id, parent, position, kind, stage, model, prompt, weight) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, + id, stepID, parent, pos, kind, s.Stage, s.Model, s.Prompt, s.Weight) if err != nil { return err } @@ -92,14 +94,14 @@ func loadDefinition(ctx context.Context, q querier, id string) (api.WorkflowDefi } children := map[int][]stepRow{} - rows, err = q.QueryContext(ctx, `SELECT id, coalesce(parent, -1), kind, stage, model, prompt FROM workflow_steps WHERE definition_id = ? ORDER BY coalesce(parent, -1), position`, id) + rows, err = q.QueryContext(ctx, `SELECT id, coalesce(parent, -1), kind, stage, model, prompt, weight FROM workflow_steps WHERE definition_id = ? ORDER BY coalesce(parent, -1), position`, id) if err != nil { return def, err } for rows.Next() { r := stepRow{} parent := 0 - err = rows.Scan(&r.id, &parent, &r.kind, &r.step.Stage, &r.step.Model, &r.step.Prompt) + err = rows.Scan(&r.id, &parent, &r.kind, &r.step.Stage, &r.step.Model, &r.step.Prompt, &r.step.Weight) if err != nil { rows.Close() return def, err @@ -125,6 +127,9 @@ func loadDefinition(ctx context.Context, q querier, id string) (api.WorkflowDefi case "parallel": sub := build(r.id) r.step.Parallel = &sub + case "random": + sub := build(r.id) + r.step.Random = &sub } steps = append(steps, r.step) } diff --git a/internal/store/migrations/105-add-random-workflow-steps.sql b/internal/store/migrations/105-add-random-workflow-steps.sql new file mode 100644 index 0000000..7f2b769 --- /dev/null +++ b/internal/store/migrations/105-add-random-workflow-steps.sql @@ -0,0 +1,17 @@ +CREATE TABLE workflow_steps_next ( + definition_id TEXT NOT NULL REFERENCES workflow_definitions(id), + id INTEGER NOT NULL, + parent INTEGER, + position INTEGER NOT NULL, + kind TEXT NOT NULL CHECK (kind IN ('stage', 'order', 'parallel', 'random')), + stage TEXT NOT NULL, + model TEXT NOT NULL, + prompt TEXT NOT NULL, + weight REAL NOT NULL DEFAULT 0, + PRIMARY KEY (definition_id, id), + UNIQUE (definition_id, parent, position) +); +INSERT INTO workflow_steps_next (definition_id, id, parent, position, kind, stage, model, prompt) + SELECT definition_id, id, parent, position, kind, stage, model, prompt FROM workflow_steps; +DROP TABLE workflow_steps; +ALTER TABLE workflow_steps_next RENAME TO workflow_steps; diff --git a/internal/store/workflow.go b/internal/store/workflow.go index eb570db..a7c4240 100644 --- a/internal/store/workflow.go +++ b/internal/store/workflow.go @@ -7,6 +7,7 @@ import ( "fmt" "g.fc.run/ai/byre/internal/api" + "g.fc.run/ai/byre/internal/workflow" ) type FrozenWorkflow struct { @@ -38,7 +39,7 @@ func (s *Store) ListWorkflows(ctx context.Context) ([]api.WorkflowSummary, error } func (s *Store) GetWorkflow(ctx context.Context, name string) (api.WorkflowDefinition, error) { - f, err := s.FreezeWorkflow(ctx, name) + f, err := s.savedWorkflow(ctx, name) return f.Definition, err } @@ -192,6 +193,20 @@ func (s *Store) DeleteWorkflow(ctx context.Context, name, actor string) error { } func (s *Store) FreezeWorkflow(ctx context.Context, name string) (FrozenWorkflow, error) { + f, err := s.savedWorkflow(ctx, name) + if err != nil || !workflow.HasRandom(f.Definition) { + return f, err + } + f.Definition = workflow.Resolve(f.Definition) + err = s.write(ctx, func(tx *sql.Tx, emit emitFunc) error { + id, err := insertDefinition(ctx, tx, f.Definition) + f.DefinitionID = id + return err + }) + return f, err +} + +func (s *Store) savedWorkflow(ctx context.Context, name string) (FrozenWorkflow, error) { f := FrozenWorkflow{Name: name} err := s.db.QueryRowContext(ctx, `SELECT definition_id FROM workflows WHERE name = ?`, name).Scan(&f.DefinitionID) if errors.Is(err, sql.ErrNoRows) { diff --git a/internal/workflow/workflow.go b/internal/workflow/workflow.go index 5481a0c..d03c5f2 100644 --- a/internal/workflow/workflow.go +++ b/internal/workflow/workflow.go @@ -3,6 +3,8 @@ package workflow import ( "errors" "fmt" + "math" + "math/rand/v2" "slices" "strings" "unicode" @@ -45,7 +47,7 @@ func Validate(def api.WorkflowDefinition) error { } seen := map[string]bool{} for i, s := range def.Steps { - problems = append(problems, stepProblems(s, fmt.Sprintf("steps[%d]", i), seen)...) + problems = append(problems, stepProblems(s, fmt.Sprintf("steps[%d]", i), seen, false)...) } if len(problems) > 0 { return fmt.Errorf("%w: %s", ErrInvalid, strings.Join(problems, "; ")) @@ -53,36 +55,52 @@ func Validate(def api.WorkflowDefinition) error { return nil } -func stepProblems(s api.WorkflowStep, where string, seen map[string]bool) []string { +func stepProblems(s api.WorkflowStep, where string, seen map[string]bool, inRandom bool) []string { kinds := 0 - for _, given := range []bool{s.Stage != "", s.Order != nil, s.Parallel != nil} { + for _, given := range []bool{s.Stage != "", s.Order != nil, s.Parallel != nil, s.Random != nil} { if given { kinds++ } } if kinds != 1 { - return []string{fmt.Sprintf("%s: a step needs exactly one of stage, order and parallel", where)} + return []string{fmt.Sprintf("%s: a step needs exactly one of stage, order, parallel and random", where)} + } + + problems := []string{} + if !inRandom && s.Weight != 0 { + problems = append(problems, fmt.Sprintf("%s: weight belongs only on a step directly in a random", where)) } if s.Stage == "" { if s.Model != "" || s.Prompt != "" || s.Agents != nil { - return []string{fmt.Sprintf("%s: model, prompt and agents belong on a stage, not on an order or parallel", where)} + return append(problems, fmt.Sprintf("%s: model, prompt and agents belong on a stage, not on an order, parallel or random", where)) } list, kind := s.Order, "order" - if s.Parallel != nil { + switch { + case s.Parallel != nil: list, kind = s.Parallel, "parallel" + case s.Random != nil: + list, kind = s.Random, "random" } if len(*list) == 0 { - return []string{fmt.Sprintf("%s: %s is empty", where, kind)} + return append(problems, fmt.Sprintf("%s: %s is empty", where, kind)) + } + if s.Random != nil { + weights := []float64{} + for _, c := range *s.Random { + weights = append(weights, c.Weight) + } + p := WeightsProblem(weights) + if p != "" { + problems = append(problems, fmt.Sprintf("%s: %s", where, p)) + } } - problems := []string{} for i, c := range *list { - problems = append(problems, stepProblems(c, fmt.Sprintf("%s.%s[%d]", where, kind, i), seen)...) + problems = append(problems, stepProblems(c, fmt.Sprintf("%s.%s[%d]", where, kind, i), seen, s.Random != nil)...) } return problems } - problems := []string{} where = fmt.Sprintf("%s (stage %q)", where, s.Stage) p := nameProblem(s.Stage) if p != "" { @@ -135,6 +153,91 @@ func TeamProblems(members []api.TeamMember) []string { return problems } +func HasRandom(def api.WorkflowDefinition) bool { + var has func(steps []api.WorkflowStep) bool + has = func(steps []api.WorkflowStep) bool { + return slices.ContainsFunc(steps, func(s api.WorkflowStep) bool { + return s.Random != nil || (s.Order != nil && has(*s.Order)) || (s.Parallel != nil && has(*s.Parallel)) + }) + } + return has(def.Steps) +} + +func Resolve(def api.WorkflowDefinition) api.WorkflowDefinition { + var resolve func(steps []api.WorkflowStep) []api.WorkflowStep + var pick func(s api.WorkflowStep) api.WorkflowStep + pick = func(s api.WorkflowStep) api.WorkflowStep { + switch { + case s.Order != nil: + sub := resolve(*s.Order) + s.Order = &sub + case s.Parallel != nil: + sub := resolve(*s.Parallel) + s.Parallel = &sub + case s.Random != nil: + weights := []float64{} + for _, c := range *s.Random { + weights = append(weights, c.Weight) + } + sum, _ := Weights(weights) + chosen := (*s.Random)[Pick(weights, sum)] + chosen.Weight = 0 + return pick(chosen) + } + return s + } + resolve = func(steps []api.WorkflowStep) []api.WorkflowStep { + out := []api.WorkflowStep{} + for _, s := range steps { + out = append(out, pick(s)) + } + return out + } + def.Steps = resolve(def.Steps) + return def +} + +const weightSlack = 1e-6 + +func Weights(weights []float64) (float64, string) { + sum := 0.0 + for i, w := range weights { + if w < 0 || w > 1 { + return 0, fmt.Sprintf("weight %d is %g, outside 0 to 1", i+1, w) + } + sum += w + } + return sum, "" +} + +func WeightsProblem(weights []float64) string { + sum, p := Weights(weights) + if p == "" && math.Abs(sum-1) > weightSlack { + p = fmt.Sprintf("the weights add up to %g, not 1", sum) + } + return p +} + +func ChoiceWeightsProblem(weights []float64) string { + sum, p := Weights(weights) + if p == "" && sum > 1+weightSlack { + p = fmt.Sprintf("the weights add up to %g, more than 1", sum) + } + return p +} + +func Pick(weights []float64, total float64) int { + n := rand.Float64() * total + cum := 0.0 + for i, w := range weights { + cum += w + if n < cum { + return i + } + } + return -1 +} + func Ends(def api.WorkflowDefinition) []string { return build(def).ends } @@ -152,9 +255,13 @@ func (g *graph) walk(s api.WorkflowStep, before []string) []string { before = g.walk(c, before) } return before - case s.Parallel != nil: + case s.Parallel != nil || s.Random != nil: + branches := s.Parallel + if s.Random != nil { + branches = s.Random + } out := []string{} - for _, b := range *s.Parallel { + for _, b := range *branches { out = append(out, g.walk(b, before)...) } return out diff --git a/mac/Sources/Byre/WorkflowEditor.swift b/mac/Sources/Byre/WorkflowEditor.swift index cace7ae..cf39d66 100644 --- a/mac/Sources/Byre/WorkflowEditor.swift +++ b/mac/Sources/Byre/WorkflowEditor.swift @@ -9,7 +9,7 @@ typealias TeamMember = Components.Schemas.TeamMember @Observable final class StepNode: Identifiable { enum Kind { - case stage, order, parallel + case stage, order, parallel, random } let id = UUID() @@ -17,6 +17,7 @@ final class StepNode: Identifiable { var name = "" var model = "" var prompt = "" + var weight = 0.0 var agents: [TeamMember]? var children: [StepNode] = [] weak var parent: StepNode? @@ -35,6 +36,8 @@ final class StepNode: Identifiable { self.init(kind: .order, children: order.map { StepNode($0) }) } else if let parallel = step.parallel { self.init(kind: .parallel, children: parallel.map { StepNode($0) }) + } else if let random = step.random { + self.init(kind: .random, children: random.map { StepNode($0) }) } else { self.init(kind: .stage) name = step.stage ?? "" @@ -42,19 +45,27 @@ final class StepNode: Identifiable { prompt = step.prompt ?? "" agents = step.agents } + weight = step.weight ?? 0 } var step: WorkflowStep { - switch kind { + let w = parent?.kind == .random ? weight : nil + return switch kind { case .stage: - WorkflowStep(stage: name, model: agents == nil ? model : nil, prompt: prompt, agents: agents) + WorkflowStep(stage: name, model: agents == nil ? model : nil, prompt: prompt, weight: w, agents: agents) case .order: - WorkflowStep(order: children.map(\.step)) + WorkflowStep(order: children.map(\.step), weight: w) case .parallel: - WorkflowStep(parallel: children.map(\.step)) + WorkflowStep(parallel: children.map(\.step), weight: w) + case .random: + WorkflowStep(random: children.map(\.step), weight: w) } } + var odds: Double { + parent?.kind == .random ? weight : 1 + } + var index: Int { parent!.children.firstIndex { $0 === self }! } @@ -132,21 +143,27 @@ func stageDiagram(_ stages: [GraphStage]) -> String { return lines.joined(separator: "\n") } +private func percent(_ odds: Double) -> String { + (odds * 100).formatted(.number.precision(.fractionLength(0)).grouping(.never)) + "%" +} + @MainActor private func stepDiagram(_ root: StepNode) -> String { var stages: [GraphStage] = [] - func walk(_ node: StepNode, _ before: [Int]) -> [Int] { + func walk(_ node: StepNode, _ before: [Int], _ odds: Double) -> [Int] { + let odds = odds * node.odds switch node.kind { case .order: - return node.children.reduce(before) { walk($1, $0) } - case .parallel: - return node.children.flatMap { walk($0, before) } + return node.children.reduce(before) { walk($1, $0, odds) } + case .parallel, .random: + return node.children.flatMap { walk($0, before, odds) } case .stage: - stages.append(GraphStage(name: node.name, agents: node.agents, after: before)) + let name = odds < 1 ? "\(node.name) ยท \(percent(odds))" : node.name + stages.append(GraphStage(name: name, agents: node.agents, after: before)) return [stages.count - 1] } } - _ = walk(root, []) + _ = walk(root, [], 1) return stageDiagram(stages) } @@ -318,6 +335,9 @@ private struct StepRow: View { VStack(alignment: .leading, spacing: 6) { HStack(alignment: .firstTextBaseline, spacing: 6) { Text(guide).foregroundStyle(Palette.muted) + if node.parent?.kind == .random { + WeightField(node: node) + } switch node.kind { case .stage: Button { @@ -343,6 +363,9 @@ private struct StepRow: View { case .parallel: Text("in parallel").foregroundStyle(Palette.muted) Spacer() + case .random: + Text("one at random").foregroundStyle(Palette.muted) + Spacer() } actions } @@ -386,11 +409,12 @@ private struct StepRow: View { Button("Add stage after") { addAfter() } Button("Run in parallel with a new stage") { wrap(.parallel) } Button("Group with a new stage in order") { wrap(.order) } - case .order, .parallel: + Button("Pick at random between it and a new stage") { wrap(.random) } + case .order, .parallel, .random: Button("Add stage inside") { node.insert(stage(), at: node.children.count) } Button("Add stage after") { addAfter() } - Button(node.kind == .order ? "Change to in parallel" : "Change to in order") { - node.kind = node.kind == .order ? .parallel : .order + ForEach(groupKinds.filter { $0.0 != node.kind }, id: \.1) { kind, label in + Button("Change to \(label)") { node.kind = kind } } Button("Ungroup") { ungroup() } } @@ -416,6 +440,8 @@ private struct StepRow: View { .fixedSize() } + private let groupKinds: [(StepNode.Kind, String)] = [(.order, "in order"), (.parallel, "in parallel"), (.random, "one at random")] + private func stage() -> StepNode { newStage(root, store.defaultModel) } @@ -429,8 +455,14 @@ private struct StepRow: View { let i = node.index node.detach() let group = StepNode(kind: kind) + let added = stage() + group.weight = node.weight + if kind == .random { + node.weight = 0.5 + added.weight = 0.5 + } group.insert(node, at: 0) - group.insert(stage(), at: 1) + group.insert(added, at: 1) parent.insert(group, at: i) } @@ -477,6 +509,23 @@ private struct StepRow: View { } } +private struct WeightField: View { + @Bindable var node: StepNode + + var body: some View { + HStack(spacing: 4) { + TextField("weight", value: $node.weight, format: .number) + .textFieldStyle(.plain) + .multilineTextAlignment(.trailing) + .frame(width: 36) + .padding(.horizontal, 4) + .background(Palette.raised, in: RoundedRectangle(cornerRadius: 4)) + .overlay(RoundedRectangle(cornerRadius: 4).stroke(Palette.border)) + } + .help("Weight: its chance of being picked, from 0 to 1. The weights in one random add up to 1.") + } +} + struct ModelPicker: View { @Binding var model: String