diff --git a/packages/api/internal/api/api.gen.go b/packages/api/internal/api/api.gen.go index b57c618b89..ffd28965b2 100644 --- a/packages/api/internal/api/api.gen.go +++ b/packages/api/internal/api/api.gen.go @@ -2846,6 +2846,21 @@ type TemplateBuildStartV2 struct { // TemplateBuildStatus Status of the template build type TemplateBuildStatus string +// TemplateRefreshEnvdResponse defines model for TemplateRefreshEnvdResponse. +type TemplateRefreshEnvdResponse struct { + // Aliases Aliases of the template (inherited from the source) + Aliases *[]string `json:"aliases,omitempty"` + + // BuildID Identifier of the new build; poll its status/logs endpoints + BuildID string `json:"buildID"` + + // FromEnvdVersion envd version the source build was baked with + FromEnvdVersion string `json:"fromEnvdVersion"` + + // TemplateID Identifier of the template being refreshed + TemplateID string `json:"templateID"` +} + // TemplateRequestResponseV3 defines model for TemplateRequestResponseV3. type TemplateRequestResponseV3 struct { // Aliases Aliases of the template @@ -5815,6 +5830,17 @@ type ClientInterface interface { // Corresponds with POST /v2/templates/{templateID}/builds/{buildID} (the `PostV2TemplatesTemplateIDBuildsBuildID` operationId). PostV2TemplatesTemplateIDBuildsBuildID(ctx context.Context, templateID TemplateID, buildID BuildID, params *PostV2TemplatesTemplateIDBuildsBuildIDParams, body PostV2TemplatesTemplateIDBuildsBuildIDJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + // PostV2TemplatesTemplateIDRefreshEnvd Rebuild a template with the current envd + // + // Derives a new build of the template FROM the template's own latest ready + // build, forcing the host's current envd binary to replace the one baked in + // by the original build. Specs (cpu, memory) and the alias are inherited + // from the source build. Returns the new build to poll via the existing + // build status/logs endpoints. + // + // Corresponds with POST /v2/templates/{templateID}/refresh-envd (the `PostV2TemplatesTemplateIDRefreshEnvd` operationId). + PostV2TemplatesTemplateIDRefreshEnvd(ctx context.Context, templateID TemplateID, reqEditors ...RequestEditorFn) (*http.Response, error) + // PostV3TemplatesWithBody Create template (v3) // // Create a new template. @@ -8835,6 +8861,27 @@ func (c *Client) PostV2TemplatesTemplateIDBuildsBuildID(ctx context.Context, tem return c.Client.Do(req) } +// PostV2TemplatesTemplateIDRefreshEnvd Rebuild a template with the current envd +// +// Derives a new build of the template FROM the template's own latest ready +// build, forcing the host's current envd binary to replace the one baked in +// by the original build. Specs (cpu, memory) and the alias are inherited +// from the source build. Returns the new build to poll via the existing +// build status/logs endpoints. +// +// Corresponds with POST /v2/templates/{templateID}/refresh-envd (the `PostV2TemplatesTemplateIDRefreshEnvd` operationId). +func (c *Client) PostV2TemplatesTemplateIDRefreshEnvd(ctx context.Context, templateID TemplateID, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewPostV2TemplatesTemplateIDRefreshEnvdRequest(c.Server, templateID) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + // PostV3TemplatesWithBody Create template (v3) // // Create a new template. @@ -15283,6 +15330,40 @@ func NewPostV2TemplatesTemplateIDBuildsBuildIDRequestWithBody(server string, tem return req, nil } +// NewPostV2TemplatesTemplateIDRefreshEnvdRequest constructs an http.Request for the PostV2TemplatesTemplateIDRefreshEnvd method +func NewPostV2TemplatesTemplateIDRefreshEnvdRequest(server string, templateID TemplateID) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithOptions("simple", false, "templateID", templateID, runtime.StyleParamOptions{ParamLocation: runtime.ParamLocationPath, Type: "string", Format: ""}) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/v2/templates/%s/refresh-envd", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest(http.MethodPost, queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + // NewPostV3TemplatesRequest calls the generic PostV3Templates builder with application/json body func NewPostV3TemplatesRequest(server string, params *PostV3TemplatesParams, body PostV3TemplatesJSONRequestBody) (*http.Request, error) { var bodyReader io.Reader @@ -17022,6 +17103,19 @@ type ClientWithResponsesInterface interface { // Corresponds with POST /v2/templates/{templateID}/builds/{buildID} (the `PostV2TemplatesTemplateIDBuildsBuildID` operationId). PostV2TemplatesTemplateIDBuildsBuildIDWithResponse(ctx context.Context, templateID TemplateID, buildID BuildID, params *PostV2TemplatesTemplateIDBuildsBuildIDParams, body PostV2TemplatesTemplateIDBuildsBuildIDJSONRequestBody, reqEditors ...RequestEditorFn) (*PostV2TemplatesTemplateIDBuildsBuildIDResponse, error) + // PostV2TemplatesTemplateIDRefreshEnvdWithResponse Rebuild a template with the current envd + // + // Derives a new build of the template FROM the template's own latest ready + // build, forcing the host's current envd binary to replace the one baked in + // by the original build. Specs (cpu, memory) and the alias are inherited + // from the source build. Returns the new build to poll via the existing + // build status/logs endpoints. + // + // Returns a wrapper object for the known response body format(s). + // + // Corresponds with POST /v2/templates/{templateID}/refresh-envd (the `PostV2TemplatesTemplateIDRefreshEnvd` operationId). + PostV2TemplatesTemplateIDRefreshEnvdWithResponse(ctx context.Context, templateID TemplateID, reqEditors ...RequestEditorFn) (*PostV2TemplatesTemplateIDRefreshEnvdResponse, error) + // PostV3TemplatesWithBodyWithResponse Create template (v3) // // Create a new template. @@ -26669,6 +26763,82 @@ func (r PostV2TemplatesTemplateIDBuildsBuildIDResponse) ContentType() string { return "" } +type PostV2TemplatesTemplateIDRefreshEnvdResponse struct { + Body []byte + HTTPResponse *http.Response + // JSON202 the response for an HTTP 202 `application/json` response + JSON202 *TemplateRefreshEnvdResponse + // JSON400 the response for an HTTP 400 `application/json` response + JSON400 *N400 + // JSON401 the response for an HTTP 401 `application/json` response + JSON401 *N401 + // JSON403 the response for an HTTP 403 `application/json` response + JSON403 *N403 + // JSON404 the response for an HTTP 404 `application/json` response + JSON404 *N404 + // JSON500 the response for an HTTP 500 `application/json` response + JSON500 *N500 +} + +// GetJSON202 returns the response for an HTTP 202 `application/json` response +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) GetJSON202() *TemplateRefreshEnvdResponse { + return r.JSON202 +} + +// GetJSON400 returns the response for an HTTP 400 `application/json` response +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) GetJSON400() *N400 { + return r.JSON400 +} + +// GetJSON401 returns the response for an HTTP 401 `application/json` response +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) GetJSON401() *N401 { + return r.JSON401 +} + +// GetJSON403 returns the response for an HTTP 403 `application/json` response +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) GetJSON403() *N403 { + return r.JSON403 +} + +// GetJSON404 returns the response for an HTTP 404 `application/json` response +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) GetJSON404() *N404 { + return r.JSON404 +} + +// GetJSON500 returns the response for an HTTP 500 `application/json` response +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) GetJSON500() *N500 { + return r.JSON500 +} + +// GetBody returns the raw response body bytes +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) GetBody() []byte { + return r.Body +} + +// Status returns HTTPResponse.Status +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +// ContentType is a convenience method to retrieve the Content-Type value from the HTTP response headers +func (r PostV2TemplatesTemplateIDRefreshEnvdResponse) ContentType() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Header.Get("Content-Type") + } + return "" +} + // PostV3TemplatesResponse400Headers the declared response headers of an HTTP 400 response for PostV3Templates type PostV3TemplatesResponse400Headers struct { ShouldRetry *bool @@ -29592,6 +29762,25 @@ func (c *ClientWithResponses) PostV2TemplatesTemplateIDBuildsBuildIDWithResponse return ParsePostV2TemplatesTemplateIDBuildsBuildIDResponse(rsp) } +// PostV2TemplatesTemplateIDRefreshEnvdWithResponse Rebuild a template with the current envd +// +// Derives a new build of the template FROM the template's own latest ready +// build, forcing the host's current envd binary to replace the one baked in +// by the original build. Specs (cpu, memory) and the alias are inherited +// from the source build. Returns the new build to poll via the existing +// build status/logs endpoints. +// +// Returns a wrapper object for the known response body format(s). +// +// Corresponds with POST /v2/templates/{templateID}/refresh-envd (the `PostV2TemplatesTemplateIDRefreshEnvd` operationId). +func (c *ClientWithResponses) PostV2TemplatesTemplateIDRefreshEnvdWithResponse(ctx context.Context, templateID TemplateID, reqEditors ...RequestEditorFn) (*PostV2TemplatesTemplateIDRefreshEnvdResponse, error) { + rsp, err := c.PostV2TemplatesTemplateIDRefreshEnvd(ctx, templateID, reqEditors...) + if err != nil { + return nil, err + } + return ParsePostV2TemplatesTemplateIDRefreshEnvdResponse(rsp) +} + // PostV3TemplatesWithBodyWithResponse Create template (v3) // // Create a new template. @@ -38161,6 +38350,67 @@ func ParsePostV2TemplatesTemplateIDBuildsBuildIDResponse(rsp *http.Response) (*P return response, nil } +// ParsePostV2TemplatesTemplateIDRefreshEnvdResponse parses an HTTP response from a PostV2TemplatesTemplateIDRefreshEnvdWithResponse call +func ParsePostV2TemplatesTemplateIDRefreshEnvdResponse(rsp *http.Response) (*PostV2TemplatesTemplateIDRefreshEnvdResponse, error) { + bodyBytes, err := io.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &PostV2TemplatesTemplateIDRefreshEnvdResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 202: + var dest TemplateRefreshEnvdResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON202 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest N400 + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 401: + var dest N401 + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON401 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 403: + var dest N403 + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON403 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 404: + var dest N404 + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON404 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 500: + var dest N500 + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON500 = &dest + + } + + return response, nil +} + // ParsePostV3TemplatesResponse parses an HTTP response from a PostV3TemplatesWithResponse call func ParsePostV3TemplatesResponse(rsp *http.Response) (*PostV3TemplatesResponse, error) { bodyBytes, err := io.ReadAll(rsp.Body) @@ -38969,6 +39219,9 @@ type ServerInterface interface { // PostV2TemplatesTemplateIDBuildsBuildID Start template build (v2) // (POST /v2/templates/{templateID}/builds/{buildID}) PostV2TemplatesTemplateIDBuildsBuildID(c *gin.Context, templateID TemplateID, buildID BuildID, params PostV2TemplatesTemplateIDBuildsBuildIDParams) + // PostV2TemplatesTemplateIDRefreshEnvd Rebuild a template with the current envd + // (POST /v2/templates/{templateID}/refresh-envd) + PostV2TemplatesTemplateIDRefreshEnvd(c *gin.Context, templateID TemplateID) // PostV3Templates Create template (v3) // (POST /v3/templates) PostV3Templates(c *gin.Context, params PostV3TemplatesParams) @@ -42793,6 +43046,31 @@ func (siw *ServerInterfaceWrapper) PostV2TemplatesTemplateIDBuildsBuildID(c *gin siw.Handler.PostV2TemplatesTemplateIDBuildsBuildID(c, templateID, buildID, params) } +// PostV2TemplatesTemplateIDRefreshEnvd operation middleware +func (siw *ServerInterfaceWrapper) PostV2TemplatesTemplateIDRefreshEnvd(c *gin.Context) { + + var err error + _ = err + + // ------------- Path parameter "templateID" ------------- + var templateID TemplateID + + err = runtime.BindStyledParameterWithOptions("simple", "templateID", c.Param("templateID"), &templateID, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "", ValueIsUnescaped: true}) + if err != nil { + siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter templateID: %w", err), http.StatusBadRequest) + return + } + + for _, middleware := range siw.HandlerMiddlewares { + middleware(c) + if c.IsAborted() { + return + } + } + + siw.Handler.PostV2TemplatesTemplateIDRefreshEnvd(c, templateID) +} + // PostV3Templates operation middleware func (siw *ServerInterfaceWrapper) PostV3Templates(c *gin.Context) { @@ -42976,6 +43254,7 @@ func RegisterHandlersWithOptions(router gin.IRouter, si ServerInterface, options router.GET(options.BaseURL+"/templates/:templateID", wrapper.GetTemplatesTemplateID) router.PATCH(options.BaseURL+"/templates/:templateID", wrapper.PatchTemplatesTemplateID) router.POST(options.BaseURL+"/v2/templates/:templateID/builds/:buildID", wrapper.PostV2TemplatesTemplateIDBuildsBuildID) + router.POST(options.BaseURL+"/v2/templates/:templateID/refresh-envd", wrapper.PostV2TemplatesTemplateIDRefreshEnvd) router.PATCH(options.BaseURL+"/v2/templates/:templateID", wrapper.PatchV2TemplatesTemplateID) router.GET(options.BaseURL+"/templates/:templateID/builds/:buildID/status", wrapper.GetTemplatesTemplateIDBuildsBuildIDStatus) router.GET(options.BaseURL+"/templates/:templateID/builds/:buildID/logs", wrapper.GetTemplatesTemplateIDBuildsBuildIDLogs) @@ -43404,298 +43683,303 @@ var swaggerSpec = []string{ "FQl0zFLPfStBXSFTKATHhRIQ3dDjiS4z0ZCHyczdWGO5mOnC64i1coENUdxwpVolVVYrMmEmiYMEJ2g1", "iiosn3fKjYg8aa1tn0sViCpBUqGnfTGVxoHNr+LGXzofuFZi43yLQP2Yrm3UqBe+nuepWBfQGDGXGosZ", "u/puVE9KBL7z/VGSwkodDH2Hyb6QLq+tF7FYdwh7TB98d1V/HZYfoswcWLFIHs6JuMau+pNaHFt1TYF+", - "aD5nBf+mpJULLi39C7cXXipLXSazWPwQnFrgdZte9eCWXUM377LZxP56R82qK06zdrLVlQ6z21TKgx2z", - "a2u0vKXXHgheZrN+tdxHyW/ExaklUOKrfV2VRpfdJaDf/fThTbbgUzGOUaQDrS4I/3+Nv6O1Ui77IhpE", - "YxGsWKSEh1ikpZpPTOxGYZZrLzG75bSaw6rVGYPQ+ybUhLmef+EmkfkFv/p1xNcCAr/viT2skZ5m4is7", - "+Mvu1tPnf3pEyV9WlNDMf/99Z+tnvjX58tuffvr2bynWv4R+gr1fh2KSruUHJZz8t25J13APPI3J4JBP", - "r25BSVRdlAZ07EF26MHeaKfLexk1PLSHT3sijvm0pxBie9lwKpFjpRXYHNZyF8c2F6mcRz/uzWfqpTEO", - "YHvwvHkYzN6gSBHotv6GAkm3h2whuX6G7mOYVcdJMHxqp2R+HWq4b3Xprffbl3Ysn/aVdO2uarPv7Y1D", - "cRq7WPc8jumpswXdFfqyQp9sEK5ZfzCmNP824dSy3vLpmBnCr3SwZhNZUqXJjY7YJn9d7ry1mrAiHUfB", - "FxR9HyKWASFJIdAa2RBK4YBSwhm9fR1H8ertQOyGFTtBCfMDlUXg6xk3tRmJylo2d60HBSDgJR6mhOiH", - "8LjZW6suX8+quEm0e1mzNH8udbXok65IwJuSqDS3SKMzbt7rckXFQMT3KXsGjEvGTsXSp5LU1UmjlzHu", - "eLtP919lJxi8d3QixoteT23IBq6g7Q24mBt2Auo9/XwSFZKN1emrs3N9Z9qUGIha15nesfVN5INBM3D/", - "Gto1NcCsVJl1VAaddwxC25cJWMZOV42ccpN7sS9u6wr8LTGkXmr8zvFWCcyK5m0WwCnqHKyhgZbh0prU", - "/U0/rjU979DLpnISR7x2tm4wXZKCBaCdW5WR2uOvEBdN+JqhGY7YHPRM0CbXi2pCT5KXrjcb4pqEppzH", - "JsWRNIVdlfdUOe6D/XP45LVBuYXFi4tKA/AlSUN23fhIUQEEn4ruo1ZPoLbKUbWz8yx7+/TV8ZuP73f3", - "PuDf4mSbfQTeDlV5vU5/pHxAvwNDomsSZxkiPbCHr/7vj68fsayojBVliIIJSeqQ0HWkPEqpEY0B0eyZ", - "JFNCI7K1aQm87G5bv+rtCtJwedZnIqwwLCfI25JnlmCg7ay1vrdMTX7wKar6VZzOtHbl9Hqh3xqPcYYY", - "eQPTC+BOF9RS19xEZcLzSHJG2g1pSY1zeq1lKb2NbiawB+DSkkLlxbLHWDAegRbEbVWKPnge+p0MU1Yz", - "8heC/8p1s+BLiIdJlllywTX1rbGUad+dX328BQ5Z9hI9SQJaQJyOIYvegkO+3j24iwubxIyCT8NUu8P8", - "0tqNJBt4EvM4CKz0SsilMZmulLBx7Zwl8/5JO6gkGcwlwyXsZqyJPvXEQD63B7AW/+My5BKDIsShhm5U", - "gZDc0od1jgjojQDsy1IKTG79RPScwj+bwhEMJ6Rbn5w+XDJugS6sYVO4jFBaCPbTIbSNPB/N8S17bjrX", - "Z5VBr4gn9RuyynSWfdlPf+317a6mk7XvUwVX/Mduhsy/jCWmZFHIGul0QL4aOmxfF9wkE86hRIPYKgXP", - "YXEwBANrXekSy3WwCZdFVQqWYQO1j3hm7eIYmx5h+Zjwbw//N6ZaYgtd2vDMTSj8HWRj+CXjKhMFwSSu", - "vXjjR+/7KuC/haehBj6GONNcIvhVEBTg5fXilZ1qdHIPw6JOyY6DGGqhKcPW2srxm8OkN6fZLH45MOvz", - "TYsUNxyT27JXsC7dUYlSOhuflyyeZt1C9rX3lzoEutnkfx58/LAlVKZzEYKWQ5gzarhGKCMRBMZBqJUi", - "51kSDjl09zkZhLz/zi+KyGt7n+fd0XiNPB+PPNmkV+ewrBQGNjTJK6RGu99ccrSQ58OSo/2HQ5fQdePW", - "8Np6t3ZB4SSvk3VLUHiEXigulsGQ1gygI9B6RtSFH1jFjat1CdMTLtNhHfdiLQVdoAiMm8uiB921T81A", - "bIfNuLEFftCv7eWJoW8ElO74eW+Fntas+LfJRFKaUFB76p5rMRtvciwno4jr6ERtSq2OzGlIhcb5GC9w", - "4rz3uORA92bA4R/ObRgkXF4zkzjCW76Kc1G646zeKF01wPdrMIwAdD7sbakGv93aIv/pOAyw7jyxUsER", - "M0w9aqifDbCi7vq4Ly6riqa00Ogw3+yM7jxtiKLVRF+TdoOcIzIPU00s8FAS5NNpKabckgjukttplZ2J", - "y68mDuMVtpFa2KaWu0G7TU77FsTri9/Wex7GtYdjUy+FXw3fROi3MZW+7XDrsH5TcCtc0SuEhaF+11wS", - "bm/54kNmYBjNZVe8AWQzdM1tQE5JLzM8v7eY/E4tJkFPSJhOei0mhKldldIuD4BliBJ287lUu4hmCtZ1", - "3A+YDanKvosXo//awje3yB9Sbw1+CZPBx//566Fv5VTwUpS/+Ln956+Ho/EIeRUJAZ/W7cBVOrSCPqvV", - "g4FXtvbe1A1EAxk0mU97W38Vy+T3lZ19onyY8hUOs2dK5E89tm5F1s8tavgqU4SdlC6100pbwLO3T1+B", - "n240Hp37JO/RzvaT7R3oWC+E4gs5ejF6BpV8HaY/bv9jDgv+OCRhPXagk1uYq4WvTEUSuhP8TYZxZma8", - "FHkNq0zBKuiSwmIgIndpBhO4rjqVb5vtHqmoGBbeZrVylVKxWAiNw1XYRXcTDknkrFIWZdtcn3v4b5Bt", - "KCaBMUd/FhbpKGB/7VNjr2lO9QUO5/d0Z8dBx1kXl4gFXDNs7/E/XMYmnTLrzqBAvq5HNwLXMe5cByQ8", - "LgtOczTgbnW1TuF+tPcGdvGnnSd93Yf5PIaX4N2nPw949+nP8O7znZ3178JLsQRBF3pHdvz9y7ex+zlI", - "gr9/gaRAU83nvFyimwWSAFvl0IXxk/UB6RDZB+2Q4OqQ6W+hktO3FTTK8wg1EivZ+EIlvFmLU9pQUrSQ", - "E5Ets0K4AM8jhQVk8MMCM9oaRUKpRh633tiFt5tJIaczgMT3L4InVRvhw5Sg9LYrNJKTndayCZQHHkTN", - "B1ERqwUv+VxYtIH0BDXUrzwOi4aJmjfLBW6UKaI/rFdwjEsf9gf+wKUmgt8ZQvA7GzPHzk9D3v3pjjPS", - "n4WtyfiBaRH5Sj6CV83j3yif8ttjvpBbUKmhl5PAswKy3kFQu4AQU3vfoeSREeW5zASDAl6TQl+YbfZZ", - "FfJMsJM/vz1koZcT2PO6mqSrcxAlaWJdPlc939UVpXsCgRziW9u9bALS1xzizGhFTZdNEjYo5CY8ieFs", - "rM/hAPxeK2Fkg6tZYZ2h56qsNjBwKMT5dKOGOhx4EJK74tiRqCCk3+Kb5MNb5heM0EImCfTLDSPm6DLL", - "eLTQKcxyih7wzMDi4ggrOKFDrZ+0udPk2nB4XMuh8EFcxDT67Vt7jN86bPLk2jqnXcvbA0gsbKP6gsij", - "NMhiebOH0rMh7z77HR1gtClNPlrBkWuPr8e/0Q3J6YR5T9EDgry+MgdTMz08vOsG8r15ebxWJfRLltII", - "f+rx1/gloxW+TR75XdA9Uc7V6Z6ifx9TuABMoOfEwueG8aKAkpmLUmPdKFQVF0Jh4aNW1LJZiAxMWLm/", - "kq0/vCjEmvr60RWutXcbnCzNdV+YqrBrdSzapMKnuZk/KOnTmiEpRiTH19/8W6RfGwLOZLGC9v8qC0f5", - "XWz/SxB5uIJDu797KnezhbkOpHLYDBHVC/6DUjmsWILoVpP5kDs4Ntq4wiSvweEe8WNcO7uTupvWzh6/", - "AOA5pE37Ea00Sajj50hTVeq1NVfamLo8RX0Zj75uwV9TikgYFdIQ6OWKG66rEB03nhaREbHdXxp7L42/", - "C2Jed3tLEl9Dum10RWN8Nfm5G9i6G9d3uQD90Gfe3RN0iStTmthg922WQMGhbMh1JPUJPr5mirp+qdjJ", - "7BwkGHfWELODd74n5psmZkeKwySnS9A0j39z/4LrTymnaxRFuODoMpsJYwlIVOlcsIXWhWEPj0bQwNHo", - "EXlCXcMUWc5rTz7lQcqSmYwXYCVA/cFss190ecHLvAbecS1AddJ8Krz17GW7baVZKadszhWfCkRi8OGz", - "InfqIJglHBwzaClUDBy6KHTGi9Cc9ws933nS4zJ97dbttV+1fTk1G7NyWPPR7Xhx9uX0au4b2NiAlkWD", - "//F4GN59MuTdJ9fpGvJLF4i256bWy5GPpTIWDBzm8W/+n2sUnUNRzjEtjSEcMH0DEQSYeC3ORQnDemCa", - "LAju0VNRaIX4ulQ2PuNFIUqWzbQ2Aiu3BkgI4DkzK6U6M8zZPuquDKOcc5GMPaBzN8lLe36ye2GqV2Gv", - "cSdhzwnmeqx9thQZD6DfnpKwjXdgNBTDr1guDDTCMr7gmbRLhjkxWYlSCyq+R2v66CWFSxLYHS5vc7cK", - "XimQxIz7tZ5T1QAa9pHy0/pnRSk3bl6hwzc0miGzqzE8uvIqAVTs945ZR4gQqQ9xbQsr8jtjyt8ZImR2", - "fv4dCaS0XEDhVMrpxoLpt1JO4Q9PzgQmk0wXtx6xgmKTfNcE3e4wNxMiiYQQJqMBryy4MbF6oKvcY4yX", - "DLiBq6nIX7JzqQskunBoYWsPDDuFcCiUV6AjFJLgHaJirUFQGWaqcoKllg3DRBaTEmWfqrROsA9L89ov", - "zNUk2JqXcRdu7FawL6d+Gq9xfYddC56mPEZO6tE+3QuE7y8QPGOGA+nKsoA4ZfUtohQZsJrndPpkhRRw", - "5QooeSESHg7BwbC8QrD1UhhdlRnEQM54ZeDZozHYG2tguQ20euTgtzSd2+Df8fqS5W6lrHbaec8Jj0B0", - "o/gYD/AhT3cSeaAh1e35TpTJ9iSRYXJbtxVc9qtdWdrUNfHU9fsOJfhOl5w0R19VmISbz3qrRHiVcWt5", - "NqvVhJRA8SW8ZFnjwGC6GNoFQuIAxbwGiMrTZXxr2FiWhKvN7akDt8CqflZX49Z6++4Z9SYZtZ9VVnGq", - "Oz5CYaB1Id3raiePmS5zUfpcFPoVWIq9ca6P8CrjpWCFmFjI4Nlmh+F3zI6Ah0pbD0mJ70rEZUVoSpIA", - "soS6zHUgO0wWJueMG4YuGRg4Mg46BAUyQXlL5lKfsHWL+RahfABqFoTnid8DqudU5OzETfmELu5aiSg1", - "xOEFUIpIswhVpQzZJqEvXy6a7JZtCB4lXro60YQVccJoJ06FiQeXHhbYgriidFmxzT5fTy1qHHUpFroM", - "O+CjYmipHxi3E2FzU9uRlquujncggFuKQ+grM7GJcOvQ/x113nYFSq+Xo8eXMVAKdRekljv1byR7KLep", - "Ds3qFT2YuFJHx3Tw0JH9OxUTRK/T7s/CvsUmQnhW99xOad96MjGiR/1Oat9e4d5JpXT/tqmG/2Slhv9k", - "Z52K39MjCuxdk6U7dRU5OtbCzp3mF1lYUfq9cRpaKBNXQzDBWouviwIBcMgomRqVfzXB1muzvo1dYo4r", - "LNYtqUuOkpCsrni7aRD5XdGUbkf23LKH1QumOOO9I5UGZY6ChGpt3Hqhcy1pmeN7UXUvqu5F1R9ZVAWU", - "4TWmWcImrmEHzXa/kPrVt3kbFNnEqBlAkh47Pzmne9K6HGkFMurPZd136+1Fp/skna2aIKTr92E1Ibpv", - "Od63jUi9NqfHRfuGZbuXmLdK1gmZ+fg396+hAcZdkdOX6dmk/199Nxsre2GAvfrBCpLzAcdNkrsno6tJ", - "x34rxSD66JyyN0kc1ynp/Am9iZJ4kQI+vafD6zml14Sud4mxvQ3JePabIs6bO/7jSW0Q3P4deMMHzd/r", - "AHdSB3ich+oQq69TvUUhNhH3dSmKq/BWx77xccEBWDKjWhDBGbUoxbnUlQkonw8Mq2s1kJNouyfwhNoa", - "rQmP3TRk5fldthLtqayo8oAKLtGrCl47QiekMpceibVv3dAjOEpmaa9AQh00mFMx0aUYOA6h8msYhTOc", - "xYNYNhF6q4bNzK11Ola5BgGueqxnmwHGr7SsDZtKo1DEkFk0UKi/u/lvONhxq/jNChPL8OI390fZHTvK", - "jIc7772uXKxBPt/kLDvwUOnXdoyhzDMIAgttsxJji1GiQjgJynM03z/9ic10VRrGp/qmBfHbr6lBCZU3", - "h6T0xbWK4tsTDQ4lPyES0pDs91e5a2LlmeCFnfXy61/wMctmIjtLsSU9X2+vt+KrfbwoXDHSfnUuDcLq", - "YM6kYTTcG0YreHZDg0dpAEGj1QI0urzkUjmGjyJaGkuOe6R0LgYgrtBriU364B6sxAHaqwHhW4mZPbp5", - "iCG9cyCjMN+r4bzQUv5+0KyRRjx9pCIy8dnj3+A/6yIO4B2GwO59pPYBW9n4VKbOU0fyD0Ga6yjyMmZM", - "5Sj5D4hO9SEis8GotzOvrNnKpQvgCqYchddBqTeFQatz4Qq2hQy5b4NQXxzJ+BXAaijYxB1Fv/zuGXLX", - "AxdIZBet/CApOyAGNcTYh1dDiCma1Ms5BbT7OgUu5y1J9E3pvCII9Y8tpuuF2VhSQ1rQHxxTEKW2iWgr", - "xQZpul+UAktw+qC3Hi23U5Jjm/kqLz/t7FBaw5xMlFyx5zs7O91P2BwcTi+xND+C/p8/rQdFZYyn0ECp", - "qykGdaeB/FfwUCvzUliec8sZckAocz4ha2CTvyk39WhUGVH+Bz/Njqqdnad/4ovFfyxKnR+NHm2ztzyb", - "ERyvyn1l1XkFyRmCQaVUV1C0zxQwd6NZaVe/FUX9HebWhBIcV9HYO3t8o2fcncuf+L7Yjt3Frxm//m0A", - "wONqGRAgHxtFceKMp222CxkbS2PFnGV6Pq+UI9E6P8N/DBdyWG6RQ8KSYJ8+HrQlgVTGCp6nI81i7r8h", - "UMlGcZrbizAbVhMnrrV3e9rljeVOPhvy7jN696ch7/70g3K04zK3y2lObh7jj+fCljJbo8a6lzCBairP", - "hWqIi/7D9b1rfM0Z+1rP53zLCHgJKLJwriRPrXtv8GSfisZIBnrcXCPHMjcr4Y36fXBz/nWPHqKHuXHQ", - "jUdUFdK9gOx9o3puWNtfpZ359b3acUvy1RPC/dl7a2evp+95YJPBJ2+TiVsZR30xqYQaHomHVBTqTReB", - "67F9xCeTB3m/LZjQu2fK+BFIGKlp5VHTJl1Hl6vjYT0hAMJGvvJ0ufNVCt0AL2M9NvXF6gc3RfwIpHyw", - "gcIUydrHmVZKZLZZHWT1RcgbPDyZUx1ts832Ju0rzoKDtQFrGV4Ar50KVgpTzeHWc3j4Dl5BYAXx1QqV", - "99+FUkMO9yO264Buf9r5mRQBROw5ziJr0LEH7D2ewlXpmE+FsseVclsPsQ2hnDcNOioa6b9FyW75mVCu", - "pqmEkCBoj2F7+NyVa1xoKhrkoXndHY3lMsdXuDlDXfRkLua6XL4gZMyTNZe9IC9eu227qti4/oujG9lG", - "l8ed73F55AVBnThlEmTEd7rGOpa4d5LcX4/XXo+d7DOXFPcTXZ71V4L6RZdnsQh/QXEgCy0VOYJaFy8m", - "FUOsXvZQYlnn01KKSbEMct9LzgBRAhIT6JuR2POQZCAlPRdohW8pnYsxOxNiAR3CL3tv8D0sCU1WtUpZ", - "XQHk0yN8QuYgB8MKhVmi0kJkq+M2DKk23GtFp1Jh2UKUXlIDpJEuz8ZMgL0742W5hIEIGSCjg/XJLYaD", - "ZsHDh/qC6HPCQpaWhuCDcKDstdJq6+nOE+8unQuuTOOscBCRLugZEI5gRCS8KCJV5EMPDNjaO3hauPHB", - "6Pap+bS7+cmNYQJQ11S5a70LoC26YwL3Rz1sEuQJl6LeppdERkLZculApYjw4GUAkqpspufiXpJ7Sf5D", - "SmeUn5cVzYWebuKSjOFX4FNSnfu1Znin36WQvJS+05eoBtHEaWldFn0IYsjd8L56HB3J55muipxuCu42", - "KRWby6KQRmRaoQ10w2hnqeyffhqA+LIOsXbVKDdHr32ys7MxLM0t3PVx1y+FiYIUfH/dv8XrPi35ppJm", - "ncMkFi21YXeAwOh1llxBZnxW8mskL0JhUuB2Lz2AP8pzXoxBVDgpMcZXsUQIvlNP5IaEx5C8h0FTEyq/", - "3MQ2G/JtAi8RYVwP8tJteHnuhdJVhNJKZ9AKuaSEvfD308r25vgTHiy+2kztdwVkW5dUuOjhJZUuV740", - "hqAC32VVePdhAxGtiRnAPs6lRc0FM4ZZVgheGibtdqqERlcwfnAzu7MXMDdAWmGCFhhmuvtpDRiLz/2P", - "OTi5effusbtag6+1bRuzNRqD+o1On+BxTB+1Qf/5zjO8VReCnwsTvxOYHK320rKMK6UxBtGZ70s5nVnI", - "SXwRzElooarMEv0R8G8BLURX+DHYcE4cyVMm1PLPwHIndNkXNlzy/Thi879sW/9fwglWLhkEh5VDLTW4", - "HndXUuDwVtpqBrjH3R7FBm+y4HEV+YjubeB/GMsJCYHLmk5KMSmFmQnTL2X26ZUG75LX0ZuXsWKG1QwS", - "fQey6n7o986yqxvipgzbUsNpmnfQr/9DErunxcuTO4jHzVz28EX6kEWvufd9R777ln8Uz0Z32q5wifed", - "jT2ucc4ws9lJfHaBVrVSGOtyKKx3FD28jE//0UvfsKmyWRSZA/q+rurGW174R9uDBQDuxN3jfhpYHjmh", - "70jI9r2v+97XPVhMEuteUkp66bBCKQgpHQtRGmmAEWrJFtI76kAgbztwhWYOfA9eb/WpVc4R3XRBg7hz", - "/bBTsdTuIqFLOZWKF1E3hZwI0EaGSqEwjisaXte8LHMxX2grVLbEevo3q7j4SUWay61mobju99REJ+2U", - "nkzW5KBcy2BcAcHuKF7x3EcLjMajmeC5oHKVB+if2tqH62cSNqQGgft2OYl6sxP7AAyoK5VfcVo/3/xQ", - "X7vSu1cb6dOnNz/Sz2pRaiBSflqI66GbzU/Bm53igSihHjwqi1eaWReH54ZGKzPBKsXPuSxgW64w6B86", - "38uJ041PeTgndWX7z3hfFNi9WDsQ/T2ooaFCkDIGmAn21TvcokRPMBH4ko7EPtvsNS+wFieCUs6Fnemc", - "zavCykVBXximz0V5UUrrbJiHh+9cWBk2WBn6vPZN1D5BbmpvJ7zlQvE0mwtuqlI0ppb3Qxwn9YZD+u7u", - "Gi/cAK9kvDCigWHhF+veJXg7LkFhOyu/gsVFVgo7AJBkUep/iMw+MMx9ss0+6IDxi9GaiF3rHhNMQTrq", - "yXW5KQ8sOGjt0NIH8dUe6jOhhujQ9WfvMDDolrzwOMmN3e+u+GhywZvn1H9twSps0TL0DMa9/vi/ogX7", - "dqM3/2dD3n32Y1oJng559+kfwEqAMsGRZ0ScQcS4XwbAP6TBHkiAnEKoui7RbAkWUTy457w8EyWc0RjW", - "LktjfXldUis6AsmDn2DWU88xHaZwU7AOThjc8n066nVAuSA8sYPU+kFFxJqFE1/5fFHQUtNc8UzYF1jF", - "Gn7FY4taysXoxU87P49HtR189MJ9doxBpsel+3A8mgsDNZCBohxjzND0is+RWPELUGWf76DDK3AOXSOu", - "eq1BnlF8LljmbsfgPfBcCh1uOcaigbihQVbEPyttec05MPDY9J+YMFjWxuSaCOWaoRI3lMHm2ZmAp/CH", - "mExEZmGyGV9gUDEt0/a9pL7Nq56XqSkhHWuBj3+jf6xBBNgX5/pMRAIDDa1Ao3nlUjSdTCbwDwjdUtWi", - "r4KVE78HruvN70b+w2G4AcnCVb8L4XevH90NrgtV3FZw3Qo0A608LT6o1ZcxM6IQmRO0MkJeLFHqr7pp", - "3Qhn7dy2nlIKW0pxfs+s98x6nczq8ENWcWpfeBPl4dbUCFd1q0uR+2vK6ZLxxcIFPHF0Tl7XZeW6ePoG", - "DInYAQWy3joWwTBR0oiQvhck94LkGkO31+vacZDE6gIP4dXgQrGCz5MnfX88wgp4uxYSc7J0VT0GMMjo", - "qsxEBLG3QTmvRkN4UdUl23szZhpf5MCYlk+3/lnxAlSbPCDjzpdb/uOj0Zh+gIV43HgAzTXefXH+BNBz", - "e9LP8D9rCs1talkeX86GfTsG6UZ0xWWzwkxEZ9dmjL7HArw0FmC0HUHahN9WoAAC+wwQQPRaQt4cugc3", - "T7fQ09WQomkSd5PSeukqsdl+M/xGc3j1S72dj3+D/wzNNo7RWVedLLjTh9jwZXONaVj3ica/s0RjIIrr", - "yDIG8ridFOMN9PD7g8bLnsN4ezaQPo/n/OtKCYQE7gA/UtII+AL+TdjRnl2Gyaj3/Ou9mLrzYmqcqJtR", - "yoxZHax9DSpB55xD8e4pdAHSaBVgty/2m2nlQr+OY1TykOcCm3FccisSVYBv1Br6nn+NBeu9IP3dCFIP", - "bmQHCFSqbnGpejnh40SdnEAl4ONtFc0J31GZHIC1Cj8NL5FzGIY+yBDhZG6/gOrWmIJPxj4C5PPnvTdw", - "8Yd/L6rTQmbB5b33hj1clP84fvS9qlL6pbjq7cUv6D3G/q3dq21ExZ4/699W3qvdS495ITmsxG/4j/4K", - "m68B7pPJSeiTkFFI6cFvmfgqjTUruW2XesP/9HDegttZzXjcvdl/UraSCv3o/Ie3eSb6znF6+66XtWwE", - "ogbMiGFhwR2Do9+Yk27IgH/PdXVFReAC2yGyLu+12Ize6I9Vcb74OjuAT312QcTjqbCUwFuHfHpTsYHN", - "nqCjjXLvUrAfMD8f1XInM37vib4VJxKo3vIGsiD+t9//vGuMnCr46KF5BAoajyRdJYs86T6+DaqmkV2a", - "qp9c80BEHg8lmTHPp4y7d++Z5m4zjSf71UzTPCR+8/9cE9gYArf8+2uPhtDuJaxN4dPh9Y5qHZGvkvL3", - "iv/VpfEwzX9NcaJwKUeBbBxaYi91xRr9NZHW+IdJqxpyAYDyda9wKTe1jMV3KwkxCNTKvRf7Dt22600Z", - "fOcG1rDZbIiBzEOZ9jHfJ2joRiT79WtYfnQ0p420q50BJ4uPj/uxi7z+yFFkq0+hFerNY+Khx7/hf5NF", - "Djp+uAb7eXzzIScTieJX1NOlShdsdlS5Od12mYOsKg36nH6kOgepMgfUq3t8GWdiLkuR4RyGZqwBVbwJ", - "X/U2XIhzUWzS6Dv8ILG0BxSiOGT3wQzUs7YU6LjRLKnjW7KEIs9Br4OtoWl9KGL5++vr7URTpITtVWU8", - "1bPaRMpLNdGXkfIH1NP3kvN7KhdfPXMHiJawlr2sHtDmo4M1KYf01HycTIzoEawbV4/53Yj+S0voWxOH", - "vbhxa8Xgvez7HrLPeFGyofSbyAJ+mnEz+7ZS5HHFqkWhec4Kqc688YWXDFpgQIBcqkh+8KWgZ0P131/g", - "3b9wM7uqPEw4aGfU7FD/LIzCy0WcAntY6AtRZtwINhNf2cFfdreePv/TIxyqtaKEr/777ztbP/OtyZff", - "/vTTt38b5NV9cjPMC0v5GTerD9I23sqLmSgROdz9iMzsNvbeZn/XGR/Zz+3c5/13m0sA7/Rdk7yArt7L", - "WFydb+w6Dfo3GF90yKdXDcCOfSl3Jbvxnn3SRtKkw2tIRFKHhR5j2d5eRvLRg0AitbaaS2OlyiyxV4jJ", - "84MDNXbGzwXjlhWCG+tq/QKsPXJ/HJX4UxyV6FrItSDYeox6gti+U1FoNcUYRK401QIWfL59pDZg59c4", - "1e/J0wNZmUZ6yWs9n1Ip5nsmvoNlxCtlL++2JoZ1kYArYwkNMBVyCUeCaLPojJu7xpxvfYDjTRoVLJ/+", - "L7zS3hYn06wGczLWfa8Z+YdEJLhn956ARtjQjbkdD/PViq5p8OcDQ6fy+lPYgSEHd/hcG8tKkQll3WsU", - "DzWHDRkz5+wXOeIqUyf4LWdnYmmEZeQj+U7y48+0UDcuP3bDmgxO+Ld8SqPb/IvXuKQbfXIgeJnNNvtE", - "l/bWRCJ1eQnlJuIj5tjiXj7+ru40fls3lpK/WT799jgSVwMEZkfEgZakFQ2kpTCNAbdJGEtos2OSew2p", - "x+pYqO8kAA9j2XQLgnBjebmZMIu+u8XgsuYiXv4GFpPivZD6fQkp3uCyhKSqlLFQVOQxh6YfZ0VlrCiH", - "yaSphHdFzvxXtduytr9gsn0drW41anLb7IMAzax00of7NkAlhChFApwrdMYL/8gXz+WJrhHR1T0nTPpu", - "ticuHoz/tZ9kR+6sc32GiVLGd1WqzR2ezzfwdz4Z4qH9EIY3h5BAcBDF4zRnctEzSn2jnuPX3IgtqYxQ", - "RiKmsqlOyVFDA2WaDhu/hR5jS6gca5j0DNqQzrgGCqs1FF1UcwWrocscgQ77GtelfbVMr8goGphPy49+", - "whbGmCFMxrsvSayxvl4/wsB6OuYmi/qkv2CC3S7ArgrvbZ3zEhpHdu8Q/oHvbxeb6n/+Bju5WZ+46xT6", - "X3WGgTjAlO4knfua2zWrgkel895Nnm9XOFu6J0JK/CdkfT1/w1CAx/n5+PeXNfULItHLLmbaiGbJ/aho", - "+lznBHNX59RLw0pdQZ3DXQQL9Q1hoIs7DTDjAFpalNpSWB1zCgionzgKghv1X/Mpl6o+SgyIhRP38Fjm", - "J7jZXDlQYTwgGkPmrmrt050nUSsEdOqaGbu5+sF9qscmwR7JLZ5O0gOkvmSc5XIyEVh7qdEdFr3livHK", - "zpgup1zJf/lxkHrs51UZYcbhxMOaujC6CLreT5LON2r/2MPjQzleJtU5L2So6Be1tjOsNddAz+lINOE4", - "8qay7bAj6oL6+07Zdm4Mb4TlskiW7XMb5ypObN+sdjwcHPWWJU0A5Q8M2i9sVqiUj39z/xqU1BbLJT7B", - "/3fQeI1rMC+Bia0rDbGnaolhS64Mz4hFjZ7Yrdw1DKy9pJIW9Z051HStc7pVzhYc67V6/NDwUlNzAaYG", - "qyXVbpMlc1gKY2wjPIMJCHUuS42DZ6VAeZIJ4wpjL0phoNyfmjbeg0YoEGEmQRwtQdy2VoKVAkBESDMP", - "Ihe+LAQ/p4HFjRpWKasrWDYapdF010+J6+ZsE5r5A8OULADBRBo3EoG+mUUt3PV8Qel/oQfM1hC56ZFF", - "RAexLFqXcej51Sca6jJUKOenRij7R+XgkCfauC1Z06SIlTrESo97pEL485ZKHXmFTdr4Cgg3wvHaa6K0", - "Ca2uwbUGKFPa9l0yotVwm0yT2J+Frelr5VXwE0zEyH+JGnJsfiry3E8HZ9pzp8AX3t3ihZACgi870msN", - "J76FiwOd35BpSSCvPXcHRxF3Jdruts/w9Uf3pkbYcJqjtTNKa4xX/lcqaQrlAXyRwIUorRSGTjtlPWri", - "qc6X2+zEX6hJyw9/HhbmhGUzrqbCBVPqMpsJr9bCaT+ZyAxpns53PCBbFoaphkP5xB3nn0r9dflGz7lU", - "vm0SHg6Y6/P+OxA51Jz7hiQOHZknoPJ/LKd7ef35TF80eoRX6JaCAGe7OE2Skkr71VjGajyo+e17gy/+", - "2r1jRLeJ5jkOP8NnPec5qVRNSRlexUM8A0tJToc9ylD8WVtuoyvgyafPh2yIwvcYmzjpkcOURHiz1w7X", - "+mUzUG/nxnEYk07Ia70zEcJ3V8MJxQyu744yAHPcBIC/puoSa8trzdAemnxDUzT1ejft0GFs38/2fC0G", - "X3fx340tvvFv2Mb1mXlhCtdp50XKWmPrbb5zi/Ze6HgTm+9KLvuDanWUOhBfdtwi3YiSN1huejySK+mT", - "VX8JKyd2oRuG9hmUgtyBOzfMFItSnEtduWsgM1YvDLvQ5RlaJSzTKhNUGFxXVqxwR6bF+D7qQ56icd43", - "qr1gF9TplYH3cEGcQrf9B2UgWsrudm+oPgRE7se/hUpFPut5gAKBL7ajexJpChogmcjAiZ08MEcqmCQr", - "BeeciwnaZlFkCF43dIWSAr0tcCuSc4HG00JM7JHSFbgXfLvRB6F5zxkKDDNiTh43zlRVFEfqxL9WR/mc", - "vIz8Q3UYEVXfDRHf0WSOFAWL9wQSfXYrjvt54Nf7wK/2K4/Es5nMCbuVSN3+qFx9ew+GRRdVI1wiqAsA", - "G4Npc863jIB20e75cS4tyCT8mK6P+C4IEfF1UWBh5gkvjOhF1rcVBYk2NIVBWVbxAuGqHEStddKuxiNj", - "lwX8AApXYhUAapB8ZW2zO4VZ9FmSMH44reTQv1CjeyfU1M5i/bLfhx9QOTx31AMictZOtUpqmx21a9Ua", - "ki7URAFZp487IrnjgSH1KG9LNb9JVbJD6++kSVZT3K3VSJA4bV/PA9OVwb8D/KhLq5ThUMKTiNfnTXfp", - "rn5AwjSsLtETuAo51mDgV8gICJvZPzZ/SfB/HykKLaCjkjxlSNZwZIKTMG6QlcJUc+HBl+EAppSjI3XY", - "oCF+JnxAnAsywPceGHYmVT6m7PalsWK+hWZQXR6puZiDH+9I7bpYhUb0rR8BZD4pHboaoxulO0tpjpRz", - "eWEwQq1S+IC5xqWJR5+GlThSjaWAwx0DFPyQGu3RLmiMj/AONmzDVSgJC5VE9B10ku87mrjCgf7lBsMX", - "YpnjhvqdTIr9wzFV4UbTvVRH23nRKxL9bnrKwI9+RFvkHRa37/kZXD9oP/D2GrNQn/S9itCFhKhzKS5W", - "pFHz3DS6pQomHRIZN7KwMFQCBQelHwSJsgVxyDQdJ0oFy7nlp9wI514AV02mI2ErjhRc1Rci3/LCsNBT", - "lG6hjTCeHrlpQxuJJAclJF5AzpS+aNypEtegI5W6B1VFwbr3nvxkzE4KbuwnWA50Yh2pE3hkLLLnyeXu", - "Nx/9rl1VIN6CGApj7RE+wZUW3vtDAaBcRkwctJdskACgOnenXJl+3eoVV+BnAtXgyc6ONyCSYWzMuDlS", - "SR9fq4TeKVcneMkfM/E1EwtLegbefY8UvAUqNld1RCU7FRNdgsAgVy1IN0/1eL08k0VBMTykJh6pjKtM", - "wI/jEBgCL5Epwj1E2jU+/pdmY2bQHlpG5FwcqdMqnwq7zT4q4buecFlUZWSnAMmBPaAr1rz0Ch7uLDO6", - "tOZI0dXeKRkuvoJJZTVMVcE4oamJrhTOAzrxHlUwQR4pYD2pKmGwng5If14UEMAkTaaVElnaHIK08oqr", - "uqjtDak52MErrr6nblOPYZVCoysLB0jk/29uyx/0NveKq24Z3nUCg6wBvRLD2S2RtYJdwcF4YSy6C+hw", - "G4ARDy4LkWz0yHJ4BwLrBOJ/jENEWlkpjFvwhwQ+pjMbuA4Ex9K/dKSCyIBjGy4iLBdmIS2VYfz08eDw", - "RQguYRkvS4mBpVHJNbBiHSmrNYO0Rge/hCvAyBQ16BqDRPq/nBXlRtmRXGbflx37rCzJFA13oqzOz4hK", - "Xv9BLS7rHHe93OrP4LWwSJzOpwCh4DkMtjevCtiGgp8Kf556L9qeZbwwOmRVEIfQAYenc6EJBgSSgNdq", - "tlHl23UhD/AW23vjbZRNtMFQh7EfbzCYKatK5rdcAC7MtY9NbvxM+n3ovYcU5X55rgDNdFWywetC8LIO", - "4yEtdZvt5WK+0BZDxtMRa+qU9K/R8FI4oBySdkncc7//68O6YJmd5BoSzXDrEiQZpvCel2c1TQH9OnFp", - "NEre3U97CMhAt4woRFSqKcbFqyNFN5tITov4nmOimjB0oWherjD6/gUYLvzNxmq8LIHEpiaYNM4bS3UF", - "3AUHDH3Qj78JHalK5Rqj7P8KlQfUNBoG/kmToBQdNpFfRU7uOLpmkWbHwRYjFiyrEDS6tI3euQl3o1ec", - "1D+ugmXZrR0s5ZEqMaXEhMtfNJj6YsV67lVHaoOL1eg2joe19xovNe4lxgY3nl55sf64qJWhLVKG8B60", - "NhaJ3iWjB/4cnyhKXERMrFVQe4+U0jncXd7R55TMlldEVmA/OBNiUV+vSmOZzshCTCUjEEohdUGpetWu", - "gzBD6vVOqGE3eGHqzPd73ZrSA+myvFfCDbsopbVC3XP9+jguYkbGW7bE7uVmqFRolcXuvV39IlXeBLUz", - "Ll5m7w0T/6x4YdgJQVacOO8st0xfKMZDuWx4Cw5o/x4cx2AXBSYzC56JccirkyV866/MdLYWhXvixrrN", - "3rgEyHpIPtSLYaQXnTn0K0bGkFnFv8723pDBU4mvlMMX4uLw2K6LEZ3EJegGuTbaFcDXiZ+3X3lm45FR", - "VieVW14JD9IvktYGHv0gFQiHx4M1CpJTaf7Lw29HVpu6IvW1lSX8XYBzEK5hqz64uBRMx26em1pW1JGZ", - "QTg0SymHMJbQdymMLiAF/HRJwge+bCXKke5MXUx0UXinaFkVgqJRfWvYbVyroRDWitKMWS6n0kJ63ZbL", - "3Ts+eeTVc6WtE3M85uUN0ec6USk0YGkwCEcNtNR25M8Nqh8R131XqIvucPq0D0dmSKj5ferZAF7fzfOY", - "qvv5dFM7VksFefwb/mMNesa+mOtzsVpiIFyP/yOvuYhiu+D73GHshOC0FG+RlrGSu3ZpxBtHLbiZjm7D", - "SBsxhdOb1vOGW6U/atYEzv5mid4FD62IXHiPgZfRILQKEb7wA1w8MavZxTX6pq9y6EgbxzzyTuObHUFv", - "/Bxv8Axyffg+v/8p1BpQv+ErRLdikGJ3re+PpoFHU3vhrsyTDVDjVYfRAabbRSx6KuDeMJhRm4RgjSgm", - "/pwiwIW1BSDc28M4ddWB5nn1OutsD3MbxTPBIAVRJubzezxeNiHcXgQSQgbwwFjhCYXWdqji0uSULs9+", - "e7R0O8fHd0XP2OT46JDOxd2D0/heEBnXdh4UWp9VixWBJ87wcIImuhPGzZhJRRbHFyHqfe8Ne8jZ5897", - "b8ZkWqqz+2vVblJnoZBHRRgbZWuNA6TOhBfFKc/OHo2bpgaC6WzaMdjDk6Co0pXjJKB59im0j2oR0Rhh", - "CKtpm2elDeP1/tq0eTbEim5kRn1He7DGivrKrfS4sySNBekxqf4zCmy7jEX11i5xbjHWWzORMFM1df94", - "EBJan7Fqwfjm4mBwfruPrMH3k+UpuGIav+OFCyMFa+VpimobREtsigCZS5eWvc1OwG1B9RtOolAA9NNi", - "McDpNvtFl+zt01cPkF9ZVkhY4BdMWjbnSw80pjESmy8WgpdBFihtZSbW8Ogl09FdHfGPZX28DSw+Tkne", - "wgz+YHh9H3rd18O4SV5+5QZmLlFOsK745KTsnSllcV+eohPp6vYoEjBeqKRlzGPjyXtI7U//co2iEYmf", - "GqF0Ks+FYntvzEv4P3i5rmZjHvjXm47TWxEbgZcvKT7MbXCpH+TmnBoXUxfmnk3vHJu+am7QYCb9zdHf", - "kFD0Rgp/HZcOf5GH0YEG1xfzW2G9VzSDy3LeLTDenproTXktR7zJO3Qk3ld3ujxfus0cwJZzrvhUzIWy", - "9xj89xj8m2Lwvw/Uc3kgfml+Z8D7V0PY375+1O1UZPJuGERUJ20myhq7nkKJMUp/aKmeyQRoiZpzAfro", - "H42qKyUL96CdDRaji11dOcs8LRPhfI/Z4bsDZoSlXAjP9AuA6mY5YnVjaw6lT+UYIk1tuNyHxCya5Xt8", - "nbF+NG3OfNGdK5Xoqd+4xjo9NV/67bhZ3Oy6P9fPfjTMq4JQvm4QqlsrGbDhf/diw29hLTi211nd1pzq", - "jz353xAAa6bL3CU6RIAF0h9aLlchHMqULerewq+8BtCq0oH5rw4TInrkvL4geyaoBtApHb8x42al5ELu", - "j353VwWp2KSQ05lF/EZpQ++6jNHxoSz6mCHUAzsV9kIIBcgRmQgQ+eNk73XdtDCOEJqZNerU0LL4qMsQ", - "hkXThfWrWyU1QWmHmMMVtK/ERbHshR8HiRSpKA72pjXlhsISof+PXa2FeqcfGBcU7jLonUGVTTAMXtqx", - "gwXz40dZ5wVcPY5j/5Onmm124DSR2uuadbSISJuJEQaCEjNUK1opVLHNgNTvmGmouz69irrsmdAtyLdr", - "OQTewmm1rmDBWkbcvllRCqtNzMTjpaaYEweQdw3i1dhSL7dKwXOphOk3Sb4G0WEaULeDVwpJZk6syRVh", - "1wDLV3S/kYYJzIsIctbxNafAz7jSEsozErf6Qjnshcy26iiV4V4ViipF8DhgcalfxqtKeDvXlNIMMAA0", - "NCczT0WGkGCpg6F5GbQzMd9mB/VP4ZZVB+MhDkjtezVk7gj5nV1RcTiTxkGChDZI8pfC6KrMaNoAEC6U", - "ZTC1sonBHPmZPG7yKskRRAYSyH6gjyGiY9cSllp7o2s5/seSFCvpPyoMFlns/W+yjEh1XhlY2XMBFxj4", - "0B14jotbVHmj8gnFQXT04wBYECPbNwnWv06oudN8mHtl701dFcl96DLefLJyjy4C2oTMZvAlu+BL2I4L", - "Xr8NFhXP/r5daZzqFb2kHIs3qElp/81KU0ZU+OKTn/MNWmw7wiF02sMgfg791WTubo7Uekjh5OxW3nxu", - "ggP8KB7/5v61xhZaozm49wOVolGQ4G8i86O0JqpCVEcomaysTulxMIqIOZeY+vnm7bu3h2/fBLORKaop", - "/O662jqqdnaeZTVuFf4tHEc1TJ9MFzl9DneHUlRGjMOlC5om3C0zkwuSmR6NomWhjb0vrTOfriFC/bMS", - "PrDCCl7moCY4v00LxgvtsEXBpJPltV3Yl+mgiZX6gpWwKAoQveAWdsHLvLn6UVYKrBAdAfX+Yta0MO27", - "AlxfosrQPzmzMLzirdHGikUNXxjp8lbOBXqaSrGF+23c11tuT6PhjVlGkDI8QQQ+o5sZifCKfq0h2Tfa", - "lrHbjx79zFUg8o307wXa49Zbdp1QGqSofKoFc8wFRCyuW2n8eH43dUX6Ez1rlqlx5QZJsgSaQpBH14RK", - "07ftnxdGlDbe9ps0G7p+qNPvFDrcGU3qAH7r7dlBGolMqwyBaYCGrjMVZtCA3KNbqj9+JzNe1hUl12W9", - "S6sZcBN1wKOG3T7Lps2tsQ0hUo0JFGib7UYIUlo525upUfrcJw8i5CkQ2u7EIejMc2mkVs6wG3T9U07V", - "QgujHdZuNIQHiWO+B6MqFHnl2RmUwlG598vaUgbfazw9Y/nSz9Aloy5dvMjcqQikOrho0jCDC6nMCwwo", - "LbAgUskCoE79ElxSMjjoRR7CRNA6AJOxvJwKHIGFVNlUhYZoE+bSYH1WXcY2pj7Ru7tYFEvH16+4ui3h", - "uymG709JoGhaElw8GFqzwrqpFqI0Iv8DHPq4ibW0cdDWRC9XljygX/4Asscb+E9lUcDEEHjN30dCrWIY", - "MNo4gqtBWlYIG9UXIA803uvvPsfi5twWz0JnV+ZaaOSeb3v5tl6eK3Ouu+4NDbG6Xip9g/FXjnI2CdU5", - "jAF9optq20f1+9UkaenS93UsNnJH7nXja4kNcqW0YqdJh/qcQbW5Hi6YrODBai5zUjqLeMW8L/YlK+Hl", - "DMkqCr7xjYXWuzE31y7BsctL8EYcxtayxwaKuL+S1eIV1yhiJLTuXteVDAsnmu+jGQ0ypLyjAd6SduB6", - "u6xe8HYyEeQEpnXFIF6zVNms1Er+6w+gDOwHs4ForwUFLV0X4bpr9uPfKhOUgls8MxJt00Bu5Nawiwqm", - "Yba+mefCQB8upi+jKFStaoFOC3SNN4CB2vx77Pe2GJZ6w/6vqtS/D64Cv4Z+fX4I9f5OnFV4FQAqPBcl", - "kJfIW/QYLe2VRYCLZzZ3414f4Vb7jIAwdz9SluusIpeV179iRgTWLik2w86Ej7z2b1AFbHRR+eZ4KTxo", - "2jb7iFyOKPMdNjeULBE3G4ZSqYD685Y8diHpCfRAib+5wOmA+ZJxQpRAlMvrVSwPhGfuA7/BtyRMfH9X", - "lSSf2tsO+3RvJGgaCcLiBPpeJw/SlTcpHnRQjI2Lu6O6kSGQlJWVapU9HjOpsqLKgWjLSrnI7BlwkN87", - "oXKfYORteRgGoJW0usQ0i0JPyXKPsXAGy3OSRmihxkIpLJdqBdgWn/s744qhriwO1K14SfbHu1rv0g3T", - "DXIj+OS6vjR9e5+T2cOml8nATFbNLD0peaYN/Nlm3FY1iPrOOZRj67uEjzJ1lwqfL7gVlXvBI5NC2CGH", - "GdiVYYlwhyO0vqZWVNchXD83BRLj85tmFqoZB8PbHC0gCBi3F/fscp3sMr5KXa7CU1w4C+Hd1RxFqAJr", - "OSp2OjVL4EQl5/yZtnSwrO7nG+c0gr64s5xGw7sCp3F86gAg7hnu7jBcc2PW8Z1H6XMFMQbDdIUvmdVT", - "YsOQ0hvBtS6q00JmXdRW7wPOeFku2Yn0aJcvmC0rceIAv2hQY8YZqNSnspB26ZG/KBW+tIiU12o9IOUV", - "kmr7ahf9rxUiG+aO20PIOWUFaEPZL4gTxlWdNuCG+S9RapAsWNW9Mnwq2EQKBOuLa6XEyGWsUgXsxgkM", - "9YQZCFfBdi+kES8HgJDh0KQhOUQpw83UaWr5xpFPApTgga+ccjkoUv/9t/EGn+jSbvTBJ6S6jT4ZDHQW", - "vrgNrDO/6rRol5XWbsC/g8q5PwIAS6uqSxqDZTz6usUXcgvC3BajF6OCiiWPR4/Pn9aGgZXiGEPl61cT", - "vPu3pwfR45XQn++F5Xifp6LWGLRjtZe10YUUyrqI7ek2O0IHwX/w0wyyDJ7+iS8W/7EodX40erTN3oKv", - "/EwsUXqd86LyWVangn3ef8eEynROZrMUlOjcjWYUmzITXot2kS0cbD3QU7Ld+iQxNPvDSoivi0LnYvRi", - "wgsj0kPAl0fjTesouQU/sA4rtFk/aTwydlnAD3A8jrpTAEnHclk6Yz3AVcbxT5hjEM47Q6kfJmMP4yPn", - "Ud+qIqJuY0qrZvIR3n7jh5Jab1LDo/XGMYqccRunx0uDwzaWzxd9Q3NfYi7HKGm/zrkVW9BO2n+1nhJ4", - "sjxY34D8u+so8PdUA+wdKkuOgi9f/AvEUifi93pqf41H/7V1qC0vtvapg7Uf49v+5RutHXZ/AjZT+aLz", - "4vzpo7RZLX0K9tU4c8H8dUwoxl3FKs4224UzcWmsmCN6RaUcT8RKM30sDcOVTTlvoBjLBofnRw9KjAYF", - "k+mFyPH0o9w6Wy4jXqizxNlnI9gTEOJPnz9nda203YPXe3tHqlMyTZdstlzMhDLsId/615jtbP08ZluP", - "xuDhmmFWf9QKQKVvs1+xHo2vU54tKe0KdJB8fKRCSJ+PsMdorGUDBIzukZTFqPNlQIcqhRUKl3YhSqnR", - "oOKndqR8QWk4amUmbbFkWcGNkRNJpZwNn2BNOlwe9vBgpqsi39qHv+gO+AjapaATNimFmR0pbmGjbesC", - "5NWMeosAlcD5bf0nGVfobEDYBzxFj9SbEG7mrT51E06cUU2fFhJTtJzH7svjuTS4mNtHCsGdthalnpbC", - "mNB2je20ukWpjv23LxlXrFJnSl+oI6Urm+m5qBt6+nRlQ+79Y9cA5kEYEbbaITKIryKrrGggpVBG4JHa", - "b79qhcrrjd9mexO/OX6hH9QTzgXPC6nAHFAZ5uXakVqI0sBJozJf/ZtdwOZjUqW7s1DqhqNM6m3svLDi", - "XOrK0KRdffCCLwXg4e8GQB6gCfF1IUuwNEjaftKgOBZaDjx4pLwCQEdGrQHs1Uu59VexbCgCc/7VA9k/", - "ff583AK2X8BalNDmf/+db/1rZ+vnrS//899ur6jxB3HhRNffnt528aagPaQz170MhIz+kKAaaRHRFfVm", - "cSZe8WDrbaomsSBap13Qu/Sq0y02Nmve7DR/0eWpzHOhrnWSP938wD/4MhfXOvBbAjBpiY4QsuwAFONA", - "Zy8sHw48Xx4FmKhwdutSwm2hCG11nOyO9NhSWG9OhIFIRaCKXxeId1W/dyFVri/Yw/Un1KOXdMHzXV9w", - "E58qOR0l17mHT5/ezh5eYnkDmGdnQcNRCN8uuDHkoZLGn+7s4bBD/Dus923wjNZsDpmbblqt2yIOZ4ts", - "A51LASq4DgiSVARVYWCenoB+r7HuumYXvIb1CRp5pPNso1mIg9I7evFsp1W1Rs6r+ejFTjjBpbJiKkq8", - "nl1peZ/fxll3IEoAx0EKu0bSeL7z7HbGLjPBKsXPucQcwmudwk+3oWpkZ6A3w61DV9enbvyQpgF3h/d6", - "YL9poGMLbwTJZVopkdn+sq8BAc515MHt4crSsgIQcjheEy4gju0Uo3KqOcQIHB6+C843uv7gr9FdCe/E", - "8IqzAeCdTbvAVrfl3v2JkujZzo4XTHGkafdS6IZ47CFdjqeoCfApIGNWyh0uEERUx6g2QNAhKNF9iwcF", - "lj93SfRwTk3dZU+o+iChVnPveIxvhbnM8RVuztAIcDIXcw23dbSin6y1ooSYvddu864atHf9Nyc3ssbt", - "6dvNxwcOuS35OM3S2zLH3+ve5pij7972wyQN3IzBNpyL6959NqoPoHXv/vSDGoIdP11Z3EPkca8v9M+i", - "7gBfXO0JDWLoHb17aRnUdd5ZXhKSmHd3+dhmGBbFXBs8w+mMcf4SqdhcFoV0h0KPQyqjaIOkb0wq+6ef", - "RuM1mmoXse4rvB3py6uG2TMsjO5rjMqddaMXT3Z2dsaNQT57CoOkbv3zzcYc/JFDVrZnyMG9OtgVCpSy", - "0hP6niYBo2GFOBeFs2xXpdpm8DU7FYW+oLsbvcDROA5B+f1rCy9uMsh3+EFifK+5EVtGKCMx6NhUp2SD", - "pFsu0wpHPhcGY5r8gZIelfHxPz3m0D/dbmVPx86wyH97erkAmYbwuMnD6d5D2I65R/ZdfyrUsTRrA2Lq", - "V5PHwGH0OJVj1wkDwGjcpnyL+91DdIOJJAHq4yPH4OECFRuccGjpsSEUskbnZA8X5T+OH10KxOGHCiyI", - "6pReIaYg3tlriCX4dl9S8I5W/nTb3JYL4cGa6Lnw3uPf/D9DPv2K2v8sCvlJ1OiPRMfdLsh/J4rwtwfR", - "fywfzkSy/P7tXS/v+a9V+z9sRz8Drua1ZKnPtJ3ugMIafdX+bfarK/Td8qGNnZ/fhCh5tOrr8iwqw+NK", - "73FDtXjhJ7D7Y/BNGvKBTFQJzr5aoc+YzcfDy4KufzVyDUFMwk3LkFeuaHhph0YSPE1jh9U74yI9fx+O", - "/psdeguw9br9N/cBCPcBCPcBCPcBCD9EAMIm6tm9N/17eNN/TDsUqZ9e4SU1ZZ3a+6xpj1oTrA7hpiE+", - "Pa2APlthlbqDCqG7U/7t2QYq4bWOwg3AXyv9QPrUTnJa4id3Pty0k2x0qnUhuBp9u8t659pR3x1Nc+1Q", - "b0FFe+3UsauN9DYUkc9qUWpgFwRvvxYKvg8o3DCgcM2C3jGlZ+1o76Kas3LQP3KcXWTKe7ZSp9FFNR/m", - "XuNz5t9OedjCo5t3K1FfGzuVHCZIZzb3duMr+m0alOEpzf9y2VxPUp9D02kFOiK6G0mn8pR2u7lU1Ouu", - "yiOP5Qq69vlU3TW7957cqsiNibXDBrG4ffwb/WNNDZA3vnDgKj6glxwn/M01u/F10o8nFRiQAIZt0F+o", - "9Nilvft4mhumPUci62hv3B9BGX3KpJroFYf7jVDXzvcSm5QPfX5PuN+FcA/XSUucFVw+iMKqshi9GM2s", - "XZgXjx/zhdwWT0+3+WKBNOW+/62N4mLQt+p+rOPLoh8RHC/+eyG3oARi/Bu2Hv1dK4512yIrhTVQV/r/", - "PwA=", + "aD5nBf+mpJULLi39C7cXXipLXSazWPwQXOIfXKX79ZuGc2iAK4g9lGomShkysOpMqUebu4mGaYMh4egl", + "FAApUGSShvcYta44KivJxG+bhodmf4ga6sKfo9lEt9pTfuYS4kfXl1V6KgiZA/do0xzSWtNtT+9LgwBQ", + "L/Sb/7dna7b/lnyDN++z28QAf0ft6ivUmXa23ZW0mdu8lQVDdtfYjNONafdA8DKb9cstnyaxkRhPLYES", + "X+3rqjS67C4B/V6Loa+WLfhUjGMY8UCrCyoAscbh1Vopl34TDaKxCFYsUqeHWKSPNZ+Z2g3DLdfeYnfL", + "aTWHVatTRqH3TagJk33/wk0i9Q9+9euIr4USDL4n9rCG+pqJr+zgL7tbT5//6RFl/1lRQjP//fedrZ/5", + "1uTLb3/66du/JcX95goq9n4dmmm6mCPU8PLfuiVdwz3wNCaDQz69ugktUXZTGrhkDXJEDA5HcJc5L6OG", + "x3bxaU/IOZ/2VMJsLxtOJfKstSLbw1ru4tjmIpX06se9+Uy9NMYBbA+eNw+D2RsUKgTd1t9QJPH2kC0k", + "39/QfQyz6niJhk/tlOzvQz03rS69+2b70pEFp301fbur2ux7e+NYrMYu1j2PY3rqbEF3hb6suFA0CNes", + "PxhTV7824dSy3vLpmBkCMHW4dhNZUqnRjY7YJn9d7ry1msBCHUfBF5R+EULWASJLIdIeGZFK4ZBywhm9", + "fR1H8ertQPCOFTtBiAkDlUXg6xk3tR2R6po2d60HBiIAZh6mhOiH8LjZW6swY8+quEm0e1mzNH8udbXo", + "k65IwJuSqDS3SKMzbt7rckXJSAR4KnsGjEvGTsXS5xLV5WmjlzHwfLtP919lKBq8d3QixoteT23IBq6g", + "7Q24mBt2Auo9/XwSVRKO1emrs3N9Z9qUGIha1/lesPVN5INBP0D/Gto1ReCsVJl1VAaddyyC25eJWMdO", + "V42cktN7wU9u6wr8LTGkXmr8zgF3CdCS5m0W0EnqJLyhkbbh0prU/U0/sDk979DLpnISR7x2tm4wXZKC", + "BaCdW5WS3OOwEhdN/KKhKa7YHPRM2DbXC2tDT5KXrjcbAtuEppzLLsWRNIVdlfeUue7DfXQA9bVHoQXG", + "jItKA/A1aUN65fhIUQUMj0Xgw5ZPoLjOUbWz8yx7+/TV8ZuP73f3PuDf4mSbfQTeDmWZvU5/pHxGh0PD", + "omsSZxlCfbCHr/7vj68fsayojBVlCIMKKAWQ0XekPEytEY0B0eyZJFNCI7S5aQm87G5bv+rtEuJwedZn", + "IqwwLCfI25JnlnDA7ay1vrdMTX7wKar6VZzOtHb1FHux/xqPcYYYegXTC+heF9RS19xEdeLzSHJG2g1p", + "SY1zeq1lKb2NbiawB+DTlELlxbLHWDAegRbEbVWKPnwm+p0MU1YzchiDA9N1s+BLCIhKehlcdFV9ayxl", + "2nnrVx9vgUOWvURXooAW0BEyZNFbeNjXuwd3cWGToGHwaZhqd5hfWruRZANPYh4Ig5VeCbk0KNeVMnau", + "nbNk3j9ph5Ulg7lkuITdjDUxqCIxkM/tAawFgLkMucSoGHGsqRtVICS39GGdIwJ6IwD8tJQCs5s/ET2n", + "APCmcATDCenWJ6cPl4xboAtr2BQuI5QXhP10CG0jz0dzfMuem871WWXQK+JJ/YasMp1lX/bTX3t9u6vp", + "ZO37VMUd/7GbIfMvY40xWRSyhrodkLCIHvvXBTdJxAGo0SG2SsFzWByMwcFiZ7rEei1swmVRlYJl2EAd", + "JDCzdnGMTY+wflD4t8d/HFMxuYUubXjmJhT+DrIx/JJxlYmCcDLXXrzxo/fCmGRUzlt4yub0mGLcaS4R", + "/i4ICvDyevHKTjVGOQwDI0/JjoMYa6Mpw9bayvGbw6Q3p9ksfjkw7fdNixQ3HJPbslewLt1RiVI6G5+X", + "LJ5m3UL2tfeXOga+2eR/Hnz8sCVUpnMRotZDnDtquEYoIxEFyGHolSLnWRIPO3T3ORmFvv/OL4rIa3uf", + "593ReI08H4882aRX57CsFAY2NMkr5Ma731x2vJDnw7Lj/YdDl9B149bw2nq3dkHxRK+ThWtQeIReKGyG", + "wZDWDKAj0HpG1MWfWMWNq3UJ0xMv1WEd92ItBV2gCIyby6IH3rdPzUBwj824sYV+0a/t5Ymhb4SU7/h5", + "b4We1iz5uMlEUppQUHvqnmsxG29yLCejkPvoRG1KrY7MaUiFxvkYL3DivPfA9ED3ZsDhH85tGCRcXjOT", + "OMJbvopzUbrjrN4oXTWqL9RoKAHpftjbUg1+u7VF/tNxGGDdeWKlgiNmmHrUUD8baFXd9XFfXFYVTWmh", + "0WG+2RndedoQRauJvibtBjlHZB6mmljgoSTIp9NSTLklEdwlt9MqOxOXX00cxitsI7WwTS13g3abnPYt", + "iNcXv633PIxrD8emXgq/Gr6J0G9jKn3b4dZh/abgVriqZ4gLRP2uuSTc3vLFh8zAMJrLrngDyWjomtsA", + "nZNeZnh+bzH5nVpMgp6QMJ30WkwIVL0qpV0eAMsQJezmc6l2Ec4WrOu4HzAbUpV9Fy9G/7WFb26RP6Te", + "GvwSJoOP//PXQ9/KqeClKH/xc/vPXw9H4xHyKhICPq3bgat0aAV9VqsHA69s7b2pG4gGMmgyn/a2/iqW", + "ye8rO/tECVHlKxxmz5TIn3ps3Yqsn1vU8FWmCDspXW6vlbaAZ2+fvgI/3Wg8OvfB9qOd7SfbO9CxXgjF", + "F3L0YvQMSjm7og64/Y85LPjjkIX32KGObmGyHr4yFUnsVvA3GcaZmfFS5DWuNgWrFMs6vt7lmUzguupU", + "vm22e6Siamh4m9XKlcrFajE0DldiGd1NOCSRs0pZlG1zfe7x30G2oZgExhz9WVikowD+tk+NvaY51Rc4", + "nN/TnR2HHWhdXCJW8M2wvcf/cCm7dMqsO4MC+boe3Qhcx7hzHZT4uC48zdGAu9UVu4X70d4b2MWfdp70", + "dR/m8xhegnef/jzg3ac/w7vPd3bWvwsvxRIEXegd2fH3L9/G7ucgCf7+BbJCTTWf83KJbhbIAm3VwxfG", + "T9YHpENkH7RDgqtDpr+FUl7fVtAozyPYUCxl5CvV8GYxVmlDTdlCTkS2zArhAjyPFFYQwg8LTGlsVIml", + "IoncemMX3m4mhZzOoCaCfxE8qdoIH6YEtdddpZmc7LSWTaA+9CBqPoiqmC14yefCog2kJ6ihfuVxWDTM", + "1L1ZLnCjTBH9Yb2CY1z6sD8+vUgQwe8MIfidjZlj56ch7/50xxnpz8LWZPzAtIh8JR/Bq+bxb5RQ++0x", + "X8gtKNXRy0ngWQFZ7zDIXUCIqb3vUPPKiPJcZoJBBbdJoS/MNvusCnkm2Mmf3x6y0MsJ7HldTtQVuoiy", + "dLEwI+OF0aGwLN0TCOUS39ruZROQvuYQZ0YrarpskrBBITfhSQxnY30OB+T/WgkjG1zNCusMPVdltYGB", + "QyHOpxs11OHAg5DcFceORBVB/RbfJB/eMr9ghBYySaBfbhgxR5dZxqOFToHWU/SAZwYWV8dYwQkdav2k", + "zZ0m14bD41oOhQ/iIqbRb9/aY/zWYZMn19Y57VreHkBiYRvlN0QepUEWy5s9lJ4NeffZ7+gAo01p8tEK", + "jlx7fD3+jW5ITifMe6peEOb5lTmYmunh4V03kO/Ny+O1KqFfspRG+FOPv8YvGa3wbfLI74LuiXKuTvcU", + "/fuYwgVgAj0nFj43jEP6vtpalBoLh6GquBAKK1+1opbNQmRgwsr9lWz94UUh1tTXj65wrb3b4GRprvvC", + "VIVdq2PRJhU+zc38QUmf1gxJMSI5vv7m3yL92hBwJosVtP9XWTjK7xZ3uASRhys4tPu7p3I3W5jrQCqH", + "zRBRweg/KJXDiiWIbjWZD7mDY6ONK0zyGhzuET/GtbM7qbtp7ezxCwCeQ9q0H9FKk4Q6fo40VaVeW3Ol", + "janLU9SX8ejrFvw1pYiEUSENoZ6uuOG6EuFx42kRGRHb/aWx99L4uyDmdbe3JPE1pNtGVzTGV5Ofu4Gt", + "u3F9lwvQD33m3T1Bl7gypYkNdt9mCRQcyoZcR1Kf4ONrpqjrl4qdzM5BgnFnDTE7fO97Yr5pYnakOExy", + "ugRN8/g39y+4/pRyukZRhAuOLrOZMJaQZJXOBVtoXRj28GgEDRyNHpEn1DVMkeW89uRTHqQsmcl4AVYC", + "1B/MNvtFlxe8zGvgHdcClKfNp8Jbz16221aalXLK5lzxqUAkBh8+K3KnDoJZwuFxg5ZC1eChi0JnvAjN", + "eb/Q850nPS7T127dXvtV25dTszErhzUf3Y4XZ19Or+a+gY0NaFk0+B+Ph+HdJ0PefXKdriG/dIFoe25q", + "vRz5WCpjwcBhHv/m/7lG0TkU5RzT0hjiQdM3EEGAidfiXJQwrAemyYLgHj0VhVYIsLzNwJ+e8aIQJctm", + "WhuBpXsDJATwnJmVUp0Z5mwfdVeGUc65SMYe0Lmb5KU9P9m9MNWrsNe4k7DnBHM91j5biowH0G9PSdjG", + "OzAaiuFXLBcGGmEZX/BM2iXDnJisRKkFJf+jNX30ksIlCewOl7e5WwWvFEhixv1az6lsBA37SPlp/bOi", + "lBs3r9DhGxrNkNnVGB5deZVAqvZ7x6wjRIjUh7i2hRX5nTHl7wwRMjs//44EUlouoHAq5XRjwfRbKafw", + "hydnApNJpotbj1hBsUm+a8Lud5ibCZFEQgiT0YBXFtyYWD3QVe5B5ksG3MDVVOQv2bnUBRJdOLSwtQeG", + "nUI4FMor0BEKSfAOUbXeIKgMM1U5wVrbhmEii0mJsk9VWifYh6V57RfmahJszcu4Czd2K9iXUz+N17i+", + "w64FT1MeIyf1aJ/uBcL3FwieMcOBdGVZQJyy+hZRigxYzXM6fbJCCrh6FZS8EAkPh+BgWF4h2n4pHNC3", + "+DrjlYFnj8Zgb6yB5TbQ6pGD39J0boN/x+tr1ruVstpp5z0nPALRjeJjPMCHPN1J5IGGVLfnO1Em25NE", + "hslt3VZw2a92ZWlT18RT1+87lOA7XXLSHH1VYRJuPuutEuFVxq3l2axWE1ICxddwk2WNA4PpYmgXCIkD", + "FPMaICpPl/GtYWNZEq42t6cO3AKr+lldjVvr7btn1Jtk1H5WWcWp7vgIlaHWhXSvK549ZrrMRelzUehX", + "YCn2xrk+wquMl4IVYmIhg2ebHYbfMTsCHiptPSQlvisRlxWhKUkCyBIKc9eB7DBZmJwzbhi6ZGDgyDjo", + "EBTI1KgkwrGoojYiqmIijMfzxO8B1XMqcnbipnxCF3etRJQa4vAC6mIrYQXKShmyTUJfvl442S3bEDxK", + "vHSFwgkr4oTRTpwKEw8uPSywBXFF6bJim32+nmLkOOpSLHQZdsBHxdBSPzBuJ8LmprYjLVddIfdAALcU", + "h9BXZmIT4dah/zvqvO0KlF4vR48vY6AU6i5ILXfq30j2UG5THZrVK3owcaWOjungoSP7dyomiF6n3Z+F", + "fYtNhPCs7rmd0r71ZGJEj/qd1L69wr2TSun+bVMN/8lKDf/JzjoVv6dHFNi7Jkt36ipydKyFnTvNL7Kw", + "ovR74zS0UCewhmCCtRZfFwUC4JBRMjUq/2qCrddmfRu7xBxXWKxbUpccJSFZXfF20yDyu6Ip3Y7suWUP", + "qxdMccZ7RyoNyhwFCdXauPVC51rSMsf3oupeVN2Lqj+yqAoow2tMs4RNXMMOmu1+IfWrb/M2KLKJUTOA", + "JD12fnJO96R1OdIKZNSfy7rv1tuLTvdJOls1QUjX78NqQnTfcrxvG5F6bU6Pi/YNy3YvMW+VrBMy8/Fv", + "7l9DA4y7Iqcv07NJ/7/6bjZW9sIAe/WDFSTnA46bJHdPRleTjv1WikH00Tllb5I4rlPS+RN6EyXxIgV8", + "ek+H13NKrwld7xJjexuS8ew3RZw3d/zHk9oguP078IYPmr/XAe6kDvA4D9UhVl+neotCbCLu61IUV+Gt", + "jn3j44IDsGRGtSCCM2pRinOpKxNQPh8YVtdqICfRdk/gCbU1WhMeu2nIyvO7bCXaU1lR5QEVXKJXFbx2", + "hE5IZS49EmvfuqFHcJTM0l6BhDpoMKdioksxcBxC5dcwCmc4iwexbCL0Vg2bmVvrdKxyDQJc9VjPNgOM", + "X2lZGzaVRqGIIbNooFB/d/PfcLDjVvGbFSaW4cVv7o+yO3aUGQ933ntduViDfL7JWXbgodKv7RhDmWcQ", + "BBbaZiXGFqNEhXASlOdovn/6E5vpqjSMT/VNC+K3X1ODEipvDknpi2sVxbcnGhxKfkIkpCHZ769y18TK", + "M8ELO+vl17/gY5bNRHaWYkt6vt5eb8VX+3hRuGKk/epcGoTVwZxJw2i4N4xW8OyGBo/SAIJGqwVodHnJ", + "pXIMH0W0NJYc90jpXAxAXKHXEpv0wT1YiQO0VwPCtxIze3TzEEN650BGYb5Xw3mhpfz9oFkjjXj6SEVk", + "4rPHv8F/1kUcwDsMgd37SO0DtrLxqUydp47kH4I011HkZcyYylHyHxCd6kNEZoNRb2deWbOVSxfAFUw5", + "Cq+DUm8Kg1bnwhVsCxly3wahvjiS8SuA1VCwiTuKfvndM+SuBy6QyC5a+UFSdkAMaoixD6+GEFM0qZdz", + "Cmj3dQpczluS6JvSeUUQ6h9bTNcLs7GkhrSgPzimIEptE9FWig3SdL8oBZbg9EFvPVpupyTHNvNVXn7a", + "2aG0hjmZKLliz3d2drqfsDk4nF5iaX4E/T9/Wg+KyhhPoYFSV1MM6k4D+a/goVbmpbA855Yz5IBQ5nxC", + "1sAmf1Nu6tGoMqL8D36aHVU7O0//xBeL/1iUOj8aPdpmb3k2IzhelfvKqvMKkjMEg0qprqBonylg7kaz", + "0q5+K4r6O8ytCSU4rqKxd/b4Rs+4O5c/8X2xHbuLXzN+/dsAgMfVMiBAPjaK4sQZT9tsFzI2lsaKOcv0", + "fF4pR6J1fob/GC7ksNwih4QlwT59PGhLAqmMFTxPR5rF3H9DoJKN4jS3F2E2rCZOXGvv9rTLG8udfDbk", + "3Wf07k9D3v3pB+Vox2Vul9Oc3DzGH8+FLWW2Ro11L2EC1VSeC9UQF/2H63vX+Joz9rWez/mWEfASUGTh", + "XEmeWvfe4Mk+FY2RDPS4uUaOZW5Wwhv1++Dm/OsePUQPc+OgG4+oKqR7Adn7RvXcsLa/Sjvz63u145bk", + "qyeE+7P31s5eT9/zwCaDT94mE7cyjvpiUgk1PBIPqSjUmy4C12P7iE8mD/J+WzChd8+U8SOQMFLTyqOm", + "TbqOLlfHw3pCAISNfOXpcuerFLoBXsZ6bOqL1Q9uivgRSPlgA4UpkrWPM62UyGyzOsjqi5A3eHgypzra", + "ZpvtTdpXnAUHawPWMrwAXjsVrBSmmsOt5/DwHbyCwAriqxUq778LpYYc7kds1wHd/rTzMykCiNhznEXW", + "oGMP2Hs8havSMZ8KZY8r5bYeYhtCOW8adFQ00n+Lkt3yM6FcTVMJIUHQHsP28Lkr17jQVDTIQ/O6OxrL", + "ZY6vcHOGuujJXMx1uXxByJgnay57QV68dtt2VbFx/RdHN7KNLo873+PyyAuCOnHKJMiI73SNdSxx7yS5", + "vx6vvR472WcuKe4nujzrrwT1iy7PYhH+guJAFloqcgS1Ll5MKoZYveyhxLLOp6UUk2IZ5L6XnAGiBCQm", + "0DcjsechyUBKei7QCt9SOhdjdibEAjqEX/be4HtYEpqsapWyugLIp0f4hMxBDoYVCrNEpYXIVsdtGFJt", + "uNeKTqXCsoUovaQGSCNdno2ZAHt3xstyCQMRMkBGB+uTWwwHzYKHD/UF0eeEhSwtDcEH4UDZa6XV1tOd", + "J95dOhdcmcZZ4SAiXdAzIBzBiEh4UUSqyIceGLC1d/C0cOOD0e1T82l385MbwwSgrqly13oXQFt0xwTu", + "j3rYJMgTLkW9TS+JjISy5dKBShHhwcsAJFXZTM/FvST3kvyHlM4oPy8rmgs93cQlGcOvwKekOvdrzfBO", + "v0sheSl9py9RDaKJ09K6LPoQxJC74X31ODqSzzNdFTndFNxtUio2l0Uhjci0QhvohtHOUtk//TQA8WUd", + "Yu2qUW6OXvtkZ2djWJpbuOvjrl8KEwUp+P66f4vXfVryTSXNOodJLFpqw+4AgdHrLLmCzPis5NdIXoTC", + "pMDtXnoAf5TnvBiDqHBSYoyvYokQfKeeyA0JjyF5D4OmJlR+uYltNuTbBF4iwrge5KXb8PLcC6WrCKWV", + "zqAVckkJe+Hvp5XtzfEnPFh8tZna7wrIti6pcNHDSypdrnxpDEEFvsuq8O7DBiJaEzOAfZxLi5oLZgyz", + "rBC8NEza7VQJja5g/OBmdmcvYG6AtMIELTDMdPfTGjAWn/sfc3By8+7dY3e1Bl9r2zZmazQG9RudPsHj", + "mD5qg/7znWd4qy4EPxcmficwOVrtpWUZV0pjDKIz35dyOrOQk/gimJPQQlWZJfoj4N8CWoiu8GOw4Zw4", + "kqdMqOWfgeVO6LIvbLjk+3HE5n/Ztv6/hBOsXDIIDiuHWmpwPe6upMDhrbTVDHCPuz2KDd5kweMq8hHd", + "28D/MJYTEgKXNZ2UYlIKMxOmX8rs0ysN3iWvozcvY8UMqxkk+g5k1f3Q751lVzfETRm2pYbTNO+gX/+H", + "JHZPi5cndxCPm7ns4Yv0IYtec+/7jnz3Lf8ono3utF3hEu87G3tc45xhZrOT+OwCrWqlMNblUFjvKHp4", + "GZ/+o5e+YVNlsygyB/R9XdWNt7zwj7YHCwDcibvH/TSwPHJC35GQ7Xtf972ve7CYJNa9pJT00mGFUhBS", + "OhaiNNIAI9SSLaR31IFA3nbgCs0c+B683upTq5wjuumCBnHn+mGnYqndRUKXcioVL6JuCjkRoI0MlUJh", + "HFc0vK55WeZivtBWqGyJ9fRvVnHxk4o0l1vNQnHd76mJTtopPZmsyUG5lsG4AoLdUbziuY8WGI1HM8Fz", + "QeUqD9A/tbUP188kbEgNAvftchL1Zif2ARhQVyq/4rR+vvmhvnald6820qdPb36kn9Wi1ECk/LQQ10M3", + "m5+CNzvFA1FCPXhUFq80sy4Ozw2NVmaCVYqfc1nAtlxh0D90vpcTpxuf8nBO6sr2n/G+KLB7sXYg+ntQ", + "Q0OFIGUMMBPsq3e4RYmeYCLwJR2JfbbZa15gLU4EpZwLO9M5m1eFlYuCvjBMn4vyopTW2TAPD9+5sDJs", + "sDL0ee2bqH2C3NTeTnjLheJpNhfcVKVoTC3vhzhO6g2H9N3dNV64AV7JeGFEA8PCL9a9S/B2XILCdlZ+", + "BYuLrBR2ACDJotT/EJl9YJj7ZJt90AHjF6M1EbvWPSaYgnTUk+tyUx5YcNDaoaUP4qs91GdCDdGh68/e", + "YWDQLXnhcZIbu99d8dHkgjfPqf/aglXYomXoGYx7/fF/RQv27UZv/s+GvPvsx7QSPB3y7tM/gJUAZYIj", + "z4g4g4hxvwyAf0iDPZAAOYVQdV2i2RIsonhwz3l5Jko4ozGsXZbG+vK6pFZ0BJIHP8Gsp55jOkzhpmAd", + "nDC45ft01OuAckF4Ygep9YOKiDULJ77y+aKgpaa54pmwL7CKNfyKxxa1lIvRi592fh6Pajv46IX77BiD", + "TI9L9+F4NBcGaiADRTnGmKHpFZ8jseIXoMo+30GHV+AcukZc9VqDPKP4XLDM3Y7Be+C5FDrccoxFA3FD", + "g6yIf1ba8ppzYOCx6T8xYbCsjck1Eco1QyVuKIPNszMBT+EPMZmIzMJkM77AoGJapu17SX2bVz0vU1NC", + "OtYCH/9G/1iDCLAvzvWZiAQGGlqBRvPKpWg6mUzgHxC6papFXwUrJ34PXNeb3438h8NwA5KFq34Xwu9e", + "P7obXBequK3guhVoBlp5WnxQqy9jZkQhMidoZYS8WKLUX3XTuhHO2rltPaUUtpTi/J5Z75n1OpnV4Yes", + "4tS+8CbKw62pEa7qVpci99eU0yXji4ULeOLonLyuy8p18fQNGBKxAwpkvXUsgmGipBEhfS9I7gXJNYZu", + "r9e14yCJ1QUewqvBhWIFnydP+v54hBXwdi0k5mTpqnoMYJDRVZmJCGJvg3JejYbwoqpLtvdmzDS+yIEx", + "LZ9u/bPiBag2eUDGnS+3/MdHozH9AAvxuPEAmmu8++L8CaDn9qSf4X/WFJrb1LI8vpwN+3YM0o3oistm", + "hZmIzq7NGH2PBXhpLMBoO4K0Cb+tQAEE9hkggOi1hLw5dA9unm6hp6shRdMk7ial9dJVYrP9ZviN5vDq", + "l3o7H/8G/xmabRyjs646WXCnD7Hhy+Ya07DuE41/Z4nGQBTXkWUM5HE7KcYb6OH3B42XPYfx9mwgfR7P", + "+deVEggJ3AF+pKQR8AX8m7CjPbsMk1Hv+dd7MXXnxdQ4UTejlBmzOlj7GlSCzjmH4t1T6AKk0SrAbl/s", + "N9PKhX4dx6jkIc8FNuO45FYkqgDfqDX0Pf8aC9Z7Qfq7EaQe3MgOEKhU3eJS9XLCx4k6OYFKwMfbKpoT", + "vqMyOQBrFX4aXiLnMAx9kCHCydx+AdWtMQWfjH0EyOfPe2/g4g//XlSnhcyCy3vvDXu4KP9x/Oh7VaX0", + "S3HV24tf0HuM/Vu7V9uIij1/1r+tvFe7lx7zQnJYid/wH/0VNl8D3CeTk9AnIaOQ0oPfMvFVGmtWctsu", + "9Yb/6eG8BbezmvG4e7P/pGwlFfrR+Q9v80z0neP09l0va9kIRA2YEcPCgjsGR78xJ92QAf+e6+qKisAF", + "tkNkXd5rsRm90R+r4nzxdXYAn/rsgojHU2EpgbcO+fSmYgObPUFHG+XepWA/YH4+quVOZvzeE30rTiRQ", + "veUNZEH8b7//edcYOVXw0UPzCBQ0Hkm6ShZ50n18G1RNI7s0VT+55oGIPB5KMmOeTxl3794zzd1mGk/2", + "q5mmeUj85v+5JrAxBG7599ceDaHdS1ibwqfD6x3VOiJfJeXvFf+rS+Nhmv+a4kThUo4C2Ti0xF7qijX6", + "ayKt8Q+TVjXkAgDl617hUm5qGYvvVhJiEKiVey/2Hbpt15sy+M4NrGGz2RADmYcy7WO+T9DQjUj269ew", + "/OhoThtpVzsDThYfH/djF3n9kaPIVp9CK9Sbx8RDj3/D/yaLHHT8cA328/jmQ04mEsWvqKdLlS7Y7Khy", + "c7rtMgdZVRr0Of1IdQ5SZQ6oV/f4Ms7EXJYiwzkMzVgDqngTvuptuBDnotik0Xf4QWJpDyhEccjugxmo", + "Z20p0HGjWVLHt2QJRZ6DXgdbQ9P6UMTy99fX24mmSAnbq8p4qme1iZSXaqIvI+UPqKfvJef3VC6+euYO", + "EC1hLXtZPaDNRwdrUg7pqfk4mRjRI1g3rh7zuxH9l5bQtyYOe3Hj1orBe9n3PWSf8aJkQ+k3kQX8NONm", + "9m2lyOOKVYtC85wVUp154wsvGbTAgAC5VJH84EtBz4bqv7/Au3/hZnZVeZhw0M6o2aH+WRiFl4s4Bfaw", + "0BeizLgRbCa+soO/7G49ff6nRzhUa0UJX/3333e2fuZbky+//emnb/82yKv75GaYF5byM25WH6RtvJUX", + "M1Eicrj7EZnZbey9zf6uMz6yn9u5z/vvNpcA3um7JnkBXb2Xsbg639h1GvRvML7okE+vGoAd+1LuSnbj", + "PfukjaRJh9eQiKQOCz3Gsr29jOSjB4FEam01l8ZKlVlirxCT5wcHauyMnwvGLSsEN9bV+gVYe+T+OCrx", + "pzgq0bWQa0Gw9Rj1BLF9p6LQaooxiFxpqgUs+Hz7SG3Azq9xqt+TpweyMo30ktd6PqVSzPdMfAfLiFfK", + "Xt5tTQzrIgFXxhIaYCrkEo4E0WbRGTd3jTnf+gDHmzQqWD79X3ilvS1OplkN5mSs+14z8g+JSHDP7j0B", + "jbChG3M7HuarFV3T4M8Hhk7l9aewA0MO7vC5NpaVIhPKutcoHmoOGzJmztkvcsRVpk7wW87OxNIIy8hH", + "8p3kx59poW5cfuyGNRmc8G/5lEa3+RevcUk3+uRA8DKbbfaJLu2tiUTq8hLKTcRHzLHFvXz8Xd1p/LZu", + "LCV/s3z67XEkrgYIzI6IAy1JKxpIS2EaA26TMJbQZsck9xpSj9WxUN9JAB7GsukWBOHG8nIzYRZ9d4vB", + "Zc1FvPwNLCbFeyH1+xJSvMFlCUlVKWOhqMhjDk0/zorKWFEOk0lTCe+KnPmvardlbX/BZPs6Wt1q1OS2", + "2QcBmlnppA/3bYBKCFGKBDhX6IwX/pEvnssTXSOiq3tOmPTdbE9cPBj/az/JjtxZ5/oME6WM76pUmzs8", + "n2/g73wyxEP7IQxvDiGB4CCKx2nO5KJnlPpGPcevuRFbUhmhjERMZVOdkqOGBso0HTZ+Cz3GllA51jDp", + "GbQhnXENFFZrKLqo5gpWQ5c5Ah32Na5L+2qZXpFRNDCflh/9hC2MMUOYjHdfklhjfb1+hIH1dMxNFvVJ", + "f8EEu12AXRXe2zrnJTSO7N4h/APf3y421f/8DXZysz5x1yn0v+oMA3GAKd1JOvc1t2tWBY9K572bPN+u", + "cLZ0T4SU+E/I+nr+hqEAj/Pz8e8va+oXRKKXXcy0Ec2S+1HR9LnOCeauzqmXhpW6gjqHuwgW6hvCQBd3", + "GmDGAbS0KLWlsDrmFBBQP3EUBDfqv+ZTLlV9lBgQCyfu4bHMT3CzuXKgwnhANIbMXdXapztPolYI6NQ1", + "M3Zz9YP7VI9Ngj2SWzydpAdIfck4y+VkIrD2UqM7LHrLFeOVnTFdTrmS//LjIPXYz6sywozDiYc1dWF0", + "EXS9nySdb9T+sYfHh3K8TKpzXshQ0S9qbWdYa66BntORaMJx5E1l22FH1AX1952y7dwY3gjLZZEs2+c2", + "zlWc2L5Z7Xg4OOotS5oAyh8YtF/YrFApH//m/jUoqS2WS3yC/++g8RrXYF4CE1tXGmJP1RLDllwZnhGL", + "Gj2xW7lrGFh7SSUt6jtzqOla53SrnC041mv1+KHhpabmAkwNVkuq3SZL5rAUxthGeAYTEOpclhoHz0qB", + "8iQTxhXGXpTCQLk/NW28B41QIMJMgjhagrhtrQQrBYCIkGYeRC58WQh+TgOLGzWsUlZXsGw0SqPprp8S", + "183ZJjTzB4YpWQCCiTRuJAJ9M4tauOv5gtL/Qg+YrSFy0yOLiA5iWbQu49Dzq0801GWoUM5PjVD2j8rB", + "IU+0cVuypkkRK3WIlR73SIXw5y2VOvIKm7TxFRBuhOO110RpE1pdg2sNUKa07btkRKvhNpkmsT8LW9PX", + "yqvgJ5iIkf8SNeTY/FTkuZ8OzrTnToEvvLvFCyEFBF92pNcaTnwLFwc6vyHTkkBee+4OjiLuSrTdbZ/h", + "64/uTY2w4TRHa2eU1hiv/K9U0hTKA/gigQtRWikMnXbKetTEU50vt9mJv1CTlh/+PCzMCctmXE2FC6bU", + "ZTYTXq2F034ykRnSPJ3veEC2LAxTDYfyiTvOP5X66/KNnnOpfNskPBww1+f9dyByqDn3DUkcOjJPQOX/", + "WE738vrzmb5o9Aiv0C0FAc52cZokJZX2q7GM1XhQ89v3Bl/8tXvHiG4TzXMcfobPes5zUqmakjK8iod4", + "BpaSnA57lKH4s7bcRlfAk0+fD9kQhe8xNnHSI4cpifBmrx2u9ctmoN7OjeMwJp2Q13pnIoTvroYTihlc", + "3x1lAOa4CQB/TdUl1pbXmqE9NPmGpmjq9W7aocPYvp/t+VoMvu7ivxtbfOPfsI3rM/PCFK7TzouUtcbW", + "23znFu290PEmNt+VXPYH1eoodSC+7LhFuhElb7Dc9HgkV9Inq/4SVk7sQjcM7TMoBbkDd26YKRalOJe6", + "ctdAZqxeGHahyzO0SlimVSaoMLiurFjhjkyL8X3UhzxF47xvVHvBLqjTKwPv4YI4hW77D8pAtJTd7d5Q", + "fQiI3I9/C5WKfNbzAAUCX2xH9yTSFDRAMpGBEzt5YI5UMElWCs45FxO0zaLIELxu6AolBXpb4FYk5wKN", + "p4WY2COlK3Av+HajD0LznjMUGGbEnDxunKmqKI7UiX+tjvI5eRn5h+owIqq+GyK+o8kcKQoW7wkk+uxW", + "HPfzwK/3gV/tVx6JZzOZE3Yrkbr9Ubn69h4Miy6qRrhEUBcANgbT5pxvGQHtot3z41xakEn4MV0f8V0Q", + "IuLrosDCzBNeGNGLrG8rChJtaAqDsqziBcJVOYha66RdjUfGLgv4ARSuxCoA1CD5ytpmdwqz6LMkYfxw", + "Wsmhf6FG906oqZ3F+mW/Dz+gcnjuqAdE5KydapXUNjtq16o1JF2oiQKyTh93RHLHA0PqUd6Wan6TqmSH", + "1t9Jk6ymuFurkSBx2r6eB6Yrg38H+FGXVinDoYQnEa/Pm+7SXf2AhGlYXaIncBVyrMHAr5AREDazf2z+", + "kuD/PlIUWkBHJXnKkKzhyAQnYdwgK4Wp5sKDL8MBTClHR+qwQUP8TPiAOBdkgO89MOxMqnxM2e1LY8V8", + "C82gujxSczEHP96R2nWxCo3oWz8CyHxSOnQ1RjdKd5bSHCnn8sJghFql8AFzjUsTjz4NK3GkGksBhzsG", + "KPghNdqjXdAYH+EdbNiGq1ASFiqJ6DvoJN93NHGFA/3LDYYvxDLHDfU7mRT7h2Oqwo2me6mOtvOiVyT6", + "3fSUgR/9iLbIOyxu3/MzuH7QfuDtNWahPul7FaELCVHnUlysSKPmuWl0SxVMOiQybmRhYagECg5KPwgS", + "ZQvikGk6TpQKlnPLT7kRzr0ArppMR8JWHCm4qi9EvuWFYaGnKN1CG2E8PXLThjYSSQ5KSLyAnCl90bhT", + "Ja5BRyp1D6qKgnXvPfnJmJ0U3NhPsBzoxDpSJ/DIWGTPk8vdbz76XbuqQLwFMRTG2iN8gistvPeHAkC5", + "jJg4aC/ZIAFAde5OuTL9utUrrsDPBKrBk50db0Akw9iYcXOkkj6+Vgm9U65O8JI/ZuJrJhaW9Ay8+x4p", + "eAtUbK7qiEp2Kia6BIFBrlqQbp7q8Xp5JouCYnhITTxSGVeZgB/HITAEXiJThHuItGt8/C/NxsygPbSM", + "yLk4UqdVPhV2m31Uwnc94bKoyshOAZIDe0BXrHnpFTzcWWZ0ac2Roqu9UzJcfAWTymqYqoJxQlMTXSmc", + "B3TiPapggjxSwHpSVcJgPR2Q/rwoIIBJmkwrJbK0OQRp5RVXdVHbG1JzsINXXH1P3aYewyqFRlcWDpDI", + "/9/clj/obe4VV90yvOsEBlkDeiWGs1siawW7goPxwlh0F9DhNgAjHlwWItnokeXwDgTWCcT/GIeItLJS", + "GLfgDwl8TGc2cB0IjqV/6UgFkQHHNlxEWC7MQloqw/jp48HhixBcwjJelhIDS6OSa2DFOlJWawZpjQ5+", + "CVeAkSlq0DUGifR/OSvKjbIjucy+Lzv2WVmSKRruRFmdnxGVvP6DWlzWOe56udWfwWthkTh2UkMoeA6D", + "7c2rArah4KfCn6fei7ZnGS+MDlkVxCF0wOHpXGiCAYEk4LWabVT5dl3IA7zF9t54G2UTbTDUYezHGwxm", + "yqqS+S0XgAtz7WOTGz+Tfh967yFFuV+eK0AzXZVs8LoQvKzDeEhL3WZ7uZgvtMWQ8XTEmjol/Ws0vBQO", + "KIekXRL33O//+rAuWGYnuYZEM9y6BEmGKbzn5VlNU0C/TlwajZJ399MeAjLQLSMKEZVqinHx6kjRzSaS", + "0yK+55ioJgxdKJqXK4y+fwGGC3+zsRovSyCxqQkmjfPGUl0Bd8EBQx/0429CR6pSucYo+79C5QE1jYaB", + "f9IkKEWHTeRXkZM7jq5ZpNlxsMWIBcsqBI0ubaN3bsLd6BUn9Y+rYFl2awdLeaRKTCkx4fIXDaa+WLGe", + "e9WR2uBiNbqN42HtvcZLjXuJscGNp1derD8uamVoi5QhvAetjUWid8nogT/HJ4oSFxETaxXU3iOldA53", + "l3f0OSWz5RWRFdgPzoRY1Ner0limM7IQU8kIhFJIXVCqXrXrIMyQer0TatgNXpg68/1et6b0QLos75Vw", + "wy5Kaa1Q91y/Po6LmJHxli2xe7kZKhVaZbF7b1e/SJU3Qe2Mi5fZe8PEPyteGHZCkBUnzjvLLdMXivFQ", + "LhveggPavwfHMdhFgcnMgmdiHPLqZAnf+iszna1F4Z64sW6zNy4Bsh6SD/ViGOlFZw79ipExZFbxr7O9", + "N2TwVOIr5fCFuDg8tutiRCdxCbpBro12BfB14uftV57ZeGSU1UnlllfCg/SLpLWBRz9IBcLh8WCNguRU", + "mv/y8NuR1aauSH1tZQl/F+AchGvYqg8uLgXTsZvnppYVdWRmEA7NUsohjCX0XQqjC0gBP12S8IEvW4ly", + "pDtTFxNdFN4pWlaFoGhU3xp2G9dqKIS1ojRjlsuptJBet+Vy945PHnn1XGnrxByPeXlD9LlOVAoNWBoM", + "wlEDLbUd+XOD6kfEdd8V6qI7nD7tw5EZEmp+n3o2gNd38zym6n4+3dSO1VJBHv+G/1iDnrEv5vpcrJYY", + "CNfj/8hrLqLYLvg+dxg7ITgtxVukZazkrl0a8cZRC26mo9sw0kZM4fSm9bzhVumPmjWBs79ZonfBQysi", + "F95j4GU0CK1ChC/8ABdPzGp2cY2+6ascOtLGMY+80/hmR9AbP8cbPINcH77P738KtQbUb/gK0a0YpNhd", + "6/ujaeDR1F64K/NkA9R41WF0gOl2EYueCrg3DGbUJiFYI4qJP6cIcGFtAQj39jBOXXWgeV69zjrbw9xG", + "8UwwSEGUifn8Ho+XTQi3F4GEkAE8MFZ4QqG1Haq4NDmly7PfHi3dzvHxXdEzNjk+OqRzcffgNL4XRMa1", + "nQeF1mfVYkXgiTM8nKCJ7oRxM2ZSkcXxRYh633vDHnL2+fPemzGZlurs/lq1m9RZKORREcZG2VrjAKkz", + "4UVxyrOzR+OmqYFgOpt2DPbwJCiqdOU4CWiefQrto1pENEYYwmra5llpw3i9vzZtng2xohuZUd/RHqyx", + "or5yKz3uLEljQXpMqv+MAtsuY1G9tUucW4z11kwkzFRN3T8ehITWZ6xaML65OBic3+4ja/D9ZHkKrpjG", + "73jhwkjBWnmaotoG0RKbIkDm0qVlb7MTcFtQ/YaTKBQA/bRYDHC6zX7RJXv79NUD5FeWFRIW+AWTls35", + "0gONaYzE5ouF4GWQBUpbmYk1PHrJdHRXR/xjWR9vA4uPU5K3MIM/GF7fh1739TBukpdfuYGZS5QTrCs+", + "OSl7Z0pZ3Jen6ES6uj2KBIwXKmkZ89h48h5S+9O/XKNoROKnRiidynOh2N4b8xL+D16uq9mYB/71puP0", + "VsRG4OVLig9zG1zqB7k5p8bF1IW5Z9M7x6avmhs0mEl/c/Q3JBS9kcJfx6XDX+RhdKDB9cX8VljvFc3g", + "spx3C4y3pyZ6U17LEW/yDh2J99WdLs+XbjMHsOWcKz4Vc6HsPQb/PQb/phj87wP1XB6IX5rfGfD+1RD2", + "t68fdTsVmbwbBhHVSZuJssaup1BijNIfWqpnMgFaouZcgD76R6PqSsnCPWhng8XoYldXzjJPy0Q432N2", + "+O6AGWEpF8Iz/QKgulmOWN3YmkPpUzmGSFMbLvchMYtm+R5fZ6wfTZszX3TnSiV66jeusU5PzZd+O24W", + "N7vuz/WzHw3zqiCUrxuE6tZKBmz4373Y8FtYC47tdVa3Naf6Y0/+NwTAmukyd4kOEWCB9IeWy1UIhzJl", + "i7q38CuvAbSqdGD+q8OEiB45ry/IngmqAXRKx2/MuFkpuZD7o9/dVUEqNinkdGYRv1Ha0LsuY3R8KIs+", + "Zgj1wE6FvRBCAXJEJgJE/jjZe103LYwjhGZmjTo1tCw+6jKEYdF0Yf3qVklNUNoh5nAF7StxUSx74cdB", + "IkUqioO9aU25obBE6P9jV2uh3ukHxgWFuwx6Z1BlEwyDl3bsYMH8+FHWeQFXj+PY/+SpZpsdOE2k9rpm", + "HS0i0mZihIGgxAzVilYKVWwzIPU7Zhrqrk+voi57JnQL8u1aDoG3cFqtK1iwlhG3b1aUwmoTM/F4qSnm", + "xAHkXYN4NbbUy61S8FwqYfpNkq9BdJgG1O3glUKSmRNrckXYNcDyFd1vpGEC8yKCnHV8zSnwM660hPKM", + "xK2+UA57IbOtOkpluFeFokoRPA5YXOqX8aoS3s41pTQDDAANzcnMU5EhJFjqYGheBu1MzLfZQf1TuGXV", + "wXiIA1L7Xg2ZO0J+Z1dUHM6kcZAgoQ2S/KUwuiozmjYAhAtlGUytbGIwR34mj5u8SnIEkYEEsh/oY4jo", + "2LWEpdbe6FqO/7EkxUr6jwqDRRZ7/5ssI1KdVwZW9lzABQY+dAee4+IWVd6ofEJxEB39OAAWxMj2TYL1", + "rxNq7jQf5l7Ze1NXRXIfuow3n6zco4uANiGzGXzJLvgStuOC12+DRcWzv29XGqd6RS8px+INalLaf7PS", + "lBEVvvjk53yDFtuOcAid9jCIn0N/NZm7myO1HlI4ObuVN5+b4AA/ise/uX+tsYXWaA7u/UClaBQk+JvI", + "/CitiaoQ1RFKJiurU3ocjCJiziWmfr55++7t4ds3wWxkimoKv7uuto6qnZ1nWY1bhX8Lx1EN0yfTRU6f", + "w92hFJUR43DpgqYJd8vM5IJkpkejaFloY+9L68yna4hQ/6yED6ywgpc5qAnOb9OC8UI7bFEw6WR5bRf2", + "ZTpoYqW+YCUsigJEL7iFXfAyb65+lJUCK0RHQL2/mDUtTPuuANeXqDL0T84sDK94a7SxYlHDF0a6vJVz", + "gZ6mUmzhfhv39Zbb02h4Y5YRpAxPEIHP6GZGIryiX2tI9o22Zez2o0c/cxWIfCP9e4H2uPWWXSeUBikq", + "n2rBHHMBEYvrVho/nt9NXZH+RM+aZWpcuUGSLIGmEOTRNaHS9G3754URpY23/SbNhq4f6vQ7hQ53RpM6", + "gN96e3aQRiLTKkNgGqCh60yFGTQg9+iW6o/fyYyXdUXJdVnv0moG3EQd8Khht8+yaXNrbEOIVGMCBdpm", + "uxGClFbO9mZqlD73yYMIeQqEtjtxCDrzXBqplTPsBl3/lFO10MJoh7UbDeFB4pjvwagKRV55dgalcFTu", + "/bK2lMH3Gk/PWL70M3TJqEsXLzJ3KgKpDi6aNMzgQirzAgNKCyyIVLIAqFO/BJeUDA56kYcwEbQOwGQs", + "L6cCR2AhVTZVoSHahLk0WJ9Vl7GNqU/07i4WxdLx9Suubkv4borh+1MSKJqWBBcPhtassG6qhSiNyP8A", + "hz5uYi1tHLQ10cuVJQ/olz+A7PEG/lNZFDAxBF7z95FQqxgGjDaO4GqQlhXCRvUFyAON9/q7z7G4ObfF", + "s9DZlbkWGrnn216+rZfnypzrrntDQ6yul0rfYPyVo5xNQnUOY0Cf6Kba9lH9fjVJWrr0fR2LjdyRe934", + "WmKDXCmt2GnSoT5nUG2uhwsmK3iwmsuclM4iXjHvi33JSng5Q7KKgm98Y6H1bszNtUtw7PISvBGHsbXs", + "sYEi7q9ktXjFNYoYCa2713Ulw8KJ5vtoRoMMKe9ogLekHbjeLqsXvJ1MBDmBaV0xiNcsVTYrtZL/+gMo", + "A/vBbCDaa0FBS9dFuO6a/fi3ygSl4BbPjETbNJAbuTXsooJpmK1v5rkw0IeL6csoClWrWqDTAl3jDWCg", + "Nv8e+70thqXesP+rKvXvg6vAr6Ffnx9Cvb8TZxVeBYAKz0UJ5CXyFj1GS3tlEeDimc3duNdHuNU+IyDM", + "3Y+U5TqryGXl9a+YEYG1S4rNsDPhI6/9G1QBG11UvjleCg+ats0+IpcjynyHzQ0lS8TNhqFUKqD+vCWP", + "XUh6Aj1Q4m8ucDpgvmScECUQ5fJ6FcsD4Zn7wG/wLQkT399VJcmn9rbDPt0bCZpGgrA4gb7XyYN05U2K", + "Bx0UY+Pi7qhuZAgkZWWlWmWPx0yqrKhyINqyUi4yewYc5PdOqNwnGHlbHoYBaCWtLjHNotBTstxjLJzB", + "8pykEVqosVAKy6VaAbbF5/7OuGKoK4sDdStekv3xrta7dMN0g9wIPrmuL03f3udk9rDpZTIwk1UzS09K", + "nmkDf7YZt1UNor5zDuXY+i7ho0zdpcLnC25F5V7wyKQQdshhBnZlWCLc4Qitr6kV1XUI189NgcT4/KaZ", + "hWrGwfA2RwsIAsbtxT27XCe7jK9Sl6vwFBfOQnh3NUcRqsBajoqdTs0SOFHJOX+mLR0sq/v5xjmNoC/u", + "LKfR8K7AaRyfOgCIe4a7OwzX3Jh1fOdR+lxBjMEwXeFLZvWU2DCk9EZwrYvqtJBZF7XV+4AzXpZLdiI9", + "2uULZstKnDjALxrUmHEGKvWpLKRdeuQvSoUvLSLltVoPSHmFpNq+2kX/a4XIhrnj9hByTlkB2lD2C+KE", + "cVWnDbhh/kuUGiQLVnWvDJ8KNpECwfriWikxchmrVAG7cQJDPWEGwlWw3QtpxMsBIGQ4NGlIDlHKcDN1", + "mlq+ceSTACV44CunXA6K1H//bbzBJ7q0G33wCaluo08GA52FL24D68yvOi3aZaW1G/DvoHLujwDA0qrq", + "ksZgGY++bvGF3IIwt8XoxaigYsnj0ePzp7VhYKU4xlD5+tUE7/7t6UH0eCX053thOd7nqag1Bu1Y7WVt", + "dCGFsi5ie7rNjtBB8B/8NIMsg6d/4ovFfyxKnR+NHm2zt+ArPxNLlF7nvKh8ltWpYJ/33zGhMp2T2SwF", + "JTp3oxnFpsyE16JdZAsHWw/0lGy3PkkMzf6wEuLrotC5GL2Y8MKI9BDw5dF40zpKbsEPrMMKbdZPGo+M", + "XRbwAxyPo+4UQNKxXJbOWA9wlXH8E+YYhPPOUOqHydjD+Mh51LeqiKjbmNKqmXyEt9/4oaTWm9TwaL1x", + "jCJn3Mbp8dLgsI3l80Xf0NyXmMsxStqvc27FFrST9l+tpwSeLA/WNyD/7joK/D3VAHuHypKj4MsX/wKx", + "1In4vZ7aX+PRf20dasuLrX3qYO3H+LZ/+UZrh92fgM1Uvui8OH/6KG1WS5+CfTXOXDB/HROKcVexirPN", + "duFMXBor5oheUSkf7h4pzfSxNAxXNuW8gWIsGxyeHz0oMRoUTKYXIsfTj3LrbLmMeKHOEmefjWBPQIg/", + "ff6c1bXSdg9e7+0dqU7JNF2y2XIxE8qwh3zrX2O2s/XzmG09GoOHa4ZZ/VErAJW+zX7FejS+Tnm2pLQr", + "0EHy8ZEKIX0+wh6jsZYNEDC6R1IWo86XAR2qFFYoXNqFKKVGg4qf2pHyBaXhqJWZtMWSZQU3Rk4klXI2", + "fII16XB52MODma6KfGsf/qI74CNol4JO2KQUZnakuIWNtq0LkFcz6i0CVALnt/WfZFyhswFhH/AUPVJv", + "QriZt/rUTThxRjV9WkhM0XIeuy+P59LgYm4fKQR32lqUeloKY0LbNbbT6halOvbfvmRcsUqdKX2hjpSu", + "bKbnom7o6dOVDbn3j10DmAdhRNhqh8ggvoqssqKBlEIZgUdqv/2qFSqvN36b7U385viFflBPOBc8L6QC", + "c0BlmJdrR2ohSgMnjcp89W92AZuPSZXuzkKpG44yqbex88KKc6krQ5N29cELvhSAh78bAHmAJsTXhSzB", + "0iBp+0mD4lhoOfDgkfIKAB0ZtQawVy/l1l/FsqEIzPlXD2T/9PnzcQvYfgFrUUKb//13vvWvna2ft778", + "z3+7vaLGH8SFE11/e3rbxZuC9pDOXPcyEDL6Q4JqpEVEV9SbxZl4xYOtt6maxIJonXZB79KrTrfY2Kx5", + "s9P8RZenMs+FutZJ/nTzA//gy1xc68BvCcCkJTpCyLIDUIwDnb2wfDjwfHkUYKLC2a1LCbeFIrTVcbI7", + "0mNLYb05EQYiFYEqfl0g3lX93oVUub5gD9efUI9e0gXPd33BTXyq5HSUXOcePn16O3t4ieUNYJ6dBQ1H", + "IXy74MaQh0oaf7qzh8MO8e+w3rfBM1qzOWRuumm1bos4nC2yDXQuBajgOiBIUhFUhYF5egL6vca665pd", + "8BrWJ2jkkc6zjWYhDkrv6MWznVbVGjmv5qMXO+EEl8qKqSjxenal5X1+G2fdgSgBHAcp7BpJ4/nOs9sZ", + "u8wEqxQ/5xJzCK91Cj/dhqqRnYHeDLcOXV2fuvFDmgbcHd7rgf2mgY4tvBEkl2mlRGb7y74GBDjXkQe3", + "hytLywpAyOF4TbiAOLZTjMqp5hAjcHj4Ljjf6PqDv0Z3JbwTwyvOBoB3Nu0CW92We/cnSqJnOzteMMWR", + "pt1LoRvisYd0OZ6iJsCngIxZKXe4QBBRHaPaAEGHoET3LR4UWP7cJdHDOTV1lz2h6oOEWs294zG+FeYy", + "x1e4OUMjwMlczDXc1tGKfrLWihJi9l67zbtq0N7135zcyBq3p283Hx845Lbk4zRLb8scf697m2OOvnvb", + "D5M0cDMG23Aurnv32ag+gNa9+9MPagh2/HRlcQ+Rx72+0D+LugN8cbUnNIihd/TupWVQ13lneUlIYt7d", + "5WObYVgUc23wDKczxvlLpGJzWRTSHQo9DqmMog2SvjGp7J9+Go3XaKpdxLqv8HakL68aZs+wMLqvMSp3", + "1o1ePNnZ2Rk3BvnsKQySuvXPNxtz8EcOWdmeIQf36mBXKFDKSk/oe5oEjIYV4lwUzrJdlWqbwdfsVBT6", + "gu5u9AJH4zgE5fevLby4ySDf4QeJ8b3mRmwZoYzEoGNTnZINkm65TCsc+VwYjGnyB0p6VMbH//SYQ/90", + "u5U9HTvDIv/t6eUCZBrC4yYPp3sPYTvmHtl3/alQx9KsDYipX00eA4fR41SOXScMAKNxm/It7ncP0Q0m", + "kgSoj48cg4cLVGxwwqGlx4ZQyBqdkz1clP84fnQpEIcfKrAgqlN6hZiCeGevIZbg231JwTta+dNtc1su", + "hAdroufCe49/8/8M+fQrav+zKOQnUaM/Eh13uyD/nSjC3x5E/7F8OBPJ8vu3d728579W7f+wHf0MuJrX", + "kqU+03a6Awpr9FX7t9mvrtB3y4c2dn5+E6Lk0aqvy7OoDI8rvccN1eKFn8Duj8E3acgHMlElOPtqhT5j", + "Nh8PLwu6/tXINQQxCTctQ165ouGlHRpJ8DSNHVbvjIv0/H04+m926C3A1uv239wHINwHINwHINwHIPwQ", + "AQibqGf33vTv4U3/Me1QpH56hZfUlEurvaXAWNgtoc7zfpX3jSjluTAuErVV4t4N5Jf9j+8bv7i0zgD1", + "wvPlkcJvsXpm5sNZZtpADG5WlSjdYSTsVCpeLskkjahO+KZWALR+hg6II3W6pB+9rHHa+MFCZIY9zBbV", + "mJG791HwC2P+DNqxpZqJUlqRH6kQku9gLVw7MQZGPWur2UIXBTuXHJ/4UsFuZi70HL0/ofSvSeWp9qrx", + "+7Qjb2FDrnxX7yq616psR2Ndd2F2hOaW8YIHeXyrbtmbScv/nd+x9wVtWpSOFtIZYq5dJYCeNQ3ia7Jl", + "gN9CgkyadZ6tMIvfwRupM2r97dkGd9JrZlUcgGdTP5C+e+8gBr0j1+BOtuOp1oXgyh3xd/Tiu3bUd+eq", + "u3aot3BHfO3ug1cb6W3chD6rRamBXbB6xLVQ8H1E84YRzWsW9I7dutaO9i7es1YO+kcO9I18Cc9WXqp0", + "Uc2H+ff5nPm3Uy7+8Ojm/drU18ZebQdK1JnNvePqio7jBmV4SvO/XDbZnNTn0HRagY6I7kbyOT2l3W4y", + "J/W6q/IoZGIFXfuEzu6a3btvb1XkxsTaYYNY3D7+jf6xpgjRG1+5dBUf0EuOE/7mmt34OunHkzK5JJCp", + "G/QXSs12ae8+oO+Gac+RyDraG/eHcEefMqkmesXhfiPUtfO9xCYBMpzfE+53IdzDddISZwWXD6KwqixG", + "L0YzaxfmxePHfCG3xdPTbb5YIE25739rw0gZDO5wP9YBrtGPiM4Z/72QW1CDNf4NW4/+rhXHum2RlcIa", + "KGz//x8A", } // decodeSpec returns the embedded OpenAPI spec as raw JSON bytes, diff --git a/packages/api/internal/handlers/template_refresh_envd.go b/packages/api/internal/handlers/template_refresh_envd.go new file mode 100644 index 0000000000..85470efd8b --- /dev/null +++ b/packages/api/internal/handlers/template_refresh_envd.go @@ -0,0 +1,271 @@ +package handlers + +import ( + "context" + "encoding/json" + "fmt" + "net/http" + + "github.com/gin-gonic/gin" + "github.com/google/uuid" + + "github.com/e2b-dev/infra/packages/api/internal/api" + "github.com/e2b-dev/infra/packages/api/internal/template" + "github.com/e2b-dev/infra/packages/db/pkg/types" + "github.com/e2b-dev/infra/packages/db/queries" + "github.com/e2b-dev/infra/packages/shared/pkg/clusters" + "github.com/e2b-dev/infra/packages/shared/pkg/featureflags" + "github.com/e2b-dev/infra/packages/shared/pkg/logger" + "github.com/e2b-dev/infra/packages/shared/pkg/telemetry" + "github.com/e2b-dev/infra/packages/shared/pkg/templates" +) + +// refreshEnvdPlan is the decision derived from a source template's latest ready +// build: what to register and build so the host envd replaces the baked-in one. +type refreshEnvdPlan struct { + // Steps is the single trivial RUN step. A FROM TEMPLATE base layer is always + // cached, so this step gets UpdateEnvd=true and the swap is guaranteed rather + // than left to finalize (see phases/steps/builder.go). + Steps []api.TemplateStep + // FromTemplate is the source the derived build bases on: the template itself, + // resolved to its latest READY build, so the old layer is reused. + FromTemplate string + // CPU and RAM are inherited from the source build so the refresh does not + // silently drop specs to the RegisterBuild defaults (2 vCPU / 1024 MiB). + CPU int32 + RAM int32 + // Alias, when set, keeps the same name pointing at the new build (in-place). + Alias *string + // FromEnvdVersion is the source build's envd version, echoed back to the caller. + FromEnvdVersion string +} + +// buildRefreshEnvdPlan validates the source build and derives the refresh plan. +// Pure (no I/O) so the decisions are unit-tested without a DB. Returns an +// *api.APIError for the caller to surface. Cross-team access is NOT enforced +// here -- it is enforced upstream by GetTeamTemplate's team-scoped query, which +// returns no row (-> 404) for a template the key's team does not own. +func buildRefreshEnvdPlan(templateID string, src queries.GetTeamTemplateRow) (refreshEnvdPlan, *api.APIError) { + if src.BuildStatus != types.BuildStatusGroupReady { + return refreshEnvdPlan{}, &api.APIError{ + Code: http.StatusBadRequest, + ClientMsg: "Template has no ready build to refresh from", + Err: fmt.Errorf("template '%s' build status is %s", templateID, src.BuildStatus), + } + } + if src.BuildVcpu == 0 || src.BuildRamMb == 0 { + return refreshEnvdPlan{}, &api.APIError{ + Code: http.StatusBadRequest, + ClientMsg: fmt.Sprintf("Source build has no usable specs (cpu=%d ram=%d)", src.BuildVcpu, src.BuildRamMb), + Err: fmt.Errorf("source build missing specs: cpu=%d ram=%d", src.BuildVcpu, src.BuildRamMb), + } + } + + fromEnvdVersion := "unknown" + if src.BuildEnvdVersion != nil { + fromEnvdVersion = *src.BuildEnvdVersion + } + + var alias *string + if len(src.Aliases) > 0 { + alias = &src.Aliases[0] + } + + return refreshEnvdPlan{ + Steps: []api.TemplateStep{{Type: "RUN", Args: new([]string{"true"})}}, + FromTemplate: templateID, + CPU: int32(src.BuildVcpu), + RAM: int32(src.BuildRamMb), + Alias: alias, + FromEnvdVersion: fromEnvdVersion, + }, nil +} + +// PostV2TemplatesTemplateIDRefreshEnvd rebuilds a template with the host's current +// envd. It derives a new build FROM the template's own latest ready build, which +// keeps the base layer cached so only a trivial RUN step plus finalize run -- and +// a cached source layer is exactly what drives UpdateEnvd=true in the step phase +// (see packages/orchestrator/pkg/template/build/phases/steps/builder.go), so the +// host envd binary replaces the one baked into the original build. +// +// Caveat: the step phase gates the swap on UpdateEnvd = sourceLayer.Cached && +// !guestTemplate.KeepGuestEnvd (steps/builder.go). A template built with +// KeepGuestEnvd keeps its baked envd even through this endpoint, so the refresh +// is a no-op for it; that is intended (the template opted out of envd swaps). +// Specs and the +// alias are inherited from the source, in-place: the new build supersedes the +// default tag under the SAME templateID. +func (a *APIStore) PostV2TemplatesTemplateIDRefreshEnvd(c *gin.Context, templateID api.TemplateID) { + ctx := c.Request.Context() + + telemetry.ReportEvent(ctx, "started envd refresh build") + + team, apiErr := a.GetTeam(ctx, c, nil) + if apiErr != nil { + a.sendAPIStoreError(c, apiErr.Code, apiErr.ClientMsg) + telemetry.ReportCriticalError(ctx, "error when getting team", apiErr.Err) + + return + } + + ctx = featureflags.AddToContext(ctx, featureflags.TemplateContext(templateID)) + telemetry.SetAttributes(ctx, + telemetry.WithTeamID(team.ID.String()), + telemetry.WithTemplateID(templateID), + ) + + // Team-scoped: the query filters on team_id and source='template', so another + // team's template returns no row and 404s here. + src, err := a.sqlcDB.GetTeamTemplate(ctx, queries.GetTeamTemplateParams{ + ID: templateID, + TeamID: team.ID, + }) + if err != nil { + a.sendAPIStoreError(c, http.StatusNotFound, fmt.Sprintf("Template '%s' not found", templateID)) + telemetry.ReportErrorByCode(ctx, http.StatusNotFound, "template not found", err, telemetry.WithTemplateID(templateID)) + + return + } + + plan, apiErr := buildRefreshEnvdPlan(templateID, src) + if apiErr != nil { + a.sendAPIStoreError(c, apiErr.Code, apiErr.ClientMsg) + telemetry.ReportErrorByCode(ctx, apiErr.Code, "refresh plan rejected", apiErr.Err, telemetry.WithTemplateID(templateID)) + + return + } + + firecrackerVersion := a.featureFlags.StringFlag(ctx, featureflags.BuildFirecrackerVersion) + kernelVersion := a.featureFlags.StringFlag(ctx, featureflags.BuildKernelVersion) + + stepsMarshalled, err := json.Marshal(dockerfileStore{FromTemplate: &plan.FromTemplate, Steps: &plan.Steps}) + if err != nil { + a.sendAPIStoreError(c, http.StatusInternalServerError, fmt.Sprintf("Error when processing steps: %s", err)) + telemetry.ReportCriticalError(ctx, "error when processing steps", err, telemetry.WithTemplateID(templateID)) + + return + } + + reg, apiErr := template.RegisterBuild(ctx, a.templateCache, a.sqlcDB, a.featureFlags, template.RegisterBuildData{ + ClusterID: clusters.WithClusterFallback(team.ClusterID), + TemplateID: templateID, + Team: team, + Alias: plan.Alias, + Dockerfile: string(stepsMarshalled), + CpuCount: &plan.CPU, + MemoryMB: &plan.RAM, + Version: templates.TemplateV2LatestVersion, + KernelVersion: kernelVersion, + FirecrackerVersion: firecrackerVersion, + }) + if apiErr != nil { + a.sendAPIStoreError(c, apiErr.Code, apiErr.ClientMsg) + telemetry.ReportErrorByCode(ctx, apiErr.Code, "error when registering refresh build", apiErr.Err, telemetry.WithTemplateID(templateID)) + + return + } + for _, al := range reg.Aliases { + a.templateCache.InvalidateAlias(context.WithoutCancel(ctx), &team.Slug, al) + } + + buildUUID, err := uuid.Parse(reg.BuildID) + if err != nil { + a.sendAPIStoreError(c, http.StatusInternalServerError, "Error when parsing new build ID") + telemetry.ReportCriticalError(ctx, "invalid build ID", err, telemetry.WithTemplateID(templateID)) + + return + } + + if _, err := a.CheckAndCancelConcurrentBuilds(ctx, templateID, buildUUID, clusters.WithClusterFallback(team.ClusterID)); err != nil { + a.sendAPIStoreError(c, http.StatusInternalServerError, "Error during refresh build request") + telemetry.ReportCriticalError(ctx, "error cancelling concurrent builds", err, telemetry.WithTemplateID(templateID)) + + return + } + + builderNode, err := a.templateManager.GetAvailableBuildClient(ctx, clusters.WithClusterFallback(team.ClusterID), nil) + if err != nil { + a.sendAPIStoreError(c, http.StatusServiceUnavailable, "Error when getting available build client") + telemetry.ReportCriticalError(ctx, "error getting build client", err, telemetry.WithTemplateID(templateID)) + + return + } + + machineInfo := builderNode.GetMachineInfo() + err = a.sqlcDB.UpdateTemplateBuild(ctx, queries.UpdateTemplateBuildParams{ + Dockerfile: new(string(stepsMarshalled)), + ClusterNodeID: new(builderNode.NodeID), + CpuArchitecture: new(machineInfo.CPUArchitecture), + CpuFamily: new(machineInfo.CPUFamily), + CpuModel: new(machineInfo.CPUModel), + CpuModelName: new(machineInfo.CPUModelName), + CpuFlags: machineInfo.CPUFlags, + BuildUuid: buildUUID, + }) + if err != nil { + a.sendAPIStoreError(c, http.StatusInternalServerError, fmt.Sprintf("Error when updating build: %s", err)) + telemetry.ReportCriticalError(ctx, "error updating build", err, telemetry.WithTemplateID(templateID)) + + return + } + + // Reload the freshly-registered build for its resolved free-disk target and the + // seeded kernel/fc versions, exactly as the v2 start handler passes them on. + built, err := a.sqlcDB.GetTemplateBuildWithTemplate(ctx, queries.GetTemplateBuildWithTemplateParams{ + TemplateID: templateID, + BuildID: buildUUID, + }) + if err != nil { + a.sendAPIStoreError(c, http.StatusInternalServerError, "Error when reloading registered build") + telemetry.ReportCriticalError(ctx, "error reloading build", err, telemetry.WithTemplateID(templateID)) + + return + } + build := built.EnvBuild + + version, err := userAgentToTemplateVersion(ctx, logger.L().With(logger.WithTemplateID(templateID), logger.WithBuildID(reg.BuildID)), c.Request.UserAgent()) + if err != nil { + a.sendAPIStoreError(c, http.StatusBadRequest, fmt.Sprintf("Error when parsing user agent: %s", err)) + telemetry.ReportErrorByCode(ctx, http.StatusBadRequest, "error parsing user agent", err, telemetry.WithTemplateID(templateID)) + + return + } + + err = a.templateManager.CreateTemplate( + ctx, + team.ID, + team.Slug, + templateID, + buildUUID, + build.KernelVersion, + build.FirecrackerVersion, + nil, // startCmd: the derived build re-runs the source's baked config + build.Vcpu, + team.Limits.DiskMb, + build.FreeDiskSizeMb, + build.RamMb, + build.MaxVcpu, // maxVCpuCount: inherit the source build's autoscale ceiling + nil, // readyCmd + nil, // fromImage + &plan.FromTemplate, + nil, // fromImageRegistry + nil, // force + &plan.Steps, + clusters.WithClusterFallback(team.ClusterID), + builderNode.NodeID, + version, + ) + if err != nil { + a.sendAPIStoreError(c, http.StatusInternalServerError, fmt.Sprintf("Error when starting refresh build: %s", err)) + telemetry.ReportCriticalError(ctx, "refresh build failed", err, telemetry.WithTemplateID(templateID)) + + return + } + + c.JSON(http.StatusAccepted, api.TemplateRefreshEnvdResponse{ + TemplateID: templateID, + BuildID: reg.BuildID, + FromEnvdVersion: plan.FromEnvdVersion, + Aliases: ®.Aliases, + }) +} diff --git a/packages/api/internal/handlers/template_refresh_envd_test.go b/packages/api/internal/handlers/template_refresh_envd_test.go new file mode 100644 index 0000000000..1e0745e18f --- /dev/null +++ b/packages/api/internal/handlers/template_refresh_envd_test.go @@ -0,0 +1,91 @@ +package handlers + +import ( + "net/http" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/e2b-dev/infra/packages/db/pkg/types" + "github.com/e2b-dev/infra/packages/db/queries" +) + +// readySource is a source template row with a usable ready build. +func readySource() queries.GetTeamTemplateRow { + envd := "0.4.0" + + return queries.GetTeamTemplateRow{ + BuildStatus: types.BuildStatusGroupReady, + BuildVcpu: 4, + BuildRamMb: 2048, + BuildEnvdVersion: &envd, + Aliases: []string{"my-template"}, + } +} + +func TestBuildRefreshEnvdPlan_Success(t *testing.T) { + plan, apiErr := buildRefreshEnvdPlan("tmpl-1", readySource()) + require.Nil(t, apiErr) + + // FROM the template itself, resolved to its latest ready build upstream. + assert.Equal(t, "tmpl-1", plan.FromTemplate) + + // Exactly one trivial RUN step -- what guarantees the step phase (and thus + // the envd swap) runs instead of leaving it to finalize. + require.Len(t, plan.Steps, 1) + assert.Equal(t, "RUN", plan.Steps[0].Type) + require.NotNil(t, plan.Steps[0].Args) + assert.Equal(t, []string{"true"}, *plan.Steps[0].Args) + + // Specs inherited from the source, not dropped to RegisterBuild defaults. + assert.Equal(t, int32(4), plan.CPU) + assert.Equal(t, int32(2048), plan.RAM) + + // Alias inherited so the in-place rebuild keeps the same name. + require.NotNil(t, plan.Alias) + assert.Equal(t, "my-template", *plan.Alias) + + assert.Equal(t, "0.4.0", plan.FromEnvdVersion) +} + +func TestBuildRefreshEnvdPlan_NoReadyBuild(t *testing.T) { + src := readySource() + src.BuildStatus = types.BuildStatusGroupInProgress + + _, apiErr := buildRefreshEnvdPlan("tmpl-1", src) + require.NotNil(t, apiErr) + assert.Equal(t, http.StatusBadRequest, apiErr.Code) +} + +func TestBuildRefreshEnvdPlan_MissingSpecs(t *testing.T) { + for _, tc := range []struct { + name string + cpu int64 + ram int64 + }{ + {"zero cpu", 0, 2048}, + {"zero ram", 4, 0}, + } { + t.Run(tc.name, func(t *testing.T) { + src := readySource() + src.BuildVcpu = tc.cpu + src.BuildRamMb = tc.ram + + _, apiErr := buildRefreshEnvdPlan("tmpl-1", src) + require.NotNil(t, apiErr) + assert.Equal(t, http.StatusBadRequest, apiErr.Code) + }) + } +} + +func TestBuildRefreshEnvdPlan_NoAliasNoEnvdVersion(t *testing.T) { + src := readySource() + src.Aliases = nil + src.BuildEnvdVersion = nil + + plan, apiErr := buildRefreshEnvdPlan("tmpl-1", src) + require.Nil(t, apiErr) + assert.Nil(t, plan.Alias, "no source alias -> nil, RegisterBuild leaves aliases untouched") + assert.Equal(t, "unknown", plan.FromEnvdVersion) +} diff --git a/spec/openapi.yml b/spec/openapi.yml index 287bf856d2..c9e87ddd51 100644 --- a/spec/openapi.yml +++ b/spec/openapi.yml @@ -2937,6 +2937,26 @@ components: nullable: true description: Failure message when status is `failed`, otherwise `null`. + TemplateRefreshEnvdResponse: + required: + - templateID + - buildID + - fromEnvdVersion + properties: + templateID: + type: string + description: Identifier of the template being refreshed + buildID: + type: string + description: Identifier of the new build; poll its status/logs endpoints + fromEnvdVersion: + type: string + description: envd version the source build was baked with + aliases: + type: array + description: Aliases of the template (inherited from the source) + items: + type: string TemplateRequestResponseV3: required: - templateID @@ -6689,6 +6709,44 @@ paths: schema: $ref: "#/components/schemas/Error" + /v2/templates/{templateID}/refresh-envd: + post: + summary: Rebuild a template with the current envd + description: | + Derives a new build of the template FROM the template's own latest ready + build, forcing the host's current envd binary to replace the one baked in + by the original build. Specs (cpu, memory) and the alias are inherited + from the source build. Returns the new build to poll via the existing + build status/logs endpoints. + tags: [templates] + security: + - ApiKeyAuth: [] + - AuthProviderBearerAuth: [] + AuthProviderTeamAuth: [] + - AdminApiKeyAuth: [] + AdminTeamAuth: [] + - AdminJWTAuth: [] + AdminTeamAuth: [] + parameters: + - $ref: "#/components/parameters/templateID" + responses: + "202": + description: The refresh build was requested successfully + content: + application/json: + schema: + $ref: "#/components/schemas/TemplateRefreshEnvdResponse" + "400": + $ref: "#/components/responses/400" + "401": + $ref: "#/components/responses/401" + "403": + $ref: "#/components/responses/403" + "404": + $ref: "#/components/responses/404" + "500": + $ref: "#/components/responses/500" + /v2/templates/{templateID}: patch: summary: Update template (v2)