diff --git a/USERS.md b/USERS.md index a1b667b2150ca..8ba8600c6a96b 100644 --- a/USERS.md +++ b/USERS.md @@ -105,6 +105,7 @@ Currently, the following organizations are **officially** using Argo CD: 1. [Ibotta](https://home.ibotta.com) 1. [IITS-Consulting](https://iits-consulting.de) 1. [imaware](https://imaware.health) +1. [Indeed](https://indeed.com) 1. [Index Exchange](https://www.indexexchange.com/) 1. [InsideBoard](https://www.insideboard.com) 1. [Intuit](https://www.intuit.com/) diff --git a/applicationset/controllers/applicationset_controller.go b/applicationset/controllers/applicationset_controller.go index 952fae0e60d01..9afc278b35a6c 100644 --- a/applicationset/controllers/applicationset_controller.go +++ b/applicationset/controllers/applicationset_controller.go @@ -25,6 +25,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/intstr" "k8s.io/client-go/kubernetes" "k8s.io/client-go/tools/record" ctrl "sigs.k8s.io/controller-runtime" @@ -69,6 +70,8 @@ type ApplicationSetReconciler struct { KubeClientset kubernetes.Interface utils.Policy utils.Renderer + + EnableProgressiveRollouts bool } // +kubebuilder:rbac:groups=argoproj.io,resources=applicationsets,verbs=get;list;watch;create;update;patch;delete @@ -134,6 +137,27 @@ func (r *ApplicationSetReconciler) Reconcile(ctx context.Context, req ctrl.Reque return ctrl.Result{RequeueAfter: ReconcileRequeueOnValidationError}, nil } + // appMap is a name->app collection of Applications in this ApplicationSet. + appMap := map[string]argov1alpha1.Application{} + // appSyncMap tracks which apps will be synced during this reconciliation. + appSyncMap := map[string]bool{} + + if r.EnableProgressiveRollouts && applicationSetInfo.Spec.Strategy != nil { + applications, err := r.getCurrentApplications(ctx, applicationSetInfo) + if err != nil { + return ctrl.Result{}, fmt.Errorf("failed to get current applications for application set: %w", err) + } + + for _, app := range applications { + appMap[app.Name] = app + } + + appSyncMap, err = r.performProgressiveRollouts(ctx, applicationSetInfo, applications, desiredApplications, appMap) + if err != nil { + return ctrl.Result{}, fmt.Errorf("failed to perform progressive rollouts reconciliation for application set: %w", err) + } + } + var validApps []argov1alpha1.Application for i := range desiredApplications { if validateErrors[i] == nil { @@ -162,6 +186,26 @@ func (r *ApplicationSetReconciler) Reconcile(ctx context.Context, req ctrl.Reque ) } + if r.EnableProgressiveRollouts { + // trigger appropriate application syncs if RollingSync strategy is enabled + if progressiveRolloutStrategyEnabled(&applicationSetInfo, "RollingSync") { + validApps, err = r.syncValidApplications(ctx, &applicationSetInfo, appSyncMap, appMap, validApps) + + if err != nil { + _ = r.setApplicationSetStatusCondition(ctx, + &applicationSetInfo, + argov1alpha1.ApplicationSetCondition{ + Type: argov1alpha1.ApplicationSetConditionErrorOccurred, + Message: err.Error(), + Reason: argov1alpha1.ApplicationSetReasonSyncApplicationError, + Status: argov1alpha1.ApplicationSetConditionStatusTrue, + }, parametersGenerated, + ) + return ctrl.Result{}, err + } + } + } + if r.Policy.Update() { err = r.createOrUpdateInCluster(ctx, applicationSetInfo, validApps) if err != nil { @@ -528,6 +572,11 @@ func (r *ApplicationSetReconciler) createOrUpdateInCluster(ctx context.Context, // Copy only the Application/ObjectMeta fields that are significant, from the generatedApp found.Spec = generatedApp.Spec + // allow setting the Operation field to trigger a sync operation on an Application + if generatedApp.Operation != nil { + found.Operation = generatedApp.Operation + } + // Preserve specially treated argo cd annotations: // * https://github.com/argoproj/applicationset/issues/180 // * https://github.com/argoproj/argo-cd/issues/10500 @@ -726,4 +775,523 @@ func (r *ApplicationSetReconciler) removeFinalizerOnInvalidDestination(ctx conte return nil } +func (r *ApplicationSetReconciler) performProgressiveRollouts(ctx context.Context, appset argov1alpha1.ApplicationSet, applications []argov1alpha1.Application, desiredApplications []argov1alpha1.Application, appMap map[string]argov1alpha1.Application) (map[string]bool, error) { + + _, err := r.updateApplicationSetApplicationStatus(ctx, &appset, applications) + if err != nil { + return nil, fmt.Errorf("failed to update applicationset app status: %w", err) + } + + appDependencyList, appStepMap, err := r.buildAppDependencyList(ctx, appset, desiredApplications) + if err != nil { + return nil, fmt.Errorf("failed to build app dependency list: %w", err) + } + + appSyncMap, err := r.buildAppSyncMap(ctx, appset, appDependencyList, appMap) + if err != nil { + return nil, fmt.Errorf("failed to build app sync map: %w", err) + } + + log.Infof("appSyncMap: %+v", appSyncMap) + + _, err = r.updateApplicationSetApplicationStatusProgress(ctx, &appset, appSyncMap, appStepMap, appMap) + if err != nil { + return nil, fmt.Errorf("failed to update applicationset application status progress: %w", err) + } + + _, err = r.updateApplicationSetApplicationStatusConditions(ctx, &appset) + if err != nil { + return nil, fmt.Errorf("failed to update applicationset application status conditions: %w", err) + } + + return appSyncMap, nil +} + +// this list tracks which Applications belong to each RollingUpdate step +func (r *ApplicationSetReconciler) buildAppDependencyList(ctx context.Context, applicationSet argov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([][]string, map[string]int, error) { + + if applicationSet.Spec.Strategy == nil || applicationSet.Spec.Strategy.Type == "" || applicationSet.Spec.Strategy.Type == "AllAtOnce" { + return [][]string{}, map[string]int{}, nil + } + + steps := []argov1alpha1.ApplicationSetRolloutStep{} + if progressiveRolloutStrategyEnabled(&applicationSet, "RollingSync") { + steps = applicationSet.Spec.Strategy.RollingSync.Steps + } + + appDependencyList := make([][]string, 0) + for range steps { + appDependencyList = append(appDependencyList, make([]string, 0)) + } + + appStepMap := map[string]int{} + + // use applicationLabelSelectors to filter generated Applications into steps and status by name + for _, app := range applications { + for i, step := range steps { + + selected := true // default to true, assuming the current Application is a match for the given step matchExpression + + allNotInMatched := true // needed to support correct AND behavior between multiple NotIn MatchExpressions + notInUsed := false // since we default to allNotInMatched == true, track whether a NotIn expression was actually used + + for _, matchExpression := range step.MatchExpressions { + + if matchExpression.Operator == "In" { + if val, ok := app.Labels[matchExpression.Key]; ok { + valueMatched := labelMatchedExpression(val, matchExpression) + + if !valueMatched { // none of the matchExpression values was a match with the Application'ss labels + selected = false + break + } + } else { + selected = false // no matching label key with In means this Application will not be included in the current step + break + } + } else if matchExpression.Operator == "NotIn" { + notInUsed = true // a NotIn selector was used in this matchExpression + if val, ok := app.Labels[matchExpression.Key]; ok { + valueMatched := labelMatchedExpression(val, matchExpression) + + if !valueMatched { // none of the matchExpression values was a match with the Application's labels + allNotInMatched = false + } + } else { + allNotInMatched = false // no matching label key with NotIn means this Application may still be included in the current step + } + } else { // handle invalid operator selection + log.Warnf("skipping AppSet rollingUpdate step Application selection for %q, invalid matchExpression operator provided: %q ", applicationSet.Name, matchExpression.Operator) + selected = false + break + } + } + + if notInUsed && allNotInMatched { // check if all NotIn Expressions matched, if so exclude this Application + selected = false + } + + if selected { + appDependencyList[i] = append(appDependencyList[i], app.Name) + if val, ok := appStepMap[app.Name]; ok { + log.Warnf("AppSet '%v' has a invalid matchExpression that selects Application '%v' label twice, in steps %v and %v", applicationSet.Name, app.Name, val+1, i+1) + } else { + appStepMap[app.Name] = i + } + } + } + } + + return appDependencyList, appStepMap, nil +} + +func labelMatchedExpression(val string, matchExpression argov1alpha1.ApplicationMatchExpression) bool { + valueMatched := false + for _, value := range matchExpression.Values { + if val == value { + valueMatched = true + break + } + } + return valueMatched +} + +// this map is used to determine which stage of Applications are ready to be updated in the reconciler loop +func (r *ApplicationSetReconciler) buildAppSyncMap(ctx context.Context, applicationSet argov1alpha1.ApplicationSet, appDependencyList [][]string, appMap map[string]argov1alpha1.Application) (map[string]bool, error) { + appSyncMap := map[string]bool{} + syncEnabled := true + + // healthy stages and the first non-healthy stage should have sync enabled + // every stage after should have sync disabled + + for i := range appDependencyList { + // set the syncEnabled boolean for every Application in the current step + for _, appName := range appDependencyList[i] { + appSyncMap[appName] = syncEnabled + } + + // detect if we need to halt before progressing to the next step + for _, appName := range appDependencyList[i] { + + idx := findApplicationStatusIndex(applicationSet.Status.ApplicationStatus, appName) + if idx == -1 { + // no Application status found, likely because the Application is being newly created + syncEnabled = false + break + } + + appStatus := applicationSet.Status.ApplicationStatus[idx] + + if app, ok := appMap[appName]; ok { + + syncEnabled = appSyncEnabledForNextStep(&applicationSet, app, appStatus) + if !syncEnabled { + break + } + } else { + // application name not found in the list of applications managed by this ApplicationSet, maybe because it's being deleted + syncEnabled = false + break + } + } + } + + return appSyncMap, nil +} + +func appSyncEnabledForNextStep(appset *argov1alpha1.ApplicationSet, app argov1alpha1.Application, appStatus argov1alpha1.ApplicationSetApplicationStatus) bool { + + if progressiveRolloutStrategyEnabled(appset, "RollingSync") { + // we still need to complete the current step if the Application is not yet Healthy or there are still pending Application changes + return isApplicationHealthy(app) && appStatus.Status == "Healthy" + } + + return true +} + +func progressiveRolloutStrategyEnabled(appset *argov1alpha1.ApplicationSet, strategyType string) bool { + if appset.Spec.Strategy == nil || appset.Spec.Strategy.Type != strategyType { + return false + } + + if strategyType == "RollingSync" && appset.Spec.Strategy.RollingSync == nil { + return false + } + + return true +} + +func isApplicationHealthy(app argov1alpha1.Application) bool { + healthStatusString, syncStatusString, operationPhaseString := statusStrings(app) + + if healthStatusString == "Healthy" && syncStatusString != "OutOfSync" && (operationPhaseString == "Succeeded" || operationPhaseString == "") { + return true + } + return false +} + +func statusStrings(app argov1alpha1.Application) (string, string, string) { + healthStatusString := string(app.Status.Health.Status) + syncStatusString := string(app.Status.Sync.Status) + operationPhaseString := "" + if app.Status.OperationState != nil { + operationPhaseString = string(app.Status.OperationState.Phase) + } + + return healthStatusString, syncStatusString, operationPhaseString +} + +// check the status of each Application's status and promote Applications to the next status if needed +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatus(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet, applications []argov1alpha1.Application) ([]argov1alpha1.ApplicationSetApplicationStatus, error) { + + now := metav1.Now() + appStatuses := make([]argov1alpha1.ApplicationSetApplicationStatus, 0, len(applications)) + + for _, app := range applications { + + healthStatusString, syncStatusString, operationPhaseString := statusStrings(app) + + idx := findApplicationStatusIndex(applicationSet.Status.ApplicationStatus, app.Name) + + if idx == -1 { + // AppStatus not found, set default status of "Waiting" + appStatuses = append(appStatuses, argov1alpha1.ApplicationSetApplicationStatus{ + Application: app.Name, + LastTransitionTime: &now, + Message: "No Application status found, defaulting status to Waiting.", + Status: "Waiting", + }) + break + } + + // we have an existing AppStatus + currentAppStatus := applicationSet.Status.ApplicationStatus[idx] + + appOutdated := false + if progressiveRolloutStrategyEnabled(applicationSet, "RollingSync") { + appOutdated = syncStatusString == "OutOfSync" + } + + if appOutdated && currentAppStatus.Status != "Waiting" && currentAppStatus.Status != "Pending" { + log.Infof("Application %v is outdated, updating its ApplicationSet status to Waiting", app.Name) + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = "Waiting" + currentAppStatus.Message = "Application has pending changes, setting status to Waiting." + } + + if currentAppStatus.Status == "Pending" { + if healthStatusString == "Progressing" || operationPhaseString == "Running" { + log.Infof("Application %v has entered Progressing status, updating its ApplicationSet status to Progressing", app.Name) + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = "Progressing" + currentAppStatus.Message = "Application resource became Progressing, updating status from Pending to Progressing." + } + } + + if currentAppStatus.Status == "Waiting" && isApplicationHealthy(app) { + log.Infof("Application %v is already synced and healthy, updating its ApplicationSet status to Healthy", app.Name) + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = healthStatusString + currentAppStatus.Message = "Application resource is already Healthy, updating status from Waiting to Healthy." + } + + if currentAppStatus.Status == "Progressing" && isApplicationHealthy(app) { + log.Infof("Application %v has completed Progressing status, updating its ApplicationSet status to Healthy", app.Name) + currentAppStatus.LastTransitionTime = &now + currentAppStatus.Status = healthStatusString + currentAppStatus.Message = "Application resource became Healthy, updating status from Progressing to Healthy." + } + + appStatuses = append(appStatuses, currentAppStatus) + } + + err := r.setAppSetApplicationStatus(ctx, applicationSet, appStatuses) + if err != nil { + return nil, fmt.Errorf("failed to set AppSet application statuses: %w", err) + } + + return appStatuses, nil +} + +// check Applications that are in Waiting status and promote them to Pending if needed +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusProgress(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet, appSyncMap map[string]bool, appStepMap map[string]int, appMap map[string]argov1alpha1.Application) ([]argov1alpha1.ApplicationSetApplicationStatus, error) { + now := metav1.Now() + + appStatuses := make([]argov1alpha1.ApplicationSetApplicationStatus, 0, len(applicationSet.Status.ApplicationStatus)) + + // if we have no RollingUpdate steps, clear out the existing ApplicationStatus entries + if applicationSet.Spec.Strategy != nil && applicationSet.Spec.Strategy.Type != "" && applicationSet.Spec.Strategy.Type != "AllAtOnce" { + updateCountMap := []int{} + totalCountMap := []int{} + + length := 0 + if progressiveRolloutStrategyEnabled(applicationSet, "RollingSync") { + length = len(applicationSet.Spec.Strategy.RollingSync.Steps) + } + for s := 0; s < length; s++ { + updateCountMap = append(updateCountMap, 0) + totalCountMap = append(totalCountMap, 0) + } + + // populate updateCountMap with counts of existing Pending and Progressing Applications + for _, appStatus := range applicationSet.Status.ApplicationStatus { + totalCountMap[appStepMap[appStatus.Application]] += 1 + + if progressiveRolloutStrategyEnabled(applicationSet, "RollingSync") { + if appStatus.Status == "Pending" || appStatus.Status == "Progressing" { + updateCountMap[appStepMap[appStatus.Application]] += 1 + } + } + } + + for _, appStatus := range applicationSet.Status.ApplicationStatus { + + maxUpdateAllowed := true + maxUpdate := &intstr.IntOrString{} + if progressiveRolloutStrategyEnabled(applicationSet, "RollingSync") { + maxUpdate = applicationSet.Spec.Strategy.RollingSync.Steps[appStepMap[appStatus.Application]].MaxUpdate + } + + // by default allow all applications to update if maxUpdate is unset + if maxUpdate != nil { + maxUpdateVal, err := intstr.GetScaledValueFromIntOrPercent(maxUpdate, totalCountMap[appStepMap[appStatus.Application]], false) + if err != nil { + log.Warnf("AppSet '%v' has a invalid maxUpdate value '%+v', ignoring maxUpdate logic for this step: %v", applicationSet.Name, maxUpdate, err) + } + + // ensure that percentage values greater than 0% always result in at least 1 Application being selected + if maxUpdate.Type == intstr.String && maxUpdate.StrVal != "0%" && maxUpdateVal < 1 { + maxUpdateVal = 1 + } + + if updateCountMap[appStepMap[appStatus.Application]] >= maxUpdateVal { + maxUpdateAllowed = false + log.Infof("Application %v is not allowed to update yet, %v/%v Applications already updating in step %v in AppSet %v", appStatus.Application, updateCountMap[appStepMap[appStatus.Application]], maxUpdateVal, appStepMap[appStatus.Application]+1, applicationSet.Name) + } + + } + + if appStatus.Status == "Waiting" && appSyncMap[appStatus.Application] && maxUpdateAllowed { + log.Infof("Application %v moved to Pending status, watching for the Application to start Progressing", appStatus.Application) + appStatus.LastTransitionTime = &now + appStatus.Status = "Pending" + appStatus.Message = "Application moved to Pending status, watching for the Application resource to start Progressing." + + updateCountMap[appStepMap[appStatus.Application]] += 1 + } + + appStatuses = append(appStatuses, appStatus) + } + } + + err := r.setAppSetApplicationStatus(ctx, applicationSet, appStatuses) + if err != nil { + return nil, fmt.Errorf("failed to set AppSet app status: %w", err) + } + + return appStatuses, nil +} + +func (r *ApplicationSetReconciler) updateApplicationSetApplicationStatusConditions(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet) ([]argov1alpha1.ApplicationSetCondition, error) { + + appSetProgressing := false + for _, appStatus := range applicationSet.Status.ApplicationStatus { + if appStatus.Status != "Healthy" { + appSetProgressing = true + break + } + } + + appSetConditionProgressing := false + for _, appSetCondition := range applicationSet.Status.Conditions { + if appSetCondition.Type == argov1alpha1.ApplicationSetConditionRolloutProgressing && appSetCondition.Status == argov1alpha1.ApplicationSetConditionStatusTrue { + appSetConditionProgressing = true + break + } + } + + if appSetProgressing && !appSetConditionProgressing { + _ = r.setApplicationSetStatusCondition(ctx, + applicationSet, + argov1alpha1.ApplicationSetCondition{ + Type: argov1alpha1.ApplicationSetConditionRolloutProgressing, + Message: "ApplicationSet Rollout Rollout started", + Reason: argov1alpha1.ApplicationSetReasonApplicationSetModified, + Status: argov1alpha1.ApplicationSetConditionStatusTrue, + }, false, + ) + } else if !appSetProgressing && appSetConditionProgressing { + _ = r.setApplicationSetStatusCondition(ctx, + applicationSet, + argov1alpha1.ApplicationSetCondition{ + Type: argov1alpha1.ApplicationSetConditionRolloutProgressing, + Message: "ApplicationSet Rollout Rollout complete", + Reason: argov1alpha1.ApplicationSetReasonApplicationSetRolloutComplete, + Status: argov1alpha1.ApplicationSetConditionStatusFalse, + }, false, + ) + } + + return applicationSet.Status.Conditions, nil +} + +func findApplicationStatusIndex(appStatuses []argov1alpha1.ApplicationSetApplicationStatus, application string) int { + for i := range appStatuses { + if appStatuses[i].Application == application { + return i + } + } + return -1 +} + +// setApplicationSetApplicationStatus updates the ApplicatonSet's status field +// with any new/changed Application statuses. +func (r *ApplicationSetReconciler) setAppSetApplicationStatus(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet, applicationStatuses []argov1alpha1.ApplicationSetApplicationStatus) error { + needToUpdateStatus := false + for i := range applicationStatuses { + appStatus := applicationStatuses[i] + idx := findApplicationStatusIndex(applicationSet.Status.ApplicationStatus, appStatus.Application) + if idx == -1 { + needToUpdateStatus = true + break + } + currentStatus := applicationSet.Status.ApplicationStatus[idx] + if currentStatus.Message != appStatus.Message || currentStatus.Status != appStatus.Status { + needToUpdateStatus = true + break + } + } + + if needToUpdateStatus { + // fetch updated Application Set object before updating it + namespacedName := types.NamespacedName{Namespace: applicationSet.Namespace, Name: applicationSet.Name} + if err := r.Get(ctx, namespacedName, applicationSet); err != nil { + if client.IgnoreNotFound(err) != nil { + return nil + } + return fmt.Errorf("error fetching updated application set: %v", err) + } + + for i := range applicationStatuses { + applicationSet.Status.SetApplicationStatus(applicationStatuses[i]) + } + + // Update the newly fetched object with new set of ApplicationStatus + err := r.Client.Status().Update(ctx, applicationSet) + if err != nil { + + log.Errorf("unable to set application set status: %v", err) + return fmt.Errorf("unable to set application set status: %v", err) + } + + if err := r.Get(ctx, namespacedName, applicationSet); err != nil { + if client.IgnoreNotFound(err) != nil { + return nil + } + return fmt.Errorf("error fetching updated application set: %v", err) + } + } + + return nil +} + +func (r *ApplicationSetReconciler) syncValidApplications(ctx context.Context, applicationSet *argov1alpha1.ApplicationSet, appSyncMap map[string]bool, appMap map[string]argov1alpha1.Application, validApps []argov1alpha1.Application) ([]argov1alpha1.Application, error) { + rolloutApps := []argov1alpha1.Application{} + for i := range validApps { + pruneEnabled := false + + // ensure that Applications generated with RollingSync do not have an automated sync policy, since the AppSet controller will handle triggering the sync operation instead + if validApps[i].Spec.SyncPolicy != nil && validApps[i].Spec.SyncPolicy.Automated != nil { + pruneEnabled = validApps[i].Spec.SyncPolicy.Automated.Prune + validApps[i].Spec.SyncPolicy.Automated = nil + } + + appSetStatusPending := false + idx := findApplicationStatusIndex(applicationSet.Status.ApplicationStatus, validApps[i].Name) + if idx > -1 && applicationSet.Status.ApplicationStatus[idx].Status == "Pending" { + // only trigger a sync for Applications that are in Pending status, since this is governed by maxUpdate + appSetStatusPending = true + } + + // check appSyncMap to determine which Applications are ready to be updated and which should be skipped + if appSyncMap[validApps[i].Name] && appMap[validApps[i].Name].Status.Sync.Status == "OutOfSync" && appSetStatusPending { + log.Infof("triggering sync for application: %v, prune enabled: %v", validApps[i].Name, pruneEnabled) + validApps[i], _ = syncApplication(validApps[i], pruneEnabled) + } + rolloutApps = append(rolloutApps, validApps[i]) + } + return rolloutApps, nil +} + +// used by the RollingSync Progressive Rollout strategy to trigger a sync of a particular Application resource +func syncApplication(application argov1alpha1.Application, prune bool) (argov1alpha1.Application, error) { + + operation := argov1alpha1.Operation{ + InitiatedBy: argov1alpha1.OperationInitiator{ + Username: "applicationset-controller", + Automated: true, + }, + Info: []*argov1alpha1.Info{ + { + Name: "Reason", + Value: "ApplicationSet RollingSync triggered a sync of this Application resource.", + }, + }, + Sync: &argov1alpha1.SyncOperation{}, + } + + if application.Spec.SyncPolicy != nil { + if application.Spec.SyncPolicy.Retry != nil { + operation.Retry = *application.Spec.SyncPolicy.Retry + } + if application.Spec.SyncPolicy.SyncOptions != nil { + operation.Sync.SyncOptions = application.Spec.SyncPolicy.SyncOptions + } + operation.Sync.Prune = prune + } + application.Operation = &operation + + return application, nil +} + var _ handler.EventHandler = &clusterSecretEventHandler{} diff --git a/applicationset/controllers/applicationset_controller_test.go b/applicationset/controllers/applicationset_controller_test.go index 852c1da0c91d6..38b25e8eac4e6 100644 --- a/applicationset/controllers/applicationset_controller_test.go +++ b/applicationset/controllers/applicationset_controller_test.go @@ -17,6 +17,7 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/types" + "k8s.io/apimachinery/pkg/util/intstr" kubefake "k8s.io/client-go/kubernetes/fake" "k8s.io/client-go/tools/record" ctrl "sigs.k8s.io/controller-runtime" @@ -26,6 +27,8 @@ import ( "github.com/argoproj/argo-cd/v2/applicationset/generators" "github.com/argoproj/argo-cd/v2/applicationset/utils" + "github.com/argoproj/gitops-engine/pkg/health" + "github.com/argoproj/gitops-engine/pkg/sync/common" "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" argov1alpha1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" @@ -2197,3 +2200,2432 @@ func TestPolicies(t *testing.T) { }) } } + +func TestSetApplicationSetApplicationStatus(t *testing.T) { + scheme := runtime.NewScheme() + err := argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + appSet := argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Generators: []argov1alpha1.ApplicationSetGenerator{ + {List: &argov1alpha1.ListGenerator{ + Elements: []apiextensionsv1.JSON{{ + Raw: []byte(`{"cluster": "my-cluster","url": "https://kubernetes.default.svc"}`), + }}, + }}, + }, + Template: argov1alpha1.ApplicationSetTemplate{}, + }, + } + + appStatuses := []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "my-application", + LastTransitionTime: &metav1.Time{}, + Message: "testing SetApplicationSetApplicationStatus to Healthy", + Status: "Healthy", + }, + } + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(&appSet).Build() + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Renderer: &utils.Render{}, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{ + "List": generators.NewListGenerator(), + }, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + err = r.setAppSetApplicationStatus(context.TODO(), &appSet, appStatuses) + assert.Nil(t, err) + + assert.Len(t, appSet.Status.ApplicationStatus, 1) +} + +func TestBuildAppDependencyList(t *testing.T) { + + scheme := runtime.NewScheme() + err := argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + client := fake.NewClientBuilder().WithScheme(scheme).Build() + + for _, cc := range []struct { + name string + appSet argov1alpha1.ApplicationSet + apps []argov1alpha1.Application + expectedList [][]string + expectedStepMap map[string]int + }{ + { + name: "handles an empty set of applications and no strategy", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{}, + }, + apps: []argov1alpha1.Application{}, + expectedList: [][]string{}, + expectedStepMap: map[string]int{}, + }, + { + name: "handles an empty set of applications and ignores AllAtOnce strategy", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "AllAtOnce", + }, + }, + }, + apps: []argov1alpha1.Application{}, + expectedList: [][]string{}, + expectedStepMap: map[string]int{}, + }, + { + name: "handles an empty set of applications with good 'In' selectors", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "dev", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{}, + expectedList: [][]string{ + {}, + }, + expectedStepMap: map[string]int{}, + }, + { + name: "handles selecting 1 application with 1 'In' selector", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "dev", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-dev"}, + }, + expectedStepMap: map[string]int{ + "app-dev": 0, + }, + }, + { + name: "handles 'In' selectors that select no applications", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "dev", + }, + }, + }, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "qa", + }, + }, + }, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "prod", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-prod", + Labels: map[string]string{ + "env": "prod", + }, + }, + }, + }, + expectedList: [][]string{ + {}, + {"app-qa"}, + {"app-prod"}, + }, + expectedStepMap: map[string]int{ + "app-qa": 1, + "app-prod": 2, + }, + }, + { + name: "multiple 'In' selectors in the same matchExpression only select Applications that match all selectors", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "region", + Operator: "In", + Values: []string{ + "us-east-2", + }, + }, + { + Key: "env", + Operator: "In", + Values: []string{ + "qa", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa1", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa2", + Labels: map[string]string{ + "env": "qa", + "region": "us-east-2", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-qa2"}, + }, + expectedStepMap: map[string]int{ + "app-qa2": 0, + }, + }, + { + name: "multiple values in the same 'In' matchExpression can match on any value", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "qa", + "prod", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-prod", + Labels: map[string]string{ + "env": "prod", + "region": "us-east-2", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-qa", "app-prod"}, + }, + expectedStepMap: map[string]int{ + "app-qa": 0, + "app-prod": 0, + }, + }, + { + name: "handles an empty set of applications with good 'NotIn' selectors", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "dev", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{}, + expectedList: [][]string{ + {}, + }, + expectedStepMap: map[string]int{}, + }, + { + name: "selects 1 application with 1 'NotIn' selector", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "NotIn", + Values: []string{ + "qa", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-dev"}, + }, + expectedStepMap: map[string]int{ + "app-dev": 0, + }, + }, + { + name: "'NotIn' selectors that select no applications", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "NotIn", + Values: []string{ + "dev", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-prod", + Labels: map[string]string{ + "env": "prod", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-qa", "app-prod"}, + }, + expectedStepMap: map[string]int{ + "app-qa": 0, + "app-prod": 0, + }, + }, + { + name: "multiple 'NotIn' selectors only match Applications with all labels", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "region", + Operator: "NotIn", + Values: []string{ + "us-east-2", + }, + }, + { + Key: "env", + Operator: "NotIn", + Values: []string{ + "qa", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa1", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa2", + Labels: map[string]string{ + "env": "qa", + "region": "us-east-2", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-qa1"}, + }, + expectedStepMap: map[string]int{ + "app-qa1": 0, + }, + }, + { + name: "multiple values in the same 'NotIn' matchExpression exclude a match from any value", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "NotIn", + Values: []string{ + "qa", + "prod", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa", + Labels: map[string]string{ + "env": "qa", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-prod", + Labels: map[string]string{ + "env": "prod", + "region": "us-east-2", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-dev"}, + }, + expectedStepMap: map[string]int{ + "app-dev": 0, + }, + }, + { + name: "in a mix of 'In' and 'NotIn' selectors, 'NotIn' takes precedence", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{ + { + Key: "env", + Operator: "In", + Values: []string{ + "qa", + "prod", + }, + }, + { + Key: "region", + Operator: "NotIn", + Values: []string{ + "us-west-2", + }, + }, + }, + }, + }, + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-dev", + Labels: map[string]string{ + "env": "dev", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa1", + Labels: map[string]string{ + "env": "qa", + "region": "us-west-2", + }, + }, + }, + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app-qa2", + Labels: map[string]string{ + "env": "qa", + "region": "us-east-2", + }, + }, + }, + }, + expectedList: [][]string{ + {"app-qa2"}, + }, + expectedStepMap: map[string]int{ + "app-qa2": 0, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appDependencyList, appStepMap, err := r.buildAppDependencyList(context.TODO(), cc.appSet, cc.apps) + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedList, appDependencyList, "expected appDependencyList did not match actual") + assert.Equal(t, cc.expectedStepMap, appStepMap, "expected appStepMap did not match actual") + }) + } +} + +func TestBuildAppSyncMap(t *testing.T) { + + scheme := runtime.NewScheme() + err := argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + client := fake.NewClientBuilder().WithScheme(scheme).Build() + + for _, cc := range []struct { + name string + appSet argov1alpha1.ApplicationSet + appMap map[string]argov1alpha1.Application + appDependencyList [][]string + expectedMap map[string]bool + }{ + { + name: "handles an empty app dependency list", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + }, + appDependencyList: [][]string{}, + expectedMap: map[string]bool{}, + }, + { + name: "handles two applications with no statuses", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles applications after an empty selection", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + }, + appDependencyList: [][]string{ + {}, + {"app1", "app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": true, + }, + }, + { + name: "handles RollingSync applications that are healthy and have no changes", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Status: "Healthy", + }, + { + Application: "app2", + Status: "Healthy", + }, + }, + }, + }, + appMap: map[string]argov1alpha1.Application{ + "app1": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app2": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app2", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": true, + }, + }, + { + name: "blocks RollingSync applications that are healthy and have no changes, but are still pending", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Status: "Pending", + }, + { + Application: "app2", + Status: "Healthy", + }, + }, + }, + }, + appMap: map[string]argov1alpha1.Application{ + "app1": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app2": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app2", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles RollingSync applications that are up to date and healthy, but still syncing", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Status: "Progressing", + }, + { + Application: "app2", + Status: "Progressing", + }, + }, + }, + }, + appMap: map[string]argov1alpha1.Application{ + "app1": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationRunning, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app2": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app2", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationRunning, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles RollingSync applications that are up to date and synced, but degraded", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Status: "Progressing", + }, + { + Application: "app2", + Status: "Progressing", + }, + }, + }, + }, + appMap: map[string]argov1alpha1.Application{ + "app1": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusDegraded, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationRunning, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app2": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app2", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusDegraded, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationRunning, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles RollingSync applications that are OutOfSync and healthy", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Status: "Healthy", + }, + { + Application: "app2", + Status: "Healthy", + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1"}, + {"app2"}, + }, + appMap: map[string]argov1alpha1.Application{ + "app1": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeOutOfSync, + }, + }, + }, + "app2": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app2", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeOutOfSync, + }, + }, + }, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": false, + }, + }, + { + name: "handles a lot of applications", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Status: "Healthy", + }, + { + Application: "app2", + Status: "Healthy", + }, + { + Application: "app3", + Status: "Healthy", + }, + { + Application: "app4", + Status: "Healthy", + }, + { + Application: "app5", + Status: "Healthy", + }, + { + Application: "app7", + Status: "Healthy", + }, + }, + }, + }, + appMap: map[string]argov1alpha1.Application{ + "app1": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app2": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app2", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app3": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app3", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app5": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app5", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + "app6": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app6", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusDegraded, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + appDependencyList: [][]string{ + {"app1", "app2", "app3"}, + {"app4", "app5", "app6"}, + {"app7", "app8", "app9"}, + }, + expectedMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + "app4": true, + "app5": true, + "app6": true, + "app7": false, + "app8": false, + "app9": false, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appSyncMap, err := r.buildAppSyncMap(context.TODO(), cc.appSet, cc.appDependencyList, cc.appMap) + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedMap, appSyncMap, "expected appSyncMap did not match actual") + }) + } +} + +func TestUpdateApplicationSetApplicationStatus(t *testing.T) { + + scheme := runtime.NewScheme() + err := argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + for _, cc := range []struct { + name string + appSet argov1alpha1.ApplicationSet + apps []argov1alpha1.Application + expectedAppStatus []argov1alpha1.ApplicationSetApplicationStatus + }{ + { + name: "handles a nil list of statuses and no applications", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + }, + apps: []argov1alpha1.Application{}, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles a nil list of statuses with a healthy application", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "No Application status found, defaulting status to Waiting.", + Status: "Waiting", + }, + }, + }, + { + name: "handles an empty list of statuses with a healthy application", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{}, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "No Application status found, defaulting status to Waiting.", + Status: "Waiting", + }, + }, + }, + { + name: "progresses an OutOfSync RollingSync application to waiting", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + Status: "Healthy", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeOutOfSync, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application has pending changes, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + { + name: "progresses a pending progressing application to progressing", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + Status: "Pending", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusProgressing, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + Status: "Progressing", + }, + }, + }, + { + name: "progresses a pending syncing application to progressing", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + Status: "Pending", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationRunning, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + Status: "Progressing", + }, + }, + }, + { + name: "progresses a progressing application to healthy", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + Status: "Progressing", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource became Healthy, updating status from Progressing to Healthy.", + Status: "Healthy", + }, + }, + }, + { + name: "progresses a waiting healthy application to healthy", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{}, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "", + Status: "Waiting", + }, + }, + }, + }, + apps: []argov1alpha1.Application{ + { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Health: argov1alpha1.HealthStatus{ + Status: health.HealthStatusHealthy, + }, + OperationState: &argov1alpha1.OperationState{ + Phase: common.OperationSucceeded, + }, + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeSynced, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource is already Healthy, updating status from Waiting to Healthy.", + Status: "Healthy", + }, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(&cc.appSet).Build() + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appStatuses, err := r.updateApplicationSetApplicationStatus(context.TODO(), &cc.appSet, cc.apps) + + // opt out of testing the LastTransitionTime is accurate + for i := range appStatuses { + appStatuses[i].LastTransitionTime = nil + } + + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedAppStatus, appStatuses, "expected appStatuses did not match actual") + }) + } +} + +func TestUpdateApplicationSetApplicationStatusProgress(t *testing.T) { + + scheme := runtime.NewScheme() + err := argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + err = argov1alpha1.AddToScheme(scheme) + assert.Nil(t, err) + + for _, cc := range []struct { + name string + appSet argov1alpha1.ApplicationSet + appSyncMap map[string]bool + appStepMap map[string]int + appMap map[string]argov1alpha1.Application + expectedAppStatus []argov1alpha1.ApplicationSetApplicationStatus + }{ + { + name: "handles an empty appSync and appStepMap", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{}, + appStepMap: map[string]int{}, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles an empty strategy", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{}, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{}, + appStepMap: map[string]int{}, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles an empty applicationset strategy", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{}, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{}, + appStepMap: map[string]int{}, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles an appSyncMap with no existing statuses", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": false, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 1, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{}, + }, + { + name: "handles updating a RollingSync status from Waiting to Pending", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + }, + appStepMap: map[string]int{ + "app1": 0, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + }, + }, + { + name: "does not update a RollingSync status if appSyncMap is false", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": false, + }, + appStepMap: map[string]int{ + "app1": 0, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + { + name: "does not update a status if status is not pending", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", + Status: "Healthy", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + }, + appStepMap: map[string]int{ + "app1": 0, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application Pending status timed out while waiting to become Progressing, reset status to Healthy.", + Status: "Healthy", + }, + }, + }, + { + name: "does not update a status if maxUpdate has already been reached with RollingSync", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + MaxUpdate: &intstr.IntOrString{ + Type: intstr.Int, + IntVal: 3, + }, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + Status: "Progressing", + }, + { + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app4", + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + "app4": true, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 0, + "app3": 0, + "app4": 0, + }, + appMap: map[string]argov1alpha1.Application{ + "app1": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app1", + }, + Status: argov1alpha1.ApplicationStatus{ + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeOutOfSync, + }, + }, + }, + "app2": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app2", + }, + Status: argov1alpha1.ApplicationStatus{ + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeOutOfSync, + }, + }, + }, + "app3": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app3", + }, + Status: argov1alpha1.ApplicationStatus{ + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeOutOfSync, + }, + }, + }, + "app4": { + ObjectMeta: metav1.ObjectMeta{ + Name: "app4", + }, + Status: argov1alpha1.ApplicationStatus{ + Sync: argov1alpha1.SyncStatus{ + Status: argov1alpha1.SyncStatusCodeOutOfSync, + }, + }, + }, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application resource became Progressing, updating status from Pending to Progressing.", + Status: "Progressing", + }, + { + Application: "app2", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + { + Application: "app3", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app4", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + }, + }, + { + name: "rounds down for maxUpdate set to percentage string", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + MaxUpdate: &intstr.IntOrString{ + Type: intstr.String, + StrVal: "50%", + }, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 0, + "app3": 0, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + { + Application: "app2", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + { + name: "does not update any applications with maxUpdate set to 0", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + MaxUpdate: &intstr.IntOrString{ + Type: intstr.Int, + IntVal: 0, + }, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 0, + "app3": 0, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app2", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + { + name: "updates all applications with maxUpdate set to 100%", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + MaxUpdate: &intstr.IntOrString{ + Type: intstr.String, + StrVal: "100%", + }, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 0, + "app3": 0, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + { + Application: "app2", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + { + Application: "app3", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + }, + }, + { + name: "updates at least 1 application with maxUpdate >0%", + appSet: argov1alpha1.ApplicationSet{ + ObjectMeta: metav1.ObjectMeta{ + Name: "name", + Namespace: "argocd", + }, + Spec: argov1alpha1.ApplicationSetSpec{ + Strategy: &argov1alpha1.ApplicationSetStrategy{ + Type: "RollingSync", + RollingSync: &argov1alpha1.ApplicationSetRolloutStrategy{ + Steps: []argov1alpha1.ApplicationSetRolloutStep{ + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + MaxUpdate: &intstr.IntOrString{ + Type: intstr.String, + StrVal: "1%", + }, + }, + { + MatchExpressions: []argov1alpha1.ApplicationMatchExpression{}, + }, + }, + }, + }, + }, + Status: argov1alpha1.ApplicationSetStatus{ + ApplicationStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app2", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + }, + appSyncMap: map[string]bool{ + "app1": true, + "app2": true, + "app3": true, + }, + appStepMap: map[string]int{ + "app1": 0, + "app2": 0, + "app3": 0, + }, + expectedAppStatus: []argov1alpha1.ApplicationSetApplicationStatus{ + { + Application: "app1", + LastTransitionTime: nil, + Message: "Application moved to Pending status, watching for the Application resource to start Progressing.", + Status: "Pending", + }, + { + Application: "app2", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + { + Application: "app3", + LastTransitionTime: nil, + Message: "Application is out of date with the current AppSet generation, setting status to Waiting.", + Status: "Waiting", + }, + }, + }, + } { + + t.Run(cc.name, func(t *testing.T) { + + kubeclientset := kubefake.NewSimpleClientset([]runtime.Object{}...) + argoDBMock := dbmocks.ArgoDB{} + argoObjs := []runtime.Object{} + + client := fake.NewClientBuilder().WithScheme(scheme).WithObjects(&cc.appSet).Build() + + r := ApplicationSetReconciler{ + Client: client, + Scheme: scheme, + Recorder: record.NewFakeRecorder(1), + Generators: map[string]generators.Generator{}, + ArgoDB: &argoDBMock, + ArgoAppClientset: appclientset.NewSimpleClientset(argoObjs...), + KubeClientset: kubeclientset, + } + + appStatuses, err := r.updateApplicationSetApplicationStatusProgress(context.TODO(), &cc.appSet, cc.appSyncMap, cc.appStepMap, cc.appMap) + + // opt out of testing the LastTransitionTime is accurate + for i := range appStatuses { + appStatuses[i].LastTransitionTime = nil + } + + assert.Equal(t, err, nil, "expected no errors, but errors occured") + assert.Equal(t, cc.expectedAppStatus, appStatuses, "expected appStatuses did not match actual") + }) + } +} diff --git a/assets/swagger.json b/assets/swagger.json index fc3874d20bc45..bd38517972ded 100644 --- a/assets/swagger.json +++ b/assets/swagger.json @@ -4362,6 +4362,24 @@ "type": "object", "title": "Generic (empty) response for GPG public key CRUD requests" }, + "intstrIntOrString": { + "description": "+protobuf=true\n+protobuf.options.(gogoproto.goproto_stringer)=false\n+k8s:openapi-gen=true", + "type": "object", + "title": "IntOrString is a type that can hold an int32 or a string. When used in\nJSON or YAML marshalling and unmarshalling, it produces or consumes the\ninner type. This allows you to have, for example, a JSON field that can\naccept a name or number.\nTODO: Rename to Int32OrString", + "properties": { + "intVal": { + "type": "integer", + "format": "int32" + }, + "strVal": { + "type": "string" + }, + "type": { + "type": "string", + "format": "int64" + } + } + }, "notificationService": { "type": "object", "properties": { @@ -5600,6 +5618,23 @@ } } }, + "v1alpha1ApplicationMatchExpression": { + "type": "object", + "properties": { + "key": { + "type": "string" + }, + "operator": { + "type": "string" + }, + "values": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, "v1alpha1ApplicationSet": { "type": "object", "title": "ApplicationSet is a set of Application resources\n+genclient\n+genclient:noStatus\n+k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object\n+kubebuilder:resource:path=applicationsets,shortName=appset;appsets\n+kubebuilder:subresource:status", @@ -5615,6 +5650,27 @@ } } }, + "v1alpha1ApplicationSetApplicationStatus": { + "type": "object", + "title": "ApplicationSetApplicationStatus contains details about each Application managed by the ApplicationSet", + "properties": { + "application": { + "type": "string", + "title": "Application contains the name of the Application resource" + }, + "lastTransitionTime": { + "$ref": "#/definitions/v1Time" + }, + "message": { + "type": "string", + "title": "Message contains human-readable message indicating details about the status" + }, + "status": { + "type": "string", + "title": "Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy)" + } + } + }, "v1alpha1ApplicationSetCondition": { "type": "object", "title": "ApplicationSetCondition contains details about an applicationset condition, which is usally an error or warning", @@ -5721,6 +5777,31 @@ } } }, + "v1alpha1ApplicationSetRolloutStep": { + "type": "object", + "properties": { + "matchExpressions": { + "type": "array", + "items": { + "$ref": "#/definitions/v1alpha1ApplicationMatchExpression" + } + }, + "maxUpdate": { + "$ref": "#/definitions/intstrIntOrString" + } + } + }, + "v1alpha1ApplicationSetRolloutStrategy": { + "type": "object", + "properties": { + "steps": { + "type": "array", + "items": { + "$ref": "#/definitions/v1alpha1ApplicationSetRolloutStep" + } + } + } + }, "v1alpha1ApplicationSetSpec": { "description": "ApplicationSetSpec represents a class of application set state.", "type": "object", @@ -5734,6 +5815,9 @@ "goTemplate": { "type": "boolean" }, + "strategy": { + "$ref": "#/definitions/v1alpha1ApplicationSetStrategy" + }, "syncPolicy": { "$ref": "#/definitions/v1alpha1ApplicationSetSyncPolicy" }, @@ -5746,6 +5830,12 @@ "type": "object", "title": "ApplicationSetStatus defines the observed state of ApplicationSet", "properties": { + "applicationStatus": { + "type": "array", + "items": { + "$ref": "#/definitions/v1alpha1ApplicationSetApplicationStatus" + } + }, "conditions": { "type": "array", "title": "INSERT ADDITIONAL STATUS FIELD - define observed state of cluster\nImportant: Run \"make\" to regenerate code after modifying this file", @@ -5755,6 +5845,18 @@ } } }, + "v1alpha1ApplicationSetStrategy": { + "description": "ApplicationSetStrategy configures how generated Applications are updated in sequence.", + "type": "object", + "properties": { + "rollingSync": { + "$ref": "#/definitions/v1alpha1ApplicationSetRolloutStrategy" + }, + "type": { + "type": "string" + } + } + }, "v1alpha1ApplicationSetSyncPolicy": { "description": "ApplicationSetSyncPolicy configures how generated Applications will relate to their\nApplicationSet.", "type": "object", diff --git a/cmd/argocd-applicationset-controller/commands/applicationset_controller.go b/cmd/argocd-applicationset-controller/commands/applicationset_controller.go index d259e973db738..1e7656f8cb66a 100644 --- a/cmd/argocd-applicationset-controller/commands/applicationset_controller.go +++ b/cmd/argocd-applicationset-controller/commands/applicationset_controller.go @@ -46,16 +46,17 @@ func getSubmoduleEnabled() bool { func NewCommand() *cobra.Command { var ( - clientConfig clientcmd.ClientConfig - metricsAddr string - probeBindAddr string - webhookAddr string - enableLeaderElection bool - namespace string - argocdRepoServer string - policy string - debugLog bool - dryRun bool + clientConfig clientcmd.ClientConfig + metricsAddr string + probeBindAddr string + webhookAddr string + enableLeaderElection bool + namespace string + argocdRepoServer string + policy string + debugLog bool + dryRun bool + enableProgressiveRollouts bool ) scheme := runtime.NewScheme() _ = clientgoscheme.AddToScheme(scheme) @@ -168,15 +169,16 @@ func NewCommand() *cobra.Command { go func() { errors.CheckError(askPassServer.Run(askpass.SocketPath)) }() if err = (&controllers.ApplicationSetReconciler{ - Generators: topLevelGenerators, - Client: mgr.GetClient(), - Scheme: mgr.GetScheme(), - Recorder: mgr.GetEventRecorderFor("applicationset-controller"), - Renderer: &utils.Render{}, - Policy: policyObj, - ArgoAppClientset: appSetConfig, - KubeClientset: k8sClient, - ArgoDB: argoCDDB, + Generators: topLevelGenerators, + Client: mgr.GetClient(), + Scheme: mgr.GetScheme(), + Recorder: mgr.GetEventRecorderFor("applicationset-controller"), + Renderer: &utils.Render{}, + Policy: policyObj, + ArgoAppClientset: appSetConfig, + KubeClientset: k8sClient, + ArgoDB: argoCDDB, + EnableProgressiveRollouts: enableProgressiveRollouts, }).SetupWithManager(mgr); err != nil { log.Error(err, "unable to create controller", "controller", "ApplicationSet") os.Exit(1) @@ -205,6 +207,7 @@ func NewCommand() *cobra.Command { command.Flags().StringVar(&cmdutil.LogFormat, "logformat", env.StringFromEnv("ARGOCD_APPLICATIONSET_CONTROLLER_LOGFORMAT", "text"), "Set the logging format. One of: text|json") command.Flags().StringVar(&cmdutil.LogLevel, "loglevel", env.StringFromEnv("ARGOCD_APPLICATIONSET_CONTROLLER_LOGLEVEL", "info"), "Set the logging level. One of: debug|info|warn|error") command.Flags().BoolVar(&dryRun, "dry-run", env.ParseBoolFromEnv("ARGOCD_APPLICATIONSET_CONTROLLER_DRY_RUN", false), "Enable dry run mode") + command.Flags().BoolVar(&enableProgressiveRollouts, "enable-progressive-rollouts", env.ParseBoolFromEnv("ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS", false), "Enable use of the experimental progressive rollouts feature.") return &command } diff --git a/docs/operator-manual/applicationset/Progressive-Rollouts.md b/docs/operator-manual/applicationset/Progressive-Rollouts.md new file mode 100644 index 0000000000000..c993dd8d44b3d --- /dev/null +++ b/docs/operator-manual/applicationset/Progressive-Rollouts.md @@ -0,0 +1,109 @@ +# Progressive Rollouts + +!!! warning "Alpha Feature" + This is an experimental, alpha-quality feature that allows you to control the order in which the ApplicationSet controller will create or update the Applications owned by an ApplicationSet resource. It may be removed in future releases or modified in backwards-incompatible ways. + +## Use Cases +The Progressive Rollouts feature set is intended to be light and flexible. The feature only interacts with the health of managed Applications. It is not intended to support direct integrations with other Rollout controllers (such as the native ReplicaSet controller or Argo Rollouts). + +* Progressive Rollouts watch for the managed Application resources to become "Healthy" before proceeding to the next stage. +* Deployments, DaemonSets, StatefulSets, and [Argo Rollouts](https://argoproj.github.io/argo-rollouts/) are all supported, because the Application enters a "Progressing" state while pods are being rolled out. In fact, any resource with a health check that can report a "Progressing" status is supported. +* [Argo CD Resource Hooks](../../user-guide/resource_hooks.md) are supported. We recommend this approach for users that need advanced functionality when an Argo Rollout cannot be used, such as smoke testing after a DaemonSet change. + +## Enabling Progressive Rollouts +As an experimental feature, progressive rollouts must be explicitly enabled, in one of these ways. +1. Pass `--enable-progressive-rollouts` to the ApplicationSet controller args. +1. Set `ARGOCD_APPLICATIONSET_ENABLE_PROGRESSIVE_ROLLOUTS=true` in the ApplicationSet controller environment variables. +1. Set `applicationsetcontroller.enable.progressive.rollouts: true` in the ArgoCD ConfigMap. + +## Strategies + +* AllAtOnce (default) +* RollingSync + +### AllAtOnce +This default Application update behavior is unchanged from the original ApplicationSet implementation. + +All Applications managed by the ApplicationSet resource are updated simultaneously when the ApplicationSet is updated. + +### RollingSync +This update strategy allows you to group Applications by labels present on the generated Application resources. +When the ApplicationSet changes, the changes will be applied to each group of Application resources sequentially. + +* Application groups are selected by `matchExpressions`. +* All `matchExpressions` must be true for an Application to be selected (multiple expressions match with AND behavior). +* The `In` and `NotIn` operators must match at least one value to be considered true (OR behavior). +* The `NotIn` operatorn has priority in the event that both a `NotIn` and `In` operator produce a match. +* All Applications in each group must become Healthy before the ApplicationSet controller will proceed to update the next group of Applications. +* The number of simultaneous Application updates in a group will not exceed its `maxUpdate` parameter (default is 100%, unbounded). +* RollingSync will capture external changes outside the ApplicationSet resource, since it relies on watching the OutOfSync status of the managed Applications. +* RollingSync will force all generated Applications to have autosync disabled. Warnings are printed in the applicationset-controller logs for any Application specs with an automated syncPolicy enabled. +* Sync operations are triggered the same way as if they were triggered by the UI or CLI (by directly setting the `operation` status field on the Application resource). This means that a RollingSync will respect sync windows just as if a user had clicked the "Sync" button in the Argo UI. +* When a sync is triggered, the sync is performed with the same syncPolicy configured for the Application. For example, this preserves the Application's retry settings. +* If an Application is considered "Pending" for `applicationsetcontroller.default.application.progressing.timeout` seconds, the Application is automatically moved to Healthy status (default 300). + +#### Example +The following example illustrates how to stage a progressive rollout over Applications with explicitly configured environment labels. + +Once a change is pushed, the following will happen in order. +* All `env-dev` Applications will be updated simultaneously. +* The rollout will wait for all `env-qa` Applications to be manually synced via the `argocd` CLI or by clicking the Sync button in the UI. +* 10% of all `env-prod` Applications will be updated at a time until all `env-prod` Applications have been updated. + +``` +--- +apiVersion: argoproj.io/v1alpha1 +kind: ApplicationSet +metadata: + name: guestbook +spec: + generators: + - list: + elements: + - cluster: engineering-dev + url: https://1.2.3.4 + env: env-dev + - cluster: engineering-qa + url: https://2.4.6.8 + env: env-qa + - cluster: engineering-prod + url: https://9.8.7.6/ + env: env-prod + strategy: + type: RollingSync + rollingSync: + steps: + - matchExpressions: + - key: env + operator: In + values: + - env-dev + #maxUpdate: 100% # if undefined, all applications matched are updated together (default is 100%) + - matchExpressions: + - key: env + operator: In + values: + - env-qa + maxUpdate: 0 # if 0, no matched applications will be updated + - matchExpressions: + - key: env + operator: In + values: + - env-prod + maxUpdate: 10% # maxUpdate supports both integer and percentage string values (rounds down, but floored at 1 Application for >0%) + goTemplate: true + template: + metadata: + name: '{{.cluster}}-guestbook' + labels: + env: '{{.env}}' + spec: + project: my-project + source: + repoURL: https://github.com/infra-team/cluster-deployments.git + targetRevision: HEAD + path: guestbook/{{.cluster}} + destination: + server: '{{.url}}' + namespace: guestbook +``` diff --git a/docs/operator-manual/argocd-cmd-params-cm.yaml b/docs/operator-manual/argocd-cmd-params-cm.yaml index be33aee9ba0f4..a694cc650b0d5 100644 --- a/docs/operator-manual/argocd-cmd-params-cm.yaml +++ b/docs/operator-manual/argocd-cmd-params-cm.yaml @@ -164,3 +164,5 @@ data: applicationsetcontroller.dryrun: "false" # Enable git submodule support applicationsetcontroller.enable.git.submodule: "true" + # Enables use of the Progressive Rollouts capability + applicationsetcontroller.enable.progressive.rollouts: "false" diff --git a/manifests/core-install.yaml b/manifests/core-install.yaml index 87ce640966327..f5ab604dc9530 100644 --- a/manifests/core-install.yaml +++ b/manifests/core-install.yaml @@ -14245,6 +14245,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingSync: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -14699,6 +14730,24 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/manifests/crds/applicationset-crd.yaml b/manifests/crds/applicationset-crd.yaml index 19a23e64a10aa..ab2b6d43ef081 100644 --- a/manifests/crds/applicationset-crd.yaml +++ b/manifests/crds/applicationset-crd.yaml @@ -10231,6 +10231,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingSync: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -10685,6 +10716,24 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/manifests/ha/install.yaml b/manifests/ha/install.yaml index 6cecdbd529924..c440acc0d4b77 100644 --- a/manifests/ha/install.yaml +++ b/manifests/ha/install.yaml @@ -14245,6 +14245,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingSync: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -14699,6 +14730,24 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/manifests/install.yaml b/manifests/install.yaml index 9f25ea32518df..acd47cd20cf4a 100644 --- a/manifests/install.yaml +++ b/manifests/install.yaml @@ -14245,6 +14245,37 @@ spec: type: array goTemplate: type: boolean + strategy: + properties: + rollingSync: + properties: + steps: + items: + properties: + matchExpressions: + items: + properties: + key: + type: string + operator: + type: string + values: + items: + type: string + type: array + type: object + type: array + maxUpdate: + anyOf: + - type: integer + - type: string + x-kubernetes-int-or-string: true + type: object + type: array + type: object + type: + type: string + type: object syncPolicy: properties: preserveResourcesOnDeletion: @@ -14699,6 +14730,24 @@ spec: type: object status: properties: + applicationStatus: + items: + properties: + application: + type: string + lastTransitionTime: + format: date-time + type: string + message: + type: string + status: + type: string + required: + - application + - message + - status + type: object + type: array conditions: items: properties: diff --git a/mkdocs.yml b/mkdocs.yml index edfa24d231c45..e713392b56dd1 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -101,6 +101,7 @@ nav: - operator-manual/applicationset/GoTemplate.md - Controlling Resource Modification: operator-manual/applicationset/Controlling-Resource-Modification.md - Application Pruning & Resource Deletion: operator-manual/applicationset/Application-Deletion.md + - Progressive Rollouts: operator-manual/applicationset/Progressive-Rollouts.md - Server Configuration Parameters: - operator-manual/server-commands/argocd-server.md - operator-manual/server-commands/argocd-application-controller.md diff --git a/pkg/apis/api-rules/violation_exceptions.list b/pkg/apis/api-rules/violation_exceptions.list index 0cfc6780de2db..754988e464117 100644 --- a/pkg/apis/api-rules/violation_exceptions.list +++ b/pkg/apis/api-rules/violation_exceptions.list @@ -7,7 +7,11 @@ API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/ap API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,AppProjectSpec,SignatureKeys API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,AppProjectSpec,SourceNamespaces API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,AppProjectSpec,SourceRepos +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationMatchExpression,Values +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetRolloutStep,MatchExpressions +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetRolloutStrategy,Steps API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetSpec,Generators +API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetStatus,ApplicationStatus API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetStatus,Conditions API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSetTemplateMeta,Finalizers API rule violation: list_type_missing,github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1,ApplicationSourceHelm,FileParameters diff --git a/pkg/apis/application/v1alpha1/applicationset_types.go b/pkg/apis/application/v1alpha1/applicationset_types.go index 25cf3f307ee62..a6c7998bc16f7 100644 --- a/pkg/apis/application/v1alpha1/applicationset_types.go +++ b/pkg/apis/application/v1alpha1/applicationset_types.go @@ -25,6 +25,7 @@ import ( apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/intstr" ) // Utility struct for a reference to a secret key. @@ -52,6 +53,28 @@ type ApplicationSetSpec struct { Generators []ApplicationSetGenerator `json:"generators" protobuf:"bytes,2,name=generators"` Template ApplicationSetTemplate `json:"template" protobuf:"bytes,3,name=template"` SyncPolicy *ApplicationSetSyncPolicy `json:"syncPolicy,omitempty" protobuf:"bytes,4,name=syncPolicy"` + Strategy *ApplicationSetStrategy `json:"strategy,omitempty" protobuf:"bytes,5,opt,name=strategy"` +} + +// ApplicationSetStrategy configures how generated Applications are updated in sequence. +type ApplicationSetStrategy struct { + Type string `json:"type,omitempty" protobuf:"bytes,1,opt,name=type"` + RollingSync *ApplicationSetRolloutStrategy `json:"rollingSync,omitempty" protobuf:"bytes,2,opt,name=rollingSync"` + // RollingUpdate *ApplicationSetRolloutStrategy `json:"rollingUpdate,omitempty" protobuf:"bytes,3,opt,name=rollingUpdate"` +} +type ApplicationSetRolloutStrategy struct { + Steps []ApplicationSetRolloutStep `json:"steps,omitempty" protobuf:"bytes,1,opt,name=steps"` +} + +type ApplicationSetRolloutStep struct { + MatchExpressions []ApplicationMatchExpression `json:"matchExpressions,omitempty" protobuf:"bytes,1,opt,name=matchExpressions"` + MaxUpdate *intstr.IntOrString `json:"maxUpdate,omitempty" protobuf:"bytes,2,opt,name=maxUpdate"` +} + +type ApplicationMatchExpression struct { + Key string `json:"key,omitempty" protobuf:"bytes,1,opt,name=key"` + Operator string `json:"operator,omitempty" protobuf:"bytes,2,opt,name=operator"` + Values []string `json:"values,omitempty" protobuf:"bytes,3,opt,name=values"` } // ApplicationSetSyncPolicy configures how generated Applications will relate to their @@ -501,7 +524,8 @@ type PullRequestGeneratorFilter struct { type ApplicationSetStatus struct { // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster // Important: Run "make" to regenerate code after modifying this file - Conditions []ApplicationSetCondition `json:"conditions,omitempty" protobuf:"bytes,1,name=conditions"` + Conditions []ApplicationSetCondition `json:"conditions,omitempty" protobuf:"bytes,1,name=conditions"` + ApplicationStatus []ApplicationSetApplicationStatus `json:"applicationStatus,omitempty" protobuf:"bytes,2,name=applicationStatus"` } // ApplicationSetCondition contains details about an applicationset condition, which is usally an error or warning @@ -542,6 +566,7 @@ const ( ApplicationSetConditionErrorOccurred ApplicationSetConditionType = "ErrorOccurred" ApplicationSetConditionParametersGenerated ApplicationSetConditionType = "ParametersGenerated" ApplicationSetConditionResourcesUpToDate ApplicationSetConditionType = "ResourcesUpToDate" + ApplicationSetConditionRolloutProgressing ApplicationSetConditionType = "RolloutProgressing" ) type ApplicationSetReasonType string @@ -558,8 +583,23 @@ const ( ApplicationSetReasonDeleteApplicationError = "DeleteApplicationError" ApplicationSetReasonRefreshApplicationError = "RefreshApplicationError" ApplicationSetReasonApplicationValidationError = "ApplicationValidationError" + ApplicationSetReasonApplicationSetModified = "ApplicationSetModified" + ApplicationSetReasonApplicationSetRolloutComplete = "ApplicationSetRolloutComplete" + ApplicationSetReasonSyncApplicationError = "SyncApplicationError" ) +// ApplicationSetApplicationStatus contains details about each Application managed by the ApplicationSet +type ApplicationSetApplicationStatus struct { + // Application contains the name of the Application resource + Application string `json:"application" protobuf:"bytes,1,opt,name=application"` + // LastTransitionTime is the time the status was last updated + LastTransitionTime *metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,2,opt,name=lastTransitionTime"` + // Message contains human-readable message indicating details about the status + Message string `json:"message" protobuf:"bytes,3,opt,name=message"` + // Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy) + Status string `json:"status" protobuf:"bytes,5,opt,name=status"` +} + // ApplicationSetList contains a list of ApplicationSet // +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object // +kubebuilder:object:root=true @@ -617,3 +657,14 @@ func findConditionIndex(conditions []ApplicationSetCondition, t ApplicationSetCo } return -1 } + +func (status *ApplicationSetStatus) SetApplicationStatus(newStatus ApplicationSetApplicationStatus) { + for i := range status.ApplicationStatus { + appStatus := status.ApplicationStatus[i] + if appStatus.Application == newStatus.Application { + status.ApplicationStatus[i] = newStatus + return + } + } + status.ApplicationStatus = append(status.ApplicationStatus, newStatus) +} diff --git a/pkg/apis/application/v1alpha1/generated.pb.go b/pkg/apis/application/v1alpha1/generated.pb.go index e110c371a3235..6eb480af30f11 100644 --- a/pkg/apis/application/v1alpha1/generated.pb.go +++ b/pkg/apis/application/v1alpha1/generated.pb.go @@ -23,6 +23,7 @@ import ( reflect "reflect" strings "strings" + intstr "k8s.io/apimachinery/pkg/util/intstr" k8s_io_apimachinery_pkg_watch "k8s.io/apimachinery/pkg/watch" ) @@ -289,10 +290,38 @@ func (m *ApplicationList) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationList proto.InternalMessageInfo +func (m *ApplicationMatchExpression) Reset() { *m = ApplicationMatchExpression{} } +func (*ApplicationMatchExpression) ProtoMessage() {} +func (*ApplicationMatchExpression) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{9} +} +func (m *ApplicationMatchExpression) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationMatchExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ApplicationMatchExpression) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationMatchExpression.Merge(m, src) +} +func (m *ApplicationMatchExpression) XXX_Size() int { + return m.Size() +} +func (m *ApplicationMatchExpression) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationMatchExpression.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationMatchExpression proto.InternalMessageInfo + func (m *ApplicationSet) Reset() { *m = ApplicationSet{} } func (*ApplicationSet) ProtoMessage() {} func (*ApplicationSet) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{9} + return fileDescriptor_030104ce3b95bcac, []int{10} } func (m *ApplicationSet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -317,10 +346,38 @@ func (m *ApplicationSet) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationSet proto.InternalMessageInfo +func (m *ApplicationSetApplicationStatus) Reset() { *m = ApplicationSetApplicationStatus{} } +func (*ApplicationSetApplicationStatus) ProtoMessage() {} +func (*ApplicationSetApplicationStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{11} +} +func (m *ApplicationSetApplicationStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetApplicationStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ApplicationSetApplicationStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetApplicationStatus.Merge(m, src) +} +func (m *ApplicationSetApplicationStatus) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetApplicationStatus) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetApplicationStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetApplicationStatus proto.InternalMessageInfo + func (m *ApplicationSetCondition) Reset() { *m = ApplicationSetCondition{} } func (*ApplicationSetCondition) ProtoMessage() {} func (*ApplicationSetCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{10} + return fileDescriptor_030104ce3b95bcac, []int{12} } func (m *ApplicationSetCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -348,7 +405,7 @@ var xxx_messageInfo_ApplicationSetCondition proto.InternalMessageInfo func (m *ApplicationSetGenerator) Reset() { *m = ApplicationSetGenerator{} } func (*ApplicationSetGenerator) ProtoMessage() {} func (*ApplicationSetGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{11} + return fileDescriptor_030104ce3b95bcac, []int{13} } func (m *ApplicationSetGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -376,7 +433,7 @@ var xxx_messageInfo_ApplicationSetGenerator proto.InternalMessageInfo func (m *ApplicationSetList) Reset() { *m = ApplicationSetList{} } func (*ApplicationSetList) ProtoMessage() {} func (*ApplicationSetList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{12} + return fileDescriptor_030104ce3b95bcac, []int{14} } func (m *ApplicationSetList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -404,7 +461,7 @@ var xxx_messageInfo_ApplicationSetList proto.InternalMessageInfo func (m *ApplicationSetNestedGenerator) Reset() { *m = ApplicationSetNestedGenerator{} } func (*ApplicationSetNestedGenerator) ProtoMessage() {} func (*ApplicationSetNestedGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{13} + return fileDescriptor_030104ce3b95bcac, []int{15} } func (m *ApplicationSetNestedGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -429,10 +486,66 @@ func (m *ApplicationSetNestedGenerator) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationSetNestedGenerator proto.InternalMessageInfo +func (m *ApplicationSetRolloutStep) Reset() { *m = ApplicationSetRolloutStep{} } +func (*ApplicationSetRolloutStep) ProtoMessage() {} +func (*ApplicationSetRolloutStep) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{16} +} +func (m *ApplicationSetRolloutStep) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetRolloutStep) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ApplicationSetRolloutStep) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetRolloutStep.Merge(m, src) +} +func (m *ApplicationSetRolloutStep) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetRolloutStep) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetRolloutStep.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetRolloutStep proto.InternalMessageInfo + +func (m *ApplicationSetRolloutStrategy) Reset() { *m = ApplicationSetRolloutStrategy{} } +func (*ApplicationSetRolloutStrategy) ProtoMessage() {} +func (*ApplicationSetRolloutStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{17} +} +func (m *ApplicationSetRolloutStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetRolloutStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ApplicationSetRolloutStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetRolloutStrategy.Merge(m, src) +} +func (m *ApplicationSetRolloutStrategy) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetRolloutStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetRolloutStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetRolloutStrategy proto.InternalMessageInfo + func (m *ApplicationSetSpec) Reset() { *m = ApplicationSetSpec{} } func (*ApplicationSetSpec) ProtoMessage() {} func (*ApplicationSetSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{14} + return fileDescriptor_030104ce3b95bcac, []int{18} } func (m *ApplicationSetSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -460,7 +573,7 @@ var xxx_messageInfo_ApplicationSetSpec proto.InternalMessageInfo func (m *ApplicationSetStatus) Reset() { *m = ApplicationSetStatus{} } func (*ApplicationSetStatus) ProtoMessage() {} func (*ApplicationSetStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{15} + return fileDescriptor_030104ce3b95bcac, []int{19} } func (m *ApplicationSetStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -485,10 +598,38 @@ func (m *ApplicationSetStatus) XXX_DiscardUnknown() { var xxx_messageInfo_ApplicationSetStatus proto.InternalMessageInfo +func (m *ApplicationSetStrategy) Reset() { *m = ApplicationSetStrategy{} } +func (*ApplicationSetStrategy) ProtoMessage() {} +func (*ApplicationSetStrategy) Descriptor() ([]byte, []int) { + return fileDescriptor_030104ce3b95bcac, []int{20} +} +func (m *ApplicationSetStrategy) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ApplicationSetStrategy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ApplicationSetStrategy) XXX_Merge(src proto.Message) { + xxx_messageInfo_ApplicationSetStrategy.Merge(m, src) +} +func (m *ApplicationSetStrategy) XXX_Size() int { + return m.Size() +} +func (m *ApplicationSetStrategy) XXX_DiscardUnknown() { + xxx_messageInfo_ApplicationSetStrategy.DiscardUnknown(m) +} + +var xxx_messageInfo_ApplicationSetStrategy proto.InternalMessageInfo + func (m *ApplicationSetSyncPolicy) Reset() { *m = ApplicationSetSyncPolicy{} } func (*ApplicationSetSyncPolicy) ProtoMessage() {} func (*ApplicationSetSyncPolicy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{16} + return fileDescriptor_030104ce3b95bcac, []int{21} } func (m *ApplicationSetSyncPolicy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -516,7 +657,7 @@ var xxx_messageInfo_ApplicationSetSyncPolicy proto.InternalMessageInfo func (m *ApplicationSetTemplate) Reset() { *m = ApplicationSetTemplate{} } func (*ApplicationSetTemplate) ProtoMessage() {} func (*ApplicationSetTemplate) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{17} + return fileDescriptor_030104ce3b95bcac, []int{22} } func (m *ApplicationSetTemplate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -544,7 +685,7 @@ var xxx_messageInfo_ApplicationSetTemplate proto.InternalMessageInfo func (m *ApplicationSetTemplateMeta) Reset() { *m = ApplicationSetTemplateMeta{} } func (*ApplicationSetTemplateMeta) ProtoMessage() {} func (*ApplicationSetTemplateMeta) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{18} + return fileDescriptor_030104ce3b95bcac, []int{23} } func (m *ApplicationSetTemplateMeta) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -572,7 +713,7 @@ var xxx_messageInfo_ApplicationSetTemplateMeta proto.InternalMessageInfo func (m *ApplicationSetTerminalGenerator) Reset() { *m = ApplicationSetTerminalGenerator{} } func (*ApplicationSetTerminalGenerator) ProtoMessage() {} func (*ApplicationSetTerminalGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{19} + return fileDescriptor_030104ce3b95bcac, []int{24} } func (m *ApplicationSetTerminalGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -600,7 +741,7 @@ var xxx_messageInfo_ApplicationSetTerminalGenerator proto.InternalMessageInfo func (m *ApplicationSource) Reset() { *m = ApplicationSource{} } func (*ApplicationSource) ProtoMessage() {} func (*ApplicationSource) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{20} + return fileDescriptor_030104ce3b95bcac, []int{25} } func (m *ApplicationSource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -628,7 +769,7 @@ var xxx_messageInfo_ApplicationSource proto.InternalMessageInfo func (m *ApplicationSourceDirectory) Reset() { *m = ApplicationSourceDirectory{} } func (*ApplicationSourceDirectory) ProtoMessage() {} func (*ApplicationSourceDirectory) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{21} + return fileDescriptor_030104ce3b95bcac, []int{26} } func (m *ApplicationSourceDirectory) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -656,7 +797,7 @@ var xxx_messageInfo_ApplicationSourceDirectory proto.InternalMessageInfo func (m *ApplicationSourceHelm) Reset() { *m = ApplicationSourceHelm{} } func (*ApplicationSourceHelm) ProtoMessage() {} func (*ApplicationSourceHelm) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{22} + return fileDescriptor_030104ce3b95bcac, []int{27} } func (m *ApplicationSourceHelm) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -684,7 +825,7 @@ var xxx_messageInfo_ApplicationSourceHelm proto.InternalMessageInfo func (m *ApplicationSourceJsonnet) Reset() { *m = ApplicationSourceJsonnet{} } func (*ApplicationSourceJsonnet) ProtoMessage() {} func (*ApplicationSourceJsonnet) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{23} + return fileDescriptor_030104ce3b95bcac, []int{28} } func (m *ApplicationSourceJsonnet) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -712,7 +853,7 @@ var xxx_messageInfo_ApplicationSourceJsonnet proto.InternalMessageInfo func (m *ApplicationSourceKustomize) Reset() { *m = ApplicationSourceKustomize{} } func (*ApplicationSourceKustomize) ProtoMessage() {} func (*ApplicationSourceKustomize) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{24} + return fileDescriptor_030104ce3b95bcac, []int{29} } func (m *ApplicationSourceKustomize) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -740,7 +881,7 @@ var xxx_messageInfo_ApplicationSourceKustomize proto.InternalMessageInfo func (m *ApplicationSourcePlugin) Reset() { *m = ApplicationSourcePlugin{} } func (*ApplicationSourcePlugin) ProtoMessage() {} func (*ApplicationSourcePlugin) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{25} + return fileDescriptor_030104ce3b95bcac, []int{30} } func (m *ApplicationSourcePlugin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -768,7 +909,7 @@ var xxx_messageInfo_ApplicationSourcePlugin proto.InternalMessageInfo func (m *ApplicationSourcePluginParameter) Reset() { *m = ApplicationSourcePluginParameter{} } func (*ApplicationSourcePluginParameter) ProtoMessage() {} func (*ApplicationSourcePluginParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{26} + return fileDescriptor_030104ce3b95bcac, []int{31} } func (m *ApplicationSourcePluginParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -796,7 +937,7 @@ var xxx_messageInfo_ApplicationSourcePluginParameter proto.InternalMessageInfo func (m *ApplicationSpec) Reset() { *m = ApplicationSpec{} } func (*ApplicationSpec) ProtoMessage() {} func (*ApplicationSpec) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{27} + return fileDescriptor_030104ce3b95bcac, []int{32} } func (m *ApplicationSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -824,7 +965,7 @@ var xxx_messageInfo_ApplicationSpec proto.InternalMessageInfo func (m *ApplicationStatus) Reset() { *m = ApplicationStatus{} } func (*ApplicationStatus) ProtoMessage() {} func (*ApplicationStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{28} + return fileDescriptor_030104ce3b95bcac, []int{33} } func (m *ApplicationStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -852,7 +993,7 @@ var xxx_messageInfo_ApplicationStatus proto.InternalMessageInfo func (m *ApplicationSummary) Reset() { *m = ApplicationSummary{} } func (*ApplicationSummary) ProtoMessage() {} func (*ApplicationSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{29} + return fileDescriptor_030104ce3b95bcac, []int{34} } func (m *ApplicationSummary) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -880,7 +1021,7 @@ var xxx_messageInfo_ApplicationSummary proto.InternalMessageInfo func (m *ApplicationTree) Reset() { *m = ApplicationTree{} } func (*ApplicationTree) ProtoMessage() {} func (*ApplicationTree) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{30} + return fileDescriptor_030104ce3b95bcac, []int{35} } func (m *ApplicationTree) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -908,7 +1049,7 @@ var xxx_messageInfo_ApplicationTree proto.InternalMessageInfo func (m *ApplicationWatchEvent) Reset() { *m = ApplicationWatchEvent{} } func (*ApplicationWatchEvent) ProtoMessage() {} func (*ApplicationWatchEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{31} + return fileDescriptor_030104ce3b95bcac, []int{36} } func (m *ApplicationWatchEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -936,7 +1077,7 @@ var xxx_messageInfo_ApplicationWatchEvent proto.InternalMessageInfo func (m *Backoff) Reset() { *m = Backoff{} } func (*Backoff) ProtoMessage() {} func (*Backoff) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{32} + return fileDescriptor_030104ce3b95bcac, []int{37} } func (m *Backoff) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -964,7 +1105,7 @@ var xxx_messageInfo_Backoff proto.InternalMessageInfo func (m *BasicAuthBitbucketServer) Reset() { *m = BasicAuthBitbucketServer{} } func (*BasicAuthBitbucketServer) ProtoMessage() {} func (*BasicAuthBitbucketServer) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{33} + return fileDescriptor_030104ce3b95bcac, []int{38} } func (m *BasicAuthBitbucketServer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -992,7 +1133,7 @@ var xxx_messageInfo_BasicAuthBitbucketServer proto.InternalMessageInfo func (m *Cluster) Reset() { *m = Cluster{} } func (*Cluster) ProtoMessage() {} func (*Cluster) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{34} + return fileDescriptor_030104ce3b95bcac, []int{39} } func (m *Cluster) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1020,7 +1161,7 @@ var xxx_messageInfo_Cluster proto.InternalMessageInfo func (m *ClusterCacheInfo) Reset() { *m = ClusterCacheInfo{} } func (*ClusterCacheInfo) ProtoMessage() {} func (*ClusterCacheInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{35} + return fileDescriptor_030104ce3b95bcac, []int{40} } func (m *ClusterCacheInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1048,7 +1189,7 @@ var xxx_messageInfo_ClusterCacheInfo proto.InternalMessageInfo func (m *ClusterConfig) Reset() { *m = ClusterConfig{} } func (*ClusterConfig) ProtoMessage() {} func (*ClusterConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{36} + return fileDescriptor_030104ce3b95bcac, []int{41} } func (m *ClusterConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1076,7 +1217,7 @@ var xxx_messageInfo_ClusterConfig proto.InternalMessageInfo func (m *ClusterGenerator) Reset() { *m = ClusterGenerator{} } func (*ClusterGenerator) ProtoMessage() {} func (*ClusterGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{37} + return fileDescriptor_030104ce3b95bcac, []int{42} } func (m *ClusterGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1104,7 +1245,7 @@ var xxx_messageInfo_ClusterGenerator proto.InternalMessageInfo func (m *ClusterInfo) Reset() { *m = ClusterInfo{} } func (*ClusterInfo) ProtoMessage() {} func (*ClusterInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{38} + return fileDescriptor_030104ce3b95bcac, []int{43} } func (m *ClusterInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1132,7 +1273,7 @@ var xxx_messageInfo_ClusterInfo proto.InternalMessageInfo func (m *ClusterList) Reset() { *m = ClusterList{} } func (*ClusterList) ProtoMessage() {} func (*ClusterList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{39} + return fileDescriptor_030104ce3b95bcac, []int{44} } func (m *ClusterList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1160,7 +1301,7 @@ var xxx_messageInfo_ClusterList proto.InternalMessageInfo func (m *Command) Reset() { *m = Command{} } func (*Command) ProtoMessage() {} func (*Command) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{40} + return fileDescriptor_030104ce3b95bcac, []int{45} } func (m *Command) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1188,7 +1329,7 @@ var xxx_messageInfo_Command proto.InternalMessageInfo func (m *ComparedTo) Reset() { *m = ComparedTo{} } func (*ComparedTo) ProtoMessage() {} func (*ComparedTo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{41} + return fileDescriptor_030104ce3b95bcac, []int{46} } func (m *ComparedTo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1216,7 +1357,7 @@ var xxx_messageInfo_ComparedTo proto.InternalMessageInfo func (m *ComponentParameter) Reset() { *m = ComponentParameter{} } func (*ComponentParameter) ProtoMessage() {} func (*ComponentParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{42} + return fileDescriptor_030104ce3b95bcac, []int{47} } func (m *ComponentParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1244,7 +1385,7 @@ var xxx_messageInfo_ComponentParameter proto.InternalMessageInfo func (m *ConfigManagementPlugin) Reset() { *m = ConfigManagementPlugin{} } func (*ConfigManagementPlugin) ProtoMessage() {} func (*ConfigManagementPlugin) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{43} + return fileDescriptor_030104ce3b95bcac, []int{48} } func (m *ConfigManagementPlugin) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1272,7 +1413,7 @@ var xxx_messageInfo_ConfigManagementPlugin proto.InternalMessageInfo func (m *ConnectionState) Reset() { *m = ConnectionState{} } func (*ConnectionState) ProtoMessage() {} func (*ConnectionState) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{44} + return fileDescriptor_030104ce3b95bcac, []int{49} } func (m *ConnectionState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1300,7 +1441,7 @@ var xxx_messageInfo_ConnectionState proto.InternalMessageInfo func (m *DuckTypeGenerator) Reset() { *m = DuckTypeGenerator{} } func (*DuckTypeGenerator) ProtoMessage() {} func (*DuckTypeGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{45} + return fileDescriptor_030104ce3b95bcac, []int{50} } func (m *DuckTypeGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1328,7 +1469,7 @@ var xxx_messageInfo_DuckTypeGenerator proto.InternalMessageInfo func (m *EnvEntry) Reset() { *m = EnvEntry{} } func (*EnvEntry) ProtoMessage() {} func (*EnvEntry) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{46} + return fileDescriptor_030104ce3b95bcac, []int{51} } func (m *EnvEntry) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1356,7 +1497,7 @@ var xxx_messageInfo_EnvEntry proto.InternalMessageInfo func (m *ExecProviderConfig) Reset() { *m = ExecProviderConfig{} } func (*ExecProviderConfig) ProtoMessage() {} func (*ExecProviderConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{47} + return fileDescriptor_030104ce3b95bcac, []int{52} } func (m *ExecProviderConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1384,7 +1525,7 @@ var xxx_messageInfo_ExecProviderConfig proto.InternalMessageInfo func (m *GitDirectoryGeneratorItem) Reset() { *m = GitDirectoryGeneratorItem{} } func (*GitDirectoryGeneratorItem) ProtoMessage() {} func (*GitDirectoryGeneratorItem) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{48} + return fileDescriptor_030104ce3b95bcac, []int{53} } func (m *GitDirectoryGeneratorItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1412,7 +1553,7 @@ var xxx_messageInfo_GitDirectoryGeneratorItem proto.InternalMessageInfo func (m *GitFileGeneratorItem) Reset() { *m = GitFileGeneratorItem{} } func (*GitFileGeneratorItem) ProtoMessage() {} func (*GitFileGeneratorItem) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{49} + return fileDescriptor_030104ce3b95bcac, []int{54} } func (m *GitFileGeneratorItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1440,7 +1581,7 @@ var xxx_messageInfo_GitFileGeneratorItem proto.InternalMessageInfo func (m *GitGenerator) Reset() { *m = GitGenerator{} } func (*GitGenerator) ProtoMessage() {} func (*GitGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{50} + return fileDescriptor_030104ce3b95bcac, []int{55} } func (m *GitGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1468,7 +1609,7 @@ var xxx_messageInfo_GitGenerator proto.InternalMessageInfo func (m *GnuPGPublicKey) Reset() { *m = GnuPGPublicKey{} } func (*GnuPGPublicKey) ProtoMessage() {} func (*GnuPGPublicKey) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{51} + return fileDescriptor_030104ce3b95bcac, []int{56} } func (m *GnuPGPublicKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1496,7 +1637,7 @@ var xxx_messageInfo_GnuPGPublicKey proto.InternalMessageInfo func (m *GnuPGPublicKeyList) Reset() { *m = GnuPGPublicKeyList{} } func (*GnuPGPublicKeyList) ProtoMessage() {} func (*GnuPGPublicKeyList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{52} + return fileDescriptor_030104ce3b95bcac, []int{57} } func (m *GnuPGPublicKeyList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1524,7 +1665,7 @@ var xxx_messageInfo_GnuPGPublicKeyList proto.InternalMessageInfo func (m *HealthStatus) Reset() { *m = HealthStatus{} } func (*HealthStatus) ProtoMessage() {} func (*HealthStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{53} + return fileDescriptor_030104ce3b95bcac, []int{58} } func (m *HealthStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1552,7 +1693,7 @@ var xxx_messageInfo_HealthStatus proto.InternalMessageInfo func (m *HelmFileParameter) Reset() { *m = HelmFileParameter{} } func (*HelmFileParameter) ProtoMessage() {} func (*HelmFileParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{54} + return fileDescriptor_030104ce3b95bcac, []int{59} } func (m *HelmFileParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1580,7 +1721,7 @@ var xxx_messageInfo_HelmFileParameter proto.InternalMessageInfo func (m *HelmOptions) Reset() { *m = HelmOptions{} } func (*HelmOptions) ProtoMessage() {} func (*HelmOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{55} + return fileDescriptor_030104ce3b95bcac, []int{60} } func (m *HelmOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1608,7 +1749,7 @@ var xxx_messageInfo_HelmOptions proto.InternalMessageInfo func (m *HelmParameter) Reset() { *m = HelmParameter{} } func (*HelmParameter) ProtoMessage() {} func (*HelmParameter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{56} + return fileDescriptor_030104ce3b95bcac, []int{61} } func (m *HelmParameter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1636,7 +1777,7 @@ var xxx_messageInfo_HelmParameter proto.InternalMessageInfo func (m *HostInfo) Reset() { *m = HostInfo{} } func (*HostInfo) ProtoMessage() {} func (*HostInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{57} + return fileDescriptor_030104ce3b95bcac, []int{62} } func (m *HostInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1664,7 +1805,7 @@ var xxx_messageInfo_HostInfo proto.InternalMessageInfo func (m *HostResourceInfo) Reset() { *m = HostResourceInfo{} } func (*HostResourceInfo) ProtoMessage() {} func (*HostResourceInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{58} + return fileDescriptor_030104ce3b95bcac, []int{63} } func (m *HostResourceInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1692,7 +1833,7 @@ var xxx_messageInfo_HostResourceInfo proto.InternalMessageInfo func (m *Info) Reset() { *m = Info{} } func (*Info) ProtoMessage() {} func (*Info) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{59} + return fileDescriptor_030104ce3b95bcac, []int{64} } func (m *Info) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1720,7 +1861,7 @@ var xxx_messageInfo_Info proto.InternalMessageInfo func (m *InfoItem) Reset() { *m = InfoItem{} } func (*InfoItem) ProtoMessage() {} func (*InfoItem) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{60} + return fileDescriptor_030104ce3b95bcac, []int{65} } func (m *InfoItem) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1748,7 +1889,7 @@ var xxx_messageInfo_InfoItem proto.InternalMessageInfo func (m *JWTToken) Reset() { *m = JWTToken{} } func (*JWTToken) ProtoMessage() {} func (*JWTToken) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{61} + return fileDescriptor_030104ce3b95bcac, []int{66} } func (m *JWTToken) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1776,7 +1917,7 @@ var xxx_messageInfo_JWTToken proto.InternalMessageInfo func (m *JWTTokens) Reset() { *m = JWTTokens{} } func (*JWTTokens) ProtoMessage() {} func (*JWTTokens) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{62} + return fileDescriptor_030104ce3b95bcac, []int{67} } func (m *JWTTokens) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1804,7 +1945,7 @@ var xxx_messageInfo_JWTTokens proto.InternalMessageInfo func (m *JsonnetVar) Reset() { *m = JsonnetVar{} } func (*JsonnetVar) ProtoMessage() {} func (*JsonnetVar) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{63} + return fileDescriptor_030104ce3b95bcac, []int{68} } func (m *JsonnetVar) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1832,7 +1973,7 @@ var xxx_messageInfo_JsonnetVar proto.InternalMessageInfo func (m *KnownTypeField) Reset() { *m = KnownTypeField{} } func (*KnownTypeField) ProtoMessage() {} func (*KnownTypeField) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{64} + return fileDescriptor_030104ce3b95bcac, []int{69} } func (m *KnownTypeField) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1860,7 +2001,7 @@ var xxx_messageInfo_KnownTypeField proto.InternalMessageInfo func (m *KustomizeOptions) Reset() { *m = KustomizeOptions{} } func (*KustomizeOptions) ProtoMessage() {} func (*KustomizeOptions) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{65} + return fileDescriptor_030104ce3b95bcac, []int{70} } func (m *KustomizeOptions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1888,7 +2029,7 @@ var xxx_messageInfo_KustomizeOptions proto.InternalMessageInfo func (m *ListGenerator) Reset() { *m = ListGenerator{} } func (*ListGenerator) ProtoMessage() {} func (*ListGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{66} + return fileDescriptor_030104ce3b95bcac, []int{71} } func (m *ListGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1916,7 +2057,7 @@ var xxx_messageInfo_ListGenerator proto.InternalMessageInfo func (m *ManagedNamespaceMetadata) Reset() { *m = ManagedNamespaceMetadata{} } func (*ManagedNamespaceMetadata) ProtoMessage() {} func (*ManagedNamespaceMetadata) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{67} + return fileDescriptor_030104ce3b95bcac, []int{72} } func (m *ManagedNamespaceMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1944,7 +2085,7 @@ var xxx_messageInfo_ManagedNamespaceMetadata proto.InternalMessageInfo func (m *MatrixGenerator) Reset() { *m = MatrixGenerator{} } func (*MatrixGenerator) ProtoMessage() {} func (*MatrixGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{68} + return fileDescriptor_030104ce3b95bcac, []int{73} } func (m *MatrixGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1972,7 +2113,7 @@ var xxx_messageInfo_MatrixGenerator proto.InternalMessageInfo func (m *MergeGenerator) Reset() { *m = MergeGenerator{} } func (*MergeGenerator) ProtoMessage() {} func (*MergeGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{69} + return fileDescriptor_030104ce3b95bcac, []int{74} } func (m *MergeGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2000,7 +2141,7 @@ var xxx_messageInfo_MergeGenerator proto.InternalMessageInfo func (m *NestedMatrixGenerator) Reset() { *m = NestedMatrixGenerator{} } func (*NestedMatrixGenerator) ProtoMessage() {} func (*NestedMatrixGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{70} + return fileDescriptor_030104ce3b95bcac, []int{75} } func (m *NestedMatrixGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2028,7 +2169,7 @@ var xxx_messageInfo_NestedMatrixGenerator proto.InternalMessageInfo func (m *NestedMergeGenerator) Reset() { *m = NestedMergeGenerator{} } func (*NestedMergeGenerator) ProtoMessage() {} func (*NestedMergeGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{71} + return fileDescriptor_030104ce3b95bcac, []int{76} } func (m *NestedMergeGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2056,7 +2197,7 @@ var xxx_messageInfo_NestedMergeGenerator proto.InternalMessageInfo func (m *Operation) Reset() { *m = Operation{} } func (*Operation) ProtoMessage() {} func (*Operation) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{72} + return fileDescriptor_030104ce3b95bcac, []int{77} } func (m *Operation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2084,7 +2225,7 @@ var xxx_messageInfo_Operation proto.InternalMessageInfo func (m *OperationInitiator) Reset() { *m = OperationInitiator{} } func (*OperationInitiator) ProtoMessage() {} func (*OperationInitiator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{73} + return fileDescriptor_030104ce3b95bcac, []int{78} } func (m *OperationInitiator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2112,7 +2253,7 @@ var xxx_messageInfo_OperationInitiator proto.InternalMessageInfo func (m *OperationState) Reset() { *m = OperationState{} } func (*OperationState) ProtoMessage() {} func (*OperationState) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{74} + return fileDescriptor_030104ce3b95bcac, []int{79} } func (m *OperationState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2140,7 +2281,7 @@ var xxx_messageInfo_OperationState proto.InternalMessageInfo func (m *OrphanedResourceKey) Reset() { *m = OrphanedResourceKey{} } func (*OrphanedResourceKey) ProtoMessage() {} func (*OrphanedResourceKey) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{75} + return fileDescriptor_030104ce3b95bcac, []int{80} } func (m *OrphanedResourceKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2168,7 +2309,7 @@ var xxx_messageInfo_OrphanedResourceKey proto.InternalMessageInfo func (m *OrphanedResourcesMonitorSettings) Reset() { *m = OrphanedResourcesMonitorSettings{} } func (*OrphanedResourcesMonitorSettings) ProtoMessage() {} func (*OrphanedResourcesMonitorSettings) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{76} + return fileDescriptor_030104ce3b95bcac, []int{81} } func (m *OrphanedResourcesMonitorSettings) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2196,7 +2337,7 @@ var xxx_messageInfo_OrphanedResourcesMonitorSettings proto.InternalMessageInfo func (m *OverrideIgnoreDiff) Reset() { *m = OverrideIgnoreDiff{} } func (*OverrideIgnoreDiff) ProtoMessage() {} func (*OverrideIgnoreDiff) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{77} + return fileDescriptor_030104ce3b95bcac, []int{82} } func (m *OverrideIgnoreDiff) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2224,7 +2365,7 @@ var xxx_messageInfo_OverrideIgnoreDiff proto.InternalMessageInfo func (m *ProjectRole) Reset() { *m = ProjectRole{} } func (*ProjectRole) ProtoMessage() {} func (*ProjectRole) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{78} + return fileDescriptor_030104ce3b95bcac, []int{83} } func (m *ProjectRole) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2252,7 +2393,7 @@ var xxx_messageInfo_ProjectRole proto.InternalMessageInfo func (m *PullRequestGenerator) Reset() { *m = PullRequestGenerator{} } func (*PullRequestGenerator) ProtoMessage() {} func (*PullRequestGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{79} + return fileDescriptor_030104ce3b95bcac, []int{84} } func (m *PullRequestGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2280,7 +2421,7 @@ var xxx_messageInfo_PullRequestGenerator proto.InternalMessageInfo func (m *PullRequestGeneratorBitbucketServer) Reset() { *m = PullRequestGeneratorBitbucketServer{} } func (*PullRequestGeneratorBitbucketServer) ProtoMessage() {} func (*PullRequestGeneratorBitbucketServer) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{80} + return fileDescriptor_030104ce3b95bcac, []int{85} } func (m *PullRequestGeneratorBitbucketServer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2308,7 +2449,7 @@ var xxx_messageInfo_PullRequestGeneratorBitbucketServer proto.InternalMessageInf func (m *PullRequestGeneratorFilter) Reset() { *m = PullRequestGeneratorFilter{} } func (*PullRequestGeneratorFilter) ProtoMessage() {} func (*PullRequestGeneratorFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{81} + return fileDescriptor_030104ce3b95bcac, []int{86} } func (m *PullRequestGeneratorFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2336,7 +2477,7 @@ var xxx_messageInfo_PullRequestGeneratorFilter proto.InternalMessageInfo func (m *PullRequestGeneratorGitLab) Reset() { *m = PullRequestGeneratorGitLab{} } func (*PullRequestGeneratorGitLab) ProtoMessage() {} func (*PullRequestGeneratorGitLab) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{82} + return fileDescriptor_030104ce3b95bcac, []int{87} } func (m *PullRequestGeneratorGitLab) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2364,7 +2505,7 @@ var xxx_messageInfo_PullRequestGeneratorGitLab proto.InternalMessageInfo func (m *PullRequestGeneratorGitea) Reset() { *m = PullRequestGeneratorGitea{} } func (*PullRequestGeneratorGitea) ProtoMessage() {} func (*PullRequestGeneratorGitea) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{83} + return fileDescriptor_030104ce3b95bcac, []int{88} } func (m *PullRequestGeneratorGitea) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2392,7 +2533,7 @@ var xxx_messageInfo_PullRequestGeneratorGitea proto.InternalMessageInfo func (m *PullRequestGeneratorGithub) Reset() { *m = PullRequestGeneratorGithub{} } func (*PullRequestGeneratorGithub) ProtoMessage() {} func (*PullRequestGeneratorGithub) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{84} + return fileDescriptor_030104ce3b95bcac, []int{89} } func (m *PullRequestGeneratorGithub) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2420,7 +2561,7 @@ var xxx_messageInfo_PullRequestGeneratorGithub proto.InternalMessageInfo func (m *RefTarget) Reset() { *m = RefTarget{} } func (*RefTarget) ProtoMessage() {} func (*RefTarget) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{85} + return fileDescriptor_030104ce3b95bcac, []int{90} } func (m *RefTarget) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2448,7 +2589,7 @@ var xxx_messageInfo_RefTarget proto.InternalMessageInfo func (m *RepoCreds) Reset() { *m = RepoCreds{} } func (*RepoCreds) ProtoMessage() {} func (*RepoCreds) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{86} + return fileDescriptor_030104ce3b95bcac, []int{91} } func (m *RepoCreds) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2476,7 +2617,7 @@ var xxx_messageInfo_RepoCreds proto.InternalMessageInfo func (m *RepoCredsList) Reset() { *m = RepoCredsList{} } func (*RepoCredsList) ProtoMessage() {} func (*RepoCredsList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{87} + return fileDescriptor_030104ce3b95bcac, []int{92} } func (m *RepoCredsList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2504,7 +2645,7 @@ var xxx_messageInfo_RepoCredsList proto.InternalMessageInfo func (m *Repository) Reset() { *m = Repository{} } func (*Repository) ProtoMessage() {} func (*Repository) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{88} + return fileDescriptor_030104ce3b95bcac, []int{93} } func (m *Repository) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2532,7 +2673,7 @@ var xxx_messageInfo_Repository proto.InternalMessageInfo func (m *RepositoryCertificate) Reset() { *m = RepositoryCertificate{} } func (*RepositoryCertificate) ProtoMessage() {} func (*RepositoryCertificate) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{89} + return fileDescriptor_030104ce3b95bcac, []int{94} } func (m *RepositoryCertificate) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2560,7 +2701,7 @@ var xxx_messageInfo_RepositoryCertificate proto.InternalMessageInfo func (m *RepositoryCertificateList) Reset() { *m = RepositoryCertificateList{} } func (*RepositoryCertificateList) ProtoMessage() {} func (*RepositoryCertificateList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{90} + return fileDescriptor_030104ce3b95bcac, []int{95} } func (m *RepositoryCertificateList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2588,7 +2729,7 @@ var xxx_messageInfo_RepositoryCertificateList proto.InternalMessageInfo func (m *RepositoryList) Reset() { *m = RepositoryList{} } func (*RepositoryList) ProtoMessage() {} func (*RepositoryList) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{91} + return fileDescriptor_030104ce3b95bcac, []int{96} } func (m *RepositoryList) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2616,7 +2757,7 @@ var xxx_messageInfo_RepositoryList proto.InternalMessageInfo func (m *ResourceAction) Reset() { *m = ResourceAction{} } func (*ResourceAction) ProtoMessage() {} func (*ResourceAction) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{92} + return fileDescriptor_030104ce3b95bcac, []int{97} } func (m *ResourceAction) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2644,7 +2785,7 @@ var xxx_messageInfo_ResourceAction proto.InternalMessageInfo func (m *ResourceActionDefinition) Reset() { *m = ResourceActionDefinition{} } func (*ResourceActionDefinition) ProtoMessage() {} func (*ResourceActionDefinition) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{93} + return fileDescriptor_030104ce3b95bcac, []int{98} } func (m *ResourceActionDefinition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2672,7 +2813,7 @@ var xxx_messageInfo_ResourceActionDefinition proto.InternalMessageInfo func (m *ResourceActionParam) Reset() { *m = ResourceActionParam{} } func (*ResourceActionParam) ProtoMessage() {} func (*ResourceActionParam) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{94} + return fileDescriptor_030104ce3b95bcac, []int{99} } func (m *ResourceActionParam) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2700,7 +2841,7 @@ var xxx_messageInfo_ResourceActionParam proto.InternalMessageInfo func (m *ResourceActions) Reset() { *m = ResourceActions{} } func (*ResourceActions) ProtoMessage() {} func (*ResourceActions) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{95} + return fileDescriptor_030104ce3b95bcac, []int{100} } func (m *ResourceActions) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2728,7 +2869,7 @@ var xxx_messageInfo_ResourceActions proto.InternalMessageInfo func (m *ResourceDiff) Reset() { *m = ResourceDiff{} } func (*ResourceDiff) ProtoMessage() {} func (*ResourceDiff) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{96} + return fileDescriptor_030104ce3b95bcac, []int{101} } func (m *ResourceDiff) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2756,7 +2897,7 @@ var xxx_messageInfo_ResourceDiff proto.InternalMessageInfo func (m *ResourceIgnoreDifferences) Reset() { *m = ResourceIgnoreDifferences{} } func (*ResourceIgnoreDifferences) ProtoMessage() {} func (*ResourceIgnoreDifferences) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{97} + return fileDescriptor_030104ce3b95bcac, []int{102} } func (m *ResourceIgnoreDifferences) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2784,7 +2925,7 @@ var xxx_messageInfo_ResourceIgnoreDifferences proto.InternalMessageInfo func (m *ResourceNetworkingInfo) Reset() { *m = ResourceNetworkingInfo{} } func (*ResourceNetworkingInfo) ProtoMessage() {} func (*ResourceNetworkingInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{98} + return fileDescriptor_030104ce3b95bcac, []int{103} } func (m *ResourceNetworkingInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2812,7 +2953,7 @@ var xxx_messageInfo_ResourceNetworkingInfo proto.InternalMessageInfo func (m *ResourceNode) Reset() { *m = ResourceNode{} } func (*ResourceNode) ProtoMessage() {} func (*ResourceNode) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{99} + return fileDescriptor_030104ce3b95bcac, []int{104} } func (m *ResourceNode) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2840,7 +2981,7 @@ var xxx_messageInfo_ResourceNode proto.InternalMessageInfo func (m *ResourceOverride) Reset() { *m = ResourceOverride{} } func (*ResourceOverride) ProtoMessage() {} func (*ResourceOverride) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{100} + return fileDescriptor_030104ce3b95bcac, []int{105} } func (m *ResourceOverride) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2868,7 +3009,7 @@ var xxx_messageInfo_ResourceOverride proto.InternalMessageInfo func (m *ResourceRef) Reset() { *m = ResourceRef{} } func (*ResourceRef) ProtoMessage() {} func (*ResourceRef) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{101} + return fileDescriptor_030104ce3b95bcac, []int{106} } func (m *ResourceRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2896,7 +3037,7 @@ var xxx_messageInfo_ResourceRef proto.InternalMessageInfo func (m *ResourceResult) Reset() { *m = ResourceResult{} } func (*ResourceResult) ProtoMessage() {} func (*ResourceResult) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{102} + return fileDescriptor_030104ce3b95bcac, []int{107} } func (m *ResourceResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2924,7 +3065,7 @@ var xxx_messageInfo_ResourceResult proto.InternalMessageInfo func (m *ResourceStatus) Reset() { *m = ResourceStatus{} } func (*ResourceStatus) ProtoMessage() {} func (*ResourceStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{103} + return fileDescriptor_030104ce3b95bcac, []int{108} } func (m *ResourceStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2952,7 +3093,7 @@ var xxx_messageInfo_ResourceStatus proto.InternalMessageInfo func (m *RetryStrategy) Reset() { *m = RetryStrategy{} } func (*RetryStrategy) ProtoMessage() {} func (*RetryStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{104} + return fileDescriptor_030104ce3b95bcac, []int{109} } func (m *RetryStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2980,7 +3121,7 @@ var xxx_messageInfo_RetryStrategy proto.InternalMessageInfo func (m *RevisionHistory) Reset() { *m = RevisionHistory{} } func (*RevisionHistory) ProtoMessage() {} func (*RevisionHistory) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{105} + return fileDescriptor_030104ce3b95bcac, []int{110} } func (m *RevisionHistory) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3008,7 +3149,7 @@ var xxx_messageInfo_RevisionHistory proto.InternalMessageInfo func (m *RevisionMetadata) Reset() { *m = RevisionMetadata{} } func (*RevisionMetadata) ProtoMessage() {} func (*RevisionMetadata) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{106} + return fileDescriptor_030104ce3b95bcac, []int{111} } func (m *RevisionMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3036,7 +3177,7 @@ var xxx_messageInfo_RevisionMetadata proto.InternalMessageInfo func (m *SCMProviderGenerator) Reset() { *m = SCMProviderGenerator{} } func (*SCMProviderGenerator) ProtoMessage() {} func (*SCMProviderGenerator) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{107} + return fileDescriptor_030104ce3b95bcac, []int{112} } func (m *SCMProviderGenerator) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3064,7 +3205,7 @@ var xxx_messageInfo_SCMProviderGenerator proto.InternalMessageInfo func (m *SCMProviderGeneratorAzureDevOps) Reset() { *m = SCMProviderGeneratorAzureDevOps{} } func (*SCMProviderGeneratorAzureDevOps) ProtoMessage() {} func (*SCMProviderGeneratorAzureDevOps) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{108} + return fileDescriptor_030104ce3b95bcac, []int{113} } func (m *SCMProviderGeneratorAzureDevOps) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3092,7 +3233,7 @@ var xxx_messageInfo_SCMProviderGeneratorAzureDevOps proto.InternalMessageInfo func (m *SCMProviderGeneratorBitbucket) Reset() { *m = SCMProviderGeneratorBitbucket{} } func (*SCMProviderGeneratorBitbucket) ProtoMessage() {} func (*SCMProviderGeneratorBitbucket) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{109} + return fileDescriptor_030104ce3b95bcac, []int{114} } func (m *SCMProviderGeneratorBitbucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3120,7 +3261,7 @@ var xxx_messageInfo_SCMProviderGeneratorBitbucket proto.InternalMessageInfo func (m *SCMProviderGeneratorBitbucketServer) Reset() { *m = SCMProviderGeneratorBitbucketServer{} } func (*SCMProviderGeneratorBitbucketServer) ProtoMessage() {} func (*SCMProviderGeneratorBitbucketServer) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{110} + return fileDescriptor_030104ce3b95bcac, []int{115} } func (m *SCMProviderGeneratorBitbucketServer) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3148,7 +3289,7 @@ var xxx_messageInfo_SCMProviderGeneratorBitbucketServer proto.InternalMessageInf func (m *SCMProviderGeneratorFilter) Reset() { *m = SCMProviderGeneratorFilter{} } func (*SCMProviderGeneratorFilter) ProtoMessage() {} func (*SCMProviderGeneratorFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{111} + return fileDescriptor_030104ce3b95bcac, []int{116} } func (m *SCMProviderGeneratorFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3176,7 +3317,7 @@ var xxx_messageInfo_SCMProviderGeneratorFilter proto.InternalMessageInfo func (m *SCMProviderGeneratorGitea) Reset() { *m = SCMProviderGeneratorGitea{} } func (*SCMProviderGeneratorGitea) ProtoMessage() {} func (*SCMProviderGeneratorGitea) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{112} + return fileDescriptor_030104ce3b95bcac, []int{117} } func (m *SCMProviderGeneratorGitea) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3204,7 +3345,7 @@ var xxx_messageInfo_SCMProviderGeneratorGitea proto.InternalMessageInfo func (m *SCMProviderGeneratorGithub) Reset() { *m = SCMProviderGeneratorGithub{} } func (*SCMProviderGeneratorGithub) ProtoMessage() {} func (*SCMProviderGeneratorGithub) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{113} + return fileDescriptor_030104ce3b95bcac, []int{118} } func (m *SCMProviderGeneratorGithub) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3232,7 +3373,7 @@ var xxx_messageInfo_SCMProviderGeneratorGithub proto.InternalMessageInfo func (m *SCMProviderGeneratorGitlab) Reset() { *m = SCMProviderGeneratorGitlab{} } func (*SCMProviderGeneratorGitlab) ProtoMessage() {} func (*SCMProviderGeneratorGitlab) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{114} + return fileDescriptor_030104ce3b95bcac, []int{119} } func (m *SCMProviderGeneratorGitlab) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3260,7 +3401,7 @@ var xxx_messageInfo_SCMProviderGeneratorGitlab proto.InternalMessageInfo func (m *SecretRef) Reset() { *m = SecretRef{} } func (*SecretRef) ProtoMessage() {} func (*SecretRef) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{115} + return fileDescriptor_030104ce3b95bcac, []int{120} } func (m *SecretRef) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3288,7 +3429,7 @@ var xxx_messageInfo_SecretRef proto.InternalMessageInfo func (m *SignatureKey) Reset() { *m = SignatureKey{} } func (*SignatureKey) ProtoMessage() {} func (*SignatureKey) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{116} + return fileDescriptor_030104ce3b95bcac, []int{121} } func (m *SignatureKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3316,7 +3457,7 @@ var xxx_messageInfo_SignatureKey proto.InternalMessageInfo func (m *SyncOperation) Reset() { *m = SyncOperation{} } func (*SyncOperation) ProtoMessage() {} func (*SyncOperation) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{117} + return fileDescriptor_030104ce3b95bcac, []int{122} } func (m *SyncOperation) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3344,7 +3485,7 @@ var xxx_messageInfo_SyncOperation proto.InternalMessageInfo func (m *SyncOperationResource) Reset() { *m = SyncOperationResource{} } func (*SyncOperationResource) ProtoMessage() {} func (*SyncOperationResource) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{118} + return fileDescriptor_030104ce3b95bcac, []int{123} } func (m *SyncOperationResource) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3372,7 +3513,7 @@ var xxx_messageInfo_SyncOperationResource proto.InternalMessageInfo func (m *SyncOperationResult) Reset() { *m = SyncOperationResult{} } func (*SyncOperationResult) ProtoMessage() {} func (*SyncOperationResult) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{119} + return fileDescriptor_030104ce3b95bcac, []int{124} } func (m *SyncOperationResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3400,7 +3541,7 @@ var xxx_messageInfo_SyncOperationResult proto.InternalMessageInfo func (m *SyncPolicy) Reset() { *m = SyncPolicy{} } func (*SyncPolicy) ProtoMessage() {} func (*SyncPolicy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{120} + return fileDescriptor_030104ce3b95bcac, []int{125} } func (m *SyncPolicy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3428,7 +3569,7 @@ var xxx_messageInfo_SyncPolicy proto.InternalMessageInfo func (m *SyncPolicyAutomated) Reset() { *m = SyncPolicyAutomated{} } func (*SyncPolicyAutomated) ProtoMessage() {} func (*SyncPolicyAutomated) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{121} + return fileDescriptor_030104ce3b95bcac, []int{126} } func (m *SyncPolicyAutomated) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3456,7 +3597,7 @@ var xxx_messageInfo_SyncPolicyAutomated proto.InternalMessageInfo func (m *SyncStatus) Reset() { *m = SyncStatus{} } func (*SyncStatus) ProtoMessage() {} func (*SyncStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{122} + return fileDescriptor_030104ce3b95bcac, []int{127} } func (m *SyncStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3484,7 +3625,7 @@ var xxx_messageInfo_SyncStatus proto.InternalMessageInfo func (m *SyncStrategy) Reset() { *m = SyncStrategy{} } func (*SyncStrategy) ProtoMessage() {} func (*SyncStrategy) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{123} + return fileDescriptor_030104ce3b95bcac, []int{128} } func (m *SyncStrategy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3512,7 +3653,7 @@ var xxx_messageInfo_SyncStrategy proto.InternalMessageInfo func (m *SyncStrategyApply) Reset() { *m = SyncStrategyApply{} } func (*SyncStrategyApply) ProtoMessage() {} func (*SyncStrategyApply) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{124} + return fileDescriptor_030104ce3b95bcac, []int{129} } func (m *SyncStrategyApply) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3540,7 +3681,7 @@ var xxx_messageInfo_SyncStrategyApply proto.InternalMessageInfo func (m *SyncStrategyHook) Reset() { *m = SyncStrategyHook{} } func (*SyncStrategyHook) ProtoMessage() {} func (*SyncStrategyHook) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{125} + return fileDescriptor_030104ce3b95bcac, []int{130} } func (m *SyncStrategyHook) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3568,7 +3709,7 @@ var xxx_messageInfo_SyncStrategyHook proto.InternalMessageInfo func (m *SyncWindow) Reset() { *m = SyncWindow{} } func (*SyncWindow) ProtoMessage() {} func (*SyncWindow) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{126} + return fileDescriptor_030104ce3b95bcac, []int{131} } func (m *SyncWindow) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3596,7 +3737,7 @@ var xxx_messageInfo_SyncWindow proto.InternalMessageInfo func (m *TLSClientConfig) Reset() { *m = TLSClientConfig{} } func (*TLSClientConfig) ProtoMessage() {} func (*TLSClientConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_030104ce3b95bcac, []int{127} + return fileDescriptor_030104ce3b95bcac, []int{132} } func (m *TLSClientConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3632,13 +3773,18 @@ func init() { proto.RegisterType((*ApplicationCondition)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationCondition") proto.RegisterType((*ApplicationDestination)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationDestination") proto.RegisterType((*ApplicationList)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationList") + proto.RegisterType((*ApplicationMatchExpression)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationMatchExpression") proto.RegisterType((*ApplicationSet)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSet") + proto.RegisterType((*ApplicationSetApplicationStatus)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetApplicationStatus") proto.RegisterType((*ApplicationSetCondition)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetCondition") proto.RegisterType((*ApplicationSetGenerator)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetGenerator") proto.RegisterType((*ApplicationSetList)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetList") proto.RegisterType((*ApplicationSetNestedGenerator)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetNestedGenerator") + proto.RegisterType((*ApplicationSetRolloutStep)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetRolloutStep") + proto.RegisterType((*ApplicationSetRolloutStrategy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetRolloutStrategy") proto.RegisterType((*ApplicationSetSpec)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetSpec") proto.RegisterType((*ApplicationSetStatus)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetStatus") + proto.RegisterType((*ApplicationSetStrategy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetStrategy") proto.RegisterType((*ApplicationSetSyncPolicy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetSyncPolicy") proto.RegisterType((*ApplicationSetTemplate)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetTemplate") proto.RegisterType((*ApplicationSetTemplateMeta)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.ApplicationSetTemplateMeta") @@ -3772,591 +3918,609 @@ func init() { } var fileDescriptor_030104ce3b95bcac = []byte{ - // 9332 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x6c, 0x1c, 0x49, - 0x76, 0xd8, 0xf5, 0x7c, 0x71, 0xe6, 0xf1, 0x43, 0x62, 0x49, 0xda, 0xe5, 0x6a, 0x77, 0x45, 0xa1, - 0x17, 0xbe, 0x5b, 0xe7, 0x76, 0xc9, 0xac, 0xbc, 0x77, 0xd9, 0x78, 0xed, 0x3d, 0x73, 0x48, 0x89, - 0xa2, 0x44, 0x8a, 0xdc, 0x22, 0x25, 0xf9, 0xf6, 0x7c, 0x1f, 0xcd, 0x9e, 0x9a, 0x61, 0x8b, 0x33, - 0xdd, 0xa3, 0xee, 0x1e, 0x8a, 0xb3, 0xfe, 0xba, 0x3b, 0x9f, 0xed, 0x4b, 0xee, 0x63, 0x2f, 0xeb, - 0x1f, 0x39, 0x03, 0x41, 0x72, 0x39, 0x1b, 0x46, 0x8c, 0xe4, 0x10, 0x07, 0xf9, 0x91, 0x38, 0x41, - 0x80, 0xc4, 0xce, 0x8f, 0x0d, 0x1c, 0x20, 0x07, 0xc4, 0xf0, 0x39, 0xb1, 0x43, 0xef, 0x31, 0x08, - 0x12, 0x04, 0x88, 0x83, 0x7c, 0xfc, 0x89, 0x90, 0x1f, 0x46, 0x7d, 0x57, 0xf7, 0xcc, 0x88, 0x33, - 0x62, 0x53, 0xd2, 0x1d, 0xf6, 0xdf, 0xcc, 0x7b, 0xaf, 0xdf, 0x7b, 0x5d, 0x5d, 0xf5, 0xea, 0x55, - 0xd5, 0x7b, 0xaf, 0x60, 0xb5, 0xe1, 0xc5, 0x3b, 0x9d, 0xed, 0x39, 0x37, 0x68, 0xcd, 0x3b, 0x61, - 0x23, 0x68, 0x87, 0xc1, 0x1d, 0xf6, 0xe3, 0x65, 0xb7, 0x36, 0xbf, 0x77, 0x69, 0xbe, 0xbd, 0xdb, - 0x98, 0x77, 0xda, 0x5e, 0x34, 0xef, 0xb4, 0xdb, 0x4d, 0xcf, 0x75, 0x62, 0x2f, 0xf0, 0xe7, 0xf7, - 0x5e, 0x71, 0x9a, 0xed, 0x1d, 0xe7, 0x95, 0xf9, 0x06, 0xf1, 0x49, 0xe8, 0xc4, 0xa4, 0x36, 0xd7, - 0x0e, 0x83, 0x38, 0x40, 0x3f, 0xa1, 0xb9, 0xcd, 0x49, 0x6e, 0xec, 0xc7, 0x67, 0xdd, 0xda, 0xdc, - 0xde, 0xa5, 0xb9, 0xf6, 0x6e, 0x63, 0x8e, 0x72, 0x9b, 0x33, 0xb8, 0xcd, 0x49, 0x6e, 0xe7, 0x5f, - 0x36, 0x74, 0x69, 0x04, 0x8d, 0x60, 0x9e, 0x31, 0xdd, 0xee, 0xd4, 0xd9, 0x3f, 0xf6, 0x87, 0xfd, - 0xe2, 0xc2, 0xce, 0xdb, 0xbb, 0xaf, 0x45, 0x73, 0x5e, 0x40, 0xd5, 0x9b, 0x77, 0x83, 0x90, 0xcc, - 0xef, 0xf5, 0x28, 0x74, 0xfe, 0xaa, 0xa6, 0x21, 0xfb, 0x31, 0xf1, 0x23, 0x2f, 0xf0, 0xa3, 0x97, - 0xa9, 0x0a, 0x24, 0xdc, 0x23, 0xa1, 0xf9, 0x7a, 0x06, 0x41, 0x3f, 0x4e, 0xaf, 0x6a, 0x4e, 0x2d, - 0xc7, 0xdd, 0xf1, 0x7c, 0x12, 0x76, 0xf5, 0xe3, 0x2d, 0x12, 0x3b, 0xfd, 0x9e, 0x9a, 0x1f, 0xf4, - 0x54, 0xd8, 0xf1, 0x63, 0xaf, 0x45, 0x7a, 0x1e, 0xf8, 0xf8, 0x51, 0x0f, 0x44, 0xee, 0x0e, 0x69, - 0x39, 0xe9, 0xe7, 0xec, 0xbb, 0x30, 0xb9, 0x70, 0x7b, 0x73, 0xa1, 0x13, 0xef, 0x2c, 0x06, 0x7e, - 0xdd, 0x6b, 0xa0, 0x8f, 0xc1, 0xb8, 0xdb, 0xec, 0x44, 0x31, 0x09, 0x6f, 0x38, 0x2d, 0x32, 0x63, - 0x5d, 0xb4, 0x5e, 0xac, 0x54, 0xcf, 0xbc, 0x77, 0x30, 0xfb, 0xa1, 0xc3, 0x83, 0xd9, 0xf1, 0x45, - 0x8d, 0xc2, 0x26, 0x1d, 0xfa, 0x51, 0x18, 0x0b, 0x83, 0x26, 0x59, 0xc0, 0x37, 0x66, 0x72, 0xec, - 0x91, 0x53, 0xe2, 0x91, 0x31, 0xcc, 0xc1, 0x58, 0xe2, 0xed, 0x3f, 0xca, 0x01, 0x2c, 0xb4, 0xdb, - 0x1b, 0x61, 0x70, 0x87, 0xb8, 0x31, 0xfa, 0x1c, 0x94, 0x69, 0x2b, 0xd4, 0x9c, 0xd8, 0x61, 0xd2, - 0xc6, 0x2f, 0xfd, 0xe5, 0x39, 0xfe, 0x32, 0x73, 0xe6, 0xcb, 0xe8, 0x3e, 0x40, 0xa9, 0xe7, 0xf6, - 0x5e, 0x99, 0x5b, 0xdf, 0xa6, 0xcf, 0xaf, 0x91, 0xd8, 0xa9, 0x22, 0x21, 0x0c, 0x34, 0x0c, 0x2b, - 0xae, 0xc8, 0x87, 0x42, 0xd4, 0x26, 0x2e, 0x53, 0x6c, 0xfc, 0xd2, 0xea, 0xdc, 0x71, 0x3a, 0xdb, - 0x9c, 0xd6, 0x7c, 0xb3, 0x4d, 0xdc, 0xea, 0x84, 0x90, 0x5c, 0xa0, 0xff, 0x30, 0x93, 0x83, 0xf6, - 0xa0, 0x14, 0xc5, 0x4e, 0xdc, 0x89, 0x66, 0xf2, 0x4c, 0xe2, 0x8d, 0xcc, 0x24, 0x32, 0xae, 0xd5, - 0x29, 0x21, 0xb3, 0xc4, 0xff, 0x63, 0x21, 0xcd, 0xfe, 0x4f, 0x16, 0x4c, 0x69, 0xe2, 0x55, 0x2f, - 0x8a, 0xd1, 0xcf, 0xf4, 0x34, 0xee, 0xdc, 0x70, 0x8d, 0x4b, 0x9f, 0x66, 0x4d, 0x7b, 0x5a, 0x08, - 0x2b, 0x4b, 0x88, 0xd1, 0xb0, 0x2d, 0x28, 0x7a, 0x31, 0x69, 0x45, 0x33, 0xb9, 0x8b, 0xf9, 0x17, - 0xc7, 0x2f, 0x5d, 0xcd, 0xea, 0x3d, 0xab, 0x93, 0x42, 0x68, 0x71, 0x85, 0xb2, 0xc7, 0x5c, 0x8a, - 0xfd, 0xdb, 0x13, 0xe6, 0xfb, 0xd1, 0x06, 0x47, 0xaf, 0xc0, 0x78, 0x14, 0x74, 0x42, 0x97, 0x60, - 0xd2, 0x0e, 0xa2, 0x19, 0xeb, 0x62, 0x9e, 0x76, 0x3d, 0xda, 0x53, 0x37, 0x35, 0x18, 0x9b, 0x34, - 0xe8, 0xeb, 0x16, 0x4c, 0xd4, 0x48, 0x14, 0x7b, 0x3e, 0x93, 0x2f, 0x95, 0xdf, 0x3a, 0xb6, 0xf2, - 0x12, 0xb8, 0xa4, 0x99, 0x57, 0xcf, 0x8a, 0x17, 0x99, 0x30, 0x80, 0x11, 0x4e, 0xc8, 0xa7, 0x23, - 0xae, 0x46, 0x22, 0x37, 0xf4, 0xda, 0xf4, 0x3f, 0xeb, 0x33, 0xc6, 0x88, 0x5b, 0xd2, 0x28, 0x6c, - 0xd2, 0x21, 0x1f, 0x8a, 0x74, 0x44, 0x45, 0x33, 0x05, 0xa6, 0xff, 0xca, 0xf1, 0xf4, 0x17, 0x8d, - 0x4a, 0x07, 0xab, 0x6e, 0x7d, 0xfa, 0x2f, 0xc2, 0x5c, 0x0c, 0xfa, 0x9a, 0x05, 0x33, 0x62, 0xc4, - 0x63, 0xc2, 0x1b, 0xf4, 0xf6, 0x8e, 0x17, 0x93, 0xa6, 0x17, 0xc5, 0x33, 0x45, 0xa6, 0xc3, 0xfc, - 0x70, 0x7d, 0x6b, 0x39, 0x0c, 0x3a, 0xed, 0xeb, 0x9e, 0x5f, 0xab, 0x5e, 0x14, 0x92, 0x66, 0x16, - 0x07, 0x30, 0xc6, 0x03, 0x45, 0xa2, 0x5f, 0xb3, 0xe0, 0xbc, 0xef, 0xb4, 0x48, 0xd4, 0x76, 0xe8, - 0xa7, 0xe5, 0xe8, 0x6a, 0xd3, 0x71, 0x77, 0x99, 0x46, 0xa5, 0x87, 0xd3, 0xc8, 0x16, 0x1a, 0x9d, - 0xbf, 0x31, 0x90, 0x35, 0x7e, 0x80, 0x58, 0xf4, 0x1b, 0x16, 0x4c, 0x07, 0x61, 0x7b, 0xc7, 0xf1, - 0x49, 0x4d, 0x62, 0xa3, 0x99, 0x31, 0x36, 0xf4, 0x3e, 0x73, 0xbc, 0x4f, 0xb4, 0x9e, 0x66, 0xbb, - 0x16, 0xf8, 0x5e, 0x1c, 0x84, 0x9b, 0x24, 0x8e, 0x3d, 0xbf, 0x11, 0x55, 0xcf, 0x1d, 0x1e, 0xcc, - 0x4e, 0xf7, 0x50, 0xe1, 0x5e, 0x7d, 0xd0, 0xcf, 0xc2, 0x78, 0xd4, 0xf5, 0xdd, 0xdb, 0x9e, 0x5f, - 0x0b, 0xee, 0x45, 0x33, 0xe5, 0x2c, 0x86, 0xef, 0xa6, 0x62, 0x28, 0x06, 0xa0, 0x16, 0x80, 0x4d, - 0x69, 0xfd, 0x3f, 0x9c, 0xee, 0x4a, 0x95, 0xac, 0x3f, 0x9c, 0xee, 0x4c, 0x0f, 0x10, 0x8b, 0x7e, - 0xd5, 0x82, 0xc9, 0xc8, 0x6b, 0xf8, 0x4e, 0xdc, 0x09, 0xc9, 0x75, 0xd2, 0x8d, 0x66, 0x80, 0x29, - 0x72, 0xed, 0x98, 0xad, 0x62, 0xb0, 0xac, 0x9e, 0x13, 0x3a, 0x4e, 0x9a, 0xd0, 0x08, 0x27, 0xe5, - 0xf6, 0x1b, 0x68, 0xba, 0x5b, 0x8f, 0x67, 0x3b, 0xd0, 0x74, 0xa7, 0x1e, 0x28, 0x12, 0xfd, 0x14, - 0x9c, 0xe6, 0x20, 0xd5, 0xb2, 0xd1, 0xcc, 0x04, 0x33, 0xb4, 0x67, 0x0f, 0x0f, 0x66, 0x4f, 0x6f, - 0xa6, 0x70, 0xb8, 0x87, 0x1a, 0xdd, 0x85, 0xd9, 0x36, 0x09, 0x5b, 0x5e, 0xbc, 0xee, 0x37, 0xbb, - 0xd2, 0x7c, 0xbb, 0x41, 0x9b, 0xd4, 0x84, 0x3a, 0xd1, 0xcc, 0xe4, 0x45, 0xeb, 0xc5, 0x72, 0xf5, - 0x23, 0x42, 0xcd, 0xd9, 0x8d, 0x07, 0x93, 0xe3, 0xa3, 0xf8, 0xd9, 0xff, 0x26, 0x07, 0xa7, 0xd3, - 0x13, 0x27, 0xfa, 0x2d, 0x0b, 0x4e, 0xdd, 0xb9, 0x17, 0x6f, 0x05, 0xbb, 0xc4, 0x8f, 0xaa, 0x5d, - 0x6a, 0xde, 0xd8, 0x94, 0x31, 0x7e, 0xc9, 0xcd, 0x76, 0x8a, 0x9e, 0xbb, 0x96, 0x94, 0x72, 0xd9, - 0x8f, 0xc3, 0x6e, 0xf5, 0x69, 0xf1, 0x76, 0xa7, 0xae, 0xdd, 0xde, 0x32, 0xb1, 0x38, 0xad, 0xd4, - 0xf9, 0xaf, 0x58, 0x70, 0xb6, 0x1f, 0x0b, 0x74, 0x1a, 0xf2, 0xbb, 0xa4, 0xcb, 0xbd, 0x32, 0x4c, - 0x7f, 0xa2, 0x4f, 0x43, 0x71, 0xcf, 0x69, 0x76, 0x88, 0xf0, 0x6e, 0x96, 0x8f, 0xf7, 0x22, 0x4a, - 0x33, 0xcc, 0xb9, 0xfe, 0x78, 0xee, 0x35, 0xcb, 0xfe, 0x77, 0x79, 0x18, 0x37, 0xe6, 0xb7, 0x47, - 0xe0, 0xb1, 0x05, 0x09, 0x8f, 0x6d, 0x2d, 0xb3, 0xa9, 0x79, 0xa0, 0xcb, 0x76, 0x2f, 0xe5, 0xb2, - 0xad, 0x67, 0x27, 0xf2, 0x81, 0x3e, 0x1b, 0x8a, 0xa1, 0x12, 0xb4, 0xa9, 0x47, 0x4e, 0xa7, 0xfe, - 0x42, 0x16, 0x9f, 0x70, 0x5d, 0xb2, 0xab, 0x4e, 0x1e, 0x1e, 0xcc, 0x56, 0xd4, 0x5f, 0xac, 0x05, - 0xd9, 0xdf, 0xb3, 0xe0, 0xac, 0xa1, 0xe3, 0x62, 0xe0, 0xd7, 0x3c, 0xf6, 0x69, 0x2f, 0x42, 0x21, - 0xee, 0xb6, 0xa5, 0xdb, 0xaf, 0x5a, 0x6a, 0xab, 0xdb, 0x26, 0x98, 0x61, 0xa8, 0xa3, 0xdf, 0x22, - 0x51, 0xe4, 0x34, 0x48, 0xda, 0xd1, 0x5f, 0xe3, 0x60, 0x2c, 0xf1, 0x28, 0x04, 0xd4, 0x74, 0xa2, - 0x78, 0x2b, 0x74, 0xfc, 0x88, 0xb1, 0xdf, 0xf2, 0x5a, 0x44, 0x34, 0xf0, 0x5f, 0x1a, 0xae, 0xc7, - 0xd0, 0x27, 0xaa, 0x4f, 0x1d, 0x1e, 0xcc, 0xa2, 0xd5, 0x1e, 0x4e, 0xb8, 0x0f, 0x77, 0xfb, 0xd7, - 0x2c, 0x78, 0xaa, 0xbf, 0x2f, 0x86, 0x3e, 0x0c, 0x25, 0xbe, 0x7a, 0x13, 0x6f, 0xa7, 0x3f, 0x09, - 0x83, 0x62, 0x81, 0x45, 0xf3, 0x50, 0x51, 0xf3, 0x84, 0x78, 0xc7, 0x69, 0x41, 0x5a, 0xd1, 0x93, - 0x8b, 0xa6, 0xa1, 0x8d, 0x46, 0xff, 0x08, 0xcf, 0x4d, 0x35, 0x1a, 0x5b, 0x24, 0x31, 0x8c, 0xfd, - 0x67, 0x16, 0x9c, 0x32, 0xb4, 0x7a, 0x04, 0xae, 0xb9, 0x9f, 0x74, 0xcd, 0x57, 0x32, 0xeb, 0xcf, - 0x03, 0x7c, 0xf3, 0xc3, 0x1c, 0xf3, 0xcd, 0x55, 0xaf, 0x27, 0x8f, 0x62, 0x61, 0x17, 0x26, 0xcc, - 0xc4, 0x46, 0x76, 0x63, 0x96, 0x0c, 0x5e, 0xdc, 0xbd, 0x9d, 0xb2, 0x14, 0x38, 0x53, 0xa9, 0x0f, - 0x5e, 0xe0, 0xfd, 0xf7, 0x1c, 0x3c, 0x9d, 0x7c, 0x40, 0x8f, 0xdc, 0x4f, 0x24, 0x46, 0xee, 0x47, - 0xcd, 0x91, 0x7b, 0xff, 0x60, 0xf6, 0xd9, 0x01, 0x8f, 0xfd, 0xc0, 0x0c, 0x6c, 0xb4, 0xac, 0xda, - 0xbd, 0xc0, 0xb4, 0x9b, 0x4f, 0xb6, 0xd1, 0xfd, 0x83, 0xd9, 0xe7, 0x07, 0xbc, 0x63, 0xca, 0xe2, - 0x7e, 0x18, 0x4a, 0x21, 0x71, 0xa2, 0xc0, 0x9f, 0x29, 0x26, 0xcd, 0x00, 0x66, 0x50, 0x2c, 0xb0, - 0xf6, 0x9f, 0x95, 0xd3, 0x8d, 0xbd, 0xcc, 0xf7, 0x4e, 0x82, 0x10, 0x79, 0x50, 0x60, 0xde, 0x18, - 0xef, 0xd6, 0xd7, 0x8f, 0xd7, 0x05, 0xe8, 0xe8, 0x55, 0xac, 0xab, 0x65, 0xfa, 0xd5, 0x28, 0x08, - 0x33, 0x11, 0x68, 0x1f, 0xca, 0xae, 0x74, 0x92, 0x72, 0x59, 0x6c, 0x27, 0x08, 0x17, 0x49, 0x4b, - 0x9c, 0xa0, 0x26, 0x44, 0x79, 0x56, 0x4a, 0x1a, 0x22, 0x90, 0x6f, 0x78, 0xb1, 0xf8, 0xac, 0xc7, - 0x74, 0x83, 0x97, 0x3d, 0xe3, 0x15, 0xc7, 0x0e, 0x0f, 0x66, 0xf3, 0xcb, 0x5e, 0x8c, 0x29, 0x7f, - 0xf4, 0xcb, 0x16, 0x8c, 0x47, 0x6e, 0x6b, 0x23, 0x0c, 0xf6, 0xbc, 0x1a, 0x09, 0xc5, 0x24, 0x78, - 0xcc, 0x61, 0xb5, 0xb9, 0xb8, 0x26, 0x19, 0x6a, 0xb9, 0x7c, 0x59, 0xa2, 0x31, 0xd8, 0x94, 0x4b, - 0x9d, 0xc3, 0xa7, 0xc5, 0xbb, 0x2f, 0x11, 0xd7, 0x8b, 0xe8, 0x94, 0x29, 0x7c, 0x61, 0xd6, 0x53, - 0x8e, 0xed, 0x14, 0x2c, 0x75, 0xdc, 0x5d, 0x3a, 0xde, 0xb4, 0x42, 0xcf, 0x1e, 0x1e, 0xcc, 0x3e, - 0xbd, 0xd8, 0x5f, 0x26, 0x1e, 0xa4, 0x0c, 0x6b, 0xb0, 0x76, 0xa7, 0xd9, 0xc4, 0xe4, 0x6e, 0x87, - 0xb0, 0x95, 0x6e, 0x06, 0x0d, 0xb6, 0xa1, 0x19, 0xa6, 0x1a, 0xcc, 0xc0, 0x60, 0x53, 0x2e, 0xba, - 0x0b, 0xa5, 0x96, 0x13, 0x87, 0xde, 0xbe, 0x58, 0xde, 0x1e, 0xd3, 0x4d, 0x5b, 0x63, 0xbc, 0xb4, - 0x70, 0xa0, 0x63, 0x92, 0x03, 0xb1, 0x10, 0x84, 0x5a, 0x50, 0x6c, 0x91, 0xb0, 0x41, 0x66, 0xca, - 0x59, 0x6c, 0xe5, 0xad, 0x51, 0x56, 0x5a, 0x60, 0x85, 0x4e, 0x6a, 0x0c, 0x86, 0xb9, 0x14, 0xf4, - 0x69, 0x28, 0x47, 0xa4, 0x49, 0xdc, 0x38, 0x08, 0x67, 0x2a, 0x4c, 0xe2, 0x8f, 0x0d, 0x39, 0x45, - 0x3b, 0xdb, 0xa4, 0xb9, 0x29, 0x1e, 0xe5, 0x03, 0x4c, 0xfe, 0xc3, 0x8a, 0xa5, 0xfd, 0x5f, 0x2c, - 0x40, 0x49, 0x0b, 0xf3, 0x08, 0x1c, 0x83, 0xbb, 0x49, 0xc7, 0x60, 0x35, 0xcb, 0xe9, 0x6b, 0x80, - 0x6f, 0xf0, 0x5e, 0x19, 0x52, 0xb6, 0xf9, 0x06, 0x89, 0x62, 0x52, 0xfb, 0xc0, 0x9e, 0x7e, 0x60, - 0x4f, 0x3f, 0xb0, 0xa7, 0xca, 0x9e, 0x6e, 0xa7, 0xec, 0xe9, 0x1b, 0xc6, 0xa8, 0xd7, 0x67, 0x4c, - 0x9f, 0x55, 0x87, 0x50, 0xa6, 0x06, 0x06, 0x01, 0xb5, 0x04, 0xd7, 0x36, 0xd7, 0x6f, 0xf4, 0x35, - 0xa0, 0x9f, 0x4d, 0x1a, 0xd0, 0xe3, 0x8a, 0x78, 0xe4, 0x26, 0xf3, 0x30, 0x9f, 0x36, 0x99, 0xec, - 0x18, 0xe0, 0x12, 0x40, 0x23, 0xd8, 0x22, 0xad, 0x76, 0xd3, 0x89, 0xb9, 0x0b, 0x5c, 0xd6, 0x4b, - 0x87, 0x65, 0x85, 0xc1, 0x06, 0x15, 0xfa, 0x6b, 0x16, 0x40, 0x43, 0x7e, 0x1a, 0x69, 0x0e, 0x6f, - 0x66, 0x69, 0x0e, 0xf5, 0x87, 0xd7, 0xba, 0x28, 0x81, 0xd8, 0x10, 0x8e, 0xbe, 0x68, 0x41, 0x39, - 0x96, 0xea, 0x73, 0x03, 0xb1, 0x95, 0xa5, 0x26, 0xf2, 0xa5, 0xf5, 0xcc, 0xa0, 0x9a, 0x44, 0xc9, - 0x45, 0xbf, 0x62, 0x01, 0x44, 0x5d, 0xdf, 0xdd, 0x08, 0x9a, 0x9e, 0xdb, 0x15, 0x76, 0xe3, 0x56, - 0xa6, 0xcb, 0x1b, 0xc5, 0xbd, 0x3a, 0x45, 0x5b, 0x43, 0xff, 0xc7, 0x86, 0x64, 0xfb, 0xdb, 0xc9, - 0xdd, 0x09, 0xb5, 0x2e, 0x62, 0x9f, 0xcc, 0x95, 0x6e, 0x7d, 0x24, 0xb6, 0xee, 0x32, 0xfd, 0x64, - 0x6a, 0xd1, 0xa0, 0x3f, 0x99, 0x02, 0x45, 0xd8, 0x10, 0x6e, 0x7f, 0xc1, 0x82, 0x99, 0x41, 0x6f, - 0x87, 0x08, 0x3c, 0xdb, 0x0e, 0x09, 0x1b, 0x43, 0x6a, 0xd3, 0x7d, 0xdd, 0x5f, 0x22, 0x4d, 0xc2, - 0xf6, 0x79, 0x78, 0x07, 0x7d, 0x41, 0x48, 0x78, 0x76, 0x63, 0x30, 0x29, 0x7e, 0x10, 0x1f, 0xfb, - 0x37, 0x73, 0x89, 0xcd, 0x0e, 0xe3, 0x43, 0xa3, 0x6f, 0x5a, 0x3d, 0x5e, 0xc4, 0x4f, 0x9f, 0x44, - 0x8f, 0x62, 0xfe, 0x86, 0xda, 0x7b, 0x1f, 0x4c, 0xf3, 0x18, 0x37, 0xf7, 0xec, 0x7f, 0x5b, 0x80, - 0x07, 0x68, 0xa6, 0xb6, 0x6f, 0xac, 0x41, 0xdb, 0x37, 0xa3, 0xef, 0x08, 0x7d, 0xd5, 0x82, 0x52, - 0x93, 0x1a, 0xb4, 0x68, 0x26, 0xcf, 0x3a, 0x69, 0xed, 0xa4, 0xda, 0x9e, 0xdb, 0xcd, 0x88, 0x6f, - 0x30, 0xab, 0xa5, 0x2c, 0x07, 0x62, 0xa1, 0x03, 0xfa, 0x96, 0x05, 0xe3, 0x8e, 0xef, 0x07, 0xb1, - 0x38, 0xf1, 0xe4, 0x27, 0x86, 0xde, 0x89, 0xe9, 0xb4, 0xa0, 0x65, 0x71, 0xc5, 0xd4, 0x69, 0xa6, - 0x81, 0xc1, 0xa6, 0x4a, 0x68, 0x0e, 0xa0, 0xee, 0xf9, 0x4e, 0xd3, 0x7b, 0x9b, 0x3a, 0x66, 0x45, - 0x76, 0xbc, 0xc0, 0x6c, 0xc4, 0x15, 0x05, 0xc5, 0x06, 0xc5, 0xf9, 0xbf, 0x0a, 0xe3, 0xc6, 0x9b, - 0xf7, 0xd9, 0x17, 0x3f, 0x6b, 0xee, 0x8b, 0x57, 0x8c, 0xed, 0xec, 0xf3, 0x6f, 0xc0, 0xe9, 0xb4, - 0x82, 0xa3, 0x3c, 0x6f, 0xff, 0x56, 0x09, 0x66, 0xd3, 0x2f, 0x1f, 0xb6, 0xa8, 0x6a, 0x1f, 0x38, - 0xb4, 0x1f, 0x38, 0xb4, 0x1f, 0x38, 0xb4, 0xf2, 0x8f, 0x7d, 0x58, 0x84, 0x69, 0x73, 0xa0, 0x70, - 0xed, 0x7e, 0x14, 0xc6, 0x42, 0xd2, 0x0e, 0x6e, 0xe2, 0x55, 0x61, 0x71, 0x75, 0xa4, 0x10, 0x07, - 0x63, 0x89, 0xa7, 0x96, 0xb9, 0xed, 0xc4, 0x3b, 0xc2, 0xe4, 0x2a, 0xcb, 0xbc, 0xe1, 0xc4, 0x3b, - 0x98, 0x61, 0xd0, 0x1b, 0x30, 0x15, 0x3b, 0x61, 0x83, 0xc4, 0x98, 0xec, 0xb1, 0x46, 0x10, 0xbb, - 0x83, 0x4f, 0x09, 0xda, 0xa9, 0xad, 0x04, 0x16, 0xa7, 0xa8, 0xd1, 0x5d, 0x28, 0xec, 0x90, 0x66, - 0x4b, 0x78, 0xdc, 0x9b, 0xd9, 0x59, 0x44, 0xf6, 0xae, 0x57, 0x49, 0xb3, 0xc5, 0xc7, 0x2b, 0xfd, - 0x85, 0x99, 0x28, 0xfa, 0x75, 0x2a, 0xbb, 0x9d, 0x28, 0x0e, 0x5a, 0xde, 0xdb, 0xd2, 0x0f, 0xff, - 0xe9, 0x8c, 0x05, 0x5f, 0x97, 0xfc, 0xf9, 0x19, 0x90, 0xfa, 0x8b, 0xb5, 0x64, 0xa6, 0x47, 0xcd, - 0x0b, 0x99, 0x5f, 0xdd, 0x9d, 0x81, 0x13, 0xd1, 0x63, 0x49, 0xf2, 0xe7, 0x7a, 0xa8, 0xbf, 0x58, - 0x4b, 0x46, 0x5d, 0x28, 0xb5, 0x9b, 0x9d, 0x86, 0xe7, 0xcf, 0x8c, 0x33, 0x1d, 0x6e, 0x66, 0xac, - 0xc3, 0x06, 0x63, 0xce, 0x57, 0x43, 0xfc, 0x37, 0x16, 0x02, 0xd1, 0x0b, 0x50, 0x74, 0x77, 0x9c, - 0x30, 0x9e, 0x99, 0x60, 0x9d, 0x46, 0xed, 0x5e, 0x2c, 0x52, 0x20, 0xe6, 0x38, 0xf4, 0x3c, 0xe4, - 0x43, 0x52, 0x67, 0x07, 0xd4, 0x95, 0xea, 0xb8, 0x20, 0xc9, 0x63, 0x52, 0xc7, 0x14, 0x6e, 0xff, - 0xdd, 0x5c, 0xd2, 0xb9, 0x48, 0xbe, 0x37, 0xef, 0xed, 0x6e, 0x27, 0x8c, 0xe4, 0xb2, 0xc4, 0xe8, - 0xed, 0x0c, 0x8c, 0x25, 0x1e, 0x7d, 0xc1, 0x82, 0xb1, 0x3b, 0x51, 0xe0, 0xfb, 0x24, 0x16, 0x86, - 0xfc, 0x56, 0xc6, 0x4d, 0x71, 0x8d, 0x73, 0xd7, 0x3a, 0x08, 0x00, 0x96, 0x72, 0xa9, 0xba, 0x64, - 0xdf, 0x6d, 0x76, 0x6a, 0xf2, 0x34, 0x4b, 0x91, 0x5e, 0xe6, 0x60, 0x2c, 0xf1, 0x94, 0xd4, 0xf3, - 0x39, 0x69, 0x21, 0x49, 0xba, 0xe2, 0x0b, 0x52, 0x81, 0xb7, 0x7f, 0xa7, 0x08, 0xe7, 0xfa, 0x0e, - 0x0e, 0x3a, 0xed, 0xb3, 0x89, 0xf5, 0x8a, 0xd7, 0x24, 0x32, 0x7c, 0x8b, 0x4d, 0xfb, 0xb7, 0x14, - 0x14, 0x1b, 0x14, 0xe8, 0x17, 0x01, 0xda, 0x4e, 0xe8, 0xb4, 0x88, 0x98, 0xee, 0xf2, 0xc7, 0x9f, - 0x5d, 0xa9, 0x1e, 0x1b, 0x92, 0xa7, 0x76, 0xfb, 0x15, 0x28, 0xc2, 0x86, 0x48, 0xf4, 0x31, 0x18, - 0x0f, 0x49, 0x93, 0x38, 0x11, 0x8b, 0x6f, 0x48, 0x07, 0x6b, 0x61, 0x8d, 0xc2, 0x26, 0x1d, 0xfa, - 0x30, 0x94, 0xd8, 0x5b, 0xc8, 0xd3, 0x0b, 0xe5, 0xa9, 0xb1, 0xf7, 0x8c, 0xb0, 0xc0, 0xa2, 0x77, - 0x2c, 0x98, 0xaa, 0x7b, 0x4d, 0xa2, 0xa5, 0x8b, 0xd0, 0xaa, 0xf5, 0xe3, 0xbf, 0xe4, 0x15, 0x93, - 0xaf, 0xb6, 0x90, 0x09, 0x70, 0x84, 0x53, 0xe2, 0xe9, 0x67, 0xde, 0x23, 0x21, 0x33, 0xad, 0xa5, - 0xe4, 0x67, 0xbe, 0xc5, 0xc1, 0x58, 0xe2, 0xd1, 0x02, 0x9c, 0x6a, 0x3b, 0x51, 0xb4, 0x18, 0x92, - 0x1a, 0xf1, 0x63, 0xcf, 0x69, 0xf2, 0xc0, 0xa7, 0xb2, 0x0e, 0x7c, 0xd8, 0x48, 0xa2, 0x71, 0x9a, - 0x1e, 0x7d, 0x12, 0x9e, 0xf6, 0x1a, 0x7e, 0x10, 0x92, 0x35, 0x2f, 0x8a, 0x3c, 0xbf, 0xa1, 0xbb, - 0x01, 0xb3, 0x94, 0xe5, 0xea, 0xac, 0x60, 0xf5, 0xf4, 0x4a, 0x7f, 0x32, 0x3c, 0xe8, 0x79, 0xf4, - 0x12, 0x94, 0xa3, 0x5d, 0xaf, 0xbd, 0x18, 0xd6, 0x22, 0xb6, 0x33, 0x51, 0xd6, 0x8b, 0xe1, 0x4d, - 0x01, 0xc7, 0x8a, 0xc2, 0xfe, 0xf5, 0x5c, 0x72, 0x79, 0x67, 0x8e, 0x1f, 0x14, 0xd1, 0x51, 0x12, - 0xdf, 0x72, 0x42, 0xb9, 0x06, 0x3d, 0x66, 0xe8, 0x94, 0xe0, 0x7b, 0xcb, 0x09, 0xcd, 0xf1, 0xc6, - 0x04, 0x60, 0x29, 0x09, 0xdd, 0x81, 0x42, 0xdc, 0x74, 0x32, 0x8a, 0xb5, 0x34, 0x24, 0xea, 0x43, - 0xfe, 0xd5, 0x85, 0x08, 0x33, 0x19, 0xe8, 0x39, 0xea, 0xbe, 0x6e, 0xf3, 0xc5, 0x4b, 0x45, 0x7a, - 0x9c, 0xdb, 0x11, 0x66, 0x50, 0xfb, 0x7f, 0x96, 0xfa, 0x98, 0x3c, 0x35, 0xc7, 0xa0, 0x4b, 0x00, - 0x74, 0x25, 0xb4, 0x11, 0x92, 0xba, 0xb7, 0x2f, 0xe6, 0x78, 0x35, 0xac, 0x6e, 0x28, 0x0c, 0x36, - 0xa8, 0xe4, 0x33, 0x9b, 0x9d, 0x3a, 0x7d, 0x26, 0xd7, 0xfb, 0x0c, 0xc7, 0x60, 0x83, 0x0a, 0xbd, - 0x0a, 0x25, 0xaf, 0xe5, 0x34, 0x88, 0x54, 0xf3, 0x39, 0x3a, 0x9e, 0x56, 0x18, 0xe4, 0xfe, 0xc1, - 0xec, 0x94, 0x52, 0x88, 0x81, 0xb0, 0xa0, 0x45, 0xbf, 0x69, 0xc1, 0x84, 0x1b, 0xb4, 0x5a, 0x81, - 0xcf, 0xd7, 0x0f, 0x62, 0x31, 0x74, 0xe7, 0xa4, 0x66, 0xe0, 0xb9, 0x45, 0x43, 0x18, 0x5f, 0x0d, - 0xa9, 0xa0, 0x50, 0x13, 0x85, 0x13, 0x5a, 0x99, 0xc3, 0xae, 0x78, 0xc4, 0xb0, 0xfb, 0xa7, 0x16, - 0x4c, 0xf3, 0x67, 0x8d, 0x65, 0x8d, 0x88, 0x7f, 0x0c, 0x4e, 0xf8, 0xb5, 0x7a, 0x56, 0x7a, 0xcf, - 0x08, 0x35, 0xa7, 0x7b, 0xf0, 0xb8, 0x57, 0x49, 0xb4, 0x0c, 0xd3, 0xf5, 0x20, 0x74, 0x89, 0xd9, - 0x10, 0xc2, 0x66, 0x28, 0x46, 0x57, 0xd2, 0x04, 0xb8, 0xf7, 0x19, 0x74, 0x0b, 0x9e, 0x32, 0x80, - 0x66, 0x3b, 0x70, 0xb3, 0x71, 0x41, 0x70, 0x7b, 0xea, 0x4a, 0x5f, 0x2a, 0x3c, 0xe0, 0xe9, 0xf3, - 0x9f, 0x80, 0xe9, 0x9e, 0xef, 0x37, 0xd2, 0x62, 0x73, 0x09, 0x9e, 0xea, 0xdf, 0x52, 0x23, 0x2d, - 0x39, 0xff, 0x71, 0xea, 0xe0, 0xdf, 0x70, 0x6c, 0x86, 0xd8, 0xbe, 0x70, 0x20, 0x4f, 0xfc, 0x3d, - 0x61, 0x38, 0xae, 0x1c, 0xaf, 0x47, 0x5c, 0xf6, 0xf7, 0xf8, 0x87, 0x66, 0x6b, 0xb4, 0xcb, 0xfe, - 0x1e, 0xa6, 0xbc, 0xd1, 0xbb, 0x56, 0x62, 0x62, 0xe6, 0x9b, 0x1e, 0x9f, 0x39, 0x11, 0x4f, 0x6e, - 0xe8, 0xb9, 0xda, 0xfe, 0x83, 0x1c, 0x5c, 0x3c, 0x8a, 0xc9, 0x10, 0xcd, 0xf7, 0x02, 0x94, 0xa2, - 0x38, 0xf4, 0xfc, 0x86, 0x18, 0x89, 0xe3, 0x74, 0x14, 0x6e, 0x32, 0xc8, 0x67, 0xb1, 0x40, 0xa1, - 0x5f, 0xb1, 0x20, 0xdf, 0x72, 0xda, 0xe2, 0xcd, 0x1b, 0x27, 0xfb, 0xe6, 0x73, 0x6b, 0x4e, 0x9b, - 0x7f, 0x05, 0xe5, 0x8f, 0xae, 0x39, 0x6d, 0x4c, 0x15, 0x40, 0xb3, 0x50, 0x74, 0xc2, 0xd0, 0xe9, - 0x32, 0xbb, 0x56, 0xe1, 0x3b, 0xf4, 0x0b, 0x14, 0x80, 0x39, 0xfc, 0xfc, 0xc7, 0xa1, 0x2c, 0x1f, - 0x1f, 0xa9, 0x0f, 0x7e, 0x75, 0x2c, 0x11, 0xc3, 0xc4, 0xf6, 0xdd, 0x23, 0x28, 0x89, 0x05, 0xb0, - 0x95, 0x75, 0xd8, 0x1c, 0x0f, 0x42, 0x65, 0x5e, 0xbb, 0x08, 0xe5, 0x17, 0xa2, 0xd0, 0x57, 0x2c, - 0x16, 0x30, 0x2f, 0xe3, 0xba, 0x84, 0xaf, 0x7c, 0x32, 0xf1, 0xfb, 0x66, 0x18, 0xbe, 0x04, 0x62, - 0x53, 0x3a, 0x35, 0xd4, 0x6d, 0x1e, 0xfa, 0x99, 0xf6, 0x98, 0x65, 0x48, 0xbd, 0xc4, 0xa3, 0xfd, - 0x3e, 0xfb, 0xeb, 0x19, 0x04, 0x5d, 0x1f, 0xbd, 0xa3, 0x8e, 0xbe, 0x65, 0xc1, 0x34, 0xf7, 0x8b, - 0x96, 0xbc, 0x7a, 0x9d, 0x84, 0xc4, 0x77, 0x89, 0xf4, 0x2c, 0x6f, 0x1f, 0x4f, 0x03, 0xb9, 0xeb, - 0xb0, 0x92, 0x66, 0xaf, 0x2d, 0x78, 0x0f, 0x0a, 0xf7, 0x2a, 0x83, 0x6a, 0x50, 0xf0, 0xfc, 0x7a, - 0x20, 0xe6, 0xad, 0xea, 0xf1, 0x94, 0x5a, 0xf1, 0xeb, 0x81, 0x1e, 0xcb, 0xf4, 0x1f, 0x66, 0xdc, - 0xd1, 0x2a, 0x9c, 0x0d, 0xc5, 0xda, 0xff, 0xaa, 0x17, 0xd1, 0x15, 0xda, 0xaa, 0xd7, 0xf2, 0x62, - 0x36, 0xe7, 0xe4, 0xab, 0x33, 0x87, 0x07, 0xb3, 0x67, 0x71, 0x1f, 0x3c, 0xee, 0xfb, 0x14, 0x7a, - 0x1b, 0xc6, 0x64, 0x84, 0x7f, 0x39, 0x0b, 0x2f, 0xbd, 0xb7, 0xff, 0xab, 0xce, 0xb4, 0x29, 0x82, - 0xf9, 0xa5, 0x40, 0xfb, 0x5f, 0x42, 0x72, 0x73, 0x85, 0x9f, 0x90, 0xfc, 0x3c, 0x54, 0x42, 0x95, - 0x75, 0x60, 0x65, 0x71, 0xc2, 0x2f, 0xbf, 0xaf, 0x08, 0x4d, 0x53, 0xfb, 0xde, 0x3a, 0xbf, 0x40, - 0x4b, 0xa4, 0x3e, 0x2a, 0xed, 0x75, 0x62, 0x48, 0x66, 0xd0, 0xb7, 0x85, 0x54, 0xbd, 0xab, 0xdf, - 0xf5, 0x5d, 0xcc, 0x64, 0xa0, 0x10, 0x4a, 0x3b, 0xc4, 0x69, 0xc6, 0x3b, 0xd9, 0x6c, 0x40, 0x5e, - 0x65, 0xbc, 0xd2, 0x01, 0x78, 0x1c, 0x8a, 0x85, 0x24, 0xb4, 0x0f, 0x63, 0x3b, 0xbc, 0x03, 0x08, - 0xb7, 0x71, 0xed, 0xb8, 0x8d, 0x9b, 0xe8, 0x55, 0xfa, 0x73, 0x0b, 0x00, 0x96, 0xe2, 0xd8, 0xe1, - 0x9c, 0x71, 0xf4, 0xc5, 0x87, 0x6e, 0x76, 0xb1, 0x87, 0x43, 0x9f, 0x7b, 0xa1, 0xcf, 0xc1, 0x44, - 0x48, 0xdc, 0xc0, 0x77, 0xbd, 0x26, 0xa9, 0x2d, 0xc8, 0xcd, 0xc5, 0x51, 0xa2, 0xfe, 0x4e, 0x53, - 0xd7, 0x17, 0x1b, 0x3c, 0x70, 0x82, 0x23, 0xfa, 0xb2, 0x05, 0x53, 0x2a, 0x54, 0x99, 0x7e, 0x10, - 0x22, 0xb6, 0xe7, 0x56, 0x33, 0x0a, 0x8c, 0x66, 0x3c, 0xab, 0x88, 0x2e, 0x7e, 0x93, 0x30, 0x9c, - 0x92, 0x8b, 0xde, 0x02, 0x08, 0xb6, 0xd9, 0xf1, 0x1b, 0x7d, 0xd5, 0xf2, 0xc8, 0xaf, 0x3a, 0xc5, - 0x43, 0x57, 0x25, 0x07, 0x6c, 0x70, 0x43, 0xd7, 0x01, 0xf8, 0xb0, 0xd9, 0xea, 0xb6, 0x09, 0x5b, - 0x91, 0xea, 0xb0, 0x4d, 0xd8, 0x54, 0x98, 0xfb, 0x07, 0xb3, 0xbd, 0x7b, 0x27, 0x2c, 0x6c, 0xd3, - 0x78, 0x1c, 0xfd, 0x2c, 0x8c, 0x45, 0x9d, 0x56, 0xcb, 0x51, 0x3b, 0x79, 0x19, 0x06, 0xc3, 0x72, - 0xbe, 0x86, 0x29, 0xe2, 0x00, 0x2c, 0x25, 0xa2, 0x3b, 0xd4, 0xa8, 0x46, 0x62, 0x53, 0x87, 0x8d, - 0x22, 0xee, 0x13, 0x8c, 0xb3, 0x77, 0xfa, 0xb8, 0x78, 0xee, 0x2c, 0xee, 0x43, 0x73, 0xff, 0x60, - 0xf6, 0xa9, 0x24, 0x7c, 0x35, 0xe0, 0x62, 0x71, 0x5f, 0x9e, 0xe8, 0x9a, 0x4c, 0xf8, 0xa3, 0xaf, - 0x2d, 0xf3, 0x50, 0x5e, 0xd4, 0x09, 0x7f, 0x0c, 0x3c, 0xb8, 0xcd, 0xcc, 0x87, 0x6d, 0x3f, 0x19, - 0x4b, 0x20, 0xde, 0xe6, 0x55, 0x98, 0x20, 0xfb, 0x31, 0x09, 0x7d, 0xa7, 0x79, 0x13, 0xaf, 0xca, - 0x4d, 0x29, 0xd6, 0x69, 0x2f, 0x1b, 0x70, 0x9c, 0xa0, 0x42, 0xb6, 0x5a, 0x8c, 0xe6, 0x18, 0x3d, - 0xe8, 0xc5, 0xa8, 0x5c, 0x7a, 0xda, 0xff, 0x2f, 0x97, 0xf0, 0xa0, 0xb6, 0x42, 0x42, 0x50, 0x00, - 0x45, 0x3f, 0xa8, 0x29, 0x63, 0x7d, 0x2d, 0x1b, 0x63, 0x7d, 0x23, 0xa8, 0x19, 0x69, 0x7c, 0xf4, - 0x5f, 0x84, 0xb9, 0x1c, 0x96, 0xe7, 0x24, 0x13, 0xc2, 0x18, 0x42, 0xac, 0x0b, 0xb2, 0x94, 0xac, - 0xf2, 0x9c, 0xd6, 0x4d, 0x41, 0x38, 0x29, 0x17, 0xed, 0x42, 0x71, 0x27, 0x88, 0x62, 0xb9, 0x5a, - 0x38, 0xe6, 0xc2, 0xe4, 0x6a, 0x10, 0xc5, 0x6c, 0xda, 0x57, 0xaf, 0x4d, 0x21, 0x11, 0xe6, 0x32, - 0xec, 0xff, 0x6a, 0x25, 0xb6, 0x20, 0x6f, 0x3b, 0xb1, 0xbb, 0x73, 0x79, 0x8f, 0xf8, 0x74, 0x1c, - 0x9a, 0x81, 0xd3, 0x7f, 0x25, 0x15, 0x38, 0xfd, 0x91, 0x41, 0x79, 0xd5, 0xf7, 0x28, 0x87, 0x39, - 0xc6, 0xc2, 0x08, 0xa2, 0xfe, 0xbc, 0x05, 0xe3, 0x86, 0x7a, 0x62, 0x22, 0xcc, 0x30, 0xfa, 0x5e, - 0x9f, 0xa4, 0x6a, 0x20, 0x36, 0x45, 0xda, 0xef, 0x5a, 0x30, 0x56, 0x75, 0xdc, 0xdd, 0xa0, 0x5e, - 0x47, 0x2f, 0x41, 0xb9, 0xd6, 0x11, 0xc9, 0x25, 0xfc, 0xfd, 0xd4, 0x9e, 0xd7, 0x92, 0x80, 0x63, - 0x45, 0x41, 0xfb, 0x70, 0xdd, 0x61, 0x91, 0x3b, 0x39, 0xe6, 0x0e, 0xb1, 0x3e, 0x7c, 0x85, 0x41, - 0xb0, 0xc0, 0xa0, 0x8f, 0xc1, 0x78, 0xcb, 0xd9, 0x97, 0x0f, 0xa7, 0xf7, 0x3f, 0xd7, 0x34, 0x0a, - 0x9b, 0x74, 0xf6, 0xbf, 0xb6, 0x60, 0xa6, 0xea, 0x44, 0x9e, 0xbb, 0xd0, 0x89, 0x77, 0xaa, 0x5e, - 0xbc, 0xdd, 0x71, 0x77, 0x49, 0xcc, 0x13, 0x2f, 0xa8, 0x96, 0x9d, 0x88, 0x0e, 0x25, 0xb5, 0x0c, - 0x53, 0x5a, 0xde, 0x14, 0x70, 0xac, 0x28, 0xd0, 0xdb, 0x30, 0xde, 0x76, 0xa2, 0xe8, 0x5e, 0x10, - 0xd6, 0x30, 0xa9, 0x67, 0x93, 0xf6, 0xb4, 0x49, 0xdc, 0x90, 0xc4, 0x98, 0xd4, 0xc5, 0x89, 0x96, - 0xe6, 0x8f, 0x4d, 0x61, 0xf6, 0xbf, 0xaa, 0xc0, 0x98, 0x38, 0x8e, 0x1b, 0x3a, 0x9d, 0x44, 0x2e, - 0x30, 0x73, 0x03, 0x17, 0x98, 0x11, 0x94, 0x5c, 0x96, 0x7c, 0x2f, 0x3c, 0x99, 0xeb, 0x99, 0x9c, - 0xdf, 0xf2, 0x7c, 0x7e, 0xad, 0x16, 0xff, 0x8f, 0x85, 0x28, 0xf4, 0x0d, 0x0b, 0x4e, 0xb9, 0x81, - 0xef, 0x13, 0x57, 0x4f, 0xb3, 0x85, 0x2c, 0x22, 0x32, 0x16, 0x93, 0x4c, 0xf5, 0xe6, 0x6f, 0x0a, - 0x81, 0xd3, 0xe2, 0xd1, 0xeb, 0x30, 0xc9, 0xdb, 0xec, 0x56, 0x62, 0xe7, 0x4b, 0x67, 0x4d, 0x9a, - 0x48, 0x9c, 0xa4, 0x45, 0x73, 0x7c, 0x07, 0x51, 0xe4, 0x27, 0x96, 0xf4, 0x49, 0x82, 0x91, 0x99, - 0x68, 0x50, 0xa0, 0x10, 0x50, 0x48, 0xea, 0x21, 0x89, 0x76, 0xc4, 0x71, 0x25, 0x9b, 0xe2, 0xc7, - 0x1e, 0x2e, 0x87, 0x01, 0xf7, 0x70, 0xc2, 0x7d, 0xb8, 0xa3, 0x5d, 0xb1, 0xc6, 0x29, 0x67, 0x61, - 0x15, 0xc4, 0x67, 0x1e, 0xb8, 0xd4, 0x99, 0x85, 0x62, 0xb4, 0xe3, 0x84, 0x35, 0xe6, 0x5a, 0xe4, - 0xf9, 0x46, 0xc0, 0x26, 0x05, 0x60, 0x0e, 0x47, 0x4b, 0x70, 0x3a, 0x95, 0xf3, 0x19, 0x31, 0xe7, - 0xa1, 0x5c, 0x9d, 0x11, 0xec, 0x4e, 0xa7, 0xb2, 0x45, 0x23, 0xdc, 0xf3, 0x84, 0xb9, 0xfe, 0x1d, - 0x3f, 0x62, 0xfd, 0xdb, 0x55, 0x41, 0x31, 0x13, 0xcc, 0xe2, 0xbf, 0x99, 0x49, 0x03, 0x0c, 0x15, - 0x01, 0xf3, 0xb5, 0x54, 0x04, 0xcc, 0x24, 0x53, 0xe0, 0x56, 0x36, 0x0a, 0x8c, 0x1e, 0xee, 0xf2, - 0x38, 0xc3, 0x57, 0xfe, 0xaf, 0x05, 0xf2, 0xbb, 0x2e, 0x3a, 0xee, 0x0e, 0xa1, 0x5d, 0x06, 0xbd, - 0x01, 0x53, 0x6a, 0x15, 0xb7, 0x18, 0x74, 0x7c, 0x1e, 0xb9, 0x92, 0xd7, 0xa7, 0x44, 0x38, 0x81, - 0xc5, 0x29, 0x6a, 0x34, 0x0f, 0x15, 0xda, 0x4e, 0xfc, 0x51, 0x3e, 0x7b, 0xa8, 0x95, 0xe2, 0xc2, - 0xc6, 0x8a, 0x78, 0x4a, 0xd3, 0xa0, 0x00, 0xa6, 0x9b, 0x4e, 0x14, 0x33, 0x0d, 0xe8, 0xa2, 0xee, - 0x21, 0x33, 0x88, 0x58, 0xca, 0xfb, 0x6a, 0x9a, 0x11, 0xee, 0xe5, 0x6d, 0x7f, 0xaf, 0x00, 0x93, - 0x09, 0xcb, 0x38, 0xe2, 0xb4, 0xf3, 0x12, 0x94, 0xe5, 0x4c, 0x20, 0x4c, 0xb9, 0xa2, 0x56, 0xd3, - 0x85, 0xa2, 0xa0, 0xd3, 0xe4, 0x36, 0x71, 0x42, 0x12, 0xb2, 0x6c, 0xda, 0xf4, 0x34, 0x59, 0xd5, - 0x28, 0x6c, 0xd2, 0x31, 0xa3, 0x1c, 0x37, 0xa3, 0xc5, 0xa6, 0x47, 0xfc, 0x98, 0xab, 0x99, 0x8d, - 0x51, 0xde, 0x5a, 0xdd, 0x34, 0x99, 0x6a, 0xa3, 0x9c, 0x42, 0xe0, 0xb4, 0x78, 0xf4, 0x25, 0x0b, - 0x26, 0x9d, 0x7b, 0x91, 0xae, 0x10, 0x23, 0x62, 0x5d, 0x8e, 0x39, 0x49, 0x25, 0x8a, 0xce, 0x54, - 0xa7, 0xa9, 0x79, 0x4f, 0x80, 0x70, 0x52, 0x28, 0xfa, 0xa6, 0x05, 0x88, 0xec, 0x13, 0x57, 0x46, - 0xe3, 0x08, 0x5d, 0x4a, 0x59, 0x2c, 0x76, 0x2e, 0xf7, 0xf0, 0xe5, 0x56, 0xbd, 0x17, 0x8e, 0xfb, - 0xe8, 0x60, 0xff, 0xb3, 0xbc, 0x1a, 0x50, 0x3a, 0x00, 0xcc, 0x31, 0xe2, 0xa0, 0xad, 0x87, 0x8f, - 0x83, 0xd6, 0x47, 0x94, 0x3d, 0xb1, 0xd0, 0xc9, 0xa0, 0xe1, 0xdc, 0x63, 0x0a, 0x1a, 0xfe, 0xa2, - 0xa5, 0x4e, 0xb6, 0xb9, 0x1b, 0xff, 0x56, 0xb6, 0xc1, 0x67, 0x73, 0xfc, 0x80, 0x3c, 0x65, 0xdd, - 0x93, 0xa7, 0xe6, 0xd4, 0x9a, 0x1a, 0x64, 0x23, 0x59, 0xc3, 0xff, 0x98, 0x87, 0x71, 0x63, 0x26, - 0xed, 0xeb, 0x16, 0x59, 0x4f, 0x98, 0x5b, 0x94, 0x1b, 0xc1, 0x2d, 0xfa, 0x45, 0xa8, 0xb8, 0xd2, - 0xca, 0x67, 0x53, 0x8e, 0x28, 0x3d, 0x77, 0x68, 0x43, 0xaf, 0x40, 0x58, 0xcb, 0x44, 0xcb, 0x30, - 0x6d, 0xb0, 0x11, 0x33, 0x44, 0x81, 0xcd, 0x10, 0x6a, 0x83, 0x78, 0x21, 0x4d, 0x80, 0x7b, 0x9f, - 0x41, 0xaf, 0xd0, 0x95, 0x95, 0x27, 0xde, 0x4b, 0x86, 0x88, 0x32, 0x77, 0x7d, 0x61, 0x63, 0x45, - 0x82, 0xb1, 0x49, 0x63, 0x7f, 0xcf, 0x52, 0x1f, 0xf7, 0x11, 0x64, 0x56, 0xdd, 0x49, 0x66, 0x56, - 0x5d, 0xce, 0xa4, 0x99, 0x07, 0xa4, 0x54, 0xdd, 0x80, 0xb1, 0xc5, 0xa0, 0xd5, 0x72, 0xfc, 0x1a, - 0xfa, 0x11, 0x18, 0x73, 0xf9, 0x4f, 0xb1, 0x55, 0xc1, 0xce, 0xa7, 0x04, 0x16, 0x4b, 0x1c, 0x7a, - 0x0e, 0x0a, 0x4e, 0xd8, 0x90, 0xdb, 0x13, 0xec, 0x48, 0x7f, 0x21, 0x6c, 0x44, 0x98, 0x41, 0xed, - 0x77, 0xf2, 0x00, 0x8b, 0x41, 0xab, 0xed, 0x84, 0xa4, 0xb6, 0x15, 0xb0, 0x72, 0x08, 0x27, 0x7a, - 0xae, 0xa3, 0x17, 0x4b, 0x4f, 0xf2, 0xd9, 0x8e, 0xb1, 0xbf, 0x9f, 0x7f, 0xd4, 0xfb, 0xfb, 0x5f, - 0xb5, 0x00, 0xd1, 0x2f, 0x12, 0xf8, 0xc4, 0x8f, 0xf5, 0x71, 0xe5, 0x3c, 0x54, 0x5c, 0x09, 0x15, - 0x5e, 0x8b, 0x1e, 0x7f, 0x12, 0x81, 0x35, 0xcd, 0x10, 0xcb, 0xcf, 0x17, 0xa4, 0x71, 0xcc, 0x27, - 0xa3, 0xe0, 0x98, 0x49, 0x15, 0xb6, 0xd2, 0xfe, 0xbd, 0x1c, 0x3c, 0xc5, 0xe7, 0xbb, 0x35, 0xc7, - 0x77, 0x1a, 0xa4, 0x45, 0xb5, 0x1a, 0xf6, 0x00, 0xda, 0xa5, 0xeb, 0x1e, 0x4f, 0x46, 0xb5, 0x1d, - 0x77, 0x60, 0xf0, 0x0e, 0xcd, 0xbb, 0xf0, 0x8a, 0xef, 0xc5, 0x98, 0x31, 0x47, 0x11, 0x94, 0x65, - 0x71, 0x3b, 0x61, 0xe8, 0x32, 0x12, 0xa4, 0xc6, 0xbc, 0x98, 0x94, 0x08, 0x56, 0x82, 0xa8, 0x57, - 0xd8, 0x0c, 0xdc, 0x5d, 0x4c, 0xda, 0x01, 0x33, 0x6a, 0x46, 0x50, 0xd1, 0xaa, 0x80, 0x63, 0x45, - 0x61, 0xff, 0x9e, 0x05, 0x69, 0x73, 0xcf, 0xb6, 0x11, 0x78, 0x5e, 0x7b, 0x7a, 0x1b, 0x21, 0x99, - 0xb6, 0x3e, 0x42, 0x7a, 0xfe, 0xcf, 0xc0, 0xb8, 0x13, 0xd3, 0x19, 0x9a, 0xaf, 0x69, 0xf3, 0x0f, - 0xb7, 0x6d, 0xbd, 0x16, 0xd4, 0xbc, 0xba, 0xc7, 0xd6, 0xb2, 0x26, 0x3b, 0xfb, 0x7f, 0x17, 0x60, - 0xba, 0x27, 0x52, 0x19, 0xbd, 0x06, 0x13, 0xae, 0xe8, 0x1e, 0x6d, 0x4c, 0xea, 0xe2, 0x65, 0x8c, - 0x48, 0x17, 0x8d, 0xc3, 0x09, 0xca, 0x21, 0x3a, 0xe8, 0x0a, 0x9c, 0x09, 0xe9, 0x2a, 0xba, 0x43, - 0x16, 0xea, 0x31, 0x09, 0x37, 0x89, 0x1b, 0xf8, 0x35, 0x5e, 0x7f, 0x21, 0x5f, 0x7d, 0xfa, 0xf0, - 0x60, 0xf6, 0x0c, 0xee, 0x45, 0xe3, 0x7e, 0xcf, 0xa0, 0x36, 0x4c, 0x36, 0x4d, 0x07, 0x4b, 0x78, - 0xd7, 0x0f, 0xe5, 0x9b, 0xa9, 0x09, 0x38, 0x01, 0xc6, 0x49, 0x01, 0x49, 0x2f, 0xad, 0xf8, 0x98, - 0xbc, 0xb4, 0x5f, 0xd2, 0x5e, 0x1a, 0x3f, 0x5f, 0xfd, 0x54, 0xc6, 0x91, 0xea, 0x27, 0xed, 0xa6, - 0xbd, 0x09, 0x65, 0x19, 0x79, 0x32, 0x54, 0xc4, 0x86, 0xc9, 0x67, 0x80, 0x45, 0xbb, 0x9f, 0x83, - 0x3e, 0x1e, 0x3e, 0x1d, 0x67, 0x7a, 0x3a, 0x4d, 0x8c, 0xb3, 0xd1, 0xa6, 0x54, 0xb4, 0xcf, 0xa3, - 0x6e, 0xf8, 0xc4, 0xf1, 0xc9, 0xac, 0x57, 0x28, 0x3a, 0x10, 0x47, 0x85, 0x80, 0xa8, 0x60, 0x9c, - 0x4b, 0x00, 0xda, 0x0b, 0x12, 0x01, 0xa7, 0xea, 0x58, 0x4f, 0x3b, 0x4b, 0xd8, 0xa0, 0xa2, 0x0b, - 0x56, 0xcf, 0x8f, 0x62, 0xa7, 0xd9, 0xbc, 0xea, 0xf9, 0xb1, 0xd8, 0x79, 0x53, 0x33, 0xe4, 0x8a, - 0x46, 0x61, 0x93, 0xee, 0xfc, 0xc7, 0x8d, 0xef, 0x32, 0xca, 0xf7, 0xdc, 0x81, 0x67, 0x96, 0xbd, - 0x58, 0x85, 0x49, 0xab, 0x7e, 0x44, 0x9d, 0x1c, 0x15, 0xf6, 0x6f, 0x0d, 0x0c, 0xfb, 0x37, 0xc2, - 0x94, 0x73, 0xc9, 0xa8, 0xea, 0x74, 0x98, 0xb2, 0xfd, 0x1a, 0x9c, 0x5d, 0xf6, 0xe2, 0x2b, 0x5e, - 0x93, 0x8c, 0x28, 0xc4, 0xfe, 0x52, 0x11, 0x26, 0xcc, 0xb4, 0x94, 0x51, 0x32, 0x17, 0xbe, 0x4e, - 0xfd, 0x18, 0xf1, 0x76, 0x9e, 0x3a, 0x63, 0xb9, 0x7d, 0xec, 0x1c, 0x99, 0xfe, 0x2d, 0x66, 0xb8, - 0x32, 0x5a, 0x26, 0x36, 0x15, 0x40, 0xf7, 0xa0, 0x58, 0x67, 0x61, 0xb4, 0xf9, 0x2c, 0x4e, 0x8e, - 0xfb, 0xb5, 0xa8, 0x1e, 0x66, 0x3c, 0x10, 0x97, 0xcb, 0xa3, 0x33, 0x64, 0x98, 0xcc, 0xcd, 0x50, - 0x86, 0x4a, 0x65, 0x65, 0x28, 0x8a, 0x41, 0xa6, 0xbe, 0xf8, 0x10, 0xa6, 0x3e, 0x61, 0x78, 0x4b, - 0x8f, 0xc9, 0xf0, 0xb2, 0x90, 0xe8, 0x78, 0x87, 0xf9, 0x6f, 0x22, 0x20, 0x76, 0x8c, 0x35, 0x82, - 0x11, 0x12, 0x9d, 0x40, 0xe3, 0x34, 0xbd, 0xfd, 0xd5, 0x1c, 0x4c, 0x2d, 0xfb, 0x9d, 0x8d, 0xe5, - 0x8d, 0xce, 0x76, 0xd3, 0x73, 0xaf, 0x93, 0x2e, 0xb5, 0x6f, 0xbb, 0xa4, 0xbb, 0xb2, 0x24, 0xba, - 0xa1, 0x6a, 0xf8, 0xeb, 0x14, 0x88, 0x39, 0x8e, 0x8e, 0xe8, 0xba, 0xe7, 0x37, 0x48, 0xd8, 0x0e, - 0x3d, 0xb1, 0x29, 0x67, 0x8c, 0xe8, 0x2b, 0x1a, 0x85, 0x4d, 0x3a, 0xca, 0x3b, 0xb8, 0xe7, 0x93, - 0x30, 0xed, 0x0d, 0xae, 0x53, 0x20, 0xe6, 0x38, 0x4a, 0x14, 0x87, 0x9d, 0x28, 0x16, 0x5f, 0x54, - 0x11, 0x6d, 0x51, 0x20, 0xe6, 0x38, 0x3a, 0x5c, 0xa2, 0xce, 0x36, 0x3b, 0xdd, 0x4e, 0x85, 0xb0, - 0x6e, 0x72, 0x30, 0x96, 0x78, 0x4a, 0xba, 0x4b, 0xba, 0x4b, 0x74, 0x5d, 0x96, 0x0a, 0x32, 0xbf, - 0xce, 0xc1, 0x58, 0xe2, 0x59, 0xd1, 0x8c, 0x64, 0x73, 0xfc, 0xc0, 0x15, 0xcd, 0x48, 0xaa, 0x3f, - 0x60, 0x85, 0xf7, 0x6d, 0x0b, 0x26, 0xcc, 0x98, 0x14, 0xd4, 0x48, 0x39, 0x8a, 0xeb, 0x3d, 0x05, - 0x90, 0x7e, 0xb2, 0x5f, 0x4d, 0xee, 0x86, 0x17, 0x07, 0xed, 0xe8, 0x65, 0xe2, 0x37, 0x3c, 0x9f, - 0xb0, 0x93, 0x4b, 0x1e, 0xcb, 0x92, 0x08, 0x78, 0x59, 0x0c, 0x6a, 0xe4, 0x21, 0x3c, 0x4d, 0xfb, - 0x36, 0x4c, 0xf7, 0x64, 0x16, 0x0c, 0x31, 0x3f, 0x1f, 0x99, 0xd7, 0x65, 0x63, 0x18, 0xa7, 0x8c, - 0xd7, 0xdb, 0x3c, 0xe8, 0x64, 0x11, 0xa6, 0xb9, 0x0f, 0x41, 0x25, 0x6d, 0xba, 0x3b, 0xa4, 0xa5, - 0xb2, 0x45, 0xd8, 0x0e, 0xf0, 0xad, 0x34, 0x12, 0xf7, 0xd2, 0xdb, 0x5f, 0xb3, 0x60, 0x32, 0x91, - 0xec, 0x91, 0x91, 0x27, 0xc1, 0x46, 0x5a, 0xc0, 0x42, 0xa4, 0x58, 0x94, 0x68, 0x9e, 0xcd, 0x48, - 0x7a, 0xa4, 0x69, 0x14, 0x36, 0xe9, 0xec, 0x77, 0x73, 0x50, 0x96, 0xa7, 0xd6, 0x43, 0xa8, 0xf2, - 0x15, 0x0b, 0x26, 0xd5, 0xae, 0x3b, 0xdb, 0xce, 0xe1, 0x9d, 0xf1, 0xc6, 0xf1, 0xcf, 0xcd, 0x55, - 0x0c, 0x9f, 0x5f, 0x0f, 0xb4, 0x5b, 0x8b, 0x4d, 0x61, 0x38, 0x29, 0x1b, 0xdd, 0x02, 0x88, 0xba, - 0x51, 0x4c, 0x5a, 0xc6, 0xc6, 0x92, 0x6d, 0x8c, 0xb8, 0x39, 0x37, 0x08, 0x09, 0x1d, 0x5f, 0x37, - 0x82, 0x1a, 0xd9, 0x54, 0x94, 0xda, 0x0f, 0xd1, 0x30, 0x6c, 0x70, 0xb2, 0xff, 0x61, 0x0e, 0x4e, - 0xa7, 0x55, 0x42, 0x9f, 0x82, 0x09, 0x29, 0xdd, 0x28, 0x4a, 0x2e, 0x8f, 0xea, 0x27, 0xb0, 0x81, - 0xbb, 0x7f, 0x30, 0x3b, 0xdb, 0x5b, 0xdf, 0x7d, 0xce, 0x24, 0xc1, 0x09, 0x66, 0xfc, 0xe8, 0x43, - 0x9c, 0xd1, 0x55, 0xbb, 0x0b, 0xed, 0xb6, 0x38, 0xbf, 0x30, 0x8e, 0x3e, 0x4c, 0x2c, 0x4e, 0x51, - 0xa3, 0x0d, 0x38, 0x6b, 0x40, 0x6e, 0x10, 0xaf, 0xb1, 0xb3, 0x1d, 0x84, 0x72, 0x79, 0xf2, 0x9c, - 0x8e, 0x7e, 0xe9, 0xa5, 0xc1, 0x7d, 0x9f, 0xa4, 0x53, 0xa6, 0xeb, 0xb4, 0x1d, 0xd7, 0x8b, 0xbb, - 0x62, 0xa7, 0x4c, 0xd9, 0xa6, 0x45, 0x01, 0xc7, 0x8a, 0xc2, 0x5e, 0x83, 0xc2, 0x90, 0x3d, 0x68, - 0x28, 0xb7, 0xf8, 0x4d, 0x28, 0x53, 0x76, 0xd2, 0x47, 0xca, 0x82, 0x65, 0x00, 0x65, 0x59, 0x57, - 0x14, 0xd9, 0x90, 0xf7, 0x1c, 0x79, 0xba, 0xa4, 0x5e, 0x6b, 0x25, 0x8a, 0x3a, 0x6c, 0xa5, 0x49, - 0x91, 0xe8, 0x05, 0xc8, 0x93, 0xfd, 0x76, 0xfa, 0x18, 0xe9, 0xf2, 0x7e, 0xdb, 0x0b, 0x49, 0x44, - 0x89, 0xc8, 0x7e, 0x1b, 0x9d, 0x87, 0x9c, 0x57, 0x13, 0x93, 0x14, 0x08, 0x9a, 0xdc, 0xca, 0x12, - 0xce, 0x79, 0x35, 0x7b, 0x1f, 0x2a, 0xaa, 0x90, 0x29, 0xda, 0x95, 0xb6, 0xdb, 0xca, 0x22, 0xcc, - 0x44, 0xf2, 0x1d, 0x60, 0xb5, 0x3b, 0x00, 0x3a, 0xb5, 0x26, 0x2b, 0xfb, 0x72, 0x11, 0x0a, 0x6e, - 0x20, 0x32, 0xf2, 0xca, 0x9a, 0x0d, 0x33, 0xda, 0x0c, 0x63, 0xdf, 0x86, 0xa9, 0xeb, 0x7e, 0x70, - 0x8f, 0x95, 0xf3, 0xbb, 0xe2, 0x91, 0x66, 0x8d, 0x32, 0xae, 0xd3, 0x1f, 0x69, 0x17, 0x81, 0x61, - 0x31, 0xc7, 0xa9, 0x6a, 0x9f, 0xb9, 0x41, 0xd5, 0x3e, 0xed, 0xcf, 0x5b, 0x70, 0x5a, 0xe5, 0x7c, - 0x48, 0x6b, 0xfc, 0x1a, 0x4c, 0x6c, 0x77, 0xbc, 0x66, 0x4d, 0xfc, 0x4f, 0xaf, 0xf5, 0xab, 0x06, - 0x0e, 0x27, 0x28, 0xe9, 0xca, 0x64, 0xdb, 0xf3, 0x9d, 0xb0, 0xbb, 0xa1, 0xcd, 0xbf, 0xb2, 0x08, - 0x55, 0x85, 0xc1, 0x06, 0x95, 0xfd, 0xc5, 0x1c, 0x4c, 0x26, 0x32, 0xe0, 0x51, 0x13, 0xca, 0xa4, - 0xc9, 0x76, 0xa0, 0xe4, 0x47, 0x3d, 0x6e, 0x1d, 0x1b, 0xd5, 0x11, 0x2f, 0x0b, 0xbe, 0x58, 0x49, - 0x78, 0x22, 0x8e, 0x59, 0xec, 0xdf, 0xcf, 0xc3, 0x0c, 0xdf, 0x78, 0xab, 0xa9, 0x78, 0x86, 0x35, - 0xe9, 0x9d, 0xfc, 0x75, 0x5d, 0x6d, 0x82, 0x37, 0xc7, 0xf6, 0x71, 0x2b, 0xb1, 0xf5, 0x17, 0x34, - 0xd4, 0x49, 0xfb, 0xdf, 0x4e, 0x9d, 0xb4, 0xe7, 0xb2, 0x48, 0x88, 0x18, 0xa8, 0xd1, 0x0f, 0xd6, - 0xd1, 0xfb, 0xdf, 0xcb, 0xc1, 0xa9, 0x54, 0x99, 0x3b, 0xf4, 0x4e, 0xb2, 0x0c, 0x91, 0x95, 0xc5, - 0xf6, 0xcc, 0x03, 0x8b, 0xad, 0x8d, 0x56, 0x8c, 0xe8, 0x71, 0x75, 0xf8, 0x3f, 0xcc, 0xc1, 0x54, - 0xb2, 0x3e, 0xdf, 0x13, 0xd8, 0x52, 0x1f, 0x85, 0x0a, 0xab, 0x7a, 0xc5, 0xca, 0xc5, 0xf3, 0x5d, - 0x20, 0x96, 0xe7, 0xbe, 0x26, 0x81, 0x58, 0xe3, 0x9f, 0x88, 0x1a, 0x4f, 0xf6, 0xdf, 0xb7, 0xe0, - 0x1c, 0x7f, 0xcb, 0x74, 0x3f, 0xfc, 0x1b, 0xfd, 0x5a, 0xf7, 0xd3, 0xd9, 0x2a, 0x98, 0xaa, 0x92, - 0x72, 0x54, 0xfb, 0xb2, 0x32, 0xd5, 0x42, 0xdb, 0x64, 0x57, 0x78, 0x02, 0x95, 0x1d, 0xa9, 0x33, - 0xd8, 0x7f, 0x98, 0x07, 0x5d, 0x99, 0x1b, 0x79, 0x22, 0x6d, 0x22, 0x93, 0x6a, 0x31, 0x9b, 0x5d, - 0xdf, 0xd5, 0x35, 0xc0, 0xcb, 0xa9, 0xac, 0x89, 0x5f, 0xb5, 0x60, 0xdc, 0xf3, 0xbd, 0xd8, 0x73, - 0x98, 0xd3, 0x99, 0x4d, 0xe9, 0x64, 0x25, 0x6e, 0x85, 0x73, 0x0e, 0x42, 0x73, 0xeb, 0x50, 0x09, - 0xc3, 0xa6, 0x64, 0xf4, 0x39, 0x11, 0x0c, 0x97, 0xcf, 0x2c, 0xe1, 0xa7, 0x9c, 0x8a, 0x80, 0x6b, - 0x43, 0x31, 0x24, 0x71, 0x28, 0x53, 0xad, 0xae, 0x1f, 0x37, 0xc2, 0x39, 0x0e, 0xbb, 0x9b, 0x71, - 0xe8, 0xc4, 0xa4, 0x61, 0x2c, 0xda, 0x19, 0x18, 0x73, 0x41, 0x76, 0x04, 0xa8, 0xb7, 0x2d, 0x46, - 0x0c, 0x34, 0x9a, 0x87, 0x8a, 0xd3, 0x89, 0x83, 0x16, 0x6d, 0x26, 0xb1, 0xbb, 0xa9, 0x43, 0xa9, - 0x24, 0x02, 0x6b, 0x1a, 0xfb, 0x9d, 0x22, 0xa4, 0xf2, 0x18, 0xd0, 0xbe, 0x59, 0x55, 0xde, 0xca, - 0xb6, 0xaa, 0xbc, 0x52, 0xa6, 0x5f, 0x65, 0x79, 0xd4, 0x80, 0x62, 0x7b, 0xc7, 0x89, 0xa4, 0x4f, - 0xf9, 0xa6, 0x6c, 0xa6, 0x0d, 0x0a, 0xbc, 0x7f, 0x30, 0xfb, 0x53, 0xc3, 0xed, 0x51, 0xd0, 0xbe, - 0x3a, 0xcf, 0xf3, 0x85, 0xb5, 0x68, 0xc6, 0x03, 0x73, 0xfe, 0xe6, 0x2e, 0x45, 0xfe, 0x88, 0xf3, - 0xb0, 0x2f, 0x88, 0xc2, 0x76, 0x98, 0x44, 0x9d, 0x66, 0x2c, 0x7a, 0xc3, 0x9b, 0x19, 0x8e, 0x32, - 0xce, 0x58, 0x67, 0xe0, 0xf1, 0xff, 0xd8, 0x10, 0x8a, 0x3e, 0x05, 0x95, 0x28, 0x76, 0xc2, 0xf8, - 0x21, 0x73, 0x66, 0x54, 0xa3, 0x6f, 0x4a, 0x26, 0x58, 0xf3, 0x43, 0x6f, 0xb1, 0xe2, 0x59, 0x5e, - 0xb4, 0xf3, 0x90, 0x31, 0xac, 0xb2, 0xd0, 0x96, 0xe0, 0x80, 0x0d, 0x6e, 0xd4, 0x65, 0x67, 0x7d, - 0x9b, 0x07, 0x6e, 0x94, 0xd9, 0x9a, 0x4c, 0x99, 0x42, 0xac, 0x30, 0xd8, 0xa0, 0xb2, 0x7f, 0x01, - 0xce, 0xa4, 0xaf, 0xa1, 0x11, 0xdb, 0x96, 0x8d, 0x30, 0xe8, 0xb4, 0xd3, 0x6b, 0x12, 0x76, 0x4d, - 0x09, 0xe6, 0x38, 0xba, 0x26, 0xd9, 0xf5, 0xfc, 0x5a, 0x7a, 0x4d, 0x72, 0xdd, 0xf3, 0x6b, 0x98, - 0x61, 0x86, 0x28, 0xb7, 0xff, 0xcf, 0x2d, 0xb8, 0x78, 0xd4, 0x6d, 0x39, 0xe8, 0x39, 0x28, 0xdc, - 0x73, 0x42, 0x59, 0x8c, 0x8f, 0xd9, 0x8e, 0xdb, 0x4e, 0xe8, 0x63, 0x06, 0x45, 0x5d, 0x28, 0xf1, - 0x1c, 0x45, 0xe1, 0xc0, 0xbe, 0x99, 0xed, 0xdd, 0x3d, 0xd7, 0x89, 0xe1, 0x41, 0xf3, 0xfc, 0x48, - 0x2c, 0x04, 0xda, 0xef, 0x5b, 0x80, 0xd6, 0xf7, 0x48, 0x18, 0x7a, 0x35, 0x23, 0xab, 0x12, 0xbd, - 0x0a, 0x13, 0x77, 0x36, 0xd7, 0x6f, 0x6c, 0x04, 0x9e, 0xcf, 0x72, 0xac, 0x8d, 0xbc, 0x94, 0x6b, - 0x06, 0x1c, 0x27, 0xa8, 0xd0, 0x22, 0x4c, 0xdf, 0xb9, 0x4b, 0xd7, 0x51, 0x97, 0xf7, 0xdb, 0x21, - 0x89, 0x22, 0xe5, 0x93, 0x8b, 0x9d, 0xb3, 0x6b, 0x6f, 0xa6, 0x90, 0xb8, 0x97, 0x1e, 0xad, 0xc3, - 0xb9, 0x16, 0xf7, 0xc0, 0xd9, 0xf2, 0x31, 0xe2, 0xee, 0x78, 0x28, 0x0b, 0x2f, 0x3c, 0x73, 0x78, - 0x30, 0x7b, 0x6e, 0xad, 0x1f, 0x01, 0xee, 0xff, 0x9c, 0xfd, 0x9d, 0x1c, 0x8c, 0x1b, 0x37, 0x4e, - 0x0d, 0xb1, 0x50, 0x4e, 0x5d, 0x92, 0x95, 0x1b, 0xf2, 0x92, 0xac, 0x17, 0xa1, 0xdc, 0x0e, 0x9a, - 0x9e, 0xeb, 0xa9, 0x2a, 0x11, 0xac, 0x98, 0xd9, 0x86, 0x80, 0x61, 0x85, 0x45, 0xf7, 0xa0, 0xa2, - 0x6e, 0x61, 0x11, 0xc9, 0x7d, 0x59, 0x6d, 0x15, 0xa8, 0xc1, 0xab, 0x6f, 0x57, 0xd1, 0xb2, 0x90, - 0x0d, 0x25, 0xd6, 0xf3, 0x65, 0x48, 0x13, 0xcb, 0xba, 0x60, 0x43, 0x22, 0xc2, 0x02, 0x63, 0xff, - 0xf2, 0x18, 0x9c, 0xed, 0x57, 0x80, 0x0b, 0xfd, 0x1c, 0x94, 0xb8, 0x8e, 0xd9, 0xd4, 0x78, 0xec, - 0x27, 0x63, 0x99, 0x31, 0x14, 0x6a, 0xb1, 0xdf, 0x58, 0xc8, 0x14, 0xd2, 0x9b, 0xce, 0xb6, 0x70, - 0x23, 0x4e, 0x46, 0xfa, 0xaa, 0xa3, 0xa5, 0xaf, 0x3a, 0x5c, 0x7a, 0xd3, 0xd9, 0x46, 0xfb, 0x50, - 0x6c, 0x78, 0x31, 0x71, 0x84, 0x33, 0x7d, 0xfb, 0x44, 0x84, 0x13, 0x87, 0x47, 0xce, 0xb3, 0x9f, - 0x98, 0x0b, 0x44, 0xdf, 0xb2, 0xe0, 0xd4, 0x76, 0x32, 0x89, 0x45, 0xcc, 0x2a, 0xce, 0x09, 0x14, - 0x59, 0x4b, 0x0a, 0xaa, 0x9e, 0x39, 0x3c, 0x98, 0x3d, 0x95, 0x02, 0xe2, 0xb4, 0x3a, 0xe8, 0x97, - 0x2c, 0x18, 0xab, 0x7b, 0x4d, 0xa3, 0x82, 0xd0, 0x09, 0x7c, 0x9c, 0x2b, 0x4c, 0x80, 0x9e, 0x79, - 0xf9, 0xff, 0x08, 0x4b, 0xc9, 0x83, 0x8e, 0xf3, 0x4a, 0xc7, 0x3d, 0xce, 0x1b, 0x7b, 0x4c, 0xcb, - 0xa7, 0xbf, 0x99, 0x83, 0x17, 0x86, 0xf8, 0x46, 0x66, 0x52, 0x84, 0x75, 0x44, 0x52, 0xc4, 0x45, - 0x28, 0x84, 0xa4, 0x1d, 0xa4, 0xe7, 0x3b, 0x16, 0x39, 0xc4, 0x30, 0xe8, 0x79, 0xc8, 0x3b, 0x6d, - 0x4f, 0x4c, 0x77, 0xea, 0xb4, 0x7f, 0x61, 0x63, 0x05, 0x53, 0x38, 0xfd, 0xd2, 0x95, 0x6d, 0x99, - 0x5a, 0x95, 0x4d, 0xd5, 0xde, 0x41, 0x99, 0x5a, 0x7c, 0x41, 0xa3, 0xb0, 0x58, 0xcb, 0xb5, 0xd7, - 0xe1, 0xfc, 0xe0, 0x1e, 0x82, 0x5e, 0x81, 0xf1, 0xed, 0xd0, 0xf1, 0xdd, 0x9d, 0x35, 0x27, 0x76, - 0xe5, 0x99, 0x3b, 0x8b, 0xdd, 0xac, 0x6a, 0x30, 0x36, 0x69, 0xec, 0xdf, 0xcf, 0xf5, 0xe7, 0xc8, - 0x8d, 0xc0, 0x28, 0x2d, 0x2c, 0xda, 0x2f, 0x37, 0xa0, 0xfd, 0xee, 0x42, 0x39, 0x66, 0x91, 0xf8, - 0xa4, 0x2e, 0x2c, 0x49, 0x66, 0xc9, 0x64, 0x6c, 0xae, 0xd9, 0x12, 0xcc, 0xb1, 0x12, 0x43, 0x4d, - 0x7e, 0x53, 0x17, 0x1f, 0x12, 0x26, 0x3f, 0xb5, 0x8f, 0xb6, 0x04, 0xa7, 0x8d, 0x5a, 0x8a, 0x3c, - 0x10, 0x99, 0x1f, 0xa3, 0xaa, 0xec, 0x9c, 0x8d, 0x14, 0x1e, 0xf7, 0x3c, 0x61, 0x7f, 0x3b, 0x07, - 0xcf, 0x0c, 0xb4, 0x6c, 0xfa, 0xac, 0xd7, 0x7a, 0xc0, 0x59, 0xef, 0xb1, 0x3b, 0xa8, 0xd9, 0xc0, - 0x85, 0x47, 0xd3, 0xc0, 0x2f, 0x41, 0xd9, 0xf3, 0x23, 0xe2, 0x76, 0x42, 0xde, 0x68, 0x46, 0x58, - 0xde, 0x8a, 0x80, 0x63, 0x45, 0x61, 0xff, 0xd1, 0xe0, 0xae, 0x46, 0x67, 0xb9, 0x1f, 0xda, 0x56, - 0x7a, 0x1d, 0x26, 0x9d, 0x76, 0x9b, 0xd3, 0xb1, 0x73, 0xb5, 0x54, 0xbe, 0xdd, 0x82, 0x89, 0xc4, - 0x49, 0x5a, 0xa3, 0x0f, 0x97, 0x06, 0xf5, 0x61, 0xfb, 0x4f, 0x2d, 0xa8, 0x60, 0x52, 0xe7, 0x35, - 0x38, 0xd1, 0x1d, 0xd1, 0x44, 0x56, 0x16, 0xc5, 0x21, 0xd8, 0x5d, 0xae, 0x1e, 0x2b, 0x9a, 0xd0, - 0xaf, 0xb1, 0x7b, 0xeb, 0x82, 0xe6, 0x46, 0xaa, 0x0b, 0xaa, 0x2a, 0x43, 0xe6, 0x07, 0x57, 0x86, - 0xb4, 0xbf, 0x5f, 0xa2, 0xaf, 0xd7, 0x0e, 0x16, 0x43, 0x52, 0x8b, 0xe8, 0xf7, 0xed, 0x84, 0x4d, - 0xd1, 0x49, 0xd4, 0xf7, 0xbd, 0x89, 0x57, 0x31, 0x85, 0x27, 0x36, 0x01, 0x72, 0x23, 0x65, 0x1b, - 0xe5, 0x8f, 0xcc, 0x36, 0x7a, 0x1d, 0x26, 0xa3, 0x68, 0x67, 0x23, 0xf4, 0xf6, 0x9c, 0x98, 0x2e, - 0x2d, 0x44, 0x58, 0x86, 0xce, 0x10, 0xd8, 0xbc, 0xaa, 0x91, 0x38, 0x49, 0x8b, 0x96, 0x61, 0x5a, - 0xe7, 0xfc, 0x90, 0x30, 0x66, 0x51, 0x18, 0xbc, 0x27, 0xa8, 0x00, 0x7d, 0x9d, 0x25, 0x24, 0x08, - 0x70, 0xef, 0x33, 0xd4, 0x62, 0x25, 0x80, 0x54, 0x91, 0x52, 0xd2, 0x62, 0x25, 0xf8, 0x50, 0x5d, - 0x7a, 0x9e, 0x40, 0x6b, 0x70, 0x86, 0x77, 0x0c, 0x76, 0xa7, 0xa2, 0x7a, 0x23, 0x1e, 0x35, 0xf3, - 0xac, 0x60, 0x74, 0x66, 0xb9, 0x97, 0x04, 0xf7, 0x7b, 0x8e, 0xae, 0x1b, 0x14, 0x78, 0x65, 0x49, - 0xac, 0x5f, 0xd5, 0xba, 0x41, 0xb1, 0x59, 0xa9, 0x61, 0x93, 0x0e, 0x7d, 0x12, 0x9e, 0xd6, 0x7f, - 0x79, 0xbc, 0x1b, 0xdf, 0xd4, 0x59, 0x12, 0xe9, 0x94, 0xaa, 0x0e, 0xe1, 0x72, 0x5f, 0xb2, 0x1a, - 0x1e, 0xf4, 0x3c, 0xda, 0x86, 0xf3, 0x0a, 0x75, 0x99, 0x2e, 0xd2, 0xda, 0xa1, 0x17, 0x91, 0xaa, - 0x13, 0x91, 0x9b, 0x61, 0x93, 0x25, 0x60, 0x56, 0x74, 0x41, 0xf5, 0x65, 0x2f, 0xbe, 0xda, 0x8f, - 0x12, 0xaf, 0xe2, 0x07, 0x70, 0x41, 0xf3, 0x50, 0x21, 0xbe, 0xb3, 0xdd, 0x24, 0xeb, 0x8b, 0x2b, - 0x2c, 0x2d, 0xd3, 0xd8, 0x43, 0xba, 0x2c, 0x11, 0x58, 0xd3, 0xa8, 0x93, 0xc0, 0x89, 0x81, 0xf7, - 0xfe, 0x6d, 0xc0, 0xd9, 0x86, 0xdb, 0xa6, 0x7e, 0x80, 0xe7, 0x92, 0x05, 0xd7, 0xa5, 0x0b, 0x7d, - 0xfa, 0x61, 0x78, 0x5d, 0x54, 0x75, 0xcc, 0xbd, 0xbc, 0xb8, 0xd1, 0x43, 0x83, 0xfb, 0x3e, 0x49, - 0xc7, 0x58, 0x3b, 0x0c, 0xf6, 0xbb, 0x33, 0x67, 0x92, 0x63, 0x6c, 0x83, 0x02, 0x31, 0xc7, 0xd9, - 0x7f, 0x62, 0xc1, 0xa4, 0x1a, 0x63, 0x8f, 0x20, 0xd2, 0xa7, 0x99, 0x8c, 0xf4, 0x59, 0x3e, 0xbe, - 0x95, 0x62, 0x9a, 0x0f, 0x38, 0x2e, 0xfe, 0x5d, 0x00, 0xd0, 0x96, 0x4c, 0x4d, 0x22, 0xd6, 0xc0, - 0x49, 0xe4, 0x89, 0xb5, 0x22, 0xfd, 0xf2, 0xa6, 0x8a, 0x8f, 0x37, 0x6f, 0x6a, 0x13, 0xce, 0xc9, - 0x29, 0x9e, 0x6f, 0xa3, 0x5c, 0x0d, 0x22, 0x65, 0x94, 0xca, 0xd5, 0xe7, 0x05, 0xa3, 0x73, 0x2b, - 0xfd, 0x88, 0x70, 0xff, 0x67, 0x13, 0x9e, 0xc5, 0xd8, 0x51, 0x9e, 0x85, 0x1e, 0x87, 0xab, 0x75, - 0x59, 0x89, 0x30, 0x35, 0x0e, 0x57, 0xaf, 0x6c, 0x62, 0x4d, 0xd3, 0xdf, 0x18, 0x57, 0x32, 0x32, - 0xc6, 0x30, 0xb2, 0x31, 0x96, 0x66, 0x61, 0x7c, 0xa0, 0x59, 0x90, 0x3b, 0x37, 0x13, 0x03, 0x77, - 0x6e, 0xde, 0x80, 0x29, 0xcf, 0xdf, 0x21, 0xa1, 0x17, 0x93, 0x1a, 0x1b, 0x0b, 0xe2, 0xae, 0x5f, - 0x35, 0x15, 0xaf, 0x24, 0xb0, 0x38, 0x45, 0x9d, 0xb4, 0x65, 0x53, 0x43, 0xd8, 0xb2, 0x01, 0x33, - 0xc8, 0xa9, 0x6c, 0x66, 0x90, 0xd3, 0xc7, 0x9f, 0x41, 0xa6, 0x4f, 0x74, 0x06, 0x41, 0x99, 0xcc, - 0x20, 0xc3, 0x18, 0x67, 0x73, 0x11, 0x76, 0xf6, 0x88, 0x45, 0xd8, 0xa0, 0xe9, 0xe3, 0xdc, 0xc3, - 0x4e, 0x1f, 0xf6, 0x97, 0x73, 0x70, 0x4e, 0xdb, 0x4e, 0xda, 0x63, 0xbd, 0x3a, 0xb5, 0x1e, 0xac, - 0x00, 0x2d, 0x0f, 0xfb, 0x30, 0x82, 0xc5, 0x74, 0xdc, 0x99, 0xc2, 0x60, 0x83, 0x8a, 0xc5, 0x5c, - 0x91, 0x90, 0x95, 0x72, 0x49, 0x1b, 0xd6, 0x45, 0x01, 0xc7, 0x8a, 0x82, 0xf6, 0x09, 0xfa, 0x5b, - 0xc4, 0xb1, 0xa6, 0xd3, 0xbb, 0x17, 0x35, 0x0a, 0x9b, 0x74, 0xe8, 0x45, 0x2e, 0x84, 0x0d, 0x6a, - 0x6a, 0x5c, 0x27, 0xc4, 0xd5, 0x0a, 0x72, 0x1c, 0x2b, 0xac, 0x54, 0x87, 0x05, 0xd7, 0x15, 0x7b, - 0xd5, 0x61, 0x87, 0x5c, 0x8a, 0xc2, 0xfe, 0x3f, 0x16, 0x3c, 0xd3, 0xb7, 0x29, 0x1e, 0xc1, 0x84, - 0xb9, 0x9f, 0x9c, 0x30, 0x37, 0xb3, 0x72, 0xeb, 0x8d, 0xb7, 0x18, 0x30, 0x79, 0xfe, 0x07, 0x0b, - 0xa6, 0x34, 0xfd, 0x23, 0x78, 0x55, 0x2f, 0xf9, 0xaa, 0xd9, 0xad, 0x60, 0x2a, 0x3d, 0xef, 0xf6, - 0x27, 0xec, 0xdd, 0xf8, 0x59, 0xc1, 0x82, 0x2b, 0xaf, 0x66, 0x3e, 0x62, 0x8f, 0xbc, 0x0b, 0x25, - 0x56, 0xfd, 0x34, 0xca, 0xe6, 0xcc, 0x22, 0x29, 0x9f, 0x45, 0xcd, 0xea, 0x33, 0x0b, 0xf6, 0x37, - 0xc2, 0x42, 0x20, 0x2b, 0x34, 0xe4, 0x45, 0xd4, 0x02, 0xd7, 0x44, 0x98, 0x9a, 0x2e, 0x34, 0x24, - 0xe0, 0x58, 0x51, 0xd8, 0x2d, 0x98, 0x49, 0x32, 0x5f, 0x22, 0x75, 0x76, 0x34, 0x3c, 0xd4, 0x6b, - 0xce, 0x43, 0xc5, 0x61, 0x4f, 0xad, 0x76, 0x9c, 0xf4, 0x6d, 0x3c, 0x0b, 0x12, 0x81, 0x35, 0x8d, - 0xfd, 0xdb, 0x16, 0x9c, 0xe9, 0xf3, 0x32, 0x19, 0x86, 0xe7, 0xc5, 0xda, 0x0a, 0x0c, 0xb8, 0x33, - 0xbb, 0x46, 0xea, 0x8e, 0x3c, 0x7c, 0x34, 0xec, 0xe4, 0x12, 0x07, 0x63, 0x89, 0xb7, 0xff, 0x87, - 0x05, 0xa7, 0x92, 0xba, 0x46, 0xe8, 0x1a, 0x20, 0xfe, 0x32, 0x4b, 0x5e, 0xe4, 0x06, 0x7b, 0x24, - 0xec, 0xd2, 0x37, 0xe7, 0x5a, 0x9f, 0x17, 0x9c, 0xd0, 0x42, 0x0f, 0x05, 0xee, 0xf3, 0x14, 0x2b, - 0x84, 0x52, 0x53, 0xad, 0x2d, 0x7b, 0xca, 0xad, 0x2c, 0x7b, 0x8a, 0xfe, 0x98, 0xe6, 0x01, 0x8d, - 0x12, 0x89, 0x4d, 0xf9, 0xf6, 0xfb, 0x05, 0x50, 0xf1, 0xbb, 0xec, 0x98, 0x2b, 0xa3, 0x43, 0xc2, - 0xc4, 0x95, 0x4d, 0xf9, 0x11, 0x2e, 0xf1, 0x2e, 0x3c, 0xe8, 0x08, 0x8a, 0xef, 0x12, 0x98, 0x9b, - 0x71, 0xea, 0x0d, 0xb7, 0x34, 0x0a, 0x9b, 0x74, 0x54, 0x93, 0xa6, 0xb7, 0x47, 0xf8, 0x43, 0xa5, - 0xa4, 0x26, 0xab, 0x12, 0x81, 0x35, 0x0d, 0xd5, 0xa4, 0xe6, 0xd5, 0xeb, 0x62, 0xc9, 0xab, 0x34, - 0xa1, 0xad, 0x83, 0x19, 0x86, 0x52, 0xec, 0x04, 0xc1, 0xae, 0xf0, 0x28, 0x15, 0xc5, 0xd5, 0x20, - 0xd8, 0xc5, 0x0c, 0x43, 0x7d, 0x20, 0x3f, 0x08, 0x5b, 0xec, 0xb6, 0xa4, 0x9a, 0x92, 0x22, 0x3c, - 0x49, 0xe5, 0x03, 0xdd, 0xe8, 0x25, 0xc1, 0xfd, 0x9e, 0xa3, 0x3d, 0xb0, 0x1d, 0x92, 0x9a, 0xe7, - 0xc6, 0x26, 0x37, 0x48, 0xf6, 0xc0, 0x8d, 0x1e, 0x0a, 0xdc, 0xe7, 0x29, 0xb4, 0x00, 0xa7, 0x64, - 0xfc, 0xb5, 0x4c, 0x51, 0x1b, 0x4f, 0xa6, 0xc4, 0xe0, 0x24, 0x1a, 0xa7, 0xe9, 0xa9, 0xb5, 0x69, - 0x89, 0xec, 0x54, 0xe6, 0x78, 0x1a, 0xd6, 0x46, 0x66, 0xad, 0x62, 0x45, 0x61, 0x7f, 0x21, 0x4f, - 0x67, 0xc7, 0x01, 0x55, 0x6a, 0x1f, 0xd9, 0xa1, 0x74, 0xb2, 0x47, 0x16, 0x86, 0xe8, 0x91, 0xaf, - 0xc2, 0xc4, 0x9d, 0x28, 0xf0, 0xd5, 0x81, 0x6f, 0x71, 0xe0, 0x81, 0xaf, 0x41, 0xd5, 0xff, 0xc0, - 0xb7, 0x94, 0xd5, 0x81, 0xef, 0xd8, 0x43, 0x1e, 0xf8, 0xfe, 0x41, 0x11, 0x54, 0x9d, 0xc7, 0x1b, - 0x24, 0xbe, 0x17, 0x84, 0xbb, 0x9e, 0xdf, 0x60, 0x71, 0xeb, 0xdf, 0xb2, 0x60, 0x82, 0x8f, 0x97, - 0x55, 0x33, 0x86, 0xb5, 0x9e, 0x51, 0x3d, 0xc2, 0x84, 0xb0, 0xb9, 0x2d, 0x43, 0x50, 0xaa, 0x18, - 0xbf, 0x89, 0xc2, 0x09, 0x8d, 0xd0, 0xcf, 0x03, 0xc8, 0xfd, 0xc1, 0x7a, 0x46, 0x37, 0xea, 0xab, - 0x5b, 0x9c, 0x48, 0x5d, 0xfb, 0xa6, 0x5b, 0x4a, 0x08, 0x36, 0x04, 0xa2, 0x2f, 0xa7, 0x6f, 0x93, - 0xfb, 0xdc, 0x89, 0xb4, 0xcd, 0x30, 0xd1, 0xbd, 0x18, 0xc6, 0x3c, 0xbf, 0x41, 0xfb, 0x89, 0x38, - 0x23, 0xff, 0x48, 0xbf, 0x9c, 0x8f, 0xd5, 0xc0, 0xa9, 0x55, 0x9d, 0xa6, 0xe3, 0xbb, 0x24, 0x5c, - 0xe1, 0xe4, 0xe6, 0xed, 0x30, 0x0c, 0x80, 0x25, 0xa3, 0x9e, 0x82, 0x9b, 0xc5, 0x61, 0x0a, 0x6e, - 0x9e, 0xff, 0x04, 0x4c, 0xf7, 0x7c, 0xcc, 0x91, 0x82, 0x79, 0x1f, 0x3e, 0x0e, 0xd8, 0xfe, 0x17, - 0x25, 0x3d, 0x69, 0xdd, 0x08, 0x6a, 0xbc, 0xec, 0x63, 0xa8, 0xbf, 0xa8, 0xf0, 0x3d, 0x33, 0xec, - 0x22, 0xc6, 0x0d, 0x33, 0x0a, 0x88, 0x4d, 0x91, 0xb4, 0x8f, 0xb6, 0x9d, 0x90, 0xf8, 0x27, 0xdd, - 0x47, 0x37, 0x94, 0x10, 0x6c, 0x08, 0x44, 0x3b, 0x89, 0x68, 0xbe, 0x2b, 0xc7, 0x8f, 0xe6, 0x63, - 0x29, 0xa5, 0xfd, 0xea, 0xda, 0x7d, 0xc3, 0x82, 0x29, 0x3f, 0xd1, 0x73, 0xc5, 0x79, 0xc9, 0xd6, - 0x49, 0x8c, 0x0a, 0x5e, 0x26, 0x38, 0x09, 0xc3, 0x29, 0xf9, 0xfd, 0xa6, 0xb4, 0xe2, 0x88, 0x53, - 0x9a, 0xae, 0x1f, 0x5b, 0x1a, 0x54, 0x3f, 0x16, 0xf9, 0xaa, 0xe2, 0xf5, 0x58, 0xe6, 0x15, 0xaf, - 0xa1, 0x4f, 0xb5, 0xeb, 0xdb, 0x50, 0x71, 0x43, 0xe2, 0xc4, 0x0f, 0x59, 0xfc, 0x98, 0x1d, 0x16, - 0x2f, 0x4a, 0x06, 0x58, 0xf3, 0xb2, 0xff, 0x7d, 0x1e, 0x4e, 0xcb, 0x16, 0x91, 0x91, 0x4e, 0x74, - 0x7e, 0xe4, 0x72, 0xb5, 0x73, 0xab, 0xe6, 0xc7, 0xab, 0x12, 0x81, 0x35, 0x0d, 0xf5, 0xc7, 0x3a, - 0x11, 0x59, 0x6f, 0x13, 0x7f, 0xd5, 0xdb, 0x8e, 0xc4, 0x39, 0x9f, 0x1a, 0x28, 0x37, 0x35, 0x0a, - 0x9b, 0x74, 0xd4, 0x19, 0xe7, 0x7e, 0x71, 0x94, 0x0e, 0x1c, 0x14, 0xfe, 0x36, 0x96, 0x78, 0xf4, - 0xeb, 0x7d, 0xcb, 0xe6, 0x67, 0x13, 0x32, 0xdb, 0x13, 0xe0, 0x35, 0x62, 0xbd, 0xfc, 0x77, 0x2c, - 0x38, 0xb5, 0x9b, 0xc8, 0xf9, 0x91, 0x26, 0xf9, 0x98, 0xd9, 0xa9, 0xc9, 0x44, 0x22, 0xdd, 0x85, - 0x93, 0xf0, 0x08, 0xa7, 0xa5, 0xdb, 0xff, 0xcb, 0x02, 0xd3, 0x3c, 0x0d, 0xe7, 0x59, 0x19, 0xf7, - 0xdc, 0xe4, 0x8e, 0xb8, 0xe7, 0x46, 0x3a, 0x61, 0xf9, 0xe1, 0x9c, 0xfe, 0xc2, 0x08, 0x4e, 0x7f, - 0x71, 0xa0, 0xd7, 0xf6, 0x3c, 0xe4, 0x3b, 0x5e, 0x4d, 0xf8, 0xed, 0xfa, 0x54, 0x6f, 0x65, 0x09, - 0x53, 0xb8, 0xfd, 0xbb, 0x45, 0xbd, 0x4e, 0x17, 0x91, 0x9e, 0x3f, 0x14, 0xaf, 0x5d, 0x57, 0xc9, - 0xc6, 0xfc, 0xcd, 0x6f, 0xf4, 0x24, 0x1b, 0xff, 0xc4, 0xe8, 0x81, 0xbc, 0xbc, 0x81, 0x06, 0xe5, - 0x1a, 0x8f, 0x1d, 0x11, 0xc5, 0x7b, 0x07, 0xca, 0x74, 0x69, 0xc3, 0x36, 0xdc, 0xca, 0x09, 0xa5, - 0xca, 0x57, 0x05, 0xfc, 0xfe, 0xc1, 0xec, 0x8f, 0x8f, 0xae, 0x96, 0x7c, 0x1a, 0x2b, 0xfe, 0x28, - 0x82, 0x0a, 0xfd, 0xcd, 0x02, 0x8e, 0xc5, 0xa2, 0xe9, 0xa6, 0xb2, 0x45, 0x12, 0x91, 0x49, 0x34, - 0xb3, 0x96, 0x83, 0x7c, 0xa8, 0xb0, 0x2b, 0x3b, 0x98, 0x50, 0xbe, 0xb6, 0xda, 0x50, 0x61, 0xbf, - 0x12, 0x71, 0xff, 0x60, 0xf6, 0xf5, 0xd1, 0x85, 0xaa, 0xc7, 0xb1, 0x16, 0x61, 0xbf, 0x5b, 0xd0, - 0x7d, 0x57, 0xe4, 0x98, 0xff, 0x50, 0xf4, 0xdd, 0xd7, 0x52, 0x7d, 0xf7, 0x62, 0x4f, 0xdf, 0x9d, - 0xd2, 0x57, 0x4b, 0x24, 0x7a, 0xe3, 0xa3, 0x9e, 0x60, 0x8f, 0x5e, 0xc7, 0x33, 0xcf, 0xe2, 0x6e, - 0xc7, 0x0b, 0x49, 0xb4, 0x11, 0x76, 0x7c, 0xcf, 0x6f, 0x88, 0xbb, 0xeb, 0x0c, 0xcf, 0x22, 0x81, - 0xc6, 0x69, 0x7a, 0x76, 0xef, 0x5d, 0xd7, 0x77, 0x6f, 0x3b, 0x7b, 0xbc, 0x57, 0x19, 0x69, 0xb7, - 0x9b, 0x02, 0x8e, 0x15, 0x85, 0xfd, 0x1d, 0x76, 0xde, 0x6a, 0x64, 0x3a, 0xd0, 0x3e, 0xd1, 0x64, - 0x77, 0xa4, 0xf0, 0x9c, 0x5d, 0xd5, 0x27, 0xf8, 0xc5, 0x28, 0x1c, 0x87, 0xee, 0xc1, 0xd8, 0x36, - 0xaf, 0x39, 0x9e, 0x4d, 0x91, 0x2f, 0x51, 0xc0, 0x9c, 0xd5, 0xe1, 0x94, 0xd5, 0xcc, 0xef, 0xeb, - 0x9f, 0x58, 0x4a, 0xb3, 0xdf, 0x2b, 0xc0, 0xa9, 0xd4, 0x2d, 0x1a, 0x89, 0x92, 0x23, 0xb9, 0x23, - 0x4b, 0x8e, 0x7c, 0x06, 0xa0, 0x46, 0xda, 0xcd, 0xa0, 0xcb, 0xdc, 0x9c, 0xc2, 0xc8, 0x6e, 0x8e, - 0xf2, 0x8c, 0x97, 0x14, 0x17, 0x6c, 0x70, 0x14, 0x89, 0xca, 0xbc, 0x82, 0x49, 0x2a, 0x51, 0xd9, - 0xa8, 0xb3, 0x57, 0x7a, 0xb4, 0x75, 0xf6, 0x3c, 0x38, 0xc5, 0x55, 0x54, 0xf9, 0x04, 0x0f, 0x91, - 0x36, 0xc0, 0x22, 0x51, 0x97, 0x92, 0x6c, 0x70, 0x9a, 0xef, 0xe3, 0xbc, 0x24, 0x07, 0x7d, 0x14, - 0x2a, 0xf2, 0x3b, 0x47, 0x33, 0x15, 0x9d, 0x93, 0x25, 0xbb, 0x01, 0xbb, 0xbc, 0x46, 0xfc, 0xb4, - 0xbf, 0x9e, 0xa3, 0x5e, 0x29, 0xff, 0xa7, 0x72, 0x6b, 0x3f, 0x0c, 0x25, 0xa7, 0x13, 0xef, 0x04, - 0x3d, 0x55, 0xde, 0x17, 0x18, 0x14, 0x0b, 0x2c, 0x5a, 0x85, 0x42, 0x4d, 0xe7, 0x4b, 0x8e, 0xd2, - 0x8a, 0x7a, 0x83, 0xcf, 0x89, 0x09, 0x66, 0x5c, 0xd0, 0x73, 0x50, 0x88, 0x9d, 0x46, 0xe2, 0xfe, - 0xc5, 0x2d, 0xa7, 0x11, 0x61, 0x06, 0x35, 0x27, 0xcd, 0xc2, 0x11, 0x93, 0xe6, 0xeb, 0x30, 0x19, - 0x79, 0x0d, 0xdf, 0x89, 0x3b, 0x21, 0x31, 0x0e, 0x93, 0xf4, 0x99, 0xbe, 0x89, 0xc4, 0x49, 0x5a, - 0xfb, 0xfd, 0x0a, 0x9c, 0xed, 0x77, 0x4f, 0x76, 0xd6, 0x51, 0xe7, 0xfd, 0x64, 0x3c, 0xba, 0xa8, - 0xf3, 0x01, 0xd2, 0x9b, 0x46, 0xd4, 0x79, 0xd3, 0x88, 0x3a, 0xff, 0xb2, 0x05, 0x15, 0x15, 0x6c, - 0x2d, 0x02, 0x46, 0x3f, 0x75, 0x02, 0x77, 0x91, 0x4b, 0x11, 0x22, 0xe6, 0x56, 0xfe, 0xc5, 0x5a, - 0xf8, 0xc9, 0x85, 0xa1, 0x3f, 0x50, 0xa1, 0x91, 0xc2, 0xd0, 0x55, 0x8c, 0x7e, 0x31, 0x8b, 0x18, - 0xfd, 0x01, 0x9f, 0xaa, 0x6f, 0x8c, 0xfe, 0x37, 0x2c, 0x18, 0x77, 0xde, 0xee, 0x84, 0x64, 0x89, - 0xec, 0xad, 0xb7, 0x23, 0x61, 0x60, 0x3f, 0x9d, 0xbd, 0x02, 0x0b, 0x5a, 0x88, 0x28, 0x47, 0xab, - 0x01, 0xd8, 0x54, 0x21, 0x11, 0x93, 0x3f, 0x96, 0x45, 0x4c, 0x7e, 0x3f, 0x75, 0x8e, 0x8c, 0xc9, - 0x7f, 0x1d, 0x26, 0xdd, 0x66, 0xe0, 0x93, 0x8d, 0x30, 0x88, 0x03, 0x37, 0x68, 0x0a, 0x67, 0x5a, - 0x99, 0x84, 0x45, 0x13, 0x89, 0x93, 0xb4, 0x83, 0x02, 0xfa, 0x2b, 0xc7, 0x0d, 0xe8, 0x87, 0xc7, - 0x14, 0xd0, 0xff, 0xe7, 0x39, 0x98, 0x3d, 0xe2, 0xa3, 0xa2, 0xd7, 0x60, 0x22, 0x08, 0x1b, 0x8e, - 0xef, 0xbd, 0xcd, 0xf3, 0x29, 0x8b, 0xc9, 0x72, 0x17, 0xeb, 0x06, 0x0e, 0x27, 0x28, 0x65, 0xc8, - 0x6f, 0x69, 0x40, 0xc8, 0xef, 0xc7, 0x60, 0x3c, 0x26, 0x4e, 0x4b, 0xc4, 0x4a, 0x88, 0x05, 0x90, - 0x3e, 0x50, 0xd2, 0x28, 0x6c, 0xd2, 0xd1, 0x6e, 0x34, 0xe5, 0xb8, 0x2e, 0x89, 0x22, 0x19, 0xd3, - 0x2b, 0x36, 0x67, 0x32, 0x0b, 0x18, 0x66, 0x7b, 0x5e, 0x0b, 0x09, 0x11, 0x38, 0x25, 0x92, 0x2a, - 0xef, 0x34, 0x9b, 0x3c, 0x7c, 0x9f, 0xc8, 0x1b, 0x95, 0x75, 0xf5, 0x05, 0x8d, 0xc2, 0x26, 0x9d, - 0xfd, 0x1b, 0x39, 0x78, 0xfe, 0x81, 0xe6, 0x65, 0xe8, 0x70, 0xeb, 0x4e, 0x44, 0xc2, 0xf4, 0x81, - 0xcc, 0xcd, 0x88, 0x84, 0x98, 0x61, 0x78, 0x2b, 0xb5, 0xdb, 0xc6, 0x55, 0x2e, 0x59, 0x47, 0xf7, - 0xf3, 0x56, 0x4a, 0x88, 0xc0, 0x29, 0x91, 0xe9, 0x56, 0x2a, 0x0c, 0xd9, 0x4a, 0xff, 0x20, 0x07, - 0x2f, 0x0c, 0x61, 0x84, 0x33, 0xcc, 0x82, 0x48, 0x66, 0x91, 0xe4, 0x1f, 0x4f, 0x16, 0xc9, 0xc3, - 0x36, 0xd7, 0x77, 0x72, 0x70, 0x7e, 0xb0, 0x2d, 0x44, 0x3f, 0x49, 0x17, 0x51, 0x32, 0xd8, 0xc2, - 0xcc, 0x40, 0x39, 0xc3, 0x17, 0x50, 0x09, 0x14, 0x4e, 0xd3, 0xa2, 0x39, 0x80, 0xb6, 0x13, 0xef, - 0x44, 0x97, 0xf7, 0xbd, 0x28, 0x16, 0xb9, 0x93, 0x53, 0x7c, 0x2b, 0x5c, 0x42, 0xb1, 0x41, 0x41, - 0xc5, 0xb1, 0x7f, 0x4b, 0xc1, 0x8d, 0x20, 0xe6, 0x0f, 0x71, 0x3f, 0xee, 0x8c, 0xac, 0xf7, 0x67, - 0xa0, 0x70, 0x9a, 0x96, 0x8a, 0x63, 0x87, 0x2d, 0x5c, 0x51, 0x71, 0x5d, 0x3c, 0x15, 0xb7, 0xaa, - 0xa0, 0xd8, 0xa0, 0x48, 0xe7, 0xd6, 0x14, 0x87, 0xc8, 0xad, 0xf9, 0x27, 0x39, 0x78, 0x66, 0xe0, - 0x5c, 0x3a, 0xdc, 0x00, 0x7c, 0xf2, 0x92, 0x6a, 0x1e, 0xae, 0xef, 0x8c, 0x98, 0x2a, 0xf2, 0xa7, - 0x03, 0x7a, 0x9a, 0x48, 0x15, 0x49, 0x4f, 0x15, 0xd6, 0xa8, 0x53, 0xc5, 0x13, 0xd4, 0x9e, 0x3d, - 0xd9, 0x21, 0x85, 0x11, 0xb2, 0x43, 0x52, 0x1f, 0xa3, 0x38, 0xe4, 0x40, 0xfe, 0xee, 0xe0, 0xe6, - 0xa5, 0xbe, 0xf7, 0x50, 0xdb, 0x53, 0x4b, 0x70, 0xda, 0xf3, 0x59, 0xed, 0xd7, 0xcd, 0xce, 0xb6, - 0xc8, 0xac, 0xcd, 0x25, 0xaf, 0x35, 0x5a, 0x49, 0xe1, 0x71, 0xcf, 0x13, 0x4f, 0x60, 0xb6, 0xce, - 0x43, 0x36, 0xe9, 0x67, 0xa0, 0xa2, 0x78, 0xf3, 0xc8, 0x48, 0xf5, 0x41, 0x7b, 0x22, 0x23, 0xd5, - 0xd7, 0x34, 0xa8, 0x68, 0x4b, 0xec, 0x92, 0x6e, 0xba, 0x67, 0x5e, 0x27, 0x5d, 0x76, 0x4a, 0x6a, - 0xff, 0x18, 0x4c, 0xa8, 0x45, 0xe4, 0xb0, 0xb5, 0x49, 0xed, 0x77, 0x4b, 0x30, 0x99, 0xa8, 0xa0, - 0x90, 0xd8, 0xb3, 0xb1, 0x8e, 0xdc, 0xb3, 0x61, 0xd1, 0xa9, 0x1d, 0x5f, 0x56, 0xff, 0x35, 0xa2, - 0x53, 0x3b, 0x3e, 0xc1, 0x1c, 0x47, 0x97, 0xee, 0xb5, 0xb0, 0x8b, 0x3b, 0xbe, 0x88, 0x48, 0x53, - 0x4b, 0xf7, 0x25, 0x06, 0xc5, 0x02, 0x8b, 0x3e, 0x6f, 0xc1, 0x44, 0xc4, 0x36, 0x04, 0xf9, 0x8e, - 0x97, 0xf8, 0xa0, 0xd7, 0xb2, 0xb8, 0xbd, 0x56, 0x54, 0x0b, 0x61, 0x87, 0xd9, 0x26, 0x04, 0x27, - 0x24, 0xa2, 0x2f, 0x59, 0xe6, 0xbd, 0xbd, 0xa5, 0x2c, 0x22, 0x29, 0xd3, 0x05, 0x2a, 0xf8, 0x56, - 0xc9, 0x83, 0xaf, 0xef, 0xd5, 0xd7, 0x79, 0x8f, 0x3d, 0xba, 0xeb, 0xbc, 0x3f, 0x0a, 0x95, 0x96, - 0xe3, 0x7b, 0x75, 0x12, 0xc5, 0x7c, 0x87, 0x48, 0xd6, 0xcd, 0x91, 0x40, 0xac, 0xf1, 0x74, 0xb2, - 0x8b, 0xd8, 0x8b, 0xc5, 0xc6, 0x96, 0x0e, 0x9b, 0xec, 0x36, 0x35, 0x18, 0x9b, 0x34, 0xe6, 0xfe, - 0x13, 0x3c, 0xd6, 0xfd, 0xa7, 0xf1, 0x23, 0xf6, 0x9f, 0xfe, 0x91, 0x05, 0xe7, 0xfa, 0x7e, 0xb5, - 0x27, 0x37, 0x46, 0xc9, 0x7e, 0x3f, 0x0f, 0x67, 0xfa, 0x94, 0x42, 0x41, 0xdd, 0x13, 0xbb, 0x87, - 0x5a, 0xd4, 0x5a, 0x99, 0x1c, 0xd8, 0x89, 0x47, 0xdb, 0xfd, 0xd5, 0x3b, 0xb0, 0xf9, 0x47, 0xbb, - 0x03, 0x6b, 0x74, 0xcb, 0xc2, 0x63, 0xed, 0x96, 0xc5, 0x23, 0xba, 0xe5, 0xfb, 0x79, 0x30, 0xae, - 0x95, 0x47, 0xbf, 0x60, 0x96, 0x27, 0xb2, 0xb2, 0x2a, 0xa5, 0xc3, 0x99, 0xab, 0xf2, 0x46, 0x5c, - 0x9d, 0x7e, 0xd5, 0x8e, 0xd2, 0x16, 0x20, 0x37, 0x84, 0x05, 0x68, 0xca, 0x3a, 0x50, 0xf9, 0xec, - 0xeb, 0x40, 0x55, 0xd2, 0x35, 0xa0, 0xd0, 0xef, 0x58, 0x30, 0xd3, 0x1a, 0x50, 0xaf, 0x30, 0x9b, - 0xf4, 0xfc, 0x41, 0xd5, 0x10, 0xab, 0xcf, 0x1d, 0x1e, 0xcc, 0x0e, 0x2c, 0x13, 0x89, 0x07, 0x6a, - 0x65, 0xff, 0x2d, 0x8b, 0x8f, 0xe2, 0xd4, 0x57, 0xd0, 0xd3, 0xac, 0xf5, 0x80, 0x69, 0xf6, 0x25, - 0x76, 0xd3, 0x59, 0xfd, 0x2a, 0x71, 0x9a, 0x62, 0x3a, 0x36, 0x2f, 0x2d, 0x63, 0x70, 0xac, 0x28, - 0xd8, 0xdd, 0x04, 0xcd, 0x66, 0x70, 0xef, 0x72, 0xab, 0x1d, 0x77, 0xc5, 0xc4, 0xac, 0xef, 0x26, - 0x50, 0x18, 0x6c, 0x50, 0xd9, 0x7f, 0x27, 0xc7, 0x7b, 0xa0, 0x38, 0xa4, 0x7c, 0x2d, 0x55, 0x08, - 0x7b, 0xf8, 0xf3, 0xbd, 0x9f, 0x03, 0x70, 0xd5, 0x25, 0x47, 0xd9, 0x5c, 0x52, 0xaf, 0x2f, 0x4d, - 0x32, 0x6f, 0x4e, 0x97, 0x30, 0x6c, 0xc8, 0x4b, 0x18, 0xa6, 0xfc, 0x91, 0x86, 0x29, 0x31, 0x46, - 0x0b, 0x47, 0x8c, 0xd1, 0x3f, 0xb7, 0x20, 0xe1, 0x5e, 0xa0, 0x36, 0x14, 0xa9, 0xba, 0xdd, 0x6c, - 0xee, 0x6f, 0x32, 0x59, 0x53, 0x3b, 0x23, 0xba, 0x3d, 0xfb, 0x89, 0xb9, 0x20, 0xd4, 0x14, 0x67, - 0x99, 0xb9, 0x2c, 0xee, 0x18, 0x33, 0x05, 0x5e, 0x0d, 0x82, 0x5d, 0x7e, 0x04, 0xa2, 0xcf, 0x45, - 0xed, 0xd7, 0x60, 0xba, 0x47, 0x29, 0x56, 0xf3, 0x36, 0x90, 0x97, 0x56, 0x19, 0xdd, 0x95, 0x55, - 0xe0, 0xc6, 0x1c, 0x67, 0x7f, 0xc7, 0x82, 0xd3, 0x69, 0xf6, 0xe8, 0x9b, 0x16, 0x4c, 0x47, 0x69, - 0x7e, 0x27, 0xd5, 0x76, 0x2a, 0xce, 0xa7, 0x07, 0x85, 0x7b, 0x95, 0xb0, 0xff, 0xbf, 0xe8, 0xfc, - 0xb7, 0x3d, 0xbf, 0x16, 0xdc, 0x53, 0xb3, 0xbc, 0x35, 0x70, 0x96, 0xa7, 0xe3, 0xd1, 0xdd, 0x21, - 0xb5, 0x4e, 0xb3, 0x27, 0x93, 0x69, 0x53, 0xc0, 0xb1, 0xa2, 0x48, 0xdc, 0x10, 0x9d, 0x3f, 0xf2, - 0x86, 0xe8, 0x57, 0x61, 0xc2, 0xbc, 0x98, 0x4d, 0xf4, 0x4b, 0xe6, 0xdd, 0x9a, 0x77, 0xb8, 0xe1, - 0x04, 0x55, 0xea, 0x6a, 0xde, 0xe2, 0x91, 0x57, 0xf3, 0xbe, 0x08, 0x65, 0x71, 0xcd, 0xac, 0x8c, - 0x86, 0xe3, 0x69, 0x52, 0x02, 0x86, 0x15, 0x96, 0x5a, 0x93, 0x96, 0xe3, 0x77, 0x9c, 0x26, 0x6d, - 0x21, 0x91, 0x8f, 0xa9, 0x86, 0xe1, 0x9a, 0xc2, 0x60, 0x83, 0x8a, 0xbe, 0x71, 0xec, 0xb5, 0xc8, - 0x5b, 0x81, 0x2f, 0xe3, 0x48, 0xf4, 0x06, 0xb1, 0x80, 0x63, 0x45, 0x61, 0xff, 0x37, 0x0b, 0xd2, - 0x77, 0x64, 0x26, 0xb6, 0x0c, 0xac, 0x23, 0x73, 0x40, 0x93, 0xd9, 0x68, 0xb9, 0xa1, 0xb2, 0xd1, - 0xcc, 0x44, 0xb1, 0xfc, 0x03, 0x13, 0xc5, 0x7e, 0x44, 0xdf, 0x9c, 0xc0, 0x33, 0xca, 0xc6, 0xfb, - 0xdd, 0x9a, 0x80, 0x6c, 0x28, 0xb9, 0x8e, 0xca, 0xec, 0x9f, 0xe0, 0x8e, 0xf8, 0xe2, 0x02, 0x23, - 0x12, 0x98, 0xea, 0xf6, 0x7b, 0xdf, 0xbf, 0xf0, 0xa1, 0xef, 0x7e, 0xff, 0xc2, 0x87, 0xfe, 0xf8, - 0xfb, 0x17, 0x3e, 0xf4, 0xf9, 0xc3, 0x0b, 0xd6, 0x7b, 0x87, 0x17, 0xac, 0xef, 0x1e, 0x5e, 0xb0, - 0xfe, 0xf8, 0xf0, 0x82, 0xf5, 0xfe, 0xe1, 0x05, 0xeb, 0x1b, 0xff, 0xf9, 0xc2, 0x87, 0xde, 0xea, - 0x1b, 0xf7, 0x43, 0x7f, 0xbc, 0xec, 0xd6, 0xe6, 0xf7, 0x2e, 0xb1, 0xd0, 0x13, 0x3a, 0x1a, 0xe6, - 0x8d, 0x2e, 0x30, 0x2f, 0x47, 0xc3, 0x5f, 0x04, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x8e, 0x81, 0x82, - 0x37, 0xbc, 0x00, 0x00, + // 9618 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6f, 0x70, 0x24, 0xc7, + 0x75, 0x18, 0xae, 0xd9, 0xc5, 0x02, 0xbb, 0x0f, 0x7f, 0xee, 0xd0, 0x77, 0x47, 0x82, 0x47, 0xf2, + 0x70, 0x35, 0x2c, 0x53, 0xd4, 0x4f, 0x24, 0xf0, 0xe3, 0x89, 0x52, 0x18, 0xd3, 0xa6, 0x8c, 0x05, + 0xee, 0x70, 0xb8, 0x03, 0x0e, 0x60, 0x03, 0x77, 0x27, 0x91, 0xa6, 0xa4, 0xc1, 0x6c, 0xef, 0x62, + 0x0e, 0xb3, 0x33, 0xcb, 0x99, 0x59, 0x1c, 0x96, 0x96, 0x65, 0x49, 0x96, 0x6d, 0x25, 0xfa, 0x43, + 0x85, 0xfe, 0x10, 0xb9, 0x92, 0xd8, 0x8a, 0xed, 0x72, 0xc5, 0x95, 0xa8, 0xe2, 0x54, 0x3e, 0x24, + 0x4e, 0x2a, 0x55, 0x89, 0x9d, 0x0f, 0x4c, 0x29, 0x55, 0x51, 0x55, 0x5c, 0x96, 0x13, 0x3b, 0x30, + 0x75, 0xa9, 0x54, 0x52, 0xa9, 0x8a, 0x53, 0xf9, 0xf3, 0x25, 0x57, 0xf9, 0x90, 0xea, 0xff, 0x3d, + 0xb3, 0xbb, 0x87, 0xdd, 0xc3, 0xe0, 0xee, 0xa4, 0xe2, 0xb7, 0xdd, 0x7e, 0x6f, 0xde, 0xeb, 0xe9, + 0xe9, 0x7e, 0xfd, 0x5e, 0xbf, 0x3f, 0x0d, 0xab, 0x0d, 0x2f, 0xd9, 0x69, 0x6f, 0xcf, 0xb9, 0x61, + 0x73, 0xde, 0x89, 0x1a, 0x61, 0x2b, 0x0a, 0x6f, 0xb1, 0x1f, 0x2f, 0xb8, 0xb5, 0xf9, 0xbd, 0x0b, + 0xf3, 0xad, 0xdd, 0xc6, 0xbc, 0xd3, 0xf2, 0xe2, 0x79, 0xa7, 0xd5, 0xf2, 0x3d, 0xd7, 0x49, 0xbc, + 0x30, 0x98, 0xdf, 0x7b, 0xd1, 0xf1, 0x5b, 0x3b, 0xce, 0x8b, 0xf3, 0x0d, 0x12, 0x90, 0xc8, 0x49, + 0x48, 0x6d, 0xae, 0x15, 0x85, 0x49, 0x88, 0x7e, 0x4a, 0x53, 0x9b, 0x93, 0xd4, 0xd8, 0x8f, 0xcf, + 0xba, 0xb5, 0xb9, 0xbd, 0x0b, 0x73, 0xad, 0xdd, 0xc6, 0x1c, 0xa5, 0x36, 0x67, 0x50, 0x9b, 0x93, + 0xd4, 0xce, 0xbe, 0x60, 0xf4, 0xa5, 0x11, 0x36, 0xc2, 0x79, 0x46, 0x74, 0xbb, 0x5d, 0x67, 0xff, + 0xd8, 0x1f, 0xf6, 0x8b, 0x33, 0x3b, 0x6b, 0xef, 0xbe, 0x1c, 0xcf, 0x79, 0x21, 0xed, 0xde, 0xbc, + 0x1b, 0x46, 0x64, 0x7e, 0xaf, 0xab, 0x43, 0x67, 0x2f, 0x6b, 0x1c, 0xb2, 0x9f, 0x90, 0x20, 0xf6, + 0xc2, 0x20, 0x7e, 0x81, 0x76, 0x81, 0x44, 0x7b, 0x24, 0x32, 0x5f, 0xcf, 0x40, 0xe8, 0x45, 0xe9, + 0x25, 0x4d, 0xa9, 0xe9, 0xb8, 0x3b, 0x5e, 0x40, 0xa2, 0x8e, 0x7e, 0xbc, 0x49, 0x12, 0xa7, 0xd7, + 0x53, 0xf3, 0xfd, 0x9e, 0x8a, 0xda, 0x41, 0xe2, 0x35, 0x49, 0xd7, 0x03, 0x9f, 0x38, 0xec, 0x81, + 0xd8, 0xdd, 0x21, 0x4d, 0xa7, 0xeb, 0xb9, 0x8f, 0xf5, 0x7b, 0xae, 0x9d, 0x78, 0xfe, 0xbc, 0x17, + 0x24, 0x71, 0x12, 0x65, 0x1f, 0xb2, 0xdf, 0x82, 0xc9, 0x85, 0x9b, 0x9b, 0x0b, 0xed, 0x64, 0x67, + 0x31, 0x0c, 0xea, 0x5e, 0x03, 0x7d, 0x1c, 0xc6, 0x5d, 0xbf, 0x1d, 0x27, 0x24, 0xba, 0xe6, 0x34, + 0xc9, 0x8c, 0x75, 0xde, 0x7a, 0xae, 0x52, 0x3d, 0xf5, 0xde, 0xc1, 0xec, 0x87, 0xee, 0x1c, 0xcc, + 0x8e, 0x2f, 0x6a, 0x10, 0x36, 0xf1, 0xd0, 0x47, 0x60, 0x2c, 0x0a, 0x7d, 0xb2, 0x80, 0xaf, 0xcd, + 0x14, 0xd8, 0x23, 0x27, 0xc4, 0x23, 0x63, 0x98, 0x37, 0x63, 0x09, 0xb7, 0xff, 0xb8, 0x00, 0xb0, + 0xd0, 0x6a, 0x6d, 0x44, 0xe1, 0x2d, 0xe2, 0x26, 0xe8, 0x73, 0x50, 0xa6, 0x43, 0x57, 0x73, 0x12, + 0x87, 0x71, 0x1b, 0xbf, 0xf0, 0xff, 0xcf, 0xf1, 0x37, 0x99, 0x33, 0xdf, 0x44, 0x4f, 0x1c, 0x8a, + 0x3d, 0xb7, 0xf7, 0xe2, 0xdc, 0xfa, 0x36, 0x7d, 0x7e, 0x8d, 0x24, 0x4e, 0x15, 0x09, 0x66, 0xa0, + 0xdb, 0xb0, 0xa2, 0x8a, 0x02, 0x18, 0x89, 0x5b, 0xc4, 0x65, 0x1d, 0x1b, 0xbf, 0xb0, 0x3a, 0x77, + 0x94, 0x19, 0x3a, 0xa7, 0x7b, 0xbe, 0xd9, 0x22, 0x6e, 0x75, 0x42, 0x70, 0x1e, 0xa1, 0xff, 0x30, + 0xe3, 0x83, 0xf6, 0x60, 0x34, 0x4e, 0x9c, 0xa4, 0x1d, 0xcf, 0x14, 0x19, 0xc7, 0x6b, 0xb9, 0x71, + 0x64, 0x54, 0xab, 0x53, 0x82, 0xe7, 0x28, 0xff, 0x8f, 0x05, 0x37, 0xfb, 0x3f, 0x58, 0x30, 0xa5, + 0x91, 0x57, 0xbd, 0x38, 0x41, 0x3f, 0xdb, 0x35, 0xb8, 0x73, 0x83, 0x0d, 0x2e, 0x7d, 0x9a, 0x0d, + 0xed, 0x49, 0xc1, 0xac, 0x2c, 0x5b, 0x8c, 0x81, 0x6d, 0x42, 0xc9, 0x4b, 0x48, 0x33, 0x9e, 0x29, + 0x9c, 0x2f, 0x3e, 0x37, 0x7e, 0xe1, 0x72, 0x5e, 0xef, 0x59, 0x9d, 0x14, 0x4c, 0x4b, 0x2b, 0x94, + 0x3c, 0xe6, 0x5c, 0xec, 0xdf, 0x9d, 0x30, 0xdf, 0x8f, 0x0e, 0x38, 0x7a, 0x11, 0xc6, 0xe3, 0xb0, + 0x1d, 0xb9, 0x04, 0x93, 0x56, 0x18, 0xcf, 0x58, 0xe7, 0x8b, 0x74, 0xea, 0xd1, 0x99, 0xba, 0xa9, + 0x9b, 0xb1, 0x89, 0x83, 0xbe, 0x69, 0xc1, 0x44, 0x8d, 0xc4, 0x89, 0x17, 0x30, 0xfe, 0xb2, 0xf3, + 0x5b, 0x47, 0xee, 0xbc, 0x6c, 0x5c, 0xd2, 0xc4, 0xab, 0xa7, 0xc5, 0x8b, 0x4c, 0x18, 0x8d, 0x31, + 0x4e, 0xf1, 0xa7, 0x2b, 0xae, 0x46, 0x62, 0x37, 0xf2, 0x5a, 0xf4, 0x3f, 0x9b, 0x33, 0xc6, 0x8a, + 0x5b, 0xd2, 0x20, 0x6c, 0xe2, 0xa1, 0x00, 0x4a, 0x74, 0x45, 0xc5, 0x33, 0x23, 0xac, 0xff, 0x2b, + 0x47, 0xeb, 0xbf, 0x18, 0x54, 0xba, 0x58, 0xf5, 0xe8, 0xd3, 0x7f, 0x31, 0xe6, 0x6c, 0xd0, 0x37, + 0x2c, 0x98, 0x11, 0x2b, 0x1e, 0x13, 0x3e, 0xa0, 0x37, 0x77, 0xbc, 0x84, 0xf8, 0x5e, 0x9c, 0xcc, + 0x94, 0x58, 0x1f, 0xe6, 0x07, 0x9b, 0x5b, 0xcb, 0x51, 0xd8, 0x6e, 0x5d, 0xf5, 0x82, 0x5a, 0xf5, + 0xbc, 0xe0, 0x34, 0xb3, 0xd8, 0x87, 0x30, 0xee, 0xcb, 0x12, 0xfd, 0xaa, 0x05, 0x67, 0x03, 0xa7, + 0x49, 0xe2, 0x96, 0x43, 0x3f, 0x2d, 0x07, 0x57, 0x7d, 0xc7, 0xdd, 0x65, 0x3d, 0x1a, 0xbd, 0xbf, + 0x1e, 0xd9, 0xa2, 0x47, 0x67, 0xaf, 0xf5, 0x25, 0x8d, 0xef, 0xc1, 0x16, 0xfd, 0x96, 0x05, 0xd3, + 0x61, 0xd4, 0xda, 0x71, 0x02, 0x52, 0x93, 0xd0, 0x78, 0x66, 0x8c, 0x2d, 0xbd, 0xcf, 0x1c, 0xed, + 0x13, 0xad, 0x67, 0xc9, 0xae, 0x85, 0x81, 0x97, 0x84, 0xd1, 0x26, 0x49, 0x12, 0x2f, 0x68, 0xc4, + 0xd5, 0x33, 0x77, 0x0e, 0x66, 0xa7, 0xbb, 0xb0, 0x70, 0x77, 0x7f, 0xd0, 0xcf, 0xc1, 0x78, 0xdc, + 0x09, 0xdc, 0x9b, 0x5e, 0x50, 0x0b, 0x6f, 0xc7, 0x33, 0xe5, 0x3c, 0x96, 0xef, 0xa6, 0x22, 0x28, + 0x16, 0xa0, 0x66, 0x80, 0x4d, 0x6e, 0xbd, 0x3f, 0x9c, 0x9e, 0x4a, 0x95, 0xbc, 0x3f, 0x9c, 0x9e, + 0x4c, 0xf7, 0x60, 0x8b, 0x7e, 0xc5, 0x82, 0xc9, 0xd8, 0x6b, 0x04, 0x4e, 0xd2, 0x8e, 0xc8, 0x55, + 0xd2, 0x89, 0x67, 0x80, 0x75, 0xe4, 0xca, 0x11, 0x47, 0xc5, 0x20, 0x59, 0x3d, 0x23, 0xfa, 0x38, + 0x69, 0xb6, 0xc6, 0x38, 0xcd, 0xb7, 0xd7, 0x42, 0xd3, 0xd3, 0x7a, 0x3c, 0xdf, 0x85, 0xa6, 0x27, + 0x75, 0x5f, 0x96, 0xe8, 0x67, 0xe0, 0x24, 0x6f, 0x52, 0x23, 0x1b, 0xcf, 0x4c, 0x30, 0x41, 0x7b, + 0xfa, 0xce, 0xc1, 0xec, 0xc9, 0xcd, 0x0c, 0x0c, 0x77, 0x61, 0xa3, 0xb7, 0x60, 0xb6, 0x45, 0xa2, + 0xa6, 0x97, 0xac, 0x07, 0x7e, 0x47, 0x8a, 0x6f, 0x37, 0x6c, 0x91, 0x9a, 0xe8, 0x4e, 0x3c, 0x33, + 0x79, 0xde, 0x7a, 0xae, 0x5c, 0xfd, 0xb0, 0xe8, 0xe6, 0xec, 0xc6, 0xbd, 0xd1, 0xf1, 0x61, 0xf4, + 0xec, 0x7f, 0x55, 0x80, 0x93, 0xd9, 0x8d, 0x13, 0xfd, 0x8e, 0x05, 0x27, 0x6e, 0xdd, 0x4e, 0xb6, + 0xc2, 0x5d, 0x12, 0xc4, 0xd5, 0x0e, 0x15, 0x6f, 0x6c, 0xcb, 0x18, 0xbf, 0xe0, 0xe6, 0xbb, 0x45, + 0xcf, 0x5d, 0x49, 0x73, 0xb9, 0x18, 0x24, 0x51, 0xa7, 0xfa, 0xb8, 0x78, 0xbb, 0x13, 0x57, 0x6e, + 0x6e, 0x99, 0x50, 0x9c, 0xed, 0xd4, 0xd9, 0xaf, 0x59, 0x70, 0xba, 0x17, 0x09, 0x74, 0x12, 0x8a, + 0xbb, 0xa4, 0xc3, 0xb5, 0x32, 0x4c, 0x7f, 0xa2, 0x37, 0xa1, 0xb4, 0xe7, 0xf8, 0x6d, 0x22, 0xb4, + 0x9b, 0xe5, 0xa3, 0xbd, 0x88, 0xea, 0x19, 0xe6, 0x54, 0x7f, 0xb2, 0xf0, 0xb2, 0x65, 0xff, 0x9b, + 0x22, 0x8c, 0x1b, 0xfb, 0xdb, 0x03, 0xd0, 0xd8, 0xc2, 0x94, 0xc6, 0xb6, 0x96, 0xdb, 0xd6, 0xdc, + 0x57, 0x65, 0xbb, 0x9d, 0x51, 0xd9, 0xd6, 0xf3, 0x63, 0x79, 0x4f, 0x9d, 0x0d, 0x25, 0x50, 0x09, + 0x5b, 0x54, 0x23, 0xa7, 0x5b, 0xff, 0x48, 0x1e, 0x9f, 0x70, 0x5d, 0x92, 0xab, 0x4e, 0xde, 0x39, + 0x98, 0xad, 0xa8, 0xbf, 0x58, 0x33, 0xb2, 0x7f, 0x60, 0xc1, 0x69, 0xa3, 0x8f, 0x8b, 0x61, 0x50, + 0xf3, 0xd8, 0xa7, 0x3d, 0x0f, 0x23, 0x49, 0xa7, 0x25, 0xd5, 0x7e, 0x35, 0x52, 0x5b, 0x9d, 0x16, + 0xc1, 0x0c, 0x42, 0x15, 0xfd, 0x26, 0x89, 0x63, 0xa7, 0x41, 0xb2, 0x8a, 0xfe, 0x1a, 0x6f, 0xc6, + 0x12, 0x8e, 0x22, 0x40, 0xbe, 0x13, 0x27, 0x5b, 0x91, 0x13, 0xc4, 0x8c, 0xfc, 0x96, 0xd7, 0x24, + 0x62, 0x80, 0xff, 0xbf, 0xc1, 0x66, 0x0c, 0x7d, 0xa2, 0xfa, 0xd8, 0x9d, 0x83, 0x59, 0xb4, 0xda, + 0x45, 0x09, 0xf7, 0xa0, 0x6e, 0xff, 0xaa, 0x05, 0x8f, 0xf5, 0xd6, 0xc5, 0xd0, 0xb3, 0x30, 0xca, + 0x4d, 0x3e, 0xf1, 0x76, 0xfa, 0x93, 0xb0, 0x56, 0x2c, 0xa0, 0x68, 0x1e, 0x2a, 0x6a, 0x9f, 0x10, + 0xef, 0x38, 0x2d, 0x50, 0x2b, 0x7a, 0x73, 0xd1, 0x38, 0x74, 0xd0, 0xe8, 0x1f, 0xa1, 0xb9, 0xa9, + 0x41, 0x63, 0x46, 0x12, 0x83, 0xd8, 0x7f, 0x6e, 0xc1, 0x09, 0xa3, 0x57, 0x0f, 0x40, 0x35, 0x0f, + 0xd2, 0xaa, 0xf9, 0x4a, 0x6e, 0xf3, 0xb9, 0x8f, 0x6e, 0xfe, 0x0d, 0x0b, 0xce, 0x1a, 0x58, 0x6b, + 0x4e, 0xe2, 0xee, 0x5c, 0xdc, 0x6f, 0x45, 0x24, 0xa6, 0xe6, 0x34, 0x7a, 0xda, 0x90, 0x5b, 0xd5, + 0x71, 0x41, 0xa1, 0x78, 0x95, 0x74, 0xb8, 0x10, 0x7b, 0x1e, 0xca, 0x7c, 0x72, 0x86, 0x91, 0x18, + 0x71, 0xf5, 0x6e, 0xeb, 0xa2, 0x1d, 0x2b, 0x0c, 0x64, 0xc3, 0x28, 0x13, 0x4e, 0x74, 0xb1, 0xd2, + 0x6d, 0x08, 0xe8, 0x47, 0xbc, 0xc1, 0x5a, 0xb0, 0x80, 0xd8, 0x77, 0x0a, 0xcc, 0x56, 0x50, 0xab, + 0x90, 0x3c, 0x08, 0x43, 0x33, 0x4a, 0x89, 0xad, 0x8d, 0xfc, 0x64, 0x08, 0xe9, 0x6f, 0x6c, 0xbe, + 0x9d, 0x91, 0x5c, 0x38, 0x57, 0xae, 0xf7, 0x36, 0x38, 0x7f, 0xa3, 0x00, 0xb3, 0xe9, 0x07, 0xba, + 0x04, 0x1f, 0xb5, 0x6e, 0x0c, 0x46, 0xd9, 0xf3, 0x04, 0x03, 0x1f, 0x9b, 0x78, 0x7d, 0x64, 0x47, + 0xe1, 0x38, 0x65, 0x87, 0x29, 0xda, 0x8a, 0x87, 0x88, 0xb6, 0x67, 0xd5, 0xa8, 0x97, 0x32, 0xb2, + 0x24, 0x3d, 0x42, 0xff, 0xb5, 0x00, 0x8f, 0xa7, 0x47, 0x48, 0xcb, 0xda, 0x4f, 0xa6, 0x64, 0xed, + 0x47, 0x4d, 0x59, 0x7b, 0xf7, 0x60, 0xf6, 0xc9, 0x3e, 0x8f, 0xfd, 0xc8, 0x88, 0x62, 0xb4, 0xac, + 0xc6, 0x68, 0x84, 0xf5, 0x6e, 0x3e, 0x3d, 0x46, 0x77, 0x0f, 0x66, 0x9f, 0xee, 0xf3, 0x8e, 0x99, + 0x3d, 0xf2, 0x59, 0x18, 0x8d, 0x88, 0x13, 0x87, 0x41, 0x76, 0xb0, 0x31, 0x6b, 0xc5, 0x02, 0x6a, + 0xff, 0x79, 0x39, 0x3b, 0xd8, 0xcb, 0xfc, 0xb4, 0x2b, 0x8c, 0x90, 0x07, 0x23, 0x4c, 0x7f, 0xe6, + 0x0b, 0xff, 0xea, 0xd1, 0x16, 0x09, 0x95, 0xb7, 0x8a, 0x74, 0xb5, 0x4c, 0xbf, 0x1a, 0x6d, 0xc2, + 0x8c, 0x05, 0xda, 0x87, 0xb2, 0x2b, 0xd5, 0xda, 0x42, 0x1e, 0x07, 0x40, 0x42, 0xa9, 0xd5, 0x1c, + 0x27, 0xa8, 0x60, 0x54, 0xba, 0xb0, 0xe2, 0x86, 0x08, 0x14, 0x1b, 0x5e, 0x22, 0x3e, 0xeb, 0x11, + 0x0d, 0x97, 0x65, 0xcf, 0x78, 0xc5, 0x31, 0x2a, 0xad, 0x97, 0xbd, 0x04, 0x53, 0xfa, 0xe8, 0x97, + 0x2c, 0x18, 0x8f, 0xdd, 0xe6, 0x46, 0x14, 0xee, 0x79, 0x35, 0x12, 0x09, 0xb5, 0xe5, 0x88, 0x82, + 0x67, 0x73, 0x71, 0x4d, 0x12, 0xd4, 0x7c, 0xb9, 0x21, 0xa9, 0x21, 0xd8, 0xe4, 0x4b, 0xd5, 0xf9, + 0xc7, 0xc5, 0xbb, 0x2f, 0x11, 0xd7, 0xa3, 0x1b, 0x8d, 0xb4, 0x5e, 0xd8, 0x4c, 0x39, 0xb2, 0x1a, + 0xb7, 0xd4, 0x76, 0x77, 0xe9, 0x7a, 0xd3, 0x1d, 0x7a, 0xf2, 0xce, 0xc1, 0xec, 0xe3, 0x8b, 0xbd, + 0x79, 0xe2, 0x7e, 0x9d, 0x61, 0x03, 0xd6, 0x6a, 0xfb, 0x3e, 0x26, 0x6f, 0xb5, 0x09, 0x3b, 0x9b, + 0xc8, 0x61, 0xc0, 0x36, 0x34, 0xc1, 0xcc, 0x80, 0x19, 0x10, 0x6c, 0xf2, 0x45, 0x6f, 0xc1, 0x68, + 0xd3, 0x49, 0x22, 0x6f, 0x5f, 0x1c, 0x48, 0x1c, 0x51, 0xb1, 0x5e, 0x63, 0xb4, 0x34, 0x73, 0xb6, + 0x0f, 0xf3, 0x46, 0x2c, 0x18, 0xa1, 0x26, 0x94, 0x9a, 0x24, 0x6a, 0x90, 0x99, 0x72, 0x1e, 0x87, + 0xaf, 0x6b, 0x94, 0x94, 0x66, 0x58, 0xa1, 0x6a, 0x08, 0x6b, 0xc3, 0x9c, 0x0b, 0x7a, 0x13, 0xca, + 0x31, 0xf1, 0x89, 0x4b, 0x15, 0x89, 0x0a, 0xe3, 0xf8, 0xb1, 0x01, 0x95, 0x2a, 0x67, 0x9b, 0xf8, + 0x9b, 0xe2, 0x51, 0xbe, 0xc0, 0xe4, 0x3f, 0xac, 0x48, 0xda, 0xff, 0xc9, 0x02, 0x94, 0x96, 0x30, + 0x0f, 0x40, 0x95, 0x7b, 0x2b, 0xad, 0xca, 0xad, 0xe6, 0xb9, 0xc1, 0xf7, 0xd1, 0xe6, 0xde, 0x2b, + 0x43, 0x46, 0x36, 0x5f, 0x23, 0x71, 0x42, 0x6a, 0x1f, 0xc8, 0xd3, 0x0f, 0xe4, 0xe9, 0x07, 0xf2, + 0x54, 0xc9, 0xd3, 0xed, 0x8c, 0x3c, 0x7d, 0xd5, 0x58, 0xf5, 0xda, 0x95, 0xf8, 0x59, 0xe5, 0x6b, + 0x34, 0x7b, 0x60, 0x20, 0x50, 0x49, 0x70, 0x65, 0x73, 0xfd, 0x5a, 0x4f, 0x01, 0xfa, 0xd9, 0xb4, + 0x00, 0x3d, 0x2a, 0x8b, 0x07, 0x2e, 0x32, 0xff, 0x46, 0x01, 0x9e, 0x48, 0x8b, 0x12, 0x1c, 0xfa, + 0x7e, 0xd8, 0x4e, 0x36, 0x13, 0xd2, 0x42, 0xbf, 0x6e, 0xc1, 0xc9, 0x66, 0xda, 0x56, 0x8c, 0xc5, + 0x91, 0xdc, 0xa7, 0x72, 0x93, 0x73, 0x19, 0x63, 0xb4, 0x3a, 0x23, 0x64, 0xde, 0xc9, 0x0c, 0x20, + 0xc6, 0x5d, 0x7d, 0x41, 0x6f, 0x42, 0xa5, 0xe9, 0xec, 0x5f, 0x6f, 0xd5, 0x9c, 0x44, 0x9a, 0x1f, + 0xfd, 0xad, 0xc6, 0x76, 0xe2, 0xf9, 0x73, 0xdc, 0xd1, 0x3a, 0xb7, 0x12, 0x24, 0xeb, 0xd1, 0x66, + 0x12, 0x79, 0x41, 0x83, 0x1f, 0xc4, 0xac, 0x49, 0x32, 0x58, 0x53, 0xb4, 0xff, 0x96, 0x95, 0x15, + 0xb4, 0x6a, 0x74, 0x22, 0x27, 0x21, 0x8d, 0x0e, 0xfa, 0x3c, 0x94, 0xe2, 0x84, 0xb4, 0xe4, 0xa8, + 0xdc, 0xcc, 0x53, 0xfa, 0x1b, 0x5f, 0x42, 0x6f, 0x04, 0xf4, 0x5f, 0x8c, 0x39, 0x53, 0xfb, 0xce, + 0x48, 0x76, 0xc3, 0x63, 0x6e, 0xb7, 0x0b, 0x00, 0x8d, 0x70, 0x8b, 0x34, 0x5b, 0x3e, 0x1d, 0x16, + 0x8b, 0x9d, 0xdd, 0x2a, 0xd3, 0x78, 0x59, 0x41, 0xb0, 0x81, 0x85, 0xfe, 0x8a, 0x05, 0xd0, 0x90, + 0x0b, 0x4b, 0x6e, 0x66, 0xd7, 0xf3, 0x7c, 0x1d, 0xbd, 0x6c, 0x75, 0x5f, 0x14, 0x43, 0x6c, 0x30, + 0x47, 0x5f, 0xb6, 0xa0, 0x9c, 0xc8, 0xee, 0x73, 0xf1, 0xbe, 0x95, 0x67, 0x4f, 0xe4, 0x4b, 0xeb, + 0x7d, 0x5d, 0x0d, 0x89, 0xe2, 0x8b, 0x7e, 0xd9, 0x02, 0x88, 0x3b, 0x81, 0xbb, 0x11, 0xfa, 0x9e, + 0xdb, 0x11, 0x52, 0xff, 0x46, 0xae, 0xe6, 0xbb, 0xa2, 0x5e, 0x9d, 0xa2, 0xa3, 0xa1, 0xff, 0x63, + 0x83, 0x33, 0xfa, 0x02, 0x94, 0x63, 0x31, 0xdd, 0x84, 0x9c, 0xdf, 0xca, 0xf7, 0x10, 0x81, 0xd3, + 0x16, 0x22, 0x42, 0xfc, 0xc3, 0x8a, 0xa7, 0xfd, 0xbd, 0x42, 0xea, 0x34, 0x52, 0x9d, 0x3b, 0xb0, + 0x29, 0xe3, 0x4a, 0xa3, 0x50, 0xae, 0x80, 0x5c, 0xa7, 0x8c, 0x32, 0x39, 0xf5, 0x94, 0x51, 0x4d, + 0x31, 0x36, 0x98, 0xd3, 0xcd, 0x71, 0xda, 0xc9, 0x9e, 0x6e, 0x88, 0x59, 0xfc, 0x66, 0x9e, 0x5d, + 0xea, 0x3e, 0x3b, 0x7e, 0x42, 0x74, 0x6d, 0xba, 0x0b, 0x84, 0xbb, 0xbb, 0x64, 0x7f, 0x2f, 0x7d, + 0x02, 0x6a, 0x7c, 0x80, 0x01, 0x4e, 0x77, 0xbf, 0x69, 0xc1, 0x78, 0x14, 0xfa, 0xbe, 0x17, 0x34, + 0xe8, 0x64, 0x11, 0x12, 0xef, 0x8d, 0x63, 0x11, 0x3a, 0x62, 0x56, 0xb0, 0x2d, 0x16, 0x6b, 0x9e, + 0xd8, 0xec, 0x80, 0xfd, 0x25, 0x0b, 0x66, 0xfa, 0x4d, 0x6a, 0x44, 0xe0, 0x49, 0x2a, 0xa9, 0xe9, + 0xc6, 0xa7, 0x7c, 0x9b, 0xeb, 0xc1, 0x12, 0xf1, 0x89, 0x3a, 0x6b, 0x2a, 0x57, 0x9f, 0x11, 0xaf, + 0xf9, 0xe4, 0x46, 0x7f, 0x54, 0x7c, 0x2f, 0x3a, 0xf6, 0x6f, 0x17, 0xb2, 0x23, 0xaa, 0x84, 0xda, + 0xb7, 0xad, 0x2e, 0xd5, 0xff, 0x53, 0xc7, 0x21, 0x48, 0x98, 0x91, 0xa0, 0x5c, 0x9c, 0xfd, 0x71, + 0x1e, 0xa2, 0x0f, 0xc5, 0xfe, 0xd7, 0x23, 0x70, 0x8f, 0x9e, 0xa9, 0x53, 0x72, 0xab, 0xdf, 0x29, + 0xf9, 0xf0, 0x07, 0xef, 0x5f, 0xb7, 0x60, 0xd4, 0xa7, 0x5a, 0x08, 0x3f, 0x09, 0x1e, 0xbf, 0x50, + 0x3b, 0xae, 0xb1, 0xe7, 0xca, 0x4e, 0xcc, 0xfd, 0x78, 0xea, 0xfc, 0x89, 0x37, 0x62, 0xd1, 0x07, + 0xf4, 0x1d, 0x0b, 0xc6, 0x9d, 0x20, 0x08, 0x13, 0x11, 0x58, 0xc2, 0x03, 0x33, 0xbc, 0x63, 0xeb, + 0xd3, 0x82, 0xe6, 0xc5, 0x3b, 0xa6, 0x8f, 0x55, 0x35, 0x04, 0x9b, 0x5d, 0x42, 0x73, 0x00, 0x75, + 0x2f, 0x70, 0x7c, 0xef, 0x6d, 0x6a, 0x4d, 0x95, 0xd8, 0xf1, 0x39, 0xdb, 0x1a, 0x2e, 0xa9, 0x56, + 0x6c, 0x60, 0x9c, 0xfd, 0xcb, 0x30, 0x6e, 0xbc, 0x79, 0x0f, 0xf7, 0xe3, 0x69, 0xd3, 0xfd, 0x58, + 0x31, 0xbc, 0x86, 0x67, 0x5f, 0x85, 0x93, 0xd9, 0x0e, 0x0e, 0xf3, 0xbc, 0xfd, 0x3b, 0xa3, 0xd9, + 0xc3, 0xe5, 0x2d, 0x12, 0x35, 0x69, 0xd7, 0x3e, 0xb0, 0x42, 0x3f, 0xb0, 0x42, 0x3f, 0xb0, 0x42, + 0xe5, 0x1f, 0xfb, 0x4e, 0x09, 0x52, 0x9a, 0x01, 0xef, 0xdd, 0x47, 0x60, 0x2c, 0x22, 0xad, 0xf0, + 0x3a, 0x5e, 0x15, 0x12, 0x57, 0x07, 0x64, 0xf2, 0x66, 0x2c, 0xe1, 0x54, 0x32, 0xb7, 0x9c, 0x64, + 0x47, 0x88, 0x5c, 0x25, 0x99, 0x37, 0x9c, 0x64, 0x07, 0x33, 0x08, 0x7a, 0x15, 0xa6, 0x12, 0x27, + 0x6a, 0x90, 0x04, 0x93, 0x3d, 0x36, 0x08, 0xe2, 0x48, 0xff, 0x31, 0x81, 0x3b, 0xb5, 0x95, 0x82, + 0xe2, 0x0c, 0x36, 0x7a, 0x0b, 0x46, 0x76, 0x88, 0xdf, 0x14, 0x66, 0xf2, 0x66, 0x7e, 0x12, 0x91, + 0xbd, 0xeb, 0x65, 0xe2, 0x37, 0xf9, 0x7a, 0xa5, 0xbf, 0x30, 0x63, 0x45, 0xbf, 0x4e, 0x65, 0xb7, + 0x1d, 0x27, 0x61, 0xd3, 0x7b, 0x5b, 0x1a, 0xcf, 0x9f, 0xca, 0x99, 0xf1, 0x55, 0x49, 0x9f, 0x5b, + 0x78, 0xea, 0x2f, 0xd6, 0x9c, 0x59, 0x3f, 0x6a, 0x5e, 0xc4, 0x8c, 0xe1, 0xce, 0x0c, 0x1c, 0x4b, + 0x3f, 0x96, 0x24, 0x7d, 0xde, 0x0f, 0xf5, 0x17, 0x6b, 0xce, 0xa8, 0x03, 0xa3, 0x2d, 0xbf, 0xdd, + 0xf0, 0x82, 0x99, 0x71, 0xd6, 0x87, 0xeb, 0x39, 0xf7, 0x61, 0x83, 0x11, 0xe7, 0x47, 0x18, 0xfc, + 0x37, 0x16, 0x0c, 0xd1, 0x33, 0x50, 0x72, 0x77, 0x9c, 0x28, 0x99, 0x99, 0x60, 0x93, 0x46, 0x59, + 0x9a, 0x8b, 0xb4, 0x11, 0x73, 0x18, 0x7a, 0x1a, 0x8a, 0x11, 0xa9, 0xb3, 0x38, 0x20, 0xc3, 0x43, + 0x8c, 0x49, 0x1d, 0xd3, 0x76, 0xfb, 0x6f, 0x17, 0xd2, 0xca, 0x45, 0xfa, 0xbd, 0xf9, 0x6c, 0x77, + 0xdb, 0x51, 0x2c, 0xad, 0x51, 0x63, 0xb6, 0xb3, 0x66, 0x2c, 0xe1, 0xe8, 0x4b, 0x16, 0x8c, 0xdd, + 0x8a, 0xc3, 0x20, 0x20, 0x89, 0x10, 0xe4, 0x37, 0x72, 0x1e, 0x8a, 0x2b, 0x9c, 0xba, 0xee, 0x83, + 0x68, 0xc0, 0x92, 0x2f, 0xed, 0x2e, 0xd9, 0x77, 0xfd, 0x76, 0xad, 0xcb, 0xd3, 0x78, 0x91, 0x37, + 0x63, 0x09, 0xa7, 0xa8, 0x5e, 0xc0, 0x51, 0x47, 0xd2, 0xa8, 0x2b, 0x81, 0x40, 0x15, 0x70, 0xfb, + 0xf7, 0x4a, 0x70, 0xa6, 0xe7, 0xe2, 0xa0, 0xdb, 0x3e, 0xdb, 0x58, 0x2f, 0x79, 0x3e, 0x91, 0x51, + 0xb2, 0x6c, 0xdb, 0xbf, 0xa1, 0x5a, 0xb1, 0x81, 0x81, 0x7e, 0x01, 0xa0, 0xe5, 0x44, 0x4e, 0x93, + 0x88, 0xed, 0xae, 0x78, 0xf4, 0xdd, 0x95, 0xf6, 0x63, 0x43, 0xd2, 0xd4, 0xd6, 0x96, 0x6a, 0x8a, + 0xb1, 0xc1, 0x12, 0x7d, 0x1c, 0xc6, 0x23, 0xe2, 0x13, 0x27, 0x66, 0x61, 0x64, 0xd9, 0x98, 0x58, + 0xac, 0x41, 0xd8, 0xc4, 0x43, 0xcf, 0xaa, 0xc8, 0x80, 0x91, 0xb4, 0xa7, 0x30, 0x1d, 0x1d, 0x80, + 0xde, 0xb1, 0x60, 0xaa, 0xee, 0xf9, 0x44, 0x73, 0x17, 0x11, 0xac, 0xeb, 0x47, 0x7f, 0xc9, 0x4b, + 0x26, 0x5d, 0x2d, 0x21, 0x53, 0xcd, 0x31, 0xce, 0xb0, 0xa7, 0x9f, 0x79, 0x8f, 0x44, 0x4c, 0xb4, + 0x8e, 0xa6, 0x3f, 0xf3, 0x0d, 0xde, 0x8c, 0x25, 0x1c, 0x2d, 0xc0, 0x89, 0x96, 0x13, 0xc7, 0x8b, + 0x11, 0xa9, 0x91, 0x20, 0xf1, 0x1c, 0x9f, 0xc7, 0x97, 0x96, 0x75, 0x7c, 0xd9, 0x46, 0x1a, 0x8c, + 0xb3, 0xf8, 0xe8, 0xd3, 0xf0, 0xb8, 0xd7, 0x08, 0xc2, 0x88, 0xac, 0x79, 0x71, 0xec, 0x05, 0x0d, + 0x3d, 0x0d, 0x98, 0xa4, 0x2c, 0x57, 0x67, 0x05, 0xa9, 0xc7, 0x57, 0x7a, 0xa3, 0xe1, 0x7e, 0xcf, + 0xa3, 0xe7, 0xa1, 0x1c, 0xef, 0x7a, 0xad, 0xc5, 0xa8, 0x16, 0xb3, 0xe3, 0xc4, 0xb2, 0x3e, 0x03, + 0xd9, 0x14, 0xed, 0x58, 0x61, 0xd8, 0xbf, 0x56, 0x48, 0x9b, 0x77, 0xe6, 0xfa, 0x41, 0x31, 0x5d, + 0x25, 0xc9, 0x0d, 0x27, 0x92, 0xa6, 0xff, 0x11, 0x23, 0x54, 0x05, 0xdd, 0x1b, 0x4e, 0x64, 0xae, + 0x37, 0xc6, 0x00, 0x4b, 0x4e, 0xe8, 0x16, 0x8c, 0x24, 0xbe, 0x93, 0x53, 0x48, 0xbb, 0xc1, 0x51, + 0x5b, 0xdb, 0xab, 0x0b, 0x31, 0x66, 0x3c, 0xd0, 0x53, 0x54, 0x7d, 0xdd, 0x96, 0x61, 0x2c, 0x42, + 0xe3, 0xdc, 0x8e, 0x31, 0x6b, 0xb5, 0xff, 0xfb, 0x68, 0x0f, 0x91, 0xa7, 0xf6, 0x18, 0x74, 0x01, + 0x80, 0x5a, 0x42, 0x1b, 0x11, 0xa9, 0x7b, 0xfb, 0x62, 0x8f, 0x57, 0xcb, 0xea, 0x9a, 0x82, 0x60, + 0x03, 0x4b, 0x3e, 0xb3, 0xd9, 0xae, 0xd3, 0x67, 0x0a, 0xdd, 0xcf, 0x70, 0x08, 0x36, 0xb0, 0xd0, + 0x4b, 0x30, 0xea, 0x35, 0x9d, 0x86, 0x8a, 0xb6, 0x79, 0x8a, 0xae, 0xa7, 0x15, 0xd6, 0x72, 0xf7, + 0x60, 0x76, 0x4a, 0x75, 0x88, 0x35, 0x61, 0x81, 0x8b, 0x7e, 0xdb, 0x82, 0x09, 0x37, 0x6c, 0x36, + 0xc3, 0x80, 0xdb, 0x0f, 0xc2, 0x18, 0xba, 0x75, 0x5c, 0x3b, 0xf0, 0xdc, 0xa2, 0xc1, 0x8c, 0x5b, + 0x43, 0x2a, 0xf6, 0xde, 0x04, 0xe1, 0x54, 0xaf, 0xcc, 0x65, 0x57, 0x3a, 0x64, 0xd9, 0xfd, 0x63, + 0x0b, 0xa6, 0xf9, 0xb3, 0x86, 0x59, 0x23, 0xc2, 0xcc, 0xc3, 0x63, 0x7e, 0xad, 0x2e, 0x4b, 0x4f, + 0x1d, 0x09, 0x75, 0xc1, 0x71, 0x77, 0x27, 0xd1, 0x32, 0x4c, 0xd7, 0xc3, 0xc8, 0x25, 0xe6, 0x40, + 0x08, 0x99, 0xa1, 0x08, 0x5d, 0xca, 0x22, 0xe0, 0xee, 0x67, 0xd0, 0x0d, 0x78, 0xcc, 0x68, 0x34, + 0xc7, 0x81, 0x8b, 0x8d, 0x73, 0x82, 0xda, 0x63, 0x97, 0x7a, 0x62, 0xe1, 0x3e, 0x4f, 0x9f, 0xfd, + 0x24, 0x4c, 0x77, 0x7d, 0xbf, 0xa1, 0x8c, 0xcd, 0x25, 0x78, 0xac, 0xf7, 0x48, 0x0d, 0x65, 0x72, + 0xfe, 0xc3, 0x4c, 0xb4, 0x8e, 0xa1, 0xd8, 0x0c, 0x70, 0x7c, 0xe1, 0x40, 0x91, 0x04, 0x7b, 0x42, + 0x70, 0x5c, 0x3a, 0xda, 0x8c, 0xb8, 0x18, 0xec, 0xf1, 0x0f, 0xcd, 0x6c, 0xb4, 0x8b, 0xc1, 0x1e, + 0xa6, 0xb4, 0xd1, 0xbb, 0x56, 0x6a, 0x63, 0xe6, 0x87, 0x1e, 0x9f, 0x39, 0x16, 0x4d, 0x6e, 0xe0, + 0xbd, 0xda, 0xfe, 0x5e, 0x01, 0xce, 0x1f, 0x46, 0x64, 0x80, 0xe1, 0x7b, 0x06, 0x46, 0x63, 0xe6, + 0x2e, 0x11, 0x2b, 0x71, 0x9c, 0xae, 0x42, 0xee, 0x40, 0xf9, 0x2c, 0x16, 0x20, 0xf4, 0xcb, 0x16, + 0x14, 0x9b, 0x4e, 0x4b, 0xbc, 0x79, 0xe3, 0x78, 0xdf, 0x7c, 0x6e, 0xcd, 0x69, 0xf1, 0xaf, 0xa0, + 0xf4, 0xd1, 0x35, 0xa7, 0x85, 0x69, 0x07, 0xd0, 0x2c, 0x94, 0x9c, 0x28, 0x72, 0x3a, 0x4c, 0xae, + 0x55, 0xb8, 0x5b, 0x6d, 0x81, 0x36, 0x60, 0xde, 0x7e, 0xf6, 0x13, 0x50, 0x96, 0x8f, 0x0f, 0x35, + 0x07, 0xbf, 0x3e, 0x96, 0x0a, 0x15, 0x65, 0xee, 0x96, 0x18, 0x46, 0x85, 0x01, 0x6c, 0xe5, 0x1d, + 0x9d, 0xcc, 0x63, 0xfd, 0x99, 0xd6, 0x2e, 0x32, 0xa6, 0x04, 0x2b, 0xf4, 0x35, 0x8b, 0xe5, 0x25, + 0xc9, 0xf0, 0x59, 0xa1, 0x2b, 0x1f, 0x4f, 0x9a, 0x94, 0x99, 0xed, 0x24, 0x1b, 0xb1, 0xc9, 0x9d, + 0x0a, 0xea, 0x16, 0x8f, 0xb0, 0xcf, 0x6a, 0xcc, 0x32, 0x73, 0x49, 0xc2, 0xd1, 0x7e, 0x0f, 0xb7, + 0x4a, 0x0e, 0xb9, 0x2d, 0x03, 0x38, 0x52, 0xbe, 0x63, 0xc1, 0x34, 0xd7, 0x8b, 0x96, 0xbc, 0x7a, + 0x9d, 0x44, 0x24, 0x70, 0x89, 0xd4, 0x2c, 0x8f, 0xe8, 0xb8, 0x93, 0xa7, 0x0e, 0x2b, 0x59, 0xf2, + 0x5a, 0x82, 0x77, 0x81, 0x70, 0x77, 0x67, 0x50, 0x0d, 0x46, 0xbc, 0xa0, 0x1e, 0x8a, 0x7d, 0xab, + 0x7a, 0xb4, 0x4e, 0xad, 0x04, 0xf5, 0x50, 0xaf, 0x65, 0xfa, 0x0f, 0x33, 0xea, 0x68, 0x15, 0x4e, + 0x47, 0xc2, 0xf6, 0xbf, 0xec, 0xc5, 0xd4, 0x42, 0x5b, 0xf5, 0x9a, 0x5e, 0xc2, 0xf6, 0x9c, 0x62, + 0x75, 0xe6, 0xce, 0xc1, 0xec, 0x69, 0xdc, 0x03, 0x8e, 0x7b, 0x3e, 0x85, 0xde, 0x86, 0x31, 0x99, + 0x48, 0x55, 0xce, 0x43, 0x4b, 0xef, 0x9e, 0xff, 0x6a, 0x32, 0x6d, 0x8a, 0x9c, 0x29, 0xc9, 0xd0, + 0xfe, 0xe7, 0x00, 0xdd, 0x6e, 0x17, 0xf4, 0xf3, 0x50, 0x89, 0x54, 0x72, 0x97, 0x95, 0x47, 0x58, + 0x8e, 0xfc, 0xbe, 0xc2, 0xe5, 0xa3, 0xce, 0xbd, 0x75, 0x1a, 0x97, 0xe6, 0x48, 0x75, 0xd4, 0x58, + 0x7b, 0x67, 0x72, 0x98, 0xdb, 0x82, 0xab, 0x3e, 0xd5, 0xef, 0x04, 0x2e, 0x66, 0x3c, 0x50, 0x04, + 0xa3, 0x3b, 0xc4, 0xf1, 0x93, 0x9d, 0x7c, 0x0e, 0x20, 0x2f, 0x33, 0x5a, 0xd9, 0xb8, 0x62, 0xde, + 0x8a, 0x05, 0x27, 0xb4, 0x0f, 0x63, 0x3b, 0x7c, 0x02, 0x08, 0xb5, 0x71, 0xed, 0xa8, 0x83, 0x9b, + 0x9a, 0x55, 0xfa, 0x73, 0x8b, 0x06, 0x2c, 0xd9, 0x31, 0x9f, 0xac, 0xe1, 0x71, 0xe4, 0x4b, 0x37, + 0xbf, 0x90, 0xea, 0xc1, 0xdd, 0x8d, 0x9f, 0x83, 0x89, 0x88, 0xb8, 0x61, 0xe0, 0x7a, 0x3e, 0xa9, + 0x2d, 0xc8, 0xc3, 0xc5, 0x61, 0x42, 0x75, 0x4f, 0x52, 0xd5, 0x17, 0x1b, 0x34, 0x70, 0x8a, 0x22, + 0xfa, 0xaa, 0x05, 0x53, 0x2a, 0x23, 0x84, 0x7e, 0x10, 0x22, 0x8e, 0xe7, 0x56, 0x73, 0xca, 0x3f, + 0x61, 0x34, 0xab, 0x88, 0x1a, 0xbf, 0xe9, 0x36, 0x9c, 0xe1, 0x8b, 0x5e, 0x07, 0x08, 0xb7, 0x99, + 0xfb, 0x8d, 0xbe, 0x6a, 0x79, 0xe8, 0x57, 0x9d, 0xe2, 0x11, 0xf9, 0x92, 0x02, 0x36, 0xa8, 0xa1, + 0xab, 0x00, 0x7c, 0xd9, 0x6c, 0x75, 0x5a, 0x84, 0x59, 0xa4, 0x3a, 0xd6, 0x1a, 0x36, 0x15, 0xe4, + 0xee, 0xc1, 0x6c, 0xf7, 0xd9, 0x09, 0x73, 0x8c, 0x1a, 0x8f, 0xa3, 0x9f, 0x83, 0xb1, 0xb8, 0xdd, + 0x6c, 0x3a, 0xea, 0x24, 0x2f, 0xc7, 0x18, 0x7f, 0x4e, 0xd7, 0x10, 0x45, 0xbc, 0x01, 0x4b, 0x8e, + 0xe8, 0x16, 0x15, 0xaa, 0xb1, 0x38, 0xd4, 0x61, 0xab, 0x88, 0xeb, 0x04, 0xe3, 0xec, 0x9d, 0x3e, + 0x21, 0x9e, 0x3b, 0x8d, 0x7b, 0xe0, 0xdc, 0x3d, 0x98, 0x7d, 0x2c, 0xdd, 0xbe, 0x1a, 0x8a, 0xa8, + 0xfb, 0x9e, 0x34, 0xd1, 0x15, 0x99, 0x57, 0x4d, 0x5f, 0x5b, 0xa6, 0xfb, 0x3d, 0xa7, 0xf3, 0xaa, + 0x59, 0x73, 0xff, 0x31, 0x33, 0x1f, 0xb6, 0x83, 0x74, 0x08, 0x89, 0x78, 0x9b, 0x97, 0x60, 0x82, + 0xec, 0x27, 0x24, 0x0a, 0x1c, 0xff, 0x3a, 0x5e, 0x95, 0x87, 0x52, 0x6c, 0xd2, 0x5e, 0x34, 0xda, + 0x71, 0x0a, 0x0b, 0xd9, 0xca, 0x18, 0x2d, 0xe8, 0xd4, 0x0f, 0x6e, 0x8c, 0x4a, 0xd3, 0xd3, 0xfe, + 0x3f, 0x85, 0x94, 0x06, 0xb5, 0x15, 0x11, 0x82, 0x42, 0x28, 0x05, 0x61, 0x4d, 0x09, 0xeb, 0x2b, + 0xf9, 0x08, 0xeb, 0x6b, 0x61, 0xcd, 0xc8, 0x96, 0xa6, 0xff, 0x62, 0xcc, 0xf9, 0xb0, 0x74, 0x52, + 0x99, 0x77, 0xcb, 0x00, 0xc2, 0x2e, 0xc8, 0x93, 0xb3, 0x4a, 0x27, 0x5d, 0x37, 0x19, 0xe1, 0x34, + 0x5f, 0xb4, 0x0b, 0xa5, 0x9d, 0x30, 0x4e, 0xa4, 0xb5, 0x70, 0x44, 0xc3, 0xe4, 0x72, 0x18, 0x27, + 0x6c, 0xdb, 0x57, 0xaf, 0x4d, 0x5b, 0x62, 0xcc, 0x79, 0xd8, 0xff, 0xd9, 0x4a, 0x1d, 0x41, 0xde, + 0x64, 0xe1, 0x54, 0x7b, 0x24, 0xa0, 0xeb, 0xd0, 0x8c, 0x3d, 0xf8, 0x4b, 0x99, 0x6c, 0x87, 0x0f, + 0xf7, 0xab, 0x5d, 0x71, 0x9b, 0x52, 0x98, 0x63, 0x24, 0x8c, 0x30, 0x85, 0x2f, 0x5a, 0xe9, 0xac, + 0x12, 0xbe, 0x11, 0xe6, 0x98, 0xe4, 0x74, 0x68, 0x82, 0x8a, 0xfd, 0xae, 0x05, 0x63, 0x55, 0xc7, + 0xdd, 0x0d, 0xeb, 0x75, 0xf4, 0x3c, 0x94, 0x6b, 0xed, 0xc8, 0x4c, 0x70, 0x51, 0x67, 0x5e, 0x4b, + 0xa2, 0x1d, 0x2b, 0x0c, 0x3a, 0x87, 0xeb, 0x8e, 0x2b, 0x53, 0x9d, 0x8a, 0x7c, 0x0e, 0x5f, 0x62, + 0x2d, 0x58, 0x40, 0xd0, 0xc7, 0x61, 0xbc, 0xe9, 0xec, 0xcb, 0x87, 0xb3, 0xe7, 0x9f, 0x6b, 0x1a, + 0x84, 0x4d, 0x3c, 0xfb, 0x5f, 0x5a, 0x30, 0x53, 0x75, 0x62, 0xcf, 0x5d, 0x68, 0x27, 0x3b, 0x55, + 0x2f, 0xd9, 0x6e, 0xbb, 0xbb, 0x24, 0xe1, 0xf9, 0x6d, 0xb4, 0x97, 0xed, 0x98, 0x2e, 0x25, 0x65, + 0x86, 0xa9, 0x5e, 0x5e, 0x17, 0xed, 0x58, 0x61, 0xa0, 0xb7, 0x61, 0xbc, 0xe5, 0xc4, 0xf1, 0xed, + 0x30, 0xaa, 0x61, 0x52, 0xcf, 0x27, 0xbb, 0x74, 0x93, 0xb8, 0x11, 0x49, 0x30, 0xa9, 0x0b, 0x8f, + 0x96, 0xa6, 0x8f, 0x4d, 0x66, 0xf6, 0xbf, 0xa8, 0xc0, 0x98, 0x70, 0xc7, 0x0d, 0x9c, 0xb5, 0x27, + 0x0d, 0xcc, 0x42, 0x5f, 0x03, 0x33, 0x86, 0x51, 0x97, 0xd5, 0x38, 0x11, 0x9a, 0xcc, 0xd5, 0x5c, + 0xfc, 0xb7, 0xbc, 0x6c, 0x8a, 0xee, 0x16, 0xff, 0x8f, 0x05, 0x2b, 0xf4, 0x2d, 0x0b, 0x4e, 0xb8, + 0x61, 0x10, 0x10, 0x57, 0x6f, 0xb3, 0x23, 0x79, 0x44, 0x64, 0x2c, 0xa6, 0x89, 0xea, 0xc3, 0xdf, + 0x0c, 0x00, 0x67, 0xd9, 0xa3, 0x57, 0x60, 0x92, 0x8f, 0xd9, 0x8d, 0xd4, 0xc9, 0x97, 0x4e, 0x4e, + 0x37, 0x81, 0x38, 0x8d, 0x8b, 0xe6, 0xf8, 0x09, 0xa2, 0x48, 0x03, 0x1f, 0xd5, 0x9e, 0x04, 0x23, + 0x01, 0xdc, 0xc0, 0x40, 0x11, 0xa0, 0x88, 0xd4, 0x23, 0x12, 0xef, 0x08, 0x77, 0x25, 0xdb, 0xe2, + 0xc7, 0xee, 0x2f, 0xf1, 0x08, 0x77, 0x51, 0xc2, 0x3d, 0xa8, 0xa3, 0x5d, 0x61, 0xe3, 0x94, 0xf3, + 0x90, 0x0a, 0xe2, 0x33, 0xf7, 0x35, 0x75, 0x66, 0xa1, 0x14, 0xef, 0x38, 0x51, 0x8d, 0xa9, 0x16, + 0x45, 0x7e, 0x10, 0xb0, 0x49, 0x1b, 0x30, 0x6f, 0x47, 0x4b, 0x70, 0x32, 0x93, 0x5a, 0x1f, 0x33, + 0xe5, 0xa1, 0xac, 0xe3, 0x50, 0x33, 0x49, 0xf9, 0x31, 0xee, 0x7a, 0xc2, 0xb4, 0x7f, 0xc7, 0x0f, + 0xb1, 0x7f, 0x3b, 0x2a, 0x28, 0x66, 0x82, 0x49, 0xfc, 0xd7, 0x72, 0x19, 0x80, 0x81, 0x22, 0x60, + 0xbe, 0x91, 0x89, 0x80, 0x99, 0x64, 0x1d, 0xb8, 0x91, 0x4f, 0x07, 0x86, 0x0f, 0x77, 0x79, 0x98, + 0xe1, 0x2b, 0xff, 0xdb, 0x02, 0xf9, 0x5d, 0x17, 0x1d, 0x77, 0x87, 0xd0, 0x29, 0x83, 0x5e, 0x85, + 0x29, 0x65, 0xc5, 0x2d, 0x86, 0xed, 0x80, 0x47, 0xae, 0x14, 0xb5, 0x97, 0x08, 0xa7, 0xa0, 0x38, + 0x83, 0x8d, 0xe6, 0xa1, 0x42, 0xc7, 0x89, 0x3f, 0xca, 0x77, 0x0f, 0x65, 0x29, 0x2e, 0x6c, 0xac, + 0x88, 0xa7, 0x34, 0x0e, 0x0a, 0x61, 0xda, 0x77, 0xe2, 0x84, 0xf5, 0x80, 0x1a, 0x75, 0xf7, 0x99, + 0xf6, 0xc7, 0x2a, 0x8b, 0xac, 0x66, 0x09, 0xe1, 0x6e, 0xda, 0xf6, 0x0f, 0x46, 0x60, 0x32, 0x25, + 0x19, 0x87, 0xdc, 0x76, 0x9e, 0x87, 0xb2, 0xdc, 0x09, 0xb2, 0x99, 0xc0, 0x6a, 0xbb, 0x50, 0x18, + 0x74, 0x9b, 0xdc, 0x26, 0x4e, 0x44, 0x22, 0x56, 0xb4, 0x20, 0xbb, 0x4d, 0x56, 0x35, 0x08, 0x9b, + 0x78, 0x4c, 0x28, 0x27, 0x7e, 0xbc, 0xe8, 0x7b, 0x24, 0x48, 0x78, 0x37, 0xf3, 0x11, 0xca, 0x5b, + 0xab, 0x9b, 0x26, 0x51, 0x2d, 0x94, 0x33, 0x00, 0x9c, 0x65, 0x8f, 0xbe, 0x62, 0xc1, 0xa4, 0x73, + 0x3b, 0xd6, 0x85, 0xb8, 0x44, 0xac, 0xcb, 0x11, 0x37, 0xa9, 0x54, 0x6d, 0xaf, 0xea, 0x34, 0x15, + 0xef, 0xa9, 0x26, 0x9c, 0x66, 0x8a, 0xbe, 0x6d, 0x01, 0x22, 0xfb, 0xc4, 0x95, 0xd1, 0x38, 0xa2, + 0x2f, 0xa3, 0x79, 0x18, 0x3b, 0x17, 0xbb, 0xe8, 0x72, 0xa9, 0xde, 0xdd, 0x8e, 0x7b, 0xf4, 0xc1, + 0xfe, 0x27, 0x45, 0xb5, 0xa0, 0x74, 0x00, 0x98, 0x63, 0x24, 0x2f, 0x58, 0xf7, 0x9f, 0xbc, 0xa0, + 0x5d, 0x94, 0x5d, 0x09, 0x0c, 0xe9, 0x58, 0xf1, 0xc2, 0x43, 0x8a, 0x15, 0xff, 0xb2, 0x95, 0xca, + 0x79, 0x1f, 0xbf, 0xf0, 0x7a, 0xbe, 0xc1, 0x67, 0x73, 0xdc, 0x41, 0x9e, 0x91, 0xee, 0x69, 0xaf, + 0x39, 0x95, 0xa6, 0x06, 0xda, 0x50, 0xd2, 0xf0, 0xdf, 0x17, 0x61, 0xdc, 0xd8, 0x49, 0x7b, 0xaa, + 0x45, 0xd6, 0x23, 0xa6, 0x16, 0x15, 0x86, 0x50, 0x8b, 0x7e, 0x01, 0x2a, 0xae, 0x94, 0xf2, 0xf9, + 0x54, 0x7d, 0xcb, 0xee, 0x1d, 0x5a, 0xd0, 0xab, 0x26, 0xac, 0x79, 0xa2, 0xe5, 0x54, 0x74, 0xba, + 0xd8, 0x21, 0x46, 0xd8, 0x0e, 0xd1, 0x2b, 0x7c, 0x5c, 0xec, 0x14, 0xdd, 0xcf, 0xa0, 0x17, 0xa9, + 0x65, 0xe5, 0x89, 0xf7, 0x92, 0x21, 0xa2, 0x4c, 0x5d, 0x5f, 0xd8, 0x58, 0x91, 0xcd, 0xd8, 0xc4, + 0xb1, 0x7f, 0x60, 0xa9, 0x8f, 0xfb, 0x00, 0xd2, 0x21, 0x6f, 0xa5, 0xd3, 0x21, 0x2f, 0xe6, 0x32, + 0xcc, 0x7d, 0xf2, 0x20, 0xaf, 0xc1, 0xd8, 0x62, 0xd8, 0x6c, 0x3a, 0x41, 0x0d, 0xfd, 0x04, 0x8c, + 0xb9, 0xfc, 0xa7, 0x38, 0xaa, 0x60, 0xfe, 0x29, 0x01, 0xc5, 0x12, 0x86, 0x9e, 0x82, 0x11, 0x27, + 0x6a, 0xc8, 0xe3, 0x09, 0xe6, 0xd2, 0x5f, 0x88, 0x1a, 0x31, 0x66, 0xad, 0xf6, 0x3b, 0x45, 0x80, + 0xc5, 0xb0, 0xd9, 0x72, 0x22, 0x52, 0xdb, 0x0a, 0x59, 0xd5, 0x99, 0x63, 0xf5, 0xeb, 0x68, 0x63, + 0xe9, 0x51, 0xf6, 0xed, 0x18, 0xe7, 0xfb, 0xc5, 0x07, 0x7d, 0xbe, 0xff, 0x75, 0x0b, 0x10, 0xfd, + 0x22, 0x61, 0x40, 0x82, 0x44, 0xbb, 0x2b, 0xe7, 0xa1, 0xe2, 0xca, 0x56, 0xa1, 0xb5, 0xe8, 0xf5, + 0x27, 0x01, 0x58, 0xe3, 0x0c, 0x60, 0x7e, 0x3e, 0x23, 0x85, 0x63, 0x31, 0x1d, 0x05, 0xc7, 0x44, + 0xaa, 0x90, 0x95, 0xf6, 0x1f, 0x14, 0xe0, 0x31, 0xbe, 0xdf, 0xad, 0x39, 0x81, 0xd3, 0x20, 0x4d, + 0xda, 0xab, 0x41, 0x1d, 0xd0, 0x2e, 0xb5, 0x7b, 0x3c, 0x19, 0xd5, 0x76, 0xd4, 0x85, 0xc1, 0x27, + 0x34, 0x9f, 0xc2, 0x2b, 0x81, 0x97, 0x60, 0x46, 0x1c, 0xc5, 0x50, 0x96, 0x35, 0x44, 0x85, 0xa0, + 0xcb, 0x89, 0x91, 0x5a, 0xf3, 0x62, 0x53, 0x22, 0x58, 0x31, 0xa2, 0x5a, 0xa1, 0x1f, 0xba, 0xbb, + 0x98, 0xb4, 0x42, 0x26, 0xd4, 0x8c, 0xa0, 0xa2, 0x55, 0xd1, 0x8e, 0x15, 0x86, 0xfd, 0x07, 0x16, + 0x64, 0xc5, 0xbd, 0x51, 0xb0, 0xc3, 0xba, 0x57, 0xc1, 0x8e, 0x61, 0x6a, 0x6a, 0xfc, 0x2c, 0x8c, + 0x3b, 0x09, 0xdd, 0xa1, 0xb9, 0x4d, 0x5b, 0xbc, 0xbf, 0x63, 0xeb, 0xb5, 0xb0, 0xe6, 0xd5, 0x3d, + 0x66, 0xcb, 0x9a, 0xe4, 0xec, 0xff, 0x39, 0x02, 0xd3, 0x5d, 0x91, 0xca, 0xe8, 0x65, 0x98, 0x70, + 0xc5, 0xf4, 0x68, 0x61, 0x52, 0x17, 0x2f, 0x63, 0x44, 0xba, 0x68, 0x18, 0x4e, 0x61, 0x0e, 0x30, + 0x41, 0x57, 0xe0, 0x54, 0x44, 0xad, 0xe8, 0x36, 0x59, 0xa8, 0x27, 0x24, 0xda, 0x24, 0x6e, 0x18, + 0xd4, 0x78, 0x59, 0x99, 0x62, 0xf5, 0xf1, 0x3b, 0x07, 0xb3, 0xa7, 0x70, 0x37, 0x18, 0xf7, 0x7a, + 0x06, 0xb5, 0x60, 0xd2, 0x37, 0x15, 0x2c, 0xa1, 0x5d, 0xdf, 0x97, 0x6e, 0xa6, 0x36, 0xe0, 0x54, + 0x33, 0x4e, 0x33, 0x48, 0x6b, 0x69, 0xa5, 0x87, 0xa4, 0xa5, 0xfd, 0xa2, 0xd6, 0xd2, 0xb8, 0x7f, + 0xf5, 0x8d, 0x9c, 0x23, 0xd5, 0x8f, 0x5b, 0x4d, 0x7b, 0x0d, 0xca, 0x32, 0xf2, 0x64, 0xa0, 0x88, + 0x0d, 0x93, 0x4e, 0x1f, 0x89, 0x76, 0xb7, 0x00, 0x3d, 0x34, 0x7c, 0xba, 0xce, 0xf4, 0x76, 0x9a, + 0x5a, 0x67, 0xc3, 0x6d, 0xa9, 0x68, 0x9f, 0x47, 0xdd, 0xf0, 0x8d, 0xe3, 0xd3, 0x79, 0x5b, 0x28, + 0x3a, 0x10, 0x47, 0x85, 0x80, 0xa8, 0x60, 0x9c, 0x0b, 0x00, 0x5a, 0x0b, 0x12, 0x01, 0xa7, 0xca, + 0xad, 0xa7, 0x95, 0x25, 0x6c, 0x60, 0x51, 0x83, 0xd5, 0x0b, 0xe2, 0xc4, 0xf1, 0xfd, 0xcb, 0x5e, + 0x90, 0x88, 0x93, 0x37, 0xb5, 0x43, 0xae, 0x68, 0x10, 0x36, 0xf1, 0xce, 0x7e, 0xc2, 0xf8, 0x2e, + 0xc3, 0x7c, 0xcf, 0x1d, 0x78, 0x62, 0xd9, 0x4b, 0x54, 0x98, 0xb4, 0x9a, 0x47, 0x54, 0xc9, 0x51, + 0x61, 0xff, 0x56, 0xdf, 0xb0, 0x7f, 0x23, 0x4c, 0xb9, 0x90, 0x8e, 0xaa, 0xce, 0x86, 0x29, 0xdb, + 0x2f, 0xc3, 0xe9, 0x65, 0x2f, 0xb9, 0xe4, 0xf9, 0x64, 0x48, 0x26, 0xf6, 0x57, 0x4a, 0x30, 0x61, + 0xa6, 0xa5, 0x0c, 0x93, 0xb9, 0xf0, 0x4d, 0xaa, 0xc7, 0x88, 0xb7, 0xf3, 0x94, 0x8f, 0xe5, 0xe6, + 0x91, 0x73, 0x64, 0x7a, 0x8f, 0x98, 0xa1, 0xca, 0x68, 0x9e, 0xd8, 0xec, 0x00, 0xba, 0x0d, 0xa5, + 0x3a, 0x0b, 0xa3, 0x2d, 0xe6, 0xe1, 0x39, 0xee, 0x35, 0xa2, 0x7a, 0x99, 0xf1, 0x40, 0x5c, 0xce, + 0x8f, 0xee, 0x90, 0x51, 0x3a, 0x37, 0x43, 0x09, 0x2a, 0x95, 0x95, 0xa1, 0x30, 0xfa, 0x89, 0xfa, + 0xd2, 0x7d, 0x88, 0xfa, 0x94, 0xe0, 0x1d, 0x7d, 0x48, 0x82, 0x97, 0x85, 0x44, 0x27, 0x3b, 0x4c, + 0x7f, 0x13, 0x01, 0xb1, 0x63, 0x6c, 0x10, 0x8c, 0x90, 0xe8, 0x14, 0x18, 0x67, 0xf1, 0xed, 0xaf, + 0x17, 0x60, 0x6a, 0x39, 0x68, 0x6f, 0x2c, 0x6f, 0xb4, 0xb7, 0x7d, 0xcf, 0xbd, 0x4a, 0x3a, 0x54, + 0xbe, 0xed, 0x92, 0xce, 0xca, 0x92, 0x98, 0x86, 0x6a, 0xe0, 0xaf, 0xd2, 0x46, 0xcc, 0x61, 0x74, + 0x45, 0xd7, 0xbd, 0xa0, 0x41, 0xa2, 0x56, 0xe4, 0x89, 0x43, 0x39, 0x63, 0x45, 0x5f, 0xd2, 0x20, + 0x6c, 0xe2, 0x51, 0xda, 0xe1, 0xed, 0x80, 0x44, 0x59, 0x6d, 0x70, 0x9d, 0x36, 0x62, 0x0e, 0xa3, + 0x48, 0x49, 0xd4, 0x8e, 0x13, 0xf1, 0x45, 0x15, 0xd2, 0x16, 0x6d, 0xc4, 0x1c, 0x46, 0x97, 0x4b, + 0xdc, 0xde, 0x66, 0xde, 0xed, 0x4c, 0x08, 0xeb, 0x26, 0x6f, 0xc6, 0x12, 0x4e, 0x51, 0x77, 0x49, + 0x67, 0x89, 0xda, 0x65, 0x99, 0x20, 0xf3, 0xab, 0xbc, 0x19, 0x4b, 0x38, 0xab, 0x74, 0x93, 0x1e, + 0x8e, 0x1f, 0xb9, 0x4a, 0x37, 0xe9, 0xee, 0xf7, 0xb1, 0xf0, 0x7e, 0xd3, 0x82, 0x09, 0x33, 0x26, + 0x05, 0x35, 0x32, 0x8a, 0xe2, 0x7a, 0x57, 0xd5, 0xb2, 0x9f, 0xee, 0x75, 0x5f, 0x42, 0xc3, 0x4b, + 0xc2, 0x56, 0xfc, 0x02, 0x09, 0x1a, 0x5e, 0x40, 0x98, 0xe7, 0x92, 0xc7, 0xb2, 0xa4, 0x02, 0x5e, + 0x16, 0xc3, 0x1a, 0xb9, 0x0f, 0x4d, 0xd3, 0xbe, 0x09, 0xd3, 0x5d, 0x99, 0x05, 0x03, 0xec, 0xcf, + 0x87, 0xe6, 0x75, 0xd9, 0x18, 0xc6, 0x29, 0xe1, 0xf5, 0x16, 0x0f, 0x3a, 0x59, 0x84, 0x69, 0xae, + 0x43, 0x50, 0x4e, 0x9b, 0xee, 0x0e, 0x69, 0xaa, 0x6c, 0x11, 0x76, 0x02, 0x7c, 0x23, 0x0b, 0xc4, + 0xdd, 0xf8, 0xf6, 0x37, 0x2c, 0x98, 0x4c, 0x25, 0x7b, 0xe4, 0xa4, 0x49, 0xb0, 0x95, 0x16, 0xb2, + 0x10, 0x29, 0x16, 0x25, 0x5a, 0x64, 0x3b, 0x92, 0x5e, 0x69, 0x1a, 0x84, 0x4d, 0x3c, 0xfb, 0xdd, + 0x02, 0x94, 0xa5, 0xd7, 0x7a, 0x80, 0xae, 0x7c, 0xcd, 0x82, 0x49, 0x75, 0xea, 0xce, 0x8e, 0x73, + 0xf8, 0x64, 0xbc, 0x76, 0x74, 0xbf, 0xb9, 0x8a, 0xe1, 0x0b, 0xea, 0xa1, 0x56, 0x6b, 0xb1, 0xc9, + 0x0c, 0xa7, 0x79, 0xa3, 0x1b, 0x00, 0x71, 0x27, 0x4e, 0x48, 0xd3, 0x38, 0x58, 0xb2, 0x8d, 0x15, + 0x37, 0xe7, 0x86, 0x11, 0xa1, 0xeb, 0xeb, 0x5a, 0x58, 0x23, 0x9b, 0x0a, 0x53, 0xeb, 0x21, 0xba, + 0x0d, 0x1b, 0x94, 0xec, 0xbf, 0x5f, 0x80, 0x93, 0xd9, 0x2e, 0xa1, 0x37, 0x60, 0x42, 0x72, 0x37, + 0xee, 0x7e, 0x90, 0xae, 0xfa, 0x09, 0x6c, 0xc0, 0xee, 0x1e, 0xcc, 0xce, 0x76, 0xdf, 0xbd, 0x31, + 0x67, 0xa2, 0xe0, 0x14, 0x31, 0xee, 0xfa, 0x10, 0x3e, 0xba, 0x6a, 0x67, 0xa1, 0xd5, 0x12, 0xfe, + 0x0b, 0xc3, 0xf5, 0x61, 0x42, 0x71, 0x06, 0x1b, 0x6d, 0xc0, 0x69, 0xa3, 0xe5, 0x1a, 0xf1, 0x1a, + 0x3b, 0xdb, 0x61, 0x24, 0xcd, 0x93, 0xa7, 0x74, 0xf4, 0x4b, 0x37, 0x0e, 0xee, 0xf9, 0x24, 0xdd, + 0x32, 0x5d, 0xa7, 0xe5, 0xb8, 0x5e, 0xd2, 0x11, 0x27, 0x65, 0x4a, 0x36, 0x2d, 0x8a, 0x76, 0xac, + 0x30, 0xec, 0x35, 0x18, 0x19, 0x70, 0x06, 0x0d, 0xa4, 0x16, 0xbf, 0x06, 0x65, 0x4a, 0x4e, 0xea, + 0x48, 0x79, 0x90, 0x0c, 0xa1, 0x2c, 0xcb, 0x37, 0x23, 0x1b, 0x8a, 0x9e, 0x23, 0xbd, 0x4b, 0xea, + 0xb5, 0x56, 0xe2, 0xb8, 0xcd, 0x2c, 0x4d, 0x0a, 0x44, 0xcf, 0x40, 0x91, 0xec, 0xb7, 0xb2, 0x6e, + 0xa4, 0x8b, 0xfb, 0x2d, 0x2f, 0x22, 0x31, 0x45, 0x22, 0xfb, 0x2d, 0x74, 0x16, 0x0a, 0x5e, 0x4d, + 0x6c, 0x52, 0x20, 0x70, 0x0a, 0x2b, 0x4b, 0xb8, 0xe0, 0xd5, 0xec, 0x7d, 0xa8, 0xa8, 0x7a, 0xd1, + 0x68, 0x57, 0xca, 0x6e, 0x2b, 0x8f, 0x30, 0x13, 0x49, 0xb7, 0x8f, 0xd4, 0x6e, 0x03, 0xe8, 0xd4, + 0x9a, 0xbc, 0xe4, 0xcb, 0x79, 0x18, 0x71, 0x43, 0x91, 0x91, 0x57, 0xd6, 0x64, 0x98, 0xd0, 0x66, + 0x10, 0xfb, 0x26, 0x4c, 0x5d, 0x0d, 0xc2, 0xdb, 0xac, 0x06, 0xe7, 0x25, 0x8f, 0xf8, 0x35, 0x4a, + 0xb8, 0x4e, 0x7f, 0x64, 0x55, 0x04, 0x06, 0xc5, 0x1c, 0xa6, 0xca, 0x6e, 0x14, 0xfa, 0x95, 0xdd, + 0xb0, 0xbf, 0x68, 0xc1, 0x49, 0x95, 0xf3, 0x21, 0xa5, 0xf1, 0xcb, 0x30, 0xb1, 0xdd, 0xf6, 0xfc, + 0x9a, 0xf8, 0x9f, 0xb5, 0xf5, 0xab, 0x06, 0x0c, 0xa7, 0x30, 0xa9, 0x65, 0xb2, 0xed, 0x05, 0x4e, + 0xd4, 0xd9, 0xd0, 0xe2, 0x5f, 0x49, 0x84, 0xaa, 0x82, 0x60, 0x03, 0xcb, 0xfe, 0x72, 0x01, 0x26, + 0x53, 0x19, 0xf0, 0xc8, 0x87, 0x32, 0xf1, 0xd9, 0x09, 0x94, 0xfc, 0xa8, 0x47, 0x2d, 0x3e, 0xa5, + 0x26, 0xe2, 0x45, 0x41, 0x17, 0x2b, 0x0e, 0x8f, 0x84, 0x9b, 0xc5, 0xfe, 0xc3, 0x22, 0xcc, 0xf0, + 0x83, 0xb7, 0x9a, 0x8a, 0x67, 0x58, 0x93, 0xda, 0xc9, 0x5f, 0xd5, 0xd5, 0x26, 0xf8, 0x70, 0x6c, + 0x1f, 0xb5, 0x7c, 0x62, 0x6f, 0x46, 0x03, 0x79, 0xda, 0x7f, 0x3d, 0xe3, 0x69, 0x2f, 0xe4, 0x91, + 0x10, 0xd1, 0xb7, 0x47, 0x3f, 0x5a, 0xae, 0xf7, 0xbf, 0x53, 0x80, 0x13, 0x99, 0xda, 0x94, 0xe8, + 0x9d, 0x74, 0xf5, 0x29, 0x2b, 0x8f, 0xe3, 0x99, 0x7b, 0x56, 0x48, 0x1c, 0xae, 0x06, 0xd5, 0xc3, + 0x9a, 0xf0, 0x7f, 0x54, 0x80, 0xa9, 0x74, 0x51, 0xcd, 0x47, 0x70, 0xa4, 0x3e, 0x0a, 0x15, 0x56, + 0xaa, 0x8e, 0xdd, 0xca, 0xc1, 0x4f, 0x81, 0x78, 0x45, 0x35, 0xd9, 0x88, 0x35, 0xfc, 0x91, 0x28, + 0xed, 0x65, 0xff, 0x5d, 0x0b, 0xce, 0xf0, 0xb7, 0xcc, 0xce, 0xc3, 0xbf, 0xd6, 0x6b, 0x74, 0xdf, + 0xcc, 0xb7, 0x83, 0x99, 0x2a, 0x29, 0x87, 0x8d, 0x2f, 0xbb, 0x0d, 0x40, 0xf4, 0x36, 0x3d, 0x15, + 0x1e, 0xc1, 0xce, 0x0e, 0x35, 0x19, 0xec, 0x3f, 0x2a, 0x82, 0xbe, 0x00, 0x01, 0x79, 0x22, 0x6d, + 0x22, 0x97, 0x6a, 0x31, 0x9b, 0x9d, 0xc0, 0xd5, 0x57, 0x2d, 0x94, 0x33, 0x59, 0x13, 0xbf, 0x62, + 0xc1, 0xb8, 0x17, 0x78, 0x89, 0xe7, 0x30, 0xa5, 0x33, 0x9f, 0x8a, 0xf0, 0x8a, 0xdd, 0x0a, 0xa7, + 0x1c, 0x46, 0xe6, 0xd1, 0xa1, 0x62, 0x86, 0x4d, 0xce, 0xe8, 0x73, 0x22, 0x18, 0xae, 0x98, 0x5b, + 0xc2, 0x4f, 0x39, 0x13, 0x01, 0xd7, 0x82, 0x52, 0x44, 0x92, 0x48, 0xa6, 0x5a, 0x5d, 0x3d, 0x6a, + 0x84, 0x73, 0x12, 0x75, 0x54, 0x71, 0x30, 0x7d, 0x15, 0x15, 0x6d, 0xc6, 0x9c, 0x91, 0x1d, 0x03, + 0xea, 0x1e, 0x8b, 0x21, 0x03, 0x8d, 0xe6, 0xa1, 0xe2, 0xb4, 0x93, 0xb0, 0x49, 0x87, 0x49, 0x9c, + 0x6e, 0xea, 0x50, 0x2a, 0x09, 0xc0, 0x1a, 0xc7, 0x7e, 0xa7, 0x04, 0x99, 0x3c, 0x06, 0xb4, 0x6f, + 0x5e, 0xde, 0x61, 0xe5, 0x7b, 0x79, 0x87, 0xea, 0x4c, 0xaf, 0x0b, 0x3c, 0x50, 0x03, 0x4a, 0xad, + 0x1d, 0x27, 0x96, 0x3a, 0xe5, 0x6b, 0x72, 0x98, 0x36, 0x68, 0xe3, 0xdd, 0x83, 0xd9, 0x9f, 0x19, + 0xec, 0x8c, 0x82, 0xce, 0xd5, 0x79, 0x9e, 0x2f, 0xac, 0x59, 0x33, 0x1a, 0x98, 0xd3, 0x1f, 0xa6, + 0x26, 0xfe, 0x97, 0x44, 0x3d, 0x43, 0x4c, 0xe2, 0xb6, 0x9f, 0x88, 0xd9, 0xf0, 0x5a, 0x8e, 0xab, + 0x8c, 0x13, 0xd6, 0x19, 0x78, 0xfc, 0x3f, 0x36, 0x98, 0xa2, 0x37, 0xa0, 0x12, 0x27, 0x4e, 0x94, + 0xdc, 0x67, 0xce, 0x8c, 0x1a, 0xf4, 0x4d, 0x49, 0x04, 0x6b, 0x7a, 0xe8, 0x75, 0x56, 0x3c, 0xcb, + 0x8b, 0x77, 0xee, 0x33, 0x86, 0x55, 0x16, 0xda, 0x12, 0x14, 0xb0, 0x41, 0x8d, 0xaa, 0xec, 0x6c, + 0x6e, 0xf3, 0xc0, 0x8d, 0x32, 0xb3, 0xc9, 0x94, 0x28, 0xc4, 0x0a, 0x82, 0x0d, 0x2c, 0xfb, 0x0b, + 0x70, 0x2a, 0x7b, 0xdb, 0x97, 0x38, 0xb6, 0x6c, 0x44, 0x61, 0xbb, 0x95, 0xb5, 0x49, 0xd8, 0x6d, + 0x50, 0x98, 0xc3, 0xa8, 0x4d, 0xb2, 0xeb, 0x05, 0xb5, 0xac, 0x4d, 0x72, 0xd5, 0x0b, 0x6a, 0x98, + 0x41, 0x06, 0xb8, 0xd5, 0xe4, 0x9f, 0x5a, 0x70, 0xfe, 0xb0, 0x4b, 0xc9, 0xd0, 0x53, 0x30, 0x72, + 0xdb, 0x89, 0x64, 0x31, 0x3e, 0x26, 0x3b, 0x6e, 0x3a, 0x51, 0x80, 0x59, 0x2b, 0xea, 0xc0, 0x28, + 0xcf, 0x51, 0x14, 0x0a, 0xec, 0x6b, 0xf9, 0x5e, 0x91, 0x76, 0x95, 0x18, 0x1a, 0x34, 0xcf, 0x8f, + 0xc4, 0x82, 0xa1, 0xfd, 0xbe, 0x05, 0x68, 0x7d, 0x8f, 0x44, 0x91, 0x57, 0x33, 0xb2, 0x2a, 0xd1, + 0x4b, 0x30, 0x71, 0x6b, 0x73, 0xfd, 0xda, 0x46, 0xe8, 0x05, 0x2c, 0xc7, 0xda, 0xc8, 0x4b, 0xb9, + 0x62, 0xb4, 0xe3, 0x14, 0x16, 0x5a, 0x84, 0xe9, 0x5b, 0x6f, 0x51, 0x3b, 0xca, 0xac, 0x63, 0x5b, + 0xd0, 0x27, 0x67, 0x57, 0x5e, 0xcb, 0x00, 0x71, 0x37, 0x3e, 0x5a, 0x87, 0x33, 0x4d, 0xae, 0x81, + 0x33, 0xf3, 0x31, 0xe6, 0xea, 0x78, 0x24, 0x0b, 0x2f, 0x3c, 0x71, 0xe7, 0x60, 0xf6, 0xcc, 0x5a, + 0x2f, 0x04, 0xdc, 0xfb, 0x39, 0xfb, 0xbb, 0x05, 0x18, 0x37, 0x2e, 0xf6, 0x1b, 0xc0, 0x50, 0xce, + 0xdc, 0x45, 0x58, 0x18, 0xf0, 0x2e, 0xc2, 0xe7, 0xa0, 0xdc, 0x0a, 0x7d, 0xcf, 0xf5, 0x54, 0x95, + 0x08, 0x56, 0xcc, 0x6c, 0x43, 0xb4, 0x61, 0x05, 0x45, 0xb7, 0xa1, 0xa2, 0x2e, 0xbb, 0x12, 0xc9, + 0x7d, 0x79, 0x1d, 0x15, 0xa8, 0xc5, 0xab, 0x2f, 0xb1, 0xd2, 0xbc, 0x90, 0x0d, 0xa3, 0x6c, 0xe6, + 0xcb, 0x90, 0x26, 0x96, 0x75, 0xc1, 0x96, 0x44, 0x8c, 0x05, 0xc4, 0xfe, 0xa5, 0x31, 0x38, 0xdd, + 0xab, 0x00, 0x17, 0xfa, 0x3c, 0x8c, 0xf2, 0x3e, 0xe6, 0x53, 0xe3, 0xb1, 0x17, 0x8f, 0x65, 0x46, + 0x50, 0x74, 0x8b, 0xfd, 0xc6, 0x82, 0xa7, 0xe0, 0xee, 0x3b, 0xdb, 0x42, 0x8d, 0x38, 0x1e, 0xee, + 0xab, 0x8e, 0xe6, 0xbe, 0xea, 0x70, 0xee, 0xbe, 0xb3, 0x8d, 0xf6, 0xa1, 0xd4, 0xf0, 0x12, 0xe2, + 0x08, 0x65, 0xfa, 0xe6, 0xb1, 0x30, 0x27, 0x0e, 0x8f, 0x9c, 0x67, 0x3f, 0x31, 0x67, 0x88, 0xbe, + 0x63, 0xc1, 0x89, 0xed, 0x74, 0x12, 0x8b, 0xd8, 0x55, 0x9c, 0x63, 0x28, 0xb2, 0x96, 0x66, 0x54, + 0x3d, 0x75, 0xe7, 0x60, 0xf6, 0x44, 0xa6, 0x11, 0x67, 0xbb, 0x83, 0x7e, 0xd1, 0x82, 0xb1, 0xba, + 0xe7, 0x1b, 0x15, 0x84, 0x8e, 0xe1, 0xe3, 0x5c, 0x62, 0x0c, 0xf4, 0xce, 0xcb, 0xff, 0xc7, 0x58, + 0x72, 0xee, 0xe7, 0xce, 0x1b, 0x3d, 0xaa, 0x3b, 0x6f, 0xec, 0x21, 0x99, 0x4f, 0x7f, 0xbd, 0x00, + 0xcf, 0x0c, 0xf0, 0x8d, 0xcc, 0xa4, 0x08, 0xeb, 0x90, 0xa4, 0x88, 0xf3, 0x30, 0x12, 0x91, 0x56, + 0x98, 0xdd, 0xef, 0x58, 0xe4, 0x10, 0x83, 0xa0, 0xa7, 0xa1, 0xe8, 0xb4, 0x3c, 0xb1, 0xdd, 0x29, + 0x6f, 0xff, 0xc2, 0xc6, 0x0a, 0xa6, 0xed, 0xf4, 0x4b, 0x57, 0xb6, 0x65, 0x6a, 0x55, 0x3e, 0xc5, + 0x9a, 0xfb, 0x65, 0x6a, 0x71, 0x83, 0x46, 0x41, 0xb1, 0xe6, 0x6b, 0xaf, 0xc3, 0xd9, 0xfe, 0x33, + 0x04, 0xbd, 0x08, 0xe3, 0xdb, 0x91, 0x13, 0xb8, 0x3b, 0xac, 0xb0, 0xb9, 0x1c, 0x13, 0x16, 0x0a, + 0xaf, 0x9b, 0xb1, 0x89, 0x63, 0xff, 0x61, 0xa1, 0x37, 0x45, 0x2e, 0x04, 0x86, 0x19, 0x61, 0x31, + 0x7e, 0x85, 0x3e, 0xe3, 0xf7, 0x16, 0x94, 0x13, 0x16, 0x89, 0x4f, 0xea, 0x42, 0x92, 0xe4, 0x96, + 0x4c, 0xc6, 0xf6, 0x9a, 0x2d, 0x41, 0x1c, 0x2b, 0x36, 0x54, 0xe4, 0xfb, 0xba, 0xf8, 0x90, 0x10, + 0xf9, 0x99, 0x73, 0xb4, 0x25, 0x38, 0x69, 0xd4, 0x52, 0xe4, 0x81, 0xc8, 0xdc, 0x8d, 0xaa, 0xb2, + 0x73, 0x36, 0x32, 0x70, 0xdc, 0xf5, 0x84, 0xfd, 0x9b, 0x05, 0x78, 0xa2, 0xaf, 0x64, 0xd3, 0xbe, + 0x5e, 0xeb, 0x1e, 0xbe, 0xde, 0x23, 0x4f, 0x50, 0x73, 0x80, 0x47, 0x1e, 0xcc, 0x00, 0x3f, 0x0f, + 0x65, 0x2f, 0x88, 0x89, 0xdb, 0x8e, 0xf8, 0xa0, 0x19, 0x61, 0x79, 0x2b, 0xa2, 0x1d, 0x2b, 0x0c, + 0xfb, 0x8f, 0xfb, 0x4f, 0x35, 0xba, 0xcb, 0xfd, 0xd8, 0x8e, 0xd2, 0x2b, 0x30, 0xe9, 0xb4, 0x5a, + 0x1c, 0x8f, 0xf9, 0xd5, 0x32, 0xf9, 0x76, 0x0b, 0x26, 0x10, 0xa7, 0x71, 0x8d, 0x39, 0x3c, 0xda, + 0x6f, 0x0e, 0xdb, 0x7f, 0x66, 0x41, 0x05, 0x93, 0x3a, 0xaf, 0xc1, 0x89, 0x6e, 0x89, 0x21, 0xb2, + 0xf2, 0x28, 0x0e, 0xc1, 0xae, 0xcc, 0xf6, 0x58, 0xd1, 0x84, 0x5e, 0x83, 0xdd, 0x5d, 0x17, 0xb4, + 0x30, 0x54, 0x5d, 0x50, 0x55, 0x19, 0xb2, 0xd8, 0xbf, 0x32, 0xa4, 0xfd, 0xc3, 0x51, 0xfa, 0x7a, + 0xad, 0x70, 0x31, 0x22, 0xb5, 0x98, 0x7e, 0xdf, 0x76, 0xe4, 0x67, 0x6f, 0x12, 0xbc, 0x8e, 0x57, + 0x31, 0x6d, 0x4f, 0x1d, 0x02, 0x14, 0x86, 0xca, 0x36, 0x2a, 0x1e, 0x9a, 0x6d, 0xf4, 0x0a, 0x4c, + 0xc6, 0xf1, 0xce, 0x46, 0xe4, 0xed, 0x39, 0x09, 0x35, 0x2d, 0x44, 0x58, 0x86, 0xce, 0x10, 0xd8, + 0xbc, 0xac, 0x81, 0x38, 0x8d, 0x8b, 0x96, 0x61, 0x5a, 0xe7, 0xfc, 0x90, 0x28, 0x61, 0x51, 0x18, + 0x7c, 0x26, 0xa8, 0x00, 0x7d, 0x9d, 0x25, 0x24, 0x10, 0x70, 0xf7, 0x33, 0x54, 0x62, 0xa5, 0x1a, + 0x69, 0x47, 0x46, 0xd3, 0x12, 0x2b, 0x45, 0x87, 0xf6, 0xa5, 0xeb, 0x09, 0xb4, 0x06, 0xa7, 0xf8, + 0xc4, 0x60, 0x57, 0xd7, 0xaa, 0x37, 0xe2, 0x51, 0x33, 0x4f, 0x0a, 0x42, 0xa7, 0x96, 0xbb, 0x51, + 0x70, 0xaf, 0xe7, 0xa8, 0xdd, 0xa0, 0x9a, 0x57, 0x96, 0x84, 0xfd, 0xaa, 0xec, 0x06, 0x45, 0x66, + 0xa5, 0x86, 0x4d, 0x3c, 0xf4, 0x69, 0x78, 0x5c, 0xff, 0xe5, 0xf1, 0x6e, 0xfc, 0x50, 0x67, 0x49, + 0xa4, 0x53, 0xaa, 0x3a, 0x84, 0xcb, 0x3d, 0xd1, 0x6a, 0xb8, 0xdf, 0xf3, 0x68, 0x1b, 0xce, 0x2a, + 0xd0, 0x45, 0x6a, 0xa4, 0xb5, 0x22, 0x2f, 0x26, 0x55, 0x27, 0x26, 0xd7, 0x23, 0x9f, 0x25, 0x60, + 0x56, 0x74, 0x41, 0xf5, 0x65, 0x2f, 0xb9, 0xdc, 0x0b, 0x13, 0xaf, 0xe2, 0x7b, 0x50, 0x41, 0xf3, + 0x50, 0x21, 0x81, 0xb3, 0xed, 0x93, 0xf5, 0xc5, 0x15, 0x96, 0x96, 0x69, 0x9c, 0x21, 0x5d, 0x94, + 0x00, 0xac, 0x71, 0x94, 0x27, 0x70, 0xa2, 0x6f, 0x01, 0xfe, 0x0d, 0x38, 0xdd, 0x70, 0x5b, 0x54, + 0x0f, 0xf0, 0x5c, 0xb2, 0xe0, 0xba, 0xd4, 0xd0, 0xa7, 0x1f, 0x86, 0xd7, 0x45, 0x55, 0x6e, 0xee, + 0xe5, 0xc5, 0x8d, 0x2e, 0x1c, 0xdc, 0xf3, 0x49, 0xba, 0xc6, 0x5a, 0x51, 0xb8, 0xdf, 0x99, 0x39, + 0x95, 0x5e, 0x63, 0x1b, 0xb4, 0x11, 0x73, 0x98, 0xfd, 0xa7, 0x16, 0x4c, 0xaa, 0x35, 0xf6, 0x00, + 0x22, 0x7d, 0xfc, 0x74, 0xa4, 0xcf, 0xf2, 0xd1, 0xa5, 0x14, 0xeb, 0x79, 0x1f, 0x77, 0xf1, 0xef, + 0x03, 0x80, 0x96, 0x64, 0x6a, 0x13, 0xb1, 0xfa, 0x6e, 0x22, 0x8f, 0xac, 0x14, 0xe9, 0x95, 0x37, + 0x55, 0x7a, 0xb8, 0x79, 0x53, 0x9b, 0x70, 0x46, 0x6e, 0xf1, 0xfc, 0x18, 0xe5, 0x72, 0x18, 0x2b, + 0xa1, 0x54, 0xae, 0x3e, 0x2d, 0x08, 0x9d, 0x59, 0xe9, 0x85, 0x84, 0x7b, 0x3f, 0x9b, 0xd2, 0x2c, + 0xc6, 0x0e, 0xd3, 0x2c, 0xf4, 0x3a, 0x5c, 0xad, 0xcb, 0x4a, 0x84, 0x99, 0x75, 0xb8, 0x7a, 0x69, + 0x13, 0x6b, 0x9c, 0xde, 0xc2, 0xb8, 0x92, 0x93, 0x30, 0x86, 0xa1, 0x85, 0xb1, 0x14, 0x0b, 0xe3, + 0x7d, 0xc5, 0x82, 0x3c, 0xb9, 0x99, 0xe8, 0x7b, 0x72, 0xf3, 0x2a, 0x4c, 0x79, 0xc1, 0x0e, 0x89, + 0xbc, 0x84, 0xd4, 0xd8, 0x5a, 0x10, 0x57, 0xaa, 0xab, 0xad, 0x78, 0x25, 0x05, 0xc5, 0x19, 0xec, + 0xb4, 0x2c, 0x9b, 0x1a, 0x40, 0x96, 0xf5, 0xd9, 0x41, 0x4e, 0xe4, 0xb3, 0x83, 0x9c, 0x3c, 0xfa, + 0x0e, 0x32, 0x7d, 0xac, 0x3b, 0x08, 0xca, 0x65, 0x07, 0x19, 0x44, 0x38, 0x9b, 0x46, 0xd8, 0xe9, + 0x43, 0x8c, 0xb0, 0x7e, 0xdb, 0xc7, 0x99, 0xfb, 0xdd, 0x3e, 0xec, 0xaf, 0x16, 0xe0, 0x8c, 0x96, + 0x9d, 0x74, 0xc6, 0x7a, 0x75, 0x2a, 0x3d, 0x58, 0x01, 0x5a, 0x1e, 0xf6, 0x61, 0x04, 0x8b, 0xe9, + 0xb8, 0x33, 0x05, 0xc1, 0x06, 0x16, 0x8b, 0xb9, 0x22, 0x11, 0x2b, 0xe5, 0x92, 0x15, 0xac, 0x8b, + 0xa2, 0x1d, 0x2b, 0x0c, 0x3a, 0x27, 0xe8, 0x6f, 0x11, 0xc7, 0x9a, 0x4d, 0xef, 0x5e, 0xd4, 0x20, + 0x6c, 0xe2, 0xa1, 0xe7, 0x38, 0x13, 0xb6, 0xa8, 0xa9, 0x70, 0x9d, 0x10, 0x57, 0x2b, 0xc8, 0x75, + 0xac, 0xa0, 0xb2, 0x3b, 0x2c, 0xb8, 0xae, 0xd4, 0xdd, 0x1d, 0xe6, 0xe4, 0x52, 0x18, 0xf6, 0xff, + 0xb2, 0xe0, 0x89, 0x9e, 0x43, 0xf1, 0x00, 0x36, 0xcc, 0xfd, 0xf4, 0x86, 0xb9, 0x99, 0x97, 0x5a, + 0x6f, 0xbc, 0x45, 0x9f, 0xcd, 0xf3, 0xdf, 0x59, 0x30, 0xa5, 0xf1, 0x1f, 0xc0, 0xab, 0x7a, 0xe9, + 0x57, 0xcd, 0xcf, 0x82, 0xa9, 0x74, 0xbd, 0xdb, 0x9f, 0xb2, 0x77, 0xe3, 0xbe, 0x82, 0x05, 0x57, + 0xde, 0x80, 0x7f, 0xc8, 0x19, 0x79, 0x07, 0x46, 0x59, 0xf5, 0xd3, 0x38, 0x1f, 0x9f, 0x45, 0x9a, + 0x3f, 0x8b, 0x9a, 0xd5, 0x3e, 0x0b, 0xf6, 0x37, 0xc6, 0x82, 0x21, 0x2b, 0x34, 0xe4, 0xc5, 0x54, + 0x02, 0xd7, 0x44, 0x98, 0x9a, 0x2e, 0x34, 0x24, 0xda, 0xb1, 0xc2, 0xb0, 0x9b, 0x30, 0x93, 0x26, + 0xbe, 0x44, 0xea, 0xcc, 0x35, 0x3c, 0xd0, 0x6b, 0xce, 0x43, 0xc5, 0x61, 0x4f, 0xad, 0xb6, 0x9d, + 0xec, 0x6d, 0x3c, 0x0b, 0x12, 0x80, 0x35, 0x8e, 0xfd, 0xbb, 0x16, 0x9c, 0xea, 0xf1, 0x32, 0x39, + 0x86, 0xe7, 0x25, 0x5a, 0x0a, 0xf4, 0xda, 0x24, 0x3f, 0x02, 0x63, 0x35, 0x52, 0x77, 0xa4, 0xf3, + 0xd1, 0x90, 0x93, 0x4b, 0xbc, 0x19, 0x4b, 0xb8, 0xfd, 0xdf, 0x2c, 0x38, 0x91, 0xee, 0x6b, 0x8c, + 0xae, 0x00, 0xe2, 0x2f, 0xb3, 0xe4, 0xc5, 0x6e, 0xb8, 0x47, 0xa2, 0x0e, 0x7d, 0x73, 0xde, 0xeb, + 0xb3, 0x82, 0x12, 0x5a, 0xe8, 0xc2, 0xc0, 0x3d, 0x9e, 0x62, 0x85, 0x50, 0x6a, 0x6a, 0xb4, 0xe5, + 0x4c, 0xb9, 0x91, 0xe7, 0x4c, 0xd1, 0x1f, 0xd3, 0x74, 0xd0, 0x28, 0x96, 0xd8, 0xe4, 0x6f, 0xbf, + 0x3f, 0x02, 0x2a, 0x7e, 0x97, 0xb9, 0xb9, 0x72, 0x72, 0x12, 0xa6, 0xae, 0x6c, 0x2a, 0x0e, 0x70, + 0x65, 0x93, 0x9c, 0x0c, 0x23, 0xf7, 0x72, 0x41, 0xf1, 0x53, 0x02, 0xf3, 0x30, 0x4e, 0xbd, 0xe1, + 0x96, 0x06, 0x61, 0x13, 0x8f, 0xf6, 0xc4, 0xf7, 0xf6, 0x08, 0x7f, 0x68, 0x34, 0xdd, 0x93, 0x55, + 0x09, 0xc0, 0x1a, 0x87, 0xf6, 0xa4, 0xe6, 0xd5, 0xeb, 0xc2, 0xe4, 0x55, 0x3d, 0xa1, 0xa3, 0x83, + 0x19, 0x84, 0x62, 0xec, 0x84, 0xe1, 0xae, 0xd0, 0x28, 0x15, 0xc6, 0xe5, 0x30, 0xdc, 0xc5, 0x0c, + 0x42, 0x75, 0xa0, 0x20, 0x8c, 0x9a, 0xec, 0xb6, 0xa4, 0x9a, 0xe2, 0x22, 0x34, 0x49, 0xa5, 0x03, + 0x5d, 0xeb, 0x46, 0xc1, 0xbd, 0x9e, 0xa3, 0x33, 0xb0, 0x15, 0x91, 0x9a, 0xe7, 0x26, 0x26, 0x35, + 0x48, 0xcf, 0xc0, 0x8d, 0x2e, 0x0c, 0xdc, 0xe3, 0x29, 0xb4, 0x00, 0x27, 0x64, 0xfc, 0xb5, 0x4c, + 0x51, 0x1b, 0x4f, 0xa7, 0xc4, 0xe0, 0x34, 0x18, 0x67, 0xf1, 0xa9, 0xb4, 0x69, 0x8a, 0xec, 0x54, + 0xa6, 0x78, 0x1a, 0xd2, 0x46, 0x66, 0xad, 0x62, 0x85, 0x61, 0x7f, 0xa9, 0x48, 0x77, 0xc7, 0x3e, + 0x55, 0x6a, 0x1f, 0x98, 0x53, 0x3a, 0x3d, 0x23, 0x47, 0x06, 0x98, 0x91, 0x2f, 0xc1, 0xc4, 0xad, + 0x38, 0x0c, 0x94, 0xc3, 0xb7, 0xd4, 0xd7, 0xe1, 0x6b, 0x60, 0xf5, 0x76, 0xf8, 0x8e, 0xe6, 0xe5, + 0xf0, 0x1d, 0xbb, 0x4f, 0x87, 0xef, 0xf7, 0x4a, 0xa0, 0xea, 0x3c, 0x5e, 0x23, 0xc9, 0xed, 0x30, + 0xda, 0xf5, 0x82, 0x06, 0x8b, 0x5b, 0xff, 0x8e, 0x05, 0x13, 0x7c, 0xbd, 0xac, 0x9a, 0x31, 0xac, + 0xf5, 0x9c, 0xea, 0x11, 0xa6, 0x98, 0xcd, 0x6d, 0x19, 0x8c, 0x32, 0xc5, 0xf8, 0x4d, 0x10, 0x4e, + 0xf5, 0x08, 0xfd, 0x3c, 0x80, 0x3c, 0x1f, 0xac, 0x4b, 0x91, 0xb9, 0x92, 0x4f, 0xff, 0x30, 0xa9, + 0x6b, 0xdd, 0x74, 0x4b, 0x31, 0xc1, 0x06, 0x43, 0xf4, 0xd5, 0xec, 0x6d, 0x72, 0x9f, 0x3b, 0x96, + 0xb1, 0x19, 0x24, 0xba, 0x17, 0xc3, 0x98, 0x17, 0x34, 0xe8, 0x3c, 0x11, 0x3e, 0xf2, 0x0f, 0xf7, + 0xca, 0xf9, 0x58, 0x0d, 0x9d, 0x5a, 0xd5, 0xf1, 0x9d, 0xc0, 0x25, 0xd1, 0x0a, 0x47, 0x37, 0x6f, + 0x87, 0x61, 0x0d, 0x58, 0x12, 0xea, 0x2a, 0xb8, 0x59, 0x1a, 0xa4, 0xe0, 0xe6, 0xd9, 0x4f, 0xc2, + 0x74, 0xd7, 0xc7, 0x1c, 0x2a, 0x98, 0xf7, 0xfe, 0xe3, 0x80, 0xed, 0x7f, 0x36, 0xaa, 0x37, 0xad, + 0x6b, 0x61, 0x8d, 0x97, 0x7d, 0x8c, 0xf4, 0x17, 0x15, 0xba, 0x67, 0x8e, 0x53, 0xc4, 0xb8, 0x61, + 0x46, 0x35, 0x62, 0x93, 0x25, 0x9d, 0xa3, 0x2d, 0x27, 0x22, 0xc1, 0x71, 0xcf, 0xd1, 0x0d, 0xc5, + 0x04, 0x1b, 0x0c, 0xd1, 0x4e, 0x2a, 0x9a, 0xef, 0xd2, 0xd1, 0xa3, 0xf9, 0x58, 0x4a, 0x69, 0xaf, + 0xba, 0x76, 0xdf, 0xb2, 0x60, 0x2a, 0x48, 0xcd, 0x5c, 0xe1, 0x2f, 0xd9, 0x3a, 0x8e, 0x55, 0xc1, + 0xcb, 0x04, 0xa7, 0xdb, 0x70, 0x86, 0x7f, 0xaf, 0x2d, 0xad, 0x34, 0xe4, 0x96, 0xa6, 0xeb, 0xc7, + 0x8e, 0xf6, 0xab, 0x1f, 0x8b, 0x02, 0x55, 0xf1, 0x7a, 0x2c, 0xf7, 0x8a, 0xd7, 0xd0, 0xa3, 0xda, + 0xf5, 0x4d, 0xa8, 0xb8, 0x11, 0x71, 0x92, 0xfb, 0x2c, 0x7e, 0xcc, 0x9c, 0xc5, 0x8b, 0x92, 0x00, + 0xd6, 0xb4, 0xec, 0x7f, 0x5b, 0x84, 0x93, 0x72, 0x44, 0x64, 0xa4, 0x13, 0xdd, 0x1f, 0x39, 0x5f, + 0xad, 0xdc, 0xaa, 0xfd, 0xf1, 0xb2, 0x04, 0x60, 0x8d, 0x43, 0xf5, 0xb1, 0x76, 0x4c, 0xd6, 0x5b, + 0x24, 0x58, 0xf5, 0xb6, 0x63, 0xe1, 0xe7, 0x53, 0x0b, 0xe5, 0xba, 0x06, 0x61, 0x13, 0x8f, 0x2a, + 0xe3, 0x5c, 0x2f, 0x8e, 0xb3, 0x81, 0x83, 0x42, 0xdf, 0xc6, 0x12, 0x8e, 0x7e, 0xad, 0x67, 0xd9, + 0xfc, 0x7c, 0x42, 0x66, 0xbb, 0x02, 0xbc, 0x86, 0xac, 0x97, 0xff, 0x8e, 0x05, 0x27, 0x76, 0x53, + 0x39, 0x3f, 0x52, 0x24, 0x1f, 0x31, 0x3b, 0x35, 0x9d, 0x48, 0xa4, 0xa7, 0x70, 0xba, 0x3d, 0xc6, + 0x59, 0xee, 0xf6, 0xff, 0xb0, 0xc0, 0x14, 0x4f, 0x83, 0x69, 0x56, 0xc6, 0x3d, 0x37, 0x85, 0x43, + 0xee, 0xb9, 0x91, 0x4a, 0x58, 0x71, 0x30, 0xa5, 0x7f, 0x64, 0x08, 0xa5, 0xbf, 0xd4, 0x57, 0x6b, + 0x7b, 0x1a, 0x8a, 0x6d, 0xaf, 0x26, 0xf4, 0x76, 0xed, 0xd5, 0x5b, 0x59, 0xc2, 0xb4, 0xdd, 0xfe, + 0xfd, 0x92, 0xb6, 0xd3, 0x45, 0xa4, 0xe7, 0x8f, 0xc5, 0x6b, 0xd7, 0x55, 0xb2, 0x31, 0x7f, 0xf3, + 0x6b, 0x5d, 0xc9, 0xc6, 0x3f, 0x35, 0x7c, 0x20, 0x2f, 0x1f, 0xa0, 0x7e, 0xb9, 0xc6, 0x63, 0x87, + 0x44, 0xf1, 0xde, 0x82, 0x32, 0x35, 0x6d, 0xd8, 0x81, 0x5b, 0x39, 0xd5, 0xa9, 0xf2, 0x65, 0xd1, + 0x7e, 0xf7, 0x60, 0xf6, 0x27, 0x87, 0xef, 0x96, 0x7c, 0x1a, 0x2b, 0xfa, 0x28, 0x86, 0x0a, 0xfd, + 0xcd, 0x02, 0x8e, 0x85, 0xd1, 0x74, 0x5d, 0xc9, 0x22, 0x09, 0xc8, 0x25, 0x9a, 0x59, 0xf3, 0x41, + 0x01, 0x54, 0xd8, 0x95, 0x1d, 0x8c, 0x29, 0xb7, 0xad, 0x36, 0x54, 0xd8, 0xaf, 0x04, 0xdc, 0x3d, + 0x98, 0x7d, 0x65, 0x78, 0xa6, 0xea, 0x71, 0xac, 0x59, 0xd8, 0xef, 0x8e, 0xe8, 0xb9, 0x2b, 0x72, + 0xcc, 0x7f, 0x2c, 0xe6, 0xee, 0xcb, 0x99, 0xb9, 0x7b, 0xbe, 0x6b, 0xee, 0x4e, 0xe9, 0xab, 0x25, + 0x52, 0xb3, 0xf1, 0x41, 0x6f, 0xb0, 0x87, 0xdb, 0xf1, 0x4c, 0xb3, 0x78, 0xab, 0xed, 0x45, 0x24, + 0xde, 0x88, 0xda, 0x81, 0x17, 0x34, 0xc4, 0xdd, 0x75, 0x86, 0x66, 0x91, 0x02, 0xe3, 0x2c, 0x3e, + 0xbb, 0xf7, 0xae, 0x13, 0xb8, 0x37, 0x9d, 0x3d, 0x3e, 0xab, 0x8c, 0xb4, 0xdb, 0x4d, 0xd1, 0x8e, + 0x15, 0x86, 0xfd, 0x5d, 0xe6, 0x6f, 0x35, 0x32, 0x1d, 0xe8, 0x9c, 0xf0, 0xd9, 0x1d, 0x29, 0x3c, + 0x67, 0x57, 0xcd, 0x09, 0x7e, 0x31, 0x0a, 0x87, 0xa1, 0xdb, 0x30, 0xb6, 0xcd, 0x6b, 0x8e, 0xe7, + 0x53, 0xe4, 0x4b, 0x14, 0x30, 0x67, 0x75, 0x38, 0x65, 0x35, 0xf3, 0xbb, 0xfa, 0x27, 0x96, 0xdc, + 0xec, 0xf7, 0x46, 0xe0, 0x44, 0xe6, 0x16, 0x8d, 0x54, 0xc9, 0x91, 0xc2, 0xa1, 0x25, 0x47, 0x3e, + 0x03, 0x50, 0x23, 0x2d, 0x3f, 0xec, 0x30, 0x35, 0x67, 0x64, 0x68, 0x35, 0x47, 0x69, 0xc6, 0x4b, + 0x8a, 0x0a, 0x36, 0x28, 0x8a, 0x44, 0x65, 0x5e, 0xc1, 0x24, 0x93, 0xa8, 0x6c, 0xd4, 0xd9, 0x1b, + 0x7d, 0xb0, 0x75, 0xf6, 0x3c, 0x38, 0xc1, 0xbb, 0xa8, 0xf2, 0x09, 0xee, 0x23, 0x6d, 0x80, 0x45, + 0xa2, 0x2e, 0xa5, 0xc9, 0xe0, 0x2c, 0xdd, 0x87, 0x79, 0x49, 0x0e, 0xfa, 0x28, 0x54, 0xe4, 0x77, + 0x8e, 0x67, 0x2a, 0x3a, 0x27, 0x4b, 0x4e, 0x03, 0x76, 0x79, 0x8d, 0xf8, 0x69, 0x7f, 0xb3, 0x40, + 0xb5, 0x52, 0xfe, 0x4f, 0xe5, 0xd6, 0x3e, 0x0b, 0xa3, 0x4e, 0x3b, 0xd9, 0x09, 0xbb, 0xaa, 0xbc, + 0x2f, 0xb0, 0x56, 0x2c, 0xa0, 0x68, 0x15, 0x46, 0x6a, 0x3a, 0x5f, 0x72, 0x98, 0x51, 0xd4, 0x07, + 0x7c, 0x4e, 0x42, 0x30, 0xa3, 0x82, 0x9e, 0x82, 0x91, 0xc4, 0x69, 0xa4, 0xee, 0x5f, 0xdc, 0x72, + 0x1a, 0x31, 0x66, 0xad, 0xe6, 0xa6, 0x39, 0x72, 0xc8, 0xa6, 0xf9, 0x0a, 0x4c, 0xc6, 0x5e, 0x23, + 0x70, 0x92, 0x76, 0x44, 0x0c, 0x67, 0x92, 0xf6, 0xe9, 0x9b, 0x40, 0x9c, 0xc6, 0xb5, 0xdf, 0xaf, + 0xc0, 0xe9, 0x5e, 0xf7, 0x64, 0xe7, 0x1d, 0x75, 0xde, 0x8b, 0xc7, 0x83, 0x8b, 0x3a, 0xef, 0xc3, + 0xdd, 0x37, 0xa2, 0xce, 0x7d, 0x23, 0xea, 0xfc, 0xab, 0x16, 0x54, 0x54, 0xb0, 0xb5, 0x08, 0x18, + 0x7d, 0xe3, 0x18, 0xee, 0x22, 0x97, 0x2c, 0x44, 0xcc, 0xad, 0xfc, 0x8b, 0x35, 0xf3, 0xe3, 0x0b, + 0x43, 0xbf, 0x67, 0x87, 0x86, 0x0a, 0x43, 0x57, 0x31, 0xfa, 0xa5, 0x3c, 0x62, 0xf4, 0xfb, 0x7c, + 0xaa, 0x9e, 0x31, 0xfa, 0xdf, 0xb2, 0x60, 0xdc, 0x79, 0xbb, 0x1d, 0x91, 0x25, 0xb2, 0xb7, 0xde, + 0x8a, 0x85, 0x80, 0x7d, 0x33, 0xff, 0x0e, 0x2c, 0x68, 0x26, 0xa2, 0x1c, 0xad, 0x6e, 0xc0, 0x66, + 0x17, 0x52, 0x31, 0xf9, 0x63, 0x79, 0xc4, 0xe4, 0xf7, 0xea, 0xce, 0xa1, 0x31, 0xf9, 0xaf, 0xc0, + 0xa4, 0xeb, 0x87, 0x01, 0xd9, 0x88, 0xc2, 0x24, 0x74, 0x43, 0x5f, 0x28, 0xd3, 0x4a, 0x24, 0x2c, + 0x9a, 0x40, 0x9c, 0xc6, 0xed, 0x17, 0xd0, 0x5f, 0x39, 0x6a, 0x40, 0x3f, 0x3c, 0xa4, 0x80, 0xfe, + 0xbf, 0x28, 0xc0, 0xec, 0x21, 0x1f, 0x15, 0xbd, 0x0c, 0x13, 0x61, 0xd4, 0x70, 0x02, 0xef, 0x6d, + 0x9e, 0x4f, 0x59, 0x4a, 0x97, 0xbb, 0x58, 0x37, 0x60, 0x38, 0x85, 0x29, 0x43, 0x7e, 0x47, 0xfb, + 0x84, 0xfc, 0x7e, 0x1c, 0xc6, 0x13, 0xe2, 0x34, 0x45, 0xac, 0x84, 0x30, 0x80, 0xb4, 0x43, 0x49, + 0x83, 0xb0, 0x89, 0x47, 0xa7, 0xd1, 0x94, 0xe3, 0xba, 0x24, 0x8e, 0x65, 0x4c, 0xaf, 0x38, 0x9c, + 0xc9, 0x2d, 0x60, 0x98, 0x9d, 0x79, 0x2d, 0xa4, 0x58, 0xe0, 0x0c, 0x4b, 0xda, 0x79, 0xc7, 0xf7, + 0x79, 0xf8, 0x3e, 0x91, 0x37, 0x2a, 0xeb, 0xea, 0x0b, 0x1a, 0x84, 0x4d, 0x3c, 0xfb, 0xb7, 0x0a, + 0xf0, 0xf4, 0x3d, 0xc5, 0xcb, 0xc0, 0xe1, 0xd6, 0xed, 0x98, 0x44, 0x59, 0x87, 0xcc, 0xf5, 0x98, + 0x44, 0x98, 0x41, 0xf8, 0x28, 0xb5, 0x5a, 0xc6, 0x55, 0x2e, 0x79, 0x47, 0xf7, 0xf3, 0x51, 0x4a, + 0xb1, 0xc0, 0x19, 0x96, 0xd9, 0x51, 0x1a, 0x19, 0x70, 0x94, 0xfe, 0x5e, 0x01, 0x9e, 0x19, 0x40, + 0x08, 0xe7, 0x98, 0x05, 0x91, 0xce, 0x22, 0x29, 0x3e, 0x9c, 0x2c, 0x92, 0xfb, 0x1d, 0xae, 0xef, + 0x16, 0xe0, 0x6c, 0x7f, 0x59, 0x88, 0x7e, 0x9a, 0x1a, 0x51, 0x32, 0xd8, 0xc2, 0xcc, 0x40, 0x39, + 0xc5, 0x0d, 0xa8, 0x14, 0x08, 0x67, 0x71, 0xd1, 0x1c, 0x40, 0xcb, 0x49, 0x76, 0xe2, 0x8b, 0xfb, + 0x5e, 0x9c, 0x88, 0xdc, 0xc9, 0x29, 0x7e, 0x14, 0x2e, 0x5b, 0xb1, 0x81, 0x41, 0xd9, 0xb1, 0x7f, + 0x4b, 0xe1, 0xb5, 0x30, 0xe1, 0x0f, 0x71, 0x3d, 0xee, 0x94, 0xac, 0xf7, 0x67, 0x80, 0x70, 0x16, + 0x97, 0xb2, 0x63, 0xce, 0x16, 0xde, 0x51, 0x71, 0x5d, 0x3c, 0x65, 0xb7, 0xaa, 0x5a, 0xb1, 0x81, + 0x91, 0xcd, 0xad, 0x29, 0x0d, 0x90, 0x5b, 0xf3, 0x8f, 0x0a, 0xf0, 0x44, 0xdf, 0xbd, 0x74, 0xb0, + 0x05, 0xf8, 0xe8, 0x25, 0xd5, 0xdc, 0xdf, 0xdc, 0x19, 0x32, 0x55, 0xe4, 0xcf, 0xfa, 0xcc, 0x34, + 0x91, 0x2a, 0x92, 0xdd, 0x2a, 0xac, 0x61, 0xb7, 0x8a, 0x47, 0x68, 0x3c, 0xbb, 0xb2, 0x43, 0x46, + 0x86, 0xc8, 0x0e, 0xc9, 0x7c, 0x8c, 0xd2, 0x80, 0x0b, 0xf9, 0xfb, 0xfd, 0x87, 0x97, 0xea, 0xde, + 0x03, 0x1d, 0x4f, 0x2d, 0xc1, 0x49, 0x2f, 0x60, 0xb5, 0x5f, 0x37, 0xdb, 0xdb, 0x22, 0xb3, 0xb6, + 0x90, 0xbe, 0xd6, 0x68, 0x25, 0x03, 0xc7, 0x5d, 0x4f, 0x3c, 0x82, 0xd9, 0x3a, 0xf7, 0x39, 0xa4, + 0x9f, 0x81, 0x8a, 0xa2, 0xcd, 0x23, 0x23, 0xd5, 0x07, 0xed, 0x8a, 0x8c, 0x54, 0x5f, 0xd3, 0xc0, + 0xa2, 0x23, 0xb1, 0x4b, 0x3a, 0xd9, 0x99, 0x79, 0x95, 0x74, 0x98, 0x97, 0xd4, 0xfe, 0x18, 0x4c, + 0x28, 0x23, 0x72, 0xd0, 0xda, 0xa4, 0xf6, 0xbb, 0xa3, 0x30, 0x99, 0xaa, 0xa0, 0x90, 0x3a, 0xb3, + 0xb1, 0x0e, 0x3d, 0xb3, 0x61, 0xd1, 0xa9, 0xed, 0x40, 0x56, 0xff, 0x35, 0xa2, 0x53, 0xdb, 0x01, + 0xc1, 0x1c, 0x46, 0x4d, 0xf7, 0x5a, 0xd4, 0xc1, 0xed, 0x40, 0x44, 0xa4, 0x29, 0xd3, 0x7d, 0x89, + 0xb5, 0x62, 0x01, 0x45, 0x5f, 0xb4, 0x60, 0x22, 0x66, 0x07, 0x82, 0xfc, 0xc4, 0x4b, 0x7c, 0xd0, + 0x2b, 0x79, 0xdc, 0x5e, 0x2b, 0xaa, 0x85, 0x30, 0x67, 0xb6, 0xd9, 0x82, 0x53, 0x1c, 0xd1, 0x57, + 0x2c, 0xf3, 0xde, 0xde, 0xd1, 0x3c, 0x22, 0x29, 0xb3, 0x05, 0x2a, 0xf8, 0x51, 0xc9, 0xbd, 0xaf, + 0xef, 0xd5, 0xd7, 0x79, 0x8f, 0x3d, 0xb8, 0xeb, 0xbc, 0x3f, 0x0a, 0x95, 0xa6, 0x13, 0x78, 0x75, + 0x12, 0x27, 0xfc, 0x84, 0x48, 0xd6, 0xcd, 0x91, 0x8d, 0x58, 0xc3, 0xe9, 0x66, 0x17, 0xb3, 0x17, + 0x4b, 0x8c, 0x23, 0x1d, 0xb6, 0xd9, 0x6d, 0xea, 0x66, 0x6c, 0xe2, 0x98, 0xe7, 0x4f, 0xf0, 0x50, + 0xcf, 0x9f, 0xc6, 0x0f, 0x39, 0x7f, 0xfa, 0x07, 0x16, 0x9c, 0xe9, 0xf9, 0xd5, 0x1e, 0xdd, 0x18, + 0x25, 0xfb, 0xfd, 0x22, 0x9c, 0xea, 0x51, 0x0a, 0x05, 0x75, 0x8e, 0xed, 0x1e, 0x6a, 0x51, 0x6b, + 0x65, 0xb2, 0xef, 0x24, 0x1e, 0xee, 0xf4, 0x57, 0x9f, 0xc0, 0x16, 0x1f, 0xec, 0x09, 0xac, 0x31, + 0x2d, 0x47, 0x1e, 0xea, 0xb4, 0x2c, 0x1d, 0x32, 0x2d, 0xdf, 0x2f, 0x82, 0x71, 0xad, 0x3c, 0xfa, + 0x82, 0x59, 0x9e, 0xc8, 0xca, 0xab, 0x94, 0x0e, 0x27, 0xae, 0xca, 0x1b, 0xf1, 0xee, 0xf4, 0xaa, + 0x76, 0x94, 0x95, 0x00, 0x85, 0x01, 0x24, 0x80, 0x2f, 0xeb, 0x40, 0x15, 0xf3, 0xaf, 0x03, 0x55, + 0xc9, 0xd6, 0x80, 0x42, 0xbf, 0x67, 0xc1, 0x4c, 0xb3, 0x4f, 0xbd, 0xc2, 0x7c, 0xd2, 0xf3, 0xfb, + 0x55, 0x43, 0xac, 0x3e, 0x75, 0xe7, 0x60, 0xb6, 0x6f, 0x99, 0x48, 0xdc, 0xb7, 0x57, 0xf6, 0xdf, + 0xb4, 0xf8, 0x2a, 0xce, 0x7c, 0x05, 0xbd, 0xcd, 0x5a, 0xf7, 0xd8, 0x66, 0x9f, 0x67, 0x37, 0x9d, + 0xd5, 0x2f, 0x13, 0xc7, 0x17, 0xdb, 0xb1, 0x79, 0x69, 0x19, 0x6b, 0xc7, 0x0a, 0x83, 0xdd, 0x4d, + 0xe0, 0xfb, 0xe1, 0xed, 0x8b, 0xcd, 0x56, 0xd2, 0x11, 0x1b, 0xb3, 0xbe, 0x9b, 0x40, 0x41, 0xb0, + 0x81, 0x65, 0xff, 0x46, 0x81, 0xcf, 0x40, 0xe1, 0xa4, 0x7c, 0x39, 0x53, 0x08, 0x7b, 0x70, 0xff, + 0xde, 0xe7, 0x01, 0x5c, 0x75, 0xc9, 0x51, 0x3e, 0x97, 0xd4, 0xeb, 0x4b, 0x93, 0xcc, 0x9b, 0xd3, + 0x65, 0x1b, 0x36, 0xf8, 0xa5, 0x04, 0x53, 0xf1, 0x50, 0xc1, 0x94, 0x5a, 0xa3, 0x23, 0x87, 0xac, + 0xd1, 0xbf, 0xb0, 0x20, 0xa5, 0x5e, 0xa0, 0x16, 0x94, 0x68, 0x77, 0x3b, 0xf9, 0xdc, 0xdf, 0x64, + 0x92, 0xa6, 0x72, 0x46, 0x4c, 0x7b, 0xf6, 0x13, 0x73, 0x46, 0xc8, 0x17, 0xbe, 0xcc, 0x42, 0x1e, + 0x77, 0x8c, 0x99, 0x0c, 0x2f, 0x87, 0xe1, 0x2e, 0x77, 0x81, 0x68, 0xbf, 0xa8, 0xfd, 0x32, 0x4c, + 0x77, 0x75, 0x8a, 0xd5, 0xbc, 0x0d, 0xe5, 0xa5, 0x55, 0xc6, 0x74, 0x65, 0x15, 0xb8, 0x31, 0x87, + 0xd9, 0xdf, 0xb5, 0xe0, 0x64, 0x96, 0x3c, 0xfa, 0xb6, 0x05, 0xd3, 0x71, 0x96, 0xde, 0x71, 0x8d, + 0x9d, 0x8a, 0xf3, 0xe9, 0x02, 0xe1, 0xee, 0x4e, 0xd8, 0xff, 0x57, 0x4c, 0xfe, 0x9b, 0x5e, 0x50, + 0x0b, 0x6f, 0xab, 0x5d, 0xde, 0xea, 0xbb, 0xcb, 0xd3, 0xf5, 0xe8, 0xee, 0x90, 0x5a, 0xdb, 0xef, + 0xca, 0x64, 0xda, 0x14, 0xed, 0x58, 0x61, 0xa4, 0x6e, 0x88, 0x2e, 0x1e, 0x7a, 0x43, 0xf4, 0x4b, + 0x30, 0x61, 0x5e, 0xcc, 0x26, 0xe6, 0x25, 0xd3, 0x6e, 0xcd, 0x3b, 0xdc, 0x70, 0x0a, 0x2b, 0x73, + 0x35, 0x6f, 0xe9, 0xd0, 0xab, 0x79, 0x9f, 0x83, 0xb2, 0xb8, 0x66, 0x56, 0x46, 0xc3, 0xf1, 0x34, + 0x29, 0xd1, 0x86, 0x15, 0x94, 0x4a, 0x93, 0xa6, 0x13, 0xb4, 0x1d, 0x9f, 0x8e, 0x90, 0xc8, 0xc7, + 0x54, 0xcb, 0x70, 0x4d, 0x41, 0xb0, 0x81, 0x45, 0xdf, 0x38, 0xf1, 0x9a, 0xe4, 0xf5, 0x30, 0x90, + 0x71, 0x24, 0xfa, 0x80, 0x58, 0xb4, 0x63, 0x85, 0x61, 0xff, 0x17, 0x0b, 0xb2, 0x77, 0x64, 0xa6, + 0x8e, 0x0c, 0xac, 0x43, 0x73, 0x40, 0xd3, 0xd9, 0x68, 0x85, 0x81, 0xb2, 0xd1, 0xcc, 0x44, 0xb1, + 0xe2, 0x3d, 0x13, 0xc5, 0x7e, 0x42, 0xdf, 0x9c, 0xc0, 0x33, 0xca, 0xc6, 0x7b, 0xdd, 0x9a, 0x80, + 0x6c, 0x18, 0x75, 0x1d, 0x95, 0xd9, 0x3f, 0xc1, 0x15, 0xf1, 0xc5, 0x05, 0x86, 0x24, 0x20, 0xd5, + 0xed, 0xf7, 0x7e, 0x78, 0xee, 0x43, 0xdf, 0xff, 0xe1, 0xb9, 0x0f, 0xfd, 0xc9, 0x0f, 0xcf, 0x7d, + 0xe8, 0x8b, 0x77, 0xce, 0x59, 0xef, 0xdd, 0x39, 0x67, 0x7d, 0xff, 0xce, 0x39, 0xeb, 0x4f, 0xee, + 0x9c, 0xb3, 0xde, 0xbf, 0x73, 0xce, 0xfa, 0xd6, 0x7f, 0x3c, 0xf7, 0xa1, 0xd7, 0x7b, 0xc6, 0xfd, + 0xd0, 0x1f, 0x2f, 0xb8, 0xb5, 0xf9, 0xbd, 0x0b, 0x2c, 0xf4, 0x84, 0xae, 0x86, 0x79, 0x63, 0x0a, + 0xcc, 0xcb, 0xd5, 0xf0, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x38, 0xc0, 0xfa, 0xc5, 0xd3, 0xc1, + 0x00, 0x00, } func (m *AWSAuthConfig) Marshal() (dAtA []byte, err error) { @@ -4917,6 +5081,48 @@ func (m *ApplicationList) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ApplicationMatchExpression) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ApplicationMatchExpression) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationMatchExpression) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Values) > 0 { + for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Values[iNdEx]) + copy(dAtA[i:], m.Values[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Values[iNdEx]))) + i-- + dAtA[i] = 0x1a + } + } + i -= len(m.Operator) + copy(dAtA[i:], m.Operator) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Operator))) + i-- + dAtA[i] = 0x12 + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *ApplicationSet) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4970,6 +5176,56 @@ func (m *ApplicationSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ApplicationSetApplicationStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ApplicationSetApplicationStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetApplicationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i -= len(m.Status) + copy(dAtA[i:], m.Status) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Status))) + i-- + dAtA[i] = 0x2a + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x1a + if m.LastTransitionTime != nil { + { + size, err := m.LastTransitionTime.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + i -= len(m.Application) + copy(dAtA[i:], m.Application) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Application))) + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *ApplicationSetCondition) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5334,6 +5590,92 @@ func (m *ApplicationSetNestedGenerator) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } +func (m *ApplicationSetRolloutStep) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ApplicationSetRolloutStep) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetRolloutStep) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MaxUpdate != nil { + { + size, err := m.MaxUpdate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.MatchExpressions) > 0 { + for iNdEx := len(m.MatchExpressions) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MatchExpressions[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *ApplicationSetRolloutStrategy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ApplicationSetRolloutStrategy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetRolloutStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Steps) > 0 { + for iNdEx := len(m.Steps) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Steps[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *ApplicationSetSpec) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -5354,6 +5696,18 @@ func (m *ApplicationSetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Strategy != nil { + { + size, err := m.Strategy.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } if m.SyncPolicy != nil { { size, err := m.SyncPolicy.MarshalToSizedBuffer(dAtA[:i]) @@ -5421,6 +5775,20 @@ func (m *ApplicationSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ApplicationStatus) > 0 { + for iNdEx := len(m.ApplicationStatus) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ApplicationStatus[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } if len(m.Conditions) > 0 { for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { { @@ -5438,7 +5806,7 @@ func (m *ApplicationSetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *ApplicationSetSyncPolicy) Marshal() (dAtA []byte, err error) { +func (m *ApplicationSetStrategy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5448,28 +5816,37 @@ func (m *ApplicationSetSyncPolicy) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ApplicationSetSyncPolicy) MarshalTo(dAtA []byte) (int, error) { +func (m *ApplicationSetStrategy) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ApplicationSetSyncPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ApplicationSetStrategy) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - i-- - if m.PreserveResourcesOnDeletion { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if m.RollingSync != nil { + { + size, err := m.RollingSync.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGenerated(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } + i -= len(m.Type) + copy(dAtA[i:], m.Type) + i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type))) i-- - dAtA[i] = 0x8 + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *ApplicationSetTemplate) Marshal() (dAtA []byte, err error) { +func (m *ApplicationSetSyncPolicy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5479,7 +5856,38 @@ func (m *ApplicationSetTemplate) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ApplicationSetTemplate) MarshalTo(dAtA []byte) (int, error) { +func (m *ApplicationSetSyncPolicy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ApplicationSetSyncPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + i-- + if m.PreserveResourcesOnDeletion { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + return len(dAtA) - i, nil +} + +func (m *ApplicationSetTemplate) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ApplicationSetTemplate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } @@ -12307,6 +12715,25 @@ func (m *ApplicationList) Size() (n int) { return n } +func (m *ApplicationMatchExpression) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Operator) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Values) > 0 { + for _, s := range m.Values { + l = len(s) + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + func (m *ApplicationSet) Size() (n int) { if m == nil { return 0 @@ -12322,6 +12749,25 @@ func (m *ApplicationSet) Size() (n int) { return n } +func (m *ApplicationSetApplicationStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Application) + n += 1 + l + sovGenerated(uint64(l)) + if m.LastTransitionTime != nil { + l = m.LastTransitionTime.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + l = len(m.Message) + n += 1 + l + sovGenerated(uint64(l)) + l = len(m.Status) + n += 1 + l + sovGenerated(uint64(l)) + return n +} + func (m *ApplicationSetCondition) Size() (n int) { if m == nil { return 0 @@ -12450,6 +12896,40 @@ func (m *ApplicationSetNestedGenerator) Size() (n int) { return n } +func (m *ApplicationSetRolloutStep) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.MatchExpressions) > 0 { + for _, e := range m.MatchExpressions { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + if m.MaxUpdate != nil { + l = m.MaxUpdate.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + return n +} + +func (m *ApplicationSetRolloutStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Steps) > 0 { + for _, e := range m.Steps { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + func (m *ApplicationSetSpec) Size() (n int) { if m == nil { return 0 @@ -12469,6 +12949,10 @@ func (m *ApplicationSetSpec) Size() (n int) { l = m.SyncPolicy.Size() n += 1 + l + sovGenerated(uint64(l)) } + if m.Strategy != nil { + l = m.Strategy.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -12484,6 +12968,27 @@ func (m *ApplicationSetStatus) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if len(m.ApplicationStatus) > 0 { + for _, e := range m.ApplicationStatus { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func (m *ApplicationSetStrategy) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Type) + n += 1 + l + sovGenerated(uint64(l)) + if m.RollingSync != nil { + l = m.RollingSync.Size() + n += 1 + l + sovGenerated(uint64(l)) + } return n } @@ -15175,6 +15680,18 @@ func (this *ApplicationList) String() string { }, "") return s } +func (this *ApplicationMatchExpression) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApplicationMatchExpression{`, + `Key:` + fmt.Sprintf("%v", this.Key) + `,`, + `Operator:` + fmt.Sprintf("%v", this.Operator) + `,`, + `Values:` + fmt.Sprintf("%v", this.Values) + `,`, + `}`, + }, "") + return s +} func (this *ApplicationSet) String() string { if this == nil { return "nil" @@ -15187,6 +15704,19 @@ func (this *ApplicationSet) String() string { }, "") return s } +func (this *ApplicationSetApplicationStatus) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApplicationSetApplicationStatus{`, + `Application:` + fmt.Sprintf("%v", this.Application) + `,`, + `LastTransitionTime:` + strings.Replace(fmt.Sprintf("%v", this.LastTransitionTime), "Time", "v1.Time", 1) + `,`, + `Message:` + fmt.Sprintf("%v", this.Message) + `,`, + `Status:` + fmt.Sprintf("%v", this.Status) + `,`, + `}`, + }, "") + return s +} func (this *ApplicationSetCondition) String() string { if this == nil { return "nil" @@ -15253,6 +15783,37 @@ func (this *ApplicationSetNestedGenerator) String() string { }, "") return s } +func (this *ApplicationSetRolloutStep) String() string { + if this == nil { + return "nil" + } + repeatedStringForMatchExpressions := "[]ApplicationMatchExpression{" + for _, f := range this.MatchExpressions { + repeatedStringForMatchExpressions += strings.Replace(strings.Replace(f.String(), "ApplicationMatchExpression", "ApplicationMatchExpression", 1), `&`, ``, 1) + "," + } + repeatedStringForMatchExpressions += "}" + s := strings.Join([]string{`&ApplicationSetRolloutStep{`, + `MatchExpressions:` + repeatedStringForMatchExpressions + `,`, + `MaxUpdate:` + strings.Replace(fmt.Sprintf("%v", this.MaxUpdate), "IntOrString", "intstr.IntOrString", 1) + `,`, + `}`, + }, "") + return s +} +func (this *ApplicationSetRolloutStrategy) String() string { + if this == nil { + return "nil" + } + repeatedStringForSteps := "[]ApplicationSetRolloutStep{" + for _, f := range this.Steps { + repeatedStringForSteps += strings.Replace(strings.Replace(f.String(), "ApplicationSetRolloutStep", "ApplicationSetRolloutStep", 1), `&`, ``, 1) + "," + } + repeatedStringForSteps += "}" + s := strings.Join([]string{`&ApplicationSetRolloutStrategy{`, + `Steps:` + repeatedStringForSteps + `,`, + `}`, + }, "") + return s +} func (this *ApplicationSetSpec) String() string { if this == nil { return "nil" @@ -15267,6 +15828,7 @@ func (this *ApplicationSetSpec) String() string { `Generators:` + repeatedStringForGenerators + `,`, `Template:` + strings.Replace(strings.Replace(this.Template.String(), "ApplicationSetTemplate", "ApplicationSetTemplate", 1), `&`, ``, 1) + `,`, `SyncPolicy:` + strings.Replace(this.SyncPolicy.String(), "ApplicationSetSyncPolicy", "ApplicationSetSyncPolicy", 1) + `,`, + `Strategy:` + strings.Replace(this.Strategy.String(), "ApplicationSetStrategy", "ApplicationSetStrategy", 1) + `,`, `}`, }, "") return s @@ -15280,8 +15842,25 @@ func (this *ApplicationSetStatus) String() string { repeatedStringForConditions += strings.Replace(strings.Replace(f.String(), "ApplicationSetCondition", "ApplicationSetCondition", 1), `&`, ``, 1) + "," } repeatedStringForConditions += "}" + repeatedStringForApplicationStatus := "[]ApplicationSetApplicationStatus{" + for _, f := range this.ApplicationStatus { + repeatedStringForApplicationStatus += strings.Replace(strings.Replace(f.String(), "ApplicationSetApplicationStatus", "ApplicationSetApplicationStatus", 1), `&`, ``, 1) + "," + } + repeatedStringForApplicationStatus += "}" s := strings.Join([]string{`&ApplicationSetStatus{`, `Conditions:` + repeatedStringForConditions + `,`, + `ApplicationStatus:` + repeatedStringForApplicationStatus + `,`, + `}`, + }, "") + return s +} +func (this *ApplicationSetStrategy) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ApplicationSetStrategy{`, + `Type:` + fmt.Sprintf("%v", this.Type) + `,`, + `RollingSync:` + strings.Replace(this.RollingSync.String(), "ApplicationSetRolloutStrategy", "ApplicationSetRolloutStrategy", 1) + `,`, `}`, }, "") return s @@ -18798,7 +19377,7 @@ func (m *ApplicationList) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSet) Unmarshal(dAtA []byte) error { +func (m *ApplicationMatchExpression) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18821,17 +19400,17 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSet: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationMatchExpression: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSet: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationMatchExpression: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18841,30 +19420,29 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18874,30 +19452,29 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18907,24 +19484,23 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Values = append(m.Values, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex @@ -18947,7 +19523,7 @@ func (m *ApplicationSet) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { +func (m *ApplicationSet) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -18970,17 +19546,17 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetCondition: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSet: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetCondition: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSet: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -18990,29 +19566,30 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Type = ApplicationSetConditionType(dAtA[iNdEx:postIndex]) + if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -19022,27 +19599,28 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Message = string(dAtA[iNdEx:postIndex]) + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19069,50 +19647,749 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.LastTransitionTime == nil { - m.LastTransitionTime = &v1.Time{} - } - if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApplicationSetApplicationStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApplicationSetApplicationStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetApplicationStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Application", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Application = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastTransitionTime == nil { + m.LastTransitionTime = &v1.Time{} + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApplicationSetCondition: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetCondition: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = ApplicationSetConditionType(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LastTransitionTime == nil { + m.LastTransitionTime = &v1.Time{} + } + if err := m.LastTransitionTime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Status = ApplicationSetConditionStatus(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApplicationSetGenerator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetGenerator: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field List", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.List == nil { + m.List = &ListGenerator{} + } + if err := m.List.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Clusters", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Clusters == nil { + m.Clusters = &ClusterGenerator{} + } + if err := m.Clusters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Git", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Git == nil { + m.Git = &GitGenerator{} + } + if err := m.Git.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SCMProvider", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SCMProvider == nil { + m.SCMProvider = &SCMProviderGenerator{} + } + if err := m.SCMProvider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterDecisionResource", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ClusterDecisionResource == nil { + m.ClusterDecisionResource = &DuckTypeGenerator{} + } + if err := m.ClusterDecisionResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PullRequest", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PullRequest == nil { + m.PullRequest = &PullRequestGenerator{} + } + if err := m.PullRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Matrix", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Matrix == nil { + m.Matrix = &MatrixGenerator{} + } + if err := m.Matrix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Status = ApplicationSetConditionStatus(dAtA[iNdEx:postIndex]) + if m.Merge == nil { + m.Merge = &MergeGenerator{} + } + if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 5: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -19122,23 +20399,27 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthGenerated } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthGenerated } if postIndex > l { return io.ErrUnexpectedEOF } - m.Reason = string(dAtA[iNdEx:postIndex]) + if m.Selector == nil { + m.Selector = &v1.LabelSelector{} + } + if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -19161,7 +20442,7 @@ func (m *ApplicationSetCondition) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19184,10 +20465,127 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetGenerator: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetList: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetGenerator: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, ApplicationSet{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApplicationSetNestedGenerator: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetNestedGenerator: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -19436,7 +20834,7 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Matrix == nil { - m.Matrix = &MatrixGenerator{} + m.Matrix = &v11.JSON{} } if err := m.Matrix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -19472,7 +20870,7 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { return io.ErrUnexpectedEOF } if m.Merge == nil { - m.Merge = &MergeGenerator{} + m.Merge = &v11.JSON{} } if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err @@ -19535,7 +20933,7 @@ func (m *ApplicationSetGenerator) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetRolloutStep) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19558,15 +20956,15 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetList: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetRolloutStep: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetList: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetRolloutStep: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19593,13 +20991,14 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.MatchExpressions = append(m.MatchExpressions, ApplicationMatchExpression{}) + if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MaxUpdate", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19626,8 +21025,10 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Items = append(m.Items, ApplicationSet{}) - if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.MaxUpdate == nil { + m.MaxUpdate = &intstr.IntOrString{} + } + if err := m.MaxUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -19652,7 +21053,7 @@ func (m *ApplicationSetList) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetRolloutStrategy) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -19675,87 +21076,15 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetNestedGenerator: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetNestedGenerator: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field List", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.List == nil { - m.List = &ListGenerator{} - } - if err := m.List.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Clusters", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Clusters == nil { - m.Clusters = &ClusterGenerator{} - } - if err := m.Clusters.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: + return fmt.Errorf("proto: ApplicationSetRolloutStrategy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetRolloutStrategy: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Git", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Steps", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19782,54 +21111,66 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Git == nil { - m.Git = &GitGenerator{} - } - if err := m.Git.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Steps = append(m.Steps, ApplicationSetRolloutStep{}) + if err := m.Steps[len(m.Steps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SCMProvider", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenerated + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthGenerated } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if m.SCMProvider == nil { - m.SCMProvider = &SCMProviderGenerator{} + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated } - if err := m.SCMProvider.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + if iNdEx >= l { + return io.ErrUnexpectedEOF } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClusterDecisionResource", wireType) + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - var msglen int + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ApplicationSetSpec: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ApplicationSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GoTemplate", wireType) + } + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowGenerated @@ -19839,31 +21180,15 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ClusterDecisionResource == nil { - m.ClusterDecisionResource = &DuckTypeGenerator{} - } - if err := m.ClusterDecisionResource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: + m.GoTemplate = bool(v != 0) + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PullRequest", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Generators", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19890,16 +21215,14 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.PullRequest == nil { - m.PullRequest = &PullRequestGenerator{} - } - if err := m.PullRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Generators = append(m.Generators, ApplicationSetGenerator{}) + if err := m.Generators[len(m.Generators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Matrix", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19926,16 +21249,13 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Matrix == nil { - m.Matrix = &v11.JSON{} - } - if err := m.Matrix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 8: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SyncPolicy", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19962,16 +21282,16 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Merge == nil { - m.Merge = &v11.JSON{} + if m.SyncPolicy == nil { + m.SyncPolicy = &ApplicationSetSyncPolicy{} } - if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.SyncPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 9: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -19998,10 +21318,10 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Selector == nil { - m.Selector = &v1.LabelSelector{} + if m.Strategy == nil { + m.Strategy = &ApplicationSetStrategy{} } - if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Strategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -20026,7 +21346,7 @@ func (m *ApplicationSetNestedGenerator) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20049,69 +21369,15 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetSpec: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetStatus: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetSpec: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GoTemplate", 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.GoTemplate = bool(v != 0) - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Generators", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenerated - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenerated - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenerated - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Generators = append(m.Generators, ApplicationSetGenerator{}) - if err := m.Generators[len(m.Generators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Template", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20138,13 +21404,14 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Template.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Conditions = append(m.Conditions, ApplicationSetCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SyncPolicy", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ApplicationStatus", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20171,10 +21438,8 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.SyncPolicy == nil { - m.SyncPolicy = &ApplicationSetSyncPolicy{} - } - if err := m.SyncPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.ApplicationStatus = append(m.ApplicationStatus, ApplicationSetApplicationStatus{}) + if err := m.ApplicationStatus[len(m.ApplicationStatus)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -20199,7 +21464,7 @@ func (m *ApplicationSetSpec) Unmarshal(dAtA []byte) error { } return nil } -func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { +func (m *ApplicationSetStrategy) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -20222,15 +21487,47 @@ func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ApplicationSetStatus: wiretype end group for non-group") + return fmt.Errorf("proto: ApplicationSetStrategy: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ApplicationSetStatus: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ApplicationSetStrategy: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Type = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RollingSync", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -20257,8 +21554,10 @@ func (m *ApplicationSetStatus) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Conditions = append(m.Conditions, ApplicationSetCondition{}) - if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.RollingSync == nil { + m.RollingSync = &ApplicationSetRolloutStrategy{} + } + if err := m.RollingSync.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/pkg/apis/application/v1alpha1/generated.proto b/pkg/apis/application/v1alpha1/generated.proto index a5bd52048cadf..c7f3a766548e3 100644 --- a/pkg/apis/application/v1alpha1/generated.proto +++ b/pkg/apis/application/v1alpha1/generated.proto @@ -10,6 +10,7 @@ import "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1/generated.proto import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/generated.proto"; import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; +import "k8s.io/apimachinery/pkg/util/intstr/generated.proto"; // Package-wide variables from generator "generated". option go_package = "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"; @@ -148,6 +149,14 @@ message ApplicationList { repeated Application items = 2; } +message ApplicationMatchExpression { + optional string key = 1; + + optional string operator = 2; + + repeated string values = 3; +} + // ApplicationSet is a set of Application resources // +genclient // +genclient:noStatus @@ -162,6 +171,21 @@ message ApplicationSet { optional ApplicationSetStatus status = 3; } +// ApplicationSetApplicationStatus contains details about each Application managed by the ApplicationSet +message ApplicationSetApplicationStatus { + // Application contains the name of the Application resource + optional string application = 1; + + // LastTransitionTime is the time the status was last updated + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time lastTransitionTime = 2; + + // Message contains human-readable message indicating details about the status + optional string message = 3; + + // Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy) + optional string status = 5; +} + // ApplicationSetCondition contains details about an applicationset condition, which is usally an error or warning message ApplicationSetCondition { // Type is an applicationset condition type @@ -236,6 +260,16 @@ message ApplicationSetNestedGenerator { optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector selector = 9; } +message ApplicationSetRolloutStep { + repeated ApplicationMatchExpression matchExpressions = 1; + + optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxUpdate = 2; +} + +message ApplicationSetRolloutStrategy { + repeated ApplicationSetRolloutStep steps = 1; +} + // ApplicationSetSpec represents a class of application set state. message ApplicationSetSpec { optional bool goTemplate = 1; @@ -245,6 +279,8 @@ message ApplicationSetSpec { optional ApplicationSetTemplate template = 3; optional ApplicationSetSyncPolicy syncPolicy = 4; + + optional ApplicationSetStrategy strategy = 5; } // ApplicationSetStatus defines the observed state of ApplicationSet @@ -252,6 +288,15 @@ message ApplicationSetStatus { // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster // Important: Run "make" to regenerate code after modifying this file repeated ApplicationSetCondition conditions = 1; + + repeated ApplicationSetApplicationStatus applicationStatus = 2; +} + +// ApplicationSetStrategy configures how generated Applications are updated in sequence. +message ApplicationSetStrategy { + optional string type = 1; + + optional ApplicationSetRolloutStrategy rollingSync = 2; } // ApplicationSetSyncPolicy configures how generated Applications will relate to their diff --git a/pkg/apis/application/v1alpha1/openapi_generated.go b/pkg/apis/application/v1alpha1/openapi_generated.go index 788ccf3b8b5f3..5452b75aa2f6e 100644 --- a/pkg/apis/application/v1alpha1/openapi_generated.go +++ b/pkg/apis/application/v1alpha1/openapi_generated.go @@ -23,13 +23,18 @@ func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenA "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationCondition": schema_pkg_apis_application_v1alpha1_ApplicationCondition(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationDestination": schema_pkg_apis_application_v1alpha1_ApplicationDestination(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationList": schema_pkg_apis_application_v1alpha1_ApplicationList(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationMatchExpression": schema_pkg_apis_application_v1alpha1_ApplicationMatchExpression(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSet": schema_pkg_apis_application_v1alpha1_ApplicationSet(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetApplicationStatus": schema_pkg_apis_application_v1alpha1_ApplicationSetApplicationStatus(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetCondition": schema_pkg_apis_application_v1alpha1_ApplicationSetCondition(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetGenerator": schema_pkg_apis_application_v1alpha1_ApplicationSetGenerator(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetList": schema_pkg_apis_application_v1alpha1_ApplicationSetList(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetNestedGenerator": schema_pkg_apis_application_v1alpha1_ApplicationSetNestedGenerator(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRolloutStep": schema_pkg_apis_application_v1alpha1_ApplicationSetRolloutStep(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRolloutStrategy": schema_pkg_apis_application_v1alpha1_ApplicationSetRolloutStrategy(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSpec": schema_pkg_apis_application_v1alpha1_ApplicationSetSpec(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStatus": schema_pkg_apis_application_v1alpha1_ApplicationSetStatus(ref), + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStrategy": schema_pkg_apis_application_v1alpha1_ApplicationSetStrategy(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy": schema_pkg_apis_application_v1alpha1_ApplicationSetSyncPolicy(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplate": schema_pkg_apis_application_v1alpha1_ApplicationSetTemplate(ref), "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplateMeta": schema_pkg_apis_application_v1alpha1_ApplicationSetTemplateMeta(ref), @@ -651,6 +656,44 @@ func schema_pkg_apis_application_v1alpha1_ApplicationList(ref common.ReferenceCa } } +func schema_pkg_apis_application_v1alpha1_ApplicationMatchExpression(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "key": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "operator": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "values": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + }, + }, + }, + }, + }, + } +} + func schema_pkg_apis_application_v1alpha1_ApplicationSet(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -699,6 +742,52 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSet(ref common.ReferenceCal } } +func schema_pkg_apis_application_v1alpha1_ApplicationSetApplicationStatus(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ApplicationSetApplicationStatus contains details about each Application managed by the ApplicationSet", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "application": { + SchemaProps: spec.SchemaProps{ + Description: "Application contains the name of the Application resource", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "lastTransitionTime": { + SchemaProps: spec.SchemaProps{ + Description: "LastTransitionTime is the time the status was last updated", + Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.Time"), + }, + }, + "message": { + SchemaProps: spec.SchemaProps{ + Description: "Message contains human-readable message indicating details about the status", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + "status": { + SchemaProps: spec.SchemaProps{ + Description: "Status contains the AppSet's perceived status of the managed Application resource: (Waiting, Pending, Progressing, Healthy)", + Default: "", + Type: []string{"string"}, + Format: "", + }, + }, + }, + Required: []string{"application", "message", "status"}, + }, + }, + Dependencies: []string{ + "k8s.io/apimachinery/pkg/apis/meta/v1.Time"}, + } +} + func schema_pkg_apis_application_v1alpha1_ApplicationSetCondition(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -926,6 +1015,65 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSetNestedGenerator(ref comm } } +func schema_pkg_apis_application_v1alpha1_ApplicationSetRolloutStep(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "matchExpressions": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationMatchExpression"), + }, + }, + }, + }, + }, + "maxUpdate": { + SchemaProps: spec.SchemaProps{ + Ref: ref("k8s.io/apimachinery/pkg/util/intstr.IntOrString"), + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationMatchExpression", "k8s.io/apimachinery/pkg/util/intstr.IntOrString"}, + } +} + +func schema_pkg_apis_application_v1alpha1_ApplicationSetRolloutStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "steps": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRolloutStep"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRolloutStep"}, + } +} + func schema_pkg_apis_application_v1alpha1_ApplicationSetSpec(ref common.ReferenceCallback) common.OpenAPIDefinition { return common.OpenAPIDefinition{ Schema: spec.Schema{ @@ -963,12 +1111,17 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSetSpec(ref common.Referenc Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy"), }, }, + "strategy": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStrategy"), + }, + }, }, Required: []string{"generators", "template"}, }, }, Dependencies: []string{ - "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetGenerator", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplate"}, + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetGenerator", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetStrategy", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetSyncPolicy", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetTemplate"}, } } @@ -993,11 +1146,50 @@ func schema_pkg_apis_application_v1alpha1_ApplicationSetStatus(ref common.Refere }, }, }, + "applicationStatus": { + SchemaProps: spec.SchemaProps{ + Type: []string{"array"}, + Items: &spec.SchemaOrArray{ + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: map[string]interface{}{}, + Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetApplicationStatus"), + }, + }, + }, + }, + }, + }, + }, + }, + Dependencies: []string{ + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetApplicationStatus", "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetCondition"}, + } +} + +func schema_pkg_apis_application_v1alpha1_ApplicationSetStrategy(ref common.ReferenceCallback) common.OpenAPIDefinition { + return common.OpenAPIDefinition{ + Schema: spec.Schema{ + SchemaProps: spec.SchemaProps{ + Description: "ApplicationSetStrategy configures how generated Applications are updated in sequence.", + Type: []string{"object"}, + Properties: map[string]spec.Schema{ + "type": { + SchemaProps: spec.SchemaProps{ + Type: []string{"string"}, + Format: "", + }, + }, + "rollingSync": { + SchemaProps: spec.SchemaProps{ + Ref: ref("github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRolloutStrategy"), + }, + }, }, }, }, Dependencies: []string{ - "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetCondition"}, + "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1.ApplicationSetRolloutStrategy"}, } } diff --git a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go index 3784e1febe465..15cc07f3c19f3 100644 --- a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go @@ -10,6 +10,7 @@ import ( apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" runtime "k8s.io/apimachinery/pkg/runtime" + intstr "k8s.io/apimachinery/pkg/util/intstr" ) // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. @@ -293,6 +294,27 @@ func (in *ApplicationList) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationMatchExpression) DeepCopyInto(out *ApplicationMatchExpression) { + *out = *in + if in.Values != nil { + in, out := &in.Values, &out.Values + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationMatchExpression. +func (in *ApplicationMatchExpression) DeepCopy() *ApplicationMatchExpression { + if in == nil { + return nil + } + out := new(ApplicationMatchExpression) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSet) DeepCopyInto(out *ApplicationSet) { *out = *in @@ -321,6 +343,26 @@ func (in *ApplicationSet) DeepCopyObject() runtime.Object { return nil } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetApplicationStatus) DeepCopyInto(out *ApplicationSetApplicationStatus) { + *out = *in + if in.LastTransitionTime != nil { + in, out := &in.LastTransitionTime, &out.LastTransitionTime + *out = (*in).DeepCopy() + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetApplicationStatus. +func (in *ApplicationSetApplicationStatus) DeepCopy() *ApplicationSetApplicationStatus { + if in == nil { + return nil + } + out := new(ApplicationSetApplicationStatus) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetCondition) DeepCopyInto(out *ApplicationSetCondition) { *out = *in @@ -518,6 +560,57 @@ func (in ApplicationSetNestedGenerators) DeepCopy() ApplicationSetNestedGenerato return *out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetRolloutStep) DeepCopyInto(out *ApplicationSetRolloutStep) { + *out = *in + if in.MatchExpressions != nil { + in, out := &in.MatchExpressions, &out.MatchExpressions + *out = make([]ApplicationMatchExpression, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.MaxUpdate != nil { + in, out := &in.MaxUpdate, &out.MaxUpdate + *out = new(intstr.IntOrString) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetRolloutStep. +func (in *ApplicationSetRolloutStep) DeepCopy() *ApplicationSetRolloutStep { + if in == nil { + return nil + } + out := new(ApplicationSetRolloutStep) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetRolloutStrategy) DeepCopyInto(out *ApplicationSetRolloutStrategy) { + *out = *in + if in.Steps != nil { + in, out := &in.Steps, &out.Steps + *out = make([]ApplicationSetRolloutStep, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetRolloutStrategy. +func (in *ApplicationSetRolloutStrategy) DeepCopy() *ApplicationSetRolloutStrategy { + if in == nil { + return nil + } + out := new(ApplicationSetRolloutStrategy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetSpec) DeepCopyInto(out *ApplicationSetSpec) { *out = *in @@ -534,6 +627,11 @@ func (in *ApplicationSetSpec) DeepCopyInto(out *ApplicationSetSpec) { *out = new(ApplicationSetSyncPolicy) **out = **in } + if in.Strategy != nil { + in, out := &in.Strategy, &out.Strategy + *out = new(ApplicationSetStrategy) + (*in).DeepCopyInto(*out) + } return } @@ -557,6 +655,13 @@ func (in *ApplicationSetStatus) DeepCopyInto(out *ApplicationSetStatus) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.ApplicationStatus != nil { + in, out := &in.ApplicationStatus, &out.ApplicationStatus + *out = make([]ApplicationSetApplicationStatus, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } return } @@ -570,6 +675,27 @@ func (in *ApplicationSetStatus) DeepCopy() *ApplicationSetStatus { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ApplicationSetStrategy) DeepCopyInto(out *ApplicationSetStrategy) { + *out = *in + if in.RollingSync != nil { + in, out := &in.RollingSync, &out.RollingSync + *out = new(ApplicationSetRolloutStrategy) + (*in).DeepCopyInto(*out) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ApplicationSetStrategy. +func (in *ApplicationSetStrategy) DeepCopy() *ApplicationSetStrategy { + if in == nil { + return nil + } + out := new(ApplicationSetStrategy) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ApplicationSetSyncPolicy) DeepCopyInto(out *ApplicationSetSyncPolicy) { *out = *in