highperfocused/P4wnP1_aloa
1
0
Fork 0
mirror of https://github.com/RoganDawes/P4wnP1_aloa.git synced 2025-03-17 13:21:50 +01:00
Code Issues Packages Projects Releases Wiki Activity

WebCLient,proto,server: Reworked TriggerAction GroupSequence to multi group (support for logical AND+OR)

Browse Source
This commit is contained in:
MaMe82 2018-10-26 16:58:27 +02:00
parent d50c854419
commit 2f08ed92f5
7 changed files with 733 additions and 512 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
proto/gopherjs/grpc.pb.gopherjs.go
View File

@ -24,7 +24,7 @@
TriggerSSHLogin
TriggerDHCPLeaseGranted
TriggerGroupReceive
TriggerGroupReceiveSequence
TriggerGroupReceiveMulti
TriggerGPIOIn
ActionStartBashScript
ActionStartHIDScript
@ -103,6 +103,32 @@ func (x BluetoothNetworkServiceType) String() string {
return BluetoothNetworkServiceType_name[int(x)]
}
type GroupReceiveMultiType int
const (
GroupReceiveMultiType_SEQUENCE GroupReceiveMultiType = 0
GroupReceiveMultiType_AND GroupReceiveMultiType = 1
GroupReceiveMultiType_OR GroupReceiveMultiType = 2
GroupReceiveMultiType_EXACT_SEQUENCE GroupReceiveMultiType = 3
)
var GroupReceiveMultiType_name = map[int]string{
0: "SEQUENCE",
1: "AND",
2: "OR",
3: "EXACT_SEQUENCE",
}
var GroupReceiveMultiType_value = map[string]int{
"SEQUENCE": 0,
"AND": 1,
"OR": 2,
"EXACT_SEQUENCE": 3,
}
func (x GroupReceiveMultiType) String() string {
return GroupReceiveMultiType_name[int(x)]
}
type GPIOInPullUpDown int
const (
@ -1373,7 +1399,7 @@ type TriggerAction struct {
// *TriggerAction_SshLogin
// *TriggerAction_DhcpLeaseGranted
// *TriggerAction_GroupReceive
// *TriggerAction_GroupReceiveSequence
// *TriggerAction_GroupReceiveMulti
// *TriggerAction_GpioIn
Trigger isTriggerAction_Trigger
// Types that are valid to be assigned to Action:
@ -1432,9 +1458,9 @@ type TriggerAction_GroupReceive struct {
GroupReceive *TriggerGroupReceive
}
// TriggerAction_GroupReceiveSequence is assignable to Trigger
type TriggerAction_GroupReceiveSequence struct {
GroupReceiveSequence *TriggerGroupReceiveSequence
// TriggerAction_GroupReceiveMulti is assignable to Trigger
type TriggerAction_GroupReceiveMulti struct {
GroupReceiveMulti *TriggerGroupReceiveMulti
}
// TriggerAction_GpioIn is assignable to Trigger
@ -1480,7 +1506,7 @@ func (*TriggerAction_WifiConnectedAsSta) isTriggerAction_Trigger() {}
func (*TriggerAction_SshLogin) isTriggerAction_Trigger() {}
func (*TriggerAction_DhcpLeaseGranted) isTriggerAction_Trigger() {}
func (*TriggerAction_GroupReceive) isTriggerAction_Trigger() {}
func (*TriggerAction_GroupReceiveSequence) isTriggerAction_Trigger() {}
func (*TriggerAction_GroupReceiveMulti) isTriggerAction_Trigger() {}
func (*TriggerAction_GpioIn) isTriggerAction_Trigger() {}
func (*TriggerAction_BashScript) isTriggerAction_Action() {}
func (*TriggerAction_HidScript) isTriggerAction_Action() {}
@ -1601,10 +1627,10 @@ func (m *TriggerAction) GetGroupReceive() (x *TriggerGroupReceive) {
return x
}
// GetGroupReceiveSequence gets the GroupReceiveSequence of the TriggerAction.
func (m *TriggerAction) GetGroupReceiveSequence() (x *TriggerGroupReceiveSequence) {
if v, ok := m.GetTrigger().(*TriggerAction_GroupReceiveSequence); ok {
return v.GroupReceiveSequence
// GetGroupReceiveMulti gets the GroupReceiveMulti of the TriggerAction.
func (m *TriggerAction) GetGroupReceiveMulti() (x *TriggerGroupReceiveMulti) {
if v, ok := m.GetTrigger().(*TriggerAction_GroupReceiveMulti); ok {
return v.GroupReceiveMulti
}
return x
}
@ -1720,10 +1746,10 @@ func (m *TriggerAction) MarshalToWriter(writer jspb.Writer) {
t.GroupReceive.MarshalToWriter(writer)
})
}
case *TriggerAction_GroupReceiveSequence:
if t.GroupReceiveSequence != nil {
case *TriggerAction_GroupReceiveMulti:
if t.GroupReceiveMulti != nil {
writer.WriteMessage(13, func() {
t.GroupReceiveSequence.MarshalToWriter(writer)
t.GroupReceiveMulti.MarshalToWriter(writer)
})
}
case *TriggerAction_GpioIn:
@ -1865,8 +1891,8 @@ func (m *TriggerAction) UnmarshalFromReader(reader jspb.Reader) *TriggerAction {
})
case 13:
reader.ReadMessage(func() {
m.Trigger = &TriggerAction_GroupReceiveSequence{
GroupReceiveSequence: new(TriggerGroupReceiveSequence).UnmarshalFromReader(reader),
m.Trigger = &TriggerAction_GroupReceiveMulti{
GroupReceiveMulti: new(TriggerGroupReceiveMulti).UnmarshalFromReader(reader),
}
})
case 14:
@ -2361,38 +2387,38 @@ func (m *TriggerGroupReceive) Unmarshal(rawBytes []byte) (*TriggerGroupReceive,
return m, nil
}
type TriggerGroupReceiveSequence struct {
GroupName string
IgnoreOutOfOrder bool
Values []int32
type TriggerGroupReceiveMulti struct {
GroupName string
Values []int32
Type GroupReceiveMultiType
}
// GetGroupName gets the GroupName of the TriggerGroupReceiveSequence.
func (m *TriggerGroupReceiveSequence) GetGroupName() (x string) {
// GetGroupName gets the GroupName of the TriggerGroupReceiveMulti.
func (m *TriggerGroupReceiveMulti) GetGroupName() (x string) {
if m == nil {
return x
}
return m.GroupName
}
// GetIgnoreOutOfOrder gets the IgnoreOutOfOrder of the TriggerGroupReceiveSequence.
func (m *TriggerGroupReceiveSequence) GetIgnoreOutOfOrder() (x bool) {
if m == nil {
return x
}
return m.IgnoreOutOfOrder
}
// GetValues gets the Values of the TriggerGroupReceiveSequence.
func (m *TriggerGroupReceiveSequence) GetValues() (x []int32) {
// GetValues gets the Values of the TriggerGroupReceiveMulti.
func (m *TriggerGroupReceiveMulti) GetValues() (x []int32) {
if m == nil {
return x
}
return m.Values
}
// MarshalToWriter marshals TriggerGroupReceiveSequence to the provided writer.
func (m *TriggerGroupReceiveSequence) MarshalToWriter(writer jspb.Writer) {
// GetType gets the Type of the TriggerGroupReceiveMulti.
func (m *TriggerGroupReceiveMulti) GetType() (x GroupReceiveMultiType) {
if m == nil {
return x
}
return m.Type
}
// MarshalToWriter marshals TriggerGroupReceiveMulti to the provided writer.
func (m *TriggerGroupReceiveMulti) MarshalToWriter(writer jspb.Writer) {
if m == nil {
return
}
@ -2401,38 +2427,38 @@ func (m *TriggerGroupReceiveSequence) MarshalToWriter(writer jspb.Writer) {
writer.WriteString(1, m.GroupName)
}
if m.IgnoreOutOfOrder {
writer.WriteBool(2, m.IgnoreOutOfOrder)
}
if len(m.Values) > 0 {
writer.WriteInt32Slice(3, m.Values)
}
if int(m.Type) != 0 {
writer.WriteEnum(4, int(m.Type))
}
return
}
// Marshal marshals TriggerGroupReceiveSequence to a slice of bytes.
func (m *TriggerGroupReceiveSequence) Marshal() []byte {
// Marshal marshals TriggerGroupReceiveMulti to a slice of bytes.
func (m *TriggerGroupReceiveMulti) Marshal() []byte {
writer := jspb.NewWriter()
m.MarshalToWriter(writer)
return writer.GetResult()
}
// UnmarshalFromReader unmarshals a TriggerGroupReceiveSequence from the provided reader.
func (m *TriggerGroupReceiveSequence) UnmarshalFromReader(reader jspb.Reader) *TriggerGroupReceiveSequence {
// UnmarshalFromReader unmarshals a TriggerGroupReceiveMulti from the provided reader.
func (m *TriggerGroupReceiveMulti) UnmarshalFromReader(reader jspb.Reader) *TriggerGroupReceiveMulti {
for reader.Next() {
if m == nil {
m = &TriggerGroupReceiveSequence{}
m = &TriggerGroupReceiveMulti{}
}
switch reader.GetFieldNumber() {
case 1:
m.GroupName = reader.ReadString()
case 2:
m.IgnoreOutOfOrder = reader.ReadBool()
case 3:
m.Values = reader.ReadInt32Slice()
case 4:
m.Type = GroupReceiveMultiType(reader.ReadEnum())
default:
reader.SkipField()
}
@ -2441,8 +2467,8 @@ func (m *TriggerGroupReceiveSequence) UnmarshalFromReader(reader jspb.Reader) *T
return m
}
// Unmarshal unmarshals a TriggerGroupReceiveSequence from a slice of bytes.
func (m *TriggerGroupReceiveSequence) Unmarshal(rawBytes []byte) (*TriggerGroupReceiveSequence, error) {
// Unmarshal unmarshals a TriggerGroupReceiveMulti from a slice of bytes.
func (m *TriggerGroupReceiveMulti) Unmarshal(rawBytes []byte) (*TriggerGroupReceiveMulti, error) {
reader := jspb.NewReader(rawBytes)
m = m.UnmarshalFromReader(reader)

711
proto/grpc.pb.go
View File

@ -24,7 +24,7 @@ It has these top-level messages:
TriggerSSHLogin
TriggerDHCPLeaseGranted
TriggerGroupReceive
TriggerGroupReceiveSequence
TriggerGroupReceiveMulti
TriggerGPIOIn
ActionStartBashScript
ActionStartHIDScript
@ -112,6 +112,33 @@ func (x BluetoothNetworkServiceType) String() string {
}
func (BluetoothNetworkServiceType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
type GroupReceiveMultiType int32
const (
GroupReceiveMultiType_SEQUENCE GroupReceiveMultiType = 0
GroupReceiveMultiType_AND GroupReceiveMultiType = 1
GroupReceiveMultiType_OR GroupReceiveMultiType = 2
GroupReceiveMultiType_EXACT_SEQUENCE GroupReceiveMultiType = 3
)
var GroupReceiveMultiType_name = map[int32]string{
0: "SEQUENCE",
1: "AND",
2: "OR",
3: "EXACT_SEQUENCE",
}
var GroupReceiveMultiType_value = map[string]int32{
"SEQUENCE": 0,
"AND": 1,
"OR": 2,
"EXACT_SEQUENCE": 3,
}
func (x GroupReceiveMultiType) String() string {
return proto.EnumName(GroupReceiveMultiType_name, int32(x))
}
func (GroupReceiveMultiType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
type GPIOInPullUpDown int32
const (
@ -134,7 +161,7 @@ var GPIOInPullUpDown_value = map[string]int32{
func (x GPIOInPullUpDown) String() string {
return proto.EnumName(GPIOInPullUpDown_name, int32(x))
}
func (GPIOInPullUpDown) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (GPIOInPullUpDown) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
type GPIOInEdge int32
@ -158,7 +185,7 @@ var GPIOInEdge_value = map[string]int32{
func (x GPIOInEdge) String() string {
return proto.EnumName(GPIOInEdge_name, int32(x))
}
func (GPIOInEdge) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (GPIOInEdge) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
type GPIONum int32
@ -233,7 +260,7 @@ var GPIONum_value = map[string]int32{
func (x GPIONum) String() string {
return proto.EnumName(GPIONum_name, int32(x))
}
func (GPIONum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (GPIONum) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
type GPIOOutValue int32
@ -257,7 +284,7 @@ var GPIOOutValue_value = map[string]int32{
func (x GPIOOutValue) String() string {
return proto.EnumName(GPIOOutValue_name, int32(x))
}
func (GPIOOutValue) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (GPIOOutValue) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
// WiFi2 (distinguish state and settings)
type WiFiWorkingMode int32
@ -285,7 +312,7 @@ var WiFiWorkingMode_value = map[string]int32{
func (x WiFiWorkingMode) String() string {
return proto.EnumName(WiFiWorkingMode_name, int32(x))
}
func (WiFiWorkingMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (WiFiWorkingMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
type WiFiStateMode int32
@ -309,7 +336,7 @@ var WiFiStateMode_value = map[string]int32{
func (x WiFiStateMode) String() string {
return proto.EnumName(WiFiStateMode_name, int32(x))
}
func (WiFiStateMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
func (WiFiStateMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
type WiFiAuthMode int32
@ -330,7 +357,7 @@ var WiFiAuthMode_value = map[string]int32{
func (x WiFiAuthMode) String() string {
return proto.EnumName(WiFiAuthMode_name, int32(x))
}
func (WiFiAuthMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (WiFiAuthMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
type AccessibleFolder int32
@ -354,7 +381,7 @@ var AccessibleFolder_value = map[string]int32{
func (x AccessibleFolder) String() string {
return proto.EnumName(AccessibleFolder_name, int32(x))
}
func (AccessibleFolder) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
func (AccessibleFolder) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
type ActionDeploySettingsTemplate_TemplateType int32
@ -812,7 +839,7 @@ type TriggerAction struct {
// *TriggerAction_SshLogin
// *TriggerAction_DhcpLeaseGranted
// *TriggerAction_GroupReceive
// *TriggerAction_GroupReceiveSequence
// *TriggerAction_GroupReceiveMulti
// *TriggerAction_GpioIn
Trigger isTriggerAction_Trigger `protobuf_oneof:"Trigger"`
// Types that are valid to be assigned to Action:
@ -861,8 +888,8 @@ type TriggerAction_DhcpLeaseGranted struct {
type TriggerAction_GroupReceive struct {
GroupReceive *TriggerGroupReceive `protobuf:"bytes,12,opt,name=groupReceive,oneof"`
}
type TriggerAction_GroupReceiveSequence struct {
GroupReceiveSequence *TriggerGroupReceiveSequence `protobuf:"bytes,13,opt,name=groupReceiveSequence,oneof"`
type TriggerAction_GroupReceiveMulti struct {
GroupReceiveMulti *TriggerGroupReceiveMulti `protobuf:"bytes,13,opt,name=groupReceiveMulti,oneof"`
}
type TriggerAction_GpioIn struct {
GpioIn *TriggerGPIOIn `protobuf:"bytes,14,opt,name=gpioIn,oneof"`
@ -894,7 +921,7 @@ func (*TriggerAction_WifiConnectedAsSta) isTriggerAction_Trigger() {}
func (*TriggerAction_SshLogin) isTriggerAction_Trigger() {}
func (*TriggerAction_DhcpLeaseGranted) isTriggerAction_Trigger() {}
func (*TriggerAction_GroupReceive) isTriggerAction_Trigger() {}
func (*TriggerAction_GroupReceiveSequence) isTriggerAction_Trigger() {}
func (*TriggerAction_GroupReceiveMulti) isTriggerAction_Trigger() {}
func (*TriggerAction_GpioIn) isTriggerAction_Trigger() {}
func (*TriggerAction_BashScript) isTriggerAction_Action() {}
func (*TriggerAction_HidScript) isTriggerAction_Action() {}
@ -1000,9 +1027,9 @@ func (m *TriggerAction) GetGroupReceive() *TriggerGroupReceive {
return nil
}
func (m *TriggerAction) GetGroupReceiveSequence() *TriggerGroupReceiveSequence {
if x, ok := m.GetTrigger().(*TriggerAction_GroupReceiveSequence); ok {
return x.GroupReceiveSequence
func (m *TriggerAction) GetGroupReceiveMulti() *TriggerGroupReceiveMulti {
if x, ok := m.GetTrigger().(*TriggerAction_GroupReceiveMulti); ok {
return x.GroupReceiveMulti
}
return nil
}
@ -1067,7 +1094,7 @@ func (*TriggerAction) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer)
(*TriggerAction_SshLogin)(nil),
(*TriggerAction_DhcpLeaseGranted)(nil),
(*TriggerAction_GroupReceive)(nil),
(*TriggerAction_GroupReceiveSequence)(nil),
(*TriggerAction_GroupReceiveMulti)(nil),
(*TriggerAction_GpioIn)(nil),
(*TriggerAction_BashScript)(nil),
(*TriggerAction_HidScript)(nil),
@ -1122,9 +1149,9 @@ func _TriggerAction_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
if err := b.EncodeMessage(x.GroupReceive); err != nil {
return err
}
case *TriggerAction_GroupReceiveSequence:
case *TriggerAction_GroupReceiveMulti:
b.EncodeVarint(13<<3 | proto.WireBytes)
if err := b.EncodeMessage(x.GroupReceiveSequence); err != nil {
if err := b.EncodeMessage(x.GroupReceiveMulti); err != nil {
return err
}
case *TriggerAction_GpioIn:
@ -1242,13 +1269,13 @@ func _TriggerAction_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.
err := b.DecodeMessage(msg)
m.Trigger = &TriggerAction_GroupReceive{msg}
return true, err
case 13: // Trigger.groupReceiveSequence
case 13: // Trigger.groupReceiveMulti
if wire != proto.WireBytes {
return true, proto.ErrInternalBadWireType
}
msg := new(TriggerGroupReceiveSequence)
msg := new(TriggerGroupReceiveMulti)
err := b.DecodeMessage(msg)
m.Trigger = &TriggerAction_GroupReceiveSequence{msg}
m.Trigger = &TriggerAction_GroupReceiveMulti{msg}
return true, err
case 14: // Trigger.gpioIn
if wire != proto.WireBytes {
@ -1355,8 +1382,8 @@ func _TriggerAction_OneofSizer(msg proto.Message) (n int) {
n += proto.SizeVarint(12<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
case *TriggerAction_GroupReceiveSequence:
s := proto.Size(x.GroupReceiveSequence)
case *TriggerAction_GroupReceiveMulti:
s := proto.Size(x.GroupReceiveMulti)
n += proto.SizeVarint(13<<3 | proto.WireBytes)
n += proto.SizeVarint(uint64(s))
n += s
@ -1496,38 +1523,38 @@ func (m *TriggerGroupReceive) GetValue() int32 {
return 0
}
type TriggerGroupReceiveSequence struct {
GroupName string `protobuf:"bytes,1,opt,name=groupName" json:"groupName,omitempty"`
IgnoreOutOfOrder bool `protobuf:"varint,2,opt,name=IgnoreOutOfOrder" json:"IgnoreOutOfOrder,omitempty"`
Values []int32 `protobuf:"varint,3,rep,packed,name=values" json:"values,omitempty"`
type TriggerGroupReceiveMulti struct {
GroupName string `protobuf:"bytes,1,opt,name=groupName" json:"groupName,omitempty"`
Values []int32 `protobuf:"varint,3,rep,packed,name=values" json:"values,omitempty"`
Type GroupReceiveMultiType `protobuf:"varint,4,opt,name=type,enum=P4wnP1_grpc.GroupReceiveMultiType" json:"type,omitempty"`
}
func (m *TriggerGroupReceiveSequence) Reset() { *m = TriggerGroupReceiveSequence{} }
func (m *TriggerGroupReceiveSequence) String() string { return proto.CompactTextString(m) }
func (*TriggerGroupReceiveSequence) ProtoMessage() {}
func (*TriggerGroupReceiveSequence) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
func (m *TriggerGroupReceiveMulti) Reset() { *m = TriggerGroupReceiveMulti{} }
func (m *TriggerGroupReceiveMulti) String() string { return proto.CompactTextString(m) }
func (*TriggerGroupReceiveMulti) ProtoMessage() {}
func (*TriggerGroupReceiveMulti) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
func (m *TriggerGroupReceiveSequence) GetGroupName() string {
func (m *TriggerGroupReceiveMulti) GetGroupName() string {
if m != nil {
return m.GroupName
}
return ""
}
func (m *TriggerGroupReceiveSequence) GetIgnoreOutOfOrder() bool {
if m != nil {
return m.IgnoreOutOfOrder
}
return false
}
func (m *TriggerGroupReceiveSequence) GetValues() []int32 {
func (m *TriggerGroupReceiveMulti) GetValues() []int32 {
if m != nil {
return m.Values
}
return nil
}
func (m *TriggerGroupReceiveMulti) GetType() GroupReceiveMultiType {
if m != nil {
return m.Type
}
return GroupReceiveMultiType_SEQUENCE
}
type TriggerGPIOIn struct {
GpioNum GPIONum `protobuf:"varint,1,opt,name=gpioNum,enum=P4wnP1_grpc.GPIONum" json:"gpioNum,omitempty"`
PullUpDown GPIOInPullUpDown `protobuf:"varint,2,opt,name=pullUpDown,enum=P4wnP1_grpc.GPIOInPullUpDown" json:"pullUpDown,omitempty"`
@ -2934,7 +2961,7 @@ func init() {
proto.RegisterType((*TriggerSSHLogin)(nil), "P4wnP1_grpc.TriggerSSHLogin")
proto.RegisterType((*TriggerDHCPLeaseGranted)(nil), "P4wnP1_grpc.TriggerDHCPLeaseGranted")
proto.RegisterType((*TriggerGroupReceive)(nil), "P4wnP1_grpc.TriggerGroupReceive")
proto.RegisterType((*TriggerGroupReceiveSequence)(nil), "P4wnP1_grpc.TriggerGroupReceiveSequence")
proto.RegisterType((*TriggerGroupReceiveMulti)(nil), "P4wnP1_grpc.TriggerGroupReceiveMulti")
proto.RegisterType((*TriggerGPIOIn)(nil), "P4wnP1_grpc.TriggerGPIOIn")
proto.RegisterType((*ActionStartBashScript)(nil), "P4wnP1_grpc.ActionStartBashScript")
proto.RegisterType((*ActionStartHIDScript)(nil), "P4wnP1_grpc.ActionStartHIDScript")
@ -2976,6 +3003,7 @@ func init() {
proto.RegisterType((*DHCPServerStaticHost)(nil), "P4wnP1_grpc.DHCPServerStaticHost")
proto.RegisterType((*Empty)(nil), "P4wnP1_grpc.Empty")
proto.RegisterEnum("P4wnP1_grpc.BluetoothNetworkServiceType", BluetoothNetworkServiceType_name, BluetoothNetworkServiceType_value)
proto.RegisterEnum("P4wnP1_grpc.GroupReceiveMultiType", GroupReceiveMultiType_name, GroupReceiveMultiType_value)
proto.RegisterEnum("P4wnP1_grpc.GPIOInPullUpDown", GPIOInPullUpDown_name, GPIOInPullUpDown_value)
proto.RegisterEnum("P4wnP1_grpc.GPIOInEdge", GPIOInEdge_name, GPIOInEdge_value)
proto.RegisterEnum("P4wnP1_grpc.GPIONum", GPIONum_name, GPIONum_value)
@ -5423,303 +5451,304 @@ var _P4WNP1_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("grpc.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 4754 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x7b, 0x49, 0x73, 0x23, 0x47,
0x76, 0x3f, 0x16, 0x2e, 0xc0, 0x03, 0x40, 0x16, 0xb3, 0xb9, 0xa0, 0xd9, 0x7b, 0xa9, 0x25, 0xf5,
0x50, 0x23, 0x4a, 0xa2, 0xa8, 0x56, 0x4b, 0x23, 0xfd, 0x35, 0xd8, 0x08, 0xa0, 0x1b, 0x04, 0xa0,
0x2a, 0xa0, 0x39, 0xdb, 0x7f, 0x6a, 0x0a, 0x55, 0x49, 0xb0, 0xd4, 0x40, 0x15, 0x5c, 0x0b, 0x29,
0xfa, 0x30, 0x0e, 0x4f, 0x84, 0x23, 0x7c, 0xf0, 0xdd, 0xdf, 0xc2, 0x37, 0xdb, 0x9f, 0xc9, 0x97,
0x89, 0xb9, 0xf8, 0xe2, 0x8b, 0x1d, 0x99, 0x59, 0x3b, 0x0a, 0x24, 0x9b, 0x2d, 0xdd, 0x32, 0x5f,
0xbe, 0xfc, 0x65, 0xe6, 0xdb, 0xf2, 0xe5, 0x2b, 0x00, 0x60, 0x6c, 0xce, 0x94, 0xfd, 0x99, 0x69,
0xd8, 0x06, 0x2a, 0xf4, 0x0f, 0x2f, 0xf4, 0xfe, 0x67, 0x12, 0x21, 0xf1, 0xff, 0x98, 0x86, 0x47,
0xd5, 0x89, 0x83, 0x6d, 0xc3, 0xb0, 0xcf, 0x04, 0xfc, 0x77, 0x0e, 0xb6, 0x6c, 0x11, 0xdb, 0xb6,
0xa6, 0x8f, 0x2d, 0xd1, 0x36, 0x4c, 0x79, 0x8c, 0x11, 0x0f, 0xc5, 0x01, 0x9e, 0xce, 0x26, 0xb2,
0x8d, 0xbb, 0xf2, 0x14, 0x97, 0xd3, 0x8f, 0xd3, 0xcf, 0xf2, 0x42, 0x84, 0x86, 0xbe, 0x86, 0x9c,
0xe5, 0x4e, 0x2b, 0x67, 0x1e, 0xa7, 0x9f, 0x15, 0x0e, 0x1e, 0xee, 0x87, 0xd6, 0xd9, 0xf7, 0xd7,
0xf0, 0xc0, 0x05, 0x9f, 0x9f, 0xff, 0xa7, 0x34, 0x6c, 0xcc, 0x8d, 0xa3, 0x5f, 0x41, 0x46, 0xd1,
0xe8, 0x5a, 0x85, 0x83, 0x8f, 0x92, 0xb1, 0x6a, 0x86, 0x6e, 0x9b, 0xc6, 0x64, 0x82, 0xcd, 0xb6,
0x7e, 0x6a, 0x98, 0x53, 0xd9, 0xd6, 0x0c, 0x5d, 0xc8, 0x28, 0x1a, 0xfa, 0x1c, 0x32, 0xb2, 0xb7,
0x91, 0xf7, 0x92, 0x27, 0x57, 0xc6, 0x58, 0xf7, 0x8f, 0x2a, 0x64, 0x64, 0x8b, 0xdf, 0x83, 0xed,
0xe4, 0x51, 0xc4, 0x41, 0x76, 0xa6, 0xe9, 0xee, 0xc1, 0x49, 0x93, 0xff, 0x9f, 0x34, 0xec, 0xf8,
0xcc, 0x5d, 0x6c, 0x5f, 0x18, 0xe6, 0x1b, 0x11, 0x9b, 0xe7, 0x9a, 0x82, 0xd1, 0x21, 0x6c, 0x9b,
0x78, 0xac, 0x59, 0x36, 0x36, 0x25, 0xc3, 0x94, 0x1c, 0xdd, 0xeb, 0x51, 0x80, 0x9c, 0xb0, 0xe9,
0xf5, 0x7b, 0xe6, 0xd0, 0x1f, 0x43, 0x7b, 0xb0, 0x61, 0x61, 0xf3, 0x9c, 0xcd, 0x51, 0x0c, 0x5d,
0xc7, 0x8a, 0x4d, 0x4f, 0x90, 0x13, 0xd6, 0xd9, 0x40, 0xcf, 0xac, 0x31, 0x32, 0xfa, 0x06, 0x96,
0xec, 0xcb, 0x19, 0x2e, 0x67, 0x1f, 0xa7, 0x9f, 0xad, 0x1d, 0x3c, 0x4b, 0x3e, 0x60, 0x74, 0x57,
0x83, 0xcb, 0x19, 0x16, 0xe8, 0x2c, 0xf4, 0x10, 0x0a, 0x53, 0x59, 0x21, 0xcb, 0xe8, 0x44, 0x9d,
0x4b, 0xf4, 0x54, 0xf9, 0xa9, 0xac, 0xf4, 0x4c, 0xaa, 0xcb, 0x47, 0x50, 0x18, 0x99, 0x9a, 0x3a,
0xc6, 0x6c, 0x7c, 0x99, 0x8e, 0x03, 0x23, 0x11, 0x06, 0xfe, 0xbf, 0x96, 0xe0, 0x5e, 0x82, 0x12,
0x7c, 0x71, 0x95, 0x61, 0x75, 0x66, 0x5c, 0x60, 0x13, 0xab, 0xee, 0x89, 0xbd, 0x2e, 0x7a, 0x0c,
0x05, 0xf7, 0x68, 0xf2, 0x68, 0x82, 0xdd, 0xe3, 0x85, 0x49, 0xe8, 0x17, 0xc0, 0x9d, 0xca, 0x96,
0x2d, 0x85, 0xd9, 0xb2, 0x4c, 0x0a, 0x84, 0x5e, 0x0b, 0xb1, 0xf2, 0x50, 0x54, 0x35, 0x4b, 0x31,
0xce, 0xb1, 0x49, 0xd9, 0x96, 0x28, 0x5b, 0x84, 0x86, 0x76, 0x21, 0x37, 0x32, 0x74, 0x95, 0x8e,
0x2f, 0xd3, 0x71, 0xbf, 0x8f, 0xf6, 0xe1, 0xce, 0x44, 0xd3, 0xdf, 0x48, 0x13, 0x7c, 0x8e, 0x27,
0x92, 0x85, 0x15, 0xc7, 0xd4, 0xec, 0xcb, 0xf2, 0x0a, 0x65, 0xdb, 0x20, 0x43, 0x1d, 0x32, 0x22,
0xba, 0x03, 0xe8, 0x00, 0xb6, 0x28, 0x13, 0x96, 0x2c, 0x6d, 0x3a, 0x9b, 0x60, 0x69, 0x26, 0x6b,
0xa6, 0xa6, 0x8f, 0xcb, 0xab, 0x74, 0xc6, 0x1d, 0x36, 0x28, 0xd2, 0xb1, 0x3e, 0x1b, 0x42, 0x5b,
0xb0, 0x32, 0x32, 0x25, 0xac, 0x9a, 0xe5, 0x1c, 0x65, 0x5a, 0x1e, 0x99, 0x0d, 0xd5, 0x44, 0x0f,
0x00, 0xce, 0xb4, 0xf1, 0x99, 0x64, 0xcd, 0x30, 0x56, 0xcb, 0x79, 0x3a, 0x94, 0x27, 0x14, 0x91,
0x10, 0xc8, 0xf0, 0xc4, 0xb8, 0x90, 0xb0, 0x8e, 0xcd, 0xf1, 0x65, 0x19, 0xd8, 0xf0, 0xc4, 0xb8,
0x68, 0x50, 0x02, 0x91, 0xa2, 0xac, 0x9e, 0x63, 0xd3, 0xd6, 0x2c, 0xb2, 0x7c, 0x81, 0x49, 0x31,
0x44, 0x42, 0x1f, 0x03, 0x72, 0xb7, 0xea, 0xca, 0x51, 0x33, 0x74, 0xab, 0x5c, 0x64, 0x27, 0x63,
0x23, 0xb5, 0x60, 0x80, 0xac, 0xa7, 0xe2, 0x91, 0x33, 0x96, 0xde, 0xe0, 0x4b, 0xab, 0x5c, 0x62,
0xeb, 0x51, 0xca, 0x2b, 0x7c, 0xc9, 0xf4, 0x69, 0x6a, 0xe7, 0xb2, 0x72, 0x59, 0x5e, 0x73, 0xf5,
0xc9, 0xba, 0xe8, 0x2b, 0x28, 0x2b, 0xbe, 0xfe, 0xc9, 0x5a, 0xa7, 0xda, 0xd8, 0x31, 0xa9, 0x1f,
0x96, 0xd7, 0x29, 0xeb, 0x4e, 0x30, 0x5e, 0x0b, 0x0f, 0xa3, 0xf7, 0x61, 0xcd, 0xb2, 0x65, 0x5b,
0x53, 0x24, 0x59, 0x55, 0x4d, 0x6c, 0x59, 0x65, 0x8e, 0x4e, 0x28, 0x31, 0x6a, 0x85, 0x11, 0xf9,
0xbf, 0x2e, 0xc1, 0xc3, 0xab, 0x1d, 0x9e, 0x6c, 0xcf, 0x83, 0x20, 0xe6, 0x56, 0x14, 0xbc, 0x2e,
0xfa, 0x08, 0x36, 0x46, 0xde, 0x5c, 0xe9, 0x1c, 0x9b, 0x16, 0xd9, 0x17, 0x31, 0xba, 0x92, 0xc0,
0xf9, 0x03, 0xaf, 0x19, 0x9d, 0x98, 0xd3, 0x54, 0xd6, 0x9d, 0x53, 0x59, 0xb1, 0x1d, 0x13, 0x9b,
0xd4, 0xea, 0x4a, 0x42, 0x84, 0x86, 0x4e, 0x00, 0x59, 0xce, 0x6c, 0x66, 0x98, 0x36, 0x56, 0x25,
0x3f, 0xe0, 0x2d, 0xd1, 0x38, 0xf3, 0xec, 0xba, 0x20, 0xe5, 0x07, 0x9b, 0x0d, 0x1f, 0xc3, 0x77,
0x19, 0x11, 0x38, 0xc5, 0x31, 0x4d, 0xac, 0xdb, 0x01, 0xec, 0xf2, 0x5b, 0xc2, 0xae, 0xbb, 0x08,
0x3e, 0xe8, 0x07, 0xb0, 0xae, 0x4c, 0x64, 0xcb, 0x92, 0x8c, 0x53, 0x49, 0xc5, 0x24, 0x0a, 0x50,
0xe3, 0x2e, 0x0a, 0x25, 0x4a, 0xee, 0x9d, 0xd6, 0x29, 0x11, 0x21, 0x58, 0xa2, 0x9e, 0xbe, 0x4a,
0x3d, 0x9d, 0xb6, 0x89, 0x49, 0x58, 0x67, 0x86, 0x69, 0xb3, 0x18, 0x90, 0x63, 0x31, 0x82, 0x52,
0x68, 0x8c, 0x78, 0x02, 0x45, 0xcd, 0x92, 0xe4, 0x73, 0x59, 0x9b, 0x50, 0xdf, 0x62, 0x26, 0x5c,
0xd0, 0xac, 0x8a, 0x47, 0x42, 0xbf, 0x82, 0x5d, 0x8b, 0xc5, 0x1e, 0x49, 0x67, 0xa1, 0x48, 0x72,
0x03, 0x9c, 0x2e, 0xcf, 0x5c, 0xa3, 0xde, 0x71, 0x39, 0x42, 0xb1, 0x0a, 0x9b, 0x5d, 0x79, 0x86,
0xbe, 0x85, 0x7b, 0x0b, 0x26, 0xcf, 0x64, 0xdd, 0x71, 0x4d, 0xbe, 0x9c, 0x34, 0xbb, 0x2f, 0xeb,
0x0e, 0xfa, 0x0a, 0xee, 0x2e, 0x98, 0x3e, 0xd6, 0x5d, 0x37, 0xd8, 0x4e, 0x9a, 0xdc, 0xd4, 0xf9,
0x1f, 0x80, 0x1b, 0x98, 0xda, 0x78, 0x8c, 0xcd, 0x0a, 0xf5, 0x0e, 0x11, 0xdb, 0xa8, 0x0a, 0x6b,
0x11, 0x1a, 0x31, 0xb4, 0xec, 0xb3, 0xc2, 0xc1, 0x6e, 0x44, 0x37, 0x11, 0x16, 0x21, 0x36, 0x83,
0x08, 0x99, 0xde, 0x9e, 0x19, 0x26, 0x64, 0x1a, 0x48, 0xff, 0x03, 0xa0, 0x14, 0x61, 0x43, 0x6b,
0x90, 0xd1, 0x58, 0xd4, 0x2c, 0x09, 0x19, 0x4d, 0x25, 0xb6, 0x6d, 0xe8, 0x58, 0x3c, 0x33, 0xbc,
0xbb, 0xc0, 0xeb, 0x92, 0xc8, 0xa6, 0x59, 0x64, 0xd6, 0xb9, 0x17, 0x20, 0xfd, 0x3e, 0xba, 0x0f,
0x79, 0x6d, 0x3a, 0x75, 0xec, 0x50, 0x58, 0x0c, 0x08, 0xa8, 0x03, 0x6b, 0xee, 0xd9, 0x45, 0x5b,
0x26, 0x56, 0xe8, 0x5a, 0x1a, 0x9f, 0x74, 0x1a, 0x31, 0xc2, 0xd9, 0x4a, 0x09, 0xb1, 0xb9, 0xe8,
0x37, 0x80, 0x1c, 0x6b, 0xd4, 0x94, 0xd5, 0x31, 0xf6, 0xa2, 0x33, 0x56, 0xa9, 0x9d, 0x15, 0x0e,
0x3e, 0x48, 0x42, 0x1c, 0x8a, 0xd5, 0x18, 0x77, 0x2b, 0x25, 0x24, 0x60, 0x20, 0x19, 0xb6, 0x7c,
0x6a, 0x9d, 0x04, 0x75, 0x0f, 0x7c, 0x95, 0x82, 0xff, 0xe2, 0x4a, 0xf0, 0xf0, 0x84, 0x56, 0x4a,
0x48, 0x46, 0x42, 0x6d, 0x28, 0x5d, 0x68, 0xa7, 0x5a, 0xa5, 0xef, 0x49, 0x22, 0x47, 0xa1, 0x9f,
0x24, 0x41, 0x9f, 0x84, 0x19, 0x5b, 0x29, 0x21, 0x3a, 0x93, 0xc8, 0x81, 0x10, 0xfc, 0xed, 0x57,
0x2c, 0xd1, 0x96, 0xa9, 0x5f, 0x2c, 0x90, 0xc3, 0xc9, 0x1c, 0x37, 0x91, 0xc3, 0x3c, 0x06, 0xcd,
0xad, 0xac, 0xb3, 0x8e, 0x31, 0xd6, 0x74, 0xea, 0x36, 0x85, 0x83, 0xfb, 0x89, 0x9a, 0x12, 0x5b,
0x94, 0xa7, 0x95, 0x12, 0x7c, 0x7e, 0x24, 0x00, 0xa7, 0x9e, 0x29, 0xb3, 0x0e, 0x96, 0x2d, 0xdc,
0x34, 0x65, 0x9d, 0x9c, 0xb1, 0x40, 0x31, 0x9e, 0x26, 0x61, 0xd4, 0x5b, 0xb5, 0x7e, 0x98, 0xb7,
0x95, 0x12, 0xe6, 0xe6, 0xa3, 0x23, 0x28, 0x8e, 0x4d, 0xc3, 0x99, 0x09, 0x58, 0xc1, 0xc4, 0xfa,
0x8a, 0x14, 0xef, 0x71, 0x12, 0x5e, 0x33, 0xc4, 0xd7, 0x4a, 0x09, 0x91, 0x79, 0xe8, 0x8f, 0xb0,
0x19, 0xee, 0x8b, 0x24, 0xfb, 0xd4, 0x15, 0x4c, 0xef, 0x9f, 0x78, 0xdc, 0x4b, 0xc0, 0xf3, 0xf8,
0x5b, 0x29, 0x21, 0x11, 0x07, 0x1d, 0xc2, 0xca, 0x78, 0xa6, 0x19, 0x6d, 0x9d, 0xde, 0x5a, 0x0b,
0xbc, 0xb5, 0xd9, 0x6f, 0xf7, 0xda, 0x44, 0x66, 0x2e, 0x2f, 0xaa, 0x03, 0x8c, 0x64, 0xeb, 0x4c,
0x54, 0x4c, 0x6d, 0x66, 0xd3, 0x4b, 0x2c, 0xee, 0x19, 0x6e, 0x5c, 0x20, 0x7a, 0xaf, 0xfa, 0x9c,
0xad, 0xb4, 0x10, 0x9a, 0x87, 0x2a, 0x90, 0x3f, 0xd3, 0x54, 0x17, 0x84, 0x4b, 0x30, 0xaa, 0x10,
0x48, 0xab, 0x5d, 0xf7, 0x31, 0x82, 0x59, 0x48, 0x81, 0x6d, 0x15, 0xcf, 0x26, 0xc6, 0xa5, 0x17,
0xcf, 0xbd, 0x84, 0xbb, 0xbc, 0x91, 0x60, 0xff, 0x0c, 0xaf, 0x9e, 0x38, 0xa1, 0x95, 0x16, 0x16,
0x40, 0xa1, 0x3d, 0xc8, 0x4e, 0x8c, 0x71, 0x19, 0x51, 0xc4, 0xed, 0x04, 0xc4, 0x8e, 0x31, 0x6e,
0xa5, 0x05, 0xc2, 0x84, 0x9e, 0xc3, 0x2a, 0x91, 0x51, 0xcf, 0xb1, 0xcb, 0x77, 0x12, 0x04, 0xca,
0xf8, 0x89, 0x3c, 0x7b, 0x0e, 0x39, 0x8a, 0xc7, 0x8c, 0xbe, 0x81, 0x3c, 0xd5, 0x8f, 0x88, 0x75,
0xb5, 0xbc, 0x99, 0x60, 0xc0, 0xee, 0x4c, 0x8f, 0x87, 0x88, 0xc1, 0x9f, 0x50, 0xcd, 0xc3, 0xaa,
0xab, 0xaa, 0x6a, 0x0e, 0x56, 0x18, 0x2b, 0xbf, 0x03, 0x5b, 0x89, 0xf1, 0x89, 0xbf, 0x07, 0x77,
0x17, 0x86, 0x19, 0xfe, 0x21, 0xdc, 0xbf, 0x2a, 0x4c, 0xf0, 0xdb, 0xb0, 0x99, 0xe4, 0xeb, 0x21,
0xd0, 0x79, 0x9f, 0xe5, 0x3f, 0x81, 0xf5, 0x98, 0x03, 0x92, 0xf0, 0x3b, 0x21, 0x8d, 0xa1, 0xe5,
0xe6, 0xfc, 0x79, 0x21, 0x20, 0xf0, 0x77, 0x61, 0x67, 0x81, 0xb7, 0xf1, 0x6d, 0xb8, 0x93, 0x60,
0xe8, 0x04, 0x8f, 0xca, 0x23, 0xf4, 0xfa, 0x0a, 0x08, 0x68, 0x13, 0x96, 0xcf, 0xe5, 0x89, 0xc3,
0x6e, 0x96, 0x65, 0x81, 0x75, 0xf8, 0x7f, 0x80, 0x7b, 0x57, 0xf8, 0xcc, 0x35, 0x90, 0x7b, 0xc0,
0xb5, 0xc7, 0xba, 0x61, 0xe2, 0x9e, 0x63, 0xf7, 0x4e, 0x7b, 0xa6, 0x8a, 0x4d, 0xf7, 0xfa, 0x99,
0xa3, 0xa3, 0x6d, 0x58, 0xa1, 0x2b, 0x5a, 0xe5, 0xec, 0xe3, 0xec, 0xb3, 0x65, 0xc1, 0xed, 0xf1,
0xff, 0x99, 0xf6, 0xef, 0x36, 0xe6, 0x63, 0x68, 0x9f, 0xd9, 0x4f, 0xd7, 0x99, 0xd2, 0x15, 0xd7,
0x0e, 0x36, 0x23, 0x56, 0x40, 0xb8, 0xba, 0xce, 0x54, 0xf0, 0x98, 0xd0, 0xb7, 0x00, 0x33, 0x67,
0x32, 0x19, 0xce, 0xea, 0xc6, 0x05, 0x4b, 0xdb, 0xd6, 0x0e, 0x1e, 0xcc, 0x4d, 0x69, 0xeb, 0x7d,
0x9f, 0x49, 0x08, 0x4d, 0x40, 0x5f, 0x02, 0x30, 0x97, 0x6e, 0xa8, 0x63, 0xef, 0xa9, 0xb4, 0x93,
0x30, 0x9d, 0x0c, 0x0b, 0x21, 0x56, 0xfe, 0x4b, 0xd8, 0x4a, 0x74, 0x71, 0xf4, 0x10, 0xc0, 0xa2,
0xad, 0x90, 0xd4, 0x42, 0x14, 0xfe, 0x39, 0x6c, 0x26, 0xb9, 0xf5, 0xb5, 0xf3, 0xfe, 0x3b, 0x0d,
0xf7, 0xaf, 0xf2, 0x5f, 0x92, 0x9a, 0xda, 0x09, 0x2f, 0xf0, 0x30, 0x0d, 0xbd, 0x74, 0xdf, 0x84,
0x4c, 0x4e, 0xcf, 0x6f, 0x1c, 0x1c, 0xf6, 0xbd, 0x46, 0xf0, 0x42, 0xe4, 0x71, 0xf0, 0xe2, 0x27,
0x54, 0xb4, 0x01, 0xa5, 0xa3, 0x61, 0xa7, 0x23, 0x89, 0x8d, 0xc1, 0xa0, 0xdd, 0x6d, 0x8a, 0x5c,
0x0a, 0x15, 0x60, 0xb5, 0xdb, 0x18, 0x9c, 0xf4, 0x84, 0x57, 0x5c, 0x1a, 0xe5, 0x60, 0xe9, 0xa4,
0x7d, 0xd4, 0xe6, 0x32, 0x68, 0x15, 0xb2, 0x43, 0xb1, 0xca, 0x65, 0x51, 0x09, 0xf2, 0xd5, 0xce,
0xb0, 0x31, 0xe8, 0xf5, 0x06, 0x2d, 0x6e, 0x09, 0xdd, 0x81, 0xf5, 0x81, 0xd0, 0x6e, 0x36, 0x1b,
0x82, 0x54, 0xa9, 0x0d, 0xda, 0xbd, 0xae, 0xc8, 0x2d, 0xf3, 0x05, 0xc8, 0xfb, 0x41, 0x86, 0x9f,
0x41, 0x29, 0x12, 0x41, 0xde, 0xda, 0x5c, 0x3e, 0x09, 0xfb, 0xc1, 0xda, 0xc1, 0xdd, 0x39, 0xee,
0x9e, 0x63, 0xbf, 0x26, 0x0c, 0x9e, 0x8b, 0x34, 0x60, 0x3d, 0x16, 0x79, 0x6e, 0xe5, 0x69, 0x17,
0xb0, 0x4b, 0xc2, 0xc2, 0x3b, 0x14, 0x4f, 0xbe, 0x98, 0x2b, 0x9e, 0x44, 0x37, 0x7f, 0xa2, 0x1d,
0x69, 0x09, 0x75, 0x93, 0x7f, 0xcd, 0x42, 0x31, 0x3c, 0xe4, 0xe7, 0xf1, 0xe9, 0x50, 0x1e, 0xbf,
0x0b, 0x39, 0x55, 0xb3, 0x48, 0xde, 0xa7, 0xba, 0x2e, 0xec, 0xf7, 0x89, 0x5d, 0x9a, 0x78, 0xec,
0x4c, 0x64, 0xdb, 0x30, 0x2f, 0xa9, 0x87, 0xe4, 0x85, 0x10, 0x05, 0x7d, 0x07, 0x45, 0x92, 0x1a,
0x6b, 0xfa, 0x58, 0x9a, 0x1a, 0x2a, 0xcb, 0x24, 0xd7, 0x62, 0xb1, 0x9b, 0x6c, 0xe0, 0x84, 0x31,
0x1d, 0x1b, 0x2a, 0x16, 0x0a, 0x17, 0x41, 0x07, 0x3d, 0x87, 0xbc, 0xec, 0xd8, 0x67, 0x6c, 0xf6,
0x72, 0x82, 0x5a, 0xc8, 0xec, 0x8a, 0x63, 0x9f, 0xd1, 0xa9, 0x39, 0xd9, 0x6d, 0x91, 0xac, 0x57,
0x39, 0x93, 0x75, 0x1d, 0x4f, 0x68, 0x22, 0x59, 0x12, 0xbc, 0x2e, 0xda, 0x87, 0x15, 0x79, 0x26,
0x55, 0x45, 0xd1, 0x4d, 0x02, 0x77, 0xe6, 0xe0, 0xaa, 0xa2, 0x58, 0x3b, 0x1d, 0x0b, 0xcb, 0xf2,
0xac, 0x2a, 0x8a, 0xe8, 0x3b, 0xf2, 0x04, 0xd2, 0xc8, 0xb3, 0xaa, 0x2a, 0x8a, 0xd2, 0x44, 0xb3,
0xec, 0x72, 0x8e, 0xa6, 0xee, 0x0b, 0x27, 0x96, 0x18, 0x7f, 0x55, 0x14, 0x3b, 0x9a, 0x65, 0xa3,
0x7b, 0xf4, 0x22, 0xc7, 0x92, 0x65, 0x69, 0xde, 0x43, 0x3d, 0x47, 0x08, 0xa2, 0xa5, 0xa9, 0x24,
0xf6, 0xe9, 0xf8, 0xc7, 0xa9, 0xa1, 0xbb, 0x6f, 0x66, 0xb7, 0xc7, 0xff, 0x5b, 0x1a, 0xf2, 0x54,
0x33, 0x36, 0xf1, 0xde, 0x7d, 0x58, 0xa2, 0x02, 0x60, 0x56, 0xbc, 0x3b, 0xaf, 0x5a, 0xc2, 0x45,
0x25, 0x40, 0xf9, 0xc2, 0xa7, 0xcf, 0x44, 0x4f, 0x8f, 0x60, 0x89, 0xee, 0x83, 0xa9, 0x8a, 0xb6,
0x51, 0x0d, 0xe2, 0xef, 0x3e, 0xf7, 0x3d, 0x7a, 0x85, 0x0d, 0xc5, 0x67, 0xf0, 0x07, 0x00, 0x81,
0x08, 0xc8, 0x32, 0xa2, 0xd8, 0xae, 0x7b, 0x76, 0x44, 0xda, 0x88, 0x83, 0x6c, 0x5f, 0x7c, 0xe5,
0xbe, 0x5e, 0x48, 0x93, 0x7f, 0x02, 0x25, 0xd1, 0x36, 0x89, 0xaa, 0xb1, 0x65, 0x11, 0x53, 0xe7,
0x20, 0x3b, 0xb5, 0xc6, 0x5e, 0x95, 0x6c, 0x6a, 0x8d, 0xf9, 0x4f, 0x01, 0x45, 0x58, 0x2a, 0xa6,
0x29, 0x5f, 0x12, 0x93, 0x9c, 0x5a, 0x63, 0xda, 0xa6, 0xef, 0xa8, 0xbc, 0xe0, 0xf7, 0xf9, 0x7d,
0x28, 0x36, 0xce, 0xb1, 0x6e, 0xbb, 0xde, 0x44, 0x4c, 0x94, 0x28, 0x0d, 0xeb, 0x24, 0x0e, 0x51,
0xe8, 0xac, 0x10, 0xa2, 0xf0, 0x32, 0x00, 0xe5, 0xa7, 0x8e, 0x8d, 0x76, 0x61, 0xd5, 0xb6, 0xe8,
0x82, 0x6c, 0x17, 0xad, 0x94, 0xe0, 0x11, 0xd0, 0x36, 0x2c, 0xdb, 0x23, 0xc3, 0x60, 0x32, 0xcd,
0xb5, 0x52, 0x02, 0xeb, 0xa2, 0x32, 0xac, 0xd8, 0x9a, 0x6e, 0x3f, 0x3f, 0xa4, 0x52, 0xcd, 0x92,
0x4c, 0x90, 0xf5, 0xab, 0xcb, 0x90, 0x3d, 0x97, 0x27, 0x7c, 0x07, 0x96, 0xe9, 0x12, 0x44, 0x2c,
0x76, 0xb0, 0x0b, 0x56, 0x4b, 0xfb, 0xc4, 0xbf, 0xfd, 0x32, 0x09, 0x66, 0x15, 0x6c, 0xcd, 0xbf,
0x16, 0xff, 0x04, 0x9b, 0xc4, 0xf7, 0xeb, 0x9a, 0xd9, 0x33, 0x8f, 0xb4, 0x09, 0xf6, 0x0e, 0xca,
0x41, 0x56, 0xd5, 0xbc, 0x6c, 0x81, 0x34, 0x89, 0x71, 0xcd, 0x4c, 0x7c, 0xaa, 0xfd, 0xe8, 0x0a,
0xdd, 0xed, 0x11, 0x91, 0x18, 0xfa, 0xe4, 0xf2, 0xc8, 0x98, 0xa8, 0x6e, 0x95, 0x22, 0x27, 0x84,
0x28, 0xe4, 0xfa, 0x8a, 0xad, 0x60, 0xcd, 0x0c, 0xdd, 0xc2, 0xcc, 0xdd, 0x2d, 0x67, 0x62, 0xf7,
0x65, 0xfb, 0xcc, 0xbb, 0x86, 0x02, 0x0a, 0xff, 0x2f, 0x69, 0x58, 0x17, 0xb0, 0xac, 0x86, 0xb7,
0xf5, 0x05, 0xac, 0x9c, 0xb2, 0x85, 0xd2, 0x09, 0xf7, 0x6f, 0x45, 0x51, 0xb0, 0x65, 0x69, 0xa3,
0x09, 0x66, 0x6b, 0x0b, 0x2e, 0x33, 0x51, 0xf1, 0xa9, 0x36, 0xc1, 0x7a, 0xf0, 0xe0, 0xf5, 0xfb,
0x24, 0x8a, 0x5a, 0xe4, 0x7e, 0x64, 0xf2, 0x16, 0x58, 0x87, 0x9c, 0x7f, 0x82, 0x75, 0x6a, 0xba,
0x59, 0x81, 0x34, 0xf9, 0x3a, 0x70, 0xc1, 0x6e, 0xdc, 0x23, 0xdc, 0x87, 0xbc, 0x89, 0x65, 0xb5,
0x66, 0x38, 0xba, 0xed, 0xea, 0x21, 0x20, 0x10, 0x05, 0xa9, 0xb2, 0x2d, 0xd3, 0x15, 0x8b, 0x02,
0x6d, 0xf3, 0xff, 0x9e, 0x06, 0xee, 0xc4, 0xd4, 0x6c, 0xfc, 0x33, 0x9f, 0x6a, 0x9b, 0x04, 0xa6,
0x19, 0xc9, 0x70, 0x99, 0x46, 0xdc, 0x1e, 0xad, 0x2a, 0x39, 0x96, 0xdd, 0x35, 0xec, 0xc6, 0x8f,
0x24, 0xfa, 0xb8, 0x45, 0xca, 0x30, 0xcd, 0xdf, 0xf7, 0x72, 0x68, 0xdf, 0xef, 0xc3, 0x3a, 0xd9,
0x71, 0x5b, 0x3f, 0x35, 0xbc, 0x5d, 0x23, 0x58, 0x9a, 0x05, 0x9a, 0xa3, 0x6d, 0xfe, 0xcf, 0xc0,
0x05, 0x6c, 0xae, 0x90, 0x92, 0xae, 0x01, 0x12, 0x39, 0xb4, 0xbf, 0x67, 0xdb, 0xce, 0x0a, 0xb4,
0x4d, 0x68, 0x34, 0x2e, 0xb1, 0x42, 0x97, 0x1f, 0x7b, 0xa6, 0x86, 0x3a, 0xd0, 0xdc, 0xba, 0x70,
0x56, 0xf0, 0xba, 0x44, 0x6d, 0x9a, 0x55, 0xd7, 0x4c, 0xb7, 0x8c, 0xca, 0x3a, 0xfc, 0xef, 0x80,
0xf3, 0xf3, 0x9c, 0x90, 0xcf, 0xb2, 0xe4, 0x26, 0x6c, 0x67, 0x01, 0x05, 0x7d, 0x00, 0x6b, 0xb6,
0x36, 0xc5, 0x86, 0x63, 0x8b, 0x58, 0x31, 0x74, 0xd5, 0x72, 0xc3, 0x5c, 0x8c, 0xca, 0x3f, 0x84,
0xa2, 0x8f, 0xfd, 0xd2, 0x18, 0xc5, 0x6b, 0x23, 0xfc, 0xd3, 0xd0, 0xda, 0x2f, 0x8d, 0x11, 0x0d,
0xd7, 0x1c, 0x64, 0x35, 0x95, 0x95, 0x67, 0x4a, 0x02, 0x69, 0xf2, 0xaf, 0xa1, 0xdc, 0x6a, 0xd7,
0x05, 0x47, 0xd7, 0x35, 0x7d, 0xfc, 0xd2, 0x18, 0xd1, 0x68, 0x2b, 0x50, 0xab, 0x0f, 0x21, 0x66,
0x69, 0xb5, 0x05, 0xc1, 0xd2, 0xf9, 0xb4, 0xad, 0x7a, 0x52, 0x22, 0x6d, 0xa2, 0x58, 0xcb, 0x70,
0x4c, 0x05, 0xbb, 0x51, 0xd7, 0xed, 0xf1, 0x7f, 0x86, 0xf5, 0xd0, 0xc9, 0x29, 0xdc, 0x47, 0x90,
0xfd, 0xc1, 0x18, 0xb9, 0xdf, 0x2c, 0xa2, 0xe1, 0x37, 0xbc, 0x51, 0x81, 0x70, 0x11, 0x29, 0x69,
0xd6, 0x91, 0xa6, 0x6b, 0xd6, 0x99, 0x7f, 0x35, 0x87, 0x28, 0x81, 0xb7, 0xbe, 0xb4, 0x0c, 0x3d,
0xb8, 0x9c, 0x3d, 0x0a, 0xbf, 0x0f, 0x85, 0x4e, 0xa3, 0xee, 0xdf, 0xfd, 0x8f, 0xa0, 0x30, 0xa2,
0xd5, 0x6c, 0xc5, 0xf7, 0x8d, 0x92, 0x00, 0x94, 0x44, 0x9d, 0x83, 0xff, 0x11, 0xee, 0x0e, 0xc5,
0xea, 0x3b, 0x64, 0x29, 0x5f, 0xce, 0x65, 0x29, 0xf7, 0xa2, 0x29, 0x16, 0x7d, 0x50, 0x25, 0xe4,
0x29, 0x7f, 0x5d, 0x86, 0xb5, 0xe8, 0x20, 0x31, 0x33, 0xac, 0xb3, 0xa4, 0xc4, 0xfd, 0x42, 0xe0,
0x76, 0x89, 0x02, 0xcf, 0x35, 0xd5, 0xbb, 0x67, 0xce, 0x35, 0x95, 0x7d, 0x7c, 0xf1, 0xee, 0x3c,
0xd2, 0x9c, 0xab, 0xd4, 0xb2, 0x2f, 0x18, 0xd1, 0x4a, 0x2d, 0xad, 0x59, 0x1b, 0xaa, 0xa3, 0xd8,
0xee, 0x07, 0x0c, 0xaf, 0x4b, 0x15, 0x8a, 0x4d, 0x4d, 0x66, 0xb9, 0x05, 0x51, 0x28, 0xed, 0xa1,
0x87, 0x50, 0x70, 0x2c, 0x2c, 0xd5, 0xea, 0x35, 0xa9, 0x51, 0x3b, 0x76, 0x8b, 0xfa, 0x79, 0xc7,
0xc2, 0xb5, 0x7a, 0xad, 0x51, 0x3b, 0x26, 0x99, 0x00, 0x19, 0x17, 0xba, 0xf5, 0xb6, 0xe8, 0x56,
0xf3, 0x73, 0x8e, 0x85, 0x69, 0x1f, 0x3d, 0x03, 0x8e, 0x0c, 0xb6, 0xda, 0x75, 0xe9, 0x55, 0xe3,
0xb7, 0xd5, 0x5e, 0x45, 0xa8, 0xbb, 0xd9, 0xc2, 0x9a, 0x63, 0xe1, 0x56, 0xbb, 0xee, 0x51, 0x11,
0x0f, 0x25, 0x8f, 0xf3, 0xb8, 0x37, 0x14, 0x1b, 0x6e, 0x25, 0xb4, 0xc0, 0xd8, 0x28, 0xc9, 0xdb,
0x0a, 0xe1, 0x11, 0x2a, 0x27, 0x6e, 0xb5, 0x33, 0xcf, 0x38, 0x84, 0xca, 0x09, 0xda, 0x81, 0x55,
0x32, 0x3e, 0x3c, 0x16, 0xdd, 0x62, 0xe6, 0x8a, 0x63, 0xe1, 0xe1, 0xb1, 0x88, 0x1e, 0x00, 0x90,
0x01, 0xb1, 0x21, 0xb4, 0x2b, 0x1d, 0xaf, 0x90, 0xef, 0x58, 0x98, 0x11, 0xd0, 0x4b, 0x58, 0x33,
0x75, 0x55, 0xb3, 0x82, 0x1a, 0xf3, 0x5a, 0xc2, 0x27, 0xb2, 0xa8, 0xae, 0x1a, 0xf6, 0x19, 0x36,
0x75, 0x6c, 0x0b, 0x25, 0x3a, 0xd5, 0x57, 0xe1, 0x31, 0x70, 0x8a, 0xaa, 0x48, 0x58, 0x99, 0x06,
0x68, 0xeb, 0x37, 0x47, 0x5b, 0x53, 0x54, 0xa5, 0xa1, 0x4c, 0x7d, 0xb8, 0x0a, 0x14, 0x9d, 0x69,
0x68, 0x63, 0x5c, 0xc2, 0x47, 0xc4, 0x28, 0xd4, 0xf0, 0x58, 0x14, 0x0a, 0xce, 0x34, 0xd8, 0xd1,
0x67, 0xb0, 0xa5, 0xe2, 0x73, 0x89, 0xc4, 0x45, 0xe9, 0x4c, 0x53, 0xa5, 0x37, 0xf8, 0x72, 0x64,
0xc8, 0xa6, 0x4a, 0xab, 0x1b, 0x79, 0x01, 0xa9, 0xf8, 0x9c, 0xc4, 0x9f, 0x96, 0xa6, 0xbe, 0x72,
0x47, 0xd0, 0x47, 0x80, 0x22, 0x53, 0xa6, 0x86, 0x63, 0x61, 0x5a, 0xdd, 0xc8, 0x0b, 0xeb, 0x01,
0xff, 0x31, 0x21, 0xa3, 0x0f, 0x81, 0x8b, 0x30, 0x9b, 0xf2, 0x05, 0x2d, 0x67, 0xe4, 0x85, 0x52,
0xc0, 0x2a, 0xc8, 0x17, 0x7c, 0x1f, 0xb6, 0x93, 0x4f, 0x4d, 0xb3, 0x49, 0xc3, 0xb2, 0xe9, 0x27,
0x0f, 0xd7, 0xc9, 0x72, 0x84, 0x50, 0x51, 0x55, 0x13, 0xdd, 0x85, 0x1c, 0xc1, 0xa7, 0x63, 0xcc,
0xfe, 0x57, 0x55, 0x7c, 0x4e, 0x86, 0xf8, 0x6f, 0x61, 0x63, 0xee, 0xf0, 0x24, 0x22, 0x2b, 0xaa,
0x69, 0x4c, 0x5d, 0x17, 0x62, 0x1d, 0x12, 0xc3, 0xc8, 0xa5, 0xe4, 0xd5, 0x99, 0x49, 0x9b, 0xff,
0xe7, 0x34, 0x3c, 0xf4, 0x25, 0x7f, 0xfb, 0x08, 0x50, 0x9d, 0x8b, 0x00, 0xd1, 0xc2, 0xa6, 0xb7,
0x44, 0x5b, 0xb7, 0xb1, 0x79, 0x2a, 0x2b, 0x38, 0x21, 0x18, 0x48, 0xf0, 0x84, 0xbd, 0x43, 0xb1,
0xba, 0x90, 0x1d, 0x7d, 0x0d, 0x4b, 0x34, 0x55, 0x67, 0x55, 0xf6, 0x9b, 0x2e, 0x42, 0xe7, 0xf0,
0x7f, 0xc9, 0xc2, 0xdd, 0xc5, 0xc8, 0x49, 0x77, 0xe3, 0x77, 0xee, 0x3d, 0xc8, 0xde, 0x8d, 0x1f,
0xdd, 0x6c, 0xb5, 0xfd, 0x50, 0xc2, 0x4e, 0x42, 0xf9, 0xcc, 0xfd, 0x60, 0x75, 0xe8, 0x85, 0xea,
0x80, 0x42, 0xf2, 0x06, 0x1d, 0xdb, 0x53, 0xd9, 0x7a, 0x73, 0xe8, 0xc6, 0x2a, 0xbf, 0x1f, 0x8e,
0x84, 0xcb, 0xd1, 0x48, 0xd8, 0x03, 0xa4, 0x9e, 0x29, 0x33, 0xf6, 0x61, 0xc2, 0xcf, 0xed, 0x59,
0x61, 0xfd, 0x51, 0x64, 0x93, 0xf5, 0x56, 0xad, 0x1f, 0x65, 0x13, 0x12, 0xa6, 0xa2, 0xa7, 0x50,
0xf2, 0xd4, 0xd0, 0xd6, 0x87, 0x16, 0x76, 0x43, 0x5c, 0x94, 0xc8, 0xd7, 0x60, 0x89, 0xbe, 0xc1,
0x00, 0x56, 0x8e, 0x2b, 0xdd, 0x61, 0xa5, 0xc3, 0xa5, 0xd0, 0x3a, 0x14, 0xc8, 0x1a, 0x52, 0xad,
0xd3, 0x6e, 0x74, 0x07, 0x5c, 0xda, 0x27, 0x88, 0x0d, 0xe1, 0x75, 0x43, 0xe0, 0x32, 0xe4, 0xb9,
0x3f, 0xec, 0x1e, 0x57, 0xba, 0x95, 0x66, 0xa3, 0xce, 0x65, 0xf9, 0xff, 0xcd, 0x02, 0x9a, 0xdf,
0x55, 0x90, 0xcd, 0xf7, 0x0d, 0xd3, 0xbf, 0xa3, 0x02, 0x0a, 0x7a, 0x06, 0xeb, 0xac, 0xe7, 0x8b,
0xdb, 0x35, 0xe3, 0x38, 0x99, 0x96, 0xd8, 0xb0, 0x6c, 0xd1, 0xac, 0xce, 0x95, 0x78, 0x40, 0x40,
0x7b, 0xc0, 0xe9, 0x86, 0x4d, 0x1e, 0x96, 0x86, 0xa9, 0xd9, 0x32, 0xfd, 0x46, 0xc2, 0x12, 0xaf,
0x39, 0x3a, 0xda, 0x07, 0xa4, 0x1a, 0x5d, 0xc3, 0xae, 0x6a, 0xba, 0x1a, 0x2c, 0xcb, 0x74, 0x91,
0x30, 0x42, 0xb2, 0x17, 0x45, 0x9e, 0x4c, 0x46, 0xb2, 0xf2, 0xc6, 0x2d, 0xef, 0xb2, 0x6b, 0x24,
0x46, 0x45, 0x87, 0xb0, 0x62, 0xca, 0xfa, 0x18, 0x5b, 0xe5, 0x55, 0x6a, 0xc5, 0xf7, 0x17, 0xa8,
0x4c, 0x20, 0x4c, 0x82, 0xcb, 0x8b, 0x8e, 0x60, 0xd5, 0x98, 0xb1, 0x4f, 0x4c, 0xec, 0x9d, 0xfa,
0xcb, 0x6b, 0x34, 0xbd, 0xdf, 0x63, 0xec, 0x0d, 0xdd, 0x36, 0x2f, 0x05, 0x6f, 0x32, 0xaa, 0x41,
0x81, 0x7d, 0x47, 0x6d, 0x19, 0x96, 0x6d, 0x95, 0xf3, 0x14, 0xeb, 0xc9, 0x22, 0x2c, 0x9f, 0x53,
0x08, 0xcf, 0xda, 0xfd, 0x1a, 0x8a, 0x61, 0x74, 0x72, 0x13, 0xbf, 0xc1, 0x97, 0xae, 0xde, 0x48,
0x33, 0x5a, 0x11, 0xc9, 0xbb, 0x15, 0x91, 0xaf, 0x33, 0x2f, 0xd2, 0xbc, 0x01, 0xeb, 0xb1, 0x33,
0xd2, 0x8c, 0x86, 0x34, 0x3a, 0xc6, 0x85, 0x5f, 0x17, 0x0d, 0x51, 0xfc, 0xf1, 0xe1, 0x6c, 0x86,
0xbd, 0x08, 0x18, 0xa2, 0xf8, 0x3a, 0xa7, 0xd9, 0x69, 0x58, 0xe7, 0x84, 0xc0, 0xbf, 0x80, 0xcd,
0xa4, 0x13, 0xd1, 0x57, 0xa9, 0xac, 0xf8, 0xaf, 0x52, 0x59, 0xa1, 0x59, 0xdf, 0xcc, 0xc5, 0xcf,
0x68, 0x33, 0x7e, 0x15, 0x96, 0x1b, 0xd3, 0x99, 0x7d, 0xb9, 0xf7, 0x22, 0xf4, 0xb3, 0x86, 0xf9,
0x5f, 0x4f, 0xa0, 0x55, 0xc8, 0x76, 0x2b, 0x7d, 0x2e, 0x85, 0x72, 0xb0, 0xd4, 0xaf, 0x74, 0x87,
0x5c, 0x1a, 0xad, 0x40, 0xa6, 0xd9, 0xe5, 0x32, 0x7b, 0x1f, 0x03, 0x17, 0xaf, 0x45, 0x92, 0xb1,
0xa1, 0xcb, 0x5d, 0xef, 0x9d, 0x74, 0xb9, 0x34, 0x01, 0xe8, 0x1d, 0x1d, 0x71, 0x99, 0xbd, 0x4f,
0x00, 0x82, 0xda, 0x23, 0xf1, 0x34, 0xa1, 0x2d, 0xb6, 0xbb, 0x4d, 0x56, 0x56, 0x3b, 0xaa, 0x74,
0x3a, 0xa4, 0x43, 0xcb, 0x6a, 0xd5, 0xde, 0xa0, 0xc5, 0x65, 0xf6, 0xfe, 0x96, 0x86, 0x55, 0xb7,
0xe0, 0x85, 0xf2, 0xb0, 0xdc, 0x1d, 0x1e, 0x4b, 0x9f, 0x71, 0x29, 0xaf, 0x79, 0xc0, 0xa5, 0xbd,
0xe6, 0xe7, 0x5c, 0xc6, 0x6b, 0x1e, 0x72, 0x59, 0xaf, 0xf9, 0x05, 0xb7, 0xe4, 0x35, 0x9f, 0x73,
0xcb, 0x5e, 0xf3, 0x4b, 0x6e, 0xc5, 0x6b, 0xbe, 0xe0, 0x56, 0xbd, 0xe6, 0x57, 0x5c, 0x8e, 0xec,
0x88, 0x2e, 0xf1, 0x29, 0x97, 0xf7, 0xdb, 0x9f, 0x71, 0xe0, 0xb7, 0x0f, 0xb8, 0x82, 0xdf, 0xfe,
0x9c, 0x2b, 0xfa, 0xed, 0x43, 0xae, 0xe4, 0xb7, 0xbf, 0xe0, 0xd6, 0xfc, 0xf6, 0x73, 0x6e, 0xdd,
0x6f, 0x7f, 0xc9, 0x71, 0x7e, 0xfb, 0x05, 0xb7, 0xe1, 0xb7, 0xbf, 0xe2, 0x90, 0xd7, 0x3e, 0xf8,
0x94, 0xbb, 0xb3, 0xf7, 0x31, 0x14, 0xc3, 0x45, 0x3b, 0x22, 0xbc, 0x4e, 0xef, 0x84, 0xc9, 0xb3,
0xd5, 0x6e, 0xb6, 0xb8, 0x34, 0x61, 0x1f, 0xf4, 0x9a, 0xcd, 0x4e, 0x83, 0xcb, 0xec, 0xd5, 0x61,
0x3d, 0x56, 0x8a, 0x22, 0xb2, 0x1c, 0x76, 0x5f, 0x75, 0x89, 0xec, 0x53, 0x44, 0x1b, 0x95, 0x3e,
0xd3, 0x81, 0x38, 0xa8, 0x70, 0x19, 0x74, 0x07, 0xd6, 0xc5, 0x41, 0x45, 0x3a, 0xaa, 0xb4, 0x3b,
0xbd, 0xd7, 0x0d, 0x41, 0xaa, 0xf4, 0xb9, 0xec, 0x5e, 0x1d, 0x4a, 0x91, 0x8a, 0x0c, 0xda, 0x82,
0x0d, 0xc2, 0xd5, 0xed, 0x0d, 0xa4, 0x5a, 0xaf, 0xdb, 0x6d, 0xd4, 0x06, 0x8d, 0x3a, 0x13, 0x7c,
0xa5, 0x2f, 0x0d, 0x09, 0xe0, 0x06, 0x94, 0x08, 0x47, 0x30, 0x9a, 0xd9, 0xfb, 0x80, 0xd5, 0xe5,
0xbc, 0xc2, 0x16, 0x2a, 0x42, 0xee, 0xa4, 0x5f, 0x39, 0x90, 0xfa, 0xe2, 0x2b, 0xb6, 0xff, 0x5e,
0xbf, 0xd1, 0xe5, 0xd2, 0x7b, 0xff, 0x0f, 0xb8, 0xf8, 0x5b, 0x93, 0xec, 0x6f, 0x70, 0x4c, 0xcc,
0x86, 0x83, 0x62, 0xb5, 0x22, 0xb6, 0x24, 0xb1, 0x26, 0xb4, 0xfb, 0x03, 0x91, 0x05, 0x5d, 0x92,
0x11, 0x7a, 0x84, 0xcc, 0xc1, 0xdf, 0xf6, 0x61, 0xa5, 0x7f, 0x78, 0xd2, 0xed, 0x7f, 0x86, 0x4e,
0xe1, 0x49, 0x13, 0xdb, 0xd7, 0xfc, 0x50, 0x02, 0x45, 0xaf, 0x36, 0x62, 0xf3, 0xbb, 0x6f, 0xf3,
0xd3, 0x2a, 0x3e, 0x85, 0xfe, 0x92, 0x86, 0xa7, 0xec, 0xfe, 0xbe, 0x66, 0xad, 0xb7, 0xc1, 0x7d,
0xdb, 0x4d, 0xbc, 0x86, 0xbb, 0xe1, 0xc3, 0x46, 0x7f, 0xab, 0x95, 0x74, 0xc8, 0x9b, 0xfc, 0x04,
0x8c, 0x4f, 0xa1, 0x1f, 0xe0, 0x7e, 0xec, 0x6c, 0x51, 0xe8, 0x9b, 0xc0, 0xdc, 0x74, 0xad, 0xdf,
0xc0, 0xae, 0x18, 0x3a, 0x43, 0xec, 0x27, 0x64, 0x4f, 0x6f, 0xf2, 0x93, 0xae, 0xdd, 0x84, 0xa3,
0xf2, 0x29, 0xf4, 0x7b, 0xd8, 0x89, 0x9d, 0x22, 0xb8, 0x7f, 0xaf, 0xfe, 0x4d, 0xde, 0xee, 0x35,
0xe3, 0x7c, 0x0a, 0xfd, 0x01, 0xb6, 0x49, 0xc6, 0x88, 0xe7, 0xb1, 0x7f, 0x99, 0x3c, 0x37, 0x39,
0xdd, 0x5c, 0xb0, 0xf5, 0xdf, 0xc1, 0x6e, 0x13, 0xdb, 0x74, 0x01, 0x75, 0x7e, 0x85, 0x68, 0xe5,
0x34, 0x52, 0x58, 0xbc, 0xc1, 0xce, 0xff, 0x3f, 0x3c, 0x70, 0x3f, 0x80, 0xfc, 0x2c, 0xf0, 0xdf,
0x13, 0xf8, 0x09, 0xb6, 0xf1, 0x6d, 0xe0, 0x93, 0xa5, 0x21, 0xc0, 0x43, 0x0a, 0xe6, 0xe5, 0xcb,
0x3f, 0x05, 0xe6, 0x00, 0xee, 0x75, 0x34, 0x6b, 0xa1, 0x88, 0x93, 0x9c, 0xe7, 0xd1, 0xe2, 0x45,
0x58, 0xcd, 0x36, 0x85, 0x8e, 0xa1, 0xdc, 0xc4, 0xb6, 0xb7, 0xcf, 0xc8, 0x4b, 0x25, 0x11, 0xf2,
0xaa, 0xc2, 0x01, 0x9f, 0x42, 0x2d, 0xb8, 0xc3, 0xb0, 0xde, 0x19, 0xe9, 0x08, 0x36, 0x9a, 0xd8,
0x8e, 0x15, 0x1f, 0x6e, 0x81, 0xd3, 0x83, 0x0d, 0x71, 0x0e, 0xe7, 0xaa, 0x39, 0xd7, 0x01, 0xfe,
0x1a, 0xd6, 0x9a, 0xd8, 0x0e, 0x17, 0x70, 0x92, 0x76, 0x55, 0x8e, 0xd0, 0x42, 0xdc, 0x0c, 0x41,
0x8c, 0x22, 0x2c, 0xe4, 0x5e, 0x60, 0x0b, 0x75, 0x28, 0x1e, 0x1b, 0x8e, 0x6e, 0x0f, 0x8f, 0x45,
0x9a, 0x35, 0x5f, 0xf3, 0xd8, 0x5e, 0x80, 0xd2, 0x07, 0x8e, 0x5a, 0xd3, 0x50, 0xac, 0x06, 0x3f,
0x3c, 0x8b, 0x70, 0x2e, 0x2c, 0x3b, 0x2d, 0x40, 0xfc, 0x1e, 0x36, 0xfd, 0x28, 0x10, 0x46, 0xbd,
0xca, 0xda, 0xaf, 0x11, 0xf7, 0xc0, 0x8b, 0x89, 0x3f, 0x29, 0xea, 0x2b, 0x82, 0x1a, 0xf8, 0xfc,
0x4d, 0x51, 0x93, 0x4f, 0xdd, 0x81, 0x72, 0xc4, 0xdb, 0xdf, 0x0d, 0xad, 0x0b, 0x5b, 0x81, 0x9f,
0x87, 0xa1, 0x6e, 0xed, 0xe1, 0x45, 0x56, 0x45, 0x75, 0x5f, 0x37, 0x0f, 0x92, 0xab, 0x9b, 0xae,
0x9e, 0x77, 0xef, 0x2f, 0x1a, 0xb6, 0x9c, 0x89, 0x4d, 0xe1, 0xd6, 0xc3, 0x70, 0x2f, 0x8d, 0xd1,
0x75, 0x88, 0x8b, 0xcb, 0xa9, 0x34, 0x52, 0x6e, 0xb5, 0xda, 0x75, 0x62, 0x34, 0x7e, 0x8d, 0x95,
0x55, 0x64, 0x17, 0xcf, 0xba, 0x76, 0x8b, 0x0d, 0x40, 0xad, 0x76, 0xbd, 0x26, 0xeb, 0x0a, 0x9e,
0x04, 0xbb, 0xbc, 0x02, 0x70, 0x91, 0x22, 0x76, 0xd8, 0xd6, 0xdc, 0x0a, 0xb4, 0xcf, 0x9f, 0xac,
0x8a, 0x07, 0x0b, 0xf1, 0x89, 0x3a, 0xf9, 0x14, 0xaa, 0xc2, 0xb6, 0xbf, 0xad, 0xca, 0x64, 0x72,
0x0d, 0xdc, 0xa2, 0x0c, 0x61, 0x2b, 0xb2, 0x27, 0xaf, 0x2a, 0x7e, 0xd5, 0xe9, 0xde, 0x8f, 0x0f,
0x25, 0x56, 0xd4, 0xe9, 0x06, 0x0b, 0x47, 0xa2, 0xff, 0xc5, 0x25, 0xa6, 0xd6, 0xf8, 0x97, 0x98,
0x05, 0x1b, 0x7c, 0x05, 0x70, 0x24, 0x7a, 0x1f, 0x7f, 0x50, 0x54, 0x53, 0xb1, 0x2f, 0x54, 0x31,
0x89, 0xc5, 0xbf, 0x18, 0x51, 0x0d, 0x94, 0x8e, 0xc4, 0x26, 0xb6, 0xbd, 0xef, 0x24, 0x31, 0xbc,
0xd8, 0x57, 0x96, 0x18, 0x5e, 0xfc, 0xe3, 0x0a, 0x9f, 0x42, 0x7f, 0x82, 0xad, 0x23, 0xb1, 0x66,
0x62, 0xd9, 0xc6, 0x91, 0xef, 0x6c, 0x28, 0xf6, 0xab, 0xc1, 0x84, 0xaf, 0x7c, 0xbb, 0xfc, 0x55,
0x2c, 0xfe, 0x0a, 0xbf, 0x86, 0x02, 0xfd, 0x72, 0xd8, 0xa1, 0x45, 0x8f, 0x98, 0x56, 0xc2, 0x9f,
0x47, 0xe3, 0xe2, 0x23, 0x43, 0x7c, 0xea, 0xd3, 0x34, 0x6a, 0x42, 0xa1, 0xa1, 0x9c, 0xf9, 0x5f,
0x8e, 0xae, 0x8a, 0x1f, 0x57, 0x8c, 0xf1, 0x29, 0xd4, 0x06, 0xc4, 0x02, 0x52, 0xe4, 0x87, 0x06,
0x8b, 0x3f, 0x2d, 0xef, 0x6e, 0x27, 0x7f, 0xde, 0xe6, 0x53, 0xe8, 0x1b, 0x28, 0x36, 0xb1, 0x1d,
0x7c, 0x16, 0x4f, 0xb2, 0xd7, 0xc5, 0xb3, 0x8f, 0x60, 0x9b, 0x89, 0xc3, 0x27, 0xd6, 0xce, 0x58,
0xc9, 0xe4, 0xed, 0x70, 0x04, 0xd8, 0xa0, 0x41, 0xf1, 0x44, 0x3b, 0x0d, 0xce, 0xf3, 0x61, 0x8c,
0x7d, 0xd1, 0xaf, 0x39, 0x16, 0x5e, 0x81, 0x5b, 0xfe, 0x85, 0x15, 0xc1, 0xbd, 0x4a, 0xee, 0x8b,
0x65, 0x48, 0x11, 0xcb, 0xe1, 0xfb, 0xea, 0xc6, 0xa0, 0x8b, 0xcf, 0xdd, 0x21, 0x88, 0xc1, 0x5d,
0x75, 0x63, 0xc4, 0xe4, 0x13, 0x1f, 0xc3, 0xdd, 0xc8, 0x65, 0xf5, 0x8e, 0x70, 0x3d, 0xa6, 0xdc,
0x84, 0xad, 0xdd, 0xf2, 0xba, 0x92, 0xe0, 0x11, 0xdb, 0xda, 0xe2, 0x4a, 0xf0, 0x0d, 0xab, 0xca,
0x0b, 0x76, 0x6c, 0xc0, 0x87, 0x4d, 0x6c, 0x57, 0x26, 0x93, 0xeb, 0x8b, 0xd9, 0x49, 0x47, 0xd8,
0x8f, 0x56, 0xe2, 0xae, 0xc3, 0xe0, 0x53, 0x68, 0x02, 0x4f, 0x43, 0x29, 0xf6, 0xe2, 0xd5, 0xae,
0x12, 0xfe, 0x0d, 0x8f, 0xcc, 0xa7, 0x90, 0xe2, 0x3e, 0x3d, 0x16, 0xaf, 0x93, 0x5c, 0x26, 0x7f,
0x2b, 0xb7, 0xf9, 0x01, 0x78, 0xdf, 0x6d, 0x7e, 0xee, 0x03, 0xfd, 0x16, 0xde, 0x0f, 0x3b, 0xd4,
0xed, 0x96, 0x4b, 0x3e, 0x06, 0x85, 0x0e, 0x3c, 0xeb, 0xa7, 0x84, 0xfe, 0x03, 0xbc, 0x17, 0xf8,
0xc5, 0xdb, 0x59, 0xd8, 0x0d, 0x9c, 0x44, 0x80, 0x7b, 0x21, 0x93, 0x9a, 0xfb, 0xd3, 0xc3, 0xf5,
0xe9, 0x49, 0x7c, 0x0a, 0x75, 0x3c, 0xf7, 0x95, 0x1d, 0x1f, 0x13, 0xf0, 0x6c, 0x22, 0x2b, 0xf1,
0x7c, 0x20, 0xce, 0x75, 0xfd, 0x02, 0xbf, 0x87, 0xbb, 0xc9, 0x0b, 0x54, 0x54, 0xf5, 0x9d, 0xc1,
0xff, 0xe8, 0x15, 0x80, 0xe6, 0x77, 0x3f, 0x35, 0xce, 0xdf, 0x7d, 0xf3, 0x91, 0xd7, 0x77, 0x7c,
0xfc, 0xd6, 0x7a, 0xec, 0xc0, 0x16, 0x45, 0x9c, 0xd3, 0xe0, 0x35, 0xdb, 0x4d, 0xb6, 0xb9, 0x11,
0xbc, 0x17, 0xf6, 0x94, 0x45, 0x7a, 0xbc, 0xca, 0x98, 0x6f, 0x20, 0xe7, 0x47, 0x57, 0xad, 0x41,
0x54, 0xf9, 0x4e, 0xf8, 0x7d, 0xa2, 0xc7, 0xc0, 0x25, 0xe7, 0x04, 0xf3, 0xf6, 0x9e, 0xf8, 0x3d,
0xec, 0x9c, 0xc8, 0x9a, 0x9d, 0xf4, 0xeb, 0xec, 0x6b, 0xff, 0xf8, 0xb0, 0x00, 0xb2, 0x0d, 0x77,
0x8e, 0x34, 0x13, 0xcf, 0xfd, 0x04, 0xf5, 0xaa, 0x9f, 0xc6, 0x2f, 0x80, 0xfa, 0x06, 0x72, 0xf5,
0x6a, 0x55, 0x56, 0xde, 0x38, 0xb3, 0x5b, 0x9c, 0xed, 0x5b, 0xc8, 0xd7, 0xab, 0x02, 0xb6, 0x88,
0xac, 0x6e, 0x95, 0x0b, 0x6c, 0x06, 0x46, 0xed, 0xbf, 0x19, 0x6e, 0x6d, 0xcd, 0x91, 0x97, 0x6b,
0xf0, 0xe3, 0xeb, 0x77, 0xf0, 0x8e, 0x3b, 0x01, 0x9e, 0x27, 0xa5, 0xdb, 0xa2, 0x8d, 0x56, 0xe8,
0x7f, 0xa8, 0x3f, 0xff, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xef, 0x93, 0x7d, 0xae, 0x51, 0x3d,
0x00, 0x00,
// 4783 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5b, 0x49, 0x73, 0x23, 0x47,
0x76, 0xc6, 0xc2, 0x05, 0x78, 0x00, 0xc8, 0x62, 0x76, 0x93, 0x44, 0xb3, 0xf7, 0x9a, 0x96, 0xd4,
0x43, 0x8d, 0x28, 0x89, 0x6a, 0xb5, 0x5a, 0x1a, 0xc9, 0x1a, 0x6c, 0x04, 0xd0, 0x0d, 0x02, 0x50,
0x16, 0xd0, 0xd4, 0x2c, 0x76, 0x4d, 0xb1, 0x2a, 0x09, 0x96, 0x1a, 0xa8, 0x82, 0x6b, 0x21, 0x45,
0x1f, 0x26, 0xc2, 0x13, 0xe1, 0x88, 0x39, 0xf8, 0xee, 0x5f, 0x61, 0xdf, 0x1c, 0xfe, 0x4d, 0xbe,
0x4c, 0xcc, 0xc5, 0x17, 0x5f, 0xec, 0xc8, 0xcc, 0x5a, 0x81, 0x02, 0xc9, 0x66, 0x4b, 0xb7, 0xcc,
0x97, 0x2f, 0xbf, 0xcc, 0x7c, 0x5b, 0xbe, 0x7c, 0x05, 0x00, 0x8c, 0xac, 0xa9, 0xba, 0x37, 0xb5,
0x4c, 0xc7, 0x44, 0x85, 0xfe, 0xb3, 0x73, 0xa3, 0xff, 0xa9, 0x4c, 0x49, 0xe2, 0x3f, 0xa7, 0xe1,
0x61, 0x75, 0xec, 0x12, 0xc7, 0x34, 0x9d, 0x53, 0x4c, 0xfe, 0xd1, 0x25, 0xb6, 0x23, 0x11, 0xc7,
0xd1, 0x8d, 0x91, 0x2d, 0x39, 0xa6, 0xa5, 0x8c, 0x08, 0x12, 0xa1, 0x38, 0x20, 0x93, 0xe9, 0x58,
0x71, 0x48, 0x57, 0x99, 0x90, 0x72, 0xfa, 0x51, 0xfa, 0x69, 0x1e, 0xc7, 0x68, 0xe8, 0x2b, 0xc8,
0xd9, 0xde, 0xb4, 0x72, 0xe6, 0x51, 0xfa, 0x69, 0x61, 0xff, 0xc1, 0x5e, 0x64, 0x9d, 0xbd, 0x60,
0x0d, 0x1f, 0x1c, 0x07, 0xfc, 0xe2, 0xbf, 0xa4, 0x61, 0x63, 0x6e, 0x1c, 0xfd, 0x1a, 0x32, 0xaa,
0xce, 0xd6, 0x2a, 0xec, 0x7f, 0x98, 0x8c, 0x55, 0x33, 0x0d, 0xc7, 0x32, 0xc7, 0x63, 0x62, 0xb5,
0x8d, 0x13, 0xd3, 0x9a, 0x28, 0x8e, 0x6e, 0x1a, 0x38, 0xa3, 0xea, 0xe8, 0x33, 0xc8, 0x28, 0xfe,
0x46, 0x7e, 0x91, 0x3c, 0xb9, 0x32, 0x22, 0x46, 0x70, 0x54, 0x9c, 0x51, 0x6c, 0x71, 0x17, 0xb6,
0x92, 0x47, 0x91, 0x00, 0xd9, 0xa9, 0x6e, 0x78, 0x07, 0xa7, 0x4d, 0xf1, 0x7f, 0xd3, 0xb0, 0x1d,
0x30, 0x77, 0x89, 0x73, 0x6e, 0x5a, 0x6f, 0x24, 0x62, 0x9d, 0xe9, 0x2a, 0x41, 0xcf, 0x60, 0xcb,
0x22, 0x23, 0xdd, 0x76, 0x88, 0x25, 0x9b, 0x96, 0xec, 0x1a, 0x7e, 0x8f, 0x01, 0xe4, 0xf0, 0x6d,
0xbf, 0xdf, 0xb3, 0x86, 0xc1, 0x18, 0xda, 0x85, 0x0d, 0x9b, 0x58, 0x67, 0x7c, 0x8e, 0x6a, 0x1a,
0x06, 0x51, 0x1d, 0x76, 0x82, 0x1c, 0x5e, 0xe7, 0x03, 0x3d, 0xab, 0xc6, 0xc9, 0xe8, 0x6b, 0x58,
0x72, 0x2e, 0xa6, 0xa4, 0x9c, 0x7d, 0x94, 0x7e, 0xba, 0xb6, 0xff, 0x34, 0xf9, 0x80, 0xf1, 0x5d,
0x0d, 0x2e, 0xa6, 0x04, 0xb3, 0x59, 0xe8, 0x01, 0x14, 0x26, 0x8a, 0x4a, 0x97, 0x31, 0xa8, 0x3a,
0x97, 0xd8, 0xa9, 0xf2, 0x13, 0x45, 0xed, 0x59, 0x4c, 0x97, 0x0f, 0xa1, 0x70, 0x6c, 0xe9, 0xda,
0x88, 0xf0, 0xf1, 0x65, 0x36, 0x0e, 0x9c, 0x44, 0x19, 0xc4, 0xff, 0x5e, 0x82, 0xbb, 0x09, 0x4a,
0x08, 0xc4, 0x55, 0x86, 0xd5, 0xa9, 0x79, 0x4e, 0x2c, 0xa2, 0x79, 0x27, 0xf6, 0xbb, 0xe8, 0x11,
0x14, 0xbc, 0xa3, 0x29, 0xc7, 0x63, 0xe2, 0x1d, 0x2f, 0x4a, 0x42, 0xbf, 0x04, 0xe1, 0x44, 0xb1,
0x1d, 0x39, 0xca, 0x96, 0xe5, 0x52, 0xa0, 0xf4, 0x5a, 0x84, 0x55, 0x84, 0xa2, 0xa6, 0xdb, 0xaa,
0x79, 0x46, 0x2c, 0xc6, 0xb6, 0xc4, 0xd8, 0x62, 0x34, 0xb4, 0x03, 0xb9, 0x63, 0xd3, 0xd0, 0xd8,
0xf8, 0x32, 0x1b, 0x0f, 0xfa, 0x68, 0x0f, 0x6e, 0x8d, 0x75, 0xe3, 0x8d, 0x3c, 0x26, 0x67, 0x64,
0x2c, 0xdb, 0x44, 0x75, 0x2d, 0xdd, 0xb9, 0x28, 0xaf, 0x30, 0xb6, 0x0d, 0x3a, 0xd4, 0xa1, 0x23,
0x92, 0x37, 0x80, 0xf6, 0x61, 0x93, 0x31, 0x11, 0xd9, 0xd6, 0x27, 0xd3, 0x31, 0x91, 0xa7, 0x8a,
0x6e, 0xe9, 0xc6, 0xa8, 0xbc, 0xca, 0x66, 0xdc, 0xe2, 0x83, 0x12, 0x1b, 0xeb, 0xf3, 0x21, 0xb4,
0x09, 0x2b, 0xc7, 0x96, 0x4c, 0x34, 0xab, 0x9c, 0x63, 0x4c, 0xcb, 0xc7, 0x56, 0x43, 0xb3, 0xd0,
0x7d, 0x80, 0x53, 0x7d, 0x74, 0x2a, 0xdb, 0x53, 0x42, 0xb4, 0x72, 0x9e, 0x0d, 0xe5, 0x29, 0x45,
0xa2, 0x04, 0x3a, 0x3c, 0x36, 0xcf, 0x65, 0x62, 0x10, 0x6b, 0x74, 0x51, 0x06, 0x3e, 0x3c, 0x36,
0xcf, 0x1b, 0x8c, 0x40, 0xa5, 0xa8, 0x68, 0x67, 0xc4, 0x72, 0x74, 0x9b, 0x2e, 0x5f, 0xe0, 0x52,
0x8c, 0x90, 0xd0, 0x47, 0x80, 0xbc, 0xad, 0x7a, 0x72, 0xd4, 0x4d, 0xc3, 0x2e, 0x17, 0xf9, 0xc9,
0xf8, 0x48, 0x2d, 0x1c, 0xa0, 0xeb, 0x69, 0xe4, 0xd8, 0x1d, 0xc9, 0x6f, 0xc8, 0x85, 0x5d, 0x2e,
0xf1, 0xf5, 0x18, 0xe5, 0x15, 0xb9, 0xe0, 0xfa, 0xb4, 0xf4, 0x33, 0x45, 0xbd, 0x28, 0xaf, 0x79,
0xfa, 0xe4, 0x5d, 0xf4, 0x25, 0x94, 0xd5, 0x40, 0xff, 0x74, 0xad, 0x13, 0x7d, 0xe4, 0x5a, 0xcc,
0x0f, 0xcb, 0xeb, 0x8c, 0x75, 0x3b, 0x1c, 0xaf, 0x45, 0x87, 0xd1, 0x7b, 0xb0, 0x66, 0x3b, 0x8a,
0xa3, 0xab, 0xb2, 0xa2, 0x69, 0x16, 0xb1, 0xed, 0xb2, 0xc0, 0x26, 0x94, 0x38, 0xb5, 0xc2, 0x89,
0xe2, 0x5f, 0x97, 0xe0, 0xc1, 0xe5, 0x0e, 0x4f, 0xb7, 0xe7, 0x43, 0x50, 0x73, 0x2b, 0x62, 0xbf,
0x8b, 0x3e, 0x84, 0x8d, 0x63, 0x7f, 0xae, 0x7c, 0x46, 0x2c, 0x9b, 0xee, 0x8b, 0x1a, 0x5d, 0x09,
0x0b, 0xc1, 0xc0, 0x6b, 0x4e, 0xa7, 0xe6, 0x34, 0x51, 0x0c, 0xf7, 0x44, 0x51, 0x1d, 0xd7, 0x22,
0x16, 0xb3, 0xba, 0x12, 0x8e, 0xd1, 0xd0, 0x11, 0x20, 0xdb, 0x9d, 0x4e, 0x4d, 0xcb, 0x21, 0x9a,
0x1c, 0x04, 0xbc, 0x25, 0x16, 0x67, 0x9e, 0x5e, 0x15, 0xa4, 0x82, 0x60, 0xb3, 0x11, 0x60, 0x04,
0x2e, 0x23, 0x81, 0xa0, 0xba, 0x96, 0x45, 0x0c, 0x27, 0x84, 0x5d, 0x7e, 0x4b, 0xd8, 0x75, 0x0f,
0x21, 0x00, 0x7d, 0x1f, 0xd6, 0xd5, 0xb1, 0x62, 0xdb, 0xb2, 0x79, 0x22, 0x6b, 0x84, 0x46, 0x01,
0x66, 0xdc, 0x45, 0x5c, 0x62, 0xe4, 0xde, 0x49, 0x9d, 0x11, 0x11, 0x82, 0x25, 0xe6, 0xe9, 0xab,
0xcc, 0xd3, 0x59, 0x9b, 0x9a, 0x84, 0x7d, 0x6a, 0x5a, 0x0e, 0x8f, 0x01, 0x39, 0x1e, 0x23, 0x18,
0x85, 0xc5, 0x88, 0xc7, 0x50, 0xd4, 0x6d, 0x59, 0x39, 0x53, 0xf4, 0x31, 0xf3, 0x2d, 0x6e, 0xc2,
0x05, 0xdd, 0xae, 0xf8, 0x24, 0xf4, 0x6b, 0xd8, 0xb1, 0x79, 0xec, 0x91, 0x0d, 0x1e, 0x8a, 0x64,
0x2f, 0xc0, 0x19, 0xca, 0xd4, 0x33, 0xea, 0x6d, 0x8f, 0x23, 0x12, 0xab, 0x88, 0xd5, 0x55, 0xa6,
0xe8, 0x1b, 0xb8, 0xbb, 0x60, 0xf2, 0x54, 0x31, 0x5c, 0xcf, 0xe4, 0xcb, 0x49, 0xb3, 0xfb, 0x8a,
0xe1, 0xa2, 0x2f, 0xe1, 0xce, 0x82, 0xe9, 0x23, 0xc3, 0x73, 0x83, 0xad, 0xa4, 0xc9, 0x4d, 0x43,
0xfc, 0x01, 0x84, 0x81, 0xa5, 0x8f, 0x46, 0xc4, 0xaa, 0x30, 0xef, 0x90, 0x88, 0x83, 0xaa, 0xb0,
0x16, 0xa3, 0x51, 0x43, 0xcb, 0x3e, 0x2d, 0xec, 0xef, 0xc4, 0x74, 0x13, 0x63, 0xc1, 0x33, 0x33,
0xa8, 0x90, 0xd9, 0xed, 0x99, 0xe1, 0x42, 0x66, 0x81, 0xf4, 0xdf, 0x01, 0x4a, 0x31, 0x36, 0xb4,
0x06, 0x19, 0x9d, 0x47, 0xcd, 0x12, 0xce, 0xe8, 0x1a, 0xb5, 0x6d, 0xd3, 0x20, 0xd2, 0xa9, 0xe9,
0xdf, 0x05, 0x7e, 0x97, 0x46, 0x36, 0xdd, 0xa6, 0xb3, 0xce, 0xfc, 0x00, 0x19, 0xf4, 0xd1, 0x3d,
0xc8, 0xeb, 0x93, 0x89, 0xeb, 0x44, 0xc2, 0x62, 0x48, 0x40, 0x1d, 0x58, 0xf3, 0xce, 0x2e, 0x39,
0x0a, 0xb5, 0x42, 0xcf, 0xd2, 0xc4, 0xa4, 0xd3, 0x48, 0x31, 0xce, 0x56, 0x0a, 0xcf, 0xcc, 0x45,
0xdf, 0x03, 0x72, 0xed, 0xe3, 0xa6, 0xa2, 0x8d, 0x88, 0x1f, 0x9d, 0x89, 0xc6, 0xec, 0xac, 0xb0,
0xff, 0x7e, 0x12, 0xe2, 0x50, 0xaa, 0xce, 0x70, 0xb7, 0x52, 0x38, 0x01, 0x03, 0x29, 0xb0, 0x19,
0x50, 0xeb, 0x34, 0xa8, 0xfb, 0xe0, 0xab, 0x0c, 0xfc, 0x97, 0x97, 0x82, 0x47, 0x27, 0xb4, 0x52,
0x38, 0x19, 0x09, 0xb5, 0xa1, 0x74, 0xae, 0x9f, 0xe8, 0x95, 0xbe, 0x2f, 0x89, 0x1c, 0x83, 0x7e,
0x9c, 0x04, 0x7d, 0x14, 0x65, 0x6c, 0xa5, 0x70, 0x7c, 0x26, 0x95, 0x03, 0x25, 0x04, 0xdb, 0xaf,
0xd8, 0x92, 0xa3, 0x30, 0xbf, 0x58, 0x20, 0x87, 0xa3, 0x39, 0x6e, 0x2a, 0x87, 0x79, 0x0c, 0x96,
0x5b, 0xd9, 0xa7, 0x1d, 0x73, 0xa4, 0x1b, 0xcc, 0x6d, 0x0a, 0xfb, 0xf7, 0x12, 0x35, 0x25, 0xb5,
0x18, 0x4f, 0x2b, 0x85, 0x03, 0x7e, 0x84, 0x41, 0xd0, 0x4e, 0xd5, 0x69, 0x87, 0x28, 0x36, 0x69,
0x5a, 0x8a, 0x41, 0xcf, 0x58, 0x60, 0x18, 0x4f, 0x92, 0x30, 0xea, 0xad, 0x5a, 0x3f, 0xca, 0xdb,
0x4a, 0xe1, 0xb9, 0xf9, 0xe8, 0x00, 0x8a, 0x23, 0xcb, 0x74, 0xa7, 0x98, 0xa8, 0x84, 0x5a, 0x5f,
0x91, 0xe1, 0x3d, 0x4a, 0xc2, 0x6b, 0x46, 0xf8, 0x5a, 0x29, 0x1c, 0x9b, 0x87, 0x86, 0xb0, 0x11,
0xed, 0x1f, 0xba, 0x63, 0x47, 0x67, 0x97, 0x4f, 0x61, 0xff, 0xbd, 0xab, 0xc0, 0x18, 0x73, 0x2b,
0x85, 0xe7, 0x11, 0xd0, 0x33, 0x58, 0x19, 0x4d, 0x75, 0xb3, 0x6d, 0xb0, 0xcb, 0x6a, 0x81, 0x93,
0x36, 0xfb, 0xed, 0x5e, 0x9b, 0x8a, 0xca, 0xe3, 0x45, 0x75, 0x80, 0x63, 0xc5, 0x3e, 0x95, 0x54,
0x4b, 0x9f, 0x3a, 0xec, 0xee, 0x9a, 0x75, 0x08, 0x2f, 0x1c, 0x50, 0x75, 0x57, 0x03, 0xce, 0x56,
0x1a, 0x47, 0xe6, 0xa1, 0x0a, 0xe4, 0x4f, 0x75, 0xcd, 0x03, 0x11, 0x12, 0x6c, 0x29, 0x02, 0xd2,
0x6a, 0xd7, 0x03, 0x8c, 0x70, 0x16, 0x52, 0x61, 0x4b, 0x23, 0xd3, 0xb1, 0x79, 0xe1, 0x87, 0x71,
0x3f, 0xcf, 0x2e, 0x6f, 0x24, 0x98, 0x3d, 0xc7, 0xab, 0x27, 0x4e, 0x68, 0xa5, 0xf1, 0x02, 0x28,
0xb4, 0x0b, 0xd9, 0xb1, 0x39, 0x2a, 0x23, 0x86, 0xb8, 0x95, 0x80, 0xd8, 0x31, 0x47, 0xad, 0x34,
0xa6, 0x4c, 0xe8, 0x39, 0xac, 0x52, 0x19, 0xf5, 0x5c, 0xa7, 0x7c, 0x2b, 0x41, 0xa0, 0x9c, 0x9f,
0xca, 0xb3, 0xe7, 0xd2, 0xa3, 0xf8, 0xcc, 0xe8, 0x6b, 0xc8, 0x33, 0xe5, 0x48, 0xc4, 0xd0, 0xca,
0xb7, 0x13, 0xec, 0xd6, 0x9b, 0xe9, 0xf3, 0x50, 0x31, 0x04, 0x13, 0xaa, 0x79, 0x58, 0xf5, 0x54,
0x55, 0xcd, 0xc1, 0x0a, 0x67, 0x15, 0xb7, 0x61, 0x33, 0x31, 0x2c, 0x89, 0x77, 0xe1, 0xce, 0xc2,
0xe8, 0x22, 0x3e, 0x80, 0x7b, 0x97, 0x45, 0x07, 0x71, 0x0b, 0x6e, 0x27, 0xb9, 0x78, 0x04, 0x74,
0xde, 0x55, 0xc5, 0x8f, 0x61, 0x7d, 0xc6, 0xef, 0x68, 0xd4, 0x1d, 0xd3, 0xc6, 0xd0, 0xf6, 0x52,
0xfd, 0x3c, 0x0e, 0x09, 0xe2, 0x1d, 0xd8, 0x5e, 0xe0, 0x64, 0x62, 0x1b, 0x6e, 0x25, 0x98, 0x38,
0xc5, 0x63, 0xf2, 0x88, 0x3c, 0xba, 0x42, 0x02, 0xba, 0x0d, 0xcb, 0x67, 0xca, 0xd8, 0xe5, 0x17,
0xca, 0x32, 0xe6, 0x1d, 0xf1, 0x2f, 0x69, 0x28, 0x2f, 0x72, 0x97, 0x2b, 0x00, 0xb7, 0x60, 0x85,
0x61, 0xd8, 0xe5, 0xec, 0xa3, 0xec, 0xd3, 0x65, 0xec, 0xf5, 0xd0, 0x73, 0xef, 0xb1, 0xb1, 0xc4,
0x1e, 0x1b, 0x71, 0x9f, 0x98, 0x5b, 0x23, 0x7c, 0x66, 0x88, 0xff, 0x95, 0x0e, 0x2e, 0x37, 0xee,
0x6d, 0x68, 0x8f, 0x5b, 0x52, 0xd7, 0x9d, 0xb0, 0xd5, 0xd7, 0xf6, 0x6f, 0xc7, 0xc1, 0xfa, 0xed,
0x5e, 0xd7, 0x9d, 0x60, 0x9f, 0x09, 0x7d, 0x03, 0x30, 0x75, 0xc7, 0xe3, 0xe1, 0xb4, 0x6e, 0x9e,
0xf3, 0xbc, 0x6d, 0x6d, 0xff, 0xfe, 0xdc, 0x94, 0xb6, 0xd1, 0x0f, 0x98, 0x70, 0x64, 0x02, 0xfa,
0x02, 0x80, 0x3b, 0x77, 0x43, 0x1b, 0xf9, 0x6f, 0xa5, 0xed, 0x84, 0xe9, 0x74, 0x18, 0x47, 0x58,
0xc5, 0x2f, 0x60, 0x33, 0xd1, 0xd9, 0xd1, 0x03, 0x00, 0x9b, 0xb5, 0x22, 0x12, 0x8c, 0x50, 0xc4,
0xe7, 0x70, 0x3b, 0xc9, 0xc1, 0xaf, 0x9c, 0xf7, 0x3f, 0x69, 0xb8, 0x77, 0x99, 0x27, 0xd3, 0xdc,
0xd4, 0x49, 0x78, 0x82, 0x47, 0x69, 0xe8, 0xa5, 0xa7, 0x27, 0x2e, 0xa7, 0xe7, 0xd7, 0x0e, 0x13,
0x7b, 0x7e, 0x23, 0xa2, 0x3b, 0x12, 0x3e, 0xf9, 0x29, 0x15, 0x6d, 0x40, 0xe9, 0x60, 0xd8, 0xe9,
0xc8, 0x52, 0x63, 0x30, 0x68, 0x77, 0x9b, 0x92, 0x90, 0x42, 0x05, 0x58, 0xed, 0x36, 0x06, 0x47,
0x3d, 0xfc, 0x4a, 0x48, 0xa3, 0x1c, 0x2c, 0x1d, 0xb5, 0x0f, 0xda, 0x42, 0x06, 0xad, 0x42, 0x76,
0x28, 0x55, 0x85, 0x2c, 0x2a, 0x41, 0xbe, 0xda, 0x19, 0x36, 0x06, 0xbd, 0xde, 0xa0, 0x25, 0x2c,
0xa1, 0x5b, 0xb0, 0x3e, 0xc0, 0xed, 0x66, 0xb3, 0x81, 0xe5, 0x4a, 0x6d, 0xd0, 0xee, 0x75, 0x25,
0x61, 0x59, 0x2c, 0x40, 0x3e, 0x08, 0x37, 0xe2, 0x14, 0x4a, 0xb1, 0x58, 0xf2, 0xd6, 0xe6, 0xf2,
0x71, 0xd4, 0x23, 0xd6, 0xf6, 0xef, 0xcc, 0x71, 0xf7, 0x5c, 0xe7, 0x35, 0x65, 0xf0, 0x9d, 0xa5,
0x01, 0xeb, 0x33, 0x31, 0xe8, 0x46, 0x3e, 0x77, 0x0e, 0x3b, 0x34, 0x40, 0xbc, 0x43, 0xf5, 0xe4,
0xf3, 0xb9, 0xea, 0x49, 0x7c, 0xf3, 0x47, 0xfa, 0x81, 0x9e, 0x50, 0x38, 0xf9, 0xb7, 0x2c, 0x14,
0xa3, 0x43, 0x41, 0x22, 0x9f, 0x8e, 0x24, 0xf2, 0x3b, 0x90, 0xd3, 0x74, 0x9b, 0x26, 0x7e, 0x9a,
0x97, 0x42, 0x06, 0x7d, 0x6a, 0x97, 0x16, 0x19, 0xb9, 0x63, 0xc5, 0x31, 0xad, 0x0b, 0xe6, 0x21,
0x79, 0x1c, 0xa1, 0xa0, 0x6f, 0xa1, 0x48, 0x73, 0x63, 0xdd, 0x18, 0xc9, 0x13, 0x53, 0xf3, 0x43,
0xc0, 0xbd, 0xb9, 0xbd, 0x1d, 0x71, 0xa6, 0x43, 0x53, 0x23, 0xb8, 0x70, 0x1e, 0x76, 0xd0, 0x73,
0xc8, 0x2b, 0xae, 0x73, 0xca, 0x67, 0x2f, 0x27, 0xa8, 0x85, 0xce, 0xae, 0xb8, 0xce, 0x29, 0x9b,
0x9a, 0x53, 0xbc, 0x16, 0x4d, 0x7b, 0xd5, 0x53, 0xc5, 0x30, 0xc8, 0x98, 0x65, 0x92, 0x25, 0xec,
0x77, 0xd1, 0x1e, 0xac, 0x28, 0x53, 0xb9, 0x2a, 0x49, 0x5e, 0x16, 0xb8, 0x3d, 0x07, 0x57, 0x95,
0xa4, 0xda, 0xc9, 0x08, 0x2f, 0x2b, 0xd3, 0xaa, 0x24, 0xa1, 0x6f, 0xe9, 0x1b, 0x48, 0xa7, 0xef,
0xaa, 0xaa, 0x24, 0xc9, 0x63, 0xdd, 0x76, 0xca, 0x39, 0x96, 0xbb, 0x2f, 0x9c, 0x58, 0xe2, 0xfc,
0x55, 0x49, 0xea, 0xe8, 0xb6, 0x83, 0xee, 0xb2, 0x2b, 0x9d, 0xc8, 0xb6, 0xad, 0xfb, 0x2f, 0xf5,
0x1c, 0x25, 0x48, 0xb6, 0xae, 0xd1, 0x98, 0x69, 0x90, 0x1f, 0x27, 0xa6, 0xe1, 0x3d, 0x9a, 0xbd,
0x9e, 0xf8, 0x1f, 0x69, 0xc8, 0x33, 0xcd, 0x38, 0xd4, 0x7b, 0xf7, 0x60, 0x89, 0x09, 0x80, 0x5b,
0xf1, 0xce, 0xbc, 0x6a, 0x29, 0x17, 0x93, 0x00, 0xe3, 0x8b, 0x9e, 0x3e, 0x13, 0x3f, 0x3d, 0x82,
0x25, 0xb6, 0x0f, 0xae, 0x2a, 0xd6, 0x46, 0x35, 0x98, 0x7d, 0xf8, 0x79, 0x0f, 0xd2, 0x4b, 0x6c,
0x68, 0x76, 0x86, 0xb8, 0x0f, 0x10, 0x8a, 0x80, 0x2e, 0x23, 0x49, 0xed, 0xba, 0x6f, 0x47, 0xb4,
0x8d, 0x04, 0xc8, 0xf6, 0xa5, 0x57, 0xde, 0xf3, 0x85, 0x36, 0xc5, 0xc7, 0x50, 0x92, 0x1c, 0x8b,
0xaa, 0x9a, 0xd8, 0x36, 0x35, 0x75, 0x01, 0xb2, 0x13, 0x7b, 0xe4, 0x97, 0xc9, 0x26, 0xf6, 0x48,
0xfc, 0x04, 0x50, 0x8c, 0xa5, 0x62, 0x59, 0xca, 0x05, 0x35, 0xc9, 0x89, 0x3d, 0x62, 0x6d, 0xf6,
0x90, 0xca, 0xe3, 0xa0, 0x2f, 0xee, 0x41, 0xb1, 0x71, 0x46, 0x0c, 0xc7, 0xf3, 0x26, 0x6a, 0xa2,
0x54, 0x69, 0xc4, 0xa0, 0x71, 0x88, 0x41, 0x67, 0x71, 0x84, 0x22, 0x2a, 0x00, 0x8c, 0x9f, 0x39,
0x36, 0xda, 0x81, 0x55, 0xc7, 0x66, 0x0b, 0xf2, 0x5d, 0xb4, 0x52, 0xd8, 0x27, 0xa0, 0x2d, 0x58,
0x76, 0x8e, 0x4d, 0x93, 0xcb, 0x34, 0xd7, 0x4a, 0x61, 0xde, 0x45, 0x65, 0x58, 0x71, 0x74, 0xc3,
0x79, 0xfe, 0x8c, 0x49, 0x35, 0x4b, 0x73, 0x42, 0xde, 0xaf, 0x2e, 0x43, 0xf6, 0x4c, 0x19, 0x8b,
0x1d, 0x58, 0x66, 0x4b, 0x50, 0xb1, 0x38, 0xe1, 0x2e, 0x78, 0x31, 0xed, 0xe3, 0xe0, 0xd6, 0xcc,
0x24, 0x98, 0x55, 0xb8, 0x35, 0xff, 0x3a, 0x15, 0xff, 0x08, 0xb7, 0xa9, 0xef, 0xd7, 0x75, 0xab,
0x67, 0x1d, 0xe8, 0x63, 0xe2, 0x1f, 0x54, 0x80, 0xac, 0xa6, 0xfb, 0x79, 0x03, 0x6d, 0x52, 0xe3,
0x9a, 0x5a, 0xe4, 0x44, 0xff, 0xd1, 0x13, 0xba, 0xd7, 0xa3, 0x22, 0x31, 0x8d, 0xf1, 0xc5, 0x81,
0x39, 0xd6, 0xbc, 0x32, 0x45, 0x0e, 0x47, 0x28, 0xf4, 0xfa, 0x9a, 0x59, 0xc1, 0x9e, 0x9a, 0x86,
0x4d, 0xb8, 0xbb, 0xdb, 0xee, 0xd8, 0xe9, 0x2b, 0xce, 0xa9, 0x7f, 0x0d, 0x85, 0x14, 0xf1, 0x5f,
0xd3, 0xb0, 0x8e, 0x89, 0xa2, 0x45, 0xb7, 0xf5, 0x39, 0xac, 0x9c, 0xf0, 0x85, 0xd2, 0x09, 0xf7,
0x6f, 0x45, 0x55, 0x89, 0x6d, 0xeb, 0xc7, 0x63, 0xc2, 0xd7, 0xc6, 0x1e, 0x33, 0x55, 0xf1, 0x89,
0x3e, 0x26, 0x46, 0xf8, 0xe2, 0x0d, 0xfa, 0x34, 0x8a, 0xda, 0xf4, 0x7e, 0xe4, 0xf2, 0xc6, 0xbc,
0x43, 0xcf, 0x3f, 0x26, 0x06, 0x33, 0xdd, 0x2c, 0xa6, 0x4d, 0xb1, 0x0e, 0x42, 0xb8, 0x1b, 0xef,
0x08, 0xf7, 0x20, 0x6f, 0x11, 0x45, 0xab, 0x99, 0xae, 0xe1, 0x78, 0x7a, 0x08, 0x09, 0x54, 0x41,
0x9a, 0xe2, 0x28, 0x6c, 0xc5, 0x22, 0x66, 0x6d, 0xf1, 0x3f, 0xd3, 0x20, 0x1c, 0x59, 0xba, 0x43,
0x7e, 0xe6, 0x53, 0x6d, 0xd1, 0xc0, 0x34, 0xa5, 0xb9, 0x2e, 0xd7, 0x88, 0xd7, 0x63, 0x65, 0x25,
0xd7, 0x76, 0xba, 0xa6, 0xd3, 0xf8, 0x91, 0x46, 0x1f, 0xaf, 0x4a, 0x19, 0xa5, 0x05, 0xfb, 0x5e,
0x8e, 0xec, 0xfb, 0x3d, 0x58, 0xa7, 0x3b, 0x6e, 0x1b, 0x27, 0xa6, 0xbf, 0x6b, 0x04, 0x4b, 0xd3,
0x50, 0x73, 0xac, 0x2d, 0xfe, 0x09, 0x84, 0x90, 0xcd, 0x13, 0x52, 0xd2, 0x35, 0x40, 0x23, 0x87,
0xfe, 0x4f, 0x7c, 0xdb, 0x59, 0xcc, 0xda, 0x94, 0xc6, 0xe2, 0x12, 0xaf, 0x74, 0x05, 0xb1, 0x67,
0x62, 0x6a, 0x03, 0xdd, 0x2b, 0x0c, 0x67, 0xb1, 0xdf, 0xa5, 0x6a, 0xd3, 0xed, 0xba, 0x6e, 0x79,
0x75, 0x54, 0xde, 0x11, 0x7f, 0x07, 0x42, 0x90, 0xe7, 0x44, 0x7c, 0x96, 0x27, 0x37, 0x51, 0x3b,
0x0b, 0x29, 0xe8, 0x7d, 0x58, 0x73, 0xf4, 0x09, 0x31, 0x5d, 0x47, 0x22, 0xaa, 0x69, 0x68, 0xb6,
0x17, 0xe6, 0x66, 0xa8, 0xe2, 0x03, 0x28, 0x06, 0xd8, 0x2f, 0xcd, 0xe3, 0xd9, 0xe2, 0x88, 0xf8,
0x24, 0xb2, 0xf6, 0x4b, 0xf3, 0x98, 0x85, 0x6b, 0x01, 0xb2, 0xba, 0xc6, 0xeb, 0x33, 0x25, 0x4c,
0x9b, 0xe2, 0x6b, 0x28, 0xb7, 0xda, 0x75, 0xec, 0x1a, 0x86, 0x6e, 0x8c, 0x5e, 0x9a, 0xc7, 0x2c,
0xda, 0x62, 0x66, 0xf5, 0x11, 0xc4, 0x2c, 0x2b, 0xb7, 0x20, 0x58, 0x3a, 0x9b, 0xb4, 0x35, 0x5f,
0x4a, 0xb4, 0x4d, 0x15, 0x6b, 0x9b, 0xae, 0xa5, 0x12, 0x2f, 0xea, 0x7a, 0x3d, 0xf1, 0x4f, 0xb0,
0x1e, 0x39, 0x39, 0x83, 0xfb, 0x10, 0xb2, 0x3f, 0x98, 0xc7, 0xde, 0x47, 0x8b, 0x78, 0xf8, 0x8d,
0x6e, 0x14, 0x53, 0x2e, 0x2a, 0x25, 0xdd, 0x3e, 0xd0, 0x0d, 0xdd, 0x3e, 0x0d, 0xae, 0xe6, 0x08,
0x25, 0xf4, 0xd6, 0x97, 0xb6, 0x69, 0x84, 0x97, 0xb3, 0x4f, 0x11, 0xf7, 0xa0, 0xd0, 0x69, 0xd4,
0x83, 0xbb, 0xff, 0x21, 0x14, 0x8e, 0x59, 0x39, 0x5b, 0x0d, 0x7c, 0xa3, 0x84, 0x81, 0x91, 0x98,
0x73, 0x88, 0x3f, 0xc2, 0x9d, 0xa1, 0x54, 0x7d, 0x87, 0x2c, 0xe5, 0x8b, 0xb9, 0x2c, 0xe5, 0x6e,
0x3c, 0xc5, 0x62, 0x4f, 0xab, 0x84, 0x3c, 0xe5, 0xaf, 0xcb, 0xb0, 0x16, 0x1f, 0xa4, 0x66, 0x46,
0x0c, 0x9e, 0x94, 0x78, 0x9f, 0x08, 0xbc, 0x2e, 0x55, 0xe0, 0x99, 0xae, 0xf9, 0xf7, 0xcc, 0x99,
0xae, 0xf1, 0xaf, 0x2f, 0xfe, 0x9d, 0x47, 0x9b, 0x73, 0xa5, 0x5a, 0xfe, 0x09, 0x23, 0x5e, 0xaa,
0x65, 0x45, 0x6b, 0x53, 0x73, 0x55, 0xc7, 0xfb, 0x82, 0xe1, 0x77, 0x99, 0x42, 0x89, 0xa5, 0x2b,
0x3c, 0xb7, 0xa0, 0x0a, 0x65, 0x3d, 0xf4, 0x00, 0x0a, 0xae, 0x4d, 0xe4, 0x5a, 0xbd, 0x26, 0x37,
0x6a, 0x87, 0x5e, 0x55, 0x3f, 0xef, 0xda, 0xa4, 0x56, 0xaf, 0x35, 0x6a, 0x87, 0x34, 0x13, 0xa0,
0xe3, 0xb8, 0x5b, 0x6f, 0x4b, 0x5e, 0x39, 0x3f, 0xe7, 0xda, 0x84, 0xf5, 0xd1, 0x53, 0x10, 0xe8,
0x60, 0xab, 0x5d, 0x97, 0x5f, 0x35, 0x7e, 0x5b, 0xed, 0x55, 0x70, 0xdd, 0xcb, 0x16, 0xd6, 0x5c,
0x9b, 0xb4, 0xda, 0x75, 0x9f, 0x8a, 0x44, 0x28, 0xf9, 0x9c, 0x87, 0xbd, 0xa1, 0xd4, 0xf0, 0x4a,
0xa1, 0x05, 0xce, 0xc6, 0x48, 0xfe, 0x56, 0x28, 0x0f, 0xae, 0x1c, 0x79, 0xe5, 0xce, 0x3c, 0xe7,
0xc0, 0x95, 0x23, 0xb4, 0x0d, 0xab, 0x74, 0x7c, 0x78, 0x28, 0x79, 0xd5, 0xcc, 0x15, 0xd7, 0x26,
0xc3, 0x43, 0x09, 0xdd, 0x07, 0xa0, 0x03, 0x52, 0x03, 0xb7, 0x2b, 0x1d, 0xbf, 0x92, 0xef, 0xda,
0x84, 0x13, 0xd0, 0x4b, 0x58, 0xb3, 0x0c, 0x4d, 0xb7, 0xc3, 0x22, 0xf3, 0x5a, 0xc2, 0x37, 0xb2,
0xb8, 0xae, 0x1a, 0xce, 0x29, 0xb1, 0x0c, 0xe2, 0xe0, 0x12, 0x9b, 0x1a, 0xa8, 0xf0, 0x10, 0x04,
0x55, 0x53, 0x65, 0xa2, 0x4e, 0x42, 0xb4, 0xf5, 0xeb, 0xa3, 0xad, 0xa9, 0x9a, 0xda, 0x50, 0x27,
0x01, 0x5c, 0x05, 0x8a, 0xee, 0x24, 0xb2, 0x31, 0x21, 0xe1, 0x2b, 0x62, 0x1c, 0x6a, 0x78, 0x28,
0xe1, 0x82, 0x3b, 0x09, 0x77, 0xf4, 0x29, 0x6c, 0x6a, 0xe4, 0x4c, 0xa6, 0x71, 0x51, 0x3e, 0xd5,
0x35, 0xf9, 0x0d, 0xb9, 0x38, 0x36, 0x15, 0x4b, 0x63, 0x75, 0x8e, 0x3c, 0x46, 0x1a, 0x39, 0xa3,
0xf1, 0xa7, 0xa5, 0x6b, 0xaf, 0xbc, 0x11, 0xf4, 0x21, 0xa0, 0xd8, 0x94, 0x89, 0xe9, 0xda, 0x84,
0xd5, 0x39, 0xf2, 0x78, 0x3d, 0xe4, 0x3f, 0xa4, 0x64, 0xf4, 0x01, 0x08, 0x31, 0x66, 0x4b, 0x39,
0x67, 0x85, 0x8d, 0x3c, 0x2e, 0x85, 0xac, 0x58, 0x39, 0x17, 0xfb, 0xb0, 0x95, 0x7c, 0x6a, 0x96,
0x4d, 0x9a, 0xb6, 0xc3, 0xbe, 0x79, 0x78, 0x4e, 0x96, 0xa3, 0x84, 0x8a, 0xa6, 0x59, 0xe8, 0x0e,
0xe4, 0x28, 0x3e, 0x1b, 0xe3, 0xf6, 0xbf, 0xaa, 0x91, 0x33, 0x3a, 0x24, 0x7e, 0x03, 0x1b, 0x73,
0x87, 0xa7, 0x11, 0x59, 0xd5, 0x2c, 0x73, 0xe2, 0xb9, 0x10, 0xef, 0xd0, 0x18, 0x46, 0x2f, 0x25,
0xbf, 0xd0, 0x4c, 0xdb, 0xe2, 0x5f, 0xd2, 0xf0, 0x20, 0x90, 0xfc, 0xcd, 0x23, 0x40, 0x75, 0x2e,
0x02, 0xc4, 0x2b, 0x9b, 0xfe, 0x12, 0x6d, 0xc3, 0x21, 0xd6, 0x89, 0xa2, 0x92, 0x84, 0x60, 0x20,
0xc3, 0x63, 0xfe, 0x0e, 0x25, 0xda, 0x42, 0x76, 0xf4, 0x15, 0x2c, 0xb1, 0x54, 0x9d, 0x97, 0xd9,
0xaf, 0xbb, 0x08, 0x9b, 0x23, 0xfe, 0x39, 0x0b, 0x77, 0x16, 0x23, 0x27, 0xdd, 0x8d, 0xdf, 0x7a,
0xf7, 0x20, 0x7f, 0x37, 0x7e, 0x78, 0xbd, 0xd5, 0xf6, 0x22, 0x09, 0x3b, 0x0d, 0xe5, 0x53, 0xef,
0x8b, 0xd5, 0x33, 0x3f, 0x54, 0x87, 0x14, 0x9a, 0x37, 0x18, 0xc4, 0x99, 0x28, 0xf6, 0x9b, 0x67,
0x5e, 0xac, 0x0a, 0xfa, 0xd1, 0x48, 0xb8, 0x1c, 0x8f, 0x84, 0x3d, 0x40, 0xda, 0xa9, 0x3a, 0xe5,
0x5f, 0x26, 0x82, 0xdc, 0x9e, 0x57, 0xd6, 0x1f, 0xc6, 0x36, 0x59, 0x6f, 0xd5, 0xfa, 0x71, 0x36,
0x9c, 0x30, 0x15, 0x3d, 0x81, 0x92, 0xaf, 0x86, 0xb6, 0x31, 0xb4, 0x89, 0x17, 0xe2, 0xe2, 0x44,
0xb1, 0x06, 0x4b, 0xec, 0x0d, 0x06, 0xb0, 0x72, 0x58, 0xe9, 0x0e, 0x2b, 0x1d, 0x21, 0x85, 0xd6,
0xa1, 0x40, 0xd7, 0x90, 0x6b, 0x9d, 0x76, 0xa3, 0x3b, 0x10, 0xd2, 0x01, 0x41, 0x6a, 0xe0, 0xd7,
0x0d, 0x2c, 0x64, 0xe8, 0x73, 0x7f, 0xd8, 0x3d, 0xac, 0x74, 0x2b, 0xcd, 0x46, 0x5d, 0xc8, 0x8a,
0xff, 0x97, 0x05, 0x34, 0xbf, 0xab, 0x30, 0x9b, 0xef, 0x9b, 0x56, 0x70, 0x47, 0x85, 0x14, 0xf4,
0x14, 0xd6, 0x79, 0x2f, 0x10, 0xb7, 0x67, 0xc6, 0xb3, 0x64, 0x56, 0x6c, 0x23, 0x8a, 0xcd, 0xb2,
0x3a, 0x4f, 0xe2, 0x21, 0x01, 0xed, 0x82, 0x60, 0x98, 0x0e, 0x7d, 0x58, 0x9a, 0x96, 0xee, 0x28,
0xec, 0x23, 0x09, 0x4f, 0xbc, 0xe6, 0xe8, 0x68, 0x0f, 0x90, 0x66, 0x76, 0x4d, 0xa7, 0xaa, 0x1b,
0x5a, 0xb8, 0x2c, 0xd7, 0x45, 0xc2, 0x08, 0xcd, 0x5e, 0x54, 0x65, 0x3c, 0x3e, 0x56, 0xd4, 0x37,
0x5e, 0xa1, 0x97, 0x5f, 0x23, 0x33, 0x54, 0xf4, 0x0c, 0x56, 0x2c, 0xc5, 0x18, 0x11, 0xbb, 0xbc,
0xca, 0xac, 0xf8, 0xde, 0x02, 0x95, 0x61, 0xca, 0x84, 0x3d, 0x5e, 0x74, 0x00, 0xab, 0xe6, 0x94,
0x7f, 0x63, 0xe2, 0xef, 0xd4, 0x5f, 0x5d, 0xa1, 0xe9, 0xbd, 0x1e, 0x67, 0x6f, 0x18, 0x8e, 0x75,
0x81, 0xfd, 0xc9, 0xa8, 0x06, 0x05, 0xfe, 0x21, 0xb5, 0x65, 0xda, 0x8e, 0x5d, 0xce, 0x33, 0xac,
0xc7, 0x8b, 0xb0, 0x02, 0x4e, 0x1c, 0x9d, 0xb5, 0xf3, 0x15, 0x14, 0xa3, 0xe8, 0xf4, 0x26, 0x7e,
0x43, 0x2e, 0x3c, 0xbd, 0xd1, 0x66, 0xbc, 0x22, 0x92, 0xf7, 0x2a, 0x22, 0x5f, 0x65, 0x5e, 0xa4,
0x45, 0x13, 0xd6, 0x67, 0xce, 0xc8, 0x32, 0x1a, 0xda, 0xe8, 0x98, 0xe7, 0x41, 0x85, 0x34, 0x42,
0x09, 0xc6, 0x87, 0xd3, 0x29, 0xf1, 0x23, 0x60, 0x84, 0x12, 0xe8, 0x9c, 0x65, 0xa7, 0x51, 0x9d,
0x53, 0x82, 0xf8, 0x02, 0x6e, 0x27, 0x9d, 0x88, 0xbd, 0x4a, 0x15, 0x35, 0x78, 0x95, 0x2a, 0x2a,
0xcb, 0xfa, 0xa6, 0x1e, 0x7e, 0x46, 0x9f, 0x8a, 0xab, 0xb0, 0xdc, 0x98, 0x4c, 0x9d, 0x8b, 0xdd,
0x17, 0x91, 0xdf, 0x35, 0xcc, 0xff, 0x7c, 0x02, 0xad, 0x42, 0xb6, 0x5b, 0xe9, 0x0b, 0x29, 0x94,
0x83, 0xa5, 0x7e, 0xa5, 0x3b, 0x14, 0xd2, 0x68, 0x05, 0x32, 0xcd, 0xae, 0x90, 0xd9, 0x7d, 0x09,
0x9b, 0x89, 0xb5, 0x50, 0x54, 0x84, 0x9c, 0xd4, 0xf8, 0x6e, 0xd8, 0xe8, 0xd6, 0x1a, 0x42, 0x8a,
0x22, 0x54, 0xba, 0x75, 0x3e, 0xaf, 0x47, 0xdd, 0x06, 0xc1, 0x5a, 0xe3, 0xfb, 0x4a, 0x6d, 0x20,
0x07, 0x4c, 0xd9, 0xdd, 0x8f, 0x40, 0x98, 0xad, 0x6b, 0x52, 0xfe, 0xa1, 0xb7, 0x72, 0xbd, 0x77,
0xd4, 0x15, 0xd2, 0x14, 0xaa, 0x77, 0x70, 0x20, 0x64, 0x76, 0x3f, 0x06, 0x08, 0xeb, 0x98, 0xd4,
0x6b, 0x71, 0x5b, 0x6a, 0x77, 0x9b, 0xbc, 0x44, 0x77, 0x50, 0xe9, 0x74, 0x68, 0x87, 0x95, 0xe8,
0xaa, 0xbd, 0x41, 0x4b, 0xc8, 0xec, 0xfe, 0x2d, 0x0d, 0xab, 0x5e, 0xf1, 0x0c, 0xe5, 0x61, 0xb9,
0x3b, 0x3c, 0x94, 0x3f, 0x15, 0x52, 0x7e, 0x73, 0x5f, 0x48, 0xfb, 0xcd, 0xcf, 0x84, 0x8c, 0xdf,
0x7c, 0x26, 0x64, 0xfd, 0xe6, 0xe7, 0xc2, 0x92, 0xdf, 0x7c, 0x2e, 0x2c, 0xfb, 0xcd, 0x2f, 0x84,
0x15, 0xbf, 0xf9, 0x42, 0x58, 0xf5, 0x9b, 0x5f, 0x0a, 0x39, 0xba, 0x23, 0xb6, 0xc4, 0x27, 0x42,
0x3e, 0x68, 0x7f, 0x2a, 0x40, 0xd0, 0xde, 0x17, 0x0a, 0x41, 0xfb, 0x33, 0xa1, 0x18, 0xb4, 0x9f,
0x09, 0xa5, 0xa0, 0xfd, 0xb9, 0xb0, 0x16, 0xb4, 0x9f, 0x0b, 0xeb, 0x41, 0xfb, 0x0b, 0x41, 0x08,
0xda, 0x2f, 0x84, 0x8d, 0xa0, 0xfd, 0xa5, 0x80, 0xfc, 0xf6, 0xfe, 0x27, 0xc2, 0xad, 0xdd, 0x8f,
0xa0, 0x18, 0x2d, 0x00, 0x52, 0xe1, 0x75, 0x7a, 0x47, 0x5c, 0x9e, 0xad, 0x76, 0xb3, 0x25, 0xa4,
0x29, 0xfb, 0xa0, 0xd7, 0x6c, 0x76, 0x1a, 0x42, 0x66, 0xb7, 0x0e, 0xeb, 0x33, 0x65, 0x2d, 0x2a,
0xcb, 0x61, 0xf7, 0x55, 0x97, 0xca, 0x3e, 0x45, 0xb5, 0x51, 0xe9, 0x73, 0x1d, 0x48, 0x83, 0x8a,
0x90, 0x41, 0xb7, 0x60, 0x5d, 0x1a, 0x54, 0xe4, 0x83, 0x4a, 0xbb, 0xd3, 0x7b, 0xdd, 0xc0, 0x72,
0xa5, 0x2f, 0x64, 0x77, 0xeb, 0x50, 0x8a, 0x55, 0x77, 0xd0, 0x26, 0x6c, 0x50, 0xae, 0x6e, 0x6f,
0x20, 0xd7, 0x7a, 0xdd, 0x6e, 0xa3, 0x36, 0x68, 0xd4, 0xb9, 0xe0, 0x2b, 0x7d, 0x79, 0x48, 0x01,
0x37, 0xa0, 0x44, 0x39, 0xc2, 0xd1, 0xcc, 0xee, 0xfb, 0xbc, 0xc6, 0xe7, 0x17, 0xc9, 0xa8, 0x41,
0x1d, 0xf5, 0x2b, 0xfb, 0x72, 0x5f, 0x7a, 0xc5, 0xf7, 0xdf, 0xeb, 0x37, 0xba, 0x42, 0x7a, 0xf7,
0xef, 0x40, 0x98, 0x7d, 0xb7, 0xd2, 0xfd, 0x0d, 0x0e, 0xa9, 0xd9, 0x08, 0x50, 0xac, 0x56, 0xa4,
0x96, 0x2c, 0xd5, 0x70, 0xbb, 0x3f, 0x90, 0x78, 0x00, 0xa7, 0xd9, 0xa5, 0x4f, 0xc8, 0xec, 0xff,
0x6d, 0x0f, 0x56, 0xfa, 0xcf, 0x8e, 0xba, 0xfd, 0x4f, 0xd1, 0x09, 0x3c, 0x6e, 0x12, 0xe7, 0x8a,
0x5f, 0x5d, 0xa0, 0xf8, 0x35, 0x49, 0xfd, 0x67, 0xe7, 0x6d, 0x7e, 0xa7, 0x25, 0xa6, 0xd0, 0x9f,
0xd3, 0xf0, 0x84, 0xe7, 0x02, 0x57, 0xac, 0xf5, 0x36, 0xb8, 0x6f, 0xbb, 0x89, 0xd7, 0x70, 0x27,
0x7a, 0xd8, 0xf8, 0x0f, 0xbf, 0x92, 0x0e, 0x79, 0x9d, 0xdf, 0x93, 0x89, 0x29, 0xf4, 0x03, 0xdc,
0x9b, 0x39, 0x5b, 0x1c, 0xfa, 0x3a, 0x30, 0xd7, 0x5d, 0xeb, 0x7b, 0xd8, 0x91, 0x22, 0x67, 0x98,
0xf9, 0x3d, 0xda, 0x93, 0xeb, 0xfc, 0x3e, 0x6c, 0x27, 0xe1, 0xa8, 0x62, 0x0a, 0xfd, 0x1e, 0xb6,
0x67, 0x4e, 0x11, 0xde, 0xe5, 0x97, 0xff, 0xc0, 0x6f, 0xe7, 0x8a, 0x71, 0x31, 0x85, 0xfe, 0x00,
0x5b, 0x34, 0xfb, 0x24, 0xf3, 0xd8, 0xbf, 0x4a, 0x9e, 0x9b, 0x9c, 0xba, 0x2e, 0xd8, 0xfa, 0xef,
0x60, 0xa7, 0x49, 0x1c, 0xb6, 0x80, 0x36, 0xbf, 0x42, 0xbc, 0x0a, 0x1b, 0x2b, 0x52, 0x5e, 0x63,
0xe7, 0x7f, 0x0f, 0xf7, 0xbd, 0x8f, 0x29, 0x3f, 0x0b, 0xfc, 0x77, 0x14, 0x7e, 0x4c, 0x1c, 0x72,
0x13, 0xf8, 0x64, 0x69, 0x60, 0x78, 0xc0, 0xc0, 0xfc, 0xdc, 0xfb, 0xa7, 0xc0, 0x1c, 0xc0, 0xdd,
0x8e, 0x6e, 0x2f, 0x14, 0x71, 0x92, 0xf3, 0x3c, 0x5c, 0xbc, 0x08, 0xaf, 0xff, 0xa6, 0xd0, 0x21,
0x94, 0x9b, 0xc4, 0xf1, 0xf7, 0x19, 0x7b, 0xf5, 0x24, 0x42, 0x5e, 0x56, 0x84, 0x10, 0x53, 0xa8,
0x05, 0xb7, 0x38, 0xd6, 0x3b, 0x23, 0x1d, 0xc0, 0x46, 0x93, 0x38, 0x33, 0x85, 0x8c, 0x1b, 0xe0,
0xf4, 0x60, 0x43, 0x9a, 0xc3, 0xb9, 0x6c, 0xce, 0x55, 0x80, 0xbf, 0x81, 0xb5, 0x26, 0x71, 0xa2,
0xc5, 0xa0, 0xa4, 0x5d, 0x95, 0x63, 0xb4, 0x08, 0x37, 0x47, 0x90, 0xe2, 0x08, 0x0b, 0xb9, 0x17,
0xd8, 0x42, 0x1d, 0x8a, 0x87, 0xa6, 0x6b, 0x38, 0xc3, 0x43, 0x89, 0x65, 0xe0, 0x57, 0x3c, 0xdc,
0x17, 0xa0, 0xf4, 0x41, 0x60, 0xd6, 0x34, 0x94, 0xaa, 0xe1, 0xaf, 0xd8, 0x62, 0x9c, 0x0b, 0x4b,
0x58, 0x0b, 0x10, 0xbf, 0x83, 0xdb, 0x41, 0x14, 0x88, 0xa2, 0x5e, 0x66, 0xed, 0x57, 0x88, 0x7b,
0xe0, 0xc7, 0xc4, 0x9f, 0x14, 0xf5, 0x15, 0x45, 0x0d, 0x7d, 0xfe, 0xba, 0xa8, 0xc9, 0xa7, 0xee,
0x40, 0x39, 0xe6, 0xed, 0xef, 0x86, 0xd6, 0x85, 0xcd, 0xd0, 0xcf, 0xa3, 0x50, 0x37, 0xf6, 0xf0,
0x22, 0xaf, 0xc8, 0x7a, 0x2f, 0xa5, 0xfb, 0xc9, 0x95, 0x52, 0x4f, 0xcf, 0x3b, 0xf7, 0x16, 0x0d,
0xdb, 0xee, 0xd8, 0x61, 0x70, 0xeb, 0x51, 0xb8, 0x97, 0xe6, 0xf1, 0x55, 0x88, 0x8b, 0x4b, 0xb3,
0x2c, 0x52, 0x6e, 0xb6, 0xda, 0x75, 0x6a, 0x34, 0x41, 0xbd, 0x96, 0x57, 0x77, 0x17, 0xcf, 0xba,
0x72, 0x8b, 0x0d, 0x40, 0xad, 0x76, 0xbd, 0xa6, 0x18, 0x2a, 0x19, 0x87, 0xbb, 0xbc, 0x04, 0x70,
0x91, 0x22, 0xb6, 0xf9, 0xd6, 0xbc, 0x6a, 0x76, 0xc0, 0x9f, 0xac, 0x8a, 0xfb, 0x0b, 0xf1, 0xa9,
0x3a, 0xc5, 0x14, 0xaa, 0xc2, 0x56, 0xb0, 0xad, 0xca, 0x78, 0x7c, 0x05, 0xdc, 0xa2, 0x0c, 0x61,
0x33, 0xb6, 0x27, 0xbf, 0xc2, 0x7e, 0xd9, 0xe9, 0xde, 0x9b, 0x1d, 0x4a, 0xac, 0xce, 0xb3, 0x0d,
0x16, 0x0e, 0xa4, 0xe0, 0xeb, 0xcd, 0x8c, 0x5a, 0x67, 0xbf, 0xea, 0x2c, 0xd8, 0xe0, 0x2b, 0x80,
0x03, 0xc9, 0xff, 0x90, 0x84, 0xe2, 0x9a, 0x9a, 0xf9, 0xda, 0x35, 0x23, 0xb1, 0xd9, 0xaf, 0x4f,
0x4c, 0x03, 0xa5, 0x03, 0xa9, 0x49, 0x1c, 0xff, 0x9b, 0xcb, 0x0c, 0xde, 0xcc, 0x17, 0x9b, 0x19,
0xbc, 0xd9, 0x0f, 0x35, 0x62, 0x0a, 0xfd, 0x11, 0x36, 0x0f, 0xa4, 0x9a, 0x45, 0x14, 0x87, 0xc4,
0xbe, 0xd9, 0xa1, 0x99, 0x9f, 0x20, 0x26, 0x7c, 0x31, 0xdc, 0x11, 0x2f, 0x63, 0x09, 0x56, 0xf8,
0x0d, 0x14, 0xd8, 0x57, 0xc8, 0x0e, 0x2b, 0xa0, 0xcc, 0x68, 0x25, 0xfa, 0xa9, 0x75, 0x56, 0x7c,
0x74, 0x48, 0x4c, 0x7d, 0x92, 0x46, 0x4d, 0x28, 0x34, 0xd4, 0xd3, 0xe0, 0x2b, 0xd4, 0x65, 0xf1,
0xe3, 0x92, 0x31, 0x31, 0x85, 0xda, 0x80, 0x78, 0x40, 0x8a, 0xfd, 0x68, 0x61, 0xf1, 0x67, 0xea,
0x9d, 0xad, 0xe4, 0x4f, 0xe5, 0x62, 0x0a, 0x7d, 0x0d, 0xc5, 0x26, 0x71, 0xc2, 0x4f, 0xec, 0x49,
0xf6, 0xba, 0x78, 0xf6, 0x01, 0x6c, 0x71, 0x71, 0x04, 0xc4, 0xda, 0x29, 0x2f, 0xbf, 0xbc, 0x1d,
0x0e, 0x86, 0x0d, 0x16, 0x14, 0x8f, 0xf4, 0x93, 0xf0, 0x3c, 0x1f, 0xcc, 0xb0, 0x2f, 0xfa, 0x65,
0xc8, 0xc2, 0x2b, 0x70, 0x33, 0xb8, 0xb0, 0x62, 0xb8, 0x97, 0xc9, 0x7d, 0xb1, 0x0c, 0x19, 0x62,
0x39, 0x7a, 0x5f, 0x5d, 0x1b, 0x74, 0xf1, 0xb9, 0x3b, 0x14, 0x31, 0xbc, 0xab, 0xae, 0x8d, 0x98,
0x7c, 0xe2, 0x43, 0xb8, 0x13, 0xbb, 0xac, 0xde, 0x11, 0xae, 0xc7, 0x95, 0x9b, 0xb0, 0xb5, 0x1b,
0x5e, 0x57, 0x32, 0x3c, 0xe4, 0x5b, 0x5b, 0x5c, 0x55, 0xbe, 0x66, 0x85, 0x7a, 0xc1, 0x8e, 0x4d,
0xf8, 0xa0, 0x49, 0x9c, 0xca, 0x78, 0x7c, 0x75, 0x61, 0x3c, 0xe9, 0x08, 0x7b, 0xf1, 0xaa, 0xde,
0x55, 0x18, 0x62, 0x0a, 0x8d, 0xe1, 0x49, 0x24, 0xc5, 0x5e, 0xbc, 0xda, 0x65, 0xc2, 0xbf, 0xe6,
0x91, 0xc5, 0x14, 0x52, 0xbd, 0xa7, 0xc7, 0xe2, 0x75, 0x92, 0x4b, 0xee, 0x6f, 0xe5, 0x36, 0x3f,
0x80, 0x18, 0xb8, 0xcd, 0xcf, 0x7d, 0xa0, 0xdf, 0xc2, 0x7b, 0x51, 0x87, 0xba, 0xd9, 0x72, 0xc9,
0xc7, 0x60, 0xd0, 0xa1, 0x67, 0xfd, 0x94, 0xd0, 0x7f, 0x80, 0x5f, 0x84, 0x7e, 0xf1, 0x76, 0x16,
0x76, 0x0d, 0x27, 0xc1, 0x70, 0x37, 0x62, 0x52, 0x73, 0xff, 0xa0, 0xb8, 0x3a, 0x3d, 0x99, 0x9d,
0xc2, 0x1c, 0xcf, 0x7b, 0x65, 0xcf, 0x8e, 0x61, 0x32, 0x1d, 0x2b, 0xea, 0x6c, 0x3e, 0x30, 0xcb,
0x75, 0xf5, 0x02, 0xbf, 0x87, 0x3b, 0xc9, 0x0b, 0x54, 0x34, 0xed, 0x9d, 0xc1, 0xff, 0xc1, 0x2f,
0x00, 0xcd, 0xef, 0x7e, 0x62, 0x9e, 0xbd, 0xfb, 0xe6, 0x63, 0xaf, 0xef, 0xd9, 0xf1, 0x1b, 0xeb,
0xb1, 0x03, 0x9b, 0x0c, 0x71, 0x4e, 0x83, 0x57, 0x6c, 0x37, 0xd9, 0xe6, 0x8e, 0xe1, 0x17, 0x51,
0x4f, 0x59, 0xa4, 0xc7, 0xcb, 0x8c, 0xf9, 0x1a, 0x72, 0x7e, 0x78, 0xd9, 0x1a, 0x54, 0x95, 0xef,
0x84, 0xdf, 0xa7, 0x7a, 0x0c, 0x5d, 0x72, 0x4e, 0x30, 0x6f, 0xef, 0x89, 0xdf, 0xc1, 0xf6, 0x91,
0xa2, 0x3b, 0x49, 0xbf, 0xf9, 0xbe, 0xf2, 0x5f, 0x14, 0x0b, 0x20, 0xdb, 0x70, 0xeb, 0x40, 0xb7,
0xc8, 0xdc, 0xcf, 0x59, 0x2f, 0xfb, 0xc1, 0xfd, 0x02, 0xa8, 0xaf, 0x21, 0x57, 0xaf, 0x56, 0x15,
0xf5, 0x8d, 0x3b, 0xbd, 0xc1, 0xd9, 0xbe, 0x81, 0x7c, 0xbd, 0x8a, 0x89, 0x4d, 0x65, 0x75, 0xa3,
0x5c, 0xe0, 0x76, 0x68, 0xd4, 0xc1, 0x9b, 0xe1, 0xc6, 0xd6, 0x1c, 0x7b, 0xb9, 0x86, 0x3f, 0xe4,
0x7e, 0x07, 0xef, 0xb8, 0x15, 0xe2, 0xf9, 0x52, 0xba, 0x29, 0xda, 0xf1, 0x0a, 0xfb, 0x43, 0xf6,
0x67, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x44, 0x6c, 0x24, 0x9e, 0x3d, 0x00, 0x00,
}

15
proto/grpc.proto
View File

@ -200,7 +200,7 @@ message TriggerAction {
TriggerSSHLogin sshLogin = 10;
TriggerDHCPLeaseGranted dhcpLeaseGranted = 11;
TriggerGroupReceive groupReceive = 12;
TriggerGroupReceiveSequence groupReceiveSequence = 13;
TriggerGroupReceiveMulti groupReceiveMulti = 13;
TriggerGPIOIn gpioIn = 14;
}
@ -227,10 +227,19 @@ message TriggerGroupReceive{ // fired when the correct value is received on the
string groupName = 1;
int32 value = 2;
}
message TriggerGroupReceiveSequence{ // fired when the correct value is received on the group channel
enum GroupReceiveMultiType {
SEQUENCE = 0; // values have to occur in order (other values allowed in between)
AND = 1; //logical and ("all" values have to occur, could be unordered)
OR = 2; //logical or ("one of" the values has to occur)
EXACT_SEQUENCE = 3; // values have to occur in order (other values are NOT allowed in between)
}
message TriggerGroupReceiveMulti{
string groupName = 1;
bool IgnoreOutOfOrder = 2;
repeated int32 values = 3;
GroupReceiveMultiType type = 4;
}
enum GPIOInPullUpDown {
UP = 0;

89
service/triggerAction.go
View File

@ -30,20 +30,20 @@ const (
triggerTypeSshLogin
triggerTypeDhcpLeaseGranted
triggerTypeGroupReceive
triggerTypeGroupReceiveSequence
triggerTypeGroupReceiveMulti
triggerTypeGpioIn
)
var triggerTypeString = map[triggerType]string {
triggerTypeServiceStarted: "TRIGGER_SERVICE_STARTED",
triggerTypeUsbGadgetConnected: "TRIGGER_USB_GADGET_CONNECTED",
triggerTypeServiceStarted: "TRIGGER_SERVICE_STARTED",
triggerTypeUsbGadgetConnected: "TRIGGER_USB_GADGET_CONNECTED",
triggerTypeUsbGadgetDisconnected: "TRIGGER_USB_GADGET_DISCONNECTED",
triggerTypeWifiAPStarted: "TRIGGER_WIFI_AP_STARTED",
triggerTypeWifiConnectedAsSta: "TRIGGER_WIFI_CONNECTED_AS_STA",
triggerTypeSshLogin: "TRIGGER_SSH_LOGIN",
triggerTypeDhcpLeaseGranted: "TRIGGER_DHCP_LEASE_GRANTED",
triggerTypeGroupReceive: "TRIGGER_GROUP_RECEIVE",
triggerTypeGroupReceiveSequence: "TRIGGER_GROUP_RECEIVE_SEQUENCE",
triggerTypeGpioIn: "TRIGGER_GPIO_IN",
triggerTypeWifiAPStarted: "TRIGGER_WIFI_AP_STARTED",
triggerTypeWifiConnectedAsSta: "TRIGGER_WIFI_CONNECTED_AS_STA",
triggerTypeSshLogin: "TRIGGER_SSH_LOGIN",
triggerTypeDhcpLeaseGranted: "TRIGGER_DHCP_LEASE_GRANTED",
triggerTypeGroupReceive: "TRIGGER_GROUP_RECEIVE",
triggerTypeGroupReceiveMulti: "TRIGGER_GROUP_RECEIVE_SEQUENCE",
triggerTypeGpioIn: "TRIGGER_GPIO_IN",
}
type actionType int
@ -85,8 +85,8 @@ func retrieveTriggerActionTypes(ta *pb.TriggerAction) (ttype triggerType, atype
ttype = triggerTypeDhcpLeaseGranted
case *pb.TriggerAction_GroupReceive:
ttype = triggerTypeGroupReceive
case *pb.TriggerAction_GroupReceiveSequence:
ttype = triggerTypeGroupReceiveSequence
case *pb.TriggerAction_GroupReceiveMulti:
ttype = triggerTypeGroupReceiveMulti
case *pb.TriggerAction_GpioIn:
ttype = triggerTypeGpioIn
case nil:
@ -273,9 +273,9 @@ func (tam *TriggerActionManager) onGroupReceive(evt *pb.Event, ta *pb.TriggerAct
}
tam.executeAction(evt, ta, tt, at) // fire action
return nil
case triggerTypeGroupReceiveSequence:
case triggerTypeGroupReceiveMulti:
// fmt.Println("### Processing GroupReceive event for trigger type GroupReceiveSequence")
triggerGroupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence).GroupReceiveSequence.GroupName
triggerGroupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.GroupName
if evGroupName != triggerGroupName {
return nil
}
@ -401,9 +401,10 @@ func (tam *TriggerActionManager) executeActionStartHidScript(evt *pb.Event, ta *
gpioPin := ta.Trigger.(*pb.TriggerAction_GpioIn).GpioIn.GpioNum
gpioPinName := pb.GPIONum_name[int32(gpioPin)]
preScript += fmt.Sprintf("var GPIO_PIN='%s';\n", gpioPinName)
case triggerTypeGroupReceiveSequence:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence).GroupReceiveSequence.GroupName
values := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence).GroupReceiveSequence.Values
case triggerTypeGroupReceiveMulti:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.GroupName
values := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.Values
rtype := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.Type
// create bash array of values
jsArray := "["
for idx,v := range values {
@ -416,6 +417,7 @@ func (tam *TriggerActionManager) executeActionStartHidScript(evt *pb.Event, ta *
jsArray += "]"
preScript += fmt.Sprintf("var GROUP='%s';\n", groupName)
preScript += fmt.Sprintf("var VALUES=%s;\n", jsArray)
preScript += fmt.Sprintf("var MULTI_TYPE='%s';\n", pb.GroupReceiveMultiType_name[int32(rtype)])
case triggerTypeGroupReceive:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceive).GroupReceive.GroupName
value := ta.Trigger.(*pb.TriggerAction_GroupReceive).GroupReceive.Value
@ -470,9 +472,10 @@ func (tam *TriggerActionManager) executeActionBashScript(evt *pb.Event, ta *pb.T
gpioPin := ta.Trigger.(*pb.TriggerAction_GpioIn).GpioIn.GpioNum
gpioPinName := pb.GPIONum_name[int32(gpioPin)]
env = append(env, fmt.Sprintf("GPIO_PIN=%s", gpioPinName))
case triggerTypeGroupReceiveSequence:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence).GroupReceiveSequence.GroupName
values := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence).GroupReceiveSequence.Values
case triggerTypeGroupReceiveMulti:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.GroupName
values := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.Values
rtype := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.Type
// create bash array of values
bashArray := "("
for _,v := range values { bashArray += fmt.Sprintf("%d ", v)}
@ -480,6 +483,7 @@ func (tam *TriggerActionManager) executeActionBashScript(evt *pb.Event, ta *pb.T
env = append(env,
fmt.Sprintf("GROUP='%s'", groupName),
fmt.Sprintf("VALUES=%s", bashArray),
fmt.Sprintf("MULTI_TYPE='%s'", pb.GroupReceiveMultiType_name[int32(rtype)]),
)
case triggerTypeGroupReceive:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceive).GroupReceive.GroupName
@ -522,14 +526,15 @@ func (tam *TriggerActionManager) executeActionLog(evt *pb.Event, ta *pb.TriggerA
gpioPin := ta.Trigger.(*pb.TriggerAction_GpioIn).GpioIn.GpioNum
gpioPinName := pb.GPIONum_name[int32(gpioPin)]
logMessage += fmt.Sprintf(" (GPIO_PIN=%s)", gpioPinName)
case triggerTypeGroupReceiveSequence:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence).GroupReceiveSequence.GroupName
values := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence).GroupReceiveSequence.Values
case triggerTypeGroupReceiveMulti:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.GroupName
values := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.Values
logMessage += fmt.Sprintf(" (GROUP='%s', VALUES=%v)", groupName, values)
case triggerTypeGroupReceive:
groupName := ta.Trigger.(*pb.TriggerAction_GroupReceive).GroupReceive.GroupName
value := ta.Trigger.(*pb.TriggerAction_GroupReceive).GroupReceive.Value
logMessage += fmt.Sprintf(" (GROUP='%s', VALUE=%d)", groupName, value)
values := ta.Trigger.(*pb.TriggerAction_GroupReceive).GroupReceive.Value
typeName := pb.GroupReceiveMultiType_name[int32(ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti).GroupReceiveMulti.Type)]
logMessage += fmt.Sprintf(" (GROUP='%s', VALUES=%+v, VALUE='%d')", groupName, values, typeName)
case triggerTypeDhcpLeaseGranted:
iface := evt.Values[1].GetTstring()
mac := evt.Values[2].GetTstring()
@ -579,7 +584,7 @@ func taTriggerTypeMatchesEvtTriggerType(ttype triggerType, evt *pb.Event) bool {
return true
}
case common_web.TRIGGER_EVT_TYPE_GROUP_RECEIVE:
if ttype == triggerTypeGroupReceive || ttype == triggerTypeGroupReceiveSequence {
if ttype == triggerTypeGroupReceive || ttype == triggerTypeGroupReceiveMulti {
return true
}
case common_web.TRIGGER_EVT_TYPE_GPIO_IN:
@ -604,10 +609,20 @@ func (tam *TriggerActionManager) AddTriggerAction(ta *pb.TriggerAction) (taAdded
taAdded = ta
//if new ta trigger is GroupReceiveSequence, add a SequenceChecker
if triggerGrpRcv,match := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence); match {
if triggerGrpRcv,match := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti); match {
tam.groupReceiveSequenceCheckersMutex.Lock()
//fmt.Printf("##### New val checker %+v\n", triggerGrpRcv.GroupReceiveSequence.Values)
tam.groupReceiveSequenceCheckers[ta] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveSequence.Values, triggerGrpRcv.GroupReceiveSequence.IgnoreOutOfOrder)
switch triggerGrpRcv.GroupReceiveMulti.Type {
case pb.GroupReceiveMultiType_AND:
tam.groupReceiveSequenceCheckers[ta] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_AND)
case pb.GroupReceiveMultiType_OR:
tam.groupReceiveSequenceCheckers[ta] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_OR)
case pb.GroupReceiveMultiType_SEQUENCE:
tam.groupReceiveSequenceCheckers[ta] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_SEQUENCE)
case pb.GroupReceiveMultiType_EXACT_SEQUENCE:
tam.groupReceiveSequenceCheckers[ta] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_EXACT_SEQUENCE)
}
tam.groupReceiveSequenceCheckersMutex.Unlock()
}
@ -627,7 +642,7 @@ func (tam *TriggerActionManager) RemoveTriggerAction(removeTa *pb.TriggerAction)
tam.registeredTriggerActions.TriggerActions = append(tam.registeredTriggerActions.TriggerActions[:idx], tam.registeredTriggerActions.TriggerActions[idx+1:]...)
//if target ta trigger had a sequenceChecker assigned, remove it
if _,match := ta.Trigger.(*pb.TriggerAction_GroupReceiveSequence); match {
if _,match := ta.Trigger.(*pb.TriggerAction_GroupReceiveMulti); match {
tam.groupReceiveSequenceCheckersMutex.Lock()
delete(tam.groupReceiveSequenceCheckers, ta)
tam.groupReceiveSequenceCheckersMutex.Unlock()
@ -664,7 +679,7 @@ func (tam *TriggerActionManager) UpdateTriggerAction(srcTa *pb.TriggerAction, ad
if targetTA.Immutable { return ErrTaImmutable }
//if target ta trigger had a sequenceChecker assigned, remove it
if _,match := targetTA.Trigger.(*pb.TriggerAction_GroupReceiveSequence); match {
if _,match := targetTA.Trigger.(*pb.TriggerAction_GroupReceiveMulti); match {
tam.groupReceiveSequenceCheckersMutex.Lock()
delete(tam.groupReceiveSequenceCheckers, targetTA)
tam.groupReceiveSequenceCheckersMutex.Unlock()
@ -677,9 +692,19 @@ func (tam *TriggerActionManager) UpdateTriggerAction(srcTa *pb.TriggerAction, ad
targetTA.Trigger = srcTa.Trigger
//if new ta trigger is GroupReceiveSequence, add a SequenceChecker
if triggerGrpRcv,match := targetTA.Trigger.(*pb.TriggerAction_GroupReceiveSequence); match {
if triggerGrpRcv,match := targetTA.Trigger.(*pb.TriggerAction_GroupReceiveMulti); match {
tam.groupReceiveSequenceCheckersMutex.Lock()
tam.groupReceiveSequenceCheckers[targetTA] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveSequence.Values, triggerGrpRcv.GroupReceiveSequence.IgnoreOutOfOrder)
switch triggerGrpRcv.GroupReceiveMulti.Type {
case pb.GroupReceiveMultiType_AND:
tam.groupReceiveSequenceCheckers[targetTA] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_AND)
case pb.GroupReceiveMultiType_OR:
tam.groupReceiveSequenceCheckers[targetTA] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_OR)
case pb.GroupReceiveMultiType_SEQUENCE:
tam.groupReceiveSequenceCheckers[targetTA] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_SEQUENCE)
case pb.GroupReceiveMultiType_EXACT_SEQUENCE:
tam.groupReceiveSequenceCheckers[targetTA] = util.NewValueSequenceChecker(triggerGrpRcv.GroupReceiveMulti.Values, util.ValueSeqType_EXACT_SEQUENCE)
}
tam.groupReceiveSequenceCheckersMutex.Unlock()
}
return nil

112
service/util/valueSequenceChecker.go
View File

@ -2,38 +2,99 @@ package util
import "fmt"
type ValueSequenceCheckerType int
const (
ValueSeqType_SEQUENCE ValueSequenceCheckerType = 0
ValueSeqType_AND ValueSequenceCheckerType = 1
ValueSeqType_OR ValueSequenceCheckerType = 2
ValueSeqType_EXACT_SEQUENCE ValueSequenceCheckerType = 3
)
type ValueSequenceChecker struct {
values []int32
allowOutOfOrder bool
values []int32 // used for sequences
valuesHitCountMap map[int32]int //used for OR / AND
valSeqCheckType ValueSequenceCheckerType
currentPos int
}
func (sc *ValueSequenceChecker) String() string {
res := "("
for i,v := range sc.values {
if i == sc.currentPos { res += "[" }
if sc.valSeqCheckType == ValueSeqType_EXACT_SEQUENCE || sc.valSeqCheckType == ValueSeqType_SEQUENCE {
res := "("
for i,v := range sc.values {
if i == sc.currentPos { res += "[" }
res += fmt.Sprintf("%d", v)
res += fmt.Sprintf("%d", v)
if i == sc.currentPos { res += "]" }
if i != len(sc.values)-1 { res += " "}
if i == sc.currentPos { res += "]" }
if i != len(sc.values)-1 { res += " "}
}
res += ")"
return res
}
res += ")"
return res
if sc.valSeqCheckType == ValueSeqType_AND {
return fmt.Sprintf("AND values (%v), still needed (%+v)", sc.values, sc.valuesHitCountMap)
}
if sc.valSeqCheckType == ValueSeqType_OR {
return fmt.Sprintf("OR values (%v)", sc.values)
}
return ""
}
func (sc *ValueSequenceChecker) Check(val int32) bool {
if len(sc.values) == 0 { return true }
switch sc.valSeqCheckType {
case ValueSeqType_SEQUENCE:
if len(sc.values) == 0 { return true }
if val == sc.values[sc.currentPos] {
if sc.advance() {
// rewind, to be able to reuse the sequence checker
sc.currentPos = 0
return true
}
}
case ValueSeqType_EXACT_SEQUENCE:
if len(sc.values) == 0 { return true }
if val == sc.values[sc.currentPos] {
if sc.advance() {
// rewind, to be able to reuse the sequence checker
sc.currentPos = 0
return true
}
} else {
sc.currentPos = 0 // rewind if no out-of-order allowed
}
case ValueSeqType_AND:
if remaining,exists := sc.valuesHitCountMap[val]; exists {
// lower count as we have a hit
newRemaining := remaining-1
sc.valuesHitCountMap[val] = newRemaining
// if count == 0, remove from map
if newRemaining < 1 {
delete(sc.valuesHitCountMap, val)
}
}
// if the map is empty, we succeeded
if len(sc.valuesHitCountMap) == 0 {
// ToDo: make this thread save
// rebuild map to be able to reuse
valuesHitCountMap := make(map[int32]int)
for _,val := range sc.values {
if currentCount,exists := valuesHitCountMap[val]; exists {
valuesHitCountMap[val] = currentCount+1
} else {
valuesHitCountMap[val] = 1
}
}
sc.valuesHitCountMap = valuesHitCountMap
if val == sc.values[sc.currentPos] {
if sc.advance() {
// rewind, to be able to reuse the sequence checker
sc.currentPos = 0
return true
}
} else {
if !sc.allowOutOfOrder {
sc.currentPos = 0 // rewind if no out-of-order allowed
case ValueSeqType_OR:
if _,exists := sc.valuesHitCountMap[val]; exists {
return true //every value from the map would produce a hit
}
}
@ -47,11 +108,22 @@ func (sc *ValueSequenceChecker) advance() bool {
return false
}
func NewValueSequenceChecker(values []int32, allowOutOfOrder bool) *ValueSequenceChecker {
func NewValueSequenceChecker(values []int32, valSeqCheckType ValueSequenceCheckerType) *ValueSequenceChecker {
res := &ValueSequenceChecker{
values: values,
allowOutOfOrder: allowOutOfOrder,
valSeqCheckType: valSeqCheckType,
currentPos: 0,
}
if valSeqCheckType == ValueSeqType_AND || valSeqCheckType == ValueSeqType_OR {
// convert values to map for easy lookup (and marking for AND)
res.valuesHitCountMap = make(map[int32]int)
for _,val := range values {
if currentCount,exists := res.valuesHitCountMap[val]; exists {
res.valuesHitCountMap[val] = currentCount+1
} else {
res.valuesHitCountMap[val] = 1
}
}
}
return res
}

102
web_client/hvueComponentsTriggerActions.go
View File

@ -42,6 +42,24 @@ func generateSelectOptionsAction() *js.Object {
return tts
}
func generateSelectOptionsGroupReceiveMultiType() *js.Object {
tts := js.Global.Get("Array").New()
type option struct {
*js.Object
Label string `js:"label"`
Value GroupReceiveMultiType `js:"value"`
}
for _, value := range availableGroupReceiveMulti {
label := groupReceiveMultiNames[value]
o := option{Object:O()}
o.Value = value
o.Label = label
tts.Call("push", o)
}
return tts
}
func generateSelectOptionsGPIOOutValue() *js.Object {
tts := js.Global.Get("Array").New()
type option struct {
@ -239,21 +257,28 @@ func InitComponentsTriggerActions() {
strTrigger += t.GroupName
strTrigger += ": " + strconv.Itoa(int(t.Value))
strTrigger += ")"
case ta.IsTriggerGroupReceiveSequence():
t := jsTriggerGroupReceiveSequence{Object: ta.TriggerData}
case ta.IsTriggerGroupReceiveMulti():
t := jsTriggerGroupReceiveMulti{Object: ta.TriggerData}
strTrigger += " ("
strTrigger += t.GroupName
strTrigger += ": ["
for idx,val := range t.ValueSequence {
strTrigger += t.GroupName + ": "
switch t.Type {
case GroupReceiveMultiType_SEQUENCE:
strTrigger += "sequence of"
case GroupReceiveMultiType_EXACT_SEQUENCE:
strTrigger += "exact sequence of"
case GroupReceiveMultiType_OR:
strTrigger += "one of"
case GroupReceiveMultiType_AND:
strTrigger += "all from"
}
strTrigger += " ["
for idx,val := range t.Values {
if idx != 0 {
strTrigger += ", "
}
strTrigger += strconv.Itoa(int(val))
}
strTrigger += "]"
if !t.IgnoreOutOfOrder {
strTrigger += ", out-of-order allowed"
}
strTrigger += ")"
case ta.IsTriggerGPIOIn():
t := jsTriggerGPIOIn{Object: ta.TriggerData}
@ -361,6 +386,9 @@ func InitComponentsTriggerActions() {
hvue.Computed("pullupdown", func(vm *hvue.VM) interface{} {
return generateSelectOptionsGPIOInPullUpDown()
}),
hvue.Computed("groupReceiveMultiSelect", func(vm *hvue.VM) interface{} {
return generateSelectOptionsGroupReceiveMultiType()
}),
hvue.Computed("edge", func(vm *hvue.VM) interface{} {
return generateSelectOptionsGPIOInEdges()
}),
@ -378,44 +406,44 @@ func InitComponentsTriggerActions() {
ta.ChangeTriggerType(tType)
}),
hvue.Method(
"TriggerGroupReceiveSequenceAddValue",
"TriggerGroupReceiveMultiAddValue",
func(vm *hvue.VM, newVal *js.Object) {
println("Force add", newVal)
ta := &jsTriggerAction{Object: vm.Get("ta")}
if !ta.IsTriggerGroupReceiveSequence() { return }
if !ta.IsTriggerGroupReceiveMulti() { return }
// cast data Object to jsTriggerGroupReceiveSequence
tgrs := &jsTriggerGroupReceiveSequence{Object:ta.TriggerData}
// cast data Object to jsTriggerGroupReceiveMulti
tgrs := &jsTriggerGroupReceiveMulti{Object: ta.TriggerData}
strVal := newVal.String()
if intVal,errconv := strconv.Atoi(strVal); errconv == nil {
//append to Values
tgrs.ValueSequence = append(tgrs.ValueSequence, int32(intVal))
tgrs.Values = append(tgrs.Values, int32(intVal))
}
}),
hvue.ComputedWithGetSet(
"TriggerGroupReceiveSequenceValues",
"TriggerGroupReceiveMultiValues",
func(vm *hvue.VM) interface{} {
ta := &jsTriggerAction{Object: vm.Get("ta")}
if !ta.IsTriggerGroupReceiveSequence() { return []string{} }
if !ta.IsTriggerGroupReceiveMulti() { return []string{} }
// cast data Object to jsTriggerGroupReceiveSequence
tgrs := &jsTriggerGroupReceiveSequence{Object:ta.TriggerData}
// cast data Object to jsTriggerGroupReceiveMulti
tgrs := &jsTriggerGroupReceiveMulti{Object: ta.TriggerData}
res := make([]string, len(tgrs.ValueSequence))
for idx,intVal := range tgrs.ValueSequence {
res := make([]string, len(tgrs.Values))
for idx,intVal := range tgrs.Values {
res[idx] = strconv.Itoa(int(intVal))
}
return res
},
func(vm *hvue.VM, newValue *js.Object) {
ta := &jsTriggerAction{Object: vm.Get("ta")}
if !ta.IsTriggerGroupReceiveSequence() { return }
if !ta.IsTriggerGroupReceiveMulti() { return }
// cast data Object to jsTriggerGroupReceiveSequence
tgrs := &jsTriggerGroupReceiveSequence{Object:ta.TriggerData}
// cast data Object to jsTriggerGroupReceiveMulti
tgrs := &jsTriggerGroupReceiveMulti{Object: ta.TriggerData}
// clear old array
tgrs.ValueSequence = []int32{}
tgrs.Values = []int32{}
// iterate over newValue, which is assumed to be an Array of strings
for idx := 0; idx < newValue.Length(); idx++ {
@ -424,7 +452,7 @@ func InitComponentsTriggerActions() {
// try to cast to int
if intVal,errconv := strconv.Atoi(strVal); errconv == nil {
//append to Values
tgrs.ValueSequence = append(tgrs.ValueSequence, int32(intVal))
tgrs.Values = append(tgrs.Values, int32(intVal))
}
}
}),
@ -434,8 +462,8 @@ func InitComponentsTriggerActions() {
hvue.Computed("isTriggerGroupReceive", func(vm *hvue.VM) interface{} {
return (&jsTriggerAction{Object: vm.Get("ta")}).IsTriggerGroupReceive()
}),
hvue.Computed("isTriggerGroupReceiveSequence", func(vm *hvue.VM) interface{} {
return (&jsTriggerAction{Object: vm.Get("ta")}).IsTriggerGroupReceiveSequence()
hvue.Computed("isTriggerGroupReceiveMulti", func(vm *hvue.VM) interface{} {
return (&jsTriggerAction{Object: vm.Get("ta")}).IsTriggerGroupReceiveMulti()
}),
)
hvue.NewComponent(
@ -659,7 +687,7 @@ const templateTrigger = `
</q-item-main>
</q-item>
<q-item tag="label" v-if="isTriggerGroupReceive || isTriggerGroupReceiveSequence">
<q-item tag="label" v-if="isTriggerGroupReceive || isTriggerGroupReceiveMulti">
<q-item-main>
<q-item-tile label>Group name</q-item-tile>
<q-item-tile sublabel>Only values send for this group name are regarded</q-item-tile>
@ -677,16 +705,17 @@ const templateTrigger = `
</q-item-tile>
</q-item-main>
</q-item>
<q-item tag="label" v-if="isTriggerGroupReceiveSequence">
<q-item tag="label" v-if="isTriggerGroupReceiveMulti">
<q-item-main>
<q-item-tile label>Values</q-item-tile>
<q-item-tile sublabel>The numeric value sequence which has to be received to activate the trigger</q-item-tile>
<q-item-tile sublabel>The numeric values which has to be received to activate the trigger</q-item-tile>
<q-item-tile>
<q-chips-input v-model="TriggerGroupReceiveSequenceValues" @duplicate="TriggerGroupReceiveSequenceAddValue($event)" type="number" decimals="0" inverted :disable="!ta.IsActive"></q-chips-input>
<q-chips-input v-model="TriggerGroupReceiveMultiValues" @duplicate="TriggerGroupReceiveMultiAddValue($event)" type="number" decimals="0" inverted :disable="!ta.IsActive"></q-chips-input>
</q-item-tile>
</q-item-main>
</q-item>
<q-item tag="label" link :disabled="!ta.IsActive" v-if="isTriggerGroupReceiveSequence">
<!--
<q-item tag="label" link :disabled="!ta.IsActive" v-if="isTriggerGroupReceiveMulti">
<q-item-side>
<q-toggle v-model="ta.TriggerData.IgnoreOutOfOrder" :disable="!ta.IsActive"></q-toggle>
</q-item-side>
@ -695,6 +724,17 @@ const templateTrigger = `
<q-item-tile sublabel>If enabled the sequence may be interrupted by other values. If disabled they have to arrive in exact order.</q-item-tile>
</q-item-main>
</q-item>
-->
<q-item tag="label" v-if="isTriggerGroupReceiveMulti">
<q-item-main>
<q-item-tile label>Type</q-item-tile>
<q-item-tile sublabel>Chose how values should be checked (logical OR, logical AND, sequence or exact sequence</q-item-tile>
<q-item-tile>
<q-select v-model="ta.TriggerData.Type" :options="groupReceiveMultiSelect" inverted :disable="!ta.IsActive"></q-select>
</q-item-tile>
</q-item-main>
</q-item>
<q-item tag="label" v-if="isTriggerGPIOIn">

98
web_client/jsDataTriggerAction.go
View File

@ -12,16 +12,16 @@ import (
type triggerType int
type actionType int
const (
TriggerServiceStarted = triggerType(0)
TriggerUsbGadgetConnected = triggerType(1)
TriggerServiceStarted = triggerType(0)
TriggerUsbGadgetConnected = triggerType(1)
TriggerUsbGadgetDisconnected = triggerType(2)
TriggerWifiAPStarted = triggerType(3)
TriggerWifiConnectedAsSta = triggerType(4)
TriggerSshLogin = triggerType(5)
TriggerDhcpLeaseGranted = triggerType(6)
TriggerGPIOIn = triggerType(7)
TriggerGroupReceive = triggerType(8)
TriggerGroupReceiveSequence = triggerType(9)
TriggerWifiAPStarted = triggerType(3)
TriggerWifiConnectedAsSta = triggerType(4)
TriggerSshLogin = triggerType(5)
TriggerDhcpLeaseGranted = triggerType(6)
TriggerGPIOIn = triggerType(7)
TriggerGroupReceive = triggerType(8)
TriggerGroupReceiveMulti = triggerType(9)
ActionLog = actionType(0)
ActionHidScript = actionType(1)
@ -31,16 +31,16 @@ const (
ActionGroupSend = actionType(5)
)
var triggerNames = map[triggerType]string{
TriggerServiceStarted: "service started",
TriggerUsbGadgetConnected: "USB gadget connected to host",
TriggerServiceStarted: "service started",
TriggerUsbGadgetConnected: "USB gadget connected to host",
TriggerUsbGadgetDisconnected: "USB Gadget disconnected from host",
TriggerWifiAPStarted: "WiFi Access Point is up",
TriggerWifiConnectedAsSta: "joined existing WiFi",
TriggerSshLogin: "SSH user login",
TriggerDhcpLeaseGranted: "DHCP lease issued",
TriggerGPIOIn: "input on GPIO",
TriggerGroupReceive: "a value on a group channel",
TriggerGroupReceiveSequence: "value sequence on a group channel",
TriggerWifiAPStarted: "WiFi Access Point is up",
TriggerWifiConnectedAsSta: "joined existing WiFi",
TriggerSshLogin: "SSH user login",
TriggerDhcpLeaseGranted: "DHCP lease issued",
TriggerGPIOIn: "input on GPIO",
TriggerGroupReceive: "a value on a group channel",
TriggerGroupReceiveMulti: "multiple values on a group channel",
}
var actionNames = map[actionType]string{
ActionLog: "write log entry",
@ -60,7 +60,7 @@ var availableTriggers = []triggerType{
TriggerGPIOIn,
TriggerSshLogin,
TriggerGroupReceive,
TriggerGroupReceiveSequence,
TriggerGroupReceiveMulti,
}
var availableActions = []actionType {
ActionLog,
@ -154,11 +154,12 @@ func (dst *jsTriggerAction) fromGo(src *pb.TriggerAction) {
dstTrigger := &jsTriggerGroupReceive{Object: dst.TriggerData}
dstTrigger.GroupName = srcTrigger.GroupReceive.GroupName
dstTrigger.Value = srcTrigger.GroupReceive.Value
case *pb.TriggerAction_GroupReceiveSequence:
dst.ChangeTriggerType(TriggerGroupReceiveSequence)
dstTrigger := &jsTriggerGroupReceiveSequence{Object: dst.TriggerData}
dstTrigger.GroupName = srcTrigger.GroupReceiveSequence.GroupName
dstTrigger.ValueSequence = srcTrigger.GroupReceiveSequence.Values
case *pb.TriggerAction_GroupReceiveMulti:
dst.ChangeTriggerType(TriggerGroupReceiveMulti)
dstTrigger := &jsTriggerGroupReceiveMulti{Object: dst.TriggerData}
dstTrigger.GroupName = srcTrigger.GroupReceiveMulti.GroupName
dstTrigger.Values = srcTrigger.GroupReceiveMulti.Values
dstTrigger.Type = GroupReceiveMultiType(srcTrigger.GroupReceiveMulti.Type)
default:
// change nothing
}
@ -273,12 +274,13 @@ func (ta *jsTriggerAction) toGo() (res *pb.TriggerAction) {
Value: triggerData.Value,
},
}
case TriggerGroupReceiveSequence:
triggerData := &jsTriggerGroupReceiveSequence{Object: ta.TriggerData}
res.Trigger = &pb.TriggerAction_GroupReceiveSequence{
GroupReceiveSequence: &pb.TriggerGroupReceiveSequence {
case TriggerGroupReceiveMulti:
triggerData := &jsTriggerGroupReceiveMulti{Object: ta.TriggerData}
res.Trigger = &pb.TriggerAction_GroupReceiveMulti{
GroupReceiveMulti: &pb.TriggerGroupReceiveMulti {
GroupName: triggerData.GroupName,
Values: triggerData.ValueSequence,
Values: triggerData.Values,
Type: pb.GroupReceiveMultiType(triggerData.Type),
},
}
default:
@ -387,11 +389,11 @@ func (ta *jsTriggerAction) ChangeTriggerType(newTt triggerType) {
d.GroupName = "Group1"
d.Value = 0
data = d.Object
case TriggerGroupReceiveSequence:
d := &jsTriggerGroupReceiveSequence{Object:O()}
case TriggerGroupReceiveMulti:
d := &jsTriggerGroupReceiveMulti{Object: O()}
d.GroupName = "Group1"
d.IgnoreOutOfOrder = false
d.ValueSequence = []int32{1,1}
d.Type = GroupReceiveMultiType_SEQUENCE
d.Values = []int32{1,2}
data = d.Object
default:
println("Unknown trigger type")
@ -429,8 +431,8 @@ func (ta *jsTriggerAction) IsTriggerGPIOIn() bool {
func (ta *jsTriggerAction) IsTriggerGroupReceive() bool {
return ta.TriggerType == TriggerGroupReceive
}
func (ta *jsTriggerAction) IsTriggerGroupReceiveSequence() bool {
return ta.TriggerType == TriggerGroupReceiveSequence
func (ta *jsTriggerAction) IsTriggerGroupReceiveMulti() bool {
return ta.TriggerType == TriggerGroupReceiveMulti
}
@ -477,12 +479,30 @@ type jsTriggerGroupReceive struct {
GroupName string `js:"GroupName"`
Value int32 `js:"Value"`
}
type jsTriggerGroupReceiveSequence struct {
type jsTriggerGroupReceiveMulti struct {
*js.Object
GroupName string `js:"GroupName"`
IgnoreOutOfOrder bool `js:"IgnoreOutOfOrder"`
ValueSequence []int32 `js:"ValueSequence"`
GroupName string `js:"GroupName"`
Type GroupReceiveMultiType `js:"Type"`
Values []int32 `js:"Values"`
}
type GroupReceiveMultiType int
const (
GroupReceiveMultiType_SEQUENCE GroupReceiveMultiType = 0
GroupReceiveMultiType_AND GroupReceiveMultiType = 1
GroupReceiveMultiType_OR GroupReceiveMultiType = 2
GroupReceiveMultiType_EXACT_SEQUENCE GroupReceiveMultiType = 3
)
var groupReceiveMultiNames = map[GroupReceiveMultiType]string{
GroupReceiveMultiType_SEQUENCE: "Ordered Sequence (out-of-oreder values allowed)",
GroupReceiveMultiType_AND: "All (logical AND)",
GroupReceiveMultiType_OR: "One of (logical OR)",
GroupReceiveMultiType_EXACT_SEQUENCE: "Exact ordered sequence",
}
var availableGroupReceiveMulti = []GroupReceiveMultiType{GroupReceiveMultiType_SEQUENCE, GroupReceiveMultiType_EXACT_SEQUENCE, GroupReceiveMultiType_AND, GroupReceiveMultiType_OR}
type jsTriggerGPIOIn struct {
*js.Object
GpioNum GPIONum `js:"GpioNum"`