From 611fcb012c7e2cc48c6a9cb906b21f6097a9f9bc Mon Sep 17 00:00:00 2001 From: Vilius Puskunalis <47086537+puskunalis@users.noreply.github.com> Date: Mon, 20 Apr 2026 09:55:13 +0300 Subject: [PATCH] feat: add sync overrun option to sync windows (#25361) (#25510) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Vilius Puškunalis <47086537+puskunalis@users.noreply.github.com> --- assets/swagger.json | 4 + cmd/argocd/commands/app.go | 2 +- cmd/argocd/commands/projectwindows.go | 142 +- cmd/argocd/commands/projectwindows_test.go | 246 ++- controller/appcontroller.go | 2 +- controller/sync.go | 7 +- docs/operator-manual/project.yaml | 7 + .../commands/argocd_proj_windows.md | 2 + .../commands/argocd_proj_windows_add.md | 5 +- ...rgocd_proj_windows_disable-sync-overrun.md | 66 + ...argocd_proj_windows_enable-sync-overrun.md | 66 + docs/user-guide/sync_windows.md | 96 +- manifests/core-install-with-hydrator.yaml | 6 + manifests/core-install.yaml | 6 + manifests/crds/appproject-crd.yaml | 6 + manifests/ha/install-with-hydrator.yaml | 6 + manifests/ha/install.yaml | 6 + manifests/install-with-hydrator.yaml | 6 + manifests/install.yaml | 6 + pkg/apis/application/v1alpha1/generated.pb.go | 1623 +++++++++-------- pkg/apis/application/v1alpha1/generated.proto | 5 + .../application/v1alpha1/openapi_generated.go | 7 + pkg/apis/application/v1alpha1/types.go | 114 +- pkg/apis/application/v1alpha1/types_test.go | 827 ++++++++- server/application/application.go | 4 +- test/e2e/project_management_test.go | 55 + .../project-details/project-details.tsx | 7 + .../project-sync-windows-edit-panel.tsx | 3 + ui/src/app/shared/models.ts | 1 + 29 files changed, 2418 insertions(+), 915 deletions(-) create mode 100644 docs/user-guide/commands/argocd_proj_windows_disable-sync-overrun.md create mode 100644 docs/user-guide/commands/argocd_proj_windows_enable-sync-overrun.md diff --git a/assets/swagger.json b/assets/swagger.json index 3cfd500370..945d695458 100644 --- a/assets/swagger.json +++ b/assets/swagger.json @@ -10935,6 +10935,10 @@ "type": "string", "title": "Schedule is the time the window will begin, specified in cron format" }, + "syncOverrun": { + "type": "boolean", + "title": "SyncOverrun allows ongoing syncs to continue in two scenarios:\nFor deny windows: allows syncs that started before the deny window became active to continue running\nFor allow windows: allows syncs that started during the allow window to continue after the window ends" + }, "timeZone": { "type": "string", "title": "TimeZone of the sync that will be applied to the schedule" diff --git a/cmd/argocd/commands/app.go b/cmd/argocd/commands/app.go index 215aaef175..7c839843eb 100644 --- a/cmd/argocd/commands/app.go +++ b/cmd/argocd/commands/app.go @@ -693,7 +693,7 @@ func printAppSummaryTable(app *argoappv1.Application, appURL string, windows *ar } if deny || !deny && !allow && inactiveAllows { - s, err := windows.CanSync(true) + s, err := windows.CanSync(true, nil) if err == nil && s { status = "Manual Allowed" } else { diff --git a/cmd/argocd/commands/projectwindows.go b/cmd/argocd/commands/projectwindows.go index 8f0549e2b6..d223b47f22 100644 --- a/cmd/argocd/commands/projectwindows.go +++ b/cmd/argocd/commands/projectwindows.go @@ -42,6 +42,8 @@ argocd proj windows list `, } roleCommand.AddCommand(NewProjectWindowsDisableManualSyncCommand(clientOpts)) roleCommand.AddCommand(NewProjectWindowsEnableManualSyncCommand(clientOpts)) + roleCommand.AddCommand(NewProjectWindowsDisableSyncOverrunCommand(clientOpts)) + roleCommand.AddCommand(NewProjectWindowsEnableSyncOverrunCommand(clientOpts)) roleCommand.AddCommand(NewProjectWindowsAddWindowCommand(clientOpts)) roleCommand.AddCommand(NewProjectWindowsDeleteCommand(clientOpts)) roleCommand.AddCommand(NewProjectWindowsListCommand(clientOpts)) @@ -49,18 +51,13 @@ argocd proj windows list `, return roleCommand } -// NewProjectWindowsDisableManualSyncCommand returns a new instance of an `argocd proj windows disable-manual-sync` command -func NewProjectWindowsDisableManualSyncCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command { - command := &cobra.Command{ - Use: "disable-manual-sync PROJECT ID", - Short: "Disable manual sync for a sync window", - Long: "Disable manual sync for a sync window. Requires ID which can be found by running \"argocd proj windows list PROJECT\"", - Example: ` -#Disable manual sync for a sync window for the Project -argocd proj windows disable-manual-sync PROJECT ID - -#Disabling manual sync for a windows set on the default project with Id 0 -argocd proj windows disable-manual-sync default 0`, +// newProjectWindowsToggleCommand creates a command for toggling a boolean field on a sync window +func newProjectWindowsToggleCommand(clientOpts *argocdclient.ClientOptions, use, short, long, example string, updateFn func(*v1alpha1.SyncWindow)) *cobra.Command { + return &cobra.Command{ + Use: use, + Short: short, + Long: long, + Example: example, Run: func(c *cobra.Command, args []string) { ctx := c.Context() @@ -79,26 +76,51 @@ argocd proj windows disable-manual-sync default 0`, proj, err := projIf.Get(ctx, &projectpkg.ProjectQuery{Name: projName}) errors.CheckError(err) + found := false for i, window := range proj.Spec.SyncWindows { if id == i { - window.ManualSync = false + updateFn(window) + found = true + break } } + if !found { + errors.CheckError(fmt.Errorf("window with id '%d' not found", id)) + } _, err = projIf.Update(ctx, &projectpkg.ProjectUpdateRequest{Project: proj}) errors.CheckError(err) }, } - return command +} + +// NewProjectWindowsDisableManualSyncCommand returns a new instance of an `argocd proj windows disable-manual-sync` command +func NewProjectWindowsDisableManualSyncCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command { + return newProjectWindowsToggleCommand( + clientOpts, + "disable-manual-sync PROJECT ID", + "Disable manual sync for a sync window", + "Disable manual sync for a sync window. Requires ID which can be found by running \"argocd proj windows list PROJECT\"", + ` +#Disable manual sync for a sync window for the Project +argocd proj windows disable-manual-sync PROJECT ID + +#Disabling manual sync for a windows set on the default project with Id 0 +argocd proj windows disable-manual-sync default 0`, + func(window *v1alpha1.SyncWindow) { + window.ManualSync = false + }, + ) } // NewProjectWindowsEnableManualSyncCommand returns a new instance of an `argocd proj windows enable-manual-sync` command func NewProjectWindowsEnableManualSyncCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command { - command := &cobra.Command{ - Use: "enable-manual-sync PROJECT ID", - Short: "Enable manual sync for a sync window", - Long: "Enable manual sync for a sync window. Requires ID which can be found by running \"argocd proj windows list PROJECT\"", - Example: ` + return newProjectWindowsToggleCommand( + clientOpts, + "enable-manual-sync PROJECT ID", + "Enable manual sync for a sync window", + "Enable manual sync for a sync window. Requires ID which can be found by running \"argocd proj windows list PROJECT\"", + ` #Enabling manual sync for a general case argocd proj windows enable-manual-sync PROJECT ID @@ -107,35 +129,48 @@ argocd proj windows enable-manual-sync default 2 #Enabling manual sync with a custom message argocd proj windows enable-manual-sync my-app-project --message "Manual sync initiated by admin`, - Run: func(c *cobra.Command, args []string) { - ctx := c.Context() - - if len(args) != 2 { - c.HelpFunc()(c, args) - os.Exit(1) - } - - projName := args[0] - id, err := strconv.Atoi(args[1]) - errors.CheckError(err) - - conn, projIf := headless.NewClientOrDie(clientOpts, c).NewProjectClientOrDie() - defer utilio.Close(conn) - - proj, err := projIf.Get(ctx, &projectpkg.ProjectQuery{Name: projName}) - errors.CheckError(err) - - for i, window := range proj.Spec.SyncWindows { - if id == i { - window.ManualSync = true - } - } - - _, err = projIf.Update(ctx, &projectpkg.ProjectUpdateRequest{Project: proj}) - errors.CheckError(err) + func(window *v1alpha1.SyncWindow) { + window.ManualSync = true }, - } - return command + ) +} + +// NewProjectWindowsDisableSyncOverrunCommand returns a new instance of an `argocd proj windows disable-sync-overrun` command +func NewProjectWindowsDisableSyncOverrunCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command { + return newProjectWindowsToggleCommand( + clientOpts, + "disable-sync-overrun PROJECT ID", + "Disable sync overrun for a sync window", + "Disable sync overrun for a sync window. Requires ID which can be found by running \"argocd proj windows list PROJECT\"", + ` +#Disable sync overrun for a sync window for the Project +argocd proj windows disable-sync-overrun PROJECT ID + +#Disabling sync overrun for a window set on the default project with Id 0 +argocd proj windows disable-sync-overrun default 0`, + func(window *v1alpha1.SyncWindow) { + window.SyncOverrun = false + }, + ) +} + +// NewProjectWindowsEnableSyncOverrunCommand returns a new instance of an `argocd proj windows enable-sync-overrun` command +func NewProjectWindowsEnableSyncOverrunCommand(clientOpts *argocdclient.ClientOptions) *cobra.Command { + return newProjectWindowsToggleCommand( + clientOpts, + "enable-sync-overrun PROJECT ID", + "Enable sync overrun for a sync window", + "Enable sync overrun for a sync window. When enabled on a deny window, syncs that started before the deny window will be allowed to continue. When enabled on an allow window, syncs that started during the allow window can continue after the window ends. Requires ID which can be found by running \"argocd proj windows list PROJECT\"", + ` +#Enable sync overrun for a sync window +argocd proj windows enable-sync-overrun PROJECT ID + +#Enabling sync overrun for a window set on the default project with Id 2 +argocd proj windows enable-sync-overrun default 2`, + func(window *v1alpha1.SyncWindow) { + window.SyncOverrun = true + }, + ) } // NewProjectWindowsAddWindowCommand returns a new instance of an `argocd proj windows add` command @@ -148,6 +183,7 @@ func NewProjectWindowsAddWindowCommand(clientOpts *argocdclient.ClientOptions) * namespaces []string clusters []string manualSync bool + syncOverrun bool timeZone string andOperator bool description string @@ -164,7 +200,7 @@ argocd proj windows add PROJECT \ --applications "*" \ --description "Ticket 123" -#Add a deny sync window with the ability to manually sync. +#Add a deny sync window with the ability to manually sync and sync overrun. argocd proj windows add PROJECT \ --kind deny \ --schedule "30 10 * * *" \ @@ -173,8 +209,8 @@ argocd proj windows add PROJECT \ --namespaces "default,\\*-prod" \ --clusters "prod,staging" \ --manual-sync \ - --description "Ticket 123" - `, + --sync-overrun \ + --description "Ticket 123"`, Run: func(c *cobra.Command, args []string) { ctx := c.Context() @@ -189,7 +225,7 @@ argocd proj windows add PROJECT \ proj, err := projIf.Get(ctx, &projectpkg.ProjectQuery{Name: projName}) errors.CheckError(err) - err = proj.Spec.AddWindow(kind, schedule, duration, applications, namespaces, clusters, manualSync, timeZone, andOperator, description) + err = proj.Spec.AddWindow(kind, schedule, duration, applications, namespaces, clusters, manualSync, timeZone, andOperator, description, syncOverrun) errors.CheckError(err) _, err = projIf.Update(ctx, &projectpkg.ProjectUpdateRequest{Project: proj}) @@ -203,6 +239,7 @@ argocd proj windows add PROJECT \ command.Flags().StringSliceVar(&namespaces, "namespaces", []string{}, "Namespaces that the schedule will be applied to. Comma separated, wildcards supported (e.g. --namespaces default,\\*-prod)") command.Flags().StringSliceVar(&clusters, "clusters", []string{}, "Clusters that the schedule will be applied to. Comma separated, wildcards supported (e.g. --clusters prod,staging)") command.Flags().BoolVar(&manualSync, "manual-sync", false, "Allow manual syncs for both deny and allow windows") + command.Flags().BoolVar(&syncOverrun, "sync-overrun", false, "Allow syncs to continue: for deny windows, syncs that started before the window; for allow windows, syncs that started during the window") command.Flags().StringVar(&timeZone, "time-zone", "UTC", "Time zone of the sync window") command.Flags().BoolVar(&andOperator, "use-and-operator", false, "Use AND operator for matching applications, namespaces and clusters instead of the default OR operator") command.Flags().StringVar(&description, "description", "", `Sync window description`) @@ -362,7 +399,7 @@ argocd proj windows list test-project`, func printSyncWindows(proj *v1alpha1.AppProject) { w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) var fmtStr string - headers := []any{"ID", "STATUS", "KIND", "SCHEDULE", "DURATION", "APPLICATIONS", "NAMESPACES", "CLUSTERS", "MANUALSYNC", "TIMEZONE", "USEANDOPERATOR"} + headers := []any{"ID", "STATUS", "KIND", "SCHEDULE", "DURATION", "APPLICATIONS", "NAMESPACES", "CLUSTERS", "MANUALSYNC", "SYNCOVERRUN", "TIMEZONE", "USEANDOPERATOR"} fmtStr = strings.Repeat("%s\t", len(headers)) + "\n" fmt.Fprintf(w, fmtStr, headers...) if proj.Spec.SyncWindows.HasWindows() { @@ -378,6 +415,7 @@ func printSyncWindows(proj *v1alpha1.AppProject) { formatListOutput(window.Namespaces), formatListOutput(window.Clusters), formatBoolEnabledOutput(window.ManualSync), + formatBoolEnabledOutput(window.SyncOverrun), window.TimeZone, formatBoolEnabledOutput(window.UseAndOperator), } diff --git a/cmd/argocd/commands/projectwindows_test.go b/cmd/argocd/commands/projectwindows_test.go index 069dd49e6d..4728ae41a1 100644 --- a/cmd/argocd/commands/projectwindows_test.go +++ b/cmd/argocd/commands/projectwindows_test.go @@ -1,6 +1,11 @@ package commands import ( + "bytes" + "io" + "os" + "regexp" + "strings" "testing" "github.com/stretchr/testify/assert" @@ -11,30 +16,229 @@ import ( ) func TestPrintSyncWindows(t *testing.T) { - proj := &v1alpha1.AppProject{ - ObjectMeta: metav1.ObjectMeta{Name: "test-project"}, - Spec: v1alpha1.AppProjectSpec{ - SyncWindows: v1alpha1.SyncWindows{ - { - Kind: "allow", - Schedule: "* * * * *", - Duration: "1h", - Applications: []string{"app1"}, - Namespaces: []string{"ns1"}, - Clusters: []string{"cluster1"}, - ManualSync: true, - UseAndOperator: true, + tests := []struct { + name string + project *v1alpha1.AppProject + expectedHeader []string + expectedRows [][]string + }{ + { + name: "Project with multiple sync windows including syncOverrun", + project: &v1alpha1.AppProject{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-project", + }, + Spec: v1alpha1.AppProjectSpec{ + SyncWindows: v1alpha1.SyncWindows{ + { + Kind: "allow", + Schedule: "0 0 * * *", + Duration: "1h", + Applications: []string{"app1", "app2"}, + Namespaces: []string{"default"}, + Clusters: []string{"cluster1"}, + ManualSync: false, + SyncOverrun: false, + TimeZone: "UTC", + UseAndOperator: false, + }, + { + Kind: "deny", + Schedule: "0 12 * * *", + Duration: "2h", + Applications: []string{"*"}, + Namespaces: []string{"production"}, + Clusters: []string{"*"}, + ManualSync: true, + SyncOverrun: true, + TimeZone: "America/New_York", + UseAndOperator: true, + }, + }, }, }, + expectedHeader: []string{"ID", "STATUS", "KIND", "SCHEDULE", "DURATION", "APPLICATIONS", "NAMESPACES", "CLUSTERS", "MANUALSYNC", "SYNCOVERRUN", "TIMEZONE", "USEANDOPERATOR"}, + expectedRows: [][]string{ + {"0", "Inactive", "allow", "0 0 * * *", "1h", "app1,app2", "default", "cluster1", "Disabled", "Disabled", "UTC", "Disabled"}, + {"1", "Inactive", "deny", "0 12 * * *", "2h", "*", "production", "*", "Enabled", "Enabled", "America/New_York", "Enabled"}, + }, + }, + { + name: "Project with empty sync window lists", + project: &v1alpha1.AppProject{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-project", + }, + Spec: v1alpha1.AppProjectSpec{ + SyncWindows: v1alpha1.SyncWindows{ + { + Kind: "allow", + Schedule: "0 1 * * *", + Duration: "30m", + Applications: []string{}, + Namespaces: []string{}, + Clusters: []string{}, + ManualSync: false, + SyncOverrun: false, + TimeZone: "UTC", + UseAndOperator: false, + }, + }, + }, + }, + expectedHeader: []string{"ID", "STATUS", "KIND", "SCHEDULE", "DURATION", "APPLICATIONS", "NAMESPACES", "CLUSTERS", "MANUALSYNC", "SYNCOVERRUN", "TIMEZONE", "USEANDOPERATOR"}, + expectedRows: [][]string{ + {"0", "Inactive", "allow", "0 1 * * *", "30m", "-", "-", "-", "Disabled", "Disabled", "UTC", "Disabled"}, + }, + }, + { + name: "Project with no sync windows", + project: &v1alpha1.AppProject{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-project", + }, + Spec: v1alpha1.AppProjectSpec{ + SyncWindows: v1alpha1.SyncWindows{}, + }, + }, + expectedHeader: []string{"ID", "STATUS", "KIND", "SCHEDULE", "DURATION", "APPLICATIONS", "NAMESPACES", "CLUSTERS", "MANUALSYNC", "SYNCOVERRUN", "TIMEZONE", "USEANDOPERATOR"}, + expectedRows: [][]string{}, }, } - output, err := captureOutput(func() error { - printSyncWindows(proj) - return nil - }) - require.NoError(t, err) - t.Log(output) - assert.Contains(t, output, "ID STATUS KIND SCHEDULE DURATION APPLICATIONS NAMESPACES CLUSTERS MANUALSYNC TIMEZONE USEANDOPERATOR") - assert.Contains(t, output, "0 Active allow * * * * * 1h app1 ns1 cluster1 Enabled Enabled") + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Capture stdout + oldStdout := os.Stdout + r, w, _ := os.Pipe() + os.Stdout = w + + // Call the function + printSyncWindows(tt.project) + + // Restore stdout + w.Close() + os.Stdout = oldStdout + + // Read captured output + var buf bytes.Buffer + _, err := io.Copy(&buf, r) + require.NoError(t, err) + output := buf.String() + + // Parse the table output + lines := strings.Split(strings.TrimSpace(output), "\n") + assert.GreaterOrEqual(t, len(lines), 1, "Should have at least a header line") + + // Parse header line (split by whitespace for headers since they don't contain spaces) + headerLine := lines[0] + headerFields := strings.Fields(headerLine) + assert.Len(t, headerFields, len(tt.expectedHeader), "Header should have correct number of columns") + assert.Equal(t, tt.expectedHeader, headerFields, "Header columns should match expected") + + // Parse data rows + dataLines := lines[1:] + assert.Len(t, dataLines, len(tt.expectedRows), "Should have expected number of data rows") + + for i, dataLine := range dataLines { + // Split by 2 or more spaces (tabwriter output uses multiple spaces as separators) + re := regexp.MustCompile(`\s{2,}`) + fields := re.Split(strings.TrimSpace(dataLine), -1) + + assert.Len(t, fields, len(tt.expectedRows[i]), "Row %d should have correct number of columns", i) + + for j, expectedValue := range tt.expectedRows[i] { + assert.Equal(t, expectedValue, fields[j], "Row %d, column %d should match expected value", i, j) + } + } + }) + } +} + +func TestFormatListOutput(t *testing.T) { + tests := []struct { + name string + input []string + expected string + }{ + { + name: "Empty list", + input: []string{}, + expected: "-", + }, + { + name: "Single item", + input: []string{"app1"}, + expected: "app1", + }, + { + name: "Multiple items", + input: []string{"app1", "app2", "app3"}, + expected: "app1,app2,app3", + }, + { + name: "Wildcard", + input: []string{"*"}, + expected: "*", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := formatListOutput(tt.input) + assert.Equal(t, tt.expected, result) + }) + } +} + +func TestFormatBoolOutput(t *testing.T) { + tests := []struct { + name string + input bool + expected string + }{ + { + name: "Active", + input: true, + expected: "Active", + }, + { + name: "Inactive", + input: false, + expected: "Inactive", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := formatBoolOutput(tt.input) + assert.Equal(t, tt.expected, result) + }) + } +} + +func TestFormatBoolEnabledOutput(t *testing.T) { + tests := []struct { + name string + input bool + expected string + }{ + { + name: "Enabled", + input: true, + expected: "Enabled", + }, + { + name: "Disabled", + input: false, + expected: "Disabled", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result := formatBoolEnabledOutput(tt.input) + assert.Equal(t, tt.expected, result) + }) + } } diff --git a/controller/appcontroller.go b/controller/appcontroller.go index 84225bd8e8..be2a2156f8 100644 --- a/controller/appcontroller.go +++ b/controller/appcontroller.go @@ -1885,7 +1885,7 @@ func (ctrl *ApplicationController) processAppRefreshQueueItem() (processNext boo app.Status.Summary = tree.GetSummary(app) } - canSync, _ := project.Spec.SyncWindows.Matches(app).CanSync(false) + canSync, _ := project.Spec.SyncWindows.Matches(app).CanSync(false, nil) if canSync { syncErrCond, opDuration := ctrl.autoSync(app, compareResult.syncStatus, compareResult.resources, compareResult.revisionsMayHaveChanges) setOpDuration = opDuration diff --git a/controller/sync.go b/controller/sync.go index 9afbbe6ba8..607294addc 100644 --- a/controller/sync.go +++ b/controller/sync.go @@ -542,10 +542,15 @@ func delayBetweenSyncWaves(_ common.SyncPhase, _ int, finalWave bool) error { func syncWindowPreventsSync(app *v1alpha1.Application, proj *v1alpha1.AppProject) (bool, error) { window := proj.Spec.SyncWindows.Matches(app) isManual := false + var operationStartTime *time.Time if app.Status.OperationState != nil { isManual = !app.Status.OperationState.Operation.InitiatedBy.Automated + if !app.Status.OperationState.StartedAt.IsZero() { + t := app.Status.OperationState.StartedAt.Time + operationStartTime = &t + } } - canSync, err := window.CanSync(isManual) + canSync, err := window.CanSync(isManual, operationStartTime) if err != nil { // prevents sync because sync window has an error return true, err diff --git a/docs/operator-manual/project.yaml b/docs/operator-manual/project.yaml index 370634008b..5c2b4e9b48 100644 --- a/docs/operator-manual/project.yaml +++ b/docs/operator-manual/project.yaml @@ -89,11 +89,18 @@ spec: applications: - '*-prod' manualSync: true + - kind: allow + schedule: '0 9 * * *' + duration: 8h + applications: + - '*' + syncOverrun: true # Syncs started during this window can continue after window ends - kind: deny schedule: '0 22 * * *' duration: 1h namespaces: - default + syncOverrun: true # Syncs started before this window can continue during the window - kind: allow schedule: '0 23 * * *' duration: 1h diff --git a/docs/user-guide/commands/argocd_proj_windows.md b/docs/user-guide/commands/argocd_proj_windows.md index dcc1dcbf36..286810837c 100644 --- a/docs/user-guide/commands/argocd_proj_windows.md +++ b/docs/user-guide/commands/argocd_proj_windows.md @@ -68,7 +68,9 @@ argocd proj windows list * [argocd proj windows add](argocd_proj_windows_add.md) - Add a sync window to a project * [argocd proj windows delete](argocd_proj_windows_delete.md) - Delete a sync window from a project. Requires ID which can be found by running "argocd proj windows list PROJECT" * [argocd proj windows disable-manual-sync](argocd_proj_windows_disable-manual-sync.md) - Disable manual sync for a sync window +* [argocd proj windows disable-sync-overrun](argocd_proj_windows_disable-sync-overrun.md) - Disable sync overrun for a sync window * [argocd proj windows enable-manual-sync](argocd_proj_windows_enable-manual-sync.md) - Enable manual sync for a sync window +* [argocd proj windows enable-sync-overrun](argocd_proj_windows_enable-sync-overrun.md) - Enable sync overrun for a sync window * [argocd proj windows list](argocd_proj_windows_list.md) - List project sync windows * [argocd proj windows update](argocd_proj_windows_update.md) - Update a project sync window diff --git a/docs/user-guide/commands/argocd_proj_windows_add.md b/docs/user-guide/commands/argocd_proj_windows_add.md index abf2f0b28e..e728a676a7 100644 --- a/docs/user-guide/commands/argocd_proj_windows_add.md +++ b/docs/user-guide/commands/argocd_proj_windows_add.md @@ -20,7 +20,7 @@ argocd proj windows add PROJECT \ --applications "*" \ --description "Ticket 123" -#Add a deny sync window with the ability to manually sync. +#Add a deny sync window with the ability to manually sync and sync overrun. argocd proj windows add PROJECT \ --kind deny \ --schedule "30 10 * * *" \ @@ -29,8 +29,8 @@ argocd proj windows add PROJECT \ --namespaces "default,\\*-prod" \ --clusters "prod,staging" \ --manual-sync \ + --sync-overrun \ --description "Ticket 123" - ``` ### Options @@ -45,6 +45,7 @@ argocd proj windows add PROJECT \ --manual-sync Allow manual syncs for both deny and allow windows --namespaces strings Namespaces that the schedule will be applied to. Comma separated, wildcards supported (e.g. --namespaces default,\*-prod) --schedule string Sync window schedule in cron format. (e.g. --schedule "0 22 * * *") + --sync-overrun Allow syncs to continue: for deny windows, syncs that started before the window; for allow windows, syncs that started during the window --time-zone string Time zone of the sync window (default "UTC") --use-and-operator Use AND operator for matching applications, namespaces and clusters instead of the default OR operator ``` diff --git a/docs/user-guide/commands/argocd_proj_windows_disable-sync-overrun.md b/docs/user-guide/commands/argocd_proj_windows_disable-sync-overrun.md new file mode 100644 index 0000000000..a06c05db99 --- /dev/null +++ b/docs/user-guide/commands/argocd_proj_windows_disable-sync-overrun.md @@ -0,0 +1,66 @@ +# `argocd proj windows disable-sync-overrun` Command Reference + +## argocd proj windows disable-sync-overrun + +Disable sync overrun for a sync window + +### Synopsis + +Disable sync overrun for a sync window. Requires ID which can be found by running "argocd proj windows list PROJECT" + +``` +argocd proj windows disable-sync-overrun PROJECT ID [flags] +``` + +### Examples + +``` + +#Disable sync overrun for a sync window for the Project +argocd proj windows disable-sync-overrun PROJECT ID + +#Disabling sync overrun for a window set on the default project with Id 0 +argocd proj windows disable-sync-overrun default 0 +``` + +### Options + +``` + -h, --help help for disable-sync-overrun +``` + +### Options inherited from parent commands + +``` + --argocd-context string The name of the Argo-CD server context to use + --auth-token string Authentication token; set this or the ARGOCD_AUTH_TOKEN environment variable + --client-crt string Client certificate file + --client-crt-key string Client certificate key file + --config string Path to Argo CD config (default "/home/user/.config/argocd/config") + --controller-name string Name of the Argo CD Application controller; set this or the ARGOCD_APPLICATION_CONTROLLER_NAME environment variable when the controller's name label differs from the default, for example when installing via the Helm chart (default "argocd-application-controller") + --core If set to true then CLI talks directly to Kubernetes instead of talking to Argo CD API server + --grpc-web Enables gRPC-web protocol. Useful if Argo CD server is behind proxy which does not support HTTP2. + --grpc-web-root-path string Enables gRPC-web protocol. Useful if Argo CD server is behind proxy which does not support HTTP2. Set web root. + -H, --header strings Sets additional header to all requests made by Argo CD CLI. (Can be repeated multiple times to add multiple headers, also supports comma separated headers) + --http-retry-max int Maximum number of retries to establish http connection to Argo CD server + --insecure Skip server certificate and domain verification + --kube-context string Directs the command to the given kube-context + --logformat string Set the logging format. One of: json|text (default "json") + --loglevel string Set the logging level. One of: debug|info|warn|error (default "info") + --plaintext Disable TLS + --port-forward Connect to a random argocd-server port using port forwarding + --port-forward-namespace string Namespace name which should be used for port forwarding + --prompts-enabled Force optional interactive prompts to be enabled or disabled, overriding local configuration. If not specified, the local configuration value will be used, which is false by default. + --redis-compress string Enable this if the application controller is configured with redis compression enabled. (possible values: gzip, none) (default "gzip") + --redis-haproxy-name string Name of the Redis HA Proxy; set this or the ARGOCD_REDIS_HAPROXY_NAME environment variable when the HA Proxy's name label differs from the default, for example when installing via the Helm chart (default "argocd-redis-ha-haproxy") + --redis-name string Name of the Redis deployment; set this or the ARGOCD_REDIS_NAME environment variable when the Redis's name label differs from the default, for example when installing via the Helm chart (default "argocd-redis") + --repo-server-name string Name of the Argo CD Repo server; set this or the ARGOCD_REPO_SERVER_NAME environment variable when the server's name label differs from the default, for example when installing via the Helm chart (default "argocd-repo-server") + --server string Argo CD server address + --server-crt string Server certificate file + --server-name string Name of the Argo CD API server; set this or the ARGOCD_SERVER_NAME environment variable when the server's name label differs from the default, for example when installing via the Helm chart (default "argocd-server") +``` + +### SEE ALSO + +* [argocd proj windows](argocd_proj_windows.md) - Manage a project's sync windows + diff --git a/docs/user-guide/commands/argocd_proj_windows_enable-sync-overrun.md b/docs/user-guide/commands/argocd_proj_windows_enable-sync-overrun.md new file mode 100644 index 0000000000..6374af265a --- /dev/null +++ b/docs/user-guide/commands/argocd_proj_windows_enable-sync-overrun.md @@ -0,0 +1,66 @@ +# `argocd proj windows enable-sync-overrun` Command Reference + +## argocd proj windows enable-sync-overrun + +Enable sync overrun for a sync window + +### Synopsis + +Enable sync overrun for a sync window. When enabled on a deny window, syncs that started before the deny window will be allowed to continue. When enabled on an allow window, syncs that started during the allow window can continue after the window ends. Requires ID which can be found by running "argocd proj windows list PROJECT" + +``` +argocd proj windows enable-sync-overrun PROJECT ID [flags] +``` + +### Examples + +``` + +#Enable sync overrun for a sync window +argocd proj windows enable-sync-overrun PROJECT ID + +#Enabling sync overrun for a window set on the default project with Id 2 +argocd proj windows enable-sync-overrun default 2 +``` + +### Options + +``` + -h, --help help for enable-sync-overrun +``` + +### Options inherited from parent commands + +``` + --argocd-context string The name of the Argo-CD server context to use + --auth-token string Authentication token; set this or the ARGOCD_AUTH_TOKEN environment variable + --client-crt string Client certificate file + --client-crt-key string Client certificate key file + --config string Path to Argo CD config (default "/home/user/.config/argocd/config") + --controller-name string Name of the Argo CD Application controller; set this or the ARGOCD_APPLICATION_CONTROLLER_NAME environment variable when the controller's name label differs from the default, for example when installing via the Helm chart (default "argocd-application-controller") + --core If set to true then CLI talks directly to Kubernetes instead of talking to Argo CD API server + --grpc-web Enables gRPC-web protocol. Useful if Argo CD server is behind proxy which does not support HTTP2. + --grpc-web-root-path string Enables gRPC-web protocol. Useful if Argo CD server is behind proxy which does not support HTTP2. Set web root. + -H, --header strings Sets additional header to all requests made by Argo CD CLI. (Can be repeated multiple times to add multiple headers, also supports comma separated headers) + --http-retry-max int Maximum number of retries to establish http connection to Argo CD server + --insecure Skip server certificate and domain verification + --kube-context string Directs the command to the given kube-context + --logformat string Set the logging format. One of: json|text (default "json") + --loglevel string Set the logging level. One of: debug|info|warn|error (default "info") + --plaintext Disable TLS + --port-forward Connect to a random argocd-server port using port forwarding + --port-forward-namespace string Namespace name which should be used for port forwarding + --prompts-enabled Force optional interactive prompts to be enabled or disabled, overriding local configuration. If not specified, the local configuration value will be used, which is false by default. + --redis-compress string Enable this if the application controller is configured with redis compression enabled. (possible values: gzip, none) (default "gzip") + --redis-haproxy-name string Name of the Redis HA Proxy; set this or the ARGOCD_REDIS_HAPROXY_NAME environment variable when the HA Proxy's name label differs from the default, for example when installing via the Helm chart (default "argocd-redis-ha-haproxy") + --redis-name string Name of the Redis deployment; set this or the ARGOCD_REDIS_NAME environment variable when the Redis's name label differs from the default, for example when installing via the Helm chart (default "argocd-redis") + --repo-server-name string Name of the Argo CD Repo server; set this or the ARGOCD_REPO_SERVER_NAME environment variable when the server's name label differs from the default, for example when installing via the Helm chart (default "argocd-repo-server") + --server string Argo CD server address + --server-crt string Server certificate file + --server-name string Name of the Argo CD API server; set this or the ARGOCD_SERVER_NAME environment variable when the server's name label differs from the default, for example when installing via the Helm chart (default "argocd-server") +``` + +### SEE ALSO + +* [argocd proj windows](argocd_proj_windows.md) - Manage a project's sync windows + diff --git a/docs/user-guide/sync_windows.md b/docs/user-guide/sync_windows.md index 1c91d73cbe..2daa394748 100644 --- a/docs/user-guide/sync_windows.md +++ b/docs/user-guide/sync_windows.md @@ -28,8 +28,8 @@ then the Application is affected by the Sync Window. ## Effect of Sync Windows -These windows affect the running of both manual and automated syncs but allow an override -for manual syncs which is useful if you are only interested in preventing automated syncs or if you need to temporarily +These windows affect the running of both manual and automated syncs but allow an override +for manual syncs which is useful if you are only interested in preventing automated syncs or if you need to temporarily override a window to perform a sync. The windows work in the following way: @@ -39,6 +39,45 @@ The windows work in the following way: - If there are any `deny` windows matching an application then all syncs will be denied when the `deny` windows are active. - If there is an active matching `allow` and an active matching `deny` then syncs will be denied as `deny` windows override `allow` windows. +### Sync Overrun + +The `syncOverrun` option allows automatic syncs that are already running to continue even when they transition out of their allowed window. This is particularly useful when you want to prevent new syncs from starting during maintenance windows but don't want to interrupt syncs that are already in progress. + +Sync overrun can be configured on both `allow` and `deny` windows: + +#### Deny Window Overrun + +When `syncOverrun` is enabled on a deny window: + +- Syncs that started **before** the deny window became active will be allowed to complete +- New syncs will still be blocked during the deny window +- **All active deny windows must have syncOverrun enabled** for the overrun to be allowed + +#### Allow Window Overrun + +When `syncOverrun` is enabled on an allow window: + +- Syncs that started **during** the allow window will be allowed to continue even after the window ends +- This is useful for long-running syncs that may extend beyond the scheduled window +- **All inactive allow windows must have syncOverrun enabled** for the overrun to be allowed +- The sync can continue as long as: + - No deny window without overrun becomes active + - If a deny window becomes active, it must also have syncOverrun enabled + +#### Transition Scenarios + +Here are some common scenarios and their behavior: + +1. **No window → Deny with overrun**: Sync continues (deny supports overrun, sync was permitted when it started) +1. **No window → Deny without overrun**: Sync is **blocked** (deny doesn't support overrun) +1. **Allow with overrun → Deny with overrun**: Sync continues (both windows support overrun) +1. **Allow with overrun → Deny without overrun**: Sync is **blocked** (deny doesn't support overrun) +1. **Allow without overrun → Deny with overrun**: Sync is **allowed** (deny supports overrun, sync was permitted when it started) +1. **Allow without overrun → Deny without overrun**: Sync is **blocked** (neither supports overrun) +1. **Allow with overrun → Allow ends**: Sync continues (overrun enabled on original allow window) +1. **Multiple allows with overrun → All end**: Sync continues (all allow windows have overrun) +1. **Multiple allows, one without overrun → All end**: Sync is **blocked** (not all allow windows have overrun) + The UI and the CLI will both display the state of the sync windows. The UI has a panel which will display different colours depending on the state. The colours are as follows. `Red: sync denied`, `Orange: manual allowed` and `Green: sync allowed`. @@ -76,8 +115,28 @@ argocd proj windows add PROJECT \ --applications "*" ``` +To create a window with sync overrun enabled (allowing in-progress syncs to continue): + +```bash +# Allow window with overrun - syncs can continue after window ends +argocd proj windows add PROJECT \ + --kind allow \ + --schedule "0 9 * * *" \ + --duration 8h \ + --applications "*" \ + --sync-overrun + +# Deny window with overrun - in-progress syncs can continue during deny window +argocd proj windows add PROJECT \ + --kind deny \ + --schedule "0 22 * * *" \ + --duration 1h \ + --applications "*" \ + --sync-overrun +``` + Alternatively, they can be created directly in the `AppProject` manifest: - + ```yaml apiVersion: argoproj.io/v1alpha1 kind: AppProject @@ -91,12 +150,19 @@ spec: applications: - '*-prod' manualSync: true + - kind: allow + schedule: '0 9 * * *' + duration: 8h + applications: + - '*' + syncOverrun: true # Allow syncs to continue after window ends - kind: deny schedule: '0 22 * * *' timeZone: "Europe/Amsterdam" duration: 1h namespaces: - default + syncOverrun: true # Allow in-progress syncs to continue during deny window - kind: allow schedule: '0 23 * * *' duration: 1h @@ -112,12 +178,24 @@ using the CLI, UI or directly in the `AppProject` manifest: argocd proj windows enable-manual-sync PROJECT ID ``` -To disable +To disable: ```bash argocd proj windows disable-manual-sync PROJECT ID ``` +Similarly, you can enable or disable sync overrun for existing windows: + +```bash +argocd proj windows enable-sync-overrun PROJECT ID +``` + +To disable: + +```bash +argocd proj windows disable-sync-overrun PROJECT ID +``` + Windows can be listed using the CLI or viewed in the UI: ```bash @@ -125,11 +203,11 @@ argocd proj windows list PROJECT ``` ```bash -ID STATUS KIND SCHEDULE DURATION APPLICATIONS NAMESPACES CLUSTERS MANUALSYNC -0 Active allow * * * * * 1h - - prod1 Disabled -1 Inactive deny * * * * 1 3h - default - Disabled -2 Inactive allow 1 2 * * * 1h prod-* - - Enabled -3 Active deny * * * * * 1h - default - Disabled +ID STATUS KIND SCHEDULE DURATION APPLICATIONS NAMESPACES CLUSTERS MANUALSYNC SYNCOVERRUN TIMEZONE USEANDOPERATOR +0 Active allow * * * * * 1h - - prod1 Disabled Disabled UTC Disabled +1 Inactive deny * * * * 1 3h - default - Disabled Enabled UTC Disabled +2 Inactive allow 1 2 * * * 1h prod-* - - Enabled Disabled UTC Disabled +3 Active deny * * * * * 1h - default - Disabled Disabled UTC Disabled ``` All fields of a window can be updated using either the CLI or UI. The `applications`, `namespaces` and `clusters` fields diff --git a/manifests/core-install-with-hydrator.yaml b/manifests/core-install-with-hydrator.yaml index 6b43f9bbce..9ff527e328 100644 --- a/manifests/core-install-with-hydrator.yaml +++ b/manifests/core-install-with-hydrator.yaml @@ -30528,6 +30528,12 @@ spec: description: Schedule is the time the window will begin, specified in cron format type: string + syncOverrun: + description: |- + SyncOverrun allows ongoing syncs to continue in two scenarios: + For deny windows: allows syncs that started before the deny window became active to continue running + For allow windows: allows syncs that started during the allow window to continue after the window ends + type: boolean timeZone: description: TimeZone of the sync that will be applied to the schedule diff --git a/manifests/core-install.yaml b/manifests/core-install.yaml index c3afe405fc..7bdf5e8ed8 100644 --- a/manifests/core-install.yaml +++ b/manifests/core-install.yaml @@ -30528,6 +30528,12 @@ spec: description: Schedule is the time the window will begin, specified in cron format type: string + syncOverrun: + description: |- + SyncOverrun allows ongoing syncs to continue in two scenarios: + For deny windows: allows syncs that started before the deny window became active to continue running + For allow windows: allows syncs that started during the allow window to continue after the window ends + type: boolean timeZone: description: TimeZone of the sync that will be applied to the schedule diff --git a/manifests/crds/appproject-crd.yaml b/manifests/crds/appproject-crd.yaml index 766a84db17..d7c2c96d5b 100644 --- a/manifests/crds/appproject-crd.yaml +++ b/manifests/crds/appproject-crd.yaml @@ -329,6 +329,12 @@ spec: description: Schedule is the time the window will begin, specified in cron format type: string + syncOverrun: + description: |- + SyncOverrun allows ongoing syncs to continue in two scenarios: + For deny windows: allows syncs that started before the deny window became active to continue running + For allow windows: allows syncs that started during the allow window to continue after the window ends + type: boolean timeZone: description: TimeZone of the sync that will be applied to the schedule diff --git a/manifests/ha/install-with-hydrator.yaml b/manifests/ha/install-with-hydrator.yaml index 9ad0d354d2..d32689e051 100644 --- a/manifests/ha/install-with-hydrator.yaml +++ b/manifests/ha/install-with-hydrator.yaml @@ -30528,6 +30528,12 @@ spec: description: Schedule is the time the window will begin, specified in cron format type: string + syncOverrun: + description: |- + SyncOverrun allows ongoing syncs to continue in two scenarios: + For deny windows: allows syncs that started before the deny window became active to continue running + For allow windows: allows syncs that started during the allow window to continue after the window ends + type: boolean timeZone: description: TimeZone of the sync that will be applied to the schedule diff --git a/manifests/ha/install.yaml b/manifests/ha/install.yaml index 3a843129de..2a31ac3704 100644 --- a/manifests/ha/install.yaml +++ b/manifests/ha/install.yaml @@ -30528,6 +30528,12 @@ spec: description: Schedule is the time the window will begin, specified in cron format type: string + syncOverrun: + description: |- + SyncOverrun allows ongoing syncs to continue in two scenarios: + For deny windows: allows syncs that started before the deny window became active to continue running + For allow windows: allows syncs that started during the allow window to continue after the window ends + type: boolean timeZone: description: TimeZone of the sync that will be applied to the schedule diff --git a/manifests/install-with-hydrator.yaml b/manifests/install-with-hydrator.yaml index 8d409690dd..6ac649d5ac 100644 --- a/manifests/install-with-hydrator.yaml +++ b/manifests/install-with-hydrator.yaml @@ -30528,6 +30528,12 @@ spec: description: Schedule is the time the window will begin, specified in cron format type: string + syncOverrun: + description: |- + SyncOverrun allows ongoing syncs to continue in two scenarios: + For deny windows: allows syncs that started before the deny window became active to continue running + For allow windows: allows syncs that started during the allow window to continue after the window ends + type: boolean timeZone: description: TimeZone of the sync that will be applied to the schedule diff --git a/manifests/install.yaml b/manifests/install.yaml index 537c063ad4..a427769f6f 100644 --- a/manifests/install.yaml +++ b/manifests/install.yaml @@ -30528,6 +30528,12 @@ spec: description: Schedule is the time the window will begin, specified in cron format type: string + syncOverrun: + description: |- + SyncOverrun allows ongoing syncs to continue in two scenarios: + For deny windows: allows syncs that started before the deny window became active to continue running + For allow windows: allows syncs that started during the allow window to continue after the window ends + type: boolean timeZone: description: TimeZone of the sync that will be applied to the schedule diff --git a/pkg/apis/application/v1alpha1/generated.pb.go b/pkg/apis/application/v1alpha1/generated.pb.go index 5a7a071933..6657853c05 100644 --- a/pkg/apis/application/v1alpha1/generated.pb.go +++ b/pkg/apis/application/v1alpha1/generated.pb.go @@ -4972,803 +4972,804 @@ func init() { } var fileDescriptor_c078c3c476799f44 = []byte{ - // 12739 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x7d, 0x70, 0x1c, 0xc9, - 0x75, 0x18, 0xae, 0xd9, 0xc5, 0x02, 0xbb, 0x0f, 0x1f, 0x24, 0x9a, 0xe4, 0x1d, 0xc8, 0xe3, 0x11, - 0xd4, 0x9c, 0x75, 0x3a, 0xff, 0x74, 0x02, 0x2d, 0x4a, 0x27, 0xdf, 0xcf, 0x67, 0xcb, 0xc1, 0x02, - 0xfc, 0x00, 0x09, 0x10, 0x50, 0x2f, 0x48, 0xea, 0xeb, 0x24, 0x0d, 0x66, 0x1b, 0xc0, 0x10, 0xb3, - 0x33, 0x7b, 0x33, 0xb3, 0x20, 0xf7, 0x2c, 0xcb, 0x92, 0x25, 0xd9, 0x92, 0x25, 0x4b, 0x17, 0x3b, - 0x15, 0x9f, 0x93, 0x48, 0x91, 0x63, 0xe7, 0xa3, 0x2a, 0xe5, 0xd8, 0x89, 0xab, 0x12, 0x57, 0x6c, - 0x97, 0x2b, 0xb6, 0xcb, 0x65, 0x57, 0x9c, 0xd8, 0x71, 0x39, 0xb6, 0x13, 0xc7, 0x88, 0xc4, 0x54, - 0xca, 0xae, 0x54, 0xc5, 0x29, 0x27, 0xa9, 0x54, 0x8a, 0x71, 0x5c, 0xa9, 0xfe, 0xee, 0x99, 0x9d, - 0x05, 0x16, 0xc4, 0x00, 0xa4, 0xec, 0xfb, 0x6f, 0xb7, 0xdf, 0x9b, 0xf7, 0x7a, 0x7a, 0xba, 0xdf, - 0x7b, 0xfd, 0xfa, 0xbd, 0xd7, 0xb0, 0xb8, 0xe1, 0x25, 0x9b, 0x9d, 0xb5, 0x19, 0x37, 0x6c, 0x5d, - 0x70, 0xa2, 0x8d, 0xb0, 0x1d, 0x85, 0x77, 0xd8, 0x8f, 0xb7, 0xbb, 0xcd, 0x0b, 0xdb, 0xef, 0xbc, - 0xd0, 0xde, 0xda, 0xb8, 0xe0, 0xb4, 0xbd, 0xf8, 0x82, 0xd3, 0x6e, 0xfb, 0x9e, 0xeb, 0x24, 0x5e, - 0x18, 0x5c, 0xd8, 0x7e, 0x87, 0xe3, 0xb7, 0x37, 0x9d, 0x77, 0x5c, 0xd8, 0x20, 0x01, 0x89, 0x9c, - 0x84, 0x34, 0x67, 0xda, 0x51, 0x98, 0x84, 0xe8, 0xdb, 0x35, 0xb5, 0x19, 0x49, 0x8d, 0xfd, 0xf8, - 0x88, 0xdb, 0x9c, 0xd9, 0x7e, 0xe7, 0x4c, 0x7b, 0x6b, 0x63, 0x86, 0x52, 0x9b, 0x31, 0xa8, 0xcd, - 0x48, 0x6a, 0x67, 0xde, 0x6e, 0xf4, 0x65, 0x23, 0xdc, 0x08, 0x2f, 0x30, 0xa2, 0x6b, 0x9d, 0x75, - 0xf6, 0x8f, 0xfd, 0x61, 0xbf, 0x38, 0xb3, 0x33, 0xf6, 0xd6, 0x8b, 0xf1, 0x8c, 0x17, 0xd2, 0xee, - 0x5d, 0x70, 0xc3, 0x88, 0x5c, 0xd8, 0xee, 0xe9, 0xd0, 0x99, 0xab, 0x1a, 0x87, 0xdc, 0x4b, 0x48, - 0x10, 0x7b, 0x61, 0x10, 0xbf, 0x9d, 0x76, 0x81, 0x44, 0xdb, 0x24, 0x32, 0x5f, 0xcf, 0x40, 0xc8, - 0xa3, 0xf4, 0x2e, 0x4d, 0xa9, 0xe5, 0xb8, 0x9b, 0x5e, 0x40, 0xa2, 0xae, 0x7e, 0xbc, 0x45, 0x12, - 0x27, 0xef, 0xa9, 0x0b, 0xfd, 0x9e, 0x8a, 0x3a, 0x41, 0xe2, 0xb5, 0x48, 0xcf, 0x03, 0xef, 0xde, - 0xeb, 0x81, 0xd8, 0xdd, 0x24, 0x2d, 0xa7, 0xe7, 0xb9, 0x77, 0xf6, 0x7b, 0xae, 0x93, 0x78, 0xfe, - 0x05, 0x2f, 0x48, 0xe2, 0x24, 0xca, 0x3e, 0x64, 0xff, 0x2d, 0x0b, 0xc6, 0x67, 0x6f, 0x37, 0x66, - 0x3b, 0xc9, 0xe6, 0x5c, 0x18, 0xac, 0x7b, 0x1b, 0xe8, 0x05, 0x18, 0x75, 0xfd, 0x4e, 0x9c, 0x90, - 0xe8, 0x86, 0xd3, 0x22, 0x53, 0xd6, 0x79, 0xeb, 0xb9, 0x5a, 0xfd, 0xc4, 0xaf, 0xed, 0x4c, 0xbf, - 0xe9, 0xfe, 0xce, 0xf4, 0xe8, 0x9c, 0x06, 0x61, 0x13, 0x0f, 0x7d, 0x33, 0x8c, 0x44, 0xa1, 0x4f, - 0x66, 0xf1, 0x8d, 0xa9, 0x12, 0x7b, 0xe4, 0x98, 0x78, 0x64, 0x04, 0xf3, 0x66, 0x2c, 0xe1, 0x14, - 0xb5, 0x1d, 0x85, 0xeb, 0x9e, 0x4f, 0xa6, 0xca, 0x69, 0xd4, 0x15, 0xde, 0x8c, 0x25, 0xdc, 0xfe, - 0xb1, 0x12, 0x1c, 0x9b, 0x6d, 0xb7, 0xaf, 0x12, 0xc7, 0x4f, 0x36, 0x1b, 0x89, 0x93, 0x74, 0x62, - 0x14, 0xc2, 0x70, 0xcc, 0x7e, 0x89, 0xbe, 0xdd, 0x16, 0x4f, 0x0f, 0x73, 0xf8, 0x83, 0x9d, 0xe9, - 0x4b, 0xbb, 0xcd, 0xe8, 0x0d, 0x2f, 0x09, 0xdb, 0xf1, 0xdb, 0x49, 0xb0, 0xe1, 0x05, 0x84, 0x8d, - 0xcf, 0x26, 0xa3, 0x3e, 0x63, 0x32, 0x99, 0x0b, 0x9b, 0x04, 0x0b, 0x36, 0xb4, 0xbf, 0x2d, 0x12, - 0xc7, 0xce, 0x06, 0xc9, 0xbe, 0xda, 0x12, 0x6f, 0xc6, 0x12, 0x8e, 0x22, 0x40, 0xbe, 0x13, 0x27, - 0xab, 0x91, 0x13, 0xc4, 0x1e, 0x9d, 0xda, 0xab, 0x5e, 0x8b, 0xbf, 0xe5, 0xe8, 0xc5, 0xff, 0x6f, - 0x86, 0x7f, 0xa0, 0x19, 0xf3, 0x03, 0xe9, 0xf5, 0x40, 0xe7, 0xcf, 0xcc, 0xf6, 0x3b, 0x66, 0xe8, - 0x13, 0xf5, 0x27, 0xee, 0xef, 0x4c, 0xa3, 0xc5, 0x1e, 0x4a, 0x38, 0x87, 0xba, 0xfd, 0xbb, 0x25, - 0x80, 0xd9, 0x76, 0x7b, 0x25, 0x0a, 0xef, 0x10, 0x37, 0x41, 0x1f, 0x85, 0x2a, 0x25, 0xd5, 0x74, - 0x12, 0x87, 0x0d, 0xd0, 0xe8, 0xc5, 0x6f, 0x19, 0x8c, 0xf1, 0xf2, 0x1a, 0x7d, 0x7e, 0x89, 0x24, - 0x4e, 0x1d, 0x89, 0x17, 0x04, 0xdd, 0x86, 0x15, 0x55, 0x14, 0xc0, 0x50, 0xdc, 0x26, 0x2e, 0x1b, - 0x8c, 0xd1, 0x8b, 0x8b, 0x33, 0x07, 0x59, 0xf1, 0x33, 0xba, 0xe7, 0x8d, 0x36, 0x71, 0xeb, 0x63, - 0x82, 0xf3, 0x10, 0xfd, 0x87, 0x19, 0x1f, 0xb4, 0xad, 0x3e, 0x38, 0x1f, 0xc8, 0x1b, 0x85, 0x71, - 0x64, 0x54, 0xeb, 0x13, 0xe9, 0x09, 0x24, 0xbf, 0xbb, 0xfd, 0x87, 0x16, 0x4c, 0x68, 0xe4, 0x45, - 0x2f, 0x4e, 0xd0, 0x87, 0x7a, 0x06, 0x77, 0x66, 0xb0, 0xc1, 0xa5, 0x4f, 0xb3, 0xa1, 0x3d, 0x2e, - 0x98, 0x55, 0x65, 0x8b, 0x31, 0xb0, 0x2d, 0xa8, 0x78, 0x09, 0x69, 0xc5, 0x53, 0xa5, 0xf3, 0xe5, - 0xe7, 0x46, 0x2f, 0x5e, 0x2d, 0xea, 0x3d, 0xeb, 0xe3, 0x82, 0x69, 0x65, 0x81, 0x92, 0xc7, 0x9c, - 0x8b, 0xfd, 0x1b, 0x13, 0xe6, 0xfb, 0xd1, 0x01, 0x47, 0xef, 0x80, 0xd1, 0x38, 0xec, 0x44, 0x2e, - 0xc1, 0xa4, 0x1d, 0xd2, 0x05, 0x56, 0xa6, 0xd3, 0x9d, 0x2e, 0xfc, 0x86, 0x6e, 0xc6, 0x26, 0x0e, - 0xfa, 0xa2, 0x05, 0x63, 0x4d, 0x12, 0x27, 0x5e, 0xc0, 0xf8, 0xcb, 0xce, 0xaf, 0x1e, 0xb8, 0xf3, - 0xb2, 0x71, 0x5e, 0x13, 0xaf, 0x9f, 0x14, 0x2f, 0x32, 0x66, 0x34, 0xc6, 0x38, 0xc5, 0x9f, 0x0a, - 0xb0, 0x26, 0x89, 0xdd, 0xc8, 0x6b, 0xd3, 0xff, 0x42, 0xc4, 0x28, 0x01, 0x36, 0xaf, 0x41, 0xd8, - 0xc4, 0x43, 0x01, 0x54, 0xa8, 0x80, 0x8a, 0xa7, 0x86, 0x58, 0xff, 0x17, 0x0e, 0xd6, 0x7f, 0x31, - 0xa8, 0x54, 0xf6, 0xe9, 0xd1, 0xa7, 0xff, 0x62, 0xcc, 0xd9, 0xa0, 0x7f, 0x6e, 0xc1, 0x94, 0x10, - 0xa0, 0x98, 0xf0, 0x01, 0xbd, 0xbd, 0xe9, 0x25, 0xc4, 0xf7, 0xe2, 0x64, 0xaa, 0xc2, 0xfa, 0xf0, - 0xa1, 0x83, 0xf5, 0x61, 0x2e, 0x4d, 0x1d, 0x93, 0x38, 0x89, 0x3c, 0x97, 0xe2, 0xd0, 0x69, 0x50, - 0x3f, 0x2f, 0xba, 0x35, 0x35, 0xd7, 0xa7, 0x17, 0xb8, 0x6f, 0xff, 0xd0, 0x0f, 0x5b, 0x70, 0x26, - 0x70, 0x5a, 0x24, 0x6e, 0x3b, 0x8c, 0x30, 0x03, 0xd7, 0x7d, 0xc7, 0xdd, 0x62, 0xdd, 0x1f, 0x66, - 0xdd, 0xbf, 0x30, 0xd8, 0xd2, 0xb8, 0x12, 0x85, 0x9d, 0xf6, 0x75, 0x2f, 0x68, 0xd6, 0x6d, 0xd1, - 0xa3, 0x33, 0x37, 0xfa, 0x92, 0xc6, 0xbb, 0xb0, 0x45, 0x3f, 0x6e, 0xc1, 0x64, 0x18, 0xb5, 0x37, - 0x9d, 0x80, 0x34, 0x25, 0x34, 0x9e, 0x1a, 0x61, 0xeb, 0xf4, 0xc3, 0x07, 0x1b, 0xcb, 0xe5, 0x2c, - 0xd9, 0xa5, 0x30, 0xf0, 0x92, 0x30, 0x6a, 0x90, 0x24, 0xf1, 0x82, 0x8d, 0xb8, 0x7e, 0xea, 0xfe, - 0xce, 0xf4, 0x64, 0x0f, 0x16, 0xee, 0xed, 0x0f, 0xfa, 0x2e, 0x18, 0x8d, 0xbb, 0x81, 0x7b, 0xdb, - 0x0b, 0x9a, 0xe1, 0xdd, 0x78, 0xaa, 0x5a, 0xc4, 0x5a, 0x6f, 0x28, 0x82, 0x62, 0xb5, 0x6a, 0x06, - 0xd8, 0xe4, 0x96, 0xff, 0xe1, 0xf4, 0xbc, 0xab, 0x15, 0xfd, 0xe1, 0xf4, 0x64, 0xda, 0x85, 0x2d, - 0xfa, 0x7e, 0x0b, 0xc6, 0x63, 0x6f, 0x23, 0x70, 0x92, 0x4e, 0x44, 0xae, 0x93, 0x6e, 0x3c, 0x05, - 0xac, 0x23, 0xd7, 0x0e, 0x38, 0x2a, 0x06, 0xc9, 0xfa, 0x29, 0xd1, 0xc7, 0x71, 0xb3, 0x35, 0xc6, - 0x69, 0xbe, 0x79, 0xab, 0x52, 0x4f, 0xeb, 0xd1, 0x47, 0xb8, 0x2a, 0xf5, 0x0a, 0xe8, 0xdb, 0x3f, - 0xf4, 0x57, 0xe0, 0x38, 0x6f, 0x52, 0x9f, 0x21, 0x9e, 0x1a, 0x63, 0x22, 0xfc, 0xe4, 0xfd, 0x9d, - 0xe9, 0xe3, 0x8d, 0x0c, 0x0c, 0xf7, 0x60, 0xa3, 0x57, 0x60, 0xba, 0x4d, 0xa2, 0x96, 0x97, 0x2c, - 0x07, 0x7e, 0x57, 0x2a, 0x06, 0x37, 0x6c, 0x93, 0xa6, 0xe8, 0x4e, 0x3c, 0x35, 0x7e, 0xde, 0x7a, - 0xae, 0x5a, 0x7f, 0xab, 0xe8, 0xe6, 0xf4, 0xca, 0xee, 0xe8, 0x78, 0x2f, 0x7a, 0xe8, 0x57, 0x2d, - 0x38, 0x63, 0xc8, 0xef, 0x06, 0x89, 0xb6, 0x3d, 0x97, 0xcc, 0xba, 0x6e, 0xd8, 0x09, 0x92, 0x78, - 0x6a, 0x82, 0x8d, 0xf9, 0xda, 0x61, 0x68, 0x93, 0x34, 0x2b, 0x3d, 0x89, 0xfb, 0xa2, 0xc4, 0x78, - 0x97, 0x9e, 0xda, 0xbf, 0x5e, 0x82, 0xe3, 0x59, 0xdb, 0x02, 0xfd, 0x3d, 0x0b, 0x8e, 0xdd, 0xb9, - 0x9b, 0xac, 0x86, 0x5b, 0x24, 0x88, 0xeb, 0x5d, 0xaa, 0x01, 0x98, 0x56, 0x1d, 0xbd, 0xe8, 0x16, - 0x6b, 0xc5, 0xcc, 0x5c, 0x4b, 0x73, 0xb9, 0x14, 0x24, 0x51, 0xb7, 0xfe, 0xa4, 0x78, 0xa7, 0x63, - 0xd7, 0x6e, 0xaf, 0x9a, 0x50, 0x9c, 0xed, 0xd4, 0x99, 0xcf, 0x5b, 0x70, 0x32, 0x8f, 0x04, 0x3a, - 0x0e, 0xe5, 0x2d, 0xd2, 0xe5, 0xb6, 0x36, 0xa6, 0x3f, 0xd1, 0xcb, 0x50, 0xd9, 0x76, 0xfc, 0x0e, - 0x11, 0x06, 0xe0, 0x95, 0x83, 0xbd, 0x88, 0xea, 0x19, 0xe6, 0x54, 0xbf, 0xad, 0xf4, 0xa2, 0x65, - 0xff, 0x66, 0x19, 0x46, 0x8d, 0x8f, 0x76, 0x04, 0x46, 0x6d, 0x98, 0x32, 0x6a, 0x97, 0x0a, 0x9b, - 0x6f, 0x7d, 0xad, 0xda, 0xbb, 0x19, 0xab, 0x76, 0xb9, 0x38, 0x96, 0xbb, 0x9a, 0xb5, 0x28, 0x81, - 0x5a, 0xd8, 0xa6, 0x9b, 0x40, 0x6a, 0x1d, 0x0d, 0x15, 0xf1, 0x09, 0x97, 0x25, 0xb9, 0xfa, 0xf8, - 0xfd, 0x9d, 0xe9, 0x9a, 0xfa, 0x8b, 0x35, 0x23, 0xfb, 0xf7, 0x2c, 0x38, 0x69, 0xf4, 0x71, 0x2e, - 0x0c, 0x9a, 0x6c, 0x0b, 0x83, 0xce, 0xc3, 0x50, 0xd2, 0x6d, 0xcb, 0x8d, 0xa6, 0x1a, 0xa9, 0xd5, - 0x6e, 0x9b, 0x60, 0x06, 0x79, 0xdc, 0xf7, 0x5f, 0x3f, 0x6c, 0xc1, 0x13, 0xf9, 0x02, 0x06, 0x3d, - 0x0b, 0xc3, 0xdc, 0xcb, 0x20, 0xde, 0x4e, 0x7f, 0x12, 0xd6, 0x8a, 0x05, 0x14, 0x5d, 0x80, 0x9a, - 0xd2, 0x8e, 0xe2, 0x1d, 0x27, 0x05, 0x6a, 0x4d, 0xab, 0x54, 0x8d, 0x43, 0x07, 0x8d, 0xfe, 0x11, - 0xc6, 0xad, 0x1a, 0x34, 0xb6, 0x2d, 0x67, 0x10, 0xfb, 0x77, 0x2c, 0xf8, 0xa6, 0x41, 0xc4, 0xde, - 0xe1, 0xf5, 0xb1, 0x01, 0xa7, 0x9a, 0x64, 0xdd, 0xe9, 0xf8, 0x49, 0x9a, 0xa3, 0xe8, 0xf4, 0xd3, - 0xe2, 0xe1, 0x53, 0xf3, 0x79, 0x48, 0x38, 0xff, 0x59, 0xfb, 0x3f, 0x5a, 0xcc, 0x21, 0x20, 0x5f, - 0xeb, 0x08, 0x36, 0x65, 0x41, 0x7a, 0x53, 0xb6, 0x50, 0xd8, 0x32, 0xed, 0xb3, 0x2b, 0xfb, 0x41, - 0x0b, 0xce, 0x18, 0x58, 0x4b, 0x4e, 0xe2, 0x6e, 0x5e, 0xba, 0xd7, 0x8e, 0x48, 0x1c, 0xd3, 0x29, - 0xf5, 0xb4, 0x21, 0x8e, 0xeb, 0xa3, 0x82, 0x42, 0xf9, 0x3a, 0xe9, 0x72, 0xd9, 0xfc, 0x3c, 0x54, - 0xf9, 0x9a, 0x0b, 0x23, 0xf1, 0x91, 0xd4, 0xbb, 0x2d, 0x8b, 0x76, 0xac, 0x30, 0x90, 0x0d, 0xc3, - 0x4c, 0xe6, 0x52, 0x19, 0x44, 0xcd, 0x04, 0xa0, 0xdf, 0xfd, 0x16, 0x6b, 0xc1, 0x02, 0x62, 0xc7, - 0xa9, 0xee, 0xac, 0x44, 0x84, 0xcd, 0x87, 0xe6, 0x65, 0x8f, 0xf8, 0xcd, 0x98, 0x6e, 0x18, 0x9d, - 0x20, 0x08, 0x13, 0xb1, 0xf7, 0x33, 0x36, 0x8c, 0xb3, 0xba, 0x19, 0x9b, 0x38, 0x94, 0xa9, 0xef, - 0xac, 0x11, 0x9f, 0x8f, 0xa8, 0x60, 0xba, 0xc8, 0x5a, 0xb0, 0x80, 0xd8, 0xf7, 0x4b, 0x6c, 0x6b, - 0xaa, 0x24, 0x1a, 0x39, 0x0a, 0xbf, 0x46, 0x94, 0x52, 0x01, 0x2b, 0xc5, 0xc9, 0x63, 0xd2, 0xdf, - 0xb7, 0xf1, 0x6a, 0x46, 0x0b, 0xe0, 0x42, 0xb9, 0xee, 0xee, 0xdf, 0xf8, 0x72, 0x19, 0xa6, 0xd3, - 0x0f, 0xf4, 0x28, 0x11, 0xba, 0x99, 0x36, 0x18, 0x65, 0xbd, 0x81, 0x06, 0x3e, 0x36, 0xf1, 0xfa, - 0xc8, 0xe1, 0xd2, 0x61, 0xca, 0x61, 0x53, 0x4d, 0x94, 0xf7, 0x50, 0x13, 0x73, 0x6a, 0xd4, 0x87, - 0x18, 0xe6, 0xdb, 0x7a, 0x5c, 0x88, 0xa7, 0x57, 0xa2, 0x70, 0x83, 0xad, 0xb9, 0x6d, 0x42, 0x37, - 0x53, 0x39, 0x6e, 0xc1, 0xf3, 0x30, 0x14, 0x27, 0xa4, 0x3d, 0x55, 0x49, 0xcb, 0xe0, 0x46, 0x42, - 0xda, 0x98, 0x41, 0xd0, 0x77, 0xc0, 0xb1, 0xc4, 0x89, 0x36, 0x48, 0x12, 0x91, 0x6d, 0x8f, 0xb9, - 0x95, 0xd9, 0xce, 0xb8, 0x56, 0x3f, 0x41, 0x4d, 0xb2, 0x55, 0x06, 0xc2, 0x12, 0x84, 0xb3, 0xb8, - 0xf6, 0x7f, 0x29, 0xc1, 0x93, 0xe9, 0xef, 0xa3, 0xb5, 0xe6, 0x77, 0xa6, 0xb4, 0xe6, 0xdb, 0x4c, - 0xad, 0xf9, 0x60, 0x67, 0xfa, 0xa9, 0x3e, 0x8f, 0x7d, 0xc3, 0x28, 0x55, 0x74, 0x25, 0xf3, 0x85, - 0x2e, 0xf4, 0x7c, 0xa1, 0xa7, 0xfb, 0xbc, 0x63, 0xc6, 0xda, 0x79, 0x16, 0x86, 0x23, 0xe2, 0xc4, - 0x61, 0x20, 0xbe, 0x93, 0x5a, 0x0c, 0x98, 0xb5, 0x62, 0x01, 0xb5, 0x7f, 0xbb, 0x96, 0x1d, 0xec, - 0x2b, 0xdc, 0x55, 0x1e, 0x46, 0xc8, 0x83, 0x21, 0xb6, 0xff, 0xe3, 0x62, 0xe7, 0xfa, 0xc1, 0x96, - 0x28, 0x55, 0x31, 0x8a, 0x74, 0xbd, 0x4a, 0xbf, 0x1a, 0x6d, 0xc2, 0x8c, 0x05, 0xba, 0x07, 0x55, - 0x57, 0xee, 0xb4, 0x4a, 0x45, 0x78, 0x3b, 0xc5, 0x3e, 0x4b, 0x73, 0x1c, 0xa3, 0xba, 0x40, 0x6d, - 0xcf, 0x14, 0x37, 0x44, 0xa0, 0xbc, 0xe1, 0x25, 0xe2, 0xb3, 0x1e, 0x70, 0xe3, 0x7d, 0xc5, 0x33, - 0x5e, 0x71, 0x84, 0x2a, 0xa8, 0x2b, 0x5e, 0x82, 0x29, 0x7d, 0xf4, 0x19, 0x0b, 0x46, 0x63, 0xb7, - 0xb5, 0x12, 0x85, 0xdb, 0x5e, 0x93, 0x44, 0xc2, 0x00, 0x3d, 0xa0, 0xd8, 0x6b, 0xcc, 0x2d, 0x49, - 0x82, 0x9a, 0x2f, 0x77, 0x84, 0x68, 0x08, 0x36, 0xf9, 0xd2, 0x8d, 0xd9, 0x93, 0xe2, 0xdd, 0xe7, - 0x89, 0xcb, 0x56, 0x9c, 0xdc, 0x50, 0xb3, 0x99, 0x72, 0x60, 0x83, 0x7c, 0xbe, 0xe3, 0x6e, 0xd1, - 0xf5, 0xa6, 0x3b, 0xf4, 0xd4, 0xfd, 0x9d, 0xe9, 0x27, 0xe7, 0xf2, 0x79, 0xe2, 0x7e, 0x9d, 0x61, - 0x03, 0xd6, 0xee, 0xf8, 0x3e, 0x26, 0xaf, 0x74, 0x08, 0xf3, 0xad, 0x15, 0x30, 0x60, 0x2b, 0x9a, - 0x60, 0x66, 0xc0, 0x0c, 0x08, 0x36, 0xf9, 0xa2, 0x57, 0x60, 0xb8, 0xe5, 0x24, 0x91, 0x77, 0x4f, - 0x38, 0xd4, 0x0e, 0xb8, 0x45, 0x5a, 0x62, 0xb4, 0x34, 0x73, 0x66, 0x05, 0xf0, 0x46, 0x2c, 0x18, - 0xa1, 0x16, 0x54, 0x5a, 0x24, 0xda, 0x20, 0x53, 0xd5, 0x22, 0x4e, 0x1a, 0x96, 0x28, 0x29, 0xcd, - 0xb0, 0x46, 0x2d, 0x2f, 0xd6, 0x86, 0x39, 0x17, 0xf4, 0x32, 0x54, 0x63, 0xe2, 0x13, 0x97, 0xda, - 0x4e, 0x35, 0xc6, 0xf1, 0x9d, 0x03, 0xda, 0x91, 0xd4, 0x68, 0x69, 0x88, 0x47, 0xf9, 0x02, 0x93, - 0xff, 0xb0, 0x22, 0x49, 0x07, 0xb0, 0xed, 0x77, 0x36, 0xbc, 0x60, 0x0a, 0x8a, 0x18, 0xc0, 0x15, - 0x46, 0x2b, 0x33, 0x80, 0xbc, 0x11, 0x0b, 0x46, 0xf6, 0x7f, 0xb6, 0x00, 0xa5, 0x85, 0xda, 0x11, - 0x18, 0xcc, 0xaf, 0xa4, 0x0d, 0xe6, 0xc5, 0x22, 0x2d, 0x9a, 0x3e, 0x36, 0xf3, 0xcf, 0xd5, 0x20, - 0xa3, 0x0e, 0x6e, 0x90, 0x38, 0x21, 0xcd, 0x37, 0x44, 0xf8, 0x1b, 0x22, 0xfc, 0x0d, 0x11, 0xae, - 0x44, 0xf8, 0x5a, 0x46, 0x84, 0xbf, 0xc7, 0x58, 0xf5, 0x3a, 0xf4, 0xe1, 0x23, 0x2a, 0x36, 0xc2, - 0xec, 0x81, 0x81, 0x40, 0x25, 0xc1, 0xb5, 0xc6, 0xf2, 0x8d, 0x5c, 0x99, 0xfd, 0x91, 0xb4, 0xcc, - 0x3e, 0x28, 0x8b, 0xbf, 0x0c, 0x52, 0xfa, 0x57, 0x2d, 0x78, 0x6b, 0x5a, 0x7a, 0xc9, 0x99, 0xb3, - 0xb0, 0x11, 0x84, 0x11, 0x99, 0xf7, 0xd6, 0xd7, 0x49, 0x44, 0x02, 0x97, 0xc4, 0xca, 0xf1, 0x63, - 0xf5, 0x73, 0xfc, 0xa0, 0x77, 0xc1, 0xd8, 0x9d, 0x38, 0x0c, 0x56, 0x42, 0x2f, 0x10, 0x22, 0x88, - 0xee, 0x38, 0x8e, 0xdf, 0xdf, 0x99, 0x1e, 0xa3, 0x23, 0x2a, 0xdb, 0x71, 0x0a, 0x0b, 0xcd, 0xc1, - 0xe4, 0x9d, 0x57, 0x56, 0x9c, 0xc4, 0x70, 0x35, 0x48, 0xa7, 0x00, 0x3b, 0xd9, 0xba, 0xf6, 0xde, - 0x0c, 0x10, 0xf7, 0xe2, 0xdb, 0x7f, 0xb3, 0x04, 0xa7, 0x33, 0x2f, 0x12, 0xfa, 0x7e, 0xd8, 0x49, - 0xe8, 0x9e, 0x08, 0x7d, 0xc5, 0x82, 0xe3, 0xad, 0xb4, 0x37, 0x23, 0x16, 0xbe, 0xf0, 0xf7, 0x15, - 0xa6, 0x23, 0x32, 0xee, 0x92, 0xfa, 0x94, 0x18, 0xa1, 0xe3, 0x19, 0x40, 0x8c, 0x7b, 0xfa, 0x82, - 0x5e, 0x86, 0x5a, 0xcb, 0xb9, 0x77, 0xb3, 0xdd, 0x74, 0x12, 0xb9, 0x57, 0xed, 0xef, 0x62, 0xe8, - 0x24, 0x9e, 0x3f, 0xc3, 0x83, 0x6a, 0x66, 0x16, 0x82, 0x64, 0x39, 0x6a, 0x24, 0x91, 0x17, 0x6c, - 0x70, 0x0f, 0xe8, 0x92, 0x24, 0x83, 0x35, 0x45, 0xfb, 0xcb, 0x56, 0x56, 0x49, 0xa9, 0xd1, 0x89, - 0x9c, 0x84, 0x6c, 0x74, 0xd1, 0xc7, 0xa0, 0x42, 0xf7, 0x8d, 0x72, 0x54, 0x6e, 0x17, 0xa9, 0x39, - 0x8d, 0x2f, 0xa1, 0x95, 0x28, 0xfd, 0x17, 0x63, 0xce, 0xd4, 0xfe, 0x4a, 0x2d, 0x6b, 0x2c, 0xb0, - 0x90, 0x80, 0x8b, 0x00, 0x1b, 0xe1, 0x2a, 0x69, 0xb5, 0x7d, 0x3a, 0x2c, 0x16, 0x3b, 0xfd, 0x51, - 0x7e, 0x94, 0x2b, 0x0a, 0x82, 0x0d, 0x2c, 0xf4, 0x39, 0x0b, 0x60, 0x43, 0xce, 0x79, 0x69, 0x08, - 0xdc, 0x2c, 0xf2, 0x75, 0xf4, 0x8a, 0xd2, 0x7d, 0x51, 0x0c, 0xb1, 0xc1, 0x1c, 0x7d, 0xaf, 0x05, - 0xd5, 0x44, 0x76, 0x9f, 0xab, 0xc6, 0xd5, 0x22, 0x7b, 0x22, 0x5f, 0x5a, 0xdb, 0x44, 0x6a, 0x48, - 0x14, 0x5f, 0xf4, 0x7d, 0x16, 0x40, 0xdc, 0x0d, 0xdc, 0x95, 0xd0, 0xf7, 0xdc, 0xae, 0xd0, 0x98, - 0xb7, 0x0a, 0xf5, 0xf5, 0x28, 0xea, 0xf5, 0x09, 0x3a, 0x1a, 0xfa, 0x3f, 0x36, 0x38, 0xa3, 0x8f, - 0x43, 0x35, 0x16, 0xd3, 0x4d, 0xe8, 0xc8, 0xd5, 0x62, 0x3d, 0x4e, 0x9c, 0xb6, 0x10, 0xaf, 0xe2, - 0x1f, 0x56, 0x3c, 0xd1, 0x8f, 0x58, 0x70, 0xac, 0x9d, 0xf6, 0x21, 0x0a, 0x75, 0x58, 0x9c, 0x0c, - 0xc8, 0xf8, 0x28, 0xb9, 0xb7, 0x25, 0xd3, 0x88, 0xb3, 0xbd, 0xa0, 0x12, 0x50, 0xcf, 0xe0, 0xe5, - 0x36, 0xf7, 0x67, 0x8e, 0x68, 0x09, 0x78, 0x25, 0x0b, 0xc4, 0xbd, 0xf8, 0x68, 0x05, 0x4e, 0xd2, - 0xde, 0x75, 0xb9, 0xf9, 0x29, 0xd5, 0x4b, 0xcc, 0x94, 0x61, 0xb5, 0x7e, 0x56, 0xcc, 0x10, 0x76, - 0x10, 0x92, 0xc5, 0xc1, 0xb9, 0x4f, 0xa2, 0xdf, 0xb4, 0xe0, 0xac, 0xc7, 0xd4, 0x80, 0xe9, 0xcd, - 0xd7, 0x1a, 0x41, 0x1c, 0xd9, 0x93, 0x42, 0x65, 0x45, 0x3f, 0xf5, 0x53, 0xff, 0x26, 0xf1, 0x06, - 0x67, 0x17, 0x76, 0xe9, 0x12, 0xde, 0xb5, 0xc3, 0xe8, 0x5b, 0x61, 0x5c, 0xae, 0x8b, 0x15, 0x2a, - 0x82, 0x99, 0xa2, 0xad, 0xd5, 0x27, 0xef, 0xef, 0x4c, 0x8f, 0xaf, 0x9a, 0x00, 0x9c, 0xc6, 0xb3, - 0xff, 0x7c, 0x28, 0x75, 0x84, 0xa4, 0x1c, 0x9c, 0x4c, 0xdc, 0xb8, 0xd2, 0xff, 0x23, 0xa5, 0x67, - 0xa1, 0xe2, 0x46, 0x79, 0x97, 0xb4, 0xb8, 0x51, 0x4d, 0x31, 0x36, 0x98, 0x53, 0xa3, 0x74, 0xd2, - 0xc9, 0xba, 0x51, 0x85, 0x04, 0x7c, 0xb9, 0xc8, 0x2e, 0xf5, 0x1e, 0xf8, 0x9d, 0x16, 0x5d, 0x9b, - 0xec, 0x01, 0xe1, 0xde, 0x2e, 0xa1, 0xef, 0x86, 0x5a, 0xa4, 0x62, 0x64, 0xca, 0x45, 0x6c, 0xd5, - 0xe4, 0xb4, 0x11, 0xdd, 0x51, 0xa7, 0x43, 0x3a, 0x1a, 0x46, 0x73, 0x44, 0xef, 0x81, 0x09, 0xf5, - 0x67, 0x8e, 0x1d, 0x0b, 0x51, 0xa1, 0x58, 0xae, 0x3f, 0x21, 0x9e, 0x9a, 0xc0, 0x29, 0x28, 0xce, - 0x60, 0xa3, 0x08, 0x86, 0x79, 0xdc, 0xa6, 0x10, 0x63, 0x07, 0xdc, 0xee, 0x98, 0xc1, 0x9f, 0xda, - 0x47, 0xc8, 0x5b, 0xb1, 0xe0, 0x64, 0x7f, 0xb6, 0x94, 0x3a, 0xe9, 0x33, 0xe4, 0xdd, 0x00, 0xa7, - 0x98, 0x5f, 0xb4, 0x60, 0x34, 0x0a, 0x7d, 0xdf, 0x0b, 0x36, 0xa8, 0x6c, 0x16, 0x06, 0xc6, 0x07, - 0x0f, 0x45, 0xc7, 0x0b, 0x21, 0xcc, 0x76, 0x03, 0x58, 0xf3, 0xc4, 0x66, 0x07, 0xd0, 0x4b, 0x30, - 0xde, 0x24, 0x3e, 0xa1, 0xcf, 0x2e, 0x47, 0x74, 0x1f, 0xc7, 0xbd, 0xe6, 0x2a, 0x4e, 0x66, 0xde, - 0x04, 0xe2, 0x34, 0xae, 0xfd, 0x87, 0x16, 0x4c, 0xf5, 0x53, 0x40, 0x88, 0xc0, 0x53, 0x52, 0xba, - 0xaa, 0xaf, 0xb8, 0x1c, 0x48, 0x7a, 0xc2, 0x86, 0x78, 0x46, 0xf0, 0x79, 0x6a, 0xa5, 0x3f, 0x2a, - 0xde, 0x8d, 0x0e, 0xfa, 0x00, 0x1c, 0x37, 0x06, 0x25, 0x56, 0xa3, 0x5a, 0xab, 0xcf, 0x50, 0x8b, - 0x6f, 0x36, 0x03, 0x7b, 0xb0, 0x33, 0xfd, 0x44, 0xb6, 0x4d, 0x68, 0xc8, 0x1e, 0x3a, 0xf6, 0x4f, - 0xf4, 0x7c, 0x6a, 0x65, 0xdc, 0xbc, 0x6e, 0xf5, 0xb8, 0x4f, 0xde, 0x77, 0x18, 0x06, 0x05, 0x73, - 0xb4, 0xa8, 0xa0, 0x94, 0xfe, 0x38, 0x8f, 0x30, 0x88, 0xc1, 0xfe, 0x8d, 0x21, 0xd8, 0xa5, 0x67, - 0x03, 0xec, 0x56, 0xf6, 0x7d, 0xaa, 0xfc, 0x05, 0x4b, 0x1d, 0x1f, 0x72, 0xa1, 0xd5, 0x3c, 0xac, - 0xb1, 0xe7, 0x1b, 0xc6, 0x98, 0x07, 0xd2, 0x28, 0x91, 0x90, 0x3e, 0xa8, 0x44, 0x5f, 0xb5, 0xd2, - 0x07, 0xa0, 0x3c, 0x78, 0xd4, 0x3b, 0xb4, 0x3e, 0x19, 0xa7, 0xaa, 0xbc, 0x63, 0xfa, 0x2c, 0xae, - 0xdf, 0x79, 0xeb, 0x0c, 0xc0, 0xba, 0x17, 0x38, 0xbe, 0xf7, 0x2a, 0xdd, 0x0e, 0x56, 0x98, 0x45, - 0xc3, 0x4c, 0xc4, 0xcb, 0xaa, 0x15, 0x1b, 0x18, 0x67, 0xfe, 0x7f, 0x18, 0x35, 0xde, 0x3c, 0x27, - 0xfe, 0xe7, 0xa4, 0x19, 0xff, 0x53, 0x33, 0xc2, 0x76, 0xce, 0xbc, 0x07, 0x8e, 0x67, 0x3b, 0xb8, - 0x9f, 0xe7, 0xed, 0xff, 0x3d, 0x92, 0x3d, 0x91, 0x5c, 0x25, 0x51, 0x8b, 0x76, 0xed, 0x0d, 0x4f, - 0xde, 0x1b, 0x9e, 0xbc, 0x37, 0x3c, 0x79, 0xe6, 0x61, 0x8c, 0xf0, 0x52, 0x8d, 0x1c, 0x91, 0x97, - 0x2a, 0xe5, 0x77, 0xab, 0x16, 0xee, 0x77, 0xb3, 0x3f, 0xd3, 0x73, 0x54, 0xb1, 0x1a, 0x11, 0x82, - 0x42, 0xa8, 0x04, 0x61, 0x93, 0x48, 0xa3, 0xfe, 0x5a, 0x31, 0x16, 0xea, 0x8d, 0xb0, 0x69, 0x84, - 0xe5, 0xd3, 0x7f, 0x31, 0xe6, 0x7c, 0xec, 0xff, 0xd5, 0x63, 0xd8, 0xdc, 0x66, 0x7e, 0xa2, 0x6d, - 0x12, 0x24, 0xe8, 0x7a, 0xca, 0xca, 0xfb, 0xd6, 0xcc, 0xa9, 0xfb, 0x5b, 0xfb, 0x25, 0x60, 0xdd, - 0xa5, 0x14, 0x66, 0x18, 0x09, 0xc3, 0x20, 0xfc, 0x82, 0x05, 0x13, 0x4e, 0x8a, 0x53, 0x61, 0x19, - 0x35, 0xe6, 0x89, 0x89, 0x32, 0xa8, 0x33, 0xb6, 0x62, 0x86, 0xb7, 0xfd, 0xe9, 0x61, 0x48, 0x6d, - 0x1c, 0xf8, 0x84, 0xff, 0x66, 0x18, 0x89, 0x48, 0x3b, 0xbc, 0x89, 0x17, 0xc5, 0x4b, 0xeb, 0xb4, - 0x2e, 0xde, 0x8c, 0x25, 0x9c, 0x2a, 0xfb, 0xb6, 0x93, 0x6c, 0x0a, 0x2d, 0xae, 0x94, 0xfd, 0x8a, - 0x93, 0x6c, 0x62, 0x06, 0xa1, 0x36, 0x7f, 0x92, 0x0a, 0x7a, 0x10, 0x87, 0xfb, 0xaa, 0x8b, 0xe9, - 0x90, 0x08, 0x9c, 0xc1, 0x46, 0xaf, 0xc0, 0xd0, 0x26, 0xf1, 0x5b, 0x62, 0xce, 0x37, 0x8a, 0x1b, - 0x26, 0xf6, 0xae, 0x57, 0x89, 0xdf, 0xe2, 0x2a, 0x80, 0xfe, 0xc2, 0x8c, 0x15, 0x5d, 0xf0, 0xb5, - 0xad, 0x4e, 0x9c, 0x84, 0x2d, 0xef, 0x55, 0xe9, 0xd3, 0x7e, 0x5f, 0xc1, 0x8c, 0xaf, 0x4b, 0xfa, - 0xdc, 0x79, 0xa8, 0xfe, 0x62, 0xcd, 0x99, 0xf5, 0xa3, 0xe9, 0x45, 0x6c, 0xad, 0x74, 0x85, 0x6b, - 0xba, 0xe8, 0x7e, 0xcc, 0x4b, 0xfa, 0xbc, 0x1f, 0xea, 0x2f, 0xd6, 0x9c, 0x51, 0x57, 0x09, 0x9e, - 0x51, 0xd6, 0x87, 0x9b, 0x05, 0xf7, 0x81, 0x0b, 0x9d, 0x5c, 0x01, 0xf4, 0x0c, 0x54, 0xdc, 0x4d, - 0x27, 0x4a, 0xa6, 0xc6, 0xd8, 0xa4, 0x51, 0xcb, 0x77, 0x8e, 0x36, 0x62, 0x0e, 0x43, 0x4f, 0x43, - 0x39, 0x22, 0xeb, 0x2c, 0x48, 0xdd, 0x08, 0x8f, 0xc3, 0x64, 0x1d, 0xd3, 0x76, 0x65, 0x90, 0x4e, - 0xf4, 0x8d, 0x9b, 0xfc, 0xb1, 0x52, 0xda, 0xa2, 0x4d, 0x8f, 0x0c, 0x5f, 0x0f, 0x6e, 0x27, 0x8a, - 0xa5, 0x2b, 0xd4, 0x58, 0x0f, 0xac, 0x19, 0x4b, 0x38, 0xfa, 0xa4, 0x05, 0x23, 0x77, 0xe2, 0x30, - 0x08, 0xd4, 0xc2, 0xbe, 0x55, 0xf0, 0x60, 0x5d, 0xe3, 0xd4, 0x75, 0x1f, 0x44, 0x03, 0x96, 0x7c, - 0x69, 0x77, 0xc9, 0x3d, 0xd7, 0xef, 0x34, 0x7b, 0x62, 0xa2, 0x2e, 0xf1, 0x66, 0x2c, 0xe1, 0x14, - 0xd5, 0x0b, 0x38, 0xea, 0x50, 0x1a, 0x75, 0x21, 0x10, 0xa8, 0x02, 0x6e, 0xff, 0x4c, 0x15, 0x4e, - 0xe5, 0x2e, 0x1f, 0x6a, 0x6b, 0x32, 0x6b, 0xee, 0xb2, 0xe7, 0x13, 0x19, 0x0d, 0xc8, 0x6c, 0xcd, - 0x5b, 0xaa, 0x15, 0x1b, 0x18, 0xe8, 0x7b, 0x00, 0xda, 0x4e, 0xe4, 0xb4, 0x88, 0x3a, 0xaa, 0x38, - 0xb0, 0x49, 0x47, 0xfb, 0xb1, 0x22, 0x69, 0x6a, 0x77, 0x8d, 0x6a, 0x8a, 0xb1, 0xc1, 0x12, 0xbd, - 0x00, 0xa3, 0x11, 0xf1, 0x89, 0x13, 0xb3, 0x2c, 0x88, 0x6c, 0xb2, 0x18, 0xd6, 0x20, 0x6c, 0xe2, - 0xa1, 0x67, 0x55, 0xe0, 0xe4, 0x50, 0x3a, 0xaa, 0x28, 0x1d, 0x3c, 0x89, 0xbe, 0x64, 0xc1, 0xc4, - 0xba, 0xe7, 0x13, 0xcd, 0x5d, 0xa4, 0x76, 0x2d, 0x1f, 0xfc, 0x25, 0x2f, 0x9b, 0x74, 0xb5, 0x0c, - 0x4d, 0x35, 0xc7, 0x38, 0xc3, 0x9e, 0x7e, 0xe6, 0x6d, 0x12, 0x31, 0xe1, 0x3b, 0x9c, 0xfe, 0xcc, - 0xb7, 0x78, 0x33, 0x96, 0x70, 0x34, 0x0b, 0xc7, 0xda, 0x4e, 0x1c, 0xcf, 0x45, 0xa4, 0x49, 0x82, - 0xc4, 0x73, 0x7c, 0x9e, 0x4b, 0x55, 0xd5, 0x59, 0x05, 0x2b, 0x69, 0x30, 0xce, 0xe2, 0xa3, 0xf7, - 0xc3, 0x93, 0xdc, 0x17, 0xb8, 0xe4, 0xc5, 0xb1, 0x17, 0x6c, 0xe8, 0x69, 0x20, 0x5c, 0xa2, 0xd3, - 0x82, 0xd4, 0x93, 0x0b, 0xf9, 0x68, 0xb8, 0xdf, 0xf3, 0xe8, 0x79, 0xa8, 0xc6, 0x5b, 0x5e, 0x7b, - 0x2e, 0x6a, 0xc6, 0xec, 0x1c, 0xb0, 0xaa, 0x1d, 0xf0, 0x0d, 0xd1, 0x8e, 0x15, 0x06, 0x72, 0x61, - 0x8c, 0x7f, 0x12, 0x1e, 0xf9, 0x29, 0x24, 0xe8, 0xdb, 0xfb, 0x5a, 0x30, 0x22, 0xd7, 0x7a, 0x06, - 0x3b, 0x77, 0x2f, 0xc9, 0x53, 0x49, 0x7e, 0x88, 0x76, 0xcb, 0x20, 0x83, 0x53, 0x44, 0xd3, 0x9b, - 0xd9, 0xd1, 0x01, 0x36, 0xb3, 0x2f, 0xc0, 0xe8, 0x56, 0x67, 0x8d, 0x88, 0x91, 0x17, 0x82, 0x4d, - 0xcd, 0xbe, 0xeb, 0x1a, 0x84, 0x4d, 0x3c, 0x16, 0x74, 0xdb, 0xf6, 0xc4, 0xbf, 0x78, 0x6a, 0xdc, - 0x08, 0xba, 0x5d, 0x59, 0x90, 0xcd, 0xd8, 0xc4, 0xa1, 0x5d, 0xa3, 0x63, 0xb1, 0x4a, 0x62, 0x96, - 0x53, 0x43, 0x87, 0x4b, 0x75, 0xad, 0x21, 0x01, 0x58, 0xe3, 0xa0, 0x15, 0x38, 0x49, 0xff, 0x34, - 0x58, 0xae, 0xf9, 0x2d, 0xc7, 0xf7, 0x9a, 0x3c, 0x02, 0xf4, 0x58, 0xda, 0x93, 0xdd, 0xc8, 0xc1, - 0xc1, 0xb9, 0x4f, 0xda, 0x3f, 0x5a, 0x4a, 0x5b, 0x56, 0xa6, 0x08, 0x43, 0x31, 0x15, 0x54, 0xc9, - 0x2d, 0x27, 0x92, 0x96, 0xde, 0x01, 0x13, 0xe2, 0x04, 0xdd, 0x5b, 0x4e, 0x64, 0x8a, 0x3c, 0xc6, - 0x00, 0x4b, 0x4e, 0xe8, 0x0e, 0x0c, 0x25, 0xbe, 0x53, 0x50, 0xba, 0xad, 0xc1, 0x51, 0xbb, 0xff, - 0x16, 0x67, 0x63, 0xcc, 0x78, 0xa0, 0xb3, 0x74, 0xdb, 0xba, 0x26, 0xcf, 0x54, 0xc5, 0x4e, 0x73, - 0x2d, 0xc6, 0xac, 0xd5, 0xfe, 0x6b, 0xe3, 0x39, 0x5a, 0x47, 0x19, 0x02, 0xe8, 0x22, 0x00, 0x9d, - 0x34, 0x2b, 0x11, 0x59, 0xf7, 0xee, 0x09, 0x43, 0x4c, 0x49, 0xb6, 0x1b, 0x0a, 0x82, 0x0d, 0x2c, - 0xf9, 0x4c, 0xa3, 0xb3, 0x4e, 0x9f, 0x29, 0xf5, 0x3e, 0xc3, 0x21, 0xd8, 0xc0, 0x42, 0xef, 0x82, - 0x61, 0xaf, 0xe5, 0x6c, 0xa8, 0x78, 0xf0, 0xb3, 0x54, 0xa4, 0x2d, 0xb0, 0x96, 0x07, 0x3b, 0xd3, - 0x13, 0xaa, 0x43, 0xac, 0x09, 0x0b, 0x5c, 0xf4, 0x13, 0x16, 0x8c, 0xb9, 0x61, 0xab, 0x15, 0x06, - 0xdc, 0x6f, 0x20, 0x9c, 0x20, 0x77, 0x0e, 0xcb, 0x4c, 0x9a, 0x99, 0x33, 0x98, 0x71, 0x2f, 0x88, - 0xca, 0x0b, 0x36, 0x41, 0x38, 0xd5, 0x2b, 0x53, 0xf2, 0x55, 0xf6, 0x90, 0x7c, 0x3f, 0x6b, 0xc1, - 0x24, 0x7f, 0xd6, 0x70, 0x67, 0x88, 0xac, 0xd6, 0xf0, 0x90, 0x5f, 0xab, 0xc7, 0xc3, 0xa3, 0xdc, - 0xfa, 0x3d, 0x70, 0xdc, 0xdb, 0x49, 0x74, 0x05, 0x26, 0xd7, 0xc3, 0xc8, 0x25, 0xe6, 0x40, 0x08, - 0xb1, 0xad, 0x08, 0x5d, 0xce, 0x22, 0xe0, 0xde, 0x67, 0xd0, 0x2d, 0x78, 0xc2, 0x68, 0x34, 0xc7, - 0x81, 0x4b, 0xee, 0x73, 0x82, 0xda, 0x13, 0x97, 0x73, 0xb1, 0x70, 0x9f, 0xa7, 0xd3, 0x42, 0xb2, - 0x36, 0x80, 0x90, 0xfc, 0x08, 0x9c, 0x76, 0x7b, 0x47, 0x66, 0x3b, 0xee, 0xac, 0xc5, 0x5c, 0x8e, - 0x57, 0xeb, 0x6f, 0x16, 0x04, 0x4e, 0xcf, 0xf5, 0x43, 0xc4, 0xfd, 0x69, 0xa0, 0x8f, 0x41, 0x35, - 0x22, 0xec, 0xab, 0xc4, 0x22, 0xc5, 0xf3, 0x80, 0x6e, 0x1e, 0x6d, 0xc1, 0x73, 0xb2, 0x5a, 0x33, - 0x89, 0x86, 0x18, 0x2b, 0x8e, 0xe8, 0x2e, 0x8c, 0xb4, 0xe9, 0xfe, 0x50, 0xe4, 0x6a, 0x1e, 0x78, - 0xfb, 0xa7, 0x98, 0xb3, 0x43, 0x33, 0xa3, 0xb6, 0x06, 0x67, 0x82, 0x25, 0x37, 0x6a, 0xab, 0xb9, - 0x61, 0xab, 0x1d, 0x06, 0x24, 0x48, 0xa4, 0x12, 0x99, 0xe0, 0x27, 0x5b, 0xb2, 0x15, 0x1b, 0x18, - 0x3d, 0xba, 0x5c, 0xa3, 0x4d, 0x4d, 0xee, 0xa2, 0xcb, 0x0d, 0x6a, 0xfd, 0x9e, 0xa7, 0xca, 0x86, - 0xf9, 0x53, 0x6f, 0x7b, 0xc9, 0x66, 0xd8, 0x49, 0xa4, 0x7b, 0x40, 0x28, 0x2a, 0xa5, 0x6c, 0x16, - 0x73, 0x70, 0x70, 0xee, 0x93, 0x59, 0xcd, 0x7a, 0xec, 0xe1, 0x34, 0xeb, 0xf1, 0x01, 0x34, 0x6b, - 0x03, 0x4e, 0xb1, 0x1e, 0x08, 0x2b, 0x59, 0x7a, 0x6b, 0xe3, 0x29, 0xc4, 0x3a, 0xaf, 0xd2, 0x9c, - 0x16, 0xf3, 0x90, 0x70, 0xfe, 0xb3, 0x67, 0xbe, 0x13, 0x26, 0x7b, 0x84, 0xdc, 0xbe, 0x3c, 0xb1, - 0xf3, 0xf0, 0x44, 0xbe, 0x38, 0xd9, 0x97, 0x3f, 0xf6, 0x67, 0x32, 0x19, 0x08, 0xc6, 0x16, 0x6d, - 0x00, 0xdf, 0xbe, 0x03, 0x65, 0x12, 0x6c, 0x0b, 0xed, 0x7a, 0xf9, 0x60, 0xb3, 0xfa, 0x52, 0xb0, - 0xcd, 0xa5, 0x21, 0x73, 0x60, 0x5e, 0x0a, 0xb6, 0x31, 0xa5, 0x8d, 0x7e, 0xc8, 0x4a, 0x6d, 0x20, - 0xf8, 0x89, 0xc0, 0x87, 0x0f, 0x65, 0x4f, 0x3a, 0xf0, 0x9e, 0xc2, 0xfe, 0x57, 0x25, 0x38, 0xbf, - 0x17, 0x91, 0x01, 0x86, 0xef, 0x19, 0x18, 0x8e, 0x59, 0x4c, 0x91, 0x50, 0x57, 0xa3, 0x74, 0x15, - 0xf3, 0x28, 0xa3, 0x8f, 0x60, 0x01, 0x42, 0x3e, 0x94, 0x5b, 0x4e, 0x5b, 0x38, 0x8a, 0x17, 0x0e, - 0x9a, 0xc6, 0x49, 0xff, 0x3b, 0xfe, 0x92, 0xd3, 0xe6, 0x73, 0xde, 0x68, 0xc0, 0x94, 0x0d, 0x4a, - 0xa0, 0xe2, 0x44, 0x91, 0x23, 0x03, 0x58, 0xae, 0x17, 0xc3, 0x6f, 0x96, 0x92, 0xe4, 0xe7, 0xff, - 0xa9, 0x26, 0xcc, 0x99, 0xd9, 0x3f, 0x52, 0x4d, 0xe5, 0xfc, 0xb1, 0xa8, 0xa4, 0x18, 0x86, 0x85, - 0x7f, 0xd8, 0x2a, 0x3a, 0x7b, 0x96, 0x27, 0xd5, 0x33, 0x0f, 0x84, 0x28, 0x7a, 0x22, 0x58, 0xa1, - 0xcf, 0x5b, 0xac, 0xb4, 0x88, 0x4c, 0xa4, 0x14, 0xbb, 0xfa, 0xc3, 0xa9, 0x74, 0x62, 0x16, 0x2c, - 0x91, 0x8d, 0xd8, 0xe4, 0x2e, 0xca, 0x28, 0xb1, 0xdd, 0x4c, 0x6f, 0x19, 0x25, 0xb6, 0x3b, 0x91, - 0x70, 0x74, 0x2f, 0x27, 0xfa, 0xa8, 0x80, 0x8a, 0x13, 0x03, 0xc4, 0x1b, 0x7d, 0xd5, 0x82, 0x49, - 0x2f, 0x1b, 0x46, 0x22, 0xf6, 0xc0, 0xb7, 0x8b, 0x71, 0xe6, 0xf6, 0x46, 0xa9, 0x28, 0x43, 0xa7, - 0x07, 0x84, 0x7b, 0x3b, 0x83, 0x9a, 0x30, 0xe4, 0x05, 0xeb, 0xa1, 0x30, 0xef, 0xea, 0x07, 0xeb, - 0xd4, 0x42, 0xb0, 0x1e, 0xea, 0xd5, 0x4c, 0xff, 0x61, 0x46, 0x1d, 0x2d, 0xc2, 0x49, 0x99, 0xd9, - 0x75, 0xd5, 0x8b, 0x93, 0x30, 0xea, 0x2e, 0x7a, 0x2d, 0x2f, 0x61, 0xa6, 0x59, 0xb9, 0x3e, 0x45, - 0xd5, 0x1b, 0xce, 0x81, 0xe3, 0xdc, 0xa7, 0xd0, 0xab, 0x30, 0x22, 0x43, 0x37, 0xaa, 0x45, 0xf8, - 0x13, 0x7a, 0xe7, 0xbf, 0x9a, 0x4c, 0x0d, 0x11, 0xbb, 0x21, 0x19, 0xa2, 0xcf, 0x5a, 0x30, 0xc1, - 0x7f, 0x5f, 0xed, 0x36, 0x79, 0xa6, 0x69, 0xad, 0x08, 0xbf, 0x75, 0x23, 0x45, 0xb3, 0x8e, 0xee, - 0xef, 0x4c, 0x4f, 0xa4, 0xdb, 0x70, 0x86, 0xaf, 0xfd, 0xf7, 0xc7, 0xa0, 0x37, 0xd8, 0x25, 0x1d, - 0xd9, 0x62, 0x1d, 0x79, 0x64, 0xcb, 0x1d, 0x18, 0x8a, 0x75, 0x80, 0x47, 0x01, 0xcb, 0x4c, 0x70, - 0xd5, 0xe7, 0xef, 0xdd, 0xc0, 0xc5, 0x8c, 0x07, 0xea, 0xa8, 0x28, 0x98, 0x72, 0x41, 0x47, 0xfe, - 0x83, 0x04, 0xc2, 0xa0, 0x7b, 0x30, 0xb2, 0xc9, 0xa7, 0xa3, 0xd8, 0xeb, 0x2d, 0x1d, 0x74, 0x7c, - 0x53, 0x73, 0x5c, 0x4f, 0x3e, 0xd1, 0x80, 0x25, 0x3b, 0x16, 0x48, 0x69, 0x84, 0x7a, 0x71, 0x41, - 0x52, 0x5c, 0xd2, 0xec, 0xe0, 0x71, 0x5e, 0x1f, 0x85, 0xb1, 0x88, 0xb8, 0x61, 0xe0, 0x7a, 0x3e, - 0x69, 0xce, 0xca, 0x93, 0xc0, 0xfd, 0xa4, 0x43, 0x32, 0x6f, 0x12, 0x36, 0x68, 0xe0, 0x14, 0x45, - 0xb6, 0xce, 0x54, 0xfd, 0x04, 0xfa, 0x41, 0x88, 0x38, 0xf8, 0x58, 0x2c, 0xa8, 0x5a, 0x03, 0xa3, - 0xc9, 0xd7, 0x59, 0xba, 0x0d, 0x67, 0xf8, 0xa2, 0x0f, 0x00, 0x84, 0x6b, 0x3c, 0x5a, 0x72, 0x36, - 0x11, 0xa7, 0x20, 0xfb, 0x79, 0xd5, 0x09, 0x9e, 0x73, 0x2d, 0x29, 0x60, 0x83, 0x1a, 0xba, 0x0e, - 0xc0, 0x57, 0xce, 0x6a, 0xb7, 0x2d, 0x37, 0x84, 0x32, 0x9f, 0x15, 0x1a, 0x0a, 0xf2, 0x60, 0x67, - 0xba, 0xd7, 0xe7, 0xcc, 0x4e, 0xd3, 0x8c, 0xc7, 0xd1, 0x77, 0xc1, 0x48, 0xdc, 0x69, 0xb5, 0x1c, - 0x75, 0x46, 0x52, 0x60, 0x16, 0x37, 0xa7, 0x6b, 0x08, 0x46, 0xde, 0x80, 0x25, 0x47, 0x74, 0x87, - 0x8a, 0x78, 0x21, 0xa1, 0xf8, 0x2a, 0xe2, 0x16, 0x0a, 0xf7, 0x04, 0xbe, 0x5b, 0xee, 0x62, 0x70, - 0x0e, 0xce, 0x83, 0x9d, 0xe9, 0x27, 0xd2, 0xed, 0x8b, 0xa1, 0xc8, 0xab, 0xce, 0xa5, 0x89, 0xae, - 0xc9, 0x42, 0x6d, 0xf4, 0xb5, 0x65, 0x95, 0x9f, 0xe7, 0x74, 0xa1, 0x36, 0xd6, 0xdc, 0x7f, 0xcc, - 0xcc, 0x87, 0xd1, 0x12, 0x9c, 0x70, 0xc3, 0x20, 0x89, 0x42, 0xdf, 0xe7, 0xc5, 0x1c, 0xf9, 0xde, - 0x9c, 0x9f, 0xa1, 0x3c, 0x25, 0xba, 0x7d, 0x62, 0xae, 0x17, 0x05, 0xe7, 0x3d, 0x47, 0x6d, 0xf2, - 0xac, 0x7e, 0x98, 0x28, 0x24, 0xae, 0x20, 0x45, 0x53, 0x48, 0x28, 0xe5, 0xf6, 0xde, 0x43, 0x53, - 0x04, 0xe9, 0xd3, 0x65, 0xf1, 0xc5, 0xde, 0x05, 0x63, 0xe4, 0x5e, 0x42, 0xa2, 0xc0, 0xf1, 0x6f, - 0xe2, 0x45, 0x79, 0x60, 0xc1, 0x16, 0xe6, 0x25, 0xa3, 0x1d, 0xa7, 0xb0, 0x90, 0xad, 0xbc, 0x64, - 0x46, 0x01, 0x03, 0xee, 0x25, 0x93, 0x3e, 0x31, 0xfb, 0xa7, 0xcb, 0x29, 0x9b, 0xf5, 0x91, 0x9c, - 0x65, 0xb3, 0xb2, 0x5a, 0xb2, 0xfe, 0x18, 0x03, 0x88, 0xbd, 0x58, 0x91, 0x9c, 0x55, 0xb8, 0xe0, - 0xb2, 0xc9, 0x08, 0xa7, 0xf9, 0xa2, 0x2d, 0xa8, 0x6c, 0x86, 0x71, 0x22, 0x77, 0x68, 0x07, 0xdc, - 0x0c, 0x5e, 0x0d, 0xe3, 0x84, 0x19, 0x5a, 0xea, 0xb5, 0x69, 0x4b, 0x8c, 0x39, 0x0f, 0xba, 0xf7, - 0x8f, 0x37, 0x9d, 0xa8, 0x99, 0x8a, 0x2b, 0x55, 0xf6, 0x74, 0x43, 0x83, 0xb0, 0x89, 0x67, 0xff, - 0x91, 0x95, 0x3a, 0xd5, 0x3a, 0xac, 0x63, 0xff, 0x4f, 0x58, 0xe9, 0x92, 0x0a, 0xa5, 0x22, 0xb6, - 0x6e, 0x66, 0x59, 0x91, 0x3d, 0xab, 0x33, 0xd8, 0x3f, 0x64, 0xc1, 0x48, 0xdd, 0x71, 0xb7, 0xc2, - 0xf5, 0x75, 0xf4, 0x3c, 0x54, 0x9b, 0x9d, 0xc8, 0xac, 0xee, 0xa0, 0x9c, 0x55, 0xf3, 0xa2, 0x1d, - 0x2b, 0x0c, 0x3a, 0xf5, 0xd7, 0x1d, 0x57, 0x16, 0x17, 0x29, 0xf3, 0xa9, 0x7f, 0x99, 0xb5, 0x60, - 0x01, 0xa1, 0xc3, 0xdf, 0x72, 0xee, 0xc9, 0x87, 0xb3, 0x47, 0x6a, 0x4b, 0x1a, 0x84, 0x4d, 0x3c, - 0xfb, 0x57, 0x2c, 0x98, 0xaa, 0x3b, 0xb1, 0xe7, 0xce, 0x76, 0x92, 0xcd, 0xba, 0x97, 0xac, 0x75, - 0xdc, 0x2d, 0x92, 0xf0, 0x22, 0x34, 0xb4, 0x97, 0x9d, 0x98, 0xae, 0x40, 0xb5, 0x63, 0x56, 0xbd, - 0xbc, 0x29, 0xda, 0xb1, 0xc2, 0x40, 0xaf, 0xc2, 0x68, 0xdb, 0x89, 0xe3, 0xbb, 0x61, 0xd4, 0xc4, - 0x64, 0xbd, 0x98, 0x32, 0x55, 0x0d, 0xe2, 0x46, 0x24, 0xc1, 0x64, 0x5d, 0x44, 0xe6, 0x68, 0xfa, - 0xd8, 0x64, 0x66, 0x7f, 0xce, 0x82, 0x93, 0x75, 0xe2, 0x44, 0x24, 0x62, 0x55, 0xad, 0xd4, 0x8b, - 0xa0, 0x57, 0xa0, 0x9a, 0xd0, 0x16, 0xda, 0x23, 0xab, 0xd8, 0x1e, 0xb1, 0x98, 0x9a, 0x55, 0x41, - 0x1c, 0x2b, 0x36, 0xf6, 0x17, 0x2d, 0x38, 0x9d, 0xd7, 0x97, 0x39, 0x3f, 0xec, 0x34, 0x1f, 0x45, - 0x87, 0xfe, 0x86, 0x05, 0x63, 0xec, 0xb8, 0x7e, 0x9e, 0x24, 0x8e, 0xe7, 0xf7, 0xd4, 0xea, 0xb4, - 0x06, 0xac, 0xd5, 0x79, 0x1e, 0x86, 0x36, 0xc3, 0x16, 0xc9, 0x86, 0x9a, 0x5c, 0x0d, 0x5b, 0x04, - 0x33, 0x08, 0x7a, 0x07, 0x9d, 0x84, 0x5e, 0x90, 0x38, 0x74, 0x39, 0xca, 0xe3, 0x8c, 0x63, 0x7c, - 0x02, 0xaa, 0x66, 0x6c, 0xe2, 0xd8, 0xff, 0xa2, 0x06, 0x23, 0x22, 0x20, 0x6c, 0xe0, 0xa2, 0x48, - 0xd2, 0x8b, 0x53, 0xea, 0xeb, 0xc5, 0x89, 0x61, 0xd8, 0x65, 0x85, 0x95, 0x85, 0x85, 0x7e, 0xbd, - 0x90, 0x08, 0x42, 0x5e, 0xab, 0x59, 0x77, 0x8b, 0xff, 0xc7, 0x82, 0x15, 0x7a, 0xcd, 0x82, 0x63, - 0x6e, 0x18, 0x04, 0xc4, 0xd5, 0xb6, 0xe3, 0x50, 0x11, 0x1b, 0x84, 0xb9, 0x34, 0x51, 0x7d, 0x12, - 0x9c, 0x01, 0xe0, 0x2c, 0x7b, 0xf4, 0x12, 0x8c, 0xf3, 0x31, 0xbb, 0x95, 0x3a, 0x83, 0xd1, 0x55, - 0x19, 0x4d, 0x20, 0x4e, 0xe3, 0xa2, 0x19, 0x7e, 0x96, 0x25, 0x4a, 0x1a, 0x0e, 0x6b, 0x57, 0xb5, - 0x51, 0xcc, 0xd0, 0xc0, 0x40, 0x11, 0xa0, 0x88, 0xac, 0x47, 0x24, 0xde, 0x14, 0x01, 0x73, 0xcc, - 0x6e, 0x1d, 0x79, 0xb8, 0x8a, 0x25, 0xb8, 0x87, 0x12, 0xce, 0xa1, 0x8e, 0xb6, 0x84, 0x1b, 0xa1, - 0x5a, 0x84, 0x3c, 0x17, 0x9f, 0xb9, 0xaf, 0x37, 0x61, 0x1a, 0x2a, 0x4c, 0x75, 0x31, 0x7b, 0xb9, - 0xcc, 0xb3, 0x64, 0x99, 0x62, 0xc3, 0xbc, 0x1d, 0xcd, 0xc3, 0xf1, 0x4c, 0x99, 0xc8, 0x58, 0x9c, - 0x95, 0xa8, 0x8c, 0xc8, 0x4c, 0x81, 0xc9, 0x18, 0xf7, 0x3c, 0x61, 0xba, 0x98, 0x46, 0xf7, 0x70, - 0x31, 0x75, 0x55, 0x58, 0x36, 0x3f, 0xc5, 0x78, 0x6f, 0x21, 0x03, 0x30, 0x50, 0x0c, 0xf6, 0x0f, - 0x66, 0x62, 0xb0, 0xc7, 0x59, 0x07, 0x6e, 0x15, 0xd3, 0x81, 0xfd, 0x07, 0x5c, 0x3f, 0xca, 0x00, - 0xea, 0xff, 0x69, 0x81, 0xfc, 0xae, 0x73, 0x8e, 0xbb, 0x49, 0xe8, 0x94, 0xc9, 0x49, 0xb5, 0xb1, - 0xf6, 0x95, 0x6a, 0x73, 0x01, 0x6a, 0x74, 0x9c, 0xf8, 0xa3, 0x5c, 0xef, 0x2b, 0x0f, 0xc8, 0xec, - 0xca, 0x82, 0x78, 0x4a, 0xe3, 0xa0, 0x10, 0x26, 0x7d, 0x27, 0x4e, 0x58, 0x0f, 0x1a, 0xdd, 0xc0, - 0x7d, 0xc8, 0x7a, 0x41, 0x2c, 0xed, 0x6e, 0x31, 0x4b, 0x08, 0xf7, 0xd2, 0xb6, 0xff, 0x4d, 0x05, - 0xc6, 0x53, 0x92, 0x71, 0x9f, 0x06, 0xc3, 0xf3, 0x50, 0x95, 0x3a, 0x3c, 0x5b, 0x35, 0x4d, 0x29, - 0x7a, 0x85, 0x41, 0x95, 0xd6, 0x9a, 0xd6, 0xaa, 0x59, 0x03, 0xc7, 0x50, 0xb8, 0xd8, 0xc4, 0x63, - 0x42, 0x39, 0xf1, 0xe3, 0x39, 0xdf, 0x23, 0x41, 0xc2, 0xbb, 0x59, 0x8c, 0x50, 0x5e, 0x5d, 0x6c, - 0x98, 0x44, 0xb5, 0x50, 0xce, 0x00, 0x70, 0x96, 0x3d, 0xfa, 0xb4, 0x05, 0xe3, 0xce, 0xdd, 0x58, - 0x57, 0xff, 0x17, 0xd1, 0xd6, 0x07, 0x54, 0x52, 0xa9, 0x0b, 0x05, 0xb8, 0x63, 0x3f, 0xd5, 0x84, - 0xd3, 0x4c, 0xd1, 0xeb, 0x16, 0x20, 0x72, 0x8f, 0xb8, 0x32, 0x1e, 0x5c, 0xf4, 0x65, 0xb8, 0x88, - 0x1d, 0xfc, 0xa5, 0x1e, 0xba, 0x5c, 0xaa, 0xf7, 0xb6, 0xe3, 0x9c, 0x3e, 0xa0, 0x6b, 0x80, 0x9a, - 0x5e, 0xec, 0xac, 0xf9, 0x64, 0x2e, 0x6c, 0xc9, 0x54, 0x71, 0x71, 0x9e, 0x7e, 0x46, 0x8c, 0x33, - 0x9a, 0xef, 0xc1, 0xc0, 0x39, 0x4f, 0xb1, 0x59, 0x16, 0x85, 0xf7, 0xba, 0x37, 0x23, 0x9f, 0x69, - 0x09, 0x73, 0x96, 0x89, 0x76, 0xac, 0x30, 0xec, 0x3f, 0x2e, 0xab, 0xa5, 0xac, 0x93, 0x1f, 0x1c, - 0x23, 0x08, 0xdb, 0x7a, 0xf8, 0x20, 0x6c, 0x1d, 0x29, 0xd5, 0x5b, 0x00, 0x21, 0x95, 0x2f, 0x5d, - 0x7a, 0x44, 0xf9, 0xd2, 0xdf, 0x6b, 0xa5, 0x2a, 0x13, 0x8e, 0x5e, 0xfc, 0x40, 0xb1, 0x89, 0x17, - 0x33, 0x3c, 0x8a, 0x2b, 0xa3, 0x57, 0x32, 0xc1, 0x7b, 0xcf, 0x43, 0x75, 0xdd, 0x77, 0x58, 0xc9, - 0x1c, 0xb6, 0x50, 0x8d, 0x08, 0xb3, 0xcb, 0xa2, 0x1d, 0x2b, 0x0c, 0x2a, 0xf5, 0x0d, 0xa2, 0xfb, - 0x92, 0xda, 0xff, 0xbe, 0x0c, 0xa3, 0x86, 0xc6, 0xcf, 0x35, 0xdf, 0xac, 0xc7, 0xcc, 0x7c, 0x2b, - 0xed, 0xc3, 0x7c, 0xfb, 0x1e, 0xa8, 0xb9, 0x52, 0x1b, 0x15, 0x73, 0x87, 0x43, 0x56, 0xc7, 0x69, - 0x85, 0xa4, 0x9a, 0xb0, 0xe6, 0x89, 0xae, 0xa4, 0x72, 0x72, 0x53, 0x7e, 0x81, 0xbc, 0xa4, 0x59, - 0xa1, 0xd1, 0x7a, 0x9f, 0xc9, 0xc6, 0x07, 0x54, 0xf6, 0x8e, 0x0f, 0xb0, 0x7f, 0xcf, 0x52, 0x1f, - 0xf7, 0x08, 0x8a, 0x2f, 0xdd, 0x49, 0x17, 0x5f, 0xba, 0x54, 0xc8, 0x30, 0xf7, 0xa9, 0xba, 0xf4, - 0x39, 0x0b, 0xce, 0xed, 0x5e, 0xcd, 0x1c, 0x3d, 0x03, 0x95, 0x8d, 0x28, 0xec, 0xb4, 0x85, 0x0e, - 0x56, 0x74, 0x58, 0xe9, 0x78, 0xcc, 0x61, 0x74, 0x13, 0xb5, 0xe5, 0x05, 0xcd, 0xec, 0x26, 0xea, - 0xba, 0x17, 0x34, 0x31, 0x83, 0x0c, 0x50, 0xee, 0xf6, 0x06, 0x8c, 0xcc, 0x85, 0xad, 0x96, 0x13, - 0x34, 0xd1, 0x5b, 0x60, 0xc4, 0xe5, 0x3f, 0x85, 0x3f, 0x8f, 0x1d, 0x9c, 0x0b, 0x28, 0x96, 0x30, - 0x74, 0x16, 0x86, 0x9c, 0x68, 0x43, 0xfa, 0xf0, 0x58, 0x40, 0xde, 0x6c, 0xb4, 0x11, 0x63, 0xd6, - 0x6a, 0xff, 0xa9, 0x05, 0x13, 0xf4, 0x11, 0x8f, 0x0d, 0x30, 0x1b, 0xda, 0x67, 0x61, 0xd8, 0xe9, - 0x24, 0x9b, 0x61, 0xcf, 0x9e, 0x70, 0x96, 0xb5, 0x62, 0x01, 0xa5, 0x9d, 0x55, 0x15, 0x44, 0x8c, - 0xce, 0xce, 0xd3, 0x75, 0xc5, 0x20, 0xd4, 0xac, 0x8e, 0x3b, 0x6b, 0x79, 0x27, 0xb7, 0x0d, 0xde, - 0x8c, 0x25, 0x9c, 0x12, 0x5b, 0x0b, 0x9b, 0x5d, 0x11, 0x66, 0xac, 0x88, 0xd5, 0xc3, 0x66, 0x17, - 0x33, 0x08, 0x7a, 0x1a, 0xca, 0xf1, 0xa6, 0x23, 0x63, 0x04, 0x64, 0xc4, 0x7b, 0xe3, 0xea, 0x2c, - 0xa6, 0xed, 0x2a, 0x81, 0x23, 0xf2, 0xb3, 0xf1, 0xbe, 0xe9, 0x04, 0x8e, 0xc8, 0xb7, 0xff, 0xc9, - 0x10, 0xb0, 0xd8, 0x1f, 0x27, 0x22, 0xcd, 0xd5, 0x90, 0x15, 0xa8, 0x3e, 0xd4, 0x23, 0x76, 0xbd, - 0xa9, 0x7e, 0x9c, 0x8f, 0xd9, 0x8d, 0xa3, 0xd6, 0xf2, 0x51, 0x1f, 0xb5, 0xe6, 0x9f, 0x9e, 0x0f, - 0x3d, 0x46, 0xa7, 0xe7, 0xf6, 0x17, 0x2c, 0x40, 0x2a, 0x92, 0x4b, 0x87, 0xb7, 0x5c, 0x80, 0x9a, - 0x0a, 0x1d, 0x13, 0xeb, 0x45, 0x8b, 0x68, 0x09, 0xc0, 0x1a, 0x67, 0x00, 0x4f, 0xca, 0x33, 0x52, - 0x7f, 0x96, 0xd3, 0xb2, 0x84, 0x69, 0x5d, 0xa1, 0x4e, 0xed, 0x5f, 0x2a, 0xc1, 0x13, 0xdc, 0x74, - 0x5b, 0x72, 0x02, 0x67, 0x83, 0xb4, 0x68, 0xaf, 0x06, 0x0d, 0x58, 0x72, 0xe9, 0x16, 0xde, 0x93, - 0xd9, 0x1a, 0x07, 0x95, 0x9d, 0x5c, 0xce, 0x70, 0xc9, 0xb2, 0x10, 0x78, 0x09, 0x66, 0xc4, 0x51, - 0x0c, 0x55, 0x79, 0x09, 0x97, 0xd0, 0x85, 0x05, 0x31, 0x52, 0x6a, 0x41, 0x58, 0x39, 0x04, 0x2b, - 0x46, 0xd4, 0x94, 0xf1, 0x43, 0x77, 0x8b, 0x2e, 0xf9, 0xac, 0x29, 0xb3, 0x28, 0xda, 0xb1, 0xc2, - 0xb0, 0x5b, 0x70, 0x4c, 0x8e, 0x61, 0xfb, 0x3a, 0xe9, 0x62, 0xb2, 0x4e, 0xf5, 0xbf, 0x2b, 0x9b, - 0x8c, 0x7b, 0xc1, 0x94, 0xfe, 0x9f, 0x33, 0x81, 0x38, 0x8d, 0x2b, 0x6b, 0x56, 0x97, 0xf2, 0x6b, - 0x56, 0xdb, 0xbf, 0x64, 0x41, 0xd6, 0x00, 0x61, 0x0e, 0x38, 0xf3, 0x92, 0xaf, 0x7e, 0xc5, 0xec, - 0xf7, 0x51, 0xc6, 0xf6, 0x43, 0x30, 0xea, 0x24, 0xd4, 0xc2, 0xe4, 0xde, 0xa0, 0xf2, 0xc3, 0x9d, - 0x62, 0x2e, 0x85, 0x4d, 0x6f, 0xdd, 0x63, 0x5e, 0x20, 0x93, 0x9c, 0xfd, 0xd7, 0x2b, 0x50, 0x9b, - 0x8f, 0xba, 0xfb, 0x4f, 0x9b, 0xeb, 0x4d, 0x8a, 0x2b, 0xed, 0x2b, 0x29, 0x4e, 0xa6, 0xdd, 0x95, - 0xfb, 0xa6, 0xdd, 0xc9, 0xb4, 0xb9, 0xa1, 0x47, 0x95, 0x36, 0x57, 0x79, 0x4c, 0xd2, 0xe6, 0x86, - 0x1f, 0x83, 0xb4, 0xb9, 0x91, 0x23, 0x4e, 0x9b, 0xb3, 0xff, 0xfb, 0x10, 0x4c, 0xf6, 0xa4, 0x3f, - 0xa3, 0x17, 0x61, 0x4c, 0xad, 0x51, 0x79, 0x00, 0x50, 0x33, 0xc3, 0xe8, 0x35, 0x0c, 0xa7, 0x30, - 0x07, 0x10, 0xd4, 0x0b, 0x70, 0x22, 0x22, 0xaf, 0x74, 0x48, 0x87, 0xcc, 0xae, 0x27, 0x24, 0x6a, - 0x10, 0x37, 0x0c, 0x9a, 0xbc, 0xc0, 0x79, 0xb9, 0xfe, 0xe4, 0xfd, 0x9d, 0xe9, 0x13, 0xb8, 0x17, - 0x8c, 0xf3, 0x9e, 0x41, 0x6d, 0x18, 0xf7, 0xcd, 0x9d, 0xab, 0x98, 0xc3, 0x0f, 0xb5, 0xe9, 0x55, - 0xb2, 0x2a, 0xd5, 0x8c, 0xd3, 0x0c, 0xd2, 0xdb, 0xdf, 0xca, 0x23, 0xda, 0xfe, 0x7e, 0x4a, 0x6f, - 0x7f, 0x79, 0x54, 0xda, 0x07, 0x0b, 0x4e, 0x7f, 0x1f, 0x64, 0xff, 0x7b, 0x90, 0x1d, 0xed, 0x7b, - 0xa1, 0x2a, 0x23, 0x76, 0x07, 0x8a, 0x74, 0x35, 0xe9, 0xf4, 0xd1, 0xec, 0x0f, 0x4a, 0x90, 0xe3, - 0xb4, 0xa1, 0x92, 0x56, 0x5b, 0xfb, 0x29, 0x49, 0xbb, 0x3f, 0x8b, 0x1f, 0xdd, 0xe3, 0xd1, 0xca, - 0xdc, 0xc6, 0x7b, 0x7f, 0xd1, 0x4e, 0x27, 0x1d, 0xc0, 0xac, 0xf4, 0x9f, 0x0a, 0x62, 0xbe, 0x08, - 0xa0, 0x37, 0x8c, 0xc2, 0xd2, 0x57, 0xe1, 0x47, 0x7a, 0x5f, 0x89, 0x0d, 0x2c, 0xf4, 0x02, 0x8c, - 0x7a, 0x41, 0x9c, 0x38, 0xbe, 0x7f, 0xd5, 0x0b, 0x12, 0x61, 0xfd, 0x2b, 0x63, 0x76, 0x41, 0x83, - 0xb0, 0x89, 0x77, 0xe6, 0xdd, 0xc6, 0x77, 0xd9, 0xcf, 0xf7, 0xdc, 0x84, 0xd3, 0x57, 0xbc, 0x44, - 0x89, 0x36, 0x35, 0x8f, 0xd8, 0x26, 0x4f, 0x6a, 0x20, 0xab, 0xaf, 0x06, 0x32, 0xd2, 0x50, 0x4b, - 0xe9, 0xac, 0xd9, 0x6c, 0x1a, 0xaa, 0xed, 0xc2, 0xc9, 0x2b, 0x5e, 0x72, 0xd9, 0xf3, 0xc9, 0x21, - 0x32, 0xf9, 0xc5, 0x61, 0x18, 0x33, 0xcb, 0x62, 0xec, 0x47, 0x5f, 0x7f, 0x91, 0xee, 0x4e, 0xc4, - 0x40, 0x78, 0x2a, 0xa4, 0xe2, 0xf6, 0x81, 0x6b, 0x74, 0xe4, 0x0f, 0xae, 0xb1, 0x41, 0xd1, 0x3c, - 0xb1, 0xd9, 0x01, 0x74, 0x17, 0x2a, 0xeb, 0x2c, 0xa3, 0xb2, 0x5c, 0x44, 0x30, 0x5c, 0xde, 0xe0, - 0xeb, 0x15, 0xc9, 0x73, 0x32, 0x39, 0x3f, 0x6a, 0x54, 0x46, 0xe9, 0x44, 0x7e, 0x23, 0xcf, 0x45, - 0x58, 0x2b, 0x0a, 0xa3, 0x9f, 0x56, 0xa8, 0x3c, 0x84, 0x56, 0x48, 0xc9, 0xe8, 0xe1, 0x47, 0x24, - 0xa3, 0x59, 0x76, 0x6c, 0xb2, 0xc9, 0xb6, 0x3c, 0x22, 0x31, 0x6f, 0x84, 0x0d, 0x82, 0x91, 0x1d, - 0x9b, 0x02, 0xe3, 0x2c, 0x3e, 0xfa, 0xb8, 0x92, 0xf2, 0xd5, 0x22, 0x8e, 0xac, 0xcc, 0x19, 0x7d, - 0xd8, 0x02, 0xfe, 0x0b, 0x25, 0x98, 0xb8, 0x12, 0x74, 0x56, 0xae, 0xac, 0x74, 0xd6, 0x7c, 0xcf, - 0xbd, 0x4e, 0xba, 0x54, 0x8a, 0x6f, 0x91, 0xee, 0xc2, 0x7c, 0xd6, 0xd7, 0x73, 0x9d, 0x36, 0x62, - 0x0e, 0xa3, 0x72, 0x6b, 0xdd, 0x0b, 0x36, 0x48, 0xd4, 0x8e, 0x3c, 0x71, 0x9a, 0x64, 0xc8, 0xad, - 0xcb, 0x1a, 0x84, 0x4d, 0x3c, 0x4a, 0x3b, 0xbc, 0x1b, 0xa8, 0x1a, 0x65, 0x8a, 0xf6, 0x32, 0x6d, - 0xc4, 0x1c, 0x46, 0x91, 0x92, 0xa8, 0x23, 0x9c, 0xb5, 0x06, 0xd2, 0x2a, 0x6d, 0xc4, 0x1c, 0x26, - 0x7c, 0x2f, 0x2c, 0xd6, 0xb0, 0xd2, 0xe3, 0x7b, 0x61, 0x61, 0x3a, 0x12, 0x4e, 0x51, 0xb7, 0x48, - 0x77, 0xde, 0x49, 0x9c, 0xac, 0xeb, 0xe4, 0x3a, 0x6f, 0xc6, 0x12, 0xce, 0x0a, 0xad, 0xa7, 0x87, - 0xe3, 0x1b, 0xae, 0xd0, 0x7a, 0xba, 0xfb, 0x7d, 0x5c, 0x7e, 0x5f, 0x29, 0xc1, 0xd8, 0x1b, 0x97, - 0x31, 0xef, 0x72, 0x19, 0xd8, 0x6d, 0x98, 0xec, 0xc9, 0xcd, 0x1f, 0xc0, 0x02, 0xda, 0xb3, 0x76, - 0x8a, 0x8d, 0x61, 0x94, 0x12, 0x96, 0x85, 0x46, 0xe7, 0x60, 0x92, 0x2f, 0x62, 0xca, 0x89, 0xa5, - 0x5a, 0xab, 0x7a, 0x0b, 0xec, 0xd8, 0xf4, 0x56, 0x16, 0x88, 0x7b, 0xf1, 0xed, 0x1f, 0xb4, 0x60, - 0x3c, 0x55, 0x2e, 0xa1, 0x20, 0x5b, 0x8d, 0xad, 0xf2, 0x90, 0xc5, 0xcb, 0xb3, 0xfc, 0xa5, 0x32, - 0x53, 0xc7, 0x7a, 0x95, 0x6b, 0x10, 0x36, 0xf1, 0xec, 0x5f, 0x2f, 0x43, 0x55, 0xc6, 0xf6, 0x0d, - 0xd0, 0x95, 0xcf, 0x5b, 0x30, 0xae, 0x8e, 0xaa, 0xd9, 0xd9, 0x42, 0xa9, 0x88, 0xec, 0x4d, 0xda, - 0x03, 0xe5, 0x1d, 0x0b, 0xd6, 0x43, 0xbd, 0x71, 0xc0, 0x26, 0x33, 0x9c, 0xe6, 0x8d, 0x6e, 0x01, - 0xc4, 0xdd, 0x38, 0x21, 0x2d, 0xe3, 0x94, 0xc3, 0x36, 0x66, 0xd9, 0x8c, 0x1b, 0x46, 0x84, 0xce, - 0xa9, 0x1b, 0x61, 0x93, 0x34, 0x14, 0xa6, 0xb6, 0xf4, 0x74, 0x1b, 0x36, 0x28, 0xa1, 0x57, 0x55, - 0x60, 0xc5, 0x50, 0x11, 0xfa, 0x5d, 0x8e, 0xef, 0x20, 0x91, 0x15, 0x07, 0x88, 0x64, 0xb0, 0x7f, - 0xaa, 0x04, 0xc7, 0xb3, 0x23, 0x89, 0x3e, 0x08, 0x63, 0x72, 0xd0, 0x0c, 0x27, 0x92, 0x0c, 0xa8, - 0x1c, 0xc3, 0x06, 0xec, 0xc1, 0xce, 0xf4, 0x74, 0xef, 0xed, 0xfe, 0x33, 0x26, 0x0a, 0x4e, 0x11, - 0xe3, 0x61, 0x0e, 0x22, 0x1e, 0xa7, 0xde, 0x9d, 0x6d, 0xb7, 0x45, 0xac, 0x82, 0x11, 0xe6, 0x60, - 0x42, 0x71, 0x06, 0x1b, 0xad, 0xc0, 0x49, 0xa3, 0xe5, 0x06, 0xf1, 0x36, 0x36, 0xd7, 0xc2, 0x48, - 0xee, 0x5b, 0xcf, 0xea, 0xf0, 0xed, 0x5e, 0x1c, 0x9c, 0xfb, 0x24, 0x35, 0x90, 0x5c, 0xa7, 0xed, - 0xb8, 0x5e, 0xd2, 0x15, 0xa7, 0x4d, 0x4a, 0x9c, 0xcf, 0x89, 0x76, 0xac, 0x30, 0xec, 0xbf, 0x33, - 0x04, 0xc7, 0x79, 0xbc, 0x32, 0x51, 0xe1, 0xf8, 0xe8, 0x83, 0x50, 0x8b, 0x13, 0x27, 0xe2, 0x2e, - 0x2b, 0x6b, 0xdf, 0xa2, 0x4b, 0xd7, 0x78, 0x90, 0x44, 0xb0, 0xa6, 0x87, 0x3e, 0xc0, 0x2a, 0x03, - 0x7a, 0xf1, 0x26, 0xa3, 0x5e, 0x7a, 0x38, 0x87, 0xd8, 0x65, 0x45, 0x01, 0x1b, 0xd4, 0xd0, 0xb7, - 0x43, 0xa5, 0xbd, 0xe9, 0xc4, 0xd2, 0x5b, 0xfb, 0xac, 0x94, 0x13, 0x2b, 0xb4, 0xf1, 0xc1, 0xce, - 0xf4, 0xa9, 0xec, 0xab, 0x32, 0x00, 0xe6, 0x0f, 0x99, 0x52, 0x7e, 0x68, 0x0f, 0x29, 0xff, 0x2c, - 0x0c, 0x37, 0xa3, 0x6e, 0xe3, 0xea, 0x6c, 0xf6, 0x82, 0xa7, 0x79, 0xd6, 0x8a, 0x05, 0x94, 0xca, - 0xa4, 0x4d, 0xce, 0xb2, 0x49, 0x91, 0x87, 0xd3, 0x96, 0xc7, 0x55, 0x0d, 0xc2, 0x26, 0x1e, 0xab, - 0xd2, 0x95, 0x89, 0x66, 0x1f, 0x39, 0x84, 0x6c, 0xa7, 0x41, 0xe3, 0xd8, 0x2f, 0x41, 0x4d, 0x74, - 0x75, 0x35, 0x44, 0x2f, 0xc2, 0x18, 0x77, 0x06, 0xd6, 0x23, 0x27, 0x70, 0x37, 0xb3, 0x4e, 0x9c, - 0x55, 0x03, 0x86, 0x53, 0x98, 0xf6, 0x12, 0x0c, 0x0d, 0x28, 0x64, 0x07, 0xda, 0x9b, 0xbf, 0x17, - 0xaa, 0x94, 0x9c, 0xdc, 0xa8, 0x15, 0x41, 0x32, 0x84, 0xaa, 0xbc, 0x19, 0x16, 0xd9, 0x50, 0xf6, - 0x1c, 0x19, 0xb5, 0xa4, 0x96, 0xd0, 0x42, 0x1c, 0x77, 0xd8, 0xb4, 0xa3, 0x40, 0xf4, 0x0c, 0x94, - 0xc9, 0xbd, 0x76, 0x36, 0x3c, 0xe9, 0xd2, 0xbd, 0xb6, 0x17, 0x91, 0x98, 0x22, 0x91, 0x7b, 0x6d, - 0x74, 0x06, 0x4a, 0x5e, 0x53, 0xcc, 0x48, 0x10, 0x38, 0xa5, 0x85, 0x79, 0x5c, 0xf2, 0x9a, 0xf6, - 0x3d, 0xa8, 0xa9, 0xab, 0x68, 0xd1, 0x96, 0x34, 0xad, 0xac, 0x22, 0xe2, 0xd5, 0x25, 0xdd, 0x3e, - 0x46, 0x55, 0x07, 0x40, 0x17, 0x0f, 0x29, 0x4a, 0x05, 0x9f, 0x87, 0x21, 0x37, 0x14, 0x65, 0x9f, - 0xaa, 0x9a, 0x0c, 0xb3, 0xa5, 0x18, 0xc4, 0xbe, 0x0d, 0x13, 0xd7, 0x83, 0xf0, 0x2e, 0xbb, 0x14, - 0x8e, 0xd5, 0x40, 0xa7, 0x84, 0xd7, 0xe9, 0x8f, 0xac, 0x05, 0xcf, 0xa0, 0x98, 0xc3, 0x54, 0xa5, - 0xe3, 0x52, 0xbf, 0x4a, 0xc7, 0xf6, 0x27, 0x2c, 0x18, 0x53, 0xde, 0xd8, 0x2b, 0xdb, 0x5b, 0x83, - 0x9d, 0x02, 0x1b, 0xe5, 0x39, 0x4a, 0x7b, 0x94, 0xe7, 0x90, 0x07, 0xc6, 0xe5, 0x7e, 0x07, 0xc6, - 0xf6, 0x9f, 0x5b, 0x70, 0x5c, 0x75, 0x41, 0xda, 0x4c, 0x2f, 0xc2, 0xd8, 0x5a, 0xc7, 0xf3, 0x9b, - 0xb2, 0xb8, 0x7b, 0x66, 0xb9, 0xd4, 0x0d, 0x18, 0x4e, 0x61, 0xa2, 0x8b, 0x00, 0x6b, 0x5e, 0xe0, - 0x44, 0xdd, 0x15, 0x6d, 0xa4, 0x29, 0xbd, 0x5d, 0x57, 0x10, 0x6c, 0x60, 0xa1, 0x8f, 0x41, 0x75, - 0x5b, 0xc6, 0x09, 0x94, 0x0b, 0xad, 0x2a, 0x21, 0xc6, 0x43, 0xaf, 0x04, 0x15, 0x78, 0xa0, 0x38, - 0xda, 0x5f, 0x2a, 0xc3, 0x44, 0xba, 0x12, 0xc4, 0x00, 0x1e, 0x94, 0x67, 0xa0, 0xc2, 0x8a, 0x43, - 0x64, 0x27, 0x16, 0xaf, 0xc6, 0xce, 0x61, 0x28, 0x86, 0x61, 0x2e, 0x4a, 0x8a, 0xb9, 0xb7, 0x58, - 0x75, 0x52, 0xf9, 0x69, 0x99, 0x13, 0x5b, 0x1c, 0x7a, 0x08, 0x56, 0xe8, 0xd3, 0x16, 0x8c, 0x84, - 0x6d, 0xb3, 0xc4, 0xee, 0xfb, 0x8b, 0xac, 0x92, 0x21, 0x52, 0xd1, 0x85, 0x35, 0xa4, 0x26, 0x9e, - 0x9c, 0x0c, 0x92, 0xf5, 0x99, 0x6f, 0x83, 0x31, 0x13, 0x73, 0x2f, 0x83, 0xa8, 0x6a, 0x1a, 0x44, - 0x9f, 0x37, 0xa7, 0xa4, 0xa8, 0x03, 0x32, 0xc0, 0x62, 0xbf, 0x09, 0x15, 0x57, 0x05, 0x5e, 0x3e, - 0xd4, 0x85, 0x24, 0xaa, 0x4e, 0x1e, 0x0b, 0x6a, 0xe1, 0xd4, 0xec, 0xdf, 0xb3, 0x8c, 0xf9, 0x81, - 0x49, 0xbc, 0xd0, 0x44, 0x11, 0x94, 0x37, 0xb6, 0xb7, 0x84, 0x91, 0x71, 0xad, 0xa0, 0xe1, 0xbd, - 0xb2, 0xbd, 0xa5, 0x57, 0x98, 0xd9, 0x8a, 0x29, 0xb3, 0x01, 0x0e, 0x13, 0x52, 0xe5, 0x62, 0xca, - 0x7b, 0x97, 0x8b, 0xb1, 0x5f, 0x2f, 0xc1, 0x64, 0xcf, 0xa4, 0x42, 0xaf, 0x42, 0x25, 0xa2, 0x6f, - 0x29, 0x5e, 0x6f, 0xb1, 0xb0, 0x02, 0x2f, 0xf1, 0x42, 0x53, 0x2b, 0xef, 0x74, 0x3b, 0xe6, 0x2c, - 0xd1, 0x35, 0x40, 0x3a, 0x3c, 0x58, 0x9d, 0x64, 0xf0, 0x57, 0x56, 0x31, 0x84, 0xb3, 0x3d, 0x18, - 0x38, 0xe7, 0x29, 0xf4, 0x52, 0xf6, 0x40, 0x24, 0x53, 0xb4, 0x7d, 0xb7, 0xb3, 0x0d, 0xfb, 0x35, - 0x73, 0x0a, 0xde, 0xd2, 0xc2, 0xf4, 0xa0, 0x9b, 0xd3, 0x1e, 0xc9, 0x5a, 0x1e, 0x54, 0xb2, 0xda, - 0x3f, 0x5f, 0x82, 0xf1, 0x54, 0x11, 0x66, 0xe4, 0x43, 0x95, 0xf8, 0xec, 0xdc, 0x5e, 0x6a, 0xdf, - 0x83, 0xde, 0x21, 0xa5, 0xe4, 0xe4, 0x25, 0x41, 0x17, 0x2b, 0x0e, 0x8f, 0x47, 0xb4, 0xe3, 0x8b, - 0x30, 0x26, 0x3b, 0xf4, 0x7e, 0xa7, 0xe5, 0x67, 0x87, 0xef, 0x92, 0x01, 0xc3, 0x29, 0x4c, 0xfb, - 0x97, 0xcb, 0x30, 0xc5, 0x03, 0x1d, 0x9a, 0x6a, 0x31, 0xa8, 0x80, 0xa5, 0x1f, 0xd0, 0xa5, 0xd2, - 0xf9, 0x40, 0xae, 0x1d, 0xf4, 0xca, 0xc6, 0x7c, 0x46, 0x03, 0x05, 0xe9, 0x7f, 0x25, 0x13, 0xa4, - 0xcf, 0xb7, 0xea, 0x1b, 0x87, 0xd4, 0xa3, 0x6f, 0xac, 0xa8, 0xfd, 0x7f, 0x50, 0x82, 0x63, 0x99, - 0xfb, 0x30, 0xd1, 0x97, 0xd2, 0x57, 0x28, 0x59, 0x45, 0x1c, 0x03, 0xee, 0x7a, 0x45, 0xe2, 0xfe, - 0x2e, 0x52, 0x7a, 0x44, 0x4b, 0xc5, 0xfe, 0x9d, 0x12, 0x4c, 0xa4, 0x2f, 0xf2, 0x7c, 0x0c, 0x47, - 0xea, 0x6d, 0x50, 0x63, 0x77, 0xd5, 0x5d, 0x27, 0x5d, 0x79, 0xda, 0xc8, 0xaf, 0x05, 0x93, 0x8d, - 0x58, 0xc3, 0x1f, 0x8b, 0xfb, 0xa9, 0xec, 0x7f, 0x68, 0xc1, 0x29, 0xfe, 0x96, 0xd9, 0x79, 0xf8, - 0x57, 0xf3, 0x46, 0xf7, 0xe5, 0x62, 0x3b, 0x98, 0x29, 0xf1, 0xbf, 0xd7, 0xf8, 0x52, 0xe3, 0xe5, - 0xa4, 0xe8, 0x6d, 0x7a, 0x2a, 0x3c, 0x86, 0x9d, 0xdd, 0xd7, 0x64, 0xb0, 0xff, 0x6d, 0x09, 0x46, - 0x97, 0xe7, 0x16, 0x94, 0x08, 0xbf, 0x00, 0x35, 0x37, 0x22, 0x8e, 0x76, 0xff, 0x98, 0x61, 0x74, - 0x12, 0x80, 0x35, 0x0e, 0xdd, 0x45, 0xf1, 0x30, 0xd4, 0x38, 0xbb, 0x8b, 0xe2, 0x51, 0xaa, 0x31, - 0x96, 0x70, 0xf4, 0x3c, 0x54, 0x59, 0xb2, 0xfa, 0xcd, 0x48, 0x6a, 0x1c, 0xbd, 0xb5, 0x66, 0xed, - 0x78, 0x11, 0x2b, 0x0c, 0x4a, 0xb8, 0x19, 0xba, 0x31, 0x45, 0xce, 0x78, 0x64, 0xe6, 0x69, 0x33, - 0x5e, 0xc4, 0x12, 0xce, 0x6a, 0x8d, 0x32, 0xaf, 0x05, 0x45, 0xae, 0xa4, 0x3b, 0xcd, 0xdd, 0x1b, - 0x14, 0x5d, 0xe3, 0xec, 0xa7, 0x26, 0x6d, 0x26, 0x61, 0x74, 0x64, 0xb0, 0x84, 0x51, 0xfb, 0x77, - 0xca, 0x50, 0xd3, 0x4e, 0x35, 0x4f, 0x54, 0x68, 0x29, 0xe4, 0x0a, 0x89, 0x46, 0x37, 0x70, 0x15, - 0x69, 0x1e, 0x55, 0x60, 0x14, 0x68, 0xf9, 0x7e, 0x0b, 0x46, 0xbd, 0xc0, 0x4b, 0x3c, 0x87, 0xf9, - 0x06, 0x85, 0xdc, 0x5c, 0x29, 0xa8, 0x82, 0xc7, 0x02, 0xa7, 0x1c, 0x46, 0xe6, 0xd1, 0xbf, 0x62, - 0x86, 0x4d, 0xce, 0xe8, 0xa3, 0x22, 0x3f, 0xb1, 0x5c, 0x58, 0x99, 0xa3, 0x6a, 0x26, 0x29, 0xb1, - 0x4d, 0x6d, 0xec, 0x24, 0x2a, 0xa8, 0x3a, 0x18, 0xa6, 0xa4, 0xd4, 0x55, 0x46, 0x6a, 0x17, 0xc3, - 0x9a, 0x31, 0x67, 0x64, 0xc7, 0x80, 0x7a, 0xc7, 0x62, 0x9f, 0xb9, 0x5f, 0x17, 0xa0, 0xe6, 0x74, - 0x92, 0xb0, 0x45, 0x87, 0x49, 0x04, 0x0e, 0xe8, 0xec, 0x36, 0x09, 0xc0, 0x1a, 0xc7, 0xfe, 0x91, - 0x0a, 0x64, 0xea, 0xa5, 0xa0, 0x7b, 0x50, 0x53, 0x15, 0x53, 0x8a, 0xc9, 0xa5, 0xd6, 0x33, 0x4a, - 0x75, 0x46, 0x35, 0x61, 0xcd, 0x0c, 0x85, 0xd2, 0xcd, 0xca, 0x57, 0xfb, 0xfb, 0xb3, 0x6e, 0xd6, - 0xab, 0xfb, 0x3b, 0x7d, 0xa3, 0x73, 0xf6, 0x02, 0xaf, 0x94, 0x39, 0xb3, 0xa7, 0x67, 0xb6, 0xbc, - 0x87, 0x67, 0xf6, 0x93, 0xe2, 0xd2, 0x43, 0x4c, 0xe2, 0x8e, 0x9f, 0x88, 0x59, 0xf1, 0xde, 0x02, - 0x57, 0x1b, 0x27, 0xac, 0xeb, 0x8f, 0xf1, 0xff, 0xd8, 0x60, 0x9a, 0xf6, 0x9f, 0x0f, 0x1f, 0xaa, - 0xff, 0x7c, 0xa4, 0x50, 0xff, 0xf9, 0x45, 0x00, 0x36, 0xc7, 0x79, 0xae, 0x4a, 0x95, 0xb9, 0x35, - 0x95, 0xaa, 0xc1, 0x0a, 0x82, 0x0d, 0x2c, 0xfb, 0x5b, 0x20, 0x5d, 0x40, 0x0f, 0x4d, 0xcb, 0x7a, - 0x7d, 0xfc, 0x64, 0x90, 0xa5, 0x09, 0xa7, 0x4a, 0xeb, 0xfd, 0xac, 0x05, 0x66, 0x95, 0x3f, 0xf4, - 0x0a, 0x2f, 0x27, 0x68, 0x15, 0x71, 0xd2, 0x64, 0xd0, 0x9d, 0x59, 0x72, 0xda, 0x99, 0xe8, 0x27, - 0x59, 0x53, 0xf0, 0xcc, 0xbb, 0xa1, 0x2a, 0xa1, 0xfb, 0x32, 0x9a, 0x3f, 0x0e, 0x27, 0x64, 0xc9, - 0x11, 0x79, 0x28, 0x24, 0xa2, 0x10, 0x8e, 0x26, 0xe3, 0xe4, 0xe7, 0x2c, 0x38, 0x9f, 0xed, 0x40, - 0xbc, 0x14, 0x06, 0x5e, 0x12, 0x46, 0x0d, 0x92, 0x24, 0x5e, 0xb0, 0xc1, 0xaa, 0x3e, 0xdf, 0x75, - 0x22, 0x79, 0xe5, 0x19, 0x13, 0x98, 0xb7, 0x9d, 0x28, 0xc0, 0xac, 0x15, 0x75, 0x61, 0x98, 0x07, - 0xd4, 0x8b, 0xdd, 0xd0, 0x01, 0xd7, 0x46, 0xce, 0x70, 0xe8, 0xed, 0x18, 0x0f, 0xe6, 0xc7, 0x82, - 0xa1, 0xfd, 0x35, 0x0b, 0xd0, 0xf2, 0x36, 0x89, 0x22, 0xaf, 0x69, 0xa4, 0x00, 0xb0, 0xcb, 0x83, - 0x8d, 0x4b, 0x82, 0xcd, 0x82, 0x38, 0x99, 0xcb, 0x83, 0x8d, 0x7f, 0xf9, 0x97, 0x07, 0x97, 0xf6, - 0x77, 0x79, 0x30, 0x5a, 0x86, 0x53, 0x2d, 0xbe, 0x9d, 0xe3, 0x17, 0x72, 0xf2, 0xbd, 0x9d, 0xaa, - 0xdd, 0x70, 0xfa, 0xfe, 0xce, 0xf4, 0xa9, 0xa5, 0x3c, 0x04, 0x9c, 0xff, 0x9c, 0xfd, 0x6e, 0x40, - 0x3c, 0x14, 0x76, 0x2e, 0x2f, 0x7c, 0xb5, 0xaf, 0xbb, 0xc3, 0xfe, 0x72, 0x05, 0x8e, 0x65, 0x2e, - 0xc4, 0xa1, 0x5b, 0xe9, 0xde, 0x78, 0xd9, 0x03, 0xeb, 0xf1, 0xde, 0xee, 0x0d, 0x14, 0x81, 0x1b, - 0x40, 0xc5, 0x0b, 0xda, 0x9d, 0xa4, 0x98, 0xd2, 0x31, 0xbc, 0x13, 0x0b, 0x94, 0xa0, 0x71, 0x3e, - 0x41, 0xff, 0x62, 0xce, 0xa6, 0xc8, 0x78, 0xde, 0xd4, 0x66, 0x67, 0xe8, 0x11, 0xb9, 0x5b, 0x3e, - 0xa9, 0xa3, 0x6b, 0x2b, 0x45, 0xf8, 0x92, 0x33, 0x93, 0xe5, 0xb0, 0x43, 0xaf, 0x7e, 0xba, 0x04, - 0xa3, 0xc6, 0x47, 0x43, 0x3f, 0x96, 0xae, 0x81, 0x6b, 0x15, 0xf7, 0x4a, 0x8c, 0xfe, 0x8c, 0xae, - 0x72, 0xcb, 0x5f, 0xe9, 0xd9, 0xde, 0xf2, 0xb7, 0x0f, 0x76, 0xa6, 0x8f, 0x67, 0x0a, 0xdc, 0xa6, - 0x4a, 0xe2, 0x9e, 0xf9, 0x6e, 0x38, 0x96, 0x21, 0x93, 0xf3, 0xca, 0xab, 0xe6, 0x2b, 0x1f, 0xd8, - 0xed, 0x67, 0x0e, 0xd9, 0x4f, 0xd2, 0x21, 0x13, 0x15, 0x2b, 0x42, 0x9f, 0x0c, 0xe0, 0xf3, 0xcc, - 0xec, 0x33, 0x4a, 0x03, 0x16, 0xa6, 0x79, 0x0e, 0xaa, 0xed, 0xd0, 0xf7, 0x5c, 0x4f, 0x95, 0xd0, - 0x67, 0xa5, 0x70, 0x56, 0x44, 0x1b, 0x56, 0x50, 0x74, 0x17, 0x6a, 0x77, 0xee, 0x26, 0xfc, 0xb8, - 0x51, 0x1c, 0x69, 0x14, 0x75, 0xca, 0xa8, 0x8c, 0x16, 0x75, 0x9e, 0x89, 0x35, 0x2f, 0x64, 0xc3, - 0x30, 0x53, 0x82, 0x32, 0x7b, 0x95, 0x1d, 0xb7, 0x30, 0xed, 0x18, 0x63, 0x01, 0xb1, 0xff, 0xf5, - 0x28, 0x9c, 0xcc, 0xbb, 0x95, 0x0c, 0x7d, 0x0c, 0x86, 0x79, 0x1f, 0x8b, 0xb9, 0xf8, 0x32, 0x8f, - 0xc7, 0x15, 0x46, 0x50, 0x74, 0x8b, 0xfd, 0xc6, 0x82, 0xa7, 0xe0, 0xee, 0x3b, 0x6b, 0x62, 0x86, - 0x1c, 0x0e, 0xf7, 0x45, 0x47, 0x73, 0x5f, 0x74, 0x38, 0x77, 0xdf, 0x59, 0x43, 0xf7, 0xa0, 0xb2, - 0xe1, 0x25, 0xc4, 0x11, 0x4e, 0x9a, 0xdb, 0x87, 0xc2, 0x9c, 0x38, 0xdc, 0x4a, 0x63, 0x3f, 0x31, - 0x67, 0x88, 0xbe, 0x6a, 0xc1, 0xb1, 0xb5, 0x74, 0x45, 0x2c, 0x21, 0x3c, 0x9d, 0x43, 0xb8, 0x79, - 0x2e, 0xcd, 0x88, 0xdf, 0x9e, 0x9d, 0x69, 0xc4, 0xd9, 0xee, 0xa0, 0x4f, 0x59, 0x30, 0xb2, 0xee, - 0xf9, 0xc6, 0x0d, 0x37, 0x87, 0xf0, 0x71, 0x2e, 0x33, 0x06, 0x7a, 0xc7, 0xc1, 0xff, 0xc7, 0x58, - 0x72, 0xee, 0xa7, 0xa9, 0x86, 0x0f, 0xaa, 0xa9, 0x46, 0x1e, 0x91, 0xa6, 0xfa, 0xac, 0x05, 0x35, - 0x35, 0xd2, 0xa2, 0xb2, 0xd0, 0x07, 0x0f, 0xf1, 0x93, 0x73, 0xcf, 0x94, 0xfa, 0x8b, 0x35, 0x73, - 0xf4, 0x9a, 0x05, 0xa3, 0xce, 0xab, 0x9d, 0x88, 0x34, 0xc9, 0x76, 0xd8, 0x8e, 0x45, 0xc9, 0xdf, - 0x97, 0x8b, 0xef, 0xcc, 0x2c, 0x65, 0x32, 0x4f, 0xb6, 0x97, 0xdb, 0xb1, 0xc8, 0xac, 0xd7, 0x0d, - 0xd8, 0xec, 0x02, 0xfa, 0x3e, 0xad, 0xc7, 0xa1, 0x88, 0xc2, 0xef, 0x79, 0xbd, 0x19, 0xa8, 0x50, - 0x04, 0x81, 0xa7, 0xdc, 0x30, 0x48, 0xbc, 0xa0, 0x43, 0x96, 0x03, 0x4c, 0xda, 0xe1, 0x8d, 0x30, - 0xb9, 0x1c, 0x76, 0x82, 0xe6, 0xa5, 0x28, 0x0a, 0x23, 0x56, 0x3a, 0xc9, 0xb8, 0xef, 0x78, 0xae, - 0x3f, 0x2a, 0xde, 0x8d, 0xce, 0x41, 0x6c, 0x86, 0x9d, 0x12, 0x4c, 0xef, 0x31, 0xd8, 0xe8, 0x45, - 0x18, 0x0b, 0xa3, 0x0d, 0x27, 0xf0, 0x5e, 0x35, 0xab, 0x01, 0x2a, 0x83, 0x74, 0xd9, 0x80, 0xe1, - 0x14, 0xa6, 0x59, 0x26, 0xaa, 0xb4, 0x47, 0x99, 0xa8, 0xf3, 0x30, 0x14, 0x91, 0x76, 0x98, 0xdd, - 0x57, 0xb1, 0x04, 0x54, 0x06, 0x41, 0x4f, 0x43, 0xd9, 0x69, 0x7b, 0xc2, 0xc9, 0xa8, 0xb6, 0x8b, - 0xb3, 0x2b, 0x0b, 0x98, 0xb6, 0xa7, 0xaa, 0xd6, 0x55, 0x8e, 0xa4, 0x6a, 0x1d, 0xd5, 0x98, 0xe2, - 0x18, 0x6d, 0x58, 0x6b, 0xcc, 0xf4, 0xf1, 0x96, 0xfd, 0x7a, 0x19, 0x9e, 0xde, 0x75, 0x69, 0xe9, - 0x10, 0x76, 0x6b, 0x97, 0x10, 0x76, 0x39, 0x3c, 0xa5, 0xbd, 0x86, 0xa7, 0xdc, 0x67, 0x78, 0x3e, - 0x45, 0x25, 0x86, 0xac, 0xa2, 0x28, 0x94, 0xc4, 0x01, 0xd3, 0x0a, 0xfa, 0x15, 0x65, 0x14, 0xc2, - 0x42, 0x42, 0xb1, 0xe6, 0x4b, 0xb7, 0x4b, 0xa9, 0x12, 0x49, 0x95, 0x22, 0x34, 0x66, 0xdf, 0x4a, - 0x86, 0x5c, 0x4c, 0xf4, 0xab, 0xbb, 0x64, 0xff, 0xc2, 0x10, 0x3c, 0x33, 0x80, 0xa2, 0x33, 0x67, - 0xb1, 0x35, 0xe0, 0x2c, 0xfe, 0x06, 0xff, 0x4c, 0x9f, 0xc9, 0xfd, 0x4c, 0xb8, 0xf8, 0xcf, 0xb4, - 0xfb, 0x17, 0x62, 0x27, 0x11, 0x41, 0x4c, 0xdc, 0x4e, 0xc4, 0xd3, 0x79, 0x8c, 0xec, 0xf4, 0x05, - 0xd1, 0x8e, 0x15, 0x06, 0xdd, 0xfe, 0xba, 0x0e, 0x5d, 0xfe, 0x23, 0x05, 0x95, 0xc4, 0x31, 0x13, - 0xdd, 0xb9, 0xf5, 0x35, 0x37, 0x4b, 0x25, 0x00, 0x67, 0x63, 0xff, 0x8a, 0x05, 0x67, 0xfa, 0x5b, - 0x23, 0xe8, 0x1d, 0x30, 0xba, 0xc6, 0x82, 0x2a, 0x97, 0x58, 0xe8, 0x94, 0x98, 0x3a, 0xec, 0x7d, - 0x75, 0x33, 0x36, 0x71, 0xd0, 0x1c, 0x4c, 0x9a, 0xd1, 0x98, 0x4b, 0x46, 0xcc, 0x15, 0xf3, 0x97, - 0xac, 0x66, 0x81, 0xb8, 0x17, 0x1f, 0xcd, 0x00, 0x24, 0x5e, 0xe2, 0x13, 0xfe, 0x34, 0x9f, 0x68, - 0xcc, 0xa1, 0xb8, 0xaa, 0x5a, 0xb1, 0x81, 0x61, 0x7f, 0xbd, 0x9c, 0xff, 0x1a, 0xdc, 0xca, 0xdd, - 0xcf, 0xec, 0x17, 0x73, 0xbb, 0x34, 0x80, 0x84, 0x2e, 0x1f, 0xb5, 0x84, 0x1e, 0xea, 0x27, 0xa1, - 0xd1, 0x3c, 0x1c, 0x37, 0x6e, 0x50, 0xe6, 0x45, 0x95, 0xf8, 0xe1, 0x94, 0xaa, 0x88, 0xb8, 0x92, - 0x81, 0xe3, 0x9e, 0x27, 0x1e, 0xf3, 0xa9, 0xfa, 0xab, 0x25, 0x38, 0xdd, 0x77, 0x63, 0x71, 0x44, - 0x1a, 0xc8, 0xfc, 0xfc, 0x43, 0x47, 0xf3, 0xf9, 0xcd, 0x8f, 0x52, 0xd9, 0xf3, 0xa3, 0x0c, 0xa2, - 0xce, 0x7f, 0xb7, 0xd4, 0x77, 0xb1, 0xd0, 0x8d, 0xe8, 0x5f, 0xd8, 0x91, 0x7c, 0x09, 0xc6, 0x9d, - 0x76, 0x9b, 0xe3, 0xb1, 0x0c, 0x8d, 0x4c, 0x95, 0xd6, 0x59, 0x13, 0x88, 0xd3, 0xb8, 0x03, 0x0d, - 0xec, 0x7f, 0xb0, 0xa0, 0x86, 0xc9, 0x3a, 0x97, 0x70, 0xe8, 0x8e, 0x18, 0x22, 0xab, 0x88, 0xab, - 0x32, 0xe8, 0xc0, 0xc6, 0x1e, 0x2b, 0xc4, 0x90, 0x37, 0xd8, 0x07, 0xad, 0xb3, 0xa1, 0xae, 0x1f, - 0x2e, 0xf7, 0xbf, 0x7e, 0xd8, 0xfe, 0xb3, 0x31, 0xfa, 0x7a, 0xed, 0x70, 0x2e, 0x22, 0xcd, 0x98, - 0x7e, 0xdf, 0x4e, 0xe4, 0x8b, 0x49, 0xa2, 0xbe, 0xef, 0x4d, 0xbc, 0x88, 0x69, 0x7b, 0xea, 0x9c, - 0xb2, 0xb4, 0xaf, 0x1a, 0x95, 0xe5, 0x3d, 0x6b, 0x54, 0xbe, 0x04, 0xe3, 0x71, 0xbc, 0xb9, 0x12, - 0x79, 0xdb, 0x4e, 0x42, 0xae, 0x13, 0x59, 0x40, 0x4a, 0xd7, 0x6b, 0x6b, 0x5c, 0xd5, 0x40, 0x9c, - 0xc6, 0x45, 0x57, 0x60, 0x52, 0x57, 0x8a, 0x24, 0x51, 0xc2, 0x52, 0x20, 0xf9, 0x4c, 0x50, 0xc5, - 0x81, 0x74, 0x6d, 0x49, 0x81, 0x80, 0x7b, 0x9f, 0xa1, 0x32, 0x37, 0xd5, 0x48, 0x3b, 0x32, 0x9c, - 0x96, 0xb9, 0x29, 0x3a, 0xb4, 0x2f, 0x3d, 0x4f, 0xa0, 0x25, 0x38, 0xc1, 0x27, 0xc6, 0x6c, 0xbb, - 0x6d, 0xbc, 0xd1, 0x48, 0xfa, 0x7e, 0x82, 0x2b, 0xbd, 0x28, 0x38, 0xef, 0x39, 0xf4, 0x02, 0x8c, - 0xaa, 0xe6, 0x85, 0x79, 0x71, 0xb4, 0xa6, 0x5c, 0x7b, 0x8a, 0xcc, 0x42, 0x13, 0x9b, 0x78, 0xe8, - 0xfd, 0xf0, 0xa4, 0xfe, 0xcb, 0x53, 0xea, 0xf9, 0xb9, 0xf3, 0xbc, 0x28, 0xc2, 0xab, 0xae, 0xbf, - 0xbb, 0x92, 0x8b, 0xd6, 0xc4, 0xfd, 0x9e, 0x47, 0x6b, 0x70, 0x46, 0x81, 0x2e, 0x05, 0x09, 0x4b, - 0x7a, 0x8d, 0x49, 0xdd, 0x89, 0x59, 0x04, 0x05, 0xb0, 0xf7, 0xb4, 0x05, 0xf5, 0x33, 0x57, 0xbc, - 0xe4, 0x6a, 0x1e, 0x26, 0x5e, 0xc4, 0xbb, 0x50, 0x41, 0x17, 0xa0, 0x46, 0x02, 0x67, 0xcd, 0x27, - 0xcb, 0x73, 0x0b, 0x62, 0x47, 0xaa, 0xb3, 0x24, 0x24, 0x00, 0x6b, 0x1c, 0x15, 0xe7, 0x3f, 0xd6, - 0x2f, 0xce, 0x1f, 0xad, 0xc0, 0xc9, 0x0d, 0xb7, 0x4d, 0xad, 0x4c, 0xcf, 0x25, 0xb3, 0x2e, 0x0b, - 0x2c, 0xa6, 0x1f, 0x86, 0x5f, 0x1c, 0xa1, 0x12, 0xa6, 0xae, 0xcc, 0xad, 0xf4, 0xe0, 0xe0, 0xdc, - 0x27, 0x59, 0x00, 0x7a, 0x14, 0xde, 0xeb, 0x4e, 0x9d, 0xc8, 0x04, 0xa0, 0xd3, 0x46, 0xcc, 0x61, - 0xe8, 0x1a, 0x20, 0x96, 0x34, 0x78, 0x35, 0x49, 0xda, 0xca, 0xac, 0x9d, 0x3a, 0x99, 0x2e, 0xc9, - 0x79, 0xb9, 0x07, 0x03, 0xe7, 0x3c, 0x45, 0xad, 0x9e, 0x20, 0x64, 0xd4, 0xa7, 0x9e, 0x4c, 0x5b, - 0x3d, 0x37, 0x78, 0x33, 0x96, 0x70, 0xf4, 0x21, 0x98, 0xea, 0xc4, 0x84, 0x6d, 0x98, 0x6f, 0x87, - 0xd1, 0x96, 0x1f, 0x3a, 0xcd, 0x05, 0x76, 0xcf, 0x71, 0xd2, 0x9d, 0x9a, 0x62, 0xcc, 0xcf, 0x8b, - 0x67, 0xa7, 0x6e, 0xf6, 0xc1, 0xc3, 0x7d, 0x29, 0x64, 0x6b, 0xca, 0x9e, 0x1e, 0xb0, 0xa6, 0xec, - 0x0a, 0x9c, 0x94, 0x7a, 0x6d, 0x79, 0x6e, 0x41, 0xbd, 0xf4, 0xd4, 0x99, 0xf4, 0xc5, 0x89, 0x0b, - 0x39, 0x38, 0x38, 0xf7, 0x49, 0xb4, 0x05, 0x4f, 0x33, 0x1f, 0x8b, 0xf8, 0x38, 0x2b, 0x91, 0x17, - 0xb8, 0x5e, 0xdb, 0xf1, 0xf9, 0x92, 0x5c, 0x68, 0x4e, 0x3d, 0xcd, 0xba, 0xf6, 0x16, 0x41, 0xfa, - 0xe9, 0xd9, 0xdd, 0x90, 0xf1, 0xee, 0xb4, 0xd0, 0x5d, 0x78, 0xf3, 0x2e, 0x08, 0x5c, 0xb5, 0x4c, - 0x9d, 0x63, 0x0c, 0xbf, 0x59, 0x30, 0x7c, 0xf3, 0xec, 0x5e, 0x0f, 0xe0, 0xbd, 0x69, 0xf6, 0x7d, - 0xcb, 0x55, 0x12, 0x38, 0xec, 0x2d, 0xa7, 0x07, 0x78, 0x4b, 0x89, 0x8c, 0x77, 0xa7, 0x85, 0x36, - 0xe1, 0x2c, 0x43, 0x98, 0x75, 0x13, 0x6f, 0x5b, 0x97, 0x0b, 0xba, 0x14, 0x34, 0xdb, 0xa1, 0x17, - 0x24, 0x53, 0xe7, 0x19, 0xaf, 0x6f, 0x12, 0xbc, 0xce, 0xce, 0xee, 0x82, 0x8b, 0x77, 0xa5, 0x64, - 0xff, 0x81, 0x05, 0xe3, 0x4a, 0xfd, 0x1c, 0x41, 0x06, 0xba, 0x9f, 0xce, 0x40, 0xbf, 0x72, 0x70, - 0x05, 0xce, 0x7a, 0xde, 0x27, 0x4f, 0xea, 0xbf, 0x4d, 0x02, 0x68, 0x25, 0xaf, 0xec, 0x2b, 0xab, - 0xaf, 0x7d, 0xf5, 0xd8, 0x2a, 0xd8, 0xbc, 0x02, 0xaf, 0x95, 0x47, 0x5b, 0xe0, 0xb5, 0x01, 0xa7, - 0xa4, 0x3c, 0xe0, 0xf1, 0x00, 0x57, 0xc3, 0x58, 0xe9, 0x6b, 0xe3, 0x1a, 0xd3, 0x85, 0x3c, 0x24, - 0x9c, 0xff, 0x6c, 0xca, 0x30, 0x1f, 0xd9, 0xd3, 0x30, 0x57, 0x2a, 0x6a, 0x71, 0x5d, 0x5e, 0x32, - 0x9c, 0x51, 0x51, 0x8b, 0x97, 0x1b, 0x58, 0xe3, 0xe4, 0xdb, 0x29, 0xb5, 0x82, 0xec, 0x14, 0xd8, - 0xb7, 0x9d, 0x22, 0x35, 0xe6, 0x68, 0x5f, 0x8d, 0x29, 0xcf, 0x1d, 0xc7, 0xfa, 0x9e, 0x3b, 0xbe, - 0x07, 0x26, 0xbc, 0x60, 0x93, 0x44, 0x5e, 0x42, 0x9a, 0x6c, 0x2d, 0x30, 0x6d, 0x5a, 0xd5, 0x56, - 0xea, 0x42, 0x0a, 0x8a, 0x33, 0xd8, 0x69, 0x35, 0x3f, 0x31, 0x80, 0x9a, 0xef, 0x63, 0x5c, 0x1d, - 0x2b, 0xc6, 0xb8, 0x3a, 0x7e, 0x70, 0xe3, 0x6a, 0xf2, 0x50, 0x8d, 0x2b, 0x54, 0x88, 0x71, 0x35, - 0x90, 0xdd, 0x62, 0x78, 0x58, 0x4e, 0xee, 0xe1, 0x61, 0xe9, 0x67, 0x59, 0x9d, 0x7a, 0x68, 0xcb, - 0x2a, 0xdf, 0x68, 0x7a, 0xe2, 0x0d, 0xa3, 0xa9, 0x10, 0xa3, 0xe9, 0x19, 0xa8, 0x34, 0x49, 0x3b, - 0xd9, 0x9c, 0x7a, 0x8a, 0x4d, 0x56, 0xf5, 0xfd, 0xe7, 0x69, 0x23, 0xe6, 0x30, 0x94, 0xc0, 0xf9, - 0xbb, 0x64, 0x6d, 0x33, 0x0c, 0xb7, 0x96, 0x9c, 0xc0, 0x5b, 0x27, 0xe2, 0x12, 0x83, 0xdb, 0x4e, - 0xd4, 0x12, 0x05, 0xe4, 0x9b, 0x53, 0x67, 0x59, 0x17, 0x9e, 0x13, 0xcf, 0x9f, 0xbf, 0xbd, 0x07, - 0x3e, 0xde, 0x93, 0xe2, 0x1b, 0xf6, 0xdc, 0x37, 0xb2, 0x3d, 0xf7, 0xd9, 0x12, 0x9c, 0xd2, 0x16, - 0x0f, 0xd5, 0x33, 0xde, 0x3a, 0xd5, 0xf9, 0x04, 0x5d, 0x04, 0xe0, 0x51, 0x30, 0x46, 0x1d, 0x0d, - 0x5d, 0x49, 0x44, 0x41, 0xb0, 0x81, 0xc5, 0xca, 0x51, 0x90, 0x88, 0xdd, 0x45, 0x96, 0x35, 0x87, - 0xe6, 0x44, 0x3b, 0x56, 0x18, 0x74, 0x71, 0xd1, 0xdf, 0xa2, 0x2a, 0x52, 0xf6, 0x96, 0x8b, 0x39, - 0x0d, 0xc2, 0x26, 0x1e, 0x7a, 0x8e, 0x33, 0x61, 0xaa, 0x98, 0x9a, 0x44, 0x63, 0xdc, 0xd7, 0xa4, - 0xb4, 0xaf, 0x82, 0xca, 0xee, 0xb0, 0x72, 0x29, 0x95, 0xde, 0xee, 0xb0, 0xc0, 0x72, 0x85, 0x61, - 0xff, 0x0f, 0x0b, 0x4e, 0xe7, 0x0e, 0xc5, 0x11, 0x98, 0xb9, 0xf7, 0xd2, 0x66, 0x6e, 0xa3, 0x28, - 0x3f, 0x95, 0xf1, 0x16, 0x7d, 0x4c, 0xde, 0x7f, 0x67, 0xc1, 0x84, 0xc6, 0x3f, 0x82, 0x57, 0xf5, - 0xd2, 0xaf, 0x5a, 0x9c, 0x4b, 0xae, 0xd6, 0xf3, 0x6e, 0xbf, 0x5c, 0x02, 0x75, 0xf3, 0xcc, 0xac, - 0x9b, 0x0c, 0x96, 0x8b, 0xda, 0x85, 0x61, 0x16, 0x56, 0x16, 0x17, 0x13, 0x32, 0x9b, 0xe6, 0xcf, - 0x42, 0xd4, 0xf4, 0x29, 0x3f, 0xfb, 0x1b, 0x63, 0xc1, 0x90, 0xdd, 0x94, 0x27, 0xe5, 0x74, 0x39, - 0x6d, 0xcc, 0x2a, 0x79, 0xac, 0x30, 0xa8, 0x21, 0xe6, 0xb9, 0x61, 0x30, 0xe7, 0x3b, 0x71, 0x2c, - 0xf6, 0x06, 0xca, 0x10, 0x5b, 0x90, 0x00, 0xac, 0x71, 0x58, 0xc4, 0x99, 0x17, 0xb7, 0x7d, 0xa7, - 0x6b, 0x38, 0x5e, 0x8d, 0xea, 0x7f, 0x0a, 0x84, 0x4d, 0x3c, 0xbb, 0x05, 0x53, 0xe9, 0x97, 0x98, - 0x27, 0xeb, 0x2c, 0xed, 0x63, 0xa0, 0xe1, 0xbc, 0x00, 0x35, 0x87, 0x3d, 0xb5, 0xd8, 0x71, 0x84, - 0x4c, 0xd0, 0xc9, 0x0f, 0x12, 0x80, 0x35, 0x8e, 0xfd, 0xad, 0x70, 0x22, 0x67, 0xcc, 0x06, 0x88, - 0xaa, 0xfd, 0xf9, 0x12, 0x1c, 0x4b, 0x3f, 0x19, 0xb3, 0xc4, 0x68, 0xde, 0x67, 0x2f, 0x76, 0xc3, - 0x6d, 0x12, 0x75, 0x69, 0x37, 0xac, 0x4c, 0x62, 0x74, 0x0f, 0x06, 0xce, 0x79, 0x8a, 0x5d, 0x02, - 0xd5, 0x54, 0xaf, 0x2e, 0xa7, 0xc7, 0xad, 0x22, 0xa7, 0x87, 0x1e, 0x59, 0x33, 0x12, 0x50, 0xb1, - 0xc4, 0x26, 0x7f, 0x6a, 0x57, 0xb3, 0xb4, 0xae, 0x7a, 0xc7, 0xf3, 0x13, 0x2f, 0x10, 0xaf, 0x2c, - 0x26, 0x8e, 0xb2, 0xab, 0x97, 0x7a, 0x51, 0x70, 0xde, 0x73, 0xf6, 0xd7, 0x86, 0x40, 0x95, 0x47, - 0x62, 0x91, 0xda, 0x05, 0xc5, 0xb9, 0xef, 0x37, 0xbd, 0x5e, 0x7d, 0xe9, 0xa1, 0xdd, 0x42, 0x27, - 0xb9, 0xeb, 0xdc, 0x3c, 0x63, 0x53, 0x03, 0xb6, 0xaa, 0x41, 0xd8, 0xc4, 0xa3, 0x3d, 0xf1, 0xbd, - 0x6d, 0xc2, 0x1f, 0x1a, 0x4e, 0xf7, 0x64, 0x51, 0x02, 0xb0, 0xc6, 0x61, 0xf7, 0x2c, 0x78, 0xeb, - 0xeb, 0xc2, 0x0f, 0xac, 0xef, 0x59, 0xf0, 0xd6, 0xd7, 0x31, 0x83, 0xf0, 0x6b, 0x02, 0xc3, 0x2d, - 0xb1, 0x97, 0x34, 0xae, 0x09, 0x0c, 0xb7, 0x30, 0x83, 0xd0, 0xaf, 0x14, 0x84, 0x51, 0xcb, 0xf1, - 0xbd, 0x57, 0x49, 0x53, 0x71, 0x11, 0x7b, 0x48, 0xf5, 0x95, 0x6e, 0xf4, 0xa2, 0xe0, 0xbc, 0xe7, - 0xe8, 0x84, 0x6e, 0x47, 0xa4, 0xe9, 0xb9, 0x89, 0x49, 0x0d, 0xd2, 0x13, 0x7a, 0xa5, 0x07, 0x03, - 0xe7, 0x3c, 0x85, 0x66, 0xe1, 0x98, 0x2c, 0x6f, 0x25, 0x4b, 0xc3, 0x8e, 0xa6, 0xeb, 0x4b, 0xe2, - 0x34, 0x18, 0x67, 0xf1, 0xa9, 0xc4, 0x6a, 0x89, 0x72, 0xe5, 0x6c, 0xcb, 0x69, 0x48, 0x2c, 0x59, - 0xc6, 0x1c, 0x2b, 0x0c, 0xfb, 0x93, 0x65, 0xaa, 0x61, 0xfb, 0xdc, 0x0a, 0x70, 0x64, 0x79, 0x15, - 0xe9, 0x19, 0x39, 0x34, 0xc0, 0x8c, 0x7c, 0x17, 0x8c, 0xdd, 0x89, 0xc3, 0x40, 0xe5, 0x2c, 0x54, - 0xfa, 0xe6, 0x2c, 0x18, 0x58, 0xf9, 0x39, 0x0b, 0xc3, 0x45, 0xe5, 0x2c, 0x8c, 0x3c, 0x64, 0xce, - 0xc2, 0xbf, 0xac, 0x80, 0xba, 0x07, 0xfa, 0x06, 0x49, 0xee, 0x86, 0xd1, 0x96, 0x17, 0x6c, 0xb0, - 0x52, 0x4d, 0x5f, 0xb5, 0x64, 0xb5, 0xa7, 0x45, 0x33, 0xa7, 0x7f, 0xbd, 0xa0, 0xbb, 0x7c, 0x53, - 0xcc, 0x66, 0x56, 0x0d, 0x46, 0x3c, 0xf6, 0x2d, 0x53, 0x55, 0x4a, 0x1c, 0xeb, 0xa5, 0x7a, 0x84, - 0xbe, 0x1b, 0x40, 0x1e, 0x9a, 0xad, 0x4b, 0x09, 0xbc, 0x50, 0x4c, 0xff, 0x30, 0x59, 0xd7, 0xf6, - 0xed, 0xaa, 0x62, 0x82, 0x0d, 0x86, 0xe8, 0xb3, 0xba, 0xde, 0x01, 0x4f, 0x72, 0xfc, 0xe8, 0xa1, - 0x8c, 0xcd, 0x20, 0xd5, 0x0e, 0x30, 0x8c, 0x78, 0xc1, 0x06, 0x9d, 0x27, 0x22, 0xb6, 0xfb, 0xad, - 0x79, 0x95, 0x00, 0x17, 0x43, 0xa7, 0x59, 0x77, 0x7c, 0x27, 0x70, 0x49, 0xb4, 0xc0, 0xd1, 0xf5, - 0x5e, 0x5a, 0x34, 0x60, 0x49, 0xa8, 0xe7, 0xb2, 0xea, 0xca, 0x20, 0x97, 0x55, 0x9f, 0xf9, 0x4e, - 0x98, 0xec, 0xf9, 0x98, 0xfb, 0x2a, 0x6e, 0x70, 0x80, 0x1a, 0x80, 0xbf, 0x30, 0xac, 0x95, 0xd6, - 0x8d, 0xb0, 0xc9, 0xef, 0x3e, 0x8e, 0xf4, 0x17, 0x15, 0xf6, 0x6b, 0x81, 0x53, 0x44, 0xa9, 0x19, - 0xa3, 0x11, 0x9b, 0x2c, 0xe9, 0x1c, 0x6d, 0x3b, 0x11, 0x09, 0x0e, 0x7b, 0x8e, 0xae, 0x28, 0x26, - 0xd8, 0x60, 0x88, 0x36, 0x53, 0x59, 0xb8, 0x97, 0x0f, 0x9e, 0x85, 0xcb, 0xea, 0x33, 0xe7, 0x5d, - 0x11, 0xfa, 0x9a, 0x05, 0x13, 0x41, 0x6a, 0xe6, 0x16, 0x93, 0x70, 0x93, 0xbf, 0x2a, 0xea, 0xe8, - 0xfe, 0xce, 0xf4, 0x44, 0xba, 0x0d, 0x67, 0xf8, 0xe7, 0xa9, 0xb4, 0xca, 0x3e, 0x55, 0x9a, 0xbe, - 0x7b, 0x7d, 0xb8, 0xdf, 0xdd, 0xeb, 0x28, 0x80, 0x61, 0x5e, 0x45, 0x56, 0x84, 0xdd, 0x1c, 0xb0, - 0x96, 0x91, 0x59, 0x8a, 0x96, 0xf3, 0xe3, 0x2d, 0x58, 0x70, 0x41, 0xb7, 0xcd, 0x24, 0xfd, 0xea, - 0xbe, 0xb3, 0x40, 0xc7, 0xfb, 0x25, 0xf3, 0xdb, 0xff, 0x67, 0x08, 0x8e, 0xcb, 0x11, 0x91, 0xc9, - 0x7a, 0x54, 0x3f, 0x72, 0xbe, 0xda, 0x56, 0x56, 0xfa, 0xf1, 0xaa, 0x04, 0x60, 0x8d, 0x43, 0xed, - 0xb1, 0x4e, 0x4c, 0x96, 0xdb, 0x24, 0x58, 0xf4, 0xd6, 0x62, 0x11, 0x20, 0xa3, 0x16, 0xca, 0x4d, - 0x0d, 0xc2, 0x26, 0x1e, 0xab, 0x24, 0xe0, 0x9a, 0xe5, 0x7c, 0x74, 0x25, 0x01, 0x61, 0xa8, 0x4a, - 0x38, 0xfa, 0xd1, 0xdc, 0x6b, 0x8a, 0x8a, 0x49, 0x75, 0xef, 0xc9, 0x51, 0xdc, 0xdf, 0xfd, 0x44, - 0xe8, 0xef, 0x5a, 0x70, 0x8a, 0xb7, 0xca, 0x91, 0xbc, 0xd9, 0x6e, 0x3a, 0x09, 0x89, 0x8b, 0xb9, - 0x5e, 0x32, 0xa7, 0x7f, 0xfa, 0xa8, 0x24, 0x8f, 0x2d, 0xce, 0xef, 0x0d, 0xfa, 0x92, 0x05, 0xc7, - 0xb6, 0x52, 0xe5, 0xf8, 0xa4, 0xea, 0x38, 0x68, 0xad, 0xaa, 0x14, 0x51, 0xbd, 0xd4, 0xd2, 0xed, - 0x31, 0xce, 0x72, 0xb7, 0xff, 0xd4, 0x02, 0x53, 0x8c, 0x1e, 0x7d, 0x15, 0xbf, 0xfd, 0x9b, 0x82, - 0xd2, 0xba, 0xac, 0xf4, 0xb5, 0x2e, 0x9f, 0x86, 0x72, 0xc7, 0x6b, 0x8a, 0xfd, 0x85, 0x0e, 0xc9, - 0x59, 0x98, 0xc7, 0xb4, 0xdd, 0xfe, 0xbf, 0x15, 0xed, 0x93, 0x10, 0x19, 0xe4, 0x7f, 0x21, 0x5e, - 0x3b, 0x50, 0x65, 0xba, 0xf9, 0x9b, 0xdf, 0xea, 0x29, 0xd3, 0x3d, 0xff, 0xf0, 0x85, 0x02, 0xf8, - 0x40, 0xf5, 0xab, 0xd2, 0x3d, 0xb2, 0x67, 0x95, 0xee, 0x2a, 0xdd, 0x8a, 0x31, 0x27, 0x63, 0x35, - 0xd5, 0xb9, 0xea, 0x55, 0xd1, 0xfe, 0x60, 0x67, 0xba, 0xfe, 0xf0, 0xdd, 0x93, 0x54, 0xb0, 0xe2, - 0x83, 0xbe, 0x0b, 0x6a, 0xf4, 0x37, 0x2b, 0x6c, 0x20, 0x36, 0x7b, 0x2f, 0x2b, 0x19, 0x2a, 0x01, - 0x85, 0x56, 0x4f, 0xd0, 0xfc, 0xd0, 0x36, 0xd4, 0x28, 0x22, 0x67, 0xce, 0xf7, 0x86, 0xef, 0x53, - 0x65, 0x06, 0x24, 0xe0, 0xc1, 0xce, 0xf4, 0xdc, 0xc3, 0x33, 0x57, 0x64, 0xb0, 0x66, 0x65, 0xa8, - 0xce, 0xd1, 0x7e, 0xaa, 0xd3, 0xfe, 0xb3, 0x21, 0x3d, 0xff, 0x45, 0x85, 0xf7, 0xbf, 0x10, 0xf3, - 0xff, 0xc5, 0xcc, 0xfc, 0x3f, 0xdf, 0x33, 0xff, 0x27, 0xe8, 0x98, 0xe5, 0xd4, 0x9b, 0x3f, 0x6a, - 0x63, 0x62, 0x6f, 0x9f, 0x05, 0xb3, 0xa2, 0x5e, 0xe9, 0x78, 0x11, 0x89, 0x57, 0xa2, 0x4e, 0xe0, - 0x05, 0x1b, 0x6c, 0x0a, 0x57, 0x4d, 0x2b, 0x2a, 0x05, 0xc6, 0x59, 0x7c, 0xf4, 0x3c, 0x54, 0xe9, - 0xbc, 0xb8, 0xed, 0x6c, 0xf3, 0x19, 0x68, 0x54, 0xd5, 0x6d, 0x88, 0x76, 0xac, 0x30, 0xd0, 0x26, - 0x9c, 0x95, 0x04, 0xe6, 0x89, 0x4f, 0xe8, 0x0b, 0xb1, 0x50, 0xe4, 0xa8, 0xc5, 0x13, 0x85, 0x78, - 0x34, 0x99, 0x3a, 0xef, 0xc0, 0xbb, 0xe0, 0xe2, 0x5d, 0x29, 0xd9, 0xbf, 0xcf, 0xe2, 0x57, 0x8c, - 0xba, 0x2f, 0x74, 0xf6, 0xf9, 0x5e, 0xcb, 0x93, 0xc5, 0x7f, 0xd5, 0xec, 0x5b, 0xa4, 0x8d, 0x98, - 0xc3, 0xd0, 0x5d, 0x18, 0x59, 0x73, 0xdc, 0xad, 0x70, 0x7d, 0xbd, 0x98, 0xab, 0xfb, 0xea, 0x9c, - 0x18, 0x2b, 0xfc, 0x3f, 0x22, 0xfe, 0x3c, 0xd0, 0x3f, 0xb1, 0xe4, 0xc6, 0xaf, 0x8d, 0x59, 0x8f, - 0x48, 0xbc, 0x29, 0x1c, 0x7b, 0xc6, 0xb5, 0x31, 0xac, 0x19, 0x4b, 0xb8, 0xfd, 0xdb, 0x15, 0x38, - 0x26, 0x63, 0x49, 0xaf, 0x7a, 0x31, 0x8b, 0x60, 0x31, 0x2f, 0x50, 0x29, 0xed, 0x79, 0x81, 0xca, - 0x87, 0x01, 0x9a, 0xa4, 0xed, 0x87, 0x5d, 0x66, 0x67, 0x0e, 0xed, 0xdb, 0xce, 0x54, 0x5b, 0x93, - 0x79, 0x45, 0x05, 0x1b, 0x14, 0x45, 0x71, 0x64, 0x7e, 0x1f, 0x4b, 0xa6, 0x38, 0xb2, 0x71, 0x17, - 0xe8, 0xf0, 0xd1, 0xde, 0x05, 0xea, 0xc1, 0x31, 0xde, 0x45, 0x55, 0x80, 0xe5, 0x21, 0xea, 0xac, - 0xb0, 0x14, 0xd6, 0xf9, 0x34, 0x19, 0x9c, 0xa5, 0x6b, 0x5e, 0xf4, 0x59, 0x3d, 0xea, 0x8b, 0x3e, - 0xdf, 0x06, 0x35, 0xf9, 0x9d, 0xe3, 0xa9, 0x9a, 0x2e, 0x12, 0x26, 0xa7, 0x41, 0x8c, 0x35, 0xbc, - 0xa7, 0xa6, 0x14, 0x3c, 0xaa, 0x9a, 0x52, 0xf6, 0x6b, 0x65, 0xba, 0x41, 0xe1, 0xfd, 0xda, 0xf7, - 0x3d, 0xb9, 0x57, 0x8d, 0x7b, 0x72, 0xf7, 0xf7, 0x3d, 0xab, 0x99, 0xfb, 0x74, 0xcf, 0xc2, 0x50, - 0xe2, 0x6c, 0xc8, 0x8c, 0x7b, 0x06, 0x5d, 0x75, 0x36, 0x62, 0xcc, 0x5a, 0xf7, 0x53, 0x4b, 0xfe, - 0x25, 0x18, 0x8f, 0xbd, 0x8d, 0xc0, 0x49, 0x3a, 0x11, 0x31, 0xce, 0x25, 0x75, 0x50, 0x97, 0x09, - 0xc4, 0x69, 0x5c, 0xf4, 0x29, 0x0b, 0x20, 0x22, 0x6a, 0xfb, 0x33, 0x5c, 0xc4, 0x1c, 0x52, 0x62, - 0x40, 0xd2, 0x35, 0x6b, 0x00, 0xa9, 0x6d, 0x8f, 0xc1, 0xd6, 0xfe, 0x8c, 0x05, 0x93, 0x3d, 0x4f, - 0xa1, 0x36, 0x0c, 0xbb, 0xec, 0x36, 0xe3, 0x62, 0xea, 0xdf, 0xa6, 0x6f, 0x46, 0xe6, 0x7a, 0x8c, - 0xb7, 0x61, 0xc1, 0xc7, 0xfe, 0xc5, 0x31, 0x38, 0xd9, 0x98, 0x5b, 0x92, 0xb7, 0xa0, 0x1d, 0x5a, - 0x09, 0x81, 0x3c, 0x1e, 0x47, 0x57, 0x42, 0xa0, 0x0f, 0x77, 0xdf, 0x28, 0x21, 0xe0, 0x1b, 0x25, - 0x04, 0xd2, 0xf9, 0xdc, 0xe5, 0x22, 0xf2, 0xb9, 0xf3, 0x7a, 0x30, 0x48, 0x3e, 0xf7, 0xa1, 0xd5, - 0x14, 0xd8, 0xb5, 0x43, 0xfb, 0xaa, 0x29, 0xa0, 0x0a, 0x2e, 0x14, 0x92, 0x3e, 0xda, 0xe7, 0x53, - 0xe5, 0x16, 0x5c, 0x50, 0xc9, 0xee, 0x3c, 0x35, 0x5a, 0x28, 0xbd, 0x97, 0x8b, 0xef, 0xc0, 0x00, - 0xc9, 0xee, 0x22, 0x3b, 0xdb, 0x2c, 0xb0, 0x30, 0x52, 0x44, 0x81, 0x85, 0xbc, 0xee, 0xec, 0x59, - 0x60, 0xe1, 0x25, 0x18, 0x77, 0xfd, 0x30, 0x20, 0x2b, 0x51, 0x98, 0x84, 0x6e, 0xe8, 0x8b, 0x1d, - 0x9b, 0xbe, 0x06, 0xd8, 0x04, 0xe2, 0x34, 0x6e, 0xbf, 0xea, 0x0c, 0xb5, 0x83, 0x56, 0x67, 0x80, - 0x47, 0x54, 0x9d, 0xc1, 0xa8, 0x3f, 0x30, 0x5a, 0x44, 0xfd, 0x81, 0xbc, 0x2f, 0x32, 0x50, 0xfd, - 0x81, 0xd7, 0x2d, 0x18, 0x77, 0xee, 0xb2, 0x7d, 0x0b, 0x97, 0xc2, 0xec, 0xb4, 0x6f, 0xf4, 0xe2, - 0x47, 0x0e, 0x61, 0xc2, 0xde, 0x6e, 0x68, 0x36, 0xf5, 0x49, 0x96, 0x13, 0x66, 0x36, 0xe1, 0x74, - 0x47, 0x0e, 0x52, 0xb3, 0xe0, 0xcb, 0x25, 0x78, 0xf3, 0x9e, 0x5d, 0x40, 0x77, 0x01, 0x12, 0x67, - 0x43, 0x4c, 0x54, 0x71, 0x26, 0x76, 0xc0, 0x38, 0xf4, 0x55, 0x49, 0x4f, 0xe4, 0xd3, 0x2a, 0xf2, - 0xd8, 0x60, 0xc5, 0xc2, 0xcf, 0x43, 0xbf, 0xa7, 0x74, 0x3d, 0x0e, 0x7d, 0x82, 0x19, 0x84, 0x1a, - 0x42, 0x11, 0xd9, 0xa0, 0xc6, 0x7d, 0x39, 0x6d, 0x08, 0x61, 0xd6, 0x8a, 0x05, 0x14, 0xbd, 0x00, - 0xa3, 0x8e, 0xef, 0xf3, 0xdc, 0x5e, 0x12, 0x8b, 0xfb, 0xb9, 0x75, 0xc1, 0x6a, 0x0d, 0xc2, 0x26, - 0x9e, 0xfd, 0x27, 0x25, 0x98, 0xde, 0x43, 0xa6, 0xf4, 0xd4, 0x74, 0xa8, 0x0c, 0x5c, 0xd3, 0x41, - 0xe4, 0x26, 0x0e, 0xf7, 0xc9, 0x4d, 0x7c, 0x01, 0x46, 0x13, 0xe2, 0xb4, 0x44, 0xe4, 0x6a, 0xb6, - 0x0e, 0xeb, 0xaa, 0x06, 0x61, 0x13, 0x8f, 0x4a, 0xb1, 0x09, 0xc7, 0x75, 0x49, 0x1c, 0xcb, 0xe4, - 0x43, 0xe1, 0x30, 0x2f, 0x2c, 0xb3, 0x91, 0x9d, 0x43, 0xcc, 0xa6, 0x58, 0xe0, 0x0c, 0xcb, 0xec, - 0x80, 0xd7, 0x06, 0x1c, 0xf0, 0x1f, 0x2f, 0xc1, 0xd3, 0xbb, 0x6a, 0xb7, 0x81, 0xf3, 0x42, 0x3b, - 0x31, 0x89, 0xb2, 0x13, 0xe7, 0x66, 0x4c, 0x22, 0xcc, 0x20, 0x7c, 0x94, 0xda, 0x6d, 0x95, 0x75, - 0x50, 0x7c, 0x22, 0x35, 0x1f, 0xa5, 0x14, 0x0b, 0x9c, 0x61, 0xf9, 0xb0, 0xd3, 0xf2, 0xb7, 0x87, - 0xe0, 0x99, 0x01, 0x6c, 0x80, 0x02, 0x13, 0xce, 0xd3, 0xc5, 0x14, 0xca, 0x8f, 0xa8, 0x98, 0xc2, - 0xc3, 0x0d, 0xd7, 0x1b, 0x35, 0x18, 0x06, 0x4a, 0x6c, 0xff, 0xc9, 0x12, 0x9c, 0xe9, 0x6f, 0xb0, - 0xa0, 0xef, 0x80, 0x63, 0x91, 0x0a, 0x35, 0x34, 0xeb, 0x30, 0x9c, 0xe0, 0xee, 0xb0, 0x14, 0x08, - 0x67, 0x71, 0xd1, 0x0c, 0x40, 0xdb, 0x49, 0x36, 0xe3, 0x4b, 0xf7, 0xbc, 0x38, 0x11, 0x85, 0x2b, - 0x27, 0xf8, 0x21, 0xae, 0x6c, 0xc5, 0x06, 0x06, 0x65, 0xc7, 0xfe, 0xcd, 0x87, 0x37, 0xc2, 0x84, - 0x3f, 0xc4, 0xb7, 0x9e, 0x27, 0xe4, 0xb5, 0xaf, 0x06, 0x08, 0x67, 0x71, 0x29, 0x3b, 0x16, 0x26, - 0xc0, 0x3b, 0x3a, 0xa4, 0x2b, 0x37, 0x2c, 0xaa, 0x56, 0x6c, 0x60, 0x64, 0x2b, 0x4c, 0x54, 0xf6, - 0xae, 0x30, 0x61, 0x7f, 0xae, 0x0c, 0xa7, 0xfb, 0x1a, 0xbc, 0x83, 0x89, 0xa9, 0xc7, 0xaf, 0xca, - 0xc3, 0x43, 0xae, 0xb0, 0xfd, 0x55, 0x07, 0x58, 0x81, 0x93, 0xe2, 0x96, 0xe8, 0xd9, 0xc8, 0xdd, - 0xf4, 0xb6, 0x49, 0x93, 0x4d, 0x1f, 0xb1, 0x26, 0x54, 0x72, 0xc0, 0xa5, 0x1c, 0x1c, 0x9c, 0xfb, - 0xa4, 0xfd, 0x8f, 0xca, 0xf9, 0x73, 0x57, 0xd4, 0x12, 0x78, 0xf8, 0xb2, 0x4b, 0x8f, 0xdf, 0x17, - 0xea, 0x29, 0x1f, 0x30, 0xb4, 0x8f, 0xf2, 0x01, 0x99, 0xcf, 0x5b, 0x19, 0xf0, 0xf3, 0x16, 0xff, - 0xc1, 0xfe, 0x69, 0xa5, 0xef, 0x07, 0xa3, 0x9b, 0xf8, 0x81, 0x0e, 0x44, 0xe6, 0xe1, 0xb8, 0x17, - 0x30, 0xda, 0x8d, 0xce, 0x9a, 0xa8, 0xb7, 0xc8, 0x8b, 0x8b, 0xab, 0x8c, 0xb2, 0x85, 0x0c, 0x1c, - 0xf7, 0x3c, 0xf1, 0x18, 0x16, 0x88, 0x78, 0xc8, 0x8f, 0xb4, 0x3f, 0xed, 0xb2, 0x0c, 0xa7, 0xe4, - 0x50, 0x6c, 0x3a, 0x11, 0x69, 0x0a, 0x83, 0x20, 0x16, 0x39, 0x84, 0xa7, 0x79, 0x1e, 0x62, 0x0e, - 0x02, 0xce, 0x7f, 0x8e, 0xdd, 0x0c, 0x1d, 0xb6, 0x3d, 0x57, 0x6c, 0x57, 0xf5, 0xcd, 0xd0, 0xb4, - 0x11, 0x73, 0x98, 0xd6, 0x69, 0xb5, 0x23, 0xd1, 0x69, 0x3c, 0x0d, 0x29, 0x67, 0xe2, 0x42, 0x36, - 0x0d, 0x29, 0x6f, 0xe2, 0xe6, 0x3d, 0x69, 0x7f, 0x18, 0x6a, 0xea, 0x0b, 0xf2, 0x0c, 0x11, 0xb5, - 0x10, 0x7b, 0x32, 0x44, 0xd4, 0x2a, 0x34, 0xb0, 0xe8, 0x7c, 0xa3, 0xdb, 0xb3, 0x8c, 0x44, 0xa1, - 0x6f, 0x40, 0xdb, 0xed, 0x77, 0xc2, 0x98, 0xf2, 0x80, 0x0e, 0x7a, 0xe3, 0xb7, 0xfd, 0xe7, 0x25, - 0xc8, 0x5c, 0x6a, 0x89, 0xee, 0x41, 0xad, 0x19, 0x75, 0x79, 0x63, 0x31, 0xe5, 0xf2, 0xe7, 0x25, - 0x39, 0x7d, 0x52, 0xa8, 0x9a, 0xb0, 0x66, 0x86, 0x3e, 0xc6, 0x2b, 0xd2, 0x0b, 0xd6, 0xa5, 0x22, - 0xca, 0x8e, 0x34, 0x14, 0x3d, 0xf3, 0x2a, 0x5f, 0xd9, 0x86, 0x0d, 0x7e, 0x28, 0x81, 0xda, 0xa6, - 0xbc, 0xbc, 0xb3, 0x18, 0x91, 0xac, 0xee, 0x02, 0xe5, 0x86, 0xa9, 0xfa, 0x8b, 0x35, 0x23, 0xfb, - 0x0f, 0x4a, 0x70, 0x32, 0xfd, 0x01, 0xc4, 0xc9, 0xee, 0x4f, 0x59, 0xf0, 0xa4, 0xef, 0xc4, 0x49, - 0xa3, 0xc3, 0xb6, 0x47, 0xeb, 0x1d, 0x7f, 0x39, 0x73, 0x89, 0xc1, 0x41, 0x5d, 0x4c, 0x8a, 0x70, - 0xf6, 0xb2, 0xd7, 0xfa, 0x53, 0xf7, 0x77, 0xa6, 0x9f, 0x5c, 0xcc, 0x67, 0x8e, 0xfb, 0xf5, 0x0a, - 0xbd, 0x66, 0xc1, 0x71, 0xb7, 0x13, 0x45, 0x24, 0x48, 0x74, 0x57, 0xf9, 0x57, 0xbc, 0x51, 0xc8, - 0x40, 0xea, 0x0e, 0x9e, 0xa4, 0x22, 0x7a, 0x2e, 0xc3, 0x0b, 0xf7, 0x70, 0xb7, 0x7f, 0x80, 0x5a, - 0xa6, 0x7d, 0xdf, 0xf3, 0x2f, 0xd9, 0xed, 0xb4, 0x7f, 0x34, 0x0c, 0xe3, 0xa9, 0x1b, 0x1a, 0x52, - 0x47, 0x9c, 0xd6, 0x9e, 0x47, 0x9c, 0x2c, 0x8f, 0xb6, 0x13, 0x88, 0xdb, 0x13, 0xcd, 0x3c, 0xda, - 0x4e, 0x40, 0x30, 0x87, 0x89, 0x21, 0xc5, 0x9d, 0x40, 0x9c, 0xb9, 0x9a, 0x43, 0x8a, 0x3b, 0x01, - 0x16, 0x50, 0xf4, 0x09, 0x0b, 0xc6, 0xd8, 0xe2, 0x13, 0x67, 0xc9, 0x42, 0x45, 0x5e, 0x2b, 0x60, - 0xb9, 0xcb, 0x5b, 0x49, 0x58, 0xf0, 0xad, 0xd9, 0x82, 0x53, 0x1c, 0xd1, 0xa7, 0x2d, 0xa8, 0xa9, - 0x5b, 0xc2, 0xc5, 0x89, 0x50, 0xa3, 0xd8, 0x0b, 0x30, 0x32, 0x52, 0x4f, 0xdd, 0x44, 0x80, 0x35, - 0x63, 0x14, 0xab, 0xd3, 0xdb, 0x91, 0xc3, 0x39, 0xbd, 0x85, 0x9c, 0x93, 0xdb, 0xb7, 0x41, 0xad, - 0x25, 0xb2, 0x52, 0xf9, 0x81, 0xaa, 0xbc, 0xf7, 0x48, 0x36, 0x62, 0x0d, 0xa7, 0x5b, 0x9c, 0x98, - 0xbd, 0x58, 0x62, 0x9c, 0x80, 0xb2, 0x2d, 0x4e, 0x43, 0x37, 0x63, 0x13, 0xc7, 0x3c, 0xae, 0x85, - 0x47, 0x7a, 0x5c, 0x3b, 0xba, 0xc7, 0x71, 0x6d, 0x03, 0x4e, 0x39, 0x9d, 0x24, 0xbc, 0x4a, 0x1c, - 0x7f, 0x36, 0x49, 0x48, 0xab, 0x9d, 0xc4, 0xfc, 0x52, 0x8f, 0x31, 0xe6, 0xf8, 0x56, 0xe1, 0x82, - 0x0d, 0xe2, 0xaf, 0xf7, 0x20, 0xe1, 0xfc, 0x67, 0xed, 0x7f, 0x6c, 0xc1, 0xa9, 0xdc, 0xa9, 0xf0, - 0xf8, 0x26, 0x6a, 0xd8, 0x3f, 0x5c, 0x81, 0x13, 0x39, 0xf7, 0xb7, 0xa0, 0xae, 0xb9, 0x48, 0xac, - 0x22, 0x62, 0x1e, 0xd3, 0x21, 0x7c, 0xf2, 0xdb, 0xe4, 0xac, 0x8c, 0xfd, 0x45, 0x60, 0xe8, 0x28, - 0x88, 0xf2, 0xd1, 0x46, 0x41, 0x18, 0x73, 0x7d, 0xe8, 0x91, 0xce, 0xf5, 0xca, 0x1e, 0x73, 0xfd, - 0xa7, 0x2d, 0x98, 0x6a, 0xf5, 0xb9, 0x94, 0x51, 0x9c, 0xa2, 0xdd, 0x3a, 0x9c, 0x2b, 0x1f, 0xeb, - 0x67, 0xef, 0xef, 0x4c, 0xf7, 0xbd, 0x0b, 0x13, 0xf7, 0xed, 0x95, 0xfd, 0xb5, 0x32, 0x30, 0x7b, - 0x8d, 0xd5, 0xe8, 0xef, 0xa2, 0x8f, 0x9b, 0xd7, 0x41, 0x59, 0x45, 0x5d, 0x59, 0xc4, 0x89, 0xab, - 0xeb, 0xa4, 0xf8, 0x08, 0xe6, 0xdd, 0x2e, 0x95, 0x95, 0x84, 0xa5, 0x01, 0x24, 0xa1, 0x2f, 0xef, - 0xdd, 0x2a, 0x17, 0x7f, 0xef, 0x56, 0x2d, 0x7b, 0xe7, 0xd6, 0xee, 0x9f, 0x78, 0xe8, 0xb1, 0xfc, - 0xc4, 0xff, 0xcc, 0xe2, 0x82, 0x27, 0xf3, 0x15, 0xd0, 0xb4, 0x34, 0x37, 0xf8, 0xf5, 0x3c, 0xb5, - 0x1e, 0x53, 0xe3, 0x39, 0xa8, 0xc6, 0x42, 0x2a, 0x0b, 0x93, 0x84, 0xed, 0x8b, 0xa5, 0xa4, 0xc6, - 0x0a, 0x8a, 0x66, 0x00, 0x1c, 0xdf, 0x0f, 0xef, 0x5e, 0x6a, 0xb5, 0x93, 0xae, 0x34, 0x4c, 0xe8, - 0x56, 0x60, 0x56, 0xb5, 0x62, 0x03, 0x03, 0xbd, 0x05, 0x46, 0x78, 0x0d, 0x96, 0xa6, 0xf0, 0x63, - 0x8d, 0xd2, 0xc5, 0xc7, 0x2b, 0xb4, 0x34, 0xb1, 0x84, 0xd9, 0x9b, 0x60, 0xec, 0x25, 0x1e, 0xfe, - 0xbe, 0xff, 0xbd, 0xaf, 0xf0, 0xb5, 0xff, 0x76, 0x49, 0xb0, 0xe2, 0x7b, 0x03, 0x1d, 0x30, 0x69, - 0xed, 0x33, 0x60, 0xf2, 0x63, 0x00, 0x6e, 0xd8, 0x6a, 0xd3, 0xfd, 0xf7, 0x6a, 0x58, 0xcc, 0x16, - 0x6b, 0x4e, 0xd1, 0xd3, 0x5b, 0x2c, 0xdd, 0x86, 0x0d, 0x7e, 0x29, 0x81, 0x5e, 0xde, 0x53, 0xa0, - 0xa7, 0x64, 0xdb, 0xd0, 0xee, 0xb2, 0xcd, 0xfe, 0x13, 0x0b, 0x52, 0xb6, 0x1e, 0x6a, 0x43, 0x85, - 0x76, 0xb7, 0x2b, 0xc4, 0xc4, 0x72, 0x71, 0x86, 0x25, 0x95, 0xcf, 0x62, 0xed, 0xb1, 0x9f, 0x98, - 0x33, 0x42, 0xbe, 0x08, 0x0e, 0x2d, 0x64, 0xcb, 0x63, 0x32, 0xbc, 0x1a, 0x86, 0x5b, 0x3c, 0x70, - 0x4a, 0x07, 0x9a, 0xda, 0x2f, 0xc2, 0x64, 0x4f, 0xa7, 0xa8, 0x79, 0xc1, 0x4a, 0xc2, 0x88, 0x35, - 0xa3, 0xcc, 0x0b, 0x56, 0x0c, 0x05, 0x73, 0x98, 0xfd, 0x93, 0x16, 0x1c, 0xcf, 0x92, 0x47, 0xaf, - 0x5b, 0x30, 0x19, 0x67, 0xe9, 0x1d, 0xd6, 0xd8, 0xa9, 0x24, 0x91, 0x1e, 0x10, 0xee, 0xed, 0x84, - 0xfd, 0x5f, 0x85, 0x0e, 0xb8, 0xed, 0x05, 0xcd, 0xf0, 0xae, 0xb2, 0x8e, 0xac, 0xbe, 0xd6, 0xd1, - 0xf3, 0x50, 0x8d, 0xdd, 0x4d, 0xd2, 0xec, 0xf8, 0x3d, 0xa5, 0x34, 0x1a, 0xa2, 0x1d, 0x2b, 0x0c, - 0x56, 0x39, 0xa0, 0x23, 0x76, 0xab, 0x99, 0x49, 0x39, 0x2f, 0xda, 0xb1, 0xc2, 0x40, 0xef, 0x82, - 0x31, 0xe3, 0x25, 0xe5, 0xbc, 0x64, 0x5b, 0x0d, 0x43, 0x6f, 0xc7, 0x38, 0x85, 0x45, 0x05, 0x90, - 0xb2, 0xb4, 0xa4, 0x9e, 0x66, 0x02, 0x48, 0x89, 0xc3, 0x18, 0x1b, 0x18, 0xac, 0x4e, 0x87, 0xdf, - 0x89, 0xd9, 0xa9, 0xf9, 0xb0, 0xbe, 0xa9, 0x66, 0x4e, 0xb4, 0x61, 0x05, 0x45, 0x17, 0x01, 0x5a, - 0x4e, 0xd0, 0x71, 0x7c, 0x3a, 0x42, 0xc2, 0x05, 0xa7, 0x96, 0xe1, 0x92, 0x82, 0x60, 0x03, 0x8b, - 0xbe, 0x71, 0xe2, 0xb5, 0xc8, 0x07, 0xc2, 0x40, 0x06, 0xf5, 0xeb, 0x40, 0x0a, 0xd1, 0x8e, 0x15, - 0x06, 0x7a, 0x11, 0x46, 0x9d, 0xa0, 0xc9, 0xcd, 0xc2, 0x30, 0x12, 0xe7, 0xb1, 0x6a, 0xcf, 0x79, - 0x33, 0x26, 0xb3, 0x1a, 0x8a, 0x4d, 0xd4, 0xec, 0x35, 0x3d, 0x30, 0xe0, 0x75, 0xa0, 0x7f, 0x6c, - 0xc1, 0x31, 0x5d, 0xd0, 0x8b, 0x79, 0xea, 0x52, 0x2e, 0x4a, 0x6b, 0x4f, 0x17, 0x65, 0xba, 0xfe, - 0x4a, 0x69, 0xa0, 0xfa, 0x2b, 0x66, 0x69, 0x94, 0xf2, 0xae, 0xa5, 0x51, 0xde, 0x02, 0x23, 0x5b, - 0xa4, 0x6b, 0xd4, 0x50, 0x61, 0xda, 0xe1, 0x3a, 0x6f, 0xc2, 0x12, 0x86, 0x6c, 0x18, 0x76, 0x1d, - 0x55, 0x9c, 0x75, 0x4c, 0xc4, 0xe1, 0xcd, 0x32, 0x24, 0x01, 0xb1, 0x97, 0xa1, 0xa6, 0x02, 0x18, - 0xa4, 0x7f, 0xcf, 0xca, 0xf7, 0xef, 0xd1, 0xb5, 0x6d, 0xc4, 0x62, 0xe8, 0xb5, 0xcd, 0x22, 0x38, - 0x44, 0x68, 0x46, 0x7d, 0xed, 0xd7, 0xbe, 0x7e, 0xee, 0x4d, 0xbf, 0xf5, 0xf5, 0x73, 0x6f, 0xfa, + // 12755 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x1c, 0xc9, + 0x75, 0x98, 0x66, 0x17, 0x0b, 0xec, 0x3e, 0x7c, 0x90, 0x68, 0x92, 0x77, 0x20, 0x8f, 0x47, 0x50, + 0x73, 0xd6, 0xe9, 0x1c, 0x9d, 0x40, 0x8b, 0xd2, 0xc9, 0x17, 0x9f, 0x2d, 0x07, 0x0b, 0xf0, 0x03, + 0x24, 0x40, 0x40, 0xbd, 0x20, 0xa9, 0xaf, 0x93, 0x34, 0x98, 0x6d, 0x00, 0x43, 0xcc, 0xce, 0xec, + 0xcd, 0xcc, 0x82, 0xdc, 0xb3, 0x2c, 0x4b, 0x96, 0x64, 0x4b, 0x96, 0x2c, 0x5d, 0xec, 0x54, 0x7c, + 0x4e, 0x22, 0x45, 0x8e, 0x9d, 0x8f, 0xaa, 0x94, 0x63, 0x27, 0xae, 0x4a, 0x5c, 0xb1, 0x5d, 0xae, + 0xd8, 0x2e, 0x97, 0x5d, 0x71, 0x62, 0xc7, 0xe5, 0xd8, 0x4e, 0x1c, 0x23, 0x12, 0x53, 0x29, 0xbb, + 0xf2, 0xc3, 0x29, 0x27, 0xa9, 0x54, 0x8a, 0x71, 0x5c, 0xa9, 0xfe, 0xee, 0x99, 0x9d, 0x05, 0x16, + 0xc4, 0x00, 0xa4, 0xec, 0xfb, 0xb7, 0xdb, 0xef, 0xcd, 0x7b, 0x3d, 0x3d, 0xdd, 0xef, 0xbd, 0x7e, + 0xfd, 0xde, 0x6b, 0x58, 0xdc, 0xf0, 0x92, 0xcd, 0xce, 0xda, 0x8c, 0x1b, 0xb6, 0x2e, 0x38, 0xd1, + 0x46, 0xd8, 0x8e, 0xc2, 0x3b, 0xec, 0xc7, 0xdb, 0xdd, 0xe6, 0x85, 0xed, 0x77, 0x5e, 0x68, 0x6f, + 0x6d, 0x5c, 0x70, 0xda, 0x5e, 0x7c, 0xc1, 0x69, 0xb7, 0x7d, 0xcf, 0x75, 0x12, 0x2f, 0x0c, 0x2e, + 0x6c, 0xbf, 0xc3, 0xf1, 0xdb, 0x9b, 0xce, 0x3b, 0x2e, 0x6c, 0x90, 0x80, 0x44, 0x4e, 0x42, 0x9a, + 0x33, 0xed, 0x28, 0x4c, 0x42, 0xf4, 0xed, 0x9a, 0xda, 0x8c, 0xa4, 0xc6, 0x7e, 0x7c, 0xc4, 0x6d, + 0xce, 0x6c, 0xbf, 0x73, 0xa6, 0xbd, 0xb5, 0x31, 0x43, 0xa9, 0xcd, 0x18, 0xd4, 0x66, 0x24, 0xb5, + 0x33, 0x6f, 0x37, 0xfa, 0xb2, 0x11, 0x6e, 0x84, 0x17, 0x18, 0xd1, 0xb5, 0xce, 0x3a, 0xfb, 0xc7, + 0xfe, 0xb0, 0x5f, 0x9c, 0xd9, 0x19, 0x7b, 0xeb, 0xc5, 0x78, 0xc6, 0x0b, 0x69, 0xf7, 0x2e, 0xb8, + 0x61, 0x44, 0x2e, 0x6c, 0xf7, 0x74, 0xe8, 0xcc, 0x55, 0x8d, 0x43, 0xee, 0x25, 0x24, 0x88, 0xbd, + 0x30, 0x88, 0xdf, 0x4e, 0xbb, 0x40, 0xa2, 0x6d, 0x12, 0x99, 0xaf, 0x67, 0x20, 0xe4, 0x51, 0x7a, + 0x97, 0xa6, 0xd4, 0x72, 0xdc, 0x4d, 0x2f, 0x20, 0x51, 0x57, 0x3f, 0xde, 0x22, 0x89, 0x93, 0xf7, + 0xd4, 0x85, 0x7e, 0x4f, 0x45, 0x9d, 0x20, 0xf1, 0x5a, 0xa4, 0xe7, 0x81, 0x77, 0xef, 0xf5, 0x40, + 0xec, 0x6e, 0x92, 0x96, 0xd3, 0xf3, 0xdc, 0x3b, 0xfb, 0x3d, 0xd7, 0x49, 0x3c, 0xff, 0x82, 0x17, + 0x24, 0x71, 0x12, 0x65, 0x1f, 0xb2, 0xff, 0x8e, 0x05, 0xe3, 0xb3, 0xb7, 0x1b, 0xb3, 0x9d, 0x64, + 0x73, 0x2e, 0x0c, 0xd6, 0xbd, 0x0d, 0xf4, 0x02, 0x8c, 0xba, 0x7e, 0x27, 0x4e, 0x48, 0x74, 0xc3, + 0x69, 0x91, 0x29, 0xeb, 0xbc, 0xf5, 0x5c, 0xad, 0x7e, 0xe2, 0xd7, 0x76, 0xa6, 0xdf, 0x74, 0x7f, + 0x67, 0x7a, 0x74, 0x4e, 0x83, 0xb0, 0x89, 0x87, 0xbe, 0x19, 0x46, 0xa2, 0xd0, 0x27, 0xb3, 0xf8, + 0xc6, 0x54, 0x89, 0x3d, 0x72, 0x4c, 0x3c, 0x32, 0x82, 0x79, 0x33, 0x96, 0x70, 0x8a, 0xda, 0x8e, + 0xc2, 0x75, 0xcf, 0x27, 0x53, 0xe5, 0x34, 0xea, 0x0a, 0x6f, 0xc6, 0x12, 0x6e, 0xff, 0x58, 0x09, + 0x8e, 0xcd, 0xb6, 0xdb, 0x57, 0x89, 0xe3, 0x27, 0x9b, 0x8d, 0xc4, 0x49, 0x3a, 0x31, 0x0a, 0x61, + 0x38, 0x66, 0xbf, 0x44, 0xdf, 0x6e, 0x8b, 0xa7, 0x87, 0x39, 0xfc, 0xc1, 0xce, 0xf4, 0xa5, 0xdd, + 0x66, 0xf4, 0x86, 0x97, 0x84, 0xed, 0xf8, 0xed, 0x24, 0xd8, 0xf0, 0x02, 0xc2, 0xc6, 0x67, 0x93, + 0x51, 0x9f, 0x31, 0x99, 0xcc, 0x85, 0x4d, 0x82, 0x05, 0x1b, 0xda, 0xdf, 0x16, 0x89, 0x63, 0x67, + 0x83, 0x64, 0x5f, 0x6d, 0x89, 0x37, 0x63, 0x09, 0x47, 0x11, 0x20, 0xdf, 0x89, 0x93, 0xd5, 0xc8, + 0x09, 0x62, 0x8f, 0x4e, 0xed, 0x55, 0xaf, 0xc5, 0xdf, 0x72, 0xf4, 0xe2, 0x5f, 0x99, 0xe1, 0x1f, + 0x68, 0xc6, 0xfc, 0x40, 0x7a, 0x3d, 0xd0, 0xf9, 0x33, 0xb3, 0xfd, 0x8e, 0x19, 0xfa, 0x44, 0xfd, + 0x89, 0xfb, 0x3b, 0xd3, 0x68, 0xb1, 0x87, 0x12, 0xce, 0xa1, 0x6e, 0xff, 0x6e, 0x09, 0x60, 0xb6, + 0xdd, 0x5e, 0x89, 0xc2, 0x3b, 0xc4, 0x4d, 0xd0, 0x47, 0xa1, 0x4a, 0x49, 0x35, 0x9d, 0xc4, 0x61, + 0x03, 0x34, 0x7a, 0xf1, 0x5b, 0x06, 0x63, 0xbc, 0xbc, 0x46, 0x9f, 0x5f, 0x22, 0x89, 0x53, 0x47, + 0xe2, 0x05, 0x41, 0xb7, 0x61, 0x45, 0x15, 0x05, 0x30, 0x14, 0xb7, 0x89, 0xcb, 0x06, 0x63, 0xf4, + 0xe2, 0xe2, 0xcc, 0x41, 0x56, 0xfc, 0x8c, 0xee, 0x79, 0xa3, 0x4d, 0xdc, 0xfa, 0x98, 0xe0, 0x3c, + 0x44, 0xff, 0x61, 0xc6, 0x07, 0x6d, 0xab, 0x0f, 0xce, 0x07, 0xf2, 0x46, 0x61, 0x1c, 0x19, 0xd5, + 0xfa, 0x44, 0x7a, 0x02, 0xc9, 0xef, 0x6e, 0xff, 0xa1, 0x05, 0x13, 0x1a, 0x79, 0xd1, 0x8b, 0x13, + 0xf4, 0xa1, 0x9e, 0xc1, 0x9d, 0x19, 0x6c, 0x70, 0xe9, 0xd3, 0x6c, 0x68, 0x8f, 0x0b, 0x66, 0x55, + 0xd9, 0x62, 0x0c, 0x6c, 0x0b, 0x2a, 0x5e, 0x42, 0x5a, 0xf1, 0x54, 0xe9, 0x7c, 0xf9, 0xb9, 0xd1, + 0x8b, 0x57, 0x8b, 0x7a, 0xcf, 0xfa, 0xb8, 0x60, 0x5a, 0x59, 0xa0, 0xe4, 0x31, 0xe7, 0x62, 0xff, + 0xc6, 0x84, 0xf9, 0x7e, 0x74, 0xc0, 0xd1, 0x3b, 0x60, 0x34, 0x0e, 0x3b, 0x91, 0x4b, 0x30, 0x69, + 0x87, 0x74, 0x81, 0x95, 0xe9, 0x74, 0xa7, 0x0b, 0xbf, 0xa1, 0x9b, 0xb1, 0x89, 0x83, 0xbe, 0x68, + 0xc1, 0x58, 0x93, 0xc4, 0x89, 0x17, 0x30, 0xfe, 0xb2, 0xf3, 0xab, 0x07, 0xee, 0xbc, 0x6c, 0x9c, + 0xd7, 0xc4, 0xeb, 0x27, 0xc5, 0x8b, 0x8c, 0x19, 0x8d, 0x31, 0x4e, 0xf1, 0xa7, 0x02, 0xac, 0x49, + 0x62, 0x37, 0xf2, 0xda, 0xf4, 0xbf, 0x10, 0x31, 0x4a, 0x80, 0xcd, 0x6b, 0x10, 0x36, 0xf1, 0x50, + 0x00, 0x15, 0x2a, 0xa0, 0xe2, 0xa9, 0x21, 0xd6, 0xff, 0x85, 0x83, 0xf5, 0x5f, 0x0c, 0x2a, 0x95, + 0x7d, 0x7a, 0xf4, 0xe9, 0xbf, 0x18, 0x73, 0x36, 0xe8, 0x5f, 0x5a, 0x30, 0x25, 0x04, 0x28, 0x26, + 0x7c, 0x40, 0x6f, 0x6f, 0x7a, 0x09, 0xf1, 0xbd, 0x38, 0x99, 0xaa, 0xb0, 0x3e, 0x7c, 0xe8, 0x60, + 0x7d, 0x98, 0x4b, 0x53, 0xc7, 0x24, 0x4e, 0x22, 0xcf, 0xa5, 0x38, 0x74, 0x1a, 0xd4, 0xcf, 0x8b, + 0x6e, 0x4d, 0xcd, 0xf5, 0xe9, 0x05, 0xee, 0xdb, 0x3f, 0xf4, 0xc3, 0x16, 0x9c, 0x09, 0x9c, 0x16, + 0x89, 0xdb, 0x0e, 0x23, 0xcc, 0xc0, 0x75, 0xdf, 0x71, 0xb7, 0x58, 0xf7, 0x87, 0x59, 0xf7, 0x2f, + 0x0c, 0xb6, 0x34, 0xae, 0x44, 0x61, 0xa7, 0x7d, 0xdd, 0x0b, 0x9a, 0x75, 0x5b, 0xf4, 0xe8, 0xcc, + 0x8d, 0xbe, 0xa4, 0xf1, 0x2e, 0x6c, 0xd1, 0x8f, 0x5b, 0x30, 0x19, 0x46, 0xed, 0x4d, 0x27, 0x20, + 0x4d, 0x09, 0x8d, 0xa7, 0x46, 0xd8, 0x3a, 0xfd, 0xf0, 0xc1, 0xc6, 0x72, 0x39, 0x4b, 0x76, 0x29, + 0x0c, 0xbc, 0x24, 0x8c, 0x1a, 0x24, 0x49, 0xbc, 0x60, 0x23, 0xae, 0x9f, 0xba, 0xbf, 0x33, 0x3d, + 0xd9, 0x83, 0x85, 0x7b, 0xfb, 0x83, 0xbe, 0x0b, 0x46, 0xe3, 0x6e, 0xe0, 0xde, 0xf6, 0x82, 0x66, + 0x78, 0x37, 0x9e, 0xaa, 0x16, 0xb1, 0xd6, 0x1b, 0x8a, 0xa0, 0x58, 0xad, 0x9a, 0x01, 0x36, 0xb9, + 0xe5, 0x7f, 0x38, 0x3d, 0xef, 0x6a, 0x45, 0x7f, 0x38, 0x3d, 0x99, 0x76, 0x61, 0x8b, 0xbe, 0xdf, + 0x82, 0xf1, 0xd8, 0xdb, 0x08, 0x9c, 0xa4, 0x13, 0x91, 0xeb, 0xa4, 0x1b, 0x4f, 0x01, 0xeb, 0xc8, + 0xb5, 0x03, 0x8e, 0x8a, 0x41, 0xb2, 0x7e, 0x4a, 0xf4, 0x71, 0xdc, 0x6c, 0x8d, 0x71, 0x9a, 0x6f, + 0xde, 0xaa, 0xd4, 0xd3, 0x7a, 0xf4, 0x11, 0xae, 0x4a, 0xbd, 0x02, 0xfa, 0xf6, 0x0f, 0xfd, 0x35, + 0x38, 0xce, 0x9b, 0xd4, 0x67, 0x88, 0xa7, 0xc6, 0x98, 0x08, 0x3f, 0x79, 0x7f, 0x67, 0xfa, 0x78, + 0x23, 0x03, 0xc3, 0x3d, 0xd8, 0xe8, 0x15, 0x98, 0x6e, 0x93, 0xa8, 0xe5, 0x25, 0xcb, 0x81, 0xdf, + 0x95, 0x8a, 0xc1, 0x0d, 0xdb, 0xa4, 0x29, 0xba, 0x13, 0x4f, 0x8d, 0x9f, 0xb7, 0x9e, 0xab, 0xd6, + 0xdf, 0x2a, 0xba, 0x39, 0xbd, 0xb2, 0x3b, 0x3a, 0xde, 0x8b, 0x1e, 0xfa, 0x55, 0x0b, 0xce, 0x18, + 0xf2, 0xbb, 0x41, 0xa2, 0x6d, 0xcf, 0x25, 0xb3, 0xae, 0x1b, 0x76, 0x82, 0x24, 0x9e, 0x9a, 0x60, + 0x63, 0xbe, 0x76, 0x18, 0xda, 0x24, 0xcd, 0x4a, 0x4f, 0xe2, 0xbe, 0x28, 0x31, 0xde, 0xa5, 0xa7, + 0xf6, 0xaf, 0x97, 0xe0, 0x78, 0xd6, 0xb6, 0x40, 0xff, 0xc0, 0x82, 0x63, 0x77, 0xee, 0x26, 0xab, + 0xe1, 0x16, 0x09, 0xe2, 0x7a, 0x97, 0x6a, 0x00, 0xa6, 0x55, 0x47, 0x2f, 0xba, 0xc5, 0x5a, 0x31, + 0x33, 0xd7, 0xd2, 0x5c, 0x2e, 0x05, 0x49, 0xd4, 0xad, 0x3f, 0x29, 0xde, 0xe9, 0xd8, 0xb5, 0xdb, + 0xab, 0x26, 0x14, 0x67, 0x3b, 0x75, 0xe6, 0xf3, 0x16, 0x9c, 0xcc, 0x23, 0x81, 0x8e, 0x43, 0x79, + 0x8b, 0x74, 0xb9, 0xad, 0x8d, 0xe9, 0x4f, 0xf4, 0x32, 0x54, 0xb6, 0x1d, 0xbf, 0x43, 0x84, 0x01, + 0x78, 0xe5, 0x60, 0x2f, 0xa2, 0x7a, 0x86, 0x39, 0xd5, 0x6f, 0x2b, 0xbd, 0x68, 0xd9, 0xbf, 0x59, + 0x86, 0x51, 0xe3, 0xa3, 0x1d, 0x81, 0x51, 0x1b, 0xa6, 0x8c, 0xda, 0xa5, 0xc2, 0xe6, 0x5b, 0x5f, + 0xab, 0xf6, 0x6e, 0xc6, 0xaa, 0x5d, 0x2e, 0x8e, 0xe5, 0xae, 0x66, 0x2d, 0x4a, 0xa0, 0x16, 0xb6, + 0xe9, 0x26, 0x90, 0x5a, 0x47, 0x43, 0x45, 0x7c, 0xc2, 0x65, 0x49, 0xae, 0x3e, 0x7e, 0x7f, 0x67, + 0xba, 0xa6, 0xfe, 0x62, 0xcd, 0xc8, 0xfe, 0x3d, 0x0b, 0x4e, 0x1a, 0x7d, 0x9c, 0x0b, 0x83, 0x26, + 0xdb, 0xc2, 0xa0, 0xf3, 0x30, 0x94, 0x74, 0xdb, 0x72, 0xa3, 0xa9, 0x46, 0x6a, 0xb5, 0xdb, 0x26, + 0x98, 0x41, 0x1e, 0xf7, 0xfd, 0xd7, 0x0f, 0x5b, 0xf0, 0x44, 0xbe, 0x80, 0x41, 0xcf, 0xc2, 0x30, + 0xf7, 0x32, 0x88, 0xb7, 0xd3, 0x9f, 0x84, 0xb5, 0x62, 0x01, 0x45, 0x17, 0xa0, 0xa6, 0xb4, 0xa3, + 0x78, 0xc7, 0x49, 0x81, 0x5a, 0xd3, 0x2a, 0x55, 0xe3, 0xd0, 0x41, 0xa3, 0x7f, 0x84, 0x71, 0xab, + 0x06, 0x8d, 0x6d, 0xcb, 0x19, 0xc4, 0xfe, 0x1d, 0x0b, 0xbe, 0x69, 0x10, 0xb1, 0x77, 0x78, 0x7d, + 0x6c, 0xc0, 0xa9, 0x26, 0x59, 0x77, 0x3a, 0x7e, 0x92, 0xe6, 0x28, 0x3a, 0xfd, 0xb4, 0x78, 0xf8, + 0xd4, 0x7c, 0x1e, 0x12, 0xce, 0x7f, 0xd6, 0xfe, 0xcf, 0x16, 0x73, 0x08, 0xc8, 0xd7, 0x3a, 0x82, + 0x4d, 0x59, 0x90, 0xde, 0x94, 0x2d, 0x14, 0xb6, 0x4c, 0xfb, 0xec, 0xca, 0x7e, 0xd0, 0x82, 0x33, + 0x06, 0xd6, 0x92, 0x93, 0xb8, 0x9b, 0x97, 0xee, 0xb5, 0x23, 0x12, 0xc7, 0x74, 0x4a, 0x3d, 0x6d, + 0x88, 0xe3, 0xfa, 0xa8, 0xa0, 0x50, 0xbe, 0x4e, 0xba, 0x5c, 0x36, 0x3f, 0x0f, 0x55, 0xbe, 0xe6, + 0xc2, 0x48, 0x7c, 0x24, 0xf5, 0x6e, 0xcb, 0xa2, 0x1d, 0x2b, 0x0c, 0x64, 0xc3, 0x30, 0x93, 0xb9, + 0x54, 0x06, 0x51, 0x33, 0x01, 0xe8, 0x77, 0xbf, 0xc5, 0x5a, 0xb0, 0x80, 0xd8, 0x71, 0xaa, 0x3b, + 0x2b, 0x11, 0x61, 0xf3, 0xa1, 0x79, 0xd9, 0x23, 0x7e, 0x33, 0xa6, 0x1b, 0x46, 0x27, 0x08, 0xc2, + 0x44, 0xec, 0xfd, 0x8c, 0x0d, 0xe3, 0xac, 0x6e, 0xc6, 0x26, 0x0e, 0x65, 0xea, 0x3b, 0x6b, 0xc4, + 0xe7, 0x23, 0x2a, 0x98, 0x2e, 0xb2, 0x16, 0x2c, 0x20, 0xf6, 0xfd, 0x12, 0xdb, 0x9a, 0x2a, 0x89, + 0x46, 0x8e, 0xc2, 0xaf, 0x11, 0xa5, 0x54, 0xc0, 0x4a, 0x71, 0xf2, 0x98, 0xf4, 0xf7, 0x6d, 0xbc, + 0x9a, 0xd1, 0x02, 0xb8, 0x50, 0xae, 0xbb, 0xfb, 0x37, 0xbe, 0x5c, 0x86, 0xe9, 0xf4, 0x03, 0x3d, + 0x4a, 0x84, 0x6e, 0xa6, 0x0d, 0x46, 0x59, 0x6f, 0xa0, 0x81, 0x8f, 0x4d, 0xbc, 0x3e, 0x72, 0xb8, + 0x74, 0x98, 0x72, 0xd8, 0x54, 0x13, 0xe5, 0x3d, 0xd4, 0xc4, 0x9c, 0x1a, 0xf5, 0x21, 0x86, 0xf9, + 0xb6, 0x1e, 0x17, 0xe2, 0xe9, 0x95, 0x28, 0xdc, 0x60, 0x6b, 0x6e, 0x9b, 0xd0, 0xcd, 0x54, 0x8e, + 0x5b, 0xf0, 0x3c, 0x0c, 0xc5, 0x09, 0x69, 0x4f, 0x55, 0xd2, 0x32, 0xb8, 0x91, 0x90, 0x36, 0x66, + 0x10, 0xf4, 0x1d, 0x70, 0x2c, 0x71, 0xa2, 0x0d, 0x92, 0x44, 0x64, 0xdb, 0x63, 0x6e, 0x65, 0xb6, + 0x33, 0xae, 0xd5, 0x4f, 0x50, 0x93, 0x6c, 0x95, 0x81, 0xb0, 0x04, 0xe1, 0x2c, 0xae, 0xfd, 0xdf, + 0x4a, 0xf0, 0x64, 0xfa, 0xfb, 0x68, 0xad, 0xf9, 0x9d, 0x29, 0xad, 0xf9, 0x36, 0x53, 0x6b, 0x3e, + 0xd8, 0x99, 0x7e, 0xaa, 0xcf, 0x63, 0xdf, 0x30, 0x4a, 0x15, 0x5d, 0xc9, 0x7c, 0xa1, 0x0b, 0x3d, + 0x5f, 0xe8, 0xe9, 0x3e, 0xef, 0x98, 0xb1, 0x76, 0x9e, 0x85, 0xe1, 0x88, 0x38, 0x71, 0x18, 0x88, + 0xef, 0xa4, 0x16, 0x03, 0x66, 0xad, 0x58, 0x40, 0xed, 0xdf, 0xae, 0x65, 0x07, 0xfb, 0x0a, 0x77, + 0x95, 0x87, 0x11, 0xf2, 0x60, 0x88, 0xed, 0xff, 0xb8, 0xd8, 0xb9, 0x7e, 0xb0, 0x25, 0x4a, 0x55, + 0x8c, 0x22, 0x5d, 0xaf, 0xd2, 0xaf, 0x46, 0x9b, 0x30, 0x63, 0x81, 0xee, 0x41, 0xd5, 0x95, 0x3b, + 0xad, 0x52, 0x11, 0xde, 0x4e, 0xb1, 0xcf, 0xd2, 0x1c, 0xc7, 0xa8, 0x2e, 0x50, 0xdb, 0x33, 0xc5, + 0x0d, 0x11, 0x28, 0x6f, 0x78, 0x89, 0xf8, 0xac, 0x07, 0xdc, 0x78, 0x5f, 0xf1, 0x8c, 0x57, 0x1c, + 0xa1, 0x0a, 0xea, 0x8a, 0x97, 0x60, 0x4a, 0x1f, 0x7d, 0xc6, 0x82, 0xd1, 0xd8, 0x6d, 0xad, 0x44, + 0xe1, 0xb6, 0xd7, 0x24, 0x91, 0x30, 0x40, 0x0f, 0x28, 0xf6, 0x1a, 0x73, 0x4b, 0x92, 0xa0, 0xe6, + 0xcb, 0x1d, 0x21, 0x1a, 0x82, 0x4d, 0xbe, 0x74, 0x63, 0xf6, 0xa4, 0x78, 0xf7, 0x79, 0xe2, 0xb2, + 0x15, 0x27, 0x37, 0xd4, 0x6c, 0xa6, 0x1c, 0xd8, 0x20, 0x9f, 0xef, 0xb8, 0x5b, 0x74, 0xbd, 0xe9, + 0x0e, 0x3d, 0x75, 0x7f, 0x67, 0xfa, 0xc9, 0xb9, 0x7c, 0x9e, 0xb8, 0x5f, 0x67, 0xd8, 0x80, 0xb5, + 0x3b, 0xbe, 0x8f, 0xc9, 0x2b, 0x1d, 0xc2, 0x7c, 0x6b, 0x05, 0x0c, 0xd8, 0x8a, 0x26, 0x98, 0x19, + 0x30, 0x03, 0x82, 0x4d, 0xbe, 0xe8, 0x15, 0x18, 0x6e, 0x39, 0x49, 0xe4, 0xdd, 0x13, 0x0e, 0xb5, + 0x03, 0x6e, 0x91, 0x96, 0x18, 0x2d, 0xcd, 0x9c, 0x59, 0x01, 0xbc, 0x11, 0x0b, 0x46, 0xa8, 0x05, + 0x95, 0x16, 0x89, 0x36, 0xc8, 0x54, 0xb5, 0x88, 0x93, 0x86, 0x25, 0x4a, 0x4a, 0x33, 0xac, 0x51, + 0xcb, 0x8b, 0xb5, 0x61, 0xce, 0x05, 0xbd, 0x0c, 0xd5, 0x98, 0xf8, 0xc4, 0xa5, 0xb6, 0x53, 0x8d, + 0x71, 0x7c, 0xe7, 0x80, 0x76, 0x24, 0x35, 0x5a, 0x1a, 0xe2, 0x51, 0xbe, 0xc0, 0xe4, 0x3f, 0xac, + 0x48, 0xd2, 0x01, 0x6c, 0xfb, 0x9d, 0x0d, 0x2f, 0x98, 0x82, 0x22, 0x06, 0x70, 0x85, 0xd1, 0xca, + 0x0c, 0x20, 0x6f, 0xc4, 0x82, 0x91, 0xfd, 0x5f, 0x2d, 0x40, 0x69, 0xa1, 0x76, 0x04, 0x06, 0xf3, + 0x2b, 0x69, 0x83, 0x79, 0xb1, 0x48, 0x8b, 0xa6, 0x8f, 0xcd, 0xfc, 0x73, 0x35, 0xc8, 0xa8, 0x83, + 0x1b, 0x24, 0x4e, 0x48, 0xf3, 0x0d, 0x11, 0xfe, 0x86, 0x08, 0x7f, 0x43, 0x84, 0x2b, 0x11, 0xbe, + 0x96, 0x11, 0xe1, 0xef, 0x31, 0x56, 0xbd, 0x0e, 0x7d, 0xf8, 0x88, 0x8a, 0x8d, 0x30, 0x7b, 0x60, + 0x20, 0x50, 0x49, 0x70, 0xad, 0xb1, 0x7c, 0x23, 0x57, 0x66, 0x7f, 0x24, 0x2d, 0xb3, 0x0f, 0xca, + 0xe2, 0x2f, 0x83, 0x94, 0xfe, 0x55, 0x0b, 0xde, 0x9a, 0x96, 0x5e, 0x72, 0xe6, 0x2c, 0x6c, 0x04, + 0x61, 0x44, 0xe6, 0xbd, 0xf5, 0x75, 0x12, 0x91, 0xc0, 0x25, 0xb1, 0x72, 0xfc, 0x58, 0xfd, 0x1c, + 0x3f, 0xe8, 0x5d, 0x30, 0x76, 0x27, 0x0e, 0x83, 0x95, 0xd0, 0x0b, 0x84, 0x08, 0xa2, 0x3b, 0x8e, + 0xe3, 0xf7, 0x77, 0xa6, 0xc7, 0xe8, 0x88, 0xca, 0x76, 0x9c, 0xc2, 0x42, 0x73, 0x30, 0x79, 0xe7, + 0x95, 0x15, 0x27, 0x31, 0x5c, 0x0d, 0xd2, 0x29, 0xc0, 0x4e, 0xb6, 0xae, 0xbd, 0x37, 0x03, 0xc4, + 0xbd, 0xf8, 0xf6, 0xdf, 0x2e, 0xc1, 0xe9, 0xcc, 0x8b, 0x84, 0xbe, 0x1f, 0x76, 0x12, 0xba, 0x27, + 0x42, 0x5f, 0xb1, 0xe0, 0x78, 0x2b, 0xed, 0xcd, 0x88, 0x85, 0x2f, 0xfc, 0x7d, 0x85, 0xe9, 0x88, + 0x8c, 0xbb, 0xa4, 0x3e, 0x25, 0x46, 0xe8, 0x78, 0x06, 0x10, 0xe3, 0x9e, 0xbe, 0xa0, 0x97, 0xa1, + 0xd6, 0x72, 0xee, 0xdd, 0x6c, 0x37, 0x9d, 0x44, 0xee, 0x55, 0xfb, 0xbb, 0x18, 0x3a, 0x89, 0xe7, + 0xcf, 0xf0, 0xa0, 0x9a, 0x99, 0x85, 0x20, 0x59, 0x8e, 0x1a, 0x49, 0xe4, 0x05, 0x1b, 0xdc, 0x03, + 0xba, 0x24, 0xc9, 0x60, 0x4d, 0xd1, 0xfe, 0xb2, 0x95, 0x55, 0x52, 0x6a, 0x74, 0x22, 0x27, 0x21, + 0x1b, 0x5d, 0xf4, 0x31, 0xa8, 0xd0, 0x7d, 0xa3, 0x1c, 0x95, 0xdb, 0x45, 0x6a, 0x4e, 0xe3, 0x4b, + 0x68, 0x25, 0x4a, 0xff, 0xc5, 0x98, 0x33, 0xb5, 0xbf, 0x52, 0xcb, 0x1a, 0x0b, 0x2c, 0x24, 0xe0, + 0x22, 0xc0, 0x46, 0xb8, 0x4a, 0x5a, 0x6d, 0x9f, 0x0e, 0x8b, 0xc5, 0x4e, 0x7f, 0x94, 0x1f, 0xe5, + 0x8a, 0x82, 0x60, 0x03, 0x0b, 0x7d, 0xce, 0x02, 0xd8, 0x90, 0x73, 0x5e, 0x1a, 0x02, 0x37, 0x8b, + 0x7c, 0x1d, 0xbd, 0xa2, 0x74, 0x5f, 0x14, 0x43, 0x6c, 0x30, 0x47, 0xdf, 0x6b, 0x41, 0x35, 0x91, + 0xdd, 0xe7, 0xaa, 0x71, 0xb5, 0xc8, 0x9e, 0xc8, 0x97, 0xd6, 0x36, 0x91, 0x1a, 0x12, 0xc5, 0x17, + 0x7d, 0x9f, 0x05, 0x10, 0x77, 0x03, 0x77, 0x25, 0xf4, 0x3d, 0xb7, 0x2b, 0x34, 0xe6, 0xad, 0x42, + 0x7d, 0x3d, 0x8a, 0x7a, 0x7d, 0x82, 0x8e, 0x86, 0xfe, 0x8f, 0x0d, 0xce, 0xe8, 0xe3, 0x50, 0x8d, + 0xc5, 0x74, 0x13, 0x3a, 0x72, 0xb5, 0x58, 0x8f, 0x13, 0xa7, 0x2d, 0xc4, 0xab, 0xf8, 0x87, 0x15, + 0x4f, 0xf4, 0x23, 0x16, 0x1c, 0x6b, 0xa7, 0x7d, 0x88, 0x42, 0x1d, 0x16, 0x27, 0x03, 0x32, 0x3e, + 0x4a, 0xee, 0x6d, 0xc9, 0x34, 0xe2, 0x6c, 0x2f, 0xa8, 0x04, 0xd4, 0x33, 0x78, 0xb9, 0xcd, 0xfd, + 0x99, 0x23, 0x5a, 0x02, 0x5e, 0xc9, 0x02, 0x71, 0x2f, 0x3e, 0x5a, 0x81, 0x93, 0xb4, 0x77, 0x5d, + 0x6e, 0x7e, 0x4a, 0xf5, 0x12, 0x33, 0x65, 0x58, 0xad, 0x9f, 0x15, 0x33, 0x84, 0x1d, 0x84, 0x64, + 0x71, 0x70, 0xee, 0x93, 0xe8, 0x37, 0x2d, 0x38, 0xeb, 0x31, 0x35, 0x60, 0x7a, 0xf3, 0xb5, 0x46, + 0x10, 0x47, 0xf6, 0xa4, 0x50, 0x59, 0xd1, 0x4f, 0xfd, 0xd4, 0xbf, 0x49, 0xbc, 0xc1, 0xd9, 0x85, + 0x5d, 0xba, 0x84, 0x77, 0xed, 0x30, 0xfa, 0x56, 0x18, 0x97, 0xeb, 0x62, 0x85, 0x8a, 0x60, 0xa6, + 0x68, 0x6b, 0xf5, 0xc9, 0xfb, 0x3b, 0xd3, 0xe3, 0xab, 0x26, 0x00, 0xa7, 0xf1, 0xec, 0x3f, 0x1f, + 0x4a, 0x1d, 0x21, 0x29, 0x07, 0x27, 0x13, 0x37, 0xae, 0xf4, 0xff, 0x48, 0xe9, 0x59, 0xa8, 0xb8, + 0x51, 0xde, 0x25, 0x2d, 0x6e, 0x54, 0x53, 0x8c, 0x0d, 0xe6, 0xd4, 0x28, 0x9d, 0x74, 0xb2, 0x6e, + 0x54, 0x21, 0x01, 0x5f, 0x2e, 0xb2, 0x4b, 0xbd, 0x07, 0x7e, 0xa7, 0x45, 0xd7, 0x26, 0x7b, 0x40, + 0xb8, 0xb7, 0x4b, 0xe8, 0xbb, 0xa1, 0x16, 0xa9, 0x18, 0x99, 0x72, 0x11, 0x5b, 0x35, 0x39, 0x6d, + 0x44, 0x77, 0xd4, 0xe9, 0x90, 0x8e, 0x86, 0xd1, 0x1c, 0xd1, 0x7b, 0x60, 0x42, 0xfd, 0x99, 0x63, + 0xc7, 0x42, 0x54, 0x28, 0x96, 0xeb, 0x4f, 0x88, 0xa7, 0x26, 0x70, 0x0a, 0x8a, 0x33, 0xd8, 0x28, + 0x82, 0x61, 0x1e, 0xb7, 0x29, 0xc4, 0xd8, 0x01, 0xb7, 0x3b, 0x66, 0xf0, 0xa7, 0xf6, 0x11, 0xf2, + 0x56, 0x2c, 0x38, 0xd9, 0x9f, 0x2d, 0xa5, 0x4e, 0xfa, 0x0c, 0x79, 0x37, 0xc0, 0x29, 0xe6, 0x17, + 0x2d, 0x18, 0x8d, 0x42, 0xdf, 0xf7, 0x82, 0x0d, 0x2a, 0x9b, 0x85, 0x81, 0xf1, 0xc1, 0x43, 0xd1, + 0xf1, 0x42, 0x08, 0xb3, 0xdd, 0x00, 0xd6, 0x3c, 0xb1, 0xd9, 0x01, 0xf4, 0x12, 0x8c, 0x37, 0x89, + 0x4f, 0xe8, 0xb3, 0xcb, 0x11, 0xdd, 0xc7, 0x71, 0xaf, 0xb9, 0x8a, 0x93, 0x99, 0x37, 0x81, 0x38, + 0x8d, 0x6b, 0xff, 0xa1, 0x05, 0x53, 0xfd, 0x14, 0x10, 0x22, 0xf0, 0x94, 0x94, 0xae, 0xea, 0x2b, + 0x2e, 0x07, 0x92, 0x9e, 0xb0, 0x21, 0x9e, 0x11, 0x7c, 0x9e, 0x5a, 0xe9, 0x8f, 0x8a, 0x77, 0xa3, + 0x83, 0x3e, 0x00, 0xc7, 0x8d, 0x41, 0x89, 0xd5, 0xa8, 0xd6, 0xea, 0x33, 0xd4, 0xe2, 0x9b, 0xcd, + 0xc0, 0x1e, 0xec, 0x4c, 0x3f, 0x91, 0x6d, 0x13, 0x1a, 0xb2, 0x87, 0x8e, 0xfd, 0x13, 0x3d, 0x9f, + 0x5a, 0x19, 0x37, 0xaf, 0x5b, 0x3d, 0xee, 0x93, 0xf7, 0x1d, 0x86, 0x41, 0xc1, 0x1c, 0x2d, 0x2a, + 0x28, 0xa5, 0x3f, 0xce, 0x23, 0x0c, 0x62, 0xb0, 0x7f, 0x63, 0x08, 0x76, 0xe9, 0xd9, 0x00, 0xbb, + 0x95, 0x7d, 0x9f, 0x2a, 0x7f, 0xc1, 0x52, 0xc7, 0x87, 0x5c, 0x68, 0x35, 0x0f, 0x6b, 0xec, 0xf9, + 0x86, 0x31, 0xe6, 0x81, 0x34, 0x4a, 0x24, 0xa4, 0x0f, 0x2a, 0xd1, 0x57, 0xad, 0xf4, 0x01, 0x28, + 0x0f, 0x1e, 0xf5, 0x0e, 0xad, 0x4f, 0xc6, 0xa9, 0x2a, 0xef, 0x98, 0x3e, 0x8b, 0xeb, 0x77, 0xde, + 0x3a, 0x03, 0xb0, 0xee, 0x05, 0x8e, 0xef, 0xbd, 0x4a, 0xb7, 0x83, 0x15, 0x66, 0xd1, 0x30, 0x13, + 0xf1, 0xb2, 0x6a, 0xc5, 0x06, 0xc6, 0x99, 0xbf, 0x0a, 0xa3, 0xc6, 0x9b, 0xe7, 0xc4, 0xff, 0x9c, + 0x34, 0xe3, 0x7f, 0x6a, 0x46, 0xd8, 0xce, 0x99, 0xf7, 0xc0, 0xf1, 0x6c, 0x07, 0xf7, 0xf3, 0xbc, + 0xfd, 0x7f, 0x46, 0xb2, 0x27, 0x92, 0xab, 0x24, 0x6a, 0xd1, 0xae, 0xbd, 0xe1, 0xc9, 0x7b, 0xc3, + 0x93, 0xf7, 0x86, 0x27, 0xcf, 0x3c, 0x8c, 0x11, 0x5e, 0xaa, 0x91, 0x23, 0xf2, 0x52, 0xa5, 0xfc, + 0x6e, 0xd5, 0xc2, 0xfd, 0x6e, 0xf6, 0x67, 0x7a, 0x8e, 0x2a, 0x56, 0x23, 0x42, 0x50, 0x08, 0x95, + 0x20, 0x6c, 0x12, 0x69, 0xd4, 0x5f, 0x2b, 0xc6, 0x42, 0xbd, 0x11, 0x36, 0x8d, 0xb0, 0x7c, 0xfa, + 0x2f, 0xc6, 0x9c, 0x8f, 0xfd, 0xbf, 0x7b, 0x0c, 0x9b, 0xdb, 0xcc, 0x4f, 0xb4, 0x4d, 0x82, 0x04, + 0x5d, 0x4f, 0x59, 0x79, 0xdf, 0x9a, 0x39, 0x75, 0x7f, 0x6b, 0xbf, 0x04, 0xac, 0xbb, 0x94, 0xc2, + 0x0c, 0x23, 0x61, 0x18, 0x84, 0x5f, 0xb0, 0x60, 0xc2, 0x49, 0x71, 0x2a, 0x2c, 0xa3, 0xc6, 0x3c, + 0x31, 0x51, 0x06, 0x75, 0xc6, 0x56, 0xcc, 0xf0, 0xb6, 0x3f, 0x3d, 0x0c, 0xa9, 0x8d, 0x03, 0x9f, + 0xf0, 0xdf, 0x0c, 0x23, 0x11, 0x69, 0x87, 0x37, 0xf1, 0xa2, 0x78, 0x69, 0x9d, 0xd6, 0xc5, 0x9b, + 0xb1, 0x84, 0x53, 0x65, 0xdf, 0x76, 0x92, 0x4d, 0xa1, 0xc5, 0x95, 0xb2, 0x5f, 0x71, 0x92, 0x4d, + 0xcc, 0x20, 0xd4, 0xe6, 0x4f, 0x52, 0x41, 0x0f, 0xe2, 0x70, 0x5f, 0x75, 0x31, 0x1d, 0x12, 0x81, + 0x33, 0xd8, 0xe8, 0x15, 0x18, 0xda, 0x24, 0x7e, 0x4b, 0xcc, 0xf9, 0x46, 0x71, 0xc3, 0xc4, 0xde, + 0xf5, 0x2a, 0xf1, 0x5b, 0x5c, 0x05, 0xd0, 0x5f, 0x98, 0xb1, 0xa2, 0x0b, 0xbe, 0xb6, 0xd5, 0x89, + 0x93, 0xb0, 0xe5, 0xbd, 0x2a, 0x7d, 0xda, 0xef, 0x2b, 0x98, 0xf1, 0x75, 0x49, 0x9f, 0x3b, 0x0f, + 0xd5, 0x5f, 0xac, 0x39, 0xb3, 0x7e, 0x34, 0xbd, 0x88, 0xad, 0x95, 0xae, 0x70, 0x4d, 0x17, 0xdd, + 0x8f, 0x79, 0x49, 0x9f, 0xf7, 0x43, 0xfd, 0xc5, 0x9a, 0x33, 0xea, 0x2a, 0xc1, 0x33, 0xca, 0xfa, + 0x70, 0xb3, 0xe0, 0x3e, 0x70, 0xa1, 0x93, 0x2b, 0x80, 0x9e, 0x81, 0x8a, 0xbb, 0xe9, 0x44, 0xc9, + 0xd4, 0x18, 0x9b, 0x34, 0x6a, 0xf9, 0xce, 0xd1, 0x46, 0xcc, 0x61, 0xe8, 0x69, 0x28, 0x47, 0x64, + 0x9d, 0x05, 0xa9, 0x1b, 0xe1, 0x71, 0x98, 0xac, 0x63, 0xda, 0xae, 0x0c, 0xd2, 0x89, 0xbe, 0x71, + 0x93, 0x3f, 0x56, 0x4a, 0x5b, 0xb4, 0xe9, 0x91, 0xe1, 0xeb, 0xc1, 0xed, 0x44, 0xb1, 0x74, 0x85, + 0x1a, 0xeb, 0x81, 0x35, 0x63, 0x09, 0x47, 0x9f, 0xb4, 0x60, 0xe4, 0x4e, 0x1c, 0x06, 0x81, 0x5a, + 0xd8, 0xb7, 0x0a, 0x1e, 0xac, 0x6b, 0x9c, 0xba, 0xee, 0x83, 0x68, 0xc0, 0x92, 0x2f, 0xed, 0x2e, + 0xb9, 0xe7, 0xfa, 0x9d, 0x66, 0x4f, 0x4c, 0xd4, 0x25, 0xde, 0x8c, 0x25, 0x9c, 0xa2, 0x7a, 0x01, + 0x47, 0x1d, 0x4a, 0xa3, 0x2e, 0x04, 0x02, 0x55, 0xc0, 0xed, 0x9f, 0xa9, 0xc2, 0xa9, 0xdc, 0xe5, + 0x43, 0x6d, 0x4d, 0x66, 0xcd, 0x5d, 0xf6, 0x7c, 0x22, 0xa3, 0x01, 0x99, 0xad, 0x79, 0x4b, 0xb5, + 0x62, 0x03, 0x03, 0x7d, 0x0f, 0x40, 0xdb, 0x89, 0x9c, 0x16, 0x51, 0x47, 0x15, 0x07, 0x36, 0xe9, + 0x68, 0x3f, 0x56, 0x24, 0x4d, 0xed, 0xae, 0x51, 0x4d, 0x31, 0x36, 0x58, 0xa2, 0x17, 0x60, 0x34, + 0x22, 0x3e, 0x71, 0x62, 0x96, 0x05, 0x91, 0x4d, 0x16, 0xc3, 0x1a, 0x84, 0x4d, 0x3c, 0xf4, 0xac, + 0x0a, 0x9c, 0x1c, 0x4a, 0x47, 0x15, 0xa5, 0x83, 0x27, 0xd1, 0x97, 0x2c, 0x98, 0x58, 0xf7, 0x7c, + 0xa2, 0xb9, 0x8b, 0xd4, 0xae, 0xe5, 0x83, 0xbf, 0xe4, 0x65, 0x93, 0xae, 0x96, 0xa1, 0xa9, 0xe6, + 0x18, 0x67, 0xd8, 0xd3, 0xcf, 0xbc, 0x4d, 0x22, 0x26, 0x7c, 0x87, 0xd3, 0x9f, 0xf9, 0x16, 0x6f, + 0xc6, 0x12, 0x8e, 0x66, 0xe1, 0x58, 0xdb, 0x89, 0xe3, 0xb9, 0x88, 0x34, 0x49, 0x90, 0x78, 0x8e, + 0xcf, 0x73, 0xa9, 0xaa, 0x3a, 0xab, 0x60, 0x25, 0x0d, 0xc6, 0x59, 0x7c, 0xf4, 0x7e, 0x78, 0x92, + 0xfb, 0x02, 0x97, 0xbc, 0x38, 0xf6, 0x82, 0x0d, 0x3d, 0x0d, 0x84, 0x4b, 0x74, 0x5a, 0x90, 0x7a, + 0x72, 0x21, 0x1f, 0x0d, 0xf7, 0x7b, 0x1e, 0x3d, 0x0f, 0xd5, 0x78, 0xcb, 0x6b, 0xcf, 0x45, 0xcd, + 0x98, 0x9d, 0x03, 0x56, 0xb5, 0x03, 0xbe, 0x21, 0xda, 0xb1, 0xc2, 0x40, 0x2e, 0x8c, 0xf1, 0x4f, + 0xc2, 0x23, 0x3f, 0x85, 0x04, 0x7d, 0x7b, 0x5f, 0x0b, 0x46, 0xe4, 0x5a, 0xcf, 0x60, 0xe7, 0xee, + 0x25, 0x79, 0x2a, 0xc9, 0x0f, 0xd1, 0x6e, 0x19, 0x64, 0x70, 0x8a, 0x68, 0x7a, 0x33, 0x3b, 0x3a, + 0xc0, 0x66, 0xf6, 0x05, 0x18, 0xdd, 0xea, 0xac, 0x11, 0x31, 0xf2, 0x42, 0xb0, 0xa9, 0xd9, 0x77, + 0x5d, 0x83, 0xb0, 0x89, 0xc7, 0x82, 0x6e, 0xdb, 0x9e, 0xf8, 0x17, 0x4f, 0x8d, 0x1b, 0x41, 0xb7, + 0x2b, 0x0b, 0xb2, 0x19, 0x9b, 0x38, 0xb4, 0x6b, 0x74, 0x2c, 0x56, 0x49, 0xcc, 0x72, 0x6a, 0xe8, + 0x70, 0xa9, 0xae, 0x35, 0x24, 0x00, 0x6b, 0x1c, 0xb4, 0x02, 0x27, 0xe9, 0x9f, 0x06, 0xcb, 0x35, + 0xbf, 0xe5, 0xf8, 0x5e, 0x93, 0x47, 0x80, 0x1e, 0x4b, 0x7b, 0xb2, 0x1b, 0x39, 0x38, 0x38, 0xf7, + 0x49, 0xfb, 0x47, 0x4b, 0x69, 0xcb, 0xca, 0x14, 0x61, 0x28, 0xa6, 0x82, 0x2a, 0xb9, 0xe5, 0x44, + 0xd2, 0xd2, 0x3b, 0x60, 0x42, 0x9c, 0xa0, 0x7b, 0xcb, 0x89, 0x4c, 0x91, 0xc7, 0x18, 0x60, 0xc9, + 0x09, 0xdd, 0x81, 0xa1, 0xc4, 0x77, 0x0a, 0x4a, 0xb7, 0x35, 0x38, 0x6a, 0xf7, 0xdf, 0xe2, 0x6c, + 0x8c, 0x19, 0x0f, 0x74, 0x96, 0x6e, 0x5b, 0xd7, 0xe4, 0x99, 0xaa, 0xd8, 0x69, 0xae, 0xc5, 0x98, + 0xb5, 0xda, 0x7f, 0x63, 0x3c, 0x47, 0xeb, 0x28, 0x43, 0x00, 0x5d, 0x04, 0xa0, 0x93, 0x66, 0x25, + 0x22, 0xeb, 0xde, 0x3d, 0x61, 0x88, 0x29, 0xc9, 0x76, 0x43, 0x41, 0xb0, 0x81, 0x25, 0x9f, 0x69, + 0x74, 0xd6, 0xe9, 0x33, 0xa5, 0xde, 0x67, 0x38, 0x04, 0x1b, 0x58, 0xe8, 0x5d, 0x30, 0xec, 0xb5, + 0x9c, 0x0d, 0x15, 0x0f, 0x7e, 0x96, 0x8a, 0xb4, 0x05, 0xd6, 0xf2, 0x60, 0x67, 0x7a, 0x42, 0x75, + 0x88, 0x35, 0x61, 0x81, 0x8b, 0x7e, 0xc2, 0x82, 0x31, 0x37, 0x6c, 0xb5, 0xc2, 0x80, 0xfb, 0x0d, + 0x84, 0x13, 0xe4, 0xce, 0x61, 0x99, 0x49, 0x33, 0x73, 0x06, 0x33, 0xee, 0x05, 0x51, 0x79, 0xc1, + 0x26, 0x08, 0xa7, 0x7a, 0x65, 0x4a, 0xbe, 0xca, 0x1e, 0x92, 0xef, 0x67, 0x2d, 0x98, 0xe4, 0xcf, + 0x1a, 0xee, 0x0c, 0x91, 0xd5, 0x1a, 0x1e, 0xf2, 0x6b, 0xf5, 0x78, 0x78, 0x94, 0x5b, 0xbf, 0x07, + 0x8e, 0x7b, 0x3b, 0x89, 0xae, 0xc0, 0xe4, 0x7a, 0x18, 0xb9, 0xc4, 0x1c, 0x08, 0x21, 0xb6, 0x15, + 0xa1, 0xcb, 0x59, 0x04, 0xdc, 0xfb, 0x0c, 0xba, 0x05, 0x4f, 0x18, 0x8d, 0xe6, 0x38, 0x70, 0xc9, + 0x7d, 0x4e, 0x50, 0x7b, 0xe2, 0x72, 0x2e, 0x16, 0xee, 0xf3, 0x74, 0x5a, 0x48, 0xd6, 0x06, 0x10, + 0x92, 0x1f, 0x81, 0xd3, 0x6e, 0xef, 0xc8, 0x6c, 0xc7, 0x9d, 0xb5, 0x98, 0xcb, 0xf1, 0x6a, 0xfd, + 0xcd, 0x82, 0xc0, 0xe9, 0xb9, 0x7e, 0x88, 0xb8, 0x3f, 0x0d, 0xf4, 0x31, 0xa8, 0x46, 0x84, 0x7d, + 0x95, 0x58, 0xa4, 0x78, 0x1e, 0xd0, 0xcd, 0xa3, 0x2d, 0x78, 0x4e, 0x56, 0x6b, 0x26, 0xd1, 0x10, + 0x63, 0xc5, 0x11, 0xdd, 0x85, 0x91, 0x36, 0xdd, 0x1f, 0x8a, 0x5c, 0xcd, 0x03, 0x6f, 0xff, 0x14, + 0x73, 0x76, 0x68, 0x66, 0xd4, 0xd6, 0xe0, 0x4c, 0xb0, 0xe4, 0x46, 0x6d, 0x35, 0x37, 0x6c, 0xb5, + 0xc3, 0x80, 0x04, 0x89, 0x54, 0x22, 0x13, 0xfc, 0x64, 0x4b, 0xb6, 0x62, 0x03, 0xa3, 0x47, 0x97, + 0x6b, 0xb4, 0xa9, 0xc9, 0x5d, 0x74, 0xb9, 0x41, 0xad, 0xdf, 0xf3, 0x54, 0xd9, 0x30, 0x7f, 0xea, + 0x6d, 0x2f, 0xd9, 0x0c, 0x3b, 0x89, 0x74, 0x0f, 0x08, 0x45, 0xa5, 0x94, 0xcd, 0x62, 0x0e, 0x0e, + 0xce, 0x7d, 0x32, 0xab, 0x59, 0x8f, 0x3d, 0x9c, 0x66, 0x3d, 0x3e, 0x80, 0x66, 0x6d, 0xc0, 0x29, + 0xd6, 0x03, 0x61, 0x25, 0x4b, 0x6f, 0x6d, 0x3c, 0x85, 0x58, 0xe7, 0x55, 0x9a, 0xd3, 0x62, 0x1e, + 0x12, 0xce, 0x7f, 0xf6, 0xcc, 0x77, 0xc2, 0x64, 0x8f, 0x90, 0xdb, 0x97, 0x27, 0x76, 0x1e, 0x9e, + 0xc8, 0x17, 0x27, 0xfb, 0xf2, 0xc7, 0xfe, 0x4c, 0x26, 0x03, 0xc1, 0xd8, 0xa2, 0x0d, 0xe0, 0xdb, + 0x77, 0xa0, 0x4c, 0x82, 0x6d, 0xa1, 0x5d, 0x2f, 0x1f, 0x6c, 0x56, 0x5f, 0x0a, 0xb6, 0xb9, 0x34, + 0x64, 0x0e, 0xcc, 0x4b, 0xc1, 0x36, 0xa6, 0xb4, 0xd1, 0x0f, 0x59, 0xa9, 0x0d, 0x04, 0x3f, 0x11, + 0xf8, 0xf0, 0xa1, 0xec, 0x49, 0x07, 0xde, 0x53, 0xd8, 0xff, 0xa6, 0x04, 0xe7, 0xf7, 0x22, 0x32, + 0xc0, 0xf0, 0x3d, 0x03, 0xc3, 0x31, 0x8b, 0x29, 0x12, 0xea, 0x6a, 0x94, 0xae, 0x62, 0x1e, 0x65, + 0xf4, 0x11, 0x2c, 0x40, 0xc8, 0x87, 0x72, 0xcb, 0x69, 0x0b, 0x47, 0xf1, 0xc2, 0x41, 0xd3, 0x38, + 0xe9, 0x7f, 0xc7, 0x5f, 0x72, 0xda, 0x7c, 0xce, 0x1b, 0x0d, 0x98, 0xb2, 0x41, 0x09, 0x54, 0x9c, + 0x28, 0x72, 0x64, 0x00, 0xcb, 0xf5, 0x62, 0xf8, 0xcd, 0x52, 0x92, 0xfc, 0xfc, 0x3f, 0xd5, 0x84, + 0x39, 0x33, 0xfb, 0x47, 0xaa, 0xa9, 0x9c, 0x3f, 0x16, 0x95, 0x14, 0xc3, 0xb0, 0xf0, 0x0f, 0x5b, + 0x45, 0x67, 0xcf, 0xf2, 0xa4, 0x7a, 0xe6, 0x81, 0x10, 0x45, 0x4f, 0x04, 0x2b, 0xf4, 0x79, 0x8b, + 0x95, 0x16, 0x91, 0x89, 0x94, 0x62, 0x57, 0x7f, 0x38, 0x95, 0x4e, 0xcc, 0x82, 0x25, 0xb2, 0x11, + 0x9b, 0xdc, 0x45, 0x19, 0x25, 0xb6, 0x9b, 0xe9, 0x2d, 0xa3, 0xc4, 0x76, 0x27, 0x12, 0x8e, 0xee, + 0xe5, 0x44, 0x1f, 0x15, 0x50, 0x71, 0x62, 0x80, 0x78, 0xa3, 0xaf, 0x5a, 0x30, 0xe9, 0x65, 0xc3, + 0x48, 0xc4, 0x1e, 0xf8, 0x76, 0x31, 0xce, 0xdc, 0xde, 0x28, 0x15, 0x65, 0xe8, 0xf4, 0x80, 0x70, + 0x6f, 0x67, 0x50, 0x13, 0x86, 0xbc, 0x60, 0x3d, 0x14, 0xe6, 0x5d, 0xfd, 0x60, 0x9d, 0x5a, 0x08, + 0xd6, 0x43, 0xbd, 0x9a, 0xe9, 0x3f, 0xcc, 0xa8, 0xa3, 0x45, 0x38, 0x29, 0x33, 0xbb, 0xae, 0x7a, + 0x71, 0x12, 0x46, 0xdd, 0x45, 0xaf, 0xe5, 0x25, 0xcc, 0x34, 0x2b, 0xd7, 0xa7, 0xa8, 0x7a, 0xc3, + 0x39, 0x70, 0x9c, 0xfb, 0x14, 0x7a, 0x15, 0x46, 0x64, 0xe8, 0x46, 0xb5, 0x08, 0x7f, 0x42, 0xef, + 0xfc, 0x57, 0x93, 0xa9, 0x21, 0x62, 0x37, 0x24, 0x43, 0xf4, 0x59, 0x0b, 0x26, 0xf8, 0xef, 0xab, + 0xdd, 0x26, 0xcf, 0x34, 0xad, 0x15, 0xe1, 0xb7, 0x6e, 0xa4, 0x68, 0xd6, 0xd1, 0xfd, 0x9d, 0xe9, + 0x89, 0x74, 0x1b, 0xce, 0xf0, 0xb5, 0xff, 0xe1, 0x18, 0xf4, 0x06, 0xbb, 0xa4, 0x23, 0x5b, 0xac, + 0x23, 0x8f, 0x6c, 0xb9, 0x03, 0x43, 0xb1, 0x0e, 0xf0, 0x28, 0x60, 0x99, 0x09, 0xae, 0xfa, 0xfc, + 0xbd, 0x1b, 0xb8, 0x98, 0xf1, 0x40, 0x1d, 0x15, 0x05, 0x53, 0x2e, 0xe8, 0xc8, 0x7f, 0x90, 0x40, + 0x18, 0x74, 0x0f, 0x46, 0x36, 0xf9, 0x74, 0x14, 0x7b, 0xbd, 0xa5, 0x83, 0x8e, 0x6f, 0x6a, 0x8e, + 0xeb, 0xc9, 0x27, 0x1a, 0xb0, 0x64, 0xc7, 0x02, 0x29, 0x8d, 0x50, 0x2f, 0x2e, 0x48, 0x8a, 0x4b, + 0x9a, 0x1d, 0x3c, 0xce, 0xeb, 0xa3, 0x30, 0x16, 0x11, 0x37, 0x0c, 0x5c, 0xcf, 0x27, 0xcd, 0x59, + 0x79, 0x12, 0xb8, 0x9f, 0x74, 0x48, 0xe6, 0x4d, 0xc2, 0x06, 0x0d, 0x9c, 0xa2, 0xc8, 0xd6, 0x99, + 0xaa, 0x9f, 0x40, 0x3f, 0x08, 0x11, 0x07, 0x1f, 0x8b, 0x05, 0x55, 0x6b, 0x60, 0x34, 0xf9, 0x3a, + 0x4b, 0xb7, 0xe1, 0x0c, 0x5f, 0xf4, 0x01, 0x80, 0x70, 0x8d, 0x47, 0x4b, 0xce, 0x26, 0xe2, 0x14, + 0x64, 0x3f, 0xaf, 0x3a, 0xc1, 0x73, 0xae, 0x25, 0x05, 0x6c, 0x50, 0x43, 0xd7, 0x01, 0xf8, 0xca, + 0x59, 0xed, 0xb6, 0xe5, 0x86, 0x50, 0xe6, 0xb3, 0x42, 0x43, 0x41, 0x1e, 0xec, 0x4c, 0xf7, 0xfa, + 0x9c, 0xd9, 0x69, 0x9a, 0xf1, 0x38, 0xfa, 0x2e, 0x18, 0x89, 0x3b, 0xad, 0x96, 0xa3, 0xce, 0x48, + 0x0a, 0xcc, 0xe2, 0xe6, 0x74, 0x0d, 0xc1, 0xc8, 0x1b, 0xb0, 0xe4, 0x88, 0xee, 0x50, 0x11, 0x2f, + 0x24, 0x14, 0x5f, 0x45, 0xdc, 0x42, 0xe1, 0x9e, 0xc0, 0x77, 0xcb, 0x5d, 0x0c, 0xce, 0xc1, 0x79, + 0xb0, 0x33, 0xfd, 0x44, 0xba, 0x7d, 0x31, 0x14, 0x79, 0xd5, 0xb9, 0x34, 0xd1, 0x35, 0x59, 0xa8, + 0x8d, 0xbe, 0xb6, 0xac, 0xf2, 0xf3, 0x9c, 0x2e, 0xd4, 0xc6, 0x9a, 0xfb, 0x8f, 0x99, 0xf9, 0x30, + 0x5a, 0x82, 0x13, 0x6e, 0x18, 0x24, 0x51, 0xe8, 0xfb, 0xbc, 0x98, 0x23, 0xdf, 0x9b, 0xf3, 0x33, + 0x94, 0xa7, 0x44, 0xb7, 0x4f, 0xcc, 0xf5, 0xa2, 0xe0, 0xbc, 0xe7, 0xa8, 0x4d, 0x9e, 0xd5, 0x0f, + 0x13, 0x85, 0xc4, 0x15, 0xa4, 0x68, 0x0a, 0x09, 0xa5, 0xdc, 0xde, 0x7b, 0x68, 0x8a, 0x20, 0x7d, + 0xba, 0x2c, 0xbe, 0xd8, 0xbb, 0x60, 0x8c, 0xdc, 0x4b, 0x48, 0x14, 0x38, 0xfe, 0x4d, 0xbc, 0x28, + 0x0f, 0x2c, 0xd8, 0xc2, 0xbc, 0x64, 0xb4, 0xe3, 0x14, 0x16, 0xb2, 0x95, 0x97, 0xcc, 0x28, 0x60, + 0xc0, 0xbd, 0x64, 0xd2, 0x27, 0x66, 0xff, 0x74, 0x39, 0x65, 0xb3, 0x3e, 0x92, 0xb3, 0x6c, 0x56, + 0x56, 0x4b, 0xd6, 0x1f, 0x63, 0x00, 0xb1, 0x17, 0x2b, 0x92, 0xb3, 0x0a, 0x17, 0x5c, 0x36, 0x19, + 0xe1, 0x34, 0x5f, 0xb4, 0x05, 0x95, 0xcd, 0x30, 0x4e, 0xe4, 0x0e, 0xed, 0x80, 0x9b, 0xc1, 0xab, + 0x61, 0x9c, 0x30, 0x43, 0x4b, 0xbd, 0x36, 0x6d, 0x89, 0x31, 0xe7, 0x41, 0xf7, 0xfe, 0xf1, 0xa6, + 0x13, 0x35, 0x53, 0x71, 0xa5, 0xca, 0x9e, 0x6e, 0x68, 0x10, 0x36, 0xf1, 0xec, 0x3f, 0xb2, 0x52, + 0xa7, 0x5a, 0x87, 0x75, 0xec, 0xff, 0x09, 0x2b, 0x5d, 0x52, 0xa1, 0x54, 0xc4, 0xd6, 0xcd, 0x2c, + 0x2b, 0xb2, 0x67, 0x75, 0x06, 0xfb, 0x87, 0x2c, 0x18, 0xa9, 0x3b, 0xee, 0x56, 0xb8, 0xbe, 0x8e, + 0x9e, 0x87, 0x6a, 0xb3, 0x13, 0x99, 0xd5, 0x1d, 0x94, 0xb3, 0x6a, 0x5e, 0xb4, 0x63, 0x85, 0x41, + 0xa7, 0xfe, 0xba, 0xe3, 0xca, 0xe2, 0x22, 0x65, 0x3e, 0xf5, 0x2f, 0xb3, 0x16, 0x2c, 0x20, 0x74, + 0xf8, 0x5b, 0xce, 0x3d, 0xf9, 0x70, 0xf6, 0x48, 0x6d, 0x49, 0x83, 0xb0, 0x89, 0x67, 0xff, 0x8a, + 0x05, 0x53, 0x75, 0x27, 0xf6, 0xdc, 0xd9, 0x4e, 0xb2, 0x59, 0xf7, 0x92, 0xb5, 0x8e, 0xbb, 0x45, + 0x12, 0x5e, 0x84, 0x86, 0xf6, 0xb2, 0x13, 0xd3, 0x15, 0xa8, 0x76, 0xcc, 0xaa, 0x97, 0x37, 0x45, + 0x3b, 0x56, 0x18, 0xe8, 0x55, 0x18, 0x6d, 0x3b, 0x71, 0x7c, 0x37, 0x8c, 0x9a, 0x98, 0xac, 0x17, + 0x53, 0xa6, 0xaa, 0x41, 0xdc, 0x88, 0x24, 0x98, 0xac, 0x8b, 0xc8, 0x1c, 0x4d, 0x1f, 0x9b, 0xcc, + 0xec, 0xcf, 0x59, 0x70, 0xb2, 0x4e, 0x9c, 0x88, 0x44, 0xac, 0xaa, 0x95, 0x7a, 0x11, 0xf4, 0x0a, + 0x54, 0x13, 0xda, 0x42, 0x7b, 0x64, 0x15, 0xdb, 0x23, 0x16, 0x53, 0xb3, 0x2a, 0x88, 0x63, 0xc5, + 0xc6, 0xfe, 0xa2, 0x05, 0xa7, 0xf3, 0xfa, 0x32, 0xe7, 0x87, 0x9d, 0xe6, 0xa3, 0xe8, 0xd0, 0xdf, + 0xb2, 0x60, 0x8c, 0x1d, 0xd7, 0xcf, 0x93, 0xc4, 0xf1, 0xfc, 0x9e, 0x5a, 0x9d, 0xd6, 0x80, 0xb5, + 0x3a, 0xcf, 0xc3, 0xd0, 0x66, 0xd8, 0x22, 0xd9, 0x50, 0x93, 0xab, 0x61, 0x8b, 0x60, 0x06, 0x41, + 0xef, 0xa0, 0x93, 0xd0, 0x0b, 0x12, 0x87, 0x2e, 0x47, 0x79, 0x9c, 0x71, 0x8c, 0x4f, 0x40, 0xd5, + 0x8c, 0x4d, 0x1c, 0xfb, 0x5f, 0xd5, 0x60, 0x44, 0x04, 0x84, 0x0d, 0x5c, 0x14, 0x49, 0x7a, 0x71, + 0x4a, 0x7d, 0xbd, 0x38, 0x31, 0x0c, 0xbb, 0xac, 0xb0, 0xb2, 0xb0, 0xd0, 0xaf, 0x17, 0x12, 0x41, + 0xc8, 0x6b, 0x35, 0xeb, 0x6e, 0xf1, 0xff, 0x58, 0xb0, 0x42, 0xaf, 0x59, 0x70, 0xcc, 0x0d, 0x83, + 0x80, 0xb8, 0xda, 0x76, 0x1c, 0x2a, 0x62, 0x83, 0x30, 0x97, 0x26, 0xaa, 0x4f, 0x82, 0x33, 0x00, + 0x9c, 0x65, 0x8f, 0x5e, 0x82, 0x71, 0x3e, 0x66, 0xb7, 0x52, 0x67, 0x30, 0xba, 0x2a, 0xa3, 0x09, + 0xc4, 0x69, 0x5c, 0x34, 0xc3, 0xcf, 0xb2, 0x44, 0x49, 0xc3, 0x61, 0xed, 0xaa, 0x36, 0x8a, 0x19, + 0x1a, 0x18, 0x28, 0x02, 0x14, 0x91, 0xf5, 0x88, 0xc4, 0x9b, 0x22, 0x60, 0x8e, 0xd9, 0xad, 0x23, + 0x0f, 0x57, 0xb1, 0x04, 0xf7, 0x50, 0xc2, 0x39, 0xd4, 0xd1, 0x96, 0x70, 0x23, 0x54, 0x8b, 0x90, + 0xe7, 0xe2, 0x33, 0xf7, 0xf5, 0x26, 0x4c, 0x43, 0x85, 0xa9, 0x2e, 0x66, 0x2f, 0x97, 0x79, 0x96, + 0x2c, 0x53, 0x6c, 0x98, 0xb7, 0xa3, 0x79, 0x38, 0x9e, 0x29, 0x13, 0x19, 0x8b, 0xb3, 0x12, 0x95, + 0x11, 0x99, 0x29, 0x30, 0x19, 0xe3, 0x9e, 0x27, 0x4c, 0x17, 0xd3, 0xe8, 0x1e, 0x2e, 0xa6, 0xae, + 0x0a, 0xcb, 0xe6, 0xa7, 0x18, 0xef, 0x2d, 0x64, 0x00, 0x06, 0x8a, 0xc1, 0xfe, 0xc1, 0x4c, 0x0c, + 0xf6, 0x38, 0xeb, 0xc0, 0xad, 0x62, 0x3a, 0xb0, 0xff, 0x80, 0xeb, 0x47, 0x19, 0x40, 0xfd, 0xbf, + 0x2c, 0x90, 0xdf, 0x75, 0xce, 0x71, 0x37, 0x09, 0x9d, 0x32, 0x39, 0xa9, 0x36, 0xd6, 0xbe, 0x52, + 0x6d, 0x2e, 0x40, 0x8d, 0x8e, 0x13, 0x7f, 0x94, 0xeb, 0x7d, 0xe5, 0x01, 0x99, 0x5d, 0x59, 0x10, + 0x4f, 0x69, 0x1c, 0x14, 0xc2, 0xa4, 0xef, 0xc4, 0x09, 0xeb, 0x41, 0xa3, 0x1b, 0xb8, 0x0f, 0x59, + 0x2f, 0x88, 0xa5, 0xdd, 0x2d, 0x66, 0x09, 0xe1, 0x5e, 0xda, 0xf6, 0xbf, 0xab, 0xc0, 0x78, 0x4a, + 0x32, 0xee, 0xd3, 0x60, 0x78, 0x1e, 0xaa, 0x52, 0x87, 0x67, 0xab, 0xa6, 0x29, 0x45, 0xaf, 0x30, + 0xa8, 0xd2, 0x5a, 0xd3, 0x5a, 0x35, 0x6b, 0xe0, 0x18, 0x0a, 0x17, 0x9b, 0x78, 0x4c, 0x28, 0x27, + 0x7e, 0x3c, 0xe7, 0x7b, 0x24, 0x48, 0x78, 0x37, 0x8b, 0x11, 0xca, 0xab, 0x8b, 0x0d, 0x93, 0xa8, + 0x16, 0xca, 0x19, 0x00, 0xce, 0xb2, 0x47, 0x9f, 0xb6, 0x60, 0xdc, 0xb9, 0x1b, 0xeb, 0xea, 0xff, + 0x22, 0xda, 0xfa, 0x80, 0x4a, 0x2a, 0x75, 0xa1, 0x00, 0x77, 0xec, 0xa7, 0x9a, 0x70, 0x9a, 0x29, + 0x7a, 0xdd, 0x02, 0x44, 0xee, 0x11, 0x57, 0xc6, 0x83, 0x8b, 0xbe, 0x0c, 0x17, 0xb1, 0x83, 0xbf, + 0xd4, 0x43, 0x97, 0x4b, 0xf5, 0xde, 0x76, 0x9c, 0xd3, 0x07, 0x74, 0x0d, 0x50, 0xd3, 0x8b, 0x9d, + 0x35, 0x9f, 0xcc, 0x85, 0x2d, 0x99, 0x2a, 0x2e, 0xce, 0xd3, 0xcf, 0x88, 0x71, 0x46, 0xf3, 0x3d, + 0x18, 0x38, 0xe7, 0x29, 0x36, 0xcb, 0xa2, 0xf0, 0x5e, 0xf7, 0x66, 0xe4, 0x33, 0x2d, 0x61, 0xce, + 0x32, 0xd1, 0x8e, 0x15, 0x86, 0xfd, 0xc7, 0x65, 0xb5, 0x94, 0x75, 0xf2, 0x83, 0x63, 0x04, 0x61, + 0x5b, 0x0f, 0x1f, 0x84, 0xad, 0x23, 0xa5, 0x7a, 0x0b, 0x20, 0xa4, 0xf2, 0xa5, 0x4b, 0x8f, 0x28, + 0x5f, 0xfa, 0x7b, 0xad, 0x54, 0x65, 0xc2, 0xd1, 0x8b, 0x1f, 0x28, 0x36, 0xf1, 0x62, 0x86, 0x47, + 0x71, 0x65, 0xf4, 0x4a, 0x26, 0x78, 0xef, 0x79, 0xa8, 0xae, 0xfb, 0x0e, 0x2b, 0x99, 0xc3, 0x16, + 0xaa, 0x11, 0x61, 0x76, 0x59, 0xb4, 0x63, 0x85, 0x41, 0xa5, 0xbe, 0x41, 0x74, 0x5f, 0x52, 0xfb, + 0x3f, 0x96, 0x61, 0xd4, 0xd0, 0xf8, 0xb9, 0xe6, 0x9b, 0xf5, 0x98, 0x99, 0x6f, 0xa5, 0x7d, 0x98, + 0x6f, 0xdf, 0x03, 0x35, 0x57, 0x6a, 0xa3, 0x62, 0xee, 0x70, 0xc8, 0xea, 0x38, 0xad, 0x90, 0x54, + 0x13, 0xd6, 0x3c, 0xd1, 0x95, 0x54, 0x4e, 0x6e, 0xca, 0x2f, 0x90, 0x97, 0x34, 0x2b, 0x34, 0x5a, + 0xef, 0x33, 0xd9, 0xf8, 0x80, 0xca, 0xde, 0xf1, 0x01, 0xf6, 0xef, 0x59, 0xea, 0xe3, 0x1e, 0x41, + 0xf1, 0xa5, 0x3b, 0xe9, 0xe2, 0x4b, 0x97, 0x0a, 0x19, 0xe6, 0x3e, 0x55, 0x97, 0x3e, 0x67, 0xc1, + 0xb9, 0xdd, 0xab, 0x99, 0xa3, 0x67, 0xa0, 0xb2, 0x11, 0x85, 0x9d, 0xb6, 0xd0, 0xc1, 0x8a, 0x0e, + 0x2b, 0x1d, 0x8f, 0x39, 0x8c, 0x6e, 0xa2, 0xb6, 0xbc, 0xa0, 0x99, 0xdd, 0x44, 0x5d, 0xf7, 0x82, + 0x26, 0x66, 0x90, 0x01, 0xca, 0xdd, 0xde, 0x80, 0x91, 0xb9, 0xb0, 0xd5, 0x72, 0x82, 0x26, 0x7a, + 0x0b, 0x8c, 0xb8, 0xfc, 0xa7, 0xf0, 0xe7, 0xb1, 0x83, 0x73, 0x01, 0xc5, 0x12, 0x86, 0xce, 0xc2, + 0x90, 0x13, 0x6d, 0x48, 0x1f, 0x1e, 0x0b, 0xc8, 0x9b, 0x8d, 0x36, 0x62, 0xcc, 0x5a, 0xed, 0x3f, + 0xb5, 0x60, 0x82, 0x3e, 0xe2, 0xb1, 0x01, 0x66, 0x43, 0xfb, 0x2c, 0x0c, 0x3b, 0x9d, 0x64, 0x33, + 0xec, 0xd9, 0x13, 0xce, 0xb2, 0x56, 0x2c, 0xa0, 0xb4, 0xb3, 0xaa, 0x82, 0x88, 0xd1, 0xd9, 0x79, + 0xba, 0xae, 0x18, 0x84, 0x9a, 0xd5, 0x71, 0x67, 0x2d, 0xef, 0xe4, 0xb6, 0xc1, 0x9b, 0xb1, 0x84, + 0x53, 0x62, 0x6b, 0x61, 0xb3, 0x2b, 0xc2, 0x8c, 0x15, 0xb1, 0x7a, 0xd8, 0xec, 0x62, 0x06, 0x41, + 0x4f, 0x43, 0x39, 0xde, 0x74, 0x64, 0x8c, 0x80, 0x8c, 0x78, 0x6f, 0x5c, 0x9d, 0xc5, 0xb4, 0x5d, + 0x25, 0x70, 0x44, 0x7e, 0x36, 0xde, 0x37, 0x9d, 0xc0, 0x11, 0xf9, 0xf6, 0x3f, 0x1b, 0x02, 0x16, + 0xfb, 0xe3, 0x44, 0xa4, 0xb9, 0x1a, 0xb2, 0x02, 0xd5, 0x87, 0x7a, 0xc4, 0xae, 0x37, 0xd5, 0x8f, + 0xf3, 0x31, 0xbb, 0x71, 0xd4, 0x5a, 0x3e, 0xea, 0xa3, 0xd6, 0xfc, 0xd3, 0xf3, 0xa1, 0xc7, 0xe8, + 0xf4, 0xdc, 0xfe, 0x82, 0x05, 0x48, 0x45, 0x72, 0xe9, 0xf0, 0x96, 0x0b, 0x50, 0x53, 0xa1, 0x63, + 0x62, 0xbd, 0x68, 0x11, 0x2d, 0x01, 0x58, 0xe3, 0x0c, 0xe0, 0x49, 0x79, 0x46, 0xea, 0xcf, 0x72, + 0x5a, 0x96, 0x30, 0xad, 0x2b, 0xd4, 0xa9, 0xfd, 0x4b, 0x25, 0x78, 0x82, 0x9b, 0x6e, 0x4b, 0x4e, + 0xe0, 0x6c, 0x90, 0x16, 0xed, 0xd5, 0xa0, 0x01, 0x4b, 0x2e, 0xdd, 0xc2, 0x7b, 0x32, 0x5b, 0xe3, + 0xa0, 0xb2, 0x93, 0xcb, 0x19, 0x2e, 0x59, 0x16, 0x02, 0x2f, 0xc1, 0x8c, 0x38, 0x8a, 0xa1, 0x2a, + 0x2f, 0xe1, 0x12, 0xba, 0xb0, 0x20, 0x46, 0x4a, 0x2d, 0x08, 0x2b, 0x87, 0x60, 0xc5, 0x88, 0x9a, + 0x32, 0x7e, 0xe8, 0x6e, 0xd1, 0x25, 0x9f, 0x35, 0x65, 0x16, 0x45, 0x3b, 0x56, 0x18, 0x76, 0x0b, + 0x8e, 0xc9, 0x31, 0x6c, 0x5f, 0x27, 0x5d, 0x4c, 0xd6, 0xa9, 0xfe, 0x77, 0x65, 0x93, 0x71, 0x2f, + 0x98, 0xd2, 0xff, 0x73, 0x26, 0x10, 0xa7, 0x71, 0x65, 0xcd, 0xea, 0x52, 0x7e, 0xcd, 0x6a, 0xfb, + 0x97, 0x2c, 0xc8, 0x1a, 0x20, 0xcc, 0x01, 0x67, 0x5e, 0xf2, 0xd5, 0xaf, 0x98, 0xfd, 0x3e, 0xca, + 0xd8, 0x7e, 0x08, 0x46, 0x9d, 0x84, 0x5a, 0x98, 0xdc, 0x1b, 0x54, 0x7e, 0xb8, 0x53, 0xcc, 0xa5, + 0xb0, 0xe9, 0xad, 0x7b, 0xcc, 0x0b, 0x64, 0x92, 0xb3, 0xff, 0x66, 0x05, 0x6a, 0xf3, 0x51, 0x77, + 0xff, 0x69, 0x73, 0xbd, 0x49, 0x71, 0xa5, 0x7d, 0x25, 0xc5, 0xc9, 0xb4, 0xbb, 0x72, 0xdf, 0xb4, + 0x3b, 0x99, 0x36, 0x37, 0xf4, 0xa8, 0xd2, 0xe6, 0x2a, 0x8f, 0x49, 0xda, 0xdc, 0xf0, 0x63, 0x90, + 0x36, 0x37, 0x72, 0xc4, 0x69, 0x73, 0xf6, 0xff, 0x18, 0x82, 0xc9, 0x9e, 0xf4, 0x67, 0xf4, 0x22, + 0x8c, 0xa9, 0x35, 0x2a, 0x0f, 0x00, 0x6a, 0x66, 0x18, 0xbd, 0x86, 0xe1, 0x14, 0xe6, 0x00, 0x82, + 0x7a, 0x01, 0x4e, 0x44, 0xe4, 0x95, 0x0e, 0xe9, 0x90, 0xd9, 0xf5, 0x84, 0x44, 0x0d, 0xe2, 0x86, + 0x41, 0x93, 0x17, 0x38, 0x2f, 0xd7, 0x9f, 0xbc, 0xbf, 0x33, 0x7d, 0x02, 0xf7, 0x82, 0x71, 0xde, + 0x33, 0xa8, 0x0d, 0xe3, 0xbe, 0xb9, 0x73, 0x15, 0x73, 0xf8, 0xa1, 0x36, 0xbd, 0x4a, 0x56, 0xa5, + 0x9a, 0x71, 0x9a, 0x41, 0x7a, 0xfb, 0x5b, 0x79, 0x44, 0xdb, 0xdf, 0x4f, 0xe9, 0xed, 0x2f, 0x8f, + 0x4a, 0xfb, 0x60, 0xc1, 0xe9, 0xef, 0x83, 0xec, 0x7f, 0x0f, 0xb2, 0xa3, 0x7d, 0x2f, 0x54, 0x65, + 0xc4, 0xee, 0x40, 0x91, 0xae, 0x26, 0x9d, 0x3e, 0x9a, 0xfd, 0x41, 0x09, 0x72, 0x9c, 0x36, 0x54, + 0xd2, 0x6a, 0x6b, 0x3f, 0x25, 0x69, 0xf7, 0x67, 0xf1, 0xa3, 0x7b, 0x3c, 0x5a, 0x99, 0xdb, 0x78, + 0xef, 0x2f, 0xda, 0xe9, 0xa4, 0x03, 0x98, 0x95, 0xfe, 0x53, 0x41, 0xcc, 0x17, 0x01, 0xf4, 0x86, + 0x51, 0x58, 0xfa, 0x2a, 0xfc, 0x48, 0xef, 0x2b, 0xb1, 0x81, 0x85, 0x5e, 0x80, 0x51, 0x2f, 0x88, + 0x13, 0xc7, 0xf7, 0xaf, 0x7a, 0x41, 0x22, 0xac, 0x7f, 0x65, 0xcc, 0x2e, 0x68, 0x10, 0x36, 0xf1, + 0xce, 0xbc, 0xdb, 0xf8, 0x2e, 0xfb, 0xf9, 0x9e, 0x9b, 0x70, 0xfa, 0x8a, 0x97, 0x28, 0xd1, 0xa6, + 0xe6, 0x11, 0xdb, 0xe4, 0x49, 0x0d, 0x64, 0xf5, 0xd5, 0x40, 0x46, 0x1a, 0x6a, 0x29, 0x9d, 0x35, + 0x9b, 0x4d, 0x43, 0xb5, 0x5d, 0x38, 0x79, 0xc5, 0x4b, 0x2e, 0x7b, 0x3e, 0x39, 0x44, 0x26, 0xbf, + 0x38, 0x0c, 0x63, 0x66, 0x59, 0x8c, 0xfd, 0xe8, 0xeb, 0x2f, 0xd2, 0xdd, 0x89, 0x18, 0x08, 0x4f, + 0x85, 0x54, 0xdc, 0x3e, 0x70, 0x8d, 0x8e, 0xfc, 0xc1, 0x35, 0x36, 0x28, 0x9a, 0x27, 0x36, 0x3b, + 0x80, 0xee, 0x42, 0x65, 0x9d, 0x65, 0x54, 0x96, 0x8b, 0x08, 0x86, 0xcb, 0x1b, 0x7c, 0xbd, 0x22, + 0x79, 0x4e, 0x26, 0xe7, 0x47, 0x8d, 0xca, 0x28, 0x9d, 0xc8, 0x6f, 0xe4, 0xb9, 0x08, 0x6b, 0x45, + 0x61, 0xf4, 0xd3, 0x0a, 0x95, 0x87, 0xd0, 0x0a, 0x29, 0x19, 0x3d, 0xfc, 0x88, 0x64, 0x34, 0xcb, + 0x8e, 0x4d, 0x36, 0xd9, 0x96, 0x47, 0x24, 0xe6, 0x8d, 0xb0, 0x41, 0x30, 0xb2, 0x63, 0x53, 0x60, + 0x9c, 0xc5, 0x47, 0x1f, 0x57, 0x52, 0xbe, 0x5a, 0xc4, 0x91, 0x95, 0x39, 0xa3, 0x0f, 0x5b, 0xc0, + 0x7f, 0xa1, 0x04, 0x13, 0x57, 0x82, 0xce, 0xca, 0x95, 0x95, 0xce, 0x9a, 0xef, 0xb9, 0xd7, 0x49, + 0x97, 0x4a, 0xf1, 0x2d, 0xd2, 0x5d, 0x98, 0xcf, 0xfa, 0x7a, 0xae, 0xd3, 0x46, 0xcc, 0x61, 0x54, + 0x6e, 0xad, 0x7b, 0xc1, 0x06, 0x89, 0xda, 0x91, 0x27, 0x4e, 0x93, 0x0c, 0xb9, 0x75, 0x59, 0x83, + 0xb0, 0x89, 0x47, 0x69, 0x87, 0x77, 0x03, 0x55, 0xa3, 0x4c, 0xd1, 0x5e, 0xa6, 0x8d, 0x98, 0xc3, + 0x28, 0x52, 0x12, 0x75, 0x84, 0xb3, 0xd6, 0x40, 0x5a, 0xa5, 0x8d, 0x98, 0xc3, 0x84, 0xef, 0x85, + 0xc5, 0x1a, 0x56, 0x7a, 0x7c, 0x2f, 0x2c, 0x4c, 0x47, 0xc2, 0x29, 0xea, 0x16, 0xe9, 0xce, 0x3b, + 0x89, 0x93, 0x75, 0x9d, 0x5c, 0xe7, 0xcd, 0x58, 0xc2, 0x59, 0xa1, 0xf5, 0xf4, 0x70, 0x7c, 0xc3, + 0x15, 0x5a, 0x4f, 0x77, 0xbf, 0x8f, 0xcb, 0xef, 0x2b, 0x25, 0x18, 0x7b, 0xe3, 0x32, 0xe6, 0x5d, + 0x2e, 0x03, 0xbb, 0x0d, 0x93, 0x3d, 0xb9, 0xf9, 0x03, 0x58, 0x40, 0x7b, 0xd6, 0x4e, 0xb1, 0x31, + 0x8c, 0x52, 0xc2, 0xb2, 0xd0, 0xe8, 0x1c, 0x4c, 0xf2, 0x45, 0x4c, 0x39, 0xb1, 0x54, 0x6b, 0x55, + 0x6f, 0x81, 0x1d, 0x9b, 0xde, 0xca, 0x02, 0x71, 0x2f, 0xbe, 0xfd, 0x83, 0x16, 0x8c, 0xa7, 0xca, + 0x25, 0x14, 0x64, 0xab, 0xb1, 0x55, 0x1e, 0xb2, 0x78, 0x79, 0x96, 0xbf, 0x54, 0x66, 0xea, 0x58, + 0xaf, 0x72, 0x0d, 0xc2, 0x26, 0x9e, 0xfd, 0xeb, 0x65, 0xa8, 0xca, 0xd8, 0xbe, 0x01, 0xba, 0xf2, + 0x79, 0x0b, 0xc6, 0xd5, 0x51, 0x35, 0x3b, 0x5b, 0x28, 0x15, 0x91, 0xbd, 0x49, 0x7b, 0xa0, 0xbc, + 0x63, 0xc1, 0x7a, 0xa8, 0x37, 0x0e, 0xd8, 0x64, 0x86, 0xd3, 0xbc, 0xd1, 0x2d, 0x80, 0xb8, 0x1b, + 0x27, 0xa4, 0x65, 0x9c, 0x72, 0xd8, 0xc6, 0x2c, 0x9b, 0x71, 0xc3, 0x88, 0xd0, 0x39, 0x75, 0x23, + 0x6c, 0x92, 0x86, 0xc2, 0xd4, 0x96, 0x9e, 0x6e, 0xc3, 0x06, 0x25, 0xf4, 0xaa, 0x0a, 0xac, 0x18, + 0x2a, 0x42, 0xbf, 0xcb, 0xf1, 0x1d, 0x24, 0xb2, 0xe2, 0x00, 0x91, 0x0c, 0xf6, 0x4f, 0x95, 0xe0, + 0x78, 0x76, 0x24, 0xd1, 0x07, 0x61, 0x4c, 0x0e, 0x9a, 0xe1, 0x44, 0x92, 0x01, 0x95, 0x63, 0xd8, + 0x80, 0x3d, 0xd8, 0x99, 0x9e, 0xee, 0xbd, 0xdd, 0x7f, 0xc6, 0x44, 0xc1, 0x29, 0x62, 0x3c, 0xcc, + 0x41, 0xc4, 0xe3, 0xd4, 0xbb, 0xb3, 0xed, 0xb6, 0x88, 0x55, 0x30, 0xc2, 0x1c, 0x4c, 0x28, 0xce, + 0x60, 0xa3, 0x15, 0x38, 0x69, 0xb4, 0xdc, 0x20, 0xde, 0xc6, 0xe6, 0x5a, 0x18, 0xc9, 0x7d, 0xeb, + 0x59, 0x1d, 0xbe, 0xdd, 0x8b, 0x83, 0x73, 0x9f, 0xa4, 0x06, 0x92, 0xeb, 0xb4, 0x1d, 0xd7, 0x4b, + 0xba, 0xe2, 0xb4, 0x49, 0x89, 0xf3, 0x39, 0xd1, 0x8e, 0x15, 0x86, 0xfd, 0xf7, 0x86, 0xe0, 0x38, + 0x8f, 0x57, 0x26, 0x2a, 0x1c, 0x1f, 0x7d, 0x10, 0x6a, 0x71, 0xe2, 0x44, 0xdc, 0x65, 0x65, 0xed, + 0x5b, 0x74, 0xe9, 0x1a, 0x0f, 0x92, 0x08, 0xd6, 0xf4, 0xd0, 0x07, 0x58, 0x65, 0x40, 0x2f, 0xde, + 0x64, 0xd4, 0x4b, 0x0f, 0xe7, 0x10, 0xbb, 0xac, 0x28, 0x60, 0x83, 0x1a, 0xfa, 0x76, 0xa8, 0xb4, + 0x37, 0x9d, 0x58, 0x7a, 0x6b, 0x9f, 0x95, 0x72, 0x62, 0x85, 0x36, 0x3e, 0xd8, 0x99, 0x3e, 0x95, + 0x7d, 0x55, 0x06, 0xc0, 0xfc, 0x21, 0x53, 0xca, 0x0f, 0xed, 0x21, 0xe5, 0x9f, 0x85, 0xe1, 0x66, + 0xd4, 0x6d, 0x5c, 0x9d, 0xcd, 0x5e, 0xf0, 0x34, 0xcf, 0x5a, 0xb1, 0x80, 0x52, 0x99, 0xb4, 0xc9, + 0x59, 0x36, 0x29, 0xf2, 0x70, 0xda, 0xf2, 0xb8, 0xaa, 0x41, 0xd8, 0xc4, 0x63, 0x55, 0xba, 0x32, + 0xd1, 0xec, 0x23, 0x87, 0x90, 0xed, 0x34, 0x68, 0x1c, 0xfb, 0x25, 0xa8, 0x89, 0xae, 0xae, 0x86, + 0xe8, 0x45, 0x18, 0xe3, 0xce, 0xc0, 0x7a, 0xe4, 0x04, 0xee, 0x66, 0xd6, 0x89, 0xb3, 0x6a, 0xc0, + 0x70, 0x0a, 0xd3, 0x5e, 0x82, 0xa1, 0x01, 0x85, 0xec, 0x40, 0x7b, 0xf3, 0xf7, 0x42, 0x95, 0x92, + 0x93, 0x1b, 0xb5, 0x22, 0x48, 0x86, 0x50, 0x95, 0x37, 0xc3, 0x22, 0x1b, 0xca, 0x9e, 0x23, 0xa3, + 0x96, 0xd4, 0x12, 0x5a, 0x88, 0xe3, 0x0e, 0x9b, 0x76, 0x14, 0x88, 0x9e, 0x81, 0x32, 0xb9, 0xd7, + 0xce, 0x86, 0x27, 0x5d, 0xba, 0xd7, 0xf6, 0x22, 0x12, 0x53, 0x24, 0x72, 0xaf, 0x8d, 0xce, 0x40, + 0xc9, 0x6b, 0x8a, 0x19, 0x09, 0x02, 0xa7, 0xb4, 0x30, 0x8f, 0x4b, 0x5e, 0xd3, 0xbe, 0x07, 0x35, + 0x75, 0x15, 0x2d, 0xda, 0x92, 0xa6, 0x95, 0x55, 0x44, 0xbc, 0xba, 0xa4, 0xdb, 0xc7, 0xa8, 0xea, + 0x00, 0xe8, 0xe2, 0x21, 0x45, 0xa9, 0xe0, 0xf3, 0x30, 0xe4, 0x86, 0xa2, 0xec, 0x53, 0x55, 0x93, + 0x61, 0xb6, 0x14, 0x83, 0xd8, 0xb7, 0x61, 0xe2, 0x7a, 0x10, 0xde, 0x65, 0x97, 0xc2, 0xb1, 0x1a, + 0xe8, 0x94, 0xf0, 0x3a, 0xfd, 0x91, 0xb5, 0xe0, 0x19, 0x14, 0x73, 0x98, 0xaa, 0x74, 0x5c, 0xea, + 0x57, 0xe9, 0xd8, 0xfe, 0x84, 0x05, 0x63, 0xca, 0x1b, 0x7b, 0x65, 0x7b, 0x6b, 0xb0, 0x53, 0x60, + 0xa3, 0x3c, 0x47, 0x69, 0x8f, 0xf2, 0x1c, 0xf2, 0xc0, 0xb8, 0xdc, 0xef, 0xc0, 0xd8, 0xfe, 0x73, + 0x0b, 0x8e, 0xab, 0x2e, 0x48, 0x9b, 0xe9, 0x45, 0x18, 0x5b, 0xeb, 0x78, 0x7e, 0x53, 0x16, 0x77, + 0xcf, 0x2c, 0x97, 0xba, 0x01, 0xc3, 0x29, 0x4c, 0x74, 0x11, 0x60, 0xcd, 0x0b, 0x9c, 0xa8, 0xbb, + 0xa2, 0x8d, 0x34, 0xa5, 0xb7, 0xeb, 0x0a, 0x82, 0x0d, 0x2c, 0xf4, 0x31, 0xa8, 0x6e, 0xcb, 0x38, + 0x81, 0x72, 0xa1, 0x55, 0x25, 0xc4, 0x78, 0xe8, 0x95, 0xa0, 0x02, 0x0f, 0x14, 0x47, 0xfb, 0x4b, + 0x65, 0x98, 0x48, 0x57, 0x82, 0x18, 0xc0, 0x83, 0xf2, 0x0c, 0x54, 0x58, 0x71, 0x88, 0xec, 0xc4, + 0xe2, 0xd5, 0xd8, 0x39, 0x0c, 0xc5, 0x30, 0xcc, 0x45, 0x49, 0x31, 0xf7, 0x16, 0xab, 0x4e, 0x2a, + 0x3f, 0x2d, 0x73, 0x62, 0x8b, 0x43, 0x0f, 0xc1, 0x0a, 0x7d, 0xda, 0x82, 0x91, 0xb0, 0x6d, 0x96, + 0xd8, 0x7d, 0x7f, 0x91, 0x55, 0x32, 0x44, 0x2a, 0xba, 0xb0, 0x86, 0xd4, 0xc4, 0x93, 0x93, 0x41, + 0xb2, 0x3e, 0xf3, 0x6d, 0x30, 0x66, 0x62, 0xee, 0x65, 0x10, 0x55, 0x4d, 0x83, 0xe8, 0xf3, 0xe6, + 0x94, 0x14, 0x75, 0x40, 0x06, 0x58, 0xec, 0x37, 0xa1, 0xe2, 0xaa, 0xc0, 0xcb, 0x87, 0xba, 0x90, + 0x44, 0xd5, 0xc9, 0x63, 0x41, 0x2d, 0x9c, 0x9a, 0xfd, 0x7b, 0x96, 0x31, 0x3f, 0x30, 0x89, 0x17, + 0x9a, 0x28, 0x82, 0xf2, 0xc6, 0xf6, 0x96, 0x30, 0x32, 0xae, 0x15, 0x34, 0xbc, 0x57, 0xb6, 0xb7, + 0xf4, 0x0a, 0x33, 0x5b, 0x31, 0x65, 0x36, 0xc0, 0x61, 0x42, 0xaa, 0x5c, 0x4c, 0x79, 0xef, 0x72, + 0x31, 0xf6, 0xeb, 0x25, 0x98, 0xec, 0x99, 0x54, 0xe8, 0x55, 0xa8, 0x44, 0xf4, 0x2d, 0xc5, 0xeb, + 0x2d, 0x16, 0x56, 0xe0, 0x25, 0x5e, 0x68, 0x6a, 0xe5, 0x9d, 0x6e, 0xc7, 0x9c, 0x25, 0xba, 0x06, + 0x48, 0x87, 0x07, 0xab, 0x93, 0x0c, 0xfe, 0xca, 0x2a, 0x86, 0x70, 0xb6, 0x07, 0x03, 0xe7, 0x3c, + 0x85, 0x5e, 0xca, 0x1e, 0x88, 0x64, 0x8a, 0xb6, 0xef, 0x76, 0xb6, 0x61, 0xbf, 0x66, 0x4e, 0xc1, + 0x5b, 0x5a, 0x98, 0x1e, 0x74, 0x73, 0xda, 0x23, 0x59, 0xcb, 0x83, 0x4a, 0x56, 0xfb, 0xe7, 0x4b, + 0x30, 0x9e, 0x2a, 0xc2, 0x8c, 0x7c, 0xa8, 0x12, 0x9f, 0x9d, 0xdb, 0x4b, 0xed, 0x7b, 0xd0, 0x3b, + 0xa4, 0x94, 0x9c, 0xbc, 0x24, 0xe8, 0x62, 0xc5, 0xe1, 0xf1, 0x88, 0x76, 0x7c, 0x11, 0xc6, 0x64, + 0x87, 0xde, 0xef, 0xb4, 0xfc, 0xec, 0xf0, 0x5d, 0x32, 0x60, 0x38, 0x85, 0x69, 0xff, 0x72, 0x19, + 0xa6, 0x78, 0xa0, 0x43, 0x53, 0x2d, 0x06, 0x15, 0xb0, 0xf4, 0x03, 0xba, 0x54, 0x3a, 0x1f, 0xc8, + 0xb5, 0x83, 0x5e, 0xd9, 0x98, 0xcf, 0x68, 0xa0, 0x20, 0xfd, 0xaf, 0x64, 0x82, 0xf4, 0xf9, 0x56, + 0x7d, 0xe3, 0x90, 0x7a, 0xf4, 0x8d, 0x15, 0xb5, 0xff, 0x8f, 0x4a, 0x70, 0x2c, 0x73, 0x1f, 0x26, + 0xfa, 0x52, 0xfa, 0x0a, 0x25, 0xab, 0x88, 0x63, 0xc0, 0x5d, 0xaf, 0x48, 0xdc, 0xdf, 0x45, 0x4a, + 0x8f, 0x68, 0xa9, 0xd8, 0xbf, 0x53, 0x82, 0x89, 0xf4, 0x45, 0x9e, 0x8f, 0xe1, 0x48, 0xbd, 0x0d, + 0x6a, 0xec, 0xae, 0xba, 0xeb, 0xa4, 0x2b, 0x4f, 0x1b, 0xf9, 0xb5, 0x60, 0xb2, 0x11, 0x6b, 0xf8, + 0x63, 0x71, 0x3f, 0x95, 0xfd, 0x8f, 0x2d, 0x38, 0xc5, 0xdf, 0x32, 0x3b, 0x0f, 0xff, 0x7a, 0xde, + 0xe8, 0xbe, 0x5c, 0x6c, 0x07, 0x33, 0x25, 0xfe, 0xf7, 0x1a, 0x5f, 0x6a, 0xbc, 0x9c, 0x14, 0xbd, + 0x4d, 0x4f, 0x85, 0xc7, 0xb0, 0xb3, 0xfb, 0x9a, 0x0c, 0xf6, 0xbf, 0x2f, 0xc1, 0xe8, 0xf2, 0xdc, + 0x82, 0x12, 0xe1, 0x17, 0xa0, 0xe6, 0x46, 0xc4, 0xd1, 0xee, 0x1f, 0x33, 0x8c, 0x4e, 0x02, 0xb0, + 0xc6, 0xa1, 0xbb, 0x28, 0x1e, 0x86, 0x1a, 0x67, 0x77, 0x51, 0x3c, 0x4a, 0x35, 0xc6, 0x12, 0x8e, + 0x9e, 0x87, 0x2a, 0x4b, 0x56, 0xbf, 0x19, 0x49, 0x8d, 0xa3, 0xb7, 0xd6, 0xac, 0x1d, 0x2f, 0x62, + 0x85, 0x41, 0x09, 0x37, 0x43, 0x37, 0xa6, 0xc8, 0x19, 0x8f, 0xcc, 0x3c, 0x6d, 0xc6, 0x8b, 0x58, + 0xc2, 0x59, 0xad, 0x51, 0xe6, 0xb5, 0xa0, 0xc8, 0x95, 0x74, 0xa7, 0xb9, 0x7b, 0x83, 0xa2, 0x6b, + 0x9c, 0xfd, 0xd4, 0xa4, 0xcd, 0x24, 0x8c, 0x8e, 0x0c, 0x96, 0x30, 0x6a, 0xff, 0x4e, 0x19, 0x6a, + 0xda, 0xa9, 0xe6, 0x89, 0x0a, 0x2d, 0x85, 0x5c, 0x21, 0xd1, 0xe8, 0x06, 0xae, 0x22, 0xcd, 0xa3, + 0x0a, 0x8c, 0x02, 0x2d, 0xdf, 0x6f, 0xc1, 0xa8, 0x17, 0x78, 0x89, 0xe7, 0x30, 0xdf, 0xa0, 0x90, + 0x9b, 0x2b, 0x05, 0x55, 0xf0, 0x58, 0xe0, 0x94, 0xc3, 0xc8, 0x3c, 0xfa, 0x57, 0xcc, 0xb0, 0xc9, + 0x19, 0x7d, 0x54, 0xe4, 0x27, 0x96, 0x0b, 0x2b, 0x73, 0x54, 0xcd, 0x24, 0x25, 0xb6, 0xa9, 0x8d, + 0x9d, 0x44, 0x05, 0x55, 0x07, 0xc3, 0x94, 0x94, 0xba, 0xca, 0x48, 0xed, 0x62, 0x58, 0x33, 0xe6, + 0x8c, 0xec, 0x18, 0x50, 0xef, 0x58, 0xec, 0x33, 0xf7, 0xeb, 0x02, 0xd4, 0x9c, 0x4e, 0x12, 0xb6, + 0xe8, 0x30, 0x89, 0xc0, 0x01, 0x9d, 0xdd, 0x26, 0x01, 0x58, 0xe3, 0xd8, 0x3f, 0x52, 0x81, 0x4c, + 0xbd, 0x14, 0x74, 0x0f, 0x6a, 0xaa, 0x62, 0x4a, 0x31, 0xb9, 0xd4, 0x7a, 0x46, 0xa9, 0xce, 0xa8, + 0x26, 0xac, 0x99, 0xa1, 0x50, 0xba, 0x59, 0xf9, 0x6a, 0x7f, 0x7f, 0xd6, 0xcd, 0x7a, 0x75, 0x7f, + 0xa7, 0x6f, 0x74, 0xce, 0x5e, 0xe0, 0x95, 0x32, 0x67, 0xf6, 0xf4, 0xcc, 0x96, 0xf7, 0xf0, 0xcc, + 0x7e, 0x52, 0x5c, 0x7a, 0x88, 0x49, 0xdc, 0xf1, 0x13, 0x31, 0x2b, 0xde, 0x5b, 0xe0, 0x6a, 0xe3, + 0x84, 0x75, 0xfd, 0x31, 0xfe, 0x1f, 0x1b, 0x4c, 0xd3, 0xfe, 0xf3, 0xe1, 0x43, 0xf5, 0x9f, 0x8f, + 0x14, 0xea, 0x3f, 0xbf, 0x08, 0xc0, 0xe6, 0x38, 0xcf, 0x55, 0xa9, 0x32, 0xb7, 0xa6, 0x52, 0x35, + 0x58, 0x41, 0xb0, 0x81, 0x65, 0x7f, 0x0b, 0xa4, 0x0b, 0xe8, 0xa1, 0x69, 0x59, 0xaf, 0x8f, 0x9f, + 0x0c, 0xb2, 0x34, 0xe1, 0x54, 0x69, 0xbd, 0x9f, 0xb5, 0xc0, 0xac, 0xf2, 0x87, 0x5e, 0xe1, 0xe5, + 0x04, 0xad, 0x22, 0x4e, 0x9a, 0x0c, 0xba, 0x33, 0x4b, 0x4e, 0x3b, 0x13, 0xfd, 0x24, 0x6b, 0x0a, + 0x9e, 0x79, 0x37, 0x54, 0x25, 0x74, 0x5f, 0x46, 0xf3, 0xc7, 0xe1, 0x84, 0x2c, 0x39, 0x22, 0x0f, + 0x85, 0x44, 0x14, 0xc2, 0xd1, 0x64, 0x9c, 0xfc, 0x9c, 0x05, 0xe7, 0xb3, 0x1d, 0x88, 0x97, 0xc2, + 0xc0, 0x4b, 0xc2, 0xa8, 0x41, 0x92, 0xc4, 0x0b, 0x36, 0x58, 0xd5, 0xe7, 0xbb, 0x4e, 0x24, 0xaf, + 0x3c, 0x63, 0x02, 0xf3, 0xb6, 0x13, 0x05, 0x98, 0xb5, 0xa2, 0x2e, 0x0c, 0xf3, 0x80, 0x7a, 0xb1, + 0x1b, 0x3a, 0xe0, 0xda, 0xc8, 0x19, 0x0e, 0xbd, 0x1d, 0xe3, 0xc1, 0xfc, 0x58, 0x30, 0xb4, 0xbf, + 0x66, 0x01, 0x5a, 0xde, 0x26, 0x51, 0xe4, 0x35, 0x8d, 0x14, 0x00, 0x76, 0x79, 0xb0, 0x71, 0x49, + 0xb0, 0x59, 0x10, 0x27, 0x73, 0x79, 0xb0, 0xf1, 0x2f, 0xff, 0xf2, 0xe0, 0xd2, 0xfe, 0x2e, 0x0f, + 0x46, 0xcb, 0x70, 0xaa, 0xc5, 0xb7, 0x73, 0xfc, 0x42, 0x4e, 0xbe, 0xb7, 0x53, 0xb5, 0x1b, 0x4e, + 0xdf, 0xdf, 0x99, 0x3e, 0xb5, 0x94, 0x87, 0x80, 0xf3, 0x9f, 0xb3, 0xdf, 0x0d, 0x88, 0x87, 0xc2, + 0xce, 0xe5, 0x85, 0xaf, 0xf6, 0x75, 0x77, 0xd8, 0x5f, 0xae, 0xc0, 0xb1, 0xcc, 0x85, 0x38, 0x74, + 0x2b, 0xdd, 0x1b, 0x2f, 0x7b, 0x60, 0x3d, 0xde, 0xdb, 0xbd, 0x81, 0x22, 0x70, 0x03, 0xa8, 0x78, + 0x41, 0xbb, 0x93, 0x14, 0x53, 0x3a, 0x86, 0x77, 0x62, 0x81, 0x12, 0x34, 0xce, 0x27, 0xe8, 0x5f, + 0xcc, 0xd9, 0x14, 0x19, 0xcf, 0x9b, 0xda, 0xec, 0x0c, 0x3d, 0x22, 0x77, 0xcb, 0x27, 0x75, 0x74, + 0x6d, 0xa5, 0x08, 0x5f, 0x72, 0x66, 0xb2, 0x1c, 0x76, 0xe8, 0xd5, 0x4f, 0x97, 0x60, 0xd4, 0xf8, + 0x68, 0xe8, 0xc7, 0xd2, 0x35, 0x70, 0xad, 0xe2, 0x5e, 0x89, 0xd1, 0x9f, 0xd1, 0x55, 0x6e, 0xf9, + 0x2b, 0x3d, 0xdb, 0x5b, 0xfe, 0xf6, 0xc1, 0xce, 0xf4, 0xf1, 0x4c, 0x81, 0xdb, 0x54, 0x49, 0xdc, + 0x33, 0xdf, 0x0d, 0xc7, 0x32, 0x64, 0x72, 0x5e, 0x79, 0xd5, 0x7c, 0xe5, 0x03, 0xbb, 0xfd, 0xcc, + 0x21, 0xfb, 0x49, 0x3a, 0x64, 0xa2, 0x62, 0x45, 0xe8, 0x93, 0x01, 0x7c, 0x9e, 0x99, 0x7d, 0x46, + 0x69, 0xc0, 0xc2, 0x34, 0xcf, 0x41, 0xb5, 0x1d, 0xfa, 0x9e, 0xeb, 0xa9, 0x12, 0xfa, 0xac, 0x14, + 0xce, 0x8a, 0x68, 0xc3, 0x0a, 0x8a, 0xee, 0x42, 0xed, 0xce, 0xdd, 0x84, 0x1f, 0x37, 0x8a, 0x23, + 0x8d, 0xa2, 0x4e, 0x19, 0x95, 0xd1, 0xa2, 0xce, 0x33, 0xb1, 0xe6, 0x85, 0x6c, 0x18, 0x66, 0x4a, + 0x50, 0x66, 0xaf, 0xb2, 0xe3, 0x16, 0xa6, 0x1d, 0x63, 0x2c, 0x20, 0xf6, 0xbf, 0x1d, 0x85, 0x93, + 0x79, 0xb7, 0x92, 0xa1, 0x8f, 0xc1, 0x30, 0xef, 0x63, 0x31, 0x17, 0x5f, 0xe6, 0xf1, 0xb8, 0xc2, + 0x08, 0x8a, 0x6e, 0xb1, 0xdf, 0x58, 0xf0, 0x14, 0xdc, 0x7d, 0x67, 0x4d, 0xcc, 0x90, 0xc3, 0xe1, + 0xbe, 0xe8, 0x68, 0xee, 0x8b, 0x0e, 0xe7, 0xee, 0x3b, 0x6b, 0xe8, 0x1e, 0x54, 0x36, 0xbc, 0x84, + 0x38, 0xc2, 0x49, 0x73, 0xfb, 0x50, 0x98, 0x13, 0x87, 0x5b, 0x69, 0xec, 0x27, 0xe6, 0x0c, 0xd1, + 0x57, 0x2d, 0x38, 0xb6, 0x96, 0xae, 0x88, 0x25, 0x84, 0xa7, 0x73, 0x08, 0x37, 0xcf, 0xa5, 0x19, + 0xf1, 0xdb, 0xb3, 0x33, 0x8d, 0x38, 0xdb, 0x1d, 0xf4, 0x29, 0x0b, 0x46, 0xd6, 0x3d, 0xdf, 0xb8, + 0xe1, 0xe6, 0x10, 0x3e, 0xce, 0x65, 0xc6, 0x40, 0xef, 0x38, 0xf8, 0xff, 0x18, 0x4b, 0xce, 0xfd, + 0x34, 0xd5, 0xf0, 0x41, 0x35, 0xd5, 0xc8, 0x23, 0xd2, 0x54, 0x9f, 0xb5, 0xa0, 0xa6, 0x46, 0x5a, + 0x54, 0x16, 0xfa, 0xe0, 0x21, 0x7e, 0x72, 0xee, 0x99, 0x52, 0x7f, 0xb1, 0x66, 0x8e, 0x5e, 0xb3, + 0x60, 0xd4, 0x79, 0xb5, 0x13, 0x91, 0x26, 0xd9, 0x0e, 0xdb, 0xb1, 0x28, 0xf9, 0xfb, 0x72, 0xf1, + 0x9d, 0x99, 0xa5, 0x4c, 0xe6, 0xc9, 0xf6, 0x72, 0x3b, 0x16, 0x99, 0xf5, 0xba, 0x01, 0x9b, 0x5d, + 0x40, 0xdf, 0xa7, 0xf5, 0x38, 0x14, 0x51, 0xf8, 0x3d, 0xaf, 0x37, 0x03, 0x15, 0x8a, 0x20, 0xf0, + 0x94, 0x1b, 0x06, 0x89, 0x17, 0x74, 0xc8, 0x72, 0x80, 0x49, 0x3b, 0xbc, 0x11, 0x26, 0x97, 0xc3, + 0x4e, 0xd0, 0xbc, 0x14, 0x45, 0x61, 0xc4, 0x4a, 0x27, 0x19, 0xf7, 0x1d, 0xcf, 0xf5, 0x47, 0xc5, + 0xbb, 0xd1, 0x39, 0x88, 0xcd, 0xb0, 0x53, 0x82, 0xe9, 0x3d, 0x06, 0x1b, 0xbd, 0x08, 0x63, 0x61, + 0xb4, 0xe1, 0x04, 0xde, 0xab, 0x66, 0x35, 0x40, 0x65, 0x90, 0x2e, 0x1b, 0x30, 0x9c, 0xc2, 0x34, + 0xcb, 0x44, 0x95, 0xf6, 0x28, 0x13, 0x75, 0x1e, 0x86, 0x22, 0xd2, 0x0e, 0xb3, 0xfb, 0x2a, 0x96, + 0x80, 0xca, 0x20, 0xe8, 0x69, 0x28, 0x3b, 0x6d, 0x4f, 0x38, 0x19, 0xd5, 0x76, 0x71, 0x76, 0x65, + 0x01, 0xd3, 0xf6, 0x54, 0xd5, 0xba, 0xca, 0x91, 0x54, 0xad, 0xa3, 0x1a, 0x53, 0x1c, 0xa3, 0x0d, + 0x6b, 0x8d, 0x99, 0x3e, 0xde, 0xb2, 0x5f, 0x2f, 0xc3, 0xd3, 0xbb, 0x2e, 0x2d, 0x1d, 0xc2, 0x6e, + 0xed, 0x12, 0xc2, 0x2e, 0x87, 0xa7, 0xb4, 0xd7, 0xf0, 0x94, 0xfb, 0x0c, 0xcf, 0xa7, 0xa8, 0xc4, + 0x90, 0x55, 0x14, 0x85, 0x92, 0x38, 0x60, 0x5a, 0x41, 0xbf, 0xa2, 0x8c, 0x42, 0x58, 0x48, 0x28, + 0xd6, 0x7c, 0xe9, 0x76, 0x29, 0x55, 0x22, 0xa9, 0x52, 0x84, 0xc6, 0xec, 0x5b, 0xc9, 0x90, 0x8b, + 0x89, 0x7e, 0x75, 0x97, 0xec, 0x5f, 0x18, 0x82, 0x67, 0x06, 0x50, 0x74, 0xe6, 0x2c, 0xb6, 0x06, + 0x9c, 0xc5, 0xdf, 0xe0, 0x9f, 0xe9, 0x33, 0xb9, 0x9f, 0x09, 0x17, 0xff, 0x99, 0x76, 0xff, 0x42, + 0xec, 0x24, 0x22, 0x88, 0x89, 0xdb, 0x89, 0x78, 0x3a, 0x8f, 0x91, 0x9d, 0xbe, 0x20, 0xda, 0xb1, + 0xc2, 0xa0, 0xdb, 0x5f, 0xd7, 0xa1, 0xcb, 0x7f, 0xa4, 0xa0, 0x92, 0x38, 0x66, 0xa2, 0x3b, 0xb7, + 0xbe, 0xe6, 0x66, 0xa9, 0x04, 0xe0, 0x6c, 0xec, 0x5f, 0xb1, 0xe0, 0x4c, 0x7f, 0x6b, 0x04, 0xbd, + 0x03, 0x46, 0xd7, 0x58, 0x50, 0xe5, 0x12, 0x0b, 0x9d, 0x12, 0x53, 0x87, 0xbd, 0xaf, 0x6e, 0xc6, + 0x26, 0x0e, 0x9a, 0x83, 0x49, 0x33, 0x1a, 0x73, 0xc9, 0x88, 0xb9, 0x62, 0xfe, 0x92, 0xd5, 0x2c, + 0x10, 0xf7, 0xe2, 0xa3, 0x19, 0x80, 0xc4, 0x4b, 0x7c, 0xc2, 0x9f, 0xe6, 0x13, 0x8d, 0x39, 0x14, + 0x57, 0x55, 0x2b, 0x36, 0x30, 0xec, 0xaf, 0x97, 0xf3, 0x5f, 0x83, 0x5b, 0xb9, 0xfb, 0x99, 0xfd, + 0x62, 0x6e, 0x97, 0x06, 0x90, 0xd0, 0xe5, 0xa3, 0x96, 0xd0, 0x43, 0xfd, 0x24, 0x34, 0x9a, 0x87, + 0xe3, 0xc6, 0x0d, 0xca, 0xbc, 0xa8, 0x12, 0x3f, 0x9c, 0x52, 0x15, 0x11, 0x57, 0x32, 0x70, 0xdc, + 0xf3, 0xc4, 0x63, 0x3e, 0x55, 0x7f, 0xb5, 0x04, 0xa7, 0xfb, 0x6e, 0x2c, 0x8e, 0x48, 0x03, 0x99, + 0x9f, 0x7f, 0xe8, 0x68, 0x3e, 0xbf, 0xf9, 0x51, 0x2a, 0x7b, 0x7e, 0x94, 0x41, 0xd4, 0xf9, 0xef, + 0x96, 0xfa, 0x2e, 0x16, 0xba, 0x11, 0xfd, 0x0b, 0x3b, 0x92, 0x2f, 0xc1, 0xb8, 0xd3, 0x6e, 0x73, + 0x3c, 0x96, 0xa1, 0x91, 0xa9, 0xd2, 0x3a, 0x6b, 0x02, 0x71, 0x1a, 0x77, 0xa0, 0x81, 0xfd, 0x4f, + 0x16, 0xd4, 0x30, 0x59, 0xe7, 0x12, 0x0e, 0xdd, 0x11, 0x43, 0x64, 0x15, 0x71, 0x55, 0x06, 0x1d, + 0xd8, 0xd8, 0x63, 0x85, 0x18, 0xf2, 0x06, 0xfb, 0xa0, 0x75, 0x36, 0xd4, 0xf5, 0xc3, 0xe5, 0xfe, + 0xd7, 0x0f, 0xdb, 0x7f, 0x36, 0x46, 0x5f, 0xaf, 0x1d, 0xce, 0x45, 0xa4, 0x19, 0xd3, 0xef, 0xdb, + 0x89, 0x7c, 0x31, 0x49, 0xd4, 0xf7, 0xbd, 0x89, 0x17, 0x31, 0x6d, 0x4f, 0x9d, 0x53, 0x96, 0xf6, + 0x55, 0xa3, 0xb2, 0xbc, 0x67, 0x8d, 0xca, 0x97, 0x60, 0x3c, 0x8e, 0x37, 0x57, 0x22, 0x6f, 0xdb, + 0x49, 0xc8, 0x75, 0x22, 0x0b, 0x48, 0xe9, 0x7a, 0x6d, 0x8d, 0xab, 0x1a, 0x88, 0xd3, 0xb8, 0xe8, + 0x0a, 0x4c, 0xea, 0x4a, 0x91, 0x24, 0x4a, 0x58, 0x0a, 0x24, 0x9f, 0x09, 0xaa, 0x38, 0x90, 0xae, + 0x2d, 0x29, 0x10, 0x70, 0xef, 0x33, 0x54, 0xe6, 0xa6, 0x1a, 0x69, 0x47, 0x86, 0xd3, 0x32, 0x37, + 0x45, 0x87, 0xf6, 0xa5, 0xe7, 0x09, 0xb4, 0x04, 0x27, 0xf8, 0xc4, 0x98, 0x6d, 0xb7, 0x8d, 0x37, + 0x1a, 0x49, 0xdf, 0x4f, 0x70, 0xa5, 0x17, 0x05, 0xe7, 0x3d, 0x87, 0x5e, 0x80, 0x51, 0xd5, 0xbc, + 0x30, 0x2f, 0x8e, 0xd6, 0x94, 0x6b, 0x4f, 0x91, 0x59, 0x68, 0x62, 0x13, 0x0f, 0xbd, 0x1f, 0x9e, + 0xd4, 0x7f, 0x79, 0x4a, 0x3d, 0x3f, 0x77, 0x9e, 0x17, 0x45, 0x78, 0xd5, 0xf5, 0x77, 0x57, 0x72, + 0xd1, 0x9a, 0xb8, 0xdf, 0xf3, 0x68, 0x0d, 0xce, 0x28, 0xd0, 0xa5, 0x20, 0x61, 0x49, 0xaf, 0x31, + 0xa9, 0x3b, 0x31, 0x8b, 0xa0, 0x00, 0xf6, 0x9e, 0xb6, 0xa0, 0x7e, 0xe6, 0x8a, 0x97, 0x5c, 0xcd, + 0xc3, 0xc4, 0x8b, 0x78, 0x17, 0x2a, 0xe8, 0x02, 0xd4, 0x48, 0xe0, 0xac, 0xf9, 0x64, 0x79, 0x6e, + 0x41, 0xec, 0x48, 0x75, 0x96, 0x84, 0x04, 0x60, 0x8d, 0xa3, 0xe2, 0xfc, 0xc7, 0xfa, 0xc5, 0xf9, + 0xa3, 0x15, 0x38, 0xb9, 0xe1, 0xb6, 0xa9, 0x95, 0xe9, 0xb9, 0x64, 0xd6, 0x65, 0x81, 0xc5, 0xf4, + 0xc3, 0xf0, 0x8b, 0x23, 0x54, 0xc2, 0xd4, 0x95, 0xb9, 0x95, 0x1e, 0x1c, 0x9c, 0xfb, 0x24, 0x0b, + 0x40, 0x8f, 0xc2, 0x7b, 0xdd, 0xa9, 0x13, 0x99, 0x00, 0x74, 0xda, 0x88, 0x39, 0x0c, 0x5d, 0x03, + 0xc4, 0x92, 0x06, 0xaf, 0x26, 0x49, 0x5b, 0x99, 0xb5, 0x53, 0x27, 0xd3, 0x25, 0x39, 0x2f, 0xf7, + 0x60, 0xe0, 0x9c, 0xa7, 0xa8, 0xd5, 0x13, 0x84, 0x8c, 0xfa, 0xd4, 0x93, 0x69, 0xab, 0xe7, 0x06, + 0x6f, 0xc6, 0x12, 0x8e, 0x3e, 0x04, 0x53, 0x9d, 0x98, 0xb0, 0x0d, 0xf3, 0xed, 0x30, 0xda, 0xf2, + 0x43, 0xa7, 0xb9, 0xc0, 0xee, 0x39, 0x4e, 0xba, 0x53, 0x53, 0x8c, 0xf9, 0x79, 0xf1, 0xec, 0xd4, + 0xcd, 0x3e, 0x78, 0xb8, 0x2f, 0x85, 0x6c, 0x4d, 0xd9, 0xd3, 0x03, 0xd6, 0x94, 0x5d, 0x81, 0x93, + 0x52, 0xaf, 0x2d, 0xcf, 0x2d, 0xa8, 0x97, 0x9e, 0x3a, 0x93, 0xbe, 0x38, 0x71, 0x21, 0x07, 0x07, + 0xe7, 0x3e, 0x89, 0xb6, 0xe0, 0x69, 0xe6, 0x63, 0x11, 0x1f, 0x67, 0x25, 0xf2, 0x02, 0xd7, 0x6b, + 0x3b, 0x3e, 0x5f, 0x92, 0x0b, 0xcd, 0xa9, 0xa7, 0x59, 0xd7, 0xde, 0x22, 0x48, 0x3f, 0x3d, 0xbb, + 0x1b, 0x32, 0xde, 0x9d, 0x16, 0xba, 0x0b, 0x6f, 0xde, 0x05, 0x81, 0xab, 0x96, 0xa9, 0x73, 0x8c, + 0xe1, 0x37, 0x0b, 0x86, 0x6f, 0x9e, 0xdd, 0xeb, 0x01, 0xbc, 0x37, 0xcd, 0xbe, 0x6f, 0xb9, 0x4a, + 0x02, 0x87, 0xbd, 0xe5, 0xf4, 0x00, 0x6f, 0x29, 0x91, 0xf1, 0xee, 0xb4, 0xd0, 0x26, 0x9c, 0x65, + 0x08, 0xb3, 0x6e, 0xe2, 0x6d, 0xeb, 0x72, 0x41, 0x97, 0x82, 0x66, 0x3b, 0xf4, 0x82, 0x64, 0xea, + 0x3c, 0xe3, 0xf5, 0x4d, 0x82, 0xd7, 0xd9, 0xd9, 0x5d, 0x70, 0xf1, 0xae, 0x94, 0xec, 0x3f, 0xb0, + 0x60, 0x5c, 0xa9, 0x9f, 0x23, 0xc8, 0x40, 0xf7, 0xd3, 0x19, 0xe8, 0x57, 0x0e, 0xae, 0xc0, 0x59, + 0xcf, 0xfb, 0xe4, 0x49, 0xfd, 0xf7, 0x49, 0x00, 0xad, 0xe4, 0x95, 0x7d, 0x65, 0xf5, 0xb5, 0xaf, + 0x1e, 0x5b, 0x05, 0x9b, 0x57, 0xe0, 0xb5, 0xf2, 0x68, 0x0b, 0xbc, 0x36, 0xe0, 0x94, 0x94, 0x07, + 0x3c, 0x1e, 0xe0, 0x6a, 0x18, 0x2b, 0x7d, 0x6d, 0x5c, 0x63, 0xba, 0x90, 0x87, 0x84, 0xf3, 0x9f, + 0x4d, 0x19, 0xe6, 0x23, 0x7b, 0x1a, 0xe6, 0x4a, 0x45, 0x2d, 0xae, 0xcb, 0x4b, 0x86, 0x33, 0x2a, + 0x6a, 0xf1, 0x72, 0x03, 0x6b, 0x9c, 0x7c, 0x3b, 0xa5, 0x56, 0x90, 0x9d, 0x02, 0xfb, 0xb6, 0x53, + 0xa4, 0xc6, 0x1c, 0xed, 0xab, 0x31, 0xe5, 0xb9, 0xe3, 0x58, 0xdf, 0x73, 0xc7, 0xf7, 0xc0, 0x84, + 0x17, 0x6c, 0x92, 0xc8, 0x4b, 0x48, 0x93, 0xad, 0x05, 0xa6, 0x4d, 0xab, 0xda, 0x4a, 0x5d, 0x48, + 0x41, 0x71, 0x06, 0x3b, 0xad, 0xe6, 0x27, 0x06, 0x50, 0xf3, 0x7d, 0x8c, 0xab, 0x63, 0xc5, 0x18, + 0x57, 0xc7, 0x0f, 0x6e, 0x5c, 0x4d, 0x1e, 0xaa, 0x71, 0x85, 0x0a, 0x31, 0xae, 0x06, 0xb2, 0x5b, + 0x0c, 0x0f, 0xcb, 0xc9, 0x3d, 0x3c, 0x2c, 0xfd, 0x2c, 0xab, 0x53, 0x0f, 0x6d, 0x59, 0xe5, 0x1b, + 0x4d, 0x4f, 0xbc, 0x61, 0x34, 0x15, 0x62, 0x34, 0x3d, 0x03, 0x95, 0x26, 0x69, 0x27, 0x9b, 0x53, + 0x4f, 0xb1, 0xc9, 0xaa, 0xbe, 0xff, 0x3c, 0x6d, 0xc4, 0x1c, 0x86, 0x12, 0x38, 0x7f, 0x97, 0xac, + 0x6d, 0x86, 0xe1, 0xd6, 0x92, 0x13, 0x78, 0xeb, 0x44, 0x5c, 0x62, 0x70, 0xdb, 0x89, 0x5a, 0xa2, + 0x80, 0x7c, 0x73, 0xea, 0x2c, 0xeb, 0xc2, 0x73, 0xe2, 0xf9, 0xf3, 0xb7, 0xf7, 0xc0, 0xc7, 0x7b, + 0x52, 0x7c, 0xc3, 0x9e, 0xfb, 0x46, 0xb6, 0xe7, 0x3e, 0x5b, 0x82, 0x53, 0xda, 0xe2, 0xa1, 0x7a, + 0xc6, 0x5b, 0xa7, 0x3a, 0x9f, 0xa0, 0x8b, 0x00, 0x3c, 0x0a, 0xc6, 0xa8, 0xa3, 0xa1, 0x2b, 0x89, + 0x28, 0x08, 0x36, 0xb0, 0x58, 0x39, 0x0a, 0x12, 0xb1, 0xbb, 0xc8, 0xb2, 0xe6, 0xd0, 0x9c, 0x68, + 0xc7, 0x0a, 0x83, 0x2e, 0x2e, 0xfa, 0x5b, 0x54, 0x45, 0xca, 0xde, 0x72, 0x31, 0xa7, 0x41, 0xd8, + 0xc4, 0x43, 0xcf, 0x71, 0x26, 0x4c, 0x15, 0x53, 0x93, 0x68, 0x8c, 0xfb, 0x9a, 0x94, 0xf6, 0x55, + 0x50, 0xd9, 0x1d, 0x56, 0x2e, 0xa5, 0xd2, 0xdb, 0x1d, 0x16, 0x58, 0xae, 0x30, 0xec, 0xff, 0x69, + 0xc1, 0xe9, 0xdc, 0xa1, 0x38, 0x02, 0x33, 0xf7, 0x5e, 0xda, 0xcc, 0x6d, 0x14, 0xe5, 0xa7, 0x32, + 0xde, 0xa2, 0x8f, 0xc9, 0xfb, 0x1f, 0x2c, 0x98, 0xd0, 0xf8, 0x47, 0xf0, 0xaa, 0x5e, 0xfa, 0x55, + 0x8b, 0x73, 0xc9, 0xd5, 0x7a, 0xde, 0xed, 0x97, 0x4b, 0xa0, 0x6e, 0x9e, 0x99, 0x75, 0x93, 0xc1, + 0x72, 0x51, 0xbb, 0x30, 0xcc, 0xc2, 0xca, 0xe2, 0x62, 0x42, 0x66, 0xd3, 0xfc, 0x59, 0x88, 0x9a, + 0x3e, 0xe5, 0x67, 0x7f, 0x63, 0x2c, 0x18, 0xb2, 0x9b, 0xf2, 0xa4, 0x9c, 0x2e, 0xa7, 0x8d, 0x59, + 0x25, 0x8f, 0x15, 0x06, 0x35, 0xc4, 0x3c, 0x37, 0x0c, 0xe6, 0x7c, 0x27, 0x8e, 0xc5, 0xde, 0x40, + 0x19, 0x62, 0x0b, 0x12, 0x80, 0x35, 0x0e, 0x8b, 0x38, 0xf3, 0xe2, 0xb6, 0xef, 0x74, 0x0d, 0xc7, + 0xab, 0x51, 0xfd, 0x4f, 0x81, 0xb0, 0x89, 0x67, 0xb7, 0x60, 0x2a, 0xfd, 0x12, 0xf3, 0x64, 0x9d, + 0xa5, 0x7d, 0x0c, 0x34, 0x9c, 0x17, 0xa0, 0xe6, 0xb0, 0xa7, 0x16, 0x3b, 0x8e, 0x90, 0x09, 0x3a, + 0xf9, 0x41, 0x02, 0xb0, 0xc6, 0xb1, 0xbf, 0x15, 0x4e, 0xe4, 0x8c, 0xd9, 0x00, 0x51, 0xb5, 0x3f, + 0x5f, 0x82, 0x63, 0xe9, 0x27, 0x63, 0x96, 0x18, 0xcd, 0xfb, 0xec, 0xc5, 0x6e, 0xb8, 0x4d, 0xa2, + 0x2e, 0xed, 0x86, 0x95, 0x49, 0x8c, 0xee, 0xc1, 0xc0, 0x39, 0x4f, 0xb1, 0x4b, 0xa0, 0x9a, 0xea, + 0xd5, 0xe5, 0xf4, 0xb8, 0x55, 0xe4, 0xf4, 0xd0, 0x23, 0x6b, 0x46, 0x02, 0x2a, 0x96, 0xd8, 0xe4, + 0x4f, 0xed, 0x6a, 0x96, 0xd6, 0x55, 0xef, 0x78, 0x7e, 0xe2, 0x05, 0xe2, 0x95, 0xc5, 0xc4, 0x51, + 0x76, 0xf5, 0x52, 0x2f, 0x0a, 0xce, 0x7b, 0xce, 0xfe, 0xda, 0x10, 0xa8, 0xf2, 0x48, 0x2c, 0x52, + 0xbb, 0xa0, 0x38, 0xf7, 0xfd, 0xa6, 0xd7, 0xab, 0x2f, 0x3d, 0xb4, 0x5b, 0xe8, 0x24, 0x77, 0x9d, + 0x9b, 0x67, 0x6c, 0x6a, 0xc0, 0x56, 0x35, 0x08, 0x9b, 0x78, 0xb4, 0x27, 0xbe, 0xb7, 0x4d, 0xf8, + 0x43, 0xc3, 0xe9, 0x9e, 0x2c, 0x4a, 0x00, 0xd6, 0x38, 0xec, 0x9e, 0x05, 0x6f, 0x7d, 0x5d, 0xf8, + 0x81, 0xf5, 0x3d, 0x0b, 0xde, 0xfa, 0x3a, 0x66, 0x10, 0x7e, 0x4d, 0x60, 0xb8, 0x25, 0xf6, 0x92, + 0xc6, 0x35, 0x81, 0xe1, 0x16, 0x66, 0x10, 0xfa, 0x95, 0x82, 0x30, 0x6a, 0x39, 0xbe, 0xf7, 0x2a, + 0x69, 0x2a, 0x2e, 0x62, 0x0f, 0xa9, 0xbe, 0xd2, 0x8d, 0x5e, 0x14, 0x9c, 0xf7, 0x1c, 0x9d, 0xd0, + 0xed, 0x88, 0x34, 0x3d, 0x37, 0x31, 0xa9, 0x41, 0x7a, 0x42, 0xaf, 0xf4, 0x60, 0xe0, 0x9c, 0xa7, + 0xd0, 0x2c, 0x1c, 0x93, 0xe5, 0xad, 0x64, 0x69, 0xd8, 0xd1, 0x74, 0x7d, 0x49, 0x9c, 0x06, 0xe3, + 0x2c, 0x3e, 0x95, 0x58, 0x2d, 0x51, 0xae, 0x9c, 0x6d, 0x39, 0x0d, 0x89, 0x25, 0xcb, 0x98, 0x63, + 0x85, 0x61, 0x7f, 0xb2, 0x4c, 0x35, 0x6c, 0x9f, 0x5b, 0x01, 0x8e, 0x2c, 0xaf, 0x22, 0x3d, 0x23, + 0x87, 0x06, 0x98, 0x91, 0xef, 0x82, 0xb1, 0x3b, 0x71, 0x18, 0xa8, 0x9c, 0x85, 0x4a, 0xdf, 0x9c, + 0x05, 0x03, 0x2b, 0x3f, 0x67, 0x61, 0xb8, 0xa8, 0x9c, 0x85, 0x91, 0x87, 0xcc, 0x59, 0xf8, 0xd7, + 0x15, 0x50, 0xf7, 0x40, 0xdf, 0x20, 0xc9, 0xdd, 0x30, 0xda, 0xf2, 0x82, 0x0d, 0x56, 0xaa, 0xe9, + 0xab, 0x96, 0xac, 0xf6, 0xb4, 0x68, 0xe6, 0xf4, 0xaf, 0x17, 0x74, 0x97, 0x6f, 0x8a, 0xd9, 0xcc, + 0xaa, 0xc1, 0x88, 0xc7, 0xbe, 0x65, 0xaa, 0x4a, 0x89, 0x63, 0xbd, 0x54, 0x8f, 0xd0, 0x77, 0x03, + 0xc8, 0x43, 0xb3, 0x75, 0x29, 0x81, 0x17, 0x8a, 0xe9, 0x1f, 0x26, 0xeb, 0xda, 0xbe, 0x5d, 0x55, + 0x4c, 0xb0, 0xc1, 0x10, 0x7d, 0x56, 0xd7, 0x3b, 0xe0, 0x49, 0x8e, 0x1f, 0x3d, 0x94, 0xb1, 0x19, + 0xa4, 0xda, 0x01, 0x86, 0x11, 0x2f, 0xd8, 0xa0, 0xf3, 0x44, 0xc4, 0x76, 0xbf, 0x35, 0xaf, 0x12, + 0xe0, 0x62, 0xe8, 0x34, 0xeb, 0x8e, 0xef, 0x04, 0x2e, 0x89, 0x16, 0x38, 0xba, 0xde, 0x4b, 0x8b, + 0x06, 0x2c, 0x09, 0xf5, 0x5c, 0x56, 0x5d, 0x19, 0xe4, 0xb2, 0xea, 0x33, 0xdf, 0x09, 0x93, 0x3d, + 0x1f, 0x73, 0x5f, 0xc5, 0x0d, 0x0e, 0x50, 0x03, 0xf0, 0x17, 0x86, 0xb5, 0xd2, 0xba, 0x11, 0x36, + 0xf9, 0xdd, 0xc7, 0x91, 0xfe, 0xa2, 0xc2, 0x7e, 0x2d, 0x70, 0x8a, 0x28, 0x35, 0x63, 0x34, 0x62, + 0x93, 0x25, 0x9d, 0xa3, 0x6d, 0x27, 0x22, 0xc1, 0x61, 0xcf, 0xd1, 0x15, 0xc5, 0x04, 0x1b, 0x0c, + 0xd1, 0x66, 0x2a, 0x0b, 0xf7, 0xf2, 0xc1, 0xb3, 0x70, 0x59, 0x7d, 0xe6, 0xbc, 0x2b, 0x42, 0x5f, + 0xb3, 0x60, 0x22, 0x48, 0xcd, 0xdc, 0x62, 0x12, 0x6e, 0xf2, 0x57, 0x45, 0x1d, 0xdd, 0xdf, 0x99, + 0x9e, 0x48, 0xb7, 0xe1, 0x0c, 0xff, 0x3c, 0x95, 0x56, 0xd9, 0xa7, 0x4a, 0xd3, 0x77, 0xaf, 0x0f, + 0xf7, 0xbb, 0x7b, 0x1d, 0x05, 0x30, 0xcc, 0xab, 0xc8, 0x8a, 0xb0, 0x9b, 0x03, 0xd6, 0x32, 0x32, + 0x4b, 0xd1, 0x72, 0x7e, 0xbc, 0x05, 0x0b, 0x2e, 0xe8, 0xb6, 0x99, 0xa4, 0x5f, 0xdd, 0x77, 0x16, + 0xe8, 0x78, 0xbf, 0x64, 0x7e, 0xfb, 0xff, 0x0e, 0xc1, 0x71, 0x39, 0x22, 0x32, 0x59, 0x8f, 0xea, + 0x47, 0xce, 0x57, 0xdb, 0xca, 0x4a, 0x3f, 0x5e, 0x95, 0x00, 0xac, 0x71, 0xa8, 0x3d, 0xd6, 0x89, + 0xc9, 0x72, 0x9b, 0x04, 0x8b, 0xde, 0x5a, 0x2c, 0x02, 0x64, 0xd4, 0x42, 0xb9, 0xa9, 0x41, 0xd8, + 0xc4, 0x63, 0x95, 0x04, 0x5c, 0xb3, 0x9c, 0x8f, 0xae, 0x24, 0x20, 0x0c, 0x55, 0x09, 0x47, 0x3f, + 0x9a, 0x7b, 0x4d, 0x51, 0x31, 0xa9, 0xee, 0x3d, 0x39, 0x8a, 0xfb, 0xbb, 0x9f, 0x08, 0xfd, 0x7d, + 0x0b, 0x4e, 0xf1, 0x56, 0x39, 0x92, 0x37, 0xdb, 0x4d, 0x27, 0x21, 0x71, 0x31, 0xd7, 0x4b, 0xe6, + 0xf4, 0x4f, 0x1f, 0x95, 0xe4, 0xb1, 0xc5, 0xf9, 0xbd, 0x41, 0x5f, 0xb2, 0xe0, 0xd8, 0x56, 0xaa, + 0x1c, 0x9f, 0x54, 0x1d, 0x07, 0xad, 0x55, 0x95, 0x22, 0xaa, 0x97, 0x5a, 0xba, 0x3d, 0xc6, 0x59, + 0xee, 0xf6, 0x9f, 0x5a, 0x60, 0x8a, 0xd1, 0xa3, 0xaf, 0xe2, 0xb7, 0x7f, 0x53, 0x50, 0x5a, 0x97, + 0x95, 0xbe, 0xd6, 0xe5, 0xd3, 0x50, 0xee, 0x78, 0x4d, 0xb1, 0xbf, 0xd0, 0x21, 0x39, 0x0b, 0xf3, + 0x98, 0xb6, 0xdb, 0xff, 0xaf, 0xa2, 0x7d, 0x12, 0x22, 0x83, 0xfc, 0x2f, 0xc4, 0x6b, 0x07, 0xaa, + 0x4c, 0x37, 0x7f, 0xf3, 0x5b, 0x3d, 0x65, 0xba, 0xe7, 0x1f, 0xbe, 0x50, 0x00, 0x1f, 0xa8, 0x7e, + 0x55, 0xba, 0x47, 0xf6, 0xac, 0xd2, 0x5d, 0xa5, 0x5b, 0x31, 0xe6, 0x64, 0xac, 0xa6, 0x3a, 0x57, + 0xbd, 0x2a, 0xda, 0x1f, 0xec, 0x4c, 0xd7, 0x1f, 0xbe, 0x7b, 0x92, 0x0a, 0x56, 0x7c, 0xd0, 0x77, + 0x41, 0x8d, 0xfe, 0x66, 0x85, 0x0d, 0xc4, 0x66, 0xef, 0x65, 0x25, 0x43, 0x25, 0xa0, 0xd0, 0xea, + 0x09, 0x9a, 0x1f, 0xda, 0x86, 0x1a, 0x45, 0xe4, 0xcc, 0xf9, 0xde, 0xf0, 0x7d, 0xaa, 0xcc, 0x80, + 0x04, 0x3c, 0xd8, 0x99, 0x9e, 0x7b, 0x78, 0xe6, 0x8a, 0x0c, 0xd6, 0xac, 0x0c, 0xd5, 0x39, 0xda, + 0x4f, 0x75, 0xda, 0x7f, 0x36, 0xa4, 0xe7, 0xbf, 0xa8, 0xf0, 0xfe, 0x17, 0x62, 0xfe, 0xbf, 0x98, + 0x99, 0xff, 0xe7, 0x7b, 0xe6, 0xff, 0x04, 0x1d, 0xb3, 0x9c, 0x7a, 0xf3, 0x47, 0x6d, 0x4c, 0xec, + 0xed, 0xb3, 0x60, 0x56, 0xd4, 0x2b, 0x1d, 0x2f, 0x22, 0xf1, 0x4a, 0xd4, 0x09, 0xbc, 0x60, 0x83, + 0x4d, 0xe1, 0xaa, 0x69, 0x45, 0xa5, 0xc0, 0x38, 0x8b, 0x8f, 0x9e, 0x87, 0x2a, 0x9d, 0x17, 0xb7, + 0x9d, 0x6d, 0x3e, 0x03, 0x8d, 0xaa, 0xba, 0x0d, 0xd1, 0x8e, 0x15, 0x06, 0xda, 0x84, 0xb3, 0x92, + 0xc0, 0x3c, 0xf1, 0x09, 0x7d, 0x21, 0x16, 0x8a, 0x1c, 0xb5, 0x78, 0xa2, 0x10, 0x8f, 0x26, 0x53, + 0xe7, 0x1d, 0x78, 0x17, 0x5c, 0xbc, 0x2b, 0x25, 0xfb, 0xf7, 0x59, 0xfc, 0x8a, 0x51, 0xf7, 0x85, + 0xce, 0x3e, 0xdf, 0x6b, 0x79, 0xb2, 0xf8, 0xaf, 0x9a, 0x7d, 0x8b, 0xb4, 0x11, 0x73, 0x18, 0xba, + 0x0b, 0x23, 0x6b, 0x8e, 0xbb, 0x15, 0xae, 0xaf, 0x17, 0x73, 0x75, 0x5f, 0x9d, 0x13, 0x63, 0x85, + 0xff, 0x47, 0xc4, 0x9f, 0x07, 0xfa, 0x27, 0x96, 0xdc, 0xf8, 0xb5, 0x31, 0xeb, 0x11, 0x89, 0x37, + 0x85, 0x63, 0xcf, 0xb8, 0x36, 0x86, 0x35, 0x63, 0x09, 0xb7, 0x7f, 0xbb, 0x02, 0xc7, 0x64, 0x2c, + 0xe9, 0x55, 0x2f, 0x66, 0x11, 0x2c, 0xe6, 0x05, 0x2a, 0xa5, 0x3d, 0x2f, 0x50, 0xf9, 0x30, 0x40, + 0x93, 0xb4, 0xfd, 0xb0, 0xcb, 0xec, 0xcc, 0xa1, 0x7d, 0xdb, 0x99, 0x6a, 0x6b, 0x32, 0xaf, 0xa8, + 0x60, 0x83, 0xa2, 0x28, 0x8e, 0xcc, 0xef, 0x63, 0xc9, 0x14, 0x47, 0x36, 0xee, 0x02, 0x1d, 0x3e, + 0xda, 0xbb, 0x40, 0x3d, 0x38, 0xc6, 0xbb, 0xa8, 0x0a, 0xb0, 0x3c, 0x44, 0x9d, 0x15, 0x96, 0xc2, + 0x3a, 0x9f, 0x26, 0x83, 0xb3, 0x74, 0xcd, 0x8b, 0x3e, 0xab, 0x47, 0x7d, 0xd1, 0xe7, 0xdb, 0xa0, + 0x26, 0xbf, 0x73, 0x3c, 0x55, 0xd3, 0x45, 0xc2, 0xe4, 0x34, 0x88, 0xb1, 0x86, 0xf7, 0xd4, 0x94, + 0x82, 0x47, 0x55, 0x53, 0xca, 0x7e, 0xad, 0x4c, 0x37, 0x28, 0xbc, 0x5f, 0xfb, 0xbe, 0x27, 0xf7, + 0xaa, 0x71, 0x4f, 0xee, 0xfe, 0xbe, 0x67, 0x35, 0x73, 0x9f, 0xee, 0x59, 0x18, 0x4a, 0x9c, 0x0d, + 0x99, 0x71, 0xcf, 0xa0, 0xab, 0xce, 0x46, 0x8c, 0x59, 0xeb, 0x7e, 0x6a, 0xc9, 0xbf, 0x04, 0xe3, + 0xb1, 0xb7, 0x11, 0x38, 0x49, 0x27, 0x22, 0xc6, 0xb9, 0xa4, 0x0e, 0xea, 0x32, 0x81, 0x38, 0x8d, + 0x8b, 0x3e, 0x65, 0x01, 0x44, 0x44, 0x6d, 0x7f, 0x86, 0x8b, 0x98, 0x43, 0x4a, 0x0c, 0x48, 0xba, + 0x66, 0x0d, 0x20, 0xb5, 0xed, 0x31, 0xd8, 0xda, 0x9f, 0xb1, 0x60, 0xb2, 0xe7, 0x29, 0xd4, 0x86, + 0x61, 0x97, 0xdd, 0x66, 0x5c, 0x4c, 0xfd, 0xdb, 0xf4, 0xcd, 0xc8, 0x5c, 0x8f, 0xf1, 0x36, 0x2c, + 0xf8, 0xd8, 0xbf, 0x38, 0x06, 0x27, 0x1b, 0x73, 0x4b, 0xf2, 0x16, 0xb4, 0x43, 0x2b, 0x21, 0x90, + 0xc7, 0xe3, 0xe8, 0x4a, 0x08, 0xf4, 0xe1, 0xee, 0x1b, 0x25, 0x04, 0x7c, 0xa3, 0x84, 0x40, 0x3a, + 0x9f, 0xbb, 0x5c, 0x44, 0x3e, 0x77, 0x5e, 0x0f, 0x06, 0xc9, 0xe7, 0x3e, 0xb4, 0x9a, 0x02, 0xbb, + 0x76, 0x68, 0x5f, 0x35, 0x05, 0x54, 0xc1, 0x85, 0x42, 0xd2, 0x47, 0xfb, 0x7c, 0xaa, 0xdc, 0x82, + 0x0b, 0x2a, 0xd9, 0x9d, 0xa7, 0x46, 0x0b, 0xa5, 0xf7, 0x72, 0xf1, 0x1d, 0x18, 0x20, 0xd9, 0x5d, + 0x64, 0x67, 0x9b, 0x05, 0x16, 0x46, 0x8a, 0x28, 0xb0, 0x90, 0xd7, 0x9d, 0x3d, 0x0b, 0x2c, 0xbc, + 0x04, 0xe3, 0xae, 0x1f, 0x06, 0x64, 0x25, 0x0a, 0x93, 0xd0, 0x0d, 0x7d, 0xb1, 0x63, 0xd3, 0xd7, + 0x00, 0x9b, 0x40, 0x9c, 0xc6, 0xed, 0x57, 0x9d, 0xa1, 0x76, 0xd0, 0xea, 0x0c, 0xf0, 0x88, 0xaa, + 0x33, 0x18, 0xf5, 0x07, 0x46, 0x8b, 0xa8, 0x3f, 0x90, 0xf7, 0x45, 0x06, 0xaa, 0x3f, 0xf0, 0xba, + 0x05, 0xe3, 0xce, 0x5d, 0xb6, 0x6f, 0xe1, 0x52, 0x98, 0x9d, 0xf6, 0x8d, 0x5e, 0xfc, 0xc8, 0x21, + 0x4c, 0xd8, 0xdb, 0x0d, 0xcd, 0xa6, 0x3e, 0xc9, 0x72, 0xc2, 0xcc, 0x26, 0x9c, 0xee, 0xc8, 0x41, + 0x6a, 0x16, 0x7c, 0xb9, 0x04, 0x6f, 0xde, 0xb3, 0x0b, 0xe8, 0x2e, 0x40, 0xe2, 0x6c, 0x88, 0x89, + 0x2a, 0xce, 0xc4, 0x0e, 0x18, 0x87, 0xbe, 0x2a, 0xe9, 0x89, 0x7c, 0x5a, 0x45, 0x1e, 0x1b, 0xac, + 0x58, 0xf8, 0x79, 0xe8, 0xf7, 0x94, 0xae, 0xc7, 0xa1, 0x4f, 0x30, 0x83, 0x50, 0x43, 0x28, 0x22, + 0x1b, 0xd4, 0xb8, 0x2f, 0xa7, 0x0d, 0x21, 0xcc, 0x5a, 0xb1, 0x80, 0xa2, 0x17, 0x60, 0xd4, 0xf1, + 0x7d, 0x9e, 0xdb, 0x4b, 0x62, 0x71, 0x3f, 0xb7, 0x2e, 0x58, 0xad, 0x41, 0xd8, 0xc4, 0xb3, 0xff, + 0xa4, 0x04, 0xd3, 0x7b, 0xc8, 0x94, 0x9e, 0x9a, 0x0e, 0x95, 0x81, 0x6b, 0x3a, 0x88, 0xdc, 0xc4, + 0xe1, 0x3e, 0xb9, 0x89, 0x2f, 0xc0, 0x68, 0x42, 0x9c, 0x96, 0x88, 0x5c, 0xcd, 0xd6, 0x61, 0x5d, + 0xd5, 0x20, 0x6c, 0xe2, 0x51, 0x29, 0x36, 0xe1, 0xb8, 0x2e, 0x89, 0x63, 0x99, 0x7c, 0x28, 0x1c, + 0xe6, 0x85, 0x65, 0x36, 0xb2, 0x73, 0x88, 0xd9, 0x14, 0x0b, 0x9c, 0x61, 0x99, 0x1d, 0xf0, 0xda, + 0x80, 0x03, 0xfe, 0xe3, 0x25, 0x78, 0x7a, 0x57, 0xed, 0x36, 0x70, 0x5e, 0x68, 0x27, 0x26, 0x51, + 0x76, 0xe2, 0xdc, 0x8c, 0x49, 0x84, 0x19, 0x84, 0x8f, 0x52, 0xbb, 0xad, 0xb2, 0x0e, 0x8a, 0x4f, + 0xa4, 0xe6, 0xa3, 0x94, 0x62, 0x81, 0x33, 0x2c, 0x1f, 0x76, 0x5a, 0xfe, 0xf6, 0x10, 0x3c, 0x33, + 0x80, 0x0d, 0x50, 0x60, 0xc2, 0x79, 0xba, 0x98, 0x42, 0xf9, 0x11, 0x15, 0x53, 0x78, 0xb8, 0xe1, + 0x7a, 0xa3, 0x06, 0xc3, 0x40, 0x89, 0xed, 0x3f, 0x59, 0x82, 0x33, 0xfd, 0x0d, 0x16, 0xf4, 0x1d, + 0x70, 0x2c, 0x52, 0xa1, 0x86, 0x66, 0x1d, 0x86, 0x13, 0xdc, 0x1d, 0x96, 0x02, 0xe1, 0x2c, 0x2e, + 0x9a, 0x01, 0x68, 0x3b, 0xc9, 0x66, 0x7c, 0xe9, 0x9e, 0x17, 0x27, 0xa2, 0x70, 0xe5, 0x04, 0x3f, + 0xc4, 0x95, 0xad, 0xd8, 0xc0, 0xa0, 0xec, 0xd8, 0xbf, 0xf9, 0xf0, 0x46, 0x98, 0xf0, 0x87, 0xf8, + 0xd6, 0xf3, 0x84, 0xbc, 0xf6, 0xd5, 0x00, 0xe1, 0x2c, 0x2e, 0x65, 0xc7, 0xc2, 0x04, 0x78, 0x47, + 0x87, 0x74, 0xe5, 0x86, 0x45, 0xd5, 0x8a, 0x0d, 0x8c, 0x6c, 0x85, 0x89, 0xca, 0xde, 0x15, 0x26, + 0xec, 0xcf, 0x95, 0xe1, 0x74, 0x5f, 0x83, 0x77, 0x30, 0x31, 0xf5, 0xf8, 0x55, 0x79, 0x78, 0xc8, + 0x15, 0xb6, 0xbf, 0xea, 0x00, 0x2b, 0x70, 0x52, 0xdc, 0x12, 0x3d, 0x1b, 0xb9, 0x9b, 0xde, 0x36, + 0x69, 0xb2, 0xe9, 0x23, 0xd6, 0x84, 0x4a, 0x0e, 0xb8, 0x94, 0x83, 0x83, 0x73, 0x9f, 0xb4, 0xff, + 0x49, 0x39, 0x7f, 0xee, 0x8a, 0x5a, 0x02, 0x0f, 0x5f, 0x76, 0xe9, 0xf1, 0xfb, 0x42, 0x3d, 0xe5, + 0x03, 0x86, 0xf6, 0x51, 0x3e, 0x20, 0xf3, 0x79, 0x2b, 0x03, 0x7e, 0xde, 0xe2, 0x3f, 0xd8, 0x3f, + 0xaf, 0xf4, 0xfd, 0x60, 0x74, 0x13, 0x3f, 0xd0, 0x81, 0xc8, 0x3c, 0x1c, 0xf7, 0x02, 0x46, 0xbb, + 0xd1, 0x59, 0x13, 0xf5, 0x16, 0x79, 0x71, 0x71, 0x95, 0x51, 0xb6, 0x90, 0x81, 0xe3, 0x9e, 0x27, + 0x1e, 0xc3, 0x02, 0x11, 0x0f, 0xf9, 0x91, 0xf6, 0xa7, 0x5d, 0x96, 0xe1, 0x94, 0x1c, 0x8a, 0x4d, + 0x27, 0x22, 0x4d, 0x61, 0x10, 0xc4, 0x22, 0x87, 0xf0, 0x34, 0xcf, 0x43, 0xcc, 0x41, 0xc0, 0xf9, + 0xcf, 0xb1, 0x9b, 0xa1, 0xc3, 0xb6, 0xe7, 0x8a, 0xed, 0xaa, 0xbe, 0x19, 0x9a, 0x36, 0x62, 0x0e, + 0xd3, 0x3a, 0xad, 0x76, 0x24, 0x3a, 0x8d, 0xa7, 0x21, 0xe5, 0x4c, 0x5c, 0xc8, 0xa6, 0x21, 0xe5, + 0x4d, 0xdc, 0xbc, 0x27, 0xed, 0x0f, 0x43, 0x4d, 0x7d, 0x41, 0x9e, 0x21, 0xa2, 0x16, 0x62, 0x4f, + 0x86, 0x88, 0x5a, 0x85, 0x06, 0x16, 0x9d, 0x6f, 0x74, 0x7b, 0x96, 0x91, 0x28, 0xf4, 0x0d, 0x68, + 0xbb, 0xfd, 0x4e, 0x18, 0x53, 0x1e, 0xd0, 0x41, 0x6f, 0xfc, 0xb6, 0xff, 0xbc, 0x04, 0x99, 0x4b, + 0x2d, 0xd1, 0x3d, 0xa8, 0x35, 0xa3, 0x2e, 0x6f, 0x2c, 0xa6, 0x5c, 0xfe, 0xbc, 0x24, 0xa7, 0x4f, + 0x0a, 0x55, 0x13, 0xd6, 0xcc, 0xd0, 0xc7, 0x78, 0x45, 0x7a, 0xc1, 0xba, 0x54, 0x44, 0xd9, 0x91, + 0x86, 0xa2, 0x67, 0x5e, 0xe5, 0x2b, 0xdb, 0xb0, 0xc1, 0x0f, 0x25, 0x50, 0xdb, 0x94, 0x97, 0x77, + 0x16, 0x23, 0x92, 0xd5, 0x5d, 0xa0, 0xdc, 0x30, 0x55, 0x7f, 0xb1, 0x66, 0x64, 0xff, 0x41, 0x09, + 0x4e, 0xa6, 0x3f, 0x80, 0x38, 0xd9, 0xfd, 0x29, 0x0b, 0x9e, 0xf4, 0x9d, 0x38, 0x69, 0x74, 0xd8, + 0xf6, 0x68, 0xbd, 0xe3, 0x2f, 0x67, 0x2e, 0x31, 0x38, 0xa8, 0x8b, 0x49, 0x11, 0xce, 0x5e, 0xf6, + 0x5a, 0x7f, 0xea, 0xfe, 0xce, 0xf4, 0x93, 0x8b, 0xf9, 0xcc, 0x71, 0xbf, 0x5e, 0xa1, 0xd7, 0x2c, + 0x38, 0xee, 0x76, 0xa2, 0x88, 0x04, 0x89, 0xee, 0x2a, 0xff, 0x8a, 0x37, 0x0a, 0x19, 0x48, 0xdd, + 0xc1, 0x93, 0x54, 0x44, 0xcf, 0x65, 0x78, 0xe1, 0x1e, 0xee, 0xf6, 0x0f, 0x50, 0xcb, 0xb4, 0xef, + 0x7b, 0xfe, 0x25, 0xbb, 0x9d, 0xf6, 0x8f, 0x86, 0x61, 0x3c, 0x75, 0x43, 0x43, 0xea, 0x88, 0xd3, + 0xda, 0xf3, 0x88, 0x93, 0xe5, 0xd1, 0x76, 0x02, 0x71, 0x7b, 0xa2, 0x99, 0x47, 0xdb, 0x09, 0x08, + 0xe6, 0x30, 0x31, 0xa4, 0xb8, 0x13, 0x88, 0x33, 0x57, 0x73, 0x48, 0x71, 0x27, 0xc0, 0x02, 0x8a, + 0x3e, 0x61, 0xc1, 0x18, 0x5b, 0x7c, 0xe2, 0x2c, 0x59, 0xa8, 0xc8, 0x6b, 0x05, 0x2c, 0x77, 0x79, + 0x2b, 0x09, 0x0b, 0xbe, 0x35, 0x5b, 0x70, 0x8a, 0x23, 0xfa, 0xb4, 0x05, 0x35, 0x75, 0x4b, 0xb8, + 0x38, 0x11, 0x6a, 0x14, 0x7b, 0x01, 0x46, 0x46, 0xea, 0xa9, 0x9b, 0x08, 0xb0, 0x66, 0x8c, 0x62, + 0x75, 0x7a, 0x3b, 0x72, 0x38, 0xa7, 0xb7, 0x90, 0x73, 0x72, 0xfb, 0x36, 0xa8, 0xb5, 0x44, 0x56, + 0x2a, 0x3f, 0x50, 0x95, 0xf7, 0x1e, 0xc9, 0x46, 0xac, 0xe1, 0x74, 0x8b, 0x13, 0xb3, 0x17, 0x4b, + 0x8c, 0x13, 0x50, 0xb6, 0xc5, 0x69, 0xe8, 0x66, 0x6c, 0xe2, 0x98, 0xc7, 0xb5, 0xf0, 0x48, 0x8f, + 0x6b, 0x47, 0xf7, 0x38, 0xae, 0x6d, 0xc0, 0x29, 0xa7, 0x93, 0x84, 0x57, 0x89, 0xe3, 0xcf, 0x26, + 0x09, 0x69, 0xb5, 0x93, 0x98, 0x5f, 0xea, 0x31, 0xc6, 0x1c, 0xdf, 0x2a, 0x5c, 0xb0, 0x41, 0xfc, + 0xf5, 0x1e, 0x24, 0x9c, 0xff, 0xac, 0xfd, 0x4f, 0x2d, 0x38, 0x95, 0x3b, 0x15, 0x1e, 0xdf, 0x44, + 0x0d, 0xfb, 0x87, 0x2b, 0x70, 0x22, 0xe7, 0xfe, 0x16, 0xd4, 0x35, 0x17, 0x89, 0x55, 0x44, 0xcc, + 0x63, 0x3a, 0x84, 0x4f, 0x7e, 0x9b, 0x9c, 0x95, 0xb1, 0xbf, 0x08, 0x0c, 0x1d, 0x05, 0x51, 0x3e, + 0xda, 0x28, 0x08, 0x63, 0xae, 0x0f, 0x3d, 0xd2, 0xb9, 0x5e, 0xd9, 0x63, 0xae, 0xff, 0xb4, 0x05, + 0x53, 0xad, 0x3e, 0x97, 0x32, 0x8a, 0x53, 0xb4, 0x5b, 0x87, 0x73, 0xe5, 0x63, 0xfd, 0xec, 0xfd, + 0x9d, 0xe9, 0xbe, 0x77, 0x61, 0xe2, 0xbe, 0xbd, 0xb2, 0xbf, 0x56, 0x06, 0x66, 0xaf, 0xb1, 0x1a, + 0xfd, 0x5d, 0xf4, 0x71, 0xf3, 0x3a, 0x28, 0xab, 0xa8, 0x2b, 0x8b, 0x38, 0x71, 0x75, 0x9d, 0x14, + 0x1f, 0xc1, 0xbc, 0xdb, 0xa5, 0xb2, 0x92, 0xb0, 0x34, 0x80, 0x24, 0xf4, 0xe5, 0xbd, 0x5b, 0xe5, + 0xe2, 0xef, 0xdd, 0xaa, 0x65, 0xef, 0xdc, 0xda, 0xfd, 0x13, 0x0f, 0x3d, 0x96, 0x9f, 0xf8, 0x5f, + 0x58, 0x5c, 0xf0, 0x64, 0xbe, 0x02, 0x9a, 0x96, 0xe6, 0x06, 0xbf, 0x9e, 0xa7, 0xd6, 0x63, 0x6a, + 0x3c, 0x07, 0xd5, 0x58, 0x48, 0x65, 0x61, 0x92, 0xb0, 0x7d, 0xb1, 0x94, 0xd4, 0x58, 0x41, 0xd1, + 0x0c, 0x80, 0xe3, 0xfb, 0xe1, 0xdd, 0x4b, 0xad, 0x76, 0xd2, 0x95, 0x86, 0x09, 0xdd, 0x0a, 0xcc, + 0xaa, 0x56, 0x6c, 0x60, 0xa0, 0xb7, 0xc0, 0x08, 0xaf, 0xc1, 0xd2, 0x14, 0x7e, 0xac, 0x51, 0xba, + 0xf8, 0x78, 0x85, 0x96, 0x26, 0x96, 0x30, 0x7b, 0x13, 0x8c, 0xbd, 0xc4, 0xc3, 0xdf, 0xf7, 0xbf, + 0xf7, 0x15, 0xbe, 0xf6, 0xdf, 0x2d, 0x09, 0x56, 0x7c, 0x6f, 0xa0, 0x03, 0x26, 0xad, 0x7d, 0x06, + 0x4c, 0x7e, 0x0c, 0xc0, 0x0d, 0x5b, 0x6d, 0xba, 0xff, 0x5e, 0x0d, 0x8b, 0xd9, 0x62, 0xcd, 0x29, + 0x7a, 0x7a, 0x8b, 0xa5, 0xdb, 0xb0, 0xc1, 0x2f, 0x25, 0xd0, 0xcb, 0x7b, 0x0a, 0xf4, 0x94, 0x6c, + 0x1b, 0xda, 0x5d, 0xb6, 0xd9, 0x7f, 0x62, 0x41, 0xca, 0xd6, 0x43, 0x6d, 0xa8, 0xd0, 0xee, 0x76, + 0x85, 0x98, 0x58, 0x2e, 0xce, 0xb0, 0xa4, 0xf2, 0x59, 0xac, 0x3d, 0xf6, 0x13, 0x73, 0x46, 0xc8, + 0x17, 0xc1, 0xa1, 0x85, 0x6c, 0x79, 0x4c, 0x86, 0x57, 0xc3, 0x70, 0x8b, 0x07, 0x4e, 0xe9, 0x40, + 0x53, 0xfb, 0x45, 0x98, 0xec, 0xe9, 0x14, 0x35, 0x2f, 0x58, 0x49, 0x18, 0xb1, 0x66, 0x94, 0x79, + 0xc1, 0x8a, 0xa1, 0x60, 0x0e, 0xb3, 0x7f, 0xd2, 0x82, 0xe3, 0x59, 0xf2, 0xe8, 0x75, 0x0b, 0x26, + 0xe3, 0x2c, 0xbd, 0xc3, 0x1a, 0x3b, 0x95, 0x24, 0xd2, 0x03, 0xc2, 0xbd, 0x9d, 0xb0, 0x7f, 0x62, + 0x88, 0x4f, 0xfe, 0xdb, 0x5e, 0xd0, 0x0c, 0xef, 0x2a, 0xeb, 0xc8, 0xea, 0x6b, 0x1d, 0x3d, 0x0f, + 0xd5, 0xd8, 0xdd, 0x24, 0xcd, 0x8e, 0xdf, 0x53, 0x4a, 0xa3, 0x21, 0xda, 0xb1, 0xc2, 0x60, 0x95, + 0x03, 0x3a, 0x62, 0xb7, 0x9a, 0x99, 0x94, 0xf3, 0xa2, 0x1d, 0x2b, 0x0c, 0xf4, 0x2e, 0x18, 0x33, + 0x5e, 0x52, 0xce, 0x4b, 0xb6, 0xd5, 0x30, 0xf4, 0x76, 0x8c, 0x53, 0x58, 0x54, 0x00, 0x29, 0x4b, + 0x4b, 0xea, 0x69, 0x26, 0x80, 0x94, 0x38, 0x8c, 0xb1, 0x81, 0xc1, 0xea, 0x74, 0xf8, 0x9d, 0x98, + 0x9d, 0x9a, 0x0f, 0xeb, 0x9b, 0x6a, 0xe6, 0x44, 0x1b, 0x56, 0x50, 0x74, 0x11, 0xa0, 0xe5, 0x04, + 0x1d, 0xc7, 0xa7, 0x23, 0x24, 0x5c, 0x70, 0x6a, 0x19, 0x2e, 0x29, 0x08, 0x36, 0xb0, 0xe8, 0x1b, + 0x27, 0x5e, 0x8b, 0x7c, 0x20, 0x0c, 0x64, 0x50, 0xbf, 0x0e, 0xa4, 0x10, 0xed, 0x58, 0x61, 0xa0, + 0x17, 0x61, 0xd4, 0x09, 0x9a, 0xdc, 0x2c, 0x0c, 0x23, 0x71, 0x1e, 0xab, 0xf6, 0x9c, 0x37, 0x63, + 0x32, 0xab, 0xa1, 0xd8, 0x44, 0xcd, 0x5e, 0xd3, 0x03, 0x03, 0x5e, 0xd3, 0xf3, 0x82, 0x50, 0xb2, + 0xdb, 0x24, 0x8a, 0x3a, 0x32, 0x80, 0x59, 0x3d, 0xd6, 0xd0, 0x20, 0x6c, 0xe2, 0xd9, 0x7f, 0x6c, + 0xc1, 0x31, 0x5d, 0x07, 0x8c, 0x39, 0xf8, 0x52, 0x9e, 0x4d, 0x6b, 0x4f, 0xcf, 0x66, 0xba, 0x6c, + 0x4b, 0x69, 0xa0, 0xb2, 0x2d, 0x66, 0x45, 0x95, 0xf2, 0xae, 0x15, 0x55, 0xde, 0x02, 0x23, 0x5b, + 0xa4, 0x6b, 0x94, 0x5e, 0x61, 0x4a, 0xe5, 0x3a, 0x6f, 0xc2, 0x12, 0x86, 0x6c, 0x18, 0x76, 0x1d, + 0x55, 0xd3, 0x75, 0x4c, 0x84, 0xef, 0xcd, 0x32, 0x24, 0x01, 0xb1, 0x97, 0xa1, 0xa6, 0xe2, 0x1e, + 0xa4, 0x5b, 0xd0, 0xca, 0x77, 0x0b, 0x52, 0x91, 0x60, 0x84, 0x70, 0x68, 0x91, 0xc0, 0x02, 0x3f, + 0x44, 0x44, 0x47, 0x7d, 0xed, 0xd7, 0xbe, 0x7e, 0xee, 0x4d, 0xbf, 0xf5, 0xf5, 0x73, 0x6f, 0xfa, 0xfd, 0xaf, 0x9f, 0x7b, 0xd3, 0x27, 0xee, 0x9f, 0xb3, 0x7e, 0xed, 0xfe, 0x39, 0xeb, 0xb7, 0xee, - 0x9f, 0xb3, 0x7e, 0xff, 0xfe, 0x39, 0xeb, 0x6b, 0xf7, 0xcf, 0x59, 0xaf, 0xfd, 0xa7, 0x73, 0x6f, - 0xfa, 0xc0, 0xb7, 0xef, 0x96, 0xbc, 0xb0, 0xfd, 0x4e, 0x96, 0xb1, 0x40, 0xd7, 0xf3, 0x05, 0x63, - 0x12, 0x5f, 0x90, 0xeb, 0xf9, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xe1, 0x68, 0xd8, 0xe3, 0x93, + 0x9f, 0xb3, 0x7e, 0xff, 0xfe, 0x39, 0xeb, 0x6b, 0xf7, 0xcf, 0x59, 0xaf, 0xfd, 0x97, 0x73, 0x6f, + 0xfa, 0xc0, 0xb7, 0xef, 0x96, 0xf3, 0xb0, 0xfd, 0x4e, 0x96, 0xe8, 0x40, 0xc5, 0xc0, 0x05, 0x63, + 0xee, 0x5f, 0x90, 0x62, 0xe0, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xd5, 0xd2, 0x54, 0x3c, 0xca, 0x0a, 0x01, 0x00, } @@ -16237,6 +16238,14 @@ func (m *SyncWindow) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i-- + if m.SyncOverrun { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 i -= len(m.Description) copy(dAtA[i:], m.Description) i = encodeVarintGenerated(dAtA, i, uint64(len(m.Description))) @@ -20299,6 +20308,7 @@ func (m *SyncWindow) Size() (n int) { n += 2 l = len(m.Description) n += 1 + l + sovGenerated(uint64(l)) + n += 2 return n } @@ -23203,6 +23213,7 @@ func (this *SyncWindow) String() string { `TimeZone:` + fmt.Sprintf("%v", this.TimeZone) + `,`, `UseAndOperator:` + fmt.Sprintf("%v", this.UseAndOperator) + `,`, `Description:` + fmt.Sprintf("%v", this.Description) + `,`, + `SyncOverrun:` + fmt.Sprintf("%v", this.SyncOverrun) + `,`, `}`, }, "") return s @@ -57877,6 +57888,26 @@ func (m *SyncWindow) Unmarshal(dAtA []byte) error { } m.Description = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SyncOverrun", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SyncOverrun = bool(v != 0) default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/pkg/apis/application/v1alpha1/generated.proto b/pkg/apis/application/v1alpha1/generated.proto index 3640b3c378..2e51562612 100644 --- a/pkg/apis/application/v1alpha1/generated.proto +++ b/pkg/apis/application/v1alpha1/generated.proto @@ -2815,6 +2815,11 @@ message SyncWindow { // Description of the sync that will be applied to the schedule, can be used to add any information such as a ticket number for example optional string description = 10; + + // SyncOverrun allows ongoing syncs to continue in two scenarios: + // For deny windows: allows syncs that started before the deny window became active to continue running + // For allow windows: allows syncs that started during the allow window to continue after the window ends + optional bool syncOverrun = 11; } // TLSClientConfig contains settings to enable transport layer security diff --git a/pkg/apis/application/v1alpha1/openapi_generated.go b/pkg/apis/application/v1alpha1/openapi_generated.go index ecd4773081..ab6dc1b4e8 100644 --- a/pkg/apis/application/v1alpha1/openapi_generated.go +++ b/pkg/apis/application/v1alpha1/openapi_generated.go @@ -8457,6 +8457,13 @@ func schema_pkg_apis_application_v1alpha1_SyncWindow(ref common.ReferenceCallbac Format: "", }, }, + "syncOverrun": { + SchemaProps: spec.SchemaProps{ + Description: "SyncOverrun allows syncs that started before this deny window to continue running", + Type: []string{"boolean"}, + Format: "", + }, + }, }, }, }, diff --git a/pkg/apis/application/v1alpha1/types.go b/pkg/apis/application/v1alpha1/types.go index affc5ab440..2eef124d8f 100644 --- a/pkg/apis/application/v1alpha1/types.go +++ b/pkg/apis/application/v1alpha1/types.go @@ -2837,6 +2837,10 @@ type SyncWindow struct { UseAndOperator bool `json:"andOperator,omitempty" protobuf:"bytes,9,opt,name=andOperator"` // Description of the sync that will be applied to the schedule, can be used to add any information such as a ticket number for example Description string `json:"description,omitempty" protobuf:"bytes,10,opt,name=description"` + // SyncOverrun allows ongoing syncs to continue in two scenarios: + // For deny windows: allows syncs that started before the deny window became active to continue running + // For allow windows: allows syncs that started during the allow window to continue after the window ends + SyncOverrun bool `json:"syncOverrun,omitempty" protobuf:"bytes,11,opt,name=syncOverrun"` } // HasWindows returns true if SyncWindows has one or more SyncWindow @@ -2934,7 +2938,7 @@ func (w *SyncWindow) scheduleOffsetByTimeZone() time.Duration { } // AddWindow adds a sync window with the given parameters to the AppProject -func (spec *AppProjectSpec) AddWindow(knd string, sch string, dur string, app []string, ns []string, cl []string, ms bool, timeZone string, andOperator bool, description string) error { +func (spec *AppProjectSpec) AddWindow(knd string, sch string, dur string, app []string, ns []string, cl []string, ms bool, timeZone string, andOperator bool, description string, syncOverrun bool) error { if knd == "" || sch == "" || dur == "" { return errors.New("cannot create window: require kind, schedule, duration and one or more of applications, namespaces and clusters") } @@ -2947,6 +2951,7 @@ func (spec *AppProjectSpec) AddWindow(knd string, sch string, dur string, app [] TimeZone: timeZone, UseAndOperator: andOperator, Description: description, + SyncOverrun: syncOverrun, } if len(app) > 0 { @@ -3062,7 +3067,12 @@ func (w *SyncWindows) Matches(app *Application) *SyncWindows { } // CanSync returns true if a sync window currently allows a sync. isManual indicates whether the sync has been triggered manually. -func (w *SyncWindows) CanSync(isManual bool) (bool, error) { +// The operationStartTime parameter supports sync overrun functionality, which allows ongoing syncs to continue in two scenarios: +// 1. When a deny window becomes active: If the operation started when sync was allowed and the deny window has syncOverrun enabled, +// the sync can continue even though a deny window is now active. +// 2. When an allow window ends: If the operation started during an allow window with syncOverrun enabled, the sync can continue +// even after the allow window has ended (and no other allow windows are active). +func (w *SyncWindows) CanSync(isManual bool, operationStartTime *time.Time) (bool, error) { if !w.HasWindows() { return true, nil } @@ -3077,6 +3087,18 @@ func (w *SyncWindows) CanSync(isManual bool) (bool, error) { if isManual && manualEnabled { return true, nil } + + // Check if operation started before deny window and overrun is allowed + if operationStartTime != nil && !operationStartTime.IsZero() && active.denyAllowsOverrun() { + wasAllowed, err := w.canSyncAtTime(isManual, *operationStartTime) + if err != nil { + return false, err + } + if wasAllowed { + return true, nil // Allow sync to continue (overrun into deny window) + } + } + return false, nil } @@ -3092,6 +3114,18 @@ func (w *SyncWindows) CanSync(isManual bool) (bool, error) { if isManual && inactiveAllows.manualEnabled() { return true, nil } + + // Check if operation started during an allow window and overrun is allowed + if operationStartTime != nil && !operationStartTime.IsZero() && inactiveAllows.inactiveAllowsAllowOverrun() { + wasAllowed, err := w.canSyncAtTime(isManual, *operationStartTime) + if err != nil { + return false, err + } + if wasAllowed { + return true, nil // Allow sync to continue (overrun out of allow window) + } + } + return false, nil } @@ -3149,6 +3183,82 @@ func (w *SyncWindows) manualEnabled() bool { return true } +// denyAllowsOverrun will iterate over the deny SyncWindows and return true if all deny windows have +// SyncOverrun set to true. Returns false if it finds at least one deny window with +// SyncOverrun set to false. This is used to determine if a sync can continue when a deny +// window becomes active after the operation started. +func (w *SyncWindows) denyAllowsOverrun() bool { + if !w.HasWindows() { + return false + } + hasDeny := false + for _, s := range *w { + if s.Kind == "deny" { + hasDeny = true + if !s.SyncOverrun { + return false + } + } + } + return hasDeny +} + +// inactiveAllowsAllowOverrun checks if all inactive allow windows have SyncOverrun enabled. +// This is used to determine if a sync can continue after an allow window has ended. +// Similar to allowsOverrun() for deny windows, ALL allow windows must have SyncOverrun enabled. +func (w *SyncWindows) inactiveAllowsAllowOverrun() bool { + if !w.HasWindows() { + return false + } + hasAllow := false + for _, s := range *w { + if s.Kind == "allow" { + hasAllow = true + if !s.SyncOverrun { + return false + } + } + } + return hasAllow +} + +// canSyncAtTime checks if a sync would have been allowed at a specific time +func (w *SyncWindows) canSyncAtTime(isManual bool, checkTime time.Time) (bool, error) { + if !w.HasWindows() { + return true, nil + } + + active, err := w.active(checkTime) + if err != nil { + return false, fmt.Errorf("invalid sync windows: %w", err) + } + hasActiveDeny, manualEnabled := active.hasDeny() + + if hasActiveDeny { + if isManual && manualEnabled { + return true, nil + } + return false, nil + } + + if active.hasAllow() { + return true, nil + } + + inactiveAllows, err := w.inactiveAllows(checkTime) + if err != nil { + return false, fmt.Errorf("invalid sync windows: %w", err) + } + if inactiveAllows.HasWindows() { + if isManual && inactiveAllows.manualEnabled() { + return true, nil + } + return false, nil + } + + return true, nil +} + // Active returns true if the sync window is currently active func (w SyncWindow) Active() (bool, error) { return w.active(time.Now()) diff --git a/pkg/apis/application/v1alpha1/types_test.go b/pkg/apis/application/v1alpha1/types_test.go index 08e789c0a1..4c9de50936 100644 --- a/pkg/apis/application/v1alpha1/types_test.go +++ b/pkg/apis/application/v1alpha1/types_test.go @@ -2365,9 +2365,9 @@ func TestAppProjectSpec_AddWindow(t *testing.T) { t.Run(tt.name, func(t *testing.T) { switch tt.want { case "error": - require.Error(t, tt.p.Spec.AddWindow(tt.k, tt.s, tt.d, tt.a, tt.n, tt.c, tt.m, tt.t, tt.o, tt.description)) + require.Error(t, tt.p.Spec.AddWindow(tt.k, tt.s, tt.d, tt.a, tt.n, tt.c, tt.m, tt.t, tt.o, tt.description, false)) case "noError": - require.NoError(t, tt.p.Spec.AddWindow(tt.k, tt.s, tt.d, tt.a, tt.n, tt.c, tt.m, tt.t, tt.o, tt.description)) + require.NoError(t, tt.p.Spec.AddWindow(tt.k, tt.s, tt.d, tt.a, tt.n, tt.c, tt.m, tt.t, tt.o, tt.description, false)) require.NoError(t, tt.p.Spec.DeleteWindow(0)) } }) @@ -2376,7 +2376,7 @@ func TestAppProjectSpec_AddWindow(t *testing.T) { func TestAppProjectSpecWindowWithDescription(t *testing.T) { proj := newTestProjectWithSyncWindows() - require.NoError(t, proj.Spec.AddWindow("allow", "* * * * *", "1h", []string{"app1"}, []string{}, []string{}, false, "error", false, "Ticket AAAAA")) + require.NoError(t, proj.Spec.AddWindow("allow", "* * * * *", "1h", []string{"app1"}, []string{}, []string{}, false, "error", false, "Ticket AAAAA", false)) require.Equal(t, "Ticket AAAAA", proj.Spec.SyncWindows[1].Description) require.NoError(t, proj.Spec.SyncWindows[1].Update("", "", []string{}, []string{}, []string{}, "", "Ticket BBBBB")) @@ -2618,7 +2618,7 @@ func TestSyncWindows_CanSync(t *testing.T) { proj := newProjectBuilder().withInactiveDenyWindow(true).build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2630,7 +2630,7 @@ func TestSyncWindows_CanSync(t *testing.T) { proj := newProjectBuilder().withInactiveDenyWindow(false).build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2645,7 +2645,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2659,7 +2659,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2673,7 +2673,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2687,7 +2687,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2702,7 +2702,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2717,7 +2717,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2731,7 +2731,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2745,7 +2745,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2759,7 +2759,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2773,7 +2773,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2788,7 +2788,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2803,7 +2803,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2818,7 +2818,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2832,7 +2832,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2846,7 +2846,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2860,7 +2860,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2874,7 +2874,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2891,7 +2891,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2908,7 +2908,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2923,7 +2923,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2938,7 +2938,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(true) + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) // then require.NoError(t, err) @@ -2953,7 +2953,7 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.NoError(t, err) @@ -2967,12 +2967,60 @@ func TestSyncWindows_CanSync(t *testing.T) { build() // when - canSync, err := proj.Spec.SyncWindows.CanSync(false) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) // then require.Error(t, err) assert.False(t, canSync) }) + t.Run("will return error when inactive-allow has invalid schedule", func(t *testing.T) { + // given + t.Parallel() + proj := newTestProject() + // Add an inactive allow window with invalid cron schedule + invalidWindow := &SyncWindow{ + Kind: "allow", + Schedule: "invalid-cron-schedule", + Duration: "1h", + Applications: []string{"app1"}, + Namespaces: []string{"public"}, + ManualSync: false, + } + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, invalidWindow) + + // when + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) + + // then + require.Error(t, err) + assert.Contains(t, err.Error(), "invalid sync windows") + assert.Contains(t, err.Error(), "cannot parse schedule") + assert.False(t, canSync) + }) + t.Run("will return error when inactive-allow has invalid duration", func(t *testing.T) { + // given + t.Parallel() + proj := newTestProject() + // Add an inactive allow window with invalid duration + invalidWindow := &SyncWindow{ + Kind: "allow", + Schedule: inactiveCronSchedule(), + Duration: "invalid-duration", + Applications: []string{"app1"}, + Namespaces: []string{"public"}, + ManualSync: false, + } + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, invalidWindow) + + // when + canSync, err := proj.Spec.SyncWindows.CanSync(true, nil) + + // then + require.Error(t, err) + assert.Contains(t, err.Error(), "invalid sync windows") + assert.Contains(t, err.Error(), "cannot parse duration") + assert.False(t, canSync) + }) } func TestSyncWindows_hasDeny(t *testing.T) { @@ -5088,6 +5136,729 @@ func TestSyncPolicyAutomatedSerialisation(t *testing.T) { } } +func TestSyncWindows_SyncOverrun(t *testing.T) { + t.Run("DenyWindowWithoutOverrunBlocksContinuingSync", func(t *testing.T) { + // given - a deny window without allowSyncOverrun + proj := newTestProjectWithSyncWindows() + deny := &SyncWindow{ + Kind: "deny", + Schedule: "* * * * *", + Duration: "1h", + Applications: []string{"*"}, + } + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, deny) + + // Operation started 5 minutes ago + operationStartTime := time.Now().Add(-5 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be blocked + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("DenyWindowWithOverrunBlocksNewSync", func(t *testing.T) { + // given - a deny window with allowSyncOverrun enabled + proj := newTestProjectWithSyncWindows() + deny := &SyncWindow{ + Kind: "deny", + Schedule: "* * * * *", + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, + } + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, deny) + + // when - checking if new sync can start (no operation start time) + canSync, err := proj.Spec.SyncWindows.CanSync(false, nil) + + // then - new sync should be blocked + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("DenyWindowWithOverrunBlocksSyncThatStartedDuringDeny", func(t *testing.T) { + // given - a deny window with allowSyncOverrun enabled + proj := newTestProjectWithSyncWindows() + deny := &SyncWindow{ + Kind: "deny", + Schedule: "* * * * *", // Always active + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, + } + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, deny) + + // Operation started 5 minutes ago (during the deny window, which was already active) + operationStartTime := time.Now().Add(-5 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be blocked because it wasn't allowed when it started + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("AllowsOverrunWhenAllDenyWindowsHaveIt", func(t *testing.T) { + // given - all deny windows have syncOverrun enabled + windows := SyncWindows{ + &SyncWindow{Kind: "deny", SyncOverrun: true}, + &SyncWindow{Kind: "deny", SyncOverrun: true}, + } + + // when - checking if overrun is allowed + denyAllowsOverrun := windows.denyAllowsOverrun() + + // then - should return true (all deny windows allow it) + assert.True(t, denyAllowsOverrun) + }) + + t.Run("DisallowsOverrunWhenOneDenyWindowDoesntHaveIt", func(t *testing.T) { + // given - mixed deny windows, one without syncOverrun + windows := SyncWindows{ + &SyncWindow{Kind: "deny", SyncOverrun: false}, + &SyncWindow{Kind: "deny", SyncOverrun: true}, + } + + // when - checking if overrun is allowed + denyAllowsOverrun := windows.denyAllowsOverrun() + + // then - should return false (not all deny windows allow it) + assert.False(t, denyAllowsOverrun) + }) + + t.Run("DisallowsOverrunWhenNoDenyWindowsHaveIt", func(t *testing.T) { + // given - deny windows without syncOverrun + windows := SyncWindows{ + &SyncWindow{Kind: "deny", SyncOverrun: false}, + } + + // when - checking if overrun is allowed + denyAllowsOverrun := windows.denyAllowsOverrun() + + // then - should return false + assert.False(t, denyAllowsOverrun) + }) + + t.Run("AllowsOverrunIgnoresAllowWindows", func(t *testing.T) { + // given - deny window with syncOverrun and allow windows + windows := SyncWindows{ + &SyncWindow{Kind: "allow", SyncOverrun: false}, + &SyncWindow{Kind: "deny", SyncOverrun: true}, + } + + // when - checking if overrun is allowed + denyAllowsOverrun := windows.denyAllowsOverrun() + + // then - should return true (only deny windows matter) + assert.True(t, denyAllowsOverrun) + }) + + t.Run("AllowsSyncToContinueWhenStartedBeforeDenyWindowWithOverrun", func(t *testing.T) { + // given - a deny window with syncOverrun that became active after operation started + proj := newTestProjectWithSyncWindows() // Has an always-active allow window + + // Create a deny window that's currently active + // Using current time to create a schedule that's active now + now := time.Now().In(time.UTC) + // Duration of 15 minutes means it will be active for 15 minutes starting from this minute + schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny := &SyncWindow{ + Kind: "deny", + Schedule: schedule, + Duration: "15m", + Applications: []string{"*"}, + SyncOverrun: true, + } + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, deny) + + // Operation started 25 minutes ago, before this deny window became active + operationStartTime := now.Add(-25 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be allowed to continue (overrun) + require.NoError(t, err) + assert.True(t, canSync) + }) + + t.Run("DeniesSyncThatStartedWhenInactiveAllowsBlockedIt", func(t *testing.T) { + // given - a deny window with syncOverrun that's currently active + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window that's currently INACTIVE (was active 2 hours ago) + // This creates a scenario where at operation start time (1 hour ago), + // there were no active windows but inactive allows were present + inactiveAllowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-3*time.Hour).Hour()) + inactiveAllow := &SyncWindow{ + Kind: "allow", + Schedule: inactiveAllowSchedule, + Duration: "30m", // Was active 3 hours ago for 30 minutes + Applications: []string{"*"}, + ManualSync: false, + } + + // Create a deny window that's currently active (just started) + activeDenySchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + activeDeny := &SyncWindow{ + Kind: "deny", + Schedule: activeDenySchedule, + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, inactiveAllow, activeDeny) + + // Operation started 1 hour ago, when there were no active windows + // but inactive allows were created after sync was started (which blocks syncs) + operationStartTime := now.Add(-1 * time.Hour) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be denied because it was blocked by inactive allows + // after it started (even though overrun is enabled) + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("AllowsSyncWhenStartedDuringAllowWindowWithOverrun", func(t *testing.T) { + // given - an allow window with syncOverrun that's currently active + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window with manual sync enabled that's was ACTIVE 1h ago + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow) + + // Operation started 45 minutes ago during allow + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be allowed (allow with overrun enabled) + require.NoError(t, err) + assert.True(t, canSync) + }) + + t.Run("DeniesSyncWhenStartedDuringAllowWindowWithoutOverrun", func(t *testing.T) { + // given - an allow window with syncOverrun that's currently active + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window with manual sync enabled that's was ACTIVE 1h ago + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow) + + // Operation started 45 minutes ago during allow + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be denied (allow without overrun enabled) + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("DeniesSyncStartedInAllowWithOverrunWhenTransitionsToDenyWithoutOverrun", func(t *testing.T) { + // Scenario: Sync starts during an allow window with overrun enabled, + // then a deny window WITHOUT overrun becomes active. + // Expected: Sync is DENIED because the current deny window doesn't allow overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window that WAS active 1 hour ago for 30 minutes, with overrun + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Create a deny window that's currently ACTIVE (without overrun) + denySchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny := &SyncWindow{ + Kind: "deny", + Schedule: denySchedule, + Duration: "1h", + Applications: []string{"*"}, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow, deny) + + // Sync started 45 minutes ago during the allow window + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be denied because current deny window doesn't allow overrun + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("AllowsSyncStartedInAllowWithoutOverrunWhenTransitionsToDenyWithOverrun", func(t *testing.T) { + // Scenario: Sync starts during an allow window WITHOUT overrun enabled, + // then a deny window WITH overrun becomes active. + // Expected: Sync is ALLOWED because the current deny window allows overrun, + // and the sync was permitted when it started (even though the original allow didn't have overrun). + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window that WAS active 1 hour ago for 30 minutes (no overrun) + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + } + + // Create a deny window that's currently ACTIVE (with overrun) + denySchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny := &SyncWindow{ + Kind: "deny", + Schedule: denySchedule, + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow, deny) + + // Sync started 45 minutes ago during the allow window + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be allowed because current deny window allows overrun + require.NoError(t, err) + assert.True(t, canSync) + }) + + t.Run("AllowsSyncStartedInAllowWithOverrunWhenTransitionsToDenyWithOverrun", func(t *testing.T) { + // Scenario: Sync starts during an allow window WITH overrun enabled, + // then a deny window WITH overrun becomes active. + // Expected: Sync is ALLOWED because both windows support overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window that WAS active 1 hour ago for 30 minutes (with overrun) + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Create a deny window that's currently ACTIVE (with overrun) + denySchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny := &SyncWindow{ + Kind: "deny", + Schedule: denySchedule, + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow, deny) + + // Sync started 45 minutes ago during the allow window + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be ALLOWED because both windows allow overrun + require.NoError(t, err) + assert.True(t, canSync) + }) + + t.Run("DeniesSyncStartedInAllowWithoutOverrunWhenTransitionsToDenyWithoutOverrun", func(t *testing.T) { + // Scenario: Sync starts during an allow window WITHOUT overrun enabled, + // then a deny window WITHOUT overrun becomes active. + // Expected: Sync is DENIED because neither window supports overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window that WAS active 1 hour ago for 30 minutes (no overrun) + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + } + + // Create a deny window that's currently ACTIVE (without overrun) + denySchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny := &SyncWindow{ + Kind: "deny", + Schedule: denySchedule, + Duration: "1h", + Applications: []string{"*"}, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow, deny) + + // Sync started 45 minutes ago during the allow window + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be denied because neither window allows overrun + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("AllowsSyncStartedInAllowWhenMultipleConcurrentDenyWindowsAllHaveOverrun", func(t *testing.T) { + // Scenario: Sync starts during an allow window, + // then multiple deny windows become active simultaneously, ALL with overrun enabled. + // Expected: Sync is ALLOWED because all currently active deny windows support overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window that WAS active 1 hour ago + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Create first deny window that's currently ACTIVE with overrun + deny1Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny1 := &SyncWindow{ + Kind: "deny", + Schedule: deny1Schedule, + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Create second deny window that's also currently ACTIVE with overrun + deny2Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny2 := &SyncWindow{ + Kind: "deny", + Schedule: deny2Schedule, + Duration: "2h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow, deny1, deny2) + + // Sync started 45 minutes ago during the allow window + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be allowed because ALL active deny windows allow overrun + require.NoError(t, err) + assert.True(t, canSync) + }) + + t.Run("DeniesSyncStartedInAllowWhenOneConcurrentDenyWindowLacksOverrun", func(t *testing.T) { + // Scenario: Sync starts during an allow window, + // then multiple deny windows become active, but ONE lacks overrun. + // Expected: Sync is DENIED because not all deny windows support overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create an allow window that WAS active 1 hour ago + allowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow := &SyncWindow{ + Kind: "allow", + Schedule: allowSchedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Create first deny window that's currently ACTIVE with overrun + deny1Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny1 := &SyncWindow{ + Kind: "deny", + Schedule: deny1Schedule, + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Create second deny window that's also currently ACTIVE WITHOUT overrun + deny2Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + deny2 := &SyncWindow{ + Kind: "deny", + Schedule: deny2Schedule, + Duration: "2h", + Applications: []string{"*"}, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow, deny1, deny2) + + // Sync started 45 minutes ago during the allow window + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be denied because not all deny windows allow overrun + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("DeniesSyncWhenLeavingMultipleAllowWindowsWhereOneLacksOverrun", func(t *testing.T) { + // Scenario: Sync starts during allow windows (multiple are active), + // then all allow windows end, but ONE allow window does NOT have overrun enabled. + // Expected: Sync is DENIED because ALL inactive allow windows must support overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create first allow window that WAS active 1 hour ago WITH overrun + allow1Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow1 := &SyncWindow{ + Kind: "allow", + Schedule: allow1Schedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, // Has overrun + } + + // Create second allow window that WAS active 1 hour ago WITHOUT overrun + allow2Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow2 := &SyncWindow{ + Kind: "allow", + Schedule: allow2Schedule, + Duration: "30m", + Applications: []string{"*"}, + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow1, allow2) + + // Sync started 45 minutes ago during the allow windows + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be denied because not all inactive allow windows have overrun + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("AllowsSyncWhenLeavingMultipleAllowWindowsWhereAllHaveOverrun", func(t *testing.T) { + // Scenario: Sync starts during allow windows (multiple are active), + // then all allow windows end, and ALL allow windows have overrun enabled. + // Expected: Sync is ALLOWED because ALL inactive allow windows support overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create first allow window that WAS active 1 hour ago WITH overrun + allow1Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow1 := &SyncWindow{ + Kind: "allow", + Schedule: allow1Schedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, // Has overrun + } + + // Create second allow window that WAS active 1 hour ago WITH overrun + allow2Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow2 := &SyncWindow{ + Kind: "allow", + Schedule: allow2Schedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, // Also has overrun + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow1, allow2) + + // Sync started 45 minutes ago during the allow windows + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue= + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be allowed because all inactive allow windows have overrun + require.NoError(t, err) + assert.True(t, canSync) + }) + + t.Run("AllowsSyncInMultipleActiveAllowWindowsWhenOneLacksOverrunAndEnds", func(t *testing.T) { + // Scenario: Sync starts during multiple ACTIVE allow windows (one with overrun, one without). + // One window (without overrun) ends while the other (with overrun) is still active. + // Expected: Sync is ALLOWED because there's still an active allow window. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Create first allow window that WAS active 1 hour ago and ended (WITHOUT overrun) + allow1Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow1 := &SyncWindow{ + Kind: "allow", + Schedule: allow1Schedule, + Duration: "30m", // Ended 30 minutes ago + Applications: []string{"*"}, + SyncOverrun: false, // No overrun + } + + // Create second allow window that's still ACTIVE (WITH overrun) + allow2Schedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-1*time.Hour).Hour()) + allow2 := &SyncWindow{ + Kind: "allow", + Schedule: allow2Schedule, + Duration: "90m", // Still active for another 30 minutes + Applications: []string{"*"}, + SyncOverrun: true, // Has overrun + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, allow1, allow2) + + // Sync started 45 minutes ago when both windows were active + operationStartTime := now.Add(-45 * time.Minute) + + // when - checking if sync can continue (allow2 still active, allow1 ended) + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be allowed because allow2 is still active + require.NoError(t, err) + assert.True(t, canSync) + }) + + t.Run("DeniesSyncWhenBothDenyAndAllowWindowsActiveAndDenyLacksOverrun", func(t *testing.T) { + // Scenario: Multiple allow AND deny windows are simultaneously active. + // Sync started during an earlier allow window. + // Expected: Sync is DENIED if any active deny window lacks overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Sync started 2 hours ago during this allow window (which has since ended) + pastAllowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-2*time.Hour).Hour()) + pastAllow := &SyncWindow{ + Kind: "allow", + Schedule: pastAllowSchedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Currently active allow window (WITH overrun) + activeAllowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + activeAllow := &SyncWindow{ + Kind: "allow", + Schedule: activeAllowSchedule, + Duration: "2h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Currently active deny window (WITHOUT overrun) + activeDenySchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + activeDeny := &SyncWindow{ + Kind: "deny", + Schedule: activeDenySchedule, + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: false, // No overrun + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, pastAllow, activeAllow, activeDeny) + + // Sync started 1 hour 45 minutes ago during pastAllow + operationStartTime := now.Add(-105 * time.Minute) + + // when - checking if sync can continue (both allow and deny are active) + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be denied because deny window is active and lacks overrun + require.NoError(t, err) + assert.False(t, canSync) + }) + + t.Run("AllowsSyncWhenBothDenyAndAllowWindowsActiveAndDenyHasOverrun", func(t *testing.T) { + // Scenario: Multiple allow AND deny windows are simultaneously active. + // Sync started before the deny window became active. + // Expected: Sync is ALLOWED if all active deny windows have overrun. + proj := newTestProject() + now := time.Now().In(time.UTC) + + // Sync started 2 hours ago during this allow window (which has since ended) + pastAllowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Add(-2*time.Hour).Hour()) + pastAllow := &SyncWindow{ + Kind: "allow", + Schedule: pastAllowSchedule, + Duration: "30m", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Currently active allow window (WITH overrun) + activeAllowSchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + activeAllow := &SyncWindow{ + Kind: "allow", + Schedule: activeAllowSchedule, + Duration: "2h", + Applications: []string{"*"}, + SyncOverrun: true, + } + + // Currently active deny window (WITH overrun) + activeDenySchedule := fmt.Sprintf("%d %d * * *", now.Minute(), now.Hour()) + activeDeny := &SyncWindow{ + Kind: "deny", + Schedule: activeDenySchedule, + Duration: "1h", + Applications: []string{"*"}, + SyncOverrun: true, // Has overrun + } + + proj.Spec.SyncWindows = append(proj.Spec.SyncWindows, pastAllow, activeAllow, activeDeny) + + // Sync started 1 hour 45 minutes ago during pastAllow (before deny became active) + operationStartTime := now.Add(-105 * time.Minute) + + // when - checking if sync can continue (both allow and deny are active, deny has overrun) + canSync, err := proj.Spec.SyncWindows.CanSync(false, &operationStartTime) + + // then - sync should be allowed because deny window has overrun enabled + require.NoError(t, err) + assert.True(t, canSync) + }) +} + func TestGetDrySource_PreservesAllFields(t *testing.T) { tests := []struct { name string diff --git a/server/application/application.go b/server/application/application.go index 86149c0b27..3bf91eca9a 100644 --- a/server/application/application.go +++ b/server/application/application.go @@ -2050,7 +2050,7 @@ func (s *Server) Sync(ctx context.Context, syncReq *application.ApplicationSyncR s.inferResourcesStatusHealth(a) - canSync, err := proj.Spec.SyncWindows.Matches(a).CanSync(true) + canSync, err := proj.Spec.SyncWindows.Matches(a).CanSync(true, nil) if err != nil { return a, status.Errorf(codes.PermissionDenied, "cannot sync: invalid sync window: %v", err) } @@ -2846,7 +2846,7 @@ func (s *Server) GetApplicationSyncWindows(ctx context.Context, q *application.A } windows := proj.Spec.SyncWindows.Matches(a) - sync, err := windows.CanSync(true) + sync, err := windows.CanSync(true, nil) if err != nil { return nil, fmt.Errorf("invalid sync windows: %w", err) } diff --git a/test/e2e/project_management_test.go b/test/e2e/project_management_test.go index 5a677b11c4..ddb94c6d5e 100644 --- a/test/e2e/project_management_test.go +++ b/test/e2e/project_management_test.go @@ -578,6 +578,61 @@ func TestGetVirtualProjectMatch(t *testing.T) { assert.ErrorContains(t, err, "blocked by sync window") } +func TestSyncWindowSyncOverrun(t *testing.T) { + fixture.EnsureCleanState(t) + + projectName := "proj-" + strconv.FormatInt(time.Now().Unix(), 10) + _, err := fixture.AppClientset.ArgoprojV1alpha1().AppProjects(fixture.TestNamespace()).Create( + t.Context(), &v1alpha1.AppProject{ObjectMeta: metav1.ObjectMeta{Name: projectName}}, metav1.CreateOptions{}) + require.NoError(t, err, "Unable to create project") + + // Test adding a sync window with --sync-overrun flag + _, err = fixture.RunCli("proj", "windows", "add", projectName, + "--kind", "deny", + "--schedule", "0 0 * * *", + "--duration", "1h", + "--applications", "*", + "--sync-overrun") + require.NoError(t, err, "Unable to add sync window with sync overrun") + + proj, err := fixture.AppClientset.ArgoprojV1alpha1().AppProjects(fixture.TestNamespace()).Get(t.Context(), projectName, metav1.GetOptions{}) + require.NoError(t, err) + assert.Len(t, proj.Spec.SyncWindows, 1) + assert.True(t, proj.Spec.SyncWindows[0].SyncOverrun, "SyncOverrun should be true after adding with flag") + + // Test disabling sync overrun + _, err = fixture.RunCli("proj", "windows", "disable-sync-overrun", projectName, "0") + require.NoError(t, err, "Unable to disable sync overrun") + + proj, err = fixture.AppClientset.ArgoprojV1alpha1().AppProjects(fixture.TestNamespace()).Get(t.Context(), projectName, metav1.GetOptions{}) + require.NoError(t, err) + assert.False(t, proj.Spec.SyncWindows[0].SyncOverrun, "SyncOverrun should be false after disabling") + + // Test enabling sync overrun + _, err = fixture.RunCli("proj", "windows", "enable-sync-overrun", projectName, "0") + require.NoError(t, err, "Unable to enable sync overrun") + + proj, err = fixture.AppClientset.ArgoprojV1alpha1().AppProjects(fixture.TestNamespace()).Get(t.Context(), projectName, metav1.GetOptions{}) + require.NoError(t, err) + assert.True(t, proj.Spec.SyncWindows[0].SyncOverrun, "SyncOverrun should be true after enabling") + + // Add a second window without sync overrun to test multiple windows + _, err = fixture.RunCli("proj", "windows", "add", projectName, + "--kind", "deny", + "--schedule", "12 0 * * *", + "--duration", "2h", + "--applications", "*") + require.NoError(t, err, "Unable to add second sync window") + + proj, err = fixture.AppClientset.ArgoprojV1alpha1().AppProjects(fixture.TestNamespace()).Get(t.Context(), projectName, metav1.GetOptions{}) + require.NoError(t, err) + assert.Len(t, proj.Spec.SyncWindows, 2) + assert.True(t, proj.Spec.SyncWindows[0].SyncOverrun, "First window should still have SyncOverrun enabled") + assert.False(t, proj.Spec.SyncWindows[1].SyncOverrun, "Second window should not have SyncOverrun enabled") + + assertProjHasEvent(t, proj, "update", argo.EventReasonResourceUpdated) +} + func TestAddProjectDestinationServiceAccount(t *testing.T) { fixture.EnsureCleanState(t) diff --git a/ui/src/app/settings/components/project-details/project-details.tsx b/ui/src/app/settings/components/project-details/project-details.tsx index b4ee45032e..7461860208 100644 --- a/ui/src/app/settings/components/project-details/project-details.tsx +++ b/ui/src/app/settings/components/project-details/project-details.tsx @@ -258,6 +258,12 @@ export const ProjectDetails: React.FC & {obj MANUALSYNC {helpTip('If the window allows manual syncs')} +
+ SYNC OVERRUN + {helpTip( + 'Allows syncs to continue: for deny windows, syncs that started before the window; for allow windows, syncs that started during the window' + )} +
USE AND OPERATOR {helpTip('Use AND operator while selecting the apps that match the configured selectors')} @@ -283,6 +289,7 @@ export const ProjectDetails: React.FC & {obj
{(window.namespaces || ['-']).join(',')}
{(window.clusters || ['-']).join(',')}
{window.manualSync ? 'Enabled' : 'Disabled'}
+
{window.syncOverrun ? 'Enabled' : 'Disabled'}
{window.andOperator ? 'Enabled' : 'Disabled'}
{window.description || ''}
diff --git a/ui/src/app/settings/components/project-sync-windows-edit-panel/project-sync-windows-edit-panel.tsx b/ui/src/app/settings/components/project-sync-windows-edit-panel/project-sync-windows-edit-panel.tsx index 2e2bfcf0c1..3bb1ec48ee 100644 --- a/ui/src/app/settings/components/project-sync-windows-edit-panel/project-sync-windows-edit-panel.tsx +++ b/ui/src/app/settings/components/project-sync-windows-edit-panel/project-sync-windows-edit-panel.tsx @@ -67,6 +67,9 @@ export const ProjectSyncWindowsEditPanel = (props: ProjectSyncWindowsEditPanelPr
+
+ +