From 7c630ec960ca1ad42b9e5c9d12785fd6a83341c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andrej=20Tokar=C4=8D=C3=ADk?= Date: Wed, 7 Jul 2021 18:20:53 +0200 Subject: [PATCH] Introduce Lock resource (#7430) --- api/client/client.go | 55 + api/client/proto/authservice.pb.go | 1775 ++++++++++--- api/client/proto/authservice.proto | 32 + api/client/streamwatcher.go | 3 + api/types/constants.go | 3 + api/types/events.go | 6 + api/types/lock.go | 219 ++ api/types/lock_test.go | 70 + api/types/types.pb.go | 2321 ++++++++++++----- api/types/types.proto | 53 + {lib => api}/utils/conv.go | 5 +- lib/auth/api.go | 6 + lib/auth/auth.go | 20 +- lib/auth/auth_with_roles.go | 43 + lib/auth/grpcserver.go | 148 +- lib/auth/grpcserver_test.go | 182 +- lib/auth/permissions.go | 3 + lib/backend/dynamo/dynamodbbk.go | 2 +- lib/backend/etcdbk/etcd.go | 3 +- lib/backend/firestore/firestorebk.go | 3 +- lib/backend/lite/lite.go | 2 +- lib/cache/cache.go | 36 +- lib/cache/collections.go | 68 + lib/events/dynamic.go | 3 +- lib/events/firestoreevents/firestoreevents.go | 3 +- lib/services/access.go | 50 + lib/services/audit.go | 3 +- lib/services/local/access.go | 93 +- lib/services/local/access_test.go | 150 ++ lib/services/local/events.go | 27 + lib/services/lock.go | 80 + lib/services/resource.go | 2 + lib/services/role.go | 21 - tool/tctl/common/collection.go | 25 + tool/tctl/common/resource_command.go | 52 +- 35 files changed, 4426 insertions(+), 1141 deletions(-) create mode 100644 api/types/lock.go create mode 100644 api/types/lock_test.go rename {lib => api}/utils/conv.go (89%) create mode 100644 lib/services/access.go create mode 100644 lib/services/local/access_test.go create mode 100644 lib/services/lock.go diff --git a/api/client/client.go b/api/client/client.go index f288fd6a8fd8d..507b13d95bf33 100644 --- a/api/client/client.go +++ b/api/client/client.go @@ -1531,3 +1531,58 @@ func (c *Client) SetClusterAuditConfig(ctx context.Context, auditConfig types.Cl func (c *Client) DeleteClusterAuditConfig(ctx context.Context) error { return trace.NotImplemented(notImplementedMessage) } + +// GetLock gets a lock by name. +func (c *Client) GetLock(ctx context.Context, name string) (types.Lock, error) { + if name == "" { + return nil, trace.BadParameter("missing lock name") + } + resp, err := c.grpc.GetLock(ctx, &proto.GetLockRequest{Name: name}, c.callOpts...) + if err != nil { + return nil, trail.FromGRPC(err) + } + return resp, nil +} + +// GetLocks gets all locks, matching at least one of the targets when specified. +func (c *Client) GetLocks(ctx context.Context, targets ...types.LockTarget) ([]types.Lock, error) { + targetPtrs := make([]*types.LockTarget, len(targets)) + for i := range targets { + targetPtrs[i] = &targets[i] + } + resp, err := c.grpc.GetLocks(ctx, &proto.GetLocksRequest{ + Targets: targetPtrs, + }) + if err != nil { + return nil, trail.FromGRPC(err) + } + locks := make([]types.Lock, 0, len(resp.Locks)) + for _, lock := range resp.Locks { + locks = append(locks, lock) + } + return locks, nil +} + +// UpsertLock upserts a lock. +func (c *Client) UpsertLock(ctx context.Context, lock types.Lock) error { + lockV2, ok := lock.(*types.LockV2) + if !ok { + return trace.BadParameter("invalid type %T", lock) + } + _, err := c.grpc.UpsertLock(ctx, lockV2, c.callOpts...) + return trail.FromGRPC(err) +} + +// DeleteLock deletes a lock. +func (c *Client) DeleteLock(ctx context.Context, name string) error { + if name == "" { + return trace.BadParameter("missing lock name") + } + _, err := c.grpc.DeleteLock(ctx, &proto.DeleteLockRequest{Name: name}, c.callOpts...) + return trail.FromGRPC(err) +} + +// DeleteAllLocks not implemented: can only be called locally. +func (c *Client) DeleteAllLocks(context.Context) error { + return trace.NotImplemented(notImplementedMessage) +} diff --git a/api/client/proto/authservice.pb.go b/api/client/proto/authservice.pb.go index 4fe5659c5a3e5..40c16c229a5c0 100644 --- a/api/client/proto/authservice.pb.go +++ b/api/client/proto/authservice.pb.go @@ -168,6 +168,7 @@ type Event struct { // *Event_SessionRecordingConfig // *Event_AuthPreference // *Event_ClusterAuditConfig + // *Event_Lock Resource isEvent_Resource `protobuf_oneof:"Resource"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` @@ -279,6 +280,9 @@ type Event_AuthPreference struct { type Event_ClusterAuditConfig struct { ClusterAuditConfig *types.ClusterAuditConfigV2 `protobuf:"bytes,23,opt,name=ClusterAuditConfig,proto3,oneof" json:"cluster_audit_config,omitempty"` } +type Event_Lock struct { + Lock *types.LockV2 `protobuf:"bytes,24,opt,name=Lock,proto3,oneof" json:"lock,omitempty"` +} func (*Event_ResourceHeader) isEvent_Resource() {} func (*Event_CertAuthority) isEvent_Resource() {} @@ -302,6 +306,7 @@ func (*Event_ClusterNetworkingConfig) isEvent_Resource() {} func (*Event_SessionRecordingConfig) isEvent_Resource() {} func (*Event_AuthPreference) isEvent_Resource() {} func (*Event_ClusterAuditConfig) isEvent_Resource() {} +func (*Event_Lock) isEvent_Resource() {} func (m *Event) GetResource() isEvent_Resource { if m != nil { @@ -471,6 +476,13 @@ func (m *Event) GetClusterAuditConfig() *types.ClusterAuditConfigV2 { return nil } +func (m *Event) GetLock() *types.LockV2 { + if x, ok := m.GetResource().(*Event_Lock); ok { + return x.Lock + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*Event) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -496,6 +508,7 @@ func (*Event) XXX_OneofWrappers() []interface{} { (*Event_SessionRecordingConfig)(nil), (*Event_AuthPreference)(nil), (*Event_ClusterAuditConfig)(nil), + (*Event_Lock)(nil), } } @@ -6301,6 +6314,199 @@ func (m *ListNodesResponse) GetNextKey() string { return "" } +type GetLocksRequest struct { + // Targets is a list of targets. Every returned lock must match at least + // one of the targets. + Targets []*types.LockTarget `protobuf:"bytes,1,rep,name=Targets,proto3" json:"Targets,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetLocksRequest) Reset() { *m = GetLocksRequest{} } +func (m *GetLocksRequest) String() string { return proto.CompactTextString(m) } +func (*GetLocksRequest) ProtoMessage() {} +func (*GetLocksRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_ce8bd90b12161215, []int{94} +} +func (m *GetLocksRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetLocksRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetLocksRequest.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 *GetLocksRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetLocksRequest.Merge(m, src) +} +func (m *GetLocksRequest) XXX_Size() int { + return m.Size() +} +func (m *GetLocksRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetLocksRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetLocksRequest proto.InternalMessageInfo + +func (m *GetLocksRequest) GetTargets() []*types.LockTarget { + if m != nil { + return m.Targets + } + return nil +} + +type GetLocksResponse struct { + // Locks is a list of locks. + Locks []*types.LockV2 `protobuf:"bytes,1,rep,name=Locks,proto3" json:"Locks,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetLocksResponse) Reset() { *m = GetLocksResponse{} } +func (m *GetLocksResponse) String() string { return proto.CompactTextString(m) } +func (*GetLocksResponse) ProtoMessage() {} +func (*GetLocksResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ce8bd90b12161215, []int{95} +} +func (m *GetLocksResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetLocksResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetLocksResponse.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 *GetLocksResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetLocksResponse.Merge(m, src) +} +func (m *GetLocksResponse) XXX_Size() int { + return m.Size() +} +func (m *GetLocksResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetLocksResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_GetLocksResponse proto.InternalMessageInfo + +func (m *GetLocksResponse) GetLocks() []*types.LockV2 { + if m != nil { + return m.Locks + } + return nil +} + +type GetLockRequest struct { + // Name is the name of the lock to get. + Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *GetLockRequest) Reset() { *m = GetLockRequest{} } +func (m *GetLockRequest) String() string { return proto.CompactTextString(m) } +func (*GetLockRequest) ProtoMessage() {} +func (*GetLockRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_ce8bd90b12161215, []int{96} +} +func (m *GetLockRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GetLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GetLockRequest.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 *GetLockRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetLockRequest.Merge(m, src) +} +func (m *GetLockRequest) XXX_Size() int { + return m.Size() +} +func (m *GetLockRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetLockRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_GetLockRequest proto.InternalMessageInfo + +func (m *GetLockRequest) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +type DeleteLockRequest struct { + // Name is the name of the lock to delete. + Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteLockRequest) Reset() { *m = DeleteLockRequest{} } +func (m *DeleteLockRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteLockRequest) ProtoMessage() {} +func (*DeleteLockRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_ce8bd90b12161215, []int{97} +} +func (m *DeleteLockRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DeleteLockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DeleteLockRequest.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 *DeleteLockRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteLockRequest.Merge(m, src) +} +func (m *DeleteLockRequest) XXX_Size() int { + return m.Size() +} +func (m *DeleteLockRequest) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteLockRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteLockRequest proto.InternalMessageInfo + +func (m *DeleteLockRequest) GetName() string { + if m != nil { + return m.Name + } + return "" +} + func init() { proto.RegisterEnum("proto.Operation", Operation_name, Operation_value) proto.RegisterEnum("proto.UserCertsRequest_CertUsage", UserCertsRequest_CertUsage_name, UserCertsRequest_CertUsage_value) @@ -6400,371 +6606,382 @@ func init() { proto.RegisterType((*Events)(nil), "proto.Events") proto.RegisterType((*ListNodesRequest)(nil), "proto.ListNodesRequest") proto.RegisterType((*ListNodesResponse)(nil), "proto.ListNodesResponse") + proto.RegisterType((*GetLocksRequest)(nil), "proto.GetLocksRequest") + proto.RegisterType((*GetLocksResponse)(nil), "proto.GetLocksResponse") + proto.RegisterType((*GetLockRequest)(nil), "proto.GetLockRequest") + proto.RegisterType((*DeleteLockRequest)(nil), "proto.DeleteLockRequest") } func init() { proto.RegisterFile("authservice.proto", fileDescriptor_ce8bd90b12161215) } var fileDescriptor_ce8bd90b12161215 = []byte{ - // 5730 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x7c, 0x4b, 0x73, 0x1b, 0x49, - 0x72, 0x30, 0x1b, 0x7c, 0x22, 0xf9, 0x02, 0x8b, 0x2f, 0x08, 0xa4, 0x08, 0x6d, 0x6b, 0x77, 0x56, - 0x33, 0x3b, 0x4b, 0xce, 0x82, 0x33, 0xdf, 0xcc, 0x8e, 0x76, 0x46, 0x1f, 0x00, 0x3e, 0x47, 0x94, - 0xc4, 0x69, 0x80, 0xd0, 0xee, 0x7a, 0x22, 0xe8, 0x26, 0x50, 0x02, 0x3b, 0x08, 0xa2, 0x31, 0xdd, - 0x0d, 0x6a, 0xe4, 0x93, 0xed, 0x58, 0xaf, 0x1d, 0x76, 0x38, 0xc2, 0x17, 0x1f, 0x7c, 0xb2, 0x23, - 0x7c, 0xf0, 0x6d, 0x4f, 0xbe, 0xee, 0xd9, 0x13, 0x8e, 0x70, 0xac, 0x6f, 0x8e, 0xf0, 0x01, 0x5e, - 0xef, 0x11, 0x3f, 0xc1, 0x27, 0x47, 0x3d, 0xbb, 0xaa, 0xd1, 0x0d, 0x92, 0x92, 0x6c, 0x5f, 0x24, - 0x76, 0x56, 0x65, 0x56, 0x66, 0x56, 0x56, 0x66, 0x56, 0x56, 0x92, 0xb0, 0x60, 0x77, 0x83, 0x73, - 0x1f, 0x7b, 0x57, 0x4e, 0x1d, 0x6f, 0x76, 0x3c, 0x37, 0x70, 0xd1, 0x38, 0xfd, 0x2f, 0xb7, 0xd4, - 0x74, 0x9b, 0x2e, 0xfd, 0x71, 0x8b, 0xfc, 0xc4, 0x06, 0x73, 0x6b, 0x4d, 0xd7, 0x6d, 0xb6, 0xf0, - 0x16, 0xfd, 0x3a, 0xeb, 0xbe, 0xd8, 0xc2, 0x97, 0x9d, 0xe0, 0x15, 0x1f, 0xcc, 0x47, 0x07, 0x03, - 0xe7, 0x12, 0xfb, 0x81, 0x7d, 0xd9, 0xe1, 0x13, 0x3e, 0x6e, 0x3a, 0xc1, 0x79, 0xf7, 0x6c, 0xb3, - 0xee, 0x5e, 0x6e, 0x35, 0x3d, 0xfb, 0xca, 0x09, 0xec, 0xc0, 0x71, 0xdb, 0x76, 0x6b, 0x2b, 0xc0, - 0x2d, 0xdc, 0x71, 0xbd, 0x60, 0xcb, 0xee, 0x38, 0x5b, 0xc1, 0xab, 0x0e, 0xf6, 0xd9, 0xbf, 0x1c, - 0xb1, 0x7c, 0x1b, 0xc4, 0x97, 0x9e, 0xdd, 0xe9, 0x60, 0x2f, 0xfc, 0x81, 0x13, 0x79, 0x74, 0x1b, - 0x22, 0xf8, 0x0a, 0xb7, 0x03, 0xf1, 0x1f, 0x23, 0x60, 0xfe, 0x43, 0x06, 0xc6, 0x77, 0x09, 0x00, - 0x7d, 0x02, 0x63, 0xd5, 0x57, 0x1d, 0x9c, 0x35, 0xee, 0x19, 0x0f, 0xe6, 0x0a, 0x19, 0x36, 0xbe, - 0xf9, 0xac, 0x83, 0x3d, 0x4a, 0xb2, 0x84, 0xfa, 0xbd, 0xfc, 0x1c, 0x21, 0xf4, 0xbe, 0x7b, 0xe9, - 0x04, 0x54, 0x47, 0x16, 0xc5, 0x40, 0xcf, 0x61, 0xce, 0xc2, 0xbe, 0xdb, 0xf5, 0xea, 0xf8, 0x00, - 0xdb, 0x0d, 0xec, 0x65, 0x53, 0xf7, 0x8c, 0x07, 0xd3, 0x85, 0xe5, 0x4d, 0x26, 0xaf, 0x3e, 0x58, - 0x5a, 0xe9, 0xf7, 0xf2, 0xc8, 0xe3, 0xb0, 0x90, 0xd8, 0xc1, 0x88, 0x15, 0x21, 0x83, 0xbe, 0x82, - 0xd9, 0x32, 0xf6, 0x82, 0x62, 0x37, 0x38, 0x77, 0x3d, 0x27, 0x78, 0x95, 0x1d, 0xa5, 0x74, 0x57, - 0x38, 0x5d, 0x6d, 0xac, 0x56, 0x28, 0xad, 0xf7, 0x7b, 0xf9, 0x6c, 0x1d, 0x7b, 0xc1, 0xa9, 0x2d, - 0xa0, 0x1a, 0x79, 0x9d, 0x18, 0xfa, 0x29, 0xcc, 0x54, 0x88, 0xba, 0xea, 0x55, 0xf7, 0x02, 0xb7, - 0xfd, 0xec, 0x98, 0xc6, 0xb4, 0x3a, 0x54, 0x2b, 0x94, 0xd6, 0xfa, 0xbd, 0xfc, 0xaa, 0x4f, 0x61, - 0xa7, 0x01, 0x05, 0x6a, 0xa4, 0x35, 0x4a, 0xe8, 0xf7, 0x61, 0xee, 0xd8, 0x73, 0xaf, 0x1c, 0xdf, - 0x71, 0xdb, 0x14, 0x94, 0x1d, 0xa7, 0xb4, 0x57, 0x39, 0x6d, 0x7d, 0xb0, 0x56, 0x28, 0xdd, 0xed, - 0xf7, 0xf2, 0x77, 0x3a, 0x02, 0xca, 0x16, 0xd0, 0x35, 0xa3, 0xa3, 0xa0, 0x2a, 0x4c, 0x97, 0x5b, - 0x5d, 0x3f, 0xc0, 0xde, 0x53, 0xfb, 0x12, 0x67, 0x27, 0x28, 0xf9, 0x25, 0xa1, 0x97, 0x70, 0xa4, - 0x56, 0x28, 0xe5, 0xfa, 0xbd, 0xfc, 0x4a, 0x9d, 0x81, 0x4e, 0xdb, 0xf6, 0xa5, 0xae, 0x72, 0x95, - 0x0c, 0xd5, 0x37, 0xfb, 0x2c, 0xbb, 0xed, 0x17, 0x4e, 0x33, 0x3b, 0xa9, 0xeb, 0x5b, 0x1d, 0xab, - 0x6d, 0x73, 0x7d, 0x73, 0xca, 0x75, 0x0a, 0x8d, 0xe8, 0x5b, 0x45, 0x40, 0x1f, 0xc3, 0xd8, 0x89, - 0x8f, 0xbd, 0xec, 0x14, 0x25, 0x3a, 0xcb, 0x89, 0x12, 0x50, 0xad, 0xc0, 0xac, 0xab, 0xeb, 0x63, - 0x4f, 0xa3, 0x40, 0x11, 0x08, 0xa2, 0xe5, 0xb6, 0x70, 0x36, 0xad, 0x21, 0x12, 0x50, 0xed, 0x43, - 0x86, 0xe8, 0xb9, 0x2d, 0x5d, 0x2c, 0x8a, 0x80, 0x0e, 0x21, 0x4d, 0xe4, 0xf2, 0x3b, 0x76, 0x1d, - 0x67, 0x81, 0x62, 0x67, 0x38, 0xb6, 0x84, 0x97, 0x56, 0xfb, 0xbd, 0xfc, 0x62, 0x5b, 0x7c, 0x6a, - 0x54, 0x42, 0x6c, 0xf4, 0x08, 0x26, 0x2a, 0xd8, 0xbb, 0xc2, 0x5e, 0x76, 0x9a, 0xd2, 0x99, 0x17, - 0x66, 0x42, 0x81, 0xb5, 0x42, 0x69, 0xa9, 0xdf, 0xcb, 0x67, 0x7c, 0xfa, 0xa5, 0xd1, 0xe0, 0x68, - 0x44, 0xb7, 0x16, 0xbe, 0xc2, 0x9e, 0x8f, 0xab, 0xdd, 0x76, 0x1b, 0xb7, 0xb2, 0x33, 0x9a, 0x6e, - 0xb5, 0x31, 0x61, 0xcb, 0x1e, 0x03, 0x9e, 0x06, 0x14, 0xaa, 0xeb, 0x56, 0x43, 0x40, 0xe7, 0x90, - 0x61, 0x3f, 0x95, 0xdd, 0x76, 0x1b, 0xd7, 0xc9, 0x81, 0xcd, 0xce, 0xd2, 0x05, 0xee, 0xf0, 0x05, - 0xa2, 0xc3, 0xb5, 0x42, 0x29, 0xdf, 0xef, 0xe5, 0xd7, 0x18, 0x6d, 0xb2, 0x7d, 0x7c, 0x40, 0x5b, - 0x66, 0x80, 0x2a, 0x91, 0xa3, 0x58, 0xaf, 0x63, 0xdf, 0xb7, 0xf0, 0xd7, 0x5d, 0xec, 0x07, 0xd9, - 0x39, 0x4d, 0x0e, 0x6d, 0x4c, 0xd8, 0x88, 0x4d, 0x81, 0xa7, 0x1e, 0x83, 0xea, 0x72, 0x68, 0x08, - 0xe8, 0x18, 0xa0, 0xd8, 0xe9, 0x54, 0xb0, 0x4f, 0x4c, 0x3d, 0x3b, 0x4f, 0x49, 0x2f, 0x72, 0xd2, - 0xcf, 0xf1, 0x19, 0x1f, 0xa8, 0x15, 0x4a, 0x77, 0xfa, 0xbd, 0xfc, 0xb2, 0xdd, 0xe9, 0x9c, 0xfa, - 0x0c, 0xa4, 0x11, 0x55, 0x68, 0x30, 0xbd, 0x5f, 0xba, 0x01, 0xe6, 0xc6, 0x98, 0xcd, 0x44, 0xf4, - 0xae, 0x8c, 0x09, 0x7e, 0x3d, 0x0a, 0x3c, 0xe5, 0xa6, 0x1d, 0xd5, 0xbb, 0x82, 0x40, 0x4e, 0xfa, - 0x8e, 0x1d, 0xd8, 0x67, 0xb6, 0x8f, 0xb9, 0x79, 0x2c, 0x68, 0x27, 0x5d, 0x1f, 0xac, 0x6d, 0xb3, - 0x93, 0xde, 0xe0, 0xd0, 0xd3, 0x18, 0x7b, 0x89, 0xd0, 0x23, 0x1a, 0x09, 0x05, 0xcf, 0xa2, 0x6b, - 0x34, 0xf2, 0x12, 0x9f, 0xc5, 0x6b, 0x24, 0x9c, 0x8a, 0x0e, 0x60, 0xea, 0x39, 0x3e, 0x63, 0x7e, - 0x69, 0x91, 0xd2, 0x5b, 0x08, 0xe9, 0x31, 0x8f, 0xb4, 0xcd, 0x4e, 0x05, 0xa1, 0x36, 0xe8, 0x8b, - 0x24, 0x36, 0xfa, 0x13, 0x03, 0x56, 0x85, 0xff, 0xc0, 0xc1, 0x4b, 0xd7, 0xbb, 0x70, 0xda, 0x4d, - 0xee, 0x3a, 0x96, 0x28, 0xe5, 0x7b, 0x11, 0x97, 0x14, 0x99, 0x55, 0x2b, 0x94, 0xbe, 0xdf, 0xef, - 0xe5, 0xef, 0x4b, 0xf7, 0x24, 0xc7, 0xe3, 0xfc, 0x49, 0xd2, 0x5a, 0xe8, 0x8f, 0x0c, 0x58, 0xe1, - 0xd2, 0x59, 0xb8, 0xee, 0x7a, 0x8d, 0x90, 0x8d, 0x65, 0xca, 0x46, 0x5e, 0x9e, 0xd6, 0xb8, 0x49, - 0xb5, 0x42, 0xe9, 0x9d, 0x7e, 0x2f, 0x6f, 0x72, 0xc5, 0x9d, 0x7a, 0x62, 0x38, 0x8e, 0x89, 0x84, - 0x85, 0x88, 0x25, 0x90, 0xd0, 0x72, 0xec, 0xe1, 0x17, 0xd8, 0xc3, 0xed, 0x3a, 0xce, 0xae, 0x68, - 0x96, 0xa0, 0x0f, 0x0a, 0x9f, 0x4f, 0x02, 0xd5, 0x69, 0x47, 0x82, 0x75, 0x4b, 0xd0, 0x51, 0xd0, - 0xd7, 0x80, 0xb8, 0x02, 0x8a, 0xdd, 0x86, 0x13, 0x70, 0x01, 0x57, 0xe9, 0x2a, 0x6b, 0xba, 0x9e, - 0x95, 0x09, 0xb5, 0x42, 0xc9, 0xec, 0xf7, 0xf2, 0x1b, 0x42, 0xc5, 0x36, 0x19, 0x8a, 0x13, 0x2c, - 0x86, 0x78, 0x09, 0x60, 0x4a, 0x84, 0x64, 0xf3, 0x00, 0xc6, 0x9f, 0xdb, 0x41, 0xfd, 0x1c, 0x3d, - 0x82, 0xf1, 0xc7, 0x4e, 0xbb, 0xe1, 0x67, 0x8d, 0x7b, 0xa3, 0xd4, 0xa3, 0xb2, 0x4c, 0x81, 0x0e, - 0x92, 0x81, 0xd2, 0xea, 0xb7, 0xbd, 0xfc, 0x48, 0xbf, 0x97, 0x9f, 0xbf, 0x20, 0xd3, 0x94, 0x74, - 0x81, 0xe1, 0x99, 0xff, 0x98, 0x82, 0xb4, 0x9c, 0x8d, 0xd6, 0x61, 0x8c, 0xfc, 0x4f, 0xf3, 0x8e, - 0x74, 0x69, 0xaa, 0xdf, 0xcb, 0x8f, 0x11, 0x3c, 0x8b, 0x42, 0x51, 0x01, 0xa6, 0x8f, 0x5c, 0xbb, - 0x51, 0xc1, 0x75, 0x0f, 0x07, 0x3e, 0x4d, 0x2c, 0xa6, 0x4a, 0x99, 0x7e, 0x2f, 0x3f, 0xd3, 0x72, - 0xed, 0xc6, 0xa9, 0xcf, 0xe0, 0x96, 0x3a, 0x89, 0x50, 0xa4, 0x51, 0x71, 0x34, 0xa4, 0x48, 0xfc, - 0xbb, 0x45, 0xa1, 0xe8, 0x0b, 0x98, 0xd8, 0x73, 0x5a, 0xc4, 0x13, 0x8c, 0x51, 0xfe, 0xd7, 0xa3, - 0xfc, 0x6f, 0xb2, 0xe1, 0xdd, 0x76, 0xe0, 0xbd, 0x62, 0x6e, 0xfd, 0x05, 0x05, 0x28, 0x82, 0x70, - 0x0a, 0xe8, 0x03, 0x98, 0xac, 0x74, 0xcf, 0x28, 0xfb, 0xe3, 0x74, 0x31, 0x9a, 0xdb, 0xf8, 0xdd, - 0xb3, 0x53, 0x22, 0x82, 0x82, 0x20, 0xa6, 0xe5, 0x7e, 0x0c, 0xd3, 0x0a, 0x79, 0x94, 0x81, 0xd1, - 0x0b, 0xfc, 0x8a, 0xc9, 0x6e, 0x91, 0x1f, 0xd1, 0x12, 0x8c, 0x5f, 0xd9, 0xad, 0x2e, 0xa6, 0xa2, - 0xa6, 0x2d, 0xf6, 0xf1, 0x69, 0xea, 0x13, 0xc3, 0xfc, 0x12, 0xc6, 0x49, 0x02, 0xe3, 0xa3, 0xfb, - 0x30, 0x5a, 0xa9, 0x1c, 0x50, 0xa4, 0x99, 0xd2, 0x42, 0xbf, 0x97, 0x9f, 0xf5, 0xfd, 0x73, 0x65, - 0x31, 0x32, 0x4a, 0x26, 0x55, 0x8f, 0x2a, 0x94, 0x0a, 0x9f, 0x14, 0xb4, 0xd4, 0xbd, 0x20, 0xa3, - 0xe6, 0x6f, 0x26, 0x20, 0x43, 0x42, 0x2c, 0xa5, 0x2b, 0x7c, 0xf0, 0xfb, 0x90, 0x3e, 0xee, 0x9e, - 0xb5, 0x9c, 0xfa, 0x63, 0xce, 0xd9, 0x4c, 0x69, 0xae, 0xdf, 0xcb, 0x43, 0x87, 0x02, 0x4f, 0x2f, - 0xf0, 0x2b, 0x2b, 0x9c, 0x80, 0x1e, 0xc0, 0x14, 0xa1, 0x40, 0x14, 0xcc, 0x58, 0x2e, 0xcd, 0xf4, - 0x7b, 0xf9, 0xa9, 0x2e, 0x87, 0x59, 0x72, 0x14, 0x55, 0x60, 0x72, 0xf7, 0x9b, 0x8e, 0xe3, 0x61, - 0x9f, 0xe7, 0x71, 0xb9, 0x4d, 0x96, 0x5c, 0x6f, 0x8a, 0xe4, 0x7a, 0xb3, 0x2a, 0x92, 0xeb, 0xd2, - 0x5d, 0x6e, 0x43, 0x0b, 0x98, 0xa1, 0x84, 0x9c, 0xff, 0xd5, 0x7f, 0xe4, 0x0d, 0x4b, 0x50, 0x42, - 0xef, 0xc3, 0xc4, 0x9e, 0xeb, 0x5d, 0xda, 0x01, 0x4d, 0xdf, 0xd2, 0x7c, 0xbf, 0x28, 0x44, 0xdb, - 0x2f, 0x0a, 0x41, 0x7b, 0x30, 0x67, 0xb9, 0xdd, 0x00, 0x57, 0x5d, 0x11, 0x0d, 0xd8, 0xb6, 0x6d, - 0xf4, 0x7b, 0xf9, 0x9c, 0x47, 0x46, 0x4e, 0x03, 0x77, 0xd0, 0xef, 0x5b, 0x11, 0x2c, 0xb4, 0x0b, - 0x73, 0x5a, 0xdc, 0xf2, 0xb3, 0x13, 0xf7, 0x46, 0x1f, 0xa4, 0xf9, 0x99, 0xd6, 0xa2, 0x9d, 0xaa, - 0xf3, 0x08, 0x12, 0x7a, 0x0a, 0x0b, 0x8f, 0xbb, 0x67, 0xd8, 0x6b, 0xe3, 0x00, 0xfb, 0x82, 0xa3, - 0x49, 0xca, 0xd1, 0xbd, 0x7e, 0x2f, 0xbf, 0x7e, 0x21, 0x07, 0x63, 0x78, 0x1a, 0x44, 0x45, 0x18, - 0xe6, 0x39, 0xa3, 0x22, 0x88, 0xf0, 0x64, 0x6b, 0x85, 0xdb, 0x78, 0x64, 0xb4, 0x74, 0x9f, 0x6b, - 0x79, 0x4d, 0xca, 0x2e, 0x42, 0x93, 0xb2, 0x50, 0x94, 0x26, 0xda, 0x86, 0xa9, 0xa7, 0x6e, 0x03, - 0xd3, 0x33, 0x96, 0xa6, 0xdc, 0xb2, 0x1c, 0xca, 0x6d, 0xe0, 0x48, 0x82, 0x69, 0xc9, 0x89, 0xe8, - 0x08, 0xc6, 0x4f, 0x7c, 0xbb, 0xc9, 0xf2, 0xb0, 0xb9, 0xc2, 0x77, 0x38, 0x47, 0x51, 0xeb, 0xa3, - 0x49, 0x3d, 0x9d, 0x58, 0x5a, 0x24, 0x2e, 0xa4, 0x4b, 0x7e, 0x54, 0x5d, 0x08, 0x1d, 0x43, 0x5f, - 0x02, 0x70, 0xae, 0x8a, 0x9d, 0x0e, 0x4f, 0xc9, 0x16, 0x74, 0x21, 0x8b, 0x9d, 0x4e, 0x69, 0x83, - 0xcb, 0xb7, 0x22, 0xe5, 0xb3, 0x3b, 0x1d, 0x85, 0x9a, 0x42, 0xc4, 0xdc, 0x81, 0xb4, 0x5c, 0x1b, - 0x4d, 0xc2, 0x68, 0xb1, 0xd5, 0xca, 0x8c, 0x90, 0x1f, 0x2a, 0x95, 0x83, 0x8c, 0x81, 0xe6, 0x00, - 0x42, 0x85, 0x67, 0x52, 0x68, 0x06, 0xa6, 0x84, 0x42, 0x32, 0xa3, 0x74, 0x7e, 0xa7, 0x93, 0x19, - 0x33, 0xff, 0xcd, 0x18, 0xd8, 0x03, 0xe2, 0xc3, 0x2a, 0xec, 0x3a, 0x4a, 0x55, 0xc6, 0x1c, 0x1d, - 0xf5, 0x61, 0xfc, 0x96, 0x4a, 0xb5, 0x66, 0xa9, 0x93, 0xc8, 0xb1, 0x3a, 0x26, 0xd2, 0xd4, 0xdd, - 0x96, 0x7a, 0xac, 0x3a, 0x1c, 0x66, 0xc9, 0x51, 0x54, 0x50, 0x0e, 0xe0, 0x68, 0xe8, 0x84, 0xc4, - 0x01, 0x54, 0x37, 0x43, 0x1e, 0xc5, 0x42, 0xc8, 0x3c, 0x3f, 0x37, 0x14, 0x27, 0x66, 0xf3, 0xe5, - 0x3c, 0xf3, 0xd7, 0x86, 0xaa, 0x73, 0xe9, 0x64, 0x8d, 0x58, 0x27, 0xfb, 0x3e, 0xa4, 0x79, 0x9c, - 0x3c, 0xdc, 0xe1, 0xfc, 0x53, 0x1f, 0x22, 0x42, 0xac, 0xd3, 0xb0, 0xc2, 0x09, 0x68, 0x0b, 0x80, - 0x39, 0x94, 0x62, 0xa3, 0xe1, 0x71, 0x21, 0xe6, 0xfb, 0xbd, 0xfc, 0x34, 0x77, 0x39, 0x76, 0xa3, - 0xe1, 0x59, 0xca, 0x14, 0xa2, 0x51, 0xf5, 0xfa, 0x33, 0x16, 0x6a, 0x54, 0xbd, 0xe8, 0x68, 0x97, - 0x1b, 0xb3, 0x05, 0x73, 0xfb, 0x38, 0x20, 0x2a, 0x10, 0x8e, 0x6e, 0xb8, 0x08, 0x3f, 0x81, 0xe9, - 0xe7, 0x4e, 0x70, 0xae, 0x47, 0x1e, 0x7a, 0x99, 0x7a, 0xe9, 0x04, 0xe7, 0x22, 0xf2, 0x28, 0xaa, - 0x52, 0xa7, 0x9b, 0xbb, 0x30, 0xcf, 0x57, 0x93, 0x7e, 0xb5, 0xa0, 0x13, 0x34, 0xc2, 0x50, 0xa6, - 0x12, 0xd4, 0xc9, 0xe0, 0xa8, 0xa3, 0x41, 0x95, 0x01, 0xd7, 0xc3, 0xc2, 0x70, 0x52, 0x02, 0x4e, - 0x4f, 0x51, 0xc4, 0x25, 0x45, 0x1d, 0x91, 0x79, 0x02, 0xb3, 0xc7, 0xad, 0x6e, 0xd3, 0x69, 0x93, - 0xdd, 0xae, 0xe0, 0xaf, 0xd1, 0x0e, 0x40, 0x08, 0xe0, 0x2b, 0x88, 0xac, 0x33, 0x1c, 0xa8, 0x6d, - 0xf3, 0x6d, 0xa2, 0x10, 0xea, 0x3b, 0x2c, 0x05, 0xcf, 0xfc, 0xf3, 0x51, 0x40, 0x7c, 0x0d, 0x72, - 0x3f, 0xc6, 0x15, 0x1c, 0x10, 0x37, 0xb5, 0x02, 0xa9, 0xc3, 0x1d, 0xae, 0xf5, 0x89, 0x7e, 0x2f, - 0x9f, 0x72, 0x1a, 0x56, 0xea, 0x70, 0x07, 0x7d, 0x08, 0xe3, 0x74, 0x1a, 0xd5, 0xf5, 0x9c, 0x5c, - 0x4f, 0xa5, 0x50, 0x4a, 0xf7, 0x7b, 0xf9, 0x71, 0x72, 0x0f, 0xc7, 0x16, 0x9b, 0x8c, 0x3e, 0x82, - 0xf4, 0x0e, 0x6e, 0xe1, 0xa6, 0x1d, 0xb8, 0xc2, 0x76, 0xa8, 0x3b, 0x6a, 0x08, 0xa0, 0xb2, 0x45, - 0xe1, 0x4c, 0x12, 0x38, 0x2c, 0x6c, 0xfb, 0x6e, 0x5b, 0x0d, 0x1c, 0x1e, 0x85, 0xa8, 0x81, 0x83, - 0xcd, 0x41, 0x7f, 0x6d, 0xc0, 0x74, 0xb1, 0xdd, 0x76, 0x59, 0x79, 0xc5, 0xe7, 0xf7, 0xf9, 0xe5, - 0x4d, 0x59, 0x8e, 0x39, 0xb2, 0xcf, 0x70, 0xab, 0x46, 0x62, 0xb5, 0x5f, 0xfa, 0x8a, 0x78, 0x9d, - 0x7f, 0xef, 0xe5, 0x1f, 0xbe, 0x4e, 0x85, 0x67, 0xb3, 0xea, 0xd9, 0x4e, 0xe0, 0xd3, 0xeb, 0x4d, - 0xb8, 0xa0, 0x6a, 0x66, 0x0a, 0x1f, 0xe8, 0x5d, 0x18, 0x27, 0x37, 0x5d, 0x11, 0x7f, 0xe8, 0x66, - 0x93, 0xcb, 0xb0, 0x96, 0x75, 0xd1, 0x19, 0xe6, 0x7d, 0x48, 0x73, 0x4d, 0x1e, 0xee, 0x24, 0x6d, - 0x81, 0xf9, 0x04, 0xde, 0xb1, 0x5c, 0xaa, 0x5d, 0xec, 0xe3, 0xe0, 0xd8, 0xf6, 0xfd, 0x97, 0xae, - 0xd7, 0xa0, 0xd9, 0x3e, 0x37, 0x49, 0x61, 0xcd, 0xf7, 0x61, 0x92, 0x82, 0x25, 0x19, 0xba, 0x33, - 0xf4, 0xb6, 0x60, 0x89, 0x11, 0xb3, 0x0c, 0xeb, 0xfb, 0x38, 0x18, 0xa4, 0x75, 0x2b, 0x22, 0xbf, - 0x30, 0x20, 0x5f, 0xf6, 0x70, 0x2c, 0x53, 0x37, 0x3b, 0xca, 0xeb, 0xbc, 0xb4, 0x95, 0x0a, 0x47, - 0x89, 0xd2, 0x79, 0xf9, 0xea, 0x7b, 0x30, 0x5a, 0xad, 0x1e, 0x51, 0xd3, 0x19, 0xa5, 0x1a, 0x1c, - 0x0d, 0x82, 0xd6, 0x7f, 0xf5, 0xf2, 0x53, 0x3b, 0x5d, 0x56, 0xfa, 0xb2, 0xc8, 0xb8, 0x39, 0x0b, - 0xd3, 0xc7, 0x4e, 0xbb, 0xc9, 0x57, 0x34, 0xff, 0x22, 0x05, 0x33, 0xec, 0xdb, 0xef, 0xb8, 0x6d, - 0xe6, 0xe5, 0x55, 0x9f, 0x64, 0xdc, 0xc0, 0x27, 0xa1, 0x4f, 0x60, 0x96, 0xdf, 0x0c, 0xb1, 0x47, - 0xef, 0x77, 0x8c, 0x43, 0x5a, 0xd3, 0x60, 0x77, 0xc3, 0xd3, 0x2b, 0x36, 0x62, 0xe9, 0x13, 0xd1, - 0x11, 0xcc, 0x31, 0xc0, 0x1e, 0xb6, 0x83, 0x6e, 0x98, 0x53, 0xcd, 0xf3, 0x20, 0x28, 0xc0, 0xcc, - 0x24, 0x38, 0xad, 0x17, 0x1c, 0x68, 0x45, 0x70, 0xd1, 0x23, 0x98, 0x3f, 0xf6, 0xdc, 0x6f, 0x5e, - 0x29, 0x5e, 0x98, 0x9d, 0x8a, 0x65, 0x92, 0x82, 0x75, 0xc8, 0xd0, 0xa9, 0xea, 0x8b, 0xa3, 0xb3, - 0xcd, 0xdf, 0xa6, 0x60, 0x4a, 0x52, 0xdb, 0x54, 0x43, 0x25, 0xf7, 0x73, 0xd4, 0xfb, 0x87, 0xf9, - 0x8c, 0xa5, 0xcc, 0x40, 0x77, 0x68, 0xf0, 0xe4, 0x1e, 0x76, 0x92, 0x6c, 0x80, 0xdd, 0xe9, 0x58, - 0x04, 0x46, 0xec, 0x74, 0xa7, 0x44, 0x45, 0x9b, 0x62, 0x76, 0xda, 0x38, 0xb3, 0x52, 0x3b, 0x25, - 0xb2, 0xa3, 0xcf, 0x0e, 0x77, 0xca, 0x94, 0xcb, 0x29, 0xb6, 0xa3, 0xae, 0xd3, 0xa8, 0x5b, 0x14, - 0x4a, 0x46, 0x2b, 0xc5, 0x27, 0x47, 0xf4, 0x94, 0xf2, 0x51, 0xdf, 0xbe, 0x6c, 0x59, 0x14, 0x8a, - 0x1e, 0x0a, 0x0f, 0x5a, 0x76, 0xdb, 0x81, 0xe7, 0xb6, 0x7c, 0x5a, 0x3e, 0x9b, 0xd2, 0x3c, 0x65, - 0x9d, 0x0f, 0x59, 0x91, 0xa9, 0xe8, 0x39, 0xac, 0x16, 0x1b, 0x57, 0x76, 0xbb, 0x8e, 0x1b, 0x6c, - 0xe4, 0xb9, 0xeb, 0x5d, 0xbc, 0x68, 0xb9, 0x2f, 0x7d, 0x9a, 0xb8, 0x4d, 0xf1, 0x14, 0x90, 0x4f, - 0x39, 0xe5, 0xe4, 0x5e, 0x8a, 0x49, 0x56, 0x12, 0x36, 0xca, 0xc3, 0x78, 0xb9, 0xe5, 0x76, 0x1b, - 0x34, 0x63, 0x9b, 0x62, 0x07, 0xa1, 0x4e, 0x00, 0x16, 0x83, 0x9b, 0x3f, 0x82, 0x05, 0xe2, 0xbd, - 0x02, 0x7c, 0xe3, 0x10, 0x66, 0x1e, 0x03, 0x54, 0xf0, 0xa5, 0xdd, 0x39, 0x77, 0xc9, 0xb6, 0x94, - 0xd4, 0x2f, 0xee, 0xd3, 0x91, 0xbc, 0x18, 0xf3, 0x81, 0xda, 0xb6, 0x08, 0xd4, 0x62, 0xa6, 0xa5, - 0x60, 0x99, 0xff, 0x92, 0x02, 0x44, 0x2f, 0x88, 0x95, 0xc0, 0xc3, 0xf6, 0xa5, 0x60, 0xe3, 0xc7, - 0x30, 0xc3, 0x4e, 0x28, 0x03, 0x53, 0x76, 0x48, 0xc0, 0x60, 0xb6, 0xa8, 0x0e, 0x1d, 0x8c, 0x58, - 0xda, 0x54, 0x82, 0x6a, 0x61, 0xbf, 0x7b, 0x29, 0x50, 0x53, 0x1a, 0xaa, 0x3a, 0x44, 0x50, 0xd5, - 0x6f, 0xf4, 0x08, 0xe6, 0xca, 0xee, 0x65, 0x87, 0xe8, 0x84, 0x23, 0x8f, 0x72, 0xb7, 0xcc, 0xd7, - 0xd5, 0x06, 0xc9, 0x8d, 0x5a, 0x87, 0xa0, 0xa7, 0xb0, 0xb8, 0xd7, 0xea, 0xfa, 0xe7, 0xc5, 0x76, - 0xa3, 0xdc, 0x72, 0x7d, 0x41, 0x65, 0x8c, 0xdf, 0x4e, 0xf8, 0x49, 0x1a, 0x9c, 0x71, 0x30, 0x62, - 0xc5, 0x21, 0xa2, 0xef, 0xf1, 0x5a, 0x3a, 0x0f, 0x0f, 0xb3, 0x9b, 0xbc, 0xd4, 0xfe, 0xac, 0x8d, - 0x9f, 0xbd, 0x38, 0x18, 0xb1, 0xd8, 0x68, 0x29, 0x0d, 0x93, 0xc2, 0x8b, 0x6c, 0xc1, 0x82, 0xa2, - 0x4e, 0x12, 0xd0, 0xba, 0x3e, 0xca, 0xc1, 0xd4, 0x49, 0x87, 0x5c, 0x6f, 0x85, 0x5b, 0xb4, 0xe4, - 0xb7, 0xf9, 0xbe, 0xae, 0x69, 0xb4, 0xae, 0x26, 0x5a, 0x6c, 0x72, 0x08, 0x30, 0x0f, 0x74, 0xe5, - 0x0e, 0x9f, 0xad, 0xad, 0x9b, 0x8a, 0xac, 0x9b, 0x89, 0xea, 0xda, 0x5c, 0x8e, 0x55, 0x9e, 0xf9, - 0xc7, 0x06, 0x2c, 0xed, 0xe3, 0x80, 0x56, 0xe0, 0x88, 0x8f, 0x91, 0x01, 0xe3, 0x07, 0x6a, 0x31, - 0x96, 0xd9, 0xeb, 0x6c, 0xbf, 0x97, 0x4f, 0xcb, 0xd2, 0xab, 0x5a, 0x6e, 0xfd, 0x0c, 0xe6, 0x2a, - 0x17, 0x4e, 0xa7, 0x66, 0xb7, 0x9c, 0x06, 0xf5, 0xc1, 0xdc, 0x3b, 0x2c, 0x53, 0x6f, 0x76, 0xe1, - 0x74, 0x4e, 0xaf, 0xc2, 0x21, 0xc3, 0x8a, 0x4c, 0x36, 0x9f, 0xc1, 0x72, 0x84, 0x07, 0xee, 0xa4, - 0xff, 0x1f, 0x4c, 0x72, 0x10, 0x3f, 0x00, 0x03, 0x75, 0xdc, 0xe9, 0x7e, 0x2f, 0x3f, 0xe9, 0x73, - 0x34, 0x31, 0xd9, 0x7c, 0x02, 0x2b, 0x27, 0x1d, 0x1f, 0x7b, 0x21, 0x4d, 0x21, 0xd6, 0xb6, 0x2c, - 0x0c, 0x1b, 0xf1, 0x85, 0x61, 0xe8, 0xf7, 0xf2, 0x13, 0x8c, 0xa0, 0x28, 0x06, 0x9b, 0x75, 0x58, - 0x61, 0x67, 0x79, 0x80, 0xdc, 0xad, 0xb4, 0x24, 0x4e, 0x7f, 0x2a, 0xf6, 0xf4, 0x1f, 0x42, 0x8e, - 0x2f, 0xd2, 0x6a, 0xbd, 0xd9, 0x76, 0x98, 0xff, 0x6c, 0xc0, 0xea, 0x3e, 0x6e, 0x63, 0xcf, 0xa6, - 0x2c, 0x6b, 0xa1, 0x57, 0x2d, 0x00, 0x18, 0x43, 0x0b, 0x00, 0x79, 0x91, 0xac, 0xa4, 0x68, 0xb2, - 0x42, 0x5d, 0x1c, 0x4d, 0x56, 0x78, 0x8a, 0x42, 0x02, 0xc1, 0x89, 0x75, 0xc8, 0x93, 0x38, 0x1a, - 0x08, 0xba, 0x9e, 0x63, 0x11, 0x18, 0x3a, 0x0c, 0x8b, 0x07, 0x63, 0xd7, 0x16, 0x0f, 0x16, 0xf9, - 0xb5, 0x6f, 0x92, 0x17, 0x0f, 0xb4, 0x92, 0x81, 0xf9, 0x10, 0xb2, 0x83, 0xb2, 0x70, 0xfb, 0xc8, - 0xc3, 0x38, 0x2b, 0x8c, 0x0e, 0xa4, 0x23, 0x0c, 0x6e, 0xee, 0x84, 0xd6, 0xcd, 0xcb, 0x80, 0xb2, - 0x68, 0x12, 0x39, 0x59, 0x43, 0x2e, 0x3c, 0x66, 0x25, 0xb4, 0x4f, 0x4e, 0x85, 0xaf, 0xff, 0x29, - 0xb1, 0x4f, 0x56, 0xea, 0x35, 0x92, 0x4b, 0xbd, 0xdc, 0x46, 0x19, 0xaa, 0x40, 0x30, 0x9f, 0xc3, - 0x8a, 0x46, 0x34, 0xb4, 0xfa, 0xcf, 0x60, 0x4a, 0xc0, 0x22, 0xb9, 0xbc, 0x46, 0x96, 0xee, 0x9b, - 0x2f, 0x90, 0x25, 0x8a, 0xf9, 0x2b, 0x03, 0x56, 0x99, 0xd3, 0x19, 0x94, 0xfb, 0xe6, 0xbb, 0xff, - 0xbf, 0x71, 0xc9, 0xfb, 0x62, 0x6c, 0x2a, 0x95, 0x19, 0x35, 0x6b, 0x90, 0x1d, 0xe4, 0xf7, 0x2d, - 0x68, 0x78, 0x1f, 0x56, 0x95, 0x63, 0xfb, 0xc6, 0xfb, 0x1f, 0xae, 0xf8, 0x16, 0xf7, 0x3f, 0x9c, - 0xf8, 0xd6, 0xf6, 0xff, 0x10, 0x16, 0x19, 0x61, 0xfd, 0xac, 0x14, 0xd4, 0xb3, 0x12, 0xfb, 0x88, - 0x30, 0x78, 0x7c, 0x9e, 0xd0, 0xe3, 0x23, 0xa6, 0x84, 0x1c, 0x7e, 0x04, 0x13, 0xfc, 0x15, 0x96, - 0xf1, 0x17, 0x43, 0x8c, 0xfa, 0x51, 0xf6, 0xf4, 0x6a, 0xf1, 0xc9, 0x66, 0x96, 0x8a, 0x4c, 0x52, - 0x49, 0x5e, 0x3b, 0x11, 0xee, 0xcd, 0xfc, 0x92, 0x38, 0xac, 0xc8, 0xc8, 0x1b, 0xc6, 0x80, 0x67, - 0x90, 0x65, 0x31, 0x40, 0xa1, 0xfa, 0x46, 0x51, 0xe0, 0x13, 0xc8, 0x32, 0x73, 0x8a, 0x21, 0x38, - 0xdc, 0xb5, 0x6f, 0xc0, 0xba, 0x74, 0xed, 0x71, 0xd2, 0xff, 0xa9, 0x01, 0x77, 0xf6, 0x71, 0xa0, - 0x3f, 0x25, 0xfd, 0x9f, 0x44, 0xe2, 0xaf, 0x20, 0x17, 0xc7, 0x08, 0xdf, 0x8a, 0xcf, 0xa3, 0x5b, - 0x91, 0xf8, 0x6e, 0x16, 0xbf, 0x25, 0x3f, 0x87, 0x35, 0xb6, 0x25, 0xfa, 0x7c, 0x21, 0xe8, 0xc3, - 0xc8, 0xae, 0x24, 0x52, 0x8f, 0xdb, 0x9d, 0xbf, 0x34, 0x60, 0x8d, 0x29, 0x39, 0x9e, 0xf8, 0xad, - 0xb4, 0x78, 0x1f, 0x26, 0x0e, 0x5c, 0x72, 0xf3, 0xe6, 0x1b, 0x4a, 0xc5, 0x39, 0x77, 0xfd, 0x80, - 0x38, 0x06, 0x3e, 0x34, 0xfc, 0xdd, 0xc2, 0x7c, 0x0a, 0x79, 0xb9, 0xe7, 0x6f, 0x61, 0x63, 0xcd, - 0x3a, 0x20, 0x41, 0xa6, 0x5c, 0xb1, 0x04, 0x89, 0x3b, 0x30, 0x5a, 0xae, 0x58, 0xbc, 0xec, 0x4f, - 0x43, 0x70, 0xdd, 0xf7, 0x2c, 0x02, 0x8b, 0xfa, 0xe3, 0xd4, 0x4d, 0x8a, 0x6e, 0xbf, 0x07, 0x8b, - 0xda, 0x22, 0x7c, 0xdf, 0xd7, 0x61, 0xac, 0x8c, 0xbd, 0x80, 0x2f, 0x43, 0x25, 0xad, 0x63, 0x2f, - 0xb0, 0x28, 0x14, 0xbd, 0x03, 0x93, 0xe5, 0x22, 0x2d, 0x0a, 0xd3, 0x4c, 0x61, 0x86, 0x39, 0xa6, - 0xba, 0x7d, 0x5a, 0xa7, 0x85, 0x62, 0x31, 0x68, 0xfe, 0x99, 0xa1, 0x50, 0x27, 0xe8, 0xd7, 0xcb, - 0xb0, 0x45, 0xee, 0x40, 0x44, 0x67, 0x8a, 0x08, 0x34, 0x08, 0xf1, 0x1b, 0x32, 0x95, 0x40, 0x99, - 0x72, 0xd3, 0xe2, 0xc0, 0x57, 0xb0, 0xa4, 0x73, 0xf2, 0x56, 0x05, 0xfd, 0x2e, 0x2d, 0x5d, 0x92, - 0x1c, 0x49, 0x88, 0x88, 0xd4, 0x7b, 0x1f, 0x37, 0x90, 0x8f, 0x21, 0xc3, 0x67, 0x85, 0x07, 0xec, - 0xbe, 0x48, 0xb9, 0xd8, 0xf1, 0xd2, 0x7b, 0x27, 0x44, 0x65, 0xe8, 0xfb, 0xe2, 0x66, 0x79, 0xdd, - 0x0a, 0x17, 0x90, 0x7d, 0xb2, 0x57, 0x2c, 0x76, 0x83, 0x73, 0xdc, 0x0e, 0x9c, 0xba, 0x1d, 0xe0, - 0xf2, 0xb9, 0xdd, 0x6a, 0xe1, 0x76, 0x93, 0x2a, 0xea, 0xa4, 0xb0, 0x27, 0xc3, 0x0b, 0xaf, 0xee, - 0x17, 0xf6, 0xe4, 0x0c, 0x8b, 0x8c, 0xa3, 0x07, 0x30, 0x56, 0x7d, 0x56, 0x3d, 0xe6, 0xd7, 0xbc, - 0x25, 0x3e, 0x8f, 0x80, 0xc2, 0x89, 0x74, 0x86, 0xf9, 0x0d, 0xac, 0x46, 0x16, 0x93, 0x52, 0xbd, - 0x23, 0xd6, 0x32, 0xe8, 0x15, 0x56, 0xae, 0x25, 0x26, 0x1c, 0x8c, 0xb0, 0xc5, 0xde, 0xd5, 0x16, - 0x5b, 0x54, 0x16, 0x53, 0x66, 0xd2, 0x29, 0xfc, 0xa5, 0x93, 0xc2, 0xcc, 0x3f, 0x80, 0x19, 0x95, - 0x71, 0x72, 0x6b, 0x7a, 0x8c, 0x5f, 0x1d, 0xd8, 0xed, 0x46, 0x4b, 0xe8, 0x23, 0x04, 0x90, 0x51, - 0x39, 0x95, 0x5f, 0x9b, 0x42, 0x00, 0x5a, 0x82, 0xf1, 0x62, 0xa7, 0x73, 0xb8, 0xc3, 0x0e, 0xb5, - 0xc5, 0x3e, 0x50, 0x16, 0x26, 0x45, 0xc5, 0x87, 0xa6, 0x35, 0x96, 0xf8, 0x34, 0x1d, 0x98, 0x56, - 0x04, 0xb9, 0x66, 0xe9, 0x0d, 0x80, 0x72, 0xcb, 0xc1, 0x6d, 0xea, 0xfe, 0xf8, 0xda, 0x0a, 0x84, - 0x5e, 0xf7, 0x9c, 0x66, 0x9b, 0x96, 0x65, 0x38, 0x03, 0x21, 0xc0, 0x9c, 0x87, 0x59, 0x4d, 0xef, - 0xa6, 0x09, 0x33, 0xaa, 0x6e, 0x88, 0x09, 0x94, 0xdd, 0x86, 0x34, 0x01, 0xf2, 0xb3, 0xf9, 0x4b, - 0x03, 0x96, 0x9e, 0xec, 0x15, 0x2d, 0xdc, 0x74, 0x68, 0x6b, 0x8f, 0x14, 0x74, 0x4b, 0xdd, 0x93, - 0x35, 0x75, 0x4f, 0x22, 0x33, 0xc5, 0xe6, 0x14, 0xb4, 0xcd, 0x59, 0xd7, 0x36, 0x67, 0x10, 0x85, - 0xed, 0x92, 0x72, 0x73, 0xfe, 0x85, 0x01, 0x8b, 0x0a, 0x23, 0x92, 0xe9, 0x4d, 0x95, 0x8f, 0xdc, - 0x20, 0x1f, 0x51, 0x1b, 0xf9, 0x91, 0xc6, 0xc6, 0x5a, 0x0c, 0x1b, 0x43, 0x6d, 0xa5, 0x01, 0x4b, - 0x71, 0x42, 0xea, 0x56, 0x61, 0x24, 0x5a, 0x45, 0x2a, 0xc1, 0x2a, 0x46, 0x75, 0xab, 0xb0, 0x61, - 0x31, 0x46, 0x04, 0xf4, 0x1e, 0x64, 0x18, 0x8c, 0xb9, 0x22, 0x5e, 0xab, 0x27, 0x98, 0x03, 0xf0, - 0xeb, 0x6c, 0xc5, 0xfc, 0xb5, 0x01, 0xcb, 0xb1, 0xca, 0x47, 0x2b, 0x24, 0x8a, 0xd6, 0x3d, 0x1c, - 0x70, 0xda, 0xfc, 0x8b, 0xc0, 0x0f, 0x7d, 0xbf, 0xcb, 0xdb, 0xfd, 0xd2, 0x16, 0xff, 0x42, 0xdf, - 0x85, 0xd9, 0x63, 0xec, 0x39, 0x6e, 0xa3, 0x82, 0xeb, 0x6e, 0xbb, 0xc1, 0x2a, 0x93, 0xb3, 0x96, - 0x0e, 0x24, 0x0a, 0x2a, 0xb6, 0x9a, 0xae, 0xe7, 0x04, 0xe7, 0x97, 0xfc, 0x10, 0x84, 0x00, 0x42, - 0x7b, 0xc7, 0x69, 0x3a, 0x01, 0xab, 0xb4, 0xcf, 0x5a, 0xfc, 0x8b, 0xa8, 0xa8, 0x58, 0xaf, 0xbb, - 0xdd, 0x76, 0x40, 0x8b, 0x76, 0x69, 0x4b, 0x7c, 0x9a, 0xef, 0xc1, 0x52, 0xdc, 0xa6, 0xc5, 0x1a, - 0xf1, 0x1f, 0xa6, 0x60, 0xb1, 0xd8, 0x68, 0x3c, 0xd9, 0x2b, 0xee, 0x60, 0x35, 0xe9, 0xfa, 0x10, - 0xc6, 0x0e, 0xdb, 0x4e, 0xc0, 0x8d, 0x67, 0x83, 0xdb, 0x42, 0xcc, 0x4c, 0x32, 0x8b, 0x98, 0x03, - 0xf9, 0x1f, 0x59, 0xb0, 0xb8, 0xfb, 0x8d, 0xe3, 0x07, 0x4e, 0xbb, 0x49, 0x0d, 0x92, 0x2d, 0xcc, - 0x0d, 0x4a, 0x10, 0x49, 0x70, 0x65, 0x07, 0x23, 0x56, 0x1c, 0x32, 0xaa, 0xc2, 0xca, 0x53, 0xfc, - 0x32, 0xc6, 0xbe, 0xe5, 0xd3, 0xb9, 0x24, 0x1b, 0x63, 0xa6, 0x09, 0xb8, 0xea, 0xf1, 0xf9, 0x65, - 0x0a, 0x96, 0x74, 0xc1, 0xf8, 0xca, 0x27, 0xb0, 0xa4, 0x30, 0xa4, 0xdb, 0xf0, 0x74, 0x21, 0x1f, - 0x2f, 0x8e, 0x7a, 0x52, 0x63, 0xd1, 0xd1, 0x73, 0x58, 0xd5, 0x99, 0xd2, 0x7d, 0x66, 0x78, 0xf2, - 0xe2, 0xa6, 0x1c, 0x8c, 0x58, 0x49, 0xd8, 0xa8, 0x00, 0xa3, 0xc5, 0xfa, 0x05, 0x57, 0x4b, 0xfc, - 0x96, 0x31, 0xc9, 0x8a, 0xf5, 0x0b, 0x72, 0xe6, 0x8b, 0xf5, 0x0b, 0xed, 0x00, 0xff, 0x8d, 0x01, - 0xab, 0x09, 0x3b, 0x4c, 0xce, 0x0c, 0x03, 0x2a, 0x91, 0x50, 0x81, 0xa0, 0xcf, 0x94, 0x77, 0x85, - 0xb9, 0xc2, 0xbb, 0xc3, 0xed, 0x65, 0x93, 0x41, 0xaa, 0xf2, 0xe1, 0xc1, 0xcc, 0x0b, 0xf2, 0xf4, - 0x19, 0x62, 0x8a, 0x39, 0x22, 0xf6, 0xe6, 0x7c, 0x52, 0xd8, 0xcb, 0x18, 0x66, 0x39, 0xca, 0x9a, - 0x94, 0x04, 0x3d, 0x80, 0x09, 0x06, 0xe4, 0x1b, 0x23, 0xfa, 0x1a, 0xc3, 0xc9, 0x7c, 0xdc, 0xfc, - 0x3b, 0x43, 0x14, 0x9b, 0x06, 0xec, 0xfd, 0x63, 0xcd, 0xde, 0xc5, 0x93, 0x7c, 0xfc, 0x64, 0xcd, - 0xe4, 0x4b, 0x30, 0xfd, 0x3a, 0xa6, 0xae, 0x22, 0xa9, 0xc6, 0xf8, 0xf7, 0x86, 0xb8, 0x58, 0x0f, - 0xda, 0xe3, 0x2e, 0xcc, 0xbc, 0x9e, 0x1d, 0x6a, 0x68, 0xe8, 0x23, 0x66, 0x26, 0xa9, 0xe1, 0x92, - 0x0e, 0xb5, 0x94, 0x9f, 0x88, 0x7a, 0xda, 0xeb, 0xd8, 0x8a, 0xb9, 0x1e, 0x83, 0x2d, 0x97, 0x33, - 0x57, 0xe8, 0xbd, 0x58, 0x0e, 0xc9, 0x8b, 0x5c, 0x99, 0x16, 0x0a, 0x54, 0xb8, 0x74, 0xfd, 0x93, - 0x1c, 0x24, 0xdb, 0xb0, 0xa2, 0x06, 0x20, 0x26, 0x10, 0x13, 0xbf, 0x73, 0xe2, 0x63, 0xaf, 0xe2, - 0xb4, 0x9b, 0x2d, 0x7c, 0xc2, 0x52, 0x54, 0x79, 0x69, 0xf8, 0xa1, 0x66, 0x04, 0xab, 0x09, 0x7d, - 0x19, 0xff, 0x53, 0x5b, 0xff, 0xb7, 0x06, 0xe4, 0xe2, 0x78, 0x7b, 0xbb, 0xbb, 0xbf, 0xc9, 0xd3, - 0x70, 0xc6, 0x6d, 0x96, 0xa3, 0xcb, 0x35, 0x85, 0xb0, 0x44, 0x48, 0xf2, 0xbf, 0xb6, 0xed, 0xbf, - 0x32, 0x60, 0xe9, 0xd0, 0xa7, 0xec, 0x7f, 0xdd, 0x75, 0x3c, 0xdc, 0x10, 0x8a, 0xdb, 0x8c, 0xeb, - 0xde, 0xa1, 0x1b, 0x7f, 0x30, 0x12, 0xd7, 0x9d, 0xf3, 0xa1, 0xd2, 0x74, 0x91, 0x1a, 0xd6, 0x96, - 0x73, 0x30, 0x12, 0xb6, 0x5d, 0xa0, 0x77, 0x60, 0xec, 0x29, 0x89, 0x5f, 0xa3, 0xfc, 0x98, 0x33, - 0x0c, 0x02, 0x3a, 0x72, 0x9b, 0x4e, 0x9b, 0xb0, 0x4c, 0x3e, 0x4a, 0x53, 0x30, 0x51, 0xb5, 0xbd, - 0x26, 0x0e, 0xcc, 0x8f, 0x20, 0x2d, 0x87, 0x69, 0x1a, 0xaf, 0x84, 0x3f, 0xf2, 0x33, 0xc9, 0x3e, - 0xe8, 0xa0, 0xc8, 0x3e, 0xe8, 0x87, 0xb9, 0x0d, 0xcb, 0x11, 0x31, 0xf9, 0x1e, 0xe4, 0x88, 0x32, - 0x18, 0x8c, 0x3d, 0xe6, 0x59, 0xf2, 0xdb, 0x2c, 0xc3, 0xc2, 0x80, 0x16, 0x11, 0x52, 0xfa, 0xd3, - 0xc8, 0x41, 0xaa, 0x54, 0x0e, 0x08, 0x4c, 0xb6, 0xa3, 0x11, 0x58, 0xf5, 0xa8, 0x52, 0x9a, 0x60, - 0xbb, 0x42, 0x62, 0x11, 0xb9, 0xb9, 0xd0, 0xc7, 0x11, 0x3f, 0x2c, 0x80, 0x44, 0xef, 0xb2, 0xea, - 0x7d, 0xba, 0x04, 0xe9, 0x4a, 0x60, 0xd3, 0x7b, 0xbf, 0x50, 0xe6, 0xb0, 0x82, 0xf0, 0xd4, 0xb7, - 0xbd, 0xfc, 0x08, 0xad, 0x02, 0x87, 0x68, 0xe8, 0x73, 0x98, 0xdc, 0x6d, 0x37, 0x28, 0x85, 0xd1, - 0x5b, 0x50, 0x10, 0x48, 0xe4, 0xc4, 0x53, 0x96, 0x89, 0xf7, 0xf6, 0x69, 0x33, 0x61, 0xda, 0x52, - 0x20, 0x54, 0xcd, 0xce, 0xa5, 0xc3, 0x5e, 0x83, 0xc6, 0x2d, 0xf6, 0x41, 0xb4, 0x49, 0x59, 0x78, - 0x8c, 0x5f, 0xf1, 0x14, 0x46, 0x7e, 0x9b, 0xbf, 0xa1, 0x65, 0xf6, 0x80, 0x17, 0xde, 0x74, 0x7d, - 0x68, 0x12, 0x1b, 0x6f, 0x2c, 0x71, 0xea, 0x75, 0x24, 0x96, 0x12, 0x8d, 0x26, 0x49, 0x34, 0x16, - 0x91, 0x68, 0x1f, 0x26, 0x98, 0x18, 0xe4, 0x26, 0x7a, 0x18, 0xe0, 0xcb, 0xf0, 0x26, 0xaa, 0xbe, - 0x8d, 0x59, 0x6c, 0x8c, 0xa4, 0x77, 0x47, 0xb6, 0x4f, 0x29, 0x31, 0xdb, 0x14, 0x9f, 0xe6, 0x19, - 0x64, 0x8e, 0x1c, 0x3f, 0x20, 0xf6, 0x7b, 0x43, 0x13, 0x91, 0xcc, 0xa6, 0x92, 0x98, 0x1d, 0x8d, - 0x30, 0xfb, 0x53, 0x58, 0x50, 0xd6, 0xe0, 0xd6, 0xff, 0xee, 0x75, 0xd5, 0x42, 0x59, 0x8d, 0x22, - 0xdc, 0x3f, 0xc5, 0xdf, 0xa8, 0xdc, 0xf3, 0xcf, 0xf7, 0xde, 0x83, 0xb4, 0xfc, 0x45, 0x1a, 0x12, - 0xe8, 0x0f, 0x9f, 0x1e, 0x56, 0x59, 0xa0, 0x3f, 0x3e, 0xa9, 0x66, 0x0c, 0x04, 0x30, 0xb1, 0xb3, - 0x7b, 0xb4, 0x5b, 0xdd, 0xcd, 0xa4, 0x0a, 0xff, 0xf4, 0x10, 0xa6, 0x89, 0x57, 0xe3, 0x35, 0x3d, - 0xf4, 0x13, 0x98, 0xab, 0xe0, 0x76, 0xe3, 0x31, 0xc6, 0x9d, 0x62, 0xcb, 0xb9, 0xc2, 0x3e, 0x12, - 0xae, 0x5e, 0x82, 0x72, 0x2b, 0x03, 0xfb, 0xb8, 0x7b, 0xd9, 0x09, 0x5e, 0x3d, 0x30, 0xd0, 0x0f, - 0x60, 0x9a, 0x36, 0xb6, 0xf2, 0x5d, 0x98, 0x51, 0x9b, 0x5d, 0x73, 0xe2, 0x8b, 0x0e, 0x7e, 0x60, - 0xa0, 0xcf, 0x60, 0x72, 0x1f, 0x53, 0xf9, 0xd1, 0x77, 0x22, 0xbf, 0xbb, 0x73, 0xd8, 0x96, 0x9a, - 0xe5, 0xea, 0xcf, 0x45, 0x15, 0x81, 0xca, 0x30, 0xc5, 0xd1, 0x7d, 0x64, 0x46, 0xf0, 0xfd, 0x18, - 0x02, 0x8b, 0x11, 0x02, 0x44, 0xf9, 0xe8, 0x73, 0x48, 0xcb, 0x4d, 0x40, 0x22, 0x1a, 0x45, 0xb7, - 0x3e, 0x97, 0x1d, 0x1c, 0xe0, 0xfb, 0xb5, 0x05, 0xc0, 0x4a, 0x82, 0x54, 0x8c, 0x28, 0x8f, 0xb9, - 0x01, 0xdd, 0xa1, 0x7d, 0x12, 0xb8, 0x49, 0x60, 0xbe, 0xa9, 0xdc, 0x09, 0xca, 0x46, 0x47, 0x30, - 0x27, 0x0b, 0x74, 0x37, 0x57, 0x42, 0x12, 0xb5, 0x4f, 0x61, 0x41, 0xbc, 0x52, 0xc9, 0x58, 0x8c, - 0x92, 0xa2, 0xb3, 0xdc, 0x49, 0x36, 0x0d, 0x43, 0x4e, 0xc5, 0xd5, 0x63, 0x2b, 0xba, 0xa7, 0x10, - 0x89, 0x4d, 0x09, 0x72, 0xdf, 0x19, 0x32, 0x83, 0xa9, 0xf9, 0x81, 0xf1, 0x81, 0x81, 0xbe, 0x80, - 0x59, 0x2d, 0x62, 0x20, 0x91, 0xc3, 0xc7, 0x85, 0xcb, 0xdc, 0x7a, 0xfc, 0x20, 0xdf, 0xb6, 0x3d, - 0x22, 0x6e, 0x10, 0xe9, 0x75, 0xcb, 0xc5, 0xf5, 0xb4, 0xb1, 0xf6, 0xe9, 0x9c, 0x78, 0xe4, 0x8f, - 0xa0, 0xec, 0xc2, 0x22, 0x7f, 0xfa, 0xd1, 0x7e, 0xaf, 0x24, 0xa1, 0x3b, 0x2e, 0x51, 0xfb, 0x8f, - 0x60, 0x91, 0xef, 0xa5, 0x46, 0x26, 0x23, 0xdb, 0x12, 0x78, 0x23, 0x55, 0x22, 0x81, 0x2f, 0x60, - 0xb9, 0x12, 0x91, 0x87, 0xb5, 0xab, 0xdd, 0xd1, 0x49, 0x28, 0x7d, 0x71, 0x89, 0xb4, 0x1e, 0x03, - 0xaa, 0x74, 0xcf, 0x2e, 0x1d, 0x49, 0xee, 0xca, 0xc1, 0x2f, 0xd1, 0xdd, 0x88, 0x48, 0x04, 0x48, - 0xa7, 0xd1, 0xe0, 0x91, 0x4b, 0x90, 0x18, 0x55, 0xd9, 0xd3, 0x23, 0xeb, 0x6a, 0xb1, 0x3b, 0xf6, - 0x99, 0xd3, 0x72, 0x02, 0x07, 0x13, 0xb3, 0x50, 0x11, 0xd4, 0x21, 0xb1, 0x83, 0x77, 0x12, 0x67, - 0xa0, 0xcf, 0x61, 0x76, 0x1f, 0x07, 0x61, 0xeb, 0x1f, 0x5a, 0x1d, 0x68, 0x16, 0xe4, 0xfb, 0x26, - 0x4a, 0x7e, 0x7a, 0xbf, 0xe1, 0x21, 0x64, 0x4e, 0x3a, 0x0d, 0x3b, 0xc0, 0x0a, 0x89, 0xbb, 0x03, - 0x24, 0xf8, 0x14, 0xdb, 0xb3, 0x2f, 0xfd, 0x44, 0x6d, 0x6d, 0xc1, 0xd8, 0xb1, 0xd3, 0x6e, 0x22, - 0x51, 0x17, 0x54, 0x9a, 0xb6, 0x72, 0x8b, 0x1a, 0x8c, 0x9b, 0x5e, 0x00, 0xf9, 0x6b, 0x7a, 0xde, - 0xd0, 0x0f, 0x65, 0xa2, 0x76, 0x93, 0xde, 0xb8, 0x9c, 0x72, 0xee, 0xe3, 0x27, 0xd6, 0xb6, 0xd1, - 0xcf, 0xe8, 0x3e, 0x0c, 0xce, 0x40, 0xf7, 0xf9, 0x5a, 0xc3, 0x1a, 0xe7, 0x72, 0x6b, 0x89, 0x2b, - 0xd4, 0xb6, 0xd1, 0xa9, 0x78, 0xfe, 0x8c, 0xa1, 0xfe, 0x8e, 0xd6, 0x93, 0xf3, 0x9a, 0x0b, 0x6c, - 0xd1, 0x38, 0x41, 0x7f, 0x37, 0x6f, 0x39, 0xe4, 0x56, 0xe9, 0x4b, 0xca, 0xe9, 0xbf, 0xdd, 0x87, - 0xb6, 0x69, 0x64, 0xa0, 0xdd, 0xb0, 0x68, 0x45, 0xc7, 0xf0, 0xe3, 0x51, 0x3e, 0x30, 0xd0, 0x36, - 0x00, 0xe3, 0x92, 0x2e, 0xa4, 0x0f, 0x27, 0xee, 0xfe, 0x36, 0x71, 0xff, 0x8d, 0x5b, 0x22, 0x7d, - 0x2e, 0x42, 0x00, 0x45, 0xca, 0x6a, 0xb7, 0x43, 0x55, 0xaa, 0x24, 0xfc, 0x43, 0xc8, 0x14, 0xeb, - 0xd4, 0xa1, 0xc9, 0x56, 0x29, 0xb4, 0x21, 0x0f, 0x8b, 0x3e, 0x20, 0x68, 0x2d, 0x47, 0x3b, 0xaf, - 0x8e, 0x30, 0x49, 0xf7, 0x0f, 0x60, 0x55, 0x86, 0xa6, 0xc8, 0x50, 0x3c, 0x46, 0x22, 0x53, 0xbb, - 0xb0, 0x54, 0xb6, 0xdb, 0x75, 0xdc, 0x7a, 0x33, 0x32, 0x9f, 0xd2, 0x93, 0xad, 0xb4, 0x91, 0xad, - 0x44, 0xf1, 0xf9, 0xc1, 0x16, 0xed, 0xf7, 0xca, 0xd4, 0x22, 0xcc, 0x33, 0x25, 0x86, 0x6a, 0x49, - 0xc2, 0x4e, 0x5a, 0xfe, 0x63, 0x98, 0xdb, 0x25, 0x9e, 0xaf, 0xdb, 0x70, 0xd8, 0x05, 0x01, 0xe9, - 0x99, 0x63, 0x22, 0xe2, 0x01, 0x2c, 0xf0, 0x40, 0x10, 0xf6, 0x57, 0x49, 0xe7, 0x3b, 0xd8, 0xc2, - 0x96, 0x5b, 0x12, 0x64, 0xd5, 0x56, 0x2c, 0x11, 0xe6, 0xb4, 0x66, 0x22, 0x19, 0xe6, 0xe2, 0xda, - 0x9c, 0x64, 0x98, 0x8b, 0xef, 0x3f, 0x2a, 0xc1, 0x7c, 0xa4, 0x8f, 0x08, 0xdd, 0x15, 0xc1, 0x36, - 0xb6, 0xbf, 0x28, 0x26, 0x61, 0x39, 0x10, 0x5a, 0x1d, 0xa4, 0x11, 0xdf, 0x54, 0x94, 0xa8, 0xa3, - 0x63, 0x19, 0xe5, 0xd4, 0x0e, 0x21, 0xa4, 0x97, 0x47, 0xe2, 0xba, 0x87, 0x12, 0x29, 0x56, 0xc8, - 0x4d, 0x4e, 0xef, 0xad, 0x41, 0x1b, 0x52, 0x23, 0xb1, 0x0d, 0x44, 0xb9, 0x7c, 0xe2, 0x38, 0x57, - 0x9a, 0xb2, 0x01, 0xec, 0x37, 0x18, 0xa3, 0x1b, 0xa0, 0x76, 0x62, 0x0c, 0x6c, 0x80, 0xde, 0x60, - 0xb1, 0x4f, 0x9f, 0xd2, 0x94, 0x26, 0x19, 0x94, 0x20, 0x4a, 0xee, 0x6e, 0x1c, 0x9d, 0x70, 0x27, - 0x2b, 0x90, 0x89, 0xf6, 0x98, 0x48, 0x49, 0x13, 0x9a, 0x65, 0xa4, 0xa4, 0x89, 0xcd, 0x29, 0x5f, - 0x40, 0x26, 0xda, 0x60, 0x22, 0x89, 0x26, 0x74, 0x9e, 0x24, 0x6e, 0xc5, 0x1e, 0x2c, 0xe9, 0x1b, - 0x78, 0x8d, 0xbc, 0xc9, 0x99, 0xcc, 0xac, 0xd6, 0x56, 0x82, 0x44, 0x68, 0x88, 0x74, 0xb0, 0x0c, - 0x68, 0x3f, 0xa6, 0xbd, 0x85, 0x69, 0x5f, 0x69, 0x51, 0xb9, 0x89, 0xf6, 0xe3, 0x3a, 0x5a, 0xa4, - 0xa2, 0x14, 0xbe, 0x84, 0xc7, 0x8d, 0x0e, 0xdc, 0x46, 0x51, 0x37, 0x61, 0x2d, 0x89, 0xce, 0x0e, - 0x4c, 0x2b, 0xbd, 0x2d, 0xe8, 0x8e, 0xa6, 0x26, 0xcd, 0xe2, 0x73, 0x9a, 0x70, 0xba, 0xb1, 0x97, - 0x61, 0x46, 0xed, 0x90, 0x49, 0xe4, 0x62, 0x6d, 0x90, 0x86, 0xaf, 0x64, 0xd3, 0x73, 0x52, 0x0b, - 0x8c, 0x9b, 0xf5, 0xa8, 0x72, 0x34, 0x86, 0x92, 0x45, 0x42, 0xaa, 0x6a, 0xae, 0x61, 0x29, 0x39, - 0x12, 0x2d, 0xb2, 0x98, 0xac, 0xff, 0xee, 0x74, 0xc2, 0xaf, 0x60, 0x0f, 0xf1, 0x56, 0xf3, 0x91, - 0x96, 0x1e, 0xa4, 0x58, 0x49, 0x4c, 0x1b, 0x4c, 0x6e, 0x23, 0x69, 0x98, 0xab, 0xe9, 0x08, 0x16, - 0x06, 0x3a, 0x7a, 0x50, 0x5e, 0xf3, 0xc7, 0x83, 0xad, 0x39, 0x43, 0xee, 0x7f, 0x0b, 0x03, 0xed, - 0x3c, 0x92, 0x5a, 0x52, 0xa3, 0x4f, 0x22, 0xb5, 0x2a, 0x2c, 0xc7, 0xb6, 0xf8, 0xc8, 0xfc, 0x70, - 0x58, 0x03, 0x50, 0x22, 0xd5, 0x9f, 0x01, 0x1a, 0x6c, 0xc7, 0x91, 0x37, 0xc2, 0xc4, 0x96, 0x21, - 0x79, 0x23, 0x1c, 0xd2, 0xcb, 0x73, 0x04, 0x4b, 0x71, 0xbd, 0x38, 0xc8, 0xd4, 0xf4, 0x19, 0xdb, - 0x4b, 0x13, 0x13, 0xe4, 0x2c, 0x71, 0x28, 0x13, 0xa8, 0x0d, 0xe9, 0xcc, 0x49, 0x14, 0xfe, 0xe7, - 0xa2, 0xdf, 0x6a, 0xb0, 0x83, 0x46, 0xe6, 0xc5, 0xd7, 0xb4, 0xd8, 0x0c, 0x49, 0x37, 0xe6, 0x2b, - 0x4e, 0xb3, 0xad, 0x34, 0xbb, 0xc8, 0x64, 0x63, 0xb0, 0xcb, 0x46, 0x3a, 0x80, 0xb8, 0xde, 0x98, - 0x67, 0xb0, 0x24, 0x22, 0xa1, 0xda, 0x52, 0x82, 0x06, 0x70, 0xc2, 0x8e, 0x17, 0xe9, 0x0c, 0x62, - 0x7b, 0x50, 0x58, 0xb6, 0x4e, 0xff, 0x20, 0x86, 0x92, 0xad, 0x2b, 0xbd, 0x1e, 0x39, 0xbd, 0x2d, - 0x04, 0x3d, 0xa4, 0xd9, 0x3a, 0x6b, 0xc9, 0x4d, 0x3a, 0xeb, 0xab, 0x3a, 0xa5, 0xd0, 0x0c, 0xb6, - 0x45, 0xfd, 0x85, 0x2e, 0xa8, 0x53, 0xbe, 0x3e, 0x01, 0xa7, 0x48, 0x7a, 0x02, 0xae, 0x32, 0x9a, - 0x7c, 0x43, 0x9e, 0x51, 0x1f, 0xca, 0xa4, 0xae, 0x62, 0x9e, 0xe2, 0xa4, 0xae, 0xe2, 0x5e, 0xd6, - 0x68, 0xbe, 0x57, 0x15, 0xf9, 0x55, 0x48, 0xef, 0xee, 0xd0, 0xa7, 0xb1, 0xdc, 0xc6, 0xf0, 0xf7, - 0x24, 0x25, 0x8b, 0x0c, 0x5f, 0x72, 0xd4, 0x24, 0x66, 0xe0, 0xdd, 0x47, 0x0d, 0xa3, 0x31, 0x8f, - 0x3f, 0x4f, 0x68, 0xbd, 0xfc, 0xd9, 0xe1, 0x4e, 0x99, 0xff, 0x61, 0x0e, 0xd7, 0x1b, 0x28, 0x5c, - 0x29, 0xbf, 0x45, 0x18, 0x6a, 0x8f, 0x4d, 0xd1, 0x10, 0x6b, 0x05, 0x54, 0xa1, 0xb5, 0x17, 0x0d, - 0x1a, 0x53, 0xbb, 0x8a, 0x21, 0x98, 0x8b, 0x27, 0x48, 0xeb, 0x78, 0xd4, 0xe9, 0x13, 0x3b, 0xd0, - 0xd9, 0x4c, 0xe0, 0x61, 0x58, 0xec, 0x60, 0x5a, 0x8d, 0x27, 0x23, 0xb8, 0xbb, 0xce, 0x40, 0x98, - 0xc6, 0x2a, 0xc5, 0x27, 0x47, 0xaf, 0xa5, 0x31, 0x0d, 0x51, 0x6a, 0x4c, 0x83, 0xde, 0x4e, 0x63, - 0x11, 0x82, 0xba, 0xc6, 0x74, 0x36, 0x13, 0x78, 0xb8, 0x5e, 0x63, 0xf1, 0x64, 0x6e, 0xaa, 0xb1, - 0x2f, 0x69, 0xa4, 0xd8, 0xa7, 0xbf, 0xc1, 0x78, 0x2b, 0x9d, 0x65, 0x45, 0xde, 0xa3, 0xa3, 0xd6, - 0xb6, 0xd1, 0x73, 0xda, 0x47, 0x1c, 0x81, 0xdf, 0x4c, 0x6f, 0xeb, 0x49, 0x44, 0xa9, 0xe6, 0x0e, - 0x61, 0x99, 0x69, 0x2e, 0xca, 0x6e, 0x22, 0x2f, 0x89, 0x62, 0xef, 0x8b, 0xb0, 0x1b, 0x25, 0x75, - 0x5b, 0xfd, 0xed, 0x50, 0x13, 0xa9, 0x7a, 0x24, 0xab, 0x69, 0x0c, 0xa6, 0x3c, 0x3a, 0x11, 0x51, - 0x2d, 0xd3, 0xa7, 0xd7, 0x0a, 0xe8, 0x90, 0xee, 0x82, 0x0e, 0x1e, 0x96, 0x13, 0xc6, 0x93, 0xa1, - 0x4a, 0x3a, 0x10, 0xf1, 0x39, 0xc2, 0x53, 0xd2, 0xda, 0xc9, 0x4c, 0xc9, 0x84, 0xf9, 0x86, 0xd2, - 0x25, 0xa9, 0x88, 0xc5, 0x19, 0x96, 0x9f, 0x5e, 0xa7, 0x99, 0xe8, 0x9f, 0xcc, 0x42, 0xff, 0x1f, - 0xd2, 0x02, 0xf9, 0x7a, 0x85, 0x44, 0xb1, 0xf9, 0x4b, 0xc3, 0x34, 0x57, 0x08, 0xe5, 0x20, 0x69, - 0xa5, 0x44, 0xf6, 0x3f, 0x83, 0x69, 0xae, 0x86, 0xa1, 0x12, 0x24, 0xa7, 0x8b, 0xcb, 0xfb, 0x38, - 0x18, 0xfc, 0xa3, 0x2b, 0xd7, 0x0a, 0x13, 0xf7, 0x37, 0x5e, 0x08, 0xb5, 0x4a, 0x2c, 0xb5, 0x61, - 0x58, 0x89, 0xbc, 0xd5, 0x68, 0xd7, 0x76, 0xd2, 0x9f, 0xdb, 0x49, 0x62, 0xf0, 0xda, 0x3f, 0xf6, - 0x43, 0xe8, 0x56, 0x92, 0xe9, 0x5e, 0x8b, 0x9f, 0xc8, 0xef, 0x53, 0x58, 0xa7, 0x85, 0xca, 0xdb, - 0x72, 0x9c, 0x9c, 0x7c, 0xdf, 0x09, 0xdf, 0x61, 0xa3, 0x7f, 0xe9, 0x27, 0x89, 0xd8, 0x75, 0x7f, - 0x64, 0x88, 0x50, 0xad, 0x24, 0x52, 0xbd, 0x0e, 0x7b, 0x48, 0x68, 0x5b, 0xa3, 0xb2, 0xdf, 0x92, - 0xdb, 0xe1, 0x7e, 0x2b, 0xf2, 0xa7, 0x87, 0x92, 0xb3, 0xc0, 0xf8, 0x3f, 0x6e, 0x44, 0xa8, 0x54, - 0x06, 0xa8, 0x24, 0xcd, 0x1e, 0x16, 0xca, 0xa8, 0x68, 0x37, 0xe4, 0x26, 0xb9, 0x26, 0x9c, 0x96, - 0xed, 0x05, 0x48, 0x49, 0x5c, 0xb5, 0x07, 0xf6, 0xdc, 0xac, 0xfa, 0x18, 0xea, 0xa3, 0x22, 0xcb, - 0x18, 0xd4, 0xa7, 0x78, 0xa5, 0x92, 0x15, 0xfb, 0x46, 0x1f, 0x21, 0x51, 0xca, 0x7c, 0xfb, 0x9f, - 0x1b, 0xc6, 0xb7, 0xbf, 0xdb, 0x30, 0xfe, 0xf5, 0x77, 0x1b, 0xc6, 0x6f, 0x7f, 0xb7, 0x61, 0x9c, - 0x4d, 0xd0, 0xf1, 0xed, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x6f, 0x5a, 0x28, 0x3a, 0xa3, 0x52, - 0x00, 0x00, + // 5849 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x3c, 0x4d, 0x73, 0x1b, 0x57, + 0x72, 0x1c, 0xf0, 0x13, 0xcd, 0x2f, 0xf0, 0xf1, 0x0b, 0x02, 0x29, 0x42, 0x1e, 0xed, 0x6a, 0x65, + 0xaf, 0x97, 0xf4, 0x82, 0x76, 0xec, 0xb5, 0x2d, 0x29, 0x00, 0xf8, 0x69, 0x51, 0x12, 0x3d, 0x20, + 0xa1, 0xdd, 0x8d, 0xab, 0x98, 0x21, 0xf0, 0x44, 0x4e, 0x11, 0xc4, 0xc0, 0x33, 0x03, 0xca, 0xca, + 0x29, 0x49, 0x6d, 0x36, 0xa9, 0xa4, 0x52, 0x95, 0x4b, 0x0e, 0x39, 0x25, 0x55, 0xb9, 0xe5, 0xb0, + 0xa7, 0x5c, 0xf7, 0xee, 0x4a, 0x55, 0x6a, 0x73, 0x4b, 0x55, 0x0e, 0x88, 0xe3, 0x23, 0x7e, 0x42, + 0x4e, 0xa9, 0xf7, 0x39, 0xef, 0x0d, 0x66, 0x00, 0x52, 0x52, 0x92, 0x0b, 0x89, 0xe9, 0xf7, 0xba, + 0x5f, 0x77, 0xbf, 0x7e, 0xdd, 0xfd, 0x7a, 0x1a, 0x80, 0x39, 0xbb, 0x1d, 0x9c, 0xfb, 0xd8, 0xbb, + 0x72, 0x6a, 0x78, 0xbd, 0xe5, 0xb9, 0x81, 0x8b, 0x46, 0xe9, 0xbf, 0xdc, 0xc2, 0x99, 0x7b, 0xe6, + 0xd2, 0x8f, 0x1b, 0xe4, 0x13, 0x1b, 0xcc, 0xad, 0x9c, 0xb9, 0xee, 0x59, 0x03, 0x6f, 0xd0, 0xa7, + 0xd3, 0xf6, 0x8b, 0x0d, 0x7c, 0xd9, 0x0a, 0x5e, 0xf1, 0xc1, 0x7c, 0x74, 0x30, 0x70, 0x2e, 0xb1, + 0x1f, 0xd8, 0x97, 0x2d, 0x3e, 0xe1, 0xe3, 0x33, 0x27, 0x38, 0x6f, 0x9f, 0xae, 0xd7, 0xdc, 0xcb, + 0x8d, 0x33, 0xcf, 0xbe, 0x72, 0x02, 0x3b, 0x70, 0xdc, 0xa6, 0xdd, 0xd8, 0x08, 0x70, 0x03, 0xb7, + 0x5c, 0x2f, 0xd8, 0xb0, 0x5b, 0xce, 0x46, 0xf0, 0xaa, 0x85, 0x7d, 0xf6, 0x97, 0x23, 0x96, 0x6f, + 0x82, 0xf8, 0xd2, 0xb3, 0x5b, 0x2d, 0xec, 0x85, 0x1f, 0x38, 0x91, 0x47, 0x37, 0x21, 0x82, 0xaf, + 0x70, 0x33, 0x10, 0xff, 0x18, 0x01, 0xf3, 0xbb, 0x0c, 0x8c, 0x6e, 0x13, 0x00, 0xfa, 0x04, 0x46, + 0x8e, 0x5e, 0xb5, 0x70, 0xd6, 0xb8, 0x63, 0xdc, 0x9f, 0x29, 0x64, 0xd8, 0xf8, 0xfa, 0xb3, 0x16, + 0xf6, 0x28, 0xc9, 0x12, 0xea, 0x76, 0xf2, 0x33, 0x84, 0xd0, 0xfb, 0xee, 0xa5, 0x13, 0x50, 0x1d, + 0x59, 0x14, 0x03, 0x3d, 0x87, 0x19, 0x0b, 0xfb, 0x6e, 0xdb, 0xab, 0xe1, 0x3d, 0x6c, 0xd7, 0xb1, + 0x97, 0x4d, 0xdd, 0x31, 0xee, 0x4f, 0x16, 0x16, 0xd7, 0x99, 0xbc, 0xfa, 0x60, 0x69, 0xa9, 0xdb, + 0xc9, 0x23, 0x8f, 0xc3, 0x42, 0x62, 0x7b, 0x43, 0x56, 0x84, 0x0c, 0xfa, 0x0a, 0xa6, 0xcb, 0xd8, + 0x0b, 0x8a, 0xed, 0xe0, 0xdc, 0xf5, 0x9c, 0xe0, 0x55, 0x76, 0x98, 0xd2, 0x5d, 0xe2, 0x74, 0xb5, + 0xb1, 0x6a, 0xa1, 0xb4, 0xda, 0xed, 0xe4, 0xb3, 0x35, 0xec, 0x05, 0x27, 0xb6, 0x80, 0x6a, 0xe4, + 0x75, 0x62, 0xe8, 0xe7, 0x30, 0x55, 0x21, 0xea, 0xaa, 0x1d, 0xb9, 0x17, 0xb8, 0xe9, 0x67, 0x47, + 0x34, 0xa6, 0xd5, 0xa1, 0x6a, 0xa1, 0xb4, 0xd2, 0xed, 0xe4, 0x97, 0x7d, 0x0a, 0x3b, 0x09, 0x28, + 0x50, 0x23, 0xad, 0x51, 0x42, 0x7f, 0x08, 0x33, 0x87, 0x9e, 0x7b, 0xe5, 0xf8, 0x8e, 0xdb, 0xa4, + 0xa0, 0xec, 0x28, 0xa5, 0xbd, 0xcc, 0x69, 0xeb, 0x83, 0xd5, 0x42, 0xe9, 0x76, 0xb7, 0x93, 0xbf, + 0xd5, 0x12, 0x50, 0xb6, 0x80, 0xae, 0x19, 0x1d, 0x05, 0x1d, 0xc1, 0x64, 0xb9, 0xd1, 0xf6, 0x03, + 0xec, 0x3d, 0xb5, 0x2f, 0x71, 0x76, 0x8c, 0x92, 0x5f, 0x10, 0x7a, 0x09, 0x47, 0xaa, 0x85, 0x52, + 0xae, 0xdb, 0xc9, 0x2f, 0xd5, 0x18, 0xe8, 0xa4, 0x69, 0x5f, 0xea, 0x2a, 0x57, 0xc9, 0x50, 0x7d, + 0xb3, 0xc7, 0xb2, 0xdb, 0x7c, 0xe1, 0x9c, 0x65, 0xc7, 0x75, 0x7d, 0xab, 0x63, 0xd5, 0x4d, 0xae, + 0x6f, 0x4e, 0xb9, 0x46, 0xa1, 0x11, 0x7d, 0xab, 0x08, 0xe8, 0x63, 0x18, 0x39, 0xf6, 0xb1, 0x97, + 0x9d, 0xa0, 0x44, 0xa7, 0x39, 0x51, 0x02, 0xaa, 0x16, 0x98, 0x75, 0xb5, 0x7d, 0xec, 0x69, 0x14, + 0x28, 0x02, 0x41, 0xb4, 0xdc, 0x06, 0xce, 0xa6, 0x35, 0x44, 0x02, 0xaa, 0x7e, 0xc8, 0x10, 0x3d, + 0xb7, 0xa1, 0x8b, 0x45, 0x11, 0xd0, 0x3e, 0xa4, 0x89, 0x5c, 0x7e, 0xcb, 0xae, 0xe1, 0x2c, 0x50, + 0xec, 0x0c, 0xc7, 0x96, 0xf0, 0xd2, 0x72, 0xb7, 0x93, 0x9f, 0x6f, 0x8a, 0x47, 0x8d, 0x4a, 0x88, + 0x8d, 0x1e, 0xc1, 0x58, 0x05, 0x7b, 0x57, 0xd8, 0xcb, 0x4e, 0x52, 0x3a, 0xb3, 0xc2, 0x4c, 0x28, + 0xb0, 0x5a, 0x28, 0x2d, 0x74, 0x3b, 0xf9, 0x8c, 0x4f, 0x9f, 0x34, 0x1a, 0x1c, 0x8d, 0xe8, 0xd6, + 0xc2, 0x57, 0xd8, 0xf3, 0xf1, 0x51, 0xbb, 0xd9, 0xc4, 0x8d, 0xec, 0x94, 0xa6, 0x5b, 0x6d, 0x4c, + 0xd8, 0xb2, 0xc7, 0x80, 0x27, 0x01, 0x85, 0xea, 0xba, 0xd5, 0x10, 0xd0, 0x39, 0x64, 0xd8, 0xa7, + 0xb2, 0xdb, 0x6c, 0xe2, 0x1a, 0x39, 0xb0, 0xd9, 0x69, 0xba, 0xc0, 0x2d, 0xbe, 0x40, 0x74, 0xb8, + 0x5a, 0x28, 0xe5, 0xbb, 0x9d, 0xfc, 0x0a, 0xa3, 0x4d, 0xb6, 0x8f, 0x0f, 0x68, 0xcb, 0xf4, 0x50, + 0x25, 0x72, 0x14, 0x6b, 0x35, 0xec, 0xfb, 0x16, 0xfe, 0xba, 0x8d, 0xfd, 0x20, 0x3b, 0xa3, 0xc9, + 0xa1, 0x8d, 0x09, 0x1b, 0xb1, 0x29, 0xf0, 0xc4, 0x63, 0x50, 0x5d, 0x0e, 0x0d, 0x01, 0x1d, 0x02, + 0x14, 0x5b, 0xad, 0x0a, 0xf6, 0x89, 0xa9, 0x67, 0x67, 0x29, 0xe9, 0x79, 0x4e, 0xfa, 0x39, 0x3e, + 0xe5, 0x03, 0xd5, 0x42, 0xe9, 0x56, 0xb7, 0x93, 0x5f, 0xb4, 0x5b, 0xad, 0x13, 0x9f, 0x81, 0x34, + 0xa2, 0x0a, 0x0d, 0xa6, 0xf7, 0x4b, 0x37, 0xc0, 0xdc, 0x18, 0xb3, 0x99, 0x88, 0xde, 0x95, 0x31, + 0xc1, 0xaf, 0x47, 0x81, 0x27, 0xdc, 0xb4, 0xa3, 0x7a, 0x57, 0x10, 0xc8, 0x49, 0xdf, 0xb2, 0x03, + 0xfb, 0xd4, 0xf6, 0x31, 0x37, 0x8f, 0x39, 0xed, 0xa4, 0xeb, 0x83, 0xd5, 0x4d, 0x76, 0xd2, 0xeb, + 0x1c, 0x7a, 0x12, 0x63, 0x2f, 0x11, 0x7a, 0x44, 0x23, 0xa1, 0xe0, 0x59, 0x34, 0x40, 0x23, 0x2f, + 0xf1, 0x69, 0xbc, 0x46, 0xc2, 0xa9, 0x68, 0x0f, 0x26, 0x9e, 0xe3, 0x53, 0xe6, 0x97, 0xe6, 0x29, + 0xbd, 0xb9, 0x90, 0x1e, 0xf3, 0x48, 0x9b, 0xec, 0x54, 0x10, 0x6a, 0xbd, 0xbe, 0x48, 0x62, 0xa3, + 0x3f, 0x33, 0x60, 0x59, 0xf8, 0x0f, 0x1c, 0xbc, 0x74, 0xbd, 0x0b, 0xa7, 0x79, 0xc6, 0x5d, 0xc7, + 0x02, 0xa5, 0x7c, 0x27, 0xe2, 0x92, 0x22, 0xb3, 0xaa, 0x85, 0xd2, 0x8f, 0xba, 0x9d, 0xfc, 0x5d, + 0xe9, 0x9e, 0xe4, 0x78, 0x9c, 0x3f, 0x49, 0x5a, 0x0b, 0xfd, 0x89, 0x01, 0x4b, 0x5c, 0x3a, 0x0b, + 0xd7, 0x5c, 0xaf, 0x1e, 0xb2, 0xb1, 0x48, 0xd9, 0xc8, 0xcb, 0xd3, 0x1a, 0x37, 0xa9, 0x5a, 0x28, + 0xdd, 0xeb, 0x76, 0xf2, 0x26, 0x57, 0xdc, 0x89, 0x27, 0x86, 0xe3, 0x98, 0x48, 0x58, 0x88, 0x58, + 0x02, 0x09, 0x2d, 0x87, 0x1e, 0x7e, 0x81, 0x3d, 0xdc, 0xac, 0xe1, 0xec, 0x92, 0x66, 0x09, 0xfa, + 0xa0, 0xf0, 0xf9, 0x24, 0x50, 0x9d, 0xb4, 0x24, 0x58, 0xb7, 0x04, 0x1d, 0x05, 0x7d, 0x0d, 0x88, + 0x2b, 0xa0, 0xd8, 0xae, 0x3b, 0x01, 0x17, 0x70, 0x99, 0xae, 0xb2, 0xa2, 0xeb, 0x59, 0x99, 0x50, + 0x2d, 0x94, 0xcc, 0x6e, 0x27, 0xbf, 0x26, 0x54, 0x6c, 0x93, 0xa1, 0x38, 0xc1, 0x62, 0x88, 0x13, + 0xcf, 0x7b, 0xe0, 0xd6, 0x2e, 0xb2, 0x59, 0xcd, 0xf3, 0x12, 0x90, 0x70, 0xd9, 0x0d, 0xb7, 0x76, + 0xa1, 0x7b, 0x5e, 0x32, 0x5a, 0x02, 0x98, 0x10, 0xb1, 0xdc, 0xdc, 0x83, 0xd1, 0xe7, 0x76, 0x50, + 0x3b, 0x47, 0x8f, 0x60, 0xf4, 0xb1, 0xd3, 0xac, 0xfb, 0x59, 0xe3, 0xce, 0x30, 0x75, 0xc5, 0x2c, + 0xc5, 0xa0, 0x83, 0x64, 0xa0, 0xb4, 0xfc, 0x6d, 0x27, 0x3f, 0xd4, 0xed, 0xe4, 0x67, 0x2f, 0xc8, + 0x34, 0x25, 0xcf, 0x60, 0x78, 0xe6, 0x3f, 0xa7, 0x20, 0x2d, 0x67, 0xa3, 0x55, 0x18, 0x21, 0xff, + 0x69, 0xc2, 0x92, 0x2e, 0x4d, 0x74, 0x3b, 0xf9, 0x11, 0x82, 0x67, 0x51, 0x28, 0x2a, 0xc0, 0xe4, + 0x81, 0x6b, 0xd7, 0x2b, 0xb8, 0xe6, 0xe1, 0xc0, 0xa7, 0x19, 0xc9, 0x44, 0x29, 0xd3, 0xed, 0xe4, + 0xa7, 0x1a, 0xae, 0x5d, 0x3f, 0xf1, 0x19, 0xdc, 0x52, 0x27, 0x11, 0x8a, 0x34, 0x9c, 0x0e, 0x87, + 0x14, 0x49, 0x60, 0xb0, 0x28, 0x14, 0x7d, 0x01, 0x63, 0x3b, 0x4e, 0x83, 0xb8, 0x90, 0x11, 0xca, + 0xff, 0x6a, 0x94, 0xff, 0x75, 0x36, 0xbc, 0xdd, 0x0c, 0xbc, 0x57, 0x2c, 0x1e, 0xbc, 0xa0, 0x00, + 0x45, 0x10, 0x4e, 0x01, 0x7d, 0x00, 0xe3, 0x95, 0xf6, 0x29, 0x65, 0x7f, 0x94, 0x2e, 0x46, 0x93, + 0x22, 0xbf, 0x7d, 0x7a, 0x42, 0x44, 0x50, 0x10, 0xc4, 0xb4, 0xdc, 0xcf, 0x60, 0x52, 0x21, 0x8f, + 0x32, 0x30, 0x7c, 0x81, 0x5f, 0x31, 0xd9, 0x2d, 0xf2, 0x11, 0x2d, 0xc0, 0xe8, 0x95, 0xdd, 0x68, + 0x63, 0x2a, 0x6a, 0xda, 0x62, 0x0f, 0x9f, 0xa6, 0x3e, 0x31, 0xcc, 0x2f, 0x61, 0x94, 0x64, 0x3e, + 0x3e, 0xba, 0x0b, 0xc3, 0x95, 0xca, 0x1e, 0x45, 0x9a, 0x2a, 0xcd, 0x75, 0x3b, 0xf9, 0x69, 0xdf, + 0x3f, 0x57, 0x16, 0x23, 0xa3, 0x64, 0xd2, 0xd1, 0x41, 0x85, 0x52, 0xe1, 0x93, 0x82, 0x86, 0xba, + 0x17, 0x64, 0xd4, 0xfc, 0xdd, 0x18, 0x64, 0x48, 0x6c, 0xa6, 0x74, 0x85, 0xf3, 0x7e, 0x1f, 0xd2, + 0x87, 0xed, 0xd3, 0x86, 0x53, 0x7b, 0xcc, 0x39, 0x9b, 0x2a, 0xcd, 0x74, 0x3b, 0x79, 0x68, 0x51, + 0xe0, 0xc9, 0x05, 0x7e, 0x65, 0x85, 0x13, 0xd0, 0x7d, 0x98, 0x20, 0x14, 0x88, 0x82, 0x19, 0xcb, + 0xa5, 0xa9, 0x6e, 0x27, 0x3f, 0xd1, 0xe6, 0x30, 0x4b, 0x8e, 0xa2, 0x0a, 0x8c, 0x6f, 0x7f, 0xd3, + 0x72, 0x3c, 0xec, 0xf3, 0x04, 0x30, 0xb7, 0xce, 0xb2, 0xf2, 0x75, 0x91, 0x95, 0xaf, 0x1f, 0x89, + 0xac, 0xbc, 0x74, 0x9b, 0xdb, 0xd0, 0x1c, 0x66, 0x28, 0x21, 0xe7, 0x7f, 0xf3, 0x9f, 0x79, 0xc3, + 0x12, 0x94, 0xd0, 0xfb, 0x30, 0xb6, 0xe3, 0x7a, 0x97, 0x76, 0x40, 0xf3, 0xbe, 0x34, 0xdf, 0x2f, + 0x0a, 0xd1, 0xf6, 0x8b, 0x42, 0xd0, 0x0e, 0xcc, 0x58, 0x6e, 0x3b, 0xc0, 0x47, 0xae, 0x08, 0x23, + 0x6c, 0xdb, 0xd6, 0xba, 0x9d, 0x7c, 0xce, 0x23, 0x23, 0x27, 0x81, 0xdb, 0x1b, 0x30, 0xac, 0x08, + 0x16, 0xda, 0x86, 0x19, 0x2d, 0xe0, 0xf9, 0xd9, 0xb1, 0x3b, 0xc3, 0xf7, 0xd3, 0xdc, 0x19, 0x68, + 0x61, 0x52, 0xd5, 0x79, 0x04, 0x09, 0x3d, 0x85, 0xb9, 0xc7, 0xed, 0x53, 0xec, 0x35, 0x71, 0x80, + 0x7d, 0xc1, 0xd1, 0x38, 0xe5, 0xe8, 0x4e, 0xb7, 0x93, 0x5f, 0xbd, 0x90, 0x83, 0x31, 0x3c, 0xf5, + 0xa2, 0x22, 0x0c, 0xb3, 0x9c, 0x51, 0x11, 0x7d, 0x78, 0x96, 0xb6, 0xc4, 0x6d, 0x3c, 0x32, 0x5a, + 0xba, 0xcb, 0xb5, 0xbc, 0x22, 0x65, 0x17, 0x31, 0x4d, 0x59, 0x28, 0x4a, 0x13, 0x6d, 0xc2, 0xc4, + 0x53, 0xb7, 0x8e, 0xe9, 0x19, 0x4b, 0x53, 0x6e, 0x59, 0xf2, 0xe5, 0xd6, 0x71, 0x24, 0x33, 0xb5, + 0xe4, 0x44, 0x74, 0x00, 0xa3, 0xc7, 0xbe, 0x7d, 0xc6, 0x12, 0xb8, 0x99, 0xc2, 0x3b, 0x9c, 0xa3, + 0xa8, 0xf5, 0xd1, 0xdb, 0x00, 0x9d, 0x58, 0x9a, 0x27, 0x2e, 0xa4, 0x4d, 0x3e, 0xaa, 0x2e, 0x84, + 0x8e, 0xa1, 0x2f, 0x01, 0x38, 0x57, 0xc5, 0x56, 0x8b, 0xe7, 0x72, 0x73, 0xba, 0x90, 0xc5, 0x56, + 0xab, 0xb4, 0xc6, 0xe5, 0x5b, 0x92, 0xf2, 0xd9, 0xad, 0x96, 0x42, 0x4d, 0x21, 0x62, 0x6e, 0x41, + 0x5a, 0xae, 0x8d, 0xc6, 0x61, 0xb8, 0xd8, 0x68, 0x64, 0x86, 0xc8, 0x87, 0x4a, 0x65, 0x2f, 0x63, + 0xa0, 0x19, 0x80, 0x50, 0xe1, 0x99, 0x14, 0x9a, 0x82, 0x09, 0xa1, 0x90, 0xcc, 0x30, 0x9d, 0xdf, + 0x6a, 0x65, 0x46, 0xcc, 0x7f, 0x37, 0x7a, 0xf6, 0x80, 0xf8, 0xb0, 0x0a, 0xbb, 0xc7, 0x52, 0x95, + 0x31, 0x47, 0x47, 0x7d, 0x18, 0xbf, 0xde, 0x52, 0xad, 0x59, 0xea, 0x24, 0x72, 0xac, 0x0e, 0x89, + 0x34, 0x35, 0xb7, 0xa1, 0x1e, 0xab, 0x16, 0x87, 0x59, 0x72, 0x14, 0x15, 0x94, 0x03, 0x38, 0x1c, + 0x3a, 0x21, 0x71, 0x00, 0xd5, 0xcd, 0x90, 0x47, 0xb1, 0x10, 0x32, 0xcf, 0xcf, 0x0d, 0xc5, 0x89, + 0xd9, 0x7c, 0x39, 0xcf, 0xfc, 0xad, 0xa1, 0xea, 0x5c, 0x3a, 0x59, 0x23, 0xd6, 0xc9, 0xbe, 0x0f, + 0x69, 0x1e, 0x60, 0xf7, 0xb7, 0x38, 0xff, 0xd4, 0x87, 0x88, 0xd8, 0xec, 0xd4, 0xad, 0x70, 0x02, + 0xda, 0x00, 0x60, 0x0e, 0xa5, 0x58, 0xaf, 0x7b, 0x5c, 0x88, 0xd9, 0x6e, 0x27, 0x3f, 0xc9, 0x5d, + 0x8e, 0x5d, 0xaf, 0x7b, 0x96, 0x32, 0x85, 0x68, 0x54, 0xbd, 0x37, 0x8d, 0x84, 0x1a, 0x55, 0x6f, + 0x48, 0xda, 0xad, 0xc8, 0x6c, 0xc0, 0xcc, 0x2e, 0x0e, 0x88, 0x0a, 0x84, 0xa3, 0xeb, 0x2f, 0xc2, + 0xe7, 0x30, 0xf9, 0xdc, 0x09, 0xce, 0xf5, 0xc8, 0x43, 0x6f, 0x61, 0x2f, 0x9d, 0xe0, 0x5c, 0x44, + 0x1e, 0x45, 0x55, 0xea, 0x74, 0x73, 0x1b, 0x66, 0xf9, 0x6a, 0xd2, 0xaf, 0x16, 0x74, 0x82, 0x46, + 0x18, 0xca, 0x54, 0x82, 0x3a, 0x19, 0x1c, 0x75, 0x34, 0xa8, 0xd2, 0xe3, 0x7a, 0x58, 0x18, 0x4e, + 0xca, 0xdc, 0xe9, 0x29, 0x8a, 0xb8, 0xa4, 0xa8, 0x23, 0x32, 0x8f, 0x61, 0xfa, 0xb0, 0xd1, 0x3e, + 0x73, 0x9a, 0x64, 0xb7, 0x2b, 0xf8, 0x6b, 0xb4, 0x05, 0x10, 0x02, 0xf8, 0x0a, 0x22, 0x5d, 0x0d, + 0x07, 0xaa, 0x9b, 0x7c, 0x9b, 0x28, 0x84, 0xfa, 0x0e, 0x4b, 0xc1, 0x33, 0xff, 0x72, 0x18, 0x10, + 0x5f, 0x83, 0x5c, 0xac, 0x71, 0x05, 0x07, 0xc4, 0x4d, 0x2d, 0x41, 0x6a, 0x7f, 0x8b, 0x6b, 0x7d, + 0xac, 0xdb, 0xc9, 0xa7, 0x9c, 0xba, 0x95, 0xda, 0xdf, 0x42, 0x1f, 0xc2, 0x28, 0x9d, 0x46, 0x75, + 0x3d, 0x23, 0xd7, 0x53, 0x29, 0x94, 0xd2, 0xdd, 0x4e, 0x7e, 0x94, 0x5c, 0xe0, 0xb1, 0xc5, 0x26, + 0xa3, 0x8f, 0x20, 0xbd, 0x85, 0x1b, 0xf8, 0xcc, 0x0e, 0x5c, 0x61, 0x3b, 0xd4, 0x1d, 0xd5, 0x05, + 0x50, 0xd9, 0xa2, 0x70, 0x26, 0x09, 0x1c, 0x16, 0xb6, 0x7d, 0xb7, 0xa9, 0x06, 0x0e, 0x8f, 0x42, + 0xd4, 0xc0, 0xc1, 0xe6, 0xa0, 0xbf, 0x35, 0x60, 0xb2, 0xd8, 0x6c, 0xba, 0xac, 0x2e, 0xe3, 0xf3, + 0x42, 0xc0, 0xe2, 0xba, 0xac, 0xe3, 0x1c, 0xd8, 0xa7, 0xb8, 0x51, 0x25, 0xb1, 0xda, 0x2f, 0x7d, + 0x45, 0xbc, 0xce, 0x7f, 0x74, 0xf2, 0x9f, 0xbd, 0x4e, 0x69, 0x68, 0xfd, 0xc8, 0xb3, 0x9d, 0xc0, + 0xa7, 0xf7, 0xa2, 0x70, 0x41, 0xd5, 0xcc, 0x14, 0x3e, 0xd0, 0xbb, 0x30, 0x4a, 0xae, 0xc8, 0x22, + 0xfe, 0xd0, 0xcd, 0x26, 0xb7, 0x68, 0x2d, 0xeb, 0xa2, 0x33, 0xcc, 0xbb, 0x90, 0xe6, 0x9a, 0xdc, + 0xdf, 0x4a, 0xda, 0x02, 0xf3, 0x09, 0xdc, 0xb3, 0x5c, 0xaa, 0x5d, 0xec, 0xe3, 0xe0, 0xd0, 0xf6, + 0xfd, 0x97, 0xae, 0x57, 0xa7, 0xd7, 0x04, 0x6e, 0x92, 0xc2, 0x9a, 0xef, 0xc2, 0x38, 0x05, 0x4b, + 0x32, 0x74, 0x67, 0xe8, 0x35, 0xc3, 0x12, 0x23, 0x66, 0x19, 0x56, 0x77, 0x71, 0xd0, 0x4b, 0xeb, + 0x46, 0x44, 0x7e, 0x65, 0x40, 0xbe, 0xec, 0xe1, 0x58, 0xa6, 0xae, 0x77, 0x94, 0x57, 0x79, 0x4d, + 0x2c, 0x15, 0x8e, 0x12, 0xa5, 0xf3, 0xba, 0xd7, 0x0f, 0x61, 0xf8, 0xe8, 0xe8, 0x80, 0x9a, 0xce, + 0x30, 0xd5, 0xe0, 0x70, 0x10, 0x34, 0xfe, 0xbb, 0x93, 0x9f, 0xd8, 0x6a, 0xb3, 0x9a, 0x99, 0x45, + 0xc6, 0xcd, 0x69, 0x98, 0x3c, 0x74, 0x9a, 0x67, 0x7c, 0x45, 0xf3, 0xaf, 0x52, 0x30, 0xc5, 0x9e, + 0xfd, 0x96, 0xdb, 0x64, 0x5e, 0x5e, 0xf5, 0x49, 0xc6, 0x35, 0x7c, 0x12, 0xfa, 0x04, 0xa6, 0xf9, + 0x95, 0x12, 0x7b, 0xf4, 0x62, 0xc8, 0x38, 0xa4, 0x29, 0x39, 0xbb, 0x54, 0x9e, 0x5c, 0xb1, 0x11, + 0x4b, 0x9f, 0x88, 0x0e, 0x60, 0x86, 0x01, 0x76, 0xb0, 0x1d, 0xb4, 0xc3, 0x9c, 0x6a, 0x96, 0x07, + 0x41, 0x01, 0x66, 0x26, 0xc1, 0x69, 0xbd, 0xe0, 0x40, 0x2b, 0x82, 0x8b, 0x1e, 0xc1, 0xec, 0xa1, + 0xe7, 0x7e, 0xf3, 0x4a, 0xf1, 0xc2, 0xec, 0x54, 0x2c, 0x92, 0x14, 0xac, 0x45, 0x86, 0x4e, 0x54, + 0x5f, 0x1c, 0x9d, 0x6d, 0x7e, 0x97, 0x82, 0x09, 0x49, 0x6d, 0x5d, 0x0d, 0x95, 0xdc, 0xcf, 0x51, + 0xef, 0x1f, 0xe6, 0x33, 0x96, 0x32, 0x03, 0xdd, 0xa2, 0xc1, 0x93, 0x7b, 0xd8, 0x71, 0xb2, 0x01, + 0x76, 0xab, 0x65, 0x11, 0x18, 0xb1, 0xd3, 0xad, 0x12, 0x15, 0x6d, 0x82, 0xd9, 0x69, 0xfd, 0xd4, + 0x4a, 0x6d, 0x95, 0xc8, 0x8e, 0x3e, 0xdb, 0xdf, 0x2a, 0x53, 0x2e, 0x27, 0xd8, 0x8e, 0xba, 0x4e, + 0xbd, 0x66, 0x51, 0x28, 0x19, 0xad, 0x14, 0x9f, 0x1c, 0xd0, 0x53, 0xca, 0x47, 0x7d, 0xfb, 0xb2, + 0x61, 0x51, 0x28, 0xfa, 0x4c, 0x78, 0xd0, 0xb2, 0xdb, 0x0c, 0x3c, 0xb7, 0xe1, 0xd3, 0xba, 0xdb, + 0x84, 0xe6, 0x29, 0x6b, 0x7c, 0xc8, 0x8a, 0x4c, 0x45, 0xcf, 0x61, 0xb9, 0x58, 0xbf, 0xb2, 0x9b, + 0x35, 0x5c, 0x67, 0x23, 0xcf, 0x5d, 0xef, 0xe2, 0x45, 0xc3, 0x7d, 0xe9, 0xd3, 0xc4, 0x6d, 0x82, + 0xa7, 0x80, 0x7c, 0xca, 0x09, 0x27, 0xf7, 0x52, 0x4c, 0xb2, 0x92, 0xb0, 0x51, 0x1e, 0x46, 0xcb, + 0x0d, 0xb7, 0x5d, 0xa7, 0x19, 0xdb, 0x04, 0x3b, 0x08, 0x35, 0x02, 0xb0, 0x18, 0xdc, 0xfc, 0x29, + 0xcc, 0x11, 0xef, 0x15, 0xe0, 0x6b, 0x87, 0x30, 0xf3, 0x10, 0xa0, 0x82, 0x2f, 0xed, 0xd6, 0xb9, + 0x4b, 0xb6, 0xa5, 0xa4, 0x3e, 0x71, 0x9f, 0x8e, 0xe4, 0x8d, 0x9a, 0x0f, 0x54, 0x37, 0x45, 0xa0, + 0x16, 0x33, 0x2d, 0x05, 0xcb, 0xfc, 0xd7, 0x14, 0x20, 0x7a, 0xb3, 0xac, 0x04, 0x1e, 0xb6, 0x2f, + 0x05, 0x1b, 0x3f, 0x83, 0x29, 0x76, 0x42, 0x19, 0x98, 0xb2, 0x43, 0x02, 0x06, 0xb3, 0x45, 0x75, + 0x68, 0x6f, 0xc8, 0xd2, 0xa6, 0x12, 0x54, 0x0b, 0xfb, 0xed, 0x4b, 0x81, 0x9a, 0xd2, 0x50, 0xd5, + 0x21, 0x82, 0xaa, 0x3e, 0xa3, 0x47, 0x30, 0x53, 0x76, 0x2f, 0x5b, 0x44, 0x27, 0x1c, 0x79, 0x98, + 0xbb, 0x65, 0xbe, 0xae, 0x36, 0x48, 0xae, 0xe2, 0x3a, 0x04, 0x3d, 0x85, 0xf9, 0x9d, 0x46, 0xdb, + 0x3f, 0x2f, 0x36, 0xeb, 0xe5, 0x86, 0xeb, 0x0b, 0x2a, 0x23, 0xfc, 0x76, 0xc2, 0x4f, 0x52, 0xef, + 0x8c, 0xbd, 0x21, 0x2b, 0x0e, 0x11, 0xfd, 0x90, 0x17, 0xe1, 0x79, 0x78, 0x98, 0x5e, 0xe7, 0x35, + 0xfa, 0x67, 0x4d, 0xfc, 0xec, 0xc5, 0xde, 0x90, 0xc5, 0x46, 0x4b, 0x69, 0x18, 0x17, 0x5e, 0x64, + 0x03, 0xe6, 0x14, 0x75, 0x92, 0x80, 0xd6, 0xf6, 0x51, 0x0e, 0x26, 0x8e, 0x5b, 0xe4, 0x7a, 0x2b, + 0xdc, 0xa2, 0x25, 0x9f, 0xcd, 0xf7, 0x75, 0x4d, 0xa3, 0x55, 0x35, 0xd1, 0x62, 0x93, 0x43, 0x80, + 0xb9, 0xa7, 0x2b, 0xb7, 0xff, 0x6c, 0x6d, 0xdd, 0x54, 0x64, 0xdd, 0x4c, 0x54, 0xd7, 0xe6, 0x62, + 0xac, 0xf2, 0xcc, 0x3f, 0x35, 0x60, 0x61, 0x17, 0x07, 0xb4, 0x74, 0x47, 0x7c, 0x8c, 0x0c, 0x18, + 0x3f, 0x56, 0xab, 0xb8, 0xcc, 0x5e, 0xa7, 0xbb, 0x9d, 0x7c, 0x5a, 0xd6, 0x6c, 0xd5, 0x3a, 0xed, + 0x03, 0x98, 0xa9, 0x5c, 0x38, 0xad, 0xaa, 0xdd, 0x70, 0xea, 0xd4, 0x07, 0x73, 0xef, 0xb0, 0x48, + 0xbd, 0xd9, 0x85, 0xd3, 0x3a, 0xb9, 0x0a, 0x87, 0x0c, 0x2b, 0x32, 0xd9, 0x7c, 0x06, 0x8b, 0x11, + 0x1e, 0xb8, 0x93, 0xfe, 0x3d, 0x18, 0xe7, 0x20, 0x7e, 0x00, 0x7a, 0x0a, 0xc0, 0x93, 0xdd, 0x4e, + 0x7e, 0xdc, 0xe7, 0x68, 0x62, 0xb2, 0xf9, 0x04, 0x96, 0x8e, 0x5b, 0x3e, 0xf6, 0x42, 0x9a, 0x42, + 0xac, 0x4d, 0x59, 0x51, 0x36, 0xe2, 0x2b, 0xca, 0xd0, 0xed, 0xe4, 0xc7, 0x18, 0x41, 0x51, 0x45, + 0x36, 0x6b, 0xb0, 0xc4, 0xce, 0x72, 0x0f, 0xb9, 0x1b, 0x69, 0x49, 0x9c, 0xfe, 0x54, 0xec, 0xe9, + 0xdf, 0x87, 0x1c, 0x5f, 0xa4, 0xd1, 0x78, 0xb3, 0xed, 0x30, 0xff, 0xc5, 0x80, 0xe5, 0x5d, 0xdc, + 0xc4, 0x9e, 0x4d, 0x59, 0xd6, 0x42, 0xaf, 0x5a, 0x00, 0x30, 0xfa, 0x16, 0x00, 0xf2, 0x22, 0x59, + 0x49, 0xd1, 0x64, 0x85, 0xba, 0x38, 0x9a, 0xac, 0xf0, 0x14, 0x85, 0x04, 0x82, 0x63, 0x6b, 0x9f, + 0x27, 0x71, 0x34, 0x10, 0xb4, 0x3d, 0xc7, 0x22, 0x30, 0xb4, 0x1f, 0x16, 0x0f, 0x46, 0x06, 0x16, + 0x0f, 0xe6, 0xf9, 0xb5, 0x6f, 0x9c, 0x17, 0x0f, 0xb4, 0x92, 0x81, 0xf9, 0x19, 0x64, 0x7b, 0x65, + 0xe1, 0xf6, 0x91, 0x87, 0x51, 0x56, 0x51, 0xed, 0x49, 0x47, 0x18, 0xdc, 0xdc, 0x0a, 0xad, 0x9b, + 0xd7, 0x0f, 0x65, 0xd1, 0x24, 0x72, 0xb2, 0xfa, 0x5c, 0x78, 0xcc, 0x4a, 0x68, 0x9f, 0x9c, 0x0a, + 0x5f, 0xff, 0x53, 0x62, 0x9f, 0xac, 0x46, 0x6c, 0x24, 0xd7, 0x88, 0xb9, 0x8d, 0x32, 0x54, 0x81, + 0x60, 0x3e, 0x87, 0x25, 0x8d, 0x68, 0x68, 0xf5, 0x0f, 0x60, 0x42, 0xc0, 0x22, 0xb9, 0xbc, 0x46, + 0x96, 0xee, 0x9b, 0x2f, 0x90, 0x25, 0x8a, 0xf9, 0x1b, 0x03, 0x96, 0x99, 0xd3, 0xe9, 0x95, 0xfb, + 0xfa, 0xbb, 0xff, 0x7f, 0x71, 0xc9, 0xfb, 0x62, 0x64, 0x22, 0x95, 0x19, 0x36, 0xab, 0x90, 0xed, + 0xe5, 0xf7, 0x2d, 0x68, 0x78, 0x17, 0x96, 0x95, 0x63, 0xfb, 0xc6, 0xfb, 0x1f, 0xae, 0xf8, 0x16, + 0xf7, 0x3f, 0x9c, 0xf8, 0xd6, 0xf6, 0x7f, 0x1f, 0xe6, 0x19, 0x61, 0xfd, 0xac, 0x14, 0xd4, 0xb3, + 0x12, 0xfb, 0xf6, 0xa1, 0xf7, 0xf8, 0x3c, 0xa1, 0xc7, 0x47, 0x4c, 0x09, 0x39, 0xfc, 0x08, 0xc6, + 0xf8, 0xeb, 0x5b, 0xc6, 0x5f, 0x0c, 0x31, 0xea, 0x47, 0xd9, 0x3b, 0x5b, 0x8b, 0x4f, 0x36, 0xb3, + 0x54, 0x64, 0x92, 0x4a, 0xf2, 0xda, 0x89, 0x70, 0x6f, 0xe6, 0x97, 0xc4, 0x61, 0x45, 0x46, 0xde, + 0x30, 0x06, 0x3c, 0x83, 0x2c, 0x8b, 0x01, 0x0a, 0xd5, 0x37, 0x8a, 0x02, 0x9f, 0x40, 0x96, 0x99, + 0x53, 0x0c, 0xc1, 0xfe, 0xae, 0x7d, 0x0d, 0x56, 0xa5, 0x6b, 0x8f, 0x93, 0xfe, 0xcf, 0x0d, 0xb8, + 0xb5, 0x8b, 0x03, 0xfd, 0x1d, 0xd4, 0xff, 0x4b, 0x24, 0xfe, 0x0a, 0x72, 0x71, 0x8c, 0xf0, 0xad, + 0x78, 0x18, 0xdd, 0x8a, 0xc4, 0x17, 0x6e, 0xf1, 0x5b, 0xf2, 0x4b, 0x58, 0x61, 0x5b, 0xa2, 0xcf, + 0x17, 0x82, 0x7e, 0x16, 0xd9, 0x95, 0x44, 0xea, 0x71, 0xbb, 0xf3, 0xd7, 0x06, 0xac, 0x30, 0x25, + 0xc7, 0x13, 0xbf, 0x91, 0x16, 0xef, 0xc2, 0xd8, 0x9e, 0x4b, 0x6e, 0xde, 0x7c, 0x43, 0xa9, 0x38, + 0xe7, 0xae, 0x1f, 0x10, 0xc7, 0xc0, 0x87, 0xfa, 0xbf, 0xb7, 0x30, 0x9f, 0x42, 0x5e, 0xee, 0xf9, + 0x5b, 0xd8, 0x58, 0xb3, 0x06, 0x48, 0x90, 0x29, 0x57, 0x2c, 0x41, 0xe2, 0x16, 0x0c, 0x97, 0x2b, + 0x16, 0x2f, 0xfb, 0xd3, 0x10, 0x5c, 0xf3, 0x3d, 0x8b, 0xc0, 0xa2, 0xfe, 0x38, 0x75, 0x9d, 0xa2, + 0xdb, 0x1f, 0xc0, 0xbc, 0xb6, 0x08, 0xdf, 0xf7, 0x55, 0x18, 0x29, 0x63, 0x2f, 0xe0, 0xcb, 0x50, + 0x49, 0x6b, 0xd8, 0x0b, 0x2c, 0x0a, 0x45, 0xf7, 0x60, 0xbc, 0x5c, 0xa4, 0x45, 0x61, 0x9a, 0x29, + 0x4c, 0x31, 0xc7, 0x54, 0xb3, 0x4f, 0x6a, 0xb4, 0x50, 0x2c, 0x06, 0xcd, 0xbf, 0x30, 0x14, 0xea, + 0x04, 0x7d, 0xb0, 0x0c, 0x1b, 0xe4, 0x0e, 0x44, 0x74, 0xa6, 0x88, 0x40, 0x83, 0x10, 0xbf, 0x21, + 0x53, 0x09, 0x94, 0x29, 0xd7, 0x2d, 0x0e, 0x7c, 0x05, 0x0b, 0x3a, 0x27, 0x6f, 0x55, 0xd0, 0x1f, + 0xd0, 0xd2, 0x25, 0xc9, 0x91, 0x84, 0x88, 0x48, 0xbd, 0xf7, 0x71, 0x03, 0xf9, 0x18, 0x32, 0x7c, + 0x56, 0x78, 0xc0, 0xee, 0x8a, 0x94, 0x8b, 0x1d, 0x2f, 0xbd, 0xe9, 0x42, 0x54, 0x86, 0x7e, 0x24, + 0x6e, 0x96, 0x83, 0x56, 0xb8, 0x80, 0xec, 0x93, 0x9d, 0x62, 0xb1, 0x1d, 0x9c, 0xe3, 0x66, 0xe0, + 0xd4, 0xec, 0x00, 0x97, 0xcf, 0xed, 0x46, 0x03, 0x37, 0xcf, 0xa8, 0xa2, 0x8e, 0x0b, 0x3b, 0x32, + 0xbc, 0xf0, 0xea, 0x7e, 0x61, 0x47, 0xce, 0xb0, 0xc8, 0x38, 0xba, 0x0f, 0x23, 0x47, 0xcf, 0x8e, + 0x0e, 0xf9, 0x35, 0x6f, 0x81, 0xcf, 0x23, 0xa0, 0x70, 0x22, 0x9d, 0x61, 0x7e, 0x03, 0xcb, 0x91, + 0xc5, 0xa4, 0x54, 0xf7, 0xc4, 0x5a, 0x06, 0xbd, 0xc2, 0xca, 0xb5, 0xc4, 0x84, 0xbd, 0x21, 0xb6, + 0xd8, 0xbb, 0xda, 0x62, 0xf3, 0xca, 0x62, 0xca, 0x4c, 0x3a, 0x85, 0xbf, 0xe9, 0xa4, 0x30, 0xf3, + 0x8f, 0x60, 0x4a, 0x65, 0x9c, 0xdc, 0x9a, 0x1e, 0xe3, 0x57, 0x7b, 0x76, 0xb3, 0xde, 0x10, 0xfa, + 0x08, 0x01, 0x64, 0x54, 0x4e, 0xe5, 0xd7, 0xa6, 0x10, 0x80, 0x16, 0x60, 0xb4, 0xd8, 0x6a, 0xed, + 0x6f, 0xb1, 0x43, 0x6d, 0xb1, 0x07, 0x94, 0x85, 0x71, 0x51, 0xf1, 0xa1, 0x69, 0x8d, 0x25, 0x1e, + 0x4d, 0x07, 0x26, 0x15, 0x41, 0x06, 0x2c, 0xbd, 0x06, 0x50, 0x6e, 0x38, 0xb8, 0x49, 0xdd, 0x1f, + 0x5f, 0x5b, 0x81, 0xd0, 0xeb, 0x9e, 0x73, 0xd6, 0xa4, 0x65, 0x19, 0xce, 0x40, 0x08, 0x30, 0x67, + 0x61, 0x5a, 0xd3, 0xbb, 0x69, 0xc2, 0x94, 0xaa, 0x1b, 0x62, 0x02, 0x65, 0xb7, 0x2e, 0x4d, 0x80, + 0x7c, 0x36, 0x7f, 0x6d, 0xc0, 0xc2, 0x93, 0x9d, 0xa2, 0x85, 0xcf, 0x1c, 0xda, 0x13, 0x24, 0x05, + 0xdd, 0x50, 0xf7, 0x64, 0x45, 0xdd, 0x93, 0xc8, 0x4c, 0xb1, 0x39, 0x05, 0x6d, 0x73, 0x56, 0xb5, + 0xcd, 0xe9, 0x45, 0x61, 0xbb, 0xa4, 0xdc, 0x9c, 0x7f, 0x65, 0xc0, 0xbc, 0xc2, 0x88, 0x64, 0x7a, + 0x5d, 0xe5, 0x23, 0xd7, 0xcb, 0x47, 0xd4, 0x46, 0x7e, 0xaa, 0xb1, 0xb1, 0x12, 0xc3, 0x46, 0x5f, + 0x5b, 0xa9, 0xc3, 0x42, 0x9c, 0x90, 0xba, 0x55, 0x18, 0x89, 0x56, 0x91, 0x4a, 0xb0, 0x8a, 0x61, + 0xdd, 0x2a, 0x6c, 0x98, 0x8f, 0x11, 0x01, 0xbd, 0x07, 0x19, 0x06, 0x63, 0xae, 0x88, 0xd7, 0xea, + 0x09, 0x66, 0x0f, 0x7c, 0x90, 0xad, 0x98, 0xbf, 0x35, 0x60, 0x31, 0x56, 0xf9, 0x68, 0x89, 0x44, + 0xd1, 0x9a, 0x87, 0x03, 0x4e, 0x9b, 0x3f, 0x11, 0xf8, 0xbe, 0xef, 0xb7, 0x79, 0x9f, 0x60, 0xda, + 0xe2, 0x4f, 0xe8, 0x07, 0x30, 0x7d, 0x88, 0x3d, 0xc7, 0xad, 0x57, 0x70, 0xcd, 0x6d, 0xd6, 0x59, + 0x65, 0x72, 0xda, 0xd2, 0x81, 0x44, 0x41, 0xc5, 0xc6, 0x99, 0xeb, 0x39, 0xc1, 0xf9, 0x25, 0x3f, + 0x04, 0x21, 0x80, 0xd0, 0xde, 0x72, 0xce, 0x9c, 0x80, 0x55, 0xda, 0xa7, 0x2d, 0xfe, 0x44, 0x54, + 0x54, 0xac, 0xd5, 0xdc, 0x76, 0x33, 0xa0, 0x45, 0xbb, 0xb4, 0x25, 0x1e, 0xcd, 0xf7, 0x60, 0x21, + 0x6e, 0xd3, 0x62, 0x8d, 0xf8, 0x8f, 0x53, 0x30, 0x5f, 0xac, 0xd7, 0x9f, 0xec, 0x14, 0xb7, 0xb0, + 0x9a, 0x74, 0x7d, 0x08, 0x23, 0xfb, 0x4d, 0x27, 0xe0, 0xc6, 0xb3, 0xc6, 0x6d, 0x21, 0x66, 0x26, + 0x99, 0x45, 0xcc, 0x81, 0xfc, 0x47, 0x16, 0xcc, 0x6f, 0x7f, 0xe3, 0xf8, 0x81, 0xd3, 0x3c, 0xa3, + 0x06, 0xc9, 0x16, 0xe6, 0x06, 0x25, 0x88, 0x24, 0xb8, 0xb2, 0xbd, 0x21, 0x2b, 0x0e, 0x19, 0x1d, + 0xc1, 0xd2, 0x53, 0xfc, 0x32, 0xc6, 0xbe, 0xe5, 0xab, 0x73, 0x49, 0x36, 0xc6, 0x4c, 0x13, 0x70, + 0xd5, 0xe3, 0xf3, 0xeb, 0x14, 0x2c, 0xe8, 0x82, 0xf1, 0x95, 0x8f, 0x61, 0x41, 0x61, 0x48, 0xb7, + 0xe1, 0xc9, 0x42, 0x3e, 0x5e, 0x1c, 0xf5, 0xa4, 0xc6, 0xa2, 0xa3, 0xe7, 0xb0, 0xac, 0x33, 0xa5, + 0xfb, 0xcc, 0xf0, 0xe4, 0xc5, 0x4d, 0xd9, 0x1b, 0xb2, 0x92, 0xb0, 0x51, 0x01, 0x86, 0x8b, 0xb5, + 0x0b, 0xae, 0x96, 0xf8, 0x2d, 0x63, 0x92, 0x15, 0x6b, 0x17, 0xe4, 0xcc, 0x17, 0x65, 0x5b, 0x0b, + 0x3b, 0xc0, 0x7f, 0x67, 0xc0, 0x72, 0xc2, 0x0e, 0x93, 0x33, 0xc3, 0x80, 0x4a, 0x24, 0x54, 0x20, + 0xe8, 0x81, 0xf2, 0x5e, 0x61, 0xa6, 0xf0, 0x6e, 0x7f, 0x7b, 0x59, 0x67, 0x90, 0x23, 0xf9, 0xe2, + 0xc1, 0xcc, 0x0b, 0xf2, 0xf4, 0x35, 0xc4, 0x04, 0x73, 0x44, 0xec, 0x9d, 0xf3, 0x71, 0x61, 0x27, + 0x63, 0x98, 0xe5, 0x28, 0x6b, 0x52, 0x12, 0x74, 0x1f, 0xc6, 0x18, 0x90, 0x6f, 0x8c, 0x68, 0x88, + 0x0c, 0x27, 0xf3, 0x71, 0xf3, 0x1f, 0x0c, 0x51, 0x6c, 0xea, 0xb1, 0xf7, 0x8f, 0x35, 0x7b, 0x17, + 0xaf, 0xe4, 0xe3, 0x27, 0x6b, 0x26, 0x5f, 0x82, 0xc9, 0xd7, 0x31, 0x75, 0x15, 0x49, 0x35, 0xc6, + 0x7f, 0x34, 0xc4, 0xc5, 0xba, 0xd7, 0x1e, 0xb7, 0x61, 0xea, 0xf5, 0xec, 0x50, 0x43, 0x43, 0x1f, + 0x31, 0x33, 0x49, 0xf5, 0x97, 0xb4, 0xaf, 0xa5, 0x7c, 0x2e, 0xea, 0x69, 0xaf, 0x63, 0x2b, 0xe6, + 0x6a, 0x0c, 0xb6, 0x5c, 0xce, 0x5c, 0xa2, 0xf7, 0x62, 0x39, 0x24, 0x2f, 0x72, 0x65, 0x5a, 0x28, + 0x50, 0xe1, 0xd2, 0xf5, 0x8f, 0x73, 0x90, 0x6c, 0xc3, 0x8a, 0x1a, 0x80, 0x98, 0x40, 0x4c, 0xfc, + 0xd6, 0xb1, 0x8f, 0xbd, 0x8a, 0xd3, 0x3c, 0x6b, 0xe0, 0x63, 0x96, 0xa2, 0xca, 0x4b, 0xc3, 0x4f, + 0x34, 0x23, 0x58, 0x4e, 0xe8, 0xcb, 0xf8, 0xdf, 0xda, 0xfa, 0xbf, 0x37, 0x20, 0x17, 0xc7, 0xdb, + 0xdb, 0xdd, 0xfd, 0x75, 0x9e, 0x86, 0x33, 0x6e, 0xb3, 0x1c, 0x5d, 0xae, 0x29, 0x84, 0x25, 0x42, + 0x92, 0xff, 0xda, 0xb6, 0xff, 0xc6, 0x80, 0x85, 0x7d, 0x9f, 0xb2, 0xff, 0x75, 0xdb, 0xf1, 0x70, + 0x5d, 0x28, 0x6e, 0x3d, 0xae, 0x7b, 0x87, 0x6e, 0xfc, 0xde, 0x50, 0x5c, 0x77, 0xce, 0x87, 0x4a, + 0xd3, 0x45, 0xaa, 0x5f, 0x5b, 0xce, 0xde, 0x50, 0xd8, 0x76, 0x81, 0xee, 0xc1, 0xc8, 0x53, 0x12, + 0xbf, 0x86, 0xf9, 0x31, 0x67, 0x18, 0x04, 0x74, 0xe0, 0x9e, 0x39, 0x4d, 0xc2, 0x32, 0x79, 0x28, + 0x4d, 0xc0, 0xd8, 0x91, 0xed, 0x9d, 0xe1, 0xc0, 0xfc, 0x08, 0xd2, 0x72, 0x98, 0xa6, 0xf1, 0x4a, + 0xf8, 0x23, 0x9f, 0x49, 0xf6, 0x41, 0x07, 0x45, 0xf6, 0x41, 0x1f, 0xcc, 0x4d, 0x58, 0x8c, 0x88, + 0xc9, 0xf7, 0x20, 0x47, 0x94, 0xc1, 0x60, 0xec, 0x65, 0x9e, 0x25, 0x9f, 0xcd, 0x32, 0xcc, 0xf5, + 0x68, 0x11, 0x21, 0xa5, 0x3f, 0x8d, 0x1c, 0xa4, 0x4a, 0x65, 0x8f, 0xc0, 0x64, 0x3b, 0x1a, 0x81, + 0x1d, 0x1d, 0x54, 0x4a, 0x63, 0x6c, 0x57, 0x48, 0x2c, 0x22, 0x37, 0x17, 0xfa, 0x72, 0xc4, 0x0f, + 0x0b, 0x20, 0xd1, 0xbb, 0xac, 0x7a, 0x9f, 0x2e, 0x41, 0xba, 0x12, 0xd8, 0xf4, 0xde, 0x2f, 0x94, + 0xd9, 0xaf, 0x20, 0x3c, 0xf1, 0x6d, 0x27, 0x3f, 0x44, 0xab, 0xc0, 0x21, 0x1a, 0x7a, 0x08, 0xe3, + 0xdb, 0xcd, 0x3a, 0xa5, 0x30, 0x7c, 0x03, 0x0a, 0x02, 0x89, 0x9c, 0x78, 0xca, 0x32, 0xf1, 0xde, + 0x3e, 0x6d, 0x26, 0x4c, 0x5b, 0x0a, 0x84, 0xaa, 0xd9, 0xb9, 0x74, 0xd8, 0xdb, 0xa0, 0x51, 0x8b, + 0x3d, 0x10, 0x6d, 0x52, 0x16, 0x1e, 0xe3, 0x57, 0x3c, 0x85, 0x91, 0xcf, 0xe6, 0xef, 0x68, 0x99, + 0x3d, 0xe0, 0x85, 0x37, 0x5d, 0x1f, 0x9a, 0xc4, 0xc6, 0x1b, 0x4b, 0x9c, 0x7a, 0x1d, 0x89, 0xa5, + 0x44, 0xc3, 0x49, 0x12, 0x8d, 0x44, 0x24, 0xda, 0x85, 0x31, 0x26, 0x06, 0xb9, 0x89, 0xee, 0x07, + 0xf8, 0x32, 0xbc, 0x89, 0xaa, 0xef, 0xc6, 0x2c, 0x36, 0x46, 0xd2, 0xbb, 0x03, 0xdb, 0xa7, 0x94, + 0x98, 0x6d, 0x8a, 0x47, 0xf3, 0x14, 0x32, 0x07, 0x8e, 0x1f, 0x10, 0xfb, 0xbd, 0xa6, 0x89, 0x48, + 0x66, 0x53, 0x49, 0xcc, 0x0e, 0x47, 0x98, 0xfd, 0x39, 0xcc, 0x29, 0x6b, 0x70, 0xeb, 0x7f, 0x77, + 0x50, 0xb5, 0x50, 0x56, 0xa3, 0x08, 0xf7, 0x4f, 0xf1, 0x37, 0x2a, 0xf7, 0xfc, 0xd1, 0x7c, 0x48, + 0xbb, 0x81, 0x0e, 0xdc, 0xda, 0x85, 0x52, 0xab, 0x19, 0x67, 0xe7, 0x35, 0x5a, 0xf2, 0x24, 0xb3, + 0xd8, 0x88, 0x25, 0x66, 0xf0, 0xab, 0x3d, 0xc7, 0x0f, 0xaf, 0xf6, 0x14, 0x10, 0xb9, 0xda, 0xb3, + 0xae, 0x5e, 0x8b, 0x8d, 0xf1, 0xca, 0x01, 0xf9, 0xdc, 0xef, 0x5e, 0x2f, 0x0b, 0x00, 0x03, 0x26, + 0xbe, 0xf7, 0x1e, 0xa4, 0xe5, 0x37, 0x89, 0x48, 0xc2, 0xb2, 0xff, 0x74, 0xff, 0x88, 0x25, 0x2c, + 0x87, 0xc7, 0x47, 0x19, 0x03, 0x01, 0x8c, 0x6d, 0x6d, 0x1f, 0x6c, 0x1f, 0x6d, 0x67, 0x52, 0x85, + 0x7f, 0x7a, 0x00, 0x93, 0xc4, 0x3b, 0xf3, 0xda, 0x24, 0xfa, 0x1c, 0x66, 0x2a, 0xb8, 0x59, 0x7f, + 0x8c, 0x71, 0xab, 0xd8, 0x70, 0xae, 0xb0, 0x8f, 0x44, 0xc8, 0x92, 0xa0, 0xdc, 0x52, 0x8f, 0x3d, + 0x6e, 0x5f, 0xb6, 0x82, 0x57, 0xf7, 0x0d, 0xf4, 0x63, 0x98, 0xa4, 0x0d, 0xba, 0xdc, 0x9a, 0xa6, + 0xd4, 0xa6, 0xdd, 0x9c, 0x78, 0xa2, 0x83, 0x1f, 0x18, 0xe8, 0x01, 0x8c, 0xef, 0x62, 0xba, 0x8f, + 0xe8, 0x9d, 0xc8, 0x97, 0x97, 0xf6, 0x9b, 0xd2, 0x42, 0xb8, 0xa0, 0xb9, 0xe8, 0x86, 0xa2, 0x32, + 0x4c, 0x70, 0x74, 0x1f, 0x99, 0x11, 0x7c, 0x3f, 0x86, 0xc0, 0x7c, 0x84, 0x00, 0x31, 0x22, 0xf4, + 0x10, 0xd2, 0xd2, 0x98, 0x90, 0x88, 0xaa, 0x51, 0x13, 0xce, 0x65, 0x7b, 0x07, 0xf8, 0xf6, 0x6e, + 0x00, 0xb0, 0xd2, 0x26, 0x15, 0x23, 0xca, 0x63, 0xae, 0x47, 0x77, 0x68, 0x97, 0x24, 0x20, 0x64, + 0x13, 0xaf, 0x2b, 0x77, 0x82, 0xb2, 0xd1, 0x01, 0xcc, 0xc8, 0x42, 0xe3, 0xf5, 0x95, 0x90, 0x44, + 0xed, 0x53, 0x98, 0x13, 0x6f, 0xdb, 0x64, 0x4e, 0x81, 0x92, 0xb2, 0x0c, 0xb9, 0x93, 0x6c, 0x1a, + 0x86, 0x9c, 0x8a, 0xab, 0xe7, 0x08, 0xe8, 0x8e, 0x42, 0x24, 0x36, 0xb5, 0xc9, 0xbd, 0xd3, 0x67, + 0x06, 0x53, 0xf3, 0x7d, 0xe3, 0x03, 0x03, 0x7d, 0x01, 0xd3, 0x5a, 0xe4, 0x43, 0xe2, 0x2e, 0x12, + 0x17, 0xf6, 0x73, 0xab, 0xf1, 0x83, 0x7c, 0xdb, 0x76, 0x88, 0xb8, 0x41, 0xa4, 0x67, 0x2f, 0x17, + 0xd7, 0x9b, 0xc7, 0xda, 0xc0, 0x73, 0xa2, 0x59, 0x21, 0x82, 0xb2, 0x0d, 0xf3, 0xfc, 0x15, 0x96, + 0xf6, 0xc5, 0x9a, 0x84, 0x2e, 0xbf, 0x44, 0xed, 0x3f, 0x82, 0x79, 0xbe, 0x97, 0x1a, 0x99, 0x8c, + 0x6c, 0xaf, 0xe0, 0x0d, 0x61, 0x89, 0x04, 0xbe, 0x80, 0xc5, 0x4a, 0x44, 0x1e, 0xd6, 0x76, 0x77, + 0x4b, 0x27, 0xa1, 0xf4, 0xf7, 0x25, 0xd2, 0x7a, 0x0c, 0xa8, 0xd2, 0x3e, 0xbd, 0x74, 0x24, 0xb9, + 0x2b, 0x07, 0xbf, 0x44, 0xb7, 0x23, 0x22, 0x11, 0x20, 0x9d, 0x46, 0x83, 0x60, 0x2e, 0x41, 0x62, + 0x74, 0xc4, 0x5e, 0xa1, 0xb2, 0xee, 0x1c, 0xbb, 0x65, 0x9f, 0x3a, 0x0d, 0x27, 0x70, 0x30, 0x31, + 0x0b, 0x15, 0x41, 0x1d, 0x12, 0x3b, 0x78, 0x2b, 0x71, 0x06, 0x7a, 0x08, 0xd3, 0xbb, 0x38, 0x08, + 0x5b, 0x18, 0xd1, 0x72, 0x4f, 0xd3, 0x23, 0xdf, 0x37, 0x51, 0xba, 0xd4, 0xfb, 0x26, 0xf7, 0x21, + 0x73, 0xdc, 0xaa, 0xdb, 0x01, 0x56, 0x48, 0xdc, 0xee, 0x21, 0xc1, 0xa7, 0xd8, 0x9e, 0x7d, 0xe9, + 0x27, 0x6a, 0x6b, 0x03, 0x46, 0x0e, 0x9d, 0xe6, 0x19, 0x12, 0xf5, 0x4d, 0xa5, 0xf9, 0x2c, 0x37, + 0xaf, 0xc1, 0xb8, 0xe9, 0x05, 0x90, 0x1f, 0xd0, 0xbb, 0x87, 0x7e, 0x22, 0x13, 0xce, 0xeb, 0xf4, + 0xf8, 0xe5, 0x94, 0x73, 0x1f, 0x3f, 0xb1, 0xba, 0x89, 0x7e, 0x41, 0xf7, 0xa1, 0x77, 0x06, 0xba, + 0xcb, 0xd7, 0xea, 0xd7, 0x00, 0x98, 0x5b, 0x49, 0x5c, 0xa1, 0xba, 0x89, 0x4e, 0xc4, 0x6b, 0xdc, + 0x18, 0xea, 0xf7, 0xb4, 0xde, 0xa2, 0xd7, 0x5c, 0x60, 0x83, 0xc6, 0x09, 0xfa, 0xe5, 0xc4, 0xc5, + 0x90, 0x5b, 0xa5, 0xbf, 0x2a, 0xa7, 0x7f, 0xbd, 0x11, 0x6d, 0xd2, 0xc8, 0x40, 0xbb, 0x7a, 0xd1, + 0x92, 0x8e, 0xe1, 0xc7, 0xa3, 0x7c, 0x60, 0xa0, 0x4d, 0x00, 0xc6, 0x25, 0x5d, 0x48, 0x1f, 0x4e, + 0xdc, 0xfd, 0x4d, 0xe2, 0xfe, 0xeb, 0x37, 0x44, 0x7a, 0x28, 0x42, 0x00, 0x45, 0xca, 0x6a, 0xb7, + 0x5c, 0x55, 0xaa, 0x24, 0xfc, 0x7d, 0xc8, 0x14, 0x6b, 0xd4, 0xa1, 0xc9, 0x96, 0x2f, 0xb4, 0x26, + 0x0f, 0x8b, 0x3e, 0x20, 0x68, 0x2d, 0x46, 0x3b, 0xc8, 0x0e, 0x30, 0xb9, 0xb6, 0xec, 0xc1, 0xb2, + 0x0c, 0x4d, 0x91, 0xa1, 0x78, 0x8c, 0x44, 0xa6, 0xb6, 0x61, 0xa1, 0x6c, 0x37, 0x6b, 0xb8, 0xf1, + 0x66, 0x64, 0x3e, 0xa5, 0x27, 0x5b, 0x69, 0x87, 0x5b, 0x8a, 0xe2, 0xf3, 0x83, 0x2d, 0xbe, 0x46, + 0xa0, 0x4c, 0x2d, 0xc2, 0x2c, 0x53, 0x62, 0xa8, 0x96, 0x24, 0xec, 0xa4, 0xe5, 0x3f, 0x86, 0x99, + 0x6d, 0xe2, 0xf9, 0xda, 0x75, 0x87, 0x5d, 0x74, 0x90, 0x9e, 0x01, 0x27, 0x22, 0xee, 0xc1, 0x1c, + 0x0f, 0x04, 0x61, 0x9f, 0x98, 0x74, 0xbe, 0xbd, 0xad, 0x78, 0xb9, 0x05, 0x41, 0x56, 0x6d, 0x29, + 0x13, 0x61, 0x4e, 0x6b, 0x8a, 0x92, 0x61, 0x2e, 0xae, 0x5d, 0x4b, 0x86, 0xb9, 0xf8, 0x3e, 0xaa, + 0x12, 0xcc, 0x46, 0xfa, 0xa1, 0xd0, 0x6d, 0x11, 0x6c, 0x63, 0xfb, 0xa4, 0x62, 0x12, 0x96, 0x3d, + 0xa1, 0xd5, 0x5e, 0x1a, 0xf1, 0xcd, 0x51, 0x89, 0x3a, 0x3a, 0x94, 0x51, 0x4e, 0xed, 0x74, 0x42, + 0x7a, 0x99, 0x27, 0xae, 0x0b, 0x2a, 0x91, 0x62, 0x85, 0x24, 0xdc, 0x7a, 0x8f, 0x10, 0x5a, 0x93, + 0x1a, 0x89, 0x6d, 0x84, 0xca, 0xe5, 0x13, 0xc7, 0xb9, 0xd2, 0x94, 0x0d, 0x60, 0x5f, 0xe1, 0x8c, + 0x6e, 0x80, 0xda, 0x51, 0xd2, 0xb3, 0x01, 0x7a, 0xa3, 0xc8, 0x2e, 0x4d, 0xec, 0x95, 0x66, 0x1f, + 0x94, 0x20, 0x4a, 0xee, 0x76, 0x1c, 0x9d, 0x70, 0x27, 0x2b, 0x90, 0x89, 0xf6, 0xca, 0x48, 0x49, + 0x13, 0x9a, 0x7e, 0xa4, 0xa4, 0x89, 0x4d, 0x36, 0x5f, 0x40, 0x26, 0xda, 0x28, 0x23, 0x89, 0x26, + 0x74, 0xd0, 0x24, 0x6e, 0xc5, 0x0e, 0x2c, 0xe8, 0x1b, 0x38, 0x40, 0xde, 0xe4, 0x4c, 0x66, 0x5a, + 0x6b, 0x8f, 0x41, 0x22, 0x34, 0x44, 0x3a, 0x71, 0x7a, 0xb4, 0x1f, 0xd3, 0xa6, 0xc3, 0xb4, 0xaf, + 0xb4, 0xda, 0x5c, 0x47, 0xfb, 0x71, 0x9d, 0x39, 0x52, 0x51, 0x0a, 0x5f, 0xc2, 0xe3, 0x46, 0x07, + 0x6e, 0xa2, 0xa8, 0xeb, 0xb0, 0x96, 0x44, 0x67, 0x0b, 0x26, 0x95, 0x1e, 0x1d, 0x74, 0x4b, 0x53, + 0x93, 0x66, 0xf1, 0x39, 0x4d, 0x38, 0xdd, 0xd8, 0xcb, 0x30, 0xa5, 0x76, 0xfa, 0x24, 0x72, 0xb1, + 0xd2, 0x4b, 0xc3, 0x57, 0xb2, 0xe9, 0x19, 0xa9, 0x05, 0xc6, 0xcd, 0x6a, 0x54, 0x39, 0x1a, 0x43, + 0xc9, 0x22, 0x21, 0x55, 0x35, 0x03, 0x58, 0x4a, 0x8e, 0x44, 0xf3, 0x2c, 0x26, 0xeb, 0x5f, 0x1e, + 0x4f, 0xf8, 0x0e, 0x7a, 0x1f, 0x6f, 0x35, 0x1b, 0x69, 0x4d, 0x42, 0x8a, 0x95, 0xc4, 0xb4, 0xf3, + 0xe4, 0xd6, 0x92, 0x86, 0xb9, 0x9a, 0x0e, 0x60, 0xae, 0xa7, 0x33, 0x09, 0xe5, 0x35, 0x7f, 0xdc, + 0xdb, 0x62, 0xd4, 0xe7, 0xfe, 0x37, 0xd7, 0xd3, 0x96, 0x24, 0xa9, 0x25, 0x35, 0x2c, 0x25, 0x52, + 0x3b, 0x82, 0xc5, 0xd8, 0x56, 0x25, 0x99, 0x1f, 0xf6, 0x6b, 0x64, 0x4a, 0xa4, 0xfa, 0x0b, 0x40, + 0xbd, 0x6d, 0x45, 0xf2, 0x46, 0x98, 0xd8, 0xfa, 0x24, 0x6f, 0x84, 0x7d, 0x7a, 0x92, 0x0e, 0x60, + 0x21, 0xae, 0xa7, 0x08, 0x99, 0x9a, 0x3e, 0x63, 0x7b, 0x82, 0x62, 0x82, 0x9c, 0x25, 0x0e, 0x65, + 0x02, 0xb5, 0x3e, 0x1d, 0x46, 0x89, 0xc2, 0xff, 0x52, 0xf4, 0x8d, 0xf5, 0x76, 0x02, 0xc9, 0xbc, + 0x78, 0x40, 0xab, 0x50, 0x9f, 0x74, 0x63, 0xb6, 0xe2, 0x9c, 0x35, 0x95, 0xa6, 0x1d, 0x99, 0x6c, + 0xf4, 0x76, 0x0b, 0x49, 0x07, 0x10, 0xd7, 0xe3, 0xf3, 0x0c, 0x16, 0x44, 0x24, 0x54, 0x5b, 0x63, + 0x50, 0x0f, 0x4e, 0xd8, 0xb9, 0x23, 0x9d, 0x41, 0x6c, 0x2f, 0x0d, 0xcb, 0xd6, 0xe9, 0x2f, 0x82, + 0x28, 0xd9, 0xba, 0xd2, 0xb3, 0x92, 0xd3, 0xdb, 0x5b, 0xd0, 0x67, 0x34, 0x5b, 0x67, 0xad, 0xc5, + 0x49, 0x67, 0x7d, 0x59, 0xa7, 0x14, 0x9a, 0xc1, 0xa6, 0xa8, 0xbf, 0xd0, 0x05, 0x75, 0xca, 0x83, + 0x13, 0x70, 0x8a, 0xa4, 0x27, 0xe0, 0x2a, 0xa3, 0xc9, 0x37, 0xe4, 0x29, 0xf5, 0x85, 0x9f, 0xd4, + 0x55, 0xcc, 0x2b, 0x45, 0xa9, 0xab, 0xb8, 0x37, 0x84, 0x34, 0xdf, 0x3b, 0x12, 0xf9, 0x55, 0x48, + 0xef, 0x76, 0xdf, 0x57, 0x7c, 0xb9, 0xb5, 0xfe, 0xef, 0xc5, 0x94, 0x2c, 0x32, 0x7c, 0x23, 0xa5, + 0x26, 0x31, 0x3d, 0xef, 0xaf, 0xd4, 0x30, 0x1a, 0xf3, 0x12, 0xeb, 0x09, 0x2d, 0x6b, 0x3e, 0xdb, + 0xdf, 0x2a, 0xf3, 0x5f, 0x26, 0x71, 0xbd, 0x9e, 0xc2, 0x95, 0xf2, 0x6d, 0xc8, 0x50, 0x7b, 0x6c, + 0x8a, 0x86, 0x58, 0x2d, 0xa0, 0x0a, 0xad, 0xbd, 0x68, 0xd0, 0x98, 0xda, 0x55, 0x0c, 0xc1, 0x5c, + 0x3c, 0x41, 0x5a, 0xc7, 0xa3, 0x4e, 0x9f, 0xd8, 0x81, 0xce, 0x66, 0x02, 0x0f, 0xfd, 0x62, 0x07, + 0xd3, 0x6a, 0x3c, 0x19, 0xc1, 0xdd, 0x20, 0x03, 0x61, 0x1a, 0xab, 0x14, 0x9f, 0x1c, 0xbc, 0x96, + 0xc6, 0x34, 0x44, 0xa9, 0x31, 0x0d, 0x7a, 0x33, 0x8d, 0x45, 0x08, 0xea, 0x1a, 0xd3, 0xd9, 0x4c, + 0xe0, 0x61, 0xb0, 0xc6, 0xe2, 0xc9, 0x5c, 0x57, 0x63, 0x5f, 0xd2, 0x48, 0xb1, 0x4b, 0xbf, 0x89, + 0x79, 0x23, 0x9d, 0x65, 0x45, 0xde, 0xa3, 0xa3, 0x56, 0x37, 0xd1, 0x73, 0xda, 0x0f, 0x1d, 0x81, + 0x5f, 0x4f, 0x6f, 0xab, 0x49, 0x44, 0xa9, 0xe6, 0xf6, 0x61, 0x91, 0x69, 0x2e, 0xca, 0x6e, 0x22, + 0x2f, 0x89, 0x62, 0xef, 0x8a, 0xb0, 0x1b, 0x25, 0x75, 0x53, 0xfd, 0x6d, 0x51, 0x13, 0x39, 0xf2, + 0x48, 0x56, 0x53, 0xef, 0x4d, 0x79, 0x74, 0x22, 0xa2, 0x5a, 0xa6, 0x4f, 0xaf, 0x16, 0xd0, 0x3e, + 0xdd, 0x05, 0x1d, 0xdc, 0x2f, 0x27, 0x8c, 0x27, 0x43, 0x95, 0xb4, 0x27, 0xe2, 0x73, 0x84, 0xa7, + 0xa4, 0xb5, 0x93, 0x99, 0x92, 0x09, 0xf3, 0x35, 0xa5, 0x4b, 0x52, 0x11, 0x8b, 0x33, 0x2c, 0x3f, + 0x1d, 0xa4, 0x99, 0xe8, 0x6f, 0x86, 0xa1, 0xdf, 0x87, 0xb4, 0x40, 0x1e, 0xac, 0x90, 0x28, 0x36, + 0x7f, 0xd3, 0x30, 0xc9, 0x15, 0x42, 0x39, 0x48, 0x5a, 0x29, 0x91, 0xfd, 0x07, 0x30, 0xc9, 0xd5, + 0xd0, 0x57, 0x82, 0xe4, 0x74, 0x71, 0x71, 0x17, 0x07, 0x31, 0xbf, 0x3a, 0x33, 0x48, 0x98, 0xb8, + 0x1f, 0xb9, 0x21, 0xd4, 0x2a, 0xb1, 0xd4, 0xfa, 0x61, 0x25, 0xf2, 0x56, 0xa5, 0xdd, 0xe7, 0x49, + 0xbf, 0x37, 0x94, 0xc4, 0xe0, 0xc0, 0x5f, 0x3b, 0x22, 0x74, 0x2b, 0xc9, 0x74, 0x07, 0xe2, 0x27, + 0xf2, 0xfb, 0x14, 0x56, 0x69, 0xa1, 0xf2, 0xa6, 0x1c, 0x27, 0x27, 0xdf, 0xb7, 0xc2, 0xf7, 0xc9, + 0xd1, 0x9f, 0x3a, 0x4a, 0x22, 0x36, 0xe8, 0x57, 0x96, 0x08, 0xd5, 0x4a, 0x22, 0xd5, 0x41, 0xd8, + 0x7d, 0x42, 0xdb, 0x0a, 0x95, 0xfd, 0x86, 0xdc, 0xf6, 0xf7, 0x5b, 0x91, 0xdf, 0x5e, 0x4a, 0xce, + 0x02, 0xe3, 0x7f, 0xdd, 0x89, 0x50, 0xa9, 0xf4, 0x50, 0x49, 0x9a, 0xdd, 0x2f, 0x94, 0x51, 0xd1, + 0xae, 0xc9, 0x4d, 0x72, 0x4d, 0x38, 0x2d, 0xdb, 0x24, 0x90, 0x92, 0xb8, 0x6a, 0x8d, 0x02, 0xb9, + 0x69, 0xf5, 0x65, 0xa8, 0x8f, 0x8a, 0x2c, 0x63, 0x50, 0x5b, 0x0a, 0x94, 0x4a, 0x56, 0x6c, 0xaf, + 0x41, 0x94, 0x04, 0x4b, 0xbc, 0x0f, 0xdc, 0xda, 0x85, 0x9a, 0x78, 0x2b, 0xef, 0x8a, 0x73, 0xfa, + 0xcb, 0x67, 0xee, 0x10, 0xe9, 0x1b, 0x68, 0xb5, 0x4c, 0xae, 0xbe, 0xff, 0x56, 0x13, 0x6f, 0xfd, + 0xbd, 0xb6, 0x4c, 0xbc, 0xe9, 0x82, 0x3a, 0xe5, 0xc1, 0x89, 0x37, 0x45, 0xd2, 0x13, 0x6f, 0x95, + 0xd1, 0x04, 0xfc, 0x52, 0xe6, 0xdb, 0xff, 0x5a, 0x33, 0xbe, 0xfd, 0x7e, 0xcd, 0xf8, 0xb7, 0xef, + 0xd7, 0x8c, 0xef, 0xbe, 0x5f, 0x33, 0x4e, 0xc7, 0xe8, 0x8c, 0xcd, 0xff, 0x09, 0x00, 0x00, 0xff, + 0xff, 0x02, 0xbf, 0xe5, 0x07, 0x87, 0x54, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -7012,6 +7229,14 @@ type AuthServiceClient interface { GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (*Events, error) // In-session request for audit events. GetSessionEvents(ctx context.Context, in *GetSessionEventsRequest, opts ...grpc.CallOption) (*Events, error) + // GetLock gets a lock by name. + GetLock(ctx context.Context, in *GetLockRequest, opts ...grpc.CallOption) (*types.LockV2, error) + // GetLocks gets all locks, matching at least one of the targets when specified. + GetLocks(ctx context.Context, in *GetLocksRequest, opts ...grpc.CallOption) (*GetLocksResponse, error) + // UpsertLock upserts a lock. + UpsertLock(ctx context.Context, in *types.LockV2, opts ...grpc.CallOption) (*empty.Empty, error) + // DeleteLock deletes a lock. + DeleteLock(ctx context.Context, in *DeleteLockRequest, opts ...grpc.CallOption) (*empty.Empty, error) } type authServiceClient struct { @@ -8117,6 +8342,42 @@ func (c *authServiceClient) GetSessionEvents(ctx context.Context, in *GetSession return out, nil } +func (c *authServiceClient) GetLock(ctx context.Context, in *GetLockRequest, opts ...grpc.CallOption) (*types.LockV2, error) { + out := new(types.LockV2) + err := c.cc.Invoke(ctx, "/proto.AuthService/GetLock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authServiceClient) GetLocks(ctx context.Context, in *GetLocksRequest, opts ...grpc.CallOption) (*GetLocksResponse, error) { + out := new(GetLocksResponse) + err := c.cc.Invoke(ctx, "/proto.AuthService/GetLocks", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authServiceClient) UpsertLock(ctx context.Context, in *types.LockV2, opts ...grpc.CallOption) (*empty.Empty, error) { + out := new(empty.Empty) + err := c.cc.Invoke(ctx, "/proto.AuthService/UpsertLock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *authServiceClient) DeleteLock(ctx context.Context, in *DeleteLockRequest, opts ...grpc.CallOption) (*empty.Empty, error) { + out := new(empty.Empty) + err := c.cc.Invoke(ctx, "/proto.AuthService/DeleteLock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // AuthServiceServer is the server API for AuthService service. type AuthServiceServer interface { // SendKeepAlives allows node to send a stream of keep alive requests @@ -8352,6 +8613,14 @@ type AuthServiceServer interface { GetEvents(context.Context, *GetEventsRequest) (*Events, error) // In-session request for audit events. GetSessionEvents(context.Context, *GetSessionEventsRequest) (*Events, error) + // GetLock gets a lock by name. + GetLock(context.Context, *GetLockRequest) (*types.LockV2, error) + // GetLocks gets all locks, matching at least one of the targets when specified. + GetLocks(context.Context, *GetLocksRequest) (*GetLocksResponse, error) + // UpsertLock upserts a lock. + UpsertLock(context.Context, *types.LockV2) (*empty.Empty, error) + // DeleteLock deletes a lock. + DeleteLock(context.Context, *DeleteLockRequest) (*empty.Empty, error) } // UnimplementedAuthServiceServer can be embedded to have forward compatible implementations. @@ -8670,6 +8939,18 @@ func (*UnimplementedAuthServiceServer) GetEvents(ctx context.Context, req *GetEv func (*UnimplementedAuthServiceServer) GetSessionEvents(ctx context.Context, req *GetSessionEventsRequest) (*Events, error) { return nil, status.Errorf(codes.Unimplemented, "method GetSessionEvents not implemented") } +func (*UnimplementedAuthServiceServer) GetLock(ctx context.Context, req *GetLockRequest) (*types.LockV2, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLock not implemented") +} +func (*UnimplementedAuthServiceServer) GetLocks(ctx context.Context, req *GetLocksRequest) (*GetLocksResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetLocks not implemented") +} +func (*UnimplementedAuthServiceServer) UpsertLock(ctx context.Context, req *types.LockV2) (*empty.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpsertLock not implemented") +} +func (*UnimplementedAuthServiceServer) DeleteLock(ctx context.Context, req *DeleteLockRequest) (*empty.Empty, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteLock not implemented") +} func RegisterAuthServiceServer(s *grpc.Server, srv AuthServiceServer) { s.RegisterService(&_AuthService_serviceDesc, srv) @@ -10593,6 +10874,78 @@ func _AuthService_GetSessionEvents_Handler(srv interface{}, ctx context.Context, return interceptor(ctx, in, info, handler) } +func _AuthService_GetLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetLockRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServiceServer).GetLock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/proto.AuthService/GetLock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServiceServer).GetLock(ctx, req.(*GetLockRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AuthService_GetLocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetLocksRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServiceServer).GetLocks(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/proto.AuthService/GetLocks", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServiceServer).GetLocks(ctx, req.(*GetLocksRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _AuthService_UpsertLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(types.LockV2) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServiceServer).UpsertLock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/proto.AuthService/UpsertLock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServiceServer).UpsertLock(ctx, req.(*types.LockV2)) + } + return interceptor(ctx, in, info, handler) +} + +func _AuthService_DeleteLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteLockRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AuthServiceServer).DeleteLock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/proto.AuthService/DeleteLock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AuthServiceServer).DeleteLock(ctx, req.(*DeleteLockRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _AuthService_serviceDesc = grpc.ServiceDesc{ ServiceName: "proto.AuthService", HandlerType: (*AuthServiceServer)(nil), @@ -10985,6 +11338,22 @@ var _AuthService_serviceDesc = grpc.ServiceDesc{ MethodName: "GetSessionEvents", Handler: _AuthService_GetSessionEvents_Handler, }, + { + MethodName: "GetLock", + Handler: _AuthService_GetLock_Handler, + }, + { + MethodName: "GetLocks", + Handler: _AuthService_GetLocks_Handler, + }, + { + MethodName: "UpsertLock", + Handler: _AuthService_UpsertLock_Handler, + }, + { + MethodName: "DeleteLock", + Handler: _AuthService_DeleteLock_Handler, + }, }, Streams: []grpc.StreamDesc{ { @@ -11549,6 +11918,29 @@ func (m *Event_ClusterAuditConfig) MarshalToSizedBuffer(dAtA []byte) (int, error } return len(dAtA) - i, nil } +func (m *Event_Lock) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Event_Lock) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Lock != nil { + { + size, err := m.Lock.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuthservice(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xc2 + } + return len(dAtA) - i, nil +} func (m *Watch) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -11794,12 +12186,12 @@ func (m *UserCertsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x22 } - n25, err25 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) - if err25 != nil { - return 0, err25 + n26, err26 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) + if err26 != nil { + return 0, err26 } - i -= n25 - i = encodeVarintAuthservice(dAtA, i, uint64(n25)) + i -= n26 + i = encodeVarintAuthservice(dAtA, i, uint64(n26)) i-- dAtA[i] = 0x1a if len(m.Username) > 0 { @@ -13108,12 +13500,12 @@ func (m *GenerateAppTokenRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } - n34, err34 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) - if err34 != nil { - return 0, err34 + n35, err35 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Expires):]) + if err35 != nil { + return 0, err35 } - i -= n34 - i = encodeVarintAuthservice(dAtA, i, uint64(n34)) + i -= n35 + i = encodeVarintAuthservice(dAtA, i, uint64(n35)) i-- dAtA[i] = 0x22 if len(m.URI) > 0 { @@ -15866,21 +16258,21 @@ func (m *GetEventsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x22 } } - n65, err65 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndDate):]) - if err65 != nil { - return 0, err65 - } - i -= n65 - i = encodeVarintAuthservice(dAtA, i, uint64(n65)) - i-- - dAtA[i] = 0x1a - n66, err66 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartDate):]) + n66, err66 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndDate):]) if err66 != nil { return 0, err66 } i -= n66 i = encodeVarintAuthservice(dAtA, i, uint64(n66)) i-- + dAtA[i] = 0x1a + n67, err67 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartDate):]) + if err67 != nil { + return 0, err67 + } + i -= n67 + i = encodeVarintAuthservice(dAtA, i, uint64(n67)) + i-- dAtA[i] = 0x12 if len(m.Namespace) > 0 { i -= len(m.Namespace) @@ -15928,21 +16320,21 @@ func (m *GetSessionEventsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) i-- dAtA[i] = 0x18 } - n67, err67 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndDate):]) - if err67 != nil { - return 0, err67 - } - i -= n67 - i = encodeVarintAuthservice(dAtA, i, uint64(n67)) - i-- - dAtA[i] = 0x12 - n68, err68 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartDate):]) + n68, err68 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndDate):]) if err68 != nil { return 0, err68 } i -= n68 i = encodeVarintAuthservice(dAtA, i, uint64(n68)) i-- + dAtA[i] = 0x12 + n69, err69 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartDate, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartDate):]) + if err69 != nil { + return 0, err69 + } + i -= n69 + i = encodeVarintAuthservice(dAtA, i, uint64(n69)) + i-- dAtA[i] = 0xa return len(dAtA) - i, nil } @@ -16089,9 +16481,159 @@ func (m *ListNodesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func encodeVarintAuthservice(dAtA []byte, offset int, v uint64) int { - offset -= sovAuthservice(v) - base := offset +func (m *GetLocksRequest) 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 *GetLocksRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetLocksRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Targets) > 0 { + for iNdEx := len(m.Targets) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Targets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuthservice(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *GetLocksResponse) 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 *GetLocksResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetLocksResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Locks) > 0 { + for iNdEx := len(m.Locks) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Locks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuthservice(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *GetLockRequest) 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 *GetLockRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GetLockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintAuthservice(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DeleteLockRequest) 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 *DeleteLockRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DeleteLockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintAuthservice(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintAuthservice(dAtA []byte, offset int, v uint64) int { + offset -= sovAuthservice(v) + base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 @@ -16382,6 +16924,18 @@ func (m *Event_ClusterAuditConfig) Size() (n int) { } return n } +func (m *Event_Lock) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Lock != nil { + l = m.Lock.Size() + n += 2 + l + sovAuthservice(uint64(l)) + } + return n +} func (m *Watch) Size() (n int) { if m == nil { return 0 @@ -18520,6 +19074,74 @@ func (m *ListNodesResponse) Size() (n int) { return n } +func (m *GetLocksRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Targets) > 0 { + for _, e := range m.Targets { + l = e.Size() + n += 1 + l + sovAuthservice(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetLocksResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Locks) > 0 { + for _, e := range m.Locks { + l = e.Size() + n += 1 + l + sovAuthservice(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *GetLockRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovAuthservice(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *DeleteLockRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovAuthservice(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovAuthservice(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -19344,6 +19966,41 @@ func (m *Event) Unmarshal(dAtA []byte) error { } m.Resource = &Event_ClusterAuditConfig{v} iNdEx = postIndex + case 24: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuthservice + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuthservice + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuthservice + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &types.LockV2{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Resource = &Event_Lock{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipAuthservice(dAtA[iNdEx:]) @@ -30034,6 +30691,342 @@ func (m *ListNodesResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *GetLocksRequest) 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 ErrIntOverflowAuthservice + } + 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: GetLocksRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetLocksRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Targets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuthservice + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuthservice + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuthservice + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Targets = append(m.Targets, &types.LockTarget{}) + if err := m.Targets[len(m.Targets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuthservice(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuthservice + } + 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 *GetLocksResponse) 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 ErrIntOverflowAuthservice + } + 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: GetLocksResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetLocksResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuthservice + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuthservice + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuthservice + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Locks = append(m.Locks, &types.LockV2{}) + if err := m.Locks[len(m.Locks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuthservice(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuthservice + } + 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 *GetLockRequest) 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 ErrIntOverflowAuthservice + } + 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: GetLockRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GetLockRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuthservice + } + 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 ErrInvalidLengthAuthservice + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuthservice + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuthservice(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuthservice + } + 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 *DeleteLockRequest) 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 ErrIntOverflowAuthservice + } + 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: DeleteLockRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DeleteLockRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuthservice + } + 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 ErrInvalidLengthAuthservice + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuthservice + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuthservice(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuthservice + } + 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 skipAuthservice(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/api/client/proto/authservice.proto b/api/client/proto/authservice.proto index 0aa5049c8e888..bc753f2c66b2c 100644 --- a/api/client/proto/authservice.proto +++ b/api/client/proto/authservice.proto @@ -87,6 +87,8 @@ message Event { // ClusterAuditConfig is a resource for cluster audit configuration. types.ClusterAuditConfigV2 ClusterAuditConfig = 23 [ (gogoproto.jsontag) = "cluster_audit_config,omitempty" ]; + // Lock is a lock resource. + types.LockV2 Lock = 24 [ (gogoproto.jsontag) = "lock,omitempty" ]; } } @@ -885,6 +887,27 @@ message ListNodesResponse { string NextKey = 2; } +message GetLocksRequest { + // Targets is a list of targets. Every returned lock must match at least + // one of the targets. + repeated types.LockTarget Targets = 1; +} + +message GetLocksResponse { + // Locks is a list of locks. + repeated types.LockV2 Locks = 1; +} + +message GetLockRequest { + // Name is the name of the lock to get. + string Name = 1; +} + +message DeleteLockRequest { + // Name is the name of the lock to delete. + string Name = 1; +} + // AuthService is authentication/authorization service implementation service AuthService { // SendKeepAlives allows node to send a stream of keep alive requests @@ -1153,4 +1176,13 @@ service AuthService { rpc GetEvents(GetEventsRequest) returns (Events); // In-session request for audit events. rpc GetSessionEvents(GetSessionEventsRequest) returns (Events); + + // GetLock gets a lock by name. + rpc GetLock(GetLockRequest) returns (types.LockV2); + // GetLocks gets all locks, matching at least one of the targets when specified. + rpc GetLocks(GetLocksRequest) returns (GetLocksResponse); + // UpsertLock upserts a lock. + rpc UpsertLock(types.LockV2) returns (google.protobuf.Empty); + // DeleteLock deletes a lock. + rpc DeleteLock(DeleteLockRequest) returns (google.protobuf.Empty); } diff --git a/api/client/streamwatcher.go b/api/client/streamwatcher.go index 670dc4709722d..c7d8c174f9df7 100644 --- a/api/client/streamwatcher.go +++ b/api/client/streamwatcher.go @@ -178,6 +178,9 @@ func eventFromGRPC(in proto.Event) (*types.Event, error) { } else if r := in.GetAuthPreference(); r != nil { out.Resource = r return &out, nil + } else if r := in.GetLock(); r != nil { + out.Resource = r + return &out, nil } else { return nil, trace.BadParameter("received unsupported resource %T", in.Resource) } diff --git a/api/types/constants.go b/api/types/constants.go index 6b2313191fb3e..1ff7422b5a9f8 100644 --- a/api/types/constants.go +++ b/api/types/constants.go @@ -218,6 +218,9 @@ const ( // KindBilling represents access to cloud billing features KindBilling = "billing" + // KindLock is a lock resource. + KindLock = "lock" + // V4 is the fourth version of resources. V4 = "v4" diff --git a/api/types/events.go b/api/types/events.go index f350c2a748b7c..1118331a88c0e 100644 --- a/api/types/events.go +++ b/api/types/events.go @@ -137,6 +137,12 @@ func (kind WatchKind) Matches(e Event) (bool, error) { return false, trace.Wrap(err) } return filter.Match(res), nil + case Lock: + var target LockTarget + if err := target.FromMap(kind.Filter); err != nil { + return false, trace.Wrap(err) + } + return target.Match(res) default: return false, trace.BadParameter("unfilterable resource type %T", e.Resource) } diff --git a/api/types/lock.go b/api/types/lock.go new file mode 100644 index 0000000000000..d2176001237d8 --- /dev/null +++ b/api/types/lock.go @@ -0,0 +1,219 @@ +/* +Copyright 2021 Gravitational, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package types + +import ( + "time" + + "github.com/gravitational/teleport/api/utils" + + "github.com/gravitational/trace" + "github.com/jonboulle/clockwork" +) + +// Lock configures locking out of a particular access vector. +type Lock interface { + Resource + + // Target returns the lock's target. + Target() LockTarget + // SetTarget sets the lock's target. + SetTarget(LockTarget) + + // Message returns the message displayed to locked-out users. + Message() string + // SetMessage sets the lock's user message. + SetMessage(string) + + // LockExpiry returns when the lock ceases to be in force. + LockExpiry() *time.Time + // SetLockExpiry sets the lock's expiry. + SetLockExpiry(*time.Time) + + // IsInForce returns whether the lock is in force. + IsInForce(clockwork.Clock) bool +} + +// NewLock is a convenience method to create a Lock resource. +func NewLock(name string, spec LockSpecV2) (Lock, error) { + lock := &LockV2{ + Metadata: Metadata{ + Name: name, + }, + Spec: spec, + } + if err := lock.CheckAndSetDefaults(); err != nil { + return nil, trace.Wrap(err) + } + return lock, nil +} + +// GetVersion returns resource version. +func (c *LockV2) GetVersion() string { + return c.Version +} + +// GetName returns the name of the resource. +func (c *LockV2) GetName() string { + return c.Metadata.Name +} + +// SetName sets the name of the resource. +func (c *LockV2) SetName(e string) { + c.Metadata.Name = e +} + +// SetExpiry sets expiry time for the object. +func (c *LockV2) SetExpiry(expires time.Time) { + c.Metadata.SetExpiry(expires) +} + +// Expiry returns object expiry setting. +func (c *LockV2) Expiry() time.Time { + return c.Metadata.Expiry() +} + +// GetMetadata returns object metadata. +func (c *LockV2) GetMetadata() Metadata { + return c.Metadata +} + +// GetResourceID returns resource ID. +func (c *LockV2) GetResourceID() int64 { + return c.Metadata.ID +} + +// SetResourceID sets resource ID. +func (c *LockV2) SetResourceID(id int64) { + c.Metadata.ID = id +} + +// GetKind returns resource kind. +func (c *LockV2) GetKind() string { + return c.Kind +} + +// GetSubKind returns resource subkind. +func (c *LockV2) GetSubKind() string { + return c.SubKind +} + +// SetSubKind sets resource subkind. +func (c *LockV2) SetSubKind(sk string) { + c.SubKind = sk +} + +// Target returns the lock's target. +func (c *LockV2) Target() LockTarget { + return c.Spec.Target +} + +// SetTarget sets the lock's target. +func (c *LockV2) SetTarget(target LockTarget) { + c.Spec.Target = target +} + +// Message returns the message displayed to locked-out users. +func (c *LockV2) Message() string { + return c.Spec.Message +} + +// SetMessage sets the lock's user message. +func (c *LockV2) SetMessage(message string) { + c.Spec.Message = message +} + +// LockExpiry returns when the lock ceases to be in force. +func (c *LockV2) LockExpiry() *time.Time { + return c.Spec.Expires +} + +// SetLockExpiry sets the lock's expiry. +func (c *LockV2) SetLockExpiry(expiry *time.Time) { + c.Spec.Expires = expiry +} + +// IsInForce returns whether the lock is in force. +func (c *LockV2) IsInForce(clock clockwork.Clock) bool { + if c.Spec.Expires == nil { + return true + } + return clock.Now().Before(*c.Spec.Expires) +} + +// setStaticFields sets static resource header and metadata fields. +func (c *LockV2) setStaticFields() { + c.Kind = KindLock + c.Version = V2 +} + +// CheckAndSetDefaults verifies the constraints for Lock. +func (c *LockV2) CheckAndSetDefaults() error { + c.setStaticFields() + err := c.Metadata.CheckAndSetDefaults() + if err != nil { + return trace.Wrap(err) + } + + return trace.Wrap(c.Spec.Target.Check()) +} + +// Check verifies the target's constraints. +func (t LockTarget) Check() error { + targetMap, err := t.IntoMap() + if err != nil { + return trace.Wrap(err) + } + for _, val := range targetMap { + if val != "" { + return nil + } + } + return trace.BadParameter("at least one target field must be set") +} + +// IntoMap returns the target attributes in the form of a map. +func (t LockTarget) IntoMap() (map[string]string, error) { + m := map[string]string{} + if err := utils.ObjectToStruct(t, &m); err != nil { + return nil, trace.Wrap(err) + } + return m, nil +} + +// FromMap copies values from a map into this LockTarget. +func (t *LockTarget) FromMap(m map[string]string) error { + return trace.Wrap(utils.ObjectToStruct(m, t)) +} + +// Match returns true if the lock's target is matched by this target. +func (t LockTarget) Match(lock Lock) (bool, error) { + targetMap, err := t.IntoMap() + if err != nil { + return false, trace.Wrap(err) + } + lockTargetMap, err := lock.Target().IntoMap() + if err != nil { + return false, trace.Wrap(err) + } + for key := range targetMap { + if targetMap[key] != "" && targetMap[key] != lockTargetMap[key] { + return false, nil + } + } + return true, nil +} diff --git a/api/types/lock_test.go b/api/types/lock_test.go new file mode 100644 index 0000000000000..5571be339d23a --- /dev/null +++ b/api/types/lock_test.go @@ -0,0 +1,70 @@ +/* +Copyright 2021 Gravitational, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package types + +import ( + "testing" + + "github.com/google/go-cmp/cmp" + "github.com/stretchr/testify/require" +) + +func TestLockTargetMapConversions(t *testing.T) { + lt := LockTarget{ + User: "user@sso.tld", + Node: "host-1", + MFADevice: "mfa-device-uuid", + } + m := map[string]string{ + "user": "user@sso.tld", + "node": "host-1", + "mfa_device": "mfa-device-uuid", + } + + ltMap, err := lt.IntoMap() + require.NoError(t, err) + require.Empty(t, cmp.Diff(m, ltMap)) + + lt2 := LockTarget{} + err = lt2.FromMap(m) + require.NoError(t, err) + require.Empty(t, cmp.Diff(lt, lt2)) +} + +func TestLockTargetMatch(t *testing.T) { + target := LockTarget{ + User: "user@sso.tld", + Node: "host-1", + MFADevice: "mfa-device-uuid", + } + lock, err := NewLock("some-lock", LockSpecV2{Target: target}) + require.NoError(t, err) + + matched, err := target.Match(lock) + require.NoError(t, err) + require.True(t, matched) + + target.Node = "host-2" + matched, err = target.Match(lock) + require.NoError(t, err) + require.False(t, matched) + + target.Node = "" + matched, err = target.Match(lock) + require.NoError(t, err) + require.True(t, matched) +} diff --git a/api/types/types.pb.go b/api/types/types.pb.go index 5af38792ca552..39f8ae49efe6a 100644 --- a/api/types/types.pb.go +++ b/api/types/types.pb.go @@ -6598,6 +6598,158 @@ func (m *TrustedClusterSpecV2) XXX_DiscardUnknown() { var xxx_messageInfo_TrustedClusterSpecV2 proto.InternalMessageInfo +// LockV2 represents a lock. +type LockV2 struct { + // Kind is a resource kind. + Kind string `protobuf:"bytes,1,opt,name=Kind,proto3" json:"kind"` + // SubKind is an optional resource sub kind, used in some resources. + SubKind string `protobuf:"bytes,2,opt,name=SubKind,proto3" json:"sub_kind,omitempty"` + // Version is a resource version. + Version string `protobuf:"bytes,3,opt,name=Version,proto3" json:"version"` + // Metadata holds resource metadata. + Metadata Metadata `protobuf:"bytes,4,opt,name=Metadata,proto3" json:"metadata"` + // Spec is a Lock specification. + Spec LockSpecV2 `protobuf:"bytes,5,opt,name=Spec,proto3" json:"spec"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LockV2) Reset() { *m = LockV2{} } +func (m *LockV2) String() string { return proto.CompactTextString(m) } +func (*LockV2) ProtoMessage() {} +func (*LockV2) Descriptor() ([]byte, []int) { + return fileDescriptor_d938547f84707355, []int{130} +} +func (m *LockV2) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LockV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LockV2.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 *LockV2) XXX_Merge(src proto.Message) { + xxx_messageInfo_LockV2.Merge(m, src) +} +func (m *LockV2) XXX_Size() int { + return m.Size() +} +func (m *LockV2) XXX_DiscardUnknown() { + xxx_messageInfo_LockV2.DiscardUnknown(m) +} + +var xxx_messageInfo_LockV2 proto.InternalMessageInfo + +// LockSpecV2 is a Lock specification. +type LockSpecV2 struct { + // Target describes the set of interactions that the lock applies to. + Target LockTarget `protobuf:"bytes,1,opt,name=Target,proto3" json:"target"` + // Message is the message displayed to locked-out users. + Message string `protobuf:"bytes,2,opt,name=Message,proto3" json:"message,omitempty"` + // Expires if set specifies when the lock ceases to be in force. + Expires *time.Time `protobuf:"bytes,3,opt,name=Expires,proto3,stdtime" json:"expires,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LockSpecV2) Reset() { *m = LockSpecV2{} } +func (m *LockSpecV2) String() string { return proto.CompactTextString(m) } +func (*LockSpecV2) ProtoMessage() {} +func (*LockSpecV2) Descriptor() ([]byte, []int) { + return fileDescriptor_d938547f84707355, []int{131} +} +func (m *LockSpecV2) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LockSpecV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LockSpecV2.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 *LockSpecV2) XXX_Merge(src proto.Message) { + xxx_messageInfo_LockSpecV2.Merge(m, src) +} +func (m *LockSpecV2) XXX_Size() int { + return m.Size() +} +func (m *LockSpecV2) XXX_DiscardUnknown() { + xxx_messageInfo_LockSpecV2.DiscardUnknown(m) +} + +var xxx_messageInfo_LockSpecV2 proto.InternalMessageInfo + +// LockTarget lists the attributes of interactions to be disabled. +type LockTarget struct { + // User specifies the name of a Teleport user. + User string `protobuf:"bytes,1,opt,name=User,proto3" json:"user,omitempty"` + // Role specifies the name of an RBAC role known to the root cluster. + // In remote clusters, this constraint is evaluated before translating to local roles. + Role string `protobuf:"bytes,2,opt,name=Role,proto3" json:"role,omitempty"` + // Cluster specifies the name of a leaf Teleport cluster. + // This prevents the root cluster's users from connecting to nodes in the leaf cluster + // but does not prevent the leaf cluster from heartbeating back to the root cluster. + Cluster string `protobuf:"bytes,3,opt,name=Cluster,proto3" json:"cluster,omitempty"` + // Login specifies the name of a local UNIX user. + Login string `protobuf:"bytes,4,opt,name=Login,proto3" json:"login,omitempty"` + // Node specifies the name or UUID of a node. + // A matching node is also unregistered and prevented from registering. + Node string `protobuf:"bytes,5,opt,name=Node,proto3" json:"node,omitempty"` + // MFADevice specifies the UUID of a user MFA device. + MFADevice string `protobuf:"bytes,6,opt,name=MFADevice,proto3" json:"mfa_device,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LockTarget) Reset() { *m = LockTarget{} } +func (m *LockTarget) String() string { return proto.CompactTextString(m) } +func (*LockTarget) ProtoMessage() {} +func (*LockTarget) Descriptor() ([]byte, []int) { + return fileDescriptor_d938547f84707355, []int{132} +} +func (m *LockTarget) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LockTarget) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LockTarget.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 *LockTarget) XXX_Merge(src proto.Message) { + xxx_messageInfo_LockTarget.Merge(m, src) +} +func (m *LockTarget) XXX_Size() int { + return m.Size() +} +func (m *LockTarget) XXX_DiscardUnknown() { + xxx_messageInfo_LockTarget.DiscardUnknown(m) +} + +var xxx_messageInfo_LockTarget proto.InternalMessageInfo + func init() { proto.RegisterEnum("types.PrivateKeyType", PrivateKeyType_name, PrivateKeyType_value) proto.RegisterEnum("types.RequestState", RequestState_name, RequestState_value) @@ -6745,269 +6897,272 @@ func init() { proto.RegisterType((*TrustedClusterV2)(nil), "types.TrustedClusterV2") proto.RegisterType((*TrustedClusterV2List)(nil), "types.TrustedClusterV2List") proto.RegisterType((*TrustedClusterSpecV2)(nil), "types.TrustedClusterSpecV2") + proto.RegisterType((*LockV2)(nil), "types.LockV2") + proto.RegisterType((*LockSpecV2)(nil), "types.LockSpecV2") + proto.RegisterType((*LockTarget)(nil), "types.LockTarget") } func init() { proto.RegisterFile("types.proto", fileDescriptor_d938547f84707355) } var fileDescriptor_d938547f84707355 = []byte{ - // 8692 bytes of a gzipped FileDescriptorProto + // 8846 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x7d, 0x6d, 0x6c, 0x1c, 0xc9, - 0x95, 0x98, 0x7a, 0x66, 0x48, 0xce, 0x3c, 0x7e, 0x68, 0x54, 0xd4, 0x07, 0xc5, 0xd5, 0xee, 0x68, - 0x7b, 0x77, 0xb5, 0xd2, 0xde, 0x2e, 0x65, 0x71, 0xbd, 0xeb, 0x5b, 0xef, 0x97, 0x67, 0x48, 0x4a, - 0xe2, 0x8a, 0x12, 0xb9, 0x3d, 0x14, 0x65, 0x9f, 0xbd, 0x9e, 0xf4, 0x4c, 0x17, 0xc9, 0x36, 0x67, - 0xa6, 0xdb, 0xdd, 0x3d, 0x94, 0x98, 0x5c, 0x70, 0x97, 0x04, 0xce, 0xe1, 0x70, 0x38, 0x3b, 0x0e, - 0xce, 0x38, 0x1f, 0x92, 0x20, 0x07, 0x03, 0xc1, 0x1d, 0x92, 0x38, 0x3f, 0x92, 0x00, 0x41, 0x02, - 0x04, 0x41, 0x82, 0x20, 0x58, 0x04, 0xf9, 0xe1, 0x7f, 0x41, 0x0e, 0xc9, 0x24, 0xe7, 0xbb, 0x3f, - 0x21, 0xf2, 0x27, 0x40, 0xfe, 0xc4, 0xc8, 0x01, 0x41, 0xbd, 0xaa, 0xea, 0xae, 0xea, 0xe9, 0x21, - 0x87, 0xbb, 0x5a, 0xc0, 0xd4, 0x2f, 0x72, 0x5e, 0xbd, 0xf7, 0xaa, 0xea, 0xd5, 0xab, 0x57, 0xaf, - 0x5e, 0xbd, 0xaa, 0x86, 0xc9, 0xe8, 0xc0, 0xa7, 0xe1, 0x82, 0x1f, 0x78, 0x91, 0x47, 0xc6, 0xf0, - 0xc7, 0xfc, 0xf9, 0x1d, 0x6f, 0xc7, 0x43, 0xc8, 0x4d, 0xf6, 0x1f, 0x2f, 0x9c, 0xaf, 0xec, 0x78, - 0xde, 0x4e, 0x9b, 0xde, 0xc4, 0x5f, 0xcd, 0xde, 0xf6, 0xcd, 0xc8, 0xed, 0xd0, 0x30, 0xb2, 0x3b, - 0xbe, 0x40, 0x58, 0xda, 0x71, 0xa3, 0xdd, 0x5e, 0x73, 0xa1, 0xe5, 0x75, 0x6e, 0xee, 0x04, 0xf6, - 0xbe, 0x1b, 0xd9, 0x91, 0xeb, 0x75, 0xed, 0xf6, 0xcd, 0x88, 0xb6, 0xa9, 0xef, 0x05, 0xd1, 0x4d, - 0xdb, 0x77, 0x6f, 0x62, 0x1d, 0x37, 0x1f, 0x07, 0xb6, 0xef, 0xd3, 0x20, 0xf9, 0x87, 0x33, 0x31, - 0xff, 0x5f, 0x0e, 0x4a, 0xf7, 0x28, 0xf5, 0xab, 0x6d, 0x77, 0x9f, 0x92, 0x97, 0xa0, 0xf0, 0xc0, - 0xee, 0xd0, 0x39, 0xe3, 0xaa, 0x71, 0xbd, 0x54, 0x3b, 0x7b, 0xd8, 0xaf, 0x4c, 0x86, 0x34, 0xd8, - 0xa7, 0x41, 0xa3, 0x6b, 0x77, 0xa8, 0x85, 0x85, 0xe4, 0x57, 0xa0, 0xc4, 0xfe, 0x86, 0xbe, 0xdd, - 0xa2, 0x73, 0x39, 0xc4, 0x9c, 0x3e, 0xec, 0x57, 0x4a, 0x5d, 0x09, 0xb4, 0x92, 0x72, 0x72, 0x0d, - 0x26, 0xd6, 0xa8, 0x1d, 0xd2, 0xd5, 0xe5, 0xb9, 0xfc, 0x55, 0xe3, 0x7a, 0xbe, 0x36, 0x75, 0xd8, - 0xaf, 0x14, 0xdb, 0x0c, 0xd4, 0x70, 0x1d, 0x4b, 0x16, 0x92, 0x55, 0x98, 0x58, 0x79, 0xe2, 0xbb, - 0x01, 0x0d, 0xe7, 0x0a, 0x57, 0x8d, 0xeb, 0x93, 0x8b, 0xf3, 0x0b, 0xbc, 0xff, 0x0b, 0xb2, 0xff, - 0x0b, 0x9b, 0xb2, 0xff, 0xb5, 0xd9, 0x4f, 0xfb, 0x95, 0x33, 0x87, 0xfd, 0xca, 0x04, 0xe5, 0x24, - 0x7f, 0xeb, 0xbf, 0x57, 0x0c, 0x4b, 0xd2, 0x93, 0xf7, 0xa0, 0xb0, 0x79, 0xe0, 0xd3, 0xb9, 0xd2, - 0x55, 0xe3, 0xfa, 0xcc, 0xe2, 0x0b, 0x0b, 0x5c, 0xe2, 0x71, 0x27, 0x93, 0xff, 0x18, 0x56, 0xad, - 0x78, 0xd8, 0xaf, 0x14, 0x18, 0x8a, 0x85, 0x54, 0xe4, 0x0d, 0x18, 0xbf, 0xeb, 0x85, 0xd1, 0xea, - 0xf2, 0x1c, 0x60, 0xd7, 0x2e, 0x1c, 0xf6, 0x2b, 0xe7, 0x76, 0xbd, 0x30, 0x6a, 0xb8, 0xce, 0xeb, - 0x5e, 0xc7, 0x8d, 0x68, 0xc7, 0x8f, 0x0e, 0x2c, 0x81, 0x64, 0xbe, 0x0f, 0xd3, 0x1a, 0x3f, 0x32, - 0x09, 0x13, 0x0f, 0x1f, 0xdc, 0x7b, 0xb0, 0xfe, 0xe8, 0x41, 0xf9, 0x0c, 0x29, 0x42, 0xe1, 0xc1, - 0xfa, 0xf2, 0x4a, 0xd9, 0x20, 0x13, 0x90, 0xaf, 0x6e, 0x6c, 0x94, 0x73, 0x64, 0x0a, 0x8a, 0xcb, - 0xd5, 0xcd, 0x6a, 0xad, 0x5a, 0x5f, 0x29, 0xe7, 0xcd, 0xdf, 0xca, 0x43, 0xf1, 0x3e, 0x8d, 0x6c, - 0xc7, 0x8e, 0x6c, 0x72, 0x45, 0x93, 0x3e, 0x36, 0x4c, 0x11, 0xfb, 0x4b, 0x83, 0x62, 0x1f, 0x3b, - 0xec, 0x57, 0x8c, 0x37, 0x54, 0x71, 0xbf, 0x0b, 0x93, 0xcb, 0x34, 0x6c, 0x05, 0xae, 0xcf, 0x54, - 0x01, 0x45, 0x5e, 0xaa, 0x5d, 0x3e, 0xec, 0x57, 0x2e, 0x38, 0x09, 0x58, 0xe9, 0x86, 0x8a, 0x4d, - 0x56, 0x61, 0x7c, 0xcd, 0x6e, 0xd2, 0x76, 0x38, 0x37, 0x76, 0x35, 0x7f, 0x7d, 0x72, 0xf1, 0x39, - 0x21, 0x3a, 0xd9, 0xc0, 0x05, 0x5e, 0xba, 0xd2, 0x8d, 0x82, 0x83, 0xda, 0xf9, 0xc3, 0x7e, 0xa5, - 0xdc, 0x46, 0x80, 0x2a, 0x16, 0x8e, 0x42, 0xea, 0xc9, 0x70, 0x8e, 0x1f, 0x3b, 0x9c, 0xcf, 0x7f, - 0xda, 0xaf, 0x18, 0x4c, 0xcc, 0x62, 0x38, 0x13, 0x7e, 0xfa, 0xc0, 0x5e, 0x85, 0xdc, 0xea, 0xf2, - 0xdc, 0x04, 0xaa, 0x51, 0xf9, 0xb0, 0x5f, 0x99, 0xd2, 0x46, 0x24, 0xb7, 0xba, 0x3c, 0xff, 0x0e, - 0x4c, 0x2a, 0x6d, 0x24, 0x65, 0xc8, 0xef, 0xd1, 0x03, 0x2e, 0x4f, 0x8b, 0xfd, 0x4b, 0xce, 0xc3, - 0xd8, 0xbe, 0xdd, 0xee, 0x09, 0x01, 0x5a, 0xfc, 0xc7, 0x57, 0x73, 0xbf, 0x6a, 0x98, 0x7f, 0xbb, - 0x00, 0x45, 0xcb, 0xe3, 0x53, 0x88, 0xdc, 0x80, 0xb1, 0x7a, 0x64, 0x47, 0x72, 0x28, 0x66, 0x0f, - 0xfb, 0x95, 0xb3, 0x21, 0x03, 0x28, 0xf5, 0x71, 0x0c, 0x86, 0xba, 0xb1, 0x6b, 0x87, 0x72, 0x48, - 0x10, 0xd5, 0x67, 0x00, 0x15, 0x15, 0x31, 0xc8, 0x35, 0x28, 0xdc, 0xf7, 0x1c, 0x2a, 0x46, 0x85, - 0x1c, 0xf6, 0x2b, 0x33, 0x1d, 0xcf, 0x51, 0x11, 0xb1, 0x9c, 0xbc, 0x0e, 0xa5, 0xa5, 0x5e, 0x10, - 0xd0, 0x2e, 0xd3, 0xc2, 0x02, 0x22, 0xcf, 0x1c, 0xf6, 0x2b, 0xd0, 0xe2, 0x40, 0x36, 0x6f, 0x12, - 0x04, 0x26, 0xea, 0x7a, 0x64, 0x07, 0x11, 0x75, 0xe6, 0xc6, 0x46, 0x12, 0x35, 0x9b, 0x39, 0xe7, - 0x42, 0x4e, 0x92, 0x16, 0xb5, 0xe0, 0x44, 0xee, 0xc2, 0xe4, 0x9d, 0xc0, 0x6e, 0xd1, 0x0d, 0x1a, - 0xb8, 0x9e, 0x83, 0x63, 0x98, 0xaf, 0x5d, 0x3b, 0xec, 0x57, 0x2e, 0xee, 0x30, 0x70, 0xc3, 0x47, - 0x78, 0x42, 0xfd, 0x8b, 0x7e, 0xa5, 0xb8, 0xdc, 0x0b, 0x50, 0x7a, 0x96, 0x4a, 0x4a, 0xfe, 0x12, - 0x1b, 0x92, 0x30, 0x42, 0xd1, 0x52, 0x07, 0x47, 0xef, 0xe8, 0x26, 0x9a, 0xa2, 0x89, 0x17, 0xdb, - 0x76, 0x18, 0x35, 0x02, 0x4e, 0x97, 0x6a, 0xa7, 0xca, 0x92, 0xac, 0x43, 0xb1, 0xde, 0xda, 0xa5, - 0x4e, 0xaf, 0x4d, 0xe7, 0x8a, 0xc8, 0xfe, 0x92, 0x50, 0x5c, 0x39, 0x9e, 0xb2, 0xb8, 0x36, 0x2f, - 0x78, 0x93, 0x50, 0x40, 0x14, 0xd9, 0xc7, 0x4c, 0xbe, 0x5a, 0xfc, 0xf1, 0x1f, 0x56, 0xce, 0xfc, - 0xe6, 0x7f, 0xbd, 0x7a, 0xc6, 0xfc, 0x17, 0x39, 0x28, 0xa7, 0x99, 0x90, 0x6d, 0x98, 0x7e, 0xe8, - 0x3b, 0x76, 0x44, 0x97, 0xda, 0x2e, 0xed, 0x46, 0x21, 0x2a, 0xc9, 0xd1, 0x7d, 0x7a, 0x59, 0xd4, - 0x3b, 0xd7, 0x43, 0xc2, 0x46, 0x8b, 0x53, 0xa6, 0x7a, 0xa5, 0xb3, 0x4d, 0xea, 0xa9, 0xa3, 0x09, - 0x0e, 0x51, 0xc3, 0x4e, 0x56, 0x0f, 0x37, 0xde, 0x43, 0xea, 0x11, 0x6c, 0x85, 0x02, 0x75, 0x9d, - 0xe6, 0x01, 0x6a, 0xe6, 0xe8, 0x0a, 0xc4, 0x48, 0x32, 0x14, 0x88, 0x81, 0xcd, 0x3f, 0x37, 0x60, - 0xc6, 0xa2, 0xa1, 0xd7, 0x0b, 0x5a, 0xf4, 0x2e, 0xb5, 0x1d, 0x1a, 0x30, 0xf5, 0xbf, 0xe7, 0x76, - 0x1d, 0x31, 0xa7, 0x50, 0xfd, 0xf7, 0xdc, 0xae, 0x3a, 0x85, 0xb1, 0x9c, 0x7c, 0x09, 0x26, 0xea, - 0xbd, 0x26, 0xa2, 0xf2, 0x39, 0x75, 0x11, 0x47, 0xac, 0xd7, 0x6c, 0xa4, 0xd0, 0x25, 0x1a, 0xb9, - 0x09, 0x13, 0x5b, 0x34, 0x08, 0x13, 0x8b, 0x87, 0x46, 0x7b, 0x9f, 0x83, 0x54, 0x02, 0x81, 0x45, - 0xee, 0x24, 0x56, 0x57, 0x2c, 0x37, 0x67, 0x53, 0xb6, 0x2e, 0x51, 0x95, 0x8e, 0x80, 0xa8, 0xaa, - 0x22, 0xb1, 0xcc, 0x1f, 0xe6, 0xa0, 0xbc, 0x6c, 0x47, 0x76, 0xd3, 0x0e, 0x85, 0x3c, 0xb7, 0xde, - 0x64, 0x76, 0x5c, 0xe9, 0x28, 0xda, 0x71, 0xd6, 0xf2, 0xcf, 0xdc, 0xbd, 0x57, 0xd2, 0xdd, 0x9b, - 0x64, 0x6b, 0x9f, 0xe8, 0x5e, 0xd2, 0xa9, 0xf7, 0x8f, 0xef, 0x54, 0x59, 0x74, 0xaa, 0x28, 0x3b, - 0x95, 0x74, 0x85, 0xbc, 0x0f, 0x85, 0xba, 0x4f, 0x5b, 0xc2, 0x88, 0x48, 0xdb, 0xaf, 0x77, 0x8e, - 0x21, 0x6c, 0xbd, 0x59, 0x9b, 0x12, 0x6c, 0x0a, 0xa1, 0x4f, 0x5b, 0x16, 0x92, 0x29, 0x93, 0xe6, - 0xdf, 0x8c, 0xc1, 0xf9, 0x2c, 0xb2, 0xf4, 0xe2, 0x64, 0x9c, 0x68, 0x71, 0xba, 0x0e, 0xc5, 0x0d, - 0xa6, 0x8e, 0x2d, 0xaf, 0x2d, 0xe4, 0x86, 0x9e, 0x84, 0x2f, 0x60, 0x56, 0x5c, 0x4a, 0x2e, 0x43, - 0xfe, 0xa1, 0xb5, 0x2a, 0x44, 0x35, 0x71, 0xd8, 0xaf, 0xe4, 0x7b, 0x81, 0x6b, 0x31, 0x18, 0x5b, - 0xdc, 0x97, 0xaa, 0x4b, 0x34, 0x88, 0x50, 0x40, 0x53, 0x5c, 0x4f, 0x5a, 0x76, 0xa3, 0x45, 0x83, - 0x48, 0x5d, 0xc5, 0x38, 0x12, 0xb9, 0x01, 0xf9, 0xea, 0xa3, 0xba, 0x90, 0x08, 0x08, 0x89, 0x54, - 0x1f, 0xd5, 0x6b, 0x93, 0x42, 0x00, 0x79, 0xfb, 0x71, 0x68, 0x31, 0x1c, 0x75, 0x8c, 0xc6, 0x8f, - 0x18, 0xa3, 0xeb, 0x50, 0x64, 0x8e, 0x03, 0x5b, 0xd6, 0xd1, 0x14, 0x8a, 0x5e, 0xec, 0x0a, 0x98, - 0x15, 0x97, 0x92, 0x97, 0x62, 0x3f, 0xa4, 0x98, 0xf0, 0x13, 0x7e, 0x88, 0xf4, 0x3e, 0xc8, 0x3e, - 0x4c, 0x2f, 0x1f, 0x74, 0xed, 0x8e, 0xdb, 0x12, 0x0b, 0x77, 0x09, 0x17, 0xee, 0x85, 0x23, 0x06, - 0x6f, 0x41, 0x23, 0xe0, 0x6b, 0xf9, 0x55, 0x69, 0x36, 0x1c, 0x5e, 0xd6, 0x18, 0x58, 0xd7, 0xf5, - 0x6a, 0xd8, 0xfc, 0x91, 0x66, 0x11, 0xdd, 0xa4, 0x44, 0xd5, 0x24, 0x38, 0x99, 0x3f, 0x81, 0x80, - 0xa8, 0xf3, 0x27, 0x5e, 0x68, 0xdf, 0x85, 0xfc, 0x9d, 0xa5, 0x8d, 0xb9, 0x49, 0xe4, 0x41, 0x04, - 0x8f, 0x3b, 0x4b, 0x1b, 0x4b, 0x6d, 0xaf, 0xe7, 0xd4, 0x3f, 0x5e, 0xab, 0x5d, 0x10, 0x6c, 0xa6, - 0x77, 0x5a, 0xbe, 0xc2, 0x81, 0x51, 0xcd, 0x3f, 0x02, 0x32, 0xd8, 0x99, 0x8c, 0x45, 0xff, 0x57, - 0xd4, 0x45, 0x7f, 0x72, 0xf1, 0x82, 0xa8, 0x66, 0xc9, 0xeb, 0x74, 0xec, 0xae, 0x83, 0xb4, 0x5b, - 0x8b, 0xaa, 0x2f, 0xf0, 0xeb, 0x38, 0xee, 0xe4, 0x75, 0x18, 0xb7, 0xe8, 0x4e, 0xa2, 0xaa, 0xe8, - 0xf2, 0x04, 0x08, 0x51, 0x95, 0x85, 0xe3, 0xa0, 0x4c, 0xa8, 0x13, 0xee, 0xba, 0xdb, 0x91, 0xa8, - 0x28, 0x96, 0x89, 0x00, 0x2b, 0x32, 0x11, 0x10, 0x4d, 0x26, 0x02, 0x66, 0xd6, 0x12, 0x46, 0xe4, - 0x6d, 0x28, 0x2d, 0xb5, 0x7b, 0x61, 0x44, 0x83, 0xd5, 0x65, 0xd1, 0x8a, 0xb9, 0xc3, 0x7e, 0xe5, - 0x7c, 0x8b, 0x03, 0x75, 0x9f, 0x34, 0x41, 0x35, 0x7f, 0xd3, 0x80, 0x49, 0x45, 0x8c, 0x8c, 0xcf, - 0x46, 0xe0, 0x7d, 0x87, 0xb6, 0x22, 0x9d, 0x8f, 0xcf, 0x81, 0x29, 0x3e, 0x31, 0x2a, 0x79, 0x07, - 0x60, 0xb5, 0xcb, 0x4c, 0x7d, 0x8b, 0x79, 0xf0, 0xb9, 0x64, 0xc6, 0xba, 0x02, 0xaa, 0x53, 0x2a, - 0xc8, 0xe6, 0x5f, 0xcb, 0x41, 0x51, 0x98, 0xc4, 0xc5, 0x53, 0x6a, 0x12, 0xdf, 0xd2, 0x4c, 0xe2, - 0xac, 0x20, 0x55, 0x66, 0xd3, 0xe2, 0x31, 0xa6, 0xf0, 0x1d, 0x98, 0x92, 0x22, 0x58, 0x73, 0x43, - 0x66, 0x50, 0x26, 0xe4, 0x62, 0x6e, 0xe0, 0x4c, 0x3d, 0xab, 0xf1, 0xdc, 0x5a, 0xb4, 0x64, 0xb9, - 0xf9, 0x83, 0x31, 0x49, 0xcb, 0x6b, 0x62, 0x22, 0xac, 0x3a, 0x4e, 0xa0, 0x8a, 0xd0, 0x76, 0x9c, - 0xc0, 0x42, 0x28, 0x1b, 0xa8, 0x8d, 0x5e, 0xb3, 0xed, 0xb6, 0x10, 0x47, 0x19, 0x28, 0x1f, 0xa1, - 0x0d, 0x86, 0xaa, 0x0e, 0x54, 0x82, 0xac, 0xd9, 0xa4, 0xfc, 0x91, 0x36, 0xe9, 0xdb, 0x50, 0x5a, - 0xea, 0x38, 0xc2, 0xd4, 0x14, 0xb0, 0x03, 0x66, 0x86, 0x50, 0x16, 0x62, 0x24, 0x6e, 0x5e, 0xae, - 0x08, 0x19, 0x9d, 0x6f, 0x75, 0x9c, 0x41, 0xd3, 0x92, 0xb0, 0xd4, 0xcc, 0xca, 0xd8, 0xe7, 0x31, - 0x2b, 0x6f, 0x43, 0xe9, 0x61, 0x48, 0x37, 0x7b, 0xdd, 0x2e, 0x6d, 0xa3, 0x3d, 0x2e, 0x72, 0x75, - 0xef, 0x85, 0xb4, 0x11, 0x21, 0x54, 0x6d, 0x40, 0x8c, 0xaa, 0xaa, 0xd5, 0xc4, 0x11, 0x6a, 0xb5, - 0x08, 0x85, 0xaa, 0xef, 0x4b, 0x6b, 0x1b, 0x2f, 0x0c, 0xbe, 0xcf, 0xbd, 0x1a, 0xdb, 0xf7, 0xd5, - 0x0e, 0x22, 0x2e, 0xa1, 0x40, 0xee, 0xf5, 0x9a, 0x34, 0xe8, 0xd2, 0x88, 0x86, 0x62, 0xa2, 0x86, - 0x73, 0x80, 0x1c, 0xe6, 0xe4, 0x1e, 0x35, 0x8d, 0x50, 0x7b, 0xee, 0xb0, 0x5f, 0xb9, 0xb4, 0xd7, - 0x6b, 0x32, 0x97, 0x91, 0x93, 0x28, 0x8c, 0x33, 0x18, 0xce, 0xd7, 0x61, 0x46, 0x97, 0xfe, 0x53, - 0xb0, 0x87, 0x1f, 0x15, 0x8a, 0xc5, 0x72, 0xc9, 0xfc, 0xbd, 0x31, 0xc8, 0x57, 0x7d, 0xff, 0x98, - 0x6d, 0xaa, 0x58, 0x7d, 0x73, 0x19, 0xab, 0xaf, 0xae, 0xa3, 0xf9, 0x93, 0xe8, 0xe8, 0x16, 0x4c, - 0xb1, 0xed, 0x56, 0xbc, 0xce, 0x71, 0xe5, 0xbb, 0x92, 0x48, 0x7e, 0x41, 0x2d, 0x3e, 0x6a, 0x87, - 0xaa, 0xf1, 0x21, 0x8d, 0xf4, 0x02, 0xca, 0x77, 0xbe, 0xcf, 0x2b, 0x8c, 0x33, 0xd6, 0xcb, 0x58, - 0x09, 0x5b, 0x5c, 0x64, 0x47, 0xac, 0x94, 0x77, 0x81, 0xac, 0x76, 0x43, 0xda, 0xea, 0x05, 0xb4, - 0xbe, 0xe7, 0xfa, 0x5b, 0x34, 0x70, 0xb7, 0x0f, 0x54, 0x95, 0x74, 0x45, 0x69, 0x23, 0xdc, 0x73, - 0xfd, 0xc6, 0x3e, 0x96, 0x5b, 0x19, 0x34, 0xe4, 0x43, 0x98, 0xb0, 0xe8, 0xe3, 0xc0, 0x8d, 0xa8, - 0xd8, 0x44, 0xcd, 0xc4, 0xcb, 0x0b, 0x42, 0xb9, 0x33, 0x13, 0xf0, 0x1f, 0xaa, 0xcd, 0x14, 0xe5, - 0x69, 0xf7, 0xab, 0x78, 0x12, 0xf7, 0x6b, 0xfe, 0x43, 0x38, 0x37, 0x20, 0xe1, 0x93, 0xec, 0xaf, - 0xbf, 0xb8, 0xc5, 0xfa, 0xaf, 0xc6, 0x72, 0x21, 0x8b, 0xb8, 0x72, 0xba, 0x01, 0x6d, 0x45, 0x68, - 0x5f, 0xc5, 0x42, 0x12, 0x08, 0x58, 0x6a, 0xb5, 0x45, 0x18, 0xf9, 0x00, 0x26, 0xf8, 0xfe, 0x84, - 0xed, 0xaf, 0xd8, 0xd8, 0x4f, 0x8b, 0x1a, 0x39, 0x54, 0xc4, 0x7f, 0x38, 0x86, 0x2a, 0x55, 0x41, - 0x64, 0xde, 0x81, 0x71, 0xb1, 0xbf, 0x39, 0x7a, 0x5e, 0x54, 0x60, 0x6c, 0x2b, 0x91, 0x4c, 0xad, - 0x74, 0xd8, 0xaf, 0xf0, 0x4e, 0x58, 0x1c, 0x6e, 0xfe, 0x8e, 0x01, 0x33, 0x7a, 0x2f, 0xc9, 0x02, - 0x8c, 0x8b, 0x0d, 0xb8, 0x81, 0x1b, 0x70, 0xd6, 0x9b, 0x71, 0xbe, 0xf5, 0xd6, 0x36, 0xdc, 0x02, - 0x8b, 0x99, 0x2f, 0xc1, 0x01, 0xfb, 0x22, 0xcc, 0x97, 0x50, 0x52, 0x4b, 0x96, 0x11, 0x93, 0xf9, - 0x35, 0x61, 0xaf, 0x1d, 0x89, 0x39, 0x08, 0x8c, 0x6d, 0x80, 0x10, 0x4b, 0x94, 0x98, 0x7d, 0x03, - 0xa0, 0x5e, 0xbf, 0x7b, 0x8f, 0x1e, 0x6c, 0xd8, 0x6e, 0x80, 0xfe, 0x03, 0xce, 0xc6, 0x7b, 0x62, - 0xb4, 0xa6, 0x84, 0xff, 0xc0, 0x67, 0xee, 0x1e, 0x3d, 0xd0, 0xfc, 0x07, 0x89, 0x8a, 0x53, 0x3e, - 0x70, 0xf7, 0xed, 0x88, 0x32, 0xc2, 0x1c, 0x12, 0xf2, 0x29, 0xcf, 0xa1, 0x29, 0x4a, 0x05, 0x99, - 0x7c, 0x02, 0x33, 0xc9, 0x2f, 0x0c, 0xe8, 0xe5, 0x31, 0xa0, 0x27, 0x35, 0x42, 0x2f, 0xac, 0xbd, - 0x70, 0xd8, 0xaf, 0xcc, 0x2b, 0x5c, 0x1b, 0x0c, 0x4b, 0x61, 0x9d, 0x62, 0x66, 0xfe, 0xc4, 0x00, - 0xd8, 0x5c, 0xab, 0xcb, 0x0e, 0x5e, 0x83, 0x02, 0xee, 0x0b, 0x78, 0xdf, 0xd0, 0x8c, 0xa7, 0x36, - 0x05, 0x58, 0x4e, 0x5e, 0x82, 0x7c, 0xd2, 0x93, 0x73, 0xcc, 0x31, 0xd5, 0x7b, 0xc0, 0x4a, 0xc9, - 0x1d, 0x98, 0x18, 0xa9, 0xcd, 0xa8, 0x9d, 0x19, 0x6d, 0x95, 0xd4, 0x38, 0x0a, 0x1f, 0x3d, 0xda, - 0x7c, 0x76, 0x47, 0xe1, 0x07, 0x39, 0x38, 0xcb, 0xe4, 0x5a, 0xed, 0x45, 0xbb, 0x5e, 0xe0, 0x46, - 0x07, 0xa7, 0xd6, 0x57, 0x7c, 0x4f, 0xf3, 0x15, 0xe7, 0xa5, 0xd9, 0x52, 0xfb, 0x36, 0x92, 0xcb, - 0xf8, 0xa7, 0x13, 0x30, 0x9b, 0x41, 0x45, 0x5e, 0x17, 0x51, 0xed, 0xc4, 0x79, 0xc7, 0xa8, 0xf5, - 0x2f, 0xfa, 0x95, 0x29, 0x89, 0xbe, 0x99, 0x44, 0xb1, 0x17, 0x61, 0x52, 0xb8, 0x04, 0x68, 0x92, - 0xb8, 0xa4, 0x30, 0x66, 0x2a, 0x77, 0x0e, 0x68, 0x9a, 0x54, 0x24, 0x52, 0x85, 0xa9, 0xa5, 0x5d, - 0xda, 0xda, 0x73, 0xbb, 0x3b, 0xf7, 0xe8, 0x41, 0x38, 0x97, 0xbf, 0x9a, 0xbf, 0x3e, 0x55, 0x7b, - 0x9e, 0x79, 0x20, 0x2d, 0x01, 0x67, 0x43, 0xaa, 0x58, 0xc1, 0x39, 0xc3, 0xd2, 0x48, 0xc8, 0x07, - 0x30, 0x59, 0x77, 0x77, 0xba, 0x92, 0x43, 0x01, 0x39, 0x5c, 0x39, 0xec, 0x57, 0x2e, 0x86, 0x1c, - 0x3c, 0xc8, 0x40, 0x25, 0x20, 0x37, 0x60, 0xcc, 0xf2, 0xda, 0x94, 0x2f, 0xc3, 0x22, 0x98, 0x1a, - 0x30, 0x80, 0x1a, 0x4c, 0x45, 0x0c, 0x72, 0x17, 0x26, 0xd8, 0x3f, 0xf7, 0x6d, 0x7f, 0x6e, 0x1c, - 0xed, 0x36, 0x89, 0x5d, 0x45, 0x84, 0xfa, 0x6e, 0x77, 0x47, 0xf5, 0x16, 0xdb, 0xb4, 0xd1, 0xb1, - 0x7d, 0x6d, 0x5d, 0xe4, 0x88, 0x64, 0x0b, 0x26, 0x13, 0x43, 0x10, 0xce, 0x4d, 0x20, 0xb7, 0x73, - 0x82, 0x5b, 0x52, 0x52, 0x7b, 0x51, 0x30, 0xbb, 0x14, 0xb5, 0x43, 0xd4, 0x6d, 0x9f, 0xe1, 0xeb, - 0x9d, 0x51, 0x18, 0x69, 0xde, 0x6c, 0x71, 0xb8, 0x37, 0x6b, 0x1c, 0xeb, 0xcd, 0x3a, 0x00, 0x42, - 0x48, 0xd5, 0xf6, 0x8e, 0x38, 0xd6, 0xb8, 0x31, 0x5c, 0xc1, 0x16, 0x12, 0x64, 0x9c, 0x93, 0x38, - 0xd3, 0xa5, 0xfc, 0xed, 0xf6, 0x8e, 0x3a, 0xd3, 0x13, 0x54, 0x26, 0x86, 0xc4, 0xd4, 0x48, 0xcf, - 0x54, 0x8a, 0x21, 0x29, 0x49, 0xc4, 0xf0, 0x9d, 0xc7, 0xd1, 0x30, 0x31, 0x28, 0x8c, 0xc8, 0x03, - 0x80, 0x6a, 0x2b, 0x72, 0xf7, 0x29, 0xaa, 0xc4, 0xa4, 0x26, 0x88, 0xa5, 0xea, 0x3d, 0x7a, 0x50, - 0xa7, 0x51, 0x1c, 0x56, 0xbc, 0x60, 0x23, 0x6a, 0x4a, 0x4d, 0x2c, 0x85, 0x03, 0xf1, 0xe1, 0x42, - 0xd5, 0x71, 0x5c, 0x7e, 0xd4, 0xb5, 0x19, 0x30, 0xfd, 0x75, 0x90, 0xf5, 0x54, 0x36, 0xeb, 0x1b, - 0x82, 0xf5, 0x8b, 0x76, 0x4c, 0xd5, 0x88, 0x38, 0x59, 0xba, 0x9a, 0x6c, 0xc6, 0xe6, 0x3a, 0xcc, - 0xe8, 0x22, 0xd5, 0x0f, 0x79, 0xa6, 0xa0, 0x68, 0xd5, 0xab, 0x8d, 0xfa, 0xdd, 0xea, 0xad, 0xb2, - 0x41, 0xca, 0x30, 0x25, 0x7e, 0x2d, 0x36, 0x16, 0xdf, 0x7a, 0xbb, 0x9c, 0xd3, 0x20, 0x6f, 0xdd, - 0x5a, 0x2c, 0xe7, 0xcd, 0x7f, 0x6a, 0x40, 0x51, 0xb6, 0x8f, 0xbc, 0x0d, 0xf9, 0x7a, 0xfd, 0xae, - 0xd8, 0x0f, 0x4a, 0x79, 0x27, 0x4b, 0x2f, 0x5f, 0x64, 0xc2, 0x70, 0x57, 0x5d, 0x64, 0xea, 0xf5, - 0xbb, 0x8c, 0x6e, 0x73, 0xad, 0x2e, 0x9c, 0x96, 0x0c, 0x75, 0x45, 0xba, 0x48, 0xf3, 0x7d, 0x19, - 0x01, 0xa3, 0xfb, 0xe8, 0xd1, 0x26, 0xce, 0xee, 0xcc, 0xf1, 0x45, 0xba, 0xef, 0x3c, 0x56, 0x97, - 0x3e, 0x46, 0x60, 0x5a, 0x30, 0xa9, 0x4c, 0x2d, 0xee, 0x44, 0x74, 0xbc, 0xf8, 0x8c, 0x44, 0x38, - 0x11, 0x0c, 0x62, 0x89, 0x12, 0xe6, 0xf3, 0xac, 0x79, 0x2d, 0xbb, 0x2d, 0xbc, 0x11, 0xf4, 0x79, - 0xda, 0x0c, 0x60, 0x71, 0xb8, 0xf9, 0x6f, 0x0d, 0x28, 0x6f, 0x04, 0xde, 0xbe, 0xcb, 0x2c, 0xf0, - 0xa6, 0xb7, 0x47, 0xbb, 0x5b, 0xb7, 0xc8, 0x1b, 0xd2, 0x08, 0x70, 0x17, 0xee, 0x12, 0xa3, 0x42, - 0x23, 0xf0, 0x8b, 0x7e, 0x05, 0xea, 0x07, 0x61, 0x44, 0x3b, 0xac, 0x5c, 0x1a, 0x02, 0xe5, 0xa8, - 0x29, 0x37, 0x7a, 0xf8, 0xfa, 0x98, 0xa3, 0xa6, 0x0a, 0x8c, 0x61, 0x73, 0xc4, 0x8a, 0x81, 0x2d, - 0x8f, 0x18, 0xc0, 0xe2, 0x70, 0xc5, 0x60, 0xff, 0x30, 0x37, 0xd0, 0x87, 0xc5, 0x67, 0x2a, 0x04, - 0xac, 0x77, 0x6e, 0xa4, 0x45, 0xec, 0x1b, 0x70, 0x3e, 0x2d, 0x12, 0x8c, 0x7f, 0x54, 0xe1, 0xac, - 0x0e, 0x97, 0x71, 0x90, 0x4b, 0x99, 0x75, 0x6d, 0x2d, 0x5a, 0x69, 0x7c, 0x73, 0x25, 0xcd, 0x5a, - 0xac, 0x8f, 0x27, 0xd3, 0x1a, 0xf3, 0x77, 0x73, 0x30, 0xc3, 0x37, 0x34, 0x9c, 0xef, 0xa9, 0x1d, - 0xb3, 0x77, 0xb5, 0x31, 0xbb, 0x2c, 0xed, 0x87, 0xd2, 0xb5, 0x91, 0x46, 0x6c, 0x17, 0xc8, 0x20, - 0x0d, 0xb1, 0xe4, 0xb6, 0x7b, 0x94, 0xc1, 0xba, 0x95, 0x04, 0x6b, 0x43, 0x24, 0x6a, 0xe0, 0x8c, - 0x09, 0x2d, 0x8d, 0x87, 0xf9, 0x3b, 0x39, 0x98, 0x56, 0xdc, 0x8e, 0x53, 0x2b, 0xf8, 0xaf, 0x6a, - 0x82, 0x97, 0x21, 0x1c, 0xa5, 0x67, 0x23, 0xc9, 0xbd, 0x07, 0xe7, 0x06, 0x48, 0xd2, 0xde, 0x9b, - 0x31, 0x8a, 0xf7, 0xf6, 0xba, 0x1a, 0x29, 0xce, 0x29, 0x87, 0xc6, 0x71, 0xa4, 0x58, 0x8d, 0x0f, - 0xa3, 0xdf, 0xcd, 0x7f, 0x2d, 0x79, 0xdd, 0x6d, 0x77, 0xe7, 0xd4, 0x1e, 0x5b, 0x0d, 0xf1, 0xbb, - 0xd5, 0xbe, 0x8d, 0x74, 0x6a, 0xf5, 0x69, 0x1e, 0x66, 0x33, 0xa8, 0x4e, 0x26, 0x57, 0xf2, 0x00, - 0xc6, 0xaa, 0x3d, 0xc7, 0x8d, 0x44, 0x4f, 0x2a, 0x7a, 0x73, 0xb0, 0x48, 0xe1, 0xbe, 0x58, 0xbb, - 0x24, 0x1c, 0xc0, 0xb3, 0x36, 0x2b, 0x52, 0xbd, 0x5c, 0xc4, 0x25, 0xdf, 0x86, 0xf2, 0x03, 0x1a, - 0x3d, 0xf6, 0x02, 0xe6, 0x62, 0x73, 0x4a, 0xe1, 0x42, 0xbd, 0x9c, 0x52, 0xb8, 0x14, 0x96, 0xa2, - 0x7c, 0xc6, 0xcf, 0x78, 0x1d, 0x67, 0xac, 0x01, 0x5e, 0xa4, 0x03, 0x17, 0xeb, 0x34, 0xc4, 0x01, - 0xa1, 0x2d, 0x2f, 0x70, 0x92, 0x5a, 0xb8, 0x37, 0xf5, 0xaa, 0xa8, 0x65, 0x8d, 0xee, 0xd8, 0xad, - 0x83, 0x6c, 0x54, 0x56, 0x55, 0xaa, 0xa2, 0x21, 0x4c, 0x89, 0x05, 0xc0, 0x9c, 0xd5, 0xdb, 0x2e, - 0x6d, 0x3b, 0xe1, 0xdc, 0xb4, 0xd6, 0x11, 0x5e, 0x85, 0x36, 0x04, 0x09, 0x6e, 0x8a, 0xbf, 0xc2, - 0xe5, 0xa3, 0x42, 0xd1, 0x28, 0xe7, 0x3e, 0x2a, 0x14, 0xf3, 0xe5, 0xc2, 0x47, 0x85, 0xe2, 0x58, - 0x79, 0x92, 0x29, 0xf7, 0xf9, 0x41, 0x89, 0x9f, 0x5a, 0x43, 0x53, 0xd5, 0x34, 0xfc, 0x58, 0x95, - 0xca, 0x50, 0x73, 0xf3, 0x7f, 0x4d, 0xc0, 0xdc, 0x30, 0x02, 0x72, 0x4d, 0xdb, 0x59, 0x62, 0xe8, - 0x23, 0xb5, 0x6b, 0xe7, 0x7b, 0xca, 0xe4, 0x38, 0x2c, 0x37, 0xc2, 0x71, 0xd8, 0x1a, 0x94, 0xb1, - 0x2a, 0xa1, 0x09, 0x61, 0x72, 0x24, 0x7b, 0xf5, 0xb0, 0x5f, 0xb9, 0x82, 0xfa, 0xde, 0x08, 0x45, - 0x61, 0xa3, 0x17, 0xb8, 0x0a, 0x8f, 0x01, 0x4a, 0xf2, 0x13, 0x03, 0x66, 0x10, 0xb8, 0xb2, 0x4f, - 0xbb, 0x11, 0x32, 0xe3, 0x92, 0xbc, 0xb8, 0x10, 0x27, 0xb4, 0xd5, 0xa3, 0xc0, 0xed, 0xee, 0x60, - 0x30, 0x2d, 0xac, 0x35, 0x99, 0x14, 0xfe, 0xa4, 0x5f, 0x79, 0xef, 0xb3, 0x24, 0xc9, 0x09, 0x56, - 0xe1, 0x61, 0xbf, 0x32, 0xcf, 0x1b, 0x4a, 0xb1, 0xda, 0x54, 0x33, 0x53, 0x2d, 0x22, 0xbf, 0x06, - 0x97, 0x56, 0xba, 0x76, 0xb3, 0x4d, 0x97, 0xbc, 0x6e, 0xe4, 0x76, 0x7b, 0x5e, 0x2f, 0xac, 0xd9, - 0xad, 0xbd, 0x9e, 0x1f, 0x8a, 0x80, 0x2f, 0xf6, 0xbc, 0x15, 0x17, 0x36, 0x9a, 0xbc, 0x54, 0x61, - 0x39, 0x8c, 0x01, 0xb9, 0x0b, 0xe7, 0x78, 0x51, 0xb5, 0x17, 0x79, 0xf5, 0x96, 0xdd, 0x76, 0xbb, - 0x3b, 0x18, 0x07, 0x2e, 0xd6, 0xe6, 0xd9, 0xfe, 0xda, 0xee, 0x45, 0x5e, 0x23, 0xe4, 0x70, 0x85, - 0xdf, 0x20, 0x11, 0x59, 0x85, 0xb3, 0x16, 0xb5, 0x9d, 0xfb, 0xf6, 0x93, 0x25, 0xdb, 0xb7, 0x5b, - 0x6e, 0x74, 0x80, 0xbb, 0xd3, 0x7c, 0xad, 0x72, 0xd8, 0xaf, 0x3c, 0x17, 0x50, 0xdb, 0x69, 0x74, - 0xec, 0x27, 0x8d, 0x96, 0x28, 0x54, 0x98, 0xa5, 0xe9, 0x62, 0x56, 0x6e, 0x37, 0x66, 0x55, 0x4a, - 0xb3, 0x72, 0xbb, 0xc3, 0x59, 0x25, 0x74, 0x92, 0xd5, 0xa6, 0x1d, 0xec, 0xd0, 0x88, 0x07, 0x4a, - 0xe1, 0xaa, 0x71, 0xdd, 0x50, 0x58, 0x45, 0x58, 0xd6, 0xc0, 0xa0, 0x69, 0x9a, 0x95, 0x42, 0xc7, - 0x34, 0xef, 0x51, 0xe0, 0x46, 0x54, 0xed, 0xe1, 0x24, 0x36, 0x0b, 0xe5, 0x8f, 0xa1, 0xe2, 0x61, - 0x5d, 0x1c, 0xa0, 0x4c, 0xb8, 0x29, 0x9d, 0x9c, 0x1a, 0xe0, 0x96, 0xdd, 0xcb, 0x01, 0xca, 0x98, - 0x9b, 0xda, 0xcf, 0x69, 0xec, 0xa7, 0xc2, 0x6d, 0x48, 0x47, 0x07, 0x28, 0xd1, 0xdc, 0x8d, 0x5b, - 0x65, 0xae, 0xa2, 0x11, 0x1b, 0x68, 0x74, 0x0c, 0xcc, 0x3f, 0xc8, 0xc1, 0xe5, 0x21, 0xeb, 0xc2, - 0xa9, 0xb5, 0x82, 0xb7, 0x35, 0x2b, 0x38, 0xfa, 0xea, 0x97, 0x36, 0x85, 0xff, 0x2e, 0x0f, 0xcf, - 0x1f, 0x49, 0x45, 0x3e, 0x66, 0x2e, 0x99, 0x4b, 0xbb, 0xd1, 0xaa, 0xd3, 0xa6, 0x6c, 0xeb, 0xe8, - 0xf5, 0x22, 0x11, 0x80, 0x7f, 0xe9, 0xb0, 0x5f, 0x99, 0xe5, 0xc9, 0x5b, 0x0d, 0xd7, 0x69, 0xd3, - 0x46, 0xc4, 0x8b, 0xb5, 0x68, 0xfc, 0x20, 0x35, 0x63, 0x19, 0x67, 0x89, 0xae, 0x76, 0x23, 0x1a, - 0xec, 0xdb, 0x3c, 0x8b, 0x45, 0xb0, 0xdc, 0xa3, 0xd4, 0x6f, 0xd8, 0xac, 0xb4, 0xe1, 0x8a, 0x62, - 0x9d, 0xe5, 0x00, 0x35, 0xb9, 0xad, 0xb0, 0x5c, 0xf2, 0x7a, 0xdd, 0xe8, 0xbe, 0xfd, 0x44, 0xa4, - 0xd8, 0x62, 0x4c, 0x58, 0x61, 0xd9, 0x62, 0xc5, 0x4c, 0xe3, 0xad, 0x41, 0x12, 0xf2, 0x09, 0x5c, - 0x10, 0x86, 0x96, 0x19, 0x9d, 0xc0, 0x6b, 0xcb, 0x1e, 0x17, 0x90, 0xd7, 0xab, 0x87, 0xfd, 0xca, - 0x25, 0x61, 0xa6, 0x1b, 0x2d, 0x8e, 0x91, 0xd9, 0xeb, 0x6c, 0x2e, 0x64, 0x93, 0x2d, 0x3c, 0x29, - 0x71, 0xdc, 0xa7, 0x61, 0x68, 0xef, 0x50, 0x1c, 0x4a, 0x91, 0x87, 0xa0, 0x0a, 0xb3, 0xd1, 0xe1, - 0xe5, 0xd6, 0x50, 0x4a, 0xf3, 0xf7, 0x73, 0x30, 0x97, 0xed, 0x62, 0x9c, 0x5a, 0xfd, 0x5e, 0xd1, - 0xf4, 0xfb, 0xa5, 0xf8, 0x58, 0x7d, 0x98, 0xc7, 0x35, 0x44, 0xbd, 0xff, 0x89, 0x01, 0x57, 0x8e, - 0x22, 0x62, 0xd2, 0xc1, 0x24, 0x54, 0x45, 0x3a, 0x1d, 0xcf, 0xa1, 0x22, 0xf5, 0xd4, 0x87, 0xd9, - 0x8d, 0xc0, 0x7b, 0x72, 0x80, 0x51, 0xdd, 0xf0, 0xae, 0x17, 0x46, 0x18, 0x5a, 0xe3, 0x81, 0x95, - 0xb2, 0x68, 0x54, 0xcd, 0xf3, 0xda, 0x68, 0x80, 0x6a, 0xaf, 0x33, 0xaf, 0xec, 0x4f, 0xfa, 0x15, - 0x60, 0xa0, 0x75, 0x3c, 0x29, 0x64, 0x8b, 0x91, 0xcf, 0x58, 0x34, 0x30, 0x68, 0x1c, 0x36, 0x30, - 0x67, 0x69, 0x8f, 0x1e, 0x84, 0x56, 0x16, 0x6b, 0xf3, 0xef, 0x18, 0x70, 0xf5, 0x38, 0xef, 0x92, - 0xdc, 0xd0, 0x1a, 0x8d, 0x47, 0x72, 0x52, 0x27, 0x03, 0x89, 0x2e, 0x7a, 0xb0, 0x36, 0xbc, 0x07, - 0x25, 0xbe, 0x54, 0x9e, 0xa4, 0x75, 0x3f, 0xcc, 0x31, 0x37, 0x26, 0xda, 0xdd, 0x08, 0xe8, 0x36, - 0x0d, 0x68, 0xb7, 0x45, 0x9f, 0xb1, 0xe0, 0x8e, 0xde, 0xb9, 0x91, 0xb6, 0xac, 0xff, 0xbb, 0x00, - 0xe7, 0xb3, 0xc8, 0x98, 0x5c, 0x14, 0x47, 0x32, 0x9d, 0x58, 0xff, 0x37, 0x0c, 0x98, 0xaa, 0xd3, - 0x96, 0xd7, 0x75, 0x6e, 0xdb, 0xad, 0xc8, 0x93, 0x49, 0x2a, 0x0d, 0x6e, 0x60, 0x18, 0xbc, 0xb1, - 0x8d, 0x05, 0x5a, 0x56, 0xf1, 0xd7, 0x46, 0xf3, 0xdf, 0x5a, 0x1e, 0x26, 0x1e, 0x45, 0x6c, 0xc6, - 0x24, 0x55, 0xe0, 0x81, 0x88, 0x56, 0x29, 0xa9, 0xc1, 0xf4, 0x92, 0xd7, 0xed, 0x52, 0xf6, 0xe3, - 0x41, 0x92, 0xf1, 0x72, 0xe5, 0xb0, 0x5f, 0x99, 0x6b, 0xc9, 0x02, 0x5c, 0x45, 0xd5, 0x33, 0x7d, - 0x8d, 0x84, 0xbc, 0x09, 0xf9, 0x87, 0x8b, 0xb7, 0xc5, 0x18, 0xc8, 0xec, 0x8f, 0x87, 0x8b, 0xb7, - 0x31, 0xfe, 0xc1, 0x36, 0x28, 0xd3, 0xbd, 0xc5, 0x6d, 0x35, 0x7c, 0xfa, 0x70, 0xf1, 0x36, 0x59, - 0x87, 0x73, 0x16, 0xfd, 0x6e, 0xcf, 0x0d, 0xa8, 0xd0, 0xf3, 0xfb, 0xb7, 0xab, 0x38, 0x16, 0xc5, - 0xda, 0x8b, 0x87, 0xfd, 0xca, 0xf3, 0x01, 0x2f, 0x94, 0x2e, 0x71, 0xa3, 0xb3, 0xad, 0x66, 0x9c, - 0x0e, 0xd2, 0x92, 0xdf, 0x80, 0x0b, 0xcb, 0x6e, 0x28, 0xda, 0xcc, 0xe3, 0x96, 0x0e, 0x1e, 0x61, - 0x8e, 0x0f, 0x99, 0xac, 0x5f, 0xc9, 0x9c, 0xac, 0x2f, 0x3a, 0x31, 0x93, 0x06, 0x0f, 0x8a, 0x3a, + 0x95, 0x98, 0x7a, 0x66, 0x48, 0xce, 0x3c, 0x7e, 0x68, 0x54, 0xd4, 0x07, 0xc5, 0xd5, 0xee, 0xc8, + 0xbd, 0xbb, 0x5a, 0x69, 0xbd, 0x4b, 0x59, 0x5c, 0xef, 0xfa, 0xd6, 0xfb, 0xe5, 0x19, 0x92, 0x92, + 0xb8, 0xa2, 0x44, 0x6e, 0x0f, 0x45, 0xd9, 0x67, 0xaf, 0x27, 0x3d, 0xd3, 0x45, 0xb2, 0xcd, 0x99, + 0xe9, 0x76, 0x77, 0x0f, 0x25, 0x26, 0x17, 0xdc, 0x25, 0x81, 0x73, 0x38, 0x1c, 0xce, 0x8e, 0x83, + 0x33, 0xce, 0x87, 0x24, 0xc8, 0xc1, 0x40, 0x70, 0x87, 0x24, 0xce, 0x8f, 0x24, 0x40, 0x90, 0x00, + 0x41, 0x90, 0x20, 0x08, 0x16, 0x41, 0x02, 0xf8, 0x5f, 0x90, 0x43, 0x32, 0xc9, 0xf9, 0xee, 0x4f, + 0x88, 0xfc, 0x09, 0x92, 0x3f, 0x31, 0x72, 0x40, 0x50, 0xaf, 0xaa, 0xba, 0xab, 0x7a, 0x7a, 0xc8, + 0xe1, 0xae, 0x16, 0x30, 0xf5, 0x8b, 0x9c, 0x57, 0xef, 0xbd, 0xaa, 0x7a, 0xf5, 0xea, 0xd5, 0xab, + 0x57, 0xaf, 0xaa, 0x61, 0x32, 0x3a, 0xf0, 0x69, 0xb8, 0xe0, 0x07, 0x5e, 0xe4, 0x91, 0x31, 0xfc, + 0x31, 0x7f, 0x7e, 0xc7, 0xdb, 0xf1, 0x10, 0x72, 0x93, 0xfd, 0xc7, 0x0b, 0xe7, 0x2b, 0x3b, 0x9e, + 0xb7, 0xd3, 0xa6, 0x37, 0xf1, 0x57, 0xb3, 0xb7, 0x7d, 0x33, 0x72, 0x3b, 0x34, 0x8c, 0xec, 0x8e, + 0x2f, 0x10, 0x96, 0x76, 0xdc, 0x68, 0xb7, 0xd7, 0x5c, 0x68, 0x79, 0x9d, 0x9b, 0x3b, 0x81, 0xbd, + 0xef, 0x46, 0x76, 0xe4, 0x7a, 0x5d, 0xbb, 0x7d, 0x33, 0xa2, 0x6d, 0xea, 0x7b, 0x41, 0x74, 0xd3, + 0xf6, 0xdd, 0x9b, 0x58, 0xc7, 0xcd, 0xc7, 0x81, 0xed, 0xfb, 0x34, 0x48, 0xfe, 0xe1, 0x4c, 0xcc, + 0xff, 0x97, 0x83, 0xd2, 0x3d, 0x4a, 0xfd, 0x6a, 0xdb, 0xdd, 0xa7, 0xe4, 0x45, 0x28, 0x3c, 0xb0, + 0x3b, 0x74, 0xce, 0xb8, 0x6a, 0x5c, 0x2f, 0xd5, 0xce, 0x1e, 0xf6, 0x2b, 0x93, 0x21, 0x0d, 0xf6, + 0x69, 0xd0, 0xe8, 0xda, 0x1d, 0x6a, 0x61, 0x21, 0xf9, 0x22, 0x94, 0xd8, 0xdf, 0xd0, 0xb7, 0x5b, + 0x74, 0x2e, 0x87, 0x98, 0xd3, 0x87, 0xfd, 0x4a, 0xa9, 0x2b, 0x81, 0x56, 0x52, 0x4e, 0xae, 0xc1, + 0xc4, 0x1a, 0xb5, 0x43, 0xba, 0xba, 0x3c, 0x97, 0xbf, 0x6a, 0x5c, 0xcf, 0xd7, 0xa6, 0x0e, 0xfb, + 0x95, 0x62, 0x9b, 0x81, 0x1a, 0xae, 0x63, 0xc9, 0x42, 0xb2, 0x0a, 0x13, 0x2b, 0x4f, 0x7c, 0x37, + 0xa0, 0xe1, 0x5c, 0xe1, 0xaa, 0x71, 0x7d, 0x72, 0x71, 0x7e, 0x81, 0xf7, 0x7f, 0x41, 0xf6, 0x7f, + 0x61, 0x53, 0xf6, 0xbf, 0x36, 0xfb, 0x49, 0xbf, 0x72, 0xe6, 0xb0, 0x5f, 0x99, 0xa0, 0x9c, 0xe4, + 0x6f, 0xfc, 0xb7, 0x8a, 0x61, 0x49, 0x7a, 0xf2, 0x2e, 0x14, 0x36, 0x0f, 0x7c, 0x3a, 0x57, 0xba, + 0x6a, 0x5c, 0x9f, 0x59, 0x7c, 0x61, 0x81, 0x4b, 0x3c, 0xee, 0x64, 0xf2, 0x1f, 0xc3, 0xaa, 0x15, + 0x0f, 0xfb, 0x95, 0x02, 0x43, 0xb1, 0x90, 0x8a, 0xbc, 0x0e, 0xe3, 0x77, 0xbd, 0x30, 0x5a, 0x5d, + 0x9e, 0x03, 0xec, 0xda, 0x85, 0xc3, 0x7e, 0xe5, 0xdc, 0xae, 0x17, 0x46, 0x0d, 0xd7, 0x79, 0xcd, + 0xeb, 0xb8, 0x11, 0xed, 0xf8, 0xd1, 0x81, 0x25, 0x90, 0xcc, 0xf7, 0x60, 0x5a, 0xe3, 0x47, 0x26, + 0x61, 0xe2, 0xe1, 0x83, 0x7b, 0x0f, 0xd6, 0x1f, 0x3d, 0x28, 0x9f, 0x21, 0x45, 0x28, 0x3c, 0x58, + 0x5f, 0x5e, 0x29, 0x1b, 0x64, 0x02, 0xf2, 0xd5, 0x8d, 0x8d, 0x72, 0x8e, 0x4c, 0x41, 0x71, 0xb9, + 0xba, 0x59, 0xad, 0x55, 0xeb, 0x2b, 0xe5, 0xbc, 0xf9, 0x9b, 0x79, 0x28, 0xde, 0xa7, 0x91, 0xed, + 0xd8, 0x91, 0x4d, 0xae, 0x68, 0xd2, 0xc7, 0x86, 0x29, 0x62, 0x7f, 0x71, 0x50, 0xec, 0x63, 0x87, + 0xfd, 0x8a, 0xf1, 0xba, 0x2a, 0xee, 0x77, 0x60, 0x72, 0x99, 0x86, 0xad, 0xc0, 0xf5, 0x99, 0x2a, + 0xa0, 0xc8, 0x4b, 0xb5, 0xcb, 0x87, 0xfd, 0xca, 0x05, 0x27, 0x01, 0x2b, 0xdd, 0x50, 0xb1, 0xc9, + 0x2a, 0x8c, 0xaf, 0xd9, 0x4d, 0xda, 0x0e, 0xe7, 0xc6, 0xae, 0xe6, 0xaf, 0x4f, 0x2e, 0x3e, 0x27, + 0x44, 0x27, 0x1b, 0xb8, 0xc0, 0x4b, 0x57, 0xba, 0x51, 0x70, 0x50, 0x3b, 0x7f, 0xd8, 0xaf, 0x94, + 0xdb, 0x08, 0x50, 0xc5, 0xc2, 0x51, 0x48, 0x3d, 0x19, 0xce, 0xf1, 0x63, 0x87, 0xf3, 0xf9, 0x4f, + 0xfa, 0x15, 0x83, 0x89, 0x59, 0x0c, 0x67, 0xc2, 0x4f, 0x1f, 0xd8, 0xab, 0x90, 0x5b, 0x5d, 0x9e, + 0x9b, 0x40, 0x35, 0x2a, 0x1f, 0xf6, 0x2b, 0x53, 0xda, 0x88, 0xe4, 0x56, 0x97, 0xe7, 0xdf, 0x86, + 0x49, 0xa5, 0x8d, 0xa4, 0x0c, 0xf9, 0x3d, 0x7a, 0xc0, 0xe5, 0x69, 0xb1, 0x7f, 0xc9, 0x79, 0x18, + 0xdb, 0xb7, 0xdb, 0x3d, 0x21, 0x40, 0x8b, 0xff, 0xf8, 0x6a, 0xee, 0x57, 0x0c, 0xf3, 0x6f, 0x16, + 0xa0, 0x68, 0x79, 0x7c, 0x0a, 0x91, 0x1b, 0x30, 0x56, 0x8f, 0xec, 0x48, 0x0e, 0xc5, 0xec, 0x61, + 0xbf, 0x72, 0x36, 0x64, 0x00, 0xa5, 0x3e, 0x8e, 0xc1, 0x50, 0x37, 0x76, 0xed, 0x50, 0x0e, 0x09, + 0xa2, 0xfa, 0x0c, 0xa0, 0xa2, 0x22, 0x06, 0xb9, 0x06, 0x85, 0xfb, 0x9e, 0x43, 0xc5, 0xa8, 0x90, + 0xc3, 0x7e, 0x65, 0xa6, 0xe3, 0x39, 0x2a, 0x22, 0x96, 0x93, 0xd7, 0xa0, 0xb4, 0xd4, 0x0b, 0x02, + 0xda, 0x65, 0x5a, 0x58, 0x40, 0xe4, 0x99, 0xc3, 0x7e, 0x05, 0x5a, 0x1c, 0xc8, 0xe6, 0x4d, 0x82, + 0xc0, 0x44, 0x5d, 0x8f, 0xec, 0x20, 0xa2, 0xce, 0xdc, 0xd8, 0x48, 0xa2, 0x66, 0x33, 0xe7, 0x5c, + 0xc8, 0x49, 0xd2, 0xa2, 0x16, 0x9c, 0xc8, 0x5d, 0x98, 0xbc, 0x13, 0xd8, 0x2d, 0xba, 0x41, 0x03, + 0xd7, 0x73, 0x70, 0x0c, 0xf3, 0xb5, 0x6b, 0x87, 0xfd, 0xca, 0xc5, 0x1d, 0x06, 0x6e, 0xf8, 0x08, + 0x4f, 0xa8, 0x7f, 0xd1, 0xaf, 0x14, 0x97, 0x7b, 0x01, 0x4a, 0xcf, 0x52, 0x49, 0xc9, 0x5f, 0x60, + 0x43, 0x12, 0x46, 0x28, 0x5a, 0xea, 0xe0, 0xe8, 0x1d, 0xdd, 0x44, 0x53, 0x34, 0xf1, 0x62, 0xdb, + 0x0e, 0xa3, 0x46, 0xc0, 0xe9, 0x52, 0xed, 0x54, 0x59, 0x92, 0x75, 0x28, 0xd6, 0x5b, 0xbb, 0xd4, + 0xe9, 0xb5, 0xe9, 0x5c, 0x11, 0xd9, 0x5f, 0x12, 0x8a, 0x2b, 0xc7, 0x53, 0x16, 0xd7, 0xe6, 0x05, + 0x6f, 0x12, 0x0a, 0x88, 0x22, 0xfb, 0x98, 0xc9, 0x57, 0x8b, 0x3f, 0xfe, 0x83, 0xca, 0x99, 0xdf, + 0xf8, 0x2f, 0x57, 0xcf, 0x98, 0xff, 0x2c, 0x07, 0xe5, 0x34, 0x13, 0xb2, 0x0d, 0xd3, 0x0f, 0x7d, + 0xc7, 0x8e, 0xe8, 0x52, 0xdb, 0xa5, 0xdd, 0x28, 0x44, 0x25, 0x39, 0xba, 0x4f, 0x2f, 0x89, 0x7a, + 0xe7, 0x7a, 0x48, 0xd8, 0x68, 0x71, 0xca, 0x54, 0xaf, 0x74, 0xb6, 0x49, 0x3d, 0x75, 0x34, 0xc1, + 0x21, 0x6a, 0xd8, 0xc9, 0xea, 0xe1, 0xc6, 0x7b, 0x48, 0x3d, 0x82, 0xad, 0x50, 0xa0, 0xae, 0xd3, + 0x3c, 0x40, 0xcd, 0x1c, 0x5d, 0x81, 0x18, 0x49, 0x86, 0x02, 0x31, 0xb0, 0xf9, 0x67, 0x06, 0xcc, + 0x58, 0x34, 0xf4, 0x7a, 0x41, 0x8b, 0xde, 0xa5, 0xb6, 0x43, 0x03, 0xa6, 0xfe, 0xf7, 0xdc, 0xae, + 0x23, 0xe6, 0x14, 0xaa, 0xff, 0x9e, 0xdb, 0x55, 0xa7, 0x30, 0x96, 0x93, 0x2f, 0xc1, 0x44, 0xbd, + 0xd7, 0x44, 0x54, 0x3e, 0xa7, 0x2e, 0xe2, 0x88, 0xf5, 0x9a, 0x8d, 0x14, 0xba, 0x44, 0x23, 0x37, + 0x61, 0x62, 0x8b, 0x06, 0x61, 0x62, 0xf1, 0xd0, 0x68, 0xef, 0x73, 0x90, 0x4a, 0x20, 0xb0, 0xc8, + 0x9d, 0xc4, 0xea, 0x8a, 0xe5, 0xe6, 0x6c, 0xca, 0xd6, 0x25, 0xaa, 0xd2, 0x11, 0x10, 0x55, 0x55, + 0x24, 0x96, 0xf9, 0xc3, 0x1c, 0x94, 0x97, 0xed, 0xc8, 0x6e, 0xda, 0xa1, 0x90, 0xe7, 0xd6, 0x1b, + 0xcc, 0x8e, 0x2b, 0x1d, 0x45, 0x3b, 0xce, 0x5a, 0xfe, 0xa9, 0xbb, 0xf7, 0x72, 0xba, 0x7b, 0x93, + 0x6c, 0xed, 0x13, 0xdd, 0x4b, 0x3a, 0xf5, 0xde, 0xf1, 0x9d, 0x2a, 0x8b, 0x4e, 0x15, 0x65, 0xa7, + 0x92, 0xae, 0x90, 0xf7, 0xa0, 0x50, 0xf7, 0x69, 0x4b, 0x18, 0x11, 0x69, 0xfb, 0xf5, 0xce, 0x31, + 0x84, 0xad, 0x37, 0x6a, 0x53, 0x82, 0x4d, 0x21, 0xf4, 0x69, 0xcb, 0x42, 0x32, 0x65, 0xd2, 0xfc, + 0xab, 0x31, 0x38, 0x9f, 0x45, 0x96, 0x5e, 0x9c, 0x8c, 0x13, 0x2d, 0x4e, 0xd7, 0xa1, 0xb8, 0xc1, + 0xd4, 0xb1, 0xe5, 0xb5, 0x85, 0xdc, 0xd0, 0x93, 0xf0, 0x05, 0xcc, 0x8a, 0x4b, 0xc9, 0x65, 0xc8, + 0x3f, 0xb4, 0x56, 0x85, 0xa8, 0x26, 0x0e, 0xfb, 0x95, 0x7c, 0x2f, 0x70, 0x2d, 0x06, 0x63, 0x8b, + 0xfb, 0x52, 0x75, 0x89, 0x06, 0x11, 0x0a, 0x68, 0x8a, 0xeb, 0x49, 0xcb, 0x6e, 0xb4, 0x68, 0x10, + 0xa9, 0xab, 0x18, 0x47, 0x22, 0x37, 0x20, 0x5f, 0x7d, 0x54, 0x17, 0x12, 0x01, 0x21, 0x91, 0xea, + 0xa3, 0x7a, 0x6d, 0x52, 0x08, 0x20, 0x6f, 0x3f, 0x0e, 0x2d, 0x86, 0xa3, 0x8e, 0xd1, 0xf8, 0x11, + 0x63, 0x74, 0x1d, 0x8a, 0xcc, 0x71, 0x60, 0xcb, 0x3a, 0x9a, 0x42, 0xd1, 0x8b, 0x5d, 0x01, 0xb3, + 0xe2, 0x52, 0xf2, 0x62, 0xec, 0x87, 0x14, 0x13, 0x7e, 0xc2, 0x0f, 0x91, 0xde, 0x07, 0xd9, 0x87, + 0xe9, 0xe5, 0x83, 0xae, 0xdd, 0x71, 0x5b, 0x62, 0xe1, 0x2e, 0xe1, 0xc2, 0xbd, 0x70, 0xc4, 0xe0, + 0x2d, 0x68, 0x04, 0x7c, 0x2d, 0xbf, 0x2a, 0xcd, 0x86, 0xc3, 0xcb, 0x1a, 0x03, 0xeb, 0xba, 0x5e, + 0x0d, 0x9b, 0x3f, 0xd2, 0x2c, 0xa2, 0x9b, 0x94, 0xa8, 0x9a, 0x04, 0x27, 0xf3, 0x27, 0x10, 0x10, + 0x75, 0xfe, 0xc4, 0x0b, 0xed, 0x3b, 0x90, 0xbf, 0xb3, 0xb4, 0x31, 0x37, 0x89, 0x3c, 0x88, 0xe0, + 0x71, 0x67, 0x69, 0x63, 0xa9, 0xed, 0xf5, 0x9c, 0xfa, 0x47, 0x6b, 0xb5, 0x0b, 0x82, 0xcd, 0xf4, + 0x4e, 0xcb, 0x57, 0x38, 0x30, 0xaa, 0xf9, 0x47, 0x40, 0x06, 0x3b, 0x93, 0xb1, 0xe8, 0x7f, 0x51, + 0x5d, 0xf4, 0x27, 0x17, 0x2f, 0x88, 0x6a, 0x96, 0xbc, 0x4e, 0xc7, 0xee, 0x3a, 0x48, 0xbb, 0xb5, + 0xa8, 0xfa, 0x02, 0xbf, 0x86, 0xe3, 0x4e, 0x5e, 0x83, 0x71, 0x8b, 0xee, 0x24, 0xaa, 0x8a, 0x2e, + 0x4f, 0x80, 0x10, 0x55, 0x59, 0x38, 0x0e, 0xca, 0x84, 0x3a, 0xe1, 0xae, 0xbb, 0x1d, 0x89, 0x8a, + 0x62, 0x99, 0x08, 0xb0, 0x22, 0x13, 0x01, 0xd1, 0x64, 0x22, 0x60, 0x66, 0x2d, 0x61, 0x44, 0xde, + 0x82, 0xd2, 0x52, 0xbb, 0x17, 0x46, 0x34, 0x58, 0x5d, 0x16, 0xad, 0x98, 0x3b, 0xec, 0x57, 0xce, + 0xb7, 0x38, 0x50, 0xf7, 0x49, 0x13, 0x54, 0xf3, 0x37, 0x0c, 0x98, 0x54, 0xc4, 0xc8, 0xf8, 0x6c, + 0x04, 0xde, 0x77, 0x68, 0x2b, 0xd2, 0xf9, 0xf8, 0x1c, 0x98, 0xe2, 0x13, 0xa3, 0x92, 0xb7, 0x01, + 0x56, 0xbb, 0xcc, 0xd4, 0xb7, 0x98, 0x07, 0x9f, 0x4b, 0x66, 0xac, 0x2b, 0xa0, 0x3a, 0xa5, 0x82, + 0x6c, 0xfe, 0x95, 0x1c, 0x14, 0x85, 0x49, 0x5c, 0x3c, 0xa5, 0x26, 0xf1, 0x4d, 0xcd, 0x24, 0xce, + 0x0a, 0x52, 0x65, 0x36, 0x2d, 0x1e, 0x63, 0x0a, 0xdf, 0x86, 0x29, 0x29, 0x82, 0x35, 0x37, 0x64, + 0x06, 0x65, 0x42, 0x2e, 0xe6, 0x06, 0xce, 0xd4, 0xb3, 0x1a, 0xcf, 0xad, 0x45, 0x4b, 0x96, 0x9b, + 0x3f, 0x18, 0x93, 0xb4, 0xbc, 0x26, 0x26, 0xc2, 0xaa, 0xe3, 0x04, 0xaa, 0x08, 0x6d, 0xc7, 0x09, + 0x2c, 0x84, 0xb2, 0x81, 0xda, 0xe8, 0x35, 0xdb, 0x6e, 0x0b, 0x71, 0x94, 0x81, 0xf2, 0x11, 0xda, + 0x60, 0xa8, 0xea, 0x40, 0x25, 0xc8, 0x9a, 0x4d, 0xca, 0x1f, 0x69, 0x93, 0xbe, 0x0d, 0xa5, 0xa5, + 0x8e, 0x23, 0x4c, 0x4d, 0x01, 0x3b, 0x60, 0x66, 0x08, 0x65, 0x21, 0x46, 0xe2, 0xe6, 0xe5, 0x8a, + 0x90, 0xd1, 0xf9, 0x56, 0xc7, 0x19, 0x34, 0x2d, 0x09, 0x4b, 0xcd, 0xac, 0x8c, 0x7d, 0x16, 0xb3, + 0xf2, 0x16, 0x94, 0x1e, 0x86, 0x74, 0xb3, 0xd7, 0xed, 0xd2, 0x36, 0xda, 0xe3, 0x22, 0x57, 0xf7, + 0x5e, 0x48, 0x1b, 0x11, 0x42, 0xd5, 0x06, 0xc4, 0xa8, 0xaa, 0x5a, 0x4d, 0x1c, 0xa1, 0x56, 0x8b, + 0x50, 0xa8, 0xfa, 0xbe, 0xb4, 0xb6, 0xf1, 0xc2, 0xe0, 0xfb, 0xdc, 0xab, 0xb1, 0x7d, 0x5f, 0xed, + 0x20, 0xe2, 0x12, 0x0a, 0xe4, 0x5e, 0xaf, 0x49, 0x83, 0x2e, 0x8d, 0x68, 0x28, 0x26, 0x6a, 0x38, + 0x07, 0xc8, 0x61, 0x4e, 0xee, 0x51, 0xd3, 0x08, 0xb5, 0xe7, 0x0e, 0xfb, 0x95, 0x4b, 0x7b, 0xbd, + 0x26, 0x73, 0x19, 0x39, 0x89, 0xc2, 0x38, 0x83, 0xe1, 0x7c, 0x1d, 0x66, 0x74, 0xe9, 0x3f, 0x05, + 0x7b, 0xf8, 0x61, 0xa1, 0x58, 0x2c, 0x97, 0xcc, 0xdf, 0x1d, 0x83, 0x7c, 0xd5, 0xf7, 0x8f, 0xd9, + 0xa6, 0x8a, 0xd5, 0x37, 0x97, 0xb1, 0xfa, 0xea, 0x3a, 0x9a, 0x3f, 0x89, 0x8e, 0x6e, 0xc1, 0x14, + 0xdb, 0x6e, 0xc5, 0xeb, 0x1c, 0x57, 0xbe, 0x2b, 0x89, 0xe4, 0x17, 0xd4, 0xe2, 0xa3, 0x76, 0xa8, + 0x1a, 0x1f, 0xd2, 0x48, 0x2f, 0xa0, 0x7c, 0xe7, 0xfb, 0xbc, 0xc2, 0x38, 0x63, 0xbd, 0x8c, 0x95, + 0xb0, 0xc5, 0x45, 0x76, 0xc4, 0x4a, 0x79, 0x17, 0xc8, 0x6a, 0x37, 0xa4, 0xad, 0x5e, 0x40, 0xeb, + 0x7b, 0xae, 0xbf, 0x45, 0x03, 0x77, 0xfb, 0x40, 0x55, 0x49, 0x57, 0x94, 0x36, 0xc2, 0x3d, 0xd7, + 0x6f, 0xec, 0x63, 0xb9, 0x95, 0x41, 0x43, 0x3e, 0x80, 0x09, 0x8b, 0x3e, 0x0e, 0xdc, 0x88, 0x8a, + 0x4d, 0xd4, 0x4c, 0xbc, 0xbc, 0x20, 0x94, 0x3b, 0x33, 0x01, 0xff, 0xa1, 0xda, 0x4c, 0x51, 0x9e, + 0x76, 0xbf, 0x8a, 0x27, 0x71, 0xbf, 0xe6, 0x3f, 0x80, 0x73, 0x03, 0x12, 0x3e, 0xc9, 0xfe, 0xfa, + 0xf3, 0x5b, 0xac, 0xff, 0x72, 0x2c, 0x17, 0xb2, 0x88, 0x2b, 0xa7, 0x1b, 0xd0, 0x56, 0x84, 0xf6, + 0x55, 0x2c, 0x24, 0x81, 0x80, 0xa5, 0x56, 0x5b, 0x84, 0x91, 0xf7, 0x61, 0x82, 0xef, 0x4f, 0xd8, + 0xfe, 0x8a, 0x8d, 0xfd, 0xb4, 0xa8, 0x91, 0x43, 0x45, 0xfc, 0x87, 0x63, 0xa8, 0x52, 0x15, 0x44, + 0xe6, 0x1d, 0x18, 0x17, 0xfb, 0x9b, 0xa3, 0xe7, 0x45, 0x05, 0xc6, 0xb6, 0x12, 0xc9, 0xd4, 0x4a, + 0x87, 0xfd, 0x0a, 0xef, 0x84, 0xc5, 0xe1, 0xe6, 0x6f, 0x1b, 0x30, 0xa3, 0xf7, 0x92, 0x2c, 0xc0, + 0xb8, 0xd8, 0x80, 0x1b, 0xb8, 0x01, 0x67, 0xbd, 0x19, 0xe7, 0x5b, 0x6f, 0x6d, 0xc3, 0x2d, 0xb0, + 0x98, 0xf9, 0x12, 0x1c, 0xb0, 0x2f, 0xc2, 0x7c, 0x09, 0x25, 0xb5, 0x64, 0x19, 0x31, 0x99, 0x5f, + 0x13, 0xf6, 0xda, 0x91, 0x98, 0x83, 0xc0, 0xd8, 0x06, 0x08, 0xb1, 0x44, 0x89, 0xd9, 0x37, 0x00, + 0xea, 0xf5, 0xbb, 0xf7, 0xe8, 0xc1, 0x86, 0xed, 0x06, 0xe8, 0x3f, 0xe0, 0x6c, 0xbc, 0x27, 0x46, + 0x6b, 0x4a, 0xf8, 0x0f, 0x7c, 0xe6, 0xee, 0xd1, 0x03, 0xcd, 0x7f, 0x90, 0xa8, 0x38, 0xe5, 0x03, + 0x77, 0xdf, 0x8e, 0x28, 0x23, 0xcc, 0x21, 0x21, 0x9f, 0xf2, 0x1c, 0x9a, 0xa2, 0x54, 0x90, 0xc9, + 0xc7, 0x30, 0x93, 0xfc, 0xc2, 0x80, 0x5e, 0x1e, 0x03, 0x7a, 0x52, 0x23, 0xf4, 0xc2, 0xda, 0x0b, + 0x87, 0xfd, 0xca, 0xbc, 0xc2, 0xb5, 0xc1, 0xb0, 0x14, 0xd6, 0x29, 0x66, 0xe6, 0x4f, 0x0c, 0x80, + 0xcd, 0xb5, 0xba, 0xec, 0xe0, 0x35, 0x28, 0xe0, 0xbe, 0x80, 0xf7, 0x0d, 0xcd, 0x78, 0x6a, 0x53, + 0x80, 0xe5, 0xe4, 0x45, 0xc8, 0x27, 0x3d, 0x39, 0xc7, 0x1c, 0x53, 0xbd, 0x07, 0xac, 0x94, 0xdc, + 0x81, 0x89, 0x91, 0xda, 0x8c, 0xda, 0x99, 0xd1, 0x56, 0x49, 0x8d, 0xa3, 0xf0, 0xe1, 0xa3, 0xcd, + 0x67, 0x77, 0x14, 0x7e, 0x90, 0x83, 0xb3, 0x4c, 0xae, 0xd5, 0x5e, 0xb4, 0xeb, 0x05, 0x6e, 0x74, + 0x70, 0x6a, 0x7d, 0xc5, 0x77, 0x35, 0x5f, 0x71, 0x5e, 0x9a, 0x2d, 0xb5, 0x6f, 0x23, 0xb9, 0x8c, + 0x7f, 0x32, 0x01, 0xb3, 0x19, 0x54, 0xe4, 0x35, 0x11, 0xd5, 0x4e, 0x9c, 0x77, 0x8c, 0x5a, 0xff, + 0xa2, 0x5f, 0x99, 0x92, 0xe8, 0x9b, 0x49, 0x14, 0x7b, 0x11, 0x26, 0x85, 0x4b, 0x80, 0x26, 0x89, + 0x4b, 0x0a, 0x63, 0xa6, 0x72, 0xe7, 0x80, 0xa6, 0x49, 0x45, 0x22, 0x55, 0x98, 0x5a, 0xda, 0xa5, + 0xad, 0x3d, 0xb7, 0xbb, 0x73, 0x8f, 0x1e, 0x84, 0x73, 0xf9, 0xab, 0xf9, 0xeb, 0x53, 0xb5, 0xe7, + 0x99, 0x07, 0xd2, 0x12, 0x70, 0x36, 0xa4, 0x8a, 0x15, 0x9c, 0x33, 0x2c, 0x8d, 0x84, 0xbc, 0x0f, + 0x93, 0x75, 0x77, 0xa7, 0x2b, 0x39, 0x14, 0x90, 0xc3, 0x95, 0xc3, 0x7e, 0xe5, 0x62, 0xc8, 0xc1, + 0x83, 0x0c, 0x54, 0x02, 0x72, 0x03, 0xc6, 0x2c, 0xaf, 0x4d, 0xf9, 0x32, 0x2c, 0x82, 0xa9, 0x01, + 0x03, 0xa8, 0xc1, 0x54, 0xc4, 0x20, 0x77, 0x61, 0x82, 0xfd, 0x73, 0xdf, 0xf6, 0xe7, 0xc6, 0xd1, + 0x6e, 0x93, 0xd8, 0x55, 0x44, 0xa8, 0xef, 0x76, 0x77, 0x54, 0x6f, 0xb1, 0x4d, 0x1b, 0x1d, 0xdb, + 0xd7, 0xd6, 0x45, 0x8e, 0x48, 0xb6, 0x60, 0x32, 0x31, 0x04, 0xe1, 0xdc, 0x04, 0x72, 0x3b, 0x27, + 0xb8, 0x25, 0x25, 0xb5, 0x2f, 0x08, 0x66, 0x97, 0xa2, 0x76, 0x88, 0xba, 0xed, 0x33, 0x7c, 0xbd, + 0x33, 0x0a, 0x23, 0xcd, 0x9b, 0x2d, 0x0e, 0xf7, 0x66, 0x8d, 0x63, 0xbd, 0x59, 0x07, 0x40, 0x08, + 0xa9, 0xda, 0xde, 0x11, 0xc7, 0x1a, 0x37, 0x86, 0x2b, 0xd8, 0x42, 0x82, 0x8c, 0x73, 0x12, 0x67, + 0xba, 0x94, 0xbf, 0xdd, 0xde, 0x51, 0x67, 0x7a, 0x82, 0xca, 0xc4, 0x90, 0x98, 0x1a, 0xe9, 0x99, + 0x4a, 0x31, 0x24, 0x25, 0x89, 0x18, 0xbe, 0xf3, 0x38, 0x1a, 0x26, 0x06, 0x85, 0x11, 0x79, 0x00, + 0x50, 0x6d, 0x45, 0xee, 0x3e, 0x45, 0x95, 0x98, 0xd4, 0x04, 0xb1, 0x54, 0xbd, 0x47, 0x0f, 0xea, + 0x34, 0x8a, 0xc3, 0x8a, 0x17, 0x6c, 0x44, 0x4d, 0xa9, 0x89, 0xa5, 0x70, 0x20, 0x3e, 0x5c, 0xa8, + 0x3a, 0x8e, 0xcb, 0x8f, 0xba, 0x36, 0x03, 0xa6, 0xbf, 0x0e, 0xb2, 0x9e, 0xca, 0x66, 0x7d, 0x43, + 0xb0, 0xfe, 0x82, 0x1d, 0x53, 0x35, 0x22, 0x4e, 0x96, 0xae, 0x26, 0x9b, 0xb1, 0xb9, 0x0e, 0x33, + 0xba, 0x48, 0xf5, 0x43, 0x9e, 0x29, 0x28, 0x5a, 0xf5, 0x6a, 0xa3, 0x7e, 0xb7, 0x7a, 0xab, 0x6c, + 0x90, 0x32, 0x4c, 0x89, 0x5f, 0x8b, 0x8d, 0xc5, 0x37, 0xdf, 0x2a, 0xe7, 0x34, 0xc8, 0x9b, 0xb7, + 0x16, 0xcb, 0x79, 0xf3, 0x1f, 0x1b, 0x50, 0x94, 0xed, 0x23, 0x6f, 0x41, 0xbe, 0x5e, 0xbf, 0x2b, + 0xf6, 0x83, 0x52, 0xde, 0xc9, 0xd2, 0xcb, 0x17, 0x99, 0x30, 0xdc, 0x55, 0x17, 0x99, 0x7a, 0xfd, + 0x2e, 0xa3, 0xdb, 0x5c, 0xab, 0x0b, 0xa7, 0x25, 0x43, 0x5d, 0x91, 0x2e, 0xd2, 0x7c, 0x5f, 0x46, + 0xc0, 0xe8, 0x3e, 0x7c, 0xb4, 0x89, 0xb3, 0x3b, 0x73, 0x7c, 0x91, 0xee, 0x3b, 0x8f, 0xd5, 0xa5, + 0x8f, 0x11, 0x98, 0x16, 0x4c, 0x2a, 0x53, 0x8b, 0x3b, 0x11, 0x1d, 0x2f, 0x3e, 0x23, 0x11, 0x4e, + 0x04, 0x83, 0x58, 0xa2, 0x84, 0xf9, 0x3c, 0x6b, 0x5e, 0xcb, 0x6e, 0x0b, 0x6f, 0x04, 0x7d, 0x9e, + 0x36, 0x03, 0x58, 0x1c, 0x6e, 0xfe, 0x6b, 0x03, 0xca, 0x1b, 0x81, 0xb7, 0xef, 0x32, 0x0b, 0xbc, + 0xe9, 0xed, 0xd1, 0xee, 0xd6, 0x2d, 0xf2, 0xba, 0x34, 0x02, 0xdc, 0x85, 0xbb, 0xc4, 0xa8, 0xd0, + 0x08, 0xfc, 0xa2, 0x5f, 0x81, 0xfa, 0x41, 0x18, 0xd1, 0x0e, 0x2b, 0x97, 0x86, 0x40, 0x39, 0x6a, + 0xca, 0x8d, 0x1e, 0xbe, 0x3e, 0xe6, 0xa8, 0xa9, 0x02, 0x63, 0xd8, 0x1c, 0xb1, 0x62, 0x60, 0xcb, + 0x23, 0x06, 0xb0, 0x38, 0x5c, 0x31, 0xd8, 0x3f, 0xcc, 0x0d, 0xf4, 0x61, 0xf1, 0x99, 0x0a, 0x01, + 0xeb, 0x9d, 0x1b, 0x69, 0x11, 0xfb, 0x06, 0x9c, 0x4f, 0x8b, 0x04, 0xe3, 0x1f, 0x55, 0x38, 0xab, + 0xc3, 0x65, 0x1c, 0xe4, 0x52, 0x66, 0x5d, 0x5b, 0x8b, 0x56, 0x1a, 0xdf, 0x5c, 0x49, 0xb3, 0x16, + 0xeb, 0xe3, 0xc9, 0xb4, 0xc6, 0xfc, 0x9d, 0x1c, 0xcc, 0xf0, 0x0d, 0x0d, 0xe7, 0x7b, 0x6a, 0xc7, + 0xec, 0x1d, 0x6d, 0xcc, 0x2e, 0x4b, 0xfb, 0xa1, 0x74, 0x6d, 0xa4, 0x11, 0xdb, 0x05, 0x32, 0x48, + 0x43, 0x2c, 0xb9, 0xed, 0x1e, 0x65, 0xb0, 0x6e, 0x25, 0xc1, 0xda, 0x10, 0x89, 0x1a, 0x38, 0x63, + 0x42, 0x4b, 0xe3, 0x61, 0xfe, 0x76, 0x0e, 0xa6, 0x15, 0xb7, 0xe3, 0xd4, 0x0a, 0xfe, 0xab, 0x9a, + 0xe0, 0x65, 0x08, 0x47, 0xe9, 0xd9, 0x48, 0x72, 0xef, 0xc1, 0xb9, 0x01, 0x92, 0xb4, 0xf7, 0x66, + 0x8c, 0xe2, 0xbd, 0xbd, 0xa6, 0x46, 0x8a, 0x73, 0xca, 0xa1, 0x71, 0x1c, 0x29, 0x56, 0xe3, 0xc3, + 0xe8, 0x77, 0xf3, 0x5f, 0x4b, 0x5e, 0x77, 0xdb, 0xdd, 0x39, 0xb5, 0xc7, 0x56, 0x43, 0xfc, 0x6e, + 0xb5, 0x6f, 0x23, 0x9d, 0x5a, 0x7d, 0x92, 0x87, 0xd9, 0x0c, 0xaa, 0x93, 0xc9, 0x95, 0x3c, 0x80, + 0xb1, 0x6a, 0xcf, 0x71, 0x23, 0xd1, 0x93, 0x8a, 0xde, 0x1c, 0x2c, 0x52, 0xb8, 0x2f, 0xd6, 0x2e, + 0x09, 0x07, 0xf0, 0xac, 0xcd, 0x8a, 0x54, 0x2f, 0x17, 0x71, 0xc9, 0xb7, 0xa1, 0xfc, 0x80, 0x46, + 0x8f, 0xbd, 0x80, 0xb9, 0xd8, 0x9c, 0x52, 0xb8, 0x50, 0x2f, 0xa5, 0x14, 0x2e, 0x85, 0xa5, 0x28, + 0x9f, 0xf1, 0x33, 0x5e, 0xc7, 0x19, 0x6b, 0x80, 0x17, 0xe9, 0xc0, 0xc5, 0x3a, 0x0d, 0x71, 0x40, + 0x68, 0xcb, 0x0b, 0x9c, 0xa4, 0x16, 0xee, 0x4d, 0xbd, 0x22, 0x6a, 0x59, 0xa3, 0x3b, 0x76, 0xeb, + 0x20, 0x1b, 0x95, 0x55, 0x95, 0xaa, 0x68, 0x08, 0x53, 0x62, 0x01, 0x30, 0x67, 0xf5, 0xb6, 0x4b, + 0xdb, 0x4e, 0x38, 0x37, 0xad, 0x75, 0x84, 0x57, 0xa1, 0x0d, 0x41, 0x82, 0x9b, 0xe2, 0xaf, 0x70, + 0xf9, 0xb0, 0x50, 0x34, 0xca, 0xb9, 0x0f, 0x0b, 0xc5, 0x7c, 0xb9, 0xf0, 0x61, 0xa1, 0x38, 0x56, + 0x9e, 0x64, 0xca, 0x7d, 0x7e, 0x50, 0xe2, 0xa7, 0xd6, 0xd0, 0x54, 0x35, 0x0d, 0x3f, 0x56, 0xa5, + 0x32, 0xd4, 0xdc, 0xfc, 0x9f, 0x13, 0x30, 0x37, 0x8c, 0x80, 0x5c, 0xd3, 0x76, 0x96, 0x18, 0xfa, + 0x48, 0xed, 0xda, 0xf9, 0x9e, 0x32, 0x39, 0x0e, 0xcb, 0x8d, 0x70, 0x1c, 0xb6, 0x06, 0x65, 0xac, + 0x4a, 0x68, 0x42, 0x98, 0x1c, 0xc9, 0x5e, 0x3d, 0xec, 0x57, 0xae, 0xa0, 0xbe, 0x37, 0x42, 0x51, + 0xd8, 0xe8, 0x05, 0xae, 0xc2, 0x63, 0x80, 0x92, 0xfc, 0xc4, 0x80, 0x19, 0x04, 0xae, 0xec, 0xd3, + 0x6e, 0x84, 0xcc, 0xb8, 0x24, 0x2f, 0x2e, 0xc4, 0x09, 0x6d, 0xf5, 0x28, 0x70, 0xbb, 0x3b, 0x18, + 0x4c, 0x0b, 0x6b, 0x4d, 0x26, 0x85, 0x3f, 0xee, 0x57, 0xde, 0xfd, 0x34, 0x49, 0x72, 0x82, 0x55, + 0x78, 0xd8, 0xaf, 0xcc, 0xf3, 0x86, 0x52, 0xac, 0x36, 0xd5, 0xcc, 0x54, 0x8b, 0xc8, 0xaf, 0xc2, + 0xa5, 0x95, 0xae, 0xdd, 0x6c, 0xd3, 0x25, 0xaf, 0x1b, 0xb9, 0xdd, 0x9e, 0xd7, 0x0b, 0x6b, 0x76, + 0x6b, 0xaf, 0xe7, 0x87, 0x22, 0xe0, 0x8b, 0x3d, 0x6f, 0xc5, 0x85, 0x8d, 0x26, 0x2f, 0x55, 0x58, + 0x0e, 0x63, 0x40, 0xee, 0xc2, 0x39, 0x5e, 0x54, 0xed, 0x45, 0x5e, 0xbd, 0x65, 0xb7, 0xdd, 0xee, + 0x0e, 0xc6, 0x81, 0x8b, 0xb5, 0x79, 0xb6, 0xbf, 0xb6, 0x7b, 0x91, 0xd7, 0x08, 0x39, 0x5c, 0xe1, + 0x37, 0x48, 0x44, 0x56, 0xe1, 0xac, 0x45, 0x6d, 0xe7, 0xbe, 0xfd, 0x64, 0xc9, 0xf6, 0xed, 0x96, + 0x1b, 0x1d, 0xe0, 0xee, 0x34, 0x5f, 0xab, 0x1c, 0xf6, 0x2b, 0xcf, 0x05, 0xd4, 0x76, 0x1a, 0x1d, + 0xfb, 0x49, 0xa3, 0x25, 0x0a, 0x15, 0x66, 0x69, 0xba, 0x98, 0x95, 0xdb, 0x8d, 0x59, 0x95, 0xd2, + 0xac, 0xdc, 0xee, 0x70, 0x56, 0x09, 0x9d, 0x64, 0xb5, 0x69, 0x07, 0x3b, 0x34, 0xe2, 0x81, 0x52, + 0xb8, 0x6a, 0x5c, 0x37, 0x14, 0x56, 0x11, 0x96, 0x35, 0x30, 0x68, 0x9a, 0x66, 0xa5, 0xd0, 0x31, + 0xcd, 0x7b, 0x14, 0xb8, 0x11, 0x55, 0x7b, 0x38, 0x89, 0xcd, 0x42, 0xf9, 0x63, 0xa8, 0x78, 0x58, + 0x17, 0x07, 0x28, 0x13, 0x6e, 0x4a, 0x27, 0xa7, 0x06, 0xb8, 0x65, 0xf7, 0x72, 0x80, 0x32, 0xe6, + 0xa6, 0xf6, 0x73, 0x1a, 0xfb, 0xa9, 0x70, 0x1b, 0xd2, 0xd1, 0x01, 0x4a, 0x34, 0x77, 0xe3, 0x56, + 0x99, 0xab, 0x68, 0xc4, 0x06, 0x1a, 0x1d, 0x03, 0xf3, 0xf7, 0x73, 0x70, 0x79, 0xc8, 0xba, 0x70, + 0x6a, 0xad, 0xe0, 0x6d, 0xcd, 0x0a, 0x8e, 0xbe, 0xfa, 0xa5, 0x4d, 0xe1, 0xbf, 0xc9, 0xc3, 0xf3, + 0x47, 0x52, 0x91, 0x8f, 0x98, 0x4b, 0xe6, 0xd2, 0x6e, 0xb4, 0xea, 0xb4, 0x29, 0xdb, 0x3a, 0x7a, + 0xbd, 0x48, 0x04, 0xe0, 0x5f, 0x3c, 0xec, 0x57, 0x66, 0x79, 0xf2, 0x56, 0xc3, 0x75, 0xda, 0xb4, + 0x11, 0xf1, 0x62, 0x2d, 0x1a, 0x3f, 0x48, 0xcd, 0x58, 0xc6, 0x59, 0xa2, 0xab, 0xdd, 0x88, 0x06, + 0xfb, 0x36, 0xcf, 0x62, 0x11, 0x2c, 0xf7, 0x28, 0xf5, 0x1b, 0x36, 0x2b, 0x6d, 0xb8, 0xa2, 0x58, + 0x67, 0x39, 0x40, 0x4d, 0x6e, 0x2b, 0x2c, 0x97, 0xbc, 0x5e, 0x37, 0xba, 0x6f, 0x3f, 0x11, 0x29, + 0xb6, 0x18, 0x13, 0x56, 0x58, 0xb6, 0x58, 0x31, 0xd3, 0x78, 0x6b, 0x90, 0x84, 0x7c, 0x0c, 0x17, + 0x84, 0xa1, 0x65, 0x46, 0x27, 0xf0, 0xda, 0xb2, 0xc7, 0x05, 0xe4, 0xf5, 0xca, 0x61, 0xbf, 0x72, + 0x49, 0x98, 0xe9, 0x46, 0x8b, 0x63, 0x64, 0xf6, 0x3a, 0x9b, 0x0b, 0xd9, 0x64, 0x0b, 0x4f, 0x4a, + 0x1c, 0xf7, 0x69, 0x18, 0xda, 0x3b, 0x14, 0x87, 0x52, 0xe4, 0x21, 0xa8, 0xc2, 0x6c, 0x74, 0x78, + 0xb9, 0x35, 0x94, 0xd2, 0xfc, 0xbd, 0x1c, 0xcc, 0x65, 0xbb, 0x18, 0xa7, 0x56, 0xbf, 0x57, 0x34, + 0xfd, 0x7e, 0x31, 0x3e, 0x56, 0x1f, 0xe6, 0x71, 0x0d, 0x51, 0xef, 0x7f, 0x64, 0xc0, 0x95, 0xa3, + 0x88, 0x98, 0x74, 0x30, 0x09, 0x55, 0x91, 0x4e, 0xc7, 0x73, 0xa8, 0x48, 0x3d, 0xf5, 0x61, 0x76, + 0x23, 0xf0, 0x9e, 0x1c, 0x60, 0x54, 0x37, 0xbc, 0xeb, 0x85, 0x11, 0x86, 0xd6, 0x78, 0x60, 0xa5, + 0x2c, 0x1a, 0x55, 0xf3, 0xbc, 0x36, 0x1a, 0xa0, 0xda, 0x6b, 0xcc, 0x2b, 0xfb, 0xe3, 0x7e, 0x05, + 0x18, 0x68, 0x1d, 0x4f, 0x0a, 0xd9, 0x62, 0xe4, 0x33, 0x16, 0x0d, 0x0c, 0x1a, 0x87, 0x0d, 0xcc, + 0x59, 0xda, 0xa3, 0x07, 0xa1, 0x95, 0xc5, 0xda, 0xfc, 0x5b, 0x06, 0x5c, 0x3d, 0xce, 0xbb, 0x24, + 0x37, 0xb4, 0x46, 0xe3, 0x91, 0x9c, 0xd4, 0xc9, 0x40, 0xa2, 0x8b, 0x1e, 0xac, 0x0d, 0xef, 0x41, + 0x89, 0x2f, 0x95, 0x27, 0x69, 0xdd, 0x0f, 0x73, 0xcc, 0x8d, 0x89, 0x76, 0x37, 0x02, 0xba, 0x4d, + 0x03, 0xda, 0x6d, 0xd1, 0x67, 0x2c, 0xb8, 0xa3, 0x77, 0x6e, 0xa4, 0x2d, 0xeb, 0xff, 0x2a, 0xc0, + 0xf9, 0x2c, 0x32, 0x26, 0x17, 0xc5, 0x91, 0x4c, 0x27, 0xd6, 0xff, 0x35, 0x03, 0xa6, 0xea, 0xb4, + 0xe5, 0x75, 0x9d, 0xdb, 0x76, 0x2b, 0xf2, 0x64, 0x92, 0x4a, 0x83, 0x1b, 0x18, 0x06, 0x6f, 0x6c, + 0x63, 0x81, 0x96, 0x55, 0xfc, 0xb5, 0xd1, 0xfc, 0xb7, 0x96, 0x87, 0x89, 0x47, 0x11, 0x9b, 0x31, + 0x49, 0x15, 0x78, 0x20, 0xa2, 0x55, 0x4a, 0x6a, 0x30, 0xbd, 0xe4, 0x75, 0xbb, 0x94, 0xfd, 0x78, + 0x90, 0x64, 0xbc, 0x5c, 0x39, 0xec, 0x57, 0xe6, 0x5a, 0xb2, 0x00, 0x57, 0x51, 0xf5, 0x4c, 0x5f, + 0x23, 0x21, 0x6f, 0x40, 0xfe, 0xe1, 0xe2, 0x6d, 0x31, 0x06, 0x32, 0xfb, 0xe3, 0xe1, 0xe2, 0x6d, + 0x8c, 0x7f, 0xb0, 0x0d, 0xca, 0x74, 0x6f, 0x71, 0x5b, 0x0d, 0x9f, 0x3e, 0x5c, 0xbc, 0x4d, 0xd6, + 0xe1, 0x9c, 0x45, 0xbf, 0xdb, 0x73, 0x03, 0x2a, 0xf4, 0xfc, 0xfe, 0xed, 0x2a, 0x8e, 0x45, 0xb1, + 0xf6, 0x85, 0xc3, 0x7e, 0xe5, 0xf9, 0x80, 0x17, 0x4a, 0x97, 0xb8, 0xd1, 0xd9, 0x56, 0x33, 0x4e, + 0x07, 0x69, 0xc9, 0xaf, 0xc3, 0x85, 0x65, 0x37, 0x14, 0x6d, 0xe6, 0x71, 0x4b, 0x07, 0x8f, 0x30, + 0xc7, 0x87, 0x4c, 0xd6, 0xaf, 0x64, 0x4e, 0xd6, 0x2f, 0x38, 0x31, 0x93, 0x06, 0x0f, 0x8a, 0x3a, 0xe9, 0x74, 0xc8, 0xec, 0x7a, 0xc8, 0x77, 0x60, 0xa6, 0xda, 0x6e, 0x7b, 0x8f, 0x31, 0x94, 0xcb, 0x14, 0x42, 0xe4, 0x25, 0x0c, 0xd6, 0xfc, 0xa5, 0xcc, 0x9a, 0xe7, 0x6d, 0x46, 0xdd, 0xc0, 0x80, - 0x70, 0xc3, 0xee, 0x45, 0xbb, 0x9a, 0x6b, 0xad, 0x71, 0x36, 0xff, 0x95, 0x01, 0xcf, 0x1f, 0xb9, + 0x70, 0xc3, 0xee, 0x45, 0xbb, 0x9a, 0x6b, 0xad, 0x71, 0x36, 0xff, 0x85, 0x01, 0xcf, 0x1f, 0xb9, 0x41, 0x24, 0xdf, 0x18, 0x26, 0x0e, 0x03, 0x65, 0xcc, 0x96, 0xd9, 0x4b, 0x43, 0xba, 0xfa, 0x8b, - 0x7e, 0xa5, 0xc0, 0x5a, 0x36, 0xac, 0xa3, 0x1f, 0x0c, 0x74, 0x34, 0x87, 0x3c, 0xd9, 0xc4, 0x86, - 0xa4, 0xf9, 0x31, 0x9b, 0x74, 0xe3, 0xff, 0xa5, 0x81, 0x0a, 0x43, 0x5e, 0x83, 0xb1, 0xaa, 0xef, + 0x7e, 0xa5, 0xc0, 0x5a, 0x36, 0xac, 0xa3, 0xef, 0x0f, 0x74, 0x34, 0x87, 0x3c, 0xd9, 0xc4, 0x86, + 0xa4, 0xf9, 0x31, 0x9b, 0x74, 0xe3, 0xff, 0xb9, 0x81, 0x0a, 0x43, 0x5e, 0x85, 0xb1, 0xaa, 0xef, 0xc7, 0x09, 0x78, 0xb8, 0x7f, 0xb2, 0x7d, 0x5f, 0x4f, 0xa1, 0xe3, 0x28, 0x6c, 0xb3, 0x75, 0xdb, 0x6e, 0xd1, 0x28, 0x14, 0xb1, 0x73, 0x44, 0xde, 0x46, 0x88, 0xba, 0xd9, 0xe2, 0x38, 0xe4, 0xeb, 0x70, 0x7e, 0x99, 0xee, 0xbb, 0x2d, 0x5a, 0x8d, 0x22, 0x1a, 0xf2, 0x29, 0xb2, 0x54, 0xe5, 0x47, - 0x78, 0xa5, 0xda, 0xcb, 0x87, 0xfd, 0xca, 0x55, 0x07, 0xcb, 0x1b, 0x76, 0x82, 0xd0, 0x68, 0xd9, - 0x2a, 0xaf, 0x4c, 0x0e, 0xe6, 0xff, 0x35, 0x94, 0x6b, 0x27, 0xa7, 0xd4, 0xf2, 0xbd, 0xad, 0x59, + 0x78, 0xa5, 0xda, 0x4b, 0x87, 0xfd, 0xca, 0x55, 0x07, 0xcb, 0x1b, 0x76, 0x82, 0xd0, 0x68, 0xd9, + 0x2a, 0xaf, 0x4c, 0x0e, 0xe6, 0xff, 0x35, 0x94, 0x6b, 0x27, 0xa7, 0xd4, 0xf2, 0xbd, 0xa5, 0x59, 0xbe, 0xf3, 0x82, 0x34, 0xee, 0x55, 0x1c, 0xbf, 0x48, 0xaf, 0xa5, 0x67, 0x61, 0x5a, 0x43, 0x62, 0x7e, 0xf5, 0x79, 0x8b, 0x86, 0x34, 0xda, 0xb0, 0xc3, 0xf0, 0xb1, 0x17, 0x38, 0x3c, 0xf0, 0xf9, - 0xe6, 0x33, 0x15, 0x58, 0x18, 0xec, 0xe0, 0x48, 0xf1, 0xb3, 0x3f, 0x36, 0x60, 0x6e, 0x18, 0x29, + 0xc6, 0x33, 0x15, 0x58, 0x18, 0xec, 0xe0, 0x48, 0xf1, 0xb3, 0x3f, 0x32, 0x60, 0x6e, 0x18, 0x29, 0x93, 0xcf, 0xc3, 0x90, 0x6a, 0xb9, 0x8b, 0xbd, 0x90, 0x06, 0x16, 0x42, 0x79, 0xca, 0xd8, 0x9a, 0x9e, 0x32, 0xd6, 0xb6, 0x18, 0x8c, 0xd4, 0x61, 0x62, 0x29, 0xa0, 0x78, 0x73, 0xa4, 0x30, 0xfa, - 0xe1, 0x4e, 0x8b, 0x93, 0xa4, 0x0f, 0x77, 0x04, 0x27, 0xf3, 0x8f, 0x72, 0xf0, 0x5c, 0x46, 0x53, + 0xe1, 0x4e, 0x8b, 0x93, 0xa4, 0x0f, 0x77, 0x04, 0x27, 0xf3, 0x0f, 0x73, 0xf0, 0x5c, 0x46, 0x53, 0x69, 0x2b, 0xa0, 0x51, 0x78, 0x6a, 0x47, 0xf3, 0xae, 0x36, 0x9a, 0xd7, 0x86, 0x8f, 0x26, 0xef, - 0xe7, 0x48, 0x83, 0xfa, 0x1f, 0x0d, 0xa8, 0x1c, 0xc3, 0x81, 0xbc, 0x04, 0xe3, 0xeb, 0x9b, 0x1b, - 0x32, 0x23, 0x45, 0x74, 0xce, 0xf3, 0xd1, 0xab, 0xb2, 0x44, 0x11, 0x79, 0x03, 0xc6, 0x3f, 0xb6, + 0xe7, 0x48, 0x83, 0xfa, 0xef, 0x0d, 0xa8, 0x1c, 0xc3, 0x81, 0xbc, 0x08, 0xe3, 0xeb, 0x9b, 0x1b, + 0x32, 0x23, 0x45, 0x74, 0xce, 0xf3, 0xd1, 0xab, 0xb2, 0x44, 0x11, 0x79, 0x1d, 0xc6, 0x3f, 0xb2, 0x96, 0x98, 0x0b, 0x97, 0x4b, 0x5c, 0xb8, 0xef, 0x06, 0x8d, 0x96, 0x7e, 0xff, 0x49, 0x20, 0xa9, 0xc3, 0x9e, 0x7f, 0x6a, 0xc3, 0xfe, 0x83, 0x1c, 0x9c, 0xad, 0xb6, 0x5a, 0x34, 0x0c, 0xd9, 0x62, - 0x4a, 0xc3, 0xe8, 0x19, 0x8b, 0x79, 0x6b, 0x7d, 0x1b, 0x69, 0x78, 0xff, 0x83, 0x01, 0x17, 0x24, + 0x4a, 0xc3, 0xe8, 0x19, 0x8b, 0x79, 0x6b, 0x7d, 0x1b, 0x69, 0x78, 0xff, 0x9d, 0x01, 0x17, 0x24, 0xd5, 0xbe, 0x4b, 0x1f, 0x6f, 0xee, 0x06, 0x34, 0xdc, 0xf5, 0xda, 0x0e, 0xb9, 0xa6, 0xe5, 0xb2, 0x61, 0x4c, 0x30, 0xe5, 0x13, 0x15, 0xc4, 0xa9, 0xc3, 0xf8, 0x6d, 0xb7, 0x1d, 0xd1, 0x40, 0x8d, 0x09, 0x6e, 0x23, 0x44, 0x5b, 0xa6, 0x10, 0x42, 0x6e, 0xc2, 0x44, 0xd5, 0xf7, 0x03, 0x6f, 0x9f, @@ -7019,224 +7174,224 @@ var fileDescriptor_d938547f84707355 = []byte{ 0x8d, 0xf4, 0xad, 0x41, 0x9d, 0x0f, 0x8f, 0xa9, 0xda, 0xa1, 0xd7, 0x15, 0xf7, 0xfc, 0x44, 0x4c, 0x95, 0x41, 0xf4, 0x98, 0x2a, 0x83, 0xa8, 0xd3, 0x62, 0xec, 0x69, 0x4d, 0x0b, 0xf2, 0x23, 0x03, 0x26, 0xab, 0xdd, 0xae, 0x48, 0x36, 0x91, 0xf7, 0x35, 0x2f, 0x24, 0x71, 0x55, 0x9e, 0x8d, 0xc8, - 0xc3, 0xaa, 0xdf, 0x12, 0x61, 0xd5, 0x77, 0x3f, 0x53, 0x58, 0x75, 0x33, 0xb0, 0xdd, 0x28, 0xc4, - 0x34, 0x8f, 0xa4, 0x42, 0x35, 0xe3, 0x54, 0x69, 0x07, 0x79, 0x17, 0xca, 0xb1, 0x3e, 0xae, 0x76, + 0xc3, 0xaa, 0xdf, 0x12, 0x61, 0xd5, 0x77, 0x3e, 0x55, 0x58, 0x75, 0x33, 0xb0, 0xdd, 0x28, 0xc4, + 0x34, 0x8f, 0xa4, 0x42, 0x35, 0xe3, 0x54, 0x69, 0x07, 0x79, 0x07, 0xca, 0xb1, 0x3e, 0xae, 0x76, 0x1d, 0xfa, 0x84, 0xf2, 0xdc, 0x9c, 0x69, 0x7e, 0x2f, 0x59, 0x8b, 0x17, 0xa7, 0x11, 0xcd, 0x1f, 0x18, 0x70, 0x51, 0x55, 0x88, 0x7a, 0xaf, 0xd9, 0x71, 0xd1, 0x75, 0x26, 0x0b, 0x50, 0x12, 0xe3, 0x15, 0x7b, 0x62, 0x83, 0x97, 0x49, 0x13, 0x14, 0xb2, 0xc2, 0x86, 0x88, 0xf1, 0x10, 0xbb, 0xe0, 0xd9, 0xd4, 0x74, 0x63, 0x45, 0xb5, 0x39, 0x21, 0xec, 0x72, 0x80, 0xbf, 0xf5, 0xb1, 0x63, 0x10, - 0xf3, 0x03, 0x38, 0xa7, 0xb7, 0xb2, 0x4e, 0xf1, 0x3e, 0x80, 0xec, 0x9a, 0x91, 0xdd, 0x35, 0x59, + 0xf3, 0x7d, 0x38, 0xa7, 0xb7, 0xb2, 0x4e, 0xf1, 0x3e, 0x80, 0xec, 0x9a, 0x91, 0xdd, 0x35, 0x59, 0x6e, 0x3e, 0x02, 0x32, 0x40, 0x1f, 0xe2, 0x12, 0x4e, 0x23, 0x79, 0x30, 0x2b, 0x0f, 0x21, 0x07, - 0x10, 0xe3, 0x1b, 0xd3, 0x93, 0x5a, 0x62, 0x3a, 0x23, 0x35, 0xff, 0xa2, 0x04, 0xb3, 0x19, 0xa6, - 0xe3, 0x98, 0x35, 0xbb, 0xa2, 0x4f, 0x9e, 0x52, 0x7c, 0xdc, 0x2e, 0xa7, 0xcc, 0x07, 0xf2, 0x0a, - 0xed, 0x11, 0x53, 0xe5, 0xa8, 0x7b, 0xb5, 0x5f, 0xc4, 0xca, 0xaf, 0xe6, 0x8a, 0x8c, 0x3d, 0xb5, + 0x10, 0xe3, 0x1b, 0xd3, 0x93, 0x5a, 0x62, 0x3a, 0x23, 0x35, 0xff, 0xbc, 0x04, 0xb3, 0x19, 0xa6, + 0xe3, 0x98, 0x35, 0xbb, 0xa2, 0x4f, 0x9e, 0x52, 0x7c, 0xdc, 0x2e, 0xa7, 0xcc, 0xfb, 0xf2, 0x0a, + 0xed, 0x11, 0x53, 0xe5, 0xa8, 0x7b, 0xb5, 0x9f, 0xc7, 0xca, 0xaf, 0xe6, 0x8a, 0x8c, 0x3d, 0xb5, 0x5c, 0x91, 0x1a, 0x4c, 0x8b, 0x5e, 0x89, 0xa9, 0x3c, 0x9e, 0x6c, 0x29, 0x03, 0x5e, 0xd0, 0x18, 0x98, 0xd2, 0x3a, 0x09, 0xe7, 0x11, 0x7a, 0xed, 0x7d, 0x2a, 0x78, 0x4c, 0xa8, 0x3c, 0xb0, 0x20, - 0x93, 0x87, 0x42, 0x42, 0xfe, 0x91, 0x01, 0x44, 0x40, 0xd4, 0xf9, 0x5c, 0x3c, 0x6a, 0x3e, 0x3b, - 0x4f, 0x67, 0x3e, 0x3f, 0x2f, 0xdb, 0x98, 0x3d, 0xaf, 0x33, 0x9a, 0x45, 0xfe, 0xd8, 0x80, 0x73, + 0x93, 0x87, 0x42, 0x42, 0xfe, 0x81, 0x01, 0x44, 0x40, 0xd4, 0xf9, 0x5c, 0x3c, 0x6a, 0x3e, 0x3b, + 0x4f, 0x67, 0x3e, 0x3f, 0x2f, 0xdb, 0x98, 0x3d, 0xaf, 0x33, 0x9a, 0x45, 0xfe, 0xc8, 0x80, 0x73, 0x3c, 0x2d, 0x43, 0x6d, 0x6c, 0xe9, 0xa8, 0xc6, 0xb6, 0x9e, 0x4e, 0x63, 0xaf, 0x84, 0x58, 0xed, - 0x90, 0xb6, 0x0e, 0x36, 0x8a, 0xfc, 0x1a, 0x40, 0x3c, 0xa3, 0x64, 0x62, 0xdc, 0x95, 0x0c, 0x2b, - 0x10, 0x23, 0x25, 0x37, 0x5e, 0xa2, 0x98, 0x4e, 0xcd, 0x66, 0x4b, 0xb8, 0x91, 0xdf, 0x80, 0xf3, + 0x90, 0xb6, 0x0e, 0x36, 0x8a, 0xfc, 0x2a, 0x40, 0x3c, 0xa3, 0x64, 0x62, 0xdc, 0x95, 0x0c, 0x2b, + 0x10, 0x23, 0x25, 0x37, 0x5e, 0xa2, 0x98, 0x4e, 0xcd, 0x66, 0x4b, 0xb8, 0x91, 0x5f, 0x87, 0xf3, 0x6c, 0xbe, 0xc4, 0x10, 0x91, 0x5e, 0x35, 0x37, 0x89, 0xb5, 0x7c, 0x79, 0xf8, 0xd2, 0xbe, 0x90, 0x45, 0xc6, 0xaf, 0x27, 0xc4, 0x69, 0x18, 0x41, 0xd4, 0x51, 0x37, 0x78, 0x59, 0x14, 0x98, 0x47, 0x89, 0xad, 0x0f, 0xe7, 0xa6, 0xb0, 0xce, 0x4c, 0xfb, 0x76, 0x59, 0xce, 0x05, 0x6e, 0xdf, 0x42, - 0xfd, 0x7e, 0x01, 0x82, 0xc8, 0xc7, 0x40, 0xea, 0xbd, 0x9d, 0x1d, 0x1a, 0x46, 0xd4, 0xe1, 0x30, + 0xfd, 0x7e, 0x01, 0x82, 0xc8, 0x47, 0x40, 0xea, 0xbd, 0x9d, 0x1d, 0x1a, 0x46, 0xd4, 0xe1, 0x30, 0x1a, 0x84, 0x73, 0xd3, 0x68, 0x1f, 0x30, 0xc4, 0x11, 0xca, 0xd2, 0x46, 0x20, 0x8b, 0x55, 0x25, 0x19, 0x24, 0x9e, 0x6f, 0xc2, 0xe5, 0xa1, 0xdd, 0xcc, 0xb8, 0x3b, 0x70, 0x53, 0xbf, 0x3b, 0x70, - 0x79, 0x98, 0x39, 0x0c, 0xd5, 0xfb, 0x03, 0x7f, 0xdf, 0x48, 0xd9, 0x3f, 0xe1, 0xac, 0xf0, 0xd7, + 0x79, 0x98, 0x39, 0x0c, 0xd5, 0xfb, 0x03, 0x7f, 0xd7, 0x48, 0xd9, 0x3f, 0xe1, 0xac, 0xf0, 0xd7, 0x06, 0x86, 0x2d, 0x10, 0xb9, 0xd5, 0x65, 0xe6, 0x9d, 0xa0, 0x85, 0xcc, 0x25, 0x4e, 0x12, 0xb3, - 0x90, 0xaa, 0x85, 0x45, 0x5b, 0xf9, 0x39, 0x4d, 0xa1, 0xf9, 0xcf, 0x0d, 0x20, 0xbc, 0x85, 0x4b, + 0x90, 0xaa, 0x85, 0x45, 0x5b, 0xf9, 0x19, 0x4d, 0xa1, 0xf9, 0x4f, 0x0d, 0x20, 0xbc, 0x85, 0x4b, 0xb6, 0x6f, 0x37, 0xdd, 0xb6, 0x1b, 0xb9, 0x34, 0x24, 0xf7, 0xa0, 0x2c, 0x58, 0xd8, 0xcd, 0x36, 0x55, 0x93, 0x9f, 0xc4, 0x99, 0x59, 0x5c, 0xd6, 0x48, 0xbb, 0x35, 0x03, 0x84, 0x43, 0x06, 0x2f, - 0xf7, 0x39, 0x06, 0xcf, 0xfc, 0x33, 0x03, 0x2e, 0x0f, 0x36, 0x5b, 0xd4, 0x1c, 0x0b, 0xcf, 0x38, + 0xf7, 0x19, 0x06, 0xcf, 0xfc, 0x53, 0x03, 0x2e, 0x0f, 0x36, 0x5b, 0xd4, 0x1c, 0x0b, 0xcf, 0x38, 0x46, 0x78, 0x59, 0xbd, 0xe4, 0xe1, 0x97, 0xa7, 0xd6, 0xcb, 0x7c, 0x12, 0x85, 0x3b, 0x79, 0x2f, - 0x7f, 0x3b, 0x07, 0x53, 0x1b, 0xed, 0xde, 0x8e, 0xdb, 0x5d, 0xb6, 0x23, 0xfb, 0xd4, 0x6e, 0x29, - 0xde, 0xd1, 0xb6, 0x14, 0x71, 0x86, 0x57, 0xdc, 0xb1, 0x91, 0xf6, 0x13, 0xbf, 0x67, 0xc0, 0xd9, + 0x7f, 0x2b, 0x07, 0x53, 0x1b, 0xed, 0xde, 0x8e, 0xdb, 0x5d, 0xb6, 0x23, 0xfb, 0xd4, 0x6e, 0x29, + 0xde, 0xd6, 0xb6, 0x14, 0x71, 0x86, 0x57, 0xdc, 0xb1, 0x91, 0xf6, 0x13, 0xbf, 0x6b, 0xc0, 0xd9, 0x84, 0x84, 0xcf, 0xd2, 0xbb, 0x50, 0x60, 0x3f, 0x84, 0x87, 0x72, 0x75, 0x80, 0x31, 0x62, 0x2d, 0xc4, 0xff, 0x09, 0x27, 0x5f, 0xbf, 0x6f, 0x8f, 0x1c, 0xe6, 0xbf, 0x02, 0xa5, 0x84, 0xed, 0x49, - 0x9e, 0xf6, 0xf8, 0x67, 0x06, 0x94, 0xd3, 0x3d, 0x21, 0xf7, 0x60, 0x82, 0x71, 0x72, 0xa9, 0x74, - 0x9e, 0x5e, 0x1e, 0xd2, 0xe7, 0x05, 0x81, 0xc6, 0x9b, 0x87, 0xc2, 0xa7, 0x1c, 0x62, 0x49, 0x0e, - 0xf3, 0x16, 0x4c, 0xa9, 0x58, 0x19, 0xad, 0x7b, 0x5d, 0x37, 0x4d, 0x17, 0xb3, 0xe5, 0xa0, 0xb6, - 0xfa, 0xef, 0x6a, 0xad, 0x16, 0x46, 0x69, 0xd4, 0x37, 0x14, 0xf0, 0x26, 0x14, 0x7f, 0x7d, 0x41, + 0x9e, 0xf6, 0xf8, 0x27, 0x06, 0x94, 0xd3, 0x3d, 0x21, 0xf7, 0x60, 0x82, 0x71, 0x72, 0xa9, 0x74, + 0x9e, 0x5e, 0x1a, 0xd2, 0xe7, 0x05, 0x81, 0xc6, 0x9b, 0x87, 0xc2, 0xa7, 0x1c, 0x62, 0x49, 0x0e, + 0xf3, 0x16, 0x4c, 0xa9, 0x58, 0x19, 0xad, 0x7b, 0x4d, 0x37, 0x4d, 0x17, 0xb3, 0xe5, 0xa0, 0xb6, + 0xfa, 0x6f, 0x6b, 0xad, 0x16, 0x46, 0x69, 0xd4, 0x37, 0x14, 0xf0, 0x26, 0x14, 0x7f, 0x7d, 0x41, 0xd5, 0xb3, 0x40, 0xc0, 0xf4, 0x9b, 0x50, 0x1c, 0xc6, 0xf6, 0x22, 0xbc, 0x3e, 0xa1, 0x67, 0xb8, - 0x17, 0xf1, 0x11, 0xa2, 0xfa, 0xb3, 0x1c, 0xc7, 0xfc, 0x7b, 0x79, 0xb8, 0x98, 0x34, 0x8f, 0xbf, + 0x17, 0xf1, 0x11, 0xa2, 0xfa, 0xb3, 0x1c, 0xc7, 0xfc, 0x3b, 0x79, 0xb8, 0x98, 0x34, 0x8f, 0xbf, 0x28, 0xb1, 0x61, 0x07, 0x76, 0x27, 0x3c, 0x66, 0x06, 0x5c, 0x1f, 0x68, 0x1a, 0x5e, 0x37, 0x95, 0x4d, 0x53, 0x1a, 0x64, 0xa6, 0x1a, 0x84, 0x9b, 0x38, 0xde, 0x20, 0xd9, 0x0c, 0x72, 0x0f, 0xf2, 0x75, 0x1a, 0x89, 0xfb, 0x80, 0xd7, 0x06, 0xa4, 0xaa, 0xb6, 0x6b, 0xa1, 0x4e, 0x23, 0x3e, 0x88, 0x3c, 0xa5, 0x9a, 0x6a, 0x29, 0xce, 0xcc, 0x1d, 0x7f, 0x04, 0xe3, 0x2b, 0x4f, 0x7c, 0xda, 0x8a, 0xc4, 0x35, 0xc0, 0x1b, 0x47, 0xf3, 0xe3, 0xb8, 0xca, 0x65, 0x43, 0x8a, 0x00, 0x55, 0x58, 0x1c, - 0x65, 0xfe, 0x6d, 0x28, 0xca, 0xca, 0x4f, 0x74, 0x69, 0xee, 0x1d, 0x98, 0x54, 0x2a, 0x39, 0x91, - 0xd2, 0xff, 0x85, 0x01, 0xe3, 0xcc, 0xe8, 0x6d, 0x7d, 0xf9, 0x94, 0x5a, 0xa4, 0x37, 0x35, 0x8b, + 0x65, 0xfe, 0x2d, 0x28, 0xca, 0xca, 0x4f, 0x74, 0x69, 0xee, 0x6d, 0x98, 0x54, 0x2a, 0x39, 0x91, + 0xd2, 0xff, 0xb9, 0x01, 0xe3, 0xcc, 0xe8, 0x6d, 0x7d, 0xf9, 0x94, 0x5a, 0xa4, 0x37, 0x34, 0x8b, 0x74, 0x4e, 0xb9, 0xdd, 0x81, 0xf3, 0xf2, 0xcb, 0xc7, 0xd8, 0xa2, 0xbe, 0x01, 0x90, 0x20, 0x93, 0x3b, 0x30, 0xc1, 0x0f, 0x1e, 0xe4, 0x73, 0x2d, 0xea, 0x75, 0x11, 0x51, 0x92, 0x78, 0x39, 0x9e, 0x9f, 0x76, 0x0b, 0x25, 0x35, 0x59, 0x86, 0x31, 0x0c, 0xef, 0xa7, 0xee, 0x27, 0x32, 0x36, 0x4b, 0x5e, 0x97, 0x5f, 0x1f, 0x08, 0x31, 0xaf, 0xef, 0x0c, 0xe6, 0xf5, 0x31, 0x5c, 0x2d, 0xbc, 0xcf, 0x00, 0x6c, 0xdf, 0x86, 0x81, 0x8d, 0xfc, 0x51, 0x4c, 0x2e, 0x0a, 0x26, 0xd9, 0x31, 0x8f, 0x1f, - 0x15, 0x79, 0x42, 0xbe, 0x6c, 0xd8, 0xfb, 0x30, 0x75, 0xdb, 0x0b, 0x1e, 0xdb, 0x81, 0x53, 0xdd, + 0x15, 0x79, 0x42, 0xbe, 0x6c, 0xd8, 0x7b, 0x30, 0x75, 0xdb, 0x0b, 0x1e, 0xdb, 0x81, 0x53, 0xdd, 0xa1, 0x5d, 0x79, 0xee, 0x71, 0x99, 0xa9, 0xfa, 0x36, 0x87, 0x37, 0x6c, 0x56, 0x10, 0x1f, 0x53, 0x68, 0xe8, 0x64, 0x1d, 0xa6, 0xef, 0xdb, 0x4f, 0xc4, 0xf9, 0xd2, 0xe6, 0xe6, 0x9a, 0x48, 0x4f, 0xb8, 0x71, 0xd8, 0xaf, 0x5c, 0xee, 0xd8, 0x4f, 0xe2, 0x73, 0xa9, 0x28, 0x6a, 0x0f, 0x79, 0xf6, 0x47, 0xa7, 0x27, 0x2e, 0xcc, 0x6c, 0x78, 0x41, 0x24, 0x2a, 0x61, 0x3e, 0x6d, 0x7e, 0xc8, 0xf1, 0xd0, 0xcd, 0xcc, 0xe3, 0xa1, 0xcb, 0xcc, 0x91, 0x6f, 0x6c, 0xc7, 0xe4, 0xda, 0x2d, 0x32, 0x8d, - 0x31, 0x79, 0x1f, 0xce, 0x2d, 0xd1, 0x20, 0x72, 0xb7, 0xdd, 0x96, 0x1d, 0xd1, 0xdb, 0x5e, 0xd0, + 0x31, 0x79, 0x0f, 0xce, 0x2d, 0xd1, 0x20, 0x72, 0xb7, 0xdd, 0x96, 0x1d, 0xd1, 0xdb, 0x5e, 0xd0, 0xb1, 0x23, 0x11, 0x50, 0xc1, 0x0d, 0x75, 0x8b, 0x72, 0x4e, 0x1d, 0x3b, 0xb2, 0x06, 0x31, 0xc9, - 0x37, 0xb3, 0x12, 0x3e, 0xc6, 0xb0, 0xfb, 0x6f, 0x30, 0xa7, 0x20, 0x23, 0xe1, 0x63, 0x88, 0x08, + 0x37, 0xb3, 0x12, 0x3e, 0xc6, 0xb0, 0xfb, 0xaf, 0x33, 0xa7, 0x20, 0x23, 0xe1, 0x63, 0x88, 0x08, 0x32, 0x52, 0x3f, 0x76, 0x8e, 0x3a, 0xa6, 0x2b, 0xd6, 0x6e, 0x89, 0x23, 0xc3, 0xe3, 0x8f, 0xe1, 0x8e, 0x3b, 0xa5, 0x5a, 0x84, 0x7c, 0x6d, 0xe3, 0x36, 0x86, 0x48, 0x44, 0x8e, 0x1d, 0xed, 0xee, 0xda, 0xdd, 0x16, 0xfa, 0x32, 0xe2, 0x8c, 0x5c, 0x35, 0x78, 0xb5, 0x8d, 0xdb, 0xc4, 0x86, 0xd9, 0x0d, 0x1a, 0x74, 0xdc, 0xe8, 0xeb, 0xb7, 0x6e, 0x29, 0x03, 0x55, 0xc4, 0xa6, 0xdd, 0x14, 0x4d, 0xab, 0xf8, 0x88, 0xd2, 0x78, 0x72, 0xeb, 0x56, 0xe6, 0x70, 0xc4, 0x0d, 0xcb, 0xe2, 0x45, 0x56, 0x60, 0xe6, 0xbe, 0xfd, 0x44, 0x1c, 0xa0, 0xc6, 0x7b, 0xbc, 0x3c, 0xde, 0x2b, 0x43, 0xc5, 0x6a, - 0x25, 0x45, 0xea, 0x10, 0xeb, 0x44, 0xe4, 0x3d, 0x98, 0x4c, 0xd4, 0x2b, 0xc4, 0xdc, 0xb0, 0x3c, + 0x25, 0x45, 0xea, 0x10, 0xeb, 0x44, 0xe4, 0x5d, 0x98, 0x4c, 0xd4, 0x2b, 0xc4, 0xdc, 0xb0, 0x3c, 0x3f, 0xce, 0x57, 0x94, 0x53, 0x8b, 0x25, 0x29, 0xe8, 0xe4, 0x61, 0xbc, 0x45, 0xe7, 0x0e, 0x29, 0xe6, 0x83, 0x95, 0x6a, 0x37, 0xd5, 0x2d, 0xba, 0x8d, 0x25, 0x5a, 0xb7, 0xce, 0xc6, 0x2e, 0x7a, 0x60, 0x47, 0x74, 0x27, 0xd9, 0xb5, 0x73, 0x2e, 0xca, 0xce, 0x7f, 0x23, 0xf0, 0x3a, 0x7e, 0x84, 0x89, 0x61, 0xa9, 0x9d, 0xbf, 0x8f, 0x25, 0x19, 0x3b, 0x7f, 0x4e, 0x92, 0x7d, 0x2e, 0x3c, 0xfd, - 0xd9, 0xcf, 0x85, 0xcd, 0x7f, 0x5c, 0x82, 0x19, 0xdd, 0x90, 0xb0, 0x95, 0x7d, 0xcd, 0xdb, 0x71, - 0xbb, 0x72, 0x7f, 0xc0, 0x6f, 0xc6, 0x23, 0x44, 0x7b, 0xbb, 0x0d, 0x21, 0xe4, 0x15, 0x80, 0xf8, + 0xe9, 0xcf, 0x85, 0xcd, 0x7f, 0x58, 0x82, 0x19, 0xdd, 0x90, 0xb0, 0x95, 0x7d, 0xcd, 0xdb, 0x71, + 0xbb, 0x72, 0x7f, 0xc0, 0x6f, 0xc6, 0x23, 0x44, 0x7b, 0xbb, 0x0d, 0x21, 0xe4, 0x65, 0x80, 0xf8, 0xd8, 0x4b, 0x6e, 0x01, 0xc4, 0x4b, 0x73, 0x4a, 0x01, 0xf9, 0x36, 0xc0, 0x03, 0xcf, 0xa1, 0xe2, - 0xde, 0x7c, 0xfe, 0xa8, 0x8d, 0xfb, 0xab, 0x62, 0xe3, 0x2e, 0x5e, 0x87, 0x3b, 0xec, 0x57, 0x2e, + 0xde, 0x7c, 0xfe, 0xa8, 0x8d, 0xfb, 0x2b, 0x62, 0xe3, 0x2e, 0x5e, 0x87, 0x3b, 0xec, 0x57, 0x2e, 0x74, 0x3d, 0x87, 0x0e, 0xbe, 0x05, 0xa1, 0x70, 0x24, 0x5f, 0x85, 0x31, 0xab, 0xd7, 0xa6, 0xf2, 0xae, 0xff, 0xa4, 0xb4, 0x91, 0xbd, 0x36, 0x4d, 0xcc, 0x6b, 0xd0, 0x4b, 0xc7, 0x6b, 0x19, 0x80, - 0x7c, 0x08, 0x70, 0xaf, 0xd7, 0xa4, 0x77, 0x02, 0xaf, 0xe7, 0xcb, 0xcb, 0x84, 0xb8, 0x5d, 0xd8, + 0x7c, 0x00, 0x70, 0xaf, 0xd7, 0xa4, 0x77, 0x02, 0xaf, 0xe7, 0xcb, 0xcb, 0x84, 0xb8, 0x5d, 0xd8, 0x8b, 0x5f, 0x4c, 0x68, 0xec, 0x60, 0xa1, 0x5a, 0x79, 0x42, 0x42, 0xd6, 0xd9, 0xae, 0x18, 0x87, 0x49, 0xc4, 0x43, 0x5f, 0xc8, 0xda, 0x89, 0x2b, 0xb6, 0x5a, 0x5c, 0xbe, 0x47, 0xb0, 0xbe, 0x39, - 0xe6, 0xdb, 0x9d, 0xf7, 0xa0, 0xc4, 0xd8, 0xb3, 0x2d, 0x4d, 0x28, 0xe6, 0x28, 0xde, 0x95, 0x55, + 0xe6, 0xdb, 0x9d, 0x77, 0xa1, 0xc4, 0xd8, 0xb3, 0x2d, 0x4d, 0x28, 0xe6, 0x28, 0xde, 0x95, 0x55, 0x1a, 0xc4, 0xb6, 0x3f, 0xda, 0xc3, 0x18, 0x31, 0x01, 0xf9, 0x26, 0x94, 0xaa, 0xbe, 0x2f, 0x44, 0x7d, 0x64, 0x40, 0xe7, 0xda, 0x80, 0xa8, 0xcf, 0xdb, 0xbe, 0x9f, 0xf1, 0xea, 0x46, 0xcc, 0x8f, - 0xec, 0xc4, 0xf7, 0x31, 0xe2, 0x47, 0x84, 0x8e, 0xa8, 0xe0, 0xb5, 0x81, 0x0a, 0xe6, 0x64, 0x2a, + 0xec, 0xc4, 0xf7, 0x31, 0xe2, 0x47, 0x84, 0x8e, 0xa8, 0xe0, 0xd5, 0x81, 0x0a, 0xe6, 0x64, 0x2a, 0xfc, 0xe0, 0xab, 0x41, 0x1a, 0x5f, 0xe2, 0x43, 0x39, 0x79, 0xb1, 0x42, 0xd4, 0x05, 0x47, 0xd5, - 0xf5, 0xc6, 0x40, 0x5d, 0xea, 0x00, 0x0e, 0x54, 0x37, 0xc0, 0x9d, 0x38, 0x30, 0x23, 0xdf, 0x40, - 0x12, 0xf5, 0x4d, 0x1e, 0x55, 0xdf, 0x2b, 0x03, 0xf5, 0xcd, 0x3a, 0xcd, 0xc1, 0x7a, 0x52, 0x3c, - 0xc9, 0x7b, 0x30, 0x2d, 0x21, 0x38, 0x3f, 0x30, 0x90, 0x22, 0xfc, 0x28, 0xa7, 0x89, 0xc9, 0x24, + 0xf5, 0xfa, 0x40, 0x5d, 0xea, 0x00, 0x0e, 0x54, 0x37, 0xc0, 0x9d, 0x38, 0x30, 0x23, 0xdf, 0x40, + 0x12, 0xf5, 0x4d, 0x1e, 0x55, 0xdf, 0xcb, 0x03, 0xf5, 0xcd, 0x3a, 0xcd, 0xc1, 0x7a, 0x52, 0x3c, + 0xc9, 0xbb, 0x30, 0x2d, 0x21, 0x38, 0x3f, 0x30, 0x90, 0x22, 0xfc, 0x28, 0xa7, 0x89, 0xc9, 0x24, 0xfa, 0x0b, 0x11, 0x2a, 0xb2, 0x4a, 0xcd, 0xb5, 0x63, 0x5a, 0xa3, 0x4e, 0x6b, 0x85, 0x8e, 0x4c, 0xbe, 0x01, 0x93, 0xab, 0x1d, 0xd6, 0x11, 0xaf, 0x6b, 0x47, 0x74, 0x6e, 0x06, 0xbb, 0x27, 0x83, 0x53, 0x4a, 0x89, 0xa2, 0xaa, 0xfc, 0xfd, 0x9e, 0xa4, 0x48, 0x35, 0x9a, 0x0a, 0x05, 0x13, 0x1e, 0xdf, 0xe6, 0x0a, 0x1d, 0x0e, 0xe7, 0xce, 0x22, 0xf7, 0xe7, 0x33, 0x02, 0x44, 0x0a, 0x7b, 0x34, - 0xec, 0x7c, 0xf7, 0xdc, 0x10, 0x13, 0x42, 0x13, 0x9e, 0xce, 0xd3, 0xfc, 0x9f, 0x79, 0xb8, 0x34, + 0xec, 0x7c, 0xf7, 0xdc, 0x10, 0x13, 0x42, 0x13, 0x9e, 0xce, 0xd3, 0xfc, 0x1f, 0x79, 0xb8, 0x34, 0x64, 0x52, 0x25, 0x27, 0x34, 0xc6, 0xb1, 0x27, 0x34, 0xdf, 0x62, 0x4a, 0x6c, 0xbb, 0x9d, 0x70, 0xd3, 0x4b, 0xe2, 0xd2, 0x49, 0x30, 0x0b, 0xcb, 0xe4, 0xad, 0x60, 0x79, 0x83, 0xf5, 0x72, 0x0b, 0x29, 0x1a, 0x91, 0x37, 0x10, 0x3a, 0xd0, 0x99, 0x0d, 0x9c, 0x91, 0xe4, 0x7f, 0x49, 0xce, 0x48, - 0xf4, 0xc8, 0x64, 0xe1, 0xa9, 0x46, 0x26, 0xb3, 0x63, 0x25, 0x63, 0x9f, 0x27, 0x22, 0xf4, 0x9f, + 0xf4, 0xc8, 0x64, 0xe1, 0xa9, 0x46, 0x26, 0xb3, 0x63, 0x25, 0x63, 0x9f, 0x25, 0x22, 0xf4, 0x1f, 0x52, 0xa7, 0x32, 0xbf, 0x8c, 0x43, 0x7d, 0x03, 0xc6, 0x1e, 0xed, 0xd2, 0x40, 0x26, 0x86, 0x61, - 0x43, 0x1e, 0x33, 0x80, 0xda, 0x10, 0xc4, 0x30, 0xff, 0x0a, 0x4c, 0xa9, 0x95, 0x91, 0x0a, 0x8c, + 0x43, 0x1e, 0x33, 0x80, 0xda, 0x10, 0xc4, 0x30, 0xff, 0x12, 0x4c, 0xa9, 0x95, 0x91, 0x0a, 0x8c, 0xe1, 0x6f, 0xb1, 0xd1, 0xc2, 0x33, 0x11, 0xac, 0xd7, 0xe2, 0xf0, 0x63, 0xdf, 0x00, 0x49, 0xa4, - 0x90, 0x3f, 0x4e, 0x0a, 0xe6, 0xbf, 0x37, 0xa0, 0xc0, 0x16, 0x3b, 0xf2, 0x16, 0x94, 0xe4, 0x8e, + 0x90, 0x3f, 0x4e, 0x0a, 0xe6, 0xbf, 0x35, 0xa0, 0xc0, 0x16, 0x3b, 0xf2, 0x26, 0x94, 0xe4, 0x8e, 0x59, 0xbd, 0xfc, 0x38, 0x2b, 0x37, 0xd4, 0xa1, 0x7e, 0xac, 0x25, 0x80, 0xac, 0xaa, 0x2d, 0x1a, 0x34, 0xb5, 0xd3, 0xcf, 0x7d, 0x06, 0x50, 0xab, 0x42, 0x8c, 0x13, 0x88, 0x04, 0x4f, 0x78, 0x85, 0x9b, 0x57, 0x40, 0xbe, 0xfc, 0x84, 0x77, 0xc0, 0xbd, 0x93, 0x58, 0xe6, 0x8f, 0x0d, 0xb8, 0x90, 0x69, 0xa6, 0x58, 0xad, 0xdc, 0x1e, 0x2a, 0x1a, 0x91, 0x36, 0x86, 0x1c, 0xe3, 0x24, 0x27, 0xb9, - 0x27, 0x18, 0xde, 0x17, 0xa1, 0x14, 0xef, 0x51, 0xd8, 0x46, 0x9b, 0x0f, 0x1d, 0x6e, 0xab, 0xe4, - 0x9b, 0x2d, 0x6c, 0x93, 0xcd, 0x9a, 0x70, 0x6a, 0x93, 0x42, 0xb3, 0x37, 0xd9, 0xac, 0x4b, 0x23, - 0xa5, 0x82, 0xfe, 0x64, 0x1c, 0x20, 0x41, 0x26, 0x4d, 0x98, 0x59, 0x5f, 0x5d, 0x5e, 0x5a, 0x75, - 0x68, 0x37, 0xc2, 0x60, 0x6f, 0xea, 0xc2, 0xe8, 0xca, 0x93, 0x88, 0x06, 0x5d, 0xbb, 0x2d, 0x10, - 0x0e, 0x92, 0xe9, 0xe9, 0xb9, 0x4e, 0xab, 0xe1, 0xc6, 0x74, 0xea, 0x7a, 0xa1, 0x73, 0x64, 0x75, - 0xd4, 0xab, 0xf7, 0xd7, 0x94, 0x3a, 0x72, 0x23, 0xd6, 0x11, 0xda, 0x9d, 0xf6, 0x90, 0x3a, 0x74, - 0x8e, 0x64, 0x17, 0xca, 0x77, 0xd0, 0x76, 0x2b, 0xb5, 0xe4, 0x8f, 0xae, 0xe5, 0x25, 0x51, 0xcb, - 0x73, 0xdc, 0xe8, 0x67, 0xd7, 0x33, 0xc0, 0x35, 0xd1, 0xdc, 0xc2, 0xb1, 0x9a, 0xfb, 0x37, 0x0d, - 0x18, 0xe7, 0x8b, 0x83, 0x18, 0xad, 0x21, 0xcb, 0xcf, 0xa3, 0xa7, 0xb3, 0xfc, 0x94, 0x23, 0xfc, - 0x4f, 0xdd, 0x1f, 0xf0, 0x32, 0xb2, 0x0c, 0xe3, 0xf5, 0xc8, 0x8e, 0x7a, 0x32, 0x55, 0x40, 0x46, - 0x52, 0x70, 0xfb, 0xc0, 0x4b, 0x92, 0xf3, 0xf0, 0x10, 0x7f, 0xab, 0x5c, 0x38, 0x86, 0xfa, 0xe0, - 0xf7, 0xc4, 0xe7, 0x7c, 0xf0, 0x7b, 0x0d, 0x4a, 0xe2, 0x80, 0xb7, 0x76, 0x20, 0xbc, 0x63, 0x19, - 0x64, 0x88, 0xe1, 0xca, 0x23, 0x74, 0x1c, 0xd4, 0x68, 0x6a, 0x8f, 0xe5, 0xc4, 0x88, 0x64, 0x1d, - 0x4a, 0x49, 0xa2, 0x67, 0x49, 0x0b, 0x87, 0xc7, 0x70, 0x91, 0x01, 0xc5, 0xef, 0x2e, 0x64, 0x26, - 0xb0, 0x26, 0x3c, 0xcc, 0xef, 0x1b, 0x50, 0x4e, 0xeb, 0x0b, 0xdb, 0xcf, 0xc6, 0x49, 0xc5, 0xf1, - 0x31, 0x13, 0xee, 0x67, 0x93, 0x2c, 0x64, 0xed, 0xc0, 0x49, 0x45, 0x27, 0x8b, 0x50, 0x64, 0xd3, - 0xae, 0x9b, 0xbc, 0xed, 0x82, 0xf6, 0xa4, 0x27, 0x60, 0x6a, 0x78, 0x57, 0xe2, 0x29, 0xb3, 0xf6, - 0x5f, 0xe7, 0x60, 0x52, 0x19, 0x2c, 0x72, 0x03, 0x8a, 0xab, 0xe1, 0x9a, 0xd7, 0xda, 0xa3, 0x8e, - 0x88, 0x1a, 0xe1, 0x7b, 0xee, 0x6e, 0xd8, 0x68, 0x23, 0xd0, 0x8a, 0x8b, 0xd9, 0x8e, 0x97, 0xff, - 0x27, 0xef, 0x70, 0xe4, 0x92, 0x1d, 0x2f, 0x47, 0x96, 0xb7, 0x37, 0xd4, 0x15, 0x56, 0x23, 0x21, - 0x9f, 0x00, 0x70, 0x00, 0x1b, 0xdf, 0x11, 0xf2, 0xbb, 0xe4, 0x04, 0xbe, 0x20, 0x2a, 0x88, 0x5c, - 0xb5, 0x87, 0xa8, 0x0a, 0x0a, 0x43, 0x7c, 0x70, 0xda, 0x6b, 0xed, 0x8d, 0xfe, 0x9a, 0x7c, 0xf2, - 0xe0, 0xb4, 0xd7, 0xda, 0x6b, 0x64, 0x1f, 0xf6, 0xab, 0x2c, 0xcd, 0xff, 0x62, 0x28, 0x0a, 0x47, - 0x1e, 0x40, 0x29, 0x1e, 0x1a, 0x11, 0x5b, 0x8c, 0x5d, 0x11, 0x09, 0xb7, 0xe8, 0x76, 0xed, 0x39, - 0x11, 0x4e, 0x99, 0x8d, 0x07, 0x58, 0xd3, 0x3f, 0x09, 0x24, 0x5f, 0x83, 0x02, 0x0a, 0xe6, 0xf8, - 0xc7, 0x2c, 0xa4, 0x61, 0x2f, 0x30, 0x89, 0x60, 0x33, 0x91, 0x92, 0x7c, 0x49, 0x1c, 0xad, 0xe5, - 0xb5, 0x67, 0xe2, 0x18, 0x88, 0xb5, 0x23, 0xb6, 0xe8, 0x49, 0x36, 0x87, 0xa2, 0x1b, 0x7f, 0xdd, - 0x80, 0xd9, 0x87, 0x8b, 0xb7, 0x2d, 0xba, 0xe3, 0x86, 0x11, 0x8f, 0x6a, 0xb1, 0x0d, 0x07, 0xb9, - 0x0c, 0x79, 0xcb, 0x7e, 0x2c, 0x1e, 0x9d, 0xc2, 0x1c, 0xcd, 0xc0, 0x7e, 0x6c, 0x31, 0x18, 0x79, - 0x1d, 0x4a, 0xf7, 0xe8, 0xc1, 0x5d, 0xbb, 0xeb, 0xb4, 0xa9, 0x78, 0x5c, 0x0a, 0x6f, 0x48, 0xef, - 0xd1, 0x83, 0xc6, 0x2e, 0x42, 0xad, 0x04, 0x01, 0x83, 0xfa, 0xbd, 0xe6, 0x3d, 0xca, 0x63, 0x9f, - 0x53, 0x22, 0xa8, 0xdf, 0x6b, 0x62, 0xb6, 0x20, 0x2f, 0x31, 0xff, 0x5b, 0x0e, 0xca, 0xe9, 0xb9, - 0x46, 0x3e, 0x84, 0x29, 0x99, 0x85, 0x78, 0xd7, 0x0e, 0x77, 0x45, 0x53, 0xf0, 0x81, 0x44, 0x5f, - 0xc0, 0x1b, 0xbb, 0xb6, 0xf6, 0x4e, 0x8a, 0x46, 0xc0, 0xd6, 0xe0, 0x4d, 0x91, 0xa9, 0xa8, 0xcc, - 0x99, 0xc8, 0x8b, 0xfc, 0xd4, 0xfb, 0x57, 0x12, 0x8d, 0x38, 0x70, 0x36, 0x25, 0x8b, 0x58, 0x5d, - 0xe3, 0xa4, 0xff, 0xb4, 0xa4, 0xf8, 0xb6, 0xbe, 0xb7, 0xb8, 0xdd, 0x08, 0x94, 0x12, 0xf5, 0xbe, - 0x62, 0x8a, 0x88, 0xbc, 0x03, 0xf0, 0x70, 0xf1, 0x36, 0x5e, 0xc8, 0xa2, 0x81, 0x48, 0x75, 0xc3, - 0x3d, 0x1a, 0x63, 0xd2, 0xe2, 0x60, 0xd5, 0x47, 0x4f, 0x90, 0xc9, 0x5b, 0x90, 0xe7, 0xd7, 0x08, - 0xf2, 0x8a, 0xcd, 0xbb, 0x7f, 0xbb, 0xca, 0x53, 0xb9, 0xf9, 0x39, 0x87, 0x1e, 0x30, 0x62, 0xf8, - 0xe6, 0xff, 0xc9, 0x41, 0x29, 0xc6, 0x22, 0x04, 0xd0, 0x53, 0x11, 0xc7, 0x0a, 0xf8, 0x3f, 0xb9, - 0x0c, 0x45, 0xe9, 0x9c, 0x88, 0xa3, 0x85, 0x89, 0x50, 0x38, 0x26, 0x73, 0x20, 0xbd, 0x10, 0xee, - 0x98, 0x58, 0xf2, 0x27, 0xb9, 0x05, 0xb1, 0x8b, 0x31, 0xcc, 0x17, 0x29, 0x30, 0xe5, 0xb3, 0x62, - 0x34, 0x32, 0x03, 0x39, 0x97, 0x27, 0xb3, 0x95, 0xac, 0x9c, 0xeb, 0x90, 0x0f, 0xa1, 0x68, 0x3b, - 0x0e, 0x75, 0x1a, 0x76, 0x34, 0xc2, 0x87, 0x03, 0x8a, 0x8c, 0x1b, 0x5f, 0x0b, 0x90, 0xaa, 0x1a, - 0x91, 0x2a, 0x94, 0xf0, 0xdd, 0xf8, 0x5e, 0x38, 0xd2, 0x63, 0xf3, 0x09, 0x87, 0x22, 0x23, 0x7b, - 0x18, 0x52, 0x87, 0xbc, 0x0a, 0x05, 0xa6, 0x14, 0x62, 0x25, 0x89, 0x5f, 0xd6, 0x59, 0xdf, 0xdc, - 0xe0, 0x02, 0xbb, 0x7b, 0xc6, 0x42, 0x04, 0xf2, 0x32, 0xe4, 0x7b, 0x8b, 0xdb, 0x62, 0x8d, 0x28, - 0x27, 0x2a, 0x11, 0xa3, 0xb1, 0xe2, 0x5a, 0x11, 0xc6, 0x79, 0xee, 0xbd, 0xf9, 0x02, 0x40, 0xc2, - 0x65, 0xf0, 0x30, 0xc7, 0xfc, 0x04, 0x4a, 0x31, 0x35, 0x79, 0x1e, 0x94, 0x09, 0xc4, 0x95, 0xdd, - 0x2a, 0xed, 0xc5, 0xd3, 0xe8, 0x12, 0x4c, 0xf8, 0x6c, 0x80, 0xe4, 0x7b, 0x6e, 0x16, 0x9b, 0x43, - 0x4c, 0x67, 0xe7, 0x60, 0x42, 0xe8, 0x0c, 0xcf, 0xb1, 0xb4, 0xe4, 0x4f, 0xb3, 0x0b, 0x53, 0xaa, - 0x41, 0x3a, 0xe6, 0xba, 0xce, 0x45, 0x4c, 0x7f, 0xe0, 0x13, 0x65, 0xfc, 0xb0, 0x5f, 0xc9, 0xb9, - 0x0e, 0x26, 0x3d, 0x5c, 0x87, 0xa2, 0x5c, 0xc4, 0xd4, 0xd7, 0x62, 0x85, 0xbf, 0x73, 0x60, 0xc5, - 0xa5, 0xe6, 0xab, 0x30, 0x21, 0x6c, 0xce, 0xd1, 0x4f, 0x23, 0x9a, 0xdf, 0xcb, 0xc1, 0x59, 0x8b, - 0x32, 0x2d, 0x12, 0xef, 0xb0, 0x3e, 0x63, 0x8f, 0xc0, 0x69, 0x7d, 0x3b, 0xe2, 0xee, 0xde, 0x4f, - 0x0d, 0x98, 0xcd, 0xc0, 0xfd, 0x4c, 0xcf, 0x81, 0xbc, 0x0d, 0xa5, 0x65, 0xd7, 0x6e, 0x57, 0x1d, - 0x27, 0x4e, 0xe3, 0x40, 0x67, 0xc5, 0x71, 0x99, 0xaf, 0xc2, 0xa0, 0xea, 0xea, 0x13, 0xa3, 0x92, - 0xd7, 0x84, 0x52, 0xe4, 0x63, 0xb1, 0xca, 0x67, 0xe6, 0x80, 0xb7, 0x29, 0x79, 0x64, 0xce, 0xfc, - 0x51, 0x0e, 0x08, 0x07, 0x26, 0x91, 0xfa, 0x53, 0x3b, 0x74, 0x1f, 0x6a, 0x43, 0x27, 0x63, 0x5c, - 0xe9, 0xee, 0x8d, 0xb4, 0x2b, 0xfa, 0x7e, 0x0e, 0x2e, 0x66, 0x13, 0x7e, 0xd6, 0x97, 0x5d, 0xf0, - 0x6a, 0xa2, 0xf2, 0x92, 0x1f, 0xae, 0xaf, 0xfc, 0x1e, 0x23, 0xe2, 0x27, 0x08, 0x64, 0x1b, 0xa6, - 0xd7, 0xec, 0x30, 0xba, 0x4b, 0xed, 0x20, 0x6a, 0x52, 0x3b, 0x1a, 0xc1, 0xc1, 0x8a, 0xbf, 0x1a, - 0x81, 0x96, 0x73, 0x57, 0x52, 0xa6, 0xbf, 0x1a, 0xa1, 0xb1, 0x8d, 0x15, 0xa5, 0x30, 0x82, 0xa2, - 0x7c, 0x17, 0xce, 0xd6, 0x69, 0xc7, 0xf6, 0x77, 0xbd, 0x80, 0x8a, 0x44, 0x86, 0x05, 0x98, 0x8e, - 0x41, 0x99, 0xda, 0xa2, 0x17, 0x6b, 0xf8, 0x8a, 0x20, 0x12, 0x53, 0xa2, 0x17, 0x9b, 0x7f, 0x90, - 0x83, 0x4b, 0xd5, 0x96, 0x38, 0x1b, 0x11, 0x05, 0x32, 0x16, 0xff, 0x05, 0xd7, 0x4d, 0x6e, 0x42, - 0xe9, 0xbe, 0xfd, 0x04, 0xbf, 0x6c, 0x14, 0x8a, 0x2b, 0xd9, 0x7c, 0x25, 0xb6, 0x9f, 0x34, 0xe2, - 0xa8, 0x8c, 0x95, 0xe0, 0x3c, 0xcd, 0x8f, 0x1f, 0x99, 0x30, 0x7e, 0xd7, 0x6b, 0x3b, 0x34, 0x10, - 0xb7, 0xab, 0xd1, 0xbd, 0xda, 0x45, 0x88, 0x25, 0x4a, 0xcc, 0x3f, 0x33, 0x60, 0x26, 0x6e, 0x31, - 0x36, 0xe1, 0x0b, 0x17, 0x49, 0xea, 0x33, 0x50, 0xa5, 0x11, 0x3e, 0x03, 0x35, 0xf6, 0xf9, 0x24, - 0x61, 0xfe, 0x43, 0x03, 0xce, 0xe9, 0xbd, 0x64, 0x2b, 0x91, 0xd2, 0x10, 0x63, 0xc4, 0x86, 0xe4, - 0x9e, 0xda, 0x90, 0xe4, 0x87, 0x0e, 0xc9, 0x6f, 0xe5, 0x60, 0x32, 0x6e, 0xec, 0xa9, 0x4d, 0x22, - 0xfb, 0x55, 0xcd, 0x86, 0x5e, 0x8c, 0xef, 0xb0, 0x8b, 0x7e, 0x8d, 0x94, 0x43, 0x56, 0x57, 0x6c, - 0x85, 0x48, 0xd5, 0xfa, 0x1a, 0x8c, 0x8b, 0xc9, 0xa4, 0xa7, 0xb9, 0x0f, 0x8c, 0x6e, 0x6d, 0x46, - 0xb0, 0x1e, 0xc7, 0x01, 0x0d, 0x2d, 0x41, 0x87, 0x49, 0x7a, 0x8f, 0x68, 0x53, 0x9c, 0x92, 0x9e, - 0xda, 0x35, 0x2a, 0x3b, 0x49, 0x2f, 0xe9, 0xd8, 0x48, 0xab, 0xd3, 0x9f, 0xe7, 0xa1, 0x9c, 0x26, - 0x39, 0xfe, 0x82, 0xde, 0x46, 0xaf, 0x29, 0xf6, 0x76, 0xb8, 0xf9, 0xf3, 0x7b, 0x4d, 0x8b, 0xc1, - 0xc8, 0x35, 0x28, 0x6c, 0x04, 0xee, 0xbe, 0xd8, 0xcc, 0x61, 0x42, 0x9a, 0x1f, 0xb8, 0xfb, 0x6a, - 0xb6, 0x0a, 0x2b, 0xc7, 0xcd, 0xd7, 0x5a, 0x5d, 0xf9, 0xf4, 0x0a, 0xdf, 0x7c, 0xb5, 0xc3, 0xf4, - 0x65, 0x63, 0x89, 0xc6, 0x96, 0xca, 0x1a, 0xb5, 0x03, 0x1a, 0xf0, 0x87, 0x18, 0xc7, 0x92, 0xa5, - 0xb2, 0x89, 0x60, 0xfe, 0xba, 0x9c, 0xa5, 0x22, 0x91, 0x36, 0x10, 0xe5, 0xe7, 0xe8, 0x5f, 0x20, - 0x93, 0x1f, 0x40, 0x39, 0xaf, 0xb2, 0x6e, 0xa8, 0xb3, 0x39, 0x83, 0xef, 0xd3, 0x0c, 0x61, 0x6d, - 0x40, 0x09, 0x23, 0x32, 0xb8, 0xf3, 0x2f, 0x1e, 0xcb, 0x4c, 0x66, 0x06, 0x01, 0x1e, 0xe2, 0x37, - 0xe2, 0xfd, 0x7f, 0xc2, 0xc4, 0xfc, 0x92, 0x3a, 0xca, 0x62, 0xd1, 0x3d, 0x72, 0x94, 0xcd, 0xdf, - 0x47, 0x37, 0xbc, 0xe3, 0x45, 0x54, 0x78, 0x1f, 0xa7, 0xd6, 0x0e, 0x25, 0x11, 0xca, 0x31, 0xed, - 0x3c, 0x54, 0xeb, 0x1d, 0xc7, 0xd8, 0x7a, 0x33, 0x31, 0x1a, 0x3c, 0x56, 0x29, 0x23, 0x94, 0xca, - 0x94, 0xf9, 0x07, 0x06, 0x5c, 0xc8, 0xa4, 0x25, 0x0b, 0x00, 0x89, 0x8f, 0x27, 0xa4, 0xc4, 0x9f, - 0x87, 0x8b, 0xa1, 0x96, 0x82, 0x41, 0xbe, 0x95, 0xf6, 0xce, 0x8e, 0x5f, 0x5c, 0xe4, 0x1b, 0xc6, - 0x33, 0xba, 0x77, 0x96, 0xe1, 0x93, 0x99, 0x3f, 0xcd, 0xc3, 0xb9, 0x81, 0x6f, 0x42, 0x1c, 0xf3, - 0x2e, 0xfd, 0x5e, 0xea, 0xcb, 0x0a, 0x3c, 0x9a, 0xfe, 0xda, 0xb0, 0x2f, 0x52, 0x64, 0x7c, 0x67, - 0x01, 0x43, 0x30, 0xe2, 0xc5, 0xc7, 0x63, 0x3e, 0xb7, 0x10, 0xa6, 0x3f, 0xb7, 0xc0, 0xa3, 0xea, - 0xbf, 0x32, 0xb4, 0xb6, 0xa7, 0xf0, 0xb1, 0xa2, 0x5f, 0xe2, 0x4f, 0x17, 0x7c, 0x2f, 0x07, 0xf0, + 0x27, 0x18, 0xde, 0x2f, 0x40, 0x29, 0xde, 0xa3, 0xb0, 0x8d, 0x36, 0x1f, 0x3a, 0xdc, 0x56, 0xc9, + 0x37, 0x5b, 0xd8, 0x26, 0x9b, 0x35, 0xe1, 0xd4, 0x26, 0x85, 0x66, 0x6f, 0xb2, 0x59, 0x97, 0x46, + 0x4a, 0x05, 0xfd, 0xc9, 0x38, 0x40, 0x82, 0x4c, 0x9a, 0x30, 0xb3, 0xbe, 0xba, 0xbc, 0xb4, 0xea, + 0xd0, 0x6e, 0x84, 0xc1, 0xde, 0xd4, 0x85, 0xd1, 0x95, 0x27, 0x11, 0x0d, 0xba, 0x76, 0x5b, 0x20, + 0x1c, 0x24, 0xd3, 0xd3, 0x73, 0x9d, 0x56, 0xc3, 0x8d, 0xe9, 0xd4, 0xf5, 0x42, 0xe7, 0xc8, 0xea, + 0xa8, 0x57, 0xef, 0xaf, 0x29, 0x75, 0xe4, 0x46, 0xac, 0x23, 0xb4, 0x3b, 0xed, 0x21, 0x75, 0xe8, + 0x1c, 0xc9, 0x2e, 0x94, 0xef, 0xa0, 0xed, 0x56, 0x6a, 0xc9, 0x1f, 0x5d, 0xcb, 0x8b, 0xa2, 0x96, + 0xe7, 0xb8, 0xd1, 0xcf, 0xae, 0x67, 0x80, 0x6b, 0xa2, 0xb9, 0x85, 0x63, 0x35, 0xf7, 0xaf, 0x1b, + 0x30, 0xce, 0x17, 0x07, 0x31, 0x5a, 0x43, 0x96, 0x9f, 0x47, 0x4f, 0x67, 0xf9, 0x29, 0x47, 0xf8, + 0x9f, 0xba, 0x3f, 0xe0, 0x65, 0x64, 0x19, 0xc6, 0xeb, 0x91, 0x1d, 0xf5, 0x64, 0xaa, 0x80, 0x8c, + 0xa4, 0xe0, 0xf6, 0x81, 0x97, 0x24, 0xe7, 0xe1, 0x21, 0xfe, 0x56, 0xb9, 0x70, 0x0c, 0xf5, 0xc1, + 0xef, 0x89, 0xcf, 0xf8, 0xe0, 0xf7, 0x1a, 0x94, 0xc4, 0x01, 0x6f, 0xed, 0x40, 0x78, 0xc7, 0x32, + 0xc8, 0x10, 0xc3, 0x95, 0x47, 0xe8, 0x38, 0xa8, 0xd1, 0xd4, 0x1e, 0xcb, 0x89, 0x11, 0xc9, 0x3a, + 0x94, 0x92, 0x44, 0xcf, 0x92, 0x16, 0x0e, 0x8f, 0xe1, 0x22, 0x03, 0x8a, 0xdf, 0x5d, 0xc8, 0x4c, + 0x60, 0x4d, 0x78, 0x98, 0xdf, 0x37, 0xa0, 0x9c, 0xd6, 0x17, 0xb6, 0x9f, 0x8d, 0x93, 0x8a, 0xe3, + 0x63, 0x26, 0xdc, 0xcf, 0x26, 0x59, 0xc8, 0xda, 0x81, 0x93, 0x8a, 0x4e, 0x16, 0xa1, 0xc8, 0xa6, + 0x5d, 0x37, 0x79, 0xdb, 0x05, 0xed, 0x49, 0x4f, 0xc0, 0xd4, 0xf0, 0xae, 0xc4, 0x53, 0x66, 0xed, + 0xbf, 0xcc, 0xc1, 0xa4, 0x32, 0x58, 0xe4, 0x06, 0x14, 0x57, 0xc3, 0x35, 0xaf, 0xb5, 0x47, 0x1d, + 0x11, 0x35, 0xc2, 0xf7, 0xdc, 0xdd, 0xb0, 0xd1, 0x46, 0xa0, 0x15, 0x17, 0xb3, 0x1d, 0x2f, 0xff, + 0x4f, 0xde, 0xe1, 0xc8, 0x25, 0x3b, 0x5e, 0x8e, 0x2c, 0x6f, 0x6f, 0xa8, 0x2b, 0xac, 0x46, 0x42, + 0x3e, 0x06, 0xe0, 0x00, 0x36, 0xbe, 0x23, 0xe4, 0x77, 0xc9, 0x09, 0x7c, 0x41, 0x54, 0x10, 0xb9, + 0x6a, 0x0f, 0x51, 0x15, 0x14, 0x86, 0xf8, 0xe0, 0xb4, 0xd7, 0xda, 0x1b, 0xfd, 0x35, 0xf9, 0xe4, + 0xc1, 0x69, 0xaf, 0xb5, 0xd7, 0xc8, 0x3e, 0xec, 0x57, 0x59, 0x9a, 0xff, 0xd9, 0x50, 0x14, 0x8e, + 0x3c, 0x80, 0x52, 0x3c, 0x34, 0x22, 0xb6, 0x18, 0xbb, 0x22, 0x12, 0x6e, 0xd1, 0xed, 0xda, 0x73, + 0x22, 0x9c, 0x32, 0x1b, 0x0f, 0xb0, 0xa6, 0x7f, 0x12, 0x48, 0xbe, 0x06, 0x05, 0x14, 0xcc, 0xf1, + 0x8f, 0x59, 0x48, 0xc3, 0x5e, 0x60, 0x12, 0xc1, 0x66, 0x22, 0x25, 0xf9, 0x92, 0x38, 0x5a, 0xcb, + 0x6b, 0xcf, 0xc4, 0x31, 0x10, 0x6b, 0x47, 0x6c, 0xd1, 0x93, 0x6c, 0x0e, 0x45, 0x37, 0xfe, 0xaa, + 0x01, 0xb3, 0x0f, 0x17, 0x6f, 0x5b, 0x74, 0xc7, 0x0d, 0x23, 0x1e, 0xd5, 0x62, 0x1b, 0x0e, 0x72, + 0x19, 0xf2, 0x96, 0xfd, 0x58, 0x3c, 0x3a, 0x85, 0x39, 0x9a, 0x81, 0xfd, 0xd8, 0x62, 0x30, 0xf2, + 0x1a, 0x94, 0xee, 0xd1, 0x83, 0xbb, 0x76, 0xd7, 0x69, 0x53, 0xf1, 0xb8, 0x14, 0xde, 0x90, 0xde, + 0xa3, 0x07, 0x8d, 0x5d, 0x84, 0x5a, 0x09, 0x02, 0x06, 0xf5, 0x7b, 0xcd, 0x7b, 0x94, 0xc7, 0x3e, + 0xa7, 0x44, 0x50, 0xbf, 0xd7, 0xc4, 0x6c, 0x41, 0x5e, 0x62, 0xfe, 0xd7, 0x1c, 0x94, 0xd3, 0x73, + 0x8d, 0x7c, 0x00, 0x53, 0x32, 0x0b, 0xf1, 0xae, 0x1d, 0xee, 0x8a, 0xa6, 0xe0, 0x03, 0x89, 0xbe, + 0x80, 0x37, 0x76, 0x6d, 0xed, 0x9d, 0x14, 0x8d, 0x80, 0xad, 0xc1, 0x9b, 0x22, 0x53, 0x51, 0x99, + 0x33, 0x91, 0x17, 0xf9, 0xa9, 0xf7, 0xaf, 0x24, 0x1a, 0x71, 0xe0, 0x6c, 0x4a, 0x16, 0xb1, 0xba, + 0xc6, 0x49, 0xff, 0x69, 0x49, 0xf1, 0x6d, 0x7d, 0x6f, 0x71, 0xbb, 0x11, 0x28, 0x25, 0xea, 0x7d, + 0xc5, 0x14, 0x11, 0x79, 0x1b, 0xe0, 0xe1, 0xe2, 0x6d, 0xbc, 0x90, 0x45, 0x03, 0x91, 0xea, 0x86, + 0x7b, 0x34, 0xc6, 0xa4, 0xc5, 0xc1, 0xaa, 0x8f, 0x9e, 0x20, 0x93, 0x37, 0x21, 0xcf, 0xaf, 0x11, + 0xe4, 0x15, 0x9b, 0x77, 0xff, 0x76, 0x95, 0xa7, 0x72, 0xf3, 0x73, 0x0e, 0x3d, 0x60, 0xc4, 0xf0, + 0xcd, 0xff, 0x93, 0x83, 0x52, 0x8c, 0x45, 0x08, 0xa0, 0xa7, 0x22, 0x8e, 0x15, 0xf0, 0x7f, 0x72, + 0x19, 0x8a, 0xd2, 0x39, 0x11, 0x47, 0x0b, 0x13, 0xa1, 0x70, 0x4c, 0xe6, 0x40, 0x7a, 0x21, 0xdc, + 0x31, 0xb1, 0xe4, 0x4f, 0x72, 0x0b, 0x62, 0x17, 0x63, 0x98, 0x2f, 0x52, 0x60, 0xca, 0x67, 0xc5, + 0x68, 0x64, 0x06, 0x72, 0x2e, 0x4f, 0x66, 0x2b, 0x59, 0x39, 0xd7, 0x21, 0x1f, 0x40, 0xd1, 0x76, + 0x1c, 0xea, 0x34, 0xec, 0x68, 0x84, 0x0f, 0x07, 0x14, 0x19, 0x37, 0xbe, 0x16, 0x20, 0x55, 0x35, + 0x22, 0x55, 0x28, 0xe1, 0xbb, 0xf1, 0xbd, 0x70, 0xa4, 0xc7, 0xe6, 0x13, 0x0e, 0x45, 0x46, 0xf6, + 0x30, 0xa4, 0x0e, 0x79, 0x05, 0x0a, 0x4c, 0x29, 0xc4, 0x4a, 0x12, 0xbf, 0xac, 0xb3, 0xbe, 0xb9, + 0xc1, 0x05, 0x76, 0xf7, 0x8c, 0x85, 0x08, 0xe4, 0x25, 0xc8, 0xf7, 0x16, 0xb7, 0xc5, 0x1a, 0x51, + 0x4e, 0x54, 0x22, 0x46, 0x63, 0xc5, 0xb5, 0x22, 0x8c, 0xf3, 0xdc, 0x7b, 0xf3, 0x05, 0x80, 0x84, + 0xcb, 0xe0, 0x61, 0x8e, 0xf9, 0x31, 0x94, 0x62, 0x6a, 0xf2, 0x3c, 0x28, 0x13, 0x88, 0x2b, 0xbb, + 0x55, 0xda, 0x8b, 0xa7, 0xd1, 0x25, 0x98, 0xf0, 0xd9, 0x00, 0xc9, 0xf7, 0xdc, 0x2c, 0x36, 0x87, + 0x98, 0xce, 0xce, 0xc1, 0x84, 0xd0, 0x19, 0x9e, 0x63, 0x69, 0xc9, 0x9f, 0x66, 0x17, 0xa6, 0x54, + 0x83, 0x74, 0xcc, 0x75, 0x9d, 0x8b, 0x98, 0xfe, 0xc0, 0x27, 0xca, 0xf8, 0x61, 0xbf, 0x92, 0x73, + 0x1d, 0x4c, 0x7a, 0xb8, 0x0e, 0x45, 0xb9, 0x88, 0xa9, 0xaf, 0xc5, 0x0a, 0x7f, 0xe7, 0xc0, 0x8a, + 0x4b, 0xcd, 0x57, 0x60, 0x42, 0xd8, 0x9c, 0xa3, 0x9f, 0x46, 0x34, 0xbf, 0x97, 0x83, 0xb3, 0x16, + 0x65, 0x5a, 0x24, 0xde, 0x61, 0x7d, 0xc6, 0x1e, 0x81, 0xd3, 0xfa, 0x76, 0xc4, 0xdd, 0xbd, 0x9f, + 0x1a, 0x30, 0x9b, 0x81, 0xfb, 0xa9, 0x9e, 0x03, 0x79, 0x0b, 0x4a, 0xcb, 0xae, 0xdd, 0xae, 0x3a, + 0x4e, 0x9c, 0xc6, 0x81, 0xce, 0x8a, 0xe3, 0x32, 0x5f, 0x85, 0x41, 0xd5, 0xd5, 0x27, 0x46, 0x25, + 0xaf, 0x0a, 0xa5, 0xc8, 0xc7, 0x62, 0x95, 0xcf, 0xcc, 0x01, 0x6f, 0x53, 0xf2, 0xc8, 0x9c, 0xf9, + 0xa3, 0x1c, 0x10, 0x0e, 0x4c, 0x22, 0xf5, 0xa7, 0x76, 0xe8, 0x3e, 0xd0, 0x86, 0x4e, 0xc6, 0xb8, + 0xd2, 0xdd, 0x1b, 0x69, 0x57, 0xf4, 0xfd, 0x1c, 0x5c, 0xcc, 0x26, 0xfc, 0xb4, 0x2f, 0xbb, 0xe0, + 0xd5, 0x44, 0xe5, 0x25, 0x3f, 0x5c, 0x5f, 0xf9, 0x3d, 0x46, 0xc4, 0x4f, 0x10, 0xc8, 0x36, 0x4c, + 0xaf, 0xd9, 0x61, 0x74, 0x97, 0xda, 0x41, 0xd4, 0xa4, 0x76, 0x34, 0x82, 0x83, 0x15, 0x7f, 0x35, + 0x02, 0x2d, 0xe7, 0xae, 0xa4, 0x4c, 0x7f, 0x35, 0x42, 0x63, 0x1b, 0x2b, 0x4a, 0x61, 0x04, 0x45, + 0xf9, 0x2e, 0x9c, 0xad, 0xd3, 0x8e, 0xed, 0xef, 0x7a, 0x01, 0x15, 0x89, 0x0c, 0x0b, 0x30, 0x1d, + 0x83, 0x32, 0xb5, 0x45, 0x2f, 0xd6, 0xf0, 0x15, 0x41, 0x24, 0xa6, 0x44, 0x2f, 0x36, 0x7f, 0x3f, + 0x07, 0x97, 0xaa, 0x2d, 0x71, 0x36, 0x22, 0x0a, 0x64, 0x2c, 0xfe, 0x73, 0xae, 0x9b, 0xdc, 0x84, + 0xd2, 0x7d, 0xfb, 0x09, 0x7e, 0xd9, 0x28, 0x14, 0x57, 0xb2, 0xf9, 0x4a, 0x6c, 0x3f, 0x69, 0xc4, + 0x51, 0x19, 0x2b, 0xc1, 0x79, 0x9a, 0x1f, 0x3f, 0x32, 0x61, 0xfc, 0xae, 0xd7, 0x76, 0x68, 0x20, + 0x6e, 0x57, 0xa3, 0x7b, 0xb5, 0x8b, 0x10, 0x4b, 0x94, 0x98, 0x7f, 0x6a, 0xc0, 0x4c, 0xdc, 0x62, + 0x6c, 0xc2, 0xe7, 0x2e, 0x92, 0xd4, 0x67, 0xa0, 0x4a, 0x23, 0x7c, 0x06, 0x6a, 0xec, 0xb3, 0x49, + 0xc2, 0xfc, 0xfb, 0x06, 0x9c, 0xd3, 0x7b, 0xc9, 0x56, 0x22, 0xa5, 0x21, 0xc6, 0x88, 0x0d, 0xc9, + 0x3d, 0xb5, 0x21, 0xc9, 0x0f, 0x1d, 0x92, 0xdf, 0xcc, 0xc1, 0x64, 0xdc, 0xd8, 0x53, 0x9b, 0x44, + 0xf6, 0x2b, 0x9a, 0x0d, 0xbd, 0x18, 0xdf, 0x61, 0x17, 0xfd, 0x1a, 0x29, 0x87, 0xac, 0xae, 0xd8, + 0x0a, 0x91, 0xaa, 0xf5, 0x35, 0x18, 0x17, 0x93, 0x49, 0x4f, 0x73, 0x1f, 0x18, 0xdd, 0xda, 0x8c, + 0x60, 0x3d, 0x8e, 0x03, 0x1a, 0x5a, 0x82, 0x0e, 0x93, 0xf4, 0x1e, 0xd1, 0xa6, 0x38, 0x25, 0x3d, + 0xb5, 0x6b, 0x54, 0x76, 0x92, 0x5e, 0xd2, 0xb1, 0x91, 0x56, 0xa7, 0x3f, 0xcb, 0x43, 0x39, 0x4d, + 0x72, 0xfc, 0x05, 0xbd, 0x8d, 0x5e, 0x53, 0xec, 0xed, 0x70, 0xf3, 0xe7, 0xf7, 0x9a, 0x16, 0x83, + 0x91, 0x6b, 0x50, 0xd8, 0x08, 0xdc, 0x7d, 0xb1, 0x99, 0xc3, 0x84, 0x34, 0x3f, 0x70, 0xf7, 0xd5, + 0x6c, 0x15, 0x56, 0x8e, 0x9b, 0xaf, 0xb5, 0xba, 0xf2, 0xe9, 0x15, 0xbe, 0xf9, 0x6a, 0x87, 0xe9, + 0xcb, 0xc6, 0x12, 0x8d, 0x2d, 0x95, 0x35, 0x6a, 0x07, 0x34, 0xe0, 0x0f, 0x31, 0x8e, 0x25, 0x4b, + 0x65, 0x13, 0xc1, 0xfc, 0x75, 0x39, 0x4b, 0x45, 0x22, 0x6d, 0x20, 0xca, 0xcf, 0xd1, 0xbf, 0x40, + 0x26, 0x3f, 0x80, 0x72, 0x5e, 0x65, 0xdd, 0x50, 0x67, 0x73, 0x06, 0xdf, 0xa7, 0x19, 0xc2, 0xda, + 0x80, 0x12, 0x46, 0x64, 0x70, 0xe7, 0x5f, 0x3c, 0x96, 0x99, 0xcc, 0x0c, 0x02, 0x3c, 0xc4, 0x6f, + 0xc4, 0xfb, 0xff, 0x84, 0x89, 0xf9, 0x25, 0x75, 0x94, 0xc5, 0xa2, 0x7b, 0xe4, 0x28, 0x9b, 0xbf, + 0x87, 0x6e, 0x78, 0xc7, 0x8b, 0xa8, 0xf0, 0x3e, 0x4e, 0xad, 0x1d, 0x4a, 0x22, 0x94, 0x63, 0xda, + 0x79, 0xa8, 0xd6, 0x3b, 0x8e, 0xb1, 0xf5, 0x46, 0x62, 0x34, 0x78, 0xac, 0x52, 0x46, 0x28, 0x95, + 0x29, 0xf3, 0xf7, 0x0c, 0xb8, 0x90, 0x49, 0x4b, 0x16, 0x00, 0x12, 0x1f, 0x4f, 0x48, 0x89, 0x3f, + 0x0f, 0x17, 0x43, 0x2d, 0x05, 0x83, 0x7c, 0x2b, 0xed, 0x9d, 0x1d, 0xbf, 0xb8, 0xc8, 0x37, 0x8c, + 0x67, 0x74, 0xef, 0x2c, 0xc3, 0x27, 0x33, 0x7f, 0x9a, 0x87, 0x73, 0x03, 0xdf, 0x84, 0x38, 0xe6, + 0x5d, 0xfa, 0xbd, 0xd4, 0x97, 0x15, 0x78, 0x34, 0xfd, 0xd5, 0x61, 0x5f, 0xa4, 0xc8, 0xf8, 0xce, + 0x02, 0x86, 0x60, 0xc4, 0x8b, 0x8f, 0xc7, 0x7c, 0x6e, 0x21, 0x4c, 0x7f, 0x6e, 0x81, 0x47, 0xd5, + 0xbf, 0x38, 0xb4, 0xb6, 0xa7, 0xf0, 0xb1, 0xa2, 0x5f, 0xe2, 0x4f, 0x17, 0x7c, 0x2f, 0x07, 0xf0, 0x88, 0x36, 0x4f, 0xf7, 0x2d, 0xf2, 0xaf, 0x68, 0x8b, 0xd2, 0x85, 0x64, 0x51, 0x1a, 0xfd, 0xee, 0xf8, 0x3a, 0xcc, 0xe8, 0xf8, 0xc7, 0x5f, 0x3e, 0xe3, 0x8b, 0x42, 0x2e, 0xfb, 0x75, 0x5e, 0xb3, - 0x09, 0xe7, 0xef, 0xd0, 0x28, 0xb1, 0x7f, 0xd2, 0xf3, 0x3f, 0x9a, 0xed, 0xeb, 0x50, 0x12, 0xf8, + 0x09, 0xe7, 0xef, 0xd0, 0x28, 0xb1, 0x7f, 0xd2, 0xf3, 0x3f, 0x9a, 0xed, 0x6b, 0x50, 0x12, 0xf8, 0xfa, 0x53, 0x8f, 0x32, 0xf5, 0xca, 0x75, 0xac, 0x04, 0xc1, 0xa4, 0x70, 0x69, 0x99, 0xb6, 0x69, - 0x44, 0xbf, 0xd8, 0x6a, 0xea, 0x40, 0x78, 0x57, 0xb0, 0x67, 0xa3, 0xd5, 0x70, 0xac, 0x7c, 0xb6, + 0x44, 0x3f, 0xdf, 0x6a, 0xea, 0x40, 0x78, 0x57, 0xb0, 0x67, 0xa3, 0xd5, 0x70, 0xac, 0x7c, 0xb6, 0xe0, 0x42, 0xdc, 0xf6, 0xa7, 0xc9, 0xf7, 0x26, 0x5b, 0x41, 0x44, 0x1e, 0x77, 0xc2, 0xf1, 0x88, - 0xd0, 0xcf, 0x13, 0x98, 0x97, 0x04, 0x8f, 0xdc, 0x38, 0xd6, 0x3b, 0x12, 0x2d, 0x79, 0x0f, 0x26, + 0xd0, 0xcf, 0x13, 0x98, 0x97, 0x04, 0x8f, 0xdc, 0x38, 0xd6, 0x3b, 0x12, 0x2d, 0x79, 0x17, 0x26, 0x15, 0x1a, 0x71, 0x29, 0x04, 0x8f, 0x50, 0x1e, 0xbb, 0xd1, 0x6e, 0x23, 0xe4, 0x70, 0xf5, 0x08, 0x45, 0x41, 0x37, 0xbf, 0x89, 0x6f, 0x00, 0xf0, 0xbd, 0x58, 0x46, 0xd5, 0x29, 0xe6, 0xc6, 0xc9, 0x98, 0x3f, 0x48, 0xba, 0xb5, 0xda, 0x8d, 0x73, 0xe6, 0x24, 0x6f, 0xa2, 0x76, 0x4b, 0x74, 0xe6, - 0xca, 0xc0, 0xd7, 0x5d, 0x95, 0xcf, 0xba, 0x9a, 0xef, 0x2a, 0x8d, 0xcd, 0x60, 0xa8, 0x11, 0x1b, + 0xca, 0xc0, 0xd7, 0x5d, 0x95, 0xcf, 0xba, 0x9a, 0xef, 0x28, 0x8d, 0xcd, 0x60, 0xa8, 0x11, 0x1b, 0x69, 0xe2, 0xef, 0xe5, 0xe0, 0xec, 0xfa, 0xea, 0xf2, 0x52, 0x1c, 0xfc, 0x7b, 0xc6, 0xc2, 0x6b, - 0x5a, 0xdf, 0x8e, 0x08, 0xaf, 0x3d, 0x84, 0xd9, 0x94, 0x18, 0xf0, 0x4d, 0xea, 0x0f, 0xf8, 0xa1, + 0x5a, 0xdf, 0x8e, 0x08, 0xaf, 0x3d, 0x84, 0xd9, 0x94, 0x18, 0xf0, 0x4d, 0xea, 0xf7, 0xf9, 0xa1, 0x75, 0x0c, 0x96, 0xbb, 0x8c, 0x8b, 0x59, 0xec, 0xb7, 0x16, 0xad, 0x14, 0xb6, 0xf9, 0xd3, 0xf1, 0x14, 0xdf, 0xf8, 0x83, 0x0d, 0xa5, 0xd5, 0x30, 0xec, 0xd1, 0xe0, 0xa1, 0xb5, 0xa6, 0x7a, 0x06, 0x2e, 0x02, 0x1b, 0xbd, 0xa0, 0x6d, 0x25, 0x08, 0xe4, 0x06, 0x14, 0x45, 0xee, 0xf0, 0xb2, 0xfa, - 0x4d, 0xe5, 0x38, 0xf5, 0xd8, 0x8a, 0x8b, 0xc9, 0x5b, 0x30, 0xc5, 0xff, 0xe7, 0xda, 0x26, 0x04, + 0x4d, 0xe5, 0x38, 0xf5, 0xd8, 0x8a, 0x8b, 0xc9, 0x9b, 0x30, 0xc5, 0xff, 0xe7, 0xda, 0x26, 0x04, 0x8e, 0x11, 0x06, 0x81, 0xce, 0xb5, 0xd3, 0xd2, 0xd0, 0x98, 0x3f, 0x2d, 0x3f, 0x7a, 0xc3, 0x5a, - 0x54, 0x48, 0xfc, 0x69, 0xf9, 0x7d, 0x1c, 0x6c, 0x93, 0x8a, 0x44, 0x5e, 0x83, 0x7c, 0x75, 0xc9, + 0x54, 0x48, 0xfc, 0x69, 0xf9, 0x7d, 0x1c, 0x6c, 0x93, 0x8a, 0x44, 0x5e, 0x85, 0x7c, 0x75, 0xc9, 0x52, 0x1f, 0x6a, 0xb3, 0x5b, 0x01, 0x7f, 0x98, 0x50, 0x7b, 0x57, 0xbe, 0xba, 0x64, 0x91, 0x45, 0xfc, 0x40, 0xe3, 0xbe, 0xcb, 0x36, 0xba, 0xe3, 0x89, 0xd6, 0xf8, 0x02, 0xa6, 0x9e, 0x49, 0x4a, 0x3c, 0x72, 0x13, 0x26, 0x96, 0xdd, 0xd0, 0x6f, 0xdb, 0x07, 0xe2, 0xc2, 0x2b, 0xa6, 0x8b, 0x38, @@ -7244,19 +7399,19 @@ var fileDescriptor_d938547f84707355 = []byte{ 0xc8, 0x00, 0xda, 0xad, 0x39, 0x06, 0xc0, 0xeb, 0x2c, 0x3c, 0x2b, 0xb7, 0xa4, 0x5c, 0x67, 0x49, 0x67, 0xe3, 0x0a, 0x9c, 0xc1, 0xa4, 0x22, 0x78, 0x9a, 0x49, 0x45, 0x4d, 0xb8, 0x74, 0x07, 0x1d, 0xbc, 0x3a, 0x0d, 0xf0, 0x91, 0x9d, 0x16, 0x06, 0xe5, 0x1f, 0x5a, 0xab, 0x22, 0x13, 0xf9, 0xfa, - 0x61, 0xbf, 0xf2, 0x32, 0xf7, 0x01, 0xf1, 0xa3, 0xad, 0xf8, 0x54, 0x0f, 0x47, 0x4a, 0x3d, 0x3a, + 0x61, 0xbf, 0xf2, 0x12, 0xf7, 0x01, 0xf1, 0xa3, 0xad, 0xf8, 0x54, 0x0f, 0x47, 0x4a, 0x3d, 0x3a, 0x3a, 0x8c, 0x11, 0xf9, 0x3a, 0x9c, 0xcf, 0x2a, 0x12, 0x39, 0xc9, 0xf8, 0x06, 0x50, 0x76, 0x05, 0xea, 0x15, 0xd1, 0x2c, 0x0e, 0x64, 0x0d, 0xca, 0x1c, 0x5e, 0x75, 0x3a, 0x6e, 0x77, 0xa5, 0x63, 0xbb, 0x6d, 0xcc, 0x50, 0x16, 0x69, 0xe6, 0x82, 0xab, 0xcd, 0x0a, 0x1b, 0x94, 0x95, 0x6a, 0x29, 0x0f, 0x29, 0x4a, 0x34, 0x47, 0xf5, 0xea, 0xfd, 0xb5, 0x67, 0xd5, 0x1c, 0x69, 0x7d, 0x3b, 0xda, 0x1c, 0xa5, 0xc4, 0x20, 0xcd, 0x91, 0x06, 0x4e, 0x9b, 0xa3, 0x14, 0x8d, 0x95, 0xc2, 0x36, 0xff, - 0xf3, 0x78, 0x8a, 0xaf, 0x30, 0x47, 0x26, 0x8c, 0x73, 0x6b, 0xa3, 0xbe, 0x88, 0xc1, 0x6d, 0x91, + 0xd3, 0x78, 0x8a, 0xaf, 0x30, 0x47, 0x26, 0x8c, 0x73, 0x6b, 0xa3, 0xbe, 0x88, 0xc1, 0x6d, 0x91, 0x25, 0x4a, 0xd8, 0x3e, 0xbf, 0x5e, 0x5f, 0x57, 0x1f, 0xe2, 0x09, 0x43, 0xcf, 0x62, 0x30, 0x36, - 0x42, 0xb8, 0x79, 0xcf, 0x27, 0x23, 0xc4, 0x36, 0xee, 0xe2, 0xab, 0x48, 0xaf, 0x24, 0xf3, 0xb8, + 0x42, 0xb8, 0x79, 0xcf, 0x27, 0x23, 0xc4, 0x36, 0xee, 0xe2, 0xab, 0x48, 0x2f, 0x27, 0xf3, 0xb8, 0x90, 0xc8, 0x5b, 0xcc, 0xe3, 0x64, 0xf6, 0x2e, 0xc1, 0x5c, 0x35, 0x0c, 0x69, 0x10, 0xf1, 0x77, 0x22, 0xc3, 0x5e, 0x87, 0x06, 0x42, 0xd7, 0x84, 0x8d, 0xc1, 0x4a, 0xed, 0x56, 0x68, 0x0d, 0x45, 0x24, 0xd7, 0xa1, 0x58, 0xed, 0x39, 0x2e, 0xed, 0xb6, 0xa8, 0xb0, 0x33, 0x18, 0xc2, 0xb3, 0x05, - 0xcc, 0x8a, 0x4b, 0xc9, 0xc7, 0x70, 0x41, 0x10, 0x49, 0x83, 0x23, 0x24, 0xc0, 0x6d, 0x0d, 0xdf, + 0xcc, 0x8a, 0x4b, 0xc9, 0x47, 0x70, 0x41, 0x10, 0x49, 0x83, 0x23, 0x24, 0xc0, 0x6d, 0x0d, 0xdf, 0xb7, 0x88, 0xb9, 0x20, 0xcd, 0x54, 0x43, 0x88, 0x24, 0x9b, 0x92, 0x54, 0xa1, 0xbc, 0x82, 0xa7, 0x5b, 0xf2, 0xdb, 0x68, 0x5e, 0x20, 0x3e, 0xa4, 0x86, 0x96, 0x8b, 0x9f, 0x7c, 0x35, 0x9c, 0xb8, 0xd0, 0x1a, 0x40, 0x27, 0xf7, 0x60, 0x36, 0x0d, 0x63, 0xf6, 0xb8, 0x94, 0x7c, 0x8e, 0x6d, 0x80, @@ -7266,35 +7421,44 @@ var fileDescriptor_d938547f84707355 = []byte{ 0x5c, 0x35, 0x3c, 0xe8, 0x74, 0x68, 0x14, 0xe0, 0xb7, 0xa6, 0xf0, 0x13, 0x22, 0xa6, 0x48, 0x75, 0x98, 0x57, 0xbe, 0xfa, 0x83, 0x9f, 0x89, 0xd1, 0x72, 0xae, 0x34, 0x9e, 0xda, 0xf2, 0x31, 0x35, 0xe2, 0xf2, 0xd1, 0x86, 0x73, 0x2b, 0xdd, 0x56, 0x70, 0x80, 0x57, 0x86, 0x64, 0xe3, 0xa6, 0x8f, - 0x69, 0xdc, 0xcb, 0xa2, 0x71, 0x57, 0x6c, 0xa9, 0x61, 0x59, 0xcd, 0x1b, 0x64, 0x6c, 0xfe, 0x3a, - 0x94, 0xd3, 0xb2, 0xfc, 0x9c, 0xdf, 0x7c, 0x3b, 0x49, 0xbe, 0x27, 0x1b, 0xe9, 0x74, 0x5f, 0xc8, + 0x69, 0xdc, 0x4b, 0xa2, 0x71, 0x57, 0x6c, 0xa9, 0x61, 0x59, 0xcd, 0x1b, 0x64, 0x6c, 0xfe, 0x1a, + 0x94, 0xd3, 0xb2, 0xfc, 0x8c, 0xdf, 0x7c, 0x3b, 0x49, 0xbe, 0x27, 0x1b, 0xe9, 0x74, 0x5f, 0xc8, 0x4d, 0xed, 0xc3, 0x5e, 0x46, 0x72, 0xe3, 0x49, 0xf9, 0x04, 0x97, 0xf6, 0x39, 0x2f, 0x39, 0x8d, - 0x73, 0x59, 0xd3, 0xd8, 0xfc, 0xed, 0x1c, 0x9c, 0xe3, 0x29, 0x6a, 0x89, 0x85, 0x39, 0xad, 0xdb, - 0xd2, 0x0f, 0x34, 0xe3, 0x2c, 0x23, 0x40, 0xa9, 0xde, 0x0d, 0xdf, 0x9d, 0x9a, 0x9f, 0xc0, 0x85, + 0x73, 0x59, 0xd3, 0xd8, 0xfc, 0xad, 0x1c, 0x9c, 0xe3, 0x29, 0x6a, 0x89, 0x85, 0x39, 0xad, 0xdb, + 0xd2, 0xf7, 0x35, 0xe3, 0x2c, 0x23, 0x40, 0xa9, 0xde, 0x0d, 0xdf, 0x9d, 0x9a, 0x1f, 0xc3, 0x85, 0x01, 0x51, 0xa0, 0x81, 0x5e, 0x96, 0xc9, 0x81, 0x03, 0x26, 0x7a, 0x2e, 0xbb, 0x92, 0xad, 0x37, - 0xad, 0x01, 0x0a, 0xf3, 0x8f, 0x72, 0x03, 0xfc, 0xc5, 0xd6, 0x57, 0xf5, 0x04, 0x8d, 0x93, 0x79, - 0x82, 0xb9, 0xcf, 0xe4, 0x09, 0xe6, 0x47, 0xf1, 0x04, 0x3f, 0x86, 0xe9, 0x4d, 0x6a, 0x33, 0x8f, + 0xac, 0x01, 0x0a, 0xf3, 0x0f, 0x73, 0x03, 0xfc, 0xc5, 0xd6, 0x57, 0xf5, 0x04, 0x8d, 0x93, 0x79, + 0x82, 0xb9, 0x4f, 0xe5, 0x09, 0xe6, 0x47, 0xf1, 0x04, 0x3f, 0x82, 0xe9, 0x4d, 0x6a, 0x33, 0x8f, 0x46, 0xdc, 0x24, 0x2a, 0x68, 0x1f, 0xdd, 0x62, 0x65, 0xd2, 0xbe, 0xc4, 0x97, 0x73, 0x22, 0x46, 0xc0, 0x4c, 0x0b, 0xbf, 0x6a, 0x64, 0xe9, 0x1c, 0xd4, 0x45, 0x63, 0x6c, 0xf8, 0xa2, 0x61, 0x7e, - 0x3f, 0x07, 0x93, 0x0a, 0x7b, 0xf2, 0x65, 0x98, 0x5a, 0x0f, 0x76, 0xec, 0xae, 0xfb, 0x97, 0x6d, + 0x3f, 0x07, 0x93, 0x0a, 0x7b, 0xf2, 0x65, 0x98, 0x5a, 0x0f, 0x76, 0xec, 0xae, 0xfb, 0x17, 0x6d, 0x25, 0xe8, 0x86, 0xcd, 0xf7, 0x14, 0xb8, 0xa5, 0x61, 0x61, 0xb2, 0x03, 0xb5, 0x3b, 0xaa, 0xe2, 0xb3, 0xe6, 0x59, 0x08, 0x55, 0x2e, 0x48, 0xe5, 0x47, 0xb8, 0x20, 0xa5, 0xdf, 0x2e, 0x2a, 0x9c, - 0xfc, 0x76, 0x91, 0x76, 0x19, 0x68, 0xec, 0x84, 0x97, 0x81, 0xcc, 0xdf, 0xcd, 0x41, 0x59, 0x7c, + 0xfc, 0x76, 0x91, 0x76, 0x19, 0x68, 0xec, 0x84, 0x97, 0x81, 0xcc, 0xdf, 0xc9, 0x41, 0x59, 0x7c, 0x9e, 0x4a, 0x06, 0x6a, 0x9f, 0xad, 0x37, 0x69, 0xf5, 0xce, 0x1d, 0x71, 0xa8, 0x51, 0xf8, 0xf1, - 0x1f, 0x56, 0xf0, 0x63, 0x43, 0x69, 0x71, 0xc8, 0x8f, 0x0d, 0xe9, 0xf0, 0x74, 0x3a, 0x72, 0x9a, - 0xca, 0x4a, 0xe3, 0x9b, 0x3f, 0xcb, 0xa5, 0x79, 0x0b, 0x6f, 0xea, 0x15, 0x98, 0xe0, 0x2f, 0xeb, + 0x1f, 0x54, 0xf0, 0x63, 0x43, 0x69, 0x71, 0xc8, 0x8f, 0x0d, 0xe9, 0xf0, 0x74, 0x3a, 0x72, 0x9a, + 0xca, 0x4a, 0xe3, 0x9b, 0x3f, 0xcb, 0xa5, 0x79, 0x0b, 0x6f, 0xea, 0x65, 0x98, 0xe0, 0x2f, 0xeb, 0xcb, 0x8c, 0x49, 0xf1, 0x2e, 0x00, 0x82, 0x2c, 0x59, 0x76, 0x92, 0xc4, 0xf4, 0xe3, 0xbe, 0x38, - 0x45, 0xde, 0x86, 0x29, 0x3c, 0xe5, 0xaf, 0x3a, 0x4e, 0x40, 0xc3, 0x50, 0x38, 0x5a, 0x78, 0xe2, + 0x45, 0xde, 0x82, 0x29, 0x3c, 0xe5, 0xaf, 0x3a, 0x4e, 0x40, 0xc3, 0x50, 0x38, 0x5a, 0x78, 0xe2, 0xf2, 0x98, 0x36, 0x1b, 0x3c, 0x1b, 0x00, 0xbf, 0x08, 0xad, 0xe1, 0x91, 0x25, 0x38, 0xaf, 0x25, 0x95, 0x48, 0xfa, 0xb1, 0x64, 0xb5, 0xe0, 0x9f, 0x44, 0xe6, 0xc4, 0x99, 0xc8, 0x4f, 0xef, 0x6b, - 0x7b, 0xaf, 0xbd, 0x92, 0xfe, 0xa0, 0x24, 0x99, 0x80, 0xbc, 0x55, 0x7d, 0x54, 0x3e, 0x43, 0x00, - 0xc6, 0x37, 0xee, 0x2d, 0xd5, 0x6f, 0xdd, 0x2a, 0x1b, 0xaf, 0x7d, 0x08, 0x53, 0xea, 0xfb, 0x28, - 0xa4, 0x08, 0x85, 0x07, 0xeb, 0x0f, 0x56, 0xca, 0x67, 0xc8, 0x24, 0x4c, 0x6c, 0xac, 0x3c, 0x58, - 0x5e, 0x7d, 0x70, 0xa7, 0x6c, 0x90, 0x29, 0x28, 0x56, 0x37, 0x36, 0xac, 0xf5, 0xad, 0x95, 0xe5, - 0x72, 0x8e, 0x31, 0x58, 0x5e, 0x79, 0xb0, 0xba, 0xb2, 0x5c, 0xce, 0xd7, 0xca, 0x9f, 0xfe, 0xe9, - 0x0b, 0x67, 0x3e, 0xfd, 0xf9, 0x0b, 0xc6, 0xcf, 0x7e, 0xfe, 0x82, 0xf1, 0x3f, 0x7e, 0xfe, 0x82, - 0xd1, 0x1c, 0xc7, 0xe0, 0xfa, 0x9b, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xac, 0x88, 0xf8, 0x1e, - 0x83, 0x89, 0x00, 0x00, + 0x7b, 0xe6, 0xff, 0x36, 0xd8, 0x5c, 0x6b, 0xed, 0x3d, 0x63, 0x29, 0xf3, 0xac, 0x4b, 0x47, 0x38, + 0xfb, 0xff, 0xd1, 0xe0, 0x49, 0xaf, 0x42, 0x7d, 0xde, 0x86, 0x71, 0xfe, 0x8e, 0xbf, 0x48, 0x18, + 0x55, 0xb9, 0xf0, 0x82, 0xe4, 0x54, 0x82, 0x7f, 0x0d, 0xc0, 0x12, 0x04, 0x6c, 0xcb, 0xac, 0xe7, + 0xde, 0xa2, 0xe3, 0x39, 0x98, 0x74, 0x2b, 0xb1, 0xd4, 0x37, 0xaf, 0x46, 0x7b, 0x4b, 0xd1, 0x38, + 0xfe, 0xcd, 0x2b, 0xf3, 0xc7, 0x39, 0xde, 0x1f, 0xd1, 0xa8, 0x51, 0x1f, 0x73, 0xb9, 0x06, 0x05, + 0xa6, 0x07, 0xea, 0x8b, 0x39, 0x4c, 0x57, 0x54, 0x3c, 0x56, 0xce, 0x3a, 0x29, 0xe6, 0x9b, 0x18, + 0x49, 0xec, 0xa4, 0x48, 0x91, 0x51, 0x3b, 0x29, 0xcf, 0x38, 0x6e, 0xc0, 0x18, 0x1a, 0x67, 0x31, + 0x2b, 0x70, 0xa2, 0xa1, 0xfd, 0x56, 0x27, 0x1a, 0x62, 0xe0, 0xd3, 0x86, 0x9e, 0x23, 0x37, 0x1c, + 0xfc, 0x69, 0x43, 0xfd, 0x15, 0x4a, 0x2c, 0x27, 0x6f, 0x29, 0x39, 0x92, 0x62, 0xa3, 0x81, 0x11, + 0x90, 0xce, 0xb6, 0xdd, 0xe0, 0x09, 0x7d, 0xaa, 0x79, 0x8e, 0x51, 0x5f, 0x7d, 0x39, 0xfd, 0xc5, + 0x54, 0x32, 0x01, 0x79, 0xab, 0xfa, 0xa8, 0x7c, 0x86, 0x00, 0x8c, 0x6f, 0xdc, 0x5b, 0xaa, 0xdf, + 0xba, 0x55, 0x36, 0x5e, 0xfd, 0x00, 0xa6, 0xd4, 0x07, 0x80, 0x48, 0x11, 0x0a, 0x0f, 0xd6, 0x1f, + 0xac, 0x94, 0xcf, 0x90, 0x49, 0x98, 0xd8, 0x58, 0x79, 0xb0, 0xbc, 0xfa, 0xe0, 0x4e, 0xd9, 0x20, + 0x53, 0x50, 0xac, 0x6e, 0x6c, 0x58, 0xeb, 0x5b, 0x2b, 0xcb, 0xe5, 0x1c, 0x63, 0xb0, 0xbc, 0xf2, + 0x60, 0x75, 0x65, 0xb9, 0x9c, 0xaf, 0x95, 0x3f, 0xf9, 0x93, 0x17, 0xce, 0x7c, 0xf2, 0xf3, 0x17, + 0x8c, 0x9f, 0xfd, 0xfc, 0x05, 0xe3, 0xbf, 0xff, 0xfc, 0x05, 0xa3, 0x39, 0x8e, 0x03, 0xfa, 0xc6, + 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x50, 0x01, 0xd8, 0x00, 0x64, 0x8c, 0x00, 0x00, } func (m *KeepAlive) Marshal() (dAtA []byte, err error) { @@ -15417,6 +15581,197 @@ func (m *TrustedClusterSpecV2) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *LockV2) 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 *LockV2) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LockV2) 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.Spec.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Version))) + i-- + dAtA[i] = 0x1a + } + if len(m.SubKind) > 0 { + i -= len(m.SubKind) + copy(dAtA[i:], m.SubKind) + i = encodeVarintTypes(dAtA, i, uint64(len(m.SubKind))) + i-- + dAtA[i] = 0x12 + } + if len(m.Kind) > 0 { + i -= len(m.Kind) + copy(dAtA[i:], m.Kind) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Kind))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LockSpecV2) 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 *LockSpecV2) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LockSpecV2) 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.Expires != nil { + n145, err145 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Expires, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expires):]) + if err145 != nil { + return 0, err145 + } + i -= n145 + i = encodeVarintTypes(dAtA, i, uint64(n145)) + i-- + dAtA[i] = 0x1a + } + if len(m.Message) > 0 { + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x12 + } + { + size, err := m.Target.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *LockTarget) 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 *LockTarget) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LockTarget) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if len(m.MFADevice) > 0 { + i -= len(m.MFADevice) + copy(dAtA[i:], m.MFADevice) + i = encodeVarintTypes(dAtA, i, uint64(len(m.MFADevice))) + i-- + dAtA[i] = 0x32 + } + if len(m.Node) > 0 { + i -= len(m.Node) + copy(dAtA[i:], m.Node) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Node))) + i-- + dAtA[i] = 0x2a + } + if len(m.Login) > 0 { + i -= len(m.Login) + copy(dAtA[i:], m.Login) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Login))) + i-- + dAtA[i] = 0x22 + } + if len(m.Cluster) > 0 { + i -= len(m.Cluster) + copy(dAtA[i:], m.Cluster) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Cluster))) + i-- + dAtA[i] = 0x1a + } + if len(m.Role) > 0 { + i -= len(m.Role) + copy(dAtA[i:], m.Role) + i = encodeVarintTypes(dAtA, i, uint64(len(m.Role))) + i-- + dAtA[i] = 0x12 + } + if len(m.User) > 0 { + i -= len(m.User) + copy(dAtA[i:], m.User) + i = encodeVarintTypes(dAtA, i, uint64(len(m.User))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { offset -= sovTypes(v) base := offset @@ -19060,6 +19415,92 @@ func (m *TrustedClusterSpecV2) Size() (n int) { return n } +func (m *LockV2) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Kind) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.SubKind) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Version) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = m.Metadata.Size() + n += 1 + l + sovTypes(uint64(l)) + l = m.Spec.Size() + n += 1 + l + sovTypes(uint64(l)) + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *LockSpecV2) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Target.Size() + n += 1 + l + sovTypes(uint64(l)) + l = len(m.Message) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.Expires != nil { + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expires) + n += 1 + l + sovTypes(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *LockTarget) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.User) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Role) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Cluster) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Login) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.Node) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + l = len(m.MFADevice) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovTypes(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -42097,11 +42538,539 @@ func (m *AttributeMapping) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Value = string(dAtA[iNdEx:postIndex]) + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + 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 *AsymmetricKeyPair) 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 ErrIntOverflowTypes + } + 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: AsymmetricKeyPair: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AsymmetricKeyPair: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrivateKey", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PrivateKey = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Cert", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Cert = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + 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 *GithubConnectorV3) 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 ErrIntOverflowTypes + } + 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: GithubConnectorV3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GithubConnectorV3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Kind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SubKind", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SubKind = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + 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 ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + 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 *GithubConnectorV3List) 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 ErrIntOverflowTypes + } + 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: GithubConnectorV3List: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GithubConnectorV3List: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GithubConnectors", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GithubConnectors = append(m.GithubConnectors, &GithubConnectorV3{}) + if err := m.GithubConnectors[len(m.GithubConnectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + 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 *GithubConnectorSpecV3) 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 ErrIntOverflowTypes + } + 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: GithubConnectorSpecV3: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GithubConnectorSpecV3: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientID = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClientSecret", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42129,64 +43098,45 @@ func (m *AttributeMapping) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) + m.ClientSecret = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(dAtA[iNdEx:]) - if err != nil { - return err + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RedirectURL", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTypes + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes } - m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AsymmetricKeyPair) 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 ErrIntOverflowTypes + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes } - if iNdEx >= l { + if postIndex > 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: AsymmetricKeyPair: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AsymmetricKeyPair: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.RedirectURL = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrivateKey", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TeamsToLogins", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -42196,27 +43146,29 @@ func (m *AsymmetricKeyPair) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.PrivateKey = string(dAtA[iNdEx:postIndex]) + m.TeamsToLogins = append(m.TeamsToLogins, TeamMapping{}) + if err := m.TeamsToLogins[len(m.TeamsToLogins)-1].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 Cert", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Display", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42244,7 +43196,7 @@ func (m *AsymmetricKeyPair) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Cert = string(dAtA[iNdEx:postIndex]) + m.Display = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -42268,7 +43220,7 @@ func (m *AsymmetricKeyPair) Unmarshal(dAtA []byte) error { } return nil } -func (m *GithubConnectorV3) Unmarshal(dAtA []byte) error { +func (m *TeamMapping) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -42291,15 +43243,15 @@ func (m *GithubConnectorV3) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GithubConnectorV3: wiretype end group for non-group") + return fmt.Errorf("proto: TeamMapping: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GithubConnectorV3: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TeamMapping: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Organization", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42327,11 +43279,11 @@ func (m *GithubConnectorV3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Kind = string(dAtA[iNdEx:postIndex]) + m.Organization = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SubKind", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Team", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42359,11 +43311,11 @@ func (m *GithubConnectorV3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SubKind = string(dAtA[iNdEx:postIndex]) + m.Team = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Logins", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42391,13 +43343,13 @@ func (m *GithubConnectorV3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Version = string(dAtA[iNdEx:postIndex]) + m.Logins = append(m.Logins, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KubeGroups", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -42407,30 +43359,29 @@ func (m *GithubConnectorV3) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.KubeGroups = append(m.KubeGroups, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field KubeUsers", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -42440,24 +43391,23 @@ func (m *GithubConnectorV3) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.KubeUsers = append(m.KubeUsers, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex @@ -42481,7 +43431,7 @@ func (m *GithubConnectorV3) Unmarshal(dAtA []byte) error { } return nil } -func (m *GithubConnectorV3List) Unmarshal(dAtA []byte) error { +func (m *TrustedClusterV2) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -42504,17 +43454,17 @@ func (m *GithubConnectorV3List) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GithubConnectorV3List: wiretype end group for non-group") + return fmt.Errorf("proto: TrustedClusterV2: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GithubConnectorV3List: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TrustedClusterV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GithubConnectors", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -42524,80 +43474,27 @@ func (m *GithubConnectorV3List) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.GithubConnectors = append(m.GithubConnectors, &GithubConnectorV3{}) - if err := m.GithubConnectors[len(m.GithubConnectors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Kind = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTypes(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTypes - } - 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 *GithubConnectorSpecV3) 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 ErrIntOverflowTypes - } - 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: GithubConnectorSpecV3: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GithubConnectorSpecV3: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientID", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SubKind", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42625,11 +43522,11 @@ func (m *GithubConnectorSpecV3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ClientID = string(dAtA[iNdEx:postIndex]) + m.SubKind = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientSecret", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42657,13 +43554,13 @@ func (m *GithubConnectorSpecV3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ClientSecret = string(dAtA[iNdEx:postIndex]) + m.Version = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RedirectURL", 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 ErrIntOverflowTypes @@ -42673,27 +43570,28 @@ func (m *GithubConnectorSpecV3) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.RedirectURL = string(dAtA[iNdEx:postIndex]) + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 4: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TeamsToLogins", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -42720,16 +43618,66 @@ func (m *GithubConnectorSpecV3) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.TeamsToLogins = append(m.TeamsToLogins, TeamMapping{}) - if err := m.TeamsToLogins[len(m.TeamsToLogins)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + 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 *TrustedClusterV2List) 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 ErrIntOverflowTypes + } + 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: TrustedClusterV2List: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TrustedClusterV2List: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Display", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field TrustedClusters", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -42739,23 +43687,25 @@ func (m *GithubConnectorSpecV3) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.Display = string(dAtA[iNdEx:postIndex]) + m.TrustedClusters = append(m.TrustedClusters, &TrustedClusterV2{}) + if err := m.TrustedClusters[len(m.TrustedClusters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -42779,7 +43729,7 @@ func (m *GithubConnectorSpecV3) Unmarshal(dAtA []byte) error { } return nil } -func (m *TeamMapping) Unmarshal(dAtA []byte) error { +func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -42802,15 +43752,35 @@ func (m *TeamMapping) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TeamMapping: wiretype end group for non-group") + return fmt.Errorf("proto: TrustedClusterSpecV2: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TeamMapping: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: TrustedClusterSpecV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Enabled = bool(v != 0) + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Organization", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42838,11 +43808,11 @@ func (m *TeamMapping) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Organization = string(dAtA[iNdEx:postIndex]) + m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Team", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42870,11 +43840,11 @@ func (m *TeamMapping) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Team = string(dAtA[iNdEx:postIndex]) + m.Token = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Logins", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ProxyAddress", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42902,11 +43872,11 @@ func (m *TeamMapping) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Logins = append(m.Logins, string(dAtA[iNdEx:postIndex])) + m.ProxyAddress = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KubeGroups", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReverseTunnelAddress", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -42934,13 +43904,13 @@ func (m *TeamMapping) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.KubeGroups = append(m.KubeGroups, string(dAtA[iNdEx:postIndex])) + m.ReverseTunnelAddress = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KubeUsers", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RoleMap", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -42950,23 +43920,25 @@ func (m *TeamMapping) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.KubeUsers = append(m.KubeUsers, string(dAtA[iNdEx:postIndex])) + m.RoleMap = append(m.RoleMap, RoleMapping{}) + if err := m.RoleMap[len(m.RoleMap)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -42990,7 +43962,7 @@ func (m *TeamMapping) Unmarshal(dAtA []byte) error { } return nil } -func (m *TrustedClusterV2) Unmarshal(dAtA []byte) error { +func (m *LockV2) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -43013,10 +43985,10 @@ func (m *TrustedClusterV2) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TrustedClusterV2: wiretype end group for non-group") + return fmt.Errorf("proto: LockV2: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TrustedClusterV2: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LockV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -43203,7 +44175,7 @@ func (m *TrustedClusterV2) Unmarshal(dAtA []byte) error { } return nil } -func (m *TrustedClusterV2List) Unmarshal(dAtA []byte) error { +func (m *LockSpecV2) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -43226,15 +44198,15 @@ func (m *TrustedClusterV2List) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TrustedClusterV2List: wiretype end group for non-group") + return fmt.Errorf("proto: LockSpecV2: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TrustedClusterV2List: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LockSpecV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TrustedClusters", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -43261,8 +44233,75 @@ func (m *TrustedClusterV2List) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.TrustedClusters = append(m.TrustedClusters, &TrustedClusterV2{}) - if err := m.TrustedClusters[len(m.TrustedClusters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Expires", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Expires == nil { + m.Expires = new(time.Time) + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Expires, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -43288,7 +44327,7 @@ func (m *TrustedClusterV2List) Unmarshal(dAtA []byte) error { } return nil } -func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { +func (m *LockTarget) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -43311,17 +44350,17 @@ func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: TrustedClusterSpecV2: wiretype end group for non-group") + return fmt.Errorf("proto: LockTarget: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: TrustedClusterSpecV2: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: LockTarget: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) } - var v int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -43331,15 +44370,27 @@ func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - v |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - m.Enabled = bool(v != 0) + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.User = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -43367,11 +44418,11 @@ func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex])) + m.Role = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -43399,11 +44450,11 @@ func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Token = string(dAtA[iNdEx:postIndex]) + m.Cluster = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ProxyAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Login", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -43431,11 +44482,11 @@ func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ProxyAddress = string(dAtA[iNdEx:postIndex]) + m.Login = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReverseTunnelAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -43463,13 +44514,13 @@ func (m *TrustedClusterSpecV2) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ReverseTunnelAddress = string(dAtA[iNdEx:postIndex]) + m.Node = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RoleMap", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MFADevice", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTypes @@ -43479,25 +44530,23 @@ func (m *TrustedClusterSpecV2) 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 ErrInvalidLengthTypes } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTypes } if postIndex > l { return io.ErrUnexpectedEOF } - m.RoleMap = append(m.RoleMap, RoleMapping{}) - if err := m.RoleMap[len(m.RoleMap)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.MFADevice = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex diff --git a/api/types/types.proto b/api/types/types.proto index 7767b06efb626..f7188f7394016 100644 --- a/api/types/types.proto +++ b/api/types/types.proto @@ -2186,3 +2186,56 @@ message TrustedClusterSpecV2 { repeated RoleMapping RoleMap = 6 [ (gogoproto.nullable) = false, (gogoproto.jsontag) = "role_map,omitempty" ]; } + +// LockV2 represents a lock. +message LockV2 { + // Kind is a resource kind. + string Kind = 1 [ (gogoproto.jsontag) = "kind" ]; + // SubKind is an optional resource sub kind, used in some resources. + string SubKind = 2 [ (gogoproto.jsontag) = "sub_kind,omitempty" ]; + // Version is a resource version. + string Version = 3 [ (gogoproto.jsontag) = "version" ]; + // Metadata holds resource metadata. + Metadata Metadata = 4 [ (gogoproto.nullable) = false, (gogoproto.jsontag) = "metadata" ]; + // Spec is a Lock specification. + LockSpecV2 Spec = 5 [ (gogoproto.nullable) = false, (gogoproto.jsontag) = "spec" ]; +} + +// LockSpecV2 is a Lock specification. +message LockSpecV2 { + // Target describes the set of interactions that the lock applies to. + LockTarget Target = 1 [ (gogoproto.nullable) = false, (gogoproto.jsontag) = "target" ]; + // Message is the message displayed to locked-out users. + string Message = 2 [ (gogoproto.jsontag) = "message,omitempty" ]; + // Expires if set specifies when the lock ceases to be in force. + google.protobuf.Timestamp Expires = 3 [ + (gogoproto.stdtime) = true, + (gogoproto.nullable) = true, + (gogoproto.jsontag) = "expires,omitempty" + ]; +} + +// LockTarget lists the attributes of interactions to be disabled. +message LockTarget { + // User specifies the name of a Teleport user. + string User = 1 [ (gogoproto.jsontag) = "user,omitempty" ]; + + // Role specifies the name of an RBAC role known to the root cluster. + // In remote clusters, this constraint is evaluated before translating to local roles. + string Role = 2 [ (gogoproto.jsontag) = "role,omitempty" ]; + + // Cluster specifies the name of a leaf Teleport cluster. + // This prevents the root cluster's users from connecting to nodes in the leaf cluster + // but does not prevent the leaf cluster from heartbeating back to the root cluster. + string Cluster = 3 [ (gogoproto.jsontag) = "cluster,omitempty" ]; + + // Login specifies the name of a local UNIX user. + string Login = 4 [ (gogoproto.jsontag) = "login,omitempty" ]; + + // Node specifies the name or UUID of a node. + // A matching node is also unregistered and prevented from registering. + string Node = 5 [ (gogoproto.jsontag) = "node,omitempty" ]; + + // MFADevice specifies the UUID of a user MFA device. + string MFADevice = 6 [ (gogoproto.jsontag) = "mfa_device,omitempty" ]; +} diff --git a/lib/utils/conv.go b/api/utils/conv.go similarity index 89% rename from lib/utils/conv.go rename to api/utils/conv.go index cff5ea8628ced..4d9678e27abac 100644 --- a/lib/utils/conv.go +++ b/api/utils/conv.go @@ -19,7 +19,6 @@ package utils import ( "encoding/json" - "fmt" "github.com/gravitational/trace" ) @@ -53,10 +52,10 @@ import ( func ObjectToStruct(in interface{}, out interface{}) error { bytes, err := json.Marshal(in) if err != nil { - return trace.Wrap(err, fmt.Sprintf("failed to marshal %v, %v", in, err)) + return trace.Wrap(err, "failed to marshal %v, %v", in, err) } if err := json.Unmarshal(bytes, out); err != nil { - return trace.Wrap(err, fmt.Sprintf("failed to unmarshal %v into %T, %v", in, out, err)) + return trace.Wrap(err, "failed to unmarshal %v into %T, %v", in, out, err) } return nil } diff --git a/lib/auth/api.go b/lib/auth/api.go index b9aa96f9b85bd..4f96b283e08ee 100644 --- a/lib/auth/api.go +++ b/lib/auth/api.go @@ -154,6 +154,12 @@ type ReadAccessPoint interface { // GetDatabaseServers returns all registered database proxy servers. GetDatabaseServers(ctx context.Context, namespace string, opts ...services.MarshalOption) ([]types.DatabaseServer, error) + + // GetLock gets a lock by name. + GetLock(ctx context.Context, name string) (types.Lock, error) + + // GetLocks gets all locks, matching at least one of the targets when specified. + GetLocks(context.Context, ...types.LockTarget) ([]types.Lock, error) } // AccessPoint is an API interface implemented by a certificate authority (CA) diff --git a/lib/auth/auth.go b/lib/auth/auth.go index 3d9ce66a1618e..0c2b269ef6001 100644 --- a/lib/auth/auth.go +++ b/lib/auth/auth.go @@ -379,27 +379,27 @@ func (a *Server) SetAuditLog(auditLog events.IAuditLog) { a.IAuditLog = auditLog } -// GetAuthPreference gets AuthPreference from the backend. +// GetAuthPreference gets AuthPreference from the cache. func (a *Server) GetAuthPreference(ctx context.Context) (types.AuthPreference, error) { return a.GetCache().GetAuthPreference(ctx) } -// GetClusterConfig gets ClusterConfig from the backend. +// GetClusterConfig gets ClusterConfig from the cache. func (a *Server) GetClusterConfig(opts ...services.MarshalOption) (types.ClusterConfig, error) { return a.GetCache().GetClusterConfig(opts...) } -// GetClusterAuditConfig gets ClusterAuditConfig from the backend. +// GetClusterAuditConfig gets ClusterAuditConfig from the cache. func (a *Server) GetClusterAuditConfig(ctx context.Context, opts ...services.MarshalOption) (types.ClusterAuditConfig, error) { return a.GetCache().GetClusterAuditConfig(ctx, opts...) } -// GetClusterNetworkingConfig gets ClusterNetworkingConfig from the backend. +// GetClusterNetworkingConfig gets ClusterNetworkingConfig from the cache. func (a *Server) GetClusterNetworkingConfig(ctx context.Context, opts ...services.MarshalOption) (types.ClusterNetworkingConfig, error) { return a.GetCache().GetClusterNetworkingConfig(ctx, opts...) } -// GetSessionRecordingConfig gets SessionRecordingConfig from the backend. +// GetSessionRecordingConfig gets SessionRecordingConfig from the cache. func (a *Server) GetSessionRecordingConfig(ctx context.Context, opts ...services.MarshalOption) (types.SessionRecordingConfig, error) { return a.GetCache().GetSessionRecordingConfig(ctx, opts...) } @@ -2242,6 +2242,16 @@ func (a *Server) GetDatabaseServers(ctx context.Context, namespace string, opts return a.GetCache().GetDatabaseServers(ctx, namespace, opts...) } +// GetLock gets a lock by name. +func (a *Server) GetLock(ctx context.Context, name string) (types.Lock, error) { + return a.GetCache().GetLock(ctx, name) +} + +// GetLocks gets all matching locks from the cache. +func (a *Server) GetLocks(ctx context.Context, targets ...types.LockTarget) ([]types.Lock, error) { + return a.GetCache().GetLocks(ctx, targets...) +} + func (a *Server) isMFARequired(ctx context.Context, checker services.AccessChecker, req *proto.IsMFARequiredRequest) (*proto.IsMFARequiredResponse, error) { pref, err := a.GetAuthPreference(ctx) if err != nil { diff --git a/lib/auth/auth_with_roles.go b/lib/auth/auth_with_roles.go index bb3f4a2694c37..ac40c06db7710 100644 --- a/lib/auth/auth_with_roles.go +++ b/lib/auth/auth_with_roles.go @@ -3111,6 +3111,49 @@ func (a *ServerWithRoles) SearchSessionEvents(fromUTC, toUTC time.Time, limit in return events, lastKey, nil } +// GetLock gets a lock by name. +func (a *ServerWithRoles) GetLock(ctx context.Context, name string) (types.Lock, error) { + if err := a.action(apidefaults.Namespace, types.KindLock, types.VerbRead); err != nil { + return nil, trace.Wrap(err) + } + return a.authServer.GetLock(ctx, name) +} + +// GetLocks gets all locks, matching at least one of the targets when specified. +func (a *ServerWithRoles) GetLocks(ctx context.Context, targets ...types.LockTarget) ([]types.Lock, error) { + if err := a.action(apidefaults.Namespace, types.KindLock, types.VerbList); err != nil { + return nil, trace.Wrap(err) + } + if err := a.action(apidefaults.Namespace, types.KindLock, types.VerbRead); err != nil { + return nil, trace.Wrap(err) + } + return a.authServer.GetLocks(ctx, targets...) +} + +// UpsertLock upserts a lock. +func (a *ServerWithRoles) UpsertLock(ctx context.Context, lock types.Lock) error { + if err := a.action(apidefaults.Namespace, types.KindLock, types.VerbCreate); err != nil { + return trace.Wrap(err) + } + if err := a.action(apidefaults.Namespace, types.KindLock, types.VerbUpdate); err != nil { + return trace.Wrap(err) + } + return a.authServer.UpsertLock(ctx, lock) +} + +// DeleteLock deletes a lock. +func (a *ServerWithRoles) DeleteLock(ctx context.Context, name string) error { + if err := a.action(apidefaults.Namespace, types.KindLock, types.VerbDelete); err != nil { + return trace.Wrap(err) + } + return a.authServer.DeleteLock(ctx, name) +} + +// DeleteAllLocks not implemented: can only be called locally. +func (a *ServerWithRoles) DeleteAllLocks(context.Context) error { + return trace.NotImplemented(notImplementedMessage) +} + // NewAdminAuthServer returns auth server authorized as admin, // used for auth server cached access func NewAdminAuthServer(authServer *Server, sessions session.Service, alog events.IAuditLog) (ClientI, error) { diff --git a/lib/auth/grpcserver.go b/lib/auth/grpcserver.go index 6ba2763a9b95a..d5334744a45a5 100644 --- a/lib/auth/grpcserver.go +++ b/lib/auth/grpcserver.go @@ -415,6 +415,10 @@ func eventToGRPC(ctx context.Context, in types.Event) (*proto.Event, error) { out.Resource = &proto.Event_AuthPreference{ AuthPreference: r, } + case *types.LockV2: + out.Resource = &proto.Event_Lock{ + Lock: r, + } default: return nil, trace.BadParameter("resource type %T is not supported", in.Resource) } @@ -1425,7 +1429,7 @@ func (g *GRPCServer) GetRole(ctx context.Context, req *proto.GetRoleRequest) (*t } downgraded, err := downgradeRole(ctx, roleV4) if err != nil { - return nil, trail.ToGRPC(err) + return nil, trace.Wrap(err) } return downgraded, nil } @@ -1448,7 +1452,7 @@ func (g *GRPCServer) GetRoles(ctx context.Context, _ *empty.Empty) (*proto.GetRo } downgraded, err := downgradeRole(ctx, role) if err != nil { - return nil, trail.ToGRPC(err) + return nil, trace.Wrap(err) } rolesV4 = append(rolesV4, downgraded) } @@ -2671,42 +2675,6 @@ func (g *GRPCServer) ResetAuthPreference(ctx context.Context, _ *empty.Empty) (* return &empty.Empty{}, nil } -type grpcContext struct { - *Context - *ServerWithRoles -} - -// authenticate extracts authentication context and returns initialized auth server -func (g *GRPCServer) authenticate(ctx context.Context) (*grpcContext, error) { - // HTTPS server expects auth context to be set by the auth middleware - authContext, err := g.Authorizer.Authorize(ctx) - if err != nil { - // propagate connection problem error so we can differentiate - // between connection failed and access denied - if trace.IsConnectionProblem(err) { - return nil, trace.ConnectionProblem(err, "[10] failed to connect to the database") - } else if trace.IsNotFound(err) { - // user not found, wrap error with access denied - return nil, trace.Wrap(err, "[10] access denied") - } else if trace.IsAccessDenied(err) { - // don't print stack trace, just log the warning - log.Warn(err) - } else { - log.Warn(trace.DebugReport(err)) - } - return nil, trace.AccessDenied("[10] access denied") - } - return &grpcContext{ - Context: authContext, - ServerWithRoles: &ServerWithRoles{ - authServer: g.AuthServer, - context: *authContext, - sessions: g.SessionService, - alog: g.AuthServer.IAuditLog, - }, - }, nil -} - // GetEvents searches for events on the backend and sends them back in a response. func (g *GRPCServer) GetEvents(ctx context.Context, req *proto.GetEventsRequest) (*proto.Events, error) { auth, err := g.authenticate(ctx) @@ -2765,6 +2733,74 @@ func (g *GRPCServer) GetSessionEvents(ctx context.Context, req *proto.GetSession return res, nil } +// GetLock retrieves a lock by name. +func (g *GRPCServer) GetLock(ctx context.Context, req *proto.GetLockRequest) (*types.LockV2, error) { + auth, err := g.authenticate(ctx) + if err != nil { + return nil, trace.Wrap(err) + } + lock, err := auth.GetLock(ctx, req.Name) + if err != nil { + return nil, trace.Wrap(err) + } + lockV2, ok := lock.(*types.LockV2) + if !ok { + return nil, trace.Errorf("unexpected lock type %T", lock) + } + return lockV2, nil +} + +// GetLocks gets all locks, matching at least one of the targets when specified. +func (g *GRPCServer) GetLocks(ctx context.Context, req *proto.GetLocksRequest) (*proto.GetLocksResponse, error) { + auth, err := g.authenticate(ctx) + if err != nil { + return nil, trace.Wrap(err) + } + targets := make([]types.LockTarget, len(req.Targets)) + for i := range req.Targets { + targets[i] = *req.Targets[i] + } + locks, err := auth.GetLocks(ctx, targets...) + if err != nil { + return nil, trace.Wrap(err) + } + var lockV2s []*types.LockV2 + for _, lock := range locks { + lockV2, ok := lock.(*types.LockV2) + if !ok { + return nil, trace.BadParameter("unexpected lock type %T", lock) + } + lockV2s = append(lockV2s, lockV2) + } + return &proto.GetLocksResponse{ + Locks: lockV2s, + }, nil +} + +// UpsertLock upserts a lock. +func (g *GRPCServer) UpsertLock(ctx context.Context, lock *types.LockV2) (*empty.Empty, error) { + auth, err := g.authenticate(ctx) + if err != nil { + return nil, trace.Wrap(err) + } + if err := auth.UpsertLock(ctx, lock); err != nil { + return nil, trace.Wrap(err) + } + return &empty.Empty{}, nil +} + +// DeleteLock deletes a lock. +func (g *GRPCServer) DeleteLock(ctx context.Context, req *proto.DeleteLockRequest) (*empty.Empty, error) { + auth, err := g.authenticate(ctx) + if err != nil { + return nil, trace.Wrap(err) + } + if err := auth.DeleteLock(ctx, req.Name); err != nil { + return nil, trace.Wrap(err) + } + return &empty.Empty{}, nil +} + // GRPCServerConfig specifies GRPC server configuration type GRPCServerConfig struct { // APIConfig is GRPC server API configuration @@ -2848,3 +2884,39 @@ func grpcErrorConvertStreamInterceptor(next grpc.StreamServerInterceptor) grpc.S return trail.ToGRPC(err) } } + +type grpcContext struct { + *Context + *ServerWithRoles +} + +// authenticate extracts authentication context and returns initialized auth server +func (g *GRPCServer) authenticate(ctx context.Context) (*grpcContext, error) { + // HTTPS server expects auth context to be set by the auth middleware + authContext, err := g.Authorizer.Authorize(ctx) + if err != nil { + // propagate connection problem error so we can differentiate + // between connection failed and access denied + if trace.IsConnectionProblem(err) { + return nil, trace.ConnectionProblem(err, "[10] failed to connect to the database") + } else if trace.IsNotFound(err) { + // user not found, wrap error with access denied + return nil, trace.Wrap(err, "[10] access denied") + } else if trace.IsAccessDenied(err) { + // don't print stack trace, just log the warning + log.Warn(err) + } else { + log.Warn(trace.DebugReport(err)) + } + return nil, trace.AccessDenied("[10] access denied") + } + return &grpcContext{ + Context: authContext, + ServerWithRoles: &ServerWithRoles{ + authServer: g.AuthServer, + context: *authContext, + sessions: g.SessionService, + alog: g.AuthServer.IAuditLog, + }, + }, nil +} diff --git a/lib/auth/grpcserver_test.go b/lib/auth/grpcserver_test.go index 8249d0a9e76cc..254cebb59e5c5 100644 --- a/lib/auth/grpcserver_test.go +++ b/lib/auth/grpcserver_test.go @@ -1026,29 +1026,6 @@ func TestDeleteLastMFADevice(t *testing.T) { }) } -// testOriginDynamicStored tests setting a ResourceWithOrigin via the server -// API always results in the resource being stored with OriginDynamic. -func testOriginDynamicStored(t *testing.T, setWithOrigin func(*Client, string) error, getStored func(*Server) (types.ResourceWithOrigin, error)) { - srv := newTestTLSServer(t) - - // Create a fake user. - user, _, err := CreateUserAndRole(srv.Auth(), "configurer", []string{}) - require.NoError(t, err) - cl, err := srv.NewClient(TestUser(user.GetName())) - require.NoError(t, err) - - for _, origin := range types.OriginValues { - t.Run(fmt.Sprintf("setting with origin %q", origin), func(t *testing.T) { - err := setWithOrigin(cl, origin) - require.NoError(t, err) - - stored, err := getStored(srv.Auth()) - require.NoError(t, err) - require.Equal(t, stored.Origin(), types.OriginDynamic) - }) - } -} - // TestRoleVersions tests that downgraded V3 roles are returned to older // clients, and V4 roles are returned to newer clients. func TestRoleVersions(t *testing.T) { @@ -1160,6 +1137,29 @@ func TestRoleVersions(t *testing.T) { } } +// testOriginDynamicStored tests setting a ResourceWithOrigin via the server +// API always results in the resource being stored with OriginDynamic. +func testOriginDynamicStored(t *testing.T, setWithOrigin func(*Client, string) error, getStored func(*Server) (types.ResourceWithOrigin, error)) { + srv := newTestTLSServer(t) + + // Create a fake user. + user, _, err := CreateUserAndRole(srv.Auth(), "configurer", []string{}) + require.NoError(t, err) + cl, err := srv.NewClient(TestUser(user.GetName())) + require.NoError(t, err) + + for _, origin := range types.OriginValues { + t.Run(fmt.Sprintf("setting with origin %q", origin), func(t *testing.T) { + err := setWithOrigin(cl, origin) + require.NoError(t, err) + + stored, err := getStored(srv.Auth()) + require.NoError(t, err) + require.Equal(t, stored.Origin(), types.OriginDynamic) + }) + } +} + func TestAuthPreferenceOriginDynamic(t *testing.T) { t.Parallel() ctx := context.Background() @@ -1254,16 +1254,16 @@ func TestNodesCRUD(t *testing.T) { // Initially expect no nodes to be returned. nodes, err := clt.GetNodes(ctx, apidefaults.Namespace) require.NoError(t, err) - require.Equal(t, 0, len(nodes)) + require.Empty(t, nodes) - // Create nodes + // Create nodes. _, err = clt.UpsertNode(ctx, node1) require.NoError(t, err) _, err = clt.UpsertNode(ctx, node2) require.NoError(t, err) - // Fail to create largeNode + // Fail to create largeNode. _, err = clt.UpsertNode(ctx, largeNode) require.IsType(t, &trace.LimitExceededError{}, err.(*trace.TraceErr).OrigError()) }) @@ -1275,22 +1275,22 @@ func TestNodesCRUD(t *testing.T) { // list nodes one at a time, last page should be empty nodes, nextKey, err := clt.ListNodes(ctx, apidefaults.Namespace, 1, "") require.NoError(t, err) - require.EqualValues(t, 1, len(nodes)) + require.Len(t, nodes, 1) require.Empty(t, cmp.Diff([]types.Server{node1}, nodes, cmpopts.IgnoreFields(types.Metadata{}, "ID"))) - require.EqualValues(t, backend.NextPaginationKey(node1), nextKey) + require.Equal(t, backend.NextPaginationKey(node1), nextKey) nodes, nextKey, err = clt.ListNodes(ctx, apidefaults.Namespace, 1, nextKey) require.NoError(t, err) - require.EqualValues(t, 1, len(nodes)) + require.Len(t, nodes, 1) require.Empty(t, cmp.Diff([]types.Server{node2}, nodes, cmpopts.IgnoreFields(types.Metadata{}, "ID"))) - require.EqualValues(t, backend.NextPaginationKey(node2), nextKey) + require.Equal(t, backend.NextPaginationKey(node2), nextKey) nodes, nextKey, err = clt.ListNodes(ctx, apidefaults.Namespace, 1, nextKey) require.NoError(t, err) - require.EqualValues(t, 0, len(nodes)) - require.EqualValues(t, "", nextKey) + require.Empty(t, nodes) + require.Equal(t, "", nextKey) // ListNodes should fail if namespace isn't provided _, _, err = clt.ListNodes(ctx, "", 1, "") @@ -1312,7 +1312,7 @@ func TestNodesCRUD(t *testing.T) { // Get all nodes, transparently handle limit exceeded errors nodes, err := clt.GetNodes(ctx, apidefaults.Namespace) require.NoError(t, err) - require.EqualValues(t, len(nodes), 2) + require.Len(t, nodes, 2) require.Empty(t, cmp.Diff([]types.Server{node1, node2}, nodes, cmpopts.IgnoreFields(types.Metadata{}, "ID"))) @@ -1375,6 +1375,120 @@ func TestNodesCRUD(t *testing.T) { // Now expect no nodes to be returned. nodes, err := clt.GetNodes(ctx, apidefaults.Namespace) require.NoError(t, err) - require.Equal(t, 0, len(nodes)) + require.Empty(t, nodes) + }) +} + +func TestLocksCRUD(t *testing.T) { + t.Parallel() + ctx := context.Background() + srv := newTestTLSServer(t) + + clt, err := srv.NewClient(TestAdmin()) + require.NoError(t, err) + + now := srv.Clock().Now() + lock1, err := types.NewLock("lock1", types.LockSpecV2{ + Target: types.LockTarget{ + User: "user-A", + }, + Expires: &now, + }) + require.NoError(t, err) + + lock2, err := types.NewLock("lock2", types.LockSpecV2{ + Target: types.LockTarget{ + Node: "node", + }, + Message: "node compromised", + }) + require.NoError(t, err) + + t.Run("CreateLock", func(t *testing.T) { + // Initially expect no locks to be returned. + locks, err := clt.GetLocks(ctx) + require.NoError(t, err) + require.Empty(t, locks) + + // Create locks. + err = clt.UpsertLock(ctx, lock1) + require.NoError(t, err) + + err = clt.UpsertLock(ctx, lock2) + require.NoError(t, err) + }) + + // Run LockGetters in nested subtests to allow parallelization. + t.Run("LockGetters", func(t *testing.T) { + t.Run("GetLocks", func(t *testing.T) { + t.Parallel() + locks, err := clt.GetLocks(ctx) + require.NoError(t, err) + require.Len(t, locks, 2) + require.Empty(t, cmp.Diff([]types.Lock{lock1, lock2}, locks, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + }) + t.Run("GetLocks with targets", func(t *testing.T) { + t.Parallel() + // Match both locks with the targets. + locks, err := clt.GetLocks(ctx, lock1.Target(), lock2.Target()) + require.NoError(t, err) + require.Len(t, locks, 2) + require.Empty(t, cmp.Diff([]types.Lock{lock1, lock2}, locks, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + + // Match only one of the locks. + roleTarget := types.LockTarget{Role: "role-A"} + locks, err = clt.GetLocks(ctx, lock1.Target(), roleTarget) + require.NoError(t, err) + require.Len(t, locks, 1) + require.Empty(t, cmp.Diff([]types.Lock{lock1}, locks, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + + // Match none of the locks. + locks, err = clt.GetLocks(ctx, roleTarget) + require.NoError(t, err) + require.Empty(t, locks) + }) + t.Run("GetLock", func(t *testing.T) { + t.Parallel() + // Get one of the locks. + lock, err := clt.GetLock(ctx, lock1.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(lock1, lock, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + + // Attempt to get a nonexistent lock. + _, err = clt.GetLock(ctx, "lock3") + require.Error(t, err) + require.True(t, trace.IsNotFound(err)) + }) + }) + + t.Run("UpsertLock", func(t *testing.T) { + // Get one of the locks. + lock, err := clt.GetLock(ctx, lock1.GetName()) + require.NoError(t, err) + require.Empty(t, lock.Message()) + + msg := "cluster maintenance" + lock1.SetMessage(msg) + err = clt.UpsertLock(ctx, lock1) + require.NoError(t, err) + + lock, err = clt.GetLock(ctx, lock1.GetName()) + require.NoError(t, err) + require.Equal(t, msg, lock.Message()) + }) + + t.Run("DeleteLock", func(t *testing.T) { + // Delete lock. + err = clt.DeleteLock(ctx, lock1.GetName()) + require.NoError(t, err) + + // Expect lock not found. + _, err := clt.GetLock(ctx, lock1.GetName()) + require.Error(t, err) + require.True(t, trace.IsNotFound(err)) }) } diff --git a/lib/auth/permissions.go b/lib/auth/permissions.go index 26542e1a8f0b5..c422df8429b45 100644 --- a/lib/auth/permissions.go +++ b/lib/auth/permissions.go @@ -338,6 +338,7 @@ func GetCheckerForBuiltinRole(clusterName string, recConfig types.SessionRecordi types.NewRule(types.KindSessionRecordingConfig, services.RO()), types.NewRule(types.KindClusterAuthPreference, services.RO()), types.NewRule(types.KindSemaphore, services.RW()), + types.NewRule(types.KindLock, services.RO()), }, }, }) @@ -441,6 +442,7 @@ func GetCheckerForBuiltinRole(clusterName string, recConfig types.SessionRecordi types.NewRule(types.KindWebToken, services.RW()), types.NewRule(types.KindKubeService, services.RW()), types.NewRule(types.KindDatabaseServer, services.RO()), + types.NewRule(types.KindLock, services.RO()), // this rule allows local proxy to update the remote cluster's host certificate authorities // during certificates renewal { @@ -501,6 +503,7 @@ func GetCheckerForBuiltinRole(clusterName string, recConfig types.SessionRecordi types.NewRule(types.KindWebToken, services.RW()), types.NewRule(types.KindKubeService, services.RW()), types.NewRule(types.KindDatabaseServer, services.RO()), + types.NewRule(types.KindLock, services.RO()), // this rule allows local proxy to update the remote cluster's host certificate authorities // during certificates renewal { diff --git a/lib/backend/dynamo/dynamodbbk.go b/lib/backend/dynamo/dynamodbbk.go index cadbe03f1558d..b2673a0f1320b 100644 --- a/lib/backend/dynamo/dynamodbbk.go +++ b/lib/backend/dynamo/dynamodbbk.go @@ -26,9 +26,9 @@ import ( "sync/atomic" "time" + "github.com/gravitational/teleport/api/utils" "github.com/gravitational/teleport/lib/backend" "github.com/gravitational/teleport/lib/defaults" - "github.com/gravitational/teleport/lib/utils" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" diff --git a/lib/backend/etcdbk/etcd.go b/lib/backend/etcdbk/etcd.go index 0e003283c8551..b811e036ef186 100644 --- a/lib/backend/etcdbk/etcd.go +++ b/lib/backend/etcdbk/etcd.go @@ -30,6 +30,7 @@ import ( apidefaults "github.com/gravitational/teleport/api/defaults" "github.com/gravitational/teleport/api/types" + apiutils "github.com/gravitational/teleport/api/utils" "github.com/gravitational/teleport/lib/backend" "github.com/gravitational/teleport/lib/tlsca" "github.com/gravitational/teleport/lib/utils" @@ -187,7 +188,7 @@ func New(ctx context.Context, params backend.Params) (*EtcdBackend, error) { // convert generic backend parameters structure to etcd config: var cfg *Config - if err = utils.ObjectToStruct(params, &cfg); err != nil { + if err = apiutils.ObjectToStruct(params, &cfg); err != nil { return nil, trace.BadParameter("invalid etcd configuration: %v", err) } if err = cfg.Validate(); err != nil { diff --git a/lib/backend/firestore/firestorebk.go b/lib/backend/firestore/firestorebk.go index c7cb0cd19b95c..a6b70c458d584 100644 --- a/lib/backend/firestore/firestorebk.go +++ b/lib/backend/firestore/firestorebk.go @@ -31,6 +31,7 @@ import ( "google.golang.org/grpc/status" "github.com/gravitational/teleport/api/types" + apiutils "github.com/gravitational/teleport/api/utils" "github.com/gravitational/teleport/lib/backend" "github.com/gravitational/teleport/lib/defaults" "github.com/gravitational/teleport/lib/utils" @@ -244,7 +245,7 @@ func CreateFirestoreClients(ctx context.Context, projectID string, endPoint stri func New(ctx context.Context, params backend.Params) (*Backend, error) { l := log.WithFields(log.Fields{trace.Component: BackendName}) var cfg *backendConfig - err := utils.ObjectToStruct(params, &cfg) + err := apiutils.ObjectToStruct(params, &cfg) if err != nil { return nil, trace.BadParameter("firestore: configuration is invalid: %v", err) } diff --git a/lib/backend/lite/lite.go b/lib/backend/lite/lite.go index df53d0cdc936f..b2ef20d1ac941 100644 --- a/lib/backend/lite/lite.go +++ b/lib/backend/lite/lite.go @@ -29,8 +29,8 @@ import ( "time" "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/api/utils" "github.com/gravitational/teleport/lib/backend" - "github.com/gravitational/teleport/lib/utils" "github.com/gravitational/trace" "github.com/jonboulle/clockwork" diff --git a/lib/cache/cache.go b/lib/cache/cache.go index 7b00f0e334aa7..d2080841fb310 100644 --- a/lib/cache/cache.go +++ b/lib/cache/cache.go @@ -69,6 +69,7 @@ func ForAuth(cfg Config) Config { {Kind: types.KindRemoteCluster}, {Kind: types.KindKubeService}, {Kind: types.KindDatabaseServer}, + {Kind: types.KindLock}, } cfg.QueueSize = defaults.AuthQueueSize return cfg @@ -100,6 +101,7 @@ func ForProxy(cfg Config) Config { {Kind: types.KindRemoteCluster}, {Kind: types.KindKubeService}, {Kind: types.KindDatabaseServer}, + {Kind: types.KindLock}, } cfg.QueueSize = defaults.ProxyQueueSize return cfg @@ -175,6 +177,7 @@ func ForNode(cfg Config) Config { {Kind: types.KindSessionRecordingConfig}, {Kind: types.KindUser}, {Kind: types.KindRole}, + {Kind: types.KindLock}, // Node only needs to "know" about default // namespace events to avoid matching too much // data about other namespaces or node events @@ -706,7 +709,7 @@ func (c *Cache) update(ctx context.Context, retry utils.Retry) { return } if err != nil { - c.Warningf("Re-init the cache on error: %v.", trace.Unwrap(err)) + c.WithError(err).Warning("Re-init the cache on error.") if c.OnlyRecent.Enabled { c.setReadOK(false) } @@ -1348,3 +1351,34 @@ func (c *Cache) GetSessionRecordingConfig(ctx context.Context, opts ...services. defer rg.Release() return rg.clusterConfig.GetSessionRecordingConfig(ctx, opts...) } + +// GetLock gets a lock by name. +func (c *Cache) GetLock(ctx context.Context, name string) (types.Lock, error) { + rg, err := c.read() + if err != nil { + return nil, trace.Wrap(err) + } + defer rg.Release() + + lock, err := rg.access.GetLock(ctx, name) + if trace.IsNotFound(err) && rg.IsCacheRead() { + // release read lock early + rg.Release() + // fallback is sane because method is never used + // in construction of derivative caches. + if lock, err := c.Config.Access.GetLock(ctx, name); err == nil { + return lock, nil + } + } + return lock, trace.Wrap(err) +} + +// GetLocks gets all locks, matching at least one of the targets when specified. +func (c *Cache) GetLocks(ctx context.Context, targets ...types.LockTarget) ([]types.Lock, error) { + rg, err := c.read() + if err != nil { + return nil, trace.Wrap(err) + } + defer rg.Release() + return rg.access.GetLocks(ctx, targets...) +} diff --git a/lib/cache/collections.go b/lib/cache/collections.go index 3d3394a453346..63b7cacbf888b 100644 --- a/lib/cache/collections.go +++ b/lib/cache/collections.go @@ -176,6 +176,11 @@ func setupCollections(c *Cache, watches []types.WatchKind) (map[resourceKind]col return nil, trace.BadParameter("missing parameter Presence") } collections[resourceKind] = &databaseServer{watch: watch, Cache: c} + case types.KindLock: + if c.Access == nil { + return nil, trace.BadParameter("missing parameter Access") + } + collections[resourceKind] = &lock{watch: watch, Cache: c} default: return nil, trace.BadParameter("resource %q is not supported", watch.Kind) } @@ -1975,3 +1980,66 @@ func (c *sessionRecordingConfig) processEvent(ctx context.Context, event types.E func (c *sessionRecordingConfig) watchKind() types.WatchKind { return c.watch } + +type lock struct { + *Cache + watch types.WatchKind +} + +func (c *lock) erase(ctx context.Context) error { + err := c.accessCache.DeleteAllLocks(ctx) + if err != nil && !trace.IsNotFound(err) { + return trace.Wrap(err) + } + return nil +} + +func (c *lock) fetch(ctx context.Context) (apply func(ctx context.Context) error, err error) { + resources, err := c.Access.GetLocks(ctx) + if err != nil { + return nil, trace.Wrap(err) + } + return func(ctx context.Context) error { + if err := c.erase(ctx); err != nil { + return trace.Wrap(err) + } + for _, resource := range resources { + c.setTTL(resource) + if err := c.accessCache.UpsertLock(ctx, resource); err != nil { + return trace.Wrap(err) + } + } + return nil + }, nil +} + +func (c *lock) processEvent(ctx context.Context, event types.Event) error { + switch event.Type { + case types.OpDelete: + err := c.accessCache.DeleteLock(ctx, event.Resource.GetName()) + if err != nil { + // Resource could be missing in the cache, expired or not created, + // if the first consumed event is delete. + if !trace.IsNotFound(err) { + c.WithError(err).Warn("Failed to delete lock.") + return trace.Wrap(err) + } + } + case types.OpPut: + resource, ok := event.Resource.(types.Lock) + if !ok { + return trace.BadParameter("unexpected type %T", event.Resource) + } + c.setTTL(resource) + if err := c.accessCache.UpsertLock(ctx, resource); err != nil { + return trace.Wrap(err) + } + default: + c.Warnf("Skipping unsupported event type %v.", event.Type) + } + return nil +} + +func (c *lock) watchKind() types.WatchKind { + return c.watch +} diff --git a/lib/events/dynamic.go b/lib/events/dynamic.go index bf51c672c0d0c..e11425e50d1fd 100644 --- a/lib/events/dynamic.go +++ b/lib/events/dynamic.go @@ -19,6 +19,7 @@ package events import ( "github.com/gravitational/teleport/api/types/events" apievents "github.com/gravitational/teleport/api/types/events" + apiutils "github.com/gravitational/teleport/api/utils" "github.com/gravitational/teleport/lib/utils" "github.com/gravitational/trace" @@ -377,7 +378,7 @@ func GetSessionID(event apievents.AuditEvent) string { // with existing public API routes when the backend is updated with the typed events. func ToEventFields(event apievents.AuditEvent) (EventFields, error) { var fields EventFields - if err := utils.ObjectToStruct(event, &fields); err != nil { + if err := apiutils.ObjectToStruct(event, &fields); err != nil { return nil, trace.Wrap(err) } diff --git a/lib/events/firestoreevents/firestoreevents.go b/lib/events/firestoreevents/firestoreevents.go index 30d2042de5220..bd9303bd5fbd2 100644 --- a/lib/events/firestoreevents/firestoreevents.go +++ b/lib/events/firestoreevents/firestoreevents.go @@ -31,6 +31,7 @@ import ( "github.com/gravitational/teleport" apidefaults "github.com/gravitational/teleport/api/defaults" + apiutils "github.com/gravitational/teleport/api/utils" firestorebk "github.com/gravitational/teleport/lib/backend/firestore" "github.com/gravitational/teleport/lib/defaults" "github.com/gravitational/teleport/lib/events" @@ -155,7 +156,7 @@ type EventsConfig struct { // SetFromParams establishes values on an EventsConfig from the supplied params func (cfg *EventsConfig) SetFromParams(params backend.Params) error { - err := utils.ObjectToStruct(params, &cfg) + err := apiutils.ObjectToStruct(params, &cfg) if err != nil { return trace.BadParameter("firestore: configuration is invalid: %v", err) } diff --git a/lib/services/access.go b/lib/services/access.go new file mode 100644 index 0000000000000..2a6a7a7678340 --- /dev/null +++ b/lib/services/access.go @@ -0,0 +1,50 @@ +/* +Copyright 2021 Gravitational, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package services + +import ( + "context" + + "github.com/gravitational/teleport/api/types" +) + +// Access service manages roles and permissions. +type Access interface { + // GetRoles returns a list of roles. + GetRoles(ctx context.Context) ([]types.Role, error) + // CreateRole creates a role. + CreateRole(role types.Role) error + // UpsertRole creates or updates role. + UpsertRole(ctx context.Context, role types.Role) error + // DeleteAllRoles deletes all roles. + DeleteAllRoles() error + // GetRole returns role by name. + GetRole(ctx context.Context, name string) (types.Role, error) + // DeleteRole deletes role by name. + DeleteRole(ctx context.Context, name string) error + + // GetLock gets a lock by name. + GetLock(ctx context.Context, name string) (types.Lock, error) + // GetLocks gets all locks, matching at least one of the targets when specified. + GetLocks(ctx context.Context, targets ...types.LockTarget) ([]types.Lock, error) + // UpsertLock upserts a lock. + UpsertLock(context.Context, types.Lock) error + // DeleteLock deletes a lock. + DeleteLock(context.Context, string) error + // DeleteLock deletes all locks. + DeleteAllLocks(context.Context) error +} diff --git a/lib/services/audit.go b/lib/services/audit.go index dfe07fb38cf55..d5e6a6e0217df 100644 --- a/lib/services/audit.go +++ b/lib/services/audit.go @@ -18,6 +18,7 @@ package services import ( "github.com/gravitational/teleport/api/types" + apiutils "github.com/gravitational/teleport/api/utils" "github.com/gravitational/teleport/lib/utils" "github.com/gravitational/trace" ) @@ -28,7 +29,7 @@ func ClusterAuditConfigSpecFromObject(in interface{}) (*types.ClusterAuditConfig if in == nil { return &cfg, nil } - if err := utils.ObjectToStruct(in, &cfg); err != nil { + if err := apiutils.ObjectToStruct(in, &cfg); err != nil { return nil, trace.Wrap(err) } return &cfg, nil diff --git a/lib/services/local/access.go b/lib/services/local/access.go index 0776da05c9aa1..5a5e75c20f322 100644 --- a/lib/services/local/access.go +++ b/lib/services/local/access.go @@ -44,7 +44,7 @@ func (s *AccessService) DeleteAllRoles() error { // GetRoles returns a list of roles registered with the local auth server func (s *AccessService) GetRoles(ctx context.Context) ([]types.Role, error) { - result, err := s.GetRange(context.TODO(), backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)), backend.NoLimit) + result, err := s.GetRange(ctx, backend.Key(rolesPrefix), backend.RangeEnd(backend.Key(rolesPrefix)), backend.NoLimit) if err != nil { return nil, trace.Wrap(err) } @@ -107,7 +107,7 @@ func (s *AccessService) GetRole(ctx context.Context, name string) (types.Role, e if name == "" { return nil, trace.BadParameter("missing role name") } - item, err := s.Get(context.TODO(), backend.Key(rolesPrefix, name, paramsPrefix)) + item, err := s.Get(ctx, backend.Key(rolesPrefix, name, paramsPrefix)) if err != nil { if trace.IsNotFound(err) { return nil, trace.NotFound("role %v is not found", name) @@ -132,7 +132,96 @@ func (s *AccessService) DeleteRole(ctx context.Context, name string) error { return trace.Wrap(err) } +// GetLock gets a lock by name. +func (s *AccessService) GetLock(ctx context.Context, name string) (types.Lock, error) { + if name == "" { + return nil, trace.BadParameter("missing lock name") + } + item, err := s.Get(ctx, backend.Key(locksPrefix, name)) + if err != nil { + if trace.IsNotFound(err) { + return nil, trace.NotFound("lock %q is not found", name) + } + return nil, trace.Wrap(err) + } + return services.UnmarshalLock(item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires)) +} + +// GetLocks gets all locks, matching at least one of the targets when specified. +func (s *AccessService) GetLocks(ctx context.Context, targets ...types.LockTarget) ([]types.Lock, error) { + startKey := backend.Key(locksPrefix) + result, err := s.GetRange(ctx, startKey, backend.RangeEnd(startKey), backend.NoLimit) + if err != nil { + return nil, trace.Wrap(err) + } + + out := []types.Lock{} + for _, item := range result.Items { + lock, err := services.UnmarshalLock(item.Value, services.WithResourceID(item.ID), services.WithExpires(item.Expires)) + if err != nil { + return nil, trace.Wrap(err) + } + // If no targets specified, return all of the found locks. + if len(targets) == 0 { + out = append(out, lock) + continue + } + // Otherwise, use the targets as filters. + for _, target := range targets { + match, err := target.Match(lock) + if err != nil { + return nil, trace.Wrap(err) + } + if match { + out = append(out, lock) + break + } + } + } + return out, nil +} + +// UpsertLock upserts a lock. +func (s *AccessService) UpsertLock(ctx context.Context, lock types.Lock) error { + value, err := services.MarshalLock(lock) + if err != nil { + return trace.Wrap(err) + } + item := backend.Item{ + Key: backend.Key(locksPrefix, lock.GetName()), + Value: value, + Expires: lock.Expiry(), + ID: lock.GetResourceID(), + } + + if _, err = s.Put(ctx, item); err != nil { + return trace.Wrap(err) + } + return nil +} + +// DeleteLock deletes a lock. +func (s *AccessService) DeleteLock(ctx context.Context, name string) error { + if name == "" { + return trace.BadParameter("missing lock name") + } + err := s.Delete(ctx, backend.Key(locksPrefix, name)) + if err != nil { + if trace.IsNotFound(err) { + return trace.NotFound("lock %q is not found", name) + } + } + return trace.Wrap(err) +} + +// DeleteLock deletes all locks. +func (s *AccessService) DeleteAllLocks(ctx context.Context) error { + startKey := backend.Key(locksPrefix) + return s.DeleteRange(ctx, startKey, backend.RangeEnd(startKey)) +} + const ( rolesPrefix = "roles" paramsPrefix = "params" + locksPrefix = "locks" ) diff --git a/lib/services/local/access_test.go b/lib/services/local/access_test.go new file mode 100644 index 0000000000000..19011c2ccaf87 --- /dev/null +++ b/lib/services/local/access_test.go @@ -0,0 +1,150 @@ +/* +Copyright 2021 Gravitational, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package local + +import ( + "context" + "testing" + + "github.com/google/go-cmp/cmp" + "github.com/google/go-cmp/cmp/cmpopts" + "github.com/gravitational/trace" + "github.com/stretchr/testify/require" + + "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/lib/backend/lite" +) + +func TestLockCRUD(t *testing.T) { + ctx := context.Background() + lite, err := lite.NewWithConfig(ctx, lite.Config{Path: t.TempDir()}) + require.NoError(t, err) + + access := NewAccessService(lite) + + lock1, err := types.NewLock("lock1", types.LockSpecV2{ + Target: types.LockTarget{ + User: "user-A", + }, + }) + require.NoError(t, err) + + lock2, err := types.NewLock("lock2", types.LockSpecV2{ + Target: types.LockTarget{ + Node: "node", + }, + }) + require.NoError(t, err) + + t.Run("CreateLock", func(t *testing.T) { + // Initially expect no locks to be returned. + locks, err := access.GetLocks(ctx) + require.NoError(t, err) + require.Empty(t, locks) + + // Create locks. + err = access.UpsertLock(ctx, lock1) + require.NoError(t, err) + err = access.UpsertLock(ctx, lock2) + require.NoError(t, err) + }) + + // Run LockGetters in nested subtests to allow parallelization. + t.Run("LockGetters", func(t *testing.T) { + t.Run("GetLocks", func(t *testing.T) { + t.Parallel() + locks, err := access.GetLocks(ctx) + require.NoError(t, err) + require.Len(t, locks, 2) + require.Empty(t, cmp.Diff([]types.Lock{lock1, lock2}, locks, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + }) + t.Run("GetLocks with targets", func(t *testing.T) { + t.Parallel() + // Match both locks with the targets. + locks, err := access.GetLocks(ctx, lock1.Target(), lock2.Target()) + require.NoError(t, err) + require.Len(t, locks, 2) + require.Empty(t, cmp.Diff([]types.Lock{lock1, lock2}, locks, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + + // Match only one of the locks. + roleTarget := types.LockTarget{Role: "role-A"} + locks, err = access.GetLocks(ctx, lock1.Target(), roleTarget) + require.NoError(t, err) + require.Len(t, locks, 1) + require.Empty(t, cmp.Diff([]types.Lock{lock1}, locks, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + + // Match none of the locks. + locks, err = access.GetLocks(ctx, roleTarget) + require.NoError(t, err) + require.Empty(t, locks) + }) + t.Run("GetLock", func(t *testing.T) { + t.Parallel() + // Get one of the locks. + lock, err := access.GetLock(ctx, lock1.GetName()) + require.NoError(t, err) + require.Empty(t, cmp.Diff(lock1, lock, + cmpopts.IgnoreFields(types.Metadata{}, "ID"))) + + // Attempt to get a nonexistent lock. + _, err = access.GetLock(ctx, "lock3") + require.Error(t, err) + require.True(t, trace.IsNotFound(err)) + }) + }) + + t.Run("UpsertLock", func(t *testing.T) { + // Get one of the locks. + lock, err := access.GetLock(ctx, lock1.GetName()) + require.NoError(t, err) + require.Empty(t, lock.Message()) + + msg := "cluster maintenance" + lock1.SetMessage(msg) + err = access.UpsertLock(ctx, lock1) + require.NoError(t, err) + + lock, err = access.GetLock(ctx, lock1.GetName()) + require.NoError(t, err) + require.Equal(t, msg, lock.Message()) + }) + + t.Run("DeleteLock", func(t *testing.T) { + // Delete lock. + err = access.DeleteLock(ctx, lock1.GetName()) + require.NoError(t, err) + + // Expect lock not found. + _, err := access.GetLock(ctx, lock1.GetName()) + require.Error(t, err) + require.True(t, trace.IsNotFound(err)) + }) + + t.Run("DeleteAllLocks", func(t *testing.T) { + // Delete all locks. + err = access.DeleteAllLocks(ctx) + require.NoError(t, err) + + // Expect no locks to be returned. + locks, err := access.GetLocks(ctx) + require.NoError(t, err) + require.Empty(t, locks) + }) +} diff --git a/lib/services/local/events.go b/lib/services/local/events.go index 6489bcaa7f94b..87803e10c68d0 100644 --- a/lib/services/local/events.go +++ b/lib/services/local/events.go @@ -119,6 +119,8 @@ func (e *EventsService) NewWatcher(ctx context.Context, watch types.Watch) (type parser = newKubeServiceParser() case types.KindDatabaseServer: parser = newDatabaseServerParser() + case types.KindLock: + parser = newLockParser() default: return nil, trace.BadParameter("watcher on object kind %q is not supported", kind.Kind) } @@ -1036,6 +1038,31 @@ func (p *remoteClusterParser) parse(event backend.Event) (types.Resource, error) } } +func newLockParser() *lockParser { + return &lockParser{ + baseParser: newBaseParser(backend.Key(locksPrefix)), + } +} + +type lockParser struct { + baseParser +} + +func (p *lockParser) parse(event backend.Event) (types.Resource, error) { + switch event.Type { + case types.OpDelete: + return resourceHeader(event, types.KindLock, types.V2, 0) + case types.OpPut: + return services.UnmarshalLock( + event.Item.Value, + services.WithResourceID(event.Item.ID), + services.WithExpires(event.Item.Expires), + ) + default: + return nil, trace.BadParameter("event %v is not supported", event.Type) + } +} + func resourceHeader(event backend.Event, kind, version string, offset int) (types.Resource, error) { name, err := base(event.Item.Key, offset) if err != nil { diff --git a/lib/services/lock.go b/lib/services/lock.go new file mode 100644 index 0000000000000..9e79b4ebcc885 --- /dev/null +++ b/lib/services/lock.go @@ -0,0 +1,80 @@ +/* +Copyright 2021 Gravitational, Inc. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package services + +import ( + "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/lib/utils" + + "github.com/gravitational/trace" +) + +// UnmarshalLock unmarshals the Lock resource from JSON. +func UnmarshalLock(bytes []byte, opts ...MarshalOption) (types.Lock, error) { + if len(bytes) == 0 { + return nil, trace.BadParameter("missing resource data") + } + + var lock types.LockV2 + if err := utils.FastUnmarshal(bytes, &lock); err != nil { + return nil, trace.BadParameter(err.Error()) + } + if err := lock.CheckAndSetDefaults(); err != nil { + return nil, trace.Wrap(err) + } + + cfg, err := CollectOptions(opts) + if err != nil { + return nil, trace.Wrap(err) + } + if cfg.ID != 0 { + lock.SetResourceID(cfg.ID) + } + if !cfg.Expires.IsZero() { + lock.SetExpiry(cfg.Expires) + } + return &lock, nil +} + +// MarshalLock marshals the Lock resource to JSON. +func MarshalLock(lock types.Lock, opts ...MarshalOption) ([]byte, error) { + if err := lock.CheckAndSetDefaults(); err != nil { + return nil, trace.Wrap(err) + } + + cfg, err := CollectOptions(opts) + if err != nil { + return nil, trace.Wrap(err) + } + + switch lock := lock.(type) { + case *types.LockV2: + if version := lock.GetVersion(); version != types.V2 { + return nil, trace.BadParameter("mismatched lock version %v and type %T", version, lock) + } + if !cfg.PreserveResourceID { + // avoid modifying the original object + // to prevent unexpected data races + copy := *lock + copy.SetResourceID(0) + lock = © + } + return utils.FastMarshal(lock) + default: + return nil, trace.BadParameter("unrecognized lock version %T", lock) + } +} diff --git a/lib/services/resource.go b/lib/services/resource.go index 059483240d876..7755d3459b5b6 100644 --- a/lib/services/resource.go +++ b/lib/services/resource.go @@ -154,6 +154,8 @@ func ParseShortcut(in string) (string, error) { return types.KindSemaphore, nil case types.KindKubeService, "kube_services": return types.KindKubeService, nil + case types.KindLock, "locks": + return types.KindLock, nil } return "", trace.BadParameter("unsupported resource: %q - resources should be expressed as 'type/name', for example 'connector/github'", in) } diff --git a/lib/services/role.go b/lib/services/role.go index 07b97fb5b9c4d..373434a816c3b 100644 --- a/lib/services/role.go +++ b/lib/services/role.go @@ -274,27 +274,6 @@ func RoleForCertAuthority(ca types.CertAuthority) types.Role { return role } -// Access service manages roles and permissions -type Access interface { - // GetRoles returns a list of roles - GetRoles(ctx context.Context) ([]types.Role, error) - - // CreateRole creates a role - CreateRole(role types.Role) error - - // UpsertRole creates or updates role - UpsertRole(ctx context.Context, role types.Role) error - - // DeleteAllRoles deletes all roles - DeleteAllRoles() error - - // GetRole returns role by name - GetRole(ctx context.Context, name string) (types.Role, error) - - // DeleteRole deletes role by name - DeleteRole(ctx context.Context, name string) error -} - const ( // Allow is the set of conditions that allow access. Allow types.RoleConditionType = true diff --git a/tool/tctl/common/collection.go b/tool/tctl/common/collection.go index 5a118299a9d84..29dafafcbe61f 100644 --- a/tool/tctl/common/collection.go +++ b/tool/tctl/common/collection.go @@ -568,3 +568,28 @@ func (c *dbCollection) toMarshal() interface{} { func (c *dbCollection) writeYAML(w io.Writer) error { return utils.WriteYAML(w, c.toMarshal()) } + +type lockCollection struct { + locks []types.Lock +} + +func (c *lockCollection) resources() (r []types.Resource) { + for _, resource := range c.locks { + r = append(r, resource) + } + return r +} + +func (c *lockCollection) writeText(w io.Writer) error { + t := asciitable.MakeTable([]string{"ID", "Target", "Message", "Expires"}) + for _, lock := range c.locks { + target := lock.Target() + expires := "never" + if lock.LockExpiry() != nil { + expires = apiutils.HumanTimeFormat(*lock.LockExpiry()) + } + t.AddRow([]string{lock.GetName(), target.String(), lock.Message(), expires}) + } + _, err := t.AsBuffer().WriteTo(w) + return trace.Wrap(err) +} diff --git a/tool/tctl/common/resource_command.go b/tool/tctl/common/resource_command.go index 3afb57bb484ca..b48b257a8ebf7 100644 --- a/tool/tctl/common/resource_command.go +++ b/tool/tctl/common/resource_command.go @@ -93,6 +93,7 @@ func (rc *ResourceCommand) Initialize(app *kingpin.Application, config *service. types.KindClusterAuthPreference: rc.createAuthPreference, types.KindClusterNetworkingConfig: rc.createClusterNetworkingConfig, types.KindSessionRecordingConfig: rc.createSessionRecordingConfig, + types.KindLock: rc.createLock, } rc.config = config @@ -348,7 +349,7 @@ func (rc *ResourceCommand) createGithubConnector(client auth.ClientI, raw servic return nil } -// createConnector implements `tctl create role.yaml` command +// createRole implements `tctl create role.yaml` command. func (rc *ResourceCommand) createRole(client auth.ClientI, raw services.UnknownResource) error { ctx := context.TODO() role, err := services.UnmarshalRole(raw.Raw) @@ -490,6 +491,33 @@ func (rc *ResourceCommand) createSessionRecordingConfig(client auth.ClientI, raw return nil } +// createLock implements `tctl create lock.yaml` command. +func (rc *ResourceCommand) createLock(client auth.ClientI, raw services.UnknownResource) error { + ctx := context.TODO() + lock, err := services.UnmarshalLock(raw.Raw) + if err != nil { + return trace.Wrap(err) + } + + // Check if a lock of the name already exists. + name := lock.GetName() + _, err = client.GetLock(ctx, name) + if err != nil && !trace.IsNotFound(err) { + return trace.Wrap(err) + } + + exists := (err == nil) + if !rc.force && exists { + return trace.AlreadyExists("lock %q already exists", name) + } + + if err := client.UpsertLock(ctx, lock); err != nil { + return trace.Wrap(err) + } + fmt.Printf("lock %q has been %s\n", name, UpsertVerb(exists, rc.force)) + return nil +} + // Delete deletes resource by name func (rc *ResourceCommand) Delete(client auth.ClientI) (err error) { singletonResources := []string{ @@ -583,6 +611,11 @@ func (rc *ResourceCommand) Delete(client auth.ClientI) (err error) { return trace.Wrap(err) } fmt.Printf("session recording configuration has been reset to defaults\n") + case types.KindLock: + if err = client.DeleteLock(ctx, rc.ref.Name); err != nil { + return trace.Wrap(err) + } + fmt.Printf("lock %q has been deleted\n", rc.ref.Name) default: return trace.BadParameter("deleting resources of type %q is not supported", rc.ref.Kind) } @@ -878,7 +911,7 @@ func (rc *ResourceCommand) getCollection(client auth.ClientI) (ResourceCollectio } return &remoteClusterCollection{remoteClusters: []types.RemoteCluster{remoteCluster}}, nil case types.KindSemaphore: - sems, err := client.GetSemaphores(context.TODO(), types.SemaphoreFilter{ + sems, err := client.GetSemaphores(ctx, types.SemaphoreFilter{ SemaphoreKind: rc.ref.SubKind, SemaphoreName: rc.ref.Name, }) @@ -887,7 +920,7 @@ func (rc *ResourceCommand) getCollection(client auth.ClientI) (ResourceCollectio } return &semaphoreCollection{sems: sems}, nil case types.KindKubeService: - servers, err := client.GetKubeServices(context.TODO()) + servers, err := client.GetKubeServices(ctx) if err != nil { return nil, trace.Wrap(err) } @@ -927,6 +960,19 @@ func (rc *ResourceCommand) getCollection(client auth.ClientI) (ResourceCollectio return nil, trace.Wrap(err) } return &recConfigCollection{recConfig}, nil + case types.KindLock: + if rc.ref.Name == "" { + locks, err := client.GetLocks(ctx) + if err != nil { + return nil, trace.Wrap(err) + } + return &lockCollection{locks: locks}, nil + } + lock, err := client.GetLock(ctx, rc.ref.Name) + if err != nil { + return nil, trace.Wrap(err) + } + return &lockCollection{locks: []types.Lock{lock}}, nil } return nil, trace.BadParameter("getting %q is not supported", rc.ref.String()) }