diff --git a/doc/openapi.yaml b/doc/openapi.yaml index 4a509eb..6a1dff1 100644 --- a/doc/openapi.yaml +++ b/doc/openapi.yaml @@ -2630,6 +2630,20 @@ paths: minimum: 0 maximum: 1 default: 0.4 + - name: timings + in: query + required: false + description: | + Attach a per-phase breakdown of where the query spent its + time (see WorkspaceSearchTimings). Diagnostic, not API + surface: it exists so a slow workspace query can be taken + apart, and it is off unless asked for. The server logs the + same breakdown by itself whenever a query is slow, so + catching a regression does not depend on someone having + passed this flag at the right moment. + schema: + type: boolean + default: false responses: "200": description: Search results @@ -6531,6 +6545,93 @@ components: under the new schema. items: $ref: "#/components/schemas/WorkspaceSearchStaleFTSRepo" + timings: + $ref: "#/components/schemas/WorkspaceSearchTimings" + + WorkspaceSearchTimings: + type: object + description: | + Where this query spent its time, in milliseconds. Returned only + when the request passes `timings=true` AND the query actually ran + a search — a workspace with no queryable project reports nothing + rather than a block of zeroes that would read as "instant". + + The fan-out phases report a sum AND a max, and both are needed: the + sum is how much work the query did across every project, the max is + how long it waited for the slowest one. With perfect parallelism the + wall time is the max; with none it is the sum; in practice it is + between them, and one number alone cannot say which. + + `projects_scanned` versus `projects_returned` is the ratio that says + how much of the work was discarded: the fan-out runs dense and BM25 + over every project in the workspace and then thresholds the answer + down to the relevant ones. `projects_in_panel` is a separate, + smaller question — how many of those the caller was actually shown, + after the `top_projects` cap. + + The named phases do not sum to `wall_ms`. The remainder is the + workspace visibility check, assembling the projects panel, the + round-robin interleave and writing the response — all in memory and, + on the load-test fixture, ~19 ms of ~9,900 ms. + properties: + wall_ms: + type: integer + description: The whole handler, from its first line to its last. + embed_ms: + type: integer + description: Round-trip to the embedding provider for the query text. + resolve_ms: + type: integer + description: | + Loading the workspace's project memberships and applying the + per-user access filter. Separate from the rest because it is the + one pre-fan-out step that grows with how many projects the + caller can see, rather than with the workspace. + stale_fts_ms: + type: integer + description: The pre-fan-out probe for repos with no BM25 mirror. + fanout_ms: + type: integer + description: Wall time of the parallel per-project phase. + dense_sum_ms: + type: integer + description: | + Vector-store search summed across projects, including hydration + of each project's winning rows, and including projects whose + query failed — the time was spent either way, and omitting it + would put the sums permanently below the wall time they explain. + dense_max_ms: + type: integer + description: | + The slowest single project's dense search. May belong to a + project whose query failed; the fan-out logs a warning of its + own for those. + bm25_sum_ms: + type: integer + description: | + FTS5/BM25 search summed across projects, on the same terms as + dense_sum_ms. + bm25_max_ms: + type: integer + description: The slowest single project's BM25 search. + fuse_ms: + type: integer + description: Normalisation, candidacy blending and thresholding. + projects_scanned: + type: integer + description: Projects the fan-out searched. + projects_returned: + type: integer + description: | + Projects that survived the relevance threshold — NOT the number + the caller was shown. Capping this at `top_projects` would peg + the scanned:returned ratio to a request parameter instead of + measuring how much of the fan-out's work was discarded. + projects_in_panel: + type: integer + description: | + Projects present in the response's `projects` array, i.e. + `min(projects_returned, top_projects)`. WorkspaceSearchPendingRepo: type: object diff --git a/server/internal/httpapi/openapi/openapi.gen.go b/server/internal/httpapi/openapi/openapi.gen.go index 0767a36..9335610 100644 --- a/server/internal/httpapi/openapi/openapi.gen.go +++ b/server/internal/httpapi/openapi/openapi.gen.go @@ -3272,6 +3272,30 @@ type WorkspaceSearchResponse struct { // no chunks returned but at least one repo errored out during // the fan-out (see `failed_repos`). Status WorkspaceSearchResponseStatus `json:"status"` + + // Timings Where this query spent its time, in milliseconds. Returned only + // when the request passes `timings=true` AND the query actually ran + // a search — a workspace with no queryable project reports nothing + // rather than a block of zeroes that would read as "instant". + // + // The fan-out phases report a sum AND a max, and both are needed: the + // sum is how much work the query did across every project, the max is + // how long it waited for the slowest one. With perfect parallelism the + // wall time is the max; with none it is the sum; in practice it is + // between them, and one number alone cannot say which. + // + // `projects_scanned` versus `projects_returned` is the ratio that says + // how much of the work was discarded: the fan-out runs dense and BM25 + // over every project in the workspace and then thresholds the answer + // down to the relevant ones. `projects_in_panel` is a separate, + // smaller question — how many of those the caller was actually shown, + // after the `top_projects` cap. + // + // The named phases do not sum to `wall_ms`. The remainder is the + // workspace visibility check, assembling the projects panel, the + // round-robin interleave and writing the response — all in memory and, + // on the load-test fixture, ~19 ms of ~9,900 ms. + Timings *WorkspaceSearchTimings `json:"timings,omitempty"` } // WorkspaceSearchResponseStatus `ok` — results follow. `empty` — workspace queried fine but @@ -3285,6 +3309,82 @@ type WorkspaceSearchStaleFTSRepo struct { ProjectPath string `json:"project_path"` } +// WorkspaceSearchTimings Where this query spent its time, in milliseconds. Returned only +// when the request passes `timings=true` AND the query actually ran +// a search — a workspace with no queryable project reports nothing +// rather than a block of zeroes that would read as "instant". +// +// The fan-out phases report a sum AND a max, and both are needed: the +// sum is how much work the query did across every project, the max is +// how long it waited for the slowest one. With perfect parallelism the +// wall time is the max; with none it is the sum; in practice it is +// between them, and one number alone cannot say which. +// +// `projects_scanned` versus `projects_returned` is the ratio that says +// how much of the work was discarded: the fan-out runs dense and BM25 +// over every project in the workspace and then thresholds the answer +// down to the relevant ones. `projects_in_panel` is a separate, +// smaller question — how many of those the caller was actually shown, +// after the `top_projects` cap. +// +// The named phases do not sum to `wall_ms`. The remainder is the +// workspace visibility check, assembling the projects panel, the +// round-robin interleave and writing the response — all in memory and, +// on the load-test fixture, ~19 ms of ~9,900 ms. +type WorkspaceSearchTimings struct { + // Bm25MaxMs The slowest single project's BM25 search. + Bm25MaxMs *int `json:"bm25_max_ms,omitempty"` + + // Bm25SumMs FTS5/BM25 search summed across projects, on the same terms as + // dense_sum_ms. + Bm25SumMs *int `json:"bm25_sum_ms,omitempty"` + + // DenseMaxMs The slowest single project's dense search. May belong to a + // project whose query failed; the fan-out logs a warning of its + // own for those. + DenseMaxMs *int `json:"dense_max_ms,omitempty"` + + // DenseSumMs Vector-store search summed across projects, including hydration + // of each project's winning rows, and including projects whose + // query failed — the time was spent either way, and omitting it + // would put the sums permanently below the wall time they explain. + DenseSumMs *int `json:"dense_sum_ms,omitempty"` + + // EmbedMs Round-trip to the embedding provider for the query text. + EmbedMs *int `json:"embed_ms,omitempty"` + + // FanoutMs Wall time of the parallel per-project phase. + FanoutMs *int `json:"fanout_ms,omitempty"` + + // FuseMs Normalisation, candidacy blending and thresholding. + FuseMs *int `json:"fuse_ms,omitempty"` + + // ProjectsInPanel Projects present in the response's `projects` array, i.e. + // `min(projects_returned, top_projects)`. + ProjectsInPanel *int `json:"projects_in_panel,omitempty"` + + // ProjectsReturned Projects that survived the relevance threshold — NOT the number + // the caller was shown. Capping this at `top_projects` would peg + // the scanned:returned ratio to a request parameter instead of + // measuring how much of the fan-out's work was discarded. + ProjectsReturned *int `json:"projects_returned,omitempty"` + + // ProjectsScanned Projects the fan-out searched. + ProjectsScanned *int `json:"projects_scanned,omitempty"` + + // ResolveMs Loading the workspace's project memberships and applying the + // per-user access filter. Separate from the rest because it is the + // one pre-fan-out step that grows with how many projects the + // caller can see, rather than with the workspace. + ResolveMs *int `json:"resolve_ms,omitempty"` + + // StaleFtsMs The pre-fan-out probe for repos with no BM25 mirror. + StaleFtsMs *int `json:"stale_fts_ms,omitempty"` + + // WallMs The whole handler, from its first line to its last. + WallMs *int `json:"wall_ms,omitempty"` +} + // ProjectHash defines model for ProjectHash. type ProjectHash = string @@ -3416,6 +3516,15 @@ type WorkspaceSearchParams struct { // recall (e.g. "authentication and authorization" across a // mixed-domain workspace). MinScore *float32 `form:"min_score,omitempty" json:"min_score,omitempty"` + + // Timings Attach a per-phase breakdown of where the query spent its + // time (see WorkspaceSearchTimings). Diagnostic, not API + // surface: it exists so a slow workspace query can be taken + // apart, and it is off unless asked for. The server logs the + // same breakdown by itself whenever a query is slow, so + // catching a regression does not depend on someone having + // passed this flag at the right moment. + Timings *bool `form:"timings,omitempty" json:"timings,omitempty"` } // SetAutoVacuumModeJSONRequestBody defines body for SetAutoVacuumMode for application/json ContentType. @@ -7454,6 +7563,19 @@ func (siw *ServerInterfaceWrapper) WorkspaceSearch(w http.ResponseWriter, r *htt return } + // ------------- Optional query parameter "timings" ------------- + + err = runtime.BindQueryParameterWithOptions("form", true, false, "timings", r.URL.Query(), ¶ms.Timings, runtime.BindQueryParameterOptions{Type: "boolean", Format: ""}) + if err != nil { + var requiredError *runtime.RequiredParameterError + if errors.As(err, &requiredError) { + siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "timings"}) + } else { + siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "timings", Err: err}) + } + return + } + handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { siw.Handler.WorkspaceSearch(w, r, id, params) })) @@ -8047,695 +8169,718 @@ func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handl // 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{ - "7P3dkts4tieKvwr+mvmHM92S0nZV93Sno+JMOm1X5W5/5GTa3b2jWSNCJCShkgLYAJhKdYUn5mo/wI4d", - "cZ5jnuHcz0PsJzmx1gJAUiL1Ybtq9zlxrqqcIglgYWFhff7Wz4NML0uthHJ2cP7zoOSGL4UTBv91bfRP", - "InM/cLuAf+bCZkaWTmo1OB+8lsY69vR3bCEeWLbgxjI9Y+ntDxdPTxbauknJ3eI0HbNbIRKVSuWEUbw4", - "K+mjdgyfveZukY4TNRgOJHwU3hkMB4ovRf0vI/5WSSPywbkzlRgObLYQSw4zEg98WRbw6G+n/yV/lv1B", - "POXfzH7/5NtngyG8DUMOzgf//a98NHsy+sOPPz/93af/PBgO3LqEl6wzUs0Hnz59gkFsqZUVuPAXPL8R", - "f6uEdfCvTCsnFP4vL8tCZhxIcPaTBTr83JjOfzZiNjgf/Kezmqhn9Ks9e2WMNjRUm45X6p4XMmeGBmQn", - "S2mtVHM2k6LI7ZBV6k7plWJ3UuVDNuU5y7Sayfnp4NNwcKnVrJDZrzDPG2F1ZTLBeGEEz9dMPEjrLDsR", - "4/mYiSWXBXP8Tiic12ttpjLPhfrlJ3ZRuYVQDr4qgECVYwXP7ixzC8EC7zCjCwETu1K5eBDmo+L3XBZ8", - "Ctzzy29xLh5gS60w9zITTGnnN7ECvsZp2Wo2k5kUyt06bfj8V5jXO+2YULqaL9jMCMFsyTPBnGYLXeRI", - "Pvgaz5wAnivXjBdaza3MBfyYKG3kXCpejFn6kjs+5VbcOu7EOFB9kkt7N5munbAp4ypnKYzT/GuiMm7M", - "GgdT1XIqjAVxgBQhgUGz/8Vp8VEtuMoLkeMmCcMEPTkEKr3Wlcp/xSMG/DHDMT8N41/tr8qz9XHPMl0p", - "B+wrLc5shQdKK+YW0gZynSjtWZpJRexBBDUsF6VQuVCZFJb9+//8N7bgZSmUhQdLbpzkxciB6MMVPTh7", - "6lngo+KVW2gj/y5+Beq/9XJXGya9TL64vmJ3Yk1zKY3OhLW/Dvnf8mKmzVLU98JU52uYW7geomSjewLm", - "+Gdt7vAM25cS5/mr8KyfRpBtnklq8bbFKZleLrUq1oyrRAmVmTV+bHQn1myqgfW5LCojWGnEvSDWm0u3", - "qKYTp++AcWZGLxO1knB9D4EovM1IL0WJ3KW0GpVG51UGA7T463IhsjsUO35ahZ5blFFGWMeNQx78FLQN", - "VAsuMifvxavlVOS5VPNro+9lLlA4lUaXwjhJ+gMtHime5xLG5sV14wnSY9qEvBbGSguitvTfDedpWujp", - "mN0ueCnYPTdwiqZrVAeeA4cm6k6sLeNGsHfvPzDrNBAdzhkSWaj70T03DHQqfIrULa8C6SkoY8A8Mt/W", - "8dKwxPHVy5PTlM2kmgtTGqnckOG9n97rNZ+Lc/rPKNO5GH1z/vTJs2/PZ4XmDpS7t9xlC2FZKgLlJkud", - "iyIFzjizjrvKtiYV9LLhABaJip6qloPzvw50UfAlHwwHuhSKy8FwQAMPftxW6pqK41/pS7jKHzsWf5Hn", - "30t3I0rd0Pvaezo1XGWoBy+leiPU3C0G50875uxZtTLFNkEXzpX2/OyMnhlnenmmV0qYMyNKzT7evBl3", - "UaHURTFBBfqeFxMrMq1yu/3x9yVxGiuFGeEH4UWWcZC9As6Df5WdPDnTS+mA2f79X/41nIBczHhVuNPG", - "HGDQuTBhErB1QkXJ0h7+Ff7A/HPMrlU2Zl48WLYS04XWd7jz3z3KvXx6lKgT/wv7y/ub8PLpc6bdQpiV", - "tCKqcXCwpWVGwKaJnH377FmLa6ZaF4LjxYFiYtLF0ZFGMgdzhYfj8r10P1RTdn3xgZ3UklUbVhp5zx3M", - "oNT2tHN7mkujEZGOg/PBkquKF4Nh5N/4B145PRgOAh3282+Dq4aBF/s42eiqfAuHzfRyc2WF8QTaPW54", - "sHOsUv5RrDvEnxGgi084Dgz3GPzfIOdOjJxcii4ids5lOCi4dZPK7v6YqgqvFZFg3fEVWcJXjnih4ge9", - "QBZrxwLweE/6yT0clEbM5MM2q76Utiz4eoRSnB4CloXjMKuKAhQTb3ylmXyY8KfTZ9k3+bcp3G5vtJoH", - "1d5pZkSm5woOk1SsALNtyOxCm6j+uwV3TDrQxhXc3vCCss5UmcMBo6bfLaaNuNd3orm8xmH0P37BBm6w", - "pARB3qar34BIzGGTB+v59TPxJT2+zcu8lJM7YvJd+pE/Cp+GA9ib8EZ7Qz8sBCsLLlEJwe2750Ulxuzx", - "4xvhKqNEzsQDz1yxZlplYvz4MQNbUODOWJFVRhRrvNlBOHpVi634mvbYGSnu4WFWcCdM515tkDKsrjHt", - "fhq9kdbdeDdJL6Hw/6UTS3s4yfx43BhO/9aOFw1mirdQ9+ztILzSOffK6T/xrKqWvcIwCO4gpZVWAj1S", - "mRFLodpf7qEkfqNr/BdaO+sML29R0eknoBIit5NpeLyDf0wl2Goh0LxiwPqWObxzpWViWbr1uOM23Jjn", - "5ihdU75ccDUX19zalTZ5L9myyhih3KT0Dx6gGymxaj2+aYEpuayW7PfoT+SZE8aO2TvNqrIUhk3BIoYl", - "Ngb5/b592ZrkxiQ61w+Uu+ROzLVZ3wiLl/nm6nNRCBAwaB37pcPsB+dPutQnsGmOe7oy4vDDhFN+X7lM", - "L0XXkaK7Z9cXbkRWcLkMy77KSXbjH0VO7pqWAJfK/e5b2o0dK7F3sixJsH6Vhfjv1YTcNEdHaLqjjcu4", - "Y7RNDC4aZrnMQTyuOArOQoM1wyyfifGedXTdQG0G2JzZxo5vk7KX8cLitzjOXyodty/3tvweEwgFvX+6", - "d/je484VL9ZW2j49JiPOkUdwbSfPLaW6opefbm7/pvxvzKg1/o7FdR/mz5h7l5Do4Ne8MsiLE/rinmMv", - "lbSLIzXnr3BGHTfH6esbG9H4QHsR7fVvz3X/rqFeRqpCL2cG5bstCn6ollyNZkYKlRdrVvCpKEDrXSnv", - "oWQ5t4up5iYfsw8NrTpRqJfBrToXShhQDL2NPELnN3mJujQ2VLl23oGb1zFMvX/h36PV9wHM2V9w9fvm", - "PBzYTJfh2iuNyEhX7nJjXc0VGNREUe9YUHrFcmHkvQDznReMPoduPG95P7KJ+svo/UXlFqNb+jVE5NhC", - "8Byu/zXLOPkWvn/1gZ2BAsRW0i3I22yrsiykyBka/0NmNapIo/h3HJQtpHLkLIs3QKLA2KkKB9P+oygd", - "Gv5Tnt2tuMktBUGcnMpCujWNqIsc3yskyAQyn6yTRcGsUHDH+JhmECRbBN1Wee8oVrbLZLi++NCiq/ed", - "WrzTYFoXr25H31++ZVMx00YkqiSfolTz5+SClRQVQ5Oy5VjGFQj4aMYNnMZEudbYZKp8Hn+H5e3gc6Or", - "spfDWzT5ud/4/ooHz4e+e6cUI9zde4ZcPpOFsGvrxJLBk2wqyG8/l9YJI3J2MhVw01uWk6lPIfNOH9OS", - "ZwupRKdP61qYkf+dffx49ZJFlp9SYO3yzRU7wcP2P87GmXw4q792OmZ/XgiVqNIIKxRZ+z5ED9zy5v3l", - "xRsUeBL4LBfKwSEA4xWsT74UGHDIE1XojBfnP9ef/nT+c6TSJziO6GznS0HU0IrlcjYToJ0nyr9mz8is", - "ybUIYYSikLkYs/dLSedSPFBckDxyPQ6JMAsUe9sU03b8g7YOpn9yGpwqMkRpAy3B0PY7gydmvPcerLmi", - "n7M+2h1uOQyjty5h+kuXw0xJJ3mxw5x6r+j6ZuERirKKFQpGtqysA0NLzUEgsBnmcxR6LtU4UcDEPF9K", - "xeyCG2FJfOjKjfRsNOUq3xIFv+9STXTRMqzxi4MhOhX3m9Rh6Vsr9R/up3EMhB0qUnqcxDMjxAi2gjUe", - "6DyfX1UEtYLpHYp45fTkHl0aXQYQz1kh7wXdrnTR0+dQIA2ZQjGPv3rntxUO7ggLl2aiJB78TBsDMgCs", - "KLUON44Rc27yQlhM9lnoFVw9c+3YQoTA0g4nCnmZOjZ+OJgWOrsT+aS2ZdrL+vNiHZIRMJJHbkrUO5mR", - "84VDJQNOLAcFZzQr8I9ZoZVg2iQKTzf7SU+HTDZyLeCA31EIUTEgsjccfY6LqZSSaj5O1DtQDtH5Ih0M", - "z2KQ8AD/s7BOLtEd2Ru8eRUeoUwLOLdDJh6yospBJlEQhMZkL1GXyuMOJypusZV/J/2Us6XgFuOvbmF0", - "NV+UlWMUkkXliLaZq0RpkwsD53rJ50q6KhdsXoGea7hbCAO6gWIcboWltLUOsNOOKcRnWyMbKSKf+YVC", - "oiiedxz3wTX8mVQeUAR5AXcXkH5aOcp9URpPDRz1I8eOPIQntSjezwbnf91tSb5FHUtxlYn38e1PPw67", - "9AriR8wD0Bb99MDEcdAhkzM4r+Mtrvw0HAA1ar/JkevCl4G79luxQS3qs1RhUvXebkSc23uXsv/r/2Rp", - "HDvFE77i1oEc0464EsQmHNoQHJEguuHxz9i+5hRLYTKfOLHkD/TS0ydPOj9BuUuDhoTfYOENKa31kvGm", - "REO/7LlPuipRu1oZ6ZxQfVlXeIqn2i0oE49x17BBj1z2vTC5zyKMofY7stf1cilULuDWrcwc6NElv/0H", - "euX3ewVWC7B5Jph4QLsiyDX/7hA9cRTKUGDwcTuStjviyos+yt6CAPSckI5WvEgZkC7jZszecEO6Duiy", - "aAnbmoumhVgCe8ULcCGyu1IDkXIGV+6SOwkGKEVgQFTQg7hlC8FLMKbcQqp5oijmBpwU7wwa6zN2Z0Nr", - "8EmxDRHbpEfzoLZO/JZU7DqO3fw/bGkcNbNs7fq27O4+Dl0XYqceJGao+2l0CHZoyyqfFFKJrlCRp1Cv", - "LAqZJR2hXzWvfPrl9o+9o/UGgEuO8Yfe362cK+4qI/Y7cL0x7VNZ6vX5eQ1rgjSWsZuwvQry51JPLqVr", - "JUE8fbLX/bheTnVxrPbs39q3vL5om0GP7eHu3g1e3BW1POIwh1nsCmC+lOaVcmbds0cHRpR6tnKHcKEP", - "98xIZE4bjAjDZ7bNK2m6HSMFpbjl4QvsBMz4kREFd/JePKc4JvuOGa1dtytEKHeUo/6DEYII2LVpplJZ", - "iPzvCrfCqGCCVIriRxkvS5EfEHAFUtSTbo7YTVp799F68bMh7TDfvjvHYmYnKHr7NeYO+WgnyHRHvSRb", - "6Xj2b4V0IG2yhdGYl4dOmcFwMJ9Xs05FIXpkugQlmPm7NgIzcnC6rAIVAbfDsqnIeAXGj17SRklhwcqL", - "KpMzQrCVMIJVCgw7DJqDleRjdmN2MUXv11JwRTe6rZZM2kQBQxXCib5Us14RWc91t5ICc4vjRwNTV2iF", - "ODYVbMWLO5EP2WohswW7E6K0iUoG9VKSAZixcBIraRe4ODQNkwGepmRAXuPb//ZGOs/JYBCDbSlotaAo", - "IUFGdrEMCpPtUVYOCY7SNg+DQPG828XxW+m0V2qmO4Kfn58J2qwYOjwf9xKTb2/xTcYt+6fb9+/IJYiP", - "TT3l0DtEKdjEazF7l2eZKJ0NmbvSsvRnevCc/fVnuMuHFJYZUmlPogIVhyEVc8hgucOm9+nTj5/SMfuB", - "mzzTucjZjeCZSxRMwzKJwRf01T1n0j2yoGpr61MZo+fUaV2QV6MrEdiKzAg3Eeq+y03RyiZGp2BcMLCj", - "xZEyI9BTzAs7pMgET9Ss4HPmBEVwVguBvgXBswVq25SmUayZFY4yxkOYY5yoj7Z2ZsewVcNSgL/7vHjK", - "IudKCZMoioMwy+/FRkBmZ677JkfeIkVeqfvtG6Q7y9jzW5uWBzE/3KjbzB9IfPil132q9k2/HuegydZ0", - "OTAo2eSekLt4efWXyZ/e//PF968mF9dXkz+++ue0+963wu2/pO8ZfB+5kuIZJyDVlFYjFIWnG6x1QL4U", - "6dwweCdNQnXSpnvZeUf+bn3LP9f15deyEJd16cZWgUH4oUM/qq2iNrHecOsY/FRHr0+ejqYcThdeB1be", - "i5707932QNNo2shiFY7StcMj6GxVVVEwOcNbnH4fH+JHRf9nz+KoHvUzV0eKELzcIfM+wI/0ZdL/oqOp", - "EBTGsnc9nz1Eu9SVK6umUgmSzvvbwY4/w5HRsLIHMGzTLGzQq2UcNpfbnOUwMlYfR/pAbXcWzVRYN7GZ", - "Jls26g1YCDLocJUdzlMdAT6sKTlYHsLcsQ5lrwxs0q+xoHrIPtLQ57eP6qJSdxN6oytr6sCT3OFxEGBK", - "TRbyCCv2Hb7zg+xMVTpi59oHsc+k73N6dGUPdXBpIE2Y2bBJy75duObrQvN8p8jcqPz88Hr0e+bEgxuz", - "F1Jxs6bIPbOLphZuqymVzHReTv7rk0VnrfztDxejZ7+lUvlczoVFGZL6l9LOL+5k/95Dc4iHvtvmr6nd", - "Wov/ZB+5bwTvTxAWKt9xCQ3ZlnRuhvkVFujATrSSM5/2XU5dodCGZ8EnHTQkN6qP/KDsJ2DQXTfO7qVQ", - "lPLAxXRIox3EBznc7Rv9B7ivdwjWnd5JWNqt4CZb9HLWtpvx2V43498qYTqqMm6rKU2YkYDPGZ9zqaxj", - "aZxxOj4y7YnG2re4r+Wb3OCFX9E3+VqbTNw6XfYvJuMqE0WxWwfiinEsrmUSK3YzYS0l5DArrJVaoX6E", - "NfGMqxwLleizY/aaF9Z/R2kMwODDMZ/nBI78T3o6+lslKpGoDPSmqvQJe4YrNOutECz9SU/tBH43IsdC", - "qk6fT/Op7VVdBh2xFAqspbMQtMVkhAkWZv6GZkf/gM9hNDpR6KPyieV1AgfOG0UJGtzwUmtqTTcvhUP3", - "cYxPb9uuloibtbHKrs33FbMdFMCsi9+Emk+2FI7n3HFcAle1I+JkLt0IyZKfhkjuOFGvfErt0/OnMcGT", - "TieQMQDIMKNXzxmmndV/W/B7kSilmZ8cPES06sih8fPruKPEnGdrxgvJyaGRNms82XffsQS/kAzScSeH", - "1MXC25rCZxRHtkuKu6sVRbBEDytutIsDCxvFg5tgATLvuAIvplYXVaiviNyJwU7x4Fju+ZZjZe+YxSya", - "RIU6YYnpj1gFO2ZvQ85K5H2vB8D/wry9UDCV2nBOHlUPCjK9R1V7+rsRaGm3P1w8bRRdev7Cy2CIbmgm", - "Fft488Z+ScH29Z46bU+v7RLtRJ1cXv1l8vLV64uPbz5Mrt+/eTO5evfh1c2fLt6cjtlFseJry7KCL8Gc", - "rErQdVDvKbQ2/uW3V+82X9yVzHRMJfif0R8Db5OvZQEihBYJAiivCmHYTBAqQM00mGqWqEA3ktu8QFmB", - "d4PTQaTQqVRajShJ0VdnJ+pt5SqM0WPqFChiJEFa5/f/9x2rK9B7HfuNLe8oVfOYBhHNKqZ+4mWScaWV", - "zHiRqGTQWez/X0lEJANGbNOTyNqsZN/L1lWZHy1aNovXv7xSvUW45lkbdhaxD9uyeGNGG4W8jRXuuJH6", - "i3lhpJCAPVHa9RZOxCgRpTZ4LaX5OogAy2age3TKgI2Hd2k/LeYE1eURvPyIXbx72XBWJspWGShGs6rA", - "9P04D3gGL1pkdSqo6GPruXSodezTEMLl/hk6Rb2F5P7uoPHbi0tGP7aqnzXIP60Y7Tn7Df3hXvJERdy4", - "s5+BmT6d+TFGUs30+PHj7uMTJtIJxnFdTQuZFWvY7IzCZtfvbz/AlYN5P2QhEpVBKnuMCLq+co16ptdw", - "rHBVyejMFOtDKq8DURs70p7uFhV7GH5RTS+ynmrIizBnD+KEnHJ98YESWIWguCBmg+tVzMeCB6RNVHSj", - "Ymr4kM10UegV+SfFvTBrps0cw1zWSqDeveRUlnOmzdz6LPIYr3lkGc9zuvBmhV5hNRIGzQiXgLNbUYjM", - "xeoVynkttZWYKVDK7E6YUEhAKY/a4FJyA5q8VE4zzmwpMjmTWaJgemDJCY46hBHFGpMnKQTAZzNZSEyb", - "tCM+nxsxxyTQeym6VcZ77rjpV8L0XHYkvvkNwF/ZCZIaox/aIPVsUc27wx3BY9j+XIK588nAWwO0WXir", - "PGfJQJu5/0mbOVfS0uraidmYfD+EZ/fLclqUf6qfAbvNgIvm7t1L4hHaIso7v774MN4is1dxJrUK3VVe", - "U+pHNmhDjB59vhEeLI0YzWRRUJzWX7dKKnS2k1UhbbueHnnMMk76SNRBC2ldz/28rzQJYRW6g2GkC4QC", - "qc0XF25Z9PKaB6XpygXZdLrE8YeblK0/0xitf48/hAq1f3Csl/5Eu0YNY3MfXgjrRmI208b5GkHcb3Z9", - "85QYFZiEO6yawFxPLPoLRVb2eaIQbgPEi+AWdEJdVvAnYrBm2aIvdfS1i+GeSVQ0cut6O1T8jqsi7MrD", - "COFLWntLm9qz1bvRPgiI7WAPVZOFvgDww4+6yyOFAaqvw6Y7a4Red5YGsVeYvuYdiqQ0YmbP+Ihz0MvB", - "x+v3O1iiuZwjtWwg8VW+m0Hm8NBE5m0eOY6D62/0TuOASRzBpcg7X8Cffry9/EngXB32SZ4fyaNHFAwe", - "WYw3PB4jbBgHx7GG9Xr2UGL3Li7xmSO30ZP4CzYzDLtrN38QvHA7Pfnd5RC3mORUrElEpISBmGKOWKUW", - "+NF1d1iQHt0q1Ihv7dfp/Be6loNAxS/EXO7IC6+KohV4QQt42O8BWslSWCpRaXhvGcxCeFUflPlofXh/", - "f0+mw84p9+5CpfpAS0gTRf9EPIIdCYI/77kdBm95SfoihhbJD/Qv/8pC4FfP6gy3kdd+fZjV3xmJippo", - "INGCW1+sORVCkedT5OxEG5bCNqAGlKLDoOTWivy0M6NvM6xDxNhcei87XGJI4MD4zh5ttH62d7jXshB2", - "Z1XCcXGxkA+AOSMPHljmt0+2xULNJMcE+iI1aWb7ltVLxEWl7uwkqx1X+wss7YQyTA9/3gfWRD75nHjg", - "xpjDzUn3jbKDJkraxY4SbcJXgsN0lBZx8F6GRCiady5tpu+Dr+6YQCmNtnedX3fzI5n3v7B9Z4Ss9vzg", - "62J72C0G6CXAtdFzI6x9dd+ZgPNeCYZAzwGZ5t1LTLa2zgi+ZMIj1U7XLEX/3BlKwjOcT+rdcU3DTKjc", - "svQCGfWcNTGvH0Yq/8lqlZLjK8VRU0rfThQwgJFLqbjzyd333EiunEejDWne3Iho4+WMW7T87rlyXV6j", - "KXfZIhbObu8N0XDXb03G2H4GMZU9uNQB9RsibEHgBMxx8PhNsfIHxq3/SbDN9b9zquyn3zDqOBwsBDdu", - "KtB8oCX7p+iBLvVyxtt6WLOcBT6Nu9xf2tcWf0eIvO1Hl8LaozOtdigVzn6mfUa7s/cchQqJDXe2/5WV", - "dOURj1NaxShkUXiODig/3o+LjP2cTtFCgmIgM16MZrwopjy7i2+hyhpeTTconA4T5f+GtE6H1PKhzcVp", - "1yE5VgIGUMeoDmwoY43SeErlI+gdr0ENmRIrYR35tZ/7+Og3Y/ZGOMs4+3iVKLvQKw+joc2Km5wtNdZp", - "5xWa9hxD0N7c16HhQT/pjsWDEgUvbRsvouYnXU0L0ZdQe8xF9hl3SWODDyg6XHDbsjlhU+Q9rHm48w7a", - "cbw+7Tsd/Rdt6Z/YpzduH7bWJbqBWCDzwgMTKB2zlVBtP2ORDaq6d8cYuyFRblLqU4/oJTqr8HukTXqW", - "RqU5PUsJUzI9S31OEb1fcOtGpkJMEld5XLXUZxhVyqbtAABMGJFZaA6trRi2UoBouAHuBgz3RcblP+lp", - "h8fDObEs3QHYiHGOX+Qd/jw/YF6VImA67x1il3f78CSdJX+YHE6css56PrzC7YavqKrNv028iMVq1LLF", - "gmRLYbR0zG4aoAxMepUrRlues1yrR45xa6ulYAQdXvU2mwhpIMdtxAE4lYeUkGzowj5Nr8Hl7QPhD8GP", - "O2J0B3hd8ZFhrU3Hvd3Y6g3a7PXY/5Oe7vae/aSnh1vMcEa/wGWGY+3yl72R6m4ftF7IH+nOzwKdxudo", - "pTG1JMVeDrWLJKQSNsASE2WE1cW9QLRE7HEVEnYQ3U5ZYRxp/SerAB82kfkQKzpjQsspJhTid4ObBnHU", - "ppS3hbv73SM/D59btOQP0Qb9XTuP+HeHJtMgMTopqudSvdHZ3W7ZuhGZ9b80yi7rcmlmC4mYUyupcr3q", - "rmyKfueNxEm9EmaUYSo8PvI8FuKh7ohR63UpWCrLCT7Q7eUUD6U0oOJ3QTy/vvzmm2/+QFBAwWemi1wg", - "Bg4ujCHAk66ch8KyhXYI5mbHfTmD22K8A4H9llpiXV1TWFhnd0xadifWmLvSXcZRZ6pvsnHGSwKhcgar", - "0ONHe4rJOhMCUlmmoSUANn65umbYMksrx4uRXQlRUtmaMOxkydWaNsZrCVqJRFGnr9NxY1danzy5uh7S", - "W6fxU5hkoGJ7sA0NowT9wn9rv9LgZSO+1RCERLoWM+w8AbvlIBD2cEFYH6svEIc05E55qHf52o8I7hyM", - "wd+DsbgTD9/Pso+yGEDaQ8+PtoM+G5GnesAGIlr0GW3KtsPVhkLcE+REZE9Q6YeDFTdqp4dip18gmDZ7", - "GmwAA9MEwjv1d/cs/X0TSu4ICEjKkCH0KUwppBTbSrFC8Hvv2oqIgVKNKZyQUrAhUbwsBbZzVZgJQyjB", - "IA8I+TDUwwkXkAVpgIvrq4iMxQk4g0dgNl4PGLAV0dnHHU0RbwlDt/OQKjwsX1tm9bHQkns1QMTkIPdU", - "l89sf/4zfSAKgY0S94eS6qdsA+Mj0+V6GBLhg5tmyk0nQN3+CRxuRaBDqatVmMkpc9RwWcAsV7AT1JdR", - "5MMWuCAYLmN2UWITR0Rd4InCMNdURJ0h7G6AlrRlAFLxqJX+pkMAuwizWQpDwBXhtql78SHqHaJm2LKQ", - "jvHMaGuZW+kkdGJkhZwJOPSWPE0E4usEjAj6y4IXM/hAZSklnJCvMbGQO5bL3CMMLwWCfY/Zh1AIHfLl", - "m2TwuDLeS4ZY8UQ964BRQx344TATW0Ku46Y5pCHAXiYAxWdXc4D9DLcJvuLPdo0Xh8GAgJe3T5buzLdu", - "/BhPDympzDpRHgQTcBBwY89XamdalPAbCldpRMkNOl+kZbnxSIbAQnODBWpgPzxnKZz68BgyPiyS2nmR", - "av2cpSgKJ05P7IqXKdOKIOdDh1Ru6oo373lsIcFSW21TlU7kOA7HpplSVyTwm5wOhxa4KR62KJFX3LIp", - "SnKHy6AkzUwrbEipQrAeZ1Hn3nocXmblsizWcCUYMYqFORvOpkg0NK6RLtSLpF49mL4rXpbhJ1wi/SNE", - "HII7qrHqPc7DjeYEiEozk2AcgO5KuuaYXQUgbDzH5BM3FTUR4CGulHGVKCeKgnGwJeyiQQfUpTnQqRCe", - "WighCzFzbLomsQ8ya0P42Mrcy3vRk1za9ndsVV5FwKhQ9bjgltzSF+zvwiCErWArLGIHSjMO/DGt5olq", - "IftalgyanwjXQDL4/BqrvjC5B8ihs9Wp/4gdLcYqt5gshVvornIKEVJ96xTggDLkNFB6xjPBkkGh57py", - "yYCdeL/rKQJEL+Aqk46d+K5iPrG9brf2yEZCO41XFBiYenbaZnj/UTBlfHO1Lg6tM9Paq/iTFKsR/Uiy", - "jxcFJoAgBixz2kcp2uuktFWUMckAy61giviZZBAS51fSLdAk9uVlDGXLCIzPEMhADSVRmJ2K7XPpG/Y5", - "YcFbXzKLIqyQCHcqJNYOMJ8ttZClTRR2pzuJ9yR+hF6gfgfU+OPVB3ZG3z894trsTdL7MjNk2OKuuEHd", - "LLrUZv2x+zr7XsMRxHLIJT43ZgvBywmCTHvsOg8auxQcbo5ZVXhc7ljimyhShM49Pm7mEEZAG4ExKQvK", - "iMRmgD5iDkME1cuZ0P0+UU0ltNA8x7rFXDyMmV1bPxvsZmPDv+DWWMj5ApkOYfV8IYZf1EIXuUVfSu6V", - "PJ/DRdUi/oZaBg3q/W1XvG+TIp+BR42fgMvlC78AzP5ln/B535/ffklVy8k8+9wXtdGV80Ase4IEgt9N", - "4k53aGJyvhitfC67xV4faOUhE+GRnQtnKuD7MbsI4Sy4Md9IVT2QfrDk2ftbvFGp+zR2DZBW2MCewV2K", - "0HeF8LcSzI0+QBlvtppaJ13lPHZdnPaBmITDwY6FXnqFcmuVTRxGbLvZsHfxBvUyNFHZXLMTXCsBMsKz", - "U7GQKsf2IY8sc9zeTaSa6VO8QjxSXTJQZzwZDIOt7YzgIJJDV3eMxANJ4AI/eK3xMB/NRJsNTDYPZscx", - "2T573QehOa3I5JtM2ylfdS6KHsjbLq3uh9dUr3P10neZapSPZzyDmzLCzTaQ56j+BjuRd1dgdVf+xpJ3", - "jB14MTeez6tZHyBYG53n62wUKlMB5av+ai85u3EFkTqTXrDey6u/TL7//uPryeXF5Q+vJi+vbsigAHvB", - "wskQedAc8HLHMpaItcfi19l3oErUNPJAHt2NjmC2h/tpG7yyr5rAf3nYWHUXuWqIrGOhvHbDdf3DoWvV", - "iwmT6yLHdV38u0kMo5e8pzz+ugG25GFnvRYTjU5QJEhbkLGM/hEC7hYFNXQYs3cf37yJJg52S4AL4cCm", - "K36CR5y5/Y6QTCvHpRJm17obobT4PDvRMycUE3+rEIC1Dj92y57PylNodBHb62eBhyiO2dmrDO7cNrTK", - "kPRAKuGvH4pYLloJO25EVb2S22wZlqiTumMYK4WJrbbicJZuy9BYz0OwYTYWMEqPoYxVjnatst7+Exur", - "xw4Uimx3aooYS/B8jyv4GpvyfA7Gec2HzZHojNUoAIex5fYXdqOaNk+HRz+RCH+x5G5EDge6z1Dhp9RN", - "cyYCVqt/0vs3csLNZtKdot6PXUd8I5JCOPRRTStZ5GN2pehN6oSFypyPAeTUybFtgiYDsoYZLC0ZJApp", - "RzW5hNHhjJzPsWc1ebDWKguY1ogy5PGUCz6PCXWIIVOjHpA1SR4O1NPOkPAetVsqHLsP+GBHx754pW+e", - "Al8pHmrNH9nAsN3lfBT1nwArIZZDV3gg7gs+4I/HTCJeNIKcbG07XrcFty5RJ0ac+lG8cNSKGaqi5w4r", - "ntHnkxs584YgDOVdGIlqYCeDfLH0DXQAfVR3Sq9UMmAbviH81oG8HWDdjkzXx9SoQL0v8XQf1SWRtwVc", - "jRlGwXyiTVPEnRUICzU+ZiZfvQHh3pFRrZ00avc20C6xa+pCg/obALyFsXjIT5Ag6FVAMtSYXEQMPGeJ", - "whGKhm+shrsJvk9t2Ku/fHh18+7iTY3NdeIW2oqIBx5wL2ACwpwGWYAduUBgELRPwDihnrsBpwPFEeKC", - "cMRrIJcZIQ0dyKs7MKAI2PEp4XVmC4yFzhAS6qS+tilbjvrvf7x50zjJY1LNgWkG54P//lc+mj0Z/eHH", - "n5/+7tN/7gG2xvZ7BwKs3IbH4VVswNAj1m4o4SkPGlhUveLl7WKCOImjWqhESeFFC2X3EZo8eqL4HBh2", - "pg/DbaZpflVVDDjtYJLhs92VMLF6qZEP6/l/Z3LAFxdjN4GR6stpS8dsStUGrwQCNFIK+2q4twXsppTY", - "ofjvTqoJZ/tge60BEvQ1MCrj+LuSbDbPTUdnFWyFMfGH9sjba8kfJlRFczz27tbIm5/btZ5wADY8JH6b", - "Y23EbqcgVcDVVUiHPH3Up8lYtUcSpjnQcGNNG5PeHGgXyarlkne5lVrK4ddSa/5xbhhKYWhuxUGH9Raf", - "7+2dVAvTjrrKchKcbsf0aoq9rvrkwz8ep/aJ8SiWm+K7zdY72XibiFv7uIPTYwfkHj/q8UgTzaTozj2v", - "HzjMMdX64Nbre8AjNpfZ7d+M3zz6gtqg3z7fYmOgrtneCG6tnKv3cOv2pnvu0dzfiVVA+goxFMTSJWCF", - "IfNwnAhktb9V+X4F4IZSey4UL9ZWdtw03P/SxxAZd2J+3Pn3Y17Sm51iIK8o58LXvO4+2O088gPBdoUC", - "c//I40GHt7PD7ZFRvRXHMGpH3OqdViOsmg39Su2QoeuHNyIcqK63+ocFlPvPROFpbvMGdVoEbm9NP0Va", - "jLGD8SITdCADEJCZRbzAHgRa78RopUmQN7E0sI3ZHVm/fjLrbiDnnRhQtxikH/HKLRDRo+FVHFInAKqj", - "WKwZj+M0AY896Ad2h40VVtJRkdVz7yjjVmNYnSL/rf5F2K+dovOFoML0XGSSwvyY4lQWPBP92HVYpiXv", - "RXceq0L8XG2YXJbaRvw+IwITPA9O7pk0S5ZLXug5A/61TDw4w7tpWjd/NXzZjNGWRvhuOV3lai/j75Tu", - "yQnl2ONrsSuHUUDjRI7pEIw7Z+S0Iv3JEaGsYHgKKM0tVo+0MiwWosh9Dlius2pJwASJonSO561sKyuw", - "C7CVKvO1M/iJpb6nJFKyvIdstdBWJGqmtSuNVKEbMJxjmDL5WJ2mNFxJTcjtmP1RlBEUgURkotD1YTX2", - "qy+AX2r+Rs8ty7Wgj0+N4HeUxd0KLw8TRWUxGVe5zIPDxoilvudFGA99r/gJePHi+ooZcS8RmidRl94/", - "jxcRjBXcVNIdFrQeDh5G9YaPgtt+cNHc1AZdWztE5NUzcpt9r3G/n7M7oBasZCWNoN7aTk5lId2anE6d", - "9KIEGEtgDsfRoa72POJOu0IsGuDCSQ9qK/WbIj6ljgdgCCw5glqLUCeEFR7YRgafTMd7L5Yo/zdhOi1f", - "lgUxgd/HYWhFRXJmZGUuxuyyoIylePQyFwUSuuatcOND87g8Wfo6VuA3Jq0GWtuSpL+Z6FeOtId2lm3Q", - "vMYmtkYcbt9QbWkbSLS9zAPuw6t2H0xTLria1FFTi9iu+MfQjBWjRJMYekOjBF3ZE4yRimV8xhdwVgph", - "OH3EvMv71dy9w7vfDQe+iLrzHsWoaYwXYhgwropRv8xobA0bGo82PpgS+usc0XT26/EJrKxmlD05GZ58", - "vabAkj/4Nu3bDvyyFIZNUS5oxfCpuuNdAPqvA1lSBT2nKMaJwq5ETlPeOj67WmhsGEvd4cfsBXwa4TKc", - "z23Cp4x0IlFY82gX2ji6WOoccvTqM7w2C+yzH79IRbC7ex71U6in1RzW4GAa4meo2I3m+Z/xcruPfofu", - "yfF+x9zvIB39O4zPnDCNDem6KveV+s8/e+Vbrov6U8MWSVsk2lpyN0fPhBEqE90ioZ06U8OB+Jc6ZUxv", - "xzavJFCWUejdE1Hbm3is3f3D+/pjhu+GHI20zp1J2YkRM8tIm/SwwARHO0QFyGD5wBc3z9zT8vILc4EO", - "6Q3Z6APXyhBqjLOnf1dkhZ0wfjvosdXc67d7m3vR9I6tfvVv7VnE12rT1T4iv2KXrhuBDvRXChtJ5TuQ", - "Vn0TkE2BJrMFM/QRNiv4va5M0wpdyZCW4QtJJVpGDUjLUEWKnXPS/wOe+o7QK08a3/HNpgI+jsgndsHT", - "kGAuaPpSzU89INtKWsHSRhloSpYNgcFpJUY/6ekji9rBKBdOGAR3w8pD6XPkMf0pUViEekLlDaBpe7AI", - "kAKo2XIXM+BBTUbkqBHOckgvFyPKsMF2eb6V/WjGZVGBLcKtsBt1Iliv2i5i7RKCxzff2I5xesqBWPfF", - "t5OvAehzI6xwsVB+fxX7ZnTa508RBC6izCAAbsQgeO77mef1bo+PR2qI1Q9U14Y8dkTDBWL+gHoQPuAt", - "stDBSIT5t1sGfA1EhF7Cf7TCXPuq/V7aK7GaNKEBtoAX0Z/JwiN1IwQ07ImjQYdBIxibQfiuHpTShfkW", - "PovE581NucqjxhcE8e/3rbc1z54l447GqpsNi0Pau2OiTPaOPtQhhD/P/UvOob3Zyo3KoU/DATk1JqhN", - "7Hv1T/jsLTzq39/EHm87Zv2Ehp40G4P1kBhUgosGquLWfYc6Q1dw4n3J/1YJdvXyOZtVDmTevTAWzFHv", - "uMDEkRIbnlE9eKyDr3wLf2mZzPcHLhqz6FwFSelLrWZy3qeHgnmVaeULizsKRCiLkp04I8TISgdnf8Xt", - "8hT7yXCViVF8P1uzjJdDlotMV2URqg/qDMzGk2P2imeL+BFfTfU/fvcH9la+GLMn7DtmRKaXS6q1P/nm", - "dL9bJw7Ul3PYqI/QhvG+ZEcs+q2T9PtTHAkQdEIwn3U8doOERls7wooIfHyEj/taIvSylbrRopM+gznB", - "+DhaR6dEEa2oDhJ/3eqh20mTouBLPmljr+5uIUxvUGmA4cvJUk63F4UPjby2stAWuXhZuhGVmWS8BHP7", - "rXzBTkb0t5HhS7+M4PQHS6LeYkwwDDtIGXX0TXLnUzWUEaA4kdsb5/DIsqr0+Li/Z9/LF7EXzhzTQW9u", - "bxkchGIjC/39+7f2dMhGT9l3rFKoaIu8Rc7RLuq4h6OoqSbzspoUfO3R+9vExEnAttID7OStcLw4u/z4", - "8uJ0iBS7vP4Y8x77x3ALUGk6BoBPFMKx1q7xyukRNTHez0YgJ+rj1TjH+ynQ2OO9dkFTZN003gNlDm+9", - "XcD0QcPIp6hu3A/aY/+4r7EJJsZS2Zk2ci4VVeaFPlu1tzzjKlSxcZYMXr5IBuwsUcnglbqH/2XJoDF5", - "rDsuCtIcnGYC5N49LyoxZn8Ua0vakwcEqdGV0c9nz1m6IdXSIUvbTJgO2XjcAy/Yzs3rak1QV7ROQkod", - "M3oVc63R3+WEqrtfo5pKNY3q/qx5hOGcSsXEbOaZ6vOSl8Okp+uuSWsmra2C8x9meP3xA7rpXbthqs/n", - "bLRROK5Uf/M62Tr8nad7+zjuOj0dAnrH3TLsvrW7ZXY8MnuVg5v2CT1MTzjo+j3q2jzs8jr4wjpEdh8q", - "rw+SuUdKzX0Jkf/P5r69TPcRD3mX67EI8PK6JDE/ZrcCw7QoNRHDQrgzIzCkT3Up98IYmaNC5YFFKMCL", - "GPgsTQbJIGUnvhsVff4UBFr6JGUnqloKI7P4d6cTdfnm1cVN+9snKMGx+nnGi8JGhBih7tlZU1099eEF", - "DKTSWu6EKD1IREDxoTugDwS848gdgIe1fQT3o/TuOJL7R+w6ooe+tUfHfCtfPGdPmiVR9Vbs2YCGktmp", - "5B08w4asOPSdTdlx+HsNWbL/pZ2yZd/rXXGmW4+223swKROh0foB4zqV8gV12w0sM9PTC7LRL/uQzkZh", - "ZvkHbu+6areB+aqyP/nJ454upbXoZgNbrOm15ZbleqVAEQKlx4kxe80LylMpCjAjYCmOT5mghvzPsaUT", - "w37d+BEyXxy3d5ZlmHQjlK7mCy+M7J1EOCdCBImYJYRINBVspY0VffV6mFU0rzrrI3GajRXBDNDp7OFp", - "mHQWszvcSCoQeELdS6PVUiiXKG8qDZkcizFTeqrzNWbzZAttQ/FdQGHunZ7pzAhzXOWgLM/kvfBadU3E", - "0pBSNow5PbgTjyxVoiV4T/xdKzFm6X/NuSzWKZp8MyMRjRtLo7x75jP7ke7gwU2I8m4E86UsCnlotxF8", - "w1Tqi4r68CP96PtbAGiEexbZfANqq4YaJKx8aRPldf0QaEBAHa7yAs6QykNYwsdupSNYMLWmNDDkuUQt", - "ubkTOfN+dcYRNM24qmxgN9UwYC1gNh+9b4cHaixy7O92MPRZd6/ZW4pb1hUEQwrFcLph0P9TcsOXwglD", - "6C2Vo4RDI9AkS5RHiUSHhFyWBUYtbDx/PQwJ2gM2IeiGmEDlYiZWKISGscS/mXfEpms/SWOpLhU7dwjE", - "UhPLgEARY01BGISrcANb6sB03u2OUrgdfaXaTUn0yEb2kZaJB5FVYGB2J0M66Yrd3T777EE0Ai3HTMOW", - "xKpBbGBWmFxaS0YePEX7Pa2hNTHO0Eu8WoK0JPSwvo6aW96WAF3K8a1YcuVkdiu4yfp7gfk6qa7uvQXP", - "7jC1AqtljS6ZD4lS0iXxdgjVcLVmpREz+QC3AoIMGb81x5Qrf16V81ZY++mT7TaCCFfJCAuE6Rl7ffXm", - "lUdhYyeIgoFq6ikl4qLc2O/GkmoS4Uc2tU18kWXaSiWYlUtZcCPdeswwUwju9yBIvYfx5Mn4GRA7UYWc", - "LxybFVr7Y0npQhyoyjPH3r1hf6sENguKqDCnZNYkCmwQp8MpfY4xKJY+GX/7m5RGdUZmjmU6FyOK0zOL", - "TAIHP+OFnJqYsnmpc3HD1R1W14/+2+83clB7gVZia7mtmJ8TkafQhkHHzy/NWECs9bE5DPTSIWerL+qP", - "X5igL6wrP/TPvChGGcZP8UlUFVW2HhKAICWdPcXE8yUvfMZ5ywvW26/o2AyK17IQiP/n08J+oRyK4QZJ", - "uolLMI9fpdP055Sp9BTdSDvpDWvhXRXqvkPToYwbs45APD5Ro/uuIk1MCHXUROu3KFB/oMIHL1T8gBe6", - "8nVbpdCtGpXWGlrk2rHLu4ugPSWPqKv0vPMFrQXimLvyfm4X3IgP2p+Ynqs1NNnenz0Wn+wcS+Yi4+Y2", - "6umbVcmTGV4XuyBRMEuF5aJ0C0Zg4Wypsf5CzyhJ3YvUPcG/3WZMv5u27IpsPwkAVCxbSKweIg0ebA1s", - "EHdCujk7q50v++eIWTjdVlgMcPeTDA/yVLiVEMpbhEAi6o5paSfOQqCdkDNsyVcq4Pz09Fem3KF2hmY0", - "QxpwzC1s5miZhNX3oCX4WEtsZ3eEfKZZBaING8zUyYnIgjtQhDFAMgmx50lokNSJEVmsR8GkazZUQ9Cd", - "/bvMSznxeRCkxWKhxeB8cP+0S1JOeXYnVAcPvqAfmmhBhPmUznXaDSC2NyvgguJEpdH3Msfwm5oLQ9VJ", - "oPaAcBfGw+b/UM3nUs1f80z4yH0+TJTSK5Ze+w+Mr16enKZUj5hqdO6dt/Qy7A+pS6G4PHfiwY3iFEff", - "jOySFxjku9drPhfn9J8Ran/fnD998uzbc9Ti0nGiPlrqBtsOTzpNJT9GMD7nUllHMccGtFy6jdCU+uPh", - "c1AEQXiPqJ4gwH/tpm+g4H4S30mVnwfiwGKJGikGGf3K0+1+4HUmCWjiMhNN65b563zG7wSbyQdXoWVc", - "46cyjsr3bXg1WO6YB3nw4iZLrjBb3Iu/3ZhlMQoZl45oQ9ihaxQEKIrTRJ3UPahQyQ7kOSV0upnWBEgL", - "O2QZZ3MjhDrDNFEQvwo+lWuPhE4t56m6rRRmyeHipVfwoZhImKiTHz58uCY0/jBLsNvvBYj66KYBA4V8", - "RjfYtMRndCKFCVCcu5jdCiKOssEjiryffqmL4rTPlQj6tHVNQbHRVAt/ZwFeNdhj/nl2EoC9MQ+Rfjy7", - "T705MkwUHckn49+OnwJV31VF0UgOwVTWJsgazDUCwtkD0ZTwwEwIYnp3OW4rG8PfVb5y0zLqDAMLkor9", - "9skTtoQJBHev563wEro16B6CU4AeXMPtYsM52qB0E66mq+bOiHnAmwqPHnKV475MKtMhZb+X7odqGvYO", - "q3UQywO08LS98anfGlxnRXBsh6ErIS2b/HNA10N9twPVaBKble47537QEXb/iPIJtoIqF3nNkY/TRAU6", - "aMU8ZcjML9bYk9ejzvnsDBVEnjDABOhMl5ZpH2Ks4wkwmfZEfHntSqKcOLHCsfTy6i+TP726ub16/25y", - "+cOryz9OXr27ePHm1cvvEEWw6Y3AMyDVvPfI+tEmONr+1E18+BKe9fpxb5P1oAJs7Wpbmdg4cMOOuHkD", - "GqlT4+lUnVbSZYuokIervdd2yGKW5a6uo1vDbLaTIYk/GA7oPhwMB3QX7s+T9u0k/Dw6l9TAsDmyDiVM", - "87iCncMqcbxv1c+/WZezs7SGVkPej+5Cq90gxL/EgvtH6yHFcABamnKT3t+tnCsOmswXEXKrtOkA0u7x", - "Q8MwX+z2fba3mulrOwJbS/ta5UxbvPgrVjR9ENZ1iKm+peVyKVS3clV7H+JDjNsaSiIEn4Iii0HARN1S", - "/6Un9U0YnygEAmCgdRI/WfC/y2K9UQrbuff6ridBoIXec9dNFiP6AJ+aR3gTV8NRx7rwiK9wKoSN2Y8H", - "6SE7jvPfu2KS8u+YN0l9R04IGB708efsicciiNhXp7tbosaaKol+5ja0+57oFjzUR8teOdAJmX8jSj0y", - "ouBo+sT6dIqknInYYYeqzkrNjNY9Ybjt2VRKieKFVJ3wdVhPUPTG9cl226OXhxo8NNLwc2ekDJJjeIpD", - "12mmH6+6PUi9l0vTTI7gm4Wu8lnBDSYCzE2PUtqv2W7DQdIYwwZJ6vX/uIew3SBiuPJjQKxae7UPXSl+", - "vX9yl9zxQs870TfJbj1yakEJ3TO1+vM75tZTZ7Mzz2ThoY87EK74UuQjh59mZTUtZMbC0wzB43PqFwpy", - "4rS3gUSTx/AlDOnI7K6vxPJzORMrwCdWuF1ZWJlWiuBr8HGyW7Gu8SSUdxB6w2n3kWpns+/JE9iT3B2D", - "942jghRr7EpzWft2vk6b+8z9/wfYvw7nb3wb6xEiR27spI+ROx3zXBMV8PjoieeUiZsMkkFdOxowkg4W", - "+31BlR1WOrlM4LapnVsYosc1acfWwtW+QJHvCPjtjqRsD53QliUDUB4S2rdkgHOpd+V5NON31/Yq7cSu", - "WE0HPsbncwMJnG5HzjUJI8Q6+Xjzhp0oTf1f0UlRcLs4JV2wkPfdS9mKrcSACRqwwFgUUSkIIsgHVnZH", - "Uw5KxOu/JUNkpeak/gMPOncfHMsOxB+fLTBZHpo02K0Ab+5Oj4trknme3EODHgWaxNn30oEud7tWWa8G", - "WOqimGAy3j0vmnGt7eIq1PXIq8pzoTLUev0b7OTJWTgJ//4v/7qRa4MZ9apYN1sFIpNh/xDqVYg1895f", - "lbITXljdzO1LVJgkkzOWrsR0ofVdupHL3+nvasFrxPE66kuxOYuIjRQ8zOJUECJb6MvRGBxWWlZ2McJW", - "IipRJ1iWF9yvQ5zd5uSYVsH9fvq8seR//5d/Df0S2UxQOg4YcYqFlT9n6ZKrihc0ckCy0IrlYskRRynY", - "ZuFs+qnCRUnjkBpZ8QOK95vEOpDJuk9V6JCwtyUmfaopL3d2v4GHGJ+GmIGuHDbB/vf/+W/Md5LhjnkK", - "JKqxNaHbLQW8A9RGpP32nvVddK20grDKvbT6AFdq74kkpaW77W9AgfB6l/c9X198aHda8ZxbWeF98dok", - "KhxPkHER74E0uZMwJvLVu49v3pz6jGGthI2GXqK49drsmH377FntNJANuEYqiORhjqRhHBJ9+bSLbotq", - "egDZ+pJzV6wssE35gwNqjdmfeIGIkXkMsnpawrKFysy6xB9dooywLlQOsELeCYZZOVKr5829wN61lNtu", - "BPZV9tWMhGz6l9H7i8otRrf02ELwXBgKDeLMH1kgIvYyAhsBPlPXZmziUOz1oRExdjDizlSafcn3Qefd", - "N6OewT3GS+/wn91HpH/Ij3aH9z/qLz01thiLjYgiGcckmkKrOZVhL4RyMsOykxsxwyvL17H5AtcAaE1Y", - "I3TvCVS34dO90VSd8WLiT/TkuDku+Zo6zWH62EYDNBQGeHOchRuEsj59ixzyryIrRjjwyPLMOr5OFC8K", - "vRJ57KeM2QoedeyBepH/wC3SiVtHHXDYvOKmN6RpdJf6/06smNFFne2HoOBNOrNuMvu0A0/nFF5L2zcj", - "Pjbw7ZZ/PIJ9I6R6g6E20ly0WzQrrUIlJN5MKIaxtMJXiheChzZkwehKFNVK1hKAXXNCvuXK48WFakht", - "WNoYPvUVd4mSbsxSOKppxFmve1oidbwCnXdVMf5yMsC3t/7ybNP+M1HHdtPw0IS7gOc1Zi9D0glsvvXN", - "cVFDiIeZ3Ute4wm9v0HE3Dux7uPfxjifXyIUIabi6/SXw9Nm/4OkBjuZAs+TA4h9++Sb0yhH9AzEBSZE", - "jEJbsvjRHiFjYNkqipkxu+gRM8yIOTc5NvFC1Uha7Lw3TtRLMj0w9wUD48/j8QrbTjxXl0vBy3AkE0U9", - "1JzReZV5ZARq0Xfip3SKBw+0xBViSjRBmvtYBE7hhA50C8yqXxgeKKu+QhMnScF3YjYcvme+u9ozNRwB", - "PXz4Y49A2J2Y3JtMTBQ53G0MQ/1ZukXso7XTb0zf3hW+a3/v/OcBL4r3s8H5Xw/p3j/sSegMKdF9sNqX", - "8GfgdpTmmBOehyx4G1vvx/YZ+zM778T6sMGMuNd3Ig+i0GIbDx9aPHhE9MUhBFsnrMlbjSliGbUz96n9", - "QS4AK1vHlyU7uXl9+c033/wBLH20cOSsFmQLUD3QI13o+RybCGxU0hwhlTe7SHRu0hYht7nlx0/DwRb4", - "WVevO2rlTjBnIwKKRw60Q49eYPSSESwaKhRKs6uz99v1236mES67P1+iCbq9txVJ6CXwxUDTbajv+rPD", - "npl3HcCOlKQOCBSR3fWA6LwBxRFdWg3W+vjhcshuXl8yYjCyoBs1tZRpCG99PkhOI67QH8oshZE6l1mw", - "TXGi0oacsp6uFMHN3bFS/I0thQXmG4Yzs2wcORyC/CLBdaBCUuVnYPCofrH/Z/LL7ILpK3VfS56jsEGH", - "A4+/CUfkS8FC/bSv1EzvSM2vnJ7USZj7kg9DEmnMXS3WrOVI9HBJtSvL+yywbQTxBshk9D5O/FOIS8uC", - "9BTsN+gmWvA8UahOnCN94cnTMUN1EDWcYatTMFkOYRqMPIdFr4bjh55YkZmuWOIPby8uGf04Zh9gXgyb", - "jygrXahpN9pxR65PSi4QtIDOWEQYsDPU8RrY9+PNG/TjcesEqHTaE+yRDeSkvi/zUH8NsgbTqYMRhtt0", - "efWXyfXHF2+uLifYws6ySoFxSTh3ohQqZ2uEE6YIG0GQHeI2bC5hi4LDLVbawZPvccyOflzx79uusXIj", - "HBRokotCYuL3x5s3pHcjDEXwliWqI27UqmAn9CogVDJQWolk0JOjXyPDbQlCI1hKk09BwxYW774xS4nI", - "KVKfY6SK+dwIT/9xotI6zpJGsITA1yPYu409PZFqZjg1t6iMSJQ3j4PLM7TtRR3/OeNhq32OrhICsYNY", - "CstNqbJY6fCyx6STltXl5gjA4CmOVugjtNI97YNdHiQcDTdoBZCGSNv9As2zwE5QMc9FNyLTKpOFeE/u", - "9O7CI18I5KfmrYDaOICR7mRZEgR/fwCwPyzqLYcenaW7fWrImPQTPGSRvX0ZGpnw2/qSX2R3aiqttvM3", - "H6E43GDp25OuLpae3p0D77Kg/N7tjzVGmtT1xfV21yywY+Mb+xCM/q/kCtrV3uy1EWIE32m1VPDCyrvR", - "UGb5Flz97paNDiZvrl6OMCCgCTW43dj0QEiTj0rCu7UXBB7rfP/QjujBr4EqQ/hsbIkdCg2otw6Zbxzt", - "pkTlwhdVsj/J2CYN5SYMPQSrYyqoxytX62bHckTnSBQCaefMaV+8hG6bA0tvvo4Pw2f+tBsc9bss9reP", - "bLXm/CwfxWd076yPxxEdO3d5KuIHr2sc/s32WcGXV4CukXs8a16zEEFDE1oFtslB44FYYiFLgn1CG4ri", - "WlTLIXLmx8QSfeld3diNIIwo1Uwn6oTU7mFM4MX/bXX8Pt2Gc821sOqRSxRcwIz7hATCdHBGll3O7eO7", - "xh7bvqD7gtrXDXZzl75y0/ItJviCwv2DOpZvDvg2MsvX6OS7R0fY2+p3dx/fTZ3ioH0jnzfCrndWGbk2", - "/Gp3M5+v2ndnL5F6AHVu+GobTCfW6sMRJBAVSp4AtRYWTVovFtSh7eTh0MF+sKEOYczeaUTQD6d/qrWl", - "64OXZSFFzk44GFX3Ulc2dilky6pwkn6nTO41qui4OlzEkK2wyUUhHGKto/mYa+yVInwdKxVlJAqRebD9", - "V0D2wYu8RI+/G1EMPjNarZeh4cl+GJ6v2uNog/8OaXlEW1m3PjqAVV+jinbjk3M65Us/64Rul1sVEUjY", - "2Ch2Fku7qYsMGGMp+TfRvUmZmVhWD0ddVy4dMuGyMbvCdWDstKDYFKai8FXbk4XtYzFJSvGCUQ6fZbkG", - "e6oQ/O45o2rKhq+l0HPioLR57NN6rnA94SCH2PAbe+XpcgD5rwW2qPtM+veBCXrMh9Yho2fH7CLg/Wnv", - "ZuSKBTyBNFFLwX3NT3hxweF6Rex9bEMbmvMReiZeTW07taQ1AR8WOjjgfMnmLmtwN013ueQ2aFpf1Rs2", - "3fLZb3vxwwRXIbnK6XL0Drnsxdtnv2X4ho39B2PE08q5StSsQGuHvPLUJveRZTDUCSorpfa+re9AeDph", - "QJrcUs193g1Obxd6xZKBJ3GpmS/RzxOlFSukEwb7ut2BFn8vTMHLZMDu7ZglgxIOmPWAWQ3JHdwv+4VY", - "LpQVx5Fp856QNbmiiB6zD3pOrm3UHdN6N1LyObqVxq9h0WRhAxC0wPiN0yxtCfv00PXEnpldMmrRTiik", - "jgG5MPK+CUXfZMVHNlGEWCjmCOlDACYJWRJnsF//FYPXA8ylSwaNv5z2YUtWy8lCdpXzX9L96WfS4D7C", - "pSUo0DwEC8JhTxRdxhkv8X5e8pzwE5U35+aFnvIi3M51c8vOLPTdMqi1KR0e3/XUyDx0aM7WwBd/fTJ8", - "+mN0yf3v/zWaFkJhaiOsAdWKRC2lGi35A1OwwYX8u8jpNMJ6kEUDn7CT//2/vnsy/u0pZQn7+YyMKMQ9", - "9qaZw+1vOKwUlA+wTJLBB13GLIRkkKiSK+wVYZyN8cwGwvc+Ntstu0Iz1TatGvs+bMqm9hE8QOD1Wwg1", - "FPhx9kFTje2wEUiE+7a8neWDEVuwcQOF1teUFhI7vXJF92yi8sps4rf505VphIpt9tHViuXS3hG6ik/S", - "9IKpdqVEwFA+nxsBjJA/D9LUg436xvMx4HGn9CpkvIKqSK3RQZ4FKJENHNYjCNpQtjqo6u/N3WTFc09I", - "vME3Uy93Wjm2EkbAfY3HCIRaotY+ToHZvNgGH9N34sVOy8rZSTObjjsnliVoyjhporM0ESgSeyXyshTc", - "MO27m6/JRZ6olG7r74JeEZxtchbV8FIT/jbP159P0Kb61EXRHTAp9fFH2UB+sM0rhvmL2nrLArcGVM0N", - "wtfmkLQhnIrix6ErDMgAu4uo3Qg/LLF5Vi7vZV7VghgmwhZyvgBmJhldfAl1+q186pI9c/YAbgOOYiFz", - "qxEGR3G8lHR2T1JaA3wzPUVMdrSYz5EvHhlRMyRm1qGIS5QXBlOfwW8RG5kteDELh3lBF4j0bXK9jZco", - "EAW8tN6bxIu5NtItlhjrq4wY0R0x42qkKxfUehhSgB4r7Jh9MHKOKbzNQgqE2nIaM7tmwOLw9dcfbhNF", - "reOJj5HhiZNrJkCeXnDLpmAh+2+C0lZFUC4lVow26/N39Ra27vWH2z6m70UYx4KV//lvEf2VwPHHLEXC", - "0m/1asgsztkMNLtp5RKlNBkOAUYcYZoiJG9K+LljlvqmoRNv7tWRsMDlQfLDrnO00GzDYMfLQOQMto1u", - "BJLQYStPrBAsbV5B6UZHUix3wUUNEKKjOZuDY/8t4Bl/jx5wF7d251iLbpcWsT02IiZlFWj3t8Aq3siB", - "zTEXFQ2w4eKlvC1Ma6XCqhQe1Eb+HfOrztkLfJsl1ZMn32SXV3+ZXFxfTf746p/xDyJFHwMMNTj3A9Wq", - "0MK5cvDpE7YkmekOTfDDh2vMUggmdprJB4+fldYmCyLl0XHMuVgitBu16lxJg3ngS2pLPl07MbKEB88z", - "o63dABSzVJ6RNvCG0kRRzrVULD3jpTy7f3pGG54yh610G7K68DABaRvCKMX4SaJ4TP+0I9IOuMOYiW83", - "WnCVW5z9f/pP7KJOLZZa4ZJWGqHqi0IUWEaAmQehlA2EIV+GkJJbY7V4cQ4vjtjjxy+MXmEO61ltOz5+", - "fM5Sgs70K4OvnmGqXUpGFyZ4st8kitWpzdiOCzHtfnCuxCq9TOs7SRsUEt1SUpz9L5hHDZcZwzyVJYeF", - "FYh8h5jRoLwphysY+cC3V+jsmN2GVEWjiwI+MdMGk2iffstyvraN5rPcRlC6MS388s0VO2O3L/+Iq93F", - "vT4hz3Mu7Jm/t+AErLiFkX0rMrj524Qr5ehOrG3qe7xhEj/YdyOs8qE6HTDVpwI+E/Ii6xu9IPA3kFcc", - "26nVHpeskCDekTF8MW5o+Y7I6MQLQQ6cnrP0+1cf2NlC8MIt0qH/Z64zix4z/BfiTZVyvObLIj7SZIKp", - "1s46w8uR53Z4tY9XYIuoRAGxxi4+fvhh8vLqljDGqNu1vZOlL8sk11oECozt609ycS8KXRLuLbAVZWus", - "uEFANGl9duYpkuLPm8lQjoMthmwbax4ob9v3gHCBSDZRONEX799/uP1wc3E9uXj59urd5NXbi6s3KfsN", - "6/z1+uL29s/vb16m1JEKLuo6uY8KVk5m2mTk7/JnOp4arfyTSLLTMbtghZjzbO3n4uVmiuYDtivAkjCW", - "c8cx2QZMiqXH5gFliVmp5qCtp0Ldj+J+pSHZtplry/0Eg3AJ8TWe59iZBa7MRIW/pgtt6RJJyaS1oZEm", - "5e0Ir+dRFQSbNgJ3UiXq482b4OuwePerYo2JK8HS9keiZmLH7wTjLP0ZxvyUso83b8DA9l05aDBJetvj", - "x0TFp79jC/EAVKbocnr7w8XTkzjx0/Tx43GiLqmrBmw9+ZCCz/csohz+wO3iGpYaaHOLzUWR4bwPEn5o", - "8354+4xmfEZlDgjkk7KFVrryHaxSylZMffneOSiwaIGEX84ZhjBIyp89jFT+k4UbwyIgXSylJHsdO6kk", - "SolVIRVorL7FFfMNUYEOVzCVa99i+NW9UC5lpADYoT8ciUoXghs3FdylcAqV82fx6ZNQnj1m74s8iB7v", - "PBIqZ0ozmniiaEloBKbNReACTtlckIpOXO65dfRPt+/fNd3ASPJXoMFZ+MdFcKLHZzBLvL7esGWRXfBS", - "nLP058TX3yeDc5YMSIx7Fz+J8WTwCTa2JREDK1FLywdYjNQqupcqRc+t2T03EiyyGuKvWCcqxKRhdPLb", - "0+jj8diPFluHnA9qjQWO5aCB6DO4f4opGiSIB+eDb8ZPxt8MGq0ZoqCFk3sW5ACWR3elSr7EVAw1R4Tm", - "urjWLoxUd4x7VzO1EcarueRzYdlcg7RBwTwzgpo/YCYGlqVWHnG44NgI2kgnLHUBqgUTMgeYMYW2LlFL", - "MPfgRwoVSPrNSvKsSYXsCrd2wc1ckLtRW9CdUGTD3KQFq8tfCwEhdaFXbFlhfZBPqi5QKK4wURPrgnwm", - "NDV+WWnjFonKNRXB+SAGFX8jEEmiLheCl+dggMwFpeETKnIaKDFBGqVIDM/u2LKNsG5txpUdJsr66AYo", - "OXwmQhU4DpFiOuY9z6pq6ds0eQ1/HRYSCUkrclYUMxoglESD1KD7FZiUloeZ/YW8F7gd0oUyJyNmBTkp", - "BC9AD4TzjRdKxAogI51bVpVzw/PgLqdyJoHwgzEpsQ7v4OwyrhKFB2cqgLUqdUfpQBj+MmJaySJ/DnI2", - "MwS2XIRvAE09z+FXmqcKvhatPO+lanTphotnicAIvu8GmVeIbyo2NbHWaTkzIiu4XKakM6TTQmNqPx3c", - "lFIx1ajuc4taOTkM/fVGWPIGO74ovSLjFDEWfAtvgndRgv2kp+T4YwTSPowQ1fVS4rlc8HuRKKP1Mto3", - "mS7XY3ZDkNzofbcOdlnPqFTVN5QDM9gFBGtyQ0qtrvLB+eB74V76ld9G6HgvR0FiPHvyZCOvYFNwYzk1", - "+hH2eRnaA6Ed1x1UjPxNmCufhoNvnzzt+3qc7tlHrK4EZZ0aQn/75Jv9L73WZirzXGBy+W8PeeNGUIar", - "/ahqLBg0lavlEjHn0LVlXBCgVv5dDEnq5IxcH6jc14zDc8QCPiGdEAG74Ergc1uX5v0IQ/TwLGbyk8hA", - "H0DVIe2v6gNGuGCFcK0ztvtEeVsDbFJ/aBuiZQXyYcnvUE8+5HCxUlvM/sMGaj69GeZyziTcCFyi9mgZ", - "SnRhRkte0jRReJHugQjRvCh0hvli2uAX8pADhmdOPDjD6Roaglix2AGaO/abp+Pf/v8j+AkdzBGqCVQu", - "WmieowR4/PjC3oUyaKplyUVbDGN/C8LjlioeWLg9Hj+GrYaZ2BXYFemzJ0/SMUMTmCvGM0e+WdT8M22x", - "XpUuHhz8YuO3ltTE3ohC4g1GEIrYMHEqMl6FW1ZaH3zApEy+DjwJlqX/dFyTnsFdo8uqQHqG5Y3ZLSqR", - "6bMnz0AtNaIh48mDEBrtESLoHh7wfJ+eo1uU5wQsv5Iq1ysM0+LN4xtnkOIRXOAIIE/Mt+BlKZSl3l7I", - "VHRXYhs86i+ObRdIpUQ26pJ/t8JdVE7/Cc/OW0J38+6AF5rajnwV2VcPEkr6P7V9cWD0fvoFhe9bxCZR", - "XGXifaBAlwz+0M/YZFjg7D224Ji98x5b6pCqBLE7PellSSQ4wi/JvKDA+qfh4NmTZ7/6+i4aHORB8Une", - "wdAEYEvnYvwr3jvfPvnDVyMEmkadK/c76WvWUNdYiCInd2CQGqiYkHkK6on1LfsxC2W+cH7nvn327BC6", - "+N4QdEN+0fUKL/+X/S9fKVvNZjIDI/TWacPnm1fzZS30Aps/slGEoBz87GvYSzbCPOtC7bgljxO5deeY", - "PxzZkZqrwJmxTC6XIpfcCe/kYyh7x+wa3Zlkmy5rho/+ZQ9iiJa8d3n55lC0JDjPcyMEgS4OvQ3kH8Gi", - "IbOko5pLXug51uYlyvJ1C8FAgkJeFCJHZ/Fj9jpEdbWasxKU34aXTVr2+HGU848fk6GS65UK+A3DRDE2", - "BSOUDK88RnB5TnCRcCHDlcjeiRW5w2zjObzdgU/JUfoTQTQT3X775JvUNzlJb4Qz69HFzAmTPq+1cfg1", - "NATN0W/tQdRKjuhWrwKkQyyAhzdigXpzgsElIA18B3FpLOayhqx1MGuXIGes0yWb4kY0oJw8HfOK5BcS", - "xkdywUq49xUToTaTs6ffjnK+jlXshZwJGGsMu/Jhw90Ju+BdnmQyPn6Mci/XpYuhQ9D4iC8kuq+pUrSq", - "j2LdKpXK5VB4VCWO+OqhFJljRlfzBSg4bClV5TBFg/2eff+CvJQrbpbs9vZly4oZsrKocEQqsQe1KHQF", - "hhU9Z6mwTi6xrMJ7nFL4XtqyKlL4QrMGILTSDy/HUE9o+eV1T444erCYoddpqfIA7gJpl2N2u+KxQTdS", - "KQRdfXFg6BSOqGiIt+O5Mzb60EXu0XV0KZTve5uEfCld5Ewrss1x01a8hGmUwmB7KVRap1q7YTiKQVFM", - "lCZNqHlz+6r9UusCDlyYBfohWKMXvHfskJwGrWtETXhFYBJmeJ3FKR6kw6sD/TnexSuMb2YqnWXXVy/Z", - "U9B30fEXiFzqQmZravdZwkysNp6ldXEv8sautPVBtuTOgeJcK7UiSsxMl7DNnD22ipd2od3jcxjaO24y", - "vfRwdNSNOrAamwoUINL6aqw6GhRPAK3Ahj1H09rvrZUFBe5yaTPspoVpSOTpCuaMUOTX94kcYGRRv/8W", - "OXG/myvTU0pIJ9dnzX6JAiPLaHQxM8TBqQ8ksIf11oLRcN4oHQ0BrDzoU+04R08OmUN0yukCwB1MlEcg", - "ZZYr0bDvsoJbK2dS5HiWcZShx7+YrhnGXQnFcUh+u5h2gTo5WgN+NMwP8tmdsE1+SlgE3pL1iXpRX5Lw", - "Rw8GXYbgWG7IN9jIF8HtJRk3Zq+l97/SL3g1g8qjETPL3xrOcGV5zPeKCNT47xmytF6pISZxRc4i53Yh", - "S4tF3w3EBrfSYaPR4zYL7lAyuxLVcagKTv59XTk0XvD0e4Ymp2PtKIjOoGyvGoOs6P9gE1X7HRpgYKju", - "BNxBDifY9yKSzl9lFEfhzIqSG+5EdCwO/RSA/1Hgg9X3sdfoa3goKG5yabhdoPfTrc+j0gKD/aQro1C9", - "oD7w6AQiZ+JUBAolKnx6yEJPeu70koLEw4Z2kOnlVCoedpT2Dj8ZTRXqp0DGOPY4E5Yiipj/x5a8RDsz", - "EIrySDJ9j1mktDNjdqFYo+E8sSI1nwMpgUB27Se8hA/xgTwGqbXBuLUgzZwkNIW4OZaCYwklNqGw1GBf", - "hdqEYIM3tjjcSyFU3DDrg+1GafbVEsRVu4rdG228KEbajEJ2jj/JXpMxYmSqOoWCSEv98CUGJWHjmvzO", - "fXS1NCKTVqAvN4rAel/DHUxjBlUJWybn6DrQK19sOw3Xcpx0ojKU1eiNpQzmeKkOWf3bVETmiZmhjUso", - "UcErQf66xmuom6Lu03qRfBYdfgZ/hoOysu1m/fUt4YZY8Wbw/2fxdlm8GyrmeDMi0FQ30R1GEUZvKf8j", - "2Lw3XmFqaYgNx1nDCfzZtq//Vr/te1Mpy9Lrm4vv316wRrQnhLpCad1S34uWX9oryJS/Xwvsoc8uDOXl", - "f754QzVY5Otjt2uVLYxWurLDGAZCkZ9REE+6oAsopk1OTVtIK8AO7sE8oVlIRzPzcTaVKPGQFZUF0YKP", - "a5+xu9BFTeUQaov3NlUQew83HVKv6kYJWi8C9X/Qn73CFEVKmAS5t8fsSuHyg2c6UegaJ0oG6GlnKkXH", - "ixTIAsW48ob7fFgXCtHUE4WSezMsXHfDLDReHTNd5P6qgs9hiqe/bKTDGCIG4gKvheAstTIihz2ZlDFk", - "GO5dRMCp8YkTBGaWRjSii06DMJaqyVCsoWsgSZ6z9Nsnf0gTFfsn+LyGZgQm5E0sBWaLw1bIqFBZVme/", - "R4LkYmY4FehQ2hH65rOmVJVFATYVnr7GrJHyy9Lg/lBYVmcYe/XmGG4+qJ/1quA70c3tNEZbvEccA++N", - "CxbUc6lE1zV0Q994bYS4Brb+hbzdfpiGq/uXdG3H0RBnpeMeuAlyTippF//vu+c2ffbAnXvOxNeNdiIk", - "67bIbgfk26H4o2+augV2q5dTZ2bLjfejgqYulDNrMltbLWvrPtMkDMDUI9ykRBHFo+hElMAghIW6Z/fc", - "WMoO5DnhYWZGYBotL+wwUWVR2ZhcQv6B+Bqc1rqPs8/dqzX1MV0CdbmmN+KlD3XFRH+ceW50maOBSmJf", - "mBH+fabNchjnnwwCFtWf3v/zxfevQupgMJ0tv5dqngwSNeVKIcQLmFOYEygtW0pM+OuSJ29kR3NB+0sm", - "EWyNhp3IOg4F/B32rGPX7a8mAFrnBGfUmM42R+OmfpWjcUYAl3tPiC/rtITHEudhRSiCO0F++g3DNLxw", - "PqaFnp5G9kL/52Zz+0aP/HHtLEcnPfmN4qhR86CvM/h4VKqFuh/dc8PeXbx9desTieC2DWlTsdJO+xBH", - "SEC8F2bKnVz2JL1Qv/ktZvolObdvyP5EmGK92Rz+18+F6WkBaqNfOzaP9oWUIGZevX3x6uXLq3ff37Yb", - "R59unIjvfcZntrneuo9/ZMk9h2LYnfVygT4hnxzrkwl8CYdvz+ENt2rqncXEhcPAn4hy79MS7IpTSjqx", - "/K2ngIbPnaA70oY6vcp7BKktEUJZUZZqE4O/cd4wv7FSTlfZwmu71GEaPdmoA/syNCLQjuP2nBxfsU75", - "kY3oCxO46ajtdQr2L0ZwsFCvvuvEg0tUnZ4GF2esCKdytkYeCn43UScpfPM7+CMiCFutvsNRRjT1UD61", - "kXvR3UL7F9JJ9zTsPigd49l/hDCgiTPuUWyfU6+ZwDnSIjPSGX+y/4y/4Hlc8n/EJehXg57dXM5mgsJz", - "R5/3gy7Bn+Hy+nTmQk+WTsfEC7LOODqyVyO+4ut6FjE0tC0gMl4U1rc3ZidwXgjtByeCSiHGReJsnoMR", - "uVLUlyNbyMI3caGW7qdextw6jaG0MWte0XloPNzovKxydEPoO2pHwD7a0GAgzLlWIr2iB1OG8a8/fkh2", - "qQ3hRqYtsIKKt8ispYJvEmYnU4zQr4c+OPXx5s0wqItB4z1tBmhAgnaJgs4m1VRaSSUdFhHvJeyXRzwg", - "iKPQzbx9coeNU/g5nfN//HwRtKu7/0a/O7/MkS1FJmdYmFgrQCeYi4gVBQLxImChza6nsUbzV00j291N", - "vNPLjPE0BmeQ4KdFHsTIP6a4AtXnWVebgsZCQlu3Bkh2VfqamqAYncA0EhUSUoZMCYdxzEp5mN9CIAgV", - "Xo5tKRl6h1Fd2paZ4Bkl+Nm8qgKH7lipick0o0Jnd/YgW0Gqke8L4N/EeiKYUaVcq3NqQ6dz1ByOKgmE", - "NBgRtwvtc4jhu1fX5Kk8uboeUg3pKSv/b/beb7ltHNsbfRWUbiJ1S7LjSWafbVdfuG132nucxJ+dTE+d", - "zSkTEiEJbQrgBkDbmq6uOldTdW537arvCc4DzDN89/MQ8ySnsNYCSMqU7MSWnfTMVXcskiCBhYX19/fj", - "EmwNGImy7yNRzSjo2KrMHrz4Vzv/PmQQp6fiiQHVNmCZj8gng5nguYUyVdBIuYRzB4OwliHbBfkkWOvE", - "MSA3kApwAuvJ2VaH+MS/7wlM6QZ3YhylgeDYlgVBlY5r/HyOLw+vAa263AmUHXyvh8itfwGx5nw/kRNX", - "dT9isD7AXUFfLrayLj82HbLUq9qUFXJ8aUMZAYj5LktlEWiwIjTS8SmDGdPK8Xxgr4Uowg17/oYLkOvU", - "W9eN++oyT9eDaEM57Rj+gp5LOI6hXQdfCHLSkAuNnMlhS5Gfg942DUld7N4XHybqOBPzQntR3MUL0Da5", - "FIuY+a9o6DDrFUsUd7ZftQeYrag2wMbCy/VBPsmCf9UiH14gAuJEV5tY8ozVQb2njBZ/Rllts7oVJIC3", - "77JP3mTgwq0+F37i+aXFzuc3bz7+cHGwf/Dj0cXh8VnaKGZtBmGH02k5oZ7Cj1ZkiRotmsbqC1s78uAV", - "YAd6L1kHMkAEXpzxK8GcTpTfp+zHHxDd4/gQ7KUZV1kAU4EexciFMebjmYhwL9ieVZnKTbZfaKoWA2D1", - "9IYnk6ooHebNoKHZilXHwFucvU3W9PsRVsU/D/xXYpl+DhPwjLrfiwe9CdbajPHlQqbvUwXThKTEatkM", - "Vc1VFXIJXkm0F3bZG81mghcMqRKA+4iYkaxw0LUFFI/kuhQ5d4DwLm4KbTEjDJnkfIHgghNdGmi/5FNk", - "tgPeITBLQFdLA89ESwSSJQR5HUIvZg0xU8wOB4gz+E1aLCoKNlmj/BPLnwLpEfQEYlyoBnEG1URjXevo", - "FDgn3MXyW6jlhENEXEmwuyAAqxOV4rBDf8cFNGJdQFo3Zc5wf6rDAsi/xIq/XFPzKHD75XNo/9UKoPMH", - "UA0JzbT4jRfwjcPI2hTbsBERDzeguAHWXeKiPAwfC4dmYMpdIrQK04/YLdg45f8Oi5MouidvNL+BpguI", - "HAA+YP2M8DySk0PxIDQoE4chmJAxXyMtG4mZhEJ0PwtQT+4QNrDK3IbKc+lWhK1DNg6pvTaaU60PtKZX", - "s8QLvtYWzZpMgCaCz/l8fbTFFc8XfxFrymACzwYV3kJJLI5NBRnhlci3jP0ZVWEGAg4ijCC0p/cbBy7q", - "Ekh5Q6HdlJuR/yqgUaCdnijCTg6VS5Q94cG+bCDNYDy6KqjB8sqbQigbOJWko13ilpVUUG8QU05U3HBD", - "dhDq0B0G01hAXENlFE12O+aqViJOfWUpzLWVFlCVoVQGMKfo6G7vQqxWCnBG0lCw7dVowEHytnfSwYSq", - "BKKe2gxdcwvouSrpxJZ7KGKtqrV3SfVKSHxjVf3VLTJw7BpAT7XW7kPBMqy7pkpPrLePAX0yPar2iwCZ", - "TsJHvOqCg34nrhTSMwB5q9i1LAL3T1PH7OMjzirx6Wy+cmOfFrLVe6XfIojkV6hrfpCwO2/vyM/XM7C8", - "q7UMQHvECuAcwyW1HQ/nYQ0BP2wlKrNCPQLNyogGAbZzDU0SUAVDFEwbBHAMkkYOKJYjRIh2OpLH3Bhy", - "L7FOEnXXhGi+qhI6rxEw6JOoWaiLx3ErzMgGnx3NsMiGWPBVtSknKnwgC2ym/qV51d5qC6HcHhUzh40E", - "sxFRUiKbTY1VEkA4uUW2/aKxkZtueIINIZZx9uYAG1IA1g22dnrbgMqMLiwZq/yaL4bsR33NJtwkKjXW", - "hsuwBBKiVME+HURwuV1/spxIVd7U6hinulKQ/q/vz+nsINszWJIwfqRg8S+45x835+P35wjE6g2lOTeX", - "3oerCzcE2hxfVM/EmkGr5wKLuUVuBVRCwuLMh4k68gqz9iMWzl/Czmgtp/biH3fehsIMNMiztGuHD1xR", - "0QY/x3o21iU4BeoW9fsODh9CpLS9p694W3/HgVaTXCK85ZP3Ejd0M2rKpqKsS3NNaX6yti6BrmiA0fp7", - "hde9gs+v/CvgvSHS3z38HoJ8//jrf0Nezf/XiLGez/1WzwiY3G+3MQdnt4q+V1yAwfTAXkvGWYqzk7I5", - "LxCYPod+QkCoBRTLFzawCrbSCNTK0ZLO4fdJh22xpHOkrvz/JSoBa5feMemwwputStw46KYBG6kGgH7b", - "2cE5OMDp26QZ0hioZbsdIcDilVhal+cJqZx5j1aseKXPrJM5w84akkJ84gW1elkvekP2gxcIyzSlwWOW", - "mVQvhbUpw6OvhDH+1O5+BxG1GFDz0rtVl11/qoBMvBFQLXOohWXv3n+IzaMYREDJDodqJYYBW7TWoUZm", - "P+xBunErPAxbQXnNcGCnHz+0CeBp2SKAG4hl18f4CLxxT33W3Cn++FrZUwv9I8TDz/ntDRJE89MVekAJ", - "WB12fN+IdTtuG4xA6LHPMFnj7UwIGoWnEs2Ak3NqyuNsbLRyfOSNVoMt/hQh8xvmwpQKg2JjBK0k6E5/", - "EPC5t/eMjdhtAKUfGhwnEj1MbFvAiknswPUOrfA6GTYSJpjC0BFoThsolgbnQVxH/x4/8gUEurh3KwzC", - "tmXSAugE4qlVxxG8OpQFUgMIxwmLjAo4JLICD/w6mUQJdSWNVhDky8SEl7nrVxAJfmq5qlDqaN6p5yRR", - "AUnYqxwNwJAzbpmGdkypnF4Vyj+PC//AbbhE6MjtJ1BnhJfIPnB7eSdpIz77z63lIsuqv2IAh5u+Pgcb", - "kgwBNMSbPuBKcoqpofPq8JTxm+bzN/7WL4rPxa8rQdb2CVAAj0rvIeVi4pbamPZVfVfB/oS9aqG/yNtV", - "GG4HHgzYpL/bZj+IkSk50j/AHp9pJfxX3/B5kVMMrmo5R/STVzs7abP3looIAQ8Y+xz8d1FXdEA2wOG9", - "lrBDdg7NAd4z5mZOLbncXiaq5uzGEu4wxVWUDvInET9VNHuS8xz6p1ErXQpRYJQvakBoai6MwP3Z1DLQ", - "MgXYIH/RSgzZAerKRAWcd4uQTrtexebahYm2Frk2qOMslIdQ2wy1igLggv83Mv4zSoNMIHSQcyf6hAOL", - "XYJ+24SYxjiHIvd07FfvoiwCM7i2AutiIFIglC6nM2rgwjFhenKqXEEiL4rWcZbzwumCcZsLAcmZ7e3d", - "7W1aqHC/96X9bxyQRG8pMjzFgxa5XVy31FMEqjiyDfcZFHen2WgYMPyGQLp2qyCP2HFXF+Q9YrHdfdTl", - "89hUS8q6vWcLNRRkEpW+Ds6ffVJn/dXdd7zT7gddquz5nXUC76L2pCVV/3mavekfrImoVuX9VbEyFvp3", - "f7dtGdFK9vrMCYN8oA0EokRhyS/NTMjYQElwLdDm9791SybrsIrJ7mzv1KOMe5AyZLUKpvBBCAnmDU09", - "Ap1JqHykKzCAAN8c/xnUiOHKSgS1OFYD7IKvQZuPiJ6J0lJzHdLLwccCY3PCZY6fdWTMeYX6Ax3YYGsC", - "isIgM/JKKLJcK46sbjqWN5E1B3G6A/Uc0i30VpQf+Vc4x0nYJMoCjbRPB2q7YUU+Z7zmqQ2rzbad1pqB", - "vI0/yiuQqsACFCC2OFN6oItbgYzKw4fq7IB8Htz9z93NFUEReWm3YkskIeeBiWdzB0FjoLb2Dtyooaj0", - "mboyaMKDNUTa41PnH8gzVk67t9I/2g33h/oB7qqI9dc8d0kUz3PiGrk7YNd6INULQgE2mKVSSSCiChQi", - "WIdnZ9xguZIu3UBPBiOuMmozVuIa3gJc8ZxPpyJjqdfOF+iwxEcRKQu4U169jwRltOrUJdItkZa0pm6M", - "4E74JdhU2iYO8Em5m5ePKoKtSRt4sey3lotpyPaxugIwzkqyPkuHbP0is19R5iHnf7sbg9sxzyqoAX/X", - "C9sO0TlkZwELT1NJBRpDQP4EQPn+5CK6m1sCixmiKLB3lRPj5dmXa8S3pb/4vdbqPv1YMvtU56/w9mRb", - "RqK2ZnPtgFaU7AzWvnoxRgBVe6t94A0qn2qAZ0ocr1I+FMP/rfmWbe6h0XldWDI42R6gh7DBZBCOQvAR", - "N7EP2iGj4XAHdQrvNRjPtBWKOTEvtOFmURGGcQT+CFk82NFQ6Vc/nSFCh+0B3ZUHfa9PrKsUVkqURL0+", - "ATrPfbWgDTfHMg/hoMPdj9hnUo3zkqBukY8uqFaMeZipcEFfi9vYylB+C2R3K/tLvIyfhtXYYItJfZwv", - "bDuH18LZ/03v6jOUryAyUdw/YUMT1+Jaz2S/kH/w19wRF015nmNIF7ejBq66UHqLOQjAzVk6ivZVvb6p", - "qw0rlRWu16jaBVR1/5HUoBUirEBsXOkW4InstDU58zxf2c+8KVgTmLe7XK4/iMVze1zzRYVDg21eOf5D", - "TnAtG1IURGa1A1av2/nmG2hDcOLGffMNSydlnl9cikVaw4wdi4pDI5LZNaGe7Axq+Yh6kBNaNXA3EYZ9", - "0glNqYHUJcFA4UKX6JhZQSgAUFmTdAIZ5pCdV6ypiFuFt6P8IfdgYcRE3qSr3TZc7I06bjjEM7luOHh0", - "1NrlePxQP+7BTpa1ZfCxSKTbRbdFB97pWQHasFcwVOHlj+JQ1HOtyKHaV7WGAbqGq0WiLgUQkl3pS0rh", - "FcLMuQogiSD++prwbmg/IBxwKCXFzCWZABfcpRGMosykY85wCSjIgNJsrkTWR+7wGikwkfQCyy133lJy", - "tRA7bIxafPrV9st2S8O/QRT4TVh8dzuT+BJfizN5FgTh/lLZxhx8Z6Vk+kvSgfLhi3hr0tlloBzSqs+z", - "QeVL3Z63dC6WMFoEUy1yrjg2g42NEKrR58m6SYcKeoByARMV4J4WuabS2zYa4G9q4H8qi9RWSac3ZO+Q", - "jLni7Y60zCuKIr8PX7z50PXSUOuO93gpRY4b1PGd3f/8c11MforAiPWFwHpwCB5CDX5cWtYtgMO6cTyX", - "btYiSejLND211rP7j8LICXCyUnquipn2WVkQLphmqRLX9Z+wjT5RrTHSNCT1/C4ItiB6QIGgBfogpU0U", - "hltcxXcOfRGhA2LpO0KJpZfiS2DS5bm8Er0hi8WSABxW2TfNkoM28vDWMx6G3bBn1Rzkoc370Q8qHxrf", - "eKTgQ510ZsljuVt+wS9fLbXvVahb7WPQPz0XbnAAArTLalT632HCVGaYK92LvPt7iTrnc3Eunfju3Bk5", - "dnvslLvZd1tpE3AK5LPgi1zzjMrFV0k9hlcA9xk0rz/3lvZ26H0JsYhKsknPVpQ2tGGIVaGtHg/maDOy", - "Cc9+Jk+fxl6tY0+Ayp7BxyO1MLxDJQJtwSNUO6RjukEM+mxJCnqddabKr0+9qVYcHEc3FMoCsBT2bRUL", - "mGgo6l763HufG7me6tLdt53OXAkzACKSMKDR19S9a50pxw6vBEqzEIOD2vi0tkdTdiX56h28x97ym8H+", - "VHy3na7YBv6V76MjgxRAuf1nKsiGqjsKHb2k5+id757n+f0AaUH5cOcQJIIyPAGZjj7m/Vk47YaJOoaQ", - "oz/O2zXUreYVrMSOCM06UcCZNCkN/EHxKzklrPzQtd+uuVZYaW832jb7VqxFXKudPo+x2uF5NTtVZPj0", - "Oxc8hHXvXHY0lpRWg9Cg2TCZQmis731eYd0A7MQ+gWukObfuwgqhvL/YZ7V/y4KsstrfSh4lAiQNqtRt", - "oR0r1YTPZS65IZZBxF1Kpb0gWafTzjurQR3AayKLDxlwUIcLh8hKbJjFeZiZTdae4Bh3xebOI3vgZ8fn", - "GgKz39ipETi9bhXdX3Ja4hVt6dk4oc/mqj+Gln2Y++3VMtGrzRfV9HetnCqG5E8EqJCJKzkW6w/GqXQD", - "IwptVx+Lx8oK5DOl0jzoFGNd9AG/KwQQm/X6jGMtu98dU+ku4LGJMoFZSSgopISWRECJgCvSOkvqz3oU", - "McnGMyB+A+pELHvJxA3d4q/T0UzG7WugjZbAZQFAAeipgJsvDZ8bviAN9FZUTAP4hdVJpHSirrW5BOge", - "9LNyqS6RIdBpFrE8axddSW87h4GqHzC5WA0sJywTlnz/RKVOX3oNho0yQVqJ41VeIcdfoe0eS6/FaKb1", - "JSA7p4mixhj0YOdclTxP41SADEV8de4lZmBn2iUqPqY0ecq+rR5rxdiIKhAXYx8Y/MPuEayooDuYVOyN", - "dD+Wo4DExbopL51OkaMGOFSkCxQ789Zazv0seyPdmSj0pji54wDPFG2m0deEm09JYCnkzL5FFJWwYx6i", - "Z76cLu2f4o44pIz9LVQ7/83fBtyoIFog/RLCddwiUaDKOFxLm6qm4MI2u6XkZuVoADvtbiNlLhzPuOMg", - "t8Tu6jQ0TvkHIOkqn4s+s2NdCNuvEf8OE3UaUkQYgsZc97ujPx6dVe0yUAcNBKLI2LkXEz3wrETFPBP0", - "yQUYS2kbmSW/8RvgN43vXGWUvIGLPuBcbNAsqY1zl2kCFz0scfg4IggZRFpsEr/T/Q+WdaNMLOehm6K1", - "Oo2IFeRwiMalRXFqUu6zkc4WDQYDocZmUSBDAUaf94/OB28O3oJnCb1TiudbqL2xJC6QGpBEzUSixrKY", - "CeOHXXFENL4wZnHqcpioAKMiVTOP7VW/HbJzvx0C4wKAl9eAk3E6E+XdOcA8mghjAvlnzh00cALKyh47", - "PXuJqxBYG7wQemcB9luiAusH5HTVYnUisyaDG81m1sZ5vkMmfunKHYaS/c9xmpwjKhlkT6utzLq0nUQ2", - "4N7ytW7dbl51htyZXj0N+VAALEKKPqSVotEB/r2Rra8sxpB3ArseewcFMCiMRaCIAsWRVT041FUeze5h", - "sCrZD39Abqn379jh0cnRhyN2fvSBvft4cgLtnKE0C+x0W9GowghGXOlAJlg6Sg8bMUDrZCvYgYmaADwR", - "vCpQH9KEQ2q26hNCgCAeXh8h04LZvbomd3kTb7409xNrnx5HYGON7q3zZ/1xs4kaxTuxQyo5xnOH0u16", - "ghlWKveLBxzc2U/UpRCRXR/QCyTWM/o3xXMJWE/qxs8tSL1E0cx0oR+utML0YgFOLi8FmtERRQHGwinF", - "8wPpqYyYGAGwShHi5E+D9/ulmw3O8bJ4RGIYfsi+r3G4ywwEOLZ898lSFDd4HkcnFPjwMLoZdy4S6RMF", - "OiITA43+YCSRJDxmhyu6D+qG9DoMY2eWIbu+EVOh/K5p30NYEbz5g/DWOM+UYLnXQWi0A5Hq3rZ6GsJH", - "gLjjmRZZ77fYsLuz+f7Bg0ioDXwYQa85Hbc2lgfhij2WNj2DFabYLWgor5s+SbeuPfy3CLL/fnwaftdC", - "tdULKJWy2msIegLmXamMwEy5kpbYzcOdCNdKCvJ2TQuoBx6IZw14MKKILMo8yyDCB1XdrcGdzPgjOoCx", - "UmgrUeH9KGtbyPElMgfUPHK/Y0orJmWOCgrU8RZF/jItrHrhIntf/EZEcEciufP9tyeDwmhiPtJmGkoW", - "eVEIblgJ4GNb/oetXyBe/ysO0ItgsX6Sqn2Lm/YWOf7eUnKIBskyI6ylK1E9jxZMZqvcZ1Ag+2HxHxUo", - "pi5S98KKQV1HL3MbK6bfAVTx2iHvZ2gKpeZNGBlefQ/ech9EmX0E3Pf7im5n3ZeYa/mWbQ+H72Axe09n", - "h5ES3Kw6i1EpYqdZ0l3PplAfOQhSuezV6l5JK0dIxx016dObp+vVcsxl3AOEsdCVdiYd22faZACSNFqw", - "uQYm1zG4cYkqSm8uIp8Fa6GzaCpap1mhizKnU8gbnIUmigtQXD95fZnS5ELwP2DuNWJ8FPPjk4nMJfqE", - "g0Tx6dSIKdgwgM5V2cKkG2vcADBw7TsTZYXwBwacSH2E4x5pOA8A9gtPob+g4zcX85E3fv3rJqrxvlY0", - "yBdm0lmWho6quqZOkQKP2g/DuaINS1vUeoplHsq/Rp8hzC04qLqargug7AnWceTPGYCBnxGo8K3zaC5B", - "0eOj6Qxyi0KOeQ5jthxFGz5j2MfCC8rr7W0SR6zjoyhx9zWi+SZKT9jL7e3ekJ1wM/VTWJMGZmegEIyA", - "BgQCesPKFQc0nxOZO2EQ3BgkkHE2B0bokMYK/EPrzrwz2Fl39M28L5AVD0ppB1JZASAjV8CsiHuY4etA", - "D3mZ5xfg+61ogfmvtQVL/ZWjBxHDDjin0fMjTtfgm6JMeynuV4KNkoUweTy3mo382rrVXTp036e96FlI", - "813fUgJWuD0mpwq0K1TJXcvAPrNmfHjv1mYhSsRrM91Ez1DTgona9xPMF0j9PcB2MSSXn2O4REtWPgiP", - "6V92yrPZKctJQim+WDtli8KldgvBltdYKQBkiQkYKG4M8MwEiY/Z90zkEg74j2cneHIAhqY3DggAmmAR", - "EQYUmSQmRs93GUdeijlXfOplo1RK5P1mz8PAH+8Hx3+6OP34/cnxwcXHsxPWlUMxXCJcmvMsvuZokSip", - "JoZjgWRpBEEEXQljIV97s+gzqaYGq5sdd3LMjk97YHcorRA+dH/pzfww708/HL9/t3+yizpz6cVQcfbD", - "3Fgs34jUmVwt6FHLTjSCD2BojvErLTNsOVIYFE86StOdSQfzz4XRo1zMqwYUWhtoVgLmTrAOYRpW1A3+", - "hG/5HsVgg8Gw5kBrIa9vSRUJ6WMUksZBmtLsbS7av8uj1/Yqzn5rQKbaUSbw7ayj5BlArj3EWhrlNN9h", - "2UoV2Xhhl1+NOyKHpAK3IPLcCgZ7IzLGk9D6P4KQkED1oSk4UU3R7Q1ZRdA4ZGelsiwA2I6hMEljlwzs", - "ZggLVY8nyvi9ZjVBxeAuHcPCoPZOkMhSRHJin0AW45iraQ/iJUyXzqutZ64KOBODUP8E7cS3BCcY77V0", - "95KUfDw7uVOkjS6L1a7rPlIietcN5Reu34Nw3LTMuUHnCli8Q9ofr4GDZJGokcg1GL6su1wp/cKypAMI", - "Uv5nuAuA/IGPcQyUZejK9lZWleDbbzKw70e4q5IELnq0ElewMLx/PZiGz4sWBP6hXvDRWoDgL9ts6YEf", - "4bmKDuDrVi7D+J8ACQsXgfGamKyCrIgic2vTfxIOFgZk7EwWVOyDicaq4jRAwYWiATBkojZYk2ePsvob", - "Bb/6hCXqr4SUXDFL20+0qb6SOX8DWC6fNOFr40p/rJ50fLgCkvoBmGStKfMNqu7aCM+VJl8lZYEFZPpl", - "S9tz6HqcmsfQ9VukxNdCFcESvaULNy0KOM5d5hVe9bQQPw9TRIgJhJOIJQBfvFJqNSf3s6y2ThtslagG", - "eWjTPgkLzzKRsa6MTm7vN41jtp9lAWcT4o+Ppiu2fvEPPV7fJncGtabLknLPlcJC1WdaqyWP279JmEei", - "Mf2iN+6tFA+gTx8fAgcUfM2KcXBRPzu0/LMerT9F/sNf0B7fXsok2QA1czuHRDlY/5ZIH9DpdwJTr393", - "pIhtyy/128e6la265325nMtmro264Dq7L7e3+505v5Fz/86v4V9S4b9e9m9nkTaJlvcfenTXUfofevTF", - "dLw0OzBtaO1kW8zPGiVs6xutqlVvqq3YfrVOIk/DRRtcABrjrkU4jZ2iD1qI7btvOqY+nZAta0WKNxVH", - "V1FNUktv2/qg02lsi9tc2InGeKbAU/jCu3spH3p+bTZF+qHeRRWKFmbcshR4ry5oyS8CxjHi8yeqO+ZK", - "6fCRRJIV5KM3ZBQs5kYwcSPmBdQvVD7TZj9qP9a+ExiftCydaesu/MmXRjJuaBOwD6lefuC+O4tBfWw7", - "uGc3afjr1i8zbme/bgHs0cA6XdwPM9rf9Tio0T9ykw34KCaLx40O2kIWIpdKhHqq0JqQqC6mtrCPJ+uF", - "Lx+yVzs7VV4zrKIMLGzQBu//L1ERCQCHupIcbjk4OYaY5IxfCaZ0A0Unvo7TifKzxbqhmeLg5PgFlKOx", - "MVdjkW8dOJMPDqj46loTDa7ts5F2MzYS1g3EZKKN200UYy+H7BQNlK3AbtQAGPj2FniApZ50af39jGEx", - "mN8uaFjXmkKQ/IkSJvEbcP/Fmx3kSwGCYC6G/s87mGgmOBupBpGBDiYswJ50sYOxB4AH8O25yPr0XCS8", - "LNUo12PCIQFcbyBNgudsjcRUKgQzmOSyINJAuDssH53lgZmXB+aqHH6hhDtuycFYz6kGcTwr1aXdsov5", - "SOfUw/z+AzPavyA+rDtHiigMLuMa4jewSM7XI/bRGmynXajxFlE+JUpfCXNtJMEutaL5/+D317nTxbG/", - "ZZNsT3GkdTbDD3G7Bx6dp+w1e86WytqXc+Vluk4atqxlPludBkSSO4t4g7YLCfrQyzNkr7ZfrVZjier6", - "E1bpCqSEGX3dww3bBMNAhBBAncpIB9RAQSExyq0TEReESgbOA6P2P/763yzk1lfUgpC9UsfA2FxnFNba", - "3Zbpxkx8bY2TQJQO+a34FQ0Ih3sLZX9Th3c79cn5tUSKvZqUvrCgH/0HzHTGMmkE9DXG4yhIc8GnYter", - "7kEsZEG8ehLBorSzWA0VCkIC097QSygcfY1Shhe8dPoFYpAHPGUHyLW6KoDwL4FNv4x1Ec11qRZrK5SX", - "UaEKYpqf7n8gHC+GoNK7fqku/KN6Q3Y8IecHNwf0C9t+vdJswvM8nmL+IYXOc6SfyJjlC+v3p1QsVdqJ", - "dAgTQ5ekEc4AMqNZ5OI2bCJwCQB6HcEUrryKYKwLd1+EP3mFoFVm0z7TVGXcw2lcmsNgqr/AVyBcHgQN", - "0VVlDyzzXqQ+1Ipl/szMVi1NfGw/frieTODwRjmCqbjmJCqVTNSMJZZVhSwWauJAbyKXOM4ysH3r0uYR", - "//wObbq65bSp2M4XarzpztMwznOReNx+j1UVTiHJBns9cKXDmL+xKuRjBU2e8KEXqNQeU/FHmvnACX+r", - "/ZqwlL1msCiCn2eNbGHt9OYcvLaWewQbtuQINECIuultrIe01zYFgEINihwMpi1QedgZr2PEKR4V/Vgz", - "C54QKVhAasC2eurejy7jKbeWRRCzXabKPE+BeUPPpeshcrrj4xnqGXx7Pzqab6ETi3FLtXJLXmgEf4mg", - "F5n2PofSDiMIe+sVFOvetvRCT0/EMbNI4M7tQNpdxlEvhjhFLSqnI+AZtPAniupVsWd/yk2Wex9PT2jJ", - "/KFX75DSeWYrnIMKB6OstZSBi7e8VKMF6GvEyQmvbWp1idrAywgnWNeIgfUOODLTVNYErHd1CzbWuvrL", - "9O6rzp8ESSAO9HxQAqsM5lgl8UiG89fM6H2f+lmsS25T0NwxzjI5gVo1t7ZB/34aG2mTbivq9jCx19zM", - "37giPfdouvy9yhfs5P3B/kkFo9lUTYUQpgdOJXBmc2vlVIkMOzlj7C7ezA0xuIDKGS0AVXKqiJwA2H5e", - "7ey0l33js2kO3hPP1GYI1nAoGOOZtvGaZEHYxsEt/G0TrOFSYM8KUP9APUwjebAqs36/rUfezFOHwY8q", - "YFnA9GlGf3/Wo4BAugqf9q7At9+naK7EAHBbLDw4c7VoeG/IDkVWFgK7rAsLdbkFeFaJqvo0FMGfR+ik", - "Krr2sx6BwfJOmzn0g1SRfv9pmRjLTECYyoi5UI7n7MpCa22zjyRR3fo1iCcUcHVFdmFnnCBox9pkAoGZ", - "nBFieCgnk0QB2K7I7B4+O1BAD+D+Piu4cZLnA++5l9DFPNZXwiz6idKGiUAiP/DubE6NK71gPvonEve0", - "08gj4RezzHNveeKsLkON4F8zIycEkmkL6HRE+yr0whAmv2U1e7nxxd5Amhmt0OmlOL+CvmmY5G8pmcKR", - "L904G+pR/IMVszkG0Vu0LNxZJWPXnkc/VaQa4YUbrxnyFWgsIyRLogggFqg1qzdnVbaDmVIhDi9OJ4uB", - "d28lwqqEfqiJzIW3/gthWWGkNks5gC0jJnYLusnFhd+8wvaoA1+H1capiUuBq7O6d9m/UXsxx4TnVsSi", - "jZHWfq5bizZ2HvGsgqkhbZKtywHQpRGgl5gGyV+gHJQX2Aw2f++fIz/wllrNvJcRIo6r05KffLpgW8N9", - "SkvO8cpN18weZ/drR5KZXT5XKBDp9NdURgu0elU31Kp4S/y2h5bpbdRGX0G9lC/Y0Z8+HJ29a9jpxNS5", - "bKvP+QLwIfCD/X73/wv9NjzifG01DaxABLvCNgfRpQ//oDfZgwAj0RAPLfU9xxn4pynyhe9tlf8H1Py2", - "67utX6aoa9bW/X5UtiY4Pxg9v383F937ZdT9IrVkmM5//PV/cBqxN/VL1Sf9zykwpmX97MrfZXGhqOBA", - "qom+FwAWhlvzxQDgOYA/M0QWP56dROzUH9/uHxCGYqKW86krK4lAk0YFivozUZURnoIKRa9hLAvugDf5", - "FghBdLMGfvJqvlaoMELbIpcTMV6Mc4Fosjo8KEZ6Z1xlOSRASftuvwIU82vNMvC4xsj+aftAnwg+WCkt", - "zAogTwHthTRil3V5j2iUuZuBIZyygHRohNX5FSKPqEUVgedQ34mAHN1Rr2ENYBkcACzHpBo7gKJAhFRO", - "FGAqO3hVPh/JaemnCyCKwKBmKaB/LQlESmCQwEum1USaOY4l1Bip+7zDISD+VivPqYsRTBO3iUo6jUOs", - "X5tiSCyENEzSWV/lQLUQx15ENw814IdZZ53RZWystcmk4u7hIECbzaYdycioGqQHfLuYC+mz92crhCtR", - "jXBGfScCQ09zRQmyszdM1GFd6EYLNp4JBAJdJ3VUb/o4fsVPNa30bYBz9ZoIk+shWGyFgxPvySo7WpWx", - "f+jaXm6ozR34M2zIDo0umr4BgMFKZxl53X3m3e4+eOcMve5+ooBOKYRU7JAdCgTckVeCCaXL6Qyhgrwh", - "IkyAxYtcUZDRiyyyoEgqmCbpVreI1yvL79kkDtI20tnii7YIH1xLHJvMY15DZVDTL0ORrMgYlCTdHWFd", - "3Xy+cv63n7C0/inrwx64Km+EYzWiIKSpgm1+HyXRNm51SZipH/0D15R51fd7LAwk4B6EHZ0ZqS4RVd4L", - "CkTzUP8mqituoPzwouDOf6ftszm/uYAgnJV/Eb092uS1fTwSjCP+WaKszJGFIhODQKwUjLS7cr0bze9+", - "TgPJv3JCjxPse+CuOvWCXtWXB5n+zNQRHJhbk4Dd9bAtuAL5q3J6SHqoFxxO1VhbWe9WmEqHlo4uEeJa", - "JSoGhoLXM+Ljy4bXs5Tf9T6r35Dw4CxUIUqDQXSLVZJ6iUxpzsczqUQf7qQfqX4Eaulr6d3tf08UhabS", - "TDgu85Q5gdWB1TMxPk81svDF1JcjpGH6WtHbLKwTc+a0zu2QvZ9Lx1LId6RbqVBZ2njK9Uzn+Ky9CqM0", - "UdCd4T/65WDELbBYj/PS+q+EpJkqoZN5yN6XrkB/Z8yLAmtf8Bu9xvqL2ILLodnTsm7qTKmAj3aXYZII", - "EkAz6Xor0ttZCIR4qdqMFvsBIMx49kwKzA9/QA9qa1LwyxwGAtVyjz3/fe1rnixf8RQdaR9ak7petnAf", - "hn3a2G094FdxNlFRD0h0tRbCMX7FZe416rDaeuIGAKJDvR6ibwJsoGaZBtpwwbPQivdcPW88C4qvi9tY", - "G9ydBlKylN28Hdp8YaNC/GTtXmtW2rSS5yw1JfKphgjWnBdehRMkX74YUJERCR25VYnqpvgDZTfTXkiq", - "IqQ2GGv+FUsw9DORO15PYO9Sc6bTkEVtNGCJwKIRLLwh89oIUN+pnLxNlUHH0/cioIQ+vharBqjpsU3q", - "rfqAd3NV60Ko33oPL+4NyssjEG7t7EbyXTp2oxtD4Ry43RGQf0vXb2XaTLSZA+/Al6uk91XN/aH1lzZm", - "1amTMtZB1M3zJ1Ol94xogZAL81HFU2JJC78vBDWcND+4pljDT/dRrNh1uSnNCi9LEW2/v4RyEqwxQGcZ", - "sqB501+STuxhTTpoq/0KhNc8UWFJr7lllxLaXFkKZR5whfJuuv8N1xmLeA5OjmEfWGrVlQp5QwdQelMW", - "/sAW3OTQS+6Az3CKJeoSDnN0SK4Bhxy4GhJlSsWwndZ74EBHoE10oZGh0G+Yl4OZLg378OFkpV4+wFnf", - "tLLEYdZpS7wix84pQ00nX02MBt8epSt0Sy+pgUZi8vO2CBh6m9oh50Jl3vIYgWOsJ2heFXyRa55ZhsC7", - "SDoR2LdUNFOGiXqLqDXs9TYZpAVo/jyH/NU335w7I/jcP0CJqXZI/PHNN7vMCpWxFLmFd1ld0G4GKvPC", - "lkIUyIixkFdEh+qNvUEmwLsSGbPwcP/W6TEVrAE8+9GVUC5lSKPgrSNgJL8CUGOBJmMfw9WcpTPBjRsJ", - "7lKqJnu5zWxvyH6iZhLMYyGRIhRLgQva+ubw1r02EpxE5WLKxwtmpZrmYvAf5+/f0Ut7f8eGPZJWFCp8", - "EnoWYW0SFVCL7MptDY+6q1wvbZ9rG1s6kXrAz6zI4nfQJLbOc5hTqBiFKrhdlt6al1otHU5mlb/AuWyF", - "b7qlgfqdtvdfyQ+yIbuTFu1Z/OfbUgNqqXVa/EzecC838Bq4rPB/UYm9OwRhpL3UslW83gKO1M5u55ek", - "Az8mnd2kg5Fcx43zh2Y/6aBagN/M4CX8CXLf/g9zLtVwquGPcCMWc3Z2X/aTDkg4BIWTzu7O9q+Juj0Q", - "lHTSQK1PxZpP/8Sd1gdg1umeT+gnHbj+Yu7//fpV+ztlWonPeqGodOBCZ+GPO9s7vx9svxrs/NuHl/+2", - "u/N6d3v7/046y7fiXMWRQetecNhBYLvsbMehL6gRNuns/u7Vv8WLI/bDBRDP+F+3/ffh6XZ/GWyogTVJ", - "X05aj6GgoeSxLlXMQrCC13Q5CmSi4JOtd/WpuJ18WQ3kvVJBsfr6E6QX3YYvNS8eCnu8PzQBGLP3Zwz3", - "Ue1vW9F/mksLnQDP5DxsuuUWnA8W/E3wKN+cfmRWZmLMDRuVdkHcV/5/+yw9E84sBvv+rEzjKU0EbxRf", - "tuV0KqyXmWsuHetSOzwFYPEW0I61ZzU/5hYA369LNXXlaC7dshVlWXfOb9jr7c83/JS0s8ez/FotBhhi", - "oyelH+F5j0p8g7tjNhFD6OvVGaW6VPpafTka44HhhgNYkqUM84MiDoQVuqrM8CckK6+HccC1240FeHOZ", - "DbwvXtDxR9ggaTHjVqR9luIpm0kLjSUi24oH7hYcuP6a5gGd9hOVCmiyympwHdy7SMHXQrUHyGTLr5ao", - "BsQIRo4rBtCIIVaqUDKF3wJQHMDzmC5ZBvSi+AZL7wqQJ7WYXqIIlGgmLTArY8ngLkRVcLbBcJFZLpLO", - "r+lK9+U8oLhuVh8Es+UOdE1cW/KEwfHzH/Bk/TBLPQxXopI3PWnw9JhSwUGZcwtUaQht6//cvkMeViyy", - "Zn9Zwc14tqlIxRF2fBGwnRczBR8JzRy8KIy+kXPuBFOCG2HdQAk5nY10aRi+WGSXW0ItuhJjgMTSeS7G", - "frAhQ/gTiEcnyr/OAIFkMd2bzqW6sGNtYLf7b7epN1OlEzlUMhZGTOTN4P3ZIFKHJgqUcK/PUiqL8feM", - "cj6+xHssn1dNnj3a+zlX05JP/bX/+H/+B9DqFJsLMwUD2Gnvow0gYhP7WjJmuPeT/IuOhHX4TAavCzGZ", - "2ttXYHcARjiINL7/+Ot/h8Q9Weks3R7upKyLjZ1G5OKKq7Fgk1xDWJsTomAkTo/FO0YXjPtZ4P7I4q40", - "PB+ED4OllIKwDK9n2gp8a9Q5+Nre1v/P7eHO6z7bHv7u9Z97+LLixqsB6V8thTem2gKI4jhEFRrpK8F+", - "fHf+E77o0o3AmOa3lr8bqg7xcwDdMd0evvoWuxf9Eo7pA8c6EwOscCS5glqoXI4MBJb99Qc6E2dcXYLI", - "Dv7X/9WDeQepvXByLi7mFvtV/VbH+uiX0A075zkrcj5u7co8p8U6x222odaaxiDPZLYtv8QaPd2QfygU", - "xVspmGy//PbFL9YbO4pVujWHjJQlZJu9aek9ezh96i5aoro1X4qRV2aFu9PnWrbLwRLy+wNctxgJoFAO", - "eHp+wDY89tXeWhCRLn5Mj/Zx7bSkP6y1JvGarUx4Nw3orDflqeE2OKwNtJm9X43wTPu+/gJrmFwCEkJ9", - "6n+D27xZDqwHTg+qL4ayMzyFIIj+WbL7yJmlNqkNKYlN1bE96zlVf4F7yCul1tzsty+ufmag761Gnv8Q", - "LRsIATeXCK1X2uYaxcESBXWKOy31bgYAXHBwOmQmlJMTCXWql0INE5WSXKUIv+v/Fyqk8gUT88Kh05IK", - "lV1A3dp33yEwB/yLbHziK4UZU7IohLMM3gKLAUi6AygGyBRAo/HMewOJQsNnj6LlltkZ3DfRea6vWVlg", - "WDTaSTjBCAGOtTpYVBsBXNtNURT6uCibgmCiAZ5pf9fGXweoEWfht7+roYI7fC+limFvfN62pk6xzR5B", - "5zTIhhwmePrzukuNV7jHQRSm/bcur+d1N91bTN5UYl0Mz2zFk6n3qcIbBvjlrm63c7py8+1AYaS27Eb4", - "6aupqwoJDn0lzJUU16zrdOEPJOgpHSMVA/WYQqDa9jbRF7dGBJwRG+v5OYG+Z8h4zOcik9wJJpQzUlDr", - "D57M2iwAB+B290+t7B/af9hd3T+IVWAHubwUfeg6zMWVyPuJUoCPVRoLYVFsrcmkQZRcABYDs6YXYeoQ", - "uUvr0FHUwJgLrT+sa4WoenoC4FlvyI6UMwuGhcixxSZR6/po9hDSYDiVLq1PjQ3RzFW87wGqxi/lZs4G", - "/+gnKk4/DB9+gggQbYogXgOkYXDRv9prWtprsHmGre+dSdRdzTOsrXfmkRjXaoLejfu15/XBI7e/1Ojy", - "7gJmwerJissdAuozbhtF74w7x8czqO24ViID9OdcqsuAflhniWAI/+1vd9o7Mtcs6VSYC0mHjWeyIBYf", - "4NuEPpdcYhr053JehHRo9Vq4avB8yIccgV/md0QbjKZ64QDpBTVp/fO8OIDDJrDKSTooAo8N84H/4kry", - "CmoiQpT7yWIjAZkh/HyIooa2+zpTPuDFjIRQhEZ+p0arZugJDI842Im0bjXxMnzKV2SCwDarhB+F2c8b", - "hzO31sWxWcPjjmqFsPcoWRfIY3bZlYAzu18B3NRgNxggmfa9vHvRxf2T53zOB/SgEM0H1M4AsdRN4b6L", - "XPNMZGmvT12xTE8S1UIAiUnMeE2tiy3gTMaSjp/1aBXL0OarAnCEtQVCSERGxQCfKcZLSQiY560408R1", - "1m20qSyZtSPRVNbIUnO3dEBNL1hWhTAMC4QKo68klLSPc11mk5wb0WdqaoDU5sNMJIp6GuKVY27ACIXe", - "b3xf6qHGzi1v+xknMsBdKquSHrbFks5YzxHrVat2qCW/4z7QB21wsXGIA+54rqcrSj/C59I1D19txKBE", - "TqEwnTY0ecqw+LXFDivbttxbI6m4X4g1614AsSLtbwbgOGHcF5bxqXeh4DGL+vpnQQCA2aEwwkK9LSk8", - "VA19OJ+8cbAVdQxaPCIiPJESGXOVKG/+8DzfKgGbwp+SsbPv4zHrzrniU5GBRkIYSuECncShHl967STn", - "fAqIvVQB5Rg9lJCe/V/oOci7lHE7G2luMrAZbKIIbYlug/8C5pBWlnXR6INKEgCAWC+c34fJ37iMwkiL", - "VcfqqTCDuDNpKUmMHkFg972EDBqPBd0RRvxUUd36Jdz56xatArjPrQ7wob5W2H4E5xJ3wkIrslclDdGN", - "2ONBiqJVPEwUwPhVOghsO7oPL58LdDKFgtx2oroHx3+6+PDx3bujk4vvj99dvN1/t//m6BC6Xns1tIga", - "FN+/txezwQfWV7FzHxiv2uSuhvIKjTHVrvUP8Lt2ZQ/MM0rpcdioe3HSAmvLY8jsE3mJ37eJTRYR36K5", - "udm3CNsibCBG1PVLaF7LV/HVmr+ufHsP2dKo3Ffv6DMxyO65qfvejMj5OADB0DsmaqyLBVTmOe+O+Z8C", - "Sd/ECXPNDRaKmFJFEaMDCiE9E7WkDNbs9tX4Uv/a1BFm6l9b+vG2NFlHrTsap3vNPqZDkPbU5+1qdBPv", - "B77rdxX009AGxHtZFw/SLT/u1kxb53dA8CXGWiksHQvUYUxBDCT2u3rjj8jYrHApeROVEauVAOQIBDpZ", - "4SySdY8fs3kvAsdp62un2mya1s/dCo8DQvpGuKZZPAgi0ljAQOPYJjErmKFOURQiPpkXA2+Rx8SFN8GA", - "BM8y6XbR1AI3EOlIkFcPRunT7sNfdeFv6CPYYIhYRKFCRkNmBD0GcD8xOQG/AOLXpRBFk5hGK7GHfedc", - "UTkGlaYAw6Dg5i69XxOsDWQLakPgoE+dSMY3oIBLG84J8hk2FT/Wm9CiRr2//XQEnY9DQvo4W410ddu+", - "QljVosgXTLr7qmUS8bpltYwYBxfgynWeUTboRdrMgq/BHninA4QHTv2TmQDBoG09+uvWbuP1mC1HVC1x", - "X1G6FUlecXhuPt56p5pZijuG0KiuOoOxS2Km80yY3qMEPJqziyNaxQs70/ferd7+Wu0EHVuLTG9vjj4E", - "mw3vfBEIZAknPN2aCZ67WbpHGhYOm0QJ6P/CwitKU+EMiWyK/AFGl06ERsCZITjtME6C8ZIYy0NUTkio", - "Yy/KwBlZIHznzyXkGXN5JZSwlEFsOx8/CPtk6sePtZqa2v9KxxHr6svvAKIJfb1SxTRG72tTRA05PfKL", - "pAfeiCGTWl5Jt2Bg+t9e8bskN3Anb02lm5UjQsK/LwXpCwwEA+gg6778PZuJG2+yGdvbON/RKW6YUDuC", - "oly6GbSELApubcgop38a/FiOBudyCt1nYrDz+vcVVgBAT4+QK2Rw/uP+zuvfhwZL2ncAAc8uxSISHcei", - "lhcNcr5Ae48w/+mQvaXWa5ExG0a3iYqFMC/3vCUaWrZTJOSo8XwM2XvFOEMzJy1KO0uRxwQW2EARDxsZ", - "rpCiOuxqUZFKLtNJJqqbLZM6jkpjXeAtkcIiyTQxE6SFVNO09mso49nZ3sZKYqUhh8XEZAIZbqsxnwic", - "BozoO9ACmuT6GpOq7eC3gPT0BiSRiBPuAjNqrNpVwEvS2aLvZXEg1FhnIqOS5xnfef3776g7c7gKjKhF", - "Wjp3MOiseA4VWyE8yh1C/rkOBc8yiSXmp8ZPp4O8EO4qGgZhsJ7al6AF3CdgmtYUBjhlhik90EUkzvGa", - "9jG5Ee/xIoeBsyfA6LBupEessSNKL8FyOmtQTG32NEAGoyCLTSyHp4Ca+KhithgKYkB/P9RbEuPSSLfo", - "7P7nn5vGbkB6I91zi1Kpi1ZSH5X1ukx5S2XTAyqZQpkl4Iz3vU/jjwVki2GYyR9cy0wkgY7sSlo5krk/", - "mAk5PYCiWiFsva6EQBUCSz7AUq7IPz5NWU+jnmctBVGcnlw+oC7wcfxurIrL89rU1gSi9kcIZbV60gew", - "EnGkDQV5lkb5pI6Bl4+/yOsXloTzoQbz+psOtJrk8mFwuI8hQrgyiDNZidEqKWpVLFu/yGwtgdKZmOsr", - "YZcqEoHGO/7zItYK1ooAvdGIbTeYF5M1JUK1N/7JGVQbvn/HDo9Ojj4csYP984P9w6M9qpBUmTD5wj+h", - "KtFqEoNSzZZWg0zaS6Sos4nyI0A5CJBBdPHzmAO4hoCmsFzqSBWkiQIHLBPWi3ZvNUFTc+fdk6LpKSsK", - "H0PIItfSnQK2mklpzURtP7GG+Nqm/41wFRrhPZZgPe953IDHh6z78eT4EBooQk4hJrZGC1Kk8YZV3rHM", - "Ptk3DsRNbTmLTZ9lS6M8U/fbWkkNjEjXTy+xX9XhR3mL6kwJlcSffv7FA2At3Xl8o9Nw9VOICA12f9M2", - "+D0PMnGfSdmBTRyNiVh8zbDdAJt3H1MHPp5Saw+fKyuMs4yzbmUryawfPvHCD9vzxhTUBSYqvW1Spc0e", - "E4j9Be8e0sRg/Yy8x5eoFLMA372glo4X6ZAdliiDot7O1nyodFbkEyhVKJXTJYT/vBdY8/rAngKHPpp4", - "Nfwx2+4BqstIrr5pzV4b7Lk9FHqNqoukbcOegEj/S7ev0APqEtvCqA4iSmpMBz3A3Vlm0V3n/lScsXdt", - "4bYt1U8UtOUBbbZWzHso/QZJKUke+jDLbVR+S0MJ7/JG5Hle7dTWChDo0KoR1H+aq/KRGry+tvMDndUa", - "LywV7jd8z25kcY5OYVy33r0PlYcfG/17pKgeLSe1ZjdUGJitEcZlEEsiM59wZRmQTVxr5ucmzzHHPyB8", - "RIR2oXndZZlQVrDuWFvp9wJ0bCExGEKa2R5sAVtw4687/18n0gn2w4fz1+z7tzuvEwW3EK7rxNnekFE/", - "ASw0pJeudUCSzKHEy2+VSWlFlijv55+JsfTqiufsjKtL9kOJfCeX3/1+GzNI+2Ojra1RSir2978NRrkA", - "zMMxV5nMgBIDMB676d//xv7P/2aj+c7rC6XNPFHfsu7Lwd//1vN/hi+Gv6eYzfn7377bHr7uMyBuhAh5", - "btlcqsGc3yTKX8hzv4GgbQHmuhcoP4zIOWZYZ0bYmc6hw7x6oX/8v/8fglD+n//Ntoev0h6AWNa+BJoB", - "IdTLlE5UxNIhBv9c3EjoI74SJudF5KzE1xiy09KIAXxQoiZcDfzCR2/RX/cuYJiG5WRGTLnJckR/TRQf", - "WZ2XTngd6DiQ4ltd12tGl04qkS8CHW+WKGkIttMxDPhwx5SWVgyge5iRNFk5lzk30i2w+gAFZgrlqfIm", - "tEKOFoREBDCbjuWCWyQspuSpuwYKX1wXp4HZl80FV1JNJ2XOJoaDsROu9xMOYgOkZIj+CU25SKCi2KiU", - "OY4LlQpGj6QCiCWTC34l1XQ3UV5gBy9RUWEQ35bmSl7VTz1is+NqAfI92Okz4cbDfqKI0LOo7QSr4Zsy", - "PZcqTJwX3ReOOX4pcJBE2Vy7IdvPr/mC2uO8wac0FGJM4YWZEf4LMvazHgFlfSZGulTtUJ9RN0eszzaF", - "CeJU6bH/WqvE5lKdCDV1s87uy/7KJObSI50uou3cyGASKmxn9+V2vzNHDqDO7mv/D6nwH9UoFRLjmmFw", - "ydsH2akPsrN9j1GWKEUB1VUrZvj1bTEfsgMUt5HI9TUecAD863c9MLySxEynfhsiQjAR3Xj9gG1ri/lc", - "OCPHhAbeECLEnwlIulZj1j9CCsd9myhENg4guuRigB4dgOjBfsUdGOJY8EO4EzHCoGPcCD+4yIjncbse", - "qJ1ok6gaPBkNEV/4WoiCNroS/gTQajpwXObAx+QNpq4YTocs6dSScLHGkYwX+EvSYRzPAZ6oubwR2SDT", - "cw7cZjEaVjEDLQlGhCpul4vt4at+Z+JVvevsdia55q5Tk5SXNTnZjnKC/cgbbqNY2sDryQdAOp4cr/Zx", - "jMQfFyMjMzgkvkWrhKQ9rHqe02kj1WfFGx4horDOXPOH+D0jVed47Qal5o3RZXGc3RWegsuYzJbzSNIy", - "yj87/SVzvz9ieMtPwJUU14OAf75qOr748NaHxlICLSqb8wWZmRCsg2/0n7wgXj7mNFSQIVnknC+oACFQ", - "XsINQ/bHqhpBqxxLEkJLOAUCoIKrIU3UayPzHKpirB1ABSgZ1Mg62QoN6V8gztsHDcK6Kew9PxYN8Ulx", - "qhYv/RxFpcHX+AXvoecMKMFUNbYaiGe1Dz8jioSKeOuXKarApTDScjzGNoTsB6PnlZjdHY6xX9dSP1Y0", - "50pfNlbtH3/9H9QoqDO6qHO0QXXS+2JU5i1z/o9R0FaPQXL06YYCVt7fWSK2xG2jL5POr2kFIFUhYCB+", - "DqMQjHcOpGIvE4UsPxUF8evt3xGzaPPJpcI3WiDDouDWG9W7SWc4HMYxsb7j8HtWAM40l7kdMqqQJk80", - "3a+b5WkA5Q+zs6Kf8kecjQ3aPDjCegMZ5lJaRjPx2AwIn/IKcTnIAzr8fqm3YE2B40nopQAon1DNuArj", - "xztJTiiuxuIuFChaae98ZSKXI7+IEPvRQ3bsANjZAsUiBnFywZS4caGLJOOOj7gViQJAGoiDWxZgzepX", - "MKUDwAtSUEH7PsSepGNc2WthAI0N2hCQPFfA8AMwPK6lyvQ1OolTTlWVcw3t19RKSGyiysYZz6V1Qkk1", - "HbJ9FXhdGlze6PSmr7Zf+t3gP4/ejyqXSnVtJL0qjB0ec/g9IWHSI0a5Hl+ykZhJROZhEyPEXxAm7tgx", - "Yr3H72TfZKXXG9/U35wyFbv4N126QFEhc5eoitE3Tqi0wKhMQDbQxQ2fi5guGcTooIdVZRD4g1HKAqac", - "B0JMqCnlsR9EK9AAJXx5IAWP85ko/8lDts8KDRWp0jJxU0CoAPAThMqEoRCDZV7lhAeradJhhgfIMG94", - "QlRXGKNNLHT9WZcAPiiD4EnLstJESUHYT2NdomwJluWkzOFlapTHU17UGsABR7CAeaIQobRIsG81m0HM", - "JvShIkKq3+QUXoS9SSV3FS4Q98uR57hQunRjPcfF8GKKJc/Vy4Q2sNjQGJfvmvv5hMDkxOh52AmQabOx", - "bLjadhggRlB5kVsiZELiOD98KrM8YJsqjULq9R58PGyBFCKepiycyFKIp0JkpTDiSurSAvxFFrhDgfgw", - "Shbs+ZHWjo1gf7ql3R/Y40CSoMNfOXz5Pf9RAGiPwRaIGWGbWFx+pxO1sof6jXBvK3W2+Q7D2mDvw4us", - "a9Ov6Vr84tuAxJF6jbOAXle/K35vm1rHwnGv15unwy+dkeBGGH80+8PCe4e4Udssq3M+FwNt5FQqgInT", - "g0w43LcVpNbZCWz1WCVqCwGvUpq8s9vZAthheq1bvTRwsGHiiBCf/HFkG1gmI+9HrMi1sVxOxHgxzgXr", - "Hpx9POw17sQg8u2bEaS7X2Nz6VcY833YN6i2lygLqofTv28/+sPMCDGA7VVBDRZGOz0GxPpgjwZuvNtP", - "2D89Zpkel/6ICugIdFemx62fQ0dPn+V6KtVWrqe6dH0AS77WJkNIA9GP9H2lrXcN+ZOt7T28SY6HKOCc", - "VrgltVv9NS33Qt8pdoeiDwCG/sCOdSEy5r/wUiwsEpedHG+dH/7Bj1F7biEH/oqWR1deBwUnqHMDIn7S", - "aUhd+gcvxZebKzlMVK2JIgRtIEqBXTmN0z7ivCJvHpZWgoQkaq4zOVk0gVqH7PTsJcMaAC+VoOP3qldc", - "ECStn8x+okJHZD/qTXetB9bxaQxtxp7DHOoMFHCciP8qhXKJMiIX3IrI0lhLyk0EdvFgxx7qSZrjmoe1", - "zt+xu+icRQAPKxyM5CfFDtnREvKvxWlZKniIUbEQU+qzqfEL4k+bqmoCju+tyJ0IR/WQYfARJtJ/fa2A", - "CYICUU73oM15i+Jy3u7AS4PcTYBxZFrm3ODbB9sAvdFCji9pnYkQRTQmDJ/bMlkkgafCWMhs7MN7sw/6", - "UijrRwpNnG0rA3mRca4VKgp55U9uSpaqjHV1EehceiwAnvpLg9AM2Tmk4RMl1Ngs/CE94G6AqVzJ2f7R", - "+eDNwVtMrAJotPOHstfTlKZl4oaPXb5IlIZjRbHT9+cf0HBo4uV4M0yAkdKcGGifHAAOStv8vCXJIahN", - "agEnBHkNdIYOmQx16UaQuaSmeDAJp/JK2NDgCSYlr/euo/ktHbNekMiSfrf/YcgOIrQVDZ0o3JNKX+8h", - "7CSizWKTARYA5bWefP94SQhEcD7APNN56KVpVdfYx7MT25ii0An9659//f8DAAD//w==", + "7L3rkhs5ki74KljOrClTTTIlVVWf7pSV7WSlpKqc1iVPZqq7xzrqMMAIJ4nKCCAaQJDJKtPY/JoHGBuz", + "fY7zDPv/PMQ8yRrcgbiQEbyk1LW9ZudXlZIRAcDhcPj1818GicoLJUFaMzj/ZVBwzXOwoPFf11r9BIn9", + "gZuF+2cKJtGisELJwfngjdDGsue/ZQt4YMmCa8PUjMW3P1w8P1koYycFt4vTeMxuASIZC2lBS56dFfRR", + "M3afveZ2EY8jORgOhPuoe2cwHEieQ/0vDX8thYZ0cG51CcOBSRaQczcjeOB5kblHv5n+t/RF8nt4zr+a", + "/e7Z1y8GQ/e2G3JwPvgff+Gj2bPR73/85flvP/3jYDiw68K9ZKwWcj749OmTG8QUShrAhX/H0xv4awnG", + "un8lSlqQ+L+8KDKRcEeCs5+Mo8Mvjen8o4bZ4HzwD2c1Uc/oV3P2Wmulaag2Ha/kkmciZZoGZCe5MEbI", + "OZsJyFIzZKW8l2ol2b2Q6ZBNecoSJWdifjr4NBxcKjnLRPIrzPMGjCp1AoxnGni6ZvAgjDXsBMbzMYOc", + "i4xZfg8S5/VG6alIU5B/+4ldlHYB0rqvgiNQaVnGk3vD7AJY4B2mVQZuYlcyhQfQHyVfcpHxqeOev/0W", + "p/DgttSAXooEmFTWb2Lp+BqnZcrZTCQCpL21SvP5rzCv98oykKqcL9hMAzBT8ASYVWyhshTJ577GEwuO", + "54o145mScyNScD9GUmkxF5JnYxa/4pZPuYFbyy2MA9UnqTD3k+nagokZlymL3TjNv0Yy4VqvcTBZ5lPQ", + "xokDpAgJDJr935wWH+WCyzSDFDcJNAN6cuio9EaVMv0Vj5jjjxmO+WlY/dX8qjxbH/ckUaW0jn2FwZmt", + "8EApyexCmECuE6k8SzMhiT2IoJqlUIBMQSYCDPuvf/tPtuBFAdK4BwuureDZyDrRhyt6sObUs8BHyUu7", + "UFr8DL8C9d95uas0E14mX1xfsXtY01wKrRIw5tch/zuezZTOob4Xpipdu7mF66GSbHRPuDn+Sel7PMPm", + "lcB5/io866cRZJtnklq8bXFKovJcyWzNuIwkyESv8WOje1izqXKsz0VWamCFhiUQ682FXZTTiVX3jnFm", + "WuWRXAl3fQ8dUXibkV5BgdwllRwVWqVl4gZo8dflApJ7FDt+WpmaG5RRGozl2iIPfgraBqoFF4kVS3id", + "TyFNhZxfa7UUKaBwKrQqQFtB+gMtHimepsKNzbPrxhOkx7QJeQ3aCONEbeG/G87TNFPTMbtd8ALYkmt3", + "iqZrVAdeOg6N5D2sDeMa2PsPd8xY5YjuzhkSGeRytOSaOZ0KnyJ1y6tAauqUMcc8It3W8eKwxPHVq5PT", + "mM2EnIMutJB2yPDej5dqzedwTv8ZJSqF0Vfnz5+9+Pp8lilunXL3jttkAYbFECg3yVUKWew448xYbkvT", + "mlTQy4YDt0hU9GSZD87/MlBZxnM+GA5UAZKLwXBAAw9+3FbqmorjX+hLuMofOxZ/kabfC3sDhWrofe09", + "nWouE9SDcyHfgpzbxeD8ececPauWOtsm6MLawpyfndEz40TlZ2olQZ9pKBT7ePN23EWFQmXZBBXoJc8m", + "BhIlU7P98Q8FcRorQI/wg+5FlnAne8GdB/8qO3l2pnJhHbP917//RzgBKcx4mdnTxhzcoHPQYRJu60BW", + "kqU9/Gv8gfnnmFnLZMy8eDBsBdOFUve4898+Sb18ehLJE/8L+/OHm/Dy6Uum7AL0Shio1Dh3sIVhGtym", + "Qcq+fvGixTVTpTLgeHGgmJh0cXRFI5E6c4WH4/K9sD+UU3Z9ccdOasmqNCu0WHLrZlAoc9q5Pc2l0YhI", + "x8H5IOey5NlgWPFv9QdeWjUYDgId9vNvg6uGgRf7OFmrsnjnDpvu5ebSgPYE2j1ueLBzrEL8AdYd4k+D", + "08UnHAd295j7v0HKLYysyKGLiJ1zGQ4ybuykNLs/JsvMa0UkWHd8RRTuK0e8UPKDXiCLtWMBeLwn/eQe", + "DgoNM/GwzaqvhCkyvh6hFKeHHMu64zArs8wpJt74ihPxMOHPpy+Sr9KvY3e7vVVyHlR7q5iGRM2lO0xC", + "ssyZbUNmFkpX6r9dcMuEddq4dLe3e0Eaq8vE4oCVpt8tpjUs1T00l9c4jP7Hz9jADZYUTpC36eo3oCLm", + "sMmD9fz6mfiSHt/mZV6IyT0x+S79yB+FT8OB25vwRntD7xbAiowLVEJw+5Y8K2HMnj69AVtqCSmDB57Y", + "bM2UTGD89ClztiDgzhhISg3ZGm92Jxy9qsVWfE17bLWApXuYZdyC7tyrDVKG1TWm3U+jt8LYG+8m6SUU", + "/r+wkJvDSebH41pz+reyPGswU3ULdc/eDMIrnXMvrfojT8oy7xWGQXAHKS2VBPRIJRpykO0v91ASv9E1", + "/ndKWWM1L25R0eknoARIzWQaHu/gH10CWy0AzSvmWN8wi3euMAzywq7HHbfhxjw3R+ma8uWCyzlcc2NW", + "Sqe9ZEtKrUHaSeEfPEA3krBqPb5pgUmRlzn7HfoTeWJBmzF7r1hZFKDZ1FnEbomNQX63b1+2Jrkxic71", + "O8pdcgtzpdc3YPAy31x9Chk4AYPWsV+6m/3g/FmX+uRsmuOeLjUcfphwyh9Km6gcuo4U3T27vnADScZF", + "HpZ9lZLsxj9CSu6algAX0v72a9qNHSsx96IoSLB+kYX479WE3DRHR2i6o43LuGW0TcxdNMxwkTrxuOIo", + "ODPlrBlm+AzGe9bRdQO1GWBzZhs7vk3KXsYLi9/iOH+pdNy+3Nvye0wgFPT+6d7he487lzxbG2H69JiE", + "OEccwbWdPJcLeUUvP9/c/k3535hRa/wdi+s+zI+Ye5eQ6ODXtNTIixP64p5jL6QwiyM15y9wRi3Xx+nr", + "GxvR+EB7Ee31b891/66hXkaqQi9nBuW7LQp+KHMuRzMtQKbZmmV8CpnTelfSeyhZys1iqrhOx+yuoVVH", + "EvUyd6vOQYJ2iqG3kUfo/CYvUZfGhirXzjtw8zp2U+9f+Pdo9d05c/ZvuPp9cx4OTKKKcO0VGhLSlbvc", + "WFdz6Qxqoqh3LEi1YilosQRnvvOM0efQject7ycmkn8efbgo7WJ0S7+GiBxbAE/d9b9mCSffwvev79iZ", + "U4DYStgFeZtNWRSZgJSh8T9kRqGKNKr+joOyhZCWnGXVDRBJZ+yUmXXT/gMUFg3/KU/uV1ynhoIgVkxF", + "JuyaRlRZiu9lwskEMp+MFVnGDEh3x/iYZhAkWwTdVnnvKVa2y2S4vrhr0dX7Tg3eaW5aF69vR99fvmNT", + "mCkNkSzIpyjk/CW5YAVFxdCkbDmWcQXgPppw7U5jJG1rbDJVHsffYXk7+Fyrsujl8BZNfuk3vr/gwfOh", + "794pVRHu7j1DLp+JDMzaWMiZe5JNgfz2c2EsaEjZyRTcTW9YSqY+hcw7fUw5TxZCQqdP6xr0yP/OPn68", + "esUqlp9SYO3y7RU7wcP2r2fjRDyc1V87HbM/LUBGstBgQJK170P0jlvefri8eIsCTzg+S0Fadwic8eqs", + "T54DBhzSSGYq4dn5L/WnP53/UlHpkzuO6GznORA1lGSpmM3AaeeR9K+ZMzJrUgUhjJBlIoUx+5ALOpfw", + "QHFB8sj1OCTCLFDsbVNMmfEPylg3/ZPT4FQRIUobaOkMbb8zeGLGe+/Bmiv6Oeuj2eGWwzB66xKmv3Q5", + "zKSwgmc7zKkPkq5vFh6hKCusUDCyvDTWGVpy7gQCm2E+R6bmQo4j6ZiYp7mQzCy4BkPiQ5V2pGajKZfp", + "lij4XZdqorKWYY1fHAzRqbjfpA5L31qp/3A/jatA2KEipcdJPNMAI7cVrPFA5/n8oiKoFUzvUMRLqyZL", + "dGl0GUA8ZZlYAt2udNHT51AgDZlEMY+/eue3AevuCOMuzUgKPPiJ0trJAGdFyXW4cTTMuU4zMJjss1Ar", + "d/XMlWULCIGlHU4U8jJ1bPxwMM1Ucg/ppLZl2sv602IdkhEwkkduStQ7mRbzhUUlw51Y7hSc0SzDPyaZ", + "ksCUjiSebvaTmg6ZaORauAN+TyFEyRyRveHoc1x0KaWQ83Ek3zvlEJ0vwrrhWRUkPMD/DMaKHN2RvcGb", + "1+ERyrRw53bI4CHJytTJJAqC0JjsFepSabXDkay22IifST/lLAduMP5qF1qV80VRWkYhWVSOaJu5jKTS", + "KWh3rnM+l8KWKbB56fRcze0CtNMNJOPuVsiFqXWAnXZMBo+2RjZSRB75hUygKJ53HPfBtfszqTxOEeSZ", + "u7sc6aelpdwXqfDUuKN+5NgVD+FJzbIPs8H5X3Zbku9Qx5JcJvChevvTj8MuvYL4EfMAlEE/vWPiatAh", + "EzN3XsdbXPlpOHDUqP0mR64LX3bctd+KDWpRn6XqJlXv7UbEub13Mft//m8WV2PHeMJX3Fgnx5QlrnRi", + "0x3aEBwRTnS7xx+xfc0pFqATnziR8wd66fmzZ52foNylQUPCb7DwhpRWKme8KdHQL3vuk64K1K5WWlgL", + "si/rCk/xVNkFZeIxbhs26JHLXoJOfRZhFWq/J3td5TnIFNytW+q5o0eX/PYf6JXfH6SzWhybJ8DgAe2K", + "INf8u0P0xFEoQzqDj5uRMN0RV571UfbWCUDPCfFoxbOYOdIlXI/ZW65J13G6LFrCpuaiaQa5Y6/qAlxA", + "cl8oR6SUuSs351Y4A5QiME5U0IO4ZQvghTOm7ELIeSQp5uY4qbozaKxH7M6G1uCTYhsitkmP5kFtnfgt", + "qdh1HLv5f9jSOGpm2dr1bdndfRy6LsROPQhmqPspdAh2aMsynWRCQleoyFOoVxaFzJKO0K+clz79cvvH", + "3tF6A8AFx/hD7+9GzCW3pYb9DlxvTPtUlnp9fl7DmiCNZewmbK+C/FjqiVzYVhLE82d73Y/rfKqyY7Vn", + "/9a+5fVF2zR6bA93927w4q6o5RGHOcxiVwDzldCvpdXrnj06MKLUs5U7hAt9uGdGkFilMSLsPrNtXgnd", + "7RjJKMUtDV9gJ86MH2nIuBVLeElxTPYt00rZblcISHuUo/5OAxABuzZNlzIJkf9d4VY3qjNBSknxo4QX", + "BaQHBFwdKepJN0fsJq25/2i8+NmQdphv351jMTMTFL39GnOHfDQTZLqjXhKtdDzz10xYJ22ShVaYl4dO", + "mcFwMJ+Xs05FofLIdAlKZ+bv2gjMyMHpstKpCLgdhk0h4aUzflROGyXAOCuvUpmsBmAr0MBK6Qw7DJo7", + "K8nH7MbsYorerxy4pBvdlDkTJpKOoTKw0Jdq1isi67nuVlLc3KrxKwNTlWiFWDYFtuLZPaRDtlqIZMHu", + "AQoTyWhQLyUaODPWncRSmAUuDk3DaICnKRqQ1/j2v78V1nOyM4idbQm0WqcoIUFGZpEHhcn0KCuHBEdp", + "m4dBoHje7eL4rXTaKzlTHcHPx2eCNiuGDs/HvcTk21t8k3HD/vn2w3tyCeJjU0859A5RCjbxWpW9y5ME", + "CmtC5q4wLP6FHjxnf/nF3eVDCssMqbQnkoGKw5CKOWRuucOm9+nTj5/iMfuB6zRRKaTsBnhiI+mmYZjA", + "4Av66l4yYZ8Yp2or41MZK8+pVSojr0ZXIrCBRIOdgFx2uSla2cToFKwW7NjR4EiJBvQU88wMKTLBIznL", + "+JxZoAjOagHoWwCeLFDbpjSNbM0MWMoYD2GOcSQ/mtqZXYWtGpaC+7vPi6csci4l6EhSHIQZvoSNgMzO", + "XPdNjrxFiryWy+0bpDvL2PNbm5YHMb+7UbeZP5D48Euv+1Ttm349zkGTrelyYFCyyT0hd/Hy6s+TP374", + "l4vvX08urq8mf3j9L3H3vW/A7r+kl8x9H7mS4hknTqpJJUcoCk83WOuAfCnSud3gnTQJ1Umb7mXrHfm7", + "9S3/XNeX34gMLuvSja0Cg/BDh35UW0VtYr3lxjL3Ux29Pnk+mnJ3uvA6MGIJPenfu+2BptG0kcUKltK1", + "wyPobJVlljExw1ucfh8f4kdF/2fP4qge9ZGrI0XIvdwh8+7cj/Rl0v8qR1MGFMYy9z2fPUS7VKUtyqZS", + "6SSd97c7O/4MR0bDyhzAsE2zsEGvlnHYXG5zlsOKsfo40gdqu7NopmDsxCSKbNlKb8BCkEGHq+xwnuoI", + "8GFNycHy0M0d61D2ysAm/RoLqofsIw19fvuoLkp5P6E3urKmDjzJHR4HcKbUZCGOsGLf4zs/iM5UpSN2", + "rn0Q+0z6PqdHV/ZQB5cG0oSZDZu07NuFa77OFE93isyNys+7N6PfMQsPdsy+E5LrNUXumVk0tXBTTqlk", + "pvNy8l+fLDpr5W9/uBi9+IZK5VMxB4MyJPYvxZ1f3Mn+vYfmEA99t81fU7u1Fv/JPnLfAO9PEAaZ7riE", + "hmxLOjfD/BILdNxOtJIzn/ddTl2h0IZnwScdNCQ3qo/8oOwnx6C7bpzdS6Eo5YGL6ZBGO4jv5HC3b/Tv", + "4L7eIVh3eifd0m6B62TRy1nbbsYXe92Mfy1Bd1Rl3JZTmjAjAZ8yPudCGsviasbx+Mi0Jxpr3+K+lG9y", + "gxd+Rd/kG6UTuLWq6F9MwmUCWbZbB+KScSyuZQIrdhMwhhJymAFjhJKoH2FNPOMyxUIl+uyYveGZ8d+R", + "CgMw+HCVz3PijvxPajr6awklRDJxelNZ+IQ9zSWa9QaAxT+pqZm43zWkWEjV6fNpPrW9qsugIxYgnbV0", + "FoK2mIwwwcLM39Ds6B/ucxiNjiT6qHxieZ3AgfNGUYIGt3upNbWmm5fCofs4xqe3bVdLVJu1scquzfcV", + "sx0UwKyL34SaT5aD5Sm3HJfAZe2IOJkLO0KypKchkjuO5GufUvv8/HmV4Emn05ExAMgwrVYvGaad1X9b", + "8CVEUirmJ+ceIlp15ND4+XXcUTDnyZrxTHByaMTNGk/27bcswi9Eg3jcySF1sfC2pvCI4sh2SXF3tSIE", + "S/Sw4kazOLCwER7sBAuQeccVeDE1KitDfUXFnRjshAfLUs+3HCt7x6zKoolkqBMWmP6IVbBj9i7krFS8", + "7/UA979u3l4o6FJuOCePqgd1Mr1HVXv+25HT0m5/uHjeKLr0/IWXwRDd0ExI9vHmrfmcgu3rPXXanl7b", + "JdqRPLm8+vPk1es3Fx/f3k2uP7x9O7l6f/f65o8Xb0/H7CJb8bVhScZzZ06WhdN1UO/JlNL+5XdX7zdf", + "3JXMdEwl+J/QH+PeJl/LwokQWqQTQGmZgWYzIFSAmmkw1SySgW4kt3mGsgLvBquCSKFTKZUcUZKir86O", + "5LvSlhijx9Qpp4iRBGmd3//jW1ZXoPc69htb3lGq5jENKjSrKvUTL5OESyVFwrNIRoPOYv9/IhERDRix", + "TU8ia7OSfS9bl0V6tGjZLF7//Er1FuGaZ23YWcQ+bMvijRltFPI2VrjjRuov5nUjhQTsiVS2t3CiihJR", + "aoPXUpqvOxFg2MzpHp0yYOPhXdpPizmd6vLEvfyEXbx/1XBWRtKUiVOMZmWG6fvVPNwzeNEiq1NBRR9b", + "z4VFrWOfhhAu90foFPUWkvu7g8bvLi4Z/diqflZO/inJaM/Zb+gPS8EjWeHGnf3imOnTmR9jJORMjZ8+", + "7T4+YSKdYBzX5TQTSbZ2m51Q2Oz6w+2du3Iw74csRKKyk8oeI4Kur1Shnuk1HAO2LBidmWx9SOV1IGpj", + "R9rT3aJiD8MvyulF0lMNeRHm7EGckFOuL+4ogRWA4oKYDa5WVT6We0CYSFZuVEwNH7KZyjK1Iv8kLEGv", + "mdJzDHMZIxz1loJTWc6Z0nPjs8ireM0Tw3ia0oU3y9QKq5EwaEa4BJzdQgaJrapXKOe1UEZgpkAhknvQ", + "oZCAUh6VxqWk2mnyQlrFODMFJGImkki66TlLDjjqEBqyNSZPUgiAz2YiE5g2aUZ8PtcwxyTQpYBulXHJ", + "Ldf9Spiai47EN78B+Cs7QVJj9ENppJ7Jynl3uCN4DNufizB3Php4a4A2C2+VlywaKD33Pyk951IYWl07", + "MRuT74fu2f2ynBbln+pnwG4z4KK5e0tBPEJbRHnn1xd34y0yexVnUqvQXeU1hXpigjbE6NGXG+HBQsNo", + "JrKM4rT+upVCorOdrAph2vX0yGOGcdJHKh00E8b23M/7SpMQVqE7GEa6QCiQ2nxxYfOsl9c8KE1XLsim", + "06Uaf7hJ2fozjdH69/guVKj9nWO99CfaNWoYm/vwHRg7gtlMaetrBHG/2fXNc2JUxyTcYtUE5npi0V8o", + "sjIvI4lwG068ADdOJ1RF6f5EDNYsW/Sljr52MdwzkayM3LreDhW/46oIu/IwQviS1t7SpvZs9W60DwJi", + "O9hD1WShzwD88KPu8khhgOrLsOnOGqE3naVB7DWmr3mHIimNmNkzPuIc9HLw8fr9DpZoLudILduR+Crd", + "zSBz99BEpG0eOY6D62/0TuOASRzBpcg7n8Gffry9/EngXB32SZoeyaNHFAweWYw3PB4jbFgNjmMN6/Xs", + "ocTuXczxmSO30ZP4MzYzDLtrN38AntmdnvzucohbTHLK1iQiYsJAjDFHrJQL/Oi6OyxIj24ValRv7dfp", + "/Be6loNAxd/BXOzICy+zrBV4QQt42O8BWokCDJWoNLy3zM0CvKrvlPnK+vD+/p5Mh51T7t2FUvaBlpAm", + "iv6J6gh2JAj+sud2GLzjBemLGFokP9C//wcLgV81qzPcRl779WFWf2dEstJEA4kW3PhizSmAJM8npOxE", + "aRa7bUANKEaHQcGNgfS0M6NvM6xDxNhcei87XGJI4MD4zh5ttH62d7g3IgOzsyrhuLhYyAfAnJEHDyzz", + "zbNtsVAzyTGBvoqaNLN9y+ol4qKU92aS1I6r/QWWZkIZpoc/7wNrkE4eEw/cGHO4Oem+UXbQRAqz2FGi", + "TfhK7jAdpUUcvJchEYrmnQqTqGXw1R0TKKXR9q7zy25+Reb9L2zfGSGrPT34utgedosBeglwrdVcgzGv", + "l50JOB8kMAR6Dsg0719hsrWxGnjOwCPVTtcsRv/cGUrCM5xP7N1xTcMMZGpYfIGMes6amNcPI5n+ZJSM", + "yfEV46gxpW9H0jGAFrmQ3Prk7iXXgkvr0WhDmjfXUNl4KeMGLb8ll7bLazTlNllUhbPbe0M03PVbkzG2", + "n0FMZQ8udUD9BoQtCJyAOQ4ev6mq/HHj1v8k2Ob63ylV9tNvGHUcDhbAtZ0Cmg+0ZP8UPdClXs54Ww9r", + "lrO4T+Mu95f2tcXfESJv+9EcjDk602qHUmHNI+0z2p295yhUSGy4s/2vrKArj3ic0ipGIYvCc3RA+fF+", + "XGTsl3SKFsIpBiLh2WjGs2zKk/vqLVRZw6vxBoXjYST935DW8ZBaPrS5OO46JMdKwADqWKkDG8pYozSe", + "UvkIesdrUEMmYQXGkl/7pY+PfjVmb8EaxtnHq0iahVp5GA2lV1ynLFdYp52WaNpzDEF7c1+Fhgf9pDsW", + "DwoyXpg2XkTNT6qcZtCXUHvMRfaIu6SxwQcUHS64admcblPE0q15uPMO2nG8Pu07Hf0XbeGf2Kc3bh+2", + "1iW6gVgg0swDE0hVZSuh2n7GKjYo694dY+yGRLlJsU89opforLrfK9rEZ3GlNMdnMWFKxmexzymi9zNu", + "7EiXiEliS4+rFvsMo1KauB0AcBNGZBaaQ2srhq0UIBpugLvhhvss4/Kf1bTD42Et5IU9ABuxmuNneYcf", + "5wdMywICpvPeIXZ5tw9P0sn5w+Rw4hR11vPhFW43fEVVbf5t4kUsVqOWLcZJttiNFo/ZTQOUgQmvclXR", + "lpcsVfKJZdyYMgdG0OFlb7OJkAZy3EYcgFN5SAnJhi7s0/QaXN4+EP4Q/LgjRneA1xUfGdbadLW3G1u9", + "QZu9Hvt/VtPd3rOf1PRwi9md0c9wmeFYu/xlb4W83wetF/JHuvOznE7jc7TiKrUkxl4OtYskpBI2wBIj", + "qcGobAmIlog9rkLCDqLbSQPaktZ/sgrwYRORDrGis0poOcWEQvxucNMgjtqU8rZwd7994ufhc4ty/lDZ", + "oL9t5xH/9tBkGiRGJ0XVXMi3KrnfLVs3IrP+l0bZZV0uzUwmEHNqJWSqVt2VTZXfeSNxUq1AjxJMhcdH", + "XlaFeKg7YtR6XQCLRTHBB7q9nPBQCO1U/C6I5zeXX3311e8JCij4zFSWAmLg4MIYAjyp0nooLJMpi2Bu", + "ZtyXM7gtxjsQ2G+pJdbVNYWFVXLPhGH3sMbcle4yjjpTfZONE14QCJXVWIVefbSnmKwzISAWRRxaAmDj", + "l6trhi2zlLQ8G5kVQEFla6DZSc7lmjbGawlKQiSp09fpuLErrU+eXF0P6a3T6lOYZCCr9mAbGkbh9Av/", + "rf1Kg5eN+FZDEBLpWsyw8wTsloOOsIcLwvpYfYY4pCF3ykO1y9d+RHDnYAz+HozFnXj4fpZ9lMUA0h56", + "fjQd9NmIPNUDNhDRKp/Rpmw7XG3IYEmQExV7OpV+OFhxLXd6KHb6BYJps6fBhmNgmkB4p/7unqV/aELJ", + "HQEBSRkyhD6FKYWUYltKlgFfetdWhRgo5JjCCTEFGyLJiwKwnavETBhCCXbygJAPQz0c2IAsSANcXF9V", + "yFicgDN4BczG6wEDtiI6+7ilKeItoel2HlKFh+Frw4w6FlpyrwaImBzknuryme3Pf6YPVEJgo8T9oaD6", + "KdPA+EhUsR6GRPjgpply3QlQt38Ch1sR6FDqahWmU8oc1VxkbpYrtxPUlxHSYQtc0BkuY3ZRYBNHRF3g", + "kcQw1xQqnSHsboCWNEUAUvGolf6mQwC7CmazAE3AFeG2qXvxIeodomaYIhOW8UQrY5hdqSh0YmSZmIE7", + "9IY8TQTia8GN6PSXBc9m7gOloZRwQr7GxEJuWSpSjzCcA4J9j9ldKIQO+fJNMnhcGe8lQ6x4op6xjlFD", + "HfjhMBNbQq7jpjmkIcBeJnCKz67mAPsZbhN8xZ/tGi8OgwEBL2+fLN2Zb934sTo9pKQyY6E4CCbgIODG", + "nq/UzrRKwm8oXIWGgmt0vgjDUu2RDB0LzTUWqDn74SWL3akPjyHju0VSOy9SrV+yGEXhxKqJWfEiZkoS", + "5HzokMp1XfHmPY8tJFhqq63LwkKK43BsmilUSQK/yenu0Dpuqg5bJZFX3LApSnKLy6AkzURJbEgpQ7Ae", + "Z1Hn3nocXmZEXmRrdyVoGFWFORvOpopoaFwjXagXSb16Z/queFGEn3CJ9I8QcQjuqMaq9zgPN5oTICrN", + "TDjjwOmupGuO2VUAwsZzTD5xXVITAR7iSgmXkbSQZYw7W8IsGnRAXZo7OmXgqYUSMoOZZdM1iX0nszaE", + "jyn1UiyhJ7m07e/YqryqAKNC1eOCG3JLX7CfQSOELbAVFrE7SjPu+GNaziPZQvY1LBo0PxGugWjw+Bqr", + "vjC5B8ihs9Wp/8COFmOlXUxysAvVVU4BIdW3TgEOKENWOUrPeAIsGmRqrkobDdiJ97ueIkD0wl1lwrIT", + "31XMJ7bX7daemIrQVuEV5QxMNTttM7z/qDNlfHO1Lg6tM9Paq/ijgNWIfiTZx7MME0AQA5ZZ5aMU7XVS", + "2irKmGiA5VZuiviZaBAS51fCLtAk9uVlDGXLyBmfIZCBGkokMTsV2+fSN8xLwoI3vmQWRVgmEO4UBNYO", + "MJ8ttRCFiSR2pzup7kn8CL1A/Q6o8cfrO3ZG3z894trsTdL7PDNk2OKuaoO6WTRXev2x+zr7XrkjiOWQ", + "OT43ZgvgxQRBpj12nQeNzYG7m2NWZh6XuyrxjSQpQuceHzexCCOgNGBMyjhlRGAzQB8xd0ME1cvq0P0+", + "kk0lNFM8xbrFFB7GzKyNnw12szHhX+7WWIj5ApkOYfV8IYZf1EJlqUFfSuqVPJ/DRdUi/obKgwb14bYr", + "3rdJkUfgUeMn3OXymV9wzP55n/B5349vvyTLfDJPHvui0qq0HohlT5AA+P2k2ukOTUzMF6OVz2U32OsD", + "rTxkIjyyc7C6dHw/ZhchnOVuzLdClg+kH+Q8+XCLNyp1n8auAcKACewZ3KUIfZeBv5Xc3OgDlPFmyqmx", + "wpbWY9dV0z4Qk3A42LHQS69Qbq2yicOIbTcb9i7eoF6GRjKZK3aCayVARvfsFBZCptg+5Ilhlpv7iZAz", + "dYpXiEeqiwbyjEeDYbC1rQbuRHLo6o6ReEcSd4EfvNbqMB/NRJsNTDYPZscx2T573QehOa2KyTeZtlO+", + "qhSyHsjbLq3uhzdUr3P1yneZapSPJzxxN2UFN9tAnqP6G+xE3l2B1V35W5W8Y+zAi7nxfF7O+gDB2ug8", + "X2ajUJkKKF/1V3vJ2Y0riNSZ9IL1Xl79efL99x/fTC4vLn94PXl1dUMGhbMXjDsZkAbNAS93LGOpsPZY", + "9XX2rVMlahp5II/uRkdutof7aRu8sq+awH952Fh1F7lqiKxjobx2w3X93aFr1YsJk+six3Vd/LtJDK1y", + "3lMef90AW/Kws16LqYxOp0iQtiCqMvonCLibZdTQYczef3z7tjJxsFuCuxAObLriJ3jEmdvvCEmUtFxI", + "0LvW3QilVc+zEzWzIBn8tUQA1jr82C17HpWn0OgittfP4h6iOGZnrzJ357ahVYakB1IJf/1QheWiJJhx", + "I6rqldxmy7BIntQdw1gBumq1VQ1n6LYMjfU8BBtmYzlG6TGUscrRrGXS239iY/XYgUKS7U5NEasSPN/j", + "yn2NTXk6d8Z5zYfNkeiM1SgAh7Hl9hd2o5o2T4dHPxEIf5FzOyKHA91nqPBT6qY+g4DV6p/0/o2UcLOZ", + "sKeo92PXEd+IJAOLPqppKbJ0zK4kvUmdsFCZ8zGAlDo5tk3QaEDWMHNLiwaRRNpRTS5hdFgt5nPsWU0e", + "rLVMAqY1ogx5POWMz6uEOsSQqVEPyJokDwfqaWdIeI/aLSSO3Qd8sKNjX3Wlb54CXykeas2fmMCw3eV8", + "FPWfOFZCLIeu8EC1L/iAPx4zgXjRCHKyte143Wbc2EieaDj1o3jhqCTTVEXPLVY8o88n1WLmDUE3lHdh", + "RLKBnezki6FvoAPoo7yXaiWjAdvwDeG3DuTtAOt2ZLo+pkYF6n2Op/uoLom8LeBqzDAK5hNtmiLuLENY", + "qPExM/niDQj3joxq7aRRu7eBdoldUxfKqb8BwBu0wUN+ggRBrwKSocbkImLgOYskjpA1fGM13E3wfSrN", + "Xv/57vXN+4u3NTbXiV0oAxUeeMC9cBMAfRpkAXbkcgKDoH0Cxgn13A04HSiOEBeEI14DucwIaehAXt2B", + "AUXAjs8JrzNZYCx0hpBQJ/W1Tdly1H//483bxkkek2rumGZwPvgff+Gj2bPR73/85flvP/1jD7A1tt87", + "EGDlNjzuXsUGDD1i7YYSntKggVWqV3V52ypBnMRRLVQqSeFFC2X3EZo8eqL43DHsTB2G20zT/KKqmOO0", + "g0mGz3ZXwlTVS418WM//O5MDPrsYuwmMVF9OWzpmU6o2eCUQoJFS2FfDvS1gN6XEDsV/d1JNONsH22sN", + "kKAvgVFZjb8ryWbz3HR0VsFWGBN/aI+8vXL+MKEqmuOxd7dG3vzcrvWEA7DhIfHbXNVG7HYKUgVcXYV0", + "yNNHfZqMVXMkYZoDDTfWtDHpzYF2kazMc97lVmoph19Krfn7uWEohaG5FQcd1lt8vrd3Ui1MO+oqi0lw", + "uh3Tq6nqddUnH/7+OLVPjFdiuSm+22y9k423ibi1jzs4veqA3ONHPR5popkU3bnn9QOHOaZaH9x6fQ94", + "xOYyu/2b1TePvqA26LfPt9gYqGu2N8CNEXP5wd26vemeezT397AKSF8hhoJYugSsMGQejhOBrPa3Kt+v", + "ANxQas+F5NnaiI6bhvtf+hgi4Rbmx51/P+YlvdkpBtKSci58zevug93OIz8QbBekM/ePPB50eDs73B4Z", + "1VtxDKN2xK3eKznCqtnQr9QMGbp+eCPCgep6q39YQLl/JApPc5s3qNMicHtr+inSYowdjFcxQQcyAAGZ", + "GcQL7EGg9U6MVpoEeRML7bYxuSfr109m3Q3kvBMD6haD9CNe2gUiejS8ikPqBEB1FIs149U4TcBjD/qB", + "3WGrCithqcjqpXeUcaMwrE6R/1b/IuzXTtH5DKgwPYVEUJgfU5yKjCfQj12HZVpiCd15rBLxc5VmIi+U", + "qfD7NAQmeBmc3DOhc5YKnqk5c/xrGDxYzbtpWjd/1TxvxmgLDb5bTle52qvqd0r35IRy7PG12JXFKKC2", + "kGI6BOPWajEtSX+yRCgDDE8BpblV1SOtDIsFZKnPAUtVUuYETBBJSud42cq2MoBdgI2Qia+dwU/kaklJ", + "pGR5D9lqoQxEcqaULbSQoRuwO8duyuRjtYrScAU1ITdj9gcoKlAEEpGRRNeHUdivPnP8UvM3em5ZqoA+", + "PtXA7ymLuxVeHkaSymISLlORBoeNhlwteRbGQ98rfsK9eHF9xTQsBULzRPLS++fxInJjBTeVsIcFrYeD", + "h1G94aPgth9cNDe1QdfWDhF51YzcZt8r3O+X7N5Ry61kJTRQb20rpiITdk1Op056UQKMITCH4+hQV3se", + "caddIRaN48JJD2or9ZsiPqWOB84QyDmCWkOoE8IKD2wjg0/G470XSyX/N2E6Dc+LjJjA7+MwtKIiOTMy", + "IoUxu8woY6k6eomtBBK65g3Y8aF5XJ4sfR0r8BuTVgOtbUnS30z0C0faQzvLNmheYxNbIw63b6i2tA0k", + "2l7mAffhVbsPpi4WXE7qqKlBbFf8Y2jGilGiSRV6Q6MEXdkTjJFCXj3jCzhLiTCcPmLe5f1q7t7h3e+G", + "A19E3XmPYtS0ihdiGLBaFaN+mZWxNWxoPEr7YEror3NE09kvxyduZTWj7MnJ8OTrNQVy/uDbtG878IsC", + "NJuiXFCS4VN1x7sA9F8HsoQMek6WjSOJXYmsorx1fHa1UNgwlrrDj9l37tMIl2F9bhM+pYWFSGLNo1ko", + "beliqXPI0avP8NrMsM9+9UUqgt3d86ifQj2t5rAGB9MQH6FiN5rnP+Lldh/9Dt2T4/2Oud9BOvp3GJ9Z", + "0I0N6boq95X6zx+98i3XRf2pYYukLRJtLbmbo2egQSbQLRLaqTM1HIh/qVPG9HZs80oCZRmF3j0VansT", + "j7W7f3hff8zw3ZCjEde5MzE70TAzjLRJDwtMcLRDVIA0lg98dvPMPS0vPzMX6JDekI0+cK0MocY4e/p3", + "VaywE8ZvBz22mnt9s7e5F03v2OpX/9aeRXypNl3tI/Irdum6AXSgv5bYSCrdgbTqm4BsCjSRLJimj7BZ", + "xpeq1E0rdCVCWoYvJBVoGTUgLUMVKXbOif8v99S3hF550viObzYV8HEgnZgFj0OCOdD0hZyfekC2lTDA", + "4kYZaEyWDYHBKQmjn9T0iUHtYJSCBY3gblh5KHyOPKY/RRKLUE+ovMFp2h4swkkB1Gy5rTLgnZqMyFEj", + "nOWQXs5GlGGD7fJ8K/vRjIusdLYIN2A26kSwXrVdxNolBI9vvrEd4/SUc2LdF99OvgSgzw0YsFWh/P4q", + "9s3otM+fIghcRJlBANwKg+Cl72ee1rs9Ph6poap+oLo25LEjGi4Q8wfUg/ABb5GFDkYQ5t9uGfAlEBF6", + "Cf/RgL72Vfu9tJewmjShAbaAF9GfycIjdSMENOyJo50Og0YwNoPwXT0opQvzLXwWic+bm3KZVhpfEMS/", + "27fe1jx7low7WlXdbFgcwtwfE2Uy9/ShDiH8OPcvOYf2Zis3Koc+DQfk1JigNrHv1T/is7fuUf/+JvZ4", + "2zHrJzT0pNkYrIfETiW4aKAqbt13qDN0BSc+FPyvJbCrVy/ZrLRO5i1BG2eOescFJo4U2PCM6sGrOvjS", + "t/AXhol0f+CiMYvOVZCUvlRyJuZ9eqgzrxIlfWFxR4EIZVGyE6sBRkZYd/ZX3OSn2E+GywRG1fvJmiW8", + "GLIUElUWWag+qDMwG0+O2WueLKqP+Gqqf/3t79k78d2YPWPfMg2JynOqtT/56nS/W6caqC/nsFEfoTTj", + "fcmOWPRbJ+n3pzgSIOiEYD7reOwGCbUyZoQVEfj4CB/3tUToZStUo0UnfQZzgvFxtI5OiSJKUh0k/rrV", + "Q7eTJlnGcz5pY6/ubiFMb1BpgOb5JBfT7UXhQyOvrSyUQS7OCzuiMpOEF87cfie+Yycj+ttI89wvIzj9", + "nSVRbzEmGIYdpIw6+ia586kaSoNTnMjtjXN4YlhZeHzc37HvxXdVL5w5poPe3N4ydxCyjSz0Dx/emdMh", + "Gz1n37JSoqINaYuco13UsQ9HUVNO5kU5yfjao/e3iYmTcNtKD7CTd2B5dnb58dXF6RApdnn9scp77B/D", + "LpxK0zGA+0QGlrV2jZdWjaiJ8X42cnKiPl6Nc7yfAo093msXNEXWTeM9p8zhrbcLmD5oGOkU1Y3loD32", + "j/sam2BiLJWdKS3mQlJlXuizVXvLEy5DFRtn0eDVd9GAnUUyGryWS/e/LBo0Jo91x1lGmoNVDJzcW/Ks", + "hDH7A6wNaU8eEKRGV0Y/nzln8YZUi4csbjNhPGTjcQ+8YDs3r6s1QV3ROgkpdUyrVZVrjf4uC7Lufo1q", + "KtU0yuVZ8wi7cyokg9nMM9XjkpfDpKfrrkkrJowpg/PfzfD64x266W27YarP52y0UTiuVH/zOtk6/J2n", + "e/s47jo9HQJ6x90y7L61u2V2dWT2Kgc37RN6mJ5w0PV71LV52OV18IV1iOw+VF4fJHOPlJr7EiL//819", + "e5nuIx7yLtdjFuDlVUFifsxuAcO0KDURwwLsmQYM6VNdyhK0FikqVB5YhAK8iIHP4mgQDWJ24rtR0edP", + "nUCLn8XsRJY5aJFUf7cqkpdvX1/ctL99ghIcq59nPMtMhRADcsnOmurqqQ8vYCCV1nIPUHiQiIDiQ3dA", + "Hwh4x5E7AA9r+wjuR+ndcST3j9h1RA99a4+O+U5895I9a5ZE1VuxZwMaSmanknfwDBuy4tB3NmXH4e81", + "ZMn+l3bKln2vd8WZbj3abu/BpEyERusHjOuU0hfUbTewTHRPL8hGv+xDOhuFmaV33Nx31W475iuL/uQn", + "j3uaC2PQzeZssabXlhuWqpV0ipBTeiyM2RueUZ5Kljkzwi3F8ikDasj/Els6MezXjR8h88Vyc29Ygkk3", + "IFU5X3hhZO4FwjkRIkiFWUKIRFNgK6UN9NXrYVbRvOysj8RpNlbkZoBOZw9Pw4Q1mN1hR0I6gQdyKbSS", + "OUgbSW8qDZkYw5hJNVXpGrN5koUyofguoDD3Tk93ZoRZLlOnLM/EErxWXROx0KSUDaucHtyJJ4Yq0SK8", + "J35WEsYs/qeUi2wdo8k30wLRuLE0yrtnHtmPdAcPbkKUdyOY5yLLxKHdRvANXcrPKurDj/Sj728BoBHu", + "WcXmG1BbNdQgYeULE0mv64dAAwLqcJlm7gzJNIQlfOxWWIIFk2tKA0Oei2TO9T2kzPvVGUfQNG3LooHd", + "VMOAtYDZfPS+HR6oscixv9vB0GfdvWZvKW5ZVxAMKRTD6YZB/0/BNc/Bgib0ltJSwqEGNMki6VEi0SEh", + "8iLDqIWpzl8PQzrtAZsQdENMoHIxgxUKoWFV4t/MO2LTtZ+kNlSXip07ALHUIA8IFFWsKQiDcBVuYEsd", + "mM673VEKt6OvVLspiZ6Yin2EYfAASekMzO5kSCtstrvbZ589iEag4Zhp2JJYNYiNmxUml9aSkQdP0X5P", + "a2hNjDP0Eq+WIC0JPayvo+aWtyVAl3J8CzmXViS3wHXS3wvM10l1de/NeHKPqRVYLatVwXxIlJIuibdD", + "qIbLNSs0zMSDuxUQZEj7rTmmXPlxVc5bYe3nz7bbCCJcJSMsEKZm7M3V29cehY2dIAoGqqmnlIiLcmO/", + "G0vISQU/sqlt4ossUUZIYEbkIuNa2PWYYaaQu9+DIPUexpNn4xeO2JHMxHxh2SxTyh9LShfijqo8sez9", + "W/bXErBZUIUKc0pmTSSdDWJVOKUvMQbF4mfjr38T06hWi8SyRKUwojg9M8gk7uAnPBNTXaVsXqoUbri8", + "x+r60X//3UYOai/QStVabivmZ6HiKbRh0PHzt2YsR6z1sTkM9NIhZ6sv6o9fmKAvrCs/9E88y0YJxk/x", + "SVQVZbIeEoAgJZ09x8TznGc+47zlBevtV3RsBsUbkQHi//m0sL9RDsVwgyTdxCWYxy/SafoxZSo9RTfC", + "THrDWnhXhbrv0HQo4VqvKyAen6jRfVeRJgYgj5po/RYF6g9U+NwLJT/gha583VYpdKtGpbWGFrl27PLu", + "ImhPySPqKj3vfEZrgWrMXXk/twuu4U75E9NztYYm2/uzx6onO8cSKSRc31Z6+mZV8mSG18UuSBTMUmEp", + "FHbBCCyc5QrrL9SMktS9SN0T/NttxvS7aYuuyPazAEDFkoXA6iHS4J2tgQ3iTkg3Z2e182X/HDELp9sK", + "qwLc/STDgzwFuwKQ3iJ0JKLumIZ24iwE2gk5wxR8JQPOT09/ZcodamdoVmZIA465hc1cWSZh9T1oCT7W", + "UrWzO0I+06wC0YYNZurkRGTBHSjCGCCZhNjzJDRI6sSIzNajYNI1G6oh6M7+XeaFmPg8CNJisdBicD5Y", + "Pu+SlFOe3IPs4MHv6IcmWhBhPsVzFXcDiO3NCrigOFGh1VKkGH6Tc9BUneTUHifcQXvY/B/K+VzI+Rue", + "gI/cp8NISrVi8bX/wPjq1clpTPWIsULn3nlLL8P+kKoAycW5hQc7qqY4+mpkcp5hkG+p1nwO5/SfEWp/", + "X50/f/bi63PU4uJxJD8a6gbbDk9aRSU/GhifcyGNpZhjA1ou3kZoiv3x8DkoQBDeI6onCPBfu+kbKLif", + "xPdCpueBOG6xRI0Yg4x+5fF2P/A6k8Rp4iKBpnXL/HU+4/fAZuLBlmgZ1/ipjKPyfRteDZY75kEevLhJ", + "ziVmi3vxtxuzrIpCVktHtCHs0DUKAhTFaSRP6h5UqGQH8pwSOt1MKQKkdTtkGGdzDSDPME3UiV/pPpUq", + "j4ROLeepuq0AnXN38dIr+FCVSBjJkx/u7q4JjT/M0tntS3CivnLTOAOFfEY32LTEZ3QihQlQnNsqu9WJ", + "OMoGr1Dk/fQLlWWnfa5Ep08b2xQUG0218HcW4FWDPeafZycB2BvzEOnHs2XszZFhJOlIPht/M37uqPq+", + "zLJGcgimsjZB1txcK0A4cyCaEh6YCUFM7y7HbWVj+LvKV24aRp1h3IKEZN88e8ZyN4Hg7vW8FV5Ctwbd", + "Q+4UoAdXc7PYcI42KN2Eq+mqudMwD3hT4dFDrnLcl0mpO6Ts98L+UE7D3mG1DmJ5OC08bm987LcG11kS", + "HNth6EpIyyb/HND1UN3vQDWaVM1K951zP+gIu39U8sltBVUu8pojn8aRDHRQknnKkJmfrbEnr0ed89kZ", + "Mog80I4J0JkuDFM+xFjHE9xk2hPx5bUrgXLixIBl8eXVnyd/fH1ze/Xh/eTyh9eXf5i8fn/x3dvXr75F", + "FMGmNwLPgJDz3iPrR5vgaPtTN/HhS/es1497m6wHFWBrV9vKxMaBG3bEzRvQSJ0aT6fqtBI2WVQKebja", + "e22HpMqy3NV1dGuYzXYyJPEHwwHdh4PhgO7C/XnSvp2En0fnkhoYNkfWoYRpHlewc1gljvet+vk363J2", + "ltbQasj70V1otRuE+G+x4P7RekgxHDgtTdpJ7+9GzCV3msxnEXKrtOkA0u7xQ7thPtvt+2JvNdOXdgS2", + "lvalypm2ePFXrGi6A2M7xFTf0lKRg+xWrmrvQ/UQ46aGkgjBp6DIYhAwkrfUf+lZfRNWT2SAABhonVSf", + "zPjPIltvlMJ27r2670kQaKH33HeTRUMf4FPzCG/ialjqWBce8RVOGZgq+/EgPWTHcf65KyYpfsa8Seo7", + "ckLA8E4ff8meeSyCCvvqdHdL1KqmSqCfuQ3tvie65R7qo2WvHOiEzL+BQo00ZBxNn6o+nSIpZ1B12KGq", + "s0IxrVRPGG57NqWUkH0nZCd8HdYTZL1xfbLd9ujloQYPjTT83Bkpg+QYnuLQdZrpx6tuD1Lv5dI0kyvw", + "zUyV6SzjGhMB5rpHKe3XbLfhIGmMYYMk9fp/3EPYbhAxXPkxIFatvdqHrlR9vX9yl9zyTM070TfJbj1y", + "akEJ3TO1+vM75tZTZ7Mzz2ThoY87EK54DunI4qdZUU4zkbDwNEPw+JT6hTo5cdrbQKLJY/gShnREct9X", + "YvlYzsQK8IkBuysLK1FSEnwNPk52K9Y1noTyDkJvOO0+Uu1s9j15AnuSu6vgfeOoIMUau9Jc1r6dr9Pm", + "Hrn/fwf71+H8rd7GeoSKIzd20sfIraryXCMZ8PjoiZeUiRsNokFdOxowkg4W+31BlR1WOrlM3G1TO7cw", + "RI9rUpatwda+QEh3BPx2R1K2h45oy6KBUx4i2rdogHOpd+VlZcbvru2VysKuWE0HPsbjuYEETrcj55qE", + "EWKdfLx5y06kov6v6KTIuFmcki6YiWX3UrZiK1XABA1Yx1gUUckIIsgHVnZHUw5KxOu/JUNkpeak/gPv", + "dO4+OJYdiD8+W2CSH5o02K0Ab+5Oj4trknie3EODHgWaxNn3wjpd7nYtk14NsFBZNsFkvCXPmnGt7eIq", + "1PXIq8pTkAlqvf4NdvLsLJyE//r3/9jItcGMepmtm60Ckcmwfwj1KsSaee+vitkJz4xq5vZFMkySiRmL", + "VzBdKHUfb+Tyd/q7WvAa1Xgd9aXYnAWqRgoeZnEKhMgW+nI0BncrLUqzGGErERnJEyzLC+7XIc5uc3JM", + "yeB+P33ZWPJ//ft/hH6JbAaUjuOMOMnCyl+yOOey5BmNHJAslGQp5BxxlIJtFs6mn6q7KGkcUiNLfkDx", + "fpNYBzJZ96kKHRL2tsSkTzXl5c7uN+4hxqchZqBKi02w/+vf/pP5TjLcMk+BSDa2JnS7pYB3gNqoaL+9", + "Z30XXSutIKxyL63u3JXaeyJJaelu+xtQILze5X3P1xd37U4rnnNLA94Xr3Qkw/F0Mq7CeyBN7iSMiXz1", + "/uPbt6c+Y1hJMJWhF0luvDY7Zl+/eFE7DUQDrpEKInmYI2kYh0RfPu2i26KcHkC2vuTcFSsybFP+YB21", + "xuyPPEPEyLQKsnpaumWDTPS6wB9tJDUYGyoHWCbugWFWjlDyZXMvsHct5bZrwL7KvpqRkE3/PPpwUdrF", + "6JYeWwBPQVNoEGf+xDgiYi8jZyO4z9S1GZs4FHt9aESMHYy4M5VmX/J90Hn3zahncI/x0jv8o/uI9A/5", + "0ezw/lf6S0+NLcZiK0SRhGMSTabknMqwFyCtSLDs5AZmeGX5OjZf4BoArQlrhO49QHXbfbo3mqoSnk38", + "iZ4cN8ecr6nTHKaPbTRAQ2GAN8dZuEEo69O3yCH/KrJiBQdesTwzlq8jybNMrSCt+iljtoJHHXugXuQ/", + "cIN04sZSBxw2L7nuDWlq1aX+v4cV0yqrs/0QFLxJZ9ZNZp924Okcu9fi9s2Ijw18u+Ufj2DfClK9wVAb", + "aS7KLpqVVqESEm8mFMNYWuErxTPgoQ1ZMLoiSbWStQRg15yQb7n0eHGhGlJpFjeGj33FXSSFHbPYHdW4", + "wlmve1oidbwCnXZVMf7tZIBvb/352ab9Z6KO7cbhoQm3Ac9rzF6FpBO3+cY3x0UNoTrMbCl4jSf04QYR", + "c+9h3ce/jXEeXyJUQUxVr9NfDk+b/f9IarCTqeN5cgCxr599dVrJETVz4gITIkahLVn10R4ho92yZSVm", + "xuyiR8wwDXOuU2zihaqRMNh5bxzJV2R6YO4LBsZfVscrbDvxXF0u5V52RzKS1EPNapWWiUdGoBZ9J35K", + "p3jwnJa4QkyJJkhzH4u4UzihA90Cs+oXhgfKqi/QxElQ8J2YDYfvme+u9kwNR0APH/7YIxB2Jyb3JhMT", + "RQ53G7uh/iTsouqjtdNvTN/eFb5rf+/8lwHPsg+zwflfDuneP+xJ6Awp0X2w2pfuz47bUZpjTngasuBN", + "1Xq/ap+xP7PzHtaHDaZhqe4hDaLQYBsPH1o8eET0xSEEWyesyTuFKWIJtTP3qf1BLjhWNpbnBTu5eXP5", + "1Vdf/d5Z+mjhiFktyBZO9UCPdKbmc2wisFFJc4RU3uwi0blJW4Tc5pYfPw0HW+BnXb3uqJU7wZyNCCge", + "OdAMPXqBVjkjWDRUKKRiV2cftuu3/UwruOz+fIkm6PbeViShl8BnA023ob7rzw57Zt51ADtSkjogUCC5", + "7wHReesUR3RpNVjr493lkN28uWTEYGRBN2pqKdPQvfV4kJxGXKE/lFmAFioVSbBNcaLChJyynq4Uwc3d", + "sVL8jeVgHPMNw5nJG0cOhyC/SHAdyJBU+QgMHtkv9v9EfpldMH2F6mvJcxQ26HDg8TfdEflcsFA/7Ss5", + "UztS80urJnUS5r7kw5BEWuWuZmvWciR6uKTaleV9Ftg2gnjDyWT0Pk78U4hLy4L0BPYbdBMteBpJVCfO", + "kb7uydMxQ3UQNZxhq1MwWQ5hGow8h1mvhuOHnhhIdFcs8Yd3F5eMfhyzOzcvhs1HpBE21LRrZbkl1ycl", + "FwAtoDMWEQbsDHW8cez78eYt+vG4seBUOuUJ9sQEclLfl3mov3ayBtOpgxGG23R59efJ9cfv3l5dTrCF", + "nWGldMYl4dxBATJla4QTpggbQZAd4jZsLmGLgsMtVtrBkx9wzI5+XNXft11jxUY4KNAkhUxg4vfHm7ek", + "dyMMRfCWRbIjbtSqYCf0KkeoaCCVhGjQk6NfI8NtCUINLKbJx07DBoN335jFROQYqc8xUsV8boSn/ziS", + "cR1niSuwhMDXI7d3G3t6IuRMc2puUWqIpDePg8sztO1FHf8l42GrfY6uBEDsIBa75cZUWSxVeNlj0gnD", + "6nJzBGDwFEcr9Ala6Z72wS4PEo6GG7QCSEOk7X6B5llgJ6iY56IbSJRMRAYfyJ3eXXjkC4H81LwVUBsH", + "bqR7URQEwd8fAOwPi3rLoUdn6W6fGjIm/QQPWWRvX4ZGJvy2vuQX2Z2aSqvt/M1HKA43WPr2pKuLpad3", + "58C7LCi/d/tjjRVN6vriertrFtix8Y19CEb/F3IF7Wpv9kYDjNx3Wi0VvLDybjSUWb4FV7+7ZaODydur", + "VyMMCChCDW43Nj0Q0uSjFO7d2gviHut8/9CO6MGvgSpD+GzVEjsUGlBvHTLfONpNkUzBF1WyP4qqTRrK", + "TTf00FkdU6Aer1yumx3LEZ0jkgiknTKrfPESum0OLL35Mj4Mn/nTbnDU77LY3z6y1ZrzUT6KR3TvrI/H", + "ER07d3kqqg9e1zj8m+2zgi8vc7pG6vGsec1CBA1NaBXYJgeNB2KJhSgI9gltKIprUS0HpMyPiSX6wru6", + "sRtBGFHImYrkCandwyqBF/+31fH7dBvONVVg5BMbSXcBM+4TEgjTwWpRdDm3j+8ae2z7gu4Lal832M1d", + "+sJNy7eY4DMK9w/qWL454LuKWb5EJ989OsLeVr+7+/hu6hQH7Rv5vBF2vbPKyLbhV7ub+XzRvjt7idQD", + "qHPDV9tgOlWtvjuCBKJCyRNOrXWLJq0XC+rQdvJw6M5+MKEOYczeK0TQD6d/qpSh64MXRSYgZSfcGVVL", + "oUpTdSlkeZlZQb9TJvcaVXRcHS5iyFbY5CIDi1jraD6mCnulgK9jpaKMSCIyD7b/Csg+eJEX6PG3I4rB", + "J1rJdR4anuyH4fmiPY42+O+Qlke0lXXrowNY9Q2qaDc+OadTvvSzTuh2uVURgYStGsXOqtJu6iLjjLGY", + "/Jvo3qTMTCyrd0ddlTYeMrDJmF3hOjB2mlFsClNR+KrtycL2sZgkJXnGKIfPsFQ5eyoDfv+SUTVlw9eS", + "qTlxUNw89nE9V3c94SCH2PAbe+XpcgD5rwFb1D2S/n1ggh7zoXXI6Nkxuwh4f8q7GblkAU8gjmQO3Nf8", + "hBcX3F2viL2PbWhDcz5Cz8SrqW2nFrQmx4eZCg44X7K5yxrcTdNdLrkNmtZX9YZNl7/4phc/DLgMyVVW", + "FaP3yGXfvXvxDcM3TNV/sIp4GjGXkZxlaO2QV57a5D4xzA11gspKobxv61snPC1oJ01uqeY+7QanNwu1", + "YtHAk7hQzJfop5FUkmXCgsa+bvdOi1+CzngRDdjSjFk0KNwBMx4wqyG5g/tlvxBLQRo4jkyb94SoyVWJ", + "6DG7U3NybaPuGNe7EZPP0a4Ufg2LJjMTgKAB4zdWsbgl7OND11P1zOySUYt2QiF1DEhBi2UTir7Jik9M", + "JAmxEOYI6UMAJhFZEmduv/4Jg9cDzKWLBo2/nPZhS5b5ZCG6yvkv6f70M2lwH+HSEhRoGoIF4bBHki7j", + "hBd4P+c8JfxE6c25eaamPAu3c93csjMLfbcMam1Kh8d3PdUiDR2ak7Xji788Gz7/sXLJ/a//OZpmIDG1", + "0a0B1YpI5kKOcv7ApNvgTPwMKZ1Gtx5k0cAn7OR//c9vn42/OaUsYT+fkYYMltibZu5uf83dSp3y4SyT", + "aHCniioLIRpEsuASe0Voa6p4ZgPhex+b7ZZdoZlqm1aNfR82ZVP7CB4g8PothBoK/Dj7oKnGdtgIJMJ9", + "W97O8sEKW7BxA4XW15QWUnV65ZLu2Uimpd7Eb/OnK1EIFdvso6skS4W5J3QVn6TpBVPtSqkAQ/l8rsEx", + "QvoySFMPNuobz1cBj3upViHj1amK1BrdybMAJbKBw3oEQRvKVgdV/b25m6x47gmJN/hm6uVOS8tWoMHd", + "13iMnFCL5NrHKTCbF9vgY/pOdbHTslJ20sym49ZCXjhNGSdNdBa6AorEXom8KIBrpnx38zW5yCMZ0239", + "bdArgrNNzCo1vFCEv83T9eMJ2lSfuii6AyalPv4oG8gPtnnFMH9RG29Z4NY4VXOD8LU5JEwIp6L4segK", + "c2Rwu4uo3Qg/LLB5ViqWIi1rQewmwhZivnDMTDI6+xzq9Fv51CV7Zs0B3OY4ioXMrUYYHMVxLujsnsS0", + "BvfN+BQx2dFiPke+eKKhZkjMrEMRF0kvDKY+g98gNjJb8GwWDvOCLhDh2+R6Gy+SThTwwnhvEs/mSgu7", + "yDHWV2oY0R0x43KkShvUejckOD0WzJjdaTHHFN5mIQVCbVmFmV0zx+Lu62/ubiNJreOJj5HhiZNrJkCe", + "XnDDps5C9t90SltZgXJJWDHarMfv6q3bujd3t31M34swjgUr//afFforgeOPWYyEpd/q1ZBZnLKZ0+ym", + "pY2kVGQ4BBhxhGmqIHljws8ds9g3DZ14c6+OhAUuD5Lf7TpHC800DHa8DCBlbtvoRiAJHbbyxACwuHkF", + "xRsdSbHcBRc1QIiO5my6qydFfki++cZG3Pm3ejFwGi4yfxEfcJm3tvdYk3CXGnLA2Hc1HbpisXhhkpgz", + "hVN9hTUeK0xIRoD6VA02ZjdhkymSvtVAt+DGnd3Yk9430b14/6rpWkosZhs4uRhJHjQHCvrWnIrmhFQN", + "ARM0joDG5Tk3kprXRi9nU8QCVjP2M2gFQdph5QwmWnHDIqq/lxbtJ2oZGhixWHADAWGDcWbKHBfAWc4f", + "KP6BSbHU/g6CMIyke1AY5qy8vEwWuJTGslORouvJGC9i/HLISnI6sTOr3NuoBQjLVlzYRja8ydQK6EiN", + "2Z8cdQrQM0eQgmueZZAJk9NUVtynPrkJ+c+/DBSVAXQdP1rmL902F5onFgH4yGXX8AjmtGj3nsf95hn1", + "PJTYuICvSXgjJcNVaybG/Q5pjNBXpWH1L0FSxGESWLflbR++9lRAGjZUP2oIIkzCdaB5tWfYIoSuBjdV", + "d4VF0tnQbVKzrRve14i5P2sw1O4SLx5pVhg5UysZFLLq7lfS3TP1eoScoJ3hGzwYcPthYRhJhI0EzfBw", + "OPXWMTkujss1Lc6p09gEkZ7EGzYcELNQKzmMZOjKDyy2qgjptyZ2lmDFv4Q+4Lk3Vb6pBN6cseOHSW5i", + "MpMoDTsl/H/il4ogS2F8ujM514bMneh8mvk+KbV6hUse0vsYlRlpNRW+qhGLHygNXAsb3g2OJTrrWYby", + "hTIeuUyH6AehZsg8HSGooEeMHLJ/ff57lmOE8l9/P/x9QN7bigChvZXzh06k8LvGITJCzmuR8sR4nxCK", + "om4wFzLlyrzz02/ubr85a3zCUd5thz/wgWhD5ldoeA7Mgs4N4yaS3jLEj/eZ7PTMo9bmDWtaHHvH1w1T", + "g1e2tbftSFrRRfyydcrQucrZimuEvlMzd1NE0h0RklFqo13O1uz7yPfHZlbsHgoKmWQlIiIt1ilVfKL2", + "3UZTZStBAH1arQwJsPrFiodxxZFsLrlyYKD4dMeRLkUQ5OTiay8OQ72PsO78uNulCOpumZsa3jMjalMN", + "ci2Y0a6CB6xf7CMatf/qItgNHjirRRGkU43CWkPm+ouDlmfhwXZz9oxLVdpecH2ar5fE4appuQBQ6PR8", + "uzTdsP3vyQFkcAOHDU8Seo2oJCqtxXI7L3bbk1VL4Y4i90pkacDOI0K2xNGTxuUUM9S4qflSJJ0ifLJ1", + "cQ1ZUwyfxnu8bPWLO+a27fmrXV0VFZA533+4I6sDL2PSohu3B14aY3bJQ28rdynZzZvDcyx4Ldxf1ueV", + "Eu+vZIVmVNDtfAMeBGBympSaYWTBkINn89L2YsOdxa3rey/F/IR2EqyWTL7zRtrNIhqMypbdbPhW8TRc", + "T9Ut+KR2yNZ5EFTVxIsi8+0IIJLuEGBpAscUXzYTGTYouvUqQO1rRkfWFBJemob6FaE2VmgYVSuxiNTC", + "Q6dk1NkqjaFoLB67jGS+ctUADFlTDa4SOepMoT7shMpn0HevNOdXaDWtO2SbSktveA26N8GrIN0jrBYq", + "q5paDYlqzgqhlPzM2apW4V8ybjql2HZJIiLPJqUWdn3rLD2vIDgjV1+UZGdtpMpQ/QsZMWgnxO5BpcXP", + "KKXO2Xf4NovKZ8++Si6v/jy5uL6a/OH1v+AfIMZYrRtqcO4Hqme6sLYYfPqErR1nqsOjfnd3jdneQWrH", + "iXjwOMRxHfpBxHFya6QccoTIJv1vJTRuTM6Ru6ZrCyNDfbX8HdoGZjZ0uccN3NY4klS7KiSLz3ghzpbP", + "z8jujZkVyb1p+rwyD7cWt6FgY8xDc4ZdKKMzI/Kycou5Z1R6xjLuLEo3+3/4B3ZRl2jifR7Ju5WqLxte", + "YgMwuwiQIEGFotQ8u0bUrezcvThiT59+584OaMPO6hjc06fnLKYWBH5l7qtnWLIUEx9joRz7TSRZXSKK", + "bY0RG/wHawtEO0mUuhe0QaFgyGvW/hesR5XWfYeXVuXcLSxDBHHsveMEqrS4gpFPIPZC1jjZ4Uu+tMoy", + "94mZ0liM+PxrlvK1qWUKOnRDRxRa+OXbK3bGbl/9AVe7i3t9YZPnXLdn3v/nTsDKKaUstHSerjcJV4jR", + "PaydPYG9srEYeiVBjxAtgfAOnFiagvtMqC+rPaMZgWg7gcKxLXUduU4yAdISY3hQI5BpoYS02GGKeCG4", + "Q07PWfz96zt2tgCe2UU89P9MVWIw8wD/hbi9hRiveZ5VjzSZYKqUNVbzYuS53b3axytui0j1Q8zmi493", + "P0xeXd0SVjM5PMy9uy9ISGOKQgW4HtbCTlJYQqYK6h/i2Mo7QLx2LYyvcjtFUvxps6jEcm29+K1qx6n+", + "1ffSs4FIJpI40e8+fLi7vbu5uJ5cvHp39X7y+t3F1duY/YZ1/np9cXv7pw83r2Lq7Aupd9ehRKbC/5OZ", + "0gnlDfgzXZ0aJYPsdiQ7HbMLlsGcJ2s/Fy83YwzDYNs3hNZgKbccixaEYSL3GKccrWo0aiIZg1yOqv2K", + "Q9Fis2aR+wkG4RLyFHmaYodLOUfm8n+NF8qQLy2m0CCm8lsuJNU/BA+Sd3dMGwmQQkby483bEDM26EOV", + "2RoLAELE0h+JmoktvwfGWfyLG/NTzD7evI1krVzhYN4x8vQpUfH5b9kCHhyVKUs3vv3h4vlJNfHT+OnT", + "cSQvqTshuo4wFh9yZ84qtPgfuFlcu6UG2txaDTxHhvO5HOjFafF+ePuMZnxG5eIIiBqzhZKq9J2AY6r6", + "ij0Mynkkjdfl/S/nqD95KX/2MJLpT8bdGAaBvStIGu8lIOtUwsopAKMUfKtgZnDOSIcrN5VrreZuY18v", + "QdqYkQJghv5wRDJeANd2CtzG7hQ6Yw7P4vNnrHJsfsjSIHq8Kg4ydYoNTTyStCQMpsXNReACTtkcyPYj", + "LvfcOvrn2w/vm+k0SPLXTkky7h8XIRmpegarbevrDVu/mgUv4JzFv0QexywanLNoQGLcp0qRGI8Gn9zG", + "tiRiYCUUMfDgFhMcUVhYK+m5NVtyLbjEUyJCbpbTMSm3141O+U80+ng89qNVLRjPB7XG4o7loIGMOlg+", + "x1R3EsSD88FX42fjrwaNFneVoHUn9yzIAYSZ6io5e4Up7d6+r0GKzEILec+4T9lBmGC6mgs+B8Pmyntg", + "IjnTQE30UK1HeJ/Sd27JuDuIKy0sGOqmWgsmZI4Fd9LZ2EjmSgP+SGq3oN+MoAwFIZFd3a2dcT0nj1iu", + "jNOdUGS7uQkTyepaCL7tLWMKe2UadzNb71jzFaVkTKyUtotIpoosZ58MRiBaCOgYycsF8OKcxY4SVM5M", + "3WXiQIkJ0ihGYnh2x9bX1DPEWWRmGEnjs8ScksNnENC0yPuLZW1LnpRl7r2h3j+3DgupCEkrsgayGQ0Q", + "oKWc1KD71TEpLQ8d95lYAm6HsAEuQsMso2AvcHRauvONF0qFuUbuf25YWcw1T0PaEcFCAMK4V8VddZoc", + "zi7h0llo6MFxrFXKeyqrwDRCDdNSZOlLJ2cTTU1rsvANR1PPc/iV5qlyX6sMbe++QWm6NhZyBKTLEWDO", + "9y+kKBP2iYBNTax1Ws40JBkXeUw6Q4yREAyncRSzghpdyqqNB2rllHgRvPnYk0tj50ypVhTkQ6w6uh0Y", + "wWRKYD+pKSVQMGp2Naxa/dRLqc7lgi/RTazyyr5JVLEesxtqbYRZTMGpQJA/wSqfltaGTkCUziGUvEoH", + "54Pvwb7yK7+tWnB5OeokxotnzzbyszcFN8JSYRhwX5CwPRDacd3JmRV/E3blp+Hg62fP+75eTffsI6LU", + "OGUdUnrpq/0vvVF6KtIUsEj3m0PeuAGqFDQfZY2piaZymeeI3Y0pAtoGAWrEzzAkqZOyOmbSYByeYk+V", + "E9IJEfjYXQl8bmqIkx/dED08ixXRJDIwFFp2SPur+oARvnIGtnXGdp8ob2s4m9Qf2oZoWTn5kPN71JMP", + "OVysUAarqLARtS8TdXM5R19wzgVqj4ahRAc9ynlB00Th5SNS3N0GWaYSrLtRGr+QhloaPHPwYDWna2jI", + "yM+G2HXsN8/H3/yfFYgkHcwRqgkEu5MpnqIEePr0wtwHOCnCBEihLYaxTyD1NRKyOrDu9nj61G21m4lZ", + "ObsifvHsWTxmaAJz6aNUQfNPlEHcH7p4cPCLjd9aUhNjy96nTlD06AYOHjKvBPskLixu4+vAk86y9J+u", + "1qRm7q5RRZkhPcPyxuwWlcj4xbMXTi3V0JDx5EEIDcups8IeHvB8H5+jX5Sn1KBrJWSqVkOKJHLKWsP+", + "C3eU/JL4BQXmW/CiAGmoRzIylY8cihQYoEGM7etIpUQ26pJ/t2AvSqv+iGfnHaFke3fAd4raN34R2VcP", + "EqDRPrVTEpzR++lvKHzfIcaj5DKBD4ECXTL4rp+xG0kKHqN9zN77zBf0TLsrDdmdngxpDmE4hLEVaUYJ", + "yp+GgxfPXvzq67tocJBvLkbyDr3SdKviuRj/ivfO189+/8UIgaZR58r9TnrsD9Q1FpCl5A4MUgMVEzJP", + "nXpCjilB2fzzhfU79/WLF4fQxffYoxvys65X9/J/2//ylTTlbCYSZ4TeWqX5fPNqvqyFXmDzJ6YSISgH", + "H30Ne8lG2NFd6Ie35HEit+4cI/4VO1KTSndmDBN5DqngFryTj6HsHbNrdGeSbZrXDF/5lz0YPFry3uXl", + "m+zSktx5nmsAAq8fehvIP4LgCzqno5oKnqk5YpxE0mC0u0aCE4aCZSk6i5+yNyE7Vsk5K5zy2/CyCcOe", + "Pq3k/NOnZKikGGCj3KphJBmbOiM0hCxDJixPCXbfXcjuSmTvYUXuMNN4Dm93x6fkKP2JWt0Q3b559lXs", + "m0XGN2D1enQxs6Djl7U27n51hyctM2c4sQqMuuCIEvw6QONVQGLujQroqznB4BIQ2n0H8T0NZgCF6l9n", + "1uZOzhirCjbFjWhA4no6piXJLySMz4h1VsLSV54HjBvOnn89Svm6QgPLxAzcWGO3K3cb7k63C97lSSbj", + "06co91JV2CoF02l8PtSP7mtC3Cnro+jmQ65Rgh1B4VEWOOLrhwJzy1Q5XzgFh+VClhZT3dnv2PffkZdy", + "xXXObm9ftayYISuyEkckqDKnFuFkywKp95LFYKzIsTzde5xi9724ZVXE7gvNWmrfeZSFl6tQT2id7HVP", + "jnjkbjHDRmZXDu4uECYfs9tVFQwmvTgkr3qQFU9kiglT6g5xZ9UwkSLwTu1TBUgfqYtC3YnKMD1sGOqe", + "zIoXbhoFaGzTi0rrVCk7DEcxKIqRVKQJNW9uj35WKJW5AxdmgX4Id9KJLokv+vBy2mldI3iApLQQmKQV", + "EYUHTETy/hzv4gWNZwBfYNdXr9hzp++i4y8QuVCZSNbuwjFl4WZilPYsrbIlpI1daeuDLOfWOsW5Vmqh", + "kpiJKtw2c/bUSF6YhbJPz93Q3nGTqNzDete5X47V2BRQgDhhiKgWdTSoOgG0AhP2HE1rv7dGZBS484F4", + "n39Gnq5gzoAkv75PiHdGVsbXbiFNcuJ+N1emplTY67OPKvaLpDOyNOY0Sp86WR1Ixx7GWwtaufNGZT0I", + "BOzBc2vHOXpyyByiU04XAO5gJH0nB2a4hIZ9l2TcGDETkOJZxlGGHkdwumYYdyU0/CH57ar0ddTJ0Rrw", + "o2Gdha+Sc9vkp4RgWi1ZH8nv6ksSsx+oqU4RgmOpJt9gI+8et5dk3Ji9Ed7/Sr/g1exUHkxQ9DYhs5pL", + "w6u6maqTD/4bk7OYWskhFsNUnEXO7UwUBsGzGsh3dqXCRqPHbRbcoWR2RbLjUGWc/PuqtGi84On3DE1O", + "x9pRUDmDkr1qDLKi/4OJZO13aIAqo7oT8Nu5O8G+p6uw/iqjOEqdkFk5Fod+Cphf5AS+s/o+9hp9DQ8F", + "xU0uNTcL9H7a9XmltLjBflKllqheUO4MOoHImTiFQKFIhk8PcSetsxqtyilIPGxoB4nKp0LysKO0d/jJ", + "ylShvnRVymhIcfJ1VCznBdqZgVCUj5+oJVbj0c6M2YWs7WBIiRVFI13nZdWuwj/hJXyID6RVkFppjFsD", + "aeYkoSnEzRFSC6FosJmfsSiKZajxDjZ4Y4vDvRRCxQ2zPthuVK5c5k5ctdHAvNHGs2yk9ChUOfiT7DUZ", + "DSNd1ikURFp3JaJfk9PGtbPLrU9Fh0QYQF9uJQLrfQ13MI0ZVKUi4wmk6DpQKw9aNA3XcjXpSCYoqyl/", + "F/PBqkt1yOrfplAxT1Vh17iEIhm8EuSva7yGuinqPq0XyWfR4WfwZzgoK9tu1l/fEm6IFW8G/2+Lt8vi", + "3VAxx5sRgaa6ie4wijB6S/nvwea98QpTS0NsOM4aTuBH277+W/22700pDYuvby6+f3fBGtGeEOoKECW5", + "WkLLLx2ScyUlSwaBPfRVWgGm608Xbyndnnx97HYtk4VWUpVmWIWBUOQnFMQTNugCkimdUvNL0gqw+iWY", + "JzQLYWlmPs4mIwkPSVYaJ1qoWMbXRWAaXn05UaiturcJicl7uOmQelW3kqD1IlD/d/qzV5gqkRImQe7t", + "MbuSuPzgmY4kusaJkqGFj9WlpONFCmRG+dzecJ//v+z933IbOZYvCr8Kgjcmq0hKVts930hRF7KkcmlG", + "trUlu6u/M9mhBJkgiVISyAGQktgVFXGuOuLcTkzEfoLzAPMM+34eop/kBNZaQGZSSUq2RMmu6asqU2QC", + "CSwsrL+/X78CXMCpJwo093JauFRO5uFHfoITnWd0VfnHQascXTbSQQ4REnFB1kJyFilhMWCPLmVMGYZ7", + "F5BEK56XBAhupBG17KLTXhlDx0SV3ajZGrAkeyx9tf3PaaIiDx3VNdQzMKFuYi6g69ZvhYwGlWVVF3Fc", + "kExMDEegAyw7gtj8uK5VZZ57nwpOX23WsPLzwsD+YFpWjyH3Su4YbL43P6u38s+JYW6nIdtCEXFIvNcu", + "WG+eSyXarqEzfMaPRohTL9YbinbTMLVQ9yZD23E0wKtsuQfOgp6TStrZ7++eW47Ze+m840w8brYTqC1u", + "q+xmQr6Ziv/smyY2ZwwanLitlS1nFEf1lrpQzizQba0go2N/x6VUFCr0rh7izyYKVzyqTkBbD0pYqCt2", + "xY3F6kCeIa/A2Agoo+W57SeqyEsbi0swPhB/5k8rRaXyRajdqyz1IV4CFewNOfGSUl2xYRpmnhldZOCg", + "xlp6+HyiDbUcOsD0CJi+f/rw/99/exRKB4PrbPmVVNOkk6gRVwqgMr07BTWB0rK5hIK/Nn1yIltI2u0m", + "iwhujQaMzi2Hwn/u96xl1+2TKYDGOYEZ1aZzW6JhUx/laGwhUcCdJ4TgcSziWsZ5WBHARLogT98zKMML", + "52OU61EvihfEP9OwH8Pjw24v9bp2KkxhwBaLwXII0mPcKI4aLQ98OvMPj0a1UFeDK27Y+/13R+dUSORv", + "21A2FRFLNKU4QgHilTAj7uR8RdHLPizPLWHapOSuGnJ1IUwOjd5+dSOf65PXwjQnFmdvY1zbXzbXQLSC", + "gDRezRy9e3N0eHj8/u35xdF7LOoGBP3e0ol4SxWf4+X3benEu+NQ9NurXvYhJkTFsVRMQC0cRHMYerhH", + "FCxGKewH+QS2MCpLsNccS9JR5M9pBaBJugvhSBuaBUuKCCK9K0ACY5Vqncusdt6gvrFUTpfQg+UN0HOY", + "M0SywQamrmpcoDXHbQ8DX7En9YWNKHYX/qa7gD6P1Pu/kMGB5qXqrhM3LlFVeZq/OCOyFsKC1OpQ4LmJ", + "6qb+mT/4D4GJxWr1A4wywKkHGIql2gt4wfYz+Pg26YrRPqscY+c5lAFOHNrjCkBpAs7OIDnSgjDiGd++", + "+4y/4Vl85ee4BOltILKbyclEYHrus8/7vS7BX/3l9duWC9yWrYGJN+idcQhkXw/4NV/U+n9Daui2ghjz", + "PLeJgpw+6/rzgqipMBEwCiEvEmez553Ia4X8huOZzIkMU+c5n/Me6ZhzpyGVFnBCKK8nHGa1MzkXCnK9", + "kNRWidKXSOvGPtlA1BbmXBmRZOj5KfvxTz99TNaZDeFGxi2wApu30K1F4CxUZt0RZOgXfUpOfTo76Qdz", + "MVi8vXqCxmvQNlXwUbTYkQhRgy0dFpjDpN8vQo5DqNiO3+HO8snt105hhL6BZe5QAb3s9DtXesGnrQwR", + "f/lyFVQVKZ/WUBVwUre6cOE1B7YQYzmBxsTKAOpCLSJ0FAjA3fMv2qu1bcYezSctI2vdqIiy1xplhnwa", + "AygKoPERWVAjX6e68qbPThvdW+1FAj12jWyoLKinJhhGXT+NRIWClD5TwkEes1REl5ILAPOFy7GpJQMH", + "M/al3XITSFBCnI1MFX/oPldrQjHNINfjS3svX0GqAaGN0C+hn8jPqFSQqMfWsYaPyx2SbGMngZBmqRnf", + "P/f4FCOV3ePTPvaQ9ljBJdgaMBJl30eiWlFsoY5l9uDFv9r55yGDOD0VTwyotgHLfEQ+GcwEzxEyBBGB", + "JNw7GIS1DFkDySfBWieOAbmBVIC3Xk/OtjrEJ36+J7CkGzyJcZQGEn5bFgRVOu7x8zm+PEwDWnW5Eyg7", + "OK+HyK2fgFhzv5/Iiau6HzFYH2CDoS8XW1mXH5sOWepVbcoKOb60oYwAxHyXpbIIdMIRYvb4lMGKaeV4", + "PrDXQhThB3v+Bxcg16m3rhu/q8s8fR9EG8ppx/AJei7hOoZ2HZwQ5KQhF+o0ziceKfJz0NumIamL3fvi", + "w0QdZ2JeaC+Ku/gFtE0uxSJm/is6b8x6xRLFne1X7QFmK6oDsLHwcn2Qz7LgX7XBV4wvI3JfV5tY8ozV", + "Qb2njBZ/QVlts7oVJIC3n7LPPmTgwq2+F37m+aXFzue3bz/9eHGwf/DT0cXh8VnaKGZtBmGH02k5oZ7C", + "T1ZkiRotmsbqC1u78mAKcAK9l6wDqToC2M/4lWBOJ8qfU/bTj4iSeHwI9tKMqyyAUkKPYgTaG/PxTETY", + "TGzPqkzliTfrCSJBY1O1GDhx4wA8gUlVlIR+Aw3NVqy6Bt7h6m2ypt+PsCr+eeDfEsv0c1iAZ9T9Xjxo", + "JlhrM8bJhUzf5wqmCUmJ1bIZqpqrKuQSvJJoL+yyt5rNBC8YUs4BhywxzFrhoGsL0BnJdSly7oApS9wU", + "2mJGGDLJ+QLhBye6NNB+yafIEA78rWCWgK6WBp6JlggkS4g6KIRezBqC25gdDlDR8Ddpsago2GSN8k8s", + "fwrksdATiHGhGlQ0VBONda2jU+CacBfLb6GWUyAQoAS7CwKwOlEpDjv0v7iARqwLSOumzBnub3XYAPnX", + "WPGXa2oeBY70fA7tv1oBBdkAqiGhmRbf8QLecRjZb2MbNiEowgEk9C/i9D8MLwuXpqWW5CVi4LD8iN2C", + "jVP+c9icRNFv8kbzG2i6gMgB4APWrwjPQ/c7Fg9CgzJxwYMJGfM10rKRmEkoRM8JLwlLpeqZ21B5Lt2K", + "sHXIxiFF8kZzqvWB1vRqlviFb7VFsyYToIngdb5cH21xxfPFX8WaMpjAV0iFt1ASi2NTQUaYEvmWsT+j", + "KsxA4HaEY4f29H7jwkVdAilvKLSbcjPybwV0dHTSE0UcNKFyibInPNiXDaQZjEdXBTVYXnlTCGUDNy1g", + "reZ05htKKqg3iCknKh64ITsIdegOg2ksIFejMoomux1zVSsRp76yFNbaSgvsNFAqA5hTdHW3dyFWOwU4", + "I2ko2PZqNOAgeds76WBCVQLhaW2FIjxc0okt91DEWlVr75LqlZD4xqr6kG2oYgbYNYCeaq3dh4JlWHdN", + "lZ5Yb1+BTKLpUbVfBKBZEj5UVP71oEwTOSdJzwB1iGLXsggAck0ds4+POKvEp7P5yo192shW75X+FsH4", + "v0Fd86OE03n7RH65noHtXa1lANojVgDnGC6pnXi4D2tMYuEoUZkV6hFoVkY0CLCda6j8gM4eomDaIBB+", + "kDRyQLEcIVJd0ZU85saQe4l1kqi7JkSXXJXQeY2AQZ9EzUJdPI5bYe83eMFphUU2xIKvqk05UeEFKb6D", + "k+ZVeysAlO5RMXM4SLAaESUlsoLW2PkBYBLQgsFqqh/kphueYEOIZZy9PcCGFIB1g6Od3jagMqMLS8Yq", + "v+aLIftJX7MJN4lKjbXha1gCCVGqYJ8OIrjcrr9ZTqQqb2p1jFNdKUj/6YdzujvI9gyWJIwfERD9BPf8", + "4+Z8/OEcgVe9oTTn5tL7cHXhhkCb44vqmVgzaPVcYDG3yC3ifsPmzIeJOvIKs/ZHLJy/hJPRWk7txT+e", + "vA2FGWiQZ2nXDi+4oqIN/hzr2ViX4BSoW9SfO7h8CNnf9p6+4m39Lw60muQSkfafvJe4oZtRUzYVZV2a", + "a0rzs7V1CbSvA4zW3yu8TjCrGaPfhkh/9/ANBPn+/rf/gLya/68RYz2f+6OeEcGTP25jDs5uFX2vONWD", + "6YG9loyzFFcnZXNeIMFXDv2EAAMNKJYvbGBnb6Vjq5WjJZ3DN0mHbbGkc6Su/P8lKgFrl+aYdFjhzVYl", + "bhx004CNVCOSuu3s4Boc4PJt0gxpDNRy3I4QYPFKLO3L84RUzrxHK1ZM6QvrZM6ws4akEJ94Qa1e1ove", + "kP3oBcIiaHedAo5UL4W1KcOjr4Qx/tbu/gARtRhQ89K7VZddf6uATLwVUC1zqIUFfObQPIpBBJTscKlW", + "YhiwRWsdamT2wxmkH26Fh2ErKK8ZDuz008c2ATwtWwRwA7Hs+hifgH/7qe+aO8Ufp5U9tdA/Qjz8nN8+", + "IEE0P1+hB5SA1WHHD41Yt+O2wayKHvsMkzXezoSgUXgq0bUh7QvmHcdGK8dH3mg12OJPETJ/YC5MqTAo", + "NkbQSoLu9BcBnwPMvI3YbUBJFhocJxI9TGxbwIpJ7MD1Dq3wOhkOEiaYwtARaE4bKJYG50FcR/8eX/IF", + "BLq4dysMwrZl0gLoBOKpVdcRTB3KAqkBhOOCRWY6HJKNSpm7gd8nkyihrqTRCoJ8mZjwMnf9CiLBLy1X", + "FUodrTv1nCQqIAl7laMBGHLGLdPQjimV06tC+edx4x94DJeI8bn9DArCMInsI7eXd5Lf47P/0lousqz6", + "Y0Uy/ujbc7AhyRBAQ7zpA64kp5gaOq8Obxmgufnig7/1q+Jz8dtKkLV9AhTAq9J7SLmYuKU2pn1VP1Vw", + "PuGsWugv8nYVhtuBTxAO6R+22Y9iZEqONHpwxmdaCf/WN3xe5BSDq1rOEf3k1c5O2uy9pSJCwAPGPgf/", + "XtQVHZANcHivJeyQnUNzgPeMuZlTSy63l4mqObuxhDsscRWlg/xJxE8VzZ7kPIf+adRKl0IQE0/UgNDU", + "XBiB57OpZaBlCrBB/gpsTgeoKxMVcN4tQjrtehWbaxcWGsi1qo6zUB5CbTPUKgqAC/7fUMqbMUqDTCB0", + "kHMn+oQDi12C/tiEmMY4hyL3dOx376IsUjJatBVYFwORAqF0OZ1RAxeOCcuTU+UKEiJTtI6znBdOF4zb", + "XAhIzmxv725v00aF33tf2v+NA5LoLUWGt3jQIreL65Z6ikAVQ0h0IoXpMyjuTrPRMGD4DYG8+lZBHvxn", + "XUHeIxbb3UddPo9NtaSs23u2UENBJlHp6+D82Sd11l/d/Yv32v2oS5U9v7NO4F3UnrSk6r9Mszf9gzUR", + "1aq8vypWxkL/7h+2kexPl67XB0oqqWJnAXniicKSX1qZkLGBkuBaoM2ff+uWTNZhFZPd2d6pRxn3IGXI", + "ahVM4YUQEswbmnoEOpNQ+UhXYAAB3jn+M6gRw5WVCGpxrAbYBV+DNh8RzS2lpeY6pJeDjwXG5oTLHF/r", + "yJjzCvUHOrDB1gQUhUFm5JVQZLlWXMPddCxvIvso4nQHCm+kW+itKD/yUzjHRdgkygKNtE8XarthRT5n", + "/M5TG1abbTutNQN5G3+UVyBVgU01QGxxpvRAF7cCGZWHD9XZAfk8uPtfeporolfy0m7FlkhCzgMh6eYu", + "gsZAbe0deFBDUekzdWXQggdriLTH564/kGesXHZvpX+yG+4P9QPcVRHrv/PcJVE8z4lr5O6AXeuFVC8I", + "BdhglkolgdA3UIhgHZ6dcYPlSrp0Az0ZjLjKqM1YiWuYBbjiOZ9ORcZSr50v0GGJjyJSFnCnvHofCcpo", + "1alLpFsiLWlN3RjBnfBbsKm0TRzgs3I3Lx9VBFuTNjCx7PeWi2nI9rG6AjDOSrK+SIds/Sqz31DmIed/", + "uxuD2zHPKqgB/6sXth2ic8jOAhaeppIKNIaA/AmA8v3NRXQ3twQWM0RRYO8qJ8avZ1+vEd+W/uL32qv7", + "9GPJ7HOdv8Lbk20ZidqezbUTTJtgZ7D23YsxAqjaW+0Db1D5VAM8U+J4lfKhGP7vzbdscw+NzuvCksHN", + "9gA9hA0mg3AVgo+4iXPQDhkNlzuoU5jXYDzTVijmxLzQhptFRRjGEfgjZPHgREOlX/12hggdtgd0V170", + "vT7xUEaWTol6fZLr6yHbVws6cHMs8xAOOtz9iHVyYY6IS1G1YszDTIUL+lrcxlaG8lsgu1vZX+Jl/DTs", + "xgZbTOrjfGXHOUwLV/93farPUL6CyERx/4wDTVyLaz2T/UL+q//OHXHRlOc5hnTxOGrgqgult5iDANyc", + "patoX9Xrm7rasFJZ4XqNql1ko30RG7RChBXYpyvdAjyRnbYmZ57nK/uZNwVrAut2l8v1r2Lx3B7XfFHh", + "0GCbV47/kBPcy4YUBZFZ7YDV63a++w7aEJy4cd99x9JJmecXl2KR1jBjx2KZM/sW1JOdQS0fUQ9yQqsG", + "7ibCsE86oSk1kLokGChc6BIdMysIBQAqa5JOIMMcsvOKNRVxq/DnKH/IPVgYMZE36Wq3DTd7o44bDvFM", + "rhsOHh21djkeP9SPe7CTZW0ZfCwS6XbRbdGBd3pWgDbsFQxVePmrOBT1XCtyqPZVrWGAvsPVIlGXAgjJ", + "rvQlpfAih3+s3TH6mvBu6DwgHHAoJcXMJZkAF9ylEYyizKRjznAJKMiA0myuRNb3RyRRNVJgIukFllvu", + "vKXkaiF2OBi1+PSr7ZftloafQRT4TVh8dzuTOIlvxZk8C4Jwf6lsYw6+s1Iy/TXpQPnwRfxp0tlloBzS", + "qs+zQeVL3Z63dC6WMFoEUy1yrjg2g42NEKrR58m6SYcKeoByARMV4J4WuabS2zYa4O9q4H8qi9RWSac3", + "ZO+RjLni7Y60zCuKIt+EN9586HppqHXXe/wqRY4b1PGd3X/7S11Mfo7AiPWNwHpwCB5CDX7cWtYtgMO6", + "cT2XbtYiSejLND211rv7T8LICXCyUnquipn2WVkQLphmqRLX9T9hG32iWmOkaUjq+VMQbEH0gAJBC/RB", + "SpsoDLe4iu8c+iJCB8TSe4QSSy/Fl8Cky3N5JXpDFoslATissm+aJQdt5OGtdzwMu2HPqjnIQ5v3ox9U", + "PjS+8UjBhzrpzJLHcrf8gl++Wmo/qFC32segf3ou3OAABGiX1aj0f8CEqcwwV7oXeff3EnXO5+JcOvHD", + "uTNy7PbYKXezH7bSJuAUyGfBF7nmGZWLr5J6DK8A7jNoXn/vLZ3t0PsSYhGVZJOerSht6MAQq0JbPR6s", + "0WZkE579TJ4+jb1ax54AlT2Dl0dqYZhDJQJtwSNUO6RjukEM+mxJCnqddabKb099qFZcHEc3FMoCsBT2", + "fRULmGgo6l563XvfG7me6tLdt53OXAkzACKSMKDR19S9a50pxw6/CZRmIQYHtfFp7Yym7Ery1Sd4j73j", + "N4P9qfhhO11xDPyU76MjgxRAuf0XKsiGqjsKHb2k52jOd6/z/H6AtKB8uHMIEkEZnoBMRy/z4SzcdsNE", + "HUPI0V/n7RrqVvMKVmJHhGadKOBMmpQGPlD8Sk4JKz907bdrrhVW2ruNts2+E2sR12q3z2PsdnhezU4V", + "GT79zg0PYd07tx2NJaXVIDRoNkymEBrre59XWDcAO7FP4Bppzq27sEIo7y/2We3fsiCrrPZZyaNEgKRB", + "lbottGOlmvC5zCU3xDKIuEuptBck63TbeWc1qAOYJrL4kAEHdbhwiazEhlmch5XZZO0JjnFXbO48sgd+", + "cXyuITD7jZMagdPrVtH9JaclXtGWno0L+myu+mNo2Ye5314tE73afFEtf9fKqWJI/kSACpm4kmOx/mKc", + "SjcwotB29bV4rKxAPlMqzYNOMdZFH/CHQgCxWa/PONay+9Mxle4CHpsoE5iVhIJCSmhJBJQI+EZaZ0n9", + "RY8iJtl4BsRvQJ2IZS+ZuKGf+O/paCbj8TXQRkvgsgCgAPRUwM2XhtcNb5AGeisqpgH8wuomUjpR19pc", + "AnQP+lm5VJfIEOg0i1ietS9dSW87h4GqP2BysRpYTlgmLPn+iUqdvvQaDBtlgrQSx6u8Qo6/Qts9ll6L", + "0UzrS0B2ThNFjTHowc65KnmexqUAGYr46txLzMDOtEtUfExp8pR9Xz3WirERVSAuxj4w+IfdI1hRQb9g", + "UrG30v1UjgISF+umvHQ6RY4a4FCRLlDszFtrOfez7K10Z6LQm+LkjgM8U7SZRl8Tbj4lgaWQM/seUVTC", + "iXmInvl6urR/jifikDL2t1Dt/Dt/H3CjgmiB9EsI13GLRIEq4/BdOlQ1BReO2S0lNytHAzhpdxspc+F4", + "xh0HuSV2V6ehcco/AElX+Vz0mR3rQth+jfh3mKjTkCLCEDTmut8f/enorGqXgTpoIBBFxs69mOiBZyUq", + "5pmgTy7AWErbyCz5g98Av2m85yqj5C186SOuxQbNkto4d5km8KWHJQ4fRwQhg0ibTeJ3uv/Rsm6UieU8", + "dFO0VqcRsYIcLtG4tShOTcp9NtLZosFgINTYLApkKMDo8/7R+eDtwTvwLKF3SvF8C7U3lsQFUgOSqJlI", + "1FgWM2H8sCuuiMYbxixOXQ4TFWBUpGrmsb3qt0N27o9DYFwA8PIacDIuZ6K8OweYRxNhTCD/zLmDBk5A", + "Wdljp2cvcRcCa4MXQu8swHlLVGD9gJyuWqxOZNZkcKPZzNo4z3fJxDddecJQsv9n3CbniEoG2dPqKLMu", + "HSeRDbi3fK1bd5pX3SF3pldPQz4UAIuQog9ppWh0gH9vZOsrizHkncCux95BAQwKYxEookBxZFUPDnWV", + "R7N7GKxK9uO/IrfUh/fs8Ojk6OMROz/6yN5/OjmBds5QmgV2uq1oVGEEI650IBMsHaWHjRigdbIV7MBE", + "TQCeCKYK1Ie04JCarfqEECCIh+kjZFowu1fX5C4f4s2X5n5m7dPjCGys0b11/6y/bjZRo3gndkglx3jv", + "ULpdTzDDSuV+8YKDX/YTdSlEZNcH9AKJ9Yx+pngvAetJ3fi5BamXKFqZLvTDlVaYXizAyeWlQDM6oijA", + "WLikeH8gPZUREyMAVilCnPx58GG/dLPBOX4tXpEYhh+yNzUOd5mBAMeW7z5ZiuIG7+PohAIfHkY348lF", + "In2iQEdkYqDRH4wkkoTH7HBF90HdkF6HYezMMmTXN2IqlD817WcIK4I3fxHeGueZEiz3ugiNdiBS3dtW", + "T0P4CBB3PNMi6/0eG3Z3Nt8/eBAJtYEPI+g1p+PRxvIg3LHH0qZnsMMUuwUN5XXTZ+nWtZf/FkH2349P", + "w59aqLZ6AaVSVnsNQU/AvCuVEZgpV9ISu3n4JcK1koK8XdMC6oEH4lkDHowoIosyzzKI8EFVd2twJzP+", + "ig5grBTaSlSYH2VtCzm+ROaAmkfuT0xpxaTMUUGBOt6iyF+mhVUvXGTvi++ICO5IJHe+/+5kUBhNzEfa", + "TEPJIi8KwQ0rAXxsy/9h61eI1/+GA/QiWKxfpOrc4qG9RY6/t5QcokGyzAhr6ZuonkcLJrNV7jMokP2w", + "+Y8KFFMXqXthxaCuo8ncxorpdwBVvHbJ+xWaQql5E0aGV++DP7kPosw+Au77c0U/Z92XmGv5nm0Ph+9h", + "M3tPZ4eREtysOotRKWKnWdJdz6ZQHzkIUrns1e5eSStHSMcdNenTm6fr1XLMZdwDhLHQlXYmHdtn2mQA", + "kjRasLkGJtcxuHGJKkpvLiKfBWuhs2gqWqdZoYsyp1vIG5yFJooLUFw/e32Z0uJC8D9g7jVifBTz45OJ", + "zCX6hINE8enUiCnYMIDOVdnCpBtr3AAwcO09E2WF8BcG3Eh9hOMeabgPAPYLb6G/ouM3F/ORN379dBPV", + "mK8VDfKFmXSWpaGjqq6pU6TAo/bDcK9ow9IWtZ5imYfy0+gzhLkFB1VXy3UBlD3BOo78OQMw8DMCFb51", + "H80lKHp8NN1BblHIMc9hzJaraMN3DPtUeEF5vb1N4oh1fBQl7r5GNN9E6Ql7ub3dG7ITbqZ+CWvSwOwM", + "FIIR0IBAQG9YueKA5nMicycMghuDBDLO5sAIHdJYgX9o3Z13Bifrjr6ZDwWy4kEp7UAqKwBk5AqYFfEM", + "M5wO9JCXeX4Bvt+KFph/X1uw1F85ehAx7IBzGj0/4nQNvinKtJfifiXYKFkIk8dzq9nI761b3aVDv/u8", + "iZ6FNN/1LSVghdtjcqpAu0KV3LUM7DNrxod5tzYLUSJem+kmeoaaFkzUvp9hvkDq7wG2iyG5/BLDJVqy", + "8kF4TP+wU57NTllOEkrx1dopWxQutVsItrzGSgEgS0zAQHFjgGcmSHzMvmcil3DBfzo7wZsDMDS9cUAA", + "0ASLiDCgyCQxMXq+yzjyUsy54lMvG6VSIu83ex4G/no/OP7zxemnNyfHBxefzk5YVw7FcIlwac6zOM3R", + "IlFSTQzHAsnSCIIIuhLGQr72ZtFnUk0NVjc77uSYHZ/2wO5QWiF86P7SzPwwH04/Hn94v3+yizpzaWKo", + "OPthbSyWb0TqTK4W9KhlJxrBBzA0x/iVlhm2HCkMiicdpemXSQfzz4XRo1zMqwYU2htoVgLmTrAOYRlW", + "1A3+jLP8gGKwwWBYc6C1kNe3pIqE9DEKSeMgTWn2Nhed3+XRa2cVV781IFOdKBP4dtZR8gwg1x5iLY1y", + "mh+wbKWKbLywy1PjjsghqcAtiDy3gsHZiIzxJLT+QxASEqg+NAUnqim6vSGrCBqH7KxUlgUA2zEUJmns", + "koHTDGGh6vFEGb/XrCaoGNylY1gY1N4JElmKSE7sE8hiHHM17UH8CtOl82rrmasCzsQg1D9BO/EtwQnG", + "ey3dvSQln85O7hRpo8titeu6j5SI3nVD+YXv70E4blrm3KBzBSzeIe2P34GLZJGokcg1GL6su1wp/cKy", + "pAMIUv7P8CsA8gc+xjFQlqEr21tZVYKz32Rg349wVyUJfOnRSlzBwvD+9WAaXi9aEPhBveCjtQDBf22z", + "pQd+hOcqOoC3W7kN4/8BSFi4CYzXxGQVZEUUmVuH/rNwsDAgY2eyoGIfTDRWFacBCi4UDYAhE7XBmjx7", + "lNXfKfjVZ2xRfyWk5IpV2n6iQ/WNrPlbwHL5rAVfG1f6U/Wk48MVkNQPwCRrTZlvUHXXRniuNPkqKQss", + "INOvW9qeQ9fj0jyGrt8iJb4Wqgi26B19cdOigOPcZV7ht54W4udhiggxgXARsQTgq1dKrebkfpbV9mmD", + "rRLVIA9t2idh4VkmMtaV0cnt/a5xzPazLOBsQvzx0XTF1q/+ocfr2+TOoNZ0WVLuuVNYqPpMe7XkcfuZ", + "hHUkGtOv+uDeSvEA+vTxIXBAwdusGAc39YtDy7/o0fpb5F/8F9rj20uZJBugZm7nkCgH62eJ9AGdficw", + "9fq5I0VsW36p3z7WrWzVPX+Xy7ls5tqoC66z+3J7u9+Z8xs593N+Df+SCv/1sn87i7RJtLx/0aO7rtJ/", + "0aOvpuOl2YFpQ2sn22J+1ShhWz9oVa16U23F9qt1EnkavrTBDaAx7tqE09gp+qCN2L77R8fUpxOyZa1I", + "8abi6CqqRWrpbVsfdDqNbXGbCzvRGM8UeApveHcv5UPvr82mSD/Wu6hC0cKMW5YC79UFbflFwDhGfP5E", + "dcdcKR1ekkiygnz0hoyCxdwIJm7EvID6hcpn2uxL7cfadwLjk5alM23dhb/50kjGDW0C9iHVyw88d2cx", + "qI9tB/fsJg2fbv0643b22xbAHg2s08X9MKP9rx4HNfonbrIBH8Vk8bjRQVvIQuRSiVBPFVoTEtXF1Bb2", + "8WS98OZD9mpnp8prhl2UgYUN2uD9/yUqIgHgUFeSw08OTo4hJjnjV4Ip3UDRidNxOlF+tVg3NFMcnBy/", + "gHI0NuZqLPKtA2fywQEVX11rosG1fTbSbsZGwrqBmEy0cbuJYuzlkJ2igbIV2I0aAAPf3wIPsNSTLq3/", + "PWNYDOaPCxrWtaYQJH+ihEl8Bzx/8ccO8qUAQTAXQ//xDiaaCc5GqkFkoIMFC7AnXexg7AHgAbx7LrI+", + "PRcJL0s1yvWYcEgA1xtIk+A5WyMxlQrBDCa5LIg0EH4dto/u8sDMywNzVQ5/oYQ7HsnBWM+pBnE8K9Wl", + "3bKL+Ujn1MP84SMz2k8QH9adI0UUBpdxD/EdWCTn6xH7aA220y7UeIsonxKlr4S5NpJgl1rR/H/05+vc", + "6eLY/2STbE9xpHU2w4/xuAcenafsNXvOlsram3PlZbpOGrasZb5YnQZEkjuLeIO2Cwn60MszZK+2X61W", + "Y4nq+htW6QqkhBl93cMD2wTDQIQQQJ3KSAfUQEEhMcqtExEXhEoGzgOj9t//9h8s5NZX1IKQvVLHwNhc", + "ZxTW2t2W6cZKfGuNk0CUDvmt+BYNCId7C2V/U5d3O/XJ+bVEir2alL6woB/9C8x0xjJpBPQ1xusoSHPB", + "p2LXq+5BLGRBvHoSwaK0s1gNFQpCAtPe0EsoXH2NUoYXvHT6BWKQBzxlB8i1uiqA8JPApl/GuojmulSL", + "tRXKy6hQBTHNT/c/Eo4XQ1DpXb9VF/5RvSE7npDzg4cD+oVtv15pNuF5Hm8x/5BC5znST2TM8oX151Mq", + "lirtRDqEhaGvpBHOADKjWeTiNmwicAsAeh3BFK68imCsC7++CB95haBVZtM+01Rl3MNlXFrDYKq/wCkQ", + "Lg+Chuiqsge2eS9SH2rFMn9nZqu2Jj62H19cTyZweaMcwVJccxKVSiZqxhLLqkIWCzVxoDeRSxxXGdi+", + "dWnziH9+hzZd3XLaVGznCzXedOdpGOe5SDxuz2NVhVNIssFZD1zpMObvrAr5WEGTJ7zoBSq1x1T8kWY+", + "cMLfar8mLGWvGSyK4JdZI1tYO705B6+t5R7Bhi05Ag0Qom56G+sh7bUtAaBQgyIHg2kLVB52xusYcYpX", + "RT/WzIInRAoWkBqwrZ6696PLeMqtZRHEbJepMs9TYN7Qc+l6iJzu+HiGegZn70dH8y10YjFuqVZuyQuN", + "4C8R9CLT3udQ2mEEYW+9gmLd25Ze6OmJOGYWCdy5HUi7yzjqxRCnqEXldAQ8gxb+RFG9KvbsT7nJcu/j", + "6Qltmb/06h1SOs9shXNQ4WCUtZYycPGWt2q0AH2NODlh2qZWl6gNTEY4wbpGDKx3wJGZprImYL+rn2Bj", + "ratPpndfdf4kSAJxoOeDElhlMMcqiUcynL9lRu/71M9iXXKbguaOcZbJCdSqubUN+vfT2EibdFtRt4eJ", + "veZm/ocr0nOPpss/qHzBTj4c7J9UMJpN1VQIYXrgVAJnNrdWTpXIsJMzxu7ij7khBhdQOaMFoEpOFZET", + "ANvPq52d9rJvfDatwQfimdoMwRoOBWM80zFekywIxzi4hb9vgjXcCuxZAeofqIdpJA9WZdbvd/TIm3nq", + "MPhRBSwLmD7N6O8vehQQSFfh094V+PbnFM2VGABui4UHZ64WDe8N2aHIykJgl3VhoS63AM8qUVWfhiL4", + "8widVEXXftEjMFjeazOHfpAq0u9fLRNjmQkIUxkxF8rxnF1ZaK1t9pEkqlv/DuIJBVxdkV3YGScI2rE2", + "mUBgJmeEGB7KySRRALYrMruHzw4U0AP4fZ8V3DjJ84H33EvoYh7rK2EW/URpw0QgkR94dzanxpVeMB/9", + "E4l72mnkkfCbWea5tzxxVZehRvDTzMgJgWTaAjod0b4KvTCEyW9ZzV5uvLE3kGZGK3R6Kc6voG8aFvl7", + "SqZw5Es3zoZ6FP9gxWyOQfQWLQu/rJKxa++jnytSjTDhxjRDvgKNZYRkSRQBxAK1ZjVzVmU7mCkV4vDi", + "crIYePdWIuxK6IeayFx4678QlhVGarOUA9gyYmK3oJtcXPjDK2yPOvB12G1cmrgVuDure5f9jNqLOSY8", + "tyIWbYy09mvdWrSx84h3FSwNaZNsXQ6AvhoBeolpkPwFykF5gc3g8Pf+Z+QH3lGrmfcyQsRxdVrys28X", + "bGu4T2nJOX5z0zWzx9n92pFkZpfvFQpEOv0tldECrV7VDbUq3hLf7aFlehu10VdQL+ULdvTnj0dn7xt2", + "OjF1Ltvqc74AfAh8YX/e/f9Cvw2POF9bTQMrEMGusM1BdOnFP+pN9iDASDTEQ0t9z3EF/scU+cL7tsr/", + "A2p+2/Xd1q9T1DVr634/KVsTnB+Nnt+/m4t++3XU/SK1ZFjOv//tP3EZsTf1a9Un/S8pMKZt/eLK32Vx", + "oajgQKqJvhcAFoZb88UA4DmAPzNEFj+dnUTs1J/e7R8QhmKilvOpKyuJQJNGBYr6M1GVEZ6CCkWvYSwL", + "7oA3+RYIQXSzBn7xar5WqDBC2yKXEzFejHOBaLI6PChGemdcZTkkQEn7br8CFPNrzTLwuMbI/mn7QJ8I", + "PlgpLawKIE8B7YU0Ypd1eY9olLmbgSGcsoB0aITV+RUij6hFFYHnUN+JgBzdUa9hDWAZHAAsx6QaO4Ci", + "QIRUThRgKjuYKp+P5LT0ywUQRWBQsxTQv5YEIiUwSOAl02oizRzHEmqM1H3e4RAQf6uV59TFCJaJ20Ql", + "ncYl1q8tMSQWQhom6ayvcqBaiGMvopuHGvDDrLPO6GtsrLXJpOLu4SBAm82mHcnIqBqkB3y7mAvpsw9n", + "K4QrUY1wRv0kAkNPc0cJsrM3TNRhXehGCzaeCQQCXSd1VG/6OH7FzzWt9H2Ac/WaCJPrIVhshYMb78kq", + "O1qVsX/o2l5uqM0d+DtsyA6NLpq+AYDBSmcZed195t3uPnjnDL3ufqKATimEVOyQHQoE3JFXggmly+kM", + "oYK8ISJMgMWLXFGQ0YsssqBIKpgm6Va3iNcry+/ZJA7SNtLZ4qu2CB9cSxybzGNeQ2VQ0y9DkazIGJQk", + "3R1hXd18vnL9t5+wtP4p68MeuCtvhWM1oiCkqYJjfh8l0TZu9ZWwUj/5B64p86qf91gYSMA9CDs6M1Jd", + "Iqq8FxSI5qH+TVRX3ED54UXBnX9P22dzfnMBQTgr/yp6e3TIa+d4JBhH/LNEWZkjC0UmBoFYKRhpd+V6", + "N5rf/ZIGkn/khB4n2PfAU3XqBb2qLw8y/YWpI7gwtyYBu+thR3AF8lfl9JD0UC843KqxtrLerTCVDi0d", + "XSLEtUpUDAwFr2fEx5cNr2cpv+t9Vn8g4cFZqEKUBoPoFqsk9RKZ0pyPZ1KJPvyS/kj1I1BLX0vvbv9z", + "oig0lWbCcZmnzAmsDqyeifF5qpGFN6a+HCEN09eKZrOwTsyZ0zq3Q/ZhLh1LId+RbqVCZWnjKdczneOz", + "9iqM0kRBd4Z/6ZeDEbfAYj3OS+vfEpJmqoRO5iH7ULoC/Z0xLwqsfcF39Brrr2ILvg7NnpZ1U2dKBXy0", + "uwyTRJAAmknXW5HezkIgxEvVZrTYjwBhxrNnUmB++AN6UFuTgt/mMBColnuc+Te1t3myfMVTdKR9bE3q", + "etnCcxjOaeO09YBfxdlERT0g0dVaCMf4FZe516jD6uiJGwCIDvV6iL4JsIGaZRpowwXPQivec/W88Swo", + "vi4eY23wdBpIyVJ283Zo84WNCvGztXutWWnTSp6z1JTIpxoiWHNeeBVOkHz5YkBFRiR05FYlqpviHyi7", + "mfZCUhUhtcFY81MswdDPRO54PYG9S82ZTkMWtdGAJQKLRrDwhsxrI0B9p3LyNlUGHU9vREAJfXwtVg1Q", + "02Ob1Fv1Ae/mqtaFUL/3Hl48G5SXRyDc2t2N5Lt07UY3hsI58HNHQP4tXb+VaTPRZg68A1+vkt5XNfeH", + "9l/amFWnTspYB1E3z59Mld4zogVCLswnFW+JJS38oRDUcNJ84ZpiDX+6j2LFrstNaVaYLEW0/fkSykmw", + "xgCdZciC5k1/TTqxhzXpoK32GxBe80SFLb3mll1KaHNlKZR5wDeUd9P933CfsYjn4OQYzoGlVl2pkDd0", + "AKU3ZeEvbMFNDr3kDvgMp1iiLuEyR4fkGnDIgashUaZUDNtpvQcOdATaRBcaGQr9gXk5mOnSsI8fT1bq", + "5QNc9U0rSxxmnbbEb+TYOWWo6eSbidHg7FG6Qrf0khpoJCa/7IiAobepE3IuVOYtjxE4xnqC5lXBF7nm", + "mWUIvIukE4F9S0UzZZiod4haw15vk0FagObPc8hffffduTOCz/0DlJhqh8Qf3323y6xQGUuRW3iX1QXt", + "ZqAyL2wpRIGMGAt5RXSo3tgbZAK8K5ExCw/3s06PqWAN4NmProRyKUMaBW8dASP5FYAaCzQZ+xiu5iyd", + "CW7cSHCXUjXZy21me0P2MzWTYB4LiRShWApc0NaZw6x7bSQ4icrFlI8XzEo1zcXgX84/vKdJe3/HhjOS", + "VhQqfBJ6FmFvEhVQi+zKYw2PuqtcL21faxtbOpF6wK+syOJ70CK2rnNYU6gYhSq4XZbeWpdaLR0uZpW/", + "wLVshW+6pYH6nbb5r+QH2ZDdSZv2LP7zbakBtdS6LH4lb7iXG5gGbiv8X1Ri7w9BGOkstRwVr7eAI7Wz", + "2/k16cAfk85u0sFIruPG+Uuzn3RQLcDfzOAlfAS5b//BnEs1nGr4EH6IxZyd3Zf9pAMSDkHhpLO7s/1b", + "om4PBCWdNFDrU7Hm0z9xp/UBmHW65xP6SQe+fzH3/379qn1OmVbiiyYUlQ580Vn4cGd754+D7VeDnX/6", + "+PKfdnde725v/19JZ/mnuFZxZNC6FxxOENguO9tx6AtqhE06u3949U/xyxH74QKIZ/xft/374e12fxls", + "qIE1SV9OWo+hoKHksS5VzEKwgtd0OQpkouCVrXf1qbidfFkN5L1SQbH6+hukF92GrzUvHgp7vD80ARiz", + "D2cMz1Hts63oP82lhU6AZ3IeNt1yC84HC/4meJRvTz8xKzMx5oaNSrsg7iv/v32WnglnFoN9f1em8ZYm", + "gjeKL9tyOhXWy8w1l451qR2eArD4E9COtWc1X+YWAN9vSzV15Wgu3bIVZVl3zm/Y6+0vN/yUtLPHs/xa", + "LQYYYqM3pR/hea9KnMHdMZuIIfTt6oxSXSp9rb4ejfHAcMMBbMlShvlBEQfCCl1VZvgzkpXXwzjg2u3G", + "Ary5zAbeFy/o+iNskLSYcSvSPkvxls2khcYSkW3FC3cLLlz/neYFnfYTlQposspqcB3cu0jB10K1B8hk", + "y1NLVANiBCPHFQNoxBArVSiZwncBKA7geUyXLAOaKM5gaa4AeVKL6SWKQIlm0gKzMpYM7kJUBVcbDBeZ", + "5SLp/JaudF/OA4rrZvVBMFvuQNfEvSVPGBw//wJP1g+z1MNwJSp505MGT48pFVyUObdAlYbQtv7j9hPy", + "sGKRNefLCm7Gs01FKo6w44uA7byYKXhJaObgRWH0jZxzJ5gS3AjrBkrI6WykS8NwYpFdbgm16EqMARJL", + "57kY+8GGDOFPIB6dKD+dAQLJYro3nUt1YcfawGn3725Tb6ZKJ3KoZCyMmMibwYezQaQOTRQo4V6fpVQW", + "438zyvn4En9j+bxq8uzR2c+5mpZ86r/79//7PwGtTrG5MFMwgJ32PtoAIjaxryVjhns/yU90JKzDZzKY", + "LsRkarOvwO4AjHAQaXz//rf/CIl7stJZuj3cSVkXGzuNyMUVV2PBJrmGsDYnRMFInB6Ld4wuGPerwP2V", + "xV1peD4ILwZbKQVhGV7PtBU4a9Q5OG1v6//b9nDndZ9tD//w+i89nKy48WpA+qmlMGOqLYAojkNUoZG+", + "Euyn9+c/40SXfgiMaf5o+V9D1SG+DqA7ptvDV99j96LfwjG94FhnYoAVjiRXUAuVy5GBwLL//oHOxBlX", + "lyCyg//1/+vBuoPUXjg5Fxdzi/2q/qhjffRL6Iad85wVOR+3dmWe02ad4zHbUGtNY5BnMtuWJ7FGTzfk", + "HwpF8acUTLZff/viV+uNHcUq3ZpDRsoSss3etPSePdw+dRctUd2aL8XIK7PC3elzLdvlYAn58wGuW4wE", + "UCgHPD0/YBse+2pvLYhIF1+mR+e4dlvSB2utSfzOVia8mwZ01pvy1PAYHNYG2szZr0Z4pnNfn8AaJpeA", + "hFBf+t/hMW+WA+uB04PqjaHsDG8hCKJ/kew+cmapTWpDSmJTdWzPek/VJ3APeaXUmpv9/sXVrwz0vdXI", + "8x+iZQMh4OYSofVK21yjOFiioE7xpKXezQCACw5Oh8yEcnIioU71UqhholKSqxThd/3/QoVUvmBiXjh0", + "WlKhsguoW/vhBwTmgH+RjU98pbBiShaFcJbBLLAYgKQ7gGKATAE0Gs+8N5AoNHz2KFpumZ3B7yY6z/U1", + "KwsMi0Y7CRcYIcCxVgeLaiOAa7spikIfN2VTEEw0wDOd79r46wA14ir8/k81VHCH96VUMZyNLzvW1Cm2", + "2SvonAbZkMMET39ed6kxhXtcRGHZf+/yel53073F5E0l1sXwzFa8mXqfK7xhgF/v6nY7p29uvh0ojNSW", + "3Qh/+mbqqkKCQ18JcyXFNes6XfgLCXpKx0jFQD2mEKi2vU30xa0RAWfExnp+TqDvGTIe87nIJHeCCeWM", + "FNT6gzezNgvAAbjd/VMr+4f2H3ZX9w9iFdhBLi9FH7oOc3El8n6iFOBjlcZCWBRbazJpECUXgMXArOlF", + "mDpE7tI6dBQ1MOZC6w/rWiGqnp4AeNYbsiPlzIJhIXJssUnUuj6aPYQ0GE6lS+tLY0M0cxXve4Cq8Vu5", + "mbvBP/qJitMPw4ufIAJEmyKI3wHSMPjSP9prWtprsHmGre+dSdRdzTOsrXfmkRjXaoLejee15/XBI7e/", + "1Ojy7gJmwerJissdAuozbhtF74w7x8czqO24ViID9OdcqsuAflhniWAI/+1/7rR3ZK5Z0qkwF5IOG89k", + "QSw+wLcJfS65xDToL+W8COnQalq4a/B8yIccgV/mT0QbjKZ64QDpBTVp/fW8OIDDJrDKSTooAo8N84H/", + "4kryCmoiQpT7xWIjAZkhfH2Iooa2+zpTPuDFjIRQhEZ+p0arVugJDI842Im0bjXxMrzKN2SCwDGrhB+F", + "2a8bhzu31sWxWcPjjmqFcPYoWRfIY3bZlYA7u18B3NRgNxggmfa9vHvRxfOT53zOB/SgEM0H1M4AsdRN", + "4XcXueaZyNJen7pimZ4kqoUAEpOY8Tu1LraAMxlLOn7Ro1UsQ5uvCsAR1hYIIREZFQN8oRgvJSFgnbfi", + "ShPXWbfRprJk1o5EU1kjS83d0gE1vWBZFcIwLBAqjL6SUNI+znWZTXJuRJ+pqQFSm48zkSjqaYjfHHMD", + "Rij0fuN8qYcaO7e87WecyAB3qaxKetgWSzpjPUesV63aoZb8iftIL7TBzcYhDrjjuZ6uKP0Ir0vfefhu", + "IwYlcgqF5bShyVOGza9tdtjZtu3eGknF/Uas2fcCiBXpfDMAxwnjvrCMT70LBY9Z1Pc/CwIAzA6FERbq", + "bUnhoWrow/3kjYOtqGPQ4hER4YmUyJirRHnzh+f5VgnYFP6WjJ19n45Zd84Vn4oMNBLCUAoX6CQO9fjS", + "ayc551NA7KUKKMfooYT07D+h5yDvUsbtbKS5ycBmsIkitCX6GfwXMIe0sqyLRh9UkgAAxHrhfBMWf+My", + "CiMtVl2rp8IM4smkrSQxegSB3fcSMmg8FnRHGPFzRXXr1/DL37ZoF8B9bnWAD/W1wvYjuJe4ExZakb0q", + "aYhuxB4PUhSt4mGiAMav0kFg29Hv8OtzgU6mUJDbTlT34PjPFx8/vX9/dHLx5vj9xbv99/tvjw6h67VX", + "Q4uoQfH9c3sxG7xgfRc794Hxqi3uaiiv0BhTnVr/AH9qV/bAPKOUHoeDuhcXLbC2PIbMPpGX+KZNbLKI", + "+BbNzc3OIhyLcIAYUdcvoXktf4uv1vx15dt7yJFG5b76RJ+JQXbPQ933ZkTOxwEIhuaYqLEuFlCZ57w7", + "5v8USPomTphrbrBQxJQqihhdUAjpmaglZbDmtK/Gl/rHoY4wU/840o93pMk6aj3RuNxrzjFdgnSmvuxU", + "o5t4P/Bdf6qgn4YOIP6WdfEi3fLjbs20df4EBF9irJXC0rFAHcYUxEBiv6s3/oiMzQqXkjdRGbFaCUCO", + "QKCTFc4iWff4Mpv3InCctr52qs2mZf3So/A4IKRvhWuaxYMgIo0NDDSObRKzghnqFEUh4pN5MfAWeUxc", + "eBMMSPAsk24XTS1wA5GOBHn1YJQ+nT78qy78D/oINhgiFlGokNGQGUGPAdxPTE7AXwDx61KIoklMo5XY", + "w75zrqgcg0pTgGFQcHOX3q8J1gayBbUhcNCnTiTjDCjg0oZzgnyGTcWP9Sa0qVHvbz8dQefjkJA+zlEj", + "Xd12rhBWtSjyBZPuvmqZRLxuWS0jxsEXcOc6zygbNJE2s+BbsAfe6wDhgUv/ZCZAMGhbr/66tduYHrPl", + "iKol7itKtyLJKy7Pzcdb71QzS3HHEBrVVWcwdknMdJ4J03uUgEdzdXFEq3hhZ/rep9XbX6udoGNrkent", + "7dHHYLPhL18EAlnCCU+3ZoLnbpbukYaFyyZRAvq/sPCK0lS4QiKbIn+A0aUToRFwZghOO4yTYLwkxvIQ", + "lRMS6tiLMnBGFgjf+UsJecZcXgklLGUQ2+7Hj8I+mfrxY62mpvZ/peuIdfXlDwDRhL5eqWIao/etKaKG", + "nB75TdIDb8SQSS2vpFswMP1v7/hdkhu4k7em0s3KESHh35eC9AUGggF0kHVf/pHNxI032YztbZzv6BQP", + "TKgdQVEu3QxaQhYFtzZklNM/D34qR4NzOYXuMzHYef3HCisAoKdHyBUyOP9pf+f1H0ODJZ07gIBnl2IR", + "iY5jUcuLBjlfoL1HmP90yN5R67XImA2j20TFQpiXe94SDS3bKRJy1Hg+huyDYpyhmZMWpZ2lyGMCG2yg", + "iIeNDFdIUR1OtahIJZfpJBPVzZZJHUelsS7wlkhhkWSamAnSQqppWvtrKOPZ2d7GSmKlIYfFxGQCGW6r", + "MZ8InAaM6DvQAprk+hqTqu3gt4D09BYkkYgT7gIzauzaVcBL0tmi72VxINRYZyKjkucZ33n9xx+oO3O4", + "CoyoRVo6dzDorHgOFVshPModQv6lDgXPMokl5qfGL6eDvBCeKhoGYbCe2pegDdwnYJrWFAY4ZYYpPdBF", + "JM7xmvYxuRHvMZHDwNkTYHRYN9Ij1tgRpZdgOZ01KKY2exsgg1GQxSaWw1NATXxSMVsMBTGgvx/qLYlx", + "aaRbdHb/7S9NYzcgvZHuuUWp1EUrqY/Kel2mvKWy6QGVTKHMEnDG+96n8dcCssUwzOQPrmUmkkBHdiWt", + "HMncX8yEnB5AUa0Qtl5XQqAKgSUfYClX5B+fpqynUc+zloIoLk8uH1AX+Dh+N1bF5XltaWsCUfsQQlmt", + "nvQB7EQcaUNBnqVRPqtj4OXjb/L6jSXhfKjBvP5HB1pNcvkwONzHECHcGcSZrMRolRS1KpatX2W2lkDp", + "TMz1lbBLFYlA4x3/eRFrBWtFgN5oxLYbzIvJmhKh2hv/5AyqDT+8Z4dHJ0cfj9jB/vnB/uHRHlVIqkyY", + "fOGfUJVoNYlBqWZLq0Em7SVS1NlE+RGgHATIILr4eswBXENAU1gudaQK0kSBA5YJ60W7t5qgqXny7knR", + "9JQVhY8hZJFr6U4BW82ktGahtp9YQ3xry/9WuAqN8B5bsJ73PB7A40PW/XRyfAgNFCGnEBNbowUp0viD", + "Vd6xzD7bNw7ETW05i03fZUujPFP321pJDYxI108vsd/U5Ud5i+pOCZXEn3//xQtgLd15nNFp+PZTiAgN", + "dn/TNvg9DzJxn0nZgU0cjYlYfM2w3QCbdx9TBz6eUmsPnysrjLOMs25lK8msH17xwg/b88YU1AUmKr1t", + "UqXNHhOI/QXvHtLEYP2MvMeXqBSzAD+8oJaOF+mQHZYog6LeztZ8qHRW5BMoVSiV0yWE/7wXWPP6wJ4C", + "hz6aeDX8MdvuAarLSK6+ac1eG+y5PRSaRtVF0nZgT0Ck/6HbV+gBdYltYVQHESU1poMe4O4ss+iuc38q", + "zti7jnDbkeonCtrygDZbK+Y9lH6DpJQkD32Y5TYqf6ShhHf5IPI8r05qawUIdGjVCOo/z1X5RA1e39r9", + "gc5qjReWCvcbvmc3sjhHpzDuW+/el8rDr43+PVJUj5aTWnMaKgzM1gjjMoglkZlPuLIMyCauNfNrk+eY", + "4x8QPiJCu9C67rJMKCtYd6yt9GcBOraQGAwhzWwPjoAtuPHfO/9fJ9IJ9uPH89fszbud14mCnxCu68TZ", + "3pBRPwFsNKSXrnVAksyhxMsflUlpRZYo7+efibH06orn7IyrS/ZjiXwnlz/8cRszSPtjo62tUUoq9t//", + "NRjlAjAPx1xlMgNKDMB47Kb//V/s//xvNprvvL5Q2swT9T3rvhz893/1/MfwxvB5itmc//6vH7aHr/sM", + "iBshQp5bNpdqMOc3ifJf5Lk/QNC2AGvdC5QfRuQcM6wzI+xM59BhXk3o7//P/4sglP/nf7Pt4au0ByCW", + "tTeBZkAI9TKlExWxdIjBPxc3EvqIr4TJeRE5K3EaQ3ZaGjGAF0rUhKuB3/joLfrvvQ8YpmE7mRFTbrIc", + "0V8TxUdW56UTXgc6DqT4Vtf1mtGlk0rki0DHmyVKGoLtdAwDPtwxpaUVA+geZiRNVs5lzo10C6w+QIGZ", + "QnmqvAmtkKMFIREBzKZjueAWCYspeequgcIX98VpYPZlc8GVVNNJmbOJ4WDshO/7BQexAVIyRP+Eplwk", + "UFFsVMocx4VKBaNHUgHEkskFv5JqupsoL7CDl6ioMIhvS3Mlr+q3HrHZcbUA+R7s9Jlw42E/UUToWdRO", + "gtXwTpmeSxUWzovuC8ccvxQ4SKJsrt2Q7efXfEHtcd7gUxoKMaYwYWaEf4OM/aJHQFmfiZEuVTvUZ9TN", + "EeuzTWGCOFV67N/XKrG5VCdCTd2ss/uyvzKJufRIp4toOzcymIQK29l9ud3vzJEDqLP72v9DKvxHNUqF", + "xLhmGNzy9kF26oPsbN9jlCVKUUB11YoZfn1bzIfsAMVtJHJ9jRccAP/6Uw8MryQx06k/hogQTEQ3Xj9g", + "29piPhfOyDGhgTeECPFnApKu1Zj1j5DC8dwmCpGNA4guuRigRwcgenBe8QSGOBb8IfwSMcKgY9wIP7jI", + "iOdxux6onWiTqBo8GQ0RJ3wtREEHXQl/A2g1HTguc+Bj8gZTVwynQ5Z0akm4WONIxgt8knQYx3uAJ2ou", + "b0Q2yPScA7dZjIZVzEBLghGhitvlYnv4qt+ZeFXvOrudSa6569Qk5WVNTrajnGA/cpuY7AM0gTd4/ObN", + "uBVsZAS/zPQ1qCkEg6sAqG0BfQPOJsrJuUBUk6Wj+1HOpZr6C/ZQ8qnS1skxFljtnx4nirTzLpMO7XML", + "4sFsrJQAKwvHG3Pl1ahXPCpRvOAmmroAdzKZsFLBHcHtJUIRox1NdSG5nlLJNYBNV+82WpCJDcVSUJbP", + "aUxpYS59KOsYBwApf4dCLZrf85oFWAhIHjCr58LrzRko5kRhOQ4erUnO4caAChtAk57ruVButRQ4XMN2", + "GYAir7i5I61zwdWGm2SW9ng9tQSc/SdHI34cF+CnxcjIDEyA79HmJF0WznSeky0h1RdFkx4hXrTOGPcm", + "2j3jkOf43Q1KzVujy+I4uyv4CF9jMlvOEvqTiNUFTn/NzP6PGLz0C3AlxfUgoNuvWo6vPnj5sbGVQHrL", + "5nxBTgSEYuEd/SsviHWROQ31gUgFOucLKi8JhKbwgyH7U1VrolWOBSeh4Z/CPFCf15Am6qSSeQ41T9YO", + "oL6X3CXkFG0F/vQTiOv2UYOwbgpZ0Y9FQ3xWFLIlBnOOotJg4/yKz9BzhgthqRpHDcSzOodfECNERbz1", + "6xRV4FKQcDnaZhtC9qPR80rM7g622W9rqx8rVnelLxu79ve//SdqFNQZXdQ52qA66X01KvOWFf6nKGir", + "xyA5+nxDAfsq7iwAXGIu0pdJ57e0gger8E0QHYlRgM27flKxl4lCDqeKYPr19h+IN7b55FLhjBbInym4", + "9S7TbtIZDodxTKzeOXzDCkAR5zK3Q0b17xRnSPfrTlcaKBfC6qzolv0JV2ODNg+OsN5AhrWUltFKPDa/", + "xedMIW4H+beHb5Y6R9aUr56EThkAagq1qqsQnLwL7ITiaizuwviinfaOXiZyOfKbCJE9PWTHDmC7LRBo", + "YoguF0yJGxd6hDLu+IhbkSiAG4Ish2UBtK7+DaZ0gO9Bxw7AGSCyKB3jyl4LA1h70GSC1MgChh+A4XEt", + "VaavMQQw5VQzi75daBQlrlhl44rn0jqhpJoO2b4KrD0NpnYMaaSvtl/60+Bfj+ZHdWmlujaSpgpjh8cc", + "viGcU3rEKNfjSzYSM4m4S2xihPgrggAeO3+avROL78m+y0qvN76rz5yc5F38TJcuEJDI3CWq4muOC+qd", + "8kIogimCHn14XUTsyWxwg8FrniQKRimLPsYAiO4UKoZ57PbRCjRACW8eKN/jeibKv/KQ7bNCQ72xtEzc", + "FBAIAnQMoTJhKIBkmVc54cFqmnSY4QEQzhueELMXxmgTy5h/0SVAS8ogeNKyrDRRUhDU1ViXKFuCZTkp", + "c5hMjdB6yotaez+gRBawThQAlvBYnlvNZhCRC13GiH/rDzkFj+FsUkFlhfrE/XbkOW6ULt1Yz3EzvJhi", + "QXs1mdDkF9tV4/Zdc7+eEHaeGD0PJ4HiNKEovDp2GP7HKJHILdFtIS2gHz6VWR6Qa5VGIfV6D14ejkAK", + "8WxTFk5kKUTLIW5WGHEldWkB3CQLzLBAaxklC878SGvHRnA+3dLpD9yAIEmA36AcTn6P4kdSYSgNIoIY", + "o4rb73SiVnbIvxXuXaXONt8/WhvsQ5jIOhCGmq7FN74NNx2J9TgL2IT1X8X3bVPr2Bbg9Xrzdvi1MxLc", + "COOvZn9ZeO8QD2qbZXXO52KgjZxKBSCAepAJh+e2Akw7O4GjHmuAbSFgKqXJO7udLQCVpmnd6pSCiw3T", + "goTn5a8j20CqGXk/YkUmleVyIsaLcS5Y9+Ds02Gv8UtMEdz+MUKw92tcPf2KQaAP5wbV9hIhRfVw+vft", + "R3+cGSEoThuBJAujnR4DH0GwRwPzYUvA9/SYZXpc+isqYF/QrzI9bn0dunr6LNdTqbZyPdWl6wMU9rU2", + "GQJWiH4kZyxtvSfM32xt8/AmOV6igGJbodLUfuq/0/Jb6CrG3l/0AcDQH9ixLkTG/BteioVFWrqT463z", + "w3/1Y9SeW8iB/0bLoyuvg4IT1JcDET/pNCSm/YOXsgfNnRwmqtYiE4I2EKXAnqvGbR9RfJEVEQtnQUIS", + "NdeZnCyaMLxDdnr2kmGFh5dK0PF71RQXBDjsF7OfqNDv2o96013rgXV8GkObsaM0h9C6AgYb8e+lUC5R", + "RuSCWxE5OGsp14nAHi3sx0Q9SWtc87DW+Tt2F52zCM9ihYOR/KLYITtawnW2uCxL5SwxKhZiSn02NX5D", + "/G1T1cTA9b0VmTHhqh4yDD7CQvq3r5WnQVAgyukeNLFvUVzO2x341SB3E+CTmZY5Nzj7YBugN1rI8SXt", + "M9HdiMaC4XNbFosk8FQYC3mrfZg3+6gvhbJ+pNCi27YzkPUa51qhopBX/uamVLjKWFcXgaynxwKcrf9q", + "EJohO4cii0QJNTYLf0kPuBtgol5ytn90Pnh78A7T5gAJ7vyl7PU0JeGZuOFjly8SpeFaUez0w/lHNBya", + "aEjeDBNgpDQXBppjB4By07Y+70hyCEiVGvyJH0ADWaVDnkpduhHkpQnyAEzCqbwSNrTvGswD1ZAJ0PyW", + "jlkvSGRJv9//OGQHEbiMhk4Unkmlr/cQVBSxhLGFBNNSeQ1xwT9eEr4U3A+wznQfemla1RP46ezENpYo", + "9Ln/9pff/r8AAAD//w==", } // decodeSpec returns the embedded OpenAPI spec as raw JSON bytes, diff --git a/server/internal/httpapi/searchtimings.go b/server/internal/httpapi/searchtimings.go new file mode 100644 index 0000000..a79f6b9 --- /dev/null +++ b/server/internal/httpapi/searchtimings.go @@ -0,0 +1,127 @@ +package httpapi + +import ( + "sync/atomic" + "time" +) + +// --------------------------------------------------------------------------- +// Where a workspace query spent its time. +// +// This exists because the alternative is arithmetic. The dense scan, the BM25 +// query and the fan-out's parallel speedup were each measured separately on the +// load-test fixture and multiplied together to guess at a 10.5 s query — a +// budget that happened to close, which is not the same as being right. Two +// optimisations were about to be built on that guess. +// +// The numbers are cheap: a handful of time.Now() calls per project and two +// atomics, against a query that reads gigabytes. So they are always COLLECTED. +// What they are not is always reported: +// +// - the log line is emitted only for a query slower than slowWorkspaceQuery. +// A breakdown printed for every query is noise nobody reads, and the +// server already logs one http_request line per request with the wall +// time in it, so the routine case is covered. A threshold keeps the +// property that matters — nobody has to have switched anything on before +// the slow query happened; +// - the response object is attached only when the caller asks for it with +// ?timings=true. In a response it is a debugging aid, not API surface. +// +// --------------------------------------------------------------------------- + +// slowWorkspaceQuery is the line above which a query is worth a log entry of +// its own. Workspace search is a fan-out over every project in the workspace +// and is expected to take a while; on the load-test fixture (45 repos, 1.9M +// chunks) the median is ~10 s, and even a small workspace on a warm cache is +// hundreds of milliseconds. Two seconds is therefore not "slow" in the sense +// of "wrong" — it is the point past which the breakdown starts being worth +// storing, and it is low enough that a regression on a small workspace still +// trips it. +// +// A var rather than a const only so the test can exercise both sides of the +// threshold without sleeping for two seconds. Nothing at runtime writes it, +// and the one test that does restores it via t.Cleanup. That is safe only +// because nothing in this package calls t.Parallel(); if you add parallel +// tests here, move the threshold onto Deps first — under -race this global +// becomes a data race whose cause is not obvious from the failure. +var slowWorkspaceQuery = 2 * time.Second + +// searchPhases accumulates one workspace query's timings. +// +// The fan-out phases keep a SUM and a MAX, and both are needed: the sum is how +// much work the query did, the max is how long the user waited for the slowest +// project. With perfect parallelism the wall time is the max; with none it is +// the sum. Measured on the fixture, eight concurrent project searches ran 3.4x +// faster than the same eight in sequence — so the truth is between the two +// numbers, and reporting only one of them hides which. +type searchPhases struct { + embed time.Duration + resolve time.Duration + staleFTS time.Duration + fanOut time.Duration + fuse time.Duration + + denseSum atomic.Int64 // nanoseconds + denseMax atomic.Int64 + bm25Sum atomic.Int64 + bm25Max atomic.Int64 +} + +// addDense records one project's dense-side latency. Includes the vector +// store's own hydration of the winning rows — the two are not separable from +// out here, and hydration is bounded by the result limit rather than by the +// collection size, so it is not what a scan-side change would move. +// +// A project whose query FAILED is recorded too. The time was spent, and +// leaving it out would put the sums permanently below the wall time they are +// meant to explain. It does mean a slow failure can own the max, which is why +// the fan-out logs its own warning per failed project. +func (p *searchPhases) addDense(d time.Duration) { addSumMax(&p.denseSum, &p.denseMax, d) } + +// addBM25 records one project's BM25-side latency. +func (p *searchPhases) addBM25(d time.Duration) { addSumMax(&p.bm25Sum, &p.bm25Max, d) } + +func addSumMax(sum, max *atomic.Int64, d time.Duration) { + n := d.Nanoseconds() + sum.Add(n) + for { + cur := max.Load() + if n <= cur || max.CompareAndSwap(cur, n) { + return + } + } +} + +// payload renders the timings for the response and for the log line. +// +// scanned vs returned is the ratio that decides whether routing the fan-out is +// worth building: the query does full dense and BM25 work on every project in +// the workspace and then thresholds the answer down. If those two numbers are +// far apart, most of the work was thrown away after it was paid for. +// +// `returned` must therefore be the count that survived the RELEVANCE +// THRESHOLD, not the count the caller was shown. The response panel is capped +// at top_projects (default 10), and feeding that number in here would peg the +// ratio at scanned:10 on any workspace with ten relevant repos or a hundred — +// a measurement of a request parameter rather than of wasted work. The panel +// count is reported separately, because "what did the caller get" is a +// different question from "what did the fan-out pay for". +func (p *searchPhases) payload(wall time.Duration, scanned, returned, panel int) map[string]any { + ms := func(d time.Duration) int64 { return d.Milliseconds() } + msn := func(n int64) int64 { return time.Duration(n).Milliseconds() } + return map[string]any{ + "wall_ms": ms(wall), + "embed_ms": ms(p.embed), + "resolve_ms": ms(p.resolve), + "stale_fts_ms": ms(p.staleFTS), + "fanout_ms": ms(p.fanOut), + "dense_sum_ms": msn(p.denseSum.Load()), + "dense_max_ms": msn(p.denseMax.Load()), + "bm25_sum_ms": msn(p.bm25Sum.Load()), + "bm25_max_ms": msn(p.bm25Max.Load()), + "fuse_ms": ms(p.fuse), + "projects_scanned": scanned, + "projects_returned": returned, + "projects_in_panel": panel, + } +} diff --git a/server/internal/httpapi/workspacesearch.go b/server/internal/httpapi/workspacesearch.go index dad38f2..0e28f64 100644 --- a/server/internal/httpapi/workspacesearch.go +++ b/server/internal/httpapi/workspacesearch.go @@ -8,6 +8,7 @@ import ( "sort" "strconv" "sync" + "time" "golang.org/x/sync/errgroup" @@ -135,6 +136,13 @@ type projectHits struct { // project threshold those repos drop out, restoring the cross-project // signal the user needs to scope an agent's follow-up search. func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id string, params openapi.WorkspaceSearchParams) { + // Always measured, conditionally reported — see searchtimings.go. Started + // on the handler's first line so wall_ms means what it says: everything + // including the visibility check, not just the part that was interesting + // to whoever added the next phase. + started := time.Now() + var phases searchPhases + if s.workspaceProjectsUnavailable(w) { return } @@ -160,7 +168,11 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri // explicitly. minScore := clampFloat32(params.MinScore, 0.4, 0, 1) + wantTimings := params.Timings != nil && *params.Timings + + embedStart := time.Now() queryEmbedding, err := s.Deps.EmbeddingSvc.EmbedQuery(r.Context(), params.Q) + phases.embed = time.Since(embedStart) if err != nil { writeError(w, http.StatusServiceUnavailable, "could not embed query: "+err.Error()) return @@ -173,6 +185,7 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri // Pull the workspace's project memberships joined with the projects // table so we can split into indexed vs pending in one pass. The // junction lives in workspace_projects; status lives on projects. + resolveStart := time.Now() rows, err := s.Deps.DB.QueryContext(r.Context(), ` SELECT p.host_path, p.status FROM workspace_projects wp @@ -224,6 +237,7 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri } members = filtered } + phases.resolve = time.Since(resolveStart) if len(members) == 0 { writeJSON(w, http.StatusOK, workspaceSearchResponse( @@ -233,6 +247,12 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri nil, nil, nil, + // Nothing was searched, so nothing is attached to the response + // whatever the caller asked for. It still goes through the + // reporter: embed_ms has already been paid by this point, and a + // hung embedding provider is exactly the case the log line is + // for. + s.reportSearchTimings(id, params.Q, &phases, started, 0, 0, 0, false), )) return } @@ -263,6 +283,7 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri pendingRepos, nil, nil, + s.reportSearchTimings(id, params.Q, &phases, started, 0, 0, 0, false), )) return } @@ -275,14 +296,20 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri // reindex — otherwise the operator sees no observable difference // from the pre-hybrid algorithm and assumes the change didn't // take effect. + staleStart := time.Now() staleRepos := s.detectStaleFTSRepos(r.Context(), projectPaths) + phases.staleFTS = time.Since(staleStart) - hits, failedRepos, err := s.fanOutHybrid(r.Context(), id, projectPaths, params.Q, queryEmbedding, minScore) + fanOutStart := time.Now() + hits, failedRepos, err := s.fanOutHybrid(r.Context(), id, projectPaths, params.Q, queryEmbedding, minScore, &phases) + phases.fanOut = time.Since(fanOutStart) if err != nil { writeError(w, http.StatusInternalServerError, "fan-out search failed: "+err.Error()) return } + fuseStart := time.Now() + // Per-query min-max normalization on each signal independently, // then α-blend. Both signals are >=0; using raw/max instead of // (raw-min)/(max-min) means a project at 60% of best gets 0.6 @@ -329,6 +356,7 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri } surviving = append(surviving, ph) } + phases.fuse = time.Since(fuseStart) if len(surviving) == 0 { status := "empty" @@ -342,6 +370,7 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri pendingRepos, failedRepos, staleRepos, + s.reportSearchTimings(id, params.Q, &phases, started, len(projectPaths), 0, 0, wantTimings), )) return } @@ -416,9 +445,45 @@ func (s *Server) WorkspaceSearch(w http.ResponseWriter, r *http.Request, id stri pendingRepos, failedRepos, staleRepos, + s.reportSearchTimings(id, params.Q, &phases, started, + len(projectPaths), len(surviving), len(projectPayloads), wantTimings), )) } +// reportSearchTimings logs the phase breakdown if the query was slow, and +// returns it for the response if the caller asked for it. +// +// Both gates are deliberate; see searchtimings.go. The breakdown itself is +// always computed because it costs a map allocation — the decision here is +// only about where it goes. +func (s *Server) reportSearchTimings(workspaceID, query string, p *searchPhases, + started time.Time, scanned, returned, panel int, requested bool) map[string]any { + + wall := time.Since(started) + t := p.payload(wall, scanned, returned, panel) + + if wall >= slowWorkspaceQuery { + fields := []any{"workspace_id", workspaceID, "query_len", len(query)} + for _, k := range timingFields { + fields = append(fields, k, t[k]) + } + s.Deps.Logger.Info("slow workspace search", fields...) + } + + if !requested { + return nil + } + return t +} + +// timingFields fixes the order of the log line's fields so successive lines +// line up when read by eye, which is the only way anyone reads them. +var timingFields = []string{ + "wall_ms", "embed_ms", "resolve_ms", "stale_fts_ms", "fanout_ms", + "dense_sum_ms", "dense_max_ms", "bm25_sum_ms", "bm25_max_ms", + "fuse_ms", "projects_scanned", "projects_returned", "projects_in_panel", +} + // interleaveByRank returns up to `limit` chunks by walking the surviving // projects round-robin — rank-1 from every project before any rank-2, // then rank-2, and so on. Projects are visited in candidacy-desc order @@ -485,12 +550,16 @@ func workspaceSearchResponse( pending []workspaceSearchPendingRepoPayload, failed []workspaceSearchFailedRepoPayload, stale []workspaceSearchStaleFTSRepoPayload, + timings map[string]any, ) map[string]any { out := map[string]any{ "status": status, "projects": projects, "chunks": chunks, } + if timings != nil { + out["timings"] = timings + } if len(pending) > 0 { out["pending_repos"] = pending } @@ -561,6 +630,7 @@ func (s *Server) fanOutHybrid( rawQuery string, queryEmbedding []float32, minScore float32, + phases *searchPhases, ) ([]projectHits, []workspaceSearchFailedRepoPayload, error) { concurrency := runtime.NumCPU() if concurrency < 1 { @@ -584,7 +654,9 @@ func (s *Server) fanOutHybrid( denseErr error ) + denseStart := time.Now() rawDense, derr := s.Deps.VectorStore.Search(gctx, pp, queryEmbedding, workspaceSearchPerProjectLimit, nil) + phases.addDense(time.Since(denseStart)) if derr != nil { denseErr = derr s.Deps.Logger.Warn("workspaces search: dense query failed", @@ -610,7 +682,9 @@ func (s *Server) fanOutHybrid( } } + bm25Start := time.Now() rawBM25, berr := chunksfts.SearchProject(gctx, s.Deps.DB, pp, rawQuery, workspaceSearchBM25Limit) + phases.addBM25(time.Since(bm25Start)) if berr != nil { s.Deps.Logger.Warn("workspaces search: bm25 query failed", "workspace_id", workspaceID, diff --git a/server/internal/httpapi/workspacesearch_test.go b/server/internal/httpapi/workspacesearch_test.go index 54bb9c2..32fffab 100644 --- a/server/internal/httpapi/workspacesearch_test.go +++ b/server/internal/httpapi/workspacesearch_test.go @@ -1,13 +1,17 @@ package httpapi import ( + "bytes" "context" "database/sql" "encoding/json" + "fmt" + "log/slog" "math" "net/http" "path/filepath" "strconv" + "strings" "testing" "time" @@ -42,6 +46,15 @@ func (e fixedEmbedder) Ready(_ context.Context) error { return nil } // vectorstore (real, on tmpdir), and a query embedder the caller // controls. func newSearchRouter(t *testing.T, d *sql.DB, vs *vectorstore.Store, emb fixedEmbedder) http.Handler { + t.Helper() + return newSearchRouterWithLogger(t, d, vs, emb, nil) +} + +// newSearchRouterWithLogger is newSearchRouter with the logger under the +// test's control, for the tests that assert on what got logged. A nil logger +// keeps the router's own default. +func newSearchRouterWithLogger(t *testing.T, d *sql.DB, vs *vectorstore.Store, + emb fixedEmbedder, logger *slog.Logger) http.Handler { t.Helper() t.Setenv("CIX_SECRET_KEY", "") t.Setenv("CIX_SECRET_KEYFILE", "") @@ -51,6 +64,7 @@ func newSearchRouter(t *testing.T, d *sql.DB, vs *vectorstore.Store, emb fixedEm } return NewRouter(Deps{ DB: d, + Logger: logger, AuthDisabled: true, Users: seedlessUsers(d), Sessions: seedlessSessions(d), @@ -1101,3 +1115,356 @@ func TestWorkspaceSearch_DefaultMinScoreIs04(t *testing.T) { len(openResp.Projects), openResp.Projects) } } + +// TestWorkspaceSearch_ReportsPhaseTimings covers the diagnostic added because +// the previous round of optimisation work was steered by arithmetic across +// separate measurements rather than by a number taken inside the handler. +// +// It asserts SHAPE, not values. Wall-clock in CI is noise — an assertion that +// dense_sum_ms is under some bound would fail on a loaded runner and teach +// everyone to ignore it. What can be asserted is that every field is present +// when the caller asks for the breakdown, and that the two counters describe +// the fan-out the request actually performed. +func TestWorkspaceSearch_ReportsPhaseTimings(t *testing.T) { + d, err := dbOpenMemory(t) + if err != nil { + t.Fatalf("open db: %v", err) + } + vs := openTestVectorStore(t) + query := l2([]float32{1, 0, 0, 0}) + router := newSearchRouter(t, d, vs, fixedEmbedder{q: query}) + wsID := createWS(t, router, "timings") + + // Two projects, one of which cannot clear the relevance threshold, so + // projects_scanned and projects_returned are different numbers. Their + // ratio is the whole reason the counters exist: it says how much of the + // fan-out's work was discarded after it was paid for. + seedRepoWithChunks(t, d, vs, wsID, "github.com/o/near@main", + []vectorstore.Chunk{ + {Content: "near", FilePath: "n.go", StartLine: 1, EndLine: 9, + ChunkType: "function", SymbolName: "N", Language: "go"}, + }, + [][]float32{l2([]float32{1.0, 0.0, 0.0, 0.0})}, + ) + seedRepoWithChunks(t, d, vs, wsID, "github.com/o/far@main", + []vectorstore.Chunk{ + {Content: "far", FilePath: "f.go", StartLine: 1, EndLine: 9, + ChunkType: "function", SymbolName: "F", Language: "go"}, + }, + [][]float32{l2([]float32{0.0, 0.0, 0.0, 1.0})}, + ) + + rr := doJSON(t, router, http.MethodGet, "/api/v1/workspaces/"+wsID+"/search?q=near&timings=true", nil) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d (%s)", rr.Code, rr.Body.String()) + } + var body struct { + Timings map[string]json.Number `json:"timings"` + } + if err := json.Unmarshal(rr.Body.Bytes(), &body); err != nil { + t.Fatalf("decode: %v", err) + } + if body.Timings == nil { + t.Fatal("no timings on a response that asked for them and ran a search") + } + for _, field := range timingFields { + if _, ok := body.Timings[field]; !ok { + t.Errorf("timings is missing %q: %v", field, body.Timings) + } + } + + num := func(k string) int64 { + n, err := body.Timings[k].Int64() + if err != nil { + t.Fatalf("%s is not an integer: %v", k, err) + } + return n + } + if got := num("projects_scanned"); got != 2 { + t.Errorf("projects_scanned = %d, want 2 — the fan-out searched both repos", got) + } + if got := num("projects_returned"); got != 1 { + t.Errorf("projects_returned = %d, want 1 — only the near repo clears the threshold", got) + } + if got := num("projects_in_panel"); got != 1 { + t.Errorf("projects_in_panel = %d, want 1", got) + } + // The max of a phase cannot exceed its sum, whatever the machine was + // doing at the time. This is the one relationship worth pinning: it + // catches a sum and a max wired to the wrong accumulator, which would + // otherwise look plausible in every log line. + for _, phase := range []string{"dense", "bm25"} { + if sum, max := num(phase+"_sum_ms"), num(phase+"_max_ms"); max > sum { + t.Errorf("%s_max_ms (%d) exceeds %s_sum_ms (%d)", phase, max, phase, sum) + } + } + assertCounterOrder(t, num) +} + +// assertCounterOrder pins the one relationship the three project counters must +// always satisfy. reportSearchTimings takes them as three consecutive ints — +// scanned, returned, panel — which is exactly the signature where a +// transposition compiles, produces plausible-looking numbers, and is invisible +// until someone reasons from the ratio. The panel is a cap on what survived, +// and what survived is a subset of what was searched. +func assertCounterOrder(t *testing.T, num func(string) int64) { + t.Helper() + scanned, returned, panel := num("projects_scanned"), num("projects_returned"), num("projects_in_panel") + if !(panel <= returned && returned <= scanned) { + t.Errorf("counters out of order: projects_in_panel=%d, projects_returned=%d, projects_scanned=%d "+ + "(want panel <= returned <= scanned)", panel, returned, scanned) + } +} + +// TestWorkspaceSearch_NoTimingsWithoutASearch is the other half: an empty +// workspace never reaches the fan-out, and reporting zeroes for phases that +// did not run would read as "the search was instant" to whoever is reading +// them. It asks for timings explicitly, so a pass means the search gate held, +// not merely that the opt-in gate did. +func TestWorkspaceSearch_NoTimingsWithoutASearch(t *testing.T) { + d, err := dbOpenMemory(t) + if err != nil { + t.Fatalf("open db: %v", err) + } + vs := openTestVectorStore(t) + router := newSearchRouter(t, d, vs, fixedEmbedder{q: l2([]float32{1, 0, 0, 0})}) + wsID := createWS(t, router, "notimings") + + rr := doJSON(t, router, http.MethodGet, "/api/v1/workspaces/"+wsID+"/search?q=anything&timings=true", nil) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d (%s)", rr.Code, rr.Body.String()) + } + var raw map[string]any + if err := json.Unmarshal(rr.Body.Bytes(), &raw); err != nil { + t.Fatalf("decode: %v", err) + } + if _, present := raw["timings"]; present { + t.Errorf("empty workspace reported timings: %v", raw["timings"]) + } +} + +// TestWorkspaceSearch_TimingsAreOptIn pins the half of the contract the +// opt-in exists for. The breakdown is a debugging aid; every caller that did +// not ask for it — the CLI, the MCP tools, the dashboard — must get the same +// response shape it got before the diagnostic was added. +func TestWorkspaceSearch_TimingsAreOptIn(t *testing.T) { + d, err := dbOpenMemory(t) + if err != nil { + t.Fatalf("open db: %v", err) + } + vs := openTestVectorStore(t) + query := l2([]float32{1, 0, 0, 0}) + router := newSearchRouter(t, d, vs, fixedEmbedder{q: query}) + wsID := createWS(t, router, "optin") + seedRepoWithChunks(t, d, vs, wsID, "github.com/o/near@main", + []vectorstore.Chunk{ + {Content: "near", FilePath: "n.go", StartLine: 1, EndLine: 9, + ChunkType: "function", SymbolName: "N", Language: "go"}, + }, + [][]float32{l2([]float32{1.0, 0.0, 0.0, 0.0})}, + ) + + for _, q := range []string{"", "&timings=false", "&timings=0"} { + rr := doJSON(t, router, http.MethodGet, + "/api/v1/workspaces/"+wsID+"/search?q=near"+q, nil) + if rr.Code != http.StatusOK { + t.Fatalf("%q: expected 200, got %d (%s)", q, rr.Code, rr.Body.String()) + } + var raw map[string]any + if err := json.Unmarshal(rr.Body.Bytes(), &raw); err != nil { + t.Fatalf("%q: decode: %v", q, err) + } + if _, present := raw["timings"]; present { + t.Errorf("%q: timings attached without being asked for: %v", q, raw["timings"]) + } + // The search itself must still have happened. + if chunks, ok := raw["chunks"].([]any); !ok || len(chunks) == 0 { + t.Errorf("%q: no chunks — the request did not actually search: %v", q, raw["chunks"]) + } + } +} + +// TestWorkspaceSearch_LogsOnlySlowQueries covers the other gate, the one that +// decides how much this diagnostic costs in production. The server already +// logs an http_request line per request; a second line per workspace query +// would be noise on every query to catch the rare slow one. The threshold is +// what buys the property that matters — nobody has to have switched anything +// on before the slow query happens. +// +// Both directions are asserted from one logger, because a test that only +// proves silence would still pass if the line were deleted outright. +func TestWorkspaceSearch_LogsOnlySlowQueries(t *testing.T) { + d, err := dbOpenMemory(t) + if err != nil { + t.Fatalf("open db: %v", err) + } + vs := openTestVectorStore(t) + var logs bytes.Buffer + router := newSearchRouterWithLogger(t, d, vs, + fixedEmbedder{q: l2([]float32{1, 0, 0, 0})}, + slog.New(slog.NewJSONHandler(&logs, &slog.HandlerOptions{Level: slog.LevelInfo}))) + wsID := createWS(t, router, "slowlog") + seedRepoWithChunks(t, d, vs, wsID, "github.com/o/near@main", + []vectorstore.Chunk{ + {Content: "near", FilePath: "n.go", StartLine: 1, EndLine: 9, + ChunkType: "function", SymbolName: "N", Language: "go"}, + }, + [][]float32{l2([]float32{1.0, 0.0, 0.0, 0.0})}, + ) + + // A four-chunk in-memory workspace is nowhere near two seconds. + doJSON(t, router, http.MethodGet, "/api/v1/workspaces/"+wsID+"/search?q=near", nil) + if strings.Contains(logs.String(), "slow workspace search") { + t.Errorf("a fast query wrote a slow-query line:\n%s", logs.String()) + } + + // Same query, threshold dropped so every query counts as slow. + restore := slowWorkspaceQuery + slowWorkspaceQuery = 0 + t.Cleanup(func() { slowWorkspaceQuery = restore }) + + logs.Reset() + rr := doJSON(t, router, http.MethodGet, "/api/v1/workspaces/"+wsID+"/search?q=near", nil) + line := "" + for _, l := range strings.Split(strings.TrimSpace(logs.String()), "\n") { + if strings.Contains(l, "slow workspace search") { + line = l + break + } + } + if line == "" { + t.Fatalf("a slow query wrote no line:\n%s", logs.String()) + } + // The line is the whole artefact — if it omits a phase, the phase is + // invisible in production no matter how carefully it was measured. + for _, field := range append([]string{"workspace_id", "query_len"}, timingFields...) { + if !strings.Contains(line, `"`+field+`"`) { + t.Errorf("slow-query line is missing %q: %s", field, line) + } + } + // The two gates are independent: crossing the log threshold must not + // start attaching the block to responses nobody asked for. + var raw map[string]any + if err := json.Unmarshal(rr.Body.Bytes(), &raw); err != nil { + t.Fatalf("decode: %v", err) + } + if _, present := raw["timings"]; present { + t.Errorf("a slow query attached timings to a response that did not ask: %v", raw["timings"]) + } +} + +// TestWorkspaceSearch_ReturnedCountIgnoresThePanelCap is the regression test +// for the counter these timings exist to feed. +// +// projects_scanned:projects_returned is meant to say how much of the fan-out's +// work was discarded — the premise of routing the fan-out at all. Counting the +// projects the caller was SHOWN instead pegs that ratio to top_projects +// (default 10), so a workspace where 12 repos are relevant and one where 40 +// are would both report the same ratio, and both would report it unchanged if +// the threshold stopped rejecting anything at all. The number the caller saw +// is a real but different question, and gets its own field. +func TestWorkspaceSearch_ReturnedCountIgnoresThePanelCap(t *testing.T) { + d, err := dbOpenMemory(t) + if err != nil { + t.Fatalf("open db: %v", err) + } + vs := openTestVectorStore(t) + query := l2([]float32{1, 0, 0, 0}) + router := newSearchRouter(t, d, vs, fixedEmbedder{q: query}) + wsID := createWS(t, router, "panelcap") + + // More relevant repos than the panel holds. Every one is a near-exact + // match, so none of them can be dropped by the relevance threshold and + // the only thing that can shrink the count is the cap. + const repos = 14 + for i := 0; i < repos; i++ { + seedRepoWithChunks(t, d, vs, wsID, + fmt.Sprintf("github.com/o/r%02d@main", i), + []vectorstore.Chunk{ + {Content: "near", FilePath: "n.go", StartLine: 1, EndLine: 9, + ChunkType: "function", SymbolName: "N", Language: "go"}, + }, + [][]float32{l2([]float32{1.0, float32(i) / 1000, 0.0, 0.0})}, + ) + } + + rr := doJSON(t, router, http.MethodGet, + "/api/v1/workspaces/"+wsID+"/search?q=near&timings=true", nil) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d (%s)", rr.Code, rr.Body.String()) + } + var body struct { + Projects []map[string]any `json:"projects"` + Timings map[string]json.Number `json:"timings"` + } + if err := json.Unmarshal(rr.Body.Bytes(), &body); err != nil { + t.Fatalf("decode: %v", err) + } + num := func(k string) int64 { + n, err := body.Timings[k].Int64() + if err != nil { + t.Fatalf("%s is not an integer: %v", k, err) + } + return n + } + + if got := num("projects_scanned"); got != repos { + t.Errorf("projects_scanned = %d, want %d", got, repos) + } + if got := num("projects_returned"); got != repos { + t.Errorf("projects_returned = %d, want %d — every repo clears the "+ + "threshold, so this must not be capped by top_projects", got, repos) + } + // The panel is capped, and its counter has to agree with the array the + // caller actually received. + panel := num("projects_in_panel") + if panel != int64(len(body.Projects)) { + t.Errorf("projects_in_panel = %d but the response carries %d projects", + panel, len(body.Projects)) + } + if panel >= repos { + t.Errorf("projects_in_panel = %d — expected the default top_projects "+ + "cap to bite with %d relevant repos", panel, repos) + } + assertCounterOrder(t, num) +} + +// TestWorkspaceSearch_LogsSlowQueriesThatSearchedNothing covers the early +// returns. A workspace with no queryable project never reaches the fan-out, +// but the query embedding has already been paid for by then — and a hung +// embedding provider is exactly the failure the slow-query line exists to +// catch. Silence on those paths would hide the one phase that ran. +func TestWorkspaceSearch_LogsSlowQueriesThatSearchedNothing(t *testing.T) { + d, err := dbOpenMemory(t) + if err != nil { + t.Fatalf("open db: %v", err) + } + vs := openTestVectorStore(t) + var logs bytes.Buffer + router := newSearchRouterWithLogger(t, d, vs, + fixedEmbedder{q: l2([]float32{1, 0, 0, 0})}, + slog.New(slog.NewJSONHandler(&logs, &slog.HandlerOptions{Level: slog.LevelInfo}))) + wsID := createWS(t, router, "emptyslow") + + restore := slowWorkspaceQuery + slowWorkspaceQuery = 0 + t.Cleanup(func() { slowWorkspaceQuery = restore }) + + rr := doJSON(t, router, http.MethodGet, + "/api/v1/workspaces/"+wsID+"/search?q=anything&timings=true", nil) + if rr.Code != http.StatusOK { + t.Fatalf("expected 200, got %d (%s)", rr.Code, rr.Body.String()) + } + if !strings.Contains(logs.String(), "slow workspace search") { + t.Errorf("an early return skipped the slow-query line:\n%s", logs.String()) + } + // And the response still carries nothing, because nothing was searched — + // even though this caller did ask for timings. + var raw map[string]any + if err := json.Unmarshal(rr.Body.Bytes(), &raw); err != nil { + t.Fatalf("decode: %v", err) + } + if _, present := raw["timings"]; present { + t.Errorf("a search that never ran reported timings: %v", raw["timings"]) + } +}