From d50fee4fa0ea358952a83798af3400c5757dff21 Mon Sep 17 00:00:00 2001 From: Adam Chalmers Date: Thu, 5 Mar 2020 15:20:12 -0600 Subject: [PATCH] TUN-2754: Add ConnDigest to cloudflared and its RPCs --- origin/supervisor.go | 19 + origin/tunnel.go | 3 + tunnelrpc/pogs/tunnelrpc.go | 3 + tunnelrpc/pogs/tunnelrpc_test.go | 5 +- tunnelrpc/tunnelrpc.capnp | 2 + tunnelrpc/tunnelrpc.capnp.go | 713 ++++++++++++++++++++----------- 6 files changed, 493 insertions(+), 252 deletions(-) diff --git a/origin/supervisor.go b/origin/supervisor.go index a1c78571..1855151f 100644 --- a/origin/supervisor.go +++ b/origin/supervisor.go @@ -39,6 +39,7 @@ const ( var ( errJWTUnset = errors.New("JWT unset") errEventDigestUnset = errors.New("event digest unset") + errConnDigestUnset = errors.New("conn digest unset") ) // Supervisor manages non-declarative tunnels. Establishes TCP connections with the edge, and @@ -64,6 +65,9 @@ type Supervisor struct { eventDigestLock *sync.RWMutex eventDigest []byte + connDigestLock *sync.RWMutex + connDigest []byte + bufferPool *buffer.Pool } @@ -332,6 +336,21 @@ func (s *Supervisor) SetEventDigest(eventDigest []byte) { s.eventDigest = eventDigest } +func (s *Supervisor) ConnDigest() ([]byte, error) { + s.connDigestLock.RLock() + defer s.connDigestLock.RUnlock() + if s.connDigest == nil { + return nil, errConnDigestUnset + } + return s.connDigest, nil +} + +func (s *Supervisor) SetConnDigest(connDigest []byte) { + s.connDigestLock.Lock() + defer s.connDigestLock.Unlock() + s.connDigest = connDigest +} + func (s *Supervisor) refreshAuth( ctx context.Context, backoff *BackoffHandler, diff --git a/origin/tunnel.go b/origin/tunnel.go index 5b04e0d2..fa2d4b2c 100644 --- a/origin/tunnel.go +++ b/origin/tunnel.go @@ -93,6 +93,8 @@ type ReconnectTunnelCredentialManager interface { ReconnectToken() ([]byte, error) EventDigest() ([]byte, error) SetEventDigest(eventDigest []byte) + ConnDigest() ([]byte, error) + SetConnDigest(connDigest []byte) } type dupConnRegisterTunnelError struct{} @@ -380,6 +382,7 @@ func RegisterTunnel( return processRegisterTunnelError(registrationErr, config.Metrics, register) } credentialManager.SetEventDigest(registration.EventDigest) + credentialManager.SetConnDigest(registration.ConnDigest) return processRegistrationSuccess(config, logger, connectionID, registration, register) } diff --git a/tunnelrpc/pogs/tunnelrpc.go b/tunnelrpc/pogs/tunnelrpc.go index 6aab7d94..96d92910 100644 --- a/tunnelrpc/pogs/tunnelrpc.go +++ b/tunnelrpc/pogs/tunnelrpc.go @@ -47,6 +47,7 @@ type SuccessfulTunnelRegistration struct { LogLines []string TunnelID string `capnp:"tunnelID"` EventDigest []byte + ConnDigest []byte } func NewSuccessfulTunnelRegistration( @@ -54,6 +55,7 @@ func NewSuccessfulTunnelRegistration( logLines []string, tunnelID string, eventDigest []byte, + connDigest []byte, ) *TunnelRegistration { // Marshal nil will result in an error if logLines == nil { @@ -65,6 +67,7 @@ func NewSuccessfulTunnelRegistration( LogLines: logLines, TunnelID: tunnelID, EventDigest: eventDigest, + ConnDigest: connDigest, }, } } diff --git a/tunnelrpc/pogs/tunnelrpc_test.go b/tunnelrpc/pogs/tunnelrpc_test.go index 6a1d5283..f28a825e 100644 --- a/tunnelrpc/pogs/tunnelrpc_test.go +++ b/tunnelrpc/pogs/tunnelrpc_test.go @@ -22,6 +22,7 @@ var ( testErr = fmt.Errorf("Invalid credential") testLogLines = []string{"all", "working"} testEventDigest = []byte("asdf") + testConnDigest = []byte("lkjh") ) // *PermanentRegistrationError implements TunnelRegistrationError @@ -32,8 +33,8 @@ var _ TunnelRegistrationError = (*RetryableRegistrationError)(nil) func TestTunnelRegistration(t *testing.T) { testCases := []*TunnelRegistration{ - NewSuccessfulTunnelRegistration(testURL, testLogLines, testTunnelID, testEventDigest), - NewSuccessfulTunnelRegistration(testURL, nil, testTunnelID, testEventDigest), + NewSuccessfulTunnelRegistration(testURL, testLogLines, testTunnelID, testEventDigest, testConnDigest), + NewSuccessfulTunnelRegistration(testURL, nil, testTunnelID, testEventDigest, testConnDigest), NewPermanentRegistrationError(testErr).Serialize(), NewRetryableRegistrationError(testErr, testRetryAfterSeconds).Serialize(), } diff --git a/tunnelrpc/tunnelrpc.capnp b/tunnelrpc/tunnelrpc.capnp index 9ef5be43..ade41e7e 100644 --- a/tunnelrpc/tunnelrpc.capnp +++ b/tunnelrpc/tunnelrpc.capnp @@ -23,6 +23,8 @@ struct TunnelRegistration { retryAfterSeconds @5 :UInt16; # A unique ID used to reconnect this tunnel. eventDigest @6 :Data; + # A unique ID used to prove this tunnel was previously connected to a given metal. + connDigest @7 :Data; } struct RegistrationOptions { diff --git a/tunnelrpc/tunnelrpc.capnp.go b/tunnelrpc/tunnelrpc.capnp.go index 51876fb7..194b0a04 100644 --- a/tunnelrpc/tunnelrpc.capnp.go +++ b/tunnelrpc/tunnelrpc.capnp.go @@ -106,6 +106,11 @@ func (s Authentication_List) At(i int) Authentication { return Authentication{s. func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) } +func (s Authentication_List) String() string { + str, _ := text.MarshalList(0xc082ef6e0d42ed1d, s.List) + return str +} + // Authentication_Promise is a wrapper for a Authentication promised by a client call. type Authentication_Promise struct{ *capnp.Pipeline } @@ -120,12 +125,12 @@ type TunnelRegistration struct{ capnp.Struct } const TunnelRegistration_TypeID = 0xf41a0f001ad49e46 func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) { - st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}) + st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6}) return TunnelRegistration{st}, err } func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) { - st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}) + st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6}) return TunnelRegistration{st}, err } @@ -251,12 +256,26 @@ func (s TunnelRegistration) SetEventDigest(v []byte) error { return s.Struct.SetData(4, v) } +func (s TunnelRegistration) ConnDigest() ([]byte, error) { + p, err := s.Struct.Ptr(5) + return []byte(p.Data()), err +} + +func (s TunnelRegistration) HasConnDigest() bool { + p, err := s.Struct.Ptr(5) + return p.IsValid() || err != nil +} + +func (s TunnelRegistration) SetConnDigest(v []byte) error { + return s.Struct.SetData(5, v) +} + // TunnelRegistration_List is a list of TunnelRegistration. type TunnelRegistration_List struct{ capnp.List } // NewTunnelRegistration creates a new list of TunnelRegistration. func NewTunnelRegistration_List(s *capnp.Segment, sz int32) (TunnelRegistration_List, error) { - l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 5}, sz) + l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 6}, sz) return TunnelRegistration_List{l}, err } @@ -268,6 +287,11 @@ func (s TunnelRegistration_List) Set(i int, v TunnelRegistration) error { return s.List.SetStruct(i, v.Struct) } +func (s TunnelRegistration_List) String() string { + str, _ := text.MarshalList(0xf41a0f001ad49e46, s.List) + return str +} + // TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call. type TunnelRegistration_Promise struct{ *capnp.Pipeline } @@ -530,6 +554,11 @@ func (s RegistrationOptions_List) Set(i int, v RegistrationOptions) error { return s.List.SetStruct(i, v.Struct) } +func (s RegistrationOptions_List) String() string { + str, _ := text.MarshalList(0xc793e50592935b4a, s.List) + return str +} + // RegistrationOptions_Promise is a wrapper for a RegistrationOptions promised by a client call. type RegistrationOptions_Promise struct{ *capnp.Pipeline } @@ -679,6 +708,11 @@ func (s CapnpConnectParameters_List) Set(i int, v CapnpConnectParameters) error return s.List.SetStruct(i, v.Struct) } +func (s CapnpConnectParameters_List) String() string { + str, _ := text.MarshalList(0xa78f37418c1077c8, s.List) + return str +} + // CapnpConnectParameters_Promise is a wrapper for a CapnpConnectParameters promised by a client call. type CapnpConnectParameters_Promise struct{ *capnp.Pipeline } @@ -737,6 +771,9 @@ func (s ConnectResult_result) Which() ConnectResult_result_Which { return ConnectResult_result_Which(s.Struct.Uint16(0)) } func (s ConnectResult_result) Err() (ConnectError, error) { + if s.Struct.Uint16(0) != 0 { + panic("Which() != err") + } p, err := s.Struct.Ptr(0) return ConnectError{Struct: p.Struct()}, err } @@ -767,6 +804,9 @@ func (s ConnectResult_result) NewErr() (ConnectError, error) { } func (s ConnectResult_result) Success() (ConnectSuccess, error) { + if s.Struct.Uint16(0) != 1 { + panic("Which() != success") + } p, err := s.Struct.Ptr(0) return ConnectSuccess{Struct: p.Struct()}, err } @@ -809,6 +849,11 @@ func (s ConnectResult_List) At(i int) ConnectResult { return ConnectResult{s.Lis func (s ConnectResult_List) Set(i int, v ConnectResult) error { return s.List.SetStruct(i, v.Struct) } +func (s ConnectResult_List) String() string { + str, _ := text.MarshalList(0xff8d9848747c956a, s.List) + return str +} + // ConnectResult_Promise is a wrapper for a ConnectResult promised by a client call. type ConnectResult_Promise struct{ *capnp.Pipeline } @@ -910,6 +955,11 @@ func (s ConnectError_List) At(i int) ConnectError { return ConnectError{s.List.S func (s ConnectError_List) Set(i int, v ConnectError) error { return s.List.SetStruct(i, v.Struct) } +func (s ConnectError_List) String() string { + str, _ := text.MarshalList(0xb14ce48f4e2abb0d, s.List) + return str +} + // ConnectError_Promise is a wrapper for a ConnectError promised by a client call. type ConnectError_Promise struct{ *capnp.Pipeline } @@ -1000,6 +1050,11 @@ func (s ConnectSuccess_List) At(i int) ConnectSuccess { return ConnectSuccess{s. func (s ConnectSuccess_List) Set(i int, v ConnectSuccess) error { return s.List.SetStruct(i, v.Struct) } +func (s ConnectSuccess_List) String() string { + str, _ := text.MarshalList(0x8407e070e0d52605, s.List) + return str +} + // ConnectSuccess_Promise is a wrapper for a ConnectSuccess promised by a client call. type ConnectSuccess_Promise struct{ *capnp.Pipeline } @@ -1158,6 +1213,11 @@ func (s ClientConfig_List) At(i int) ClientConfig { return ClientConfig{s.List.S func (s ClientConfig_List) Set(i int, v ClientConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s ClientConfig_List) String() string { + str, _ := text.MarshalList(0xf0a143f1c95a678e, s.List) + return str +} + // ClientConfig_Promise is a wrapper for a ClientConfig promised by a client call. type ClientConfig_Promise struct{ *capnp.Pipeline } @@ -1238,6 +1298,11 @@ func (s SupervisorConfig_List) Set(i int, v SupervisorConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s SupervisorConfig_List) String() string { + str, _ := text.MarshalList(0xf7f49b3f779ae258, s.List) + return str +} + // SupervisorConfig_Promise is a wrapper for a SupervisorConfig promised by a client call. type SupervisorConfig_Promise struct{ *capnp.Pipeline } @@ -1339,6 +1404,11 @@ func (s EdgeConnectionConfig_List) Set(i int, v EdgeConnectionConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s EdgeConnectionConfig_List) String() string { + str, _ := text.MarshalList(0xc744e349009087aa, s.List) + return str +} + // EdgeConnectionConfig_Promise is a wrapper for a EdgeConnectionConfig promised by a client call. type EdgeConnectionConfig_Promise struct{ *capnp.Pipeline } @@ -1421,6 +1491,9 @@ func (s ReverseProxyConfig_originConfig) Which() ReverseProxyConfig_originConfig return ReverseProxyConfig_originConfig_Which(s.Struct.Uint16(0)) } func (s ReverseProxyConfig_originConfig) Http() (HTTPOriginConfig, error) { + if s.Struct.Uint16(0) != 0 { + panic("Which() != http") + } p, err := s.Struct.Ptr(1) return HTTPOriginConfig{Struct: p.Struct()}, err } @@ -1451,6 +1524,9 @@ func (s ReverseProxyConfig_originConfig) NewHttp() (HTTPOriginConfig, error) { } func (s ReverseProxyConfig_originConfig) Websocket() (WebSocketOriginConfig, error) { + if s.Struct.Uint16(0) != 1 { + panic("Which() != websocket") + } p, err := s.Struct.Ptr(1) return WebSocketOriginConfig{Struct: p.Struct()}, err } @@ -1481,6 +1557,9 @@ func (s ReverseProxyConfig_originConfig) NewWebsocket() (WebSocketOriginConfig, } func (s ReverseProxyConfig_originConfig) HelloWorld() (HelloWorldOriginConfig, error) { + if s.Struct.Uint16(0) != 2 { + panic("Which() != helloWorld") + } p, err := s.Struct.Ptr(1) return HelloWorldOriginConfig{Struct: p.Struct()}, err } @@ -1551,6 +1630,11 @@ func (s ReverseProxyConfig_List) Set(i int, v ReverseProxyConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s ReverseProxyConfig_List) String() string { + str, _ := text.MarshalList(0xc766a92976e389c4, s.List) + return str +} + // ReverseProxyConfig_Promise is a wrapper for a ReverseProxyConfig promised by a client call. type ReverseProxyConfig_Promise struct{ *capnp.Pipeline } @@ -1690,6 +1774,11 @@ func (s WebSocketOriginConfig_List) Set(i int, v WebSocketOriginConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s WebSocketOriginConfig_List) String() string { + str, _ := text.MarshalList(0xf9c895683ed9ac4c, s.List) + return str +} + // WebSocketOriginConfig_Promise is a wrapper for a WebSocketOriginConfig promised by a client call. type WebSocketOriginConfig_Promise struct{ *capnp.Pipeline } @@ -1867,6 +1956,11 @@ func (s HTTPOriginConfig_List) Set(i int, v HTTPOriginConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s HTTPOriginConfig_List) String() string { + str, _ := text.MarshalList(0xe4a6a1bc139211b4, s.List) + return str +} + // HTTPOriginConfig_Promise is a wrapper for a HTTPOriginConfig promised by a client call. type HTTPOriginConfig_Promise struct{ *capnp.Pipeline } @@ -1965,6 +2059,11 @@ func (s DoHProxyConfig_List) At(i int) DoHProxyConfig { return DoHProxyConfig{s. func (s DoHProxyConfig_List) Set(i int, v DoHProxyConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s DoHProxyConfig_List) String() string { + str, _ := text.MarshalList(0xb167b0bebe562cd0, s.List) + return str +} + // DoHProxyConfig_Promise is a wrapper for a DoHProxyConfig promised by a client call. type DoHProxyConfig_Promise struct{ *capnp.Pipeline } @@ -2015,6 +2114,11 @@ func (s HelloWorldOriginConfig_List) Set(i int, v HelloWorldOriginConfig) error return s.List.SetStruct(i, v.Struct) } +func (s HelloWorldOriginConfig_List) String() string { + str, _ := text.MarshalList(0x8891f360e47c30d3, s.List) + return str +} + // HelloWorldOriginConfig_Promise is a wrapper for a HelloWorldOriginConfig promised by a client call. type HelloWorldOriginConfig_Promise struct{ *capnp.Pipeline } @@ -2099,6 +2203,11 @@ func (s Tag_List) At(i int) Tag { return Tag{s.List.Struct(i)} } func (s Tag_List) Set(i int, v Tag) error { return s.List.SetStruct(i, v.Struct) } +func (s Tag_List) String() string { + str, _ := text.MarshalList(0xcbd96442ae3bb01a, s.List) + return str +} + // Tag_Promise is a wrapper for a Tag promised by a client call. type Tag_Promise struct{ *capnp.Pipeline } @@ -2224,6 +2333,11 @@ func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct( func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) } +func (s ServerInfo_List) String() string { + str, _ := text.MarshalList(0xf2c68e2547ec3866, s.List) + return str +} + // ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call. type ServerInfo_Promise struct{ *capnp.Pipeline } @@ -2307,6 +2421,11 @@ func (s UseConfigurationResult_List) Set(i int, v UseConfigurationResult) error return s.List.SetStruct(i, v.Struct) } +func (s UseConfigurationResult_List) String() string { + str, _ := text.MarshalList(0xd58a254e7a792b87, s.List) + return str +} + // UseConfigurationResult_Promise is a wrapper for a UseConfigurationResult promised by a client call. type UseConfigurationResult_Promise struct{ *capnp.Pipeline } @@ -2371,6 +2490,9 @@ func (s FailedConfig_config) Which() FailedConfig_config_Which { return FailedConfig_config_Which(s.Struct.Uint16(0)) } func (s FailedConfig_config) Supervisor() (SupervisorConfig, error) { + if s.Struct.Uint16(0) != 0 { + panic("Which() != supervisor") + } p, err := s.Struct.Ptr(0) return SupervisorConfig{Struct: p.Struct()}, err } @@ -2401,6 +2523,9 @@ func (s FailedConfig_config) NewSupervisor() (SupervisorConfig, error) { } func (s FailedConfig_config) EdgeConnection() (EdgeConnectionConfig, error) { + if s.Struct.Uint16(0) != 1 { + panic("Which() != edgeConnection") + } p, err := s.Struct.Ptr(0) return EdgeConnectionConfig{Struct: p.Struct()}, err } @@ -2431,6 +2556,9 @@ func (s FailedConfig_config) NewEdgeConnection() (EdgeConnectionConfig, error) { } func (s FailedConfig_config) Doh() (DoHProxyConfig, error) { + if s.Struct.Uint16(0) != 2 { + panic("Which() != doh") + } p, err := s.Struct.Ptr(0) return DoHProxyConfig{Struct: p.Struct()}, err } @@ -2461,6 +2589,9 @@ func (s FailedConfig_config) NewDoh() (DoHProxyConfig, error) { } func (s FailedConfig_config) ReverseProxy() (ReverseProxyConfig, error) { + if s.Struct.Uint16(0) != 3 { + panic("Which() != reverseProxy") + } p, err := s.Struct.Ptr(0) return ReverseProxyConfig{Struct: p.Struct()}, err } @@ -2522,6 +2653,11 @@ func (s FailedConfig_List) At(i int) FailedConfig { return FailedConfig{s.List.S func (s FailedConfig_List) Set(i int, v FailedConfig) error { return s.List.SetStruct(i, v.Struct) } +func (s FailedConfig_List) String() string { + str, _ := text.MarshalList(0xea20b390b257d1a5, s.List) + return str +} + // FailedConfig_Promise is a wrapper for a FailedConfig promised by a client call. type FailedConfig_Promise struct{ *capnp.Pipeline } @@ -2660,6 +2796,11 @@ func (s AuthenticateResponse_List) Set(i int, v AuthenticateResponse) error { return s.List.SetStruct(i, v.Struct) } +func (s AuthenticateResponse_List) String() string { + str, _ := text.MarshalList(0x82c325a07ad22a65, s.List) + return str +} + // AuthenticateResponse_Promise is a wrapper for a AuthenticateResponse promised by a client call. type AuthenticateResponse_Promise struct{ *capnp.Pipeline } @@ -3053,6 +3194,11 @@ func (s TunnelServer_registerTunnel_Params_List) Set(i int, v TunnelServer_regis return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_registerTunnel_Params_List) String() string { + str, _ := text.MarshalList(0xb70431c0dc014915, s.List) + return str +} + // TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call. type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline } @@ -3132,6 +3278,11 @@ func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_regi return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_registerTunnel_Results_List) String() string { + str, _ := text.MarshalList(0xf2c122394f447e8e, s.List) + return str +} + // TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call. type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline } @@ -3186,6 +3337,11 @@ func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getSer return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_getServerInfo_Params_List) String() string { + str, _ := text.MarshalList(0xdc3ed6801961e502, s.List) + return str +} + // TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call. type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline } @@ -3261,6 +3417,11 @@ func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getSe return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_getServerInfo_Results_List) String() string { + str, _ := text.MarshalList(0xe3e37d096a5b564e, s.List) + return str +} + // TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call. type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline } @@ -3323,6 +3484,11 @@ func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unr return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_unregisterTunnel_Params_List) String() string { + str, _ := text.MarshalList(0x9b87b390babc2ccf, s.List) + return str +} + // TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call. type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline } @@ -3373,6 +3539,11 @@ func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_un return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_unregisterTunnel_Results_List) String() string { + str, _ := text.MarshalList(0xa29a916d4ebdd894, s.List) + return str +} + // TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call. type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline } @@ -3448,6 +3619,11 @@ func (s TunnelServer_connect_Params_List) Set(i int, v TunnelServer_connect_Para return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_connect_Params_List) String() string { + str, _ := text.MarshalList(0xa766b24d4fe5da35, s.List) + return str +} + // TunnelServer_connect_Params_Promise is a wrapper for a TunnelServer_connect_Params promised by a client call. type TunnelServer_connect_Params_Promise struct{ *capnp.Pipeline } @@ -3527,6 +3703,11 @@ func (s TunnelServer_connect_Results_List) Set(i int, v TunnelServer_connect_Res return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_connect_Results_List) String() string { + str, _ := text.MarshalList(0xfeac5c8f4899ef7c, s.List) + return str +} + // TunnelServer_connect_Results_Promise is a wrapper for a TunnelServer_connect_Results promised by a client call. type TunnelServer_connect_Results_Promise struct{ *capnp.Pipeline } @@ -3639,6 +3820,11 @@ func (s TunnelServer_authenticate_Params_List) Set(i int, v TunnelServer_authent return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_authenticate_Params_List) String() string { + str, _ := text.MarshalList(0x85c8cea1ab1894f3, s.List) + return str +} + // TunnelServer_authenticate_Params_Promise is a wrapper for a TunnelServer_authenticate_Params promised by a client call. type TunnelServer_authenticate_Params_Promise struct{ *capnp.Pipeline } @@ -3718,6 +3904,11 @@ func (s TunnelServer_authenticate_Results_List) Set(i int, v TunnelServer_authen return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_authenticate_Results_List) String() string { + str, _ := text.MarshalList(0xfc5edf80e39c0796, s.List) + return str +} + // TunnelServer_authenticate_Results_Promise is a wrapper for a TunnelServer_authenticate_Results promised by a client call. type TunnelServer_authenticate_Results_Promise struct{ *capnp.Pipeline } @@ -3844,6 +4035,11 @@ func (s TunnelServer_reconnectTunnel_Params_List) Set(i int, v TunnelServer_reco return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_reconnectTunnel_Params_List) String() string { + str, _ := text.MarshalList(0xa353a3556df74984, s.List) + return str +} + // TunnelServer_reconnectTunnel_Params_Promise is a wrapper for a TunnelServer_reconnectTunnel_Params promised by a client call. type TunnelServer_reconnectTunnel_Params_Promise struct{ *capnp.Pipeline } @@ -3923,6 +4119,11 @@ func (s TunnelServer_reconnectTunnel_Results_List) Set(i int, v TunnelServer_rec return s.List.SetStruct(i, v.Struct) } +func (s TunnelServer_reconnectTunnel_Results_List) String() string { + str, _ := text.MarshalList(0xd4d18de97bb12de3, s.List) + return str +} + // TunnelServer_reconnectTunnel_Results_Promise is a wrapper for a TunnelServer_reconnectTunnel_Results promised by a client call. type TunnelServer_reconnectTunnel_Results_Promise struct{ *capnp.Pipeline } @@ -4067,6 +4268,11 @@ func (s ClientService_useConfiguration_Params_List) Set(i int, v ClientService_u return s.List.SetStruct(i, v.Struct) } +func (s ClientService_useConfiguration_Params_List) String() string { + str, _ := text.MarshalList(0xb9d4ef45c2b5fc5b, s.List) + return str +} + // ClientService_useConfiguration_Params_Promise is a wrapper for a ClientService_useConfiguration_Params promised by a client call. type ClientService_useConfiguration_Params_Promise struct{ *capnp.Pipeline } @@ -4146,6 +4352,11 @@ func (s ClientService_useConfiguration_Results_List) Set(i int, v ClientService_ return s.List.SetStruct(i, v.Struct) } +func (s ClientService_useConfiguration_Results_List) String() string { + str, _ := text.MarshalList(0x91f7a001ca145b9d, s.List) + return str +} + // ClientService_useConfiguration_Results_Promise is a wrapper for a ClientService_useConfiguration_Results promised by a client call. type ClientService_useConfiguration_Results_Promise struct{ *capnp.Pipeline } @@ -4159,253 +4370,255 @@ func (p ClientService_useConfiguration_Results_Promise) Result() UseConfiguratio } const schema_db8274f9144abc7e = "x\xda\xccZ{\x90Tev?\xe7\xde\x1e\xee\x0c\xcc" + - "\xd0}s\xdbr\xa0\x18:\xa0Da\x85\x88\xb3$\xee" + - "$\xd9\x9e\x07\xc3\xce\xb0<\xe6N\xcf\xa0\x8e$\xe5\x9d" + - "\xeeof\xee\xd0}os\x1f\xc0\x10X\x1e\x85Q&" + - "\xa0\xe8J\x0a\\\xdcR\\\xe3#&+.VV\x03" + - "\x96&\x9b\xa8Y\x89\xeb\x06R\xb2\xd1\x0a\x0aVJK" + - "\xcb\xc5G\x19R\xeaM\x9d\xfb\x9ef\x18\xc0$U\xfb" + - "\x0ft\x9d{\xbe\xc7y\xfd\xce\xe3\x9b\xeb\xef\x9a\xdc\xcc" + - "-\xac\xba&\x09 ?U5\xc9a\xf3~\xb9\xf1\xc1" + - "9\xff\xb0\x1d\xe4\xe9\x88\xce\xf7\x8e,M\x9f\xb3\xb6\xff" + - ";T\xf1\x02@\xe3\x88\xb0\x11\xa5\xdd\x82\x00 \xed\x14" + - "\xfe\x13\xd0\xa9\xfa\x9d\x13\xa7\xca\xa7\x84\x1d N\x8f3" + - "s\xc4\\\xaa^\x8a\xd2\xb6jb\xde\\\xbd\x1e\xd0\xf9" + - "\xc3\xd2k\x07\x7fo\xef\xcf\x89\x99\x8b\x98\x01\x1b\xdf\xad" + - "\xde\x88\xd29\x97\xf3\xb3\xea\x95\x80\xce'\xf7\xd5\xff\xd5" + - "C\xff\xf2\xf2\xed ^\x83\xe0\x9f]W\xf3+\x04\x94" + - "f\xd5\xfc\x18\xd0\xf9\xd7\xeb7\x9d\xb9\xed\x93{\xee\x1c" + - "{n\x82\xf8^\xac\x19E\xe9d\x8d\x00\xbc\xf3\xc0\xad" + - "\xe9\x7f\xc6\x07?\xbf\x07\xc4ki\x1b\xa4\xcf\xcf\xd4L" + - "\xe6\x00\xa5c5Y@\xe7\xb5\xeb\x8e<\xb7\xe7'w" + - "\xfc\x00\xe4k\x10\xc1[\xffa\xcd\x7f\xd398\x99\x18" + - "\xce\xfe\xe8\x1b\x89\xbf~\xed\xb7~\xe828\x8f\xbc~" + - "\xd3\xd3{~\xf2\xdb\xefC/'`\x02\xa0q\xeed" + - "\x83x\x17M&]\xdc\xf7\xc6\xd1\x15\xa5{\xee?\xe8" + - "]\xda\xdd\xeb\x8a)\x1c\x07\x09gG\xe7\xe7\xa5\xde\x87" + - "s\x0f\xfb\xe2\xb8\x9fj\xa6|LK\x1b\xa6\xd0\xd2E" + - "\xbfzw\xe5\xf2\xa7\x07\x1e\xf5\x19\xdc\x8b\x9e\x9b\xf24" + - "1\xd4\xd4\xd2=^^\x9f\xda\xd5\xf2\xfbw?Zi" + - "\x95*\xe2\x9c_;\x8aR{-\xfdl\xa9\xbd\x09\x01" + - "\x9d\xd1o\x1d]\xf5\xc9\x9f\x99O\x80<\x1f\x13\xce\xcf" + - "v\x9e^7\xf7\xf1\x81\x97\xdck\xf3\x00\x8d\xcf\xd6\xfd" + - "\x92\xb6>VG\xaa\xac\xfb\xbby+\xee>\xb3\xec\x10" + - "m\x1d3\x8bw\x89\xd2\xd4&\x946O%\xcb\x8cL" + - "%\xee_\\\xb7\xea\xf9\xe7\x9f\x1a\x1d~\xd6e\xb8\xf5" + - "\x8bg\xfe\xbe\xfd\xa3\xe3\xcf\xc6-tO\x8a#\x0b=" + - "\x92\"\xc1\xfbF\xb1\xf4fS\xf3\xf3 _\x8b\xe8\x0c" + - "\xef\xdddu\xec\xdb\xed@/\x0a\xc8\x014\x1eKm" + - "\xa4\xcdN\xa6\xc8\xbf\x1a>l\xad\xd3>\xda\xfeB\x85" + - "3\xba\xa7.\x12\x97\xa2\xd4)\xd2\xd5\xda\xc5\x1f\x03~" + - "\xfe\xc4\x1d{:O/~I\x9e\x8e\x89J\xa1\xdf\x16" + - "7\xa2\xf4\x19\xf16\x9e\x153\xa4\xcfP\x83\x15\xec\xae" + - "\xd4\xb3\xa4a\x94\x16I\xf4s\xa1\xe4\xb2/\xbd\xf5\xfb" + - "\xf7V\xbd\xfb\xfd\x97*UJ\x1e\xde\xf8Gi\x03%" + - "9M?\x97\xa7\xaf\xe4\x01\x9d\xe9O\xfd\xc1\xdf\xb4\x16" + - "N\xfe|\x9c \x92\x8e]\xf9\xb1t\xf2J\xfau\xe2" + - "J\x92\xf1\xf4\xfcC\x7f\xfa\xde\xee\xd7\x8f\xc7=ea" + - "\xbd\xeb\xb1\xed\xf5\xa4\xb0;\xbe1\xb2q\xc5\x9c\xd1\x13" + - "\x95\x06r9Y\xfd(J\x9b\xeb]s\xd6\xd3v\xdc" + - "\xbb\xca\xb4\xad\xff\xf6\xed7c>\xfb^\xfd;\x08\x09" + - "g\xc5\xaa[\x87k6\x9f>\x1d?\xe8\xadz\xcft" + - "\xeeA\x87\xc5{\xa5#\x0f\xfd\xe5\x19:H\xa8T\xb7" + - "8\xad\x0f\xa59\xd3\\\xf5L{\x94\x83X\xec\x8c\xe7" + - "8\x0d3\x9aP\x9a?\xc3u\x9c\x19t\xafE\xb7\xb5" + - "\xb0\xd57\xde\xfc>\x88\xd3\xf91P\xa1\x12\xe7\x08q" + - "6\xda3\xee@is\x83\x00\xe0\xdc5\xd8\xf7\xca\xd9" + - "\xb6\x87~]\xb9\xb9+\x10khB\xc9&\xbe\xc6\xb5" + - "\x0d\xae}\x1a\x17\xfe\xf9\x87{\x1fn;{\xde\xeeG" + - "g\xb6\xa2tl&\xdd\xe3\x95\x99\xdf\x91\xce\xcdt7" + - "\xff\xde\xe2\x95\xdf\x9a\xfd\xe2\xc7qM\xbc=\xd3\x8d\xde" + - "\xcff\x92&\x06n\xfc\xe0;s\xee\xfa\xa7\x8f+\xec" + - "\xe72^\x91\x99\x87\xd2\x9c\x0c\xed8+\x93\x05\xfch" + - "\xc9\x0f\x8fOON\xfft\xbc8n\xcf\x0c\xa3t\x0b" + - "\xf16\xf6f\xee\xa6\x8b\xde\xfc\xce\xfd\xeb\xb3?\xf8\xf4" + - "s\x92\x8b\xaf\xc0\xb9\x9aY}(5\xcc\xa2\x9d\xa7\xcd" + - "\xa2XZ\xf6\xe4\xc9o\x0f\xed}\xf9\xdc\xb8\xc8\xfd\x8f" + - "\xb3\xb6\xa3t\xd2\xe5>1\x8b \xe7/\x84\x03\xa7\xb7" + - "\xfe\xc7\x9f|\x11\x97\xea\xe8\xecwH\xaa\xd7g\x93T" + - "\x9b>\xda\xdfq\xf7\xea'\xbf\x8a3\x9c\x9d\xfd\x9c\x8b" + - "\x8dW\x11C\x18\x8c\xe3y\xda\xac\xabZQZx\x15" + - "\x9d7\xff\xaa,\xccw,[\xd3X\xd1('\xf2\xbf" + - "\x1b\xfc\xcc/\xc8+e\xad\xdc\xd4b[CL\xb3\xd4" + - "\xbcb\xb1n\x965\xcb\xbaf\xb2.D9\xc5'\x00" + - "\x12\x08 *\xc3\x00\xf2m<\xcaE\x0eE\xc44\xa1" + - "\xb5\xa8\x12q\x88G\xd9\xe2P\xe4\xb84!\x82\xb8v" + - "6\x80\\\xe4Q\xde\xc0!\xf2i\xc2;\xd1\xbe\x17@" + - "\xde\xc0\xa3\xbc\x83C\xa7\xcc\x8c\x92\xa21\x0d\x92V\xbb" + - "a`-pX\x0b\xe8\x18\xcc2F\x94\xfe\"$Y" + - "\x8c,\x0c\xaf\xb7\xb0\x0e8\xac\x03t\x86t\xdb0{" + - "5\x0b\xd5b7\x1b0\x98\x89C8\x098\x9c\x048" + - "\x91xm\xba\xa6\xb1\xbc\x95\xb3\xf3yf\x9a\x00$Y" + - "u(\xd9\xdc\xfb\x01\xe4\xebx\x94o\x8cI\xb6\x88$" + - "\xfb&\x8fr3\x87\x8e\xc9\x8cu\xccX\xa6c^\xb1" + - "T][\xa1\xf0%\x16^;_T\x99f\xb5\xe9\x90" + - "\xd4\x06\xd4ALE\xa1\x00\x88\xa9\x89/\xd6\xbeA5" + - "-U\x1b\xecq\xe9\xd9.\xbd\xa8\xe6G\xe8v\xb5\xae" + - "&\x1b\x9ah\x0f\xf1\x8a>\x00\xe4D\xb1\x15 \xab\x0e" + - "j\xba\xc1\x9c\x82j\xe6I(\xe0\xf3\xd6\x96~\xa5\xa8" + - "hy\x16\x1e4\xe9\xfc\x83\xbc\x03r\xae\x1c\x0b\x94\x98" + - "\xb5\xaf\xeeR\x0c\x85/\x99rm\xa8\x8f\xf6>\x00y" + - "1\x8frWL\x1f\xcb\x97\x02\xc8\xcbx\x94o\x8eY" + - "\xba\xb7\x15@\xee\xe2Q^\xcd\xa1\xa3\x1b\xea\xa0\xaa\xb5" + - "1\xe0\x8d\xb8\xc1LKSJ\x0c\x00\x02\x85m\xd1\xcb" + - "\xa4D\x13S\x11JWh\xaa\xea|\x01:X\xb1\xa8" + - "\xdf\xa4\x1b\xc5\xc2J\xef\x1c\x9d\xb4\xed\x9a2\\&\x8c" + - "cy\xd78$\xb7\x9ag\x0bl\x93y\xebl\xc35" + - "\xe4\xd5\xdd\xcc\xb4\x8b\x96\x09 'B\xf1\xeb\x9a\x00\xe4" + - "j\x1e\xe54\x87Y\xc3e\xc0T\x04\xea\x15W\xbd\x98" + - "\xaem\xcd`\x83\xaai1\xc3#_\x9d%\x85\x97\xcc" + - "\xf8\x81\xe4\x7f)\x1e\xe5\x19\x1c:\x83\x86\x92g]\xcc" + - "@U/\xacP4=\xc7\xb3~\x10@~\x92G\xf9\xa7\xa4I\xce\xd3\xe4" + - "3\xf3\xa8m\xe2Q~\x95C1\xc1\xa7\xa9+\x10_" + - "\xa1\x90z\x95G\xf9\x0d\x0e\xc5\xaaD\x1a\xab\x00\xc4\x13" + - "d\x9d\xe3<\xca\xa7.\x84V\xf9\xa2n\x17\x06\x8a\x0a" + - "d\x0cV\xe8\\\x1c\xd25\xbb\xd4e\xb0u*\xea\xb6" + - "\xd9bY\xac$\x94-3H\xa9\xe8Z\x1e\xe5or(0\x83\xf2" + - "d\xd8\xe9{\x87n1\xbd\x8a\x14S\xd1\x18\xe7\xe2\xd7" + - "\x89\x15\xeb\xaa\xae\x9d\xe7\x86\xb3\xa3p\x09M\xd8yC" + - "\xcc\xae\x81\x09\x97\xf7Gv\x15\xd6\xb0\x91\xc0J\x19V" + - "R\xd4\x08\x8d|\xe3\xb6\x80\xf0\xdd\x88g\xc2\xa2\xd6O" + - "\xfe^\xea\xcfz\xd6\xa2K\xa6\xc3Kn\x1e\x05\x90\xb7" + - "\xf2(\xef\x8a]r'\xf5\x08\xbbx\x94\xf7\xc5.\xb9" + - "\x97\x94\xb8\x87G\xf9@,{\xee'\x03\x1f\xe0Q~" + - "\x8cCLx\x90\xff\x08A\xfec<\xca\x879\x17\xb0" + - ";Z\xdat\x0d\xfdK\x98\x00a\x9f0\xc4\x14\xc3\xea" + - "g\x0aZ\x9d\x9a\xc5\x8cu\x0a\x16\x03H\xd8b\xa9%" + - "\xa6\xdbV\x08\x11%e\x83[Xa\xa1\xc3[%(" + - "\x96\x895\xc0a\x0dE\xa4\xc9\x8c6\x83\x15\x90\xac\xa1" + - "\x14\xbb\x14\xde\x1a\xba\x14\x05\x8d\x05\xf1\xe48\xea\xa1\xb2" + - "l\x13\x8f\xf2\x9d\x04%\x18\x9b&\x89\xb7\x0f\x03\xe7\"" + - "\x09\xc9\xbc\xb65^Zp^\x9a\x8b\xb7ZnB\x9c" + - "\x04 n#\xed\xec\xe0Q\xde\xc3\x05W\xeb\xd0!\xeb" + - "Eh\xa5\xa9\xfdVf\x0b\xa1\xa6\xca\"y\xfdzA" + - "E]\xebq\x15\x85\x91\xa6\xf2z\xa9l\x90+\xab\xba" + - "&\xdbJQ\xe5\xad\x91p\xe1\x84\xba H\xf2By" + - "e9\xe3\x1a\x8b\x94qc\xa0\x0ci\x04\x97\x02\xe46" + - " \x8f\xb9\x1d\x18\xb9\x8b\xb4\x0d[\x01r\x9b\x88~'" + - "F\x1e#\xdd\x8e\xd3\x01r[\x89\xbe\x0b\xc3\x0eT\xda" + - "\x89O\x00\xe4v\x11y\x1fF\xa5\x82\xb4\xd7\xdd\xfe>" + - "\xa2?\x88Q\xb5 =\x80\xf3\x00r\xfb\x88~\x98\xe8" + - "\x938W\x93\xd2!\x1c\x06\xc8=E\xf4#D\x17\xaa" + - "\xd2\xd4nK\xcf\xa2\x01\x90\xfb)\xd1\x7fF\xf4\xea\xfa" + - "4V\x03H/\xba\xf4\x17\x88\xfe*\xd1k\xa6\xa5\xb1" + - "\x06@z\x05\xb7\x03\xe4^&\xfaq\xa2O\xc64N" + - "\x06\x90^\xc7\xfb\x01r\xc7\x89~\x8a\xe8S&\xa5q" + - "\x0a\x80\xf4\x96{\x9f7\x88~\x86\xe8\xb5\x894\xd6\x02" + - "Ho\xe3A\x80\xdc\x19\xa2\xff\x9a\xe8uB\x1a\xeb\x00" + - "\xa4\x0f]\xb9> z5\x17\xe2`g!\x0e\xc7\xe4" + - "\x86jT\x8e\xf0\xba\x19\xba\x02\xf3;S\xf4rE\x97" + - "\x9e\xa4\xd6\x14\x93\xd1\x08\x19\x10\x93\x80NY\xd7\x8b+" + - "\xc6\xc2\xfc\xc5*\"\xdf\x8d \xa9k\x9d\x850.=" + - "\xe7[\xa6C&\xaf\x14;\xcbQ\x8dd\xb6\xd8\x96n" + - "\x97!SP,V\x08\x13\xb5akK\x0c\xbd\xd4\x83" + - "\xcc(\xa9\x9aR\x84\xf0\xcbD\xbe\x98\xb4m\xb5\x10\xee" + - "=aa\xe7\x0c0\xc5\xb2\x0df\x92h\x17\xc8\xb8\\" + - "\xa5Gg\xcaM=\xca`\xc5\x80a^\x94\x1eB\xb4" + - "\x9b\x7fC\x94\x1d\x92\xf1(\xcc\xacS\x8a6\xbb\x94b" + - "p\xc2\x96\xa5;\xeb\xb5<\x17\xebl\x83q\xd8\xc5\xab" + - "\xf9\xde\x8a\xcc\xeb\xe5\xc3\xf3\xa6)\xad\x91\xb0\xa1\xac\x86" + - "?a\xe9\xe0\xa2\x9c\x17Xk\xc0\xef\\!C{\xc7" + - "\xfc&\x9cW\xfa~s\xa9\x9a\x18d\x96\xf7\xabS\x1b" + - "\xd0\xa9<\x10\x94\x92\xf95Ww33y)Z\x8c" + - "&\x90\x17\xcf\xdf\x1d==]\xd1\x10\x83\xf7\xc0\xff\xfa" + - "\x10\xefZ\xb0\x1b \xd7L\x81\xbb\x0cC\x1dJ\x9d." + - "\xeet\x10\xb9\x07\xa3\xaaW\x92]|\xe9\"\xfaj\x8c" + - "\xfa\"\xe9\x16\x17\x17V\x13}\xc8\xc5\xbb\x16\x0f\xef\x98" + - "\xbb}\x81\xe8e\x17\xef\xd0\xc3\xbb\x92\xbb\x7f\x91\xe8\x1b" + - "\xe2xg\xe3\xe8\x18\xf8\x15x\x0f\xef\xb6\xb98\xb5\x83" + - "\xe8{\\\xbcKxx\xb7\x1b\x9f\x06\xc8\xed!\xfa\x01" + - "\x17\xef\xaa<\xbc\xdb\x8f\xcf\x01\xe4\x0e\x10\xfd1\x17\xef" + - "&yx\xf7\x88\xcb\xffX\x88\xb3SZ=\xbc;\xe4" + - "\xe2c\x88\xb3\x8em\x14s\x96\xa1j\x80\x83Ql\xe4" + - "\xcb\xdfe\xac\xdc\x02\xc9\xa2\xba\x8e\x85\xb9\xa8\xa0*\xc5" + - "\xc5\xb6R\x84L\xceR\xf2k\xa2\xd2\xbehv(Z" + - "\xc1\xc4!e\x0d\xa3\x0c&\xc4s\xbdU4W1C" + - "\x1d\x00\x8c\x9a\x81\xb0\xf6Iv\xe9zeI\xe4\xd6\x94" + - "\xcc\xf0\xc0/\xfcVR6t\x16\x8a\xac\x0d\x83\x0a\x88" + - "\xd7\xa2\x0c\xaa\xd2\x17]\xd3\xd0+Kz\xd4\xcc\xd8z" + - "\xa3\xec\xb7\x17A\xdd\xd2\x93\xad(H\xd8\x862\xcb[" + - "m:j\x96\xaa\xd9\xec\xbc\x0d\xf2C\xb6\xb6\x86\x15\xda" + - "Q\xcb\xeb\x05U\x1b\x84\xf3\xfa\x1a\xfeB\xb3\xa3X\xa1" + - "\xe6F3\xc6\xde\xde\xc4\xb9M\xc0\xb9\xd0Ee\x87\xd8" + - "\x14M\x07\xb2ywU\xd6`\x8a\x19kl'8\xcd" + - "\x9fuzA\xe6M\x02\xaa\x00\xc2\x87*\x0c\x86\xfd\xe2" + - "\xa1\x8d\xc0\x89\x8f\x0b\x18\xbd\x91`\xf0$\">`\x00" + - "'\xee\x15\x90\x0b\x1f\x101x\xfc\x13w\x8e\x02'\xde" + - ". \x1f>\xeaa0I\x17GZ\x81\x13K\x02&" + - "\xc2\x07N\x0c\xc6\xf0\xa2B\xa5\xd5-\x02V\x85\xaf\x85" + - "\x18\xbc\xf5\x88\xcb\xb7\x03'\xb6\x0bN\xd0AA\xd6\x13" + - "\xa3\x19\x9d\x000 \xe3BF3:\xc1\xf4\x09\x83N" + - "\x0b\xa0\x19\xb7\xf8\xf0\xdc\x8cN0\x7f\x85d^\xb1X" + - "3\xb5\xa7\xdeG\xf4\xc1\x1b\x9a1>\xd7\xe4/\xd4\x13" + - "\x8d_[\xb7F\xf5_\x00\xc0\xdbF\xa3\xf2/\xecC" + - "w?\x11/\xad\xfdq\xca\xfe\xed\xfe0\xe6pl\x9c" + - "r\x88\xea\xed\xc3<\xca\xbf\xe0\xa2\xa2!\xf0\xe9`\x14" + - "\x88\xba\x114\xc6\x13L\x04}\xcf\xf7\xcb\xde\xca\xb9\xa0" + - "S\xd0\x87\xdc\xb2\x18\xbd\xadL\x88\xd2A|X85" + - "6,\xc4\xa0%\x17\xc6d\x8f\xf8\xe8p\xeaE\xfa\xbb" + - "x\x83\xe9\xa6\xb3\x84\xeb\x92\xc1\xd3(\x06\xaf\xd8\xa2H" + - "\xaeU'8A\x13\x8aA.\x84\x0a\x93]f'\xde" + - "\xcd2\xff\x9bd=\x8e\x83x\xe7$\xc9#=\x81\xc2" + - "}\x87c\xa3\xbd\xa2\xee7\x91\xc9\x15\xf1>`\x02]" + - "y\x17\x0e\xaa\xf6$-\xa6\xfdg\x84\xfb?3\xdb\x9f" + - "\xc7\x1d\x89\x15;\xcf\xce\xf6\x1d\xe8\x85Xkwt)" + - "\x80|\xc4\x1b\xd2\x05\xefD'\xc8Q\xdf\xe0Q>\x13" + - "s\xbf\xb7\x89\xf1\x14\x8f\xf2\x07Q\xbe\x12\xdf\xa36\xe7" + - "\x03\x1e\xe5\xff\xa2d\x95\xf0\xda\x9c\xcf\xa8\xa5\xfd\x94\xc7" + - "n\xf4[\xee\xe0\x11\xc96\"\xf4.\xea\x83\xcbTm" + - "\xdc\xb2.x\x99B\x8b0\xd16\x08\xd8\xc7\x02h\xe7" + - "\xe2X\xa1\x1b\xce\x95\x90\x199\x8a\xe1\x02\x9a\xe1\xbcf" + - "\xfcI\xee\x04\xaa\xcd\xf9\x81\xe4\xc5\x91_\x17\xc4\x1a\xfb" + - "\x83\xb1\x99W\xa0X\xf99\x7f\x96t[L\xb1\x7f\xdc" + - "\x1f\xcd\xa6\x09l\xf4\xderAA\x8b-1\xd8Z\x9b" + - "\x09Z~$jp\xa9\xc5\xcb\x9b\xbdX\xa6\xe2z\x89" + - "\xc1\xb2km\x16g\x08\xde#@P\xf5\xc2y\x0f\x11" + - "\xe3T\x897\xb1\xfe\x9c\x9e_\xc3\xac1\xef4\x15o" + - "\x89\xdd\xd1cD\xf8\x94\xd8\x1d\x7fJ\xf4!j\xedp" + - "4&\x0f!jd4\xea\x8e\xc7/\x0b\xfeo2\xf9" + - "\xd7zN\xa3\xa2X\xb8\x94\x821\xfc+\x9f\xaf9\xb4" + - "\xbf\xd4\xfa>z$\xbe\xccA\x17\x84\xb8\x81\xb1?\x02" + - "\xa1C8\x7f\xf3\xff\x09\x00\x00\xff\xff\xa6\xa4\xec\x8a" + "\xd0}s\x9br\xa0\x80^^QX!\xe2,\x89;" + + "I\xb6\xe7\xc1\xb03,\x8f\xb9\xd33\xa8#\x9b\xf2N" + + "\xf773w\xe8\xbe\xb7\xb9\x0f`\x08,\x8f\xc2(\x13" + + "X\xd1\x95\x14\xb8h)\xae\xf1\x11\x93\x15\x17+\xabQ" + + "K\x93\xad\xa8Y\x89\xba\x81\x94l\xb4\xa2\x82\x95Zk" + + "-\xc5GY\xa4\xd4\x9b:\xf7==\xc3\x00&\xa9\xda" + + "\x7f\xa0\xeb\xdc\xf3=\xce\xebw\x1e\xdf\\s\xef\xe4&" + + "ni\xd5\x95I\x00\xf9\xf1\xaaI\x0e[\xf4\xab\xad\xf7" + + "-\xf8\xa7\xdd \xcf@t~\xf0\xcc\xca\xf4yk\xf7" + + "\x7f@\x15/\x004\x0c\x0b[Q\xda/\x08\x00\xd2^" + + "\xe1\xbf\x00\x9d\xaa\xdf?\xf5v\xf9ma\x0f\x883\xe2" + + "\xcc\x1c1\x97\xaaW\xa2\xb4\xab\x9a\x98\xb7Wo\x06t" + + "\xfe\xa4\xf4\xea\xd1?<\xf8Kb\xe6\"f\xc0\x86\xf7" + + "\xaa\xb7\xa2t\xde\xe5\xfc\xacz-\xa0\xf3\xc9]\xf5\x7f" + + "s\xff\xbf\xbet\x0b\x88W\"\xf8g\xd7\xd5\xfc\x1a\x01" + + "\xa595?\x05t\xfe\xed\x9amgo\xfe\xe4\x8e\xdb" + + "F\x9f\x9b \xbe\x17jFP:]#\x00\xef\xdcs" + + "S\xfa_\xf0\xbe\xcf\xef\x00\xf1*\xda\x06\xe9\xf3\x935" + + "\x939@\xe9DM\x16\xd0y\xf5\xeag\x9e>\xf0\xb3" + + "[\x7f\x0c\xf2\x95\x88\xe0\xad\xff\xa0\xe6\xbf\xe9\x1c\x9cL" + + "\x0c\xe7~\xf2\xcd\xc4\xdf\xbe\xfa{\xf7\xba\x0c\xce\x83\xaf" + + "_\xff\xc4\x81\x9f}\xe3}\xe8\xe1\x04L\x004,\x9c" + + "l\x10\xef\xb2\xc9\xa4\x8b\xbb\xdexvM\xe9\x8e\xbb\x8f" + + "z\x97v\xf7\x9a6\x85\xe3 \xe1\xec\xe9\xf8\xbc\xd4\xf3" + + "@\xee\x01_\x1c\xf7S\xcd\x94\x8fi\xe9\xac)\xb4t" + + "\xd9\xaf\xdf[\xbb\xfa\x89\xfe\x87|\x06\xf7\xa2\xe7\xa7<" + + "A\x0c5\xb5t\x8f\x976\xa7\xf65\xff\xd1\xed\x0fU" + + "Z\xa5\x8a8\x17\xd7\x8e\xa0\xd4VK?\x9bk\xafG" + + "@g\xe4\xdb\xcf\xae\xfb\xe4/\xccGA^\x8c\x09\xe7" + + "\x17{\xcflZ\xf8H\xff\x8b\xee\xb5y\x80\x86\xa7\xea" + + "~E[\x9f\xa8#U\xd6\xfd\xc3\xa25\xb7\x9f]u" + + "\x8c\xb6\x8e\x99\xc5\xbbDij#J\xdb\xa7\x92e\x86" + + "\xa7\x12\xf7kW\xaf{\xee\xb9\xc7\x07\x8eU^\xc4\xb5" + + "\xf8\xf4\xe4J\x94\x16'\x89{a\x92\xb8\xa7u\xe0\x9b" + + "\xcf/M\xfc}\xdc\x8eo%\xdf\xa7\xc3\xcf\xb9\x0c7" + + "}\xf1\xe4?\xb6}x\xf2\xa9\xb8\x85\xeeHqd\xa1" + + "\x07S$x\xef\x08\x96\xdellz\x0e\xe4\xab\x10\x9d" + + "\xa1\x83\xdb\xac\xf6C\xfb\x1d\xe8A\x019\x80\x86\x13\xa9" + + "\xad\xb4\xd9\xe9\x14\xf9\xd7\xac\x0fZ\xea\xb4\x0fw?_" + + "\xe1\x8c\xee\xa9\xcb\xc4\x95(u\x88t\xb56\xf1\xa7\x80" + + "\x9f?z\xeb\x81\x8e3\xcb_\x94g`\xa2R\xe8w" + + "\xc4\xad(}F\xbc\x0d\xe7\xc4\x0c\xe93\xd4`\x05\xbb" + + "+\xf5\x1ci\x08\xa5e\x12\xfd\\*\xb9\xec+o\xfa" + + "\xd1\x9dU\xef\xfd\xe8\xc5J\x95\x92\x877\xfci\xda@" + + "IN\xd3\xcf\xd5\xe9+x@g\xc6\xe3\x7f\xfcw-" + + "\x85\xd3\xbf\x1c'\x88\xa4\x13W|,\x9d\xbe\x82~\x9d" + + "\xba\x82d<\xb3\xf8\xd8\x9f\xfff\xff\xeb'\xe3\x9e\xb2" + + "\xb4\xde\xf5\xd8\xb6zR\xd8\xad\xdf\x1c\xde\xbaf\xc1\xc8" + + "\xa9J\x03\xb9\x9c\xac~\x04\xa5\xed\xf5\xae9\xebi;" + + "\xee=e\xfa\xce\x7f\xff\xce\x9b1\x9f\xfdM\xfd\xbb\x08" + + "\x09g\xcd\xba\x9b\x86j\xb6\x9f9\x13?\xe8\xadz\xcf" + + "t\xeeA\xc7\xc5;\xa5g\xee\xff\xeb\xb3t\x90P\xa9" + + "nqz/J\x0b\xa6\xbb\xea\x99\xfe\x10\x07\xb1\xd8\x19" + + "\xcfqf\xcdlDi\xf1L\xd7qf\xd2\xbd\x96\xdd" + + "\xdc\xcc\xd6_w\xc3\xfb \xce\xe0GA\x85J\x9c\xc3" + + "\xc4\xd9`\xcf\xbc\x15\xa5\xed\xb3\x04\x00\xe7\x87\x03\xbd/" + + "\x9fk\xbd\xff\xa3\xca\xcd]\x81\xd8\xacF\x94l\xe2k" + + "\xd88\xcb\xb5O\xc3\xd2\xbf\xfc\xe0\xe0\x03\xad\xe7\xc6\xec" + + "\xfe\xec\xec\x16\x94N\xcc\xa6{\xbc<\xfb\xbb\xd2\xf9\xd9" + + "\xee\xe6?X\xbe\xf6\xdbs_\xf88\xae\x89wf\xbb" + + "\xd1\xfb\xd9l\xd2D\xffu\xbf\xfd\xee\x82\x1f\xfe\xf3\xc7" + + "\x15\xf6s\x19\xa7e\x16\xa1\xb4 C;\xce\xc9d\x01" + + "?\\q\xef\xc9\x19\xc9\x19\x9fV\\t\x12\xf1\xb6e" + + "\x86P\xba\x91x\x1bz2/\xd2Eox\xf7\xee\xcd" + + "\xd9\x1f\x7f\xfa9\xc9\xc5W\xe0\\\xc7\x9c^\x94\xbe?" + + "\x87v\xbeq\x0e\xc5\xd2\xaa\xc7N\x7fg\xf0\xe0K\xe7" + + "\xc7E\xee\xaa\xb9\xbbQ\x9a>\x97\xb8\xa7\xcd%\xc8\xf9" + + "+\xe1\xc8\x99\x9d\xff\xf9g_\xc4\xa5\xfar\xee\xbb$" + + "\x958\x8f\xa4\xda\xf6\xe1\xe1\xf6\xdb\xd7?\xf6\xd5(O" + + "\x9b\xf7414\xbb\x0ca0\x8e\xe7i\xca\xbc\x16\x94" + + "6\xce\xa3\xf3J\xf3\xb2\xb0\xd8\xb1lMcE\xa3\x9c" + + "\xc8\xffA\xf03\xbf$\xaf\x94\xb5rc\xb3m\x0d2" + + "\xcdR\xf3\x8a\xc5\xbaX\xd6,\xeb\x9a\xc9:\x11\xe5\x14" + + "\x9f\x00H \x80\xa8\x0c\x01\xc87\xf3(\x179\x14\x11" + + "\xd3\x84\xd6\xa2J\xc4A\x1ee\x8bC\x91\xe3\xd2\x84\x08" + + "\xe2\xc6\xb9\x00r\x91Gy\x0b\x87\xc8\xa7\x09\xefD\xfb" + + "N\x00y\x0b\x8f\xf2\x1e\x0e\x9d23J\x8a\xc64H" + + "Zm\x86\x81\xb5\xc0a-\xa0c0\xcb\x18V\xfa\x8a" + + "\x90d1\xb20\xb4\xd9\xc2:\xe0\xb0\x0e\xd0\x19\xd4m" + + "\xc3\xec\xd1,T\x8b]\xac\xdf`&\x0e\xe2$\xe0p" + + "\x12\xe0D\xe2\xb5\xea\x9a\xc6\xf2V\xce\xce\xe7\x99i\x02" + + "\x90d\xd5\xa1d\x0b\xef\x06\x90\xaf\xe6Q\xbe.&\xd9" + + "2\x92\xec[<\xcaM\x1c:&361c\x95\x8e" + + "y\xc5Rum\x8d\xc2\x97Xx\xed|Qe\x9a\xd5" + + "\xaaCR\xebW\x070\x15\x85\x02 \xa6&\xbeX\xdb" + + "\x16\xd5\xb4Tm\xa0\xdb\xa5g;\xf5\xa2\x9a\x1f\xa6\xdb" + + "\xd5\xba\x9a\x9c\xd5H{\x88\xd3z\x01\x90\x13\xc5\x16\x80" + + "\xac:\xa0\xe9\x06s\x0a\xaa\x99'\xa1\x80\xcf[;\xfa" + + "\x94\xa2\xa2\xe5Yx\xd0\xa4\xb1\x07y\x07\xe4\\9\x96" + + "(1k\xcf\xefT\x0c\x85/\x99rm\xa8\x8f\xb6^" + + "\x00y9\x8frgL\x1f\xabW\x02\xc8\xabx\x94o" + + "\x88Y\xba\xa7\x05@\xee\xe4Q^\xcf\xa1\xa3\x1b\xea\x80" + + "\xaa\xb52\xe0\x8d\xb8\xc1LKSJ\x0c\x00\x02\x85\xed" + + "\xd0\xcb\xa4D\x13S\x11JWh\xaaj\xac\x00\xed\xac" + + "X\xd4\xaf\xd7\x8dba\xadw\x8eN\xdavM\x19." + + "\x13\xc6\xb1\xbck\x1c\x92[\xcd\xb3%\xb6\xc9\xbcu\xb6" + + "\xe1\x1ar~\x173\xed\xa2e\x02\xc8\x89P\xfc\xbaF" + + "\x00\xb9\x9aG9\xcda\xd6p\x190\x15\x81z\xc5U" + + "/\xa6k[3\xd8\x80jZ\xcc\xf0\xc8\xf3\xb3\xa4\xf0" + + "\x92\x19?\x90\xfc/\xc5\xa3<\x93Cg\xc0P\xf2\xac" + + "\x93\x19\xa8\xea\x855\x8a\xa6\xe7x\x96\xc7*\xe0\xb0j" + + "bOZ\xa1\xa8EV\xf0\xa4[\x92\xcf\xb8\xffS\xf4" + + "\xd6:\x8e\x17\xbe\xbdQ\xf8\xd6\xe1W\x8e\x1f\xbf[\xa3" + + "\xf8\xad\xe3\xbet\xc6\x06p\x1d\xff\x85\xe3\x870E\x84" + + "\xc5\xa3\xbc\x93\"\xc2.\x93NM\xe0u\x03S\x11J" + + "\xfa\xdaa\x85\x01\xd2\xb4\x06Y\x96'Ec*\xc8\xf6" + + "\x1e\x83P\xd0\x071\x15\x952\xfe2\x83mb\x86\xc9" + + ":!i\xe8[\x861\x15e\xfd\x0a\xadO\xbd\\\xad" + + "\x07\x86\x0eWM\xbc\xde`y\x0f2\xfc\xe5\x9d\x19\xcf" + + "h18$\x1d\xad\xe7Q\x1e\x8c\x05\x09\xeb\x03\x90\x0b" + + "<\xca\xe5X\x90\x94VF\xda\x14\xf9\x00\x0f)r\xca" + + "<\xca\xdb\xb8\xd1\x08\xc761\xcdZ\xae\x0e\x80\xc0\xcc" + + "\xff\x870\x1a%\xa5/c(]\xcc%\xc9[jy" + + "\x94\xeb\x09\xae\xe9+\xb3(\xb0\xe9\xb4\xb0\x10\xbe\xf8i" + + "\xad\xf4\xaf\x0f\xbe\x9d\xfe.\x86\x8f\xbf\xf5\xe1a\x87\xe9" + + "\xb0C<\xca?\x89\xa9\xf2~\x03@\xbe\x8fG\xf91" + + "\x0e\xd1\xd7\xe4#G\x01\xe4\xc7x\x94\x7fN\x9a\xe4<" + + "M>\xb9\x88\xda&\x1e\xe5W8\x14\x13|\x9a\xba\x02" + + "\xf1e\x0a\xa9Wx\x94\xdf\xe0P\xacJ\xa4\xb1\x0a@" + + "\x1d\x95\xc1\x8f" + + "\xc6\x12j\xde_\x8d\xee\xf2V]\x13.\xbbJ\xf3\x11" + + "\xcc\xcb!K\xfc\x9a\x80\x0a\xc8 \xb9.\xa4d0\x9f" + + "G\xf9\x9axr]L*\xba\x8aG\xf9[\x1c\x0a\xcc" + + "\xa0<\x19v\xfa\xde\xa1;L\xaf\"\xc5T4\xc6\xb9" + + "\xf8ub\xc5\xba\xaakc\xdcpn\x14.\xa1\x09;" + + "\xae\x8d\xd950\xe1\xea\xbe\xc8\xae\xc2\x066\x1cX)" + + "\xc3J\x8a\x1a\xa1\x91o\xdcf\x10\xbe\x17\xf1LX\xd4" + + "\xfa\xc9\xdfK\xfdY\xcfZt\xc9tx\xc9\xed#\x00" + + "\xf2N\x1e\xe5}\xb1K\xee\xa5\x1ea\x1f\x8f\xf2\xa1\xd8" + + "%\x0f\x92\x12\x0f\xf0(\x1f\x89e\xcf\xc3d\xe0#<" + + "\xca\x0fs\x88\x09\x0f\xf2\x1f$\xc8\x7f\x98G\xf98\xe7" + + "\x02v{s\xab\xae\xa1\x7f\x09\x13 \xec\x13\x06\x99b" + + "X}LA\xabC\xb3\x98\xb1I\xc1b\x00\x09;," + + "\xb5\xc4t\xdb\x0a!\xa2\xa4lq\x0b+,\xb4{\xab" + + "\x04\xc52\xb1\x068\xac\xa1\x884\x99\xd1j\xb0\x02\x92" + + "5\x94b\xa7\xc2[\x83\x97\xa2\xa0\xd1 \x9e\x1cG=" + + "T\x96m\xe3Q\xbe\x8d\xa0\x04c\xd3$\xf1\x96!\xe0" + + "\\$!\x997\xb6\xc4K\x0b\xceKs\xf1V\xcbM" + + "\x88\x93\x00\xc4]\xa4\x9d=<\xca\x07\xb8\xe0j\xed:" + + "d\xbd\x08\xad4\xb5\xdf\xca\xec \xd4TY$\xaf_" + + "/\xa8\xa8k\xdd\xae\xa20\xd2T^/\x95\x0dre" + + "U\xd7d[)\xaa\xbc5\x1c.\x9cP\x17\x04I^" + + "(\xaf-g\\c\x912\xae\x0b\x94!\x0d\xe3J\x80" + + "\xdc\x16\xe41\xb7\x07#w\x91va\x0b@n\x1b\xd1" + + "o\xc3\xc8c\xa4[p\x06@n'\xd1\xf7a\xd8\x81" + + "J{\xf1Q\x80\xdc>\"\x1f\xc2\xa8T\x90\x0e\xba\xdb" + + "\xdfE\xf4\xfb0\xaa\x16\xa4{p\x11@\xee\x10\xd1\x8f" + + "\x13}\x12\xe7jR:\x86C\x00\xb9\xc7\x89\xfe\x0c\xd1" + + "\x85\xaa4\xb5\xdb\xd2Sh\x00\xe4~N\xf4_\x10\xbd" + + "\xba>\x8d\xd5\x00\xd2\x0b.\xfdy\xa2\xbfB\xf4\x9a\xe9" + + "i\xac\x01\x90^\xc6\xdd\x00\xb9\x97\x88~\x92\xe8\x931" + + "\x8d\x93\x01\xa4\xd7\xf1n\x80\xdcI\xa2\xbfM\xf4)\x93" + + "\xd28\x05@z\xcb\xbd\xcf\x1bD?K\xf4\xdaD\x1a" + + "k\x01\xa4w\xf0(@\xee,\xd1?\"z\x9d\x90\xc6" + + ":\x00\xe9\x03W\xae\xdf\x12\xbd\x9a\x0bq\xb0\xa3\x10\x87" + + "crC5*Gx\xdd\x0c]\x81\xf9\x9d)z\xb9" + + "\xa2SORk\x8a\xc9h\x84\x0c\x88I@\xa7\xac\xeb" + + "\xc55\xa3a\xfeb\x15\x91\xefF\x90\xd4\xb5\x8eB\x18" + + "\x97\x9e\xf3\xad\xd2!\x93W\x8a\x1d\xe5\xa8F2\x9bm" + + "K\xb7\xcb\x90)(\x16+\x84\x89\xda\xb0\xb5\x15\x86^" + + "\xeaFf\x94TM)B\xf8e\"_L\xda\xb6Z" + + "\x08\xf7\x9e\xb0\xb0s\xfa\x99b\xd9\x063I\xb4\x0bd" + + "\\\xae\xd2\xa33\xe5\xc6ne\xa0b\xc0\xb0(J\x0f" + + "!\xda-\xbe6\xca\x0e\xc9x\x14f6)E\x9b]" + + "J18a\xcb\xd2\x95\xf5Z\x9e\x8bu\xb6\xc18\xec" + + "\xe2\xd5|OE\xe6\xf5\xf2\xe1\x98iJK$l(" + + "\xab\xe1OX\xda\xb9(\xe7\x05\xd6\xea\xf7;W\xc8\xd0" + + "\xde1\xbf\x09\xe7\x95\xbe\xdf\\\xaa&\x06\x98\xe5\xfd\xea" + + "\xd0\xfau*\x0f\x04\xa5d~\xcd\xd5]\xccL^\x8a" + + "\x16\xa3\x09\xe4\xc5\xf3w{wwg4\xc4\xe0=\xf0" + + "\xbf&\xc4\xbbf\xec\x02\xc85Q\xe0\xae\xc2P\x87R" + + "\x87\x8b;\xedD\xee\xc6\xa8\xea\x95d\x17_:\x89\xbe" + + "\x1e\xa3\xbeH\xba\xd1\xc5\x85\xf5D\x1ft\xf1\xae\xd9\xc3" + + ";\xe6n_ z\xd9\xc5;\xf4\xf0\xae\xe4\xee_$" + + "\xfa\x968\xde\xd982\x0a~\x05\xde\xc3\xbb].N" + + "\xed!\xfa\x01\x17\xef\x12\x1e\xde\xed\xc7'\x00r\x07\x88" + + "~\xc4\xc5\xbb*\x0f\xef\x0e\xe3\xd3\x00\xb9#D\x7f\xd8" + + "\xc5\xbbI\x1e\xde=\xe8\xf2?\x1c\xe2\xec\x94\x16\x0f\xef" + + "\x8e\xb9\xf8\x18\xe2\xacc\x1b\xc5\x9ce\xa8\x1a\xe0@\x14" + + "\x1b\xf9\xf2\xf7\x18+7C\xb2\xa8nba.*\xa8" + + "Jq\xb9\xad\x14!\x93\xb3\x94\xfc\x86\xa8\xb4/\x9a\xed" + + "\x8aV0qP\xd9\xc0(\x83\x09\xf1\\o\x15\xcdu" + + "\xccP\xfb\x01\xa3f \xac}\x92\x9d\xba^Y\x12\xb9" + + "5%3<\xf0\x0b\xbf\x95\x94-\x1d\x85\"k\xc5\xa0" + + "\x02\xe2\xb5(\x83\xaa\xf4E\xd74\xf4\xca\x92n53" + + "\xba\xde(\xfb\xedEP\xb7tg+\x0a\x12\xb6\xa5\xcc" + + "\xf2V\xab\x8e\x9a\xa5j6\x1b\xb3A~\xd0\xd66\xb0" + + "B\x1bjy\xbd\xa0j\x030\xa6\xaf\xe1/4;\x8a" + + "\x15jn4c\xec\xedM\\\xd8\x08\x9c\x0b]Tv" + + "\x88\x8d\xd1t \x9bwWe\x0d\xa6\x98\xb1\xc6v\x82" + + "\xd3\xfcY\xa7\x17d\xde$\xa0\x0a |\xa8\xc2`\xd8" + + "/\x1e\xdb\x0a\x9c\xf8\x88\x80\xd1\x1b\x09\x06O\"\xe2=" + + "\x06p\xe2A\x01\xb9\xf0\x01\x11\x83\xc7?q\xef\x08p" + + "\xe2-\x02\xf2\xe1\xa3\x1e\x06\x93tq\xb8\x058\xb1$" + + "`\"|\xe0\xc4`\x0c/*TZ\xdd(`U\xf8" + + "Z\x88\xc1[\x8f\xb8z7pb\x9b\xe0\x04\x1d\x14d" + + "=1\x9a\xd0\x09\x00\x032.d4\xa1\x13L\x9f0" + + "\xe8\xb4\x00\x9ap\x87\x0f\xcfM\xe8\x04\xf3WH\xe6\x15" + + "\x8b5Q{\xea}D\x1f\xbc\xa1\x09\xe3sM\xfeB" + + "=\xd1\xf8\xb5uKT\xff\x05\x00\xbck$*\xff\xc2" + + ">t\xff\xa3\xf1\xd2\xda\x1f\xa7\x1c\xde\xed\x0fc\x8e\xc7" + + "\xc6)\xc7\xa8\xde>\xce\xa3\xfc\x1a\x17\x15\x0d\x81O\x07" + + "\xa3@\xd4\x8d\xa01\x9e`\"\xe8{\xbe_\xf6V\xce" + + "\x05\x9d\x82>\xe8\x96\xc5\xe8meB\x94\x0e\xe2\xc3\xc2" + + "\xa9\xb1a!\x06-\xb90*{\xc4G\x87S/\xd2" + + "\xdf\xc5\x1bL7\x9d%\\\x97\x0c\x9eF1x\xc5\x16" + + "Er\xad:\xc1\x09\x9aP\x0cr!T\x98\xec2;" + + "\xf1.\x96\xf9\xdf$\xebq\x1c\xc4;'I\x1e\xe9\x09" + + "\x14\xee;\x14\x1b\xed\x15u\xbf\x89L\xae\x89\xf7\x01\x13" + + "\xe8\xca\xbbpP\xb5'i1\xed\xff\x8dp\xff\xd7\xe7" + + "\xc6Fo\x81\xff\x9d\"\xe2k<\xcao\xc6Z\xbb\xd3" + + "+\x01\xe47x\x94?\x8d\xde\x89\xce\x91\xa3~\xcac" + + "W\xacD\x17\xbf$\xc6/\xa8\x90\x8d'\xac*\xbc\x13" + + " WM\x09\"\xed&\xac\x84\x97\xb0D\xec\x03\xc8\xa5" + + "\x88>3^\xa0O\xc7^\x80\\=\xd1\xe7\xa3\xdf\x91" + + "\x07oL\xb6\x11\x81{Q\x1fX\xa5j\xe3V}\xc1" + + "\xc3\x15Z\x04\x99\xb6A\xb8?\x1a_;\x96\xc7\xea\xe0" + + "p\xec\x84\xcc\xc8Q\x88\x17\xd0\x0c\xc79\xe3\x0fz\x09" + + "\x07\x96\xab\x03\xcc\x1d\x07\x05\xc4\x09\xcc\x91\xf3\x83\xcf\x8b" + + "=\xbf\x96\x88\x0d\x03\x8e\xc6\xe6d\x811\xe4\xa7\xfd\xf9" + + "\xd3\xcd1c|\xbf/\x9ag\x13@\xe9=\xe5\x82\x82" + + "\x16[a\xb0\x8d6\x13\xb4\xfcp\xd4\x14S[\x987" + + "{\xb0L\x05\xf9\x0a\x83e7\xda,\xce\x10\xbca\x80" + + "\xa0\xea\x851\x8f\x17\xe3T\x96\xd7\xb3\xbe\x9c\x9e\xdf\xc0" + + "\xacQo;\x15\xef\x8f]\xd1\x03F\xf8\xfc\xd8\x15\x7f" + + "~\xf4am\xe3P4Z\x0famx$\xea\xa8\xc7" + + "/%\xfeo\xb2\xff\xd7z\x82\xa3BZ\xb8\x94\"3" + + "\xfc\xcb\xa0\xaf9\xe8\xbf\xd4\x9e zX\xbe\xcc\xe1\x18" + + "\x84X\x83\xb1?\x1c\xa1C8\x7f\xf3\xff\x09\x00\x00\xff" + + "\xffm\x81\xedW" func init() { schemas.Register(schema_db8274f9144abc7e,