From a56bc4ed7bd59ab2e54470ec34091b8e6d74f16d Mon Sep 17 00:00:00 2001 From: rosstimothy <39066650+rosstimothy@users.noreply.github.com> Date: Fri, 6 Dec 2024 13:21:43 -0500 Subject: [PATCH 01/16] Attempt to reduce flakiness of integration tests (#49888) Closes #47156. All of the tests suffering from issues dialing hosts, and failing with a `failed to dial target host` error were incorrectly waiting for nodes to become visible before establishing connections. The main culprit for most of the failures was `waitForNodesToRegister`, though a few tests had a very similar hand rolled variant, which incorrectly returned when the nodes appeard in Auth. However, since the Proxy is the one performing dialing, they should have waited for the nodes to appear in the Proxy. To resolve, `waitForNodesToRegister` and all hand rolled equivalents have been removed in favor of `(TeleInstance) WaitForNodeCount` which correctly uses the `CachingAccessPoint` of the RemoteSite instead of `GetClient`. Additionally, `helpers.WaitForNodeCount` was updated to validate that the node watcher used for routing in the Proxy also contained the expected number of nodes. --- integration/helpers/helpers.go | 5 +- integration/helpers/instance.go | 50 +++++++++ integration/helpers/trustedclusters.go | 33 ------ integration/integration_test.go | 137 +++++++------------------ integration/proxy/proxy_helpers.go | 2 +- integration/proxy/proxy_test.go | 6 +- 6 files changed, 92 insertions(+), 141 deletions(-) diff --git a/integration/helpers/helpers.go b/integration/helpers/helpers.go index 7d1b7e58b819f..fdede24b0209a 100644 --- a/integration/helpers/helpers.go +++ b/integration/helpers/helpers.go @@ -132,10 +132,7 @@ func ExternalSSHCommand(o CommandOptions) (*exec.Cmd, error) { } // Create an exec.Command and tell it where to find the SSH agent. - cmd, err := exec.Command(sshpath, execArgs...), nil - if err != nil { - return nil, trace.Wrap(err) - } + cmd := exec.Command(sshpath, execArgs...) cmd.Env = []string{fmt.Sprintf("SSH_AUTH_SOCK=%v", o.SocketPath)} return cmd, nil diff --git a/integration/helpers/instance.go b/integration/helpers/instance.go index 275837306b9d3..cdff68ef04e2a 100644 --- a/integration/helpers/instance.go +++ b/integration/helpers/instance.go @@ -45,8 +45,10 @@ import ( "github.com/gravitational/teleport/api/breaker" clientproto "github.com/gravitational/teleport/api/client/proto" + apidefaults "github.com/gravitational/teleport/api/defaults" "github.com/gravitational/teleport/api/types" "github.com/gravitational/teleport/api/utils/keys" + "github.com/gravitational/teleport/api/utils/retryutils" "github.com/gravitational/teleport/lib/auth/authclient" "github.com/gravitational/teleport/lib/auth/keygen" "github.com/gravitational/teleport/lib/auth/state" @@ -1765,3 +1767,51 @@ func (i *TeleInstance) StopAll() error { i.Log.Infof("Stopped all teleport services for site %q", i.Secrets.SiteName) return trace.NewAggregate(errors...) } + +// WaitForNodeCount waits for a certain number of nodes in the provided cluster +// to be visible to the Proxy. This should be called prior to any client dialing +// of nodes to be sure that the node is registered and routable. +func (i *TeleInstance) WaitForNodeCount(ctx context.Context, cluster string, count int) error { + const ( + deadline = time.Second * 30 + iterWaitTime = time.Second + ) + + err := retryutils.RetryStaticFor(deadline, iterWaitTime, func() error { + site, err := i.Tunnel.GetSite(cluster) + if err != nil { + return trace.Wrap(err) + } + + // Validate that the site cache contains the expected count. + accessPoint, err := site.CachingAccessPoint() + if err != nil { + return trace.Wrap(err) + } + + nodes, err := accessPoint.GetNodes(ctx, apidefaults.Namespace) + if err != nil { + return trace.Wrap(err) + } + if len(nodes) != count { + return trace.BadParameter("cache contained %v nodes, but wanted to find %v nodes", len(nodes), count) + } + + // Validate that the site watcher contains the expected count. + watcher, err := site.NodeWatcher() + if err != nil { + return trace.Wrap(err) + } + + if watcher.ResourceCount() != count { + return trace.BadParameter("node watcher contained %v nodes, but wanted to find %v nodes", watcher.ResourceCount(), count) + } + + return nil + }) + if err != nil { + return trace.Wrap(err) + } + + return nil +} diff --git a/integration/helpers/trustedclusters.go b/integration/helpers/trustedclusters.go index a883fb8635a9e..1b3f43b61507c 100644 --- a/integration/helpers/trustedclusters.go +++ b/integration/helpers/trustedclusters.go @@ -30,9 +30,7 @@ import ( "github.com/stretchr/testify/require" "github.com/gravitational/teleport" - "github.com/gravitational/teleport/api/defaults" "github.com/gravitational/teleport/api/types" - "github.com/gravitational/teleport/api/utils/retryutils" "github.com/gravitational/teleport/lib/auth" "github.com/gravitational/teleport/lib/reversetunnelclient" ) @@ -112,37 +110,6 @@ func WaitForClusters(tun reversetunnelclient.Server, expected int) func() bool { } } -// WaitForNodeCount waits for a certain number of nodes to show up in the remote site. -func WaitForNodeCount(ctx context.Context, t *TeleInstance, clusterName string, count int) error { - const ( - deadline = time.Second * 30 - iterWaitTime = time.Second - ) - - err := retryutils.RetryStaticFor(deadline, iterWaitTime, func() error { - remoteSite, err := t.Tunnel.GetSite(clusterName) - if err != nil { - return trace.Wrap(err) - } - accessPoint, err := remoteSite.CachingAccessPoint() - if err != nil { - return trace.Wrap(err) - } - nodes, err := accessPoint.GetNodes(ctx, defaults.Namespace) - if err != nil { - return trace.Wrap(err) - } - if len(nodes) == count { - return nil - } - return trace.BadParameter("found %v nodes, but wanted to find %v nodes", len(nodes), count) - }) - if err != nil { - return trace.Wrap(err) - } - return nil -} - // WaitForActiveTunnelConnections waits for remote cluster to report a minimum number of active connections func WaitForActiveTunnelConnections(t *testing.T, tunnel reversetunnelclient.Server, clusterName string, expectedCount int) { require.EventuallyWithT(t, func(t *assert.CollectT) { diff --git a/integration/integration_test.go b/integration/integration_test.go index f49dfb06f5e0c..e1f3e9e07796b 100644 --- a/integration/integration_test.go +++ b/integration/integration_test.go @@ -442,27 +442,9 @@ func testAuditOn(t *testing.T, suite *integrationTestSuite) { ctx := context.Background() - // wait 10 seconds for both nodes to show up, otherwise + // wait for both nodes to show up, otherwise // we'll have trouble connecting to the node below. - waitForNodes := func(site authclient.ClientI, count int) error { - tickCh := time.Tick(500 * time.Millisecond) - stopCh := time.After(10 * time.Second) - for { - select { - case <-tickCh: - nodesInSite, err := site.GetNodes(ctx, defaults.Namespace) - if err != nil && !trace.IsNotFound(err) { - return trace.Wrap(err) - } - if got, want := len(nodesInSite), count; got == want { - return nil - } - case <-stopCh: - return trace.BadParameter("waited 10s, did find %v nodes", count) - } - } - } - err = waitForNodes(site, 2) + err = teleport.WaitForNodeCount(ctx, helpers.Site, 2) require.NoError(t, err) // should have no sessions: @@ -796,8 +778,6 @@ func testUUIDBasedProxy(t *testing.T, suite *integrationTestSuite) { teleportSvr := suite.newTeleport(t, nil, true) defer teleportSvr.StopAll() - site := teleportSvr.GetSiteAPI(helpers.Site) - // addNode adds a node to the teleport instance, returning its uuid. // All nodes added this way have the same hostname. addNode := func() (string, error) { @@ -819,36 +799,11 @@ func testUUIDBasedProxy(t *testing.T, suite *integrationTestSuite) { uuid1, err := addNode() require.NoError(t, err) - uuid2, err := addNode() + _, err = addNode() require.NoError(t, err) - // wait up to 10 seconds for supplied node names to show up. - waitForNodes := func(site authclient.ClientI, nodes ...string) error { - tickCh := time.Tick(500 * time.Millisecond) - stopCh := time.After(10 * time.Second) - Outer: - for _, nodeName := range nodes { - for { - select { - case <-tickCh: - nodesInSite, err := site.GetNodes(ctx, defaults.Namespace) - if err != nil && !trace.IsNotFound(err) { - return trace.Wrap(err) - } - for _, node := range nodesInSite { - if node.GetName() == nodeName { - continue Outer - } - } - case <-stopCh: - return trace.BadParameter("waited 10s, did find node %s", nodeName) - } - } - } - return nil - } - - err = waitForNodes(site, uuid1, uuid2) + // wait for supplied node names to show up. + err = teleportSvr.WaitForNodeCount(ctx, helpers.Site, 3) require.NoError(t, err) // attempting to run a command by hostname should generate NodeIsAmbiguous error. @@ -2150,7 +2105,8 @@ func runDisconnectTest(t *testing.T, suite *integrationTestSuite, tc disconnectT tc.concurrentConns = 1 } - waitForNodesToRegister(t, teleport, helpers.Site) + err = teleport.WaitForNodeCount(ctx, helpers.Site, 1) + require.NoError(t, err) asyncErrors := make(chan error, 1) @@ -2169,7 +2125,11 @@ func runDisconnectTest(t *testing.T, suite *integrationTestSuite, tc disconnectT tc.clientConfigOpts(&cc) } cl, err := teleport.NewClient(cc) - require.NoError(t, err) + if err != nil { + asyncErrors <- err + return + } + cl.Stdout = person cl.Stdin = person @@ -3139,6 +3099,10 @@ func trustedClusters(t *testing.T, suite *integrationTestSuite, test trustedClus cmd := []string{"echo", "hello world"} + // Wait for nodes to be visible before attempting connections + err = main.WaitForNodeCount(ctx, clusterAux, 2) + require.NoError(t, err) + // Try and connect to a node in the Aux cluster from the Main cluster using // direct dialing. creds, err := helpers.GenerateUserCreds(helpers.UserCredsRequest{ @@ -3224,6 +3188,10 @@ func trustedClusters(t *testing.T, suite *integrationTestSuite, test trustedClus require.Eventually(t, helpers.WaitForClusters(main.Tunnel, 1), 10*time.Second, 1*time.Second, "Two clusters do not see each other: tunnels are not working.") + // Wait for nodes to be visible before attempting connections + err = main.WaitForNodeCount(ctx, clusterAux, 2) + require.NoError(t, err) + // connection and client should recover and work again output = &bytes.Buffer{} tc.Stdout = output @@ -3630,7 +3598,7 @@ func testTrustedTunnelNode(t *testing.T, suite *integrationTestSuite) { "Two clusters do not see each other: tunnels are not working.") // Wait for both nodes to show up before attempting to dial to them. - err = helpers.WaitForNodeCount(ctx, main, clusterAux, 2) + err = main.WaitForNodeCount(ctx, clusterAux, 2) require.NoError(t, err) cmd := []string{"echo", "hello world"} @@ -4026,7 +3994,8 @@ func testDiscovery(t *testing.T, suite *integrationTestSuite) { helpers.WaitForActiveTunnelConnections(t, main.Tunnel, "cluster-remote", 1) helpers.WaitForActiveTunnelConnections(t, secondProxy, "cluster-remote", 1) - waitForNodesToRegister(t, main, "cluster-remote") + err = main.WaitForNodeCount(ctx, "cluster-remote", 1) + require.NoError(t, err) // execute the connection via first proxy cfg := helpers.ClientConfig{ @@ -4077,7 +4046,8 @@ func testDiscovery(t *testing.T, suite *integrationTestSuite) { helpers.WaitForActiveTunnelConnections(t, main.Tunnel, "cluster-remote", 1) helpers.WaitForActiveTunnelConnections(t, secondProxy, "cluster-remote", 1) - waitForNodesToRegister(t, main, "cluster-remote") + err = main.WaitForNodeCount(ctx, "cluster-remote", 1) + require.NoError(t, err) // Requests going via main proxy should succeed. output, err = runCommand(t, main, []string{"echo", "hello world"}, cfg, 1) @@ -4859,11 +4829,8 @@ func testProxyHostKeyCheck(t *testing.T, suite *integrationTestSuite) { require.NoError(t, err) // Wait for the node to be visible before continuing. - require.EventuallyWithT(t, func(t *assert.CollectT) { - found, err := clt.GetNodes(context.Background(), defaults.Namespace) - assert.NoError(t, err) - assert.Len(t, found, 2) - }, 10*time.Second, 100*time.Millisecond) + err = instance.WaitForNodeCount(context.Background(), helpers.Site, 2) + require.NoError(t, err) _, err = runCommand(t, instance, []string{"echo hello"}, clientConfig, 1) @@ -5956,27 +5923,9 @@ func testList(t *testing.T, suite *integrationTestSuite) { clt := teleport.GetSiteAPI(helpers.Site) require.NotNil(t, clt) - // Wait 10 seconds for both nodes to show up to make sure they both have + // Wait for both nodes to show up to make sure they both have // registered themselves. - waitForNodes := func(clt authclient.ClientI, count int) error { - tickCh := time.Tick(500 * time.Millisecond) - stopCh := time.After(10 * time.Second) - for { - select { - case <-tickCh: - nodesInCluster, err := clt.GetNodes(ctx, defaults.Namespace) - if err != nil && !trace.IsNotFound(err) { - return trace.Wrap(err) - } - if got, want := len(nodesInCluster), count; got == want { - return nil - } - case <-stopCh: - return trace.BadParameter("waited 10s, did find %v nodes", count) - } - } - } - err = waitForNodes(clt, 2) + err = teleport.WaitForNodeCount(ctx, helpers.Site, 2) require.NoError(t, err) tests := []struct { @@ -6158,22 +6107,6 @@ func testCmdLabels(t *testing.T, suite *integrationTestSuite) { } } -func waitForNodesToRegister(t *testing.T, teleport *helpers.TeleInstance, site string) { - t.Helper() - require.EventuallyWithT(t, func(t *assert.CollectT) { - // once the tunnel is established we need to wait until we have a - // connection to the remote auth - site := teleport.GetSiteAPI(site) - if !assert.NotNil(t, site) { - return - } - // we need to wait until we know about the node because direct dial to - // unregistered servers is no longer supported - _, err := site.GetNode(context.Background(), defaults.Namespace, teleport.Config.HostUUID) - assert.NoError(t, err) - }, time.Second*30, 250*time.Millisecond) -} - // TestDataTransfer makes sure that a "session.data" event is emitted at the // end of a session that matches the amount of data that was transferred. func testDataTransfer(t *testing.T, suite *integrationTestSuite) { @@ -6187,6 +6120,9 @@ func testDataTransfer(t *testing.T, suite *integrationTestSuite) { main := suite.newTeleport(t, nil, true) defer main.StopAll() + err := main.WaitForNodeCount(context.Background(), helpers.Site, 1) + require.NoError(t, err) + // Create a client to the above Teleport cluster. clientConfig := helpers.ClientConfig{ Login: suite.Me.Username, @@ -6195,8 +6131,6 @@ func testDataTransfer(t *testing.T, suite *integrationTestSuite) { Port: helpers.Port(t, main.SSH), } - waitForNodesToRegister(t, main, helpers.Site) - // Write 1 MB to stdout. command := []string{"dd", "if=/dev/zero", "bs=1024", "count=1024"} output, err := runCommand(t, main, command, clientConfig, 1) @@ -7155,6 +7089,7 @@ func (s *integrationTestSuite) defaultServiceConfig() *servicecfg.Config { cfg.Log = s.Log cfg.CircuitBreakerConfig = breaker.NoopBreakerConfig() cfg.InstanceMetadataClient = imds.NewDisabledIMDSClient() + cfg.DebugService.Enabled = false return cfg } @@ -7778,7 +7713,8 @@ func testModeratedSFTP(t *testing.T, suite *integrationTestSuite) { _, err = authServer.CreateUser(ctx, moderatorUser) require.NoError(t, err) - waitForNodesToRegister(t, instance, helpers.Site) + err = instance.WaitForNodeCount(context.Background(), helpers.Site, 1) + require.NoError(t, err) // Start a shell so a moderated session is created peerClient, err := instance.NewClient(helpers.ClientConfig{ @@ -8036,7 +7972,8 @@ func testSFTP(t *testing.T, suite *integrationTestSuite) { teleport.StopAll() }) - waitForNodesToRegister(t, teleport, helpers.Site) + err := teleport.WaitForNodeCount(context.Background(), helpers.Site, 1) + require.NoError(t, err) teleportClient, err := teleport.NewClient(helpers.ClientConfig{ Login: suite.Me.Username, diff --git a/integration/proxy/proxy_helpers.go b/integration/proxy/proxy_helpers.go index 422695a363d45..e0e3c7b587224 100644 --- a/integration/proxy/proxy_helpers.go +++ b/integration/proxy/proxy_helpers.go @@ -216,7 +216,7 @@ func (p *Suite) addNodeToLeafCluster(t *testing.T, tunnelNodeHostname string) { "Two clusters do not see each other: tunnels are not working.") // Wait for both nodes to show up before attempting to dial to them. - err = helpers.WaitForNodeCount(context.Background(), p.root, p.leaf.Secrets.SiteName, 2) + err = p.root.WaitForNodeCount(context.Background(), p.leaf.Secrets.SiteName, 2) require.NoError(t, err) } diff --git a/integration/proxy/proxy_test.go b/integration/proxy/proxy_test.go index 43d6254911a3b..0dcf986d70109 100644 --- a/integration/proxy/proxy_test.go +++ b/integration/proxy/proxy_test.go @@ -1614,7 +1614,7 @@ func TestALPNProxyHTTPProxyNoProxyDial(t *testing.T) { ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second*30)) defer cancel() - err = helpers.WaitForNodeCount(ctx, rc, "root.example.com", 1) + err = rc.WaitForNodeCount(ctx, "root.example.com", 1) require.NoError(t, err) require.Zero(t, ph.Count()) @@ -1624,7 +1624,7 @@ func TestALPNProxyHTTPProxyNoProxyDial(t *testing.T) { require.NoError(t, os.Unsetenv("no_proxy")) _, err = rc.StartNode(makeNodeConfig("second-root-node", rcProxyAddr)) require.NoError(t, err) - err = helpers.WaitForNodeCount(ctx, rc, "root.example.com", 2) + err = rc.WaitForNodeCount(ctx, "root.example.com", 2) require.NoError(t, err) require.NotZero(t, ph.Count()) @@ -1723,7 +1723,7 @@ func TestALPNProxyHTTPProxyBasicAuthDial(t *testing.T) { startErrC <- err }() require.NoError(t, <-startErrC) - require.NoError(t, helpers.WaitForNodeCount(context.Background(), rc, rc.Secrets.SiteName, 1)) + require.NoError(t, rc.WaitForNodeCount(context.Background(), rc.Secrets.SiteName, 1)) require.Greater(t, ph.Count(), 0) } From aa971ffda19ef66ee867dc7e599bc48d4db9243a Mon Sep 17 00:00:00 2001 From: Paul Gottschling Date: Fri, 6 Dec 2024 14:03:49 -0500 Subject: [PATCH 02/16] Fix Vale warnings in the Session Recording guide (#49878) This docs page is tied for the highest number of Vale warnings by page. --- .../architecture/session-recording.mdx | 33 ++++++++++--------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/docs/pages/reference/architecture/session-recording.mdx b/docs/pages/reference/architecture/session-recording.mdx index eae3e56e84d33..1f40d9d6eb35d 100644 --- a/docs/pages/reference/architecture/session-recording.mdx +++ b/docs/pages/reference/architecture/session-recording.mdx @@ -91,7 +91,7 @@ Proxy Server cannot see the SSH traffic to the node. It is encrypted end-to-end In **Recording Proxy Mode**, the Proxy Service terminates (decrypts) the SSH connection using the certificate supplied by the client via SSH agent forwarding and then establishes its own SSH connection to the final destination server. -This allows the Proxy Service to forward SSH session data to the auth server to +This allows the Proxy Service to forward SSH session data to the Auth Service to be recorded, as shown below: ![recording-proxy](../../../img/recording-proxy.svg) @@ -124,7 +124,7 @@ Auth Service. When synchronous recording is enabled, the Teleport component doing the recording (which may be the Teleport SSH Service or the Proxy Service instance depending on your configuration) -submits each recording event to Teleport's Auth Server as it occurs. In this mode, +submits each recording event to Teleport's Auth Service as it occurs. In this mode, failure to emit a recording event is considered fatal - the session will be terminated if an event cannot be recorded. This makes synchronous recording best suited for highly regulated environments where you need to be confident that all data is recorded. @@ -132,9 +132,9 @@ This also means that you need a reliable and low-latency connection to the Auth Server for the duration of the session to ensure that the session isn't interrupted or terminated due to temporary connection loss. -In synchronous recording modes, the Auth Server receives a stream of recording +In synchronous recording modes, the Auth Service receives a stream of recording events and is responsible for assembling them into the final artifact and uploading -it to the storage backend. Since data is streamed directly to the Auth Server, +it to the storage backend. Since data is streamed directly to the Auth Service, Teleport administrators don't need to be concerned with disk space on their Teleport SSH Service and Proxy Service instances, as no recording data is written to those disks. @@ -143,7 +143,7 @@ written to those disks. When asynchronous, recording events are written to the local filesystem during the session. When the session completes, Teleport assembles the parts into a -complete recording and submits the entire recording to the Auth Server for storage. +complete recording and submits the entire recording to the Auth Service for storage. Since recording data is flushed to disk, administrators should be careful to ensure that the system has enough disk space to accommodate the expected number of Teleport @@ -152,13 +152,14 @@ is a greater chance that it can be tampered with, deleted, or otherwise corrupte before the upload completes. The advantage of asynchronous recording is that it doesn't require a persistent -connection to the Auth Server. For example, an SSH session can continue to operate -even if Teleport's Auth Server goes down. When the session completes Teleport will -attempt to upload the recording to the Auth Server. If the Auth Server is still +connection to the Auth Service. For example, an SSH session can continue to operate +even if Teleport's Auth Service goes down. When the session completes Teleport will +attempt to upload the recording to the Auth Service. If the Auth Service is still unavailable, Teleport has built-in retry and backoff mechanisms that will upload -the artifact when the Auth Server comes back online. Additionally, asynchronous +the artifact when the Auth Service comes back online. Additionally, asynchronous recording is well-suited towards recording sessions that are extra chatty or in -environments where the connection to the auth server is unreliable or high-latency. +environments where the connection to the Auth Service is unreliable or +high-latency. ## Storage @@ -209,17 +210,17 @@ to be completed. In asynchronous recording modes, if the node goes down during the session, the partially completed recording will sit on the node's disk. The node's upload completer will eventually -detect the abandoned upload and stream it to the Teleport Auth Server where it will be +detect the abandoned upload and stream it to the Teleport Auth Service where it will be written to the storage backend. -In synchronous recording modes, Teleport's Auth Server is streaming the recording directly -to storage. If the Auth Server goes down during a session, the uncompleted upload will sit -as a series of parts (in cloud storage or on the Auth Server's disk) and it is the -responsibility of the Auth Server's upload completer to detect the abandoned upload and +In synchronous recording modes, Teleport's Auth Service is streaming the recording directly +to storage. If the Auth Service goes down during a session, the uncompleted upload will sit +as a series of parts (in cloud storage or on an Auth Service instance's disk) and it is the +responsibility of the Auth Service's upload completer to detect the abandoned upload and complete it. ## Related reading - [Recording Proxy Mode](../../enroll-resources/server-access/guides/recording-proxy-mode.mdx) - [SSH recording modes](../monitoring/audit.mdx) -- [Desktop Access recording](../agent-services/desktop-access-reference/sessions.mdx) +- [Session recording for desktops](../agent-services/desktop-access-reference/sessions.mdx) From 443354dd717932d5f5b74ce00e3b66b7a56ab4c6 Mon Sep 17 00:00:00 2001 From: Paul Gottschling Date: Fri, 6 Dec 2024 14:03:57 -0500 Subject: [PATCH 03/16] Add DEB/RPM package info to the Installation guide (#49825) Closes #21264 Edit the section on downloading TAR archives, since this already includes information on installing Teleport from a local, downloaded file. --- docs/cspell.json | 1 + docs/pages/installation.mdx | 87 +++++++++++++++++++++++++++++++------ 2 files changed, 75 insertions(+), 13 deletions(-) diff --git a/docs/cspell.json b/docs/cspell.json index 108255715c1c6..0f3c97dfdf644 100644 --- a/docs/cspell.json +++ b/docs/cspell.json @@ -613,6 +613,7 @@ "lmnop", "loadbalancer", "localca", + "localinstall", "loginerrortroubleshooting", "loginrule", "loginrules", diff --git a/docs/pages/installation.mdx b/docs/pages/installation.mdx index bc5793a03d31e..fbc2671d74b92 100644 --- a/docs/pages/installation.mdx +++ b/docs/pages/installation.mdx @@ -317,14 +317,15 @@ repositories. -### TAR archives (self-hosted only) +### Downloading packages and TAR archives (self-hosted only) -For self-hosted deployments, Teleport maintains TAR archives for +Teleport maintains TAR archives as well as DEB and RPM packages for Linux-compatible binaries at `https://cdn.teleport.dev`. This section explains -the Teleport TAR archives and how to use them. +how to install Teleport by manually downloading a release. -It is not possible to install the automatic agent updater using TAR archives. -Teleport Cloud customers must use the [one-line installation +It is not possible to install the automatic agent updater using this method, so +using packages and TAR archives is only available for users who self-hosted +Teleport. Teleport Cloud customers must use the [one-line installation script](#one-line-installation-script) or manually install Teleport from a [package repository](#package-repositories) in order to install the updater. @@ -354,38 +355,98 @@ script](#one-line-installation-script) or manually install Teleport from a The following architecture values are available: - - `amd64` + - `amd64` (`x86_84` if downloading an RPM package) - `arm64` - `arm` - - `386` + - `386` (`i386` if downloading a DEB or RPM package) -1. Run the following commands to download the Teleport archive, unpack it, and - install binaries: +1. Run the following commands to download a Teleport package or archive, unpack + it, and install binaries: + + + ```code $ curl https://cdn.teleport.dev/${TELEPORT_PKG?}-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-bin.tar.gz.sha256 # $ curl -O https://cdn.teleport.dev/${TELEPORT_PKG?}-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-bin.tar.gz - $ shasum -a 256 ${TELEPORT_PKG?}-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-bin.tar.gz - # Verify that the checksums match + $ shasum --check -a 256 ${TELEPORT_PKG?}-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-bin.tar.gz $ tar -xvf ${TELEPORT_PKG?}-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-bin.tar.gz $ cd ${TELEPORT_PKG?} $ sudo ./install ``` + + + + ```code + $ curl https://cdn.teleport.dev/${TELEPORT_PKG?}_${TELEPORT_VERSION?}_${SYSTEM_ARCH?}.deb.sha256 + # + $ curl -O https://cdn.teleport.dev/${TELEPORT_PKG?}_${TELEPORT_VERSION?}_${SYSTEM_ARCH?}.deb + $ shasum --check -a 256 ${TELEPORT_PKG?}_${TELEPORT_VERSION?}_${SYSTEM_ARCH?}.deb + $ sudo dpkg -i ${TELEPORT_PKG?}_${TELEPORT_VERSION?}_${SYSTEM_ARCH?}.deb + ``` + + + + + ```code + $ curl https://cdn.teleport.dev/${TELEPORT_PKG?}-${TELEPORT_VERSION?}-1.${SYSTEM_ARCH?}.rpm.sha256 + # + $ curl -O https://cdn.teleport.dev/${TELEPORT_PKG?}-${TELEPORT_VERSION?}-1.${SYSTEM_ARCH?}.rpm + $ shasum --check -a 256 https://cdn.teleport.dev/${TELEPORT_PKG?}-${TELEPORT_VERSION?}-1.${SYSTEM_ARCH?}.rpm + # Or use yum localinstall, dnf localinstall etc. + $ sudo rpm -i https://cdn.teleport.dev/${TELEPORT_PKG?}-${TELEPORT_VERSION?}-1.${SYSTEM_ARCH?}.rpm + ``` + + + For FedRAMP/FIPS-compliant installations of Teleport Enterprise, package URLs are slightly different: + + + ```code $ curl https://cdn.teleport.dev/teleport-ent-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-fips-bin.tar.gz.sha256 # $ curl -O https://cdn.teleport.dev/teleport-ent-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-fips-bin.tar.gz - $ shasum -a 256 teleport-ent-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-fips-bin.tar.gz - # Verify that the checksums match + $ shasum --check -a 256 teleport-ent-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-fips-bin.tar.gz $ tar -xvf teleport-ent-v${TELEPORT_VERSION?}-linux-${SYSTEM_ARCH?}-fips-bin.tar.gz $ cd teleport-ent $ sudo ./install ``` + + + + FIPS builds are only available for the `arm64` and `amd64` system + architectures. + + ```code + $ curl https://cdn.teleport.dev/teleport-ent_${TELEPORT_VERSION}-fips_${SYSTEM_ARCH}.deb.sha256 + # + $ curl -O https://cdn.teleport.dev/teleport-ent_${TELEPORT_VERSION}-fips_${SYSTEM_ARCH}.deb + $ shasum --check -a 256 teleport-ent_${TELEPORT_VERSION}-fips_${SYSTEM_ARCH}.deb + $ sudo dpkg -i teleport-ent_${TELEPORT_VERSION}-fips_${SYSTEM_ARCH}.deb + ``` + + + + + FIPS builds are only available for the `arm64` and `x86_64` system + architectures. + + ```code + $ curl https://cdn.teleport.dev/teleport-ent-${TELEPORT_VERSION?}-1-fips.${SYSTEM_ARCH?}.rpm.sha256 + # + $ curl -O https://cdn.teleport.dev/teleport-ent-${TELEPORT_VERSION?}-1-fips.${SYSTEM_ARCH?}.rpm + $ shasum --check -a 256 https://cdn.teleport.dev/teleport-ent-${TELEPORT_VERSION?}-1-fips.${SYSTEM_ARCH?}.rpm + # Or use yum localinstall, dnf localinstall etc. + $ sudo rpm -i https://cdn.teleport.dev/teleport-ent-${TELEPORT_VERSION?}-1-fips.${SYSTEM_ARCH?}.rpm + ``` + + + ### From your browser From 597b4c770cceb8778f8c0137037f8d47be38b0a3 Mon Sep 17 00:00:00 2001 From: Paul Gottschling Date: Fri, 6 Dec 2024 14:04:25 -0500 Subject: [PATCH 04/16] Edit the Uninstall Teleport guide (#49800) Closes #46955 Include zypper instructions. --- docs/cspell.json | 7 +++---- .../management/admin/uninstall-teleport.mdx | 16 ++++++++++++++++ 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/docs/cspell.json b/docs/cspell.json index 0f3c97dfdf644..9c8b9d51e36b6 100644 --- a/docs/cspell.json +++ b/docs/cspell.json @@ -810,6 +810,7 @@ "remask", "remotefx", "removelock", + "removerepo", "replaceall", "replicaset", "replicationgroup", @@ -1031,11 +1032,9 @@ "zxvf", "zztop" ], - "flagWords": [ - "hte" - ], + "flagWords": ["hte"], "ignorePaths": [ "**/reference/terraform-provider/**", "**/reference/operator-resources/**" ] -} \ No newline at end of file +} diff --git a/docs/pages/admin-guides/management/admin/uninstall-teleport.mdx b/docs/pages/admin-guides/management/admin/uninstall-teleport.mdx index 873458083c86b..17ca404890208 100644 --- a/docs/pages/admin-guides/management/admin/uninstall-teleport.mdx +++ b/docs/pages/admin-guides/management/admin/uninstall-teleport.mdx @@ -132,6 +132,22 @@ Follow the instructions for your Linux distribution: ``` + + + + Uninstall the Teleport binary using zypper: + + ```code + # Change the package name to "teleport" for Teleport Community Edition + $ sudo zypper -y remove teleport-ent + ``` + + Uninstall the Teleport zypper repo: + + ```code + $ sudo zypper removerepo teleport + ``` + From 44d71ff1f51a3ea86036df66bf3a90983ce93a5e Mon Sep 17 00:00:00 2001 From: Nic Klaassen Date: Fri, 6 Dec 2024 11:05:40 -0800 Subject: [PATCH 05/16] [v17] feat: interactive tctl auth rotate (#49896) Backport #49171 to branch/v17 changelog: Added an interactive mode for tctl auth rotate --- go.mod | 7 +- go.sum | 14 +- lib/asciitable/table.go | 42 +- lib/services/resource.go | 4 +- tool/tctl/common/auth_command.go | 43 +- tool/tctl/common/auth_rotate_command.go | 1347 +++++++++++++++++++++++ tool/tctl/common/status_command.go | 40 +- 7 files changed, 1424 insertions(+), 73 deletions(-) create mode 100644 tool/tctl/common/auth_rotate_command.go diff --git a/go.mod b/go.mod index 14fa90c67cb9a..3b6ae97b36357 100644 --- a/go.mod +++ b/go.mod @@ -78,6 +78,7 @@ require ( github.com/buildkite/bintest/v3 v3.3.0 github.com/charmbracelet/bubbles v0.20.0 github.com/charmbracelet/bubbletea v1.1.0 + github.com/charmbracelet/huh v0.6.0 github.com/charmbracelet/lipgloss v0.13.0 github.com/coreos/go-oidc v2.2.1+incompatible // replaced github.com/coreos/go-oidc/v3 v3.11.0 @@ -266,6 +267,7 @@ require ( github.com/alicebob/gopher-json v0.0.0-20230218143504-906a9b012302 // indirect github.com/apache/arrow/go/v15 v15.0.0 // indirect github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect + github.com/atotto/clipboard v0.1.4 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6 // indirect github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.22 // indirect github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.22 // indirect @@ -285,11 +287,13 @@ require ( github.com/blang/semver v3.5.1+incompatible // indirect github.com/blang/semver/v4 v4.0.0 // indirect github.com/boombuler/barcode v1.0.1 // indirect + github.com/catppuccin/go v0.2.0 // indirect github.com/cenkalti/backoff/v4 v4.3.0 // indirect github.com/census-instrumentation/opencensus-proto v0.4.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/chai2010/gettext-go v1.0.2 // indirect github.com/charmbracelet/x/ansi v0.2.3 // indirect + github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 // indirect github.com/charmbracelet/x/term v0.2.0 // indirect github.com/cloudflare/cfssl v1.6.4 // indirect github.com/cncf/xds/go v0.0.0-20240822171458-6449f94b4d59 // indirect @@ -432,6 +436,7 @@ require ( github.com/mitchellh/copystructure v1.2.0 // indirect github.com/mitchellh/go-homedir v1.1.0 // indirect github.com/mitchellh/go-wordwrap v1.0.1 // indirect + github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect github.com/mitchellh/reflectwalk v1.0.2 // indirect github.com/moby/locker v1.0.1 // indirect github.com/moby/spdystream v0.4.0 // indirect @@ -442,7 +447,7 @@ require ( github.com/mtibben/percent v0.2.1 // indirect github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect github.com/muesli/cancelreader v0.2.2 // indirect - github.com/muesli/termenv v0.15.2 // indirect + github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f // indirect github.com/nozzle/throttler v0.0.0-20180817012639-2ea982251481 // indirect diff --git a/go.sum b/go.sum index 0d37d8ebebb48..3c570a4e09445 100644 --- a/go.sum +++ b/go.sum @@ -829,6 +829,8 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= github.com/aws/aws-sdk-go v1.44.256/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/aws/aws-sdk-go v1.44.263/go.mod h1:aVsgQcEevwlmQ7qHE9I3h+dtQgpqhFB+i8Phjh7fkwI= github.com/aws/aws-sdk-go v1.49.12/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= @@ -983,6 +985,8 @@ github.com/buildkite/interpolate v0.1.3/go.mod h1:UNVe6A+UfiBNKbhAySrBbZFZFxQ+DX github.com/buildkite/roko v1.2.0 h1:hbNURz//dQqNl6Eo9awjQOVOZwSDJ8VEbBDxSfT9rGQ= github.com/buildkite/roko v1.2.0/go.mod h1:23R9e6nHxgedznkwwfmqZ6+0VJZJZ2Sg/uVcp2cP46I= github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= +github.com/catppuccin/go v0.2.0 h1:ktBeIrIP42b/8FGiScP9sgrWOss3lw0Z5SktRoithGA= +github.com/catppuccin/go v0.2.0/go.mod h1:8IHJuMGaUUjQM82qBrGNBv7LFq6JI3NnQCF6MOlZjpc= github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= github.com/cenkalti/backoff/v3 v3.2.2 h1:cfUAAO3yvKMYKPrvhDuHSwQnhZNk/RMHKdZqKTxfm6M= github.com/cenkalti/backoff/v3 v3.2.2/go.mod h1:cIeZDE3IrqwwJl6VUwCN6trj1oXrTS4rc0ij+ULvLYs= @@ -1003,10 +1007,14 @@ github.com/charmbracelet/bubbles v0.20.0 h1:jSZu6qD8cRQ6k9OMfR1WlM+ruM8fkPWkHvQW github.com/charmbracelet/bubbles v0.20.0/go.mod h1:39slydyswPy+uVOHZ5x/GjwVAFkCsV8IIVy+4MhzwwU= github.com/charmbracelet/bubbletea v1.1.0 h1:FjAl9eAL3HBCHenhz/ZPjkKdScmaS5SK69JAK2YJK9c= github.com/charmbracelet/bubbletea v1.1.0/go.mod h1:9Ogk0HrdbHolIKHdjfFpyXJmiCzGwy+FesYkZr7hYU4= +github.com/charmbracelet/huh v0.6.0 h1:mZM8VvZGuE0hoDXq6XLxRtgfWyTI3b2jZNKh0xWmax8= +github.com/charmbracelet/huh v0.6.0/go.mod h1:GGNKeWCeNzKpEOh/OJD8WBwTQjV3prFAtQPpLv+AVwU= github.com/charmbracelet/lipgloss v0.13.0 h1:4X3PPeoWEDCMvzDvGmTajSyYPcZM4+y8sCA/SsA3cjw= github.com/charmbracelet/lipgloss v0.13.0/go.mod h1:nw4zy0SBX/F/eAO1cWdcvy6qnkDUxr8Lw7dvFrAIbbY= github.com/charmbracelet/x/ansi v0.2.3 h1:VfFN0NUpcjBRd4DnKfRaIRo53KRgey/nhOoEqosGDEY= github.com/charmbracelet/x/ansi v0.2.3/go.mod h1:dk73KoMTT5AX5BsX0KrqhsTqAnhZZoCBjs7dGWp4Ktw= +github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 h1:qko3AQ4gK1MTS/de7F5hPGx6/k1u0w4TeYmBFwzYVP4= +github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0/go.mod h1:pBhA0ybfXv6hDjQUZ7hk1lVxBiUbupdw5R31yPUViVQ= github.com/charmbracelet/x/term v0.2.0 h1:cNB9Ot9q8I711MyZ7myUR5HFWL/lc3OpU8jZ4hwm0x0= github.com/charmbracelet/x/term v0.2.0/go.mod h1:GVxgxAbjUrmpvIINHIQnJJKpMlHiZ4cktEQCN6GWyF0= github.com/chengxilo/virtualterm v1.0.4 h1:Z6IpERbRVlfB8WkOmtbHiDbBANU7cimRIof7mk9/PwM= @@ -1822,6 +1830,8 @@ github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrk github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4= +github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= @@ -1858,8 +1868,8 @@ github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= -github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo= -github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8= +github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a h1:2MaM6YC3mGu54x+RKAA6JiFFHlHDY1UbkxqppT7wYOg= +github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a/go.mod h1:hxSnBBYLK21Vtq/PHd0S2FYCxBXzBua8ov5s1RobyRQ= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= diff --git a/lib/asciitable/table.go b/lib/asciitable/table.go index 39d332a2cce1a..ac43ea85d9e2d 100644 --- a/lib/asciitable/table.go +++ b/lib/asciitable/table.go @@ -23,11 +23,13 @@ package asciitable import ( "bytes" "fmt" + "io" "os" "slices" "strings" "text/tabwriter" + "github.com/gravitational/trace" "golang.org/x/term" ) @@ -158,10 +160,26 @@ func (t *Table) truncateCell(colIndex int, cell string) (string, bool) { } // AsBuffer returns a *bytes.Buffer with the printed output of the table. +// +// TODO(nklaassen): delete this, all calls either immediately copy the buffer to +// another writer or just call .String() once. func (t *Table) AsBuffer() *bytes.Buffer { var buffer bytes.Buffer + // Writes to bytes.Buffer never return an error. + _ = t.WriteTo(&buffer) + return &buffer +} - writer := tabwriter.NewWriter(&buffer, 5, 0, 1, ' ', 0) +func (t *Table) String() string { + var sb strings.Builder + // Writes to strings.Builder never return an error. + _ = t.WriteTo(&sb) + return sb.String() +} + +// WriteTo writes the full table to [w] or else returns an error. +func (t *Table) WriteTo(w io.Writer) error { + writer := tabwriter.NewWriter(w, 5, 0, 1, ' ', 0) template := strings.Repeat("%v\t", len(t.columns)) // Header and separator. @@ -173,8 +191,12 @@ func (t *Table) AsBuffer() *bytes.Buffer { colh = append(colh, col.Title) cols = append(cols, strings.Repeat("-", col.width)) } - fmt.Fprintf(writer, template+"\n", colh...) - fmt.Fprintf(writer, template+"\n", cols...) + if _, err := fmt.Fprintf(writer, template+"\n", colh...); err != nil { + return trace.Wrap(err) + } + if _, err := fmt.Fprintf(writer, template+"\n", cols...); err != nil { + return trace.Wrap(err) + } } // Body. @@ -188,17 +210,23 @@ func (t *Table) AsBuffer() *bytes.Buffer { } rowi = append(rowi, cell) } - fmt.Fprintf(writer, template+"\n", rowi...) + if _, err := fmt.Fprintf(writer, template+"\n", rowi...); err != nil { + return trace.Wrap(err) + } } // Footnotes. for label := range footnoteLabels { - fmt.Fprintln(writer) - fmt.Fprintln(writer, label, t.footnotes[label]) + if _, err := fmt.Fprintln(writer); err != nil { + return trace.Wrap(err) + } + if _, err := fmt.Fprintln(writer, label, t.footnotes[label]); err != nil { + return trace.Wrap(err) + } } writer.Flush() - return &buffer + return nil } // IsHeadless returns true if none of the table title cells contains any text. diff --git a/lib/services/resource.go b/lib/services/resource.go index fdb886e0a25ca..d2fba666fa6fd 100644 --- a/lib/services/resource.go +++ b/lib/services/resource.go @@ -175,7 +175,7 @@ func ParseShortcut(in string) (string, error) { return types.KindKubeServer, nil case types.KindLock, "locks": return types.KindLock, nil - case types.KindDatabaseServer: + case types.KindDatabaseServer, "db_servers": return types.KindDatabaseServer, nil case types.KindNetworkRestrictions: return types.KindNetworkRestrictions, nil @@ -185,7 +185,7 @@ func ParseShortcut(in string) (string, error) { return types.KindApp, nil case types.KindAppServer, "app_servers": return types.KindAppServer, nil - case types.KindWindowsDesktopService, "windows_service", "win_desktop_service", "win_service": + case types.KindWindowsDesktopService, "windows_service", "win_desktop_service", "win_service", "windows_desktop_services": return types.KindWindowsDesktopService, nil case types.KindWindowsDesktop, "win_desktop": return types.KindWindowsDesktop, nil diff --git a/tool/tctl/common/auth_command.go b/tool/tctl/common/auth_command.go index 141a38e8fe46d..44e24f54b8ef2 100644 --- a/tool/tctl/common/auth_command.go +++ b/tool/tctl/common/auth_command.go @@ -88,15 +88,11 @@ type AuthCommand struct { streamTarfile bool identityWriter identityfile.ConfigWriter - rotateGracePeriod time.Duration - rotateType string - rotateManualMode bool - rotateTargetPhase string + authRotate authRotateCommand authGenerate *kingpin.CmdClause authExport *kingpin.CmdClause authSign *kingpin.CmdClause - authRotate *kingpin.CmdClause authLS *kingpin.CmdClause authCRL *kingpin.CmdClause // testInsecureSkipVerify is used to skip TLS verification during tests @@ -155,13 +151,7 @@ func (a *AuthCommand) Initialize(app *kingpin.Application, config *servicecfg.Co a.authSign.Flag("windows-sid", `Optional Security Identifier to embed in the certificate. Only used when --format is set to "windows"`).StringVar(&a.windowsSID) a.authSign.Flag("omit-cdp", `Omit CRL Distribution Points from the cert. Only used when --format is set to "windows"`).BoolVar(&a.omitCDP) - a.authRotate = auth.Command("rotate", "Rotate certificate authorities in the cluster.") - a.authRotate.Flag("grace-period", "Grace period keeps previous certificate authorities signatures valid, if set to 0 will force users to re-login and nodes to re-register."). - Default(fmt.Sprintf("%v", defaults.RotationGracePeriod)). - DurationVar(&a.rotateGracePeriod) - a.authRotate.Flag("manual", "Activate manual rotation , set rotation phases manually").BoolVar(&a.rotateManualMode) - a.authRotate.Flag("type", fmt.Sprintf("Certificate authority to rotate, one of: %s", strings.Join(getCertAuthTypes(), ", "))).Required().EnumVar(&a.rotateType, getCertAuthTypes()...) - a.authRotate.Flag("phase", fmt.Sprintf("Target rotation phase to set, used in manual rotation, one of: %v", strings.Join(types.RotatePhases, ", "))).StringVar(&a.rotateTargetPhase) + a.authRotate.Initialize(auth) a.authLS = auth.Command("ls", "List connected auth servers.") a.authLS.Flag("format", "Output format: 'yaml', 'json' or 'text'").Default(teleport.YAML).StringVar(&a.format) @@ -173,6 +163,9 @@ func (a *AuthCommand) Initialize(app *kingpin.Application, config *servicecfg.Co // TryRun takes the CLI command as an argument (like "auth gen") and executes it // or returns match=false if 'cmd' does not belong to it func (a *AuthCommand) TryRun(ctx context.Context, cmd string, client *authclient.Client) (match bool, err error) { + if match, err := a.authRotate.TryRun(ctx, cmd, client); match || err != nil { + return match, trace.Wrap(err) + } switch cmd { case a.authGenerate.FullCommand(): err = a.GenerateKeys(ctx, client) @@ -180,8 +173,6 @@ func (a *AuthCommand) TryRun(ctx context.Context, cmd string, client *authclient err = a.ExportAuthorities(ctx, client) case a.authSign.FullCommand(): err = a.GenerateAndSignKeys(ctx, client) - case a.authRotate.FullCommand(): - err = a.RotateCertAuthority(ctx, client) case a.authLS.FullCommand(): err = a.ListAuthServers(ctx, client) case a.authCRL.FullCommand(): @@ -427,30 +418,6 @@ func (a *AuthCommand) generateSnowflakeKey(ctx context.Context, clusterAPI certi writeHelperMessageDBmTLS(a.helperMsgDst(), filesWritten, "", a.outputFormat, "", a.streamTarfile)) } -// RotateCertAuthority starts or restarts certificate authority rotation process -func (a *AuthCommand) RotateCertAuthority(ctx context.Context, client *authclient.Client) error { - req := types.RotateRequest{ - Type: types.CertAuthType(a.rotateType), - GracePeriod: &a.rotateGracePeriod, - TargetPhase: a.rotateTargetPhase, - } - if a.rotateManualMode { - req.Mode = types.RotationModeManual - } else { - req.Mode = types.RotationModeAuto - } - if err := client.RotateCertAuthority(ctx, req); err != nil { - return err - } - if a.rotateTargetPhase != "" { - fmt.Printf("Updated rotation phase to %q. To check status use 'tctl status'\n", a.rotateTargetPhase) - } else { - fmt.Printf("Initiated certificate authority rotation. To check status use 'tctl status'\n") - } - - return nil -} - // ListAuthServers prints a list of connected auth servers func (a *AuthCommand) ListAuthServers(ctx context.Context, clusterAPI *authclient.Client) error { servers, err := clusterAPI.GetAuthServers() diff --git a/tool/tctl/common/auth_rotate_command.go b/tool/tctl/common/auth_rotate_command.go new file mode 100644 index 0000000000000..02a0d3205d9fc --- /dev/null +++ b/tool/tctl/common/auth_rotate_command.go @@ -0,0 +1,1347 @@ +/* + * 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 common + +import ( + "cmp" + "context" + "fmt" + "io" + "log/slog" + "os" + "strings" + "sync" + "time" + + "github.com/alecthomas/kingpin/v2" + "github.com/charmbracelet/bubbles/help" + "github.com/charmbracelet/bubbles/key" + "github.com/charmbracelet/bubbles/spinner" + tea "github.com/charmbracelet/bubbletea" + "github.com/charmbracelet/huh" + "github.com/charmbracelet/lipgloss" + "github.com/gravitational/trace" + "github.com/sirupsen/logrus" + "golang.org/x/term" + + apiclient "github.com/gravitational/teleport/api/client" + "github.com/gravitational/teleport/api/client/proto" + apidefaults "github.com/gravitational/teleport/api/defaults" + "github.com/gravitational/teleport/api/mfa" + "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/api/utils/prompt" + "github.com/gravitational/teleport/lib/auth/authclient" + libmfa "github.com/gravitational/teleport/lib/client/mfa" + "github.com/gravitational/teleport/lib/defaults" + logutils "github.com/gravitational/teleport/lib/utils/log" +) + +const ( + updateInterval = 3 * time.Second + maxWidth = 80 +) + +type authRotateCommand struct { + cmd *kingpin.CmdClause + interactiveMode bool + manualMode bool + caType string + targetPhase string + gracePeriod time.Duration +} + +func (c *authRotateCommand) Initialize(authCmd *kingpin.CmdClause) { + c.cmd = authCmd.Command("rotate", "Rotate certificate authorities in the cluster. Starts in interactive mode by default, provide --type to manually send rotation requests.") + c.cmd.Flag("interactive", "Enable interactive mode").BoolVar(&c.interactiveMode) + c.cmd.Flag("manual", "Activate manual rotation, set rotation phases manually").BoolVar(&c.manualMode) + c.cmd.Flag("type", fmt.Sprintf("Certificate authority to rotate, one of: %s", strings.Join(getCertAuthTypes(), ", "))).EnumVar(&c.caType, getCertAuthTypes()...) + c.cmd.Flag("phase", fmt.Sprintf("Target rotation phase to set, used in manual rotation, one of: %v", strings.Join(types.RotatePhases, ", "))).StringVar(&c.targetPhase) + c.cmd.Flag("grace-period", "Grace period keeps previous certificate authorities signatures valid, if set to 0 will force users to re-login and nodes to re-register."). + Default(fmt.Sprintf("%v", defaults.RotationGracePeriod)). + DurationVar(&c.gracePeriod) +} + +func (c *authRotateCommand) TryRun(ctx context.Context, cmd string, client *authclient.Client) (match bool, err error) { + if c.cmd.FullCommand() == cmd { + return true, trace.Wrap(c.Run(ctx, client)) + } + return false, nil +} + +func (c *authRotateCommand) Run(ctx context.Context, client *authclient.Client) error { + if c.interactiveMode { + return trace.Wrap(c.runInteractive(ctx, client)) + } + if !c.manualMode && c.caType == "" && c.targetPhase == "" && c.gracePeriod == defaults.RotationGracePeriod { + // If the user passed zero arguments, default to interactive mode. + if !term.IsTerminal(int(os.Stdin.Fd())) { + return trace.BadParameter("required flag --type not provided, not starting interactive mode because stdin does not appear to be a terminal") + } + return trace.Wrap(c.runInteractive(ctx, client)) + } + + return trace.Wrap(c.runNoninteractive(ctx, client)) +} + +func (c *authRotateCommand) runNoninteractive(ctx context.Context, client *authclient.Client) error { + if c.caType == "" { + return trace.BadParameter("required flag --type not provided") + } + req := types.RotateRequest{ + Type: types.CertAuthType(c.caType), + TargetPhase: c.targetPhase, + GracePeriod: &c.gracePeriod, + } + if c.manualMode { + req.Mode = types.RotationModeManual + } else { + req.Mode = types.RotationModeAuto + } + if err := client.RotateCertAuthority(ctx, req); err != nil { + return trace.Wrap(err) + } + if c.targetPhase != "" { + fmt.Printf("Updated rotation phase to %q. To check status use 'tctl status'\n", c.targetPhase) + } else { + fmt.Printf("Initiated certificate authority rotation. To check status use 'tctl status'\n") + } + return nil +} + +func (c *authRotateCommand) runInteractive(ctx context.Context, client *authclient.Client) error { + pingResp, err := client.Ping(ctx) + if err != nil { + return trace.Wrap(err, "failed to ping cluster") + } + m := newRotateModel(client, pingResp, types.CertAuthType(c.caType)) + p := tea.NewProgram(m, tea.WithContext(ctx)) + _, err = p.Run() + return trace.Wrap(err) +} + +type authRotateStyle struct { + formTheme *huh.Theme + normal lipgloss.Style + title lipgloss.Style + highlight lipgloss.Style + errorMessage lipgloss.Style +} + +var formTheme = huh.ThemeBase16() +var authRotateTheme = authRotateStyle{ + formTheme: formTheme, + normal: lipgloss.NewStyle(), + title: formTheme.Focused.Title, + highlight: formTheme.Focused.SelectedOption, + errorMessage: formTheme.Focused.ErrorMessage.SetString(""), +} + +type rotateModel struct { + client *authclient.Client + pingResp proto.PingResponse + + logsModel *writerModel + rotateStatusModel *rotateStatusModel + caTypeModel *caTypeModel + currentPhaseModel *currentPhaseModel + waitForCurrentPhaseReadyModel *waitForReadyModel + targetPhaseModel *targetPhaseModel + confirmed bool + sendRotateRequestModel *sendRotateRequestModel + mfaPromptModel *writerModel + waitForTargetPhaseReadyModel *waitForReadyModel + continueBinding key.Binding + newBinding key.Binding + quitBinding key.Binding + help help.Model +} + +func newRotateModel(client *authclient.Client, pingResp proto.PingResponse, caType types.CertAuthType) *rotateModel { + m := &rotateModel{ + client: client, + pingResp: pingResp, + logsModel: newWriterModel(authRotateTheme.normal), + rotateStatusModel: newRotateStatusModel(client, pingResp), + caTypeModel: newCATypeModel(caType), + mfaPromptModel: newWriterModel(authRotateTheme.errorMessage), + continueBinding: key.NewBinding(key.WithKeys("c"), key.WithHelp("c", "continue rotating selected CA")), + newBinding: key.NewBinding(key.WithKeys("n"), key.WithHelp("n", "rotate a new CA")), + quitBinding: key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")), + help: help.New(), + } + if caType != "" { + m.currentPhaseModel = newCurrentPhaseModel(client, pingResp, caType) + } + setupLoggers(m.logsModel) + setupMFAPrompt(client, pingResp, m.mfaPromptModel) + return m +} + +// Init implements [tea.Model]. It is the first function that will be called by +// bubbletea. +func (m *rotateModel) Init() tea.Cmd { + cmds := []tea.Cmd{ + m.rotateStatusModel.init(), + m.caTypeModel.init(), + } + if m.currentPhaseModel != nil { + cmds = append(cmds, m.currentPhaseModel.init()) + } + return tea.Batch(cmds...) +} + +// Update implements [tea.Model], it is called every time a message is received. +// The update method reacts to the message and updates the state of the model. +// All messages are passed to the update method of all active submodels, each model +// may optionally return a [tea.Cmd] to trigger future updates with new messages. +func (m *rotateModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + var cmds []tea.Cmd + switch msg := msg.(type) { + case tea.KeyMsg: + switch { + case key.Matches(msg, m.quitBinding): + return m, tea.Quit + } + } + + cmds = append(cmds, m.rotateStatusModel.update(msg)) + + cmds = append(cmds, m.caTypeModel.update(msg)) + if m.caTypeModel.caType == "" { + // Return early if the user hasn't picked a CA type yet. + return m, tea.Batch(cmds...) + } + + // Now that we have a CA type, init the current phase model if we haven't yet. + if m.currentPhaseModel == nil { + m.currentPhaseModel = newCurrentPhaseModel(m.client, m.pingResp, m.caTypeModel.caType) + cmds = append(cmds, m.currentPhaseModel.init()) + } + cmds = append(cmds, m.currentPhaseModel.update(msg)) + if m.currentPhaseModel.phase == "" { + // Return early if we haven't got the current phase yet. + return m, tea.Batch(cmds...) + } + + // Now that we've got the current phase, init the waitForCurrentPhaseReady + // model if we haven't yet and the current phase is not standby. + if m.waitForCurrentPhaseReadyModel == nil && m.currentPhaseModel.phase != "standby" { + m.waitForCurrentPhaseReadyModel = newWaitForReadyModel(m.client, m.currentPhaseModel.caID, m.currentPhaseModel.phase) + cmds = append(cmds, m.waitForCurrentPhaseReadyModel.init()) + } + if m.waitForCurrentPhaseReadyModel != nil { + cmds = append(cmds, m.waitForCurrentPhaseReadyModel.update(msg)) + if !m.waitForCurrentPhaseReadyModel.ready() { + // Return early if the current phase is not ready yet. + return m, tea.Batch(cmds...) + } + } + + // Now that we know the current phase, init the target phase model if we haven't yet. + if m.targetPhaseModel == nil { + m.targetPhaseModel = newTargetPhaseModel(m.caTypeModel.caType, m.currentPhaseModel.phase) + cmds = append(cmds, m.targetPhaseModel.init()) + } + cmds = append(cmds, m.targetPhaseModel.update(msg)) + if m.targetPhaseModel.targetPhase == "" { + // Return early if we haven't got the target phase yet. + return m, tea.Batch(cmds...) + } + + // Wait for the user to confirm the rotate request. + if !m.confirmed { + switch msg := msg.(type) { + case tea.KeyMsg: + switch msg.String() { + case "n", "N": + // Go back to the beginning. + m = newRotateModel(m.client, m.pingResp, "") + return m, m.Init() + case "y", "Y": + m.confirmed = true + default: + return m, tea.Batch(cmds...) + } + default: + return m, tea.Batch(cmds...) + } + } + + // Now that we got user confirmation, send the rotate request. + if m.sendRotateRequestModel == nil { + m.sendRotateRequestModel = newSendRotateRequestModel(m.client, m.caTypeModel.caType, m.targetPhaseModel.targetPhase) + cmds = append(cmds, m.sendRotateRequestModel.init()) + return m, tea.Batch(cmds...) + } + cmds = append(cmds, m.sendRotateRequestModel.update(msg)) + if !m.sendRotateRequestModel.success { + // Return early if the rotate request hasn't been successfully sent yet. + return m, tea.Batch(cmds...) + } + + // Now that we've sent the rotate request, init the waitForTargetPhaseReady model if we haven't yet. + if m.waitForTargetPhaseReadyModel == nil { + m.waitForTargetPhaseReadyModel = newWaitForReadyModel(m.client, m.currentPhaseModel.caID, m.targetPhaseModel.targetPhase) + cmds = append(cmds, m.waitForTargetPhaseReadyModel.init()) + } + cmds = append(cmds, m.waitForTargetPhaseReadyModel.update(msg)) + + // If we've made it this far, let the user restart with the keybinds. + switch msg := msg.(type) { + case tea.KeyMsg: + switch { + case key.Matches(msg, m.continueBinding): + newModel := newRotateModel(m.client, m.pingResp, m.caTypeModel.caType) + newModel.waitForCurrentPhaseReadyModel = m.waitForTargetPhaseReadyModel + return newModel, newModel.Init() + case key.Matches(msg, m.newBinding): + newModel := newRotateModel(m.client, m.pingResp, "") + return newModel, newModel.Init() + } + } + + return m, tea.Batch(cmds...) +} + +// View implements [tea.Model], it renders the program's UI, which is just a +// string. The view is rendered after every Update. +func (m *rotateModel) View() string { + var sb strings.Builder + writeln(&sb, m.logsModel.view()) + writeln(&sb, m.rotateStatusModel.view()) + writeln(&sb, m.caTypeModel.view()) + if m.caTypeModel.caType == "" { + return sb.String() + } + + writeln(&sb, m.currentPhaseModel.view()) + if m.currentPhaseModel.phase == "" { + return sb.String() + } + + if m.waitForCurrentPhaseReadyModel != nil && !m.confirmed { + writeln(&sb, m.waitForCurrentPhaseReadyModel.view()) + if !m.waitForCurrentPhaseReadyModel.ready() { + return sb.String() + } + } + + writeln(&sb, m.targetPhaseModel.view()) + if m.targetPhaseModel.targetPhase == "" { + return sb.String() + } + + sb.WriteString(authRotateTheme.normal.Render("Send request to rotate ")) + sb.WriteString(authRotateTheme.highlight.Render(string(m.caTypeModel.caType))) + sb.WriteString(authRotateTheme.normal.Render(" CA to ")) + sb.WriteString(authRotateTheme.highlight.Render(m.targetPhaseModel.targetPhase)) + sb.WriteString(authRotateTheme.normal.Render(" phase? (y/n): ")) + if !m.confirmed { + return sb.String() + } + writeln(&sb, authRotateTheme.highlight.PaddingBottom(1).Render("y")) + + writeln(&sb, m.sendRotateRequestModel.view()) + if !m.sendRotateRequestModel.success { + if mfaPrompt := m.mfaPromptModel.view(); len(mfaPrompt) > 0 { + writeln(&sb, mfaPrompt) + } + return sb.String() + } + + writeln(&sb, m.waitForTargetPhaseReadyModel.view()) + if !m.waitForTargetPhaseReadyModel.ready() { + return sb.String() + } + + helpBindings := []key.Binding{m.continueBinding, m.newBinding, m.quitBinding} + if m.waitForTargetPhaseReadyModel.targetPhase == "standby" { + helpBindings = helpBindings[1:] + } + writeln(&sb, authRotateTheme.normal.Render(m.help.ShortHelpView(helpBindings))) + + return sb.String() +} + +type rotateStatusModel struct { + client *authclient.Client + pingResp proto.PingResponse + spinner spinner.Model + + status *statusModel + err error +} + +func newRotateStatusModel(client *authclient.Client, pingResp proto.PingResponse) *rotateStatusModel { + status, err := newStatusModel(context.TODO(), client, pingResp) + return &rotateStatusModel{ + client: client, + pingResp: pingResp, + spinner: spinner.New(spinner.WithSpinner(spinner.Spinner{ + Frames: []string{"", ".", "..", "...", "...", "...", "...", "...", "..", ".", ""}, + FPS: time.Second / 8, + })), + status: status, + err: trace.Wrap(err), + } +} + +func (m *rotateStatusModel) updateRotateStatus(_ time.Time) tea.Msg { + rotateStatus, err := newStatusModel(context.TODO(), m.client, m.pingResp) + if err != nil { + return newTaggedMsg(err, rotateStatusTag{}) + } + return newTaggedMsg(rotateStatus, rotateStatusTag{}) +} + +type rotateStatusTag struct{} + +func (m *rotateStatusModel) init() tea.Cmd { + return tea.Batch( + tea.Tick(updateInterval, m.updateRotateStatus), + m.spinner.Tick) +} + +func (m *rotateStatusModel) update(msg tea.Msg) tea.Cmd { + msg, ok := matchTaggedMsg(msg, rotateStatusTag{}) + if !ok { + s, msg := m.spinner.Update(msg) + m.spinner = s + return msg + } + switch msg := msg.(type) { + case error: + m.err = trace.Wrap(msg) + case *statusModel: + m.status = msg + } + return tea.Tick(updateInterval, m.updateRotateStatus) +} + +func (m *rotateStatusModel) view() string { + if m.err != nil { + return authRotateTheme.errorMessage.Render("Error fetching cluster status:", m.err.Error()) + } + + var table strings.Builder + m.status.renderText(&table, false /*debug*/) + + var sb strings.Builder + sb.WriteString(authRotateTheme.title.Render("Current status")) + writeln(&sb, authRotateTheme.title.Render(m.spinner.View())) + sb.WriteString(authRotateTheme.normal. + Render(table.String())) + return sb.String() +} + +type caTypeModel struct { + caType types.CertAuthType + form *huh.Form +} + +func newCATypeModel(caType types.CertAuthType) *caTypeModel { + return &caTypeModel{ + caType: caType, + form: newSelectForm("Choose CA to rotate:", types.CertAuthTypes...), + } +} + +func (m *caTypeModel) init() tea.Cmd { + if m.caType != "" { + return nil + } + return m.form.Init() +} + +func (m *caTypeModel) update(msg tea.Msg) tea.Cmd { + if m.caType != "" { + return nil + } + form, cmd := m.form.Update(msg) + m.form = form.(*huh.Form) + if m.form.State == huh.StateCompleted { + m.caType = m.form.Get("selected").(types.CertAuthType) + } + return cmd +} + +func (m *caTypeModel) view() string { + if m.caType == "" { + return m.form.View() + } + var sb strings.Builder + sb.WriteString(authRotateTheme.normal.Render("Rotating the ")) + sb.WriteString(authRotateTheme.highlight.Render(string(m.caType))) + sb.WriteString(authRotateTheme.normal.Render(" CA.")) + return sb.String() +} + +type currentPhaseModel struct { + client *authclient.Client + pingResp proto.PingResponse + + spinner spinner.Model + caType types.CertAuthType + caID types.CertAuthID + phase string + err error +} + +func newCurrentPhaseModel(client *authclient.Client, pingResp proto.PingResponse, caType types.CertAuthType) *currentPhaseModel { + return ¤tPhaseModel{ + client: client, + pingResp: pingResp, + spinner: spinner.New(spinner.WithSpinner(spinner.Dot)), + caType: caType, + } +} + +func (m *currentPhaseModel) init() tea.Cmd { + return tea.Batch(m.getCurrentPhase, m.spinner.Tick) +} + +func (m *currentPhaseModel) getCurrentPhase() tea.Msg { + m.caID = types.CertAuthID{ + Type: m.caType, + DomainName: m.pingResp.ClusterName, + } + ca, err := m.client.GetCertAuthority(context.TODO(), m.caID, false /*loadSigningKeys*/) + if err != nil { + return newTaggedMsg(trace.Wrap(err, "failed to fetch CA status"), currentPhaseTag{}) + } + return newTaggedMsg(cmp.Or(ca.GetRotation().Phase, "standby"), currentPhaseTag{}) +} + +type currentPhaseTag struct{} + +func (m *currentPhaseModel) update(msg tea.Msg) tea.Cmd { + if m.phase != "" { + // Already got the current phase, no need for more updates. + return nil + } + msg, ok := matchTaggedMsg(msg, currentPhaseTag{}) + if !ok { + s, cmd := m.spinner.Update(msg) + m.spinner = s + return cmd + } + switch msg := msg.(type) { + case string: + m.phase = msg + case error: + m.err = trace.Wrap(msg) + return tea.Quit + } + return nil +} + +func (m *currentPhaseModel) view() string { + if m.phase == "" { + var sb strings.Builder + sb.WriteString(authRotateTheme.highlight.Render(m.spinner.View())) + sb.WriteString(authRotateTheme.normal.Render("Fetching current CA rotation phase")) + return sb.String() + } + var sb strings.Builder + sb.WriteString(authRotateTheme.normal.Render("Current rotation phase is ")) + sb.WriteString(authRotateTheme.highlight.Render(m.phase)) + sb.WriteString(authRotateTheme.normal.Render(".")) + if remaining := remainingPhases(m.phase); len(remaining) > 0 { + sb.WriteString(authRotateTheme.normal.Render("\nRemaining phases: ")) + for len(remaining) > 1 { + phase := remaining[0] + remaining = remaining[1:] + sb.WriteString(authRotateTheme.highlight.Render(phase)) + sb.WriteString(authRotateTheme.normal.Render(", ")) + } + sb.WriteString(authRotateTheme.highlight.Render(remaining[0])) + sb.WriteString(authRotateTheme.normal.Render(".")) + } + return sb.String() +} + +type targetPhaseModel struct { + caType types.CertAuthType + currentPhase string + targetPhase string + form *huh.Form +} + +func newTargetPhaseModel(caType types.CertAuthType, currentPhase string) *targetPhaseModel { + options := nextPhases(currentPhase) + if len(options) == 1 { + return &targetPhaseModel{ + caType: caType, + currentPhase: currentPhase, + targetPhase: options[0], + } + } + return &targetPhaseModel{ + caType: caType, + currentPhase: currentPhase, + form: newSelectForm("Select target phase:", options...), + } +} + +func (m *targetPhaseModel) init() tea.Cmd { + if m.form == nil { + return nil + } + return m.form.Init() +} + +func (m *targetPhaseModel) update(msg tea.Msg) tea.Cmd { + if m.targetPhase != "" { + return nil + } + form, cmd := m.form.Update(msg) + m.form = form.(*huh.Form) + if m.form.State == huh.StateCompleted { + m.targetPhase = m.form.GetString("selected") + } + return cmd +} + +func (m *targetPhaseModel) view() string { + if m.targetPhase == "" { + return m.form.View() + } + var sb strings.Builder + sb.WriteString(authRotateTheme.normal.Render("Target rotation phase is ")) + sb.WriteString(authRotateTheme.highlight.Render(m.targetPhase)) + writeln(&sb, authRotateTheme.normal.Render(".")) + sb.WriteString(authRotateTheme.normal.Width(maxWidth). + MarginTop(1).MarginBottom(1).MarginLeft(2). + Render(phaseHelpText(m.caType, m.currentPhase, m.targetPhase))) + return sb.String() +} + +type sendRotateRequestModel struct { + client *authclient.Client + spinner spinner.Model + caType types.CertAuthType + targetPhase string + success bool + err error +} + +type sendRotateRequestTag struct{} + +func newSendRotateRequestModel(client *authclient.Client, caType types.CertAuthType, targetPhase string) *sendRotateRequestModel { + return &sendRotateRequestModel{ + client: client, + spinner: spinner.New(spinner.WithSpinner(spinner.Dot)), + caType: caType, + targetPhase: targetPhase, + } +} + +func (m *sendRotateRequestModel) sendRotateRequest() tea.Msg { + err := m.client.RotateCertAuthority(context.TODO(), types.RotateRequest{ + Type: m.caType, + TargetPhase: m.targetPhase, + Mode: types.RotationModeManual, + }) + return newTaggedMsg(trace.Wrap(err), sendRotateRequestTag{}) +} + +func (m *sendRotateRequestModel) init() tea.Cmd { + return tea.Batch(m.sendRotateRequest, m.spinner.Tick) +} + +func (m *sendRotateRequestModel) update(msg tea.Msg) tea.Cmd { + if m.success { + return nil + } + msg, ok := matchTaggedMsg(msg, sendRotateRequestTag{}) + if !ok { + s, cmd := m.spinner.Update(msg) + m.spinner = s + return cmd + } + switch msg := msg.(type) { + case error: + m.err = trace.Wrap(msg) + } + if m.err == nil { + m.success = true + } + return nil +} + +func (m *sendRotateRequestModel) view() string { + if m.err != nil { + return authRotateTheme.errorMessage.Render("Error sending rotate request:", m.err.Error()) + } + if !m.success { + var sb strings.Builder + sb.WriteString(authRotateTheme.highlight.Render(m.spinner.View())) + sb.WriteString(authRotateTheme.normal.Render("Sending CA rotation request")) + return sb.String() + } + var sb strings.Builder + sb.WriteString(authRotateTheme.highlight.Render("âś“ ")) + switch m.targetPhase { + case "init": + sb.WriteString(authRotateTheme.normal.Render("Initiated certificate authority rotation.")) + default: + sb.WriteString(authRotateTheme.normal.Render("Updated rotation phase to ")) + sb.WriteString(authRotateTheme.highlight.Render(m.targetPhase)) + sb.WriteString(authRotateTheme.normal.Render(".")) + } + return sb.String() +} + +type writerModel struct { + style lipgloss.Style + buf []byte + mu sync.Mutex +} + +func newWriterModel(style lipgloss.Style) *writerModel { + return &writerModel{style: style} +} + +func (m *writerModel) view() string { + m.mu.Lock() + defer m.mu.Unlock() + if len(m.buf) == 0 { + return "" + } + // This will always be printed by the caller with writeln, remove trailing + // newlines if present. + b := m.buf + if b[len(b)-1] == '\n' { + b = b[:len(b)-1] + } + return m.style.Render(string(b)) +} + +func (m *writerModel) Write(b []byte) (int, error) { + m.mu.Lock() + defer m.mu.Unlock() + m.buf = append(m.buf, b...) + return len(b), nil +} + +type waitForReadyModel struct { + client *authclient.Client + targetPhase string + kindReadyModels []*waitForKindReadyModel + manualSteps []string + acknowledged bool + skipped bool + acknowledgeBinding key.Binding + skipBinding key.Binding + quitBinding key.Binding + help help.Model +} + +func newWaitForReadyModel(client *authclient.Client, caID types.CertAuthID, targetPhase string) *waitForReadyModel { + m := &waitForReadyModel{ + client: client, + targetPhase: targetPhase, + manualSteps: manualSteps(caID.Type, targetPhase), + acknowledgeBinding: key.NewBinding(key.WithKeys("a"), key.WithHelp("a", "acknowledge manual steps completed")), + skipBinding: key.NewBinding(key.WithKeys("s"), key.WithHelp("s", "skip all checks (unsafe)")), + quitBinding: key.NewBinding(key.WithKeys("q"), key.WithHelp("q", "quit")), + help: help.New(), + } + if caID.Type != types.HostCA { + return m + } + m.kindReadyModels = []*waitForKindReadyModel{ + newWaitForKindReadyModel( + targetPhase, "auth_servers", adaptServerGetter(client.GetAuthServers)).withMinReady(1), + newWaitForKindReadyModel( + targetPhase, "proxies", adaptServerGetter(client.GetProxies)), + newWaitForKindReadyModel( + targetPhase, "nodes", adaptServerGetter(func() ([]types.Server, error) { + return apiclient.GetAllResources[types.Server](context.TODO(), client, &proto.ListResourcesRequest{ + ResourceType: types.KindNode, + Namespace: apidefaults.Namespace, + PredicateExpression: `resource.sub_kind == ""`, + }) + })), + newWaitForKindReadyModel( + targetPhase, "app_servers", adaptServerGetter(func() ([]types.AppServer, error) { + return client.GetApplicationServers(context.TODO(), apidefaults.Namespace) + })), + newWaitForKindReadyModel( + targetPhase, "db_servers", adaptServerGetter(func() ([]types.DatabaseServer, error) { + return client.GetDatabaseServers(context.TODO(), apidefaults.Namespace) + })), + newWaitForKindReadyModel( + targetPhase, "kube_servers", adaptServerGetter(func() ([]types.KubeServer, error) { + return client.GetKubernetesServers(context.TODO()) + })), + } + return m +} + +func adaptServerGetter[T rotatable](f func() ([]T, error)) func() ([]rotatable, error) { + return func() ([]rotatable, error) { + servers, err := f() + if err != nil { + return nil, trace.Wrap(err) + } + out := make([]rotatable, len(servers)) + for i, server := range servers { + out[i] = server + } + return out, nil + } +} + +func (m *waitForReadyModel) ready() bool { + if m.skipped { + return true + } + if len(m.manualSteps) > 0 && !m.acknowledged { + return false + } + for _, kindReadyModel := range m.kindReadyModels { + if !kindReadyModel.ready() { + return false + } + } + return true +} + +func (m *waitForReadyModel) init() tea.Cmd { + var cmds []tea.Cmd + for _, kindReadyModel := range m.kindReadyModels { + cmds = append(cmds, kindReadyModel.init()) + } + return tea.Batch(cmds...) +} + +func (m *waitForReadyModel) update(msg tea.Msg) tea.Cmd { + if m.ready() { + return nil + } + switch msg := msg.(type) { + case tea.KeyMsg: + switch { + case key.Matches(msg, m.acknowledgeBinding): + m.acknowledged = true + case key.Matches(msg, m.skipBinding): + m.skipped = true + for _, kindReadyModel := range m.kindReadyModels { + kindReadyModel.skipped = true + } + } + } + var cmds []tea.Cmd + for i := range m.kindReadyModels { + if m.kindReadyModels[i].ready() { + continue + } + cmds = append(cmds, m.kindReadyModels[i].update(msg)) + } + return tea.Batch(cmds...) +} + +func (m *waitForReadyModel) view() string { + var sb strings.Builder + for _, kindReadyModel := range m.kindReadyModels { + writeln(&sb, kindReadyModel.view()) + } + manualStepPrefix := authRotateTheme.errorMessage.Render("! ") + if m.acknowledged { + manualStepPrefix = authRotateTheme.highlight.Render("âś“ ") + } + for _, manualStep := range m.manualSteps { + writeln(&sb, lipgloss.JoinHorizontal(0, + manualStepPrefix, + authRotateTheme.normal.Width(maxWidth-2).Render(manualStep), + )) + } + if !m.ready() { + helpKeys := []key.Binding{m.acknowledgeBinding, m.skipBinding, m.quitBinding} + if m.acknowledged { + helpKeys = helpKeys[1:] + } + writeln(&sb, authRotateTheme.normal.PaddingTop(1).Render( + m.help.ShortHelpView(helpKeys), + )) + } + return sb.String() +} + +type readyStatus struct { + totalCount, readyCount int +} + +type waitForKindReadyModel struct { + targetPhase string + desc string + getter func() ([]rotatable, error) + minReady int + spinner spinner.Model + readyStatus readyStatus + err error + gotFirstResponse bool + skipped bool +} + +type rotatable interface { + GetRotation() types.Rotation +} + +func newWaitForKindReadyModel(targetPhase string, desc string, getter func() ([]rotatable, error)) *waitForKindReadyModel { + return &waitForKindReadyModel{ + targetPhase: targetPhase, + desc: desc, + getter: getter, + spinner: spinner.New(spinner.WithSpinner(spinner.Dot)), + } +} + +func (m *waitForKindReadyModel) withMinReady(n int) *waitForKindReadyModel { + m.minReady = n + return m +} + +func (m *waitForKindReadyModel) getKindServersStatus() tea.Msg { + servers, err := m.getter() + if err != nil { + return newTaggedMsg(trace.Wrap(err), m.desc) + } + ready := 0 + for _, server := range servers { + phase := server.GetRotation().Phase + if phase == m.targetPhase || m.targetPhase == "standby" && phase == "" { + ready++ + } + } + return newTaggedMsg(readyStatus{totalCount: len(servers), readyCount: ready}, m.desc) +} + +func (m *waitForKindReadyModel) ready() bool { + return m.gotFirstResponse && + m.readyStatus.readyCount >= m.minReady && + m.readyStatus.readyCount == m.readyStatus.totalCount +} + +func (m *waitForKindReadyModel) init() tea.Cmd { + return tea.Batch(m.getKindServersStatus, m.spinner.Tick) +} + +func (m *waitForKindReadyModel) update(msg tea.Msg) tea.Cmd { + msg, ok := matchTaggedMsg(msg, m.desc) + if !ok { + s, cmd := m.spinner.Update(msg) + m.spinner = s + return cmd + } + switch msg := msg.(type) { + case error: + m.err = trace.Wrap(msg) + return tea.Tick(updateInterval, func(time.Time) tea.Msg { return m.getKindServersStatus() }) + case readyStatus: + m.gotFirstResponse = true + m.err = nil + m.readyStatus = msg + if m.ready() { + return nil + } + return tea.Tick(updateInterval, func(time.Time) tea.Msg { return m.getKindServersStatus() }) + } + return nil +} + +func (m *waitForKindReadyModel) view() string { + if m.err != nil { + var sb strings.Builder + sb.WriteString(authRotateTheme.errorMessage.Render("x ")) + sb.WriteString(authRotateTheme.normal.Render("Error fetching ")) + sb.WriteString(authRotateTheme.highlight.Render(m.desc)) + sb.WriteString(authRotateTheme.normal.Render(" status: ")) + sb.WriteString(authRotateTheme.errorMessage.Render(m.err.Error())) + return sb.String() + } + if m.ready() { + var sb strings.Builder + sb.WriteString(authRotateTheme.highlight.Render("âś“ ")) + if m.readyStatus.totalCount == 0 { + sb.WriteString(authRotateTheme.normal.Render("No ")) + sb.WriteString(authRotateTheme.highlight.Render(m.desc)) + sb.WriteString(authRotateTheme.normal.Render(" found.")) + return sb.String() + } + sb.WriteString(authRotateTheme.normal.Render("All ")) + sb.WriteString(authRotateTheme.highlight.Render(m.desc)) + sb.WriteString(authRotateTheme.normal.Render(" are in the ")) + sb.WriteString(authRotateTheme.highlight.Render(m.targetPhase)) + sb.WriteString(authRotateTheme.normal.Render( + fmt.Sprintf(" phase (%d/%d).", m.readyStatus.readyCount, m.readyStatus.totalCount))) + return sb.String() + } + var sb strings.Builder + if m.skipped { + sb.WriteString(authRotateTheme.errorMessage.Render("! ")) + } else { + sb.WriteString(authRotateTheme.highlight.Render(m.spinner.View())) + } + if m.gotFirstResponse { + if m.skipped { + sb.WriteString(authRotateTheme.normal.Render("Skipped waiting for ")) + } else { + sb.WriteString(authRotateTheme.normal.Render("Waiting for ")) + } + sb.WriteString(authRotateTheme.highlight.Render(m.desc)) + sb.WriteString(authRotateTheme.normal.Render(" to enter ")) + sb.WriteString(authRotateTheme.highlight.Render(m.targetPhase)) + sb.WriteString(authRotateTheme.normal.Render(fmt.Sprintf(" phase (%d/%d). ", + m.readyStatus.readyCount, m.readyStatus.totalCount))) + } else { + if m.skipped { + sb.WriteString(authRotateTheme.normal.Render("Skipped checking current rotation phase of ")) + } else { + sb.WriteString(authRotateTheme.normal.Render("Checking current rotation phase of ")) + } + sb.WriteString(authRotateTheme.highlight.Render(m.desc)) + sb.WriteString(authRotateTheme.normal.Render(". ")) + } + sb.WriteString(authRotateTheme.normal.Render(fmt.Sprintf("Run 'tctl get %s' to check status.", m.desc))) + return sb.String() + +} + +type taggedMsg[T comparable] struct { + msg tea.Msg + tag T +} + +func newTaggedMsg[T comparable](msg tea.Msg, tag T) taggedMsg[T] { + return taggedMsg[T]{ + msg: msg, + tag: tag, + } +} + +func matchTaggedMsg[T comparable](msg tea.Msg, tag T) (tea.Msg, bool) { + if msg, ok := msg.(taggedMsg[T]); ok && msg.tag == tag { + return msg.msg, true + } + return msg, false +} + +func phaseHelpText(caType types.CertAuthType, currentPhase, targetPhase string) string { + var sb strings.Builder + switch targetPhase { + case "init": + initPhaseHelpText(&sb, caType) + case "update_clients": + updateClientsPhaseHelpText(&sb, caType) + case "update_servers": + updateServersPhaseHelpText(&sb, caType) + case "rollback": + rollbackPhaseHelpText(&sb) + case "standby": + standbyPhaseHelpText(&sb, caType, currentPhase) + } + return sb.String() +} + +func initPhaseHelpText(sb *strings.Builder, caType types.CertAuthType) { + sb.WriteString("The init phase initiates a new Certificate Authority (CA) rotation. ") + sb.WriteString("New CA key pairs and certificates will be generated and must be trusted but will not yet be used.") + switch caType { + case types.HostCA: + sb.WriteString("\nDuring this phase all Teleport services will automatically begin to trust the new SSH host key and X509 CA certificate.") + } +} + +func updateClientsPhaseHelpText(sb *strings.Builder, caType types.CertAuthType) { + sb.WriteString("In the update_clients phase the new CA keys become the active signing keys for all new certificates issued by the CA. ") + sb.WriteString("Clients will immediately begin to use their new certificates, but servers will continue to use their original certificates.") + switch caType { + case types.HostCA: + sb.WriteString("\nDuring this phase, all Teleport services will automatically retrieve new certificates issued by the new CA.") + case types.OpenSSHCA: + sb.WriteString("\nAll new connections to OpenSSH hosts will begin to use certificates issued by the new CA keys.") + case types.UserCA: + sb.WriteString("\nAll new connections to Windows desktops will begin to use certificates issued by the new CA certificate. ") + case types.DatabaseClientCA: + sb.WriteString("\nAll new database connections will begin to use certificates issued by the new CA certificate.") + default: + sb.WriteString("\nAll client certificates issued by this CA must be re-issued before proceeding to the update_servers phase.") + } +} + +func updateServersPhaseHelpText(sb *strings.Builder, caType types.CertAuthType) { + sb.WriteString("In the update_servers phase servers will begin to use certificates issued by the new CA.") +} + +func rollbackPhaseHelpText(sb *strings.Builder) { + sb.WriteString("In the rollback phase the original CA keys become the active signing keys for all new certificates issued by the CA. ") + sb.WriteString("The new CA certificates/keys remain trusted until proceeding to the standby phase.") +} + +func standbyPhaseHelpText(sb *strings.Builder, caType types.CertAuthType, previousPhase string) { + sb.WriteString("The standby phase completes the ") + switch previousPhase { + case "rollback": + sb.WriteString("rollback") + default: + sb.WriteString("rotation") + } + sb.WriteByte('.') + + switch caType { + case types.HostCA: + sb.WriteString("\nAfter entering the standby phase all Teleport Services will stop trusting the ") + switch previousPhase { + case "rollback": + sb.WriteString("new CA and exclusively trust the original CA") + default: + sb.WriteString("old CA") + } + sb.WriteString(" X509 certificate and SSH key.") + } +} + +func manualSteps(caType types.CertAuthType, phase string) []string { + const trustedClusterStep = "Wait up to 30 minutes for any root or leaf clusters to follow the rotation." + const remoteReloginStep = "If you are currently using tctl remotely and logged in with tsh, you must log out and log back in." + const offlineNodesStep = "If any Teleport services may currently be offline, wait for them to come online and follow the rotation." + switch caType { + case types.HostCA: + switch phase { + case "init": + return []string{offlineNodesStep, trustedClusterStep} + case "update_clients": + return []string{offlineNodesStep, trustedClusterStep, remoteReloginStep} + case "update_servers": + return []string{ + "Any OpenSSH hosts must be issued new host certificates signed by the new CA.", + offlineNodesStep, + trustedClusterStep, + } + case "rollback": + return []string{ + "Any OpenSSH host certificates reissued during the rotation must be reissued again to revert to the original issuing CA.", + offlineNodesStep, + trustedClusterStep, + } + case "standby": + return []string{offlineNodesStep, trustedClusterStep} + } + case types.OpenSSHCA: + switch phase { + case "init": + return []string{ + "Any OpenSSH hosts must be updated to trust both the new and old CA keys.", + trustedClusterStep, + } + case "update_clients": + return []string{trustedClusterStep} + case "update_servers": + return []string{trustedClusterStep} + case "rollback": + return []string{ + "Any OpenSSH hosts updated to trust the new CA keys during the update_servers phase should be reverted to only trust the original CA keys.", + trustedClusterStep, + } + case "standby": + return []string{ + "Any OpenSSH hosts should be updated to stop trusting the CA keys that have now been rotated out.", + trustedClusterStep, + } + } + case types.UserCA: + switch phase { + case "init": + return []string{ + "All Windows desktops must be updated to trust both the new and old CA certificates.", + trustedClusterStep, + } + case "update_clients": + return []string{trustedClusterStep} + case "update_servers": + return []string{ + "Wait up to 30 hours for all user sessions to expire, or else users may have to log out and log back in.", + trustedClusterStep, + remoteReloginStep, + } + case "rollback": + return []string{ + "Any Windows desktops updated to trust the new CA certificate during the update_servers phase should be reverted to only trust the original CA certificate.", + trustedClusterStep, + } + case "standby": + return []string{ + "All Windows desktops should be updated to stop trusting the CA certificates that have now been rotated out.", + trustedClusterStep, + } + } + case types.DatabaseCA: + switch phase { + case "init": + return []string{ + "If you also need to rotate the db_client CA, rotate it to the init phase now to reconfigure self-hosted databases with new server certificates and trusted client CAs simultaneously.", + "All self-hosted databases must be issued new certificates signed by the new CA.", + } + case "rollback": + return []string{"Any self-hosted database certificates reissued during the rotation must be reissued again to revert to the original issuing CA."} + } + case types.DatabaseClientCA: + switch phase { + case "init": + return []string{ + "If you also need to rotate the db_client CA, rotate it to the init phase now to reconfigure self-hosted databases with new server certificates and trusted client CAs simultaneously.", + "All self-hosted databases must be updated to trust both the new and old CA certificates.", + } + case "standby": + return []string{"All self-hosted databases should be updated to stop trusting the CA certificates that have now been rotated out."} + } + case types.SAMLIDPCA: + switch phase { + case "update_clients": + return []string{"Any service providers that rely on the SAML IdP must by updated to trust the new CA, follow the SAML IdP guide: https://goteleport.com/docs/admin-guides/access-controls/idps/saml-guide/"} + case "rollback": + return []string{"Any service provider configuration changes made during the rotation must be reverted."} + } + case types.OIDCIdPCA: + // No manual steps required. + return nil + case types.SPIFFECA: + // TODO(strideynet): populate any known manual steps during SPIFFE CA rotation. + fallthrough + case types.OktaCA: + // TODO(smallinsky): populate any known manual steps during Okta CA rotation. + fallthrough + default: + return []string{"Consult the CA rotation docs for any manual steps that may be required: https://goteleport.com/docs/admin-guides/management/operations/ca-rotation/"} + } + return nil +} + +func nextPhases(currentPhase string) []string { + switch currentPhase { + case "standby": + return []string{"init"} + case "init": + return []string{"update_clients", "rollback"} + case "update_clients": + return []string{"update_servers", "rollback"} + case "update_servers": + return []string{"standby", "rollback"} + case "rollback": + return []string{"standby"} + } + return nil +} + +var ( + optimisticPhases = [...]string{"init", "update_clients", "update_servers", "standby"} +) + +func remainingPhases(afterPhase string) []string { + switch afterPhase { + case "standby": + return optimisticPhases[:] + case "init": + return optimisticPhases[1:] + case "update_clients": + return optimisticPhases[2:] + case "update_servers": + return optimisticPhases[3:] + case "rollback": + return []string{"standby"} + } + return nil +} + +func writeln(sb *strings.Builder, s string) { + sb.WriteString(s) + sb.WriteByte('\n') +} + +func setupLoggers(logWriter io.Writer) { + slog.SetDefault(slog.New(logutils.NewSlogTextHandler( + logWriter, + logutils.SlogTextHandlerConfig{EnableColors: true}, + ))) + logrus.StandardLogger().SetOutput(logWriter) +} + +func setupMFAPrompt(client *authclient.Client, pingResp proto.PingResponse, promptWriter io.Writer) { + client.SetMFAPromptConstructor(func(opts ...mfa.PromptOpt) mfa.Prompt { + promptCfg := libmfa.NewPromptConfig(pingResp.ProxyPublicAddr, opts...) + return libmfa.NewCLIPrompt(&libmfa.CLIPromptConfig{ + PromptConfig: *promptCfg, + Writer: promptWriter, + StdinFunc: func() prompt.StdinReader { + return brokenStdinReader{} + }, + }) + }) +} + +var errNoStdin = fmt.Errorf("interactive CA rotation does not support reading passwords from stdin") + +// brokenStdinReader implements [prompt.StdinReader] and returns errNoStdin for +// all methods. Currently this should be unnecessary because MFA for admin +// actions only applies when the only MFA method is webauthn, which should never +// prompt for a password. If we ever enable MFA for admin actions with OTP, +// we'll hit this error instead of bubbletea competing for stdin with the +// password prompt. +type brokenStdinReader struct{} + +func (brokenStdinReader) IsTerminal() bool { return true } +func (brokenStdinReader) ReadContext(_ context.Context) ([]byte, error) { return nil, errNoStdin } +func (brokenStdinReader) ReadPassword(_ context.Context) ([]byte, error) { return nil, errNoStdin } + +func newSelectForm[T comparable](title string, options ...T) *huh.Form { + keyMap := huh.NewDefaultKeyMap() + keyMap.Quit = key.NewBinding(key.WithKeys("q"), key.WithHelp("q", "quit")) + selectField := &fieldWithKeyBinds{ + Field: huh.NewSelect[T](). + Key("selected"). + Options(huh.NewOptions(options...)...). + Title(title), + keyBinds: []key.Binding{ + keyMap.Select.Up, + keyMap.Select.Down, + keyMap.Select.Submit, + keyMap.Quit, + }, + } + return huh.NewForm( + huh.NewGroup(selectField).WithKeyMap(keyMap), + ).WithTheme(authRotateTheme.formTheme) +} + +type fieldWithKeyBinds struct { + huh.Field + keyBinds []key.Binding +} + +func (f *fieldWithKeyBinds) Update(msg tea.Msg) (tea.Model, tea.Cmd) { + field, cmd := f.Field.Update(msg) + f.Field = field.(huh.Field) + return f, cmd +} + +func (f *fieldWithKeyBinds) KeyBinds() []key.Binding { + return f.keyBinds +} diff --git a/tool/tctl/common/status_command.go b/tool/tctl/common/status_command.go index 40f6e90f2f63f..38f19c79ca71e 100644 --- a/tool/tctl/common/status_command.go +++ b/tool/tctl/common/status_command.go @@ -72,22 +72,12 @@ func (c *StatusCommand) TryRun(ctx context.Context, cmd string, client *authclie // Status is called to execute "status" CLI command. func (c *StatusCommand) Status(ctx context.Context, client *authclient.Client) error { - pingRsp, err := client.Ping(ctx) + pingResp, err := client.Ping(ctx) if err != nil { return trace.Wrap(err) } - var authorities []types.CertAuthority - for _, caType := range types.CertAuthTypes { - cas, err := client.GetCertAuthorities(ctx, caType, false) - if err != nil { - slog.WarnContext(ctx, "Failed to fetch CA.", "type", caType, "error", err) - continue - } - authorities = append(authorities, cas...) - } - - status, err := newStatusModel(pingRsp, authorities) + status, err := newStatusModel(ctx, client, pingResp) if err != nil { return trace.Wrap(err) } @@ -102,18 +92,23 @@ type statusModel struct { authorities []*authorityStatusModel } -func newStatusModel(pingResp proto.PingResponse, authorities []types.CertAuthority) (*statusModel, error) { +func newStatusModel(ctx context.Context, client *authclient.Client, pingResp proto.PingResponse) (*statusModel, error) { + var authorities []types.CertAuthority + for _, caType := range types.CertAuthTypes { + cas, err := client.GetCertAuthorities(ctx, caType, false) + if err != nil { + slog.WarnContext(ctx, "Failed to fetch CA", "type", caType, "error", err) + continue + } + authorities = append(authorities, cas...) + } cluster, err := newClusterStatusModel(pingResp, authorities) if err != nil { return nil, trace.Wrap(err) } authorityModels := make([]*authorityStatusModel, 0, len(authorities)) for _, authority := range authorities { - authorityStatus, err := newAuthorityStatusModel(authority) - if err != nil { - return nil, trace.Wrap(err) - } - authorityModels = append(authorityModels, authorityStatus) + authorityModels = append(authorityModels, newAuthorityStatusModel(authority)) } return &statusModel{ cluster: cluster, @@ -132,7 +127,7 @@ func (m *statusModel) renderText(w io.Writer, debug bool) error { summaryTable.AddRow([]string{"", caPin}) } } - if _, err := io.Copy(w, summaryTable.AsBuffer()); err != nil { + if err := summaryTable.WriteTo(w); err != nil { return trace.Wrap(err) } fmt.Fprintln(w, "") @@ -163,8 +158,7 @@ func (m *statusModel) renderText(w io.Writer, debug bool) error { keysTable.AddRow(row) } } - _, err := io.Copy(w, keysTable.AsBuffer()) - return trace.Wrap(err) + return trace.Wrap(keysTable.WriteTo(w)) } // sortRows sorts the rows by each column left to right. @@ -215,14 +209,14 @@ type authorityStatusModel struct { additionalTrustedKeys []*authorityKeyModel } -func newAuthorityStatusModel(authority types.CertAuthority) (*authorityStatusModel, error) { +func newAuthorityStatusModel(authority types.CertAuthority) *authorityStatusModel { return &authorityStatusModel{ clusterName: authority.GetClusterName(), authorityType: authority.GetType(), rotationStatus: authority.GetRotation(), activeKeys: newAuthorityKeyModels(authority.GetActiveKeys()), additionalTrustedKeys: newAuthorityKeyModels(authority.GetAdditionalTrustedKeys()), - }, nil + } } type authorityKeyModel struct { From 58289c805666a542775e6bd916b1e2f2d63cc45f Mon Sep 17 00:00:00 2001 From: "Guillaume J. Charmes" Date: Fri, 6 Dec 2024 14:22:47 -0500 Subject: [PATCH 06/16] Emit port-forward event only the first time, add port-forward-end event. Include cluster and pod metadta in event. (#49900) --- .../teleport/legacy/types/events/events.proto | 15 + api/types/events/events.pb.go | 2358 +++++++++-------- lib/events/api.go | 26 +- lib/events/codes.go | 2 + lib/kube/proxy/forwarder.go | 34 +- .../src/Audit/EventList/EventTypeCell.tsx | 1 + .../teleport/src/services/audit/makeEvent.ts | 5 + .../teleport/src/services/audit/types.ts | 2 + 8 files changed, 1297 insertions(+), 1146 deletions(-) diff --git a/api/proto/teleport/legacy/types/events/events.proto b/api/proto/teleport/legacy/types/events/events.proto index bd61c99381b62..fa3fee74c5ecd 100644 --- a/api/proto/teleport/legacy/types/events/events.proto +++ b/api/proto/teleport/legacy/types/events/events.proto @@ -1617,6 +1617,21 @@ message PortForward { // Addr is a target port forwarding address string Addr = 5 [(gogoproto.jsontag) = "addr"]; + + // KubernetesCluster has information about a kubernetes cluster, if + // applicable. + KubernetesClusterMetadata KubernetesCluster = 6 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // KubernetesPod has information about a kubernetes pod, if applicable. + KubernetesPodMetadata KubernetesPod = 7 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; } // X11Forward is emitted when a user requests X11 protocol forwarding diff --git a/api/types/events/events.pb.go b/api/types/events/events.pb.go index b386ffc8f6e20..8667be1cf5aed 100644 --- a/api/types/events/events.pb.go +++ b/api/types/events/events.pb.go @@ -2976,10 +2976,15 @@ type PortForward struct { // Status contains operation success or failure status Status `protobuf:"bytes,4,opt,name=Status,proto3,embedded=Status" json:""` // Addr is a target port forwarding address - Addr string `protobuf:"bytes,5,opt,name=Addr,proto3" json:"addr"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Addr string `protobuf:"bytes,5,opt,name=Addr,proto3" json:"addr"` + // KubernetesCluster has information about a kubernetes cluster, if + // applicable. + KubernetesClusterMetadata `protobuf:"bytes,6,opt,name=KubernetesCluster,proto3,embedded=KubernetesCluster" json:""` + // KubernetesPod has information about a kubernetes pod, if applicable. + KubernetesPodMetadata `protobuf:"bytes,7,opt,name=KubernetesPod,proto3,embedded=KubernetesPod" json:""` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *PortForward) Reset() { *m = PortForward{} } @@ -15139,1063 +15144,1064 @@ func init() { } var fileDescriptor_007ba1c3d6266d56 = []byte{ - // 16888 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, 0x01, 0x04, 0x1e, 0x03, 0xe4, 0xbc, 0x6a, 0x67, 0x67, 0x17, 0xbb, - 0xb5, 0x77, 0x73, 0x33, 0x7b, 0xbb, 0x98, 0xdb, 0xd9, 0xd9, 0xdd, 0xdb, 0xd7, 0xed, 0x35, 0xd0, - 0xc0, 0xa0, 0x67, 0xf0, 0xda, 0x6a, 0xcc, 0xcc, 0xed, 0x91, 0x77, 0xcd, 0x42, 0x57, 0xa2, 0x51, - 0x3b, 0xdd, 0x55, 0xcd, 0xaa, 0xea, 0xc1, 0x60, 0xfd, 0xe2, 0xd1, 0x14, 0x45, 0x8a, 0xc7, 0xd3, - 0xf9, 0x68, 0x8a, 0xd4, 0xc3, 0xd6, 0x51, 0x0f, 0x9b, 0xa2, 0x28, 0x9e, 0x29, 0xd1, 0x24, 0x8f, - 0xe4, 0x59, 0x92, 0xe9, 0xc7, 0x89, 0xfc, 0xcc, 0x8f, 0x94, 0x6d, 0x7d, 0xfa, 0x6c, 0x19, 0x27, - 0xd3, 0xd6, 0x1f, 0x7c, 0xf6, 0xf7, 0xd1, 0xf6, 0x7d, 0xd6, 0x59, 0x96, 0xfd, 0xe9, 0xcb, 0xc8, - 0xac, 0xaa, 0xac, 0x57, 0xe3, 0xb9, 0xc2, 0xe2, 0x06, 0x7f, 0x66, 0xd0, 0x11, 0x91, 0x91, 0x59, - 0x91, 0x91, 0x99, 0x91, 0x99, 0x91, 0x11, 0x70, 0xcd, 0xa3, 0x2d, 0xda, 0xb1, 0x1d, 0xef, 0x7a, - 0x8b, 0x36, 0xf5, 0xc6, 0xd6, 0x75, 0x6f, 0xab, 0x43, 0xdd, 0xeb, 0xf4, 0x21, 0xb5, 0x3c, 0xff, - 0xbf, 0xa9, 0x8e, 0x63, 0x7b, 0x36, 0x29, 0xf1, 0x5f, 0x97, 0xce, 0x35, 0xed, 0xa6, 0x8d, 0xa0, - 0xeb, 0xec, 0x2f, 0x8e, 0xbd, 0x74, 0xb9, 0x69, 0xdb, 0xcd, 0x16, 0xbd, 0x8e, 0xbf, 0xd6, 0xba, - 0xeb, 0xd7, 0x5d, 0xcf, 0xe9, 0x36, 0x3c, 0x81, 0x9d, 0x8c, 0x63, 0x3d, 0xb3, 0x4d, 0x5d, 0x4f, - 0x6f, 0x77, 0x04, 0xc1, 0xd3, 0x71, 0x82, 0x4d, 0x47, 0xef, 0x74, 0xa8, 0x23, 0x2a, 0xbf, 0xf4, - 0x89, 0xa0, 0x9d, 0x7a, 0xa3, 0x41, 0x5d, 0xb7, 0x65, 0xba, 0xde, 0xf5, 0x87, 0x2f, 0x49, 0xbf, - 0x04, 0xe1, 0xb3, 0xe9, 0x1f, 0x84, 0xff, 0x0a, 0x92, 0x17, 0xd3, 0x49, 0xfc, 0x1a, 0x63, 0x55, - 0xab, 0x5f, 0xcb, 0xc3, 0xe0, 0x22, 0xf5, 0x74, 0x43, 0xf7, 0x74, 0x72, 0x19, 0xfa, 0xab, 0x96, - 0x41, 0x1f, 0x29, 0xb9, 0x67, 0x72, 0x57, 0x0b, 0xd3, 0xa5, 0x9d, 0xed, 0xc9, 0x3c, 0x35, 0x35, - 0x0e, 0x24, 0x4f, 0x41, 0x71, 0x75, 0xab, 0x43, 0x95, 0xfc, 0x33, 0xb9, 0xab, 0x43, 0xd3, 0x43, - 0x3b, 0xdb, 0x93, 0xfd, 0x28, 0x34, 0x0d, 0xc1, 0xe4, 0x59, 0xc8, 0x57, 0x2b, 0x4a, 0x01, 0x91, - 0x13, 0x3b, 0xdb, 0x93, 0xa3, 0x5d, 0xd3, 0x78, 0xc1, 0x6e, 0x9b, 0x1e, 0x6d, 0x77, 0xbc, 0x2d, - 0x2d, 0x5f, 0xad, 0x90, 0x2b, 0x50, 0x9c, 0xb1, 0x0d, 0xaa, 0x14, 0x91, 0x88, 0xec, 0x6c, 0x4f, - 0x8e, 0x35, 0x6c, 0x83, 0x4a, 0x54, 0x88, 0x27, 0x9f, 0x85, 0xe2, 0xaa, 0xd9, 0xa6, 0x4a, 0xff, - 0x33, 0xb9, 0xab, 0xc3, 0x37, 0x2e, 0x4d, 0x71, 0xf1, 0x4d, 0xf9, 0xe2, 0x9b, 0x5a, 0xf5, 0xe5, - 0x3b, 0x3d, 0xfe, 0xed, 0xed, 0xc9, 0xbe, 0x9d, 0xed, 0xc9, 0x22, 0x13, 0xf9, 0x57, 0xbf, 0x33, - 0x99, 0xd3, 0xb0, 0x24, 0x79, 0x0b, 0x86, 0x67, 0x5a, 0x5d, 0xd7, 0xa3, 0xce, 0x92, 0xde, 0xa6, - 0x4a, 0x09, 0x2b, 0xbc, 0xb4, 0xb3, 0x3d, 0x79, 0xa1, 0xc1, 0xc1, 0x75, 0x4b, 0x6f, 0xcb, 0x15, - 0xcb, 0xe4, 0xea, 0x6f, 0xe6, 0xe0, 0x4c, 0x8d, 0xba, 0xae, 0x69, 0x5b, 0x81, 0x6c, 0x3e, 0x0e, - 0x43, 0x02, 0x54, 0xad, 0xa0, 0x7c, 0x86, 0xa6, 0x07, 0x76, 0xb6, 0x27, 0x0b, 0xae, 0x69, 0x68, - 0x21, 0x86, 0x7c, 0x0a, 0x06, 0xee, 0x9b, 0xde, 0xc6, 0xe2, 0x5c, 0x59, 0xc8, 0xe9, 0xc2, 0xce, - 0xf6, 0x24, 0xd9, 0x34, 0xbd, 0x8d, 0x7a, 0x7b, 0x5d, 0x97, 0x2a, 0xf4, 0xc9, 0xc8, 0x02, 0x8c, - 0xaf, 0x38, 0xe6, 0x43, 0xdd, 0xa3, 0x77, 0xe8, 0xd6, 0x8a, 0xdd, 0x32, 0x1b, 0x5b, 0x42, 0x8a, - 0xcf, 0xec, 0x6c, 0x4f, 0x5e, 0xee, 0x70, 0x5c, 0xfd, 0x01, 0xdd, 0xaa, 0x77, 0x10, 0x2b, 0x31, - 0x49, 0x94, 0x54, 0x7f, 0xab, 0x04, 0x23, 0x77, 0x5d, 0xea, 0x04, 0xed, 0xbe, 0x02, 0x45, 0xf6, - 0x5b, 0x34, 0x19, 0x65, 0xde, 0x75, 0xa9, 0x23, 0xcb, 0x9c, 0xe1, 0xc9, 0x35, 0xe8, 0x5f, 0xb0, - 0x9b, 0xa6, 0x25, 0x9a, 0x7d, 0x76, 0x67, 0x7b, 0xf2, 0x4c, 0x8b, 0x01, 0x24, 0x4a, 0x4e, 0x41, - 0x3e, 0x03, 0x23, 0xd5, 0x36, 0xd3, 0x21, 0xdb, 0xd2, 0x3d, 0xdb, 0x11, 0xad, 0x45, 0xe9, 0x9a, - 0x12, 0x5c, 0x2a, 0x18, 0xa1, 0x27, 0x6f, 0x00, 0x94, 0xef, 0xd7, 0x34, 0xbb, 0x45, 0xcb, 0xda, - 0x92, 0x50, 0x06, 0x2c, 0xad, 0x6f, 0xba, 0x75, 0xc7, 0x6e, 0xd1, 0xba, 0xee, 0xc8, 0xd5, 0x4a, - 0xd4, 0x64, 0x16, 0xc6, 0xca, 0x38, 0x2a, 0x34, 0xfa, 0xc3, 0x5d, 0xea, 0x7a, 0xae, 0xd2, 0xff, - 0x4c, 0xe1, 0xea, 0xd0, 0xf4, 0x53, 0x3b, 0xdb, 0x93, 0x4f, 0xf0, 0xf1, 0x52, 0x77, 0x04, 0x4a, - 0x62, 0x11, 0x2b, 0x44, 0xa6, 0x61, 0xb4, 0xfc, 0x41, 0xd7, 0xa1, 0x55, 0x83, 0x5a, 0x9e, 0xe9, - 0x6d, 0x09, 0x0d, 0xb9, 0xbc, 0xb3, 0x3d, 0xa9, 0xe8, 0x0c, 0x51, 0x37, 0x05, 0x46, 0x62, 0x12, - 0x2d, 0x42, 0x96, 0x61, 0xe2, 0xd6, 0xcc, 0x4a, 0x8d, 0x3a, 0x0f, 0xcd, 0x06, 0x2d, 0x37, 0x1a, - 0x76, 0xd7, 0xf2, 0x94, 0x01, 0xe4, 0xf3, 0xec, 0xce, 0xf6, 0xe4, 0x53, 0xcd, 0x46, 0xa7, 0xee, - 0x72, 0x6c, 0x5d, 0xe7, 0x68, 0x89, 0x59, 0xb2, 0x2c, 0xf9, 0x3c, 0x8c, 0xae, 0x3a, 0x4c, 0x0b, - 0x8d, 0x0a, 0x65, 0x70, 0x65, 0x10, 0xf5, 0xff, 0xc2, 0x94, 0x98, 0xa9, 0x38, 0xd4, 0xef, 0x59, - 0xde, 0x58, 0x8f, 0x17, 0xa8, 0x1b, 0x88, 0x93, 0x1b, 0x1b, 0x61, 0x45, 0x28, 0x28, 0xec, 0xe3, - 0x4d, 0x87, 0x1a, 0x09, 0x6d, 0x1b, 0xc2, 0x36, 0x5f, 0xdb, 0xd9, 0x9e, 0xfc, 0xb8, 0x23, 0x68, - 0xea, 0x3d, 0xd5, 0x2e, 0x93, 0x15, 0x99, 0x85, 0x41, 0xa6, 0x4d, 0x77, 0x4c, 0xcb, 0x50, 0xe0, - 0x99, 0xdc, 0xd5, 0xb1, 0x1b, 0xe3, 0x7e, 0xeb, 0x7d, 0xf8, 0xf4, 0xc5, 0x9d, 0xed, 0xc9, 0xb3, - 0x4c, 0x07, 0xeb, 0x0f, 0x4c, 0x4b, 0x9e, 0x22, 0x82, 0xa2, 0x6c, 0x14, 0x4d, 0xdb, 0x1e, 0x0e, - 0xdd, 0xe1, 0x70, 0x14, 0xad, 0xd9, 0x5e, 0x7c, 0xd8, 0xfa, 0x64, 0x64, 0x06, 0x46, 0xa7, 0x6d, - 0xaf, 0x6a, 0xb9, 0x9e, 0x6e, 0x35, 0x68, 0xb5, 0xa2, 0x8c, 0x60, 0x39, 0x54, 0x0b, 0x56, 0xce, - 0x14, 0x98, 0x7a, 0x64, 0x52, 0x8a, 0x96, 0x51, 0xff, 0x79, 0x11, 0xc6, 0x58, 0x9f, 0x48, 0xc3, - 0xa7, 0xcc, 0x66, 0x02, 0x06, 0x61, 0xb5, 0xb8, 0x1d, 0xbd, 0x41, 0xc5, 0x48, 0xc2, 0xaf, 0xb0, - 0x7c, 0xa0, 0xc4, 0x33, 0x4e, 0x4f, 0xae, 0xc1, 0x20, 0x07, 0x55, 0x2b, 0x62, 0x70, 0x8d, 0xee, - 0x6c, 0x4f, 0x0e, 0xb9, 0x08, 0xab, 0x9b, 0x86, 0x16, 0xa0, 0x99, 0x76, 0xf3, 0xbf, 0xe7, 0x6d, - 0xd7, 0x63, 0xcc, 0xc5, 0xd8, 0xc2, 0xcf, 0x10, 0x05, 0x36, 0x04, 0x4a, 0xd6, 0xee, 0x68, 0x21, - 0xf2, 0x3a, 0x00, 0x87, 0x94, 0x0d, 0xc3, 0x11, 0x03, 0xec, 0x89, 0x9d, 0xed, 0xc9, 0xf3, 0x82, - 0x85, 0x6e, 0x18, 0xf2, 0xe8, 0x94, 0x88, 0x49, 0x1b, 0x46, 0xf8, 0xaf, 0x05, 0x7d, 0x8d, 0xb6, - 0xf8, 0xe8, 0x1a, 0xbe, 0x71, 0xd5, 0xef, 0xc4, 0xa8, 0x74, 0xa6, 0x64, 0xd2, 0x59, 0xcb, 0x73, - 0xb6, 0xa6, 0x27, 0xc5, 0x84, 0x7c, 0x51, 0x54, 0xd5, 0x42, 0x9c, 0x3c, 0x15, 0xc8, 0x65, 0xd8, - 0x3c, 0x3d, 0x67, 0x3b, 0x9b, 0xba, 0x63, 0x50, 0x63, 0x7a, 0x4b, 0x9e, 0xa7, 0xd7, 0x7d, 0x70, - 0x7d, 0x4d, 0x56, 0x3d, 0x99, 0x9c, 0x75, 0x3a, 0xe7, 0x56, 0xeb, 0xae, 0xa1, 0xca, 0x0d, 0x24, - 0xa4, 0xe5, 0x76, 0xd7, 0xe2, 0x6a, 0x16, 0x2d, 0xc3, 0xa6, 0x02, 0x0e, 0xb8, 0x47, 0x1d, 0x36, - 0x89, 0xe3, 0xa8, 0x13, 0x53, 0x81, 0x60, 0xf2, 0x90, 0x63, 0x92, 0x3c, 0x44, 0x91, 0x4b, 0xef, - 0xc0, 0x44, 0x42, 0x14, 0x64, 0x1c, 0x0a, 0x0f, 0xe8, 0x16, 0x57, 0x17, 0x8d, 0xfd, 0x49, 0xce, - 0x41, 0xff, 0x43, 0xbd, 0xd5, 0x15, 0x4b, 0xa8, 0xc6, 0x7f, 0xbc, 0x91, 0xff, 0x74, 0x8e, 0xad, - 0x38, 0x64, 0xc6, 0xb6, 0x2c, 0xda, 0xf0, 0xe4, 0x45, 0xe7, 0x55, 0x18, 0x5a, 0xb0, 0x1b, 0x7a, - 0x0b, 0xfb, 0x91, 0xeb, 0x9d, 0xb2, 0xb3, 0x3d, 0x79, 0x8e, 0x75, 0xe0, 0x54, 0x8b, 0x61, 0xa4, - 0x36, 0x85, 0xa4, 0x4c, 0x01, 0x34, 0xda, 0xb6, 0x3d, 0x8a, 0x05, 0xf3, 0xa1, 0x02, 0x60, 0x41, - 0x07, 0x51, 0xb2, 0x02, 0x84, 0xc4, 0xe4, 0x3a, 0x0c, 0xae, 0xb0, 0x75, 0xb6, 0x61, 0xb7, 0x84, - 0xf2, 0xe1, 0x52, 0x80, 0x6b, 0xaf, 0x3c, 0x56, 0x7d, 0x22, 0x75, 0x1e, 0xc6, 0x66, 0x5a, 0x26, - 0xb5, 0x3c, 0xb9, 0xd5, 0x6c, 0x24, 0x97, 0x9b, 0xd4, 0xf2, 0xe4, 0x56, 0xe3, 0x98, 0xd7, 0x19, - 0x54, 0x6e, 0x75, 0x40, 0xaa, 0xfe, 0x41, 0x01, 0x9e, 0xb8, 0xd3, 0x5d, 0xa3, 0x8e, 0x45, 0x3d, - 0xea, 0x8a, 0x05, 0x39, 0xe0, 0xba, 0x04, 0x13, 0x09, 0xa4, 0xe0, 0x8e, 0x0b, 0xe5, 0x83, 0x00, - 0x59, 0x17, 0x6b, 0xbc, 0x3c, 0xdb, 0x26, 0x8a, 0x92, 0x79, 0x38, 0x13, 0x02, 0x59, 0x23, 0x5c, - 0x25, 0x8f, 0x4b, 0xc9, 0xd3, 0x3b, 0xdb, 0x93, 0x97, 0x24, 0x6e, 0xac, 0xd9, 0xb2, 0x06, 0xc7, - 0x8b, 0x91, 0x3b, 0x30, 0x1e, 0x82, 0x6e, 0x39, 0x76, 0xb7, 0xe3, 0x2a, 0x05, 0x64, 0x35, 0xb9, - 0xb3, 0x3d, 0xf9, 0xa4, 0xc4, 0xaa, 0x89, 0x48, 0x79, 0x01, 0x8f, 0x17, 0x24, 0x3f, 0x96, 0x93, - 0xb9, 0x89, 0x51, 0x58, 0xc4, 0x51, 0xf8, 0x9a, 0x3f, 0x0a, 0x33, 0x85, 0x34, 0x15, 0x2f, 0x29, - 0x06, 0x65, 0xac, 0x19, 0x89, 0x41, 0x99, 0xa8, 0xf1, 0xd2, 0x0c, 0x9c, 0x4f, 0xe5, 0xb5, 0x2f, - 0xad, 0xfe, 0x67, 0x05, 0x99, 0xcb, 0x8a, 0x6d, 0x04, 0x9d, 0xb9, 0x2c, 0x77, 0xe6, 0x8a, 0x6d, - 0xe0, 0x54, 0x9f, 0x0b, 0xd7, 0x4e, 0xa9, 0xb1, 0x1d, 0xdb, 0x88, 0xcf, 0xfa, 0xc9, 0xb2, 0xe4, - 0x8b, 0x70, 0x21, 0x01, 0xe4, 0xd3, 0x35, 0xd7, 0xfe, 0x2b, 0x3b, 0xdb, 0x93, 0x6a, 0x0a, 0xd7, - 0xf8, 0xec, 0x9d, 0xc1, 0x85, 0xe8, 0x70, 0x51, 0x92, 0xba, 0x6d, 0x79, 0xba, 0x69, 0x09, 0xe3, - 0x92, 0x8f, 0x92, 0x4f, 0xec, 0x6c, 0x4f, 0x3e, 0x27, 0xeb, 0xa0, 0x4f, 0x13, 0x6f, 0x7c, 0x16, - 0x1f, 0x62, 0x80, 0x92, 0x82, 0xaa, 0xb6, 0xf5, 0xa6, 0x6f, 0x31, 0x5f, 0xdd, 0xd9, 0x9e, 0xfc, - 0x58, 0x6a, 0x1d, 0x26, 0xa3, 0x92, 0x57, 0xe8, 0x2c, 0x4e, 0x44, 0x03, 0x12, 0xe2, 0x96, 0x6c, - 0x83, 0xe2, 0x37, 0xf4, 0x23, 0x7f, 0x75, 0x67, 0x7b, 0xf2, 0x69, 0x89, 0xbf, 0x65, 0x1b, 0x34, - 0xde, 0xfc, 0x94, 0xd2, 0xea, 0x6f, 0x16, 0xe0, 0xe9, 0x5a, 0x79, 0x71, 0xa1, 0x6a, 0xf8, 0x26, - 0xcd, 0x8a, 0x63, 0x3f, 0x34, 0x0d, 0x69, 0xf4, 0xae, 0xc1, 0xc5, 0x18, 0x6a, 0x16, 0xad, 0xa8, - 0xc0, 0x98, 0xc6, 0x6f, 0xf3, 0xcd, 0xa5, 0x8e, 0xa0, 0xa9, 0x73, 0x53, 0x2b, 0xba, 0x68, 0x67, - 0x31, 0x62, 0x7d, 0x14, 0x43, 0xd5, 0x36, 0x6c, 0xc7, 0x6b, 0x74, 0x3d, 0xa1, 0x04, 0xd8, 0x47, - 0x89, 0x3a, 0x5c, 0x41, 0xd4, 0xa3, 0x0a, 0x9f, 0x0f, 0xf9, 0xc9, 0x1c, 0x8c, 0x97, 0x3d, 0xcf, - 0x31, 0xd7, 0xba, 0x1e, 0x5d, 0xd4, 0x3b, 0x1d, 0xd3, 0x6a, 0xe2, 0x58, 0x1f, 0xbe, 0xf1, 0x56, - 0xb0, 0x46, 0xf6, 0x94, 0xc4, 0x54, 0xbc, 0xb8, 0x34, 0x44, 0x75, 0x1f, 0x55, 0x6f, 0x73, 0x9c, - 0x3c, 0x44, 0xe3, 0xe5, 0xd8, 0x10, 0x4d, 0xe5, 0xb5, 0xaf, 0x21, 0xfa, 0xb5, 0x02, 0x5c, 0x5e, - 0x7e, 0xe0, 0xe9, 0x1a, 0x75, 0xed, 0xae, 0xd3, 0xa0, 0xee, 0xdd, 0x8e, 0xa1, 0x7b, 0x34, 0x1c, - 0xa9, 0x93, 0xd0, 0x5f, 0x36, 0x0c, 0x6a, 0x20, 0xbb, 0x7e, 0xbe, 0xed, 0xd3, 0x19, 0x40, 0xe3, - 0x70, 0xf2, 0x71, 0x18, 0x10, 0x65, 0x90, 0x7b, 0xff, 0xf4, 0xf0, 0xce, 0xf6, 0xe4, 0x40, 0x97, - 0x83, 0x34, 0x1f, 0xc7, 0xc8, 0x2a, 0xb4, 0x45, 0x19, 0x59, 0x21, 0x24, 0x33, 0x38, 0x48, 0xf3, - 0x71, 0xe4, 0x5d, 0x18, 0x43, 0xb6, 0x41, 0x7b, 0xc4, 0xdc, 0x77, 0xce, 0x97, 0xae, 0xdc, 0x58, - 0xbe, 0x34, 0x61, 0x6b, 0xea, 0x8e, 0x5f, 0x40, 0x8b, 0x31, 0x20, 0xf7, 0x61, 0x5c, 0x34, 0x22, - 0x64, 0xda, 0xdf, 0x83, 0xe9, 0xf9, 0x9d, 0xed, 0xc9, 0x09, 0xd1, 0x7e, 0x89, 0x6d, 0x82, 0x09, - 0x63, 0x2c, 0x9a, 0x1d, 0x32, 0x2e, 0xed, 0xc6, 0x58, 0x7c, 0xb1, 0xcc, 0x38, 0xce, 0x44, 0x7d, - 0x0f, 0x46, 0xe4, 0x82, 0xe4, 0x02, 0x6e, 0xad, 0xf9, 0x38, 0xc1, 0x4d, 0xb9, 0x69, 0xe0, 0x7e, - 0xfa, 0x25, 0x18, 0xae, 0x50, 0xb7, 0xe1, 0x98, 0x1d, 0x66, 0x35, 0x08, 0x25, 0x3f, 0xb3, 0xb3, - 0x3d, 0x39, 0x6c, 0x84, 0x60, 0x4d, 0xa6, 0x51, 0xff, 0xef, 0x1c, 0x5c, 0x60, 0xbc, 0xcb, 0xae, - 0x6b, 0x36, 0xad, 0xb6, 0xbc, 0x6c, 0xbf, 0x00, 0xa5, 0x1a, 0xd6, 0x27, 0x6a, 0x3a, 0xb7, 0xb3, - 0x3d, 0x39, 0xce, 0x5b, 0x20, 0xe9, 0xa1, 0xa0, 0x09, 0xf6, 0x95, 0xf9, 0x5d, 0xf6, 0x95, 0xcc, - 0xa4, 0xf5, 0x74, 0xc7, 0x33, 0xad, 0x66, 0xcd, 0xd3, 0xbd, 0xae, 0x1b, 0x31, 0x69, 0x05, 0xa6, - 0xee, 0x22, 0x2a, 0x62, 0xd2, 0x46, 0x0a, 0x91, 0x77, 0x60, 0x64, 0xd6, 0x32, 0x42, 0x26, 0x7c, - 0x42, 0x7c, 0x92, 0x59, 0x9a, 0x14, 0xe1, 0x49, 0x16, 0x91, 0x02, 0xea, 0xdf, 0xca, 0x81, 0xc2, - 0x37, 0x81, 0x0b, 0xa6, 0xeb, 0x2d, 0xd2, 0xf6, 0x9a, 0x34, 0x3b, 0xcd, 0xf9, 0xbb, 0x4a, 0x86, - 0x93, 0xd6, 0x22, 0x34, 0x05, 0xc4, 0xae, 0xb2, 0x65, 0xba, 0x89, 0xed, 0x47, 0xac, 0x14, 0xa9, - 0xc2, 0x00, 0xe7, 0xcc, 0x6d, 0x89, 0xe1, 0x1b, 0x8a, 0xaf, 0x08, 0xf1, 0xaa, 0xb9, 0x32, 0xb4, - 0x39, 0xb1, 0xbc, 0xa1, 0x11, 0xe5, 0xd5, 0xaf, 0x17, 0x60, 0x3c, 0x5e, 0x88, 0xdc, 0x87, 0xc1, - 0xdb, 0xb6, 0x69, 0x51, 0x63, 0xd9, 0xc2, 0x16, 0xf6, 0x3e, 0x1c, 0xf1, 0x6d, 0xf1, 0xb3, 0xef, - 0x63, 0x99, 0xba, 0x6c, 0xc1, 0xe2, 0x59, 0x49, 0xc0, 0x8c, 0x7c, 0x1e, 0x86, 0x98, 0x0d, 0xf8, - 0x10, 0x39, 0xe7, 0x77, 0xe5, 0xfc, 0x8c, 0xe0, 0x7c, 0xce, 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, - 0x62, 0xc1, 0x19, 0x21, 0xd0, 0x0d, 0xb3, 0x83, 0x56, 0x3f, 0xae, 0x6b, 0x63, 0x37, 0xae, 0x4c, - 0xf9, 0x87, 0x62, 0x53, 0xd2, 0x91, 0xda, 0xc3, 0x97, 0xa6, 0x16, 0x03, 0x72, 0xdc, 0x99, 0xa2, - 0x4e, 0xc6, 0x58, 0xc8, 0xbd, 0xdd, 0x8e, 0x90, 0xab, 0x3f, 0x9e, 0x87, 0x17, 0xc3, 0x2e, 0xd2, - 0xe8, 0x43, 0x93, 0x6e, 0x86, 0x1c, 0xc5, 0x1e, 0x99, 0x0d, 0x31, 0x77, 0x66, 0x43, 0xb7, 0x9a, - 0xd4, 0x20, 0xd7, 0xa0, 0x5f, 0xb3, 0x5b, 0xd4, 0x55, 0x72, 0x68, 0x1e, 0xe2, 0xf4, 0xe5, 0x30, - 0x80, 0x7c, 0xc8, 0x82, 0x14, 0xc4, 0x86, 0xd2, 0xaa, 0xa3, 0x9b, 0x9e, 0xaf, 0x49, 0xe5, 0xa4, - 0x26, 0xed, 0xa1, 0xc6, 0x29, 0xce, 0x83, 0xaf, 0x31, 0x28, 0x78, 0x0f, 0x01, 0xb2, 0xe0, 0x39, - 0xc9, 0xa5, 0xd7, 0x61, 0x58, 0x22, 0xde, 0xd7, 0x22, 0xf2, 0xcd, 0xa2, 0x3c, 0xb6, 0xfc, 0x66, - 0x89, 0xb1, 0x75, 0x9d, 0x8d, 0x09, 0xd7, 0x65, 0x56, 0x0c, 0x1f, 0x54, 0x42, 0xf3, 0x11, 0x14, - 0xd5, 0x7c, 0x04, 0x91, 0x97, 0x61, 0x90, 0xb3, 0x08, 0xf6, 0xcb, 0xb8, 0xd7, 0x76, 0x10, 0x16, - 0x35, 0x05, 0x02, 0x42, 0xf2, 0x4b, 0x39, 0x78, 0xaa, 0xa7, 0x24, 0x50, 0xf9, 0x86, 0x6f, 0xbc, - 0x72, 0x20, 0x31, 0x4e, 0xbf, 0xb8, 0xb3, 0x3d, 0x79, 0x4d, 0xd2, 0x0c, 0x47, 0xa2, 0xa9, 0x37, - 0x38, 0x91, 0xd4, 0xae, 0xde, 0x4d, 0x61, 0xc6, 0x2a, 0xaf, 0x74, 0x0e, 0x8f, 0xaa, 0xac, 0xc6, - 0x96, 0xdf, 0xc8, 0x62, 0x68, 0xac, 0x8a, 0xef, 0x5d, 0xf7, 0x49, 0x52, 0xaa, 0xc9, 0xe0, 0x42, - 0x1a, 0x70, 0x91, 0x63, 0x2a, 0xfa, 0xd6, 0xf2, 0xfa, 0xa2, 0x6d, 0x79, 0x1b, 0x7e, 0x05, 0xfd, - 0xf2, 0x59, 0x0f, 0x56, 0x60, 0xe8, 0x5b, 0x75, 0x7b, 0xbd, 0xde, 0x66, 0x54, 0x29, 0x75, 0x64, - 0x71, 0x62, 0x13, 0xbb, 0x18, 0xe3, 0xfe, 0x94, 0x57, 0x0a, 0x4f, 0xe2, 0xfc, 0x79, 0x21, 0x39, - 0xc1, 0xc5, 0x0a, 0xa9, 0x55, 0x18, 0x59, 0xb0, 0x1b, 0x0f, 0x02, 0x75, 0x79, 0x1d, 0x4a, 0xab, - 0xba, 0xd3, 0xa4, 0x1e, 0xca, 0x62, 0xf8, 0xc6, 0xc4, 0x14, 0x3f, 0xdd, 0x66, 0x44, 0x1c, 0x31, - 0x3d, 0x26, 0x66, 0x9f, 0x92, 0x87, 0xbf, 0x35, 0x51, 0x40, 0xfd, 0x4e, 0x3f, 0x8c, 0x88, 0x93, - 0x58, 0x5c, 0x3d, 0xc8, 0x1b, 0xe1, 0xd9, 0xb6, 0x98, 0x2e, 0x83, 0xd3, 0xa8, 0xe0, 0x14, 0x6d, - 0x84, 0x31, 0xfb, 0xc3, 0xed, 0xc9, 0xdc, 0xce, 0xf6, 0x64, 0x9f, 0x36, 0x28, 0x6d, 0x62, 0xc3, - 0xf5, 0x4d, 0x5a, 0xd0, 0xe5, 0xb3, 0xd5, 0x58, 0x59, 0xbe, 0xde, 0xbd, 0x03, 0x03, 0xa2, 0x0d, - 0x42, 0xe3, 0x2e, 0x86, 0x67, 0x27, 0x91, 0x13, 0xe5, 0x58, 0x69, 0xbf, 0x14, 0x79, 0x0b, 0x4a, - 0xfc, 0x2c, 0x41, 0x08, 0xe0, 0x42, 0xfa, 0xd9, 0x4b, 0xac, 0xb8, 0x28, 0x43, 0xe6, 0x01, 0xc2, - 0x73, 0x84, 0xe0, 0x00, 0x5d, 0x70, 0x48, 0x9e, 0x30, 0xc4, 0xb8, 0x48, 0x65, 0xc9, 0xab, 0x30, - 0xb2, 0x4a, 0x9d, 0xb6, 0x69, 0xe9, 0xad, 0x9a, 0xf9, 0x81, 0x7f, 0x86, 0x8e, 0x0b, 0xbd, 0x6b, - 0x7e, 0x20, 0x8f, 0xdc, 0x08, 0x1d, 0xf9, 0x42, 0xda, 0x3e, 0x7d, 0x00, 0x1b, 0xf2, 0xec, 0xae, - 0x1b, 0xd8, 0x58, 0x7b, 0x52, 0xb6, 0xed, 0xef, 0xc2, 0x68, 0x64, 0x8b, 0x26, 0x0e, 0x49, 0x9f, - 0x4a, 0xb2, 0x96, 0xf6, 0x9b, 0x31, 0xb6, 0x51, 0x0e, 0x4c, 0x93, 0xab, 0x96, 0xe9, 0x99, 0x7a, - 0x6b, 0xc6, 0x6e, 0xb7, 0x75, 0xcb, 0x50, 0x86, 0x42, 0x4d, 0x36, 0x39, 0xa6, 0xde, 0xe0, 0x28, - 0x59, 0x93, 0xa3, 0x85, 0xc8, 0x1d, 0x18, 0x17, 0x7d, 0xa8, 0xd1, 0x86, 0xed, 0x30, 0xdb, 0x03, - 0xcf, 0x40, 0xc5, 0x31, 0x80, 0xcb, 0x71, 0x75, 0xc7, 0x47, 0xca, 0xc6, 0x7d, 0xbc, 0xe0, 0xed, - 0xe2, 0xe0, 0xf0, 0xf8, 0x48, 0xfc, 0xd8, 0x5a, 0xfd, 0x1b, 0x05, 0x18, 0x16, 0xa4, 0x6c, 0xe9, - 0x3e, 0x55, 0xf0, 0xc3, 0x28, 0x78, 0xaa, 0xa2, 0x96, 0x8e, 0x4a, 0x51, 0xd5, 0x2f, 0xe7, 0x83, - 0xd9, 0x68, 0xc5, 0x31, 0xad, 0xc3, 0xcd, 0x46, 0x57, 0x00, 0x66, 0x36, 0xba, 0xd6, 0x03, 0x7e, - 0x3d, 0x97, 0x0f, 0xaf, 0xe7, 0x1a, 0xa6, 0x26, 0x61, 0xc8, 0x53, 0x50, 0xac, 0x30, 0xfe, 0xac, - 0x67, 0x46, 0xa6, 0x87, 0xbe, 0xcd, 0x39, 0xe5, 0x5e, 0xd4, 0x10, 0xcc, 0x36, 0x73, 0xd3, 0x5b, - 0x1e, 0xe5, 0xe6, 0x73, 0x81, 0x6f, 0xe6, 0xd6, 0x18, 0x40, 0xe3, 0x70, 0x72, 0x13, 0x26, 0x2a, - 0xb4, 0xa5, 0x6f, 0x2d, 0x9a, 0xad, 0x96, 0xe9, 0xd2, 0x86, 0x6d, 0x19, 0x2e, 0x0a, 0x59, 0x54, - 0xd7, 0x76, 0xb5, 0x24, 0x01, 0x51, 0xa1, 0xb4, 0xbc, 0xbe, 0xee, 0x52, 0x0f, 0xc5, 0x57, 0x98, - 0x06, 0x36, 0x39, 0xdb, 0x08, 0xd1, 0x04, 0x46, 0xfd, 0x46, 0x8e, 0xed, 0x96, 0xdc, 0x07, 0x9e, - 0xdd, 0x09, 0xb4, 0xfc, 0x50, 0x22, 0xb9, 0x16, 0xda, 0x15, 0x79, 0xfc, 0xda, 0x33, 0xe2, 0x6b, - 0x07, 0x84, 0x6d, 0x11, 0x5a, 0x14, 0xa9, 0x5f, 0x55, 0xd8, 0xe5, 0xab, 0xd4, 0x3f, 0xc9, 0xc3, - 0x45, 0xd1, 0xe2, 0x99, 0x96, 0xd9, 0x59, 0xb3, 0x75, 0xc7, 0xd0, 0x68, 0x83, 0x9a, 0x0f, 0xe9, - 0xc9, 0x1c, 0x78, 0xd1, 0xa1, 0x53, 0x3c, 0xc4, 0xd0, 0xb9, 0x81, 0x1b, 0x4f, 0x26, 0x19, 0x3c, - 0x60, 0xe6, 0x46, 0xc5, 0xf8, 0xce, 0xf6, 0xe4, 0x88, 0xc1, 0xc1, 0x78, 0xc5, 0xa0, 0xc9, 0x44, - 0x4c, 0x49, 0x16, 0xa8, 0xd5, 0xf4, 0x36, 0x50, 0x49, 0xfa, 0xb9, 0x92, 0xb4, 0x10, 0xa2, 0x09, - 0x8c, 0xfa, 0xbf, 0xe7, 0xe1, 0x5c, 0x5c, 0xe4, 0x35, 0x6a, 0x19, 0xa7, 0xf2, 0xfe, 0x70, 0xe4, - 0xfd, 0xdd, 0x02, 0x3c, 0x29, 0xca, 0xd4, 0x36, 0x74, 0x87, 0x1a, 0x15, 0xd3, 0xa1, 0x0d, 0xcf, - 0x76, 0xb6, 0x4e, 0xb0, 0x01, 0x75, 0x74, 0x62, 0xbf, 0x09, 0x25, 0x71, 0xdc, 0xc0, 0xd7, 0x99, - 0xb1, 0xa0, 0x25, 0x08, 0x4d, 0xac, 0x50, 0xfc, 0xa8, 0x22, 0xd6, 0x59, 0xa5, 0xbd, 0x74, 0xd6, - 0xa7, 0x61, 0x34, 0x10, 0x3d, 0x6e, 0x7c, 0x07, 0x42, 0x6b, 0xcb, 0xf0, 0x11, 0xb8, 0xf7, 0xd5, - 0xa2, 0x84, 0x58, 0x9b, 0x0f, 0xa8, 0x56, 0xd0, 0x1a, 0x1a, 0x15, 0xb5, 0x05, 0xe5, 0x4c, 0x43, - 0x93, 0x89, 0xd4, 0xed, 0x22, 0x5c, 0x4a, 0xef, 0x76, 0x8d, 0xea, 0xc6, 0x69, 0xaf, 0x7f, 0x5f, - 0xf6, 0x3a, 0x79, 0x16, 0x8a, 0x2b, 0xba, 0xb7, 0x21, 0xae, 0xfb, 0xf1, 0x0e, 0x7a, 0xdd, 0x6c, - 0xd1, 0x7a, 0x47, 0xf7, 0x36, 0x34, 0x44, 0x49, 0x73, 0x06, 0x20, 0xc7, 0x94, 0x39, 0x43, 0x5a, - 0xec, 0x87, 0x9f, 0xc9, 0x5d, 0x2d, 0xa6, 0x2e, 0xf6, 0xdf, 0x29, 0x66, 0xcd, 0x2b, 0xf7, 0x1d, - 0xd3, 0xa3, 0xa7, 0x1a, 0x76, 0xaa, 0x61, 0x87, 0xd4, 0xb0, 0x7f, 0x98, 0x87, 0xd1, 0x60, 0xd3, - 0xf4, 0x3e, 0x6d, 0x1c, 0xcf, 0x5a, 0x15, 0x6e, 0x65, 0x0a, 0x87, 0xde, 0xca, 0x1c, 0x46, 0xa1, - 0xd4, 0xe0, 0x88, 0x95, 0x9b, 0x06, 0x28, 0x31, 0x7e, 0xc4, 0x1a, 0x1c, 0xac, 0x3e, 0x0b, 0x03, - 0x8b, 0xfa, 0x23, 0xb3, 0xdd, 0x6d, 0x0b, 0x2b, 0x1d, 0xdd, 0xd7, 0xda, 0xfa, 0x23, 0xcd, 0x87, - 0xab, 0xff, 0x5d, 0x0e, 0xc6, 0x84, 0x50, 0x05, 0xf3, 0x43, 0x49, 0x35, 0x94, 0x4e, 0xfe, 0xd0, - 0xd2, 0x29, 0x1c, 0x5c, 0x3a, 0xea, 0x5f, 0x2a, 0x80, 0x32, 0x67, 0xb6, 0xe8, 0xaa, 0xa3, 0x5b, - 0xee, 0x3a, 0x75, 0xc4, 0x76, 0x7a, 0x96, 0xb1, 0x3a, 0xd4, 0x07, 0x4a, 0x53, 0x4a, 0xfe, 0x40, - 0x53, 0xca, 0x27, 0x61, 0x48, 0x34, 0x26, 0x70, 0x9d, 0xc4, 0x51, 0xe3, 0xf8, 0x40, 0x2d, 0xc4, - 0x33, 0xe2, 0x72, 0xa7, 0xe3, 0xd8, 0x0f, 0xa9, 0xc3, 0x6f, 0xc5, 0x04, 0xb1, 0xee, 0x03, 0xb5, - 0x10, 0x2f, 0x71, 0xa6, 0xbe, 0xbd, 0x28, 0x73, 0xa6, 0x8e, 0x16, 0xe2, 0xc9, 0x55, 0x18, 0x5c, - 0xb0, 0x1b, 0x3a, 0x0a, 0x9a, 0x4f, 0x2b, 0x23, 0x3b, 0xdb, 0x93, 0x83, 0x2d, 0x01, 0xd3, 0x02, - 0x2c, 0xa3, 0xac, 0xd8, 0x9b, 0x56, 0xcb, 0xd6, 0xb9, 0xb3, 0xcd, 0x20, 0xa7, 0x34, 0x04, 0x4c, - 0x0b, 0xb0, 0x8c, 0x92, 0xc9, 0x1c, 0x9d, 0x98, 0x06, 0x43, 0x9e, 0xeb, 0x02, 0xa6, 0x05, 0x58, - 0xf5, 0x1b, 0x45, 0xa6, 0xbd, 0xae, 0xf9, 0xc1, 0x63, 0xbf, 0x2e, 0x84, 0x03, 0xa6, 0xff, 0x00, - 0x03, 0xe6, 0xb1, 0x39, 0xb0, 0x53, 0xff, 0xf9, 0x00, 0x80, 0x90, 0xfe, 0xec, 0xe9, 0xe6, 0xf0, - 0x70, 0x5a, 0x53, 0x81, 0x89, 0x59, 0x6b, 0x43, 0xb7, 0x1a, 0xd4, 0x08, 0x8f, 0x2d, 0x4b, 0x38, - 0xb4, 0xd1, 0xe9, 0x92, 0x0a, 0x64, 0x78, 0x6e, 0xa9, 0x25, 0x0b, 0x90, 0x97, 0x60, 0xb8, 0x6a, - 0x79, 0xd4, 0xd1, 0x1b, 0x9e, 0xf9, 0x90, 0x8a, 0xa9, 0x01, 0x6f, 0xa2, 0xcd, 0x10, 0xac, 0xc9, - 0x34, 0xe4, 0x26, 0x8c, 0xac, 0xe8, 0x8e, 0x67, 0x36, 0xcc, 0x8e, 0x6e, 0x79, 0xae, 0x32, 0x88, - 0x33, 0x1a, 0x5a, 0x18, 0x1d, 0x09, 0xae, 0x45, 0xa8, 0xc8, 0x17, 0x60, 0x08, 0xb7, 0xa6, 0xe8, - 0x1f, 0x3e, 0xb4, 0xeb, 0x45, 0xe5, 0x73, 0xa1, 0x3b, 0x22, 0x3f, 0x7d, 0xc5, 0x1b, 0xe7, 0xf8, - 0x5d, 0x65, 0xc0, 0x91, 0x7c, 0x0e, 0x06, 0x66, 0x2d, 0x03, 0x99, 0xc3, 0xae, 0xcc, 0x55, 0xc1, - 0xfc, 0x42, 0xc8, 0xdc, 0xee, 0xc4, 0x78, 0xfb, 0xec, 0xd2, 0x47, 0xd9, 0xf0, 0x87, 0x37, 0xca, - 0x46, 0x3e, 0x84, 0x63, 0xf1, 0xd1, 0xa3, 0x3a, 0x16, 0x1f, 0x3b, 0xe0, 0xb1, 0xb8, 0xfa, 0x01, - 0x0c, 0x4f, 0xaf, 0xcc, 0x05, 0xa3, 0xf7, 0x09, 0x28, 0xac, 0x08, 0xcf, 0x88, 0x22, 0xb7, 0x67, - 0x3a, 0xa6, 0xa1, 0x31, 0x18, 0xb9, 0x06, 0x83, 0x33, 0xe8, 0x6e, 0x27, 0x6e, 0x11, 0x8b, 0x7c, - 0xfd, 0x6b, 0x20, 0x0c, 0xbd, 0x6e, 0x7d, 0x34, 0xf9, 0x38, 0x0c, 0xac, 0x38, 0x76, 0xd3, 0xd1, - 0xdb, 0x62, 0x0d, 0x46, 0xd7, 0x94, 0x0e, 0x07, 0x69, 0x3e, 0x4e, 0xfd, 0x99, 0x9c, 0x6f, 0xb6, - 0xb3, 0x12, 0xb5, 0x2e, 0x1e, 0xcd, 0x63, 0xdd, 0x83, 0xbc, 0x84, 0xcb, 0x41, 0x9a, 0x8f, 0x23, - 0xd7, 0xa0, 0x7f, 0xd6, 0x71, 0x6c, 0x47, 0xf6, 0xa9, 0xa7, 0x0c, 0x20, 0x5f, 0xf7, 0x22, 0x05, - 0x79, 0x0d, 0x86, 0xf9, 0x9c, 0xc3, 0x4f, 0x34, 0x0b, 0xbd, 0x6e, 0x4a, 0x65, 0x4a, 0xf5, 0x77, - 0x0b, 0x92, 0xcd, 0xc6, 0x25, 0xfe, 0x18, 0xde, 0x0a, 0xbc, 0x0c, 0x85, 0xe9, 0x95, 0x39, 0x31, - 0x01, 0x9e, 0xf5, 0x8b, 0x4a, 0xaa, 0x12, 0x2b, 0xc7, 0xa8, 0xc9, 0x65, 0x28, 0xae, 0x30, 0xf5, - 0x29, 0xa1, 0x7a, 0x0c, 0xee, 0x6c, 0x4f, 0x16, 0x3b, 0x4c, 0x7f, 0x10, 0x8a, 0x58, 0xb6, 0x99, - 0xe1, 0x3b, 0x26, 0x8e, 0x0d, 0xf7, 0x31, 0x97, 0xa1, 0x58, 0x76, 0x9a, 0x0f, 0xc5, 0xac, 0x85, - 0x58, 0xdd, 0x69, 0x3e, 0xd4, 0x10, 0x4a, 0xae, 0x03, 0x68, 0xd4, 0xeb, 0x3a, 0x16, 0x3e, 0x77, - 0x19, 0xc2, 0xf3, 0x37, 0x9c, 0x0d, 0x1d, 0x84, 0xd6, 0x1b, 0xb6, 0x41, 0x35, 0x89, 0x44, 0xfd, - 0xeb, 0xe1, 0xc5, 0x4e, 0xc5, 0x74, 0x1f, 0x9c, 0x76, 0xe1, 0x3e, 0xba, 0x50, 0x17, 0x47, 0x9c, - 0xc9, 0x4e, 0x9a, 0x84, 0xfe, 0xb9, 0x96, 0xde, 0x74, 0xb1, 0x0f, 0x85, 0xef, 0xda, 0x3a, 0x03, - 0x68, 0x1c, 0x1e, 0xeb, 0xa7, 0xc1, 0xdd, 0xfb, 0xe9, 0xe7, 0xfa, 0x83, 0xd1, 0xb6, 0x44, 0xbd, - 0x4d, 0xdb, 0x39, 0xed, 0xaa, 0xbd, 0x76, 0xd5, 0x15, 0x18, 0xa8, 0x39, 0x0d, 0xe9, 0xe8, 0x02, - 0xf7, 0x03, 0xae, 0xd3, 0xe0, 0xc7, 0x16, 0x3e, 0x92, 0xd1, 0x55, 0x5c, 0x0f, 0xe9, 0x06, 0x42, - 0x3a, 0xc3, 0xf5, 0x04, 0x9d, 0x40, 0x0a, 0xba, 0x15, 0xdb, 0xf1, 0x44, 0xc7, 0x05, 0x74, 0x1d, - 0xdb, 0xf1, 0x34, 0x1f, 0x49, 0x3e, 0x09, 0xb0, 0x3a, 0xb3, 0xe2, 0x3b, 0xf7, 0x0f, 0x85, 0xbe, - 0x87, 0xc2, 0xab, 0x5f, 0x93, 0xd0, 0x64, 0x15, 0x86, 0x96, 0x3b, 0xd4, 0xe1, 0x5b, 0x21, 0xfe, - 0x80, 0xe5, 0x13, 0x31, 0xd1, 0x8a, 0x7e, 0x9f, 0x12, 0xff, 0x07, 0xe4, 0x7c, 0x7d, 0xb1, 0xfd, - 0x9f, 0x5a, 0xc8, 0x88, 0xbc, 0x06, 0xa5, 0x32, 0xb7, 0xf3, 0x86, 0x91, 0x65, 0x20, 0x32, 0xdc, - 0x82, 0x72, 0x14, 0xdf, 0xb3, 0xeb, 0xf8, 0xb7, 0x26, 0xc8, 0xd5, 0x6b, 0x30, 0x1e, 0xaf, 0x86, - 0x0c, 0xc3, 0xc0, 0xcc, 0xf2, 0xd2, 0xd2, 0xec, 0xcc, 0xea, 0x78, 0x1f, 0x19, 0x84, 0x62, 0x6d, - 0x76, 0xa9, 0x32, 0x9e, 0x53, 0x7f, 0x59, 0x9a, 0x41, 0x98, 0x6a, 0x9d, 0x5e, 0x0d, 0x1f, 0xea, - 0xbe, 0x65, 0x1c, 0xef, 0x43, 0xf1, 0xc4, 0xa0, 0x6d, 0x7a, 0x1e, 0x35, 0xc4, 0x2a, 0x81, 0xf7, - 0x85, 0xde, 0x23, 0x2d, 0x81, 0x27, 0x2f, 0xc0, 0x28, 0xc2, 0xc4, 0x15, 0x21, 0xdf, 0x1f, 0x8b, - 0x02, 0xce, 0x23, 0x2d, 0x8a, 0x54, 0x7f, 0x3f, 0xbc, 0x1d, 0x5e, 0xa0, 0xfa, 0x49, 0xbd, 0x51, - 0xfc, 0x88, 0xf4, 0x97, 0xfa, 0x2f, 0x8b, 0xfc, 0xc9, 0x09, 0x7f, 0x9f, 0x78, 0x1c, 0xa2, 0x0c, - 0x8f, 0x74, 0x0b, 0xfb, 0x38, 0xd2, 0x7d, 0x01, 0x4a, 0x8b, 0xd4, 0xdb, 0xb0, 0x7d, 0xc7, 0x2f, - 0xf4, 0xd0, 0x6b, 0x23, 0x44, 0xf6, 0xd0, 0xe3, 0x34, 0xe4, 0x01, 0x10, 0xff, 0xf1, 0x61, 0xe0, - 0xf8, 0xed, 0x1f, 0x21, 0x5f, 0x4c, 0xec, 0x53, 0x6a, 0xf8, 0x44, 0x19, 0x7d, 0xfa, 0xcf, 0x05, - 0x8e, 0xe5, 0x92, 0x27, 0xd6, 0xbf, 0xd8, 0x9e, 0x2c, 0x71, 0x1a, 0x2d, 0x85, 0x2d, 0x79, 0x17, - 0x86, 0x16, 0xe7, 0xca, 0xe2, 0x21, 0x22, 0xf7, 0x8a, 0x78, 0x22, 0x90, 0xa2, 0x8f, 0x08, 0x44, - 0x82, 0xef, 0x7b, 0xda, 0xeb, 0x7a, 0xf2, 0x1d, 0x62, 0xc8, 0x85, 0x69, 0x0b, 0x7f, 0x29, 0x24, - 0x4e, 0x17, 0x02, 0x6d, 0x89, 0xbe, 0x1f, 0x8a, 0xcb, 0x8a, 0x63, 0x63, 0xda, 0x32, 0x78, 0x88, - 0xd1, 0xbd, 0x0c, 0x13, 0xe5, 0x4e, 0xa7, 0x65, 0x52, 0x03, 0xf5, 0x45, 0xeb, 0xb6, 0xa8, 0x2b, - 0x5c, 0x7e, 0xf0, 0xf1, 0x89, 0xce, 0x91, 0x75, 0x7c, 0xfe, 0x5a, 0x77, 0xba, 0x51, 0xff, 0xcc, - 0x64, 0x59, 0xf5, 0xcf, 0xe5, 0xe1, 0xc2, 0x8c, 0x43, 0x75, 0x8f, 0x2e, 0xce, 0x95, 0xcb, 0x5d, - 0xf4, 0x91, 0x6b, 0xb5, 0xa8, 0xd5, 0x3c, 0x9e, 0x61, 0xfd, 0x26, 0x8c, 0x05, 0x0d, 0xa8, 0x35, - 0xec, 0x0e, 0x95, 0x1f, 0x72, 0x35, 0x7c, 0x4c, 0xdd, 0x65, 0x28, 0x2d, 0x46, 0x4a, 0xee, 0xc0, - 0xd9, 0x00, 0x52, 0x6e, 0xb5, 0xec, 0x4d, 0x8d, 0x76, 0x5d, 0xee, 0x88, 0x3b, 0xc8, 0x1d, 0x71, - 0x43, 0x0e, 0x3a, 0xc3, 0xd7, 0x1d, 0x46, 0xa0, 0xa5, 0x95, 0x52, 0xbf, 0x5e, 0x80, 0x8b, 0xf7, - 0xf4, 0x96, 0x69, 0x84, 0xa2, 0xd1, 0xa8, 0xdb, 0xb1, 0x2d, 0x97, 0x9e, 0xa0, 0x51, 0x1a, 0x19, - 0x0a, 0xc5, 0x23, 0x19, 0x0a, 0xc9, 0x2e, 0xea, 0x3f, 0x74, 0x17, 0x95, 0x0e, 0xd4, 0x45, 0xff, - 0x5b, 0x0e, 0xc6, 0xfd, 0x87, 0x06, 0xf2, 0xa3, 0x71, 0xc9, 0x0b, 0x1e, 0x8f, 0x10, 0x63, 0x7e, - 0xd7, 0x88, 0x27, 0x35, 0x18, 0x98, 0x7d, 0xd4, 0x31, 0x1d, 0xea, 0xee, 0xc1, 0x69, 0xfc, 0x29, - 0x71, 0x5c, 0x32, 0x41, 0x79, 0x91, 0xc4, 0x49, 0x09, 0x07, 0xe3, 0xf3, 0x41, 0xfe, 0xd4, 0x62, - 0xda, 0x7f, 0x09, 0xcf, 0x9f, 0x0f, 0x8a, 0x27, 0x19, 0x91, 0xf7, 0xa0, 0x21, 0x29, 0x79, 0x0e, - 0x0a, 0xab, 0xab, 0x0b, 0x62, 0x26, 0xc5, 0x08, 0x04, 0x9e, 0x27, 0xbf, 0x8f, 0x64, 0x58, 0xf5, - 0x9f, 0xe4, 0x01, 0x98, 0x2a, 0xf0, 0xe1, 0x7a, 0x2c, 0x4a, 0x38, 0x0d, 0x83, 0xbe, 0xc0, 0x85, - 0x1a, 0x06, 0xaf, 0x04, 0xe2, 0x1d, 0x11, 0xaf, 0x3b, 0x78, 0x11, 0x32, 0xe9, 0x3b, 0x92, 0xf3, - 0x7b, 0x00, 0xdc, 0xd9, 0xa0, 0x23, 0xb9, 0xef, 0x3e, 0xfe, 0x49, 0x18, 0x12, 0x33, 0x9e, 0x1d, - 0x39, 0xff, 0x6f, 0xf8, 0x40, 0x2d, 0xc4, 0xc7, 0xa6, 0xd6, 0xd2, 0x21, 0x16, 0x62, 0x5f, 0xbc, - 0xbc, 0x57, 0x4e, 0xc5, 0x7b, 0xc4, 0xe2, 0xfd, 0x8a, 0x10, 0x2f, 0x7f, 0x31, 0x74, 0x62, 0xc5, - 0x7b, 0x64, 0x67, 0xdf, 0xea, 0x3f, 0xcc, 0x01, 0x61, 0xcd, 0x5a, 0xd1, 0x5d, 0x77, 0xd3, 0x76, - 0x0c, 0xee, 0x9c, 0x7e, 0x2c, 0x82, 0x39, 0xba, 0xfb, 0xca, 0xdf, 0x1d, 0x84, 0xb3, 0x11, 0xc7, - 0xdf, 0x13, 0x3e, 0x59, 0x5d, 0x8b, 0x8e, 0xa6, 0x5e, 0xaf, 0x5e, 0x3e, 0x26, 0x5f, 0x88, 0xf6, - 0x47, 0x1e, 0xbc, 0x49, 0x37, 0xa1, 0x2f, 0xc2, 0x88, 0xf8, 0xc1, 0x56, 0x68, 0xff, 0xa6, 0x0b, - 0x47, 0xa9, 0xcb, 0x00, 0x5a, 0x04, 0x4d, 0x5e, 0x81, 0x21, 0x36, 0x60, 0x9a, 0x18, 0xac, 0x64, - 0x20, 0x7c, 0x51, 0x62, 0xf8, 0x40, 0x79, 0x3d, 0x09, 0x28, 0xa5, 0x77, 0x4b, 0x83, 0x7b, 0x78, - 0xb7, 0xf4, 0x45, 0x18, 0x2e, 0x5b, 0x96, 0xed, 0xe1, 0x26, 0xdd, 0x15, 0x57, 0x13, 0x99, 0x56, - 0xf9, 0x73, 0xf8, 0x18, 0x3f, 0xa4, 0x4f, 0x35, 0xcb, 0x65, 0x86, 0xe4, 0x86, 0xff, 0x2a, 0x86, - 0x3a, 0xc2, 0xab, 0x1c, 0xaf, 0x67, 0x1c, 0x01, 0x4b, 0x3e, 0x8a, 0xc1, 0xce, 0x1b, 0x5d, 0x71, - 0xec, 0x8e, 0xed, 0x52, 0x83, 0x0b, 0x6a, 0x38, 0x0c, 0x6d, 0xd0, 0x11, 0x08, 0x7c, 0x37, 0x17, - 0x09, 0x1c, 0x12, 0x29, 0x42, 0xd6, 0xe1, 0x9c, 0x7f, 0x51, 0x1c, 0xbc, 0x50, 0xac, 0x56, 0x5c, - 0x65, 0x04, 0x5f, 0x25, 0x91, 0xb8, 0x32, 0x54, 0x2b, 0xd3, 0x4f, 0xfb, 0xd7, 0x22, 0xfe, 0x13, - 0xc7, 0xba, 0x69, 0xc8, 0x5d, 0x9d, 0xca, 0x8f, 0xfc, 0x10, 0x0c, 0x2f, 0xea, 0x8f, 0x2a, 0x5d, - 0x71, 0xf6, 0x32, 0xba, 0xf7, 0xdb, 0x97, 0xb6, 0xfe, 0xa8, 0x6e, 0x88, 0x72, 0x31, 0x9b, 0x42, - 0x66, 0x49, 0xea, 0x70, 0x61, 0xc5, 0xb1, 0xdb, 0xb6, 0x47, 0x8d, 0xd8, 0x63, 0xbf, 0x33, 0xe1, - 0xeb, 0xe0, 0x8e, 0xa0, 0xa8, 0xf7, 0x78, 0xf5, 0x97, 0xc1, 0x86, 0xb4, 0xe1, 0x4c, 0xd9, 0x75, - 0xbb, 0x6d, 0x1a, 0xde, 0x50, 0x8d, 0xef, 0xfa, 0x19, 0x9f, 0x10, 0x5e, 0xcb, 0x4f, 0xea, 0x58, - 0x94, 0x5f, 0x50, 0xd5, 0x3d, 0x53, 0xae, 0x11, 0xbf, 0x25, 0xce, 0xfb, 0x76, 0x71, 0x70, 0x6c, - 0xfc, 0x8c, 0x76, 0x31, 0xd9, 0x98, 0x55, 0xd3, 0x6b, 0x51, 0xf5, 0x5b, 0x39, 0x80, 0x50, 0xc0, - 0xe4, 0xc5, 0x68, 0x44, 0xa4, 0x5c, 0x78, 0xd1, 0x21, 0xa2, 0x25, 0x44, 0x42, 0x20, 0x91, 0xcb, - 0x50, 0xc4, 0x88, 0x1a, 0xf9, 0xf0, 0x60, 0xf5, 0x81, 0x69, 0x19, 0x1a, 0x42, 0x19, 0x56, 0x7a, - 0xfa, 0x8e, 0x58, 0xbc, 0xd4, 0xe7, 0x56, 0x61, 0x05, 0xce, 0xd4, 0xba, 0x6b, 0x7e, 0xdd, 0xd2, - 0x3b, 0x3e, 0x0c, 0xec, 0xe1, 0x76, 0xd7, 0x82, 0xc7, 0xaf, 0x91, 0xb0, 0x29, 0xd1, 0x22, 0xea, - 0x37, 0x72, 0xb1, 0x59, 0xf0, 0x18, 0x17, 0xbd, 0x8f, 0x25, 0xfd, 0x34, 0x92, 0xd3, 0x92, 0xfa, - 0x97, 0xf3, 0x30, 0xbc, 0x62, 0x3b, 0x9e, 0x08, 0x51, 0x72, 0xb2, 0x57, 0x21, 0x69, 0xaf, 0x54, - 0xdc, 0xc7, 0x5e, 0xe9, 0x32, 0x14, 0x25, 0x17, 0x65, 0x7e, 0x2f, 0x62, 0x18, 0x8e, 0x86, 0x50, - 0xf5, 0x47, 0xf2, 0x00, 0x9f, 0x7b, 0xe9, 0xa5, 0xc7, 0x58, 0x40, 0xea, 0x5f, 0xcc, 0xc1, 0x19, - 0x71, 0x51, 0x27, 0xc5, 0x16, 0x1b, 0xf0, 0xaf, 0x58, 0xe5, 0x71, 0xc9, 0x41, 0x9a, 0x8f, 0x63, - 0x4b, 0xc0, 0xec, 0x23, 0xd3, 0xc3, 0xbb, 0x0a, 0x29, 0xb8, 0x18, 0x15, 0x30, 0x79, 0x09, 0xf0, - 0xe9, 0xc8, 0x8b, 0xfe, 0x15, 0x64, 0x21, 0x5c, 0xf7, 0x58, 0x81, 0xd9, 0xd4, 0x6b, 0x48, 0xf5, - 0xd7, 0x8b, 0x50, 0x9c, 0x7d, 0x44, 0x1b, 0x27, 0xbc, 0x6b, 0xa4, 0x83, 0xcd, 0xe2, 0x21, 0x0f, - 0x36, 0x0f, 0xe2, 0x53, 0xf1, 0x4e, 0xd8, 0x9f, 0xa5, 0x68, 0xf5, 0xb1, 0x9e, 0x8f, 0x57, 0xef, - 0xf7, 0xf4, 0xc9, 0x73, 0xc9, 0xf9, 0x2f, 0x0b, 0x50, 0xa8, 0xcd, 0xac, 0x9c, 0xea, 0xcd, 0xb1, - 0xea, 0x4d, 0xef, 0x3b, 0x6b, 0x35, 0xb8, 0x86, 0x1a, 0x0c, 0xbd, 0x44, 0x63, 0x37, 0x4e, 0xdf, - 0x2d, 0xc0, 0x58, 0x6d, 0x6e, 0x75, 0x45, 0x3a, 0x09, 0xbe, 0xc3, 0x3d, 0xf9, 0xd0, 0xa7, 0x8c, - 0x77, 0xe9, 0xe5, 0x84, 0x3d, 0x73, 0xb7, 0x6a, 0x79, 0xaf, 0xde, 0xbc, 0xa7, 0xb7, 0xba, 0x14, - 0x8f, 0x5e, 0xb8, 0xdf, 0xaf, 0x6b, 0x7e, 0x40, 0xbf, 0x8e, 0x81, 0x06, 0x7c, 0x06, 0xe4, 0x4d, - 0x28, 0xdc, 0x15, 0x1e, 0x19, 0x59, 0x7c, 0x5e, 0xbe, 0xc1, 0xf9, 0xb0, 0x49, 0xb0, 0xd0, 0x35, - 0x0d, 0xe4, 0xc0, 0x4a, 0xb1, 0xc2, 0xb7, 0xc4, 0x02, 0xbc, 0xa7, 0xc2, 0x4d, 0xbf, 0xf0, 0xad, - 0x6a, 0x85, 0xd4, 0x60, 0x78, 0x85, 0x3a, 0x6d, 0x13, 0x3b, 0xca, 0x9f, 0xb3, 0x7b, 0x33, 0x61, - 0x3b, 0x95, 0xe1, 0x4e, 0x58, 0x08, 0x99, 0xc9, 0x5c, 0xc8, 0x7b, 0x00, 0xdc, 0x46, 0xd9, 0x63, - 0xbc, 0xca, 0xa7, 0xd0, 0xee, 0xe7, 0xa6, 0x65, 0x8a, 0x8d, 0x27, 0x31, 0x23, 0x0f, 0x60, 0x7c, - 0xd1, 0x36, 0xcc, 0x75, 0x93, 0xbb, 0x5e, 0x62, 0x05, 0xa5, 0xdd, 0x1d, 0x9e, 0x98, 0x29, 0xd9, - 0x96, 0xca, 0xa5, 0x55, 0x93, 0x60, 0xac, 0xfe, 0xdd, 0x7e, 0x28, 0xb2, 0x6e, 0x3f, 0x1d, 0xbf, - 0x87, 0x19, 0xbf, 0x65, 0x18, 0xbf, 0x6f, 0x3b, 0x0f, 0x4c, 0xab, 0x19, 0x78, 0xc5, 0x8b, 0xbd, - 0x29, 0x7a, 0xf2, 0x6c, 0x72, 0x5c, 0x3d, 0x70, 0xa0, 0xd7, 0x12, 0xe4, 0xbb, 0x8c, 0xe0, 0xd7, - 0x01, 0xf8, 0x5b, 0x77, 0xa4, 0x19, 0x0c, 0x83, 0x63, 0xf0, 0x97, 0xf0, 0xe8, 0x68, 0x2f, 0x07, - 0xc7, 0x08, 0x89, 0xd9, 0x26, 0x9c, 0xfb, 0x42, 0x0c, 0xa1, 0xdf, 0x3d, 0x6e, 0xc2, 0xd1, 0x17, - 0x42, 0x36, 0x02, 0xb8, 0x57, 0xc4, 0x0a, 0x80, 0x74, 0xbf, 0x04, 0x31, 0x41, 0x44, 0x26, 0x07, - 0x11, 0x8e, 0x2e, 0xe5, 0x7a, 0x49, 0x93, 0x78, 0x90, 0x57, 0x63, 0x17, 0xe0, 0x24, 0xc2, 0x2d, - 0xf3, 0xfe, 0x3b, 0x74, 0xa0, 0x1a, 0xd9, 0xcd, 0x81, 0x4a, 0xfd, 0x9b, 0x05, 0x18, 0x66, 0xdc, - 0x6a, 0xdd, 0x76, 0x5b, 0x77, 0xb6, 0x4e, 0x15, 0xf9, 0x30, 0x8a, 0x5c, 0x87, 0x09, 0xd9, 0x61, - 0x9e, 0x99, 0xae, 0x7e, 0x68, 0xa3, 0xe0, 0xf8, 0x27, 0x4e, 0xc0, 0x6d, 0x4b, 0x9c, 0xf7, 0x3d, - 0x01, 0xc6, 0xb3, 0x05, 0x57, 0x4b, 0xf2, 0x52, 0x7f, 0x36, 0x07, 0xe3, 0x71, 0x68, 0xa0, 0xfb, - 0xb9, 0x54, 0xdd, 0x7f, 0x01, 0x86, 0xc4, 0x15, 0xba, 0x6e, 0x08, 0x8f, 0xbe, 0xb1, 0x9d, 0xed, - 0x49, 0xc0, 0xf7, 0xcb, 0x75, 0x87, 0xea, 0x86, 0x16, 0x12, 0x90, 0x57, 0x60, 0x04, 0x7f, 0xdc, - 0x77, 0x4c, 0xcf, 0xa3, 0xbc, 0x33, 0x8a, 0xfc, 0x56, 0x80, 0x17, 0xd8, 0xe4, 0x08, 0x2d, 0x42, - 0xa6, 0xfe, 0x5e, 0x1e, 0x86, 0x6a, 0xdd, 0x35, 0x77, 0xcb, 0xf5, 0x68, 0xfb, 0x84, 0xeb, 0x90, - 0xbf, 0x49, 0x2f, 0xa6, 0x6e, 0xd2, 0x9f, 0xf3, 0x87, 0x96, 0x74, 0x7a, 0x1d, 0x6c, 0x0c, 0x7c, - 0xaf, 0xc4, 0x50, 0x8b, 0x4a, 0xfb, 0xd7, 0x22, 0xf5, 0x6f, 0xe7, 0x61, 0x9c, 0x5f, 0xde, 0x56, - 0x4c, 0xb7, 0x71, 0x04, 0x0f, 0x4a, 0x8e, 0x5f, 0xa6, 0x87, 0x73, 0x78, 0xd8, 0xc3, 0x33, 0x1d, - 0xf5, 0x4b, 0x79, 0x18, 0x2e, 0x77, 0xbd, 0x8d, 0xb2, 0x87, 0xf3, 0xdb, 0x63, 0xb9, 0x47, 0xfe, - 0x07, 0x39, 0x38, 0xc3, 0x1a, 0xb2, 0x6a, 0x3f, 0xa0, 0xd6, 0x11, 0x1c, 0x7e, 0xcb, 0x87, 0xd8, - 0xf9, 0x03, 0x1e, 0x62, 0xfb, 0xb2, 0x2c, 0xec, 0x4f, 0x96, 0x78, 0x65, 0xa3, 0xd9, 0x2d, 0x7a, - 0xb2, 0x3f, 0xe3, 0x08, 0xaf, 0x6c, 0x7c, 0x81, 0x1c, 0xc1, 0x15, 0xe1, 0xf7, 0x97, 0x40, 0x8e, - 0xe0, 0x7c, 0xf3, 0xfb, 0x43, 0x20, 0xbf, 0x9b, 0x83, 0xa1, 0x69, 0xdb, 0x3b, 0xe1, 0x03, 0x5f, - 0x7c, 0xc5, 0xc9, 0x56, 0x73, 0xff, 0x2b, 0x4e, 0xb6, 0x6e, 0xaa, 0x3f, 0x9f, 0x87, 0x73, 0x22, - 0x1e, 0xbe, 0x38, 0x03, 0x3b, 0x9d, 0x8e, 0xc5, 0x60, 0x4b, 0x8a, 0xe6, 0x74, 0x1e, 0x12, 0xa2, - 0xf9, 0xc5, 0x02, 0x9c, 0xc3, 0xf0, 0xbd, 0x6c, 0x47, 0xf5, 0x7d, 0x60, 0x8b, 0x90, 0x46, 0xf4, - 0x22, 0x7e, 0x31, 0xe5, 0x22, 0xfe, 0x5f, 0x6c, 0x4f, 0xbe, 0xda, 0x34, 0xbd, 0x8d, 0xee, 0xda, - 0x54, 0xc3, 0x6e, 0x5f, 0x6f, 0x3a, 0xfa, 0x43, 0x93, 0x5f, 0x41, 0xeb, 0xad, 0xeb, 0x61, 0x9a, - 0x9a, 0x8e, 0x29, 0x92, 0xce, 0xd4, 0x70, 0xa7, 0xc4, 0xb8, 0xfa, 0x57, 0xf8, 0x2e, 0xc0, 0x6d, - 0xdb, 0xb4, 0x84, 0x5f, 0x2b, 0x37, 0x74, 0x6b, 0x3b, 0xdb, 0x93, 0xe7, 0xdf, 0xb7, 0x4d, 0xab, - 0x1e, 0x77, 0x6e, 0xdd, 0x6f, 0x7d, 0x21, 0x6b, 0x4d, 0xaa, 0x46, 0xfd, 0x6f, 0x73, 0xf0, 0x44, - 0x54, 0x8b, 0xbf, 0x1f, 0x6c, 0xc7, 0x3f, 0x9f, 0x87, 0xf3, 0xb7, 0x50, 0x38, 0x81, 0x33, 0xd1, - 0xe9, 0xbc, 0x25, 0x06, 0x67, 0x8a, 0x6c, 0x4e, 0x2d, 0xca, 0x6c, 0xd9, 0x9c, 0x4e, 0xea, 0x42, - 0x36, 0xff, 0x4d, 0x0e, 0xce, 0x2e, 0x57, 0x2b, 0x33, 0xdf, 0x27, 0x23, 0x2a, 0xf9, 0x3d, 0x27, - 0xdc, 0xe0, 0x4c, 0x7c, 0xcf, 0x09, 0x37, 0x3d, 0xbf, 0x96, 0x87, 0xb3, 0xb5, 0xf2, 0xe2, 0xc2, - 0xf7, 0xcb, 0x0c, 0x3e, 0x23, 0x7b, 0xbe, 0xfa, 0x87, 0x60, 0xc2, 0x16, 0x90, 0x3f, 0xf3, 0xde, - 0x8d, 0x6c, 0x8f, 0xd8, 0xa4, 0x50, 0x4e, 0xf8, 0xd4, 0x7d, 0x24, 0x42, 0x61, 0x9a, 0x1f, 0xa1, - 0x3e, 0xe1, 0x9a, 0xff, 0x5f, 0x94, 0x60, 0xf8, 0x4e, 0x77, 0x8d, 0x0a, 0x07, 0xa9, 0xc7, 0xfa, - 0xe4, 0xf7, 0x06, 0x0c, 0x0b, 0x31, 0xe0, 0x0d, 0x87, 0x14, 0xc0, 0x51, 0x04, 0xe4, 0xe1, 0x31, - 0xb2, 0x64, 0x22, 0x72, 0x19, 0x8a, 0xf7, 0xa8, 0xb3, 0x26, 0xbf, 0x6d, 0x7e, 0x48, 0x9d, 0x35, - 0x0d, 0xa1, 0x64, 0x21, 0x7c, 0xb6, 0x51, 0x5e, 0xa9, 0x62, 0xf2, 0x20, 0x71, 0x69, 0x88, 0xd9, - 0x90, 0x02, 0xdf, 0x4b, 0xbd, 0x63, 0xf2, 0xb4, 0x43, 0x72, 0x5c, 0x85, 0x78, 0x49, 0xb2, 0x04, - 0x13, 0xb2, 0xf3, 0x1d, 0xcf, 0x9c, 0x33, 0x98, 0xc2, 0x2e, 0x2d, 0x67, 0x4e, 0xb2, 0x28, 0x79, - 0x07, 0x46, 0x7c, 0x20, 0xba, 0x11, 0x0e, 0x85, 0xe9, 0x1a, 0x02, 0x56, 0xb1, 0xe8, 0xfa, 0x91, - 0x02, 0x32, 0x03, 0xbc, 0xc4, 0x80, 0x14, 0x06, 0x31, 0xb7, 0xcc, 0x48, 0x01, 0xf2, 0x0a, 0x32, - 0xc0, 0xa7, 0x46, 0xe8, 0x30, 0x35, 0x8c, 0x0f, 0x7f, 0xf1, 0x02, 0xc8, 0x11, 0x70, 0xfe, 0xbc, - 0x3b, 0x42, 0x46, 0x96, 0x01, 0x42, 0xc7, 0x16, 0x11, 0x44, 0x63, 0xdf, 0x2e, 0x37, 0x12, 0x0b, - 0xf9, 0x26, 0x6f, 0xf4, 0x20, 0x37, 0x79, 0xea, 0x1f, 0xe5, 0x61, 0xb8, 0xdc, 0xe9, 0x04, 0x43, - 0xe1, 0x45, 0x28, 0x95, 0x3b, 0x9d, 0xbb, 0x5a, 0x55, 0x0e, 0xa7, 0xaf, 0x77, 0x3a, 0xf5, 0xae, - 0x63, 0xca, 0x7e, 0xc9, 0x9c, 0x88, 0xcc, 0xc0, 0x68, 0xb9, 0xd3, 0x59, 0xe9, 0xae, 0xb5, 0xcc, - 0x86, 0x94, 0x0d, 0x8c, 0xe7, 0x4b, 0xec, 0x74, 0xea, 0x1d, 0xc4, 0xc4, 0x53, 0xc2, 0x45, 0xcb, - 0x90, 0x2f, 0x62, 0xe8, 0x29, 0x91, 0x8c, 0x8a, 0xa7, 0xbb, 0x51, 0x83, 0x40, 0xfa, 0x61, 0xdb, - 0xa6, 0x02, 0x22, 0x9e, 0x70, 0xe0, 0xb2, 0x9f, 0x26, 0x82, 0x55, 0x94, 0x48, 0x3a, 0x15, 0xb2, - 0x24, 0x9f, 0x82, 0x81, 0x72, 0xa7, 0x23, 0xdd, 0x56, 0xa1, 0x63, 0x1b, 0x2b, 0x15, 0xcf, 0xf7, - 0x27, 0xc8, 0x2e, 0xbd, 0x05, 0x63, 0xd1, 0xca, 0xf6, 0x95, 0xb0, 0xe0, 0x7b, 0x39, 0xfc, 0xa0, - 0x13, 0xee, 0x57, 0xff, 0x32, 0x14, 0xca, 0x9d, 0x8e, 0x98, 0x8f, 0xce, 0xa6, 0xf4, 0x47, 0xfc, - 0x19, 0x7e, 0xb9, 0xd3, 0xf1, 0x3f, 0xfd, 0x84, 0x3f, 0xd0, 0x39, 0xd0, 0xa7, 0xff, 0x2e, 0xff, - 0xf4, 0x93, 0xfd, 0x78, 0x46, 0xfd, 0xf5, 0x02, 0x9c, 0x29, 0x77, 0x3a, 0xa7, 0x89, 0x0e, 0x8e, - 0xea, 0xb1, 0xff, 0x4b, 0x00, 0xd2, 0xf4, 0x38, 0x10, 0x3c, 0x1f, 0x1c, 0x96, 0xa6, 0x46, 0x25, - 0xa7, 0x49, 0x44, 0xbe, 0xfa, 0x0d, 0xee, 0x4b, 0xfd, 0xbe, 0x54, 0xc0, 0xa9, 0xf8, 0xa4, 0x07, - 0x2e, 0xfb, 0xa8, 0x74, 0x9b, 0xe8, 0x83, 0xd2, 0xbe, 0xfa, 0xe0, 0xef, 0x47, 0x06, 0x0f, 0x06, - 0xce, 0x3f, 0xed, 0x85, 0xfe, 0x43, 0x99, 0xc5, 0x63, 0xb2, 0x30, 0x45, 0x34, 0x25, 0x3f, 0x79, - 0x98, 0x88, 0xed, 0xd5, 0x60, 0xa8, 0xba, 0x69, 0x68, 0x31, 0x5a, 0xbf, 0x0f, 0x07, 0xf6, 0xd5, - 0x87, 0xdb, 0x79, 0x7c, 0xbf, 0x1f, 0xc4, 0x06, 0x3b, 0xfc, 0xee, 0xe2, 0x3a, 0x00, 0xf7, 0x3c, - 0x08, 0x5c, 0xeb, 0x47, 0x79, 0x18, 0x20, 0x9e, 0x53, 0x4c, 0x84, 0x01, 0x0a, 0x49, 0x02, 0x4f, - 0xa5, 0x42, 0xaa, 0xa7, 0xd2, 0x35, 0x18, 0xd4, 0xf4, 0xcd, 0x77, 0xbb, 0xd4, 0xd9, 0x12, 0xe6, - 0x0c, 0x0f, 0xbd, 0xa9, 0x6f, 0xd6, 0x7f, 0x98, 0x01, 0xb5, 0x00, 0x4d, 0xd4, 0x20, 0x00, 0x84, - 0xe4, 0x11, 0xc2, 0xcf, 0xc8, 0x83, 0xb0, 0x0f, 0x07, 0x51, 0x74, 0xf2, 0x06, 0x14, 0xca, 0xf7, - 0x6b, 0x42, 0xb2, 0x41, 0xd7, 0x96, 0xef, 0xd7, 0x84, 0xbc, 0x32, 0xcb, 0xde, 0xaf, 0xa9, 0x5f, - 0xca, 0x03, 0x49, 0x52, 0x92, 0x57, 0x61, 0x08, 0xa1, 0x4d, 0xa6, 0x33, 0x72, 0x32, 0xda, 0x4d, - 0xb7, 0xee, 0x20, 0x34, 0x62, 0xdc, 0xf9, 0xa4, 0xe4, 0x75, 0x4c, 0xf7, 0x2d, 0xd2, 0x21, 0x46, - 0x92, 0xd1, 0x6e, 0xba, 0x7e, 0x82, 0xec, 0x58, 0xb6, 0x6f, 0x41, 0x8c, 0x76, 0xe1, 0xfd, 0xda, - 0xbc, 0xed, 0x7a, 0x42, 0xd4, 0xdc, 0x2e, 0xdc, 0x74, 0x31, 0x0b, 0x72, 0xc4, 0x2e, 0xe4, 0x64, - 0x98, 0xc9, 0xed, 0x7e, 0x8d, 0x3f, 0x95, 0x32, 0x34, 0xbb, 0xe5, 0x1b, 0x94, 0x3c, 0x93, 0xdb, - 0xa6, 0x5b, 0xe7, 0xcf, 0xac, 0x0c, 0xcc, 0x33, 0x1e, 0xc9, 0xe4, 0x16, 0x29, 0xa5, 0xfe, 0xf4, - 0x20, 0x8c, 0x57, 0x74, 0x4f, 0x5f, 0xd3, 0x5d, 0x2a, 0xed, 0xa6, 0xcf, 0xf8, 0x30, 0xff, 0x73, - 0x24, 0x39, 0x18, 0x6b, 0x29, 0x5f, 0x13, 0x2f, 0x40, 0xde, 0x0c, 0xf9, 0x06, 0x79, 0x76, 0xe5, - 0xc4, 0x7d, 0x6b, 0xf5, 0x8e, 0x00, 0x6b, 0x09, 0x42, 0xf2, 0x02, 0x0c, 0xfb, 0x30, 0xb6, 0x01, - 0x28, 0x84, 0x3a, 0x63, 0xac, 0x31, 0xfb, 0x5f, 0x93, 0xd1, 0xe4, 0x75, 0x18, 0xf1, 0x7f, 0x4a, - 0xa6, 0x35, 0xcf, 0x42, 0xb8, 0x96, 0xd8, 0x3d, 0xc9, 0xa4, 0x72, 0x51, 0x9c, 0xdf, 0xfa, 0x23, - 0x45, 0x63, 0x89, 0xfe, 0x22, 0xa4, 0xe4, 0x87, 0x61, 0xcc, 0xff, 0x2d, 0x36, 0x0c, 0xdc, 0x71, - 0xf0, 0x85, 0x20, 0x8d, 0x79, 0x4c, 0xac, 0x53, 0x51, 0x72, 0xbe, 0x75, 0x78, 0xd2, 0xcf, 0x5d, - 0x67, 0xac, 0x25, 0x77, 0x0e, 0xb1, 0x0a, 0x48, 0x15, 0x26, 0x7c, 0x48, 0xa8, 0xa1, 0x03, 0xe1, - 0x8e, 0xd1, 0x58, 0xab, 0xa7, 0x2a, 0x69, 0xb2, 0x14, 0x69, 0xc1, 0xe5, 0x08, 0xd0, 0x70, 0x37, - 0xcc, 0x75, 0x4f, 0x6c, 0xf7, 0x44, 0x1c, 0x6c, 0x91, 0xac, 0x34, 0xe0, 0xca, 0x69, 0xfc, 0xac, - 0xc3, 0xd1, 0x0c, 0x65, 0x3d, 0xb9, 0x91, 0x1a, 0x9c, 0xf3, 0xf1, 0xb7, 0x66, 0x56, 0x56, 0x1c, - 0xfb, 0x7d, 0xda, 0xf0, 0xaa, 0x15, 0xb1, 0x5d, 0xc6, 0xf8, 0x88, 0xc6, 0x5a, 0xbd, 0xd9, 0xe8, - 0x30, 0xa5, 0x60, 0xb8, 0x28, 0xf3, 0xd4, 0xc2, 0xe4, 0x1e, 0x9c, 0x97, 0xe0, 0x52, 0x4a, 0x74, - 0x08, 0xf7, 0xf3, 0x82, 0x6b, 0x7a, 0x56, 0xf4, 0xf4, 0xe2, 0xe4, 0x2d, 0x18, 0xf5, 0x11, 0xfc, - 0x16, 0x71, 0x18, 0x6f, 0x11, 0x71, 0x48, 0x1a, 0x6b, 0xf5, 0xf8, 0x8b, 0xde, 0x28, 0xb1, 0xac, - 0x51, 0xab, 0x5b, 0x1d, 0x2a, 0x3c, 0x7a, 0x7d, 0x8d, 0xf2, 0xb6, 0x3a, 0xa9, 0xca, 0xc8, 0x48, - 0xc9, 0x3b, 0xa1, 0x46, 0x2d, 0x3b, 0x66, 0xd3, 0xe4, 0x3b, 0x69, 0xff, 0x11, 0xef, 0x5a, 0xdd, - 0x46, 0x60, 0x9a, 0x7e, 0x70, 0xf2, 0x4b, 0x65, 0x38, 0x9b, 0xa2, 0x63, 0xfb, 0xda, 0x31, 0x7e, - 0x39, 0x1f, 0x36, 0xe2, 0x84, 0x6f, 0x1b, 0xa7, 0x61, 0xd0, 0xff, 0x12, 0x61, 0x3c, 0x28, 0x59, - 0x43, 0x33, 0xce, 0xc3, 0xc7, 0x47, 0xc4, 0x71, 0xc2, 0xb7, 0x92, 0x47, 0x21, 0x8e, 0x6f, 0xe7, - 0x42, 0x71, 0x9c, 0xf0, 0xed, 0xe5, 0x4f, 0x15, 0xc3, 0x39, 0xe9, 0x74, 0x8f, 0x79, 0x54, 0x66, - 0x72, 0xe8, 0x07, 0x5b, 0xda, 0xc7, 0x63, 0x5a, 0x59, 0x35, 0x07, 0x0e, 0xa6, 0x9a, 0xe4, 0x2d, - 0x18, 0x5e, 0xb1, 0x5d, 0xaf, 0xe9, 0x50, 0x77, 0x25, 0xc8, 0xe3, 0x80, 0x0f, 0xb1, 0x3b, 0x02, - 0x5c, 0xef, 0x44, 0x66, 0x7f, 0x99, 0x5c, 0xfd, 0x47, 0x85, 0x84, 0x36, 0x70, 0xc3, 0xf5, 0x44, - 0x6a, 0xc3, 0x11, 0x0c, 0x75, 0x72, 0x23, 0x5c, 0x05, 0xb9, 0x85, 0xdf, 0x2f, 0x05, 0xa9, 0x5c, - 0x13, 0x06, 0x7e, 0x94, 0x84, 0xfc, 0x00, 0x5c, 0x8c, 0x00, 0x56, 0x74, 0x47, 0x6f, 0x53, 0x2f, - 0xcc, 0x99, 0x89, 0x61, 0xc7, 0xfc, 0xd2, 0xf5, 0x4e, 0x80, 0x96, 0xf3, 0x70, 0x66, 0x70, 0x90, - 0x54, 0x6b, 0x60, 0x1f, 0x2e, 0xd6, 0x3f, 0x57, 0x08, 0x0d, 0x9d, 0x68, 0xf8, 0x60, 0x8d, 0xba, - 0xdd, 0x96, 0xf7, 0xf8, 0x76, 0xf0, 0xc1, 0x92, 0xb3, 0xcc, 0xc3, 0x99, 0xf2, 0xfa, 0x3a, 0x6d, - 0x78, 0x7e, 0x54, 0x74, 0x57, 0x04, 0x8c, 0xe4, 0x1b, 0x0f, 0x81, 0x12, 0x51, 0xae, 0xe5, 0x7e, - 0x8d, 0x17, 0x53, 0xff, 0x71, 0x11, 0x94, 0xc0, 0xf0, 0x0f, 0x9e, 0x1a, 0x1e, 0xe3, 0x22, 0xfb, - 0x91, 0xe8, 0x15, 0x13, 0x26, 0x42, 0x61, 0x88, 0x37, 0x5e, 0x22, 0x8b, 0xfb, 0x64, 0x9c, 0x59, - 0x48, 0xc8, 0xf7, 0x12, 0x97, 0xc4, 0x5e, 0x82, 0x84, 0x4f, 0x39, 0xeb, 0x2e, 0x67, 0xa1, 0x25, - 0xb9, 0x92, 0xaf, 0xe4, 0xe0, 0x9c, 0xdf, 0x29, 0xcb, 0x6b, 0xcc, 0xa8, 0x9e, 0xb1, 0xbb, 0x56, - 0xf0, 0x00, 0xea, 0x8d, 0xec, 0xea, 0x78, 0x27, 0x4d, 0xa5, 0x15, 0xe6, 0x2d, 0x09, 0x42, 0xa3, - 0x04, 0x0a, 0x61, 0x23, 0x4d, 0xbd, 0x81, 0x44, 0x5a, 0x6a, 0xbd, 0x97, 0x6e, 0xc1, 0x13, 0x99, - 0x2c, 0x77, 0x33, 0x62, 0xfb, 0x65, 0x23, 0xf6, 0xbf, 0xcf, 0x85, 0x13, 0x51, 0x4c, 0x48, 0x64, - 0x0a, 0x20, 0x04, 0x89, 0x6d, 0x2d, 0xbe, 0xaf, 0x0a, 0x85, 0xa6, 0x49, 0x14, 0x64, 0x19, 0x4a, - 0x42, 0x2c, 0x3c, 0x3f, 0xf5, 0x27, 0x77, 0xe9, 0x85, 0x29, 0x59, 0x0e, 0xb8, 0x65, 0x15, 0xdf, - 0x2c, 0xd8, 0x5c, 0x7a, 0x1d, 0x86, 0x0f, 0xfa, 0x5d, 0x5f, 0x29, 0x00, 0x91, 0xf7, 0xa0, 0xc7, - 0x68, 0xa0, 0x9f, 0xe0, 0x29, 0xec, 0x2a, 0x0c, 0xb2, 0x4f, 0xc0, 0x8c, 0x2d, 0x52, 0x84, 0xe6, - 0xae, 0x80, 0x69, 0x01, 0x36, 0x0c, 0x8f, 0x36, 0x90, 0x1e, 0x1e, 0x4d, 0xfd, 0xd9, 0x02, 0x5c, - 0x90, 0x3b, 0xa4, 0x42, 0x31, 0xe9, 0xc3, 0x69, 0xa7, 0x7c, 0x88, 0x9d, 0xa2, 0x42, 0x89, 0x6f, - 0x3d, 0x44, 0xf6, 0x0d, 0x7e, 0x2c, 0x84, 0x10, 0x4d, 0x60, 0xd4, 0xff, 0x25, 0x0f, 0xa3, 0x81, - 0x79, 0xa7, 0x3b, 0xee, 0x63, 0xdc, 0x1d, 0x9f, 0x86, 0x51, 0x0c, 0x70, 0xd5, 0xa6, 0x16, 0x0f, - 0x02, 0xd5, 0x2f, 0xa5, 0xcb, 0xf1, 0x11, 0x22, 0x33, 0x5a, 0x84, 0x90, 0x69, 0x3f, 0xb7, 0xfc, - 0xa4, 0xb0, 0x63, 0xdc, 0xec, 0xe3, 0x70, 0xf5, 0xaf, 0x14, 0x60, 0xc4, 0x97, 0xf2, 0xb4, 0x79, - 0x52, 0xef, 0x79, 0x8e, 0x57, 0xc8, 0xd7, 0x01, 0x56, 0x6c, 0xc7, 0xd3, 0x5b, 0x4b, 0xa1, 0xe6, - 0xe3, 0x01, 0x69, 0x07, 0xa1, 0xbc, 0x8c, 0x44, 0x82, 0xeb, 0x57, 0x68, 0x56, 0xf3, 0x89, 0x89, - 0xaf, 0x5f, 0x01, 0x54, 0x93, 0x28, 0xd4, 0xdf, 0xce, 0xc3, 0x19, 0xbf, 0x93, 0x66, 0x1f, 0xd1, - 0x46, 0xf7, 0x71, 0x9e, 0x9b, 0xa2, 0xd2, 0xee, 0xdf, 0x55, 0xda, 0xea, 0xff, 0x25, 0x4d, 0x24, - 0x33, 0x2d, 0xfb, 0x74, 0x22, 0xf9, 0xd7, 0xa1, 0xe3, 0xea, 0x8f, 0x15, 0xe0, 0x9c, 0x2f, 0xf5, - 0xb9, 0xae, 0x85, 0x47, 0x0b, 0x33, 0x7a, 0xab, 0xf5, 0x38, 0xef, 0xc6, 0x87, 0x7d, 0x41, 0x2c, - 0x8b, 0x88, 0x91, 0x22, 0x4b, 0xe5, 0xba, 0x00, 0xd7, 0x6d, 0xd3, 0xd0, 0x64, 0x22, 0xf2, 0x0e, - 0x8c, 0xf8, 0x3f, 0xcb, 0x4e, 0xd3, 0xdf, 0x82, 0xe3, 0x45, 0x41, 0x50, 0x48, 0x77, 0x22, 0x81, - 0x31, 0x22, 0x05, 0xd4, 0x2f, 0x0d, 0xc0, 0xa5, 0xfb, 0xa6, 0x65, 0xd8, 0x9b, 0xae, 0x9f, 0xe4, - 0xf4, 0xc4, 0x1f, 0x94, 0x1d, 0x77, 0x72, 0xd3, 0x77, 0xe1, 0x7c, 0x5c, 0xa4, 0x4e, 0x10, 0x7a, - 0x5e, 0xf4, 0xce, 0x26, 0x27, 0xa8, 0xfb, 0xe9, 0x4e, 0xc5, 0x6d, 0x9b, 0x96, 0x5e, 0x32, 0x9e, - 0x2f, 0x75, 0x60, 0x2f, 0xf9, 0x52, 0x9f, 0x87, 0x52, 0xc5, 0x6e, 0xeb, 0xa6, 0x1f, 0x22, 0x09, - 0x47, 0x71, 0x50, 0x2f, 0x62, 0x34, 0x41, 0xc1, 0xf8, 0x8b, 0x8a, 0xb1, 0xcb, 0x86, 0x42, 0xfe, - 0x7e, 0x01, 0x66, 0xa5, 0x69, 0x32, 0x11, 0xb1, 0x61, 0x54, 0x54, 0x27, 0xee, 0xc6, 0x00, 0x37, - 0x4f, 0xaf, 0xf8, 0x32, 0xca, 0x56, 0xab, 0xa9, 0x48, 0x39, 0xbe, 0x8d, 0xe2, 0x69, 0x5c, 0xc5, - 0xc7, 0xf0, 0x5b, 0x32, 0x2d, 0xca, 0x5f, 0x12, 0x02, 0x4e, 0x32, 0xc3, 0x49, 0x21, 0xe0, 0x2c, - 0x23, 0x13, 0x91, 0x59, 0x98, 0xc0, 0x00, 0xe1, 0xc1, 0x56, 0x8a, 0xa9, 0xc4, 0x08, 0x1a, 0x95, - 0x78, 0xe5, 0xc2, 0x63, 0x8a, 0xb3, 0x8f, 0xab, 0x37, 0x04, 0x5a, 0x4b, 0x96, 0x20, 0x4f, 0x40, - 0x61, 0x69, 0xa1, 0x8c, 0x77, 0x35, 0x83, 0x3c, 0x39, 0x97, 0xd5, 0xd2, 0x35, 0x06, 0xbb, 0xf4, - 0x59, 0x20, 0xc9, 0xcf, 0xd9, 0xd7, 0x7d, 0xcc, 0x7f, 0x25, 0x6d, 0xf9, 0x4e, 0xba, 0x47, 0xcd, - 0x51, 0x4c, 0x84, 0x91, 0xbc, 0x78, 0xfd, 0x1f, 0x66, 0x5e, 0xbc, 0xd2, 0x91, 0xe6, 0xc5, 0x53, - 0x7f, 0x25, 0x07, 0x13, 0x89, 0x20, 0xfa, 0xe4, 0x65, 0x00, 0x0e, 0x91, 0x82, 0x95, 0x62, 0xf4, - 0x9f, 0x30, 0xb0, 0xbe, 0x58, 0x1e, 0x43, 0x32, 0x72, 0x1d, 0x06, 0xf9, 0x2f, 0x11, 0x60, 0x2c, - 0x59, 0xa4, 0xdb, 0x35, 0x0d, 0x2d, 0x20, 0x0a, 0x6b, 0xc1, 0x1b, 0xc9, 0x42, 0x6a, 0x11, 0x6f, - 0xab, 0x13, 0xd4, 0xc2, 0xc8, 0xd4, 0x9f, 0xce, 0xc3, 0x48, 0xd0, 0xe0, 0xb2, 0x71, 0x5c, 0x3a, - 0x57, 0x12, 0xf9, 0x08, 0x0a, 0xbb, 0xe5, 0x23, 0x88, 0xcd, 0xb7, 0x22, 0x01, 0xc1, 0xd1, 0x3d, - 0xa8, 0xfa, 0x6a, 0x1e, 0xce, 0x04, 0xb5, 0x1e, 0xe3, 0xe5, 0xd7, 0x47, 0x48, 0x24, 0x5f, 0xc9, - 0x81, 0x32, 0x6d, 0xb6, 0x5a, 0xa6, 0xd5, 0xac, 0x5a, 0xeb, 0xb6, 0xd3, 0xc6, 0x09, 0xf1, 0xf8, - 0x8e, 0x70, 0xd5, 0x3f, 0x9d, 0x83, 0x09, 0xd1, 0xa0, 0x19, 0xdd, 0x31, 0x8e, 0xef, 0x7c, 0x2c, - 0xde, 0x92, 0xe3, 0xd3, 0x17, 0xf5, 0x9b, 0x79, 0x80, 0x05, 0xbb, 0xf1, 0xe0, 0x84, 0xbf, 0xc7, - 0x7a, 0x13, 0x4a, 0x3c, 0xca, 0x9b, 0xd0, 0xd8, 0x09, 0xf1, 0xee, 0x88, 0x7d, 0x1a, 0x47, 0x4c, - 0x8f, 0x8b, 0xf9, 0xb8, 0xc4, 0xa3, 0xc4, 0x29, 0x39, 0x4d, 0x14, 0x61, 0x95, 0x32, 0x3a, 0xb1, - 0x60, 0x04, 0x95, 0x32, 0x58, 0xb4, 0xd2, 0x9d, 0xed, 0xc9, 0x62, 0xcb, 0x6e, 0x3c, 0xd0, 0x90, - 0x5e, 0xfd, 0x97, 0x39, 0x2e, 0xbb, 0x13, 0xfe, 0xaa, 0xd4, 0xff, 0xfc, 0xe2, 0x3e, 0x3f, 0xff, - 0xcf, 0xe4, 0xe0, 0x9c, 0x46, 0x1b, 0xf6, 0x43, 0xea, 0x6c, 0xcd, 0xd8, 0x06, 0xbd, 0x45, 0x2d, - 0xea, 0x1c, 0xd7, 0x88, 0xfa, 0x1d, 0x4c, 0xe0, 0x12, 0x36, 0xe6, 0xae, 0x4b, 0x8d, 0x93, 0x93, - 0x5c, 0x47, 0xfd, 0xb5, 0x01, 0x50, 0x52, 0xad, 0xde, 0x13, 0x6b, 0xce, 0x65, 0x6e, 0x65, 0x8a, - 0x47, 0xb5, 0x95, 0xe9, 0xdf, 0xdf, 0x56, 0xa6, 0xb4, 0xdf, 0xad, 0xcc, 0xc0, 0x5e, 0xb6, 0x32, - 0xed, 0xf8, 0x56, 0x66, 0x10, 0xb7, 0x32, 0x2f, 0xf7, 0xdc, 0xca, 0xcc, 0x5a, 0xc6, 0x01, 0x37, - 0x32, 0x27, 0x36, 0xf1, 0xf3, 0x41, 0x76, 0x60, 0x57, 0xd9, 0xa4, 0xd8, 0xb0, 0x1d, 0x83, 0x1a, - 0x62, 0xe3, 0x85, 0xa7, 0xfe, 0x8e, 0x80, 0x69, 0x01, 0x36, 0x91, 0x45, 0x7b, 0x74, 0x2f, 0x59, - 0xb4, 0x8f, 0x60, 0xff, 0xf5, 0xe5, 0x3c, 0x4c, 0xcc, 0x50, 0xc7, 0xe3, 0x61, 0x64, 0x8f, 0xc2, - 0x25, 0xae, 0x0c, 0x67, 0x24, 0x86, 0x68, 0x91, 0xe7, 0x43, 0x37, 0xbf, 0x06, 0x75, 0xbc, 0xb8, - 0x97, 0x60, 0x9c, 0x9e, 0x55, 0xef, 0x67, 0xb2, 0x13, 0x63, 0x37, 0xa8, 0xde, 0x87, 0x73, 0x41, - 0x9a, 0xe2, 0x97, 0x16, 0xd0, 0x4b, 0xc9, 0xe9, 0x8a, 0xfb, 0x4f, 0x4e, 0xa7, 0xfe, 0x72, 0x0e, - 0xae, 0x68, 0xd4, 0xa2, 0x9b, 0xfa, 0x5a, 0x8b, 0x4a, 0xcd, 0x12, 0x2b, 0x03, 0x9b, 0x35, 0x4c, - 0xb7, 0xad, 0x7b, 0x8d, 0x8d, 0x43, 0xc9, 0x68, 0x0e, 0x46, 0xe4, 0xf9, 0x6b, 0x1f, 0x73, 0x5b, - 0xa4, 0x9c, 0xfa, 0x6b, 0x45, 0x18, 0x98, 0xb6, 0xbd, 0xdb, 0xf6, 0x21, 0xb3, 0x25, 0x86, 0x53, - 0x7e, 0x7e, 0x1f, 0x67, 0x3d, 0x9f, 0xc2, 0xca, 0xa5, 0x04, 0x12, 0xe8, 0x42, 0xba, 0x66, 0x27, - 0x12, 0x6d, 0xf8, 0x64, 0xfb, 0xcc, 0x93, 0xf8, 0x2a, 0x0c, 0x61, 0xf4, 0x17, 0xe9, 0x34, 0x16, - 0x1d, 0xb4, 0x3d, 0x06, 0x8c, 0xd7, 0x11, 0x92, 0x92, 0x1f, 0x88, 0xc4, 0xbd, 0x2d, 0x1d, 0x3e, - 0xaf, 0xa2, 0x1c, 0x02, 0xf7, 0x65, 0x7e, 0x91, 0x87, 0x6d, 0x92, 0x72, 0xd0, 0xe0, 0x29, 0x4a, - 0xac, 0x49, 0x01, 0xe1, 0x11, 0xe6, 0x3c, 0x9c, 0x81, 0xd1, 0x69, 0xdb, 0x93, 0x9c, 0x81, 0x87, - 0xc2, 0x67, 0xa0, 0x4c, 0xf2, 0xe9, 0x9e, 0xc0, 0xd1, 0x32, 0xea, 0x77, 0x8b, 0x30, 0xe2, 0xff, - 0x3c, 0x26, 0xdd, 0x79, 0x11, 0x4a, 0xf3, 0xb6, 0x94, 0x86, 0x03, 0x1d, 0x88, 0x37, 0x6c, 0x37, - 0xe6, 0x19, 0x2d, 0x88, 0x98, 0xd4, 0x97, 0x6c, 0x43, 0x76, 0x7f, 0x47, 0xa9, 0x5b, 0xb6, 0x91, - 0x78, 0x3e, 0x1c, 0x10, 0x92, 0x2b, 0x50, 0xc4, 0x97, 0x03, 0xd2, 0x41, 0x7e, 0xec, 0xb5, 0x00, - 0xe2, 0x25, 0xad, 0x2c, 0xed, 0x57, 0x2b, 0x07, 0x0e, 0xaa, 0x95, 0x83, 0x47, 0xab, 0x95, 0xef, - 0xc1, 0x08, 0xd6, 0xe4, 0x67, 0xf1, 0xdb, 0x7d, 0x61, 0x7d, 0x42, 0xac, 0x7d, 0xa3, 0xbc, 0xdd, - 0x22, 0x97, 0x1f, 0x2e, 0x79, 0x11, 0x56, 0x31, 0xdd, 0x85, 0x43, 0x6c, 0xa7, 0xff, 0x51, 0x0e, - 0x06, 0xee, 0x5a, 0x0f, 0x2c, 0x7b, 0xf3, 0x70, 0x1a, 0xf7, 0x32, 0x0c, 0x0b, 0x36, 0xd2, 0xea, - 0x82, 0x2f, 0xc2, 0xbb, 0x1c, 0x5c, 0x47, 0x4e, 0x9a, 0x4c, 0x45, 0xde, 0x0a, 0x0a, 0xe1, 0xe3, - 0xa0, 0x42, 0x98, 0xc8, 0xc6, 0x2f, 0xd4, 0x88, 0xe6, 0xde, 0x90, 0xc9, 0xc9, 0x65, 0x28, 0x56, - 0x58, 0x53, 0xa5, 0x18, 0xbc, 0xac, 0x29, 0x1a, 0x42, 0xd5, 0x2f, 0x17, 0x61, 0x2c, 0x76, 0xf0, - 0xf5, 0x3c, 0x0c, 0x89, 0x83, 0x27, 0xd3, 0x4f, 0x06, 0x82, 0x8f, 0x87, 0x02, 0xa0, 0x36, 0xc8, - 0xff, 0xac, 0x1a, 0xe4, 0x33, 0x30, 0x60, 0xbb, 0xb8, 0x28, 0xe2, 0xb7, 0x8c, 0x85, 0x43, 0x68, - 0xb9, 0xc6, 0xda, 0xce, 0x07, 0x87, 0x20, 0x91, 0x35, 0xd2, 0x76, 0xf1, 0xd3, 0x6e, 0xc2, 0x90, - 0xee, 0xba, 0xd4, 0xab, 0x7b, 0x7a, 0x53, 0xce, 0x0f, 0x12, 0x00, 0xe5, 0xd1, 0x81, 0xc0, 0x55, - 0xbd, 0x49, 0x3e, 0x0b, 0xa3, 0x0d, 0x87, 0xe2, 0xb2, 0xa9, 0xb7, 0x58, 0x2b, 0x25, 0xb3, 0x36, - 0x82, 0x90, 0xef, 0x4f, 0x42, 0x44, 0xd5, 0x20, 0xf7, 0x60, 0x54, 0x7c, 0x0e, 0xf7, 0xdc, 0xc7, - 0x81, 0x36, 0x16, 0x2e, 0x63, 0x5c, 0x24, 0xdc, 0x77, 0x5f, 0x3c, 0xe0, 0x90, 0xc9, 0x65, 0xbe, - 0x86, 0x44, 0x4a, 0x96, 0x81, 0x6c, 0xd2, 0xb5, 0xba, 0xde, 0xf5, 0x36, 0x58, 0x5d, 0x3c, 0xbc, - 0xbd, 0x48, 0x8b, 0x89, 0xaf, 0x1e, 0x92, 0x58, 0xf9, 0x31, 0xc8, 0x26, 0x5d, 0x2b, 0x47, 0x90, - 0xe4, 0x3e, 0x9c, 0x4f, 0x16, 0x61, 0x9f, 0xcc, 0x2f, 0x07, 0x9e, 0xdb, 0xd9, 0x9e, 0x9c, 0x4c, - 0x25, 0x90, 0xd8, 0x9e, 0x4d, 0xb0, 0xad, 0x1a, 0xb7, 0x8b, 0x83, 0x03, 0xe3, 0x83, 0xda, 0x18, - 0x2b, 0xeb, 0x9b, 0x90, 0xa6, 0xa1, 0xfe, 0x7e, 0x8e, 0x99, 0x8a, 0xec, 0x83, 0x30, 0x2f, 0x38, - 0xd3, 0xf5, 0xf6, 0x3e, 0x75, 0xbd, 0x1d, 0x66, 0xf0, 0x2c, 0xb9, 0x3d, 0x66, 0x57, 0x4d, 0x60, - 0xc9, 0x14, 0x94, 0x0c, 0xf9, 0xd4, 0xec, 0x42, 0xb4, 0x13, 0xfc, 0x7a, 0x34, 0x41, 0x45, 0xae, - 0x42, 0x91, 0x2d, 0x59, 0xf1, 0x2d, 0xb3, 0x6c, 0x5d, 0x68, 0x48, 0xa1, 0xfe, 0x48, 0x1e, 0x46, - 0xa4, 0xaf, 0xb9, 0x71, 0xa8, 0xcf, 0x79, 0x63, 0x6f, 0xcd, 0xf4, 0x9d, 0x5e, 0x70, 0x2f, 0xe5, - 0x37, 0xf9, 0x66, 0x20, 0x8a, 0x3d, 0x5d, 0x48, 0x09, 0xc1, 0xbc, 0x2a, 0x3e, 0xb4, 0xb4, 0xf7, - 0xed, 0x23, 0xa3, 0xbf, 0x5d, 0x1c, 0xcc, 0x8f, 0x17, 0x6e, 0x17, 0x07, 0x8b, 0xe3, 0xfd, 0x18, - 0x87, 0x0b, 0x43, 0x5f, 0xf3, 0xbd, 0xb9, 0xb5, 0x6e, 0x36, 0x4f, 0xf8, 0xdb, 0x91, 0xa3, 0x8d, - 0x51, 0x16, 0x93, 0xcd, 0x09, 0x7f, 0x48, 0xf2, 0xa1, 0xca, 0xe6, 0x34, 0xe3, 0xa7, 0x90, 0xcd, - 0x3f, 0xce, 0x81, 0x92, 0x2a, 0x9b, 0xf2, 0x31, 0xf9, 0x41, 0x1c, 0x5d, 0xde, 0xcf, 0x3f, 0xce, - 0xc3, 0x44, 0xd5, 0xf2, 0x68, 0x93, 0xef, 0x18, 0x4f, 0xf8, 0x54, 0x71, 0x07, 0x86, 0xa5, 0x8f, - 0x11, 0x7d, 0xfe, 0x64, 0xb0, 0x1f, 0x0f, 0x51, 0x19, 0x9c, 0xe4, 0xd2, 0x47, 0xf7, 0x12, 0x27, - 0x2e, 0xe4, 0x13, 0x3e, 0xe7, 0x9c, 0x0c, 0x21, 0x9f, 0xf0, 0xc9, 0xeb, 0x23, 0x2a, 0xe4, 0xff, - 0x23, 0x07, 0x67, 0x53, 0x2a, 0x27, 0x57, 0x60, 0xa0, 0xd6, 0x5d, 0xc3, 0xb0, 0x5b, 0xb9, 0xd0, - 0x63, 0xd8, 0xed, 0xae, 0x61, 0xc4, 0x2d, 0xcd, 0x47, 0x92, 0x55, 0x7c, 0x5c, 0xbf, 0x5c, 0xad, - 0xcc, 0x08, 0xa9, 0xaa, 0x52, 0x98, 0x00, 0x06, 0x4e, 0xfb, 0xb2, 0xe0, 0x01, 0xbe, 0x6d, 0x1a, - 0x8d, 0xd8, 0x03, 0x7c, 0x56, 0x86, 0xfc, 0x20, 0x0c, 0x95, 0x3f, 0xe8, 0x3a, 0x14, 0xf9, 0x72, - 0x89, 0x7f, 0x2c, 0xe0, 0xeb, 0x23, 0xd2, 0x38, 0xf3, 0x58, 0x02, 0x8c, 0x22, 0xce, 0x3b, 0x64, - 0xa8, 0xfe, 0x74, 0x0e, 0x2e, 0x65, 0xb7, 0x8e, 0x7c, 0x0a, 0x06, 0xd8, 0xce, 0xbc, 0xac, 0x2d, - 0x89, 0x4f, 0xe7, 0x39, 0x72, 0xed, 0x16, 0xad, 0xeb, 0x8e, 0x6c, 0xec, 0xfb, 0x64, 0xe4, 0x6d, - 0x18, 0xae, 0xba, 0x6e, 0x97, 0x3a, 0xb5, 0x97, 0xef, 0x6a, 0x55, 0xb1, 0x27, 0xc4, 0x3d, 0x87, - 0x89, 0xe0, 0xba, 0xfb, 0x72, 0x2c, 0xb0, 0x96, 0x4c, 0xaf, 0xfe, 0x44, 0x0e, 0x2e, 0xf7, 0xfa, - 0x2a, 0xf2, 0x32, 0x0c, 0xae, 0x52, 0x4b, 0xb7, 0xbc, 0x6a, 0x45, 0x34, 0x09, 0xb7, 0x58, 0x1e, - 0xc2, 0xa2, 0x3b, 0x85, 0x80, 0x90, 0x15, 0xe2, 0xe7, 0x8a, 0x81, 0x23, 0x03, 0x3f, 0x03, 0x45, - 0x58, 0xac, 0x90, 0x4f, 0xa8, 0xfe, 0x41, 0x1e, 0x46, 0x56, 0x5a, 0xdd, 0xa6, 0x29, 0x2d, 0x1c, - 0x07, 0xb6, 0xb7, 0x7d, 0xeb, 0x37, 0xbf, 0x3f, 0xeb, 0x97, 0x0d, 0x37, 0xe7, 0x80, 0xc3, 0xcd, - 0x2f, 0x47, 0xde, 0x82, 0x52, 0x07, 0xbf, 0x23, 0x7e, 0x12, 0xcb, 0xbf, 0x2e, 0xeb, 0x24, 0x96, - 0x97, 0x61, 0xe3, 0xab, 0x71, 0x88, 0xf1, 0x15, 0x96, 0x95, 0x04, 0x1a, 0x2e, 0x12, 0xa7, 0x02, - 0x3d, 0x12, 0x81, 0x86, 0x0b, 0xc2, 0xa9, 0x40, 0x0f, 0x21, 0xd0, 0x5f, 0xcb, 0xc3, 0x58, 0xb4, - 0x4a, 0xf2, 0x29, 0x18, 0xe6, 0xd5, 0xf0, 0x73, 0xa1, 0x9c, 0xe4, 0x54, 0x1c, 0x82, 0x35, 0xe0, - 0x3f, 0xc4, 0x01, 0xd7, 0x99, 0x0d, 0xdd, 0xad, 0x87, 0x27, 0x34, 0xfc, 0xfe, 0x76, 0x90, 0x7b, - 0x42, 0xc5, 0x50, 0xda, 0xd8, 0x86, 0xee, 0xce, 0x84, 0xbf, 0xc9, 0x2c, 0x10, 0x87, 0x76, 0x5d, - 0x1a, 0x65, 0x50, 0x44, 0x06, 0x22, 0x41, 0x79, 0x1c, 0xab, 0x4d, 0x70, 0x98, 0xcc, 0xe6, 0x0b, - 0x41, 0xb3, 0x51, 0x19, 0xfa, 0xf7, 0x90, 0x3d, 0x5d, 0xa2, 0x4f, 0x3f, 0xe6, 0xe4, 0x04, 0x15, - 0xdd, 0xd3, 0xf9, 0xa6, 0xdc, 0xef, 0x00, 0xf5, 0x47, 0x3b, 0xd0, 0xbf, 0x6c, 0xd1, 0xe5, 0x75, - 0xf2, 0x12, 0x0c, 0x31, 0x85, 0x59, 0xb0, 0x59, 0x5f, 0xe6, 0x84, 0xff, 0x84, 0xa4, 0x49, 0x88, - 0x98, 0xef, 0xd3, 0x42, 0x2a, 0x72, 0x13, 0x20, 0x7c, 0x62, 0x26, 0xb4, 0x8f, 0xc8, 0x65, 0x38, - 0x66, 0xbe, 0x4f, 0x93, 0xe8, 0xfc, 0x52, 0xe2, 0x81, 0x4e, 0x21, 0x59, 0x8a, 0x63, 0xfc, 0x52, - 0x62, 0x7c, 0x2c, 0x00, 0x61, 0xbf, 0x56, 0x74, 0xd7, 0xdd, 0xb4, 0x1d, 0x63, 0x66, 0x43, 0xb7, - 0x9a, 0x34, 0xbe, 0x7b, 0x4a, 0x52, 0xcc, 0xf7, 0x69, 0x29, 0xe5, 0xc8, 0x1b, 0x30, 0x22, 0x3b, - 0x94, 0xc6, 0x9d, 0x3e, 0x64, 0xdc, 0x7c, 0x9f, 0x16, 0xa1, 0x25, 0xaf, 0xc1, 0xb0, 0xf8, 0x7d, - 0xdb, 0x16, 0x37, 0xca, 0x52, 0x2c, 0x22, 0x09, 0x35, 0xdf, 0xa7, 0xc9, 0x94, 0x52, 0xa5, 0x2b, - 0x8e, 0x69, 0x79, 0xe2, 0x8d, 0x72, 0xbc, 0x52, 0xc4, 0x49, 0x95, 0xe2, 0x6f, 0xf2, 0x36, 0x8c, - 0x06, 0x41, 0x9e, 0xde, 0xa7, 0x0d, 0x4f, 0x1c, 0x7e, 0x9f, 0x8f, 0x15, 0xe6, 0xc8, 0xf9, 0x3e, - 0x2d, 0x4a, 0x4d, 0xae, 0x42, 0x49, 0xa3, 0xae, 0xf9, 0x81, 0x7f, 0x5d, 0x3c, 0x26, 0x8d, 0x73, - 0xf3, 0x03, 0x26, 0x25, 0x81, 0x67, 0xbd, 0x13, 0xde, 0x4f, 0x8b, 0xa3, 0x6a, 0x12, 0xab, 0x65, - 0xd6, 0x32, 0x58, 0xef, 0x48, 0xce, 0x09, 0x9f, 0x0d, 0x43, 0x5f, 0x89, 0xa4, 0xad, 0xc3, 0xf1, - 0x18, 0x03, 0x32, 0x76, 0xbe, 0x4f, 0x8b, 0xd1, 0x4b, 0x52, 0xad, 0x98, 0xee, 0x03, 0x11, 0x6d, - 0x34, 0x2e, 0x55, 0x86, 0x92, 0xa4, 0xca, 0x7e, 0x4a, 0x55, 0x2f, 0x51, 0x6f, 0xd3, 0x76, 0x1e, - 0x88, 0xd8, 0xa2, 0xf1, 0xaa, 0x05, 0x56, 0xaa, 0x5a, 0x40, 0xe4, 0xaa, 0xd9, 0x80, 0x1b, 0x4b, - 0xaf, 0x5a, 0xf7, 0x74, 0xb9, 0x6a, 0x7e, 0x12, 0xe7, 0x77, 0xd2, 0x02, 0xd5, 0x1f, 0xf2, 0xdc, - 0xf9, 0xc9, 0x0e, 0x45, 0x9c, 0xd4, 0xa1, 0xf8, 0x9b, 0x55, 0x2a, 0xe5, 0x47, 0x17, 0xc9, 0xf1, - 0x83, 0x4a, 0x25, 0x14, 0xab, 0x54, 0xce, 0xa4, 0x7e, 0x53, 0x4e, 0x1b, 0xae, 0x4c, 0x44, 0x3b, - 0x28, 0xc4, 0xb0, 0x0e, 0x92, 0xd2, 0x8b, 0x4f, 0x62, 0x4a, 0x62, 0x85, 0x20, 0xf9, 0x70, 0xd0, - 0xc2, 0x99, 0x95, 0xf9, 0x3e, 0x0d, 0x93, 0x15, 0xab, 0x3c, 0xd9, 0xb5, 0x72, 0x16, 0x29, 0x46, - 0x7c, 0x0a, 0x06, 0x9b, 0xef, 0xd3, 0x78, 0x22, 0xec, 0x97, 0xa4, 0x84, 0x80, 0xca, 0xb9, 0xe8, - 0x14, 0x11, 0x20, 0xd8, 0x14, 0x11, 0xa6, 0x0d, 0x9c, 0x4b, 0xa6, 0xbd, 0x53, 0xce, 0x47, 0x97, - 0x9a, 0x38, 0x7e, 0xbe, 0x4f, 0x4b, 0xa6, 0xca, 0x7b, 0x2d, 0x92, 0x09, 0x4e, 0xb9, 0x10, 0x0b, - 0x00, 0x16, 0xa2, 0x98, 0xb8, 0xe4, 0x9c, 0x71, 0xcb, 0xb1, 0xcc, 0xf9, 0x62, 0xb2, 0xba, 0x18, - 0xdd, 0xb8, 0xa4, 0x90, 0xcc, 0xf7, 0x69, 0x69, 0x25, 0xc9, 0x4c, 0x22, 0x1f, 0x9b, 0xa2, 0x44, - 0x7d, 0x63, 0x62, 0xe8, 0xf9, 0x3e, 0x2d, 0x91, 0xc1, 0xed, 0xa6, 0x9c, 0x08, 0x4d, 0x79, 0x22, - 0xda, 0x89, 0x21, 0x86, 0x75, 0xa2, 0x94, 0x30, 0xed, 0xa6, 0x9c, 0x1c, 0x4b, 0xb9, 0x94, 0x2c, - 0x15, 0xce, 0x9c, 0x52, 0x12, 0x2d, 0x2d, 0x3d, 0xdf, 0x8f, 0xf2, 0xa4, 0xc8, 0xfa, 0x2b, 0xca, - 0xa7, 0xd1, 0xcc, 0xf7, 0x69, 0xe9, 0xb9, 0x82, 0xb4, 0xf4, 0x44, 0x39, 0xca, 0xe5, 0x5e, 0x3c, - 0x83, 0xd6, 0xa5, 0x27, 0xd9, 0xd1, 0x7b, 0xa4, 0x2d, 0x51, 0x9e, 0x8a, 0x46, 0x1f, 0xce, 0x24, - 0x9c, 0xef, 0xd3, 0x7a, 0x24, 0x3f, 0xb9, 0x9b, 0x91, 0x43, 0x44, 0x79, 0x3a, 0x9a, 0xf4, 0x3b, - 0x95, 0x68, 0xbe, 0x4f, 0xcb, 0xc8, 0x40, 0x72, 0x37, 0x23, 0xc5, 0x84, 0x32, 0xd9, 0x93, 0x6d, - 0x20, 0x8f, 0x8c, 0x04, 0x15, 0xcb, 0xa9, 0xd9, 0x19, 0x94, 0x67, 0xa2, 0xaa, 0x9b, 0x42, 0xc2, - 0x54, 0x37, 0x2d, 0xaf, 0xc3, 0x72, 0x6a, 0x3a, 0x01, 0xe5, 0xd9, 0x1e, 0x0c, 0x83, 0x36, 0xa6, - 0x26, 0x22, 0x58, 0x4e, 0x8d, 0xe7, 0xaf, 0xa8, 0x51, 0x86, 0x29, 0x24, 0x8c, 0x61, 0x5a, 0x26, - 0x80, 0xe5, 0xd4, 0xb0, 0xef, 0xca, 0x73, 0x3d, 0x18, 0x86, 0x2d, 0x4c, 0x0b, 0x18, 0xff, 0x5a, - 0x24, 0xee, 0xba, 0xf2, 0xb1, 0xe8, 0xbc, 0x21, 0xa1, 0xd8, 0xbc, 0x21, 0x47, 0x68, 0x9f, 0x49, - 0x44, 0x96, 0x55, 0x3e, 0x1e, 0x1d, 0xe6, 0x31, 0x34, 0x1b, 0xe6, 0xf1, 0x58, 0xb4, 0x33, 0x89, - 0x08, 0x9b, 0xca, 0x95, 0x2c, 0x26, 0x88, 0x8e, 0x32, 0xe1, 0x31, 0x39, 0xab, 0x29, 0x21, 0x1e, - 0x95, 0x4f, 0x44, 0xfd, 0xba, 0x13, 0x04, 0xf3, 0x7d, 0x5a, 0x4a, 0x60, 0x48, 0x2d, 0x3d, 0x9e, - 0x91, 0x72, 0x35, 0x3a, 0x6c, 0xd3, 0x68, 0xd8, 0xb0, 0x4d, 0x8d, 0x85, 0xb4, 0x90, 0xf6, 0xf8, - 0x44, 0xb9, 0x16, 0x35, 0xcc, 0x92, 0x14, 0xcc, 0x30, 0x4b, 0x79, 0xb4, 0xa2, 0xa5, 0xc7, 0xd8, - 0x51, 0x9e, 0xef, 0xd9, 0x42, 0xa4, 0x49, 0x69, 0x21, 0x0f, 0x39, 0x13, 0xda, 0x4e, 0x77, 0x3b, - 0x2d, 0x5b, 0x37, 0x94, 0x4f, 0xa6, 0xda, 0x4e, 0x1c, 0x29, 0xd9, 0x4e, 0x1c, 0xc0, 0x56, 0x79, - 0xf9, 0x8d, 0x83, 0xf2, 0x42, 0x74, 0x95, 0x97, 0x71, 0x6c, 0x95, 0x8f, 0xbc, 0x87, 0x98, 0x49, - 0xbc, 0x07, 0x50, 0x5e, 0x8c, 0x2a, 0x40, 0x0c, 0xcd, 0x14, 0x20, 0xfe, 0x82, 0xe0, 0x8b, 0xd9, - 0x1e, 0xf4, 0xca, 0x14, 0x72, 0x7b, 0xc6, 0xe7, 0x96, 0x45, 0x37, 0xdf, 0xa7, 0x65, 0x7b, 0xe1, - 0x57, 0x53, 0x1c, 0xe2, 0x95, 0xeb, 0x51, 0x05, 0x4b, 0x10, 0x30, 0x05, 0x4b, 0xba, 0xd1, 0x57, - 0x53, 0x3c, 0xda, 0x95, 0x4f, 0x65, 0xb2, 0x0a, 0xbe, 0x39, 0xc5, 0x0f, 0xfe, 0xa6, 0xec, 0x92, - 0xae, 0xbc, 0x14, 0x5d, 0xec, 0x42, 0x0c, 0x5b, 0xec, 0x24, 0xd7, 0xf5, 0x9b, 0xb2, 0x33, 0xb6, - 0x72, 0x23, 0x59, 0x2a, 0x5c, 0x22, 0x25, 0xa7, 0x6d, 0x2d, 0xdd, 0x87, 0x59, 0x79, 0x39, 0xaa, - 0x75, 0x69, 0x34, 0x4c, 0xeb, 0x52, 0xfd, 0x9f, 0xe7, 0x92, 0xae, 0xc8, 0xca, 0xcd, 0xf8, 0x26, - 0x3b, 0x8a, 0x67, 0x96, 0x4f, 0xc2, 0x7d, 0xf9, 0xb3, 0xf1, 0x60, 0x7b, 0xca, 0x2b, 0xb1, 0x6b, - 0xdf, 0x08, 0x96, 0xd9, 0xb7, 0xb1, 0xe0, 0x7c, 0x9f, 0x8d, 0xc7, 0xa7, 0x53, 0x5e, 0x4d, 0xe7, - 0x10, 0xe8, 0x4a, 0x3c, 0x9e, 0xdd, 0x67, 0xe3, 0x21, 0xdd, 0x94, 0xd7, 0xd2, 0x39, 0x04, 0xd2, - 0x8d, 0x87, 0x80, 0x7b, 0x49, 0x0a, 0x32, 0xaf, 0x7c, 0x3a, 0x6a, 0x3a, 0x06, 0x08, 0x66, 0x3a, - 0x86, 0xa1, 0xe8, 0x5f, 0x92, 0x82, 0xb3, 0x2b, 0xaf, 0x27, 0x8a, 0x04, 0x8d, 0x95, 0x42, 0xb8, - 0xbf, 0x24, 0x05, 0x35, 0x57, 0xde, 0x48, 0x14, 0x09, 0x5a, 0x27, 0x85, 0x3e, 0x37, 0x7a, 0xbd, - 0x5f, 0x55, 0xde, 0x8c, 0x1e, 0x06, 0x67, 0x53, 0xce, 0xf7, 0x69, 0xbd, 0xde, 0xc1, 0x7e, 0x31, - 0xdb, 0xb1, 0x5b, 0x79, 0x2b, 0x3a, 0x84, 0xb3, 0xe8, 0xd8, 0x10, 0xce, 0x74, 0x0e, 0x7f, 0x3b, - 0x16, 0xcb, 0x42, 0x79, 0x3b, 0x3a, 0xc5, 0x45, 0x90, 0x6c, 0x8a, 0x8b, 0x47, 0xbe, 0x88, 0x04, - 0x69, 0x50, 0x3e, 0x13, 0x9d, 0xe2, 0x64, 0x1c, 0x9b, 0xe2, 0x22, 0x01, 0x1d, 0x66, 0x12, 0xb1, - 0x03, 0x94, 0x77, 0xa2, 0x53, 0x5c, 0x0c, 0xcd, 0xa6, 0xb8, 0x78, 0xb4, 0x81, 0xb7, 0x63, 0x4f, - 0xe8, 0x95, 0xcf, 0xa6, 0xb7, 0x1f, 0x91, 0x72, 0xfb, 0xf9, 0x83, 0x7b, 0x2d, 0xfd, 0x2d, 0xb8, - 0x52, 0x8e, 0x8e, 0xdf, 0x34, 0x1a, 0x36, 0x7e, 0x53, 0xdf, 0x91, 0xc7, 0x37, 0x0e, 0x42, 0xab, - 0xa6, 0x7b, 0x6c, 0x1c, 0x42, 0x53, 0x24, 0x05, 0x1c, 0xd9, 0x23, 0xf3, 0x8d, 0xd0, 0x4c, 0xc6, - 0x1e, 0xd9, 0xdf, 0x06, 0xc5, 0xe8, 0xd9, 0xec, 0x9a, 0xf0, 0x33, 0x56, 0x2a, 0xd1, 0xd9, 0x35, - 0x41, 0xc0, 0x66, 0xd7, 0xa4, 0x77, 0xf2, 0x1c, 0x8c, 0x0b, 0x2d, 0xe2, 0xee, 0xd3, 0xa6, 0xd5, - 0x54, 0x66, 0x63, 0xef, 0x2d, 0x63, 0x78, 0x36, 0x3b, 0xc5, 0x61, 0xb8, 0x5e, 0x73, 0xd8, 0x4c, - 0xcb, 0xec, 0xac, 0xd9, 0xba, 0x63, 0xd4, 0xa8, 0x65, 0x28, 0x73, 0xb1, 0xf5, 0x3a, 0x85, 0x06, - 0xd7, 0xeb, 0x14, 0x38, 0x86, 0x88, 0x8b, 0xc1, 0x35, 0xda, 0xa0, 0xe6, 0x43, 0xaa, 0xdc, 0x42, - 0xb6, 0x93, 0x59, 0x6c, 0x05, 0xd9, 0x7c, 0x9f, 0x96, 0xc5, 0x81, 0xd9, 0xea, 0x8b, 0x5b, 0xb5, - 0x77, 0x17, 0x82, 0xf0, 0x03, 0x2b, 0x0e, 0xed, 0xe8, 0x0e, 0x55, 0xe6, 0xa3, 0xb6, 0x7a, 0x2a, - 0x11, 0xb3, 0xd5, 0x53, 0x11, 0x49, 0xb6, 0xfe, 0x58, 0xa8, 0xf6, 0x62, 0x1b, 0x8e, 0x88, 0xf4, - 0xd2, 0x6c, 0x76, 0x8a, 0x22, 0x98, 0x80, 0x16, 0x6c, 0xab, 0x89, 0x27, 0x15, 0xb7, 0xa3, 0xb3, - 0x53, 0x36, 0x25, 0x9b, 0x9d, 0xb2, 0xb1, 0x4c, 0xd5, 0xa3, 0x58, 0x3e, 0x06, 0xef, 0x44, 0x55, - 0x3d, 0x85, 0x84, 0xa9, 0x7a, 0x0a, 0x38, 0xc9, 0x50, 0xa3, 0x2e, 0xf5, 0x94, 0x85, 0x5e, 0x0c, - 0x91, 0x24, 0xc9, 0x10, 0xc1, 0x49, 0x86, 0x73, 0xd4, 0x6b, 0x6c, 0x28, 0x8b, 0xbd, 0x18, 0x22, - 0x49, 0x92, 0x21, 0x82, 0xd9, 0x66, 0x33, 0x0a, 0x9e, 0xee, 0xb6, 0x1e, 0xf8, 0x7d, 0xb6, 0x14, - 0xdd, 0x6c, 0x66, 0x12, 0xb2, 0xcd, 0x66, 0x26, 0x92, 0xfc, 0xc4, 0x9e, 0xfd, 0xe0, 0x95, 0x65, - 0xac, 0x70, 0x2a, 0xb4, 0x0b, 0xf6, 0x52, 0x6a, 0xbe, 0x4f, 0xdb, 0xab, 0x9f, 0xfd, 0x27, 0x03, - 0xa7, 0x51, 0x65, 0x05, 0xab, 0x3a, 0x13, 0x9c, 0x55, 0x70, 0xf0, 0x7c, 0x9f, 0x16, 0xb8, 0x95, - 0xbe, 0x06, 0xc3, 0xf8, 0x51, 0x55, 0xcb, 0xf4, 0x2a, 0xd3, 0xca, 0xbb, 0xd1, 0x2d, 0x93, 0x84, - 0x62, 0x5b, 0x26, 0xe9, 0x27, 0x9b, 0xc4, 0xf1, 0x27, 0x9f, 0x62, 0x2a, 0xd3, 0x8a, 0x16, 0x9d, - 0xc4, 0x23, 0x48, 0x36, 0x89, 0x47, 0x00, 0x41, 0xbd, 0x15, 0xc7, 0xee, 0x54, 0xa6, 0x95, 0x5a, - 0x4a, 0xbd, 0x1c, 0x15, 0xd4, 0xcb, 0x7f, 0x06, 0xf5, 0xd6, 0x36, 0xba, 0x5e, 0x85, 0x7d, 0xe3, - 0x6a, 0x4a, 0xbd, 0x3e, 0x32, 0xa8, 0xd7, 0x07, 0xb0, 0xa9, 0x10, 0x01, 0x2b, 0x8e, 0xcd, 0x26, - 0xed, 0x3b, 0x66, 0xab, 0xa5, 0xdc, 0x8d, 0x4e, 0x85, 0x71, 0x3c, 0x9b, 0x0a, 0xe3, 0x30, 0x66, - 0x7a, 0xf2, 0x56, 0xd1, 0xb5, 0x6e, 0x53, 0xb9, 0x17, 0x35, 0x3d, 0x43, 0x0c, 0x33, 0x3d, 0xc3, - 0x5f, 0xb8, 0xbb, 0x60, 0xbf, 0x34, 0xba, 0xee, 0x50, 0x77, 0x43, 0xb9, 0x1f, 0xdb, 0x5d, 0x48, - 0x38, 0xdc, 0x5d, 0x48, 0xbf, 0x49, 0x13, 0x9e, 0x8c, 0x2c, 0x34, 0xfe, 0xa5, 0x4d, 0x8d, 0xea, - 0x4e, 0x63, 0x43, 0xf9, 0x1c, 0xb2, 0x7a, 0x2e, 0x75, 0xa9, 0x8a, 0x92, 0xce, 0xf7, 0x69, 0xbd, - 0x38, 0xe1, 0xb6, 0xfc, 0xdd, 0x05, 0x1e, 0x09, 0x56, 0x5b, 0x99, 0xf1, 0x37, 0xa1, 0xef, 0xc5, - 0xb6, 0xe5, 0x49, 0x12, 0xdc, 0x96, 0x27, 0xc1, 0xa4, 0x03, 0x4f, 0xc7, 0xb6, 0x6a, 0x8b, 0x7a, - 0x8b, 0xed, 0x4b, 0xa8, 0xb1, 0xa2, 0x37, 0x1e, 0x50, 0x4f, 0xf9, 0x3c, 0xf2, 0xbe, 0x92, 0xb1, - 0xe1, 0x8b, 0x51, 0xcf, 0xf7, 0x69, 0xbb, 0xf0, 0x23, 0x2a, 0x14, 0x6b, 0x73, 0xab, 0x2b, 0xca, - 0x0f, 0x44, 0xcf, 0x37, 0x19, 0x6c, 0xbe, 0x4f, 0x43, 0x1c, 0xb3, 0xd2, 0xee, 0x76, 0x9a, 0x8e, - 0x6e, 0x50, 0x6e, 0x68, 0xa1, 0xed, 0x26, 0x0c, 0xd0, 0x1f, 0x8c, 0x5a, 0x69, 0x59, 0x74, 0xcc, - 0x4a, 0xcb, 0xc2, 0x31, 0x45, 0x8d, 0x24, 0x3d, 0x51, 0xbe, 0x10, 0x55, 0xd4, 0x08, 0x92, 0x29, - 0x6a, 0x34, 0x45, 0xca, 0xe7, 0xe0, 0x42, 0xb0, 0x9f, 0x17, 0xeb, 0x2f, 0xef, 0x34, 0xe5, 0x8b, - 0xc8, 0xe7, 0xe9, 0xc4, 0x65, 0x40, 0x84, 0x6a, 0xbe, 0x4f, 0xcb, 0x28, 0xcf, 0x56, 0xdc, 0x44, - 0x3e, 0x2f, 0x61, 0x5e, 0xfc, 0x50, 0x74, 0xc5, 0xcd, 0x20, 0x63, 0x2b, 0x6e, 0x06, 0x2a, 0x95, - 0xb9, 0x10, 0xaa, 0xbe, 0x0b, 0xf3, 0x40, 0xa6, 0x59, 0x1c, 0x52, 0x99, 0x0b, 0x4b, 0x6d, 0x6d, - 0x17, 0xe6, 0x81, 0xb5, 0x96, 0xc5, 0x81, 0x5c, 0x85, 0x52, 0xad, 0xb6, 0xa8, 0x75, 0x2d, 0xa5, - 0x11, 0xf3, 0x96, 0x45, 0xe8, 0x7c, 0x9f, 0x26, 0xf0, 0xcc, 0x0c, 0x9a, 0x6d, 0xe9, 0xae, 0x67, - 0x36, 0x5c, 0x1c, 0x31, 0xfe, 0x08, 0x31, 0xa2, 0x66, 0x50, 0x1a, 0x0d, 0x33, 0x83, 0xd2, 0xe0, - 0xcc, 0x5e, 0x9c, 0xd1, 0x5d, 0x57, 0xb7, 0x0c, 0x47, 0x9f, 0xc6, 0x65, 0x82, 0xc6, 0x5e, 0x63, - 0x45, 0xb0, 0xcc, 0x5e, 0x8c, 0x42, 0xf0, 0xf0, 0xdd, 0x87, 0xf8, 0x66, 0xce, 0x7a, 0xec, 0xf0, - 0x3d, 0x86, 0xc7, 0xc3, 0xf7, 0x18, 0x0c, 0xed, 0x4e, 0x1f, 0xa6, 0xd1, 0xa6, 0xc9, 0x44, 0xa4, - 0x34, 0x63, 0x76, 0x67, 0x9c, 0x00, 0xed, 0xce, 0x38, 0x30, 0xd2, 0x24, 0x7f, 0xb9, 0xdd, 0xc8, - 0x68, 0x52, 0xb8, 0xca, 0x26, 0xca, 0xb0, 0xf5, 0x3b, 0x1c, 0x1c, 0x95, 0x2d, 0x4b, 0x6f, 0xdb, - 0x95, 0x69, 0x5f, 0xea, 0x66, 0x74, 0xfd, 0xce, 0x24, 0x64, 0xeb, 0x77, 0x26, 0x92, 0xcd, 0xae, - 0xfe, 0x46, 0x6b, 0x43, 0x77, 0xa8, 0x51, 0x31, 0x1d, 0x3c, 0x59, 0xdc, 0xe2, 0x5b, 0xc3, 0xf7, - 0xa3, 0xb3, 0x6b, 0x0f, 0x52, 0x36, 0xbb, 0xf6, 0x40, 0x33, 0x23, 0x2f, 0x1d, 0xad, 0x51, 0xdd, - 0x50, 0x1e, 0x44, 0x8d, 0xbc, 0x6c, 0x4a, 0x66, 0xe4, 0x65, 0x63, 0xb3, 0x3f, 0xe7, 0xbe, 0x63, - 0x7a, 0x54, 0x69, 0xed, 0xe5, 0x73, 0x90, 0x34, 0xfb, 0x73, 0x10, 0xcd, 0x36, 0x84, 0xf1, 0x0e, - 0x69, 0x47, 0x37, 0x84, 0xc9, 0x6e, 0x88, 0x97, 0x60, 0x16, 0x8b, 0x78, 0x94, 0xa7, 0x58, 0x51, - 0x8b, 0x45, 0x80, 0x99, 0xc5, 0x12, 0x3e, 0xdb, 0x8b, 0x3c, 0xc5, 0x52, 0xec, 0xe8, 0x1a, 0x2a, - 0xe3, 0xd8, 0x1a, 0x1a, 0x79, 0xb6, 0xf5, 0x5a, 0xe4, 0x9d, 0x81, 0xd2, 0x89, 0x5a, 0x1d, 0x12, - 0x8a, 0x59, 0x1d, 0xf2, 0x8b, 0x84, 0x19, 0x38, 0x83, 0xb7, 0xe0, 0x5a, 0x37, 0xb8, 0xc7, 0xf9, - 0xe1, 0xe8, 0x67, 0xc6, 0xd0, 0xec, 0x33, 0x63, 0xa0, 0x08, 0x13, 0x31, 0x6d, 0x39, 0x19, 0x4c, - 0xc2, 0xf3, 0xc1, 0x18, 0x88, 0x2c, 0x00, 0xa9, 0x95, 0x17, 0x17, 0xaa, 0xc6, 0x8a, 0x7c, 0x45, - 0xe6, 0x46, 0x4f, 0x60, 0x93, 0x14, 0xf3, 0x7d, 0x5a, 0x4a, 0x39, 0xf2, 0x3e, 0x5c, 0x16, 0x50, - 0xf1, 0xe2, 0x1a, 0xd3, 0xfe, 0x1b, 0xc1, 0x82, 0xe0, 0x45, 0xfd, 0xd8, 0x7a, 0xd1, 0xce, 0xf7, - 0x69, 0x3d, 0x79, 0x65, 0xd7, 0x25, 0xd6, 0x87, 0xee, 0x5e, 0xea, 0x0a, 0x16, 0x89, 0x9e, 0xbc, - 0xb2, 0xeb, 0x12, 0x72, 0x7f, 0xb8, 0x97, 0xba, 0x82, 0x4e, 0xe8, 0xc9, 0x8b, 0xb8, 0x30, 0xd9, - 0x0b, 0x5f, 0x6e, 0xb5, 0x94, 0x4d, 0xac, 0xee, 0x13, 0x7b, 0xa9, 0xae, 0x8c, 0x06, 0xe7, 0x6e, - 0x1c, 0xd9, 0x2c, 0xbd, 0xdc, 0xa1, 0x56, 0x2d, 0xb2, 0x00, 0x3d, 0x8a, 0xce, 0xd2, 0x09, 0x02, - 0x36, 0x4b, 0x27, 0x80, 0x6c, 0x40, 0xc9, 0xcf, 0x55, 0x94, 0xad, 0xe8, 0x80, 0x92, 0x71, 0x6c, - 0x40, 0x45, 0x9e, 0xb6, 0x2c, 0xc3, 0xd9, 0xe5, 0x07, 0x9e, 0xee, 0x5b, 0x90, 0xae, 0xe8, 0xca, - 0x0f, 0x62, 0x97, 0x4c, 0x49, 0x12, 0xbc, 0x64, 0x4a, 0x82, 0xd9, 0x18, 0x61, 0xe0, 0xda, 0x96, - 0xd5, 0x98, 0xd3, 0xcd, 0x56, 0xd7, 0xa1, 0xca, 0xbf, 0x11, 0x1d, 0x23, 0x31, 0x34, 0x1b, 0x23, - 0x31, 0x10, 0x5b, 0xa0, 0x19, 0xa8, 0xec, 0xba, 0x66, 0xd3, 0x12, 0xfb, 0xca, 0x6e, 0xcb, 0x53, - 0xfe, 0xcd, 0xe8, 0x02, 0x9d, 0x46, 0xc3, 0x16, 0xe8, 0x34, 0x38, 0x9e, 0x3a, 0xb1, 0x5e, 0x60, - 0x8b, 0x87, 0x7c, 0x57, 0xf9, 0x6f, 0xc5, 0x4e, 0x9d, 0x52, 0x68, 0xf0, 0xd4, 0x29, 0x05, 0xce, - 0xd6, 0x47, 0x6e, 0x93, 0x2d, 0x98, 0xc1, 0x5d, 0xf5, 0xbf, 0x1d, 0x5d, 0x1f, 0xe3, 0x78, 0xb6, - 0x3e, 0xc6, 0x61, 0x51, 0x3e, 0xa2, 0x0b, 0xfe, 0x9d, 0x2c, 0x3e, 0x81, 0xfc, 0x13, 0x65, 0xc8, - 0x2d, 0x99, 0x8f, 0x18, 0x29, 0x3f, 0x92, 0xcb, 0x62, 0x14, 0x0c, 0x8f, 0x44, 0xa1, 0x28, 0x23, - 0x8d, 0x3e, 0x34, 0xe9, 0xa6, 0xf2, 0xa5, 0x4c, 0x46, 0x9c, 0x20, 0xca, 0x88, 0xc3, 0xc8, 0x7b, - 0x70, 0x21, 0x84, 0x2d, 0xd2, 0xf6, 0x5a, 0x30, 0x33, 0xfd, 0x68, 0x2e, 0x6a, 0x06, 0xa7, 0x93, - 0x31, 0x33, 0x38, 0x1d, 0x93, 0xc6, 0x5a, 0x88, 0xee, 0xdf, 0xdd, 0x85, 0x75, 0x20, 0xc1, 0x0c, - 0x06, 0x69, 0xac, 0x85, 0x34, 0x7f, 0x6c, 0x17, 0xd6, 0x81, 0x4c, 0x33, 0x18, 0x90, 0x9f, 0xcc, - 0xc1, 0x95, 0x74, 0x54, 0xb9, 0xd5, 0x9a, 0xb3, 0x9d, 0x10, 0xa7, 0xfc, 0xa9, 0x5c, 0xf4, 0xa0, - 0x61, 0x6f, 0xc5, 0xe6, 0xfb, 0xb4, 0x3d, 0x56, 0x40, 0x3e, 0x03, 0xa3, 0xe5, 0xae, 0x61, 0x7a, - 0x78, 0xf1, 0xc6, 0x0c, 0xe7, 0x1f, 0xcf, 0xc5, 0xb6, 0x38, 0x32, 0x16, 0xb7, 0x38, 0x32, 0x80, - 0xdc, 0x86, 0x89, 0x1a, 0x6d, 0x74, 0x1d, 0xd3, 0xdb, 0xd2, 0x68, 0xc7, 0x76, 0x3c, 0xc6, 0xe3, - 0x4f, 0xe7, 0xa2, 0x93, 0x58, 0x82, 0x82, 0x4d, 0x62, 0x09, 0x20, 0xb9, 0x97, 0xb8, 0x95, 0x17, - 0x9d, 0xf9, 0x13, 0xb9, 0x9e, 0xd7, 0xf2, 0x41, 0x5f, 0xa6, 0x17, 0x27, 0x2b, 0xb1, 0x5b, 0x74, - 0xc1, 0xf5, 0x27, 0x73, 0x3d, 0xae, 0xd1, 0xa5, 0x19, 0x2e, 0x09, 0x66, 0x1c, 0x53, 0x32, 0xc0, - 0x2b, 0x7f, 0x26, 0xd7, 0xe3, 0xda, 0x3b, 0xe4, 0x98, 0x96, 0x3c, 0xfe, 0x15, 0xee, 0x29, 0x22, - 0x18, 0xfd, 0x54, 0x2e, 0xe9, 0x2a, 0x12, 0x94, 0x97, 0x08, 0x59, 0xb1, 0xbb, 0x6e, 0xa0, 0xf4, - 0x5f, 0xce, 0x25, 0x7d, 0xf3, 0xc2, 0x62, 0xe1, 0x2f, 0x42, 0xe1, 0xd2, 0xec, 0x23, 0x8f, 0x3a, - 0x96, 0xde, 0xc2, 0xee, 0xac, 0x79, 0xb6, 0xa3, 0x37, 0xe9, 0xac, 0xa5, 0xaf, 0xb5, 0xa8, 0xf2, - 0xd3, 0xb9, 0xa8, 0x05, 0x9b, 0x4d, 0xca, 0x2c, 0xd8, 0x6c, 0x2c, 0xd9, 0x80, 0x27, 0xd3, 0xb0, - 0x15, 0xd3, 0xc5, 0x7a, 0xbe, 0x92, 0x8b, 0x9a, 0xb0, 0x3d, 0x68, 0x99, 0x09, 0xdb, 0x03, 0x4d, - 0x6e, 0xc0, 0xd0, 0xb4, 0xed, 0x4f, 0xbf, 0x7f, 0x36, 0xe6, 0x0c, 0x19, 0x60, 0xe6, 0xfb, 0xb4, - 0x90, 0x4c, 0x94, 0x11, 0x83, 0xfa, 0xab, 0xc9, 0x32, 0xe1, 0xe5, 0x53, 0xf0, 0x43, 0x94, 0x11, - 0xe2, 0xfe, 0xf7, 0x92, 0x65, 0xc2, 0x3b, 0xae, 0xe0, 0x07, 0x9b, 0x49, 0x78, 0x8d, 0x8b, 0x73, - 0x65, 0x66, 0xb7, 0xcd, 0x6c, 0xe8, 0xad, 0x16, 0xb5, 0x9a, 0x54, 0xf9, 0x5a, 0x6c, 0x26, 0x49, - 0x27, 0x63, 0x33, 0x49, 0x3a, 0x86, 0xfc, 0x20, 0x5c, 0xbc, 0xa7, 0xb7, 0x4c, 0x23, 0xc4, 0xf9, - 0xf9, 0xc0, 0x95, 0x9f, 0xc9, 0x45, 0x77, 0xd3, 0x19, 0x74, 0x6c, 0x37, 0x9d, 0x81, 0x22, 0x8b, - 0x40, 0x70, 0x19, 0x0d, 0x66, 0x0b, 0xb6, 0x3e, 0x2b, 0xff, 0x7e, 0x2e, 0x6a, 0xa7, 0x26, 0x49, - 0x98, 0x9d, 0x9a, 0x84, 0x92, 0x7a, 0x76, 0x6a, 0x10, 0xe5, 0x67, 0x73, 0xd1, 0xd3, 0x9a, 0x2c, - 0xc2, 0xf9, 0x3e, 0x2d, 0x3b, 0xbf, 0xc8, 0x2d, 0x18, 0xaf, 0xad, 0x54, 0xe7, 0xe6, 0x66, 0x6b, - 0xf7, 0xaa, 0x15, 0x7c, 0xe8, 0x60, 0x28, 0x7f, 0x2e, 0xb6, 0x62, 0xc5, 0x09, 0xd8, 0x8a, 0x15, - 0x87, 0x91, 0x37, 0x61, 0x84, 0xb5, 0x9f, 0x0d, 0x18, 0xfc, 0xe4, 0x9f, 0xcb, 0x45, 0xcd, 0x29, - 0x19, 0xc9, 0xcc, 0x29, 0xf9, 0x37, 0xa9, 0xc1, 0x39, 0x26, 0xc5, 0x15, 0x87, 0xae, 0x53, 0x87, - 0x5a, 0x0d, 0x7f, 0x4c, 0xff, 0x7c, 0x2e, 0x6a, 0x65, 0xa4, 0x11, 0x31, 0x2b, 0x23, 0x0d, 0x4e, - 0x1e, 0xc0, 0xe5, 0xf8, 0x49, 0x90, 0xfc, 0xec, 0x54, 0xf9, 0xf3, 0xb9, 0x98, 0x31, 0xdc, 0x83, - 0x18, 0x8d, 0xe1, 0x1e, 0x78, 0x62, 0xc1, 0x53, 0xe2, 0x58, 0x45, 0x38, 0x5c, 0xc6, 0x6b, 0xfb, - 0x0b, 0xbc, 0xb6, 0x8f, 0x87, 0x0e, 0x81, 0x3d, 0xa8, 0xe7, 0xfb, 0xb4, 0xde, 0xec, 0x98, 0x9e, - 0x25, 0x13, 0x60, 0x28, 0x7f, 0x31, 0x97, 0xee, 0x91, 0x12, 0x71, 0x53, 0x4e, 0xcb, 0x9c, 0xf1, - 0x5e, 0x56, 0xfa, 0x06, 0xe5, 0x2f, 0xc5, 0xc6, 0x5b, 0x3a, 0x19, 0x1b, 0x6f, 0x19, 0xf9, 0x1f, - 0x6e, 0xc3, 0x04, 0x57, 0xea, 0x15, 0x1d, 0x87, 0xa1, 0xd5, 0xa4, 0x86, 0xf2, 0x1f, 0xc4, 0x56, - 0xbb, 0x04, 0x05, 0xba, 0xf6, 0xc4, 0x81, 0x6c, 0xea, 0xae, 0x75, 0x74, 0xcb, 0xc2, 0x63, 0x56, - 0xe5, 0x3f, 0x8c, 0x4d, 0xdd, 0x21, 0x0a, 0x1d, 0x77, 0x83, 0x5f, 0x4c, 0x13, 0x7a, 0xa5, 0x3e, - 0x52, 0xfe, 0x72, 0x4c, 0x13, 0x7a, 0x11, 0x33, 0x4d, 0xe8, 0x99, 0x47, 0xe9, 0x5e, 0xc6, 0x13, - 0x70, 0xe5, 0xeb, 0xb1, 0x15, 0x39, 0x95, 0x8a, 0xad, 0xc8, 0xe9, 0x2f, 0xc8, 0xef, 0x65, 0x3c, - 0x9f, 0x56, 0x7e, 0xa1, 0x37, 0xdf, 0x70, 0xa5, 0x4f, 0x7f, 0x7d, 0x7d, 0x2f, 0xe3, 0xe9, 0xb1, - 0xf2, 0x57, 0x7a, 0xf3, 0x0d, 0x1d, 0xfb, 0xd2, 0x5f, 0x2e, 0xd7, 0xb3, 0x9f, 0xed, 0x2a, 0x7f, - 0x35, 0x3e, 0x75, 0x65, 0x10, 0xe2, 0xd4, 0x95, 0xf5, 0xf6, 0x77, 0x0d, 0x9e, 0xe0, 0x1a, 0x72, - 0xcb, 0xd1, 0x3b, 0x1b, 0x35, 0xea, 0x79, 0xa6, 0xd5, 0xf4, 0x77, 0x62, 0x7f, 0x2d, 0x17, 0x3b, - 0x1e, 0xcb, 0xa2, 0xc4, 0xe3, 0xb1, 0x2c, 0x24, 0x53, 0xde, 0xc4, 0x03, 0x5d, 0xe5, 0xaf, 0xc7, - 0x94, 0x37, 0x41, 0xc1, 0x94, 0x37, 0xf9, 0xae, 0xf7, 0x76, 0xca, 0x3b, 0x54, 0xe5, 0x3f, 0xca, - 0xe6, 0x15, 0xb4, 0x2f, 0xe5, 0xf9, 0xea, 0xed, 0x94, 0xe7, 0x96, 0xca, 0x7f, 0x9c, 0xcd, 0x2b, - 0xf4, 0x41, 0x4a, 0xbe, 0xd2, 0x7c, 0x0f, 0x2e, 0xf0, 0xd9, 0x7c, 0x8e, 0x1a, 0x34, 0xf2, 0xa1, - 0xbf, 0x18, 0x1b, 0xfb, 0xe9, 0x64, 0x78, 0xe4, 0x9e, 0x8a, 0x49, 0x63, 0x2d, 0xda, 0xfa, 0x37, - 0x76, 0x61, 0x1d, 0x6e, 0x08, 0xd2, 0x31, 0x6c, 0xbd, 0x91, 0x1f, 0xbf, 0x29, 0xbf, 0x14, 0x5b, - 0x6f, 0x64, 0x24, 0xba, 0x73, 0xc8, 0x2f, 0xe5, 0xde, 0x8c, 0x3e, 0xf4, 0x52, 0xfe, 0x66, 0x6a, - 0xe1, 0xa0, 0x03, 0xa2, 0xaf, 0xc2, 0xde, 0x8c, 0x3e, 0x6a, 0x52, 0x7e, 0x39, 0xb5, 0x70, 0xf0, - 0x01, 0xd1, 0x17, 0x50, 0x6c, 0x8b, 0xd4, 0xf5, 0x6c, 0xce, 0x2a, 0x32, 0x3d, 0xfc, 0xad, 0xf8, - 0x16, 0x29, 0x95, 0x0c, 0xb7, 0x48, 0xa9, 0x98, 0x34, 0xd6, 0xe2, 0xf3, 0x7e, 0x65, 0x17, 0xd6, - 0xd2, 0xc6, 0x2e, 0x15, 0x93, 0xc6, 0x5a, 0x7c, 0xfc, 0x37, 0x76, 0x61, 0x2d, 0x6d, 0xec, 0x52, - 0x31, 0xcc, 0x1c, 0x0b, 0x31, 0xf7, 0xa8, 0xe3, 0x86, 0xea, 0xf7, 0x9f, 0xc4, 0xcc, 0xb1, 0x0c, - 0x3a, 0x66, 0x8e, 0x65, 0xa0, 0x52, 0xb9, 0x0b, 0xa1, 0xfc, 0xea, 0x6e, 0xdc, 0xc3, 0x7b, 0x99, - 0x0c, 0x54, 0x2a, 0x77, 0x21, 0x97, 0xbf, 0xbd, 0x1b, 0xf7, 0xf0, 0x62, 0x26, 0x03, 0xc5, 0x8c, - 0xa2, 0x9a, 0xa7, 0x7b, 0x66, 0x63, 0xde, 0x76, 0x3d, 0x69, 0x91, 0xff, 0x3b, 0x31, 0xa3, 0x28, - 0x8d, 0x88, 0x19, 0x45, 0x69, 0xf0, 0x24, 0x53, 0x21, 0x8d, 0x5f, 0xeb, 0xc9, 0x34, 0xb4, 0xb4, - 0xd2, 0xe0, 0x49, 0xa6, 0x42, 0x08, 0xff, 0x69, 0x4f, 0xa6, 0xa1, 0xa7, 0x7c, 0x1a, 0x9c, 0x59, - 0xa6, 0x33, 0x8e, 0xbd, 0x69, 0xdd, 0xa6, 0x9b, 0xb4, 0x25, 0x3e, 0xfd, 0xd7, 0x63, 0x96, 0x69, - 0x9c, 0x00, 0x6f, 0x51, 0x62, 0xb0, 0x28, 0x23, 0xf1, 0xb9, 0xbf, 0x91, 0xc9, 0x28, 0x3c, 0x26, - 0x8a, 0xc3, 0xa2, 0x8c, 0xc4, 0x27, 0xfe, 0x66, 0x26, 0xa3, 0xf0, 0x98, 0x28, 0x0e, 0x23, 0x65, - 0x18, 0xc3, 0xb7, 0x12, 0xba, 0xeb, 0x7b, 0x7e, 0xfe, 0x4e, 0x2e, 0x7a, 0xeb, 0x15, 0x45, 0xcf, - 0xf7, 0x69, 0xb1, 0x02, 0x32, 0x0b, 0xf1, 0x49, 0xdf, 0xca, 0x60, 0x11, 0xfa, 0x3b, 0x46, 0x21, - 0x32, 0x0b, 0xf1, 0x31, 0xff, 0x59, 0x06, 0x8b, 0xd0, 0xe1, 0x31, 0x0a, 0x21, 0x9f, 0x86, 0xe1, - 0xda, 0xdc, 0xea, 0x8a, 0x9f, 0x9e, 0xef, 0xef, 0xe6, 0x62, 0xaf, 0x8a, 0x42, 0x1c, 0xbe, 0x2a, - 0x0a, 0x7f, 0x4e, 0x0f, 0x40, 0x3f, 0x1e, 0xa5, 0xde, 0x2e, 0x0d, 0x7e, 0x33, 0x37, 0xfe, 0x5b, - 0xb9, 0xdb, 0xa5, 0xc1, 0xdf, 0xca, 0x8d, 0xff, 0x36, 0xfb, 0xff, 0xb7, 0x73, 0xe3, 0xbf, 0x93, - 0xd3, 0x9e, 0x08, 0x87, 0x45, 0xb9, 0x49, 0x2d, 0x6f, 0xa5, 0xa5, 0x8b, 0x41, 0x9d, 0x8a, 0xe2, - 0x3f, 0x53, 0x51, 0x22, 0x15, 0xd6, 0xd7, 0x73, 0x30, 0x52, 0xf3, 0x1c, 0xaa, 0xb7, 0x45, 0x64, - 0xb9, 0x4b, 0x30, 0xc8, 0x9d, 0x9f, 0xfd, 0x97, 0xda, 0x5a, 0xf0, 0x9b, 0x5c, 0x81, 0xb1, 0x05, - 0xdd, 0xf5, 0xb0, 0x89, 0x55, 0xcb, 0xa0, 0x8f, 0xf0, 0xe1, 0x5f, 0x41, 0x8b, 0x41, 0xc9, 0x02, - 0xa7, 0xe3, 0xe5, 0x30, 0x98, 0x68, 0x61, 0xd7, 0x80, 0x6a, 0x83, 0xdf, 0xde, 0x9e, 0xec, 0xc3, - 0xf8, 0x69, 0xb1, 0xb2, 0xea, 0xef, 0xe7, 0x20, 0xe1, 0x96, 0x7d, 0xf0, 0x08, 0x0a, 0xcb, 0x70, - 0x26, 0x16, 0xc0, 0x56, 0xbc, 0x5e, 0xdc, 0x63, 0x7c, 0xdb, 0x78, 0x69, 0xf2, 0x89, 0xe0, 0xd5, - 0xdc, 0x5d, 0x6d, 0x41, 0x04, 0xcb, 0xc3, 0x34, 0x0f, 0x5d, 0xa7, 0xa5, 0x49, 0x28, 0x11, 0x0c, - 0xe9, 0x7b, 0xe3, 0x61, 0x74, 0x4e, 0x72, 0x45, 0x84, 0x73, 0xc8, 0x85, 0x21, 0xf6, 0x62, 0x49, - 0xe5, 0x79, 0xf8, 0x86, 0xcf, 0xc0, 0x48, 0xb5, 0xdd, 0xa1, 0x8e, 0x6b, 0x5b, 0xba, 0x67, 0x3b, - 0xe2, 0x35, 0x3c, 0x86, 0x5f, 0x33, 0x25, 0xb8, 0x1c, 0x12, 0x4c, 0xa6, 0x27, 0xd7, 0xfc, 0x4c, - 0x75, 0x05, 0x8c, 0x8b, 0x8a, 0x4f, 0x5a, 0xe3, 0x89, 0xca, 0x39, 0x05, 0x23, 0xbd, 0xeb, 0xea, - 0xf8, 0xbe, 0x32, 0x20, 0xed, 0x32, 0x80, 0x4c, 0x8a, 0x14, 0xe4, 0x05, 0x28, 0xe1, 0x7d, 0x94, - 0x8b, 0x19, 0x28, 0x45, 0xe0, 0xbf, 0x16, 0x42, 0xe4, 0x30, 0x6b, 0x9c, 0x86, 0xdc, 0x81, 0xf1, - 0xf0, 0xb2, 0xfd, 0x96, 0x63, 0x77, 0x3b, 0x7e, 0xce, 0x19, 0x4c, 0xf0, 0xfe, 0x20, 0xc0, 0xd5, - 0x9b, 0x88, 0x94, 0x58, 0x24, 0x0a, 0x92, 0x79, 0x38, 0x13, 0xc2, 0x98, 0x88, 0xfc, 0x5c, 0x57, - 0x98, 0x67, 0x54, 0xe2, 0xc5, 0xc4, 0x19, 0xc9, 0x33, 0x1a, 0x2b, 0x46, 0xaa, 0x30, 0xe0, 0x47, - 0xfd, 0x1b, 0xdc, 0x55, 0x49, 0xcf, 0x8a, 0xa8, 0x7f, 0x03, 0x72, 0xbc, 0x3f, 0xbf, 0x3c, 0x99, - 0x83, 0x31, 0xcd, 0xee, 0x7a, 0x74, 0xd5, 0x16, 0xbb, 0x54, 0x11, 0x5d, 0x12, 0xdb, 0xe4, 0x30, - 0x4c, 0xdd, 0xb3, 0xfd, 0xfc, 0xf8, 0x72, 0x9e, 0xf6, 0x68, 0x29, 0xb2, 0x04, 0x13, 0x09, 0xb7, - 0x04, 0x39, 0x6b, 0xbd, 0xf4, 0x79, 0x49, 0x66, 0xc9, 0xa2, 0xe4, 0xc7, 0x73, 0x50, 0x5a, 0x75, - 0x74, 0xd3, 0x73, 0xc5, 0xd3, 0xcc, 0xf3, 0x53, 0x9b, 0x8e, 0xde, 0x61, 0xfa, 0x31, 0x85, 0x81, - 0x6f, 0xef, 0xe9, 0xad, 0x2e, 0x75, 0xa7, 0xef, 0xb3, 0xaf, 0xfb, 0x1f, 0xb6, 0x27, 0xdf, 0x6c, - 0xe2, 0xe1, 0xe7, 0x54, 0xc3, 0x6e, 0x5f, 0x6f, 0x3a, 0xfa, 0x43, 0xd3, 0x43, 0x13, 0x53, 0x6f, - 0x5d, 0xf7, 0x68, 0x0b, 0xcf, 0x58, 0xaf, 0xeb, 0x1d, 0xf3, 0x3a, 0x06, 0x58, 0xbf, 0x1e, 0x70, - 0xe2, 0x35, 0x30, 0x15, 0xf0, 0xf0, 0x2f, 0x59, 0x05, 0x38, 0x8e, 0x2c, 0x01, 0x88, 0x4f, 0x2d, - 0x77, 0x3a, 0xe2, 0x9d, 0xa7, 0x74, 0x32, 0xe9, 0x63, 0xb8, 0x62, 0x07, 0x02, 0xd3, 0x3b, 0x52, - 0x50, 0x61, 0x4d, 0xe2, 0xc0, 0xb4, 0x60, 0x55, 0xb4, 0xc8, 0x17, 0xd3, 0x68, 0x28, 0x71, 0xbf, - 0xb1, 0x29, 0x42, 0x8a, 0x17, 0x23, 0x6b, 0x70, 0x46, 0xf0, 0x0d, 0x52, 0x90, 0x8c, 0x45, 0x67, - 0x85, 0x18, 0x9a, 0x2b, 0x6d, 0xd0, 0x46, 0x43, 0x80, 0xe5, 0x3a, 0x62, 0x25, 0xc8, 0x74, 0x98, - 0x32, 0x79, 0x49, 0x6f, 0x53, 0x57, 0x39, 0x83, 0x1a, 0x7b, 0x79, 0x67, 0x7b, 0x52, 0xf1, 0xcb, - 0x63, 0x00, 0x4c, 0x59, 0x74, 0xd1, 0x22, 0x32, 0x0f, 0xae, 0xf5, 0xe3, 0x29, 0x3c, 0xe2, 0x3a, - 0x1f, 0x2d, 0x42, 0x66, 0x60, 0x34, 0x78, 0x66, 0x72, 0xf7, 0x6e, 0xb5, 0x82, 0x0f, 0x49, 0x45, - 0x0c, 0xd4, 0x58, 0x92, 0x10, 0x99, 0x49, 0xa4, 0x8c, 0x14, 0x9b, 0x83, 0xbf, 0x2c, 0x8d, 0xc5, - 0xe6, 0xe8, 0xa4, 0xc4, 0xe6, 0x58, 0x21, 0x6f, 0xc3, 0x70, 0xf9, 0x7e, 0x4d, 0xc4, 0x1c, 0x71, - 0x95, 0xb3, 0x61, 0xc6, 0x29, 0x7d, 0xd3, 0xad, 0xfb, 0xf1, 0x49, 0xe4, 0xa6, 0xcb, 0xf4, 0x64, - 0x16, 0xc6, 0x22, 0x9e, 0x6a, 0xae, 0x72, 0x0e, 0x39, 0x60, 0xcb, 0x75, 0xc4, 0xd4, 0x1d, 0x81, - 0x92, 0x87, 0x57, 0xb4, 0x10, 0xd3, 0x9a, 0x8a, 0xe9, 0x62, 0xf6, 0x1e, 0x8d, 0x62, 0x78, 0x13, - 0x7c, 0x96, 0x3a, 0xc8, 0xb5, 0xc6, 0x10, 0xa8, 0xba, 0xc3, 0x71, 0x72, 0x8f, 0xc6, 0x8a, 0x91, - 0xf7, 0x81, 0x60, 0xbe, 0x1f, 0x6a, 0xf8, 0x17, 0x97, 0xd5, 0x8a, 0xab, 0x5c, 0xc0, 0x00, 0xe0, - 0x24, 0x1e, 0x4e, 0xa1, 0x5a, 0x99, 0xbe, 0x22, 0xa6, 0x8f, 0xa7, 0x75, 0x5e, 0xaa, 0xee, 0x87, - 0x52, 0xa8, 0x9b, 0x91, 0x64, 0xc8, 0x29, 0x5c, 0xc9, 0x26, 0x5c, 0x5c, 0x71, 0xe8, 0x43, 0xd3, - 0xee, 0xba, 0xfe, 0xf2, 0xe1, 0xcf, 0x5b, 0x17, 0x77, 0x9d, 0xb7, 0x9e, 0x15, 0x15, 0x9f, 0xef, - 0x38, 0xf4, 0x61, 0xdd, 0x0f, 0xfb, 0x1c, 0x89, 0x5a, 0x9a, 0xc5, 0x1d, 0x53, 0x3a, 0x7f, 0xd0, - 0x75, 0xa8, 0x80, 0x9b, 0xd4, 0x55, 0x94, 0x70, 0xaa, 0xe5, 0x91, 0x6a, 0xcc, 0x00, 0x17, 0x49, - 0xe9, 0x1c, 0x2d, 0x46, 0x34, 0x20, 0xb7, 0x66, 0xfc, 0x4b, 0xec, 0x72, 0x83, 0x27, 0xbe, 0x55, - 0x9e, 0x40, 0x66, 0x2a, 0x13, 0x4b, 0xb3, 0x11, 0x84, 0x80, 0xaf, 0xeb, 0x02, 0x2f, 0x8b, 0x25, - 0x59, 0x9a, 0x2c, 0xc0, 0xf8, 0x8a, 0x83, 0x47, 0x6a, 0x77, 0xe8, 0xd6, 0x8a, 0xdd, 0x32, 0x1b, - 0x5b, 0xf8, 0x3a, 0x56, 0x4c, 0x95, 0x1d, 0x8e, 0xab, 0x3f, 0xa0, 0x5b, 0xf5, 0x0e, 0x62, 0xe5, - 0x65, 0x25, 0x5e, 0x52, 0x0e, 0xc9, 0xfc, 0xe4, 0xde, 0x42, 0x32, 0x53, 0x18, 0x17, 0x57, 0xe0, - 0x8f, 0x3c, 0x6a, 0xb1, 0xa5, 0xde, 0x15, 0x2f, 0x61, 0x95, 0xd8, 0x95, 0x79, 0x80, 0xe7, 0x53, - 0x87, 0x18, 0x65, 0x34, 0x00, 0xcb, 0x0d, 0x8b, 0x17, 0x49, 0xc6, 0x2d, 0x7e, 0xea, 0x00, 0x71, - 0x8b, 0xff, 0x4e, 0x41, 0x9e, 0x7f, 0xc9, 0x65, 0x28, 0x4a, 0x69, 0x85, 0x30, 0x28, 0x2b, 0x86, - 0x60, 0x2f, 0x8a, 0x58, 0xd3, 0x43, 0xc2, 0x76, 0x09, 0xa2, 0xef, 0x60, 0x1e, 0xc9, 0x30, 0x50, - 0xa7, 0x16, 0x12, 0x60, 0x0e, 0xbf, 0xee, 0x5a, 0xcb, 0x6c, 0x60, 0x60, 0xfe, 0x82, 0x14, 0x6e, - 0x03, 0xa1, 0x3c, 0x2e, 0xbf, 0x44, 0x42, 0x6e, 0xc0, 0xb0, 0x7f, 0x94, 0x1b, 0x06, 0x25, 0xc6, - 0x78, 0xed, 0x62, 0xb6, 0x16, 0xe1, 0xe0, 0x25, 0x22, 0xf2, 0x06, 0x40, 0x38, 0x1d, 0x08, 0x4b, - 0x0b, 0x97, 0x0a, 0x79, 0xf6, 0x90, 0x97, 0x8a, 0x90, 0x9a, 0x4d, 0x9c, 0xb2, 0x3a, 0xfa, 0x59, - 0x4b, 0x71, 0xe2, 0x8c, 0xe8, 0xb0, 0xac, 0x20, 0xd1, 0x22, 0x64, 0x19, 0x26, 0x12, 0x1a, 0x28, - 0x42, 0x18, 0x63, 0xe6, 0xfa, 0x14, 0xf5, 0x95, 0x17, 0xe6, 0x44, 0x59, 0xf2, 0x1c, 0x14, 0xee, - 0x6a, 0x55, 0x11, 0x46, 0x95, 0x47, 0xe0, 0x8d, 0xc4, 0x58, 0x62, 0x58, 0xf5, 0x47, 0xf3, 0x89, - 0xb5, 0x89, 0x49, 0x4f, 0xb0, 0x92, 0x7a, 0x10, 0xa5, 0xe7, 0xd7, 0xcf, 0xa5, 0x27, 0x11, 0x91, - 0xab, 0x30, 0xb8, 0xc2, 0x66, 0x86, 0x86, 0xdd, 0x12, 0xfd, 0x89, 0x01, 0xb1, 0x3a, 0x02, 0xa6, - 0x05, 0x58, 0x72, 0x43, 0x4a, 0xb6, 0x2b, 0x45, 0x26, 0xf7, 0x93, 0xed, 0xc6, 0x43, 0x74, 0x63, - 0xda, 0xdd, 0x1b, 0xb1, 0xe4, 0x5d, 0xa2, 0x4c, 0xca, 0xba, 0x18, 0x26, 0xeb, 0x0a, 0xac, 0xd2, - 0xfe, 0xdd, 0xac, 0x52, 0xf5, 0xef, 0xe5, 0x92, 0xe3, 0x8c, 0xdc, 0x4c, 0x06, 0x09, 0xc6, 0x45, - 0x28, 0x00, 0xca, 0xb5, 0x06, 0xe1, 0x82, 0x23, 0xe1, 0x7e, 0xf3, 0x07, 0x0e, 0xf7, 0x5b, 0xd8, - 0x67, 0xb8, 0x5f, 0xf5, 0xff, 0x2d, 0xf6, 0x74, 0xd9, 0x3e, 0x96, 0xb0, 0x70, 0xaf, 0xb3, 0x9d, - 0x15, 0xab, 0xbd, 0xec, 0x26, 0xf6, 0x07, 0xdc, 0x23, 0xb5, 0xae, 0xf3, 0xa1, 0xe5, 0x6a, 0x51, - 0x4a, 0xf2, 0x0e, 0x8c, 0xf8, 0x1f, 0x80, 0x61, 0xa4, 0xa5, 0xf0, 0xc7, 0xc1, 0xaa, 0x16, 0x0b, - 0xb8, 0x1c, 0x29, 0x40, 0x5e, 0x81, 0x21, 0xb4, 0x69, 0x3a, 0x7a, 0xc3, 0x8f, 0x31, 0xce, 0x83, - 0x92, 0xfb, 0x40, 0x39, 0xf4, 0x59, 0x40, 0x49, 0xbe, 0x00, 0x25, 0x91, 0x68, 0x83, 0xe7, 0xa1, - 0xbf, 0xbe, 0x07, 0x1f, 0xf7, 0x29, 0x39, 0xc9, 0x06, 0xdf, 0xa5, 0x20, 0x20, 0xb2, 0x4b, 0xe1, - 0xf9, 0x35, 0x56, 0xe1, 0xec, 0x8a, 0x43, 0x0d, 0x7c, 0x4d, 0x31, 0xfb, 0xa8, 0xe3, 0x88, 0x14, - 0x28, 0x7c, 0x94, 0xe3, 0x22, 0xd5, 0xf1, 0xd1, 0x6c, 0xf9, 0x14, 0x78, 0x39, 0xd0, 0x71, 0x4a, - 0x71, 0x66, 0xb9, 0xf0, 0x96, 0xdc, 0xa1, 0x5b, 0x9b, 0xb6, 0x63, 0xf0, 0x2c, 0x21, 0x62, 0xfe, - 0x16, 0x82, 0x7e, 0x20, 0x50, 0xb2, 0xe5, 0x12, 0x2d, 0x74, 0xe9, 0x75, 0x18, 0x3e, 0x68, 0xa2, - 0x8a, 0x5f, 0xcd, 0x67, 0x3c, 0x7e, 0x7a, 0x7c, 0x73, 0x05, 0x06, 0x09, 0xac, 0xfb, 0x33, 0x12, - 0x58, 0x7f, 0x37, 0x9f, 0xf1, 0xb2, 0xeb, 0xb1, 0x4e, 0x34, 0x1b, 0x08, 0x23, 0x9a, 0x68, 0x36, - 0xcc, 0xf1, 0x6b, 0x1a, 0x9a, 0x4c, 0x14, 0x4b, 0x49, 0x5d, 0xda, 0x35, 0x25, 0xf5, 0x2f, 0x16, - 0x7a, 0xbd, 0x7c, 0x3b, 0x95, 0xfd, 0x7e, 0x64, 0x7f, 0x03, 0x86, 0x03, 0xc9, 0x56, 0x2b, 0x68, - 0xf4, 0x8c, 0x06, 0x69, 0x71, 0x38, 0x18, 0xcb, 0x48, 0x44, 0xe4, 0x1a, 0x6f, 0x6b, 0xcd, 0xfc, - 0x80, 0x27, 0x68, 0x18, 0x15, 0xa1, 0xf7, 0x75, 0x4f, 0xaf, 0xbb, 0xe6, 0x07, 0x54, 0x0b, 0xd0, - 0xea, 0x7f, 0x9e, 0x4f, 0x7d, 0x3e, 0x78, 0xda, 0x47, 0xfb, 0xe8, 0xa3, 0x14, 0x21, 0xf2, 0x87, - 0x8f, 0xa7, 0x42, 0xdc, 0x87, 0x10, 0xff, 0x24, 0x9f, 0xfa, 0x4c, 0xf4, 0x54, 0x88, 0xfb, 0x99, - 0x2d, 0x5e, 0x80, 0x21, 0xcd, 0xde, 0x74, 0x67, 0x70, 0x63, 0xc3, 0xe7, 0x0a, 0x9c, 0xa8, 0x1d, - 0x7b, 0xd3, 0xad, 0xe3, 0x96, 0x45, 0x0b, 0x09, 0xd4, 0xef, 0xe5, 0x7b, 0x3c, 0xa4, 0x3d, 0x15, - 0xfc, 0x87, 0xb9, 0x44, 0xfe, 0x46, 0x3e, 0xf2, 0x50, 0xf7, 0xf1, 0x15, 0xf6, 0x75, 0x80, 0x5a, - 0x63, 0x83, 0xb6, 0x75, 0x29, 0xc9, 0x15, 0x9e, 0x3b, 0xb8, 0x08, 0x15, 0xc9, 0x91, 0x43, 0x12, - 0xf5, 0x9b, 0xf9, 0xd8, 0x4b, 0xe5, 0x53, 0xd9, 0xed, 0x59, 0x76, 0x81, 0xd6, 0x89, 0xc7, 0xd7, - 0xa7, 0x92, 0xdb, 0xab, 0xe4, 0x7e, 0x22, 0x1f, 0x7b, 0xa7, 0xfe, 0xd8, 0xca, 0x8e, 0x0d, 0xc0, - 0xe4, 0xfb, 0xf9, 0xc7, 0x56, 0x93, 0x5e, 0x80, 0x21, 0x21, 0x87, 0x60, 0xa9, 0xe0, 0xf3, 0x3e, - 0x07, 0xe2, 0x29, 0x6b, 0x40, 0xa0, 0xfe, 0xa9, 0x3c, 0x44, 0xe3, 0x07, 0x3c, 0xa6, 0x3a, 0xf4, - 0x1b, 0xf9, 0x68, 0xe4, 0x84, 0xc7, 0x57, 0x7f, 0xa6, 0x00, 0x6a, 0xdd, 0xb5, 0x86, 0x08, 0xbc, - 0xdb, 0x2f, 0x1d, 0xd3, 0x07, 0x50, 0x4d, 0xa2, 0x50, 0xff, 0xbf, 0x7c, 0x6a, 0x38, 0x87, 0xc7, - 0x57, 0x80, 0x2f, 0xe3, 0xa9, 0x78, 0xc3, 0x0a, 0x27, 0x72, 0x3c, 0x84, 0x64, 0xe3, 0x2f, 0x91, - 0x19, 0xd1, 0x27, 0x24, 0x9f, 0x4e, 0x31, 0xd7, 0x30, 0x6f, 0x43, 0x68, 0xae, 0xc9, 0xd7, 0x10, - 0x92, 0xe1, 0xf6, 0x7b, 0xf9, 0xdd, 0xa2, 0x5f, 0x3c, 0xce, 0xab, 0xea, 0xc0, 0x8a, 0xbe, 0x85, - 0x51, 0x1a, 0x59, 0x4f, 0x8c, 0xf0, 0xbc, 0x7d, 0x1d, 0x0e, 0x92, 0xef, 0xde, 0x04, 0x95, 0xfa, - 0xcf, 0xfa, 0xd3, 0x43, 0x2f, 0x3c, 0xbe, 0x22, 0xbc, 0x0c, 0xc5, 0x15, 0xdd, 0xdb, 0x10, 0x9a, - 0x8c, 0x57, 0x7a, 0x1d, 0xdd, 0xdb, 0xd0, 0x10, 0x4a, 0xae, 0xc1, 0xa0, 0xa6, 0x6f, 0xf2, 0x33, - 0xcf, 0x52, 0x98, 0x53, 0xd1, 0xd1, 0x37, 0xeb, 0xfc, 0xdc, 0x33, 0x40, 0x13, 0x35, 0xc8, 0xe9, - 0xc9, 0x4f, 0xbe, 0x31, 0xa1, 0x1c, 0xcf, 0xe9, 0x19, 0x64, 0xf2, 0xbc, 0x0c, 0xc5, 0x69, 0xdb, - 0xd8, 0xc2, 0xeb, 0xab, 0x11, 0x5e, 0xd9, 0x9a, 0x6d, 0x6c, 0x69, 0x08, 0x25, 0x3f, 0x99, 0x83, - 0x81, 0x79, 0xaa, 0x1b, 0x6c, 0x84, 0x0c, 0xf5, 0xf2, 0x3a, 0xf9, 0xdc, 0xd1, 0x78, 0x9d, 0x4c, - 0x6c, 0xf0, 0xca, 0x64, 0x45, 0x11, 0xf5, 0x93, 0x5b, 0x30, 0x38, 0xa3, 0x7b, 0xb4, 0x69, 0x3b, - 0x5b, 0xe8, 0x47, 0x33, 0x16, 0xba, 0xef, 0x47, 0xf4, 0xc7, 0x27, 0xe2, 0x37, 0x63, 0x0d, 0xf1, - 0x4b, 0x0b, 0x0a, 0x33, 0xb1, 0xac, 0xea, 0x4e, 0x93, 0x7a, 0x22, 0x7f, 0x35, 0x8a, 0xc5, 0x43, - 0x88, 0x26, 0x30, 0xe1, 0xb1, 0xf2, 0x48, 0xfa, 0xb1, 0x32, 0x5a, 0x8f, 0xe8, 0x6b, 0x87, 0x99, - 0x34, 0x47, 0x71, 0xd1, 0xe7, 0xd6, 0x23, 0x42, 0x31, 0x91, 0xa6, 0x26, 0x91, 0xa8, 0xdf, 0xe9, - 0x87, 0xd4, 0x87, 0xda, 0xa7, 0x4a, 0x7e, 0xaa, 0xe4, 0xa1, 0x92, 0x57, 0x12, 0x4a, 0x7e, 0x29, - 0xf9, 0xf4, 0xff, 0x23, 0xaa, 0xe1, 0x3f, 0x57, 0x4c, 0x04, 0x0e, 0x79, 0xbc, 0x77, 0x97, 0xa1, - 0xf4, 0xfa, 0x77, 0x95, 0x5e, 0x30, 0x20, 0x4a, 0xbb, 0x0e, 0x88, 0x81, 0xbd, 0x0e, 0x88, 0xc1, - 0xcc, 0x01, 0x11, 0x2a, 0xc8, 0x50, 0xa6, 0x82, 0x54, 0xc5, 0xa0, 0x81, 0xde, 0xf9, 0x4b, 0x2e, - 0xef, 0x6c, 0x4f, 0x8e, 0xb1, 0xd1, 0x94, 0x9a, 0xb8, 0x04, 0x59, 0xa8, 0xbf, 0x5f, 0xec, 0x11, - 0xed, 0xe7, 0x58, 0x74, 0xe4, 0x65, 0x28, 0x94, 0x3b, 0x1d, 0xa1, 0x1f, 0x67, 0xa5, 0x40, 0x43, - 0x19, 0xa5, 0x18, 0x35, 0x79, 0x03, 0x0a, 0xe5, 0xfb, 0xb5, 0x78, 0xce, 0x92, 0xf2, 0xfd, 0x9a, - 0xf8, 0x92, 0xcc, 0xb2, 0xf7, 0x6b, 0xe4, 0xad, 0x30, 0x78, 0xe8, 0x46, 0xd7, 0x7a, 0x20, 0x36, - 0x8a, 0xc2, 0xdd, 0xd6, 0x77, 0xc7, 0x69, 0x30, 0x14, 0xdb, 0x2e, 0xc6, 0x68, 0x63, 0xda, 0x54, - 0xda, 0xbb, 0x36, 0x0d, 0xec, 0xaa, 0x4d, 0x83, 0x7b, 0xd5, 0xa6, 0xa1, 0x3d, 0x68, 0x13, 0xec, - 0xaa, 0x4d, 0xc3, 0x87, 0xd7, 0xa6, 0x0e, 0x5c, 0x4a, 0x46, 0x68, 0x0b, 0x34, 0x42, 0x03, 0x92, - 0xc4, 0x0a, 0xc7, 0x12, 0xbc, 0xfa, 0xef, 0x72, 0x6c, 0x7d, 0x13, 0xd1, 0x75, 0x97, 0xe1, 0x65, - 0xff, 0xb4, 0x64, 0x69, 0xf5, 0x57, 0xf3, 0xd9, 0x81, 0xe5, 0x4e, 0xe6, 0x14, 0xf7, 0x43, 0xa9, - 0x52, 0x2a, 0x46, 0x1f, 0xfa, 0x67, 0x4b, 0x39, 0xc6, 0x36, 0x4d, 0x66, 0xdf, 0xc8, 0x67, 0x45, - 0xbb, 0x3b, 0x94, 0xc4, 0x3e, 0x9e, 0xf4, 0x68, 0x43, 0x3f, 0x7d, 0x37, 0xea, 0xca, 0x36, 0x07, - 0x23, 0xb2, 0x10, 0x85, 0x94, 0xf6, 0x22, 0xe0, 0x48, 0x39, 0xf2, 0x56, 0x90, 0x5a, 0x46, 0xf2, - 0x8f, 0x41, 0x77, 0x35, 0x7f, 0xcc, 0xc6, 0xdc, 0x63, 0x64, 0x72, 0xf2, 0x02, 0x94, 0xe6, 0x30, - 0x56, 0xbb, 0x3c, 0xd8, 0x79, 0xf4, 0x76, 0xd9, 0x6b, 0x85, 0xd3, 0xa8, 0x7f, 0x2f, 0x07, 0x67, - 0xef, 0x74, 0xd7, 0xa8, 0xf0, 0x96, 0x0b, 0xda, 0xf0, 0x3e, 0x00, 0x03, 0x0b, 0x87, 0x99, 0x1c, - 0x3a, 0xcc, 0x7c, 0x52, 0x8e, 0x8a, 0x17, 0x2b, 0x30, 0x15, 0x52, 0x73, 0x67, 0x99, 0xa7, 0x7c, - 0xc7, 0xd1, 0x07, 0xdd, 0x35, 0x5a, 0x4f, 0x78, 0xcd, 0x48, 0xdc, 0x2f, 0xbd, 0xcd, 0x5d, 0xf2, - 0x0f, 0xea, 0xa0, 0xf2, 0x2b, 0xf9, 0xcc, 0x40, 0x84, 0x27, 0x36, 0x63, 0xe6, 0x0f, 0xa4, 0xf6, - 0x4a, 0x3c, 0x73, 0x66, 0x0a, 0x49, 0x8c, 0x63, 0x1a, 0x97, 0x74, 0x81, 0x9d, 0xf0, 0x3c, 0xae, - 0x1f, 0xaa, 0xc0, 0xfe, 0x28, 0x97, 0x19, 0x30, 0xf2, 0xa4, 0x0a, 0x4c, 0xfd, 0x5f, 0x0b, 0x7e, - 0x9c, 0xca, 0x43, 0x7d, 0xc2, 0x0b, 0x30, 0x24, 0x9e, 0xeb, 0x47, 0x9d, 0x7d, 0xc5, 0xb1, 0x21, - 0x1e, 0x43, 0x07, 0x04, 0xcc, 0xa4, 0x90, 0x3c, 0x91, 0x25, 0x67, 0x5f, 0xc9, 0x0b, 0x59, 0x93, - 0x48, 0x98, 0xd1, 0x30, 0xfb, 0xc8, 0xf4, 0xd0, 0x02, 0x61, 0x7d, 0x59, 0xe0, 0x46, 0x03, 0x7d, - 0x64, 0x7a, 0xdc, 0xfe, 0x08, 0xd0, 0xcc, 0x20, 0xa8, 0x85, 0x59, 0xea, 0x85, 0x41, 0xe0, 0x8a, - 0x64, 0xfd, 0xe2, 0x89, 0xda, 0x0b, 0x30, 0x24, 0x3c, 0x68, 0x85, 0x4b, 0x8b, 0x68, 0xad, 0xf0, - 0xb9, 0xc5, 0xd6, 0x06, 0x04, 0x8c, 0xa3, 0x46, 0x9b, 0xa1, 0x13, 0x1f, 0x72, 0x74, 0x10, 0xa2, - 0x09, 0x0c, 0xb9, 0x01, 0x63, 0x35, 0x4f, 0xb7, 0x0c, 0xdd, 0x31, 0x96, 0xbb, 0x5e, 0xa7, 0xeb, - 0xc9, 0x06, 0xb0, 0xeb, 0x19, 0x76, 0xd7, 0xd3, 0x62, 0x14, 0xe4, 0x53, 0x30, 0xea, 0x43, 0x66, - 0x1d, 0xc7, 0x76, 0x64, 0x2b, 0xc7, 0xf5, 0x0c, 0xea, 0x38, 0x5a, 0x94, 0x80, 0x7c, 0x1a, 0x46, - 0xab, 0xd6, 0x43, 0xbb, 0xc1, 0x9f, 0xac, 0x6b, 0x0b, 0xc2, 0xe6, 0xc1, 0x67, 0x5f, 0x66, 0x80, - 0xa8, 0x77, 0x9d, 0x96, 0x16, 0x25, 0x54, 0x77, 0xf2, 0xc9, 0x70, 0x9e, 0x8f, 0xef, 0x06, 0xe9, - 0x5a, 0xd4, 0x71, 0x0f, 0xbd, 0x55, 0xd1, 0xf8, 0x94, 0xfd, 0x86, 0xb9, 0x0d, 0x7a, 0x03, 0x06, - 0xef, 0xd0, 0x2d, 0xee, 0x63, 0x5a, 0x0a, 0xdd, 0x92, 0x1f, 0x08, 0x98, 0x7c, 0xba, 0xeb, 0xd3, - 0xa9, 0xdf, 0xca, 0x27, 0x03, 0x95, 0x3e, 0xbe, 0xc2, 0xfe, 0x14, 0x0c, 0xa0, 0x28, 0xab, 0xfe, - 0xf5, 0x02, 0x0a, 0x10, 0xc5, 0x1d, 0xf5, 0x76, 0xf6, 0xc9, 0xd4, 0x5f, 0x28, 0xc5, 0xa3, 0xd7, - 0x3e, 0xbe, 0xd2, 0x7b, 0x13, 0x86, 0x67, 0x6c, 0xcb, 0x35, 0x5d, 0x8f, 0x5a, 0x0d, 0x5f, 0x61, - 0x9f, 0x60, 0x06, 0x55, 0x23, 0x04, 0xcb, 0x36, 0xa0, 0x44, 0x7d, 0x10, 0xe5, 0x25, 0xaf, 0xc2, - 0x10, 0x8a, 0x1c, 0x6d, 0x4e, 0x3e, 0xe1, 0xe1, 0xcd, 0xc4, 0x1a, 0x03, 0xc6, 0x2d, 0xce, 0x90, - 0x94, 0xdc, 0x85, 0xc1, 0x99, 0x0d, 0xb3, 0x65, 0x38, 0xd4, 0x42, 0xdf, 0x64, 0x29, 0x48, 0x48, - 0xb4, 0x2f, 0xa7, 0xf0, 0x5f, 0xa4, 0xe5, 0xcd, 0x69, 0x88, 0x62, 0x91, 0x17, 0x5f, 0x02, 0x76, - 0xe9, 0x67, 0xf3, 0x00, 0x61, 0x01, 0xf2, 0x0c, 0xe4, 0x83, 0x04, 0xd0, 0xe8, 0x12, 0x13, 0xd1, - 0xa0, 0x3c, 0x2e, 0x15, 0x62, 0x6c, 0xe7, 0x77, 0x1d, 0xdb, 0x77, 0xa1, 0xc4, 0x4f, 0xd7, 0xd0, - 0x6b, 0x5d, 0x0a, 0xa8, 0x99, 0xd9, 0xe0, 0x29, 0xa4, 0xe7, 0xb6, 0x34, 0x5a, 0x9e, 0x11, 0x0f, - 0x70, 0xce, 0xec, 0x52, 0x03, 0xfa, 0xf1, 0x2f, 0x72, 0x05, 0x8a, 0xab, 0x7e, 0xf2, 0xd8, 0x51, - 0x3e, 0x4b, 0xc7, 0xe4, 0x87, 0x78, 0xd6, 0x4d, 0x33, 0xb6, 0xe5, 0xb1, 0xaa, 0xb1, 0xd5, 0x23, - 0x42, 0x2e, 0x02, 0x16, 0x91, 0x8b, 0x80, 0xa9, 0xff, 0x75, 0x3e, 0x25, 0xae, 0xf2, 0xe3, 0x3b, - 0x4c, 0x5e, 0x07, 0xc0, 0xe7, 0xe3, 0x4c, 0x9e, 0xfe, 0x73, 0x10, 0x1c, 0x25, 0xc8, 0x08, 0xd5, - 0x36, 0xb2, 0xed, 0x08, 0x89, 0xd5, 0x7f, 0x90, 0x4b, 0x04, 0xe3, 0x3d, 0x94, 0x1c, 0x65, 0xab, - 0x2c, 0x7f, 0x40, 0x33, 0xd6, 0xef, 0x8b, 0xc2, 0xfe, 0xfa, 0x22, 0xfa, 0x2d, 0x47, 0x60, 0x99, - 0x1e, 0xe7, 0xb7, 0x7c, 0x27, 0x9f, 0x16, 0x9a, 0xf8, 0x64, 0xaa, 0xf8, 0xcd, 0xc0, 0x28, 0x2d, - 0xc6, 0x82, 0xc1, 0x23, 0x34, 0x9e, 0xe0, 0x5a, 0x98, 0xa9, 0x5f, 0x84, 0x33, 0xb1, 0x80, 0xbd, - 0x22, 0xd7, 0xf0, 0x95, 0xde, 0x91, 0x7f, 0xb3, 0x03, 0x0f, 0x44, 0xc8, 0xd4, 0xff, 0x3f, 0xd7, - 0x3b, 0x5c, 0xf3, 0xb1, 0xab, 0x4e, 0x8a, 0x00, 0x0a, 0xff, 0x7a, 0x04, 0x70, 0x04, 0xdb, 0xe0, - 0x93, 0x2d, 0x80, 0x8f, 0xc8, 0xe4, 0xf1, 0x61, 0x0b, 0xe0, 0x17, 0x72, 0xbb, 0x46, 0xdb, 0x3e, - 0x6e, 0x19, 0xa8, 0xff, 0x53, 0x2e, 0x35, 0x2a, 0xf6, 0xa1, 0xda, 0xf5, 0x16, 0x94, 0xb8, 0x0b, - 0x8f, 0x68, 0x95, 0x94, 0x47, 0x8c, 0x41, 0xb3, 0x32, 0xef, 0x73, 0x2c, 0x59, 0x80, 0x01, 0xde, - 0x06, 0x43, 0xf4, 0xc6, 0xc7, 0x7a, 0x84, 0xe6, 0x36, 0xb2, 0x26, 0x47, 0x81, 0x56, 0xff, 0x7e, - 0x2e, 0x11, 0xa4, 0xfb, 0x18, 0xbf, 0x2d, 0x9c, 0xaa, 0x0b, 0x7b, 0x9f, 0xaa, 0xd5, 0x7f, 0x9a, - 0x4f, 0x8f, 0x11, 0x7e, 0x8c, 0x1f, 0x72, 0x14, 0xc7, 0x69, 0x07, 0x5b, 0xb7, 0x56, 0x61, 0x2c, - 0x2a, 0x0b, 0xb1, 0x6c, 0x3d, 0x9d, 0x1e, 0x29, 0x3d, 0xa3, 0x15, 0x31, 0x1e, 0xea, 0xb7, 0x73, - 0xc9, 0xf0, 0xe6, 0xc7, 0x3e, 0x3f, 0x1d, 0x4c, 0x5b, 0xa2, 0x9f, 0xf2, 0x11, 0x59, 0x6b, 0x8e, - 0xe2, 0x53, 0x3e, 0x22, 0xab, 0xc6, 0xc1, 0x3e, 0xe5, 0x97, 0xf2, 0x59, 0xd1, 0xe1, 0x8f, 0xfd, - 0x83, 0x3e, 0x2f, 0x0b, 0x99, 0xb7, 0x4c, 0x7c, 0xda, 0x33, 0x59, 0xe1, 0xd8, 0x33, 0x78, 0x26, - 0xf8, 0x1c, 0x6c, 0x8c, 0xa7, 0x0a, 0xeb, 0x23, 0xa2, 0xc8, 0x27, 0x43, 0x58, 0x1f, 0x91, 0xa1, - 0xf2, 0xd1, 0x13, 0xd6, 0x6f, 0xe5, 0xf7, 0x9a, 0x92, 0xe0, 0x54, 0x78, 0x09, 0xe1, 0x7d, 0x35, - 0x9f, 0x4c, 0x95, 0x71, 0xec, 0x62, 0x9a, 0x83, 0x92, 0x48, 0xda, 0x91, 0x29, 0x1c, 0x8e, 0xcf, - 0xb2, 0x68, 0xc4, 0x77, 0xdc, 0x04, 0x71, 0x91, 0xb3, 0x37, 0x91, 0x70, 0x5a, 0xf5, 0x7b, 0xb9, - 0x58, 0x5e, 0x89, 0x63, 0x39, 0x42, 0x38, 0xd0, 0x92, 0x44, 0xde, 0xf6, 0x0f, 0x33, 0x8b, 0xb1, - 0xb8, 0xde, 0xc1, 0xf7, 0x54, 0xa8, 0xa7, 0x9b, 0xad, 0x78, 0x79, 0x11, 0x7f, 0xe0, 0x5b, 0x79, - 0x98, 0x48, 0x90, 0x92, 0x2b, 0x91, 0xb0, 0x3d, 0x78, 0x2c, 0x19, 0x73, 0x54, 0xe7, 0x01, 0x7c, - 0xf6, 0x71, 0x92, 0x7a, 0x05, 0x8a, 0x15, 0x7d, 0x8b, 0x7f, 0x5b, 0x3f, 0x67, 0x69, 0xe8, 0x5b, - 0xf2, 0x89, 0x1b, 0xe2, 0xc9, 0x1a, 0x9c, 0xe7, 0xf7, 0x21, 0xa6, 0x6d, 0xad, 0x9a, 0x6d, 0x5a, - 0xb5, 0x16, 0xcd, 0x56, 0xcb, 0x74, 0xc5, 0xa5, 0xde, 0x0b, 0x3b, 0xdb, 0x93, 0x57, 0x3d, 0xdb, - 0xd3, 0x5b, 0x75, 0xea, 0x93, 0xd5, 0x3d, 0xb3, 0x4d, 0xeb, 0xa6, 0x55, 0x6f, 0x23, 0xa5, 0xc4, - 0x32, 0x9d, 0x15, 0xa9, 0xf2, 0x10, 0xee, 0xb5, 0x86, 0x6e, 0x59, 0xd4, 0xa8, 0x5a, 0xd3, 0x5b, - 0x1e, 0xe5, 0x97, 0x81, 0x05, 0x7e, 0x24, 0xc8, 0xdf, 0xa1, 0x73, 0x34, 0x63, 0xbc, 0xc6, 0x08, - 0xb4, 0x94, 0x42, 0xea, 0x6f, 0x17, 0x53, 0x52, 0x8a, 0x9c, 0x20, 0xf5, 0xf1, 0x7b, 0xba, 0xb8, - 0x4b, 0x4f, 0x5f, 0x87, 0x01, 0x11, 0x23, 0x57, 0x5c, 0x30, 0xa0, 0xe3, 0xfc, 0x43, 0x0e, 0x92, - 0x6f, 0x68, 0x04, 0x15, 0x69, 0xc1, 0xa5, 0x55, 0xd6, 0x4d, 0xe9, 0x9d, 0x59, 0x3a, 0x40, 0x67, - 0xf6, 0xe0, 0x47, 0xde, 0x83, 0x8b, 0x88, 0x4d, 0xe9, 0xd6, 0x01, 0xac, 0x0a, 0xe3, 0x61, 0xf1, - 0xaa, 0xd2, 0x3b, 0x37, 0xab, 0x3c, 0xf9, 0x3c, 0x8c, 0x04, 0x03, 0xc4, 0xa4, 0xae, 0xb8, 0xb9, - 0xe8, 0x31, 0xce, 0x78, 0xb0, 0x39, 0x06, 0x46, 0x77, 0xb5, 0x68, 0xc0, 0xb2, 0x08, 0x2f, 0xf5, - 0x7f, 0xcc, 0xf5, 0x4a, 0x6d, 0x72, 0xec, 0xb3, 0xf2, 0xdb, 0x30, 0x60, 0xf0, 0x8f, 0x12, 0x3a, - 0xd5, 0x3b, 0xf9, 0x09, 0x27, 0xd5, 0xfc, 0x32, 0xea, 0x3f, 0xc9, 0xf5, 0xcc, 0xa8, 0x72, 0xd2, - 0x3f, 0xef, 0xab, 0x85, 0x8c, 0xcf, 0x13, 0x93, 0xe8, 0x35, 0x18, 0x37, 0xc3, 0x90, 0xef, 0xf5, - 0x30, 0xd4, 0x95, 0x76, 0x46, 0x82, 0xe3, 0xe8, 0xba, 0x09, 0x81, 0xc3, 0x96, 0xe3, 0x7b, 0xa3, - 0xb9, 0xf5, 0xae, 0x63, 0xf2, 0x71, 0xa9, 0x9d, 0x73, 0x63, 0xae, 0x6a, 0xee, 0x5d, 0xc7, 0x64, - 0x15, 0xe8, 0xde, 0x06, 0xb5, 0xf4, 0xfa, 0xa6, 0xed, 0x3c, 0xc0, 0x88, 0xa6, 0x7c, 0x70, 0x6a, - 0x67, 0x38, 0xfc, 0xbe, 0x0f, 0x26, 0xcf, 0xc1, 0x68, 0xb3, 0xd5, 0xa5, 0x41, 0x0c, 0x49, 0x7e, - 0xd7, 0xa7, 0x8d, 0x30, 0x60, 0x70, 0x43, 0xf2, 0x14, 0x00, 0x12, 0x79, 0x98, 0xef, 0x06, 0x2f, - 0xf6, 0xb4, 0x21, 0x06, 0x59, 0x15, 0xdd, 0x75, 0x89, 0x6b, 0x35, 0x17, 0x52, 0xbd, 0x65, 0x5b, - 0xcd, 0xba, 0x47, 0x9d, 0x36, 0x36, 0x14, 0x9d, 0x19, 0xb4, 0x0b, 0x48, 0x81, 0x57, 0x27, 0xee, - 0x82, 0x6d, 0x35, 0x57, 0xa9, 0xd3, 0x66, 0x4d, 0x7d, 0x01, 0x88, 0x68, 0xaa, 0x83, 0x87, 0x1e, - 0xfc, 0xe3, 0xd0, 0x9b, 0x41, 0x13, 0x1f, 0xc1, 0x4f, 0x43, 0xf0, 0xc3, 0x26, 0x61, 0x98, 0x07, - 0xd2, 0xe3, 0x42, 0x43, 0x17, 0x06, 0x0d, 0x38, 0x08, 0xe5, 0x75, 0x01, 0x84, 0x77, 0x05, 0xf7, - 0x20, 0xd7, 0xc4, 0x2f, 0xf5, 0xcb, 0x85, 0xb4, 0x24, 0x30, 0x87, 0x52, 0xb4, 0x70, 0x5a, 0xcd, - 0xef, 0x6b, 0x5a, 0x3d, 0x63, 0x75, 0xdb, 0x75, 0xbd, 0xd3, 0xa9, 0xaf, 0x9b, 0x2d, 0x7c, 0xc2, - 0x85, 0x0b, 0x9f, 0x36, 0x6a, 0x75, 0xdb, 0xe5, 0x4e, 0x67, 0x8e, 0x03, 0xc9, 0xf3, 0x30, 0xc1, - 0xe8, 0xb0, 0x93, 0x02, 0xca, 0x22, 0x52, 0x32, 0x06, 0x18, 0x89, 0xd6, 0xa7, 0x7d, 0x02, 0x06, - 0x05, 0x4f, 0xbe, 0x56, 0xf5, 0x6b, 0x03, 0x9c, 0x99, 0xcb, 0x7a, 0x2e, 0x60, 0xc3, 0x27, 0xd7, - 0x7e, 0x6d, 0xc8, 0x2f, 0x8f, 0xf1, 0x96, 0xad, 0x6e, 0x9b, 0x47, 0xdf, 0x1a, 0x40, 0x64, 0xf0, - 0x9b, 0x5c, 0x81, 0x31, 0xc6, 0x25, 0x10, 0x18, 0x0f, 0x51, 0xdb, 0xaf, 0xc5, 0xa0, 0xe4, 0x06, - 0x9c, 0x8b, 0x40, 0xb8, 0x0d, 0xca, 0x9f, 0x24, 0xf4, 0x6b, 0xa9, 0x38, 0xf5, 0x9b, 0x85, 0x68, - 0x6a, 0x9a, 0x63, 0xe8, 0x88, 0x8b, 0x30, 0x60, 0x3b, 0xcd, 0x7a, 0xd7, 0x69, 0x89, 0xb1, 0x57, - 0xb2, 0x9d, 0xe6, 0x5d, 0xa7, 0x45, 0xce, 0x43, 0x89, 0xf5, 0x8e, 0x69, 0x88, 0x21, 0xd6, 0xaf, - 0x77, 0x3a, 0x55, 0x83, 0x94, 0x79, 0x87, 0x60, 0x78, 0xd3, 0x7a, 0x03, 0xb7, 0xf6, 0xdc, 0x29, - 0xa1, 0x9f, 0xaf, 0x78, 0x09, 0x24, 0xf6, 0x13, 0x06, 0x3d, 0xe5, 0x07, 0x01, 0x31, 0x16, 0x06, - 0x6e, 0x4b, 0x0c, 0xde, 0x27, 0x71, 0x16, 0x02, 0x19, 0xb2, 0xe0, 0x9b, 0x18, 0x83, 0x54, 0x80, - 0x84, 0x54, 0x6d, 0xdb, 0x30, 0xd7, 0x4d, 0xca, 0x5f, 0x90, 0xf4, 0xf3, 0x8b, 0xdf, 0x24, 0x56, - 0x1b, 0xf7, 0x99, 0x2c, 0x0a, 0x08, 0x79, 0x93, 0x2b, 0x21, 0xa7, 0xc3, 0xb5, 0x8f, 0xf7, 0x2d, - 0xb7, 0xd3, 0x62, 0x28, 0xd4, 0x4c, 0x2c, 0x8f, 0x0b, 0xa1, 0xfa, 0xd7, 0x8a, 0xc9, 0xfc, 0x44, - 0xc7, 0x62, 0xd7, 0xcc, 0x03, 0x88, 0xf4, 0x63, 0xe1, 0xe5, 0x5a, 0xe0, 0xdd, 0x1e, 0x62, 0x32, - 0x78, 0x48, 0x65, 0xc9, 0x35, 0x18, 0xe4, 0x5f, 0x54, 0xad, 0x08, 0x7b, 0x07, 0x5d, 0xc4, 0xdc, - 0x8e, 0xb9, 0xbe, 0x8e, 0xfe, 0x64, 0x01, 0x9a, 0x5c, 0x81, 0x81, 0xca, 0x52, 0xad, 0x56, 0x5e, - 0xf2, 0x6f, 0x8a, 0xf1, 0x2d, 0x8b, 0x61, 0xb9, 0x75, 0x57, 0xb7, 0x5c, 0xcd, 0x47, 0x92, 0xe7, - 0xa0, 0x54, 0x5d, 0x41, 0x32, 0xfe, 0x42, 0x73, 0x78, 0x67, 0x7b, 0x72, 0xc0, 0xec, 0x70, 0x2a, - 0x81, 0xc2, 0x7a, 0xef, 0x55, 0x2b, 0x92, 0xbb, 0x04, 0xaf, 0xf7, 0xa1, 0x69, 0xe0, 0xb5, 0xb3, - 0x16, 0xa0, 0xc9, 0x2b, 0x30, 0x52, 0xa3, 0x8e, 0xa9, 0xb7, 0x96, 0xba, 0xb8, 0x55, 0x94, 0xc2, - 0x36, 0xba, 0x08, 0xaf, 0x5b, 0x88, 0xd0, 0x22, 0x64, 0xe4, 0x32, 0x14, 0xe7, 0x4d, 0xcb, 0x7f, - 0x2e, 0x81, 0xfe, 0xf4, 0x1b, 0xa6, 0xe5, 0x69, 0x08, 0x25, 0xcf, 0x41, 0xe1, 0xf6, 0x6a, 0x55, - 0x78, 0x82, 0x21, 0xaf, 0xf7, 0xbd, 0x48, 0x08, 0xc8, 0xdb, 0xab, 0x55, 0xf2, 0x0a, 0x0c, 0xb1, - 0x45, 0x8c, 0x5a, 0x0d, 0xea, 0x2a, 0xc3, 0xf8, 0x31, 0x3c, 0x64, 0xa1, 0x0f, 0x94, 0x7d, 0x3a, - 0x02, 0x4a, 0xf5, 0xff, 0xcc, 0xa7, 0x27, 0x90, 0x3a, 0x86, 0xa1, 0x7e, 0xc0, 0x5b, 0xe4, 0x98, - 0x82, 0x15, 0x0f, 0xa1, 0x60, 0xeb, 0x70, 0xa6, 0x6c, 0xb4, 0x4d, 0xab, 0x8c, 0x3f, 0xdd, 0xc5, - 0xb9, 0x32, 0x4e, 0x1d, 0xd2, 0x53, 0xc0, 0x18, 0x5a, 0x7c, 0x0f, 0x0f, 0x2e, 0xcc, 0x50, 0x75, - 0x9d, 0xe3, 0xea, 0xed, 0x75, 0xbd, 0xde, 0xe0, 0xb9, 0x97, 0xb4, 0x38, 0x53, 0xf5, 0x67, 0xf2, - 0xbb, 0xe4, 0xbc, 0x7a, 0x1c, 0xa5, 0xaf, 0x7e, 0x2d, 0xdf, 0x3b, 0xed, 0xd8, 0x63, 0x29, 0x94, - 0x3f, 0xc9, 0xa7, 0x24, 0x01, 0x3b, 0x94, 0x24, 0xae, 0xc1, 0x20, 0x67, 0x13, 0xb8, 0xf1, 0xe2, - 0x6c, 0xc6, 0x95, 0x15, 0x67, 0x51, 0x1f, 0x4d, 0x96, 0xe0, 0x5c, 0x79, 0x7d, 0x9d, 0x36, 0xbc, - 0x30, 0xcc, 0xf4, 0x52, 0x18, 0xf0, 0x95, 0x87, 0xd5, 0x15, 0xf8, 0x30, 0x4c, 0x35, 0x06, 0x36, - 0x49, 0x2d, 0x47, 0x56, 0xe1, 0x42, 0x1c, 0x5e, 0xe3, 0x5b, 0x80, 0xa2, 0x14, 0x69, 0x37, 0xc1, - 0x91, 0xff, 0xa7, 0x65, 0x94, 0x4d, 0x6b, 0x25, 0x4e, 0xd5, 0xfd, 0xbd, 0x5a, 0x89, 0xf3, 0x76, - 0x6a, 0x39, 0xf5, 0x5b, 0x05, 0x39, 0x57, 0xda, 0xe3, 0xeb, 0x70, 0x75, 0x33, 0xe2, 0x66, 0xbd, - 0xd7, 0x21, 0xf3, 0x8a, 0x88, 0x56, 0x62, 0x74, 0x1d, 0xdf, 0x23, 0x31, 0x88, 0x96, 0x80, 0x40, - 0x79, 0x1d, 0x0a, 0x28, 0x49, 0x15, 0x8a, 0x65, 0xa7, 0xc9, 0xcd, 0xdb, 0xdd, 0x1e, 0x70, 0xe9, - 0x4e, 0xd3, 0x4d, 0x7f, 0xc0, 0xc5, 0x58, 0xa8, 0x7f, 0x36, 0xdf, 0x23, 0xbd, 0xd9, 0x63, 0x39, - 0x89, 0xfc, 0x85, 0x7c, 0x56, 0xa2, 0xb2, 0x93, 0xea, 0x3a, 0xf6, 0x21, 0x0b, 0xe7, 0x64, 0xfb, - 0xd5, 0x1d, 0xa1, 0x70, 0xfe, 0x30, 0x9f, 0x95, 0x75, 0xed, 0x54, 0x38, 0x07, 0x9b, 0x20, 0x53, - 0x45, 0xfa, 0x18, 0xdb, 0xdc, 0xb2, 0x2a, 0xf4, 0x1f, 0xd0, 0x7d, 0x2a, 0x4d, 0xa4, 0xa7, 0x43, - 0xf8, 0x50, 0x5a, 0xfa, 0x47, 0xf9, 0xcc, 0xec, 0x82, 0xa7, 0x32, 0x3d, 0x4a, 0x99, 0x9e, 0x0e, - 0xfd, 0x43, 0x0d, 0xfd, 0x54, 0x99, 0x9e, 0x8e, 0xfd, 0x43, 0xe9, 0xe9, 0x1f, 0xe4, 0xd3, 0xf3, - 0x67, 0x1e, 0x83, 0x92, 0x1e, 0x85, 0x87, 0xa3, 0xdf, 0x0d, 0xc5, 0x43, 0x75, 0x43, 0xff, 0x21, - 0xac, 0xa8, 0xa4, 0x40, 0x8f, 0x6d, 0xd4, 0x7f, 0xbf, 0x0a, 0xf4, 0x08, 0x86, 0xfc, 0xe3, 0x2c, - 0xd0, 0x9f, 0x2a, 0x24, 0x73, 0xc6, 0x3e, 0xae, 0x6b, 0x92, 0x73, 0xc0, 0x35, 0xc9, 0x2f, 0x47, - 0xde, 0x81, 0x33, 0xa1, 0x2c, 0xe5, 0x28, 0x63, 0x78, 0x7d, 0xd4, 0x60, 0xa8, 0xfa, 0xfb, 0x0c, - 0x27, 0xc2, 0xe1, 0xc4, 0xa9, 0xd5, 0xef, 0x15, 0x92, 0x89, 0x77, 0x4f, 0x7b, 0xe3, 0x80, 0xbd, - 0x71, 0x17, 0x2e, 0xcc, 0x74, 0x1d, 0x87, 0x5a, 0x5e, 0x7a, 0xa7, 0xe0, 0xe1, 0x7d, 0x83, 0x53, - 0xd4, 0x93, 0x9d, 0x93, 0x51, 0x98, 0xb1, 0x15, 0xaf, 0x1b, 0xe2, 0x6c, 0x07, 0x42, 0xb6, 0x5d, - 0x4e, 0x91, 0xc6, 0x36, 0xbd, 0xb0, 0xfa, 0x7b, 0xf9, 0x64, 0xaa, 0xe4, 0xd3, 0xae, 0x3f, 0x58, - 0xd7, 0xab, 0x5f, 0x2e, 0xc4, 0xd3, 0x45, 0x9f, 0x2e, 0x10, 0x07, 0xef, 0x0e, 0x5f, 0x92, 0x38, - 0x6e, 0xa4, 0xaf, 0xf0, 0xe1, 0x59, 0x5f, 0xe1, 0xe3, 0xd5, 0x5f, 0x29, 0xc6, 0x53, 0x6f, 0x9f, - 0x76, 0xc7, 0xf1, 0x75, 0x07, 0x59, 0x86, 0x73, 0x62, 0x6e, 0xf3, 0x41, 0x98, 0x6e, 0x42, 0xcc, - 0x5f, 0x3c, 0x6b, 0x9d, 0x98, 0x16, 0xbb, 0x2e, 0x75, 0xea, 0x9e, 0xee, 0x3e, 0xa8, 0x63, 0x7e, - 0x0a, 0x2d, 0xb5, 0x20, 0x63, 0x28, 0x66, 0xb5, 0x28, 0xc3, 0xc1, 0x90, 0xa1, 0x3f, 0x21, 0x26, - 0x18, 0xa6, 0x15, 0x54, 0x7f, 0x23, 0x07, 0xe3, 0xf1, 0xcf, 0x21, 0x53, 0x30, 0xc8, 0x7e, 0x07, - 0xcf, 0xee, 0xa5, 0x9c, 0xd8, 0x9c, 0x23, 0xbf, 0x92, 0xf7, 0x69, 0xc8, 0xab, 0x30, 0x84, 0xde, - 0x0f, 0x58, 0x20, 0x1f, 0x46, 0x3b, 0x08, 0x0b, 0x60, 0xa2, 0x56, 0x5e, 0x2c, 0x24, 0x25, 0x6f, - 0xc2, 0x70, 0x35, 0x74, 0xf3, 0x12, 0x77, 0x5e, 0xe8, 0x5d, 0x2a, 0x95, 0x0c, 0x09, 0x34, 0x99, - 0x5a, 0xfd, 0x76, 0x3e, 0x9e, 0x22, 0xfe, 0x54, 0xd5, 0x0f, 0xa6, 0xea, 0xcf, 0x2f, 0x72, 0x55, - 0xbf, 0x63, 0x5a, 0x06, 0x79, 0x02, 0xce, 0xdf, 0xad, 0xcd, 0x6a, 0xf5, 0x3b, 0xd5, 0xa5, 0x4a, - 0xfd, 0xee, 0x52, 0x6d, 0x65, 0x76, 0xa6, 0x3a, 0x57, 0x9d, 0xad, 0x8c, 0xf7, 0x91, 0xb3, 0x70, - 0x26, 0x44, 0xcd, 0xdf, 0x5d, 0x2c, 0x2f, 0x8d, 0xe7, 0xc8, 0x04, 0x8c, 0x86, 0xc0, 0xe9, 0xe5, - 0xd5, 0xf1, 0xfc, 0xf3, 0x9f, 0x80, 0x61, 0x74, 0x6f, 0xe3, 0xd7, 0xf1, 0x64, 0x04, 0x06, 0x97, - 0xa7, 0x6b, 0xb3, 0xda, 0x3d, 0x64, 0x02, 0x50, 0xaa, 0xcc, 0x2e, 0x31, 0x86, 0xb9, 0xe7, 0xff, - 0x9f, 0x1c, 0x40, 0x6d, 0x6e, 0x75, 0x45, 0x10, 0x0e, 0xc3, 0x40, 0x75, 0xe9, 0x5e, 0x79, 0xa1, - 0xca, 0xe8, 0x06, 0xa1, 0xb8, 0xbc, 0x32, 0xcb, 0x6a, 0x18, 0x82, 0xfe, 0x99, 0x85, 0xe5, 0xda, - 0xec, 0x78, 0x9e, 0x01, 0xb5, 0xd9, 0x72, 0x65, 0xbc, 0xc0, 0x80, 0xf7, 0xb5, 0xea, 0xea, 0xec, - 0x78, 0x91, 0xfd, 0xb9, 0x50, 0x5b, 0x2d, 0xaf, 0x8e, 0xf7, 0xb3, 0x3f, 0xe7, 0xf0, 0xcf, 0x12, - 0x63, 0x56, 0x9b, 0x5d, 0xc5, 0x1f, 0x03, 0xac, 0x09, 0x73, 0xfe, 0xaf, 0x41, 0x86, 0x62, 0xac, - 0x2b, 0x55, 0x6d, 0x7c, 0x88, 0xfd, 0x60, 0x2c, 0xd9, 0x0f, 0x60, 0x8d, 0xd3, 0x66, 0x17, 0x97, - 0xef, 0xcd, 0x8e, 0x0f, 0x33, 0x5e, 0x8b, 0x77, 0x18, 0x78, 0x84, 0xfd, 0xa9, 0x2d, 0xb2, 0x3f, - 0x47, 0x19, 0x27, 0x6d, 0xb6, 0xbc, 0xb0, 0x52, 0x5e, 0x9d, 0x1f, 0x1f, 0x63, 0xed, 0x41, 0x9e, - 0x67, 0x78, 0xc9, 0xa5, 0xf2, 0xe2, 0xec, 0xf8, 0xb8, 0xa0, 0xa9, 0x2c, 0x54, 0x97, 0xee, 0x8c, - 0x4f, 0x60, 0x43, 0xde, 0x5b, 0xc4, 0x1f, 0x84, 0x15, 0xc0, 0xbf, 0xce, 0x3e, 0xff, 0x83, 0x50, - 0x5a, 0xae, 0xe1, 0x28, 0xb8, 0x08, 0x67, 0x97, 0x6b, 0xf5, 0xd5, 0xf7, 0x56, 0x66, 0x63, 0xf2, - 0x9e, 0x80, 0x51, 0x1f, 0xb1, 0x50, 0x5d, 0xba, 0xfb, 0x39, 0x2e, 0x6d, 0x1f, 0xb4, 0x58, 0x9e, - 0x59, 0xae, 0x8d, 0xe7, 0x59, 0xaf, 0xf8, 0xa0, 0xfb, 0xd5, 0xa5, 0xca, 0xf2, 0xfd, 0xda, 0x78, - 0xe1, 0xf9, 0x87, 0x30, 0xc2, 0xf3, 0x74, 0x2e, 0x3b, 0x66, 0xd3, 0xb4, 0xc8, 0x53, 0xf0, 0x44, - 0x65, 0xf6, 0x5e, 0x75, 0x66, 0xb6, 0xbe, 0xac, 0x55, 0x6f, 0x55, 0x97, 0x62, 0x35, 0x9d, 0x87, - 0x89, 0x28, 0xba, 0xbc, 0x52, 0x1d, 0xcf, 0x91, 0x0b, 0x40, 0xa2, 0xe0, 0xdb, 0xe5, 0xc5, 0xb9, - 0xf1, 0x3c, 0x51, 0xe0, 0x5c, 0x14, 0x5e, 0x5d, 0x5a, 0xbd, 0xbb, 0x34, 0x3b, 0x5e, 0x78, 0xfe, - 0xaf, 0xe6, 0xe0, 0x7c, 0x6a, 0x2c, 0x67, 0xa2, 0xc2, 0xd3, 0xb3, 0x0b, 0xe5, 0xda, 0x6a, 0x75, - 0xa6, 0x36, 0x5b, 0xd6, 0x66, 0xe6, 0xeb, 0x33, 0xe5, 0xd5, 0xd9, 0x5b, 0xcb, 0xda, 0x7b, 0xf5, - 0x5b, 0xb3, 0x4b, 0xb3, 0x5a, 0x79, 0x61, 0xbc, 0x8f, 0x3c, 0x07, 0x93, 0x19, 0x34, 0xb5, 0xd9, - 0x99, 0xbb, 0x5a, 0x75, 0xf5, 0xbd, 0xf1, 0x1c, 0x79, 0x16, 0x9e, 0xca, 0x24, 0x62, 0xbf, 0xc7, - 0xf3, 0xe4, 0x69, 0xb8, 0x94, 0x45, 0xf2, 0xee, 0xc2, 0x78, 0xe1, 0xf9, 0x9f, 0xcf, 0x01, 0x49, - 0x06, 0xe3, 0x25, 0xcf, 0xc0, 0x65, 0xa6, 0x17, 0xf5, 0xec, 0x06, 0x3e, 0x0b, 0x4f, 0xa5, 0x52, - 0x48, 0xcd, 0x9b, 0x84, 0x27, 0x33, 0x48, 0x44, 0xe3, 0x2e, 0x83, 0x92, 0x4e, 0x80, 0x4d, 0xfb, - 0xf5, 0x1c, 0x9c, 0x4f, 0xf5, 0x80, 0x21, 0x57, 0xe1, 0x63, 0xe5, 0xca, 0x22, 0xeb, 0x9b, 0x99, - 0xd5, 0xea, 0xf2, 0x52, 0xad, 0xbe, 0x38, 0x57, 0xae, 0x33, 0xed, 0xbb, 0x5b, 0x8b, 0xf5, 0xe6, - 0x15, 0x50, 0x7b, 0x50, 0xce, 0xcc, 0x97, 0x97, 0x6e, 0xb1, 0xe1, 0x47, 0x3e, 0x06, 0xcf, 0x64, - 0xd2, 0xcd, 0x2e, 0x95, 0xa7, 0x17, 0x66, 0x2b, 0xe3, 0x79, 0xf2, 0x71, 0x78, 0x36, 0x93, 0xaa, - 0x52, 0xad, 0x71, 0xb2, 0xc2, 0x74, 0xe5, 0xdb, 0xff, 0xf3, 0xd3, 0x7d, 0xdf, 0xfe, 0xe3, 0xa7, - 0x73, 0x7f, 0xf8, 0xc7, 0x4f, 0xe7, 0xfe, 0xe9, 0x1f, 0x3f, 0x9d, 0xfb, 0xfc, 0x8d, 0xfd, 0x04, - 0x59, 0xe6, 0xd3, 0xd6, 0x5a, 0x09, 0x6f, 0xa3, 0x5f, 0xfe, 0x57, 0x01, 0x00, 0x00, 0xff, 0xff, - 0xcb, 0xba, 0x9e, 0x8e, 0x2c, 0x81, 0x01, 0x00, + // 16898 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x78, 0x24, 0xc9, + 0x71, 0x20, 0x86, 0x7e, 0xa0, 0x01, 0x04, 0x1e, 0x03, 0xe4, 0xbc, 0x6a, 0x67, 0x67, 0x17, 0xbb, + 0xb5, 0xe4, 0x70, 0x66, 0xb9, 0x8b, 0xe1, 0xce, 0xce, 0xee, 0x72, 0x5f, 0x5c, 0x36, 0xd0, 0xc0, + 0xa0, 0x67, 0xf0, 0xda, 0x6a, 0xcc, 0x0c, 0x97, 0x12, 0xd9, 0x2a, 0x74, 0x25, 0x1a, 0xb5, 0xd3, + 0x5d, 0xd5, 0xaa, 0xaa, 0x1e, 0x0c, 0xd6, 0x2f, 0x51, 0xd6, 0xe9, 0xa4, 0x13, 0xc5, 0xa3, 0x29, + 0xeb, 0xa4, 0x7b, 0xd8, 0xa6, 0xee, 0x61, 0xeb, 0x74, 0x3a, 0xd1, 0xba, 0x93, 0x25, 0x51, 0x12, + 0x7d, 0x77, 0x96, 0x1f, 0x3c, 0xe9, 0xb3, 0x3e, 0xe9, 0x6c, 0xdf, 0x77, 0x9f, 0x7d, 0x06, 0xcf, + 0xb2, 0xef, 0x0f, 0x3e, 0xfb, 0xfb, 0x64, 0x9b, 0x9f, 0x8f, 0x3e, 0x9f, 0xfd, 0xf9, 0xcb, 0xc8, + 0xac, 0xaa, 0xac, 0x57, 0xe3, 0xb9, 0xc2, 0x82, 0x83, 0x3f, 0x33, 0xe8, 0x88, 0xc8, 0xc8, 0xac, + 0xc8, 0xc8, 0xcc, 0xc8, 0xcc, 0xc8, 0x08, 0xb8, 0xe6, 0xd1, 0x16, 0xed, 0xd8, 0x8e, 0x77, 0xbd, + 0x45, 0x9b, 0x7a, 0x63, 0xeb, 0xba, 0xb7, 0xd5, 0xa1, 0xee, 0x75, 0xfa, 0x90, 0x5a, 0x9e, 0xff, + 0xdf, 0x54, 0xc7, 0xb1, 0x3d, 0x9b, 0x94, 0xf8, 0xaf, 0x4b, 0xe7, 0x9a, 0x76, 0xd3, 0x46, 0xd0, + 0x75, 0xf6, 0x17, 0xc7, 0x5e, 0xba, 0xdc, 0xb4, 0xed, 0x66, 0x8b, 0x5e, 0xc7, 0x5f, 0x6b, 0xdd, + 0xf5, 0xeb, 0xae, 0xe7, 0x74, 0x1b, 0x9e, 0xc0, 0x4e, 0xc6, 0xb1, 0x9e, 0xd9, 0xa6, 0xae, 0xa7, + 0xb7, 0x3b, 0x82, 0xe0, 0xe9, 0x38, 0xc1, 0xa6, 0xa3, 0x77, 0x3a, 0xd4, 0x11, 0x95, 0x5f, 0xfa, + 0x44, 0xd0, 0x4e, 0xbd, 0xd1, 0xa0, 0xae, 0xdb, 0x32, 0x5d, 0xef, 0xfa, 0xc3, 0x97, 0xa4, 0x5f, + 0x82, 0xf0, 0xd9, 0xf4, 0x0f, 0xc2, 0x7f, 0x05, 0xc9, 0x8b, 0xe9, 0x24, 0x7e, 0x8d, 0xb1, 0xaa, + 0xd5, 0xaf, 0xe5, 0x61, 0x70, 0x91, 0x7a, 0xba, 0xa1, 0x7b, 0x3a, 0xb9, 0x0c, 0xfd, 0x55, 0xcb, + 0xa0, 0x8f, 0x94, 0xdc, 0x33, 0xb9, 0xab, 0x85, 0xe9, 0xd2, 0xce, 0xf6, 0x64, 0x9e, 0x9a, 0x1a, + 0x07, 0x92, 0xa7, 0xa0, 0xb8, 0xba, 0xd5, 0xa1, 0x4a, 0xfe, 0x99, 0xdc, 0xd5, 0xa1, 0xe9, 0xa1, + 0x9d, 0xed, 0xc9, 0x7e, 0x14, 0x9a, 0x86, 0x60, 0xf2, 0x2c, 0xe4, 0xab, 0x15, 0xa5, 0x80, 0xc8, + 0x89, 0x9d, 0xed, 0xc9, 0xd1, 0xae, 0x69, 0xbc, 0x60, 0xb7, 0x4d, 0x8f, 0xb6, 0x3b, 0xde, 0x96, + 0x96, 0xaf, 0x56, 0xc8, 0x15, 0x28, 0xce, 0xd8, 0x06, 0x55, 0x8a, 0x48, 0x44, 0x76, 0xb6, 0x27, + 0xc7, 0x1a, 0xb6, 0x41, 0x25, 0x2a, 0xc4, 0x93, 0xcf, 0x42, 0x71, 0xd5, 0x6c, 0x53, 0xa5, 0xff, + 0x99, 0xdc, 0xd5, 0xe1, 0x1b, 0x97, 0xa6, 0xb8, 0xf8, 0xa6, 0x7c, 0xf1, 0x4d, 0xad, 0xfa, 0xf2, + 0x9d, 0x1e, 0xff, 0xf6, 0xf6, 0x64, 0xdf, 0xce, 0xf6, 0x64, 0x91, 0x89, 0xfc, 0xab, 0xdf, 0x99, + 0xcc, 0x69, 0x58, 0x92, 0xbc, 0x05, 0xc3, 0x33, 0xad, 0xae, 0xeb, 0x51, 0x67, 0x49, 0x6f, 0x53, + 0xa5, 0x84, 0x15, 0x5e, 0xda, 0xd9, 0x9e, 0xbc, 0xd0, 0xe0, 0xe0, 0xba, 0xa5, 0xb7, 0xe5, 0x8a, + 0x65, 0x72, 0xf5, 0x37, 0x73, 0x70, 0xa6, 0x46, 0x5d, 0xd7, 0xb4, 0xad, 0x40, 0x36, 0x1f, 0x87, + 0x21, 0x01, 0xaa, 0x56, 0x50, 0x3e, 0x43, 0xd3, 0x03, 0x3b, 0xdb, 0x93, 0x05, 0xd7, 0x34, 0xb4, + 0x10, 0x43, 0x3e, 0x05, 0x03, 0xf7, 0x4d, 0x6f, 0x63, 0x71, 0xae, 0x2c, 0xe4, 0x74, 0x61, 0x67, + 0x7b, 0x92, 0x6c, 0x9a, 0xde, 0x46, 0xbd, 0xbd, 0xae, 0x4b, 0x15, 0xfa, 0x64, 0x64, 0x01, 0xc6, + 0x57, 0x1c, 0xf3, 0xa1, 0xee, 0xd1, 0x3b, 0x74, 0x6b, 0xc5, 0x6e, 0x99, 0x8d, 0x2d, 0x21, 0xc5, + 0x67, 0x76, 0xb6, 0x27, 0x2f, 0x77, 0x38, 0xae, 0xfe, 0x80, 0x6e, 0xd5, 0x3b, 0x88, 0x95, 0x98, + 0x24, 0x4a, 0xaa, 0xbf, 0x55, 0x82, 0x91, 0xbb, 0x2e, 0x75, 0x82, 0x76, 0x5f, 0x81, 0x22, 0xfb, + 0x2d, 0x9a, 0x8c, 0x32, 0xef, 0xba, 0xd4, 0x91, 0x65, 0xce, 0xf0, 0xe4, 0x1a, 0xf4, 0x2f, 0xd8, + 0x4d, 0xd3, 0x12, 0xcd, 0x3e, 0xbb, 0xb3, 0x3d, 0x79, 0xa6, 0xc5, 0x00, 0x12, 0x25, 0xa7, 0x20, + 0x9f, 0x81, 0x91, 0x6a, 0x9b, 0xe9, 0x90, 0x6d, 0xe9, 0x9e, 0xed, 0x88, 0xd6, 0xa2, 0x74, 0x4d, + 0x09, 0x2e, 0x15, 0x8c, 0xd0, 0x93, 0x37, 0x00, 0xca, 0xf7, 0x6b, 0x9a, 0xdd, 0xa2, 0x65, 0x6d, + 0x49, 0x28, 0x03, 0x96, 0xd6, 0x37, 0xdd, 0xba, 0x63, 0xb7, 0x68, 0x5d, 0x77, 0xe4, 0x6a, 0x25, + 0x6a, 0x32, 0x0b, 0x63, 0x65, 0x1c, 0x15, 0x1a, 0xfd, 0xe1, 0x2e, 0x75, 0x3d, 0x57, 0xe9, 0x7f, + 0xa6, 0x70, 0x75, 0x68, 0xfa, 0xa9, 0x9d, 0xed, 0xc9, 0x27, 0xf8, 0x78, 0xa9, 0x3b, 0x02, 0x25, + 0xb1, 0x88, 0x15, 0x22, 0xd3, 0x30, 0x5a, 0xfe, 0xa0, 0xeb, 0xd0, 0xaa, 0x41, 0x2d, 0xcf, 0xf4, + 0xb6, 0x84, 0x86, 0x5c, 0xde, 0xd9, 0x9e, 0x54, 0x74, 0x86, 0xa8, 0x9b, 0x02, 0x23, 0x31, 0x89, + 0x16, 0x21, 0xcb, 0x30, 0x71, 0x6b, 0x66, 0xa5, 0x46, 0x9d, 0x87, 0x66, 0x83, 0x96, 0x1b, 0x0d, + 0xbb, 0x6b, 0x79, 0xca, 0x00, 0xf2, 0x79, 0x76, 0x67, 0x7b, 0xf2, 0xa9, 0x66, 0xa3, 0x53, 0x77, + 0x39, 0xb6, 0xae, 0x73, 0xb4, 0xc4, 0x2c, 0x59, 0x96, 0x7c, 0x1e, 0x46, 0x57, 0x1d, 0xa6, 0x85, + 0x46, 0x85, 0x32, 0xb8, 0x32, 0x88, 0xfa, 0x7f, 0x61, 0x4a, 0xcc, 0x54, 0x1c, 0xea, 0xf7, 0x2c, + 0x6f, 0xac, 0xc7, 0x0b, 0xd4, 0x0d, 0xc4, 0xc9, 0x8d, 0x8d, 0xb0, 0x22, 0x14, 0x14, 0xf6, 0xf1, + 0xa6, 0x43, 0x8d, 0x84, 0xb6, 0x0d, 0x61, 0x9b, 0xaf, 0xed, 0x6c, 0x4f, 0x7e, 0xdc, 0x11, 0x34, + 0xf5, 0x9e, 0x6a, 0x97, 0xc9, 0x8a, 0xcc, 0xc2, 0x20, 0xd3, 0xa6, 0x3b, 0xa6, 0x65, 0x28, 0xf0, + 0x4c, 0xee, 0xea, 0xd8, 0x8d, 0x71, 0xbf, 0xf5, 0x3e, 0x7c, 0xfa, 0xe2, 0xce, 0xf6, 0xe4, 0x59, + 0xa6, 0x83, 0xf5, 0x07, 0xa6, 0x25, 0x4f, 0x11, 0x41, 0x51, 0x36, 0x8a, 0xa6, 0x6d, 0x0f, 0x87, + 0xee, 0x70, 0x38, 0x8a, 0xd6, 0x6c, 0x2f, 0x3e, 0x6c, 0x7d, 0x32, 0x32, 0x03, 0xa3, 0xd3, 0xb6, + 0x57, 0xb5, 0x5c, 0x4f, 0xb7, 0x1a, 0xb4, 0x5a, 0x51, 0x46, 0xb0, 0x1c, 0xaa, 0x05, 0x2b, 0x67, + 0x0a, 0x4c, 0x3d, 0x32, 0x29, 0x45, 0xcb, 0xa8, 0xff, 0xa2, 0x08, 0x63, 0xac, 0x4f, 0xa4, 0xe1, + 0x53, 0x66, 0x33, 0x01, 0x83, 0xb0, 0x5a, 0xdc, 0x8e, 0xde, 0xa0, 0x62, 0x24, 0xe1, 0x57, 0x58, + 0x3e, 0x50, 0xe2, 0x19, 0xa7, 0x27, 0xd7, 0x60, 0x90, 0x83, 0xaa, 0x15, 0x31, 0xb8, 0x46, 0x77, + 0xb6, 0x27, 0x87, 0x5c, 0x84, 0xd5, 0x4d, 0x43, 0x0b, 0xd0, 0x4c, 0xbb, 0xf9, 0xdf, 0xf3, 0xb6, + 0xeb, 0x31, 0xe6, 0x62, 0x6c, 0xe1, 0x67, 0x88, 0x02, 0x1b, 0x02, 0x25, 0x6b, 0x77, 0xb4, 0x10, + 0x79, 0x1d, 0x80, 0x43, 0xca, 0x86, 0xe1, 0x88, 0x01, 0xf6, 0xc4, 0xce, 0xf6, 0xe4, 0x79, 0xc1, + 0x42, 0x37, 0x0c, 0x79, 0x74, 0x4a, 0xc4, 0xa4, 0x0d, 0x23, 0xfc, 0xd7, 0x82, 0xbe, 0x46, 0x5b, + 0x7c, 0x74, 0x0d, 0xdf, 0xb8, 0xea, 0x77, 0x62, 0x54, 0x3a, 0x53, 0x32, 0xe9, 0xac, 0xe5, 0x39, + 0x5b, 0xd3, 0x93, 0x62, 0x42, 0xbe, 0x28, 0xaa, 0x6a, 0x21, 0x4e, 0x9e, 0x0a, 0xe4, 0x32, 0x6c, + 0x9e, 0x9e, 0xb3, 0x9d, 0x4d, 0xdd, 0x31, 0xa8, 0x31, 0xbd, 0x25, 0xcf, 0xd3, 0xeb, 0x3e, 0xb8, + 0xbe, 0x26, 0xab, 0x9e, 0x4c, 0xce, 0x3a, 0x9d, 0x73, 0xab, 0x75, 0xd7, 0x50, 0xe5, 0x06, 0x12, + 0xd2, 0x72, 0xbb, 0x6b, 0x71, 0x35, 0x8b, 0x96, 0x61, 0x53, 0x01, 0x07, 0xdc, 0xa3, 0x0e, 0x9b, + 0xc4, 0x71, 0xd4, 0x89, 0xa9, 0x40, 0x30, 0x79, 0xc8, 0x31, 0x49, 0x1e, 0xa2, 0xc8, 0xa5, 0x77, + 0x60, 0x22, 0x21, 0x0a, 0x32, 0x0e, 0x85, 0x07, 0x74, 0x8b, 0xab, 0x8b, 0xc6, 0xfe, 0x24, 0xe7, + 0xa0, 0xff, 0xa1, 0xde, 0xea, 0x8a, 0x25, 0x54, 0xe3, 0x3f, 0xde, 0xc8, 0x7f, 0x3a, 0xc7, 0x56, + 0x1c, 0x32, 0x63, 0x5b, 0x16, 0x6d, 0x78, 0xf2, 0xa2, 0xf3, 0x2a, 0x0c, 0x2d, 0xd8, 0x0d, 0xbd, + 0x85, 0xfd, 0xc8, 0xf5, 0x4e, 0xd9, 0xd9, 0x9e, 0x3c, 0xc7, 0x3a, 0x70, 0xaa, 0xc5, 0x30, 0x52, + 0x9b, 0x42, 0x52, 0xa6, 0x00, 0x1a, 0x6d, 0xdb, 0x1e, 0xc5, 0x82, 0xf9, 0x50, 0x01, 0xb0, 0xa0, + 0x83, 0x28, 0x59, 0x01, 0x42, 0x62, 0x72, 0x1d, 0x06, 0x57, 0xd8, 0x3a, 0xdb, 0xb0, 0x5b, 0x42, + 0xf9, 0x70, 0x29, 0xc0, 0xb5, 0x57, 0x1e, 0xab, 0x3e, 0x91, 0x3a, 0x0f, 0x63, 0x33, 0x2d, 0x93, + 0x5a, 0x9e, 0xdc, 0x6a, 0x36, 0x92, 0xcb, 0x4d, 0x6a, 0x79, 0x72, 0xab, 0x71, 0xcc, 0xeb, 0x0c, + 0x2a, 0xb7, 0x3a, 0x20, 0x55, 0xff, 0xa0, 0x00, 0x4f, 0xdc, 0xe9, 0xae, 0x51, 0xc7, 0xa2, 0x1e, + 0x75, 0xc5, 0x82, 0x1c, 0x70, 0x5d, 0x82, 0x89, 0x04, 0x52, 0x70, 0xc7, 0x85, 0xf2, 0x41, 0x80, + 0xac, 0x8b, 0x35, 0x5e, 0x9e, 0x6d, 0x13, 0x45, 0xc9, 0x3c, 0x9c, 0x09, 0x81, 0xac, 0x11, 0xae, + 0x92, 0xc7, 0xa5, 0xe4, 0xe9, 0x9d, 0xed, 0xc9, 0x4b, 0x12, 0x37, 0xd6, 0x6c, 0x59, 0x83, 0xe3, + 0xc5, 0xc8, 0x1d, 0x18, 0x0f, 0x41, 0xb7, 0x1c, 0xbb, 0xdb, 0x71, 0x95, 0x02, 0xb2, 0x9a, 0xdc, + 0xd9, 0x9e, 0x7c, 0x52, 0x62, 0xd5, 0x44, 0xa4, 0xbc, 0x80, 0xc7, 0x0b, 0x92, 0x1f, 0xcb, 0xc9, + 0xdc, 0xc4, 0x28, 0x2c, 0xe2, 0x28, 0x7c, 0xcd, 0x1f, 0x85, 0x99, 0x42, 0x9a, 0x8a, 0x97, 0x14, + 0x83, 0x32, 0xd6, 0x8c, 0xc4, 0xa0, 0x4c, 0xd4, 0x78, 0x69, 0x06, 0xce, 0xa7, 0xf2, 0xda, 0x97, + 0x56, 0xff, 0xf3, 0x82, 0xcc, 0x65, 0xc5, 0x36, 0x82, 0xce, 0x5c, 0x96, 0x3b, 0x73, 0xc5, 0x36, + 0x70, 0xaa, 0xcf, 0x85, 0x6b, 0xa7, 0xd4, 0xd8, 0x8e, 0x6d, 0xc4, 0x67, 0xfd, 0x64, 0x59, 0xf2, + 0x45, 0xb8, 0x90, 0x00, 0xf2, 0xe9, 0x9a, 0x6b, 0xff, 0x95, 0x9d, 0xed, 0x49, 0x35, 0x85, 0x6b, + 0x7c, 0xf6, 0xce, 0xe0, 0x42, 0x74, 0xb8, 0x28, 0x49, 0xdd, 0xb6, 0x3c, 0xdd, 0xb4, 0x84, 0x71, + 0xc9, 0x47, 0xc9, 0x27, 0x76, 0xb6, 0x27, 0x9f, 0x93, 0x75, 0xd0, 0xa7, 0x89, 0x37, 0x3e, 0x8b, + 0x0f, 0x31, 0x40, 0x49, 0x41, 0x55, 0xdb, 0x7a, 0xd3, 0xb7, 0x98, 0xaf, 0xee, 0x6c, 0x4f, 0x7e, + 0x2c, 0xb5, 0x0e, 0x93, 0x51, 0xc9, 0x2b, 0x74, 0x16, 0x27, 0xa2, 0x01, 0x09, 0x71, 0x4b, 0xb6, + 0x41, 0xf1, 0x1b, 0xfa, 0x91, 0xbf, 0xba, 0xb3, 0x3d, 0xf9, 0xb4, 0xc4, 0xdf, 0xb2, 0x0d, 0x1a, + 0x6f, 0x7e, 0x4a, 0x69, 0xf5, 0x37, 0x0b, 0xf0, 0x74, 0xad, 0xbc, 0xb8, 0x50, 0x35, 0x7c, 0x93, + 0x66, 0xc5, 0xb1, 0x1f, 0x9a, 0x86, 0x34, 0x7a, 0xd7, 0xe0, 0x62, 0x0c, 0x35, 0x8b, 0x56, 0x54, + 0x60, 0x4c, 0xe3, 0xb7, 0xf9, 0xe6, 0x52, 0x47, 0xd0, 0xd4, 0xb9, 0xa9, 0x15, 0x5d, 0xb4, 0xb3, + 0x18, 0xb1, 0x3e, 0x8a, 0xa1, 0x6a, 0x1b, 0xb6, 0xe3, 0x35, 0xba, 0x9e, 0x50, 0x02, 0xec, 0xa3, + 0x44, 0x1d, 0xae, 0x20, 0xea, 0x51, 0x85, 0xcf, 0x87, 0xfc, 0x64, 0x0e, 0xc6, 0xcb, 0x9e, 0xe7, + 0x98, 0x6b, 0x5d, 0x8f, 0x2e, 0xea, 0x9d, 0x8e, 0x69, 0x35, 0x71, 0xac, 0x0f, 0xdf, 0x78, 0x2b, + 0x58, 0x23, 0x7b, 0x4a, 0x62, 0x2a, 0x5e, 0x5c, 0x1a, 0xa2, 0xba, 0x8f, 0xaa, 0xb7, 0x39, 0x4e, + 0x1e, 0xa2, 0xf1, 0x72, 0x6c, 0x88, 0xa6, 0xf2, 0xda, 0xd7, 0x10, 0xfd, 0x5a, 0x01, 0x2e, 0x2f, + 0x3f, 0xf0, 0x74, 0x8d, 0xba, 0x76, 0xd7, 0x69, 0x50, 0xf7, 0x6e, 0xc7, 0xd0, 0x3d, 0x1a, 0x8e, + 0xd4, 0x49, 0xe8, 0x2f, 0x1b, 0x06, 0x35, 0x90, 0x5d, 0x3f, 0xdf, 0xf6, 0xe9, 0x0c, 0xa0, 0x71, + 0x38, 0xf9, 0x38, 0x0c, 0x88, 0x32, 0xc8, 0xbd, 0x7f, 0x7a, 0x78, 0x67, 0x7b, 0x72, 0xa0, 0xcb, + 0x41, 0x9a, 0x8f, 0x63, 0x64, 0x15, 0xda, 0xa2, 0x8c, 0xac, 0x10, 0x92, 0x19, 0x1c, 0xa4, 0xf9, + 0x38, 0xf2, 0x2e, 0x8c, 0x21, 0xdb, 0xa0, 0x3d, 0x62, 0xee, 0x3b, 0xe7, 0x4b, 0x57, 0x6e, 0x2c, + 0x5f, 0x9a, 0xb0, 0x35, 0x75, 0xc7, 0x2f, 0xa0, 0xc5, 0x18, 0x90, 0xfb, 0x30, 0x2e, 0x1a, 0x11, + 0x32, 0xed, 0xef, 0xc1, 0xf4, 0xfc, 0xce, 0xf6, 0xe4, 0x84, 0x68, 0xbf, 0xc4, 0x36, 0xc1, 0x84, + 0x31, 0x16, 0xcd, 0x0e, 0x19, 0x97, 0x76, 0x63, 0x2c, 0xbe, 0x58, 0x66, 0x1c, 0x67, 0xa2, 0xbe, + 0x07, 0x23, 0x72, 0x41, 0x72, 0x01, 0xb7, 0xd6, 0x7c, 0x9c, 0xe0, 0xa6, 0xdc, 0x34, 0x70, 0x3f, + 0xfd, 0x12, 0x0c, 0x57, 0xa8, 0xdb, 0x70, 0xcc, 0x0e, 0xb3, 0x1a, 0x84, 0x92, 0x9f, 0xd9, 0xd9, + 0x9e, 0x1c, 0x36, 0x42, 0xb0, 0x26, 0xd3, 0xa8, 0xff, 0x57, 0x0e, 0x2e, 0x30, 0xde, 0x65, 0xd7, + 0x35, 0x9b, 0x56, 0x5b, 0x5e, 0xb6, 0x5f, 0x80, 0x52, 0x0d, 0xeb, 0x13, 0x35, 0x9d, 0xdb, 0xd9, + 0x9e, 0x1c, 0xe7, 0x2d, 0x90, 0xf4, 0x50, 0xd0, 0x04, 0xfb, 0xca, 0xfc, 0x2e, 0xfb, 0x4a, 0x66, + 0xd2, 0x7a, 0xba, 0xe3, 0x99, 0x56, 0xb3, 0xe6, 0xe9, 0x5e, 0xd7, 0x8d, 0x98, 0xb4, 0x02, 0x53, + 0x77, 0x11, 0x15, 0x31, 0x69, 0x23, 0x85, 0xc8, 0x3b, 0x30, 0x32, 0x6b, 0x19, 0x21, 0x13, 0x3e, + 0x21, 0x3e, 0xc9, 0x2c, 0x4d, 0x8a, 0xf0, 0x24, 0x8b, 0x48, 0x01, 0xf5, 0x6f, 0xe7, 0x40, 0xe1, + 0x9b, 0xc0, 0x05, 0xd3, 0xf5, 0x16, 0x69, 0x7b, 0x4d, 0x9a, 0x9d, 0xe6, 0xfc, 0x5d, 0x25, 0xc3, + 0x49, 0x6b, 0x11, 0x9a, 0x02, 0x62, 0x57, 0xd9, 0x32, 0xdd, 0xc4, 0xf6, 0x23, 0x56, 0x8a, 0x54, + 0x61, 0x80, 0x73, 0xe6, 0xb6, 0xc4, 0xf0, 0x0d, 0xc5, 0x57, 0x84, 0x78, 0xd5, 0x5c, 0x19, 0xda, + 0x9c, 0x58, 0xde, 0xd0, 0x88, 0xf2, 0xea, 0xd7, 0x0b, 0x30, 0x1e, 0x2f, 0x44, 0xee, 0xc3, 0xe0, + 0x6d, 0xdb, 0xb4, 0xa8, 0xb1, 0x6c, 0x61, 0x0b, 0x7b, 0x1f, 0x8e, 0xf8, 0xb6, 0xf8, 0xd9, 0xf7, + 0xb1, 0x4c, 0x5d, 0xb6, 0x60, 0xf1, 0xac, 0x24, 0x60, 0x46, 0x3e, 0x0f, 0x43, 0xcc, 0x06, 0x7c, + 0x88, 0x9c, 0xf3, 0xbb, 0x72, 0x7e, 0x46, 0x70, 0x3e, 0xe7, 0xf0, 0x42, 0x49, 0xd6, 0x21, 0x3b, + 0xa6, 0x57, 0x1a, 0xd5, 0x5d, 0xdb, 0x12, 0x3d, 0x8f, 0x7a, 0xe5, 0x20, 0x44, 0xd6, 0x2b, 0x4e, + 0xc3, 0x4c, 0x57, 0xfe, 0xb1, 0xd8, 0x0d, 0xd2, 0xde, 0x85, 0xcb, 0x2a, 0xde, 0x03, 0x12, 0x31, + 0xb1, 0xe0, 0x8c, 0x10, 0xe8, 0x86, 0xd9, 0x41, 0xab, 0x1f, 0xd7, 0xb5, 0xb1, 0x1b, 0x57, 0xa6, + 0xfc, 0x43, 0xb1, 0x29, 0xe9, 0x48, 0xed, 0xe1, 0x4b, 0x53, 0x8b, 0x01, 0x39, 0xee, 0x4c, 0x51, + 0x27, 0x63, 0x2c, 0xe4, 0xde, 0x6e, 0x47, 0xc8, 0xd5, 0x1f, 0xcf, 0xc3, 0x8b, 0x61, 0x17, 0x69, + 0xf4, 0xa1, 0x49, 0x37, 0x43, 0x8e, 0x62, 0x8f, 0xcc, 0x86, 0x98, 0x3b, 0xb3, 0xa1, 0x5b, 0x4d, + 0x6a, 0x90, 0x6b, 0xd0, 0xaf, 0xd9, 0x2d, 0xea, 0x2a, 0x39, 0x34, 0x0f, 0x71, 0xfa, 0x72, 0x18, + 0x40, 0x3e, 0x64, 0x41, 0x0a, 0x62, 0x43, 0x69, 0xd5, 0xd1, 0x4d, 0xcf, 0xd7, 0xa4, 0x72, 0x52, + 0x93, 0xf6, 0x50, 0xe3, 0x14, 0xe7, 0xc1, 0xd7, 0x18, 0x14, 0xbc, 0x87, 0x00, 0x59, 0xf0, 0x9c, + 0xe4, 0xd2, 0xeb, 0x30, 0x2c, 0x11, 0xef, 0x6b, 0x11, 0xf9, 0x66, 0x51, 0x1e, 0x5b, 0x7e, 0xb3, + 0xc4, 0xd8, 0xba, 0xce, 0xc6, 0x84, 0xeb, 0x32, 0x2b, 0x86, 0x0f, 0x2a, 0xa1, 0xf9, 0x08, 0x8a, + 0x6a, 0x3e, 0x82, 0xc8, 0xcb, 0x30, 0xc8, 0x59, 0x04, 0xfb, 0x65, 0xdc, 0x6b, 0x3b, 0x08, 0x8b, + 0x9a, 0x02, 0x01, 0x21, 0xf9, 0xa5, 0x1c, 0x3c, 0xd5, 0x53, 0x12, 0xa8, 0x7c, 0xc3, 0x37, 0x5e, + 0x39, 0x90, 0x18, 0xa7, 0x5f, 0xdc, 0xd9, 0x9e, 0xbc, 0x26, 0x69, 0x86, 0x23, 0xd1, 0xd4, 0x1b, + 0x9c, 0x48, 0x6a, 0x57, 0xef, 0xa6, 0x30, 0x63, 0x95, 0x57, 0x3a, 0x87, 0x47, 0x55, 0x56, 0x63, + 0xcb, 0x6f, 0x64, 0x31, 0x34, 0x56, 0xc5, 0xf7, 0xae, 0xfb, 0x24, 0x29, 0xd5, 0x64, 0x70, 0x21, + 0x0d, 0xb8, 0xc8, 0x31, 0x15, 0x7d, 0x6b, 0x79, 0x7d, 0xd1, 0xb6, 0xbc, 0x0d, 0xbf, 0x82, 0x7e, + 0xf9, 0xac, 0x07, 0x2b, 0x30, 0xf4, 0xad, 0xba, 0xbd, 0x5e, 0x6f, 0x33, 0xaa, 0x94, 0x3a, 0xb2, + 0x38, 0xb1, 0x89, 0x5d, 0x8c, 0x71, 0x7f, 0xca, 0x2b, 0x85, 0x27, 0x71, 0xfe, 0xbc, 0x90, 0x9c, + 0xe0, 0x62, 0x85, 0xd4, 0x2a, 0x8c, 0x2c, 0xd8, 0x8d, 0x07, 0x81, 0xba, 0xbc, 0x0e, 0xa5, 0x55, + 0xdd, 0x69, 0x52, 0x0f, 0x65, 0x31, 0x7c, 0x63, 0x62, 0x8a, 0x9f, 0x6e, 0x33, 0x22, 0x8e, 0x98, + 0x1e, 0x13, 0xb3, 0x4f, 0xc9, 0xc3, 0xdf, 0x9a, 0x28, 0xa0, 0x7e, 0xa7, 0x1f, 0x46, 0xc4, 0x49, + 0x2c, 0xae, 0x1e, 0xe4, 0x8d, 0xf0, 0x6c, 0x5b, 0x4c, 0x97, 0xc1, 0x69, 0x54, 0x70, 0x8a, 0x36, + 0xc2, 0x98, 0xfd, 0xe1, 0xf6, 0x64, 0x6e, 0x67, 0x7b, 0xb2, 0x4f, 0x1b, 0x94, 0x36, 0xb1, 0xe1, + 0xfa, 0x26, 0x2d, 0xe8, 0xf2, 0xd9, 0x6a, 0xac, 0x2c, 0x5f, 0xef, 0xde, 0x81, 0x01, 0xd1, 0x06, + 0xa1, 0x71, 0x17, 0xc3, 0xb3, 0x93, 0xc8, 0x89, 0x72, 0xac, 0xb4, 0x5f, 0x8a, 0xbc, 0x05, 0x25, + 0x7e, 0x96, 0x20, 0x04, 0x70, 0x21, 0xfd, 0xec, 0x25, 0x56, 0x5c, 0x94, 0x21, 0xf3, 0x00, 0xe1, + 0x39, 0x42, 0x70, 0x80, 0x2e, 0x38, 0x24, 0x4f, 0x18, 0x62, 0x5c, 0xa4, 0xb2, 0xe4, 0x55, 0x18, + 0x59, 0xa5, 0x4e, 0xdb, 0xb4, 0xf4, 0x56, 0xcd, 0xfc, 0xc0, 0x3f, 0x43, 0xc7, 0x85, 0xde, 0x35, + 0x3f, 0x90, 0x47, 0x6e, 0x84, 0x8e, 0x7c, 0x21, 0x6d, 0x9f, 0x3e, 0x80, 0x0d, 0x79, 0x76, 0xd7, + 0x0d, 0x6c, 0xac, 0x3d, 0x29, 0xdb, 0xf6, 0x77, 0x61, 0x34, 0xb2, 0x45, 0x13, 0x87, 0xa4, 0x4f, + 0x25, 0x59, 0x4b, 0xfb, 0xcd, 0x18, 0xdb, 0x28, 0x07, 0xa6, 0xc9, 0x55, 0xcb, 0xf4, 0x4c, 0xbd, + 0x35, 0x63, 0xb7, 0xdb, 0xba, 0x65, 0x28, 0x43, 0xa1, 0x26, 0x9b, 0x1c, 0x53, 0x6f, 0x70, 0x94, + 0xac, 0xc9, 0xd1, 0x42, 0xe4, 0x0e, 0x8c, 0x8b, 0x3e, 0xd4, 0x68, 0xc3, 0x76, 0x98, 0xed, 0x81, + 0x67, 0xa0, 0xe2, 0x18, 0xc0, 0xe5, 0xb8, 0xba, 0xe3, 0x23, 0x65, 0xe3, 0x3e, 0x5e, 0xf0, 0x76, + 0x71, 0x70, 0x78, 0x7c, 0x24, 0x7e, 0x6c, 0xad, 0xfe, 0xcd, 0x02, 0x0c, 0x0b, 0x52, 0xb6, 0x74, + 0x9f, 0x2a, 0xf8, 0x61, 0x14, 0x3c, 0x55, 0x51, 0x4b, 0x47, 0xa5, 0xa8, 0xea, 0x97, 0xf3, 0xc1, + 0x6c, 0xb4, 0xe2, 0x98, 0xd6, 0xe1, 0x66, 0xa3, 0x2b, 0x00, 0x33, 0x1b, 0x5d, 0xeb, 0x01, 0xbf, + 0x9e, 0xcb, 0x87, 0xd7, 0x73, 0x0d, 0x53, 0x93, 0x30, 0xe4, 0x29, 0x28, 0x56, 0x18, 0x7f, 0xd6, + 0x33, 0x23, 0xd3, 0x43, 0xdf, 0xe6, 0x9c, 0x72, 0x2f, 0x6a, 0x08, 0x66, 0x9b, 0xb9, 0xe9, 0x2d, + 0x8f, 0x72, 0xf3, 0xb9, 0xc0, 0x37, 0x73, 0x6b, 0x0c, 0xa0, 0x71, 0x38, 0xb9, 0x09, 0x13, 0x15, + 0xda, 0xd2, 0xb7, 0x16, 0xcd, 0x56, 0xcb, 0x74, 0x69, 0xc3, 0xb6, 0x0c, 0x17, 0x85, 0x2c, 0xaa, + 0x6b, 0xbb, 0x5a, 0x92, 0x80, 0xa8, 0x50, 0x5a, 0x5e, 0x5f, 0x77, 0xa9, 0x87, 0xe2, 0x2b, 0x4c, + 0x03, 0x9b, 0x9c, 0x6d, 0x84, 0x68, 0x02, 0xa3, 0x7e, 0x23, 0xc7, 0x76, 0x4b, 0xee, 0x03, 0xcf, + 0xee, 0x04, 0x5a, 0x7e, 0x28, 0x91, 0x5c, 0x0b, 0xed, 0x8a, 0x3c, 0x7e, 0xed, 0x19, 0xf1, 0xb5, + 0x03, 0xc2, 0xb6, 0x08, 0x2d, 0x8a, 0xd4, 0xaf, 0x2a, 0xec, 0xf2, 0x55, 0xea, 0x9f, 0xe4, 0xe1, + 0xa2, 0x68, 0xf1, 0x4c, 0xcb, 0xec, 0xac, 0xd9, 0xba, 0x63, 0x68, 0xb4, 0x41, 0xcd, 0x87, 0xf4, + 0x64, 0x0e, 0xbc, 0xe8, 0xd0, 0x29, 0x1e, 0x62, 0xe8, 0xdc, 0xc0, 0x8d, 0x27, 0x93, 0x0c, 0x1e, + 0x30, 0x73, 0xa3, 0x62, 0x7c, 0x67, 0x7b, 0x72, 0xc4, 0xe0, 0x60, 0xbc, 0x62, 0xd0, 0x64, 0x22, + 0xa6, 0x24, 0x0b, 0xd4, 0x6a, 0x7a, 0x1b, 0xa8, 0x24, 0xfd, 0x5c, 0x49, 0x5a, 0x08, 0xd1, 0x04, + 0x46, 0xfd, 0xdf, 0xf2, 0x70, 0x2e, 0x2e, 0xf2, 0x1a, 0xb5, 0x8c, 0x53, 0x79, 0x7f, 0x38, 0xf2, + 0xfe, 0x6e, 0x01, 0x9e, 0x14, 0x65, 0x6a, 0x1b, 0xba, 0x43, 0x8d, 0x8a, 0xe9, 0xd0, 0x86, 0x67, + 0x3b, 0x5b, 0x27, 0xd8, 0x80, 0x3a, 0x3a, 0xb1, 0xdf, 0x84, 0x92, 0x38, 0x6e, 0xe0, 0xeb, 0xcc, + 0x58, 0xd0, 0x12, 0x84, 0x26, 0x56, 0x28, 0x7e, 0x54, 0x11, 0xeb, 0xac, 0xd2, 0x5e, 0x3a, 0xeb, + 0xd3, 0x30, 0x1a, 0x88, 0x1e, 0x37, 0xbe, 0x03, 0xa1, 0xb5, 0x65, 0xf8, 0x08, 0xdc, 0xfb, 0x6a, + 0x51, 0x42, 0xac, 0xcd, 0x07, 0x54, 0x2b, 0x68, 0x0d, 0x8d, 0x8a, 0xda, 0x82, 0x72, 0xa6, 0xa1, + 0xc9, 0x44, 0xea, 0x76, 0x11, 0x2e, 0xa5, 0x77, 0xbb, 0x46, 0x75, 0xe3, 0xb4, 0xd7, 0xbf, 0x2f, + 0x7b, 0x9d, 0x3c, 0x0b, 0xc5, 0x15, 0xdd, 0xdb, 0x10, 0xd7, 0xfd, 0x78, 0x07, 0xbd, 0x6e, 0xb6, + 0x68, 0xbd, 0xa3, 0x7b, 0x1b, 0x1a, 0xa2, 0xa4, 0x39, 0x03, 0x90, 0x63, 0xca, 0x9c, 0x21, 0x2d, + 0xf6, 0xc3, 0xcf, 0xe4, 0xae, 0x16, 0x53, 0x17, 0xfb, 0xef, 0x14, 0xb3, 0xe6, 0x95, 0xfb, 0x8e, + 0xe9, 0xd1, 0x53, 0x0d, 0x3b, 0xd5, 0xb0, 0x43, 0x6a, 0xd8, 0x3f, 0xca, 0xc3, 0x68, 0xb0, 0x69, + 0x7a, 0x9f, 0x36, 0x8e, 0x67, 0xad, 0x0a, 0xb7, 0x32, 0x85, 0x43, 0x6f, 0x65, 0x0e, 0xa3, 0x50, + 0x6a, 0x70, 0xc4, 0xca, 0x4d, 0x03, 0x94, 0x18, 0x3f, 0x62, 0x0d, 0x0e, 0x56, 0x9f, 0x85, 0x81, + 0x45, 0xfd, 0x91, 0xd9, 0xee, 0xb6, 0x85, 0x95, 0x8e, 0xee, 0x6b, 0x6d, 0xfd, 0x91, 0xe6, 0xc3, + 0xd5, 0xff, 0x36, 0x07, 0x63, 0x42, 0xa8, 0x82, 0xf9, 0xa1, 0xa4, 0x1a, 0x4a, 0x27, 0x7f, 0x68, + 0xe9, 0x14, 0x0e, 0x2e, 0x1d, 0xf5, 0xaf, 0x14, 0x40, 0x99, 0x33, 0x5b, 0x74, 0xd5, 0xd1, 0x2d, + 0x77, 0x9d, 0x3a, 0x62, 0x3b, 0x3d, 0xcb, 0x58, 0x1d, 0xea, 0x03, 0xa5, 0x29, 0x25, 0x7f, 0xa0, + 0x29, 0xe5, 0x93, 0x30, 0x24, 0x1a, 0x13, 0xb8, 0x4e, 0xe2, 0xa8, 0x71, 0x7c, 0xa0, 0x16, 0xe2, + 0x19, 0x71, 0xb9, 0xd3, 0x71, 0xec, 0x87, 0xd4, 0xe1, 0xb7, 0x62, 0x82, 0x58, 0xf7, 0x81, 0x5a, + 0x88, 0x97, 0x38, 0x53, 0xdf, 0x5e, 0x94, 0x39, 0x53, 0x47, 0x0b, 0xf1, 0xe4, 0x2a, 0x0c, 0x2e, + 0xd8, 0x0d, 0x1d, 0x05, 0xcd, 0xa7, 0x95, 0x91, 0x9d, 0xed, 0xc9, 0xc1, 0x96, 0x80, 0x69, 0x01, + 0x96, 0x51, 0x56, 0xec, 0x4d, 0xab, 0x65, 0xeb, 0xdc, 0xd9, 0x66, 0x90, 0x53, 0x1a, 0x02, 0xa6, + 0x05, 0x58, 0x46, 0xc9, 0x64, 0x8e, 0x4e, 0x4c, 0x83, 0x21, 0xcf, 0x75, 0x01, 0xd3, 0x02, 0xac, + 0xfa, 0x8d, 0x22, 0xd3, 0x5e, 0xd7, 0xfc, 0xe0, 0xb1, 0x5f, 0x17, 0xc2, 0x01, 0xd3, 0x7f, 0x80, + 0x01, 0xf3, 0xd8, 0x1c, 0xd8, 0xa9, 0xff, 0x62, 0x00, 0x40, 0x48, 0x7f, 0xf6, 0x74, 0x73, 0x78, + 0x38, 0xad, 0xa9, 0xc0, 0xc4, 0xac, 0xb5, 0xa1, 0x5b, 0x0d, 0x6a, 0x84, 0xc7, 0x96, 0x25, 0x1c, + 0xda, 0xe8, 0x74, 0x49, 0x05, 0x32, 0x3c, 0xb7, 0xd4, 0x92, 0x05, 0xc8, 0x4b, 0x30, 0x5c, 0xb5, + 0x3c, 0xea, 0xe8, 0x0d, 0xcf, 0x7c, 0x48, 0xc5, 0xd4, 0x80, 0x37, 0xd1, 0x66, 0x08, 0xd6, 0x64, + 0x1a, 0x72, 0x13, 0x46, 0x56, 0x74, 0xc7, 0x33, 0x1b, 0x66, 0x47, 0xb7, 0x3c, 0x57, 0x19, 0xc4, + 0x19, 0x0d, 0x2d, 0x8c, 0x8e, 0x04, 0xd7, 0x22, 0x54, 0xe4, 0x0b, 0x30, 0x84, 0x5b, 0x53, 0xf4, + 0x0f, 0x1f, 0xda, 0xf5, 0xa2, 0xf2, 0xb9, 0xd0, 0x1d, 0x91, 0x9f, 0xbe, 0xe2, 0x8d, 0x73, 0xfc, + 0xae, 0x32, 0xe0, 0x48, 0x3e, 0x07, 0x03, 0xb3, 0x96, 0x81, 0xcc, 0x61, 0x57, 0xe6, 0xaa, 0x60, + 0x7e, 0x21, 0x64, 0x6e, 0x77, 0x62, 0xbc, 0x7d, 0x76, 0xe9, 0xa3, 0x6c, 0xf8, 0xc3, 0x1b, 0x65, + 0x23, 0x1f, 0xc2, 0xb1, 0xf8, 0xe8, 0x51, 0x1d, 0x8b, 0x8f, 0x1d, 0xf0, 0x58, 0x5c, 0xfd, 0x00, + 0x86, 0xa7, 0x57, 0xe6, 0x82, 0xd1, 0xfb, 0x04, 0x14, 0x56, 0x84, 0x67, 0x44, 0x91, 0xdb, 0x33, + 0x1d, 0xd3, 0xd0, 0x18, 0x8c, 0x5c, 0x83, 0xc1, 0x19, 0x74, 0xb7, 0x13, 0xb7, 0x88, 0x45, 0xbe, + 0xfe, 0x35, 0x10, 0x86, 0x5e, 0xb7, 0x3e, 0x9a, 0x7c, 0x1c, 0x06, 0x56, 0x1c, 0xbb, 0xe9, 0xe8, + 0x6d, 0xb1, 0x06, 0xa3, 0x6b, 0x4a, 0x87, 0x83, 0x34, 0x1f, 0xa7, 0xfe, 0x4c, 0xce, 0x37, 0xdb, + 0x59, 0x89, 0x5a, 0x17, 0x8f, 0xe6, 0xb1, 0xee, 0x41, 0x5e, 0xc2, 0xe5, 0x20, 0xcd, 0xc7, 0x91, + 0x6b, 0xd0, 0x3f, 0xeb, 0x38, 0xb6, 0x23, 0xfb, 0xd4, 0x53, 0x06, 0x90, 0xaf, 0x7b, 0x91, 0x82, + 0xbc, 0x06, 0xc3, 0x7c, 0xce, 0xe1, 0x27, 0x9a, 0x85, 0x5e, 0x37, 0xa5, 0x32, 0xa5, 0xfa, 0xbb, + 0x05, 0xc9, 0x66, 0xe3, 0x12, 0x7f, 0x0c, 0x6f, 0x05, 0x5e, 0x86, 0xc2, 0xf4, 0xca, 0x9c, 0x98, + 0x00, 0xcf, 0xfa, 0x45, 0x25, 0x55, 0x89, 0x95, 0x63, 0xd4, 0xe4, 0x32, 0x14, 0x57, 0x98, 0xfa, + 0x94, 0x50, 0x3d, 0x06, 0x77, 0xb6, 0x27, 0x8b, 0x1d, 0xa6, 0x3f, 0x08, 0x45, 0x2c, 0xdb, 0xcc, + 0xf0, 0x1d, 0x13, 0xc7, 0x86, 0xfb, 0x98, 0xcb, 0x50, 0x2c, 0x3b, 0xcd, 0x87, 0x62, 0xd6, 0x42, + 0xac, 0xee, 0x34, 0x1f, 0x6a, 0x08, 0x25, 0xd7, 0x01, 0x34, 0xea, 0x75, 0x1d, 0x0b, 0x9f, 0xbb, + 0x0c, 0xe1, 0xf9, 0x1b, 0xce, 0x86, 0x0e, 0x42, 0xeb, 0x0d, 0xdb, 0xa0, 0x9a, 0x44, 0xa2, 0xfe, + 0x8d, 0xf0, 0x62, 0xa7, 0x62, 0xba, 0x0f, 0x4e, 0xbb, 0x70, 0x1f, 0x5d, 0xa8, 0x8b, 0x23, 0xce, + 0x64, 0x27, 0x4d, 0x42, 0xff, 0x5c, 0x4b, 0x6f, 0xba, 0xd8, 0x87, 0xc2, 0x77, 0x6d, 0x9d, 0x01, + 0x34, 0x0e, 0x8f, 0xf5, 0xd3, 0xe0, 0xee, 0xfd, 0xf4, 0x73, 0xfd, 0xc1, 0x68, 0x5b, 0xa2, 0xde, + 0xa6, 0xed, 0x9c, 0x76, 0xd5, 0x5e, 0xbb, 0xea, 0x0a, 0x0c, 0xd4, 0x9c, 0x86, 0x74, 0x74, 0x81, + 0xfb, 0x01, 0xd7, 0x69, 0xf0, 0x63, 0x0b, 0x1f, 0xc9, 0xe8, 0x2a, 0xae, 0x87, 0x74, 0x03, 0x21, + 0x9d, 0xe1, 0x7a, 0x82, 0x4e, 0x20, 0x05, 0xdd, 0x8a, 0xed, 0x78, 0xa2, 0xe3, 0x02, 0xba, 0x8e, + 0xed, 0x78, 0x9a, 0x8f, 0x24, 0x9f, 0x04, 0x58, 0x9d, 0x59, 0xf1, 0x9d, 0xfb, 0x87, 0x42, 0xdf, + 0x43, 0xe1, 0xd5, 0xaf, 0x49, 0x68, 0xb2, 0x0a, 0x43, 0xcb, 0x1d, 0xea, 0xf0, 0xad, 0x10, 0x7f, + 0xc0, 0xf2, 0x89, 0x98, 0x68, 0x45, 0xbf, 0x4f, 0x89, 0xff, 0x03, 0x72, 0xbe, 0xbe, 0xd8, 0xfe, + 0x4f, 0x2d, 0x64, 0x44, 0x5e, 0x83, 0x52, 0x99, 0xdb, 0x79, 0xc3, 0xc8, 0x32, 0x10, 0x19, 0x6e, + 0x41, 0x39, 0x8a, 0xef, 0xd9, 0x75, 0xfc, 0x5b, 0x13, 0xe4, 0xea, 0x35, 0x18, 0x8f, 0x57, 0x43, + 0x86, 0x61, 0x60, 0x66, 0x79, 0x69, 0x69, 0x76, 0x66, 0x75, 0xbc, 0x8f, 0x0c, 0x42, 0xb1, 0x36, + 0xbb, 0x54, 0x19, 0xcf, 0xa9, 0xbf, 0x2c, 0xcd, 0x20, 0x4c, 0xb5, 0x4e, 0xaf, 0x86, 0x0f, 0x75, + 0xdf, 0x32, 0x8e, 0xf7, 0xa1, 0x78, 0x62, 0xd0, 0x36, 0x3d, 0x8f, 0x1a, 0x62, 0x95, 0xc0, 0xfb, + 0x42, 0xef, 0x91, 0x96, 0xc0, 0x93, 0x17, 0x60, 0x14, 0x61, 0xe2, 0x8a, 0x90, 0xef, 0x8f, 0x45, + 0x01, 0xe7, 0x91, 0x16, 0x45, 0xaa, 0xbf, 0x1f, 0xde, 0x0e, 0x2f, 0x50, 0xfd, 0xa4, 0xde, 0x28, + 0x7e, 0x44, 0xfa, 0x4b, 0xfd, 0x57, 0x45, 0xfe, 0xe4, 0x84, 0xbf, 0x4f, 0x3c, 0x0e, 0x51, 0x86, + 0x47, 0xba, 0x85, 0x7d, 0x1c, 0xe9, 0xbe, 0x00, 0xa5, 0x45, 0xea, 0x6d, 0xd8, 0xbe, 0xe3, 0x17, + 0x7a, 0xe8, 0xb5, 0x11, 0x22, 0x7b, 0xe8, 0x71, 0x1a, 0xf2, 0x00, 0x88, 0xff, 0xf8, 0x30, 0x70, + 0xfc, 0xf6, 0x8f, 0x90, 0x2f, 0x26, 0xf6, 0x29, 0x35, 0x7c, 0xa2, 0x8c, 0x3e, 0xfd, 0xe7, 0x02, + 0xc7, 0x72, 0xc9, 0x13, 0xeb, 0x5f, 0x6e, 0x4f, 0x96, 0x38, 0x8d, 0x96, 0xc2, 0x96, 0xbc, 0x0b, + 0x43, 0x8b, 0x73, 0x65, 0xf1, 0x10, 0x91, 0x7b, 0x45, 0x3c, 0x11, 0x48, 0xd1, 0x47, 0x04, 0x22, + 0xc1, 0xf7, 0x3d, 0xed, 0x75, 0x3d, 0xf9, 0x0e, 0x31, 0xe4, 0xc2, 0xb4, 0x85, 0xbf, 0x14, 0x12, + 0xa7, 0x0b, 0x81, 0xb6, 0x44, 0xdf, 0x0f, 0xc5, 0x65, 0xc5, 0xb1, 0x31, 0x6d, 0x19, 0x3c, 0xc4, + 0xe8, 0x5e, 0x86, 0x89, 0x72, 0xa7, 0xd3, 0x32, 0xa9, 0x81, 0xfa, 0xa2, 0x75, 0x5b, 0xd4, 0x15, + 0x2e, 0x3f, 0xf8, 0xf8, 0x44, 0xe7, 0xc8, 0x3a, 0x3e, 0x7f, 0xad, 0x3b, 0xdd, 0xa8, 0x7f, 0x66, + 0xb2, 0xac, 0xfa, 0x17, 0xf2, 0x70, 0x61, 0xc6, 0xa1, 0xba, 0x47, 0x17, 0xe7, 0xca, 0xe5, 0x2e, + 0xfa, 0xc8, 0xb5, 0x5a, 0xd4, 0x6a, 0x1e, 0xcf, 0xb0, 0x7e, 0x13, 0xc6, 0x82, 0x06, 0xd4, 0x1a, + 0x76, 0x87, 0xca, 0x0f, 0xb9, 0x1a, 0x3e, 0xa6, 0xee, 0x32, 0x94, 0x16, 0x23, 0x25, 0x77, 0xe0, + 0x6c, 0x00, 0x29, 0xb7, 0x5a, 0xf6, 0xa6, 0x46, 0xbb, 0x2e, 0x77, 0xc4, 0x1d, 0xe4, 0x8e, 0xb8, + 0x21, 0x07, 0x9d, 0xe1, 0xeb, 0x0e, 0x23, 0xd0, 0xd2, 0x4a, 0xa9, 0x5f, 0x2f, 0xc0, 0xc5, 0x7b, + 0x7a, 0xcb, 0x34, 0x42, 0xd1, 0x68, 0xd4, 0xed, 0xd8, 0x96, 0x4b, 0x4f, 0xd0, 0x28, 0x8d, 0x0c, + 0x85, 0xe2, 0x91, 0x0c, 0x85, 0x64, 0x17, 0xf5, 0x1f, 0xba, 0x8b, 0x4a, 0x07, 0xea, 0xa2, 0xff, + 0x35, 0x07, 0xe3, 0xfe, 0x43, 0x03, 0xf9, 0xd1, 0xb8, 0xe4, 0x05, 0x8f, 0x47, 0x88, 0x31, 0xbf, + 0x6b, 0xc4, 0x93, 0x1a, 0x0c, 0xcc, 0x3e, 0xea, 0x98, 0x0e, 0x75, 0xf7, 0xe0, 0x34, 0xfe, 0x94, + 0x38, 0x2e, 0x99, 0xa0, 0xbc, 0x48, 0xe2, 0xa4, 0x84, 0x83, 0xf1, 0xf9, 0x20, 0x7f, 0x6a, 0x31, + 0xed, 0xbf, 0x84, 0xe7, 0xcf, 0x07, 0xc5, 0x93, 0x8c, 0xc8, 0x7b, 0xd0, 0x90, 0x94, 0x3c, 0x07, + 0x85, 0xd5, 0xd5, 0x05, 0x31, 0x93, 0x62, 0x04, 0x02, 0xcf, 0x93, 0xdf, 0x47, 0x32, 0xac, 0xfa, + 0x4f, 0xf3, 0x00, 0x4c, 0x15, 0xf8, 0x70, 0x3d, 0x16, 0x25, 0x9c, 0x86, 0x41, 0x5f, 0xe0, 0x42, + 0x0d, 0x83, 0x57, 0x02, 0xf1, 0x8e, 0x88, 0xd7, 0x1d, 0xbc, 0x08, 0x99, 0xf4, 0x1d, 0xc9, 0xf9, + 0x3d, 0x00, 0xee, 0x6c, 0xd0, 0x91, 0xdc, 0x77, 0x1f, 0xff, 0x24, 0x0c, 0x89, 0x19, 0xcf, 0x8e, + 0x9c, 0xff, 0x37, 0x7c, 0xa0, 0x16, 0xe2, 0x63, 0x53, 0x6b, 0xe9, 0x10, 0x0b, 0xb1, 0x2f, 0x5e, + 0xde, 0x2b, 0xa7, 0xe2, 0x3d, 0x62, 0xf1, 0x7e, 0x45, 0x88, 0x97, 0xbf, 0x18, 0x3a, 0xb1, 0xe2, + 0x3d, 0xb2, 0xb3, 0x6f, 0xf5, 0x1f, 0xe5, 0x80, 0xb0, 0x66, 0xad, 0xe8, 0xae, 0xbb, 0x69, 0x3b, + 0x06, 0x77, 0x4e, 0x3f, 0x16, 0xc1, 0x1c, 0xdd, 0x7d, 0xe5, 0xef, 0x0e, 0xc2, 0xd9, 0x88, 0xe3, + 0xef, 0x09, 0x9f, 0xac, 0xae, 0x45, 0x47, 0x53, 0xaf, 0x57, 0x2f, 0x1f, 0x93, 0x2f, 0x44, 0xfb, + 0x23, 0x0f, 0xde, 0xa4, 0x9b, 0xd0, 0x17, 0x61, 0x44, 0xfc, 0x60, 0x2b, 0xb4, 0x7f, 0xd3, 0x85, + 0xa3, 0xd4, 0x65, 0x00, 0x2d, 0x82, 0x26, 0xaf, 0xc0, 0x10, 0x1b, 0x30, 0x4d, 0x0c, 0x56, 0x32, + 0x10, 0xbe, 0x28, 0x31, 0x7c, 0xa0, 0xbc, 0x9e, 0x04, 0x94, 0xd2, 0xbb, 0xa5, 0xc1, 0x3d, 0xbc, + 0x5b, 0xfa, 0x22, 0x0c, 0x97, 0x2d, 0xcb, 0xf6, 0x70, 0x93, 0xee, 0x8a, 0xab, 0x89, 0x4c, 0xab, + 0xfc, 0x39, 0x7c, 0x8c, 0x1f, 0xd2, 0xa7, 0x9a, 0xe5, 0x32, 0x43, 0x72, 0xc3, 0x7f, 0x15, 0x43, + 0x1d, 0xe1, 0x55, 0x8e, 0xd7, 0x33, 0x8e, 0x80, 0x25, 0x1f, 0xc5, 0x60, 0xe7, 0x8d, 0xae, 0x38, + 0x76, 0xc7, 0x76, 0xa9, 0xc1, 0x05, 0x35, 0x1c, 0x86, 0x36, 0xe8, 0x08, 0x04, 0xbe, 0x9b, 0x8b, + 0x04, 0x0e, 0x89, 0x14, 0x21, 0xeb, 0x70, 0xce, 0xbf, 0x28, 0x0e, 0x5e, 0x28, 0x56, 0x2b, 0xae, + 0x32, 0x82, 0xaf, 0x92, 0x48, 0x5c, 0x19, 0xaa, 0x95, 0xe9, 0xa7, 0xfd, 0x6b, 0x11, 0xff, 0x89, + 0x63, 0xdd, 0x34, 0xe4, 0xae, 0x4e, 0xe5, 0x47, 0x7e, 0x08, 0x86, 0x17, 0xf5, 0x47, 0x95, 0xae, + 0x38, 0x7b, 0x19, 0xdd, 0xfb, 0xed, 0x4b, 0x5b, 0x7f, 0x54, 0x37, 0x44, 0xb9, 0x98, 0x4d, 0x21, + 0xb3, 0x24, 0x75, 0xb8, 0xb0, 0xe2, 0xd8, 0x6d, 0xdb, 0xa3, 0x46, 0xec, 0xb1, 0xdf, 0x99, 0xf0, + 0x75, 0x70, 0x47, 0x50, 0xd4, 0x7b, 0xbc, 0xfa, 0xcb, 0x60, 0x43, 0xda, 0x70, 0xa6, 0xec, 0xba, + 0xdd, 0x36, 0x0d, 0x6f, 0xa8, 0xc6, 0x77, 0xfd, 0x8c, 0x4f, 0x08, 0xaf, 0xe5, 0x27, 0x75, 0x2c, + 0xca, 0x2f, 0xa8, 0xea, 0x9e, 0x29, 0xd7, 0x88, 0xdf, 0x12, 0xe7, 0x7d, 0xbb, 0x38, 0x38, 0x36, + 0x7e, 0x46, 0xbb, 0x98, 0x6c, 0xcc, 0xaa, 0xe9, 0xb5, 0xa8, 0xfa, 0xad, 0x1c, 0x40, 0x28, 0x60, + 0xf2, 0x62, 0x34, 0x22, 0x52, 0x2e, 0xbc, 0xe8, 0x10, 0xd1, 0x12, 0x22, 0x21, 0x90, 0xc8, 0x65, + 0x28, 0x62, 0x44, 0x8d, 0x7c, 0x78, 0xb0, 0xfa, 0xc0, 0xb4, 0x0c, 0x0d, 0xa1, 0x0c, 0x2b, 0x3d, + 0x7d, 0x47, 0x2c, 0x5e, 0xea, 0x73, 0xab, 0xb0, 0x02, 0x67, 0x6a, 0xdd, 0x35, 0xbf, 0x6e, 0xe9, + 0x1d, 0x1f, 0x06, 0xf6, 0x70, 0xbb, 0x6b, 0xc1, 0xe3, 0xd7, 0x48, 0xd8, 0x94, 0x68, 0x11, 0xf5, + 0x1b, 0xb9, 0xd8, 0x2c, 0x78, 0x8c, 0x8b, 0xde, 0xc7, 0x92, 0x7e, 0x1a, 0xc9, 0x69, 0x49, 0xfd, + 0xa3, 0x02, 0x0c, 0xaf, 0xd8, 0x8e, 0x27, 0x42, 0x94, 0x9c, 0xec, 0x55, 0x48, 0xda, 0x2b, 0x15, + 0xf7, 0xb1, 0x57, 0xba, 0x0c, 0x45, 0xc9, 0x45, 0x99, 0xdf, 0x8b, 0x18, 0x86, 0xa3, 0x21, 0xf4, + 0x43, 0x7e, 0x72, 0x91, 0xbc, 0x04, 0x1d, 0x38, 0xb4, 0xab, 0xc1, 0x8f, 0xe4, 0x01, 0x3e, 0xf7, + 0xd2, 0x4b, 0x8f, 0x71, 0x97, 0xaa, 0x7f, 0x39, 0x07, 0x67, 0xc4, 0xd5, 0xa2, 0x14, 0x0d, 0x6d, + 0xc0, 0xbf, 0x14, 0x96, 0x67, 0x12, 0x0e, 0xd2, 0x7c, 0x1c, 0x5b, 0xb4, 0x66, 0x1f, 0x99, 0x1e, + 0xde, 0xae, 0x48, 0xe1, 0xd0, 0xa8, 0x80, 0xc9, 0x8b, 0x96, 0x4f, 0x47, 0x5e, 0xf4, 0x2f, 0x4d, + 0x0b, 0xe1, 0x4a, 0xcd, 0x0a, 0xcc, 0xa6, 0x5e, 0x9c, 0xaa, 0xbf, 0x5e, 0x84, 0xe2, 0xec, 0x23, + 0xda, 0x38, 0xe1, 0x5d, 0x23, 0x1d, 0xc5, 0x16, 0x0f, 0x79, 0x14, 0x7b, 0x10, 0x2f, 0x90, 0x77, + 0xc2, 0xfe, 0x2c, 0x45, 0xab, 0x8f, 0xf5, 0x7c, 0xbc, 0x7a, 0xbf, 0xa7, 0x4f, 0x9e, 0x13, 0xd1, + 0x7f, 0x51, 0x80, 0x42, 0x6d, 0x66, 0xe5, 0x54, 0x6f, 0x8e, 0x55, 0x6f, 0x7a, 0xdf, 0xb2, 0xab, + 0xc1, 0xc5, 0xd9, 0x60, 0xe8, 0xd7, 0x1a, 0xbb, 0x23, 0xfb, 0x6e, 0x01, 0xc6, 0x6a, 0x73, 0xab, + 0x2b, 0xd2, 0xd9, 0xf5, 0x1d, 0xee, 0x7b, 0x88, 0x5e, 0x70, 0xbc, 0x4b, 0x2f, 0x27, 0x2c, 0xb0, + 0xbb, 0x55, 0xcb, 0x7b, 0xf5, 0xe6, 0x3d, 0xbd, 0xd5, 0xa5, 0x78, 0x58, 0xc4, 0x3d, 0x95, 0x5d, + 0xf3, 0x03, 0xfa, 0x75, 0x0c, 0x8d, 0xe0, 0x33, 0x20, 0x6f, 0x42, 0xe1, 0xae, 0xf0, 0x21, 0xc9, + 0xe2, 0xf3, 0xf2, 0x0d, 0xce, 0x87, 0x4d, 0x82, 0x85, 0xae, 0x69, 0x20, 0x07, 0x56, 0x8a, 0x15, + 0xbe, 0x25, 0x4c, 0x86, 0x3d, 0x15, 0x6e, 0xfa, 0x85, 0x6f, 0x55, 0x2b, 0xa4, 0x06, 0xc3, 0x2b, + 0xd4, 0x69, 0x9b, 0xd8, 0x51, 0xfe, 0x9c, 0xdd, 0x9b, 0x09, 0xdb, 0x5b, 0x0d, 0x77, 0xc2, 0x42, + 0xc8, 0x4c, 0xe6, 0x42, 0xde, 0x03, 0xe0, 0x56, 0xd5, 0x1e, 0x23, 0x6c, 0x3e, 0x85, 0x3b, 0x15, + 0x6e, 0x0c, 0xa7, 0x58, 0xa5, 0x12, 0x33, 0xf2, 0x00, 0xc6, 0x17, 0x6d, 0xc3, 0x5c, 0x37, 0xb9, + 0xb3, 0x28, 0x56, 0x50, 0xda, 0xdd, 0x45, 0x8b, 0x19, 0xbf, 0x6d, 0xa9, 0x5c, 0x5a, 0x35, 0x09, + 0xc6, 0xea, 0xdf, 0xeb, 0x87, 0x22, 0xeb, 0xf6, 0xd3, 0xf1, 0x7b, 0x98, 0xf1, 0x5b, 0x86, 0xf1, + 0xfb, 0xb6, 0xf3, 0xc0, 0xb4, 0x9a, 0x81, 0x1f, 0xbf, 0xd8, 0x4d, 0xa3, 0xef, 0xd1, 0x26, 0xc7, + 0xd5, 0x03, 0x97, 0x7f, 0x2d, 0x41, 0xbe, 0xcb, 0x08, 0x7e, 0x1d, 0x80, 0xbf, 0xce, 0x47, 0x9a, + 0xc1, 0x30, 0x9c, 0x07, 0x7f, 0xbb, 0x8f, 0x4f, 0x03, 0xe4, 0x70, 0x1e, 0x21, 0x31, 0xb9, 0xe6, + 0x7b, 0x6f, 0x0c, 0xe1, 0x4b, 0x01, 0x3c, 0x36, 0x40, 0xef, 0x0d, 0xd9, 0x08, 0xe0, 0x7e, 0x1c, + 0x2b, 0x00, 0xd2, 0x8d, 0x18, 0xc4, 0x04, 0x11, 0x99, 0x1c, 0x44, 0x00, 0xbd, 0x94, 0x0b, 0x31, + 0x4d, 0xe2, 0x41, 0x5e, 0x8d, 0x5d, 0xd9, 0x93, 0x08, 0xb7, 0xcc, 0x1b, 0xfb, 0xd0, 0xe5, 0x6b, + 0x64, 0x37, 0x97, 0x2f, 0xf5, 0x6f, 0x15, 0x60, 0x98, 0x71, 0xab, 0x75, 0xdb, 0x6d, 0xdd, 0xd9, + 0x3a, 0x55, 0xe4, 0xc3, 0x28, 0x72, 0x1d, 0x26, 0x64, 0x17, 0x7f, 0x66, 0xba, 0xfa, 0xc1, 0x98, + 0x82, 0x03, 0xab, 0x38, 0x01, 0xb7, 0x2d, 0x71, 0xde, 0xf7, 0x04, 0x18, 0x4f, 0x43, 0x5c, 0x2d, + 0xc9, 0x4b, 0xfd, 0xd9, 0x1c, 0x8c, 0xc7, 0xa1, 0x81, 0xee, 0xe7, 0x52, 0x75, 0xff, 0x05, 0x18, + 0x12, 0x97, 0xfe, 0xba, 0x21, 0x7c, 0x10, 0xc7, 0x76, 0xb6, 0x27, 0x01, 0x5f, 0x5c, 0xd7, 0x1d, + 0xaa, 0x1b, 0x5a, 0x48, 0x40, 0x5e, 0x81, 0x11, 0xfc, 0x71, 0xdf, 0x31, 0x3d, 0x8f, 0xf2, 0xce, + 0x28, 0xf2, 0x7b, 0x0c, 0x5e, 0x60, 0x93, 0x23, 0xb4, 0x08, 0x99, 0xfa, 0x7b, 0x79, 0x18, 0xaa, + 0x75, 0xd7, 0xdc, 0x2d, 0xd7, 0xa3, 0xed, 0x13, 0xae, 0x43, 0xfe, 0xb1, 0x42, 0x31, 0xf5, 0x58, + 0xe1, 0x39, 0x7f, 0x68, 0x49, 0xe7, 0xed, 0xc1, 0xc6, 0xc0, 0xf7, 0xa3, 0x0c, 0xb5, 0xa8, 0xb4, + 0x7f, 0x2d, 0x52, 0xff, 0x4e, 0x1e, 0xc6, 0xf9, 0x75, 0x73, 0xc5, 0x74, 0x1b, 0x47, 0xf0, 0x04, + 0xe6, 0xf8, 0x65, 0x7a, 0x38, 0x17, 0x8d, 0x3d, 0x3c, 0x2c, 0x52, 0xbf, 0x94, 0x87, 0xe1, 0x72, + 0xd7, 0xdb, 0x28, 0x7b, 0x38, 0xbf, 0x3d, 0x96, 0x7b, 0xe4, 0x7f, 0x98, 0x83, 0x33, 0xac, 0x21, + 0xab, 0xf6, 0x03, 0x6a, 0x1d, 0xc1, 0x71, 0xbd, 0x7c, 0xec, 0x9e, 0x3f, 0xe0, 0xb1, 0xbb, 0x2f, + 0xcb, 0xc2, 0xfe, 0x64, 0x89, 0x97, 0x4c, 0x9a, 0xdd, 0xa2, 0x27, 0xfb, 0x33, 0x8e, 0xf0, 0x92, + 0xc9, 0x17, 0xc8, 0x11, 0x5c, 0x6a, 0x7e, 0x7f, 0x09, 0xe4, 0x08, 0x4e, 0x64, 0xbf, 0x3f, 0x04, + 0xf2, 0xbb, 0x39, 0x18, 0x9a, 0xb6, 0xbd, 0x13, 0x3e, 0xf0, 0xc5, 0x57, 0x9c, 0x6c, 0x35, 0xf7, + 0xbf, 0xe2, 0x64, 0xeb, 0xa6, 0xfa, 0xf3, 0x79, 0x38, 0x27, 0x22, 0xf8, 0x8b, 0x33, 0xb0, 0xd3, + 0xe9, 0x58, 0x0c, 0xb6, 0xa4, 0x68, 0x4e, 0xe7, 0x21, 0x21, 0x9a, 0x5f, 0x2c, 0xc0, 0x39, 0x0c, + 0x38, 0xcc, 0x76, 0x54, 0xdf, 0x07, 0xb6, 0x08, 0x69, 0x44, 0x5d, 0x07, 0x16, 0x53, 0x5c, 0x07, + 0xfe, 0xe5, 0xf6, 0xe4, 0xab, 0x4d, 0xd3, 0xdb, 0xe8, 0xae, 0x4d, 0x35, 0xec, 0xf6, 0xf5, 0xa6, + 0xa3, 0x3f, 0x34, 0xf9, 0xa5, 0xb9, 0xde, 0xba, 0x1e, 0x26, 0xd6, 0xe9, 0x98, 0x22, 0x4d, 0x4e, + 0x0d, 0x77, 0x4a, 0x8c, 0xab, 0xef, 0x74, 0xe0, 0x02, 0xdc, 0xb6, 0x4d, 0x4b, 0x78, 0xe2, 0x72, + 0x43, 0xb7, 0xb6, 0xb3, 0x3d, 0x79, 0xfe, 0x7d, 0xdb, 0xb4, 0xea, 0x71, 0x77, 0xdc, 0xfd, 0xd6, + 0x17, 0xb2, 0xd6, 0xa4, 0x6a, 0xd4, 0xff, 0x26, 0x07, 0x4f, 0x44, 0xb5, 0xf8, 0xfb, 0xc1, 0x76, + 0xfc, 0x8b, 0x79, 0x38, 0x7f, 0x0b, 0x85, 0x13, 0xb8, 0x3f, 0x9d, 0xce, 0x5b, 0x62, 0x70, 0xa6, + 0xc8, 0xe6, 0xd4, 0xa2, 0xcc, 0x96, 0xcd, 0xe9, 0xa4, 0x2e, 0x64, 0xf3, 0x5f, 0xe7, 0xe0, 0xec, + 0x72, 0xb5, 0x32, 0xf3, 0x7d, 0x32, 0xa2, 0x92, 0xdf, 0x73, 0xc2, 0x0d, 0xce, 0xc4, 0xf7, 0x9c, + 0x70, 0xd3, 0xf3, 0x6b, 0x79, 0x38, 0x5b, 0x2b, 0x2f, 0x2e, 0x7c, 0xbf, 0xcc, 0xe0, 0x33, 0xb2, + 0xaf, 0xae, 0x7f, 0x08, 0x26, 0x6c, 0x01, 0xf9, 0x33, 0xef, 0xdd, 0xc8, 0xf6, 0xe1, 0x4d, 0x0a, + 0xe5, 0x84, 0x4f, 0xdd, 0x47, 0x22, 0x14, 0xa6, 0xf9, 0x11, 0xea, 0x13, 0xae, 0xf9, 0xff, 0x79, + 0x09, 0x86, 0xef, 0x74, 0xd7, 0xa8, 0x70, 0xe9, 0x7a, 0xac, 0x4f, 0x7e, 0x6f, 0xc0, 0xb0, 0x10, + 0x03, 0xde, 0x70, 0x48, 0x21, 0x27, 0x45, 0x08, 0x21, 0x1e, 0xd5, 0x4b, 0x26, 0x22, 0x97, 0xa1, + 0x78, 0x8f, 0x3a, 0x6b, 0xf2, 0x6b, 0xec, 0x87, 0xd4, 0x59, 0xd3, 0x10, 0x4a, 0x16, 0xc2, 0x87, + 0x26, 0xe5, 0x95, 0x2a, 0xa6, 0x3b, 0x12, 0x97, 0x86, 0x98, 0xbf, 0x29, 0xf0, 0x16, 0xd5, 0x3b, + 0x26, 0x4f, 0x94, 0x24, 0x47, 0x82, 0x88, 0x97, 0x24, 0x4b, 0x30, 0x21, 0xbb, 0x0b, 0xf2, 0x5c, + 0x3f, 0x83, 0x29, 0xec, 0xd2, 0xb2, 0xfc, 0x24, 0x8b, 0x92, 0x77, 0x60, 0xc4, 0x07, 0xa2, 0xe3, + 0xe3, 0x50, 0x98, 0x60, 0x22, 0x60, 0x15, 0xcb, 0x07, 0x10, 0x29, 0x20, 0x33, 0xc0, 0x4b, 0x0c, + 0x48, 0x61, 0x10, 0x73, 0x24, 0x8d, 0x14, 0x20, 0xaf, 0x20, 0x03, 0x7c, 0x1c, 0x85, 0x0e, 0x53, + 0xc3, 0xf8, 0x54, 0x19, 0x2f, 0x80, 0x1c, 0x01, 0xe7, 0x0f, 0xd2, 0x23, 0x64, 0x64, 0x19, 0x20, + 0x74, 0x6c, 0x11, 0x61, 0x3f, 0xf6, 0xed, 0x72, 0x23, 0xb1, 0x90, 0x6f, 0xf2, 0x46, 0x0f, 0x72, + 0x93, 0xa7, 0xfe, 0x51, 0x1e, 0x86, 0xcb, 0x9d, 0x4e, 0x30, 0x14, 0x5e, 0x84, 0x52, 0xb9, 0xd3, + 0xb9, 0xab, 0x55, 0xe5, 0x04, 0x00, 0x7a, 0xa7, 0x53, 0xef, 0x3a, 0xa6, 0xec, 0x49, 0xcd, 0x89, + 0xc8, 0x0c, 0x8c, 0x96, 0x3b, 0x9d, 0x95, 0xee, 0x5a, 0xcb, 0x6c, 0x48, 0xf9, 0xcb, 0x78, 0x86, + 0xc7, 0x4e, 0xa7, 0xde, 0x41, 0x4c, 0x3c, 0x89, 0x5d, 0xb4, 0x0c, 0xf9, 0x22, 0x06, 0xcb, 0x12, + 0xe9, 0xb3, 0x78, 0x82, 0x1e, 0x35, 0x08, 0xfd, 0x1f, 0xb6, 0x6d, 0x2a, 0x20, 0xe2, 0x29, 0x12, + 0x2e, 0xfb, 0x89, 0x2d, 0x58, 0x45, 0x89, 0x34, 0x59, 0x21, 0x4b, 0xf2, 0x29, 0x18, 0x28, 0x77, + 0x3a, 0xd2, 0x6d, 0x15, 0x3a, 0xb6, 0xb1, 0x52, 0xf1, 0x0c, 0x85, 0x82, 0xec, 0xd2, 0x5b, 0x30, + 0x16, 0xad, 0x6c, 0x5f, 0x29, 0x16, 0xbe, 0x97, 0xc3, 0x0f, 0x3a, 0xe1, 0x2f, 0x01, 0x5e, 0x86, + 0x42, 0xb9, 0xd3, 0x11, 0xf3, 0xd1, 0xd9, 0x94, 0xfe, 0x88, 0x07, 0x0e, 0x28, 0x77, 0x3a, 0xfe, + 0xa7, 0x9f, 0xf0, 0x27, 0x45, 0x07, 0xfa, 0xf4, 0xdf, 0xe5, 0x9f, 0x7e, 0xb2, 0x9f, 0xfb, 0xa8, + 0xbf, 0x5e, 0x80, 0x33, 0xe5, 0x4e, 0xe7, 0x34, 0x35, 0xc3, 0x51, 0x85, 0x27, 0x78, 0x09, 0x40, + 0x9a, 0x1e, 0x07, 0x82, 0x07, 0x8f, 0xc3, 0xd2, 0xd4, 0xa8, 0xe4, 0x34, 0x89, 0xc8, 0x57, 0xbf, + 0xc1, 0x7d, 0xa9, 0xdf, 0x97, 0x0a, 0x38, 0x15, 0x9f, 0xf4, 0x50, 0x6b, 0x1f, 0x95, 0x6e, 0x13, + 0x7d, 0x50, 0xda, 0x57, 0x1f, 0xfc, 0x83, 0xc8, 0xe0, 0xc1, 0x50, 0xff, 0xa7, 0xbd, 0xd0, 0x7f, + 0x28, 0xb3, 0x78, 0x4c, 0x16, 0xa6, 0x88, 0xff, 0xe4, 0xa7, 0x3b, 0x13, 0xd1, 0xc8, 0x1a, 0x0c, + 0x55, 0x37, 0x0d, 0x2d, 0x46, 0xeb, 0xf7, 0xe1, 0xc0, 0xbe, 0xfa, 0x70, 0x3b, 0x8f, 0x11, 0x07, + 0x82, 0x68, 0x66, 0x87, 0xdf, 0x5d, 0x5c, 0x07, 0xe0, 0x9e, 0x07, 0x81, 0x6b, 0xfd, 0x28, 0x0f, + 0x5c, 0xc4, 0xb3, 0xa0, 0x89, 0xc0, 0x45, 0x21, 0x49, 0xe0, 0xa9, 0x54, 0x48, 0xf5, 0x54, 0xba, + 0x06, 0x83, 0x9a, 0xbe, 0xf9, 0x6e, 0x97, 0x3a, 0x5b, 0xc2, 0x9c, 0xe1, 0xc1, 0x42, 0xf5, 0xcd, + 0xfa, 0x0f, 0x33, 0xa0, 0x16, 0xa0, 0x89, 0x1a, 0x84, 0xac, 0x90, 0x3c, 0x42, 0xf8, 0x19, 0x79, + 0x10, 0xa8, 0xe2, 0x20, 0x8a, 0x4e, 0xde, 0x80, 0x42, 0xf9, 0x7e, 0x4d, 0x48, 0x36, 0xe8, 0xda, + 0xf2, 0xfd, 0x9a, 0x90, 0x57, 0x66, 0xd9, 0xfb, 0x35, 0xf5, 0x4b, 0x79, 0x20, 0x49, 0x4a, 0xf2, + 0x2a, 0x0c, 0x21, 0xb4, 0xc9, 0x74, 0x46, 0x4e, 0x9f, 0xbb, 0xe9, 0xd6, 0x1d, 0x84, 0x46, 0x8c, + 0x3b, 0x9f, 0x94, 0xbc, 0x8e, 0x09, 0xca, 0x45, 0x02, 0xc7, 0x48, 0xfa, 0xdc, 0x4d, 0xd7, 0x4f, + 0xe9, 0x1d, 0xcb, 0x4f, 0x2e, 0x88, 0xd1, 0x2e, 0xbc, 0x5f, 0x9b, 0xb7, 0x5d, 0x4f, 0x88, 0x9a, + 0xdb, 0x85, 0x9b, 0x2e, 0xe6, 0x6d, 0x8e, 0xd8, 0x85, 0x9c, 0x0c, 0x73, 0xcf, 0xdd, 0xaf, 0xf1, + 0xc7, 0x5d, 0x86, 0x66, 0xb7, 0x7c, 0x83, 0x92, 0xe7, 0x9e, 0xdb, 0x74, 0xeb, 0xfc, 0x61, 0x98, + 0x81, 0x99, 0xd1, 0x23, 0xb9, 0xe7, 0x22, 0xa5, 0xd4, 0x9f, 0x1e, 0x84, 0xf1, 0x8a, 0xee, 0xe9, + 0x6b, 0xba, 0x4b, 0xa5, 0xdd, 0xf4, 0x19, 0x1f, 0xe6, 0x7f, 0x8e, 0x24, 0x07, 0x63, 0x2d, 0xe5, + 0x6b, 0xe2, 0x05, 0xc8, 0x9b, 0x21, 0xdf, 0x20, 0x33, 0xb0, 0x9c, 0x6a, 0x70, 0xad, 0xde, 0x11, + 0x60, 0x2d, 0x41, 0x48, 0x5e, 0x80, 0x61, 0x1f, 0xc6, 0x36, 0x00, 0x85, 0x50, 0x67, 0x8c, 0x35, + 0x66, 0xff, 0x6b, 0x32, 0x9a, 0xbc, 0x0e, 0x23, 0xfe, 0x4f, 0xc9, 0xb4, 0xe6, 0x79, 0x13, 0xd7, + 0x12, 0xbb, 0x27, 0x99, 0x54, 0x2e, 0x8a, 0xf3, 0x5b, 0x7f, 0xa4, 0x68, 0x2c, 0x35, 0x61, 0x84, + 0x94, 0xfc, 0x30, 0x8c, 0xf9, 0xbf, 0xc5, 0x86, 0x81, 0x3b, 0x0e, 0xbe, 0x10, 0x24, 0x5e, 0x8f, + 0x89, 0x75, 0x2a, 0x4a, 0xce, 0xb7, 0x0e, 0x4f, 0xfa, 0xd9, 0xf6, 0x8c, 0xb5, 0xe4, 0xce, 0x21, + 0x56, 0x01, 0xa9, 0xc2, 0x84, 0x0f, 0x09, 0x35, 0x74, 0x20, 0xdc, 0x31, 0x1a, 0x6b, 0xf5, 0x54, + 0x25, 0x4d, 0x96, 0x22, 0x2d, 0xb8, 0x1c, 0x01, 0x1a, 0xee, 0x86, 0xb9, 0xee, 0x89, 0xed, 0x9e, + 0x88, 0xdc, 0x2d, 0xd2, 0xab, 0x06, 0x5c, 0x39, 0x8d, 0x9f, 0x27, 0x39, 0x9a, 0x53, 0xad, 0x27, + 0x37, 0x52, 0x83, 0x73, 0x3e, 0xfe, 0xd6, 0xcc, 0xca, 0x8a, 0x63, 0xbf, 0x4f, 0x1b, 0x5e, 0xb5, + 0x22, 0xb6, 0xcb, 0x18, 0xd1, 0xd1, 0x58, 0xab, 0x37, 0x1b, 0x1d, 0xa6, 0x14, 0x0c, 0x17, 0x65, + 0x9e, 0x5a, 0x98, 0xdc, 0x83, 0xf3, 0x12, 0x5c, 0x4a, 0xe2, 0x0e, 0xe1, 0x7e, 0x5e, 0x70, 0x4d, + 0xcf, 0xe3, 0x9e, 0x5e, 0x9c, 0xbc, 0x05, 0xa3, 0x3e, 0x82, 0xdf, 0x22, 0x0e, 0xe3, 0x2d, 0x22, + 0x0e, 0x49, 0x63, 0xad, 0x1e, 0x7f, 0x83, 0x1c, 0x25, 0x96, 0x35, 0x6a, 0x75, 0xab, 0x43, 0x85, + 0x47, 0xaf, 0xaf, 0x51, 0xde, 0x56, 0x27, 0x55, 0x19, 0x19, 0x29, 0x79, 0x27, 0xd4, 0xa8, 0x65, + 0xc7, 0x6c, 0x9a, 0x7c, 0x27, 0xed, 0x3f, 0x3b, 0x5e, 0xab, 0xdb, 0x08, 0x4c, 0xd3, 0x0f, 0x4e, + 0x7e, 0xa9, 0x0c, 0x67, 0x53, 0x74, 0x6c, 0x5f, 0x3b, 0xc6, 0x2f, 0xe7, 0xc3, 0x46, 0x9c, 0xf0, + 0x6d, 0xe3, 0x34, 0x0c, 0xfa, 0x5f, 0x22, 0x8c, 0x07, 0x25, 0x6b, 0x68, 0xc6, 0x79, 0xf8, 0xf8, + 0x88, 0x38, 0x4e, 0xf8, 0x56, 0xf2, 0x28, 0xc4, 0xf1, 0xed, 0x5c, 0x28, 0x8e, 0x13, 0xbe, 0xbd, + 0xfc, 0xa9, 0x62, 0x38, 0x27, 0x9d, 0xee, 0x31, 0x8f, 0xca, 0x4c, 0x0e, 0xfd, 0x60, 0x4b, 0xfb, + 0x78, 0xfe, 0x2b, 0xab, 0xe6, 0xc0, 0xc1, 0x54, 0x93, 0xbc, 0x05, 0xc3, 0x2b, 0xb6, 0xeb, 0x35, + 0x1d, 0xea, 0xae, 0x04, 0x99, 0x27, 0xf0, 0xe9, 0x78, 0x47, 0x80, 0xeb, 0x9d, 0xc8, 0xec, 0x2f, + 0x93, 0xab, 0xff, 0xb8, 0x90, 0xd0, 0x06, 0x6e, 0xb8, 0x9e, 0x48, 0x6d, 0x38, 0x82, 0xa1, 0x4e, + 0x6e, 0x84, 0xab, 0x20, 0xb7, 0xf0, 0xfb, 0xa5, 0xb0, 0x9a, 0x6b, 0xc2, 0xc0, 0x8f, 0x92, 0x90, + 0x1f, 0x80, 0x8b, 0x11, 0xc0, 0x8a, 0xee, 0xe8, 0x6d, 0xea, 0x85, 0x59, 0x3e, 0x31, 0x50, 0x9a, + 0x5f, 0xba, 0xde, 0x09, 0xd0, 0x72, 0xe6, 0xd0, 0x0c, 0x0e, 0x92, 0x6a, 0x0d, 0xec, 0xc3, 0xc5, + 0xfa, 0xe7, 0x0a, 0xa1, 0xa1, 0x13, 0x0d, 0x78, 0xac, 0x51, 0xb7, 0xdb, 0xf2, 0x1e, 0xdf, 0x0e, + 0x3e, 0x58, 0x3a, 0x99, 0x79, 0x38, 0x53, 0x5e, 0x5f, 0xa7, 0x0d, 0xcf, 0x8f, 0xe3, 0xee, 0x8a, + 0x10, 0x97, 0x7c, 0xe3, 0x21, 0x50, 0x22, 0x2e, 0xb7, 0xdc, 0xaf, 0xf1, 0x62, 0xea, 0x3f, 0x29, + 0x82, 0x12, 0x18, 0xfe, 0xc1, 0x53, 0xc3, 0x63, 0x5c, 0x64, 0x3f, 0x12, 0xbd, 0x62, 0xc2, 0x44, + 0x28, 0x0c, 0xf1, 0xc6, 0x4b, 0xe4, 0x9d, 0x9f, 0x8c, 0x33, 0x0b, 0x09, 0xf9, 0x5e, 0xe2, 0x92, + 0xd8, 0x4b, 0x90, 0xf0, 0x29, 0x67, 0xdd, 0xe5, 0x2c, 0xb4, 0x24, 0x57, 0xf2, 0x95, 0x1c, 0x9c, + 0xf3, 0x3b, 0x65, 0x79, 0x8d, 0x19, 0xd5, 0x33, 0x76, 0xd7, 0x0a, 0x1e, 0x40, 0xbd, 0x91, 0x5d, + 0x1d, 0xef, 0xa4, 0xa9, 0xb4, 0xc2, 0xbc, 0x25, 0x41, 0x30, 0x97, 0x40, 0x21, 0x6c, 0xa4, 0xa9, + 0x37, 0x90, 0x48, 0x4b, 0xad, 0xf7, 0xd2, 0x2d, 0x78, 0x22, 0x93, 0xe5, 0x6e, 0x46, 0x6c, 0xbf, + 0x6c, 0xc4, 0xfe, 0x77, 0xb9, 0x70, 0x22, 0x8a, 0x09, 0x89, 0x4c, 0x01, 0x84, 0x20, 0xb1, 0xad, + 0xc5, 0xf7, 0x55, 0xa1, 0xd0, 0x34, 0x89, 0x82, 0x2c, 0x43, 0x49, 0x88, 0x85, 0x67, 0xd4, 0xfe, + 0xe4, 0x2e, 0xbd, 0x30, 0x25, 0xcb, 0x01, 0xb7, 0xac, 0xe2, 0x9b, 0x05, 0x9b, 0x4b, 0xaf, 0xc3, + 0xf0, 0x41, 0xbf, 0xeb, 0x2b, 0x05, 0x20, 0xf2, 0x1e, 0xf4, 0x18, 0x0d, 0xf4, 0x13, 0x3c, 0x85, + 0x5d, 0x85, 0x41, 0xf6, 0x09, 0x98, 0x63, 0x46, 0x8a, 0x29, 0xdd, 0x15, 0x30, 0x2d, 0xc0, 0x86, + 0x01, 0xdd, 0x06, 0xd2, 0x03, 0xba, 0xa9, 0x3f, 0x5b, 0x80, 0x0b, 0x72, 0x87, 0x54, 0x28, 0xa6, + 0xa9, 0x38, 0xed, 0x94, 0x0f, 0xb1, 0x53, 0x54, 0x28, 0xf1, 0xad, 0x87, 0xc8, 0x17, 0xc2, 0x8f, + 0x85, 0x10, 0xa2, 0x09, 0x8c, 0xfa, 0x3f, 0xe7, 0x61, 0x34, 0x30, 0xef, 0x74, 0xc7, 0x7d, 0x8c, + 0xbb, 0xe3, 0xd3, 0x30, 0x8a, 0x21, 0xb9, 0xda, 0xd4, 0xe2, 0x61, 0xab, 0xfa, 0xa5, 0x04, 0x3f, + 0x3e, 0x42, 0xe4, 0x72, 0x8b, 0x10, 0x32, 0xed, 0xe7, 0x96, 0x9f, 0x14, 0x28, 0x8d, 0x9b, 0x7d, + 0x1c, 0xae, 0xfe, 0xd5, 0x02, 0x8c, 0xf8, 0x52, 0x9e, 0x36, 0x4f, 0xea, 0x3d, 0xcf, 0xf1, 0x0a, + 0xf9, 0x3a, 0xc0, 0x8a, 0xed, 0x78, 0x7a, 0x6b, 0x29, 0xd4, 0x7c, 0x3c, 0x20, 0xed, 0x20, 0x94, + 0x97, 0x91, 0x48, 0x70, 0xfd, 0x0a, 0xcd, 0x6a, 0x3e, 0x31, 0xf1, 0xf5, 0x2b, 0x80, 0x6a, 0x12, + 0x85, 0xfa, 0xdb, 0x79, 0x38, 0xe3, 0x77, 0xd2, 0xec, 0x23, 0xda, 0xe8, 0x3e, 0xce, 0x73, 0x53, + 0x54, 0xda, 0xfd, 0xbb, 0x4a, 0x5b, 0xfd, 0x3f, 0xa5, 0x89, 0x64, 0xa6, 0x65, 0x9f, 0x4e, 0x24, + 0x7f, 0x1a, 0x3a, 0xae, 0xfe, 0x58, 0x01, 0xce, 0xf9, 0x52, 0x9f, 0xeb, 0x5a, 0x78, 0xb4, 0x30, + 0xa3, 0xb7, 0x5a, 0x8f, 0xf3, 0x6e, 0x7c, 0xd8, 0x17, 0xc4, 0xb2, 0x88, 0x71, 0x29, 0xf2, 0x6a, + 0xae, 0x0b, 0x70, 0xdd, 0x36, 0x0d, 0x4d, 0x26, 0x22, 0xef, 0xc0, 0x88, 0xff, 0xb3, 0xec, 0x34, + 0xfd, 0x2d, 0x38, 0x5e, 0x14, 0x04, 0x85, 0x74, 0x27, 0x12, 0x18, 0x23, 0x52, 0x40, 0xfd, 0xd2, + 0x00, 0x5c, 0xba, 0x6f, 0x5a, 0x86, 0xbd, 0xe9, 0xfa, 0x69, 0x59, 0x4f, 0xfc, 0x41, 0xd9, 0x71, + 0xa7, 0x63, 0x7d, 0x17, 0xce, 0xc7, 0x45, 0xea, 0x04, 0xc1, 0xf2, 0x45, 0xef, 0x6c, 0x72, 0x82, + 0xba, 0x9f, 0xa0, 0x55, 0xdc, 0xb6, 0x69, 0xe9, 0x25, 0xe3, 0x19, 0x5e, 0x07, 0xf6, 0x92, 0xe1, + 0xf5, 0x79, 0x28, 0x55, 0xec, 0xb6, 0x6e, 0xfa, 0x21, 0x92, 0x70, 0x14, 0x07, 0xf5, 0x22, 0x46, + 0x13, 0x14, 0x8c, 0xbf, 0xa8, 0x18, 0xbb, 0x6c, 0x28, 0xe4, 0xef, 0x17, 0x60, 0x56, 0x9a, 0x26, + 0x13, 0x11, 0x1b, 0x46, 0x45, 0x75, 0xe2, 0x6e, 0x0c, 0x70, 0xf3, 0xf4, 0x8a, 0x2f, 0xa3, 0x6c, + 0xb5, 0x9a, 0x8a, 0x94, 0xe3, 0xdb, 0x28, 0x9e, 0x78, 0x56, 0x7c, 0x0c, 0xbf, 0x25, 0xd3, 0xa2, + 0xfc, 0x25, 0x21, 0xe0, 0x24, 0x33, 0x9c, 0x14, 0x02, 0xce, 0x32, 0x32, 0x11, 0x99, 0x85, 0x09, + 0x0c, 0x69, 0x1e, 0x6c, 0xa5, 0x98, 0x4a, 0x8c, 0xa0, 0x51, 0x89, 0x57, 0x2e, 0x3c, 0x0a, 0x3a, + 0xfb, 0xb8, 0x7a, 0x43, 0xa0, 0xb5, 0x64, 0x09, 0xf2, 0x04, 0x14, 0x96, 0x16, 0xca, 0x78, 0x57, + 0x33, 0xc8, 0xd3, 0x89, 0x59, 0x2d, 0x5d, 0x63, 0xb0, 0x4b, 0x9f, 0x05, 0x92, 0xfc, 0x9c, 0x7d, + 0xdd, 0xc7, 0xfc, 0x97, 0xd2, 0x96, 0xef, 0xa4, 0x7b, 0xd4, 0x1c, 0xc5, 0x44, 0x18, 0xc9, 0xe4, + 0xd7, 0xff, 0x61, 0x66, 0xf2, 0x2b, 0x1d, 0x69, 0x26, 0x3f, 0xf5, 0x57, 0x72, 0x30, 0x91, 0x08, + 0xfb, 0x4f, 0x5e, 0x06, 0xe0, 0x10, 0x29, 0xbc, 0x2a, 0x46, 0xff, 0x09, 0x53, 0x01, 0x88, 0xe5, + 0x31, 0x24, 0x23, 0xd7, 0x61, 0x90, 0xff, 0x12, 0x01, 0xc6, 0x92, 0x45, 0xba, 0x5d, 0xd3, 0xd0, + 0x02, 0xa2, 0xb0, 0x16, 0xbc, 0x91, 0x2c, 0xa4, 0x16, 0xf1, 0xb6, 0x3a, 0x41, 0x2d, 0x8c, 0x4c, + 0xfd, 0xe9, 0x3c, 0x8c, 0x04, 0x0d, 0x2e, 0x1b, 0xc7, 0xa5, 0x73, 0x25, 0x91, 0x41, 0xa1, 0xb0, + 0x5b, 0x06, 0x85, 0xd8, 0x7c, 0x2b, 0x52, 0x26, 0x1c, 0xdd, 0x83, 0xaa, 0xaf, 0xe6, 0xe1, 0x4c, + 0x50, 0xeb, 0x31, 0x5e, 0x7e, 0x7d, 0x84, 0x44, 0xf2, 0x95, 0x1c, 0x28, 0xd3, 0x66, 0xab, 0x65, + 0x5a, 0xcd, 0xaa, 0xb5, 0x6e, 0x3b, 0x6d, 0x9c, 0x10, 0x8f, 0xef, 0x08, 0x57, 0xfd, 0xb3, 0x39, + 0x98, 0x10, 0x0d, 0x9a, 0xd1, 0x1d, 0xe3, 0xf8, 0xce, 0xc7, 0xe2, 0x2d, 0x39, 0x3e, 0x7d, 0x51, + 0xbf, 0x99, 0x07, 0x58, 0xb0, 0x1b, 0x0f, 0x4e, 0xf8, 0x7b, 0xac, 0x37, 0xa1, 0xc4, 0xa3, 0xbc, + 0x09, 0x8d, 0x9d, 0x10, 0xef, 0x8e, 0xd8, 0xa7, 0x71, 0xc4, 0xf4, 0xb8, 0x98, 0x8f, 0x4b, 0x3c, + 0x4a, 0x9c, 0x92, 0xd3, 0x44, 0x11, 0x56, 0x29, 0xa3, 0x13, 0x0b, 0x46, 0x50, 0x29, 0x83, 0x45, + 0x2b, 0xdd, 0xd9, 0x9e, 0x2c, 0xb6, 0xec, 0xc6, 0x03, 0x0d, 0xe9, 0xd5, 0x7f, 0x95, 0xe3, 0xb2, + 0x3b, 0xe1, 0xaf, 0x4a, 0xfd, 0xcf, 0x2f, 0xee, 0xf3, 0xf3, 0xff, 0x5c, 0x0e, 0xce, 0x69, 0xb4, + 0x61, 0x3f, 0xa4, 0xce, 0xd6, 0x8c, 0x6d, 0xd0, 0x5b, 0xd4, 0xa2, 0xce, 0x71, 0x8d, 0xa8, 0xdf, + 0xc1, 0x94, 0x33, 0x61, 0x63, 0xee, 0xba, 0xd4, 0x38, 0x39, 0xe9, 0x80, 0xd4, 0x5f, 0x1b, 0x00, + 0x25, 0xd5, 0xea, 0x3d, 0xb1, 0xe6, 0x5c, 0xe6, 0x56, 0xa6, 0x78, 0x54, 0x5b, 0x99, 0xfe, 0xfd, + 0x6d, 0x65, 0x4a, 0xfb, 0xdd, 0xca, 0x0c, 0xec, 0x65, 0x2b, 0xd3, 0x8e, 0x6f, 0x65, 0x06, 0x71, + 0x2b, 0xf3, 0x72, 0xcf, 0xad, 0xcc, 0xac, 0x65, 0x1c, 0x70, 0x23, 0x73, 0x62, 0x53, 0x55, 0x1f, + 0x64, 0x07, 0x76, 0x95, 0x4d, 0x8a, 0x0d, 0xdb, 0x31, 0xa8, 0x21, 0x36, 0x5e, 0x78, 0xea, 0xef, + 0x08, 0x98, 0x16, 0x60, 0x13, 0x79, 0xbf, 0x47, 0xf7, 0x92, 0xf7, 0xfb, 0x08, 0xf6, 0x5f, 0x5f, + 0xce, 0xc3, 0xc4, 0x0c, 0x75, 0x3c, 0x1e, 0x46, 0xf6, 0x28, 0x5c, 0xe2, 0xca, 0x70, 0x46, 0x62, + 0x88, 0x16, 0x79, 0x3e, 0x74, 0xf3, 0x6b, 0x50, 0xc7, 0x8b, 0x7b, 0x09, 0xc6, 0xe9, 0x59, 0xf5, + 0x7e, 0xee, 0x3d, 0x31, 0x76, 0x83, 0xea, 0x7d, 0x38, 0x17, 0xa4, 0x29, 0x7e, 0x69, 0x01, 0xbd, + 0x94, 0x4e, 0xaf, 0xb8, 0xff, 0x74, 0x7a, 0xea, 0x2f, 0xe7, 0xe0, 0x8a, 0x46, 0x2d, 0xba, 0xa9, + 0xaf, 0xb5, 0xa8, 0xd4, 0x2c, 0xb1, 0x32, 0xb0, 0x59, 0xc3, 0x74, 0xdb, 0xba, 0xd7, 0xd8, 0x38, + 0x94, 0x8c, 0xe6, 0x60, 0x44, 0x9e, 0xbf, 0xf6, 0x31, 0xb7, 0x45, 0xca, 0xa9, 0xbf, 0x56, 0x84, + 0x81, 0x69, 0xdb, 0xbb, 0x6d, 0x1f, 0x32, 0xbf, 0x63, 0x38, 0xe5, 0xe7, 0xf7, 0x71, 0xd6, 0xf3, + 0x29, 0xac, 0x5c, 0x4a, 0x79, 0x81, 0x2e, 0xa4, 0x6b, 0x76, 0x22, 0x35, 0x88, 0x4f, 0xb6, 0xcf, + 0xcc, 0x8e, 0xaf, 0xc2, 0x10, 0x46, 0x7f, 0x91, 0x4e, 0x63, 0xd1, 0x41, 0xdb, 0x63, 0xc0, 0x78, + 0x1d, 0x21, 0x29, 0xf9, 0x81, 0x48, 0xdc, 0xdb, 0xd2, 0xe1, 0x33, 0x41, 0xca, 0x21, 0x70, 0x5f, + 0xe6, 0x17, 0x79, 0xd8, 0x26, 0x29, 0x6b, 0x0e, 0x9e, 0xa2, 0xc4, 0x9a, 0x14, 0x10, 0x1e, 0x61, + 0x96, 0xc6, 0x19, 0x18, 0x9d, 0xb6, 0x3d, 0xc9, 0x19, 0x78, 0x28, 0x7c, 0x06, 0xca, 0x24, 0x9f, + 0xee, 0x09, 0x1c, 0x2d, 0xa3, 0x7e, 0xb7, 0x08, 0x23, 0xfe, 0xcf, 0x63, 0xd2, 0x9d, 0x17, 0xa1, + 0x34, 0x6f, 0x4b, 0x89, 0x43, 0xd0, 0x81, 0x78, 0xc3, 0x76, 0x63, 0x9e, 0xd1, 0x82, 0x88, 0x49, + 0x7d, 0xc9, 0x36, 0x64, 0xf7, 0x77, 0x94, 0xba, 0x65, 0x1b, 0x89, 0xe7, 0xc3, 0x01, 0x21, 0xb9, + 0x02, 0x45, 0x7c, 0x39, 0x20, 0x1d, 0xe4, 0xc7, 0x5e, 0x0b, 0x20, 0x5e, 0xd2, 0xca, 0xd2, 0x7e, + 0xb5, 0x72, 0xe0, 0xa0, 0x5a, 0x39, 0x78, 0xb4, 0x5a, 0xf9, 0x1e, 0x8c, 0x60, 0x4d, 0x7e, 0xde, + 0xc1, 0xdd, 0x17, 0xd6, 0x27, 0xc4, 0xda, 0x37, 0xca, 0xdb, 0x2d, 0xb2, 0x0f, 0xe2, 0x92, 0x17, + 0x61, 0x15, 0xd3, 0x5d, 0x38, 0xc4, 0x76, 0xfa, 0x1f, 0xe7, 0x60, 0xe0, 0xae, 0xf5, 0xc0, 0xb2, + 0x37, 0x0f, 0xa7, 0x71, 0x2f, 0xc3, 0xb0, 0x60, 0x23, 0xad, 0x2e, 0xf8, 0x22, 0xbc, 0xcb, 0xc1, + 0x75, 0xe4, 0xa4, 0xc9, 0x54, 0xe4, 0xad, 0xa0, 0x10, 0x3e, 0x0e, 0x2a, 0x84, 0xa9, 0x77, 0xfc, + 0x42, 0x8d, 0x68, 0xee, 0x0d, 0x99, 0x9c, 0x5c, 0x86, 0x62, 0x85, 0x35, 0x55, 0x8a, 0xc1, 0xcb, + 0x9a, 0xa2, 0x21, 0x54, 0xfd, 0x72, 0x11, 0xc6, 0x62, 0x07, 0x5f, 0xcf, 0xc3, 0x90, 0x38, 0x78, + 0x32, 0xfd, 0x64, 0x20, 0xf8, 0x78, 0x28, 0x00, 0x6a, 0x83, 0xfc, 0xcf, 0xaa, 0x41, 0x3e, 0x03, + 0x03, 0xb6, 0x8b, 0x8b, 0x22, 0x7e, 0xcb, 0x58, 0x38, 0x84, 0x96, 0x6b, 0xac, 0xed, 0x7c, 0x70, + 0x08, 0x12, 0x59, 0x23, 0x6d, 0x17, 0x3f, 0xed, 0x26, 0x0c, 0xe9, 0xae, 0x4b, 0xbd, 0xba, 0xa7, + 0x37, 0xe5, 0xfc, 0x20, 0x01, 0x50, 0x1e, 0x1d, 0x08, 0x5c, 0xd5, 0x9b, 0xe4, 0xb3, 0x30, 0xda, + 0x70, 0x28, 0x2e, 0x9b, 0x7a, 0x8b, 0xb5, 0x52, 0x32, 0x6b, 0x23, 0x08, 0xf9, 0xfe, 0x24, 0x44, + 0x54, 0x0d, 0x72, 0x0f, 0x46, 0xc5, 0xe7, 0x70, 0xcf, 0x7d, 0x1c, 0x68, 0x63, 0xe1, 0x32, 0xc6, + 0x45, 0xc2, 0x7d, 0xf7, 0xc5, 0x03, 0x0e, 0x99, 0x5c, 0xe6, 0x6b, 0x48, 0xa4, 0x64, 0x19, 0xc8, + 0x26, 0x5d, 0xab, 0xeb, 0x5d, 0x6f, 0x83, 0xd5, 0xc5, 0xc3, 0xdb, 0x8b, 0x44, 0x9e, 0xf8, 0xea, + 0x21, 0x89, 0x95, 0x1f, 0x83, 0x6c, 0xd2, 0xb5, 0x72, 0x04, 0x49, 0xee, 0xc3, 0xf9, 0x64, 0x11, + 0xf6, 0xc9, 0xfc, 0x72, 0xe0, 0xb9, 0x9d, 0xed, 0xc9, 0xc9, 0x54, 0x02, 0x89, 0xed, 0xd9, 0x04, + 0xdb, 0xaa, 0x71, 0xbb, 0x38, 0x38, 0x30, 0x3e, 0xa8, 0x8d, 0xb1, 0xb2, 0xbe, 0x09, 0x69, 0x1a, + 0xea, 0xef, 0xe7, 0x98, 0xa9, 0xc8, 0x3e, 0x08, 0x33, 0x99, 0x33, 0x5d, 0x6f, 0xef, 0x53, 0xd7, + 0xdb, 0x61, 0xce, 0xd1, 0x92, 0xdb, 0x63, 0x76, 0xd5, 0x04, 0x96, 0x4c, 0x41, 0xc9, 0x90, 0x4f, + 0xcd, 0x2e, 0x44, 0x3b, 0xc1, 0xaf, 0x47, 0x13, 0x54, 0xe4, 0x2a, 0x14, 0xd9, 0x92, 0x15, 0xdf, + 0x32, 0xcb, 0xd6, 0x85, 0x86, 0x14, 0xea, 0x8f, 0xe4, 0x61, 0x44, 0xfa, 0x9a, 0x1b, 0x87, 0xfa, + 0x9c, 0x37, 0xf6, 0xd6, 0x4c, 0xdf, 0xe9, 0x05, 0xf7, 0x52, 0x7e, 0x93, 0x6f, 0x06, 0xa2, 0xd8, + 0xd3, 0x85, 0x94, 0x10, 0xcc, 0xab, 0xe2, 0x43, 0x4b, 0x7b, 0xdf, 0x3e, 0x32, 0xfa, 0xdb, 0xc5, + 0xc1, 0xfc, 0x78, 0xe1, 0x76, 0x71, 0xb0, 0x38, 0xde, 0x8f, 0x71, 0xb8, 0x30, 0xf4, 0x35, 0xdf, + 0x9b, 0x5b, 0xeb, 0x66, 0xf3, 0x84, 0xbf, 0x1d, 0x39, 0xda, 0x18, 0x65, 0x31, 0xd9, 0x9c, 0xf0, + 0x87, 0x24, 0x1f, 0xaa, 0x6c, 0x4e, 0x73, 0x94, 0x0a, 0xd9, 0xfc, 0x93, 0x1c, 0x28, 0xa9, 0xb2, + 0x29, 0x1f, 0x93, 0x1f, 0xc4, 0xd1, 0x65, 0x2a, 0xfd, 0xe3, 0x3c, 0x4c, 0x54, 0x2d, 0x8f, 0x36, + 0xf9, 0x8e, 0xf1, 0x84, 0x4f, 0x15, 0x77, 0x60, 0x58, 0xfa, 0x18, 0xd1, 0xe7, 0x4f, 0x06, 0xfb, + 0xf1, 0x10, 0x95, 0xc1, 0x49, 0x2e, 0x7d, 0x74, 0x2f, 0x71, 0xe2, 0x42, 0x3e, 0xe1, 0x73, 0xce, + 0xc9, 0x10, 0xf2, 0x09, 0x9f, 0xbc, 0x3e, 0xa2, 0x42, 0xfe, 0xdf, 0x73, 0x70, 0x36, 0xa5, 0x72, + 0x72, 0x05, 0x06, 0x6a, 0xdd, 0x35, 0x0c, 0xbb, 0x95, 0x0b, 0x3d, 0x86, 0xdd, 0xee, 0x1a, 0x46, + 0xdc, 0xd2, 0x7c, 0x24, 0x59, 0xc5, 0xc7, 0xf5, 0xcb, 0xd5, 0xca, 0x8c, 0x90, 0xaa, 0x2a, 0x85, + 0x09, 0x60, 0xe0, 0xb4, 0x2f, 0x0b, 0x1e, 0xe0, 0xdb, 0xa6, 0xd1, 0x88, 0x3d, 0xc0, 0x67, 0x65, + 0xc8, 0x0f, 0xc2, 0x50, 0xf9, 0x83, 0xae, 0x43, 0x91, 0x2f, 0x97, 0xf8, 0xc7, 0x02, 0xbe, 0x3e, + 0x22, 0x8d, 0x33, 0x8f, 0x25, 0xc0, 0x28, 0xe2, 0xbc, 0x43, 0x86, 0xea, 0x4f, 0xe7, 0xe0, 0x52, + 0x76, 0xeb, 0xc8, 0xa7, 0x60, 0x80, 0xed, 0xcc, 0xcb, 0xda, 0x92, 0xf8, 0x74, 0x9e, 0xd5, 0xd7, + 0x6e, 0xd1, 0xba, 0xee, 0xc8, 0xc6, 0xbe, 0x4f, 0x46, 0xde, 0x86, 0xe1, 0xaa, 0xeb, 0x76, 0xa9, + 0x53, 0x7b, 0xf9, 0xae, 0x56, 0x15, 0x7b, 0x42, 0xdc, 0x73, 0x98, 0x08, 0xae, 0xbb, 0x2f, 0xc7, + 0x02, 0x6b, 0xc9, 0xf4, 0xea, 0x4f, 0xe4, 0xe0, 0x72, 0xaf, 0xaf, 0x22, 0x2f, 0xc3, 0xe0, 0x2a, + 0xb5, 0x74, 0xcb, 0xab, 0x56, 0x44, 0x93, 0x70, 0x8b, 0xe5, 0x21, 0x2c, 0xba, 0x53, 0x08, 0x08, + 0x59, 0x21, 0x7e, 0xae, 0x18, 0x38, 0x32, 0xf0, 0x33, 0x50, 0x84, 0xc5, 0x0a, 0xf9, 0x84, 0xea, + 0x1f, 0xe4, 0x61, 0x64, 0xa5, 0xd5, 0x6d, 0x9a, 0xd2, 0xc2, 0x71, 0x60, 0x7b, 0xdb, 0xb7, 0x7e, + 0xf3, 0xfb, 0xb3, 0x7e, 0xd9, 0x70, 0x73, 0x0e, 0x38, 0xdc, 0xfc, 0x72, 0xe4, 0x2d, 0x28, 0x75, + 0xf0, 0x3b, 0xe2, 0x27, 0xb1, 0xfc, 0xeb, 0xb2, 0x4e, 0x62, 0x79, 0x19, 0x36, 0xbe, 0x1a, 0x87, + 0x18, 0x5f, 0x61, 0x59, 0x49, 0xa0, 0xe1, 0x22, 0x71, 0x2a, 0xd0, 0x23, 0x11, 0x68, 0xb8, 0x20, + 0x9c, 0x0a, 0xf4, 0x10, 0x02, 0xfd, 0xb5, 0x3c, 0x8c, 0x45, 0xab, 0x24, 0x9f, 0x82, 0x61, 0x5e, + 0x0d, 0x3f, 0x17, 0xca, 0x49, 0x4e, 0xc5, 0x21, 0x58, 0x03, 0xfe, 0x43, 0x1c, 0x70, 0x9d, 0xd9, + 0xd0, 0xdd, 0x7a, 0x78, 0x42, 0xc3, 0xef, 0x6f, 0x07, 0xb9, 0x27, 0x54, 0x0c, 0xa5, 0x8d, 0x6d, + 0xe8, 0xee, 0x4c, 0xf8, 0x9b, 0xcc, 0x02, 0x71, 0x68, 0xd7, 0xa5, 0x51, 0x06, 0x45, 0x64, 0x20, + 0x52, 0xaa, 0xc7, 0xb1, 0xda, 0x04, 0x87, 0xc9, 0x6c, 0xbe, 0x10, 0x34, 0x1b, 0x95, 0xa1, 0x7f, + 0x0f, 0xf9, 0xde, 0x25, 0xfa, 0xf4, 0x63, 0x4e, 0x4e, 0x50, 0xd1, 0x3d, 0x9d, 0x6f, 0xca, 0xfd, + 0x0e, 0x50, 0x7f, 0xb4, 0x03, 0xfd, 0xcb, 0x16, 0x5d, 0x5e, 0x27, 0x2f, 0xc1, 0x10, 0x53, 0x98, + 0x05, 0x9b, 0xf5, 0x65, 0x4e, 0xf8, 0x4f, 0x48, 0x9a, 0x84, 0x88, 0xf9, 0x3e, 0x2d, 0xa4, 0x22, + 0x37, 0x01, 0xc2, 0x27, 0x66, 0x42, 0xfb, 0x88, 0x5c, 0x86, 0x63, 0xe6, 0xfb, 0x34, 0x89, 0xce, + 0x2f, 0x25, 0x1e, 0xe8, 0x14, 0x92, 0xa5, 0x38, 0xc6, 0x2f, 0x25, 0xc6, 0xc7, 0x02, 0x10, 0xf6, + 0x6b, 0x45, 0x77, 0xdd, 0x4d, 0xdb, 0x31, 0x66, 0x36, 0x74, 0xab, 0x49, 0xe3, 0xbb, 0xa7, 0x24, + 0xc5, 0x7c, 0x9f, 0x96, 0x52, 0x8e, 0xbc, 0x01, 0x23, 0xb2, 0x43, 0x69, 0xdc, 0xe9, 0x43, 0xc6, + 0xcd, 0xf7, 0x69, 0x11, 0x5a, 0xf2, 0x1a, 0x0c, 0x8b, 0xdf, 0xb7, 0x6d, 0x71, 0xa3, 0x2c, 0xc5, + 0x22, 0x92, 0x50, 0xf3, 0x7d, 0x9a, 0x4c, 0x29, 0x55, 0xba, 0xe2, 0x98, 0x96, 0x27, 0xde, 0x28, + 0xc7, 0x2b, 0x45, 0x9c, 0x54, 0x29, 0xfe, 0x26, 0x6f, 0xc3, 0x68, 0x10, 0xe4, 0xe9, 0x7d, 0xda, + 0xf0, 0xc4, 0xe1, 0xf7, 0xf9, 0x58, 0x61, 0x8e, 0x9c, 0xef, 0xd3, 0xa2, 0xd4, 0xe4, 0x2a, 0x94, + 0x34, 0xea, 0x9a, 0x1f, 0xf8, 0xd7, 0xc5, 0x63, 0xd2, 0x38, 0x37, 0x3f, 0x60, 0x52, 0x12, 0x78, + 0xd6, 0x3b, 0xe1, 0xfd, 0xb4, 0x38, 0xaa, 0x26, 0xb1, 0x5a, 0x66, 0x2d, 0x83, 0xf5, 0x8e, 0xe4, + 0x9c, 0xf0, 0xd9, 0x30, 0xf4, 0x95, 0x48, 0xda, 0x3a, 0x1c, 0x8f, 0x31, 0x20, 0x63, 0xe7, 0xfb, + 0xb4, 0x18, 0xbd, 0x24, 0xd5, 0x8a, 0xe9, 0x3e, 0x10, 0xd1, 0x46, 0xe3, 0x52, 0x65, 0x28, 0x49, + 0xaa, 0xec, 0xa7, 0x54, 0xf5, 0x12, 0xf5, 0x36, 0x6d, 0xe7, 0x81, 0x88, 0x2d, 0x1a, 0xaf, 0x5a, + 0x60, 0xa5, 0xaa, 0x05, 0x44, 0xae, 0x9a, 0x0d, 0xb8, 0xb1, 0xf4, 0xaa, 0x75, 0x4f, 0x97, 0xab, + 0xe6, 0x27, 0x71, 0x7e, 0x27, 0x2d, 0x50, 0xfd, 0x21, 0xcf, 0xf6, 0x9f, 0xec, 0x50, 0xc4, 0x49, + 0x1d, 0x8a, 0xbf, 0x59, 0xa5, 0x52, 0x46, 0x77, 0x91, 0xce, 0x3f, 0xa8, 0x54, 0x42, 0xb1, 0x4a, + 0xe5, 0xdc, 0xef, 0x37, 0xe5, 0xb4, 0xe1, 0xca, 0x44, 0xb4, 0x83, 0x42, 0x0c, 0xeb, 0x20, 0x29, + 0xbd, 0xf8, 0x24, 0xa6, 0x24, 0x56, 0x08, 0x92, 0x0f, 0x07, 0x2d, 0x9c, 0x59, 0x99, 0xef, 0xd3, + 0x30, 0x59, 0xb1, 0xca, 0x93, 0x5d, 0x2b, 0x67, 0x91, 0x62, 0xc4, 0xa7, 0x60, 0xb0, 0xf9, 0x3e, + 0x8d, 0x27, 0xc2, 0x7e, 0x49, 0x4a, 0x08, 0xa8, 0x9c, 0x8b, 0x4e, 0x11, 0x01, 0x82, 0x4d, 0x11, + 0x61, 0xda, 0xc0, 0xb9, 0x64, 0xda, 0x3b, 0xe5, 0x7c, 0x74, 0xa9, 0x89, 0xe3, 0xe7, 0xfb, 0xb4, + 0x64, 0xaa, 0xbc, 0xd7, 0x22, 0x99, 0xe0, 0x94, 0x0b, 0xb1, 0x00, 0x60, 0x21, 0x8a, 0x89, 0x4b, + 0xce, 0x19, 0xb7, 0x1c, 0xcb, 0xf5, 0x2f, 0x26, 0xab, 0x8b, 0xd1, 0x8d, 0x4b, 0x0a, 0xc9, 0x7c, + 0x9f, 0x96, 0x56, 0x92, 0xcc, 0x24, 0xf2, 0xb1, 0x29, 0x4a, 0xd4, 0x37, 0x26, 0x86, 0x9e, 0xef, + 0xd3, 0x12, 0x19, 0xdc, 0x6e, 0xca, 0x89, 0xd0, 0x94, 0x27, 0xa2, 0x9d, 0x18, 0x62, 0x58, 0x27, + 0x4a, 0x09, 0xd3, 0x6e, 0xca, 0xc9, 0xb1, 0x94, 0x4b, 0xc9, 0x52, 0xe1, 0xcc, 0x29, 0x25, 0xd1, + 0xd2, 0xd2, 0xf3, 0xfd, 0x28, 0x4f, 0x8a, 0xac, 0xbf, 0xa2, 0x7c, 0x1a, 0xcd, 0x7c, 0x9f, 0x96, + 0x9e, 0x2b, 0x48, 0x4b, 0x4f, 0x94, 0xa3, 0x5c, 0xee, 0xc5, 0x33, 0x68, 0x5d, 0x7a, 0x92, 0x1d, + 0xbd, 0x47, 0xda, 0x12, 0xe5, 0xa9, 0x68, 0xf4, 0xe1, 0x4c, 0xc2, 0xf9, 0x3e, 0xad, 0x47, 0xf2, + 0x93, 0xbb, 0x19, 0x39, 0x44, 0x94, 0xa7, 0xa3, 0x49, 0xbf, 0x53, 0x89, 0xe6, 0xfb, 0xb4, 0x8c, + 0x0c, 0x24, 0x77, 0x33, 0x52, 0x4c, 0x28, 0x93, 0x3d, 0xd9, 0x06, 0xf2, 0xc8, 0x48, 0x50, 0xb1, + 0x9c, 0x9a, 0x9d, 0x41, 0x79, 0x26, 0xaa, 0xba, 0x29, 0x24, 0x4c, 0x75, 0xd3, 0xf2, 0x3a, 0x2c, + 0xa7, 0xa6, 0x13, 0x50, 0x9e, 0xed, 0xc1, 0x30, 0x68, 0x63, 0x6a, 0x22, 0x82, 0xe5, 0xd4, 0x78, + 0xfe, 0x8a, 0x1a, 0x65, 0x98, 0x42, 0xc2, 0x18, 0xa6, 0x65, 0x02, 0x58, 0x4e, 0x0d, 0xfb, 0xae, + 0x3c, 0xd7, 0x83, 0x61, 0xd8, 0xc2, 0xb4, 0x80, 0xf1, 0xaf, 0x45, 0xe2, 0xae, 0x2b, 0x1f, 0x8b, + 0xce, 0x1b, 0x12, 0x8a, 0xcd, 0x1b, 0x72, 0x84, 0xf6, 0x99, 0x44, 0x64, 0x59, 0xe5, 0xe3, 0xd1, + 0x61, 0x1e, 0x43, 0xb3, 0x61, 0x1e, 0x8f, 0x45, 0x3b, 0x93, 0x88, 0xb0, 0xa9, 0x5c, 0xc9, 0x62, + 0x82, 0xe8, 0x28, 0x13, 0x1e, 0x93, 0xb3, 0x9a, 0x12, 0xe2, 0x51, 0xf9, 0x44, 0xd4, 0xaf, 0x3b, + 0x41, 0x30, 0xdf, 0xa7, 0xa5, 0x04, 0x86, 0xd4, 0xd2, 0xe3, 0x19, 0x29, 0x57, 0xa3, 0xc3, 0x36, + 0x8d, 0x86, 0x0d, 0xdb, 0xd4, 0x58, 0x48, 0x0b, 0x69, 0x8f, 0x4f, 0x94, 0x6b, 0x51, 0xc3, 0x2c, + 0x49, 0xc1, 0x0c, 0xb3, 0x94, 0x47, 0x2b, 0x5a, 0x7a, 0x8c, 0x1d, 0xe5, 0xf9, 0x9e, 0x2d, 0x44, + 0x9a, 0x94, 0x16, 0xf2, 0x90, 0x33, 0xa1, 0xed, 0x74, 0xb7, 0xd3, 0xb2, 0x75, 0x43, 0xf9, 0x64, + 0xaa, 0xed, 0xc4, 0x91, 0x92, 0xed, 0xc4, 0x01, 0x6c, 0x95, 0x97, 0xdf, 0x38, 0x28, 0x2f, 0x44, + 0x57, 0x79, 0x19, 0xc7, 0x56, 0xf9, 0xc8, 0x7b, 0x88, 0x99, 0xc4, 0x7b, 0x00, 0xe5, 0xc5, 0xa8, + 0x02, 0xc4, 0xd0, 0x4c, 0x01, 0xe2, 0x2f, 0x08, 0xbe, 0x98, 0xed, 0x41, 0xaf, 0x4c, 0x21, 0xb7, + 0x67, 0x7c, 0x6e, 0x59, 0x74, 0xf3, 0x7d, 0x5a, 0xb6, 0x17, 0x7e, 0x35, 0xc5, 0x21, 0x5e, 0xb9, + 0x1e, 0x55, 0xb0, 0x04, 0x01, 0x53, 0xb0, 0xa4, 0x1b, 0x7d, 0x35, 0xc5, 0xa3, 0x5d, 0xf9, 0x54, + 0x26, 0xab, 0xe0, 0x9b, 0x53, 0xfc, 0xe0, 0x6f, 0xca, 0x2e, 0xe9, 0xca, 0x4b, 0xd1, 0xc5, 0x2e, + 0xc4, 0xb0, 0xc5, 0x4e, 0x72, 0x5d, 0xbf, 0x29, 0x3b, 0x63, 0x2b, 0x37, 0x92, 0xa5, 0xc2, 0x25, + 0x52, 0x72, 0xda, 0xd6, 0xd2, 0x7d, 0x98, 0x95, 0x97, 0xa3, 0x5a, 0x97, 0x46, 0xc3, 0xb4, 0x2e, + 0xd5, 0xff, 0x79, 0x2e, 0xe9, 0x8a, 0xac, 0xdc, 0x8c, 0x6f, 0xb2, 0xa3, 0x78, 0x66, 0xf9, 0x24, + 0xdc, 0x97, 0x3f, 0x1b, 0x0f, 0xb6, 0xa7, 0xbc, 0x12, 0xbb, 0xf6, 0x8d, 0x60, 0x99, 0x7d, 0x1b, + 0x0b, 0xce, 0xf7, 0xd9, 0x78, 0x7c, 0x3a, 0xe5, 0xd5, 0x74, 0x0e, 0x81, 0xae, 0xc4, 0xe3, 0xd9, + 0x7d, 0x36, 0x1e, 0xd2, 0x4d, 0x79, 0x2d, 0x9d, 0x43, 0x20, 0xdd, 0x78, 0x08, 0xb8, 0x97, 0xa4, + 0x20, 0xf3, 0xca, 0xa7, 0xa3, 0xa6, 0x63, 0x80, 0x60, 0xa6, 0x63, 0x18, 0x8a, 0xfe, 0x25, 0x29, + 0x38, 0xbb, 0xf2, 0x7a, 0xa2, 0x48, 0xd0, 0x58, 0x29, 0x84, 0xfb, 0x4b, 0x52, 0x50, 0x73, 0xe5, + 0x8d, 0x44, 0x91, 0xa0, 0x75, 0x52, 0xe8, 0x73, 0xa3, 0xd7, 0xfb, 0x55, 0xe5, 0xcd, 0xe8, 0x61, + 0x70, 0x36, 0xe5, 0x7c, 0x9f, 0xd6, 0xeb, 0x1d, 0xec, 0x17, 0xb3, 0x1d, 0xbb, 0x95, 0xb7, 0xa2, + 0x43, 0x38, 0x8b, 0x8e, 0x0d, 0xe1, 0x4c, 0xe7, 0xf0, 0xb7, 0x63, 0xb1, 0x2c, 0x94, 0xb7, 0xa3, + 0x53, 0x5c, 0x04, 0xc9, 0xa6, 0xb8, 0x78, 0xe4, 0x8b, 0x48, 0x90, 0x06, 0xe5, 0x33, 0xd1, 0x29, + 0x4e, 0xc6, 0xb1, 0x29, 0x2e, 0x12, 0xd0, 0x61, 0x26, 0x11, 0x3b, 0x40, 0x79, 0x27, 0x3a, 0xc5, + 0xc5, 0xd0, 0x6c, 0x8a, 0x8b, 0x47, 0x1b, 0x78, 0x3b, 0xf6, 0x84, 0x5e, 0xf9, 0x6c, 0x7a, 0xfb, + 0x11, 0x29, 0xb7, 0x9f, 0x3f, 0xb8, 0xd7, 0xd2, 0xdf, 0x82, 0x2b, 0xe5, 0xe8, 0xf8, 0x4d, 0xa3, + 0x61, 0xe3, 0x37, 0xf5, 0x1d, 0x79, 0x7c, 0xe3, 0x20, 0xb4, 0x6a, 0xba, 0xc7, 0xc6, 0x21, 0x34, + 0x45, 0x52, 0xc0, 0x91, 0x3d, 0x32, 0xdf, 0x08, 0xcd, 0x64, 0xec, 0x91, 0xfd, 0x6d, 0x50, 0x8c, + 0x9e, 0xcd, 0xae, 0x09, 0x3f, 0x63, 0xa5, 0x12, 0x9d, 0x5d, 0x13, 0x04, 0x6c, 0x76, 0x4d, 0x7a, + 0x27, 0xcf, 0xc1, 0xb8, 0xd0, 0x22, 0xee, 0x3e, 0x6d, 0x5a, 0x4d, 0x65, 0x36, 0xf6, 0xde, 0x32, + 0x86, 0x67, 0xb3, 0x53, 0x1c, 0x86, 0xeb, 0x35, 0x87, 0xcd, 0xb4, 0xcc, 0xce, 0x9a, 0xad, 0x3b, + 0x46, 0x8d, 0x5a, 0x86, 0x32, 0x17, 0x5b, 0xaf, 0x53, 0x68, 0x70, 0xbd, 0x4e, 0x81, 0x63, 0x88, + 0xb8, 0x18, 0x5c, 0xa3, 0x0d, 0x6a, 0x3e, 0xa4, 0xca, 0x2d, 0x64, 0x3b, 0x99, 0xc5, 0x56, 0x90, + 0xcd, 0xf7, 0x69, 0x59, 0x1c, 0x98, 0xad, 0xbe, 0xb8, 0x55, 0x7b, 0x77, 0x21, 0x08, 0x3f, 0xb0, + 0xe2, 0xd0, 0x8e, 0xee, 0x50, 0x65, 0x3e, 0x6a, 0xab, 0xa7, 0x12, 0x31, 0x5b, 0x3d, 0x15, 0x91, + 0x64, 0xeb, 0x8f, 0x85, 0x6a, 0x2f, 0xb6, 0xe1, 0x88, 0x48, 0x2f, 0xcd, 0x66, 0xa7, 0x28, 0x82, + 0x09, 0x68, 0xc1, 0xb6, 0x9a, 0x78, 0x52, 0x71, 0x3b, 0x3a, 0x3b, 0x65, 0x53, 0xb2, 0xd9, 0x29, + 0x1b, 0xcb, 0x54, 0x3d, 0x8a, 0xe5, 0x63, 0xf0, 0x4e, 0x54, 0xd5, 0x53, 0x48, 0x98, 0xaa, 0xa7, + 0x80, 0x93, 0x0c, 0x35, 0xea, 0x52, 0x4f, 0x59, 0xe8, 0xc5, 0x10, 0x49, 0x92, 0x0c, 0x11, 0x9c, + 0x64, 0x38, 0x47, 0xbd, 0xc6, 0x86, 0xb2, 0xd8, 0x8b, 0x21, 0x92, 0x24, 0x19, 0x22, 0x98, 0x6d, + 0x36, 0xa3, 0xe0, 0xe9, 0x6e, 0xeb, 0x81, 0xdf, 0x67, 0x4b, 0xd1, 0xcd, 0x66, 0x26, 0x21, 0xdb, + 0x6c, 0x66, 0x22, 0xc9, 0x4f, 0xec, 0xd9, 0x0f, 0x5e, 0x59, 0xc6, 0x0a, 0xa7, 0x42, 0xbb, 0x60, + 0x2f, 0xa5, 0xe6, 0xfb, 0xb4, 0xbd, 0xfa, 0xd9, 0x7f, 0x32, 0x70, 0x1a, 0x55, 0x56, 0xb0, 0xaa, + 0x33, 0xc1, 0x59, 0x05, 0x07, 0xcf, 0xf7, 0x69, 0x81, 0x5b, 0xe9, 0x6b, 0x30, 0x8c, 0x1f, 0x55, + 0xb5, 0x4c, 0xaf, 0x32, 0xad, 0xbc, 0x1b, 0xdd, 0x32, 0x49, 0x28, 0xb6, 0x65, 0x92, 0x7e, 0xb2, + 0x49, 0x1c, 0x7f, 0xf2, 0x29, 0xa6, 0x32, 0xad, 0x68, 0xd1, 0x49, 0x3c, 0x82, 0x64, 0x93, 0x78, + 0x04, 0x10, 0xd4, 0x5b, 0x71, 0xec, 0x4e, 0x65, 0x5a, 0xa9, 0xa5, 0xd4, 0xcb, 0x51, 0x41, 0xbd, + 0xfc, 0x67, 0x50, 0x6f, 0x6d, 0xa3, 0xeb, 0x55, 0xd8, 0x37, 0xae, 0xa6, 0xd4, 0xeb, 0x23, 0x83, + 0x7a, 0x7d, 0x00, 0x9b, 0x0a, 0x11, 0xb0, 0xe2, 0xd8, 0x6c, 0xd2, 0xbe, 0x63, 0xb6, 0x5a, 0xca, + 0xdd, 0xe8, 0x54, 0x18, 0xc7, 0xb3, 0xa9, 0x30, 0x0e, 0x63, 0xa6, 0x27, 0x6f, 0x15, 0x5d, 0xeb, + 0x36, 0x95, 0x7b, 0x51, 0xd3, 0x33, 0xc4, 0x30, 0xd3, 0x33, 0xfc, 0x85, 0xbb, 0x0b, 0xf6, 0x4b, + 0xa3, 0xeb, 0x0e, 0x75, 0x37, 0x94, 0xfb, 0xb1, 0xdd, 0x85, 0x84, 0xc3, 0xdd, 0x85, 0xf4, 0x9b, + 0x34, 0xe1, 0xc9, 0xc8, 0x42, 0xe3, 0x5f, 0xda, 0xd4, 0xa8, 0xee, 0x34, 0x36, 0x94, 0xcf, 0x21, + 0xab, 0xe7, 0x52, 0x97, 0xaa, 0x28, 0xe9, 0x7c, 0x9f, 0xd6, 0x8b, 0x13, 0x6e, 0xcb, 0xdf, 0x5d, + 0xe0, 0x91, 0x60, 0xb5, 0x95, 0x19, 0x7f, 0x13, 0xfa, 0x5e, 0x6c, 0x5b, 0x9e, 0x24, 0xc1, 0x6d, + 0x79, 0x12, 0x4c, 0x3a, 0xf0, 0x74, 0x6c, 0xab, 0xb6, 0xa8, 0xb7, 0xd8, 0xbe, 0x84, 0x1a, 0x2b, + 0x7a, 0xe3, 0x01, 0xf5, 0x94, 0xcf, 0x23, 0xef, 0x2b, 0x19, 0x1b, 0xbe, 0x18, 0xf5, 0x7c, 0x9f, + 0xb6, 0x0b, 0x3f, 0xa2, 0x42, 0xb1, 0x36, 0xb7, 0xba, 0xa2, 0xfc, 0x40, 0xf4, 0x7c, 0x93, 0xc1, + 0xe6, 0xfb, 0x34, 0xc4, 0x31, 0x2b, 0xed, 0x6e, 0xa7, 0xe9, 0xe8, 0x06, 0xe5, 0x86, 0x16, 0xda, + 0x6e, 0xc2, 0x00, 0xfd, 0xc1, 0xa8, 0x95, 0x96, 0x45, 0xc7, 0xac, 0xb4, 0x2c, 0x1c, 0x53, 0xd4, + 0x48, 0xd2, 0x13, 0xe5, 0x0b, 0x51, 0x45, 0x8d, 0x20, 0x99, 0xa2, 0x46, 0x53, 0xa4, 0x7c, 0x0e, + 0x2e, 0x04, 0xfb, 0x79, 0xb1, 0xfe, 0xf2, 0x4e, 0x53, 0xbe, 0x88, 0x7c, 0x9e, 0x4e, 0x5c, 0x06, + 0x44, 0xa8, 0xe6, 0xfb, 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, 0xd6, 0x76, 0x61, 0x1e, 0x58, 0x6b, 0x59, + 0x1c, 0xc8, 0x55, 0x28, 0xd5, 0x6a, 0x8b, 0x5a, 0xd7, 0x52, 0x1a, 0x31, 0x6f, 0x59, 0x84, 0xce, + 0xf7, 0x69, 0x02, 0xcf, 0xcc, 0xa0, 0xd9, 0x96, 0xee, 0x7a, 0x66, 0xc3, 0xc5, 0x11, 0xe3, 0x8f, + 0x10, 0x23, 0x6a, 0x06, 0xa5, 0xd1, 0x30, 0x33, 0x28, 0x0d, 0xce, 0xec, 0xc5, 0x19, 0xdd, 0x75, + 0x75, 0xcb, 0x70, 0xf4, 0x69, 0x5c, 0x26, 0x68, 0xec, 0x35, 0x56, 0x04, 0xcb, 0xec, 0xc5, 0x28, + 0x04, 0x0f, 0xdf, 0x7d, 0x88, 0x6f, 0xe6, 0xac, 0xc7, 0x0e, 0xdf, 0x63, 0x78, 0x3c, 0x7c, 0x8f, + 0xc1, 0xd0, 0xee, 0xf4, 0x61, 0x1a, 0x6d, 0x9a, 0x4c, 0x44, 0x4a, 0x33, 0x66, 0x77, 0xc6, 0x09, + 0xd0, 0xee, 0x8c, 0x03, 0x23, 0x4d, 0xf2, 0x97, 0xdb, 0x8d, 0x8c, 0x26, 0x85, 0xab, 0x6c, 0xa2, + 0x0c, 0x5b, 0xbf, 0xc3, 0xc1, 0x51, 0xd9, 0xb2, 0xf4, 0xb6, 0x5d, 0x99, 0xf6, 0xa5, 0x6e, 0x46, + 0xd7, 0xef, 0x4c, 0x42, 0xb6, 0x7e, 0x67, 0x22, 0xd9, 0xec, 0xea, 0x6f, 0xb4, 0x36, 0x74, 0x87, + 0x1a, 0x15, 0xd3, 0xc1, 0x93, 0xc5, 0x2d, 0xbe, 0x35, 0x7c, 0x3f, 0x3a, 0xbb, 0xf6, 0x20, 0x65, + 0xb3, 0x6b, 0x0f, 0x34, 0x33, 0xf2, 0xd2, 0xd1, 0x1a, 0xd5, 0x0d, 0xe5, 0x41, 0xd4, 0xc8, 0xcb, + 0xa6, 0x64, 0x46, 0x5e, 0x36, 0x36, 0xfb, 0x73, 0xee, 0x3b, 0xa6, 0x47, 0x95, 0xd6, 0x5e, 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, 0x81, 0x33, 0x78, 0x0b, 0xae, 0x75, 0x83, 0x7b, 0x9c, 0x1f, 0x8e, 0x7e, 0x66, 0x0c, 0xcd, + 0x3e, 0x33, 0x06, 0x8a, 0x30, 0x11, 0xd3, 0x96, 0x93, 0xc1, 0x24, 0x3c, 0x1f, 0x8c, 0x81, 0xc8, + 0x02, 0x90, 0x5a, 0x79, 0x71, 0xa1, 0x6a, 0xac, 0xc8, 0x57, 0x64, 0x6e, 0xf4, 0x04, 0x36, 0x49, + 0x31, 0xdf, 0xa7, 0xa5, 0x94, 0x23, 0xef, 0xc3, 0x65, 0x01, 0x15, 0x2f, 0xae, 0x31, 0xed, 0xbf, + 0x11, 0x2c, 0x08, 0x5e, 0xd4, 0x8f, 0xad, 0x17, 0xed, 0x7c, 0x9f, 0xd6, 0x93, 0x57, 0x76, 0x5d, + 0x62, 0x7d, 0xe8, 0xee, 0xa5, 0xae, 0x60, 0x91, 0xe8, 0xc9, 0x2b, 0xbb, 0x2e, 0x21, 0xf7, 0x87, + 0x7b, 0xa9, 0x2b, 0xe8, 0x84, 0x9e, 0xbc, 0x88, 0x0b, 0x93, 0xbd, 0xf0, 0xe5, 0x56, 0x4b, 0xd9, + 0xc4, 0xea, 0x3e, 0xb1, 0x97, 0xea, 0xca, 0x68, 0x70, 0xee, 0xc6, 0x91, 0xcd, 0xd2, 0xcb, 0x1d, + 0x6a, 0xd5, 0x22, 0x0b, 0xd0, 0xa3, 0xe8, 0x2c, 0x9d, 0x20, 0x60, 0xb3, 0x74, 0x02, 0xc8, 0x06, + 0x94, 0xfc, 0x5c, 0x45, 0xd9, 0x8a, 0x0e, 0x28, 0x19, 0xc7, 0x06, 0x54, 0xe4, 0x69, 0xcb, 0x32, + 0x9c, 0x5d, 0x7e, 0xe0, 0xe9, 0xbe, 0x05, 0xe9, 0x8a, 0xae, 0xfc, 0x20, 0x76, 0xc9, 0x94, 0x24, + 0xc1, 0x4b, 0xa6, 0x24, 0x98, 0x8d, 0x11, 0x06, 0xae, 0x6d, 0x59, 0x8d, 0x39, 0xdd, 0x6c, 0x75, + 0x1d, 0xaa, 0xfc, 0x6b, 0xd1, 0x31, 0x12, 0x43, 0xb3, 0x31, 0x12, 0x03, 0xb1, 0x05, 0x9a, 0x81, + 0xca, 0xae, 0x6b, 0x36, 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, 0x82, + 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, 0x92, 0xf9, 0x88, 0x91, 0xf2, + 0x23, 0xb9, 0x2c, 0x46, 0xc1, 0xf0, 0x48, 0x14, 0x8a, 0x32, 0xd2, 0xe8, 0x43, 0x93, 0x6e, 0x2a, + 0x5f, 0xca, 0x64, 0xc4, 0x09, 0xa2, 0x8c, 0x38, 0x8c, 0xbc, 0x07, 0x17, 0x42, 0xd8, 0x22, 0x6d, + 0xaf, 0x05, 0x33, 0xd3, 0x8f, 0xe6, 0xa2, 0x66, 0x70, 0x3a, 0x19, 0x33, 0x83, 0xd3, 0x31, 0x69, + 0xac, 0x85, 0xe8, 0xfe, 0xed, 0x5d, 0x58, 0x07, 0x12, 0xcc, 0x60, 0x90, 0xc6, 0x5a, 0x48, 0xf3, + 0xc7, 0x76, 0x61, 0x1d, 0xc8, 0x34, 0x83, 0x01, 0xf9, 0xc9, 0x1c, 0x5c, 0x49, 0x47, 0x95, 0x5b, + 0xad, 0x39, 0xdb, 0x09, 0x71, 0xca, 0x9f, 0xc9, 0x45, 0x0f, 0x1a, 0xf6, 0x56, 0x6c, 0xbe, 0x4f, + 0xdb, 0x63, 0x05, 0xe4, 0x33, 0x30, 0x5a, 0xee, 0x1a, 0xa6, 0x87, 0x17, 0x6f, 0xcc, 0x70, 0xfe, + 0xf1, 0x5c, 0x6c, 0x8b, 0x23, 0x63, 0x71, 0x8b, 0x23, 0x03, 0xc8, 0x6d, 0x98, 0xa8, 0xd1, 0x46, + 0xd7, 0x31, 0xbd, 0x2d, 0x8d, 0x76, 0x6c, 0xc7, 0x63, 0x3c, 0xfe, 0x6c, 0x2e, 0x3a, 0x89, 0x25, + 0x28, 0xd8, 0x24, 0x96, 0x00, 0x92, 0x7b, 0x89, 0x5b, 0x79, 0xd1, 0x99, 0x3f, 0x91, 0xeb, 0x79, + 0x2d, 0x1f, 0xf4, 0x65, 0x7a, 0x71, 0xb2, 0x12, 0xbb, 0x45, 0x17, 0x5c, 0x7f, 0x32, 0xd7, 0xe3, + 0x1a, 0x5d, 0x9a, 0xe1, 0x92, 0x60, 0xc6, 0x31, 0x25, 0x03, 0xbc, 0xf2, 0xe7, 0x72, 0x3d, 0xae, + 0xbd, 0x43, 0x8e, 0x69, 0xc9, 0xe3, 0x5f, 0xe1, 0x9e, 0x22, 0x82, 0xd1, 0x4f, 0xe5, 0x92, 0xae, + 0x22, 0x41, 0x79, 0x89, 0x90, 0x15, 0xbb, 0xeb, 0x06, 0x4a, 0xff, 0xe5, 0x5c, 0xd2, 0x37, 0x2f, + 0x2c, 0x16, 0xfe, 0x22, 0x14, 0x2e, 0xcd, 0x3e, 0xf2, 0xa8, 0x63, 0xe9, 0x2d, 0xec, 0xce, 0x9a, + 0x67, 0x3b, 0x7a, 0x93, 0xce, 0x5a, 0xfa, 0x5a, 0x8b, 0x2a, 0x3f, 0x9d, 0x8b, 0x5a, 0xb0, 0xd9, + 0xa4, 0xcc, 0x82, 0xcd, 0xc6, 0x92, 0x0d, 0x78, 0x32, 0x0d, 0x5b, 0x31, 0x5d, 0xac, 0xe7, 0x2b, + 0xb9, 0xa8, 0x09, 0xdb, 0x83, 0x96, 0x99, 0xb0, 0x3d, 0xd0, 0xe4, 0x06, 0x0c, 0x4d, 0xdb, 0xfe, + 0xf4, 0xfb, 0xe7, 0x63, 0xce, 0x90, 0x01, 0x66, 0xbe, 0x4f, 0x0b, 0xc9, 0x44, 0x19, 0x31, 0xa8, + 0xbf, 0x9a, 0x2c, 0x13, 0x5e, 0x3e, 0x05, 0x3f, 0x44, 0x19, 0x21, 0xee, 0x7f, 0x27, 0x59, 0x26, + 0xbc, 0xe3, 0x0a, 0x7e, 0xb0, 0x99, 0x84, 0xd7, 0xb8, 0x38, 0x57, 0x66, 0x76, 0xdb, 0xcc, 0x86, + 0xde, 0x6a, 0x51, 0xab, 0x49, 0x95, 0xaf, 0xc5, 0x66, 0x92, 0x74, 0x32, 0x36, 0x93, 0xa4, 0x63, + 0xc8, 0x0f, 0xc2, 0xc5, 0x7b, 0x7a, 0xcb, 0x34, 0x42, 0x9c, 0x9f, 0x0f, 0x5c, 0xf9, 0x99, 0x5c, + 0x74, 0x37, 0x9d, 0x41, 0xc7, 0x76, 0xd3, 0x19, 0x28, 0xb2, 0x08, 0x04, 0x97, 0xd1, 0x60, 0xb6, + 0x60, 0xeb, 0xb3, 0xf2, 0xef, 0xe6, 0xa2, 0x76, 0x6a, 0x92, 0x84, 0xd9, 0xa9, 0x49, 0x28, 0xa9, + 0x67, 0xa7, 0x06, 0x51, 0x7e, 0x36, 0x17, 0x3d, 0xad, 0xc9, 0x22, 0x9c, 0xef, 0xd3, 0xb2, 0xf3, + 0x8b, 0xdc, 0x82, 0xf1, 0xda, 0x4a, 0x75, 0x6e, 0x6e, 0xb6, 0x76, 0xaf, 0x5a, 0xc1, 0x87, 0x0e, + 0x86, 0xf2, 0x17, 0x62, 0x2b, 0x56, 0x9c, 0x80, 0xad, 0x58, 0x71, 0x18, 0x79, 0x13, 0x46, 0x58, + 0xfb, 0xd9, 0x80, 0xc1, 0x4f, 0xfe, 0xb9, 0x5c, 0xd4, 0x9c, 0x92, 0x91, 0xcc, 0x9c, 0x92, 0x7f, + 0x93, 0x1a, 0x9c, 0x63, 0x52, 0x5c, 0x71, 0xe8, 0x3a, 0x75, 0xa8, 0xd5, 0xf0, 0xc7, 0xf4, 0xcf, + 0xe7, 0xa2, 0x56, 0x46, 0x1a, 0x11, 0xb3, 0x32, 0xd2, 0xe0, 0xe4, 0x01, 0x5c, 0x8e, 0x9f, 0x04, + 0xc9, 0xcf, 0x4e, 0x95, 0xbf, 0x98, 0x8b, 0x19, 0xc3, 0x3d, 0x88, 0xd1, 0x18, 0xee, 0x81, 0x27, + 0x16, 0x3c, 0x25, 0x8e, 0x55, 0x84, 0xc3, 0x65, 0xbc, 0xb6, 0xbf, 0xc4, 0x6b, 0xfb, 0x78, 0xe8, + 0x10, 0xd8, 0x83, 0x7a, 0xbe, 0x4f, 0xeb, 0xcd, 0x8e, 0xe9, 0x59, 0x32, 0x01, 0x86, 0xf2, 0x97, + 0x73, 0xe9, 0x1e, 0x29, 0x11, 0x37, 0xe5, 0xb4, 0xcc, 0x19, 0xef, 0x65, 0xa5, 0x6f, 0x50, 0xfe, + 0x4a, 0x6c, 0xbc, 0xa5, 0x93, 0xb1, 0xf1, 0x96, 0x91, 0xff, 0xe1, 0x36, 0x4c, 0x70, 0xa5, 0x5e, + 0xd1, 0x71, 0x18, 0x5a, 0x4d, 0x6a, 0x28, 0xff, 0x5e, 0x6c, 0xb5, 0x4b, 0x50, 0xa0, 0x6b, 0x4f, + 0x1c, 0xc8, 0xa6, 0xee, 0x5a, 0x47, 0xb7, 0x2c, 0x3c, 0x66, 0x55, 0xfe, 0xfd, 0xd8, 0xd4, 0x1d, + 0xa2, 0xd0, 0x71, 0x37, 0xf8, 0xc5, 0x34, 0xa1, 0x57, 0xea, 0x23, 0xe5, 0x3f, 0x88, 0x69, 0x42, + 0x2f, 0x62, 0xa6, 0x09, 0x3d, 0xf3, 0x28, 0xdd, 0xcb, 0x78, 0x02, 0xae, 0x7c, 0x3d, 0xb6, 0x22, + 0xa7, 0x52, 0xb1, 0x15, 0x39, 0xfd, 0x05, 0xf9, 0xbd, 0x8c, 0xe7, 0xd3, 0xca, 0x2f, 0xf4, 0xe6, + 0x1b, 0xae, 0xf4, 0xe9, 0xaf, 0xaf, 0xef, 0x65, 0x3c, 0x3d, 0x56, 0xfe, 0x6a, 0x6f, 0xbe, 0xa1, + 0x63, 0x5f, 0xfa, 0xcb, 0xe5, 0x7a, 0xf6, 0xb3, 0x5d, 0xe5, 0xaf, 0xc5, 0xa7, 0xae, 0x0c, 0x42, + 0x9c, 0xba, 0xb2, 0xde, 0xfe, 0xae, 0xc1, 0x13, 0x5c, 0x43, 0x6e, 0x39, 0x7a, 0x67, 0xa3, 0x46, + 0x3d, 0xcf, 0xb4, 0x9a, 0xfe, 0x4e, 0xec, 0xaf, 0xe7, 0x62, 0xc7, 0x63, 0x59, 0x94, 0x78, 0x3c, + 0x96, 0x85, 0x64, 0xca, 0x9b, 0x78, 0xa0, 0xab, 0xfc, 0x8d, 0x98, 0xf2, 0x26, 0x28, 0x98, 0xf2, + 0x26, 0xdf, 0xf5, 0xde, 0x4e, 0x79, 0x87, 0xaa, 0xfc, 0x87, 0xd9, 0xbc, 0x82, 0xf6, 0xa5, 0x3c, + 0x5f, 0xbd, 0x9d, 0xf2, 0xdc, 0x52, 0xf9, 0x8f, 0xb2, 0x79, 0x85, 0x3e, 0x48, 0xc9, 0x57, 0x9a, + 0xef, 0xc1, 0x05, 0x3e, 0x9b, 0xcf, 0x51, 0x83, 0x46, 0x3e, 0xf4, 0x17, 0x63, 0x63, 0x3f, 0x9d, + 0x0c, 0x8f, 0xdc, 0x53, 0x31, 0x69, 0xac, 0x45, 0x5b, 0xff, 0xe6, 0x2e, 0xac, 0xc3, 0x0d, 0x41, + 0x3a, 0x86, 0xad, 0x37, 0xf2, 0xe3, 0x37, 0xe5, 0x97, 0x62, 0xeb, 0x8d, 0x8c, 0x44, 0x77, 0x0e, + 0xf9, 0xa5, 0xdc, 0x9b, 0xd1, 0x87, 0x5e, 0xca, 0xdf, 0x4a, 0x2d, 0x1c, 0x74, 0x40, 0xf4, 0x55, + 0xd8, 0x9b, 0xd1, 0x47, 0x4d, 0xca, 0x2f, 0xa7, 0x16, 0x0e, 0x3e, 0x20, 0xfa, 0x02, 0x8a, 0x6d, + 0x91, 0xba, 0x9e, 0xcd, 0x59, 0x45, 0xa6, 0x87, 0xbf, 0x1d, 0xdf, 0x22, 0xa5, 0x92, 0xe1, 0x16, + 0x29, 0x15, 0x93, 0xc6, 0x5a, 0x7c, 0xde, 0xaf, 0xec, 0xc2, 0x5a, 0xda, 0xd8, 0xa5, 0x62, 0xd2, + 0x58, 0x8b, 0x8f, 0xff, 0xc6, 0x2e, 0xac, 0xa5, 0x8d, 0x5d, 0x2a, 0x86, 0x99, 0x63, 0x21, 0xe6, + 0x1e, 0x75, 0xdc, 0x50, 0xfd, 0xfe, 0xe3, 0x98, 0x39, 0x96, 0x41, 0xc7, 0xcc, 0xb1, 0x0c, 0x54, + 0x2a, 0x77, 0x21, 0x94, 0x5f, 0xdd, 0x8d, 0x7b, 0x78, 0x2f, 0x93, 0x81, 0x4a, 0xe5, 0x2e, 0xe4, + 0xf2, 0x77, 0x76, 0xe3, 0x1e, 0x5e, 0xcc, 0x64, 0xa0, 0x98, 0x51, 0x54, 0xf3, 0x74, 0xcf, 0x6c, + 0xcc, 0xdb, 0xae, 0x27, 0x2d, 0xf2, 0x7f, 0x37, 0x66, 0x14, 0xa5, 0x11, 0x31, 0xa3, 0x28, 0x0d, + 0x9e, 0x64, 0x2a, 0xa4, 0xf1, 0x6b, 0x3d, 0x99, 0x86, 0x96, 0x56, 0x1a, 0x3c, 0xc9, 0x54, 0x08, + 0xe1, 0x3f, 0xe9, 0xc9, 0x34, 0xf4, 0x94, 0x4f, 0x83, 0x33, 0xcb, 0x74, 0xc6, 0xb1, 0x37, 0xad, + 0xdb, 0x74, 0x93, 0xb6, 0xc4, 0xa7, 0xff, 0x7a, 0xcc, 0x32, 0x8d, 0x13, 0xe0, 0x2d, 0x4a, 0x0c, + 0x16, 0x65, 0x24, 0x3e, 0xf7, 0x37, 0x32, 0x19, 0x85, 0xc7, 0x44, 0x71, 0x58, 0x94, 0x91, 0xf8, + 0xc4, 0xdf, 0xcc, 0x64, 0x14, 0x1e, 0x13, 0xc5, 0x61, 0xa4, 0x0c, 0x63, 0xf8, 0x56, 0x42, 0x77, + 0x7d, 0xcf, 0xcf, 0xdf, 0xc9, 0x45, 0x6f, 0xbd, 0xa2, 0xe8, 0xf9, 0x3e, 0x2d, 0x56, 0x40, 0x66, + 0x21, 0x3e, 0xe9, 0x5b, 0x19, 0x2c, 0x42, 0x7f, 0xc7, 0x28, 0x44, 0x66, 0x21, 0x3e, 0xe6, 0x3f, + 0xcd, 0x60, 0x11, 0x3a, 0x3c, 0x46, 0x21, 0xe4, 0xd3, 0x30, 0x5c, 0x9b, 0x5b, 0x5d, 0xf1, 0xd3, + 0xf3, 0xfd, 0xbd, 0x5c, 0xec, 0x55, 0x51, 0x88, 0xc3, 0x57, 0x45, 0xe1, 0xcf, 0xe9, 0x01, 0xe8, + 0xc7, 0xa3, 0xd4, 0xdb, 0xa5, 0xc1, 0x6f, 0xe6, 0xc6, 0x7f, 0x2b, 0x77, 0xbb, 0x34, 0xf8, 0x5b, + 0xb9, 0xf1, 0xdf, 0x66, 0xff, 0xff, 0x76, 0x6e, 0xfc, 0x77, 0x72, 0xda, 0x13, 0xe1, 0xb0, 0x28, + 0x37, 0xa9, 0xe5, 0xad, 0xb4, 0x74, 0x31, 0xa8, 0x53, 0x51, 0xfc, 0x67, 0x2a, 0x4a, 0xa4, 0xc2, + 0xfa, 0x7a, 0x0e, 0x46, 0x6a, 0x9e, 0x43, 0xf5, 0xb6, 0x88, 0x2c, 0x77, 0x09, 0x06, 0xb9, 0xf3, + 0xb3, 0xff, 0x52, 0x5b, 0x0b, 0x7e, 0x93, 0x2b, 0x30, 0xb6, 0xa0, 0xbb, 0x1e, 0x36, 0xb1, 0x6a, + 0x19, 0xf4, 0x11, 0x3e, 0xfc, 0x2b, 0x68, 0x31, 0x28, 0x59, 0xe0, 0x74, 0xbc, 0x1c, 0x06, 0x13, + 0x2d, 0xec, 0x1a, 0x50, 0x6d, 0xf0, 0xdb, 0xdb, 0x93, 0x7d, 0x18, 0x3f, 0x2d, 0x56, 0x56, 0xfd, + 0xfd, 0x1c, 0x24, 0xdc, 0xb2, 0x0f, 0x1e, 0x41, 0x61, 0x19, 0xce, 0xc4, 0x02, 0xd8, 0x8a, 0xd7, + 0x8b, 0x7b, 0x8c, 0x6f, 0x1b, 0x2f, 0x4d, 0x3e, 0x11, 0xbc, 0x9a, 0xbb, 0xab, 0x2d, 0x88, 0x60, + 0x79, 0x98, 0xe6, 0xa1, 0xeb, 0xb4, 0x34, 0x09, 0x25, 0x82, 0x21, 0x7d, 0x6f, 0x3c, 0x8c, 0xce, + 0x49, 0xae, 0x88, 0x70, 0x0e, 0xb9, 0x30, 0xc4, 0x5e, 0x2c, 0xa9, 0x3c, 0x0f, 0xdf, 0xf0, 0x19, + 0x18, 0xa9, 0xb6, 0x3b, 0xd4, 0x71, 0x6d, 0x4b, 0xf7, 0x6c, 0x47, 0xbc, 0x86, 0xc7, 0xf0, 0x6b, + 0xa6, 0x04, 0x97, 0x43, 0x82, 0xc9, 0xf4, 0xe4, 0x9a, 0x9f, 0xa9, 0xae, 0x80, 0x71, 0x51, 0xf1, + 0x49, 0x6b, 0x3c, 0x51, 0x39, 0xa7, 0x60, 0xa4, 0x77, 0x5d, 0x1d, 0xdf, 0x57, 0x06, 0xa4, 0x5d, + 0x06, 0x90, 0x49, 0x91, 0x82, 0xbc, 0x00, 0x25, 0xbc, 0x8f, 0x72, 0x31, 0x03, 0xa5, 0x08, 0xfc, + 0xd7, 0x42, 0x88, 0x1c, 0x66, 0x8d, 0xd3, 0x90, 0x3b, 0x30, 0x1e, 0x5e, 0xb6, 0xdf, 0x72, 0xec, + 0x6e, 0xc7, 0xcf, 0x39, 0x83, 0x09, 0xde, 0x1f, 0x04, 0xb8, 0x7a, 0x13, 0x91, 0x12, 0x8b, 0x44, + 0x41, 0x32, 0x0f, 0x67, 0x42, 0x18, 0x13, 0x91, 0x9f, 0xeb, 0x0a, 0xf3, 0x8c, 0x4a, 0xbc, 0x98, + 0x38, 0x23, 0x79, 0x46, 0x63, 0xc5, 0x48, 0x15, 0x06, 0xfc, 0xa8, 0x7f, 0x83, 0xbb, 0x2a, 0xe9, + 0x59, 0x11, 0xf5, 0x6f, 0x40, 0x8e, 0xf7, 0xe7, 0x97, 0x27, 0x73, 0x30, 0xa6, 0xd9, 0x5d, 0x8f, + 0xae, 0xda, 0x62, 0x97, 0x2a, 0xa2, 0x4b, 0x62, 0x9b, 0x1c, 0x86, 0xa9, 0x7b, 0xb6, 0x9f, 0x1f, + 0x5f, 0xce, 0xd3, 0x1e, 0x2d, 0x45, 0x96, 0x60, 0x22, 0xe1, 0x96, 0x20, 0x67, 0xad, 0x97, 0x3e, + 0x2f, 0xc9, 0x2c, 0x59, 0x94, 0xfc, 0x78, 0x0e, 0x4a, 0xab, 0x8e, 0x6e, 0x7a, 0xae, 0x78, 0x9a, + 0x79, 0x7e, 0x6a, 0xd3, 0xd1, 0x3b, 0x4c, 0x3f, 0xa6, 0x30, 0xf0, 0xed, 0x3d, 0xbd, 0xd5, 0xa5, + 0xee, 0xf4, 0x7d, 0xf6, 0x75, 0xff, 0xfd, 0xf6, 0xe4, 0x9b, 0x4d, 0x3c, 0xfc, 0x9c, 0x6a, 0xd8, + 0xed, 0xeb, 0x4d, 0x47, 0x7f, 0x68, 0x7a, 0x68, 0x62, 0xea, 0xad, 0xeb, 0x1e, 0x6d, 0xe1, 0x19, + 0xeb, 0x75, 0xbd, 0x63, 0x5e, 0xc7, 0x00, 0xeb, 0xd7, 0x03, 0x4e, 0xbc, 0x06, 0xa6, 0x02, 0x1e, + 0xfe, 0x25, 0xab, 0x00, 0xc7, 0x91, 0x25, 0x00, 0xf1, 0xa9, 0xe5, 0x4e, 0x47, 0xbc, 0xf3, 0x94, + 0x4e, 0x26, 0x7d, 0x0c, 0x57, 0xec, 0x40, 0x60, 0x7a, 0x47, 0x0a, 0x2a, 0xac, 0x49, 0x1c, 0x98, + 0x16, 0xac, 0x8a, 0x16, 0xf9, 0x62, 0x1a, 0x0d, 0x25, 0xee, 0x37, 0x36, 0x45, 0x48, 0xf1, 0x62, + 0x64, 0x0d, 0xce, 0x08, 0xbe, 0x41, 0x0a, 0x92, 0xb1, 0xe8, 0xac, 0x10, 0x43, 0x73, 0xa5, 0x0d, + 0xda, 0x68, 0x08, 0xb0, 0x5c, 0x47, 0xac, 0x04, 0x99, 0x0e, 0x53, 0x26, 0x2f, 0xe9, 0x6d, 0xea, + 0x2a, 0x67, 0x50, 0x63, 0x2f, 0xef, 0x6c, 0x4f, 0x2a, 0x7e, 0x79, 0x0c, 0x80, 0x29, 0x8b, 0x2e, + 0x5a, 0x44, 0xe6, 0xc1, 0xb5, 0x7e, 0x3c, 0x85, 0x47, 0x5c, 0xe7, 0xa3, 0x45, 0xc8, 0x0c, 0x8c, + 0x06, 0xcf, 0x4c, 0xee, 0xde, 0xad, 0x56, 0xf0, 0x21, 0xa9, 0x88, 0x81, 0x1a, 0x4b, 0x12, 0x22, + 0x33, 0x89, 0x94, 0x91, 0x62, 0x73, 0xf0, 0x97, 0xa5, 0xb1, 0xd8, 0x1c, 0x9d, 0x94, 0xd8, 0x1c, + 0x2b, 0xe4, 0x6d, 0x18, 0x2e, 0xdf, 0xaf, 0x89, 0x98, 0x23, 0xae, 0x72, 0x36, 0xcc, 0x38, 0xa5, + 0x6f, 0xba, 0x75, 0x3f, 0x3e, 0x89, 0xdc, 0x74, 0x99, 0x9e, 0xcc, 0xc2, 0x58, 0xc4, 0x53, 0xcd, + 0x55, 0xce, 0x21, 0x07, 0x6c, 0xb9, 0x8e, 0x98, 0xba, 0x23, 0x50, 0xf2, 0xf0, 0x8a, 0x16, 0x62, + 0x5a, 0x53, 0x31, 0x5d, 0xcc, 0xde, 0xa3, 0x51, 0x0c, 0x6f, 0x82, 0xcf, 0x52, 0x07, 0xb9, 0xd6, + 0x18, 0x02, 0x55, 0x77, 0x38, 0x4e, 0xee, 0xd1, 0x58, 0x31, 0xf2, 0x3e, 0x10, 0xcc, 0xf7, 0x43, + 0x0d, 0xff, 0xe2, 0xb2, 0x5a, 0x71, 0x95, 0x0b, 0x18, 0x00, 0x9c, 0xc4, 0xc3, 0x29, 0x54, 0x2b, + 0xd3, 0x57, 0xc4, 0xf4, 0xf1, 0xb4, 0xce, 0x4b, 0xd5, 0xfd, 0x50, 0x0a, 0x75, 0x33, 0x92, 0x0c, + 0x39, 0x85, 0x2b, 0xd9, 0x84, 0x8b, 0x2b, 0x0e, 0x7d, 0x68, 0xda, 0x5d, 0xd7, 0x5f, 0x3e, 0xfc, + 0x79, 0xeb, 0xe2, 0xae, 0xf3, 0xd6, 0xb3, 0xa2, 0xe2, 0xf3, 0x1d, 0x87, 0x3e, 0xac, 0xfb, 0x61, + 0x9f, 0x23, 0x51, 0x4b, 0xb3, 0xb8, 0x63, 0x4a, 0xe7, 0x0f, 0xba, 0x0e, 0x15, 0x70, 0x93, 0xba, + 0x8a, 0x12, 0x4e, 0xb5, 0x3c, 0x52, 0x8d, 0x19, 0xe0, 0x22, 0x29, 0x9d, 0xa3, 0xc5, 0x88, 0x06, + 0xe4, 0xd6, 0x8c, 0x7f, 0x89, 0x5d, 0x6e, 0xf0, 0xc4, 0xb7, 0xca, 0x13, 0xc8, 0x4c, 0x65, 0x62, + 0x69, 0x36, 0x82, 0x10, 0xf0, 0x75, 0x5d, 0xe0, 0x65, 0xb1, 0x24, 0x4b, 0x93, 0x05, 0x18, 0x5f, + 0x71, 0xf0, 0x48, 0xed, 0x0e, 0xdd, 0x5a, 0xb1, 0x5b, 0x66, 0x63, 0x0b, 0x5f, 0xc7, 0x8a, 0xa9, + 0xb2, 0xc3, 0x71, 0xf5, 0x07, 0x74, 0xab, 0xde, 0x41, 0xac, 0xbc, 0xac, 0xc4, 0x4b, 0xca, 0x21, + 0x99, 0x9f, 0xdc, 0x5b, 0x48, 0x66, 0x0a, 0xe3, 0xe2, 0x0a, 0xfc, 0x91, 0x47, 0x2d, 0xb6, 0xd4, + 0xbb, 0xe2, 0x25, 0xac, 0x12, 0xbb, 0x32, 0x0f, 0xf0, 0x7c, 0xea, 0x10, 0xa3, 0x8c, 0x06, 0x60, + 0xb9, 0x61, 0xf1, 0x22, 0xc9, 0xb8, 0xc5, 0x4f, 0x1d, 0x20, 0x6e, 0xf1, 0xdf, 0x2d, 0xc8, 0xf3, + 0x2f, 0xb9, 0x0c, 0x45, 0x29, 0xad, 0x10, 0x06, 0x65, 0xc5, 0x10, 0xec, 0x45, 0x11, 0x6b, 0x7a, + 0x48, 0xd8, 0x2e, 0x41, 0xf4, 0x1d, 0xcc, 0x23, 0x19, 0x06, 0xea, 0xd4, 0x42, 0x02, 0xcc, 0xe1, + 0xd7, 0x5d, 0x6b, 0x99, 0x0d, 0x0c, 0xcc, 0x5f, 0x90, 0xc2, 0x6d, 0x20, 0x94, 0xc7, 0xe5, 0x97, + 0x48, 0xc8, 0x0d, 0x18, 0xf6, 0x8f, 0x72, 0xc3, 0xa0, 0xc4, 0x18, 0xaf, 0x5d, 0xcc, 0xd6, 0x22, + 0x1c, 0xbc, 0x44, 0x44, 0xde, 0x00, 0x08, 0xa7, 0x03, 0x61, 0x69, 0xe1, 0x52, 0x21, 0xcf, 0x1e, + 0xf2, 0x52, 0x11, 0x52, 0xb3, 0x89, 0x53, 0x56, 0x47, 0x3f, 0x6b, 0x29, 0x4e, 0x9c, 0x11, 0x1d, + 0x96, 0x15, 0x24, 0x5a, 0x84, 0x2c, 0xc3, 0x44, 0x42, 0x03, 0x45, 0x08, 0x63, 0xcc, 0x5c, 0x9f, + 0xa2, 0xbe, 0xf2, 0xc2, 0x9c, 0x28, 0x4b, 0x9e, 0x83, 0xc2, 0x5d, 0xad, 0x2a, 0xc2, 0xa8, 0xf2, + 0x08, 0xbc, 0x91, 0x18, 0x4b, 0x0c, 0xab, 0xfe, 0x68, 0x3e, 0xb1, 0x36, 0x31, 0xe9, 0x09, 0x56, + 0x52, 0x0f, 0xa2, 0xf4, 0xfc, 0xfa, 0xb9, 0xf4, 0x24, 0x22, 0x72, 0x15, 0x06, 0x57, 0xd8, 0xcc, + 0xd0, 0xb0, 0x5b, 0xa2, 0x3f, 0x31, 0x20, 0x56, 0x47, 0xc0, 0xb4, 0x00, 0x4b, 0x6e, 0x48, 0xc9, + 0x76, 0xa5, 0xc8, 0xe4, 0x7e, 0xb2, 0xdd, 0x78, 0x88, 0x6e, 0x4c, 0xbb, 0x7b, 0x23, 0x96, 0xbc, + 0x4b, 0x94, 0x49, 0x59, 0x17, 0xc3, 0x64, 0x5d, 0x81, 0x55, 0xda, 0xbf, 0x9b, 0x55, 0xaa, 0xfe, + 0xfd, 0x5c, 0x72, 0x9c, 0x91, 0x9b, 0xc9, 0x20, 0xc1, 0xb8, 0x08, 0x05, 0x40, 0xb9, 0xd6, 0x20, + 0x5c, 0x70, 0x24, 0xdc, 0x6f, 0xfe, 0xc0, 0xe1, 0x7e, 0x0b, 0xfb, 0x0c, 0xf7, 0xab, 0xfe, 0x3f, + 0xc5, 0x9e, 0x2e, 0xdb, 0xc7, 0x12, 0x16, 0xee, 0x75, 0xb6, 0xb3, 0x62, 0xb5, 0x97, 0xdd, 0xc4, + 0xfe, 0x80, 0x7b, 0xa4, 0xd6, 0x75, 0x3e, 0xb4, 0x5c, 0x2d, 0x4a, 0x49, 0xde, 0x81, 0x11, 0xff, + 0x03, 0x30, 0x8c, 0xb4, 0x14, 0xfe, 0x38, 0x58, 0xd5, 0x62, 0x01, 0x97, 0x23, 0x05, 0xc8, 0x2b, + 0x30, 0x84, 0x36, 0x4d, 0x47, 0x6f, 0xf8, 0x31, 0xc6, 0x79, 0x50, 0x72, 0x1f, 0x28, 0x87, 0x3e, + 0x0b, 0x28, 0xc9, 0x17, 0xa0, 0x24, 0x12, 0x6d, 0xf0, 0x3c, 0xf4, 0xd7, 0xf7, 0xe0, 0xe3, 0x3e, + 0x25, 0x27, 0xd9, 0xe0, 0xbb, 0x14, 0x04, 0x44, 0x76, 0x29, 0x3c, 0xbf, 0xc6, 0x2a, 0x9c, 0x5d, + 0x71, 0xa8, 0x81, 0xaf, 0x29, 0x66, 0x1f, 0x75, 0x1c, 0x91, 0x02, 0x85, 0x8f, 0x72, 0x5c, 0xa4, + 0x3a, 0x3e, 0x9a, 0x2d, 0x9f, 0x02, 0x2f, 0x07, 0x3a, 0x4e, 0x29, 0xce, 0x2c, 0x17, 0xde, 0x92, + 0x3b, 0x74, 0x6b, 0xd3, 0x76, 0x0c, 0x9e, 0x25, 0x44, 0xcc, 0xdf, 0x42, 0xd0, 0x0f, 0x04, 0x4a, + 0xb6, 0x5c, 0xa2, 0x85, 0x2e, 0xbd, 0x0e, 0xc3, 0x07, 0x4d, 0x54, 0xf1, 0xab, 0xf9, 0x8c, 0xc7, + 0x4f, 0x8f, 0x6f, 0xae, 0xc0, 0x20, 0x81, 0x75, 0x7f, 0x46, 0x02, 0xeb, 0xef, 0xe6, 0x33, 0x5e, + 0x76, 0x3d, 0xd6, 0x89, 0x66, 0x03, 0x61, 0x44, 0x13, 0xcd, 0x86, 0x39, 0x7e, 0x4d, 0x43, 0x93, + 0x89, 0x62, 0x29, 0xa9, 0x4b, 0xbb, 0xa6, 0xa4, 0xfe, 0xc5, 0x42, 0xaf, 0x97, 0x6f, 0xa7, 0xb2, + 0xdf, 0x8f, 0xec, 0x6f, 0xc0, 0x70, 0x20, 0xd9, 0x6a, 0x05, 0x8d, 0x9e, 0xd1, 0x20, 0x2d, 0x0e, + 0x07, 0x63, 0x19, 0x89, 0x88, 0x5c, 0xe3, 0x6d, 0xad, 0x99, 0x1f, 0xf0, 0x04, 0x0d, 0xa3, 0x22, + 0xf4, 0xbe, 0xee, 0xe9, 0x75, 0xd7, 0xfc, 0x80, 0x6a, 0x01, 0x5a, 0xfd, 0xcf, 0xf2, 0xa9, 0xcf, + 0x07, 0x4f, 0xfb, 0x68, 0x1f, 0x7d, 0x94, 0x22, 0x44, 0xfe, 0xf0, 0xf1, 0x54, 0x88, 0xfb, 0x10, + 0xe2, 0x9f, 0xe4, 0x53, 0x9f, 0x89, 0x9e, 0x0a, 0x71, 0x3f, 0xb3, 0xc5, 0x0b, 0x30, 0xa4, 0xd9, + 0x9b, 0xee, 0x0c, 0x6e, 0x6c, 0xf8, 0x5c, 0x81, 0x13, 0xb5, 0x63, 0x6f, 0xba, 0x75, 0xdc, 0xb2, + 0x68, 0x21, 0x81, 0xfa, 0xbd, 0x7c, 0x8f, 0x87, 0xb4, 0xa7, 0x82, 0xff, 0x30, 0x97, 0xc8, 0xdf, + 0xc8, 0x47, 0x1e, 0xea, 0x3e, 0xbe, 0xc2, 0xbe, 0x0e, 0x50, 0x6b, 0x6c, 0xd0, 0xb6, 0x2e, 0x25, + 0xb9, 0xc2, 0x73, 0x07, 0x17, 0xa1, 0x22, 0x39, 0x72, 0x48, 0xa2, 0x7e, 0x33, 0x1f, 0x7b, 0xa9, + 0x7c, 0x2a, 0xbb, 0x3d, 0xcb, 0x2e, 0xd0, 0x3a, 0xf1, 0xf8, 0xfa, 0x54, 0x72, 0x7b, 0x95, 0xdc, + 0x4f, 0xe4, 0x63, 0xef, 0xd4, 0x1f, 0x5b, 0xd9, 0xb1, 0x01, 0x98, 0x7c, 0x3f, 0xff, 0xd8, 0x6a, + 0xd2, 0x0b, 0x30, 0x24, 0xe4, 0x10, 0x2c, 0x15, 0x7c, 0xde, 0xe7, 0x40, 0x3c, 0x65, 0x0d, 0x08, + 0xd4, 0x3f, 0x93, 0x87, 0x68, 0xfc, 0x80, 0xc7, 0x54, 0x87, 0x7e, 0x23, 0x1f, 0x8d, 0x9c, 0xf0, + 0xf8, 0xea, 0xcf, 0x14, 0x40, 0xad, 0xbb, 0xd6, 0x10, 0x81, 0x77, 0xfb, 0xa5, 0x63, 0xfa, 0x00, + 0xaa, 0x49, 0x14, 0xea, 0xff, 0x9b, 0x4f, 0x0d, 0xe7, 0xf0, 0xf8, 0x0a, 0xf0, 0x65, 0x3c, 0x15, + 0x6f, 0x58, 0xe1, 0x44, 0x8e, 0x87, 0x90, 0x6c, 0xfc, 0x25, 0x32, 0x23, 0xfa, 0x84, 0xe4, 0xd3, + 0x29, 0xe6, 0x1a, 0xe6, 0x6d, 0x08, 0xcd, 0x35, 0xf9, 0x1a, 0x42, 0x32, 0xdc, 0x7e, 0x2f, 0xbf, + 0x5b, 0xf4, 0x8b, 0xc7, 0x79, 0x55, 0x1d, 0x58, 0xd1, 0xb7, 0x30, 0x4a, 0x23, 0xeb, 0x89, 0x11, + 0x9e, 0xb7, 0xaf, 0xc3, 0x41, 0xf2, 0xdd, 0x9b, 0xa0, 0x52, 0xff, 0x79, 0x7f, 0x7a, 0xe8, 0x85, + 0xc7, 0x57, 0x84, 0x97, 0xa1, 0xb8, 0xa2, 0x7b, 0x1b, 0x42, 0x93, 0xf1, 0x4a, 0xaf, 0xa3, 0x7b, + 0x1b, 0x1a, 0x42, 0xc9, 0x35, 0x18, 0xd4, 0xf4, 0x4d, 0x7e, 0xe6, 0x59, 0x0a, 0x73, 0x2a, 0x3a, + 0xfa, 0x66, 0x9d, 0x9f, 0x7b, 0x06, 0x68, 0xa2, 0x06, 0x39, 0x3d, 0xf9, 0xc9, 0x37, 0x26, 0x94, + 0xe3, 0x39, 0x3d, 0x83, 0x4c, 0x9e, 0x97, 0xa1, 0x38, 0x6d, 0x1b, 0x5b, 0x78, 0x7d, 0x35, 0xc2, + 0x2b, 0x5b, 0xb3, 0x8d, 0x2d, 0x0d, 0xa1, 0xe4, 0x27, 0x73, 0x30, 0x30, 0x4f, 0x75, 0x83, 0x8d, + 0x90, 0xa1, 0x5e, 0x5e, 0x27, 0x9f, 0x3b, 0x1a, 0xaf, 0x93, 0x89, 0x0d, 0x5e, 0x99, 0xac, 0x28, + 0xa2, 0x7e, 0x72, 0x0b, 0x06, 0x67, 0x74, 0x8f, 0x36, 0x6d, 0x67, 0x0b, 0xfd, 0x68, 0xc6, 0x42, + 0xf7, 0xfd, 0x88, 0xfe, 0xf8, 0x44, 0xfc, 0x66, 0xac, 0x21, 0x7e, 0x69, 0x41, 0x61, 0x26, 0x96, + 0x55, 0xdd, 0x69, 0x52, 0x4f, 0xe4, 0xaf, 0x46, 0xb1, 0x78, 0x08, 0xd1, 0x04, 0x26, 0x3c, 0x56, + 0x1e, 0x49, 0x3f, 0x56, 0x46, 0xeb, 0x11, 0x7d, 0xed, 0x30, 0x93, 0xe6, 0x28, 0x2e, 0xfa, 0xdc, + 0x7a, 0x44, 0x28, 0x26, 0xd2, 0xd4, 0x24, 0x12, 0xf5, 0x3b, 0xfd, 0x90, 0xfa, 0x50, 0xfb, 0x54, + 0xc9, 0x4f, 0x95, 0x3c, 0x54, 0xf2, 0x4a, 0x42, 0xc9, 0x2f, 0x25, 0x9f, 0xfe, 0x7f, 0x44, 0x35, + 0xfc, 0xe7, 0x8a, 0x89, 0xc0, 0x21, 0x8f, 0xf7, 0xee, 0x32, 0x94, 0x5e, 0xff, 0xae, 0xd2, 0x0b, + 0x06, 0x44, 0x69, 0xd7, 0x01, 0x31, 0xb0, 0xd7, 0x01, 0x31, 0x98, 0x39, 0x20, 0x42, 0x05, 0x19, + 0xca, 0x54, 0x90, 0xaa, 0x18, 0x34, 0xd0, 0x3b, 0x7f, 0xc9, 0xe5, 0x9d, 0xed, 0xc9, 0x31, 0x36, + 0x9a, 0x52, 0x13, 0x97, 0x20, 0x0b, 0xf5, 0xf7, 0x8b, 0x3d, 0xa2, 0xfd, 0x1c, 0x8b, 0x8e, 0xbc, + 0x0c, 0x85, 0x72, 0xa7, 0x23, 0xf4, 0xe3, 0xac, 0x14, 0x68, 0x28, 0xa3, 0x14, 0xa3, 0x26, 0x6f, + 0x40, 0xa1, 0x7c, 0xbf, 0x16, 0xcf, 0x59, 0x52, 0xbe, 0x5f, 0x13, 0x5f, 0x92, 0x59, 0xf6, 0x7e, + 0x8d, 0xbc, 0x15, 0x06, 0x0f, 0xdd, 0xe8, 0x5a, 0x0f, 0xc4, 0x46, 0x51, 0xb8, 0xdb, 0xfa, 0xee, + 0x38, 0x0d, 0x86, 0x62, 0xdb, 0xc5, 0x18, 0x6d, 0x4c, 0x9b, 0x4a, 0x7b, 0xd7, 0xa6, 0x81, 0x5d, + 0xb5, 0x69, 0x70, 0xaf, 0xda, 0x34, 0xb4, 0x07, 0x6d, 0x82, 0x5d, 0xb5, 0x69, 0xf8, 0xf0, 0xda, + 0xd4, 0x81, 0x4b, 0xc9, 0x08, 0x6d, 0x81, 0x46, 0x68, 0x40, 0x92, 0x58, 0xe1, 0x58, 0x82, 0x57, + 0xff, 0x5d, 0x8e, 0xad, 0x6f, 0x22, 0xba, 0xee, 0x32, 0xbc, 0xec, 0x9f, 0x96, 0x2c, 0xad, 0xfe, + 0x6a, 0x3e, 0x3b, 0xb0, 0xdc, 0xc9, 0x9c, 0xe2, 0x7e, 0x28, 0x55, 0x4a, 0xc5, 0xe8, 0x43, 0xff, + 0x6c, 0x29, 0xc7, 0xd8, 0xa6, 0xc9, 0xec, 0x1b, 0xf9, 0xac, 0x68, 0x77, 0x87, 0x92, 0xd8, 0xc7, + 0x93, 0x1e, 0x6d, 0xe8, 0xa7, 0xef, 0x46, 0x5d, 0xd9, 0xe6, 0x60, 0x44, 0x16, 0xa2, 0x90, 0xd2, + 0x5e, 0x04, 0x1c, 0x29, 0x47, 0xde, 0x0a, 0x52, 0xcb, 0x48, 0xfe, 0x31, 0xe8, 0xae, 0xe6, 0x8f, + 0xd9, 0x98, 0x7b, 0x8c, 0x4c, 0x4e, 0x5e, 0x80, 0xd2, 0x1c, 0xc6, 0x6a, 0x97, 0x07, 0x3b, 0x8f, + 0xde, 0x2e, 0x7b, 0xad, 0x70, 0x1a, 0xf5, 0xef, 0xe7, 0xe0, 0xec, 0x9d, 0xee, 0x1a, 0x15, 0xde, + 0x72, 0x41, 0x1b, 0xde, 0x07, 0x60, 0x60, 0xe1, 0x30, 0x93, 0x43, 0x87, 0x99, 0x4f, 0xca, 0x51, + 0xf1, 0x62, 0x05, 0xa6, 0x42, 0x6a, 0xee, 0x2c, 0xf3, 0x94, 0xef, 0x38, 0xfa, 0xa0, 0xbb, 0x46, + 0xeb, 0x09, 0xaf, 0x19, 0x89, 0xfb, 0xa5, 0xb7, 0xb9, 0x4b, 0xfe, 0x41, 0x1d, 0x54, 0x7e, 0x25, + 0x9f, 0x19, 0x88, 0xf0, 0xc4, 0x66, 0xcc, 0xfc, 0x81, 0xd4, 0x5e, 0x89, 0x67, 0xce, 0x4c, 0x21, + 0x89, 0x71, 0x4c, 0xe3, 0x92, 0x2e, 0xb0, 0x13, 0x9e, 0xc7, 0xf5, 0x43, 0x15, 0xd8, 0x1f, 0xe5, + 0x32, 0x03, 0x46, 0x9e, 0x54, 0x81, 0xa9, 0xff, 0x4b, 0xc1, 0x8f, 0x53, 0x79, 0xa8, 0x4f, 0x78, + 0x01, 0x86, 0xc4, 0x73, 0xfd, 0xa8, 0xb3, 0xaf, 0x38, 0x36, 0xc4, 0x63, 0xe8, 0x80, 0x80, 0x99, + 0x14, 0x92, 0x27, 0xb2, 0xe4, 0xec, 0x2b, 0x79, 0x21, 0x6b, 0x12, 0x09, 0x33, 0x1a, 0x66, 0x1f, + 0x99, 0x1e, 0x5a, 0x20, 0xac, 0x2f, 0x0b, 0xdc, 0x68, 0xa0, 0x8f, 0x4c, 0x8f, 0xdb, 0x1f, 0x01, + 0x9a, 0x19, 0x04, 0xb5, 0x30, 0x4b, 0xbd, 0x30, 0x08, 0x5c, 0x91, 0xac, 0x5f, 0x3c, 0x51, 0x7b, + 0x01, 0x86, 0x84, 0x07, 0xad, 0x70, 0x69, 0x11, 0xad, 0x15, 0x3e, 0xb7, 0xd8, 0xda, 0x80, 0x80, + 0x71, 0xd4, 0x68, 0x33, 0x74, 0xe2, 0x43, 0x8e, 0x0e, 0x42, 0x34, 0x81, 0x21, 0x37, 0x60, 0xac, + 0xe6, 0xe9, 0x96, 0xa1, 0x3b, 0xc6, 0x72, 0xd7, 0xeb, 0x74, 0x3d, 0xd9, 0x00, 0x76, 0x3d, 0xc3, + 0xee, 0x7a, 0x5a, 0x8c, 0x82, 0x7c, 0x0a, 0x46, 0x7d, 0xc8, 0xac, 0xe3, 0xd8, 0x8e, 0x6c, 0xe5, + 0xb8, 0x9e, 0x41, 0x1d, 0x47, 0x8b, 0x12, 0x90, 0x4f, 0xc3, 0x68, 0xd5, 0x7a, 0x68, 0x37, 0xf8, + 0x93, 0x75, 0x6d, 0x41, 0xd8, 0x3c, 0xf8, 0xec, 0xcb, 0x0c, 0x10, 0xf5, 0xae, 0xd3, 0xd2, 0xa2, + 0x84, 0xea, 0x4e, 0x3e, 0x19, 0xce, 0xf3, 0xf1, 0xdd, 0x20, 0x5d, 0x8b, 0x3a, 0xee, 0xa1, 0xb7, + 0x2a, 0x1a, 0x9f, 0xb2, 0xdf, 0x30, 0xb7, 0x41, 0x6f, 0xc0, 0xe0, 0x1d, 0xba, 0xc5, 0x7d, 0x4c, + 0x4b, 0xa1, 0x5b, 0xf2, 0x03, 0x01, 0x93, 0x4f, 0x77, 0x7d, 0x3a, 0xf5, 0x5b, 0xf9, 0x64, 0xa0, + 0xd2, 0xc7, 0x57, 0xd8, 0x9f, 0x82, 0x01, 0x14, 0x65, 0xd5, 0xbf, 0x5e, 0x40, 0x01, 0xa2, 0xb8, + 0xa3, 0xde, 0xce, 0x3e, 0x99, 0xfa, 0x0b, 0xa5, 0x78, 0xf4, 0xda, 0xc7, 0x57, 0x7a, 0x6f, 0xc2, + 0xf0, 0x8c, 0x6d, 0xb9, 0xa6, 0xeb, 0x51, 0xab, 0xe1, 0x2b, 0xec, 0x13, 0xcc, 0xa0, 0x6a, 0x84, + 0x60, 0xd9, 0x06, 0x94, 0xa8, 0x0f, 0xa2, 0xbc, 0xe4, 0x55, 0x18, 0x42, 0x91, 0xa3, 0xcd, 0xc9, + 0x27, 0x3c, 0xbc, 0x99, 0x58, 0x63, 0xc0, 0xb8, 0xc5, 0x19, 0x92, 0x92, 0xbb, 0x30, 0x38, 0xb3, + 0x61, 0xb6, 0x0c, 0x87, 0x5a, 0xe8, 0x9b, 0x2c, 0x05, 0x09, 0x89, 0xf6, 0xe5, 0x14, 0xfe, 0x8b, + 0xb4, 0xbc, 0x39, 0x0d, 0x51, 0x2c, 0xf2, 0xe2, 0x4b, 0xc0, 0x2e, 0xfd, 0x6c, 0x1e, 0x20, 0x2c, + 0x40, 0x9e, 0x81, 0x7c, 0x90, 0x00, 0x1a, 0x5d, 0x62, 0x22, 0x1a, 0x94, 0xc7, 0xa5, 0x42, 0x8c, + 0xed, 0xfc, 0xae, 0x63, 0xfb, 0x2e, 0x94, 0xf8, 0xe9, 0x1a, 0x7a, 0xad, 0x4b, 0x01, 0x35, 0x33, + 0x1b, 0x3c, 0x85, 0xf4, 0xdc, 0x96, 0x46, 0xcb, 0x33, 0xe2, 0x01, 0xce, 0x99, 0x5d, 0x6a, 0x40, + 0x3f, 0xfe, 0x45, 0xae, 0x40, 0x71, 0xd5, 0x4f, 0x1e, 0x3b, 0xca, 0x67, 0xe9, 0x98, 0xfc, 0x10, + 0xcf, 0xba, 0x69, 0xc6, 0xb6, 0x3c, 0x56, 0x35, 0xb6, 0x7a, 0x44, 0xc8, 0x45, 0xc0, 0x22, 0x72, + 0x11, 0x30, 0xf5, 0xbf, 0xca, 0xa7, 0xc4, 0x55, 0x7e, 0x7c, 0x87, 0xc9, 0xeb, 0x00, 0xf8, 0x7c, + 0x9c, 0xc9, 0xd3, 0x7f, 0x0e, 0x82, 0xa3, 0x04, 0x19, 0xa1, 0xda, 0x46, 0xb6, 0x1d, 0x21, 0xb1, + 0xfa, 0x0f, 0x73, 0x89, 0x60, 0xbc, 0x87, 0x92, 0xa3, 0x6c, 0x95, 0xe5, 0x0f, 0x68, 0xc6, 0xfa, + 0x7d, 0x51, 0xd8, 0x5f, 0x5f, 0x44, 0xbf, 0xe5, 0x08, 0x2c, 0xd3, 0xe3, 0xfc, 0x96, 0xef, 0xe4, + 0xd3, 0x42, 0x13, 0x9f, 0x4c, 0x15, 0xbf, 0x19, 0x18, 0xa5, 0xc5, 0x58, 0x30, 0x78, 0x84, 0xc6, + 0x13, 0x5c, 0x0b, 0x33, 0xf5, 0x8b, 0x70, 0x26, 0x16, 0xb0, 0x57, 0xe4, 0x1a, 0xbe, 0xd2, 0x3b, + 0xf2, 0x6f, 0x76, 0xe0, 0x81, 0x08, 0x99, 0xfa, 0xff, 0xe5, 0x7a, 0x87, 0x6b, 0x3e, 0x76, 0xd5, + 0x49, 0x11, 0x40, 0xe1, 0x4f, 0x47, 0x00, 0x47, 0xb0, 0x0d, 0x3e, 0xd9, 0x02, 0xf8, 0x88, 0x4c, + 0x1e, 0x1f, 0xb6, 0x00, 0x7e, 0x21, 0xb7, 0x6b, 0xb4, 0xed, 0xe3, 0x96, 0x81, 0xfa, 0x3f, 0xe6, + 0x52, 0xa3, 0x62, 0x1f, 0xaa, 0x5d, 0x6f, 0x41, 0x89, 0xbb, 0xf0, 0x88, 0x56, 0x49, 0x79, 0xc4, + 0x18, 0x34, 0x2b, 0xf3, 0x3e, 0xc7, 0x92, 0x05, 0x18, 0xe0, 0x6d, 0x30, 0x44, 0x6f, 0x7c, 0xac, + 0x47, 0x68, 0x6e, 0x23, 0x6b, 0x72, 0x14, 0x68, 0xf5, 0x1f, 0xe4, 0x12, 0x41, 0xba, 0x8f, 0xf1, + 0xdb, 0xc2, 0xa9, 0xba, 0xb0, 0xf7, 0xa9, 0x5a, 0xfd, 0x67, 0xf9, 0xf4, 0x18, 0xe1, 0xc7, 0xf8, + 0x21, 0x47, 0x71, 0x9c, 0x76, 0xb0, 0x75, 0x6b, 0x15, 0xc6, 0xa2, 0xb2, 0x10, 0xcb, 0xd6, 0xd3, + 0xe9, 0x91, 0xd2, 0x33, 0x5a, 0x11, 0xe3, 0xa1, 0x7e, 0x3b, 0x97, 0x0c, 0x6f, 0x7e, 0xec, 0xf3, + 0xd3, 0xc1, 0xb4, 0x25, 0xfa, 0x29, 0x1f, 0x91, 0xb5, 0xe6, 0x28, 0x3e, 0xe5, 0x23, 0xb2, 0x6a, + 0x1c, 0xec, 0x53, 0x7e, 0x29, 0x9f, 0x15, 0x1d, 0xfe, 0xd8, 0x3f, 0xe8, 0xf3, 0xb2, 0x90, 0x79, + 0xcb, 0xc4, 0xa7, 0x3d, 0x93, 0x15, 0x8e, 0x3d, 0x83, 0x67, 0x82, 0xcf, 0xc1, 0xc6, 0x78, 0xaa, + 0xb0, 0x3e, 0x22, 0x8a, 0x7c, 0x32, 0x84, 0xf5, 0x11, 0x19, 0x2a, 0x1f, 0x3d, 0x61, 0xfd, 0x56, + 0x7e, 0xaf, 0x29, 0x09, 0x4e, 0x85, 0x97, 0x10, 0xde, 0x57, 0xf3, 0xc9, 0x54, 0x19, 0xc7, 0x2e, + 0xa6, 0x39, 0x28, 0x89, 0xa4, 0x1d, 0x99, 0xc2, 0xe1, 0xf8, 0x2c, 0x8b, 0x46, 0x7c, 0xc7, 0x4d, + 0x10, 0x17, 0x39, 0x7b, 0x13, 0x09, 0xa7, 0x55, 0xbf, 0x97, 0x8b, 0xe5, 0x95, 0x38, 0x96, 0x23, + 0x84, 0x03, 0x2d, 0x49, 0xe4, 0x6d, 0xff, 0x30, 0xb3, 0x18, 0x8b, 0xeb, 0x1d, 0x7c, 0x4f, 0x85, + 0x7a, 0xba, 0xd9, 0x8a, 0x97, 0x17, 0xf1, 0x07, 0xbe, 0x95, 0x87, 0x89, 0x04, 0x29, 0xb9, 0x12, + 0x09, 0xdb, 0x83, 0xc7, 0x92, 0x31, 0x47, 0x75, 0x1e, 0xc0, 0x67, 0x1f, 0x27, 0xa9, 0x57, 0xa0, + 0x58, 0xd1, 0xb7, 0xf8, 0xb7, 0xf5, 0x73, 0x96, 0x86, 0xbe, 0x25, 0x9f, 0xb8, 0x21, 0x9e, 0xac, + 0xc1, 0x79, 0x7e, 0x1f, 0x62, 0xda, 0xd6, 0xaa, 0xd9, 0xa6, 0x55, 0x6b, 0xd1, 0x6c, 0xb5, 0x4c, + 0x57, 0x5c, 0xea, 0xbd, 0xb0, 0xb3, 0x3d, 0x79, 0xd5, 0xb3, 0x3d, 0xbd, 0x55, 0xa7, 0x3e, 0x59, + 0xdd, 0x33, 0xdb, 0xb4, 0x6e, 0x5a, 0xf5, 0x36, 0x52, 0x4a, 0x2c, 0xd3, 0x59, 0x91, 0x2a, 0x0f, + 0xe1, 0x5e, 0x6b, 0xe8, 0x96, 0x45, 0x8d, 0xaa, 0x35, 0xbd, 0xe5, 0x51, 0x7e, 0x19, 0x58, 0xe0, + 0x47, 0x82, 0xfc, 0x1d, 0x3a, 0x47, 0x33, 0xc6, 0x6b, 0x8c, 0x40, 0x4b, 0x29, 0xa4, 0xfe, 0x76, + 0x31, 0x25, 0xa5, 0xc8, 0x09, 0x52, 0x1f, 0xbf, 0xa7, 0x8b, 0xbb, 0xf4, 0xf4, 0x75, 0x18, 0x10, + 0x31, 0x72, 0xc5, 0x05, 0x03, 0x3a, 0xce, 0x3f, 0xe4, 0x20, 0xf9, 0x86, 0x46, 0x50, 0x91, 0x16, + 0x5c, 0x5a, 0x65, 0xdd, 0x94, 0xde, 0x99, 0xa5, 0x03, 0x74, 0x66, 0x0f, 0x7e, 0xe4, 0x3d, 0xb8, + 0x88, 0xd8, 0x94, 0x6e, 0x1d, 0xc0, 0xaa, 0x30, 0x1e, 0x16, 0xaf, 0x2a, 0xbd, 0x73, 0xb3, 0xca, + 0x93, 0xcf, 0xc3, 0x48, 0x30, 0x40, 0x4c, 0xea, 0x8a, 0x9b, 0x8b, 0x1e, 0xe3, 0x8c, 0x07, 0x9b, + 0x63, 0x60, 0x74, 0x57, 0x8b, 0x06, 0x2c, 0x8b, 0xf0, 0x52, 0xff, 0x87, 0x5c, 0xaf, 0xd4, 0x26, + 0xc7, 0x3e, 0x2b, 0xbf, 0x0d, 0x03, 0x06, 0xff, 0x28, 0xa1, 0x53, 0xbd, 0x93, 0x9f, 0x70, 0x52, + 0xcd, 0x2f, 0xa3, 0xfe, 0xd3, 0x5c, 0xcf, 0x8c, 0x2a, 0x27, 0xfd, 0xf3, 0xbe, 0x5a, 0xc8, 0xf8, + 0x3c, 0x31, 0x89, 0x5e, 0x83, 0x71, 0x33, 0x0c, 0xf9, 0x5e, 0x0f, 0x43, 0x5d, 0x69, 0x67, 0x24, + 0x38, 0x8e, 0xae, 0x9b, 0x10, 0x38, 0x6c, 0x39, 0xbe, 0x37, 0x9a, 0x5b, 0xef, 0x3a, 0x26, 0x1f, + 0x97, 0xda, 0x39, 0x37, 0xe6, 0xaa, 0xe6, 0xde, 0x75, 0x4c, 0x56, 0x81, 0xee, 0x6d, 0x50, 0x4b, + 0xaf, 0x6f, 0xda, 0xce, 0x03, 0x8c, 0x68, 0xca, 0x07, 0xa7, 0x76, 0x86, 0xc3, 0xef, 0xfb, 0x60, + 0xf2, 0x1c, 0x8c, 0x36, 0x5b, 0x5d, 0x1a, 0xc4, 0x90, 0xe4, 0x77, 0x7d, 0xda, 0x08, 0x03, 0x06, + 0x37, 0x24, 0x4f, 0x01, 0x20, 0x91, 0x87, 0xf9, 0x6e, 0xf0, 0x62, 0x4f, 0x1b, 0x62, 0x90, 0x55, + 0xd1, 0x5d, 0x97, 0xb8, 0x56, 0x73, 0x21, 0xd5, 0x5b, 0xb6, 0xd5, 0xac, 0x7b, 0xd4, 0x69, 0x63, + 0x43, 0xd1, 0x99, 0x41, 0xbb, 0x80, 0x14, 0x78, 0x75, 0xe2, 0x2e, 0xd8, 0x56, 0x73, 0x95, 0x3a, + 0x6d, 0xd6, 0xd4, 0x17, 0x80, 0x88, 0xa6, 0x3a, 0x78, 0xe8, 0xc1, 0x3f, 0x0e, 0xbd, 0x19, 0x34, + 0xf1, 0x11, 0xfc, 0x34, 0x04, 0x3f, 0x6c, 0x12, 0x86, 0x79, 0x20, 0x3d, 0x2e, 0x34, 0x74, 0x61, + 0xd0, 0x80, 0x83, 0x50, 0x5e, 0x17, 0x40, 0x78, 0x57, 0x70, 0x0f, 0x72, 0x4d, 0xfc, 0x52, 0xbf, + 0x5c, 0x48, 0x4b, 0x02, 0x73, 0x28, 0x45, 0x0b, 0xa7, 0xd5, 0xfc, 0xbe, 0xa6, 0xd5, 0x33, 0x56, + 0xb7, 0x5d, 0xd7, 0x3b, 0x9d, 0xfa, 0xba, 0xd9, 0xc2, 0x27, 0x5c, 0xb8, 0xf0, 0x69, 0xa3, 0x56, + 0xb7, 0x5d, 0xee, 0x74, 0xe6, 0x38, 0x90, 0x3c, 0x0f, 0x13, 0x8c, 0x0e, 0x3b, 0x29, 0xa0, 0x2c, + 0x22, 0x25, 0x63, 0x80, 0x91, 0x68, 0x7d, 0xda, 0x27, 0x60, 0x50, 0xf0, 0xe4, 0x6b, 0x55, 0xbf, + 0x36, 0xc0, 0x99, 0xb9, 0xac, 0xe7, 0x02, 0x36, 0x7c, 0x72, 0xed, 0xd7, 0x86, 0xfc, 0xf2, 0x18, + 0x6f, 0xd9, 0xea, 0xb6, 0x79, 0xf4, 0xad, 0x01, 0x44, 0x06, 0xbf, 0xc9, 0x15, 0x18, 0x63, 0x5c, + 0x02, 0x81, 0xf1, 0x10, 0xb5, 0xfd, 0x5a, 0x0c, 0x4a, 0x6e, 0xc0, 0xb9, 0x08, 0x84, 0xdb, 0xa0, + 0xfc, 0x49, 0x42, 0xbf, 0x96, 0x8a, 0x53, 0xbf, 0x59, 0x88, 0xa6, 0xa6, 0x39, 0x86, 0x8e, 0xb8, + 0x08, 0x03, 0xb6, 0xd3, 0xac, 0x77, 0x9d, 0x96, 0x18, 0x7b, 0x25, 0xdb, 0x69, 0xde, 0x75, 0x5a, + 0xe4, 0x3c, 0x94, 0x58, 0xef, 0x98, 0x86, 0x18, 0x62, 0xfd, 0x7a, 0xa7, 0x53, 0x35, 0x48, 0x99, + 0x77, 0x08, 0x86, 0x37, 0xad, 0x37, 0x70, 0x6b, 0xcf, 0x9d, 0x12, 0xfa, 0xf9, 0x8a, 0x97, 0x40, + 0x62, 0x3f, 0x61, 0xd0, 0x53, 0x7e, 0x10, 0x10, 0x63, 0x61, 0xe0, 0xb6, 0xc4, 0xe0, 0x7d, 0x12, + 0x67, 0x21, 0x90, 0x21, 0x0b, 0xbe, 0x89, 0x31, 0x48, 0x05, 0x48, 0x48, 0xd5, 0xb6, 0x0d, 0x73, + 0xdd, 0xa4, 0xfc, 0x05, 0x49, 0x3f, 0xbf, 0xf8, 0x4d, 0x62, 0xb5, 0x71, 0x9f, 0xc9, 0xa2, 0x80, + 0x90, 0x37, 0xb9, 0x12, 0x72, 0x3a, 0x5c, 0xfb, 0x78, 0xdf, 0x72, 0x3b, 0x2d, 0x86, 0x42, 0xcd, + 0xc4, 0xf2, 0xb8, 0x10, 0xaa, 0x7f, 0xbd, 0x98, 0xcc, 0x4f, 0x74, 0x2c, 0x76, 0xcd, 0x3c, 0x80, + 0x48, 0x3f, 0x16, 0x5e, 0xae, 0x05, 0xde, 0xed, 0x21, 0x26, 0x83, 0x87, 0x54, 0x96, 0x5c, 0x83, + 0x41, 0xfe, 0x45, 0xd5, 0x8a, 0xb0, 0x77, 0xd0, 0x45, 0xcc, 0xed, 0x98, 0xeb, 0xeb, 0xe8, 0x4f, + 0x16, 0xa0, 0xc9, 0x15, 0x18, 0xa8, 0x2c, 0xd5, 0x6a, 0xe5, 0x25, 0xff, 0xa6, 0x18, 0xdf, 0xb2, + 0x18, 0x96, 0x5b, 0x77, 0x75, 0xcb, 0xd5, 0x7c, 0x24, 0x79, 0x0e, 0x4a, 0xd5, 0x15, 0x24, 0xe3, + 0x2f, 0x34, 0x87, 0x77, 0xb6, 0x27, 0x07, 0xcc, 0x0e, 0xa7, 0x12, 0x28, 0xac, 0xf7, 0x5e, 0xb5, + 0x22, 0xb9, 0x4b, 0xf0, 0x7a, 0x1f, 0x9a, 0x06, 0x5e, 0x3b, 0x6b, 0x01, 0x9a, 0xbc, 0x02, 0x23, + 0x35, 0xea, 0x98, 0x7a, 0x6b, 0xa9, 0x8b, 0x5b, 0x45, 0x29, 0x6c, 0xa3, 0x8b, 0xf0, 0xba, 0x85, + 0x08, 0x2d, 0x42, 0x46, 0x2e, 0x43, 0x71, 0xde, 0xb4, 0xfc, 0xe7, 0x12, 0xe8, 0x4f, 0xbf, 0x61, + 0x5a, 0x9e, 0x86, 0x50, 0xf2, 0x1c, 0x14, 0x6e, 0xaf, 0x56, 0x85, 0x27, 0x18, 0xf2, 0x7a, 0xdf, + 0x8b, 0x84, 0x80, 0xbc, 0xbd, 0x5a, 0x25, 0xaf, 0xc0, 0x10, 0x5b, 0xc4, 0xa8, 0xd5, 0xa0, 0xae, + 0x32, 0x8c, 0x1f, 0xc3, 0x43, 0x16, 0xfa, 0x40, 0xd9, 0xa7, 0x23, 0xa0, 0x54, 0xff, 0x8f, 0x7c, + 0x7a, 0x02, 0xa9, 0x63, 0x18, 0xea, 0x07, 0xbc, 0x45, 0x8e, 0x29, 0x58, 0xf1, 0x10, 0x0a, 0xb6, + 0x0e, 0x67, 0xca, 0x46, 0xdb, 0xb4, 0xca, 0xf8, 0xd3, 0x5d, 0x9c, 0x2b, 0xe3, 0xd4, 0x21, 0x3d, + 0x05, 0x8c, 0xa1, 0xc5, 0xf7, 0xf0, 0xe0, 0xc2, 0x0c, 0x55, 0xd7, 0x39, 0xae, 0xde, 0x5e, 0xd7, + 0xeb, 0x0d, 0x9e, 0x7b, 0x49, 0x8b, 0x33, 0x55, 0x7f, 0x26, 0xbf, 0x4b, 0xce, 0xab, 0xc7, 0x51, + 0xfa, 0xea, 0xd7, 0xf2, 0xbd, 0xd3, 0x8e, 0x3d, 0x96, 0x42, 0xf9, 0x93, 0x7c, 0x4a, 0x12, 0xb0, + 0x43, 0x49, 0xe2, 0x1a, 0x0c, 0x72, 0x36, 0x81, 0x1b, 0x2f, 0xce, 0x66, 0x5c, 0x59, 0x71, 0x16, + 0xf5, 0xd1, 0x64, 0x09, 0xce, 0x95, 0xd7, 0xd7, 0x69, 0xc3, 0x0b, 0xc3, 0x4c, 0x2f, 0x85, 0x01, + 0x5f, 0x79, 0x58, 0x5d, 0x81, 0x0f, 0xc3, 0x54, 0x63, 0x60, 0x93, 0xd4, 0x72, 0x64, 0x15, 0x2e, + 0xc4, 0xe1, 0x35, 0xbe, 0x05, 0x28, 0x4a, 0x91, 0x76, 0x13, 0x1c, 0xf9, 0x7f, 0x5a, 0x46, 0xd9, + 0xb4, 0x56, 0xe2, 0x54, 0xdd, 0xdf, 0xab, 0x95, 0x38, 0x6f, 0xa7, 0x96, 0x53, 0xbf, 0x55, 0x90, + 0x73, 0xa5, 0x3d, 0xbe, 0x0e, 0x57, 0x37, 0x23, 0x6e, 0xd6, 0x7b, 0x1d, 0x32, 0xaf, 0x88, 0x68, + 0x25, 0x46, 0xd7, 0xf1, 0x3d, 0x12, 0x83, 0x68, 0x09, 0x08, 0x94, 0xd7, 0xa1, 0x80, 0x92, 0x54, + 0xa1, 0x58, 0x76, 0x9a, 0xdc, 0xbc, 0xdd, 0xed, 0x01, 0x97, 0xee, 0x34, 0xdd, 0xf4, 0x07, 0x5c, + 0x8c, 0x85, 0xfa, 0xe7, 0xf3, 0x3d, 0xd2, 0x9b, 0x3d, 0x96, 0x93, 0xc8, 0x5f, 0xca, 0x67, 0x25, + 0x2a, 0x3b, 0xa9, 0xae, 0x63, 0x1f, 0xb2, 0x70, 0x4e, 0xb6, 0x5f, 0xdd, 0x11, 0x0a, 0xe7, 0x0f, + 0xf3, 0x59, 0x59, 0xd7, 0x4e, 0x85, 0x73, 0xb0, 0x09, 0x32, 0x55, 0xa4, 0x8f, 0xb1, 0xcd, 0x2d, + 0xab, 0x42, 0xff, 0x01, 0xdd, 0xa7, 0xd2, 0x44, 0x7a, 0x3a, 0x84, 0x0f, 0xa5, 0xa5, 0x7f, 0x94, + 0xcf, 0xcc, 0x2e, 0x78, 0x2a, 0xd3, 0xa3, 0x94, 0xe9, 0xe9, 0xd0, 0x3f, 0xd4, 0xd0, 0x4f, 0x95, + 0xe9, 0xe9, 0xd8, 0x3f, 0x94, 0x9e, 0xfe, 0x41, 0x3e, 0x3d, 0x7f, 0xe6, 0x31, 0x28, 0xe9, 0x51, + 0x78, 0x38, 0xfa, 0xdd, 0x50, 0x3c, 0x54, 0x37, 0xf4, 0x1f, 0xc2, 0x8a, 0x4a, 0x0a, 0xf4, 0xd8, + 0x46, 0xfd, 0xf7, 0xab, 0x40, 0x8f, 0x60, 0xc8, 0x3f, 0xce, 0x02, 0xfd, 0xa9, 0x42, 0x32, 0x67, + 0xec, 0xe3, 0xba, 0x26, 0x39, 0x07, 0x5c, 0x93, 0xfc, 0x72, 0xe4, 0x1d, 0x38, 0x13, 0xca, 0x52, + 0x8e, 0x32, 0x86, 0xd7, 0x47, 0x0d, 0x86, 0xaa, 0xbf, 0xcf, 0x70, 0x22, 0x1c, 0x4e, 0x9c, 0x5a, + 0xfd, 0x5e, 0x21, 0x99, 0x78, 0xf7, 0xb4, 0x37, 0x0e, 0xd8, 0x1b, 0x77, 0xe1, 0xc2, 0x4c, 0xd7, + 0x71, 0xa8, 0xe5, 0xa5, 0x77, 0x0a, 0x1e, 0xde, 0x37, 0x38, 0x45, 0x3d, 0xd9, 0x39, 0x19, 0x85, + 0x19, 0x5b, 0xf1, 0xba, 0x21, 0xce, 0x76, 0x20, 0x64, 0xdb, 0xe5, 0x14, 0x69, 0x6c, 0xd3, 0x0b, + 0xab, 0xbf, 0x97, 0x4f, 0xa6, 0x4a, 0x3e, 0xed, 0xfa, 0x83, 0x75, 0xbd, 0xfa, 0xe5, 0x42, 0x3c, + 0x5d, 0xf4, 0xe9, 0x02, 0x71, 0xf0, 0xee, 0xf0, 0x25, 0x89, 0xe3, 0x46, 0xfa, 0x0a, 0x1f, 0x9e, + 0xf5, 0x15, 0x3e, 0x5e, 0xfd, 0x95, 0x62, 0x3c, 0xf5, 0xf6, 0x69, 0x77, 0x1c, 0x5f, 0x77, 0x90, + 0x65, 0x38, 0x27, 0xe6, 0x36, 0x1f, 0x84, 0xe9, 0x26, 0xc4, 0xfc, 0xc5, 0xb3, 0xd6, 0x89, 0x69, + 0xb1, 0xeb, 0x52, 0xa7, 0xee, 0xe9, 0xee, 0x83, 0x3a, 0xe6, 0xa7, 0xd0, 0x52, 0x0b, 0x32, 0x86, + 0x62, 0x56, 0x8b, 0x32, 0x1c, 0x0c, 0x19, 0xfa, 0x13, 0x62, 0x82, 0x61, 0x5a, 0x41, 0xf5, 0x37, + 0x72, 0x30, 0x1e, 0xff, 0x1c, 0x32, 0x05, 0x83, 0xec, 0x77, 0xf0, 0xec, 0x5e, 0xca, 0x89, 0xcd, + 0x39, 0xf2, 0x2b, 0x79, 0x9f, 0x86, 0xbc, 0x0a, 0x43, 0xe8, 0xfd, 0x80, 0x05, 0xf2, 0x61, 0xb4, + 0x83, 0xb0, 0x00, 0x26, 0x6a, 0xe5, 0xc5, 0x42, 0x52, 0xf2, 0x26, 0x0c, 0x57, 0x43, 0x37, 0x2f, + 0x71, 0xe7, 0x85, 0xde, 0xa5, 0x52, 0xc9, 0x90, 0x40, 0x93, 0xa9, 0xd5, 0x6f, 0xe7, 0xe3, 0x29, + 0xe2, 0x4f, 0x55, 0xfd, 0x60, 0xaa, 0xfe, 0xfc, 0x22, 0x57, 0xf5, 0x3b, 0xa6, 0x65, 0x90, 0x27, + 0xe0, 0xfc, 0xdd, 0xda, 0xac, 0x56, 0xbf, 0x53, 0x5d, 0xaa, 0xd4, 0xef, 0x2e, 0xd5, 0x56, 0x66, + 0x67, 0xaa, 0x73, 0xd5, 0xd9, 0xca, 0x78, 0x1f, 0x39, 0x0b, 0x67, 0x42, 0xd4, 0xfc, 0xdd, 0xc5, + 0xf2, 0xd2, 0x78, 0x8e, 0x4c, 0xc0, 0x68, 0x08, 0x9c, 0x5e, 0x5e, 0x1d, 0xcf, 0x3f, 0xff, 0x09, + 0x18, 0x46, 0xf7, 0x36, 0x7e, 0x1d, 0x4f, 0x46, 0x60, 0x70, 0x79, 0xba, 0x36, 0xab, 0xdd, 0x43, + 0x26, 0x00, 0xa5, 0xca, 0xec, 0x12, 0x63, 0x98, 0x7b, 0xfe, 0xff, 0xce, 0x01, 0xd4, 0xe6, 0x56, + 0x57, 0x04, 0xe1, 0x30, 0x0c, 0x54, 0x97, 0xee, 0x95, 0x17, 0xaa, 0x8c, 0x6e, 0x10, 0x8a, 0xcb, + 0x2b, 0xb3, 0xac, 0x86, 0x21, 0xe8, 0x9f, 0x59, 0x58, 0xae, 0xcd, 0x8e, 0xe7, 0x19, 0x50, 0x9b, + 0x2d, 0x57, 0xc6, 0x0b, 0x0c, 0x78, 0x5f, 0xab, 0xae, 0xce, 0x8e, 0x17, 0xd9, 0x9f, 0x0b, 0xb5, + 0xd5, 0xf2, 0xea, 0x78, 0x3f, 0xfb, 0x73, 0x0e, 0xff, 0x2c, 0x31, 0x66, 0xb5, 0xd9, 0x55, 0xfc, + 0x31, 0xc0, 0x9a, 0x30, 0xe7, 0xff, 0x1a, 0x64, 0x28, 0xc6, 0xba, 0x52, 0xd5, 0xc6, 0x87, 0xd8, + 0x0f, 0xc6, 0x92, 0xfd, 0x00, 0xd6, 0x38, 0x6d, 0x76, 0x71, 0xf9, 0xde, 0xec, 0xf8, 0x30, 0xe3, + 0xb5, 0x78, 0x87, 0x81, 0x47, 0xd8, 0x9f, 0xda, 0x22, 0xfb, 0x73, 0x94, 0x71, 0xd2, 0x66, 0xcb, + 0x0b, 0x2b, 0xe5, 0xd5, 0xf9, 0xf1, 0x31, 0xd6, 0x1e, 0xe4, 0x79, 0x86, 0x97, 0x5c, 0x2a, 0x2f, + 0xce, 0x8e, 0x8f, 0x0b, 0x9a, 0xca, 0x42, 0x75, 0xe9, 0xce, 0xf8, 0x04, 0x36, 0xe4, 0xbd, 0x45, + 0xfc, 0x41, 0x58, 0x01, 0xfc, 0xeb, 0xec, 0xf3, 0x3f, 0x08, 0xa5, 0xe5, 0x1a, 0x8e, 0x82, 0x8b, + 0x70, 0x76, 0xb9, 0x56, 0x5f, 0x7d, 0x6f, 0x65, 0x36, 0x26, 0xef, 0x09, 0x18, 0xf5, 0x11, 0x0b, + 0xd5, 0xa5, 0xbb, 0x9f, 0xe3, 0xd2, 0xf6, 0x41, 0x8b, 0xe5, 0x99, 0xe5, 0xda, 0x78, 0x9e, 0xf5, + 0x8a, 0x0f, 0xba, 0x5f, 0x5d, 0xaa, 0x2c, 0xdf, 0xaf, 0x8d, 0x17, 0x9e, 0x7f, 0x08, 0x23, 0x3c, + 0x4f, 0xe7, 0xb2, 0x63, 0x36, 0x4d, 0x8b, 0x3c, 0x05, 0x4f, 0x54, 0x66, 0xef, 0x55, 0x67, 0x66, + 0xeb, 0xcb, 0x5a, 0xf5, 0x56, 0x75, 0x29, 0x56, 0xd3, 0x79, 0x98, 0x88, 0xa2, 0xcb, 0x2b, 0xd5, + 0xf1, 0x1c, 0xb9, 0x00, 0x24, 0x0a, 0xbe, 0x5d, 0x5e, 0x9c, 0x1b, 0xcf, 0x13, 0x05, 0xce, 0x45, + 0xe1, 0xd5, 0xa5, 0xd5, 0xbb, 0x4b, 0xb3, 0xe3, 0x85, 0xe7, 0xff, 0x5a, 0x0e, 0xce, 0xa7, 0xc6, + 0x72, 0x26, 0x2a, 0x3c, 0x3d, 0xbb, 0x50, 0xae, 0xad, 0x56, 0x67, 0x6a, 0xb3, 0x65, 0x6d, 0x66, + 0xbe, 0x3e, 0x53, 0x5e, 0x9d, 0xbd, 0xb5, 0xac, 0xbd, 0x57, 0xbf, 0x35, 0xbb, 0x34, 0xab, 0x95, + 0x17, 0xc6, 0xfb, 0xc8, 0x73, 0x30, 0x99, 0x41, 0x53, 0x9b, 0x9d, 0xb9, 0xab, 0x55, 0x57, 0xdf, + 0x1b, 0xcf, 0x91, 0x67, 0xe1, 0xa9, 0x4c, 0x22, 0xf6, 0x7b, 0x3c, 0x4f, 0x9e, 0x86, 0x4b, 0x59, + 0x24, 0xef, 0x2e, 0x8c, 0x17, 0x9e, 0xff, 0xf9, 0x1c, 0x90, 0x64, 0x30, 0x5e, 0xf2, 0x0c, 0x5c, + 0x66, 0x7a, 0x51, 0xcf, 0x6e, 0xe0, 0xb3, 0xf0, 0x54, 0x2a, 0x85, 0xd4, 0xbc, 0x49, 0x78, 0x32, + 0x83, 0x44, 0x34, 0xee, 0x32, 0x28, 0xe9, 0x04, 0xd8, 0xb4, 0x5f, 0xcf, 0xc1, 0xf9, 0x54, 0x0f, + 0x18, 0x72, 0x15, 0x3e, 0x56, 0xae, 0x2c, 0xb2, 0xbe, 0x99, 0x59, 0xad, 0x2e, 0x2f, 0xd5, 0xea, + 0x8b, 0x73, 0xe5, 0x3a, 0xd3, 0xbe, 0xbb, 0xb5, 0x58, 0x6f, 0x5e, 0x01, 0xb5, 0x07, 0xe5, 0xcc, + 0x7c, 0x79, 0xe9, 0x16, 0x1b, 0x7e, 0xe4, 0x63, 0xf0, 0x4c, 0x26, 0xdd, 0xec, 0x52, 0x79, 0x7a, + 0x61, 0xb6, 0x32, 0x9e, 0x27, 0x1f, 0x87, 0x67, 0x33, 0xa9, 0x2a, 0xd5, 0x1a, 0x27, 0x2b, 0x4c, + 0x57, 0xbe, 0xfd, 0x3f, 0x3d, 0xdd, 0xf7, 0xed, 0x3f, 0x7e, 0x3a, 0xf7, 0x87, 0x7f, 0xfc, 0x74, + 0xee, 0x9f, 0xfd, 0xf1, 0xd3, 0xb9, 0xcf, 0xdf, 0xd8, 0x4f, 0x90, 0x65, 0x3e, 0x6d, 0xad, 0x95, + 0xf0, 0x36, 0xfa, 0xe5, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xb9, 0x4b, 0xf8, 0x16, 0xde, 0x81, + 0x01, 0x00, } func (m *Metadata) Marshal() (dAtA []byte, err error) { @@ -20024,6 +20030,26 @@ func (m *PortForward) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.KubernetesPodMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + { + size, err := m.KubernetesClusterMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 if len(m.Addr) > 0 { i -= len(m.Addr) copy(dAtA[i:], m.Addr) @@ -20422,63 +20448,63 @@ func (m *SFTPAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.XXX_unrecognized) } if m.ModificationTime != nil { - n154, err154 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.ModificationTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.ModificationTime):]) - if err154 != nil { - return 0, err154 - } - i -= n154 - i = encodeVarintEvents(dAtA, i, uint64(n154)) - i-- - dAtA[i] = 0x32 - } - if m.AccessTime != nil { - n155, err155 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.AccessTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.AccessTime):]) - if err155 != nil { - return 0, err155 - } - i -= n155 - i = encodeVarintEvents(dAtA, i, uint64(n155)) - i-- - dAtA[i] = 0x2a - } - if m.Permissions != nil { - n156, err156 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.Permissions, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.Permissions):]) + n156, err156 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.ModificationTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.ModificationTime):]) if err156 != nil { return 0, err156 } i -= n156 i = encodeVarintEvents(dAtA, i, uint64(n156)) i-- - dAtA[i] = 0x22 + dAtA[i] = 0x32 } - if m.GID != nil { - n157, err157 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.GID, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.GID):]) + if m.AccessTime != nil { + n157, err157 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.AccessTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.AccessTime):]) if err157 != nil { return 0, err157 } i -= n157 i = encodeVarintEvents(dAtA, i, uint64(n157)) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x2a } - if m.UID != nil { - n158, err158 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.UID, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.UID):]) + if m.Permissions != nil { + n158, err158 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.Permissions, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.Permissions):]) if err158 != nil { return 0, err158 } i -= n158 i = encodeVarintEvents(dAtA, i, uint64(n158)) i-- - dAtA[i] = 0x12 + dAtA[i] = 0x22 } - if m.FileSize != nil { - n159, err159 := github_com_gogo_protobuf_types.StdUInt64MarshalTo(*m.FileSize, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.FileSize):]) + if m.GID != nil { + n159, err159 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.GID, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.GID):]) if err159 != nil { return 0, err159 } i -= n159 i = encodeVarintEvents(dAtA, i, uint64(n159)) i-- + dAtA[i] = 0x1a + } + if m.UID != nil { + n160, err160 := github_com_gogo_protobuf_types.StdUInt32MarshalTo(*m.UID, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt32(*m.UID):]) + if err160 != nil { + return 0, err160 + } + i -= n160 + i = encodeVarintEvents(dAtA, i, uint64(n160)) + i-- + dAtA[i] = 0x12 + } + if m.FileSize != nil { + n161, err161 := github_com_gogo_protobuf_types.StdUInt64MarshalTo(*m.FileSize, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdUInt64(*m.FileSize):]) + if err161 != nil { + return 0, err161 + } + i -= n161 + i = encodeVarintEvents(dAtA, i, uint64(n161)) + i-- dAtA[i] = 0xa } return len(dAtA) - i, nil @@ -24551,20 +24577,20 @@ func (m *DatabaseSessionEnd) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n358, err358 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err358 != nil { - return 0, err358 + n360, err360 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) + if err360 != nil { + return 0, err360 } - i -= n358 - i = encodeVarintEvents(dAtA, i, uint64(n358)) + i -= n360 + i = encodeVarintEvents(dAtA, i, uint64(n360)) i-- dAtA[i] = 0x32 - n359, err359 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err359 != nil { - return 0, err359 + n361, err361 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) + if err361 != nil { + return 0, err361 } - i -= n359 - i = encodeVarintEvents(dAtA, i, uint64(n359)) + i -= n361 + i = encodeVarintEvents(dAtA, i, uint64(n361)) i-- dAtA[i] = 0x2a { @@ -25231,20 +25257,20 @@ func (m *WindowsDesktopSessionEnd) MarshalToSizedBuffer(dAtA []byte) (int, error i-- dAtA[i] = 0x5a } - n392, err392 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err392 != nil { - return 0, err392 + n394, err394 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) + if err394 != nil { + return 0, err394 } - i -= n392 - i = encodeVarintEvents(dAtA, i, uint64(n392)) + i -= n394 + i = encodeVarintEvents(dAtA, i, uint64(n394)) i-- dAtA[i] = 0x52 - n393, err393 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err393 != nil { - return 0, err393 + n395, err395 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) + if err395 != nil { + return 0, err395 } - i -= n393 - i = encodeVarintEvents(dAtA, i, uint64(n393)) + i -= n395 + i = encodeVarintEvents(dAtA, i, uint64(n395)) i-- dAtA[i] = 0x4a if len(m.DesktopLabels) > 0 { @@ -25578,12 +25604,12 @@ func (m *InstanceJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x52 - n407, err407 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.TokenExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.TokenExpires):]) - if err407 != nil { - return 0, err407 + n409, err409 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.TokenExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.TokenExpires):]) + if err409 != nil { + return 0, err409 } - i -= n407 - i = encodeVarintEvents(dAtA, i, uint64(n407)) + i -= n409 + i = encodeVarintEvents(dAtA, i, uint64(n409)) i-- dAtA[i] = 0x4a if m.Attributes != nil { @@ -31188,12 +31214,12 @@ func (m *StreamStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n655, err655 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastUploadTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUploadTime):]) - if err655 != nil { - return 0, err655 + n657, err657 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastUploadTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUploadTime):]) + if err657 != nil { + return 0, err657 } - i -= n655 - i = encodeVarintEvents(dAtA, i, uint64(n655)) + i -= n657 + i = encodeVarintEvents(dAtA, i, uint64(n657)) i-- dAtA[i] = 0x1a if m.LastEventIndex != 0 { @@ -31352,12 +31378,12 @@ func (m *Identity) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0xc2 } } - n659, err659 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PreviousIdentityExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousIdentityExpires):]) - if err659 != nil { - return 0, err659 + n661, err661 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PreviousIdentityExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousIdentityExpires):]) + if err661 != nil { + return 0, err661 } - i -= n659 - i = encodeVarintEvents(dAtA, i, uint64(n659)) + i -= n661 + i = encodeVarintEvents(dAtA, i, uint64(n661)) i-- dAtA[i] = 0x1 i-- @@ -31505,12 +31531,12 @@ func (m *Identity) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x4a } - n663, err663 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) - if err663 != nil { - return 0, err663 + n665, err665 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) + if err665 != nil { + return 0, err665 } - i -= n663 - i = encodeVarintEvents(dAtA, i, uint64(n663)) + i -= n665 + i = encodeVarintEvents(dAtA, i, uint64(n665)) i-- dAtA[i] = 0x42 if len(m.KubernetesUsers) > 0 { @@ -39673,6 +39699,10 @@ func (m *PortForward) Size() (n int) { if l > 0 { n += 1 + l + sovEvents(uint64(l)) } + l = m.KubernetesClusterMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) + l = m.KubernetesPodMetadata.Size() + n += 1 + l + sovEvents(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -58738,6 +58768,72 @@ func (m *PortForward) Unmarshal(dAtA []byte) error { } m.Addr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KubernetesClusterMetadata", 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.KubernetesClusterMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KubernetesPodMetadata", 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.KubernetesPodMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) diff --git a/lib/events/api.go b/lib/events/api.go index 20b72ddd2e5f9..ce09acd15865a 100644 --- a/lib/events/api.go +++ b/lib/events/api.go @@ -792,35 +792,35 @@ const ( // IntegrationCreateEvent is emitted when an integration resource is created. IntegrationCreateEvent = "integration.create" - //IntegrationUpdateEvent is emitted when an integration resource is updated. + // IntegrationUpdateEvent is emitted when an integration resource is updated. IntegrationUpdateEvent = "integration.update" // IntegrationDeleteEvent is emitted when an integration resource is deleted. IntegrationDeleteEvent = "integration.delete" // PluginCreateEvent is emitted when a plugin resource is created. PluginCreateEvent = "plugin.create" - //PluginUpdateEvent is emitted when a plugin resource is updated. + // PluginUpdateEvent is emitted when a plugin resource is updated. PluginUpdateEvent = "plugin.update" // PluginDeleteEvent is emitted when a plugin resource is deleted. PluginDeleteEvent = "plugin.delete" // StaticHostUserCreateEvent is emitted when a static host user resource is created. StaticHostUserCreateEvent = "static_host_user.create" - //StaticHostUserUpdateEvent is emitted when a static host user resource is updated. + // StaticHostUserUpdateEvent is emitted when a static host user resource is updated. StaticHostUserUpdateEvent = "static_host_user.update" // StaticHostUserDeleteEvent is emitted when a static host user resource is deleted. StaticHostUserDeleteEvent = "static_host_user.delete" // CrownJewelCreateEvent is emitted when a crown jewel resource is created. CrownJewelCreateEvent = "access_graph.crown_jewel.create" - //CrownJewelUpdateEvent is emitted when a crown jewel resource is updated. + // CrownJewelUpdateEvent is emitted when a crown jewel resource is updated. 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 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" @@ -856,15 +856,13 @@ const ( V3 = 3 ) -var ( - // SessionRecordingEvents is a list of events that are related to session - // recorings. - SessionRecordingEvents = []string{ - SessionEndEvent, - WindowsDesktopSessionEndEvent, - DatabaseSessionEndEvent, - } -) +// SessionRecordingEvents is a list of events that are related to session +// recorings. +var SessionRecordingEvents = []string{ + SessionEndEvent, + WindowsDesktopSessionEndEvent, + DatabaseSessionEndEvent, +} // ServerMetadataGetter represents interface // that provides information about its server id diff --git a/lib/events/codes.go b/lib/events/codes.go index fa8c284fe925b..62897e9b168b9 100644 --- a/lib/events/codes.go +++ b/lib/events/codes.go @@ -286,6 +286,8 @@ const ( ExecFailureCode = "T3002E" // PortForwardCode is the port forward event code. PortForwardCode = "T3003I" + // PortForwardStopCode is the port forward stop event code. + PortForwardStopCode = "T3003S" // PortForwardFailureCode is the port forward failure event code. PortForwardFailureCode = "T3003E" // SCPDownloadCode is the file download event code. diff --git a/lib/kube/proxy/forwarder.go b/lib/kube/proxy/forwarder.go index 1cfd6351fddce..6f88ff1aa59c8 100644 --- a/lib/kube/proxy/forwarder.go +++ b/lib/kube/proxy/forwarder.go @@ -1773,10 +1773,12 @@ func (f *Forwarder) portForward(authCtx *authContext, w http.ResponseWriter, req return nil, trace.Wrap(err) } + auditSent := map[string]bool{} // Set of `addr`. Can be multiple ports on single call. Using bool to simplify the check. onPortForward := func(addr string, success bool) { - if !sess.isLocalKubernetesCluster { + if !sess.isLocalKubernetesCluster || auditSent[addr] { return } + auditSent[addr] = true portForward := &apievents.PortForward{ Metadata: apievents.Metadata{ Type: events.PortForwardEvent, @@ -1792,6 +1794,11 @@ func (f *Forwarder) portForward(authCtx *authContext, w http.ResponseWriter, req Status: apievents.Status{ Success: success, }, + KubernetesClusterMetadata: sess.eventClusterMeta(req), + KubernetesPodMetadata: apievents.KubernetesPodMetadata{ + KubernetesPodNamespace: p.ByName("podNamespace"), + KubernetesPodName: p.ByName("podName"), + }, } if !success { portForward.Code = events.PortForwardFailureCode @@ -1800,6 +1807,31 @@ func (f *Forwarder) portForward(authCtx *authContext, w http.ResponseWriter, req f.log.WithError(err).Warn("Failed to emit event.") } } + defer func() { + for addr := range auditSent { + portForward := &apievents.PortForward{ + Metadata: apievents.Metadata{ + Type: events.PortForwardEvent, + Code: events.PortForwardStopCode, + }, + UserMetadata: authCtx.eventUserMeta(), + ConnectionMetadata: apievents.ConnectionMetadata{ + LocalAddr: sess.kubeAddress, + RemoteAddr: req.RemoteAddr, + Protocol: events.EventProtocolKube, + }, + Addr: addr, + KubernetesClusterMetadata: sess.eventClusterMeta(req), + KubernetesPodMetadata: apievents.KubernetesPodMetadata{ + KubernetesPodNamespace: p.ByName("podNamespace"), + KubernetesPodName: p.ByName("podName"), + }, + } + if err := f.cfg.Emitter.EmitAuditEvent(f.ctx, portForward); err != nil { + f.log.WithError(err).Warn("Failed to emit event.") + } + } + }() q := req.URL.Query() request := portForwardRequest{ diff --git a/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx b/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx index d403cb036f23d..4f480fd516b40 100644 --- a/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx +++ b/web/packages/teleport/src/Audit/EventList/EventTypeCell.tsx @@ -195,6 +195,7 @@ const EventIconMap: Record = { [eventCodes.CLIENT_DISCONNECT]: Icons.Info, [eventCodes.PORTFORWARD]: Icons.Info, [eventCodes.PORTFORWARD_FAILURE]: Icons.Info, + [eventCodes.PORTFORWARD_STOP]: Icons.Info, [eventCodes.SUBSYSTEM]: Icons.Info, [eventCodes.SUBSYSTEM_FAILURE]: Icons.Info, [eventCodes.LOCK_CREATED]: Icons.Lock, diff --git a/web/packages/teleport/src/services/audit/makeEvent.ts b/web/packages/teleport/src/services/audit/makeEvent.ts index 52a0f5f7b30a8..04ea92e3bfe10 100644 --- a/web/packages/teleport/src/services/audit/makeEvent.ts +++ b/web/packages/teleport/src/services/audit/makeEvent.ts @@ -231,6 +231,11 @@ export const formatters: Formatters = { format: ({ user, error }) => `User [${user}] port forwarding request failed: ${error}`, }, + [eventCodes.PORTFORWARD_STOP]: { + type: 'port', + desc: 'Port Forwarding Stopped', + format: ({ user }) => `User [${user}] stopped port forwarding`, + }, [eventCodes.SAML_CONNECTOR_CREATED]: { type: 'saml.created', desc: 'SAML Connector Created', diff --git a/web/packages/teleport/src/services/audit/types.ts b/web/packages/teleport/src/services/audit/types.ts index 4d0a7a109ea71..9ee8adb612b05 100644 --- a/web/packages/teleport/src/services/audit/types.ts +++ b/web/packages/teleport/src/services/audit/types.ts @@ -143,6 +143,7 @@ export const eventCodes = { OIDC_CONNECTOR_DELETED: 'T8101I', OIDC_CONNECTOR_UPDATED: 'T8102I', PORTFORWARD_FAILURE: 'T3003E', + PORTFORWARD_STOP: 'T3003S', PORTFORWARD: 'T3003I', RECOVERY_TOKEN_CREATED: 'T6001I', PRIVILEGE_TOKEN_CREATED: 'T6002I', @@ -392,6 +393,7 @@ export type RawEvents = { typeof eventCodes.OIDC_CONNECTOR_UPDATED >; [eventCodes.PORTFORWARD]: RawEvent; + [eventCodes.PORTFORWARD_STOP]: RawEvent; [eventCodes.PORTFORWARD_FAILURE]: RawEvent< typeof eventCodes.PORTFORWARD_FAILURE, { From dc376cb690abffb6d008c4bb10e23324318fe1fa Mon Sep 17 00:00:00 2001 From: Alan Parra Date: Fri, 6 Dec 2024 17:14:11 -0300 Subject: [PATCH 07/16] [v17] Suggest enabling PROXY protocol in DTW troubleshooting (#49905) * Suggest enabling PROXY protocol in DTW troubleshooting * Mention audit as a source of information for errors * Mention solutions for both L7 and L4 LBs * Link X-Forwarded-For to config references --- docs/pages/includes/device-trust/prereqs.mdx | 4 ++++ .../includes/device-trust/troubleshooting.mdx | 17 +++++++++++++++-- 2 files changed, 19 insertions(+), 2 deletions(-) diff --git a/docs/pages/includes/device-trust/prereqs.mdx b/docs/pages/includes/device-trust/prereqs.mdx index 046cfd9fbcc1d..32699c20b21a7 100644 --- a/docs/pages/includes/device-trust/prereqs.mdx +++ b/docs/pages/includes/device-trust/prereqs.mdx @@ -12,3 +12,7 @@ - `tsh` v15.0.0 or newer. [Install tsh for Linux](../../installation.mdx#linux). - To authenticate a Web UI session you need [Teleport Connect]( ../../connect-your-client/teleport-connect.mdx#installation--upgrade) +- Correct end-user IP propagation to your Teleport deployment: + [X-Forwarded-For header](../../reference/config.mdx#proxy-service) (L7 load + balancer) or [PROXY protocol]( + ../../admin-guides/management/security/proxy-protocol.mdx) (L4 load balancer) diff --git a/docs/pages/includes/device-trust/troubleshooting.mdx b/docs/pages/includes/device-trust/troubleshooting.mdx index 3e18fb6d56d67..aeac5c840d216 100644 --- a/docs/pages/includes/device-trust/troubleshooting.mdx +++ b/docs/pages/includes/device-trust/troubleshooting.mdx @@ -80,8 +80,21 @@ follow the steps below: 4. Ask your cluster administrator if device trust is enabled (cluster mode "optional" or higher) -If all of the above steps are done, try logging out from the Web UI and logging -in again. +After the steps above are done try logging out from the Web UI and logging in +again. If the error persists, check your audit log for failed "device +authenticated" or "device web" events and look for failure details within the +events. + +### "device web authentication IP mismatch" errors + +"IP mismatch" errors in audit logs indicate that the IP checks performed by the +device web authentication ceremony failed. In this case it's likely that +end-user IPs are not propagated correctly to your Teleport deployment. + +* L7 load balancer: make sure it propagates the [X-Forwarded-For header]( + ../../reference/config.mdx#proxy-service) +* L4 load balancer: enable [PROXY protocol]( + ../../admin-guides/management/security/proxy-protocol.mdx) ### Checking Device Trust authorization status in the web UI From dafa8ffdda004e0e86d88c790a5cd4a1dd6313b3 Mon Sep 17 00:00:00 2001 From: rosstimothy <39066650+rosstimothy@users.noreply.github.com> Date: Fri, 6 Dec 2024 16:03:54 -0500 Subject: [PATCH 08/16] Prevent races counting missed heartbeats (#49908) Increments the `heartbeatsMissedByAuth` gauge directly instead of keeping a local count and setting the gauge once. This fixes a race caught in https://github.com/gravitational/teleport/actions/runs/11828850190/job/32959672995?pr=48949. ``` ================== WARNING: DATA RACE Write at 0x00c003857da8 by goroutine 48258: github.com/gravitational/teleport/lib/auth.(*Server).runPeriodicOperations.func3.1() /__w/teleport/teleport/lib/auth/auth.go:1471 +0x84 github.com/gravitational/teleport/lib/services.(*UnifiedResourceCache).getRange.func1.1() /__w/teleport/teleport/lib/services/unified_resource.go:239 +0x14d github.com/google/btree.(*node[go.shape.*uint8]).iterate() /go/pkg/mod/github.com/google/btree@v1.1.3/btree_generic.go:522 +0x62c github.com/google/btree.(*BTreeG[go.shape.*uint8]).AscendRange() /go/pkg/mod/github.com/google/btree@v1.1.3/btree_generic.go:752 +0x104 github.com/google/btree.(*BTreeG[*github.com/gravitational/teleport/lib/services.item]).AscendRange-fm() :1 +0x58 github.com/gravitational/teleport/lib/services.(*UnifiedResourceCache).getRange.func1() /__w/teleport/teleport/lib/services/unified_resource.go:230 +0x7a8 github.com/gravitational/teleport/lib/services.(*UnifiedResourceCache).read() /__w/teleport/teleport/lib/services/unified_resource.go:591 +0x2ad github.com/gravitational/teleport/lib/services.(*UnifiedResourceCache).getRange() /__w/teleport/teleport/lib/services/unified_resource.go:215 +0x2d9 github.com/gravitational/teleport/lib/services.(*UnifiedResourceCache).IterateUnifiedResources() /__w/teleport/teleport/lib/services/unified_resource.go:288 +0xe6 github.com/gravitational/teleport/lib/auth.(*Server).runPeriodicOperations.func3() /__w/teleport/teleport/lib/auth/auth.go:1464 +0x237 Previous read at 0x00c003857da8 by goroutine 48219: github.com/gravitational/teleport/lib/auth.(*Server).runPeriodicOperations.func3() /__w/teleport/teleport/lib/auth/auth.go:1489 +0x2d2 Goroutine 48258 (running) created at: github.com/gravitational/teleport/lib/auth.(*Server).runPeriodicOperations() /__w/teleport/teleport/lib/auth/auth.go:1460 +0xf9e github.com/gravitational/teleport/lib/auth.initCluster.gowrap1() /__w/teleport/teleport/lib/auth/init.go:594 +0x33 Goroutine 48219 (finished) created at: github.com/gravitational/teleport/lib/auth.(*Server).runPeriodicOperations() /__w/teleport/teleport/lib/auth/auth.go:1460 +0xf9e github.com/gravitational/teleport/lib/auth.initCluster.gowrap1() /__w/teleport/teleport/lib/auth/init.go:594 +0x33 ================== ``` --- lib/auth/auth.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/lib/auth/auth.go b/lib/auth/auth.go index e6365f6a7ac53..d7ccd64b82c1e 100644 --- a/lib/auth/auth.go +++ b/lib/auth/auth.go @@ -1380,8 +1380,6 @@ func (a *Server) runPeriodicOperations() { defer ticker.Stop() - missedKeepAliveCount := 0 - // Prevent some periodic operations from running for dashboard tenants. if !services.IsDashboard(*modules.GetModules().Features().ToProto()) { ticker.Push(interval.SubInterval[periodicIntervalKey]{ @@ -1483,7 +1481,7 @@ func (a *Server) runPeriodicOperations() { return false, nil } if services.NodeHasMissedKeepAlives(srv) { - missedKeepAliveCount++ + heartbeatsMissedByAuth.Inc() } // TODO(tross) DELETE in v20.0.0 - all invalid hostnames should have been sanitized by then. @@ -1521,9 +1519,6 @@ func (a *Server) runPeriodicOperations() { break } } - - // Update prometheus gauge - heartbeatsMissedByAuth.Set(float64(missedKeepAliveCount)) }() case metricsKey: go a.updateAgentMetrics() From a8942def4cc472ba41b9ed6c944c9ef683c00aed Mon Sep 17 00:00:00 2001 From: Cam Hutchison Date: Mon, 9 Dec 2024 09:58:57 +1100 Subject: [PATCH 09/16] examples/teleport-usage: Bump Go to 1.22 for math/rand/v2 (#49916) Bump Go to 1.22 in `go.mod` and the `Dockerfile` as that is the first version with `math/rand/v2`. bcbfa8192e4c60c33599fb7e38016804d26f958d changed this package to use `math/rand/v2` but the docker build failed because it uses Go 1.21. --- examples/teleport-usage/Dockerfile | 2 +- examples/teleport-usage/go.mod | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/teleport-usage/Dockerfile b/examples/teleport-usage/Dockerfile index ba959b0c00107..aa9f485221143 100644 --- a/examples/teleport-usage/Dockerfile +++ b/examples/teleport-usage/Dockerfile @@ -1,6 +1,6 @@ ARG BASE_IMAGE=gcr.io/distroless/static-debian12 -FROM golang:1.21-bookworm as builder +FROM golang:1.22-bookworm as builder WORKDIR /go/src/github.com/gravitational/teleport/examples/teleport-usage diff --git a/examples/teleport-usage/go.mod b/examples/teleport-usage/go.mod index eaf6665957da9..9c009bebf497a 100644 --- a/examples/teleport-usage/go.mod +++ b/examples/teleport-usage/go.mod @@ -1,6 +1,6 @@ module usage-script -go 1.19 +go 1.22 require ( github.com/aws/aws-sdk-go v1.47.4 From f980eb90ba8f3696b800455c611deaaa03dda851 Mon Sep 17 00:00:00 2001 From: Bartosz Leper Date: Mon, 9 Dec 2024 11:51:19 +0100 Subject: [PATCH 10/16] SlideTabs improvements (#49545) (#49890) * Validation Adds a model-level validation capability to our validation library. * Move tooltips to the design package They will be later required in the SlideTabs component * SlideTabs improvements Add support for tooltips and status icons * Review * Also, rename the tooltip directory * Fix an import * Review: status-related props, extract StatusIcon * Also, rename the tooltip component * review * review * Never return undefined from useValidation() --- web/packages/design/src/Alert/Alert.tsx | 61 ++++---- .../design/src/SlideTabs/SlideTabs.story.tsx | 65 ++++++-- .../design/src/SlideTabs/SlideTabs.test.tsx | 9 +- .../design/src/SlideTabs/SlideTabs.tsx | 143 ++++++++++++++---- .../src/StatusIcon/StatusIcon.story.tsx | 44 ++++++ .../design/src/StatusIcon/StatusIcon.tsx | 78 ++++++++++ web/packages/design/src/StatusIcon/index.ts | 19 +++ 7 files changed, 349 insertions(+), 70 deletions(-) create mode 100644 web/packages/design/src/StatusIcon/StatusIcon.story.tsx create mode 100644 web/packages/design/src/StatusIcon/StatusIcon.tsx create mode 100644 web/packages/design/src/StatusIcon/index.ts diff --git a/web/packages/design/src/Alert/Alert.tsx b/web/packages/design/src/Alert/Alert.tsx index 68c5487b7788e..f8ce4b7269310 100644 --- a/web/packages/design/src/Alert/Alert.tsx +++ b/web/packages/design/src/Alert/Alert.tsx @@ -22,6 +22,8 @@ import { style, color, ColorProps } from 'styled-system'; import { IconProps } from 'design/Icon/Icon'; +import { StatusIcon, StatusKind } from 'design/StatusIcon'; + import { space, SpaceProps, width, WidthProps } from '../system'; import { Theme } from '../theme'; import * as Icon from '../Icon'; @@ -193,7 +195,12 @@ export const Alert = ({ - + ` ${backgroundColor} `; -const AlertIcon = ({ - kind, - customIcon: CustomIcon, - ...otherProps -}: { - kind: AlertKind | BannerKind; - customIcon?: React.ComponentType; -} & IconProps) => { - const commonProps = { role: 'graphics-symbol', ...otherProps }; - if (CustomIcon) { - return ; - } - switch (kind) { - case 'success': - return ; - case 'danger': - case 'outline-danger': - return ; - case 'info': - case 'outline-info': - return ; - case 'warning': - case 'outline-warn': - return ; - case 'neutral': - case 'primary': - return ; - } -}; - const iconContainerStyles = ({ kind, theme, @@ -468,7 +445,12 @@ export const Banner = ({ gap={3} alignItems="center" > - + {children} {details} @@ -525,3 +507,18 @@ const bannerColors = (theme: Theme, kind: BannerKind) => { }; } }; + +const iconKind = (kind: AlertKind | BannerKind): StatusKind => { + switch (kind) { + case 'outline-danger': + return 'danger'; + case 'outline-warn': + return 'warning'; + case 'outline-info': + return 'info'; + case 'primary': + return 'neutral'; + default: + return kind; + } +}; diff --git a/web/packages/design/src/SlideTabs/SlideTabs.story.tsx b/web/packages/design/src/SlideTabs/SlideTabs.story.tsx index fa2ce7dbafa2b..bb3eb8c49818a 100644 --- a/web/packages/design/src/SlideTabs/SlideTabs.story.tsx +++ b/web/packages/design/src/SlideTabs/SlideTabs.story.tsx @@ -21,7 +21,7 @@ import React, { useState } from 'react'; import * as Icon from 'design/Icon'; import Flex from 'design/Flex'; -import { SlideTabs } from './SlideTabs'; +import { SlideTabs, TabSpec } from './SlideTabs'; export default { title: 'Design/SlideTabs', @@ -120,9 +120,33 @@ export const Small = () => { { ); }; -export const LoadingTab = () => { +export const StatusIcons = () => { + const [activeIndex, setActiveIndex] = useState(0); + const tabs: TabSpec[] = [ + { key: 'warning', title: 'warning', status: { kind: 'warning' } }, + { key: 'danger', title: 'danger', status: { kind: 'danger' } }, + { key: 'neutral', title: 'neutral', status: { kind: 'neutral' } }, + ]; return ( - null} - activeIndex={1} - isProcessing={true} - /> + + + + + ); }; diff --git a/web/packages/design/src/SlideTabs/SlideTabs.test.tsx b/web/packages/design/src/SlideTabs/SlideTabs.test.tsx index 4636655d25700..fe4137f34b28b 100644 --- a/web/packages/design/src/SlideTabs/SlideTabs.test.tsx +++ b/web/packages/design/src/SlideTabs/SlideTabs.test.tsx @@ -21,6 +21,8 @@ import { screen } from '@testing-library/react'; import { render, userEvent } from 'design/utils/testing'; +import * as Icon from 'design/Icon'; + import { SlideTabs, SlideTabsProps } from './SlideTabs'; describe('design/SlideTabs', () => { @@ -87,7 +89,12 @@ describe('design/SlideTabs', () => { ); diff --git a/web/packages/design/src/SlideTabs/SlideTabs.tsx b/web/packages/design/src/SlideTabs/SlideTabs.tsx index 6b92c5803fdf0..9a81f79fd99ac 100644 --- a/web/packages/design/src/SlideTabs/SlideTabs.tsx +++ b/web/packages/design/src/SlideTabs/SlideTabs.tsx @@ -17,10 +17,13 @@ */ import React, { useEffect, useRef } from 'react'; -import styled from 'styled-components'; +import styled, { useTheme } from 'styled-components'; import { Flex, Indicator } from 'design'; import { IconProps } from 'design/Icon/Icon'; +import { HoverTooltip } from 'design/Tooltip'; +import { Position } from 'design/Popover/Popover'; +import { StatusIcon, StatusKind } from 'design/StatusIcon'; export function SlideTabs({ appearance = 'square', @@ -31,7 +34,9 @@ export function SlideTabs({ isProcessing = false, disabled = false, fitContent = false, + hideStatusIconOnActiveTab, }: SlideTabsProps) { + const theme = useTheme(); const activeTab = useRef(null); const tabContainer = useRef(null); @@ -75,7 +80,15 @@ export function SlideTabs({ icon: Icon, ariaLabel, controls, + tooltip: { + content: tooltipContent, + position: tooltipPosition, + } = {}, + status: { kind: statusKind, ariaLabel: statusAriaLabel } = {}, } = toFullTabSpec(tabSpec, tabIndex); + const statusIconColorActive = hideStatusIconOnActiveTab + ? 'transparent' + : theme.colors.text.primaryInverse; let onClick = undefined; if (!disabled && !isProcessing) { @@ -86,32 +99,45 @@ export function SlideTabs({ } return ( - - {/* We need a separate tab content component, since the spinner, - when displayed, shouldn't take up space to prevent layout - jumping. TabContent serves as a positioning anchor whose left - edge is the left edge of the content (not the tab button, - which can be much wider). */} - - {selected && isProcessing && } - {Icon && } - {title} - - + + {/* We need a separate tab content component, since the status + icon, when displayed, shouldn't take up space to prevent + layout jumping. TabContent serves as a positioning anchor + whose left edge is the left edge of the content (not the tab + button, which can be much wider). */} + + + + + {Icon && } + {title} + + + ); })} {/* The tab slider is positioned absolutely and appears below the @@ -169,6 +195,13 @@ export type SlideTabsProps = { * but instead wraps its contents. */ fitContent?: boolean; + /** + * Hides the status icon on active tab. Note that this is not the same as + * simply making some tab's `tabSpec.status` field set conditionally on + * whether that tab is active or not. Using this field provides a smooth + * animation for transitions between active and inactive state. + */ + hideStatusIconOnActiveTab?: boolean; }; /** @@ -179,7 +212,7 @@ export type SlideTabsProps = { * TODO(bl-nero): remove the string option once Enterprise is migrated to * simplify it a bit. */ -type TabSpec = string | FullTabSpec; +export type TabSpec = string | FullTabSpec; type FullTabSpec = TabContentSpec & { /** Iteration key for the tab. */ @@ -190,6 +223,19 @@ type FullTabSpec = TabContentSpec & { * attribute set to "tabpanel". */ controls?: string; + tooltip?: { + content: React.ReactNode; + position?: Position; + }; + /** + * An icon that will be displayed on the side. The layout will stay the same + * whether the icon is there or not. If `isProcessing` prop is set to `true`, + * the icon for an active tab is replaced by a spinner. + */ + status?: { + kind: StatusKind; + ariaLabel?: string; + }; }; /** @@ -220,6 +266,48 @@ function toFullTabSpec(spec: TabSpec, index: number): FullTabSpec { }; } +function StatusIconOrSpinner({ + showSpinner, + statusKind, + size, + color, + ariaLabel, +}: { + showSpinner: boolean; + statusKind: StatusKind | undefined; + size: Size; + color: string | undefined; + ariaLabel: string | undefined; +}) { + if (showSpinner) { + return ; + } + + // This is one of these rare cases when there is a difference between + // property being undefined and not present at all: undefined props would + // override the default ones, but we want it them to interfere at all. + const optionalProps: { color?: string; 'aria-label'?: string } = {}; + if (color !== undefined) { + optionalProps.color = color; + } + if (ariaLabel !== undefined) { + optionalProps['aria-label'] = ariaLabel; + } + + if (!statusKind) { + return null; + } + + return ( + + ); +} + const TabSliderInner = styled.div<{ appearance: Appearance }>` height: 100%; background-color: ${({ theme }) => theme.colors.brand}; @@ -343,6 +431,9 @@ const TabList = styled.div<{ itemCount: number }>` const Spinner = styled(Indicator)` color: ${p => p.theme.colors.levels.deep}; +`; + +const StatusIconContainer = styled.div` position: absolute; left: -${p => p.theme.space[5]}px; `; diff --git a/web/packages/design/src/StatusIcon/StatusIcon.story.tsx b/web/packages/design/src/StatusIcon/StatusIcon.story.tsx new file mode 100644 index 0000000000000..5c9897c6d3896 --- /dev/null +++ b/web/packages/design/src/StatusIcon/StatusIcon.story.tsx @@ -0,0 +1,44 @@ +/** + * 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 . + */ + +import { StoryObj } from '@storybook/react'; + +import Flex from 'design/Flex'; + +import { StatusIcon } from '.'; + +export default { + title: 'Design', +}; + +export const Story: StoryObj = { + name: 'StatusIcon', + render() { + return ( + + {(['neutral', 'danger', 'info', 'warning', 'success'] as const).map( + status => ( + + {status} + + ) + )} + + ); + }, +}; diff --git a/web/packages/design/src/StatusIcon/StatusIcon.tsx b/web/packages/design/src/StatusIcon/StatusIcon.tsx new file mode 100644 index 0000000000000..08fe46a020b22 --- /dev/null +++ b/web/packages/design/src/StatusIcon/StatusIcon.tsx @@ -0,0 +1,78 @@ +/** + * 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 . + */ + +import React from 'react'; + +import { useTheme } from 'styled-components'; + +import * as Icon from 'design/Icon'; +import { IconProps } from 'design/Icon/Icon'; + +export type StatusKind = 'neutral' | 'danger' | 'info' | 'warning' | 'success'; + +export const StatusIcon = ({ + kind, + customIcon: CustomIcon, + ...otherProps +}: { + kind: StatusKind; + customIcon?: React.ComponentType; +} & IconProps) => { + const commonProps = { role: 'graphics-symbol', ...otherProps }; + const theme = useTheme(); + + if (CustomIcon) { + return ; + } + switch (kind) { + case 'success': + return ( + + ); + case 'danger': + return ( + + ); + case 'info': + return ( + + ); + case 'warning': + return ( + + ); + case 'neutral': + return ; + } +}; diff --git a/web/packages/design/src/StatusIcon/index.ts b/web/packages/design/src/StatusIcon/index.ts new file mode 100644 index 0000000000000..7c674b723d6af --- /dev/null +++ b/web/packages/design/src/StatusIcon/index.ts @@ -0,0 +1,19 @@ +/** + * 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 . + */ + +export { StatusIcon, type StatusKind } from './StatusIcon'; From 9d22da74b80450cf6c5c64b58f11002dd42feb0d Mon Sep 17 00:00:00 2001 From: Noah Stride Date: Mon, 9 Dec 2024 12:50:08 +0100 Subject: [PATCH 11/16] Workload ID: Add Protos for WorkloadIdentity resource, CRUD and events (#49650) (#49926) * Add protos for resource and resource svc * Add field for encoding the created/updated workloadidentity in audit events * Remove redundant package qualifier * Add UpsertWorkloadIdentity * Appease linter * Add TrimToMaxSize implementation --- api/client/events.go | 8 + api/client/proto/event.pb.go | 696 +- .../workloadidentity/v1/resource.pb.go | 523 ++ .../v1/resource_service.pb.go | 580 ++ .../v1/resource_service_grpc.pb.go | 361 ++ .../teleport/legacy/client/proto/event.proto | 3 + .../teleport/legacy/types/events/events.proto | 108 + .../workloadidentity/v1/resource.proto | 85 + .../v1/resource_service.proto | 95 + api/types/constants.go | 3 + api/types/events/events.go | 42 + api/types/events/events.pb.go | 5572 ++++++++++------- api/types/events/oneof.go | 12 + lib/events/api.go | 7 + lib/events/codes.go | 7 + lib/events/dynamic.go | 8 + lib/events/events_test.go | 3 + 17 files changed, 5653 insertions(+), 2460 deletions(-) create mode 100644 api/gen/proto/go/teleport/workloadidentity/v1/resource.pb.go create mode 100644 api/gen/proto/go/teleport/workloadidentity/v1/resource_service.pb.go create mode 100644 api/gen/proto/go/teleport/workloadidentity/v1/resource_service_grpc.pb.go create mode 100644 api/proto/teleport/workloadidentity/v1/resource.proto create mode 100644 api/proto/teleport/workloadidentity/v1/resource_service.proto diff --git a/api/client/events.go b/api/client/events.go index 89e5b5ecc3157..c7d9d8c51d14b 100644 --- a/api/client/events.go +++ b/api/client/events.go @@ -30,6 +30,7 @@ import ( provisioningv1 "github.com/gravitational/teleport/api/gen/proto/go/teleport/provisioning/v1" userprovisioningpb "github.com/gravitational/teleport/api/gen/proto/go/teleport/userprovisioning/v2" usertasksv1 "github.com/gravitational/teleport/api/gen/proto/go/teleport/usertasks/v1" + workloadidentityv1pb "github.com/gravitational/teleport/api/gen/proto/go/teleport/workloadidentity/v1" "github.com/gravitational/teleport/api/types" "github.com/gravitational/teleport/api/types/accesslist" accesslistv1conv "github.com/gravitational/teleport/api/types/accesslist/convert/v1" @@ -135,6 +136,10 @@ func EventToGRPC(in types.Event) (*proto.Event, error) { out.Resource = &proto.Event_IdentityCenterAccountAssignment{ IdentityCenterAccountAssignment: r, } + case *workloadidentityv1pb.WorkloadIdentity: + out.Resource = &proto.Event_WorkloadIdentity{ + WorkloadIdentity: r, + } default: return nil, trace.BadParameter("resource type %T is not supported", r) } @@ -609,6 +614,9 @@ func EventFromGRPC(in *proto.Event) (*types.Event, error) { } else if r := in.GetIdentityCenterAccountAssignment(); r != nil { out.Resource = types.Resource153ToLegacy(r) return &out, nil + } else if r := in.GetWorkloadIdentity(); r != nil { + out.Resource = types.Resource153ToLegacy(r) + return &out, nil } else { return nil, trace.BadParameter("received unsupported resource %T", in.Resource) } diff --git a/api/client/proto/event.pb.go b/api/client/proto/event.pb.go index 8cb8416436e6f..e1a9b29a48355 100644 --- a/api/client/proto/event.pb.go +++ b/api/client/proto/event.pb.go @@ -37,6 +37,7 @@ import ( v11 "github.com/gravitational/teleport/api/gen/proto/go/teleport/userloginstate/v1" v2 "github.com/gravitational/teleport/api/gen/proto/go/teleport/userprovisioning/v2" v112 "github.com/gravitational/teleport/api/gen/proto/go/teleport/usertasks/v1" + v115 "github.com/gravitational/teleport/api/gen/proto/go/teleport/workloadidentity/v1" types "github.com/gravitational/teleport/api/types" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" @@ -186,6 +187,7 @@ type Event struct { // *Event_IdentityCenterAccount // *Event_IdentityCenterPrincipalAssignment // *Event_IdentityCenterAccountAssignment + // *Event_WorkloadIdentity Resource isEvent_Resource `protobuf_oneof:"Resource"` } @@ -716,6 +718,13 @@ func (x *Event) GetIdentityCenterAccountAssignment() *v114.AccountAssignment { return nil } +func (x *Event) GetWorkloadIdentity() *v115.WorkloadIdentity { + if x, ok := x.GetResource().(*Event_WorkloadIdentity); ok { + return x.WorkloadIdentity + } + return nil +} + type isEvent_Resource interface { isEvent_Resource() } @@ -1071,6 +1080,11 @@ type Event_IdentityCenterAccountAssignment struct { IdentityCenterAccountAssignment *v114.AccountAssignment `protobuf:"bytes,74,opt,name=IdentityCenterAccountAssignment,proto3,oneof"` } +type Event_WorkloadIdentity struct { + // WorkloadIdentity is a resource for workload identity. + WorkloadIdentity *v115.WorkloadIdentity `protobuf:"bytes,76,opt,name=WorkloadIdentity,proto3,oneof"` +} + func (*Event_ResourceHeader) isEvent_Resource() {} func (*Event_CertAuthority) isEvent_Resource() {} @@ -1209,6 +1223,8 @@ func (*Event_IdentityCenterPrincipalAssignment) isEvent_Resource() {} func (*Event_IdentityCenterAccountAssignment) isEvent_Resource() {} +func (*Event_WorkloadIdentity) isEvent_Resource() {} + var File_teleport_legacy_client_proto_event_proto protoreflect.FileDescriptor var file_teleport_legacy_client_proto_event_proto_rawDesc = []byte{ @@ -1267,338 +1283,347 @@ var file_teleport_legacy_client_proto_event_proto_rawDesc = []byte{ 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2f, 0x76, 0x31, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x22, 0xcf, 0x28, 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x04, 0x54, 0x79, - 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x3f, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x65, 0x61, 0x64, - 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, - 0x00, 0x52, 0x0e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x12, 0x3e, 0x0a, 0x0d, 0x43, 0x65, 0x72, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, - 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x2e, 0x43, 0x65, 0x72, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x56, 0x32, - 0x48, 0x00, 0x52, 0x0d, 0x43, 0x65, 0x72, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, - 0x79, 0x12, 0x3b, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, - 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x56, 0x32, 0x48, 0x00, - 0x52, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x41, - 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x50, - 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x32, 0x48, - 0x00, 0x52, 0x0e, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, - 0x6e, 0x12, 0x38, 0x0a, 0x0b, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, - 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0b, - 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x04, 0x55, - 0x73, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x79, 0x70, 0x65, - 0x73, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x56, 0x32, 0x48, 0x00, 0x52, 0x04, 0x55, 0x73, 0x65, 0x72, - 0x12, 0x23, 0x0a, 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x56, 0x36, 0x48, 0x00, 0x52, - 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x12, 0x30, 0x0a, 0x09, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, - 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x48, 0x00, 0x52, 0x09, 0x4e, 0x61, - 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x29, 0x0a, 0x06, 0x53, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, - 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x56, 0x32, 0x48, 0x00, 0x52, 0x06, 0x53, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x12, 0x3e, 0x0a, 0x0d, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x54, 0x75, 0x6e, - 0x6e, 0x65, 0x6c, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, - 0x73, 0x2e, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x56, - 0x32, 0x48, 0x00, 0x52, 0x0d, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x54, 0x75, 0x6e, 0x6e, - 0x65, 0x6c, 0x12, 0x47, 0x0a, 0x10, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x6e, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x74, - 0x79, 0x70, 0x65, 0x73, 0x2e, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, 0x10, 0x54, 0x75, 0x6e, 0x6e, 0x65, - 0x6c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0d, 0x41, - 0x63, 0x63, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x0e, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x41, 0x63, 0x63, 0x65, 0x73, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x33, 0x48, 0x00, 0x52, 0x0d, 0x41, 0x63, - 0x63, 0x65, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x0a, 0x41, - 0x70, 0x70, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x13, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, - 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0a, 0x41, 0x70, 0x70, 0x53, 0x65, 0x73, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0d, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6c, 0x75, 0x73, - 0x74, 0x65, 0x72, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, - 0x73, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x56, - 0x33, 0x48, 0x00, 0x52, 0x0d, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x12, 0x41, 0x0a, 0x0e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, 0x70, - 0x65, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x56, 0x33, 0x48, 0x00, 0x52, 0x0e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, - 0x69, 0x6f, 0x6e, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x79, 0x70, 0x65, - 0x73, 0x2e, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, - 0x52, 0x0a, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x08, - 0x57, 0x65, 0x62, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x65, 0x62, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, - 0x33, 0x48, 0x00, 0x52, 0x08, 0x57, 0x65, 0x62, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x5c, 0x0a, + 0x1a, 0x2b, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x76, 0x31, 0x2f, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xad, 0x29, + 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3f, 0x0a, + 0x0e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x00, 0x52, 0x0e, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x3e, + 0x0a, 0x0d, 0x43, 0x65, 0x72, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, 0x65, + 0x72, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x56, 0x32, 0x48, 0x00, 0x52, + 0x0d, 0x43, 0x65, 0x72, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x3b, + 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x69, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0c, 0x53, + 0x74, 0x61, 0x74, 0x69, 0x63, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x73, 0x12, 0x41, 0x0a, 0x0e, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x50, 0x72, 0x6f, 0x76, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0e, + 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x38, + 0x0a, 0x0b, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0b, 0x43, 0x6c, 0x75, + 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x04, 0x55, 0x73, 0x65, 0x72, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x55, + 0x73, 0x65, 0x72, 0x56, 0x32, 0x48, 0x00, 0x52, 0x04, 0x55, 0x73, 0x65, 0x72, 0x12, 0x23, 0x0a, + 0x04, 0x52, 0x6f, 0x6c, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x52, 0x6f, 0x6c, 0x65, 0x56, 0x36, 0x48, 0x00, 0x52, 0x04, 0x52, 0x6f, + 0x6c, 0x65, 0x12, 0x30, 0x0a, 0x09, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4e, 0x61, + 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x48, 0x00, 0x52, 0x09, 0x4e, 0x61, 0x6d, 0x65, 0x73, + 0x70, 0x61, 0x63, 0x65, 0x12, 0x29, 0x0a, 0x06, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x53, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x56, 0x32, 0x48, 0x00, 0x52, 0x06, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, + 0x3e, 0x0a, 0x0d, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x52, + 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x56, 0x32, 0x48, 0x00, + 0x52, 0x0d, 0x52, 0x65, 0x76, 0x65, 0x72, 0x73, 0x65, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x12, + 0x47, 0x0a, 0x10, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2e, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, 0x10, 0x54, 0x75, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0d, 0x41, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x56, 0x33, 0x48, 0x00, 0x52, 0x0d, 0x41, 0x63, 0x63, 0x65, 0x73, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x0a, 0x41, 0x70, 0x70, 0x53, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x56, + 0x32, 0x48, 0x00, 0x52, 0x0a, 0x41, 0x70, 0x70, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x3e, 0x0a, 0x0d, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x52, + 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x56, 0x33, 0x48, 0x00, + 0x52, 0x0d, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, + 0x41, 0x0a, 0x0e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, + 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x56, 0x33, + 0x48, 0x00, 0x52, 0x0e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, + 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0a, 0x57, + 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2f, 0x0a, 0x08, 0x57, 0x65, 0x62, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x57, 0x65, 0x62, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x56, 0x33, 0x48, 0x00, + 0x52, 0x08, 0x57, 0x65, 0x62, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x5c, 0x0a, 0x17, 0x43, 0x6c, + 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x65, 0x74, 0x77, 0x6f, + 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x56, 0x32, 0x48, 0x00, 0x52, 0x17, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x69, - 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x65, - 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x56, 0x32, - 0x48, 0x00, 0x52, 0x17, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x65, 0x74, 0x77, 0x6f, - 0x72, 0x6b, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x59, 0x0a, 0x16, 0x53, - 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x79, - 0x70, 0x65, 0x73, 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x6f, 0x72, - 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x56, 0x32, 0x48, 0x00, 0x52, 0x16, - 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, - 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x41, 0x0a, 0x0e, 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, - 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, 0x65, 0x66, 0x65, - 0x72, 0x65, 0x6e, 0x63, 0x65, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0e, 0x41, 0x75, 0x74, 0x68, 0x50, - 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x4d, 0x0a, 0x12, 0x43, 0x6c, 0x75, - 0x73, 0x74, 0x65, 0x72, 0x41, 0x75, 0x64, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, - 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x41, 0x75, 0x64, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x56, 0x32, 0x48, 0x00, 0x52, 0x12, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x41, 0x75, 0x64, - 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x23, 0x0a, 0x04, 0x4c, 0x6f, 0x63, 0x6b, - 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4c, - 0x6f, 0x63, 0x6b, 0x56, 0x32, 0x48, 0x00, 0x52, 0x04, 0x4c, 0x6f, 0x63, 0x6b, 0x12, 0x50, 0x0a, - 0x13, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x74, 0x79, 0x70, - 0x65, 0x73, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x56, 0x34, 0x48, 0x00, 0x52, 0x13, 0x4e, 0x65, 0x74, 0x77, - 0x6f, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, - 0x56, 0x0a, 0x15, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, - 0x70, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, - 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x56, 0x33, 0x48, 0x00, - 0x52, 0x15, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, - 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x41, 0x0a, 0x0e, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x17, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, - 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x56, 0x33, 0x48, 0x00, 0x52, 0x0e, 0x57, 0x69, 0x6e, 0x64, - 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x12, 0x2f, 0x0a, 0x08, 0x44, 0x61, - 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, - 0x79, 0x70, 0x65, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x56, 0x33, 0x48, - 0x00, 0x52, 0x08, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x09, 0x41, - 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x56, 0x33, 0x48, 0x00, 0x52, 0x09, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, - 0x20, 0x0a, 0x03, 0x41, 0x70, 0x70, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x74, - 0x79, 0x70, 0x65, 0x73, 0x2e, 0x41, 0x70, 0x70, 0x56, 0x33, 0x48, 0x00, 0x52, 0x03, 0x41, 0x70, - 0x70, 0x12, 0x41, 0x0a, 0x10, 0x53, 0x6e, 0x6f, 0x77, 0x66, 0x6c, 0x61, 0x6b, 0x65, 0x53, 0x65, - 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x79, - 0x70, 0x65, 0x73, 0x2e, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x56, 0x32, - 0x48, 0x00, 0x52, 0x10, 0x53, 0x6e, 0x6f, 0x77, 0x66, 0x6c, 0x61, 0x6b, 0x65, 0x53, 0x65, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x47, 0x0a, 0x10, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, - 0x65, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, - 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, - 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x56, 0x33, 0x48, 0x00, 0x52, 0x10, 0x4b, 0x75, 0x62, - 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x4a, 0x0a, - 0x11, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6c, 0x75, 0x73, 0x74, - 0x65, 0x72, 0x56, 0x33, 0x48, 0x00, 0x52, 0x11, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, - 0x65, 0x73, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x09, 0x49, 0x6e, 0x73, - 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, - 0x79, 0x70, 0x65, 0x73, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x56, 0x31, - 0x48, 0x00, 0x52, 0x09, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x44, 0x0a, + 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x59, 0x0a, 0x16, 0x53, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x66, + 0x69, 0x67, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x2e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, + 0x67, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x56, 0x32, 0x48, 0x00, 0x52, 0x16, 0x53, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x12, 0x41, 0x0a, 0x0e, 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, 0x65, 0x66, 0x65, + 0x72, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, + 0x63, 0x65, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0e, 0x41, 0x75, 0x74, 0x68, 0x50, 0x72, 0x65, 0x66, + 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x4d, 0x0a, 0x12, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, + 0x72, 0x41, 0x75, 0x64, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x17, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x41, 0x75, 0x64, 0x69, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x56, 0x32, 0x48, + 0x00, 0x52, 0x12, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x41, 0x75, 0x64, 0x69, 0x74, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x23, 0x0a, 0x04, 0x4c, 0x6f, 0x63, 0x6b, 0x18, 0x18, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4c, 0x6f, 0x63, 0x6b, + 0x56, 0x32, 0x48, 0x00, 0x52, 0x04, 0x4c, 0x6f, 0x63, 0x6b, 0x12, 0x50, 0x0a, 0x13, 0x4e, 0x65, + 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, + 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x56, 0x34, 0x48, 0x00, 0x52, 0x13, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, + 0x52, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x56, 0x0a, 0x15, + 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x53, 0x65, + 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, + 0x6f, 0x70, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x56, 0x33, 0x48, 0x00, 0x52, 0x15, 0x57, + 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x53, 0x65, 0x72, + 0x76, 0x69, 0x63, 0x65, 0x12, 0x41, 0x0a, 0x0e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, + 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, + 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, + 0x74, 0x6f, 0x70, 0x56, 0x33, 0x48, 0x00, 0x52, 0x0e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, + 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x12, 0x2f, 0x0a, 0x08, 0x44, 0x61, 0x74, 0x61, 0x62, + 0x61, 0x73, 0x65, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x56, 0x33, 0x48, 0x00, 0x52, 0x08, + 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x09, 0x41, 0x70, 0x70, 0x53, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x56, 0x33, 0x48, + 0x00, 0x52, 0x09, 0x41, 0x70, 0x70, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x20, 0x0a, 0x03, + 0x41, 0x70, 0x70, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2e, 0x41, 0x70, 0x70, 0x56, 0x33, 0x48, 0x00, 0x52, 0x03, 0x41, 0x70, 0x70, 0x12, 0x41, + 0x0a, 0x10, 0x53, 0x6e, 0x6f, 0x77, 0x66, 0x6c, 0x61, 0x6b, 0x65, 0x53, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, + 0x2e, 0x57, 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, + 0x10, 0x53, 0x6e, 0x6f, 0x77, 0x66, 0x6c, 0x61, 0x6b, 0x65, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x47, 0x0a, 0x10, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x53, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x74, 0x79, + 0x70, 0x65, 0x73, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x53, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x56, 0x33, 0x48, 0x00, 0x52, 0x10, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, + 0x65, 0x74, 0x65, 0x73, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x4a, 0x0a, 0x11, 0x4b, 0x75, + 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x18, + 0x21, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4b, 0x75, + 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x56, + 0x33, 0x48, 0x00, 0x52, 0x11, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x43, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x09, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6c, + 0x6c, 0x65, 0x72, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2e, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x56, 0x31, 0x48, 0x00, 0x52, + 0x09, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x12, 0x44, 0x0a, 0x0f, 0x44, 0x61, + 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x23, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x61, + 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x56, 0x31, 0x48, 0x00, 0x52, 0x0f, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x18, 0x23, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x44, - 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x56, 0x31, - 0x48, 0x00, 0x52, 0x0f, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x53, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x12, 0x59, 0x0a, 0x16, 0x53, 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x18, 0x24, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x53, 0x41, 0x4d, 0x4c, - 0x49, 0x64, 0x50, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, - 0x65, 0x72, 0x56, 0x31, 0x48, 0x00, 0x52, 0x16, 0x53, 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, 0x53, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x3d, - 0x0a, 0x0e, 0x53, 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, - 0x18, 0x25, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, - 0x65, 0x62, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0e, 0x53, - 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, - 0x09, 0x55, 0x73, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x26, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x12, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x56, 0x31, 0x48, 0x00, 0x52, 0x09, 0x55, 0x73, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x12, 0x2f, 0x0a, 0x08, 0x55, 0x49, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x27, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x55, 0x49, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x56, 0x31, 0x48, 0x00, 0x52, 0x08, 0x55, 0x49, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x12, 0x41, 0x0a, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, - 0x52, 0x75, 0x6c, 0x65, 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, 0x70, - 0x65, 0x73, 0x2e, 0x4f, 0x6b, 0x74, 0x61, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6c, - 0x65, 0x56, 0x31, 0x48, 0x00, 0x52, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x49, 0x6d, 0x70, 0x6f, 0x72, - 0x74, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x41, 0x0a, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x41, 0x73, 0x73, - 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x29, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, - 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x4f, 0x6b, 0x74, 0x61, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, - 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x31, 0x48, 0x00, 0x52, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x41, 0x73, - 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x0b, 0x49, 0x6e, 0x74, 0x65, - 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, - 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x56, 0x31, 0x48, 0x00, 0x52, 0x0b, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x0b, 0x57, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x18, 0x2b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, - 0x57, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x56, 0x31, 0x48, 0x00, 0x52, - 0x0b, 0x57, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x57, 0x0a, 0x16, - 0x48, 0x65, 0x61, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x74, - 0x79, 0x70, 0x65, 0x73, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x41, 0x75, 0x74, - 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x16, 0x48, - 0x65, 0x61, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, - 0x69, 0x73, 0x74, 0x18, 0x2d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x65, 0x6c, 0x65, + 0x12, 0x59, 0x0a, 0x16, 0x53, 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, 0x53, 0x65, 0x72, 0x76, 0x69, + 0x63, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x18, 0x24, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x53, 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x56, + 0x31, 0x48, 0x00, 0x52, 0x16, 0x53, 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x12, 0x3d, 0x0a, 0x0e, 0x53, + 0x41, 0x4d, 0x4c, 0x49, 0x64, 0x50, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x25, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x65, 0x62, 0x53, + 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x56, 0x32, 0x48, 0x00, 0x52, 0x0e, 0x53, 0x41, 0x4d, 0x4c, + 0x49, 0x64, 0x50, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x09, 0x55, 0x73, + 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x26, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x56, + 0x31, 0x48, 0x00, 0x52, 0x09, 0x55, 0x73, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2f, + 0x0a, 0x08, 0x55, 0x49, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x27, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x11, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x55, 0x49, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x56, 0x31, 0x48, 0x00, 0x52, 0x08, 0x55, 0x49, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, + 0x41, 0x0a, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6c, + 0x65, 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, + 0x4f, 0x6b, 0x74, 0x61, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x75, 0x6c, 0x65, 0x56, 0x31, + 0x48, 0x00, 0x52, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x52, 0x75, + 0x6c, 0x65, 0x12, 0x41, 0x0a, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, + 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x29, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2e, 0x4f, 0x6b, 0x74, 0x61, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, + 0x74, 0x56, 0x31, 0x48, 0x00, 0x52, 0x0e, 0x4f, 0x6b, 0x74, 0x61, 0x41, 0x73, 0x73, 0x69, 0x67, + 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x0b, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x2a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x31, + 0x48, 0x00, 0x52, 0x0b, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x38, 0x0a, 0x0b, 0x57, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x2b, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x57, 0x61, 0x74, + 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x56, 0x31, 0x48, 0x00, 0x52, 0x0b, 0x57, 0x61, + 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x57, 0x0a, 0x16, 0x48, 0x65, 0x61, + 0x64, 0x6c, 0x65, 0x73, 0x73, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x2c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x74, 0x79, 0x70, 0x65, + 0x73, 0x2e, 0x48, 0x65, 0x61, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, + 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x16, 0x48, 0x65, 0x61, 0x64, + 0x6c, 0x65, 0x73, 0x73, 0x41, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, + 0x18, 0x2d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x2e, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, + 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0a, 0x41, 0x63, + 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x54, 0x0a, 0x0e, 0x55, 0x73, 0x65, 0x72, + 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x18, 0x2e, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2a, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x73, + 0x65, 0x72, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0e, + 0x55, 0x73, 0x65, 0x72, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x4c, + 0x0a, 0x10, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, + 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x76, + 0x31, 0x2e, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x48, 0x00, 0x52, 0x10, 0x41, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x58, 0x0a, 0x0f, + 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, + 0x30, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, + 0x2e, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x0f, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x41, 0x75, 0x64, 0x69, 0x74, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x65, 0x6c, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x73, + 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x64, 0x69, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x48, 0x00, + 0x52, 0x0a, 0x41, 0x75, 0x64, 0x69, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x38, 0x0a, 0x06, + 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x33, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, + 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x48, 0x00, 0x52, 0x06, + 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x47, 0x0a, 0x0b, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x18, 0x34, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x65, + 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, + 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x48, 0x00, 0x52, 0x0b, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x4c, 0x0a, 0x10, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x76, + 0x69, 0x65, 0x77, 0x18, 0x35, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6c, 0x69, 0x73, 0x74, 0x2e, - 0x76, 0x31, 0x2e, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x48, 0x00, 0x52, - 0x0a, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x54, 0x0a, 0x0e, 0x55, - 0x73, 0x65, 0x72, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x18, 0x2e, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x75, - 0x73, 0x65, 0x72, 0x6c, 0x6f, 0x67, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2e, 0x76, 0x31, - 0x2e, 0x55, 0x73, 0x65, 0x72, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, - 0x00, 0x52, 0x0e, 0x55, 0x73, 0x65, 0x72, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x12, 0x4c, 0x0a, 0x10, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x4d, - 0x65, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, 0x65, - 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6c, 0x69, 0x73, - 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x48, 0x00, 0x52, 0x10, 0x41, - 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x12, - 0x58, 0x0a, 0x0f, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x18, 0x30, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, - 0x6f, 0x72, 0x74, 0x2e, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, - 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x0f, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, - 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x44, 0x0a, 0x0a, 0x41, 0x75, 0x64, - 0x69, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, - 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x70, 0x6f, - 0x72, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x64, 0x69, 0x74, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x48, 0x00, 0x52, 0x0a, 0x41, 0x75, 0x64, 0x69, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, - 0x38, 0x0a, 0x06, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x33, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, - 0x70, 0x6f, 0x72, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x48, - 0x00, 0x52, 0x06, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x47, 0x0a, 0x0b, 0x52, 0x65, 0x70, - 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x18, 0x34, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, - 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x73, 0x65, 0x63, 0x72, 0x65, 0x70, - 0x6f, 0x72, 0x74, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x53, 0x74, - 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x12, 0x4c, 0x0a, 0x10, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, - 0x52, 0x65, 0x76, 0x69, 0x65, 0x77, 0x18, 0x35, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, - 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6c, 0x69, - 0x73, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x76, 0x69, 0x65, 0x77, 0x48, 0x00, 0x52, 0x10, - 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x76, 0x69, 0x65, 0x77, - 0x12, 0x6d, 0x0a, 0x14, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, - 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x18, 0x36, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, - 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, - 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x2e, - 0x76, 0x31, 0x2e, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, - 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x48, 0x00, 0x52, 0x14, 0x41, 0x63, 0x63, 0x65, 0x73, - 0x73, 0x4d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x12, - 0x7e, 0x0a, 0x1a, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x57, 0x61, 0x69, - 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x37, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6b, - 0x75, 0x62, 0x65, 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, - 0x6e, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, - 0x73, 0x57, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, - 0x72, 0x48, 0x00, 0x52, 0x1a, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x57, - 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, - 0x55, 0x0a, 0x10, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x38, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x74, 0x65, 0x6c, 0x65, - 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5f, 0x0a, 0x12, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, - 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x39, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6e, 0x6f, - 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, - 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x48, 0x00, 0x52, 0x12, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4e, 0x6f, 0x74, 0x69, 0x66, - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x0a, 0x43, 0x72, 0x6f, 0x77, 0x6e, - 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x18, 0x3a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x65, - 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x63, 0x72, 0x6f, 0x77, 0x6e, 0x6a, 0x65, 0x77, 0x65, - 0x6c, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x6f, 0x77, 0x6e, 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x48, - 0x00, 0x52, 0x0a, 0x43, 0x72, 0x6f, 0x77, 0x6e, 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x12, 0x4e, 0x0a, - 0x0e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, - 0x3b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, - 0x2e, 0x64, 0x62, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, - 0x61, 0x62, 0x61, 0x73, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x00, 0x52, 0x0e, 0x44, - 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x46, 0x0a, - 0x0b, 0x42, 0x6f, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x3c, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6d, 0x61, - 0x63, 0x68, 0x69, 0x6e, 0x65, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x74, 0x49, 0x6e, - 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x42, 0x6f, 0x74, 0x49, 0x6e, 0x73, - 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x62, 0x0a, 0x13, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x47, - 0x72, 0x61, 0x70, 0x68, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x3d, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x63, 0x6c, - 0x75, 0x73, 0x74, 0x65, 0x72, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x41, - 0x63, 0x63, 0x65, 0x73, 0x73, 0x47, 0x72, 0x61, 0x70, 0x68, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, - 0x67, 0x73, 0x48, 0x00, 0x52, 0x13, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x47, 0x72, 0x61, 0x70, - 0x68, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x55, 0x0a, 0x10, 0x53, 0x50, 0x49, - 0x46, 0x46, 0x45, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x3e, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6d, - 0x61, 0x63, 0x68, 0x69, 0x6e, 0x65, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x50, 0x49, 0x46, - 0x46, 0x45, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x10, - 0x53, 0x50, 0x49, 0x46, 0x46, 0x45, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x56, 0x0a, 0x10, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x18, 0x40, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x74, 0x65, 0x6c, - 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x48, 0x00, 0x52, 0x10, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x59, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x6f, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x41, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, - 0x75, 0x74, 0x6f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x74, - 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x00, - 0x52, 0x11, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x12, 0x5a, 0x0a, 0x10, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x48, 0x6f, 0x73, - 0x74, 0x55, 0x73, 0x65, 0x72, 0x56, 0x32, 0x18, 0x42, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, - 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x70, 0x72, 0x6f, - 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x74, 0x61, - 0x74, 0x69, 0x63, 0x48, 0x6f, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x48, 0x00, 0x52, 0x10, 0x53, - 0x74, 0x61, 0x74, 0x69, 0x63, 0x48, 0x6f, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x56, 0x32, 0x12, - 0x3d, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x54, 0x61, 0x73, 0x6b, 0x18, 0x43, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x75, 0x73, 0x65, - 0x72, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x54, 0x61, - 0x73, 0x6b, 0x48, 0x00, 0x52, 0x08, 0x55, 0x73, 0x65, 0x72, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x56, - 0x0a, 0x15, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, - 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x18, 0x45, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, - 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x56, 0x31, 0x48, 0x00, 0x52, - 0x15, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, - 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x12, 0x6a, 0x0a, 0x1a, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, - 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x18, 0x46, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x74, 0x65, 0x6c, - 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x69, - 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x1a, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, - 0x6e, 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x12, 0x68, 0x0a, 0x16, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x41, 0x67, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0x18, 0x47, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x75, - 0x74, 0x6f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x74, 0x6f, - 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x6f, - 0x75, 0x74, 0x48, 0x00, 0x52, 0x16, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x41, 0x67, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0x12, 0x5b, 0x0a, 0x15, - 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, - 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x48, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x65, - 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x63, - 0x65, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, - 0x48, 0x00, 0x52, 0x15, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, - 0x65, 0x72, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x7f, 0x0a, 0x21, 0x49, 0x64, 0x65, - 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x50, 0x72, 0x69, 0x6e, 0x63, - 0x69, 0x70, 0x61, 0x6c, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x49, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, - 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x41, 0x73, 0x73, 0x69, 0x67, - 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x21, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, - 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, - 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x79, 0x0a, 0x1f, 0x49, 0x64, - 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x63, 0x6f, - 0x75, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x4a, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, - 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, - 0x6e, 0x74, 0x48, 0x00, 0x52, 0x1f, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, - 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x69, 0x67, - 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x42, 0x0a, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x4a, 0x04, 0x08, 0x07, 0x10, 0x08, 0x4a, 0x04, 0x08, 0x31, 0x10, 0x32, 0x4a, 0x04, 0x08, - 0x3f, 0x10, 0x40, 0x4a, 0x04, 0x08, 0x44, 0x10, 0x45, 0x52, 0x12, 0x45, 0x78, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x43, 0x6c, 0x6f, 0x75, 0x64, 0x41, 0x75, 0x64, 0x69, 0x74, 0x52, 0x0e, 0x53, - 0x74, 0x61, 0x74, 0x69, 0x63, 0x48, 0x6f, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x13, 0x41, - 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x50, 0x6c, - 0x61, 0x6e, 0x2a, 0x2a, 0x0a, 0x09, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x08, 0x0a, 0x04, 0x49, 0x4e, 0x49, 0x54, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x50, 0x55, 0x54, - 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x02, 0x42, 0x34, - 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, 0x61, - 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x6c, 0x65, 0x70, - 0x6f, 0x72, 0x74, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x76, 0x31, 0x2e, 0x52, 0x65, 0x76, 0x69, 0x65, 0x77, 0x48, 0x00, 0x52, 0x10, 0x41, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x76, 0x69, 0x65, 0x77, 0x12, 0x6d, 0x0a, + 0x14, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x6e, + 0x67, 0x52, 0x75, 0x6c, 0x65, 0x18, 0x36, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x74, 0x65, + 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6d, 0x6f, 0x6e, + 0x69, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x2e, 0x76, 0x31, 0x2e, + 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x67, + 0x52, 0x75, 0x6c, 0x65, 0x48, 0x00, 0x52, 0x14, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4d, 0x6f, + 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x7e, 0x0a, 0x1a, + 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x57, 0x61, 0x69, 0x74, 0x69, 0x6e, + 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x18, 0x37, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x3c, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6b, 0x75, 0x62, 0x65, + 0x77, 0x61, 0x69, 0x74, 0x69, 0x6e, 0x67, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x57, 0x61, + 0x69, 0x74, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x48, 0x00, + 0x52, 0x1a, 0x4b, 0x75, 0x62, 0x65, 0x72, 0x6e, 0x65, 0x74, 0x65, 0x73, 0x57, 0x61, 0x69, 0x74, + 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x55, 0x0a, 0x10, + 0x55, 0x73, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x38, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x2e, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x76, 0x31, 0x2e, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x00, 0x52, 0x10, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x5f, 0x0a, 0x12, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4e, 0x6f, 0x74, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x39, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2d, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6e, 0x6f, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x6c, 0x6f, 0x62, + 0x61, 0x6c, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, + 0x52, 0x12, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x44, 0x0a, 0x0a, 0x43, 0x72, 0x6f, 0x77, 0x6e, 0x4a, 0x65, 0x77, + 0x65, 0x6c, 0x18, 0x3a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, + 0x6f, 0x72, 0x74, 0x2e, 0x63, 0x72, 0x6f, 0x77, 0x6e, 0x6a, 0x65, 0x77, 0x65, 0x6c, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x72, 0x6f, 0x77, 0x6e, 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x48, 0x00, 0x52, 0x0a, + 0x43, 0x72, 0x6f, 0x77, 0x6e, 0x4a, 0x65, 0x77, 0x65, 0x6c, 0x12, 0x4e, 0x0a, 0x0e, 0x44, 0x61, + 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x3b, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x64, 0x62, + 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x62, 0x61, + 0x73, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x48, 0x00, 0x52, 0x0e, 0x44, 0x61, 0x74, 0x61, + 0x62, 0x61, 0x73, 0x65, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x46, 0x0a, 0x0b, 0x42, 0x6f, + 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x3c, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6d, 0x61, 0x63, 0x68, 0x69, + 0x6e, 0x65, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, + 0x6e, 0x63, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x42, 0x6f, 0x74, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, + 0x63, 0x65, 0x12, 0x62, 0x0a, 0x13, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x47, 0x72, 0x61, 0x70, + 0x68, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x18, 0x3d, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x63, 0x65, + 0x73, 0x73, 0x47, 0x72, 0x61, 0x70, 0x68, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x48, + 0x00, 0x52, 0x13, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x47, 0x72, 0x61, 0x70, 0x68, 0x53, 0x65, + 0x74, 0x74, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x55, 0x0a, 0x10, 0x53, 0x50, 0x49, 0x46, 0x46, 0x45, + 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x3e, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x27, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x6d, 0x61, 0x63, 0x68, + 0x69, 0x6e, 0x65, 0x69, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x50, 0x49, 0x46, 0x46, 0x45, 0x46, + 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x53, 0x50, 0x49, + 0x46, 0x46, 0x45, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x56, 0x0a, + 0x10, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x18, 0x40, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x76, 0x31, + 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x48, 0x00, 0x52, 0x10, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x59, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x41, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x29, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x75, 0x74, 0x6f, + 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x11, 0x41, + 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x5a, 0x0a, 0x10, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, 0x48, 0x6f, 0x73, 0x74, 0x55, 0x73, + 0x65, 0x72, 0x56, 0x32, 0x18, 0x42, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x74, 0x65, 0x6c, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x32, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, + 0x48, 0x6f, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x48, 0x00, 0x52, 0x10, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x63, 0x48, 0x6f, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x56, 0x32, 0x12, 0x3d, 0x0a, 0x08, + 0x55, 0x73, 0x65, 0x72, 0x54, 0x61, 0x73, 0x6b, 0x18, 0x43, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x74, 0x61, + 0x73, 0x6b, 0x73, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x54, 0x61, 0x73, 0x6b, 0x48, + 0x00, 0x52, 0x08, 0x55, 0x73, 0x65, 0x72, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x56, 0x0a, 0x15, 0x44, + 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, + 0x6b, 0x74, 0x6f, 0x70, 0x18, 0x45, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x74, 0x79, 0x70, + 0x65, 0x73, 0x2e, 0x44, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x73, 0x44, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x56, 0x31, 0x48, 0x00, 0x52, 0x15, 0x44, 0x79, + 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x73, 0x6b, + 0x74, 0x6f, 0x70, 0x12, 0x6a, 0x0a, 0x1a, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x69, 0x6e, 0x67, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x18, 0x46, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x2e, + 0x76, 0x31, 0x2e, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x48, 0x00, 0x52, 0x1a, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, + 0x67, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, + 0x68, 0x0a, 0x16, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x67, 0x65, + 0x6e, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0x18, 0x47, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x61, 0x75, 0x74, 0x6f, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0x48, + 0x00, 0x52, 0x16, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x41, 0x67, 0x65, + 0x6e, 0x74, 0x52, 0x6f, 0x6c, 0x6c, 0x6f, 0x75, 0x74, 0x12, 0x5b, 0x0a, 0x15, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x48, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, + 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x63, 0x65, 0x6e, 0x74, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x48, 0x00, 0x52, + 0x15, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x41, + 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x7f, 0x0a, 0x21, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, + 0x6c, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x49, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2f, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, + 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x48, 0x00, 0x52, 0x21, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, + 0x6e, 0x74, 0x65, 0x72, 0x50, 0x72, 0x69, 0x6e, 0x63, 0x69, 0x70, 0x61, 0x6c, 0x41, 0x73, 0x73, + 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x79, 0x0a, 0x1f, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x4a, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2d, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x69, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x48, + 0x00, 0x52, 0x1f, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x65, 0x6e, 0x74, 0x65, + 0x72, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x6d, 0x65, + 0x6e, 0x74, 0x12, 0x5c, 0x0a, 0x10, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x4c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, + 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x48, 0x00, 0x52, 0x10, + 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x42, 0x0a, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4a, 0x04, 0x08, 0x07, + 0x10, 0x08, 0x4a, 0x04, 0x08, 0x31, 0x10, 0x32, 0x4a, 0x04, 0x08, 0x3f, 0x10, 0x40, 0x4a, 0x04, + 0x08, 0x44, 0x10, 0x45, 0x52, 0x12, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x43, 0x6c, + 0x6f, 0x75, 0x64, 0x41, 0x75, 0x64, 0x69, 0x74, 0x52, 0x0e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, + 0x48, 0x6f, 0x73, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x13, 0x41, 0x75, 0x74, 0x6f, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x50, 0x6c, 0x61, 0x6e, 0x2a, 0x2a, 0x0a, + 0x09, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x4e, + 0x49, 0x54, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x50, 0x55, 0x54, 0x10, 0x01, 0x12, 0x0a, 0x0a, + 0x06, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x02, 0x42, 0x34, 0x5a, 0x32, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, 0x61, 0x76, 0x69, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -1684,6 +1709,7 @@ var file_teleport_legacy_client_proto_event_proto_goTypes = []any{ (*v114.Account)(nil), // 65: teleport.identitycenter.v1.Account (*v114.PrincipalAssignment)(nil), // 66: teleport.identitycenter.v1.PrincipalAssignment (*v114.AccountAssignment)(nil), // 67: teleport.identitycenter.v1.AccountAssignment + (*v115.WorkloadIdentity)(nil), // 68: teleport.workloadidentity.v1.WorkloadIdentity } var file_teleport_legacy_client_proto_event_proto_depIdxs = []int32{ 0, // 0: proto.Event.Type:type_name -> proto.Operation @@ -1756,11 +1782,12 @@ var file_teleport_legacy_client_proto_event_proto_depIdxs = []int32{ 65, // 67: proto.Event.IdentityCenterAccount:type_name -> teleport.identitycenter.v1.Account 66, // 68: proto.Event.IdentityCenterPrincipalAssignment:type_name -> teleport.identitycenter.v1.PrincipalAssignment 67, // 69: proto.Event.IdentityCenterAccountAssignment:type_name -> teleport.identitycenter.v1.AccountAssignment - 70, // [70:70] is the sub-list for method output_type - 70, // [70:70] is the sub-list for method input_type - 70, // [70:70] is the sub-list for extension type_name - 70, // [70:70] is the sub-list for extension extendee - 0, // [0:70] is the sub-list for field type_name + 68, // 70: proto.Event.WorkloadIdentity:type_name -> teleport.workloadidentity.v1.WorkloadIdentity + 71, // [71:71] is the sub-list for method output_type + 71, // [71:71] is the sub-list for method input_type + 71, // [71:71] is the sub-list for extension type_name + 71, // [71:71] is the sub-list for extension extendee + 0, // [0:71] is the sub-list for field type_name } func init() { file_teleport_legacy_client_proto_event_proto_init() } @@ -1838,6 +1865,7 @@ func file_teleport_legacy_client_proto_event_proto_init() { (*Event_IdentityCenterAccount)(nil), (*Event_IdentityCenterPrincipalAssignment)(nil), (*Event_IdentityCenterAccountAssignment)(nil), + (*Event_WorkloadIdentity)(nil), } type x struct{} out := protoimpl.TypeBuilder{ diff --git a/api/gen/proto/go/teleport/workloadidentity/v1/resource.pb.go b/api/gen/proto/go/teleport/workloadidentity/v1/resource.pb.go new file mode 100644 index 0000000000000..684bfe1f98bb4 --- /dev/null +++ b/api/gen/proto/go/teleport/workloadidentity/v1/resource.pb.go @@ -0,0 +1,523 @@ +// 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. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.35.1 +// protoc (unknown) +// source: teleport/workloadidentity/v1/resource.proto + +package workloadidentityv1pb + +import ( + v1 "github.com/gravitational/teleport/api/gen/proto/go/teleport/header/v1" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// WorkloadIdentity represents a single, or group of similar, workload +// identities and configures the structure of workload identity credentials and +// authorization rules. is a resource that represents the configuration of a trust +// domain federation. +type WorkloadIdentity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The kind of resource represented. + Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"` + // Differentiates variations of the same kind. All resources should + // contain one, even if it is never populated. + SubKind string `protobuf:"bytes,2,opt,name=sub_kind,json=subKind,proto3" json:"sub_kind,omitempty"` + // The version of the resource being represented. + Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"` + // Common metadata that all resources share. + Metadata *v1.Metadata `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"` + // The configured properties of the WorkloadIdentity + Spec *WorkloadIdentitySpec `protobuf:"bytes,5,opt,name=spec,proto3" json:"spec,omitempty"` +} + +func (x *WorkloadIdentity) Reset() { + *x = WorkloadIdentity{} + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorkloadIdentity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkloadIdentity) ProtoMessage() {} + +func (x *WorkloadIdentity) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkloadIdentity.ProtoReflect.Descriptor instead. +func (*WorkloadIdentity) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_proto_rawDescGZIP(), []int{0} +} + +func (x *WorkloadIdentity) GetKind() string { + if x != nil { + return x.Kind + } + return "" +} + +func (x *WorkloadIdentity) GetSubKind() string { + if x != nil { + return x.SubKind + } + return "" +} + +func (x *WorkloadIdentity) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *WorkloadIdentity) GetMetadata() *v1.Metadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *WorkloadIdentity) GetSpec() *WorkloadIdentitySpec { + if x != nil { + return x.Spec + } + return nil +} + +// The individual conditions that make up a rule. +type WorkloadIdentityCondition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the attribute to evaluate the condition against. + Attribute string `protobuf:"bytes,1,opt,name=attribute,proto3" json:"attribute,omitempty"` + // An exact string that the attribute must match. + Equals string `protobuf:"bytes,2,opt,name=equals,proto3" json:"equals,omitempty"` +} + +func (x *WorkloadIdentityCondition) Reset() { + *x = WorkloadIdentityCondition{} + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorkloadIdentityCondition) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkloadIdentityCondition) ProtoMessage() {} + +func (x *WorkloadIdentityCondition) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkloadIdentityCondition.ProtoReflect.Descriptor instead. +func (*WorkloadIdentityCondition) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_proto_rawDescGZIP(), []int{1} +} + +func (x *WorkloadIdentityCondition) GetAttribute() string { + if x != nil { + return x.Attribute + } + return "" +} + +func (x *WorkloadIdentityCondition) GetEquals() string { + if x != nil { + return x.Equals + } + return "" +} + +// An individual rule that is evaluated during the issuance of a WorkloadIdentity. +type WorkloadIdentityRule struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The conditions that must be met for this rule to be considered passed. + Conditions []*WorkloadIdentityCondition `protobuf:"bytes,1,rep,name=conditions,proto3" json:"conditions,omitempty"` +} + +func (x *WorkloadIdentityRule) Reset() { + *x = WorkloadIdentityRule{} + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorkloadIdentityRule) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkloadIdentityRule) ProtoMessage() {} + +func (x *WorkloadIdentityRule) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkloadIdentityRule.ProtoReflect.Descriptor instead. +func (*WorkloadIdentityRule) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_proto_rawDescGZIP(), []int{2} +} + +func (x *WorkloadIdentityRule) GetConditions() []*WorkloadIdentityCondition { + if x != nil { + return x.Conditions + } + return nil +} + +// The rules which are evaluated before the WorkloadIdentity can be issued. +type WorkloadIdentityRules struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A list of rules used to determine if a WorkloadIdentity can be issued. + // If none are provided, it will be considered a pass. If any are provided, + // then at least one must pass for the rules to be considered passed. + Allow []*WorkloadIdentityRule `protobuf:"bytes,1,rep,name=allow,proto3" json:"allow,omitempty"` +} + +func (x *WorkloadIdentityRules) Reset() { + *x = WorkloadIdentityRules{} + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorkloadIdentityRules) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkloadIdentityRules) ProtoMessage() {} + +func (x *WorkloadIdentityRules) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkloadIdentityRules.ProtoReflect.Descriptor instead. +func (*WorkloadIdentityRules) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_proto_rawDescGZIP(), []int{3} +} + +func (x *WorkloadIdentityRules) GetAllow() []*WorkloadIdentityRule { + if x != nil { + return x.Allow + } + return nil +} + +// Configuration pertaining to the issuance of SPIFFE-compatible workload +// identity credentials. +type WorkloadIdentitySPIFFE struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The path of the SPIFFE ID that will be issued to the workload. + // + // This should be prefixed with a forward-slash ("/"). + // + // This field supports templating using attributes. + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // A freeform text field which is provided to workloads along with a + // credential produced by this WorkloadIdentity. This can be used to provide + // additional context that can be used to select between multiple credentials. + Hint string `protobuf:"bytes,2,opt,name=hint,proto3" json:"hint,omitempty"` +} + +func (x *WorkloadIdentitySPIFFE) Reset() { + *x = WorkloadIdentitySPIFFE{} + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorkloadIdentitySPIFFE) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkloadIdentitySPIFFE) ProtoMessage() {} + +func (x *WorkloadIdentitySPIFFE) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkloadIdentitySPIFFE.ProtoReflect.Descriptor instead. +func (*WorkloadIdentitySPIFFE) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_proto_rawDescGZIP(), []int{4} +} + +func (x *WorkloadIdentitySPIFFE) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *WorkloadIdentitySPIFFE) GetHint() string { + if x != nil { + return x.Hint + } + return "" +} + +// The spec for the WorkloadIdentity resource. +type WorkloadIdentitySpec struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The rules which are evaluated before the WorkloadIdentity can be issued. + Rules *WorkloadIdentityRules `protobuf:"bytes,1,opt,name=rules,proto3" json:"rules,omitempty"` + // Configuration pertaining to the issuance of SPIFFE-compatible workload + // identity credentials. + Spiffe *WorkloadIdentitySPIFFE `protobuf:"bytes,2,opt,name=spiffe,proto3" json:"spiffe,omitempty"` +} + +func (x *WorkloadIdentitySpec) Reset() { + *x = WorkloadIdentitySpec{} + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorkloadIdentitySpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorkloadIdentitySpec) ProtoMessage() {} + +func (x *WorkloadIdentitySpec) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorkloadIdentitySpec.ProtoReflect.Descriptor instead. +func (*WorkloadIdentitySpec) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_proto_rawDescGZIP(), []int{5} +} + +func (x *WorkloadIdentitySpec) GetRules() *WorkloadIdentityRules { + if x != nil { + return x.Rules + } + return nil +} + +func (x *WorkloadIdentitySpec) GetSpiffe() *WorkloadIdentitySPIFFE { + if x != nil { + return x.Spiffe + } + return nil +} + +var File_teleport_workloadidentity_v1_resource_proto protoreflect.FileDescriptor + +var file_teleport_workloadidentity_v1_resource_proto_rawDesc = []byte{ + 0x0a, 0x2b, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x76, 0x31, 0x2f, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1c, 0x74, + 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, + 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x1a, 0x21, 0x74, 0x65, 0x6c, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x2f, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdd, + 0x01, 0x0a, 0x10, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x75, 0x62, 0x5f, 0x6b, + 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x62, 0x4b, 0x69, + 0x6e, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x38, 0x0a, 0x08, + 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, + 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x52, 0x08, 0x6d, 0x65, + 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x46, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x53, 0x70, 0x65, 0x63, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x22, 0x51, + 0x0a, 0x19, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x61, + 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x71, 0x75, + 0x61, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x71, 0x75, 0x61, 0x6c, + 0x73, 0x22, 0x6f, 0x0a, 0x14, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x57, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, + 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x43, 0x6f, 0x6e, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x22, 0x61, 0x0a, 0x15, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x05, 0x61, + 0x6c, 0x6c, 0x6f, 0x77, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x74, 0x65, 0x6c, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x75, 0x6c, 0x65, 0x52, 0x05, + 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x22, 0x3c, 0x0a, 0x16, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x50, 0x49, 0x46, 0x46, 0x45, 0x12, + 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x68, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, + 0x69, 0x6e, 0x74, 0x22, 0xaf, 0x01, 0x0a, 0x14, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x70, 0x65, 0x63, 0x12, 0x49, 0x0a, 0x05, + 0x72, 0x75, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x74, 0x65, + 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x75, 0x6c, 0x65, 0x73, + 0x52, 0x05, 0x72, 0x75, 0x6c, 0x65, 0x73, 0x12, 0x4c, 0x0a, 0x06, 0x73, 0x70, 0x69, 0x66, 0x66, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x50, 0x49, 0x46, 0x46, 0x45, 0x52, 0x06, 0x73, + 0x70, 0x69, 0x66, 0x66, 0x65, 0x42, 0x66, 0x5a, 0x64, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, 0x61, 0x76, 0x69, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x61, + 0x6c, 0x2f, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x74, 0x65, 0x6c, 0x65, + 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x76, 0x31, 0x3b, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x76, 0x31, 0x70, 0x62, 0x62, 0x06, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_teleport_workloadidentity_v1_resource_proto_rawDescOnce sync.Once + file_teleport_workloadidentity_v1_resource_proto_rawDescData = file_teleport_workloadidentity_v1_resource_proto_rawDesc +) + +func file_teleport_workloadidentity_v1_resource_proto_rawDescGZIP() []byte { + file_teleport_workloadidentity_v1_resource_proto_rawDescOnce.Do(func() { + file_teleport_workloadidentity_v1_resource_proto_rawDescData = protoimpl.X.CompressGZIP(file_teleport_workloadidentity_v1_resource_proto_rawDescData) + }) + return file_teleport_workloadidentity_v1_resource_proto_rawDescData +} + +var file_teleport_workloadidentity_v1_resource_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_teleport_workloadidentity_v1_resource_proto_goTypes = []any{ + (*WorkloadIdentity)(nil), // 0: teleport.workloadidentity.v1.WorkloadIdentity + (*WorkloadIdentityCondition)(nil), // 1: teleport.workloadidentity.v1.WorkloadIdentityCondition + (*WorkloadIdentityRule)(nil), // 2: teleport.workloadidentity.v1.WorkloadIdentityRule + (*WorkloadIdentityRules)(nil), // 3: teleport.workloadidentity.v1.WorkloadIdentityRules + (*WorkloadIdentitySPIFFE)(nil), // 4: teleport.workloadidentity.v1.WorkloadIdentitySPIFFE + (*WorkloadIdentitySpec)(nil), // 5: teleport.workloadidentity.v1.WorkloadIdentitySpec + (*v1.Metadata)(nil), // 6: teleport.header.v1.Metadata +} +var file_teleport_workloadidentity_v1_resource_proto_depIdxs = []int32{ + 6, // 0: teleport.workloadidentity.v1.WorkloadIdentity.metadata:type_name -> teleport.header.v1.Metadata + 5, // 1: teleport.workloadidentity.v1.WorkloadIdentity.spec:type_name -> teleport.workloadidentity.v1.WorkloadIdentitySpec + 1, // 2: teleport.workloadidentity.v1.WorkloadIdentityRule.conditions:type_name -> teleport.workloadidentity.v1.WorkloadIdentityCondition + 2, // 3: teleport.workloadidentity.v1.WorkloadIdentityRules.allow:type_name -> teleport.workloadidentity.v1.WorkloadIdentityRule + 3, // 4: teleport.workloadidentity.v1.WorkloadIdentitySpec.rules:type_name -> teleport.workloadidentity.v1.WorkloadIdentityRules + 4, // 5: teleport.workloadidentity.v1.WorkloadIdentitySpec.spiffe:type_name -> teleport.workloadidentity.v1.WorkloadIdentitySPIFFE + 6, // [6:6] is the sub-list for method output_type + 6, // [6:6] is the sub-list for method input_type + 6, // [6:6] is the sub-list for extension type_name + 6, // [6:6] is the sub-list for extension extendee + 0, // [0:6] is the sub-list for field type_name +} + +func init() { file_teleport_workloadidentity_v1_resource_proto_init() } +func file_teleport_workloadidentity_v1_resource_proto_init() { + if File_teleport_workloadidentity_v1_resource_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_teleport_workloadidentity_v1_resource_proto_rawDesc, + NumEnums: 0, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_teleport_workloadidentity_v1_resource_proto_goTypes, + DependencyIndexes: file_teleport_workloadidentity_v1_resource_proto_depIdxs, + MessageInfos: file_teleport_workloadidentity_v1_resource_proto_msgTypes, + }.Build() + File_teleport_workloadidentity_v1_resource_proto = out.File + file_teleport_workloadidentity_v1_resource_proto_rawDesc = nil + file_teleport_workloadidentity_v1_resource_proto_goTypes = nil + file_teleport_workloadidentity_v1_resource_proto_depIdxs = nil +} diff --git a/api/gen/proto/go/teleport/workloadidentity/v1/resource_service.pb.go b/api/gen/proto/go/teleport/workloadidentity/v1/resource_service.pb.go new file mode 100644 index 0000000000000..c311ba2a64e87 --- /dev/null +++ b/api/gen/proto/go/teleport/workloadidentity/v1/resource_service.pb.go @@ -0,0 +1,580 @@ +// 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. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.35.1 +// protoc (unknown) +// source: teleport/workloadidentity/v1/resource_service.proto + +package workloadidentityv1pb + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + emptypb "google.golang.org/protobuf/types/known/emptypb" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// The request for CreateWorkloadIdentity. +type CreateWorkloadIdentityRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The workload identity to create. + WorkloadIdentity *WorkloadIdentity `protobuf:"bytes,1,opt,name=workload_identity,json=workloadIdentity,proto3" json:"workload_identity,omitempty"` +} + +func (x *CreateWorkloadIdentityRequest) Reset() { + *x = CreateWorkloadIdentityRequest{} + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateWorkloadIdentityRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateWorkloadIdentityRequest) ProtoMessage() {} + +func (x *CreateWorkloadIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateWorkloadIdentityRequest.ProtoReflect.Descriptor instead. +func (*CreateWorkloadIdentityRequest) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP(), []int{0} +} + +func (x *CreateWorkloadIdentityRequest) GetWorkloadIdentity() *WorkloadIdentity { + if x != nil { + return x.WorkloadIdentity + } + return nil +} + +// The request for UpdateWorkloadIdentity. +type UpdateWorkloadIdentityRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The workload identity to update. + WorkloadIdentity *WorkloadIdentity `protobuf:"bytes,1,opt,name=workload_identity,json=workloadIdentity,proto3" json:"workload_identity,omitempty"` +} + +func (x *UpdateWorkloadIdentityRequest) Reset() { + *x = UpdateWorkloadIdentityRequest{} + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateWorkloadIdentityRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateWorkloadIdentityRequest) ProtoMessage() {} + +func (x *UpdateWorkloadIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateWorkloadIdentityRequest.ProtoReflect.Descriptor instead. +func (*UpdateWorkloadIdentityRequest) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP(), []int{1} +} + +func (x *UpdateWorkloadIdentityRequest) GetWorkloadIdentity() *WorkloadIdentity { + if x != nil { + return x.WorkloadIdentity + } + return nil +} + +// The request for UpsertWorkloadIdentityRequest. +type UpsertWorkloadIdentityRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The workload identity to upsert. + WorkloadIdentity *WorkloadIdentity `protobuf:"bytes,1,opt,name=workload_identity,json=workloadIdentity,proto3" json:"workload_identity,omitempty"` +} + +func (x *UpsertWorkloadIdentityRequest) Reset() { + *x = UpsertWorkloadIdentityRequest{} + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpsertWorkloadIdentityRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpsertWorkloadIdentityRequest) ProtoMessage() {} + +func (x *UpsertWorkloadIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpsertWorkloadIdentityRequest.ProtoReflect.Descriptor instead. +func (*UpsertWorkloadIdentityRequest) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP(), []int{2} +} + +func (x *UpsertWorkloadIdentityRequest) GetWorkloadIdentity() *WorkloadIdentity { + if x != nil { + return x.WorkloadIdentity + } + return nil +} + +// The request for GetWorkloadIdentity. +type GetWorkloadIdentityRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the workload identity to retrieve. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *GetWorkloadIdentityRequest) Reset() { + *x = GetWorkloadIdentityRequest{} + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetWorkloadIdentityRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetWorkloadIdentityRequest) ProtoMessage() {} + +func (x *GetWorkloadIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetWorkloadIdentityRequest.ProtoReflect.Descriptor instead. +func (*GetWorkloadIdentityRequest) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP(), []int{3} +} + +func (x *GetWorkloadIdentityRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// The request for DeleteWorkloadIdentity. +type DeleteWorkloadIdentityRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The name of the workload identity to delete. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *DeleteWorkloadIdentityRequest) Reset() { + *x = DeleteWorkloadIdentityRequest{} + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteWorkloadIdentityRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteWorkloadIdentityRequest) ProtoMessage() {} + +func (x *DeleteWorkloadIdentityRequest) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteWorkloadIdentityRequest.ProtoReflect.Descriptor instead. +func (*DeleteWorkloadIdentityRequest) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP(), []int{4} +} + +func (x *DeleteWorkloadIdentityRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +// The request for ListWorkloadIdentities. +type ListWorkloadIdentitiesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The maximum number of items to return. + // The server may impose a different page size at its discretion. + PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + // The page_token value returned from a previous ListWorkloadIdentities request, if any. + PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` +} + +func (x *ListWorkloadIdentitiesRequest) Reset() { + *x = ListWorkloadIdentitiesRequest{} + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListWorkloadIdentitiesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListWorkloadIdentitiesRequest) ProtoMessage() {} + +func (x *ListWorkloadIdentitiesRequest) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListWorkloadIdentitiesRequest.ProtoReflect.Descriptor instead. +func (*ListWorkloadIdentitiesRequest) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP(), []int{5} +} + +func (x *ListWorkloadIdentitiesRequest) GetPageSize() int32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *ListWorkloadIdentitiesRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +// The response for ListWorkloadIdentities. +type ListWorkloadIdentitiesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The page of workload identities that matched the request. + WorkloadIdentities []*WorkloadIdentity `protobuf:"bytes,1,rep,name=workload_identities,json=workloadIdentities,proto3" json:"workload_identities,omitempty"` + // Token to retrieve the next page of results, or empty if there are no + // more results in the list. + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` +} + +func (x *ListWorkloadIdentitiesResponse) Reset() { + *x = ListWorkloadIdentitiesResponse{} + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListWorkloadIdentitiesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListWorkloadIdentitiesResponse) ProtoMessage() {} + +func (x *ListWorkloadIdentitiesResponse) ProtoReflect() protoreflect.Message { + mi := &file_teleport_workloadidentity_v1_resource_service_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListWorkloadIdentitiesResponse.ProtoReflect.Descriptor instead. +func (*ListWorkloadIdentitiesResponse) Descriptor() ([]byte, []int) { + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP(), []int{6} +} + +func (x *ListWorkloadIdentitiesResponse) GetWorkloadIdentities() []*WorkloadIdentity { + if x != nil { + return x.WorkloadIdentities + } + return nil +} + +func (x *ListWorkloadIdentitiesResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +var File_teleport_workloadidentity_v1_resource_service_proto protoreflect.FileDescriptor + +var file_teleport_workloadidentity_v1_resource_service_proto_rawDesc = []byte{ + 0x0a, 0x33, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x76, 0x31, 0x2f, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1c, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x2e, 0x76, 0x31, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x1a, 0x2b, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x76, 0x31, 0x2f, 0x72, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x7c, 0x0a, + 0x1d, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x5b, + 0x0a, 0x11, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, + 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x10, 0x77, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x22, 0x7c, 0x0a, 0x1d, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x5b, 0x0a, 0x11, + 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, + 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x10, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x22, 0x7c, 0x0a, 0x1d, 0x55, 0x70, 0x73, + 0x65, 0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x5b, 0x0a, 0x11, 0x77, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, + 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, + 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x10, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x22, 0x30, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x33, 0x0a, 0x1d, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x5b, + 0x0a, 0x1d, 0x4c, 0x69, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x1b, 0x0a, 0x09, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x08, 0x70, 0x61, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x1d, 0x0a, 0x0a, + 0x70, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x70, 0x61, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0xa9, 0x01, 0x0a, 0x1e, + 0x4c, 0x69, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5f, + 0x0a, 0x13, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x74, 0x65, + 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x12, 0x77, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, + 0x26, 0x0a, 0x0f, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x6f, 0x6b, + 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6e, 0x65, 0x78, 0x74, 0x50, 0x61, + 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x32, 0xbf, 0x06, 0x0a, 0x1f, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x85, 0x01, 0x0a, 0x16, + 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x3b, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, + 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x12, 0x85, 0x01, 0x0a, 0x16, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x3b, + 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x74, 0x65, + 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, + 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x85, 0x01, 0x0a, 0x16, + 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x3b, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, + 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x73, 0x65, 0x72, 0x74, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, + 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, + 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x12, 0x7f, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x38, 0x2e, 0x74, 0x65, 0x6c, + 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x57, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, + 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x2e, 0x76, 0x31, 0x2e, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x12, 0x6d, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x57, 0x6f, + 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x3b, + 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x74, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x16, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, + 0x70, 0x74, 0x79, 0x12, 0x93, 0x01, 0x0a, 0x16, 0x4c, 0x69, 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, + 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x3b, + 0x2e, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, + 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, + 0x73, 0x74, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x3c, 0x2e, 0x74, 0x65, + 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x57, + 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69, 0x65, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x66, 0x5a, 0x64, 0x67, 0x69, 0x74, + 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, 0x61, 0x76, 0x69, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x61, + 0x70, 0x69, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, + 0x74, 0x65, 0x6c, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, + 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x76, 0x31, 0x3b, 0x77, 0x6f, 0x72, + 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x76, 0x31, 0x70, + 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_teleport_workloadidentity_v1_resource_service_proto_rawDescOnce sync.Once + file_teleport_workloadidentity_v1_resource_service_proto_rawDescData = file_teleport_workloadidentity_v1_resource_service_proto_rawDesc +) + +func file_teleport_workloadidentity_v1_resource_service_proto_rawDescGZIP() []byte { + file_teleport_workloadidentity_v1_resource_service_proto_rawDescOnce.Do(func() { + file_teleport_workloadidentity_v1_resource_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_teleport_workloadidentity_v1_resource_service_proto_rawDescData) + }) + return file_teleport_workloadidentity_v1_resource_service_proto_rawDescData +} + +var file_teleport_workloadidentity_v1_resource_service_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_teleport_workloadidentity_v1_resource_service_proto_goTypes = []any{ + (*CreateWorkloadIdentityRequest)(nil), // 0: teleport.workloadidentity.v1.CreateWorkloadIdentityRequest + (*UpdateWorkloadIdentityRequest)(nil), // 1: teleport.workloadidentity.v1.UpdateWorkloadIdentityRequest + (*UpsertWorkloadIdentityRequest)(nil), // 2: teleport.workloadidentity.v1.UpsertWorkloadIdentityRequest + (*GetWorkloadIdentityRequest)(nil), // 3: teleport.workloadidentity.v1.GetWorkloadIdentityRequest + (*DeleteWorkloadIdentityRequest)(nil), // 4: teleport.workloadidentity.v1.DeleteWorkloadIdentityRequest + (*ListWorkloadIdentitiesRequest)(nil), // 5: teleport.workloadidentity.v1.ListWorkloadIdentitiesRequest + (*ListWorkloadIdentitiesResponse)(nil), // 6: teleport.workloadidentity.v1.ListWorkloadIdentitiesResponse + (*WorkloadIdentity)(nil), // 7: teleport.workloadidentity.v1.WorkloadIdentity + (*emptypb.Empty)(nil), // 8: google.protobuf.Empty +} +var file_teleport_workloadidentity_v1_resource_service_proto_depIdxs = []int32{ + 7, // 0: teleport.workloadidentity.v1.CreateWorkloadIdentityRequest.workload_identity:type_name -> teleport.workloadidentity.v1.WorkloadIdentity + 7, // 1: teleport.workloadidentity.v1.UpdateWorkloadIdentityRequest.workload_identity:type_name -> teleport.workloadidentity.v1.WorkloadIdentity + 7, // 2: teleport.workloadidentity.v1.UpsertWorkloadIdentityRequest.workload_identity:type_name -> teleport.workloadidentity.v1.WorkloadIdentity + 7, // 3: teleport.workloadidentity.v1.ListWorkloadIdentitiesResponse.workload_identities:type_name -> teleport.workloadidentity.v1.WorkloadIdentity + 0, // 4: teleport.workloadidentity.v1.WorkloadIdentityResourceService.CreateWorkloadIdentity:input_type -> teleport.workloadidentity.v1.CreateWorkloadIdentityRequest + 1, // 5: teleport.workloadidentity.v1.WorkloadIdentityResourceService.UpdateWorkloadIdentity:input_type -> teleport.workloadidentity.v1.UpdateWorkloadIdentityRequest + 2, // 6: teleport.workloadidentity.v1.WorkloadIdentityResourceService.UpsertWorkloadIdentity:input_type -> teleport.workloadidentity.v1.UpsertWorkloadIdentityRequest + 3, // 7: teleport.workloadidentity.v1.WorkloadIdentityResourceService.GetWorkloadIdentity:input_type -> teleport.workloadidentity.v1.GetWorkloadIdentityRequest + 4, // 8: teleport.workloadidentity.v1.WorkloadIdentityResourceService.DeleteWorkloadIdentity:input_type -> teleport.workloadidentity.v1.DeleteWorkloadIdentityRequest + 5, // 9: teleport.workloadidentity.v1.WorkloadIdentityResourceService.ListWorkloadIdentities:input_type -> teleport.workloadidentity.v1.ListWorkloadIdentitiesRequest + 7, // 10: teleport.workloadidentity.v1.WorkloadIdentityResourceService.CreateWorkloadIdentity:output_type -> teleport.workloadidentity.v1.WorkloadIdentity + 7, // 11: teleport.workloadidentity.v1.WorkloadIdentityResourceService.UpdateWorkloadIdentity:output_type -> teleport.workloadidentity.v1.WorkloadIdentity + 7, // 12: teleport.workloadidentity.v1.WorkloadIdentityResourceService.UpsertWorkloadIdentity:output_type -> teleport.workloadidentity.v1.WorkloadIdentity + 7, // 13: teleport.workloadidentity.v1.WorkloadIdentityResourceService.GetWorkloadIdentity:output_type -> teleport.workloadidentity.v1.WorkloadIdentity + 8, // 14: teleport.workloadidentity.v1.WorkloadIdentityResourceService.DeleteWorkloadIdentity:output_type -> google.protobuf.Empty + 6, // 15: teleport.workloadidentity.v1.WorkloadIdentityResourceService.ListWorkloadIdentities:output_type -> teleport.workloadidentity.v1.ListWorkloadIdentitiesResponse + 10, // [10:16] is the sub-list for method output_type + 4, // [4:10] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name +} + +func init() { file_teleport_workloadidentity_v1_resource_service_proto_init() } +func file_teleport_workloadidentity_v1_resource_service_proto_init() { + if File_teleport_workloadidentity_v1_resource_service_proto != nil { + return + } + file_teleport_workloadidentity_v1_resource_proto_init() + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_teleport_workloadidentity_v1_resource_service_proto_rawDesc, + NumEnums: 0, + NumMessages: 7, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_teleport_workloadidentity_v1_resource_service_proto_goTypes, + DependencyIndexes: file_teleport_workloadidentity_v1_resource_service_proto_depIdxs, + MessageInfos: file_teleport_workloadidentity_v1_resource_service_proto_msgTypes, + }.Build() + File_teleport_workloadidentity_v1_resource_service_proto = out.File + file_teleport_workloadidentity_v1_resource_service_proto_rawDesc = nil + file_teleport_workloadidentity_v1_resource_service_proto_goTypes = nil + file_teleport_workloadidentity_v1_resource_service_proto_depIdxs = nil +} diff --git a/api/gen/proto/go/teleport/workloadidentity/v1/resource_service_grpc.pb.go b/api/gen/proto/go/teleport/workloadidentity/v1/resource_service_grpc.pb.go new file mode 100644 index 0000000000000..bd3492fee51ec --- /dev/null +++ b/api/gen/proto/go/teleport/workloadidentity/v1/resource_service_grpc.pb.go @@ -0,0 +1,361 @@ +// 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. + +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc (unknown) +// source: teleport/workloadidentity/v1/resource_service.proto + +package workloadidentityv1pb + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + emptypb "google.golang.org/protobuf/types/known/emptypb" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + WorkloadIdentityResourceService_CreateWorkloadIdentity_FullMethodName = "/teleport.workloadidentity.v1.WorkloadIdentityResourceService/CreateWorkloadIdentity" + WorkloadIdentityResourceService_UpdateWorkloadIdentity_FullMethodName = "/teleport.workloadidentity.v1.WorkloadIdentityResourceService/UpdateWorkloadIdentity" + WorkloadIdentityResourceService_UpsertWorkloadIdentity_FullMethodName = "/teleport.workloadidentity.v1.WorkloadIdentityResourceService/UpsertWorkloadIdentity" + WorkloadIdentityResourceService_GetWorkloadIdentity_FullMethodName = "/teleport.workloadidentity.v1.WorkloadIdentityResourceService/GetWorkloadIdentity" + WorkloadIdentityResourceService_DeleteWorkloadIdentity_FullMethodName = "/teleport.workloadidentity.v1.WorkloadIdentityResourceService/DeleteWorkloadIdentity" + WorkloadIdentityResourceService_ListWorkloadIdentities_FullMethodName = "/teleport.workloadidentity.v1.WorkloadIdentityResourceService/ListWorkloadIdentities" +) + +// WorkloadIdentityResourceServiceClient is the client API for WorkloadIdentityResourceService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// WorkloadIdentityResourceService provides methods to manage the +// WorkloadIdentity resource. +type WorkloadIdentityResourceServiceClient interface { + // CreateWorkloadIdentity creates a new workload identity, it will refuse to + // create a workload identity if one already exists with the same name. + CreateWorkloadIdentity(ctx context.Context, in *CreateWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) + // UpdateWorkloadIdentity updates an existing workload identity, it will refuse + // to update a workload identity if one does not already exist with the same name. + // + // ConditionalUpdate semantics are applied, e.g, the update will only succeed + // if the revision of the provided WorkloadIdentity matches the revision of + // the existing WorkloadIdentity. + UpdateWorkloadIdentity(ctx context.Context, in *UpdateWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) + // UpsertWorkloadIdentity creates or updates a workload identity. You should + // prefer to call Create or Update. + UpsertWorkloadIdentity(ctx context.Context, in *UpsertWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) + // GetWorkloadIdentity retrieves a workload identity by name. + GetWorkloadIdentity(ctx context.Context, in *GetWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) + // DeleteWorkloadIdentity deletes a workload identity by name. + DeleteWorkloadIdentity(ctx context.Context, in *DeleteWorkloadIdentityRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // ListWorkloadIdentities of all workload identities, pagination semantics are + // applied. + ListWorkloadIdentities(ctx context.Context, in *ListWorkloadIdentitiesRequest, opts ...grpc.CallOption) (*ListWorkloadIdentitiesResponse, error) +} + +type workloadIdentityResourceServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewWorkloadIdentityResourceServiceClient(cc grpc.ClientConnInterface) WorkloadIdentityResourceServiceClient { + return &workloadIdentityResourceServiceClient{cc} +} + +func (c *workloadIdentityResourceServiceClient) CreateWorkloadIdentity(ctx context.Context, in *CreateWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(WorkloadIdentity) + err := c.cc.Invoke(ctx, WorkloadIdentityResourceService_CreateWorkloadIdentity_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *workloadIdentityResourceServiceClient) UpdateWorkloadIdentity(ctx context.Context, in *UpdateWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(WorkloadIdentity) + err := c.cc.Invoke(ctx, WorkloadIdentityResourceService_UpdateWorkloadIdentity_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *workloadIdentityResourceServiceClient) UpsertWorkloadIdentity(ctx context.Context, in *UpsertWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(WorkloadIdentity) + err := c.cc.Invoke(ctx, WorkloadIdentityResourceService_UpsertWorkloadIdentity_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *workloadIdentityResourceServiceClient) GetWorkloadIdentity(ctx context.Context, in *GetWorkloadIdentityRequest, opts ...grpc.CallOption) (*WorkloadIdentity, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(WorkloadIdentity) + err := c.cc.Invoke(ctx, WorkloadIdentityResourceService_GetWorkloadIdentity_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *workloadIdentityResourceServiceClient) DeleteWorkloadIdentity(ctx context.Context, in *DeleteWorkloadIdentityRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, WorkloadIdentityResourceService_DeleteWorkloadIdentity_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *workloadIdentityResourceServiceClient) ListWorkloadIdentities(ctx context.Context, in *ListWorkloadIdentitiesRequest, opts ...grpc.CallOption) (*ListWorkloadIdentitiesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListWorkloadIdentitiesResponse) + err := c.cc.Invoke(ctx, WorkloadIdentityResourceService_ListWorkloadIdentities_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// WorkloadIdentityResourceServiceServer is the server API for WorkloadIdentityResourceService service. +// All implementations must embed UnimplementedWorkloadIdentityResourceServiceServer +// for forward compatibility. +// +// WorkloadIdentityResourceService provides methods to manage the +// WorkloadIdentity resource. +type WorkloadIdentityResourceServiceServer interface { + // CreateWorkloadIdentity creates a new workload identity, it will refuse to + // create a workload identity if one already exists with the same name. + CreateWorkloadIdentity(context.Context, *CreateWorkloadIdentityRequest) (*WorkloadIdentity, error) + // UpdateWorkloadIdentity updates an existing workload identity, it will refuse + // to update a workload identity if one does not already exist with the same name. + // + // ConditionalUpdate semantics are applied, e.g, the update will only succeed + // if the revision of the provided WorkloadIdentity matches the revision of + // the existing WorkloadIdentity. + UpdateWorkloadIdentity(context.Context, *UpdateWorkloadIdentityRequest) (*WorkloadIdentity, error) + // UpsertWorkloadIdentity creates or updates a workload identity. You should + // prefer to call Create or Update. + UpsertWorkloadIdentity(context.Context, *UpsertWorkloadIdentityRequest) (*WorkloadIdentity, error) + // GetWorkloadIdentity retrieves a workload identity by name. + GetWorkloadIdentity(context.Context, *GetWorkloadIdentityRequest) (*WorkloadIdentity, error) + // DeleteWorkloadIdentity deletes a workload identity by name. + DeleteWorkloadIdentity(context.Context, *DeleteWorkloadIdentityRequest) (*emptypb.Empty, error) + // ListWorkloadIdentities of all workload identities, pagination semantics are + // applied. + ListWorkloadIdentities(context.Context, *ListWorkloadIdentitiesRequest) (*ListWorkloadIdentitiesResponse, error) + mustEmbedUnimplementedWorkloadIdentityResourceServiceServer() +} + +// UnimplementedWorkloadIdentityResourceServiceServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedWorkloadIdentityResourceServiceServer struct{} + +func (UnimplementedWorkloadIdentityResourceServiceServer) CreateWorkloadIdentity(context.Context, *CreateWorkloadIdentityRequest) (*WorkloadIdentity, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateWorkloadIdentity not implemented") +} +func (UnimplementedWorkloadIdentityResourceServiceServer) UpdateWorkloadIdentity(context.Context, *UpdateWorkloadIdentityRequest) (*WorkloadIdentity, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateWorkloadIdentity not implemented") +} +func (UnimplementedWorkloadIdentityResourceServiceServer) UpsertWorkloadIdentity(context.Context, *UpsertWorkloadIdentityRequest) (*WorkloadIdentity, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpsertWorkloadIdentity not implemented") +} +func (UnimplementedWorkloadIdentityResourceServiceServer) GetWorkloadIdentity(context.Context, *GetWorkloadIdentityRequest) (*WorkloadIdentity, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetWorkloadIdentity not implemented") +} +func (UnimplementedWorkloadIdentityResourceServiceServer) DeleteWorkloadIdentity(context.Context, *DeleteWorkloadIdentityRequest) (*emptypb.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteWorkloadIdentity not implemented") +} +func (UnimplementedWorkloadIdentityResourceServiceServer) ListWorkloadIdentities(context.Context, *ListWorkloadIdentitiesRequest) (*ListWorkloadIdentitiesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ListWorkloadIdentities not implemented") +} +func (UnimplementedWorkloadIdentityResourceServiceServer) mustEmbedUnimplementedWorkloadIdentityResourceServiceServer() { +} +func (UnimplementedWorkloadIdentityResourceServiceServer) testEmbeddedByValue() {} + +// UnsafeWorkloadIdentityResourceServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to WorkloadIdentityResourceServiceServer will +// result in compilation errors. +type UnsafeWorkloadIdentityResourceServiceServer interface { + mustEmbedUnimplementedWorkloadIdentityResourceServiceServer() +} + +func RegisterWorkloadIdentityResourceServiceServer(s grpc.ServiceRegistrar, srv WorkloadIdentityResourceServiceServer) { + // If the following call pancis, it indicates UnimplementedWorkloadIdentityResourceServiceServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&WorkloadIdentityResourceService_ServiceDesc, srv) +} + +func _WorkloadIdentityResourceService_CreateWorkloadIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateWorkloadIdentityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(WorkloadIdentityResourceServiceServer).CreateWorkloadIdentity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: WorkloadIdentityResourceService_CreateWorkloadIdentity_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(WorkloadIdentityResourceServiceServer).CreateWorkloadIdentity(ctx, req.(*CreateWorkloadIdentityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _WorkloadIdentityResourceService_UpdateWorkloadIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateWorkloadIdentityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(WorkloadIdentityResourceServiceServer).UpdateWorkloadIdentity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: WorkloadIdentityResourceService_UpdateWorkloadIdentity_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(WorkloadIdentityResourceServiceServer).UpdateWorkloadIdentity(ctx, req.(*UpdateWorkloadIdentityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _WorkloadIdentityResourceService_UpsertWorkloadIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpsertWorkloadIdentityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(WorkloadIdentityResourceServiceServer).UpsertWorkloadIdentity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: WorkloadIdentityResourceService_UpsertWorkloadIdentity_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(WorkloadIdentityResourceServiceServer).UpsertWorkloadIdentity(ctx, req.(*UpsertWorkloadIdentityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _WorkloadIdentityResourceService_GetWorkloadIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetWorkloadIdentityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(WorkloadIdentityResourceServiceServer).GetWorkloadIdentity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: WorkloadIdentityResourceService_GetWorkloadIdentity_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(WorkloadIdentityResourceServiceServer).GetWorkloadIdentity(ctx, req.(*GetWorkloadIdentityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _WorkloadIdentityResourceService_DeleteWorkloadIdentity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteWorkloadIdentityRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(WorkloadIdentityResourceServiceServer).DeleteWorkloadIdentity(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: WorkloadIdentityResourceService_DeleteWorkloadIdentity_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(WorkloadIdentityResourceServiceServer).DeleteWorkloadIdentity(ctx, req.(*DeleteWorkloadIdentityRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _WorkloadIdentityResourceService_ListWorkloadIdentities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListWorkloadIdentitiesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(WorkloadIdentityResourceServiceServer).ListWorkloadIdentities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: WorkloadIdentityResourceService_ListWorkloadIdentities_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(WorkloadIdentityResourceServiceServer).ListWorkloadIdentities(ctx, req.(*ListWorkloadIdentitiesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// WorkloadIdentityResourceService_ServiceDesc is the grpc.ServiceDesc for WorkloadIdentityResourceService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var WorkloadIdentityResourceService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "teleport.workloadidentity.v1.WorkloadIdentityResourceService", + HandlerType: (*WorkloadIdentityResourceServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateWorkloadIdentity", + Handler: _WorkloadIdentityResourceService_CreateWorkloadIdentity_Handler, + }, + { + MethodName: "UpdateWorkloadIdentity", + Handler: _WorkloadIdentityResourceService_UpdateWorkloadIdentity_Handler, + }, + { + MethodName: "UpsertWorkloadIdentity", + Handler: _WorkloadIdentityResourceService_UpsertWorkloadIdentity_Handler, + }, + { + MethodName: "GetWorkloadIdentity", + Handler: _WorkloadIdentityResourceService_GetWorkloadIdentity_Handler, + }, + { + MethodName: "DeleteWorkloadIdentity", + Handler: _WorkloadIdentityResourceService_DeleteWorkloadIdentity_Handler, + }, + { + MethodName: "ListWorkloadIdentities", + Handler: _WorkloadIdentityResourceService_ListWorkloadIdentities_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "teleport/workloadidentity/v1/resource_service.proto", +} diff --git a/api/proto/teleport/legacy/client/proto/event.proto b/api/proto/teleport/legacy/client/proto/event.proto index 7c0cd043eb13d..e221a9c25ad14 100644 --- a/api/proto/teleport/legacy/client/proto/event.proto +++ b/api/proto/teleport/legacy/client/proto/event.proto @@ -34,6 +34,7 @@ import "teleport/secreports/v1/secreports.proto"; import "teleport/userloginstate/v1/userloginstate.proto"; import "teleport/userprovisioning/v2/statichostuser.proto"; import "teleport/usertasks/v1/user_tasks.proto"; +import "teleport/workloadidentity/v1/resource.proto"; option go_package = "github.com/gravitational/teleport/api/client/proto"; @@ -206,5 +207,7 @@ message Event { // IdentityCenterAccountlAssignment is a resource representing a potential // Permission Set grant on a specific AWS account. teleport.identitycenter.v1.AccountAssignment IdentityCenterAccountAssignment = 74; + // WorkloadIdentity is a resource for workload identity. + teleport.workloadidentity.v1.WorkloadIdentity WorkloadIdentity = 76; } } diff --git a/api/proto/teleport/legacy/types/events/events.proto b/api/proto/teleport/legacy/types/events/events.proto index fa3fee74c5ecd..bfb8bebe26a59 100644 --- a/api/proto/teleport/legacy/types/events/events.proto +++ b/api/proto/teleport/legacy/types/events/events.proto @@ -4691,6 +4691,9 @@ message OneOf { events.UserTaskUpdate UserTaskUpdate = 189; events.UserTaskDelete UserTaskDelete = 190; events.SFTPSummary SFTPSummary = 191; + events.WorkloadIdentityCreate WorkloadIdentityCreate = 194; + events.WorkloadIdentityUpdate WorkloadIdentityUpdate = 195; + events.WorkloadIdentityDelete WorkloadIdentityDelete = 196; } } @@ -7581,3 +7584,108 @@ message UserTaskDelete { (gogoproto.jsontag) = "" ]; } + +// WorkloadIdentityCreate is emitted when a WorkloadIdentity is created. +message WorkloadIdentityCreate { + // Metadata is a common event metadata + Metadata Metadata = 1 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ResourceMetadata is a common resource event metadata + ResourceMetadata Resource = 2 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // User is a common user event metadata + UserMetadata User = 3 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ConnectionMetadata holds information about the connection + ConnectionMetadata Connection = 4 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // WorkloadIdentityData is a copy of the WorkloadIdentity resource + google.protobuf.Struct WorkloadIdentityData = 5 [ + (gogoproto.jsontag) = "workload_identity_data,omitempty", + (gogoproto.casttype) = "Struct" + ]; +} + +// WorkloadIdentityUpdate is emitted when a WorkloadIdentity is updated. +message WorkloadIdentityUpdate { + // Metadata is a common event metadata + Metadata Metadata = 1 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ResourceMetadata is a common resource event metadata + ResourceMetadata Resource = 2 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // User is a common user event metadata + UserMetadata User = 3 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ConnectionMetadata holds information about the connection + ConnectionMetadata Connection = 4 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // WorkloadIdentityData is a copy of the WorkloadIdentity resource + google.protobuf.Struct WorkloadIdentityData = 5 [ + (gogoproto.jsontag) = "workload_identity_data,omitempty", + (gogoproto.casttype) = "Struct" + ]; +} + +// WorkloadIdentityDelete is emitted when a WorkloadIdentity is deleted. +message WorkloadIdentityDelete { + // Metadata is a common event metadata + Metadata Metadata = 1 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ResourceMetadata is a common resource event metadata + ResourceMetadata Resource = 2 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // User is a common user event metadata + UserMetadata User = 3 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; + + // ConnectionMetadata holds information about the connection + ConnectionMetadata Connection = 4 [ + (gogoproto.nullable) = false, + (gogoproto.embed) = true, + (gogoproto.jsontag) = "" + ]; +} diff --git a/api/proto/teleport/workloadidentity/v1/resource.proto b/api/proto/teleport/workloadidentity/v1/resource.proto new file mode 100644 index 0000000000000..6bf73e0f07fab --- /dev/null +++ b/api/proto/teleport/workloadidentity/v1/resource.proto @@ -0,0 +1,85 @@ +// 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. + +syntax = "proto3"; + +package teleport.workloadidentity.v1; + +import "teleport/header/v1/metadata.proto"; + +option go_package = "github.com/gravitational/teleport/api/gen/proto/go/teleport/workloadidentity/v1;workloadidentityv1pb"; + +// WorkloadIdentity represents a single, or group of similar, workload +// identities and configures the structure of workload identity credentials and +// authorization rules. is a resource that represents the configuration of a trust +// domain federation. +message WorkloadIdentity { + // The kind of resource represented. + string kind = 1; + // Differentiates variations of the same kind. All resources should + // contain one, even if it is never populated. + string sub_kind = 2; + // The version of the resource being represented. + string version = 3; + // Common metadata that all resources share. + teleport.header.v1.Metadata metadata = 4; + // The configured properties of the WorkloadIdentity + WorkloadIdentitySpec spec = 5; +} + +// The individual conditions that make up a rule. +message WorkloadIdentityCondition { + // The name of the attribute to evaluate the condition against. + string attribute = 1; + // An exact string that the attribute must match. + string equals = 2; +} + +// An individual rule that is evaluated during the issuance of a WorkloadIdentity. +message WorkloadIdentityRule { + // The conditions that must be met for this rule to be considered passed. + repeated WorkloadIdentityCondition conditions = 1; +} + +// The rules which are evaluated before the WorkloadIdentity can be issued. +message WorkloadIdentityRules { + // A list of rules used to determine if a WorkloadIdentity can be issued. + // If none are provided, it will be considered a pass. If any are provided, + // then at least one must pass for the rules to be considered passed. + repeated WorkloadIdentityRule allow = 1; +} + +// Configuration pertaining to the issuance of SPIFFE-compatible workload +// identity credentials. +message WorkloadIdentitySPIFFE { + // The path of the SPIFFE ID that will be issued to the workload. + // + // This should be prefixed with a forward-slash ("/"). + // + // This field supports templating using attributes. + string id = 1; + // A freeform text field which is provided to workloads along with a + // credential produced by this WorkloadIdentity. This can be used to provide + // additional context that can be used to select between multiple credentials. + string hint = 2; +} + +// The spec for the WorkloadIdentity resource. +message WorkloadIdentitySpec { + // The rules which are evaluated before the WorkloadIdentity can be issued. + WorkloadIdentityRules rules = 1; + // Configuration pertaining to the issuance of SPIFFE-compatible workload + // identity credentials. + WorkloadIdentitySPIFFE spiffe = 2; +} diff --git a/api/proto/teleport/workloadidentity/v1/resource_service.proto b/api/proto/teleport/workloadidentity/v1/resource_service.proto new file mode 100644 index 0000000000000..28351aefb6434 --- /dev/null +++ b/api/proto/teleport/workloadidentity/v1/resource_service.proto @@ -0,0 +1,95 @@ +// 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. + +syntax = "proto3"; + +package teleport.workloadidentity.v1; + +import "google/protobuf/empty.proto"; +import "teleport/workloadidentity/v1/resource.proto"; + +option go_package = "github.com/gravitational/teleport/api/gen/proto/go/teleport/workloadidentity/v1;workloadidentityv1pb"; + +// WorkloadIdentityResourceService provides methods to manage the +// WorkloadIdentity resource. +service WorkloadIdentityResourceService { + // CreateWorkloadIdentity creates a new workload identity, it will refuse to + // create a workload identity if one already exists with the same name. + rpc CreateWorkloadIdentity(CreateWorkloadIdentityRequest) returns (WorkloadIdentity); + // UpdateWorkloadIdentity updates an existing workload identity, it will refuse + // to update a workload identity if one does not already exist with the same name. + // + // ConditionalUpdate semantics are applied, e.g, the update will only succeed + // if the revision of the provided WorkloadIdentity matches the revision of + // the existing WorkloadIdentity. + rpc UpdateWorkloadIdentity(UpdateWorkloadIdentityRequest) returns (WorkloadIdentity); + // UpsertWorkloadIdentity creates or updates a workload identity. You should + // prefer to call Create or Update. + rpc UpsertWorkloadIdentity(UpsertWorkloadIdentityRequest) returns (WorkloadIdentity); + // GetWorkloadIdentity retrieves a workload identity by name. + rpc GetWorkloadIdentity(GetWorkloadIdentityRequest) returns (WorkloadIdentity); + // DeleteWorkloadIdentity deletes a workload identity by name. + rpc DeleteWorkloadIdentity(DeleteWorkloadIdentityRequest) returns (google.protobuf.Empty); + // ListWorkloadIdentities of all workload identities, pagination semantics are + // applied. + rpc ListWorkloadIdentities(ListWorkloadIdentitiesRequest) returns (ListWorkloadIdentitiesResponse); +} + +// The request for CreateWorkloadIdentity. +message CreateWorkloadIdentityRequest { + // The workload identity to create. + WorkloadIdentity workload_identity = 1; +} + +// The request for UpdateWorkloadIdentity. +message UpdateWorkloadIdentityRequest { + // The workload identity to update. + WorkloadIdentity workload_identity = 1; +} + +// The request for UpsertWorkloadIdentityRequest. +message UpsertWorkloadIdentityRequest { + // The workload identity to upsert. + WorkloadIdentity workload_identity = 1; +} + +// The request for GetWorkloadIdentity. +message GetWorkloadIdentityRequest { + // The name of the workload identity to retrieve. + string name = 1; +} + +// The request for DeleteWorkloadIdentity. +message DeleteWorkloadIdentityRequest { + // The name of the workload identity to delete. + string name = 1; +} + +// The request for ListWorkloadIdentities. +message ListWorkloadIdentitiesRequest { + // The maximum number of items to return. + // The server may impose a different page size at its discretion. + int32 page_size = 1; + // The page_token value returned from a previous ListWorkloadIdentities request, if any. + string page_token = 2; +} + +// The response for ListWorkloadIdentities. +message ListWorkloadIdentitiesResponse { + // The page of workload identities that matched the request. + repeated WorkloadIdentity workload_identities = 1; + // Token to retrieve the next page of results, or empty if there are no + // more results in the list. + string next_page_token = 2; +} diff --git a/api/types/constants.go b/api/types/constants.go index 62125faa1bd7a..884035267df51 100644 --- a/api/types/constants.go +++ b/api/types/constants.go @@ -593,6 +593,9 @@ const ( // pair that can be requested by a Teleport User. KindIdentityCenterAccountAssignment = "aws_ic_account_assignment" + // KindWorkloadIdentity is the WorkloadIdentity resource. + KindWorkloadIdentity = "workload_identity" + // MetaNameAccessGraphSettings is the exact name of the singleton resource holding // access graph settings. MetaNameAccessGraphSettings = "access-graph-settings" diff --git a/api/types/events/events.go b/api/types/events/events.go index 19cc44b5e8981..d3f9f0b085ace 100644 --- a/api/types/events/events.go +++ b/api/types/events/events.go @@ -2352,3 +2352,45 @@ func (m *AutoUpdateVersionUpdate) TrimToMaxSize(_ int) AuditEvent { func (m *AutoUpdateVersionDelete) TrimToMaxSize(_ int) AuditEvent { return m } + +func (m *WorkloadIdentityCreate) TrimToMaxSize(maxSize int) AuditEvent { + size := m.Size() + if size <= maxSize { + return m + } + + out := utils.CloneProtoMsg(m) + out.WorkloadIdentityData = nil + + maxSize = adjustedMaxSize(out, maxSize) + + customFieldsCount := m.WorkloadIdentityData.nonEmptyStrs() + maxFieldsSize := maxSizePerField(maxSize, customFieldsCount) + + out.WorkloadIdentityData = m.WorkloadIdentityData.trimToMaxSize(maxFieldsSize) + + return out +} + +func (m *WorkloadIdentityUpdate) TrimToMaxSize(maxSize int) AuditEvent { + size := m.Size() + if size <= maxSize { + return m + } + + out := utils.CloneProtoMsg(m) + out.WorkloadIdentityData = nil + + maxSize = adjustedMaxSize(out, maxSize) + + customFieldsCount := m.WorkloadIdentityData.nonEmptyStrs() + maxFieldsSize := maxSizePerField(maxSize, customFieldsCount) + + out.WorkloadIdentityData = m.WorkloadIdentityData.trimToMaxSize(maxFieldsSize) + + return out +} + +func (m *WorkloadIdentityDelete) TrimToMaxSize(_ int) AuditEvent { + return m +} diff --git a/api/types/events/events.pb.go b/api/types/events/events.pb.go index 8667be1cf5aed..ae7387937b04e 100644 --- a/api/types/events/events.pb.go +++ b/api/types/events/events.pb.go @@ -7839,6 +7839,9 @@ type OneOf struct { // *OneOf_UserTaskUpdate // *OneOf_UserTaskDelete // *OneOf_SFTPSummary + // *OneOf_WorkloadIdentityCreate + // *OneOf_WorkloadIdentityUpdate + // *OneOf_WorkloadIdentityDelete Event isOneOf_Event `protobuf_oneof:"Event"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -8445,6 +8448,15 @@ type OneOf_UserTaskDelete struct { type OneOf_SFTPSummary struct { SFTPSummary *SFTPSummary `protobuf:"bytes,191,opt,name=SFTPSummary,proto3,oneof" json:"SFTPSummary,omitempty"` } +type OneOf_WorkloadIdentityCreate struct { + WorkloadIdentityCreate *WorkloadIdentityCreate `protobuf:"bytes,194,opt,name=WorkloadIdentityCreate,proto3,oneof" json:"WorkloadIdentityCreate,omitempty"` +} +type OneOf_WorkloadIdentityUpdate struct { + WorkloadIdentityUpdate *WorkloadIdentityUpdate `protobuf:"bytes,195,opt,name=WorkloadIdentityUpdate,proto3,oneof" json:"WorkloadIdentityUpdate,omitempty"` +} +type OneOf_WorkloadIdentityDelete struct { + WorkloadIdentityDelete *WorkloadIdentityDelete `protobuf:"bytes,196,opt,name=WorkloadIdentityDelete,proto3,oneof" json:"WorkloadIdentityDelete,omitempty"` +} func (*OneOf_UserLogin) isOneOf_Event() {} func (*OneOf_UserCreate) isOneOf_Event() {} @@ -8633,6 +8645,9 @@ func (*OneOf_UserTaskCreate) isOneOf_Event() {} func (*OneOf_UserTaskUpdate) isOneOf_Event() {} func (*OneOf_UserTaskDelete) isOneOf_Event() {} func (*OneOf_SFTPSummary) isOneOf_Event() {} +func (*OneOf_WorkloadIdentityCreate) isOneOf_Event() {} +func (*OneOf_WorkloadIdentityUpdate) isOneOf_Event() {} +func (*OneOf_WorkloadIdentityDelete) isOneOf_Event() {} func (m *OneOf) GetEvent() isOneOf_Event { if m != nil { @@ -9950,6 +9965,27 @@ func (m *OneOf) GetSFTPSummary() *SFTPSummary { return nil } +func (m *OneOf) GetWorkloadIdentityCreate() *WorkloadIdentityCreate { + if x, ok := m.GetEvent().(*OneOf_WorkloadIdentityCreate); ok { + return x.WorkloadIdentityCreate + } + return nil +} + +func (m *OneOf) GetWorkloadIdentityUpdate() *WorkloadIdentityUpdate { + if x, ok := m.GetEvent().(*OneOf_WorkloadIdentityUpdate); ok { + return x.WorkloadIdentityUpdate + } + return nil +} + +func (m *OneOf) GetWorkloadIdentityDelete() *WorkloadIdentityDelete { + if x, ok := m.GetEvent().(*OneOf_WorkloadIdentityDelete); ok { + return x.WorkloadIdentityDelete + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*OneOf) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -10140,6 +10176,9 @@ func (*OneOf) XXX_OneofWrappers() []interface{} { (*OneOf_UserTaskUpdate)(nil), (*OneOf_UserTaskDelete)(nil), (*OneOf_SFTPSummary)(nil), + (*OneOf_WorkloadIdentityCreate)(nil), + (*OneOf_WorkloadIdentityUpdate)(nil), + (*OneOf_WorkloadIdentityDelete)(nil), } } @@ -14880,6 +14919,154 @@ func (m *UserTaskDelete) XXX_DiscardUnknown() { var xxx_messageInfo_UserTaskDelete proto.InternalMessageInfo +// WorkloadIdentityCreate is emitted when a WorkloadIdentity is created. +type WorkloadIdentityCreate struct { + // Metadata is a common event metadata + Metadata `protobuf:"bytes,1,opt,name=Metadata,proto3,embedded=Metadata" json:""` + // ResourceMetadata is a common resource event metadata + ResourceMetadata `protobuf:"bytes,2,opt,name=Resource,proto3,embedded=Resource" json:""` + // User is a common user event metadata + UserMetadata `protobuf:"bytes,3,opt,name=User,proto3,embedded=User" json:""` + // ConnectionMetadata holds information about the connection + ConnectionMetadata `protobuf:"bytes,4,opt,name=Connection,proto3,embedded=Connection" json:""` + // WorkloadIdentityData is a copy of the WorkloadIdentity resource + WorkloadIdentityData *Struct `protobuf:"bytes,5,opt,name=WorkloadIdentityData,proto3,casttype=Struct" json:"workload_identity_data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WorkloadIdentityCreate) Reset() { *m = WorkloadIdentityCreate{} } +func (m *WorkloadIdentityCreate) String() string { return proto.CompactTextString(m) } +func (*WorkloadIdentityCreate) ProtoMessage() {} +func (*WorkloadIdentityCreate) Descriptor() ([]byte, []int) { + return fileDescriptor_007ba1c3d6266d56, []int{233} +} +func (m *WorkloadIdentityCreate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WorkloadIdentityCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WorkloadIdentityCreate.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 *WorkloadIdentityCreate) XXX_Merge(src proto.Message) { + xxx_messageInfo_WorkloadIdentityCreate.Merge(m, src) +} +func (m *WorkloadIdentityCreate) XXX_Size() int { + return m.Size() +} +func (m *WorkloadIdentityCreate) XXX_DiscardUnknown() { + xxx_messageInfo_WorkloadIdentityCreate.DiscardUnknown(m) +} + +var xxx_messageInfo_WorkloadIdentityCreate proto.InternalMessageInfo + +// WorkloadIdentityUpdate is emitted when a WorkloadIdentity is updated. +type WorkloadIdentityUpdate struct { + // Metadata is a common event metadata + Metadata `protobuf:"bytes,1,opt,name=Metadata,proto3,embedded=Metadata" json:""` + // ResourceMetadata is a common resource event metadata + ResourceMetadata `protobuf:"bytes,2,opt,name=Resource,proto3,embedded=Resource" json:""` + // User is a common user event metadata + UserMetadata `protobuf:"bytes,3,opt,name=User,proto3,embedded=User" json:""` + // ConnectionMetadata holds information about the connection + ConnectionMetadata `protobuf:"bytes,4,opt,name=Connection,proto3,embedded=Connection" json:""` + // WorkloadIdentityData is a copy of the WorkloadIdentity resource + WorkloadIdentityData *Struct `protobuf:"bytes,5,opt,name=WorkloadIdentityData,proto3,casttype=Struct" json:"workload_identity_data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WorkloadIdentityUpdate) Reset() { *m = WorkloadIdentityUpdate{} } +func (m *WorkloadIdentityUpdate) String() string { return proto.CompactTextString(m) } +func (*WorkloadIdentityUpdate) ProtoMessage() {} +func (*WorkloadIdentityUpdate) Descriptor() ([]byte, []int) { + return fileDescriptor_007ba1c3d6266d56, []int{234} +} +func (m *WorkloadIdentityUpdate) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WorkloadIdentityUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WorkloadIdentityUpdate.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 *WorkloadIdentityUpdate) XXX_Merge(src proto.Message) { + xxx_messageInfo_WorkloadIdentityUpdate.Merge(m, src) +} +func (m *WorkloadIdentityUpdate) XXX_Size() int { + return m.Size() +} +func (m *WorkloadIdentityUpdate) XXX_DiscardUnknown() { + xxx_messageInfo_WorkloadIdentityUpdate.DiscardUnknown(m) +} + +var xxx_messageInfo_WorkloadIdentityUpdate proto.InternalMessageInfo + +// WorkloadIdentityDelete is emitted when a WorkloadIdentity is deleted. +type WorkloadIdentityDelete struct { + // Metadata is a common event metadata + Metadata `protobuf:"bytes,1,opt,name=Metadata,proto3,embedded=Metadata" json:""` + // ResourceMetadata is a common resource event metadata + ResourceMetadata `protobuf:"bytes,2,opt,name=Resource,proto3,embedded=Resource" json:""` + // User is a common user event metadata + UserMetadata `protobuf:"bytes,3,opt,name=User,proto3,embedded=User" json:""` + // ConnectionMetadata holds information about the connection + ConnectionMetadata `protobuf:"bytes,4,opt,name=Connection,proto3,embedded=Connection" json:""` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *WorkloadIdentityDelete) Reset() { *m = WorkloadIdentityDelete{} } +func (m *WorkloadIdentityDelete) String() string { return proto.CompactTextString(m) } +func (*WorkloadIdentityDelete) ProtoMessage() {} +func (*WorkloadIdentityDelete) Descriptor() ([]byte, []int) { + return fileDescriptor_007ba1c3d6266d56, []int{235} +} +func (m *WorkloadIdentityDelete) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WorkloadIdentityDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WorkloadIdentityDelete.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 *WorkloadIdentityDelete) XXX_Merge(src proto.Message) { + xxx_messageInfo_WorkloadIdentityDelete.Merge(m, src) +} +func (m *WorkloadIdentityDelete) XXX_Size() int { + return m.Size() +} +func (m *WorkloadIdentityDelete) XXX_DiscardUnknown() { + xxx_messageInfo_WorkloadIdentityDelete.DiscardUnknown(m) +} + +var xxx_messageInfo_WorkloadIdentityDelete proto.InternalMessageInfo + func init() { proto.RegisterEnum("events.UserKind", UserKind_name, UserKind_value) proto.RegisterEnum("events.EventAction", EventAction_name, EventAction_value) @@ -15137,6 +15324,9 @@ func init() { proto.RegisterType((*UserTaskUpdate)(nil), "events.UserTaskUpdate") proto.RegisterType((*UserTaskMetadata)(nil), "events.UserTaskMetadata") proto.RegisterType((*UserTaskDelete)(nil), "events.UserTaskDelete") + proto.RegisterType((*WorkloadIdentityCreate)(nil), "events.WorkloadIdentityCreate") + proto.RegisterType((*WorkloadIdentityUpdate)(nil), "events.WorkloadIdentityUpdate") + proto.RegisterType((*WorkloadIdentityDelete)(nil), "events.WorkloadIdentityDelete") } func init() { @@ -15144,1064 +15334,1070 @@ func init() { } var fileDescriptor_007ba1c3d6266d56 = []byte{ - // 16898 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x78, 0x24, 0xc9, - 0x71, 0x20, 0x86, 0x7e, 0xa0, 0x01, 0x04, 0x1e, 0x03, 0xe4, 0xbc, 0x6a, 0x67, 0x67, 0x17, 0xbb, - 0xb5, 0xe4, 0x70, 0x66, 0xb9, 0x8b, 0xe1, 0xce, 0xce, 0xee, 0x72, 0x5f, 0x5c, 0x36, 0xd0, 0xc0, - 0xa0, 0x67, 0xf0, 0xda, 0x6a, 0xcc, 0x0c, 0x97, 0x12, 0xd9, 0x2a, 0x74, 0x25, 0x1a, 0xb5, 0xd3, - 0x5d, 0xd5, 0xaa, 0xaa, 0x1e, 0x0c, 0xd6, 0x2f, 0x51, 0xd6, 0xe9, 0xa4, 0x13, 0xc5, 0xa3, 0x29, - 0xeb, 0xa4, 0x7b, 0xd8, 0xa6, 0xee, 0x61, 0xeb, 0x74, 0x3a, 0xd1, 0xba, 0x93, 0x25, 0x51, 0x12, - 0x7d, 0x77, 0x96, 0x1f, 0x3c, 0xe9, 0xb3, 0x3e, 0xe9, 0x6c, 0xdf, 0x77, 0x9f, 0x7d, 0x06, 0xcf, - 0xb2, 0xef, 0x0f, 0x3e, 0xfb, 0xfb, 0x64, 0x9b, 0x9f, 0x8f, 0x3e, 0x9f, 0xfd, 0xf9, 0xcb, 0xc8, - 0xac, 0xaa, 0xac, 0x57, 0xe3, 0xb9, 0xc2, 0x82, 0x83, 0x3f, 0x33, 0xe8, 0x88, 0xc8, 0xc8, 0xac, - 0xc8, 0xc8, 0xcc, 0xc8, 0xcc, 0xc8, 0x08, 0xb8, 0xe6, 0xd1, 0x16, 0xed, 0xd8, 0x8e, 0x77, 0xbd, - 0x45, 0x9b, 0x7a, 0x63, 0xeb, 0xba, 0xb7, 0xd5, 0xa1, 0xee, 0x75, 0xfa, 0x90, 0x5a, 0x9e, 0xff, - 0xdf, 0x54, 0xc7, 0xb1, 0x3d, 0x9b, 0x94, 0xf8, 0xaf, 0x4b, 0xe7, 0x9a, 0x76, 0xd3, 0x46, 0xd0, - 0x75, 0xf6, 0x17, 0xc7, 0x5e, 0xba, 0xdc, 0xb4, 0xed, 0x66, 0x8b, 0x5e, 0xc7, 0x5f, 0x6b, 0xdd, - 0xf5, 0xeb, 0xae, 0xe7, 0x74, 0x1b, 0x9e, 0xc0, 0x4e, 0xc6, 0xb1, 0x9e, 0xd9, 0xa6, 0xae, 0xa7, - 0xb7, 0x3b, 0x82, 0xe0, 0xe9, 0x38, 0xc1, 0xa6, 0xa3, 0x77, 0x3a, 0xd4, 0x11, 0x95, 0x5f, 0xfa, - 0x44, 0xd0, 0x4e, 0xbd, 0xd1, 0xa0, 0xae, 0xdb, 0x32, 0x5d, 0xef, 0xfa, 0xc3, 0x97, 0xa4, 0x5f, - 0x82, 0xf0, 0xd9, 0xf4, 0x0f, 0xc2, 0x7f, 0x05, 0xc9, 0x8b, 0xe9, 0x24, 0x7e, 0x8d, 0xb1, 0xaa, - 0xd5, 0xaf, 0xe5, 0x61, 0x70, 0x91, 0x7a, 0xba, 0xa1, 0x7b, 0x3a, 0xb9, 0x0c, 0xfd, 0x55, 0xcb, - 0xa0, 0x8f, 0x94, 0xdc, 0x33, 0xb9, 0xab, 0x85, 0xe9, 0xd2, 0xce, 0xf6, 0x64, 0x9e, 0x9a, 0x1a, - 0x07, 0x92, 0xa7, 0xa0, 0xb8, 0xba, 0xd5, 0xa1, 0x4a, 0xfe, 0x99, 0xdc, 0xd5, 0xa1, 0xe9, 0xa1, - 0x9d, 0xed, 0xc9, 0x7e, 0x14, 0x9a, 0x86, 0x60, 0xf2, 0x2c, 0xe4, 0xab, 0x15, 0xa5, 0x80, 0xc8, - 0x89, 0x9d, 0xed, 0xc9, 0xd1, 0xae, 0x69, 0xbc, 0x60, 0xb7, 0x4d, 0x8f, 0xb6, 0x3b, 0xde, 0x96, - 0x96, 0xaf, 0x56, 0xc8, 0x15, 0x28, 0xce, 0xd8, 0x06, 0x55, 0x8a, 0x48, 0x44, 0x76, 0xb6, 0x27, - 0xc7, 0x1a, 0xb6, 0x41, 0x25, 0x2a, 0xc4, 0x93, 0xcf, 0x42, 0x71, 0xd5, 0x6c, 0x53, 0xa5, 0xff, - 0x99, 0xdc, 0xd5, 0xe1, 0x1b, 0x97, 0xa6, 0xb8, 0xf8, 0xa6, 0x7c, 0xf1, 0x4d, 0xad, 0xfa, 0xf2, - 0x9d, 0x1e, 0xff, 0xf6, 0xf6, 0x64, 0xdf, 0xce, 0xf6, 0x64, 0x91, 0x89, 0xfc, 0xab, 0xdf, 0x99, - 0xcc, 0x69, 0x58, 0x92, 0xbc, 0x05, 0xc3, 0x33, 0xad, 0xae, 0xeb, 0x51, 0x67, 0x49, 0x6f, 0x53, - 0xa5, 0x84, 0x15, 0x5e, 0xda, 0xd9, 0x9e, 0xbc, 0xd0, 0xe0, 0xe0, 0xba, 0xa5, 0xb7, 0xe5, 0x8a, - 0x65, 0x72, 0xf5, 0x37, 0x73, 0x70, 0xa6, 0x46, 0x5d, 0xd7, 0xb4, 0xad, 0x40, 0x36, 0x1f, 0x87, - 0x21, 0x01, 0xaa, 0x56, 0x50, 0x3e, 0x43, 0xd3, 0x03, 0x3b, 0xdb, 0x93, 0x05, 0xd7, 0x34, 0xb4, - 0x10, 0x43, 0x3e, 0x05, 0x03, 0xf7, 0x4d, 0x6f, 0x63, 0x71, 0xae, 0x2c, 0xe4, 0x74, 0x61, 0x67, - 0x7b, 0x92, 0x6c, 0x9a, 0xde, 0x46, 0xbd, 0xbd, 0xae, 0x4b, 0x15, 0xfa, 0x64, 0x64, 0x01, 0xc6, - 0x57, 0x1c, 0xf3, 0xa1, 0xee, 0xd1, 0x3b, 0x74, 0x6b, 0xc5, 0x6e, 0x99, 0x8d, 0x2d, 0x21, 0xc5, - 0x67, 0x76, 0xb6, 0x27, 0x2f, 0x77, 0x38, 0xae, 0xfe, 0x80, 0x6e, 0xd5, 0x3b, 0x88, 0x95, 0x98, - 0x24, 0x4a, 0xaa, 0xbf, 0x55, 0x82, 0x91, 0xbb, 0x2e, 0x75, 0x82, 0x76, 0x5f, 0x81, 0x22, 0xfb, - 0x2d, 0x9a, 0x8c, 0x32, 0xef, 0xba, 0xd4, 0x91, 0x65, 0xce, 0xf0, 0xe4, 0x1a, 0xf4, 0x2f, 0xd8, - 0x4d, 0xd3, 0x12, 0xcd, 0x3e, 0xbb, 0xb3, 0x3d, 0x79, 0xa6, 0xc5, 0x00, 0x12, 0x25, 0xa7, 0x20, - 0x9f, 0x81, 0x91, 0x6a, 0x9b, 0xe9, 0x90, 0x6d, 0xe9, 0x9e, 0xed, 0x88, 0xd6, 0xa2, 0x74, 0x4d, - 0x09, 0x2e, 0x15, 0x8c, 0xd0, 0x93, 0x37, 0x00, 0xca, 0xf7, 0x6b, 0x9a, 0xdd, 0xa2, 0x65, 0x6d, - 0x49, 0x28, 0x03, 0x96, 0xd6, 0x37, 0xdd, 0xba, 0x63, 0xb7, 0x68, 0x5d, 0x77, 0xe4, 0x6a, 0x25, - 0x6a, 0x32, 0x0b, 0x63, 0x65, 0x1c, 0x15, 0x1a, 0xfd, 0xe1, 0x2e, 0x75, 0x3d, 0x57, 0xe9, 0x7f, - 0xa6, 0x70, 0x75, 0x68, 0xfa, 0xa9, 0x9d, 0xed, 0xc9, 0x27, 0xf8, 0x78, 0xa9, 0x3b, 0x02, 0x25, - 0xb1, 0x88, 0x15, 0x22, 0xd3, 0x30, 0x5a, 0xfe, 0xa0, 0xeb, 0xd0, 0xaa, 0x41, 0x2d, 0xcf, 0xf4, - 0xb6, 0x84, 0x86, 0x5c, 0xde, 0xd9, 0x9e, 0x54, 0x74, 0x86, 0xa8, 0x9b, 0x02, 0x23, 0x31, 0x89, - 0x16, 0x21, 0xcb, 0x30, 0x71, 0x6b, 0x66, 0xa5, 0x46, 0x9d, 0x87, 0x66, 0x83, 0x96, 0x1b, 0x0d, - 0xbb, 0x6b, 0x79, 0xca, 0x00, 0xf2, 0x79, 0x76, 0x67, 0x7b, 0xf2, 0xa9, 0x66, 0xa3, 0x53, 0x77, - 0x39, 0xb6, 0xae, 0x73, 0xb4, 0xc4, 0x2c, 0x59, 0x96, 0x7c, 0x1e, 0x46, 0x57, 0x1d, 0xa6, 0x85, - 0x46, 0x85, 0x32, 0xb8, 0x32, 0x88, 0xfa, 0x7f, 0x61, 0x4a, 0xcc, 0x54, 0x1c, 0xea, 0xf7, 0x2c, - 0x6f, 0xac, 0xc7, 0x0b, 0xd4, 0x0d, 0xc4, 0xc9, 0x8d, 0x8d, 0xb0, 0x22, 0x14, 0x14, 0xf6, 0xf1, - 0xa6, 0x43, 0x8d, 0x84, 0xb6, 0x0d, 0x61, 0x9b, 0xaf, 0xed, 0x6c, 0x4f, 0x7e, 0xdc, 0x11, 0x34, - 0xf5, 0x9e, 0x6a, 0x97, 0xc9, 0x8a, 0xcc, 0xc2, 0x20, 0xd3, 0xa6, 0x3b, 0xa6, 0x65, 0x28, 0xf0, - 0x4c, 0xee, 0xea, 0xd8, 0x8d, 0x71, 0xbf, 0xf5, 0x3e, 0x7c, 0xfa, 0xe2, 0xce, 0xf6, 0xe4, 0x59, - 0xa6, 0x83, 0xf5, 0x07, 0xa6, 0x25, 0x4f, 0x11, 0x41, 0x51, 0x36, 0x8a, 0xa6, 0x6d, 0x0f, 0x87, - 0xee, 0x70, 0x38, 0x8a, 0xd6, 0x6c, 0x2f, 0x3e, 0x6c, 0x7d, 0x32, 0x32, 0x03, 0xa3, 0xd3, 0xb6, - 0x57, 0xb5, 0x5c, 0x4f, 0xb7, 0x1a, 0xb4, 0x5a, 0x51, 0x46, 0xb0, 0x1c, 0xaa, 0x05, 0x2b, 0x67, - 0x0a, 0x4c, 0x3d, 0x32, 0x29, 0x45, 0xcb, 0xa8, 0xff, 0xa2, 0x08, 0x63, 0xac, 0x4f, 0xa4, 0xe1, - 0x53, 0x66, 0x33, 0x01, 0x83, 0xb0, 0x5a, 0xdc, 0x8e, 0xde, 0xa0, 0x62, 0x24, 0xe1, 0x57, 0x58, - 0x3e, 0x50, 0xe2, 0x19, 0xa7, 0x27, 0xd7, 0x60, 0x90, 0x83, 0xaa, 0x15, 0x31, 0xb8, 0x46, 0x77, - 0xb6, 0x27, 0x87, 0x5c, 0x84, 0xd5, 0x4d, 0x43, 0x0b, 0xd0, 0x4c, 0xbb, 0xf9, 0xdf, 0xf3, 0xb6, - 0xeb, 0x31, 0xe6, 0x62, 0x6c, 0xe1, 0x67, 0x88, 0x02, 0x1b, 0x02, 0x25, 0x6b, 0x77, 0xb4, 0x10, - 0x79, 0x1d, 0x80, 0x43, 0xca, 0x86, 0xe1, 0x88, 0x01, 0xf6, 0xc4, 0xce, 0xf6, 0xe4, 0x79, 0xc1, - 0x42, 0x37, 0x0c, 0x79, 0x74, 0x4a, 0xc4, 0xa4, 0x0d, 0x23, 0xfc, 0xd7, 0x82, 0xbe, 0x46, 0x5b, - 0x7c, 0x74, 0x0d, 0xdf, 0xb8, 0xea, 0x77, 0x62, 0x54, 0x3a, 0x53, 0x32, 0xe9, 0xac, 0xe5, 0x39, - 0x5b, 0xd3, 0x93, 0x62, 0x42, 0xbe, 0x28, 0xaa, 0x6a, 0x21, 0x4e, 0x9e, 0x0a, 0xe4, 0x32, 0x6c, - 0x9e, 0x9e, 0xb3, 0x9d, 0x4d, 0xdd, 0x31, 0xa8, 0x31, 0xbd, 0x25, 0xcf, 0xd3, 0xeb, 0x3e, 0xb8, - 0xbe, 0x26, 0xab, 0x9e, 0x4c, 0xce, 0x3a, 0x9d, 0x73, 0xab, 0x75, 0xd7, 0x50, 0xe5, 0x06, 0x12, - 0xd2, 0x72, 0xbb, 0x6b, 0x71, 0x35, 0x8b, 0x96, 0x61, 0x53, 0x01, 0x07, 0xdc, 0xa3, 0x0e, 0x9b, - 0xc4, 0x71, 0xd4, 0x89, 0xa9, 0x40, 0x30, 0x79, 0xc8, 0x31, 0x49, 0x1e, 0xa2, 0xc8, 0xa5, 0x77, - 0x60, 0x22, 0x21, 0x0a, 0x32, 0x0e, 0x85, 0x07, 0x74, 0x8b, 0xab, 0x8b, 0xc6, 0xfe, 0x24, 0xe7, - 0xa0, 0xff, 0xa1, 0xde, 0xea, 0x8a, 0x25, 0x54, 0xe3, 0x3f, 0xde, 0xc8, 0x7f, 0x3a, 0xc7, 0x56, - 0x1c, 0x32, 0x63, 0x5b, 0x16, 0x6d, 0x78, 0xf2, 0xa2, 0xf3, 0x2a, 0x0c, 0x2d, 0xd8, 0x0d, 0xbd, - 0x85, 0xfd, 0xc8, 0xf5, 0x4e, 0xd9, 0xd9, 0x9e, 0x3c, 0xc7, 0x3a, 0x70, 0xaa, 0xc5, 0x30, 0x52, - 0x9b, 0x42, 0x52, 0xa6, 0x00, 0x1a, 0x6d, 0xdb, 0x1e, 0xc5, 0x82, 0xf9, 0x50, 0x01, 0xb0, 0xa0, - 0x83, 0x28, 0x59, 0x01, 0x42, 0x62, 0x72, 0x1d, 0x06, 0x57, 0xd8, 0x3a, 0xdb, 0xb0, 0x5b, 0x42, - 0xf9, 0x70, 0x29, 0xc0, 0xb5, 0x57, 0x1e, 0xab, 0x3e, 0x91, 0x3a, 0x0f, 0x63, 0x33, 0x2d, 0x93, - 0x5a, 0x9e, 0xdc, 0x6a, 0x36, 0x92, 0xcb, 0x4d, 0x6a, 0x79, 0x72, 0xab, 0x71, 0xcc, 0xeb, 0x0c, - 0x2a, 0xb7, 0x3a, 0x20, 0x55, 0xff, 0xa0, 0x00, 0x4f, 0xdc, 0xe9, 0xae, 0x51, 0xc7, 0xa2, 0x1e, - 0x75, 0xc5, 0x82, 0x1c, 0x70, 0x5d, 0x82, 0x89, 0x04, 0x52, 0x70, 0xc7, 0x85, 0xf2, 0x41, 0x80, - 0xac, 0x8b, 0x35, 0x5e, 0x9e, 0x6d, 0x13, 0x45, 0xc9, 0x3c, 0x9c, 0x09, 0x81, 0xac, 0x11, 0xae, - 0x92, 0xc7, 0xa5, 0xe4, 0xe9, 0x9d, 0xed, 0xc9, 0x4b, 0x12, 0x37, 0xd6, 0x6c, 0x59, 0x83, 0xe3, - 0xc5, 0xc8, 0x1d, 0x18, 0x0f, 0x41, 0xb7, 0x1c, 0xbb, 0xdb, 0x71, 0x95, 0x02, 0xb2, 0x9a, 0xdc, - 0xd9, 0x9e, 0x7c, 0x52, 0x62, 0xd5, 0x44, 0xa4, 0xbc, 0x80, 0xc7, 0x0b, 0x92, 0x1f, 0xcb, 0xc9, - 0xdc, 0xc4, 0x28, 0x2c, 0xe2, 0x28, 0x7c, 0xcd, 0x1f, 0x85, 0x99, 0x42, 0x9a, 0x8a, 0x97, 0x14, - 0x83, 0x32, 0xd6, 0x8c, 0xc4, 0xa0, 0x4c, 0xd4, 0x78, 0x69, 0x06, 0xce, 0xa7, 0xf2, 0xda, 0x97, - 0x56, 0xff, 0xf3, 0x82, 0xcc, 0x65, 0xc5, 0x36, 0x82, 0xce, 0x5c, 0x96, 0x3b, 0x73, 0xc5, 0x36, - 0x70, 0xaa, 0xcf, 0x85, 0x6b, 0xa7, 0xd4, 0xd8, 0x8e, 0x6d, 0xc4, 0x67, 0xfd, 0x64, 0x59, 0xf2, - 0x45, 0xb8, 0x90, 0x00, 0xf2, 0xe9, 0x9a, 0x6b, 0xff, 0x95, 0x9d, 0xed, 0x49, 0x35, 0x85, 0x6b, - 0x7c, 0xf6, 0xce, 0xe0, 0x42, 0x74, 0xb8, 0x28, 0x49, 0xdd, 0xb6, 0x3c, 0xdd, 0xb4, 0x84, 0x71, - 0xc9, 0x47, 0xc9, 0x27, 0x76, 0xb6, 0x27, 0x9f, 0x93, 0x75, 0xd0, 0xa7, 0x89, 0x37, 0x3e, 0x8b, - 0x0f, 0x31, 0x40, 0x49, 0x41, 0x55, 0xdb, 0x7a, 0xd3, 0xb7, 0x98, 0xaf, 0xee, 0x6c, 0x4f, 0x7e, - 0x2c, 0xb5, 0x0e, 0x93, 0x51, 0xc9, 0x2b, 0x74, 0x16, 0x27, 0xa2, 0x01, 0x09, 0x71, 0x4b, 0xb6, - 0x41, 0xf1, 0x1b, 0xfa, 0x91, 0xbf, 0xba, 0xb3, 0x3d, 0xf9, 0xb4, 0xc4, 0xdf, 0xb2, 0x0d, 0x1a, - 0x6f, 0x7e, 0x4a, 0x69, 0xf5, 0x37, 0x0b, 0xf0, 0x74, 0xad, 0xbc, 0xb8, 0x50, 0x35, 0x7c, 0x93, - 0x66, 0xc5, 0xb1, 0x1f, 0x9a, 0x86, 0x34, 0x7a, 0xd7, 0xe0, 0x62, 0x0c, 0x35, 0x8b, 0x56, 0x54, - 0x60, 0x4c, 0xe3, 0xb7, 0xf9, 0xe6, 0x52, 0x47, 0xd0, 0xd4, 0xb9, 0xa9, 0x15, 0x5d, 0xb4, 0xb3, - 0x18, 0xb1, 0x3e, 0x8a, 0xa1, 0x6a, 0x1b, 0xb6, 0xe3, 0x35, 0xba, 0x9e, 0x50, 0x02, 0xec, 0xa3, - 0x44, 0x1d, 0xae, 0x20, 0xea, 0x51, 0x85, 0xcf, 0x87, 0xfc, 0x64, 0x0e, 0xc6, 0xcb, 0x9e, 0xe7, - 0x98, 0x6b, 0x5d, 0x8f, 0x2e, 0xea, 0x9d, 0x8e, 0x69, 0x35, 0x71, 0xac, 0x0f, 0xdf, 0x78, 0x2b, - 0x58, 0x23, 0x7b, 0x4a, 0x62, 0x2a, 0x5e, 0x5c, 0x1a, 0xa2, 0xba, 0x8f, 0xaa, 0xb7, 0x39, 0x4e, - 0x1e, 0xa2, 0xf1, 0x72, 0x6c, 0x88, 0xa6, 0xf2, 0xda, 0xd7, 0x10, 0xfd, 0x5a, 0x01, 0x2e, 0x2f, - 0x3f, 0xf0, 0x74, 0x8d, 0xba, 0x76, 0xd7, 0x69, 0x50, 0xf7, 0x6e, 0xc7, 0xd0, 0x3d, 0x1a, 0x8e, - 0xd4, 0x49, 0xe8, 0x2f, 0x1b, 0x06, 0x35, 0x90, 0x5d, 0x3f, 0xdf, 0xf6, 0xe9, 0x0c, 0xa0, 0x71, - 0x38, 0xf9, 0x38, 0x0c, 0x88, 0x32, 0xc8, 0xbd, 0x7f, 0x7a, 0x78, 0x67, 0x7b, 0x72, 0xa0, 0xcb, - 0x41, 0x9a, 0x8f, 0x63, 0x64, 0x15, 0xda, 0xa2, 0x8c, 0xac, 0x10, 0x92, 0x19, 0x1c, 0xa4, 0xf9, - 0x38, 0xf2, 0x2e, 0x8c, 0x21, 0xdb, 0xa0, 0x3d, 0x62, 0xee, 0x3b, 0xe7, 0x4b, 0x57, 0x6e, 0x2c, - 0x5f, 0x9a, 0xb0, 0x35, 0x75, 0xc7, 0x2f, 0xa0, 0xc5, 0x18, 0x90, 0xfb, 0x30, 0x2e, 0x1a, 0x11, - 0x32, 0xed, 0xef, 0xc1, 0xf4, 0xfc, 0xce, 0xf6, 0xe4, 0x84, 0x68, 0xbf, 0xc4, 0x36, 0xc1, 0x84, - 0x31, 0x16, 0xcd, 0x0e, 0x19, 0x97, 0x76, 0x63, 0x2c, 0xbe, 0x58, 0x66, 0x1c, 0x67, 0xa2, 0xbe, - 0x07, 0x23, 0x72, 0x41, 0x72, 0x01, 0xb7, 0xd6, 0x7c, 0x9c, 0xe0, 0xa6, 0xdc, 0x34, 0x70, 0x3f, - 0xfd, 0x12, 0x0c, 0x57, 0xa8, 0xdb, 0x70, 0xcc, 0x0e, 0xb3, 0x1a, 0x84, 0x92, 0x9f, 0xd9, 0xd9, - 0x9e, 0x1c, 0x36, 0x42, 0xb0, 0x26, 0xd3, 0xa8, 0xff, 0x57, 0x0e, 0x2e, 0x30, 0xde, 0x65, 0xd7, - 0x35, 0x9b, 0x56, 0x5b, 0x5e, 0xb6, 0x5f, 0x80, 0x52, 0x0d, 0xeb, 0x13, 0x35, 0x9d, 0xdb, 0xd9, - 0x9e, 0x1c, 0xe7, 0x2d, 0x90, 0xf4, 0x50, 0xd0, 0x04, 0xfb, 0xca, 0xfc, 0x2e, 0xfb, 0x4a, 0x66, - 0xd2, 0x7a, 0xba, 0xe3, 0x99, 0x56, 0xb3, 0xe6, 0xe9, 0x5e, 0xd7, 0x8d, 0x98, 0xb4, 0x02, 0x53, - 0x77, 0x11, 0x15, 0x31, 0x69, 0x23, 0x85, 0xc8, 0x3b, 0x30, 0x32, 0x6b, 0x19, 0x21, 0x13, 0x3e, - 0x21, 0x3e, 0xc9, 0x2c, 0x4d, 0x8a, 0xf0, 0x24, 0x8b, 0x48, 0x01, 0xf5, 0x6f, 0xe7, 0x40, 0xe1, - 0x9b, 0xc0, 0x05, 0xd3, 0xf5, 0x16, 0x69, 0x7b, 0x4d, 0x9a, 0x9d, 0xe6, 0xfc, 0x5d, 0x25, 0xc3, - 0x49, 0x6b, 0x11, 0x9a, 0x02, 0x62, 0x57, 0xd9, 0x32, 0xdd, 0xc4, 0xf6, 0x23, 0x56, 0x8a, 0x54, - 0x61, 0x80, 0x73, 0xe6, 0xb6, 0xc4, 0xf0, 0x0d, 0xc5, 0x57, 0x84, 0x78, 0xd5, 0x5c, 0x19, 0xda, - 0x9c, 0x58, 0xde, 0xd0, 0x88, 0xf2, 0xea, 0xd7, 0x0b, 0x30, 0x1e, 0x2f, 0x44, 0xee, 0xc3, 0xe0, - 0x6d, 0xdb, 0xb4, 0xa8, 0xb1, 0x6c, 0x61, 0x0b, 0x7b, 0x1f, 0x8e, 0xf8, 0xb6, 0xf8, 0xd9, 0xf7, - 0xb1, 0x4c, 0x5d, 0xb6, 0x60, 0xf1, 0xac, 0x24, 0x60, 0x46, 0x3e, 0x0f, 0x43, 0xcc, 0x06, 0x7c, - 0x88, 0x9c, 0xf3, 0xbb, 0x72, 0x7e, 0x46, 0x70, 0x3e, 0xe7, 0xf0, 0x42, 0x49, 0xd6, 0x21, 0x3b, - 0xa6, 0x57, 0x1a, 0xd5, 0x5d, 0xdb, 0x12, 0x3d, 0x8f, 0x7a, 0xe5, 0x20, 0x44, 0xd6, 0x2b, 0x4e, - 0xc3, 0x4c, 0x57, 0xfe, 0xb1, 0xd8, 0x0d, 0xd2, 0xde, 0x85, 0xcb, 0x2a, 0xde, 0x03, 0x12, 0x31, - 0xb1, 0xe0, 0x8c, 0x10, 0xe8, 0x86, 0xd9, 0x41, 0xab, 0x1f, 0xd7, 0xb5, 0xb1, 0x1b, 0x57, 0xa6, - 0xfc, 0x43, 0xb1, 0x29, 0xe9, 0x48, 0xed, 0xe1, 0x4b, 0x53, 0x8b, 0x01, 0x39, 0xee, 0x4c, 0x51, - 0x27, 0x63, 0x2c, 0xe4, 0xde, 0x6e, 0x47, 0xc8, 0xd5, 0x1f, 0xcf, 0xc3, 0x8b, 0x61, 0x17, 0x69, - 0xf4, 0xa1, 0x49, 0x37, 0x43, 0x8e, 0x62, 0x8f, 0xcc, 0x86, 0x98, 0x3b, 0xb3, 0xa1, 0x5b, 0x4d, - 0x6a, 0x90, 0x6b, 0xd0, 0xaf, 0xd9, 0x2d, 0xea, 0x2a, 0x39, 0x34, 0x0f, 0x71, 0xfa, 0x72, 0x18, - 0x40, 0x3e, 0x64, 0x41, 0x0a, 0x62, 0x43, 0x69, 0xd5, 0xd1, 0x4d, 0xcf, 0xd7, 0xa4, 0x72, 0x52, - 0x93, 0xf6, 0x50, 0xe3, 0x14, 0xe7, 0xc1, 0xd7, 0x18, 0x14, 0xbc, 0x87, 0x00, 0x59, 0xf0, 0x9c, - 0xe4, 0xd2, 0xeb, 0x30, 0x2c, 0x11, 0xef, 0x6b, 0x11, 0xf9, 0x66, 0x51, 0x1e, 0x5b, 0x7e, 0xb3, - 0xc4, 0xd8, 0xba, 0xce, 0xc6, 0x84, 0xeb, 0x32, 0x2b, 0x86, 0x0f, 0x2a, 0xa1, 0xf9, 0x08, 0x8a, - 0x6a, 0x3e, 0x82, 0xc8, 0xcb, 0x30, 0xc8, 0x59, 0x04, 0xfb, 0x65, 0xdc, 0x6b, 0x3b, 0x08, 0x8b, - 0x9a, 0x02, 0x01, 0x21, 0xf9, 0xa5, 0x1c, 0x3c, 0xd5, 0x53, 0x12, 0xa8, 0x7c, 0xc3, 0x37, 0x5e, - 0x39, 0x90, 0x18, 0xa7, 0x5f, 0xdc, 0xd9, 0x9e, 0xbc, 0x26, 0x69, 0x86, 0x23, 0xd1, 0xd4, 0x1b, - 0x9c, 0x48, 0x6a, 0x57, 0xef, 0xa6, 0x30, 0x63, 0x95, 0x57, 0x3a, 0x87, 0x47, 0x55, 0x56, 0x63, - 0xcb, 0x6f, 0x64, 0x31, 0x34, 0x56, 0xc5, 0xf7, 0xae, 0xfb, 0x24, 0x29, 0xd5, 0x64, 0x70, 0x21, - 0x0d, 0xb8, 0xc8, 0x31, 0x15, 0x7d, 0x6b, 0x79, 0x7d, 0xd1, 0xb6, 0xbc, 0x0d, 0xbf, 0x82, 0x7e, - 0xf9, 0xac, 0x07, 0x2b, 0x30, 0xf4, 0xad, 0xba, 0xbd, 0x5e, 0x6f, 0x33, 0xaa, 0x94, 0x3a, 0xb2, - 0x38, 0xb1, 0x89, 0x5d, 0x8c, 0x71, 0x7f, 0xca, 0x2b, 0x85, 0x27, 0x71, 0xfe, 0xbc, 0x90, 0x9c, - 0xe0, 0x62, 0x85, 0xd4, 0x2a, 0x8c, 0x2c, 0xd8, 0x8d, 0x07, 0x81, 0xba, 0xbc, 0x0e, 0xa5, 0x55, - 0xdd, 0x69, 0x52, 0x0f, 0x65, 0x31, 0x7c, 0x63, 0x62, 0x8a, 0x9f, 0x6e, 0x33, 0x22, 0x8e, 0x98, - 0x1e, 0x13, 0xb3, 0x4f, 0xc9, 0xc3, 0xdf, 0x9a, 0x28, 0xa0, 0x7e, 0xa7, 0x1f, 0x46, 0xc4, 0x49, - 0x2c, 0xae, 0x1e, 0xe4, 0x8d, 0xf0, 0x6c, 0x5b, 0x4c, 0x97, 0xc1, 0x69, 0x54, 0x70, 0x8a, 0x36, - 0xc2, 0x98, 0xfd, 0xe1, 0xf6, 0x64, 0x6e, 0x67, 0x7b, 0xb2, 0x4f, 0x1b, 0x94, 0x36, 0xb1, 0xe1, - 0xfa, 0x26, 0x2d, 0xe8, 0xf2, 0xd9, 0x6a, 0xac, 0x2c, 0x5f, 0xef, 0xde, 0x81, 0x01, 0xd1, 0x06, - 0xa1, 0x71, 0x17, 0xc3, 0xb3, 0x93, 0xc8, 0x89, 0x72, 0xac, 0xb4, 0x5f, 0x8a, 0xbc, 0x05, 0x25, - 0x7e, 0x96, 0x20, 0x04, 0x70, 0x21, 0xfd, 0xec, 0x25, 0x56, 0x5c, 0x94, 0x21, 0xf3, 0x00, 0xe1, - 0x39, 0x42, 0x70, 0x80, 0x2e, 0x38, 0x24, 0x4f, 0x18, 0x62, 0x5c, 0xa4, 0xb2, 0xe4, 0x55, 0x18, - 0x59, 0xa5, 0x4e, 0xdb, 0xb4, 0xf4, 0x56, 0xcd, 0xfc, 0xc0, 0x3f, 0x43, 0xc7, 0x85, 0xde, 0x35, - 0x3f, 0x90, 0x47, 0x6e, 0x84, 0x8e, 0x7c, 0x21, 0x6d, 0x9f, 0x3e, 0x80, 0x0d, 0x79, 0x76, 0xd7, - 0x0d, 0x6c, 0xac, 0x3d, 0x29, 0xdb, 0xf6, 0x77, 0x61, 0x34, 0xb2, 0x45, 0x13, 0x87, 0xa4, 0x4f, - 0x25, 0x59, 0x4b, 0xfb, 0xcd, 0x18, 0xdb, 0x28, 0x07, 0xa6, 0xc9, 0x55, 0xcb, 0xf4, 0x4c, 0xbd, - 0x35, 0x63, 0xb7, 0xdb, 0xba, 0x65, 0x28, 0x43, 0xa1, 0x26, 0x9b, 0x1c, 0x53, 0x6f, 0x70, 0x94, - 0xac, 0xc9, 0xd1, 0x42, 0xe4, 0x0e, 0x8c, 0x8b, 0x3e, 0xd4, 0x68, 0xc3, 0x76, 0x98, 0xed, 0x81, - 0x67, 0xa0, 0xe2, 0x18, 0xc0, 0xe5, 0xb8, 0xba, 0xe3, 0x23, 0x65, 0xe3, 0x3e, 0x5e, 0xf0, 0x76, - 0x71, 0x70, 0x78, 0x7c, 0x24, 0x7e, 0x6c, 0xad, 0xfe, 0xcd, 0x02, 0x0c, 0x0b, 0x52, 0xb6, 0x74, - 0x9f, 0x2a, 0xf8, 0x61, 0x14, 0x3c, 0x55, 0x51, 0x4b, 0x47, 0xa5, 0xa8, 0xea, 0x97, 0xf3, 0xc1, - 0x6c, 0xb4, 0xe2, 0x98, 0xd6, 0xe1, 0x66, 0xa3, 0x2b, 0x00, 0x33, 0x1b, 0x5d, 0xeb, 0x01, 0xbf, - 0x9e, 0xcb, 0x87, 0xd7, 0x73, 0x0d, 0x53, 0x93, 0x30, 0xe4, 0x29, 0x28, 0x56, 0x18, 0x7f, 0xd6, - 0x33, 0x23, 0xd3, 0x43, 0xdf, 0xe6, 0x9c, 0x72, 0x2f, 0x6a, 0x08, 0x66, 0x9b, 0xb9, 0xe9, 0x2d, - 0x8f, 0x72, 0xf3, 0xb9, 0xc0, 0x37, 0x73, 0x6b, 0x0c, 0xa0, 0x71, 0x38, 0xb9, 0x09, 0x13, 0x15, - 0xda, 0xd2, 0xb7, 0x16, 0xcd, 0x56, 0xcb, 0x74, 0x69, 0xc3, 0xb6, 0x0c, 0x17, 0x85, 0x2c, 0xaa, - 0x6b, 0xbb, 0x5a, 0x92, 0x80, 0xa8, 0x50, 0x5a, 0x5e, 0x5f, 0x77, 0xa9, 0x87, 0xe2, 0x2b, 0x4c, - 0x03, 0x9b, 0x9c, 0x6d, 0x84, 0x68, 0x02, 0xa3, 0x7e, 0x23, 0xc7, 0x76, 0x4b, 0xee, 0x03, 0xcf, - 0xee, 0x04, 0x5a, 0x7e, 0x28, 0x91, 0x5c, 0x0b, 0xed, 0x8a, 0x3c, 0x7e, 0xed, 0x19, 0xf1, 0xb5, - 0x03, 0xc2, 0xb6, 0x08, 0x2d, 0x8a, 0xd4, 0xaf, 0x2a, 0xec, 0xf2, 0x55, 0xea, 0x9f, 0xe4, 0xe1, - 0xa2, 0x68, 0xf1, 0x4c, 0xcb, 0xec, 0xac, 0xd9, 0xba, 0x63, 0x68, 0xb4, 0x41, 0xcd, 0x87, 0xf4, - 0x64, 0x0e, 0xbc, 0xe8, 0xd0, 0x29, 0x1e, 0x62, 0xe8, 0xdc, 0xc0, 0x8d, 0x27, 0x93, 0x0c, 0x1e, - 0x30, 0x73, 0xa3, 0x62, 0x7c, 0x67, 0x7b, 0x72, 0xc4, 0xe0, 0x60, 0xbc, 0x62, 0xd0, 0x64, 0x22, - 0xa6, 0x24, 0x0b, 0xd4, 0x6a, 0x7a, 0x1b, 0xa8, 0x24, 0xfd, 0x5c, 0x49, 0x5a, 0x08, 0xd1, 0x04, - 0x46, 0xfd, 0xdf, 0xf2, 0x70, 0x2e, 0x2e, 0xf2, 0x1a, 0xb5, 0x8c, 0x53, 0x79, 0x7f, 0x38, 0xf2, - 0xfe, 0x6e, 0x01, 0x9e, 0x14, 0x65, 0x6a, 0x1b, 0xba, 0x43, 0x8d, 0x8a, 0xe9, 0xd0, 0x86, 0x67, - 0x3b, 0x5b, 0x27, 0xd8, 0x80, 0x3a, 0x3a, 0xb1, 0xdf, 0x84, 0x92, 0x38, 0x6e, 0xe0, 0xeb, 0xcc, - 0x58, 0xd0, 0x12, 0x84, 0x26, 0x56, 0x28, 0x7e, 0x54, 0x11, 0xeb, 0xac, 0xd2, 0x5e, 0x3a, 0xeb, - 0xd3, 0x30, 0x1a, 0x88, 0x1e, 0x37, 0xbe, 0x03, 0xa1, 0xb5, 0x65, 0xf8, 0x08, 0xdc, 0xfb, 0x6a, - 0x51, 0x42, 0xac, 0xcd, 0x07, 0x54, 0x2b, 0x68, 0x0d, 0x8d, 0x8a, 0xda, 0x82, 0x72, 0xa6, 0xa1, - 0xc9, 0x44, 0xea, 0x76, 0x11, 0x2e, 0xa5, 0x77, 0xbb, 0x46, 0x75, 0xe3, 0xb4, 0xd7, 0xbf, 0x2f, - 0x7b, 0x9d, 0x3c, 0x0b, 0xc5, 0x15, 0xdd, 0xdb, 0x10, 0xd7, 0xfd, 0x78, 0x07, 0xbd, 0x6e, 0xb6, - 0x68, 0xbd, 0xa3, 0x7b, 0x1b, 0x1a, 0xa2, 0xa4, 0x39, 0x03, 0x90, 0x63, 0xca, 0x9c, 0x21, 0x2d, - 0xf6, 0xc3, 0xcf, 0xe4, 0xae, 0x16, 0x53, 0x17, 0xfb, 0xef, 0x14, 0xb3, 0xe6, 0x95, 0xfb, 0x8e, - 0xe9, 0xd1, 0x53, 0x0d, 0x3b, 0xd5, 0xb0, 0x43, 0x6a, 0xd8, 0x3f, 0xca, 0xc3, 0x68, 0xb0, 0x69, - 0x7a, 0x9f, 0x36, 0x8e, 0x67, 0xad, 0x0a, 0xb7, 0x32, 0x85, 0x43, 0x6f, 0x65, 0x0e, 0xa3, 0x50, - 0x6a, 0x70, 0xc4, 0xca, 0x4d, 0x03, 0x94, 0x18, 0x3f, 0x62, 0x0d, 0x0e, 0x56, 0x9f, 0x85, 0x81, - 0x45, 0xfd, 0x91, 0xd9, 0xee, 0xb6, 0x85, 0x95, 0x8e, 0xee, 0x6b, 0x6d, 0xfd, 0x91, 0xe6, 0xc3, - 0xd5, 0xff, 0x36, 0x07, 0x63, 0x42, 0xa8, 0x82, 0xf9, 0xa1, 0xa4, 0x1a, 0x4a, 0x27, 0x7f, 0x68, - 0xe9, 0x14, 0x0e, 0x2e, 0x1d, 0xf5, 0xaf, 0x14, 0x40, 0x99, 0x33, 0x5b, 0x74, 0xd5, 0xd1, 0x2d, - 0x77, 0x9d, 0x3a, 0x62, 0x3b, 0x3d, 0xcb, 0x58, 0x1d, 0xea, 0x03, 0xa5, 0x29, 0x25, 0x7f, 0xa0, - 0x29, 0xe5, 0x93, 0x30, 0x24, 0x1a, 0x13, 0xb8, 0x4e, 0xe2, 0xa8, 0x71, 0x7c, 0xa0, 0x16, 0xe2, - 0x19, 0x71, 0xb9, 0xd3, 0x71, 0xec, 0x87, 0xd4, 0xe1, 0xb7, 0x62, 0x82, 0x58, 0xf7, 0x81, 0x5a, - 0x88, 0x97, 0x38, 0x53, 0xdf, 0x5e, 0x94, 0x39, 0x53, 0x47, 0x0b, 0xf1, 0xe4, 0x2a, 0x0c, 0x2e, - 0xd8, 0x0d, 0x1d, 0x05, 0xcd, 0xa7, 0x95, 0x91, 0x9d, 0xed, 0xc9, 0xc1, 0x96, 0x80, 0x69, 0x01, - 0x96, 0x51, 0x56, 0xec, 0x4d, 0xab, 0x65, 0xeb, 0xdc, 0xd9, 0x66, 0x90, 0x53, 0x1a, 0x02, 0xa6, - 0x05, 0x58, 0x46, 0xc9, 0x64, 0x8e, 0x4e, 0x4c, 0x83, 0x21, 0xcf, 0x75, 0x01, 0xd3, 0x02, 0xac, - 0xfa, 0x8d, 0x22, 0xd3, 0x5e, 0xd7, 0xfc, 0xe0, 0xb1, 0x5f, 0x17, 0xc2, 0x01, 0xd3, 0x7f, 0x80, - 0x01, 0xf3, 0xd8, 0x1c, 0xd8, 0xa9, 0xff, 0x62, 0x00, 0x40, 0x48, 0x7f, 0xf6, 0x74, 0x73, 0x78, - 0x38, 0xad, 0xa9, 0xc0, 0xc4, 0xac, 0xb5, 0xa1, 0x5b, 0x0d, 0x6a, 0x84, 0xc7, 0x96, 0x25, 0x1c, - 0xda, 0xe8, 0x74, 0x49, 0x05, 0x32, 0x3c, 0xb7, 0xd4, 0x92, 0x05, 0xc8, 0x4b, 0x30, 0x5c, 0xb5, - 0x3c, 0xea, 0xe8, 0x0d, 0xcf, 0x7c, 0x48, 0xc5, 0xd4, 0x80, 0x37, 0xd1, 0x66, 0x08, 0xd6, 0x64, - 0x1a, 0x72, 0x13, 0x46, 0x56, 0x74, 0xc7, 0x33, 0x1b, 0x66, 0x47, 0xb7, 0x3c, 0x57, 0x19, 0xc4, - 0x19, 0x0d, 0x2d, 0x8c, 0x8e, 0x04, 0xd7, 0x22, 0x54, 0xe4, 0x0b, 0x30, 0x84, 0x5b, 0x53, 0xf4, - 0x0f, 0x1f, 0xda, 0xf5, 0xa2, 0xf2, 0xb9, 0xd0, 0x1d, 0x91, 0x9f, 0xbe, 0xe2, 0x8d, 0x73, 0xfc, - 0xae, 0x32, 0xe0, 0x48, 0x3e, 0x07, 0x03, 0xb3, 0x96, 0x81, 0xcc, 0x61, 0x57, 0xe6, 0xaa, 0x60, - 0x7e, 0x21, 0x64, 0x6e, 0x77, 0x62, 0xbc, 0x7d, 0x76, 0xe9, 0xa3, 0x6c, 0xf8, 0xc3, 0x1b, 0x65, - 0x23, 0x1f, 0xc2, 0xb1, 0xf8, 0xe8, 0x51, 0x1d, 0x8b, 0x8f, 0x1d, 0xf0, 0x58, 0x5c, 0xfd, 0x00, - 0x86, 0xa7, 0x57, 0xe6, 0x82, 0xd1, 0xfb, 0x04, 0x14, 0x56, 0x84, 0x67, 0x44, 0x91, 0xdb, 0x33, - 0x1d, 0xd3, 0xd0, 0x18, 0x8c, 0x5c, 0x83, 0xc1, 0x19, 0x74, 0xb7, 0x13, 0xb7, 0x88, 0x45, 0xbe, - 0xfe, 0x35, 0x10, 0x86, 0x5e, 0xb7, 0x3e, 0x9a, 0x7c, 0x1c, 0x06, 0x56, 0x1c, 0xbb, 0xe9, 0xe8, - 0x6d, 0xb1, 0x06, 0xa3, 0x6b, 0x4a, 0x87, 0x83, 0x34, 0x1f, 0xa7, 0xfe, 0x4c, 0xce, 0x37, 0xdb, - 0x59, 0x89, 0x5a, 0x17, 0x8f, 0xe6, 0xb1, 0xee, 0x41, 0x5e, 0xc2, 0xe5, 0x20, 0xcd, 0xc7, 0x91, - 0x6b, 0xd0, 0x3f, 0xeb, 0x38, 0xb6, 0x23, 0xfb, 0xd4, 0x53, 0x06, 0x90, 0xaf, 0x7b, 0x91, 0x82, - 0xbc, 0x06, 0xc3, 0x7c, 0xce, 0xe1, 0x27, 0x9a, 0x85, 0x5e, 0x37, 0xa5, 0x32, 0xa5, 0xfa, 0xbb, - 0x05, 0xc9, 0x66, 0xe3, 0x12, 0x7f, 0x0c, 0x6f, 0x05, 0x5e, 0x86, 0xc2, 0xf4, 0xca, 0x9c, 0x98, - 0x00, 0xcf, 0xfa, 0x45, 0x25, 0x55, 0x89, 0x95, 0x63, 0xd4, 0xe4, 0x32, 0x14, 0x57, 0x98, 0xfa, - 0x94, 0x50, 0x3d, 0x06, 0x77, 0xb6, 0x27, 0x8b, 0x1d, 0xa6, 0x3f, 0x08, 0x45, 0x2c, 0xdb, 0xcc, - 0xf0, 0x1d, 0x13, 0xc7, 0x86, 0xfb, 0x98, 0xcb, 0x50, 0x2c, 0x3b, 0xcd, 0x87, 0x62, 0xd6, 0x42, - 0xac, 0xee, 0x34, 0x1f, 0x6a, 0x08, 0x25, 0xd7, 0x01, 0x34, 0xea, 0x75, 0x1d, 0x0b, 0x9f, 0xbb, - 0x0c, 0xe1, 0xf9, 0x1b, 0xce, 0x86, 0x0e, 0x42, 0xeb, 0x0d, 0xdb, 0xa0, 0x9a, 0x44, 0xa2, 0xfe, - 0x8d, 0xf0, 0x62, 0xa7, 0x62, 0xba, 0x0f, 0x4e, 0xbb, 0x70, 0x1f, 0x5d, 0xa8, 0x8b, 0x23, 0xce, - 0x64, 0x27, 0x4d, 0x42, 0xff, 0x5c, 0x4b, 0x6f, 0xba, 0xd8, 0x87, 0xc2, 0x77, 0x6d, 0x9d, 0x01, - 0x34, 0x0e, 0x8f, 0xf5, 0xd3, 0xe0, 0xee, 0xfd, 0xf4, 0x73, 0xfd, 0xc1, 0x68, 0x5b, 0xa2, 0xde, - 0xa6, 0xed, 0x9c, 0x76, 0xd5, 0x5e, 0xbb, 0xea, 0x0a, 0x0c, 0xd4, 0x9c, 0x86, 0x74, 0x74, 0x81, - 0xfb, 0x01, 0xd7, 0x69, 0xf0, 0x63, 0x0b, 0x1f, 0xc9, 0xe8, 0x2a, 0xae, 0x87, 0x74, 0x03, 0x21, - 0x9d, 0xe1, 0x7a, 0x82, 0x4e, 0x20, 0x05, 0xdd, 0x8a, 0xed, 0x78, 0xa2, 0xe3, 0x02, 0xba, 0x8e, - 0xed, 0x78, 0x9a, 0x8f, 0x24, 0x9f, 0x04, 0x58, 0x9d, 0x59, 0xf1, 0x9d, 0xfb, 0x87, 0x42, 0xdf, - 0x43, 0xe1, 0xd5, 0xaf, 0x49, 0x68, 0xb2, 0x0a, 0x43, 0xcb, 0x1d, 0xea, 0xf0, 0xad, 0x10, 0x7f, - 0xc0, 0xf2, 0x89, 0x98, 0x68, 0x45, 0xbf, 0x4f, 0x89, 0xff, 0x03, 0x72, 0xbe, 0xbe, 0xd8, 0xfe, - 0x4f, 0x2d, 0x64, 0x44, 0x5e, 0x83, 0x52, 0x99, 0xdb, 0x79, 0xc3, 0xc8, 0x32, 0x10, 0x19, 0x6e, - 0x41, 0x39, 0x8a, 0xef, 0xd9, 0x75, 0xfc, 0x5b, 0x13, 0xe4, 0xea, 0x35, 0x18, 0x8f, 0x57, 0x43, - 0x86, 0x61, 0x60, 0x66, 0x79, 0x69, 0x69, 0x76, 0x66, 0x75, 0xbc, 0x8f, 0x0c, 0x42, 0xb1, 0x36, - 0xbb, 0x54, 0x19, 0xcf, 0xa9, 0xbf, 0x2c, 0xcd, 0x20, 0x4c, 0xb5, 0x4e, 0xaf, 0x86, 0x0f, 0x75, - 0xdf, 0x32, 0x8e, 0xf7, 0xa1, 0x78, 0x62, 0xd0, 0x36, 0x3d, 0x8f, 0x1a, 0x62, 0x95, 0xc0, 0xfb, - 0x42, 0xef, 0x91, 0x96, 0xc0, 0x93, 0x17, 0x60, 0x14, 0x61, 0xe2, 0x8a, 0x90, 0xef, 0x8f, 0x45, - 0x01, 0xe7, 0x91, 0x16, 0x45, 0xaa, 0xbf, 0x1f, 0xde, 0x0e, 0x2f, 0x50, 0xfd, 0xa4, 0xde, 0x28, - 0x7e, 0x44, 0xfa, 0x4b, 0xfd, 0x57, 0x45, 0xfe, 0xe4, 0x84, 0xbf, 0x4f, 0x3c, 0x0e, 0x51, 0x86, - 0x47, 0xba, 0x85, 0x7d, 0x1c, 0xe9, 0xbe, 0x00, 0xa5, 0x45, 0xea, 0x6d, 0xd8, 0xbe, 0xe3, 0x17, - 0x7a, 0xe8, 0xb5, 0x11, 0x22, 0x7b, 0xe8, 0x71, 0x1a, 0xf2, 0x00, 0x88, 0xff, 0xf8, 0x30, 0x70, - 0xfc, 0xf6, 0x8f, 0x90, 0x2f, 0x26, 0xf6, 0x29, 0x35, 0x7c, 0xa2, 0x8c, 0x3e, 0xfd, 0xe7, 0x02, - 0xc7, 0x72, 0xc9, 0x13, 0xeb, 0x5f, 0x6e, 0x4f, 0x96, 0x38, 0x8d, 0x96, 0xc2, 0x96, 0xbc, 0x0b, - 0x43, 0x8b, 0x73, 0x65, 0xf1, 0x10, 0x91, 0x7b, 0x45, 0x3c, 0x11, 0x48, 0xd1, 0x47, 0x04, 0x22, - 0xc1, 0xf7, 0x3d, 0xed, 0x75, 0x3d, 0xf9, 0x0e, 0x31, 0xe4, 0xc2, 0xb4, 0x85, 0xbf, 0x14, 0x12, - 0xa7, 0x0b, 0x81, 0xb6, 0x44, 0xdf, 0x0f, 0xc5, 0x65, 0xc5, 0xb1, 0x31, 0x6d, 0x19, 0x3c, 0xc4, - 0xe8, 0x5e, 0x86, 0x89, 0x72, 0xa7, 0xd3, 0x32, 0xa9, 0x81, 0xfa, 0xa2, 0x75, 0x5b, 0xd4, 0x15, - 0x2e, 0x3f, 0xf8, 0xf8, 0x44, 0xe7, 0xc8, 0x3a, 0x3e, 0x7f, 0xad, 0x3b, 0xdd, 0xa8, 0x7f, 0x66, - 0xb2, 0xac, 0xfa, 0x17, 0xf2, 0x70, 0x61, 0xc6, 0xa1, 0xba, 0x47, 0x17, 0xe7, 0xca, 0xe5, 0x2e, - 0xfa, 0xc8, 0xb5, 0x5a, 0xd4, 0x6a, 0x1e, 0xcf, 0xb0, 0x7e, 0x13, 0xc6, 0x82, 0x06, 0xd4, 0x1a, - 0x76, 0x87, 0xca, 0x0f, 0xb9, 0x1a, 0x3e, 0xa6, 0xee, 0x32, 0x94, 0x16, 0x23, 0x25, 0x77, 0xe0, - 0x6c, 0x00, 0x29, 0xb7, 0x5a, 0xf6, 0xa6, 0x46, 0xbb, 0x2e, 0x77, 0xc4, 0x1d, 0xe4, 0x8e, 0xb8, - 0x21, 0x07, 0x9d, 0xe1, 0xeb, 0x0e, 0x23, 0xd0, 0xd2, 0x4a, 0xa9, 0x5f, 0x2f, 0xc0, 0xc5, 0x7b, - 0x7a, 0xcb, 0x34, 0x42, 0xd1, 0x68, 0xd4, 0xed, 0xd8, 0x96, 0x4b, 0x4f, 0xd0, 0x28, 0x8d, 0x0c, - 0x85, 0xe2, 0x91, 0x0c, 0x85, 0x64, 0x17, 0xf5, 0x1f, 0xba, 0x8b, 0x4a, 0x07, 0xea, 0xa2, 0xff, - 0x35, 0x07, 0xe3, 0xfe, 0x43, 0x03, 0xf9, 0xd1, 0xb8, 0xe4, 0x05, 0x8f, 0x47, 0x88, 0x31, 0xbf, - 0x6b, 0xc4, 0x93, 0x1a, 0x0c, 0xcc, 0x3e, 0xea, 0x98, 0x0e, 0x75, 0xf7, 0xe0, 0x34, 0xfe, 0x94, - 0x38, 0x2e, 0x99, 0xa0, 0xbc, 0x48, 0xe2, 0xa4, 0x84, 0x83, 0xf1, 0xf9, 0x20, 0x7f, 0x6a, 0x31, - 0xed, 0xbf, 0x84, 0xe7, 0xcf, 0x07, 0xc5, 0x93, 0x8c, 0xc8, 0x7b, 0xd0, 0x90, 0x94, 0x3c, 0x07, - 0x85, 0xd5, 0xd5, 0x05, 0x31, 0x93, 0x62, 0x04, 0x02, 0xcf, 0x93, 0xdf, 0x47, 0x32, 0xac, 0xfa, - 0x4f, 0xf3, 0x00, 0x4c, 0x15, 0xf8, 0x70, 0x3d, 0x16, 0x25, 0x9c, 0x86, 0x41, 0x5f, 0xe0, 0x42, - 0x0d, 0x83, 0x57, 0x02, 0xf1, 0x8e, 0x88, 0xd7, 0x1d, 0xbc, 0x08, 0x99, 0xf4, 0x1d, 0xc9, 0xf9, - 0x3d, 0x00, 0xee, 0x6c, 0xd0, 0x91, 0xdc, 0x77, 0x1f, 0xff, 0x24, 0x0c, 0x89, 0x19, 0xcf, 0x8e, - 0x9c, 0xff, 0x37, 0x7c, 0xa0, 0x16, 0xe2, 0x63, 0x53, 0x6b, 0xe9, 0x10, 0x0b, 0xb1, 0x2f, 0x5e, - 0xde, 0x2b, 0xa7, 0xe2, 0x3d, 0x62, 0xf1, 0x7e, 0x45, 0x88, 0x97, 0xbf, 0x18, 0x3a, 0xb1, 0xe2, - 0x3d, 0xb2, 0xb3, 0x6f, 0xf5, 0x1f, 0xe5, 0x80, 0xb0, 0x66, 0xad, 0xe8, 0xae, 0xbb, 0x69, 0x3b, - 0x06, 0x77, 0x4e, 0x3f, 0x16, 0xc1, 0x1c, 0xdd, 0x7d, 0xe5, 0xef, 0x0e, 0xc2, 0xd9, 0x88, 0xe3, - 0xef, 0x09, 0x9f, 0xac, 0xae, 0x45, 0x47, 0x53, 0xaf, 0x57, 0x2f, 0x1f, 0x93, 0x2f, 0x44, 0xfb, - 0x23, 0x0f, 0xde, 0xa4, 0x9b, 0xd0, 0x17, 0x61, 0x44, 0xfc, 0x60, 0x2b, 0xb4, 0x7f, 0xd3, 0x85, - 0xa3, 0xd4, 0x65, 0x00, 0x2d, 0x82, 0x26, 0xaf, 0xc0, 0x10, 0x1b, 0x30, 0x4d, 0x0c, 0x56, 0x32, - 0x10, 0xbe, 0x28, 0x31, 0x7c, 0xa0, 0xbc, 0x9e, 0x04, 0x94, 0xd2, 0xbb, 0xa5, 0xc1, 0x3d, 0xbc, - 0x5b, 0xfa, 0x22, 0x0c, 0x97, 0x2d, 0xcb, 0xf6, 0x70, 0x93, 0xee, 0x8a, 0xab, 0x89, 0x4c, 0xab, - 0xfc, 0x39, 0x7c, 0x8c, 0x1f, 0xd2, 0xa7, 0x9a, 0xe5, 0x32, 0x43, 0x72, 0xc3, 0x7f, 0x15, 0x43, - 0x1d, 0xe1, 0x55, 0x8e, 0xd7, 0x33, 0x8e, 0x80, 0x25, 0x1f, 0xc5, 0x60, 0xe7, 0x8d, 0xae, 0x38, - 0x76, 0xc7, 0x76, 0xa9, 0xc1, 0x05, 0x35, 0x1c, 0x86, 0x36, 0xe8, 0x08, 0x04, 0xbe, 0x9b, 0x8b, - 0x04, 0x0e, 0x89, 0x14, 0x21, 0xeb, 0x70, 0xce, 0xbf, 0x28, 0x0e, 0x5e, 0x28, 0x56, 0x2b, 0xae, - 0x32, 0x82, 0xaf, 0x92, 0x48, 0x5c, 0x19, 0xaa, 0x95, 0xe9, 0xa7, 0xfd, 0x6b, 0x11, 0xff, 0x89, - 0x63, 0xdd, 0x34, 0xe4, 0xae, 0x4e, 0xe5, 0x47, 0x7e, 0x08, 0x86, 0x17, 0xf5, 0x47, 0x95, 0xae, - 0x38, 0x7b, 0x19, 0xdd, 0xfb, 0xed, 0x4b, 0x5b, 0x7f, 0x54, 0x37, 0x44, 0xb9, 0x98, 0x4d, 0x21, - 0xb3, 0x24, 0x75, 0xb8, 0xb0, 0xe2, 0xd8, 0x6d, 0xdb, 0xa3, 0x46, 0xec, 0xb1, 0xdf, 0x99, 0xf0, - 0x75, 0x70, 0x47, 0x50, 0xd4, 0x7b, 0xbc, 0xfa, 0xcb, 0x60, 0x43, 0xda, 0x70, 0xa6, 0xec, 0xba, - 0xdd, 0x36, 0x0d, 0x6f, 0xa8, 0xc6, 0x77, 0xfd, 0x8c, 0x4f, 0x08, 0xaf, 0xe5, 0x27, 0x75, 0x2c, - 0xca, 0x2f, 0xa8, 0xea, 0x9e, 0x29, 0xd7, 0x88, 0xdf, 0x12, 0xe7, 0x7d, 0xbb, 0x38, 0x38, 0x36, - 0x7e, 0x46, 0xbb, 0x98, 0x6c, 0xcc, 0xaa, 0xe9, 0xb5, 0xa8, 0xfa, 0xad, 0x1c, 0x40, 0x28, 0x60, - 0xf2, 0x62, 0x34, 0x22, 0x52, 0x2e, 0xbc, 0xe8, 0x10, 0xd1, 0x12, 0x22, 0x21, 0x90, 0xc8, 0x65, - 0x28, 0x62, 0x44, 0x8d, 0x7c, 0x78, 0xb0, 0xfa, 0xc0, 0xb4, 0x0c, 0x0d, 0xa1, 0x0c, 0x2b, 0x3d, - 0x7d, 0x47, 0x2c, 0x5e, 0xea, 0x73, 0xab, 0xb0, 0x02, 0x67, 0x6a, 0xdd, 0x35, 0xbf, 0x6e, 0xe9, - 0x1d, 0x1f, 0x06, 0xf6, 0x70, 0xbb, 0x6b, 0xc1, 0xe3, 0xd7, 0x48, 0xd8, 0x94, 0x68, 0x11, 0xf5, - 0x1b, 0xb9, 0xd8, 0x2c, 0x78, 0x8c, 0x8b, 0xde, 0xc7, 0x92, 0x7e, 0x1a, 0xc9, 0x69, 0x49, 0xfd, - 0xa3, 0x02, 0x0c, 0xaf, 0xd8, 0x8e, 0x27, 0x42, 0x94, 0x9c, 0xec, 0x55, 0x48, 0xda, 0x2b, 0x15, - 0xf7, 0xb1, 0x57, 0xba, 0x0c, 0x45, 0xc9, 0x45, 0x99, 0xdf, 0x8b, 0x18, 0x86, 0xa3, 0x21, 0xf4, - 0x43, 0x7e, 0x72, 0x91, 0xbc, 0x04, 0x1d, 0x38, 0xb4, 0xab, 0xc1, 0x8f, 0xe4, 0x01, 0x3e, 0xf7, - 0xd2, 0x4b, 0x8f, 0x71, 0x97, 0xaa, 0x7f, 0x39, 0x07, 0x67, 0xc4, 0xd5, 0xa2, 0x14, 0x0d, 0x6d, - 0xc0, 0xbf, 0x14, 0x96, 0x67, 0x12, 0x0e, 0xd2, 0x7c, 0x1c, 0x5b, 0xb4, 0x66, 0x1f, 0x99, 0x1e, - 0xde, 0xae, 0x48, 0xe1, 0xd0, 0xa8, 0x80, 0xc9, 0x8b, 0x96, 0x4f, 0x47, 0x5e, 0xf4, 0x2f, 0x4d, - 0x0b, 0xe1, 0x4a, 0xcd, 0x0a, 0xcc, 0xa6, 0x5e, 0x9c, 0xaa, 0xbf, 0x5e, 0x84, 0xe2, 0xec, 0x23, - 0xda, 0x38, 0xe1, 0x5d, 0x23, 0x1d, 0xc5, 0x16, 0x0f, 0x79, 0x14, 0x7b, 0x10, 0x2f, 0x90, 0x77, - 0xc2, 0xfe, 0x2c, 0x45, 0xab, 0x8f, 0xf5, 0x7c, 0xbc, 0x7a, 0xbf, 0xa7, 0x4f, 0x9e, 0x13, 0xd1, - 0x7f, 0x51, 0x80, 0x42, 0x6d, 0x66, 0xe5, 0x54, 0x6f, 0x8e, 0x55, 0x6f, 0x7a, 0xdf, 0xb2, 0xab, - 0xc1, 0xc5, 0xd9, 0x60, 0xe8, 0xd7, 0x1a, 0xbb, 0x23, 0xfb, 0x6e, 0x01, 0xc6, 0x6a, 0x73, 0xab, - 0x2b, 0xd2, 0xd9, 0xf5, 0x1d, 0xee, 0x7b, 0x88, 0x5e, 0x70, 0xbc, 0x4b, 0x2f, 0x27, 0x2c, 0xb0, - 0xbb, 0x55, 0xcb, 0x7b, 0xf5, 0xe6, 0x3d, 0xbd, 0xd5, 0xa5, 0x78, 0x58, 0xc4, 0x3d, 0x95, 0x5d, - 0xf3, 0x03, 0xfa, 0x75, 0x0c, 0x8d, 0xe0, 0x33, 0x20, 0x6f, 0x42, 0xe1, 0xae, 0xf0, 0x21, 0xc9, - 0xe2, 0xf3, 0xf2, 0x0d, 0xce, 0x87, 0x4d, 0x82, 0x85, 0xae, 0x69, 0x20, 0x07, 0x56, 0x8a, 0x15, - 0xbe, 0x25, 0x4c, 0x86, 0x3d, 0x15, 0x6e, 0xfa, 0x85, 0x6f, 0x55, 0x2b, 0xa4, 0x06, 0xc3, 0x2b, - 0xd4, 0x69, 0x9b, 0xd8, 0x51, 0xfe, 0x9c, 0xdd, 0x9b, 0x09, 0xdb, 0x5b, 0x0d, 0x77, 0xc2, 0x42, - 0xc8, 0x4c, 0xe6, 0x42, 0xde, 0x03, 0xe0, 0x56, 0xd5, 0x1e, 0x23, 0x6c, 0x3e, 0x85, 0x3b, 0x15, - 0x6e, 0x0c, 0xa7, 0x58, 0xa5, 0x12, 0x33, 0xf2, 0x00, 0xc6, 0x17, 0x6d, 0xc3, 0x5c, 0x37, 0xb9, - 0xb3, 0x28, 0x56, 0x50, 0xda, 0xdd, 0x45, 0x8b, 0x19, 0xbf, 0x6d, 0xa9, 0x5c, 0x5a, 0x35, 0x09, - 0xc6, 0xea, 0xdf, 0xeb, 0x87, 0x22, 0xeb, 0xf6, 0xd3, 0xf1, 0x7b, 0x98, 0xf1, 0x5b, 0x86, 0xf1, - 0xfb, 0xb6, 0xf3, 0xc0, 0xb4, 0x9a, 0x81, 0x1f, 0xbf, 0xd8, 0x4d, 0xa3, 0xef, 0xd1, 0x26, 0xc7, - 0xd5, 0x03, 0x97, 0x7f, 0x2d, 0x41, 0xbe, 0xcb, 0x08, 0x7e, 0x1d, 0x80, 0xbf, 0xce, 0x47, 0x9a, - 0xc1, 0x30, 0x9c, 0x07, 0x7f, 0xbb, 0x8f, 0x4f, 0x03, 0xe4, 0x70, 0x1e, 0x21, 0x31, 0xb9, 0xe6, - 0x7b, 0x6f, 0x0c, 0xe1, 0x4b, 0x01, 0x3c, 0x36, 0x40, 0xef, 0x0d, 0xd9, 0x08, 0xe0, 0x7e, 0x1c, - 0x2b, 0x00, 0xd2, 0x8d, 0x18, 0xc4, 0x04, 0x11, 0x99, 0x1c, 0x44, 0x00, 0xbd, 0x94, 0x0b, 0x31, - 0x4d, 0xe2, 0x41, 0x5e, 0x8d, 0x5d, 0xd9, 0x93, 0x08, 0xb7, 0xcc, 0x1b, 0xfb, 0xd0, 0xe5, 0x6b, - 0x64, 0x37, 0x97, 0x2f, 0xf5, 0x6f, 0x15, 0x60, 0x98, 0x71, 0xab, 0x75, 0xdb, 0x6d, 0xdd, 0xd9, - 0x3a, 0x55, 0xe4, 0xc3, 0x28, 0x72, 0x1d, 0x26, 0x64, 0x17, 0x7f, 0x66, 0xba, 0xfa, 0xc1, 0x98, - 0x82, 0x03, 0xab, 0x38, 0x01, 0xb7, 0x2d, 0x71, 0xde, 0xf7, 0x04, 0x18, 0x4f, 0x43, 0x5c, 0x2d, - 0xc9, 0x4b, 0xfd, 0xd9, 0x1c, 0x8c, 0xc7, 0xa1, 0x81, 0xee, 0xe7, 0x52, 0x75, 0xff, 0x05, 0x18, - 0x12, 0x97, 0xfe, 0xba, 0x21, 0x7c, 0x10, 0xc7, 0x76, 0xb6, 0x27, 0x01, 0x5f, 0x5c, 0xd7, 0x1d, - 0xaa, 0x1b, 0x5a, 0x48, 0x40, 0x5e, 0x81, 0x11, 0xfc, 0x71, 0xdf, 0x31, 0x3d, 0x8f, 0xf2, 0xce, - 0x28, 0xf2, 0x7b, 0x0c, 0x5e, 0x60, 0x93, 0x23, 0xb4, 0x08, 0x99, 0xfa, 0x7b, 0x79, 0x18, 0xaa, - 0x75, 0xd7, 0xdc, 0x2d, 0xd7, 0xa3, 0xed, 0x13, 0xae, 0x43, 0xfe, 0xb1, 0x42, 0x31, 0xf5, 0x58, - 0xe1, 0x39, 0x7f, 0x68, 0x49, 0xe7, 0xed, 0xc1, 0xc6, 0xc0, 0xf7, 0xa3, 0x0c, 0xb5, 0xa8, 0xb4, - 0x7f, 0x2d, 0x52, 0xff, 0x4e, 0x1e, 0xc6, 0xf9, 0x75, 0x73, 0xc5, 0x74, 0x1b, 0x47, 0xf0, 0x04, - 0xe6, 0xf8, 0x65, 0x7a, 0x38, 0x17, 0x8d, 0x3d, 0x3c, 0x2c, 0x52, 0xbf, 0x94, 0x87, 0xe1, 0x72, - 0xd7, 0xdb, 0x28, 0x7b, 0x38, 0xbf, 0x3d, 0x96, 0x7b, 0xe4, 0x7f, 0x98, 0x83, 0x33, 0xac, 0x21, - 0xab, 0xf6, 0x03, 0x6a, 0x1d, 0xc1, 0x71, 0xbd, 0x7c, 0xec, 0x9e, 0x3f, 0xe0, 0xb1, 0xbb, 0x2f, - 0xcb, 0xc2, 0xfe, 0x64, 0x89, 0x97, 0x4c, 0x9a, 0xdd, 0xa2, 0x27, 0xfb, 0x33, 0x8e, 0xf0, 0x92, - 0xc9, 0x17, 0xc8, 0x11, 0x5c, 0x6a, 0x7e, 0x7f, 0x09, 0xe4, 0x08, 0x4e, 0x64, 0xbf, 0x3f, 0x04, - 0xf2, 0xbb, 0x39, 0x18, 0x9a, 0xb6, 0xbd, 0x13, 0x3e, 0xf0, 0xc5, 0x57, 0x9c, 0x6c, 0x35, 0xf7, - 0xbf, 0xe2, 0x64, 0xeb, 0xa6, 0xfa, 0xf3, 0x79, 0x38, 0x27, 0x22, 0xf8, 0x8b, 0x33, 0xb0, 0xd3, - 0xe9, 0x58, 0x0c, 0xb6, 0xa4, 0x68, 0x4e, 0xe7, 0x21, 0x21, 0x9a, 0x5f, 0x2c, 0xc0, 0x39, 0x0c, - 0x38, 0xcc, 0x76, 0x54, 0xdf, 0x07, 0xb6, 0x08, 0x69, 0x44, 0x5d, 0x07, 0x16, 0x53, 0x5c, 0x07, - 0xfe, 0xe5, 0xf6, 0xe4, 0xab, 0x4d, 0xd3, 0xdb, 0xe8, 0xae, 0x4d, 0x35, 0xec, 0xf6, 0xf5, 0xa6, - 0xa3, 0x3f, 0x34, 0xf9, 0xa5, 0xb9, 0xde, 0xba, 0x1e, 0x26, 0xd6, 0xe9, 0x98, 0x22, 0x4d, 0x4e, - 0x0d, 0x77, 0x4a, 0x8c, 0xab, 0xef, 0x74, 0xe0, 0x02, 0xdc, 0xb6, 0x4d, 0x4b, 0x78, 0xe2, 0x72, - 0x43, 0xb7, 0xb6, 0xb3, 0x3d, 0x79, 0xfe, 0x7d, 0xdb, 0xb4, 0xea, 0x71, 0x77, 0xdc, 0xfd, 0xd6, - 0x17, 0xb2, 0xd6, 0xa4, 0x6a, 0xd4, 0xff, 0x26, 0x07, 0x4f, 0x44, 0xb5, 0xf8, 0xfb, 0xc1, 0x76, - 0xfc, 0x8b, 0x79, 0x38, 0x7f, 0x0b, 0x85, 0x13, 0xb8, 0x3f, 0x9d, 0xce, 0x5b, 0x62, 0x70, 0xa6, - 0xc8, 0xe6, 0xd4, 0xa2, 0xcc, 0x96, 0xcd, 0xe9, 0xa4, 0x2e, 0x64, 0xf3, 0x5f, 0xe7, 0xe0, 0xec, - 0x72, 0xb5, 0x32, 0xf3, 0x7d, 0x32, 0xa2, 0x92, 0xdf, 0x73, 0xc2, 0x0d, 0xce, 0xc4, 0xf7, 0x9c, - 0x70, 0xd3, 0xf3, 0x6b, 0x79, 0x38, 0x5b, 0x2b, 0x2f, 0x2e, 0x7c, 0xbf, 0xcc, 0xe0, 0x33, 0xb2, - 0xaf, 0xae, 0x7f, 0x08, 0x26, 0x6c, 0x01, 0xf9, 0x33, 0xef, 0xdd, 0xc8, 0xf6, 0xe1, 0x4d, 0x0a, - 0xe5, 0x84, 0x4f, 0xdd, 0x47, 0x22, 0x14, 0xa6, 0xf9, 0x11, 0xea, 0x13, 0xae, 0xf9, 0xff, 0x79, - 0x09, 0x86, 0xef, 0x74, 0xd7, 0xa8, 0x70, 0xe9, 0x7a, 0xac, 0x4f, 0x7e, 0x6f, 0xc0, 0xb0, 0x10, - 0x03, 0xde, 0x70, 0x48, 0x21, 0x27, 0x45, 0x08, 0x21, 0x1e, 0xd5, 0x4b, 0x26, 0x22, 0x97, 0xa1, - 0x78, 0x8f, 0x3a, 0x6b, 0xf2, 0x6b, 0xec, 0x87, 0xd4, 0x59, 0xd3, 0x10, 0x4a, 0x16, 0xc2, 0x87, - 0x26, 0xe5, 0x95, 0x2a, 0xa6, 0x3b, 0x12, 0x97, 0x86, 0x98, 0xbf, 0x29, 0xf0, 0x16, 0xd5, 0x3b, - 0x26, 0x4f, 0x94, 0x24, 0x47, 0x82, 0x88, 0x97, 0x24, 0x4b, 0x30, 0x21, 0xbb, 0x0b, 0xf2, 0x5c, - 0x3f, 0x83, 0x29, 0xec, 0xd2, 0xb2, 0xfc, 0x24, 0x8b, 0x92, 0x77, 0x60, 0xc4, 0x07, 0xa2, 0xe3, - 0xe3, 0x50, 0x98, 0x60, 0x22, 0x60, 0x15, 0xcb, 0x07, 0x10, 0x29, 0x20, 0x33, 0xc0, 0x4b, 0x0c, - 0x48, 0x61, 0x10, 0x73, 0x24, 0x8d, 0x14, 0x20, 0xaf, 0x20, 0x03, 0x7c, 0x1c, 0x85, 0x0e, 0x53, - 0xc3, 0xf8, 0x54, 0x19, 0x2f, 0x80, 0x1c, 0x01, 0xe7, 0x0f, 0xd2, 0x23, 0x64, 0x64, 0x19, 0x20, - 0x74, 0x6c, 0x11, 0x61, 0x3f, 0xf6, 0xed, 0x72, 0x23, 0xb1, 0x90, 0x6f, 0xf2, 0x46, 0x0f, 0x72, - 0x93, 0xa7, 0xfe, 0x51, 0x1e, 0x86, 0xcb, 0x9d, 0x4e, 0x30, 0x14, 0x5e, 0x84, 0x52, 0xb9, 0xd3, - 0xb9, 0xab, 0x55, 0xe5, 0x04, 0x00, 0x7a, 0xa7, 0x53, 0xef, 0x3a, 0xa6, 0xec, 0x49, 0xcd, 0x89, - 0xc8, 0x0c, 0x8c, 0x96, 0x3b, 0x9d, 0x95, 0xee, 0x5a, 0xcb, 0x6c, 0x48, 0xf9, 0xcb, 0x78, 0x86, - 0xc7, 0x4e, 0xa7, 0xde, 0x41, 0x4c, 0x3c, 0x89, 0x5d, 0xb4, 0x0c, 0xf9, 0x22, 0x06, 0xcb, 0x12, - 0xe9, 0xb3, 0x78, 0x82, 0x1e, 0x35, 0x08, 0xfd, 0x1f, 0xb6, 0x6d, 0x2a, 0x20, 0xe2, 0x29, 0x12, - 0x2e, 0xfb, 0x89, 0x2d, 0x58, 0x45, 0x89, 0x34, 0x59, 0x21, 0x4b, 0xf2, 0x29, 0x18, 0x28, 0x77, - 0x3a, 0xd2, 0x6d, 0x15, 0x3a, 0xb6, 0xb1, 0x52, 0xf1, 0x0c, 0x85, 0x82, 0xec, 0xd2, 0x5b, 0x30, - 0x16, 0xad, 0x6c, 0x5f, 0x29, 0x16, 0xbe, 0x97, 0xc3, 0x0f, 0x3a, 0xe1, 0x2f, 0x01, 0x5e, 0x86, - 0x42, 0xb9, 0xd3, 0x11, 0xf3, 0xd1, 0xd9, 0x94, 0xfe, 0x88, 0x07, 0x0e, 0x28, 0x77, 0x3a, 0xfe, - 0xa7, 0x9f, 0xf0, 0x27, 0x45, 0x07, 0xfa, 0xf4, 0xdf, 0xe5, 0x9f, 0x7e, 0xb2, 0x9f, 0xfb, 0xa8, - 0xbf, 0x5e, 0x80, 0x33, 0xe5, 0x4e, 0xe7, 0x34, 0x35, 0xc3, 0x51, 0x85, 0x27, 0x78, 0x09, 0x40, - 0x9a, 0x1e, 0x07, 0x82, 0x07, 0x8f, 0xc3, 0xd2, 0xd4, 0xa8, 0xe4, 0x34, 0x89, 0xc8, 0x57, 0xbf, - 0xc1, 0x7d, 0xa9, 0xdf, 0x97, 0x0a, 0x38, 0x15, 0x9f, 0xf4, 0x50, 0x6b, 0x1f, 0x95, 0x6e, 0x13, - 0x7d, 0x50, 0xda, 0x57, 0x1f, 0xfc, 0x83, 0xc8, 0xe0, 0xc1, 0x50, 0xff, 0xa7, 0xbd, 0xd0, 0x7f, - 0x28, 0xb3, 0x78, 0x4c, 0x16, 0xa6, 0x88, 0xff, 0xe4, 0xa7, 0x3b, 0x13, 0xd1, 0xc8, 0x1a, 0x0c, - 0x55, 0x37, 0x0d, 0x2d, 0x46, 0xeb, 0xf7, 0xe1, 0xc0, 0xbe, 0xfa, 0x70, 0x3b, 0x8f, 0x11, 0x07, - 0x82, 0x68, 0x66, 0x87, 0xdf, 0x5d, 0x5c, 0x07, 0xe0, 0x9e, 0x07, 0x81, 0x6b, 0xfd, 0x28, 0x0f, - 0x5c, 0xc4, 0xb3, 0xa0, 0x89, 0xc0, 0x45, 0x21, 0x49, 0xe0, 0xa9, 0x54, 0x48, 0xf5, 0x54, 0xba, - 0x06, 0x83, 0x9a, 0xbe, 0xf9, 0x6e, 0x97, 0x3a, 0x5b, 0xc2, 0x9c, 0xe1, 0xc1, 0x42, 0xf5, 0xcd, - 0xfa, 0x0f, 0x33, 0xa0, 0x16, 0xa0, 0x89, 0x1a, 0x84, 0xac, 0x90, 0x3c, 0x42, 0xf8, 0x19, 0x79, - 0x10, 0xa8, 0xe2, 0x20, 0x8a, 0x4e, 0xde, 0x80, 0x42, 0xf9, 0x7e, 0x4d, 0x48, 0x36, 0xe8, 0xda, - 0xf2, 0xfd, 0x9a, 0x90, 0x57, 0x66, 0xd9, 0xfb, 0x35, 0xf5, 0x4b, 0x79, 0x20, 0x49, 0x4a, 0xf2, - 0x2a, 0x0c, 0x21, 0xb4, 0xc9, 0x74, 0x46, 0x4e, 0x9f, 0xbb, 0xe9, 0xd6, 0x1d, 0x84, 0x46, 0x8c, - 0x3b, 0x9f, 0x94, 0xbc, 0x8e, 0x09, 0xca, 0x45, 0x02, 0xc7, 0x48, 0xfa, 0xdc, 0x4d, 0xd7, 0x4f, - 0xe9, 0x1d, 0xcb, 0x4f, 0x2e, 0x88, 0xd1, 0x2e, 0xbc, 0x5f, 0x9b, 0xb7, 0x5d, 0x4f, 0x88, 0x9a, - 0xdb, 0x85, 0x9b, 0x2e, 0xe6, 0x6d, 0x8e, 0xd8, 0x85, 0x9c, 0x0c, 0x73, 0xcf, 0xdd, 0xaf, 0xf1, - 0xc7, 0x5d, 0x86, 0x66, 0xb7, 0x7c, 0x83, 0x92, 0xe7, 0x9e, 0xdb, 0x74, 0xeb, 0xfc, 0x61, 0x98, - 0x81, 0x99, 0xd1, 0x23, 0xb9, 0xe7, 0x22, 0xa5, 0xd4, 0x9f, 0x1e, 0x84, 0xf1, 0x8a, 0xee, 0xe9, - 0x6b, 0xba, 0x4b, 0xa5, 0xdd, 0xf4, 0x19, 0x1f, 0xe6, 0x7f, 0x8e, 0x24, 0x07, 0x63, 0x2d, 0xe5, - 0x6b, 0xe2, 0x05, 0xc8, 0x9b, 0x21, 0xdf, 0x20, 0x33, 0xb0, 0x9c, 0x6a, 0x70, 0xad, 0xde, 0x11, - 0x60, 0x2d, 0x41, 0x48, 0x5e, 0x80, 0x61, 0x1f, 0xc6, 0x36, 0x00, 0x85, 0x50, 0x67, 0x8c, 0x35, - 0x66, 0xff, 0x6b, 0x32, 0x9a, 0xbc, 0x0e, 0x23, 0xfe, 0x4f, 0xc9, 0xb4, 0xe6, 0x79, 0x13, 0xd7, - 0x12, 0xbb, 0x27, 0x99, 0x54, 0x2e, 0x8a, 0xf3, 0x5b, 0x7f, 0xa4, 0x68, 0x2c, 0x35, 0x61, 0x84, - 0x94, 0xfc, 0x30, 0x8c, 0xf9, 0xbf, 0xc5, 0x86, 0x81, 0x3b, 0x0e, 0xbe, 0x10, 0x24, 0x5e, 0x8f, - 0x89, 0x75, 0x2a, 0x4a, 0xce, 0xb7, 0x0e, 0x4f, 0xfa, 0xd9, 0xf6, 0x8c, 0xb5, 0xe4, 0xce, 0x21, - 0x56, 0x01, 0xa9, 0xc2, 0x84, 0x0f, 0x09, 0x35, 0x74, 0x20, 0xdc, 0x31, 0x1a, 0x6b, 0xf5, 0x54, - 0x25, 0x4d, 0x96, 0x22, 0x2d, 0xb8, 0x1c, 0x01, 0x1a, 0xee, 0x86, 0xb9, 0xee, 0x89, 0xed, 0x9e, - 0x88, 0xdc, 0x2d, 0xd2, 0xab, 0x06, 0x5c, 0x39, 0x8d, 0x9f, 0x27, 0x39, 0x9a, 0x53, 0xad, 0x27, - 0x37, 0x52, 0x83, 0x73, 0x3e, 0xfe, 0xd6, 0xcc, 0xca, 0x8a, 0x63, 0xbf, 0x4f, 0x1b, 0x5e, 0xb5, - 0x22, 0xb6, 0xcb, 0x18, 0xd1, 0xd1, 0x58, 0xab, 0x37, 0x1b, 0x1d, 0xa6, 0x14, 0x0c, 0x17, 0x65, - 0x9e, 0x5a, 0x98, 0xdc, 0x83, 0xf3, 0x12, 0x5c, 0x4a, 0xe2, 0x0e, 0xe1, 0x7e, 0x5e, 0x70, 0x4d, - 0xcf, 0xe3, 0x9e, 0x5e, 0x9c, 0xbc, 0x05, 0xa3, 0x3e, 0x82, 0xdf, 0x22, 0x0e, 0xe3, 0x2d, 0x22, - 0x0e, 0x49, 0x63, 0xad, 0x1e, 0x7f, 0x83, 0x1c, 0x25, 0x96, 0x35, 0x6a, 0x75, 0xab, 0x43, 0x85, - 0x47, 0xaf, 0xaf, 0x51, 0xde, 0x56, 0x27, 0x55, 0x19, 0x19, 0x29, 0x79, 0x27, 0xd4, 0xa8, 0x65, - 0xc7, 0x6c, 0x9a, 0x7c, 0x27, 0xed, 0x3f, 0x3b, 0x5e, 0xab, 0xdb, 0x08, 0x4c, 0xd3, 0x0f, 0x4e, - 0x7e, 0xa9, 0x0c, 0x67, 0x53, 0x74, 0x6c, 0x5f, 0x3b, 0xc6, 0x2f, 0xe7, 0xc3, 0x46, 0x9c, 0xf0, - 0x6d, 0xe3, 0x34, 0x0c, 0xfa, 0x5f, 0x22, 0x8c, 0x07, 0x25, 0x6b, 0x68, 0xc6, 0x79, 0xf8, 0xf8, - 0x88, 0x38, 0x4e, 0xf8, 0x56, 0xf2, 0x28, 0xc4, 0xf1, 0xed, 0x5c, 0x28, 0x8e, 0x13, 0xbe, 0xbd, - 0xfc, 0xa9, 0x62, 0x38, 0x27, 0x9d, 0xee, 0x31, 0x8f, 0xca, 0x4c, 0x0e, 0xfd, 0x60, 0x4b, 0xfb, - 0x78, 0xfe, 0x2b, 0xab, 0xe6, 0xc0, 0xc1, 0x54, 0x93, 0xbc, 0x05, 0xc3, 0x2b, 0xb6, 0xeb, 0x35, - 0x1d, 0xea, 0xae, 0x04, 0x99, 0x27, 0xf0, 0xe9, 0x78, 0x47, 0x80, 0xeb, 0x9d, 0xc8, 0xec, 0x2f, - 0x93, 0xab, 0xff, 0xb8, 0x90, 0xd0, 0x06, 0x6e, 0xb8, 0x9e, 0x48, 0x6d, 0x38, 0x82, 0xa1, 0x4e, - 0x6e, 0x84, 0xab, 0x20, 0xb7, 0xf0, 0xfb, 0xa5, 0xb0, 0x9a, 0x6b, 0xc2, 0xc0, 0x8f, 0x92, 0x90, - 0x1f, 0x80, 0x8b, 0x11, 0xc0, 0x8a, 0xee, 0xe8, 0x6d, 0xea, 0x85, 0x59, 0x3e, 0x31, 0x50, 0x9a, - 0x5f, 0xba, 0xde, 0x09, 0xd0, 0x72, 0xe6, 0xd0, 0x0c, 0x0e, 0x92, 0x6a, 0x0d, 0xec, 0xc3, 0xc5, - 0xfa, 0xe7, 0x0a, 0xa1, 0xa1, 0x13, 0x0d, 0x78, 0xac, 0x51, 0xb7, 0xdb, 0xf2, 0x1e, 0xdf, 0x0e, - 0x3e, 0x58, 0x3a, 0x99, 0x79, 0x38, 0x53, 0x5e, 0x5f, 0xa7, 0x0d, 0xcf, 0x8f, 0xe3, 0xee, 0x8a, - 0x10, 0x97, 0x7c, 0xe3, 0x21, 0x50, 0x22, 0x2e, 0xb7, 0xdc, 0xaf, 0xf1, 0x62, 0xea, 0x3f, 0x29, - 0x82, 0x12, 0x18, 0xfe, 0xc1, 0x53, 0xc3, 0x63, 0x5c, 0x64, 0x3f, 0x12, 0xbd, 0x62, 0xc2, 0x44, - 0x28, 0x0c, 0xf1, 0xc6, 0x4b, 0xe4, 0x9d, 0x9f, 0x8c, 0x33, 0x0b, 0x09, 0xf9, 0x5e, 0xe2, 0x92, - 0xd8, 0x4b, 0x90, 0xf0, 0x29, 0x67, 0xdd, 0xe5, 0x2c, 0xb4, 0x24, 0x57, 0xf2, 0x95, 0x1c, 0x9c, - 0xf3, 0x3b, 0x65, 0x79, 0x8d, 0x19, 0xd5, 0x33, 0x76, 0xd7, 0x0a, 0x1e, 0x40, 0xbd, 0x91, 0x5d, - 0x1d, 0xef, 0xa4, 0xa9, 0xb4, 0xc2, 0xbc, 0x25, 0x41, 0x30, 0x97, 0x40, 0x21, 0x6c, 0xa4, 0xa9, - 0x37, 0x90, 0x48, 0x4b, 0xad, 0xf7, 0xd2, 0x2d, 0x78, 0x22, 0x93, 0xe5, 0x6e, 0x46, 0x6c, 0xbf, - 0x6c, 0xc4, 0xfe, 0x77, 0xb9, 0x70, 0x22, 0x8a, 0x09, 0x89, 0x4c, 0x01, 0x84, 0x20, 0xb1, 0xad, - 0xc5, 0xf7, 0x55, 0xa1, 0xd0, 0x34, 0x89, 0x82, 0x2c, 0x43, 0x49, 0x88, 0x85, 0x67, 0xd4, 0xfe, - 0xe4, 0x2e, 0xbd, 0x30, 0x25, 0xcb, 0x01, 0xb7, 0xac, 0xe2, 0x9b, 0x05, 0x9b, 0x4b, 0xaf, 0xc3, - 0xf0, 0x41, 0xbf, 0xeb, 0x2b, 0x05, 0x20, 0xf2, 0x1e, 0xf4, 0x18, 0x0d, 0xf4, 0x13, 0x3c, 0x85, - 0x5d, 0x85, 0x41, 0xf6, 0x09, 0x98, 0x63, 0x46, 0x8a, 0x29, 0xdd, 0x15, 0x30, 0x2d, 0xc0, 0x86, - 0x01, 0xdd, 0x06, 0xd2, 0x03, 0xba, 0xa9, 0x3f, 0x5b, 0x80, 0x0b, 0x72, 0x87, 0x54, 0x28, 0xa6, - 0xa9, 0x38, 0xed, 0x94, 0x0f, 0xb1, 0x53, 0x54, 0x28, 0xf1, 0xad, 0x87, 0xc8, 0x17, 0xc2, 0x8f, - 0x85, 0x10, 0xa2, 0x09, 0x8c, 0xfa, 0x3f, 0xe7, 0x61, 0x34, 0x30, 0xef, 0x74, 0xc7, 0x7d, 0x8c, - 0xbb, 0xe3, 0xd3, 0x30, 0x8a, 0x21, 0xb9, 0xda, 0xd4, 0xe2, 0x61, 0xab, 0xfa, 0xa5, 0x04, 0x3f, - 0x3e, 0x42, 0xe4, 0x72, 0x8b, 0x10, 0x32, 0xed, 0xe7, 0x96, 0x9f, 0x14, 0x28, 0x8d, 0x9b, 0x7d, - 0x1c, 0xae, 0xfe, 0xd5, 0x02, 0x8c, 0xf8, 0x52, 0x9e, 0x36, 0x4f, 0xea, 0x3d, 0xcf, 0xf1, 0x0a, - 0xf9, 0x3a, 0xc0, 0x8a, 0xed, 0x78, 0x7a, 0x6b, 0x29, 0xd4, 0x7c, 0x3c, 0x20, 0xed, 0x20, 0x94, - 0x97, 0x91, 0x48, 0x70, 0xfd, 0x0a, 0xcd, 0x6a, 0x3e, 0x31, 0xf1, 0xf5, 0x2b, 0x80, 0x6a, 0x12, - 0x85, 0xfa, 0xdb, 0x79, 0x38, 0xe3, 0x77, 0xd2, 0xec, 0x23, 0xda, 0xe8, 0x3e, 0xce, 0x73, 0x53, - 0x54, 0xda, 0xfd, 0xbb, 0x4a, 0x5b, 0xfd, 0x3f, 0xa5, 0x89, 0x64, 0xa6, 0x65, 0x9f, 0x4e, 0x24, - 0x7f, 0x1a, 0x3a, 0xae, 0xfe, 0x58, 0x01, 0xce, 0xf9, 0x52, 0x9f, 0xeb, 0x5a, 0x78, 0xb4, 0x30, - 0xa3, 0xb7, 0x5a, 0x8f, 0xf3, 0x6e, 0x7c, 0xd8, 0x17, 0xc4, 0xb2, 0x88, 0x71, 0x29, 0xf2, 0x6a, - 0xae, 0x0b, 0x70, 0xdd, 0x36, 0x0d, 0x4d, 0x26, 0x22, 0xef, 0xc0, 0x88, 0xff, 0xb3, 0xec, 0x34, - 0xfd, 0x2d, 0x38, 0x5e, 0x14, 0x04, 0x85, 0x74, 0x27, 0x12, 0x18, 0x23, 0x52, 0x40, 0xfd, 0xd2, - 0x00, 0x5c, 0xba, 0x6f, 0x5a, 0x86, 0xbd, 0xe9, 0xfa, 0x69, 0x59, 0x4f, 0xfc, 0x41, 0xd9, 0x71, - 0xa7, 0x63, 0x7d, 0x17, 0xce, 0xc7, 0x45, 0xea, 0x04, 0xc1, 0xf2, 0x45, 0xef, 0x6c, 0x72, 0x82, - 0xba, 0x9f, 0xa0, 0x55, 0xdc, 0xb6, 0x69, 0xe9, 0x25, 0xe3, 0x19, 0x5e, 0x07, 0xf6, 0x92, 0xe1, - 0xf5, 0x79, 0x28, 0x55, 0xec, 0xb6, 0x6e, 0xfa, 0x21, 0x92, 0x70, 0x14, 0x07, 0xf5, 0x22, 0x46, - 0x13, 0x14, 0x8c, 0xbf, 0xa8, 0x18, 0xbb, 0x6c, 0x28, 0xe4, 0xef, 0x17, 0x60, 0x56, 0x9a, 0x26, - 0x13, 0x11, 0x1b, 0x46, 0x45, 0x75, 0xe2, 0x6e, 0x0c, 0x70, 0xf3, 0xf4, 0x8a, 0x2f, 0xa3, 0x6c, - 0xb5, 0x9a, 0x8a, 0x94, 0xe3, 0xdb, 0x28, 0x9e, 0x78, 0x56, 0x7c, 0x0c, 0xbf, 0x25, 0xd3, 0xa2, - 0xfc, 0x25, 0x21, 0xe0, 0x24, 0x33, 0x9c, 0x14, 0x02, 0xce, 0x32, 0x32, 0x11, 0x99, 0x85, 0x09, - 0x0c, 0x69, 0x1e, 0x6c, 0xa5, 0x98, 0x4a, 0x8c, 0xa0, 0x51, 0x89, 0x57, 0x2e, 0x3c, 0x0a, 0x3a, - 0xfb, 0xb8, 0x7a, 0x43, 0xa0, 0xb5, 0x64, 0x09, 0xf2, 0x04, 0x14, 0x96, 0x16, 0xca, 0x78, 0x57, - 0x33, 0xc8, 0xd3, 0x89, 0x59, 0x2d, 0x5d, 0x63, 0xb0, 0x4b, 0x9f, 0x05, 0x92, 0xfc, 0x9c, 0x7d, - 0xdd, 0xc7, 0xfc, 0x97, 0xd2, 0x96, 0xef, 0xa4, 0x7b, 0xd4, 0x1c, 0xc5, 0x44, 0x18, 0xc9, 0xe4, - 0xd7, 0xff, 0x61, 0x66, 0xf2, 0x2b, 0x1d, 0x69, 0x26, 0x3f, 0xf5, 0x57, 0x72, 0x30, 0x91, 0x08, - 0xfb, 0x4f, 0x5e, 0x06, 0xe0, 0x10, 0x29, 0xbc, 0x2a, 0x46, 0xff, 0x09, 0x53, 0x01, 0x88, 0xe5, - 0x31, 0x24, 0x23, 0xd7, 0x61, 0x90, 0xff, 0x12, 0x01, 0xc6, 0x92, 0x45, 0xba, 0x5d, 0xd3, 0xd0, - 0x02, 0xa2, 0xb0, 0x16, 0xbc, 0x91, 0x2c, 0xa4, 0x16, 0xf1, 0xb6, 0x3a, 0x41, 0x2d, 0x8c, 0x4c, - 0xfd, 0xe9, 0x3c, 0x8c, 0x04, 0x0d, 0x2e, 0x1b, 0xc7, 0xa5, 0x73, 0x25, 0x91, 0x41, 0xa1, 0xb0, - 0x5b, 0x06, 0x85, 0xd8, 0x7c, 0x2b, 0x52, 0x26, 0x1c, 0xdd, 0x83, 0xaa, 0xaf, 0xe6, 0xe1, 0x4c, - 0x50, 0xeb, 0x31, 0x5e, 0x7e, 0x7d, 0x84, 0x44, 0xf2, 0x95, 0x1c, 0x28, 0xd3, 0x66, 0xab, 0x65, - 0x5a, 0xcd, 0xaa, 0xb5, 0x6e, 0x3b, 0x6d, 0x9c, 0x10, 0x8f, 0xef, 0x08, 0x57, 0xfd, 0xb3, 0x39, - 0x98, 0x10, 0x0d, 0x9a, 0xd1, 0x1d, 0xe3, 0xf8, 0xce, 0xc7, 0xe2, 0x2d, 0x39, 0x3e, 0x7d, 0x51, - 0xbf, 0x99, 0x07, 0x58, 0xb0, 0x1b, 0x0f, 0x4e, 0xf8, 0x7b, 0xac, 0x37, 0xa1, 0xc4, 0xa3, 0xbc, - 0x09, 0x8d, 0x9d, 0x10, 0xef, 0x8e, 0xd8, 0xa7, 0x71, 0xc4, 0xf4, 0xb8, 0x98, 0x8f, 0x4b, 0x3c, - 0x4a, 0x9c, 0x92, 0xd3, 0x44, 0x11, 0x56, 0x29, 0xa3, 0x13, 0x0b, 0x46, 0x50, 0x29, 0x83, 0x45, - 0x2b, 0xdd, 0xd9, 0x9e, 0x2c, 0xb6, 0xec, 0xc6, 0x03, 0x0d, 0xe9, 0xd5, 0x7f, 0x95, 0xe3, 0xb2, - 0x3b, 0xe1, 0xaf, 0x4a, 0xfd, 0xcf, 0x2f, 0xee, 0xf3, 0xf3, 0xff, 0x5c, 0x0e, 0xce, 0x69, 0xb4, - 0x61, 0x3f, 0xa4, 0xce, 0xd6, 0x8c, 0x6d, 0xd0, 0x5b, 0xd4, 0xa2, 0xce, 0x71, 0x8d, 0xa8, 0xdf, - 0xc1, 0x94, 0x33, 0x61, 0x63, 0xee, 0xba, 0xd4, 0x38, 0x39, 0xe9, 0x80, 0xd4, 0x5f, 0x1b, 0x00, - 0x25, 0xd5, 0xea, 0x3d, 0xb1, 0xe6, 0x5c, 0xe6, 0x56, 0xa6, 0x78, 0x54, 0x5b, 0x99, 0xfe, 0xfd, - 0x6d, 0x65, 0x4a, 0xfb, 0xdd, 0xca, 0x0c, 0xec, 0x65, 0x2b, 0xd3, 0x8e, 0x6f, 0x65, 0x06, 0x71, - 0x2b, 0xf3, 0x72, 0xcf, 0xad, 0xcc, 0xac, 0x65, 0x1c, 0x70, 0x23, 0x73, 0x62, 0x53, 0x55, 0x1f, - 0x64, 0x07, 0x76, 0x95, 0x4d, 0x8a, 0x0d, 0xdb, 0x31, 0xa8, 0x21, 0x36, 0x5e, 0x78, 0xea, 0xef, - 0x08, 0x98, 0x16, 0x60, 0x13, 0x79, 0xbf, 0x47, 0xf7, 0x92, 0xf7, 0xfb, 0x08, 0xf6, 0x5f, 0x5f, - 0xce, 0xc3, 0xc4, 0x0c, 0x75, 0x3c, 0x1e, 0x46, 0xf6, 0x28, 0x5c, 0xe2, 0xca, 0x70, 0x46, 0x62, - 0x88, 0x16, 0x79, 0x3e, 0x74, 0xf3, 0x6b, 0x50, 0xc7, 0x8b, 0x7b, 0x09, 0xc6, 0xe9, 0x59, 0xf5, - 0x7e, 0xee, 0x3d, 0x31, 0x76, 0x83, 0xea, 0x7d, 0x38, 0x17, 0xa4, 0x29, 0x7e, 0x69, 0x01, 0xbd, - 0x94, 0x4e, 0xaf, 0xb8, 0xff, 0x74, 0x7a, 0xea, 0x2f, 0xe7, 0xe0, 0x8a, 0x46, 0x2d, 0xba, 0xa9, - 0xaf, 0xb5, 0xa8, 0xd4, 0x2c, 0xb1, 0x32, 0xb0, 0x59, 0xc3, 0x74, 0xdb, 0xba, 0xd7, 0xd8, 0x38, - 0x94, 0x8c, 0xe6, 0x60, 0x44, 0x9e, 0xbf, 0xf6, 0x31, 0xb7, 0x45, 0xca, 0xa9, 0xbf, 0x56, 0x84, - 0x81, 0x69, 0xdb, 0xbb, 0x6d, 0x1f, 0x32, 0xbf, 0x63, 0x38, 0xe5, 0xe7, 0xf7, 0x71, 0xd6, 0xf3, - 0x29, 0xac, 0x5c, 0x4a, 0x79, 0x81, 0x2e, 0xa4, 0x6b, 0x76, 0x22, 0x35, 0x88, 0x4f, 0xb6, 0xcf, - 0xcc, 0x8e, 0xaf, 0xc2, 0x10, 0x46, 0x7f, 0x91, 0x4e, 0x63, 0xd1, 0x41, 0xdb, 0x63, 0xc0, 0x78, - 0x1d, 0x21, 0x29, 0xf9, 0x81, 0x48, 0xdc, 0xdb, 0xd2, 0xe1, 0x33, 0x41, 0xca, 0x21, 0x70, 0x5f, - 0xe6, 0x17, 0x79, 0xd8, 0x26, 0x29, 0x6b, 0x0e, 0x9e, 0xa2, 0xc4, 0x9a, 0x14, 0x10, 0x1e, 0x61, - 0x96, 0xc6, 0x19, 0x18, 0x9d, 0xb6, 0x3d, 0xc9, 0x19, 0x78, 0x28, 0x7c, 0x06, 0xca, 0x24, 0x9f, - 0xee, 0x09, 0x1c, 0x2d, 0xa3, 0x7e, 0xb7, 0x08, 0x23, 0xfe, 0xcf, 0x63, 0xd2, 0x9d, 0x17, 0xa1, - 0x34, 0x6f, 0x4b, 0x89, 0x43, 0xd0, 0x81, 0x78, 0xc3, 0x76, 0x63, 0x9e, 0xd1, 0x82, 0x88, 0x49, - 0x7d, 0xc9, 0x36, 0x64, 0xf7, 0x77, 0x94, 0xba, 0x65, 0x1b, 0x89, 0xe7, 0xc3, 0x01, 0x21, 0xb9, - 0x02, 0x45, 0x7c, 0x39, 0x20, 0x1d, 0xe4, 0xc7, 0x5e, 0x0b, 0x20, 0x5e, 0xd2, 0xca, 0xd2, 0x7e, - 0xb5, 0x72, 0xe0, 0xa0, 0x5a, 0x39, 0x78, 0xb4, 0x5a, 0xf9, 0x1e, 0x8c, 0x60, 0x4d, 0x7e, 0xde, - 0xc1, 0xdd, 0x17, 0xd6, 0x27, 0xc4, 0xda, 0x37, 0xca, 0xdb, 0x2d, 0xb2, 0x0f, 0xe2, 0x92, 0x17, - 0x61, 0x15, 0xd3, 0x5d, 0x38, 0xc4, 0x76, 0xfa, 0x1f, 0xe7, 0x60, 0xe0, 0xae, 0xf5, 0xc0, 0xb2, - 0x37, 0x0f, 0xa7, 0x71, 0x2f, 0xc3, 0xb0, 0x60, 0x23, 0xad, 0x2e, 0xf8, 0x22, 0xbc, 0xcb, 0xc1, - 0x75, 0xe4, 0xa4, 0xc9, 0x54, 0xe4, 0xad, 0xa0, 0x10, 0x3e, 0x0e, 0x2a, 0x84, 0xa9, 0x77, 0xfc, - 0x42, 0x8d, 0x68, 0xee, 0x0d, 0x99, 0x9c, 0x5c, 0x86, 0x62, 0x85, 0x35, 0x55, 0x8a, 0xc1, 0xcb, - 0x9a, 0xa2, 0x21, 0x54, 0xfd, 0x72, 0x11, 0xc6, 0x62, 0x07, 0x5f, 0xcf, 0xc3, 0x90, 0x38, 0x78, - 0x32, 0xfd, 0x64, 0x20, 0xf8, 0x78, 0x28, 0x00, 0x6a, 0x83, 0xfc, 0xcf, 0xaa, 0x41, 0x3e, 0x03, - 0x03, 0xb6, 0x8b, 0x8b, 0x22, 0x7e, 0xcb, 0x58, 0x38, 0x84, 0x96, 0x6b, 0xac, 0xed, 0x7c, 0x70, - 0x08, 0x12, 0x59, 0x23, 0x6d, 0x17, 0x3f, 0xed, 0x26, 0x0c, 0xe9, 0xae, 0x4b, 0xbd, 0xba, 0xa7, - 0x37, 0xe5, 0xfc, 0x20, 0x01, 0x50, 0x1e, 0x1d, 0x08, 0x5c, 0xd5, 0x9b, 0xe4, 0xb3, 0x30, 0xda, - 0x70, 0x28, 0x2e, 0x9b, 0x7a, 0x8b, 0xb5, 0x52, 0x32, 0x6b, 0x23, 0x08, 0xf9, 0xfe, 0x24, 0x44, - 0x54, 0x0d, 0x72, 0x0f, 0x46, 0xc5, 0xe7, 0x70, 0xcf, 0x7d, 0x1c, 0x68, 0x63, 0xe1, 0x32, 0xc6, - 0x45, 0xc2, 0x7d, 0xf7, 0xc5, 0x03, 0x0e, 0x99, 0x5c, 0xe6, 0x6b, 0x48, 0xa4, 0x64, 0x19, 0xc8, - 0x26, 0x5d, 0xab, 0xeb, 0x5d, 0x6f, 0x83, 0xd5, 0xc5, 0xc3, 0xdb, 0x8b, 0x44, 0x9e, 0xf8, 0xea, - 0x21, 0x89, 0x95, 0x1f, 0x83, 0x6c, 0xd2, 0xb5, 0x72, 0x04, 0x49, 0xee, 0xc3, 0xf9, 0x64, 0x11, - 0xf6, 0xc9, 0xfc, 0x72, 0xe0, 0xb9, 0x9d, 0xed, 0xc9, 0xc9, 0x54, 0x02, 0x89, 0xed, 0xd9, 0x04, - 0xdb, 0xaa, 0x71, 0xbb, 0x38, 0x38, 0x30, 0x3e, 0xa8, 0x8d, 0xb1, 0xb2, 0xbe, 0x09, 0x69, 0x1a, - 0xea, 0xef, 0xe7, 0x98, 0xa9, 0xc8, 0x3e, 0x08, 0x33, 0x99, 0x33, 0x5d, 0x6f, 0xef, 0x53, 0xd7, - 0xdb, 0x61, 0xce, 0xd1, 0x92, 0xdb, 0x63, 0x76, 0xd5, 0x04, 0x96, 0x4c, 0x41, 0xc9, 0x90, 0x4f, - 0xcd, 0x2e, 0x44, 0x3b, 0xc1, 0xaf, 0x47, 0x13, 0x54, 0xe4, 0x2a, 0x14, 0xd9, 0x92, 0x15, 0xdf, - 0x32, 0xcb, 0xd6, 0x85, 0x86, 0x14, 0xea, 0x8f, 0xe4, 0x61, 0x44, 0xfa, 0x9a, 0x1b, 0x87, 0xfa, - 0x9c, 0x37, 0xf6, 0xd6, 0x4c, 0xdf, 0xe9, 0x05, 0xf7, 0x52, 0x7e, 0x93, 0x6f, 0x06, 0xa2, 0xd8, - 0xd3, 0x85, 0x94, 0x10, 0xcc, 0xab, 0xe2, 0x43, 0x4b, 0x7b, 0xdf, 0x3e, 0x32, 0xfa, 0xdb, 0xc5, - 0xc1, 0xfc, 0x78, 0xe1, 0x76, 0x71, 0xb0, 0x38, 0xde, 0x8f, 0x71, 0xb8, 0x30, 0xf4, 0x35, 0xdf, - 0x9b, 0x5b, 0xeb, 0x66, 0xf3, 0x84, 0xbf, 0x1d, 0x39, 0xda, 0x18, 0x65, 0x31, 0xd9, 0x9c, 0xf0, - 0x87, 0x24, 0x1f, 0xaa, 0x6c, 0x4e, 0x73, 0x94, 0x0a, 0xd9, 0xfc, 0x93, 0x1c, 0x28, 0xa9, 0xb2, - 0x29, 0x1f, 0x93, 0x1f, 0xc4, 0xd1, 0x65, 0x2a, 0xfd, 0xe3, 0x3c, 0x4c, 0x54, 0x2d, 0x8f, 0x36, - 0xf9, 0x8e, 0xf1, 0x84, 0x4f, 0x15, 0x77, 0x60, 0x58, 0xfa, 0x18, 0xd1, 0xe7, 0x4f, 0x06, 0xfb, - 0xf1, 0x10, 0x95, 0xc1, 0x49, 0x2e, 0x7d, 0x74, 0x2f, 0x71, 0xe2, 0x42, 0x3e, 0xe1, 0x73, 0xce, - 0xc9, 0x10, 0xf2, 0x09, 0x9f, 0xbc, 0x3e, 0xa2, 0x42, 0xfe, 0xdf, 0x73, 0x70, 0x36, 0xa5, 0x72, - 0x72, 0x05, 0x06, 0x6a, 0xdd, 0x35, 0x0c, 0xbb, 0x95, 0x0b, 0x3d, 0x86, 0xdd, 0xee, 0x1a, 0x46, - 0xdc, 0xd2, 0x7c, 0x24, 0x59, 0xc5, 0xc7, 0xf5, 0xcb, 0xd5, 0xca, 0x8c, 0x90, 0xaa, 0x2a, 0x85, - 0x09, 0x60, 0xe0, 0xb4, 0x2f, 0x0b, 0x1e, 0xe0, 0xdb, 0xa6, 0xd1, 0x88, 0x3d, 0xc0, 0x67, 0x65, - 0xc8, 0x0f, 0xc2, 0x50, 0xf9, 0x83, 0xae, 0x43, 0x91, 0x2f, 0x97, 0xf8, 0xc7, 0x02, 0xbe, 0x3e, - 0x22, 0x8d, 0x33, 0x8f, 0x25, 0xc0, 0x28, 0xe2, 0xbc, 0x43, 0x86, 0xea, 0x4f, 0xe7, 0xe0, 0x52, - 0x76, 0xeb, 0xc8, 0xa7, 0x60, 0x80, 0xed, 0xcc, 0xcb, 0xda, 0x92, 0xf8, 0x74, 0x9e, 0xd5, 0xd7, - 0x6e, 0xd1, 0xba, 0xee, 0xc8, 0xc6, 0xbe, 0x4f, 0x46, 0xde, 0x86, 0xe1, 0xaa, 0xeb, 0x76, 0xa9, - 0x53, 0x7b, 0xf9, 0xae, 0x56, 0x15, 0x7b, 0x42, 0xdc, 0x73, 0x98, 0x08, 0xae, 0xbb, 0x2f, 0xc7, - 0x02, 0x6b, 0xc9, 0xf4, 0xea, 0x4f, 0xe4, 0xe0, 0x72, 0xaf, 0xaf, 0x22, 0x2f, 0xc3, 0xe0, 0x2a, - 0xb5, 0x74, 0xcb, 0xab, 0x56, 0x44, 0x93, 0x70, 0x8b, 0xe5, 0x21, 0x2c, 0xba, 0x53, 0x08, 0x08, - 0x59, 0x21, 0x7e, 0xae, 0x18, 0x38, 0x32, 0xf0, 0x33, 0x50, 0x84, 0xc5, 0x0a, 0xf9, 0x84, 0xea, - 0x1f, 0xe4, 0x61, 0x64, 0xa5, 0xd5, 0x6d, 0x9a, 0xd2, 0xc2, 0x71, 0x60, 0x7b, 0xdb, 0xb7, 0x7e, - 0xf3, 0xfb, 0xb3, 0x7e, 0xd9, 0x70, 0x73, 0x0e, 0x38, 0xdc, 0xfc, 0x72, 0xe4, 0x2d, 0x28, 0x75, - 0xf0, 0x3b, 0xe2, 0x27, 0xb1, 0xfc, 0xeb, 0xb2, 0x4e, 0x62, 0x79, 0x19, 0x36, 0xbe, 0x1a, 0x87, - 0x18, 0x5f, 0x61, 0x59, 0x49, 0xa0, 0xe1, 0x22, 0x71, 0x2a, 0xd0, 0x23, 0x11, 0x68, 0xb8, 0x20, - 0x9c, 0x0a, 0xf4, 0x10, 0x02, 0xfd, 0xb5, 0x3c, 0x8c, 0x45, 0xab, 0x24, 0x9f, 0x82, 0x61, 0x5e, - 0x0d, 0x3f, 0x17, 0xca, 0x49, 0x4e, 0xc5, 0x21, 0x58, 0x03, 0xfe, 0x43, 0x1c, 0x70, 0x9d, 0xd9, - 0xd0, 0xdd, 0x7a, 0x78, 0x42, 0xc3, 0xef, 0x6f, 0x07, 0xb9, 0x27, 0x54, 0x0c, 0xa5, 0x8d, 0x6d, - 0xe8, 0xee, 0x4c, 0xf8, 0x9b, 0xcc, 0x02, 0x71, 0x68, 0xd7, 0xa5, 0x51, 0x06, 0x45, 0x64, 0x20, - 0x52, 0xaa, 0xc7, 0xb1, 0xda, 0x04, 0x87, 0xc9, 0x6c, 0xbe, 0x10, 0x34, 0x1b, 0x95, 0xa1, 0x7f, - 0x0f, 0xf9, 0xde, 0x25, 0xfa, 0xf4, 0x63, 0x4e, 0x4e, 0x50, 0xd1, 0x3d, 0x9d, 0x6f, 0xca, 0xfd, - 0x0e, 0x50, 0x7f, 0xb4, 0x03, 0xfd, 0xcb, 0x16, 0x5d, 0x5e, 0x27, 0x2f, 0xc1, 0x10, 0x53, 0x98, - 0x05, 0x9b, 0xf5, 0x65, 0x4e, 0xf8, 0x4f, 0x48, 0x9a, 0x84, 0x88, 0xf9, 0x3e, 0x2d, 0xa4, 0x22, - 0x37, 0x01, 0xc2, 0x27, 0x66, 0x42, 0xfb, 0x88, 0x5c, 0x86, 0x63, 0xe6, 0xfb, 0x34, 0x89, 0xce, - 0x2f, 0x25, 0x1e, 0xe8, 0x14, 0x92, 0xa5, 0x38, 0xc6, 0x2f, 0x25, 0xc6, 0xc7, 0x02, 0x10, 0xf6, - 0x6b, 0x45, 0x77, 0xdd, 0x4d, 0xdb, 0x31, 0x66, 0x36, 0x74, 0xab, 0x49, 0xe3, 0xbb, 0xa7, 0x24, - 0xc5, 0x7c, 0x9f, 0x96, 0x52, 0x8e, 0xbc, 0x01, 0x23, 0xb2, 0x43, 0x69, 0xdc, 0xe9, 0x43, 0xc6, - 0xcd, 0xf7, 0x69, 0x11, 0x5a, 0xf2, 0x1a, 0x0c, 0x8b, 0xdf, 0xb7, 0x6d, 0x71, 0xa3, 0x2c, 0xc5, - 0x22, 0x92, 0x50, 0xf3, 0x7d, 0x9a, 0x4c, 0x29, 0x55, 0xba, 0xe2, 0x98, 0x96, 0x27, 0xde, 0x28, - 0xc7, 0x2b, 0x45, 0x9c, 0x54, 0x29, 0xfe, 0x26, 0x6f, 0xc3, 0x68, 0x10, 0xe4, 0xe9, 0x7d, 0xda, - 0xf0, 0xc4, 0xe1, 0xf7, 0xf9, 0x58, 0x61, 0x8e, 0x9c, 0xef, 0xd3, 0xa2, 0xd4, 0xe4, 0x2a, 0x94, - 0x34, 0xea, 0x9a, 0x1f, 0xf8, 0xd7, 0xc5, 0x63, 0xd2, 0x38, 0x37, 0x3f, 0x60, 0x52, 0x12, 0x78, - 0xd6, 0x3b, 0xe1, 0xfd, 0xb4, 0x38, 0xaa, 0x26, 0xb1, 0x5a, 0x66, 0x2d, 0x83, 0xf5, 0x8e, 0xe4, - 0x9c, 0xf0, 0xd9, 0x30, 0xf4, 0x95, 0x48, 0xda, 0x3a, 0x1c, 0x8f, 0x31, 0x20, 0x63, 0xe7, 0xfb, - 0xb4, 0x18, 0xbd, 0x24, 0xd5, 0x8a, 0xe9, 0x3e, 0x10, 0xd1, 0x46, 0xe3, 0x52, 0x65, 0x28, 0x49, - 0xaa, 0xec, 0xa7, 0x54, 0xf5, 0x12, 0xf5, 0x36, 0x6d, 0xe7, 0x81, 0x88, 0x2d, 0x1a, 0xaf, 0x5a, - 0x60, 0xa5, 0xaa, 0x05, 0x44, 0xae, 0x9a, 0x0d, 0xb8, 0xb1, 0xf4, 0xaa, 0x75, 0x4f, 0x97, 0xab, - 0xe6, 0x27, 0x71, 0x7e, 0x27, 0x2d, 0x50, 0xfd, 0x21, 0xcf, 0xf6, 0x9f, 0xec, 0x50, 0xc4, 0x49, - 0x1d, 0x8a, 0xbf, 0x59, 0xa5, 0x52, 0x46, 0x77, 0x91, 0xce, 0x3f, 0xa8, 0x54, 0x42, 0xb1, 0x4a, - 0xe5, 0xdc, 0xef, 0x37, 0xe5, 0xb4, 0xe1, 0xca, 0x44, 0xb4, 0x83, 0x42, 0x0c, 0xeb, 0x20, 0x29, - 0xbd, 0xf8, 0x24, 0xa6, 0x24, 0x56, 0x08, 0x92, 0x0f, 0x07, 0x2d, 0x9c, 0x59, 0x99, 0xef, 0xd3, - 0x30, 0x59, 0xb1, 0xca, 0x93, 0x5d, 0x2b, 0x67, 0x91, 0x62, 0xc4, 0xa7, 0x60, 0xb0, 0xf9, 0x3e, - 0x8d, 0x27, 0xc2, 0x7e, 0x49, 0x4a, 0x08, 0xa8, 0x9c, 0x8b, 0x4e, 0x11, 0x01, 0x82, 0x4d, 0x11, - 0x61, 0xda, 0xc0, 0xb9, 0x64, 0xda, 0x3b, 0xe5, 0x7c, 0x74, 0xa9, 0x89, 0xe3, 0xe7, 0xfb, 0xb4, - 0x64, 0xaa, 0xbc, 0xd7, 0x22, 0x99, 0xe0, 0x94, 0x0b, 0xb1, 0x00, 0x60, 0x21, 0x8a, 0x89, 0x4b, - 0xce, 0x19, 0xb7, 0x1c, 0xcb, 0xf5, 0x2f, 0x26, 0xab, 0x8b, 0xd1, 0x8d, 0x4b, 0x0a, 0xc9, 0x7c, - 0x9f, 0x96, 0x56, 0x92, 0xcc, 0x24, 0xf2, 0xb1, 0x29, 0x4a, 0xd4, 0x37, 0x26, 0x86, 0x9e, 0xef, - 0xd3, 0x12, 0x19, 0xdc, 0x6e, 0xca, 0x89, 0xd0, 0x94, 0x27, 0xa2, 0x9d, 0x18, 0x62, 0x58, 0x27, - 0x4a, 0x09, 0xd3, 0x6e, 0xca, 0xc9, 0xb1, 0x94, 0x4b, 0xc9, 0x52, 0xe1, 0xcc, 0x29, 0x25, 0xd1, - 0xd2, 0xd2, 0xf3, 0xfd, 0x28, 0x4f, 0x8a, 0xac, 0xbf, 0xa2, 0x7c, 0x1a, 0xcd, 0x7c, 0x9f, 0x96, - 0x9e, 0x2b, 0x48, 0x4b, 0x4f, 0x94, 0xa3, 0x5c, 0xee, 0xc5, 0x33, 0x68, 0x5d, 0x7a, 0x92, 0x1d, - 0xbd, 0x47, 0xda, 0x12, 0xe5, 0xa9, 0x68, 0xf4, 0xe1, 0x4c, 0xc2, 0xf9, 0x3e, 0xad, 0x47, 0xf2, - 0x93, 0xbb, 0x19, 0x39, 0x44, 0x94, 0xa7, 0xa3, 0x49, 0xbf, 0x53, 0x89, 0xe6, 0xfb, 0xb4, 0x8c, - 0x0c, 0x24, 0x77, 0x33, 0x52, 0x4c, 0x28, 0x93, 0x3d, 0xd9, 0x06, 0xf2, 0xc8, 0x48, 0x50, 0xb1, - 0x9c, 0x9a, 0x9d, 0x41, 0x79, 0x26, 0xaa, 0xba, 0x29, 0x24, 0x4c, 0x75, 0xd3, 0xf2, 0x3a, 0x2c, - 0xa7, 0xa6, 0x13, 0x50, 0x9e, 0xed, 0xc1, 0x30, 0x68, 0x63, 0x6a, 0x22, 0x82, 0xe5, 0xd4, 0x78, - 0xfe, 0x8a, 0x1a, 0x65, 0x98, 0x42, 0xc2, 0x18, 0xa6, 0x65, 0x02, 0x58, 0x4e, 0x0d, 0xfb, 0xae, - 0x3c, 0xd7, 0x83, 0x61, 0xd8, 0xc2, 0xb4, 0x80, 0xf1, 0xaf, 0x45, 0xe2, 0xae, 0x2b, 0x1f, 0x8b, - 0xce, 0x1b, 0x12, 0x8a, 0xcd, 0x1b, 0x72, 0x84, 0xf6, 0x99, 0x44, 0x64, 0x59, 0xe5, 0xe3, 0xd1, - 0x61, 0x1e, 0x43, 0xb3, 0x61, 0x1e, 0x8f, 0x45, 0x3b, 0x93, 0x88, 0xb0, 0xa9, 0x5c, 0xc9, 0x62, - 0x82, 0xe8, 0x28, 0x13, 0x1e, 0x93, 0xb3, 0x9a, 0x12, 0xe2, 0x51, 0xf9, 0x44, 0xd4, 0xaf, 0x3b, - 0x41, 0x30, 0xdf, 0xa7, 0xa5, 0x04, 0x86, 0xd4, 0xd2, 0xe3, 0x19, 0x29, 0x57, 0xa3, 0xc3, 0x36, - 0x8d, 0x86, 0x0d, 0xdb, 0xd4, 0x58, 0x48, 0x0b, 0x69, 0x8f, 0x4f, 0x94, 0x6b, 0x51, 0xc3, 0x2c, - 0x49, 0xc1, 0x0c, 0xb3, 0x94, 0x47, 0x2b, 0x5a, 0x7a, 0x8c, 0x1d, 0xe5, 0xf9, 0x9e, 0x2d, 0x44, - 0x9a, 0x94, 0x16, 0xf2, 0x90, 0x33, 0xa1, 0xed, 0x74, 0xb7, 0xd3, 0xb2, 0x75, 0x43, 0xf9, 0x64, - 0xaa, 0xed, 0xc4, 0x91, 0x92, 0xed, 0xc4, 0x01, 0x6c, 0x95, 0x97, 0xdf, 0x38, 0x28, 0x2f, 0x44, - 0x57, 0x79, 0x19, 0xc7, 0x56, 0xf9, 0xc8, 0x7b, 0x88, 0x99, 0xc4, 0x7b, 0x00, 0xe5, 0xc5, 0xa8, - 0x02, 0xc4, 0xd0, 0x4c, 0x01, 0xe2, 0x2f, 0x08, 0xbe, 0x98, 0xed, 0x41, 0xaf, 0x4c, 0x21, 0xb7, - 0x67, 0x7c, 0x6e, 0x59, 0x74, 0xf3, 0x7d, 0x5a, 0xb6, 0x17, 0x7e, 0x35, 0xc5, 0x21, 0x5e, 0xb9, - 0x1e, 0x55, 0xb0, 0x04, 0x01, 0x53, 0xb0, 0xa4, 0x1b, 0x7d, 0x35, 0xc5, 0xa3, 0x5d, 0xf9, 0x54, - 0x26, 0xab, 0xe0, 0x9b, 0x53, 0xfc, 0xe0, 0x6f, 0xca, 0x2e, 0xe9, 0xca, 0x4b, 0xd1, 0xc5, 0x2e, - 0xc4, 0xb0, 0xc5, 0x4e, 0x72, 0x5d, 0xbf, 0x29, 0x3b, 0x63, 0x2b, 0x37, 0x92, 0xa5, 0xc2, 0x25, - 0x52, 0x72, 0xda, 0xd6, 0xd2, 0x7d, 0x98, 0x95, 0x97, 0xa3, 0x5a, 0x97, 0x46, 0xc3, 0xb4, 0x2e, - 0xd5, 0xff, 0x79, 0x2e, 0xe9, 0x8a, 0xac, 0xdc, 0x8c, 0x6f, 0xb2, 0xa3, 0x78, 0x66, 0xf9, 0x24, - 0xdc, 0x97, 0x3f, 0x1b, 0x0f, 0xb6, 0xa7, 0xbc, 0x12, 0xbb, 0xf6, 0x8d, 0x60, 0x99, 0x7d, 0x1b, - 0x0b, 0xce, 0xf7, 0xd9, 0x78, 0x7c, 0x3a, 0xe5, 0xd5, 0x74, 0x0e, 0x81, 0xae, 0xc4, 0xe3, 0xd9, - 0x7d, 0x36, 0x1e, 0xd2, 0x4d, 0x79, 0x2d, 0x9d, 0x43, 0x20, 0xdd, 0x78, 0x08, 0xb8, 0x97, 0xa4, - 0x20, 0xf3, 0xca, 0xa7, 0xa3, 0xa6, 0x63, 0x80, 0x60, 0xa6, 0x63, 0x18, 0x8a, 0xfe, 0x25, 0x29, - 0x38, 0xbb, 0xf2, 0x7a, 0xa2, 0x48, 0xd0, 0x58, 0x29, 0x84, 0xfb, 0x4b, 0x52, 0x50, 0x73, 0xe5, - 0x8d, 0x44, 0x91, 0xa0, 0x75, 0x52, 0xe8, 0x73, 0xa3, 0xd7, 0xfb, 0x55, 0xe5, 0xcd, 0xe8, 0x61, - 0x70, 0x36, 0xe5, 0x7c, 0x9f, 0xd6, 0xeb, 0x1d, 0xec, 0x17, 0xb3, 0x1d, 0xbb, 0x95, 0xb7, 0xa2, - 0x43, 0x38, 0x8b, 0x8e, 0x0d, 0xe1, 0x4c, 0xe7, 0xf0, 0xb7, 0x63, 0xb1, 0x2c, 0x94, 0xb7, 0xa3, - 0x53, 0x5c, 0x04, 0xc9, 0xa6, 0xb8, 0x78, 0xe4, 0x8b, 0x48, 0x90, 0x06, 0xe5, 0x33, 0xd1, 0x29, - 0x4e, 0xc6, 0xb1, 0x29, 0x2e, 0x12, 0xd0, 0x61, 0x26, 0x11, 0x3b, 0x40, 0x79, 0x27, 0x3a, 0xc5, - 0xc5, 0xd0, 0x6c, 0x8a, 0x8b, 0x47, 0x1b, 0x78, 0x3b, 0xf6, 0x84, 0x5e, 0xf9, 0x6c, 0x7a, 0xfb, - 0x11, 0x29, 0xb7, 0x9f, 0x3f, 0xb8, 0xd7, 0xd2, 0xdf, 0x82, 0x2b, 0xe5, 0xe8, 0xf8, 0x4d, 0xa3, - 0x61, 0xe3, 0x37, 0xf5, 0x1d, 0x79, 0x7c, 0xe3, 0x20, 0xb4, 0x6a, 0xba, 0xc7, 0xc6, 0x21, 0x34, - 0x45, 0x52, 0xc0, 0x91, 0x3d, 0x32, 0xdf, 0x08, 0xcd, 0x64, 0xec, 0x91, 0xfd, 0x6d, 0x50, 0x8c, - 0x9e, 0xcd, 0xae, 0x09, 0x3f, 0x63, 0xa5, 0x12, 0x9d, 0x5d, 0x13, 0x04, 0x6c, 0x76, 0x4d, 0x7a, - 0x27, 0xcf, 0xc1, 0xb8, 0xd0, 0x22, 0xee, 0x3e, 0x6d, 0x5a, 0x4d, 0x65, 0x36, 0xf6, 0xde, 0x32, - 0x86, 0x67, 0xb3, 0x53, 0x1c, 0x86, 0xeb, 0x35, 0x87, 0xcd, 0xb4, 0xcc, 0xce, 0x9a, 0xad, 0x3b, - 0x46, 0x8d, 0x5a, 0x86, 0x32, 0x17, 0x5b, 0xaf, 0x53, 0x68, 0x70, 0xbd, 0x4e, 0x81, 0x63, 0x88, - 0xb8, 0x18, 0x5c, 0xa3, 0x0d, 0x6a, 0x3e, 0xa4, 0xca, 0x2d, 0x64, 0x3b, 0x99, 0xc5, 0x56, 0x90, - 0xcd, 0xf7, 0x69, 0x59, 0x1c, 0x98, 0xad, 0xbe, 0xb8, 0x55, 0x7b, 0x77, 0x21, 0x08, 0x3f, 0xb0, - 0xe2, 0xd0, 0x8e, 0xee, 0x50, 0x65, 0x3e, 0x6a, 0xab, 0xa7, 0x12, 0x31, 0x5b, 0x3d, 0x15, 0x91, - 0x64, 0xeb, 0x8f, 0x85, 0x6a, 0x2f, 0xb6, 0xe1, 0x88, 0x48, 0x2f, 0xcd, 0x66, 0xa7, 0x28, 0x82, - 0x09, 0x68, 0xc1, 0xb6, 0x9a, 0x78, 0x52, 0x71, 0x3b, 0x3a, 0x3b, 0x65, 0x53, 0xb2, 0xd9, 0x29, - 0x1b, 0xcb, 0x54, 0x3d, 0x8a, 0xe5, 0x63, 0xf0, 0x4e, 0x54, 0xd5, 0x53, 0x48, 0x98, 0xaa, 0xa7, - 0x80, 0x93, 0x0c, 0x35, 0xea, 0x52, 0x4f, 0x59, 0xe8, 0xc5, 0x10, 0x49, 0x92, 0x0c, 0x11, 0x9c, - 0x64, 0x38, 0x47, 0xbd, 0xc6, 0x86, 0xb2, 0xd8, 0x8b, 0x21, 0x92, 0x24, 0x19, 0x22, 0x98, 0x6d, - 0x36, 0xa3, 0xe0, 0xe9, 0x6e, 0xeb, 0x81, 0xdf, 0x67, 0x4b, 0xd1, 0xcd, 0x66, 0x26, 0x21, 0xdb, - 0x6c, 0x66, 0x22, 0xc9, 0x4f, 0xec, 0xd9, 0x0f, 0x5e, 0x59, 0xc6, 0x0a, 0xa7, 0x42, 0xbb, 0x60, - 0x2f, 0xa5, 0xe6, 0xfb, 0xb4, 0xbd, 0xfa, 0xd9, 0x7f, 0x32, 0x70, 0x1a, 0x55, 0x56, 0xb0, 0xaa, - 0x33, 0xc1, 0x59, 0x05, 0x07, 0xcf, 0xf7, 0x69, 0x81, 0x5b, 0xe9, 0x6b, 0x30, 0x8c, 0x1f, 0x55, - 0xb5, 0x4c, 0xaf, 0x32, 0xad, 0xbc, 0x1b, 0xdd, 0x32, 0x49, 0x28, 0xb6, 0x65, 0x92, 0x7e, 0xb2, - 0x49, 0x1c, 0x7f, 0xf2, 0x29, 0xa6, 0x32, 0xad, 0x68, 0xd1, 0x49, 0x3c, 0x82, 0x64, 0x93, 0x78, - 0x04, 0x10, 0xd4, 0x5b, 0x71, 0xec, 0x4e, 0x65, 0x5a, 0xa9, 0xa5, 0xd4, 0xcb, 0x51, 0x41, 0xbd, - 0xfc, 0x67, 0x50, 0x6f, 0x6d, 0xa3, 0xeb, 0x55, 0xd8, 0x37, 0xae, 0xa6, 0xd4, 0xeb, 0x23, 0x83, - 0x7a, 0x7d, 0x00, 0x9b, 0x0a, 0x11, 0xb0, 0xe2, 0xd8, 0x6c, 0xd2, 0xbe, 0x63, 0xb6, 0x5a, 0xca, - 0xdd, 0xe8, 0x54, 0x18, 0xc7, 0xb3, 0xa9, 0x30, 0x0e, 0x63, 0xa6, 0x27, 0x6f, 0x15, 0x5d, 0xeb, - 0x36, 0x95, 0x7b, 0x51, 0xd3, 0x33, 0xc4, 0x30, 0xd3, 0x33, 0xfc, 0x85, 0xbb, 0x0b, 0xf6, 0x4b, - 0xa3, 0xeb, 0x0e, 0x75, 0x37, 0x94, 0xfb, 0xb1, 0xdd, 0x85, 0x84, 0xc3, 0xdd, 0x85, 0xf4, 0x9b, - 0x34, 0xe1, 0xc9, 0xc8, 0x42, 0xe3, 0x5f, 0xda, 0xd4, 0xa8, 0xee, 0x34, 0x36, 0x94, 0xcf, 0x21, - 0xab, 0xe7, 0x52, 0x97, 0xaa, 0x28, 0xe9, 0x7c, 0x9f, 0xd6, 0x8b, 0x13, 0x6e, 0xcb, 0xdf, 0x5d, - 0xe0, 0x91, 0x60, 0xb5, 0x95, 0x19, 0x7f, 0x13, 0xfa, 0x5e, 0x6c, 0x5b, 0x9e, 0x24, 0xc1, 0x6d, - 0x79, 0x12, 0x4c, 0x3a, 0xf0, 0x74, 0x6c, 0xab, 0xb6, 0xa8, 0xb7, 0xd8, 0xbe, 0x84, 0x1a, 0x2b, - 0x7a, 0xe3, 0x01, 0xf5, 0x94, 0xcf, 0x23, 0xef, 0x2b, 0x19, 0x1b, 0xbe, 0x18, 0xf5, 0x7c, 0x9f, - 0xb6, 0x0b, 0x3f, 0xa2, 0x42, 0xb1, 0x36, 0xb7, 0xba, 0xa2, 0xfc, 0x40, 0xf4, 0x7c, 0x93, 0xc1, - 0xe6, 0xfb, 0x34, 0xc4, 0x31, 0x2b, 0xed, 0x6e, 0xa7, 0xe9, 0xe8, 0x06, 0xe5, 0x86, 0x16, 0xda, - 0x6e, 0xc2, 0x00, 0xfd, 0xc1, 0xa8, 0x95, 0x96, 0x45, 0xc7, 0xac, 0xb4, 0x2c, 0x1c, 0x53, 0xd4, - 0x48, 0xd2, 0x13, 0xe5, 0x0b, 0x51, 0x45, 0x8d, 0x20, 0x99, 0xa2, 0x46, 0x53, 0xa4, 0x7c, 0x0e, - 0x2e, 0x04, 0xfb, 0x79, 0xb1, 0xfe, 0xf2, 0x4e, 0x53, 0xbe, 0x88, 0x7c, 0x9e, 0x4e, 0x5c, 0x06, - 0x44, 0xa8, 0xe6, 0xfb, 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, 0xd6, 0x76, 0x61, 0x1e, 0x58, 0x6b, 0x59, - 0x1c, 0xc8, 0x55, 0x28, 0xd5, 0x6a, 0x8b, 0x5a, 0xd7, 0x52, 0x1a, 0x31, 0x6f, 0x59, 0x84, 0xce, - 0xf7, 0x69, 0x02, 0xcf, 0xcc, 0xa0, 0xd9, 0x96, 0xee, 0x7a, 0x66, 0xc3, 0xc5, 0x11, 0xe3, 0x8f, - 0x10, 0x23, 0x6a, 0x06, 0xa5, 0xd1, 0x30, 0x33, 0x28, 0x0d, 0xce, 0xec, 0xc5, 0x19, 0xdd, 0x75, - 0x75, 0xcb, 0x70, 0xf4, 0x69, 0x5c, 0x26, 0x68, 0xec, 0x35, 0x56, 0x04, 0xcb, 0xec, 0xc5, 0x28, - 0x04, 0x0f, 0xdf, 0x7d, 0x88, 0x6f, 0xe6, 0xac, 0xc7, 0x0e, 0xdf, 0x63, 0x78, 0x3c, 0x7c, 0x8f, - 0xc1, 0xd0, 0xee, 0xf4, 0x61, 0x1a, 0x6d, 0x9a, 0x4c, 0x44, 0x4a, 0x33, 0x66, 0x77, 0xc6, 0x09, - 0xd0, 0xee, 0x8c, 0x03, 0x23, 0x4d, 0xf2, 0x97, 0xdb, 0x8d, 0x8c, 0x26, 0x85, 0xab, 0x6c, 0xa2, - 0x0c, 0x5b, 0xbf, 0xc3, 0xc1, 0x51, 0xd9, 0xb2, 0xf4, 0xb6, 0x5d, 0x99, 0xf6, 0xa5, 0x6e, 0x46, - 0xd7, 0xef, 0x4c, 0x42, 0xb6, 0x7e, 0x67, 0x22, 0xd9, 0xec, 0xea, 0x6f, 0xb4, 0x36, 0x74, 0x87, - 0x1a, 0x15, 0xd3, 0xc1, 0x93, 0xc5, 0x2d, 0xbe, 0x35, 0x7c, 0x3f, 0x3a, 0xbb, 0xf6, 0x20, 0x65, - 0xb3, 0x6b, 0x0f, 0x34, 0x33, 0xf2, 0xd2, 0xd1, 0x1a, 0xd5, 0x0d, 0xe5, 0x41, 0xd4, 0xc8, 0xcb, - 0xa6, 0x64, 0x46, 0x5e, 0x36, 0x36, 0xfb, 0x73, 0xee, 0x3b, 0xa6, 0x47, 0x95, 0xd6, 0x5e, 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, 0x81, 0x33, 0x78, 0x0b, 0xae, 0x75, 0x83, 0x7b, 0x9c, 0x1f, 0x8e, 0x7e, 0x66, 0x0c, 0xcd, - 0x3e, 0x33, 0x06, 0x8a, 0x30, 0x11, 0xd3, 0x96, 0x93, 0xc1, 0x24, 0x3c, 0x1f, 0x8c, 0x81, 0xc8, - 0x02, 0x90, 0x5a, 0x79, 0x71, 0xa1, 0x6a, 0xac, 0xc8, 0x57, 0x64, 0x6e, 0xf4, 0x04, 0x36, 0x49, - 0x31, 0xdf, 0xa7, 0xa5, 0x94, 0x23, 0xef, 0xc3, 0x65, 0x01, 0x15, 0x2f, 0xae, 0x31, 0xed, 0xbf, - 0x11, 0x2c, 0x08, 0x5e, 0xd4, 0x8f, 0xad, 0x17, 0xed, 0x7c, 0x9f, 0xd6, 0x93, 0x57, 0x76, 0x5d, - 0x62, 0x7d, 0xe8, 0xee, 0xa5, 0xae, 0x60, 0x91, 0xe8, 0xc9, 0x2b, 0xbb, 0x2e, 0x21, 0xf7, 0x87, - 0x7b, 0xa9, 0x2b, 0xe8, 0x84, 0x9e, 0xbc, 0x88, 0x0b, 0x93, 0xbd, 0xf0, 0xe5, 0x56, 0x4b, 0xd9, - 0xc4, 0xea, 0x3e, 0xb1, 0x97, 0xea, 0xca, 0x68, 0x70, 0xee, 0xc6, 0x91, 0xcd, 0xd2, 0xcb, 0x1d, - 0x6a, 0xd5, 0x22, 0x0b, 0xd0, 0xa3, 0xe8, 0x2c, 0x9d, 0x20, 0x60, 0xb3, 0x74, 0x02, 0xc8, 0x06, - 0x94, 0xfc, 0x5c, 0x45, 0xd9, 0x8a, 0x0e, 0x28, 0x19, 0xc7, 0x06, 0x54, 0xe4, 0x69, 0xcb, 0x32, - 0x9c, 0x5d, 0x7e, 0xe0, 0xe9, 0xbe, 0x05, 0xe9, 0x8a, 0xae, 0xfc, 0x20, 0x76, 0xc9, 0x94, 0x24, - 0xc1, 0x4b, 0xa6, 0x24, 0x98, 0x8d, 0x11, 0x06, 0xae, 0x6d, 0x59, 0x8d, 0x39, 0xdd, 0x6c, 0x75, - 0x1d, 0xaa, 0xfc, 0x6b, 0xd1, 0x31, 0x12, 0x43, 0xb3, 0x31, 0x12, 0x03, 0xb1, 0x05, 0x9a, 0x81, - 0xca, 0xae, 0x6b, 0x36, 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, 0x82, - 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, 0x92, 0xf9, 0x88, 0x91, 0xf2, - 0x23, 0xb9, 0x2c, 0x46, 0xc1, 0xf0, 0x48, 0x14, 0x8a, 0x32, 0xd2, 0xe8, 0x43, 0x93, 0x6e, 0x2a, - 0x5f, 0xca, 0x64, 0xc4, 0x09, 0xa2, 0x8c, 0x38, 0x8c, 0xbc, 0x07, 0x17, 0x42, 0xd8, 0x22, 0x6d, - 0xaf, 0x05, 0x33, 0xd3, 0x8f, 0xe6, 0xa2, 0x66, 0x70, 0x3a, 0x19, 0x33, 0x83, 0xd3, 0x31, 0x69, - 0xac, 0x85, 0xe8, 0xfe, 0xed, 0x5d, 0x58, 0x07, 0x12, 0xcc, 0x60, 0x90, 0xc6, 0x5a, 0x48, 0xf3, - 0xc7, 0x76, 0x61, 0x1d, 0xc8, 0x34, 0x83, 0x01, 0xf9, 0xc9, 0x1c, 0x5c, 0x49, 0x47, 0x95, 0x5b, - 0xad, 0x39, 0xdb, 0x09, 0x71, 0xca, 0x9f, 0xc9, 0x45, 0x0f, 0x1a, 0xf6, 0x56, 0x6c, 0xbe, 0x4f, - 0xdb, 0x63, 0x05, 0xe4, 0x33, 0x30, 0x5a, 0xee, 0x1a, 0xa6, 0x87, 0x17, 0x6f, 0xcc, 0x70, 0xfe, - 0xf1, 0x5c, 0x6c, 0x8b, 0x23, 0x63, 0x71, 0x8b, 0x23, 0x03, 0xc8, 0x6d, 0x98, 0xa8, 0xd1, 0x46, - 0xd7, 0x31, 0xbd, 0x2d, 0x8d, 0x76, 0x6c, 0xc7, 0x63, 0x3c, 0xfe, 0x6c, 0x2e, 0x3a, 0x89, 0x25, - 0x28, 0xd8, 0x24, 0x96, 0x00, 0x92, 0x7b, 0x89, 0x5b, 0x79, 0xd1, 0x99, 0x3f, 0x91, 0xeb, 0x79, - 0x2d, 0x1f, 0xf4, 0x65, 0x7a, 0x71, 0xb2, 0x12, 0xbb, 0x45, 0x17, 0x5c, 0x7f, 0x32, 0xd7, 0xe3, - 0x1a, 0x5d, 0x9a, 0xe1, 0x92, 0x60, 0xc6, 0x31, 0x25, 0x03, 0xbc, 0xf2, 0xe7, 0x72, 0x3d, 0xae, - 0xbd, 0x43, 0x8e, 0x69, 0xc9, 0xe3, 0x5f, 0xe1, 0x9e, 0x22, 0x82, 0xd1, 0x4f, 0xe5, 0x92, 0xae, - 0x22, 0x41, 0x79, 0x89, 0x90, 0x15, 0xbb, 0xeb, 0x06, 0x4a, 0xff, 0xe5, 0x5c, 0xd2, 0x37, 0x2f, - 0x2c, 0x16, 0xfe, 0x22, 0x14, 0x2e, 0xcd, 0x3e, 0xf2, 0xa8, 0x63, 0xe9, 0x2d, 0xec, 0xce, 0x9a, - 0x67, 0x3b, 0x7a, 0x93, 0xce, 0x5a, 0xfa, 0x5a, 0x8b, 0x2a, 0x3f, 0x9d, 0x8b, 0x5a, 0xb0, 0xd9, - 0xa4, 0xcc, 0x82, 0xcd, 0xc6, 0x92, 0x0d, 0x78, 0x32, 0x0d, 0x5b, 0x31, 0x5d, 0xac, 0xe7, 0x2b, - 0xb9, 0xa8, 0x09, 0xdb, 0x83, 0x96, 0x99, 0xb0, 0x3d, 0xd0, 0xe4, 0x06, 0x0c, 0x4d, 0xdb, 0xfe, - 0xf4, 0xfb, 0xe7, 0x63, 0xce, 0x90, 0x01, 0x66, 0xbe, 0x4f, 0x0b, 0xc9, 0x44, 0x19, 0x31, 0xa8, - 0xbf, 0x9a, 0x2c, 0x13, 0x5e, 0x3e, 0x05, 0x3f, 0x44, 0x19, 0x21, 0xee, 0x7f, 0x27, 0x59, 0x26, - 0xbc, 0xe3, 0x0a, 0x7e, 0xb0, 0x99, 0x84, 0xd7, 0xb8, 0x38, 0x57, 0x66, 0x76, 0xdb, 0xcc, 0x86, - 0xde, 0x6a, 0x51, 0xab, 0x49, 0x95, 0xaf, 0xc5, 0x66, 0x92, 0x74, 0x32, 0x36, 0x93, 0xa4, 0x63, - 0xc8, 0x0f, 0xc2, 0xc5, 0x7b, 0x7a, 0xcb, 0x34, 0x42, 0x9c, 0x9f, 0x0f, 0x5c, 0xf9, 0x99, 0x5c, - 0x74, 0x37, 0x9d, 0x41, 0xc7, 0x76, 0xd3, 0x19, 0x28, 0xb2, 0x08, 0x04, 0x97, 0xd1, 0x60, 0xb6, - 0x60, 0xeb, 0xb3, 0xf2, 0xef, 0xe6, 0xa2, 0x76, 0x6a, 0x92, 0x84, 0xd9, 0xa9, 0x49, 0x28, 0xa9, - 0x67, 0xa7, 0x06, 0x51, 0x7e, 0x36, 0x17, 0x3d, 0xad, 0xc9, 0x22, 0x9c, 0xef, 0xd3, 0xb2, 0xf3, - 0x8b, 0xdc, 0x82, 0xf1, 0xda, 0x4a, 0x75, 0x6e, 0x6e, 0xb6, 0x76, 0xaf, 0x5a, 0xc1, 0x87, 0x0e, - 0x86, 0xf2, 0x17, 0x62, 0x2b, 0x56, 0x9c, 0x80, 0xad, 0x58, 0x71, 0x18, 0x79, 0x13, 0x46, 0x58, - 0xfb, 0xd9, 0x80, 0xc1, 0x4f, 0xfe, 0xb9, 0x5c, 0xd4, 0x9c, 0x92, 0x91, 0xcc, 0x9c, 0x92, 0x7f, - 0x93, 0x1a, 0x9c, 0x63, 0x52, 0x5c, 0x71, 0xe8, 0x3a, 0x75, 0xa8, 0xd5, 0xf0, 0xc7, 0xf4, 0xcf, - 0xe7, 0xa2, 0x56, 0x46, 0x1a, 0x11, 0xb3, 0x32, 0xd2, 0xe0, 0xe4, 0x01, 0x5c, 0x8e, 0x9f, 0x04, - 0xc9, 0xcf, 0x4e, 0x95, 0xbf, 0x98, 0x8b, 0x19, 0xc3, 0x3d, 0x88, 0xd1, 0x18, 0xee, 0x81, 0x27, - 0x16, 0x3c, 0x25, 0x8e, 0x55, 0x84, 0xc3, 0x65, 0xbc, 0xb6, 0xbf, 0xc4, 0x6b, 0xfb, 0x78, 0xe8, - 0x10, 0xd8, 0x83, 0x7a, 0xbe, 0x4f, 0xeb, 0xcd, 0x8e, 0xe9, 0x59, 0x32, 0x01, 0x86, 0xf2, 0x97, - 0x73, 0xe9, 0x1e, 0x29, 0x11, 0x37, 0xe5, 0xb4, 0xcc, 0x19, 0xef, 0x65, 0xa5, 0x6f, 0x50, 0xfe, - 0x4a, 0x6c, 0xbc, 0xa5, 0x93, 0xb1, 0xf1, 0x96, 0x91, 0xff, 0xe1, 0x36, 0x4c, 0x70, 0xa5, 0x5e, - 0xd1, 0x71, 0x18, 0x5a, 0x4d, 0x6a, 0x28, 0xff, 0x5e, 0x6c, 0xb5, 0x4b, 0x50, 0xa0, 0x6b, 0x4f, - 0x1c, 0xc8, 0xa6, 0xee, 0x5a, 0x47, 0xb7, 0x2c, 0x3c, 0x66, 0x55, 0xfe, 0xfd, 0xd8, 0xd4, 0x1d, - 0xa2, 0xd0, 0x71, 0x37, 0xf8, 0xc5, 0x34, 0xa1, 0x57, 0xea, 0x23, 0xe5, 0x3f, 0x88, 0x69, 0x42, - 0x2f, 0x62, 0xa6, 0x09, 0x3d, 0xf3, 0x28, 0xdd, 0xcb, 0x78, 0x02, 0xae, 0x7c, 0x3d, 0xb6, 0x22, - 0xa7, 0x52, 0xb1, 0x15, 0x39, 0xfd, 0x05, 0xf9, 0xbd, 0x8c, 0xe7, 0xd3, 0xca, 0x2f, 0xf4, 0xe6, - 0x1b, 0xae, 0xf4, 0xe9, 0xaf, 0xaf, 0xef, 0x65, 0x3c, 0x3d, 0x56, 0xfe, 0x6a, 0x6f, 0xbe, 0xa1, - 0x63, 0x5f, 0xfa, 0xcb, 0xe5, 0x7a, 0xf6, 0xb3, 0x5d, 0xe5, 0xaf, 0xc5, 0xa7, 0xae, 0x0c, 0x42, - 0x9c, 0xba, 0xb2, 0xde, 0xfe, 0xae, 0xc1, 0x13, 0x5c, 0x43, 0x6e, 0x39, 0x7a, 0x67, 0xa3, 0x46, - 0x3d, 0xcf, 0xb4, 0x9a, 0xfe, 0x4e, 0xec, 0xaf, 0xe7, 0x62, 0xc7, 0x63, 0x59, 0x94, 0x78, 0x3c, - 0x96, 0x85, 0x64, 0xca, 0x9b, 0x78, 0xa0, 0xab, 0xfc, 0x8d, 0x98, 0xf2, 0x26, 0x28, 0x98, 0xf2, - 0x26, 0xdf, 0xf5, 0xde, 0x4e, 0x79, 0x87, 0xaa, 0xfc, 0x87, 0xd9, 0xbc, 0x82, 0xf6, 0xa5, 0x3c, - 0x5f, 0xbd, 0x9d, 0xf2, 0xdc, 0x52, 0xf9, 0x8f, 0xb2, 0x79, 0x85, 0x3e, 0x48, 0xc9, 0x57, 0x9a, - 0xef, 0xc1, 0x05, 0x3e, 0x9b, 0xcf, 0x51, 0x83, 0x46, 0x3e, 0xf4, 0x17, 0x63, 0x63, 0x3f, 0x9d, - 0x0c, 0x8f, 0xdc, 0x53, 0x31, 0x69, 0xac, 0x45, 0x5b, 0xff, 0xe6, 0x2e, 0xac, 0xc3, 0x0d, 0x41, - 0x3a, 0x86, 0xad, 0x37, 0xf2, 0xe3, 0x37, 0xe5, 0x97, 0x62, 0xeb, 0x8d, 0x8c, 0x44, 0x77, 0x0e, - 0xf9, 0xa5, 0xdc, 0x9b, 0xd1, 0x87, 0x5e, 0xca, 0xdf, 0x4a, 0x2d, 0x1c, 0x74, 0x40, 0xf4, 0x55, - 0xd8, 0x9b, 0xd1, 0x47, 0x4d, 0xca, 0x2f, 0xa7, 0x16, 0x0e, 0x3e, 0x20, 0xfa, 0x02, 0x8a, 0x6d, - 0x91, 0xba, 0x9e, 0xcd, 0x59, 0x45, 0xa6, 0x87, 0xbf, 0x1d, 0xdf, 0x22, 0xa5, 0x92, 0xe1, 0x16, - 0x29, 0x15, 0x93, 0xc6, 0x5a, 0x7c, 0xde, 0xaf, 0xec, 0xc2, 0x5a, 0xda, 0xd8, 0xa5, 0x62, 0xd2, - 0x58, 0x8b, 0x8f, 0xff, 0xc6, 0x2e, 0xac, 0xa5, 0x8d, 0x5d, 0x2a, 0x86, 0x99, 0x63, 0x21, 0xe6, - 0x1e, 0x75, 0xdc, 0x50, 0xfd, 0xfe, 0xe3, 0x98, 0x39, 0x96, 0x41, 0xc7, 0xcc, 0xb1, 0x0c, 0x54, - 0x2a, 0x77, 0x21, 0x94, 0x5f, 0xdd, 0x8d, 0x7b, 0x78, 0x2f, 0x93, 0x81, 0x4a, 0xe5, 0x2e, 0xe4, - 0xf2, 0x77, 0x76, 0xe3, 0x1e, 0x5e, 0xcc, 0x64, 0xa0, 0x98, 0x51, 0x54, 0xf3, 0x74, 0xcf, 0x6c, - 0xcc, 0xdb, 0xae, 0x27, 0x2d, 0xf2, 0x7f, 0x37, 0x66, 0x14, 0xa5, 0x11, 0x31, 0xa3, 0x28, 0x0d, - 0x9e, 0x64, 0x2a, 0xa4, 0xf1, 0x6b, 0x3d, 0x99, 0x86, 0x96, 0x56, 0x1a, 0x3c, 0xc9, 0x54, 0x08, - 0xe1, 0x3f, 0xe9, 0xc9, 0x34, 0xf4, 0x94, 0x4f, 0x83, 0x33, 0xcb, 0x74, 0xc6, 0xb1, 0x37, 0xad, - 0xdb, 0x74, 0x93, 0xb6, 0xc4, 0xa7, 0xff, 0x7a, 0xcc, 0x32, 0x8d, 0x13, 0xe0, 0x2d, 0x4a, 0x0c, - 0x16, 0x65, 0x24, 0x3e, 0xf7, 0x37, 0x32, 0x19, 0x85, 0xc7, 0x44, 0x71, 0x58, 0x94, 0x91, 0xf8, - 0xc4, 0xdf, 0xcc, 0x64, 0x14, 0x1e, 0x13, 0xc5, 0x61, 0xa4, 0x0c, 0x63, 0xf8, 0x56, 0x42, 0x77, - 0x7d, 0xcf, 0xcf, 0xdf, 0xc9, 0x45, 0x6f, 0xbd, 0xa2, 0xe8, 0xf9, 0x3e, 0x2d, 0x56, 0x40, 0x66, - 0x21, 0x3e, 0xe9, 0x5b, 0x19, 0x2c, 0x42, 0x7f, 0xc7, 0x28, 0x44, 0x66, 0x21, 0x3e, 0xe6, 0x3f, - 0xcd, 0x60, 0x11, 0x3a, 0x3c, 0x46, 0x21, 0xe4, 0xd3, 0x30, 0x5c, 0x9b, 0x5b, 0x5d, 0xf1, 0xd3, - 0xf3, 0xfd, 0xbd, 0x5c, 0xec, 0x55, 0x51, 0x88, 0xc3, 0x57, 0x45, 0xe1, 0xcf, 0xe9, 0x01, 0xe8, - 0xc7, 0xa3, 0xd4, 0xdb, 0xa5, 0xc1, 0x6f, 0xe6, 0xc6, 0x7f, 0x2b, 0x77, 0xbb, 0x34, 0xf8, 0x5b, - 0xb9, 0xf1, 0xdf, 0x66, 0xff, 0xff, 0x76, 0x6e, 0xfc, 0x77, 0x72, 0xda, 0x13, 0xe1, 0xb0, 0x28, - 0x37, 0xa9, 0xe5, 0xad, 0xb4, 0x74, 0x31, 0xa8, 0x53, 0x51, 0xfc, 0x67, 0x2a, 0x4a, 0xa4, 0xc2, - 0xfa, 0x7a, 0x0e, 0x46, 0x6a, 0x9e, 0x43, 0xf5, 0xb6, 0x88, 0x2c, 0x77, 0x09, 0x06, 0xb9, 0xf3, - 0xb3, 0xff, 0x52, 0x5b, 0x0b, 0x7e, 0x93, 0x2b, 0x30, 0xb6, 0xa0, 0xbb, 0x1e, 0x36, 0xb1, 0x6a, - 0x19, 0xf4, 0x11, 0x3e, 0xfc, 0x2b, 0x68, 0x31, 0x28, 0x59, 0xe0, 0x74, 0xbc, 0x1c, 0x06, 0x13, - 0x2d, 0xec, 0x1a, 0x50, 0x6d, 0xf0, 0xdb, 0xdb, 0x93, 0x7d, 0x18, 0x3f, 0x2d, 0x56, 0x56, 0xfd, - 0xfd, 0x1c, 0x24, 0xdc, 0xb2, 0x0f, 0x1e, 0x41, 0x61, 0x19, 0xce, 0xc4, 0x02, 0xd8, 0x8a, 0xd7, - 0x8b, 0x7b, 0x8c, 0x6f, 0x1b, 0x2f, 0x4d, 0x3e, 0x11, 0xbc, 0x9a, 0xbb, 0xab, 0x2d, 0x88, 0x60, - 0x79, 0x98, 0xe6, 0xa1, 0xeb, 0xb4, 0x34, 0x09, 0x25, 0x82, 0x21, 0x7d, 0x6f, 0x3c, 0x8c, 0xce, - 0x49, 0xae, 0x88, 0x70, 0x0e, 0xb9, 0x30, 0xc4, 0x5e, 0x2c, 0xa9, 0x3c, 0x0f, 0xdf, 0xf0, 0x19, - 0x18, 0xa9, 0xb6, 0x3b, 0xd4, 0x71, 0x6d, 0x4b, 0xf7, 0x6c, 0x47, 0xbc, 0x86, 0xc7, 0xf0, 0x6b, - 0xa6, 0x04, 0x97, 0x43, 0x82, 0xc9, 0xf4, 0xe4, 0x9a, 0x9f, 0xa9, 0xae, 0x80, 0x71, 0x51, 0xf1, - 0x49, 0x6b, 0x3c, 0x51, 0x39, 0xa7, 0x60, 0xa4, 0x77, 0x5d, 0x1d, 0xdf, 0x57, 0x06, 0xa4, 0x5d, - 0x06, 0x90, 0x49, 0x91, 0x82, 0xbc, 0x00, 0x25, 0xbc, 0x8f, 0x72, 0x31, 0x03, 0xa5, 0x08, 0xfc, - 0xd7, 0x42, 0x88, 0x1c, 0x66, 0x8d, 0xd3, 0x90, 0x3b, 0x30, 0x1e, 0x5e, 0xb6, 0xdf, 0x72, 0xec, - 0x6e, 0xc7, 0xcf, 0x39, 0x83, 0x09, 0xde, 0x1f, 0x04, 0xb8, 0x7a, 0x13, 0x91, 0x12, 0x8b, 0x44, - 0x41, 0x32, 0x0f, 0x67, 0x42, 0x18, 0x13, 0x91, 0x9f, 0xeb, 0x0a, 0xf3, 0x8c, 0x4a, 0xbc, 0x98, - 0x38, 0x23, 0x79, 0x46, 0x63, 0xc5, 0x48, 0x15, 0x06, 0xfc, 0xa8, 0x7f, 0x83, 0xbb, 0x2a, 0xe9, - 0x59, 0x11, 0xf5, 0x6f, 0x40, 0x8e, 0xf7, 0xe7, 0x97, 0x27, 0x73, 0x30, 0xa6, 0xd9, 0x5d, 0x8f, - 0xae, 0xda, 0x62, 0x97, 0x2a, 0xa2, 0x4b, 0x62, 0x9b, 0x1c, 0x86, 0xa9, 0x7b, 0xb6, 0x9f, 0x1f, - 0x5f, 0xce, 0xd3, 0x1e, 0x2d, 0x45, 0x96, 0x60, 0x22, 0xe1, 0x96, 0x20, 0x67, 0xad, 0x97, 0x3e, - 0x2f, 0xc9, 0x2c, 0x59, 0x94, 0xfc, 0x78, 0x0e, 0x4a, 0xab, 0x8e, 0x6e, 0x7a, 0xae, 0x78, 0x9a, - 0x79, 0x7e, 0x6a, 0xd3, 0xd1, 0x3b, 0x4c, 0x3f, 0xa6, 0x30, 0xf0, 0xed, 0x3d, 0xbd, 0xd5, 0xa5, - 0xee, 0xf4, 0x7d, 0xf6, 0x75, 0xff, 0xfd, 0xf6, 0xe4, 0x9b, 0x4d, 0x3c, 0xfc, 0x9c, 0x6a, 0xd8, - 0xed, 0xeb, 0x4d, 0x47, 0x7f, 0x68, 0x7a, 0x68, 0x62, 0xea, 0xad, 0xeb, 0x1e, 0x6d, 0xe1, 0x19, - 0xeb, 0x75, 0xbd, 0x63, 0x5e, 0xc7, 0x00, 0xeb, 0xd7, 0x03, 0x4e, 0xbc, 0x06, 0xa6, 0x02, 0x1e, - 0xfe, 0x25, 0xab, 0x00, 0xc7, 0x91, 0x25, 0x00, 0xf1, 0xa9, 0xe5, 0x4e, 0x47, 0xbc, 0xf3, 0x94, - 0x4e, 0x26, 0x7d, 0x0c, 0x57, 0xec, 0x40, 0x60, 0x7a, 0x47, 0x0a, 0x2a, 0xac, 0x49, 0x1c, 0x98, - 0x16, 0xac, 0x8a, 0x16, 0xf9, 0x62, 0x1a, 0x0d, 0x25, 0xee, 0x37, 0x36, 0x45, 0x48, 0xf1, 0x62, - 0x64, 0x0d, 0xce, 0x08, 0xbe, 0x41, 0x0a, 0x92, 0xb1, 0xe8, 0xac, 0x10, 0x43, 0x73, 0xa5, 0x0d, - 0xda, 0x68, 0x08, 0xb0, 0x5c, 0x47, 0xac, 0x04, 0x99, 0x0e, 0x53, 0x26, 0x2f, 0xe9, 0x6d, 0xea, - 0x2a, 0x67, 0x50, 0x63, 0x2f, 0xef, 0x6c, 0x4f, 0x2a, 0x7e, 0x79, 0x0c, 0x80, 0x29, 0x8b, 0x2e, - 0x5a, 0x44, 0xe6, 0xc1, 0xb5, 0x7e, 0x3c, 0x85, 0x47, 0x5c, 0xe7, 0xa3, 0x45, 0xc8, 0x0c, 0x8c, - 0x06, 0xcf, 0x4c, 0xee, 0xde, 0xad, 0x56, 0xf0, 0x21, 0xa9, 0x88, 0x81, 0x1a, 0x4b, 0x12, 0x22, - 0x33, 0x89, 0x94, 0x91, 0x62, 0x73, 0xf0, 0x97, 0xa5, 0xb1, 0xd8, 0x1c, 0x9d, 0x94, 0xd8, 0x1c, - 0x2b, 0xe4, 0x6d, 0x18, 0x2e, 0xdf, 0xaf, 0x89, 0x98, 0x23, 0xae, 0x72, 0x36, 0xcc, 0x38, 0xa5, - 0x6f, 0xba, 0x75, 0x3f, 0x3e, 0x89, 0xdc, 0x74, 0x99, 0x9e, 0xcc, 0xc2, 0x58, 0xc4, 0x53, 0xcd, - 0x55, 0xce, 0x21, 0x07, 0x6c, 0xb9, 0x8e, 0x98, 0xba, 0x23, 0x50, 0xf2, 0xf0, 0x8a, 0x16, 0x62, - 0x5a, 0x53, 0x31, 0x5d, 0xcc, 0xde, 0xa3, 0x51, 0x0c, 0x6f, 0x82, 0xcf, 0x52, 0x07, 0xb9, 0xd6, - 0x18, 0x02, 0x55, 0x77, 0x38, 0x4e, 0xee, 0xd1, 0x58, 0x31, 0xf2, 0x3e, 0x10, 0xcc, 0xf7, 0x43, - 0x0d, 0xff, 0xe2, 0xb2, 0x5a, 0x71, 0x95, 0x0b, 0x18, 0x00, 0x9c, 0xc4, 0xc3, 0x29, 0x54, 0x2b, - 0xd3, 0x57, 0xc4, 0xf4, 0xf1, 0xb4, 0xce, 0x4b, 0xd5, 0xfd, 0x50, 0x0a, 0x75, 0x33, 0x92, 0x0c, - 0x39, 0x85, 0x2b, 0xd9, 0x84, 0x8b, 0x2b, 0x0e, 0x7d, 0x68, 0xda, 0x5d, 0xd7, 0x5f, 0x3e, 0xfc, - 0x79, 0xeb, 0xe2, 0xae, 0xf3, 0xd6, 0xb3, 0xa2, 0xe2, 0xf3, 0x1d, 0x87, 0x3e, 0xac, 0xfb, 0x61, - 0x9f, 0x23, 0x51, 0x4b, 0xb3, 0xb8, 0x63, 0x4a, 0xe7, 0x0f, 0xba, 0x0e, 0x15, 0x70, 0x93, 0xba, - 0x8a, 0x12, 0x4e, 0xb5, 0x3c, 0x52, 0x8d, 0x19, 0xe0, 0x22, 0x29, 0x9d, 0xa3, 0xc5, 0x88, 0x06, - 0xe4, 0xd6, 0x8c, 0x7f, 0x89, 0x5d, 0x6e, 0xf0, 0xc4, 0xb7, 0xca, 0x13, 0xc8, 0x4c, 0x65, 0x62, - 0x69, 0x36, 0x82, 0x10, 0xf0, 0x75, 0x5d, 0xe0, 0x65, 0xb1, 0x24, 0x4b, 0x93, 0x05, 0x18, 0x5f, - 0x71, 0xf0, 0x48, 0xed, 0x0e, 0xdd, 0x5a, 0xb1, 0x5b, 0x66, 0x63, 0x0b, 0x5f, 0xc7, 0x8a, 0xa9, - 0xb2, 0xc3, 0x71, 0xf5, 0x07, 0x74, 0xab, 0xde, 0x41, 0xac, 0xbc, 0xac, 0xc4, 0x4b, 0xca, 0x21, - 0x99, 0x9f, 0xdc, 0x5b, 0x48, 0x66, 0x0a, 0xe3, 0xe2, 0x0a, 0xfc, 0x91, 0x47, 0x2d, 0xb6, 0xd4, - 0xbb, 0xe2, 0x25, 0xac, 0x12, 0xbb, 0x32, 0x0f, 0xf0, 0x7c, 0xea, 0x10, 0xa3, 0x8c, 0x06, 0x60, - 0xb9, 0x61, 0xf1, 0x22, 0xc9, 0xb8, 0xc5, 0x4f, 0x1d, 0x20, 0x6e, 0xf1, 0xdf, 0x2d, 0xc8, 0xf3, - 0x2f, 0xb9, 0x0c, 0x45, 0x29, 0xad, 0x10, 0x06, 0x65, 0xc5, 0x10, 0xec, 0x45, 0x11, 0x6b, 0x7a, - 0x48, 0xd8, 0x2e, 0x41, 0xf4, 0x1d, 0xcc, 0x23, 0x19, 0x06, 0xea, 0xd4, 0x42, 0x02, 0xcc, 0xe1, - 0xd7, 0x5d, 0x6b, 0x99, 0x0d, 0x0c, 0xcc, 0x5f, 0x90, 0xc2, 0x6d, 0x20, 0x94, 0xc7, 0xe5, 0x97, - 0x48, 0xc8, 0x0d, 0x18, 0xf6, 0x8f, 0x72, 0xc3, 0xa0, 0xc4, 0x18, 0xaf, 0x5d, 0xcc, 0xd6, 0x22, - 0x1c, 0xbc, 0x44, 0x44, 0xde, 0x00, 0x08, 0xa7, 0x03, 0x61, 0x69, 0xe1, 0x52, 0x21, 0xcf, 0x1e, - 0xf2, 0x52, 0x11, 0x52, 0xb3, 0x89, 0x53, 0x56, 0x47, 0x3f, 0x6b, 0x29, 0x4e, 0x9c, 0x11, 0x1d, - 0x96, 0x15, 0x24, 0x5a, 0x84, 0x2c, 0xc3, 0x44, 0x42, 0x03, 0x45, 0x08, 0x63, 0xcc, 0x5c, 0x9f, - 0xa2, 0xbe, 0xf2, 0xc2, 0x9c, 0x28, 0x4b, 0x9e, 0x83, 0xc2, 0x5d, 0xad, 0x2a, 0xc2, 0xa8, 0xf2, - 0x08, 0xbc, 0x91, 0x18, 0x4b, 0x0c, 0xab, 0xfe, 0x68, 0x3e, 0xb1, 0x36, 0x31, 0xe9, 0x09, 0x56, - 0x52, 0x0f, 0xa2, 0xf4, 0xfc, 0xfa, 0xb9, 0xf4, 0x24, 0x22, 0x72, 0x15, 0x06, 0x57, 0xd8, 0xcc, - 0xd0, 0xb0, 0x5b, 0xa2, 0x3f, 0x31, 0x20, 0x56, 0x47, 0xc0, 0xb4, 0x00, 0x4b, 0x6e, 0x48, 0xc9, - 0x76, 0xa5, 0xc8, 0xe4, 0x7e, 0xb2, 0xdd, 0x78, 0x88, 0x6e, 0x4c, 0xbb, 0x7b, 0x23, 0x96, 0xbc, - 0x4b, 0x94, 0x49, 0x59, 0x17, 0xc3, 0x64, 0x5d, 0x81, 0x55, 0xda, 0xbf, 0x9b, 0x55, 0xaa, 0xfe, - 0xfd, 0x5c, 0x72, 0x9c, 0x91, 0x9b, 0xc9, 0x20, 0xc1, 0xb8, 0x08, 0x05, 0x40, 0xb9, 0xd6, 0x20, - 0x5c, 0x70, 0x24, 0xdc, 0x6f, 0xfe, 0xc0, 0xe1, 0x7e, 0x0b, 0xfb, 0x0c, 0xf7, 0xab, 0xfe, 0x3f, - 0xc5, 0x9e, 0x2e, 0xdb, 0xc7, 0x12, 0x16, 0xee, 0x75, 0xb6, 0xb3, 0x62, 0xb5, 0x97, 0xdd, 0xc4, - 0xfe, 0x80, 0x7b, 0xa4, 0xd6, 0x75, 0x3e, 0xb4, 0x5c, 0x2d, 0x4a, 0x49, 0xde, 0x81, 0x11, 0xff, - 0x03, 0x30, 0x8c, 0xb4, 0x14, 0xfe, 0x38, 0x58, 0xd5, 0x62, 0x01, 0x97, 0x23, 0x05, 0xc8, 0x2b, - 0x30, 0x84, 0x36, 0x4d, 0x47, 0x6f, 0xf8, 0x31, 0xc6, 0x79, 0x50, 0x72, 0x1f, 0x28, 0x87, 0x3e, - 0x0b, 0x28, 0xc9, 0x17, 0xa0, 0x24, 0x12, 0x6d, 0xf0, 0x3c, 0xf4, 0xd7, 0xf7, 0xe0, 0xe3, 0x3e, - 0x25, 0x27, 0xd9, 0xe0, 0xbb, 0x14, 0x04, 0x44, 0x76, 0x29, 0x3c, 0xbf, 0xc6, 0x2a, 0x9c, 0x5d, - 0x71, 0xa8, 0x81, 0xaf, 0x29, 0x66, 0x1f, 0x75, 0x1c, 0x91, 0x02, 0x85, 0x8f, 0x72, 0x5c, 0xa4, - 0x3a, 0x3e, 0x9a, 0x2d, 0x9f, 0x02, 0x2f, 0x07, 0x3a, 0x4e, 0x29, 0xce, 0x2c, 0x17, 0xde, 0x92, - 0x3b, 0x74, 0x6b, 0xd3, 0x76, 0x0c, 0x9e, 0x25, 0x44, 0xcc, 0xdf, 0x42, 0xd0, 0x0f, 0x04, 0x4a, - 0xb6, 0x5c, 0xa2, 0x85, 0x2e, 0xbd, 0x0e, 0xc3, 0x07, 0x4d, 0x54, 0xf1, 0xab, 0xf9, 0x8c, 0xc7, - 0x4f, 0x8f, 0x6f, 0xae, 0xc0, 0x20, 0x81, 0x75, 0x7f, 0x46, 0x02, 0xeb, 0xef, 0xe6, 0x33, 0x5e, - 0x76, 0x3d, 0xd6, 0x89, 0x66, 0x03, 0x61, 0x44, 0x13, 0xcd, 0x86, 0x39, 0x7e, 0x4d, 0x43, 0x93, - 0x89, 0x62, 0x29, 0xa9, 0x4b, 0xbb, 0xa6, 0xa4, 0xfe, 0xc5, 0x42, 0xaf, 0x97, 0x6f, 0xa7, 0xb2, - 0xdf, 0x8f, 0xec, 0x6f, 0xc0, 0x70, 0x20, 0xd9, 0x6a, 0x05, 0x8d, 0x9e, 0xd1, 0x20, 0x2d, 0x0e, - 0x07, 0x63, 0x19, 0x89, 0x88, 0x5c, 0xe3, 0x6d, 0xad, 0x99, 0x1f, 0xf0, 0x04, 0x0d, 0xa3, 0x22, - 0xf4, 0xbe, 0xee, 0xe9, 0x75, 0xd7, 0xfc, 0x80, 0x6a, 0x01, 0x5a, 0xfd, 0xcf, 0xf2, 0xa9, 0xcf, - 0x07, 0x4f, 0xfb, 0x68, 0x1f, 0x7d, 0x94, 0x22, 0x44, 0xfe, 0xf0, 0xf1, 0x54, 0x88, 0xfb, 0x10, - 0xe2, 0x9f, 0xe4, 0x53, 0x9f, 0x89, 0x9e, 0x0a, 0x71, 0x3f, 0xb3, 0xc5, 0x0b, 0x30, 0xa4, 0xd9, - 0x9b, 0xee, 0x0c, 0x6e, 0x6c, 0xf8, 0x5c, 0x81, 0x13, 0xb5, 0x63, 0x6f, 0xba, 0x75, 0xdc, 0xb2, - 0x68, 0x21, 0x81, 0xfa, 0xbd, 0x7c, 0x8f, 0x87, 0xb4, 0xa7, 0x82, 0xff, 0x30, 0x97, 0xc8, 0xdf, - 0xc8, 0x47, 0x1e, 0xea, 0x3e, 0xbe, 0xc2, 0xbe, 0x0e, 0x50, 0x6b, 0x6c, 0xd0, 0xb6, 0x2e, 0x25, - 0xb9, 0xc2, 0x73, 0x07, 0x17, 0xa1, 0x22, 0x39, 0x72, 0x48, 0xa2, 0x7e, 0x33, 0x1f, 0x7b, 0xa9, - 0x7c, 0x2a, 0xbb, 0x3d, 0xcb, 0x2e, 0xd0, 0x3a, 0xf1, 0xf8, 0xfa, 0x54, 0x72, 0x7b, 0x95, 0xdc, - 0x4f, 0xe4, 0x63, 0xef, 0xd4, 0x1f, 0x5b, 0xd9, 0xb1, 0x01, 0x98, 0x7c, 0x3f, 0xff, 0xd8, 0x6a, - 0xd2, 0x0b, 0x30, 0x24, 0xe4, 0x10, 0x2c, 0x15, 0x7c, 0xde, 0xe7, 0x40, 0x3c, 0x65, 0x0d, 0x08, - 0xd4, 0x3f, 0x93, 0x87, 0x68, 0xfc, 0x80, 0xc7, 0x54, 0x87, 0x7e, 0x23, 0x1f, 0x8d, 0x9c, 0xf0, - 0xf8, 0xea, 0xcf, 0x14, 0x40, 0xad, 0xbb, 0xd6, 0x10, 0x81, 0x77, 0xfb, 0xa5, 0x63, 0xfa, 0x00, - 0xaa, 0x49, 0x14, 0xea, 0xff, 0x9b, 0x4f, 0x0d, 0xe7, 0xf0, 0xf8, 0x0a, 0xf0, 0x65, 0x3c, 0x15, - 0x6f, 0x58, 0xe1, 0x44, 0x8e, 0x87, 0x90, 0x6c, 0xfc, 0x25, 0x32, 0x23, 0xfa, 0x84, 0xe4, 0xd3, - 0x29, 0xe6, 0x1a, 0xe6, 0x6d, 0x08, 0xcd, 0x35, 0xf9, 0x1a, 0x42, 0x32, 0xdc, 0x7e, 0x2f, 0xbf, - 0x5b, 0xf4, 0x8b, 0xc7, 0x79, 0x55, 0x1d, 0x58, 0xd1, 0xb7, 0x30, 0x4a, 0x23, 0xeb, 0x89, 0x11, - 0x9e, 0xb7, 0xaf, 0xc3, 0x41, 0xf2, 0xdd, 0x9b, 0xa0, 0x52, 0xff, 0x79, 0x7f, 0x7a, 0xe8, 0x85, - 0xc7, 0x57, 0x84, 0x97, 0xa1, 0xb8, 0xa2, 0x7b, 0x1b, 0x42, 0x93, 0xf1, 0x4a, 0xaf, 0xa3, 0x7b, - 0x1b, 0x1a, 0x42, 0xc9, 0x35, 0x18, 0xd4, 0xf4, 0x4d, 0x7e, 0xe6, 0x59, 0x0a, 0x73, 0x2a, 0x3a, - 0xfa, 0x66, 0x9d, 0x9f, 0x7b, 0x06, 0x68, 0xa2, 0x06, 0x39, 0x3d, 0xf9, 0xc9, 0x37, 0x26, 0x94, - 0xe3, 0x39, 0x3d, 0x83, 0x4c, 0x9e, 0x97, 0xa1, 0x38, 0x6d, 0x1b, 0x5b, 0x78, 0x7d, 0x35, 0xc2, - 0x2b, 0x5b, 0xb3, 0x8d, 0x2d, 0x0d, 0xa1, 0xe4, 0x27, 0x73, 0x30, 0x30, 0x4f, 0x75, 0x83, 0x8d, - 0x90, 0xa1, 0x5e, 0x5e, 0x27, 0x9f, 0x3b, 0x1a, 0xaf, 0x93, 0x89, 0x0d, 0x5e, 0x99, 0xac, 0x28, - 0xa2, 0x7e, 0x72, 0x0b, 0x06, 0x67, 0x74, 0x8f, 0x36, 0x6d, 0x67, 0x0b, 0xfd, 0x68, 0xc6, 0x42, - 0xf7, 0xfd, 0x88, 0xfe, 0xf8, 0x44, 0xfc, 0x66, 0xac, 0x21, 0x7e, 0x69, 0x41, 0x61, 0x26, 0x96, - 0x55, 0xdd, 0x69, 0x52, 0x4f, 0xe4, 0xaf, 0x46, 0xb1, 0x78, 0x08, 0xd1, 0x04, 0x26, 0x3c, 0x56, - 0x1e, 0x49, 0x3f, 0x56, 0x46, 0xeb, 0x11, 0x7d, 0xed, 0x30, 0x93, 0xe6, 0x28, 0x2e, 0xfa, 0xdc, - 0x7a, 0x44, 0x28, 0x26, 0xd2, 0xd4, 0x24, 0x12, 0xf5, 0x3b, 0xfd, 0x90, 0xfa, 0x50, 0xfb, 0x54, - 0xc9, 0x4f, 0x95, 0x3c, 0x54, 0xf2, 0x4a, 0x42, 0xc9, 0x2f, 0x25, 0x9f, 0xfe, 0x7f, 0x44, 0x35, - 0xfc, 0xe7, 0x8a, 0x89, 0xc0, 0x21, 0x8f, 0xf7, 0xee, 0x32, 0x94, 0x5e, 0xff, 0xae, 0xd2, 0x0b, - 0x06, 0x44, 0x69, 0xd7, 0x01, 0x31, 0xb0, 0xd7, 0x01, 0x31, 0x98, 0x39, 0x20, 0x42, 0x05, 0x19, - 0xca, 0x54, 0x90, 0xaa, 0x18, 0x34, 0xd0, 0x3b, 0x7f, 0xc9, 0xe5, 0x9d, 0xed, 0xc9, 0x31, 0x36, - 0x9a, 0x52, 0x13, 0x97, 0x20, 0x0b, 0xf5, 0xf7, 0x8b, 0x3d, 0xa2, 0xfd, 0x1c, 0x8b, 0x8e, 0xbc, - 0x0c, 0x85, 0x72, 0xa7, 0x23, 0xf4, 0xe3, 0xac, 0x14, 0x68, 0x28, 0xa3, 0x14, 0xa3, 0x26, 0x6f, - 0x40, 0xa1, 0x7c, 0xbf, 0x16, 0xcf, 0x59, 0x52, 0xbe, 0x5f, 0x13, 0x5f, 0x92, 0x59, 0xf6, 0x7e, - 0x8d, 0xbc, 0x15, 0x06, 0x0f, 0xdd, 0xe8, 0x5a, 0x0f, 0xc4, 0x46, 0x51, 0xb8, 0xdb, 0xfa, 0xee, - 0x38, 0x0d, 0x86, 0x62, 0xdb, 0xc5, 0x18, 0x6d, 0x4c, 0x9b, 0x4a, 0x7b, 0xd7, 0xa6, 0x81, 0x5d, - 0xb5, 0x69, 0x70, 0xaf, 0xda, 0x34, 0xb4, 0x07, 0x6d, 0x82, 0x5d, 0xb5, 0x69, 0xf8, 0xf0, 0xda, - 0xd4, 0x81, 0x4b, 0xc9, 0x08, 0x6d, 0x81, 0x46, 0x68, 0x40, 0x92, 0x58, 0xe1, 0x58, 0x82, 0x57, - 0xff, 0x5d, 0x8e, 0xad, 0x6f, 0x22, 0xba, 0xee, 0x32, 0xbc, 0xec, 0x9f, 0x96, 0x2c, 0xad, 0xfe, - 0x6a, 0x3e, 0x3b, 0xb0, 0xdc, 0xc9, 0x9c, 0xe2, 0x7e, 0x28, 0x55, 0x4a, 0xc5, 0xe8, 0x43, 0xff, - 0x6c, 0x29, 0xc7, 0xd8, 0xa6, 0xc9, 0xec, 0x1b, 0xf9, 0xac, 0x68, 0x77, 0x87, 0x92, 0xd8, 0xc7, - 0x93, 0x1e, 0x6d, 0xe8, 0xa7, 0xef, 0x46, 0x5d, 0xd9, 0xe6, 0x60, 0x44, 0x16, 0xa2, 0x90, 0xd2, - 0x5e, 0x04, 0x1c, 0x29, 0x47, 0xde, 0x0a, 0x52, 0xcb, 0x48, 0xfe, 0x31, 0xe8, 0xae, 0xe6, 0x8f, - 0xd9, 0x98, 0x7b, 0x8c, 0x4c, 0x4e, 0x5e, 0x80, 0xd2, 0x1c, 0xc6, 0x6a, 0x97, 0x07, 0x3b, 0x8f, - 0xde, 0x2e, 0x7b, 0xad, 0x70, 0x1a, 0xf5, 0xef, 0xe7, 0xe0, 0xec, 0x9d, 0xee, 0x1a, 0x15, 0xde, - 0x72, 0x41, 0x1b, 0xde, 0x07, 0x60, 0x60, 0xe1, 0x30, 0x93, 0x43, 0x87, 0x99, 0x4f, 0xca, 0x51, - 0xf1, 0x62, 0x05, 0xa6, 0x42, 0x6a, 0xee, 0x2c, 0xf3, 0x94, 0xef, 0x38, 0xfa, 0xa0, 0xbb, 0x46, - 0xeb, 0x09, 0xaf, 0x19, 0x89, 0xfb, 0xa5, 0xb7, 0xb9, 0x4b, 0xfe, 0x41, 0x1d, 0x54, 0x7e, 0x25, - 0x9f, 0x19, 0x88, 0xf0, 0xc4, 0x66, 0xcc, 0xfc, 0x81, 0xd4, 0x5e, 0x89, 0x67, 0xce, 0x4c, 0x21, - 0x89, 0x71, 0x4c, 0xe3, 0x92, 0x2e, 0xb0, 0x13, 0x9e, 0xc7, 0xf5, 0x43, 0x15, 0xd8, 0x1f, 0xe5, - 0x32, 0x03, 0x46, 0x9e, 0x54, 0x81, 0xa9, 0xff, 0x4b, 0xc1, 0x8f, 0x53, 0x79, 0xa8, 0x4f, 0x78, - 0x01, 0x86, 0xc4, 0x73, 0xfd, 0xa8, 0xb3, 0xaf, 0x38, 0x36, 0xc4, 0x63, 0xe8, 0x80, 0x80, 0x99, - 0x14, 0x92, 0x27, 0xb2, 0xe4, 0xec, 0x2b, 0x79, 0x21, 0x6b, 0x12, 0x09, 0x33, 0x1a, 0x66, 0x1f, - 0x99, 0x1e, 0x5a, 0x20, 0xac, 0x2f, 0x0b, 0xdc, 0x68, 0xa0, 0x8f, 0x4c, 0x8f, 0xdb, 0x1f, 0x01, - 0x9a, 0x19, 0x04, 0xb5, 0x30, 0x4b, 0xbd, 0x30, 0x08, 0x5c, 0x91, 0xac, 0x5f, 0x3c, 0x51, 0x7b, - 0x01, 0x86, 0x84, 0x07, 0xad, 0x70, 0x69, 0x11, 0xad, 0x15, 0x3e, 0xb7, 0xd8, 0xda, 0x80, 0x80, - 0x71, 0xd4, 0x68, 0x33, 0x74, 0xe2, 0x43, 0x8e, 0x0e, 0x42, 0x34, 0x81, 0x21, 0x37, 0x60, 0xac, - 0xe6, 0xe9, 0x96, 0xa1, 0x3b, 0xc6, 0x72, 0xd7, 0xeb, 0x74, 0x3d, 0xd9, 0x00, 0x76, 0x3d, 0xc3, - 0xee, 0x7a, 0x5a, 0x8c, 0x82, 0x7c, 0x0a, 0x46, 0x7d, 0xc8, 0xac, 0xe3, 0xd8, 0x8e, 0x6c, 0xe5, - 0xb8, 0x9e, 0x41, 0x1d, 0x47, 0x8b, 0x12, 0x90, 0x4f, 0xc3, 0x68, 0xd5, 0x7a, 0x68, 0x37, 0xf8, - 0x93, 0x75, 0x6d, 0x41, 0xd8, 0x3c, 0xf8, 0xec, 0xcb, 0x0c, 0x10, 0xf5, 0xae, 0xd3, 0xd2, 0xa2, - 0x84, 0xea, 0x4e, 0x3e, 0x19, 0xce, 0xf3, 0xf1, 0xdd, 0x20, 0x5d, 0x8b, 0x3a, 0xee, 0xa1, 0xb7, - 0x2a, 0x1a, 0x9f, 0xb2, 0xdf, 0x30, 0xb7, 0x41, 0x6f, 0xc0, 0xe0, 0x1d, 0xba, 0xc5, 0x7d, 0x4c, - 0x4b, 0xa1, 0x5b, 0xf2, 0x03, 0x01, 0x93, 0x4f, 0x77, 0x7d, 0x3a, 0xf5, 0x5b, 0xf9, 0x64, 0xa0, - 0xd2, 0xc7, 0x57, 0xd8, 0x9f, 0x82, 0x01, 0x14, 0x65, 0xd5, 0xbf, 0x5e, 0x40, 0x01, 0xa2, 0xb8, - 0xa3, 0xde, 0xce, 0x3e, 0x99, 0xfa, 0x0b, 0xa5, 0x78, 0xf4, 0xda, 0xc7, 0x57, 0x7a, 0x6f, 0xc2, - 0xf0, 0x8c, 0x6d, 0xb9, 0xa6, 0xeb, 0x51, 0xab, 0xe1, 0x2b, 0xec, 0x13, 0xcc, 0xa0, 0x6a, 0x84, - 0x60, 0xd9, 0x06, 0x94, 0xa8, 0x0f, 0xa2, 0xbc, 0xe4, 0x55, 0x18, 0x42, 0x91, 0xa3, 0xcd, 0xc9, - 0x27, 0x3c, 0xbc, 0x99, 0x58, 0x63, 0xc0, 0xb8, 0xc5, 0x19, 0x92, 0x92, 0xbb, 0x30, 0x38, 0xb3, - 0x61, 0xb6, 0x0c, 0x87, 0x5a, 0xe8, 0x9b, 0x2c, 0x05, 0x09, 0x89, 0xf6, 0xe5, 0x14, 0xfe, 0x8b, - 0xb4, 0xbc, 0x39, 0x0d, 0x51, 0x2c, 0xf2, 0xe2, 0x4b, 0xc0, 0x2e, 0xfd, 0x6c, 0x1e, 0x20, 0x2c, - 0x40, 0x9e, 0x81, 0x7c, 0x90, 0x00, 0x1a, 0x5d, 0x62, 0x22, 0x1a, 0x94, 0xc7, 0xa5, 0x42, 0x8c, - 0xed, 0xfc, 0xae, 0x63, 0xfb, 0x2e, 0x94, 0xf8, 0xe9, 0x1a, 0x7a, 0xad, 0x4b, 0x01, 0x35, 0x33, - 0x1b, 0x3c, 0x85, 0xf4, 0xdc, 0x96, 0x46, 0xcb, 0x33, 0xe2, 0x01, 0xce, 0x99, 0x5d, 0x6a, 0x40, - 0x3f, 0xfe, 0x45, 0xae, 0x40, 0x71, 0xd5, 0x4f, 0x1e, 0x3b, 0xca, 0x67, 0xe9, 0x98, 0xfc, 0x10, - 0xcf, 0xba, 0x69, 0xc6, 0xb6, 0x3c, 0x56, 0x35, 0xb6, 0x7a, 0x44, 0xc8, 0x45, 0xc0, 0x22, 0x72, - 0x11, 0x30, 0xf5, 0xbf, 0xca, 0xa7, 0xc4, 0x55, 0x7e, 0x7c, 0x87, 0xc9, 0xeb, 0x00, 0xf8, 0x7c, - 0x9c, 0xc9, 0xd3, 0x7f, 0x0e, 0x82, 0xa3, 0x04, 0x19, 0xa1, 0xda, 0x46, 0xb6, 0x1d, 0x21, 0xb1, - 0xfa, 0x0f, 0x73, 0x89, 0x60, 0xbc, 0x87, 0x92, 0xa3, 0x6c, 0x95, 0xe5, 0x0f, 0x68, 0xc6, 0xfa, - 0x7d, 0x51, 0xd8, 0x5f, 0x5f, 0x44, 0xbf, 0xe5, 0x08, 0x2c, 0xd3, 0xe3, 0xfc, 0x96, 0xef, 0xe4, - 0xd3, 0x42, 0x13, 0x9f, 0x4c, 0x15, 0xbf, 0x19, 0x18, 0xa5, 0xc5, 0x58, 0x30, 0x78, 0x84, 0xc6, - 0x13, 0x5c, 0x0b, 0x33, 0xf5, 0x8b, 0x70, 0x26, 0x16, 0xb0, 0x57, 0xe4, 0x1a, 0xbe, 0xd2, 0x3b, - 0xf2, 0x6f, 0x76, 0xe0, 0x81, 0x08, 0x99, 0xfa, 0xff, 0xe5, 0x7a, 0x87, 0x6b, 0x3e, 0x76, 0xd5, - 0x49, 0x11, 0x40, 0xe1, 0x4f, 0x47, 0x00, 0x47, 0xb0, 0x0d, 0x3e, 0xd9, 0x02, 0xf8, 0x88, 0x4c, - 0x1e, 0x1f, 0xb6, 0x00, 0x7e, 0x21, 0xb7, 0x6b, 0xb4, 0xed, 0xe3, 0x96, 0x81, 0xfa, 0x3f, 0xe6, - 0x52, 0xa3, 0x62, 0x1f, 0xaa, 0x5d, 0x6f, 0x41, 0x89, 0xbb, 0xf0, 0x88, 0x56, 0x49, 0x79, 0xc4, - 0x18, 0x34, 0x2b, 0xf3, 0x3e, 0xc7, 0x92, 0x05, 0x18, 0xe0, 0x6d, 0x30, 0x44, 0x6f, 0x7c, 0xac, - 0x47, 0x68, 0x6e, 0x23, 0x6b, 0x72, 0x14, 0x68, 0xf5, 0x1f, 0xe4, 0x12, 0x41, 0xba, 0x8f, 0xf1, - 0xdb, 0xc2, 0xa9, 0xba, 0xb0, 0xf7, 0xa9, 0x5a, 0xfd, 0x67, 0xf9, 0xf4, 0x18, 0xe1, 0xc7, 0xf8, - 0x21, 0x47, 0x71, 0x9c, 0x76, 0xb0, 0x75, 0x6b, 0x15, 0xc6, 0xa2, 0xb2, 0x10, 0xcb, 0xd6, 0xd3, - 0xe9, 0x91, 0xd2, 0x33, 0x5a, 0x11, 0xe3, 0xa1, 0x7e, 0x3b, 0x97, 0x0c, 0x6f, 0x7e, 0xec, 0xf3, - 0xd3, 0xc1, 0xb4, 0x25, 0xfa, 0x29, 0x1f, 0x91, 0xb5, 0xe6, 0x28, 0x3e, 0xe5, 0x23, 0xb2, 0x6a, - 0x1c, 0xec, 0x53, 0x7e, 0x29, 0x9f, 0x15, 0x1d, 0xfe, 0xd8, 0x3f, 0xe8, 0xf3, 0xb2, 0x90, 0x79, - 0xcb, 0xc4, 0xa7, 0x3d, 0x93, 0x15, 0x8e, 0x3d, 0x83, 0x67, 0x82, 0xcf, 0xc1, 0xc6, 0x78, 0xaa, - 0xb0, 0x3e, 0x22, 0x8a, 0x7c, 0x32, 0x84, 0xf5, 0x11, 0x19, 0x2a, 0x1f, 0x3d, 0x61, 0xfd, 0x56, - 0x7e, 0xaf, 0x29, 0x09, 0x4e, 0x85, 0x97, 0x10, 0xde, 0x57, 0xf3, 0xc9, 0x54, 0x19, 0xc7, 0x2e, - 0xa6, 0x39, 0x28, 0x89, 0xa4, 0x1d, 0x99, 0xc2, 0xe1, 0xf8, 0x2c, 0x8b, 0x46, 0x7c, 0xc7, 0x4d, - 0x10, 0x17, 0x39, 0x7b, 0x13, 0x09, 0xa7, 0x55, 0xbf, 0x97, 0x8b, 0xe5, 0x95, 0x38, 0x96, 0x23, - 0x84, 0x03, 0x2d, 0x49, 0xe4, 0x6d, 0xff, 0x30, 0xb3, 0x18, 0x8b, 0xeb, 0x1d, 0x7c, 0x4f, 0x85, - 0x7a, 0xba, 0xd9, 0x8a, 0x97, 0x17, 0xf1, 0x07, 0xbe, 0x95, 0x87, 0x89, 0x04, 0x29, 0xb9, 0x12, - 0x09, 0xdb, 0x83, 0xc7, 0x92, 0x31, 0x47, 0x75, 0x1e, 0xc0, 0x67, 0x1f, 0x27, 0xa9, 0x57, 0xa0, - 0x58, 0xd1, 0xb7, 0xf8, 0xb7, 0xf5, 0x73, 0x96, 0x86, 0xbe, 0x25, 0x9f, 0xb8, 0x21, 0x9e, 0xac, - 0xc1, 0x79, 0x7e, 0x1f, 0x62, 0xda, 0xd6, 0xaa, 0xd9, 0xa6, 0x55, 0x6b, 0xd1, 0x6c, 0xb5, 0x4c, - 0x57, 0x5c, 0xea, 0xbd, 0xb0, 0xb3, 0x3d, 0x79, 0xd5, 0xb3, 0x3d, 0xbd, 0x55, 0xa7, 0x3e, 0x59, - 0xdd, 0x33, 0xdb, 0xb4, 0x6e, 0x5a, 0xf5, 0x36, 0x52, 0x4a, 0x2c, 0xd3, 0x59, 0x91, 0x2a, 0x0f, - 0xe1, 0x5e, 0x6b, 0xe8, 0x96, 0x45, 0x8d, 0xaa, 0x35, 0xbd, 0xe5, 0x51, 0x7e, 0x19, 0x58, 0xe0, - 0x47, 0x82, 0xfc, 0x1d, 0x3a, 0x47, 0x33, 0xc6, 0x6b, 0x8c, 0x40, 0x4b, 0x29, 0xa4, 0xfe, 0x76, - 0x31, 0x25, 0xa5, 0xc8, 0x09, 0x52, 0x1f, 0xbf, 0xa7, 0x8b, 0xbb, 0xf4, 0xf4, 0x75, 0x18, 0x10, - 0x31, 0x72, 0xc5, 0x05, 0x03, 0x3a, 0xce, 0x3f, 0xe4, 0x20, 0xf9, 0x86, 0x46, 0x50, 0x91, 0x16, - 0x5c, 0x5a, 0x65, 0xdd, 0x94, 0xde, 0x99, 0xa5, 0x03, 0x74, 0x66, 0x0f, 0x7e, 0xe4, 0x3d, 0xb8, - 0x88, 0xd8, 0x94, 0x6e, 0x1d, 0xc0, 0xaa, 0x30, 0x1e, 0x16, 0xaf, 0x2a, 0xbd, 0x73, 0xb3, 0xca, + // 17005 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, 0x01, 0x04, 0x1e, 0x83, 0xc9, 0x79, 0xd5, 0xcc, 0xce, 0x2e, 0x76, + 0x6b, 0xef, 0xe6, 0x66, 0xf6, 0x76, 0x31, 0xb7, 0xb3, 0xb3, 0xbb, 0xb7, 0xaf, 0xdb, 0x6b, 0xa0, + 0x81, 0x41, 0xcf, 0xe0, 0xb5, 0xd5, 0x98, 0x99, 0xdb, 0x23, 0xef, 0x9a, 0x85, 0xae, 0x9c, 0x46, + 0xed, 0x74, 0x57, 0x35, 0xab, 0xaa, 0x07, 0x83, 0x95, 0x1f, 0x3c, 0x99, 0xa2, 0x48, 0xf1, 0x78, + 0x3a, 0x1f, 0x4d, 0x1d, 0x45, 0xc9, 0xf6, 0x51, 0x0f, 0x9b, 0xa2, 0x28, 0x9e, 0x29, 0xd1, 0x24, + 0x8f, 0xe4, 0x59, 0x8f, 0x93, 0xed, 0x13, 0xf9, 0x99, 0x1f, 0x29, 0xdb, 0xfa, 0xf4, 0xd9, 0x32, + 0x4e, 0xa6, 0xad, 0x3f, 0xf8, 0xec, 0xef, 0xa3, 0x6d, 0x7e, 0xd6, 0x59, 0x96, 0xfd, 0xe9, 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, 0xe6, 0xd1, 0x16, 0xed, 0xd8, 0x8e, 0x77, + 0xbd, 0x45, 0x9b, 0x7a, 0x63, 0xe3, 0xba, 0xb7, 0xd1, 0xa1, 0xee, 0x75, 0xfa, 0x88, 0x5a, 0x9e, + 0xff, 0xdf, 0x64, 0xc7, 0xb1, 0x3d, 0x9b, 0x94, 0xf8, 0xaf, 0x4b, 0x67, 0x9b, 0x76, 0xd3, 0x46, + 0xd0, 0x75, 0xf6, 0x17, 0xc7, 0x5e, 0xba, 0xdc, 0xb4, 0xed, 0x66, 0x8b, 0x5e, 0xc7, 0x5f, 0xab, + 0xdd, 0x07, 0xd7, 0x5d, 0xcf, 0xe9, 0x36, 0x3c, 0x81, 0x9d, 0x88, 0x63, 0x3d, 0xb3, 0x4d, 0x5d, + 0x4f, 0x6f, 0x77, 0x04, 0xc1, 0x53, 0x71, 0x82, 0x75, 0x47, 0xef, 0x74, 0xa8, 0x23, 0x2a, 0xbf, + 0xf4, 0x89, 0xa0, 0x9d, 0x7a, 0xa3, 0x41, 0x5d, 0xb7, 0x65, 0xba, 0xde, 0xf5, 0x47, 0x2f, 0x4a, + 0xbf, 0x04, 0xe1, 0x33, 0xe9, 0x1f, 0x84, 0xff, 0x0a, 0x92, 0x17, 0xd2, 0x49, 0xfc, 0x1a, 0x63, + 0x55, 0xab, 0x5f, 0xcb, 0xc3, 0xe0, 0x02, 0xf5, 0x74, 0x43, 0xf7, 0x74, 0x72, 0x19, 0xfa, 0xab, + 0x96, 0x41, 0x1f, 0x2b, 0xb9, 0xa7, 0x73, 0x57, 0x0b, 0x53, 0xa5, 0xad, 0xcd, 0x89, 0x3c, 0x35, + 0x35, 0x0e, 0x24, 0x4f, 0x42, 0x71, 0x65, 0xa3, 0x43, 0x95, 0xfc, 0xd3, 0xb9, 0xab, 0x43, 0x53, + 0x43, 0x5b, 0x9b, 0x13, 0xfd, 0x28, 0x34, 0x0d, 0xc1, 0xe4, 0x19, 0xc8, 0x57, 0x2b, 0x4a, 0x01, + 0x91, 0xa7, 0xb7, 0x36, 0x27, 0x46, 0xbb, 0xa6, 0xf1, 0xbc, 0xdd, 0x36, 0x3d, 0xda, 0xee, 0x78, + 0x1b, 0x5a, 0xbe, 0x5a, 0x21, 0x57, 0xa0, 0x38, 0x6d, 0x1b, 0x54, 0x29, 0x22, 0x11, 0xd9, 0xda, + 0x9c, 0x18, 0x6b, 0xd8, 0x06, 0x95, 0xa8, 0x10, 0x4f, 0x3e, 0x0b, 0xc5, 0x15, 0xb3, 0x4d, 0x95, + 0xfe, 0xa7, 0x73, 0x57, 0x87, 0x6f, 0x5c, 0x9a, 0xe4, 0xe2, 0x9b, 0xf4, 0xc5, 0x37, 0xb9, 0xe2, + 0xcb, 0x77, 0x6a, 0xfc, 0xbb, 0x9b, 0x13, 0x7d, 0x5b, 0x9b, 0x13, 0x45, 0x26, 0xf2, 0xaf, 0x7e, + 0x6f, 0x22, 0xa7, 0x61, 0x49, 0xf2, 0x26, 0x0c, 0x4f, 0xb7, 0xba, 0xae, 0x47, 0x9d, 0x45, 0xbd, + 0x4d, 0x95, 0x12, 0x56, 0x78, 0x69, 0x6b, 0x73, 0xe2, 0x7c, 0x83, 0x83, 0xeb, 0x96, 0xde, 0x96, + 0x2b, 0x96, 0xc9, 0xd5, 0xdf, 0xc8, 0xc1, 0xa9, 0x1a, 0x75, 0x5d, 0xd3, 0xb6, 0x02, 0xd9, 0x7c, + 0x1c, 0x86, 0x04, 0xa8, 0x5a, 0x41, 0xf9, 0x0c, 0x4d, 0x0d, 0x6c, 0x6d, 0x4e, 0x14, 0x5c, 0xd3, + 0xd0, 0x42, 0x0c, 0xf9, 0x14, 0x0c, 0xdc, 0x37, 0xbd, 0xb5, 0x85, 0xd9, 0xb2, 0x90, 0xd3, 0xf9, + 0xad, 0xcd, 0x09, 0xb2, 0x6e, 0x7a, 0x6b, 0xf5, 0xf6, 0x03, 0x5d, 0xaa, 0xd0, 0x27, 0x23, 0xf3, + 0x30, 0xbe, 0xec, 0x98, 0x8f, 0x74, 0x8f, 0xde, 0xa1, 0x1b, 0xcb, 0x76, 0xcb, 0x6c, 0x6c, 0x08, + 0x29, 0x3e, 0xbd, 0xb5, 0x39, 0x71, 0xb9, 0xc3, 0x71, 0xf5, 0x87, 0x74, 0xa3, 0xde, 0x41, 0xac, + 0xc4, 0x24, 0x51, 0x52, 0xfd, 0xcd, 0x12, 0x8c, 0xdc, 0x75, 0xa9, 0x13, 0xb4, 0xfb, 0x0a, 0x14, + 0xd9, 0x6f, 0xd1, 0x64, 0x94, 0x79, 0xd7, 0xa5, 0x8e, 0x2c, 0x73, 0x86, 0x27, 0xd7, 0xa0, 0x7f, + 0xde, 0x6e, 0x9a, 0x96, 0x68, 0xf6, 0x99, 0xad, 0xcd, 0x89, 0x53, 0x2d, 0x06, 0x90, 0x28, 0x39, + 0x05, 0xf9, 0x0c, 0x8c, 0x54, 0xdb, 0x4c, 0x87, 0x6c, 0x4b, 0xf7, 0x6c, 0x47, 0xb4, 0x16, 0xa5, + 0x6b, 0x4a, 0x70, 0xa9, 0x60, 0x84, 0x9e, 0xbc, 0x0e, 0x50, 0xbe, 0x5f, 0xd3, 0xec, 0x16, 0x2d, + 0x6b, 0x8b, 0x42, 0x19, 0xb0, 0xb4, 0xbe, 0xee, 0xd6, 0x1d, 0xbb, 0x45, 0xeb, 0xba, 0x23, 0x57, + 0x2b, 0x51, 0x93, 0x19, 0x18, 0x2b, 0xe3, 0xa8, 0xd0, 0xe8, 0x0f, 0x77, 0xa9, 0xeb, 0xb9, 0x4a, + 0xff, 0xd3, 0x85, 0xab, 0x43, 0x53, 0x4f, 0x6e, 0x6d, 0x4e, 0x5c, 0xe4, 0xe3, 0xa5, 0xee, 0x08, + 0x94, 0xc4, 0x22, 0x56, 0x88, 0x4c, 0xc1, 0x68, 0xf9, 0xfd, 0xae, 0x43, 0xab, 0x06, 0xb5, 0x3c, + 0xd3, 0xdb, 0x10, 0x1a, 0x72, 0x79, 0x6b, 0x73, 0x42, 0xd1, 0x19, 0xa2, 0x6e, 0x0a, 0x8c, 0xc4, + 0x24, 0x5a, 0x84, 0x2c, 0xc1, 0xe9, 0x5b, 0xd3, 0xcb, 0x35, 0xea, 0x3c, 0x32, 0x1b, 0xb4, 0xdc, + 0x68, 0xd8, 0x5d, 0xcb, 0x53, 0x06, 0x90, 0xcf, 0x33, 0x5b, 0x9b, 0x13, 0x4f, 0x36, 0x1b, 0x9d, + 0xba, 0xcb, 0xb1, 0x75, 0x9d, 0xa3, 0x25, 0x66, 0xc9, 0xb2, 0xe4, 0xf3, 0x30, 0xba, 0xe2, 0x30, + 0x2d, 0x34, 0x2a, 0x94, 0xc1, 0x95, 0x41, 0xd4, 0xff, 0xf3, 0x93, 0x62, 0xa6, 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, 0x08, 0xdb, 0x7c, 0x6d, 0x6b, 0x73, 0xe2, 0xe3, 0x8e, + 0xa0, 0xa9, 0xf7, 0x54, 0xbb, 0x4c, 0x56, 0x64, 0x06, 0x06, 0x99, 0x36, 0xdd, 0x31, 0x2d, 0x43, + 0x81, 0xa7, 0x73, 0x57, 0xc7, 0x6e, 0x8c, 0xfb, 0xad, 0xf7, 0xe1, 0x53, 0x17, 0xb6, 0x36, 0x27, + 0xce, 0x30, 0x1d, 0xac, 0x3f, 0x34, 0x2d, 0x79, 0x8a, 0x08, 0x8a, 0xb2, 0x51, 0x34, 0x65, 0x7b, + 0x38, 0x74, 0x87, 0xc3, 0x51, 0xb4, 0x6a, 0x7b, 0xf1, 0x61, 0xeb, 0x93, 0x91, 0x69, 0x18, 0x9d, + 0xb2, 0xbd, 0xaa, 0xe5, 0x7a, 0xba, 0xd5, 0xa0, 0xd5, 0x8a, 0x32, 0x82, 0xe5, 0x50, 0x2d, 0x58, + 0x39, 0x53, 0x60, 0xea, 0x91, 0x49, 0x29, 0x5a, 0x46, 0xfd, 0x97, 0x45, 0x18, 0x63, 0x7d, 0x22, + 0x0d, 0x9f, 0x32, 0x9b, 0x09, 0x18, 0x84, 0xd5, 0xe2, 0x76, 0xf4, 0x06, 0x15, 0x23, 0x09, 0xbf, + 0xc2, 0xf2, 0x81, 0x12, 0xcf, 0x38, 0x3d, 0xb9, 0x06, 0x83, 0x1c, 0x54, 0xad, 0x88, 0xc1, 0x35, + 0xba, 0xb5, 0x39, 0x31, 0xe4, 0x22, 0xac, 0x6e, 0x1a, 0x5a, 0x80, 0x66, 0xda, 0xcd, 0xff, 0x9e, + 0xb3, 0x5d, 0x8f, 0x31, 0x17, 0x63, 0x0b, 0x3f, 0x43, 0x14, 0x58, 0x13, 0x28, 0x59, 0xbb, 0xa3, + 0x85, 0xc8, 0x6b, 0x00, 0x1c, 0x52, 0x36, 0x0c, 0x47, 0x0c, 0xb0, 0x8b, 0x5b, 0x9b, 0x13, 0xe7, + 0x04, 0x0b, 0xdd, 0x30, 0xe4, 0xd1, 0x29, 0x11, 0x93, 0x36, 0x8c, 0xf0, 0x5f, 0xf3, 0xfa, 0x2a, + 0x6d, 0xf1, 0xd1, 0x35, 0x7c, 0xe3, 0xaa, 0xdf, 0x89, 0x51, 0xe9, 0x4c, 0xca, 0xa4, 0x33, 0x96, + 0xe7, 0x6c, 0x4c, 0x4d, 0x88, 0x09, 0xf9, 0x82, 0xa8, 0xaa, 0x85, 0x38, 0x79, 0x2a, 0x90, 0xcb, + 0xb0, 0x79, 0x7a, 0xd6, 0x76, 0xd6, 0x75, 0xc7, 0xa0, 0xc6, 0xd4, 0x86, 0x3c, 0x4f, 0x3f, 0xf0, + 0xc1, 0xf5, 0x55, 0x59, 0xf5, 0x64, 0x72, 0xd6, 0xe9, 0x9c, 0x5b, 0xad, 0xbb, 0x8a, 0x2a, 0x37, + 0x90, 0x90, 0x96, 0xdb, 0x5d, 0x8d, 0xab, 0x59, 0xb4, 0x0c, 0x9b, 0x0a, 0x38, 0xe0, 0x1e, 0x75, + 0xd8, 0x24, 0x8e, 0xa3, 0x4e, 0x4c, 0x05, 0x82, 0xc9, 0x23, 0x8e, 0x49, 0xf2, 0x10, 0x45, 0x2e, + 0xbd, 0x0d, 0xa7, 0x13, 0xa2, 0x20, 0xe3, 0x50, 0x78, 0x48, 0x37, 0xb8, 0xba, 0x68, 0xec, 0x4f, + 0x72, 0x16, 0xfa, 0x1f, 0xe9, 0xad, 0xae, 0x58, 0x42, 0x35, 0xfe, 0xe3, 0xf5, 0xfc, 0xa7, 0x73, + 0x6c, 0xc5, 0x21, 0xd3, 0xb6, 0x65, 0xd1, 0x86, 0x27, 0x2f, 0x3a, 0xaf, 0xc0, 0xd0, 0xbc, 0xdd, + 0xd0, 0x5b, 0xd8, 0x8f, 0x5c, 0xef, 0x94, 0xad, 0xcd, 0x89, 0xb3, 0xac, 0x03, 0x27, 0x5b, 0x0c, + 0x23, 0xb5, 0x29, 0x24, 0x65, 0x0a, 0xa0, 0xd1, 0xb6, 0xed, 0x51, 0x2c, 0x98, 0x0f, 0x15, 0x00, + 0x0b, 0x3a, 0x88, 0x92, 0x15, 0x20, 0x24, 0x26, 0xd7, 0x61, 0x70, 0x99, 0xad, 0xb3, 0x0d, 0xbb, + 0x25, 0x94, 0x0f, 0x97, 0x02, 0x5c, 0x7b, 0xe5, 0xb1, 0xea, 0x13, 0xa9, 0x73, 0x30, 0x36, 0xdd, + 0x32, 0xa9, 0xe5, 0xc9, 0xad, 0x66, 0x23, 0xb9, 0xdc, 0xa4, 0x96, 0x27, 0xb7, 0x1a, 0xc7, 0xbc, + 0xce, 0xa0, 0x72, 0xab, 0x03, 0x52, 0xf5, 0xf7, 0x0a, 0x70, 0xf1, 0x4e, 0x77, 0x95, 0x3a, 0x16, + 0xf5, 0xa8, 0x2b, 0x16, 0xe4, 0x80, 0xeb, 0x22, 0x9c, 0x4e, 0x20, 0x05, 0x77, 0x5c, 0x28, 0x1f, + 0x06, 0xc8, 0xba, 0x58, 0xe3, 0xe5, 0xd9, 0x36, 0x51, 0x94, 0xcc, 0xc1, 0xa9, 0x10, 0xc8, 0x1a, + 0xe1, 0x2a, 0x79, 0x5c, 0x4a, 0x9e, 0xda, 0xda, 0x9c, 0xb8, 0x24, 0x71, 0x63, 0xcd, 0x96, 0x35, + 0x38, 0x5e, 0x8c, 0xdc, 0x81, 0xf1, 0x10, 0x74, 0xcb, 0xb1, 0xbb, 0x1d, 0x57, 0x29, 0x20, 0xab, + 0x89, 0xad, 0xcd, 0x89, 0x27, 0x24, 0x56, 0x4d, 0x44, 0xca, 0x0b, 0x78, 0xbc, 0x20, 0xf9, 0xd1, + 0x9c, 0xcc, 0x4d, 0x8c, 0xc2, 0x22, 0x8e, 0xc2, 0x57, 0xfd, 0x51, 0x98, 0x29, 0xa4, 0xc9, 0x78, + 0x49, 0x31, 0x28, 0x63, 0xcd, 0x48, 0x0c, 0xca, 0x44, 0x8d, 0x97, 0xa6, 0xe1, 0x5c, 0x2a, 0xaf, + 0x5d, 0x69, 0xf5, 0xbf, 0x28, 0xc8, 0x5c, 0x96, 0x6d, 0x23, 0xe8, 0xcc, 0x25, 0xb9, 0x33, 0x97, + 0x6d, 0x03, 0xa7, 0xfa, 0x5c, 0xb8, 0x76, 0x4a, 0x8d, 0xed, 0xd8, 0x46, 0x7c, 0xd6, 0x4f, 0x96, + 0x25, 0x5f, 0x84, 0xf3, 0x09, 0x20, 0x9f, 0xae, 0xb9, 0xf6, 0x5f, 0xd9, 0xda, 0x9c, 0x50, 0x53, + 0xb8, 0xc6, 0x67, 0xef, 0x0c, 0x2e, 0x44, 0x87, 0x0b, 0x92, 0xd4, 0x6d, 0xcb, 0xd3, 0x4d, 0x4b, + 0x18, 0x97, 0x7c, 0x94, 0x7c, 0x62, 0x6b, 0x73, 0xe2, 0x59, 0x59, 0x07, 0x7d, 0x9a, 0x78, 0xe3, + 0xb3, 0xf8, 0x10, 0x03, 0x94, 0x14, 0x54, 0xb5, 0xad, 0x37, 0x7d, 0x8b, 0xf9, 0xea, 0xd6, 0xe6, + 0xc4, 0xc7, 0x52, 0xeb, 0x30, 0x19, 0x95, 0xbc, 0x42, 0x67, 0x71, 0x22, 0x1a, 0x90, 0x10, 0xb7, + 0x68, 0x1b, 0x14, 0xbf, 0xa1, 0x1f, 0xf9, 0xab, 0x5b, 0x9b, 0x13, 0x4f, 0x49, 0xfc, 0x2d, 0xdb, + 0xa0, 0xf1, 0xe6, 0xa7, 0x94, 0x56, 0x7f, 0xa3, 0x00, 0x4f, 0xd5, 0xca, 0x0b, 0xf3, 0x55, 0xc3, + 0x37, 0x69, 0x96, 0x1d, 0xfb, 0x91, 0x69, 0x48, 0xa3, 0x77, 0x15, 0x2e, 0xc4, 0x50, 0x33, 0x68, + 0x45, 0x05, 0xc6, 0x34, 0x7e, 0x9b, 0x6f, 0x2e, 0x75, 0x04, 0x4d, 0x9d, 0x9b, 0x5a, 0xd1, 0x45, + 0x3b, 0x8b, 0x11, 0xeb, 0xa3, 0x18, 0xaa, 0xb6, 0x66, 0x3b, 0x5e, 0xa3, 0xeb, 0x09, 0x25, 0xc0, + 0x3e, 0x4a, 0xd4, 0xe1, 0x0a, 0xa2, 0x1e, 0x55, 0xf8, 0x7c, 0xc8, 0x4f, 0xe4, 0x60, 0xbc, 0xec, + 0x79, 0x8e, 0xb9, 0xda, 0xf5, 0xe8, 0x82, 0xde, 0xe9, 0x98, 0x56, 0x13, 0xc7, 0xfa, 0xf0, 0x8d, + 0x37, 0x83, 0x35, 0xb2, 0xa7, 0x24, 0x26, 0xe3, 0xc5, 0xa5, 0x21, 0xaa, 0xfb, 0xa8, 0x7a, 0x9b, + 0xe3, 0xe4, 0x21, 0x1a, 0x2f, 0xc7, 0x86, 0x68, 0x2a, 0xaf, 0x5d, 0x0d, 0xd1, 0xaf, 0x15, 0xe0, + 0xf2, 0xd2, 0x43, 0x4f, 0xd7, 0xa8, 0x6b, 0x77, 0x9d, 0x06, 0x75, 0xef, 0x76, 0x0c, 0xdd, 0xa3, + 0xe1, 0x48, 0x9d, 0x80, 0xfe, 0xb2, 0x61, 0x50, 0x03, 0xd9, 0xf5, 0xf3, 0x6d, 0x9f, 0xce, 0x00, + 0x1a, 0x87, 0x93, 0x8f, 0xc3, 0x80, 0x28, 0x83, 0xdc, 0xfb, 0xa7, 0x86, 0xb7, 0x36, 0x27, 0x06, + 0xba, 0x1c, 0xa4, 0xf9, 0x38, 0x46, 0x56, 0xa1, 0x2d, 0xca, 0xc8, 0x0a, 0x21, 0x99, 0xc1, 0x41, + 0x9a, 0x8f, 0x23, 0xef, 0xc0, 0x18, 0xb2, 0x0d, 0xda, 0x23, 0xe6, 0xbe, 0xb3, 0xbe, 0x74, 0xe5, + 0xc6, 0xf2, 0xa5, 0x09, 0x5b, 0x53, 0x77, 0xfc, 0x02, 0x5a, 0x8c, 0x01, 0xb9, 0x0f, 0xe3, 0xa2, + 0x11, 0x21, 0xd3, 0xfe, 0x1e, 0x4c, 0xcf, 0x6d, 0x6d, 0x4e, 0x9c, 0x16, 0xed, 0x97, 0xd8, 0x26, + 0x98, 0x30, 0xc6, 0xa2, 0xd9, 0x21, 0xe3, 0xd2, 0x76, 0x8c, 0xc5, 0x17, 0xcb, 0x8c, 0xe3, 0x4c, + 0xd4, 0x77, 0x61, 0x44, 0x2e, 0x48, 0xce, 0xe3, 0xd6, 0x9a, 0x8f, 0x13, 0xdc, 0x94, 0x9b, 0x06, + 0xee, 0xa7, 0x5f, 0x84, 0xe1, 0x0a, 0x75, 0x1b, 0x8e, 0xd9, 0x61, 0x56, 0x83, 0x50, 0xf2, 0x53, + 0x5b, 0x9b, 0x13, 0xc3, 0x46, 0x08, 0xd6, 0x64, 0x1a, 0xf5, 0xff, 0xce, 0xc1, 0x79, 0xc6, 0xbb, + 0xec, 0xba, 0x66, 0xd3, 0x6a, 0xcb, 0xcb, 0xf6, 0xf3, 0x50, 0xaa, 0x61, 0x7d, 0xa2, 0xa6, 0xb3, + 0x5b, 0x9b, 0x13, 0xe3, 0xbc, 0x05, 0x92, 0x1e, 0x0a, 0x9a, 0x60, 0x5f, 0x99, 0xdf, 0x66, 0x5f, + 0xc9, 0x4c, 0x5a, 0x4f, 0x77, 0x3c, 0xd3, 0x6a, 0xd6, 0x3c, 0xdd, 0xeb, 0xba, 0x11, 0x93, 0x56, + 0x60, 0xea, 0x2e, 0xa2, 0x22, 0x26, 0x6d, 0xa4, 0x10, 0x79, 0x1b, 0x46, 0x66, 0x2c, 0x23, 0x64, + 0xc2, 0x27, 0xc4, 0x27, 0x98, 0xa5, 0x49, 0x11, 0x9e, 0x64, 0x11, 0x29, 0xa0, 0xfe, 0xad, 0x1c, + 0x28, 0x7c, 0x13, 0x38, 0x6f, 0xba, 0xde, 0x02, 0x6d, 0xaf, 0x4a, 0xb3, 0xd3, 0xac, 0xbf, 0xab, + 0x64, 0x38, 0x69, 0x2d, 0x42, 0x53, 0x40, 0xec, 0x2a, 0x5b, 0xa6, 0x9b, 0xd8, 0x7e, 0xc4, 0x4a, + 0x91, 0x2a, 0x0c, 0x70, 0xce, 0xdc, 0x96, 0x18, 0xbe, 0xa1, 0xf8, 0x8a, 0x10, 0xaf, 0x9a, 0x2b, + 0x43, 0x9b, 0x13, 0xcb, 0x1b, 0x1a, 0x51, 0x5e, 0xfd, 0x46, 0x01, 0xc6, 0xe3, 0x85, 0xc8, 0x7d, + 0x18, 0xbc, 0x6d, 0x9b, 0x16, 0x35, 0x96, 0x2c, 0x6c, 0x61, 0xef, 0xc3, 0x11, 0xdf, 0x16, 0x3f, + 0xf3, 0x1e, 0x96, 0xa9, 0xcb, 0x16, 0x2c, 0x9e, 0x95, 0x04, 0xcc, 0xc8, 0xe7, 0x61, 0x88, 0xd9, + 0x80, 0x8f, 0x90, 0x73, 0x7e, 0x5b, 0xce, 0x4f, 0x0b, 0xce, 0x67, 0x1d, 0x5e, 0x28, 0xc9, 0x3a, + 0x64, 0xc7, 0xf4, 0x4a, 0xa3, 0xba, 0x6b, 0x5b, 0xa2, 0xe7, 0x51, 0xaf, 0x1c, 0x84, 0xc8, 0x7a, + 0xc5, 0x69, 0x98, 0xe9, 0xca, 0x3f, 0x16, 0xbb, 0x41, 0xda, 0xbb, 0x70, 0x59, 0xc5, 0x7b, 0x40, + 0x22, 0x26, 0x16, 0x9c, 0x12, 0x02, 0x5d, 0x33, 0x3b, 0x68, 0xf5, 0xe3, 0xba, 0x36, 0x76, 0xe3, + 0xca, 0xa4, 0x7f, 0x28, 0x36, 0x29, 0x1d, 0xa9, 0x3d, 0x7a, 0x71, 0x72, 0x21, 0x20, 0xc7, 0x9d, + 0x29, 0xea, 0x64, 0x8c, 0x85, 0xdc, 0xdb, 0xed, 0x08, 0xb9, 0xfa, 0x63, 0x79, 0x78, 0x21, 0xec, + 0x22, 0x8d, 0x3e, 0x32, 0xe9, 0x7a, 0xc8, 0x51, 0xec, 0x91, 0xd9, 0x10, 0x73, 0xa7, 0xd7, 0x74, + 0xab, 0x49, 0x0d, 0x72, 0x0d, 0xfa, 0x35, 0xbb, 0x45, 0x5d, 0x25, 0x87, 0xe6, 0x21, 0x4e, 0x5f, + 0x0e, 0x03, 0xc8, 0x87, 0x2c, 0x48, 0x41, 0x6c, 0x28, 0xad, 0x38, 0xba, 0xe9, 0xf9, 0x9a, 0x54, + 0x4e, 0x6a, 0xd2, 0x0e, 0x6a, 0x9c, 0xe4, 0x3c, 0xf8, 0x1a, 0x83, 0x82, 0xf7, 0x10, 0x20, 0x0b, + 0x9e, 0x93, 0x5c, 0x7a, 0x0d, 0x86, 0x25, 0xe2, 0x5d, 0x2d, 0x22, 0xdf, 0x2a, 0xca, 0x63, 0xcb, + 0x6f, 0x96, 0x18, 0x5b, 0xd7, 0xd9, 0x98, 0x70, 0x5d, 0x66, 0xc5, 0xf0, 0x41, 0x25, 0x34, 0x1f, + 0x41, 0x51, 0xcd, 0x47, 0x10, 0x79, 0x09, 0x06, 0x39, 0x8b, 0x60, 0xbf, 0x8c, 0x7b, 0x6d, 0x07, + 0x61, 0x51, 0x53, 0x20, 0x20, 0x24, 0xbf, 0x98, 0x83, 0x27, 0x7b, 0x4a, 0x02, 0x95, 0x6f, 0xf8, + 0xc6, 0xcb, 0x7b, 0x12, 0xe3, 0xd4, 0x0b, 0x5b, 0x9b, 0x13, 0xd7, 0x24, 0xcd, 0x70, 0x24, 0x9a, + 0x7a, 0x83, 0x13, 0x49, 0xed, 0xea, 0xdd, 0x14, 0x66, 0xac, 0xf2, 0x4a, 0x67, 0xf1, 0xa8, 0xca, + 0x6a, 0x6c, 0xf8, 0x8d, 0x2c, 0x86, 0xc6, 0xaa, 0xf8, 0xde, 0x07, 0x3e, 0x49, 0x4a, 0x35, 0x19, + 0x5c, 0x48, 0x03, 0x2e, 0x70, 0x4c, 0x45, 0xdf, 0x58, 0x7a, 0xb0, 0x60, 0x5b, 0xde, 0x9a, 0x5f, + 0x41, 0xbf, 0x7c, 0xd6, 0x83, 0x15, 0x18, 0xfa, 0x46, 0xdd, 0x7e, 0x50, 0x6f, 0x33, 0xaa, 0x94, + 0x3a, 0xb2, 0x38, 0xb1, 0x89, 0x5d, 0x8c, 0x71, 0x7f, 0xca, 0x2b, 0x85, 0x27, 0x71, 0xfe, 0xbc, + 0x90, 0x9c, 0xe0, 0x62, 0x85, 0xd4, 0x2a, 0x8c, 0xcc, 0xdb, 0x8d, 0x87, 0x81, 0xba, 0xbc, 0x06, + 0xa5, 0x15, 0xdd, 0x69, 0x52, 0x0f, 0x65, 0x31, 0x7c, 0xe3, 0xf4, 0x24, 0x3f, 0xdd, 0x66, 0x44, + 0x1c, 0x31, 0x35, 0x26, 0x66, 0x9f, 0x92, 0x87, 0xbf, 0x35, 0x51, 0x40, 0xfd, 0x5e, 0x3f, 0x8c, + 0x88, 0x93, 0x58, 0x5c, 0x3d, 0xc8, 0xeb, 0xe1, 0xd9, 0xb6, 0x98, 0x2e, 0x83, 0xd3, 0xa8, 0xe0, + 0x14, 0x6d, 0x84, 0x31, 0xfb, 0xfd, 0xcd, 0x89, 0xdc, 0xd6, 0xe6, 0x44, 0x9f, 0x36, 0x28, 0x6d, + 0x62, 0xc3, 0xf5, 0x4d, 0x5a, 0xd0, 0xe5, 0xb3, 0xd5, 0x58, 0x59, 0xbe, 0xde, 0xbd, 0x0d, 0x03, + 0xa2, 0x0d, 0x42, 0xe3, 0x2e, 0x84, 0x67, 0x27, 0x91, 0x13, 0xe5, 0x58, 0x69, 0xbf, 0x14, 0x79, + 0x13, 0x4a, 0xfc, 0x2c, 0x41, 0x08, 0xe0, 0x7c, 0xfa, 0xd9, 0x4b, 0xac, 0xb8, 0x28, 0x43, 0xe6, + 0x00, 0xc2, 0x73, 0x84, 0xe0, 0x00, 0x5d, 0x70, 0x48, 0x9e, 0x30, 0xc4, 0xb8, 0x48, 0x65, 0xc9, + 0x2b, 0x30, 0xb2, 0x42, 0x9d, 0xb6, 0x69, 0xe9, 0xad, 0x9a, 0xf9, 0xbe, 0x7f, 0x86, 0x8e, 0x0b, + 0xbd, 0x6b, 0xbe, 0x2f, 0x8f, 0xdc, 0x08, 0x1d, 0xf9, 0x42, 0xda, 0x3e, 0x7d, 0x00, 0x1b, 0xf2, + 0xcc, 0xb6, 0x1b, 0xd8, 0x58, 0x7b, 0x52, 0xb6, 0xed, 0xef, 0xc0, 0x68, 0x64, 0x8b, 0x26, 0x0e, + 0x49, 0x9f, 0x4c, 0xb2, 0x96, 0xf6, 0x9b, 0x31, 0xb6, 0x51, 0x0e, 0x4c, 0x93, 0xab, 0x96, 0xe9, + 0x99, 0x7a, 0x6b, 0xda, 0x6e, 0xb7, 0x75, 0xcb, 0x50, 0x86, 0x42, 0x4d, 0x36, 0x39, 0xa6, 0xde, + 0xe0, 0x28, 0x59, 0x93, 0xa3, 0x85, 0xc8, 0x1d, 0x18, 0x17, 0x7d, 0xa8, 0xd1, 0x86, 0xed, 0x30, + 0xdb, 0x03, 0xcf, 0x40, 0xc5, 0x31, 0x80, 0xcb, 0x71, 0x75, 0xc7, 0x47, 0xca, 0xc6, 0x7d, 0xbc, + 0xe0, 0xed, 0xe2, 0xe0, 0xf0, 0xf8, 0x48, 0xfc, 0xd8, 0x5a, 0xfd, 0x1b, 0x05, 0x18, 0x16, 0xa4, + 0x6c, 0xe9, 0x3e, 0x51, 0xf0, 0xfd, 0x28, 0x78, 0xaa, 0xa2, 0x96, 0x0e, 0x4a, 0x51, 0xd5, 0x2f, + 0xe7, 0x83, 0xd9, 0x68, 0xd9, 0x31, 0xad, 0xfd, 0xcd, 0x46, 0x57, 0x00, 0xa6, 0xd7, 0xba, 0xd6, + 0x43, 0x7e, 0x3d, 0x97, 0x0f, 0xaf, 0xe7, 0x1a, 0xa6, 0x26, 0x61, 0xc8, 0x93, 0x50, 0xac, 0x30, + 0xfe, 0xac, 0x67, 0x46, 0xa6, 0x86, 0xbe, 0xcb, 0x39, 0xe5, 0x5e, 0xd0, 0x10, 0xcc, 0x36, 0x73, + 0x53, 0x1b, 0x1e, 0xe5, 0xe6, 0x73, 0x81, 0x6f, 0xe6, 0x56, 0x19, 0x40, 0xe3, 0x70, 0x72, 0x13, + 0x4e, 0x57, 0x68, 0x4b, 0xdf, 0x58, 0x30, 0x5b, 0x2d, 0xd3, 0xa5, 0x0d, 0xdb, 0x32, 0x5c, 0x14, + 0xb2, 0xa8, 0xae, 0xed, 0x6a, 0x49, 0x02, 0xa2, 0x42, 0x69, 0xe9, 0xc1, 0x03, 0x97, 0x7a, 0x28, + 0xbe, 0xc2, 0x14, 0xb0, 0xc9, 0xd9, 0x46, 0x88, 0x26, 0x30, 0xea, 0x37, 0x73, 0x6c, 0xb7, 0xe4, + 0x3e, 0xf4, 0xec, 0x4e, 0xa0, 0xe5, 0xfb, 0x12, 0xc9, 0xb5, 0xd0, 0xae, 0xc8, 0xe3, 0xd7, 0x9e, + 0x12, 0x5f, 0x3b, 0x20, 0x6c, 0x8b, 0xd0, 0xa2, 0x48, 0xfd, 0xaa, 0xc2, 0x36, 0x5f, 0xa5, 0xfe, + 0x51, 0x1e, 0x2e, 0x88, 0x16, 0x4f, 0xb7, 0xcc, 0xce, 0xaa, 0xad, 0x3b, 0x86, 0x46, 0x1b, 0xd4, + 0x7c, 0x44, 0x8f, 0xe6, 0xc0, 0x8b, 0x0e, 0x9d, 0xe2, 0x3e, 0x86, 0xce, 0x0d, 0xdc, 0x78, 0x32, + 0xc9, 0xe0, 0x01, 0x33, 0x37, 0x2a, 0xc6, 0xb7, 0x36, 0x27, 0x46, 0x0c, 0x0e, 0xc6, 0x2b, 0x06, + 0x4d, 0x26, 0x62, 0x4a, 0x32, 0x4f, 0xad, 0xa6, 0xb7, 0x86, 0x4a, 0xd2, 0xcf, 0x95, 0xa4, 0x85, + 0x10, 0x4d, 0x60, 0xd4, 0xff, 0x3d, 0x0f, 0x67, 0xe3, 0x22, 0xaf, 0x51, 0xcb, 0x38, 0x91, 0xf7, + 0x07, 0x23, 0xef, 0x3f, 0x2e, 0xc0, 0x13, 0xa2, 0x4c, 0x6d, 0x4d, 0x77, 0xa8, 0x51, 0x31, 0x1d, + 0xda, 0xf0, 0x6c, 0x67, 0xe3, 0x08, 0x1b, 0x50, 0x07, 0x27, 0xf6, 0x9b, 0x50, 0x12, 0xc7, 0x0d, + 0x7c, 0x9d, 0x19, 0x0b, 0x5a, 0x82, 0xd0, 0xc4, 0x0a, 0xc5, 0x8f, 0x2a, 0x62, 0x9d, 0x55, 0xda, + 0x49, 0x67, 0x7d, 0x1a, 0x46, 0x03, 0xd1, 0xe3, 0xc6, 0x77, 0x20, 0xb4, 0xb6, 0x0c, 0x1f, 0x81, + 0x7b, 0x5f, 0x2d, 0x4a, 0x88, 0xb5, 0xf9, 0x80, 0x6a, 0x05, 0xad, 0xa1, 0x51, 0x51, 0x5b, 0x50, + 0xce, 0x34, 0x34, 0x99, 0x48, 0xdd, 0x2c, 0xc2, 0xa5, 0xf4, 0x6e, 0xd7, 0xa8, 0x6e, 0x9c, 0xf4, + 0xfa, 0x47, 0xb2, 0xd7, 0xc9, 0x33, 0x50, 0x5c, 0xd6, 0xbd, 0x35, 0x71, 0xdd, 0x8f, 0x77, 0xd0, + 0x0f, 0xcc, 0x16, 0xad, 0x77, 0x74, 0x6f, 0x4d, 0x43, 0x94, 0x34, 0x67, 0x00, 0x72, 0x4c, 0x99, + 0x33, 0xa4, 0xc5, 0x7e, 0xf8, 0xe9, 0xdc, 0xd5, 0x62, 0xea, 0x62, 0xff, 0xbd, 0x62, 0xd6, 0xbc, + 0x72, 0xdf, 0x31, 0x3d, 0x7a, 0xa2, 0x61, 0x27, 0x1a, 0xb6, 0x4f, 0x0d, 0xfb, 0xc7, 0x79, 0x18, + 0x0d, 0x36, 0x4d, 0xef, 0xd1, 0xc6, 0xe1, 0xac, 0x55, 0xe1, 0x56, 0xa6, 0xb0, 0xef, 0xad, 0xcc, + 0x7e, 0x14, 0x4a, 0x0d, 0x8e, 0x58, 0xb9, 0x69, 0x80, 0x12, 0xe3, 0x47, 0xac, 0xc1, 0xc1, 0xea, + 0x33, 0x30, 0xb0, 0xa0, 0x3f, 0x36, 0xdb, 0xdd, 0xb6, 0xb0, 0xd2, 0xd1, 0x7d, 0xad, 0xad, 0x3f, + 0xd6, 0x7c, 0xb8, 0xfa, 0xdf, 0xe5, 0x60, 0x4c, 0x08, 0x55, 0x30, 0xdf, 0x97, 0x54, 0x43, 0xe9, + 0xe4, 0xf7, 0x2d, 0x9d, 0xc2, 0xde, 0xa5, 0xa3, 0xfe, 0xe5, 0x02, 0x28, 0xb3, 0x66, 0x8b, 0xae, + 0x38, 0xba, 0xe5, 0x3e, 0xa0, 0x8e, 0xd8, 0x4e, 0xcf, 0x30, 0x56, 0xfb, 0xfa, 0x40, 0x69, 0x4a, + 0xc9, 0xef, 0x69, 0x4a, 0xf9, 0x24, 0x0c, 0x89, 0xc6, 0x04, 0xae, 0x93, 0x38, 0x6a, 0x1c, 0x1f, + 0xa8, 0x85, 0x78, 0x46, 0x5c, 0xee, 0x74, 0x1c, 0xfb, 0x11, 0x75, 0xf8, 0xad, 0x98, 0x20, 0xd6, + 0x7d, 0xa0, 0x16, 0xe2, 0x25, 0xce, 0xd4, 0xb7, 0x17, 0x65, 0xce, 0xd4, 0xd1, 0x42, 0x3c, 0xb9, + 0x0a, 0x83, 0xf3, 0x76, 0x43, 0x47, 0x41, 0xf3, 0x69, 0x65, 0x64, 0x6b, 0x73, 0x62, 0xb0, 0x25, + 0x60, 0x5a, 0x80, 0x65, 0x94, 0x15, 0x7b, 0xdd, 0x6a, 0xd9, 0x3a, 0x77, 0xb6, 0x19, 0xe4, 0x94, + 0x86, 0x80, 0x69, 0x01, 0x96, 0x51, 0x32, 0x99, 0xa3, 0x13, 0xd3, 0x60, 0xc8, 0xf3, 0x81, 0x80, + 0x69, 0x01, 0x56, 0xfd, 0x66, 0x91, 0x69, 0xaf, 0x6b, 0xbe, 0x7f, 0xec, 0xd7, 0x85, 0x70, 0xc0, + 0xf4, 0xef, 0x61, 0xc0, 0x1c, 0x9b, 0x03, 0x3b, 0xf5, 0x5f, 0x0e, 0x00, 0x08, 0xe9, 0xcf, 0x9c, + 0x6c, 0x0e, 0xf7, 0xa7, 0x35, 0x15, 0x38, 0x3d, 0x63, 0xad, 0xe9, 0x56, 0x83, 0x1a, 0xe1, 0xb1, + 0x65, 0x09, 0x87, 0x36, 0x3a, 0x5d, 0x52, 0x81, 0x0c, 0xcf, 0x2d, 0xb5, 0x64, 0x01, 0xf2, 0x22, + 0x0c, 0x57, 0x2d, 0x8f, 0x3a, 0x7a, 0xc3, 0x33, 0x1f, 0x51, 0x31, 0x35, 0xe0, 0x4d, 0xb4, 0x19, + 0x82, 0x35, 0x99, 0x86, 0xdc, 0x84, 0x91, 0x65, 0xdd, 0xf1, 0xcc, 0x86, 0xd9, 0xd1, 0x2d, 0xcf, + 0x55, 0x06, 0x71, 0x46, 0x43, 0x0b, 0xa3, 0x23, 0xc1, 0xb5, 0x08, 0x15, 0xf9, 0x02, 0x0c, 0xe1, + 0xd6, 0x14, 0xfd, 0xc3, 0x87, 0xb6, 0xbd, 0xa8, 0x7c, 0x36, 0x74, 0x47, 0xe4, 0xa7, 0xaf, 0x78, + 0xe3, 0x1c, 0xbf, 0xab, 0x0c, 0x38, 0x92, 0xcf, 0xc1, 0xc0, 0x8c, 0x65, 0x20, 0x73, 0xd8, 0x96, + 0xb9, 0x2a, 0x98, 0x9f, 0x0f, 0x99, 0xdb, 0x9d, 0x18, 0x6f, 0x9f, 0x5d, 0xfa, 0x28, 0x1b, 0xfe, + 0xe0, 0x46, 0xd9, 0xc8, 0x07, 0x70, 0x2c, 0x3e, 0x7a, 0x50, 0xc7, 0xe2, 0x63, 0x7b, 0x3c, 0x16, + 0x57, 0xdf, 0x87, 0xe1, 0xa9, 0xe5, 0xd9, 0x60, 0xf4, 0x5e, 0x84, 0xc2, 0xb2, 0xf0, 0x8c, 0x28, + 0x72, 0x7b, 0xa6, 0x63, 0x1a, 0x1a, 0x83, 0x91, 0x6b, 0x30, 0x38, 0x8d, 0xee, 0x76, 0xe2, 0x16, + 0xb1, 0xc8, 0xd7, 0xbf, 0x06, 0xc2, 0xd0, 0xeb, 0xd6, 0x47, 0x93, 0x8f, 0xc3, 0xc0, 0xb2, 0x63, + 0x37, 0x1d, 0xbd, 0x2d, 0xd6, 0x60, 0x74, 0x4d, 0xe9, 0x70, 0x90, 0xe6, 0xe3, 0xd4, 0x9f, 0xce, + 0xf9, 0x66, 0x3b, 0x2b, 0x51, 0xeb, 0xe2, 0xd1, 0x3c, 0xd6, 0x3d, 0xc8, 0x4b, 0xb8, 0x1c, 0xa4, + 0xf9, 0x38, 0x72, 0x0d, 0xfa, 0x67, 0x1c, 0xc7, 0x76, 0x64, 0x9f, 0x7a, 0xca, 0x00, 0xf2, 0x75, + 0x2f, 0x52, 0x90, 0x57, 0x61, 0x98, 0xcf, 0x39, 0xfc, 0x44, 0xb3, 0xd0, 0xeb, 0xa6, 0x54, 0xa6, + 0x54, 0xbf, 0x53, 0x90, 0x6c, 0x36, 0x2e, 0xf1, 0x63, 0x78, 0x2b, 0xf0, 0x12, 0x14, 0xa6, 0x96, + 0x67, 0xc5, 0x04, 0x78, 0xc6, 0x2f, 0x2a, 0xa9, 0x4a, 0xac, 0x1c, 0xa3, 0x26, 0x97, 0xa1, 0xb8, + 0xcc, 0xd4, 0xa7, 0x84, 0xea, 0x31, 0xb8, 0xb5, 0x39, 0x51, 0xec, 0x30, 0xfd, 0x41, 0x28, 0x62, + 0xd9, 0x66, 0x86, 0xef, 0x98, 0x38, 0x36, 0xdc, 0xc7, 0x5c, 0x86, 0x62, 0xd9, 0x69, 0x3e, 0x12, + 0xb3, 0x16, 0x62, 0x75, 0xa7, 0xf9, 0x48, 0x43, 0x28, 0xb9, 0x0e, 0xa0, 0x51, 0xaf, 0xeb, 0x58, + 0xf8, 0xdc, 0x65, 0x08, 0xcf, 0xdf, 0x70, 0x36, 0x74, 0x10, 0x5a, 0x6f, 0xd8, 0x06, 0xd5, 0x24, + 0x12, 0xf5, 0xaf, 0x87, 0x17, 0x3b, 0x15, 0xd3, 0x7d, 0x78, 0xd2, 0x85, 0xbb, 0xe8, 0x42, 0x5d, + 0x1c, 0x71, 0x26, 0x3b, 0x69, 0x02, 0xfa, 0x67, 0x5b, 0x7a, 0xd3, 0xc5, 0x3e, 0x14, 0xbe, 0x6b, + 0x0f, 0x18, 0x40, 0xe3, 0xf0, 0x58, 0x3f, 0x0d, 0x6e, 0xdf, 0x4f, 0x5f, 0xef, 0x0f, 0x46, 0xdb, + 0x22, 0xf5, 0xd6, 0x6d, 0xe7, 0xa4, 0xab, 0x76, 0xda, 0x55, 0x57, 0x60, 0xa0, 0xe6, 0x34, 0xa4, + 0xa3, 0x0b, 0xdc, 0x0f, 0xb8, 0x4e, 0x83, 0x1f, 0x5b, 0xf8, 0x48, 0x46, 0x57, 0x71, 0x3d, 0xa4, + 0x1b, 0x08, 0xe9, 0x0c, 0xd7, 0x13, 0x74, 0x02, 0x29, 0xe8, 0x96, 0x6d, 0xc7, 0x13, 0x1d, 0x17, + 0xd0, 0x75, 0x6c, 0xc7, 0xd3, 0x7c, 0x24, 0xf9, 0x24, 0xc0, 0xca, 0xf4, 0xb2, 0xef, 0xdc, 0x3f, + 0x14, 0xfa, 0x1e, 0x0a, 0xaf, 0x7e, 0x4d, 0x42, 0x93, 0x15, 0x18, 0x5a, 0xea, 0x50, 0x87, 0x6f, + 0x85, 0xf8, 0x03, 0x96, 0x4f, 0xc4, 0x44, 0x2b, 0xfa, 0x7d, 0x52, 0xfc, 0x1f, 0x90, 0xf3, 0xf5, + 0xc5, 0xf6, 0x7f, 0x6a, 0x21, 0x23, 0xf2, 0x2a, 0x94, 0xca, 0xdc, 0xce, 0x1b, 0x46, 0x96, 0x81, + 0xc8, 0x70, 0x0b, 0xca, 0x51, 0x7c, 0xcf, 0xae, 0xe3, 0xdf, 0x9a, 0x20, 0x57, 0xaf, 0xc1, 0x78, + 0xbc, 0x1a, 0x32, 0x0c, 0x03, 0xd3, 0x4b, 0x8b, 0x8b, 0x33, 0xd3, 0x2b, 0xe3, 0x7d, 0x64, 0x10, + 0x8a, 0xb5, 0x99, 0xc5, 0xca, 0x78, 0x4e, 0xfd, 0x25, 0x69, 0x06, 0x61, 0xaa, 0x75, 0x72, 0x35, + 0xbc, 0xaf, 0xfb, 0x96, 0x71, 0xbc, 0x0f, 0xc5, 0x13, 0x83, 0xb6, 0xe9, 0x79, 0xd4, 0x10, 0xab, + 0x04, 0xde, 0x17, 0x7a, 0x8f, 0xb5, 0x04, 0x9e, 0x3c, 0x0f, 0xa3, 0x08, 0x13, 0x57, 0x84, 0x7c, + 0x7f, 0x2c, 0x0a, 0x38, 0x8f, 0xb5, 0x28, 0x52, 0xfd, 0xdd, 0xf0, 0x76, 0x78, 0x9e, 0xea, 0x47, + 0xf5, 0x46, 0xf1, 0x43, 0xd2, 0x5f, 0xea, 0xbf, 0x2e, 0xf2, 0x27, 0x27, 0xfc, 0x7d, 0xe2, 0x61, + 0x88, 0x32, 0x3c, 0xd2, 0x2d, 0xec, 0xe2, 0x48, 0xf7, 0x79, 0x28, 0x2d, 0x50, 0x6f, 0xcd, 0xf6, + 0x1d, 0xbf, 0xd0, 0x43, 0xaf, 0x8d, 0x10, 0xd9, 0x43, 0x8f, 0xd3, 0x90, 0x87, 0x40, 0xfc, 0xc7, + 0x87, 0x81, 0xe3, 0xb7, 0x7f, 0x84, 0x7c, 0x21, 0xb1, 0x4f, 0xa9, 0xe1, 0x13, 0x65, 0xf4, 0xe9, + 0x3f, 0x1b, 0x38, 0x96, 0x4b, 0x9e, 0x58, 0xff, 0x6a, 0x73, 0xa2, 0xc4, 0x69, 0xb4, 0x14, 0xb6, + 0xe4, 0x1d, 0x18, 0x5a, 0x98, 0x2d, 0x8b, 0x87, 0x88, 0xdc, 0x2b, 0xe2, 0x62, 0x20, 0x45, 0x1f, + 0x11, 0x88, 0x04, 0xdf, 0xf7, 0xb4, 0x1f, 0xe8, 0xc9, 0x77, 0x88, 0x21, 0x17, 0xa6, 0x2d, 0xfc, + 0xa5, 0x90, 0x38, 0x5d, 0x08, 0xb4, 0x25, 0xfa, 0x7e, 0x28, 0x2e, 0x2b, 0x8e, 0x8d, 0x69, 0xcb, + 0xe0, 0x3e, 0x46, 0xf7, 0x12, 0x9c, 0x2e, 0x77, 0x3a, 0x2d, 0x93, 0x1a, 0xa8, 0x2f, 0x5a, 0xb7, + 0x45, 0x5d, 0xe1, 0xf2, 0x83, 0x8f, 0x4f, 0x74, 0x8e, 0xac, 0xe3, 0xf3, 0xd7, 0xba, 0xd3, 0x8d, + 0xfa, 0x67, 0x26, 0xcb, 0xaa, 0x7f, 0x21, 0x0f, 0xe7, 0xa7, 0x1d, 0xaa, 0x7b, 0x74, 0x61, 0xb6, + 0x5c, 0xee, 0xa2, 0x8f, 0x5c, 0xab, 0x45, 0xad, 0xe6, 0xe1, 0x0c, 0xeb, 0x37, 0x60, 0x2c, 0x68, + 0x40, 0xad, 0x61, 0x77, 0xa8, 0xfc, 0x90, 0xab, 0xe1, 0x63, 0xea, 0x2e, 0x43, 0x69, 0x31, 0x52, + 0x72, 0x07, 0xce, 0x04, 0x90, 0x72, 0xab, 0x65, 0xaf, 0x6b, 0xb4, 0xeb, 0x72, 0x47, 0xdc, 0x41, + 0xee, 0x88, 0x1b, 0x72, 0xd0, 0x19, 0xbe, 0xee, 0x30, 0x02, 0x2d, 0xad, 0x94, 0xfa, 0x8d, 0x02, + 0x5c, 0xb8, 0xa7, 0xb7, 0x4c, 0x23, 0x14, 0x8d, 0x46, 0xdd, 0x8e, 0x6d, 0xb9, 0xf4, 0x08, 0x8d, + 0xd2, 0xc8, 0x50, 0x28, 0x1e, 0xc8, 0x50, 0x48, 0x76, 0x51, 0xff, 0xbe, 0xbb, 0xa8, 0xb4, 0xa7, + 0x2e, 0xfa, 0xdf, 0x72, 0x30, 0xee, 0x3f, 0x34, 0x90, 0x1f, 0x8d, 0x4b, 0x5e, 0xf0, 0x78, 0x84, + 0x18, 0xf3, 0xbb, 0x46, 0x3c, 0xa9, 0xc1, 0xc0, 0xcc, 0xe3, 0x8e, 0xe9, 0x50, 0x77, 0x07, 0x4e, + 0xe3, 0x4f, 0x8a, 0xe3, 0x92, 0xd3, 0x94, 0x17, 0x49, 0x9c, 0x94, 0x70, 0x30, 0x3e, 0x1f, 0xe4, + 0x4f, 0x2d, 0xa6, 0xfc, 0x97, 0xf0, 0xfc, 0xf9, 0xa0, 0x78, 0x92, 0x11, 0x79, 0x0f, 0x1a, 0x92, + 0x92, 0x67, 0xa1, 0xb0, 0xb2, 0x32, 0x2f, 0x66, 0x52, 0x8c, 0x40, 0xe0, 0x79, 0xf2, 0xfb, 0x48, + 0x86, 0x55, 0xff, 0x59, 0x1e, 0x80, 0xa9, 0x02, 0x1f, 0xae, 0x87, 0xa2, 0x84, 0x53, 0x30, 0xe8, + 0x0b, 0x5c, 0xa8, 0x61, 0xf0, 0x4a, 0x20, 0xde, 0x11, 0xf1, 0xba, 0x83, 0x17, 0x21, 0x13, 0xbe, + 0x23, 0x39, 0xbf, 0x07, 0xc0, 0x9d, 0x0d, 0x3a, 0x92, 0xfb, 0xee, 0xe3, 0x9f, 0x84, 0x21, 0x31, + 0xe3, 0xd9, 0x91, 0xf3, 0xff, 0x86, 0x0f, 0xd4, 0x42, 0x7c, 0x6c, 0x6a, 0x2d, 0xed, 0x63, 0x21, + 0xf6, 0xc5, 0xcb, 0x7b, 0xe5, 0x44, 0xbc, 0x07, 0x2c, 0xde, 0xaf, 0x08, 0xf1, 0xf2, 0x17, 0x43, + 0x47, 0x56, 0xbc, 0x07, 0x76, 0xf6, 0xad, 0xfe, 0xe3, 0x1c, 0x10, 0xd6, 0xac, 0x65, 0xdd, 0x75, + 0xd7, 0x6d, 0xc7, 0xe0, 0xce, 0xe9, 0x87, 0x22, 0x98, 0x83, 0xbb, 0xaf, 0xfc, 0xce, 0x20, 0x9c, + 0x89, 0x38, 0xfe, 0x1e, 0xf1, 0xc9, 0xea, 0x5a, 0x74, 0x34, 0xf5, 0x7a, 0xf5, 0xf2, 0x31, 0xf9, + 0x42, 0xb4, 0x3f, 0xf2, 0xe0, 0x4d, 0xba, 0x09, 0x7d, 0x01, 0x46, 0xc4, 0x0f, 0xb6, 0x42, 0xfb, + 0x37, 0x5d, 0x38, 0x4a, 0x5d, 0x06, 0xd0, 0x22, 0x68, 0xf2, 0x32, 0x0c, 0xb1, 0x01, 0xd3, 0xc4, + 0x60, 0x25, 0x03, 0xe1, 0x8b, 0x12, 0xc3, 0x07, 0xca, 0xeb, 0x49, 0x40, 0x29, 0xbd, 0x5b, 0x1a, + 0xdc, 0xc1, 0xbb, 0xa5, 0x2f, 0xc2, 0x70, 0xd9, 0xb2, 0x6c, 0x0f, 0x37, 0xe9, 0xae, 0xb8, 0x9a, + 0xc8, 0xb4, 0xca, 0x9f, 0xc5, 0xc7, 0xf8, 0x21, 0x7d, 0xaa, 0x59, 0x2e, 0x33, 0x24, 0x37, 0xfc, + 0x57, 0x31, 0xd4, 0x11, 0x5e, 0xe5, 0x78, 0x3d, 0xe3, 0x08, 0x58, 0xf2, 0x51, 0x0c, 0x76, 0xde, + 0xe8, 0xb2, 0x63, 0x77, 0x6c, 0x97, 0x1a, 0x5c, 0x50, 0xc3, 0x61, 0x68, 0x83, 0x8e, 0x40, 0xe0, + 0xbb, 0xb9, 0x48, 0xe0, 0x90, 0x48, 0x11, 0xf2, 0x00, 0xce, 0xfa, 0x17, 0xc5, 0xc1, 0x0b, 0xc5, + 0x6a, 0xc5, 0x55, 0x46, 0xf0, 0x55, 0x12, 0x89, 0x2b, 0x43, 0xb5, 0x32, 0xf5, 0x94, 0x7f, 0x2d, + 0xe2, 0x3f, 0x71, 0xac, 0x9b, 0x86, 0xdc, 0xd5, 0xa9, 0xfc, 0xc8, 0x0f, 0xc1, 0xf0, 0x82, 0xfe, + 0xb8, 0xd2, 0x15, 0x67, 0x2f, 0xa3, 0x3b, 0xbf, 0x7d, 0x69, 0xeb, 0x8f, 0xeb, 0x86, 0x28, 0x17, + 0xb3, 0x29, 0x64, 0x96, 0xa4, 0x0e, 0xe7, 0x97, 0x1d, 0xbb, 0x6d, 0x7b, 0xd4, 0x88, 0x3d, 0xf6, + 0x3b, 0x15, 0xbe, 0x0e, 0xee, 0x08, 0x8a, 0x7a, 0x8f, 0x57, 0x7f, 0x19, 0x6c, 0x48, 0x1b, 0x4e, + 0x95, 0x5d, 0xb7, 0xdb, 0xa6, 0xe1, 0x0d, 0xd5, 0xf8, 0xb6, 0x9f, 0xf1, 0x09, 0xe1, 0xb5, 0xfc, + 0x84, 0x8e, 0x45, 0xf9, 0x05, 0x55, 0xdd, 0x33, 0xe5, 0x1a, 0xf1, 0x5b, 0xe2, 0xbc, 0x6f, 0x17, + 0x07, 0xc7, 0xc6, 0x4f, 0x69, 0x17, 0x92, 0x8d, 0x59, 0x31, 0xbd, 0x16, 0x55, 0xbf, 0x9d, 0x03, + 0x08, 0x05, 0x4c, 0x5e, 0x88, 0x46, 0x44, 0xca, 0x85, 0x17, 0x1d, 0x22, 0x5a, 0x42, 0x24, 0x04, + 0x12, 0xb9, 0x0c, 0x45, 0x8c, 0xa8, 0x91, 0x0f, 0x0f, 0x56, 0x1f, 0x9a, 0x96, 0xa1, 0x21, 0x94, + 0x61, 0xa5, 0xa7, 0xef, 0x88, 0xc5, 0x4b, 0x7d, 0x6e, 0x15, 0x56, 0xe0, 0x54, 0xad, 0xbb, 0xea, + 0xd7, 0x2d, 0xbd, 0xe3, 0xc3, 0xc0, 0x1e, 0x6e, 0x77, 0x35, 0x78, 0xfc, 0x1a, 0x09, 0x9b, 0x12, + 0x2d, 0xa2, 0x7e, 0x33, 0x17, 0x9b, 0x05, 0x0f, 0x71, 0xd1, 0xfb, 0x58, 0xd2, 0x4f, 0x23, 0x39, + 0x2d, 0xa9, 0x7f, 0x50, 0x80, 0xe1, 0x65, 0xdb, 0xf1, 0x44, 0x88, 0x92, 0xa3, 0xbd, 0x0a, 0x49, + 0x7b, 0xa5, 0xe2, 0x2e, 0xf6, 0x4a, 0x97, 0xa1, 0x28, 0xb9, 0x28, 0xf3, 0x7b, 0x11, 0xc3, 0x70, + 0x34, 0x84, 0x7e, 0xc0, 0x4f, 0x2e, 0x92, 0x97, 0xa0, 0x03, 0xfb, 0x76, 0x35, 0xf8, 0x91, 0x3c, + 0xc0, 0xe7, 0x5e, 0x7c, 0xf1, 0x18, 0x77, 0xa9, 0xfa, 0x97, 0x72, 0x70, 0x4a, 0x5c, 0x2d, 0x4a, + 0xd1, 0xd0, 0x06, 0xfc, 0x4b, 0x61, 0x79, 0x26, 0xe1, 0x20, 0xcd, 0xc7, 0xb1, 0x45, 0x6b, 0xe6, + 0xb1, 0xe9, 0xe1, 0xed, 0x8a, 0x14, 0x0e, 0x8d, 0x0a, 0x98, 0xbc, 0x68, 0xf9, 0x74, 0xe4, 0x05, + 0xff, 0xd2, 0xb4, 0x10, 0xae, 0xd4, 0xac, 0xc0, 0x4c, 0xea, 0xc5, 0xa9, 0xfa, 0x6b, 0x45, 0x28, + 0xce, 0x3c, 0xa6, 0x8d, 0x23, 0xde, 0x35, 0xd2, 0x51, 0x6c, 0x71, 0x9f, 0x47, 0xb1, 0x7b, 0xf1, + 0x02, 0x79, 0x3b, 0xec, 0xcf, 0x52, 0xb4, 0xfa, 0x58, 0xcf, 0xc7, 0xab, 0xf7, 0x7b, 0xfa, 0xe8, + 0x39, 0x11, 0xfd, 0x97, 0x05, 0x28, 0xd4, 0xa6, 0x97, 0x4f, 0xf4, 0xe6, 0x50, 0xf5, 0xa6, 0xf7, + 0x2d, 0xbb, 0x1a, 0x5c, 0x9c, 0x0d, 0x86, 0x7e, 0xad, 0xb1, 0x3b, 0xb2, 0x3f, 0x2e, 0xc0, 0x58, + 0x6d, 0x76, 0x65, 0x59, 0x3a, 0xbb, 0xbe, 0xc3, 0x7d, 0x0f, 0xd1, 0x0b, 0x8e, 0x77, 0xe9, 0xe5, + 0x84, 0x05, 0x76, 0xb7, 0x6a, 0x79, 0xaf, 0xdc, 0xbc, 0xa7, 0xb7, 0xba, 0x14, 0x0f, 0x8b, 0xb8, + 0xa7, 0xb2, 0x6b, 0xbe, 0x4f, 0xbf, 0x81, 0xa1, 0x11, 0x7c, 0x06, 0xe4, 0x0d, 0x28, 0xdc, 0x15, + 0x3e, 0x24, 0x59, 0x7c, 0x5e, 0xba, 0xc1, 0xf9, 0xb0, 0x49, 0xb0, 0xd0, 0x35, 0x0d, 0xe4, 0xc0, + 0x4a, 0xb1, 0xc2, 0xb7, 0x84, 0xc9, 0xb0, 0xa3, 0xc2, 0x4d, 0xbf, 0xf0, 0xad, 0x6a, 0x85, 0xd4, + 0x60, 0x78, 0x99, 0x3a, 0x6d, 0x13, 0x3b, 0xca, 0x9f, 0xb3, 0x7b, 0x33, 0x61, 0x7b, 0xab, 0xe1, + 0x4e, 0x58, 0x08, 0x99, 0xc9, 0x5c, 0xc8, 0xbb, 0x00, 0xdc, 0xaa, 0xda, 0x61, 0x84, 0xcd, 0x27, + 0x71, 0xa7, 0xc2, 0x8d, 0xe1, 0x14, 0xab, 0x54, 0x62, 0x46, 0x1e, 0xc2, 0xf8, 0x82, 0x6d, 0x98, + 0x0f, 0x4c, 0xee, 0x2c, 0x8a, 0x15, 0x94, 0xb6, 0x77, 0xd1, 0x62, 0xc6, 0x6f, 0x5b, 0x2a, 0x97, + 0x56, 0x4d, 0x82, 0xb1, 0xfa, 0x77, 0xfb, 0xa1, 0xc8, 0xba, 0xfd, 0x64, 0xfc, 0xee, 0x67, 0xfc, + 0x96, 0x61, 0xfc, 0xbe, 0xed, 0x3c, 0x34, 0xad, 0x66, 0xe0, 0xc7, 0x2f, 0x76, 0xd3, 0xe8, 0x7b, + 0xb4, 0xce, 0x71, 0xf5, 0xc0, 0xe5, 0x5f, 0x4b, 0x90, 0x6f, 0x33, 0x82, 0x5f, 0x03, 0xe0, 0xaf, + 0xf3, 0x91, 0x66, 0x30, 0x0c, 0xe7, 0xc1, 0xdf, 0xee, 0xe3, 0xd3, 0x00, 0x39, 0x9c, 0x47, 0x48, + 0x4c, 0xae, 0xf9, 0xde, 0x1b, 0x43, 0xf8, 0x52, 0x00, 0x8f, 0x0d, 0xd0, 0x7b, 0x43, 0x36, 0x02, + 0xb8, 0x1f, 0xc7, 0x32, 0x80, 0x74, 0x23, 0x06, 0x31, 0x41, 0x44, 0x26, 0x07, 0x11, 0x40, 0x2f, + 0xe5, 0x42, 0x4c, 0x93, 0x78, 0x90, 0x57, 0x62, 0x57, 0xf6, 0x24, 0xc2, 0x2d, 0xf3, 0xc6, 0x3e, + 0x74, 0xf9, 0x1a, 0xd9, 0xce, 0xe5, 0x4b, 0xfd, 0x9b, 0x05, 0x18, 0x66, 0xdc, 0x6a, 0xdd, 0x76, + 0x5b, 0x77, 0x36, 0x4e, 0x14, 0x79, 0x3f, 0x8a, 0x5c, 0x87, 0xd3, 0xb2, 0x8b, 0x3f, 0x33, 0x5d, + 0xfd, 0x60, 0x4c, 0xc1, 0x81, 0x55, 0x9c, 0x80, 0xdb, 0x96, 0x38, 0xef, 0x7b, 0x02, 0x8c, 0xa7, + 0x21, 0xae, 0x96, 0xe4, 0xa5, 0xfe, 0x4c, 0x0e, 0xc6, 0xe3, 0xd0, 0x40, 0xf7, 0x73, 0xa9, 0xba, + 0xff, 0x3c, 0x0c, 0x89, 0x4b, 0x7f, 0xdd, 0x10, 0x3e, 0x88, 0x63, 0x5b, 0x9b, 0x13, 0x80, 0x2f, + 0xae, 0xeb, 0x0e, 0xd5, 0x0d, 0x2d, 0x24, 0x20, 0x2f, 0xc3, 0x08, 0xfe, 0xb8, 0xef, 0x98, 0x9e, + 0x47, 0x79, 0x67, 0x14, 0xf9, 0x3d, 0x06, 0x2f, 0xb0, 0xce, 0x11, 0x5a, 0x84, 0x4c, 0xfd, 0x9d, + 0x3c, 0x0c, 0xd5, 0xba, 0xab, 0xee, 0x86, 0xeb, 0xd1, 0xf6, 0x11, 0xd7, 0x21, 0xff, 0x58, 0xa1, + 0x98, 0x7a, 0xac, 0xf0, 0xac, 0x3f, 0xb4, 0xa4, 0xf3, 0xf6, 0x60, 0x63, 0xe0, 0xfb, 0x51, 0x86, + 0x5a, 0x54, 0xda, 0xbd, 0x16, 0xa9, 0x7f, 0x3b, 0x0f, 0xe3, 0xfc, 0xba, 0xb9, 0x62, 0xba, 0x8d, + 0x03, 0x78, 0x02, 0x73, 0xf8, 0x32, 0xdd, 0x9f, 0x8b, 0xc6, 0x0e, 0x1e, 0x16, 0xa9, 0x5f, 0xca, + 0xc3, 0x70, 0xb9, 0xeb, 0xad, 0x95, 0x3d, 0x9c, 0xdf, 0x8e, 0xe5, 0x1e, 0xf9, 0x1f, 0xe5, 0xe0, + 0x14, 0x6b, 0xc8, 0x8a, 0xfd, 0x90, 0x5a, 0x07, 0x70, 0x5c, 0x2f, 0x1f, 0xbb, 0xe7, 0xf7, 0x78, + 0xec, 0xee, 0xcb, 0xb2, 0xb0, 0x3b, 0x59, 0xe2, 0x25, 0x93, 0x66, 0xb7, 0xe8, 0xd1, 0xfe, 0x8c, + 0x03, 0xbc, 0x64, 0xf2, 0x05, 0x72, 0x00, 0x97, 0x9a, 0x1f, 0x2d, 0x81, 0x1c, 0xc0, 0x89, 0xec, + 0x47, 0x43, 0x20, 0xdf, 0xc9, 0xc1, 0xd0, 0x94, 0xed, 0x1d, 0xf1, 0x81, 0x2f, 0xbe, 0xe2, 0x68, + 0xab, 0xb9, 0xff, 0x15, 0x47, 0x5b, 0x37, 0xd5, 0x9f, 0xcd, 0xc3, 0x59, 0x11, 0xc1, 0x5f, 0x9c, + 0x81, 0x9d, 0x4c, 0xc7, 0x62, 0xb0, 0x25, 0x45, 0x73, 0x32, 0x0f, 0x09, 0xd1, 0xfc, 0x42, 0x01, + 0xce, 0x62, 0xc0, 0x61, 0xb6, 0xa3, 0xfa, 0x08, 0xd8, 0x22, 0xa4, 0x11, 0x75, 0x1d, 0x58, 0x48, + 0x71, 0x1d, 0xf8, 0x57, 0x9b, 0x13, 0xaf, 0x34, 0x4d, 0x6f, 0xad, 0xbb, 0x3a, 0xd9, 0xb0, 0xdb, + 0xd7, 0x9b, 0x8e, 0xfe, 0xc8, 0xe4, 0x97, 0xe6, 0x7a, 0xeb, 0x7a, 0x98, 0x58, 0xa7, 0x63, 0x8a, + 0x34, 0x39, 0x35, 0xdc, 0x29, 0x31, 0xae, 0xbe, 0xd3, 0x81, 0x0b, 0x70, 0xdb, 0x36, 0x2d, 0xe1, + 0x89, 0xcb, 0x0d, 0xdd, 0xda, 0xd6, 0xe6, 0xc4, 0xb9, 0xf7, 0x6c, 0xd3, 0xaa, 0xc7, 0xdd, 0x71, + 0x77, 0x5b, 0x5f, 0xc8, 0x5a, 0x93, 0xaa, 0x51, 0xff, 0xdb, 0x1c, 0x5c, 0x8c, 0x6a, 0xf1, 0x47, + 0xc1, 0x76, 0xfc, 0x8b, 0x79, 0x38, 0x77, 0x0b, 0x85, 0x13, 0xb8, 0x3f, 0x9d, 0xcc, 0x5b, 0x62, + 0x70, 0xa6, 0xc8, 0xe6, 0xc4, 0xa2, 0xcc, 0x96, 0xcd, 0xc9, 0xa4, 0x2e, 0x64, 0xf3, 0xdf, 0xe4, + 0xe0, 0xcc, 0x52, 0xb5, 0x32, 0xfd, 0x11, 0x19, 0x51, 0xc9, 0xef, 0x39, 0xe2, 0x06, 0x67, 0xe2, + 0x7b, 0x8e, 0xb8, 0xe9, 0xf9, 0xb5, 0x3c, 0x9c, 0xa9, 0x95, 0x17, 0xe6, 0x3f, 0x2a, 0x33, 0xf8, + 0xb4, 0xec, 0xab, 0xeb, 0x1f, 0x82, 0x09, 0x5b, 0x40, 0xfe, 0xcc, 0x7b, 0x37, 0xb2, 0x7d, 0x78, + 0x93, 0x42, 0x39, 0xe2, 0x53, 0xf7, 0x81, 0x08, 0x85, 0x69, 0x7e, 0x84, 0xfa, 0x88, 0x6b, 0xfe, + 0x3f, 0x2c, 0xc1, 0xf0, 0x9d, 0xee, 0x2a, 0x15, 0x2e, 0x5d, 0xc7, 0xfa, 0xe4, 0xf7, 0x06, 0x0c, + 0x0b, 0x31, 0xe0, 0x0d, 0x87, 0x14, 0x72, 0x52, 0x84, 0x10, 0xe2, 0x51, 0xbd, 0x64, 0x22, 0x72, + 0x19, 0x8a, 0xf7, 0xa8, 0xb3, 0x2a, 0xbf, 0xc6, 0x7e, 0x44, 0x9d, 0x55, 0x0d, 0xa1, 0x64, 0x3e, + 0x7c, 0x68, 0x52, 0x5e, 0xae, 0x62, 0xba, 0x23, 0x71, 0x69, 0x88, 0xf9, 0x9b, 0x02, 0x6f, 0x51, + 0xbd, 0x63, 0xf2, 0x44, 0x49, 0x72, 0x24, 0x88, 0x78, 0x49, 0xb2, 0x08, 0xa7, 0x65, 0x77, 0x41, + 0x9e, 0xeb, 0x67, 0x30, 0x85, 0x5d, 0x5a, 0x96, 0x9f, 0x64, 0x51, 0xf2, 0x36, 0x8c, 0xf8, 0x40, + 0x74, 0x7c, 0x1c, 0x0a, 0x13, 0x4c, 0x04, 0xac, 0x62, 0xf9, 0x00, 0x22, 0x05, 0x64, 0x06, 0x78, + 0x89, 0x01, 0x29, 0x0c, 0x62, 0x8e, 0xa4, 0x91, 0x02, 0xe4, 0x65, 0x64, 0x80, 0x8f, 0xa3, 0xd0, + 0x61, 0x6a, 0x18, 0x9f, 0x2a, 0xe3, 0x05, 0x90, 0x23, 0xe0, 0xfc, 0x41, 0x7a, 0x84, 0x8c, 0x2c, + 0x01, 0x84, 0x8e, 0x2d, 0x22, 0xec, 0xc7, 0xae, 0x5d, 0x6e, 0x24, 0x16, 0xf2, 0x4d, 0xde, 0xe8, + 0x5e, 0x6e, 0xf2, 0xd4, 0x3f, 0xc8, 0xc3, 0x70, 0xb9, 0xd3, 0x09, 0x86, 0xc2, 0x0b, 0x50, 0x2a, + 0x77, 0x3a, 0x77, 0xb5, 0xaa, 0x9c, 0x00, 0x40, 0xef, 0x74, 0xea, 0x5d, 0xc7, 0x94, 0x3d, 0xa9, + 0x39, 0x11, 0x99, 0x86, 0xd1, 0x72, 0xa7, 0xb3, 0xdc, 0x5d, 0x6d, 0x99, 0x0d, 0x29, 0x7f, 0x19, + 0xcf, 0xf0, 0xd8, 0xe9, 0xd4, 0x3b, 0x88, 0x89, 0x27, 0xb1, 0x8b, 0x96, 0x21, 0x5f, 0xc4, 0x60, + 0x59, 0x22, 0x7d, 0x16, 0x4f, 0xd0, 0xa3, 0x06, 0xa1, 0xff, 0xc3, 0xb6, 0x4d, 0x06, 0x44, 0x3c, + 0x45, 0xc2, 0x65, 0x3f, 0xb1, 0x05, 0xab, 0x28, 0x91, 0x26, 0x2b, 0x64, 0x49, 0x3e, 0x05, 0x03, + 0xe5, 0x4e, 0x47, 0xba, 0xad, 0x42, 0xc7, 0x36, 0x56, 0x2a, 0x9e, 0xa1, 0x50, 0x90, 0x5d, 0x7a, + 0x13, 0xc6, 0xa2, 0x95, 0xed, 0x2a, 0xc5, 0xc2, 0xf7, 0x73, 0xf8, 0x41, 0x47, 0xfc, 0x25, 0xc0, + 0x4b, 0x50, 0x28, 0x77, 0x3a, 0x62, 0x3e, 0x3a, 0x93, 0xd2, 0x1f, 0xf1, 0xc0, 0x01, 0xe5, 0x4e, + 0xc7, 0xff, 0xf4, 0x23, 0xfe, 0xa4, 0x68, 0x4f, 0x9f, 0xfe, 0x1d, 0xfe, 0xe9, 0x47, 0xfb, 0xb9, + 0x8f, 0xfa, 0x6b, 0x05, 0x38, 0x55, 0xee, 0x74, 0x4e, 0x52, 0x33, 0x1c, 0x54, 0x78, 0x82, 0x17, + 0x01, 0xa4, 0xe9, 0x71, 0x20, 0x78, 0xf0, 0x38, 0x2c, 0x4d, 0x8d, 0x4a, 0x4e, 0x93, 0x88, 0x7c, + 0xf5, 0x1b, 0xdc, 0x95, 0xfa, 0x7d, 0xa9, 0x80, 0x53, 0xf1, 0x51, 0x0f, 0xb5, 0xf6, 0x61, 0xe9, + 0x36, 0xd1, 0x07, 0xa5, 0x5d, 0xf5, 0xc1, 0xdf, 0x8f, 0x0c, 0x1e, 0x0c, 0xf5, 0x7f, 0xd2, 0x0b, + 0xfd, 0xfb, 0x32, 0x8b, 0xc7, 0x64, 0x61, 0x8a, 0xf8, 0x4f, 0x7e, 0xba, 0x33, 0x11, 0x8d, 0xac, + 0xc1, 0x50, 0x75, 0xd3, 0xd0, 0x62, 0xb4, 0x7e, 0x1f, 0x0e, 0xec, 0xaa, 0x0f, 0x37, 0xf3, 0x18, + 0x71, 0x20, 0x88, 0x66, 0xb6, 0xff, 0xdd, 0xc5, 0x75, 0x00, 0xee, 0x79, 0x10, 0xb8, 0xd6, 0x8f, + 0xf2, 0xc0, 0x45, 0x3c, 0x0b, 0x9a, 0x08, 0x5c, 0x14, 0x92, 0x04, 0x9e, 0x4a, 0x85, 0x54, 0x4f, + 0xa5, 0x6b, 0x30, 0xa8, 0xe9, 0xeb, 0xef, 0x74, 0xa9, 0xb3, 0x21, 0xcc, 0x19, 0x1e, 0x2c, 0x54, + 0x5f, 0xaf, 0xff, 0x30, 0x03, 0x6a, 0x01, 0x9a, 0xa8, 0x41, 0xc8, 0x0a, 0xc9, 0x23, 0x84, 0x9f, + 0x91, 0x07, 0x81, 0x2a, 0xf6, 0xa2, 0xe8, 0xe4, 0x75, 0x28, 0x94, 0xef, 0xd7, 0x84, 0x64, 0x83, + 0xae, 0x2d, 0xdf, 0xaf, 0x09, 0x79, 0x65, 0x96, 0xbd, 0x5f, 0x53, 0xbf, 0x94, 0x07, 0x92, 0xa4, + 0x24, 0xaf, 0xc0, 0x10, 0x42, 0x9b, 0x4c, 0x67, 0xe4, 0xf4, 0xb9, 0xeb, 0x6e, 0xdd, 0x41, 0x68, + 0xc4, 0xb8, 0xf3, 0x49, 0xc9, 0x6b, 0x98, 0xa0, 0x5c, 0x24, 0x70, 0x8c, 0xa4, 0xcf, 0x5d, 0x77, + 0xfd, 0x94, 0xde, 0xb1, 0xfc, 0xe4, 0x82, 0x18, 0xed, 0xc2, 0xfb, 0xb5, 0x39, 0xdb, 0xf5, 0x84, + 0xa8, 0xb9, 0x5d, 0xb8, 0xee, 0x62, 0xde, 0xe6, 0x88, 0x5d, 0xc8, 0xc9, 0x30, 0xf7, 0xdc, 0xfd, + 0x1a, 0x7f, 0xdc, 0x65, 0x68, 0x76, 0xcb, 0x37, 0x28, 0x79, 0xee, 0xb9, 0x75, 0xb7, 0xce, 0x1f, + 0x86, 0x19, 0x98, 0x19, 0x3d, 0x92, 0x7b, 0x2e, 0x52, 0x4a, 0xfd, 0xa9, 0x41, 0x18, 0xaf, 0xe8, + 0x9e, 0xbe, 0xaa, 0xbb, 0x54, 0xda, 0x4d, 0x9f, 0xf2, 0x61, 0xfe, 0xe7, 0x48, 0x72, 0x30, 0x56, + 0x53, 0xbe, 0x26, 0x5e, 0x80, 0xbc, 0x11, 0xf2, 0x0d, 0x32, 0x03, 0xcb, 0xa9, 0x06, 0x57, 0xeb, + 0x1d, 0x01, 0xd6, 0x12, 0x84, 0xe4, 0x79, 0x18, 0xf6, 0x61, 0x6c, 0x03, 0x50, 0x08, 0x75, 0xc6, + 0x58, 0x65, 0xf6, 0xbf, 0x26, 0xa3, 0xc9, 0x6b, 0x30, 0xe2, 0xff, 0x94, 0x4c, 0x6b, 0x9e, 0x37, + 0x71, 0x35, 0xb1, 0x7b, 0x92, 0x49, 0xe5, 0xa2, 0x38, 0xbf, 0xf5, 0x47, 0x8a, 0xc6, 0x52, 0x13, + 0x46, 0x48, 0xc9, 0x0f, 0xc3, 0x98, 0xff, 0x5b, 0x6c, 0x18, 0xb8, 0xe3, 0xe0, 0xf3, 0x41, 0xe2, + 0xf5, 0x98, 0x58, 0x27, 0xa3, 0xe4, 0x7c, 0xeb, 0xf0, 0x84, 0x9f, 0x6d, 0xcf, 0x58, 0x4d, 0xee, + 0x1c, 0x62, 0x15, 0x90, 0x2a, 0x9c, 0xf6, 0x21, 0xa1, 0x86, 0x0e, 0x84, 0x3b, 0x46, 0x63, 0xb5, + 0x9e, 0xaa, 0xa4, 0xc9, 0x52, 0xa4, 0x05, 0x97, 0x23, 0x40, 0xc3, 0x5d, 0x33, 0x1f, 0x78, 0x62, + 0xbb, 0x27, 0x22, 0x77, 0x8b, 0xf4, 0xaa, 0x01, 0x57, 0x4e, 0xe3, 0xe7, 0x49, 0x8e, 0xe6, 0x54, + 0xeb, 0xc9, 0x8d, 0xd4, 0xe0, 0xac, 0x8f, 0xbf, 0x35, 0xbd, 0xbc, 0xec, 0xd8, 0xef, 0xd1, 0x86, + 0x57, 0xad, 0x88, 0xed, 0x32, 0x46, 0x74, 0x34, 0x56, 0xeb, 0xcd, 0x46, 0x87, 0x29, 0x05, 0xc3, + 0x45, 0x99, 0xa7, 0x16, 0x26, 0xf7, 0xe0, 0x9c, 0x04, 0x97, 0x92, 0xb8, 0x43, 0xb8, 0x9f, 0x17, + 0x5c, 0xd3, 0xf3, 0xb8, 0xa7, 0x17, 0x27, 0x6f, 0xc2, 0xa8, 0x8f, 0xe0, 0xb7, 0x88, 0xc3, 0x78, + 0x8b, 0x88, 0x43, 0xd2, 0x58, 0xad, 0xc7, 0xdf, 0x20, 0x47, 0x89, 0x65, 0x8d, 0x5a, 0xd9, 0xe8, + 0x50, 0xe1, 0xd1, 0xeb, 0x6b, 0x94, 0xb7, 0xd1, 0x49, 0x55, 0x46, 0x46, 0x4a, 0xde, 0x0e, 0x35, + 0x6a, 0xc9, 0x31, 0x9b, 0x26, 0xdf, 0x49, 0xfb, 0xcf, 0x8e, 0x57, 0xeb, 0x36, 0x02, 0xd3, 0xf4, + 0x83, 0x93, 0x5f, 0x2a, 0xc3, 0x99, 0x14, 0x1d, 0xdb, 0xd5, 0x8e, 0xf1, 0xcb, 0xf9, 0xb0, 0x11, + 0x47, 0x7c, 0xdb, 0x38, 0x05, 0x83, 0xfe, 0x97, 0x08, 0xe3, 0x41, 0xc9, 0x1a, 0x9a, 0x71, 0x1e, + 0x3e, 0x3e, 0x22, 0x8e, 0x23, 0xbe, 0x95, 0x3c, 0x08, 0x71, 0x7c, 0x37, 0x17, 0x8a, 0xe3, 0x88, + 0x6f, 0x2f, 0x7f, 0xb2, 0x18, 0xce, 0x49, 0x27, 0x7b, 0xcc, 0x83, 0x32, 0x93, 0x43, 0x3f, 0xd8, + 0xd2, 0x2e, 0x9e, 0xff, 0xca, 0xaa, 0x39, 0xb0, 0x37, 0xd5, 0x24, 0x6f, 0xc2, 0xf0, 0xb2, 0xed, + 0x7a, 0x4d, 0x87, 0xba, 0xcb, 0x41, 0xe6, 0x09, 0x7c, 0x3a, 0xde, 0x11, 0xe0, 0x7a, 0x27, 0x32, + 0xfb, 0xcb, 0xe4, 0xea, 0x3f, 0x29, 0x24, 0xb4, 0x81, 0x1b, 0xae, 0x47, 0x52, 0x1b, 0x0e, 0x60, + 0xa8, 0x93, 0x1b, 0xe1, 0x2a, 0xc8, 0x2d, 0xfc, 0x7e, 0x29, 0xac, 0xe6, 0xaa, 0x30, 0xf0, 0xa3, + 0x24, 0xe4, 0x07, 0xe0, 0x42, 0x04, 0xb0, 0xac, 0x3b, 0x7a, 0x9b, 0x7a, 0x61, 0x96, 0x4f, 0x0c, + 0x94, 0xe6, 0x97, 0xae, 0x77, 0x02, 0xb4, 0x9c, 0x39, 0x34, 0x83, 0x83, 0xa4, 0x5a, 0x03, 0xbb, + 0x70, 0xb1, 0xfe, 0x7a, 0x21, 0x34, 0x74, 0xa2, 0x01, 0x8f, 0x35, 0xea, 0x76, 0x5b, 0xde, 0xf1, + 0xed, 0xe0, 0xbd, 0xa5, 0x93, 0x99, 0x83, 0x53, 0xe5, 0x07, 0x0f, 0x68, 0xc3, 0xf3, 0xe3, 0xb8, + 0xbb, 0x22, 0xc4, 0x25, 0xdf, 0x78, 0x08, 0x94, 0x88, 0xcb, 0x2d, 0xf7, 0x6b, 0xbc, 0x98, 0xfa, + 0x4f, 0x8b, 0xa0, 0x04, 0x86, 0x7f, 0xf0, 0xd4, 0xf0, 0x10, 0x17, 0xd9, 0x0f, 0x45, 0xaf, 0x98, + 0x70, 0x3a, 0x14, 0x86, 0x78, 0xe3, 0x25, 0xf2, 0xce, 0x4f, 0xc4, 0x99, 0x85, 0x84, 0x7c, 0x2f, + 0x71, 0x49, 0xec, 0x25, 0x48, 0xf8, 0x94, 0xb3, 0xee, 0x72, 0x16, 0x5a, 0x92, 0x2b, 0xf9, 0x4a, + 0x0e, 0xce, 0xfa, 0x9d, 0xb2, 0xb4, 0xca, 0x8c, 0xea, 0x69, 0xbb, 0x6b, 0x05, 0x0f, 0xa0, 0x5e, + 0xcf, 0xae, 0x8e, 0x77, 0xd2, 0x64, 0x5a, 0x61, 0xde, 0x92, 0x20, 0x98, 0x4b, 0xa0, 0x10, 0x36, + 0xd2, 0xd4, 0x1b, 0x48, 0xa4, 0xa5, 0xd6, 0x7b, 0xe9, 0x16, 0x5c, 0xcc, 0x64, 0xb9, 0x9d, 0x11, + 0xdb, 0x2f, 0x1b, 0xb1, 0xff, 0x7d, 0x2e, 0x9c, 0x88, 0x62, 0x42, 0x22, 0x93, 0x00, 0x21, 0x48, + 0x6c, 0x6b, 0xf1, 0x7d, 0x55, 0x28, 0x34, 0x4d, 0xa2, 0x20, 0x4b, 0x50, 0x12, 0x62, 0xe1, 0x19, + 0xb5, 0x3f, 0xb9, 0x4d, 0x2f, 0x4c, 0xca, 0x72, 0xc0, 0x2d, 0xab, 0xf8, 0x66, 0xc1, 0xe6, 0xd2, + 0x6b, 0x30, 0xbc, 0xd7, 0xef, 0xfa, 0x4a, 0x01, 0x88, 0xbc, 0x07, 0x3d, 0x44, 0x03, 0xfd, 0x08, + 0x4f, 0x61, 0x57, 0x61, 0x90, 0x7d, 0x02, 0xe6, 0x98, 0x91, 0x62, 0x4a, 0x77, 0x05, 0x4c, 0x0b, + 0xb0, 0x61, 0x40, 0xb7, 0x81, 0xf4, 0x80, 0x6e, 0xea, 0xcf, 0x14, 0xe0, 0xbc, 0xdc, 0x21, 0x15, + 0x8a, 0x69, 0x2a, 0x4e, 0x3a, 0xe5, 0x03, 0xec, 0x14, 0x15, 0x4a, 0x7c, 0xeb, 0x21, 0xf2, 0x85, + 0xf0, 0x63, 0x21, 0x84, 0x68, 0x02, 0xa3, 0xfe, 0x2f, 0x79, 0x18, 0x0d, 0xcc, 0x3b, 0xdd, 0x71, + 0x8f, 0x71, 0x77, 0x7c, 0x1a, 0x46, 0x31, 0x24, 0x57, 0x9b, 0x5a, 0x3c, 0x6c, 0x55, 0xbf, 0x94, + 0xe0, 0xc7, 0x47, 0x88, 0x5c, 0x6e, 0x11, 0x42, 0xa6, 0xfd, 0xdc, 0xf2, 0x93, 0x02, 0xa5, 0x71, + 0xb3, 0x8f, 0xc3, 0xd5, 0xbf, 0x52, 0x80, 0x11, 0x5f, 0xca, 0x53, 0xe6, 0x51, 0xbd, 0xe7, 0x39, + 0x5c, 0x21, 0x5f, 0x07, 0x58, 0xb6, 0x1d, 0x4f, 0x6f, 0x2d, 0x86, 0x9a, 0x8f, 0x07, 0xa4, 0x1d, + 0x84, 0xf2, 0x32, 0x12, 0x09, 0xae, 0x5f, 0xa1, 0x59, 0xcd, 0x27, 0x26, 0xbe, 0x7e, 0x05, 0x50, + 0x4d, 0xa2, 0x50, 0x7f, 0x2b, 0x0f, 0xa7, 0xfc, 0x4e, 0x9a, 0x79, 0x4c, 0x1b, 0xdd, 0xe3, 0x3c, + 0x37, 0x45, 0xa5, 0xdd, 0xbf, 0xad, 0xb4, 0xd5, 0xff, 0x4b, 0x9a, 0x48, 0xa6, 0x5b, 0xf6, 0xc9, + 0x44, 0xf2, 0x27, 0xa1, 0xe3, 0xea, 0x8f, 0x16, 0xe0, 0xac, 0x2f, 0xf5, 0xd9, 0xae, 0x85, 0x47, + 0x0b, 0xd3, 0x7a, 0xab, 0x75, 0x9c, 0x77, 0xe3, 0xc3, 0xbe, 0x20, 0x96, 0x44, 0x8c, 0x4b, 0x91, + 0x57, 0xf3, 0x81, 0x00, 0xd7, 0x6d, 0xd3, 0xd0, 0x64, 0x22, 0xf2, 0x36, 0x8c, 0xf8, 0x3f, 0xcb, + 0x4e, 0xd3, 0xdf, 0x82, 0xe3, 0x45, 0x41, 0x50, 0x48, 0x77, 0x22, 0x81, 0x31, 0x22, 0x05, 0xd4, + 0x2f, 0x0d, 0xc0, 0xa5, 0xfb, 0xa6, 0x65, 0xd8, 0xeb, 0xae, 0x9f, 0x96, 0xf5, 0xc8, 0x1f, 0x94, + 0x1d, 0x76, 0x3a, 0xd6, 0x77, 0xe0, 0x5c, 0x5c, 0xa4, 0x4e, 0x10, 0x2c, 0x5f, 0xf4, 0xce, 0x3a, + 0x27, 0xa8, 0xfb, 0x09, 0x5a, 0xc5, 0x6d, 0x9b, 0x96, 0x5e, 0x32, 0x9e, 0xe1, 0x75, 0x60, 0x27, + 0x19, 0x5e, 0x9f, 0x83, 0x52, 0xc5, 0x6e, 0xeb, 0xa6, 0x1f, 0x22, 0x09, 0x47, 0x71, 0x50, 0x2f, + 0x62, 0x34, 0x41, 0xc1, 0xf8, 0x8b, 0x8a, 0xb1, 0xcb, 0x86, 0x42, 0xfe, 0x7e, 0x01, 0x66, 0xa5, + 0x69, 0x32, 0x11, 0xb1, 0x61, 0x54, 0x54, 0x27, 0xee, 0xc6, 0x00, 0x37, 0x4f, 0x2f, 0xfb, 0x32, + 0xca, 0x56, 0xab, 0xc9, 0x48, 0x39, 0xbe, 0x8d, 0xe2, 0x89, 0x67, 0xc5, 0xc7, 0xf0, 0x5b, 0x32, + 0x2d, 0xca, 0x5f, 0x12, 0x02, 0x4e, 0x32, 0xc3, 0x49, 0x21, 0xe0, 0x2c, 0x23, 0x13, 0x91, 0x19, + 0x38, 0x8d, 0x21, 0xcd, 0x83, 0xad, 0x14, 0x53, 0x89, 0x11, 0x34, 0x2a, 0xf1, 0xca, 0x85, 0x47, + 0x41, 0x67, 0x1f, 0x57, 0x6f, 0x08, 0xb4, 0x96, 0x2c, 0x41, 0x2e, 0x42, 0x61, 0x71, 0xbe, 0x8c, + 0x77, 0x35, 0x83, 0x3c, 0x9d, 0x98, 0xd5, 0xd2, 0x35, 0x06, 0xbb, 0xf4, 0x59, 0x20, 0xc9, 0xcf, + 0xd9, 0xd5, 0x7d, 0xcc, 0x7f, 0x25, 0x6d, 0xf9, 0x8e, 0xba, 0x47, 0xcd, 0x41, 0x4c, 0x84, 0x91, + 0x4c, 0x7e, 0xfd, 0x1f, 0x64, 0x26, 0xbf, 0xd2, 0x81, 0x66, 0xf2, 0x53, 0x7f, 0x39, 0x07, 0xa7, + 0x13, 0x61, 0xff, 0xc9, 0x4b, 0x00, 0x1c, 0x22, 0x85, 0x57, 0xc5, 0xe8, 0x3f, 0x61, 0x2a, 0x00, + 0xb1, 0x3c, 0x86, 0x64, 0xe4, 0x3a, 0x0c, 0xf2, 0x5f, 0x22, 0xc0, 0x58, 0xb2, 0x48, 0xb7, 0x6b, + 0x1a, 0x5a, 0x40, 0x14, 0xd6, 0x82, 0x37, 0x92, 0x85, 0xd4, 0x22, 0xde, 0x46, 0x27, 0xa8, 0x85, + 0x91, 0xa9, 0x3f, 0x95, 0x87, 0x91, 0xa0, 0xc1, 0x65, 0xe3, 0xb0, 0x74, 0xae, 0x24, 0x32, 0x28, + 0x14, 0xb6, 0xcb, 0xa0, 0x10, 0x9b, 0x6f, 0x45, 0xca, 0x84, 0x83, 0x7b, 0x50, 0xf5, 0xd5, 0x3c, + 0x9c, 0x0a, 0x6a, 0x3d, 0xc4, 0xcb, 0xaf, 0x0f, 0x91, 0x48, 0xbe, 0x92, 0x03, 0x65, 0xca, 0x6c, + 0xb5, 0x4c, 0xab, 0x59, 0xb5, 0x1e, 0xd8, 0x4e, 0x1b, 0x27, 0xc4, 0xc3, 0x3b, 0xc2, 0x55, 0xff, + 0x6c, 0x0e, 0x4e, 0x8b, 0x06, 0x4d, 0xeb, 0x8e, 0x71, 0x78, 0xe7, 0x63, 0xf1, 0x96, 0x1c, 0x9e, + 0xbe, 0xa8, 0xdf, 0xca, 0x03, 0xcc, 0xdb, 0x8d, 0x87, 0x47, 0xfc, 0x3d, 0xd6, 0x1b, 0x50, 0xe2, + 0x51, 0xde, 0x84, 0xc6, 0x9e, 0x16, 0xef, 0x8e, 0xd8, 0xa7, 0x71, 0xc4, 0xd4, 0xb8, 0x98, 0x8f, + 0x4b, 0x3c, 0x4a, 0x9c, 0x92, 0xd3, 0x44, 0x11, 0x56, 0x29, 0xa3, 0x13, 0x0b, 0x46, 0x50, 0x29, + 0x83, 0x45, 0x2b, 0xdd, 0xda, 0x9c, 0x28, 0xb6, 0xec, 0xc6, 0x43, 0x0d, 0xe9, 0xd5, 0x7f, 0x9d, + 0xe3, 0xb2, 0x3b, 0xe2, 0xaf, 0x4a, 0xfd, 0xcf, 0x2f, 0xee, 0xf2, 0xf3, 0xff, 0x5c, 0x0e, 0xce, + 0x6a, 0xb4, 0x61, 0x3f, 0xa2, 0xce, 0xc6, 0xb4, 0x6d, 0xd0, 0x5b, 0xd4, 0xa2, 0xce, 0x61, 0x8d, + 0xa8, 0xdf, 0xc6, 0x94, 0x33, 0x61, 0x63, 0xee, 0xba, 0xd4, 0x38, 0x3a, 0xe9, 0x80, 0xd4, 0x5f, + 0x1d, 0x00, 0x25, 0xd5, 0xea, 0x3d, 0xb2, 0xe6, 0x5c, 0xe6, 0x56, 0xa6, 0x78, 0x50, 0x5b, 0x99, + 0xfe, 0xdd, 0x6d, 0x65, 0x4a, 0xbb, 0xdd, 0xca, 0x0c, 0xec, 0x64, 0x2b, 0xd3, 0x8e, 0x6f, 0x65, + 0x06, 0x71, 0x2b, 0xf3, 0x52, 0xcf, 0xad, 0xcc, 0x8c, 0x65, 0xec, 0x71, 0x23, 0x73, 0x64, 0x53, + 0x55, 0xef, 0x65, 0x07, 0x76, 0x95, 0x4d, 0x8a, 0x0d, 0xdb, 0x31, 0xa8, 0x21, 0x36, 0x5e, 0x78, + 0xea, 0xef, 0x08, 0x98, 0x16, 0x60, 0x13, 0x79, 0xbf, 0x47, 0x77, 0x92, 0xf7, 0xfb, 0x00, 0xf6, + 0x5f, 0x5f, 0xce, 0xc3, 0xe9, 0x69, 0xea, 0x78, 0x3c, 0x8c, 0xec, 0x41, 0xb8, 0xc4, 0x95, 0xe1, + 0x94, 0xc4, 0x10, 0x2d, 0xf2, 0x7c, 0xe8, 0xe6, 0xd7, 0xa0, 0x8e, 0x17, 0xf7, 0x12, 0x8c, 0xd3, + 0xb3, 0xea, 0xfd, 0xdc, 0x7b, 0x62, 0xec, 0x06, 0xd5, 0xfb, 0x70, 0x2e, 0x48, 0x53, 0xfc, 0xd2, + 0x02, 0x7a, 0x29, 0x9d, 0x5e, 0x71, 0xf7, 0xe9, 0xf4, 0xd4, 0x5f, 0xca, 0xc1, 0x15, 0x8d, 0x5a, + 0x74, 0x5d, 0x5f, 0x6d, 0x51, 0xa9, 0x59, 0x62, 0x65, 0x60, 0xb3, 0x86, 0xe9, 0xb6, 0x75, 0xaf, + 0xb1, 0xb6, 0x2f, 0x19, 0xcd, 0xc2, 0x88, 0x3c, 0x7f, 0xed, 0x62, 0x6e, 0x8b, 0x94, 0x53, 0x7f, + 0xb5, 0x08, 0x03, 0x53, 0xb6, 0x77, 0xdb, 0xde, 0x67, 0x7e, 0xc7, 0x70, 0xca, 0xcf, 0xef, 0xe2, + 0xac, 0xe7, 0x53, 0x58, 0xb9, 0x94, 0xf2, 0x02, 0x5d, 0x48, 0x57, 0xed, 0x44, 0x6a, 0x10, 0x9f, + 0x6c, 0x97, 0x99, 0x1d, 0x5f, 0x81, 0x21, 0x8c, 0xfe, 0x22, 0x9d, 0xc6, 0xa2, 0x83, 0xb6, 0xc7, + 0x80, 0xf1, 0x3a, 0x42, 0x52, 0xf2, 0x03, 0x91, 0xb8, 0xb7, 0xa5, 0xfd, 0x67, 0x82, 0x94, 0x43, + 0xe0, 0xbe, 0xc4, 0x2f, 0xf2, 0xb0, 0x4d, 0x52, 0xd6, 0x1c, 0x3c, 0x45, 0x89, 0x35, 0x29, 0x20, + 0x3c, 0xc0, 0x2c, 0x8d, 0xd3, 0x30, 0x3a, 0x65, 0x7b, 0x92, 0x33, 0xf0, 0x50, 0xf8, 0x0c, 0x94, + 0x49, 0x3e, 0xdd, 0x13, 0x38, 0x5a, 0x46, 0xfd, 0xe3, 0x22, 0x8c, 0xf8, 0x3f, 0x0f, 0x49, 0x77, + 0x5e, 0x80, 0xd2, 0x9c, 0x2d, 0x25, 0x0e, 0x41, 0x07, 0xe2, 0x35, 0xdb, 0x8d, 0x79, 0x46, 0x0b, + 0x22, 0x26, 0xf5, 0x45, 0xdb, 0x90, 0xdd, 0xdf, 0x51, 0xea, 0x96, 0x6d, 0x24, 0x9e, 0x0f, 0x07, + 0x84, 0xe4, 0x0a, 0x14, 0xf1, 0xe5, 0x80, 0x74, 0x90, 0x1f, 0x7b, 0x2d, 0x80, 0x78, 0x49, 0x2b, + 0x4b, 0xbb, 0xd5, 0xca, 0x81, 0xbd, 0x6a, 0xe5, 0xe0, 0xc1, 0x6a, 0xe5, 0xbb, 0x30, 0x82, 0x35, + 0xf9, 0x79, 0x07, 0xb7, 0x5f, 0x58, 0x2f, 0x8a, 0xb5, 0x6f, 0x94, 0xb7, 0x5b, 0x64, 0x1f, 0xc4, + 0x25, 0x2f, 0xc2, 0x2a, 0xa6, 0xbb, 0xb0, 0x8f, 0xed, 0xf4, 0x3f, 0xc9, 0xc1, 0xc0, 0x5d, 0xeb, + 0xa1, 0x65, 0xaf, 0xef, 0x4f, 0xe3, 0x5e, 0x82, 0x61, 0xc1, 0x46, 0x5a, 0x5d, 0xf0, 0x45, 0x78, + 0x97, 0x83, 0xeb, 0xc8, 0x49, 0x93, 0xa9, 0xc8, 0x9b, 0x41, 0x21, 0x7c, 0x1c, 0x54, 0x08, 0x53, + 0xef, 0xf8, 0x85, 0x1a, 0xd1, 0xdc, 0x1b, 0x32, 0x39, 0xb9, 0x0c, 0xc5, 0x0a, 0x6b, 0xaa, 0x14, + 0x83, 0x97, 0x35, 0x45, 0x43, 0xa8, 0xfa, 0xe5, 0x22, 0x8c, 0xc5, 0x0e, 0xbe, 0x9e, 0x83, 0x21, + 0x71, 0xf0, 0x64, 0xfa, 0xc9, 0x40, 0xf0, 0xf1, 0x50, 0x00, 0xd4, 0x06, 0xf9, 0x9f, 0x55, 0x83, + 0x7c, 0x06, 0x06, 0x6c, 0x17, 0x17, 0x45, 0xfc, 0x96, 0xb1, 0x70, 0x08, 0x2d, 0xd5, 0x58, 0xdb, + 0xf9, 0xe0, 0x10, 0x24, 0xb2, 0x46, 0xda, 0x2e, 0x7e, 0xda, 0x4d, 0x18, 0xd2, 0x5d, 0x97, 0x7a, + 0x75, 0x4f, 0x6f, 0xca, 0xf9, 0x41, 0x02, 0xa0, 0x3c, 0x3a, 0x10, 0xb8, 0xa2, 0x37, 0xc9, 0x67, + 0x61, 0xb4, 0xe1, 0x50, 0x5c, 0x36, 0xf5, 0x16, 0x6b, 0xa5, 0x64, 0xd6, 0x46, 0x10, 0xf2, 0xfd, + 0x49, 0x88, 0xa8, 0x1a, 0xe4, 0x1e, 0x8c, 0x8a, 0xcf, 0xe1, 0x9e, 0xfb, 0x38, 0xd0, 0xc6, 0xc2, + 0x65, 0x8c, 0x8b, 0x84, 0xfb, 0xee, 0x8b, 0x07, 0x1c, 0x32, 0xb9, 0xcc, 0xd7, 0x90, 0x48, 0xc9, + 0x12, 0x90, 0x75, 0xba, 0x5a, 0xd7, 0xbb, 0xde, 0x1a, 0xab, 0x8b, 0x87, 0xb7, 0x17, 0x89, 0x3c, + 0xf1, 0xd5, 0x43, 0x12, 0x2b, 0x3f, 0x06, 0x59, 0xa7, 0xab, 0xe5, 0x08, 0x92, 0xdc, 0x87, 0x73, + 0xc9, 0x22, 0xec, 0x93, 0xf9, 0xe5, 0xc0, 0xb3, 0x5b, 0x9b, 0x13, 0x13, 0xa9, 0x04, 0x12, 0xdb, + 0x33, 0x09, 0xb6, 0x55, 0xe3, 0x76, 0x71, 0x70, 0x60, 0x7c, 0x50, 0x1b, 0x63, 0x65, 0x7d, 0x13, + 0xd2, 0x34, 0xd4, 0xdf, 0xcd, 0x31, 0x53, 0x91, 0x7d, 0x10, 0x66, 0x32, 0x67, 0xba, 0xde, 0xde, + 0xa5, 0xae, 0xb7, 0xc3, 0x9c, 0xa3, 0x25, 0xb7, 0xc7, 0xec, 0xaa, 0x09, 0x2c, 0x99, 0x84, 0x92, + 0x21, 0x9f, 0x9a, 0x9d, 0x8f, 0x76, 0x82, 0x5f, 0x8f, 0x26, 0xa8, 0xc8, 0x55, 0x28, 0xb2, 0x25, + 0x2b, 0xbe, 0x65, 0x96, 0xad, 0x0b, 0x0d, 0x29, 0xd4, 0x1f, 0xc9, 0xc3, 0x88, 0xf4, 0x35, 0x37, + 0xf6, 0xf5, 0x39, 0xaf, 0xef, 0xac, 0x99, 0xbe, 0xd3, 0x0b, 0xee, 0xa5, 0xfc, 0x26, 0xdf, 0x0c, + 0x44, 0xb1, 0xa3, 0x0b, 0x29, 0x21, 0x98, 0x57, 0xc4, 0x87, 0x96, 0x76, 0xbe, 0x7d, 0x64, 0xf4, + 0xb7, 0x8b, 0x83, 0xf9, 0xf1, 0xc2, 0xed, 0xe2, 0x60, 0x71, 0xbc, 0x1f, 0xe3, 0x70, 0x61, 0xe8, + 0x6b, 0xbe, 0x37, 0xb7, 0x1e, 0x98, 0xcd, 0x23, 0xfe, 0x76, 0xe4, 0x60, 0x63, 0x94, 0xc5, 0x64, + 0x73, 0xc4, 0x1f, 0x92, 0x7c, 0xa0, 0xb2, 0x39, 0xc9, 0x51, 0x2a, 0x64, 0xf3, 0x4f, 0x73, 0xa0, + 0xa4, 0xca, 0xa6, 0x7c, 0x48, 0x7e, 0x10, 0x07, 0x97, 0xa9, 0xf4, 0x0f, 0xf3, 0x70, 0xba, 0x6a, + 0x79, 0xb4, 0xc9, 0x77, 0x8c, 0x47, 0x7c, 0xaa, 0xb8, 0x03, 0xc3, 0xd2, 0xc7, 0x88, 0x3e, 0x7f, + 0x22, 0xd8, 0x8f, 0x87, 0xa8, 0x0c, 0x4e, 0x72, 0xe9, 0x83, 0x7b, 0x89, 0x13, 0x17, 0xf2, 0x11, + 0x9f, 0x73, 0x8e, 0x86, 0x90, 0x8f, 0xf8, 0xe4, 0xf5, 0x21, 0x15, 0xf2, 0xff, 0x91, 0x83, 0x33, + 0x29, 0x95, 0x93, 0x2b, 0x30, 0x50, 0xeb, 0xae, 0x62, 0xd8, 0xad, 0x5c, 0xe8, 0x31, 0xec, 0x76, + 0x57, 0x31, 0xe2, 0x96, 0xe6, 0x23, 0xc9, 0x0a, 0x3e, 0xae, 0x5f, 0xaa, 0x56, 0xa6, 0x85, 0x54, + 0x55, 0x29, 0x4c, 0x00, 0x03, 0xa7, 0x7d, 0x59, 0xf0, 0x00, 0xdf, 0x36, 0x8d, 0x46, 0xec, 0x01, + 0x3e, 0x2b, 0x43, 0x7e, 0x10, 0x86, 0xca, 0xef, 0x77, 0x1d, 0x8a, 0x7c, 0xb9, 0xc4, 0x3f, 0x16, + 0xf0, 0xf5, 0x11, 0x69, 0x9c, 0x79, 0x2c, 0x01, 0x46, 0x11, 0xe7, 0x1d, 0x32, 0x54, 0x7f, 0x2a, + 0x07, 0x97, 0xb2, 0x5b, 0x47, 0x3e, 0x05, 0x03, 0x6c, 0x67, 0x5e, 0xd6, 0x16, 0xc5, 0xa7, 0xf3, + 0xac, 0xbe, 0x76, 0x8b, 0xd6, 0x75, 0x47, 0x36, 0xf6, 0x7d, 0x32, 0xf2, 0x16, 0x0c, 0x57, 0x5d, + 0xb7, 0x4b, 0x9d, 0xda, 0x4b, 0x77, 0xb5, 0xaa, 0xd8, 0x13, 0xe2, 0x9e, 0xc3, 0x44, 0x70, 0xdd, + 0x7d, 0x29, 0x16, 0x58, 0x4b, 0xa6, 0x57, 0x7f, 0x3c, 0x07, 0x97, 0x7b, 0x7d, 0x15, 0x79, 0x09, + 0x06, 0x57, 0xa8, 0xa5, 0x5b, 0x5e, 0xb5, 0x22, 0x9a, 0x84, 0x5b, 0x2c, 0x0f, 0x61, 0xd1, 0x9d, + 0x42, 0x40, 0xc8, 0x0a, 0xf1, 0x73, 0xc5, 0xc0, 0x91, 0x81, 0x9f, 0x81, 0x22, 0x2c, 0x56, 0xc8, + 0x27, 0x54, 0x7f, 0x2f, 0x0f, 0x23, 0xcb, 0xad, 0x6e, 0xd3, 0x94, 0x16, 0x8e, 0x3d, 0xdb, 0xdb, + 0xbe, 0xf5, 0x9b, 0xdf, 0x9d, 0xf5, 0xcb, 0x86, 0x9b, 0xb3, 0xc7, 0xe1, 0xe6, 0x97, 0x23, 0x6f, + 0x42, 0xa9, 0x83, 0xdf, 0x11, 0x3f, 0x89, 0xe5, 0x5f, 0x97, 0x75, 0x12, 0xcb, 0xcb, 0xb0, 0xf1, + 0xd5, 0xd8, 0xc7, 0xf8, 0x0a, 0xcb, 0x4a, 0x02, 0x0d, 0x17, 0x89, 0x13, 0x81, 0x1e, 0x88, 0x40, + 0xc3, 0x05, 0xe1, 0x44, 0xa0, 0xfb, 0x10, 0xe8, 0xaf, 0xe6, 0x61, 0x2c, 0x5a, 0x25, 0xf9, 0x14, + 0x0c, 0xf3, 0x6a, 0xf8, 0xb9, 0x50, 0x4e, 0x72, 0x2a, 0x0e, 0xc1, 0x1a, 0xf0, 0x1f, 0xe2, 0x80, + 0xeb, 0xd4, 0x9a, 0xee, 0xd6, 0xc3, 0x13, 0x1a, 0x7e, 0x7f, 0x3b, 0xc8, 0x3d, 0xa1, 0x62, 0x28, + 0x6d, 0x6c, 0x4d, 0x77, 0xa7, 0xc3, 0xdf, 0x64, 0x06, 0x88, 0x43, 0xbb, 0x2e, 0x8d, 0x32, 0x28, + 0x22, 0x03, 0x91, 0x52, 0x3d, 0x8e, 0xd5, 0x4e, 0x73, 0x98, 0xcc, 0xe6, 0x0b, 0x41, 0xb3, 0x51, + 0x19, 0xfa, 0x77, 0x90, 0xef, 0x5d, 0xa2, 0x4f, 0x3f, 0xe6, 0xe4, 0x04, 0x15, 0xdd, 0xd3, 0xf9, + 0xa6, 0xdc, 0xef, 0x00, 0xf5, 0xa7, 0x1d, 0xe8, 0x5f, 0xb2, 0xe8, 0xd2, 0x03, 0xf2, 0x22, 0x0c, + 0x31, 0x85, 0x99, 0xb7, 0x59, 0x5f, 0xe6, 0x84, 0xff, 0x84, 0xa4, 0x49, 0x88, 0x98, 0xeb, 0xd3, + 0x42, 0x2a, 0x72, 0x13, 0x20, 0x7c, 0x62, 0x26, 0xb4, 0x8f, 0xc8, 0x65, 0x38, 0x66, 0xae, 0x4f, + 0x93, 0xe8, 0xfc, 0x52, 0xe2, 0x81, 0x4e, 0x21, 0x59, 0x8a, 0x63, 0xfc, 0x52, 0x62, 0x7c, 0xcc, + 0x03, 0x61, 0xbf, 0x96, 0x75, 0xd7, 0x5d, 0xb7, 0x1d, 0x63, 0x7a, 0x4d, 0xb7, 0x9a, 0x34, 0xbe, + 0x7b, 0x4a, 0x52, 0xcc, 0xf5, 0x69, 0x29, 0xe5, 0xc8, 0xeb, 0x30, 0x22, 0x3b, 0x94, 0xc6, 0x9d, + 0x3e, 0x64, 0xdc, 0x5c, 0x9f, 0x16, 0xa1, 0x25, 0xaf, 0xc2, 0xb0, 0xf8, 0x7d, 0xdb, 0x16, 0x37, + 0xca, 0x52, 0x2c, 0x22, 0x09, 0x35, 0xd7, 0xa7, 0xc9, 0x94, 0x52, 0xa5, 0xcb, 0x8e, 0x69, 0x79, + 0xe2, 0x8d, 0x72, 0xbc, 0x52, 0xc4, 0x49, 0x95, 0xe2, 0x6f, 0xf2, 0x16, 0x8c, 0x06, 0x41, 0x9e, + 0xde, 0xa3, 0x0d, 0x4f, 0x1c, 0x7e, 0x9f, 0x8b, 0x15, 0xe6, 0xc8, 0xb9, 0x3e, 0x2d, 0x4a, 0x4d, + 0xae, 0x42, 0x49, 0xa3, 0xae, 0xf9, 0xbe, 0x7f, 0x5d, 0x3c, 0x26, 0x8d, 0x73, 0xf3, 0x7d, 0x26, + 0x25, 0x81, 0x67, 0xbd, 0x13, 0xde, 0x4f, 0x8b, 0xa3, 0x6a, 0x12, 0xab, 0x65, 0xc6, 0x32, 0x58, + 0xef, 0x48, 0xce, 0x09, 0x9f, 0x0d, 0x43, 0x5f, 0x89, 0xa4, 0xad, 0xc3, 0xf1, 0x18, 0x03, 0x32, + 0x76, 0xae, 0x4f, 0x8b, 0xd1, 0x4b, 0x52, 0xad, 0x98, 0xee, 0x43, 0x11, 0x6d, 0x34, 0x2e, 0x55, + 0x86, 0x92, 0xa4, 0xca, 0x7e, 0x4a, 0x55, 0x2f, 0x52, 0x6f, 0xdd, 0x76, 0x1e, 0x8a, 0xd8, 0xa2, + 0xf1, 0xaa, 0x05, 0x56, 0xaa, 0x5a, 0x40, 0xe4, 0xaa, 0xd9, 0x80, 0x1b, 0x4b, 0xaf, 0x5a, 0xf7, + 0x74, 0xb9, 0x6a, 0x7e, 0x12, 0xe7, 0x77, 0xd2, 0x3c, 0xd5, 0x1f, 0xf1, 0x6c, 0xff, 0xc9, 0x0e, + 0x45, 0x9c, 0xd4, 0xa1, 0xf8, 0x9b, 0x55, 0x2a, 0x65, 0x74, 0x17, 0xe9, 0xfc, 0x83, 0x4a, 0x25, + 0x14, 0xab, 0x54, 0xce, 0xfd, 0x7e, 0x53, 0x4e, 0x1b, 0xae, 0x9c, 0x8e, 0x76, 0x50, 0x88, 0x61, + 0x1d, 0x24, 0xa5, 0x17, 0x9f, 0xc0, 0x94, 0xc4, 0x0a, 0x41, 0xf2, 0xe1, 0xa0, 0x85, 0xd3, 0xcb, + 0x73, 0x7d, 0x1a, 0x26, 0x2b, 0x56, 0x79, 0xb2, 0x6b, 0xe5, 0x0c, 0x52, 0x8c, 0xf8, 0x14, 0x0c, + 0x36, 0xd7, 0xa7, 0xf1, 0x44, 0xd8, 0x2f, 0x4a, 0x09, 0x01, 0x95, 0xb3, 0xd1, 0x29, 0x22, 0x40, + 0xb0, 0x29, 0x22, 0x4c, 0x1b, 0x38, 0x9b, 0x4c, 0x7b, 0xa7, 0x9c, 0x8b, 0x2e, 0x35, 0x71, 0xfc, + 0x5c, 0x9f, 0x96, 0x4c, 0x95, 0xf7, 0x6a, 0x24, 0x13, 0x9c, 0x72, 0x3e, 0x16, 0x00, 0x2c, 0x44, + 0x31, 0x71, 0xc9, 0x39, 0xe3, 0x96, 0x62, 0xb9, 0xfe, 0xc5, 0x64, 0x75, 0x21, 0xba, 0x71, 0x49, + 0x21, 0x99, 0xeb, 0xd3, 0xd2, 0x4a, 0x92, 0xe9, 0x44, 0x3e, 0x36, 0x45, 0x89, 0xfa, 0xc6, 0xc4, + 0xd0, 0x73, 0x7d, 0x5a, 0x22, 0x83, 0xdb, 0x4d, 0x39, 0x11, 0x9a, 0x72, 0x31, 0xda, 0x89, 0x21, + 0x86, 0x75, 0xa2, 0x94, 0x30, 0xed, 0xa6, 0x9c, 0x1c, 0x4b, 0xb9, 0x94, 0x2c, 0x15, 0xce, 0x9c, + 0x52, 0x12, 0x2d, 0x2d, 0x3d, 0xdf, 0x8f, 0xf2, 0x84, 0xc8, 0xfa, 0x2b, 0xca, 0xa7, 0xd1, 0xcc, + 0xf5, 0x69, 0xe9, 0xb9, 0x82, 0xb4, 0xf4, 0x44, 0x39, 0xca, 0xe5, 0x5e, 0x3c, 0x83, 0xd6, 0xa5, + 0x27, 0xd9, 0xd1, 0x7b, 0xa4, 0x2d, 0x51, 0x9e, 0x8c, 0x46, 0x1f, 0xce, 0x24, 0x9c, 0xeb, 0xd3, + 0x7a, 0x24, 0x3f, 0xb9, 0x9b, 0x91, 0x43, 0x44, 0x79, 0x2a, 0x9a, 0xf4, 0x3b, 0x95, 0x68, 0xae, + 0x4f, 0xcb, 0xc8, 0x40, 0x72, 0x37, 0x23, 0xc5, 0x84, 0x32, 0xd1, 0x93, 0x6d, 0x20, 0x8f, 0x8c, + 0x04, 0x15, 0x4b, 0xa9, 0xd9, 0x19, 0x94, 0xa7, 0xa3, 0xaa, 0x9b, 0x42, 0xc2, 0x54, 0x37, 0x2d, + 0xaf, 0xc3, 0x52, 0x6a, 0x3a, 0x01, 0xe5, 0x99, 0x1e, 0x0c, 0x83, 0x36, 0xa6, 0x26, 0x22, 0x58, + 0x4a, 0x8d, 0xe7, 0xaf, 0xa8, 0x51, 0x86, 0x29, 0x24, 0x8c, 0x61, 0x5a, 0x26, 0x80, 0xa5, 0xd4, + 0xb0, 0xef, 0xca, 0xb3, 0x3d, 0x18, 0x86, 0x2d, 0x4c, 0x0b, 0x18, 0xff, 0x6a, 0x24, 0xee, 0xba, + 0xf2, 0xb1, 0xe8, 0xbc, 0x21, 0xa1, 0xd8, 0xbc, 0x21, 0x47, 0x68, 0x9f, 0x4e, 0x44, 0x96, 0x55, + 0x3e, 0x1e, 0x1d, 0xe6, 0x31, 0x34, 0x1b, 0xe6, 0xf1, 0x58, 0xb4, 0xd3, 0x89, 0x08, 0x9b, 0xca, + 0x95, 0x2c, 0x26, 0x88, 0x8e, 0x32, 0xe1, 0x31, 0x39, 0xab, 0x29, 0x21, 0x1e, 0x95, 0x4f, 0x44, + 0xfd, 0xba, 0x13, 0x04, 0x73, 0x7d, 0x5a, 0x4a, 0x60, 0x48, 0x2d, 0x3d, 0x9e, 0x91, 0x72, 0x35, + 0x3a, 0x6c, 0xd3, 0x68, 0xd8, 0xb0, 0x4d, 0x8d, 0x85, 0x34, 0x9f, 0xf6, 0xf8, 0x44, 0xb9, 0x16, + 0x35, 0xcc, 0x92, 0x14, 0xcc, 0x30, 0x4b, 0x79, 0xb4, 0xa2, 0xa5, 0xc7, 0xd8, 0x51, 0x9e, 0xeb, + 0xd9, 0x42, 0xa4, 0x49, 0x69, 0x21, 0x0f, 0x39, 0x13, 0xda, 0x4e, 0x77, 0x3b, 0x2d, 0x5b, 0x37, + 0x94, 0x4f, 0xa6, 0xda, 0x4e, 0x1c, 0x29, 0xd9, 0x4e, 0x1c, 0xc0, 0x56, 0x79, 0xf9, 0x8d, 0x83, + 0xf2, 0x7c, 0x74, 0x95, 0x97, 0x71, 0x6c, 0x95, 0x8f, 0xbc, 0x87, 0x98, 0x4e, 0xbc, 0x07, 0x50, + 0x5e, 0x88, 0x2a, 0x40, 0x0c, 0xcd, 0x14, 0x20, 0xfe, 0x82, 0xe0, 0x8b, 0xd9, 0x1e, 0xf4, 0xca, + 0x24, 0x72, 0x7b, 0xda, 0xe7, 0x96, 0x45, 0x37, 0xd7, 0xa7, 0x65, 0x7b, 0xe1, 0x57, 0x53, 0x1c, + 0xe2, 0x95, 0xeb, 0x51, 0x05, 0x4b, 0x10, 0x30, 0x05, 0x4b, 0xba, 0xd1, 0x57, 0x53, 0x3c, 0xda, + 0x95, 0x4f, 0x65, 0xb2, 0x0a, 0xbe, 0x39, 0xc5, 0x0f, 0xfe, 0xa6, 0xec, 0x92, 0xae, 0xbc, 0x18, + 0x5d, 0xec, 0x42, 0x0c, 0x5b, 0xec, 0x24, 0xd7, 0xf5, 0x9b, 0xb2, 0x33, 0xb6, 0x72, 0x23, 0x59, + 0x2a, 0x5c, 0x22, 0x25, 0xa7, 0x6d, 0x2d, 0xdd, 0x87, 0x59, 0x79, 0x29, 0xaa, 0x75, 0x69, 0x34, + 0x4c, 0xeb, 0x52, 0xfd, 0x9f, 0x67, 0x93, 0xae, 0xc8, 0xca, 0xcd, 0xf8, 0x26, 0x3b, 0x8a, 0x67, + 0x96, 0x4f, 0xc2, 0x7d, 0xf9, 0xb3, 0xf1, 0x60, 0x7b, 0xca, 0xcb, 0xb1, 0x6b, 0xdf, 0x08, 0x96, + 0xd9, 0xb7, 0xb1, 0xe0, 0x7c, 0x9f, 0x8d, 0xc7, 0xa7, 0x53, 0x5e, 0x49, 0xe7, 0x10, 0xe8, 0x4a, + 0x3c, 0x9e, 0xdd, 0x67, 0xe3, 0x21, 0xdd, 0x94, 0x57, 0xd3, 0x39, 0x04, 0xd2, 0x8d, 0x87, 0x80, + 0x7b, 0x51, 0x0a, 0x32, 0xaf, 0x7c, 0x3a, 0x6a, 0x3a, 0x06, 0x08, 0x66, 0x3a, 0x86, 0xa1, 0xe8, + 0x5f, 0x94, 0x82, 0xb3, 0x2b, 0xaf, 0x25, 0x8a, 0x04, 0x8d, 0x95, 0x42, 0xb8, 0xbf, 0x28, 0x05, + 0x35, 0x57, 0x5e, 0x4f, 0x14, 0x09, 0x5a, 0x27, 0x85, 0x3e, 0x37, 0x7a, 0xbd, 0x5f, 0x55, 0xde, + 0x88, 0x1e, 0x06, 0x67, 0x53, 0xce, 0xf5, 0x69, 0xbd, 0xde, 0xc1, 0x7e, 0x31, 0xdb, 0xb1, 0x5b, + 0x79, 0x33, 0x3a, 0x84, 0xb3, 0xe8, 0xd8, 0x10, 0xce, 0x74, 0x0e, 0x7f, 0x2b, 0x16, 0xcb, 0x42, + 0x79, 0x2b, 0x3a, 0xc5, 0x45, 0x90, 0x6c, 0x8a, 0x8b, 0x47, 0xbe, 0x88, 0x04, 0x69, 0x50, 0x3e, + 0x13, 0x9d, 0xe2, 0x64, 0x1c, 0x9b, 0xe2, 0x22, 0x01, 0x1d, 0xa6, 0x13, 0xb1, 0x03, 0x94, 0xb7, + 0xa3, 0x53, 0x5c, 0x0c, 0xcd, 0xa6, 0xb8, 0x78, 0xb4, 0x81, 0xb7, 0x62, 0x4f, 0xe8, 0x95, 0xcf, + 0xa6, 0xb7, 0x1f, 0x91, 0x72, 0xfb, 0xf9, 0x83, 0x7b, 0x2d, 0xfd, 0x2d, 0xb8, 0x52, 0x8e, 0x8e, + 0xdf, 0x34, 0x1a, 0x36, 0x7e, 0x53, 0xdf, 0x91, 0xc7, 0x37, 0x0e, 0x42, 0xab, 0xa6, 0x7a, 0x6c, + 0x1c, 0x42, 0x53, 0x24, 0x05, 0x1c, 0xd9, 0x23, 0xf3, 0x8d, 0xd0, 0x74, 0xc6, 0x1e, 0xd9, 0xdf, + 0x06, 0xc5, 0xe8, 0xd9, 0xec, 0x9a, 0xf0, 0x33, 0x56, 0x2a, 0xd1, 0xd9, 0x35, 0x41, 0xc0, 0x66, + 0xd7, 0xa4, 0x77, 0xf2, 0x2c, 0x8c, 0x0b, 0x2d, 0xe2, 0xee, 0xd3, 0xa6, 0xd5, 0x54, 0x66, 0x62, + 0xef, 0x2d, 0x63, 0x78, 0x36, 0x3b, 0xc5, 0x61, 0xb8, 0x5e, 0x73, 0xd8, 0x74, 0xcb, 0xec, 0xac, + 0xda, 0xba, 0x63, 0xd4, 0xa8, 0x65, 0x28, 0xb3, 0xb1, 0xf5, 0x3a, 0x85, 0x06, 0xd7, 0xeb, 0x14, + 0x38, 0x86, 0x88, 0x8b, 0xc1, 0x35, 0xda, 0xa0, 0xe6, 0x23, 0xaa, 0xdc, 0x42, 0xb6, 0x13, 0x59, + 0x6c, 0x05, 0xd9, 0x5c, 0x9f, 0x96, 0xc5, 0x81, 0xd9, 0xea, 0x0b, 0x1b, 0xb5, 0x77, 0xe6, 0x83, + 0xf0, 0x03, 0xcb, 0x0e, 0xed, 0xe8, 0x0e, 0x55, 0xe6, 0xa2, 0xb6, 0x7a, 0x2a, 0x11, 0xb3, 0xd5, + 0x53, 0x11, 0x49, 0xb6, 0xfe, 0x58, 0xa8, 0xf6, 0x62, 0x1b, 0x8e, 0x88, 0xf4, 0xd2, 0x6c, 0x76, + 0x8a, 0x22, 0x98, 0x80, 0xe6, 0x6d, 0xab, 0x89, 0x27, 0x15, 0xb7, 0xa3, 0xb3, 0x53, 0x36, 0x25, + 0x9b, 0x9d, 0xb2, 0xb1, 0x4c, 0xd5, 0xa3, 0x58, 0x3e, 0x06, 0xef, 0x44, 0x55, 0x3d, 0x85, 0x84, + 0xa9, 0x7a, 0x0a, 0x38, 0xc9, 0x50, 0xa3, 0x2e, 0xf5, 0x94, 0xf9, 0x5e, 0x0c, 0x91, 0x24, 0xc9, + 0x10, 0xc1, 0x49, 0x86, 0xb3, 0xd4, 0x6b, 0xac, 0x29, 0x0b, 0xbd, 0x18, 0x22, 0x49, 0x92, 0x21, + 0x82, 0xd9, 0x66, 0x33, 0x0a, 0x9e, 0xea, 0xb6, 0x1e, 0xfa, 0x7d, 0xb6, 0x18, 0xdd, 0x6c, 0x66, + 0x12, 0xb2, 0xcd, 0x66, 0x26, 0x92, 0xfc, 0xf8, 0x8e, 0xfd, 0xe0, 0x95, 0x25, 0xac, 0x70, 0x32, + 0xb4, 0x0b, 0x76, 0x52, 0x6a, 0xae, 0x4f, 0xdb, 0xa9, 0x9f, 0xfd, 0x27, 0x03, 0xa7, 0x51, 0x65, + 0x19, 0xab, 0x3a, 0x15, 0x9c, 0x55, 0x70, 0xf0, 0x5c, 0x9f, 0x16, 0xb8, 0x95, 0xbe, 0x0a, 0xc3, + 0xf8, 0x51, 0x55, 0xcb, 0xf4, 0x2a, 0x53, 0xca, 0x3b, 0xd1, 0x2d, 0x93, 0x84, 0x62, 0x5b, 0x26, + 0xe9, 0x27, 0x9b, 0xc4, 0xf1, 0x27, 0x9f, 0x62, 0x2a, 0x53, 0x8a, 0x16, 0x9d, 0xc4, 0x23, 0x48, + 0x36, 0x89, 0x47, 0x00, 0x41, 0xbd, 0x15, 0xc7, 0xee, 0x54, 0xa6, 0x94, 0x5a, 0x4a, 0xbd, 0x1c, + 0x15, 0xd4, 0xcb, 0x7f, 0x06, 0xf5, 0xd6, 0xd6, 0xba, 0x5e, 0x85, 0x7d, 0xe3, 0x4a, 0x4a, 0xbd, + 0x3e, 0x32, 0xa8, 0xd7, 0x07, 0xb0, 0xa9, 0x10, 0x01, 0xcb, 0x8e, 0xcd, 0x26, 0xed, 0x3b, 0x66, + 0xab, 0xa5, 0xdc, 0x8d, 0x4e, 0x85, 0x71, 0x3c, 0x9b, 0x0a, 0xe3, 0x30, 0x66, 0x7a, 0xf2, 0x56, + 0xd1, 0xd5, 0x6e, 0x53, 0xb9, 0x17, 0x35, 0x3d, 0x43, 0x0c, 0x33, 0x3d, 0xc3, 0x5f, 0xb8, 0xbb, + 0x60, 0xbf, 0x34, 0xfa, 0xc0, 0xa1, 0xee, 0x9a, 0x72, 0x3f, 0xb6, 0xbb, 0x90, 0x70, 0xb8, 0xbb, + 0x90, 0x7e, 0x93, 0x26, 0x3c, 0x11, 0x59, 0x68, 0xfc, 0x4b, 0x9b, 0x1a, 0xd5, 0x9d, 0xc6, 0x9a, + 0xf2, 0x39, 0x64, 0xf5, 0x6c, 0xea, 0x52, 0x15, 0x25, 0x9d, 0xeb, 0xd3, 0x7a, 0x71, 0xc2, 0x6d, + 0xf9, 0x3b, 0xf3, 0x3c, 0x12, 0xac, 0xb6, 0x3c, 0xed, 0x6f, 0x42, 0xdf, 0x8d, 0x6d, 0xcb, 0x93, + 0x24, 0xb8, 0x2d, 0x4f, 0x82, 0x49, 0x07, 0x9e, 0x8a, 0x6d, 0xd5, 0x16, 0xf4, 0x16, 0xdb, 0x97, + 0x50, 0x63, 0x59, 0x6f, 0x3c, 0xa4, 0x9e, 0xf2, 0x79, 0xe4, 0x7d, 0x25, 0x63, 0xc3, 0x17, 0xa3, + 0x9e, 0xeb, 0xd3, 0xb6, 0xe1, 0x47, 0x54, 0x28, 0xd6, 0x66, 0x57, 0x96, 0x95, 0x1f, 0x88, 0x9e, + 0x6f, 0x32, 0xd8, 0x5c, 0x9f, 0x86, 0x38, 0x66, 0xa5, 0xdd, 0xed, 0x34, 0x1d, 0xdd, 0xa0, 0xdc, + 0xd0, 0x42, 0xdb, 0x4d, 0x18, 0xa0, 0x3f, 0x18, 0xb5, 0xd2, 0xb2, 0xe8, 0x98, 0x95, 0x96, 0x85, + 0x63, 0x8a, 0x1a, 0x49, 0x7a, 0xa2, 0x7c, 0x21, 0xaa, 0xa8, 0x11, 0x24, 0x53, 0xd4, 0x68, 0x8a, + 0x94, 0xcf, 0xc1, 0xf9, 0x60, 0x3f, 0x2f, 0xd6, 0x5f, 0xde, 0x69, 0xca, 0x17, 0x91, 0xcf, 0x53, + 0x89, 0xcb, 0x80, 0x08, 0xd5, 0x5c, 0x9f, 0x96, 0x51, 0x9e, 0xad, 0xb8, 0x89, 0x7c, 0x5e, 0xc2, + 0xbc, 0xf8, 0xa1, 0xe8, 0x8a, 0x9b, 0x41, 0xc6, 0x56, 0xdc, 0x0c, 0x54, 0x2a, 0x73, 0x21, 0x54, + 0x7d, 0x1b, 0xe6, 0x81, 0x4c, 0xb3, 0x38, 0xa4, 0x32, 0x17, 0x96, 0xda, 0xea, 0x36, 0xcc, 0x03, + 0x6b, 0x2d, 0x8b, 0x03, 0xb9, 0x0a, 0xa5, 0x5a, 0x6d, 0x41, 0xeb, 0x5a, 0x4a, 0x23, 0xe6, 0x2d, + 0x8b, 0xd0, 0xb9, 0x3e, 0x4d, 0xe0, 0x99, 0x19, 0x34, 0xd3, 0xd2, 0x5d, 0xcf, 0x6c, 0xb8, 0x38, + 0x62, 0xfc, 0x11, 0x62, 0x44, 0xcd, 0xa0, 0x34, 0x1a, 0x66, 0x06, 0xa5, 0xc1, 0x99, 0xbd, 0x38, + 0xad, 0xbb, 0xae, 0x6e, 0x19, 0x8e, 0x3e, 0x85, 0xcb, 0x04, 0x8d, 0xbd, 0xc6, 0x8a, 0x60, 0x99, + 0xbd, 0x18, 0x85, 0xe0, 0xe1, 0xbb, 0x0f, 0xf1, 0xcd, 0x9c, 0x07, 0xb1, 0xc3, 0xf7, 0x18, 0x1e, + 0x0f, 0xdf, 0x63, 0x30, 0xb4, 0x3b, 0x7d, 0x98, 0x46, 0x9b, 0x26, 0x13, 0x91, 0xd2, 0x8c, 0xd9, + 0x9d, 0x71, 0x02, 0xb4, 0x3b, 0xe3, 0xc0, 0x48, 0x93, 0xfc, 0xe5, 0x76, 0x2d, 0xa3, 0x49, 0xe1, + 0x2a, 0x9b, 0x28, 0xc3, 0xd6, 0xef, 0x70, 0x70, 0x54, 0x36, 0x2c, 0xbd, 0x6d, 0x57, 0xa6, 0x7c, + 0xa9, 0x9b, 0xd1, 0xf5, 0x3b, 0x93, 0x90, 0xad, 0xdf, 0x99, 0x48, 0x36, 0xbb, 0xfa, 0x1b, 0xad, + 0x35, 0xdd, 0xa1, 0x46, 0xc5, 0x74, 0xf0, 0x64, 0x71, 0x83, 0x6f, 0x0d, 0xdf, 0x8b, 0xce, 0xae, + 0x3d, 0x48, 0xd9, 0xec, 0xda, 0x03, 0xcd, 0x8c, 0xbc, 0x74, 0xb4, 0x46, 0x75, 0x43, 0x79, 0x18, + 0x35, 0xf2, 0xb2, 0x29, 0x99, 0x91, 0x97, 0x8d, 0xcd, 0xfe, 0x9c, 0xfb, 0x8e, 0xe9, 0x51, 0xa5, + 0xb5, 0x93, 0xcf, 0x41, 0xd2, 0xec, 0xcf, 0x41, 0x34, 0xdb, 0x10, 0xc6, 0x3b, 0xa4, 0x1d, 0xdd, + 0x10, 0x26, 0xbb, 0x21, 0x5e, 0x82, 0x59, 0x2c, 0xe2, 0x51, 0x9e, 0x62, 0x45, 0x2d, 0x16, 0x01, + 0x66, 0x16, 0x4b, 0xf8, 0x6c, 0x2f, 0xf2, 0x14, 0x4b, 0xb1, 0xa3, 0x6b, 0xa8, 0x8c, 0x63, 0x6b, + 0x68, 0xe4, 0xd9, 0xd6, 0xab, 0x91, 0x77, 0x06, 0x4a, 0x27, 0x6a, 0x75, 0x48, 0x28, 0x66, 0x75, + 0xc8, 0x2f, 0x12, 0xa6, 0xe1, 0x14, 0xde, 0x82, 0x6b, 0xdd, 0xe0, 0x1e, 0xe7, 0x87, 0xa3, 0x9f, + 0x19, 0x43, 0xb3, 0xcf, 0x8c, 0x81, 0x22, 0x4c, 0xc4, 0xb4, 0xe5, 0x64, 0x30, 0x09, 0xcf, 0x07, + 0x63, 0x20, 0x32, 0x0f, 0xa4, 0x56, 0x5e, 0x98, 0xaf, 0x1a, 0xcb, 0xf2, 0x15, 0x99, 0x1b, 0x3d, + 0x81, 0x4d, 0x52, 0xcc, 0xf5, 0x69, 0x29, 0xe5, 0xc8, 0x7b, 0x70, 0x59, 0x40, 0xc5, 0x8b, 0x6b, + 0x4c, 0xfb, 0x6f, 0x04, 0x0b, 0x82, 0x17, 0xf5, 0x63, 0xeb, 0x45, 0x3b, 0xd7, 0xa7, 0xf5, 0xe4, + 0x95, 0x5d, 0x97, 0x58, 0x1f, 0xba, 0x3b, 0xa9, 0x2b, 0x58, 0x24, 0x7a, 0xf2, 0xca, 0xae, 0x4b, + 0xc8, 0xfd, 0xd1, 0x4e, 0xea, 0x0a, 0x3a, 0xa1, 0x27, 0x2f, 0xe2, 0xc2, 0x44, 0x2f, 0x7c, 0xb9, + 0xd5, 0x52, 0xd6, 0xb1, 0xba, 0x4f, 0xec, 0xa4, 0xba, 0x32, 0x1a, 0x9c, 0xdb, 0x71, 0x64, 0xb3, + 0xf4, 0x52, 0x87, 0x5a, 0xb5, 0xc8, 0x02, 0xf4, 0x38, 0x3a, 0x4b, 0x27, 0x08, 0xd8, 0x2c, 0x9d, + 0x00, 0xb2, 0x01, 0x25, 0x3f, 0x57, 0x51, 0x36, 0xa2, 0x03, 0x4a, 0xc6, 0xb1, 0x01, 0x15, 0x79, + 0xda, 0xb2, 0x04, 0x67, 0x96, 0x1e, 0x7a, 0xba, 0x6f, 0x41, 0xba, 0xa2, 0x2b, 0xdf, 0x8f, 0x5d, + 0x32, 0x25, 0x49, 0xf0, 0x92, 0x29, 0x09, 0x66, 0x63, 0x84, 0x81, 0x6b, 0x1b, 0x56, 0x63, 0x56, + 0x37, 0x5b, 0x5d, 0x87, 0x2a, 0x7f, 0x2a, 0x3a, 0x46, 0x62, 0x68, 0x36, 0x46, 0x62, 0x20, 0xb6, + 0x40, 0x33, 0x50, 0xd9, 0x75, 0xcd, 0xa6, 0x25, 0xf6, 0x95, 0xdd, 0x96, 0xa7, 0xfc, 0x5b, 0xd1, + 0x05, 0x3a, 0x8d, 0x86, 0x2d, 0xd0, 0x69, 0x70, 0x3c, 0x75, 0x62, 0xbd, 0xc0, 0x16, 0x0f, 0xf9, + 0xae, 0xf2, 0xdf, 0x8e, 0x9d, 0x3a, 0xa5, 0xd0, 0xe0, 0xa9, 0x53, 0x0a, 0x9c, 0xad, 0x8f, 0xdc, + 0x26, 0x9b, 0x37, 0x83, 0xbb, 0xea, 0x7f, 0x27, 0xba, 0x3e, 0xc6, 0xf1, 0x6c, 0x7d, 0x8c, 0xc3, + 0xa2, 0x7c, 0x44, 0x17, 0xfc, 0xbb, 0x59, 0x7c, 0x02, 0xf9, 0x27, 0xca, 0x90, 0x5b, 0x32, 0x1f, + 0x31, 0x52, 0x7e, 0x24, 0x97, 0xc5, 0x28, 0x18, 0x1e, 0x89, 0x42, 0x51, 0x46, 0x1a, 0x7d, 0x64, + 0xd2, 0x75, 0xe5, 0x4b, 0x99, 0x8c, 0x38, 0x41, 0x94, 0x11, 0x87, 0x91, 0x77, 0xe1, 0x7c, 0x08, + 0x5b, 0xa0, 0xed, 0xd5, 0x60, 0x66, 0xfa, 0xd3, 0xb9, 0xa8, 0x19, 0x9c, 0x4e, 0xc6, 0xcc, 0xe0, + 0x74, 0x4c, 0x1a, 0x6b, 0x21, 0xba, 0x7f, 0x6f, 0x1b, 0xd6, 0x81, 0x04, 0x33, 0x18, 0xa4, 0xb1, + 0x16, 0xd2, 0xfc, 0xd1, 0x6d, 0x58, 0x07, 0x32, 0xcd, 0x60, 0x40, 0x7e, 0x22, 0x07, 0x57, 0xd2, + 0x51, 0xe5, 0x56, 0x6b, 0xd6, 0x76, 0x42, 0x9c, 0xf2, 0x67, 0x72, 0xd1, 0x83, 0x86, 0x9d, 0x15, + 0x9b, 0xeb, 0xd3, 0x76, 0x58, 0x01, 0xf9, 0x0c, 0x8c, 0x96, 0xbb, 0x86, 0xe9, 0xe1, 0xc5, 0x1b, + 0x33, 0x9c, 0x7f, 0x2c, 0x17, 0xdb, 0xe2, 0xc8, 0x58, 0xdc, 0xe2, 0xc8, 0x00, 0x72, 0x1b, 0x4e, + 0xd7, 0x68, 0xa3, 0xeb, 0x98, 0xde, 0x86, 0x46, 0x3b, 0xb6, 0xe3, 0x31, 0x1e, 0x7f, 0x36, 0x17, + 0x9d, 0xc4, 0x12, 0x14, 0x6c, 0x12, 0x4b, 0x00, 0xc9, 0xbd, 0xc4, 0xad, 0xbc, 0xe8, 0xcc, 0x1f, + 0xcf, 0xf5, 0xbc, 0x96, 0x0f, 0xfa, 0x32, 0xbd, 0x38, 0x59, 0x8e, 0xdd, 0xa2, 0x0b, 0xae, 0x3f, + 0x91, 0xeb, 0x71, 0x8d, 0x2e, 0xcd, 0x70, 0x49, 0x30, 0xe3, 0x98, 0x92, 0x01, 0x5e, 0xf9, 0x73, + 0xb9, 0x1e, 0xd7, 0xde, 0x21, 0xc7, 0xb4, 0xe4, 0xf1, 0x2f, 0x73, 0x4f, 0x11, 0xc1, 0xe8, 0x27, + 0x73, 0x49, 0x57, 0x91, 0xa0, 0xbc, 0x44, 0xc8, 0x8a, 0xdd, 0x75, 0x03, 0xa5, 0xff, 0x72, 0x2e, + 0xe9, 0x9b, 0x17, 0x16, 0x0b, 0x7f, 0x11, 0x0a, 0x97, 0x66, 0x1e, 0x7b, 0xd4, 0xb1, 0xf4, 0x16, + 0x76, 0x67, 0xcd, 0xb3, 0x1d, 0xbd, 0x49, 0x67, 0x2c, 0x7d, 0xb5, 0x45, 0x95, 0x9f, 0xca, 0x45, + 0x2d, 0xd8, 0x6c, 0x52, 0x66, 0xc1, 0x66, 0x63, 0xc9, 0x1a, 0x3c, 0x91, 0x86, 0xad, 0x98, 0x2e, + 0xd6, 0xf3, 0x95, 0x5c, 0xd4, 0x84, 0xed, 0x41, 0xcb, 0x4c, 0xd8, 0x1e, 0x68, 0x72, 0x03, 0x86, + 0xa6, 0x6c, 0x7f, 0xfa, 0xfd, 0xf3, 0x31, 0x67, 0xc8, 0x00, 0x33, 0xd7, 0xa7, 0x85, 0x64, 0xa2, + 0x8c, 0x18, 0xd4, 0x5f, 0x4d, 0x96, 0x09, 0x2f, 0x9f, 0x82, 0x1f, 0xa2, 0x8c, 0x10, 0xf7, 0xbf, + 0x9f, 0x2c, 0x13, 0xde, 0x71, 0x05, 0x3f, 0xd8, 0x4c, 0xc2, 0x6b, 0x5c, 0x98, 0x2d, 0x33, 0xbb, + 0x6d, 0x7a, 0x4d, 0x6f, 0xb5, 0xa8, 0xd5, 0xa4, 0xca, 0xd7, 0x62, 0x33, 0x49, 0x3a, 0x19, 0x9b, + 0x49, 0xd2, 0x31, 0xe4, 0x07, 0xe1, 0xc2, 0x3d, 0xbd, 0x65, 0x1a, 0x21, 0xce, 0xcf, 0x07, 0xae, + 0xfc, 0x74, 0x2e, 0xba, 0x9b, 0xce, 0xa0, 0x63, 0xbb, 0xe9, 0x0c, 0x14, 0x59, 0x00, 0x82, 0xcb, + 0x68, 0x30, 0x5b, 0xb0, 0xf5, 0x59, 0xf9, 0x0f, 0x72, 0x51, 0x3b, 0x35, 0x49, 0xc2, 0xec, 0xd4, + 0x24, 0x94, 0xd4, 0xb3, 0x53, 0x83, 0x28, 0x3f, 0x93, 0x8b, 0x9e, 0xd6, 0x64, 0x11, 0xce, 0xf5, + 0x69, 0xd9, 0xf9, 0x45, 0x6e, 0xc1, 0x78, 0x6d, 0xb9, 0x3a, 0x3b, 0x3b, 0x53, 0xbb, 0x57, 0xad, + 0xe0, 0x43, 0x07, 0x43, 0xf9, 0x0b, 0xb1, 0x15, 0x2b, 0x4e, 0xc0, 0x56, 0xac, 0x38, 0x8c, 0xbc, + 0x01, 0x23, 0xac, 0xfd, 0x6c, 0xc0, 0xe0, 0x27, 0x7f, 0x3d, 0x17, 0x35, 0xa7, 0x64, 0x24, 0x33, + 0xa7, 0xe4, 0xdf, 0xa4, 0x06, 0x67, 0x99, 0x14, 0x97, 0x1d, 0xfa, 0x80, 0x3a, 0xd4, 0x6a, 0xf8, + 0x63, 0xfa, 0x67, 0x73, 0x51, 0x2b, 0x23, 0x8d, 0x88, 0x59, 0x19, 0x69, 0x70, 0xf2, 0x10, 0x2e, + 0xc7, 0x4f, 0x82, 0xe4, 0x67, 0xa7, 0xca, 0x5f, 0xcc, 0xc5, 0x8c, 0xe1, 0x1e, 0xc4, 0x68, 0x0c, + 0xf7, 0xc0, 0x13, 0x0b, 0x9e, 0x14, 0xc7, 0x2a, 0xc2, 0xe1, 0x32, 0x5e, 0xdb, 0xcf, 0xf1, 0xda, + 0x3e, 0x1e, 0x3a, 0x04, 0xf6, 0xa0, 0x9e, 0xeb, 0xd3, 0x7a, 0xb3, 0x63, 0x7a, 0x96, 0x4c, 0x80, + 0xa1, 0xfc, 0xa5, 0x5c, 0xba, 0x47, 0x4a, 0xc4, 0x4d, 0x39, 0x2d, 0x73, 0xc6, 0xbb, 0x59, 0xe9, + 0x1b, 0x94, 0xbf, 0x1c, 0x1b, 0x6f, 0xe9, 0x64, 0x6c, 0xbc, 0x65, 0xe4, 0x7f, 0xb8, 0x0d, 0xa7, + 0xb9, 0x52, 0x2f, 0xeb, 0x38, 0x0c, 0xad, 0x26, 0x35, 0x94, 0xff, 0x30, 0xb6, 0xda, 0x25, 0x28, + 0xd0, 0xb5, 0x27, 0x0e, 0x64, 0x53, 0x77, 0xad, 0xa3, 0x5b, 0x16, 0x1e, 0xb3, 0x2a, 0xff, 0x51, + 0x6c, 0xea, 0x0e, 0x51, 0xe8, 0xb8, 0x1b, 0xfc, 0x62, 0x9a, 0xd0, 0x2b, 0xf5, 0x91, 0xf2, 0x1f, + 0xc7, 0x34, 0xa1, 0x17, 0x31, 0xd3, 0x84, 0x9e, 0x79, 0x94, 0xee, 0x65, 0x3c, 0x01, 0x57, 0xbe, + 0x11, 0x5b, 0x91, 0x53, 0xa9, 0xd8, 0x8a, 0x9c, 0xfe, 0x82, 0xfc, 0x5e, 0xc6, 0xf3, 0x69, 0xe5, + 0xe7, 0x7b, 0xf3, 0x0d, 0x57, 0xfa, 0xf4, 0xd7, 0xd7, 0xf7, 0x32, 0x9e, 0x1e, 0x2b, 0x7f, 0xa5, + 0x37, 0xdf, 0xd0, 0xb1, 0x2f, 0xfd, 0xe5, 0x72, 0x3d, 0xfb, 0xd9, 0xae, 0xf2, 0x57, 0xe3, 0x53, + 0x57, 0x06, 0x21, 0x4e, 0x5d, 0x59, 0x6f, 0x7f, 0x57, 0xe1, 0x22, 0xd7, 0x90, 0x5b, 0x8e, 0xde, + 0x59, 0xab, 0x51, 0xcf, 0x33, 0xad, 0xa6, 0xbf, 0x13, 0xfb, 0x6b, 0xb9, 0xd8, 0xf1, 0x58, 0x16, + 0x25, 0x1e, 0x8f, 0x65, 0x21, 0x99, 0xf2, 0x26, 0x1e, 0xe8, 0x2a, 0x7f, 0x3d, 0xa6, 0xbc, 0x09, + 0x0a, 0xa6, 0xbc, 0xc9, 0x77, 0xbd, 0xb7, 0x53, 0xde, 0xa1, 0x2a, 0xff, 0x49, 0x36, 0xaf, 0xa0, + 0x7d, 0x29, 0xcf, 0x57, 0x6f, 0xa7, 0x3c, 0xb7, 0x54, 0xfe, 0xd3, 0x6c, 0x5e, 0xa1, 0x0f, 0x52, + 0xf2, 0x95, 0xe6, 0xbb, 0x70, 0x9e, 0xcf, 0xe6, 0xb3, 0xd4, 0xa0, 0x91, 0x0f, 0xfd, 0x85, 0xd8, + 0xd8, 0x4f, 0x27, 0xc3, 0x23, 0xf7, 0x54, 0x4c, 0x1a, 0x6b, 0xd1, 0xd6, 0xbf, 0xb1, 0x0d, 0xeb, + 0x70, 0x43, 0x90, 0x8e, 0x61, 0xeb, 0x8d, 0xfc, 0xf8, 0x4d, 0xf9, 0xc5, 0xd8, 0x7a, 0x23, 0x23, + 0xd1, 0x9d, 0x43, 0x7e, 0x29, 0xf7, 0x46, 0xf4, 0xa1, 0x97, 0xf2, 0x37, 0x53, 0x0b, 0x07, 0x1d, + 0x10, 0x7d, 0x15, 0xf6, 0x46, 0xf4, 0x51, 0x93, 0xf2, 0x4b, 0xa9, 0x85, 0x83, 0x0f, 0x88, 0xbe, + 0x80, 0x62, 0x5b, 0xa4, 0xae, 0x67, 0x73, 0x56, 0x91, 0xe9, 0xe1, 0x6f, 0xc5, 0xb7, 0x48, 0xa9, + 0x64, 0xb8, 0x45, 0x4a, 0xc5, 0xa4, 0xb1, 0x16, 0x9f, 0xf7, 0xcb, 0xdb, 0xb0, 0x96, 0x36, 0x76, + 0xa9, 0x98, 0x34, 0xd6, 0xe2, 0xe3, 0xbf, 0xb9, 0x0d, 0x6b, 0x69, 0x63, 0x97, 0x8a, 0x61, 0xe6, + 0x58, 0x88, 0xb9, 0x47, 0x1d, 0x37, 0x54, 0xbf, 0xff, 0x2c, 0x66, 0x8e, 0x65, 0xd0, 0x31, 0x73, + 0x2c, 0x03, 0x95, 0xca, 0x5d, 0x08, 0xe5, 0x57, 0xb6, 0xe3, 0x1e, 0xde, 0xcb, 0x64, 0xa0, 0x52, + 0xb9, 0x0b, 0xb9, 0xfc, 0xed, 0xed, 0xb8, 0x87, 0x17, 0x33, 0x19, 0x28, 0x66, 0x14, 0xd5, 0x3c, + 0xdd, 0x33, 0x1b, 0x73, 0xb6, 0xeb, 0x49, 0x8b, 0xfc, 0xdf, 0x89, 0x19, 0x45, 0x69, 0x44, 0xcc, + 0x28, 0x4a, 0x83, 0x27, 0x99, 0x0a, 0x69, 0xfc, 0x6a, 0x4f, 0xa6, 0xa1, 0xa5, 0x95, 0x06, 0x4f, + 0x32, 0x15, 0x42, 0xf8, 0xcf, 0x7b, 0x32, 0x0d, 0x3d, 0xe5, 0xd3, 0xe0, 0xcc, 0x32, 0x9d, 0x76, + 0xec, 0x75, 0xeb, 0x36, 0x5d, 0xa7, 0x2d, 0xf1, 0xe9, 0xbf, 0x16, 0xb3, 0x4c, 0xe3, 0x04, 0x78, + 0x8b, 0x12, 0x83, 0x45, 0x19, 0x89, 0xcf, 0xfd, 0xf5, 0x4c, 0x46, 0xe1, 0x31, 0x51, 0x1c, 0x16, + 0x65, 0x24, 0x3e, 0xf1, 0x37, 0x32, 0x19, 0x85, 0xc7, 0x44, 0x71, 0x18, 0x29, 0xc3, 0x18, 0xbe, + 0x95, 0xd0, 0x5d, 0xdf, 0xf3, 0xf3, 0xb7, 0x73, 0xd1, 0x5b, 0xaf, 0x28, 0x7a, 0xae, 0x4f, 0x8b, + 0x15, 0x90, 0x59, 0x88, 0x4f, 0xfa, 0x76, 0x06, 0x8b, 0xd0, 0xdf, 0x31, 0x0a, 0x91, 0x59, 0x88, + 0x8f, 0xf9, 0x2f, 0x32, 0x58, 0x84, 0x0e, 0x8f, 0x51, 0x08, 0xf9, 0x34, 0x0c, 0xd7, 0x66, 0x57, + 0x96, 0xfd, 0xf4, 0x7c, 0x7f, 0x37, 0x17, 0x7b, 0x55, 0x14, 0xe2, 0xf0, 0x55, 0x51, 0xf8, 0x93, + 0xcd, 0x28, 0xf7, 0x6d, 0xe7, 0x61, 0xcb, 0xd6, 0x0d, 0x3f, 0x22, 0xa3, 0x10, 0xc5, 0x3f, 0x88, + 0xcd, 0x28, 0xe9, 0x64, 0x6c, 0x46, 0x49, 0xc7, 0xa4, 0xb1, 0x16, 0x22, 0xfa, 0xce, 0x36, 0xac, + 0xc3, 0x79, 0x30, 0x1d, 0x93, 0xc6, 0x5a, 0x88, 0xee, 0x1f, 0x6e, 0xc3, 0x3a, 0x9c, 0x07, 0xd3, + 0x31, 0x53, 0x03, 0xd0, 0x8f, 0x67, 0xcb, 0xb7, 0x4b, 0x83, 0xdf, 0xca, 0x8d, 0xff, 0x66, 0xee, + 0x76, 0x69, 0xf0, 0x37, 0x73, 0xe3, 0xbf, 0xc5, 0xfe, 0xff, 0xad, 0xdc, 0xf8, 0x6f, 0xe7, 0xb4, + 0x8b, 0xe1, 0x3c, 0x51, 0x6e, 0x52, 0xcb, 0x5b, 0x6e, 0xe9, 0x62, 0x96, 0x4b, 0x45, 0xf1, 0x9f, + 0xa9, 0x28, 0x91, 0x1b, 0xec, 0x1b, 0x39, 0x18, 0xa9, 0x79, 0x0e, 0xd5, 0xdb, 0x22, 0xd4, 0xde, + 0x25, 0x18, 0xe4, 0xde, 0xe0, 0xfe, 0xd3, 0x75, 0x2d, 0xf8, 0x4d, 0xae, 0xc0, 0xd8, 0xbc, 0xee, + 0x7a, 0xd8, 0xc4, 0xaa, 0x65, 0xd0, 0xc7, 0xf8, 0x12, 0xb2, 0xa0, 0xc5, 0xa0, 0x64, 0x9e, 0xd3, + 0xf1, 0x72, 0x18, 0x5d, 0xb5, 0xb0, 0x6d, 0x84, 0xb9, 0xc1, 0xef, 0x6e, 0x4e, 0xf4, 0x61, 0x40, + 0xb9, 0x58, 0x59, 0xf5, 0x77, 0x73, 0x90, 0xf0, 0x53, 0xdf, 0x7b, 0x48, 0x89, 0x25, 0x38, 0x15, + 0x8b, 0xe8, 0x2b, 0x9e, 0x73, 0xee, 0x30, 0xe0, 0x6f, 0xbc, 0x34, 0xf9, 0x44, 0xf0, 0x8c, 0xf0, + 0xae, 0x36, 0x2f, 0xa2, 0x07, 0x62, 0xde, 0x8b, 0xae, 0xd3, 0xd2, 0x24, 0x94, 0x88, 0x0e, 0xf5, + 0xfd, 0xf1, 0x30, 0x5c, 0x29, 0xb9, 0x22, 0xe2, 0x5b, 0xe4, 0xc2, 0x98, 0x83, 0xb1, 0x2c, 0xfb, + 0x3c, 0x9e, 0xc5, 0x67, 0x60, 0xa4, 0xda, 0xee, 0x50, 0xc7, 0xb5, 0x2d, 0xdd, 0xb3, 0x1d, 0x11, + 0x1e, 0x00, 0xe3, 0xd1, 0x99, 0x12, 0x5c, 0x8e, 0x91, 0x26, 0xd3, 0x93, 0x6b, 0x7e, 0xea, 0xbe, + 0x02, 0x06, 0x8a, 0xc5, 0x37, 0xbe, 0xf1, 0xcc, 0xed, 0x9c, 0x82, 0x91, 0xde, 0x75, 0x75, 0x7c, + 0x70, 0x1a, 0x90, 0x76, 0x19, 0x40, 0x26, 0x45, 0x0a, 0xf2, 0x3c, 0x94, 0xf0, 0x82, 0xce, 0xc5, + 0x94, 0x9c, 0x22, 0x12, 0x62, 0x0b, 0x21, 0x72, 0xdc, 0x39, 0x4e, 0x43, 0xee, 0xc0, 0x78, 0xe8, + 0x7d, 0x70, 0xcb, 0xb1, 0xbb, 0x1d, 0x3f, 0x09, 0x0f, 0x66, 0xbc, 0x7f, 0x18, 0xe0, 0xea, 0x4d, + 0x44, 0x4a, 0x2c, 0x12, 0x05, 0xc9, 0x1c, 0x9c, 0x0a, 0x61, 0x4c, 0x44, 0x7e, 0xf2, 0x2f, 0x4c, + 0xbc, 0x2a, 0xf1, 0x62, 0xe2, 0x8c, 0x24, 0x5e, 0x8d, 0x15, 0x23, 0x55, 0x18, 0xf0, 0xc3, 0x20, + 0x0e, 0x6e, 0xab, 0xa4, 0x67, 0x44, 0x18, 0xc4, 0x01, 0x39, 0x00, 0xa2, 0x5f, 0x9e, 0xcc, 0xc2, + 0x98, 0x66, 0x77, 0x3d, 0xba, 0x62, 0x8b, 0x6d, 0xbb, 0x08, 0xb7, 0x89, 0x6d, 0x72, 0x18, 0xa6, + 0xee, 0xd9, 0xf5, 0x06, 0xc7, 0xc9, 0x89, 0xeb, 0xa3, 0xa5, 0xc8, 0x22, 0x9c, 0x4e, 0xf8, 0x69, + 0xc8, 0x69, 0xfc, 0xa5, 0xcf, 0x4b, 0x32, 0x4b, 0x16, 0x25, 0x3f, 0x96, 0x83, 0xd2, 0x8a, 0xa3, + 0x9b, 0x9e, 0x2b, 0xde, 0xaa, 0x9e, 0x9b, 0x5c, 0x77, 0xf4, 0x0e, 0xd3, 0x8f, 0x49, 0x8c, 0x04, + 0x7c, 0x4f, 0x6f, 0x75, 0xa9, 0x3b, 0x75, 0x9f, 0x7d, 0xdd, 0xff, 0xb0, 0x39, 0xf1, 0x46, 0x13, + 0x4f, 0x83, 0x27, 0x1b, 0x76, 0xfb, 0x7a, 0xd3, 0xd1, 0x1f, 0x99, 0x1e, 0xda, 0xdc, 0x7a, 0xeb, + 0xba, 0x47, 0x5b, 0x78, 0xe8, 0x7c, 0x5d, 0xef, 0x98, 0xd7, 0x31, 0xe2, 0xfc, 0xf5, 0x80, 0x13, + 0xaf, 0x81, 0xa9, 0x80, 0x87, 0x7f, 0xc9, 0x2a, 0xc0, 0x71, 0x64, 0x11, 0x40, 0x7c, 0x6a, 0xb9, + 0xd3, 0x11, 0x0f, 0x5f, 0xa5, 0xa3, 0x5a, 0x1f, 0xc3, 0x15, 0x3b, 0x10, 0x98, 0xde, 0x91, 0xa2, + 0x2c, 0x6b, 0x12, 0x07, 0xa6, 0x05, 0x2b, 0xa2, 0x45, 0xbe, 0x98, 0x46, 0x43, 0x89, 0xfb, 0x8d, + 0x4d, 0x11, 0x52, 0xbc, 0x18, 0x59, 0x85, 0x53, 0x82, 0x6f, 0x90, 0x93, 0x65, 0x2c, 0x3a, 0x2b, + 0xc4, 0xd0, 0x5c, 0x69, 0x83, 0x36, 0x1a, 0x02, 0x2c, 0xd7, 0x11, 0x2b, 0x41, 0xa6, 0xc2, 0x1c, + 0xd2, 0x8b, 0x7a, 0x9b, 0xba, 0xca, 0x29, 0xd4, 0xd8, 0xcb, 0x5b, 0x9b, 0x13, 0x8a, 0x5f, 0x1e, + 0x23, 0x82, 0xca, 0xa2, 0x8b, 0x16, 0x91, 0x79, 0x70, 0xad, 0x1f, 0x4f, 0xe1, 0x11, 0xd7, 0xf9, + 0x68, 0x11, 0x32, 0x0d, 0xa3, 0xc1, 0xbb, 0x9b, 0xbb, 0x77, 0xab, 0x15, 0x7c, 0x59, 0x2b, 0x82, + 0xc2, 0xc6, 0xb2, 0xa6, 0xc8, 0x4c, 0x22, 0x65, 0xa4, 0x60, 0x25, 0xfc, 0xa9, 0x6d, 0x2c, 0x58, + 0x49, 0x27, 0x25, 0x58, 0xc9, 0x32, 0x79, 0x0b, 0x86, 0xcb, 0xf7, 0x6b, 0x22, 0x08, 0x8b, 0xab, + 0x9c, 0x09, 0x53, 0x70, 0xe9, 0xeb, 0x6e, 0xdd, 0x0f, 0xd8, 0x22, 0x37, 0x5d, 0xa6, 0x27, 0x33, + 0x30, 0x16, 0x71, 0xdd, 0x73, 0x95, 0xb3, 0xc8, 0x01, 0x5b, 0xae, 0x23, 0xa6, 0xee, 0x08, 0x94, + 0x3c, 0xbc, 0xa2, 0x85, 0x98, 0xd6, 0x54, 0x4c, 0x17, 0xd3, 0x19, 0x69, 0x14, 0xe3, 0xbd, 0xe0, + 0x3b, 0xdd, 0x41, 0xae, 0x35, 0x86, 0x40, 0xd5, 0x1d, 0x8e, 0x93, 0x7b, 0x34, 0x56, 0x8c, 0xbc, + 0x07, 0x04, 0x13, 0x20, 0x51, 0xc3, 0xbf, 0xc9, 0xad, 0x56, 0x5c, 0xe5, 0x3c, 0x46, 0x44, 0x27, + 0xf1, 0xf8, 0x12, 0xd5, 0xca, 0xd4, 0x15, 0x31, 0x7d, 0x3c, 0xa5, 0xf3, 0x52, 0x75, 0x3f, 0xb6, + 0x44, 0xdd, 0x8c, 0x64, 0x87, 0x4e, 0xe1, 0x4a, 0xd6, 0xe1, 0xc2, 0xb2, 0x43, 0x1f, 0x99, 0x76, + 0xd7, 0xf5, 0x97, 0x0f, 0x7f, 0xde, 0xba, 0xb0, 0xed, 0xbc, 0xf5, 0x8c, 0xa8, 0xf8, 0x5c, 0xc7, + 0xa1, 0x8f, 0xea, 0x7e, 0x1c, 0xec, 0x48, 0x18, 0xd7, 0x2c, 0xee, 0x98, 0xe3, 0xfa, 0xfd, 0xae, + 0x43, 0x05, 0xdc, 0xa4, 0xae, 0xa2, 0x84, 0x53, 0x2d, 0x0f, 0xdd, 0x63, 0x06, 0xb8, 0x48, 0x8e, + 0xeb, 0x68, 0x31, 0xa2, 0x01, 0xb9, 0x35, 0xed, 0xdf, 0xea, 0x97, 0x1b, 0x3c, 0x13, 0xb0, 0x72, + 0x11, 0x99, 0xa9, 0x4c, 0x2c, 0xcd, 0x46, 0x10, 0x13, 0xbf, 0xae, 0x0b, 0xbc, 0x2c, 0x96, 0x64, + 0x69, 0x32, 0x0f, 0xe3, 0xcb, 0x0e, 0x9e, 0x31, 0xde, 0xa1, 0x1b, 0xcb, 0x76, 0xcb, 0x6c, 0x6c, + 0xe0, 0x73, 0x61, 0x31, 0x55, 0x76, 0x38, 0xae, 0xfe, 0x90, 0x6e, 0xd4, 0x3b, 0x88, 0x95, 0x97, + 0x95, 0x78, 0x49, 0x39, 0x46, 0xf5, 0x13, 0x3b, 0x8b, 0x51, 0x4d, 0x61, 0x5c, 0xf8, 0x04, 0x3c, + 0xf6, 0xa8, 0xc5, 0x96, 0x7a, 0x57, 0x3c, 0x0d, 0x56, 0x62, 0x3e, 0x04, 0x01, 0x9e, 0x4f, 0x1d, + 0x62, 0x94, 0xd1, 0x00, 0x2c, 0x37, 0x2c, 0x5e, 0x24, 0x19, 0xc8, 0xf9, 0xc9, 0x3d, 0x04, 0x72, + 0xfe, 0x3b, 0x05, 0x79, 0xfe, 0x25, 0x97, 0xa1, 0x28, 0xe5, 0x59, 0xc2, 0x28, 0xb5, 0x18, 0x93, + 0xbe, 0x28, 0x82, 0x6f, 0x0f, 0x09, 0xdb, 0x25, 0x08, 0x47, 0x84, 0x89, 0x35, 0xc3, 0xc8, 0xa5, + 0x5a, 0x48, 0x80, 0x49, 0x0d, 0xbb, 0xab, 0x2d, 0xb3, 0x81, 0x99, 0x0a, 0x0a, 0x52, 0xfc, 0x11, + 0x84, 0xf2, 0x44, 0x05, 0x12, 0x09, 0xb9, 0x01, 0xc3, 0xfe, 0xd9, 0x76, 0x18, 0xa5, 0x19, 0x03, + 0xd8, 0x8b, 0xd9, 0x5a, 0xc4, 0xc7, 0x97, 0x88, 0xc8, 0xeb, 0x00, 0xe1, 0x74, 0x20, 0x2c, 0x2d, + 0x5c, 0x2a, 0xe4, 0xd9, 0x43, 0x5e, 0x2a, 0x42, 0x6a, 0x36, 0x71, 0xca, 0xea, 0xe8, 0xa7, 0x71, + 0xc5, 0x89, 0x33, 0xa2, 0xc3, 0xb2, 0x82, 0x44, 0x8b, 0x90, 0x25, 0x38, 0x9d, 0xd0, 0x40, 0x11, + 0xd3, 0x19, 0x53, 0xf9, 0xa7, 0xa8, 0xaf, 0xbc, 0x30, 0x27, 0xca, 0x92, 0x67, 0xa1, 0x70, 0x57, + 0xab, 0x8a, 0xb8, 0xb2, 0x3c, 0x24, 0x71, 0x24, 0xe8, 0x14, 0xc3, 0xaa, 0x7f, 0x3a, 0x9f, 0x58, + 0x9b, 0x98, 0xf4, 0x04, 0x2b, 0xa9, 0x07, 0x51, 0x7a, 0x7e, 0xfd, 0x5c, 0x7a, 0x12, 0x11, 0xb9, + 0x0a, 0x83, 0xcb, 0x6c, 0x66, 0x68, 0xd8, 0x2d, 0xd1, 0x9f, 0x18, 0x21, 0xac, 0x23, 0x60, 0x5a, + 0x80, 0x25, 0x37, 0xa4, 0xec, 0xc3, 0x52, 0xa8, 0x76, 0x3f, 0xfb, 0x70, 0x3c, 0x66, 0x39, 0xe6, + 0x21, 0xbe, 0x11, 0xcb, 0x66, 0x26, 0xca, 0xa4, 0xac, 0x8b, 0x61, 0xf6, 0xb2, 0xc0, 0x2a, 0xed, + 0xdf, 0xce, 0x2a, 0x55, 0xff, 0x5e, 0x2e, 0x39, 0xce, 0xc8, 0xcd, 0x64, 0xd4, 0x64, 0x5c, 0x84, + 0x02, 0xa0, 0x5c, 0x6b, 0x10, 0x3f, 0x39, 0x12, 0xff, 0x38, 0xbf, 0xe7, 0xf8, 0xc7, 0x85, 0x5d, + 0xc6, 0x3f, 0x56, 0xff, 0xdf, 0x62, 0x4f, 0x1f, 0xf6, 0x43, 0x89, 0x93, 0xf7, 0x1a, 0xdb, 0x59, + 0xb1, 0xda, 0xcb, 0x6e, 0x62, 0x7f, 0xc0, 0x5d, 0x74, 0xeb, 0x3a, 0x1f, 0x5a, 0xae, 0x16, 0xa5, + 0x24, 0x6f, 0xc3, 0x88, 0xff, 0x01, 0x18, 0x57, 0x5b, 0x8a, 0x07, 0x1d, 0xac, 0x6a, 0xb1, 0x08, + 0xd4, 0x91, 0x02, 0xe4, 0x65, 0x18, 0x42, 0x9b, 0xa6, 0xa3, 0x37, 0xfc, 0xa0, 0xeb, 0x3c, 0x4a, + 0xbb, 0x0f, 0x94, 0x63, 0xc1, 0x05, 0x94, 0xe4, 0x0b, 0x50, 0x12, 0x99, 0x47, 0x78, 0x62, 0xfe, + 0xeb, 0x3b, 0x70, 0xfa, 0x9f, 0x94, 0xb3, 0x8e, 0xf0, 0x5d, 0x0a, 0x02, 0x22, 0xbb, 0x14, 0x9e, + 0x70, 0x64, 0x05, 0xce, 0x2c, 0x3b, 0xd4, 0xc0, 0xe7, 0x25, 0x33, 0x8f, 0x3b, 0x8e, 0xc8, 0x09, + 0xc3, 0x47, 0x39, 0x2e, 0x52, 0x1d, 0x1f, 0xcd, 0x96, 0x4f, 0x81, 0x97, 0x23, 0x3f, 0xa7, 0x14, + 0x67, 0x96, 0x0b, 0x6f, 0xc9, 0x1d, 0xba, 0xb1, 0x6e, 0x3b, 0x06, 0x4f, 0x9b, 0x22, 0xe6, 0x6f, + 0x21, 0xe8, 0x87, 0x02, 0x25, 0x5b, 0x2e, 0xd1, 0x42, 0x97, 0x5e, 0x83, 0xe1, 0xbd, 0x66, 0xee, + 0xf8, 0x95, 0x7c, 0xc6, 0x6b, 0xb0, 0xe3, 0x9b, 0x3c, 0x31, 0xc8, 0xe8, 0xdd, 0x9f, 0x91, 0xd1, + 0xfb, 0x8f, 0xf3, 0x19, 0x4f, 0xdd, 0x8e, 0x75, 0xe6, 0xdd, 0x40, 0x18, 0xd1, 0xcc, 0xbb, 0x61, + 0xd2, 0x63, 0xd3, 0xd0, 0x64, 0xa2, 0x58, 0x8e, 0xee, 0xd2, 0xb6, 0x39, 0xba, 0x7f, 0xa1, 0xd0, + 0xeb, 0x29, 0xe0, 0x89, 0xec, 0x77, 0x23, 0xfb, 0x1b, 0x30, 0x1c, 0x48, 0xb6, 0x5a, 0x41, 0xa3, + 0x67, 0x34, 0xc8, 0x13, 0xc4, 0xc1, 0x58, 0x46, 0x22, 0x22, 0xd7, 0x78, 0x5b, 0x6b, 0xe6, 0xfb, + 0x3c, 0x63, 0xc5, 0xa8, 0xc8, 0x45, 0xa0, 0x7b, 0x7a, 0xdd, 0x35, 0xdf, 0xa7, 0x5a, 0x80, 0x56, + 0xff, 0x41, 0x3e, 0xf5, 0x3d, 0xe5, 0x49, 0x1f, 0xed, 0xa2, 0x8f, 0x52, 0x84, 0xc8, 0x5f, 0x82, + 0x9e, 0x08, 0x71, 0x17, 0x42, 0xfc, 0xa3, 0x7c, 0xea, 0xbb, 0xd9, 0x13, 0x21, 0xee, 0x66, 0xb6, + 0x78, 0x1e, 0x86, 0x34, 0x7b, 0xdd, 0x9d, 0xc6, 0x8d, 0x0d, 0x9f, 0x2b, 0x70, 0xa2, 0x76, 0xec, + 0x75, 0xb7, 0x8e, 0x5b, 0x16, 0x2d, 0x24, 0x50, 0xbf, 0x9f, 0xef, 0xf1, 0xb2, 0xf8, 0x44, 0xf0, + 0x1f, 0xe4, 0x12, 0xf9, 0xeb, 0xf9, 0xc8, 0xcb, 0xe5, 0xe3, 0x2b, 0xec, 0xeb, 0x00, 0xb5, 0xc6, + 0x1a, 0x6d, 0xeb, 0x52, 0xd6, 0x2f, 0x3c, 0x77, 0x70, 0x11, 0x2a, 0xb2, 0x45, 0x87, 0x24, 0xea, + 0xb7, 0xf2, 0xb1, 0xa7, 0xdb, 0x27, 0xb2, 0xdb, 0xb1, 0xec, 0x02, 0xad, 0x13, 0xaf, 0xd1, 0x4f, + 0x24, 0xb7, 0x53, 0xc9, 0xfd, 0x78, 0x3e, 0xf6, 0x70, 0xff, 0xd8, 0xca, 0x8e, 0x0d, 0xc0, 0x64, + 0x40, 0x81, 0x63, 0xab, 0x49, 0xcf, 0xc3, 0x90, 0x90, 0x43, 0xb0, 0x54, 0xf0, 0x79, 0x9f, 0x03, + 0xf1, 0x94, 0x35, 0x20, 0x50, 0xff, 0x4c, 0x1e, 0xa2, 0x01, 0x15, 0x8e, 0xa9, 0x0e, 0xfd, 0x7a, + 0x3e, 0x1a, 0x4a, 0xe2, 0xf8, 0xea, 0xcf, 0x24, 0x40, 0xad, 0xbb, 0xda, 0x10, 0x91, 0x88, 0xfb, + 0xa5, 0x63, 0xfa, 0x00, 0xaa, 0x49, 0x14, 0xea, 0xff, 0x97, 0x4f, 0x8d, 0x6f, 0x71, 0x7c, 0x05, + 0xf8, 0x12, 0x9e, 0x8a, 0x37, 0xac, 0x70, 0x22, 0xc7, 0x43, 0x48, 0x36, 0xfe, 0x12, 0xa9, 0x22, + 0x7d, 0x42, 0xf2, 0xe9, 0x14, 0x73, 0x0d, 0x13, 0x59, 0x84, 0xe6, 0x9a, 0x7c, 0x0d, 0x21, 0x19, + 0x6e, 0xbf, 0x93, 0xdf, 0x2e, 0x1c, 0xc8, 0x71, 0x5e, 0x55, 0x07, 0x96, 0xf5, 0x0d, 0x0c, 0x5b, + 0xc9, 0x7a, 0x62, 0x84, 0x27, 0x32, 0xec, 0x70, 0x90, 0x7c, 0xf7, 0x26, 0xa8, 0xd4, 0x7f, 0xd1, + 0x9f, 0x1e, 0x8b, 0xe2, 0xf8, 0x8a, 0xf0, 0x32, 0x14, 0x97, 0x75, 0x6f, 0x4d, 0x68, 0x32, 0x5e, + 0xe9, 0x75, 0x74, 0x6f, 0x4d, 0x43, 0x28, 0xb9, 0x06, 0x83, 0x9a, 0xbe, 0xce, 0xcf, 0x3c, 0x4b, + 0x61, 0x92, 0x49, 0x47, 0x5f, 0xaf, 0xf3, 0x73, 0xcf, 0x00, 0x4d, 0xd4, 0x20, 0xc9, 0x29, 0x3f, + 0xf9, 0xc6, 0x0c, 0x7b, 0x3c, 0xc9, 0x69, 0x90, 0xda, 0xf4, 0x32, 0x14, 0xa7, 0x6c, 0x63, 0x03, + 0xaf, 0xaf, 0x46, 0x78, 0x65, 0xab, 0xb6, 0xb1, 0xa1, 0x21, 0x94, 0xfc, 0x44, 0x0e, 0x06, 0xe6, + 0xa8, 0x6e, 0xb0, 0x11, 0x32, 0xd4, 0xcb, 0xeb, 0xe4, 0x73, 0x07, 0xe3, 0x75, 0x72, 0x7a, 0x8d, + 0x57, 0x26, 0x2b, 0x8a, 0xa8, 0x9f, 0xdc, 0x82, 0xc1, 0x69, 0xdd, 0xa3, 0x4d, 0xdb, 0xd9, 0x40, + 0x3f, 0x9a, 0xb1, 0xf0, 0x3d, 0x43, 0x44, 0x7f, 0x7c, 0x22, 0x7e, 0x33, 0xd6, 0x10, 0xbf, 0xb4, + 0xa0, 0x30, 0x13, 0xcb, 0x8a, 0xee, 0x34, 0xa9, 0x27, 0x12, 0x7a, 0xa3, 0x58, 0x3c, 0x84, 0x68, + 0x02, 0x13, 0x1e, 0x2b, 0x8f, 0xa4, 0x1f, 0x2b, 0xa3, 0xf5, 0x88, 0xbe, 0x76, 0x98, 0x5a, 0x74, + 0x14, 0x17, 0x7d, 0x6e, 0x3d, 0x22, 0x14, 0x33, 0x8b, 0x6a, 0x12, 0x89, 0xfa, 0xbd, 0x7e, 0x48, + 0x7d, 0xb9, 0x7e, 0xa2, 0xe4, 0x27, 0x4a, 0x1e, 0x2a, 0x79, 0x25, 0xa1, 0xe4, 0x97, 0x92, 0xb1, + 0x10, 0x3e, 0xa4, 0x1a, 0xfe, 0xf5, 0x62, 0x22, 0x92, 0xca, 0xf1, 0xde, 0x5d, 0x86, 0xd2, 0xeb, + 0xdf, 0x56, 0x7a, 0xc1, 0x80, 0x28, 0x6d, 0x3b, 0x20, 0x06, 0x76, 0x3a, 0x20, 0x06, 0x33, 0x07, + 0x44, 0xa8, 0x20, 0x43, 0x99, 0x0a, 0x52, 0x15, 0x83, 0x06, 0x7a, 0x27, 0x74, 0xb9, 0xbc, 0xb5, + 0x39, 0x31, 0xc6, 0x46, 0x53, 0x6a, 0x26, 0x17, 0x64, 0xa1, 0xfe, 0x6e, 0xb1, 0x47, 0xf8, 0xa3, + 0x43, 0xd1, 0x91, 0x97, 0xa0, 0x50, 0xee, 0x74, 0x84, 0x7e, 0x9c, 0x91, 0x22, 0x2f, 0x65, 0x94, + 0x62, 0xd4, 0xe4, 0x75, 0x28, 0x94, 0xef, 0xd7, 0xe2, 0x49, 0x5c, 0xca, 0xf7, 0x6b, 0xe2, 0x4b, + 0x32, 0xcb, 0xde, 0xaf, 0x91, 0x37, 0xc3, 0x68, 0xaa, 0x6b, 0x5d, 0xeb, 0xa1, 0xd8, 0x28, 0x0a, + 0x77, 0x5b, 0xdf, 0x1d, 0xa7, 0xc1, 0x50, 0x6c, 0xbb, 0x18, 0xa3, 0x8d, 0x69, 0x53, 0x69, 0xe7, + 0xda, 0x34, 0xb0, 0xad, 0x36, 0x0d, 0xee, 0x54, 0x9b, 0x86, 0x76, 0xa0, 0x4d, 0xb0, 0xad, 0x36, + 0x0d, 0xef, 0x5f, 0x9b, 0x3a, 0x70, 0x29, 0x19, 0xb2, 0x2e, 0xd0, 0x08, 0x0d, 0x48, 0x12, 0x2b, + 0x1c, 0x4b, 0xf0, 0xea, 0xbf, 0xcb, 0xb1, 0xf5, 0x75, 0x44, 0xd7, 0x5d, 0x86, 0x97, 0xfd, 0xd3, + 0x92, 0xa5, 0xd5, 0x5f, 0xc9, 0x67, 0x47, 0xda, 0x3b, 0x9a, 0x53, 0xdc, 0x0f, 0xa5, 0x4a, 0xa9, + 0x18, 0x8d, 0x7c, 0x90, 0x2d, 0xe5, 0x18, 0xdb, 0x34, 0x99, 0x7d, 0x33, 0x9f, 0x15, 0xfe, 0x6f, + 0x5f, 0x12, 0xfb, 0x78, 0xd2, 0xa3, 0x0d, 0xfd, 0xf4, 0xdd, 0xa8, 0x2b, 0xdb, 0x2c, 0x8c, 0xc8, + 0x42, 0x14, 0x52, 0xda, 0x89, 0x80, 0x23, 0xe5, 0xc8, 0x9b, 0x41, 0xae, 0x1d, 0xc9, 0x3f, 0x06, + 0xdd, 0xd5, 0xfc, 0x31, 0x1b, 0x73, 0x8f, 0x91, 0xc9, 0xc9, 0xf3, 0x50, 0x9a, 0xc5, 0xe0, 0xf5, + 0xf2, 0x60, 0xe7, 0xe1, 0xec, 0x65, 0xaf, 0x15, 0x4e, 0xa3, 0xfe, 0xbd, 0x1c, 0x9c, 0xb9, 0xd3, + 0x5d, 0xa5, 0xc2, 0x5b, 0x2e, 0x68, 0xc3, 0x7b, 0x00, 0x0c, 0x2c, 0x1c, 0x66, 0x72, 0xe8, 0x30, + 0xf3, 0x49, 0x39, 0x4c, 0x60, 0xac, 0xc0, 0x64, 0x48, 0xcd, 0x9d, 0x65, 0x9e, 0xf4, 0x1d, 0x47, + 0x1f, 0x76, 0x57, 0x69, 0x3d, 0xe1, 0x35, 0x23, 0x71, 0xbf, 0xf4, 0x16, 0x77, 0xc9, 0xdf, 0xab, + 0x83, 0xca, 0x2f, 0xe7, 0x33, 0x23, 0x33, 0x1e, 0xd9, 0x14, 0xa2, 0x3f, 0x90, 0xda, 0x2b, 0xf1, + 0x54, 0xa2, 0x29, 0x24, 0x31, 0x8e, 0x69, 0x5c, 0xd2, 0x05, 0x76, 0xc4, 0x13, 0xdb, 0x7e, 0xa0, + 0x02, 0xfb, 0x83, 0x5c, 0x66, 0x04, 0xcd, 0xa3, 0x2a, 0x30, 0xf5, 0x7f, 0x2d, 0xf8, 0x81, 0x3b, + 0xf7, 0xf5, 0x09, 0xcf, 0xc3, 0x90, 0x88, 0x5f, 0x10, 0x75, 0xf6, 0x15, 0xc7, 0x86, 0x78, 0x0c, + 0x1d, 0x10, 0x30, 0x93, 0x42, 0xf2, 0x44, 0x96, 0x9c, 0x7d, 0x25, 0x2f, 0x64, 0x4d, 0x22, 0x61, + 0x46, 0xc3, 0xcc, 0x63, 0xd3, 0x43, 0x0b, 0x84, 0xf5, 0x65, 0x81, 0x1b, 0x0d, 0xf4, 0xb1, 0xe9, + 0x71, 0xfb, 0x23, 0x40, 0x33, 0x83, 0xa0, 0x16, 0xa6, 0xed, 0x17, 0x06, 0x01, 0x37, 0x55, 0x34, + 0x81, 0x61, 0xad, 0x15, 0x1e, 0xb4, 0xc2, 0xa5, 0x45, 0xb4, 0x56, 0xf8, 0xdc, 0x62, 0x6b, 0x03, + 0x02, 0xc6, 0x51, 0xa3, 0xcd, 0xd0, 0x89, 0x0f, 0x39, 0x3a, 0x08, 0xd1, 0x04, 0x86, 0xdc, 0x80, + 0xb1, 0x9a, 0xa7, 0x5b, 0x86, 0xee, 0x18, 0x4b, 0x5d, 0xaf, 0xd3, 0xf5, 0x64, 0x03, 0xd8, 0xf5, + 0x0c, 0xbb, 0xeb, 0x69, 0x31, 0x0a, 0xf2, 0x29, 0x18, 0xf5, 0x21, 0x33, 0x8e, 0x63, 0x3b, 0xb2, + 0x95, 0xe3, 0x7a, 0x06, 0x75, 0x1c, 0x2d, 0x4a, 0x40, 0x3e, 0x0d, 0xa3, 0x55, 0xeb, 0x91, 0xdd, + 0xe0, 0x6f, 0xf8, 0xb5, 0x79, 0x61, 0xf3, 0xe0, 0xb3, 0x2f, 0x33, 0x40, 0xd4, 0xbb, 0x4e, 0x4b, + 0x8b, 0x12, 0xaa, 0x5b, 0xf9, 0x64, 0x7c, 0xd3, 0xe3, 0xbb, 0x41, 0xba, 0x16, 0x75, 0xdc, 0x43, + 0x6f, 0x55, 0x34, 0x3e, 0x65, 0xbf, 0x61, 0x6e, 0x83, 0xde, 0x80, 0xc1, 0x3b, 0x74, 0x83, 0xfb, + 0x98, 0x96, 0x42, 0xb7, 0xe4, 0x87, 0x02, 0x26, 0x9f, 0xee, 0xfa, 0x74, 0xea, 0xb7, 0xf3, 0xc9, + 0xc8, 0xad, 0xc7, 0x57, 0xd8, 0x9f, 0x82, 0x01, 0x14, 0x65, 0xd5, 0xbf, 0x5e, 0x40, 0x01, 0xa2, + 0xb8, 0xa3, 0xde, 0xce, 0x3e, 0x99, 0xfa, 0xf3, 0xa5, 0x78, 0x38, 0xdf, 0xe3, 0x2b, 0xbd, 0x37, + 0x60, 0x78, 0xda, 0xb6, 0x5c, 0xd3, 0xf5, 0xa8, 0xd5, 0xf0, 0x15, 0xf6, 0x22, 0x33, 0xa8, 0x1a, + 0x21, 0x58, 0xb6, 0x01, 0x25, 0xea, 0xbd, 0x28, 0x2f, 0x79, 0x05, 0x86, 0x50, 0xe4, 0x68, 0x73, + 0xf2, 0x09, 0x0f, 0x6f, 0x26, 0x56, 0x19, 0x30, 0x6e, 0x71, 0x86, 0xa4, 0xe4, 0x2e, 0x0c, 0x4e, + 0xaf, 0x99, 0x2d, 0xc3, 0xa1, 0x16, 0xfa, 0x26, 0x4b, 0x51, 0x53, 0xa2, 0x7d, 0x39, 0x89, 0xff, + 0x22, 0x2d, 0x6f, 0x4e, 0x43, 0x14, 0x8b, 0xbc, 0xf8, 0x12, 0xb0, 0x4b, 0x3f, 0x93, 0x07, 0x08, + 0x0b, 0x90, 0xa7, 0x21, 0x1f, 0x64, 0xc4, 0x46, 0x97, 0x98, 0x88, 0x06, 0xe5, 0x71, 0xa9, 0x10, + 0x63, 0x3b, 0xbf, 0xed, 0xd8, 0xbe, 0x0b, 0x25, 0x7e, 0xba, 0x86, 0x5e, 0xeb, 0x52, 0x84, 0xd1, + 0xcc, 0x06, 0x4f, 0x22, 0x3d, 0xb7, 0xa5, 0xd1, 0xf2, 0x8c, 0x78, 0x80, 0x73, 0x66, 0x97, 0x1a, + 0xd0, 0x8f, 0x7f, 0x91, 0x2b, 0x50, 0x5c, 0xf1, 0xb3, 0xe9, 0x8e, 0xf2, 0x59, 0x3a, 0x26, 0x3f, + 0xc4, 0xb3, 0x6e, 0x9a, 0xb6, 0x2d, 0x8f, 0x55, 0x8d, 0xad, 0x1e, 0x11, 0x72, 0x11, 0xb0, 0x88, + 0x5c, 0x04, 0x4c, 0xfd, 0xaf, 0xf3, 0x29, 0x81, 0xa6, 0x8f, 0xef, 0x30, 0x79, 0x0d, 0x00, 0x9f, + 0x8f, 0x33, 0x79, 0xfa, 0xcf, 0x41, 0x70, 0x94, 0x20, 0x23, 0x54, 0xdb, 0xc8, 0xb6, 0x23, 0x24, + 0x56, 0xff, 0x51, 0x2e, 0x11, 0x9d, 0x78, 0x5f, 0x72, 0x94, 0xad, 0xb2, 0xfc, 0x1e, 0xcd, 0x58, + 0xbf, 0x2f, 0x0a, 0xbb, 0xeb, 0x8b, 0xe8, 0xb7, 0x1c, 0x80, 0x65, 0x7a, 0x98, 0xdf, 0xf2, 0xbd, + 0x7c, 0x5a, 0xac, 0xe6, 0xa3, 0xa9, 0xe2, 0x37, 0x03, 0xa3, 0xb4, 0x18, 0x8b, 0x8e, 0x8f, 0xd0, + 0x78, 0xc6, 0x6f, 0x61, 0xa6, 0x7e, 0x11, 0x4e, 0xc5, 0x22, 0x18, 0x8b, 0xe4, 0xcb, 0x57, 0x7a, + 0x87, 0x42, 0xce, 0x0e, 0x3c, 0x10, 0x21, 0x53, 0xff, 0xff, 0x5c, 0xef, 0xf8, 0xd5, 0x87, 0xae, + 0x3a, 0x29, 0x02, 0x28, 0xfc, 0xc9, 0x08, 0xe0, 0x00, 0xb6, 0xc1, 0x47, 0x5b, 0x00, 0x1f, 0x92, + 0xc9, 0xe3, 0x83, 0x16, 0xc0, 0xcf, 0xe7, 0xb6, 0x0d, 0x3f, 0x7e, 0xd8, 0x32, 0x50, 0xff, 0xa7, + 0x5c, 0x6a, 0x98, 0xf0, 0x7d, 0xb5, 0xeb, 0x4d, 0x28, 0x71, 0x17, 0x1e, 0xd1, 0x2a, 0x29, 0xb1, + 0x1a, 0x83, 0x66, 0x94, 0x17, 0x65, 0xc8, 0x3c, 0x0c, 0xf0, 0x36, 0x18, 0xa2, 0x37, 0x3e, 0xd6, + 0x23, 0x56, 0xb9, 0x91, 0x35, 0x39, 0x0a, 0xb4, 0xfa, 0xf7, 0x73, 0x89, 0xa8, 0xe5, 0x87, 0xf8, + 0x6d, 0xe1, 0x54, 0x5d, 0xd8, 0xf9, 0x54, 0xad, 0xfe, 0xf3, 0x7c, 0x7a, 0xd0, 0xf4, 0x43, 0xfc, + 0x90, 0x83, 0x38, 0x4e, 0xdb, 0xdb, 0xba, 0xb5, 0x02, 0x63, 0x51, 0x59, 0x88, 0x65, 0xeb, 0xa9, + 0xf4, 0xd0, 0xf1, 0x19, 0xad, 0x88, 0xf1, 0x50, 0xbf, 0x9b, 0x4b, 0xc6, 0x7b, 0x3f, 0xf4, 0xf9, + 0x69, 0x6f, 0xda, 0x12, 0xfd, 0x94, 0x0f, 0xc9, 0x5a, 0x73, 0x10, 0x9f, 0xf2, 0x21, 0x59, 0x35, + 0xf6, 0xf6, 0x29, 0xbf, 0x98, 0xcf, 0x0a, 0x97, 0x7f, 0xe8, 0x1f, 0xf4, 0x79, 0x59, 0xc8, 0xbc, + 0x65, 0xe2, 0xd3, 0x9e, 0xce, 0x8a, 0x4f, 0x9f, 0xc1, 0x33, 0xc1, 0x67, 0x6f, 0x63, 0x3c, 0x55, + 0x58, 0x1f, 0x12, 0x45, 0x3e, 0x1a, 0xc2, 0xfa, 0x90, 0x0c, 0x95, 0x0f, 0x9f, 0xb0, 0x7e, 0x33, + 0xbf, 0xd3, 0x1c, 0x0d, 0x27, 0xc2, 0x4b, 0x08, 0xef, 0xab, 0xf9, 0x64, 0xee, 0x90, 0x43, 0x17, + 0xd3, 0x2c, 0x94, 0x44, 0x16, 0x93, 0x4c, 0xe1, 0x70, 0x7c, 0x96, 0x45, 0x23, 0xbe, 0xe3, 0x26, + 0x88, 0x8b, 0x9c, 0x9d, 0x89, 0x84, 0xd3, 0xaa, 0xdf, 0xcf, 0xc5, 0x12, 0x6d, 0x1c, 0xca, 0x11, + 0xc2, 0x9e, 0x96, 0x24, 0xf2, 0x96, 0x7f, 0x98, 0x59, 0x8c, 0x05, 0x3a, 0x0f, 0xbe, 0xa7, 0x42, + 0x3d, 0xdd, 0x6c, 0xc5, 0xcb, 0x8b, 0xf8, 0x03, 0xdf, 0xce, 0xc3, 0xe9, 0x04, 0x29, 0xb9, 0x12, + 0x09, 0xdb, 0x83, 0xc7, 0x92, 0x31, 0x47, 0x75, 0x1e, 0xc0, 0x67, 0x17, 0x27, 0xa9, 0x57, 0xa0, + 0x58, 0xd1, 0x37, 0xf8, 0xb7, 0xf5, 0x73, 0x96, 0x86, 0xbe, 0x21, 0x9f, 0xb8, 0x21, 0x9e, 0xac, + 0xc2, 0x39, 0x7e, 0x1f, 0x62, 0xda, 0xd6, 0x8a, 0xd9, 0xa6, 0x55, 0x6b, 0xc1, 0x6c, 0xb5, 0x4c, + 0x57, 0x5c, 0xea, 0x3d, 0xbf, 0xb5, 0x39, 0x71, 0xd5, 0xb3, 0x3d, 0xbd, 0x55, 0xa7, 0x3e, 0x59, + 0xdd, 0x33, 0xdb, 0xb4, 0x6e, 0x5a, 0xf5, 0x36, 0x52, 0x4a, 0x2c, 0xd3, 0x59, 0x91, 0x2a, 0x8f, + 0x69, 0x5f, 0x6b, 0xe8, 0x96, 0x45, 0x8d, 0xaa, 0x35, 0xb5, 0xe1, 0x51, 0x7e, 0x19, 0x58, 0xe0, + 0x47, 0x82, 0xfc, 0x1d, 0x3a, 0x47, 0x33, 0xc6, 0xab, 0x8c, 0x40, 0x4b, 0x29, 0xa4, 0xfe, 0x56, + 0x31, 0x25, 0xc7, 0xca, 0x11, 0x52, 0x1f, 0xbf, 0xa7, 0x8b, 0xdb, 0xf4, 0xf4, 0x75, 0x18, 0x10, + 0x41, 0x83, 0xc5, 0x05, 0x03, 0x3a, 0xce, 0x3f, 0xe2, 0x20, 0xf9, 0x86, 0x46, 0x50, 0x91, 0x16, + 0x5c, 0x5a, 0x61, 0xdd, 0x94, 0xde, 0x99, 0xa5, 0x3d, 0x74, 0x66, 0x0f, 0x7e, 0xe4, 0x5d, 0xb8, + 0x80, 0xd8, 0x94, 0x6e, 0x1d, 0xc0, 0xaa, 0x30, 0x1e, 0x16, 0xaf, 0x2a, 0xbd, 0x73, 0xb3, 0xca, 0x93, 0xcf, 0xc3, 0x48, 0x30, 0x40, 0x4c, 0xea, 0x8a, 0x9b, 0x8b, 0x1e, 0xe3, 0x8c, 0x07, 0x9b, - 0x63, 0x60, 0x74, 0x57, 0x8b, 0x06, 0x2c, 0x8b, 0xf0, 0x52, 0xff, 0x87, 0x5c, 0xaf, 0xd4, 0x26, - 0xc7, 0x3e, 0x2b, 0xbf, 0x0d, 0x03, 0x06, 0xff, 0x28, 0xa1, 0x53, 0xbd, 0x93, 0x9f, 0x70, 0x52, - 0xcd, 0x2f, 0xa3, 0xfe, 0xd3, 0x5c, 0xcf, 0x8c, 0x2a, 0x27, 0xfd, 0xf3, 0xbe, 0x5a, 0xc8, 0xf8, - 0x3c, 0x31, 0x89, 0x5e, 0x83, 0x71, 0x33, 0x0c, 0xf9, 0x5e, 0x0f, 0x43, 0x5d, 0x69, 0x67, 0x24, + 0x63, 0x60, 0x74, 0x57, 0x8b, 0x06, 0x2c, 0x8b, 0xf0, 0x52, 0xff, 0xc7, 0x5c, 0xaf, 0x5c, 0x2f, + 0x87, 0x3e, 0x2b, 0xbf, 0x05, 0x03, 0x06, 0xff, 0x28, 0xa1, 0x53, 0xbd, 0xb3, 0xc1, 0x70, 0x52, + 0xcd, 0x2f, 0xa3, 0xfe, 0xb3, 0x5c, 0xcf, 0x14, 0x33, 0x47, 0xfd, 0xf3, 0xbe, 0x5a, 0xc8, 0xf8, + 0x3c, 0x31, 0x89, 0x5e, 0x83, 0x71, 0x33, 0x8c, 0x81, 0x5f, 0x0f, 0x43, 0x5d, 0x69, 0xa7, 0x24, 0x38, 0x8e, 0xae, 0x9b, 0x10, 0x38, 0x6c, 0x39, 0xbe, 0x37, 0x9a, 0x5b, 0xef, 0x3a, 0x26, 0x1f, - 0x97, 0xda, 0x39, 0x37, 0xe6, 0xaa, 0xe6, 0xde, 0x75, 0x4c, 0x56, 0x81, 0xee, 0x6d, 0x50, 0x4b, - 0xaf, 0x6f, 0xda, 0xce, 0x03, 0x8c, 0x68, 0xca, 0x07, 0xa7, 0x76, 0x86, 0xc3, 0xef, 0xfb, 0x60, - 0xf2, 0x1c, 0x8c, 0x36, 0x5b, 0x5d, 0x1a, 0xc4, 0x90, 0xe4, 0x77, 0x7d, 0xda, 0x08, 0x03, 0x06, - 0x37, 0x24, 0x4f, 0x01, 0x20, 0x91, 0x87, 0xf9, 0x6e, 0xf0, 0x62, 0x4f, 0x1b, 0x62, 0x90, 0x55, + 0x97, 0xda, 0x59, 0x37, 0xe6, 0xaa, 0xe6, 0xde, 0x75, 0x4c, 0x56, 0x81, 0xee, 0xad, 0x51, 0x4b, + 0xaf, 0xaf, 0xdb, 0xce, 0x43, 0x8c, 0x68, 0xca, 0x07, 0xa7, 0x76, 0x8a, 0xc3, 0xef, 0xfb, 0x60, + 0xf2, 0x2c, 0x8c, 0x36, 0x5b, 0x5d, 0x1a, 0xc4, 0x90, 0xe4, 0x77, 0x7d, 0xda, 0x08, 0x03, 0x06, + 0x37, 0x24, 0x4f, 0x02, 0x20, 0x91, 0x87, 0x09, 0x80, 0xf0, 0x62, 0x4f, 0x1b, 0x62, 0x90, 0x15, 0xd1, 0x5d, 0x97, 0xb8, 0x56, 0x73, 0x21, 0xd5, 0x5b, 0xb6, 0xd5, 0xac, 0x7b, 0xd4, 0x69, 0x63, - 0x43, 0xd1, 0x99, 0x41, 0xbb, 0x80, 0x14, 0x78, 0x75, 0xe2, 0x2e, 0xd8, 0x56, 0x73, 0x95, 0x3a, - 0x6d, 0xd6, 0xd4, 0x17, 0x80, 0x88, 0xa6, 0x3a, 0x78, 0xe8, 0xc1, 0x3f, 0x0e, 0xbd, 0x19, 0x34, - 0xf1, 0x11, 0xfc, 0x34, 0x04, 0x3f, 0x6c, 0x12, 0x86, 0x79, 0x20, 0x3d, 0x2e, 0x34, 0x74, 0x61, - 0xd0, 0x80, 0x83, 0x50, 0x5e, 0x17, 0x40, 0x78, 0x57, 0x70, 0x0f, 0x72, 0x4d, 0xfc, 0x52, 0xbf, - 0x5c, 0x48, 0x4b, 0x02, 0x73, 0x28, 0x45, 0x0b, 0xa7, 0xd5, 0xfc, 0xbe, 0xa6, 0xd5, 0x33, 0x56, - 0xb7, 0x5d, 0xd7, 0x3b, 0x9d, 0xfa, 0xba, 0xd9, 0xc2, 0x27, 0x5c, 0xb8, 0xf0, 0x69, 0xa3, 0x56, - 0xb7, 0x5d, 0xee, 0x74, 0xe6, 0x38, 0x90, 0x3c, 0x0f, 0x13, 0x8c, 0x0e, 0x3b, 0x29, 0xa0, 0x2c, - 0x22, 0x25, 0x63, 0x80, 0x91, 0x68, 0x7d, 0xda, 0x27, 0x60, 0x50, 0xf0, 0xe4, 0x6b, 0x55, 0xbf, - 0x36, 0xc0, 0x99, 0xb9, 0xac, 0xe7, 0x02, 0x36, 0x7c, 0x72, 0xed, 0xd7, 0x86, 0xfc, 0xf2, 0x18, - 0x6f, 0xd9, 0xea, 0xb6, 0x79, 0xf4, 0xad, 0x01, 0x44, 0x06, 0xbf, 0xc9, 0x15, 0x18, 0x63, 0x5c, - 0x02, 0x81, 0xf1, 0x10, 0xb5, 0xfd, 0x5a, 0x0c, 0x4a, 0x6e, 0xc0, 0xb9, 0x08, 0x84, 0xdb, 0xa0, - 0xfc, 0x49, 0x42, 0xbf, 0x96, 0x8a, 0x53, 0xbf, 0x59, 0x88, 0xa6, 0xa6, 0x39, 0x86, 0x8e, 0xb8, - 0x08, 0x03, 0xb6, 0xd3, 0xac, 0x77, 0x9d, 0x96, 0x18, 0x7b, 0x25, 0xdb, 0x69, 0xde, 0x75, 0x5a, - 0xe4, 0x3c, 0x94, 0x58, 0xef, 0x98, 0x86, 0x18, 0x62, 0xfd, 0x7a, 0xa7, 0x53, 0x35, 0x48, 0x99, - 0x77, 0x08, 0x86, 0x37, 0xad, 0x37, 0x70, 0x6b, 0xcf, 0x9d, 0x12, 0xfa, 0xf9, 0x8a, 0x97, 0x40, - 0x62, 0x3f, 0x61, 0xd0, 0x53, 0x7e, 0x10, 0x10, 0x63, 0x61, 0xe0, 0xb6, 0xc4, 0xe0, 0x7d, 0x12, - 0x67, 0x21, 0x90, 0x21, 0x0b, 0xbe, 0x89, 0x31, 0x48, 0x05, 0x48, 0x48, 0xd5, 0xb6, 0x0d, 0x73, - 0xdd, 0xa4, 0xfc, 0x05, 0x49, 0x3f, 0xbf, 0xf8, 0x4d, 0x62, 0xb5, 0x71, 0x9f, 0xc9, 0xa2, 0x80, - 0x90, 0x37, 0xb9, 0x12, 0x72, 0x3a, 0x5c, 0xfb, 0x78, 0xdf, 0x72, 0x3b, 0x2d, 0x86, 0x42, 0xcd, - 0xc4, 0xf2, 0xb8, 0x10, 0xaa, 0x7f, 0xbd, 0x98, 0xcc, 0x4f, 0x74, 0x2c, 0x76, 0xcd, 0x3c, 0x80, - 0x48, 0x3f, 0x16, 0x5e, 0xae, 0x05, 0xde, 0xed, 0x21, 0x26, 0x83, 0x87, 0x54, 0x96, 0x5c, 0x83, - 0x41, 0xfe, 0x45, 0xd5, 0x8a, 0xb0, 0x77, 0xd0, 0x45, 0xcc, 0xed, 0x98, 0xeb, 0xeb, 0xe8, 0x4f, - 0x16, 0xa0, 0xc9, 0x15, 0x18, 0xa8, 0x2c, 0xd5, 0x6a, 0xe5, 0x25, 0xff, 0xa6, 0x18, 0xdf, 0xb2, - 0x18, 0x96, 0x5b, 0x77, 0x75, 0xcb, 0xd5, 0x7c, 0x24, 0x79, 0x0e, 0x4a, 0xd5, 0x15, 0x24, 0xe3, - 0x2f, 0x34, 0x87, 0x77, 0xb6, 0x27, 0x07, 0xcc, 0x0e, 0xa7, 0x12, 0x28, 0xac, 0xf7, 0x5e, 0xb5, - 0x22, 0xb9, 0x4b, 0xf0, 0x7a, 0x1f, 0x9a, 0x06, 0x5e, 0x3b, 0x6b, 0x01, 0x9a, 0xbc, 0x02, 0x23, - 0x35, 0xea, 0x98, 0x7a, 0x6b, 0xa9, 0x8b, 0x5b, 0x45, 0x29, 0x6c, 0xa3, 0x8b, 0xf0, 0xba, 0x85, - 0x08, 0x2d, 0x42, 0x46, 0x2e, 0x43, 0x71, 0xde, 0xb4, 0xfc, 0xe7, 0x12, 0xe8, 0x4f, 0xbf, 0x61, - 0x5a, 0x9e, 0x86, 0x50, 0xf2, 0x1c, 0x14, 0x6e, 0xaf, 0x56, 0x85, 0x27, 0x18, 0xf2, 0x7a, 0xdf, - 0x8b, 0x84, 0x80, 0xbc, 0xbd, 0x5a, 0x25, 0xaf, 0xc0, 0x10, 0x5b, 0xc4, 0xa8, 0xd5, 0xa0, 0xae, - 0x32, 0x8c, 0x1f, 0xc3, 0x43, 0x16, 0xfa, 0x40, 0xd9, 0xa7, 0x23, 0xa0, 0x54, 0xff, 0x8f, 0x7c, - 0x7a, 0x02, 0xa9, 0x63, 0x18, 0xea, 0x07, 0xbc, 0x45, 0x8e, 0x29, 0x58, 0xf1, 0x10, 0x0a, 0xb6, - 0x0e, 0x67, 0xca, 0x46, 0xdb, 0xb4, 0xca, 0xf8, 0xd3, 0x5d, 0x9c, 0x2b, 0xe3, 0xd4, 0x21, 0x3d, - 0x05, 0x8c, 0xa1, 0xc5, 0xf7, 0xf0, 0xe0, 0xc2, 0x0c, 0x55, 0xd7, 0x39, 0xae, 0xde, 0x5e, 0xd7, - 0xeb, 0x0d, 0x9e, 0x7b, 0x49, 0x8b, 0x33, 0x55, 0x7f, 0x26, 0xbf, 0x4b, 0xce, 0xab, 0xc7, 0x51, - 0xfa, 0xea, 0xd7, 0xf2, 0xbd, 0xd3, 0x8e, 0x3d, 0x96, 0x42, 0xf9, 0x93, 0x7c, 0x4a, 0x12, 0xb0, - 0x43, 0x49, 0xe2, 0x1a, 0x0c, 0x72, 0x36, 0x81, 0x1b, 0x2f, 0xce, 0x66, 0x5c, 0x59, 0x71, 0x16, - 0xf5, 0xd1, 0x64, 0x09, 0xce, 0x95, 0xd7, 0xd7, 0x69, 0xc3, 0x0b, 0xc3, 0x4c, 0x2f, 0x85, 0x01, - 0x5f, 0x79, 0x58, 0x5d, 0x81, 0x0f, 0xc3, 0x54, 0x63, 0x60, 0x93, 0xd4, 0x72, 0x64, 0x15, 0x2e, - 0xc4, 0xe1, 0x35, 0xbe, 0x05, 0x28, 0x4a, 0x91, 0x76, 0x13, 0x1c, 0xf9, 0x7f, 0x5a, 0x46, 0xd9, - 0xb4, 0x56, 0xe2, 0x54, 0xdd, 0xdf, 0xab, 0x95, 0x38, 0x6f, 0xa7, 0x96, 0x53, 0xbf, 0x55, 0x90, - 0x73, 0xa5, 0x3d, 0xbe, 0x0e, 0x57, 0x37, 0x23, 0x6e, 0xd6, 0x7b, 0x1d, 0x32, 0xaf, 0x88, 0x68, - 0x25, 0x46, 0xd7, 0xf1, 0x3d, 0x12, 0x83, 0x68, 0x09, 0x08, 0x94, 0xd7, 0xa1, 0x80, 0x92, 0x54, - 0xa1, 0x58, 0x76, 0x9a, 0xdc, 0xbc, 0xdd, 0xed, 0x01, 0x97, 0xee, 0x34, 0xdd, 0xf4, 0x07, 0x5c, - 0x8c, 0x85, 0xfa, 0xe7, 0xf3, 0x3d, 0xd2, 0x9b, 0x3d, 0x96, 0x93, 0xc8, 0x5f, 0xca, 0x67, 0x25, - 0x2a, 0x3b, 0xa9, 0xae, 0x63, 0x1f, 0xb2, 0x70, 0x4e, 0xb6, 0x5f, 0xdd, 0x11, 0x0a, 0xe7, 0x0f, - 0xf3, 0x59, 0x59, 0xd7, 0x4e, 0x85, 0x73, 0xb0, 0x09, 0x32, 0x55, 0xa4, 0x8f, 0xb1, 0xcd, 0x2d, - 0xab, 0x42, 0xff, 0x01, 0xdd, 0xa7, 0xd2, 0x44, 0x7a, 0x3a, 0x84, 0x0f, 0xa5, 0xa5, 0x7f, 0x94, - 0xcf, 0xcc, 0x2e, 0x78, 0x2a, 0xd3, 0xa3, 0x94, 0xe9, 0xe9, 0xd0, 0x3f, 0xd4, 0xd0, 0x4f, 0x95, - 0xe9, 0xe9, 0xd8, 0x3f, 0x94, 0x9e, 0xfe, 0x41, 0x3e, 0x3d, 0x7f, 0xe6, 0x31, 0x28, 0xe9, 0x51, - 0x78, 0x38, 0xfa, 0xdd, 0x50, 0x3c, 0x54, 0x37, 0xf4, 0x1f, 0xc2, 0x8a, 0x4a, 0x0a, 0xf4, 0xd8, - 0x46, 0xfd, 0xf7, 0xab, 0x40, 0x8f, 0x60, 0xc8, 0x3f, 0xce, 0x02, 0xfd, 0xa9, 0x42, 0x32, 0x67, - 0xec, 0xe3, 0xba, 0x26, 0x39, 0x07, 0x5c, 0x93, 0xfc, 0x72, 0xe4, 0x1d, 0x38, 0x13, 0xca, 0x52, - 0x8e, 0x32, 0x86, 0xd7, 0x47, 0x0d, 0x86, 0xaa, 0xbf, 0xcf, 0x70, 0x22, 0x1c, 0x4e, 0x9c, 0x5a, - 0xfd, 0x5e, 0x21, 0x99, 0x78, 0xf7, 0xb4, 0x37, 0x0e, 0xd8, 0x1b, 0x77, 0xe1, 0xc2, 0x4c, 0xd7, - 0x71, 0xa8, 0xe5, 0xa5, 0x77, 0x0a, 0x1e, 0xde, 0x37, 0x38, 0x45, 0x3d, 0xd9, 0x39, 0x19, 0x85, - 0x19, 0x5b, 0xf1, 0xba, 0x21, 0xce, 0x76, 0x20, 0x64, 0xdb, 0xe5, 0x14, 0x69, 0x6c, 0xd3, 0x0b, - 0xab, 0xbf, 0x97, 0x4f, 0xa6, 0x4a, 0x3e, 0xed, 0xfa, 0x83, 0x75, 0xbd, 0xfa, 0xe5, 0x42, 0x3c, - 0x5d, 0xf4, 0xe9, 0x02, 0x71, 0xf0, 0xee, 0xf0, 0x25, 0x89, 0xe3, 0x46, 0xfa, 0x0a, 0x1f, 0x9e, - 0xf5, 0x15, 0x3e, 0x5e, 0xfd, 0x95, 0x62, 0x3c, 0xf5, 0xf6, 0x69, 0x77, 0x1c, 0x5f, 0x77, 0x90, - 0x65, 0x38, 0x27, 0xe6, 0x36, 0x1f, 0x84, 0xe9, 0x26, 0xc4, 0xfc, 0xc5, 0xb3, 0xd6, 0x89, 0x69, - 0xb1, 0xeb, 0x52, 0xa7, 0xee, 0xe9, 0xee, 0x83, 0x3a, 0xe6, 0xa7, 0xd0, 0x52, 0x0b, 0x32, 0x86, - 0x62, 0x56, 0x8b, 0x32, 0x1c, 0x0c, 0x19, 0xfa, 0x13, 0x62, 0x82, 0x61, 0x5a, 0x41, 0xf5, 0x37, - 0x72, 0x30, 0x1e, 0xff, 0x1c, 0x32, 0x05, 0x83, 0xec, 0x77, 0xf0, 0xec, 0x5e, 0xca, 0x89, 0xcd, - 0x39, 0xf2, 0x2b, 0x79, 0x9f, 0x86, 0xbc, 0x0a, 0x43, 0xe8, 0xfd, 0x80, 0x05, 0xf2, 0x61, 0xb4, - 0x83, 0xb0, 0x00, 0x26, 0x6a, 0xe5, 0xc5, 0x42, 0x52, 0xf2, 0x26, 0x0c, 0x57, 0x43, 0x37, 0x2f, - 0x71, 0xe7, 0x85, 0xde, 0xa5, 0x52, 0xc9, 0x90, 0x40, 0x93, 0xa9, 0xd5, 0x6f, 0xe7, 0xe3, 0x29, - 0xe2, 0x4f, 0x55, 0xfd, 0x60, 0xaa, 0xfe, 0xfc, 0x22, 0x57, 0xf5, 0x3b, 0xa6, 0x65, 0x90, 0x27, - 0xe0, 0xfc, 0xdd, 0xda, 0xac, 0x56, 0xbf, 0x53, 0x5d, 0xaa, 0xd4, 0xef, 0x2e, 0xd5, 0x56, 0x66, - 0x67, 0xaa, 0x73, 0xd5, 0xd9, 0xca, 0x78, 0x1f, 0x39, 0x0b, 0x67, 0x42, 0xd4, 0xfc, 0xdd, 0xc5, - 0xf2, 0xd2, 0x78, 0x8e, 0x4c, 0xc0, 0x68, 0x08, 0x9c, 0x5e, 0x5e, 0x1d, 0xcf, 0x3f, 0xff, 0x09, - 0x18, 0x46, 0xf7, 0x36, 0x7e, 0x1d, 0x4f, 0x46, 0x60, 0x70, 0x79, 0xba, 0x36, 0xab, 0xdd, 0x43, - 0x26, 0x00, 0xa5, 0xca, 0xec, 0x12, 0x63, 0x98, 0x7b, 0xfe, 0xff, 0xce, 0x01, 0xd4, 0xe6, 0x56, - 0x57, 0x04, 0xe1, 0x30, 0x0c, 0x54, 0x97, 0xee, 0x95, 0x17, 0xaa, 0x8c, 0x6e, 0x10, 0x8a, 0xcb, - 0x2b, 0xb3, 0xac, 0x86, 0x21, 0xe8, 0x9f, 0x59, 0x58, 0xae, 0xcd, 0x8e, 0xe7, 0x19, 0x50, 0x9b, - 0x2d, 0x57, 0xc6, 0x0b, 0x0c, 0x78, 0x5f, 0xab, 0xae, 0xce, 0x8e, 0x17, 0xd9, 0x9f, 0x0b, 0xb5, - 0xd5, 0xf2, 0xea, 0x78, 0x3f, 0xfb, 0x73, 0x0e, 0xff, 0x2c, 0x31, 0x66, 0xb5, 0xd9, 0x55, 0xfc, - 0x31, 0xc0, 0x9a, 0x30, 0xe7, 0xff, 0x1a, 0x64, 0x28, 0xc6, 0xba, 0x52, 0xd5, 0xc6, 0x87, 0xd8, - 0x0f, 0xc6, 0x92, 0xfd, 0x00, 0xd6, 0x38, 0x6d, 0x76, 0x71, 0xf9, 0xde, 0xec, 0xf8, 0x30, 0xe3, - 0xb5, 0x78, 0x87, 0x81, 0x47, 0xd8, 0x9f, 0xda, 0x22, 0xfb, 0x73, 0x94, 0x71, 0xd2, 0x66, 0xcb, - 0x0b, 0x2b, 0xe5, 0xd5, 0xf9, 0xf1, 0x31, 0xd6, 0x1e, 0xe4, 0x79, 0x86, 0x97, 0x5c, 0x2a, 0x2f, - 0xce, 0x8e, 0x8f, 0x0b, 0x9a, 0xca, 0x42, 0x75, 0xe9, 0xce, 0xf8, 0x04, 0x36, 0xe4, 0xbd, 0x45, - 0xfc, 0x41, 0x58, 0x01, 0xfc, 0xeb, 0xec, 0xf3, 0x3f, 0x08, 0xa5, 0xe5, 0x1a, 0x8e, 0x82, 0x8b, - 0x70, 0x76, 0xb9, 0x56, 0x5f, 0x7d, 0x6f, 0x65, 0x36, 0x26, 0xef, 0x09, 0x18, 0xf5, 0x11, 0x0b, - 0xd5, 0xa5, 0xbb, 0x9f, 0xe3, 0xd2, 0xf6, 0x41, 0x8b, 0xe5, 0x99, 0xe5, 0xda, 0x78, 0x9e, 0xf5, - 0x8a, 0x0f, 0xba, 0x5f, 0x5d, 0xaa, 0x2c, 0xdf, 0xaf, 0x8d, 0x17, 0x9e, 0x7f, 0x08, 0x23, 0x3c, - 0x4f, 0xe7, 0xb2, 0x63, 0x36, 0x4d, 0x8b, 0x3c, 0x05, 0x4f, 0x54, 0x66, 0xef, 0x55, 0x67, 0x66, - 0xeb, 0xcb, 0x5a, 0xf5, 0x56, 0x75, 0x29, 0x56, 0xd3, 0x79, 0x98, 0x88, 0xa2, 0xcb, 0x2b, 0xd5, - 0xf1, 0x1c, 0xb9, 0x00, 0x24, 0x0a, 0xbe, 0x5d, 0x5e, 0x9c, 0x1b, 0xcf, 0x13, 0x05, 0xce, 0x45, - 0xe1, 0xd5, 0xa5, 0xd5, 0xbb, 0x4b, 0xb3, 0xe3, 0x85, 0xe7, 0xff, 0x5a, 0x0e, 0xce, 0xa7, 0xc6, - 0x72, 0x26, 0x2a, 0x3c, 0x3d, 0xbb, 0x50, 0xae, 0xad, 0x56, 0x67, 0x6a, 0xb3, 0x65, 0x6d, 0x66, - 0xbe, 0x3e, 0x53, 0x5e, 0x9d, 0xbd, 0xb5, 0xac, 0xbd, 0x57, 0xbf, 0x35, 0xbb, 0x34, 0xab, 0x95, - 0x17, 0xc6, 0xfb, 0xc8, 0x73, 0x30, 0x99, 0x41, 0x53, 0x9b, 0x9d, 0xb9, 0xab, 0x55, 0x57, 0xdf, - 0x1b, 0xcf, 0x91, 0x67, 0xe1, 0xa9, 0x4c, 0x22, 0xf6, 0x7b, 0x3c, 0x4f, 0x9e, 0x86, 0x4b, 0x59, - 0x24, 0xef, 0x2e, 0x8c, 0x17, 0x9e, 0xff, 0xf9, 0x1c, 0x90, 0x64, 0x30, 0x5e, 0xf2, 0x0c, 0x5c, - 0x66, 0x7a, 0x51, 0xcf, 0x6e, 0xe0, 0xb3, 0xf0, 0x54, 0x2a, 0x85, 0xd4, 0xbc, 0x49, 0x78, 0x32, - 0x83, 0x44, 0x34, 0xee, 0x32, 0x28, 0xe9, 0x04, 0xd8, 0xb4, 0x5f, 0xcf, 0xc1, 0xf9, 0x54, 0x0f, - 0x18, 0x72, 0x15, 0x3e, 0x56, 0xae, 0x2c, 0xb2, 0xbe, 0x99, 0x59, 0xad, 0x2e, 0x2f, 0xd5, 0xea, - 0x8b, 0x73, 0xe5, 0x3a, 0xd3, 0xbe, 0xbb, 0xb5, 0x58, 0x6f, 0x5e, 0x01, 0xb5, 0x07, 0xe5, 0xcc, - 0x7c, 0x79, 0xe9, 0x16, 0x1b, 0x7e, 0xe4, 0x63, 0xf0, 0x4c, 0x26, 0xdd, 0xec, 0x52, 0x79, 0x7a, - 0x61, 0xb6, 0x32, 0x9e, 0x27, 0x1f, 0x87, 0x67, 0x33, 0xa9, 0x2a, 0xd5, 0x1a, 0x27, 0x2b, 0x4c, - 0x57, 0xbe, 0xfd, 0x3f, 0x3d, 0xdd, 0xf7, 0xed, 0x3f, 0x7e, 0x3a, 0xf7, 0x87, 0x7f, 0xfc, 0x74, - 0xee, 0x9f, 0xfd, 0xf1, 0xd3, 0xb9, 0xcf, 0xdf, 0xd8, 0x4f, 0x90, 0x65, 0x3e, 0x6d, 0xad, 0x95, - 0xf0, 0x36, 0xfa, 0xe5, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xb9, 0x4b, 0xf8, 0x16, 0xde, 0x81, - 0x01, 0x00, + 0x43, 0xd1, 0x99, 0x41, 0x3b, 0x8f, 0x14, 0x78, 0x75, 0xe2, 0xce, 0xdb, 0x56, 0x73, 0x85, 0x3a, + 0x6d, 0xd6, 0xd4, 0xe7, 0x81, 0x88, 0xa6, 0x3a, 0x78, 0xe8, 0xc1, 0x3f, 0x0e, 0xbd, 0x19, 0x34, + 0xf1, 0x11, 0xfc, 0x34, 0x04, 0x3f, 0x6c, 0x02, 0x86, 0x79, 0x20, 0x3d, 0x2e, 0x34, 0x74, 0x61, + 0xd0, 0x80, 0x83, 0x50, 0x5e, 0xe7, 0x41, 0x78, 0x57, 0x70, 0x0f, 0x72, 0x4d, 0xfc, 0x52, 0xbf, + 0x5c, 0x48, 0xcb, 0x8a, 0xb3, 0x2f, 0x45, 0x0b, 0xa7, 0xd5, 0xfc, 0xae, 0xa6, 0xd5, 0x53, 0x56, + 0xb7, 0x5d, 0xd7, 0x3b, 0x9d, 0xfa, 0x03, 0xb3, 0x85, 0x4f, 0xb8, 0x70, 0xe1, 0xd3, 0x46, 0xad, + 0x6e, 0xbb, 0xdc, 0xe9, 0xcc, 0x72, 0x20, 0x79, 0x0e, 0x4e, 0x33, 0x3a, 0xec, 0xa4, 0x80, 0xb2, + 0x88, 0x94, 0x8c, 0x01, 0x46, 0xa2, 0xf5, 0x69, 0x2f, 0xc2, 0xa0, 0xe0, 0xc9, 0xd7, 0xaa, 0x7e, + 0x6d, 0x80, 0x33, 0x73, 0x59, 0xcf, 0x05, 0x6c, 0xf8, 0xe4, 0xda, 0xaf, 0x0d, 0xf9, 0xe5, 0x31, + 0xde, 0xb2, 0xd5, 0x6d, 0xf3, 0xe8, 0x5b, 0x03, 0x88, 0x0c, 0x7e, 0x93, 0x2b, 0x30, 0xc6, 0xb8, + 0x04, 0x02, 0xe3, 0x21, 0x6a, 0xfb, 0xb5, 0x18, 0x94, 0xdc, 0x80, 0xb3, 0x11, 0x08, 0xb7, 0x41, + 0xf9, 0x93, 0x84, 0x7e, 0x2d, 0x15, 0xa7, 0x7e, 0xab, 0x10, 0xcd, 0xd5, 0x73, 0x08, 0x1d, 0x71, + 0x01, 0x06, 0x6c, 0xa7, 0x59, 0xef, 0x3a, 0x2d, 0x31, 0xf6, 0x4a, 0xb6, 0xd3, 0xbc, 0xeb, 0xb4, + 0xc8, 0x39, 0x28, 0xb1, 0xde, 0x31, 0x0d, 0x31, 0xc4, 0xfa, 0xf5, 0x4e, 0xa7, 0x6a, 0x90, 0x32, + 0xef, 0x10, 0x0c, 0x6f, 0x5a, 0x6f, 0xe0, 0xd6, 0x9e, 0x3b, 0x25, 0xf4, 0xf3, 0x15, 0x2f, 0x81, + 0xc4, 0x7e, 0xc2, 0xa0, 0xa7, 0xfc, 0x20, 0x20, 0xc6, 0xc2, 0xc0, 0x6d, 0x89, 0xc1, 0xfb, 0x24, + 0xce, 0x42, 0x20, 0x43, 0x16, 0x7c, 0x13, 0x63, 0x90, 0x0a, 0x90, 0x90, 0xaa, 0x6d, 0x1b, 0xe6, + 0x03, 0x93, 0xf2, 0x17, 0x24, 0xfd, 0xfc, 0xe2, 0x37, 0x89, 0xd5, 0xc6, 0x7d, 0x26, 0x0b, 0x02, + 0x42, 0xde, 0xe0, 0x4a, 0xc8, 0xe9, 0x70, 0xed, 0xe3, 0x7d, 0xcb, 0xed, 0xb4, 0x18, 0x0a, 0x35, + 0x13, 0xcb, 0xe3, 0x42, 0xa8, 0xfe, 0xb5, 0x62, 0x32, 0x61, 0xd3, 0xa1, 0xd8, 0x35, 0x73, 0x00, + 0x22, 0x1f, 0x5b, 0x78, 0xb9, 0x16, 0x78, 0xb7, 0x87, 0x98, 0x0c, 0x1e, 0x52, 0x59, 0x72, 0x0d, + 0x06, 0xf9, 0x17, 0x55, 0x2b, 0xc2, 0xde, 0x41, 0x17, 0x31, 0xb7, 0x63, 0x3e, 0x78, 0x80, 0xfe, + 0x64, 0x01, 0x9a, 0x5c, 0x81, 0x81, 0xca, 0x62, 0xad, 0x56, 0x5e, 0xf4, 0x6f, 0x8a, 0xf1, 0x2d, + 0x8b, 0x61, 0xb9, 0x75, 0x57, 0xb7, 0x5c, 0xcd, 0x47, 0x92, 0x67, 0xa1, 0x54, 0x5d, 0x46, 0x32, + 0xfe, 0x42, 0x73, 0x78, 0x6b, 0x73, 0x62, 0xc0, 0xec, 0x70, 0x2a, 0x81, 0xc2, 0x7a, 0xef, 0x55, + 0x2b, 0x92, 0xbb, 0x04, 0xaf, 0xf7, 0x91, 0x69, 0xe0, 0xb5, 0xb3, 0x16, 0xa0, 0xc9, 0xcb, 0x30, + 0x52, 0xa3, 0x8e, 0xa9, 0xb7, 0x16, 0xbb, 0xb8, 0x55, 0x94, 0xc2, 0x36, 0xba, 0x08, 0xaf, 0x5b, + 0x88, 0xd0, 0x22, 0x64, 0xe4, 0x32, 0x14, 0xe7, 0x4c, 0xcb, 0x7f, 0x2e, 0x81, 0xfe, 0xf4, 0x6b, + 0xa6, 0xe5, 0x69, 0x08, 0x25, 0xcf, 0x42, 0xe1, 0xf6, 0x4a, 0x55, 0x78, 0x82, 0x21, 0xaf, 0xf7, + 0xbc, 0x48, 0x08, 0xc8, 0xdb, 0x2b, 0x55, 0xf2, 0x32, 0x0c, 0xb1, 0x45, 0x8c, 0x5a, 0x0d, 0xea, + 0x2a, 0xc3, 0xf8, 0x31, 0x3c, 0x64, 0xa1, 0x0f, 0x94, 0x7d, 0x3a, 0x02, 0x4a, 0xf5, 0xff, 0xcc, + 0xa7, 0x67, 0xd4, 0x3a, 0x84, 0xa1, 0xbe, 0xc7, 0x5b, 0xe4, 0x98, 0x82, 0x15, 0xf7, 0xa1, 0x60, + 0x0f, 0xe0, 0x54, 0xd9, 0x68, 0x9b, 0x56, 0x19, 0x7f, 0xba, 0x0b, 0xb3, 0x65, 0x9c, 0x3a, 0xa4, + 0xa7, 0x80, 0x31, 0xb4, 0xf8, 0x1e, 0x1e, 0x5c, 0x98, 0xa1, 0xea, 0x3a, 0xc7, 0xd5, 0xdb, 0x0f, + 0xf4, 0x7a, 0x83, 0x27, 0xa3, 0xd2, 0xe2, 0x4c, 0xd5, 0x9f, 0xce, 0x6f, 0x93, 0x04, 0xec, 0x38, + 0x4a, 0x5f, 0xfd, 0x5a, 0xbe, 0x77, 0x1e, 0xb6, 0x63, 0x29, 0x94, 0x3f, 0xca, 0xa7, 0x64, 0x45, + 0xdb, 0x97, 0x24, 0xae, 0xc1, 0x20, 0x67, 0x13, 0xb8, 0xf1, 0xe2, 0x6c, 0xc6, 0x95, 0x15, 0x67, + 0x51, 0x1f, 0x4d, 0x16, 0xe1, 0x6c, 0xf9, 0xc1, 0x03, 0xda, 0xf0, 0xc2, 0x30, 0xd3, 0x8b, 0x61, + 0xc0, 0x57, 0x1e, 0x56, 0x57, 0xe0, 0xc3, 0x30, 0xd5, 0x18, 0xd8, 0x24, 0xb5, 0x1c, 0x59, 0x81, + 0xf3, 0x71, 0x78, 0x8d, 0x6f, 0x01, 0x8a, 0x52, 0xa4, 0xdd, 0x04, 0x47, 0xfe, 0x9f, 0x96, 0x51, + 0x36, 0xad, 0x95, 0x38, 0x55, 0xf7, 0xf7, 0x6a, 0x25, 0xce, 0xdb, 0xa9, 0xe5, 0xd4, 0x6f, 0x17, + 0xe4, 0xe4, 0x71, 0xc7, 0xd7, 0xe1, 0xea, 0x66, 0xc4, 0xcd, 0x7a, 0xa7, 0x43, 0xe6, 0x65, 0x11, + 0xad, 0xc4, 0xe8, 0x3a, 0xbe, 0x47, 0x62, 0x10, 0x2d, 0x01, 0x81, 0xf2, 0x3a, 0x14, 0x50, 0x92, + 0x2a, 0x14, 0xcb, 0x4e, 0x93, 0x9b, 0xb7, 0xdb, 0x3d, 0xe0, 0xd2, 0x9d, 0xa6, 0x9b, 0xfe, 0x80, + 0x8b, 0xb1, 0x50, 0xff, 0x7c, 0xbe, 0x47, 0xbe, 0xb7, 0x63, 0x39, 0x89, 0xfc, 0x5c, 0x3e, 0x2b, + 0x73, 0xdb, 0x51, 0x75, 0x1d, 0xfb, 0x80, 0x85, 0x73, 0xb4, 0xfd, 0xea, 0x0e, 0x50, 0x38, 0xbf, + 0x9f, 0xcf, 0x4a, 0x43, 0x77, 0x22, 0x9c, 0xbd, 0x4d, 0x90, 0xa9, 0x22, 0x3d, 0xc6, 0x36, 0xb7, + 0xac, 0x0a, 0xfd, 0x7b, 0x74, 0x9f, 0x4a, 0x13, 0xe9, 0xc9, 0x10, 0xde, 0x97, 0x96, 0xfe, 0x41, + 0x3e, 0x33, 0xdd, 0xe2, 0x89, 0x4c, 0x0f, 0x52, 0xa6, 0x27, 0x43, 0x7f, 0x5f, 0x43, 0x3f, 0x55, + 0xa6, 0x27, 0x63, 0x7f, 0x5f, 0x7a, 0xfa, 0x7b, 0xf9, 0xf4, 0x84, 0xa2, 0x87, 0xa0, 0xa4, 0x07, + 0xe1, 0xe1, 0xe8, 0x77, 0x43, 0x71, 0x5f, 0xdd, 0xd0, 0xbf, 0x0f, 0x2b, 0x2a, 0x29, 0xd0, 0x43, + 0x1b, 0xf5, 0x1f, 0x55, 0x81, 0x1e, 0xc0, 0x90, 0x3f, 0xce, 0x02, 0xfd, 0xc9, 0x42, 0x32, 0x89, + 0xee, 0x71, 0x5d, 0x93, 0x9c, 0x3d, 0xae, 0x49, 0x7e, 0x39, 0xf2, 0x36, 0x9c, 0x0a, 0x65, 0x29, + 0x47, 0x19, 0xc3, 0xeb, 0xa3, 0x06, 0x43, 0xd5, 0xdf, 0x63, 0x38, 0x11, 0x0e, 0x27, 0x4e, 0xad, + 0x7e, 0xbf, 0x90, 0xcc, 0x44, 0x7c, 0xd2, 0x1b, 0x7b, 0xec, 0x8d, 0xbb, 0x70, 0x7e, 0xba, 0xeb, + 0x38, 0xd4, 0xf2, 0xd2, 0x3b, 0x05, 0x0f, 0xef, 0x1b, 0x9c, 0xa2, 0x9e, 0xec, 0x9c, 0x8c, 0xc2, + 0x8c, 0xad, 0x78, 0xdd, 0x10, 0x67, 0x3b, 0x10, 0xb2, 0xed, 0x72, 0x8a, 0x34, 0xb6, 0xe9, 0x85, + 0xd5, 0xdf, 0xc9, 0x27, 0x73, 0x47, 0x9f, 0x74, 0xfd, 0xde, 0xba, 0x5e, 0xfd, 0x72, 0x21, 0x9e, + 0x3f, 0xfb, 0x64, 0x81, 0xd8, 0x7b, 0x77, 0xf8, 0x92, 0xc4, 0x71, 0x23, 0x7d, 0x85, 0x0f, 0xcf, + 0xfa, 0x0a, 0x1f, 0xaf, 0xfe, 0x72, 0x31, 0x9e, 0x8b, 0xfc, 0xa4, 0x3b, 0x0e, 0xaf, 0x3b, 0xc8, + 0x12, 0x9c, 0x15, 0x73, 0x9b, 0x0f, 0xc2, 0x74, 0x13, 0x62, 0xfe, 0xe2, 0x59, 0xeb, 0xc4, 0xb4, + 0xd8, 0x75, 0xa9, 0x53, 0xf7, 0x74, 0xf7, 0x61, 0x1d, 0xf3, 0x53, 0x68, 0xa9, 0x05, 0x19, 0x43, + 0x31, 0xab, 0x45, 0x19, 0x0e, 0x86, 0x0c, 0xfd, 0x09, 0x31, 0xc1, 0x30, 0xad, 0xa0, 0xfa, 0xeb, + 0x39, 0x18, 0x8f, 0x7f, 0x0e, 0x99, 0x84, 0x41, 0xf6, 0x3b, 0x78, 0x76, 0x2f, 0xe5, 0xc4, 0xe6, + 0x1c, 0xf9, 0x95, 0xbc, 0x4f, 0x43, 0x5e, 0x81, 0x21, 0xf4, 0x7e, 0xc0, 0x02, 0xf9, 0x30, 0xda, + 0x41, 0x58, 0x00, 0x13, 0xb5, 0xf2, 0x62, 0x21, 0x29, 0x79, 0x03, 0x86, 0xab, 0xa1, 0x9b, 0x97, + 0xb8, 0xf3, 0x42, 0xef, 0x52, 0xa9, 0x64, 0x48, 0xa0, 0xc9, 0xd4, 0xea, 0x77, 0xf3, 0xf1, 0x9c, + 0xf9, 0x27, 0xaa, 0xbe, 0x47, 0xd3, 0xf4, 0xeb, 0x05, 0xc8, 0x4a, 0xe0, 0x7f, 0xb2, 0xc1, 0xff, + 0x53, 0x70, 0x36, 0x2e, 0x9b, 0x0a, 0x93, 0x46, 0x7f, 0xef, 0x6b, 0xb4, 0xc9, 0xad, 0xcd, 0x89, + 0xa7, 0xd7, 0x45, 0xc1, 0x30, 0xd7, 0x2f, 0xab, 0x2c, 0xf5, 0x62, 0x2d, 0xb5, 0x92, 0xd4, 0x9e, + 0xf9, 0x90, 0x3c, 0x10, 0x3a, 0xe6, 0x3d, 0xf3, 0x73, 0xf9, 0x64, 0xcf, 0x9c, 0x1c, 0x8a, 0x71, + 0x8a, 0xe7, 0x16, 0xf8, 0xda, 0x79, 0xc7, 0xb4, 0x0c, 0x72, 0x11, 0xce, 0xdd, 0xad, 0xcd, 0x68, + 0xf5, 0x3b, 0xd5, 0xc5, 0x4a, 0xfd, 0xee, 0x62, 0x6d, 0x79, 0x66, 0xba, 0x3a, 0x5b, 0x9d, 0xa9, + 0x8c, 0xf7, 0x91, 0x33, 0x70, 0x2a, 0x44, 0xcd, 0xdd, 0x5d, 0x28, 0x2f, 0x8e, 0xe7, 0xc8, 0x69, + 0x18, 0x0d, 0x81, 0x53, 0x4b, 0x2b, 0xe3, 0xf9, 0xe7, 0x3e, 0x01, 0xc3, 0xe8, 0x2f, 0xcb, 0xfd, + 0x7b, 0xc8, 0x08, 0x0c, 0x2e, 0x4d, 0xd5, 0x66, 0xb4, 0x7b, 0xc8, 0x04, 0xa0, 0x54, 0x99, 0x59, + 0x64, 0x0c, 0x73, 0xcf, 0xfd, 0x3f, 0x39, 0x80, 0xda, 0xec, 0xca, 0xb2, 0x20, 0x1c, 0x86, 0x81, + 0xea, 0xe2, 0xbd, 0xf2, 0x7c, 0x95, 0xd1, 0x0d, 0x42, 0x71, 0x69, 0x79, 0x86, 0xd5, 0x30, 0x04, + 0xfd, 0xd3, 0xf3, 0x4b, 0xb5, 0x99, 0xf1, 0x3c, 0x03, 0x6a, 0x33, 0xe5, 0xca, 0x78, 0x81, 0x01, + 0xef, 0x6b, 0xd5, 0x95, 0x99, 0xf1, 0x22, 0xfb, 0x73, 0xbe, 0xb6, 0x52, 0x5e, 0x19, 0xef, 0x67, + 0x7f, 0xce, 0xe2, 0x9f, 0x25, 0xc6, 0xac, 0x36, 0xb3, 0x82, 0x3f, 0x06, 0x58, 0x13, 0x66, 0xfd, + 0x5f, 0x83, 0x0c, 0xc5, 0x58, 0x57, 0xaa, 0xda, 0xf8, 0x10, 0xfb, 0xc1, 0x58, 0xb2, 0x1f, 0xc0, + 0x1a, 0xa7, 0xcd, 0x2c, 0x2c, 0xdd, 0x9b, 0x19, 0x1f, 0x66, 0xbc, 0x16, 0xee, 0x30, 0xf0, 0x08, + 0xfb, 0x53, 0x5b, 0x60, 0x7f, 0x8e, 0x32, 0x4e, 0xda, 0x4c, 0x79, 0x7e, 0xb9, 0xbc, 0x32, 0x37, + 0x3e, 0xc6, 0xda, 0x83, 0x3c, 0x4f, 0xf1, 0x92, 0x8b, 0xe5, 0x85, 0x99, 0xf1, 0x71, 0x41, 0x53, + 0x99, 0xaf, 0x2e, 0xde, 0x19, 0x3f, 0x8d, 0x0d, 0x79, 0x77, 0x01, 0x7f, 0x10, 0x56, 0x00, 0xff, + 0x3a, 0xf3, 0xdc, 0x0f, 0x42, 0x69, 0xa9, 0x86, 0xcb, 0xea, 0x05, 0x38, 0xb3, 0x54, 0xab, 0xaf, + 0xbc, 0xbb, 0x3c, 0x13, 0x93, 0xf7, 0x69, 0x18, 0xf5, 0x11, 0xf3, 0xd5, 0xc5, 0xbb, 0x9f, 0xe3, + 0xd2, 0xf6, 0x41, 0x0b, 0xe5, 0xe9, 0xa5, 0xda, 0x78, 0x9e, 0xf5, 0x8a, 0x0f, 0xba, 0x5f, 0x5d, + 0xac, 0x2c, 0xdd, 0xaf, 0x8d, 0x17, 0x9e, 0x7b, 0x04, 0x23, 0x3c, 0xf1, 0xef, 0x92, 0x63, 0x36, + 0x4d, 0x8b, 0x3c, 0x09, 0x17, 0x2b, 0x33, 0xf7, 0xaa, 0xd3, 0x33, 0xf5, 0x25, 0xad, 0x7a, 0xab, + 0xba, 0x18, 0xab, 0xe9, 0x1c, 0x9c, 0x8e, 0xa2, 0xcb, 0xcb, 0xd5, 0xf1, 0x1c, 0x39, 0x0f, 0x24, + 0x0a, 0xbe, 0x5d, 0x5e, 0x98, 0x1d, 0xcf, 0x13, 0x05, 0xce, 0x46, 0xe1, 0xd5, 0xc5, 0x95, 0xbb, + 0x8b, 0x33, 0xe3, 0x85, 0xe7, 0xfe, 0x6a, 0x0e, 0xce, 0xa5, 0x06, 0x87, 0x27, 0x2a, 0x3c, 0x35, + 0x33, 0x5f, 0xae, 0xad, 0x54, 0xa7, 0x6b, 0x33, 0x65, 0x6d, 0x7a, 0xae, 0x3e, 0x5d, 0x5e, 0x99, + 0xb9, 0xb5, 0xa4, 0xbd, 0x5b, 0xbf, 0x35, 0xb3, 0x38, 0xa3, 0x95, 0xe7, 0xc7, 0xfb, 0xc8, 0xb3, + 0x30, 0x91, 0x41, 0x53, 0x9b, 0x99, 0xbe, 0xab, 0x55, 0x57, 0xde, 0x1d, 0xcf, 0x91, 0x67, 0xe0, + 0xc9, 0x4c, 0x22, 0xf6, 0x7b, 0x3c, 0x4f, 0x9e, 0x82, 0x4b, 0x59, 0x24, 0xef, 0xcc, 0x8f, 0x17, + 0x9e, 0xfb, 0xd9, 0x1c, 0x90, 0x64, 0x74, 0x6f, 0xf2, 0x34, 0x5c, 0x66, 0x7a, 0x51, 0xcf, 0x6e, + 0xe0, 0x33, 0xf0, 0x64, 0x2a, 0x85, 0xd4, 0xbc, 0x09, 0x78, 0x22, 0x83, 0x44, 0x34, 0xee, 0x32, + 0x28, 0xe9, 0x04, 0xd8, 0xb4, 0x5f, 0xcb, 0xc1, 0xb9, 0x54, 0x97, 0x3a, 0x72, 0x15, 0x3e, 0x56, + 0xae, 0x2c, 0xb0, 0xbe, 0x99, 0x5e, 0xa9, 0x2e, 0x2d, 0xd6, 0xea, 0x0b, 0xb3, 0xe5, 0x3a, 0xd3, + 0xbe, 0xbb, 0xb5, 0x58, 0x6f, 0x5e, 0x01, 0xb5, 0x07, 0xe5, 0xf4, 0x5c, 0x79, 0xf1, 0x16, 0x1b, + 0x7e, 0xe4, 0x63, 0xf0, 0x74, 0x26, 0xdd, 0xcc, 0x62, 0x79, 0x6a, 0x7e, 0xa6, 0x32, 0x9e, 0x27, + 0x1f, 0x87, 0x67, 0x32, 0xa9, 0x2a, 0xd5, 0x1a, 0x27, 0x2b, 0x4c, 0x55, 0xbe, 0xfb, 0x3f, 0x3f, + 0xd5, 0xf7, 0xdd, 0x3f, 0x7c, 0x2a, 0xf7, 0xfb, 0x7f, 0xf8, 0x54, 0xee, 0x9f, 0xff, 0xe1, 0x53, + 0xb9, 0xcf, 0xdf, 0xd8, 0x4d, 0xd4, 0x76, 0x3e, 0x6d, 0xad, 0x96, 0x70, 0xf6, 0x7f, 0xe9, 0xdf, + 0x04, 0x00, 0x00, 0xff, 0xff, 0x39, 0x34, 0xdc, 0x92, 0x40, 0x87, 0x01, 0x00, } func (m *Metadata) Marshal() (dAtA []byte, err error) { @@ -31190,6 +31386,75 @@ func (m *OneOf_SFTPSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) { } return len(dAtA) - i, nil } +func (m *OneOf_WorkloadIdentityCreate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OneOf_WorkloadIdentityCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.WorkloadIdentityCreate != nil { + { + size, err := m.WorkloadIdentityCreate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0x92 + } + return len(dAtA) - i, nil +} +func (m *OneOf_WorkloadIdentityUpdate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OneOf_WorkloadIdentityUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.WorkloadIdentityUpdate != nil { + { + size, err := m.WorkloadIdentityUpdate.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0x9a + } + return len(dAtA) - i, nil +} +func (m *OneOf_WorkloadIdentityDelete) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *OneOf_WorkloadIdentityDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.WorkloadIdentityDelete != nil { + { + size, err := m.WorkloadIdentityDelete.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xc + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} func (m *StreamStatus) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -31214,12 +31479,12 @@ func (m *StreamStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n657, err657 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastUploadTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUploadTime):]) - if err657 != nil { - return 0, err657 + n660, err660 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastUploadTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastUploadTime):]) + if err660 != nil { + return 0, err660 } - i -= n657 - i = encodeVarintEvents(dAtA, i, uint64(n657)) + i -= n660 + i = encodeVarintEvents(dAtA, i, uint64(n660)) i-- dAtA[i] = 0x1a if m.LastEventIndex != 0 { @@ -31378,12 +31643,12 @@ func (m *Identity) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0xc2 } } - n661, err661 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PreviousIdentityExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousIdentityExpires):]) - if err661 != nil { - return 0, err661 + n664, err664 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PreviousIdentityExpires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PreviousIdentityExpires):]) + if err664 != nil { + return 0, err664 } - i -= n661 - i = encodeVarintEvents(dAtA, i, uint64(n661)) + i -= n664 + i = encodeVarintEvents(dAtA, i, uint64(n664)) i-- dAtA[i] = 0x1 i-- @@ -31531,12 +31796,12 @@ func (m *Identity) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x4a } - n665, err665 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) - if err665 != nil { - return 0, err665 + n668, err668 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) + if err668 != nil { + return 0, err668 } - i -= n665 - i = encodeVarintEvents(dAtA, i, uint64(n665)) + i -= n668 + i = encodeVarintEvents(dAtA, i, uint64(n668)) i-- dAtA[i] = 0x42 if len(m.KubernetesUsers) > 0 { @@ -38159,6 +38424,231 @@ func (m *UserTaskDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *WorkloadIdentityCreate) 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 *WorkloadIdentityCreate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WorkloadIdentityCreate) 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 m.WorkloadIdentityData != nil { + { + size, err := m.WorkloadIdentityData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + { + size, err := m.ConnectionMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.UserMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.ResourceMetadata.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 *WorkloadIdentityUpdate) 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 *WorkloadIdentityUpdate) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WorkloadIdentityUpdate) 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 m.WorkloadIdentityData != nil { + { + size, err := m.WorkloadIdentityData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + { + size, err := m.ConnectionMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.UserMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.ResourceMetadata.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 *WorkloadIdentityDelete) 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 *WorkloadIdentityDelete) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WorkloadIdentityDelete) 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] = 0x22 + { + size, err := m.UserMetadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.ResourceMetadata.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 @@ -44294,6 +44784,42 @@ func (m *OneOf_SFTPSummary) Size() (n int) { } return n } +func (m *OneOf_WorkloadIdentityCreate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.WorkloadIdentityCreate != nil { + l = m.WorkloadIdentityCreate.Size() + n += 2 + l + sovEvents(uint64(l)) + } + return n +} +func (m *OneOf_WorkloadIdentityUpdate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.WorkloadIdentityUpdate != nil { + l = m.WorkloadIdentityUpdate.Size() + n += 2 + l + sovEvents(uint64(l)) + } + return n +} +func (m *OneOf_WorkloadIdentityDelete) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.WorkloadIdentityDelete != nil { + l = m.WorkloadIdentityDelete.Size() + n += 2 + l + sovEvents(uint64(l)) + } + return n +} func (m *StreamStatus) Size() (n int) { if m == nil { return 0 @@ -46777,6 +47303,74 @@ func (m *UserTaskDelete) Size() (n int) { return n } +func (m *WorkloadIdentityCreate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.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.WorkloadIdentityData != nil { + l = m.WorkloadIdentityData.Size() + n += 1 + l + sovEvents(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *WorkloadIdentityUpdate) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.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.WorkloadIdentityData != nil { + l = m.WorkloadIdentityData.Size() + n += 1 + l + sovEvents(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *WorkloadIdentityDelete) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Metadata.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 } @@ -85422,62 +86016,11 @@ func (m *OneOf) Unmarshal(dAtA []byte) error { } m.Event = &OneOf_SFTPSummary{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 194: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UploadID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadIdentityCreate", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -85487,29 +86030,32 @@ 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]) + v := &WorkloadIdentityCreate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Event = &OneOf_WorkloadIdentityCreate{v} iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LastEventIndex", wireType) + case 195: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadIdentityUpdate", wireType) } - m.LastEventIndex = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -85519,14 +86065,30 @@ func (m *StreamStatus) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.LastEventIndex |= int64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: + if msglen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &WorkloadIdentityUpdate{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Event = &OneOf_WorkloadIdentityUpdate{v} + iNdEx = postIndex + case 196: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LastUploadTime", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadIdentityDelete", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -85553,9 +86115,11 @@ 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 := &WorkloadIdentityDelete{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } + m.Event = &OneOf_WorkloadIdentityDelete{v} iNdEx = postIndex default: iNdEx = preIndex @@ -85579,7 +86143,7 @@ func (m *StreamStatus) Unmarshal(dAtA []byte) error { } return nil } -func (m *SessionUpload) Unmarshal(dAtA []byte) error { +func (m *StreamStatus) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -85602,17 +86166,17 @@ func (m *SessionUpload) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SessionUpload: wiretype end group for non-group") + return fmt.Errorf("proto: StreamStatus: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SessionUpload: illegal tag %d (wire type %d)", fieldNum, wire) + 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 Metadata", 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 @@ -85622,30 +86186,29 @@ 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.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.UploadID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SessionMetadata", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastEventIndex", wireType) } - var msglen int + m.LastEventIndex = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -85655,30 +86218,16 @@ func (m *SessionUpload) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.LastEventIndex |= int64(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 5: + 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 @@ -85688,23 +86237,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 @@ -85728,7 +86278,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 { @@ -85751,17 +86301,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 @@ -85771,29 +86321,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 @@ -85803,27 +86354,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 { @@ -85851,11 +86403,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 { @@ -85883,11 +86486,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 { @@ -85915,11 +86518,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 { @@ -85947,11 +86550,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 { @@ -85979,13 +86582,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 @@ -85995,28 +86598,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 { @@ -86044,11 +86646,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 { @@ -86076,11 +86678,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 { @@ -86107,15 +86709,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 @@ -86125,31 +86727,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 { @@ -86177,11 +86775,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 { @@ -86208,18 +86806,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 @@ -86229,27 +86824,31 @@ 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 { @@ -86277,13 +86876,13 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.DatabaseUsers = append(m.DatabaseUsers, string(dAtA[iNdEx:postIndex])) + m.TeleportCluster = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 17: + case 14: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MFADeviceUUID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RouteToDatabase", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -86293,27 +86892,31 @@ 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.MFADeviceUUID = string(dAtA[iNdEx:postIndex]) + if m.RouteToDatabase == nil { + m.RouteToDatabase = &RouteToDatabase{} + } + if err := m.RouteToDatabase.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 18: + case 15: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientIP", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseNames", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86341,11 +86944,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ClientIP = string(dAtA[iNdEx:postIndex]) + m.DatabaseNames = append(m.DatabaseNames, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 19: + case 16: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AWSRoleARNs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DatabaseUsers", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86373,11 +86976,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.AWSRoleARNs = append(m.AWSRoleARNs, string(dAtA[iNdEx:postIndex])) + m.DatabaseUsers = append(m.DatabaseUsers, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 20: + case 17: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AccessRequests", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MFADeviceUUID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86405,67 +87008,13 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.AccessRequests = append(m.AccessRequests, string(dAtA[iNdEx:postIndex])) - iNdEx = postIndex - case 21: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DisallowReissue", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.DisallowReissue = bool(v != 0) - case 22: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AllowedResourceIDs", 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 - } - m.AllowedResourceIDs = append(m.AllowedResourceIDs, ResourceID{}) - if err := m.AllowedResourceIDs[len(m.AllowedResourceIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.MFADeviceUUID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 23: + case 18: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PreviousIdentityExpires", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClientIP", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -86475,28 +87024,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.PreviousIdentityExpires, dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.ClientIP = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 24: + case 19: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AzureIdentities", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AWSRoleARNs", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86524,11 +87072,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.AzureIdentities = append(m.AzureIdentities, string(dAtA[iNdEx:postIndex])) + m.AWSRoleARNs = append(m.AWSRoleARNs, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 25: + case 20: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GCPServiceAccounts", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AccessRequests", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86556,13 +87104,13 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.GCPServiceAccounts = append(m.GCPServiceAccounts, string(dAtA[iNdEx:postIndex])) + m.AccessRequests = append(m.AccessRequests, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 26: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrivateKeyPolicy", wireType) + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisallowReissue", wireType) } - var stringLen uint64 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -86572,29 +87120,17 @@ func (m *Identity) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + v |= int(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.PrivateKeyPolicy = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 27: + m.DisallowReissue = bool(v != 0) + case 22: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BotName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AllowedResourceIDs", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -86604,27 +87140,29 @@ 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.BotName = string(dAtA[iNdEx:postIndex]) + m.AllowedResourceIDs = append(m.AllowedResourceIDs, ResourceID{}) + if err := m.AllowedResourceIDs[len(m.AllowedResourceIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 28: + case 23: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DeviceExtensions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PreviousIdentityExpires", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -86651,16 +87189,13 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DeviceExtensions == nil { - m.DeviceExtensions = &DeviceExtensions{} - } - if err := m.DeviceExtensions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.PreviousIdentityExpires, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 29: + case 24: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BotInstanceID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AzureIdentities", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86688,62 +87223,11 @@ func (m *Identity) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BotInstanceID = string(dAtA[iNdEx:postIndex]) + m.AzureIdentities = append(m.AzureIdentities, 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 *RouteToApp) 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: RouteToApp: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RouteToApp: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 25: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GCPServiceAccounts", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86771,11 +87255,11 @@ func (m *RouteToApp) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.GCPServiceAccounts = append(m.GCPServiceAccounts, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 2: + case 26: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PrivateKeyPolicy", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86803,11 +87287,11 @@ func (m *RouteToApp) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SessionID = string(dAtA[iNdEx:postIndex]) + m.PrivateKeyPolicy = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 27: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PublicAddr", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BotName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86835,13 +87319,13 @@ func (m *RouteToApp) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PublicAddr = string(dAtA[iNdEx:postIndex]) + m.BotName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 28: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DeviceExtensions", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -86851,27 +87335,31 @@ func (m *RouteToApp) 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.ClusterName = string(dAtA[iNdEx:postIndex]) + if m.DeviceExtensions == nil { + m.DeviceExtensions = &DeviceExtensions{} + } + if err := m.DeviceExtensions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 5: + case 29: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AWSRoleARN", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BotInstanceID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86899,11 +87387,62 @@ func (m *RouteToApp) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.AWSRoleARN = string(dAtA[iNdEx:postIndex]) + m.BotInstanceID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: + 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 *RouteToApp) 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: RouteToApp: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RouteToApp: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AzureIdentity", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86931,11 +87470,11 @@ func (m *RouteToApp) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.AzureIdentity = string(dAtA[iNdEx:postIndex]) + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 7: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GCPServiceAccount", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86963,11 +87502,11 @@ func (m *RouteToApp) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.GCPServiceAccount = string(dAtA[iNdEx:postIndex]) + m.SessionID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field URI", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PublicAddr", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -86995,62 +87534,11 @@ func (m *RouteToApp) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.URI = string(dAtA[iNdEx:postIndex]) + m.PublicAddr = 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 *RouteToDatabase) 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: RouteToDatabase: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RouteToDatabase: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClusterName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -87078,11 +87566,11 @@ func (m *RouteToDatabase) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ServiceName = string(dAtA[iNdEx:postIndex]) + m.ClusterName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AWSRoleARN", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -87110,11 +87598,11 @@ func (m *RouteToDatabase) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Protocol = string(dAtA[iNdEx:postIndex]) + m.AWSRoleARN = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AzureIdentity", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -87142,11 +87630,11 @@ func (m *RouteToDatabase) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Username = string(dAtA[iNdEx:postIndex]) + m.AzureIdentity = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Database", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GCPServiceAccount", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -87174,11 +87662,222 @@ func (m *RouteToDatabase) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Database = string(dAtA[iNdEx:postIndex]) + m.GCPServiceAccount = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field URI", 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.URI = 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 *RouteToDatabase) 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: RouteToDatabase: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RouteToDatabase: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ServiceName", 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.ServiceName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Protocol", 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.Protocol = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Username", 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.Username = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Database", 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.Database = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -100877,13 +101576,548 @@ 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 - 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 *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 Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -100910,15 +102144,15 @@ 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.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + 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 ChangeID", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -100928,30 +102162,61 @@ 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.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + 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 ConnectionMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceSource", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -100961,30 +102226,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.AffectedResourceSource = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AdminActionsMFA", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AffectedResourceType", wireType) } - m.AdminActionsMFA = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -100994,11 +102258,24 @@ func (m *AuthPreferenceUpdate) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.AdminActionsMFA |= AdminActionsMFAStatus(b&0x7F) << shift + 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:]) @@ -101021,7 +102298,7 @@ func (m *AuthPreferenceUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { +func (m *SpannerRPC) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101044,10 +102321,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: SpannerRPC: 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: SpannerRPC: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101085,7 +102362,7 @@ func (m *ClusterNetworkingConfigUpdate) 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 UserMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -101112,13 +102389,13 @@ func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + 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 UserMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SessionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -101145,13 +102422,13 @@ func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.SessionMetadata.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 DatabaseMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -101178,7 +102455,108 @@ func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.DatabaseMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + 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 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Procedure", 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.Procedure = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", 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.Args == nil { + m.Args = &Struct{} + } + if err := m.Args.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -101204,7 +102582,7 @@ func (m *ClusterNetworkingConfigUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *SessionRecordingConfigUpdate) Unmarshal(dAtA []byte) error { +func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101227,10 +102605,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: AccessGraphSettingsUpdate: 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: AccessGraphSettingsUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101387,7 +102765,7 @@ func (m *SessionRecordingConfigUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AccessPathChanged) Unmarshal(dAtA []byte) error { +func (m *SPIFFEFederationCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101410,10 +102788,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: SPIFFEFederationCreate: 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: SPIFFEFederationCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101451,9 +102829,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 @@ -101463,29 +102841,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 @@ -101495,29 +102874,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 @@ -101527,55 +102907,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 @@ -101599,7 +102948,7 @@ func (m *AccessPathChanged) Unmarshal(dAtA []byte) error { } return nil } -func (m *SpannerRPC) Unmarshal(dAtA []byte) error { +func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101622,10 +102971,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: SPIFFEFederationDelete: 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: SPIFFEFederationDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101663,7 +103012,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 { @@ -101690,13 +103039,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 { @@ -101723,111 +103072,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) - } - 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.DatabaseMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - 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 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Procedure", 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.Procedure = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 7: - 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 { @@ -101854,10 +103105,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 @@ -101883,7 +103131,7 @@ func (m *SpannerRPC) Unmarshal(dAtA []byte) error { } return nil } -func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateConfigCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -101906,10 +103154,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: AutoUpdateConfigCreate: 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: AutoUpdateConfigCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -101947,7 +103195,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 { @@ -101974,7 +103222,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 @@ -102044,6 +103292,39 @@ func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + 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 default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -102066,7 +103347,7 @@ func (m *AccessGraphSettingsUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *SPIFFEFederationCreate) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -102089,10 +103370,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: AutoUpdateConfigUpdate: 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: AutoUpdateConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -102130,7 +103411,7 @@ func (m *SPIFFEFederationCreate) 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 { @@ -102157,7 +103438,7 @@ func (m *SPIFFEFederationCreate) 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 @@ -102227,6 +103508,39 @@ func (m *SPIFFEFederationCreate) 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 default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -102249,7 +103563,7 @@ func (m *SPIFFEFederationCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -102272,10 +103586,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: AutoUpdateConfigDelete: 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: AutoUpdateConfigDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -102410,6 +103724,39 @@ func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 5: + 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 default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -102432,7 +103779,7 @@ func (m *SPIFFEFederationDelete) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateConfigCreate) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -102455,10 +103802,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: AutoUpdateVersionCreate: 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: AutoUpdateVersionCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -102648,7 +103995,7 @@ func (m *AutoUpdateConfigCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -102671,10 +104018,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: AutoUpdateVersionUpdate: 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: AutoUpdateVersionUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -102864,7 +104211,7 @@ func (m *AutoUpdateConfigUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { +func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -102887,10 +104234,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: AutoUpdateVersionDelete: 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: AutoUpdateVersionDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -103080,7 +104427,7 @@ func (m *AutoUpdateConfigDelete) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { +func (m *StaticHostUserCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -103103,10 +104450,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: StaticHostUserCreate: 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: StaticHostUserCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -103144,7 +104491,7 @@ func (m *AutoUpdateVersionCreate) 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 { @@ -103171,13 +104518,13 @@ func (m *AutoUpdateVersionCreate) 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 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 { @@ -103204,13 +104551,13 @@ func (m *AutoUpdateVersionCreate) 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 { @@ -103237,13 +104584,13 @@ func (m *AutoUpdateVersionCreate) 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 Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -103270,7 +104617,7 @@ func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -103296,7 +104643,7 @@ func (m *AutoUpdateVersionCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { +func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -103319,10 +104666,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: StaticHostUserUpdate: 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: StaticHostUserUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -103393,7 +104740,7 @@ func (m *AutoUpdateVersionUpdate) 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 { @@ -103420,13 +104767,13 @@ func (m *AutoUpdateVersionUpdate) 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 { @@ -103453,13 +104800,13 @@ func (m *AutoUpdateVersionUpdate) 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 { @@ -103486,7 +104833,7 @@ func (m *AutoUpdateVersionUpdate) 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 @@ -103512,7 +104859,7 @@ func (m *AutoUpdateVersionUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { +func (m *StaticHostUserDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -103535,10 +104882,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: StaticHostUserDelete: 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: StaticHostUserDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -103576,7 +104923,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 { @@ -103603,13 +104950,13 @@ 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 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 { @@ -103636,13 +104983,13 @@ func (m *AutoUpdateVersionDelete) 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 { @@ -103669,13 +105016,13 @@ func (m *AutoUpdateVersionDelete) 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 Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -103702,7 +105049,7 @@ func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -103728,7 +105075,7 @@ func (m *AutoUpdateVersionDelete) Unmarshal(dAtA []byte) error { } return nil } -func (m *StaticHostUserCreate) Unmarshal(dAtA []byte) error { +func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -103751,10 +105098,10 @@ func (m *StaticHostUserCreate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StaticHostUserCreate: wiretype end group for non-group") + return fmt.Errorf("proto: CrownJewelCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StaticHostUserCreate: 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: @@ -103825,7 +105172,7 @@ func (m *StaticHostUserCreate) 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 { @@ -103852,13 +105199,13 @@ func (m *StaticHostUserCreate) 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 { @@ -103885,13 +105232,13 @@ func (m *StaticHostUserCreate) 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 { @@ -103918,10 +105265,42 @@ func (m *StaticHostUserCreate) 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 + 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:]) @@ -103944,7 +105323,7 @@ func (m *StaticHostUserCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { +func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -103967,10 +105346,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: CrownJewelUpdate: 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: CrownJewelUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -104041,7 +105420,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 { @@ -104068,13 +105447,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 { @@ -104101,13 +105480,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 { @@ -104134,10 +105513,74 @@ 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 + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentCrownJewelQuery", 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.CurrentCrownJewelQuery = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedCrownJewelQuery", 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.UpdatedCrownJewelQuery = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) @@ -104160,7 +105603,7 @@ func (m *StaticHostUserUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *StaticHostUserDelete) Unmarshal(dAtA []byte) error { +func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -104183,10 +105626,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: CrownJewelDelete: 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: CrownJewelDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -104257,7 +105700,7 @@ func (m *StaticHostUserDelete) 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 { @@ -104284,13 +105727,13 @@ func (m *StaticHostUserDelete) 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 { @@ -104317,13 +105760,13 @@ func (m *StaticHostUserDelete) 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 { @@ -104350,7 +105793,7 @@ func (m *StaticHostUserDelete) 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 @@ -104376,7 +105819,7 @@ func (m *StaticHostUserDelete) Unmarshal(dAtA []byte) error { } return nil } -func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { +func (m *UserTaskCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -104399,10 +105842,10 @@ func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CrownJewelCreate: wiretype end group for non-group") + return fmt.Errorf("proto: UserTaskCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CrownJewelCreate: 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: @@ -104473,7 +105916,7 @@ func (m *CrownJewelCreate) 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 { @@ -104500,13 +105943,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.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 { @@ -104533,13 +105976,13 @@ 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.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 { @@ -104566,15 +106009,15 @@ func (m *CrownJewelCreate) 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 case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CrownJewelQuery", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserTaskMetadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -104584,23 +106027,24 @@ 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]) + if err := m.UserTaskMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -104624,7 +106068,7 @@ func (m *CrownJewelCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { +func (m *UserTaskUpdate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -104647,10 +106091,10 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: CrownJewelUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: UserTaskUpdate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: CrownJewelUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UserTaskUpdate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -104720,6 +106164,39 @@ func (m *CrownJewelUpdate) 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) } @@ -104752,7 +106229,7 @@ func (m *CrownJewelUpdate) 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) } @@ -104785,9 +106262,9 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 5: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserTaskMetadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -104814,13 +106291,13 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UserTaskMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 6: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CurrentCrownJewelQuery", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CurrentUserTaskState", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -104848,11 +106325,11 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.CurrentCrownJewelQuery = string(dAtA[iNdEx:postIndex]) + m.CurrentUserTaskState = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 7: + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UpdatedCrownJewelQuery", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UpdatedUserTaskState", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -104880,7 +106357,7 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.UpdatedCrownJewelQuery = string(dAtA[iNdEx:postIndex]) + m.UpdatedUserTaskState = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -104904,7 +106381,7 @@ func (m *CrownJewelUpdate) Unmarshal(dAtA []byte) error { } return nil } -func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { +func (m *UserTaskMetadata) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -104927,17 +106404,17 @@ 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: UserTaskMetadata: 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: 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 Metadata", 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 @@ -104947,30 +106424,29 @@ func (m *CrownJewelDelete) 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.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.TaskType = string(dAtA[iNdEx:postIndex]) 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 IssueType", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -104980,96 +106456,29 @@ func (m *CrownJewelDelete) 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.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.IssueType = string(dAtA[iNdEx:postIndex]) 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 != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResourceMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Integration", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -105079,24 +106488,23 @@ func (m *CrownJewelDelete) 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.Integration = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -105120,7 +106528,7 @@ func (m *CrownJewelDelete) Unmarshal(dAtA []byte) error { } return nil } -func (m *UserTaskCreate) Unmarshal(dAtA []byte) error { +func (m *UserTaskDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -105143,10 +106551,10 @@ func (m *UserTaskCreate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UserTaskCreate: wiretype end group for non-group") + return fmt.Errorf("proto: UserTaskDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UserTaskCreate: 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: @@ -105310,40 +106718,7 @@ func (m *UserTaskCreate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserTaskMetadata", 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.UserTaskMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -105369,7 +106744,7 @@ func (m *UserTaskCreate) Unmarshal(dAtA []byte) error { } return nil } -func (m *UserTaskUpdate) Unmarshal(dAtA []byte) error { +func (m *WorkloadIdentityCreate) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -105392,10 +106767,10 @@ func (m *UserTaskUpdate) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UserTaskUpdate: wiretype end group for non-group") + return fmt.Errorf("proto: WorkloadIdentityCreate: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UserTaskUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WorkloadIdentityCreate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -105433,7 +106808,7 @@ func (m *UserTaskUpdate) 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 { @@ -105460,13 +106835,13 @@ func (m *UserTaskUpdate) 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 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 { @@ -105493,13 +106868,13 @@ func (m *UserTaskUpdate) 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 { @@ -105526,13 +106901,13 @@ func (m *UserTaskUpdate) 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 WorkloadIdentityData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -105559,13 +106934,67 @@ func (m *UserTaskUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.WorkloadIdentityData == nil { + m.WorkloadIdentityData = &Struct{} + } + if err := m.WorkloadIdentityData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 6: + 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 *WorkloadIdentityUpdate) 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: WorkloadIdentityUpdate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WorkloadIdentityUpdate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UserTaskMetadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -105592,15 +107021,15 @@ func (m *UserTaskUpdate) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.UserTaskMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 7: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CurrentUserTaskState", 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 @@ -105610,29 +107039,30 @@ func (m *UserTaskUpdate) 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.CurrentUserTaskState = string(dAtA[iNdEx:postIndex]) + if err := m.ResourceMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 8: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field UpdatedUserTaskState", 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 @@ -105642,80 +107072,30 @@ func (m *UserTaskUpdate) 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.UpdatedUserTaskState = 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 *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: + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TaskType", 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 @@ -105725,29 +107105,30 @@ func (m *UserTaskMetadata) 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.TaskType = string(dAtA[iNdEx:postIndex]) + if err := m.ConnectionMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 2: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field IssueType", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WorkloadIdentityData", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -105757,55 +107138,27 @@ func (m *UserTaskMetadata) 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.IssueType = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Integration", wireType) + if m.WorkloadIdentityData == nil { + m.WorkloadIdentityData = &Struct{} } - 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.WorkloadIdentityData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - m.Integration = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -105829,7 +107182,7 @@ func (m *UserTaskMetadata) Unmarshal(dAtA []byte) error { } return nil } -func (m *UserTaskDelete) Unmarshal(dAtA []byte) error { +func (m *WorkloadIdentityDelete) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -105852,10 +107205,10 @@ func (m *UserTaskDelete) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UserTaskDelete: wiretype end group for non-group") + return fmt.Errorf("proto: WorkloadIdentityDelete: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UserTaskDelete: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: WorkloadIdentityDelete: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -105892,39 +107245,6 @@ func (m *UserTaskDelete) 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) } @@ -105957,7 +107277,7 @@ func (m *UserTaskDelete) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 4: + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UserMetadata", wireType) } @@ -105990,7 +107310,7 @@ func (m *UserTaskDelete) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 5: + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ConnectionMetadata", wireType) } diff --git a/api/types/events/oneof.go b/api/types/events/oneof.go index 6e856b3c5f2b2..8f3c73e7ceb24 100644 --- a/api/types/events/oneof.go +++ b/api/types/events/oneof.go @@ -790,6 +790,18 @@ func ToOneOf(in AuditEvent) (*OneOf, error) { out.Event = &OneOf_AutoUpdateVersionDelete{ AutoUpdateVersionDelete: e, } + case *WorkloadIdentityCreate: + out.Event = &OneOf_WorkloadIdentityCreate{ + WorkloadIdentityCreate: e, + } + case *WorkloadIdentityUpdate: + out.Event = &OneOf_WorkloadIdentityUpdate{ + WorkloadIdentityUpdate: e, + } + case *WorkloadIdentityDelete: + out.Event = &OneOf_WorkloadIdentityDelete{ + WorkloadIdentityDelete: 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/events/api.go b/lib/events/api.go index ce09acd15865a..0ae32c51c9c2c 100644 --- a/lib/events/api.go +++ b/lib/events/api.go @@ -838,6 +838,13 @@ const ( AutoUpdateVersionUpdateEvent = "auto_update_version.update" // AutoUpdateVersionDeleteEvent is emitted when a AutoUpdateVersion resource is deleted. AutoUpdateVersionDeleteEvent = "auto_update_version.delete" + + // WorkloadIdentityCreateEvent is emitted when a WorkloadIdentity resource is created. + WorkloadIdentityCreateEvent = "workload_identity.create" + // WorkloadIdentityUpdateEvent is emitted when a WorkloadIdentity resource is updated. + WorkloadIdentityUpdateEvent = "workload_identity.update" + // WorkloadIdentityDeleteEvent is emitted when a WorkloadIdentity resource is deleted. + WorkloadIdentityDeleteEvent = "workload_identity.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 62897e9b168b9..90ca42e07f68c 100644 --- a/lib/events/codes.go +++ b/lib/events/codes.go @@ -671,6 +671,13 @@ const ( // AutoUpdateVersionDeleteCode is the auto update version delete event code. AutoUpdateVersionDeleteCode = "AUV003I" + // WorkloadIdentityCreateCode is the workload identity create event code. + WorkloadIdentityCreateCode = "WID001I" + // WorkloadIdentityUpdateCode is the workload identity update event code. + WorkloadIdentityUpdateCode = "WID002I" + // WorkloadIdentityDeleteCode is the workload identity delete event code. + WorkloadIdentityDeleteCode = "WID003I" + // 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 476528255e5ba..1fc5a3b4919de 100644 --- a/lib/events/dynamic.go +++ b/lib/events/dynamic.go @@ -462,6 +462,14 @@ func FromEventFields(fields EventFields) (events.AuditEvent, error) { e = &events.AutoUpdateVersionUpdate{} case AutoUpdateVersionDeleteEvent: e = &events.AutoUpdateVersionDelete{} + + case WorkloadIdentityCreateEvent: + e = &events.WorkloadIdentityCreate{} + case WorkloadIdentityUpdateEvent: + e = &events.WorkloadIdentityUpdate{} + case WorkloadIdentityDeleteEvent: + e = &events.WorkloadIdentityDelete{} + default: slog.ErrorContext(context.Background(), "Attempted to convert dynamic event of unknown type into protobuf event.", "event_type", eventType) unknown := &events.Unknown{} diff --git a/lib/events/events_test.go b/lib/events/events_test.go index d304a65ddd4bc..a806eccda3295 100644 --- a/lib/events/events_test.go +++ b/lib/events/events_test.go @@ -242,6 +242,9 @@ var eventsMap = map[string]apievents.AuditEvent{ AutoUpdateVersionCreateEvent: &apievents.AutoUpdateVersionCreate{}, AutoUpdateVersionUpdateEvent: &apievents.AutoUpdateVersionUpdate{}, AutoUpdateVersionDeleteEvent: &apievents.AutoUpdateVersionDelete{}, + WorkloadIdentityCreateEvent: &apievents.WorkloadIdentityCreate{}, + WorkloadIdentityUpdateEvent: &apievents.WorkloadIdentityUpdate{}, + WorkloadIdentityDeleteEvent: &apievents.WorkloadIdentityDelete{}, } // TestJSON tests JSON marshal events From 16c5fd553e4a063add8be6ad7a7c8aecc0bc4cf1 Mon Sep 17 00:00:00 2001 From: Zac Bergquist Date: Mon, 9 Dec 2024 07:00:02 -0700 Subject: [PATCH 12/16] postrelease: prefer the Go version in go.mod's toolchain directive (#49919) The go tool will automatically remove the toolchain directive if it happens to be the same as the go directive. This means in order to reliably get the version of Go that is used to build, we need to first check the toolchain directive, and fall back to the go directive only if the toolchain is not specified. Additionally, the toolchain directive is prefixed with "go", so we need to strip that to get consistent output. --- .github/workflows/post-release.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/post-release.yaml b/.github/workflows/post-release.yaml index 9641d2c00758a..df1c33bb64798 100644 --- a/.github/workflows/post-release.yaml +++ b/.github/workflows/post-release.yaml @@ -94,8 +94,8 @@ jobs: git config --global user.email "noreply@github.com" git config --global user.name "GitHub" - # get Go version from go.mod - GO_VERSION=$(go mod edit -json | jq -r .Go) + # get Go version from go.mod (preferring the toolchain directive if it's present) + GO_VERSION=$(go mod edit -json | jq -r 'if has("Toolchain") then .Toolchain | sub("go"; "") else .Go end') # update versions in docs/config.json # for docker images replace version number after : From 2c0f2f15678e31757cd13e739dbeec8943307741 Mon Sep 17 00:00:00 2001 From: Alan Parra Date: Mon, 9 Dec 2024 11:41:04 -0300 Subject: [PATCH 13/16] fix: Respect the --no-allow-passwordless flag (#49933) --- tool/tsh/common/mfa.go | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/tool/tsh/common/mfa.go b/tool/tsh/common/mfa.go index c540cce3b1228..404be014e1c0f 100644 --- a/tool/tsh/common/mfa.go +++ b/tool/tsh/common/mfa.go @@ -197,12 +197,14 @@ type mfaAddCommand struct { devName string devType string - // allowPasswordless is initially true if --allow-passwordless is set, false - // if not explicitly requested. - // It can only be set by users if wancli.IsFIDO2Available() is true. + // allowPasswordless and allowPasswordlessSet hold the state of the + // --(no-)allow-passwordless flag. + // + // allowPasswordless can only be set by users if wancli.IsFIDO2Available() is + // true. // Note that Touch ID registrations are always passwordless-capable, // regardless of other settings. - allowPasswordless bool + allowPasswordless, allowPasswordlessSet bool } func newMFAAddCommand(parent *kingpin.CmdClause) *mfaAddCommand { @@ -213,7 +215,9 @@ func newMFAAddCommand(parent *kingpin.CmdClause) *mfaAddCommand { c.Flag("type", fmt.Sprintf("Type of the new MFA device (%s)", strings.Join(defaultDeviceTypes, ", "))). EnumVar(&c.devType, defaultDeviceTypes...) if wancli.IsFIDO2Available() { - c.Flag("allow-passwordless", "Allow passwordless logins").BoolVar(&c.allowPasswordless) + c.Flag("allow-passwordless", "Allow passwordless logins"). + IsSetByUser(&c.allowPasswordlessSet). + BoolVar(&c.allowPasswordless) } return c } @@ -265,9 +269,7 @@ func (c *mfaAddCommand) run(cf *CLIConf) error { switch c.devType { case webauthnDeviceType: // Ask the user? - // c.allowPasswordless=false at this point only means that the flag wasn't - // explicitly set. - if !c.allowPasswordless && wancli.IsFIDO2Available() { + if !c.allowPasswordlessSet && wancli.IsFIDO2Available() { answer, err := prompt.PickOne(ctx, os.Stdout, prompt.Stdin(), "Allow passwordless logins", []string{"YES", "NO"}) if err != nil { return trace.Wrap(err) From 12d40a232f513ba7c66a26dbc5830c8a578f4734 Mon Sep 17 00:00:00 2001 From: Grzegorz Zdunek Date: Mon, 9 Dec 2024 16:11:14 +0100 Subject: [PATCH 14/16] [v17] Convert dialog to authorize web session to regular tab and handle expired certs (#49931) * Add `AddMetadataToRetryableError` to `AuthenticateWebDevice` * Add a document for web session authorization * Replace `AuthenticateWebDevice` modal with the document * Remove dot from anchor * Move more logic to `authorizeAndCloseDocument` * Add a comment about `canAuthorize` * Filter out documents before restoring session * Add a comment about `processedRedirectUri` * Restore filtering out documents before saving them on disk * Fix test * Refer to Teleport Connect instead of 'the app' --- lib/teleterm/daemon/daemon.go | 12 +- .../src/services/tshd/fixtures/mocks.ts | 8 +- .../DocumentAuthorizeWebSession.story.tsx | 90 ++++++++ .../DocumentAuthorizeWebSession.test.tsx | 105 ++++++++++ .../DocumentAuthorizeWebSession.tsx | 196 ++++++++++++++++++ .../index.ts} | 24 +-- .../src/ui/Documents/DocumentsRenderer.tsx | 3 + .../teleterm/src/ui/ModalsHost/ModalsHost.tsx | 15 -- .../AuthenticateWebDevice.tsx | 82 -------- .../ui/services/deepLinks/deepLinksService.ts | 38 +--- .../src/ui/services/modals/modalsService.ts | 8 - .../documentsService/documentsService.ts | 17 ++ .../documentsService/documentsUtils.ts | 2 + .../documentsService/types.ts | 22 +- .../workspacesService.test.ts | 117 ++++++++++- .../workspacesService/workspacesService.ts | 28 ++- 16 files changed, 604 insertions(+), 163 deletions(-) create mode 100644 web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.story.tsx create mode 100644 web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.test.tsx create mode 100644 web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.tsx rename web/packages/teleterm/src/ui/{ModalsHost/modals/AuthenticateWebDevice/AuthenticateWebDevice.story.tsx => DocumentAuthorizeWebSession/index.ts} (52%) delete mode 100644 web/packages/teleterm/src/ui/ModalsHost/modals/AuthenticateWebDevice/AuthenticateWebDevice.tsx diff --git a/lib/teleterm/daemon/daemon.go b/lib/teleterm/daemon/daemon.go index 19724daceb6b3..13f12f4dfa253 100644 --- a/lib/teleterm/daemon/daemon.go +++ b/lib/teleterm/daemon/daemon.go @@ -1131,10 +1131,14 @@ func (s *Service) AuthenticateWebDevice(ctx context.Context, rootClusterURI uri. } devicesClient := proxyClient.CurrentCluster().DevicesClient() - ceremony := dtauthn.NewCeremony() - confirmationToken, err := ceremony.RunWeb(ctx, devicesClient, &devicepb.DeviceWebToken{ - Id: req.DeviceWebToken.Id, - Token: req.DeviceWebToken.Token, + var confirmationToken *devicepb.DeviceConfirmationToken + err = clusters.AddMetadataToRetryableError(ctx, func() error { + ceremony := dtauthn.NewCeremony() + confirmationToken, err = ceremony.RunWeb(ctx, devicesClient, &devicepb.DeviceWebToken{ + Id: req.DeviceWebToken.Id, + Token: req.DeviceWebToken.Token, + }) + return trace.Wrap(err) }) if err != nil { return nil, trace.Wrap(err) diff --git a/web/packages/teleterm/src/services/tshd/fixtures/mocks.ts b/web/packages/teleterm/src/services/tshd/fixtures/mocks.ts index 8696b36ee532d..8d0fa6999711d 100644 --- a/web/packages/teleterm/src/services/tshd/fixtures/mocks.ts +++ b/web/packages/teleterm/src/services/tshd/fixtures/mocks.ts @@ -101,7 +101,13 @@ export class MockTshClient implements TshdClient { getSuggestedAccessLists = () => new MockedUnaryCall({ accessLists: [] }); promoteAccessRequest = () => new MockedUnaryCall({}); updateTshdEventsServerAddress = () => new MockedUnaryCall({}); - authenticateWebDevice = () => new MockedUnaryCall({}); + authenticateWebDevice = () => + new MockedUnaryCall({ + confirmationToken: { + id: '123456789', + token: '7c8e7438-abe1-4cbc-b3e6-bd233bba967c', + }, + }); startHeadlessWatcher = () => new MockedUnaryCall({}); } diff --git a/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.story.tsx b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.story.tsx new file mode 100644 index 0000000000000..7b697092f7c62 --- /dev/null +++ b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.story.tsx @@ -0,0 +1,90 @@ +/** + * 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 . + */ + +import { wait } from 'shared/utils/wait'; + +import { MockAppContextProvider } from 'teleterm/ui/fixtures/MockAppContextProvider'; +import { + makeRootCluster, + makeLoggedInUser, + rootClusterUri, +} from 'teleterm/services/tshd/testHelpers'; +import { MockAppContext } from 'teleterm/ui/fixtures/mocks'; +import { MockWorkspaceContextProvider } from 'teleterm/ui/fixtures/MockWorkspaceContextProvider'; +import * as types from 'teleterm/ui/services/workspacesService'; +import { MockedUnaryCall } from 'teleterm/services/tshd/cloneableClient'; + +import { DocumentAuthorizeWebSession } from './DocumentAuthorizeWebSession'; + +export default { + title: 'Teleterm/DocumentAuthorizeWebSession', +}; + +const doc: types.DocumentAuthorizeWebSession = { + uri: '/docs/e2hyt5', + rootClusterUri: rootClusterUri, + kind: 'doc.authorize_web_session', + title: 'Authorize Web Session', + webSessionRequest: { + redirectUri: '', + token: '', + id: '', + }, +}; + +export function DeviceNotTrusted() { + const rootCluster = makeRootCluster(); + const appContext = new MockAppContext(); + appContext.clustersService.setState(draftState => { + draftState.clusters.set(rootCluster.uri, rootCluster); + }); + return ( + + + + + + ); +} + +export function DeviceTrusted() { + const rootCluster = makeRootCluster({ + loggedInUser: makeLoggedInUser({ isDeviceTrusted: true }), + }); + const appContext = new MockAppContext(); + appContext.clustersService.setState(draftState => { + draftState.clusters.set(rootCluster.uri, rootCluster); + }); + appContext.clustersService.authenticateWebDevice = async () => { + await wait(2_000); + return new MockedUnaryCall({ + confirmationToken: { + id: '123456789', + token: '7c8e7438-abe1-4cbc-b3e6-bd233bba967c', + }, + }); + }; + + return ( + + + + + + ); +} diff --git a/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.test.tsx b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.test.tsx new file mode 100644 index 0000000000000..c06ff109ff93c --- /dev/null +++ b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.test.tsx @@ -0,0 +1,105 @@ +/** + * 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 . + */ + +import { render, screen } from 'design/utils/testing'; +import userEvent from '@testing-library/user-event'; + +import { MockAppContextProvider } from 'teleterm/ui/fixtures/MockAppContextProvider'; +import { MockWorkspaceContextProvider } from 'teleterm/ui/fixtures/MockWorkspaceContextProvider'; +import { + makeRootCluster, + makeLoggedInUser, + rootClusterUri, +} from 'teleterm/services/tshd/testHelpers'; +import * as types from 'teleterm/ui/services/workspacesService'; +import { MockAppContext } from 'teleterm/ui/fixtures/mocks'; + +import { DocumentAuthorizeWebSession } from './DocumentAuthorizeWebSession'; + +const doc: types.DocumentAuthorizeWebSession = { + uri: '/docs/e2hyt5', + rootClusterUri: rootClusterUri, + kind: 'doc.authorize_web_session', + title: 'Authorize Web Session', + webSessionRequest: { + redirectUri: '', + token: '', + id: '', + }, +}; + +test('authorize button is disabled when device is not trusted', async () => { + const rootCluster = makeRootCluster({ + loggedInUser: makeLoggedInUser({ isDeviceTrusted: false }), + }); + const appContext = new MockAppContext(); + appContext.clustersService.setState(draftState => { + draftState.clusters.set(rootCluster.uri, rootCluster); + }); + + render( + + + + + + ); + + expect(await screen.findByText(/This device is not trusted/)).toBeVisible(); + expect(await screen.findByText(/Authorize Session/)).toBeDisabled(); +}); + +test('authorizing a session opens its URL and closes document', async () => { + jest.spyOn(window, 'open').mockImplementation(); + const rootCluster = makeRootCluster({ + loggedInUser: makeLoggedInUser({ isDeviceTrusted: true }), + }); + const appContext = new MockAppContext(); + appContext.clustersService.setState(draftState => { + draftState.clusters.set(rootCluster.uri, rootCluster); + }); + appContext.workspacesService.setState(draftState => { + draftState.workspaces[rootCluster.uri] = { + localClusterUri: rootCluster.uri, + documents: [doc], + location: undefined, + accessRequests: undefined, + }; + }); + + render( + + + + + + ); + + const button = await screen.findByText(/Authorize Session/); + await userEvent.click(button); + + expect(await screen.findByText(/Session Authorized/)).toBeVisible(); + expect(window.open).toHaveBeenCalledWith( + 'https://teleport-local:3080/webapi/devices/webconfirm?id=123456789&token=7c8e7438-abe1-4cbc-b3e6-bd233bba967c' + ); + expect( + appContext.workspacesService + .getWorkspaceDocumentService(rootCluster.uri) + .getDocuments() + ).toHaveLength(0); +}); diff --git a/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.tsx b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.tsx new file mode 100644 index 0000000000000..461a8de679ae4 --- /dev/null +++ b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/DocumentAuthorizeWebSession.tsx @@ -0,0 +1,196 @@ +/** + * 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 . + */ + +import { Text, Alert, ButtonPrimary, H1, ButtonText } from 'design'; +import Flex from 'design/Flex'; +import { useAsync, Attempt } from 'shared/hooks/useAsync'; +import { processRedirectUri } from 'shared/redirects'; +import { Cluster } from 'gen-proto-ts/teleport/lib/teleterm/v1/cluster_pb'; +import { DeviceConfirmationToken } from 'gen-proto-ts/teleport/devicetrust/v1/device_confirmation_token_pb'; + +import Document from 'teleterm/ui/Document'; +import { routing } from 'teleterm/ui/uri'; +import { retryWithRelogin } from 'teleterm/ui/utils'; +import { useAppContext } from 'teleterm/ui/appContextProvider'; +import * as types from 'teleterm/ui/services/workspacesService'; +import { WebSessionRequest } from 'teleterm/ui/services/workspacesService'; +import { useWorkspaceContext } from 'teleterm/ui/Documents'; + +export function DocumentAuthorizeWebSession(props: { + doc: types.DocumentAuthorizeWebSession; + visible: boolean; +}) { + const ctx = useAppContext(); + const { documentsService } = useWorkspaceContext(); + const rootCluster = ctx.clustersService.findCluster(props.doc.rootClusterUri); + const [authorizeAttempt, authorize] = useAsync(async () => { + const { + response: { confirmationToken }, + } = await retryWithRelogin(ctx, props.doc.rootClusterUri, () => + ctx.clustersService.authenticateWebDevice( + props.doc.rootClusterUri, + props.doc.webSessionRequest + ) + ); + return confirmationToken; + }); + const clusterName = routing.parseClusterName(props.doc.rootClusterUri); + const canAuthorize = rootCluster.loggedInUser?.isDeviceTrusted; + + async function authorizeAndCloseDocument() { + const [confirmationToken, error] = await authorize(); + if (!error) { + const url = buildAuthorizedSessionUrl( + rootCluster, + props.doc.webSessionRequest, + confirmationToken + ); + // This endpoint verifies the token and "upgrades" the web session and redirects to "/web". + window.open(url); + closeAndNotify(); + } + } + + function openUnauthorizedAndCloseDocument() { + const url = buildUnauthorizedSessionUrl( + rootCluster, + props.doc.webSessionRequest + ); + window.open(url); + closeAndNotify(); + } + + function closeAndNotify() { + documentsService.close(props.doc.uri); + ctx.notificationsService.notifyInfo( + 'Web session has been opened in the browser' + ); + } + + return ( + + +

Authorize Web Session

+ + {/*It's technically possible to open a deep link to authorize a session on a device that is not enrolled.*/} + {!canAuthorize && ( + + To authorize a web session, you must first{' '} + + enroll your device + + . Then log out of Teleport Connect, log back in, and try + again. + + } + > + This device is not trusted + + )} + {authorizeAttempt.status === 'error' && ( + + Could not authorize the session + + )} + + Would you like to authorize a device trust web session for{' '} + {clusterName}? +
+ The session will automatically open in a new browser tab. + + + + {getButtonText(authorizeAttempt)} + + + Open Session Without Device Trust + + + + + + ); +} + +const confirmPath = 'webapi/devices/webconfirm'; + +function buildAuthorizedSessionUrl( + rootCluster: Cluster, + webSessionRequest: WebSessionRequest, + confirmationToken: DeviceConfirmationToken +): string { + const { redirectUri } = webSessionRequest; + + let url = `https://${rootCluster.proxyHost}/${confirmPath}?id=${confirmationToken.id}&token=${confirmationToken.token}`; + if (redirectUri) { + url = `${url}&redirect_uri=${redirectUri}`; + } + return url; +} + +function buildUnauthorizedSessionUrl( + rootCluster: Cluster, + webSessionRequest: WebSessionRequest +): string { + // processedRedirectUri is the path part of the redirectUri. + // Unlike in buildAuthorizedSessionUrl, here we return a full path to open + // instead of including redirection as the `redirect_uri` query parameter. + const processedRedirectUri = processRedirectUri( + webSessionRequest.redirectUri + ); + return `https://${rootCluster.proxyHost}${processedRedirectUri}`; +} + +function getButtonText(attempt: Attempt): string { + switch (attempt.status) { + case '': + case 'error': + return 'Authorize Session'; + case 'processing': + return 'Authorizing Session…'; + case 'success': + return 'Session Authorized'; + } +} diff --git a/web/packages/teleterm/src/ui/ModalsHost/modals/AuthenticateWebDevice/AuthenticateWebDevice.story.tsx b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/index.ts similarity index 52% rename from web/packages/teleterm/src/ui/ModalsHost/modals/AuthenticateWebDevice/AuthenticateWebDevice.story.tsx rename to web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/index.ts index b6f35a6e673f2..ffd92d5d17b86 100644 --- a/web/packages/teleterm/src/ui/ModalsHost/modals/AuthenticateWebDevice/AuthenticateWebDevice.story.tsx +++ b/web/packages/teleterm/src/ui/DocumentAuthorizeWebSession/index.ts @@ -1,6 +1,6 @@ /** * Teleport - * Copyright (C) 2023 Gravitational, Inc. + * 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 @@ -16,24 +16,4 @@ * along with this program. If not, see . */ -import React from 'react'; - -import { makeRootCluster } from 'teleterm/services/tshd/testHelpers'; -import { MockAppContextProvider } from 'teleterm/ui/fixtures/MockAppContextProvider'; - -import { AuthenticateWebDevice } from './AuthenticateWebDevice'; - -export default { - title: 'Teleterm/ModalsHost/AuthenticateWebDevice', -}; - -export const Dialog = () => ( - - {}} - onCancel={() => {}} - onAuthorize={async () => {}} - /> - -); +export * from './DocumentAuthorizeWebSession'; diff --git a/web/packages/teleterm/src/ui/Documents/DocumentsRenderer.tsx b/web/packages/teleterm/src/ui/Documents/DocumentsRenderer.tsx index 0be864d2748f6..d1d300f0d8428 100644 --- a/web/packages/teleterm/src/ui/Documents/DocumentsRenderer.tsx +++ b/web/packages/teleterm/src/ui/Documents/DocumentsRenderer.tsx @@ -41,6 +41,7 @@ import { } from 'teleterm/ui/ConnectMyComputer'; import { DocumentGatewayKube } from 'teleterm/ui/DocumentGatewayKube'; import { DocumentGatewayApp } from 'teleterm/ui/DocumentGatewayApp'; +import { DocumentAuthorizeWebSession } from 'teleterm/ui/DocumentAuthorizeWebSession'; import Document from 'teleterm/ui/Document'; import { RootClusterUri, isDatabaseUri, isAppUri } from 'teleterm/ui/uri'; @@ -153,6 +154,8 @@ function MemoizedDocument(props: { doc: types.Document; visible: boolean }) { return ; case 'doc.connect_my_computer': return ; + case 'doc.authorize_web_session': + return ; default: return ( diff --git a/web/packages/teleterm/src/ui/ModalsHost/ModalsHost.tsx b/web/packages/teleterm/src/ui/ModalsHost/ModalsHost.tsx index 3ccb6f6c164ad..ba276907d9037 100644 --- a/web/packages/teleterm/src/ui/ModalsHost/ModalsHost.tsx +++ b/web/packages/teleterm/src/ui/ModalsHost/ModalsHost.tsx @@ -32,7 +32,6 @@ import { assertUnreachable } from '../utils'; import { UsageData } from './modals/UsageData'; import { UserJobRole } from './modals/UserJobRole'; import { ReAuthenticate } from './modals/ReAuthenticate'; -import { AuthenticateWebDevice } from './modals/AuthenticateWebDevice/AuthenticateWebDevice'; import { ChangeAccessRequestKind } from './modals/ChangeAccessRequestKind'; import { AskPin, ChangePin, OverwriteSlot, Touch } from './modals/HardwareKeys'; @@ -87,20 +86,6 @@ function renderDialog({ } switch (dialog.kind) { - case 'device-trust-authorize': { - return ( - + +## Require displaying a message of the day + +Teleport can display a custom message of the day (MOTD) for users prior to authenticating +in the Teleport Web UI and CLI. + +### Self-Hosted + +Add the following to your Teleport configuration file, which is stored in +`/etc/teleport.yaml` by default. + +```yaml +auth_service: + message_of_the_day: | + Welcome to the Example Teleport Cluster + All activity is monitored and should follow organization policies +``` + +Restart the Teleport Auth Service instances to apply this change. + +### Teleport Enterprise Cloud/Dynamic + +Edit your `cluster_auth_preference` resource: + +```code +$ tctl edit cap +``` + +Ensure that the resource includes the `message_of_the_day` field: + +```yaml +kind: cluster_auth_preference +metadata: + name: cluster-auth-preference +spec: + message_of_the_day: | + Welcome to the Example Teleport Cluster + All activity is monitored and should follow organization policies + type: local + second_factor: "on" + webauthn: + rp_id: example.teleport.sh +version: v2 +``` + +Save and close the file in your editor to apply changes.