Repository: micromdm/micromdm
Pull request #757 (2021-06-09 07:31:52)

Added SetRecoveryLock support
It says SetFirmwarePassword on the files, but its meant to be SetRecoveryLock and VerifyRecoveryLock.

I was thinking about test files, but in what file should I put the tests?

meta-github: verify_firmware_password script is using VerifyRecoveryLock. A typo?

Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4b68eac..d39d38a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,14 @@
 ## [Unreleased](https://github.com/micromdm/micromdm/compare/v1.8.0...main) TBD
 
+- Added support for SetRecoveryLock and VerifyRecoveryLock (#757)
 - Fix SetFirmwarePassword and VerifyFirmwarePassword parameters (#743)
 - Command UUID can now be passed in as as a request parameter (#754)
 - Update to SCEP v2, switch to Mozilla PKCS7 fork, interface cleanup (#737)
 - Fix panic when using DEP mdmctl commands with no DEP tokens configured (#750)
+- Spruce up built-in landing page including better accessibility (#721, #751)
+- Documentation & CLI usage improvements (#729, #730, #748, #749)
+
+Thanks to our contributors for this release: @discentem, @korylprince, @williamtheaker, @bpmcneilly, @daemonsy
 
 ## [v1.8.0](https://github.com/micromdm/micromdm/compare/v1.7.1...v1.8.0) February, 2021
 
diff --git a/mdm/mdm/command.go b/mdm/mdm/command.go
index 4627387..2078a7b 100644
--- a/mdm/mdm/command.go
+++ b/mdm/mdm/command.go
@@ -61,6 +61,8 @@ type Command struct {
 	ManagedApplicationFeedback      *ManagedApplicationFeedback
 	SetFirmwarePassword             *SetFirmwarePassword
 	VerifyFirmwarePassword          *VerifyFirmwarePassword
+	SetRecoveryLock                 *SetRecoveryLock
+	VerifyRecoveryLock              *VerifyRecoveryLock
 	SetAutoAdminPassword            *SetAutoAdminPassword
 	ScheduleOSUpdate                *ScheduleOSUpdate
 	ScheduleOSUpdateScan            *ScheduleOSUpdateScan
@@ -248,15 +250,27 @@ type ManagedApplicationFeedback struct {
 }
 
 type SetFirmwarePassword struct {
-	CurrentPassword string `plist:",omitempty" json:"current_password,omitempty"`
-	NewPassword     string `json:"new_password"`
-	AllowOroms      bool   `plist:",omitempty" json:"allow_oroms,omitempty"`
+	CurrentPassword              string `plist:",omitempty" json:"current_password,omitempty"`
+	NewPassword                  string `json:"new_password"`
+	RequestRequiresNetworkTether bool   `plist:",omitempty" json:"request_requires_network_tether,omitempty"`
+	AllowOroms                   bool   `plist:",omitempty" json:"allow_oroms,omitempty"`
 }
 
 type VerifyFirmwarePassword struct {
 	Password string `json:"password"`
 }
 
+type SetRecoveryLock struct {
+	CurrentPassword              string `plist:",omitempty" json:"current_password,omitempty"`
+	NewPassword                  string `json:"new_password"`
+	RequestRequiresNetworkTether bool   `plist:",omitempty" json:"request_requires_network_tether,omitempty"`
+	AllowOroms                   bool   `plist:",omitempty" json:"allow_oroms,omitempty"`
+}
+
+type VerifyRecoveryLock struct {
+	Password string `json:"password"`
+}
+
 type SetAutoAdminPassword struct {
 	GUID         string `plist:",omitempty" json:"guid,omitempty"`
 	PasswordHash []byte `plist:"passwordHash" json:"password_hash"`
diff --git a/mdm/mdm/internal/mdmproto/mdm.pb.go b/mdm/mdm/internal/mdmproto/mdm.pb.go
index ce50b3a..5ccdc54 100644
--- a/mdm/mdm/internal/mdmproto/mdm.pb.go
+++ b/mdm/mdm/internal/mdmproto/mdm.pb.go
@@ -53,7 +53,7 @@ func (x ResultPayload_Status) String() string {
 }
 
 func (ResultPayload_Status) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{67, 0}
+	return fileDescriptor_fd1fa389f704dbf7, []int{69, 0}
 }
 
 type CommandPayload struct {
@@ -173,6 +173,8 @@ type Command struct {
 	//	*Command_RotateFilevaultKey
 	//	*Command_InstallEnterpriseApplication
 	//	*Command_SetBootstrapToken
+	//	*Command_SetRecoveryLock
+	//	*Command_VerifyRecoveryLock
 	Request              isCommand_Request `protobuf_oneof:"request"`
 	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
 	XXX_unrecognized     []byte            `json:"-"`
@@ -326,6 +328,12 @@ type Command_InstallEnterpriseApplication struct {
 type Command_SetBootstrapToken struct {
 	SetBootstrapToken *SetBootstrapToken `protobuf:"bytes,37,opt,name=set_bootstrap_token,json=setBootstrapToken,proto3,oneof" json:"set_bootstrap_token,omitempty"`
 }
+type Command_SetRecoveryLock struct {
+	SetRecoveryLock *SetRecoveryLock `protobuf:"bytes,38,opt,name=set_recovery_lock,json=setRecoveryLock,proto3,oneof" json:"set_recovery_lock,omitempty"`
+}
+type Command_VerifyRecoveryLock struct {
+	VerifyRecoveryLock *VerifyRecoveryLock `protobuf:"bytes,39,opt,name=verify_recovery_lock,json=verifyRecoveryLock,proto3,oneof" json:"verify_recovery_lock,omitempty"`
+}
 
 func (*Command_InstallProfile) isCommand_Request()                  {}
 func (*Command_RemoveProfile) isCommand_Request()                   {}
@@ -363,6 +371,8 @@ func (*Command_ActiveNsExtensions) isCommand_Request()              {}
 func (*Command_RotateFilevaultKey) isCommand_Request()              {}
 func (*Command_InstallEnterpriseApplication) isCommand_Request()    {}
 func (*Command_SetBootstrapToken) isCommand_Request()               {}
+func (*Command_SetRecoveryLock) isCommand_Request()                 {}
+func (*Command_VerifyRecoveryLock) isCommand_Request()              {}
 
 func (m *Command) GetRequest() isCommand_Request {
 	if m != nil {
@@ -630,6 +640,20 @@ func (m *Command) GetSetBootstrapToken() *SetBootstrapToken {
 	return nil
 }
 
+func (m *Command) GetSetRecoveryLock() *SetRecoveryLock {
+	if x, ok := m.GetRequest().(*Command_SetRecoveryLock); ok {
+		return x.SetRecoveryLock
+	}
+	return nil
+}
+
+func (m *Command) GetVerifyRecoveryLock() *VerifyRecoveryLock {
+	if x, ok := m.GetRequest().(*Command_VerifyRecoveryLock); ok {
+		return x.VerifyRecoveryLock
+	}
+	return nil
+}
+
 // XXX_OneofWrappers is for the internal use of the proto package.
 func (*Command) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
@@ -669,6 +693,8 @@ func (*Command) XXX_OneofWrappers() []interface{} {
 		(*Command_RotateFilevaultKey)(nil),
 		(*Command_InstallEnterpriseApplication)(nil),
 		(*Command_SetBootstrapToken)(nil),
+		(*Command_SetRecoveryLock)(nil),
+		(*Command_VerifyRecoveryLock)(nil),
 	}
 }
 
@@ -3786,12 +3812,13 @@ func (m *ManagedApplicationFeedback) GetDeleteFeedback() bool {
 }
 
 type SetFirmwarePassword struct {
-	CurrentPassword      string   `protobuf:"bytes,1,opt,name=current_password,json=currentPassword,proto3" json:"current_password,omitempty"`
-	NewPassword          string   `protobuf:"bytes,2,opt,name=new_password,json=newPassword,proto3" json:"new_password,omitempty"`
-	AllowOroms           bool     `protobuf:"varint,3,opt,name=allow_oroms,json=allowOroms,proto3" json:"allow_oroms,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	CurrentPassword              string   `protobuf:"bytes,1,opt,name=current_password,json=currentPassword,proto3" json:"current_password,omitempty"`
+	NewPassword                  string   `protobuf:"bytes,2,opt,name=new_password,json=newPassword,proto3" json:"new_password,omitempty"`
+	AllowOroms                   bool     `protobuf:"varint,3,opt,name=allow_oroms,json=allowOroms,proto3" json:"allow_oroms,omitempty"`
+	RequestRequiresNetworkTether bool     `protobuf:"varint,4,opt,name=request_requires_network_tether,json=requestRequiresNetworkTether,proto3" json:"request_requires_network_tether,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
+	XXX_unrecognized             []byte   `json:"-"`
+	XXX_sizecache                int32    `json:"-"`
 }
 
 func (m *SetFirmwarePassword) Reset()         { *m = SetFirmwarePassword{} }
@@ -3848,6 +3875,13 @@ func (m *SetFirmwarePassword) GetAllowOroms() bool {
 	return false
 }
 
+func (m *SetFirmwarePassword) GetRequestRequiresNetworkTether() bool {
+	if m != nil {
+		return m.RequestRequiresNetworkTether
+	}
+	return false
+}
+
 type VerifyFirmwarePassword struct {
 	Password             string   `protobuf:"bytes,1,opt,name=password,proto3" json:"password,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -3895,6 +3929,124 @@ func (m *VerifyFirmwarePassword) GetPassword() string {
 	return ""
 }
 
+type SetRecoveryLock struct {
+	CurrentPassword              string   `protobuf:"bytes,1,opt,name=current_password,json=currentPassword,proto3" json:"current_password,omitempty"`
+	NewPassword                  string   `protobuf:"bytes,2,opt,name=new_password,json=newPassword,proto3" json:"new_password,omitempty"`
+	AllowOroms                   bool     `protobuf:"varint,3,opt,name=allow_oroms,json=allowOroms,proto3" json:"allow_oroms,omitempty"`
+	RequestRequiresNetworkTether bool     `protobuf:"varint,4,opt,name=request_requires_network_tether,json=requestRequiresNetworkTether,proto3" json:"request_requires_network_tether,omitempty"`
+	XXX_NoUnkeyedLiteral         struct{} `json:"-"`
+	XXX_unrecognized             []byte   `json:"-"`
+	XXX_sizecache                int32    `json:"-"`
+}
+
+func (m *SetRecoveryLock) Reset()         { *m = SetRecoveryLock{} }
+func (m *SetRecoveryLock) String() string { return proto.CompactTextString(m) }
+func (*SetRecoveryLock) ProtoMessage()    {}
+func (*SetRecoveryLock) Descriptor() ([]byte, []int) {
+	return fileDescriptor_fd1fa389f704dbf7, []int{59}
+}
+func (m *SetRecoveryLock) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *SetRecoveryLock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_SetRecoveryLock.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 *SetRecoveryLock) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetRecoveryLock.Merge(m, src)
+}
+func (m *SetRecoveryLock) XXX_Size() int {
+	return m.Size()
+}
+func (m *SetRecoveryLock) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetRecoveryLock.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetRecoveryLock proto.InternalMessageInfo
+
+func (m *SetRecoveryLock) GetCurrentPassword() string {
+	if m != nil {
+		return m.CurrentPassword
+	}
+	return ""
+}
+
+func (m *SetRecoveryLock) GetNewPassword() string {
+	if m != nil {
+		return m.NewPassword
+	}
+	return ""
+}
+
+func (m *SetRecoveryLock) GetAllowOroms() bool {
+	if m != nil {
+		return m.AllowOroms
+	}
+	return false
+}
+
+func (m *SetRecoveryLock) GetRequestRequiresNetworkTether() bool {
+	if m != nil {
+		return m.RequestRequiresNetworkTether
+	}
+	return false
+}
+
+type VerifyRecoveryLock struct {
+	Password             string   `protobuf:"bytes,1,opt,name=password,proto3" json:"password,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *VerifyRecoveryLock) Reset()         { *m = VerifyRecoveryLock{} }
+func (m *VerifyRecoveryLock) String() string { return proto.CompactTextString(m) }
+func (*VerifyRecoveryLock) ProtoMessage()    {}
+func (*VerifyRecoveryLock) Descriptor() ([]byte, []int) {
+	return fileDescriptor_fd1fa389f704dbf7, []int{60}
+}
+func (m *VerifyRecoveryLock) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *VerifyRecoveryLock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_VerifyRecoveryLock.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 *VerifyRecoveryLock) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VerifyRecoveryLock.Merge(m, src)
+}
+func (m *VerifyRecoveryLock) XXX_Size() int {
+	return m.Size()
+}
+func (m *VerifyRecoveryLock) XXX_DiscardUnknown() {
+	xxx_messageInfo_VerifyRecoveryLock.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VerifyRecoveryLock proto.InternalMessageInfo
+
+func (m *VerifyRecoveryLock) GetPassword() string {
+	if m != nil {
+		return m.Password
+	}
+	return ""
+}
+
 type SetAutoAdminPassword struct {
 	Guid                 string   `protobuf:"bytes,1,opt,name=guid,proto3" json:"guid,omitempty"`
 	PasswordHash         []byte   `protobuf:"bytes,2,opt,name=password_hash,json=passwordHash,proto3" json:"password_hash,omitempty"`
@@ -3907,7 +4059,7 @@ func (m *SetAutoAdminPassword) Reset()         { *m = SetAutoAdminPassword{} }
 func (m *SetAutoAdminPassword) String() string { return proto.CompactTextString(m) }
 func (*SetAutoAdminPassword) ProtoMessage()    {}
 func (*SetAutoAdminPassword) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{59}
+	return fileDescriptor_fd1fa389f704dbf7, []int{61}
 }
 func (m *SetAutoAdminPassword) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -3961,7 +4113,7 @@ func (m *ScheduleOSUpdate) Reset()         { *m = ScheduleOSUpdate{} }
 func (m *ScheduleOSUpdate) String() string { return proto.CompactTextString(m) }
 func (*ScheduleOSUpdate) ProtoMessage()    {}
 func (*ScheduleOSUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{60}
+	return fileDescriptor_fd1fa389f704dbf7, []int{62}
 }
 func (m *ScheduleOSUpdate) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4010,7 +4162,7 @@ func (m *Update) Reset()         { *m = Update{} }
 func (m *Update) String() string { return proto.CompactTextString(m) }
 func (*Update) ProtoMessage()    {}
 func (*Update) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{61}
+	return fileDescriptor_fd1fa389f704dbf7, []int{63}
 }
 func (m *Update) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4071,7 +4223,7 @@ func (m *ScheduleOSUpdateScan) Reset()         { *m = ScheduleOSUpdateScan{} }
 func (m *ScheduleOSUpdateScan) String() string { return proto.CompactTextString(m) }
 func (*ScheduleOSUpdateScan) ProtoMessage()    {}
 func (*ScheduleOSUpdateScan) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{62}
+	return fileDescriptor_fd1fa389f704dbf7, []int{64}
 }
 func (m *ScheduleOSUpdateScan) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4118,7 +4270,7 @@ func (m *ActiveNSExtensions) Reset()         { *m = ActiveNSExtensions{} }
 func (m *ActiveNSExtensions) String() string { return proto.CompactTextString(m) }
 func (*ActiveNSExtensions) ProtoMessage()    {}
 func (*ActiveNSExtensions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{63}
+	return fileDescriptor_fd1fa389f704dbf7, []int{65}
 }
 func (m *ActiveNSExtensions) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4168,7 +4320,7 @@ func (m *RotateFileVaultKey) Reset()         { *m = RotateFileVaultKey{} }
 func (m *RotateFileVaultKey) String() string { return proto.CompactTextString(m) }
 func (*RotateFileVaultKey) ProtoMessage()    {}
 func (*RotateFileVaultKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{64}
+	return fileDescriptor_fd1fa389f704dbf7, []int{66}
 }
 func (m *RotateFileVaultKey) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4238,7 +4390,7 @@ func (m *FileVaultUnlock) Reset()         { *m = FileVaultUnlock{} }
 func (m *FileVaultUnlock) String() string { return proto.CompactTextString(m) }
 func (*FileVaultUnlock) ProtoMessage()    {}
 func (*FileVaultUnlock) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{65}
+	return fileDescriptor_fd1fa389f704dbf7, []int{67}
 }
 func (m *FileVaultUnlock) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4299,7 +4451,7 @@ func (m *SetBootstrapToken) Reset()         { *m = SetBootstrapToken{} }
 func (m *SetBootstrapToken) String() string { return proto.CompactTextString(m) }
 func (*SetBootstrapToken) ProtoMessage()    {}
 func (*SetBootstrapToken) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{66}
+	return fileDescriptor_fd1fa389f704dbf7, []int{68}
 }
 func (m *SetBootstrapToken) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4348,7 +4500,7 @@ func (m *ResultPayload) Reset()         { *m = ResultPayload{} }
 func (m *ResultPayload) String() string { return proto.CompactTextString(m) }
 func (*ResultPayload) ProtoMessage()    {}
 func (*ResultPayload) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{67}
+	return fileDescriptor_fd1fa389f704dbf7, []int{69}
 }
 func (m *ResultPayload) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4415,7 +4567,7 @@ func (m *ErrorChain) Reset()         { *m = ErrorChain{} }
 func (m *ErrorChain) String() string { return proto.CompactTextString(m) }
 func (*ErrorChain) ProtoMessage()    {}
 func (*ErrorChain) Descriptor() ([]byte, []int) {
-	return fileDescriptor_fd1fa389f704dbf7, []int{68}
+	return fileDescriptor_fd1fa389f704dbf7, []int{70}
 }
 func (m *ErrorChain) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -4533,6 +4685,8 @@ func init() {
 	proto.RegisterType((*ManagedApplicationFeedback)(nil), "mdmproto.ManagedApplicationFeedback")
 	proto.RegisterType((*SetFirmwarePassword)(nil), "mdmproto.SetFirmwarePassword")
 	proto.RegisterType((*VerifyFirmwarePassword)(nil), "mdmproto.VerifyFirmwarePassword")
+	proto.RegisterType((*SetRecoveryLock)(nil), "mdmproto.SetRecoveryLock")
+	proto.RegisterType((*VerifyRecoveryLock)(nil), "mdmproto.VerifyRecoveryLock")
 	proto.RegisterType((*SetAutoAdminPassword)(nil), "mdmproto.SetAutoAdminPassword")
 	proto.RegisterType((*ScheduleOSUpdate)(nil), "mdmproto.ScheduleOSUpdate")
 	proto.RegisterType((*Update)(nil), "mdmproto.Update")
@@ -4548,247 +4702,253 @@ func init() {
 func init() { proto.RegisterFile("mdm.proto", fileDescriptor_fd1fa389f704dbf7) }
 
 var fileDescriptor_fd1fa389f704dbf7 = []byte{
-	// 3838 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0x4f, 0x73, 0x1b, 0x47,
-	0x76, 0x27, 0x48, 0x8a, 0x04, 0x1e, 0x40, 0x12, 0x6c, 0xfe, 0x11, 0x48, 0x4a, 0xa4, 0x34, 0xb2,
-	0xd7, 0xb2, 0xd7, 0x96, 0x12, 0xd9, 0xf2, 0x7a, 0x77, 0xed, 0xc4, 0x14, 0x29, 0x2d, 0xb9, 0x16,
-	0x45, 0xd6, 0x40, 0x92, 0xab, 0xd6, 0xd9, 0xcc, 0x0e, 0x31, 0x4d, 0xa0, 0x8b, 0xf3, 0x6f, 0xbb,
-	0x67, 0x40, 0xc3, 0xe7, 0xa4, 0x72, 0xce, 0x25, 0x49, 0xe5, 0x92, 0x7b, 0x2a, 0x5f, 0x20, 0xf9,
-	0x04, 0x39, 0xa6, 0xf2, 0x09, 0xb6, 0x9c, 0xaf, 0x90, 0x8b, 0x6f, 0xa9, 0xd7, 0x7f, 0x66, 0x06,
-	0x83, 0x21, 0xa8, 0x4b, 0x6e, 0xe8, 0xf7, 0x7e, 0xfd, 0xba, 0xe7, 0x75, 0xbf, 0xd7, 0xef, 0x0f,
-	0xa0, 0x11, 0x78, 0xc1, 0xa3, 0x98, 0x47, 0x49, 0x44, 0xea, 0x81, 0x17, 0xc8, 0x5f, 0xd6, 0x1f,
-	0x60, 0xf9, 0x20, 0x0a, 0x02, 0x37, 0xf4, 0xce, 0xdc, 0x91, 0x1f, 0xb9, 0x1e, 0xb9, 0x0f, 0xad,
-	0x9e, 0xa2, 0x38, 0x69, 0xca, 0xbc, 0x4e, 0xed, 0x5e, 0xed, 0x61, 0xc3, 0x6e, 0x6a, 0xda, 0x9b,
-	0x94, 0x79, 0xe4, 0xe7, 0xb0, 0xa8, 0x87, 0x9d, 0xd9, 0x7b, 0xb5, 0x87, 0xcd, 0x27, 0xab, 0x8f,
-	0x8c, 0xc0, 0x47, 0x5a, 0x9a, 0x6d, 0x10, 0xd6, 0xbf, 0xdd, 0x86, 0x45, 0x4d, 0x44, 0xd9, 0x9c,
-	0xfe, 0x31, 0xa5, 0x22, 0x71, 0x92, 0x51, 0x4c, 0x8d, 0x6c, 0x4d, 0x7b, 0x3d, 0x8a, 0x29, 0x39,
-	0x80, 0x15, 0x16, 0x8a, 0xc4, 0xf5, 0x7d, 0x27, 0xe6, 0xd1, 0x05, 0xf3, 0xa9, 0x5e, 0xa3, 0x93,
-	0xaf, 0x71, 0xac, 0x00, 0x67, 0x8a, 0x7f, 0x34, 0x63, 0x2f, 0xb3, 0x31, 0x0a, 0xf9, 0x1a, 0x96,
-	0x39, 0x0d, 0xa2, 0x21, 0xcd, 0x64, 0xcc, 0x49, 0x19, 0xb7, 0x73, 0x19, 0xb6, 0xe4, 0xe7, 0x22,
-	0x96, 0x78, 0x91, 0x40, 0x06, 0x70, 0xa7, 0xb0, 0x8d, 0x21, 0x13, 0x2c, 0x0a, 0x59, 0xd8, 0xcf,
-	0xe4, 0xcd, 0x4b, 0x79, 0xef, 0x55, 0xed, 0x29, 0x03, 0xe7, 0xc2, 0xb7, 0xd9, 0xb5, 0x5c, 0x42,
-	0x61, 0xa7, 0xb8, 0xd7, 0xf2, 0x42, 0xb7, 0xe4, 0x42, 0x0f, 0x2a, 0x36, 0x5e, 0xb1, 0xce, 0x56,
-	0xe1, 0x23, 0x4a, 0xcb, 0x9c, 0x83, 0xd9, 0x04, 0xf5, 0x1c, 0x37, 0x8e, 0x7d, 0xd6, 0x73, 0x13,
-	0x16, 0x85, 0x8e, 0xcf, 0x44, 0xd2, 0x59, 0x90, 0xab, 0x58, 0x13, 0x9f, 0x43, 0xbd, 0xfd, 0x1c,
-	0xfa, 0x92, 0x89, 0xe4, 0x68, 0xc6, 0xee, 0xb0, 0x6b, 0x78, 0xe4, 0x25, 0x10, 0x8f, 0x0e, 0x59,
-	0x8f, 0x3a, 0x2c, 0xbc, 0x88, 0x78, 0x20, 0x39, 0x9d, 0x45, 0x29, 0x7b, 0x27, 0x97, 0x7d, 0x28,
-	0x31, 0xc7, 0x39, 0xe4, 0x68, 0xc6, 0x5e, 0xf5, 0xca, 0x44, 0xf2, 0x0b, 0x68, 0x6a, 0x69, 0x7e,
-	0xd4, 0xbb, 0xec, 0xd4, 0xa5, 0x98, 0xf5, 0xb2, 0x98, 0x97, 0x51, 0xef, 0xf2, 0x68, 0xc6, 0x06,
-	0x2f, 0x1b, 0xe1, 0xe9, 0xf7, 0x7c, 0xea, 0x72, 0x27, 0x76, 0x85, 0xe8, 0x45, 0x1e, 0xed, 0x34,
-	0xca, 0xa7, 0x7f, 0x80, 0xfc, 0x33, 0xcd, 0xc6, 0xd3, 0xef, 0x15, 0x09, 0xe4, 0x57, 0xd0, 0xa2,
-	0xdc, 0x15, 0xd4, 0x51, 0x52, 0x3b, 0x20, 0xe7, 0x6f, 0xe4, 0xf3, 0x9f, 0x23, 0x57, 0x6d, 0xe0,
-	0x68, 0xc6, 0x6e, 0xd2, 0x7c, 0x48, 0x8e, 0x61, 0xd5, 0xdc, 0xf1, 0x80, 0x71, 0x1e, 0x71, 0x16,
-	0xf6, 0x3b, 0x4d, 0x29, 0x60, 0xbb, 0x78, 0x8a, 0x12, 0x72, 0x62, 0x10, 0x47, 0x33, 0x76, 0x9b,
-	0x97, 0x68, 0xe4, 0x4b, 0x34, 0x17, 0x91, 0x70, 0xd6, 0x43, 0x85, 0x88, 0x4e, 0x4b, 0x4a, 0xd9,
-	0x2c, 0x4a, 0xc9, 0xb9, 0x47, 0x33, 0xf6, 0x18, 0x9a, 0x9c, 0xc0, 0x5a, 0x1a, 0xa2, 0xea, 0x9c,
-	0x54, 0x50, 0xee, 0xb8, 0xbd, 0x5e, 0x94, 0x86, 0x49, 0x67, 0xa9, 0x7c, 0x1c, 0x6f, 0x24, 0xe8,
-	0x8d, 0xa0, 0x7c, 0x5f, 0x41, 0xf0, 0x38, 0xd2, 0x32, 0x51, 0x1d, 0x87, 0x4f, 0x13, 0x2a, 0xc5,
-	0x75, 0x96, 0x27, 0x8f, 0x03, 0x99, 0x38, 0x43, 0x1d, 0x87, 0x19, 0x91, 0x43, 0x68, 0xd3, 0xd0,
-	0x3d, 0xf7, 0xf1, 0x1c, 0x51, 0x29, 0x78, 0x20, 0x2b, 0x65, 0x93, 0x7e, 0x2e, 0x11, 0x2f, 0x23,
-	0x91, 0x9c, 0xa8, 0x13, 0x59, 0xa6, 0x63, 0x14, 0x72, 0x0a, 0x6b, 0xc6, 0x20, 0x0b, 0xb7, 0xb7,
-	0xd3, 0x96, 0x82, 0xee, 0x4c, 0x5c, 0xdc, 0xc2, 0xd5, 0x3c, 0x9a, 0xb1, 0x09, 0x9b, 0xa0, 0x92,
-	0x37, 0xb0, 0xa1, 0x55, 0xe2, 0xf4, 0xa2, 0xf0, 0x82, 0xf5, 0x53, 0xae, 0x44, 0xae, 0x4a, 0x91,
-	0xbb, 0xb9, 0x48, 0xad, 0x81, 0x83, 0x22, 0xea, 0x68, 0xc6, 0x5e, 0x77, 0x2b, 0xe8, 0xa4, 0x0b,
-	0x1b, 0xb8, 0xbf, 0x91, 0xc3, 0xa9, 0x47, 0x83, 0x58, 0x9a, 0x98, 0xbc, 0x83, 0x44, 0x8a, 0xbd,
-	0x5b, 0x10, 0x8b, 0x30, 0x3b, 0x43, 0x1d, 0xa8, 0xef, 0x5e, 0x73, 0x27, 0xc9, 0xe4, 0xaf, 0xa0,
-	0x13, 0xb8, 0xa1, 0xdb, 0xaf, 0x32, 0xdd, 0x35, 0x29, 0xf7, 0x5e, 0x2e, 0xf7, 0x44, 0x21, 0x27,
-	0x0d, 0x77, 0x33, 0xa8, 0xe4, 0xa0, 0xd9, 0x6a, 0x0f, 0x54, 0xd4, 0xec, 0x7a, 0xf9, 0x9e, 0x28,
-	0xc7, 0x33, 0xae, 0xd8, 0x55, 0x5e, 0x26, 0x92, 0xdf, 0xc0, 0x2a, 0x0b, 0x87, 0x2c, 0xa1, 0x4e,
-	0x12, 0xa1, 0x17, 0xeb, 0x73, 0x37, 0xe8, 0x6c, 0x48, 0x61, 0x5b, 0xc5, 0x63, 0x42, 0xc8, 0xeb,
-	0xe8, 0x4c, 0x01, 0x8e, 0x66, 0xec, 0x15, 0x36, 0x4e, 0xc2, 0x03, 0x1a, 0xba, 0x3e, 0xf3, 0xdc,
-	0xc4, 0x2d, 0x6e, 0x4c, 0x74, 0x36, 0xcb, 0x07, 0xf4, 0x56, 0xc1, 0x8a, 0xdb, 0x40, 0x73, 0x58,
-	0x37, 0xd3, 0x8b, 0x74, 0xf2, 0x15, 0x2c, 0x99, 0x8b, 0x14, 0x50, 0x8f, 0xb9, 0x9d, 0xdb, 0x65,
-	0xab, 0xd2, 0x57, 0xe8, 0x04, 0xb9, 0x68, 0x55, 0xac, 0x30, 0x46, 0xd7, 0xa0, 0x95, 0xa5, 0x66,
-	0x77, 0xca, 0xae, 0x41, 0xa9, 0xc9, 0x4c, 0x6e, 0xf2, 0x7c, 0x48, 0xfe, 0x0c, 0xea, 0x82, 0x26,
-	0x09, 0x0b, 0xfb, 0xa2, 0xb3, 0x25, 0xe7, 0x91, 0x7c, 0x5e, 0x57, 0x73, 0x8e, 0x66, 0xec, 0x0c,
-	0x45, 0xae, 0xe0, 0x7e, 0xd5, 0xc1, 0x8f, 0x5f, 0xd8, 0x6d, 0x29, 0xea, 0xc3, 0x69, 0x37, 0xa0,
-	0x7c, 0x77, 0xf7, 0x82, 0xe9, 0x10, 0x12, 0xc2, 0x6e, 0xd5, 0xc2, 0x6e, 0x92, 0x70, 0x76, 0x9e,
-	0x26, 0x54, 0x74, 0x76, 0xe4, 0xaa, 0x3f, 0x9b, 0xb6, 0xea, 0x7e, 0x86, 0x3e, 0x9a, 0xb1, 0xef,
-	0x04, 0x53, 0xf8, 0xf8, 0xde, 0x56, 0xad, 0x77, 0x41, 0xa9, 0x77, 0xee, 0xf6, 0x2e, 0x3b, 0x77,
-	0xca, 0xef, 0xed, 0xe4, 0x6a, 0x2f, 0x34, 0x16, 0xdf, 0xdb, 0xe0, 0x5a, 0x2e, 0x1a, 0xa8, 0xa0,
-	0x89, 0x73, 0xc1, 0x78, 0x70, 0xe5, 0x72, 0x2a, 0x1f, 0x89, 0xab, 0x88, 0x7b, 0x9d, 0xbb, 0x65,
-	0x03, 0xed, 0xd2, 0xe4, 0x85, 0x46, 0x9d, 0x69, 0x10, 0x1a, 0xa8, 0x98, 0x24, 0xa3, 0x81, 0x0e,
-	0x29, 0x67, 0x17, 0xa3, 0x0a, 0xb9, 0xbb, 0x65, 0x03, 0x7d, 0x2b, 0x91, 0x15, 0xa2, 0x37, 0x87,
-	0x95, 0x1c, 0xf2, 0x2d, 0xdc, 0xc6, 0x2d, 0xbb, 0x69, 0x12, 0x39, 0xae, 0x17, 0xb0, 0x30, 0x17,
-	0xbe, 0x57, 0xb6, 0x85, 0x2e, 0x4d, 0xf6, 0xd3, 0x24, 0xda, 0x47, 0x58, 0x41, 0xf4, 0xba, 0xa8,
-	0xa0, 0x93, 0xdf, 0x02, 0x11, 0xbd, 0x01, 0xf5, 0x52, 0x9f, 0x3a, 0x91, 0x70, 0xd2, 0x18, 0xad,
-	0xa8, 0x73, 0xaf, 0xfc, 0x58, 0x75, 0x35, 0xe6, 0xb4, 0xfb, 0x46, 0x22, 0xf0, 0xb1, 0x32, 0xf3,
-	0x4e, 0x85, 0xa2, 0xc9, 0x4d, 0x4e, 0xc8, 0x72, 0x44, 0xcf, 0x0d, 0x3b, 0xf7, 0x27, 0x36, 0x59,
-	0x12, 0xd8, 0xed, 0xb9, 0xd2, 0xa3, 0x96, 0x85, 0x22, 0x9d, 0x9c, 0xc1, 0xba, 0xdb, 0x4b, 0xd8,
-	0x90, 0x3a, 0xa1, 0x70, 0xe8, 0xf7, 0x09, 0x0d, 0x85, 0x74, 0x03, 0x56, 0xd9, 0xf5, 0xef, 0x4b,
-	0xd4, 0xab, 0xee, 0xf3, 0x0c, 0x83, 0xae, 0x5f, 0xcd, 0x7d, 0x25, 0x72, 0x2a, 0x4a, 0xe4, 0x51,
-	0x82, 0xdb, 0xc3, 0xd0, 0x68, 0xe8, 0xa6, 0x7e, 0xe2, 0x5c, 0xd2, 0x51, 0xe7, 0x41, 0x59, 0xa2,
-	0x2d, 0x51, 0x2f, 0x98, 0x4f, 0xdf, 0x22, 0xe8, 0x1b, 0x3a, 0x42, 0x89, 0x3c, 0xa3, 0x0e, 0x35,
-	0x15, 0xcd, 0xc5, 0x38, 0x15, 0x1a, 0x26, 0x94, 0xc7, 0x9c, 0x89, 0x71, 0x77, 0xfa, 0x5e, 0xd9,
-	0x5c, 0xb4, 0x97, 0x79, 0x9e, 0xc1, 0xc7, 0x3d, 0xab, 0x09, 0x3f, 0x2b, 0xf9, 0xf8, 0xb6, 0xe3,
-	0x8d, 0x38, 0x8f, 0xa2, 0x44, 0x24, 0xdc, 0x8d, 0x9d, 0x24, 0xba, 0xa4, 0x61, 0xe7, 0xfd, 0xb2,
-	0xcf, 0xee, 0xd2, 0xe4, 0x99, 0xc1, 0xbc, 0x46, 0x08, 0xfa, 0x6c, 0x51, 0x26, 0x3e, 0x6b, 0xc0,
-	0xa2, 0x0e, 0x3e, 0xac, 0x8f, 0x60, 0x79, 0x3c, 0xbc, 0x26, 0x1d, 0x58, 0x8c, 0x55, 0x6e, 0x20,
-	0xe3, 0xf5, 0x96, 0x6d, 0x86, 0xd6, 0x63, 0x58, 0x1a, 0x0b, 0xa3, 0xc9, 0x2e, 0x00, 0xf3, 0x68,
-	0x98, 0xb0, 0x0b, 0x46, 0xb9, 0x8e, 0xee, 0x0b, 0x14, 0xeb, 0x14, 0xb6, 0xaf, 0x8f, 0x93, 0xc9,
-	0x9f, 0xc3, 0x7a, 0x65, 0xac, 0xad, 0x56, 0x5d, 0x8b, 0x27, 0xa7, 0x58, 0x8f, 0x61, 0xeb, 0xda,
-	0x78, 0x98, 0x10, 0x98, 0x2f, 0x64, 0x30, 0xf2, 0xb7, 0x35, 0x80, 0xce, 0x75, 0xa1, 0x2d, 0xb9,
-	0x07, 0xcd, 0x7c, 0xaf, 0xa2, 0x53, 0xbb, 0x37, 0x87, 0xc9, 0x49, 0x81, 0x44, 0x3e, 0x82, 0xd5,
-	0x82, 0x97, 0x12, 0x4e, 0x14, 0xfa, 0x23, 0x99, 0x9e, 0xd4, 0xed, 0x95, 0xdc, 0xe5, 0x88, 0xd3,
-	0xd0, 0x1f, 0x59, 0x9f, 0xc0, 0xea, 0x44, 0xa0, 0x8b, 0xba, 0xfc, 0x63, 0x4a, 0x39, 0xa3, 0x46,
-	0xbc, 0x19, 0x5a, 0x4f, 0x60, 0x69, 0x2c, 0x28, 0xc5, 0x5c, 0x49, 0x87, 0x6f, 0xea, 0x6c, 0x95,
-	0x16, 0x9a, 0x8a, 0x26, 0x8f, 0xcd, 0xfa, 0x0e, 0x20, 0x0f, 0x82, 0x49, 0x1b, 0xe6, 0x62, 0x16,
-	0xea, 0xaf, 0xc5, 0x9f, 0xb8, 0x5a, 0x40, 0x85, 0x70, 0xfb, 0x2a, 0x87, 0x6a, 0xd8, 0x66, 0x88,
-	0xc2, 0xe3, 0x41, 0x14, 0x52, 0x27, 0x4c, 0x83, 0x73, 0xca, 0x65, 0x7a, 0xd4, 0xb0, 0x9b, 0x92,
-	0xf6, 0x4a, 0x92, 0xac, 0xbf, 0xab, 0x41, 0xb3, 0x10, 0xe6, 0x56, 0x88, 0xff, 0x18, 0x48, 0xcc,
-	0xa9, 0xa0, 0x7c, 0x48, 0x1d, 0xf9, 0x4a, 0xc7, 0xbe, 0x1b, 0x6a, 0x75, 0xb4, 0x0d, 0xe7, 0xd0,
-	0x4d, 0xdc, 0x33, 0xdf, 0x0d, 0xc9, 0x17, 0xd0, 0xf1, 0x98, 0x70, 0x7d, 0x3f, 0xba, 0xc2, 0x93,
-	0xfd, 0x9e, 0x05, 0x2c, 0x19, 0x39, 0x82, 0x26, 0x69, 0x2c, 0x97, 0xaf, 0xdb, 0x9b, 0x86, 0x7f,
-	0x66, 0xd8, 0x5d, 0xe4, 0x5a, 0xff, 0x5a, 0x83, 0x76, 0x39, 0x5e, 0x26, 0x1f, 0x42, 0xdb, 0xa3,
-	0x22, 0x61, 0xa1, 0x7a, 0x28, 0x42, 0x37, 0x30, 0xe9, 0xe4, 0x4a, 0x81, 0xfe, 0xca, 0x0d, 0x28,
-	0x79, 0x02, 0x1b, 0x45, 0xa8, 0x49, 0x51, 0x3c, 0xad, 0x94, 0xb5, 0x02, 0x53, 0x9f, 0x98, 0x47,
-	0x76, 0xa0, 0x81, 0xae, 0xcb, 0x49, 0x58, 0x40, 0xb5, 0x76, 0xea, 0x48, 0x78, 0xcd, 0x02, 0x4a,
-	0xb6, 0xa1, 0x9e, 0x39, 0xe0, 0x79, 0xc5, 0x33, 0x63, 0x6b, 0x1f, 0x5a, 0xc5, 0xa8, 0x5c, 0x5f,
-	0x6a, 0xbc, 0x8f, 0xce, 0x58, 0x2c, 0x5f, 0x93, 0x9f, 0xbc, 0xa6, 0x79, 0xc5, 0x29, 0xd6, 0x63,
-	0x58, 0x9d, 0x88, 0xc9, 0x71, 0x4d, 0x8c, 0xbb, 0x0b, 0xdf, 0x99, 0x8d, 0xad, 0x53, 0xbc, 0x07,
-	0x59, 0xbc, 0x3d, 0x05, 0x49, 0xde, 0x87, 0xe5, 0x8b, 0x88, 0xf7, 0x30, 0xb1, 0xf1, 0xa9, 0xf4,
-	0x4b, 0xea, 0xb8, 0x96, 0x24, 0xf5, 0x50, 0x13, 0x2d, 0x06, 0xcb, 0xe3, 0x01, 0x79, 0xf1, 0x2a,
-	0xd5, 0xa6, 0x5f, 0xa5, 0xd9, 0x89, 0xab, 0x84, 0x3b, 0xba, 0x88, 0xa2, 0x24, 0x8c, 0x92, 0x4c,
-	0x97, 0x66, 0x6c, 0xfd, 0xc7, 0x1c, 0x90, 0xc9, 0x98, 0x9d, 0xfc, 0x0c, 0x56, 0x58, 0x92, 0x86,
-	0x54, 0x38, 0x22, 0x89, 0xb8, 0x3c, 0x2d, 0x5c, 0x77, 0xce, 0x5e, 0x52, 0xe4, 0x2e, 0x52, 0x8f,
-	0xbd, 0x92, 0xc7, 0x99, 0x2d, 0x7b, 0x1c, 0xf2, 0x15, 0x2c, 0x46, 0xb1, 0xd2, 0xf8, 0x5c, 0x39,
-	0x93, 0x9e, 0x5c, 0xf6, 0x54, 0x41, 0x6d, 0x33, 0x07, 0x3f, 0x2e, 0x70, 0x43, 0x76, 0x81, 0xd9,
-	0x5c, 0xca, 0x7d, 0x7d, 0xda, 0x4d, 0x43, 0x7b, 0xc3, 0x7d, 0xbc, 0x88, 0xca, 0xf4, 0x03, 0x1a,
-	0x26, 0xce, 0x85, 0xef, 0xf6, 0x85, 0x4c, 0xda, 0xe7, 0x8c, 0x4b, 0x40, 0xfa, 0x0b, 0x24, 0x93,
-	0x53, 0x58, 0x1a, 0x8f, 0xdc, 0x16, 0xca, 0x91, 0xdb, 0xe4, 0x96, 0xc6, 0xc2, 0x32, 0x7b, 0x7c,
-	0x3e, 0x79, 0x01, 0x50, 0x88, 0xc8, 0x16, 0xaf, 0x79, 0x62, 0x2a, 0x23, 0x2e, 0xbb, 0x30, 0x93,
-	0x7c, 0x0e, 0xb7, 0x7b, 0x03, 0x37, 0xec, 0x53, 0xa7, 0xf0, 0x29, 0x02, 0x5f, 0x39, 0x99, 0x76,
-	0x37, 0xec, 0x0d, 0xc5, 0x3e, 0xc9, 0xb8, 0x5d, 0x64, 0x5a, 0x87, 0xb0, 0x75, 0xad, 0x12, 0xc9,
-	0x07, 0xb0, 0x12, 0xa7, 0xbc, 0x37, 0xc0, 0x3c, 0x3a, 0xa0, 0xc9, 0x20, 0x32, 0x47, 0xb8, 0x6c,
-	0xc8, 0x27, 0x92, 0x6a, 0xdd, 0x87, 0xbd, 0x1b, 0xbe, 0xdb, 0xda, 0x85, 0x3b, 0xd3, 0x3e, 0xc6,
-	0xfa, 0xa9, 0x96, 0x01, 0xaa, 0x1f, 0xcc, 0x47, 0x50, 0x37, 0x87, 0x26, 0x77, 0x31, 0x16, 0x7a,
-	0x9f, 0x68, 0x8e, 0x9d, 0x61, 0x26, 0x0e, 0x7e, 0x76, 0xf2, 0xe0, 0x7f, 0x0d, 0xdb, 0x45, 0x88,
-	0x13, 0xb3, 0x50, 0x3e, 0x5b, 0x3d, 0xca, 0x13, 0xbc, 0x6d, 0x73, 0x0f, 0x5b, 0xf6, 0xed, 0xc2,
-	0x84, 0x33, 0xc5, 0x3f, 0x40, 0x36, 0x39, 0x86, 0xfb, 0x06, 0xcf, 0xe9, 0x30, 0x32, 0x71, 0xfd,
-	0x80, 0xf6, 0x2e, 0x1d, 0x7c, 0x8a, 0x19, 0xa7, 0xca, 0xb7, 0xd4, 0xed, 0x5d, 0x0d, 0xb4, 0x33,
-	0xdc, 0x01, 0xc2, 0x6c, 0x8d, 0xb2, 0x8e, 0xa1, 0x6e, 0x3e, 0x80, 0x7c, 0x05, 0xcb, 0xd9, 0x9e,
-	0x58, 0x42, 0x03, 0xf5, 0xcc, 0x8c, 0x65, 0x37, 0x06, 0x7b, 0x9c, 0xd0, 0xc0, 0x5e, 0x0a, 0x0a,
-	0x23, 0x61, 0xf5, 0xa1, 0x55, 0x64, 0x93, 0x0f, 0x60, 0xc1, 0x15, 0x82, 0x26, 0x46, 0xcc, 0x4a,
-	0x21, 0xd8, 0x42, 0xba, 0xad, 0xd9, 0x52, 0xbd, 0x34, 0x71, 0xf1, 0x15, 0xd0, 0xe5, 0xba, 0xa2,
-	0x7a, 0x35, 0xc7, 0xce, 0x30, 0xd6, 0x3f, 0xd6, 0xe0, 0x96, 0x94, 0x80, 0x8f, 0xf4, 0x25, 0x0b,
-	0xb3, 0x47, 0x1a, 0x7f, 0x93, 0x2d, 0xa8, 0x07, 0xde, 0x53, 0x47, 0xb0, 0x1f, 0xd4, 0xc3, 0x35,
-	0x67, 0x2f, 0x06, 0xde, 0xd3, 0x2e, 0xfb, 0x41, 0xbe, 0xe9, 0x81, 0xf7, 0x54, 0xa9, 0xb7, 0x61,
-	0xcb, 0xdf, 0xf8, 0x32, 0xe5, 0xb6, 0x89, 0x3f, 0xc9, 0x1e, 0x34, 0xc5, 0xc0, 0x7d, 0xf2, 0xf4,
-	0x73, 0x25, 0x43, 0x99, 0x23, 0x28, 0x92, 0x14, 0xd3, 0x81, 0x45, 0x35, 0x12, 0x9d, 0x05, 0xf5,
-	0x0e, 0xeb, 0xa1, 0xf5, 0xbf, 0x35, 0xa8, 0x9b, 0x0d, 0x93, 0x9f, 0xc3, 0xea, 0x79, 0x1a, 0x7a,
-	0x3e, 0xfa, 0x9f, 0x52, 0x58, 0xd3, 0x56, 0x8c, 0xe3, 0xdc, 0xd5, 0xbc, 0x0f, 0xcb, 0x1a, 0x3c,
-	0xa4, 0x5c, 0x18, 0xdf, 0xda, 0xb0, 0x97, 0x14, 0xf5, 0xad, 0x22, 0x92, 0x8f, 0xe0, 0x96, 0x3a,
-	0x99, 0x39, 0xa9, 0xd2, 0x42, 0x05, 0xe5, 0x99, 0x92, 0x18, 0x5e, 0x44, 0xb6, 0x82, 0x64, 0xca,
-	0x99, 0x2f, 0x28, 0x67, 0x1b, 0xea, 0x22, 0x3d, 0x4f, 0x58, 0xa2, 0x8b, 0x83, 0xf8, 0x30, 0xe9,
-	0x31, 0x59, 0x87, 0x5b, 0x8a, 0xb1, 0x20, 0x19, 0x6a, 0x40, 0x2c, 0x58, 0x42, 0x35, 0x38, 0x2c,
-	0x74, 0xce, 0x47, 0xc6, 0x51, 0xcc, 0xd9, 0x4d, 0x24, 0x1e, 0x87, 0xcf, 0x90, 0x64, 0xfd, 0x01,
-	0x20, 0x5f, 0xfe, 0xff, 0xe3, 0xbb, 0xad, 0xbf, 0x86, 0xb5, 0x8a, 0x8a, 0xc7, 0x4d, 0x21, 0x23,
-	0x7a, 0x91, 0x72, 0x25, 0x45, 0x89, 0x5f, 0xe6, 0x63, 0x82, 0xac, 0x5f, 0xc1, 0x66, 0x75, 0xe5,
-	0xe3, 0xe6, 0xb8, 0xce, 0xfa, 0x14, 0x56, 0x27, 0xaa, 0x1b, 0x37, 0x06, 0xb3, 0xdf, 0xc2, 0x4a,
-	0xa9, 0x8a, 0x41, 0xee, 0x02, 0xe8, 0x8a, 0x87, 0x93, 0xc5, 0x9d, 0x0d, 0x4d, 0x39, 0xf6, 0x50,
-	0x53, 0xb2, 0xc8, 0xa1, 0x8c, 0x3d, 0x77, 0x2b, 0x4b, 0x39, 0xf5, 0x0d, 0xf7, 0xad, 0x2f, 0x60,
-	0xbd, 0xaa, 0xa2, 0xf1, 0x0e, 0xdf, 0xf1, 0x2f, 0xf3, 0xb0, 0x5e, 0x55, 0xad, 0x22, 0x2f, 0xe1,
-	0x81, 0xb8, 0x64, 0xb1, 0x13, 0x73, 0x16, 0xb8, 0x5c, 0x87, 0x5d, 0x4e, 0x56, 0xff, 0xe2, 0x54,
-	0xbd, 0x47, 0x2a, 0x28, 0xd9, 0x43, 0xe8, 0x99, 0x42, 0xca, 0x08, 0xcc, 0x88, 0xd4, 0x30, 0xf2,
-	0x16, 0x3e, 0xc4, 0xec, 0xa3, 0x5a, 0x98, 0x2b, 0x1c, 0x4e, 0xfb, 0xa9, 0xef, 0x72, 0x55, 0x28,
-	0x54, 0x01, 0xc6, 0x03, 0x41, 0x93, 0x0a, 0x91, 0xfb, 0xc2, 0x56, 0x58, 0x19, 0xb9, 0x74, 0xe1,
-	0x03, 0x2f, 0x0a, 0x75, 0xa2, 0x1b, 0x47, 0x71, 0xea, 0x63, 0x8e, 0x66, 0x96, 0x31, 0x0b, 0xb0,
-	0xf0, 0x22, 0xd2, 0xae, 0xd1, 0x42, 0x38, 0xa6, 0xb5, 0x67, 0x1a, 0xac, 0x97, 0xd0, 0xd2, 0xe5,
-	0x5d, 0xfe, 0x25, 0x6c, 0xc9, 0x28, 0xba, 0x52, 0xcc, 0x2d, 0x15, 0x78, 0x22, 0xa0, 0x7a, 0x6a,
-	0x79, 0xd6, 0x45, 0xea, 0xfb, 0x2a, 0xd8, 0x54, 0x26, 0xb6, 0x19, 0x8f, 0x4d, 0x7b, 0x91, 0xfa,
-	0xbe, 0x8c, 0x39, 0x2b, 0xa6, 0xca, 0x2a, 0xac, 0x9c, 0xba, 0x58, 0x35, 0x15, 0x35, 0x20, 0xa7,
-	0x7e, 0x07, 0x5b, 0x52, 0x01, 0x5a, 0xad, 0x32, 0xdf, 0xd7, 0x32, 0x8c, 0xd3, 0x28, 0x14, 0x13,
-	0xf0, 0xeb, 0x95, 0x46, 0x11, 0xa8, 0x65, 0x09, 0x7b, 0xd3, 0xad, 0xa4, 0x5b, 0x7f, 0x5f, 0x83,
-	0xcd, 0xea, 0x29, 0x78, 0x79, 0xc5, 0x20, 0xe2, 0x49, 0x31, 0x96, 0x6e, 0x48, 0x8a, 0xdc, 0xd6,
-	0x0e, 0x34, 0xf2, 0x8f, 0x9f, 0xd5, 0x51, 0x9c, 0xf9, 0xdc, 0x07, 0xb0, 0x64, 0x22, 0x60, 0x67,
-	0xe0, 0x8a, 0x81, 0x0c, 0xb6, 0x5a, 0x76, 0xcb, 0x10, 0x8f, 0x5c, 0x31, 0x20, 0x9b, 0xb0, 0x30,
-	0x60, 0x9e, 0x47, 0x43, 0x7d, 0x7a, 0x7a, 0x64, 0x71, 0x68, 0x15, 0x4b, 0x6e, 0xef, 0x1c, 0xfb,
-	0xed, 0x40, 0x43, 0xd6, 0xe0, 0x0a, 0x96, 0x54, 0x97, 0x04, 0x7c, 0x9d, 0xef, 0x02, 0x28, 0xa6,
-	0x6c, 0x34, 0xa9, 0xa8, 0x53, 0xc1, 0x5f, 0x8f, 0x62, 0x6a, 0x8d, 0xa0, 0x59, 0x28, 0xd4, 0x95,
-	0xd0, 0xb5, 0x12, 0xba, 0x6a, 0x47, 0xb3, 0x55, 0x3b, 0x42, 0x35, 0xa0, 0xbb, 0x13, 0x09, 0x06,
-	0x50, 0xcc, 0xd3, 0xeb, 0xb6, 0x72, 0xe2, 0xb1, 0x67, 0xfd, 0x12, 0xea, 0xa6, 0xd6, 0x47, 0x3e,
-	0x29, 0x54, 0x04, 0xd5, 0x13, 0xbb, 0x3a, 0x51, 0x11, 0xcc, 0xcb, 0x81, 0xd6, 0x4f, 0x75, 0x58,
-	0xd4, 0x54, 0x7c, 0x1b, 0xf0, 0x91, 0x30, 0x0f, 0x27, 0xfe, 0x26, 0x5f, 0x66, 0x2d, 0x93, 0xec,
-	0x94, 0x2a, 0x3a, 0x2f, 0x78, 0x62, 0x46, 0xb6, 0xee, 0x9b, 0xc8, 0x43, 0x7c, 0x0a, 0xf5, 0x41,
-	0x24, 0x12, 0x39, 0x75, 0xae, 0x5c, 0xb0, 0x3d, 0xd2, 0x9c, 0x6c, 0x53, 0x06, 0x4a, 0x9e, 0xc1,
-	0xd2, 0x30, 0xc2, 0x35, 0x79, 0xe4, 0x06, 0x2c, 0xec, 0xeb, 0xde, 0x58, 0xa1, 0x90, 0xf6, 0x16,
-	0xd9, 0xb6, 0xe2, 0x9a, 0xf9, 0xad, 0x61, 0x81, 0x48, 0xbe, 0x81, 0x36, 0xea, 0x28, 0x0a, 0x5d,
-	0xdf, 0x19, 0x44, 0x89, 0x88, 0xa3, 0x44, 0x77, 0xbe, 0x0a, 0x57, 0xfd, 0x4c, 0x23, 0x8e, 0x14,
-	0xc0, 0x48, 0x5a, 0x89, 0xc7, 0xe9, 0xe4, 0x0b, 0x68, 0x5c, 0xb9, 0xbe, 0x1f, 0xbb, 0x31, 0xe5,
-	0x3a, 0xc4, 0x2e, 0x14, 0xb3, 0xbe, 0x35, 0x2c, 0x33, 0x3f, 0x07, 0x93, 0xbf, 0x84, 0x96, 0x4c,
-	0x64, 0xcd, 0x97, 0x2c, 0x96, 0x0b, 0x42, 0x98, 0xcd, 0x96, 0x3e, 0xa4, 0xe9, 0xe5, 0x34, 0x5c,
-	0xfa, 0xdc, 0x4f, 0x69, 0x12, 0x45, 0xc9, 0x40, 0x77, 0xac, 0x0a, 0x4b, 0x3f, 0x33, 0xac, 0x6c,
-	0xe9, 0x0c, 0x4c, 0x7e, 0x0f, 0x9b, 0xd7, 0x14, 0x5a, 0x1b, 0xe5, 0xb0, 0xbe, 0x32, 0x04, 0x36,
-	0x22, 0x37, 0xdc, 0xca, 0xfa, 0xea, 0x97, 0xd0, 0x0c, 0xbc, 0xc0, 0x31, 0xb9, 0x10, 0x94, 0x6f,
-	0xc6, 0xc9, 0xe1, 0x89, 0x8e, 0xdb, 0xb3, 0x9b, 0x11, 0x78, 0x81, 0x09, 0xe5, 0x29, 0x6c, 0x9b,
-	0x5e, 0x9a, 0x6c, 0xc6, 0x39, 0x7d, 0xee, 0xf6, 0xa8, 0x13, 0x53, 0xce, 0x22, 0x4f, 0x37, 0xb7,
-	0x1e, 0x16, 0x0e, 0x4a, 0x63, 0x5f, 0x46, 0xbd, 0xcb, 0xdf, 0x20, 0xf2, 0x4c, 0x02, 0x8d, 0xe4,
-	0xdb, 0x71, 0x35, 0x9f, 0x7c, 0x07, 0x9b, 0x81, 0xfb, 0x3d, 0x0b, 0xd2, 0x00, 0x73, 0x65, 0xf9,
-	0xb0, 0x49, 0xaf, 0x69, 0x3a, 0x5f, 0xef, 0x17, 0xa3, 0x58, 0x89, 0xb3, 0x35, 0x0c, 0x9d, 0x67,
-	0xb6, 0xf3, 0xf5, 0xa0, 0x82, 0x49, 0x7e, 0x07, 0x1b, 0x1e, 0x73, 0xfb, 0x61, 0x24, 0x12, 0xd6,
-	0x73, 0x44, 0x7a, 0x1e, 0x30, 0x21, 0xa3, 0x95, 0xa5, 0xb2, 0xec, 0xc3, 0x0c, 0xd6, 0xcd, 0x50,
-	0x99, 0x6c, 0xaf, 0x82, 0x89, 0x26, 0xe0, 0xc6, 0xb1, 0xe3, 0x86, 0xae, 0x3f, 0x4a, 0x58, 0x4f,
-	0xe8, 0xee, 0xd8, 0x78, 0xb3, 0x67, 0xdf, 0x70, 0x33, 0x13, 0x70, 0x0b, 0x44, 0x72, 0x01, 0x5b,
-	0xd7, 0x97, 0xf8, 0x57, 0xca, 0x89, 0xe2, 0x75, 0x99, 0x92, 0x91, 0xdd, 0x71, 0xaf, 0xab, 0xec,
-	0x7f, 0x0e, 0x8d, 0x84, 0x05, 0xd4, 0xf9, 0x21, 0x0a, 0xa9, 0x6e, 0x9f, 0x15, 0xcc, 0xfc, 0x35,
-	0x0b, 0xe8, 0xef, 0xa2, 0x30, 0x37, 0xf3, 0x44, 0x13, 0xac, 0xc7, 0xb0, 0x56, 0x61, 0xc7, 0x18,
-	0x49, 0xab, 0x4e, 0x9d, 0xa7, 0xa3, 0x07, 0x33, 0xb4, 0x9e, 0xc0, 0x66, 0xb5, 0xc5, 0x4e, 0x99,
-	0xf3, 0x17, 0xd0, 0x2e, 0xdb, 0x27, 0x06, 0xb5, 0x2c, 0x30, 0x85, 0x87, 0x96, 0xad, 0x06, 0x48,
-	0xbd, 0x1a, 0x50, 0x6e, 0x12, 0x04, 0x35, 0xb0, 0x1e, 0x01, 0x99, 0x34, 0xd1, 0x29, 0xeb, 0x7d,
-	0x0c, 0xed, 0xb2, 0x51, 0x4e, 0x41, 0xff, 0x43, 0x0d, 0xee, 0x4c, 0x33, 0xbe, 0x1b, 0x83, 0xd9,
-	0xb7, 0xd7, 0x1a, 0xb9, 0x72, 0xd5, 0x7b, 0x37, 0x18, 0xf9, 0x35, 0xd6, 0x6d, 0xfd, 0x6d, 0x0d,
-	0xf6, 0x6e, 0xb8, 0x11, 0x37, 0xee, 0xed, 0x19, 0xdc, 0x1d, 0xbb, 0x73, 0x8e, 0xa7, 0xea, 0x51,
-	0x18, 0xc2, 0x64, 0x79, 0x5d, 0xcb, 0xde, 0x19, 0x03, 0x1d, 0x66, 0x18, 0x54, 0xbb, 0xf5, 0x04,
-	0x36, 0xaa, 0xdb, 0x3b, 0x5b, 0x50, 0x1f, 0xc6, 0x61, 0xf1, 0x0f, 0x25, 0x8b, 0xc3, 0x38, 0x7c,
-	0x93, 0x32, 0xcf, 0xfa, 0xcc, 0xd4, 0x49, 0x0b, 0xcf, 0x12, 0x26, 0x70, 0xc5, 0x87, 0x4c, 0xef,
-	0x36, 0x7f, 0xab, 0xac, 0x47, 0xb0, 0x52, 0xba, 0xaa, 0x18, 0x0e, 0xe4, 0x17, 0x5b, 0x17, 0xbe,
-	0xb2, 0xdb, 0xfb, 0x09, 0xac, 0x94, 0x5e, 0x30, 0x4c, 0xa4, 0xb2, 0xe7, 0x4e, 0xc3, 0xcd, 0xd8,
-	0xfa, 0x2d, 0xac, 0x4e, 0x78, 0x44, 0xf2, 0x74, 0xdc, 0x87, 0xd6, 0xca, 0x1d, 0xf0, 0x7c, 0x46,
-	0xd1, 0x79, 0x5a, 0x1e, 0x40, 0xce, 0x21, 0x6f, 0xe1, 0xa1, 0xec, 0x48, 0xe8, 0x0e, 0x2e, 0x3a,
-	0x53, 0x59, 0xf3, 0xa4, 0x9e, 0x73, 0x35, 0x60, 0x3e, 0x75, 0x44, 0x1a, 0x53, 0x3e, 0x64, 0x22,
-	0xbb, 0x7e, 0xef, 0xe5, 0x78, 0x74, 0x98, 0xfb, 0x0a, 0xfd, 0x2d, 0x82, 0xbb, 0x19, 0xd6, 0xfa,
-	0x3d, 0xec, 0x4e, 0x77, 0xbb, 0xe4, 0xd7, 0x53, 0x9d, 0xb8, 0x8a, 0xb0, 0xae, 0x73, 0xcd, 0x56,
-	0x17, 0x76, 0xa6, 0xb8, 0x5c, 0xf2, 0xd9, 0xb5, 0x9e, 0x5b, 0xc9, 0xad, 0x74, 0xc9, 0xd6, 0x2f,
-	0x60, 0x67, 0x8a, 0xaf, 0x9d, 0x62, 0x88, 0x8f, 0x65, 0x2e, 0x59, 0x76, 0xa8, 0x53, 0x26, 0x1c,
-	0xc0, 0xde, 0x0d, 0x4d, 0xd1, 0x77, 0xc8, 0xae, 0xbe, 0x86, 0x3b, 0xd3, 0x7a, 0x9c, 0xef, 0x20,
-	0xa1, 0x0f, 0xdb, 0xd7, 0xf7, 0x2d, 0xdf, 0xa1, 0xff, 0xf0, 0x01, 0xac, 0xe8, 0xff, 0x60, 0x64,
-	0x8d, 0x51, 0x95, 0x5e, 0x2d, 0x2b, 0xb2, 0x11, 0x65, 0xfd, 0x4d, 0x0d, 0xd6, 0x2a, 0xda, 0x97,
-	0xe4, 0x43, 0x68, 0xf7, 0x52, 0xce, 0xf1, 0x78, 0xb2, 0x0a, 0xb6, 0xae, 0x9a, 0x6b, 0x7a, 0x06,
-	0xbd, 0x0f, 0xad, 0x90, 0x5e, 0xe5, 0x30, 0x5d, 0x01, 0x0b, 0xe9, 0x55, 0x06, 0xd9, 0x83, 0xa6,
-	0xaa, 0xe7, 0x47, 0x3c, 0x0a, 0x84, 0xae, 0xe2, 0x83, 0x24, 0x9d, 0x22, 0xc5, 0xfa, 0x0c, 0x36,
-	0xab, 0x9b, 0x9d, 0x63, 0x25, 0xf4, 0x5a, 0xa9, 0x84, 0x7e, 0x0a, 0xeb, 0x55, 0x5d, 0x4c, 0x8c,
-	0x78, 0xfb, 0x85, 0x7e, 0x0e, 0xfe, 0x9e, 0x4c, 0x3c, 0x66, 0x27, 0x13, 0x0f, 0x7c, 0x55, 0xca,
-	0x1d, 0x47, 0xf2, 0x11, 0x2c, 0xaa, 0x16, 0xa5, 0x09, 0xbc, 0xdb, 0x85, 0x7f, 0xc4, 0x48, 0x86,
-	0x6d, 0x00, 0xd6, 0x08, 0x16, 0xf4, 0xac, 0x3d, 0x68, 0xc6, 0x3c, 0xf2, 0xd2, 0x9e, 0x6a, 0x18,
-	0x6a, 0xbf, 0xa4, 0x49, 0xdf, 0xd0, 0x91, 0x2c, 0x7a, 0x6a, 0xc0, 0x78, 0x35, 0x64, 0x59, 0x93,
-	0x4d, 0x19, 0x48, 0xd6, 0x02, 0xf4, 0xff, 0x59, 0xa4, 0x0f, 0xd5, 0xb9, 0x82, 0xf9, 0x73, 0xc2,
-	0xbe, 0x24, 0x5a, 0x1f, 0xc3, 0x7a, 0x55, 0xb3, 0x14, 0x9f, 0x3f, 0x59, 0xb2, 0xd7, 0x17, 0x5d,
-	0x0d, 0xac, 0x97, 0x40, 0x26, 0x9b, 0xa0, 0xe4, 0x73, 0xb8, 0x7d, 0xc1, 0xfc, 0x84, 0xf2, 0xbc,
-	0x7b, 0xea, 0xc4, 0x11, 0x0b, 0x13, 0x73, 0xc7, 0x36, 0x14, 0x3b, 0x9b, 0x72, 0x26, 0x99, 0xd6,
-	0x9f, 0x6a, 0x40, 0x26, 0x3b, 0xa0, 0xe8, 0xcb, 0x2f, 0xe9, 0xa8, 0x98, 0x29, 0x2d, 0x5e, 0xd2,
-	0x91, 0xcc, 0x93, 0x0e, 0xa1, 0x9d, 0x77, 0x54, 0x55, 0xa7, 0x4a, 0xbf, 0x6c, 0x85, 0x10, 0x23,
-	0x13, 0xa6, 0x9a, 0x1c, 0xf6, 0x4a, 0x36, 0x45, 0x11, 0x50, 0x87, 0x78, 0xf3, 0x7a, 0x94, 0xe3,
-	0xbd, 0xef, 0xb9, 0xba, 0x6b, 0xd0, 0xb2, 0x97, 0x43, 0x7a, 0x75, 0x90, 0x53, 0xc9, 0xd7, 0x70,
-	0x87, 0xd3, 0xd8, 0x1f, 0x39, 0x34, 0xec, 0xf1, 0x91, 0xae, 0x10, 0x15, 0x66, 0xcd, 0xcb, 0x59,
-	0xdb, 0x12, 0xf3, 0x3c, 0x83, 0x14, 0x24, 0x58, 0xff, 0x5c, 0x83, 0x95, 0xd2, 0x7e, 0xa6, 0x5d,
-	0x4d, 0xd5, 0xf2, 0x42, 0x67, 0x4c, 0xf1, 0xfc, 0x1d, 0xfa, 0x7d, 0x1c, 0xf1, 0x44, 0xdf, 0xb9,
-	0xb6, 0xe6, 0x7c, 0x43, 0x47, 0xcf, 0x25, 0x9d, 0x7c, 0x05, 0x3b, 0x93, 0xe8, 0xdc, 0xa2, 0xd4,
-	0x81, 0x77, 0xca, 0xd3, 0xcc, 0x7d, 0xb7, 0xbe, 0x84, 0xd5, 0x89, 0xfe, 0x2d, 0x2a, 0xa7, 0xdc,
-	0xf5, 0x55, 0x9b, 0x5c, 0x3e, 0x1f, 0x03, 0x5a, 0xff, 0x5d, 0x83, 0x25, 0x9b, 0x8a, 0xd4, 0x4f,
-	0xcc, 0x3f, 0x3b, 0x09, 0xcc, 0xa7, 0x5e, 0xa1, 0x1f, 0xea, 0xb1, 0xc9, 0x7f, 0x7b, 0xce, 0x4e,
-	0xfe, 0xdb, 0xf3, 0x29, 0x34, 0x29, 0xe7, 0x11, 0x77, 0x7a, 0x03, 0x97, 0x85, 0x93, 0x65, 0xcb,
-	0xe7, 0xc8, 0x3c, 0x40, 0x9e, 0x0d, 0x34, 0xfb, 0x6d, 0x75, 0x61, 0xa1, 0x9b, 0xb8, 0x49, 0x2a,
-	0x48, 0x1b, 0x5a, 0xfb, 0xbd, 0xcb, 0x30, 0xba, 0xf2, 0xa9, 0xd7, 0xa7, 0x5e, 0x7b, 0x86, 0x34,
-	0xe0, 0x96, 0x9c, 0xd5, 0xae, 0x91, 0x4d, 0x20, 0xfa, 0xdf, 0xa1, 0x2f, 0x64, 0x97, 0x54, 0xd1,
-	0x67, 0x49, 0x1d, 0xe6, 0x8f, 0x3d, 0x9f, 0xb6, 0xe7, 0x08, 0xc0, 0xc2, 0xab, 0x28, 0x79, 0x15,
-	0x5d, 0xb5, 0xe7, 0xad, 0x7f, 0xaf, 0x01, 0xe4, 0xeb, 0x91, 0x4f, 0x61, 0xc3, 0x8f, 0x7a, 0xae,
-	0xcf, 0x7e, 0xa0, 0x9e, 0xe3, 0x51, 0xd1, 0xe3, 0x2c, 0xce, 0x0a, 0x59, 0x0d, 0x7b, 0x3d, 0x63,
-	0x1e, 0xe6, 0x3c, 0x7c, 0xab, 0x52, 0xe1, 0xd0, 0xb0, 0xef, 0x33, 0x31, 0x18, 0x9b, 0xa5, 0x3e,
-	0x7e, 0x3d, 0x15, 0xcf, 0x15, 0xb3, 0x38, 0xeb, 0x3e, 0xb4, 0x94, 0x16, 0xbc, 0x28, 0x50, 0x6a,
-	0x90, 0x8a, 0x92, 0xb4, 0x43, 0x49, 0x22, 0x77, 0x01, 0xb4, 0xa2, 0x22, 0x4f, 0x5d, 0xbe, 0x5b,
-	0x76, 0x43, 0x69, 0x24, 0xf2, 0xe8, 0xb3, 0xf6, 0x7f, 0xfe, 0xb8, 0x5b, 0xfb, 0xaf, 0x1f, 0x77,
-	0x6b, 0x7f, 0xfa, 0x71, 0xb7, 0xf6, 0x4f, 0xff, 0xb3, 0x3b, 0x73, 0xbe, 0x20, 0x15, 0xf8, 0xe9,
-	0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x97, 0x27, 0x04, 0x81, 0x9a, 0x2b, 0x00, 0x00,
+	// 3936 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0x4f, 0x73, 0x1b, 0x47,
+	0x76, 0x27, 0x44, 0x89, 0x04, 0x1e, 0x40, 0x02, 0x6c, 0xfe, 0xd1, 0x90, 0x94, 0x48, 0x69, 0x64,
+	0x5b, 0xb2, 0xd7, 0x96, 0x36, 0xb2, 0xe5, 0xf5, 0xee, 0xda, 0x89, 0x29, 0x52, 0x5a, 0x72, 0x2d,
+	0x8a, 0xac, 0x81, 0x24, 0x57, 0xad, 0xb3, 0x99, 0x1d, 0xce, 0x34, 0x81, 0x2e, 0xce, 0xbf, 0xed,
+	0xee, 0x01, 0x0d, 0xdf, 0x53, 0x39, 0xe7, 0x92, 0xa4, 0x72, 0xc9, 0x3d, 0xdf, 0x20, 0xf9, 0x02,
+	0x9b, 0xaa, 0x5c, 0x52, 0xf9, 0x04, 0x5b, 0xce, 0x57, 0xc8, 0x65, 0x6f, 0xa9, 0xfe, 0x37, 0x33,
+	0x18, 0x0c, 0x21, 0x5d, 0x72, 0xd8, 0x1b, 0xfa, 0xbd, 0x5f, 0xbf, 0xee, 0x79, 0xdd, 0xef, 0xf5,
+	0xfb, 0x03, 0x68, 0x45, 0x41, 0xf4, 0x30, 0xa5, 0x09, 0x4f, 0x50, 0x33, 0x0a, 0x22, 0xf9, 0xcb,
+	0xfe, 0x1d, 0x2c, 0xef, 0x27, 0x51, 0xe4, 0xc5, 0xc1, 0xa9, 0x37, 0x0e, 0x13, 0x2f, 0x40, 0x77,
+	0xa1, 0xe3, 0x2b, 0x8a, 0x9b, 0x65, 0x24, 0xb0, 0x1a, 0x77, 0x1a, 0x0f, 0x5a, 0x4e, 0x5b, 0xd3,
+	0x5e, 0x67, 0x24, 0x40, 0x3f, 0x81, 0x45, 0x3d, 0xb4, 0xae, 0xdd, 0x69, 0x3c, 0x68, 0x3f, 0x5e,
+	0x79, 0x68, 0x04, 0x3e, 0xd4, 0xd2, 0x1c, 0x83, 0xb0, 0xff, 0x60, 0xc1, 0xa2, 0x26, 0x0a, 0xd9,
+	0x14, 0xff, 0x3e, 0xc3, 0x8c, 0xbb, 0x7c, 0x9c, 0x62, 0x23, 0x5b, 0xd3, 0x5e, 0x8d, 0x53, 0x8c,
+	0xf6, 0xa1, 0x4b, 0x62, 0xc6, 0xbd, 0x30, 0x74, 0x53, 0x9a, 0x9c, 0x93, 0x10, 0xeb, 0x35, 0xac,
+	0x62, 0x8d, 0x23, 0x05, 0x38, 0x55, 0xfc, 0xc3, 0x39, 0x67, 0x99, 0x4c, 0x50, 0xd0, 0xd7, 0xb0,
+	0x4c, 0x71, 0x94, 0x8c, 0x70, 0x2e, 0x63, 0x5e, 0xca, 0xb8, 0x59, 0xc8, 0x70, 0x24, 0xbf, 0x10,
+	0xb1, 0x44, 0xcb, 0x04, 0x34, 0x84, 0x5b, 0xa5, 0x6d, 0x8c, 0x08, 0x23, 0x49, 0x4c, 0xe2, 0x41,
+	0x2e, 0xef, 0xba, 0x94, 0xf7, 0x5e, 0xdd, 0x9e, 0x72, 0x70, 0x21, 0x7c, 0x8b, 0x5c, 0xc9, 0x45,
+	0x18, 0xb6, 0xcb, 0x7b, 0xad, 0x2e, 0x74, 0x43, 0x2e, 0x74, 0xaf, 0x66, 0xe3, 0x35, 0xeb, 0x6c,
+	0x96, 0x3e, 0xa2, 0xb2, 0xcc, 0x19, 0x98, 0x4d, 0xe0, 0xc0, 0xf5, 0xd2, 0x34, 0x24, 0xbe, 0xc7,
+	0x49, 0x12, 0xbb, 0x21, 0x61, 0xdc, 0x5a, 0x90, 0xab, 0xd8, 0x53, 0x9f, 0x83, 0x83, 0xbd, 0x02,
+	0xfa, 0x82, 0x30, 0x7e, 0x38, 0xe7, 0x58, 0xe4, 0x0a, 0x1e, 0x7a, 0x01, 0x28, 0xc0, 0x23, 0xe2,
+	0x63, 0x97, 0xc4, 0xe7, 0x09, 0x8d, 0x24, 0xc7, 0x5a, 0x94, 0xb2, 0xb7, 0x0b, 0xd9, 0x07, 0x12,
+	0x73, 0x54, 0x40, 0x0e, 0xe7, 0x9c, 0x95, 0xa0, 0x4a, 0x44, 0x3f, 0x83, 0xb6, 0x96, 0x16, 0x26,
+	0xfe, 0x85, 0xd5, 0x94, 0x62, 0xd6, 0xaa, 0x62, 0x5e, 0x24, 0xfe, 0xc5, 0xe1, 0x9c, 0x03, 0x41,
+	0x3e, 0x12, 0xa7, 0xef, 0x87, 0xd8, 0xa3, 0x6e, 0xea, 0x31, 0xe6, 0x27, 0x01, 0xb6, 0x5a, 0xd5,
+	0xd3, 0xdf, 0x17, 0xfc, 0x53, 0xcd, 0x16, 0xa7, 0xef, 0x97, 0x09, 0xe8, 0x17, 0xd0, 0xc1, 0xd4,
+	0x63, 0xd8, 0x55, 0x52, 0x2d, 0x90, 0xf3, 0xd7, 0x8b, 0xf9, 0xcf, 0x04, 0x57, 0x6d, 0xe0, 0x70,
+	0xce, 0x69, 0xe3, 0x62, 0x88, 0x8e, 0x60, 0xc5, 0xdc, 0xf1, 0x88, 0x50, 0x9a, 0x50, 0x12, 0x0f,
+	0xac, 0xb6, 0x14, 0xb0, 0x55, 0x3e, 0x45, 0x09, 0x39, 0x36, 0x88, 0xc3, 0x39, 0xa7, 0x47, 0x2b,
+	0x34, 0xf4, 0xa5, 0x30, 0x17, 0xc6, 0x29, 0xf1, 0x85, 0x42, 0x98, 0xd5, 0x91, 0x52, 0x36, 0xca,
+	0x52, 0x0a, 0xee, 0xe1, 0x9c, 0x33, 0x81, 0x46, 0xc7, 0xb0, 0x9a, 0xc5, 0x42, 0x75, 0x6e, 0xc6,
+	0x30, 0x75, 0x3d, 0xdf, 0x4f, 0xb2, 0x98, 0x5b, 0x4b, 0xd5, 0xe3, 0x78, 0x2d, 0x41, 0xaf, 0x19,
+	0xa6, 0x7b, 0x0a, 0x22, 0x8e, 0x23, 0xab, 0x12, 0xd5, 0x71, 0x84, 0x98, 0x63, 0x29, 0xce, 0x5a,
+	0x9e, 0x3e, 0x0e, 0xc1, 0x14, 0x33, 0xd4, 0x71, 0x98, 0x11, 0x3a, 0x80, 0x1e, 0x8e, 0xbd, 0xb3,
+	0x50, 0x9c, 0xa3, 0x50, 0x8a, 0x38, 0x90, 0x6e, 0xd5, 0xa4, 0x9f, 0x49, 0xc4, 0x8b, 0x84, 0xf1,
+	0x63, 0x75, 0x22, 0xcb, 0x78, 0x82, 0x82, 0x4e, 0x60, 0xd5, 0x18, 0x64, 0xe9, 0xf6, 0x5a, 0x3d,
+	0x29, 0xe8, 0xd6, 0xd4, 0xc5, 0x2d, 0x5d, 0xcd, 0xc3, 0x39, 0x07, 0x91, 0x29, 0x2a, 0x7a, 0x0d,
+	0xeb, 0x5a, 0x25, 0xae, 0x9f, 0xc4, 0xe7, 0x64, 0x90, 0x51, 0x25, 0x72, 0x45, 0x8a, 0xdc, 0x29,
+	0x44, 0x6a, 0x0d, 0xec, 0x97, 0x51, 0x87, 0x73, 0xce, 0x9a, 0x57, 0x43, 0x47, 0x7d, 0x58, 0x17,
+	0xfb, 0x1b, 0xbb, 0x14, 0x07, 0x38, 0x4a, 0xa5, 0x89, 0xc9, 0x3b, 0x88, 0xa4, 0xd8, 0xdb, 0x25,
+	0xb1, 0x02, 0xe6, 0xe4, 0xa8, 0x7d, 0xf5, 0xdd, 0xab, 0xde, 0x34, 0x19, 0xfd, 0x35, 0x58, 0x91,
+	0x17, 0x7b, 0x83, 0x3a, 0xd3, 0x5d, 0x95, 0x72, 0xef, 0x14, 0x72, 0x8f, 0x15, 0x72, 0xda, 0x70,
+	0x37, 0xa2, 0x5a, 0x8e, 0x30, 0x5b, 0xed, 0x81, 0xca, 0x9a, 0x5d, 0xab, 0xde, 0x13, 0xe5, 0x78,
+	0x26, 0x15, 0xbb, 0x42, 0xab, 0x44, 0xf4, 0x2b, 0x58, 0x21, 0xf1, 0x88, 0x70, 0xec, 0xf2, 0x44,
+	0x78, 0xb1, 0x01, 0xf5, 0x22, 0x6b, 0x5d, 0x0a, 0xdb, 0x2c, 0x1f, 0x93, 0x80, 0xbc, 0x4a, 0x4e,
+	0x15, 0xe0, 0x70, 0xce, 0xe9, 0x92, 0x49, 0x92, 0x38, 0xa0, 0x91, 0x17, 0x92, 0xc0, 0xe3, 0x5e,
+	0x79, 0x63, 0xcc, 0xda, 0xa8, 0x1e, 0xd0, 0x1b, 0x05, 0x2b, 0x6f, 0x43, 0x98, 0xc3, 0x9a, 0x99,
+	0x5e, 0xa6, 0xa3, 0xaf, 0x60, 0xc9, 0x5c, 0xa4, 0x08, 0x07, 0xc4, 0xb3, 0x6e, 0x56, 0xad, 0x4a,
+	0x5f, 0xa1, 0x63, 0xc1, 0x15, 0x56, 0x45, 0x4a, 0x63, 0xe1, 0x1a, 0xb4, 0xb2, 0xd4, 0x6c, 0xab,
+	0xea, 0x1a, 0x94, 0x9a, 0xcc, 0xe4, 0x36, 0x2d, 0x86, 0xe8, 0xa7, 0xd0, 0x64, 0x98, 0x73, 0x12,
+	0x0f, 0x98, 0xb5, 0x29, 0xe7, 0xa1, 0x62, 0x5e, 0x5f, 0x73, 0x0e, 0xe7, 0x9c, 0x1c, 0x85, 0x2e,
+	0xe1, 0x6e, 0xdd, 0xc1, 0x4f, 0x5e, 0xd8, 0x2d, 0x29, 0xea, 0xc3, 0x59, 0x37, 0xa0, 0x7a, 0x77,
+	0x77, 0xa3, 0xd9, 0x10, 0x14, 0xc3, 0x4e, 0xdd, 0xc2, 0x1e, 0xe7, 0x94, 0x9c, 0x65, 0x1c, 0x33,
+	0x6b, 0x5b, 0xae, 0xfa, 0xc1, 0xac, 0x55, 0xf7, 0x72, 0xf4, 0xe1, 0x9c, 0x73, 0x2b, 0x9a, 0xc1,
+	0x17, 0xef, 0x6d, 0xdd, 0x7a, 0xe7, 0x18, 0x07, 0x67, 0x9e, 0x7f, 0x61, 0xdd, 0xaa, 0xbe, 0xb7,
+	0xd3, 0xab, 0x3d, 0xd7, 0x58, 0xf1, 0xde, 0x46, 0x57, 0x72, 0x85, 0x81, 0x32, 0xcc, 0xdd, 0x73,
+	0x42, 0xa3, 0x4b, 0x8f, 0x62, 0xf9, 0x48, 0x5c, 0x26, 0x34, 0xb0, 0x6e, 0x57, 0x0d, 0xb4, 0x8f,
+	0xf9, 0x73, 0x8d, 0x3a, 0xd5, 0x20, 0x61, 0xa0, 0x6c, 0x9a, 0x2c, 0x0c, 0x74, 0x84, 0x29, 0x39,
+	0x1f, 0xd7, 0xc8, 0xdd, 0xa9, 0x1a, 0xe8, 0x1b, 0x89, 0xac, 0x11, 0xbd, 0x31, 0xaa, 0xe5, 0xa0,
+	0x6f, 0xe1, 0xa6, 0xd8, 0xb2, 0x97, 0xf1, 0xc4, 0xf5, 0x82, 0x88, 0xc4, 0x85, 0xf0, 0xdd, 0xaa,
+	0x2d, 0xf4, 0x31, 0xdf, 0xcb, 0x78, 0xb2, 0x27, 0x60, 0x25, 0xd1, 0x6b, 0xac, 0x86, 0x8e, 0x7e,
+	0x0d, 0x88, 0xf9, 0x43, 0x1c, 0x64, 0x21, 0x76, 0x13, 0xe6, 0x66, 0xa9, 0xb0, 0x22, 0xeb, 0x4e,
+	0xf5, 0xb1, 0xea, 0x6b, 0xcc, 0x49, 0xff, 0xb5, 0x44, 0x88, 0xc7, 0xca, 0xcc, 0x3b, 0x61, 0x8a,
+	0x26, 0x37, 0x39, 0x25, 0xcb, 0x65, 0xbe, 0x17, 0x5b, 0x77, 0xa7, 0x36, 0x59, 0x11, 0xd8, 0xf7,
+	0x3d, 0xe9, 0x51, 0xab, 0x42, 0x05, 0x1d, 0x9d, 0xc2, 0x9a, 0xe7, 0x73, 0x32, 0xc2, 0x6e, 0xcc,
+	0x5c, 0xfc, 0x3d, 0xc7, 0x31, 0x93, 0x6e, 0xc0, 0xae, 0xba, 0xfe, 0x3d, 0x89, 0x7a, 0xd9, 0x7f,
+	0x96, 0x63, 0x84, 0xeb, 0x57, 0x73, 0x5f, 0xb2, 0x82, 0x2a, 0x24, 0xd2, 0x84, 0x8b, 0xed, 0x89,
+	0xd0, 0x68, 0xe4, 0x65, 0x21, 0x77, 0x2f, 0xf0, 0xd8, 0xba, 0x57, 0x95, 0xe8, 0x48, 0xd4, 0x73,
+	0x12, 0xe2, 0x37, 0x02, 0xf4, 0x0d, 0x1e, 0x0b, 0x89, 0x34, 0xa7, 0x8e, 0x34, 0x55, 0x98, 0x8b,
+	0x71, 0x2a, 0x38, 0xe6, 0x98, 0xa6, 0x94, 0xb0, 0x49, 0x77, 0xfa, 0x5e, 0xd5, 0x5c, 0xb4, 0x97,
+	0x79, 0x96, 0xc3, 0x27, 0x3d, 0xab, 0x09, 0x3f, 0x6b, 0xf9, 0xe2, 0x6d, 0x17, 0x37, 0xe2, 0x2c,
+	0x49, 0x38, 0xe3, 0xd4, 0x4b, 0x5d, 0x9e, 0x5c, 0xe0, 0xd8, 0x7a, 0xbf, 0xea, 0xb3, 0xfb, 0x98,
+	0x3f, 0x35, 0x98, 0x57, 0x02, 0x22, 0x7c, 0x36, 0xab, 0x12, 0x85, 0xcf, 0x16, 0xe2, 0x28, 0xf6,
+	0x93, 0x11, 0xa6, 0x63, 0x15, 0x70, 0x7d, 0x50, 0xf5, 0xd9, 0x7d, 0xcc, 0x1d, 0x8d, 0xd0, 0x51,
+	0x57, 0x97, 0x4d, 0x92, 0x84, 0x66, 0xb5, 0x1d, 0x4c, 0xca, 0xba, 0x5f, 0xd5, 0xac, 0xb2, 0x81,
+	0x8a, 0x38, 0x34, 0x9a, 0xa2, 0x3e, 0x6d, 0xc1, 0xa2, 0x8e, 0x8b, 0xec, 0x8f, 0x60, 0x79, 0x32,
+	0xf2, 0x47, 0x16, 0x2c, 0xa6, 0x2a, 0x6d, 0x91, 0xa9, 0x44, 0xc7, 0x31, 0x43, 0xfb, 0x11, 0x2c,
+	0x4d, 0x44, 0xf8, 0x68, 0x07, 0x80, 0x04, 0x38, 0xe6, 0xe4, 0x9c, 0x60, 0xaa, 0x13, 0x8f, 0x12,
+	0xc5, 0x3e, 0x81, 0xad, 0xab, 0x43, 0x78, 0xf4, 0x17, 0xb0, 0x56, 0x9b, 0x06, 0xa8, 0x55, 0x57,
+	0xd3, 0xe9, 0x29, 0xf6, 0x23, 0xd8, 0xbc, 0x32, 0x54, 0x47, 0x08, 0xae, 0x97, 0x92, 0x2b, 0xf9,
+	0xdb, 0x1e, 0x82, 0x75, 0x55, 0xd4, 0x8d, 0xee, 0x40, 0xbb, 0xd8, 0x2b, 0xb3, 0x1a, 0x77, 0xe6,
+	0x45, 0xde, 0x54, 0x22, 0xa1, 0x8f, 0x60, 0xa5, 0xe4, 0x40, 0x99, 0x9b, 0xc4, 0xe1, 0x58, 0x66,
+	0x4e, 0x4d, 0xa7, 0x5b, 0x78, 0x43, 0x76, 0x12, 0x87, 0x63, 0xfb, 0x13, 0x58, 0x99, 0x8a, 0xc1,
+	0x85, 0x2e, 0x7f, 0x9f, 0x61, 0x4a, 0xb0, 0x11, 0x6f, 0x86, 0xf6, 0x63, 0x58, 0x9a, 0x88, 0x97,
+	0x45, 0x1a, 0xa7, 0x23, 0x4b, 0x75, 0xed, 0x94, 0x16, 0xda, 0x8a, 0x26, 0x6f, 0x94, 0xfd, 0x1d,
+	0x40, 0x11, 0x9f, 0xa3, 0x1e, 0xcc, 0xa7, 0x24, 0xd6, 0x5f, 0x2b, 0x7e, 0x8a, 0xd5, 0x22, 0xcc,
+	0x98, 0x37, 0x50, 0xe9, 0x5d, 0xcb, 0x31, 0x43, 0x21, 0x3c, 0x1d, 0x26, 0x31, 0x76, 0xe3, 0x2c,
+	0x3a, 0xc3, 0x54, 0x66, 0x6e, 0x2d, 0xa7, 0x2d, 0x69, 0x2f, 0x25, 0xc9, 0xfe, 0xbb, 0x06, 0xb4,
+	0x4b, 0x11, 0x78, 0x8d, 0xf8, 0x8f, 0x01, 0xa5, 0x14, 0x33, 0x4c, 0x47, 0xd8, 0x95, 0x01, 0x44,
+	0x1a, 0x7a, 0xb1, 0x56, 0x47, 0xcf, 0x70, 0x0e, 0x3c, 0xee, 0x9d, 0x86, 0x5e, 0x8c, 0xbe, 0x00,
+	0x2b, 0x20, 0xcc, 0x0b, 0xc3, 0xe4, 0x52, 0x9c, 0xec, 0xf7, 0x24, 0x22, 0x7c, 0xec, 0x32, 0xcc,
+	0xb3, 0x54, 0x2e, 0xdf, 0x74, 0x36, 0x0c, 0xff, 0xd4, 0xb0, 0xfb, 0x82, 0x6b, 0xff, 0x6b, 0x03,
+	0x7a, 0xd5, 0x50, 0x1e, 0x7d, 0x08, 0xbd, 0x00, 0x33, 0x4e, 0x62, 0xf5, 0x86, 0xc5, 0x5e, 0x64,
+	0x32, 0xdd, 0x6e, 0x89, 0xfe, 0xd2, 0x8b, 0x30, 0x7a, 0x0c, 0xeb, 0x65, 0xa8, 0xc9, 0x9e, 0x02,
+	0xad, 0x94, 0xd5, 0x12, 0x53, 0x9f, 0x58, 0x80, 0xb6, 0xa1, 0x25, 0xbc, 0xaa, 0xcb, 0x49, 0x84,
+	0xb5, 0x76, 0x9a, 0x82, 0xf0, 0x8a, 0x44, 0x18, 0x6d, 0x41, 0x33, 0x7f, 0x1b, 0xae, 0x2b, 0x9e,
+	0x19, 0xdb, 0x7b, 0xd0, 0x29, 0x27, 0x0c, 0xfa, 0x52, 0x8b, 0xfb, 0xe8, 0x4e, 0xa4, 0x19, 0x0d,
+	0xf9, 0xc9, 0xab, 0x9a, 0x57, 0x9e, 0x62, 0x3f, 0x82, 0x95, 0xa9, 0x74, 0x41, 0xac, 0x29, 0x52,
+	0x82, 0xd2, 0x77, 0xe6, 0x63, 0xfb, 0x44, 0xdc, 0x83, 0x3c, 0x15, 0x98, 0x81, 0x44, 0xef, 0xc3,
+	0xf2, 0x79, 0x42, 0x7d, 0x91, 0x73, 0x85, 0x58, 0xba, 0x4c, 0x75, 0x5c, 0x4b, 0x92, 0x7a, 0xa0,
+	0x89, 0x36, 0x81, 0xe5, 0xc9, 0x5c, 0xa1, 0x7c, 0x95, 0x1a, 0xb3, 0xaf, 0xd2, 0xb5, 0xa9, 0xab,
+	0x24, 0x76, 0x74, 0x9e, 0x24, 0x3c, 0x4e, 0x78, 0xae, 0x4b, 0x33, 0xb6, 0xff, 0x7d, 0x1e, 0xd0,
+	0x74, 0x3a, 0x81, 0x3e, 0x80, 0x2e, 0xe1, 0x59, 0x8c, 0x99, 0xcb, 0x78, 0x42, 0xe5, 0x69, 0x89,
+	0x75, 0xe7, 0x9d, 0x25, 0x45, 0xee, 0x0b, 0xea, 0x51, 0x50, 0xf1, 0x38, 0xd7, 0xaa, 0x1e, 0x07,
+	0x7d, 0x05, 0x8b, 0x49, 0xaa, 0x34, 0x3e, 0x5f, 0x4d, 0xf2, 0xa7, 0x97, 0x3d, 0x51, 0x50, 0xc7,
+	0xcc, 0x11, 0x1f, 0x17, 0x79, 0x31, 0x39, 0x17, 0x89, 0x66, 0x46, 0x43, 0x7d, 0xda, 0x6d, 0x43,
+	0x7b, 0x4d, 0x43, 0x71, 0x11, 0x95, 0xe9, 0x47, 0x38, 0xe6, 0xee, 0x79, 0xe8, 0x0d, 0x98, 0xac,
+	0x27, 0xcc, 0x1b, 0x97, 0x20, 0xe8, 0xcf, 0x05, 0x19, 0x9d, 0xc0, 0xd2, 0x64, 0x50, 0xb9, 0x50,
+	0x0d, 0x2a, 0xa7, 0xb7, 0x34, 0x11, 0x31, 0x3a, 0x93, 0xf3, 0xd1, 0x73, 0x80, 0x52, 0xb0, 0xb8,
+	0x78, 0xc5, 0xeb, 0x57, 0x1b, 0x0c, 0x3a, 0xa5, 0x99, 0xe8, 0x73, 0xb8, 0xe9, 0x0f, 0xbd, 0x78,
+	0x80, 0xdd, 0xd2, 0xa7, 0x30, 0xf1, 0x00, 0xcb, 0x8a, 0x40, 0xcb, 0x59, 0x57, 0xec, 0xe3, 0x9c,
+	0xdb, 0x17, 0x4c, 0xfb, 0x00, 0x36, 0xaf, 0x54, 0x22, 0xba, 0x0f, 0xdd, 0x34, 0xa3, 0xfe, 0x50,
+	0xa4, 0xf8, 0x11, 0xe6, 0xc3, 0xc4, 0x1c, 0xe1, 0xb2, 0x21, 0x1f, 0x4b, 0xaa, 0x7d, 0x17, 0x76,
+	0xdf, 0xf2, 0xdd, 0xf6, 0x0e, 0xdc, 0x9a, 0xf5, 0x31, 0xf6, 0x9f, 0x1a, 0x39, 0xa0, 0xfe, 0x2d,
+	0x7f, 0x08, 0x4d, 0x73, 0x68, 0x72, 0x17, 0x13, 0x59, 0xc1, 0xb1, 0xe6, 0x38, 0x39, 0x66, 0xea,
+	0xe0, 0xaf, 0x4d, 0x1f, 0xfc, 0x2f, 0x61, 0xab, 0x0c, 0x71, 0x53, 0x12, 0xcb, 0x67, 0xcb, 0xc7,
+	0x94, 0x8b, 0xdb, 0x36, 0xff, 0xa0, 0xe3, 0xdc, 0x2c, 0x4d, 0x38, 0x55, 0xfc, 0x7d, 0xc1, 0x46,
+	0x47, 0x70, 0xd7, 0xe0, 0x29, 0x1e, 0x25, 0x26, 0xe5, 0x18, 0x62, 0xff, 0xc2, 0x15, 0x4f, 0x31,
+	0xa1, 0x58, 0xf9, 0x96, 0xa6, 0xb3, 0xa3, 0x81, 0x4e, 0x8e, 0xdb, 0x17, 0x30, 0x47, 0xa3, 0xec,
+	0x23, 0x68, 0x9a, 0x0f, 0x40, 0x5f, 0xc1, 0x72, 0xbe, 0x27, 0xc2, 0x71, 0xa4, 0x9e, 0x99, 0x89,
+	0xc4, 0xcb, 0x60, 0x8f, 0x38, 0x8e, 0x9c, 0xa5, 0xa8, 0x34, 0x62, 0xf6, 0x00, 0x3a, 0x65, 0x36,
+	0xba, 0x0f, 0x0b, 0x1e, 0x63, 0x98, 0x1b, 0x31, 0xdd, 0x52, 0x1c, 0x28, 0xe8, 0x8e, 0x66, 0x4b,
+	0xf5, 0x62, 0xee, 0x89, 0x57, 0x40, 0x57, 0x12, 0xcb, 0xea, 0xd5, 0x1c, 0x27, 0xc7, 0xd8, 0xff,
+	0xd8, 0x80, 0x1b, 0x52, 0x82, 0x78, 0xa4, 0x2f, 0x48, 0x9c, 0x3f, 0xd2, 0xe2, 0x37, 0xda, 0x84,
+	0x66, 0x14, 0x3c, 0x71, 0x19, 0xf9, 0x41, 0x3d, 0x5c, 0xf3, 0xce, 0x62, 0x14, 0x3c, 0xe9, 0x93,
+	0x1f, 0xe4, 0x9b, 0x1e, 0x05, 0x4f, 0x94, 0x7a, 0x5b, 0x8e, 0xfc, 0x2d, 0x5e, 0xa6, 0xc2, 0x36,
+	0xc5, 0x4f, 0xb4, 0x0b, 0x6d, 0x36, 0xf4, 0x1e, 0x3f, 0xf9, 0x5c, 0xc9, 0x50, 0xe6, 0x08, 0x8a,
+	0x24, 0xc5, 0x58, 0xb0, 0xa8, 0x46, 0xcc, 0x5a, 0x50, 0xef, 0xb0, 0x1e, 0xda, 0xff, 0xdb, 0x80,
+	0xa6, 0xd9, 0x30, 0xfa, 0x09, 0xac, 0x9c, 0x65, 0x71, 0x10, 0x0a, 0xff, 0x53, 0x09, 0x6b, 0x7a,
+	0x8a, 0x71, 0x54, 0xb8, 0x9a, 0xf7, 0x61, 0x59, 0x83, 0x47, 0x98, 0x32, 0xe3, 0x5b, 0x5b, 0xce,
+	0x92, 0xa2, 0xbe, 0x51, 0x44, 0xf4, 0x11, 0xdc, 0x50, 0x27, 0x33, 0x2f, 0x55, 0x5a, 0x2a, 0xee,
+	0x3c, 0x55, 0x12, 0xe3, 0xf3, 0xc4, 0x51, 0x90, 0x5c, 0x39, 0xd7, 0x4b, 0xca, 0xd9, 0x82, 0x26,
+	0xcb, 0xce, 0x38, 0xe1, 0xba, 0x6e, 0x29, 0x1e, 0x26, 0x3d, 0x46, 0x6b, 0x70, 0x43, 0x31, 0x16,
+	0x24, 0x43, 0x0d, 0x90, 0x0d, 0x4b, 0x42, 0x0d, 0x2e, 0x89, 0xdd, 0xb3, 0xb1, 0x71, 0x14, 0xf3,
+	0x4e, 0x5b, 0x10, 0x8f, 0xe2, 0xa7, 0x82, 0x64, 0xff, 0x0e, 0xa0, 0x58, 0xfe, 0xff, 0xe3, 0xbb,
+	0xed, 0xbf, 0x81, 0xd5, 0x9a, 0x62, 0xcc, 0xdb, 0x42, 0x46, 0xe1, 0x45, 0xaa, 0x45, 0x1e, 0x25,
+	0x7e, 0x99, 0x4e, 0x08, 0xb2, 0x7f, 0x01, 0x1b, 0xf5, 0x45, 0x99, 0xb7, 0xc7, 0x75, 0xf6, 0xa7,
+	0xb0, 0x32, 0x55, 0x78, 0x79, 0x6b, 0x30, 0xfb, 0x2d, 0x74, 0x2b, 0x05, 0x16, 0x74, 0x1b, 0x40,
+	0x17, 0x63, 0xdc, 0x3c, 0xee, 0x6c, 0x69, 0xca, 0x51, 0x20, 0x34, 0x25, 0xeb, 0x2f, 0xca, 0xd8,
+	0x0b, 0xb7, 0xb2, 0x54, 0x50, 0x5f, 0xd3, 0xd0, 0xfe, 0x02, 0xd6, 0xea, 0x8a, 0x2d, 0xef, 0xf0,
+	0x1d, 0xff, 0x72, 0x1d, 0xd6, 0xea, 0x0a, 0x69, 0xe8, 0x05, 0xdc, 0x63, 0x17, 0x24, 0x75, 0x53,
+	0x4a, 0x22, 0x8f, 0xea, 0xb0, 0xcb, 0xcd, 0x4b, 0x73, 0x14, 0xab, 0xf7, 0x48, 0x05, 0x25, 0xbb,
+	0x02, 0x7a, 0xaa, 0x90, 0x32, 0x02, 0x33, 0x22, 0x35, 0x0c, 0xbd, 0x81, 0x0f, 0x45, 0x26, 0x53,
+	0x2f, 0xcc, 0x63, 0x2e, 0xc5, 0x83, 0x2c, 0xf4, 0xa8, 0xaa, 0x61, 0xaa, 0x00, 0xe3, 0x1e, 0xc3,
+	0xbc, 0x46, 0xe4, 0x1e, 0x73, 0x14, 0x56, 0x46, 0x2e, 0x7d, 0xb8, 0x1f, 0x24, 0xb1, 0xce, 0xc1,
+	0xd3, 0x24, 0xcd, 0x42, 0x91, 0x3e, 0x9a, 0x65, 0xcc, 0x02, 0x24, 0x3e, 0x4f, 0xb4, 0x6b, 0xb4,
+	0x05, 0x5c, 0x64, 0xdc, 0xa7, 0x1a, 0xac, 0x97, 0xd0, 0xd2, 0xe5, 0x5d, 0xfe, 0x39, 0x6c, 0xca,
+	0x28, 0xba, 0x56, 0xcc, 0x0d, 0x15, 0x78, 0x0a, 0x40, 0xfd, 0xd4, 0xea, 0xac, 0xf3, 0x2c, 0x0c,
+	0x55, 0xb0, 0xa9, 0x4c, 0x6c, 0x23, 0x9d, 0x98, 0xf6, 0x3c, 0x0b, 0x43, 0x19, 0x73, 0xd6, 0x4c,
+	0x95, 0x05, 0x62, 0x39, 0x75, 0xb1, 0x6e, 0xaa, 0xd0, 0x80, 0x9c, 0xfa, 0x1d, 0x6c, 0x4a, 0x05,
+	0x68, 0xb5, 0xca, 0x52, 0x84, 0x96, 0x61, 0x9c, 0x46, 0xa9, 0xce, 0x21, 0xbe, 0x5e, 0x69, 0x54,
+	0x00, 0xb5, 0x2c, 0xe6, 0x6c, 0x78, 0xb5, 0x74, 0xfb, 0xef, 0x1b, 0xb0, 0x51, 0x3f, 0x45, 0x5c,
+	0x5e, 0x36, 0x4c, 0x28, 0x2f, 0xc7, 0xd2, 0x2d, 0x49, 0x91, 0xdb, 0xda, 0x86, 0x56, 0xf1, 0xf1,
+	0xd7, 0x74, 0x14, 0x67, 0x3e, 0xf7, 0x1e, 0x2c, 0x99, 0x08, 0xd8, 0x1d, 0x7a, 0x6c, 0x28, 0x83,
+	0xad, 0x8e, 0xd3, 0x31, 0xc4, 0x43, 0x8f, 0x0d, 0xd1, 0x06, 0x2c, 0x0c, 0x49, 0x10, 0xe0, 0x58,
+	0x9f, 0x9e, 0x1e, 0xd9, 0x14, 0x3a, 0xe5, 0x6a, 0xe0, 0x3b, 0xc7, 0x7e, 0xdb, 0xd0, 0x92, 0xe5,
+	0xc1, 0x92, 0x25, 0x35, 0x25, 0x41, 0xbc, 0xce, 0xb7, 0x01, 0x14, 0x53, 0xf6, 0xc0, 0x54, 0xd4,
+	0xa9, 0xe0, 0xaf, 0xc6, 0x29, 0xb6, 0xc7, 0xd0, 0x2e, 0xd5, 0x10, 0x2b, 0xe8, 0x46, 0x05, 0x5d,
+	0xb7, 0xa3, 0x6b, 0x75, 0x3b, 0x12, 0x6a, 0x10, 0xee, 0x8e, 0x71, 0x11, 0x40, 0x91, 0x40, 0xaf,
+	0xdb, 0x29, 0x88, 0x47, 0x81, 0xfd, 0x73, 0x68, 0x9a, 0x32, 0x24, 0xfa, 0xa4, 0x54, 0xac, 0x54,
+	0x4f, 0xec, 0xca, 0x54, 0xb1, 0xb2, 0xa8, 0x54, 0xda, 0x7f, 0x6a, 0xc2, 0xa2, 0xa6, 0x8a, 0xb7,
+	0x41, 0x3c, 0x12, 0xe6, 0xe1, 0x14, 0xbf, 0xd1, 0x97, 0x79, 0x37, 0x27, 0x3f, 0xa5, 0x9a, 0xa6,
+	0x90, 0x38, 0x31, 0x23, 0x5b, 0xb7, 0x74, 0xe4, 0x21, 0x3e, 0x81, 0xe6, 0x30, 0x61, 0x5c, 0x4e,
+	0x9d, 0xaf, 0xd6, 0x25, 0x0e, 0x35, 0x27, 0xdf, 0x94, 0x81, 0xa2, 0xa7, 0xb0, 0x34, 0x4a, 0xc4,
+	0x9a, 0x34, 0xf1, 0x22, 0x12, 0x0f, 0x74, 0xdb, 0xae, 0x54, 0xe3, 0x7b, 0x23, 0xd8, 0x8e, 0xe2,
+	0x9a, 0xf9, 0x9d, 0x51, 0x89, 0x88, 0xbe, 0x81, 0x9e, 0xd0, 0x51, 0x12, 0x7b, 0xa1, 0x3b, 0x4c,
+	0x38, 0x4b, 0x13, 0xae, 0x9b, 0x72, 0xa5, 0xab, 0x7e, 0xaa, 0x11, 0x87, 0x0a, 0x60, 0x24, 0x75,
+	0xd3, 0x49, 0x3a, 0xfa, 0x02, 0x5a, 0x97, 0x5e, 0x18, 0xa6, 0x5e, 0x8a, 0xa9, 0x0e, 0xb1, 0x4b,
+	0x75, 0xb6, 0x6f, 0x0d, 0xcb, 0xcc, 0x2f, 0xc0, 0xe8, 0xaf, 0xa0, 0x23, 0x13, 0x59, 0xf3, 0x25,
+	0x8b, 0xd5, 0x8a, 0x8a, 0xc8, 0x66, 0x2b, 0x1f, 0xd2, 0x0e, 0x0a, 0x9a, 0x58, 0xfa, 0x2c, 0xcc,
+	0x30, 0x4f, 0x12, 0x3e, 0xd4, 0xcd, 0xb4, 0xd2, 0xd2, 0x4f, 0x0d, 0x2b, 0x5f, 0x3a, 0x07, 0xa3,
+	0xdf, 0xc2, 0xc6, 0x15, 0x35, 0xe0, 0x56, 0x35, 0xac, 0xaf, 0x0d, 0x81, 0x8d, 0xc8, 0x75, 0xaf,
+	0xb6, 0xf4, 0xfb, 0x25, 0xb4, 0xa3, 0x20, 0x72, 0x4d, 0x2e, 0x04, 0xd5, 0x9b, 0x71, 0x7c, 0x70,
+	0xac, 0xe3, 0xf6, 0xfc, 0x66, 0x44, 0x41, 0x64, 0x42, 0x79, 0x0c, 0x5b, 0xa6, 0xcd, 0x27, 0x4b,
+	0x4d, 0xee, 0x80, 0x7a, 0x3e, 0x76, 0x53, 0x4c, 0x49, 0x12, 0xe8, 0xbe, 0xdb, 0x83, 0xd2, 0x41,
+	0x69, 0xec, 0x8b, 0xc4, 0xbf, 0xf8, 0x95, 0x40, 0x9e, 0x4a, 0xa0, 0x91, 0x7c, 0x33, 0xad, 0xe7,
+	0xa3, 0xef, 0x60, 0x23, 0xf2, 0xbe, 0x27, 0x51, 0x16, 0x89, 0x5c, 0x59, 0x3e, 0x6c, 0xd2, 0x6b,
+	0x9a, 0xa6, 0xdc, 0xfb, 0xe5, 0x28, 0x56, 0xe2, 0x1c, 0x0d, 0x13, 0xce, 0x33, 0xdf, 0xf9, 0x5a,
+	0x54, 0xc3, 0x44, 0xbf, 0x81, 0xf5, 0x80, 0x78, 0x83, 0x38, 0x61, 0x9c, 0xf8, 0x2e, 0xcb, 0xce,
+	0x22, 0xc2, 0x64, 0xb4, 0xb2, 0x54, 0x95, 0x7d, 0x90, 0xc3, 0xfa, 0x39, 0x2a, 0x97, 0x1d, 0xd4,
+	0x30, 0x85, 0x09, 0x78, 0x69, 0xea, 0x7a, 0xb1, 0x17, 0x8e, 0x39, 0xf1, 0x99, 0x6e, 0xdc, 0x4d,
+	0xf6, 0xa1, 0xf6, 0x0c, 0x37, 0x37, 0x01, 0xaf, 0x44, 0x44, 0xe7, 0xb0, 0x79, 0x75, 0xf7, 0xa1,
+	0x5b, 0x4d, 0x14, 0xaf, 0xca, 0x94, 0x8c, 0x6c, 0xcb, 0xbb, 0xaa, 0xe9, 0xf0, 0x39, 0xb4, 0x38,
+	0x89, 0xb0, 0xfb, 0x43, 0x12, 0x63, 0xdd, 0xd9, 0x2b, 0x99, 0xf9, 0x2b, 0x12, 0xe1, 0xdf, 0x24,
+	0x71, 0x61, 0xe6, 0x5c, 0x13, 0xec, 0x47, 0xb0, 0x5a, 0x63, 0xc7, 0x22, 0x92, 0x56, 0x4d, 0xc4,
+	0x40, 0x47, 0x0f, 0x66, 0x68, 0x3f, 0x86, 0x8d, 0x7a, 0x8b, 0x9d, 0x31, 0xe7, 0x2f, 0xa1, 0x57,
+	0xb5, 0x4f, 0x11, 0xd4, 0x92, 0xc8, 0x14, 0x1e, 0x3a, 0x8e, 0x1a, 0x08, 0xea, 0xe5, 0x10, 0x53,
+	0x93, 0x20, 0xa8, 0x81, 0xfd, 0x10, 0xd0, 0xb4, 0x89, 0xce, 0x58, 0xef, 0x63, 0xe8, 0x55, 0x8d,
+	0x72, 0x06, 0xfa, 0x1f, 0x1a, 0x70, 0x6b, 0x96, 0xf1, 0xbd, 0x35, 0x98, 0x7d, 0x73, 0xa5, 0x91,
+	0x2b, 0x57, 0xbd, 0xfb, 0x16, 0x23, 0xbf, 0xc2, 0xba, 0xed, 0xbf, 0x6d, 0xc0, 0xee, 0x5b, 0x6e,
+	0xc4, 0x5b, 0xf7, 0xf6, 0x14, 0x6e, 0x4f, 0xdc, 0x39, 0x37, 0x50, 0xf5, 0x28, 0x11, 0xc2, 0xe4,
+	0x79, 0x5d, 0xc7, 0xd9, 0x9e, 0x00, 0x1d, 0xe4, 0x18, 0xa1, 0x76, 0xfb, 0x31, 0xac, 0xd7, 0x77,
+	0x9e, 0x36, 0xa1, 0x39, 0x4a, 0xe3, 0xf2, 0x7f, 0x5d, 0x16, 0x47, 0x69, 0xfc, 0x3a, 0x23, 0x81,
+	0xfd, 0x99, 0xa9, 0x93, 0x96, 0x9e, 0x25, 0x91, 0xc0, 0x95, 0x1f, 0x32, 0xbd, 0xdb, 0xe2, 0xad,
+	0xb2, 0x1f, 0x42, 0xb7, 0x72, 0x55, 0x45, 0x38, 0x50, 0x5c, 0x6c, 0x5d, 0xf8, 0xca, 0x6f, 0xef,
+	0x27, 0xd0, 0xad, 0xbc, 0x60, 0x22, 0x91, 0xca, 0x9f, 0x3b, 0x0d, 0x37, 0x63, 0xfb, 0xd7, 0xb0,
+	0x32, 0xe5, 0x11, 0xd1, 0x93, 0x49, 0x1f, 0xda, 0xa8, 0x36, 0xe7, 0x8b, 0x19, 0x65, 0xe7, 0x69,
+	0x07, 0x00, 0x05, 0x07, 0xbd, 0x81, 0x07, 0xb2, 0x59, 0xa2, 0x9b, 0xcb, 0xc2, 0x99, 0xca, 0x9a,
+	0x27, 0x0e, 0xdc, 0xcb, 0x21, 0x09, 0xb1, 0xcb, 0xb2, 0x14, 0xd3, 0x11, 0x61, 0xf9, 0xf5, 0x7b,
+	0xaf, 0xc0, 0x0b, 0x87, 0xb9, 0xa7, 0xd0, 0xdf, 0x0a, 0x70, 0x3f, 0xc7, 0xda, 0xbf, 0x85, 0x9d,
+	0xd9, 0x6e, 0x17, 0xfd, 0x72, 0xa6, 0x13, 0x57, 0x11, 0xd6, 0x55, 0xae, 0xd9, 0xee, 0xc3, 0xf6,
+	0x0c, 0x97, 0x8b, 0x3e, 0xbb, 0xd2, 0x73, 0x2b, 0xb9, 0xb5, 0x2e, 0xd9, 0xfe, 0x19, 0x6c, 0xcf,
+	0xf0, 0xb5, 0x33, 0x0c, 0xf1, 0x91, 0xcc, 0x25, 0xab, 0x0e, 0x75, 0xc6, 0x84, 0x7d, 0xd8, 0x7d,
+	0x4b, 0xbf, 0xf6, 0x1d, 0xb2, 0xab, 0xaf, 0xe1, 0xd6, 0xac, 0xf6, 0xeb, 0x3b, 0x48, 0x18, 0xc0,
+	0xd6, 0xd5, 0x2d, 0xd5, 0x77, 0xe8, 0x3f, 0xdc, 0x87, 0xae, 0xfe, 0x7b, 0x48, 0xde, 0xb3, 0x55,
+	0xe9, 0xd5, 0xb2, 0x22, 0x1b, 0x51, 0xf6, 0x7f, 0x36, 0x60, 0xb5, 0xa6, 0xb3, 0x8a, 0x3e, 0x84,
+	0x9e, 0x9f, 0x51, 0x2a, 0x8e, 0x27, 0xaf, 0x60, 0xeb, 0xaa, 0xb9, 0xa6, 0xe7, 0xd0, 0xbb, 0xd0,
+	0x89, 0xf1, 0x65, 0x01, 0xd3, 0x15, 0xb0, 0x18, 0x5f, 0xe6, 0x90, 0x5d, 0x68, 0xab, 0x7a, 0x7e,
+	0x42, 0x93, 0x88, 0xe9, 0x2a, 0x3e, 0x48, 0xd2, 0x89, 0xa0, 0xa0, 0x67, 0xb0, 0x6b, 0xfe, 0xa6,
+	0xa3, 0x8b, 0x5a, 0xcc, 0x8d, 0x31, 0xbf, 0x4c, 0xe8, 0x85, 0xcb, 0x31, 0x1f, 0x62, 0xaa, 0x53,
+	0x81, 0x5b, 0x1a, 0xa6, 0x8b, 0x5a, 0xec, 0xa5, 0x02, 0xbd, 0x92, 0x18, 0xfb, 0x33, 0xd8, 0xa8,
+	0x6f, 0xe7, 0x4e, 0x54, 0xe2, 0x1b, 0x95, 0x4a, 0xfc, 0x1f, 0x1a, 0xd0, 0xad, 0x74, 0xd3, 0xfe,
+	0x4c, 0xbf, 0xff, 0xa7, 0x80, 0xa6, 0x5b, 0x79, 0x33, 0xbf, 0xfd, 0x04, 0xd6, 0xea, 0x7a, 0xd4,
+	0x22, 0x69, 0x18, 0x94, 0x5a, 0x62, 0xe2, 0xf7, 0x74, 0xee, 0x76, 0x6d, 0x3a, 0x77, 0x13, 0x0f,
+	0x73, 0xb5, 0x9f, 0x8c, 0x3e, 0x82, 0x45, 0xd5, 0x80, 0x36, 0xb9, 0x4b, 0xaf, 0xf4, 0x7f, 0x27,
+	0xc9, 0x70, 0x0c, 0xc0, 0x1e, 0xc3, 0x82, 0x9e, 0xb5, 0x0b, 0xed, 0x94, 0x26, 0x41, 0xe6, 0xab,
+	0x76, 0xb0, 0x76, 0xed, 0x9a, 0xf4, 0x0d, 0x1e, 0xcb, 0xba, 0xb1, 0x06, 0x4c, 0x16, 0x94, 0x96,
+	0x35, 0xd9, 0x54, 0xd2, 0x64, 0x39, 0x45, 0xff, 0x5b, 0x49, 0x3e, 0x43, 0x3a, 0xdd, 0x32, 0x7f,
+	0x3d, 0xd9, 0x93, 0x44, 0xfb, 0x63, 0x58, 0xab, 0x6b, 0x85, 0x8b, 0x08, 0x42, 0x76, 0x3d, 0xb4,
+	0xaf, 0x50, 0x03, 0xfb, 0x05, 0xa0, 0xe9, 0x16, 0x37, 0xfa, 0x1c, 0x6e, 0x9e, 0x93, 0x90, 0x63,
+	0x5a, 0xf4, 0xc6, 0xdd, 0x34, 0x21, 0x31, 0x37, 0x66, 0xba, 0xae, 0xd8, 0xf9, 0x94, 0x53, 0xc9,
+	0xb4, 0xff, 0xd8, 0x00, 0x34, 0xdd, 0xdf, 0x16, 0xcf, 0xe1, 0x05, 0x1e, 0x97, 0x93, 0xcd, 0xc5,
+	0x0b, 0x3c, 0x96, 0xa9, 0xe6, 0x01, 0xf4, 0x8a, 0x7e, 0xb9, 0x6a, 0xf6, 0xe9, 0xe0, 0xa0, 0x14,
+	0xa5, 0xe5, 0xc2, 0x54, 0x9f, 0xc8, 0xe9, 0xe6, 0x53, 0x14, 0x41, 0xe8, 0x50, 0x5c, 0x5e, 0x1f,
+	0x53, 0xe1, 0x3a, 0x7c, 0x4f, 0x37, 0x5e, 0x3a, 0xce, 0x72, 0x8c, 0x2f, 0xf7, 0x0b, 0x2a, 0xfa,
+	0x1a, 0x6e, 0x51, 0x9c, 0x86, 0x63, 0x17, 0xc7, 0x3e, 0x1d, 0xeb, 0x22, 0x5b, 0x69, 0xd6, 0x75,
+	0x39, 0x6b, 0x4b, 0x62, 0x9e, 0xe5, 0x90, 0x92, 0x04, 0xfb, 0x9f, 0x1b, 0xd0, 0xad, 0xec, 0x67,
+	0xd6, 0xd5, 0x54, 0x5d, 0x43, 0xf1, 0x9e, 0x61, 0x71, 0xfe, 0x2e, 0xfe, 0x3e, 0x4d, 0x28, 0xd7,
+	0x77, 0xae, 0xa7, 0x39, 0xdf, 0xe0, 0xf1, 0x33, 0x49, 0x47, 0x5f, 0xc1, 0xf6, 0x34, 0xba, 0x30,
+	0x4a, 0x75, 0xe0, 0x56, 0x75, 0x9a, 0xb9, 0xef, 0xf6, 0x97, 0xb0, 0x32, 0xd5, 0x9d, 0x17, 0xca,
+	0xa9, 0xf6, 0xf4, 0xd5, 0x26, 0x97, 0xcf, 0x26, 0x80, 0xf6, 0x7f, 0x37, 0x60, 0xc9, 0xc1, 0x2c,
+	0x0b, 0xb9, 0xf9, 0xdf, 0x2e, 0x82, 0xeb, 0x59, 0x50, 0x6a, 0x29, 0x07, 0x64, 0xfa, 0xbf, 0xbc,
+	0xd7, 0xa6, 0xff, 0xcb, 0xfb, 0x04, 0xda, 0x98, 0xd2, 0x84, 0xba, 0xfe, 0xd0, 0x23, 0xf1, 0x74,
+	0xe5, 0xf7, 0x99, 0x60, 0xee, 0x0b, 0x9e, 0x03, 0x38, 0xff, 0x6d, 0xf7, 0x61, 0xa1, 0xcf, 0x3d,
+	0x9e, 0x31, 0xd4, 0x83, 0xce, 0x9e, 0x7f, 0x11, 0x27, 0x97, 0x21, 0x0e, 0x06, 0x38, 0xe8, 0xcd,
+	0xa1, 0x16, 0xdc, 0x90, 0xb3, 0x7a, 0x0d, 0xb4, 0x01, 0x48, 0xff, 0xf7, 0xf7, 0xb9, 0x6c, 0x34,
+	0x2b, 0xfa, 0x35, 0xd4, 0x84, 0xeb, 0x47, 0x41, 0x88, 0x7b, 0xf3, 0x08, 0x60, 0xe1, 0x65, 0xc2,
+	0x5f, 0x26, 0x97, 0xbd, 0xeb, 0xf6, 0xbf, 0x35, 0x00, 0x8a, 0xf5, 0xd0, 0xa7, 0xb0, 0x1e, 0x26,
+	0xbe, 0x17, 0x92, 0x1f, 0x70, 0xe0, 0x06, 0x98, 0xf9, 0x94, 0xa4, 0x79, 0x2d, 0xb0, 0xe5, 0xac,
+	0xe5, 0xcc, 0x83, 0x82, 0x27, 0x9e, 0xfb, 0x8c, 0xb9, 0x38, 0x1e, 0x84, 0x84, 0x0d, 0x27, 0x66,
+	0xa9, 0x8f, 0x5f, 0xcb, 0xd8, 0x33, 0xc5, 0x2c, 0xcf, 0xba, 0x0b, 0x1d, 0xa5, 0x85, 0x20, 0x89,
+	0x94, 0x1a, 0xa4, 0xa2, 0x24, 0xed, 0x40, 0x92, 0xd0, 0x6d, 0x00, 0xad, 0xa8, 0x24, 0x50, 0x97,
+	0xef, 0x86, 0xd3, 0x52, 0x1a, 0x49, 0x02, 0xfc, 0xb4, 0xf7, 0x1f, 0x3f, 0xee, 0x34, 0xfe, 0xeb,
+	0xc7, 0x9d, 0xc6, 0x1f, 0x7f, 0xdc, 0x69, 0xfc, 0xd3, 0xff, 0xec, 0xcc, 0x9d, 0x2d, 0x48, 0x05,
+	0x7e, 0xfa, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb1, 0x8b, 0x23, 0xaa, 0x78, 0x2d, 0x00, 0x00,
 }
 
 func (m *CommandPayload) Marshal() (dAtA []byte, err error) {
@@ -5680,6 +5840,52 @@ func (m *Command_SetBootstrapToken) MarshalToSizedBuffer(dAtA []byte) (int, erro
 	}
 	return len(dAtA) - i, nil
 }
+func (m *Command_SetRecoveryLock) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Command_SetRecoveryLock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.SetRecoveryLock != nil {
+		{
+			size, err := m.SetRecoveryLock.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintMdm(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2
+		i--
+		dAtA[i] = 0xb2
+	}
+	return len(dAtA) - i, nil
+}
+func (m *Command_VerifyRecoveryLock) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Command_VerifyRecoveryLock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.VerifyRecoveryLock != nil {
+		{
+			size, err := m.VerifyRecoveryLock.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintMdm(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x2
+		i--
+		dAtA[i] = 0xba
+	}
+	return len(dAtA) - i, nil
+}
 func (m *InstallProfile) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -8238,6 +8444,16 @@ func (m *SetFirmwarePassword) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
+	if m.RequestRequiresNetworkTether {
+		i--
+		if m.RequestRequiresNetworkTether {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x20
+	}
 	if m.AllowOroms {
 		i--
 		if m.AllowOroms {
@@ -8299,6 +8515,101 @@ func (m *VerifyFirmwarePassword) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	return len(dAtA) - i, nil
 }
 
+func (m *SetRecoveryLock) 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 *SetRecoveryLock) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SetRecoveryLock) 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.RequestRequiresNetworkTether {
+		i--
+		if m.RequestRequiresNetworkTether {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.AllowOroms {
+		i--
+		if m.AllowOroms {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x18
+	}
+	if len(m.NewPassword) > 0 {
+		i -= len(m.NewPassword)
+		copy(dAtA[i:], m.NewPassword)
+		i = encodeVarintMdm(dAtA, i, uint64(len(m.NewPassword)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.CurrentPassword) > 0 {
+		i -= len(m.CurrentPassword)
+		copy(dAtA[i:], m.CurrentPassword)
+		i = encodeVarintMdm(dAtA, i, uint64(len(m.CurrentPassword)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *VerifyRecoveryLock) 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 *VerifyRecoveryLock) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *VerifyRecoveryLock) 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.Password) > 0 {
+		i -= len(m.Password)
+		copy(dAtA[i:], m.Password)
+		i = encodeVarintMdm(dAtA, i, uint64(len(m.Password)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *SetAutoAdminPassword) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -9234,23 +9545,47 @@ func (m *Command_SetBootstrapToken) Size() (n int) {
 	}
 	return n
 }
-func (m *InstallProfile) Size() (n int) {
+func (m *Command_SetRecoveryLock) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = len(m.Payload)
-	if l > 0 {
-		n += 1 + l + sovMdm(uint64(l))
-	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
+	if m.SetRecoveryLock != nil {
+		l = m.SetRecoveryLock.Size()
+		n += 2 + l + sovMdm(uint64(l))
 	}
 	return n
 }
-
-func (m *RemoveProfile) Size() (n int) {
+func (m *Command_VerifyRecoveryLock) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.VerifyRecoveryLock != nil {
+		l = m.VerifyRecoveryLock.Size()
+		n += 2 + l + sovMdm(uint64(l))
+	}
+	return n
+}
+func (m *InstallProfile) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Payload)
+	if l > 0 {
+		n += 1 + l + sovMdm(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *RemoveProfile) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -10395,6 +10730,9 @@ func (m *SetFirmwarePassword) Size() (n int) {
 	if m.AllowOroms {
 		n += 2
 	}
+	if m.RequestRequiresNetworkTether {
+		n += 2
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@@ -10417,6 +10755,48 @@ func (m *VerifyFirmwarePassword) Size() (n int) {
 	return n
 }
 
+func (m *SetRecoveryLock) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.CurrentPassword)
+	if l > 0 {
+		n += 1 + l + sovMdm(uint64(l))
+	}
+	l = len(m.NewPassword)
+	if l > 0 {
+		n += 1 + l + sovMdm(uint64(l))
+	}
+	if m.AllowOroms {
+		n += 2
+	}
+	if m.RequestRequiresNetworkTether {
+		n += 2
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *VerifyRecoveryLock) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovMdm(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *SetAutoAdminPassword) Size() (n int) {
 	if m == nil {
 		return 0
@@ -12079,6 +12459,76 @@ func (m *Command) Unmarshal(dAtA []byte) error {
 			}
 			m.Request = &Command_SetBootstrapToken{v}
 			iNdEx = postIndex
+		case 38:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SetRecoveryLock", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthMdm
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthMdm
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &SetRecoveryLock{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Request = &Command_SetRecoveryLock{v}
+			iNdEx = postIndex
+		case 39:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VerifyRecoveryLock", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthMdm
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthMdm
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &VerifyRecoveryLock{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Request = &Command_VerifyRecoveryLock{v}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipMdm(dAtA[iNdEx:])
@@ -18630,6 +19080,26 @@ func (m *SetFirmwarePassword) Unmarshal(dAtA []byte) error {
 				}
 			}
 			m.AllowOroms = bool(v != 0)
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RequestRequiresNetworkTether", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.RequestRequiresNetworkTether = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipMdm(dAtA[iNdEx:])
@@ -18735,6 +19205,244 @@ func (m *VerifyFirmwarePassword) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *SetRecoveryLock) 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 ErrIntOverflowMdm
+			}
+			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: SetRecoveryLock: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SetRecoveryLock: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CurrentPassword", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				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 ErrInvalidLengthMdm
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMdm
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.CurrentPassword = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NewPassword", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				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 ErrInvalidLengthMdm
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMdm
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.NewPassword = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AllowOroms", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.AllowOroms = bool(v != 0)
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RequestRequiresNetworkTether", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.RequestRequiresNetworkTether = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipMdm(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthMdm
+			}
+			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 *VerifyRecoveryLock) 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 ErrIntOverflowMdm
+			}
+			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: VerifyRecoveryLock: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: VerifyRecoveryLock: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMdm
+				}
+				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 ErrInvalidLengthMdm
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMdm
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Password = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipMdm(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthMdm
+			}
+			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 *SetAutoAdminPassword) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/mdm/mdm/internal/mdmproto/mdm.proto b/mdm/mdm/internal/mdmproto/mdm.proto
index 8db397b..d31d9f0 100644
--- a/mdm/mdm/internal/mdmproto/mdm.proto
+++ b/mdm/mdm/internal/mdmproto/mdm.proto
@@ -69,6 +69,8 @@ message Command {
     RotateFileVaultKey rotate_filevault_key = 35;
     InstallEnterpriseApplication install_enterprise_application = 36;
     SetBootstrapToken set_bootstrap_token = 37;
+    SetRecoveryLock set_recovery_lock = 38;
+    VerifyRecoveryLock verify_recovery_lock = 39;
   }
 }
 
@@ -362,12 +364,24 @@ message SetFirmwarePassword {
   string current_password = 1;
   string new_password = 2;
   bool allow_oroms = 3;
+  bool request_requires_network_tether = 4;
 }
 
 message VerifyFirmwarePassword {
   string password = 1;
 }
 
+message SetRecoveryLock {
+  string current_password = 1;
+  string new_password = 2;
+  bool allow_oroms = 3;
+  bool request_requires_network_tether = 4;
+}
+
+message VerifyRecoveryLock {
+  string password = 1;
+}
+
 message SetAutoAdminPassword {
   string guid = 1;
   bytes password_hash = 2;
diff --git a/mdm/mdm/marshal_json.go b/mdm/mdm/marshal_json.go
index b1d0870..70f2ce6 100644
--- a/mdm/mdm/marshal_json.go
+++ b/mdm/mdm/marshal_json.go
@@ -304,6 +304,24 @@ func (c *Command) MarshalJSON() ([]byte, error) {
 			VerifyFirmwarePassword: c.VerifyFirmwarePassword,
 		}
 		return json.Marshal(&x)
+	case "SetRecoveryLock":
+		var x = struct {
+			RequestType string `json:"request_type"`
+			*SetRecoveryLock
+		}{
+			RequestType:     c.RequestType,
+			SetRecoveryLock: c.SetRecoveryLock,
+		}
+		return json.Marshal(&x)
+	case "VerifyRecoveryLock":
+		var x = struct {
+			RequestType string `json:"request_type"`
+			*VerifyRecoveryLock
+		}{
+			RequestType:        c.RequestType,
+			VerifyRecoveryLock: c.VerifyRecoveryLock,
+		}
+		return json.Marshal(&x)
 	case "SetAutoAdminPassword":
 		var x = struct {
 			RequestType string `json:"request_type"`
diff --git a/mdm/mdm/marshal_plist.go b/mdm/mdm/marshal_plist.go
index 95cf014..68280ea 100644
--- a/mdm/mdm/marshal_plist.go
+++ b/mdm/mdm/marshal_plist.go
@@ -287,6 +287,22 @@ func (c *Command) MarshalPlist() (interface{}, error) {
 			RequestType:            c.RequestType,
 			VerifyFirmwarePassword: c.VerifyFirmwarePassword,
 		}, nil
+	case "SetRecoveryLock":
+		return &struct {
+			RequestType string
+			*SetRecoveryLock
+		}{
+			RequestType:     c.RequestType,
+			SetRecoveryLock: c.SetRecoveryLock,
+		}, nil
+	case "VerifyRecoveryLock":
+		return &struct {
+			RequestType string
+			*VerifyRecoveryLock
+		}{
+			RequestType:        c.RequestType,
+			VerifyRecoveryLock: c.VerifyRecoveryLock,
+		}, nil
 	case "SetAutoAdminPassword":
 		return &struct {
 			RequestType string
diff --git a/mdm/mdm/marshal_proto.go b/mdm/mdm/marshal_proto.go
index bb133cc..5730cc6 100644
--- a/mdm/mdm/marshal_proto.go
+++ b/mdm/mdm/marshal_proto.go
@@ -326,9 +326,19 @@ func commandToProto(cmd *Command) (*mdmproto.Command, error) {
 	case "SetFirmwarePassword":
 		cmdproto.Request = &mdmproto.Command_SetFirmwarePassword{
 			SetFirmwarePassword: &mdmproto.SetFirmwarePassword{
-				CurrentPassword: cmd.SetFirmwarePassword.CurrentPassword,
-				NewPassword:     cmd.SetFirmwarePassword.NewPassword,
-				AllowOroms:      cmd.SetFirmwarePassword.AllowOroms,
+				CurrentPassword:              cmd.SetFirmwarePassword.CurrentPassword,
+				NewPassword:                  cmd.SetFirmwarePassword.NewPassword,
+				AllowOroms:                   cmd.SetFirmwarePassword.AllowOroms,
+				RequestRequiresNetworkTether: cmd.SetFirmwarePassword.RequestRequiresNetworkTether,
+			},
+		}
+	case "SetRecoveryLock":
+		cmdproto.Request = &mdmproto.Command_SetRecoveryLock{
+			SetRecoveryLock: &mdmproto.SetRecoveryLock{
+				CurrentPassword:              cmd.SetRecoveryLock.CurrentPassword,
+				NewPassword:                  cmd.SetRecoveryLock.NewPassword,
+				AllowOroms:                   cmd.SetRecoveryLock.AllowOroms,
+				RequestRequiresNetworkTether: cmd.SetRecoveryLock.RequestRequiresNetworkTether,
 			},
 		}
 	case "SetBootstrapToken":
@@ -343,6 +353,12 @@ func commandToProto(cmd *Command) (*mdmproto.Command, error) {
 				Password: cmd.VerifyFirmwarePassword.Password,
 			},
 		}
+	case "VerifyRecoveryLock":
+		cmdproto.Request = &mdmproto.Command_VerifyRecoveryLock{
+			VerifyRecoveryLock: &mdmproto.VerifyRecoveryLock{
+				Password: cmd.VerifyRecoveryLock.Password,
+			},
+		}
 	case "SetAutoAdminPassword":
 		cmdproto.Request = &mdmproto.Command_SetAutoAdminPassword{
 			SetAutoAdminPassword: &mdmproto.SetAutoAdminPassword{
diff --git a/mdm/mdm/unmarshal_json.go b/mdm/mdm/unmarshal_json.go
index 6622d55..01fa1db 100644
--- a/mdm/mdm/unmarshal_json.go
+++ b/mdm/mdm/unmarshal_json.go
@@ -264,6 +264,20 @@ func (c *Command) UnmarshalJSON(data []byte) error {
 		}
 		c.VerifyFirmwarePassword = &payload
 		return nil
+	case "SetRecoveryLock":
+		var payload SetRecoveryLock
+		if err := json.Unmarshal(data, &payload); err != nil {
+			return errors.Wrapf(err, "mdm: unmarshal %s command json", c.RequestType)
+		}
+		c.SetRecoveryLock = &payload
+		return nil
+	case "VerifyRecoveryLock":
+		var payload VerifyRecoveryLock
+		if err := json.Unmarshal(data, &payload); err != nil {
+			return errors.Wrapf(err, "mdm: unmarshal %s command json", c.RequestType)
+		}
+		c.VerifyRecoveryLock = &payload
+		return nil
 	case "SetAutoAdminPassword":
 		var payload SetAutoAdminPassword
 		if err := json.Unmarshal(data, &payload); err != nil {
diff --git a/mdm/mdm/unmarshal_plist.go b/mdm/mdm/unmarshal_plist.go
index 706c7d3..64988f3 100644
--- a/mdm/mdm/unmarshal_plist.go
+++ b/mdm/mdm/unmarshal_plist.go
@@ -248,6 +248,20 @@ func (c *Command) UnmarshalPlist(unmarshal func(i interface{}) error) error {
 		}
 		c.VerifyFirmwarePassword = &payload
 		return nil
+	case "SetRecoveryLock":
+		var payload SetRecoveryLock
+		if err := unmarshal(&payload); err != nil {
+			return errors.Wrapf(err, "mdm: unmarshal %s command plist", requestType.RequestType)
+		}
+		c.SetRecoveryLock = &payload
+		return nil
+	case "VerifyRecoveryLock":
+		var payload VerifyRecoveryLock
+		if err := unmarshal(&payload); err != nil {
+			return errors.Wrapf(err, "mdm: unmarshal %s command plist", requestType.RequestType)
+		}
+		c.VerifyRecoveryLock = &payload
+		return nil
 	case "SetAutoAdminPassword":
 		var payload SetAutoAdminPassword
 		if err := unmarshal(&payload); err != nil {
diff --git a/mdm/mdm/unmarshal_proto.go b/mdm/mdm/unmarshal_proto.go
index 71a9bd5..6004393 100644
--- a/mdm/mdm/unmarshal_proto.go
+++ b/mdm/mdm/unmarshal_proto.go
@@ -296,20 +296,34 @@ func protoToCommand(pb *mdmproto.Command) *Command {
 	case "SetFirmwarePassword":
 		pbc := pb.GetSetFirmwarePassword()
 		cmd.SetFirmwarePassword = &SetFirmwarePassword{
-			CurrentPassword: pbc.GetCurrentPassword(),
-			NewPassword:     pbc.GetNewPassword(),
-			AllowOroms:      pbc.GetAllowOroms(),
+			CurrentPassword:              pbc.GetCurrentPassword(),
+			NewPassword:                  pbc.GetNewPassword(),
+			AllowOroms:                   pbc.GetAllowOroms(),
+			RequestRequiresNetworkTether: pbc.GetRequestRequiresNetworkTether(),
 		}
 	case "SetBootstrapToken":
 		pbc := pb.GetSetBootstrapToken()
 		cmd.SetBootstrapToken = &SetBootstrapToken{
 			BootstrapToken: pbc.GetBootstrapToken(),
 		}
+	case "SetRecoveryLock":
+		pbc := pb.GetSetRecoveryLock()
+		cmd.SetRecoveryLock = &SetRecoveryLock{
+			CurrentPassword:              pbc.GetCurrentPassword(),
+			NewPassword:                  pbc.GetNewPassword(),
+			AllowOroms:                   pbc.GetAllowOroms(),
+			RequestRequiresNetworkTether: pbc.GetRequestRequiresNetworkTether(),
+		}
 	case "VerifyFirmwarePassword":
 		pbc := pb.GetVerifyFirmwarePassword()
 		cmd.VerifyFirmwarePassword = &VerifyFirmwarePassword{
 			Password: pbc.GetPassword(),
 		}
+	case "VerifyRecoveryLock":
+		pbc := pb.GetVerifyRecoveryLock()
+		cmd.VerifyRecoveryLock = &VerifyRecoveryLock{
+			Password: pbc.GetPassword(),
+		}
 	case "SetAutoAdminPassword":
 		pbc := pb.GetSetAutoAdminPassword()
 		cmd.SetAutoAdminPassword = &SetAutoAdminPassword{
diff --git a/tools/api/commands/set_firmware_password b/tools/api/commands/set_firmware_password
new file mode 100644
index 0000000..d776867
--- /dev/null
+++ b/tools/api/commands/set_firmware_password
@@ -0,0 +1,18 @@
+#!/bin/bash
+source $MICROMDM_ENV_PATH
+endpoint="v1/commands"
+jq -n \
+  --arg request_type "SetFirmwarePassword" \
+  --arg udid "$1" \
+  --arg current_password $2 \
+  --arg new_password $3 \
+  --arg request_requires_network_tether $4 \
+  --arg allow_oroms $5 \
+  '.udid = $udid 
+  |.current_password = $current_password  
+  |.new_password = $new_password  
+  |.request_requires_network_tether = $request_requires_network_tether 
+  |.allow_oroms = $allow_oroms 
+  |.request_type = $request_type
+  '|\
+  curl $CURL_OPTS -K <(cat <<< "-u micromdm:$API_TOKEN") "$SERVER_URL/$endpoint" -d@-
diff --git a/tools/api/commands/set_recovery_lock b/tools/api/commands/set_recovery_lock
new file mode 100644
index 0000000..19de463
--- /dev/null
+++ b/tools/api/commands/set_recovery_lock
@@ -0,0 +1,18 @@
+#!/bin/bash
+source $MICROMDM_ENV_PATH
+endpoint="v1/commands"
+jq -n \
+  --arg request_type "SetRecoveryLock" \
+  --arg udid "$1" \
+  --arg current_password $2 \
+  --arg new_password $3 \
+  --arg request_requires_network_tether $4 \
+  --arg allow_oroms $5 \
+  '.udid = $udid 
+  |.current_password = $current_password  
+  |.new_password = $new_password  
+  |.request_requires_network_tether = $request_requires_network_tether 
+  |.allow_oroms = $allow_oroms 
+  |.request_type = $request_type
+  '|\
+  curl $CURL_OPTS -K <(cat <<< "-u micromdm:$API_TOKEN") "$SERVER_URL/$endpoint" -d@-
diff --git a/tools/api/commands/verify_firmware_password b/tools/api/commands/verify_firmware_password
new file mode 100644
index 0000000..e55840c
--- /dev/null
+++ b/tools/api/commands/verify_firmware_password
@@ -0,0 +1,15 @@
+#!/bin/bash
+source $MICROMDM_ENV_PATH
+endpoint="v1/commands"
+jq -n \
+  --arg request_type "VerifyFirmwarePassword" \
+  --arg udid "$1" \
+  --arg password $2 \
+  --arg request_requires_network_tether $3 \
+  --arg allow_oroms $4 \
+  '.udid = $udid 
+  |.password = $current_password  
+  |.request_requires_network_tether = $request_requires_network_tether 
+  |.request_type = $request_type
+  '|\
+  curl $CURL_OPTS -K <(cat <<< "-u micromdm:$API_TOKEN") "$SERVER_URL/$endpoint" -d@-
diff --git a/tools/api/commands/verify_recovery_lock b/tools/api/commands/verify_recovery_lock
new file mode 100644
index 0000000..dfb33a5
--- /dev/null
+++ b/tools/api/commands/verify_recovery_lock
@@ -0,0 +1,15 @@
+#!/bin/bash
+source $MICROMDM_ENV_PATH
+endpoint="v1/commands"
+jq -n \
+  --arg request_type "VerifyRecoveryLock" \
+  --arg udid "$1" \
+  --arg password $2 \
+  --arg request_requires_network_tether $3 \
+  --arg allow_oroms $4 \
+  '.udid = $udid 
+  |.password = $current_password  
+  |.request_requires_network_tether = $request_requires_network_tether 
+  |.request_type = $request_type
+  '|\
+  curl $CURL_OPTS -K <(cat <<< "-u micromdm:$API_TOKEN") "$SERVER_URL/$endpoint" -d@-


Test patch:
diff --git a/mdm/mdm/mdm_command_test.go b/mdm/mdm/mdm_command_test.go
index 2875e63..c4cdf93 100644
--- a/mdm/mdm/mdm_command_test.go
+++ b/mdm/mdm/mdm_command_test.go
@@ -86,6 +86,30 @@ func TestMarshalCommand(t *testing.T) {
 				},
 			},
 		},
+		{
+			Command: Command{
+				RequestType: "SetRecoveryLock",
+				SetRecoveryLock: &SetRecoveryLock{
+					CurrentPassword: "test",
+				},
+			},
+		},
+		{
+			Command: Command{
+				RequestType: "SetRecoveryLock",
+				SetRecoveryLock: &SetRecoveryLock{
+					NewPassword: "test",
+				},
+			},
+		},
+		{
+			Command: Command{
+				RequestType: "SetRecoveryLock",
+				VerifyRecoveryLock: &VerifyRecoveryLock{
+					Password: "test",
+				},
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.Command.RequestType+"_json", func(t *testing.T) {
@@ -356,6 +380,71 @@ func TestEndToEnd(t *testing.T) {
 				}
 			},
 		},
+		{
+			name: "SetRecoveryLock_NoNewPassword",
+			requestBytes: []byte(
+				`{"request_type":"SetRecoveryLock","current_password":"test"}`,
+			),
+			testFn: func(t *testing.T, parts endToEndParts) {
+				needToSee := [][]byte{
+					[]byte(`CurrentPassword`),
+					[]byte(`test`),
+					[]byte(`NewPassword`),
+				}
+				for _, b := range needToSee {
+					if !bytes.Contains(parts.plistData, b) {
+						t.Error(fmt.Sprintf("marshaled plist does not contain required bytes: '%s'", string(b)))
+					}
+				}
+			},
+		},
+		{
+			name: "SetRecoveryLock_NewPassword",
+			requestBytes: []byte(
+				`{"request_type":"SetRecoveryLock","new_password":"test"}`,
+			),
+			testFn: func(t *testing.T, parts endToEndParts) {
+				needToSee := [][]byte{
+					[]byte(`NewPassword`),
+					[]byte(`test`),
+				}
+				for _, b := range needToSee {
+					if !bytes.Contains(parts.plistData, b) {
+						t.Error(fmt.Sprintf("marshaled plist does not contain required bytes: '%s'", string(b)))
+					}
+				}
+			},
+		},
+
+		{
+			name: "VerifyRecoveryLock",
+			requestBytes: []byte(
+				`{"request_type":"VerifyRecoveryLock","password":"test"}`,
+			),
+			testFn: func(t *testing.T, parts endToEndParts) {
+				needToSee := [][]byte{
+					[]byte(`Password`),
+					[]byte(`test`),
+				}
+				for _, b := range needToSee {
+					if !bytes.Contains(parts.plistData, b) {
+						t.Error(fmt.Sprintf("marshaled plist does not contain required bytes: '%s'", string(b)))
+					}
+				}
+			},
+		},
+
+		{
+			name: "Set Command UUID",
+			requestBytes: []byte(
+				`{"request_type":"VerifyRecoveryLock","password":"test","command_uuid":"this-uuid-should-be-used"}`,
+			),
+			testFn: func(t *testing.T, parts endToEndParts) {
+				if parts.payload.CommandUUID != "this-uuid-should-be-used" {
+					t.Error("CommandUUID should be set to request payload's command_uuid")
+				}
+			},
+		},
 	}
 
 	for _, tt := range tests {