From 539e8a47e9ee516ba4db87bbed1b94f412fca638 Mon Sep 17 00:00:00 2001 From: Paul Gottschling Date: Tue, 29 Oct 2024 16:55:10 -0400 Subject: [PATCH 1/5] [v16] Add troubleshooting info to Usage and Billing page (#48081) * Add troubleshooting info to Usage and Billing page Turn the section on validating usage data into the intro paragraph for a troubleshooting section. We don't actually need to compare the usage reporting system to audit events, and removing the comparison makes this information concise enough for an introductory paragraph. Add H2s for issues we have identified with usage reporting and billing on self-hosted clusters. * Fix grammar in the Usage/Billing guide --- docs/pages/usage-billing.mdx | 71 ++++++++++++++++++++++++++---------- 1 file changed, 52 insertions(+), 19 deletions(-) diff --git a/docs/pages/usage-billing.mdx b/docs/pages/usage-billing.mdx index f3a0f1a2ab4c9..fd35fd8e8e048 100644 --- a/docs/pages/usage-billing.mdx +++ b/docs/pages/usage-billing.mdx @@ -64,25 +64,6 @@ Set the `TELEPORT_REPORTING_HTTPS_PROXY` and `TELEPORT_REPORTING_HTTP_PROXY` environment variables to your proxy address. That will apply as the HTTP connect proxy setting overriding `HTTPS_PROXY` and `HTTP_PROXY` just for outbound usage reporting. -### Validating usage reports - -The system that Teleport uses for submitting usage reports is independent of the -system that Teleport uses for submitting audit events. - -Teleport processes submit audit events to the Teleport Auth Service, which -stores them on its audit event backend for retrieval by Teleport API clients. In -contrast, usage reports are aggregated on a submission service that runs either -on self-hosted Teleport infrastructure or Teleport Cloud, depending on the -user's plan. The submission service persists usage reports in the case of a -submission failure. After a successful submission, the submission service -deletes the reports. - -It is not possible for Teleport users to independently validate usage event -data, as there is no way to set up a third-party usage event destination or -retrieve usage events from a Teleport backend. Reach out to -support@goteleport.com if you have questions about usage reporting on your -Teleport account. - ## Billing metrics Teleport uses the anonymized usage data described in the previous section to @@ -144,6 +125,11 @@ to compute a daily TPR. Then we average the daily TPR over a monthly period, which starts on the subscription start date and ends on each monthly anniversary thereafter. +If you recreate a single resource more than once an hour, this will affect the +hourly average. For example, if you were to create then delete 10 servers three +times in one hour, Teleport would display 10 servers at any given time. However, +for the entire hour, Teleport would report 30 protected servers. + ## Usage measurement for billing We aggregate all counts of the billing metrics on a monthly basis starting on @@ -155,3 +141,50 @@ Subscription, also known as a high water mark calculation. Reach out to sales@goteleport.com if you have questions about the commercial editions of Teleport. + +## Troubleshooting usage and billing + +Teleport aggregates usage reports on a submission service that runs either on +self-hosted Teleport infrastructure or Teleport Cloud, depending on the user's +plan. The submission service persists usage reports in the case of a submission +failure, and deletes the reports after a successful submission. It is not +possible to set up a third-party destination for usage events to independently +verify usage event data. + +If you are using Teleport Enterprise (Cloud), your usage data is accurate as +long as Teleport-managed reporting infrastructure works as expected (check the +[status page](https://status.teleport.sh/) for any incidents). On self-hosted +Teleport Enterprise clusters, some conditions can interfere with data reporting. +This section describes some scenarios that can lead to inaccurate data on +self-hosted clusters. + +If you suspect that any of these scenarios describe your Teleport cluster, or +your usage data appears inaccurate, reach out to support@goteleport.com. + +### Multiple Teleport clusters + +In versions older than v14.3.1, Teleport does not de-duplicate users as expected +across multiple Teleport clusters that belong to the same account. If you are +running multiple Teleport clusters with affected versions, the count of active +users may be higher than expected. + +### Unexpected license differences + +When distributing copies of your Teleport Enterprise (Self-Hosted) license +across Auth Service instances, you must not download a license multiple times +from your Teleport account. Instead, you must download a license once and copy +that license across Auth Service instances. Otherwise, the Teleport usage +reporting infrastructure will identify multiple licenses and misrepresent your +usage numbers. + +### SSO users + +In Teleport, single sign-on (SSO) users are +[ephemeral](reference/user-types.mdx#temporary-users). Teleport deletes an SSO user +when its session expires. To count the number of SSO users in your cluster, you +can examine Teleport audit events for unique SSO users that have authenticated +to Teleport during a given time period. The Teleport documentation includes +[how-to guides](./admin-guides/management/export-audit-events.mdx) for +exporting audit events to common log management solutions so you can identify +users that have authenticated using an SSO provider. + From 2e35b37f40221f815e328381576c85634a4d985d Mon Sep 17 00:00:00 2001 From: Forrest <30576607+fspmarshall@users.noreply.github.com> Date: Tue, 29 Oct 2024 17:30:36 -0700 Subject: [PATCH 2/5] switch trusted/remote cluster management to atomic write (#48009) (#48097) --- api/types/trustedcluster.go | 8 + lib/auth/trustedcluster.go | 295 +++++++---------- lib/auth/trustedcluster_test.go | 17 +- lib/services/local/trust.go | 531 ++++++++++++++++++++++++++----- lib/services/local/trust_test.go | 330 ++++++++++++++++++- lib/services/trust.go | 20 ++ 6 files changed, 916 insertions(+), 285 deletions(-) diff --git a/api/types/trustedcluster.go b/api/types/trustedcluster.go index 7e233c864c826..27d8129f70cfe 100644 --- a/api/types/trustedcluster.go +++ b/api/types/trustedcluster.go @@ -22,6 +22,8 @@ import ( "time" "github.com/gravitational/trace" + + "github.com/gravitational/teleport/api/utils" ) // TrustedCluster holds information needed for a cluster that can not be directly @@ -60,6 +62,8 @@ type TrustedCluster interface { SetReverseTunnelAddress(string) // CanChangeStateTo checks the TrustedCluster can transform into another. CanChangeStateTo(TrustedCluster) error + // Clone returns a deep copy of the TrustedCluster. + Clone() TrustedCluster } // NewTrustedCluster is a convenience way to create a TrustedCluster resource. @@ -259,6 +263,10 @@ func (c *TrustedClusterV2) CanChangeStateTo(t TrustedCluster) error { return nil } +func (c *TrustedClusterV2) Clone() TrustedCluster { + return utils.CloneProtoMsg(c) +} + // String represents a human readable version of trusted cluster settings. func (c *TrustedClusterV2) String() string { return fmt.Sprintf("TrustedCluster(Enabled=%v,Roles=%v,Token=%v,ProxyAddress=%v,ReverseTunnelAddress=%v)", diff --git a/lib/auth/trustedcluster.go b/lib/auth/trustedcluster.go index 7433c2680d9ab..4bbf2cf61cb4e 100644 --- a/lib/auth/trustedcluster.go +++ b/lib/auth/trustedcluster.go @@ -21,6 +21,7 @@ package auth import ( "context" "encoding/json" + "log/slog" "net/http" "net/url" "strings" @@ -45,129 +46,115 @@ import ( ) // UpsertTrustedCluster creates or toggles a Trusted Cluster relationship. -func (a *Server) UpsertTrustedCluster(ctx context.Context, trustedCluster types.TrustedCluster) (newTrustedCluster types.TrustedCluster, returnErr error) { +func (a *Server) UpsertTrustedCluster(ctx context.Context, tc types.TrustedCluster) (newTrustedCluster types.TrustedCluster, returnErr error) { + // verify that trusted cluster role map does not reference non-existent roles + if err := a.checkLocalRoles(ctx, tc.GetRoleMap()); err != nil { + return nil, trace.Wrap(err) + } + // It is recommended to omit trusted cluster name because the trusted cluster name // is updated to the roots cluster name during the handshake with the root cluster. var existingCluster types.TrustedCluster - if trustedCluster.GetName() != "" { + var cas []types.CertAuthority + if tc.GetName() != "" { var err error - existingCluster, err = a.GetTrustedCluster(ctx, trustedCluster.GetName()) + existingCluster, err = a.GetTrustedCluster(ctx, tc.GetName()) if err != nil && !trace.IsNotFound(err) { return nil, trace.Wrap(err) } } - enable := trustedCluster.GetEnabled() - - // If the trusted cluster already exists in the backend, make sure it's a - // valid state change client is trying to make. - if existingCluster != nil { - if err := existingCluster.CanChangeStateTo(trustedCluster); err != nil { - return nil, trace.Wrap(err) - } + // if there is no existing cluster, switch to the create case + if existingCluster == nil { + return a.createTrustedCluster(ctx, tc) } - logger := log.WithField("trusted_cluster", trustedCluster.GetName()) + if err := existingCluster.CanChangeStateTo(tc); err != nil { + return nil, trace.Wrap(err) + } - // change state - if err := a.checkLocalRoles(ctx, trustedCluster.GetRoleMap()); err != nil { + // always load all current CAs. even if we aren't changing them as part of + // this function, Services.UpdateTrustedCluster will only correctly activate/deactivate + // CAs that are explicitly passed to it. note that we pass in the existing cluster state + // since where CAs are stored depends on the current state of the trusted cluster. + cas, err := a.getCAsForTrustedCluster(ctx, existingCluster) + if err != nil { return nil, trace.Wrap(err) } - // Update role map - if existingCluster != nil && !existingCluster.GetRoleMap().IsEqual(trustedCluster.GetRoleMap()) { - if err := a.UpdateUserCARoleMap(ctx, existingCluster.GetName(), trustedCluster.GetRoleMap(), - existingCluster.GetEnabled()); err != nil { - return nil, trace.Wrap(err) - } + // propagate any role map changes to cas + configureCAsForTrustedCluster(tc, cas) - // Reset previous UserCA role map if this func fails later on - defer func() { - if returnErr != nil { - if err := a.UpdateUserCARoleMap(ctx, trustedCluster.GetName(), existingCluster.GetRoleMap(), - trustedCluster.GetEnabled()); err != nil { - returnErr = trace.NewAggregate(err, returnErr) - } - } - }() - } - // Create or update state - switch { - case existingCluster != nil && enable == true: - if existingCluster.GetEnabled() { - break - } - log.Debugf("Enabling existing Trusted Cluster relationship.") + // state transition is valid, set the expected revision + tc.SetRevision(existingCluster.GetRevision()) - if err := a.activateCertAuthority(ctx, trustedCluster); err != nil { - if trace.IsNotFound(err) { - return nil, trace.BadParameter("enable only supported for Trusted Clusters created with Teleport 2.3 and above") - } - return nil, trace.Wrap(err) - } + revision, err := a.Services.UpdateTrustedCluster(ctx, tc, cas) + if err != nil { + return nil, trace.Wrap(err) + } - if err := a.createReverseTunnel(trustedCluster); err != nil { - return nil, trace.Wrap(err) - } - case existingCluster != nil && enable == false: - if !existingCluster.GetEnabled() { - break - } - log.Debugf("Disabling existing Trusted Cluster relationship.") + tc.SetRevision(revision) - if err := a.deactivateCertAuthority(ctx, trustedCluster); err != nil { - if trace.IsNotFound(err) { - return nil, trace.BadParameter("enable only supported for Trusted Clusters created with Teleport 2.3 and above") - } - return nil, trace.Wrap(err) - } + if err := a.onTrustedClusterWrite(ctx, tc); err != nil { + return nil, trace.Wrap(err) + } - if err := a.DeleteReverseTunnel(trustedCluster.GetName()); err != nil { - return nil, trace.Wrap(err) - } - case existingCluster == nil && enable == true: - logger.Info("Creating enabled Trusted Cluster relationship.") + return tc, nil +} - remoteCAs, err := a.establishTrust(ctx, trustedCluster) - if err != nil { - return nil, trace.Wrap(err) - } +func (a *Server) createTrustedCluster(ctx context.Context, tc types.TrustedCluster) (types.TrustedCluster, error) { + remoteCAs, err := a.establishTrust(ctx, tc) + if err != nil { + return nil, trace.Wrap(err) + } - // Force name of the trusted cluster resource - // to be equal to the name of the remote cluster it is connecting to. - trustedCluster.SetName(remoteCAs[0].GetClusterName()) + // Force name to the name of the trusted cluster. + tc.SetName(remoteCAs[0].GetClusterName()) - if err := a.addCertAuthorities(ctx, trustedCluster, remoteCAs); err != nil { - return nil, trace.Wrap(err) - } + // perform some configuration on the remote CAs + configureCAsForTrustedCluster(tc, remoteCAs) - if err := a.createReverseTunnel(trustedCluster); err != nil { - return nil, trace.Wrap(err) - } + // atomically create trusted cluster and cert authorities + revision, err := a.Services.CreateTrustedCluster(ctx, tc, remoteCAs) + if err != nil { + return nil, trace.Wrap(err) + } - case existingCluster == nil && enable == false: - logger.Info("Creating disabled Trusted Cluster relationship.") + tc.SetRevision(revision) - remoteCAs, err := a.establishTrust(ctx, trustedCluster) - if err != nil { - return nil, trace.Wrap(err) - } + if err := a.onTrustedClusterWrite(ctx, tc); err != nil { + return nil, trace.Wrap(err) + } - // Force name to the name of the trusted cluster. - trustedCluster.SetName(remoteCAs[0].GetClusterName()) + return tc, nil +} - if err := a.addCertAuthorities(ctx, trustedCluster, remoteCAs); err != nil { - return nil, trace.Wrap(err) - } +// configureCAsForTrustedCluster modifies remote CAs for use as trusted cluster CAs. +func configureCAsForTrustedCluster(tc types.TrustedCluster, cas []types.CertAuthority) { + // modify the remote CAs for use as tc cas. + for _, ca := range cas { + // change the name of the remote ca to the name of the trusted cluster. + ca.SetName(tc.GetName()) - if err := a.deactivateCertAuthority(ctx, trustedCluster); err != nil { - return nil, trace.Wrap(err) + // wipe out roles sent from the remote cluster and set roles from the trusted cluster + ca.SetRoles(nil) + if ca.GetType() == types.UserCA { + for _, r := range tc.GetRoles() { + ca.AddRole(r) + } + ca.SetRoleMap(tc.GetRoleMap()) } } +} - tc, err := a.Services.UpsertTrustedCluster(ctx, trustedCluster) - if err != nil { - return nil, trace.Wrap(err) +func (a *Server) onTrustedClusterWrite(ctx context.Context, tc types.TrustedCluster) error { + var cerr error + if tc.GetEnabled() { + cerr = a.createReverseTunnel(tc) + } else { + if err := a.DeleteReverseTunnel(tc.GetName()); err != nil && !trace.IsNotFound(err) { + cerr = err + } } if err := a.emitter.EmitAuditEvent(ctx, &apievents.TrustedClusterCreate{ @@ -177,14 +164,14 @@ func (a *Server) UpsertTrustedCluster(ctx context.Context, trustedCluster types. }, UserMetadata: authz.ClientUserMetadata(ctx), ResourceMetadata: apievents.ResourceMetadata{ - Name: trustedCluster.GetName(), + Name: tc.GetName(), }, ConnectionMetadata: authz.ConnectionMetadata(ctx), }); err != nil { - logger.WithError(err).Warn("Failed to emit trusted cluster create event.") + slog.WarnContext(ctx, "failed to emit trusted cluster create event", "error", err) } - return tc, nil + return trace.Wrap(cerr) } func (a *Server) checkLocalRoles(ctx context.Context, roleMap types.RoleMap) error { @@ -207,6 +194,29 @@ func (a *Server) checkLocalRoles(ctx context.Context, roleMap types.RoleMap) err return nil } +func (a *Server) getCAsForTrustedCluster(ctx context.Context, tc types.TrustedCluster) ([]types.CertAuthority, error) { + var cas []types.CertAuthority + // not all CA types are present for trusted clusters, but there isn't a meaningful downside to + // just grabbing everything. + for _, caType := range types.CertAuthTypes { + var ca types.CertAuthority + var err error + if tc.GetEnabled() { + ca, err = a.GetCertAuthority(ctx, types.CertAuthID{Type: caType, DomainName: tc.GetName()}, false) + } else { + ca, err = a.GetInactiveCertAuthority(ctx, types.CertAuthID{Type: caType, DomainName: tc.GetName()}, false) + } + if err != nil { + if trace.IsNotFound(err) { + continue + } + return nil, trace.Wrap(err) + } + cas = append(cas, ca) + } + return cas, nil +} + // DeleteTrustedCluster removes types.CertAuthority, services.ReverseTunnel, // and services.TrustedCluster resources. func (a *Server) DeleteTrustedCluster(ctx context.Context, name string) error { @@ -229,7 +239,7 @@ func (a *Server) DeleteTrustedCluster(ctx context.Context, name string) error { }) } - if err := a.DeleteCertAuthorities(ctx, ids...); err != nil { + if err := a.Services.DeleteTrustedClusterInternal(ctx, name, ids); err != nil { return trace.Wrap(err) } @@ -239,10 +249,6 @@ func (a *Server) DeleteTrustedCluster(ctx context.Context, name string) error { } } - if err := a.Services.DeleteTrustedCluster(ctx, name); err != nil { - return trace.Wrap(err) - } - if err := a.emitter.EmitAuditEvent(ctx, &apievents.TrustedClusterDelete{ Metadata: apievents.Metadata{ Type: events.TrustedClusterDeleteEvent, @@ -324,54 +330,30 @@ func (a *Server) establishTrust(ctx context.Context, trustedCluster types.Truste return validateResponse.CAs, nil } -func (a *Server) addCertAuthorities(ctx context.Context, trustedCluster types.TrustedCluster, remoteCAs []types.CertAuthority) error { - // the remote auth server has verified our token. add the - // remote certificate authority to our backend - for _, remoteCertAuthority := range remoteCAs { - // change the name of the remote ca to the name of the trusted cluster - remoteCertAuthority.SetName(trustedCluster.GetName()) - - // wipe out roles sent from the remote cluster and set roles from the trusted cluster - remoteCertAuthority.SetRoles(nil) - if remoteCertAuthority.GetType() == types.UserCA { - for _, r := range trustedCluster.GetRoles() { - remoteCertAuthority.AddRole(r) - } - remoteCertAuthority.SetRoleMap(trustedCluster.GetRoleMap()) - } - } - - // we use create here instead of upsert to prevent people from wiping out - // their own ca if it has the same name as the remote ca - _, err := a.CreateCertAuthorities(ctx, remoteCAs...) - return trace.Wrap(err) -} - // DeleteRemoteCluster deletes remote cluster resource, all certificate authorities // associated with it -func (a *Server) DeleteRemoteCluster(ctx context.Context, clusterName string) error { - // To make sure remote cluster exists - to protect against random - // clusterName requests (e.g. when clusterName is set to local cluster name) - if _, err := a.GetRemoteCluster(ctx, clusterName); err != nil { +func (a *Server) DeleteRemoteCluster(ctx context.Context, name string) error { + cn, err := a.GetClusterName() + if err != nil { return trace.Wrap(err) } + // This check ensures users are not deleting their root/own cluster. + if cn.GetClusterName() == name { + return trace.BadParameter("remote cluster %q is the name of this root cluster and cannot be removed.", name) + } + // we only expect host CAs to be present for remote clusters, but it doesn't hurt // to err on the side of paranoia and delete all CA types. var ids []types.CertAuthID for _, caType := range types.CertAuthTypes { ids = append(ids, types.CertAuthID{ Type: caType, - DomainName: clusterName, + DomainName: name, }) } - // delete cert authorities associated with the cluster - if err := a.DeleteCertAuthorities(ctx, ids...); err != nil { - return trace.Wrap(err) - } - - return trace.Wrap(a.Services.DeleteRemoteCluster(ctx, clusterName)) + return trace.Wrap(a.Services.DeleteRemoteClusterInternal(ctx, name, ids)) } // GetRemoteCluster returns remote cluster by name @@ -497,12 +479,6 @@ func (a *Server) validateTrustedCluster(ctx context.Context, validateRequest *au if remoteClusterName == domainName { return nil, trace.AccessDenied("remote cluster has same name as this cluster: %v", domainName) } - _, err = a.GetTrustedCluster(ctx, remoteClusterName) - if err == nil { - return nil, trace.AccessDenied("remote cluster has same name as trusted cluster: %v", remoteClusterName) - } else if !trace.IsNotFound(err) { - return nil, trace.Wrap(err) - } remoteCluster, err := types.NewRemoteCluster(remoteClusterName) if err != nil { @@ -522,15 +498,8 @@ func (a *Server) validateTrustedCluster(ctx context.Context, validateRequest *au } remoteCluster.SetConnectionStatus(teleport.RemoteClusterStatusOffline) - _, err = a.CreateRemoteCluster(ctx, remoteCluster) - if err != nil { - if !trace.IsAlreadyExists(err) { - return nil, trace.Wrap(err) - } - } - - err = a.UpsertCertAuthority(ctx, remoteCA) - if err != nil { + _, err = a.CreateRemoteClusterInternal(ctx, remoteCluster, []types.CertAuthority{remoteCA}) + if err != nil && !trace.IsAlreadyExists(err) { return nil, trace.Wrap(err) } @@ -641,36 +610,6 @@ func (a *Server) sendValidateRequestToProxy(host string, validateRequest *authcl return validateResponse, nil } -// activateCertAuthority will activate both the user and host certificate -// authority given in the services.TrustedCluster resource. -func (a *Server) activateCertAuthority(ctx context.Context, t types.TrustedCluster) error { - return trace.Wrap(a.ActivateCertAuthorities(ctx, []types.CertAuthID{ - { - Type: types.UserCA, - DomainName: t.GetName(), - }, - { - Type: types.HostCA, - DomainName: t.GetName(), - }, - }...)) -} - -// deactivateCertAuthority will deactivate both the user and host certificate -// authority given in the services.TrustedCluster resource. -func (a *Server) deactivateCertAuthority(ctx context.Context, t types.TrustedCluster) error { - return trace.Wrap(a.DeactivateCertAuthorities(ctx, []types.CertAuthID{ - { - Type: types.UserCA, - DomainName: t.GetName(), - }, - { - Type: types.HostCA, - DomainName: t.GetName(), - }, - }...)) -} - // createReverseTunnel will create a services.ReverseTunnel givenin the // services.TrustedCluster resource. func (a *Server) createReverseTunnel(t types.TrustedCluster) error { diff --git a/lib/auth/trustedcluster_test.go b/lib/auth/trustedcluster_test.go index ee7f52c7a89ae..61da68dd4dab3 100644 --- a/lib/auth/trustedcluster_test.go +++ b/lib/auth/trustedcluster_test.go @@ -469,22 +469,11 @@ func TestUpsertTrustedCluster(t *testing.T) { }) require.NoError(t, err) - leafClusterCA := types.CertAuthority(suite.NewTestCA(types.HostCA, "trustedcluster")) - _, err = a.validateTrustedCluster(ctx, &authclient.ValidateTrustedClusterRequest{ - Token: validToken, - CAs: []types.CertAuthority{leafClusterCA}, - TeleportVersion: teleport.Version, - }) - require.NoError(t, err) - - _, err = a.Services.UpsertTrustedCluster(ctx, trustedCluster) - require.NoError(t, err) - ca := suite.NewTestCA(types.UserCA, "trustedcluster") - err = a.addCertAuthorities(ctx, trustedCluster, []types.CertAuthority{ca}) - require.NoError(t, err) - err = a.UpsertCertAuthority(ctx, ca) + configureCAsForTrustedCluster(trustedCluster, []types.CertAuthority{ca}) + + _, err = a.Services.CreateTrustedCluster(ctx, trustedCluster, []types.CertAuthority{ca}) require.NoError(t, err) err = a.createReverseTunnel(trustedCluster) diff --git a/lib/services/local/trust.go b/lib/services/local/trust.go index 5ceaf0d3c1545..2a2e454cdcb19 100644 --- a/lib/services/local/trust.go +++ b/lib/services/local/trust.go @@ -20,7 +20,6 @@ package local import ( "context" - "encoding/json" "errors" "log/slog" "slices" @@ -67,44 +66,164 @@ func (s *CA) CreateCertAuthority(ctx context.Context, ca types.CertAuthority) er // CreateCertAuthorities creates multiple cert authorities atomically. func (s *CA) CreateCertAuthorities(ctx context.Context, cas ...types.CertAuthority) (revision string, err error) { - var condacts []backend.ConditionalAction - var clusterNames []string - for _, ca := range cas { - if !slices.Contains(clusterNames, ca.GetName()) { - clusterNames = append(clusterNames, ca.GetName()) + condacts, err := createCertAuthoritiesCondActs(cas, true /* active */) + if err != nil { + return "", trace.Wrap(err) + } + + rev, err := s.AtomicWrite(ctx, condacts) + if err != nil { + if errors.Is(err, backend.ErrConditionFailed) { + var clusterNames []string + for _, ca := range cas { + if slices.Contains(clusterNames, ca.GetClusterName()) { + continue + } + clusterNames = append(clusterNames, ca.GetClusterName()) + } + return "", trace.AlreadyExists("one or more CAs from cluster(s) %q already exist", strings.Join(clusterNames, ",")) } + return "", trace.Wrap(err) + } + + return rev, nil +} + +// createCertAuthoritiesCondActs sets up conditional actions for creating a set of CAs. +func createCertAuthoritiesCondActs(cas []types.CertAuthority, active bool) ([]backend.ConditionalAction, error) { + condacts := make([]backend.ConditionalAction, 0, len(cas)*2) + for _, ca := range cas { if err := services.ValidateCertAuthority(ca); err != nil { - return "", trace.Wrap(err) + return nil, trace.Wrap(err) } - item, err := caToItem(nil, ca) + item, err := caToItem(backend.Key{}, ca) if err != nil { - return "", trace.Wrap(err) + return nil, trace.Wrap(err) } - condacts = append(condacts, []backend.ConditionalAction{ - { - Key: activeCAKey(ca.GetID()), - Condition: backend.NotExists(), - Action: backend.Put(item), - }, - { - Key: inactiveCAKey(ca.GetID()), - Condition: backend.Whatever(), - Action: backend.Delete(), - }, - }...) + if active { + // for an enabled tc, we perform a conditional create for the active CA key + // and an unconditional delete for the inactive CA key since the active range + // is given priority over the inactive range. + condacts = append(condacts, []backend.ConditionalAction{ + { + Key: activeCAKey(ca.GetID()), + Condition: backend.NotExists(), + Action: backend.Put(item), + }, + { + Key: inactiveCAKey(ca.GetID()), + Condition: backend.Whatever(), + Action: backend.Delete(), + }, + }...) + } else { + // for a disabled tc, we perform a conditional create for the inactive CA key + // and assert the non-existence of the active CA key. + condacts = append(condacts, []backend.ConditionalAction{ + { + Key: inactiveCAKey(ca.GetID()), + Condition: backend.NotExists(), + Action: backend.Put(item), + }, + { + Key: activeCAKey(ca.GetID()), + Condition: backend.NotExists(), + Action: backend.Nop(), + }, + }...) + } } - rev, err := s.AtomicWrite(ctx, condacts) - if err != nil { - if errors.Is(err, backend.ErrConditionFailed) { - return "", trace.AlreadyExists("one or more CAs from cluster(s) %q already exist", strings.Join(clusterNames, ",")) + return condacts, nil +} + +func updateCertAuthoritiesCondActs(cas []types.CertAuthority, active bool, currentlyActive bool) ([]backend.ConditionalAction, error) { + condacts := make([]backend.ConditionalAction, 0, len(cas)*2) + for _, ca := range cas { + if err := services.ValidateCertAuthority(ca); err != nil { + return nil, trace.Wrap(err) + } + + item, err := caToItem(backend.Key{}, ca) + if err != nil { + return nil, trace.Wrap(err) + } + + if active { + if currentlyActive { + // we are updating an active CA without changing its active status. we want to perform + // a conditional update on the acitve CA key and an unconditonal delete on the inactive + // CA key in order to correctly model active range priority. + condacts = append(condacts, []backend.ConditionalAction{ + { + Key: activeCAKey(ca.GetID()), + Condition: backend.Revision(item.Revision), + Action: backend.Put(item), + }, + { + Key: inactiveCAKey(ca.GetID()), + Condition: backend.Whatever(), + Action: backend.Delete(), + }, + }...) + } else { + // we are updating a currently inactive CA to the active state. we want to perform + // a create on the active CA key and a revision-conditional delete on the inactive CA key + // to affect a "move-and-update" that respects the active range priority. + condacts = append(condacts, []backend.ConditionalAction{ + { + Key: activeCAKey(ca.GetID()), + Condition: backend.NotExists(), + Action: backend.Put(item), + }, + { + Key: inactiveCAKey(ca.GetID()), + Condition: backend.Revision(item.Revision), + Action: backend.Delete(), + }, + }...) + } + } else { + if currentlyActive { + // we are updating an active CA to the inactive state. we want to perform a conditional + // delete on the active CA key and an unconditional put on the inactive CA key to + // affect a "move-and-update" that respects the active range priority. + condacts = append(condacts, []backend.ConditionalAction{ + { + Key: activeCAKey(ca.GetID()), + Condition: backend.Revision(item.Revision), + Action: backend.Delete(), + }, + { + Key: inactiveCAKey(ca.GetID()), + Condition: backend.Whatever(), + Action: backend.Put(item), + }, + }...) + + } else { + // we are updating an inactive CA without changing its active status. we want to perform + // a conditional update on the inactive CA key and assert the non-existence of the active + // CA key. + condacts = append(condacts, []backend.ConditionalAction{ + { + Key: inactiveCAKey(ca.GetID()), + Condition: backend.Revision(item.Revision), + Action: backend.Put(item), + }, + { + Key: activeCAKey(ca.GetID()), + Condition: backend.NotExists(), + Action: backend.Nop(), + }, + }...) + } } - return "", trace.Wrap(err) } - return rev, nil + return condacts, nil } // UpsertCertAuthority updates or inserts a new certificate authority @@ -198,10 +317,15 @@ func (s *CA) DeleteCertAuthority(ctx context.Context, id types.CertAuthID) error // DeleteCertAuthorities deletes multiple cert authorities atomically. func (s *CA) DeleteCertAuthorities(ctx context.Context, ids ...types.CertAuthID) error { + _, err := s.AtomicWrite(ctx, s.deleteCertAuthoritiesCondActs(ids)) + return trace.Wrap(err) +} + +func (s *CA) deleteCertAuthoritiesCondActs(ids []types.CertAuthID) []backend.ConditionalAction { var condacts []backend.ConditionalAction for _, id := range ids { if err := id.Check(); err != nil { - return trace.Wrap(err) + continue } for _, key := range []backend.Key{activeCAKey(id), inactiveCAKey(id)} { condacts = append(condacts, backend.ConditionalAction{ @@ -211,9 +335,7 @@ func (s *CA) DeleteCertAuthorities(ctx context.Context, ids ...types.CertAuthID) }) } } - - _, err := s.AtomicWrite(ctx, condacts) - return trace.Wrap(err) + return condacts } // ActivateCertAuthority moves a CertAuthority from the deactivated list to @@ -325,10 +447,26 @@ func (s *CA) DeactivateCertAuthorities(ctx context.Context, ids ...types.CertAut // GetCertAuthority returns certificate authority by given id. Parameter loadSigningKeys // controls if signing keys are loaded func (s *CA) GetCertAuthority(ctx context.Context, id types.CertAuthID, loadSigningKeys bool) (types.CertAuthority, error) { + return s.getCertAuthority(ctx, id, loadSigningKeys, true /* active */) +} + +// GetInactiveCertAuthority returns inactive certificate authority by given id. Parameter loadSigningKeys +// controls if signing keys are loaded. +func (s *CA) GetInactiveCertAuthority(ctx context.Context, id types.CertAuthID, loadSigningKeys bool) (types.CertAuthority, error) { + return s.getCertAuthority(ctx, id, loadSigningKeys, false /* inactive */) +} + +func (s *CA) getCertAuthority(ctx context.Context, id types.CertAuthID, loadSigningKeys bool, active bool) (types.CertAuthority, error) { if err := id.Check(); err != nil { return nil, trace.Wrap(err) } - item, err := s.Get(ctx, activeCAKey(id)) + + key := activeCAKey(id) + if !active { + key = inactiveCAKey(id) + } + + item, err := s.Get(ctx, key) if err != nil { return nil, trace.Wrap(err) } @@ -425,25 +563,135 @@ func (s *CA) UpdateUserCARoleMap(ctx context.Context, name string, roleMap types return nil } +// CreateTrustedCluster atomically creates a new trusted cluster along with associated resources. +func (s *CA) CreateTrustedCluster(ctx context.Context, tc types.TrustedCluster, cas []types.CertAuthority) (revision string, err error) { + if err := services.ValidateTrustedCluster(tc); err != nil { + return "", trace.Wrap(err) + } + + item, err := trustedClusterToItem(tc) + if err != nil { + return "", trace.Wrap(err) + } + + condacts := []backend.ConditionalAction{ + { + Key: item.Key, + Condition: backend.NotExists(), + Action: backend.Put(item), + }, + // also assert that no remote cluster exists by this name, as + // we currently do not allow for a trusted cluster and remote + // cluster to share a name (CAs end up stored at the same location). + { + Key: remoteClusterKey(tc.GetName()), + Condition: backend.NotExists(), + Action: backend.Nop(), + }, + } + + // perform some initial trusted-cluster related validation. common ca validation is handled later + // on by the createCertAuthoritiesCondActs helper. + for _, ca := range cas { + if tc.GetName() != ca.GetClusterName() { + return "", trace.BadParameter("trusted cluster name %q does not match CA cluster name %q", tc.GetName(), ca.GetClusterName()) + } + } + + ccas, err := createCertAuthoritiesCondActs(cas, tc.GetEnabled()) + if err != nil { + return "", trace.Wrap(err) + } + + condacts = append(condacts, ccas...) + + rev, err := s.AtomicWrite(ctx, condacts) + if err != nil { + if errors.Is(err, backend.ErrConditionFailed) { + if _, err := s.GetRemoteCluster(ctx, tc.GetName()); err == nil { + return "", trace.BadParameter("cannot create trusted cluster with same name as remote cluster %q, bidirectional trust is not supported", tc.GetName()) + } + + return "", trace.AlreadyExists("trusted cluster %q and/or one or more of its cert authorities already exists", tc.GetName()) + } + return "", trace.Wrap(err) + } + + return rev, nil +} + +// UpdateTrustedCluster atomically updates a trusted cluster along with associated resources. +func (s *CA) UpdateTrustedCluster(ctx context.Context, tc types.TrustedCluster, cas []types.CertAuthority) (revision string, err error) { + if err := services.ValidateTrustedCluster(tc); err != nil { + return "", trace.Wrap(err) + } + + // fetch the current state. we'll need this later on to correctly construct our CA condacts, and + // it doesn't hurt to reject mismatched revisions early. + extant, err := s.GetTrustedCluster(ctx, tc.GetName()) + if err != nil { + return "", trace.Wrap(err) + } + + if tc.GetRevision() != extant.GetRevision() { + return "", trace.CompareFailed("trusted cluster %q has been modified, please retry", tc.GetName()) + } + + item, err := trustedClusterToItem(tc) + if err != nil { + return "", trace.Wrap(err) + } + + condacts := []backend.ConditionalAction{ + { + Key: item.Key, + Condition: backend.Revision(item.Revision), + Action: backend.Put(item), + }, + } + + // perform some initial trusted-cluster related validation. common ca validation is handled later + // on by the createCertAuthoritiesCondActs helper. + for _, ca := range cas { + if tc.GetName() != ca.GetClusterName() { + return "", trace.BadParameter("trusted cluster name %q does not match CA cluster name %q", tc.GetName(), ca.GetClusterName()) + } + } + + ccas, err := updateCertAuthoritiesCondActs(cas, tc.GetEnabled(), extant.GetEnabled()) + if err != nil { + return "", trace.Wrap(err) + } + + condacts = append(condacts, ccas...) + + rev, err := s.AtomicWrite(ctx, condacts) + if err != nil { + if errors.Is(err, backend.ErrConditionFailed) { + return "", trace.CompareFailed("trusted cluster %q and/or one or more of its cert authorities have been modified, please retry", tc.GetName()) + } + return "", trace.Wrap(err) + } + + return rev, nil +} + // UpsertTrustedCluster creates or updates a TrustedCluster in the backend. func (s *CA) UpsertTrustedCluster(ctx context.Context, trustedCluster types.TrustedCluster) (types.TrustedCluster, error) { if err := services.ValidateTrustedCluster(trustedCluster); err != nil { return nil, trace.Wrap(err) } - rev := trustedCluster.GetRevision() - value, err := services.MarshalTrustedCluster(trustedCluster) + + item, err := trustedClusterToItem(trustedCluster) if err != nil { return nil, trace.Wrap(err) } - _, err = s.Put(ctx, backend.Item{ - Key: backend.NewKey(trustedClustersPrefix, trustedCluster.GetName()), - Value: value, - Expires: trustedCluster.Expiry(), - Revision: rev, - }) + + _, err = s.Put(ctx, item) if err != nil { return nil, trace.Wrap(err) } + return trustedCluster, nil } @@ -482,16 +730,44 @@ func (s *CA) GetTrustedClusters(ctx context.Context) ([]types.TrustedCluster, er // DeleteTrustedCluster removes a TrustedCluster from the backend by name. func (s *CA) DeleteTrustedCluster(ctx context.Context, name string) error { + return s.DeleteTrustedClusterInternal(ctx, name, nil /* no cert authorities */) +} + +// DeleteTrustedClusterInternal removes a trusted cluster and associated resources atomically. +func (s *CA) DeleteTrustedClusterInternal(ctx context.Context, name string, caIDs []types.CertAuthID) error { if name == "" { return trace.BadParameter("missing trusted cluster name") } - err := s.Delete(ctx, backend.NewKey(trustedClustersPrefix, name)) - if err != nil { - if trace.IsNotFound(err) { + + for _, id := range caIDs { + if err := id.Check(); err != nil { + return trace.Wrap(err) + } + + if id.DomainName != name { + return trace.BadParameter("ca %q does not belong to trusted cluster %q", id.DomainName, name) + } + } + + condacts := []backend.ConditionalAction{ + { + Key: backend.NewKey(trustedClustersPrefix, name), + Condition: backend.Exists(), + Action: backend.Delete(), + }, + } + + condacts = append(condacts, s.deleteCertAuthoritiesCondActs(caIDs)...) + + if _, err := s.AtomicWrite(ctx, condacts); err != nil { + if errors.Is(err, backend.ErrConditionFailed) { return trace.NotFound("trusted cluster %q is not found", name) } + + return trace.Wrap(err) } - return trace.Wrap(err) + + return nil } // UpsertTunnelConnection updates or creates tunnel connection @@ -608,25 +884,71 @@ func (s *CA) DeleteAllTunnelConnections() error { return trace.Wrap(err) } -// CreateRemoteCluster creates remote cluster -func (s *CA) CreateRemoteCluster( - ctx context.Context, rc types.RemoteCluster, -) (types.RemoteCluster, error) { - value, err := json.Marshal(rc) +// CreateRemoteCluster creates a remote cluster +func (s *CA) CreateRemoteCluster(ctx context.Context, rc types.RemoteCluster) (types.RemoteCluster, error) { + rev, err := s.CreateRemoteClusterInternal(ctx, rc, nil) if err != nil { return nil, trace.Wrap(err) } - item := backend.Item{ - Key: backend.NewKey(remoteClustersPrefix, rc.GetName()), - Value: value, - Expires: rc.Expiry(), + + rc.SetRevision(rev) + return rc, nil +} + +// CreateRemoteCluster atomically creates a new remote cluster along with associated resources. +func (s *CA) CreateRemoteClusterInternal(ctx context.Context, rc types.RemoteCluster, cas []types.CertAuthority) (revision string, err error) { + if err := services.CheckAndSetDefaults(rc); err != nil { + return "", trace.Wrap(err) } - lease, err := s.Create(ctx, item) + + item, err := remoteClusterToItem(rc) if err != nil { - return nil, trace.Wrap(err) + return "", trace.Wrap(err) } - rc.SetRevision(lease.Revision) - return rc, nil + + condacts := []backend.ConditionalAction{ + { + Key: item.Key, + Condition: backend.NotExists(), + Action: backend.Put(item), + }, + // also assert that no trusted cluster exists by this name, as + // we currently do not allow for a trusted cluster and remote + // cluster to share a name (CAs end up stored at the same location). + { + Key: trustedClusterKey(rc.GetName()), + Condition: backend.NotExists(), + Action: backend.Nop(), + }, + } + + // perform some initial remote-cluster related validation. common ca validation is handled later + // on by the createCertAuthoritiesCondActs helper. + for _, ca := range cas { + if rc.GetName() != ca.GetClusterName() { + return "", trace.BadParameter("remote cluster name %q does not match CA cluster name %q", rc.GetName(), ca.GetClusterName()) + } + } + + ccas, err := createCertAuthoritiesCondActs(cas, true /* remote cluster cas always considered active */) + if err != nil { + return "", trace.Wrap(err) + } + + condacts = append(condacts, ccas...) + + rev, err := s.AtomicWrite(ctx, condacts) + if err != nil { + if errors.Is(err, backend.ErrConditionFailed) { + if _, err := s.GetTrustedCluster(ctx, rc.GetName()); err == nil { + return "", trace.BadParameter("cannot create remote cluster with same name as trusted cluster %q, bidirectional trust is not supported", rc.GetName()) + } + return "", trace.AlreadyExists("remote cluster %q and/or one or more of its cert authorities already exists", rc.GetName()) + } + return "", trace.Wrap(err) + } + + return rev, nil } // UpdateRemoteCluster updates selected remote cluster fields: expiry and labels @@ -652,17 +974,12 @@ func (s *CA) UpdateRemoteCluster(ctx context.Context, rc types.RemoteCluster) (t existing.SetConnectionStatus(rc.GetConnectionStatus()) existing.SetMetadata(rc.GetMetadata()) - updateValue, err := services.MarshalRemoteCluster(existing) + item, err := remoteClusterToItem(existing) if err != nil { return nil, trace.Wrap(err) } - lease, err := s.ConditionalUpdate(ctx, backend.Item{ - Key: backend.NewKey(remoteClustersPrefix, existing.GetName()), - Value: updateValue, - Expires: existing.Expiry(), - Revision: existing.GetRevision(), - }) + lease, err := s.ConditionalUpdate(ctx, item) if err != nil { if trace.IsCompareFailed(err) { // Retry! @@ -707,17 +1024,12 @@ func (s *CA) PatchRemoteCluster( return nil, trace.BadParameter("metadata.revision: cannot be patched") } - updatedValue, err := services.MarshalRemoteCluster(updated) + item, err := remoteClusterToItem(updated) if err != nil { return nil, trace.Wrap(err) } - lease, err := s.ConditionalUpdate(ctx, backend.Item{ - Key: backend.NewKey(remoteClustersPrefix, name), - Value: updatedValue, - Expires: updated.Expiry(), - Revision: updated.GetRevision(), - }) + lease, err := s.ConditionalUpdate(ctx, item) if err != nil { if trace.IsCompareFailed(err) { // Retry! @@ -822,13 +1134,44 @@ func (s *CA) GetRemoteCluster( } // DeleteRemoteCluster deletes remote cluster by name -func (s *CA) DeleteRemoteCluster( - ctx context.Context, clusterName string, -) error { - if clusterName == "" { +func (s *CA) DeleteRemoteCluster(ctx context.Context, clusterName string) error { + return s.DeleteRemoteClusterInternal(ctx, clusterName, nil /* no cert authorities */) +} + +// DeleteRemoteClusterInternal atomically deletes a remote cluster along with associated resources. +func (s *CA) DeleteRemoteClusterInternal(ctx context.Context, name string, ids []types.CertAuthID) error { + if name == "" { return trace.BadParameter("missing parameter cluster name") } - return s.Delete(ctx, backend.NewKey(remoteClustersPrefix, clusterName)) + + for _, id := range ids { + if err := id.Check(); err != nil { + return trace.Wrap(err) + } + + if id.DomainName != name { + return trace.BadParameter("ca %q does not belong to remote cluster %q", id.DomainName, name) + } + } + + condacts := []backend.ConditionalAction{ + { + Key: remoteClusterKey(name), + Condition: backend.Exists(), + Action: backend.Delete(), + }, + } + + condacts = append(condacts, s.deleteCertAuthoritiesCondActs(ids)...) + + if _, err := s.AtomicWrite(ctx, condacts); err != nil { + if errors.Is(err, backend.ErrConditionFailed) { + return trace.NotFound("remote cluster %q is not found", name) + } + return trace.Wrap(err) + } + + return nil } // DeleteAllRemoteClusters deletes all remote clusters @@ -853,6 +1196,42 @@ func caToItem(key backend.Key, ca types.CertAuthority) (backend.Item, error) { }, nil } +func trustedClusterToItem(tc types.TrustedCluster) (backend.Item, error) { + value, err := services.MarshalTrustedCluster(tc) + if err != nil { + return backend.Item{}, trace.Wrap(err) + } + + return backend.Item{ + Key: trustedClusterKey(tc.GetName()), + Value: value, + Expires: tc.Expiry(), + Revision: tc.GetRevision(), + }, nil +} + +func trustedClusterKey(name string) backend.Key { + return backend.NewKey(trustedClustersPrefix, name) +} + +func remoteClusterToItem(rc types.RemoteCluster) (backend.Item, error) { + value, err := services.MarshalRemoteCluster(rc) + if err != nil { + return backend.Item{}, trace.Wrap(err) + } + + return backend.Item{ + Key: remoteClusterKey(rc.GetName()), + Value: value, + Expires: rc.Expiry(), + Revision: rc.GetRevision(), + }, nil +} + +func remoteClusterKey(name string) backend.Key { + return backend.NewKey(remoteClustersPrefix, name) +} + // activeCAKey builds the active key variant for the supplied ca id. func activeCAKey(id types.CertAuthID) backend.Key { return backend.NewKey(authoritiesPrefix, string(id.Type), id.DomainName) diff --git a/lib/services/local/trust_test.go b/lib/services/local/trust_test.go index 716b214f728fe..3188c546e6c16 100644 --- a/lib/services/local/trust_test.go +++ b/lib/services/local/trust_test.go @@ -20,6 +20,7 @@ package local import ( "context" + "crypto/x509/pkix" "fmt" "testing" "time" @@ -32,11 +33,205 @@ import ( "github.com/gravitational/teleport" "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/lib/auth/testauthority" "github.com/gravitational/teleport/lib/backend" "github.com/gravitational/teleport/lib/backend/lite" "github.com/gravitational/teleport/lib/backend/memory" + "github.com/gravitational/teleport/lib/tlsca" ) +func TestUpdateCertAuthorityCondActs(t *testing.T) { + t.Parallel() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // setup closure creates our initial state and returns its components + setup := func(active bool) (types.TrustedCluster, types.CertAuthority, *CA) { + bk, err := memory.New(memory.Config{}) + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, bk.Close()) }) + service := NewCAService(bk) + + tc, err := types.NewTrustedCluster("tc", types.TrustedClusterSpecV2{ + Enabled: active, + Roles: []string{"rrr"}, + Token: "xxx", + ProxyAddress: "xxx", + ReverseTunnelAddress: "xxx", + }) + require.NoError(t, err) + + ca := newCertAuthority(t, types.HostCA, "tc") + revision, err := service.CreateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + return tc, ca, service + } + + // putCA is a helper for injecting a CA into the backend, bypassing atomic condition protections + putCA := func(ctx context.Context, service *CA, ca types.CertAuthority, active bool) { + key := activeCAKey(ca.GetID()) + if !active { + key = inactiveCAKey(ca.GetID()) + } + item, err := caToItem(key, ca) + require.NoError(t, err) + _, err = service.Put(ctx, item) + require.NoError(t, err) + } + + // delCA is a helper for deleting a CA from the backend, bypassing atomic condition protections + delCA := func(ctx context.Context, service *CA, ca types.CertAuthority, active bool) { + key := activeCAKey(ca.GetID()) + if !active { + key = inactiveCAKey(ca.GetID()) + } + require.NoError(t, service.Delete(ctx, key)) + } + + // -- update active in place --- + tc, ca, service := setup(true /* active */) + + // verify basic update works + tc.SetRoles([]string{"rrr", "zzz"}) + revision, err := service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + + gotTC, err := service.GetTrustedCluster(ctx, tc.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(tc, gotTC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + _, err = service.GetCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + _, err = service.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + + // verify that an inactive CA doesn't prevent update + putCA(ctx, service, ca, false /* inactive */) + tc.SetRoles([]string{"rrr", "zzz", "aaa"}) + revision, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + + gotTC, err = service.GetTrustedCluster(ctx, tc.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(tc, gotTC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + _, err = service.GetCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + _, err = service.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + + // verify that concurrent update of the active CA causes update to fail + putCA(ctx, service, ca, true /* active */) + tc.SetRoles([]string{"rrr", "zzz", "aaa", "bbb"}) + _, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.True(t, trace.IsCompareFailed(err), "err=%v", err) + + // --- update inactive in place --- + tc, ca, service = setup(false /* inactive */) + + // verify basic update works + tc.SetRoles([]string{"rrr", "zzz"}) + revision, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + + gotTC, err = service.GetTrustedCluster(ctx, tc.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(tc, gotTC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + _, err = service.GetCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + _, err = service.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + + // verify that an active CA prevents update + putCA(ctx, service, ca, true /* active */) + tc.SetRoles([]string{"rrr", "zzz", "aaa"}) + _, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.True(t, trace.IsCompareFailed(err), "err=%v", err) + delCA(ctx, service, ca, true /* active */) + + // verify that concurrent update of the inactive CA causes update to fail + putCA(ctx, service, ca, false /* inactive */) + tc.SetRoles([]string{"rrr", "zzz", "aaa", "bbb"}) + _, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.True(t, trace.IsCompareFailed(err), "err=%v", err) + + // --- activate/deactivate --- + tc, ca, service = setup(false /* inactive */) + + // verify that activating works + tc.SetEnabled(true) + revision, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + + gotTC, err = service.GetTrustedCluster(ctx, tc.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(tc, gotTC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + _, err = service.GetCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + _, err = service.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + + // verify that deactivating works + tc.SetEnabled(false) + revision, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + + gotTC, err = service.GetTrustedCluster(ctx, tc.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(tc, gotTC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + _, err = service.GetCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + _, err = service.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + + // verify that an active CA conflicts with activation + putCA(ctx, service, ca, true /* active */) + tc.SetEnabled(true) + _, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.True(t, trace.IsCompareFailed(err), "err=%v", err) + delCA(ctx, service, ca, true /* active */) + + // activation should work after deleting conlicting CA + revision, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + + gotTC, err = service.GetTrustedCluster(ctx, tc.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(tc, gotTC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + _, err = service.GetCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + _, err = service.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + + // verify that deactivation works even if there is an inaactive CA present + putCA(ctx, service, ca, false /* inactive */) + tc.SetEnabled(false) + revision, err = service.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + tc.SetRevision(revision) + ca.SetRevision(revision) + + gotTC, err = service.GetTrustedCluster(ctx, tc.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(tc, gotTC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + _, err = service.GetCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + _, err = service.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) +} + func TestRemoteClusterCRUD(t *testing.T) { t.Parallel() ctx := context.Background() @@ -67,22 +262,38 @@ func TestRemoteClusterCRUD(t *testing.T) { src.SetConnectionStatus(teleport.RemoteClusterStatusOnline) src.SetLastHeartbeat(clock.Now().Add(-time.Hour)) - // create remote clusters - gotRC, err := trustService.CreateRemoteCluster(ctx, rc) + // set up fake CAs for the remote clusters + ca := newCertAuthority(t, types.HostCA, "foo") + sca := newCertAuthority(t, types.HostCA, "bar") + + // create remote cluster + revision, err := trustService.CreateRemoteClusterInternal(ctx, rc, []types.CertAuthority{ca}) require.NoError(t, err) - require.Empty(t, cmp.Diff(rc, gotRC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) - gotSRC, err := trustService.CreateRemoteCluster(ctx, src) + rc.SetRevision(revision) + ca.SetRevision(revision) + + _, err = trustService.CreateRemoteClusterInternal(ctx, rc, []types.CertAuthority{ca}) + require.True(t, trace.IsAlreadyExists(err), "err=%v", err) + + revision, err = trustService.CreateRemoteClusterInternal(ctx, src, []types.CertAuthority{sca}) require.NoError(t, err) - require.Empty(t, cmp.Diff(src, gotSRC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + src.SetRevision(revision) + sca.SetRevision(revision) // get remote cluster make sure it's correct - gotRC, err = trustService.GetRemoteCluster(ctx, "foo") + gotRC, err := trustService.GetRemoteCluster(ctx, "foo") require.NoError(t, err) require.Equal(t, "foo", gotRC.GetName()) require.Equal(t, teleport.RemoteClusterStatusOffline, gotRC.GetConnectionStatus()) require.Equal(t, clock.Now().Nanosecond(), gotRC.GetLastHeartbeat().Nanosecond()) require.Equal(t, originalLabels, gotRC.GetMetadata().Labels) + // get remote cluster CA make sure it's correct + gotCA, err := trustService.GetCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + + require.Empty(t, cmp.Diff(ca, gotCA, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + rc = gotRC updatedLabels := map[string]string{ "e": "f", @@ -99,10 +310,9 @@ func TestRemoteClusterCRUD(t *testing.T) { require.NoError(t, err) require.Empty(t, cmp.Diff(rc, gotRC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) - src = gotSRC src.SetConnectionStatus(teleport.RemoteClusterStatusOffline) src.SetLastHeartbeat(clock.Now()) - gotSRC, err = trustService.UpdateRemoteCluster(ctx, src) + gotSRC, err := trustService.UpdateRemoteCluster(ctx, src) require.NoError(t, err) require.Empty(t, cmp.Diff(src, gotSRC, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) @@ -126,13 +336,26 @@ func TestRemoteClusterCRUD(t *testing.T) { require.Len(t, allRC, 2) // delete cluster - err = trustService.DeleteRemoteCluster(ctx, "foo") + err = trustService.DeleteRemoteClusterInternal(ctx, "foo", []types.CertAuthID{ca.GetID()}) require.NoError(t, err) // make sure it's really gone - err = trustService.DeleteRemoteCluster(ctx, "foo") - require.Error(t, err) - require.ErrorIs(t, err, trace.NotFound("key \"/remoteClusters/foo\" is not found")) + _, err = trustService.GetRemoteCluster(ctx, "foo") + require.True(t, trace.IsNotFound(err)) + _, err = trustService.GetCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err)) + + // make sure we can't create trusted clusters with the same name as an extant remote cluster + tc, err := types.NewTrustedCluster("bar", types.TrustedClusterSpecV2{ + Enabled: true, + Roles: []string{"bar", "baz"}, + Token: "qux", + ProxyAddress: "quux", + ReverseTunnelAddress: "quuz", + }) + require.NoError(t, err) + _, err = trustService.CreateTrustedCluster(ctx, tc, nil) + require.True(t, trace.IsBadParameter(err), "err=%v", err) } func TestPresenceService_PatchRemoteCluster(t *testing.T) { @@ -290,10 +513,13 @@ func TestTrustedClusterCRUD(t *testing.T) { }) require.NoError(t, err) + ca := newCertAuthority(t, types.HostCA, "foo") + sca := newCertAuthority(t, types.HostCA, "bar") + // create trusted clusters - _, err = trustService.UpsertTrustedCluster(ctx, tc) + _, err = trustService.CreateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) require.NoError(t, err) - _, err = trustService.UpsertTrustedCluster(ctx, stc) + _, err = trustService.CreateTrustedCluster(ctx, stc, []types.CertAuthority{sca}) require.NoError(t, err) // get trusted cluster make sure it's correct @@ -306,17 +532,87 @@ func TestTrustedClusterCRUD(t *testing.T) { require.Equal(t, "quux", gotTC.GetProxyAddress()) require.Equal(t, "quuz", gotTC.GetReverseTunnelAddress()) + // get trusted cluster CA make sure it's correct + gotCA, err := trustService.GetCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + require.Empty(t, cmp.Diff(ca, gotCA, cmpopts.IgnoreFields(types.Metadata{}, "Revision"))) + // get all clusters allTC, err := trustService.GetTrustedClusters(ctx) require.NoError(t, err) require.Len(t, allTC, 2) + // verify that enabling/disabling correctly shows/hides CAs + tc.SetEnabled(false) + tc.SetRevision(gotTC.GetRevision()) + ca.SetRevision(gotCA.GetRevision()) + revision, err := trustService.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + _, err = trustService.GetCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + + _, err = trustService.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + + tc.SetEnabled(true) + tc.SetRevision(revision) + ca.SetRevision(revision) + _, err = trustService.UpdateTrustedCluster(ctx, tc, []types.CertAuthority{ca}) + require.NoError(t, err) + + _, err = trustService.GetCertAuthority(ctx, ca.GetID(), true) + require.NoError(t, err) + _, err = trustService.GetInactiveCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + // delete cluster - err = trustService.DeleteTrustedCluster(ctx, "foo") + err = trustService.DeleteTrustedClusterInternal(ctx, "foo", []types.CertAuthID{ca.GetID()}) require.NoError(t, err) // make sure it's really gone _, err = trustService.GetTrustedCluster(ctx, "foo") - require.Error(t, err) - require.ErrorIs(t, err, trace.NotFound("key /trustedclusters/foo is not found")) + require.True(t, trace.IsNotFound(err), "err=%v", err) + _, err = trustService.GetCertAuthority(ctx, ca.GetID(), true) + require.True(t, trace.IsNotFound(err), "err=%v", err) + + // make sure we can't create remote clusters with the same name as an extant trusted cluster + rc, err := types.NewRemoteCluster("bar") + require.NoError(t, err) + _, err = trustService.CreateRemoteCluster(ctx, rc) + require.True(t, trace.IsBadParameter(err), "err=%v", err) +} + +func newCertAuthority(t *testing.T, caType types.CertAuthType, domain string) types.CertAuthority { + t.Helper() + + ta := testauthority.New() + priv, pub, err := ta.GenerateKeyPair() + require.NoError(t, err) + + key, cert, err := tlsca.GenerateSelfSignedCA(pkix.Name{CommonName: domain}, nil, time.Hour) + require.NoError(t, err) + + ca, err := types.NewCertAuthority(types.CertAuthoritySpecV2{ + Type: caType, + ClusterName: domain, + ActiveKeys: types.CAKeySet{ + SSH: []*types.SSHKeyPair{{ + PrivateKey: priv, + PrivateKeyType: types.PrivateKeyType_RAW, + PublicKey: pub, + }}, + TLS: []*types.TLSKeyPair{{ + Cert: cert, + Key: key, + }}, + JWT: []*types.JWTKeyPair{{ + PublicKey: pub, + PrivateKey: priv, + PrivateKeyType: types.PrivateKeyType_RAW, + }}, + }, + }) + require.NoError(t, err) + + return ca } diff --git a/lib/services/trust.go b/lib/services/trust.go index c7cbfe0229bce..63775ae5b52bb 100644 --- a/lib/services/trust.go +++ b/lib/services/trust.go @@ -83,6 +83,26 @@ type Trust interface { // auth server for some local operations. type TrustInternal interface { Trust + + // CreateTrustedCluster atomically creates a new trusted cluster along with associated resources. + CreateTrustedCluster(context.Context, types.TrustedCluster, []types.CertAuthority) (revision string, err error) + + // UpdateTrustedCluster atomically updates a trusted cluster along with associated resources. + UpdateTrustedCluster(context.Context, types.TrustedCluster, []types.CertAuthority) (revision string, err error) + + // DeleteTrustedClusterInternal atomically deletes a trusted cluster along with associated resources. + DeleteTrustedClusterInternal(context.Context, string, []types.CertAuthID) error + + // CreateRemoteCluster atomically creates a new remote cluster along with associated resources. + CreateRemoteClusterInternal(context.Context, types.RemoteCluster, []types.CertAuthority) (revision string, err error) + + // DeleteRemotClusterInternal atomically deletes a remote cluster along with associated resources. + DeleteRemoteClusterInternal(context.Context, string, []types.CertAuthID) error + + // GetInactiveCertAuthority returns inactive certificate authority by given id. Parameter loadSigningKeys + // controls if signing keys are loaded. + GetInactiveCertAuthority(ctx context.Context, id types.CertAuthID, loadSigningKeys bool) (types.CertAuthority, error) + // CreateCertAuthorities creates multiple cert authorities atomically. CreateCertAuthorities(context.Context, ...types.CertAuthority) (revision string, err error) From bd9dfc24a167b606e60e1a8a5e904b1ceec3c846 Mon Sep 17 00:00:00 2001 From: Marco Dinis Date: Wed, 30 Oct 2024 09:16:52 +0000 Subject: [PATCH 3/5] [v16] Add UserTask audit events (#47496) (#47713) * Add UserTask audit events (#47496) * Add UserTask audit events * add events to fixtures * update snapshots --- .../teleport/legacy/types/events/events.proto | 147 + api/types/events/events.go | 12 + api/types/events/events.pb.go | 5339 +++++++++++------ api/types/events/oneof.go | 12 + lib/auth/grpcserver.go | 1 + lib/auth/usertasks/usertasksv1/service.go | 115 +- .../usertasks/usertasksv1/service_test.go | 100 +- lib/events/api.go | 7 + lib/events/codes.go | 7 + lib/events/dynamic.go | 7 + lib/events/events_test.go | 3 + .../src/Audit/EventList/EventTypeCell.tsx | 3 + .../__snapshots__/Audit.story.test.tsx.snap | 170 +- .../teleport/src/Audit/fixtures/index.ts | 53 + .../teleport/src/services/audit/makeEvent.ts | 21 + .../teleport/src/services/audit/types.ts | 15 + 16 files changed, 4237 insertions(+), 1775 deletions(-) diff --git a/api/proto/teleport/legacy/types/events/events.proto b/api/proto/teleport/legacy/types/events/events.proto index a200ef2626c90..469850859e82d 100644 --- a/api/proto/teleport/legacy/types/events/events.proto +++ b/api/proto/teleport/legacy/types/events/events.proto @@ -4610,6 +4610,9 @@ message OneOf { events.CrownJewelCreate CrownJewelCreate = 182; events.CrownJewelUpdate CrownJewelUpdate = 183; events.CrownJewelDelete CrownJewelDelete = 184; + events.UserTaskCreate UserTaskCreate = 188; + events.UserTaskUpdate UserTaskUpdate = 189; + events.UserTaskDelete UserTaskDelete = 190; } } @@ -7310,3 +7313,147 @@ message CrownJewelDelete { (gogoproto.jsontag) = "" ]; } + +// UserTaskCreate is emitted when a user task is created. +message UserTaskCreate { + // Metadata is a common event metadata + Metadata Metadata = 1 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // Status indicates whether the update was successful. + Status Status = 2 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ResourceMetadata is a common resource event metadata + ResourceMetadata Resource = 3 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // User is a common user event metadata + UserMetadata User = 4 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ConnectionMetadata holds information about the connection + ConnectionMetadata Connection = 5 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // UserTaskMetadata holds information about the user task. + UserTaskMetadata UserTask = 6 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; +} + +// UserTaskUpdate is emitted when a user task is updated. +message UserTaskUpdate { + // Metadata is a common event metadata + Metadata Metadata = 1 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // Status indicates whether the update was successful. + Status Status = 2 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ResourceMetadata is a common resource event metadata + ResourceMetadata Resource = 3 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // User is a common user event metadata. + UserMetadata User = 4 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ConnectionMetadata holds information about the connection. + ConnectionMetadata Connection = 5 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // UserTaskMetadata holds information about the user task. + UserTaskMetadata UserTask = 6 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // CurrentUserTaskState is the current UserTask State. + string CurrentUserTaskState = 7 [(gogoproto.jsontag) = "current_user_task_state"]; + + // UpdatedUserTaskState is the updated UserTask State. + string UpdatedUserTaskState = 8 [(gogoproto.jsontag) = "updated_user_task_state"]; +} + +// UserTaskMetadata contains key fields for the UserTask. +message UserTaskMetadata { + // TaskType is type of the task. + string TaskType = 1 [(gogoproto.jsontag) = "user_task_type"]; + // IssueType is type of the issue task. + string IssueType = 2 [(gogoproto.jsontag) = "user_task_issue_type"]; + // Integration is type of associated integration. + string Integration = 3 [(gogoproto.jsontag) = "user_task_integration"]; +} + +// UserTaskDelete is emitted when a user task is deleted. +message UserTaskDelete { + // Metadata is a common event metadata + Metadata Metadata = 1 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // Status indicates whether the update was successful. + Status Status = 2 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ResourceMetadata is a common resource event metadata + ResourceMetadata Resource = 3 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // User is a common user event metadata + UserMetadata User = 4 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ConnectionMetadata holds information about the connection + ConnectionMetadata Connection = 5 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; +} diff --git a/api/types/events/events.go b/api/types/events/events.go index 4f50d219310d2..4c1e561c7e2f1 100644 --- a/api/types/events/events.go +++ b/api/types/events/events.go @@ -2290,3 +2290,15 @@ func (m *CrownJewelUpdate) TrimToMaxSize(_ int) AuditEvent { func (m *CrownJewelDelete) TrimToMaxSize(_ int) AuditEvent { return m } + +func (m *UserTaskCreate) TrimToMaxSize(_ int) AuditEvent { + return m +} + +func (m *UserTaskUpdate) TrimToMaxSize(_ int) AuditEvent { + return m +} + +func (m *UserTaskDelete) TrimToMaxSize(_ int) AuditEvent { + return m +} diff --git a/api/types/events/events.pb.go b/api/types/events/events.pb.go index b4b68bf4562df..c35d7982c9b9f 100644 --- a/api/types/events/events.pb.go +++ b/api/types/events/events.pb.go @@ -7731,6 +7731,9 @@ type OneOf struct { // *OneOf_CrownJewelCreate // *OneOf_CrownJewelUpdate // *OneOf_CrownJewelDelete + // *OneOf_UserTaskCreate + // *OneOf_UserTaskUpdate + // *OneOf_UserTaskDelete Event isOneOf_Event `protobuf_oneof:"Event"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -8325,6 +8328,15 @@ type OneOf_CrownJewelUpdate struct { type OneOf_CrownJewelDelete struct { CrownJewelDelete *CrownJewelDelete `protobuf:"bytes,184,opt,name=CrownJewelDelete,proto3,oneof" json:"CrownJewelDelete,omitempty"` } +type OneOf_UserTaskCreate struct { + UserTaskCreate *UserTaskCreate `protobuf:"bytes,188,opt,name=UserTaskCreate,proto3,oneof" json:"UserTaskCreate,omitempty"` +} +type OneOf_UserTaskUpdate struct { + UserTaskUpdate *UserTaskUpdate `protobuf:"bytes,189,opt,name=UserTaskUpdate,proto3,oneof" json:"UserTaskUpdate,omitempty"` +} +type OneOf_UserTaskDelete struct { + UserTaskDelete *UserTaskDelete `protobuf:"bytes,190,opt,name=UserTaskDelete,proto3,oneof" json:"UserTaskDelete,omitempty"` +} func (*OneOf_UserLogin) isOneOf_Event() {} func (*OneOf_UserCreate) isOneOf_Event() {} @@ -8509,6 +8521,9 @@ func (*OneOf_StaticHostUserDelete) isOneOf_Event() {} func (*OneOf_CrownJewelCreate) isOneOf_Event() {} func (*OneOf_CrownJewelUpdate) isOneOf_Event() {} func (*OneOf_CrownJewelDelete) isOneOf_Event() {} +func (*OneOf_UserTaskCreate) isOneOf_Event() {} +func (*OneOf_UserTaskUpdate) isOneOf_Event() {} +func (*OneOf_UserTaskDelete) isOneOf_Event() {} func (m *OneOf) GetEvent() isOneOf_Event { if m != nil { @@ -9798,6 +9813,27 @@ func (m *OneOf) GetCrownJewelDelete() *CrownJewelDelete { return nil } +func (m *OneOf) GetUserTaskCreate() *UserTaskCreate { + if x, ok := m.GetEvent().(*OneOf_UserTaskCreate); ok { + return x.UserTaskCreate + } + return nil +} + +func (m *OneOf) GetUserTaskUpdate() *UserTaskUpdate { + if x, ok := m.GetEvent().(*OneOf_UserTaskUpdate); ok { + return x.UserTaskUpdate + } + return nil +} + +func (m *OneOf) GetUserTaskDelete() *UserTaskDelete { + if x, ok := m.GetEvent().(*OneOf_UserTaskDelete); ok { + return x.UserTaskDelete + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*OneOf) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -9984,6 +10020,9 @@ func (*OneOf) XXX_OneofWrappers() []interface{} { (*OneOf_CrownJewelCreate)(nil), (*OneOf_CrownJewelUpdate)(nil), (*OneOf_CrownJewelDelete)(nil), + (*OneOf_UserTaskCreate)(nil), + (*OneOf_UserTaskUpdate)(nil), + (*OneOf_UserTaskDelete)(nil), } } @@ -14504,6 +14543,210 @@ func (m *CrownJewelDelete) XXX_DiscardUnknown() { var xxx_messageInfo_CrownJewelDelete proto.InternalMessageInfo +// UserTaskCreate is emitted when a user task is created. +type UserTaskCreate struct { + // Metadata is a common event metadata + Metadata `protobuf:"bytes,1,opt,name=Metadata,proto3,embedded=Metadata" json:""` + // Status indicates whether the update was successful. + Status `protobuf:"bytes,2,opt,name=Status,proto3,embedded=Status" json:""` + // ResourceMetadata is a common resource event metadata + ResourceMetadata `protobuf:"bytes,3,opt,name=Resource,proto3,embedded=Resource" json:""` + // User is a common user event metadata + UserMetadata `protobuf:"bytes,4,opt,name=User,proto3,embedded=User" json:""` + // ConnectionMetadata holds information about the connection + ConnectionMetadata `protobuf:"bytes,5,opt,name=Connection,proto3,embedded=Connection" json:""` + // UserTaskMetadata holds information about the user task. + UserTaskMetadata `protobuf:"bytes,6,opt,name=UserTask,proto3,embedded=UserTask" json:""` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UserTaskCreate) Reset() { *m = UserTaskCreate{} } +func (m *UserTaskCreate) String() string { return proto.CompactTextString(m) } +func (*UserTaskCreate) ProtoMessage() {} +func (*UserTaskCreate) Descriptor() ([]byte, []int) { + return fileDescriptor_007ba1c3d6266d56, []int{227} +} +func (m *UserTaskCreate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UserTaskCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UserTaskCreate.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UserTaskCreate) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserTaskCreate.Merge(m, src) +} +func (m *UserTaskCreate) XXX_Size() int { + return m.Size() +} +func (m *UserTaskCreate) XXX_DiscardUnknown() { + xxx_messageInfo_UserTaskCreate.DiscardUnknown(m) +} + +var xxx_messageInfo_UserTaskCreate proto.InternalMessageInfo + +// UserTaskUpdate is emitted when a user task is updated. +type UserTaskUpdate struct { + // Metadata is a common event metadata + Metadata `protobuf:"bytes,1,opt,name=Metadata,proto3,embedded=Metadata" json:""` + // Status indicates whether the update was successful. + Status `protobuf:"bytes,2,opt,name=Status,proto3,embedded=Status" json:""` + // ResourceMetadata is a common resource event metadata + ResourceMetadata `protobuf:"bytes,3,opt,name=Resource,proto3,embedded=Resource" json:""` + // User is a common user event metadata. + UserMetadata `protobuf:"bytes,4,opt,name=User,proto3,embedded=User" json:""` + // ConnectionMetadata holds information about the connection. + ConnectionMetadata `protobuf:"bytes,5,opt,name=Connection,proto3,embedded=Connection" json:""` + // UserTaskMetadata holds information about the user task. + UserTaskMetadata `protobuf:"bytes,6,opt,name=UserTask,proto3,embedded=UserTask" json:""` + // CurrentUserTaskState is the current UserTask State. + CurrentUserTaskState string `protobuf:"bytes,7,opt,name=CurrentUserTaskState,proto3" json:"current_user_task_state"` + // UpdatedUserTaskState is the updated UserTask State. + UpdatedUserTaskState string `protobuf:"bytes,8,opt,name=UpdatedUserTaskState,proto3" json:"updated_user_task_state"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UserTaskUpdate) Reset() { *m = UserTaskUpdate{} } +func (m *UserTaskUpdate) String() string { return proto.CompactTextString(m) } +func (*UserTaskUpdate) ProtoMessage() {} +func (*UserTaskUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_007ba1c3d6266d56, []int{228} +} +func (m *UserTaskUpdate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UserTaskUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UserTaskUpdate.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UserTaskUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserTaskUpdate.Merge(m, src) +} +func (m *UserTaskUpdate) XXX_Size() int { + return m.Size() +} +func (m *UserTaskUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_UserTaskUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_UserTaskUpdate proto.InternalMessageInfo + +// UserTaskMetadata contains key fields for the UserTask. +type UserTaskMetadata struct { + // TaskType is type of the task. + TaskType string `protobuf:"bytes,1,opt,name=TaskType,proto3" json:"user_task_type"` + // IssueType is type of the issue task. + IssueType string `protobuf:"bytes,2,opt,name=IssueType,proto3" json:"user_task_issue_type"` + // Integration is type of associated integration. + Integration string `protobuf:"bytes,3,opt,name=Integration,proto3" json:"user_task_integration"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UserTaskMetadata) Reset() { *m = UserTaskMetadata{} } +func (m *UserTaskMetadata) String() string { return proto.CompactTextString(m) } +func (*UserTaskMetadata) ProtoMessage() {} +func (*UserTaskMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_007ba1c3d6266d56, []int{229} +} +func (m *UserTaskMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UserTaskMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UserTaskMetadata.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UserTaskMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserTaskMetadata.Merge(m, src) +} +func (m *UserTaskMetadata) XXX_Size() int { + return m.Size() +} +func (m *UserTaskMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_UserTaskMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_UserTaskMetadata proto.InternalMessageInfo + +// UserTaskDelete is emitted when a user task is deleted. +type UserTaskDelete struct { + // Metadata is a common event metadata + Metadata `protobuf:"bytes,1,opt,name=Metadata,proto3,embedded=Metadata" json:""` + // Status indicates whether the update was successful. + Status `protobuf:"bytes,2,opt,name=Status,proto3,embedded=Status" json:""` + // ResourceMetadata is a common resource event metadata + ResourceMetadata `protobuf:"bytes,3,opt,name=Resource,proto3,embedded=Resource" json:""` + // User is a common user event metadata + UserMetadata `protobuf:"bytes,4,opt,name=User,proto3,embedded=User" json:""` + // ConnectionMetadata holds information about the connection + ConnectionMetadata `protobuf:"bytes,5,opt,name=Connection,proto3,embedded=Connection" json:""` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UserTaskDelete) Reset() { *m = UserTaskDelete{} } +func (m *UserTaskDelete) String() string { return proto.CompactTextString(m) } +func (*UserTaskDelete) ProtoMessage() {} +func (*UserTaskDelete) Descriptor() ([]byte, []int) { + return fileDescriptor_007ba1c3d6266d56, []int{230} +} +func (m *UserTaskDelete) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *UserTaskDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_UserTaskDelete.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *UserTaskDelete) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserTaskDelete.Merge(m, src) +} +func (m *UserTaskDelete) XXX_Size() int { + return m.Size() +} +func (m *UserTaskDelete) XXX_DiscardUnknown() { + xxx_messageInfo_UserTaskDelete.DiscardUnknown(m) +} + +var xxx_messageInfo_UserTaskDelete proto.InternalMessageInfo + func init() { proto.RegisterEnum("events.UserKind", UserKind_name, UserKind_value) proto.RegisterEnum("events.EventAction", EventAction_name, EventAction_value) @@ -14755,6 +14998,10 @@ func init() { proto.RegisterType((*CrownJewelCreate)(nil), "events.CrownJewelCreate") proto.RegisterType((*CrownJewelUpdate)(nil), "events.CrownJewelUpdate") proto.RegisterType((*CrownJewelDelete)(nil), "events.CrownJewelDelete") + proto.RegisterType((*UserTaskCreate)(nil), "events.UserTaskCreate") + proto.RegisterType((*UserTaskUpdate)(nil), "events.UserTaskUpdate") + proto.RegisterType((*UserTaskMetadata)(nil), "events.UserTaskMetadata") + proto.RegisterType((*UserTaskDelete)(nil), "events.UserTaskDelete") } func init() { @@ -14762,1033 +15009,1045 @@ func init() { } var fileDescriptor_007ba1c3d6266d56 = []byte{ - // 16403 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x5b, 0x74, 0x24, 0x49, - 0x76, 0x18, 0x86, 0x7a, 0xa0, 0x00, 0x5c, 0xbc, 0xa3, 0x5f, 0x39, 0x3d, 0x3d, 0x8d, 0x99, 0x9c, - 0xdd, 0xde, 0xee, 0xd9, 0x99, 0xee, 0x9d, 0x9e, 0x9e, 0x99, 0x9d, 0xd7, 0xce, 0x16, 0x50, 0x40, - 0xa3, 0xba, 0xf1, 0x9a, 0x2c, 0xa0, 0x7b, 0x67, 0xc9, 0xdd, 0x62, 0xa2, 0x32, 0x00, 0xe4, 0x74, - 0x55, 0x66, 0x31, 0x33, 0xab, 0xd1, 0x18, 0xbf, 0xb8, 0x32, 0x45, 0x91, 0xe2, 0xee, 0x6a, 0xbd, - 0x34, 0x1f, 0x12, 0x65, 0x8b, 0xd4, 0xc3, 0xa6, 0x68, 0x8a, 0x14, 0x25, 0x9a, 0x0f, 0xc9, 0x3c, - 0x96, 0xbc, 0x7e, 0xac, 0xc4, 0x63, 0x1e, 0x49, 0xb6, 0x75, 0x74, 0x6c, 0x19, 0x2b, 0xd3, 0xd6, - 0x0f, 0x8e, 0x7d, 0x0e, 0x6d, 0xf3, 0x58, 0x6b, 0x59, 0xf6, 0xf1, 0x89, 0x1b, 0x91, 0x99, 0x91, - 0xaf, 0xc2, 0x73, 0x88, 0xc1, 0x00, 0x3f, 0xdd, 0xa8, 0x7b, 0x6f, 0xdc, 0x88, 0xbc, 0x71, 0x23, - 0xe2, 0x46, 0xc4, 0x8d, 0x7b, 0xe1, 0x86, 0x47, 0x9b, 0xb4, 0x6d, 0x3b, 0xde, 0xad, 0x26, 0x5d, - 0xd7, 0x1b, 0x5b, 0xb7, 0xbc, 0xad, 0x36, 0x75, 0x6f, 0xd1, 0xc7, 0xd4, 0xf2, 0xfc, 0xff, 0x6e, - 0xb6, 0x1d, 0xdb, 0xb3, 0x49, 0x89, 0xff, 0xba, 0x7c, 0x7e, 0xdd, 0x5e, 0xb7, 0x11, 0x74, 0x8b, - 0xfd, 0xc5, 0xb1, 0x97, 0xaf, 0xac, 0xdb, 0xf6, 0x7a, 0x93, 0xde, 0xc2, 0x5f, 0xab, 0x9d, 0xb5, - 0x5b, 0xae, 0xe7, 0x74, 0x1a, 0x9e, 0xc0, 0x4e, 0xc4, 0xb1, 0x9e, 0xd9, 0xa2, 0xae, 0xa7, 0xb7, - 0xda, 0x82, 0xe0, 0x6a, 0x9c, 0x60, 0xd3, 0xd1, 0xdb, 0x6d, 0xea, 0x88, 0xca, 0x2f, 0x3f, 0x97, - 0xde, 0x4e, 0xfc, 0x57, 0x90, 0xbc, 0x94, 0x4e, 0xe2, 0x33, 0x8a, 0x71, 0x54, 0xbf, 0x9d, 0x87, - 0xfe, 0x79, 0xea, 0xe9, 0x86, 0xee, 0xe9, 0xe4, 0x0a, 0xf4, 0x56, 0x2d, 0x83, 0x3e, 0x51, 0x72, - 0xcf, 0xe6, 0xae, 0x17, 0x26, 0x4b, 0x3b, 0xdb, 0x13, 0x79, 0x6a, 0x6a, 0x1c, 0x48, 0x9e, 0x81, - 0xe2, 0xf2, 0x56, 0x9b, 0x2a, 0xf9, 0x67, 0x73, 0xd7, 0x07, 0x26, 0x07, 0x76, 0xb6, 0x27, 0x7a, - 0x51, 0x16, 0x1a, 0x82, 0xc9, 0x73, 0x90, 0xaf, 0x56, 0x94, 0x02, 0x22, 0xc7, 0x77, 0xb6, 0x27, - 0x86, 0x3b, 0xa6, 0xf1, 0xa2, 0xdd, 0x32, 0x3d, 0xda, 0x6a, 0x7b, 0x5b, 0x5a, 0xbe, 0x5a, 0x21, - 0xd7, 0xa0, 0x38, 0x65, 0x1b, 0x54, 0x29, 0x22, 0x11, 0xd9, 0xd9, 0x9e, 0x18, 0x69, 0xd8, 0x06, - 0x95, 0xa8, 0x10, 0x4f, 0xbe, 0x08, 0xc5, 0x65, 0xb3, 0x45, 0x95, 0xde, 0x67, 0x73, 0xd7, 0x07, - 0x6f, 0x5f, 0xbe, 0xc9, 0xa5, 0x72, 0xd3, 0x97, 0xca, 0xcd, 0x65, 0x5f, 0x6c, 0x93, 0x63, 0xdf, - 0xdd, 0x9e, 0xe8, 0xd9, 0xd9, 0x9e, 0x28, 0x32, 0x49, 0x7e, 0xeb, 0x7b, 0x13, 0x39, 0x0d, 0x4b, - 0x92, 0xb7, 0x61, 0x70, 0xaa, 0xd9, 0x71, 0x3d, 0xea, 0x2c, 0xe8, 0x2d, 0xaa, 0x94, 0xb0, 0xc2, - 0xcb, 0x3b, 0xdb, 0x13, 0x17, 0x1b, 0x1c, 0x5c, 0xb7, 0xf4, 0x96, 0x5c, 0xb1, 0x4c, 0xae, 0xfe, - 0x76, 0x0e, 0x46, 0x6b, 0xd4, 0x75, 0x4d, 0xdb, 0x0a, 0x64, 0xf3, 0x69, 0x18, 0x10, 0xa0, 0x6a, - 0x05, 0xe5, 0x33, 0x30, 0xd9, 0xb7, 0xb3, 0x3d, 0x51, 0x70, 0x4d, 0x43, 0x0b, 0x31, 0xe4, 0x73, - 0xd0, 0xf7, 0xd0, 0xf4, 0x36, 0xe6, 0x67, 0xca, 0x42, 0x4e, 0x17, 0x77, 0xb6, 0x27, 0xc8, 0xa6, - 0xe9, 0x6d, 0xd4, 0x5b, 0x6b, 0xba, 0x54, 0xa1, 0x4f, 0x46, 0xe6, 0x60, 0x6c, 0xc9, 0x31, 0x1f, - 0xeb, 0x1e, 0xbd, 0x4f, 0xb7, 0x96, 0xec, 0xa6, 0xd9, 0xd8, 0x12, 0x52, 0x7c, 0x76, 0x67, 0x7b, - 0xe2, 0x4a, 0x9b, 0xe3, 0xea, 0x8f, 0xe8, 0x56, 0xbd, 0x8d, 0x58, 0x89, 0x49, 0xa2, 0xa4, 0xfa, - 0xb7, 0x4a, 0x30, 0xb4, 0xe2, 0x52, 0x27, 0x68, 0xf7, 0x35, 0x28, 0xb2, 0xdf, 0xa2, 0xc9, 0x28, - 0xf3, 0x8e, 0x4b, 0x1d, 0x59, 0xe6, 0x0c, 0x4f, 0x6e, 0x40, 0xef, 0x9c, 0xbd, 0x6e, 0x5a, 0xa2, - 0xd9, 0xe7, 0x76, 0xb6, 0x27, 0x46, 0x9b, 0x0c, 0x20, 0x51, 0x72, 0x0a, 0xf2, 0x05, 0x18, 0xaa, - 0xb6, 0x98, 0x0e, 0xd9, 0x96, 0xee, 0xd9, 0x8e, 0x68, 0x2d, 0x4a, 0xd7, 0x94, 0xe0, 0x52, 0xc1, - 0x08, 0x3d, 0x79, 0x13, 0xa0, 0xfc, 0xb0, 0xa6, 0xd9, 0x4d, 0x5a, 0xd6, 0x16, 0x84, 0x32, 0x60, - 0x69, 0x7d, 0xd3, 0xad, 0x3b, 0x76, 0x93, 0xd6, 0x75, 0x47, 0xae, 0x56, 0xa2, 0x26, 0xd3, 0x30, - 0x52, 0x6e, 0x34, 0xa8, 0xeb, 0x6a, 0xf4, 0x87, 0x3b, 0xd4, 0xf5, 0x5c, 0xa5, 0xf7, 0xd9, 0xc2, - 0xf5, 0x81, 0xc9, 0x67, 0x76, 0xb6, 0x27, 0x9e, 0xd2, 0x11, 0x53, 0x77, 0x04, 0x4a, 0x62, 0x11, - 0x2b, 0x44, 0x26, 0x61, 0xb8, 0xfc, 0x61, 0xc7, 0xa1, 0x55, 0x83, 0x5a, 0x9e, 0xe9, 0x6d, 0x09, - 0x0d, 0xb9, 0xb2, 0xb3, 0x3d, 0xa1, 0xe8, 0x0c, 0x51, 0x37, 0x05, 0x46, 0x62, 0x12, 0x2d, 0x42, - 0x16, 0x61, 0xfc, 0xee, 0xd4, 0x52, 0x8d, 0x3a, 0x8f, 0xcd, 0x06, 0x2d, 0x37, 0x1a, 0x76, 0xc7, - 0xf2, 0x94, 0x3e, 0xe4, 0xf3, 0xdc, 0xce, 0xf6, 0xc4, 0x33, 0xeb, 0x8d, 0x76, 0xdd, 0xe5, 0xd8, - 0xba, 0xce, 0xd1, 0x12, 0xb3, 0x64, 0x59, 0xf2, 0x65, 0x18, 0x5e, 0x76, 0x98, 0x16, 0x1a, 0x15, - 0xca, 0xe0, 0x4a, 0x3f, 0xea, 0xff, 0xc5, 0x9b, 0x62, 0x02, 0xe2, 0x50, 0xbf, 0x67, 0x79, 0x63, - 0x3d, 0x5e, 0xa0, 0x6e, 0x20, 0x4e, 0x6e, 0x6c, 0x84, 0x15, 0xa1, 0xa0, 0xb0, 0x8f, 0x37, 0x1d, - 0x6a, 0x24, 0xb4, 0x6d, 0x00, 0xdb, 0x7c, 0x63, 0x67, 0x7b, 0xe2, 0xd3, 0x8e, 0xa0, 0xa9, 0x77, - 0x55, 0xbb, 0x4c, 0x56, 0x64, 0x1a, 0xfa, 0x99, 0x36, 0xdd, 0x37, 0x2d, 0x43, 0x81, 0x67, 0x73, - 0xd7, 0x47, 0x6e, 0x8f, 0xf9, 0xad, 0xf7, 0xe1, 0x93, 0x97, 0x76, 0xb6, 0x27, 0xce, 0x31, 0x1d, - 0xac, 0x3f, 0x32, 0x2d, 0x79, 0x8a, 0x08, 0x8a, 0xb2, 0x51, 0x34, 0x69, 0x7b, 0x38, 0x74, 0x07, - 0xc3, 0x51, 0xb4, 0x6a, 0x7b, 0xf1, 0x61, 0xeb, 0x93, 0x91, 0x29, 0x18, 0x9e, 0xb4, 0xbd, 0xaa, - 0xe5, 0x7a, 0xba, 0xd5, 0xa0, 0xd5, 0x8a, 0x32, 0x84, 0xe5, 0x50, 0x2d, 0x58, 0x39, 0x53, 0x60, - 0xea, 0x91, 0x49, 0x29, 0x5a, 0x46, 0xfd, 0x17, 0x45, 0x18, 0x61, 0x7d, 0x22, 0x0d, 0x9f, 0x32, - 0x9b, 0x09, 0x18, 0x84, 0xd5, 0xe2, 0xb6, 0xf5, 0x06, 0x15, 0x23, 0x09, 0xbf, 0xc2, 0xf2, 0x81, - 0x12, 0xcf, 0x38, 0x3d, 0xb9, 0x01, 0xfd, 0x1c, 0x54, 0xad, 0x88, 0xc1, 0x35, 0xbc, 0xb3, 0x3d, - 0x31, 0xe0, 0x22, 0xac, 0x6e, 0x1a, 0x5a, 0x80, 0x66, 0xda, 0xcd, 0xff, 0x9e, 0xb5, 0x5d, 0x8f, - 0x31, 0x17, 0x63, 0x0b, 0x3f, 0x43, 0x14, 0xd8, 0x10, 0x28, 0x59, 0xbb, 0xa3, 0x85, 0xc8, 0x1b, - 0x00, 0x1c, 0x52, 0x36, 0x0c, 0x47, 0x0c, 0xb0, 0xa7, 0x76, 0xb6, 0x27, 0x2e, 0x08, 0x16, 0xba, - 0x61, 0xc8, 0xa3, 0x53, 0x22, 0x26, 0x2d, 0x18, 0xe2, 0xbf, 0xe6, 0xf4, 0x55, 0xda, 0xe4, 0xa3, - 0x6b, 0xf0, 0xf6, 0x75, 0xbf, 0x13, 0xa3, 0xd2, 0xb9, 0x29, 0x93, 0x4e, 0x5b, 0x9e, 0xb3, 0x35, - 0x39, 0x21, 0x26, 0xe4, 0x4b, 0xa2, 0xaa, 0x26, 0xe2, 0xe4, 0xa9, 0x40, 0x2e, 0xc3, 0xe6, 0xe9, - 0x19, 0xdb, 0xd9, 0xd4, 0x1d, 0x83, 0x1a, 0x93, 0x5b, 0xf2, 0x3c, 0xbd, 0xe6, 0x83, 0xeb, 0xab, - 0xb2, 0xea, 0xc9, 0xe4, 0xac, 0xd3, 0x39, 0xb7, 0x5a, 0x67, 0x15, 0x55, 0xae, 0x2f, 0x21, 0x2d, - 0xb7, 0xb3, 0x1a, 0x57, 0xb3, 0x68, 0x19, 0x36, 0x15, 0x70, 0xc0, 0x03, 0xea, 0xb0, 0x49, 0x1c, - 0x47, 0x9d, 0x98, 0x0a, 0x04, 0x93, 0xc7, 0x1c, 0x93, 0xe4, 0x21, 0x8a, 0x5c, 0x7e, 0x17, 0xc6, - 0x13, 0xa2, 0x20, 0x63, 0x50, 0x78, 0x44, 0xb7, 0xb8, 0xba, 0x68, 0xec, 0x4f, 0x72, 0x1e, 0x7a, - 0x1f, 0xeb, 0xcd, 0x8e, 0x58, 0x42, 0x35, 0xfe, 0xe3, 0xcd, 0xfc, 0xe7, 0x73, 0x6c, 0xc5, 0x21, - 0x53, 0xb6, 0x65, 0xd1, 0x86, 0x27, 0x2f, 0x3a, 0xaf, 0xc1, 0xc0, 0x9c, 0xdd, 0xd0, 0x9b, 0xd8, - 0x8f, 0x5c, 0xef, 0x94, 0x9d, 0xed, 0x89, 0xf3, 0xac, 0x03, 0x6f, 0x36, 0x19, 0x46, 0x6a, 0x53, - 0x48, 0xca, 0x14, 0x40, 0xa3, 0x2d, 0xdb, 0xa3, 0x58, 0x30, 0x1f, 0x2a, 0x00, 0x16, 0x74, 0x10, - 0x25, 0x2b, 0x40, 0x48, 0x4c, 0x6e, 0x41, 0xff, 0x12, 0x5b, 0x67, 0x1b, 0x76, 0x53, 0x28, 0x1f, - 0x2e, 0x05, 0xb8, 0xf6, 0xca, 0x63, 0xd5, 0x27, 0x52, 0x67, 0x61, 0x64, 0xaa, 0x69, 0x52, 0xcb, - 0x93, 0x5b, 0xcd, 0x46, 0x72, 0x79, 0x9d, 0x5a, 0x9e, 0xdc, 0x6a, 0x1c, 0xf3, 0x3a, 0x83, 0xca, - 0xad, 0x0e, 0x48, 0xd5, 0xdf, 0x2f, 0xc0, 0x53, 0xf7, 0x3b, 0xab, 0xd4, 0xb1, 0xa8, 0x47, 0x5d, - 0xb1, 0x20, 0x07, 0x5c, 0x17, 0x60, 0x3c, 0x81, 0x14, 0xdc, 0x71, 0xa1, 0x7c, 0x14, 0x20, 0xeb, - 0x62, 0x8d, 0x97, 0x67, 0xdb, 0x44, 0x51, 0x32, 0x0b, 0xa3, 0x21, 0x90, 0x35, 0xc2, 0x55, 0xf2, - 0xb8, 0x94, 0x5c, 0xdd, 0xd9, 0x9e, 0xb8, 0x2c, 0x71, 0x63, 0xcd, 0x96, 0x35, 0x38, 0x5e, 0x8c, - 0xdc, 0x87, 0xb1, 0x10, 0x74, 0xd7, 0xb1, 0x3b, 0x6d, 0x57, 0x29, 0x20, 0xab, 0x89, 0x9d, 0xed, - 0x89, 0xa7, 0x25, 0x56, 0xeb, 0x88, 0x94, 0x17, 0xf0, 0x78, 0x41, 0xf2, 0xa3, 0x39, 0x99, 0x9b, - 0x18, 0x85, 0x45, 0x1c, 0x85, 0xaf, 0xfb, 0xa3, 0x30, 0x53, 0x48, 0x37, 0xe3, 0x25, 0xc5, 0xa0, - 0x8c, 0x35, 0x23, 0x31, 0x28, 0x13, 0x35, 0x5e, 0x9e, 0x82, 0x0b, 0xa9, 0xbc, 0xf6, 0xa5, 0xd5, - 0xff, 0xbc, 0x20, 0x73, 0x59, 0xb2, 0x8d, 0xa0, 0x33, 0x17, 0xe5, 0xce, 0x5c, 0xb2, 0x0d, 0x9c, - 0xea, 0x73, 0xe1, 0xda, 0x29, 0x35, 0xb6, 0x6d, 0x1b, 0xf1, 0x59, 0x3f, 0x59, 0x96, 0x7c, 0x15, - 0x2e, 0x26, 0x80, 0x7c, 0xba, 0xe6, 0xda, 0x7f, 0x6d, 0x67, 0x7b, 0x42, 0x4d, 0xe1, 0x1a, 0x9f, - 0xbd, 0x33, 0xb8, 0x10, 0x1d, 0x2e, 0x49, 0x52, 0xb7, 0x2d, 0x4f, 0x37, 0x2d, 0x61, 0x5c, 0xf2, - 0x51, 0xf2, 0x99, 0x9d, 0xed, 0x89, 0xe7, 0x65, 0x1d, 0xf4, 0x69, 0xe2, 0x8d, 0xcf, 0xe2, 0x43, - 0x0c, 0x50, 0x52, 0x50, 0xd5, 0x96, 0xbe, 0xee, 0x5b, 0xcc, 0xd7, 0x77, 0xb6, 0x27, 0x3e, 0x95, - 0x5a, 0x87, 0xc9, 0xa8, 0xe4, 0x15, 0x3a, 0x8b, 0x13, 0xd1, 0x80, 0x84, 0xb8, 0x05, 0xdb, 0xa0, - 0xf8, 0x0d, 0xbd, 0xc8, 0x5f, 0xdd, 0xd9, 0x9e, 0xb8, 0x2a, 0xf1, 0xb7, 0x6c, 0x83, 0xc6, 0x9b, - 0x9f, 0x52, 0x5a, 0xfd, 0xed, 0x02, 0x5c, 0xad, 0x95, 0xe7, 0xe7, 0xaa, 0x86, 0x6f, 0xd2, 0x2c, - 0x39, 0xf6, 0x63, 0xd3, 0x90, 0x46, 0xef, 0x2a, 0x5c, 0x8a, 0xa1, 0xa6, 0xd1, 0x8a, 0x0a, 0x8c, - 0x69, 0xfc, 0x36, 0xdf, 0x5c, 0x6a, 0x0b, 0x9a, 0x3a, 0x37, 0xb5, 0xa2, 0x8b, 0x76, 0x16, 0x23, - 0xd6, 0x47, 0x31, 0x54, 0x6d, 0xc3, 0x76, 0xbc, 0x46, 0xc7, 0x13, 0x4a, 0x80, 0x7d, 0x94, 0xa8, - 0xc3, 0x15, 0x44, 0x5d, 0xaa, 0xf0, 0xf9, 0x90, 0x9f, 0xc8, 0xc1, 0x58, 0xd9, 0xf3, 0x1c, 0x73, - 0xb5, 0xe3, 0xd1, 0x79, 0xbd, 0xdd, 0x36, 0xad, 0x75, 0x1c, 0xeb, 0x83, 0xb7, 0xdf, 0x0e, 0xd6, - 0xc8, 0xae, 0x92, 0xb8, 0x19, 0x2f, 0x2e, 0x0d, 0x51, 0xdd, 0x47, 0xd5, 0x5b, 0x1c, 0x27, 0x0f, - 0xd1, 0x78, 0x39, 0x36, 0x44, 0x53, 0x79, 0xed, 0x6b, 0x88, 0x7e, 0xbb, 0x00, 0x57, 0x16, 0x1f, - 0x79, 0xba, 0x46, 0x5d, 0xbb, 0xe3, 0x34, 0xa8, 0xbb, 0xd2, 0x36, 0x74, 0x8f, 0x86, 0x23, 0x75, - 0x02, 0x7a, 0xcb, 0x86, 0x41, 0x0d, 0x64, 0xd7, 0xcb, 0xb7, 0x7d, 0x3a, 0x03, 0x68, 0x1c, 0x4e, - 0x3e, 0x0d, 0x7d, 0xa2, 0x0c, 0x72, 0xef, 0x9d, 0x1c, 0xdc, 0xd9, 0x9e, 0xe8, 0xeb, 0x70, 0x90, - 0xe6, 0xe3, 0x18, 0x59, 0x85, 0x36, 0x29, 0x23, 0x2b, 0x84, 0x64, 0x06, 0x07, 0x69, 0x3e, 0x8e, - 0xbc, 0x07, 0x23, 0xc8, 0x36, 0x68, 0x8f, 0x98, 0xfb, 0xce, 0xfb, 0xd2, 0x95, 0x1b, 0xcb, 0x97, - 0x26, 0x6c, 0x4d, 0xdd, 0xf1, 0x0b, 0x68, 0x31, 0x06, 0xe4, 0x21, 0x8c, 0x89, 0x46, 0x84, 0x4c, - 0x7b, 0xbb, 0x30, 0xbd, 0xb0, 0xb3, 0x3d, 0x31, 0x2e, 0xda, 0x2f, 0xb1, 0x4d, 0x30, 0x61, 0x8c, - 0x45, 0xb3, 0x43, 0xc6, 0xa5, 0xdd, 0x18, 0x8b, 0x2f, 0x96, 0x19, 0xc7, 0x99, 0xa8, 0xef, 0xc3, - 0x90, 0x5c, 0x90, 0x5c, 0xc4, 0xad, 0x35, 0x1f, 0x27, 0xb8, 0x29, 0x37, 0x0d, 0xdc, 0x4f, 0xbf, - 0x0c, 0x83, 0x15, 0xea, 0x36, 0x1c, 0xb3, 0xcd, 0xac, 0x06, 0xa1, 0xe4, 0xa3, 0x3b, 0xdb, 0x13, - 0x83, 0x46, 0x08, 0xd6, 0x64, 0x1a, 0xf5, 0xff, 0xca, 0xc1, 0x45, 0xc6, 0xbb, 0xec, 0xba, 0xe6, - 0xba, 0xd5, 0x92, 0x97, 0xed, 0x17, 0xa1, 0x54, 0xc3, 0xfa, 0x44, 0x4d, 0xe7, 0x77, 0xb6, 0x27, - 0xc6, 0x78, 0x0b, 0x24, 0x3d, 0x14, 0x34, 0xc1, 0xbe, 0x32, 0xbf, 0xcb, 0xbe, 0x92, 0x99, 0xb4, - 0x9e, 0xee, 0x78, 0xa6, 0xb5, 0x5e, 0xf3, 0x74, 0xaf, 0xe3, 0x46, 0x4c, 0x5a, 0x81, 0xa9, 0xbb, - 0x88, 0x8a, 0x98, 0xb4, 0x91, 0x42, 0xe4, 0x5d, 0x18, 0x9a, 0xb6, 0x8c, 0x90, 0x09, 0x9f, 0x10, - 0x9f, 0x66, 0x96, 0x26, 0x45, 0x78, 0x92, 0x45, 0xa4, 0x80, 0xfa, 0xd7, 0x72, 0xa0, 0xf0, 0x4d, - 0xe0, 0x9c, 0xe9, 0x7a, 0xf3, 0xb4, 0xb5, 0x2a, 0xcd, 0x4e, 0x33, 0xfe, 0xae, 0x92, 0xe1, 0xa4, - 0xb5, 0x08, 0x4d, 0x01, 0xb1, 0xab, 0x6c, 0x9a, 0x6e, 0x62, 0xfb, 0x11, 0x2b, 0x45, 0xaa, 0xd0, - 0xc7, 0x39, 0x73, 0x5b, 0x62, 0xf0, 0xb6, 0xe2, 0x2b, 0x42, 0xbc, 0x6a, 0xae, 0x0c, 0x2d, 0x4e, - 0x2c, 0x6f, 0x68, 0x44, 0x79, 0xf5, 0xaf, 0xe7, 0x61, 0x2c, 0x5e, 0x88, 0x3c, 0x84, 0xfe, 0x7b, - 0xb6, 0x69, 0x51, 0x63, 0xd1, 0xc2, 0x16, 0x76, 0x3f, 0x1c, 0xf1, 0x6d, 0xf1, 0x73, 0x1f, 0x60, - 0x99, 0xba, 0x6c, 0xc1, 0xe2, 0x59, 0x49, 0xc0, 0x8c, 0x7c, 0x19, 0x06, 0x98, 0x0d, 0xf8, 0x18, - 0x39, 0xe7, 0x77, 0xe5, 0xfc, 0xac, 0xe0, 0x7c, 0xde, 0xe1, 0x85, 0x92, 0xac, 0x43, 0x76, 0x4c, - 0xaf, 0x34, 0xaa, 0xbb, 0xb6, 0x25, 0x7a, 0x1e, 0xf5, 0xca, 0x41, 0x88, 0xac, 0x57, 0x9c, 0x86, - 0x99, 0xae, 0xfc, 0x63, 0xb1, 0x1b, 0xa4, 0xbd, 0x0b, 0x97, 0x55, 0xbc, 0x07, 0x24, 0x62, 0xf5, - 0xc7, 0xf2, 0xf0, 0x52, 0x28, 0x32, 0x8d, 0x3e, 0x36, 0xe9, 0xa6, 0x10, 0xe7, 0x86, 0xd9, 0x16, - 0x7b, 0x56, 0xa6, 0xf2, 0xee, 0xd4, 0x86, 0x6e, 0xad, 0x53, 0x83, 0xdc, 0x80, 0x5e, 0xcd, 0x6e, - 0x52, 0x57, 0xc9, 0xa1, 0xb9, 0x86, 0xd3, 0x89, 0xc3, 0x00, 0xf2, 0xa1, 0x07, 0x52, 0x10, 0x1b, - 0x4a, 0xcb, 0x8e, 0x6e, 0x7a, 0x7e, 0xcf, 0x96, 0x93, 0x3d, 0xbb, 0x87, 0x1a, 0x6f, 0x72, 0x1e, - 0x7c, 0xce, 0x47, 0x41, 0x78, 0x08, 0x90, 0x05, 0xc1, 0x49, 0x2e, 0xbf, 0x01, 0x83, 0x12, 0xf1, - 0xbe, 0x26, 0xf5, 0xdf, 0x29, 0xca, 0xba, 0xee, 0x37, 0x4b, 0xe8, 0xfa, 0x2d, 0xa6, 0xa3, 0xae, - 0xcb, 0xac, 0x0a, 0xae, 0xe4, 0x42, 0x13, 0x11, 0x14, 0xd5, 0x44, 0x04, 0x91, 0x57, 0xa0, 0x9f, - 0xb3, 0x08, 0xf6, 0xaf, 0xb8, 0xf7, 0x75, 0x10, 0x16, 0x5d, 0x9a, 0x03, 0x42, 0xf2, 0xcb, 0x39, - 0x78, 0xa6, 0xab, 0x24, 0x50, 0x19, 0x06, 0x6f, 0xbf, 0x7a, 0x20, 0x31, 0x4e, 0xbe, 0xb4, 0xb3, - 0x3d, 0x71, 0xa3, 0x15, 0x90, 0xd4, 0x1d, 0x89, 0xa6, 0xde, 0xe0, 0x44, 0x52, 0xbb, 0xba, 0x37, - 0x85, 0x19, 0x8f, 0xbc, 0xd2, 0x19, 0x3c, 0x3a, 0xb2, 0x1a, 0x5b, 0x7e, 0x23, 0x8b, 0xa1, 0xf1, - 0x28, 0xbe, 0x77, 0xcd, 0x27, 0x49, 0xa9, 0x26, 0x83, 0x0b, 0x69, 0xc0, 0x25, 0x8e, 0xa9, 0xe8, - 0x5b, 0x8b, 0x6b, 0xf3, 0xb6, 0xe5, 0x6d, 0xf8, 0x15, 0xf4, 0xca, 0x67, 0x2f, 0x58, 0x81, 0xa1, - 0x6f, 0xd5, 0xed, 0xb5, 0x7a, 0x8b, 0x51, 0xa5, 0xd4, 0x91, 0xc5, 0x89, 0x4d, 0xb4, 0x62, 0xcc, - 0xf9, 0x53, 0x50, 0x29, 0x3c, 0x19, 0xf3, 0xc7, 0x69, 0x72, 0xc2, 0x89, 0x15, 0x52, 0xab, 0x30, - 0x34, 0x67, 0x37, 0x1e, 0x05, 0xea, 0xf2, 0x06, 0x94, 0x96, 0x75, 0x67, 0x9d, 0x7a, 0x28, 0x8b, - 0xc1, 0xdb, 0xe3, 0x37, 0xf9, 0x69, 0x33, 0x23, 0xe2, 0x88, 0xc9, 0x11, 0x31, 0x1b, 0x94, 0x3c, - 0xfc, 0xad, 0x89, 0x02, 0xea, 0xf7, 0x7a, 0x61, 0x48, 0x9c, 0x8c, 0xe2, 0x6c, 0x4e, 0xde, 0x0c, - 0xcf, 0x9a, 0xc5, 0xf4, 0x15, 0x9c, 0x0e, 0x05, 0xa7, 0x5a, 0x43, 0x8c, 0xd9, 0x3f, 0xd8, 0x9e, - 0xc8, 0xed, 0x6c, 0x4f, 0xf4, 0x68, 0xfd, 0xd2, 0xa6, 0x32, 0x5c, 0x6f, 0xa4, 0x05, 0x56, 0x3e, - 0xeb, 0x8c, 0x95, 0xe5, 0xeb, 0xcf, 0xbb, 0xd0, 0x27, 0xda, 0x20, 0x34, 0xee, 0x52, 0x78, 0x96, - 0x11, 0x39, 0xe1, 0x8d, 0x95, 0xf6, 0x4b, 0x91, 0xb7, 0xa1, 0xc4, 0xf7, 0xf6, 0x42, 0x00, 0x17, - 0xd3, 0xcf, 0x42, 0x62, 0xc5, 0x45, 0x19, 0x32, 0x0b, 0x10, 0xee, 0xeb, 0x83, 0x03, 0x6d, 0xc1, - 0x21, 0xb9, 0xe3, 0x8f, 0x71, 0x91, 0xca, 0x92, 0xd7, 0x60, 0x68, 0x99, 0x3a, 0x2d, 0xd3, 0xd2, - 0x9b, 0x35, 0xf3, 0x43, 0xff, 0x4c, 0x1b, 0x17, 0x5e, 0xd7, 0xfc, 0x50, 0x1e, 0xb9, 0x11, 0x3a, - 0xf2, 0x95, 0xb4, 0x7d, 0x73, 0x1f, 0x36, 0xe4, 0xb9, 0x5d, 0x37, 0x94, 0xb1, 0xf6, 0xa4, 0x6c, - 0xa3, 0xdf, 0x83, 0xe1, 0xc8, 0x96, 0x49, 0x1c, 0x5a, 0x3e, 0x93, 0x64, 0x2d, 0xed, 0xff, 0x62, - 0x6c, 0xa3, 0x1c, 0x98, 0x26, 0x57, 0x2d, 0xd3, 0x33, 0xf5, 0xe6, 0x94, 0xdd, 0x6a, 0xe9, 0x96, - 0xa1, 0x0c, 0x84, 0x9a, 0x6c, 0x72, 0x4c, 0xbd, 0xc1, 0x51, 0xb2, 0x26, 0x47, 0x0b, 0xb1, 0x6d, - 0xb9, 0xe8, 0x43, 0x8d, 0x36, 0x6c, 0x87, 0xd9, 0x02, 0x78, 0x26, 0x29, 0xb6, 0xe5, 0x2e, 0xc7, - 0xd5, 0x1d, 0x1f, 0x29, 0x1b, 0xdb, 0xf1, 0x82, 0xf7, 0x8a, 0xfd, 0x83, 0x63, 0x43, 0xf1, 0x63, - 0x64, 0xf5, 0xaf, 0x16, 0x60, 0x50, 0x90, 0xb2, 0xa5, 0xf4, 0x4c, 0xc1, 0x0f, 0xa3, 0xe0, 0xa9, - 0x8a, 0x5a, 0x3a, 0x2a, 0x45, 0x55, 0xbf, 0x9e, 0x0f, 0x66, 0xa3, 0x25, 0xc7, 0xb4, 0x0e, 0x37, - 0x1b, 0x5d, 0x03, 0x98, 0xda, 0xe8, 0x58, 0x8f, 0xf8, 0x75, 0x59, 0x3e, 0xbc, 0x2e, 0x6b, 0x98, - 0x9a, 0x84, 0x21, 0xcf, 0x40, 0xb1, 0xc2, 0xf8, 0xb3, 0x9e, 0x19, 0x9a, 0x1c, 0xf8, 0x2e, 0xe7, - 0x94, 0x7b, 0x49, 0x43, 0x30, 0xdb, 0x5c, 0x4d, 0x6e, 0x79, 0x94, 0x9b, 0xb3, 0x05, 0xbe, 0xb9, - 0x5a, 0x65, 0x00, 0x8d, 0xc3, 0xc9, 0x1d, 0x18, 0xaf, 0xd0, 0xa6, 0xbe, 0x35, 0x6f, 0x36, 0x9b, - 0xa6, 0x4b, 0x1b, 0xb6, 0x65, 0xb8, 0x28, 0x64, 0x51, 0x5d, 0xcb, 0xd5, 0x92, 0x04, 0x44, 0x85, - 0xd2, 0xe2, 0xda, 0x9a, 0x4b, 0x3d, 0x14, 0x5f, 0x61, 0x12, 0xd8, 0xe4, 0x6c, 0x23, 0x44, 0x13, - 0x18, 0xf5, 0xd7, 0x72, 0x6c, 0xf7, 0xe2, 0x3e, 0xf2, 0xec, 0x76, 0xa0, 0xe5, 0x87, 0x12, 0xc9, - 0x8d, 0xd0, 0xae, 0xc8, 0xe3, 0xd7, 0x8e, 0x8a, 0xaf, 0xed, 0x13, 0xb6, 0x45, 0x68, 0x51, 0xa4, - 0x7e, 0x55, 0x61, 0x97, 0xaf, 0x52, 0xff, 0x30, 0x0f, 0x97, 0x44, 0x8b, 0xa7, 0x9a, 0x66, 0x7b, - 0xd5, 0xd6, 0x1d, 0x43, 0xa3, 0x0d, 0x6a, 0x3e, 0xa6, 0x27, 0x73, 0xe0, 0x45, 0x87, 0x4e, 0xf1, - 0x10, 0x43, 0xe7, 0x36, 0x6e, 0x04, 0x99, 0x64, 0xf0, 0xc0, 0x97, 0x1b, 0x15, 0x63, 0x3b, 0xdb, - 0x13, 0x43, 0x06, 0x07, 0xe3, 0x91, 0xbf, 0x26, 0x13, 0x31, 0x25, 0x99, 0xa3, 0xd6, 0xba, 0xb7, - 0x81, 0x4a, 0xd2, 0xcb, 0x95, 0xa4, 0x89, 0x10, 0x4d, 0x60, 0xd4, 0xff, 0x2d, 0x0f, 0xe7, 0xe3, - 0x22, 0xaf, 0x51, 0xcb, 0x38, 0x93, 0xf7, 0x47, 0x23, 0xef, 0x3f, 0x2a, 0xc0, 0xd3, 0xa2, 0x4c, - 0x6d, 0x43, 0x77, 0xa8, 0x51, 0x31, 0x1d, 0xda, 0xf0, 0x6c, 0x67, 0xeb, 0x04, 0x1b, 0x50, 0x47, - 0x27, 0xf6, 0x3b, 0x50, 0x12, 0xdb, 0x7f, 0xbe, 0xce, 0x8c, 0x04, 0x2d, 0x41, 0x68, 0x62, 0x85, - 0xe2, 0x47, 0x07, 0xb1, 0xce, 0x2a, 0xed, 0xa5, 0xb3, 0x3e, 0x0f, 0xc3, 0x81, 0xe8, 0x71, 0x23, - 0xda, 0x17, 0x5a, 0x5b, 0x86, 0x8f, 0xc0, 0xbd, 0xa8, 0x16, 0x25, 0xc4, 0xda, 0x7c, 0x40, 0xb5, - 0x82, 0xd6, 0xd0, 0xb0, 0xa8, 0x2d, 0x28, 0x67, 0x1a, 0x9a, 0x4c, 0xa4, 0x6e, 0x17, 0xe1, 0x72, - 0x7a, 0xb7, 0x6b, 0x54, 0x37, 0xce, 0x7a, 0xfd, 0x13, 0xd9, 0xeb, 0xe4, 0x39, 0x28, 0x2e, 0xe9, - 0xde, 0x86, 0xb8, 0x7e, 0xc7, 0x3b, 0xe1, 0x35, 0xb3, 0x49, 0xeb, 0x6d, 0xdd, 0xdb, 0xd0, 0x10, - 0x25, 0xcd, 0x19, 0x80, 0x1c, 0x53, 0xe6, 0x0c, 0x69, 0xb1, 0x1f, 0x7c, 0x36, 0x77, 0xbd, 0x98, - 0xba, 0xd8, 0x7f, 0xaf, 0x98, 0x35, 0xaf, 0x3c, 0x74, 0x4c, 0x8f, 0x9e, 0x69, 0xd8, 0x99, 0x86, - 0x1d, 0x52, 0xc3, 0xfe, 0x51, 0x1e, 0x86, 0x83, 0x4d, 0xd3, 0x07, 0xb4, 0x71, 0x3c, 0x6b, 0x55, - 0xb8, 0x95, 0x29, 0x1c, 0x7a, 0x2b, 0x73, 0x18, 0x85, 0x52, 0x83, 0x23, 0x4f, 0x6e, 0x1a, 0xa0, - 0xc4, 0xf8, 0x91, 0x67, 0x70, 0xd0, 0xf9, 0x1c, 0xf4, 0xcd, 0xeb, 0x4f, 0xcc, 0x56, 0xa7, 0x25, - 0xac, 0x74, 0x74, 0x27, 0x6b, 0xe9, 0x4f, 0x34, 0x1f, 0xae, 0xfe, 0xb7, 0x39, 0x18, 0x11, 0x42, - 0x15, 0xcc, 0x0f, 0x25, 0xd5, 0x50, 0x3a, 0xf9, 0x43, 0x4b, 0xa7, 0x70, 0x70, 0xe9, 0xa8, 0x7f, - 0xbe, 0x00, 0xca, 0x8c, 0xd9, 0xa4, 0xcb, 0x8e, 0x6e, 0xb9, 0x6b, 0xd4, 0x11, 0xdb, 0xe9, 0x69, - 0xc6, 0xea, 0x50, 0x1f, 0x28, 0x4d, 0x29, 0xf9, 0x03, 0x4d, 0x29, 0x9f, 0x85, 0x01, 0xd1, 0x98, - 0xc0, 0x95, 0x11, 0x47, 0x8d, 0xe3, 0x03, 0xb5, 0x10, 0xcf, 0x88, 0xcb, 0xed, 0xb6, 0x63, 0x3f, - 0xa6, 0x0e, 0xbf, 0xa5, 0x12, 0xc4, 0xba, 0x0f, 0xd4, 0x42, 0xbc, 0xc4, 0x99, 0xfa, 0xf6, 0xa2, - 0xcc, 0x99, 0x3a, 0x5a, 0x88, 0x27, 0xd7, 0xa1, 0x7f, 0xce, 0x6e, 0xe8, 0x28, 0x68, 0x3e, 0xad, - 0x0c, 0xed, 0x6c, 0x4f, 0xf4, 0x37, 0x05, 0x4c, 0x0b, 0xb0, 0x8c, 0xb2, 0x62, 0x6f, 0x5a, 0x4d, - 0x5b, 0xe7, 0xce, 0x2f, 0xfd, 0x9c, 0xd2, 0x10, 0x30, 0x2d, 0xc0, 0x32, 0x4a, 0x26, 0x73, 0x74, - 0x2a, 0xea, 0x0f, 0x79, 0xae, 0x09, 0x98, 0x16, 0x60, 0xd5, 0x5f, 0x2b, 0x32, 0xed, 0x75, 0xcd, - 0x0f, 0x4f, 0xfd, 0xba, 0x10, 0x0e, 0x98, 0xde, 0x03, 0x0c, 0x98, 0x53, 0x73, 0x60, 0xa7, 0xfe, - 0x8b, 0x3e, 0x00, 0x21, 0xfd, 0xe9, 0xb3, 0xcd, 0xe1, 0xe1, 0xb4, 0xa6, 0x02, 0xe3, 0xd3, 0xd6, - 0x86, 0x6e, 0x35, 0xa8, 0x11, 0x1e, 0x5b, 0x96, 0x70, 0x68, 0xa3, 0x13, 0x24, 0x15, 0xc8, 0xf0, - 0xdc, 0x52, 0x4b, 0x16, 0x20, 0x2f, 0xc3, 0x60, 0xd5, 0xf2, 0xa8, 0xa3, 0x37, 0x3c, 0xf3, 0x31, - 0x15, 0x53, 0x03, 0xde, 0x0c, 0x9b, 0x21, 0x58, 0x93, 0x69, 0xc8, 0x1d, 0x18, 0x5a, 0xd2, 0x1d, - 0xcf, 0x6c, 0x98, 0x6d, 0xdd, 0xf2, 0x5c, 0xa5, 0x1f, 0x67, 0x34, 0xb4, 0x30, 0xda, 0x12, 0x5c, - 0x8b, 0x50, 0x91, 0xaf, 0xc0, 0x00, 0x6e, 0x4d, 0xd1, 0x5f, 0x7b, 0x60, 0xd7, 0x8b, 0xc3, 0xe7, - 0x43, 0xf7, 0x40, 0x7e, 0xfa, 0x8a, 0x37, 0xc0, 0xf1, 0xbb, 0xc3, 0x80, 0x23, 0xf9, 0x12, 0xf4, - 0x4d, 0x5b, 0x06, 0x32, 0x87, 0x5d, 0x99, 0xab, 0x82, 0xf9, 0xc5, 0x90, 0xb9, 0xdd, 0x8e, 0xf1, - 0xf6, 0xd9, 0xa5, 0x8f, 0xb2, 0xc1, 0x8f, 0x6e, 0x94, 0x0d, 0x7d, 0x04, 0xc7, 0xe2, 0xc3, 0x47, - 0x75, 0x2c, 0x3e, 0x72, 0xc0, 0x63, 0x71, 0xf5, 0x43, 0x18, 0x9c, 0x5c, 0x9a, 0x09, 0x46, 0xef, - 0x53, 0x50, 0x58, 0x12, 0x9e, 0x0a, 0x45, 0x6e, 0xcf, 0xb4, 0x4d, 0x43, 0x63, 0x30, 0x72, 0x03, - 0xfa, 0xa7, 0xd0, 0xfd, 0x4d, 0xdc, 0x22, 0x16, 0xf9, 0xfa, 0xd7, 0x40, 0x18, 0x7a, 0xc1, 0xfa, - 0x68, 0xf2, 0x69, 0xe8, 0x5b, 0x72, 0xec, 0x75, 0x47, 0x6f, 0x89, 0x35, 0x18, 0x5d, 0x45, 0xda, - 0x1c, 0xa4, 0xf9, 0x38, 0xf5, 0xa7, 0x72, 0xbe, 0xd9, 0xce, 0x4a, 0xd4, 0x3a, 0x78, 0x34, 0x8f, - 0x75, 0xf7, 0xf3, 0x12, 0x2e, 0x07, 0x69, 0x3e, 0x8e, 0xdc, 0x80, 0xde, 0x69, 0xc7, 0xb1, 0x1d, - 0xd9, 0xc7, 0x9d, 0x32, 0x80, 0x7c, 0xdd, 0x8b, 0x14, 0xe4, 0x75, 0x18, 0xe4, 0x73, 0x0e, 0x3f, - 0xd1, 0x2c, 0x74, 0xbb, 0x29, 0x95, 0x29, 0xd5, 0xef, 0x14, 0x24, 0x9b, 0x8d, 0x4b, 0xfc, 0x14, - 0xde, 0x0a, 0xbc, 0x02, 0x85, 0xc9, 0xa5, 0x19, 0x31, 0x01, 0x9e, 0xf3, 0x8b, 0x4a, 0xaa, 0x12, - 0x2b, 0xc7, 0xa8, 0xc9, 0x15, 0x28, 0x2e, 0x31, 0xf5, 0x29, 0xa1, 0x7a, 0xf4, 0xef, 0x6c, 0x4f, - 0x14, 0xdb, 0x4c, 0x7f, 0x10, 0x8a, 0x58, 0xb6, 0x99, 0xe1, 0x3b, 0x26, 0x8e, 0x0d, 0xf7, 0x31, - 0x57, 0xa0, 0x58, 0x76, 0xd6, 0x1f, 0x8b, 0x59, 0x0b, 0xb1, 0xba, 0xb3, 0xfe, 0x58, 0x43, 0x28, - 0xb9, 0x05, 0xa0, 0x51, 0xaf, 0xe3, 0x58, 0xf8, 0xfc, 0x64, 0x00, 0xcf, 0xdf, 0x70, 0x36, 0x74, - 0x10, 0x5a, 0x6f, 0xd8, 0x06, 0xd5, 0x24, 0x12, 0xf5, 0xaf, 0x84, 0x17, 0x3b, 0x15, 0xd3, 0x7d, - 0x74, 0xd6, 0x85, 0xfb, 0xe8, 0x42, 0x5d, 0x1c, 0x71, 0x26, 0x3b, 0x69, 0x02, 0x7a, 0x67, 0x9a, - 0xfa, 0xba, 0x8b, 0x7d, 0x28, 0x7c, 0xc9, 0xd6, 0x18, 0x40, 0xe3, 0xf0, 0x58, 0x3f, 0xf5, 0xef, - 0xde, 0x4f, 0x3f, 0xdb, 0x1b, 0x8c, 0xb6, 0x05, 0xea, 0x6d, 0xda, 0xce, 0x59, 0x57, 0xed, 0xb5, - 0xab, 0xae, 0x41, 0x5f, 0xcd, 0x69, 0x48, 0x47, 0x17, 0xb8, 0x1f, 0x70, 0x9d, 0x06, 0x3f, 0xb6, - 0xf0, 0x91, 0x8c, 0xae, 0xe2, 0x7a, 0x48, 0xd7, 0x17, 0xd2, 0x19, 0xae, 0x27, 0xe8, 0x04, 0x52, - 0xd0, 0x2d, 0xd9, 0x8e, 0x27, 0x3a, 0x2e, 0xa0, 0x6b, 0xdb, 0x8e, 0xa7, 0xf9, 0x48, 0xf2, 0x59, - 0x80, 0xe5, 0xa9, 0x25, 0xdf, 0xd9, 0x7e, 0x20, 0xf4, 0x05, 0x14, 0x5e, 0xf6, 0x9a, 0x84, 0x26, - 0xcb, 0x30, 0xb0, 0xd8, 0xa6, 0x0e, 0xdf, 0x0a, 0xf1, 0x07, 0x25, 0x9f, 0x89, 0x89, 0x56, 0xf4, - 0xfb, 0x4d, 0xf1, 0x7f, 0x40, 0xce, 0xd7, 0x17, 0xdb, 0xff, 0xa9, 0x85, 0x8c, 0xc8, 0xeb, 0x50, - 0x2a, 0x73, 0x3b, 0x6f, 0x10, 0x59, 0x06, 0x22, 0xc3, 0x2d, 0x28, 0x47, 0xf1, 0x3d, 0xbb, 0x8e, - 0x7f, 0x6b, 0x82, 0x5c, 0xbd, 0x01, 0x63, 0xf1, 0x6a, 0xc8, 0x20, 0xf4, 0x4d, 0x2d, 0x2e, 0x2c, - 0x4c, 0x4f, 0x2d, 0x8f, 0xf5, 0x90, 0x7e, 0x28, 0xd6, 0xa6, 0x17, 0x2a, 0x63, 0x39, 0xf5, 0x57, - 0xa4, 0x19, 0x84, 0xa9, 0xd6, 0xd9, 0xd5, 0xf0, 0xa1, 0xee, 0x5b, 0xc6, 0xf0, 0x3e, 0x14, 0x4f, - 0x0c, 0x5a, 0xa6, 0xe7, 0x51, 0x43, 0xac, 0x12, 0x78, 0x5f, 0xe8, 0x3d, 0xd1, 0x12, 0x78, 0xf2, - 0x22, 0x0c, 0x23, 0x4c, 0x5c, 0x11, 0xf2, 0xfd, 0xb1, 0x28, 0xe0, 0x3c, 0xd1, 0xa2, 0x48, 0xf5, - 0xf7, 0xc2, 0xdb, 0xe1, 0x39, 0xaa, 0x9f, 0xd4, 0x1b, 0xc5, 0x8f, 0x49, 0x7f, 0xa9, 0xff, 0xaa, - 0xc8, 0x9f, 0x80, 0xf0, 0xf7, 0x82, 0xc7, 0x21, 0xca, 0xf0, 0x48, 0xb7, 0xb0, 0x8f, 0x23, 0xdd, - 0x17, 0xa1, 0x34, 0x4f, 0xbd, 0x0d, 0xdb, 0x77, 0xfc, 0x42, 0x0f, 0xbd, 0x16, 0x42, 0x64, 0x0f, - 0x3d, 0x4e, 0x43, 0x1e, 0x01, 0xf1, 0x1f, 0x03, 0x06, 0x8e, 0xd8, 0xfe, 0x11, 0xf2, 0xa5, 0xc4, - 0x3e, 0xa5, 0x86, 0x2f, 0x81, 0xd1, 0xc7, 0xfe, 0x7c, 0xe0, 0xe8, 0x2d, 0x79, 0x62, 0xfd, 0xcb, - 0xed, 0x89, 0x12, 0xa7, 0xd1, 0x52, 0xd8, 0x92, 0xf7, 0x60, 0x60, 0x7e, 0xa6, 0x2c, 0x1e, 0x06, - 0x72, 0xaf, 0x88, 0xa7, 0x02, 0x29, 0xfa, 0x88, 0x40, 0x24, 0xf8, 0xde, 0xa6, 0xb5, 0xa6, 0x27, - 0xdf, 0x05, 0x86, 0x5c, 0x98, 0xb6, 0xf0, 0x97, 0x3b, 0xe2, 0x74, 0x21, 0xd0, 0x96, 0xe8, 0x7b, - 0x9e, 0xb8, 0xac, 0x38, 0x36, 0xa6, 0x2d, 0xfd, 0x87, 0x18, 0xdd, 0x8b, 0x30, 0x5e, 0x6e, 0xb7, - 0x9b, 0x26, 0x35, 0x50, 0x5f, 0xb4, 0x4e, 0x93, 0xba, 0xc2, 0xe5, 0x07, 0x1f, 0x83, 0xe8, 0x1c, - 0x59, 0xc7, 0xe7, 0xa8, 0x75, 0xa7, 0x13, 0xf5, 0xcf, 0x4c, 0x96, 0x55, 0x7f, 0x26, 0x0f, 0x17, - 0xa7, 0x1c, 0xaa, 0x7b, 0x74, 0x7e, 0xa6, 0x5c, 0xee, 0xa0, 0x8f, 0x5c, 0xb3, 0x49, 0xad, 0xf5, - 0xe3, 0x19, 0xd6, 0x6f, 0xc1, 0x48, 0xd0, 0x80, 0x5a, 0xc3, 0x6e, 0x53, 0xf9, 0x61, 0x55, 0xc3, - 0xc7, 0xd4, 0x5d, 0x86, 0xd2, 0x62, 0xa4, 0xe4, 0x3e, 0x9c, 0x0b, 0x20, 0xe5, 0x66, 0xd3, 0xde, - 0xd4, 0x68, 0xc7, 0xe5, 0x8e, 0xb1, 0xfd, 0xdc, 0x31, 0x36, 0xe4, 0xa0, 0x33, 0x7c, 0xdd, 0x61, - 0x04, 0x5a, 0x5a, 0x29, 0xf5, 0x17, 0x0a, 0x70, 0xe9, 0x81, 0xde, 0x34, 0x8d, 0x50, 0x34, 0x1a, - 0x75, 0xdb, 0xb6, 0xe5, 0xd2, 0x13, 0x34, 0x4a, 0x23, 0x43, 0xa1, 0x78, 0x24, 0x43, 0x21, 0xd9, - 0x45, 0xbd, 0x87, 0xee, 0xa2, 0xd2, 0x81, 0xba, 0xe8, 0x7f, 0xcd, 0xc1, 0x98, 0xef, 0xf8, 0x2f, - 0x3f, 0xe2, 0x96, 0xbc, 0xd2, 0xf1, 0x08, 0x31, 0xe6, 0x07, 0x8d, 0x78, 0x52, 0x83, 0xbe, 0xe9, - 0x27, 0x6d, 0xd3, 0xa1, 0xee, 0x1e, 0x9c, 0xb8, 0x9f, 0x11, 0xc7, 0x25, 0xe3, 0x94, 0x17, 0x49, - 0x9c, 0x94, 0x70, 0x30, 0x3e, 0xe7, 0xe3, 0x4f, 0x1f, 0x26, 0xfd, 0x97, 0xe9, 0xfc, 0x39, 0x9f, - 0x78, 0x22, 0x11, 0x79, 0x9f, 0x19, 0x92, 0x92, 0xe7, 0xa1, 0xb0, 0xbc, 0x3c, 0x27, 0x66, 0x52, - 0x8c, 0x08, 0xe0, 0x79, 0xf2, 0x7b, 0x45, 0x86, 0x55, 0xff, 0x69, 0x1e, 0x80, 0xa9, 0x02, 0x1f, - 0xae, 0xc7, 0xa2, 0x84, 0x93, 0xd0, 0xef, 0x0b, 0x5c, 0xa8, 0x61, 0xe0, 0xb5, 0x1f, 0xef, 0x88, - 0x78, 0xdd, 0xc1, 0x0b, 0x8d, 0x09, 0xdf, 0x91, 0x9c, 0xdf, 0x03, 0xe0, 0xce, 0x06, 0x1d, 0xc9, - 0x7d, 0xf7, 0xf1, 0xcf, 0xc2, 0x80, 0x98, 0xf1, 0xec, 0xc8, 0xf9, 0x7f, 0xc3, 0x07, 0x6a, 0x21, - 0x3e, 0x36, 0xb5, 0x96, 0x0e, 0xb1, 0x10, 0xfb, 0xe2, 0xe5, 0xbd, 0x72, 0x26, 0xde, 0x23, 0x16, - 0xef, 0x37, 0x85, 0x78, 0xf9, 0x0b, 0x9e, 0x13, 0x2b, 0xde, 0x23, 0x3b, 0xfb, 0x56, 0xff, 0x51, - 0x0e, 0x08, 0x6b, 0xd6, 0x92, 0xee, 0xba, 0x9b, 0xb6, 0x63, 0x70, 0xe7, 0xf4, 0x63, 0x11, 0xcc, - 0xd1, 0xdd, 0x57, 0x7e, 0xa7, 0x1f, 0xce, 0x45, 0x1c, 0x7f, 0x4f, 0xf8, 0x64, 0x75, 0x23, 0x3a, - 0x9a, 0xba, 0xbd, 0x7a, 0xf9, 0x94, 0x7c, 0x21, 0xda, 0x1b, 0x79, 0x80, 0x26, 0xdd, 0x84, 0xbe, - 0x04, 0x43, 0xe2, 0x07, 0x5b, 0xa1, 0xfd, 0x9b, 0x2e, 0x1c, 0xa5, 0x2e, 0x03, 0x68, 0x11, 0x34, - 0x79, 0x15, 0x06, 0xd8, 0x80, 0x59, 0xc7, 0xe0, 0x21, 0x7d, 0xe1, 0x8b, 0x12, 0xc3, 0x07, 0xca, - 0xeb, 0x49, 0x40, 0x29, 0xbd, 0x23, 0xea, 0xdf, 0xc3, 0x3b, 0xa2, 0xaf, 0xc2, 0x60, 0xd9, 0xb2, - 0x6c, 0x0f, 0x37, 0xe9, 0xae, 0xb8, 0x9a, 0xc8, 0xb4, 0xca, 0x9f, 0xc7, 0xc7, 0xf1, 0x21, 0x7d, - 0xaa, 0x59, 0x2e, 0x33, 0x24, 0xb7, 0xfd, 0x57, 0x31, 0xd4, 0x11, 0x5e, 0xe5, 0x78, 0x3d, 0xe3, - 0x08, 0x58, 0xf2, 0x51, 0x0c, 0x76, 0xde, 0xf0, 0x92, 0x63, 0xb7, 0x6d, 0x97, 0x1a, 0x5c, 0x50, - 0x83, 0x61, 0xa8, 0x81, 0xb6, 0x40, 0xe0, 0x3b, 0xb6, 0x48, 0x20, 0x8f, 0x48, 0x11, 0xb2, 0x06, - 0xe7, 0xfd, 0x8b, 0xe2, 0xe0, 0xc5, 0x60, 0xb5, 0xe2, 0x2a, 0x43, 0xf8, 0x2a, 0x89, 0xc4, 0x95, - 0xa1, 0x5a, 0x99, 0xbc, 0xea, 0x5f, 0x8b, 0xf8, 0x4f, 0x0e, 0xeb, 0xa6, 0x21, 0x77, 0x75, 0x2a, - 0x3f, 0xf2, 0x43, 0x30, 0x38, 0xaf, 0x3f, 0xa9, 0x74, 0xc4, 0xd9, 0xcb, 0xf0, 0xde, 0x6f, 0x5f, - 0x5a, 0xfa, 0x93, 0xba, 0x21, 0xca, 0xc5, 0x6c, 0x0a, 0x99, 0x25, 0xa9, 0xc3, 0xc5, 0x25, 0xc7, - 0x6e, 0xd9, 0x1e, 0x35, 0x62, 0x8f, 0xef, 0x46, 0xc3, 0xd7, 0xba, 0x6d, 0x41, 0x51, 0xef, 0xf2, - 0x0a, 0x2f, 0x83, 0x0d, 0x69, 0xc1, 0x68, 0xd9, 0x75, 0x3b, 0x2d, 0x1a, 0xde, 0x50, 0x8d, 0xed, - 0xfa, 0x19, 0x9f, 0x11, 0x5e, 0xcb, 0x4f, 0xeb, 0x58, 0x94, 0x5f, 0x50, 0xd5, 0x3d, 0x53, 0xae, - 0x11, 0xbf, 0x25, 0xce, 0xfb, 0x5e, 0xb1, 0x7f, 0x64, 0x6c, 0x54, 0xbb, 0x94, 0x6c, 0xcc, 0xb2, - 0xe9, 0x35, 0xa9, 0xfa, 0xbb, 0x39, 0x80, 0x50, 0xc0, 0xe4, 0xa5, 0x68, 0x84, 0xa2, 0x5c, 0x78, - 0xd1, 0x21, 0xa2, 0x17, 0x44, 0x42, 0x12, 0x91, 0x2b, 0x50, 0xc4, 0x08, 0x17, 0xf9, 0xf0, 0x60, - 0xf5, 0x91, 0x69, 0x19, 0x1a, 0x42, 0x19, 0x56, 0x7a, 0x8a, 0x8e, 0x58, 0xbc, 0xd4, 0xe7, 0x56, - 0x61, 0x05, 0x46, 0x6b, 0x9d, 0x55, 0xbf, 0x6e, 0xe9, 0x5d, 0x1d, 0x06, 0xda, 0x70, 0x3b, 0xab, - 0xc1, 0x63, 0xd4, 0x48, 0x18, 0x93, 0x68, 0x11, 0xf5, 0xd7, 0x72, 0xb1, 0x59, 0xf0, 0x18, 0x17, - 0xbd, 0x4f, 0x25, 0xfd, 0x34, 0x92, 0xd3, 0x92, 0xfa, 0x17, 0xf2, 0x30, 0xb8, 0x64, 0x3b, 0x9e, - 0x08, 0x19, 0x72, 0xb2, 0x57, 0x21, 0x69, 0xaf, 0x54, 0xdc, 0xc7, 0x5e, 0xe9, 0x0a, 0x14, 0x25, - 0x17, 0x65, 0x7e, 0x2f, 0x62, 0x18, 0x8e, 0x86, 0x50, 0xf5, 0x47, 0xf2, 0x00, 0x5f, 0x7a, 0xf9, - 0xe5, 0x53, 0x2c, 0x20, 0xf5, 0xe7, 0x73, 0x30, 0x2a, 0x2e, 0xea, 0xa4, 0x58, 0x5f, 0x7d, 0xfe, - 0x15, 0xab, 0x3c, 0x2e, 0x39, 0x48, 0xf3, 0x71, 0x6c, 0x09, 0x98, 0x7e, 0x62, 0x7a, 0x78, 0x57, - 0x21, 0x05, 0xfb, 0xa2, 0x02, 0x26, 0x2f, 0x01, 0x3e, 0x1d, 0x79, 0xc9, 0xbf, 0x82, 0x2c, 0x84, - 0xeb, 0x1e, 0x2b, 0x30, 0x9d, 0x7a, 0x0d, 0xa9, 0xfe, 0x66, 0x11, 0x8a, 0xd3, 0x4f, 0x68, 0xe3, - 0x84, 0x77, 0x8d, 0x74, 0xb0, 0x59, 0x3c, 0xe4, 0xc1, 0xe6, 0x41, 0x7c, 0x2a, 0xde, 0x0d, 0xfb, - 0xb3, 0x14, 0xad, 0x3e, 0xd6, 0xf3, 0xf1, 0xea, 0xfd, 0x9e, 0x3e, 0x79, 0x2e, 0x39, 0xff, 0x45, - 0x01, 0x0a, 0xb5, 0xa9, 0xa5, 0x33, 0xbd, 0x39, 0x56, 0xbd, 0xe9, 0x7e, 0x67, 0xad, 0x06, 0xd7, - 0x50, 0xfd, 0xa1, 0x97, 0x68, 0xec, 0xc6, 0xe9, 0x8f, 0x0a, 0x30, 0x52, 0x9b, 0x59, 0x5e, 0x92, - 0x4e, 0x82, 0xef, 0x73, 0x4f, 0x3e, 0xf4, 0x29, 0xe3, 0x5d, 0x7a, 0x25, 0x61, 0xcf, 0xac, 0x54, - 0x2d, 0xef, 0xb5, 0x3b, 0x0f, 0xf4, 0x66, 0x87, 0xe2, 0xd1, 0x0b, 0xf7, 0xfb, 0x75, 0xcd, 0x0f, - 0xe9, 0x2f, 0xe0, 0xc3, 0x7f, 0x9f, 0x01, 0x79, 0x0b, 0x0a, 0x2b, 0xc2, 0x23, 0x23, 0x8b, 0xcf, - 0x2b, 0xb7, 0x39, 0x1f, 0x36, 0x09, 0x16, 0x3a, 0xa6, 0x81, 0x1c, 0x58, 0x29, 0x56, 0xf8, 0xae, - 0x58, 0x80, 0xf7, 0x54, 0x78, 0xdd, 0x2f, 0x7c, 0xb7, 0x5a, 0x21, 0x35, 0x18, 0x5c, 0xa2, 0x4e, - 0xcb, 0xc4, 0x8e, 0xf2, 0xe7, 0xec, 0xee, 0x4c, 0xd8, 0x4e, 0x65, 0xb0, 0x1d, 0x16, 0x42, 0x66, - 0x32, 0x17, 0xf2, 0x3e, 0x00, 0xb7, 0x51, 0xf6, 0x18, 0x3f, 0xf2, 0x19, 0xb4, 0xfb, 0xb9, 0x69, - 0x99, 0x62, 0xe3, 0x49, 0xcc, 0xc8, 0x23, 0x18, 0x9b, 0xb7, 0x0d, 0x73, 0xcd, 0xe4, 0xae, 0x97, - 0x58, 0x41, 0x69, 0x77, 0x87, 0x27, 0x66, 0x4a, 0xb6, 0xa4, 0x72, 0x69, 0xd5, 0x24, 0x18, 0xab, - 0xff, 0x69, 0x2f, 0x14, 0x59, 0xb7, 0x9f, 0x8d, 0xdf, 0xc3, 0x8c, 0xdf, 0x32, 0x8c, 0x3d, 0xb4, - 0x9d, 0x47, 0xa6, 0xb5, 0x1e, 0x78, 0xc5, 0x8b, 0xbd, 0x29, 0x7a, 0xf2, 0x6c, 0x72, 0x5c, 0x3d, - 0x70, 0xa0, 0xd7, 0x12, 0xe4, 0xbb, 0x8c, 0xe0, 0x37, 0x00, 0xf8, 0x5b, 0x77, 0xa4, 0xe9, 0x0f, + // 16605 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x78, 0x24, 0x49, + 0x72, 0x18, 0x86, 0x7e, 0xa0, 0xd1, 0x08, 0x3c, 0x06, 0x93, 0xf3, 0xaa, 0x9d, 0x9d, 0x5d, 0xec, + 0xd6, 0xde, 0xcd, 0xcd, 0xec, 0xed, 0xce, 0xdc, 0xce, 0xce, 0xee, 0xde, 0xbe, 0x6e, 0xaf, 0x81, + 0x06, 0x06, 0x3d, 0x83, 0xd7, 0x56, 0x63, 0x66, 0x6e, 0x8f, 0xbc, 0x6b, 0x16, 0xba, 0x12, 0x40, + 0x2d, 0xba, 0xab, 0x9a, 0x55, 0xd5, 0x83, 0xc1, 0xfa, 0xc5, 0x93, 0x29, 0x8a, 0x14, 0xf7, 0x4e, + 0xe7, 0xa3, 0x29, 0x52, 0xa2, 0x6c, 0x91, 0x7a, 0xd8, 0x14, 0x4d, 0x91, 0xa2, 0x44, 0xf3, 0x21, + 0xe9, 0x6c, 0xc9, 0xe7, 0xc7, 0x49, 0xfc, 0xcc, 0x4f, 0x92, 0x6d, 0x7d, 0xfa, 0x6c, 0x19, 0x27, + 0xd3, 0xd6, 0x1f, 0x7c, 0xf6, 0xf7, 0xd1, 0xf6, 0x7d, 0xd6, 0x59, 0x96, 0xfd, 0xf9, 0xcb, 0xc8, + 0xac, 0xaa, 0xac, 0x57, 0xe3, 0xb9, 0xc4, 0x62, 0x81, 0x3f, 0x33, 0xe8, 0x88, 0xc8, 0xc8, 0xac, + 0xc8, 0xc8, 0xcc, 0xc8, 0xcc, 0xc8, 0x08, 0xb8, 0xee, 0xd1, 0x16, 0xed, 0xd8, 0x8e, 0x77, 0xb3, + 0x45, 0x57, 0xf5, 0xe6, 0xe6, 0x4d, 0x6f, 0xb3, 0x43, 0xdd, 0x9b, 0xf4, 0x11, 0xb5, 0x3c, 0xff, + 0xbf, 0x1b, 0x1d, 0xc7, 0xf6, 0x6c, 0x52, 0xe2, 0xbf, 0x2e, 0x9f, 0x5f, 0xb5, 0x57, 0x6d, 0x04, + 0xdd, 0x64, 0x7f, 0x71, 0xec, 0xe5, 0x2b, 0xab, 0xb6, 0xbd, 0xda, 0xa2, 0x37, 0xf1, 0xd7, 0x72, + 0x77, 0xe5, 0xa6, 0xeb, 0x39, 0xdd, 0xa6, 0x27, 0xb0, 0xe3, 0x71, 0xac, 0x67, 0xb6, 0xa9, 0xeb, + 0xe9, 0xed, 0x8e, 0x20, 0x78, 0x3a, 0x4e, 0xb0, 0xe1, 0xe8, 0x9d, 0x0e, 0x75, 0x44, 0xe5, 0x97, + 0x9f, 0x4d, 0x6f, 0x27, 0xfe, 0x2b, 0x48, 0x5e, 0x4c, 0x27, 0xf1, 0x19, 0xc5, 0x38, 0xaa, 0xdf, + 0xca, 0x43, 0x79, 0x8e, 0x7a, 0xba, 0xa1, 0x7b, 0x3a, 0xb9, 0x02, 0xfd, 0x35, 0xcb, 0xa0, 0x8f, + 0x95, 0xdc, 0x33, 0xb9, 0x6b, 0x85, 0x89, 0xd2, 0xf6, 0xd6, 0x78, 0x9e, 0x9a, 0x1a, 0x07, 0x92, + 0xa7, 0xa0, 0xb8, 0xb4, 0xd9, 0xa1, 0x4a, 0xfe, 0x99, 0xdc, 0xb5, 0xc1, 0x89, 0xc1, 0xed, 0xad, + 0xf1, 0x7e, 0x94, 0x85, 0x86, 0x60, 0xf2, 0x2c, 0xe4, 0x6b, 0x55, 0xa5, 0x80, 0xc8, 0xb3, 0xdb, + 0x5b, 0xe3, 0x23, 0x5d, 0xd3, 0x78, 0xc1, 0x6e, 0x9b, 0x1e, 0x6d, 0x77, 0xbc, 0x4d, 0x2d, 0x5f, + 0xab, 0x92, 0xab, 0x50, 0x9c, 0xb4, 0x0d, 0xaa, 0x14, 0x91, 0x88, 0x6c, 0x6f, 0x8d, 0x8f, 0x36, + 0x6d, 0x83, 0x4a, 0x54, 0x88, 0x27, 0x5f, 0x84, 0xe2, 0x92, 0xd9, 0xa6, 0x4a, 0xff, 0x33, 0xb9, + 0x6b, 0x43, 0xb7, 0x2e, 0xdf, 0xe0, 0x52, 0xb9, 0xe1, 0x4b, 0xe5, 0xc6, 0x92, 0x2f, 0xb6, 0x89, + 0xb1, 0xef, 0x6e, 0x8d, 0xf7, 0x6d, 0x6f, 0x8d, 0x17, 0x99, 0x24, 0xbf, 0xf9, 0xbd, 0xf1, 0x9c, + 0x86, 0x25, 0xc9, 0x5b, 0x30, 0x34, 0xd9, 0xea, 0xba, 0x1e, 0x75, 0xe6, 0xf5, 0x36, 0x55, 0x4a, + 0x58, 0xe1, 0xe5, 0xed, 0xad, 0xf1, 0x8b, 0x4d, 0x0e, 0x6e, 0x58, 0x7a, 0x5b, 0xae, 0x58, 0x26, + 0x57, 0x7f, 0x27, 0x07, 0x67, 0xea, 0xd4, 0x75, 0x4d, 0xdb, 0x0a, 0x64, 0xf3, 0x69, 0x18, 0x14, + 0xa0, 0x5a, 0x15, 0xe5, 0x33, 0x38, 0x31, 0xb0, 0xbd, 0x35, 0x5e, 0x70, 0x4d, 0x43, 0x0b, 0x31, + 0xe4, 0x73, 0x30, 0xf0, 0xd0, 0xf4, 0xd6, 0xe6, 0xa6, 0x2b, 0x42, 0x4e, 0x17, 0xb7, 0xb7, 0xc6, + 0xc9, 0x86, 0xe9, 0xad, 0x35, 0xda, 0x2b, 0xba, 0x54, 0xa1, 0x4f, 0x46, 0x66, 0x61, 0x6c, 0xd1, + 0x31, 0x1f, 0xe9, 0x1e, 0xbd, 0x47, 0x37, 0x17, 0xed, 0x96, 0xd9, 0xdc, 0x14, 0x52, 0x7c, 0x66, + 0x7b, 0x6b, 0xfc, 0x4a, 0x87, 0xe3, 0x1a, 0xeb, 0x74, 0xb3, 0xd1, 0x41, 0xac, 0xc4, 0x24, 0x51, + 0x52, 0xfd, 0x9b, 0x25, 0x18, 0xbe, 0xef, 0x52, 0x27, 0x68, 0xf7, 0x55, 0x28, 0xb2, 0xdf, 0xa2, + 0xc9, 0x28, 0xf3, 0xae, 0x4b, 0x1d, 0x59, 0xe6, 0x0c, 0x4f, 0xae, 0x43, 0xff, 0xac, 0xbd, 0x6a, + 0x5a, 0xa2, 0xd9, 0xe7, 0xb6, 0xb7, 0xc6, 0xcf, 0xb4, 0x18, 0x40, 0xa2, 0xe4, 0x14, 0xe4, 0x0b, + 0x30, 0x5c, 0x6b, 0x33, 0x1d, 0xb2, 0x2d, 0xdd, 0xb3, 0x1d, 0xd1, 0x5a, 0x94, 0xae, 0x29, 0xc1, + 0xa5, 0x82, 0x11, 0x7a, 0xf2, 0x06, 0x40, 0xe5, 0x61, 0x5d, 0xb3, 0x5b, 0xb4, 0xa2, 0xcd, 0x0b, + 0x65, 0xc0, 0xd2, 0xfa, 0x86, 0xdb, 0x70, 0xec, 0x16, 0x6d, 0xe8, 0x8e, 0x5c, 0xad, 0x44, 0x4d, + 0xa6, 0x60, 0xb4, 0xd2, 0x6c, 0x52, 0xd7, 0xd5, 0xe8, 0x8f, 0x76, 0xa9, 0xeb, 0xb9, 0x4a, 0xff, + 0x33, 0x85, 0x6b, 0x83, 0x13, 0x4f, 0x6d, 0x6f, 0x8d, 0x3f, 0xa1, 0x23, 0xa6, 0xe1, 0x08, 0x94, + 0xc4, 0x22, 0x56, 0x88, 0x4c, 0xc0, 0x48, 0xe5, 0x83, 0xae, 0x43, 0x6b, 0x06, 0xb5, 0x3c, 0xd3, + 0xdb, 0x14, 0x1a, 0x72, 0x65, 0x7b, 0x6b, 0x5c, 0xd1, 0x19, 0xa2, 0x61, 0x0a, 0x8c, 0xc4, 0x24, + 0x5a, 0x84, 0x2c, 0xc0, 0xd9, 0x3b, 0x93, 0x8b, 0x75, 0xea, 0x3c, 0x32, 0x9b, 0xb4, 0xd2, 0x6c, + 0xda, 0x5d, 0xcb, 0x53, 0x06, 0x90, 0xcf, 0xb3, 0xdb, 0x5b, 0xe3, 0x4f, 0xad, 0x36, 0x3b, 0x0d, + 0x97, 0x63, 0x1b, 0x3a, 0x47, 0x4b, 0xcc, 0x92, 0x65, 0xc9, 0x97, 0x61, 0x64, 0xc9, 0x61, 0x5a, + 0x68, 0x54, 0x29, 0x83, 0x2b, 0x65, 0xd4, 0xff, 0x8b, 0x37, 0xc4, 0x04, 0xc4, 0xa1, 0x7e, 0xcf, + 0xf2, 0xc6, 0x7a, 0xbc, 0x40, 0xc3, 0x40, 0x9c, 0xdc, 0xd8, 0x08, 0x2b, 0x42, 0x41, 0x61, 0x1f, + 0x6f, 0x3a, 0xd4, 0x48, 0x68, 0xdb, 0x20, 0xb6, 0xf9, 0xfa, 0xf6, 0xd6, 0xf8, 0xa7, 0x1d, 0x41, + 0xd3, 0xe8, 0xa9, 0x76, 0x99, 0xac, 0xc8, 0x14, 0x94, 0x99, 0x36, 0xdd, 0x33, 0x2d, 0x43, 0x81, + 0x67, 0x72, 0xd7, 0x46, 0x6f, 0x8d, 0xf9, 0xad, 0xf7, 0xe1, 0x13, 0x97, 0xb6, 0xb7, 0xc6, 0xcf, + 0x31, 0x1d, 0x6c, 0xac, 0x9b, 0x96, 0x3c, 0x45, 0x04, 0x45, 0xd9, 0x28, 0x9a, 0xb0, 0x3d, 0x1c, + 0xba, 0x43, 0xe1, 0x28, 0x5a, 0xb6, 0xbd, 0xf8, 0xb0, 0xf5, 0xc9, 0xc8, 0x24, 0x8c, 0x4c, 0xd8, + 0x5e, 0xcd, 0x72, 0x3d, 0xdd, 0x6a, 0xd2, 0x5a, 0x55, 0x19, 0xc6, 0x72, 0xa8, 0x16, 0xac, 0x9c, + 0x29, 0x30, 0x8d, 0xc8, 0xa4, 0x14, 0x2d, 0xa3, 0xfe, 0x8b, 0x22, 0x8c, 0xb2, 0x3e, 0x91, 0x86, + 0x4f, 0x85, 0xcd, 0x04, 0x0c, 0xc2, 0x6a, 0x71, 0x3b, 0x7a, 0x93, 0x8a, 0x91, 0x84, 0x5f, 0x61, + 0xf9, 0x40, 0x89, 0x67, 0x9c, 0x9e, 0x5c, 0x87, 0x32, 0x07, 0xd5, 0xaa, 0x62, 0x70, 0x8d, 0x6c, + 0x6f, 0x8d, 0x0f, 0xba, 0x08, 0x6b, 0x98, 0x86, 0x16, 0xa0, 0x99, 0x76, 0xf3, 0xbf, 0x67, 0x6c, + 0xd7, 0x63, 0xcc, 0xc5, 0xd8, 0xc2, 0xcf, 0x10, 0x05, 0xd6, 0x04, 0x4a, 0xd6, 0xee, 0x68, 0x21, + 0xf2, 0x3a, 0x00, 0x87, 0x54, 0x0c, 0xc3, 0x11, 0x03, 0xec, 0x89, 0xed, 0xad, 0xf1, 0x0b, 0x82, + 0x85, 0x6e, 0x18, 0xf2, 0xe8, 0x94, 0x88, 0x49, 0x1b, 0x86, 0xf9, 0xaf, 0x59, 0x7d, 0x99, 0xb6, + 0xf8, 0xe8, 0x1a, 0xba, 0x75, 0xcd, 0xef, 0xc4, 0xa8, 0x74, 0x6e, 0xc8, 0xa4, 0x53, 0x96, 0xe7, + 0x6c, 0x4e, 0x8c, 0x8b, 0x09, 0xf9, 0x92, 0xa8, 0xaa, 0x85, 0x38, 0x79, 0x2a, 0x90, 0xcb, 0xb0, + 0x79, 0x7a, 0xda, 0x76, 0x36, 0x74, 0xc7, 0xa0, 0xc6, 0xc4, 0xa6, 0x3c, 0x4f, 0xaf, 0xf8, 0xe0, + 0xc6, 0xb2, 0xac, 0x7a, 0x32, 0x39, 0xeb, 0x74, 0xce, 0xad, 0xde, 0x5d, 0x46, 0x95, 0x1b, 0x48, + 0x48, 0xcb, 0xed, 0x2e, 0xc7, 0xd5, 0x2c, 0x5a, 0x86, 0x4d, 0x05, 0x1c, 0xf0, 0x80, 0x3a, 0x6c, + 0x12, 0xc7, 0x51, 0x27, 0xa6, 0x02, 0xc1, 0xe4, 0x11, 0xc7, 0x24, 0x79, 0x88, 0x22, 0x97, 0xdf, + 0x81, 0xb3, 0x09, 0x51, 0x90, 0x31, 0x28, 0xac, 0xd3, 0x4d, 0xae, 0x2e, 0x1a, 0xfb, 0x93, 0x9c, + 0x87, 0xfe, 0x47, 0x7a, 0xab, 0x2b, 0x96, 0x50, 0x8d, 0xff, 0x78, 0x23, 0xff, 0xf9, 0x1c, 0x5b, + 0x71, 0xc8, 0xa4, 0x6d, 0x59, 0xb4, 0xe9, 0xc9, 0x8b, 0xce, 0xab, 0x30, 0x38, 0x6b, 0x37, 0xf5, + 0x16, 0xf6, 0x23, 0xd7, 0x3b, 0x65, 0x7b, 0x6b, 0xfc, 0x3c, 0xeb, 0xc0, 0x1b, 0x2d, 0x86, 0x91, + 0xda, 0x14, 0x92, 0x32, 0x05, 0xd0, 0x68, 0xdb, 0xf6, 0x28, 0x16, 0xcc, 0x87, 0x0a, 0x80, 0x05, + 0x1d, 0x44, 0xc9, 0x0a, 0x10, 0x12, 0x93, 0x9b, 0x50, 0x5e, 0x64, 0xeb, 0x6c, 0xd3, 0x6e, 0x09, + 0xe5, 0xc3, 0xa5, 0x00, 0xd7, 0x5e, 0x79, 0xac, 0xfa, 0x44, 0xea, 0x0c, 0x8c, 0x4e, 0xb6, 0x4c, + 0x6a, 0x79, 0x72, 0xab, 0xd9, 0x48, 0xae, 0xac, 0x52, 0xcb, 0x93, 0x5b, 0x8d, 0x63, 0x5e, 0x67, + 0x50, 0xb9, 0xd5, 0x01, 0xa9, 0xfa, 0xfb, 0x05, 0x78, 0xe2, 0x5e, 0x77, 0x99, 0x3a, 0x16, 0xf5, + 0xa8, 0x2b, 0x16, 0xe4, 0x80, 0xeb, 0x3c, 0x9c, 0x4d, 0x20, 0x05, 0x77, 0x5c, 0x28, 0xd7, 0x03, + 0x64, 0x43, 0xac, 0xf1, 0xf2, 0x6c, 0x9b, 0x28, 0x4a, 0x66, 0xe0, 0x4c, 0x08, 0x64, 0x8d, 0x70, + 0x95, 0x3c, 0x2e, 0x25, 0x4f, 0x6f, 0x6f, 0x8d, 0x5f, 0x96, 0xb8, 0xb1, 0x66, 0xcb, 0x1a, 0x1c, + 0x2f, 0x46, 0xee, 0xc1, 0x58, 0x08, 0xba, 0xe3, 0xd8, 0xdd, 0x8e, 0xab, 0x14, 0x90, 0xd5, 0xf8, + 0xf6, 0xd6, 0xf8, 0x93, 0x12, 0xab, 0x55, 0x44, 0xca, 0x0b, 0x78, 0xbc, 0x20, 0xf9, 0xf1, 0x9c, + 0xcc, 0x4d, 0x8c, 0xc2, 0x22, 0x8e, 0xc2, 0xd7, 0xfc, 0x51, 0x98, 0x29, 0xa4, 0x1b, 0xf1, 0x92, + 0x62, 0x50, 0xc6, 0x9a, 0x91, 0x18, 0x94, 0x89, 0x1a, 0x2f, 0x4f, 0xc2, 0x85, 0x54, 0x5e, 0x7b, + 0xd2, 0xea, 0x7f, 0x5e, 0x90, 0xb9, 0x2c, 0xda, 0x46, 0xd0, 0x99, 0x0b, 0x72, 0x67, 0x2e, 0xda, + 0x06, 0x4e, 0xf5, 0xb9, 0x70, 0xed, 0x94, 0x1a, 0xdb, 0xb1, 0x8d, 0xf8, 0xac, 0x9f, 0x2c, 0x4b, + 0xbe, 0x0a, 0x17, 0x13, 0x40, 0x3e, 0x5d, 0x73, 0xed, 0xbf, 0xba, 0xbd, 0x35, 0xae, 0xa6, 0x70, + 0x8d, 0xcf, 0xde, 0x19, 0x5c, 0x88, 0x0e, 0x97, 0x24, 0xa9, 0xdb, 0x96, 0xa7, 0x9b, 0x96, 0x30, + 0x2e, 0xf9, 0x28, 0xf9, 0xcc, 0xf6, 0xd6, 0xf8, 0x73, 0xb2, 0x0e, 0xfa, 0x34, 0xf1, 0xc6, 0x67, + 0xf1, 0x21, 0x06, 0x28, 0x29, 0xa8, 0x5a, 0x5b, 0x5f, 0xf5, 0x2d, 0xe6, 0x6b, 0xdb, 0x5b, 0xe3, + 0x9f, 0x4a, 0xad, 0xc3, 0x64, 0x54, 0xf2, 0x0a, 0x9d, 0xc5, 0x89, 0x68, 0x40, 0x42, 0xdc, 0xbc, + 0x6d, 0x50, 0xfc, 0x86, 0x7e, 0xe4, 0xaf, 0x6e, 0x6f, 0x8d, 0x3f, 0x2d, 0xf1, 0xb7, 0x6c, 0x83, + 0xc6, 0x9b, 0x9f, 0x52, 0x5a, 0xfd, 0x9d, 0x02, 0x3c, 0x5d, 0xaf, 0xcc, 0xcd, 0xd6, 0x0c, 0xdf, + 0xa4, 0x59, 0x74, 0xec, 0x47, 0xa6, 0x21, 0x8d, 0xde, 0x65, 0xb8, 0x14, 0x43, 0x4d, 0xa1, 0x15, + 0x15, 0x18, 0xd3, 0xf8, 0x6d, 0xbe, 0xb9, 0xd4, 0x11, 0x34, 0x0d, 0x6e, 0x6a, 0x45, 0x17, 0xed, + 0x2c, 0x46, 0xac, 0x8f, 0x62, 0xa8, 0xfa, 0x9a, 0xed, 0x78, 0xcd, 0xae, 0x27, 0x94, 0x00, 0xfb, + 0x28, 0x51, 0x87, 0x2b, 0x88, 0x7a, 0x54, 0xe1, 0xf3, 0x21, 0x3f, 0x95, 0x83, 0xb1, 0x8a, 0xe7, + 0x39, 0xe6, 0x72, 0xd7, 0xa3, 0x73, 0x7a, 0xa7, 0x63, 0x5a, 0xab, 0x38, 0xd6, 0x87, 0x6e, 0xbd, + 0x15, 0xac, 0x91, 0x3d, 0x25, 0x71, 0x23, 0x5e, 0x5c, 0x1a, 0xa2, 0xba, 0x8f, 0x6a, 0xb4, 0x39, + 0x4e, 0x1e, 0xa2, 0xf1, 0x72, 0x6c, 0x88, 0xa6, 0xf2, 0xda, 0xd3, 0x10, 0xfd, 0x56, 0x01, 0xae, + 0x2c, 0xac, 0x7b, 0xba, 0x46, 0x5d, 0xbb, 0xeb, 0x34, 0xa9, 0x7b, 0xbf, 0x63, 0xe8, 0x1e, 0x0d, + 0x47, 0xea, 0x38, 0xf4, 0x57, 0x0c, 0x83, 0x1a, 0xc8, 0xae, 0x9f, 0x6f, 0xfb, 0x74, 0x06, 0xd0, + 0x38, 0x9c, 0x7c, 0x1a, 0x06, 0x44, 0x19, 0xe4, 0xde, 0x3f, 0x31, 0xb4, 0xbd, 0x35, 0x3e, 0xd0, + 0xe5, 0x20, 0xcd, 0xc7, 0x31, 0xb2, 0x2a, 0x6d, 0x51, 0x46, 0x56, 0x08, 0xc9, 0x0c, 0x0e, 0xd2, + 0x7c, 0x1c, 0x79, 0x17, 0x46, 0x91, 0x6d, 0xd0, 0x1e, 0x31, 0xf7, 0x9d, 0xf7, 0xa5, 0x2b, 0x37, + 0x96, 0x2f, 0x4d, 0xd8, 0x9a, 0x86, 0xe3, 0x17, 0xd0, 0x62, 0x0c, 0xc8, 0x43, 0x18, 0x13, 0x8d, + 0x08, 0x99, 0xf6, 0xf7, 0x60, 0x7a, 0x61, 0x7b, 0x6b, 0xfc, 0xac, 0x68, 0xbf, 0xc4, 0x36, 0xc1, + 0x84, 0x31, 0x16, 0xcd, 0x0e, 0x19, 0x97, 0x76, 0x62, 0x2c, 0xbe, 0x58, 0x66, 0x1c, 0x67, 0xa2, + 0xbe, 0x07, 0xc3, 0x72, 0x41, 0x72, 0x11, 0xb7, 0xd6, 0x7c, 0x9c, 0xe0, 0xa6, 0xdc, 0x34, 0x70, + 0x3f, 0xfd, 0x12, 0x0c, 0x55, 0xa9, 0xdb, 0x74, 0xcc, 0x0e, 0xb3, 0x1a, 0x84, 0x92, 0x9f, 0xd9, + 0xde, 0x1a, 0x1f, 0x32, 0x42, 0xb0, 0x26, 0xd3, 0xa8, 0xff, 0x57, 0x0e, 0x2e, 0x32, 0xde, 0x15, + 0xd7, 0x35, 0x57, 0xad, 0xb6, 0xbc, 0x6c, 0xbf, 0x00, 0xa5, 0x3a, 0xd6, 0x27, 0x6a, 0x3a, 0xbf, + 0xbd, 0x35, 0x3e, 0xc6, 0x5b, 0x20, 0xe9, 0xa1, 0xa0, 0x09, 0xf6, 0x95, 0xf9, 0x1d, 0xf6, 0x95, + 0xcc, 0xa4, 0xf5, 0x74, 0xc7, 0x33, 0xad, 0xd5, 0xba, 0xa7, 0x7b, 0x5d, 0x37, 0x62, 0xd2, 0x0a, + 0x4c, 0xc3, 0x45, 0x54, 0xc4, 0xa4, 0x8d, 0x14, 0x22, 0xef, 0xc0, 0xf0, 0x94, 0x65, 0x84, 0x4c, + 0xf8, 0x84, 0xf8, 0x24, 0xb3, 0x34, 0x29, 0xc2, 0x93, 0x2c, 0x22, 0x05, 0xd4, 0xbf, 0x9a, 0x03, + 0x85, 0x6f, 0x02, 0x67, 0x4d, 0xd7, 0x9b, 0xa3, 0xed, 0x65, 0x69, 0x76, 0x9a, 0xf6, 0x77, 0x95, + 0x0c, 0x27, 0xad, 0x45, 0x68, 0x0a, 0x88, 0x5d, 0x65, 0xcb, 0x74, 0x13, 0xdb, 0x8f, 0x58, 0x29, + 0x52, 0x83, 0x01, 0xce, 0x99, 0xdb, 0x12, 0x43, 0xb7, 0x14, 0x5f, 0x11, 0xe2, 0x55, 0x73, 0x65, + 0x68, 0x73, 0x62, 0x79, 0x43, 0x23, 0xca, 0xab, 0x7f, 0x2d, 0x0f, 0x63, 0xf1, 0x42, 0xe4, 0x21, + 0x94, 0xef, 0xda, 0xa6, 0x45, 0x8d, 0x05, 0x0b, 0x5b, 0xd8, 0xfb, 0x70, 0xc4, 0xb7, 0xc5, 0xcf, + 0xbd, 0x8f, 0x65, 0x1a, 0xb2, 0x05, 0x8b, 0x67, 0x25, 0x01, 0x33, 0xf2, 0x65, 0x18, 0x64, 0x36, + 0xe0, 0x23, 0xe4, 0x9c, 0xdf, 0x91, 0xf3, 0x33, 0x82, 0xf3, 0x79, 0x87, 0x17, 0x4a, 0xb2, 0x0e, + 0xd9, 0x31, 0xbd, 0xd2, 0xa8, 0xee, 0xda, 0x96, 0xe8, 0x79, 0xd4, 0x2b, 0x07, 0x21, 0xb2, 0x5e, + 0x71, 0x1a, 0x66, 0xba, 0xf2, 0x8f, 0xc5, 0x6e, 0x90, 0xf6, 0x2e, 0x5c, 0x56, 0xf1, 0x1e, 0x90, + 0x88, 0xd5, 0x9f, 0xc8, 0xc3, 0x8b, 0xa1, 0xc8, 0x34, 0xfa, 0xc8, 0xa4, 0x1b, 0x42, 0x9c, 0x6b, + 0x66, 0x47, 0xec, 0x59, 0x99, 0xca, 0xbb, 0x93, 0x6b, 0xba, 0xb5, 0x4a, 0x0d, 0x72, 0x1d, 0xfa, + 0x35, 0xbb, 0x45, 0x5d, 0x25, 0x87, 0xe6, 0x1a, 0x4e, 0x27, 0x0e, 0x03, 0xc8, 0x87, 0x1e, 0x48, + 0x41, 0x6c, 0x28, 0x2d, 0x39, 0xba, 0xe9, 0xf9, 0x3d, 0x5b, 0x49, 0xf6, 0xec, 0x2e, 0x6a, 0xbc, + 0xc1, 0x79, 0xf0, 0x39, 0x1f, 0x05, 0xe1, 0x21, 0x40, 0x16, 0x04, 0x27, 0xb9, 0xfc, 0x3a, 0x0c, + 0x49, 0xc4, 0x7b, 0x9a, 0xd4, 0x7f, 0xb7, 0x28, 0xeb, 0xba, 0xdf, 0x2c, 0xa1, 0xeb, 0x37, 0x99, + 0x8e, 0xba, 0x2e, 0xb3, 0x2a, 0xb8, 0x92, 0x0b, 0x4d, 0x44, 0x50, 0x54, 0x13, 0x11, 0x44, 0x5e, + 0x86, 0x32, 0x67, 0x11, 0xec, 0x5f, 0x71, 0xef, 0xeb, 0x20, 0x2c, 0xba, 0x34, 0x07, 0x84, 0xe4, + 0x57, 0x72, 0xf0, 0x54, 0x4f, 0x49, 0xa0, 0x32, 0x0c, 0xdd, 0x7a, 0x65, 0x5f, 0x62, 0x9c, 0x78, + 0x71, 0x7b, 0x6b, 0xfc, 0x7a, 0x3b, 0x20, 0x69, 0x38, 0x12, 0x4d, 0xa3, 0xc9, 0x89, 0xa4, 0x76, + 0xf5, 0x6e, 0x0a, 0x33, 0x1e, 0x79, 0xa5, 0xd3, 0x78, 0x74, 0x64, 0x35, 0x37, 0xfd, 0x46, 0x16, + 0x43, 0xe3, 0x51, 0x7c, 0xef, 0x8a, 0x4f, 0x92, 0x52, 0x4d, 0x06, 0x17, 0xd2, 0x84, 0x4b, 0x1c, + 0x53, 0xd5, 0x37, 0x17, 0x56, 0xe6, 0x6c, 0xcb, 0x5b, 0xf3, 0x2b, 0xe8, 0x97, 0xcf, 0x5e, 0xb0, + 0x02, 0x43, 0xdf, 0x6c, 0xd8, 0x2b, 0x8d, 0x36, 0xa3, 0x4a, 0xa9, 0x23, 0x8b, 0x13, 0x9b, 0x68, + 0xc5, 0x98, 0xf3, 0xa7, 0xa0, 0x52, 0x78, 0x32, 0xe6, 0x8f, 0xd3, 0xe4, 0x84, 0x13, 0x2b, 0xa4, + 0xd6, 0x60, 0x78, 0xd6, 0x6e, 0xae, 0x07, 0xea, 0xf2, 0x3a, 0x94, 0x96, 0x74, 0x67, 0x95, 0x7a, + 0x28, 0x8b, 0xa1, 0x5b, 0x67, 0x6f, 0xf0, 0xd3, 0x66, 0x46, 0xc4, 0x11, 0x13, 0xa3, 0x62, 0x36, + 0x28, 0x79, 0xf8, 0x5b, 0x13, 0x05, 0xd4, 0xef, 0xf5, 0xc3, 0xb0, 0x38, 0x19, 0xc5, 0xd9, 0x9c, + 0xbc, 0x11, 0x9e, 0x35, 0x8b, 0xe9, 0x2b, 0x38, 0x1d, 0x0a, 0x4e, 0xb5, 0x86, 0x19, 0xb3, 0x7f, + 0xb0, 0x35, 0x9e, 0xdb, 0xde, 0x1a, 0xef, 0xd3, 0xca, 0xd2, 0xa6, 0x32, 0x5c, 0x6f, 0xa4, 0x05, + 0x56, 0x3e, 0xeb, 0x8c, 0x95, 0xe5, 0xeb, 0xcf, 0x3b, 0x30, 0x20, 0xda, 0x20, 0x34, 0xee, 0x52, + 0x78, 0x96, 0x11, 0x39, 0xe1, 0x8d, 0x95, 0xf6, 0x4b, 0x91, 0xb7, 0xa0, 0xc4, 0xf7, 0xf6, 0x42, + 0x00, 0x17, 0xd3, 0xcf, 0x42, 0x62, 0xc5, 0x45, 0x19, 0x32, 0x03, 0x10, 0xee, 0xeb, 0x83, 0x03, + 0x6d, 0xc1, 0x21, 0xb9, 0xe3, 0x8f, 0x71, 0x91, 0xca, 0x92, 0x57, 0x61, 0x78, 0x89, 0x3a, 0x6d, + 0xd3, 0xd2, 0x5b, 0x75, 0xf3, 0x03, 0xff, 0x4c, 0x1b, 0x17, 0x5e, 0xd7, 0xfc, 0x40, 0x1e, 0xb9, + 0x11, 0x3a, 0xf2, 0x95, 0xb4, 0x7d, 0xf3, 0x00, 0x36, 0xe4, 0xd9, 0x1d, 0x37, 0x94, 0xb1, 0xf6, + 0xa4, 0x6c, 0xa3, 0xdf, 0x85, 0x91, 0xc8, 0x96, 0x49, 0x1c, 0x5a, 0x3e, 0x95, 0x64, 0x2d, 0xed, + 0xff, 0x62, 0x6c, 0xa3, 0x1c, 0x98, 0x26, 0xd7, 0x2c, 0xd3, 0x33, 0xf5, 0xd6, 0xa4, 0xdd, 0x6e, + 0xeb, 0x96, 0xa1, 0x0c, 0x86, 0x9a, 0x6c, 0x72, 0x4c, 0xa3, 0xc9, 0x51, 0xb2, 0x26, 0x47, 0x0b, + 0xb1, 0x6d, 0xb9, 0xe8, 0x43, 0x8d, 0x36, 0x6d, 0x87, 0xd9, 0x02, 0x78, 0x26, 0x29, 0xb6, 0xe5, + 0x2e, 0xc7, 0x35, 0x1c, 0x1f, 0x29, 0x1b, 0xdb, 0xf1, 0x82, 0x77, 0x8b, 0xe5, 0xa1, 0xb1, 0xe1, + 0xf8, 0x31, 0xb2, 0xfa, 0x57, 0x0a, 0x30, 0x24, 0x48, 0xd9, 0x52, 0x7a, 0xaa, 0xe0, 0x07, 0x51, + 0xf0, 0x54, 0x45, 0x2d, 0x1d, 0x96, 0xa2, 0xaa, 0x1f, 0xe6, 0x83, 0xd9, 0x68, 0xd1, 0x31, 0xad, + 0x83, 0xcd, 0x46, 0x57, 0x01, 0x26, 0xd7, 0xba, 0xd6, 0x3a, 0xbf, 0x2e, 0xcb, 0x87, 0xd7, 0x65, + 0x4d, 0x53, 0x93, 0x30, 0xe4, 0x29, 0x28, 0x56, 0x19, 0x7f, 0xd6, 0x33, 0xc3, 0x13, 0x83, 0xdf, + 0xe5, 0x9c, 0x72, 0x2f, 0x6a, 0x08, 0x66, 0x9b, 0xab, 0x89, 0x4d, 0x8f, 0x72, 0x73, 0xb6, 0xc0, + 0x37, 0x57, 0xcb, 0x0c, 0xa0, 0x71, 0x38, 0xb9, 0x0d, 0x67, 0xab, 0xb4, 0xa5, 0x6f, 0xce, 0x99, + 0xad, 0x96, 0xe9, 0xd2, 0xa6, 0x6d, 0x19, 0x2e, 0x0a, 0x59, 0x54, 0xd7, 0x76, 0xb5, 0x24, 0x01, + 0x51, 0xa1, 0xb4, 0xb0, 0xb2, 0xe2, 0x52, 0x0f, 0xc5, 0x57, 0x98, 0x00, 0x36, 0x39, 0xdb, 0x08, + 0xd1, 0x04, 0x46, 0xfd, 0xf5, 0x1c, 0xdb, 0xbd, 0xb8, 0xeb, 0x9e, 0xdd, 0x09, 0xb4, 0xfc, 0x40, + 0x22, 0xb9, 0x1e, 0xda, 0x15, 0x79, 0xfc, 0xda, 0x33, 0xe2, 0x6b, 0x07, 0x84, 0x6d, 0x11, 0x5a, + 0x14, 0xa9, 0x5f, 0x55, 0xd8, 0xe1, 0xab, 0xd4, 0x3f, 0xcc, 0xc3, 0x25, 0xd1, 0xe2, 0xc9, 0x96, + 0xd9, 0x59, 0xb6, 0x75, 0xc7, 0xd0, 0x68, 0x93, 0x9a, 0x8f, 0xe8, 0xf1, 0x1c, 0x78, 0xd1, 0xa1, + 0x53, 0x3c, 0xc0, 0xd0, 0xb9, 0x85, 0x1b, 0x41, 0x26, 0x19, 0x3c, 0xf0, 0xe5, 0x46, 0xc5, 0xd8, + 0xf6, 0xd6, 0xf8, 0xb0, 0xc1, 0xc1, 0x78, 0xe4, 0xaf, 0xc9, 0x44, 0x4c, 0x49, 0x66, 0xa9, 0xb5, + 0xea, 0xad, 0xa1, 0x92, 0xf4, 0x73, 0x25, 0x69, 0x21, 0x44, 0x13, 0x18, 0xf5, 0x7f, 0xcb, 0xc3, + 0xf9, 0xb8, 0xc8, 0xeb, 0xd4, 0x32, 0x4e, 0xe5, 0xfd, 0xd1, 0xc8, 0xfb, 0xfb, 0x05, 0x78, 0x52, + 0x94, 0xa9, 0xaf, 0xe9, 0x0e, 0x35, 0xaa, 0xa6, 0x43, 0x9b, 0x9e, 0xed, 0x6c, 0x1e, 0x63, 0x03, + 0xea, 0xf0, 0xc4, 0x7e, 0x1b, 0x4a, 0x62, 0xfb, 0xcf, 0xd7, 0x99, 0xd1, 0xa0, 0x25, 0x08, 0x4d, + 0xac, 0x50, 0xfc, 0xe8, 0x20, 0xd6, 0x59, 0xa5, 0xdd, 0x74, 0xd6, 0xe7, 0x61, 0x24, 0x10, 0x3d, + 0x6e, 0x44, 0x07, 0x42, 0x6b, 0xcb, 0xf0, 0x11, 0xb8, 0x17, 0xd5, 0xa2, 0x84, 0x58, 0x9b, 0x0f, + 0xa8, 0x55, 0xd1, 0x1a, 0x1a, 0x11, 0xb5, 0x05, 0xe5, 0x4c, 0x43, 0x93, 0x89, 0xd4, 0xad, 0x22, + 0x5c, 0x4e, 0xef, 0x76, 0x8d, 0xea, 0xc6, 0x69, 0xaf, 0x7f, 0x22, 0x7b, 0x9d, 0x3c, 0x0b, 0xc5, + 0x45, 0xdd, 0x5b, 0x13, 0xd7, 0xef, 0x78, 0x27, 0xbc, 0x62, 0xb6, 0x68, 0xa3, 0xa3, 0x7b, 0x6b, + 0x1a, 0xa2, 0xa4, 0x39, 0x03, 0x90, 0x63, 0xca, 0x9c, 0x21, 0x2d, 0xf6, 0x43, 0xcf, 0xe4, 0xae, + 0x15, 0x53, 0x17, 0xfb, 0xef, 0x15, 0xb3, 0xe6, 0x95, 0x87, 0x8e, 0xe9, 0xd1, 0x53, 0x0d, 0x3b, + 0xd5, 0xb0, 0x03, 0x6a, 0xd8, 0x3f, 0xca, 0xc3, 0x48, 0xb0, 0x69, 0x7a, 0x9f, 0x36, 0x8f, 0x66, + 0xad, 0x0a, 0xb7, 0x32, 0x85, 0x03, 0x6f, 0x65, 0x0e, 0xa2, 0x50, 0x6a, 0x70, 0xe4, 0xc9, 0x4d, + 0x03, 0x94, 0x18, 0x3f, 0xf2, 0x0c, 0x0e, 0x3a, 0x9f, 0x85, 0x81, 0x39, 0xfd, 0xb1, 0xd9, 0xee, + 0xb6, 0x85, 0x95, 0x8e, 0xee, 0x64, 0x6d, 0xfd, 0xb1, 0xe6, 0xc3, 0xd5, 0xff, 0x36, 0x07, 0xa3, + 0x42, 0xa8, 0x82, 0xf9, 0x81, 0xa4, 0x1a, 0x4a, 0x27, 0x7f, 0x60, 0xe9, 0x14, 0xf6, 0x2f, 0x1d, + 0xf5, 0xcf, 0x15, 0x40, 0x99, 0x36, 0x5b, 0x74, 0xc9, 0xd1, 0x2d, 0x77, 0x85, 0x3a, 0x62, 0x3b, + 0x3d, 0xc5, 0x58, 0x1d, 0xe8, 0x03, 0xa5, 0x29, 0x25, 0xbf, 0xaf, 0x29, 0xe5, 0xb3, 0x30, 0x28, + 0x1a, 0x13, 0xb8, 0x32, 0xe2, 0xa8, 0x71, 0x7c, 0xa0, 0x16, 0xe2, 0x19, 0x71, 0xa5, 0xd3, 0x71, + 0xec, 0x47, 0xd4, 0xe1, 0xb7, 0x54, 0x82, 0x58, 0xf7, 0x81, 0x5a, 0x88, 0x97, 0x38, 0x53, 0xdf, + 0x5e, 0x94, 0x39, 0x53, 0x47, 0x0b, 0xf1, 0xe4, 0x1a, 0x94, 0x67, 0xed, 0xa6, 0x8e, 0x82, 0xe6, + 0xd3, 0xca, 0xf0, 0xf6, 0xd6, 0x78, 0xb9, 0x25, 0x60, 0x5a, 0x80, 0x65, 0x94, 0x55, 0x7b, 0xc3, + 0x6a, 0xd9, 0x3a, 0x77, 0x7e, 0x29, 0x73, 0x4a, 0x43, 0xc0, 0xb4, 0x00, 0xcb, 0x28, 0x99, 0xcc, + 0xd1, 0xa9, 0xa8, 0x1c, 0xf2, 0x5c, 0x11, 0x30, 0x2d, 0xc0, 0xaa, 0xbf, 0x5e, 0x64, 0xda, 0xeb, + 0x9a, 0x1f, 0x9c, 0xf8, 0x75, 0x21, 0x1c, 0x30, 0xfd, 0xfb, 0x18, 0x30, 0x27, 0xe6, 0xc0, 0x4e, + 0xfd, 0x17, 0x03, 0x00, 0x42, 0xfa, 0x53, 0xa7, 0x9b, 0xc3, 0x83, 0x69, 0x4d, 0x15, 0xce, 0x4e, + 0x59, 0x6b, 0xba, 0xd5, 0xa4, 0x46, 0x78, 0x6c, 0x59, 0xc2, 0xa1, 0x8d, 0x4e, 0x90, 0x54, 0x20, + 0xc3, 0x73, 0x4b, 0x2d, 0x59, 0x80, 0xbc, 0x04, 0x43, 0x35, 0xcb, 0xa3, 0x8e, 0xde, 0xf4, 0xcc, + 0x47, 0x54, 0x4c, 0x0d, 0x78, 0x33, 0x6c, 0x86, 0x60, 0x4d, 0xa6, 0x21, 0xb7, 0x61, 0x78, 0x51, + 0x77, 0x3c, 0xb3, 0x69, 0x76, 0x74, 0xcb, 0x73, 0x95, 0x32, 0xce, 0x68, 0x68, 0x61, 0x74, 0x24, + 0xb8, 0x16, 0xa1, 0x22, 0x5f, 0x81, 0x41, 0xdc, 0x9a, 0xa2, 0xbf, 0xf6, 0xe0, 0x8e, 0x17, 0x87, + 0xcf, 0x85, 0xee, 0x81, 0xfc, 0xf4, 0x15, 0x6f, 0x80, 0xe3, 0x77, 0x87, 0x01, 0x47, 0xf2, 0x25, + 0x18, 0x98, 0xb2, 0x0c, 0x64, 0x0e, 0x3b, 0x32, 0x57, 0x05, 0xf3, 0x8b, 0x21, 0x73, 0xbb, 0x13, + 0xe3, 0xed, 0xb3, 0x4b, 0x1f, 0x65, 0x43, 0x1f, 0xdd, 0x28, 0x1b, 0xfe, 0x08, 0x8e, 0xc5, 0x47, + 0x0e, 0xeb, 0x58, 0x7c, 0x74, 0x9f, 0xc7, 0xe2, 0xea, 0x07, 0x30, 0x34, 0xb1, 0x38, 0x1d, 0x8c, + 0xde, 0x27, 0xa0, 0xb0, 0x28, 0x3c, 0x15, 0x8a, 0xdc, 0x9e, 0xe9, 0x98, 0x86, 0xc6, 0x60, 0xe4, + 0x3a, 0x94, 0x27, 0xd1, 0xfd, 0x4d, 0xdc, 0x22, 0x16, 0xf9, 0xfa, 0xd7, 0x44, 0x18, 0x7a, 0xc1, + 0xfa, 0x68, 0xf2, 0x69, 0x18, 0x58, 0x74, 0xec, 0x55, 0x47, 0x6f, 0x8b, 0x35, 0x18, 0x5d, 0x45, + 0x3a, 0x1c, 0xa4, 0xf9, 0x38, 0xf5, 0x67, 0x72, 0xbe, 0xd9, 0xce, 0x4a, 0xd4, 0xbb, 0x78, 0x34, + 0x8f, 0x75, 0x97, 0x79, 0x09, 0x97, 0x83, 0x34, 0x1f, 0x47, 0xae, 0x43, 0xff, 0x94, 0xe3, 0xd8, + 0x8e, 0xec, 0xe3, 0x4e, 0x19, 0x40, 0xbe, 0xee, 0x45, 0x0a, 0xf2, 0x1a, 0x0c, 0xf1, 0x39, 0x87, + 0x9f, 0x68, 0x16, 0x7a, 0xdd, 0x94, 0xca, 0x94, 0xea, 0x77, 0x0a, 0x92, 0xcd, 0xc6, 0x25, 0x7e, + 0x02, 0x6f, 0x05, 0x5e, 0x86, 0xc2, 0xc4, 0xe2, 0xb4, 0x98, 0x00, 0xcf, 0xf9, 0x45, 0x25, 0x55, + 0x89, 0x95, 0x63, 0xd4, 0xe4, 0x0a, 0x14, 0x17, 0x99, 0xfa, 0x94, 0x50, 0x3d, 0xca, 0xdb, 0x5b, + 0xe3, 0xc5, 0x0e, 0xd3, 0x1f, 0x84, 0x22, 0x96, 0x6d, 0x66, 0xf8, 0x8e, 0x89, 0x63, 0xc3, 0x7d, + 0xcc, 0x15, 0x28, 0x56, 0x9c, 0xd5, 0x47, 0x62, 0xd6, 0x42, 0xac, 0xee, 0xac, 0x3e, 0xd2, 0x10, + 0x4a, 0x6e, 0x02, 0x68, 0xd4, 0xeb, 0x3a, 0x16, 0x3e, 0x3f, 0x19, 0xc4, 0xf3, 0x37, 0x9c, 0x0d, + 0x1d, 0x84, 0x36, 0x9a, 0xb6, 0x41, 0x35, 0x89, 0x44, 0xfd, 0xcb, 0xe1, 0xc5, 0x4e, 0xd5, 0x74, + 0xd7, 0x4f, 0xbb, 0x70, 0x0f, 0x5d, 0xa8, 0x8b, 0x23, 0xce, 0x64, 0x27, 0x8d, 0x43, 0xff, 0x74, + 0x4b, 0x5f, 0x75, 0xb1, 0x0f, 0x85, 0x2f, 0xd9, 0x0a, 0x03, 0x68, 0x1c, 0x1e, 0xeb, 0xa7, 0xf2, + 0xce, 0xfd, 0xf4, 0x73, 0xfd, 0xc1, 0x68, 0x9b, 0xa7, 0xde, 0x86, 0xed, 0x9c, 0x76, 0xd5, 0x6e, + 0xbb, 0xea, 0x2a, 0x0c, 0xd4, 0x9d, 0xa6, 0x74, 0x74, 0x81, 0xfb, 0x01, 0xd7, 0x69, 0xf2, 0x63, + 0x0b, 0x1f, 0xc9, 0xe8, 0xaa, 0xae, 0x87, 0x74, 0x03, 0x21, 0x9d, 0xe1, 0x7a, 0x82, 0x4e, 0x20, + 0x05, 0xdd, 0xa2, 0xed, 0x78, 0xa2, 0xe3, 0x02, 0xba, 0x8e, 0xed, 0x78, 0x9a, 0x8f, 0x24, 0x9f, + 0x05, 0x58, 0x9a, 0x5c, 0xf4, 0x9d, 0xed, 0x07, 0x43, 0x5f, 0x40, 0xe1, 0x65, 0xaf, 0x49, 0x68, + 0xb2, 0x04, 0x83, 0x0b, 0x1d, 0xea, 0xf0, 0xad, 0x10, 0x7f, 0x50, 0xf2, 0x99, 0x98, 0x68, 0x45, + 0xbf, 0xdf, 0x10, 0xff, 0x07, 0xe4, 0x7c, 0x7d, 0xb1, 0xfd, 0x9f, 0x5a, 0xc8, 0x88, 0xbc, 0x06, + 0xa5, 0x0a, 0xb7, 0xf3, 0x86, 0x90, 0x65, 0x20, 0x32, 0xdc, 0x82, 0x72, 0x14, 0xdf, 0xb3, 0xeb, + 0xf8, 0xb7, 0x26, 0xc8, 0xd5, 0xeb, 0x30, 0x16, 0xaf, 0x86, 0x0c, 0xc1, 0xc0, 0xe4, 0xc2, 0xfc, + 0xfc, 0xd4, 0xe4, 0xd2, 0x58, 0x1f, 0x29, 0x43, 0xb1, 0x3e, 0x35, 0x5f, 0x1d, 0xcb, 0xa9, 0xbf, + 0x2a, 0xcd, 0x20, 0x4c, 0xb5, 0x4e, 0xaf, 0x86, 0x0f, 0x74, 0xdf, 0x32, 0x86, 0xf7, 0xa1, 0x78, + 0x62, 0xd0, 0x36, 0x3d, 0x8f, 0x1a, 0x62, 0x95, 0xc0, 0xfb, 0x42, 0xef, 0xb1, 0x96, 0xc0, 0x93, + 0x17, 0x60, 0x04, 0x61, 0xe2, 0x8a, 0x90, 0xef, 0x8f, 0x45, 0x01, 0xe7, 0xb1, 0x16, 0x45, 0xaa, + 0xbf, 0x17, 0xde, 0x0e, 0xcf, 0x52, 0xfd, 0xb8, 0xde, 0x28, 0x7e, 0x4c, 0xfa, 0x4b, 0xfd, 0x57, + 0x45, 0xfe, 0x04, 0x84, 0xbf, 0x17, 0x3c, 0x0a, 0x51, 0x86, 0x47, 0xba, 0x85, 0x3d, 0x1c, 0xe9, + 0xbe, 0x00, 0xa5, 0x39, 0xea, 0xad, 0xd9, 0xbe, 0xe3, 0x17, 0x7a, 0xe8, 0xb5, 0x11, 0x22, 0x7b, + 0xe8, 0x71, 0x1a, 0xb2, 0x0e, 0xc4, 0x7f, 0x0c, 0x18, 0x38, 0x62, 0xfb, 0x47, 0xc8, 0x97, 0x12, + 0xfb, 0x94, 0x3a, 0xbe, 0x04, 0x46, 0x1f, 0xfb, 0xf3, 0x81, 0xa3, 0xb7, 0xe4, 0x89, 0xf5, 0x2f, + 0xb7, 0xc6, 0x4b, 0x9c, 0x46, 0x4b, 0x61, 0x4b, 0xde, 0x85, 0xc1, 0xb9, 0xe9, 0x8a, 0x78, 0x18, + 0xc8, 0xbd, 0x22, 0x9e, 0x08, 0xa4, 0xe8, 0x23, 0x02, 0x91, 0xe0, 0x7b, 0x9b, 0xf6, 0x8a, 0x9e, + 0x7c, 0x17, 0x18, 0x72, 0x61, 0xda, 0xc2, 0x5f, 0xee, 0x88, 0xd3, 0x85, 0x40, 0x5b, 0xa2, 0xef, + 0x79, 0xe2, 0xb2, 0xe2, 0xd8, 0x98, 0xb6, 0x94, 0x0f, 0x30, 0xba, 0x17, 0xe0, 0x6c, 0xa5, 0xd3, + 0x69, 0x99, 0xd4, 0x40, 0x7d, 0xd1, 0xba, 0x2d, 0xea, 0x0a, 0x97, 0x1f, 0x7c, 0x0c, 0xa2, 0x73, + 0x64, 0x03, 0x9f, 0xa3, 0x36, 0x9c, 0x6e, 0xd4, 0x3f, 0x33, 0x59, 0x56, 0xfd, 0xd3, 0x79, 0xb8, + 0x38, 0xe9, 0x50, 0xdd, 0xa3, 0x73, 0xd3, 0x95, 0x4a, 0x17, 0x7d, 0xe4, 0x5a, 0x2d, 0x6a, 0xad, + 0x1e, 0xcd, 0xb0, 0x7e, 0x13, 0x46, 0x83, 0x06, 0xd4, 0x9b, 0x76, 0x87, 0xca, 0x0f, 0xab, 0x9a, + 0x3e, 0xa6, 0xe1, 0x32, 0x94, 0x16, 0x23, 0x25, 0xf7, 0xe0, 0x5c, 0x00, 0xa9, 0xb4, 0x5a, 0xf6, + 0x86, 0x46, 0xbb, 0x2e, 0x77, 0x8c, 0x2d, 0x73, 0xc7, 0xd8, 0x90, 0x83, 0xce, 0xf0, 0x0d, 0x87, + 0x11, 0x68, 0x69, 0xa5, 0xd4, 0x5f, 0x2c, 0xc0, 0xa5, 0x07, 0x7a, 0xcb, 0x34, 0x42, 0xd1, 0x68, + 0xd4, 0xed, 0xd8, 0x96, 0x4b, 0x8f, 0xd1, 0x28, 0x8d, 0x0c, 0x85, 0xe2, 0xa1, 0x0c, 0x85, 0x64, + 0x17, 0xf5, 0x1f, 0xb8, 0x8b, 0x4a, 0xfb, 0xea, 0xa2, 0xff, 0x35, 0x07, 0x63, 0xbe, 0xe3, 0xbf, + 0xfc, 0x88, 0x5b, 0xf2, 0x4a, 0xc7, 0x23, 0xc4, 0x98, 0x1f, 0x34, 0xe2, 0x49, 0x1d, 0x06, 0xa6, + 0x1e, 0x77, 0x4c, 0x87, 0xba, 0xbb, 0x70, 0xe2, 0x7e, 0x4a, 0x1c, 0x97, 0x9c, 0xa5, 0xbc, 0x48, + 0xe2, 0xa4, 0x84, 0x83, 0xf1, 0x39, 0x1f, 0x7f, 0xfa, 0x30, 0xe1, 0xbf, 0x4c, 0xe7, 0xcf, 0xf9, + 0xc4, 0x13, 0x89, 0xc8, 0xfb, 0xcc, 0x90, 0x94, 0x3c, 0x07, 0x85, 0xa5, 0xa5, 0x59, 0x31, 0x93, + 0x62, 0x44, 0x00, 0xcf, 0x93, 0xdf, 0x2b, 0x32, 0xac, 0xfa, 0x4f, 0xf3, 0x00, 0x4c, 0x15, 0xf8, + 0x70, 0x3d, 0x12, 0x25, 0x9c, 0x80, 0xb2, 0x2f, 0x70, 0xa1, 0x86, 0x81, 0xd7, 0x7e, 0xbc, 0x23, + 0xe2, 0x75, 0x07, 0x2f, 0x34, 0xc6, 0x7d, 0x47, 0x72, 0x7e, 0x0f, 0x80, 0x3b, 0x1b, 0x74, 0x24, + 0xf7, 0xdd, 0xc7, 0x3f, 0x0b, 0x83, 0x62, 0xc6, 0xb3, 0x23, 0xe7, 0xff, 0x4d, 0x1f, 0xa8, 0x85, + 0xf8, 0xd8, 0xd4, 0x5a, 0x3a, 0xc0, 0x42, 0xec, 0x8b, 0x97, 0xf7, 0xca, 0xa9, 0x78, 0x0f, 0x59, + 0xbc, 0xdf, 0x10, 0xe2, 0xe5, 0x2f, 0x78, 0x8e, 0xad, 0x78, 0x0f, 0xed, 0xec, 0x5b, 0xfd, 0x47, + 0x39, 0x20, 0xac, 0x59, 0x8b, 0xba, 0xeb, 0x6e, 0xd8, 0x8e, 0xc1, 0x9d, 0xd3, 0x8f, 0x44, 0x30, + 0x87, 0x77, 0x5f, 0xf9, 0x9d, 0x32, 0x9c, 0x8b, 0x38, 0xfe, 0x1e, 0xf3, 0xc9, 0xea, 0x7a, 0x74, + 0x34, 0xf5, 0x7a, 0xf5, 0xf2, 0x29, 0xf9, 0x42, 0xb4, 0x3f, 0xf2, 0x00, 0x4d, 0xba, 0x09, 0x7d, + 0x11, 0x86, 0xc5, 0x0f, 0xb6, 0x42, 0xfb, 0x37, 0x5d, 0x38, 0x4a, 0x5d, 0x06, 0xd0, 0x22, 0x68, + 0xf2, 0x0a, 0x0c, 0xb2, 0x01, 0xb3, 0x8a, 0xc1, 0x43, 0x06, 0xc2, 0x17, 0x25, 0x86, 0x0f, 0x94, + 0xd7, 0x93, 0x80, 0x52, 0x7a, 0x47, 0x54, 0xde, 0xc5, 0x3b, 0xa2, 0xaf, 0xc2, 0x50, 0xc5, 0xb2, + 0x6c, 0x0f, 0x37, 0xe9, 0xae, 0xb8, 0x9a, 0xc8, 0xb4, 0xca, 0x9f, 0xc3, 0xc7, 0xf1, 0x21, 0x7d, + 0xaa, 0x59, 0x2e, 0x33, 0x24, 0xb7, 0xfc, 0x57, 0x31, 0xd4, 0x11, 0x5e, 0xe5, 0x78, 0x3d, 0xe3, + 0x08, 0x58, 0xf2, 0x51, 0x0c, 0x76, 0xde, 0xc8, 0xa2, 0x63, 0x77, 0x6c, 0x97, 0x1a, 0x5c, 0x50, + 0x43, 0x61, 0xa8, 0x81, 0x8e, 0x40, 0xe0, 0x3b, 0xb6, 0x48, 0x20, 0x8f, 0x48, 0x11, 0xb2, 0x02, + 0xe7, 0xfd, 0x8b, 0xe2, 0xe0, 0xc5, 0x60, 0xad, 0xea, 0x2a, 0xc3, 0xf8, 0x2a, 0x89, 0xc4, 0x95, + 0xa1, 0x56, 0x9d, 0x78, 0xda, 0xbf, 0x16, 0xf1, 0x9f, 0x1c, 0x36, 0x4c, 0x43, 0xee, 0xea, 0x54, + 0x7e, 0xe4, 0x47, 0x60, 0x68, 0x4e, 0x7f, 0x5c, 0xed, 0x8a, 0xb3, 0x97, 0x91, 0xdd, 0xdf, 0xbe, + 0xb4, 0xf5, 0xc7, 0x0d, 0x43, 0x94, 0x8b, 0xd9, 0x14, 0x32, 0x4b, 0xd2, 0x80, 0x8b, 0x8b, 0x8e, + 0xdd, 0xb6, 0x3d, 0x6a, 0xc4, 0x1e, 0xdf, 0x9d, 0x09, 0x5f, 0xeb, 0x76, 0x04, 0x45, 0xa3, 0xc7, + 0x2b, 0xbc, 0x0c, 0x36, 0xa4, 0x0d, 0x67, 0x2a, 0xae, 0xdb, 0x6d, 0xd3, 0xf0, 0x86, 0x6a, 0x6c, + 0xc7, 0xcf, 0xf8, 0x8c, 0xf0, 0x5a, 0x7e, 0x52, 0xc7, 0xa2, 0xfc, 0x82, 0xaa, 0xe1, 0x99, 0x72, + 0x8d, 0xf8, 0x2d, 0x71, 0xde, 0x77, 0x8b, 0xe5, 0xd1, 0xb1, 0x33, 0xda, 0xa5, 0x64, 0x63, 0x96, + 0x4c, 0xaf, 0x45, 0xd5, 0x6f, 0xe7, 0x00, 0x42, 0x01, 0x93, 0x17, 0xa3, 0x11, 0x8a, 0x72, 0xe1, + 0x45, 0x87, 0x88, 0x5e, 0x10, 0x09, 0x49, 0x44, 0xae, 0x40, 0x11, 0x23, 0x5c, 0xe4, 0xc3, 0x83, + 0xd5, 0x75, 0xd3, 0x32, 0x34, 0x84, 0x32, 0xac, 0xf4, 0x14, 0x1d, 0xb1, 0x78, 0xa9, 0xcf, 0xad, + 0xc2, 0x2a, 0x9c, 0xa9, 0x77, 0x97, 0xfd, 0xba, 0xa5, 0x77, 0x75, 0x18, 0x68, 0xc3, 0xed, 0x2e, + 0x07, 0x8f, 0x51, 0x23, 0x61, 0x4c, 0xa2, 0x45, 0xd4, 0x5f, 0xcf, 0xc5, 0x66, 0xc1, 0x23, 0x5c, + 0xf4, 0x3e, 0x95, 0xf4, 0xd3, 0x48, 0x4e, 0x4b, 0xea, 0x9f, 0xcf, 0xc3, 0xd0, 0xa2, 0xed, 0x78, + 0x22, 0x64, 0xc8, 0xf1, 0x5e, 0x85, 0xa4, 0xbd, 0x52, 0x71, 0x0f, 0x7b, 0xa5, 0x2b, 0x50, 0x94, + 0x5c, 0x94, 0xf9, 0xbd, 0x88, 0x61, 0x38, 0x1a, 0x42, 0xd5, 0x1f, 0xcb, 0x03, 0x7c, 0xe9, 0xa5, + 0x97, 0x4e, 0xb0, 0x80, 0xd4, 0x5f, 0xc8, 0xc1, 0x19, 0x71, 0x51, 0x27, 0xc5, 0xfa, 0x1a, 0xf0, + 0xaf, 0x58, 0xe5, 0x71, 0xc9, 0x41, 0x9a, 0x8f, 0x63, 0x4b, 0xc0, 0xd4, 0x63, 0xd3, 0xc3, 0xbb, + 0x0a, 0x29, 0xd8, 0x17, 0x15, 0x30, 0x79, 0x09, 0xf0, 0xe9, 0xc8, 0x8b, 0xfe, 0x15, 0x64, 0x21, + 0x5c, 0xf7, 0x58, 0x81, 0xa9, 0xd4, 0x6b, 0x48, 0xf5, 0xb7, 0x8a, 0x50, 0x9c, 0x7a, 0x4c, 0x9b, + 0xc7, 0xbc, 0x6b, 0xa4, 0x83, 0xcd, 0xe2, 0x01, 0x0f, 0x36, 0xf7, 0xe3, 0x53, 0xf1, 0x4e, 0xd8, + 0x9f, 0xa5, 0x68, 0xf5, 0xb1, 0x9e, 0x8f, 0x57, 0xef, 0xf7, 0xf4, 0xf1, 0x73, 0xc9, 0xf9, 0x2f, + 0x0a, 0x50, 0xa8, 0x4f, 0x2e, 0x9e, 0xea, 0xcd, 0x91, 0xea, 0x4d, 0xef, 0x3b, 0x6b, 0x35, 0xb8, + 0x86, 0x2a, 0x87, 0x5e, 0xa2, 0xb1, 0x1b, 0xa7, 0xef, 0x17, 0x60, 0xb4, 0x3e, 0xbd, 0xb4, 0x28, + 0x9d, 0x04, 0xdf, 0xe3, 0x9e, 0x7c, 0xe8, 0x53, 0xc6, 0xbb, 0xf4, 0x4a, 0xc2, 0x9e, 0xb9, 0x5f, + 0xb3, 0xbc, 0x57, 0x6f, 0x3f, 0xd0, 0x5b, 0x5d, 0x8a, 0x47, 0x2f, 0xdc, 0xef, 0xd7, 0x35, 0x3f, + 0xa0, 0xbf, 0x88, 0x0f, 0xff, 0x7d, 0x06, 0xe4, 0x4d, 0x28, 0xdc, 0x17, 0x1e, 0x19, 0x59, 0x7c, + 0x5e, 0xbe, 0xc5, 0xf9, 0xb0, 0x49, 0xb0, 0xd0, 0x35, 0x0d, 0xe4, 0xc0, 0x4a, 0xb1, 0xc2, 0x77, + 0xc4, 0x02, 0xbc, 0xab, 0xc2, 0xab, 0x7e, 0xe1, 0x3b, 0xb5, 0x2a, 0xa9, 0xc3, 0xd0, 0x22, 0x75, + 0xda, 0x26, 0x76, 0x94, 0x3f, 0x67, 0xf7, 0x66, 0xc2, 0x76, 0x2a, 0x43, 0x9d, 0xb0, 0x10, 0x32, + 0x93, 0xb9, 0x90, 0xf7, 0x00, 0xb8, 0x8d, 0xb2, 0xcb, 0xf8, 0x91, 0x4f, 0xa1, 0xdd, 0xcf, 0x4d, + 0xcb, 0x14, 0x1b, 0x4f, 0x62, 0x46, 0xd6, 0x61, 0x6c, 0xce, 0x36, 0xcc, 0x15, 0x93, 0xbb, 0x5e, + 0x62, 0x05, 0xa5, 0x9d, 0x1d, 0x9e, 0x98, 0x29, 0xd9, 0x96, 0xca, 0xa5, 0x55, 0x93, 0x60, 0xac, + 0xfe, 0xa7, 0xfd, 0x50, 0x64, 0xdd, 0x7e, 0x3a, 0x7e, 0x0f, 0x32, 0x7e, 0x2b, 0x30, 0xf6, 0xd0, + 0x76, 0xd6, 0x4d, 0x6b, 0x35, 0xf0, 0x8a, 0x17, 0x7b, 0x53, 0xf4, 0xe4, 0xd9, 0xe0, 0xb8, 0x46, + 0xe0, 0x40, 0xaf, 0x25, 0xc8, 0x77, 0x18, 0xc1, 0xaf, 0x03, 0xf0, 0xb7, 0xee, 0x48, 0x53, 0x0e, 0x83, 0x55, 0xf0, 0x97, 0xf0, 0xe8, 0x68, 0x2f, 0x07, 0xab, 0x08, 0x89, 0xd9, 0x26, 0x9c, 0xfb, - 0x42, 0x0c, 0xa0, 0xdf, 0x3d, 0x6e, 0xc2, 0xd1, 0x17, 0x42, 0x36, 0x02, 0xb8, 0x57, 0xc4, 0x12, + 0x42, 0x0c, 0xa2, 0xdf, 0x3d, 0x6e, 0xc2, 0xd1, 0x17, 0x42, 0x36, 0x02, 0xb8, 0x57, 0xc4, 0x22, 0x80, 0x74, 0xbf, 0x04, 0x31, 0x41, 0x44, 0x26, 0x07, 0x11, 0x1e, 0x2e, 0xe5, 0x7a, 0x49, 0x93, - 0x78, 0x90, 0xd7, 0x62, 0x17, 0xe0, 0x24, 0xc2, 0x2d, 0xf3, 0xfe, 0x3b, 0x74, 0xa0, 0x1a, 0xda, - 0xcd, 0x81, 0x4a, 0xfd, 0x7a, 0x1e, 0x06, 0x6a, 0x9d, 0x55, 0x77, 0xcb, 0xf5, 0x68, 0xeb, 0x84, - 0xab, 0xb1, 0xbf, 0xbd, 0x2a, 0xa6, 0x6e, 0xaf, 0x9e, 0xf7, 0x85, 0x22, 0x9d, 0x3b, 0x06, 0x26, - 0x9d, 0x2f, 0x8e, 0xbf, 0x91, 0x87, 0x31, 0x7e, 0x71, 0x56, 0x31, 0xdd, 0xc6, 0x11, 0x38, 0xf3, - 0x1f, 0xbf, 0x54, 0x0e, 0x77, 0xd9, 0xbc, 0x87, 0x27, 0x12, 0xea, 0xd7, 0xf2, 0x30, 0x58, 0xee, - 0x78, 0x1b, 0x65, 0x0f, 0x75, 0xeb, 0x54, 0xee, 0x4f, 0xfe, 0x5e, 0x0e, 0x46, 0x59, 0x43, 0x96, - 0xed, 0x47, 0xd4, 0x3a, 0x82, 0x83, 0x47, 0xf9, 0x00, 0x31, 0x7f, 0xc0, 0x03, 0x44, 0x5f, 0x96, - 0x85, 0xfd, 0xc9, 0x12, 0x8f, 0xcb, 0x35, 0xbb, 0x49, 0x4f, 0xf6, 0x67, 0x1c, 0xe1, 0x71, 0xb9, - 0x2f, 0x90, 0x23, 0xb8, 0x9e, 0xf9, 0x64, 0x09, 0xe4, 0x08, 0xce, 0x96, 0x3e, 0x19, 0x02, 0xf9, - 0x4e, 0x0e, 0x06, 0x26, 0x6d, 0xef, 0x84, 0x0f, 0x7c, 0xf1, 0x15, 0x27, 0x5b, 0xcd, 0xfd, 0xaf, - 0x38, 0xd9, 0xba, 0xa9, 0xfe, 0x5c, 0x1e, 0xce, 0x8b, 0xd8, 0xe0, 0xe2, 0xfc, 0xe1, 0x6c, 0x3a, - 0x16, 0x83, 0x2d, 0x29, 0x9a, 0xb3, 0x79, 0x48, 0x88, 0xe6, 0x97, 0x0a, 0x70, 0x1e, 0x43, 0x99, - 0xb2, 0x6d, 0xd9, 0x27, 0xc0, 0x16, 0x21, 0x8d, 0xe8, 0x25, 0xe8, 0x7c, 0xca, 0x25, 0xe8, 0xbf, - 0xdc, 0x9e, 0x78, 0x6d, 0xdd, 0xf4, 0x36, 0x3a, 0xab, 0x37, 0x1b, 0x76, 0xeb, 0xd6, 0xba, 0xa3, - 0x3f, 0x36, 0xf9, 0xf5, 0x9f, 0xde, 0xbc, 0x15, 0xa4, 0xd9, 0xd0, 0xdb, 0xa6, 0x48, 0xc0, 0x51, - 0xc3, 0xbd, 0x0e, 0xe3, 0xea, 0x5f, 0x9f, 0xba, 0x00, 0xf7, 0x6c, 0xd3, 0x12, 0x3e, 0x85, 0xdc, - 0xd0, 0xad, 0xb1, 0xfd, 0xe1, 0x07, 0xb6, 0x69, 0xd5, 0xe3, 0x8e, 0x85, 0xfb, 0xad, 0x2f, 0x64, - 0xad, 0x49, 0xd5, 0xa8, 0xff, 0x4d, 0x0e, 0x9e, 0x8a, 0x6a, 0xf1, 0x27, 0xc1, 0x76, 0xfc, 0xb3, - 0x79, 0xb8, 0x70, 0x17, 0x85, 0x13, 0x38, 0x72, 0x9c, 0xcd, 0x5b, 0x62, 0x70, 0xa6, 0xc8, 0xe6, - 0xcc, 0xa2, 0xcc, 0x96, 0xcd, 0xd9, 0xa4, 0x2e, 0x64, 0xf3, 0x5f, 0xe7, 0xe0, 0xdc, 0x62, 0xb5, - 0x32, 0xf5, 0x09, 0x19, 0x51, 0xc9, 0xef, 0x39, 0xe1, 0x06, 0x67, 0xe2, 0x7b, 0x4e, 0xb8, 0xe9, - 0xf9, 0xed, 0x3c, 0x9c, 0xab, 0x95, 0xe7, 0xe7, 0x3e, 0x29, 0x33, 0xf8, 0x94, 0xec, 0x75, 0xe8, - 0x1f, 0x82, 0x09, 0x5b, 0x40, 0xfe, 0xcc, 0x07, 0xb7, 0xb3, 0xbd, 0x11, 0x93, 0x42, 0x39, 0xe1, - 0x53, 0xf7, 0x91, 0x08, 0x85, 0x69, 0x7e, 0x84, 0xfa, 0x84, 0x6b, 0xfe, 0x7f, 0x5e, 0x82, 0xc1, - 0xfb, 0x9d, 0x55, 0x2a, 0x9c, 0x53, 0x4e, 0xf5, 0xc9, 0xef, 0x6d, 0x18, 0x14, 0x62, 0xc0, 0x5b, - 0x13, 0x29, 0x78, 0x9e, 0x08, 0x86, 0xc2, 0xe3, 0x13, 0xc9, 0x44, 0xe4, 0x0a, 0x14, 0x1f, 0x50, - 0x67, 0x55, 0x7e, 0x57, 0xfa, 0x98, 0x3a, 0xab, 0x1a, 0x42, 0xc9, 0x5c, 0xe8, 0x32, 0x5f, 0x5e, - 0xaa, 0x62, 0x22, 0x15, 0x71, 0x61, 0x83, 0x99, 0x61, 0x02, 0xbf, 0x37, 0xbd, 0x6d, 0xf2, 0x14, - 0x2c, 0xf2, 0x9b, 0xf6, 0x78, 0x49, 0xb2, 0x00, 0xe3, 0xb2, 0xe3, 0x13, 0xcf, 0x22, 0xd2, 0x9f, - 0xc2, 0x2e, 0x2d, 0x7f, 0x48, 0xb2, 0x28, 0x79, 0x17, 0x86, 0x7c, 0x20, 0xba, 0x70, 0x0d, 0x84, - 0xa1, 0xeb, 0x03, 0x56, 0xb1, 0x14, 0x45, 0x91, 0x02, 0x32, 0x03, 0xbc, 0x86, 0x80, 0x14, 0x06, - 0x31, 0x97, 0xb8, 0x48, 0x01, 0xf2, 0x2a, 0x32, 0xc0, 0x67, 0x1e, 0xe8, 0xac, 0x32, 0x88, 0x8f, - 0x2e, 0xd1, 0x25, 0xdf, 0x11, 0x70, 0xfe, 0xb4, 0x36, 0x42, 0x46, 0x16, 0x01, 0x42, 0xa7, 0x02, - 0x11, 0xc0, 0x60, 0xdf, 0xee, 0x0e, 0x12, 0x0b, 0xf9, 0x3a, 0x70, 0xf8, 0x20, 0xd7, 0x81, 0xea, - 0x3f, 0xcc, 0xc3, 0x60, 0xb9, 0xdd, 0x0e, 0x86, 0xc2, 0x4b, 0x50, 0x2a, 0xb7, 0xdb, 0x2b, 0x5a, - 0x55, 0x0e, 0x65, 0xae, 0xb7, 0xdb, 0xf5, 0x8e, 0x63, 0xca, 0x3e, 0xa1, 0x9c, 0x88, 0x4c, 0xc1, - 0x70, 0xb9, 0xdd, 0x5e, 0xea, 0xac, 0x36, 0xcd, 0x86, 0x94, 0x19, 0x89, 0xe7, 0x8e, 0x6b, 0xb7, - 0xeb, 0x6d, 0xc4, 0xc4, 0xd3, 0x63, 0x45, 0xcb, 0x90, 0xaf, 0x62, 0xd8, 0x1f, 0x91, 0x98, 0x87, - 0xa7, 0xfe, 0x50, 0x83, 0x20, 0xe6, 0x61, 0xdb, 0x6e, 0x06, 0x44, 0x3c, 0xd8, 0xfb, 0x15, 0x3f, - 0x64, 0x3e, 0xab, 0x28, 0x91, 0x80, 0x27, 0x64, 0x49, 0x3e, 0x07, 0x7d, 0xe5, 0x76, 0x5b, 0xba, - 0x6f, 0x42, 0xa7, 0x22, 0x56, 0x2a, 0x9e, 0xfb, 0x4c, 0x90, 0x5d, 0x7e, 0x1b, 0x46, 0xa2, 0x95, - 0xed, 0x2b, 0x58, 0xfc, 0xf7, 0x73, 0xf8, 0x41, 0x27, 0xdc, 0xa7, 0xf9, 0x15, 0x28, 0x94, 0xdb, - 0x6d, 0x31, 0x1f, 0x9d, 0x4b, 0xe9, 0x8f, 0xf8, 0x13, 0xe8, 0x72, 0xbb, 0xed, 0x7f, 0xfa, 0x09, - 0x7f, 0x1c, 0x71, 0xa0, 0x4f, 0xff, 0x0e, 0xff, 0xf4, 0x93, 0xfd, 0x70, 0x41, 0xfd, 0xcd, 0x02, - 0x8c, 0x96, 0xdb, 0xed, 0xb3, 0x20, 0xf3, 0x47, 0xf5, 0xd0, 0xfa, 0x65, 0x00, 0x69, 0x7a, 0xec, - 0x0b, 0x9e, 0x6e, 0x0d, 0x4a, 0x53, 0xa3, 0x92, 0xd3, 0x24, 0x22, 0x5f, 0xfd, 0xfa, 0xf7, 0xa5, - 0x7e, 0x5f, 0x2b, 0xe0, 0x54, 0x7c, 0xd2, 0x83, 0x46, 0x7d, 0x5c, 0xba, 0x4d, 0xf4, 0x41, 0x69, - 0x5f, 0x7d, 0xf0, 0x77, 0x23, 0x83, 0x07, 0x83, 0x96, 0x9f, 0xf5, 0x42, 0xef, 0xa1, 0xcc, 0xe2, - 0x11, 0x59, 0x98, 0x22, 0x92, 0x8d, 0x9f, 0x48, 0x49, 0xc4, 0x55, 0x6a, 0x30, 0x54, 0xdd, 0x34, - 0xb4, 0x18, 0xad, 0xdf, 0x87, 0x7d, 0xfb, 0xea, 0xc3, 0xed, 0x3c, 0xbe, 0x9d, 0x0e, 0xe2, 0x32, - 0x1d, 0x7e, 0x77, 0x71, 0x0b, 0x80, 0x7b, 0x1e, 0x04, 0x6e, 0xcd, 0xc3, 0x3c, 0x04, 0x0b, 0xcf, - 0xaf, 0x24, 0x42, 0xb0, 0x84, 0x24, 0x81, 0x87, 0x54, 0x21, 0xd5, 0x43, 0xea, 0x06, 0xf4, 0x6b, - 0xfa, 0xe6, 0x7b, 0x1d, 0xea, 0x6c, 0x09, 0x73, 0x86, 0x87, 0x3d, 0xd4, 0x37, 0xeb, 0x3f, 0xcc, - 0x80, 0x5a, 0x80, 0x26, 0x6a, 0xf0, 0xf8, 0x5e, 0xf2, 0x08, 0xe1, 0x67, 0xe4, 0xc1, 0x93, 0xfb, - 0x83, 0x28, 0x3a, 0x79, 0x13, 0x0a, 0xe5, 0x87, 0x35, 0x21, 0xd9, 0xa0, 0x6b, 0xcb, 0x0f, 0x6b, - 0x42, 0x5e, 0x99, 0x65, 0x1f, 0xd6, 0xd4, 0xaf, 0xe5, 0x81, 0x24, 0x29, 0xc9, 0x6b, 0x30, 0x80, - 0xd0, 0x75, 0xa6, 0x33, 0x72, 0x62, 0xce, 0x4d, 0xb7, 0xee, 0x20, 0x34, 0x62, 0xdc, 0xf9, 0xa4, - 0xe4, 0x0d, 0x4c, 0x7d, 0x2c, 0x52, 0xc3, 0x45, 0x12, 0x73, 0x6e, 0xba, 0x7e, 0xb2, 0xe0, 0x58, - 0xe6, 0x63, 0x41, 0x8c, 0x76, 0xe1, 0xc3, 0xda, 0xac, 0xed, 0x7a, 0x42, 0xd4, 0xdc, 0x2e, 0xdc, - 0x74, 0x31, 0x23, 0x6c, 0xc4, 0x2e, 0xe4, 0x64, 0x98, 0xd5, 0xea, 0x61, 0x8d, 0x3f, 0x53, 0x31, - 0x34, 0xbb, 0xe9, 0x1b, 0x94, 0x3c, 0xab, 0xd5, 0xa6, 0x5b, 0xe7, 0x4f, 0x5c, 0x0c, 0xcc, 0xb9, - 0x1c, 0xc9, 0x6a, 0x15, 0x29, 0xa5, 0x7e, 0xa3, 0x1f, 0xc6, 0x2a, 0xba, 0xa7, 0xaf, 0xea, 0x2e, - 0x95, 0x76, 0xd3, 0xa3, 0x3e, 0xcc, 0xff, 0x1c, 0x49, 0x0e, 0xc6, 0x6a, 0xca, 0xd7, 0xc4, 0x0b, - 0x90, 0xb7, 0x42, 0xbe, 0x41, 0xce, 0x51, 0x39, 0x89, 0xd9, 0x6a, 0xbd, 0x2d, 0xc0, 0x5a, 0x82, - 0x90, 0xbc, 0x08, 0x83, 0x3e, 0x8c, 0x6d, 0x00, 0x0a, 0xa1, 0xce, 0x18, 0xab, 0xcc, 0xfe, 0xd7, - 0x64, 0x34, 0x79, 0x03, 0x86, 0xfc, 0x9f, 0x92, 0x69, 0xcd, 0x33, 0xb2, 0xad, 0x26, 0x76, 0x4f, - 0x32, 0xa9, 0x5c, 0x14, 0xe7, 0xb7, 0xde, 0x48, 0xd1, 0x58, 0xd2, 0xb3, 0x08, 0x29, 0xf9, 0x61, - 0x18, 0xf1, 0x7f, 0x8b, 0x0d, 0x03, 0xcf, 0x0f, 0xf7, 0x62, 0x90, 0xd2, 0x39, 0x26, 0xd6, 0x9b, - 0x51, 0x72, 0xbe, 0x75, 0x78, 0xda, 0xcf, 0xe3, 0x65, 0xac, 0x26, 0x77, 0x0e, 0xb1, 0x0a, 0x48, - 0x15, 0xc6, 0x7d, 0x48, 0xa8, 0xa1, 0x7d, 0xe1, 0x8e, 0xd1, 0x58, 0xad, 0xa7, 0x2a, 0x69, 0xb2, - 0x14, 0x69, 0xc2, 0x95, 0x08, 0xd0, 0x70, 0x37, 0xcc, 0x35, 0x4f, 0x6c, 0xf7, 0x44, 0x0c, 0x62, - 0x91, 0xb8, 0x31, 0xe0, 0xca, 0x69, 0xfc, 0x0c, 0xac, 0xd1, 0xec, 0x50, 0x5d, 0xb9, 0x91, 0x1a, - 0x9c, 0xf7, 0xf1, 0x77, 0xa7, 0x96, 0x96, 0x1c, 0xfb, 0x03, 0xda, 0xf0, 0xaa, 0x15, 0xb1, 0x5d, - 0xc6, 0xd8, 0x74, 0xc6, 0x6a, 0x7d, 0xbd, 0xd1, 0x66, 0x4a, 0xc1, 0x70, 0x51, 0xe6, 0xa9, 0x85, + 0x78, 0x90, 0x57, 0x63, 0x17, 0xe0, 0x24, 0xc2, 0x2d, 0xf3, 0xfe, 0x3b, 0x74, 0xa0, 0x1a, 0xde, + 0xc9, 0x81, 0x4a, 0xfd, 0x30, 0x0f, 0x83, 0xf5, 0xee, 0xb2, 0xbb, 0xe9, 0x7a, 0xb4, 0x7d, 0xcc, + 0xd5, 0xd8, 0xdf, 0x5e, 0x15, 0x53, 0xb7, 0x57, 0xcf, 0xf9, 0x42, 0x91, 0xce, 0x1d, 0x03, 0x93, + 0xce, 0x17, 0xc7, 0x5f, 0xcf, 0xc3, 0x18, 0xbf, 0x38, 0xab, 0x9a, 0x6e, 0xf3, 0x10, 0x9c, 0xf9, + 0x8f, 0x5e, 0x2a, 0x07, 0xbb, 0x6c, 0xde, 0xc5, 0x13, 0x09, 0xf5, 0x6b, 0x79, 0x18, 0xaa, 0x74, + 0xbd, 0xb5, 0x8a, 0x87, 0xba, 0x75, 0x22, 0xf7, 0x27, 0x7f, 0x2f, 0x07, 0x67, 0x58, 0x43, 0x96, + 0xec, 0x75, 0x6a, 0x1d, 0xc2, 0xc1, 0xa3, 0x7c, 0x80, 0x98, 0xdf, 0xe7, 0x01, 0xa2, 0x2f, 0xcb, + 0xc2, 0xde, 0x64, 0x89, 0xc7, 0xe5, 0x9a, 0xdd, 0xa2, 0xc7, 0xfb, 0x33, 0x0e, 0xf1, 0xb8, 0xdc, + 0x17, 0xc8, 0x21, 0x5c, 0xcf, 0x7c, 0xb2, 0x04, 0x72, 0x08, 0x67, 0x4b, 0x9f, 0x0c, 0x81, 0x7c, + 0x27, 0x07, 0x83, 0x13, 0xb6, 0x77, 0xcc, 0x07, 0xbe, 0xf8, 0x8a, 0xe3, 0xad, 0xe6, 0xfe, 0x57, + 0x1c, 0x6f, 0xdd, 0x54, 0x7f, 0x3e, 0x0f, 0xe7, 0x45, 0x6c, 0x70, 0x71, 0xfe, 0x70, 0x3a, 0x1d, + 0x8b, 0xc1, 0x96, 0x14, 0xcd, 0xe9, 0x3c, 0x24, 0x44, 0xf3, 0xcb, 0x05, 0x38, 0x8f, 0xa1, 0x4c, + 0xd9, 0xb6, 0xec, 0x13, 0x60, 0x8b, 0x90, 0x66, 0xf4, 0x12, 0x74, 0x2e, 0xe5, 0x12, 0xf4, 0x5f, + 0x6e, 0x8d, 0xbf, 0xba, 0x6a, 0x7a, 0x6b, 0xdd, 0xe5, 0x1b, 0x4d, 0xbb, 0x7d, 0x73, 0xd5, 0xd1, + 0x1f, 0x99, 0xfc, 0xfa, 0x4f, 0x6f, 0xdd, 0x0c, 0xd2, 0x6c, 0xe8, 0x1d, 0x53, 0x24, 0xe0, 0xa8, + 0xe3, 0x5e, 0x87, 0x71, 0xf5, 0xaf, 0x4f, 0x5d, 0x80, 0xbb, 0xb6, 0x69, 0x09, 0x9f, 0x42, 0x6e, + 0xe8, 0xd6, 0xd9, 0xfe, 0xf0, 0x7d, 0xdb, 0xb4, 0x1a, 0x71, 0xc7, 0xc2, 0xbd, 0xd6, 0x17, 0xb2, + 0xd6, 0xa4, 0x6a, 0xd4, 0xff, 0x26, 0x07, 0x4f, 0x44, 0xb5, 0xf8, 0x93, 0x60, 0x3b, 0xfe, 0x99, + 0x3c, 0x5c, 0xb8, 0x83, 0xc2, 0x09, 0x1c, 0x39, 0x4e, 0xe7, 0x2d, 0x31, 0x38, 0x53, 0x64, 0x73, + 0x6a, 0x51, 0x66, 0xcb, 0xe6, 0x74, 0x52, 0x17, 0xb2, 0xf9, 0xaf, 0x73, 0x70, 0x6e, 0xa1, 0x56, + 0x9d, 0xfc, 0x84, 0x8c, 0xa8, 0xe4, 0xf7, 0x1c, 0x73, 0x83, 0x33, 0xf1, 0x3d, 0xc7, 0xdc, 0xf4, + 0xfc, 0x56, 0x1e, 0xce, 0xd5, 0x2b, 0x73, 0xb3, 0x9f, 0x94, 0x19, 0x7c, 0x52, 0xf6, 0x3a, 0xf4, + 0x0f, 0xc1, 0x84, 0x2d, 0x20, 0x7f, 0xe6, 0x83, 0x5b, 0xd9, 0xde, 0x88, 0x49, 0xa1, 0x1c, 0xf3, + 0xa9, 0xfb, 0x50, 0x84, 0xc2, 0x34, 0x3f, 0x42, 0x7d, 0xcc, 0x35, 0xff, 0x3f, 0x2f, 0xc1, 0xd0, + 0xbd, 0xee, 0x32, 0x15, 0xce, 0x29, 0x27, 0xfa, 0xe4, 0xf7, 0x16, 0x0c, 0x09, 0x31, 0xe0, 0xad, + 0x89, 0x14, 0x3c, 0x4f, 0x04, 0x43, 0xe1, 0xf1, 0x89, 0x64, 0x22, 0x72, 0x05, 0x8a, 0x0f, 0xa8, + 0xb3, 0x2c, 0xbf, 0x2b, 0x7d, 0x44, 0x9d, 0x65, 0x0d, 0xa1, 0x64, 0x36, 0x74, 0x99, 0xaf, 0x2c, + 0xd6, 0x30, 0x91, 0x8a, 0xb8, 0xb0, 0xc1, 0xcc, 0x30, 0x81, 0xdf, 0x9b, 0xde, 0x31, 0x79, 0x0a, + 0x16, 0xf9, 0x4d, 0x7b, 0xbc, 0x24, 0x99, 0x87, 0xb3, 0xb2, 0xe3, 0x13, 0xcf, 0x22, 0x52, 0x4e, + 0x61, 0x97, 0x96, 0x3f, 0x24, 0x59, 0x94, 0xbc, 0x03, 0xc3, 0x3e, 0x10, 0x5d, 0xb8, 0x06, 0xc3, + 0xd0, 0xf5, 0x01, 0xab, 0x58, 0x8a, 0xa2, 0x48, 0x01, 0x99, 0x01, 0x5e, 0x43, 0x40, 0x0a, 0x83, + 0x98, 0x4b, 0x5c, 0xa4, 0x00, 0x79, 0x05, 0x19, 0xe0, 0x33, 0x0f, 0x74, 0x56, 0x19, 0xc2, 0x47, + 0x97, 0xe8, 0x92, 0xef, 0x08, 0x38, 0x7f, 0x5a, 0x1b, 0x21, 0x23, 0x0b, 0x00, 0xa1, 0x53, 0x81, + 0x08, 0x60, 0xb0, 0x67, 0x77, 0x07, 0x89, 0x85, 0x7c, 0x1d, 0x38, 0xb2, 0x9f, 0xeb, 0x40, 0xf5, + 0x1f, 0xe6, 0x61, 0xa8, 0xd2, 0xe9, 0x04, 0x43, 0xe1, 0x45, 0x28, 0x55, 0x3a, 0x9d, 0xfb, 0x5a, + 0x4d, 0x0e, 0x65, 0xae, 0x77, 0x3a, 0x8d, 0xae, 0x63, 0xca, 0x3e, 0xa1, 0x9c, 0x88, 0x4c, 0xc2, + 0x48, 0xa5, 0xd3, 0x59, 0xec, 0x2e, 0xb7, 0xcc, 0xa6, 0x94, 0x19, 0x89, 0xe7, 0x8e, 0xeb, 0x74, + 0x1a, 0x1d, 0xc4, 0xc4, 0xd3, 0x63, 0x45, 0xcb, 0x90, 0xaf, 0x62, 0xd8, 0x1f, 0x91, 0x98, 0x87, + 0xa7, 0xfe, 0x50, 0x83, 0x20, 0xe6, 0x61, 0xdb, 0x6e, 0x04, 0x44, 0x3c, 0xd8, 0xfb, 0x15, 0x3f, + 0x64, 0x3e, 0xab, 0x28, 0x91, 0x80, 0x27, 0x64, 0x49, 0x3e, 0x07, 0x03, 0x95, 0x4e, 0x47, 0xba, + 0x6f, 0x42, 0xa7, 0x22, 0x56, 0x2a, 0x9e, 0xfb, 0x4c, 0x90, 0x5d, 0x7e, 0x0b, 0x46, 0xa3, 0x95, + 0xed, 0x29, 0x58, 0xfc, 0x0f, 0x72, 0xf8, 0x41, 0xc7, 0xdc, 0xa7, 0xf9, 0x65, 0x28, 0x54, 0x3a, + 0x1d, 0x31, 0x1f, 0x9d, 0x4b, 0xe9, 0x8f, 0xf8, 0x13, 0xe8, 0x4a, 0xa7, 0xe3, 0x7f, 0xfa, 0x31, + 0x7f, 0x1c, 0xb1, 0xaf, 0x4f, 0xff, 0x0e, 0xff, 0xf4, 0xe3, 0xfd, 0x70, 0x41, 0xfd, 0xad, 0x02, + 0x9c, 0xa9, 0x74, 0x3a, 0xa7, 0x41, 0xe6, 0x0f, 0xeb, 0xa1, 0xf5, 0x4b, 0x00, 0xd2, 0xf4, 0x38, + 0x10, 0x3c, 0xdd, 0x1a, 0x92, 0xa6, 0x46, 0x25, 0xa7, 0x49, 0x44, 0xbe, 0xfa, 0x95, 0xf7, 0xa4, + 0x7e, 0x5f, 0x2b, 0xe0, 0x54, 0x7c, 0xdc, 0x83, 0x46, 0x7d, 0x5c, 0xba, 0x4d, 0xf4, 0x41, 0x69, + 0x4f, 0x7d, 0xf0, 0x77, 0x23, 0x83, 0x07, 0x83, 0x96, 0x9f, 0xf6, 0x42, 0xff, 0x81, 0xcc, 0xe2, + 0x51, 0x59, 0x98, 0x22, 0x92, 0x8d, 0x9f, 0x48, 0x49, 0xc4, 0x55, 0x6a, 0x32, 0x54, 0xc3, 0x34, + 0xb4, 0x18, 0xad, 0xdf, 0x87, 0x03, 0x7b, 0xea, 0xc3, 0xad, 0x3c, 0xbe, 0x9d, 0x0e, 0xe2, 0x32, + 0x1d, 0x7c, 0x77, 0x71, 0x13, 0x80, 0x7b, 0x1e, 0x04, 0x6e, 0xcd, 0x23, 0x3c, 0x04, 0x0b, 0xcf, + 0xaf, 0x24, 0x42, 0xb0, 0x84, 0x24, 0x81, 0x87, 0x54, 0x21, 0xd5, 0x43, 0xea, 0x3a, 0x94, 0x35, + 0x7d, 0xe3, 0xdd, 0x2e, 0x75, 0x36, 0x85, 0x39, 0xc3, 0xc3, 0x1e, 0xea, 0x1b, 0x8d, 0x1f, 0x65, + 0x40, 0x2d, 0x40, 0x13, 0x35, 0x78, 0x7c, 0x2f, 0x79, 0x84, 0xf0, 0x33, 0xf2, 0xe0, 0xc9, 0xfd, + 0x7e, 0x14, 0x9d, 0xbc, 0x01, 0x85, 0xca, 0xc3, 0xba, 0x90, 0x6c, 0xd0, 0xb5, 0x95, 0x87, 0x75, + 0x21, 0xaf, 0xcc, 0xb2, 0x0f, 0xeb, 0xea, 0xd7, 0xf2, 0x40, 0x92, 0x94, 0xe4, 0x55, 0x18, 0x44, + 0xe8, 0x2a, 0xd3, 0x19, 0x39, 0x31, 0xe7, 0x86, 0xdb, 0x70, 0x10, 0x1a, 0x31, 0xee, 0x7c, 0x52, + 0xf2, 0x3a, 0xa6, 0x3e, 0x16, 0xa9, 0xe1, 0x22, 0x89, 0x39, 0x37, 0x5c, 0x3f, 0x59, 0x70, 0x2c, + 0xf3, 0xb1, 0x20, 0x46, 0xbb, 0xf0, 0x61, 0x7d, 0xc6, 0x76, 0x3d, 0x21, 0x6a, 0x6e, 0x17, 0x6e, + 0xb8, 0x98, 0x11, 0x36, 0x62, 0x17, 0x72, 0x32, 0xcc, 0x6a, 0xf5, 0xb0, 0xce, 0x9f, 0xa9, 0x18, + 0x9a, 0xdd, 0xf2, 0x0d, 0x4a, 0x9e, 0xd5, 0x6a, 0xc3, 0x6d, 0xf0, 0x27, 0x2e, 0x06, 0xe6, 0x5c, + 0x8e, 0x64, 0xb5, 0x8a, 0x94, 0x52, 0xbf, 0x5e, 0x86, 0xb1, 0xaa, 0xee, 0xe9, 0xcb, 0xba, 0x4b, + 0xa5, 0xdd, 0xf4, 0x19, 0x1f, 0xe6, 0x7f, 0x8e, 0x24, 0x07, 0x63, 0x39, 0xe5, 0x6b, 0xe2, 0x05, + 0xc8, 0x9b, 0x21, 0xdf, 0x20, 0xe7, 0xa8, 0x9c, 0xc4, 0x6c, 0xb9, 0xd1, 0x11, 0x60, 0x2d, 0x41, + 0x48, 0x5e, 0x80, 0x21, 0x1f, 0xc6, 0x36, 0x00, 0x85, 0x50, 0x67, 0x8c, 0x65, 0x66, 0xff, 0x6b, + 0x32, 0x9a, 0xbc, 0x0e, 0xc3, 0xfe, 0x4f, 0xc9, 0xb4, 0xe6, 0x19, 0xd9, 0x96, 0x13, 0xbb, 0x27, + 0x99, 0x54, 0x2e, 0x8a, 0xf3, 0x5b, 0x7f, 0xa4, 0x68, 0x2c, 0xe9, 0x59, 0x84, 0x94, 0xfc, 0x28, + 0x8c, 0xfa, 0xbf, 0xc5, 0x86, 0x81, 0xe7, 0x87, 0x7b, 0x21, 0x48, 0xe9, 0x1c, 0x13, 0xeb, 0x8d, + 0x28, 0x39, 0xdf, 0x3a, 0x3c, 0xe9, 0xe7, 0xf1, 0x32, 0x96, 0x93, 0x3b, 0x87, 0x58, 0x05, 0xa4, + 0x06, 0x67, 0x7d, 0x48, 0xa8, 0xa1, 0x03, 0xe1, 0x8e, 0xd1, 0x58, 0x6e, 0xa4, 0x2a, 0x69, 0xb2, + 0x14, 0x69, 0xc1, 0x95, 0x08, 0xd0, 0x70, 0xd7, 0xcc, 0x15, 0x4f, 0x6c, 0xf7, 0x44, 0x0c, 0x62, + 0x91, 0xb8, 0x31, 0xe0, 0xca, 0x69, 0xfc, 0x0c, 0xac, 0xd1, 0xec, 0x50, 0x3d, 0xb9, 0x91, 0x3a, + 0x9c, 0xf7, 0xf1, 0x77, 0x26, 0x17, 0x17, 0x1d, 0xfb, 0x7d, 0xda, 0xf4, 0x6a, 0x55, 0xb1, 0x5d, + 0xc6, 0xd8, 0x74, 0xc6, 0x72, 0x63, 0xb5, 0xd9, 0x61, 0x4a, 0xc1, 0x70, 0x51, 0xe6, 0xa9, 0x85, 0xc9, 0x03, 0xb8, 0x20, 0xc1, 0xa5, 0xf4, 0xd0, 0x10, 0xee, 0xe7, 0x05, 0xd7, 0xf4, 0x0c, 0xd1, - 0xe9, 0xc5, 0xc9, 0xdb, 0x30, 0xec, 0x23, 0xf8, 0x2d, 0xe2, 0x20, 0xde, 0x22, 0xe2, 0x90, 0x34, - 0x56, 0xeb, 0xf1, 0xd7, 0x94, 0x51, 0x62, 0x59, 0xa3, 0x30, 0xa3, 0xfe, 0x50, 0x44, 0xa3, 0xbc, - 0xad, 0x76, 0xaa, 0x32, 0x62, 0x96, 0xfd, 0x77, 0x43, 0x8d, 0x5a, 0x74, 0xcc, 0x75, 0x93, 0xef, - 0xa4, 0xfd, 0x07, 0x94, 0xab, 0x75, 0x1b, 0x81, 0x69, 0xfa, 0xc1, 0xc9, 0x2f, 0x97, 0xe1, 0x5c, - 0x8a, 0x8e, 0xed, 0x6b, 0xc7, 0xf8, 0xf5, 0x7c, 0xd8, 0x88, 0x13, 0xbe, 0x6d, 0x9c, 0x84, 0x7e, - 0xff, 0x4b, 0x84, 0xf1, 0xa0, 0x64, 0x0d, 0xcd, 0x38, 0x0f, 0x1f, 0x1f, 0x11, 0xc7, 0x09, 0xdf, - 0x4a, 0x1e, 0x85, 0x38, 0xbe, 0x9b, 0x0b, 0xc5, 0x71, 0xc2, 0xb7, 0x97, 0x3f, 0x59, 0x0c, 0xe7, - 0xa4, 0xb3, 0x3d, 0xe6, 0x51, 0x99, 0xc9, 0xa1, 0x1f, 0x6c, 0x69, 0x1f, 0x0f, 0x19, 0x65, 0xd5, - 0xec, 0x3b, 0x98, 0x6a, 0x92, 0xb7, 0x61, 0x70, 0xc9, 0x76, 0xbd, 0x75, 0x87, 0xba, 0x4b, 0x41, - 0x0c, 0x7d, 0x7c, 0x04, 0xdb, 0x16, 0xe0, 0x7a, 0x3b, 0x32, 0xfb, 0xcb, 0xe4, 0xea, 0x3f, 0x2e, - 0x24, 0xb4, 0x81, 0x1b, 0xae, 0x27, 0x52, 0x1b, 0x8e, 0x60, 0xa8, 0x93, 0xdb, 0xe1, 0x2a, 0xc8, - 0x2d, 0xfc, 0x5e, 0x29, 0x40, 0xe0, 0xaa, 0x30, 0xf0, 0xa3, 0x24, 0xe4, 0x07, 0xe0, 0x52, 0x04, - 0xb0, 0xa4, 0x3b, 0x7a, 0x8b, 0x7a, 0x61, 0xbe, 0x42, 0x0c, 0xf9, 0xe4, 0x97, 0xae, 0xb7, 0x03, - 0xb4, 0x9c, 0x03, 0x31, 0x83, 0x83, 0xa4, 0x5a, 0x7d, 0xfb, 0x70, 0xb1, 0xfe, 0xd9, 0x42, 0x68, - 0xe8, 0x44, 0x43, 0xb7, 0x6a, 0xd4, 0xed, 0x34, 0xbd, 0xd3, 0xdb, 0xc1, 0x07, 0x4b, 0x8c, 0x31, - 0x0b, 0xa3, 0xe5, 0xb5, 0x35, 0xda, 0xf0, 0xfc, 0x88, 0xd4, 0xae, 0x08, 0xd6, 0xc7, 0x37, 0x1e, - 0x02, 0x25, 0x22, 0x0c, 0x47, 0x32, 0xeb, 0xc7, 0x8a, 0xa9, 0xff, 0xa4, 0x08, 0x4a, 0x60, 0xf8, - 0x07, 0xcf, 0xbc, 0x8e, 0x71, 0x91, 0xfd, 0x58, 0xf4, 0x8a, 0x09, 0xe3, 0xa1, 0x30, 0x6a, 0x9d, - 0x56, 0x4b, 0xc7, 0xa1, 0xc7, 0x36, 0x16, 0x13, 0x71, 0x66, 0x21, 0x21, 0xdf, 0x4b, 0x5c, 0x16, - 0x7b, 0x09, 0x12, 0x3e, 0xa3, 0xab, 0xbb, 0x9c, 0x85, 0x96, 0xe4, 0x4a, 0xbe, 0x99, 0x83, 0xf3, - 0x7e, 0xa7, 0x2c, 0xae, 0x32, 0xa3, 0x7a, 0xca, 0xee, 0x58, 0x9e, 0xbf, 0x8f, 0x79, 0x33, 0xbb, - 0x3a, 0xde, 0x49, 0x37, 0xd3, 0x0a, 0xf3, 0x96, 0x04, 0x61, 0x29, 0x02, 0x85, 0xb0, 0x91, 0xa6, - 0xde, 0x40, 0x22, 0x2d, 0xb5, 0xde, 0xcb, 0x77, 0xe1, 0xa9, 0x4c, 0x96, 0xbb, 0x19, 0xb1, 0xbd, - 0xb2, 0x11, 0xfb, 0xdf, 0xe5, 0xc2, 0x89, 0x28, 0x26, 0x24, 0x72, 0x13, 0x20, 0x04, 0x89, 0x6d, - 0xed, 0xc8, 0xce, 0xf6, 0x04, 0x84, 0x42, 0xd3, 0x24, 0x0a, 0xb2, 0x08, 0x25, 0x21, 0x16, 0x9e, - 0x1b, 0xf8, 0xb3, 0xbb, 0xf4, 0xc2, 0x4d, 0x59, 0x0e, 0xb8, 0x65, 0x15, 0xdf, 0x2c, 0xd8, 0x5c, - 0x7e, 0x03, 0x06, 0x0f, 0xfa, 0x5d, 0xdf, 0x2c, 0x00, 0x91, 0xf7, 0xa0, 0xc7, 0x68, 0xa0, 0x9f, - 0xe0, 0x29, 0xec, 0x3a, 0xf4, 0xb3, 0x4f, 0xc0, 0x6c, 0x19, 0x52, 0x74, 0xdc, 0x8e, 0x80, 0x69, - 0x01, 0x36, 0x0c, 0x4d, 0xd5, 0x97, 0x1e, 0x9a, 0x4a, 0xfd, 0xe9, 0x02, 0x5c, 0x94, 0x3b, 0xa4, - 0x42, 0x31, 0xe0, 0xfe, 0x59, 0xa7, 0x7c, 0x84, 0x9d, 0xa2, 0x42, 0x89, 0x6f, 0x3d, 0x44, 0xe6, - 0x03, 0x7e, 0x2c, 0x84, 0x10, 0x4d, 0x60, 0xd4, 0xff, 0x39, 0x0f, 0xc3, 0x81, 0x79, 0xa7, 0x3b, - 0xee, 0x29, 0xee, 0x8e, 0xcf, 0xc3, 0x30, 0x06, 0x17, 0x6a, 0x51, 0x8b, 0x07, 0xe0, 0xe9, 0x95, - 0x52, 0x95, 0xf8, 0x08, 0x91, 0x95, 0x2a, 0x42, 0xc8, 0xb4, 0x9f, 0x5b, 0x7e, 0x52, 0xc8, 0x27, - 0x6e, 0xf6, 0x71, 0xb8, 0xfa, 0x17, 0x0b, 0x30, 0xe4, 0x4b, 0x79, 0xd2, 0x3c, 0xa9, 0xf7, 0x3c, - 0xc7, 0x2b, 0xe4, 0x5b, 0x00, 0x4b, 0xb6, 0xe3, 0xe9, 0xcd, 0x85, 0x50, 0xf3, 0xf1, 0x80, 0xb4, - 0x8d, 0x50, 0x5e, 0x46, 0x22, 0xc1, 0xf5, 0x2b, 0x34, 0xab, 0xf9, 0xc4, 0xc4, 0xd7, 0xaf, 0x00, - 0xaa, 0x49, 0x14, 0xea, 0xdf, 0xce, 0xc3, 0xa8, 0xdf, 0x49, 0xd3, 0x4f, 0x68, 0xa3, 0x73, 0x9a, - 0xe7, 0xa6, 0xa8, 0xb4, 0x7b, 0x77, 0x95, 0xb6, 0xfa, 0x7f, 0x4a, 0x13, 0xc9, 0x54, 0xd3, 0x3e, - 0x9b, 0x48, 0xfe, 0x38, 0x74, 0x5c, 0xfd, 0xd1, 0x02, 0x9c, 0xf7, 0xa5, 0x3e, 0xd3, 0xb1, 0xf0, - 0x68, 0x61, 0x4a, 0x6f, 0x36, 0x4f, 0xf3, 0x6e, 0x7c, 0xd0, 0x17, 0xc4, 0xa2, 0x88, 0xd6, 0x27, - 0x32, 0x04, 0xae, 0x09, 0x70, 0xdd, 0x36, 0x0d, 0x4d, 0x26, 0x22, 0xef, 0xc2, 0x90, 0xff, 0xb3, - 0xec, 0xac, 0xfb, 0x5b, 0x70, 0xbc, 0x28, 0x08, 0x0a, 0xe9, 0x4e, 0x24, 0x28, 0x41, 0xa4, 0x80, - 0xfa, 0xb5, 0x3e, 0xb8, 0xfc, 0xd0, 0xb4, 0x0c, 0x7b, 0xd3, 0xf5, 0x13, 0x4c, 0x9e, 0xf8, 0x83, - 0xb2, 0xe3, 0x4e, 0x2c, 0xf9, 0x1e, 0x5c, 0x88, 0x8b, 0xd4, 0x09, 0xc2, 0x7e, 0x8b, 0xde, 0xd9, - 0xe4, 0x04, 0x75, 0x3f, 0xd5, 0xa4, 0xb8, 0x6d, 0xd3, 0xd2, 0x4b, 0xc6, 0x73, 0x55, 0xf6, 0xed, - 0x25, 0x57, 0xe5, 0x0b, 0x50, 0xaa, 0xd8, 0x2d, 0xdd, 0xf4, 0xc3, 0xd3, 0xe0, 0x28, 0x0e, 0xea, - 0x45, 0x8c, 0x26, 0x28, 0x18, 0x7f, 0x51, 0x31, 0x76, 0xd9, 0x40, 0xc8, 0xdf, 0x2f, 0xc0, 0xac, - 0x34, 0x4d, 0x26, 0x22, 0x36, 0x0c, 0x8b, 0xea, 0xc4, 0xdd, 0x18, 0xe0, 0xe6, 0xe9, 0x55, 0x5f, - 0x46, 0xd9, 0x6a, 0x75, 0x33, 0x52, 0x8e, 0x6f, 0xa3, 0x78, 0x0a, 0x4d, 0xf1, 0x31, 0xfc, 0x96, - 0x4c, 0x8b, 0xf2, 0x97, 0x84, 0x80, 0x93, 0xcc, 0x60, 0x52, 0x08, 0x38, 0xcb, 0xc8, 0x44, 0x64, - 0x1a, 0xc6, 0x31, 0x38, 0x73, 0xb0, 0x95, 0x62, 0x2a, 0x31, 0x84, 0x46, 0x25, 0x5e, 0xb9, 0xf0, - 0x78, 0xce, 0xec, 0xe3, 0xea, 0x0d, 0x81, 0xd6, 0x92, 0x25, 0xc8, 0x53, 0x50, 0x58, 0x98, 0x2b, - 0xe3, 0x5d, 0x4d, 0x3f, 0x4f, 0x8c, 0x64, 0x35, 0x75, 0x8d, 0xc1, 0x2e, 0x7f, 0x11, 0x48, 0xf2, - 0x73, 0xf6, 0x75, 0x1f, 0xf3, 0x5f, 0x4a, 0x5b, 0xbe, 0x93, 0xee, 0x51, 0x73, 0x14, 0x13, 0x61, - 0x24, 0x27, 0x59, 0xef, 0x47, 0x99, 0x93, 0xac, 0x74, 0xa4, 0x39, 0xc9, 0xd4, 0x5f, 0xcd, 0xc1, - 0x78, 0x22, 0x80, 0x39, 0x79, 0x05, 0x80, 0x43, 0xa4, 0x40, 0x91, 0x18, 0x79, 0x25, 0x0c, 0x6a, - 0x2e, 0x96, 0xc7, 0x90, 0x8c, 0xdc, 0x82, 0x7e, 0xfe, 0x4b, 0x04, 0x77, 0x4a, 0x16, 0xe9, 0x74, - 0x4c, 0x43, 0x0b, 0x88, 0xc2, 0x5a, 0xf0, 0x46, 0xb2, 0x90, 0x5a, 0xc4, 0xdb, 0x6a, 0x07, 0xb5, - 0x30, 0x32, 0xf5, 0x1b, 0x79, 0x18, 0x0a, 0x1a, 0x5c, 0x36, 0x8e, 0x4b, 0xe7, 0x4a, 0x22, 0x16, - 0x7c, 0x61, 0xb7, 0x58, 0xf0, 0xb1, 0xf9, 0x56, 0x04, 0x7f, 0x3f, 0xba, 0x07, 0x55, 0xdf, 0xca, - 0xc3, 0x68, 0x50, 0xeb, 0x31, 0x5e, 0x7e, 0x7d, 0x8c, 0x44, 0xf2, 0xcd, 0x1c, 0x28, 0x93, 0x66, - 0xb3, 0x69, 0x5a, 0xeb, 0x55, 0x6b, 0xcd, 0x76, 0x5a, 0x38, 0x21, 0x1e, 0xdf, 0x11, 0xae, 0xfa, - 0xa7, 0x72, 0x30, 0x2e, 0x1a, 0x34, 0xa5, 0x3b, 0xc6, 0xf1, 0x9d, 0x8f, 0xc5, 0x5b, 0x72, 0x7c, - 0xfa, 0xa2, 0xfe, 0x4e, 0x1e, 0x60, 0xce, 0x6e, 0x3c, 0x3a, 0xe1, 0xef, 0xb1, 0xde, 0x82, 0x12, - 0x8f, 0xb0, 0x25, 0x34, 0x76, 0x5c, 0xbc, 0x3b, 0x62, 0x9f, 0xc6, 0x11, 0x93, 0x63, 0x62, 0x3e, - 0x2e, 0xf1, 0x08, 0x5d, 0x4a, 0x4e, 0x13, 0x45, 0x58, 0xa5, 0x8c, 0x4e, 0x2c, 0x18, 0x41, 0xa5, - 0x0c, 0x16, 0xad, 0x74, 0x67, 0x7b, 0xa2, 0xd8, 0xb4, 0x1b, 0x8f, 0x34, 0xa4, 0x57, 0xff, 0x55, - 0x8e, 0xcb, 0xee, 0x84, 0xbf, 0x2a, 0xf5, 0x3f, 0xbf, 0xb8, 0xcf, 0xcf, 0xff, 0xd3, 0x39, 0x38, - 0xaf, 0xd1, 0x86, 0xfd, 0x98, 0x3a, 0x5b, 0x53, 0xb6, 0x41, 0xef, 0x52, 0x8b, 0x3a, 0xc7, 0x35, - 0xa2, 0xfe, 0x13, 0x4c, 0x9e, 0x11, 0x36, 0x66, 0xc5, 0xa5, 0xc6, 0xc9, 0x49, 0x6c, 0xa2, 0xfe, - 0x46, 0x1f, 0x28, 0xa9, 0x56, 0xef, 0x89, 0x35, 0xe7, 0x32, 0xb7, 0x32, 0xc5, 0xa3, 0xda, 0xca, - 0xf4, 0xee, 0x6f, 0x2b, 0x53, 0xda, 0xef, 0x56, 0xa6, 0x6f, 0x2f, 0x5b, 0x99, 0x56, 0x7c, 0x2b, - 0xd3, 0x8f, 0x5b, 0x99, 0x57, 0xba, 0x6e, 0x65, 0xa6, 0x2d, 0xe3, 0x80, 0x1b, 0x99, 0x13, 0x9b, - 0x74, 0xf7, 0x20, 0x3b, 0xb0, 0xeb, 0x6c, 0x52, 0x6c, 0xd8, 0x8e, 0x41, 0x0d, 0xb1, 0xf1, 0xc2, - 0x53, 0x7f, 0x47, 0xc0, 0xb4, 0x00, 0x9b, 0xc8, 0x60, 0x3c, 0xbc, 0x97, 0x0c, 0xc6, 0x47, 0xb0, - 0xff, 0xfa, 0x7a, 0x1e, 0xc6, 0xa7, 0xa8, 0xe3, 0xf1, 0x10, 0x9e, 0x47, 0xe1, 0x12, 0x57, 0x86, - 0x51, 0x89, 0x21, 0x5a, 0xe4, 0xf9, 0xd0, 0xcd, 0xaf, 0x41, 0x1d, 0x2f, 0xee, 0x25, 0x18, 0xa7, - 0x67, 0xd5, 0xfb, 0x59, 0xc4, 0xc4, 0xd8, 0x0d, 0xaa, 0xf7, 0xe1, 0x5c, 0x90, 0xa6, 0xf8, 0xa5, - 0x05, 0xf4, 0x52, 0x62, 0xb0, 0xe2, 0xfe, 0x13, 0x83, 0xa9, 0xbf, 0x92, 0x83, 0x6b, 0x1a, 0xb5, - 0xe8, 0xa6, 0xbe, 0xda, 0xa4, 0x52, 0xb3, 0xc4, 0xca, 0xc0, 0x66, 0x0d, 0xd3, 0x6d, 0xe9, 0x5e, - 0x63, 0xe3, 0x50, 0x32, 0x9a, 0x81, 0x21, 0x79, 0xfe, 0xda, 0xc7, 0xdc, 0x16, 0x29, 0xa7, 0xfe, - 0x46, 0x11, 0xfa, 0x26, 0x6d, 0xef, 0x9e, 0x7d, 0xc8, 0x4c, 0x75, 0xe1, 0x94, 0x9f, 0xdf, 0xc7, - 0x59, 0xcf, 0xe7, 0xb0, 0x72, 0x29, 0x78, 0x3f, 0xba, 0x90, 0xae, 0xda, 0x89, 0x24, 0x07, 0x3e, - 0xd9, 0x3e, 0x73, 0xd4, 0xbd, 0x06, 0x03, 0x18, 0xfd, 0x45, 0x3a, 0x8d, 0x45, 0x07, 0x6d, 0x8f, - 0x01, 0xe3, 0x75, 0x84, 0xa4, 0xe4, 0x07, 0x22, 0x31, 0x47, 0x4b, 0x87, 0xcf, 0x69, 0x27, 0x87, - 0x1f, 0x7d, 0x85, 0x5f, 0xe4, 0x61, 0x9b, 0xa4, 0xfc, 0x1f, 0x78, 0x8a, 0x12, 0x6b, 0x52, 0x40, - 0x78, 0x84, 0xf9, 0xe6, 0xa6, 0x60, 0x78, 0xd2, 0xf6, 0x24, 0x67, 0xe0, 0x81, 0xf0, 0x19, 0x28, - 0x93, 0x7c, 0xba, 0x27, 0x70, 0xb4, 0x8c, 0xfa, 0x47, 0x45, 0x18, 0xf2, 0x7f, 0x1e, 0x93, 0xee, - 0xbc, 0x04, 0xa5, 0x59, 0x5b, 0x4a, 0x81, 0x80, 0x0e, 0xc4, 0x1b, 0xb6, 0x1b, 0xf3, 0x8c, 0x16, - 0x44, 0x4c, 0xea, 0x0b, 0xb6, 0x21, 0xbb, 0xbf, 0xa3, 0xd4, 0x2d, 0xdb, 0x48, 0x3c, 0x1f, 0x0e, - 0x08, 0xc9, 0x35, 0x28, 0xe2, 0xcb, 0x01, 0xe9, 0x20, 0x3f, 0xf6, 0x5a, 0x00, 0xf1, 0x92, 0x56, - 0x96, 0xf6, 0xab, 0x95, 0x7d, 0x07, 0xd5, 0xca, 0xfe, 0xa3, 0xd5, 0xca, 0xf7, 0x61, 0x08, 0x6b, - 0xf2, 0x33, 0xa8, 0xed, 0xbe, 0xb0, 0x3e, 0x25, 0xd6, 0xbe, 0x61, 0xde, 0x6e, 0x91, 0x47, 0x0d, - 0x97, 0xbc, 0x08, 0xab, 0x98, 0xee, 0xc2, 0x21, 0xb6, 0xd3, 0xff, 0x38, 0x07, 0x7d, 0x2b, 0xd6, - 0x23, 0xcb, 0xde, 0x3c, 0x9c, 0xc6, 0xbd, 0x02, 0x83, 0x82, 0x8d, 0xb4, 0xba, 0xe0, 0x8b, 0xf0, - 0x0e, 0x07, 0xd7, 0x91, 0x93, 0x26, 0x53, 0x91, 0xb7, 0x83, 0x42, 0xf8, 0x38, 0xa8, 0x10, 0x26, - 0x11, 0xf1, 0x0b, 0x35, 0xa2, 0x79, 0x0f, 0x64, 0x72, 0x72, 0x05, 0x8a, 0x15, 0xd6, 0x54, 0x29, - 0x8a, 0x2e, 0x6b, 0x8a, 0x86, 0x50, 0xf5, 0xeb, 0x45, 0x18, 0x89, 0x1d, 0x7c, 0xbd, 0x00, 0x03, - 0xe2, 0xe0, 0xc9, 0xf4, 0x13, 0x31, 0xe0, 0xe3, 0xa1, 0x00, 0xa8, 0xf5, 0xf3, 0x3f, 0xab, 0x06, - 0xf9, 0x02, 0xf4, 0xd9, 0x2e, 0x2e, 0x8a, 0xf8, 0x2d, 0x23, 0xe1, 0x10, 0x5a, 0xac, 0xb1, 0xb6, - 0xf3, 0xc1, 0x21, 0x48, 0x64, 0x8d, 0xb4, 0x5d, 0xfc, 0xb4, 0x3b, 0x30, 0xa0, 0xbb, 0x2e, 0xf5, - 0xea, 0x9e, 0xbe, 0x2e, 0xe7, 0x66, 0x08, 0x80, 0xf2, 0xe8, 0x40, 0xe0, 0xb2, 0xbe, 0x4e, 0xbe, - 0x08, 0xc3, 0x0d, 0x87, 0xe2, 0xb2, 0xa9, 0x37, 0x59, 0x2b, 0x25, 0xb3, 0x36, 0x82, 0x90, 0xef, - 0x4f, 0x42, 0x44, 0xd5, 0x20, 0x0f, 0x60, 0x58, 0x7c, 0x0e, 0xf7, 0xdc, 0xc7, 0x81, 0x36, 0x12, - 0x2e, 0x63, 0x5c, 0x24, 0xdc, 0x77, 0x5f, 0x3c, 0xe0, 0x90, 0xc9, 0x65, 0xbe, 0x86, 0x44, 0x4a, - 0x16, 0x81, 0x6c, 0xd2, 0xd5, 0xba, 0xde, 0xf1, 0x36, 0x58, 0x5d, 0x3c, 0xb4, 0xb8, 0x48, 0x49, - 0x88, 0xaf, 0x1e, 0x92, 0x58, 0xf9, 0x31, 0xc8, 0x26, 0x5d, 0x2d, 0x47, 0x90, 0xe4, 0x21, 0x5c, - 0x48, 0x16, 0x61, 0x9f, 0xcc, 0x2f, 0x07, 0x9e, 0xdf, 0xd9, 0x9e, 0x98, 0x48, 0x25, 0x90, 0xd8, - 0x9e, 0x4b, 0xb0, 0xad, 0x1a, 0xf7, 0x8a, 0xfd, 0x7d, 0x63, 0xfd, 0xda, 0x08, 0x2b, 0xeb, 0x9b, - 0x90, 0xa6, 0xa1, 0xfe, 0x5e, 0x8e, 0x99, 0x8a, 0xec, 0x83, 0x30, 0x27, 0x33, 0xd3, 0xf5, 0xd6, - 0x3e, 0x75, 0xbd, 0x15, 0x66, 0x4f, 0x2c, 0xb9, 0x5d, 0x66, 0x57, 0x4d, 0x60, 0xc9, 0x4d, 0x28, - 0x19, 0xf2, 0xa9, 0xd9, 0xc5, 0x68, 0x27, 0xf8, 0xf5, 0x68, 0x82, 0x8a, 0x5c, 0x87, 0x22, 0x5b, - 0xb2, 0xe2, 0x5b, 0x66, 0xd9, 0xba, 0xd0, 0x90, 0x42, 0xfd, 0x91, 0x3c, 0x0c, 0x49, 0x5f, 0x73, - 0xfb, 0x50, 0x9f, 0xf3, 0xe6, 0xde, 0x9a, 0xe9, 0x3b, 0xbd, 0xe0, 0x5e, 0xca, 0x6f, 0xf2, 0x9d, - 0x40, 0x14, 0x7b, 0xba, 0x90, 0x12, 0x82, 0x79, 0x4d, 0x7c, 0x68, 0x69, 0xef, 0xdb, 0x47, 0x46, - 0x7f, 0xaf, 0xd8, 0x9f, 0x1f, 0x2b, 0xdc, 0x2b, 0xf6, 0x17, 0xc7, 0x7a, 0x31, 0x0e, 0x17, 0x86, - 0xbe, 0xe6, 0x7b, 0x73, 0x6b, 0xcd, 0x5c, 0x3f, 0xe1, 0x6f, 0x47, 0x8e, 0x36, 0x46, 0x59, 0x4c, - 0x36, 0x27, 0xfc, 0x21, 0xc9, 0x47, 0x2a, 0x9b, 0xb3, 0x6c, 0x8b, 0x42, 0x36, 0xff, 0x24, 0x07, - 0x4a, 0xaa, 0x6c, 0xca, 0xc7, 0xe4, 0x07, 0x71, 0x74, 0x39, 0x17, 0xff, 0x20, 0x0f, 0xe3, 0x55, - 0xcb, 0xa3, 0xeb, 0x7c, 0xc7, 0x78, 0xc2, 0xa7, 0x8a, 0xfb, 0x30, 0x28, 0x7d, 0x8c, 0xe8, 0xf3, - 0xa7, 0x83, 0xfd, 0x78, 0x88, 0xca, 0xe0, 0x24, 0x97, 0x3e, 0xc2, 0x34, 0xed, 0x31, 0x21, 0x9f, - 0xf0, 0x39, 0xe7, 0x64, 0x08, 0xf9, 0x84, 0x4f, 0x5e, 0x1f, 0x53, 0x21, 0xff, 0xef, 0x39, 0x38, - 0x97, 0x52, 0x39, 0xb9, 0x06, 0x7d, 0xb5, 0xce, 0x2a, 0x86, 0xdd, 0xca, 0x85, 0x1e, 0xc3, 0x6e, - 0x67, 0x15, 0x23, 0x6e, 0x69, 0x3e, 0x92, 0x2c, 0xe3, 0xe3, 0xfa, 0xc5, 0x6a, 0x65, 0x4a, 0x48, - 0x55, 0x95, 0xc2, 0x04, 0x30, 0x70, 0xda, 0x97, 0x05, 0x0f, 0xf0, 0x6d, 0xd3, 0x68, 0xc4, 0x1e, - 0xe0, 0xb3, 0x32, 0xe4, 0x07, 0x61, 0xa0, 0xfc, 0x61, 0xc7, 0xa1, 0xc8, 0x97, 0x4b, 0xfc, 0x53, - 0x01, 0x5f, 0x1f, 0x91, 0xc6, 0x99, 0xc7, 0x12, 0x60, 0x14, 0x71, 0xde, 0x21, 0x43, 0xf5, 0x1b, - 0x39, 0xb8, 0x9c, 0xdd, 0x3a, 0xf2, 0x39, 0xe8, 0x63, 0x3b, 0xf3, 0xb2, 0xb6, 0x20, 0x3e, 0x9d, - 0xe7, 0x27, 0xb5, 0x9b, 0xb4, 0xae, 0x3b, 0xb2, 0xb1, 0xef, 0x93, 0x91, 0x77, 0x60, 0xb0, 0xea, - 0xba, 0x1d, 0xea, 0xd4, 0x5e, 0x59, 0xd1, 0xaa, 0x62, 0x4f, 0x88, 0x7b, 0x0e, 0x13, 0xc1, 0x75, - 0xf7, 0x95, 0x58, 0x60, 0x2d, 0x99, 0x5e, 0xfd, 0xf1, 0x1c, 0x5c, 0xe9, 0xf6, 0x55, 0xe4, 0x15, - 0xe8, 0x5f, 0xa6, 0x96, 0x6e, 0x79, 0xd5, 0x8a, 0x68, 0x12, 0x6e, 0xb1, 0x3c, 0x84, 0x45, 0x77, - 0x0a, 0x01, 0x21, 0x2b, 0xc4, 0xcf, 0x15, 0x03, 0x47, 0x06, 0x7e, 0x06, 0x8a, 0xb0, 0x58, 0x21, - 0x9f, 0x50, 0xfd, 0xfd, 0x3c, 0x0c, 0x2d, 0x35, 0x3b, 0xeb, 0xa6, 0xb4, 0x70, 0x1c, 0xd8, 0xde, - 0xf6, 0xad, 0xdf, 0xfc, 0xfe, 0xac, 0x5f, 0x36, 0xdc, 0x9c, 0x03, 0x0e, 0x37, 0xbf, 0x1c, 0x79, - 0x1b, 0x4a, 0x6d, 0xfc, 0x8e, 0xf8, 0x49, 0x2c, 0xff, 0xba, 0xac, 0x93, 0x58, 0x5e, 0x86, 0x8d, - 0xaf, 0xc6, 0x21, 0xc6, 0x57, 0x58, 0x56, 0x12, 0x68, 0xb8, 0x48, 0x9c, 0x09, 0xf4, 0x48, 0x04, - 0x1a, 0x2e, 0x08, 0x67, 0x02, 0x3d, 0x84, 0x40, 0x7f, 0x23, 0x0f, 0x23, 0xd1, 0x2a, 0xc9, 0xe7, - 0x60, 0x90, 0x57, 0xc3, 0xcf, 0x85, 0x72, 0x92, 0x53, 0x71, 0x08, 0xd6, 0x80, 0xff, 0x10, 0x07, - 0x5c, 0xa3, 0x1b, 0xba, 0x5b, 0x0f, 0x4f, 0x68, 0xf8, 0xfd, 0x6d, 0x3f, 0xf7, 0x84, 0x8a, 0xa1, - 0xb4, 0x91, 0x0d, 0xdd, 0x9d, 0x0a, 0x7f, 0x93, 0x69, 0x20, 0x0e, 0xed, 0xb8, 0x34, 0xca, 0xa0, - 0x88, 0x0c, 0x44, 0x72, 0xe8, 0x38, 0x56, 0x1b, 0xe7, 0x30, 0x99, 0xcd, 0x57, 0x82, 0x66, 0xa3, - 0x32, 0xf4, 0xee, 0x21, 0x73, 0xb5, 0x44, 0x9f, 0x7e, 0xcc, 0xc9, 0x09, 0x2a, 0xba, 0xa7, 0xf3, - 0x4d, 0xb9, 0xdf, 0x01, 0xea, 0xcf, 0xb4, 0xa0, 0x77, 0xd1, 0xa2, 0x8b, 0x6b, 0xe4, 0x65, 0x18, - 0x60, 0x0a, 0x33, 0x67, 0xb3, 0xbe, 0xcc, 0x09, 0xff, 0x09, 0x49, 0x93, 0x10, 0x31, 0xdb, 0xa3, - 0x85, 0x54, 0xe4, 0x0e, 0xcf, 0x7e, 0xcf, 0xe7, 0x58, 0xa1, 0x7d, 0x44, 0x2e, 0xc3, 0x31, 0xb3, - 0x3d, 0x9a, 0x44, 0xe7, 0x97, 0x12, 0x0f, 0x74, 0x0a, 0xc9, 0x52, 0x1c, 0xe3, 0x97, 0x12, 0xe3, - 0x63, 0x2e, 0x2d, 0xb1, 0x7c, 0x7c, 0xf7, 0x94, 0xa4, 0x98, 0xed, 0xd1, 0xd2, 0x13, 0xd2, 0x0f, - 0xc9, 0x0e, 0xa5, 0x71, 0xa7, 0x0f, 0x19, 0x37, 0xdb, 0xa3, 0x45, 0x68, 0xc9, 0xeb, 0x30, 0x28, - 0x7e, 0xdf, 0xb3, 0xc5, 0x8d, 0xb2, 0x14, 0x8b, 0x48, 0x42, 0xcd, 0xf6, 0x68, 0x32, 0xa5, 0x54, - 0xe9, 0x92, 0x63, 0x5a, 0x9e, 0x78, 0xa3, 0x1c, 0xaf, 0x14, 0x71, 0x52, 0xa5, 0xf8, 0x9b, 0xbc, - 0x03, 0xc3, 0x41, 0x90, 0xa7, 0x0f, 0x68, 0xc3, 0x13, 0x87, 0xdf, 0x17, 0x62, 0x85, 0x39, 0x72, - 0xb6, 0x47, 0x8b, 0x52, 0x93, 0xeb, 0x50, 0xd2, 0xa8, 0x6b, 0x7e, 0xe8, 0x5f, 0x17, 0x8f, 0x48, - 0xe3, 0xdc, 0xfc, 0x90, 0x49, 0x49, 0xe0, 0x59, 0xef, 0x84, 0xf7, 0xd3, 0xe2, 0xa8, 0x9a, 0xc4, - 0x6a, 0x99, 0xb6, 0x0c, 0xd6, 0x3b, 0x92, 0x73, 0xc2, 0x17, 0xc3, 0xd0, 0x57, 0x22, 0x61, 0xe6, - 0x60, 0x3c, 0xc6, 0x80, 0x8c, 0x9d, 0xed, 0xd1, 0x62, 0xf4, 0x92, 0x54, 0x2b, 0xa6, 0xfb, 0x48, - 0x44, 0x1b, 0x8d, 0x4b, 0x95, 0xa1, 0x24, 0xa9, 0xb2, 0x9f, 0x52, 0xd5, 0x0b, 0xd4, 0xdb, 0xb4, - 0x9d, 0x47, 0x22, 0xb6, 0x68, 0xbc, 0x6a, 0x81, 0x95, 0xaa, 0x16, 0x10, 0xb9, 0x6a, 0x36, 0xe0, - 0x46, 0xd2, 0xab, 0xd6, 0x3d, 0x5d, 0xae, 0x9a, 0x9f, 0xc4, 0xf9, 0x9d, 0x34, 0x47, 0xf5, 0xc7, - 0x3c, 0x6f, 0x79, 0xb2, 0x43, 0x11, 0x27, 0x75, 0x28, 0xfe, 0x66, 0x95, 0x4a, 0xb9, 0xa9, 0x45, - 0x62, 0xf2, 0xa0, 0x52, 0x09, 0xc5, 0x2a, 0x95, 0xb3, 0x58, 0xdf, 0x91, 0x53, 0x36, 0x2b, 0xe3, - 0xd1, 0x0e, 0x0a, 0x31, 0xac, 0x83, 0xa4, 0xd4, 0xce, 0x13, 0x98, 0x0e, 0x56, 0x21, 0x48, 0x3e, - 0x18, 0xb4, 0x70, 0x6a, 0x69, 0xb6, 0x47, 0xc3, 0x44, 0xb1, 0x2a, 0x4f, 0x34, 0xac, 0x9c, 0x43, - 0x8a, 0x21, 0x9f, 0x82, 0xc1, 0x66, 0x7b, 0x34, 0x9e, 0x84, 0xf8, 0x65, 0x29, 0xa5, 0x9f, 0x72, - 0x3e, 0x3a, 0x45, 0x04, 0x08, 0x36, 0x45, 0x84, 0x89, 0xff, 0x66, 0x92, 0x69, 0xef, 0x94, 0x0b, - 0xd1, 0xa5, 0x26, 0x8e, 0x9f, 0xed, 0xd1, 0x92, 0xa9, 0xf2, 0x5e, 0x8f, 0x64, 0x82, 0x53, 0x2e, - 0xc6, 0x02, 0x80, 0x85, 0x28, 0x26, 0x2e, 0x39, 0x67, 0xdc, 0x62, 0x2c, 0x6b, 0xb9, 0x98, 0xac, - 0x2e, 0x45, 0x37, 0x2e, 0x29, 0x24, 0xb3, 0x3d, 0x5a, 0x5a, 0x49, 0x32, 0x95, 0xc8, 0xc7, 0xa6, - 0x28, 0x51, 0xdf, 0x98, 0x18, 0x7a, 0xb6, 0x47, 0x4b, 0x64, 0x70, 0xbb, 0x23, 0x27, 0x42, 0x53, - 0x9e, 0x8a, 0x76, 0x62, 0x88, 0x61, 0x9d, 0x28, 0x25, 0x4c, 0xbb, 0x23, 0x27, 0xc7, 0x52, 0x2e, - 0x27, 0x4b, 0x85, 0x33, 0xa7, 0x94, 0x44, 0x4b, 0x4b, 0xcf, 0xf7, 0xa3, 0x3c, 0x2d, 0x32, 0xae, - 0x8a, 0xf2, 0x69, 0x34, 0xb3, 0x3d, 0x5a, 0x7a, 0xae, 0x20, 0x2d, 0x3d, 0x51, 0x8e, 0x72, 0xa5, - 0x1b, 0xcf, 0xa0, 0x75, 0xe9, 0x49, 0x76, 0xf4, 0x2e, 0x69, 0x4b, 0x94, 0x67, 0xa2, 0xd1, 0x87, - 0x33, 0x09, 0x67, 0x7b, 0xb4, 0x2e, 0xc9, 0x4f, 0x56, 0x32, 0x72, 0x88, 0x28, 0x57, 0xa3, 0x09, - 0x97, 0x53, 0x89, 0x66, 0x7b, 0xb4, 0x8c, 0x0c, 0x24, 0x2b, 0x19, 0x29, 0x26, 0x94, 0x89, 0xae, - 0x6c, 0x03, 0x79, 0x64, 0x24, 0xa8, 0x58, 0x4c, 0xcd, 0xce, 0xa0, 0x3c, 0x1b, 0x55, 0xdd, 0x14, - 0x12, 0xa6, 0xba, 0x69, 0x79, 0x1d, 0x16, 0x53, 0xd3, 0x09, 0x28, 0xcf, 0x75, 0x61, 0x18, 0xb4, - 0x31, 0x35, 0x11, 0xc1, 0x62, 0x6a, 0x3c, 0x7f, 0x45, 0x8d, 0x32, 0x4c, 0x21, 0x61, 0x0c, 0xd3, - 0x32, 0x01, 0x2c, 0xa6, 0x86, 0x7d, 0x57, 0x9e, 0xef, 0xc2, 0x30, 0x6c, 0x61, 0x5a, 0xc0, 0xf8, - 0xd7, 0x23, 0x71, 0xd7, 0x95, 0x4f, 0x45, 0xe7, 0x0d, 0x09, 0xc5, 0xe6, 0x0d, 0x39, 0x42, 0xfb, - 0x54, 0x22, 0xb2, 0xac, 0xf2, 0xe9, 0xe8, 0x30, 0x8f, 0xa1, 0xd9, 0x30, 0x8f, 0xc7, 0xa2, 0x9d, - 0x4a, 0x44, 0xd8, 0x54, 0xae, 0x65, 0x31, 0x41, 0x74, 0x94, 0x09, 0x8f, 0xc9, 0x59, 0x4d, 0x09, - 0xf1, 0xa8, 0x7c, 0x26, 0xea, 0xd7, 0x9d, 0x20, 0x98, 0xed, 0xd1, 0x52, 0x02, 0x43, 0x6a, 0xe9, - 0xf1, 0x8c, 0x94, 0xeb, 0xd1, 0x61, 0x9b, 0x46, 0xc3, 0x86, 0x6d, 0x6a, 0x2c, 0xa4, 0xb9, 0xb4, - 0xc7, 0x27, 0xca, 0x8d, 0xa8, 0x61, 0x96, 0xa4, 0x60, 0x86, 0x59, 0xca, 0xa3, 0x15, 0x2d, 0x3d, - 0xc6, 0x8e, 0xf2, 0x42, 0xd7, 0x16, 0x22, 0x4d, 0x4a, 0x0b, 0x79, 0xc8, 0x99, 0xd0, 0x76, 0x5a, - 0x69, 0x37, 0x6d, 0xdd, 0x50, 0x3e, 0x9b, 0x6a, 0x3b, 0x71, 0xa4, 0x64, 0x3b, 0x71, 0x00, 0x5b, - 0xe5, 0xe5, 0x37, 0x0e, 0xca, 0x8b, 0xd1, 0x55, 0x5e, 0xc6, 0xb1, 0x55, 0x3e, 0xf2, 0x1e, 0x62, - 0x2a, 0xf1, 0x1e, 0x40, 0x79, 0x29, 0xaa, 0x00, 0x31, 0x34, 0x53, 0x80, 0xf8, 0x0b, 0x82, 0xaf, - 0x66, 0x7b, 0xd0, 0x2b, 0x37, 0x91, 0xdb, 0xb3, 0x3e, 0xb7, 0x2c, 0xba, 0xd9, 0x1e, 0x2d, 0xdb, - 0x0b, 0xbf, 0x9a, 0xe2, 0x10, 0xaf, 0xdc, 0x8a, 0x2a, 0x58, 0x82, 0x80, 0x29, 0x58, 0xd2, 0x8d, - 0xbe, 0x9a, 0xe2, 0xd1, 0xae, 0x7c, 0x2e, 0x93, 0x55, 0xf0, 0xcd, 0x29, 0x7e, 0xf0, 0x77, 0x64, - 0x97, 0x74, 0xe5, 0xe5, 0xe8, 0x62, 0x17, 0x62, 0xd8, 0x62, 0x27, 0xb9, 0xae, 0xdf, 0x91, 0x9d, - 0xb1, 0x95, 0xdb, 0xc9, 0x52, 0xe1, 0x12, 0x29, 0x39, 0x6d, 0x6b, 0xe9, 0x3e, 0xcc, 0xca, 0x2b, - 0x51, 0xad, 0x4b, 0xa3, 0x61, 0x5a, 0x97, 0xea, 0xff, 0x3c, 0x93, 0x74, 0x45, 0x56, 0xee, 0xc4, - 0x37, 0xd9, 0x51, 0x3c, 0xb3, 0x7c, 0x12, 0xee, 0xcb, 0x5f, 0x8c, 0x07, 0xdb, 0x53, 0x5e, 0x8d, - 0x5d, 0xfb, 0x46, 0xb0, 0xcc, 0xbe, 0x8d, 0x05, 0xe7, 0xfb, 0x62, 0x3c, 0x3e, 0x9d, 0xf2, 0x5a, - 0x3a, 0x87, 0x40, 0x57, 0xe2, 0xf1, 0xec, 0xbe, 0x18, 0x0f, 0xe9, 0xa6, 0xbc, 0x9e, 0xce, 0x21, - 0x90, 0x6e, 0x3c, 0x04, 0xdc, 0xcb, 0x52, 0x90, 0x79, 0xe5, 0xf3, 0x51, 0xd3, 0x31, 0x40, 0x30, - 0xd3, 0x31, 0x0c, 0x45, 0xff, 0xb2, 0x14, 0x9c, 0x5d, 0x79, 0x23, 0x51, 0x24, 0x68, 0xac, 0x14, - 0xc2, 0xfd, 0x65, 0x29, 0xa8, 0xb9, 0xf2, 0x66, 0xa2, 0x48, 0xd0, 0x3a, 0x29, 0xf4, 0xb9, 0xd1, - 0xed, 0xfd, 0xaa, 0xf2, 0x56, 0xf4, 0x30, 0x38, 0x9b, 0x72, 0xb6, 0x47, 0xeb, 0xf6, 0x0e, 0xf6, - 0xab, 0xd9, 0x8e, 0xdd, 0xca, 0xdb, 0xd1, 0x21, 0x9c, 0x45, 0xc7, 0x86, 0x70, 0xa6, 0x73, 0xf8, - 0x3b, 0xb1, 0x58, 0x16, 0xca, 0x3b, 0xd1, 0x29, 0x2e, 0x82, 0x64, 0x53, 0x5c, 0x3c, 0xf2, 0x45, - 0x24, 0x48, 0x83, 0xf2, 0x85, 0xe8, 0x14, 0x27, 0xe3, 0xd8, 0x14, 0x17, 0x09, 0xe8, 0x30, 0x95, - 0x88, 0x1d, 0xa0, 0xbc, 0x1b, 0x9d, 0xe2, 0x62, 0x68, 0x36, 0xc5, 0xc5, 0xa3, 0x0d, 0xbc, 0x13, - 0x7b, 0x42, 0xaf, 0x7c, 0x31, 0xbd, 0xfd, 0x88, 0x94, 0xdb, 0xcf, 0x1f, 0xdc, 0x6b, 0xe9, 0x6f, - 0xc1, 0x95, 0x72, 0x74, 0xfc, 0xa6, 0xd1, 0xb0, 0xf1, 0x9b, 0xfa, 0x8e, 0x3c, 0xbe, 0x71, 0x10, - 0x5a, 0x35, 0xd9, 0x65, 0xe3, 0x10, 0x9a, 0x22, 0x29, 0xe0, 0xc8, 0x1e, 0x99, 0x6f, 0x84, 0xa6, - 0x32, 0xf6, 0xc8, 0xfe, 0x36, 0x28, 0x46, 0xcf, 0x66, 0xd7, 0x84, 0x9f, 0xb1, 0x52, 0x89, 0xce, - 0xae, 0x09, 0x02, 0x36, 0xbb, 0x26, 0xbd, 0x93, 0x67, 0x60, 0x4c, 0x68, 0x11, 0x77, 0x9f, 0x36, - 0xad, 0x75, 0x65, 0x3a, 0xf6, 0xde, 0x32, 0x86, 0x67, 0xb3, 0x53, 0x1c, 0x86, 0xeb, 0x35, 0x87, - 0x4d, 0x35, 0xcd, 0xf6, 0xaa, 0xad, 0x3b, 0x46, 0x8d, 0x5a, 0x86, 0x32, 0x13, 0x5b, 0xaf, 0x53, - 0x68, 0x70, 0xbd, 0x4e, 0x81, 0x63, 0x88, 0xb8, 0x18, 0x5c, 0xa3, 0x0d, 0x6a, 0x3e, 0xa6, 0xca, - 0x5d, 0x64, 0x3b, 0x91, 0xc5, 0x56, 0x90, 0xcd, 0xf6, 0x68, 0x59, 0x1c, 0x98, 0xad, 0x3e, 0xbf, - 0x55, 0x7b, 0x6f, 0x2e, 0x08, 0x3f, 0xb0, 0xe4, 0xd0, 0xb6, 0xee, 0x50, 0x65, 0x36, 0x6a, 0xab, - 0xa7, 0x12, 0x31, 0x5b, 0x3d, 0x15, 0x91, 0x64, 0xeb, 0x8f, 0x85, 0x6a, 0x37, 0xb6, 0xe1, 0x88, - 0x48, 0x2f, 0xcd, 0x66, 0xa7, 0x28, 0x82, 0x09, 0x68, 0xce, 0xb6, 0xd6, 0xf1, 0xa4, 0xe2, 0x5e, - 0x74, 0x76, 0xca, 0xa6, 0x64, 0xb3, 0x53, 0x36, 0x96, 0xa9, 0x7a, 0x14, 0xcb, 0xc7, 0xe0, 0xfd, - 0xa8, 0xaa, 0xa7, 0x90, 0x30, 0x55, 0x4f, 0x01, 0x27, 0x19, 0x6a, 0xd4, 0xa5, 0x9e, 0x32, 0xd7, - 0x8d, 0x21, 0x92, 0x24, 0x19, 0x22, 0x38, 0xc9, 0x70, 0x86, 0x7a, 0x8d, 0x0d, 0x65, 0xbe, 0x1b, - 0x43, 0x24, 0x49, 0x32, 0x44, 0x30, 0xdb, 0x6c, 0x46, 0xc1, 0x93, 0x9d, 0xe6, 0x23, 0xbf, 0xcf, - 0x16, 0xa2, 0x9b, 0xcd, 0x4c, 0x42, 0xb6, 0xd9, 0xcc, 0x44, 0x92, 0x1f, 0xdf, 0xb3, 0x1f, 0xbc, - 0xb2, 0x88, 0x15, 0xde, 0x0c, 0xed, 0x82, 0xbd, 0x94, 0x9a, 0xed, 0xd1, 0xf6, 0xea, 0x67, 0xff, - 0xd9, 0xc0, 0x69, 0x54, 0x59, 0xc2, 0xaa, 0x46, 0x83, 0xb3, 0x0a, 0x0e, 0x9e, 0xed, 0xd1, 0x02, - 0xb7, 0xd2, 0xd7, 0x61, 0x10, 0x3f, 0xaa, 0x6a, 0x99, 0x5e, 0x65, 0x52, 0x79, 0x2f, 0xba, 0x65, - 0x92, 0x50, 0x6c, 0xcb, 0x24, 0xfd, 0x64, 0x93, 0x38, 0xfe, 0xe4, 0x53, 0x4c, 0x65, 0x52, 0xd1, - 0xa2, 0x93, 0x78, 0x04, 0xc9, 0x26, 0xf1, 0x08, 0x20, 0xa8, 0xb7, 0xe2, 0xd8, 0xed, 0xca, 0xa4, - 0x52, 0x4b, 0xa9, 0x97, 0xa3, 0x82, 0x7a, 0xf9, 0xcf, 0xa0, 0xde, 0xda, 0x46, 0xc7, 0xab, 0xb0, - 0x6f, 0x5c, 0x4e, 0xa9, 0xd7, 0x47, 0x06, 0xf5, 0xfa, 0x00, 0x36, 0x15, 0x22, 0x60, 0xc9, 0xb1, - 0xd9, 0xa4, 0x7d, 0xdf, 0x6c, 0x36, 0x95, 0x95, 0xe8, 0x54, 0x18, 0xc7, 0xb3, 0xa9, 0x30, 0x0e, - 0x63, 0xa6, 0x27, 0x6f, 0x15, 0x5d, 0xed, 0xac, 0x2b, 0x0f, 0xa2, 0xa6, 0x67, 0x88, 0x61, 0xa6, - 0x67, 0xf8, 0x0b, 0x77, 0x17, 0xec, 0x97, 0x46, 0xd7, 0x1c, 0xea, 0x6e, 0x28, 0x0f, 0x63, 0xbb, - 0x0b, 0x09, 0x87, 0xbb, 0x0b, 0xe9, 0x37, 0x59, 0x87, 0xa7, 0x23, 0x0b, 0x8d, 0x7f, 0x69, 0x53, - 0xa3, 0xba, 0xd3, 0xd8, 0x50, 0xbe, 0x84, 0xac, 0x9e, 0x4f, 0x5d, 0xaa, 0xa2, 0xa4, 0xb3, 0x3d, - 0x5a, 0x37, 0x4e, 0xb8, 0x2d, 0x7f, 0x6f, 0x8e, 0x47, 0x82, 0xd5, 0x96, 0xa6, 0xfc, 0x4d, 0xe8, - 0xfb, 0xb1, 0x6d, 0x79, 0x92, 0x04, 0xb7, 0xe5, 0x49, 0x30, 0x69, 0xc3, 0xd5, 0xd8, 0x56, 0x6d, - 0x5e, 0x6f, 0xb2, 0x7d, 0x09, 0x35, 0x96, 0xf4, 0xc6, 0x23, 0xea, 0x29, 0x5f, 0x46, 0xde, 0xd7, - 0x32, 0x36, 0x7c, 0x31, 0xea, 0xd9, 0x1e, 0x6d, 0x17, 0x7e, 0x44, 0x85, 0x62, 0x6d, 0x66, 0x79, - 0x49, 0xf9, 0x81, 0xe8, 0xf9, 0x26, 0x83, 0xcd, 0xf6, 0x68, 0x88, 0x63, 0x56, 0xda, 0x4a, 0x7b, - 0xdd, 0xd1, 0x0d, 0xca, 0x0d, 0x2d, 0xb4, 0xdd, 0x84, 0x01, 0xfa, 0x83, 0x51, 0x2b, 0x2d, 0x8b, - 0x8e, 0x59, 0x69, 0x59, 0x38, 0xa6, 0xa8, 0x91, 0xa4, 0x27, 0xca, 0x57, 0xa2, 0x8a, 0x1a, 0x41, - 0x32, 0x45, 0x8d, 0xa6, 0x48, 0xf9, 0x12, 0x5c, 0x0c, 0xf6, 0xf3, 0x62, 0xfd, 0xe5, 0x9d, 0xa6, - 0x7c, 0x15, 0xf9, 0x5c, 0x4d, 0x5c, 0x06, 0x44, 0xa8, 0x66, 0x7b, 0xb4, 0x8c, 0xf2, 0x6c, 0xc5, - 0x4d, 0xe4, 0xf3, 0x12, 0xe6, 0xc5, 0x0f, 0x45, 0x57, 0xdc, 0x0c, 0x32, 0xb6, 0xe2, 0x66, 0xa0, - 0x52, 0x99, 0x0b, 0xa1, 0xea, 0xbb, 0x30, 0x0f, 0x64, 0x9a, 0xc5, 0x21, 0x95, 0xb9, 0xb0, 0xd4, - 0x56, 0x77, 0x61, 0x1e, 0x58, 0x6b, 0x59, 0x1c, 0xc8, 0x75, 0x28, 0xd5, 0x6a, 0xf3, 0x5a, 0xc7, - 0x52, 0x1a, 0x31, 0x6f, 0x59, 0x84, 0xce, 0xf6, 0x68, 0x02, 0xcf, 0xcc, 0xa0, 0xe9, 0xa6, 0xee, - 0x7a, 0x66, 0xc3, 0xc5, 0x11, 0xe3, 0x8f, 0x10, 0x23, 0x6a, 0x06, 0xa5, 0xd1, 0x30, 0x33, 0x28, - 0x0d, 0xce, 0xec, 0xc5, 0x29, 0xdd, 0x75, 0x75, 0xcb, 0x70, 0xf4, 0x49, 0x5c, 0x26, 0x68, 0xec, - 0x35, 0x56, 0x04, 0xcb, 0xec, 0xc5, 0x28, 0x04, 0x0f, 0xdf, 0x7d, 0x88, 0x6f, 0xe6, 0xac, 0xc5, - 0x0e, 0xdf, 0x63, 0x78, 0x3c, 0x7c, 0x8f, 0xc1, 0xd0, 0xee, 0xf4, 0x61, 0x1a, 0x5d, 0x37, 0x99, - 0x88, 0x94, 0xf5, 0x98, 0xdd, 0x19, 0x27, 0x40, 0xbb, 0x33, 0x0e, 0x8c, 0x34, 0xc9, 0x5f, 0x6e, - 0x37, 0x32, 0x9a, 0x14, 0xae, 0xb2, 0x89, 0x32, 0x6c, 0xfd, 0x0e, 0x07, 0x47, 0x65, 0xcb, 0xd2, - 0x5b, 0x76, 0x65, 0xd2, 0x97, 0xba, 0x19, 0x5d, 0xbf, 0x33, 0x09, 0xd9, 0xfa, 0x9d, 0x89, 0x64, - 0xb3, 0xab, 0xbf, 0xd1, 0xda, 0xd0, 0x1d, 0x6a, 0x54, 0x4c, 0x07, 0x4f, 0x16, 0xb7, 0xf8, 0xd6, - 0xf0, 0x83, 0xe8, 0xec, 0xda, 0x85, 0x94, 0xcd, 0xae, 0x5d, 0xd0, 0xcc, 0xc8, 0x4b, 0x47, 0x6b, - 0x54, 0x37, 0x94, 0x47, 0x51, 0x23, 0x2f, 0x9b, 0x92, 0x19, 0x79, 0xd9, 0xd8, 0xec, 0xcf, 0x79, - 0xe8, 0x98, 0x1e, 0x55, 0x9a, 0x7b, 0xf9, 0x1c, 0x24, 0xcd, 0xfe, 0x1c, 0x44, 0xb3, 0x0d, 0x61, - 0xbc, 0x43, 0x5a, 0xd1, 0x0d, 0x61, 0xb2, 0x1b, 0xe2, 0x25, 0x98, 0xc5, 0x22, 0x1e, 0xe5, 0x29, - 0x56, 0xd4, 0x62, 0x11, 0x60, 0x66, 0xb1, 0x84, 0xcf, 0xf6, 0x22, 0x4f, 0xb1, 0x14, 0x3b, 0xba, - 0x86, 0xca, 0x38, 0xb6, 0x86, 0x46, 0x9e, 0x6d, 0xbd, 0x1e, 0x79, 0x67, 0xa0, 0xb4, 0xa3, 0x56, - 0x87, 0x84, 0x62, 0x56, 0x87, 0xfc, 0x22, 0x61, 0x0a, 0x46, 0xf1, 0x16, 0x5c, 0xeb, 0x04, 0xf7, - 0x38, 0x3f, 0x1c, 0xfd, 0xcc, 0x18, 0x9a, 0x7d, 0x66, 0x0c, 0x14, 0x61, 0x22, 0xa6, 0x2d, 0x27, - 0x83, 0x49, 0x78, 0x3e, 0x18, 0x03, 0x91, 0x39, 0x20, 0xb5, 0xf2, 0xfc, 0x5c, 0xd5, 0x58, 0x92, - 0xaf, 0xc8, 0xdc, 0xe8, 0x09, 0x6c, 0x92, 0x62, 0xb6, 0x47, 0x4b, 0x29, 0x47, 0x3e, 0x80, 0x2b, - 0x02, 0x2a, 0x5e, 0x5c, 0x63, 0xda, 0x7f, 0x23, 0x58, 0x10, 0xbc, 0xa8, 0x1f, 0x5b, 0x37, 0xda, - 0xd9, 0x1e, 0xad, 0x2b, 0xaf, 0xec, 0xba, 0xc4, 0xfa, 0xd0, 0xd9, 0x4b, 0x5d, 0xc1, 0x22, 0xd1, - 0x95, 0x57, 0x76, 0x5d, 0x42, 0xee, 0x8f, 0xf7, 0x52, 0x57, 0xd0, 0x09, 0x5d, 0x79, 0x11, 0x17, - 0x26, 0xba, 0xe1, 0xcb, 0xcd, 0xa6, 0xb2, 0x89, 0xd5, 0x7d, 0x66, 0x2f, 0xd5, 0x95, 0xd1, 0xe0, - 0xdc, 0x8d, 0x23, 0x9b, 0xa5, 0x17, 0xdb, 0xd4, 0xaa, 0x45, 0x16, 0xa0, 0x27, 0xd1, 0x59, 0x3a, - 0x41, 0xc0, 0x66, 0xe9, 0x04, 0x90, 0x0d, 0x28, 0xf9, 0xb9, 0x8a, 0xb2, 0x15, 0x1d, 0x50, 0x32, - 0x8e, 0x0d, 0xa8, 0xc8, 0xd3, 0x96, 0x45, 0x38, 0xb7, 0xf8, 0xc8, 0xd3, 0x7d, 0x0b, 0xd2, 0x15, - 0x5d, 0xf9, 0x61, 0xec, 0x92, 0x29, 0x49, 0x82, 0x97, 0x4c, 0x49, 0x30, 0x1b, 0x23, 0x0c, 0x5c, - 0xdb, 0xb2, 0x1a, 0x33, 0xba, 0xd9, 0xec, 0x38, 0x54, 0xf9, 0xd7, 0xa2, 0x63, 0x24, 0x86, 0x66, - 0x63, 0x24, 0x06, 0x62, 0x0b, 0x34, 0x03, 0x95, 0x5d, 0xd7, 0x5c, 0xb7, 0xc4, 0xbe, 0xb2, 0xd3, - 0xf4, 0x94, 0x7f, 0x3d, 0xba, 0x40, 0xa7, 0xd1, 0xb0, 0x05, 0x3a, 0x0d, 0x8e, 0xa7, 0x4e, 0xac, - 0x17, 0xd8, 0xe2, 0x21, 0xdf, 0x55, 0xfe, 0x1b, 0xb1, 0x53, 0xa7, 0x14, 0x1a, 0x3c, 0x75, 0x4a, - 0x81, 0xb3, 0xf5, 0x91, 0xdb, 0x64, 0x73, 0x66, 0x70, 0x57, 0xfd, 0x6f, 0x46, 0xd7, 0xc7, 0x38, - 0x9e, 0xad, 0x8f, 0x71, 0x58, 0x94, 0x8f, 0xe8, 0x82, 0x7f, 0x2b, 0x8b, 0x4f, 0x20, 0xff, 0x44, - 0x19, 0x72, 0x57, 0xe6, 0x23, 0x46, 0xca, 0x8f, 0xe4, 0xb2, 0x18, 0x05, 0xc3, 0x23, 0x51, 0x28, - 0xca, 0x48, 0xa3, 0x8f, 0x4d, 0xba, 0xa9, 0x7c, 0x2d, 0x93, 0x11, 0x27, 0x88, 0x32, 0xe2, 0x30, - 0xf2, 0x3e, 0x5c, 0x0c, 0x61, 0xf3, 0xb4, 0xb5, 0x1a, 0xcc, 0x4c, 0x7f, 0x22, 0x17, 0x35, 0x83, - 0xd3, 0xc9, 0x98, 0x19, 0x9c, 0x8e, 0x49, 0x63, 0x2d, 0x44, 0xf7, 0x6f, 0xef, 0xc2, 0x3a, 0x90, - 0x60, 0x06, 0x83, 0x34, 0xd6, 0x42, 0x9a, 0x3f, 0xba, 0x0b, 0xeb, 0x40, 0xa6, 0x19, 0x0c, 0xc8, - 0x4f, 0xe4, 0xe0, 0x5a, 0x3a, 0xaa, 0xdc, 0x6c, 0xce, 0xd8, 0x4e, 0x88, 0x53, 0xfe, 0x64, 0x2e, - 0x7a, 0xd0, 0xb0, 0xb7, 0x62, 0xb3, 0x3d, 0xda, 0x1e, 0x2b, 0x20, 0x5f, 0x80, 0xe1, 0x72, 0xc7, - 0x30, 0x3d, 0xbc, 0x78, 0x63, 0x86, 0xf3, 0x8f, 0xe5, 0x62, 0x5b, 0x1c, 0x19, 0x8b, 0x5b, 0x1c, - 0x19, 0x40, 0xee, 0xc1, 0x78, 0x8d, 0x36, 0x3a, 0x8e, 0xe9, 0x6d, 0x69, 0xb4, 0x6d, 0x3b, 0x1e, - 0xe3, 0xf1, 0xa7, 0x72, 0xd1, 0x49, 0x2c, 0x41, 0xc1, 0x26, 0xb1, 0x04, 0x90, 0x3c, 0x48, 0xdc, - 0xca, 0x8b, 0xce, 0xfc, 0xf1, 0x5c, 0xd7, 0x6b, 0xf9, 0xa0, 0x2f, 0xd3, 0x8b, 0x93, 0xa5, 0xd8, - 0x2d, 0xba, 0xe0, 0xfa, 0x13, 0xb9, 0x2e, 0xd7, 0xe8, 0xd2, 0x0c, 0x97, 0x04, 0x33, 0x8e, 0x29, - 0x19, 0xe0, 0x95, 0x3f, 0x9d, 0xeb, 0x72, 0xed, 0x1d, 0x72, 0x4c, 0x4b, 0x1e, 0xff, 0x2a, 0xf7, - 0x14, 0x11, 0x8c, 0x7e, 0x32, 0x97, 0x74, 0x15, 0x09, 0xca, 0x4b, 0x84, 0xac, 0xd8, 0x8a, 0x1b, - 0x28, 0xfd, 0xd7, 0x73, 0x49, 0xdf, 0xbc, 0xb0, 0x58, 0xf8, 0x8b, 0x50, 0xb8, 0x3c, 0xfd, 0xc4, - 0xa3, 0x8e, 0xa5, 0x37, 0xb1, 0x3b, 0x6b, 0x9e, 0xed, 0xe8, 0xeb, 0x74, 0xda, 0xd2, 0x57, 0x9b, - 0x54, 0xf9, 0x46, 0x2e, 0x6a, 0xc1, 0x66, 0x93, 0x32, 0x0b, 0x36, 0x1b, 0x4b, 0x36, 0xe0, 0xe9, - 0x34, 0x6c, 0xc5, 0x74, 0xb1, 0x9e, 0x6f, 0xe6, 0xa2, 0x26, 0x6c, 0x17, 0x5a, 0x66, 0xc2, 0x76, - 0x41, 0x93, 0xdb, 0x30, 0x30, 0x69, 0xfb, 0xd3, 0xef, 0x9f, 0x89, 0x39, 0x43, 0x06, 0x98, 0xd9, - 0x1e, 0x2d, 0x24, 0x13, 0x65, 0xc4, 0xa0, 0xfe, 0x56, 0xb2, 0x4c, 0x78, 0xf9, 0x14, 0xfc, 0x10, - 0x65, 0x84, 0xb8, 0xff, 0x9d, 0x64, 0x99, 0xf0, 0x8e, 0x2b, 0xf8, 0xc1, 0x66, 0x12, 0x5e, 0xe3, - 0xfc, 0x4c, 0x99, 0xd9, 0x6d, 0x53, 0x1b, 0x7a, 0xb3, 0x49, 0xad, 0x75, 0xaa, 0x7c, 0x3b, 0x36, - 0x93, 0xa4, 0x93, 0xb1, 0x99, 0x24, 0x1d, 0x43, 0x7e, 0x10, 0x2e, 0x3d, 0xd0, 0x9b, 0xa6, 0x11, - 0xe2, 0xfc, 0x7c, 0xe0, 0xca, 0x4f, 0xe5, 0xa2, 0xbb, 0xe9, 0x0c, 0x3a, 0xb6, 0x9b, 0xce, 0x40, - 0x91, 0x79, 0x20, 0xb8, 0x8c, 0x06, 0xb3, 0x05, 0x5b, 0x9f, 0x95, 0x7f, 0x37, 0x17, 0xb5, 0x53, - 0x93, 0x24, 0xcc, 0x4e, 0x4d, 0x42, 0x49, 0x3d, 0x3b, 0x35, 0x88, 0xf2, 0xd3, 0xb9, 0xe8, 0x69, - 0x4d, 0x16, 0xe1, 0x6c, 0x8f, 0x96, 0x9d, 0x5f, 0xe4, 0x2e, 0x8c, 0xd5, 0x96, 0xaa, 0x33, 0x33, - 0xd3, 0xb5, 0x07, 0xd5, 0x0a, 0x3e, 0x74, 0x30, 0x94, 0x9f, 0x89, 0xad, 0x58, 0x71, 0x02, 0xb6, - 0x62, 0xc5, 0x61, 0xe4, 0x2d, 0x18, 0x62, 0xed, 0x67, 0x03, 0x06, 0x3f, 0xf9, 0x67, 0x73, 0x51, - 0x73, 0x4a, 0x46, 0x32, 0x73, 0x4a, 0xfe, 0x4d, 0x6a, 0x70, 0x9e, 0x49, 0x71, 0xc9, 0xa1, 0x6b, - 0xd4, 0xa1, 0x56, 0xc3, 0x1f, 0xd3, 0x3f, 0x97, 0x8b, 0x5a, 0x19, 0x69, 0x44, 0xcc, 0xca, 0x48, - 0x83, 0x93, 0x47, 0x70, 0x25, 0x7e, 0x12, 0x24, 0x3f, 0x3b, 0x55, 0xfe, 0x6c, 0x2e, 0x66, 0x0c, - 0x77, 0x21, 0x46, 0x63, 0xb8, 0x0b, 0x9e, 0x58, 0xf0, 0x8c, 0x38, 0x56, 0x11, 0x0e, 0x97, 0xf1, - 0xda, 0xfe, 0x1c, 0xaf, 0xed, 0xd3, 0xa1, 0x43, 0x60, 0x17, 0xea, 0xd9, 0x1e, 0xad, 0x3b, 0x3b, - 0xa6, 0x67, 0xc9, 0x04, 0x18, 0xca, 0xcf, 0xe7, 0xd2, 0x3d, 0x52, 0x22, 0x6e, 0xca, 0x69, 0x99, - 0x33, 0xde, 0xcf, 0x4a, 0xdf, 0xa0, 0xfc, 0xf9, 0xd8, 0x78, 0x4b, 0x27, 0x63, 0xe3, 0x2d, 0x23, - 0xff, 0xc3, 0x3d, 0x18, 0xe7, 0x4a, 0xbd, 0xa4, 0xe3, 0x30, 0xb4, 0xd6, 0xa9, 0xa1, 0xfc, 0x7b, - 0xb1, 0xd5, 0x2e, 0x41, 0x81, 0xae, 0x3d, 0x71, 0x20, 0x9b, 0xba, 0x6b, 0x6d, 0xdd, 0xb2, 0xf0, - 0x98, 0x55, 0xf9, 0xf7, 0x63, 0x53, 0x77, 0x88, 0x42, 0xc7, 0xdd, 0xe0, 0x17, 0xd3, 0x84, 0x6e, - 0xa9, 0x8f, 0x94, 0xbf, 0x10, 0xd3, 0x84, 0x6e, 0xc4, 0x4c, 0x13, 0xba, 0xe6, 0x51, 0x7a, 0x90, - 0xf1, 0x04, 0x5c, 0xf9, 0x85, 0xd8, 0x8a, 0x9c, 0x4a, 0xc5, 0x56, 0xe4, 0xf4, 0x17, 0xe4, 0x0f, - 0x32, 0x9e, 0x4f, 0x2b, 0xbf, 0xd8, 0x9d, 0x6f, 0xb8, 0xd2, 0xa7, 0xbf, 0xbe, 0x7e, 0x90, 0xf1, - 0xf4, 0x58, 0xf9, 0x8b, 0xdd, 0xf9, 0x86, 0x8e, 0x7d, 0xe9, 0x2f, 0x97, 0xeb, 0xd9, 0xcf, 0x76, - 0x95, 0xbf, 0x14, 0x9f, 0xba, 0x32, 0x08, 0x71, 0xea, 0xca, 0x7a, 0xfb, 0xbb, 0x0a, 0x4f, 0x71, - 0x0d, 0xb9, 0xeb, 0xe8, 0xed, 0x8d, 0x1a, 0xf5, 0x3c, 0xd3, 0x5a, 0xf7, 0x77, 0x62, 0x7f, 0x39, + 0xe9, 0xc5, 0xc9, 0x5b, 0x30, 0xe2, 0x23, 0xf8, 0x2d, 0xe2, 0x10, 0xde, 0x22, 0xe2, 0x90, 0x34, + 0x96, 0x1b, 0xf1, 0xd7, 0x94, 0x51, 0x62, 0x59, 0xa3, 0x30, 0xa3, 0xfe, 0x70, 0x44, 0xa3, 0xbc, + 0xcd, 0x4e, 0xaa, 0x32, 0x62, 0x96, 0xfd, 0x77, 0x42, 0x8d, 0x5a, 0x70, 0xcc, 0x55, 0x93, 0xef, + 0xa4, 0xfd, 0x07, 0x94, 0xcb, 0x0d, 0x1b, 0x81, 0x69, 0xfa, 0xc1, 0xc9, 0x2f, 0x57, 0xe0, 0x5c, + 0x8a, 0x8e, 0xed, 0x69, 0xc7, 0xf8, 0x61, 0x3e, 0x6c, 0xc4, 0x31, 0xdf, 0x36, 0x4e, 0x40, 0xd9, + 0xff, 0x12, 0x61, 0x3c, 0x28, 0x59, 0x43, 0x33, 0xce, 0xc3, 0xc7, 0x47, 0xc4, 0x71, 0xcc, 0xb7, + 0x92, 0x87, 0x21, 0x8e, 0xef, 0xe6, 0x42, 0x71, 0x1c, 0xf3, 0xed, 0xe5, 0x4f, 0x17, 0xc3, 0x39, + 0xe9, 0x74, 0x8f, 0x79, 0x58, 0x66, 0x72, 0xe8, 0x07, 0x5b, 0xda, 0xc3, 0x43, 0x46, 0x59, 0x35, + 0x07, 0xf6, 0xa7, 0x9a, 0xe4, 0x2d, 0x18, 0x5a, 0xb4, 0x5d, 0x6f, 0xd5, 0xa1, 0xee, 0x62, 0x10, + 0x43, 0x1f, 0x1f, 0xc1, 0x76, 0x04, 0xb8, 0xd1, 0x89, 0xcc, 0xfe, 0x32, 0xb9, 0xfa, 0x8f, 0x0b, + 0x09, 0x6d, 0xe0, 0x86, 0xeb, 0xb1, 0xd4, 0x86, 0x43, 0x18, 0xea, 0xe4, 0x56, 0xb8, 0x0a, 0x72, + 0x0b, 0xbf, 0x5f, 0x0a, 0x10, 0xb8, 0x2c, 0x0c, 0xfc, 0x28, 0x09, 0xf9, 0x21, 0xb8, 0x14, 0x01, + 0x2c, 0xea, 0x8e, 0xde, 0xa6, 0x5e, 0x98, 0xaf, 0x10, 0x43, 0x3e, 0xf9, 0xa5, 0x1b, 0x9d, 0x00, + 0x2d, 0xe7, 0x40, 0xcc, 0xe0, 0x20, 0xa9, 0xd6, 0xc0, 0x1e, 0x5c, 0xac, 0x7f, 0xae, 0x10, 0x1a, + 0x3a, 0xd1, 0xd0, 0xad, 0x1a, 0x75, 0xbb, 0x2d, 0xef, 0xe4, 0x76, 0xf0, 0xfe, 0x12, 0x63, 0xcc, + 0xc0, 0x99, 0xca, 0xca, 0x0a, 0x6d, 0x7a, 0x7e, 0x44, 0x6a, 0x57, 0x04, 0xeb, 0xe3, 0x1b, 0x0f, + 0x81, 0x12, 0x11, 0x86, 0x23, 0x99, 0xf5, 0x63, 0xc5, 0xd4, 0x7f, 0x52, 0x04, 0x25, 0x30, 0xfc, + 0x83, 0x67, 0x5e, 0x47, 0xb8, 0xc8, 0x7e, 0x2c, 0x7a, 0xc5, 0x84, 0xb3, 0xa1, 0x30, 0xea, 0xdd, + 0x76, 0x5b, 0xc7, 0xa1, 0xc7, 0x36, 0x16, 0xe3, 0x71, 0x66, 0x21, 0x21, 0xdf, 0x4b, 0x5c, 0x16, + 0x7b, 0x09, 0x12, 0x3e, 0xa3, 0x6b, 0xb8, 0x9c, 0x85, 0x96, 0xe4, 0x4a, 0xbe, 0x91, 0x83, 0xf3, + 0x7e, 0xa7, 0x2c, 0x2c, 0x33, 0xa3, 0x7a, 0xd2, 0xee, 0x5a, 0x9e, 0xbf, 0x8f, 0x79, 0x23, 0xbb, + 0x3a, 0xde, 0x49, 0x37, 0xd2, 0x0a, 0xf3, 0x96, 0x04, 0x61, 0x29, 0x02, 0x85, 0xb0, 0x91, 0xa6, + 0xd1, 0x44, 0x22, 0x2d, 0xb5, 0xde, 0xcb, 0x77, 0xe0, 0x89, 0x4c, 0x96, 0x3b, 0x19, 0xb1, 0xfd, + 0xb2, 0x11, 0xfb, 0xdf, 0xe5, 0xc2, 0x89, 0x28, 0x26, 0x24, 0x72, 0x03, 0x20, 0x04, 0x89, 0x6d, + 0xed, 0xe8, 0xf6, 0xd6, 0x38, 0x84, 0x42, 0xd3, 0x24, 0x0a, 0xb2, 0x00, 0x25, 0x21, 0x16, 0x9e, + 0x1b, 0xf8, 0xb3, 0x3b, 0xf4, 0xc2, 0x0d, 0x59, 0x0e, 0xb8, 0x65, 0x15, 0xdf, 0x2c, 0xd8, 0x5c, + 0x7e, 0x1d, 0x86, 0xf6, 0xfb, 0x5d, 0xdf, 0x28, 0x00, 0x91, 0xf7, 0xa0, 0x47, 0x68, 0xa0, 0x1f, + 0xe3, 0x29, 0xec, 0x1a, 0x94, 0xd9, 0x27, 0x60, 0xb6, 0x0c, 0x29, 0x3a, 0x6e, 0x57, 0xc0, 0xb4, + 0x00, 0x1b, 0x86, 0xa6, 0x1a, 0x48, 0x0f, 0x4d, 0xa5, 0xfe, 0x6c, 0x01, 0x2e, 0xca, 0x1d, 0x52, + 0xa5, 0x18, 0x70, 0xff, 0xb4, 0x53, 0x3e, 0xc2, 0x4e, 0x51, 0xa1, 0xc4, 0xb7, 0x1e, 0x22, 0xf3, + 0x01, 0x3f, 0x16, 0x42, 0x88, 0x26, 0x30, 0xea, 0xff, 0x9c, 0x87, 0x91, 0xc0, 0xbc, 0xd3, 0x1d, + 0xf7, 0x04, 0x77, 0xc7, 0xe7, 0x61, 0x04, 0x83, 0x0b, 0xb5, 0xa9, 0xc5, 0x03, 0xf0, 0xf4, 0x4b, + 0xa9, 0x4a, 0x7c, 0x84, 0xc8, 0x4a, 0x15, 0x21, 0x64, 0xda, 0xcf, 0x2d, 0x3f, 0x29, 0xe4, 0x13, + 0x37, 0xfb, 0x38, 0x5c, 0xfd, 0x0b, 0x05, 0x18, 0xf6, 0xa5, 0x3c, 0x61, 0x1e, 0xd7, 0x7b, 0x9e, + 0xa3, 0x15, 0xf2, 0x4d, 0x80, 0x45, 0xdb, 0xf1, 0xf4, 0xd6, 0x7c, 0xa8, 0xf9, 0x78, 0x40, 0xda, + 0x41, 0x28, 0x2f, 0x23, 0x91, 0xe0, 0xfa, 0x15, 0x9a, 0xd5, 0x7c, 0x62, 0xe2, 0xeb, 0x57, 0x00, + 0xd5, 0x24, 0x0a, 0xf5, 0x6f, 0xe5, 0xe1, 0x8c, 0xdf, 0x49, 0x53, 0x8f, 0x69, 0xb3, 0x7b, 0x92, + 0xe7, 0xa6, 0xa8, 0xb4, 0xfb, 0x77, 0x94, 0xb6, 0xfa, 0x7f, 0x4a, 0x13, 0xc9, 0x64, 0xcb, 0x3e, + 0x9d, 0x48, 0xfe, 0x28, 0x74, 0x5c, 0xfd, 0xf1, 0x02, 0x9c, 0xf7, 0xa5, 0x3e, 0xdd, 0xb5, 0xf0, + 0x68, 0x61, 0x52, 0x6f, 0xb5, 0x4e, 0xf2, 0x6e, 0x7c, 0xc8, 0x17, 0xc4, 0x82, 0x88, 0xd6, 0x27, + 0x32, 0x04, 0xae, 0x08, 0x70, 0xc3, 0x36, 0x0d, 0x4d, 0x26, 0x22, 0xef, 0xc0, 0xb0, 0xff, 0xb3, + 0xe2, 0xac, 0xfa, 0x5b, 0x70, 0xbc, 0x28, 0x08, 0x0a, 0xe9, 0x4e, 0x24, 0x28, 0x41, 0xa4, 0x80, + 0xfa, 0xb5, 0x01, 0xb8, 0xfc, 0xd0, 0xb4, 0x0c, 0x7b, 0xc3, 0xf5, 0x13, 0x4c, 0x1e, 0xfb, 0x83, + 0xb2, 0xa3, 0x4e, 0x2c, 0xf9, 0x2e, 0x5c, 0x88, 0x8b, 0xd4, 0x09, 0xc2, 0x7e, 0x8b, 0xde, 0xd9, + 0xe0, 0x04, 0x0d, 0x3f, 0xd5, 0xa4, 0xb8, 0x6d, 0xd3, 0xd2, 0x4b, 0xc6, 0x73, 0x55, 0x0e, 0xec, + 0x26, 0x57, 0xe5, 0xf3, 0x50, 0xaa, 0xda, 0x6d, 0xdd, 0xf4, 0xc3, 0xd3, 0xe0, 0x28, 0x0e, 0xea, + 0x45, 0x8c, 0x26, 0x28, 0x18, 0x7f, 0x51, 0x31, 0x76, 0xd9, 0x60, 0xc8, 0xdf, 0x2f, 0xc0, 0xac, + 0x34, 0x4d, 0x26, 0x22, 0x36, 0x8c, 0x88, 0xea, 0xc4, 0xdd, 0x18, 0xe0, 0xe6, 0xe9, 0x15, 0x5f, + 0x46, 0xd9, 0x6a, 0x75, 0x23, 0x52, 0x8e, 0x6f, 0xa3, 0x78, 0x0a, 0x4d, 0xf1, 0x31, 0xfc, 0x96, + 0x4c, 0x8b, 0xf2, 0x97, 0x84, 0x80, 0x93, 0xcc, 0x50, 0x52, 0x08, 0x38, 0xcb, 0xc8, 0x44, 0x64, + 0x0a, 0xce, 0x62, 0x70, 0xe6, 0x60, 0x2b, 0xc5, 0x54, 0x62, 0x18, 0x8d, 0x4a, 0xbc, 0x72, 0xe1, + 0xf1, 0x9c, 0xd9, 0xc7, 0x35, 0x9a, 0x02, 0xad, 0x25, 0x4b, 0x90, 0x27, 0xa0, 0x30, 0x3f, 0x5b, + 0xc1, 0xbb, 0x9a, 0x32, 0x4f, 0x8c, 0x64, 0xb5, 0x74, 0x8d, 0xc1, 0x2e, 0x7f, 0x11, 0x48, 0xf2, + 0x73, 0xf6, 0x74, 0x1f, 0xf3, 0x5f, 0x4a, 0x5b, 0xbe, 0xe3, 0xee, 0x51, 0x73, 0x18, 0x13, 0x61, + 0x24, 0x27, 0x59, 0xff, 0x47, 0x99, 0x93, 0xac, 0x74, 0xa8, 0x39, 0xc9, 0xd4, 0x5f, 0xcb, 0xc1, + 0xd9, 0x44, 0x00, 0x73, 0xf2, 0x32, 0x00, 0x87, 0x48, 0x81, 0x22, 0x31, 0xf2, 0x4a, 0x18, 0xd4, + 0x5c, 0x2c, 0x8f, 0x21, 0x19, 0xb9, 0x09, 0x65, 0xfe, 0x4b, 0x04, 0x77, 0x4a, 0x16, 0xe9, 0x76, + 0x4d, 0x43, 0x0b, 0x88, 0xc2, 0x5a, 0xf0, 0x46, 0xb2, 0x90, 0x5a, 0xc4, 0xdb, 0xec, 0x04, 0xb5, + 0x30, 0x32, 0xf5, 0xeb, 0x79, 0x18, 0x0e, 0x1a, 0x5c, 0x31, 0x8e, 0x4a, 0xe7, 0x4a, 0x22, 0x16, + 0x7c, 0x61, 0xa7, 0x58, 0xf0, 0xb1, 0xf9, 0x56, 0x04, 0x7f, 0x3f, 0xbc, 0x07, 0x55, 0xdf, 0xcc, + 0xc3, 0x99, 0xa0, 0xd6, 0x23, 0xbc, 0xfc, 0xfa, 0x18, 0x89, 0xe4, 0x1b, 0x39, 0x50, 0x26, 0xcc, + 0x56, 0xcb, 0xb4, 0x56, 0x6b, 0xd6, 0x8a, 0xed, 0xb4, 0x71, 0x42, 0x3c, 0xba, 0x23, 0x5c, 0xf5, + 0x4f, 0xe4, 0xe0, 0xac, 0x68, 0xd0, 0xa4, 0xee, 0x18, 0x47, 0x77, 0x3e, 0x16, 0x6f, 0xc9, 0xd1, + 0xe9, 0x8b, 0xfa, 0xbb, 0x79, 0x80, 0x59, 0xbb, 0xb9, 0x7e, 0xcc, 0xdf, 0x63, 0xbd, 0x09, 0x25, + 0x1e, 0x61, 0x4b, 0x68, 0xec, 0x59, 0xf1, 0xee, 0x88, 0x7d, 0x1a, 0x47, 0x4c, 0x8c, 0x89, 0xf9, + 0xb8, 0xc4, 0x23, 0x74, 0x29, 0x39, 0x4d, 0x14, 0x61, 0x95, 0x32, 0x3a, 0xb1, 0x60, 0x04, 0x95, + 0x32, 0x58, 0xb4, 0xd2, 0xed, 0xad, 0xf1, 0x62, 0xcb, 0x6e, 0xae, 0x6b, 0x48, 0xaf, 0xfe, 0xab, + 0x1c, 0x97, 0xdd, 0x31, 0x7f, 0x55, 0xea, 0x7f, 0x7e, 0x71, 0x8f, 0x9f, 0xff, 0x27, 0x73, 0x70, + 0x5e, 0xa3, 0x4d, 0xfb, 0x11, 0x75, 0x36, 0x27, 0x6d, 0x83, 0xde, 0xa1, 0x16, 0x75, 0x8e, 0x6a, + 0x44, 0xfd, 0x6d, 0x4c, 0x9e, 0x11, 0x36, 0xe6, 0xbe, 0x4b, 0x8d, 0xe3, 0x93, 0xd8, 0x44, 0xfd, + 0xcd, 0x01, 0x50, 0x52, 0xad, 0xde, 0x63, 0x6b, 0xce, 0x65, 0x6e, 0x65, 0x8a, 0x87, 0xb5, 0x95, + 0xe9, 0xdf, 0xdb, 0x56, 0xa6, 0xb4, 0xd7, 0xad, 0xcc, 0xc0, 0x6e, 0xb6, 0x32, 0xed, 0xf8, 0x56, + 0xa6, 0x8c, 0x5b, 0x99, 0x97, 0x7b, 0x6e, 0x65, 0xa6, 0x2c, 0x63, 0x9f, 0x1b, 0x99, 0x63, 0x9b, + 0x74, 0x77, 0x3f, 0x3b, 0xb0, 0x6b, 0x6c, 0x52, 0x6c, 0xda, 0x8e, 0x41, 0x0d, 0xb1, 0xf1, 0xc2, + 0x53, 0x7f, 0x47, 0xc0, 0xb4, 0x00, 0x9b, 0xc8, 0x60, 0x3c, 0xb2, 0x9b, 0x0c, 0xc6, 0x87, 0xb0, + 0xff, 0xfa, 0x30, 0x0f, 0x67, 0x27, 0xa9, 0xe3, 0xf1, 0x10, 0x9e, 0x87, 0xe1, 0x12, 0x57, 0x81, + 0x33, 0x12, 0x43, 0xb4, 0xc8, 0xf3, 0xa1, 0x9b, 0x5f, 0x93, 0x3a, 0x5e, 0xdc, 0x4b, 0x30, 0x4e, + 0xcf, 0xaa, 0xf7, 0xb3, 0x88, 0x89, 0xb1, 0x1b, 0x54, 0xef, 0xc3, 0xb9, 0x20, 0x4d, 0xf1, 0x4b, + 0x0b, 0xe8, 0xa5, 0xc4, 0x60, 0xc5, 0xbd, 0x27, 0x06, 0x53, 0x7f, 0x35, 0x07, 0x57, 0x35, 0x6a, + 0xd1, 0x0d, 0x7d, 0xb9, 0x45, 0xa5, 0x66, 0x89, 0x95, 0x81, 0xcd, 0x1a, 0xa6, 0xdb, 0xd6, 0xbd, + 0xe6, 0xda, 0x81, 0x64, 0x34, 0x0d, 0xc3, 0xf2, 0xfc, 0xb5, 0x87, 0xb9, 0x2d, 0x52, 0x4e, 0xfd, + 0xcd, 0x22, 0x0c, 0x4c, 0xd8, 0xde, 0x5d, 0xfb, 0x80, 0x99, 0xea, 0xc2, 0x29, 0x3f, 0xbf, 0x87, + 0xb3, 0x9e, 0xcf, 0x61, 0xe5, 0x52, 0xf0, 0x7e, 0x74, 0x21, 0x5d, 0xb6, 0x13, 0x49, 0x0e, 0x7c, + 0xb2, 0x3d, 0xe6, 0xa8, 0x7b, 0x15, 0x06, 0x31, 0xfa, 0x8b, 0x74, 0x1a, 0x8b, 0x0e, 0xda, 0x1e, + 0x03, 0xc6, 0xeb, 0x08, 0x49, 0xc9, 0x0f, 0x45, 0x62, 0x8e, 0x96, 0x0e, 0x9e, 0xd3, 0x4e, 0x0e, + 0x3f, 0xfa, 0x32, 0xbf, 0xc8, 0xc3, 0x36, 0x49, 0xf9, 0x3f, 0xf0, 0x14, 0x25, 0xd6, 0xa4, 0x80, + 0xf0, 0x10, 0xf3, 0xcd, 0x4d, 0xc2, 0xc8, 0x84, 0xed, 0x49, 0xce, 0xc0, 0x83, 0xe1, 0x33, 0x50, + 0x26, 0xf9, 0x74, 0x4f, 0xe0, 0x68, 0x19, 0xf5, 0xfb, 0x45, 0x18, 0xf6, 0x7f, 0x1e, 0x91, 0xee, + 0xbc, 0x08, 0xa5, 0x19, 0x5b, 0x4a, 0x81, 0x80, 0x0e, 0xc4, 0x6b, 0xb6, 0x1b, 0xf3, 0x8c, 0x16, + 0x44, 0x4c, 0xea, 0xf3, 0xb6, 0x21, 0xbb, 0xbf, 0xa3, 0xd4, 0x2d, 0xdb, 0x48, 0x3c, 0x1f, 0x0e, + 0x08, 0xc9, 0x55, 0x28, 0xe2, 0xcb, 0x01, 0xe9, 0x20, 0x3f, 0xf6, 0x5a, 0x00, 0xf1, 0x92, 0x56, + 0x96, 0xf6, 0xaa, 0x95, 0x03, 0xfb, 0xd5, 0xca, 0xf2, 0xe1, 0x6a, 0xe5, 0x7b, 0x30, 0x8c, 0x35, + 0xf9, 0x19, 0xd4, 0x76, 0x5e, 0x58, 0x9f, 0x10, 0x6b, 0xdf, 0x08, 0x6f, 0xb7, 0xc8, 0xa3, 0x86, + 0x4b, 0x5e, 0x84, 0x55, 0x4c, 0x77, 0xe1, 0x00, 0xdb, 0xe9, 0x7f, 0x9c, 0x83, 0x81, 0xfb, 0xd6, + 0xba, 0x65, 0x6f, 0x1c, 0x4c, 0xe3, 0x5e, 0x86, 0x21, 0xc1, 0x46, 0x5a, 0x5d, 0xf0, 0x45, 0x78, + 0x97, 0x83, 0x1b, 0xc8, 0x49, 0x93, 0xa9, 0xc8, 0x5b, 0x41, 0x21, 0x7c, 0x1c, 0x54, 0x08, 0x93, + 0x88, 0xf8, 0x85, 0x9a, 0xd1, 0xbc, 0x07, 0x32, 0x39, 0xb9, 0x02, 0xc5, 0x2a, 0x6b, 0xaa, 0x14, + 0x45, 0x97, 0x35, 0x45, 0x43, 0xa8, 0xfa, 0x61, 0x11, 0x46, 0x63, 0x07, 0x5f, 0xcf, 0xc3, 0xa0, + 0x38, 0x78, 0x32, 0xfd, 0x44, 0x0c, 0xf8, 0x78, 0x28, 0x00, 0x6a, 0x65, 0xfe, 0x67, 0xcd, 0x20, + 0x5f, 0x80, 0x01, 0xdb, 0xc5, 0x45, 0x11, 0xbf, 0x65, 0x34, 0x1c, 0x42, 0x0b, 0x75, 0xd6, 0x76, + 0x3e, 0x38, 0x04, 0x89, 0xac, 0x91, 0xb6, 0x8b, 0x9f, 0x76, 0x1b, 0x06, 0x75, 0xd7, 0xa5, 0x5e, + 0xc3, 0xd3, 0x57, 0xe5, 0xdc, 0x0c, 0x01, 0x50, 0x1e, 0x1d, 0x08, 0x5c, 0xd2, 0x57, 0xc9, 0x17, + 0x61, 0xa4, 0xe9, 0x50, 0x5c, 0x36, 0xf5, 0x16, 0x6b, 0xa5, 0x64, 0xd6, 0x46, 0x10, 0xf2, 0xfd, + 0x49, 0x88, 0xa8, 0x19, 0xe4, 0x01, 0x8c, 0x88, 0xcf, 0xe1, 0x9e, 0xfb, 0x38, 0xd0, 0x46, 0xc3, + 0x65, 0x8c, 0x8b, 0x84, 0xfb, 0xee, 0x8b, 0x07, 0x1c, 0x32, 0xb9, 0xcc, 0xd7, 0x90, 0x48, 0xc9, + 0x02, 0x90, 0x0d, 0xba, 0xdc, 0xd0, 0xbb, 0xde, 0x1a, 0xab, 0x8b, 0x87, 0x16, 0x17, 0x29, 0x09, + 0xf1, 0xd5, 0x43, 0x12, 0x2b, 0x3f, 0x06, 0xd9, 0xa0, 0xcb, 0x95, 0x08, 0x92, 0x3c, 0x84, 0x0b, + 0xc9, 0x22, 0xec, 0x93, 0xf9, 0xe5, 0xc0, 0x73, 0xdb, 0x5b, 0xe3, 0xe3, 0xa9, 0x04, 0x12, 0xdb, + 0x73, 0x09, 0xb6, 0x35, 0xe3, 0x6e, 0xb1, 0x3c, 0x30, 0x56, 0xd6, 0x46, 0x59, 0x59, 0xdf, 0x84, + 0x34, 0x0d, 0xf5, 0xf7, 0x72, 0xcc, 0x54, 0x64, 0x1f, 0x84, 0x39, 0x99, 0x99, 0xae, 0xb7, 0xf7, + 0xa8, 0xeb, 0xed, 0x30, 0x7b, 0x62, 0xc9, 0xed, 0x31, 0xbb, 0x6a, 0x02, 0x4b, 0x6e, 0x40, 0xc9, + 0x90, 0x4f, 0xcd, 0x2e, 0x46, 0x3b, 0xc1, 0xaf, 0x47, 0x13, 0x54, 0xe4, 0x1a, 0x14, 0xd9, 0x92, + 0x15, 0xdf, 0x32, 0xcb, 0xd6, 0x85, 0x86, 0x14, 0xea, 0x8f, 0xe5, 0x61, 0x58, 0xfa, 0x9a, 0x5b, + 0x07, 0xfa, 0x9c, 0x37, 0x76, 0xd7, 0x4c, 0xdf, 0xe9, 0x05, 0xf7, 0x52, 0x7e, 0x93, 0x6f, 0x07, + 0xa2, 0xd8, 0xd5, 0x85, 0x94, 0x10, 0xcc, 0xab, 0xe2, 0x43, 0x4b, 0xbb, 0xdf, 0x3e, 0x32, 0xfa, + 0xbb, 0xc5, 0x72, 0x7e, 0xac, 0x70, 0xb7, 0x58, 0x2e, 0x8e, 0xf5, 0x63, 0x1c, 0x2e, 0x0c, 0x7d, + 0xcd, 0xf7, 0xe6, 0xd6, 0x8a, 0xb9, 0x7a, 0xcc, 0xdf, 0x8e, 0x1c, 0x6e, 0x8c, 0xb2, 0x98, 0x6c, + 0x8e, 0xf9, 0x43, 0x92, 0x8f, 0x54, 0x36, 0xa7, 0xd9, 0x16, 0x85, 0x6c, 0xfe, 0x49, 0x0e, 0x94, + 0x54, 0xd9, 0x54, 0x8e, 0xc8, 0x0f, 0xe2, 0xf0, 0x72, 0x2e, 0xfe, 0x41, 0x1e, 0xce, 0xd6, 0x2c, + 0x8f, 0xae, 0xf2, 0x1d, 0xe3, 0x31, 0x9f, 0x2a, 0xee, 0xc1, 0x90, 0xf4, 0x31, 0xa2, 0xcf, 0x9f, + 0x0c, 0xf6, 0xe3, 0x21, 0x2a, 0x83, 0x93, 0x5c, 0xfa, 0x10, 0xd3, 0xb4, 0xc7, 0x84, 0x7c, 0xcc, + 0xe7, 0x9c, 0xe3, 0x21, 0xe4, 0x63, 0x3e, 0x79, 0x7d, 0x4c, 0x85, 0xfc, 0xbf, 0xe7, 0xe0, 0x5c, + 0x4a, 0xe5, 0xe4, 0x2a, 0x0c, 0xd4, 0xbb, 0xcb, 0x18, 0x76, 0x2b, 0x17, 0x7a, 0x0c, 0xbb, 0xdd, + 0x65, 0x8c, 0xb8, 0xa5, 0xf9, 0x48, 0xb2, 0x84, 0x8f, 0xeb, 0x17, 0x6a, 0xd5, 0x49, 0x21, 0x55, + 0x55, 0x0a, 0x13, 0xc0, 0xc0, 0x69, 0x5f, 0x16, 0x3c, 0xc0, 0xb7, 0x4d, 0xa3, 0x19, 0x7b, 0x80, + 0xcf, 0xca, 0x90, 0x1f, 0x86, 0xc1, 0xca, 0x07, 0x5d, 0x87, 0x22, 0x5f, 0x2e, 0xf1, 0x4f, 0x05, + 0x7c, 0x7d, 0x44, 0x1a, 0x67, 0x1e, 0x4b, 0x80, 0x51, 0xc4, 0x79, 0x87, 0x0c, 0xd5, 0xaf, 0xe7, + 0xe0, 0x72, 0x76, 0xeb, 0xc8, 0xe7, 0x60, 0x80, 0xed, 0xcc, 0x2b, 0xda, 0xbc, 0xf8, 0x74, 0x9e, + 0x9f, 0xd4, 0x6e, 0xd1, 0x86, 0xee, 0xc8, 0xc6, 0xbe, 0x4f, 0x46, 0xde, 0x86, 0xa1, 0x9a, 0xeb, + 0x76, 0xa9, 0x53, 0x7f, 0xf9, 0xbe, 0x56, 0x13, 0x7b, 0x42, 0xdc, 0x73, 0x98, 0x08, 0x6e, 0xb8, + 0x2f, 0xc7, 0x02, 0x6b, 0xc9, 0xf4, 0xea, 0x4f, 0xe6, 0xe0, 0x4a, 0xaf, 0xaf, 0x22, 0x2f, 0x43, + 0x79, 0x89, 0x5a, 0xba, 0xe5, 0xd5, 0xaa, 0xa2, 0x49, 0xb8, 0xc5, 0xf2, 0x10, 0x16, 0xdd, 0x29, + 0x04, 0x84, 0xac, 0x10, 0x3f, 0x57, 0x0c, 0x1c, 0x19, 0xf8, 0x19, 0x28, 0xc2, 0x62, 0x85, 0x7c, + 0x42, 0xf5, 0xf7, 0xf3, 0x30, 0xbc, 0xd8, 0xea, 0xae, 0x9a, 0xd2, 0xc2, 0xb1, 0x6f, 0x7b, 0xdb, + 0xb7, 0x7e, 0xf3, 0x7b, 0xb3, 0x7e, 0xd9, 0x70, 0x73, 0xf6, 0x39, 0xdc, 0xfc, 0x72, 0xe4, 0x2d, + 0x28, 0x75, 0xf0, 0x3b, 0xe2, 0x27, 0xb1, 0xfc, 0xeb, 0xb2, 0x4e, 0x62, 0x79, 0x19, 0x36, 0xbe, + 0x9a, 0x07, 0x18, 0x5f, 0x61, 0x59, 0x49, 0xa0, 0xe1, 0x22, 0x71, 0x2a, 0xd0, 0x43, 0x11, 0x68, + 0xb8, 0x20, 0x9c, 0x0a, 0xf4, 0x00, 0x02, 0xfd, 0xcd, 0x3c, 0x8c, 0x46, 0xab, 0x24, 0x9f, 0x83, + 0x21, 0x5e, 0x0d, 0x3f, 0x17, 0xca, 0x49, 0x4e, 0xc5, 0x21, 0x58, 0x03, 0xfe, 0x43, 0x1c, 0x70, + 0x9d, 0x59, 0xd3, 0xdd, 0x46, 0x78, 0x42, 0xc3, 0xef, 0x6f, 0xcb, 0xdc, 0x13, 0x2a, 0x86, 0xd2, + 0x46, 0xd7, 0x74, 0x77, 0x32, 0xfc, 0x4d, 0xa6, 0x80, 0x38, 0xb4, 0xeb, 0xd2, 0x28, 0x83, 0x22, + 0x32, 0x10, 0xc9, 0xa1, 0xe3, 0x58, 0xed, 0x2c, 0x87, 0xc9, 0x6c, 0xbe, 0x12, 0x34, 0x1b, 0x95, + 0xa1, 0x7f, 0x17, 0x99, 0xab, 0x25, 0xfa, 0xf4, 0x63, 0x4e, 0x4e, 0x50, 0xd5, 0x3d, 0x9d, 0x6f, + 0xca, 0xfd, 0x0e, 0x50, 0xbf, 0x67, 0x41, 0xff, 0x82, 0x45, 0x17, 0x56, 0xc8, 0x4b, 0x30, 0xc8, + 0x14, 0x66, 0xd6, 0x66, 0x7d, 0x99, 0x13, 0xfe, 0x13, 0x92, 0x26, 0x21, 0x62, 0xa6, 0x4f, 0x0b, + 0xa9, 0xc8, 0x6d, 0x9e, 0xfd, 0x9e, 0xcf, 0xb1, 0x42, 0xfb, 0x88, 0x5c, 0x86, 0x63, 0x66, 0xfa, + 0x34, 0x89, 0xce, 0x2f, 0x25, 0x1e, 0xe8, 0x14, 0x92, 0xa5, 0x38, 0xc6, 0x2f, 0x25, 0xc6, 0xc7, + 0x6c, 0x5a, 0x62, 0xf9, 0xf8, 0xee, 0x29, 0x49, 0x31, 0xd3, 0xa7, 0xa5, 0x27, 0xa4, 0x1f, 0x96, + 0x1d, 0x4a, 0xe3, 0x4e, 0x1f, 0x32, 0x6e, 0xa6, 0x4f, 0x8b, 0xd0, 0x92, 0xd7, 0x60, 0x48, 0xfc, + 0xbe, 0x6b, 0x8b, 0x1b, 0x65, 0x29, 0x16, 0x91, 0x84, 0x9a, 0xe9, 0xd3, 0x64, 0x4a, 0xa9, 0xd2, + 0x45, 0xc7, 0xb4, 0x3c, 0xf1, 0x46, 0x39, 0x5e, 0x29, 0xe2, 0xa4, 0x4a, 0xf1, 0x37, 0x79, 0x1b, + 0x46, 0x82, 0x20, 0x4f, 0xef, 0xd3, 0xa6, 0x27, 0x0e, 0xbf, 0x2f, 0xc4, 0x0a, 0x73, 0xe4, 0x4c, + 0x9f, 0x16, 0xa5, 0x26, 0xd7, 0xa0, 0xa4, 0x51, 0xd7, 0xfc, 0xc0, 0xbf, 0x2e, 0x1e, 0x95, 0xc6, + 0xb9, 0xf9, 0x01, 0x93, 0x92, 0xc0, 0xb3, 0xde, 0x09, 0xef, 0xa7, 0xc5, 0x51, 0x35, 0x89, 0xd5, + 0x32, 0x65, 0x19, 0xac, 0x77, 0x24, 0xe7, 0x84, 0x2f, 0x86, 0xa1, 0xaf, 0x44, 0xc2, 0xcc, 0xa1, + 0x78, 0x8c, 0x01, 0x19, 0x3b, 0xd3, 0xa7, 0xc5, 0xe8, 0x25, 0xa9, 0x56, 0x4d, 0x77, 0x5d, 0x44, + 0x1b, 0x8d, 0x4b, 0x95, 0xa1, 0x24, 0xa9, 0xb2, 0x9f, 0x52, 0xd5, 0xf3, 0xd4, 0xdb, 0xb0, 0x9d, + 0x75, 0x11, 0x5b, 0x34, 0x5e, 0xb5, 0xc0, 0x4a, 0x55, 0x0b, 0x88, 0x5c, 0x35, 0x1b, 0x70, 0xa3, + 0xe9, 0x55, 0xeb, 0x9e, 0x2e, 0x57, 0xcd, 0x4f, 0xe2, 0xfc, 0x4e, 0x9a, 0xa5, 0xfa, 0x23, 0x9e, + 0xb7, 0x3c, 0xd9, 0xa1, 0x88, 0x93, 0x3a, 0x14, 0x7f, 0xb3, 0x4a, 0xa5, 0xdc, 0xd4, 0x22, 0x31, + 0x79, 0x50, 0xa9, 0x84, 0x62, 0x95, 0xca, 0x59, 0xac, 0x6f, 0xcb, 0x29, 0x9b, 0x95, 0xb3, 0xd1, + 0x0e, 0x0a, 0x31, 0xac, 0x83, 0xa4, 0xd4, 0xce, 0xe3, 0x98, 0x0e, 0x56, 0x21, 0x48, 0x3e, 0x14, + 0xb4, 0x70, 0x72, 0x71, 0xa6, 0x4f, 0xc3, 0x44, 0xb1, 0x2a, 0x4f, 0x34, 0xac, 0x9c, 0x43, 0x8a, + 0x61, 0x9f, 0x82, 0xc1, 0x66, 0xfa, 0x34, 0x9e, 0x84, 0xf8, 0x25, 0x29, 0xa5, 0x9f, 0x72, 0x3e, + 0x3a, 0x45, 0x04, 0x08, 0x36, 0x45, 0x84, 0x89, 0xff, 0xa6, 0x93, 0x69, 0xef, 0x94, 0x0b, 0xd1, + 0xa5, 0x26, 0x8e, 0x9f, 0xe9, 0xd3, 0x92, 0xa9, 0xf2, 0x5e, 0x8b, 0x64, 0x82, 0x53, 0x2e, 0xc6, + 0x02, 0x80, 0x85, 0x28, 0x26, 0x2e, 0x39, 0x67, 0xdc, 0x42, 0x2c, 0x6b, 0xb9, 0x98, 0xac, 0x2e, + 0x45, 0x37, 0x2e, 0x29, 0x24, 0x33, 0x7d, 0x5a, 0x5a, 0x49, 0x32, 0x99, 0xc8, 0xc7, 0xa6, 0x28, + 0x51, 0xdf, 0x98, 0x18, 0x7a, 0xa6, 0x4f, 0x4b, 0x64, 0x70, 0xbb, 0x2d, 0x27, 0x42, 0x53, 0x9e, + 0x88, 0x76, 0x62, 0x88, 0x61, 0x9d, 0x28, 0x25, 0x4c, 0xbb, 0x2d, 0x27, 0xc7, 0x52, 0x2e, 0x27, + 0x4b, 0x85, 0x33, 0xa7, 0x94, 0x44, 0x4b, 0x4b, 0xcf, 0xf7, 0xa3, 0x3c, 0x29, 0x32, 0xae, 0x8a, + 0xf2, 0x69, 0x34, 0x33, 0x7d, 0x5a, 0x7a, 0xae, 0x20, 0x2d, 0x3d, 0x51, 0x8e, 0x72, 0xa5, 0x17, + 0xcf, 0xa0, 0x75, 0xe9, 0x49, 0x76, 0xf4, 0x1e, 0x69, 0x4b, 0x94, 0xa7, 0xa2, 0xd1, 0x87, 0x33, + 0x09, 0x67, 0xfa, 0xb4, 0x1e, 0xc9, 0x4f, 0xee, 0x67, 0xe4, 0x10, 0x51, 0x9e, 0x8e, 0x26, 0x5c, + 0x4e, 0x25, 0x9a, 0xe9, 0xd3, 0x32, 0x32, 0x90, 0xdc, 0xcf, 0x48, 0x31, 0xa1, 0x8c, 0xf7, 0x64, + 0x1b, 0xc8, 0x23, 0x23, 0x41, 0xc5, 0x42, 0x6a, 0x76, 0x06, 0xe5, 0x99, 0xa8, 0xea, 0xa6, 0x90, + 0x30, 0xd5, 0x4d, 0xcb, 0xeb, 0xb0, 0x90, 0x9a, 0x4e, 0x40, 0x79, 0xb6, 0x07, 0xc3, 0xa0, 0x8d, + 0xa9, 0x89, 0x08, 0x16, 0x52, 0xe3, 0xf9, 0x2b, 0x6a, 0x94, 0x61, 0x0a, 0x09, 0x63, 0x98, 0x96, + 0x09, 0x60, 0x21, 0x35, 0xec, 0xbb, 0xf2, 0x5c, 0x0f, 0x86, 0x61, 0x0b, 0xd3, 0x02, 0xc6, 0xbf, + 0x16, 0x89, 0xbb, 0xae, 0x7c, 0x2a, 0x3a, 0x6f, 0x48, 0x28, 0x36, 0x6f, 0xc8, 0x11, 0xda, 0x27, + 0x13, 0x91, 0x65, 0x95, 0x4f, 0x47, 0x87, 0x79, 0x0c, 0xcd, 0x86, 0x79, 0x3c, 0x16, 0xed, 0x64, + 0x22, 0xc2, 0xa6, 0x72, 0x35, 0x8b, 0x09, 0xa2, 0xa3, 0x4c, 0x78, 0x4c, 0xce, 0x5a, 0x4a, 0x88, + 0x47, 0xe5, 0x33, 0x51, 0xbf, 0xee, 0x04, 0xc1, 0x4c, 0x9f, 0x96, 0x12, 0x18, 0x52, 0x4b, 0x8f, + 0x67, 0xa4, 0x5c, 0x8b, 0x0e, 0xdb, 0x34, 0x1a, 0x36, 0x6c, 0x53, 0x63, 0x21, 0xcd, 0xa6, 0x3d, + 0x3e, 0x51, 0xae, 0x47, 0x0d, 0xb3, 0x24, 0x05, 0x33, 0xcc, 0x52, 0x1e, 0xad, 0x68, 0xe9, 0x31, + 0x76, 0x94, 0xe7, 0x7b, 0xb6, 0x10, 0x69, 0x52, 0x5a, 0xc8, 0x43, 0xce, 0x84, 0xb6, 0xd3, 0xfd, + 0x4e, 0xcb, 0xd6, 0x0d, 0xe5, 0xb3, 0xa9, 0xb6, 0x13, 0x47, 0x4a, 0xb6, 0x13, 0x07, 0xb0, 0x55, + 0x5e, 0x7e, 0xe3, 0xa0, 0xbc, 0x10, 0x5d, 0xe5, 0x65, 0x1c, 0x5b, 0xe5, 0x23, 0xef, 0x21, 0x26, + 0x13, 0xef, 0x01, 0x94, 0x17, 0xa3, 0x0a, 0x10, 0x43, 0x33, 0x05, 0x88, 0xbf, 0x20, 0xf8, 0x6a, + 0xb6, 0x07, 0xbd, 0x72, 0x03, 0xb9, 0x3d, 0xe3, 0x73, 0xcb, 0xa2, 0x9b, 0xe9, 0xd3, 0xb2, 0xbd, + 0xf0, 0x6b, 0x29, 0x0e, 0xf1, 0xca, 0xcd, 0xa8, 0x82, 0x25, 0x08, 0x98, 0x82, 0x25, 0xdd, 0xe8, + 0x6b, 0x29, 0x1e, 0xed, 0xca, 0xe7, 0x32, 0x59, 0x05, 0xdf, 0x9c, 0xe2, 0x07, 0x7f, 0x5b, 0x76, + 0x49, 0x57, 0x5e, 0x8a, 0x2e, 0x76, 0x21, 0x86, 0x2d, 0x76, 0x92, 0xeb, 0xfa, 0x6d, 0xd9, 0x19, + 0x5b, 0xb9, 0x95, 0x2c, 0x15, 0x2e, 0x91, 0x92, 0xd3, 0xb6, 0x96, 0xee, 0xc3, 0xac, 0xbc, 0x1c, + 0xd5, 0xba, 0x34, 0x1a, 0xa6, 0x75, 0xa9, 0xfe, 0xcf, 0xd3, 0x49, 0x57, 0x64, 0xe5, 0x76, 0x7c, + 0x93, 0x1d, 0xc5, 0x33, 0xcb, 0x27, 0xe1, 0xbe, 0xfc, 0xc5, 0x78, 0xb0, 0x3d, 0xe5, 0x95, 0xd8, + 0xb5, 0x6f, 0x04, 0xcb, 0xec, 0xdb, 0x58, 0x70, 0xbe, 0x2f, 0xc6, 0xe3, 0xd3, 0x29, 0xaf, 0xa6, + 0x73, 0x08, 0x74, 0x25, 0x1e, 0xcf, 0xee, 0x8b, 0xf1, 0x90, 0x6e, 0xca, 0x6b, 0xe9, 0x1c, 0x02, + 0xe9, 0xc6, 0x43, 0xc0, 0xbd, 0x24, 0x05, 0x99, 0x57, 0x3e, 0x1f, 0x35, 0x1d, 0x03, 0x04, 0x33, + 0x1d, 0xc3, 0x50, 0xf4, 0x2f, 0x49, 0xc1, 0xd9, 0x95, 0xd7, 0x13, 0x45, 0x82, 0xc6, 0x4a, 0x21, + 0xdc, 0x5f, 0x92, 0x82, 0x9a, 0x2b, 0x6f, 0x24, 0x8a, 0x04, 0xad, 0x93, 0x42, 0x9f, 0x1b, 0xbd, + 0xde, 0xaf, 0x2a, 0x6f, 0x46, 0x0f, 0x83, 0xb3, 0x29, 0x67, 0xfa, 0xb4, 0x5e, 0xef, 0x60, 0xbf, + 0x9a, 0xed, 0xd8, 0xad, 0xbc, 0x15, 0x1d, 0xc2, 0x59, 0x74, 0x6c, 0x08, 0x67, 0x3a, 0x87, 0xbf, + 0x1d, 0x8b, 0x65, 0xa1, 0xbc, 0x1d, 0x9d, 0xe2, 0x22, 0x48, 0x36, 0xc5, 0xc5, 0x23, 0x5f, 0x44, + 0x82, 0x34, 0x28, 0x5f, 0x88, 0x4e, 0x71, 0x32, 0x8e, 0x4d, 0x71, 0x91, 0x80, 0x0e, 0x93, 0x89, + 0xd8, 0x01, 0xca, 0x3b, 0xd1, 0x29, 0x2e, 0x86, 0x66, 0x53, 0x5c, 0x3c, 0xda, 0xc0, 0xdb, 0xb1, + 0x27, 0xf4, 0xca, 0x17, 0xd3, 0xdb, 0x8f, 0x48, 0xb9, 0xfd, 0xfc, 0xc1, 0xbd, 0x96, 0xfe, 0x16, + 0x5c, 0xa9, 0x44, 0xc7, 0x6f, 0x1a, 0x0d, 0x1b, 0xbf, 0xa9, 0xef, 0xc8, 0xe3, 0x1b, 0x07, 0xa1, + 0x55, 0x13, 0x3d, 0x36, 0x0e, 0xa1, 0x29, 0x92, 0x02, 0x8e, 0xec, 0x91, 0xf9, 0x46, 0x68, 0x32, + 0x63, 0x8f, 0xec, 0x6f, 0x83, 0x62, 0xf4, 0x6c, 0x76, 0x4d, 0xf8, 0x19, 0x2b, 0xd5, 0xe8, 0xec, + 0x9a, 0x20, 0x60, 0xb3, 0x6b, 0xd2, 0x3b, 0x79, 0x1a, 0xc6, 0x84, 0x16, 0x71, 0xf7, 0x69, 0xd3, + 0x5a, 0x55, 0xa6, 0x62, 0xef, 0x2d, 0x63, 0x78, 0x36, 0x3b, 0xc5, 0x61, 0xb8, 0x5e, 0x73, 0xd8, + 0x64, 0xcb, 0xec, 0x2c, 0xdb, 0xba, 0x63, 0xd4, 0xa9, 0x65, 0x28, 0xd3, 0xb1, 0xf5, 0x3a, 0x85, + 0x06, 0xd7, 0xeb, 0x14, 0x38, 0x86, 0x88, 0x8b, 0xc1, 0x35, 0xda, 0xa4, 0xe6, 0x23, 0xaa, 0xdc, + 0x41, 0xb6, 0xe3, 0x59, 0x6c, 0x05, 0xd9, 0x4c, 0x9f, 0x96, 0xc5, 0x81, 0xd9, 0xea, 0x73, 0x9b, + 0xf5, 0x77, 0x67, 0x83, 0xf0, 0x03, 0x8b, 0x0e, 0xed, 0xe8, 0x0e, 0x55, 0x66, 0xa2, 0xb6, 0x7a, + 0x2a, 0x11, 0xb3, 0xd5, 0x53, 0x11, 0x49, 0xb6, 0xfe, 0x58, 0xa8, 0xf5, 0x62, 0x1b, 0x8e, 0x88, + 0xf4, 0xd2, 0x6c, 0x76, 0x8a, 0x22, 0x98, 0x80, 0x66, 0x6d, 0x6b, 0x15, 0x4f, 0x2a, 0xee, 0x46, + 0x67, 0xa7, 0x6c, 0x4a, 0x36, 0x3b, 0x65, 0x63, 0x99, 0xaa, 0x47, 0xb1, 0x7c, 0x0c, 0xde, 0x8b, + 0xaa, 0x7a, 0x0a, 0x09, 0x53, 0xf5, 0x14, 0x70, 0x92, 0xa1, 0x46, 0x5d, 0xea, 0x29, 0xb3, 0xbd, + 0x18, 0x22, 0x49, 0x92, 0x21, 0x82, 0x93, 0x0c, 0xa7, 0xa9, 0xd7, 0x5c, 0x53, 0xe6, 0x7a, 0x31, + 0x44, 0x92, 0x24, 0x43, 0x04, 0xb3, 0xcd, 0x66, 0x14, 0x3c, 0xd1, 0x6d, 0xad, 0xfb, 0x7d, 0x36, + 0x1f, 0xdd, 0x6c, 0x66, 0x12, 0xb2, 0xcd, 0x66, 0x26, 0x92, 0xfc, 0xe4, 0xae, 0xfd, 0xe0, 0x95, + 0x05, 0xac, 0xf0, 0x46, 0x68, 0x17, 0xec, 0xa6, 0xd4, 0x4c, 0x9f, 0xb6, 0x5b, 0x3f, 0xfb, 0xcf, + 0x06, 0x4e, 0xa3, 0xca, 0x22, 0x56, 0x75, 0x26, 0x38, 0xab, 0xe0, 0xe0, 0x99, 0x3e, 0x2d, 0x70, + 0x2b, 0x7d, 0x0d, 0x86, 0xf0, 0xa3, 0x6a, 0x96, 0xe9, 0x55, 0x27, 0x94, 0x77, 0xa3, 0x5b, 0x26, + 0x09, 0xc5, 0xb6, 0x4c, 0xd2, 0x4f, 0x36, 0x89, 0xe3, 0x4f, 0x3e, 0xc5, 0x54, 0x27, 0x14, 0x2d, + 0x3a, 0x89, 0x47, 0x90, 0x6c, 0x12, 0x8f, 0x00, 0x82, 0x7a, 0xab, 0x8e, 0xdd, 0xa9, 0x4e, 0x28, + 0xf5, 0x94, 0x7a, 0x39, 0x2a, 0xa8, 0x97, 0xff, 0x0c, 0xea, 0xad, 0xaf, 0x75, 0xbd, 0x2a, 0xfb, + 0xc6, 0xa5, 0x94, 0x7a, 0x7d, 0x64, 0x50, 0xaf, 0x0f, 0x60, 0x53, 0x21, 0x02, 0x16, 0x1d, 0x9b, + 0x4d, 0xda, 0xf7, 0xcc, 0x56, 0x4b, 0xb9, 0x1f, 0x9d, 0x0a, 0xe3, 0x78, 0x36, 0x15, 0xc6, 0x61, + 0xcc, 0xf4, 0xe4, 0xad, 0xa2, 0xcb, 0xdd, 0x55, 0xe5, 0x41, 0xd4, 0xf4, 0x0c, 0x31, 0xcc, 0xf4, + 0x0c, 0x7f, 0xe1, 0xee, 0x82, 0xfd, 0xd2, 0xe8, 0x8a, 0x43, 0xdd, 0x35, 0xe5, 0x61, 0x6c, 0x77, + 0x21, 0xe1, 0x70, 0x77, 0x21, 0xfd, 0x26, 0xab, 0xf0, 0x64, 0x64, 0xa1, 0xf1, 0x2f, 0x6d, 0xea, + 0x54, 0x77, 0x9a, 0x6b, 0xca, 0x97, 0x90, 0xd5, 0x73, 0xa9, 0x4b, 0x55, 0x94, 0x74, 0xa6, 0x4f, + 0xeb, 0xc5, 0x09, 0xb7, 0xe5, 0xef, 0xce, 0xf2, 0x48, 0xb0, 0xda, 0xe2, 0xa4, 0xbf, 0x09, 0x7d, + 0x2f, 0xb6, 0x2d, 0x4f, 0x92, 0xe0, 0xb6, 0x3c, 0x09, 0x26, 0x1d, 0x78, 0x3a, 0xb6, 0x55, 0x9b, + 0xd3, 0x5b, 0x6c, 0x5f, 0x42, 0x8d, 0x45, 0xbd, 0xb9, 0x4e, 0x3d, 0xe5, 0xcb, 0xc8, 0xfb, 0x6a, + 0xc6, 0x86, 0x2f, 0x46, 0x3d, 0xd3, 0xa7, 0xed, 0xc0, 0x8f, 0xa8, 0x50, 0xac, 0x4f, 0x2f, 0x2d, + 0x2a, 0x3f, 0x14, 0x3d, 0xdf, 0x64, 0xb0, 0x99, 0x3e, 0x0d, 0x71, 0xcc, 0x4a, 0xbb, 0xdf, 0x59, + 0x75, 0x74, 0x83, 0x72, 0x43, 0x0b, 0x6d, 0x37, 0x61, 0x80, 0xfe, 0x70, 0xd4, 0x4a, 0xcb, 0xa2, + 0x63, 0x56, 0x5a, 0x16, 0x8e, 0x29, 0x6a, 0x24, 0xe9, 0x89, 0xf2, 0x95, 0xa8, 0xa2, 0x46, 0x90, + 0x4c, 0x51, 0xa3, 0x29, 0x52, 0xbe, 0x04, 0x17, 0x83, 0xfd, 0xbc, 0x58, 0x7f, 0x79, 0xa7, 0x29, + 0x5f, 0x45, 0x3e, 0x4f, 0x27, 0x2e, 0x03, 0x22, 0x54, 0x33, 0x7d, 0x5a, 0x46, 0x79, 0xb6, 0xe2, + 0x26, 0xf2, 0x79, 0x09, 0xf3, 0xe2, 0x47, 0xa2, 0x2b, 0x6e, 0x06, 0x19, 0x5b, 0x71, 0x33, 0x50, + 0xa9, 0xcc, 0x85, 0x50, 0xf5, 0x1d, 0x98, 0x07, 0x32, 0xcd, 0xe2, 0x90, 0xca, 0x5c, 0x58, 0x6a, + 0xcb, 0x3b, 0x30, 0x0f, 0xac, 0xb5, 0x2c, 0x0e, 0xe4, 0x1a, 0x94, 0xea, 0xf5, 0x39, 0xad, 0x6b, + 0x29, 0xcd, 0x98, 0xb7, 0x2c, 0x42, 0x67, 0xfa, 0x34, 0x81, 0x67, 0x66, 0xd0, 0x54, 0x4b, 0x77, + 0x3d, 0xb3, 0xe9, 0xe2, 0x88, 0xf1, 0x47, 0x88, 0x11, 0x35, 0x83, 0xd2, 0x68, 0x98, 0x19, 0x94, + 0x06, 0x67, 0xf6, 0xe2, 0xa4, 0xee, 0xba, 0xba, 0x65, 0x38, 0xfa, 0x04, 0x2e, 0x13, 0x34, 0xf6, + 0x1a, 0x2b, 0x82, 0x65, 0xf6, 0x62, 0x14, 0x82, 0x87, 0xef, 0x3e, 0xc4, 0x37, 0x73, 0x56, 0x62, + 0x87, 0xef, 0x31, 0x3c, 0x1e, 0xbe, 0xc7, 0x60, 0x68, 0x77, 0xfa, 0x30, 0x8d, 0xae, 0x9a, 0x4c, + 0x44, 0xca, 0x6a, 0xcc, 0xee, 0x8c, 0x13, 0xa0, 0xdd, 0x19, 0x07, 0x46, 0x9a, 0xe4, 0x2f, 0xb7, + 0x6b, 0x19, 0x4d, 0x0a, 0x57, 0xd9, 0x44, 0x19, 0xb6, 0x7e, 0x87, 0x83, 0xa3, 0xba, 0x69, 0xe9, + 0x6d, 0xbb, 0x3a, 0xe1, 0x4b, 0xdd, 0x8c, 0xae, 0xdf, 0x99, 0x84, 0x6c, 0xfd, 0xce, 0x44, 0xb2, + 0xd9, 0xd5, 0xdf, 0x68, 0xad, 0xe9, 0x0e, 0x35, 0xaa, 0xa6, 0x83, 0x27, 0x8b, 0x9b, 0x7c, 0x6b, + 0xf8, 0x7e, 0x74, 0x76, 0xed, 0x41, 0xca, 0x66, 0xd7, 0x1e, 0x68, 0x66, 0xe4, 0xa5, 0xa3, 0x35, + 0xaa, 0x1b, 0xca, 0x7a, 0xd4, 0xc8, 0xcb, 0xa6, 0x64, 0x46, 0x5e, 0x36, 0x36, 0xfb, 0x73, 0x1e, + 0x3a, 0xa6, 0x47, 0x95, 0xd6, 0x6e, 0x3e, 0x07, 0x49, 0xb3, 0x3f, 0x07, 0xd1, 0x6c, 0x43, 0x18, + 0xef, 0x90, 0x76, 0x74, 0x43, 0x98, 0xec, 0x86, 0x78, 0x09, 0x66, 0xb1, 0x88, 0x47, 0x79, 0x8a, + 0x15, 0xb5, 0x58, 0x04, 0x98, 0x59, 0x2c, 0xe1, 0xb3, 0xbd, 0xc8, 0x53, 0x2c, 0xc5, 0x8e, 0xae, + 0xa1, 0x32, 0x8e, 0xad, 0xa1, 0x91, 0x67, 0x5b, 0xaf, 0x45, 0xde, 0x19, 0x28, 0x9d, 0xa8, 0xd5, + 0x21, 0xa1, 0x98, 0xd5, 0x21, 0xbf, 0x48, 0x98, 0x84, 0x33, 0x78, 0x0b, 0xae, 0x75, 0x83, 0x7b, + 0x9c, 0x1f, 0x8d, 0x7e, 0x66, 0x0c, 0xcd, 0x3e, 0x33, 0x06, 0x8a, 0x30, 0x11, 0xd3, 0x96, 0x93, + 0xc1, 0x24, 0x3c, 0x1f, 0x8c, 0x81, 0xc8, 0x2c, 0x90, 0x7a, 0x65, 0x6e, 0xb6, 0x66, 0x2c, 0xca, + 0x57, 0x64, 0x6e, 0xf4, 0x04, 0x36, 0x49, 0x31, 0xd3, 0xa7, 0xa5, 0x94, 0x23, 0xef, 0xc3, 0x15, + 0x01, 0x15, 0x2f, 0xae, 0x31, 0xed, 0xbf, 0x11, 0x2c, 0x08, 0x5e, 0xd4, 0x8f, 0xad, 0x17, 0xed, + 0x4c, 0x9f, 0xd6, 0x93, 0x57, 0x76, 0x5d, 0x62, 0x7d, 0xe8, 0xee, 0xa6, 0xae, 0x60, 0x91, 0xe8, + 0xc9, 0x2b, 0xbb, 0x2e, 0x21, 0xf7, 0x47, 0xbb, 0xa9, 0x2b, 0xe8, 0x84, 0x9e, 0xbc, 0x88, 0x0b, + 0xe3, 0xbd, 0xf0, 0x95, 0x56, 0x4b, 0xd9, 0xc0, 0xea, 0x3e, 0xb3, 0x9b, 0xea, 0x2a, 0x68, 0x70, + 0xee, 0xc4, 0x91, 0xcd, 0xd2, 0x0b, 0x1d, 0x6a, 0xd5, 0x23, 0x0b, 0xd0, 0xe3, 0xe8, 0x2c, 0x9d, + 0x20, 0x60, 0xb3, 0x74, 0x02, 0xc8, 0x06, 0x94, 0xfc, 0x5c, 0x45, 0xd9, 0x8c, 0x0e, 0x28, 0x19, + 0xc7, 0x06, 0x54, 0xe4, 0x69, 0xcb, 0x02, 0x9c, 0x5b, 0x58, 0xf7, 0x74, 0xdf, 0x82, 0x74, 0x45, + 0x57, 0x7e, 0x10, 0xbb, 0x64, 0x4a, 0x92, 0xe0, 0x25, 0x53, 0x12, 0xcc, 0xc6, 0x08, 0x03, 0xd7, + 0x37, 0xad, 0xe6, 0xb4, 0x6e, 0xb6, 0xba, 0x0e, 0x55, 0xfe, 0xb5, 0xe8, 0x18, 0x89, 0xa1, 0xd9, + 0x18, 0x89, 0x81, 0xd8, 0x02, 0xcd, 0x40, 0x15, 0xd7, 0x35, 0x57, 0x2d, 0xb1, 0xaf, 0xec, 0xb6, + 0x3c, 0xe5, 0x5f, 0x8f, 0x2e, 0xd0, 0x69, 0x34, 0x6c, 0x81, 0x4e, 0x83, 0xe3, 0xa9, 0x13, 0xeb, + 0x05, 0xb6, 0x78, 0xc8, 0x77, 0x95, 0xff, 0x46, 0xec, 0xd4, 0x29, 0x85, 0x06, 0x4f, 0x9d, 0x52, + 0xe0, 0x6c, 0x7d, 0xe4, 0x36, 0xd9, 0xac, 0x19, 0xdc, 0x55, 0xff, 0x9b, 0xd1, 0xf5, 0x31, 0x8e, + 0x67, 0xeb, 0x63, 0x1c, 0x16, 0xe5, 0x23, 0xba, 0xe0, 0xdf, 0xca, 0xe2, 0x13, 0xc8, 0x3f, 0x51, + 0x86, 0xdc, 0x91, 0xf9, 0x88, 0x91, 0xf2, 0x63, 0xb9, 0x2c, 0x46, 0xc1, 0xf0, 0x48, 0x14, 0x8a, + 0x32, 0xd2, 0xe8, 0x23, 0x93, 0x6e, 0x28, 0x5f, 0xcb, 0x64, 0xc4, 0x09, 0xa2, 0x8c, 0x38, 0x8c, + 0xbc, 0x07, 0x17, 0x43, 0xd8, 0x1c, 0x6d, 0x2f, 0x07, 0x33, 0xd3, 0x1f, 0xcb, 0x45, 0xcd, 0xe0, + 0x74, 0x32, 0x66, 0x06, 0xa7, 0x63, 0xd2, 0x58, 0x0b, 0xd1, 0xfd, 0xdb, 0x3b, 0xb0, 0x0e, 0x24, + 0x98, 0xc1, 0x20, 0x8d, 0xb5, 0x90, 0xe6, 0x8f, 0xef, 0xc0, 0x3a, 0x90, 0x69, 0x06, 0x03, 0xf2, + 0x53, 0x39, 0xb8, 0x9a, 0x8e, 0xaa, 0xb4, 0x5a, 0xd3, 0xb6, 0x13, 0xe2, 0x94, 0x3f, 0x9e, 0x8b, + 0x1e, 0x34, 0xec, 0xae, 0xd8, 0x4c, 0x9f, 0xb6, 0xcb, 0x0a, 0xc8, 0x17, 0x60, 0xa4, 0xd2, 0x35, + 0x4c, 0x0f, 0x2f, 0xde, 0x98, 0xe1, 0xfc, 0x13, 0xb9, 0xd8, 0x16, 0x47, 0xc6, 0xe2, 0x16, 0x47, + 0x06, 0x90, 0xbb, 0x70, 0xb6, 0x4e, 0x9b, 0x5d, 0xc7, 0xf4, 0x36, 0x35, 0xda, 0xb1, 0x1d, 0x8f, + 0xf1, 0xf8, 0x13, 0xb9, 0xe8, 0x24, 0x96, 0xa0, 0x60, 0x93, 0x58, 0x02, 0x48, 0x1e, 0x24, 0x6e, + 0xe5, 0x45, 0x67, 0xfe, 0x64, 0xae, 0xe7, 0xb5, 0x7c, 0xd0, 0x97, 0xe9, 0xc5, 0xc9, 0x62, 0xec, + 0x16, 0x5d, 0x70, 0xfd, 0xa9, 0x5c, 0x8f, 0x6b, 0x74, 0x69, 0x86, 0x4b, 0x82, 0x19, 0xc7, 0x94, + 0x0c, 0xf0, 0xca, 0x9f, 0xcc, 0xf5, 0xb8, 0xf6, 0x0e, 0x39, 0xa6, 0x25, 0x8f, 0x7f, 0x85, 0x7b, + 0x8a, 0x08, 0x46, 0x3f, 0x9d, 0x4b, 0xba, 0x8a, 0x04, 0xe5, 0x25, 0x42, 0x56, 0xec, 0xbe, 0x1b, + 0x28, 0xfd, 0x87, 0xb9, 0xa4, 0x6f, 0x5e, 0x58, 0x2c, 0xfc, 0x45, 0x28, 0x5c, 0x9e, 0x7a, 0xec, + 0x51, 0xc7, 0xd2, 0x5b, 0xd8, 0x9d, 0x75, 0xcf, 0x76, 0xf4, 0x55, 0x3a, 0x65, 0xe9, 0xcb, 0x2d, + 0xaa, 0x7c, 0x3d, 0x17, 0xb5, 0x60, 0xb3, 0x49, 0x99, 0x05, 0x9b, 0x8d, 0x25, 0x6b, 0xf0, 0x64, + 0x1a, 0xb6, 0x6a, 0xba, 0x58, 0xcf, 0x37, 0x72, 0x51, 0x13, 0xb6, 0x07, 0x2d, 0x33, 0x61, 0x7b, + 0xa0, 0xc9, 0x2d, 0x18, 0x9c, 0xb0, 0xfd, 0xe9, 0xf7, 0x4f, 0xc5, 0x9c, 0x21, 0x03, 0xcc, 0x4c, + 0x9f, 0x16, 0x92, 0x89, 0x32, 0x62, 0x50, 0x7f, 0x33, 0x59, 0x26, 0xbc, 0x7c, 0x0a, 0x7e, 0x88, + 0x32, 0x42, 0xdc, 0xff, 0x4e, 0xb2, 0x4c, 0x78, 0xc7, 0x15, 0xfc, 0x60, 0x33, 0x09, 0xaf, 0x71, + 0x6e, 0xba, 0xc2, 0xec, 0xb6, 0xc9, 0x35, 0xbd, 0xd5, 0xa2, 0xd6, 0x2a, 0x55, 0xbe, 0x15, 0x9b, + 0x49, 0xd2, 0xc9, 0xd8, 0x4c, 0x92, 0x8e, 0x21, 0x3f, 0x0c, 0x97, 0x1e, 0xe8, 0x2d, 0xd3, 0x08, + 0x71, 0x7e, 0x3e, 0x70, 0xe5, 0x67, 0x72, 0xd1, 0xdd, 0x74, 0x06, 0x1d, 0xdb, 0x4d, 0x67, 0xa0, + 0xc8, 0x1c, 0x10, 0x5c, 0x46, 0x83, 0xd9, 0x82, 0xad, 0xcf, 0xca, 0xbf, 0x9b, 0x8b, 0xda, 0xa9, + 0x49, 0x12, 0x66, 0xa7, 0x26, 0xa1, 0xa4, 0x91, 0x9d, 0x1a, 0x44, 0xf9, 0xd9, 0x5c, 0xf4, 0xb4, + 0x26, 0x8b, 0x70, 0xa6, 0x4f, 0xcb, 0xce, 0x2f, 0x72, 0x07, 0xc6, 0xea, 0x8b, 0xb5, 0xe9, 0xe9, + 0xa9, 0xfa, 0x83, 0x5a, 0x15, 0x1f, 0x3a, 0x18, 0xca, 0x9f, 0x8e, 0xad, 0x58, 0x71, 0x02, 0xb6, + 0x62, 0xc5, 0x61, 0xe4, 0x4d, 0x18, 0x66, 0xed, 0x67, 0x03, 0x06, 0x3f, 0xf9, 0xe7, 0x72, 0x51, + 0x73, 0x4a, 0x46, 0x32, 0x73, 0x4a, 0xfe, 0x4d, 0xea, 0x70, 0x9e, 0x49, 0x71, 0xd1, 0xa1, 0x2b, + 0xd4, 0xa1, 0x56, 0xd3, 0x1f, 0xd3, 0x3f, 0x9f, 0x8b, 0x5a, 0x19, 0x69, 0x44, 0xcc, 0xca, 0x48, + 0x83, 0x93, 0x75, 0xb8, 0x12, 0x3f, 0x09, 0x92, 0x9f, 0x9d, 0x2a, 0x7f, 0x26, 0x17, 0x33, 0x86, + 0x7b, 0x10, 0xa3, 0x31, 0xdc, 0x03, 0x4f, 0x2c, 0x78, 0x4a, 0x1c, 0xab, 0x08, 0x87, 0xcb, 0x78, + 0x6d, 0x7f, 0x96, 0xd7, 0xf6, 0xe9, 0xd0, 0x21, 0xb0, 0x07, 0xf5, 0x4c, 0x9f, 0xd6, 0x9b, 0x1d, + 0xd3, 0xb3, 0x64, 0x02, 0x0c, 0xe5, 0x17, 0x72, 0xe9, 0x1e, 0x29, 0x11, 0x37, 0xe5, 0xb4, 0xcc, + 0x19, 0xef, 0x65, 0xa5, 0x6f, 0x50, 0xfe, 0x5c, 0x6c, 0xbc, 0xa5, 0x93, 0xb1, 0xf1, 0x96, 0x91, + 0xff, 0xe1, 0x2e, 0x9c, 0xe5, 0x4a, 0xbd, 0xa8, 0xe3, 0x30, 0xb4, 0x56, 0xa9, 0xa1, 0xfc, 0x7b, + 0xb1, 0xd5, 0x2e, 0x41, 0x81, 0xae, 0x3d, 0x71, 0x20, 0x9b, 0xba, 0xeb, 0x1d, 0xdd, 0xb2, 0xf0, + 0x98, 0x55, 0xf9, 0xf7, 0x63, 0x53, 0x77, 0x88, 0x42, 0xc7, 0xdd, 0xe0, 0x17, 0xd3, 0x84, 0x5e, + 0xa9, 0x8f, 0x94, 0x3f, 0x1f, 0xd3, 0x84, 0x5e, 0xc4, 0x4c, 0x13, 0x7a, 0xe6, 0x51, 0x7a, 0x90, + 0xf1, 0x04, 0x5c, 0xf9, 0xc5, 0xd8, 0x8a, 0x9c, 0x4a, 0xc5, 0x56, 0xe4, 0xf4, 0x17, 0xe4, 0x0f, + 0x32, 0x9e, 0x4f, 0x2b, 0xbf, 0xd4, 0x9b, 0x6f, 0xb8, 0xd2, 0xa7, 0xbf, 0xbe, 0x7e, 0x90, 0xf1, + 0xf4, 0x58, 0xf9, 0x0b, 0xbd, 0xf9, 0x86, 0x8e, 0x7d, 0xe9, 0x2f, 0x97, 0x1b, 0xd9, 0xcf, 0x76, + 0x95, 0xbf, 0x18, 0x9f, 0xba, 0x32, 0x08, 0x71, 0xea, 0xca, 0x7a, 0xfb, 0xbb, 0x0c, 0x4f, 0x70, + 0x0d, 0xb9, 0xe3, 0xe8, 0x9d, 0xb5, 0x3a, 0xf5, 0x3c, 0xd3, 0x5a, 0xf5, 0x77, 0x62, 0x7f, 0x29, 0x17, 0x3b, 0x1e, 0xcb, 0xa2, 0xc4, 0xe3, 0xb1, 0x2c, 0x24, 0x53, 0xde, 0xc4, 0x03, 0x5d, 0xe5, - 0xaf, 0xc4, 0x94, 0x37, 0x41, 0xc1, 0x94, 0x37, 0xf9, 0xae, 0xf7, 0x5e, 0xca, 0x3b, 0x54, 0xe5, - 0x3f, 0xc8, 0xe6, 0x15, 0xb4, 0x2f, 0xe5, 0xf9, 0xea, 0xbd, 0x94, 0xe7, 0x96, 0xca, 0x7f, 0x98, - 0xcd, 0x2b, 0xf4, 0x41, 0x4a, 0xbe, 0xd2, 0x7c, 0x1f, 0x2e, 0xf2, 0xd9, 0x7c, 0x86, 0x1a, 0x34, - 0xf2, 0xa1, 0xbf, 0x14, 0x1b, 0xfb, 0xe9, 0x64, 0x78, 0xe4, 0x9e, 0x8a, 0x49, 0x63, 0x2d, 0xda, - 0xfa, 0x57, 0x77, 0x61, 0x1d, 0x6e, 0x08, 0xd2, 0x31, 0x6c, 0xbd, 0x91, 0x1f, 0xbf, 0x29, 0xbf, - 0x1c, 0x5b, 0x6f, 0x64, 0x24, 0xba, 0x73, 0xc8, 0x2f, 0xe5, 0xde, 0x8a, 0x3e, 0xf4, 0x52, 0xfe, - 0xa3, 0xd4, 0xc2, 0x41, 0x07, 0x44, 0x5f, 0x85, 0xbd, 0x15, 0x7d, 0xd4, 0xa4, 0xfc, 0x4a, 0x6a, - 0xe1, 0xe0, 0x03, 0xa2, 0x2f, 0xa0, 0xd8, 0x16, 0xa9, 0xe3, 0xd9, 0x9c, 0x55, 0x64, 0x7a, 0xf8, - 0x6b, 0xf1, 0x2d, 0x52, 0x2a, 0x19, 0x6e, 0x91, 0x52, 0x31, 0x69, 0xac, 0xc5, 0xe7, 0xfd, 0xea, - 0x2e, 0xac, 0xa5, 0x8d, 0x5d, 0x2a, 0x26, 0x8d, 0xb5, 0xf8, 0xf8, 0x5f, 0xdb, 0x85, 0xb5, 0xb4, - 0xb1, 0x4b, 0xc5, 0x30, 0x73, 0x2c, 0xc4, 0x3c, 0xa0, 0x8e, 0x1b, 0xaa, 0xdf, 0x5f, 0x8f, 0x99, - 0x63, 0x19, 0x74, 0xcc, 0x1c, 0xcb, 0x40, 0xa5, 0x72, 0x17, 0x42, 0xf9, 0xf5, 0xdd, 0xb8, 0x87, - 0xf7, 0x32, 0x19, 0xa8, 0x54, 0xee, 0x42, 0x2e, 0x7f, 0x63, 0x37, 0xee, 0xe1, 0xc5, 0x4c, 0x06, - 0x8a, 0x19, 0x45, 0x35, 0x4f, 0xf7, 0xcc, 0xc6, 0xac, 0xed, 0x7a, 0xd2, 0x22, 0xff, 0x37, 0x63, - 0x46, 0x51, 0x1a, 0x11, 0x33, 0x8a, 0xd2, 0xe0, 0x49, 0xa6, 0x42, 0x1a, 0xbf, 0xd1, 0x95, 0x69, - 0x68, 0x69, 0xa5, 0xc1, 0x93, 0x4c, 0x85, 0x10, 0xfe, 0xe3, 0xae, 0x4c, 0x43, 0x4f, 0xf9, 0x34, - 0x38, 0xb3, 0x4c, 0xa7, 0x1c, 0x7b, 0xd3, 0xba, 0x47, 0x37, 0x69, 0x53, 0x7c, 0xfa, 0x6f, 0xc6, - 0x2c, 0xd3, 0x38, 0x01, 0xde, 0xa2, 0xc4, 0x60, 0x51, 0x46, 0xe2, 0x73, 0x7f, 0x2b, 0x93, 0x51, - 0x78, 0x4c, 0x14, 0x87, 0x45, 0x19, 0x89, 0x4f, 0xfc, 0xed, 0x4c, 0x46, 0xe1, 0x31, 0x51, 0x1c, - 0x36, 0xd9, 0x07, 0xbd, 0x78, 0x8e, 0xa8, 0xfe, 0x42, 0x0e, 0x86, 0x6a, 0x9e, 0x43, 0xf5, 0x96, - 0x88, 0x76, 0x76, 0x19, 0xfa, 0xb9, 0x43, 0xae, 0xff, 0x7a, 0x58, 0x0b, 0x7e, 0x93, 0x6b, 0x30, - 0x32, 0xa7, 0xbb, 0x1e, 0x96, 0xac, 0x5a, 0x06, 0x7d, 0x82, 0x8f, 0xd1, 0x0a, 0x5a, 0x0c, 0x4a, - 0xe6, 0x38, 0x1d, 0x2f, 0x87, 0x01, 0x2e, 0x0b, 0xbb, 0x06, 0xf9, 0xea, 0xff, 0xee, 0xf6, 0x44, - 0x0f, 0xc6, 0xf4, 0x8a, 0x95, 0x55, 0x7f, 0x2f, 0x07, 0x09, 0x57, 0xe1, 0x83, 0xbf, 0xea, 0x5f, - 0x84, 0xd1, 0x58, 0x50, 0x55, 0xf1, 0xa2, 0x6e, 0x8f, 0x31, 0x57, 0xe3, 0xa5, 0xc9, 0x67, 0x82, - 0x97, 0x5c, 0x2b, 0xda, 0x9c, 0x08, 0xe0, 0x86, 0xa9, 0x07, 0x3a, 0x4e, 0x53, 0x93, 0x50, 0x22, - 0x40, 0xcf, 0xf7, 0xc7, 0xc2, 0x88, 0x91, 0xe4, 0x9a, 0x08, 0x31, 0x90, 0x0b, 0xc3, 0xbe, 0xc5, - 0x12, 0x9d, 0xf3, 0x90, 0x02, 0x5f, 0x80, 0xa1, 0x6a, 0xab, 0x4d, 0x1d, 0xd7, 0xb6, 0x74, 0xcf, - 0x76, 0xc4, 0x0b, 0x6d, 0x0c, 0x09, 0x66, 0x4a, 0x70, 0x39, 0x4c, 0x95, 0x4c, 0x4f, 0x6e, 0xf8, - 0xd9, 0xd3, 0x0a, 0x18, 0xab, 0x13, 0x9f, 0x59, 0xc6, 0x93, 0x67, 0x73, 0x0a, 0x46, 0xba, 0xe2, - 0xea, 0xf8, 0xe6, 0x2f, 0x20, 0xed, 0x30, 0x80, 0x4c, 0x8a, 0x14, 0xe4, 0x45, 0x28, 0xe1, 0x1d, - 0x89, 0x8b, 0x59, 0x11, 0x45, 0x30, 0xba, 0x26, 0x42, 0xe4, 0xd0, 0x5f, 0x9c, 0x86, 0xdc, 0x87, - 0xb1, 0xf0, 0x02, 0xf8, 0xae, 0x63, 0x77, 0xda, 0x7e, 0x1e, 0x14, 0x4c, 0x3a, 0xfe, 0x28, 0xc0, - 0xd5, 0xd7, 0x11, 0x29, 0xb1, 0x48, 0x14, 0x24, 0xb3, 0x30, 0x1a, 0xc2, 0x98, 0x88, 0xfc, 0xfc, - 0x4b, 0x98, 0xfb, 0x52, 0xe2, 0xc5, 0xc4, 0x19, 0xc9, 0x7d, 0x19, 0x2b, 0x46, 0xaa, 0xd0, 0xe7, - 0x47, 0xa2, 0xeb, 0xdf, 0x55, 0x49, 0xcf, 0x89, 0x48, 0x74, 0x7d, 0x72, 0x0c, 0x3a, 0xbf, 0x3c, - 0x99, 0x81, 0x11, 0xcd, 0xee, 0x78, 0x74, 0xd9, 0x16, 0x3b, 0x27, 0x11, 0xf1, 0x10, 0xdb, 0xe4, - 0x30, 0x4c, 0xdd, 0xb3, 0xfd, 0x9c, 0xed, 0x72, 0xee, 0xf0, 0x68, 0x29, 0xb2, 0x00, 0xe3, 0x89, - 0xab, 0x72, 0x39, 0x93, 0xba, 0xf4, 0x79, 0x49, 0x66, 0xc9, 0xa2, 0xe4, 0xc7, 0x72, 0x50, 0x5a, - 0x76, 0x74, 0xd3, 0x73, 0xc5, 0x73, 0xc1, 0x0b, 0x37, 0x37, 0x1d, 0xbd, 0xcd, 0xf4, 0xe3, 0x26, - 0x06, 0x63, 0x7d, 0xa0, 0x37, 0x3b, 0xd4, 0x9d, 0x7c, 0xc8, 0xbe, 0xee, 0xbf, 0xdf, 0x9e, 0x78, - 0x6b, 0x1d, 0x0f, 0xe4, 0x6e, 0x36, 0xec, 0xd6, 0xad, 0x75, 0x47, 0x7f, 0x6c, 0x7a, 0x68, 0xf6, - 0xe8, 0xcd, 0x5b, 0x1e, 0x6d, 0xe2, 0xb9, 0xdf, 0x2d, 0xbd, 0x6d, 0xde, 0xc2, 0xa0, 0xdf, 0xb7, - 0x02, 0x4e, 0xbc, 0x06, 0xa6, 0x02, 0x1e, 0xfe, 0x25, 0xab, 0x00, 0xc7, 0x91, 0x05, 0x00, 0xf1, - 0xa9, 0xe5, 0x76, 0x5b, 0xbc, 0x3d, 0x94, 0x4e, 0xcb, 0x7c, 0x0c, 0x57, 0xec, 0x40, 0x60, 0x7a, - 0x5b, 0x0a, 0x74, 0xab, 0x49, 0x1c, 0x98, 0x16, 0x2c, 0x8b, 0x16, 0xf9, 0x62, 0x1a, 0x0e, 0x25, - 0xee, 0x37, 0x36, 0x45, 0x48, 0xf1, 0x62, 0x64, 0x15, 0x46, 0x05, 0xdf, 0x20, 0x2d, 0xc6, 0x48, - 0x74, 0x56, 0x88, 0xa1, 0xb9, 0xd2, 0x06, 0x6d, 0x34, 0x04, 0x58, 0xae, 0x23, 0x56, 0x82, 0x4c, - 0x86, 0x69, 0x7c, 0x17, 0xf4, 0x16, 0x75, 0x95, 0x51, 0xd4, 0xd8, 0x2b, 0x3b, 0xdb, 0x13, 0x8a, - 0x5f, 0x1e, 0x83, 0x32, 0xa6, 0xa6, 0xb4, 0xc7, 0x22, 0x32, 0x0f, 0xae, 0xf5, 0x63, 0x29, 0x3c, - 0xe2, 0x3a, 0x1f, 0x2d, 0x42, 0xa6, 0x60, 0x38, 0x78, 0xfa, 0xb0, 0xb2, 0x52, 0xad, 0xe0, 0xe3, - 0x46, 0x11, 0x97, 0x33, 0x96, 0xb8, 0x42, 0x66, 0x12, 0x29, 0x23, 0xc5, 0x8b, 0xe0, 0xaf, 0x1d, - 0x63, 0xf1, 0x22, 0xda, 0x29, 0xf1, 0x22, 0x96, 0xc8, 0x3b, 0x30, 0x58, 0x7e, 0x58, 0x13, 0x71, - 0x30, 0x5c, 0xe5, 0x5c, 0x98, 0x05, 0x49, 0xdf, 0x74, 0xeb, 0x7e, 0xcc, 0x0c, 0xb9, 0xe9, 0x32, - 0x3d, 0x99, 0x86, 0x91, 0x88, 0xf7, 0x94, 0xab, 0x9c, 0x47, 0x0e, 0xd8, 0x72, 0x1d, 0x31, 0x75, - 0x47, 0xa0, 0xe4, 0xe1, 0x15, 0x2d, 0xc4, 0xb4, 0xa6, 0x62, 0xba, 0x98, 0x51, 0x46, 0xa3, 0x18, - 0x72, 0x03, 0x9f, 0x4a, 0xf6, 0x73, 0xad, 0x31, 0x04, 0xaa, 0xee, 0x70, 0x9c, 0xdc, 0xa3, 0xb1, - 0x62, 0xe4, 0x03, 0x20, 0x98, 0x83, 0x86, 0x1a, 0xfe, 0x65, 0x5a, 0xb5, 0xe2, 0x2a, 0x17, 0x31, - 0x28, 0x35, 0x89, 0x3f, 0xf1, 0xaf, 0x56, 0x26, 0xaf, 0x89, 0xe9, 0xe3, 0xaa, 0xce, 0x4b, 0xd5, - 0xfd, 0xe7, 0xfd, 0x75, 0x33, 0x92, 0xa0, 0x37, 0x85, 0x2b, 0xd9, 0x84, 0x4b, 0x4b, 0x0e, 0x7d, - 0x6c, 0xda, 0x1d, 0xd7, 0x5f, 0x3e, 0xfc, 0x79, 0xeb, 0xd2, 0xae, 0xf3, 0xd6, 0x73, 0xa2, 0xe2, - 0x0b, 0x6d, 0x87, 0x3e, 0xae, 0xfb, 0xa1, 0x88, 0x23, 0x91, 0x34, 0xb3, 0xb8, 0x63, 0x9a, 0xe1, - 0x0f, 0x3b, 0x0e, 0x15, 0x70, 0x93, 0xba, 0x8a, 0x12, 0x4e, 0xb5, 0x3c, 0x7a, 0x8a, 0x19, 0xe0, - 0x22, 0x69, 0x86, 0xa3, 0xc5, 0x88, 0x06, 0xe4, 0xee, 0x94, 0x7f, 0xb1, 0x5a, 0x6e, 0xf0, 0x64, - 0xac, 0xca, 0x53, 0xc8, 0x4c, 0x65, 0x62, 0x59, 0x6f, 0x04, 0x61, 0xc9, 0xeb, 0xba, 0xc0, 0xcb, - 0x62, 0x49, 0x96, 0x26, 0x73, 0x30, 0xb6, 0xe4, 0xe0, 0x31, 0xcf, 0x7d, 0xba, 0xb5, 0x64, 0x37, - 0xcd, 0xc6, 0x16, 0xbe, 0xd8, 0x14, 0x53, 0x65, 0x9b, 0xe3, 0xea, 0x8f, 0xe8, 0x56, 0xbd, 0x8d, - 0x58, 0x79, 0x59, 0x89, 0x97, 0x94, 0xc3, 0x04, 0x3f, 0xbd, 0xb7, 0x30, 0xc1, 0x14, 0xc6, 0xc4, - 0xb5, 0xec, 0x13, 0x8f, 0x5a, 0x6c, 0xa9, 0x77, 0xc5, 0xeb, 0x4c, 0x25, 0x76, 0x8d, 0x1b, 0xe0, - 0xf9, 0xd4, 0x21, 0x46, 0x19, 0x0d, 0xc0, 0x72, 0xc3, 0xe2, 0x45, 0x92, 0xb1, 0x74, 0x9f, 0x39, - 0x40, 0x2c, 0xdd, 0xbf, 0x59, 0x90, 0xe7, 0x5f, 0x72, 0x05, 0x8a, 0x52, 0xaa, 0x1b, 0x0c, 0x14, - 0x8a, 0x61, 0xc1, 0x8b, 0x22, 0xfe, 0xf1, 0x80, 0xb0, 0x5d, 0x82, 0x88, 0x30, 0x98, 0xdb, 0x30, - 0x0c, 0x1e, 0xa9, 0x85, 0x04, 0x98, 0x57, 0xae, 0xb3, 0xda, 0x34, 0x1b, 0x18, 0x2c, 0xbe, 0x20, - 0x85, 0x80, 0x40, 0x28, 0x8f, 0x15, 0x2f, 0x91, 0x90, 0xdb, 0x30, 0xe8, 0x1f, 0x2f, 0x86, 0x81, - 0x72, 0x31, 0x86, 0xb8, 0x98, 0xad, 0x45, 0x88, 0x72, 0x89, 0x88, 0xbc, 0x09, 0x10, 0x4e, 0x07, - 0xc2, 0xd2, 0xc2, 0xa5, 0x42, 0x9e, 0x3d, 0xe4, 0xa5, 0x22, 0xa4, 0x66, 0x13, 0xa7, 0xac, 0x8e, - 0x7e, 0x26, 0x4d, 0x9c, 0x38, 0x23, 0x3a, 0x2c, 0x2b, 0x48, 0xb4, 0x08, 0x59, 0x84, 0xf1, 0x84, - 0x06, 0x8a, 0xb0, 0xba, 0x98, 0x4d, 0x3d, 0x45, 0x7d, 0xe5, 0x85, 0x39, 0x51, 0x96, 0x3c, 0x0f, - 0x85, 0x15, 0xad, 0x2a, 0x42, 0x7b, 0xf2, 0xa8, 0xb0, 0x91, 0xb8, 0x3f, 0x0c, 0xab, 0xfe, 0x89, - 0x7c, 0x62, 0x6d, 0x62, 0xd2, 0x13, 0xac, 0xa4, 0x1e, 0x44, 0xe9, 0xf9, 0xf5, 0x73, 0xe9, 0x49, - 0x44, 0xe4, 0x3a, 0xf4, 0x2f, 0xb1, 0x99, 0xa1, 0x61, 0x37, 0x45, 0x7f, 0x62, 0x90, 0xa6, 0xb6, - 0x80, 0x69, 0x01, 0x96, 0xdc, 0x96, 0x12, 0xc0, 0x4a, 0xd1, 0xb2, 0xfd, 0x04, 0xb0, 0xf1, 0xb0, - 0xd1, 0x98, 0x0a, 0xf6, 0x76, 0x2c, 0xa1, 0x94, 0x28, 0x93, 0xb2, 0x2e, 0x86, 0x09, 0xa4, 0x02, - 0xab, 0xb4, 0x77, 0x37, 0xab, 0x54, 0xfd, 0x3b, 0xb9, 0xe4, 0x38, 0x23, 0x77, 0x92, 0x81, 0x6b, - 0x71, 0x11, 0x0a, 0x80, 0x72, 0xad, 0x41, 0x08, 0xdb, 0x48, 0x08, 0xda, 0xfc, 0x81, 0x43, 0xd0, - 0x16, 0xf6, 0x19, 0x82, 0x56, 0xfd, 0x7f, 0x8a, 0x5d, 0xdd, 0x88, 0x8f, 0x25, 0x54, 0xd9, 0x1b, - 0x6c, 0x67, 0xc5, 0x6a, 0x2f, 0xbb, 0x89, 0xfd, 0x01, 0xf7, 0x92, 0xac, 0xeb, 0x7c, 0x68, 0xb9, - 0x5a, 0x94, 0x92, 0xbc, 0x0b, 0x43, 0xfe, 0x07, 0x60, 0x68, 0x63, 0x29, 0x24, 0x6f, 0xb0, 0xaa, - 0xc5, 0x82, 0x00, 0x47, 0x0a, 0x90, 0x57, 0x61, 0x00, 0x6d, 0x9a, 0xb6, 0xde, 0xf0, 0xe3, 0x5e, - 0xf3, 0x40, 0xd9, 0x3e, 0x50, 0x0e, 0xc7, 0x15, 0x50, 0x92, 0xaf, 0x40, 0x49, 0x24, 0x7f, 0xe0, - 0xb9, 0xd1, 0x6f, 0xed, 0xc1, 0xef, 0xfa, 0xa6, 0x9c, 0xf8, 0x81, 0xef, 0x52, 0x10, 0x10, 0xd9, - 0xa5, 0xf0, 0x9c, 0x0f, 0xcb, 0x70, 0x6e, 0xc9, 0xa1, 0x06, 0x7a, 0xf8, 0x4f, 0x3f, 0x69, 0x3b, - 0x22, 0x2d, 0x07, 0x1f, 0xe5, 0xb8, 0x48, 0xb5, 0x7d, 0x34, 0x5b, 0x3e, 0x05, 0x5e, 0x0e, 0xbe, - 0x9b, 0x52, 0x9c, 0x59, 0x2e, 0xbc, 0x25, 0xf7, 0xe9, 0xd6, 0x26, 0x66, 0xea, 0xef, 0x0f, 0x2d, - 0x17, 0x21, 0xe8, 0x47, 0x02, 0x25, 0x5b, 0x2e, 0xd1, 0x42, 0x97, 0xdf, 0x80, 0xc1, 0x83, 0x26, - 0x4f, 0xf8, 0xf5, 0x7c, 0xc6, 0x83, 0x9c, 0xd3, 0x9b, 0xbf, 0x2e, 0x48, 0xaa, 0xdc, 0x9b, 0x91, - 0x54, 0xf9, 0x8f, 0xf2, 0x19, 0xaf, 0x8d, 0x4e, 0x75, 0xf2, 0xd3, 0x40, 0x18, 0xd1, 0xe4, 0xa7, - 0x61, 0xde, 0x59, 0xd3, 0xd0, 0x64, 0xa2, 0x58, 0x9a, 0xe4, 0xd2, 0xae, 0x69, 0x92, 0x7f, 0xa9, - 0xd0, 0xed, 0x35, 0xd6, 0x99, 0xec, 0xf7, 0x23, 0xfb, 0xdb, 0x30, 0x18, 0x48, 0xb6, 0x5a, 0x41, - 0xa3, 0x67, 0x38, 0x48, 0xd5, 0xc2, 0xc1, 0x58, 0x46, 0x22, 0x22, 0x37, 0x78, 0x5b, 0x6b, 0xe6, - 0x87, 0x3c, 0x69, 0xc0, 0xb0, 0x08, 0x07, 0xaf, 0x7b, 0x7a, 0xdd, 0x35, 0x3f, 0xa4, 0x5a, 0x80, - 0x56, 0xff, 0xb3, 0x7c, 0xea, 0x93, 0xb6, 0xb3, 0x3e, 0xda, 0x47, 0x1f, 0xa5, 0x08, 0x91, 0x3f, - 0xc6, 0x3b, 0x13, 0xe2, 0x3e, 0x84, 0xf8, 0x87, 0xf9, 0xd4, 0xa7, 0x8b, 0x67, 0x42, 0xdc, 0xcf, - 0x6c, 0xf1, 0x22, 0x0c, 0x68, 0xf6, 0xa6, 0x3b, 0x85, 0x1b, 0x1b, 0x3e, 0x57, 0xe0, 0x44, 0xed, - 0xd8, 0x9b, 0x6e, 0x1d, 0xb7, 0x2c, 0x5a, 0x48, 0xa0, 0x7e, 0x3f, 0xdf, 0xe5, 0x71, 0xe7, 0x99, - 0xe0, 0x3f, 0xca, 0x25, 0xf2, 0xb7, 0xf2, 0x91, 0xc7, 0xa3, 0xa7, 0x57, 0xd8, 0xb7, 0x00, 0x6a, - 0x8d, 0x0d, 0xda, 0xd2, 0xa5, 0xc4, 0x4b, 0x78, 0xee, 0xe0, 0x22, 0x54, 0x24, 0xec, 0x0d, 0x49, - 0xd4, 0xdf, 0xc9, 0xc7, 0x5e, 0xcf, 0x9e, 0xc9, 0x6e, 0xcf, 0xb2, 0x0b, 0xb4, 0x4e, 0x3c, 0x08, - 0x3e, 0x93, 0xdc, 0x5e, 0x25, 0xf7, 0xe3, 0xf9, 0xd8, 0xdb, 0xe9, 0x53, 0x2b, 0x3b, 0x36, 0x00, - 0x93, 0x6f, 0xba, 0x4f, 0xad, 0x26, 0xbd, 0x08, 0x03, 0x42, 0x0e, 0xc1, 0x52, 0xc1, 0xe7, 0x7d, - 0x0e, 0xc4, 0x53, 0xd6, 0x80, 0x40, 0xfd, 0x93, 0x79, 0x88, 0xbe, 0x69, 0x3f, 0xa5, 0x3a, 0xf4, - 0x5b, 0xf9, 0xe8, 0x6b, 0xfe, 0xd3, 0xab, 0x3f, 0x37, 0x01, 0x6a, 0x9d, 0xd5, 0x86, 0x08, 0x06, - 0xdb, 0x2b, 0x1d, 0xd3, 0x07, 0x50, 0x4d, 0xa2, 0x50, 0xff, 0xdf, 0x7c, 0x6a, 0x88, 0x81, 0xd3, - 0x2b, 0xc0, 0x57, 0xf0, 0x54, 0xbc, 0x61, 0x85, 0x13, 0x39, 0x1e, 0x42, 0xb2, 0xf1, 0x97, 0xc8, - 0xd6, 0xe7, 0x13, 0x92, 0xcf, 0xa7, 0x98, 0x6b, 0x98, 0x4b, 0x20, 0x34, 0xd7, 0xe4, 0x6b, 0x08, - 0xc9, 0x70, 0xfb, 0xfb, 0xf9, 0xdd, 0x22, 0x32, 0x9c, 0xe6, 0x55, 0xb5, 0x6f, 0x49, 0xdf, 0xc2, - 0xc8, 0x81, 0xac, 0x27, 0x86, 0x78, 0x2e, 0xb9, 0x36, 0x07, 0xc9, 0x77, 0x6f, 0x82, 0x4a, 0xfd, - 0xe7, 0xbd, 0xe9, 0xe1, 0x00, 0x4e, 0xaf, 0x08, 0xaf, 0x40, 0x71, 0x49, 0xf7, 0x36, 0x84, 0x26, - 0xe3, 0x95, 0x5e, 0x5b, 0xf7, 0x36, 0x34, 0x84, 0x92, 0x1b, 0xd0, 0xaf, 0xe9, 0x9b, 0xfc, 0xcc, - 0xb3, 0x14, 0xe6, 0xf9, 0x73, 0xf4, 0xcd, 0x3a, 0x3f, 0xf7, 0x0c, 0xd0, 0x44, 0x0d, 0xf2, 0x4c, - 0xf2, 0x93, 0x6f, 0x4c, 0x72, 0xc6, 0xf3, 0x4c, 0x06, 0xd9, 0x25, 0xaf, 0x40, 0x71, 0xd2, 0x36, - 0xb6, 0xf0, 0xfa, 0x6a, 0x88, 0x57, 0xb6, 0x6a, 0x1b, 0x5b, 0x1a, 0x42, 0xc9, 0x4f, 0xe4, 0xa0, - 0x6f, 0x96, 0xea, 0x06, 0x1b, 0x21, 0x03, 0xdd, 0xbc, 0x4e, 0xbe, 0x74, 0x34, 0x5e, 0x27, 0xe3, - 0x1b, 0xbc, 0x32, 0x59, 0x51, 0x44, 0xfd, 0xe4, 0x2e, 0xf4, 0x4f, 0xe9, 0x1e, 0x5d, 0xb7, 0x9d, - 0x2d, 0xf4, 0xa3, 0x19, 0x09, 0x5d, 0xca, 0x23, 0xfa, 0xe3, 0x13, 0xf1, 0x9b, 0xb1, 0x86, 0xf8, - 0xa5, 0x05, 0x85, 0x99, 0x58, 0x44, 0xe6, 0xfb, 0xc1, 0x50, 0x2c, 0x3c, 0xc5, 0x7d, 0x90, 0xe0, - 0x3e, 0x38, 0x56, 0x1e, 0x4a, 0x3f, 0x56, 0x46, 0xeb, 0x11, 0x7d, 0xed, 0x30, 0xbb, 0xe3, 0x30, - 0x2e, 0xfa, 0xdc, 0x7a, 0x44, 0x28, 0x26, 0x77, 0xd4, 0x24, 0x12, 0xf5, 0x7b, 0xbd, 0x90, 0xfa, - 0x78, 0xf8, 0x4c, 0xc9, 0xcf, 0x94, 0x3c, 0x54, 0xf2, 0x4a, 0x42, 0xc9, 0x2f, 0x27, 0x9f, 0xa3, - 0x7f, 0x4c, 0x35, 0xfc, 0x67, 0x8b, 0x89, 0x60, 0x16, 0xa7, 0x7b, 0x77, 0x19, 0x4a, 0xaf, 0x77, - 0x57, 0xe9, 0x05, 0x03, 0xa2, 0xb4, 0xeb, 0x80, 0xe8, 0xdb, 0xeb, 0x80, 0xe8, 0xcf, 0x1c, 0x10, - 0xa1, 0x82, 0x0c, 0x64, 0x2a, 0x48, 0x55, 0x0c, 0x1a, 0xe8, 0x9e, 0x53, 0xe3, 0xca, 0xce, 0xf6, - 0xc4, 0x08, 0x1b, 0x4d, 0xa9, 0xc9, 0x34, 0x90, 0x85, 0xfa, 0x7b, 0xc5, 0x2e, 0x11, 0x68, 0x8e, - 0x45, 0x47, 0x5e, 0x81, 0x42, 0xb9, 0xdd, 0x16, 0xfa, 0x71, 0x4e, 0x0a, 0x7e, 0x93, 0x51, 0x8a, - 0x51, 0x93, 0x37, 0xa1, 0x50, 0x7e, 0x58, 0x8b, 0xe7, 0xd1, 0x28, 0x3f, 0xac, 0x89, 0x2f, 0xc9, - 0x2c, 0xfb, 0xb0, 0x46, 0xde, 0x0e, 0x03, 0x5a, 0x6e, 0x74, 0xac, 0x47, 0x62, 0xa3, 0x28, 0xdc, - 0x6d, 0x7d, 0x77, 0x9c, 0x06, 0x43, 0xb1, 0xed, 0x62, 0x8c, 0x36, 0xa6, 0x4d, 0xa5, 0xbd, 0x6b, - 0x53, 0xdf, 0xae, 0xda, 0xd4, 0xbf, 0x57, 0x6d, 0x1a, 0xd8, 0x83, 0x36, 0xc1, 0xae, 0xda, 0x34, - 0x78, 0x78, 0x6d, 0x6a, 0xc3, 0xe5, 0x64, 0xd4, 0xb0, 0x40, 0x23, 0x34, 0x20, 0x49, 0xac, 0x70, - 0x2c, 0xc1, 0xab, 0xff, 0x0e, 0xc7, 0xd6, 0x37, 0x11, 0x5d, 0x77, 0x19, 0x5e, 0xf6, 0x4f, 0x4b, - 0x96, 0x56, 0x7f, 0x3d, 0x9f, 0x1d, 0xec, 0xec, 0x64, 0x4e, 0x71, 0x3f, 0x94, 0x2a, 0xa5, 0x62, - 0xf4, 0xf1, 0x79, 0xb6, 0x94, 0x63, 0x6c, 0xd3, 0x64, 0xf6, 0x9d, 0x5c, 0x56, 0x04, 0xb6, 0x43, - 0x49, 0xec, 0xd3, 0x49, 0x8f, 0x36, 0xf4, 0xd3, 0x77, 0xa3, 0xae, 0x6c, 0x33, 0x30, 0x24, 0x0b, - 0x51, 0x48, 0x69, 0x2f, 0x02, 0x8e, 0x94, 0x53, 0xff, 0x4e, 0x0e, 0xce, 0xdd, 0xef, 0xac, 0x52, - 0xe1, 0xc1, 0x16, 0x34, 0xe3, 0x03, 0x00, 0x06, 0x16, 0x4e, 0x2c, 0x39, 0x74, 0x62, 0xf9, 0xac, - 0x1c, 0x3d, 0x2d, 0x56, 0xe0, 0x66, 0x48, 0xcd, 0x1d, 0x58, 0x9e, 0xf1, 0x9d, 0x39, 0x1f, 0x75, - 0x56, 0x69, 0x3d, 0xe1, 0xc9, 0x22, 0x71, 0xbf, 0xfc, 0x0e, 0x77, 0x93, 0x3f, 0xa8, 0xd3, 0xc8, - 0xaf, 0xe6, 0x33, 0x03, 0xd6, 0x9d, 0xd8, 0xcc, 0x8a, 0x3f, 0x90, 0xda, 0x2b, 0xf1, 0x0c, 0x8b, - 0x29, 0x24, 0x31, 0x8e, 0x69, 0x5c, 0xd2, 0x05, 0x76, 0xc2, 0xf3, 0x7d, 0x7e, 0xa4, 0x02, 0xfb, - 0x87, 0xb9, 0xcc, 0xc0, 0x82, 0x27, 0x55, 0x60, 0xea, 0xff, 0x52, 0xf0, 0xe3, 0x19, 0x1e, 0xea, - 0x13, 0x5e, 0x84, 0x01, 0xf1, 0xac, 0x3b, 0xea, 0x80, 0x2b, 0x8e, 0xf2, 0xf0, 0x68, 0x38, 0x20, - 0x60, 0xcb, 0xbc, 0xe4, 0x1d, 0x2c, 0x39, 0xe0, 0x4a, 0x9e, 0xc1, 0x9a, 0x44, 0xc2, 0x16, 0xf2, - 0xe9, 0x27, 0xa6, 0x87, 0x56, 0x01, 0xeb, 0xcb, 0x02, 0x5f, 0xc8, 0xe9, 0x13, 0xd3, 0xe3, 0x36, - 0x41, 0x80, 0x66, 0x8b, 0x74, 0x2d, 0xcc, 0x66, 0x2e, 0x16, 0x69, 0x57, 0x24, 0x75, 0x17, 0xcf, - 0xc6, 0x5e, 0x84, 0x01, 0xe1, 0xd5, 0x2a, 0xdc, 0x4c, 0x44, 0x6b, 0x85, 0x1f, 0x2c, 0xb6, 0x36, - 0x20, 0x60, 0x1c, 0x35, 0xba, 0x1e, 0x3a, 0xd6, 0x21, 0x47, 0x07, 0x21, 0x9a, 0xc0, 0x90, 0xdb, - 0x30, 0x52, 0xf3, 0x74, 0xcb, 0xd0, 0x1d, 0x63, 0xb1, 0xe3, 0xb5, 0x3b, 0x9e, 0x6c, 0x94, 0xba, - 0x9e, 0x61, 0x77, 0x3c, 0x2d, 0x46, 0x41, 0x3e, 0x07, 0xc3, 0x3e, 0x64, 0xda, 0x71, 0x6c, 0x47, - 0xb6, 0x3c, 0x5c, 0xcf, 0xa0, 0x8e, 0xa3, 0x45, 0x09, 0xc8, 0xe7, 0x61, 0xb8, 0x6a, 0x3d, 0xb6, - 0x79, 0x9a, 0xfc, 0x15, 0x6d, 0x4e, 0xd8, 0x21, 0xf8, 0x14, 0xcb, 0x0c, 0x10, 0xf5, 0x8e, 0xd3, - 0xd4, 0xa2, 0x84, 0xea, 0x4e, 0x3e, 0x19, 0xf6, 0xf1, 0xf4, 0x6e, 0x5a, 0x6e, 0x44, 0x9d, 0xe9, - 0xd0, 0x83, 0x14, 0x0d, 0x42, 0xd9, 0x97, 0x97, 0xdb, 0x85, 0xb7, 0xa1, 0xff, 0x3e, 0xdd, 0xe2, - 0x7e, 0x9f, 0xa5, 0xd0, 0x55, 0xf8, 0x91, 0x80, 0xc9, 0x27, 0xae, 0x3e, 0x9d, 0xfa, 0xbb, 0xf9, - 0x64, 0x40, 0xcb, 0xd3, 0x2b, 0xec, 0xcf, 0x41, 0x1f, 0x8a, 0xb2, 0xea, 0x1f, 0xf9, 0xa3, 0x00, - 0x51, 0xdc, 0x51, 0x0f, 0x64, 0x9f, 0x4c, 0xfd, 0xc5, 0x52, 0x3c, 0xca, 0xe9, 0xe9, 0x95, 0xde, - 0x5b, 0x30, 0x38, 0x65, 0x5b, 0xae, 0xe9, 0x7a, 0xd4, 0x6a, 0xf8, 0x0a, 0xfb, 0x14, 0x33, 0xa8, - 0x1a, 0x21, 0x58, 0x7e, 0x83, 0x24, 0x51, 0x1f, 0x44, 0x79, 0xc9, 0x6b, 0x30, 0x80, 0x22, 0x47, - 0x3f, 0x69, 0x3e, 0xe1, 0xe1, 0x6d, 0xc1, 0x2a, 0x03, 0xc6, 0x9d, 0xa4, 0x43, 0x52, 0xb2, 0x02, - 0xfd, 0x53, 0x1b, 0x66, 0xd3, 0x70, 0xa8, 0x85, 0xfe, 0xc2, 0x52, 0x30, 0x89, 0x68, 0x5f, 0xde, - 0xc4, 0x7f, 0x91, 0x96, 0x37, 0xa7, 0x21, 0x8a, 0x45, 0x5e, 0x61, 0x09, 0xd8, 0xe5, 0x9f, 0xce, - 0x03, 0x84, 0x05, 0xc8, 0xb3, 0x90, 0x0f, 0x12, 0x05, 0xa3, 0x9b, 0x4a, 0x44, 0x83, 0xf2, 0xb8, - 0x54, 0x88, 0xb1, 0x9d, 0xdf, 0x75, 0x6c, 0xaf, 0x40, 0x89, 0x9f, 0x78, 0xa1, 0x27, 0xb9, 0x14, - 0x78, 0x31, 0xb3, 0xc1, 0x37, 0x91, 0x9e, 0x6f, 0x66, 0xd1, 0xf2, 0x8c, 0x78, 0x65, 0x73, 0x66, - 0x97, 0x1b, 0xd0, 0x8b, 0x7f, 0x91, 0x6b, 0x50, 0x5c, 0xf6, 0x93, 0x8c, 0x0e, 0xf3, 0x59, 0x3a, - 0x26, 0x3f, 0xc4, 0xb3, 0x6e, 0x9a, 0xb2, 0x2d, 0x8f, 0x55, 0x8d, 0xad, 0x1e, 0x12, 0x72, 0x11, - 0xb0, 0x88, 0x5c, 0x04, 0x4c, 0xfd, 0xaf, 0xf2, 0x29, 0xf1, 0x77, 0x4f, 0xef, 0x30, 0x79, 0x03, - 0x00, 0x9f, 0x74, 0x33, 0x79, 0xfa, 0x4f, 0x34, 0x70, 0x94, 0x20, 0x23, 0x54, 0xdb, 0xc8, 0xb6, - 0x23, 0x24, 0x56, 0xff, 0x5e, 0x2e, 0x11, 0xb4, 0xf5, 0x50, 0x72, 0x94, 0xad, 0xb2, 0xfc, 0x01, - 0xcd, 0x58, 0xbf, 0x2f, 0x0a, 0xfb, 0xeb, 0x8b, 0xe8, 0xb7, 0x1c, 0x81, 0x65, 0x7a, 0x9c, 0xdf, - 0xf2, 0xbd, 0x7c, 0x5a, 0x08, 0xdb, 0x93, 0xa9, 0xe2, 0x77, 0x02, 0xa3, 0xb4, 0x18, 0x0b, 0x1a, - 0x8e, 0xd0, 0x78, 0x22, 0x64, 0x61, 0xa6, 0x7e, 0x15, 0x46, 0x63, 0x81, 0x5d, 0x45, 0x4e, 0xda, - 0x6b, 0xdd, 0x23, 0xc4, 0x66, 0x07, 0x03, 0x88, 0x90, 0xa9, 0xff, 0x5f, 0xae, 0x7b, 0x58, 0xdf, - 0x63, 0x57, 0x9d, 0x14, 0x01, 0x14, 0xfe, 0x78, 0x04, 0x70, 0x04, 0xdb, 0xe0, 0x93, 0x2d, 0x80, - 0x8f, 0xc9, 0xe4, 0xf1, 0x51, 0x0b, 0xe0, 0x17, 0x73, 0xbb, 0x46, 0x65, 0x3e, 0x6e, 0x19, 0xa8, - 0xff, 0x63, 0x2e, 0x35, 0x7a, 0xf2, 0xa1, 0xda, 0xf5, 0x36, 0x94, 0xb8, 0x5b, 0x8d, 0x68, 0x95, - 0x94, 0x6f, 0x8a, 0x41, 0xb3, 0x32, 0xb4, 0x73, 0x2c, 0x99, 0x83, 0x3e, 0xde, 0x06, 0x43, 0xf4, - 0xc6, 0xa7, 0xba, 0x84, 0x70, 0x36, 0xb2, 0x26, 0x47, 0x81, 0x56, 0xff, 0x6e, 0x2e, 0x11, 0xcc, - 0xf9, 0x18, 0xbf, 0x2d, 0x9c, 0xaa, 0x0b, 0x7b, 0x9f, 0xaa, 0xd5, 0x7f, 0x96, 0x4f, 0x8f, 0x25, - 0x7d, 0x8c, 0x1f, 0x72, 0x14, 0xc7, 0x69, 0x07, 0x5b, 0xb7, 0x96, 0x61, 0x24, 0x2a, 0x0b, 0xb1, - 0x6c, 0x5d, 0x4d, 0x8f, 0xa8, 0x9d, 0xd1, 0x8a, 0x18, 0x0f, 0xf5, 0xbb, 0xb9, 0x64, 0x18, 0xec, - 0x63, 0x9f, 0x9f, 0x0e, 0xa6, 0x2d, 0xd1, 0x4f, 0xf9, 0x98, 0xac, 0x35, 0x47, 0xf1, 0x29, 0x1f, - 0x93, 0x55, 0xe3, 0x60, 0x9f, 0xf2, 0xcb, 0xf9, 0xac, 0x28, 0xe2, 0xc7, 0xfe, 0x41, 0x5f, 0x96, - 0x85, 0xcc, 0x5b, 0x26, 0x3e, 0xed, 0xd9, 0xac, 0xb0, 0xdd, 0x19, 0x3c, 0x13, 0x7c, 0x0e, 0x36, - 0xc6, 0x53, 0x85, 0xf5, 0x31, 0x51, 0xe4, 0x93, 0x21, 0xac, 0x8f, 0xc9, 0x50, 0xf9, 0xf8, 0x09, - 0xeb, 0x6f, 0xe5, 0xf7, 0x1a, 0xba, 0xfe, 0x4c, 0x78, 0x09, 0xe1, 0x7d, 0x2b, 0x9f, 0x4c, 0xa9, - 0x70, 0xec, 0x62, 0x9a, 0x81, 0x92, 0x48, 0xee, 0x90, 0x29, 0x1c, 0x8e, 0xcf, 0xb2, 0x68, 0xc4, - 0x77, 0xdc, 0x01, 0x71, 0x91, 0xb3, 0x37, 0x91, 0x70, 0x5a, 0xf5, 0xfb, 0xb9, 0x58, 0xfe, 0x81, - 0x63, 0x39, 0x42, 0x38, 0xd0, 0x92, 0x44, 0xde, 0xf1, 0x0f, 0x33, 0x8b, 0xb1, 0xf8, 0xcf, 0xc1, - 0xf7, 0x54, 0xa8, 0xa7, 0x9b, 0xcd, 0x78, 0x79, 0x11, 0x13, 0xe0, 0x77, 0xf3, 0x30, 0x9e, 0x20, - 0x25, 0xd7, 0x22, 0xa1, 0x74, 0xf0, 0x58, 0x32, 0xe6, 0x3c, 0xce, 0x83, 0xea, 0xec, 0xe3, 0x24, - 0xf5, 0x1a, 0x14, 0x2b, 0xfa, 0x16, 0xff, 0xb6, 0x5e, 0xce, 0xd2, 0xd0, 0xb7, 0xe4, 0x13, 0x37, - 0xc4, 0x93, 0x55, 0xb8, 0xc0, 0xef, 0x43, 0x4c, 0xdb, 0x5a, 0x36, 0x5b, 0xb4, 0x6a, 0xcd, 0x9b, - 0xcd, 0xa6, 0xe9, 0x8a, 0x4b, 0xbd, 0x17, 0x77, 0xb6, 0x27, 0xae, 0x7b, 0xb6, 0xa7, 0x37, 0xeb, - 0xd4, 0x27, 0xab, 0x7b, 0x66, 0x8b, 0xd6, 0x4d, 0xab, 0xde, 0x42, 0x4a, 0x89, 0x65, 0x3a, 0x2b, - 0x52, 0xe5, 0xa1, 0xbe, 0x6b, 0x0d, 0xdd, 0xb2, 0xa8, 0x51, 0xb5, 0x26, 0xb7, 0x3c, 0xca, 0x2f, - 0x03, 0x0b, 0xfc, 0x48, 0x90, 0xbf, 0x0d, 0xe7, 0x68, 0xc6, 0x78, 0x95, 0x11, 0x68, 0x29, 0x85, - 0xd4, 0xbf, 0x5d, 0x4c, 0x49, 0x3d, 0x71, 0x82, 0xd4, 0xc7, 0xef, 0xe9, 0xe2, 0x2e, 0x3d, 0x7d, - 0x0b, 0xfa, 0x44, 0x2c, 0x55, 0x71, 0xc1, 0x80, 0xce, 0xec, 0x8f, 0x39, 0x48, 0xbe, 0xa1, 0x11, - 0x54, 0xa4, 0x09, 0x97, 0x97, 0x59, 0x37, 0xa5, 0x77, 0x66, 0xe9, 0x00, 0x9d, 0xd9, 0x85, 0x1f, - 0x79, 0x1f, 0x2e, 0x21, 0x36, 0xa5, 0x5b, 0xfb, 0xb0, 0x2a, 0x8c, 0x51, 0xc5, 0xab, 0x4a, 0xef, - 0xdc, 0xac, 0xf2, 0xe4, 0xcb, 0x30, 0x14, 0x0c, 0x10, 0x93, 0xba, 0xe2, 0xe6, 0xa2, 0xcb, 0x38, - 0xe3, 0x01, 0xe0, 0x18, 0x18, 0x5d, 0xc8, 0xa2, 0x41, 0xc4, 0x22, 0xbc, 0xd4, 0xff, 0x21, 0xd7, - 0x2d, 0x05, 0xc6, 0xb1, 0xcf, 0xca, 0xef, 0x40, 0x9f, 0xc1, 0x3f, 0x4a, 0xe8, 0x54, 0xf7, 0x24, - 0x19, 0x9c, 0x54, 0xf3, 0xcb, 0xa8, 0xff, 0x34, 0xd7, 0x35, 0xf3, 0xc6, 0x49, 0xff, 0xbc, 0x6f, - 0x15, 0x32, 0x3e, 0x4f, 0x4c, 0xa2, 0x37, 0x60, 0xcc, 0x0c, 0x43, 0x83, 0xd7, 0xc3, 0xf0, 0x53, - 0xda, 0xa8, 0x04, 0xc7, 0xd1, 0x75, 0x07, 0x2e, 0xfa, 0x8e, 0x8f, 0x8e, 0xef, 0x21, 0xe6, 0xd6, - 0x3b, 0x8e, 0xc9, 0xc7, 0xa5, 0x76, 0xde, 0x8d, 0xb9, 0x8f, 0xb9, 0x2b, 0x8e, 0xc9, 0x2a, 0xd0, - 0xbd, 0x0d, 0x6a, 0xe9, 0xf5, 0x4d, 0xdb, 0x79, 0x84, 0x51, 0x46, 0xf9, 0xe0, 0xd4, 0x46, 0x39, - 0xfc, 0xa1, 0x0f, 0x26, 0xcf, 0xc3, 0xf0, 0x7a, 0xb3, 0x43, 0x83, 0xb8, 0x8e, 0xfc, 0xae, 0x4f, - 0x1b, 0x62, 0xc0, 0xe0, 0x86, 0xe4, 0x19, 0x00, 0x24, 0xf2, 0x30, 0x2f, 0x0a, 0x5e, 0xec, 0x69, - 0x03, 0x0c, 0xb2, 0x2c, 0xba, 0xeb, 0x32, 0xd7, 0x6a, 0x2e, 0xa4, 0x7a, 0xd3, 0xb6, 0xd6, 0xeb, - 0x1e, 0x75, 0x5a, 0xd8, 0x50, 0x74, 0x66, 0xd0, 0x2e, 0x22, 0x05, 0x5e, 0x9d, 0xb8, 0x73, 0xb6, - 0xb5, 0xbe, 0x4c, 0x9d, 0x16, 0x6b, 0xea, 0x8b, 0x40, 0x44, 0x53, 0x1d, 0x3c, 0xf4, 0xe0, 0x1f, - 0x87, 0xde, 0x0c, 0x9a, 0xf8, 0x08, 0x7e, 0x1a, 0x82, 0x1f, 0x36, 0x01, 0x83, 0x3c, 0xb8, 0x1d, - 0x17, 0x1a, 0xba, 0x30, 0x68, 0xc0, 0x41, 0x28, 0xaf, 0x8b, 0x20, 0xbc, 0x2b, 0xb8, 0x57, 0xb7, - 0x26, 0x7e, 0xa9, 0x5f, 0x2f, 0xa4, 0x25, 0x0b, 0x39, 0x94, 0xa2, 0x85, 0xd3, 0x6a, 0x7e, 0x5f, - 0xd3, 0xea, 0xa8, 0xd5, 0x69, 0xd5, 0xf5, 0x76, 0xbb, 0xbe, 0x66, 0x36, 0xf1, 0x59, 0x15, 0x2e, - 0x7c, 0xda, 0xb0, 0xd5, 0x69, 0x95, 0xdb, 0xed, 0x19, 0x0e, 0x24, 0x2f, 0xc0, 0x38, 0xa3, 0xc3, - 0x4e, 0x0a, 0x28, 0x8b, 0x48, 0xc9, 0x18, 0x60, 0x74, 0x58, 0x9f, 0xf6, 0x29, 0xe8, 0x17, 0x3c, - 0xf9, 0x5a, 0xd5, 0xab, 0xf5, 0x71, 0x66, 0x2e, 0xeb, 0xb9, 0x80, 0x0d, 0x9f, 0x5c, 0x7b, 0xb5, - 0x01, 0xbf, 0x3c, 0xc6, 0x40, 0xb6, 0x3a, 0x2d, 0x1e, 0x11, 0xab, 0x0f, 0x91, 0xc1, 0x6f, 0x72, - 0x0d, 0x46, 0x18, 0x97, 0x40, 0x60, 0x3c, 0x6c, 0x6c, 0xaf, 0x16, 0x83, 0x92, 0xdb, 0x70, 0x3e, - 0x02, 0xe1, 0x36, 0x28, 0x7f, 0x26, 0xd0, 0xab, 0xa5, 0xe2, 0xd4, 0xdf, 0x29, 0x44, 0x53, 0x98, - 0x1c, 0x43, 0x47, 0x5c, 0x82, 0x3e, 0xdb, 0x59, 0xaf, 0x77, 0x9c, 0xa6, 0x18, 0x7b, 0x25, 0xdb, - 0x59, 0x5f, 0x71, 0x9a, 0xe4, 0x02, 0x94, 0x58, 0xef, 0x98, 0x86, 0x18, 0x62, 0xbd, 0x7a, 0xbb, - 0x5d, 0x35, 0x48, 0x99, 0x77, 0x08, 0x86, 0x1c, 0xad, 0x37, 0x70, 0x6b, 0xcf, 0x9d, 0x12, 0x7a, - 0xf9, 0x8a, 0x97, 0x40, 0x62, 0x3f, 0x61, 0x20, 0x52, 0x7e, 0x10, 0x10, 0x63, 0x61, 0xe0, 0xb6, - 0xc4, 0xe0, 0x7d, 0x12, 0x67, 0x21, 0x90, 0x21, 0x0b, 0xbe, 0x89, 0x31, 0x48, 0x05, 0x48, 0x48, - 0xd5, 0xb2, 0x0d, 0x73, 0xcd, 0xa4, 0xfc, 0x55, 0x47, 0x2f, 0xbf, 0xf8, 0x4d, 0x62, 0xb5, 0x31, - 0x9f, 0xc9, 0xbc, 0x80, 0x90, 0xb7, 0xb8, 0x12, 0x72, 0x3a, 0x5c, 0xfb, 0x78, 0xdf, 0x72, 0x3b, - 0x2d, 0x86, 0x42, 0xcd, 0xc4, 0xf2, 0xb8, 0x10, 0xaa, 0x7f, 0xb9, 0x98, 0xcc, 0x63, 0x73, 0x2c, - 0x76, 0xcd, 0x2c, 0x80, 0x48, 0x53, 0x15, 0x5e, 0xae, 0x05, 0x1e, 0xe7, 0x21, 0x26, 0x83, 0x87, - 0x54, 0x96, 0xdc, 0x80, 0x7e, 0xfe, 0x45, 0xd5, 0x8a, 0xb0, 0x77, 0xd0, 0x45, 0xcc, 0x6d, 0x9b, - 0x6b, 0x6b, 0xe8, 0x4f, 0x16, 0xa0, 0xc9, 0x35, 0xe8, 0xab, 0x2c, 0xd4, 0x6a, 0xe5, 0x05, 0xff, - 0xa6, 0x18, 0xdf, 0x97, 0x18, 0x96, 0x5b, 0x77, 0x75, 0xcb, 0xd5, 0x7c, 0x24, 0x79, 0x1e, 0x4a, - 0xd5, 0x25, 0x24, 0xe3, 0xaf, 0x26, 0x07, 0x77, 0xb6, 0x27, 0xfa, 0xcc, 0x36, 0xa7, 0x12, 0x28, - 0xac, 0xf7, 0x41, 0xb5, 0x22, 0xb9, 0x4b, 0xf0, 0x7a, 0x1f, 0x9b, 0x06, 0x5e, 0x3b, 0x6b, 0x01, - 0x9a, 0xbc, 0x0a, 0x43, 0x35, 0xea, 0x98, 0x7a, 0x73, 0xa1, 0x83, 0x5b, 0x45, 0x29, 0x94, 0xa2, - 0x8b, 0xf0, 0xba, 0x85, 0x08, 0x2d, 0x42, 0x46, 0xae, 0x40, 0x71, 0xd6, 0xb4, 0xfc, 0x27, 0x0c, - 0xe8, 0xe3, 0xbe, 0x61, 0x5a, 0x9e, 0x86, 0x50, 0xf2, 0x3c, 0x14, 0xee, 0x2d, 0x57, 0x85, 0x27, - 0x18, 0xf2, 0xfa, 0xc0, 0x8b, 0x84, 0x65, 0xbc, 0xb7, 0x5c, 0x25, 0xaf, 0xc2, 0x00, 0x5b, 0xc4, - 0xa8, 0xd5, 0xa0, 0xae, 0x32, 0x88, 0x1f, 0xc3, 0xc3, 0x08, 0xfa, 0x40, 0xd9, 0xa7, 0x23, 0xa0, - 0x54, 0xff, 0x8f, 0x7c, 0x7a, 0xa2, 0xa1, 0x63, 0x18, 0xea, 0x07, 0xbc, 0x45, 0x8e, 0x29, 0x58, - 0xf1, 0x10, 0x0a, 0xb6, 0x06, 0xa3, 0x65, 0xa3, 0x65, 0x5a, 0x65, 0xfc, 0xe9, 0xce, 0xcf, 0x94, - 0x71, 0xea, 0x90, 0x9e, 0xe7, 0xc5, 0xd0, 0xe2, 0x7b, 0x78, 0xc0, 0x5f, 0x86, 0xaa, 0xeb, 0x1c, - 0x57, 0x6f, 0xad, 0xe9, 0xf5, 0x06, 0xcf, 0xd1, 0xa3, 0xc5, 0x99, 0xaa, 0x3f, 0x95, 0xdf, 0x25, - 0x37, 0xd2, 0x69, 0x94, 0xbe, 0xfa, 0xed, 0x7c, 0xf7, 0xf4, 0x54, 0xa7, 0x52, 0x28, 0x7f, 0x98, - 0x4f, 0x49, 0x16, 0x75, 0x28, 0x49, 0xdc, 0x80, 0x7e, 0xce, 0x26, 0x70, 0xe3, 0xc5, 0xd9, 0x8c, - 0x2b, 0x2b, 0xce, 0xa2, 0x3e, 0x9a, 0x2c, 0xc0, 0xf9, 0xf2, 0xda, 0x1a, 0x6d, 0x78, 0x61, 0xe8, - 0xe7, 0x85, 0x30, 0x08, 0x2b, 0x0f, 0x75, 0x2b, 0xf0, 0x61, 0xe8, 0x68, 0x0c, 0x36, 0x92, 0x5a, - 0x8e, 0x2c, 0xc3, 0xc5, 0x38, 0xbc, 0xc6, 0xb7, 0x00, 0x45, 0x29, 0xfa, 0x6d, 0x82, 0x23, 0xff, - 0x4f, 0xcb, 0x28, 0x9b, 0xd6, 0x4a, 0x9c, 0xaa, 0x7b, 0xbb, 0xb5, 0x12, 0xe7, 0xed, 0xd4, 0x72, - 0xea, 0xef, 0x16, 0xe4, 0x9c, 0x5a, 0xa7, 0xd7, 0xe1, 0xea, 0x4e, 0xc4, 0xcd, 0x7a, 0xaf, 0x43, - 0xe6, 0x55, 0x11, 0x41, 0xc4, 0xe8, 0x38, 0xbe, 0x47, 0x62, 0x10, 0xc1, 0x00, 0x81, 0xf2, 0x3a, - 0x14, 0x50, 0x92, 0x2a, 0x14, 0xcb, 0xce, 0x3a, 0x37, 0x6f, 0x77, 0x7b, 0x54, 0xa5, 0x3b, 0xeb, - 0x6e, 0xfa, 0xa3, 0x2a, 0xc6, 0x42, 0xfd, 0x33, 0xf9, 0x2e, 0x69, 0xb0, 0x4e, 0xe5, 0x24, 0xf2, - 0xe7, 0xf2, 0x59, 0x09, 0xad, 0x4e, 0xaa, 0xeb, 0xd8, 0x47, 0x2c, 0x9c, 0x93, 0xed, 0x57, 0x77, - 0xc4, 0xc2, 0xc9, 0x48, 0xae, 0x75, 0x26, 0x9c, 0xaf, 0xe7, 0xb3, 0xf2, 0x8b, 0x9d, 0xda, 0x59, - 0x26, 0x23, 0xa5, 0xd9, 0x99, 0xae, 0xfc, 0x7c, 0x3e, 0x33, 0xab, 0xdb, 0x99, 0x74, 0xd4, 0x6f, - 0xe4, 0x33, 0xb3, 0xd2, 0x9d, 0xca, 0xa1, 0x94, 0xaa, 0x2d, 0x67, 0x63, 0x49, 0x48, 0xe7, 0xf7, - 0xf3, 0xe9, 0x79, 0x00, 0x8f, 0x41, 0x55, 0x8e, 0xc2, 0x03, 0xcf, 0x17, 0x68, 0xf1, 0x50, 0x02, - 0xed, 0x3d, 0x52, 0x81, 0x1e, 0xdb, 0xd8, 0xfb, 0xa4, 0x0a, 0xf4, 0x08, 0x06, 0xef, 0x69, 0x16, - 0xe8, 0x4f, 0x16, 0x92, 0xb9, 0x2f, 0x4f, 0xe5, 0x11, 0xe5, 0x24, 0xf4, 0xfb, 0x67, 0x18, 0x42, - 0xa0, 0x7b, 0xee, 0x4e, 0xbf, 0x1c, 0x79, 0x17, 0x46, 0x43, 0x59, 0xca, 0x91, 0xa9, 0xf0, 0x7a, - 0xa3, 0xc1, 0x50, 0xf5, 0x0f, 0x18, 0x4e, 0x84, 0x50, 0x89, 0x53, 0xab, 0xdf, 0x2f, 0x24, 0x13, - 0x88, 0x9e, 0xf5, 0xc6, 0x01, 0x7b, 0x63, 0x05, 0x2e, 0x4e, 0x75, 0x1c, 0x87, 0x5a, 0x5e, 0x7a, - 0xa7, 0xe0, 0xe1, 0x72, 0x83, 0x53, 0xd4, 0x93, 0x9d, 0x93, 0x51, 0x98, 0xb1, 0x15, 0xde, 0xf7, - 0x71, 0xb6, 0x7d, 0x21, 0xdb, 0x0e, 0xa7, 0x48, 0x63, 0x9b, 0x5e, 0x58, 0xfd, 0xfb, 0xf9, 0x64, - 0xca, 0xd7, 0xb3, 0xae, 0x3f, 0x58, 0xd7, 0xbf, 0x30, 0xcf, 0x13, 0x5b, 0xdd, 0x37, 0x2d, 0x83, - 0x3c, 0x05, 0x17, 0x56, 0x6a, 0xd3, 0x5a, 0xfd, 0x7e, 0x75, 0xa1, 0x52, 0x5f, 0x59, 0xa8, 0x2d, - 0x4d, 0x4f, 0x55, 0x67, 0xaa, 0xd3, 0x95, 0xb1, 0x1e, 0x72, 0x0e, 0x46, 0x43, 0xd4, 0xec, 0xca, - 0x7c, 0x79, 0x61, 0x2c, 0x47, 0xc6, 0x61, 0x38, 0x04, 0x4e, 0x2e, 0x2e, 0x8f, 0xe5, 0x5f, 0xf8, - 0x0c, 0x0c, 0xe2, 0xcd, 0x3d, 0xbf, 0x69, 0x20, 0x43, 0xd0, 0xbf, 0x38, 0x59, 0x9b, 0xd6, 0x1e, - 0x20, 0x13, 0x80, 0x52, 0x65, 0x7a, 0x81, 0x31, 0xcc, 0xbd, 0xf0, 0x7f, 0xe7, 0x00, 0x6a, 0x33, - 0xcb, 0x4b, 0x82, 0x70, 0x10, 0xfa, 0xaa, 0x0b, 0x0f, 0xca, 0x73, 0x55, 0x46, 0xd7, 0x0f, 0xc5, - 0xc5, 0xa5, 0x69, 0x56, 0xc3, 0x00, 0xf4, 0x4e, 0xcd, 0x2d, 0xd6, 0xa6, 0xc7, 0xf2, 0x0c, 0xa8, - 0x4d, 0x97, 0x2b, 0x63, 0x05, 0x06, 0x7c, 0xa8, 0x55, 0x97, 0xa7, 0xc7, 0x8a, 0xec, 0xcf, 0xb9, - 0xda, 0x72, 0x79, 0x79, 0xac, 0x97, 0xfd, 0x39, 0x83, 0x7f, 0x96, 0x18, 0xb3, 0xda, 0xf4, 0x32, - 0xfe, 0xe8, 0x63, 0x4d, 0x98, 0xf1, 0x7f, 0xf5, 0x33, 0x14, 0x63, 0x5d, 0xa9, 0x6a, 0x63, 0x03, - 0xec, 0x07, 0x63, 0xc9, 0x7e, 0x00, 0x6b, 0x9c, 0x36, 0x3d, 0xbf, 0xf8, 0x60, 0x7a, 0x6c, 0x90, - 0xf1, 0x9a, 0xbf, 0xcf, 0xc0, 0x43, 0xec, 0x4f, 0x6d, 0x9e, 0xfd, 0x39, 0xcc, 0x38, 0x69, 0xd3, - 0xe5, 0xb9, 0xa5, 0xf2, 0xf2, 0xec, 0xd8, 0x08, 0x6b, 0x0f, 0xf2, 0x1c, 0xe5, 0x25, 0x17, 0xca, - 0xf3, 0xd3, 0x63, 0x63, 0x82, 0xa6, 0x32, 0x57, 0x5d, 0xb8, 0x3f, 0x36, 0x8e, 0x0d, 0x79, 0x7f, - 0x1e, 0x7f, 0x10, 0x56, 0x00, 0xff, 0x3a, 0xf7, 0xc2, 0x0f, 0x42, 0x69, 0xb1, 0x86, 0x77, 0x75, - 0x97, 0xe0, 0xdc, 0x62, 0xad, 0xbe, 0xfc, 0xfe, 0xd2, 0x74, 0x4c, 0xde, 0xe3, 0x30, 0xec, 0x23, - 0xe6, 0xaa, 0x0b, 0x2b, 0x5f, 0xe2, 0xd2, 0xf6, 0x41, 0xf3, 0xe5, 0xa9, 0xc5, 0xda, 0x58, 0x9e, - 0xf5, 0x8a, 0x0f, 0x7a, 0x58, 0x5d, 0xa8, 0x2c, 0x3e, 0xac, 0x8d, 0x15, 0x5e, 0x78, 0x0c, 0x43, - 0x3c, 0x2d, 0xd8, 0xa2, 0x63, 0xae, 0x9b, 0x16, 0x79, 0x06, 0x9e, 0xaa, 0x4c, 0x3f, 0xa8, 0x4e, - 0x4d, 0xd7, 0x17, 0xb5, 0xea, 0xdd, 0xea, 0x42, 0xac, 0xa6, 0x0b, 0x30, 0x1e, 0x45, 0x97, 0x97, - 0xaa, 0x63, 0x39, 0x72, 0x11, 0x48, 0x14, 0x7c, 0xaf, 0x3c, 0x3f, 0x33, 0x96, 0x27, 0x0a, 0x9c, - 0x8f, 0xc2, 0xab, 0x0b, 0xcb, 0x2b, 0x0b, 0xd3, 0x63, 0x85, 0x17, 0xfe, 0x52, 0x0e, 0x2e, 0xa4, - 0x86, 0x8e, 0x24, 0x2a, 0x5c, 0x9d, 0x9e, 0x2b, 0xd7, 0x96, 0xab, 0x53, 0xb5, 0xe9, 0xb2, 0x36, - 0x35, 0x5b, 0x9f, 0x2a, 0x2f, 0x4f, 0xdf, 0x5d, 0xd4, 0xde, 0xaf, 0xdf, 0x9d, 0x5e, 0x98, 0xd6, - 0xca, 0x73, 0x63, 0x3d, 0xe4, 0x79, 0x98, 0xc8, 0xa0, 0xa9, 0x4d, 0x4f, 0xad, 0x68, 0xd5, 0xe5, - 0xf7, 0xc7, 0x72, 0xe4, 0x39, 0x78, 0x26, 0x93, 0x88, 0xfd, 0x1e, 0xcb, 0x93, 0xab, 0x70, 0x39, - 0x8b, 0xe4, 0xbd, 0xb9, 0xb1, 0xc2, 0x0b, 0x3f, 0x97, 0x03, 0x92, 0x8c, 0xfd, 0x47, 0x9e, 0x85, - 0x2b, 0x4c, 0x2f, 0xea, 0xd9, 0x0d, 0x7c, 0x0e, 0x9e, 0x49, 0xa5, 0x90, 0x9a, 0x37, 0x01, 0x4f, - 0x67, 0x90, 0x88, 0xc6, 0x5d, 0x01, 0x25, 0x9d, 0x00, 0x9b, 0xf6, 0x9b, 0x39, 0xb8, 0x90, 0x7a, - 0xb9, 0x47, 0xae, 0xc3, 0xa7, 0xca, 0x95, 0x79, 0xd6, 0x37, 0x53, 0xcb, 0xd5, 0xc5, 0x85, 0x5a, - 0x7d, 0x7e, 0xa6, 0x5c, 0x67, 0xda, 0xb7, 0x52, 0x8b, 0xf5, 0xe6, 0x35, 0x50, 0xbb, 0x50, 0x4e, - 0xcd, 0x96, 0x17, 0xee, 0xb2, 0xe1, 0x47, 0x3e, 0x05, 0xcf, 0x66, 0xd2, 0x4d, 0x2f, 0x94, 0x27, - 0xe7, 0xa6, 0x2b, 0x63, 0x79, 0xf2, 0x69, 0x78, 0x2e, 0x93, 0xaa, 0x52, 0xad, 0x71, 0xb2, 0xc2, - 0x64, 0xe5, 0xbb, 0xff, 0xd3, 0xd5, 0x9e, 0xef, 0xfe, 0xc1, 0xd5, 0xdc, 0x3f, 0xf8, 0x83, 0xab, - 0xb9, 0x7f, 0xf6, 0x07, 0x57, 0x73, 0x5f, 0xbe, 0xbd, 0x9f, 0x98, 0x8e, 0x7c, 0xca, 0x5a, 0x2d, - 0xe1, 0x41, 0xfb, 0x2b, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x04, 0xc3, 0x8a, 0x39, 0x12, - 0x75, 0x01, 0x00, + 0x2f, 0xc7, 0x94, 0x37, 0x41, 0xc1, 0x94, 0x37, 0xf9, 0xae, 0xf7, 0x6e, 0xca, 0x3b, 0x54, 0xe5, + 0x3f, 0xc8, 0xe6, 0x15, 0xb4, 0x2f, 0xe5, 0xf9, 0xea, 0xdd, 0x94, 0xe7, 0x96, 0xca, 0x7f, 0x98, + 0xcd, 0x2b, 0xf4, 0x41, 0x4a, 0xbe, 0xd2, 0x7c, 0x0f, 0x2e, 0xf2, 0xd9, 0x7c, 0x9a, 0x1a, 0x34, + 0xf2, 0xa1, 0xbf, 0x1c, 0x1b, 0xfb, 0xe9, 0x64, 0x78, 0xe4, 0x9e, 0x8a, 0x49, 0x63, 0x2d, 0xda, + 0xfa, 0x57, 0x76, 0x60, 0x1d, 0x6e, 0x08, 0xd2, 0x31, 0x6c, 0xbd, 0x91, 0x1f, 0xbf, 0x29, 0xbf, + 0x12, 0x5b, 0x6f, 0x64, 0x24, 0xba, 0x73, 0xc8, 0x2f, 0xe5, 0xde, 0x8c, 0x3e, 0xf4, 0x52, 0xfe, + 0xa3, 0xd4, 0xc2, 0x41, 0x07, 0x44, 0x5f, 0x85, 0xbd, 0x19, 0x7d, 0xd4, 0xa4, 0xfc, 0x6a, 0x6a, + 0xe1, 0xe0, 0x03, 0xa2, 0x2f, 0xa0, 0xd8, 0x16, 0xa9, 0xeb, 0xd9, 0x9c, 0x55, 0x64, 0x7a, 0xf8, + 0xab, 0xf1, 0x2d, 0x52, 0x2a, 0x19, 0x6e, 0x91, 0x52, 0x31, 0x69, 0xac, 0xc5, 0xe7, 0xfd, 0xda, + 0x0e, 0xac, 0xa5, 0x8d, 0x5d, 0x2a, 0x26, 0x8d, 0xb5, 0xf8, 0xf8, 0x5f, 0xdf, 0x81, 0xb5, 0xb4, + 0xb1, 0x4b, 0xc5, 0x30, 0x73, 0x2c, 0xc4, 0x3c, 0xa0, 0x8e, 0x1b, 0xaa, 0xdf, 0x5f, 0x8b, 0x99, + 0x63, 0x19, 0x74, 0xcc, 0x1c, 0xcb, 0x40, 0xa5, 0x72, 0x17, 0x42, 0xf9, 0x8d, 0x9d, 0xb8, 0x87, + 0xf7, 0x32, 0x19, 0xa8, 0x54, 0xee, 0x42, 0x2e, 0x7f, 0x7d, 0x27, 0xee, 0xe1, 0xc5, 0x4c, 0x06, + 0x8a, 0x19, 0x45, 0x75, 0x4f, 0xf7, 0xcc, 0xe6, 0x8c, 0xed, 0x7a, 0xd2, 0x22, 0xff, 0x37, 0x62, + 0x46, 0x51, 0x1a, 0x11, 0x33, 0x8a, 0xd2, 0xe0, 0x49, 0xa6, 0x42, 0x1a, 0xbf, 0xd9, 0x93, 0x69, + 0x68, 0x69, 0xa5, 0xc1, 0x93, 0x4c, 0x85, 0x10, 0xfe, 0xe3, 0x9e, 0x4c, 0x43, 0x4f, 0xf9, 0x34, + 0x38, 0xb3, 0x4c, 0x27, 0x1d, 0x7b, 0xc3, 0xba, 0x4b, 0x37, 0x68, 0x4b, 0x7c, 0xfa, 0x6f, 0xc5, + 0x2c, 0xd3, 0x38, 0x01, 0xde, 0xa2, 0xc4, 0x60, 0x51, 0x46, 0xe2, 0x73, 0x7f, 0x3b, 0x93, 0x51, + 0x78, 0x4c, 0x14, 0x87, 0x45, 0x19, 0x89, 0x4f, 0xfc, 0x9d, 0x4c, 0x46, 0xe1, 0x31, 0x51, 0x1c, + 0x46, 0x2a, 0x30, 0x8a, 0x6f, 0x25, 0x74, 0xd7, 0xf7, 0xfc, 0xfc, 0xdb, 0xb9, 0xe8, 0xad, 0x57, + 0x14, 0x3d, 0xd3, 0xa7, 0xc5, 0x0a, 0xc8, 0x2c, 0xc4, 0x27, 0x7d, 0x3b, 0x83, 0x45, 0xe8, 0xef, + 0x18, 0x85, 0xc8, 0x2c, 0xc4, 0xc7, 0xfc, 0x27, 0x19, 0x2c, 0x42, 0x87, 0xc7, 0x28, 0x64, 0x62, + 0x00, 0xfa, 0xf1, 0x40, 0x54, 0xfd, 0xc5, 0x1c, 0x0c, 0xd7, 0x3d, 0x87, 0xea, 0x6d, 0x11, 0xb6, + 0xed, 0x32, 0x94, 0xb9, 0x67, 0xb1, 0xff, 0x0c, 0x5a, 0x0b, 0x7e, 0x93, 0xab, 0x30, 0x3a, 0xab, + 0xbb, 0x1e, 0x96, 0xac, 0x59, 0x06, 0x7d, 0x8c, 0xaf, 0xea, 0x0a, 0x5a, 0x0c, 0x4a, 0x66, 0x39, + 0x1d, 0x2f, 0x87, 0x91, 0x3a, 0x0b, 0x3b, 0x46, 0x2b, 0x2b, 0x7f, 0x77, 0x6b, 0xbc, 0x0f, 0x83, + 0x93, 0xc5, 0xca, 0xaa, 0xbf, 0x97, 0x83, 0x84, 0xcf, 0xf3, 0xfe, 0xc3, 0x13, 0x2c, 0xc0, 0x99, + 0x58, 0x74, 0x58, 0xf1, 0x34, 0x70, 0x97, 0xc1, 0x63, 0xe3, 0xa5, 0xc9, 0x67, 0x82, 0x27, 0x69, + 0xf7, 0xb5, 0x59, 0x11, 0x89, 0x0e, 0x73, 0x28, 0x74, 0x9d, 0x96, 0x26, 0xa1, 0x44, 0xa4, 0xa1, + 0x1f, 0x8c, 0x85, 0xa1, 0x2f, 0xc9, 0x55, 0x11, 0x2b, 0x21, 0x17, 0xc6, 0xaf, 0x8b, 0x65, 0x6c, + 0xe7, 0xb1, 0x11, 0xbe, 0x00, 0xc3, 0xb5, 0x76, 0x87, 0x3a, 0xae, 0x6d, 0xe9, 0x9e, 0xed, 0x88, + 0xa7, 0xe6, 0x18, 0xdb, 0xcc, 0x94, 0xe0, 0x72, 0xbc, 0x2d, 0x99, 0x9e, 0x5c, 0xf7, 0xd3, 0xc0, + 0x15, 0x30, 0xe8, 0x28, 0xbe, 0x17, 0x8d, 0x67, 0x01, 0xe7, 0x14, 0x8c, 0xf4, 0xbe, 0xab, 0xe3, + 0xe3, 0xc5, 0x80, 0xb4, 0xcb, 0x00, 0x32, 0x29, 0x52, 0x90, 0x17, 0xa0, 0x84, 0x97, 0x3d, 0x2e, + 0xa6, 0x77, 0x14, 0x51, 0xf5, 0x5a, 0x08, 0x91, 0x63, 0x98, 0x71, 0x1a, 0x72, 0x0f, 0xc6, 0xc2, + 0x9b, 0xec, 0x3b, 0x8e, 0xdd, 0xed, 0xf8, 0x09, 0x5d, 0x30, 0x7b, 0xfa, 0x7a, 0x80, 0x6b, 0xac, + 0x22, 0x52, 0x62, 0x91, 0x28, 0x48, 0x66, 0xe0, 0x4c, 0x08, 0x63, 0x22, 0xf2, 0x13, 0x49, 0x61, + 0x12, 0x4f, 0x89, 0x17, 0x13, 0x67, 0x24, 0x89, 0x67, 0xac, 0x18, 0xa9, 0xc1, 0x80, 0x1f, 0x52, + 0xaf, 0xbc, 0xa3, 0x92, 0x9e, 0x13, 0x21, 0xf5, 0x06, 0xe4, 0x60, 0x7a, 0x7e, 0x79, 0x32, 0x0d, + 0xa3, 0x9a, 0xdd, 0xf5, 0xe8, 0x92, 0x2d, 0xb6, 0x80, 0x22, 0x74, 0x23, 0xb6, 0xc9, 0x61, 0x98, + 0x86, 0x67, 0xfb, 0xc9, 0xe7, 0xe5, 0x24, 0xe8, 0xd1, 0x52, 0x64, 0x1e, 0xce, 0x26, 0xee, 0xfc, + 0xe5, 0x94, 0xf0, 0xd2, 0xe7, 0x25, 0x99, 0x25, 0x8b, 0x92, 0x9f, 0xc8, 0x41, 0x69, 0xc9, 0xd1, + 0x4d, 0xcf, 0x15, 0xef, 0x1e, 0x2f, 0xdc, 0xd8, 0x70, 0xf4, 0x0e, 0xd3, 0x8f, 0x1b, 0x18, 0x55, + 0xf6, 0x81, 0xde, 0xea, 0x52, 0x77, 0xe2, 0x21, 0xfb, 0xba, 0xff, 0x7e, 0x6b, 0xfc, 0xcd, 0x55, + 0x3c, 0x59, 0xbc, 0xd1, 0xb4, 0xdb, 0x37, 0x57, 0x1d, 0xfd, 0x91, 0xe9, 0xa1, 0xfd, 0xa6, 0xb7, + 0x6e, 0x7a, 0xb4, 0x85, 0x07, 0x98, 0x37, 0xf5, 0x8e, 0x79, 0x13, 0xa3, 0x97, 0xdf, 0x0c, 0x38, + 0xf1, 0x1a, 0x98, 0x0a, 0x78, 0xf8, 0x97, 0xac, 0x02, 0x1c, 0x47, 0xe6, 0x01, 0xc4, 0xa7, 0x56, + 0x3a, 0x1d, 0xf1, 0x88, 0x52, 0x3a, 0xf6, 0xf3, 0x31, 0x5c, 0xb1, 0x03, 0x81, 0xe9, 0x1d, 0x29, + 0x62, 0xaf, 0x26, 0x71, 0x60, 0x5a, 0xb0, 0x24, 0x5a, 0xe4, 0x8b, 0x69, 0x24, 0x94, 0xb8, 0xdf, + 0xd8, 0x14, 0x21, 0xc5, 0x8b, 0x91, 0x65, 0x38, 0x23, 0xf8, 0x06, 0xf9, 0x3d, 0x46, 0xa3, 0xb3, + 0x42, 0x0c, 0xcd, 0x95, 0x36, 0x68, 0xa3, 0x21, 0xc0, 0x72, 0x1d, 0xb1, 0x12, 0x64, 0x22, 0xcc, + 0x47, 0x3c, 0xaf, 0xb7, 0xa9, 0xab, 0x9c, 0x41, 0x8d, 0xbd, 0xb2, 0xbd, 0x35, 0xae, 0xf8, 0xe5, + 0x31, 0xba, 0x64, 0x6a, 0x6e, 0x7e, 0x2c, 0x22, 0xf3, 0xe0, 0x5a, 0x3f, 0x96, 0xc2, 0x23, 0xae, + 0xf3, 0xd1, 0x22, 0x64, 0x12, 0x46, 0x82, 0x37, 0x1c, 0xf7, 0xef, 0xd7, 0xaa, 0xf8, 0x4a, 0x53, + 0x04, 0x18, 0x8d, 0x65, 0xe0, 0x90, 0x99, 0x44, 0xca, 0x48, 0x81, 0x2f, 0xf8, 0xb3, 0xcd, 0x58, + 0xe0, 0x8b, 0x4e, 0x4a, 0xe0, 0x8b, 0x45, 0xf2, 0x36, 0x0c, 0x55, 0x1e, 0xd6, 0x45, 0x40, 0x0f, + 0x57, 0x39, 0x17, 0xa6, 0x73, 0xd2, 0x37, 0xdc, 0x86, 0x1f, 0xfc, 0x43, 0x6e, 0xba, 0x4c, 0x4f, + 0xa6, 0x60, 0x34, 0xe2, 0x06, 0xe6, 0x2a, 0xe7, 0x91, 0x03, 0xb6, 0x5c, 0x47, 0x4c, 0xc3, 0x11, + 0x28, 0x79, 0x78, 0x45, 0x0b, 0x31, 0xad, 0xa9, 0x9a, 0x2e, 0xa6, 0xc6, 0xd1, 0x28, 0xc6, 0x0e, + 0xc1, 0x37, 0x9f, 0x65, 0xae, 0x35, 0x86, 0x40, 0x35, 0x1c, 0x8e, 0x93, 0x7b, 0x34, 0x56, 0x8c, + 0xbc, 0x0f, 0x04, 0x93, 0xe9, 0x50, 0xc3, 0xbf, 0x15, 0xac, 0x55, 0x5d, 0xe5, 0x22, 0x46, 0xd7, + 0x26, 0xf1, 0x58, 0x05, 0xb5, 0xea, 0xc4, 0x55, 0x31, 0x7d, 0x3c, 0xad, 0xf3, 0x52, 0x0d, 0x3f, + 0x4e, 0x41, 0xc3, 0x8c, 0x64, 0x1a, 0x4e, 0xe1, 0x4a, 0x36, 0xe0, 0xd2, 0xa2, 0x43, 0x1f, 0x99, + 0x76, 0xd7, 0xf5, 0x97, 0x0f, 0x7f, 0xde, 0xba, 0xb4, 0xe3, 0xbc, 0xf5, 0xac, 0xa8, 0xf8, 0x42, + 0xc7, 0xa1, 0x8f, 0x1a, 0x7e, 0x4c, 0xe5, 0x48, 0x48, 0xd0, 0x2c, 0xee, 0x98, 0x2f, 0xf9, 0x83, + 0xae, 0x43, 0x05, 0xdc, 0xa4, 0xae, 0xa2, 0x84, 0x53, 0x2d, 0x0f, 0x03, 0x63, 0x06, 0xb8, 0x48, + 0xbe, 0xe4, 0x68, 0x31, 0xa2, 0x01, 0xb9, 0x33, 0xe9, 0xdf, 0x10, 0x57, 0x9a, 0x3c, 0xab, 0xac, + 0xf2, 0x04, 0x32, 0x53, 0x99, 0x58, 0x56, 0x9b, 0x41, 0x7c, 0xf5, 0x86, 0x2e, 0xf0, 0xb2, 0x58, + 0x92, 0xa5, 0xc9, 0x2c, 0x8c, 0x2d, 0x3a, 0x78, 0x5e, 0x75, 0x8f, 0x6e, 0x2e, 0xda, 0x2d, 0xb3, + 0xb9, 0x89, 0x4f, 0x4f, 0xc5, 0x54, 0xd9, 0xe1, 0xb8, 0xc6, 0x3a, 0xdd, 0x6c, 0x74, 0x10, 0x2b, + 0x2f, 0x2b, 0xf1, 0x92, 0x72, 0xbc, 0xe3, 0x27, 0x77, 0x17, 0xef, 0x98, 0xc2, 0x98, 0xb8, 0x5f, + 0x7e, 0xec, 0x51, 0x8b, 0x2d, 0xf5, 0xae, 0x78, 0x66, 0xaa, 0xc4, 0xee, 0xa3, 0x03, 0x3c, 0x9f, + 0x3a, 0xc4, 0x28, 0xa3, 0x01, 0x58, 0x6e, 0x58, 0xbc, 0x48, 0x32, 0x28, 0xf0, 0x53, 0xfb, 0x08, + 0x0a, 0xfc, 0x37, 0x0a, 0xf2, 0xfc, 0x4b, 0xae, 0x40, 0x51, 0xca, 0xd9, 0x83, 0x11, 0x4f, 0x31, + 0xbe, 0x79, 0x51, 0x04, 0x72, 0x1e, 0x14, 0xb6, 0x4b, 0x10, 0xda, 0x06, 0x93, 0x34, 0x86, 0x51, + 0x30, 0xb5, 0x90, 0x00, 0x13, 0xe4, 0x75, 0x97, 0x5b, 0x66, 0x13, 0xa3, 0xde, 0x17, 0xa4, 0x58, + 0x16, 0x08, 0xe5, 0x41, 0xef, 0x25, 0x12, 0x72, 0x0b, 0x86, 0xfc, 0x73, 0xd2, 0x30, 0xe2, 0x2f, + 0x06, 0x43, 0x17, 0xb3, 0xb5, 0x88, 0xb5, 0x2e, 0x11, 0x91, 0x37, 0x00, 0xc2, 0xe9, 0x40, 0x58, + 0x5a, 0xb8, 0x54, 0xc8, 0xb3, 0x87, 0xbc, 0x54, 0x84, 0xd4, 0x6c, 0xe2, 0x94, 0xd5, 0xd1, 0x4f, + 0x09, 0x8a, 0x13, 0x67, 0x44, 0x87, 0x65, 0x05, 0x89, 0x16, 0x21, 0x0b, 0x70, 0x36, 0xa1, 0x81, + 0x22, 0x3e, 0x30, 0xa6, 0x85, 0x4f, 0x51, 0x5f, 0x79, 0x61, 0x4e, 0x94, 0x25, 0xcf, 0x41, 0xe1, + 0xbe, 0x56, 0x13, 0x31, 0x4a, 0x79, 0x78, 0xdb, 0x48, 0x00, 0x23, 0x86, 0x55, 0xff, 0x58, 0x3e, + 0xb1, 0x36, 0x31, 0xe9, 0x09, 0x56, 0x52, 0x0f, 0xa2, 0xf4, 0xfc, 0xfa, 0xb9, 0xf4, 0x24, 0x22, + 0x72, 0x0d, 0xca, 0x8b, 0x6c, 0x66, 0x68, 0xda, 0x2d, 0xd1, 0x9f, 0x18, 0x6d, 0xaa, 0x23, 0x60, + 0x5a, 0x80, 0x25, 0xb7, 0xa4, 0x4c, 0xb6, 0x52, 0xd8, 0x6f, 0x3f, 0x93, 0x6d, 0x3c, 0xfe, 0x35, + 0xe6, 0xb4, 0xbd, 0x15, 0xcb, 0x8c, 0x25, 0xca, 0xa4, 0xac, 0x8b, 0x61, 0x26, 0xac, 0xc0, 0x2a, + 0xed, 0xdf, 0xc9, 0x2a, 0x55, 0xff, 0x4e, 0x2e, 0x39, 0xce, 0xc8, 0xed, 0x64, 0x04, 0x5e, 0x5c, + 0x84, 0x02, 0xa0, 0x5c, 0x6b, 0x10, 0x8b, 0x37, 0x12, 0x4b, 0x37, 0xbf, 0xef, 0x58, 0xba, 0x85, + 0x3d, 0xc6, 0xd2, 0x55, 0xff, 0x9f, 0x62, 0x4f, 0x7f, 0xe8, 0x23, 0x89, 0xb9, 0xf6, 0x3a, 0xdb, + 0x59, 0xb1, 0xda, 0x2b, 0x6e, 0x62, 0x7f, 0xc0, 0xdd, 0x3d, 0x1b, 0x3a, 0x1f, 0x5a, 0xae, 0x16, + 0xa5, 0x24, 0xef, 0xc0, 0xb0, 0xff, 0x01, 0x18, 0xa3, 0x59, 0x8a, 0x2d, 0x1c, 0xac, 0x6a, 0xb1, + 0x68, 0xc6, 0x91, 0x02, 0xe4, 0x15, 0x18, 0x44, 0x9b, 0xa6, 0xa3, 0x37, 0xfd, 0x00, 0xde, 0x3c, + 0xe2, 0xb7, 0x0f, 0x94, 0xe3, 0x8a, 0x05, 0x94, 0xe4, 0x2b, 0x50, 0x12, 0x59, 0x2c, 0x78, 0x92, + 0xf7, 0x9b, 0xbb, 0x70, 0x20, 0xbf, 0x21, 0x67, 0xb0, 0xe0, 0xbb, 0x14, 0x04, 0x44, 0x76, 0x29, + 0x3c, 0x79, 0xc5, 0x12, 0x9c, 0x5b, 0x74, 0xa8, 0x81, 0x4f, 0x15, 0xa6, 0x1e, 0x77, 0x1c, 0x91, + 0x5f, 0x84, 0x8f, 0x72, 0x5c, 0xa4, 0x3a, 0x3e, 0x9a, 0x2d, 0x9f, 0x02, 0x2f, 0x47, 0x11, 0x4e, + 0x29, 0xce, 0x2c, 0x17, 0xde, 0x92, 0x7b, 0x74, 0x73, 0xc3, 0x76, 0x0c, 0x9e, 0x82, 0x43, 0xcc, + 0xdf, 0x42, 0xd0, 0xeb, 0x02, 0x25, 0x5b, 0x2e, 0xd1, 0x42, 0x97, 0x5f, 0x87, 0xa1, 0xfd, 0x66, + 0x81, 0xf8, 0x8d, 0x7c, 0xc6, 0xcb, 0xa2, 0x93, 0x9b, 0x88, 0x2f, 0xc8, 0x0e, 0xdd, 0x9f, 0x91, + 0x1d, 0xfa, 0xfb, 0xf9, 0x8c, 0x67, 0x53, 0x27, 0x3a, 0x8b, 0x6b, 0x20, 0x8c, 0x68, 0x16, 0xd7, + 0x30, 0x81, 0xae, 0x69, 0x68, 0x32, 0x51, 0x2c, 0xdf, 0x73, 0x69, 0xc7, 0x7c, 0xcf, 0xbf, 0x5c, + 0xe8, 0xf5, 0xac, 0xec, 0x54, 0xf6, 0x7b, 0x91, 0xfd, 0x2d, 0x18, 0x0a, 0x24, 0x5b, 0xab, 0xa2, + 0xd1, 0x33, 0x12, 0xe4, 0x9c, 0xe1, 0x60, 0x2c, 0x23, 0x11, 0x91, 0xeb, 0xbc, 0xad, 0x75, 0xf3, + 0x03, 0x9e, 0xfd, 0x60, 0x44, 0xc4, 0xb5, 0xd7, 0x3d, 0xbd, 0xe1, 0x9a, 0x1f, 0x50, 0x2d, 0x40, + 0xab, 0xff, 0x59, 0x3e, 0xf5, 0x6d, 0xde, 0x69, 0x1f, 0xed, 0xa1, 0x8f, 0x52, 0x84, 0xc8, 0x5f, + 0x15, 0x9e, 0x0a, 0x71, 0x0f, 0x42, 0xfc, 0xc3, 0x7c, 0xea, 0x1b, 0xcc, 0x53, 0x21, 0xee, 0x65, + 0xb6, 0x78, 0x01, 0x06, 0x35, 0x7b, 0xc3, 0x9d, 0xc4, 0x8d, 0x0d, 0x9f, 0x2b, 0x70, 0xa2, 0x76, + 0xec, 0x0d, 0xb7, 0x81, 0x5b, 0x16, 0x2d, 0x24, 0x50, 0x7f, 0x90, 0xef, 0xf1, 0x4a, 0xf5, 0x54, + 0xf0, 0x1f, 0xe5, 0x12, 0xf9, 0xdb, 0xf9, 0xc8, 0x2b, 0xd8, 0x93, 0x2b, 0xec, 0x9b, 0x00, 0xf5, + 0xe6, 0x1a, 0x6d, 0xeb, 0x52, 0x06, 0x29, 0x3c, 0x77, 0x70, 0x11, 0x2a, 0x32, 0x0f, 0x87, 0x24, + 0xea, 0xef, 0xe6, 0x63, 0xcf, 0x80, 0x4f, 0x65, 0xb7, 0x6b, 0xd9, 0x05, 0x5a, 0x27, 0x5e, 0x36, + 0x9f, 0x4a, 0x6e, 0xb7, 0x92, 0xfb, 0xc9, 0x7c, 0xec, 0x11, 0xf8, 0x89, 0x95, 0x1d, 0x1b, 0x80, + 0xc9, 0xc7, 0xe9, 0x27, 0x56, 0x93, 0x5e, 0x80, 0x41, 0x21, 0x87, 0x60, 0xa9, 0xe0, 0xf3, 0x3e, + 0x07, 0xe2, 0x29, 0x6b, 0x40, 0xa0, 0xfe, 0xf1, 0x3c, 0x44, 0x1f, 0xe7, 0x9f, 0x50, 0x1d, 0xfa, + 0xed, 0x7c, 0x34, 0x2c, 0xc1, 0xc9, 0xd5, 0x9f, 0x1b, 0x00, 0xf5, 0xee, 0x72, 0x53, 0x44, 0xb5, + 0xed, 0x97, 0x8e, 0xe9, 0x03, 0xa8, 0x26, 0x51, 0xa8, 0xff, 0x6f, 0x3e, 0x35, 0x56, 0xc2, 0xc9, + 0x15, 0xe0, 0xcb, 0x78, 0x2a, 0xde, 0xb4, 0xc2, 0x89, 0x1c, 0x0f, 0x21, 0xd9, 0xf8, 0x4b, 0xa4, + 0x1d, 0xf4, 0x09, 0xc9, 0xe7, 0x53, 0xcc, 0x35, 0x4c, 0x8a, 0x10, 0x9a, 0x6b, 0xf2, 0x35, 0x84, + 0x64, 0xb8, 0xfd, 0xfd, 0xfc, 0x4e, 0xa1, 0x25, 0x4e, 0xf2, 0xaa, 0x3a, 0xb0, 0xa8, 0x6f, 0x62, + 0x08, 0x44, 0xd6, 0x13, 0xc3, 0x3c, 0x29, 0x5e, 0x87, 0x83, 0xe4, 0xbb, 0x37, 0x41, 0xa5, 0xfe, + 0xf3, 0xfe, 0xf4, 0xb8, 0x06, 0x27, 0x57, 0x84, 0x57, 0xa0, 0xb8, 0xa8, 0x7b, 0x6b, 0x42, 0x93, + 0xf1, 0x4a, 0xaf, 0xa3, 0x7b, 0x6b, 0x1a, 0x42, 0xc9, 0x75, 0x28, 0x6b, 0xfa, 0x06, 0x3f, 0xf3, + 0x2c, 0x85, 0x09, 0x0b, 0x1d, 0x7d, 0xa3, 0xc1, 0xcf, 0x3d, 0x03, 0x34, 0x51, 0x83, 0x84, 0x99, + 0xfc, 0xe4, 0x1b, 0xb3, 0xb5, 0xf1, 0x84, 0x99, 0x41, 0x9a, 0xcc, 0x2b, 0x50, 0x9c, 0xb0, 0x8d, + 0x4d, 0xbc, 0xbe, 0x1a, 0xe6, 0x95, 0x2d, 0xdb, 0xc6, 0xa6, 0x86, 0x50, 0xf2, 0x53, 0x39, 0x18, + 0x98, 0xa1, 0xba, 0xc1, 0x46, 0xc8, 0x60, 0x2f, 0xaf, 0x93, 0x2f, 0x1d, 0x8e, 0xd7, 0xc9, 0xd9, + 0x35, 0x5e, 0x99, 0xac, 0x28, 0xa2, 0x7e, 0x72, 0x07, 0xca, 0x93, 0xba, 0x47, 0x57, 0x6d, 0x67, + 0x13, 0xfd, 0x68, 0x46, 0x43, 0xdf, 0xf8, 0x88, 0xfe, 0xf8, 0x44, 0xfc, 0x66, 0xac, 0x29, 0x7e, + 0x69, 0x41, 0x61, 0x26, 0x16, 0x91, 0xc2, 0x7f, 0x28, 0x14, 0x0b, 0xcf, 0xd5, 0x1f, 0x64, 0xea, + 0x0f, 0x8e, 0x95, 0x87, 0xd3, 0x8f, 0x95, 0xd1, 0x7a, 0x44, 0x5f, 0x3b, 0x4c, 0x53, 0x39, 0x82, + 0x8b, 0x3e, 0xb7, 0x1e, 0x11, 0x8a, 0x59, 0x2a, 0x35, 0x89, 0x44, 0xfd, 0x5e, 0x3f, 0xa4, 0xbe, + 0x82, 0x3e, 0x55, 0xf2, 0x53, 0x25, 0x0f, 0x95, 0xbc, 0x9a, 0x50, 0xf2, 0xcb, 0xc9, 0x77, 0xf5, + 0x1f, 0x53, 0x0d, 0xff, 0xb9, 0x62, 0x22, 0x2a, 0xc7, 0xc9, 0xde, 0x5d, 0x86, 0xd2, 0xeb, 0xdf, + 0x51, 0x7a, 0xc1, 0x80, 0x28, 0xed, 0x38, 0x20, 0x06, 0x76, 0x3b, 0x20, 0xca, 0x99, 0x03, 0x22, + 0x54, 0x90, 0xc1, 0x4c, 0x05, 0xa9, 0x89, 0x41, 0x03, 0xbd, 0x93, 0x83, 0x5c, 0xd9, 0xde, 0x1a, + 0x1f, 0x65, 0xa3, 0x29, 0x35, 0x2b, 0x08, 0xb2, 0x50, 0x7f, 0xaf, 0xd8, 0x23, 0x94, 0xce, 0x91, + 0xe8, 0xc8, 0xcb, 0x50, 0xa8, 0x74, 0x3a, 0x42, 0x3f, 0xce, 0x49, 0x51, 0x7c, 0x32, 0x4a, 0x31, + 0x6a, 0xf2, 0x06, 0x14, 0x2a, 0x0f, 0xeb, 0xf1, 0x84, 0x20, 0x95, 0x87, 0x75, 0xf1, 0x25, 0x99, + 0x65, 0x1f, 0xd6, 0xc9, 0x5b, 0x61, 0x64, 0xce, 0xb5, 0xae, 0xb5, 0x2e, 0x36, 0x8a, 0xc2, 0xdd, + 0xd6, 0x77, 0xc7, 0x69, 0x32, 0x14, 0xdb, 0x2e, 0xc6, 0x68, 0x63, 0xda, 0x54, 0xda, 0xbd, 0x36, + 0x0d, 0xec, 0xa8, 0x4d, 0xe5, 0xdd, 0x6a, 0xd3, 0xe0, 0x2e, 0xb4, 0x09, 0x76, 0xd4, 0xa6, 0xa1, + 0x83, 0x6b, 0x53, 0x07, 0x2e, 0x27, 0xc3, 0x9f, 0x05, 0x1a, 0xa1, 0x01, 0x49, 0x62, 0x85, 0x63, + 0x09, 0x5e, 0xfd, 0x77, 0x39, 0xb6, 0xb1, 0x81, 0xe8, 0x86, 0xcb, 0xf0, 0xb2, 0x7f, 0x5a, 0xb2, + 0xb4, 0xfa, 0x1b, 0xf9, 0xec, 0xa8, 0x6d, 0xc7, 0x73, 0x8a, 0xfb, 0x91, 0x54, 0x29, 0x15, 0xa3, + 0xaf, 0xe8, 0xb3, 0xa5, 0x1c, 0x63, 0x9b, 0x26, 0xb3, 0xef, 0xe4, 0xb2, 0x42, 0xc9, 0x1d, 0x48, + 0x62, 0x9f, 0x4e, 0x7a, 0xb4, 0xa1, 0x9f, 0xbe, 0x1b, 0x75, 0x65, 0x9b, 0x86, 0x61, 0x59, 0x88, + 0x42, 0x4a, 0xbb, 0x11, 0x70, 0xa4, 0x9c, 0xfa, 0x77, 0x72, 0x70, 0xee, 0x5e, 0x77, 0x99, 0x0a, + 0x0f, 0xb6, 0xa0, 0x19, 0xef, 0x03, 0x30, 0xb0, 0x70, 0x62, 0xc9, 0xa1, 0x13, 0xcb, 0x67, 0xe5, + 0x30, 0x70, 0xb1, 0x02, 0x37, 0x42, 0x6a, 0xee, 0xc0, 0xf2, 0x94, 0xef, 0xcc, 0xb9, 0xde, 0x5d, + 0xa6, 0x8d, 0x84, 0x27, 0x8b, 0xc4, 0xfd, 0xf2, 0xdb, 0xdc, 0x4d, 0x7e, 0xbf, 0x4e, 0x23, 0xbf, + 0x96, 0xcf, 0x8c, 0xbc, 0x77, 0x6c, 0x53, 0x44, 0xfe, 0x50, 0x6a, 0xaf, 0xc4, 0x53, 0x45, 0xa6, + 0x90, 0xc4, 0x38, 0xa6, 0x71, 0x49, 0x17, 0xd8, 0x31, 0x4f, 0x5c, 0xfa, 0x91, 0x0a, 0xec, 0x1f, + 0xe6, 0x32, 0x23, 0x24, 0x1e, 0x57, 0x81, 0xa9, 0xff, 0x4b, 0xc1, 0x0f, 0xcc, 0x78, 0xa0, 0x4f, + 0x78, 0x01, 0x06, 0xc5, 0xfb, 0xf4, 0xa8, 0x03, 0xae, 0x38, 0xca, 0xc3, 0xa3, 0xe1, 0x80, 0x80, + 0x2d, 0xf3, 0x92, 0x77, 0xb0, 0xe4, 0x80, 0x2b, 0x79, 0x06, 0x6b, 0x12, 0x09, 0x5b, 0xc8, 0xa7, + 0x1e, 0x9b, 0x1e, 0x5a, 0x05, 0xac, 0x2f, 0x0b, 0x7c, 0x21, 0xa7, 0x8f, 0x4d, 0x8f, 0xdb, 0x04, + 0x01, 0x9a, 0x2d, 0xd2, 0xf5, 0x30, 0x2d, 0xbb, 0x58, 0xa4, 0x5d, 0x91, 0x9d, 0x5e, 0x3c, 0x1b, + 0x7b, 0x01, 0x06, 0x85, 0x57, 0xab, 0x70, 0x33, 0x11, 0xad, 0x15, 0x7e, 0xb0, 0xd8, 0xda, 0x80, + 0x80, 0x71, 0xd4, 0xe8, 0x6a, 0xe8, 0x58, 0x87, 0x1c, 0x1d, 0x84, 0x68, 0x02, 0x43, 0x6e, 0xc1, + 0x68, 0xdd, 0xd3, 0x2d, 0x43, 0x77, 0x8c, 0x85, 0xae, 0xd7, 0xe9, 0x7a, 0xb2, 0x51, 0xea, 0x7a, + 0x86, 0xdd, 0xf5, 0xb4, 0x18, 0x05, 0xf9, 0x1c, 0x8c, 0xf8, 0x90, 0x29, 0xc7, 0xb1, 0x1d, 0xd9, + 0xf2, 0x70, 0x3d, 0x83, 0x3a, 0x8e, 0x16, 0x25, 0x20, 0x9f, 0x87, 0x91, 0x9a, 0xf5, 0xc8, 0xe6, + 0xf9, 0xfe, 0xef, 0x6b, 0xb3, 0xc2, 0x0e, 0xc1, 0xa7, 0x58, 0x66, 0x80, 0x68, 0x74, 0x9d, 0x96, + 0x16, 0x25, 0x54, 0xb7, 0xf3, 0xc9, 0xf8, 0x95, 0x27, 0x77, 0xd3, 0x72, 0x3d, 0xea, 0x4c, 0x87, + 0x1e, 0xa4, 0x68, 0x10, 0xca, 0xbe, 0xbc, 0xdc, 0x2e, 0xbc, 0x05, 0xe5, 0x7b, 0x74, 0x93, 0xfb, + 0x7d, 0x96, 0x42, 0x57, 0xe1, 0x75, 0x01, 0x93, 0x4f, 0x5c, 0x7d, 0x3a, 0xf5, 0xdb, 0xf9, 0x64, + 0x64, 0xce, 0x93, 0x2b, 0xec, 0xcf, 0xc1, 0x00, 0x8a, 0xb2, 0xe6, 0x1f, 0xf9, 0xa3, 0x00, 0x51, + 0xdc, 0x51, 0x0f, 0x64, 0x9f, 0x4c, 0xfd, 0xa5, 0x52, 0x3c, 0x5c, 0xeb, 0xc9, 0x95, 0xde, 0x9b, + 0x30, 0x34, 0x69, 0x5b, 0xae, 0xe9, 0x7a, 0xd4, 0x6a, 0xfa, 0x0a, 0xfb, 0x04, 0x33, 0xa8, 0x9a, + 0x21, 0x58, 0x7e, 0x83, 0x24, 0x51, 0xef, 0x47, 0x79, 0xc9, 0xab, 0x30, 0x88, 0x22, 0x47, 0x3f, + 0x69, 0x3e, 0xe1, 0xe1, 0x6d, 0xc1, 0x32, 0x03, 0xc6, 0x9d, 0xa4, 0x43, 0x52, 0x72, 0x1f, 0xca, + 0x93, 0x6b, 0x66, 0xcb, 0x70, 0xa8, 0x85, 0xfe, 0xc2, 0x52, 0x54, 0x8c, 0x68, 0x5f, 0xde, 0xc0, + 0x7f, 0x91, 0x96, 0x37, 0xa7, 0x29, 0x8a, 0x45, 0x5e, 0x61, 0x09, 0xd8, 0xe5, 0x9f, 0xcd, 0x03, + 0x84, 0x05, 0xc8, 0x33, 0x90, 0x0f, 0x32, 0x1e, 0xa3, 0x9b, 0x4a, 0x44, 0x83, 0xf2, 0xb8, 0x54, + 0x88, 0xb1, 0x9d, 0xdf, 0x71, 0x6c, 0xdf, 0x87, 0x12, 0x3f, 0xf1, 0x42, 0x4f, 0x72, 0x29, 0x82, + 0x64, 0x66, 0x83, 0x6f, 0x20, 0x3d, 0xdf, 0xcc, 0xa2, 0xe5, 0x19, 0xf1, 0xca, 0xe6, 0xcc, 0x2e, + 0x37, 0xa1, 0x1f, 0xff, 0x22, 0x57, 0xa1, 0xb8, 0xe4, 0x67, 0x4b, 0x1d, 0xe1, 0xb3, 0x74, 0x4c, + 0x7e, 0x88, 0x67, 0xdd, 0x34, 0x69, 0x5b, 0x1e, 0xab, 0x1a, 0x5b, 0x3d, 0x2c, 0xe4, 0x22, 0x60, + 0x11, 0xb9, 0x08, 0x98, 0xfa, 0x5f, 0xe5, 0x53, 0x02, 0x09, 0x9f, 0xdc, 0x61, 0xf2, 0x3a, 0x00, + 0x3e, 0xe9, 0x66, 0xf2, 0xf4, 0x9f, 0x68, 0xe0, 0x28, 0x41, 0x46, 0xa8, 0xb6, 0x91, 0x6d, 0x47, + 0x48, 0xac, 0xfe, 0xbd, 0x5c, 0x22, 0xfa, 0xec, 0x81, 0xe4, 0x28, 0x5b, 0x65, 0xf9, 0x7d, 0x9a, + 0xb1, 0x7e, 0x5f, 0x14, 0xf6, 0xd6, 0x17, 0xd1, 0x6f, 0x39, 0x04, 0xcb, 0xf4, 0x28, 0xbf, 0xe5, + 0x7b, 0xf9, 0xb4, 0x58, 0xbc, 0xc7, 0x53, 0xc5, 0x6f, 0x07, 0x46, 0x69, 0x31, 0x16, 0xfd, 0x1c, + 0xa1, 0xf1, 0x8c, 0xce, 0xc2, 0x4c, 0xfd, 0x2a, 0x9c, 0x89, 0x45, 0xa8, 0x15, 0xc9, 0x75, 0xaf, + 0xf6, 0x0e, 0x75, 0x9b, 0x1d, 0x0c, 0x20, 0x42, 0xa6, 0xfe, 0x7f, 0xb9, 0xde, 0xf1, 0x89, 0x8f, + 0x5c, 0x75, 0x52, 0x04, 0x50, 0xf8, 0xa3, 0x11, 0xc0, 0x21, 0x6c, 0x83, 0x8f, 0xb7, 0x00, 0x3e, + 0x26, 0x93, 0xc7, 0x47, 0x2d, 0x80, 0x5f, 0xca, 0xed, 0x18, 0x5e, 0xfa, 0xa8, 0x65, 0xa0, 0xfe, + 0x8f, 0xb9, 0xd4, 0x30, 0xd0, 0x07, 0x6a, 0xd7, 0x5b, 0x50, 0xe2, 0x6e, 0x35, 0xa2, 0x55, 0x52, + 0xe2, 0x2c, 0x06, 0xcd, 0x4a, 0x35, 0xcf, 0xb1, 0x64, 0x16, 0x06, 0x78, 0x1b, 0x0c, 0xd1, 0x1b, + 0x9f, 0xea, 0x11, 0x8b, 0xda, 0xc8, 0x9a, 0x1c, 0x05, 0x5a, 0xfd, 0xbb, 0xb9, 0x44, 0x54, 0xea, + 0x23, 0xfc, 0xb6, 0x70, 0xaa, 0x2e, 0xec, 0x7e, 0xaa, 0x56, 0xff, 0x59, 0x3e, 0x3d, 0x28, 0xf6, + 0x11, 0x7e, 0xc8, 0x61, 0x1c, 0xa7, 0xed, 0x6f, 0xdd, 0x5a, 0x82, 0xd1, 0xa8, 0x2c, 0xc4, 0xb2, + 0xf5, 0x74, 0x7a, 0x68, 0xf0, 0x8c, 0x56, 0xc4, 0x78, 0xa8, 0xdf, 0xcd, 0x25, 0xe3, 0x79, 0x1f, + 0xf9, 0xfc, 0xb4, 0x3f, 0x6d, 0x89, 0x7e, 0xca, 0xc7, 0x64, 0xad, 0x39, 0x8c, 0x4f, 0xf9, 0x98, + 0xac, 0x1a, 0xfb, 0xfb, 0x94, 0x5f, 0xc9, 0x67, 0x85, 0x43, 0x3f, 0xf2, 0x0f, 0xfa, 0xb2, 0x2c, + 0x64, 0xde, 0x32, 0xf1, 0x69, 0xcf, 0x64, 0xc5, 0x1f, 0xcf, 0xe0, 0x99, 0xe0, 0xb3, 0xbf, 0x31, + 0x9e, 0x2a, 0xac, 0x8f, 0x89, 0x22, 0x1f, 0x0f, 0x61, 0x7d, 0x4c, 0x86, 0xca, 0xc7, 0x4f, 0x58, + 0x7f, 0x33, 0xbf, 0xdb, 0x18, 0xfc, 0xa7, 0xc2, 0x4b, 0x08, 0xef, 0x9b, 0xf9, 0x64, 0x6e, 0x88, + 0x23, 0x17, 0xd3, 0x34, 0x94, 0x44, 0x96, 0x8a, 0x4c, 0xe1, 0x70, 0x7c, 0x96, 0x45, 0x23, 0xbe, + 0xe3, 0x36, 0x88, 0x8b, 0x9c, 0xdd, 0x89, 0x84, 0xd3, 0xaa, 0x3f, 0xc8, 0xc5, 0x12, 0x29, 0x1c, + 0xc9, 0x11, 0xc2, 0xbe, 0x96, 0x24, 0xf2, 0xb6, 0x7f, 0x98, 0x59, 0x8c, 0x05, 0xb2, 0x0e, 0xbe, + 0xa7, 0x4a, 0x3d, 0xdd, 0x6c, 0xc5, 0xcb, 0x8b, 0x98, 0x00, 0xdf, 0xce, 0xc3, 0xd9, 0x04, 0x29, + 0xb9, 0x1a, 0x09, 0xa5, 0x83, 0xc7, 0x92, 0x31, 0xe7, 0x71, 0x1e, 0x54, 0x67, 0x0f, 0x27, 0xa9, + 0x57, 0xa1, 0x58, 0xd5, 0x37, 0xf9, 0xb7, 0xf5, 0x73, 0x96, 0x86, 0xbe, 0x29, 0x9f, 0xb8, 0x21, + 0x9e, 0x2c, 0xc3, 0x05, 0x7e, 0x1f, 0x62, 0xda, 0xd6, 0x92, 0xd9, 0xa6, 0x35, 0x6b, 0xce, 0x6c, + 0xb5, 0x4c, 0x57, 0x5c, 0xea, 0xbd, 0xb0, 0xbd, 0x35, 0x7e, 0xcd, 0xb3, 0x3d, 0xbd, 0xd5, 0xa0, + 0x3e, 0x59, 0xc3, 0x33, 0xdb, 0xb4, 0x61, 0x5a, 0x8d, 0x36, 0x52, 0x4a, 0x2c, 0xd3, 0x59, 0x91, + 0x1a, 0x8f, 0x59, 0x5e, 0x6f, 0xea, 0x96, 0x45, 0x8d, 0x9a, 0x35, 0xb1, 0xe9, 0x51, 0x7e, 0x19, + 0x58, 0xe0, 0x47, 0x82, 0xfc, 0x6d, 0x38, 0x47, 0x33, 0xc6, 0xcb, 0x8c, 0x40, 0x4b, 0x29, 0xa4, + 0xfe, 0xad, 0x62, 0x4a, 0x0e, 0x8d, 0x63, 0xa4, 0x3e, 0x7e, 0x4f, 0x17, 0x77, 0xe8, 0xe9, 0x9b, + 0x30, 0x20, 0x82, 0xc2, 0x8a, 0x0b, 0x06, 0x74, 0x66, 0x7f, 0xc4, 0x41, 0xf2, 0x0d, 0x8d, 0xa0, + 0x22, 0x2d, 0xb8, 0xbc, 0xc4, 0xba, 0x29, 0xbd, 0x33, 0x4b, 0xfb, 0xe8, 0xcc, 0x1e, 0xfc, 0xc8, + 0x7b, 0x70, 0x09, 0xb1, 0x29, 0xdd, 0x3a, 0x80, 0x55, 0x61, 0x8c, 0x2a, 0x5e, 0x55, 0x7a, 0xe7, + 0x66, 0x95, 0x27, 0x5f, 0x86, 0xe1, 0x60, 0x80, 0x98, 0xd4, 0x15, 0x37, 0x17, 0x3d, 0xc6, 0x19, + 0x0f, 0x00, 0xc7, 0xc0, 0xe8, 0x42, 0x16, 0x0d, 0x22, 0x16, 0xe1, 0xa5, 0xfe, 0x0f, 0xb9, 0x5e, + 0xb9, 0x3c, 0x8e, 0x7c, 0x56, 0x7e, 0x1b, 0x06, 0x0c, 0xfe, 0x51, 0x42, 0xa7, 0x7a, 0x67, 0xfb, + 0xe0, 0xa4, 0x9a, 0x5f, 0x46, 0xfd, 0xa7, 0xb9, 0x9e, 0x29, 0x44, 0x8e, 0xfb, 0xe7, 0x7d, 0xb3, + 0x90, 0xf1, 0x79, 0x62, 0x12, 0xbd, 0x0e, 0x63, 0x66, 0x18, 0xe3, 0xbc, 0x11, 0x86, 0x9f, 0xd2, + 0xce, 0x48, 0x70, 0x1c, 0x5d, 0xb7, 0xe1, 0xa2, 0xef, 0xf8, 0xe8, 0xf8, 0x1e, 0x62, 0x6e, 0xa3, + 0xeb, 0x98, 0x7c, 0x5c, 0x6a, 0xe7, 0xdd, 0x98, 0xfb, 0x98, 0x7b, 0xdf, 0x31, 0x59, 0x05, 0xba, + 0xb7, 0x46, 0x2d, 0xbd, 0xb1, 0x61, 0x3b, 0xeb, 0x18, 0x65, 0x94, 0x0f, 0x4e, 0xed, 0x0c, 0x87, + 0x3f, 0xf4, 0xc1, 0xe4, 0x39, 0x18, 0x59, 0x6d, 0x75, 0x69, 0x10, 0xd7, 0x91, 0xdf, 0xf5, 0x69, + 0xc3, 0x0c, 0x18, 0xdc, 0x90, 0x3c, 0x05, 0x80, 0x44, 0x1e, 0x26, 0x78, 0xc1, 0x8b, 0x3d, 0x6d, + 0x90, 0x41, 0x96, 0x44, 0x77, 0x5d, 0xe6, 0x5a, 0xcd, 0x85, 0xd4, 0x68, 0xd9, 0xd6, 0x6a, 0xc3, + 0xa3, 0x4e, 0x1b, 0x1b, 0x8a, 0xce, 0x0c, 0xda, 0x45, 0xa4, 0xc0, 0xab, 0x13, 0x77, 0xd6, 0xb6, + 0x56, 0x97, 0xa8, 0xd3, 0x66, 0x4d, 0x7d, 0x01, 0x88, 0x68, 0xaa, 0x83, 0x87, 0x1e, 0xfc, 0xe3, + 0xd0, 0x9b, 0x41, 0x13, 0x1f, 0xc1, 0x4f, 0x43, 0xf0, 0xc3, 0xc6, 0x61, 0x88, 0x07, 0xb7, 0xe3, + 0x42, 0x43, 0x17, 0x06, 0x0d, 0x38, 0x08, 0xe5, 0x75, 0x11, 0x84, 0x77, 0x05, 0xf7, 0xea, 0xd6, + 0xc4, 0x2f, 0xf5, 0xc3, 0x42, 0x5a, 0xd6, 0x93, 0x03, 0x29, 0x5a, 0x38, 0xad, 0xe6, 0xf7, 0x34, + 0xad, 0x9e, 0xb1, 0xba, 0xed, 0x86, 0xde, 0xe9, 0x34, 0x56, 0xcc, 0x16, 0x3e, 0xab, 0xc2, 0x85, + 0x4f, 0x1b, 0xb1, 0xba, 0xed, 0x4a, 0xa7, 0x33, 0xcd, 0x81, 0xe4, 0x79, 0x38, 0xcb, 0xe8, 0xb0, + 0x93, 0x02, 0xca, 0x22, 0x52, 0x32, 0x06, 0x18, 0x1d, 0xd6, 0xa7, 0x7d, 0x02, 0xca, 0x82, 0x27, + 0x5f, 0xab, 0xfa, 0xb5, 0x01, 0xce, 0xcc, 0x65, 0x3d, 0x17, 0xb0, 0xe1, 0x93, 0x6b, 0xbf, 0x36, + 0xe8, 0x97, 0xc7, 0x18, 0xc8, 0x56, 0xb7, 0xcd, 0x23, 0x62, 0x0d, 0x20, 0x32, 0xf8, 0x4d, 0xae, + 0xc2, 0x28, 0xe3, 0x12, 0x08, 0x8c, 0x87, 0x8d, 0xed, 0xd7, 0x62, 0x50, 0x72, 0x0b, 0xce, 0x47, + 0x20, 0xdc, 0x06, 0xe5, 0xcf, 0x04, 0xfa, 0xb5, 0x54, 0x9c, 0xfa, 0xbb, 0x85, 0x68, 0x2e, 0x96, + 0x23, 0xe8, 0x88, 0x4b, 0x30, 0x60, 0x3b, 0xab, 0x8d, 0xae, 0xd3, 0x12, 0x63, 0xaf, 0x64, 0x3b, + 0xab, 0xf7, 0x9d, 0x16, 0xb9, 0x00, 0x25, 0xd6, 0x3b, 0xa6, 0x21, 0x86, 0x58, 0xbf, 0xde, 0xe9, + 0xd4, 0x0c, 0x52, 0xe1, 0x1d, 0x82, 0x21, 0x47, 0x1b, 0x4d, 0xdc, 0xda, 0x73, 0xa7, 0x84, 0x7e, + 0xbe, 0xe2, 0x25, 0x90, 0xd8, 0x4f, 0x18, 0x88, 0x94, 0x1f, 0x04, 0xc4, 0x58, 0x18, 0xb8, 0x2d, + 0x31, 0x78, 0x9f, 0xc4, 0x59, 0x08, 0x64, 0xc8, 0x82, 0x6f, 0x62, 0x0c, 0x52, 0x05, 0x12, 0x52, + 0xb5, 0x6d, 0xc3, 0x5c, 0x31, 0x29, 0x7f, 0xd5, 0xd1, 0xcf, 0x2f, 0x7e, 0x93, 0x58, 0x6d, 0xcc, + 0x67, 0x32, 0x27, 0x20, 0xe4, 0x4d, 0xae, 0x84, 0x9c, 0x0e, 0xd7, 0x3e, 0xde, 0xb7, 0xdc, 0x4e, + 0x8b, 0xa1, 0x50, 0x33, 0xb1, 0x3c, 0x2e, 0x84, 0xea, 0x5f, 0x2a, 0x26, 0x13, 0xf2, 0x1c, 0x89, + 0x5d, 0x33, 0x03, 0x20, 0xf2, 0x6d, 0x85, 0x97, 0x6b, 0x81, 0xc7, 0x79, 0x88, 0xc9, 0xe0, 0x21, + 0x95, 0x25, 0xd7, 0xa1, 0xcc, 0xbf, 0xa8, 0x56, 0x15, 0xf6, 0x0e, 0xba, 0x88, 0xb9, 0x1d, 0x73, + 0x65, 0x05, 0xfd, 0xc9, 0x02, 0x34, 0xb9, 0x0a, 0x03, 0xd5, 0xf9, 0x7a, 0xbd, 0x32, 0xef, 0xdf, + 0x14, 0xe3, 0xfb, 0x12, 0xc3, 0x72, 0x1b, 0xae, 0x6e, 0xb9, 0x9a, 0x8f, 0x24, 0xcf, 0x41, 0xa9, + 0xb6, 0x88, 0x64, 0xfc, 0xd5, 0xe4, 0xd0, 0xf6, 0xd6, 0xf8, 0x80, 0xd9, 0xe1, 0x54, 0x02, 0x85, + 0xf5, 0x3e, 0xa8, 0x55, 0x25, 0x77, 0x09, 0x5e, 0xef, 0x23, 0xd3, 0xc0, 0x6b, 0x67, 0x2d, 0x40, + 0x93, 0x57, 0x60, 0xb8, 0x4e, 0x1d, 0x53, 0x6f, 0xcd, 0x77, 0x71, 0xab, 0x28, 0x85, 0x52, 0x74, + 0x11, 0xde, 0xb0, 0x10, 0xa1, 0x45, 0xc8, 0xc8, 0x15, 0x28, 0xce, 0x98, 0x96, 0xff, 0x84, 0x01, + 0x7d, 0xdc, 0xd7, 0x4c, 0xcb, 0xd3, 0x10, 0x4a, 0x9e, 0x83, 0xc2, 0xdd, 0xa5, 0x9a, 0xf0, 0x04, + 0x43, 0x5e, 0xef, 0x7b, 0x91, 0xb0, 0x8c, 0x77, 0x97, 0x6a, 0xe4, 0x15, 0x18, 0x64, 0x8b, 0x18, + 0xb5, 0x9a, 0xd4, 0x55, 0x86, 0xf0, 0x63, 0x78, 0x18, 0x41, 0x1f, 0x28, 0xfb, 0x74, 0x04, 0x94, + 0xea, 0xff, 0x91, 0x4f, 0xcf, 0x98, 0x74, 0x04, 0x43, 0x7d, 0x9f, 0xb7, 0xc8, 0x31, 0x05, 0x2b, + 0x1e, 0x40, 0xc1, 0x56, 0xe0, 0x4c, 0xc5, 0x68, 0x9b, 0x56, 0x05, 0x7f, 0xba, 0x73, 0xd3, 0x15, + 0x9c, 0x3a, 0xa4, 0xe7, 0x79, 0x31, 0xb4, 0xf8, 0x1e, 0x1e, 0xf0, 0x97, 0xa1, 0x1a, 0x3a, 0xc7, + 0x35, 0xda, 0x2b, 0x7a, 0xa3, 0xc9, 0x93, 0x0d, 0x69, 0x71, 0xa6, 0xea, 0xcf, 0xe4, 0x77, 0x48, + 0xf2, 0x74, 0x12, 0xa5, 0xaf, 0x7e, 0x2b, 0xdf, 0x3b, 0xcf, 0xd6, 0x89, 0x14, 0xca, 0x1f, 0xe6, + 0x53, 0xb2, 0x5e, 0x1d, 0x48, 0x12, 0xd7, 0xa1, 0xcc, 0xd9, 0x04, 0x6e, 0xbc, 0x38, 0x9b, 0x71, + 0x65, 0xc5, 0x59, 0xd4, 0x47, 0x93, 0x79, 0x38, 0x5f, 0x59, 0x59, 0xa1, 0x4d, 0x2f, 0x0c, 0xfd, + 0x3c, 0x1f, 0x06, 0x61, 0xe5, 0xa1, 0x6e, 0x05, 0x3e, 0x0c, 0x1d, 0x8d, 0xc1, 0x46, 0x52, 0xcb, + 0x91, 0x25, 0xb8, 0x18, 0x87, 0xd7, 0xf9, 0x16, 0xa0, 0x28, 0x45, 0xbf, 0x4d, 0x70, 0xe4, 0xff, + 0x69, 0x19, 0x65, 0xd3, 0x5a, 0x89, 0x53, 0x75, 0x7f, 0xaf, 0x56, 0xe2, 0xbc, 0x9d, 0x5a, 0x4e, + 0xfd, 0x76, 0x41, 0x4e, 0x0e, 0x76, 0x72, 0x1d, 0xae, 0x6e, 0x47, 0xdc, 0xac, 0x77, 0x3b, 0x64, + 0x5e, 0x11, 0x11, 0x44, 0x8c, 0xae, 0xe3, 0x7b, 0x24, 0x06, 0x11, 0x0c, 0x10, 0x28, 0xaf, 0x43, + 0x01, 0x25, 0xa9, 0x41, 0xb1, 0xe2, 0xac, 0x72, 0xf3, 0x76, 0xa7, 0x47, 0x55, 0xba, 0xb3, 0xea, + 0xa6, 0x3f, 0xaa, 0x62, 0x2c, 0xd4, 0x3f, 0x95, 0xef, 0x91, 0xcf, 0xeb, 0x44, 0x4e, 0x22, 0x7f, + 0x36, 0x9f, 0x95, 0x99, 0xeb, 0xb8, 0xba, 0x8e, 0x7d, 0xc4, 0xc2, 0x39, 0xde, 0x7e, 0x75, 0x87, + 0x2c, 0x9c, 0x8c, 0x2c, 0x61, 0xa7, 0xc2, 0xf9, 0x30, 0x9f, 0x95, 0x28, 0xed, 0xc4, 0xce, 0x32, + 0x19, 0xb9, 0xd9, 0x4e, 0x75, 0xe5, 0x17, 0xf2, 0x99, 0xe9, 0xe9, 0x4e, 0xa5, 0xa3, 0x7e, 0x3d, + 0x9f, 0x99, 0x5e, 0xef, 0x44, 0x0e, 0xa5, 0x54, 0x6d, 0x39, 0x1d, 0x4b, 0x42, 0x3a, 0xbf, 0x9f, + 0x4f, 0x4f, 0x68, 0x78, 0x04, 0xaa, 0x72, 0x18, 0x1e, 0x78, 0xbe, 0x40, 0x8b, 0x07, 0x12, 0x68, + 0xff, 0xa1, 0x0a, 0xf4, 0xc8, 0xc6, 0xde, 0x27, 0x55, 0xa0, 0x87, 0x30, 0x78, 0x4f, 0xb2, 0x40, + 0x7f, 0xba, 0x90, 0x4c, 0xe2, 0x79, 0x22, 0x8f, 0x28, 0x27, 0xa0, 0xec, 0x9f, 0x61, 0x08, 0x81, + 0xee, 0xba, 0x3b, 0xfd, 0x72, 0xe4, 0x1d, 0x38, 0x13, 0xca, 0x52, 0x8e, 0x4c, 0x85, 0xd7, 0x1b, + 0x4d, 0x86, 0x6a, 0xbc, 0xcf, 0x70, 0x22, 0x84, 0x4a, 0x9c, 0x5a, 0xfd, 0x41, 0x21, 0x99, 0x09, + 0xf5, 0xb4, 0x37, 0xf6, 0xd9, 0x1b, 0xf7, 0xe1, 0xe2, 0x64, 0xd7, 0x71, 0xa8, 0xe5, 0xa5, 0x77, + 0x0a, 0x1e, 0x2e, 0x37, 0x39, 0x45, 0x23, 0xd9, 0x39, 0x19, 0x85, 0x19, 0x5b, 0xe1, 0x7d, 0x1f, + 0x67, 0x3b, 0x10, 0xb2, 0xed, 0x72, 0x8a, 0x34, 0xb6, 0xe9, 0x85, 0xd5, 0xbf, 0x9f, 0x4f, 0xe6, + 0xae, 0x3d, 0xed, 0xfa, 0xfd, 0x75, 0xbd, 0xfa, 0x61, 0x21, 0x9e, 0xbf, 0xf7, 0x74, 0x81, 0xd8, + 0x7f, 0x77, 0xf8, 0x92, 0xc4, 0x71, 0x23, 0x7d, 0x85, 0x0f, 0xcf, 0xfa, 0x0a, 0x1f, 0xaf, 0xfe, + 0x5a, 0x31, 0x9e, 0x0b, 0xf9, 0xb4, 0x3b, 0x8e, 0xae, 0x3b, 0xc8, 0x02, 0x9c, 0x17, 0x73, 0x9b, + 0x0f, 0xc2, 0x14, 0x05, 0x62, 0xfe, 0xe2, 0x99, 0xce, 0xc4, 0xb4, 0xd8, 0x75, 0xa9, 0xd3, 0xf0, + 0x74, 0x77, 0xbd, 0x81, 0x39, 0x0d, 0xb4, 0xd4, 0x82, 0x8c, 0xa1, 0x98, 0xd5, 0xa2, 0x0c, 0xcb, + 0x21, 0x43, 0x7f, 0x42, 0x4c, 0x30, 0x4c, 0x2b, 0xa8, 0xfe, 0x76, 0x0e, 0xc6, 0xe2, 0x9f, 0x43, + 0x6e, 0x40, 0x99, 0xfd, 0x0e, 0x9e, 0x85, 0x4b, 0x79, 0x94, 0x39, 0x47, 0x7e, 0x65, 0xec, 0xd3, + 0x90, 0x57, 0x61, 0x10, 0x6f, 0xe7, 0xb1, 0x40, 0x3e, 0x7c, 0x8d, 0x1f, 0x16, 0xc0, 0xe4, 0x9e, + 0xbc, 0x58, 0x48, 0x4a, 0xde, 0x84, 0xa1, 0x5a, 0xe8, 0x86, 0x24, 0xee, 0x64, 0xd0, 0xfb, 0x51, + 0x2a, 0x19, 0x12, 0x68, 0x32, 0xb5, 0xfa, 0xdd, 0x7c, 0x3c, 0x67, 0xf7, 0xa9, 0xaa, 0xef, 0x4f, + 0xd5, 0x9f, 0x9f, 0xe3, 0xaa, 0x7e, 0xcf, 0xb4, 0x0c, 0xf2, 0x04, 0x5c, 0xb8, 0x5f, 0x9f, 0xd2, + 0x1a, 0xf7, 0x6a, 0xf3, 0xd5, 0xc6, 0xfd, 0xf9, 0xfa, 0xe2, 0xd4, 0x64, 0x6d, 0xba, 0x36, 0x55, + 0x1d, 0xeb, 0x23, 0xe7, 0xe0, 0x4c, 0x88, 0x9a, 0xb9, 0x3f, 0x57, 0x99, 0x1f, 0xcb, 0x91, 0xb3, + 0x30, 0x12, 0x02, 0x27, 0x16, 0x96, 0xc6, 0xf2, 0xcf, 0x7f, 0x06, 0x86, 0xd0, 0xfd, 0x8a, 0x5f, + 0x17, 0x93, 0x61, 0x28, 0x2f, 0x4c, 0xd4, 0xa7, 0xb4, 0x07, 0xc8, 0x04, 0xa0, 0x54, 0x9d, 0x9a, + 0x67, 0x0c, 0x73, 0xcf, 0xff, 0xdf, 0x39, 0x80, 0xfa, 0xf4, 0xd2, 0xa2, 0x20, 0x1c, 0x82, 0x81, + 0xda, 0xfc, 0x83, 0xca, 0x6c, 0x8d, 0xd1, 0x95, 0xa1, 0xb8, 0xb0, 0x38, 0xc5, 0x6a, 0x18, 0x84, + 0xfe, 0xc9, 0xd9, 0x85, 0xfa, 0xd4, 0x58, 0x9e, 0x01, 0xb5, 0xa9, 0x4a, 0x75, 0xac, 0xc0, 0x80, + 0x0f, 0xb5, 0xda, 0xd2, 0xd4, 0x58, 0x91, 0xfd, 0x39, 0x5b, 0x5f, 0xaa, 0x2c, 0x8d, 0xf5, 0xb3, + 0x3f, 0xa7, 0xf1, 0xcf, 0x12, 0x63, 0x56, 0x9f, 0x5a, 0xc2, 0x1f, 0x03, 0xac, 0x09, 0xd3, 0xfe, + 0xaf, 0x32, 0x43, 0x31, 0xd6, 0xd5, 0x9a, 0x36, 0x36, 0xc8, 0x7e, 0x30, 0x96, 0xec, 0x07, 0xb0, + 0xc6, 0x69, 0x53, 0x73, 0x0b, 0x0f, 0xa6, 0xc6, 0x86, 0x18, 0xaf, 0xb9, 0x7b, 0x0c, 0x3c, 0xcc, + 0xfe, 0xd4, 0xe6, 0xd8, 0x9f, 0x23, 0x8c, 0x93, 0x36, 0x55, 0x99, 0x5d, 0xac, 0x2c, 0xcd, 0x8c, + 0x8d, 0xb2, 0xf6, 0x20, 0xcf, 0x33, 0xbc, 0xe4, 0x7c, 0x65, 0x6e, 0x6a, 0x6c, 0x4c, 0xd0, 0x54, + 0x67, 0x6b, 0xf3, 0xf7, 0xc6, 0xce, 0x62, 0x43, 0xde, 0x9b, 0xc3, 0x1f, 0x84, 0x15, 0xc0, 0xbf, + 0xce, 0x3d, 0xff, 0xc3, 0x50, 0x5a, 0xa8, 0xe3, 0x28, 0xb8, 0x04, 0xe7, 0x16, 0xea, 0x8d, 0xa5, + 0xf7, 0x16, 0xa7, 0x62, 0xf2, 0x3e, 0x0b, 0x23, 0x3e, 0x62, 0xb6, 0x36, 0x7f, 0xff, 0x4b, 0x5c, + 0xda, 0x3e, 0x68, 0xae, 0x32, 0xb9, 0x50, 0x1f, 0xcb, 0xb3, 0x5e, 0xf1, 0x41, 0x0f, 0x6b, 0xf3, + 0xd5, 0x85, 0x87, 0xf5, 0xb1, 0xc2, 0xf3, 0x8f, 0x60, 0x98, 0xe7, 0x76, 0x5c, 0x70, 0xcc, 0x55, + 0xd3, 0x22, 0x4f, 0xc1, 0x13, 0xd5, 0xa9, 0x07, 0xb5, 0xc9, 0xa9, 0xc6, 0x82, 0x56, 0xbb, 0x53, + 0x9b, 0x8f, 0xd5, 0x74, 0x01, 0xce, 0x46, 0xd1, 0x95, 0xc5, 0xda, 0x58, 0x8e, 0x5c, 0x04, 0x12, + 0x05, 0xdf, 0xad, 0xcc, 0x4d, 0x8f, 0xe5, 0x89, 0x02, 0xe7, 0xa3, 0xf0, 0xda, 0xfc, 0xd2, 0xfd, + 0xf9, 0xa9, 0xb1, 0xc2, 0xf3, 0x7f, 0x31, 0x07, 0x17, 0x52, 0xe3, 0xff, 0x12, 0x15, 0x9e, 0x9e, + 0x9a, 0xad, 0xd4, 0x97, 0x6a, 0x93, 0xf5, 0xa9, 0x8a, 0x36, 0x39, 0xd3, 0x98, 0xac, 0x2c, 0x4d, + 0xdd, 0x59, 0xd0, 0xde, 0x6b, 0xdc, 0x99, 0x9a, 0x9f, 0xd2, 0x2a, 0xb3, 0x63, 0x7d, 0xe4, 0x39, + 0x18, 0xcf, 0xa0, 0xa9, 0x4f, 0x4d, 0xde, 0xd7, 0x6a, 0x4b, 0xef, 0x8d, 0xe5, 0xc8, 0xb3, 0xf0, + 0x54, 0x26, 0x11, 0xfb, 0x3d, 0x96, 0x27, 0x4f, 0xc3, 0xe5, 0x2c, 0x92, 0x77, 0x67, 0xc7, 0x0a, + 0xcf, 0xff, 0x7c, 0x0e, 0x48, 0x32, 0x80, 0x2b, 0x79, 0x06, 0xae, 0x30, 0xbd, 0x68, 0x64, 0x37, + 0xf0, 0x59, 0x78, 0x2a, 0x95, 0x42, 0x6a, 0xde, 0x38, 0x3c, 0x99, 0x41, 0x22, 0x1a, 0x77, 0x05, + 0x94, 0x74, 0x02, 0x6c, 0xda, 0x6f, 0xe5, 0xe0, 0x42, 0xaa, 0x87, 0x06, 0xb9, 0x06, 0x9f, 0xaa, + 0x54, 0xe7, 0x58, 0xdf, 0x4c, 0x2e, 0xd5, 0x16, 0xe6, 0xeb, 0x8d, 0xb9, 0xe9, 0x4a, 0x83, 0x69, + 0xdf, 0xfd, 0x7a, 0xac, 0x37, 0xaf, 0x82, 0xda, 0x83, 0x72, 0x72, 0xa6, 0x32, 0x7f, 0x87, 0x0d, + 0x3f, 0xf2, 0x29, 0x78, 0x26, 0x93, 0x6e, 0x6a, 0xbe, 0x32, 0x31, 0x3b, 0x55, 0x1d, 0xcb, 0x93, + 0x4f, 0xc3, 0xb3, 0x99, 0x54, 0xd5, 0x5a, 0x9d, 0x93, 0x15, 0x26, 0xaa, 0xdf, 0xfd, 0x9f, 0x9e, + 0xee, 0xfb, 0xee, 0x1f, 0x3c, 0x9d, 0xfb, 0x07, 0x7f, 0xf0, 0x74, 0xee, 0x9f, 0xfd, 0xc1, 0xd3, + 0xb9, 0x2f, 0xdf, 0xda, 0x4b, 0x60, 0x5e, 0x3e, 0x6d, 0x2d, 0x97, 0xf0, 0xb6, 0xf4, 0xe5, 0xff, + 0x3f, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x0a, 0xc6, 0x45, 0xa0, 0x7b, 0x01, 0x00, } func (m *Metadata) Marshal() (dAtA []byte, err error) { @@ -30515,6 +30774,75 @@ func (m *OneOf_CrownJewelDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) } return len(dAtA) - i, nil } +func (m *OneOf_UserTaskCreate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OneOf_UserTaskCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.UserTaskCreate != nil { + { + size, err := m.UserTaskCreate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xb + i-- + dAtA[i] = 0xe2 + } + return len(dAtA) - i, nil +} +func (m *OneOf_UserTaskUpdate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OneOf_UserTaskUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.UserTaskUpdate != nil { + { + size, err := m.UserTaskUpdate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xb + i-- + dAtA[i] = 0xea + } + return len(dAtA) - i, nil +} +func (m *OneOf_UserTaskDelete) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OneOf_UserTaskDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.UserTaskDelete != nil { + { + size, err := m.UserTaskDelete.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xb + i-- + dAtA[i] = 0xf2 + } + return len(dAtA) - i, nil +} func (m *StreamStatus) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -30539,12 +30867,12 @@ func (m *StreamStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n645, err645 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastUploadTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUploadTime):]) - if err645 != nil { - return 0, err645 + n648, err648 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastUploadTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUploadTime):]) + if err648 != nil { + return 0, err648 } - i -= n645 - i = encodeVarintEvents(dAtA, i, uint64(n645)) + i -= n648 + i = encodeVarintEvents(dAtA, i, uint64(n648)) i-- dAtA[i] = 0x1a if m.LastEventIndex != 0 { @@ -30703,12 +31031,12 @@ func (m *Identity) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0xc2 } } - n649, err649 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PreviousIdentityExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousIdentityExpires):]) - if err649 != nil { - return 0, err649 + n652, err652 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PreviousIdentityExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousIdentityExpires):]) + if err652 != nil { + return 0, err652 } - i -= n649 - i = encodeVarintEvents(dAtA, i, uint64(n649)) + i -= n652 + i = encodeVarintEvents(dAtA, i, uint64(n652)) i-- dAtA[i] = 0x1 i-- @@ -30856,12 +31184,12 @@ func (m *Identity) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x4a } - n653, err653 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) - if err653 != nil { - return 0, err653 + n656, err656 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) + if err656 != nil { + return 0, err656 } - i -= n653 - i = encodeVarintEvents(dAtA, i, uint64(n653)) + i -= n656 + i = encodeVarintEvents(dAtA, i, uint64(n656)) i-- dAtA[i] = 0x42 if len(m.KubernetesUsers) > 0 { @@ -37097,6 +37425,319 @@ func (m *CrownJewelDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *UserTaskCreate) 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 *UserTaskCreate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UserTaskCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + { + size, err := m.UserTaskMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + { + size, err := m.ConnectionMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + { + size, err := m.UserMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.ResourceMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *UserTaskUpdate) 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 *UserTaskUpdate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UserTaskUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.UpdatedUserTaskState) > 0 { + i -= len(m.UpdatedUserTaskState) + copy(dAtA[i:], m.UpdatedUserTaskState) + i = encodeVarintEvents(dAtA, i, uint64(len(m.UpdatedUserTaskState))) + i-- + dAtA[i] = 0x42 + } + if len(m.CurrentUserTaskState) > 0 { + i -= len(m.CurrentUserTaskState) + copy(dAtA[i:], m.CurrentUserTaskState) + i = encodeVarintEvents(dAtA, i, uint64(len(m.CurrentUserTaskState))) + i-- + dAtA[i] = 0x3a + } + { + size, err := m.UserTaskMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + { + size, err := m.ConnectionMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + { + size, err := m.UserMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.ResourceMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *UserTaskMetadata) 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 *UserTaskMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UserTaskMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Integration) > 0 { + i -= len(m.Integration) + copy(dAtA[i:], m.Integration) + i = encodeVarintEvents(dAtA, i, uint64(len(m.Integration))) + i-- + dAtA[i] = 0x1a + } + if len(m.IssueType) > 0 { + i -= len(m.IssueType) + copy(dAtA[i:], m.IssueType) + i = encodeVarintEvents(dAtA, i, uint64(len(m.IssueType))) + i-- + dAtA[i] = 0x12 + } + if len(m.TaskType) > 0 { + i -= len(m.TaskType) + copy(dAtA[i:], m.TaskType) + i = encodeVarintEvents(dAtA, i, uint64(len(m.TaskType))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *UserTaskDelete) 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 *UserTaskDelete) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *UserTaskDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + { + size, err := m.ConnectionMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + { + size, err := m.UserMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.ResourceMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.Status.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func encodeVarintEvents(dAtA []byte, offset int, v uint64) int { offset -= sovEvents(v) base := offset @@ -43125,6 +43766,42 @@ func (m *OneOf_CrownJewelDelete) Size() (n int) { } return n } +func (m *OneOf_UserTaskCreate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UserTaskCreate != nil { + l = m.UserTaskCreate.Size() + n += 2 + l + sovEvents(uint64(l)) + } + return n +} +func (m *OneOf_UserTaskUpdate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UserTaskUpdate != nil { + l = m.UserTaskUpdate.Size() + n += 2 + l + sovEvents(uint64(l)) + } + return n +} +func (m *OneOf_UserTaskDelete) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.UserTaskDelete != nil { + l = m.UserTaskDelete.Size() + n += 2 + l + sovEvents(uint64(l)) + } + return n +} func (m *StreamStatus) Size() (n int) { if m == nil { return 0 @@ -45486,6 +46163,108 @@ func (m *CrownJewelDelete) Size() (n int) { return n } +func (m *UserTaskCreate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.ResourceMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.UserMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.ConnectionMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.UserTaskMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UserTaskUpdate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.ResourceMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.UserMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.ConnectionMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.UserTaskMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = len(m.CurrentUserTaskState) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = len(m.UpdatedUserTaskState) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UserTaskMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.TaskType) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = len(m.IssueType) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = len(m.Integration) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *UserTaskDelete) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.Status.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.ResourceMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.UserMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.ConnectionMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovEvents(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -83502,62 +84281,11 @@ func (m *OneOf) Unmarshal(dAtA []byte) error { } m.Event = &OneOf_CrownJewelDelete{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipEvents(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthEvents - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StreamStatus) 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 ErrIntOverflowEvents - } - 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: StreamStatus: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StreamStatus: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 188: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UploadID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserTaskCreate", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -83567,46 +84295,30 @@ func (m *StreamStatus) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.UploadID = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LastEventIndex", wireType) - } - m.LastEventIndex = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LastEventIndex |= int64(b&0x7F) << shift - if b < 0x80 { - break - } + v := &UserTaskCreate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - case 3: + m.Event = &OneOf_UserTaskCreate{v} + iNdEx = postIndex + case 189: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LastUploadTime", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserTaskUpdate", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -83633,64 +84345,15 @@ func (m *StreamStatus) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastUploadTime, dAtA[iNdEx:postIndex]); err != nil { + v := &UserTaskUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.Event = &OneOf_UserTaskUpdate{v} iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipEvents(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthEvents - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *SessionUpload) 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 ErrIntOverflowEvents - } - 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: SessionUpload: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SessionUpload: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 190: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserTaskDelete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -83717,15 +84380,68 @@ func (m *SessionUpload) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + v := &UserTaskDelete{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.Event = &OneOf_UserTaskDelete{v} iNdEx = postIndex - case 2: + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StreamStatus) 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 ErrIntOverflowEvents + } + 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: StreamStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StreamStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SessionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UploadID", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -83735,30 +84451,48 @@ func (m *SessionUpload) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.SessionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.UploadID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastEventIndex", wireType) + } + m.LastEventIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LastEventIndex |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SessionURL", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field LastUploadTime", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -83768,23 +84502,24 @@ func (m *SessionUpload) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.SessionURL = string(dAtA[iNdEx:postIndex]) + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastUploadTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -83808,7 +84543,7 @@ func (m *SessionUpload) Unmarshal(dAtA []byte) error { } return nil } -func (m *Identity) Unmarshal(dAtA []byte) error { +func (m *SessionUpload) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -83831,17 +84566,17 @@ func (m *Identity) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Identity: wiretype end group for non-group") + return fmt.Errorf("proto: SessionUpload: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Identity: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SessionUpload: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -83851,29 +84586,30 @@ func (m *Identity) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.User = string(dAtA[iNdEx:postIndex]) + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Impersonator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SessionMetadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -83883,27 +84619,28 @@ func (m *Identity) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.Impersonator = string(dAtA[iNdEx:postIndex]) + if err := m.SessionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 3: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SessionURL", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -83931,11 +84668,62 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) + m.SessionURL = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Identity) 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 ErrIntOverflowEvents + } + 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: Identity: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Identity: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -83963,11 +84751,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Usage = append(m.Usage, string(dAtA[iNdEx:postIndex])) + m.User = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Logins", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Impersonator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -83995,11 +84783,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Logins = append(m.Logins, string(dAtA[iNdEx:postIndex])) + m.Impersonator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KubernetesGroups", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -84027,11 +84815,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.KubernetesGroups = append(m.KubernetesGroups, string(dAtA[iNdEx:postIndex])) + m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 7: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KubernetesUsers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Usage", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -84059,13 +84847,13 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.KubernetesUsers = append(m.KubernetesUsers, string(dAtA[iNdEx:postIndex])) + m.Usage = append(m.Usage, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 8: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Expires", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Logins", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -84075,28 +84863,27 @@ func (m *Identity) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Expires, dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Logins = append(m.Logins, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 9: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RouteToCluster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KubernetesGroups", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -84124,11 +84911,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.RouteToCluster = string(dAtA[iNdEx:postIndex]) + m.KubernetesGroups = append(m.KubernetesGroups, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 10: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KubernetesCluster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KubernetesUsers", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -84156,11 +84943,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.KubernetesCluster = string(dAtA[iNdEx:postIndex]) + m.KubernetesUsers = append(m.KubernetesUsers, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 11: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Traits", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Expires", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -84187,15 +84974,15 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Traits.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Expires, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 12: + case 9: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RouteToApp", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RouteToCluster", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -84205,31 +84992,27 @@ func (m *Identity) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if m.RouteToApp == nil { - m.RouteToApp = &RouteToApp{} - } - if err := m.RouteToApp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.RouteToCluster = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 13: + case 10: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TeleportCluster", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KubernetesCluster", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -84257,11 +85040,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.TeleportCluster = string(dAtA[iNdEx:postIndex]) + m.KubernetesCluster = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 14: + case 11: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RouteToDatabase", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Traits", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -84288,18 +85071,15 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RouteToDatabase == nil { - m.RouteToDatabase = &RouteToDatabase{} - } - if err := m.RouteToDatabase.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Traits.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 15: + case 12: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DatabaseNames", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RouteToApp", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -84309,27 +85089,131 @@ func (m *Identity) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.DatabaseNames = append(m.DatabaseNames, string(dAtA[iNdEx:postIndex])) + if m.RouteToApp == nil { + m.RouteToApp = &RouteToApp{} + } + if err := m.RouteToApp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 16: + case 13: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DatabaseUsers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TeleportCluster", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TeleportCluster = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 14: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RouteToDatabase", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.RouteToDatabase == nil { + m.RouteToDatabase = &RouteToDatabase{} + } + if err := m.RouteToDatabase.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseNames", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.DatabaseNames = append(m.DatabaseNames, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseUsers", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -98893,13 +99777,859 @@ func (m *AuthPreferenceUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AdminActionsMFA", wireType) + } + m.AdminActionsMFA = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AdminActionsMFA |= AdminActionsMFAStatus(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ClusterNetworkingConfigUpdate) 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 ErrIntOverflowEvents + } + 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: ClusterNetworkingConfigUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClusterNetworkingConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SessionRecordingConfigUpdate) 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 ErrIntOverflowEvents + } + 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: SessionRecordingConfigUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SessionRecordingConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AccessPathChanged) 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 ErrIntOverflowEvents + } + 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: AccessPathChanged: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AccessPathChanged: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChangeID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ChangeID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AffectedResourceName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceSource", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AffectedResourceSource = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AffectedResourceType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SpannerRPC) 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 ErrIntOverflowEvents + } + 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: SpannerRPC: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SpannerRPC: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SessionMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.SessionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -98926,13 +100656,13 @@ func (m *AuthPreferenceUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.DatabaseMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -98959,15 +100689,15 @@ func (m *AuthPreferenceUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Procedure", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -98977,30 +100707,29 @@ func (m *AuthPreferenceUpdate) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Procedure = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AdminActionsMFA", wireType) + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) } - m.AdminActionsMFA = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -99010,11 +100739,28 @@ func (m *AuthPreferenceUpdate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.AdminActionsMFA |= AdminActionsMFAStatus(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Args == nil { + m.Args = &Struct{} + } + if err := m.Args.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -99037,7 +100783,7 @@ func (m *AuthPreferenceUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { +func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -99060,10 +100806,10 @@ func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ClusterNetworkingConfigUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: AccessGraphSettingsUpdate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ClusterNetworkingConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AccessGraphSettingsUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -99220,7 +100966,7 @@ func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *SessionRecordingConfigUpdate) Unmarshal(dAtA []byte) error { +func (m *SPIFFEFederationCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -99243,10 +100989,10 @@ func (m *SessionRecordingConfigUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SessionRecordingConfigUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: SPIFFEFederationCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SessionRecordingConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SPIFFEFederationCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -99284,7 +101030,7 @@ func (m *SessionRecordingConfigUpdate) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -99311,7 +101057,7 @@ func (m *SessionRecordingConfigUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -99403,7 +101149,7 @@ func (m *SessionRecordingConfigUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AccessPathChanged) Unmarshal(dAtA []byte) error { +func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -99426,10 +101172,10 @@ func (m *AccessPathChanged) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AccessPathChanged: wiretype end group for non-group") + return fmt.Errorf("proto: SPIFFEFederationDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AccessPathChanged: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SPIFFEFederationDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -99467,9 +101213,9 @@ func (m *AccessPathChanged) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChangeID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -99479,29 +101225,30 @@ func (m *AccessPathChanged) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.ChangeID = string(dAtA[iNdEx:postIndex]) + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -99511,29 +101258,30 @@ func (m *AccessPathChanged) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.AffectedResourceName = string(dAtA[iNdEx:postIndex]) + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceSource", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -99543,55 +101291,24 @@ func (m *AccessPathChanged) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.AffectedResourceSource = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceType", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - 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 ErrInvalidLengthEvents - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthEvents - } - if postIndex > l { - return io.ErrUnexpectedEOF + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.AffectedResourceType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -99615,7 +101332,7 @@ func (m *AccessPathChanged) Unmarshal(dAtA []byte) error { } return nil } -func (m *SpannerRPC) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateConfigCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -99638,10 +101355,10 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SpannerRPC: wiretype end group for non-group") + return fmt.Errorf("proto: AutoUpdateConfigCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SpannerRPC: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AutoUpdateConfigCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -99679,7 +101396,7 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -99706,13 +101423,13 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SessionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -99739,13 +101456,13 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.SessionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DatabaseMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -99772,11 +101489,95 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.DatabaseMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AutoUpdateConfigUpdate) 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 ErrIntOverflowEvents + } + 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: AutoUpdateConfigUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AutoUpdateConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } @@ -99809,11 +101610,11 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 6: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Procedure", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -99823,27 +101624,28 @@ func (m *SpannerRPC) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.Procedure = string(dAtA[iNdEx:postIndex]) + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 7: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -99870,10 +101672,7 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Args == nil { - m.Args = &Struct{} - } - if err := m.Args.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -99899,7 +101698,7 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { } return nil } -func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -99922,10 +101721,10 @@ func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AccessGraphSettingsUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: AutoUpdateConfigDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AccessGraphSettingsUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AutoUpdateConfigDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -99963,7 +101762,7 @@ func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -99990,7 +101789,7 @@ func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -100082,7 +101881,7 @@ func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *SPIFFEFederationCreate) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -100105,10 +101904,10 @@ func (m *SPIFFEFederationCreate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SPIFFEFederationCreate: wiretype end group for non-group") + return fmt.Errorf("proto: AutoUpdateVersionCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SPIFFEFederationCreate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AutoUpdateVersionCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -100265,7 +102064,7 @@ func (m *SPIFFEFederationCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -100288,10 +102087,10 @@ func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SPIFFEFederationDelete: wiretype end group for non-group") + return fmt.Errorf("proto: AutoUpdateVersionUpdate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SPIFFEFederationDelete: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AutoUpdateVersionUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -100329,7 +102128,7 @@ func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -100356,7 +102155,7 @@ func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -100448,7 +102247,7 @@ func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateConfigCreate) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -100471,10 +102270,10 @@ func (m *AutoUpdateConfigCreate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AutoUpdateConfigCreate: wiretype end group for non-group") + return fmt.Errorf("proto: AutoUpdateVersionDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AutoUpdateConfigCreate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: AutoUpdateVersionDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -100631,7 +102430,7 @@ func (m *AutoUpdateConfigCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { +func (m *StaticHostUserCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -100654,10 +102453,10 @@ func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AutoUpdateConfigUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: StaticHostUserCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AutoUpdateConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StaticHostUserCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -100727,6 +102526,39 @@ func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } @@ -100759,7 +102591,7 @@ func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 4: + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } @@ -100814,7 +102646,7 @@ func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { +func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -100837,10 +102669,10 @@ func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AutoUpdateConfigDelete: wiretype end group for non-group") + return fmt.Errorf("proto: StaticHostUserUpdate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AutoUpdateConfigDelete: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StaticHostUserUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -100877,6 +102709,39 @@ func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } @@ -100909,7 +102774,7 @@ func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 3: + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } @@ -100942,7 +102807,7 @@ func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 4: + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } @@ -100997,7 +102862,7 @@ func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { +func (m *StaticHostUserDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101020,10 +102885,10 @@ func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AutoUpdateVersionCreate: wiretype end group for non-group") + return fmt.Errorf("proto: StaticHostUserDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AutoUpdateVersionCreate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StaticHostUserDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101060,6 +102925,39 @@ func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { } iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } @@ -101092,7 +102990,7 @@ func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 3: + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } @@ -101125,7 +103023,7 @@ func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 4: + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } @@ -101180,7 +103078,7 @@ func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { +func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101203,10 +103101,10 @@ func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AutoUpdateVersionUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: CrownJewelCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AutoUpdateVersionUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CrownJewelCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101341,6 +103239,71 @@ func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CrownJewelQuery", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + 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 ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CrownJewelQuery = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -101363,7 +103326,7 @@ func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { +func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101386,10 +103349,10 @@ func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AutoUpdateVersionDelete: wiretype end group for non-group") + return fmt.Errorf("proto: CrownJewelUpdate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AutoUpdateVersionDelete: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CrownJewelUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101427,7 +103390,7 @@ func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -101454,7 +103417,7 @@ func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -101524,124 +103487,7 @@ func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipEvents(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthEvents - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *StaticHostUserCreate) 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 ErrIntOverflowEvents - } - 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: StaticHostUserCreate: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: StaticHostUserCreate: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthEvents - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthEvents - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthEvents - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthEvents - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: + case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } @@ -101674,11 +103520,11 @@ func (m *StaticHostUserCreate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 4: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CurrentCrownJewelQuery", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -101688,30 +103534,29 @@ func (m *StaticHostUserCreate) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.CurrentCrownJewelQuery = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedCrownJewelQuery", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -101721,24 +103566,23 @@ func (m *StaticHostUserCreate) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.UpdatedCrownJewelQuery = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -101762,7 +103606,7 @@ func (m *StaticHostUserCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { +func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101785,10 +103629,10 @@ func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StaticHostUserUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: CrownJewelDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StaticHostUserUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: CrownJewelDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101859,7 +103703,7 @@ func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -101886,13 +103730,13 @@ func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -101919,13 +103763,13 @@ func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -101952,7 +103796,7 @@ func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -101978,7 +103822,7 @@ func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *StaticHostUserDelete) Unmarshal(dAtA []byte) error { +func (m *UserTaskCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -102001,10 +103845,10 @@ func (m *StaticHostUserDelete) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StaticHostUserDelete: wiretype end group for non-group") + return fmt.Errorf("proto: UserTaskCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StaticHostUserDelete: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UserTaskCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -102168,97 +104012,13 @@ func (m *StaticHostUserDelete) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipEvents(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthEvents - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CrownJewelCreate) 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 ErrIntOverflowEvents - } - 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: CrownJewelCreate: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CrownJewelCreate: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthEvents - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthEvents - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserTaskMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102285,13 +104045,64 @@ func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UserTaskMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserTaskUpdate) 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 ErrIntOverflowEvents + } + 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: UserTaskUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserTaskUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102318,13 +104129,13 @@ func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Metadata.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 ConnectionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102351,11 +104162,11 @@ func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } @@ -102388,11 +104199,11 @@ func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 6: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CrownJewelQuery", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -102402,78 +104213,28 @@ func (m *CrownJewelCreate) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.CrownJewelQuery = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipEvents(dAtA[iNdEx:]) - if err != nil { + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthEvents - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *CrownJewelUpdate) 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 ErrIntOverflowEvents - } - 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: CrownJewelUpdate: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: CrownJewelUpdate: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102500,13 +104261,13 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 2: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserTaskMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102533,15 +104294,15 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UserTaskMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CurrentUserTaskState", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -102551,30 +104312,29 @@ func (m *CrownJewelUpdate) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.CurrentUserTaskState = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedUserTaskState", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -102584,30 +104344,80 @@ func (m *CrownJewelUpdate) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.UpdatedUserTaskState = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { return err } - iNdEx = postIndex - case 5: + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserTaskMetadata) 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 ErrIntOverflowEvents + } + 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: UserTaskMetadata: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserTaskMetadata: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TaskType", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -102617,28 +104427,27 @@ func (m *CrownJewelUpdate) 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 ErrInvalidLengthEvents } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.TaskType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CurrentCrownJewelQuery", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field IssueType", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -102666,11 +104475,11 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.CurrentCrownJewelQuery = string(dAtA[iNdEx:postIndex]) + m.IssueType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 7: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UpdatedCrownJewelQuery", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Integration", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -102698,7 +104507,7 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.UpdatedCrownJewelQuery = string(dAtA[iNdEx:postIndex]) + m.Integration = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -102722,7 +104531,7 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { +func (m *UserTaskDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -102745,10 +104554,10 @@ func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CrownJewelDelete: wiretype end group for non-group") + return fmt.Errorf("proto: UserTaskDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CrownJewelDelete: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UserTaskDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -102819,7 +104628,7 @@ func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102846,13 +104655,13 @@ func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102879,13 +104688,13 @@ func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -102912,7 +104721,7 @@ func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/api/types/events/oneof.go b/api/types/events/oneof.go index 4d18b2bd7a689..1cb8cad1aa509 100644 --- a/api/types/events/oneof.go +++ b/api/types/events/oneof.go @@ -748,6 +748,18 @@ func ToOneOf(in AuditEvent) (*OneOf, error) { out.Event = &OneOf_CrownJewelDelete{ CrownJewelDelete: e, } + case *UserTaskCreate: + out.Event = &OneOf_UserTaskCreate{ + UserTaskCreate: e, + } + case *UserTaskUpdate: + out.Event = &OneOf_UserTaskUpdate{ + UserTaskUpdate: e, + } + case *UserTaskDelete: + out.Event = &OneOf_UserTaskDelete{ + UserTaskDelete: e, + } default: slog.ErrorContext(context.Background(), "Attempted to convert dynamic event of unknown type into protobuf event.", "event_type", in.GetType()) unknown := &Unknown{} diff --git a/lib/auth/grpcserver.go b/lib/auth/grpcserver.go index feb9e222cb219..053603468001d 100644 --- a/lib/auth/grpcserver.go +++ b/lib/auth/grpcserver.go @@ -5329,6 +5329,7 @@ func NewGRPCServer(cfg GRPCServerConfig) (*GRPCServer, error) { // This must be a function because cfg.AuthServer.UsageReporter is changed after `NewGRPCServer` is called. // It starts as a DiscardUsageReporter, but when running in Cloud, gets replaced by a real reporter. UsageReporter: func() usagereporter.UsageReporter { return cfg.AuthServer.UsageReporter }, + Emitter: cfg.Emitter, }) if err != nil { return nil, trace.Wrap(err) diff --git a/lib/auth/usertasks/usertasksv1/service.go b/lib/auth/usertasks/usertasksv1/service.go index d36e411f8c233..c20d745d05a9b 100644 --- a/lib/auth/usertasks/usertasksv1/service.go +++ b/lib/auth/usertasks/usertasksv1/service.go @@ -20,14 +20,19 @@ package usertasksv1 import ( "context" + "log/slog" + "time" "github.com/gravitational/trace" "google.golang.org/protobuf/types/known/emptypb" + "google.golang.org/protobuf/types/known/timestamppb" usertasksv1 "github.com/gravitational/teleport/api/gen/proto/go/teleport/usertasks/v1" "github.com/gravitational/teleport/api/types" + apievents "github.com/gravitational/teleport/api/types/events" "github.com/gravitational/teleport/api/types/usertasks" "github.com/gravitational/teleport/lib/authz" + libevents "github.com/gravitational/teleport/lib/events" "github.com/gravitational/teleport/lib/services" usagereporter "github.com/gravitational/teleport/lib/usagereporter/teleport" ) @@ -45,6 +50,9 @@ type ServiceConfig struct { // UsageReporter is the reporter for sending usage without it be related to an API call. UsageReporter func() usagereporter.UsageReporter + + // Emitter is the event emitter. + Emitter apievents.Emitter } // CheckAndSetDefaults checks the ServiceConfig fields and returns an error if @@ -63,6 +71,9 @@ func (s *ServiceConfig) CheckAndSetDefaults() error { if s.UsageReporter == nil { return trace.BadParameter("usage reporter is required") } + if s.Emitter == nil { + return trace.BadParameter("emitter is required") + } return nil } @@ -82,6 +93,7 @@ type Service struct { backend services.UserTasks cache Reader usageReporter func() usagereporter.UsageReporter + emitter apievents.Emitter } // NewService returns a new UserTask gRPC service. @@ -95,6 +107,7 @@ func NewService(cfg ServiceConfig) (*Service, error) { backend: cfg.Backend, cache: cfg.Cache, usageReporter: cfg.UsageReporter, + emitter: cfg.Emitter, }, nil } @@ -110,6 +123,7 @@ func (s *Service) CreateUserTask(ctx context.Context, req *usertasksv1.CreateUse } rsp, err := s.backend.CreateUserTask(ctx, req.UserTask) + s.emitCreateAuditEvent(ctx, rsp, authCtx, err) if err != nil { return nil, trace.Wrap(err) } @@ -119,6 +133,30 @@ func (s *Service) CreateUserTask(ctx context.Context, req *usertasksv1.CreateUse return rsp, nil } +func (s *Service) emitCreateAuditEvent(ctx context.Context, req *usertasksv1.UserTask, authCtx *authz.Context, createErr error) { + if auditErr := s.emitter.EmitAuditEvent(ctx, &apievents.UserTaskCreate{ + Metadata: apievents.Metadata{ + Type: libevents.UserTaskCreateEvent, + Code: libevents.UserTaskCreateCode, + }, + UserMetadata: authCtx.GetUserMetadata(), + ConnectionMetadata: authz.ConnectionMetadata(ctx), + Status: eventStatus(createErr), + ResourceMetadata: apievents.ResourceMetadata{ + Name: req.GetMetadata().GetName(), + Expires: getExpires(req.GetMetadata().GetExpires()), + UpdatedBy: authCtx.Identity.GetIdentity().Username, + }, + UserTaskMetadata: apievents.UserTaskMetadata{ + TaskType: req.GetSpec().GetTaskType(), + IssueType: req.GetSpec().GetIssueType(), + Integration: req.GetSpec().GetIntegration(), + }, + }); auditErr != nil { + slog.WarnContext(ctx, "Failed to emit user task create event.", "error", auditErr) + } +} + func userTaskToUserTaskStateEvent(ut *usertasksv1.UserTask) *usagereporter.UserTaskStateEvent { ret := &usagereporter.UserTaskStateEvent{ TaskType: ut.GetSpec().GetTaskType(), @@ -212,6 +250,7 @@ func (s *Service) UpdateUserTask(ctx context.Context, req *usertasksv1.UpdateUse } rsp, err := s.backend.UpdateUserTask(ctx, req.UserTask) + s.emitUpdateAuditEvent(ctx, existingUserTask, req.GetUserTask(), authCtx, err) if err != nil { return nil, trace.Wrap(err) } @@ -223,6 +262,32 @@ func (s *Service) UpdateUserTask(ctx context.Context, req *usertasksv1.UpdateUse return rsp, nil } +func (s *Service) emitUpdateAuditEvent(ctx context.Context, old, new *usertasksv1.UserTask, authCtx *authz.Context, updateErr error) { + if auditErr := s.emitter.EmitAuditEvent(ctx, &apievents.UserTaskUpdate{ + Metadata: apievents.Metadata{ + Type: libevents.UserTaskUpdateEvent, + Code: libevents.UserTaskUpdateCode, + }, + UserMetadata: authCtx.GetUserMetadata(), + ConnectionMetadata: authz.ConnectionMetadata(ctx), + Status: eventStatus(updateErr), + ResourceMetadata: apievents.ResourceMetadata{ + Name: new.GetMetadata().GetName(), + Expires: getExpires(new.GetMetadata().GetExpires()), + UpdatedBy: authCtx.Identity.GetIdentity().Username, + }, + UserTaskMetadata: apievents.UserTaskMetadata{ + TaskType: new.GetSpec().GetTaskType(), + IssueType: new.GetSpec().GetIssueType(), + Integration: new.GetSpec().GetIntegration(), + }, + CurrentUserTaskState: old.GetSpec().GetState(), + UpdatedUserTaskState: new.GetSpec().GetState(), + }); auditErr != nil { + slog.WarnContext(ctx, "Failed to emit user task update event.", "error", auditErr) + } +} + // UpsertUserTask upserts user task resource. func (s *Service) UpsertUserTask(ctx context.Context, req *usertasksv1.UpsertUserTaskRequest) (*usertasksv1.UserTask, error) { authCtx, err := s.authorizer.Authorize(ctx) @@ -249,6 +314,7 @@ func (s *Service) UpsertUserTask(ctx context.Context, req *usertasksv1.UpsertUse } rsp, err := s.backend.UpsertUserTask(ctx, req.UserTask) + s.emitUpsertAuditEvent(ctx, existingUserTask, req.GetUserTask(), authCtx, err) if err != nil { return nil, trace.Wrap(err) } @@ -258,7 +324,14 @@ func (s *Service) UpsertUserTask(ctx context.Context, req *usertasksv1.UpsertUse } return rsp, nil +} +func (s *Service) emitUpsertAuditEvent(ctx context.Context, old, new *usertasksv1.UserTask, authCtx *authz.Context, err error) { + if old == nil { + s.emitCreateAuditEvent(ctx, new, authCtx, err) + return + } + s.emitUpdateAuditEvent(ctx, old, new, authCtx, err) } // DeleteUserTask deletes user task resource. @@ -272,9 +345,49 @@ func (s *Service) DeleteUserTask(ctx context.Context, req *usertasksv1.DeleteUse return nil, trace.Wrap(err) } - if err := s.backend.DeleteUserTask(ctx, req.GetName()); err != nil { + err = s.backend.DeleteUserTask(ctx, req.GetName()) + s.emitDeleteAuditEvent(ctx, req.GetName(), authCtx, err) + if err != nil { return nil, trace.Wrap(err) } return &emptypb.Empty{}, nil } + +func (s *Service) emitDeleteAuditEvent(ctx context.Context, taskName string, authCtx *authz.Context, deleteErr error) { + if auditErr := s.emitter.EmitAuditEvent(ctx, &apievents.UserTaskDelete{ + Metadata: apievents.Metadata{ + Type: libevents.UserTaskDeleteEvent, + Code: libevents.UserTaskDeleteCode, + }, + UserMetadata: authCtx.GetUserMetadata(), + ConnectionMetadata: authz.ConnectionMetadata(ctx), + Status: eventStatus(deleteErr), + ResourceMetadata: apievents.ResourceMetadata{ + Name: taskName, + UpdatedBy: authCtx.Identity.GetIdentity().Username, + }, + }); auditErr != nil { + slog.WarnContext(ctx, "Failed to emit user task delete event.", "error", auditErr) + } +} + +func eventStatus(err error) apievents.Status { + var msg string + if err != nil { + msg = err.Error() + } + + return apievents.Status{ + Success: err == nil, + Error: msg, + UserMessage: msg, + } +} + +func getExpires(cj *timestamppb.Timestamp) time.Time { + if cj == nil { + return time.Time{} + } + return cj.AsTime() +} diff --git a/lib/auth/usertasks/usertasksv1/service_test.go b/lib/auth/usertasks/usertasksv1/service_test.go index d2e014476e0ee..0f0a56fb4ef1c 100644 --- a/lib/auth/usertasks/usertasksv1/service_test.go +++ b/lib/auth/usertasks/usertasksv1/service_test.go @@ -23,17 +23,24 @@ import ( "fmt" "slices" "testing" + "time" + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" "github.com/gravitational/trace" "github.com/stretchr/testify/require" usertasksv1 "github.com/gravitational/teleport/api/gen/proto/go/teleport/usertasks/v1" "github.com/gravitational/teleport/api/types" + apievents "github.com/gravitational/teleport/api/types/events" "github.com/gravitational/teleport/api/types/usertasks" "github.com/gravitational/teleport/lib/authz" "github.com/gravitational/teleport/lib/backend/memory" + libevents "github.com/gravitational/teleport/lib/events" + "github.com/gravitational/teleport/lib/events/eventstest" "github.com/gravitational/teleport/lib/services" "github.com/gravitational/teleport/lib/services/local" + "github.com/gravitational/teleport/lib/tlsca" usagereporter "github.com/gravitational/teleport/lib/usagereporter/teleport" "github.com/gravitational/teleport/lib/utils" ) @@ -81,7 +88,7 @@ func TestServiceAccess(t *testing.T) { t.Run(tt.name, func(t *testing.T) { for _, verbs := range utils.Combinations(tt.allowedVerbs) { t.Run(fmt.Sprintf("verbs=%v", verbs), func(t *testing.T) { - service := newService(t, fakeChecker{allowedVerbs: verbs}, testReporter) + service := newService(t, fakeChecker{allowedVerbs: verbs}, testReporter, &libevents.DiscardEmitter{}) err := callMethod(t, service, tt.name) // expect access denied except with full set of verbs. if len(verbs) == len(tt.allowedVerbs) { @@ -108,10 +115,11 @@ func TestServiceAccess(t *testing.T) { }) } -func TestUsageEvents(t *testing.T) { +func TestEvents(t *testing.T) { rwVerbs := []string{types.VerbList, types.VerbCreate, types.VerbRead, types.VerbUpdate, types.VerbDelete} testReporter := &mockUsageReporter{} - service := newService(t, fakeChecker{allowedVerbs: rwVerbs}, testReporter) + auditEventsSink := eventstest.NewChannelEmitter(10) + service := newService(t, fakeChecker{allowedVerbs: rwVerbs}, testReporter, auditEventsSink) ctx := context.Background() ut1, err := usertasks.NewDiscoverEC2UserTask(&usertasksv1.UserTaskSpec{ @@ -123,7 +131,7 @@ func TestUsageEvents(t *testing.T) { AccountId: "123456789012", Region: "us-east-1", Instances: map[string]*usertasksv1.DiscoverEC2Instance{ - "i-123": &usertasksv1.DiscoverEC2Instance{ + "i-123": { InstanceId: "i-123", DiscoveryConfig: "dc01", DiscoveryGroup: "dg01", @@ -132,11 +140,13 @@ func TestUsageEvents(t *testing.T) { }, }) require.NoError(t, err) + userTaskName := ut1.GetMetadata().GetName() _, err = service.CreateUserTask(ctx, &usertasksv1.CreateUserTaskRequest{UserTask: ut1}) require.NoError(t, err) // Usage reporting happens when user task is created, so we expect to see an event. require.Len(t, testReporter.emittedEvents, 1) + consumeAssertEvent(t, auditEventsSink.C(), auditEventFor(userTaskName, "create", "", "")) ut1.Spec.DiscoverEc2.Instances["i-345"] = &usertasksv1.DiscoverEC2Instance{ InstanceId: "i-345", @@ -147,12 +157,86 @@ func TestUsageEvents(t *testing.T) { require.NoError(t, err) // State was not updated, so usage events must not increase. require.Len(t, testReporter.emittedEvents, 1) + consumeAssertEvent(t, auditEventsSink.C(), auditEventFor(userTaskName, "update", "OPEN", "OPEN")) ut1.Spec.State = "RESOLVED" _, err = service.UpdateUserTask(ctx, &usertasksv1.UpdateUserTaskRequest{UserTask: ut1}) require.NoError(t, err) // State was updated, so usage events include this new usage report. require.Len(t, testReporter.emittedEvents, 2) + consumeAssertEvent(t, auditEventsSink.C(), auditEventFor(userTaskName, "update", "OPEN", "RESOLVED")) + + _, err = service.DeleteUserTask(ctx, &usertasksv1.DeleteUserTaskRequest{Name: userTaskName}) + require.NoError(t, err) + // No usage report for deleted resources. + require.Len(t, testReporter.emittedEvents, 2) + consumeAssertEvent(t, auditEventsSink.C(), auditEventFor(userTaskName, "delete", "", "")) +} + +func auditEventFor(resourceName, eventType, oldState, newState string) any { + status := apievents.Status{ + Success: true, + } + userMetadata := apievents.UserMetadata{ + UserKind: apievents.UserKind_USER_KIND_HUMAN, + } + resourceMetadata := apievents.ResourceMetadata{ + Name: resourceName, + UpdatedBy: "llama", + } + userTaskMetadata := apievents.UserTaskMetadata{ + TaskType: "discover-ec2", + IssueType: "ec2-ssm-invocation-failure", + Integration: "my-integration", + } + + var evt any + switch eventType { + case "create": + evt = &apievents.UserTaskCreate{ + Status: status, + ResourceMetadata: resourceMetadata, + UserMetadata: userMetadata, + UserTaskMetadata: userTaskMetadata, + Metadata: apievents.Metadata{ + Type: libevents.UserTaskCreateEvent, + Code: libevents.UserTaskCreateCode, + }, + } + case "update": + evt = &apievents.UserTaskUpdate{ + Status: status, + ResourceMetadata: resourceMetadata, + UserMetadata: userMetadata, + UserTaskMetadata: userTaskMetadata, + Metadata: apievents.Metadata{ + Type: libevents.UserTaskUpdateEvent, + Code: libevents.UserTaskUpdateCode, + }, + CurrentUserTaskState: oldState, + UpdatedUserTaskState: newState, + } + case "delete": + evt = &apievents.UserTaskDelete{ + Status: status, + ResourceMetadata: resourceMetadata, + UserMetadata: userMetadata, + Metadata: apievents.Metadata{ + Type: libevents.UserTaskDeleteEvent, + Code: libevents.UserTaskDeleteCode, + }, + } + } + return evt +} + +func consumeAssertEvent(t *testing.T, q <-chan apievents.AuditEvent, expectedEvent any) { + select { + case evt := <-q: + require.Empty(t, cmp.Diff(expectedEvent, evt, cmpopts.IgnoreFields(apievents.UserMetadata{}, "User"))) + case <-time.After(5 * time.Second): + t.Fatalf("timed out waiting for user task create event") + } } // callMethod calls a method with given name in the UserTask service @@ -182,7 +266,7 @@ func (f fakeChecker) CheckAccessToRule(_ services.RuleContext, _ string, resourc return trace.AccessDenied("access denied to rule=%v/verb=%v", resource, verb) } -func newService(t *testing.T, checker services.AccessChecker, usageReporter usagereporter.UsageReporter) *Service { +func newService(t *testing.T, checker services.AccessChecker, usageReporter usagereporter.UsageReporter, emitter apievents.Emitter) *Service { t.Helper() b, err := memory.New(memory.Config{}) @@ -199,6 +283,11 @@ func newService(t *testing.T, checker services.AccessChecker, usageReporter usag return &authz.Context{ User: user, Checker: checker, + Identity: authz.LocalUser{ + Identity: tlsca.Identity{ + Username: user.GetName(), + }, + }, }, nil }) @@ -207,6 +296,7 @@ func newService(t *testing.T, checker services.AccessChecker, usageReporter usag Backend: backendService, Cache: backendService, UsageReporter: func() usagereporter.UsageReporter { return usageReporter }, + Emitter: emitter, }) require.NoError(t, err) return service diff --git a/lib/events/api.go b/lib/events/api.go index 0e8c288f5c11d..3e55b5d575d2c 100644 --- a/lib/events/api.go +++ b/lib/events/api.go @@ -815,6 +815,13 @@ const ( CrownJewelUpdateEvent = "access_graph.crown_jewel.update" // CrownJewelDeleteEvent is emitted when a crown jewel resource is deleted. CrownJewelDeleteEvent = "access_graph.crown_jewel.delete" + + // UserTaskCreateEvent is emitted when a user task resource is created. + UserTaskCreateEvent = "user_task.create" + //UserTaskUpdateEvent is emitted when a user task resource is updated. + UserTaskUpdateEvent = "user_task.update" + // UserTaskDeleteEvent is emitted when a user task resource is deleted. + UserTaskDeleteEvent = "user_task.delete" ) // Add an entry to eventsMap in lib/events/events_test.go when you add diff --git a/lib/events/codes.go b/lib/events/codes.go index a5a2f737f9c1c..e26cc1294d257 100644 --- a/lib/events/codes.go +++ b/lib/events/codes.go @@ -664,6 +664,13 @@ const ( // CrownJewelDeleteCode is the crown jewel delete event code. CrownJewelDeleteCode = "CJ003I" + // UserTaskCreateCode is the user task create event code. + UserTaskCreateCode = "UT001I" + // UserTaskUpdateCode is the user task update event code. + UserTaskUpdateCode = "UT002I" + // UserTaskDeleteCode is the user task delete event code. + UserTaskDeleteCode = "UT003I" + // UnknownCode is used when an event of unknown type is encountered. UnknownCode = apievents.UnknownCode ) diff --git a/lib/events/dynamic.go b/lib/events/dynamic.go index d09e884d4d500..96dded31b85a1 100644 --- a/lib/events/dynamic.go +++ b/lib/events/dynamic.go @@ -437,6 +437,13 @@ func FromEventFields(fields EventFields) (events.AuditEvent, error) { e = &events.CrownJewelUpdate{} case CrownJewelDeleteEvent: e = &events.CrownJewelDelete{} + + case UserTaskCreateEvent: + e = &events.UserTaskCreate{} + case UserTaskUpdateEvent: + e = &events.UserTaskUpdate{} + case UserTaskDeleteEvent: + e = &events.UserTaskDelete{} default: log.Errorf("Attempted to convert dynamic event of unknown type %q into protobuf event.", eventType) unknown := &events.Unknown{} diff --git a/lib/events/events_test.go b/lib/events/events_test.go index 6773bd871d80f..56e61392820f7 100644 --- a/lib/events/events_test.go +++ b/lib/events/events_test.go @@ -232,6 +232,9 @@ var eventsMap = map[string]apievents.AuditEvent{ CrownJewelCreateEvent: &apievents.CrownJewelCreate{}, CrownJewelUpdateEvent: &apievents.CrownJewelUpdate{}, CrownJewelDeleteEvent: &apievents.CrownJewelDelete{}, + UserTaskCreateEvent: &apievents.UserTaskCreate{}, + UserTaskUpdateEvent: &apievents.UserTaskUpdate{}, + UserTaskDeleteEvent: &apievents.UserTaskDelete{}, } // TestJSON tests JSON marshal events diff --git a/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx b/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx index b36b3df635807..704de4b00e33e 100644 --- a/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx +++ b/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx @@ -294,6 +294,9 @@ const EventIconMap: Record = { [eventCodes.CROWN_JEWEL_CREATE]: Icons.Info, [eventCodes.CROWN_JEWEL_UPDATE]: Icons.Info, [eventCodes.CROWN_JEWEL_DELETE]: Icons.Info, + [eventCodes.USER_TASK_CREATE]: Icons.Info, + [eventCodes.USER_TASK_UPDATE]: Icons.Info, + [eventCodes.USER_TASK_DELETE]: Icons.Info, [eventCodes.UNKNOWN]: Icons.Question, }; diff --git a/web/packages/teleport/src/Audit/__snapshots__/Audit.story.test.tsx.snap b/web/packages/teleport/src/Audit/__snapshots__/Audit.story.test.tsx.snap index 00469aa3aed81..f4cfd876a8d78 100644 --- a/web/packages/teleport/src/Audit/__snapshots__/Audit.story.test.tsx.snap +++ b/web/packages/teleport/src/Audit/__snapshots__/Audit.story.test.tsx.snap @@ -400,12 +400,12 @@ exports[`list of all events 1`] = ` - - 252 + 255 of - 252 + 255 + + + + +
+ + + + + + + + User Task Updated +
+ + + User [30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix] updated a user task [d217950f-cb5f-5703-96ef-39ab8cd86601] + + + 2024-10-17T14:01:02.853Z + + + + + + + +
+ + + + + + + + User Task Created +
+ + + User [30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix] created a user task [d217950f-cb5f-5703-96ef-39ab8cd86601] + + + 2024-10-17T14:00:34.186Z + + + + + - - 252 + 255 of - 252 + 255 diff --git a/web/packages/teleport/src/Audit/fixtures/index.ts b/web/packages/teleport/src/Audit/fixtures/index.ts index afb44b62a9a11..cdc20e89e95d4 100644 --- a/web/packages/teleport/src/Audit/fixtures/index.ts +++ b/web/packages/teleport/src/Audit/fixtures/index.ts @@ -3656,6 +3656,59 @@ export const events = [ name: 'test-user', user: 'bob', }, + { + 'addr.remote': '127.0.0.1:52763', + cluster_name: 'lenix', + code: 'UT001I', + ei: 0, + event: 'user_task.create', + expires: '0001-01-01T00:00:00Z', + name: 'd217950f-cb5f-5703-96ef-39ab8cd86601', + success: true, + time: '2024-10-17T14:00:34.186Z', + uid: '709840ec-288e-4056-ba20-c8f4b12a478f', + updated_by: '30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix', + user: '30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix', + user_kind: 1, + user_task_integration: 'teleportdev', + user_task_issue_type: 'ec2-ssm-invocation-failure', + user_task_type: 'discover-ec2', + }, + { + 'addr.remote': '127.0.0.1:52833', + cluster_name: 'lenix', + code: 'UT002I', + current_user_task_state: 'OPEN', + ei: 0, + event: 'user_task.update', + expires: '0001-01-01T00:00:00Z', + name: 'd217950f-cb5f-5703-96ef-39ab8cd86601', + success: true, + time: '2024-10-17T14:01:02.853Z', + uid: '0ba36761-4a6a-429e-bce4-1825d80ce06a', + updated_by: '30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix', + updated_user_task_state: 'OPEN', + user: '30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix', + user_kind: 1, + user_task_integration: 'teleportdev', + user_task_issue_type: 'ec2-ssm-invocation-failure', + user_task_type: 'discover-ec2', + }, + { + 'addr.remote': '127.0.0.1:52915', + cluster_name: 'lenix', + code: 'UT003I', + ei: 0, + event: 'user_task.delete', + expires: '0001-01-01T00:00:00Z', + name: 'd217950f-cb5f-5703-96ef-39ab8cd86601', + success: true, + time: '2024-10-17T14:01:11.031Z', + uid: '7699b806-e717-4821-85a5-d2f41acbe373', + updated_by: '30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix', + user: '30a6b2e1-3b61-4965-92cf-b4f84e9dc683.lenix', + user_kind: 1, + }, ].map(makeEvent); // Do not add new events to this array, add it to `events` list. diff --git a/web/packages/teleport/src/services/audit/makeEvent.ts b/web/packages/teleport/src/services/audit/makeEvent.ts index 6847751948a53..caab90105eeab 100644 --- a/web/packages/teleport/src/services/audit/makeEvent.ts +++ b/web/packages/teleport/src/services/audit/makeEvent.ts @@ -1950,6 +1950,27 @@ export const formatters: Formatters = { return `User [${user}] deleted a crown jewel [${name}]`; }, }, + [eventCodes.USER_TASK_CREATE]: { + type: 'user_task.create', + desc: 'User Task Created', + format: ({ user, name }) => { + return `User [${user}] created a user task [${name}]`; + }, + }, + [eventCodes.USER_TASK_UPDATE]: { + type: 'user_task.update', + desc: 'User Task Updated', + format: ({ user, name }) => { + return `User [${user}] updated a user task [${name}]`; + }, + }, + [eventCodes.USER_TASK_DELETE]: { + type: 'user_task.delete', + desc: 'User Task Deleted', + format: ({ user, name }) => { + return `User [${user}] deleted a user task [${name}]`; + }, + }, [eventCodes.UNKNOWN]: { type: 'unknown', desc: 'Unknown Event', diff --git a/web/packages/teleport/src/services/audit/types.ts b/web/packages/teleport/src/services/audit/types.ts index 5af66ef558b32..3a52afb6617f5 100644 --- a/web/packages/teleport/src/services/audit/types.ts +++ b/web/packages/teleport/src/services/audit/types.ts @@ -314,6 +314,9 @@ export const eventCodes = { CROWN_JEWEL_CREATE: 'CJ001I', CROWN_JEWEL_UPDATE: 'CJ002I', CROWN_JEWEL_DELETE: 'CJ003I', + USER_TASK_CREATE: 'UT001I', + USER_TASK_UPDATE: 'UT002I', + USER_TASK_DELETE: 'UT003I', } as const; /** @@ -1731,6 +1734,18 @@ export type RawEvents = { typeof eventCodes.CROWN_JEWEL_DELETE, HasName >; + [eventCodes.USER_TASK_CREATE]: RawEvent< + typeof eventCodes.USER_TASK_CREATE, + HasName + >; + [eventCodes.USER_TASK_UPDATE]: RawEvent< + typeof eventCodes.USER_TASK_UPDATE, + HasName + >; + [eventCodes.USER_TASK_DELETE]: RawEvent< + typeof eventCodes.USER_TASK_DELETE, + HasName + >; }; /** From 331d8a3d0f5c37843431ade1e41aa0d92db55571 Mon Sep 17 00:00:00 2001 From: Tiago Silva Date: Wed, 30 Oct 2024 09:56:28 +0000 Subject: [PATCH 4/5] [entraid] add setup script for offline clusters. (#47863) (#48089) * [entraid] add setup script for offline clusters. This PR adds a cli configuration for Entra ID where it's possible to default to system credentials instead of relying on OIDC for authentication in EntraID. OIDC is not always a possibility specially when the cluster is private and not internet acessible. The UX is the following: ```text Step 1: Run the Setup Script 1. Open **Azure Cloud Shell** (Bash) using **Google Chrome** or **Safari** for the best compatibility. 2. Upload the setup script using the **Upload** button in the Cloud Shell toolbar. 3. Once uploaded, execute the script by running the following command: $ bash entraid.sh **Important Considerations**: - You must have **Azure privileged administrator permissions** to complete the integration. - Ensure you're using the **Bash** environment in Cloud Shell. - During the script execution, you'll be prompted to run 'az login' to authenticate with Azure. **Teleport** does not store or persist your credentials. - **Mozilla Firefox** users may experience connectivity issues in Azure Cloud Shell; using Chrome or Safari is recommended. Once the script completes, type 'continue' to proceed, 'exit' to quit: continue Step 2: Input Tenant ID and Client ID With the output of Step 1, please copy and paste the following information: Enter the Tenant ID: 1056b571-0390-4b08-86c8-2edba8d9ae79 Enter the Client ID: 1056b571-0390-4b08-86c8-2edba8d9ae79 Successfully created EntraID plugin "name". ``` * move function to api * handle code review comments * Apply suggestions from code review * fix url * enable group claims * add godoc * handle code review comments * fix gomod --------- Signed-off-by: Tiago Silva Co-authored-by: Marco Dinis --- api/utils/entraid/federation_metadata.go | 33 ++ go.mod | 2 +- go.sum | 4 +- integrations/event-handler/go.mod | 2 +- integrations/event-handler/go.sum | 4 +- integrations/terraform/go.mod | 2 +- integrations/terraform/go.sum | 4 +- lib/config/configuration.go | 3 + lib/integrations/azureoidc/enterprise_app.go | 10 +- lib/integrations/azureoidc/provision_sso.go | 3 + lib/msgraph/models.go | 14 +- tool/tctl/common/plugin/entraid.go | 419 ++++++++++++++++++ tool/tctl/common/plugin/plugins_command.go | 20 +- .../common/plugin/plugins_command_test.go | 31 ++ tool/teleport/common/integration_configure.go | 2 +- tool/teleport/common/teleport.go | 1 + 16 files changed, 534 insertions(+), 20 deletions(-) create mode 100644 api/utils/entraid/federation_metadata.go create mode 100644 tool/tctl/common/plugin/entraid.go diff --git a/api/utils/entraid/federation_metadata.go b/api/utils/entraid/federation_metadata.go new file mode 100644 index 0000000000000..2dfa76080cdeb --- /dev/null +++ b/api/utils/entraid/federation_metadata.go @@ -0,0 +1,33 @@ +/* +Copyright 2024 Gravitational, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ +package entraid + +import ( + "net/url" + "path" +) + +// FederationMetadataURL returns the URL for the federation metadata endpoint +func FederationMetadataURL(tenantID, appID string) string { + return (&url.URL{ + Scheme: "https", + Host: "login.microsoftonline.com", + Path: path.Join(tenantID, "federationmetadata", "2007-06", "federationmetadata.xml"), + RawQuery: url.Values{ + "appid": {appID}, + }.Encode(), + }).String() +} diff --git a/go.mod b/go.mod index 25a8fa25ac4e1..5597b1f7884fe 100644 --- a/go.mod +++ b/go.mod @@ -82,6 +82,7 @@ require ( github.com/elastic/go-elasticsearch/v8 v8.13.1 github.com/elimity-com/scim v0.0.0-20240320110924-172bf2aee9c8 github.com/evanphx/json-patch v5.9.0+incompatible + github.com/fatih/color v1.17.0 github.com/fsouza/fake-gcs-server v1.48.0 github.com/fxamacker/cbor/v2 v2.6.0 github.com/ghodss/yaml v1.0.0 @@ -313,7 +314,6 @@ require ( github.com/evanphx/json-patch/v5 v5.9.0 // indirect github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d // indirect github.com/fatih/camelcase v1.0.0 // indirect - github.com/fatih/color v1.16.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/form3tech-oss/jwt-go v3.2.5+incompatible // indirect github.com/fsnotify/fsnotify v1.7.0 diff --git a/go.sum b/go.sum index 3588e1d39cfe2..ca4fc55beb9ca 100644 --- a/go.sum +++ b/go.sum @@ -1164,8 +1164,8 @@ github.com/fatih/camelcase v1.0.0 h1:hxNvNX/xYBp0ovncs8WyWZrOrpBNub/JfaMvbURyft8 github.com/fatih/camelcase v1.0.0/go.mod h1:yN2Sb0lFhZJUdVvtELVWefmrXpuZESvPmqwoZc+/fpc= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= -github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= -github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= +github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4= +github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= diff --git a/integrations/event-handler/go.mod b/integrations/event-handler/go.mod index 930c9f3977a53..72bb9c208a88a 100644 --- a/integrations/event-handler/go.mod +++ b/integrations/event-handler/go.mod @@ -124,7 +124,7 @@ require ( github.com/evanphx/json-patch v5.9.0+incompatible // indirect github.com/evanphx/json-patch/v5 v5.9.0 // indirect github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d // indirect - github.com/fatih/color v1.16.0 // indirect + github.com/fatih/color v1.17.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/fsnotify/fsnotify v1.7.0 // indirect github.com/fxamacker/cbor/v2 v2.6.0 // indirect diff --git a/integrations/event-handler/go.sum b/integrations/event-handler/go.sum index 03d199d801fbd..67762e55c087f 100644 --- a/integrations/event-handler/go.sum +++ b/integrations/event-handler/go.sum @@ -927,8 +927,8 @@ github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d h1:105gxyaGwC github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d/go.mod h1:ZZMPRZwes7CROmyNKgQzC3XPs6L/G2EJLHddWejkmf4= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= -github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= -github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= +github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4= +github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= diff --git a/integrations/terraform/go.mod b/integrations/terraform/go.mod index e7a9c0c3bc950..4a1e307345f4d 100644 --- a/integrations/terraform/go.mod +++ b/integrations/terraform/go.mod @@ -143,7 +143,7 @@ require ( github.com/evanphx/json-patch v5.9.0+incompatible // indirect github.com/evanphx/json-patch/v5 v5.9.0 // indirect github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d // indirect - github.com/fatih/color v1.16.0 // indirect + github.com/fatih/color v1.17.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/fsnotify/fsnotify v1.7.0 // indirect github.com/fxamacker/cbor/v2 v2.6.0 // indirect diff --git a/integrations/terraform/go.sum b/integrations/terraform/go.sum index 6392da56d26e6..9353f809d1114 100644 --- a/integrations/terraform/go.sum +++ b/integrations/terraform/go.sum @@ -1017,8 +1017,8 @@ github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d/go.mod h1:ZZM github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= -github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= -github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= +github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4= +github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc= diff --git a/lib/config/configuration.go b/lib/config/configuration.go index 48e543f212feb..892134b498e4b 100644 --- a/lib/config/configuration.go +++ b/lib/config/configuration.go @@ -296,6 +296,9 @@ type IntegrationConfAzureOIDC struct { // When this is true, the integration script will produce // a cache file necessary for TAG synchronization. AccessGraphEnabled bool + + // SkipOIDCConfiguration is a flag indicating that OIDC configuration should be skipped. + SkipOIDCConfiguration bool } // IntegrationConfDeployServiceIAM contains the arguments of diff --git a/lib/integrations/azureoidc/enterprise_app.go b/lib/integrations/azureoidc/enterprise_app.go index e159470d0bb39..e7de09225ec58 100644 --- a/lib/integrations/azureoidc/enterprise_app.go +++ b/lib/integrations/azureoidc/enterprise_app.go @@ -52,7 +52,7 @@ var appRoles = []string{ // - Provides Teleport with OIDC authentication to Azure // - Is given the permissions to access certain Microsoft Graph API endpoints for this tenant. // - Provides SSO to the Teleport cluster via SAML. -func SetupEnterpriseApp(ctx context.Context, proxyPublicAddr string, authConnectorName string) (string, string, error) { +func SetupEnterpriseApp(ctx context.Context, proxyPublicAddr string, authConnectorName string, skipOIDCSetup bool) (string, string, error) { var appID, tenantID string tenantID, err := getTenantID() @@ -120,8 +120,12 @@ func SetupEnterpriseApp(ctx context.Context, proxyPublicAddr string, authConnect } } - if err := createFederatedAuthCredential(ctx, graphClient, *app.ID, proxyPublicAddr); err != nil { - return appID, tenantID, trace.Wrap(err, "failed to create an OIDC federated auth credential") + // Skip OIDC setup if requested. + // This is useful for clusters that can't use OIDC because they are not reachable from the public internet. + if !skipOIDCSetup { + if err := createFederatedAuthCredential(ctx, graphClient, *app.ID, proxyPublicAddr); err != nil { + return appID, tenantID, trace.Wrap(err, "failed to create an OIDC federated auth credential") + } } acsURL, err := url.Parse(proxyPublicAddr) diff --git a/lib/integrations/azureoidc/provision_sso.go b/lib/integrations/azureoidc/provision_sso.go index 07d4366040752..9bb17aa5771dd 100644 --- a/lib/integrations/azureoidc/provision_sso.go +++ b/lib/integrations/azureoidc/provision_sso.go @@ -48,6 +48,9 @@ func setupSSO(ctx context.Context, graphClient *msgraph.Client, appObjectID stri webApp := &msgraph.WebApplication{} webApp.RedirectURIs = &uris app.Web = webApp + securityGroups := new(string) + *securityGroups = "SecurityGroup" + app.GroupMembershipClaims = securityGroups err = graphClient.UpdateApplication(ctx, appObjectID, app) diff --git a/lib/msgraph/models.go b/lib/msgraph/models.go index f867ecbb634c5..829d55a040464 100644 --- a/lib/msgraph/models.go +++ b/lib/msgraph/models.go @@ -18,6 +18,7 @@ package msgraph import ( "encoding/json" + "slices" "github.com/gravitational/trace" ) @@ -34,6 +35,12 @@ type DirectoryObject struct { type Group struct { DirectoryObject + GroupTypes []string `json:"groupTypes,omitempty"` +} + +func (g *Group) IsOffice365Group() bool { + const office365Group = "Unified" + return slices.Contains(g.GroupTypes, office365Group) } func (g *Group) isGroupMember() {} @@ -53,9 +60,10 @@ func (u *User) GetID() *string { return u.ID } type Application struct { DirectoryObject - AppID *string `json:"appId,omitempty"` - IdentifierURIs *[]string `json:"identifierUris,omitempty"` - Web *WebApplication `json:"web,omitempty"` + AppID *string `json:"appId,omitempty"` + IdentifierURIs *[]string `json:"identifierUris,omitempty"` + Web *WebApplication `json:"web,omitempty"` + GroupMembershipClaims *string `json:"groupMembershipClaims,omitempty"` } type WebApplication struct { diff --git a/tool/tctl/common/plugin/entraid.go b/tool/tctl/common/plugin/entraid.go new file mode 100644 index 0000000000000..ea5010504ca9f --- /dev/null +++ b/tool/tctl/common/plugin/entraid.go @@ -0,0 +1,419 @@ +/* + * Teleport + * Copyright (C) 2024 Gravitational, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package plugin + +import ( + "bufio" + "context" + "encoding/json" + "errors" + "fmt" + "io" + "os" + "path/filepath" + "strings" + + "github.com/alecthomas/kingpin/v2" + "github.com/fatih/color" + "github.com/google/safetext/shsprintf" + "github.com/google/uuid" + "github.com/gravitational/trace" + + pluginspb "github.com/gravitational/teleport/api/gen/proto/go/teleport/plugins/v1" + "github.com/gravitational/teleport/api/types" + entraapiutils "github.com/gravitational/teleport/api/utils/entraid" + "github.com/gravitational/teleport/lib/integrations/azureoidc" + "github.com/gravitational/teleport/lib/utils/oidc" + "github.com/gravitational/teleport/lib/web/scripts/oneoff" +) + +var ( + bold = color.New(color.Bold).SprintFunc() + boldRed = color.New(color.Bold, color.FgRed).SprintFunc() + + step1Template = bold("Step 1: Run the Setup Script") + ` + +1. Open ` + bold("Azure Cloud Shell") + ` (Bash) [https://portal.azure.com/#cloudshell/] using ` + bold("Google Chrome") + ` or ` + bold("Safari") + ` for the best compatibility. +2. Upload the setup script in ` + boldRed("%s") + ` using the ` + bold("Upload") + ` button in the Cloud Shell toolbar. +3. Once uploaded, execute the script by running the following command: + $ bash %s + +` + bold("Important Considerations") + `: +- You must have ` + bold("Azure privileged administrator permissions") + ` to complete the integration. +- Ensure you're using the ` + bold("Bash") + ` environment in Cloud Shell. +- During the script execution, you'll be prompted to run 'az login' to authenticate with Azure. ` + bold("Teleport") + ` does not store or persist your credentials. +- ` + bold("Mozilla Firefox") + ` users may experience connectivity issues in Azure Cloud Shell; using Chrome or Safari is recommended. + +To rerun the script, type 'exit' to close and then restart the process. + +` + + step2Template = ` + +` + bold("Step 2: Input Tenant ID and Client ID") + ` + +With the output of Step 1, please copy and paste the following information: +` +) + +type entraArgs struct { + cmd *kingpin.CmdClause + authConnectorName string + defaultOwners []string + useSystemCredentials bool + accessGraph bool + force bool +} + +func (p *PluginsCommand) initInstallEntra(parent *kingpin.CmdClause) { + p.install.entraID.cmd = parent.Command("entraid", "Install an EntraId integration.") + cmd := p.install.entraID.cmd + cmd. + Flag("name", "Name of the plugin resource to create"). + Default("entra-id"). + StringVar(&p.install.name) + + cmd. + Flag("auth-connector-name", "Name of the SAML connector resource to create"). + Default("entra-id-default"). + StringVar(&p.install.entraID.authConnectorName) + + cmd. + Flag("use-system-credentials", "Uses system credentials instead of OIDC."). + BoolVar(&p.install.entraID.useSystemCredentials) + + cmd.Flag("default-owner", "List of Teleport users that are default owners for the imported access lists. Multiple flags allowed."). + Required(). + StringsVar(&p.install.entraID.defaultOwners) + + cmd. + Flag("access-graph", "Enables Access Graph cache build."). + Default("true"). + BoolVar(&p.install.entraID.accessGraph) + + cmd. + Flag("force", "Proceed with installation even if plugin already exists."). + Short('f'). + Default("false"). + BoolVar(&p.install.entraID.force) +} + +type entraSettings struct { + accessGraphCache *azureoidc.TAGInfoCache + clientID string + tenantID string +} + +var ( + errCancel = trace.BadParameter("operation canceled") +) + +func (p *PluginsCommand) entraSetupGuide(proxyPublicAddr string) (entraSettings, error) { + pwd, err := os.Getwd() + if err != nil { + return entraSettings{}, trace.Wrap(err, "failed to get working dir") + } + f, err := os.CreateTemp(pwd, "entraid-setup-*.sh") + if err != nil { + return entraSettings{}, trace.Wrap(err, "failed to create temp file") + } + + defer os.Remove(f.Name()) + + buildScript, err := buildScript(proxyPublicAddr, p.install.entraID) + if err != nil { + return entraSettings{}, trace.Wrap(err, "failed to build script") + } + + if _, err := f.Write([]byte(buildScript)); err != nil { + return entraSettings{}, trace.Wrap(err, "failed to write script to file") + } + + if err := f.Close(); err != nil { + return entraSettings{}, trace.Wrap(err, "failed to close file") + } + fileLoc := f.Name() + + fmt.Fprintf(os.Stdout, step1Template, fileLoc, filepath.Base(fileLoc)) + + op, err := readData(os.Stdin, os.Stdout, + `Once the script completes, type 'continue' to proceed, 'exit' to quit`, + func(input string) bool { + return input == "continue" || input == "exit" + }, "Invalid input. Please enter 'continue' or 'exit'.") + if err != nil { + return entraSettings{}, trace.Wrap(err, "failed to read operation") + } + if op == "exit" { // User chose to exit + return entraSettings{}, errCancel + } + + validUUID := func(input string) bool { + _, err := uuid.Parse(input) + return err == nil + } + + fmt.Fprint(os.Stdout, step2Template) + + var settings entraSettings + settings.tenantID, err = readData(os.Stdin, os.Stdout, "Enter the Tenant ID", validUUID, "Invalid Tenant ID") + if err != nil { + return settings, trace.Wrap(err, "failed to read Tenant ID") + } + + settings.clientID, err = readData(os.Stdin, os.Stdout, "Enter the Client ID", validUUID, "Invalid Client ID") + if err != nil { + return settings, trace.Wrap(err, "failed to read Client ID") + } + + if p.install.entraID.accessGraph { + dataValidator := func(input string) bool { + settings.accessGraphCache, err = readTAGCache(input) + return err == nil + } + _, err = readData(os.Stdin, os.Stdout, "Enter the Access Graph Cache file location", dataValidator, "File does not exist or is invalid") + if err != nil { + return settings, trace.Wrap(err, "failed to read Access Graph Cache file") + } + } + return settings, nil +} + +// InstallEntra is the entry point for the `tctl plugins install entraid` command. +// This function guides users through an interactive setup process to configure EntraID integration, +// directing them to execute a script in Azure Cloud Shell and provide the required configuration inputs. +// The script creates an Azure EntraID Enterprise Application, enabling SAML logins in Teleport with +// the following claims: +// - givenname: user.givenname +// - surname: user.surname +// - emailaddress: user.mail +// - name: user.userprincipalname +// - groups: user.groups +// Additionally, the script establishes a Trust Policy in the application to allow Teleport +// to be recognized as a credential issuer when system credentials are not used. +// If system credentials are present, the script will skip the Trust policy creation using +// system credentials for EntraID authentication. +// Finally, if no system credentials are in use, the script will set up an Azure OIDC integration +// in Teleport and a Teleport plugin to synchronize access lists from EntraID to Teleport. +func (p *PluginsCommand) InstallEntra(ctx context.Context, args installPluginArgs) error { + inputs := p.install + + proxyPublicAddr, err := getProxyPublicAddr(ctx, args.authClient) + if err != nil { + return trace.Wrap(err) + } + + settings, err := p.entraSetupGuide(proxyPublicAddr) + if err != nil { + if errors.Is(err, errCancel) { + return nil + } + return trace.Wrap(err) + } + + var tagSyncSettings *types.PluginEntraIDAccessGraphSettings + if settings.accessGraphCache != nil { + tagSyncSettings = &types.PluginEntraIDAccessGraphSettings{ + AppSsoSettingsCache: settings.accessGraphCache.AppSsoSettingsCache, + } + } + + saml, err := types.NewSAMLConnector(inputs.entraID.authConnectorName, types.SAMLConnectorSpecV2{ + AssertionConsumerService: strings.TrimRight(proxyPublicAddr, "/") + "/v1/webapi/saml/acs/" + inputs.entraID.authConnectorName, + AllowIDPInitiated: true, + // AttributesToRoles is required, but Entra ID does not have a default group (like Okta's "Everyone"), + // so we add a dummy claim that will always be fulfilled and map them to the "requester" role. + AttributesToRoles: []types.AttributeMapping{ + { + Name: "http://schemas.microsoft.com/ws/2008/06/identity/claims/groups", + Value: "*", + Roles: []string{"requester"}, + }, + }, + Display: "Entra ID", + EntityDescriptorURL: entraapiutils.FederationMetadataURL(settings.tenantID, settings.clientID), + }) + if err != nil { + return trace.Wrap(err, "failed to create SAML connector") + } + + if _, err = args.authClient.CreateSAMLConnector(ctx, saml); err != nil { + if !trace.IsAlreadyExists(err) || !inputs.entraID.force { + return trace.Wrap(err, "failed to create SAML connector") + } + if _, err = args.authClient.UpsertSAMLConnector(ctx, saml); err != nil { + return trace.Wrap(err, "failed to upsert SAML connector") + } + } + + if !inputs.entraID.useSystemCredentials { + integrationSpec, err := types.NewIntegrationAzureOIDC( + types.Metadata{Name: inputs.name}, + &types.AzureOIDCIntegrationSpecV1{ + TenantID: settings.tenantID, + ClientID: settings.clientID, + }, + ) + if err != nil { + return trace.Wrap(err, "failed to create Azure OIDC integration") + } + + if _, err = args.authClient.CreateIntegration(ctx, integrationSpec); err != nil { + if !trace.IsAlreadyExists(err) || !inputs.entraID.force { + return trace.Wrap(err, "failed to create Azure OIDC integration") + } + + integration, err := args.authClient.GetIntegration(ctx, integrationSpec.GetName()) + if err != nil { + return trace.Wrap(err, "failed to get Azure OIDC integration") + } + integration.SetAWSOIDCIntegrationSpec(integrationSpec.GetAWSOIDCIntegrationSpec()) + if _, err = args.authClient.UpdateIntegration(ctx, integration); err != nil { + return trace.Wrap(err, "failed to create Azure OIDC integration") + } + } + } + + credentialsSource := types.EntraIDCredentialsSource_ENTRAID_CREDENTIALS_SOURCE_OIDC + if inputs.entraID.useSystemCredentials { + credentialsSource = types.EntraIDCredentialsSource_ENTRAID_CREDENTIALS_SOURCE_SYSTEM_CREDENTIALS + } + req := &pluginspb.CreatePluginRequest{ + Plugin: &types.PluginV1{ + Metadata: types.Metadata{ + Name: inputs.name, + Labels: map[string]string{ + "teleport.dev/hosted-plugin": "true", + }, + }, + Spec: types.PluginSpecV1{ + Settings: &types.PluginSpecV1_EntraId{ + EntraId: &types.PluginEntraIDSettings{ + SyncSettings: &types.PluginEntraIDSyncSettings{ + DefaultOwners: inputs.entraID.defaultOwners, + SsoConnectorId: inputs.entraID.authConnectorName, + CredentialsSource: credentialsSource, + TenantId: settings.tenantID, + }, + AccessGraphSettings: tagSyncSettings, + }, + }, + }, + }, + } + + _, err = args.plugins.CreatePlugin(ctx, req) + if err != nil { + if !trace.IsAlreadyExists(err) || !inputs.entraID.force { + return trace.Wrap(err) + } + plugin := req.GetPlugin() + { + oldPlugin, err := args.plugins.GetPlugin(ctx, &pluginspb.GetPluginRequest{ + Name: inputs.name, + }) + if err != nil { + return trace.Wrap(err) + } + plugin.Metadata.Revision = oldPlugin.GetMetadata().Revision + } + if _, err = args.plugins.UpdatePlugin(ctx, &pluginspb.UpdatePluginRequest{ + Plugin: plugin, + }); err != nil { + return trace.Wrap(err) + } + } + + fmt.Printf("Successfully created EntraID plugin %q\n\n", p.install.name) + + return nil +} + +func buildScript(proxyPublicAddr string, entraCfg entraArgs) (string, error) { + // The script must execute the following command: + argsList := []string{ + "integration", "configure", "azure-oidc", + fmt.Sprintf("--proxy-public-addr=%s", shsprintf.EscapeDefaultContext(proxyPublicAddr)), + fmt.Sprintf("--auth-connector-name=%s", shsprintf.EscapeDefaultContext(entraCfg.authConnectorName)), + } + + if entraCfg.accessGraph { + argsList = append(argsList, "--access-graph") + } + + if entraCfg.useSystemCredentials { + argsList = append(argsList, "--skip-oidc-integration") + } + + script, err := oneoff.BuildScript(oneoff.OneOffScriptParams{ + TeleportArgs: strings.Join(argsList, " "), + SuccessMessage: "Success! You can now go back to the Teleport Web UI to use the integration with Azure.", + }) + if err != nil { + return "", trace.Wrap(err) + } + return script, nil +} + +func getProxyPublicAddr(ctx context.Context, authClient authClient) (string, error) { + pingResp, err := authClient.Ping(ctx) + if err != nil { + return "", trace.Wrap(err, "failed fetching cluster info") + } + proxyPublicAddr := pingResp.GetProxyPublicAddr() + oidcIssuer, err := oidc.IssuerFromPublicAddress(proxyPublicAddr, "") + return oidcIssuer, trace.Wrap(err) +} + +// readTAGCache reads the TAG cache file and returns the TAGInfoCache object. +// azureoidc.TAGInfoCache is a struct that contains the information necessary for Access Graph to analyze Azure SSO. +// It contains a list of AppID and their corresponding FederatedSsoV2 information. +func readTAGCache(fileLoc string) (*azureoidc.TAGInfoCache, error) { + if fileLoc == "" { + return nil, trace.BadParameter("no TAG cache file specified") + } + + file, err := os.Open(fileLoc) + if err != nil { + return nil, trace.Wrap(err) + } + defer file.Close() + + var result azureoidc.TAGInfoCache + if err := json.NewDecoder(file).Decode(&result); err != nil { + return nil, trace.Wrap(err) + } + + return &result, nil +} + +func readData(r io.Reader, w io.Writer, message string, validate func(string) bool, errorMessage string) (string, error) { + reader := bufio.NewReader(r) + for { + fmt.Fprintf(w, "%s: ", message) + input, _ := reader.ReadString('\n') + input = strings.TrimSpace(input) // Clean up any extra newlines or spaces + + if !validate(input) { + fmt.Fprintf(w, "%s\n", errorMessage) + continue + } + return input, nil + } +} diff --git a/tool/tctl/common/plugin/plugins_command.go b/tool/tctl/common/plugin/plugins_command.go index ba6c92f7ae5a9..df8b9eeb4ed3b 100644 --- a/tool/tctl/common/plugin/plugins_command.go +++ b/tool/tctl/common/plugin/plugins_command.go @@ -49,10 +49,11 @@ func logErrorMessage(err error) slog.Attr { } type pluginInstallArgs struct { - cmd *kingpin.CmdClause - name string - okta oktaArgs - scim scimArgs + cmd *kingpin.CmdClause + name string + okta oktaArgs + scim scimArgs + entraID entraArgs } type scimArgs struct { @@ -98,6 +99,7 @@ func (p *PluginsCommand) initInstall(parent *kingpin.CmdClause, config *servicec p.initInstallOkta(p.install.cmd) p.initInstallSCIM(p.install.cmd) + p.initInstallEntra(p.install.cmd) } func (p *PluginsCommand) initInstallSCIM(parent *kingpin.CmdClause) { @@ -200,11 +202,18 @@ func (p *PluginsCommand) Cleanup(ctx context.Context, clusterAPI *authclient.Cli type authClient interface { GetSAMLConnector(ctx context.Context, id string, withSecrets bool) (types.SAMLConnector, error) + CreateSAMLConnector(ctx context.Context, connector types.SAMLConnector) (types.SAMLConnector, error) + UpsertSAMLConnector(ctx context.Context, connector types.SAMLConnector) (types.SAMLConnector, error) + CreateIntegration(ctx context.Context, ig types.Integration) (types.Integration, error) + GetIntegration(ctx context.Context, name string) (types.Integration, error) + UpdateIntegration(ctx context.Context, ig types.Integration) (types.Integration, error) Ping(ctx context.Context) (proto.PingResponse, error) } type pluginsClient interface { CreatePlugin(ctx context.Context, in *pluginsv1.CreatePluginRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + GetPlugin(ctx context.Context, in *pluginsv1.GetPluginRequest, opts ...grpc.CallOption) (*types.PluginV1, error) + UpdatePlugin(ctx context.Context, in *pluginsv1.UpdatePluginRequest, opts ...grpc.CallOption) (*types.PluginV1, error) } type installPluginArgs struct { @@ -310,6 +319,9 @@ func (p *PluginsCommand) TryRun(ctx context.Context, cmd string, client *authcli err = p.InstallOkta(ctx, args) case p.install.scim.cmd.FullCommand(): err = p.InstallSCIM(ctx, client) + case p.install.entraID.cmd.FullCommand(): + args := installPluginArgs{authClient: client, plugins: client.PluginsClient()} + err = p.InstallEntra(ctx, args) case p.delete.cmd.FullCommand(): err = p.Delete(ctx, client) default: diff --git a/tool/tctl/common/plugin/plugins_command_test.go b/tool/tctl/common/plugin/plugins_command_test.go index e42f21e26310f..9033311f3272c 100644 --- a/tool/tctl/common/plugin/plugins_command_test.go +++ b/tool/tctl/common/plugin/plugins_command_test.go @@ -449,6 +449,16 @@ func (m *mockPluginsClient) CreatePlugin(ctx context.Context, in *pluginsv1.Crea return result.Get(0).(*emptypb.Empty), result.Error(1) } +func (m *mockPluginsClient) GetPlugin(ctx context.Context, in *pluginsv1.GetPluginRequest, opts ...grpc.CallOption) (*types.PluginV1, error) { + result := m.Called(ctx, in, opts) + return result.Get(0).(*types.PluginV1), result.Error(1) +} + +func (m *mockPluginsClient) UpdatePlugin(ctx context.Context, in *pluginsv1.UpdatePluginRequest, opts ...grpc.CallOption) (*types.PluginV1, error) { + result := m.Called(ctx, in, opts) + return result.Get(0).(*types.PluginV1), result.Error(1) +} + type mockAuthClient struct { mock.Mock } @@ -457,6 +467,27 @@ func (m *mockAuthClient) GetSAMLConnector(ctx context.Context, id string, withSe result := m.Called(ctx, id, withSecrets) return result.Get(0).(types.SAMLConnector), result.Error(1) } +func (m *mockAuthClient) CreateSAMLConnector(ctx context.Context, connector types.SAMLConnector) (types.SAMLConnector, error) { + result := m.Called(ctx, connector) + return result.Get(0).(types.SAMLConnector), result.Error(1) +} +func (m *mockAuthClient) UpsertSAMLConnector(ctx context.Context, connector types.SAMLConnector) (types.SAMLConnector, error) { + result := m.Called(ctx, connector) + return result.Get(0).(types.SAMLConnector), result.Error(1) +} +func (m *mockAuthClient) CreateIntegration(ctx context.Context, ig types.Integration) (types.Integration, error) { + result := m.Called(ctx, ig) + return result.Get(0).(types.Integration), result.Error(1) +} +func (m *mockAuthClient) UpdateIntegration(ctx context.Context, ig types.Integration) (types.Integration, error) { + result := m.Called(ctx, ig) + return result.Get(0).(types.Integration), result.Error(1) +} + +func (m *mockAuthClient) GetIntegration(ctx context.Context, name string) (types.Integration, error) { + result := m.Called(ctx, name) + return result.Get(0).(types.Integration), result.Error(1) +} func (m *mockAuthClient) Ping(ctx context.Context) (proto.PingResponse, error) { result := m.Called(ctx) diff --git a/tool/teleport/common/integration_configure.go b/tool/teleport/common/integration_configure.go index b79d285010dab..7edb6ad0e810d 100644 --- a/tool/teleport/common/integration_configure.go +++ b/tool/teleport/common/integration_configure.go @@ -250,7 +250,7 @@ func onIntegrationConfAzureOIDCCmd(ctx context.Context, params config.Integratio fmt.Println("Teleport is setting up the Azure integration. This may take a few minutes.") - appID, tenantID, err := azureoidc.SetupEnterpriseApp(ctx, params.ProxyPublicAddr, params.AuthConnectorName) + appID, tenantID, err := azureoidc.SetupEnterpriseApp(ctx, params.ProxyPublicAddr, params.AuthConnectorName, params.SkipOIDCConfiguration) if err != nil { return trace.Wrap(err) } diff --git a/tool/teleport/common/teleport.go b/tool/teleport/common/teleport.go index 3ef745f4afc0e..6ab4e4b0e7af2 100644 --- a/tool/teleport/common/teleport.go +++ b/tool/teleport/common/teleport.go @@ -551,6 +551,7 @@ func Run(options Options) (app *kingpin.Application, executedCommand string, con integrationConfAzureOIDCCmd.Flag("proxy-public-addr", "The public address of Teleport Proxy Service").Required().StringVar(&ccf.IntegrationConfAzureOIDCArguments.ProxyPublicAddr) integrationConfAzureOIDCCmd.Flag("auth-connector-name", "The name of Entra ID SAML Auth connector in Teleport.").Required().StringVar(&ccf.IntegrationConfAzureOIDCArguments.AuthConnectorName) integrationConfAzureOIDCCmd.Flag("access-graph", "Enable Access Graph integration.").BoolVar(&ccf.IntegrationConfAzureOIDCArguments.AccessGraphEnabled) + integrationConfAzureOIDCCmd.Flag("skip-oidc-integration", "Skip OIDC integration.").BoolVar(&ccf.IntegrationConfAzureOIDCArguments.SkipOIDCConfiguration) integrationConfSAMLIdP := integrationConfigureCmd.Command("samlidp", "Manage SAML IdP integrations.") integrationSAMLIdPGCPWorkforce := integrationConfSAMLIdP.Command("gcp-workforce", "Configures GCP Workforce Identity Federation pool and SAML provider.") From ec98f769d804dcffe9825d313224bddb76b9aebe Mon Sep 17 00:00:00 2001 From: Bartosz Leper Date: Wed, 30 Oct 2024 11:52:39 +0100 Subject: [PATCH 5/5] Update e/ reference (#48119) --- e | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/e b/e index 4f6680c23b769..cc7fefb390f14 160000 --- a/e +++ b/e @@ -1 +1 @@ -Subproject commit 4f6680c23b769510330646b68bac4e92682f869f +Subproject commit cc7fefb390f14edad07539c81264b327070e2558