config.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: github.com/google/cloudprober/probes/proto/config.proto

package proto

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import proto2 "github.com/google/cloudprober/metrics/proto"
import proto6 "github.com/google/cloudprober/probes/dns/proto"
import proto7 "github.com/google/cloudprober/probes/external/proto"
import proto5 "github.com/google/cloudprober/probes/http/proto"
import proto4 "github.com/google/cloudprober/probes/ping/proto"
import proto8 "github.com/google/cloudprober/probes/udp/proto"
import proto9 "github.com/google/cloudprober/probes/udplistener/proto"
import proto1 "github.com/google/cloudprober/targets/proto"
import proto3 "github.com/google/cloudprober/validators/proto"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type ProbeDef_Type int32

const (
	ProbeDef_PING         ProbeDef_Type = 0
	ProbeDef_HTTP         ProbeDef_Type = 1
	ProbeDef_DNS          ProbeDef_Type = 2
	ProbeDef_EXTERNAL     ProbeDef_Type = 3
	ProbeDef_UDP          ProbeDef_Type = 4
	ProbeDef_UDP_LISTENER ProbeDef_Type = 5
	// One of the extension probe types. See "extensions" below for more
	// details.
	ProbeDef_EXTENSION ProbeDef_Type = 98
	// USER_DEFINED probe type is for a one off probe that you want to compile
	// into cloudprober, but you don't expect it to be reused. If you expect
	// it to be reused, you should consider adding it using the extensions
	// mechanism.
	ProbeDef_USER_DEFINED ProbeDef_Type = 99
)

var ProbeDef_Type_name = map[int32]string{
	0:  "PING",
	1:  "HTTP",
	2:  "DNS",
	3:  "EXTERNAL",
	4:  "UDP",
	5:  "UDP_LISTENER",
	98: "EXTENSION",
	99: "USER_DEFINED",
}
var ProbeDef_Type_value = map[string]int32{
	"PING":         0,
	"HTTP":         1,
	"DNS":          2,
	"EXTERNAL":     3,
	"UDP":          4,
	"UDP_LISTENER": 5,
	"EXTENSION":    98,
	"USER_DEFINED": 99,
}

func (x ProbeDef_Type) Enum() *ProbeDef_Type {
	p := new(ProbeDef_Type)
	*p = x
	return p
}
func (x ProbeDef_Type) String() string {
	return proto.EnumName(ProbeDef_Type_name, int32(x))
}
func (x *ProbeDef_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProbeDef_Type_value, data, "ProbeDef_Type")
	if err != nil {
		return err
	}
	*x = ProbeDef_Type(value)
	return nil
}
func (ProbeDef_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_config_699221e7c78c5f06, []int{0, 0}
}

type ProbeDef struct {
	Name *string        `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
	Type *ProbeDef_Type `protobuf:"varint,2,req,name=type,enum=cloudprober.probes.ProbeDef_Type" json:"type,omitempty"`
	// Which machines this probe should run on. If defined, cloudprober will run
	// this probe only if machine's hostname matches this value.
	RunOn *string `protobuf:"bytes,3,opt,name=run_on,json=runOn" json:"run_on,omitempty"`
	// Interval between two probes
	IntervalMsec *int32 `protobuf:"varint,4,opt,name=interval_msec,json=intervalMsec,def=2000" json:"interval_msec,omitempty"`
	// Timeout for each probe
	TimeoutMsec *int32 `protobuf:"varint,5,opt,name=timeout_msec,json=timeoutMsec,def=1000" json:"timeout_msec,omitempty"`
	// Targets for the probe
	Targets *proto1.TargetsDef `protobuf:"bytes,6,req,name=targets" json:"targets,omitempty"`
	// Latency distribution. If specified, latency is stored as a distribution.
	LatencyDistribution *proto2.Dist `protobuf:"bytes,7,opt,name=latency_distribution,json=latencyDistribution" json:"latency_distribution,omitempty"`
	// Latency unit. Any string that's parseable by time.ParseDuration.
	// Valid values: "ns", "us" (or "µs"), "ms", "s", "m", "h".
	LatencyUnit *string `protobuf:"bytes,8,opt,name=latency_unit,json=latencyUnit,def=us" json:"latency_unit,omitempty"`
	// Validators are in experimental phase right now and can change at any time.
	// They only work for ping and http probes right now.
	Validator []*proto3.Validator `protobuf:"bytes,9,rep,name=validator" json:"validator,omitempty"`
	// Types that are valid to be assigned to Probe:
	//	*ProbeDef_PingProbe
	//	*ProbeDef_HttpProbe
	//	*ProbeDef_DnsProbe
	//	*ProbeDef_ExternalProbe
	//	*ProbeDef_UdpProbe
	//	*ProbeDef_UdpListenerProbe
	//	*ProbeDef_UserDefinedProbe
	Probe                        isProbeDef_Probe `protobuf_oneof:"probe"`
	XXX_NoUnkeyedLiteral         struct{}         `json:"-"`
	proto.XXX_InternalExtensions `json:"-"`
	XXX_unrecognized             []byte `json:"-"`
	XXX_sizecache                int32  `json:"-"`
}

func (m *ProbeDef) Reset()         { *m = ProbeDef{} }
func (m *ProbeDef) String() string { return proto.CompactTextString(m) }
func (*ProbeDef) ProtoMessage()    {}
func (*ProbeDef) Descriptor() ([]byte, []int) {
	return fileDescriptor_config_699221e7c78c5f06, []int{0}
}

var extRange_ProbeDef = []proto.ExtensionRange{
	{Start: 200, End: 536870911},
}

func (*ProbeDef) ExtensionRangeArray() []proto.ExtensionRange {
	return extRange_ProbeDef
}
func (m *ProbeDef) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ProbeDef.Unmarshal(m, b)
}
func (m *ProbeDef) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ProbeDef.Marshal(b, m, deterministic)
}
func (dst *ProbeDef) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProbeDef.Merge(dst, src)
}
func (m *ProbeDef) XXX_Size() int {
	return xxx_messageInfo_ProbeDef.Size(m)
}
func (m *ProbeDef) XXX_DiscardUnknown() {
	xxx_messageInfo_ProbeDef.DiscardUnknown(m)
}

var xxx_messageInfo_ProbeDef proto.InternalMessageInfo

const Default_ProbeDef_IntervalMsec int32 = 2000
const Default_ProbeDef_TimeoutMsec int32 = 1000
const Default_ProbeDef_LatencyUnit string = "us"

func (m *ProbeDef) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *ProbeDef) GetType() ProbeDef_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ProbeDef_PING
}

func (m *ProbeDef) GetRunOn() string {
	if m != nil && m.RunOn != nil {
		return *m.RunOn
	}
	return ""
}

func (m *ProbeDef) GetIntervalMsec() int32 {
	if m != nil && m.IntervalMsec != nil {
		return *m.IntervalMsec
	}
	return Default_ProbeDef_IntervalMsec
}

func (m *ProbeDef) GetTimeoutMsec() int32 {
	if m != nil && m.TimeoutMsec != nil {
		return *m.TimeoutMsec
	}
	return Default_ProbeDef_TimeoutMsec
}

func (m *ProbeDef) GetTargets() *proto1.TargetsDef {
	if m != nil {
		return m.Targets
	}
	return nil
}

func (m *ProbeDef) GetLatencyDistribution() *proto2.Dist {
	if m != nil {
		return m.LatencyDistribution
	}
	return nil
}

func (m *ProbeDef) GetLatencyUnit() string {
	if m != nil && m.LatencyUnit != nil {
		return *m.LatencyUnit
	}
	return Default_ProbeDef_LatencyUnit
}

func (m *ProbeDef) GetValidator() []*proto3.Validator {
	if m != nil {
		return m.Validator
	}
	return nil
}

type isProbeDef_Probe interface {
	isProbeDef_Probe()
}

type ProbeDef_PingProbe struct {
	PingProbe *proto4.ProbeConf `protobuf:"bytes,20,opt,name=ping_probe,json=pingProbe,oneof"`
}

type ProbeDef_HttpProbe struct {
	HttpProbe *proto5.ProbeConf `protobuf:"bytes,21,opt,name=http_probe,json=httpProbe,oneof"`
}

type ProbeDef_DnsProbe struct {
	DnsProbe *proto6.ProbeConf `protobuf:"bytes,22,opt,name=dns_probe,json=dnsProbe,oneof"`
}

type ProbeDef_ExternalProbe struct {
	ExternalProbe *proto7.ProbeConf `protobuf:"bytes,23,opt,name=external_probe,json=externalProbe,oneof"`
}

type ProbeDef_UdpProbe struct {
	UdpProbe *proto8.ProbeConf `protobuf:"bytes,24,opt,name=udp_probe,json=udpProbe,oneof"`
}

type ProbeDef_UdpListenerProbe struct {
	UdpListenerProbe *proto9.ProbeConf `protobuf:"bytes,25,opt,name=udp_listener_probe,json=udpListenerProbe,oneof"`
}

type ProbeDef_UserDefinedProbe struct {
	UserDefinedProbe string `protobuf:"bytes,99,opt,name=user_defined_probe,json=userDefinedProbe,oneof"`
}

func (*ProbeDef_PingProbe) isProbeDef_Probe() {}

func (*ProbeDef_HttpProbe) isProbeDef_Probe() {}

func (*ProbeDef_DnsProbe) isProbeDef_Probe() {}

func (*ProbeDef_ExternalProbe) isProbeDef_Probe() {}

func (*ProbeDef_UdpProbe) isProbeDef_Probe() {}

func (*ProbeDef_UdpListenerProbe) isProbeDef_Probe() {}

func (*ProbeDef_UserDefinedProbe) isProbeDef_Probe() {}

func (m *ProbeDef) GetProbe() isProbeDef_Probe {
	if m != nil {
		return m.Probe
	}
	return nil
}

func (m *ProbeDef) GetPingProbe() *proto4.ProbeConf {
	if x, ok := m.GetProbe().(*ProbeDef_PingProbe); ok {
		return x.PingProbe
	}
	return nil
}

func (m *ProbeDef) GetHttpProbe() *proto5.ProbeConf {
	if x, ok := m.GetProbe().(*ProbeDef_HttpProbe); ok {
		return x.HttpProbe
	}
	return nil
}

func (m *ProbeDef) GetDnsProbe() *proto6.ProbeConf {
	if x, ok := m.GetProbe().(*ProbeDef_DnsProbe); ok {
		return x.DnsProbe
	}
	return nil
}

func (m *ProbeDef) GetExternalProbe() *proto7.ProbeConf {
	if x, ok := m.GetProbe().(*ProbeDef_ExternalProbe); ok {
		return x.ExternalProbe
	}
	return nil
}

func (m *ProbeDef) GetUdpProbe() *proto8.ProbeConf {
	if x, ok := m.GetProbe().(*ProbeDef_UdpProbe); ok {
		return x.UdpProbe
	}
	return nil
}

func (m *ProbeDef) GetUdpListenerProbe() *proto9.ProbeConf {
	if x, ok := m.GetProbe().(*ProbeDef_UdpListenerProbe); ok {
		return x.UdpListenerProbe
	}
	return nil
}

func (m *ProbeDef) GetUserDefinedProbe() string {
	if x, ok := m.GetProbe().(*ProbeDef_UserDefinedProbe); ok {
		return x.UserDefinedProbe
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ProbeDef) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ProbeDef_OneofMarshaler, _ProbeDef_OneofUnmarshaler, _ProbeDef_OneofSizer, []interface{}{
		(*ProbeDef_PingProbe)(nil),
		(*ProbeDef_HttpProbe)(nil),
		(*ProbeDef_DnsProbe)(nil),
		(*ProbeDef_ExternalProbe)(nil),
		(*ProbeDef_UdpProbe)(nil),
		(*ProbeDef_UdpListenerProbe)(nil),
		(*ProbeDef_UserDefinedProbe)(nil),
	}
}

func _ProbeDef_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ProbeDef)
	// probe
	switch x := m.Probe.(type) {
	case *ProbeDef_PingProbe:
		b.EncodeVarint(20<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PingProbe); err != nil {
			return err
		}
	case *ProbeDef_HttpProbe:
		b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.HttpProbe); err != nil {
			return err
		}
	case *ProbeDef_DnsProbe:
		b.EncodeVarint(22<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DnsProbe); err != nil {
			return err
		}
	case *ProbeDef_ExternalProbe:
		b.EncodeVarint(23<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ExternalProbe); err != nil {
			return err
		}
	case *ProbeDef_UdpProbe:
		b.EncodeVarint(24<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.UdpProbe); err != nil {
			return err
		}
	case *ProbeDef_UdpListenerProbe:
		b.EncodeVarint(25<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.UdpListenerProbe); err != nil {
			return err
		}
	case *ProbeDef_UserDefinedProbe:
		b.EncodeVarint(99<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.UserDefinedProbe)
	case nil:
	default:
		return fmt.Errorf("ProbeDef.Probe has unexpected type %T", x)
	}
	return nil
}

func _ProbeDef_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ProbeDef)
	switch tag {
	case 20: // probe.ping_probe
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(proto4.ProbeConf)
		err := b.DecodeMessage(msg)
		m.Probe = &ProbeDef_PingProbe{msg}
		return true, err
	case 21: // probe.http_probe
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(proto5.ProbeConf)
		err := b.DecodeMessage(msg)
		m.Probe = &ProbeDef_HttpProbe{msg}
		return true, err
	case 22: // probe.dns_probe
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(proto6.ProbeConf)
		err := b.DecodeMessage(msg)
		m.Probe = &ProbeDef_DnsProbe{msg}
		return true, err
	case 23: // probe.external_probe
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(proto7.ProbeConf)
		err := b.DecodeMessage(msg)
		m.Probe = &ProbeDef_ExternalProbe{msg}
		return true, err
	case 24: // probe.udp_probe
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(proto8.ProbeConf)
		err := b.DecodeMessage(msg)
		m.Probe = &ProbeDef_UdpProbe{msg}
		return true, err
	case 25: // probe.udp_listener_probe
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(proto9.ProbeConf)
		err := b.DecodeMessage(msg)
		m.Probe = &ProbeDef_UdpListenerProbe{msg}
		return true, err
	case 99: // probe.user_defined_probe
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Probe = &ProbeDef_UserDefinedProbe{x}
		return true, err
	default:
		return false, nil
	}
}

func _ProbeDef_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ProbeDef)
	// probe
	switch x := m.Probe.(type) {
	case *ProbeDef_PingProbe:
		s := proto.Size(x.PingProbe)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ProbeDef_HttpProbe:
		s := proto.Size(x.HttpProbe)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ProbeDef_DnsProbe:
		s := proto.Size(x.DnsProbe)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ProbeDef_ExternalProbe:
		s := proto.Size(x.ExternalProbe)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ProbeDef_UdpProbe:
		s := proto.Size(x.UdpProbe)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ProbeDef_UdpListenerProbe:
		s := proto.Size(x.UdpListenerProbe)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ProbeDef_UserDefinedProbe:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(len(x.UserDefinedProbe)))
		n += len(x.UserDefinedProbe)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterType((*ProbeDef)(nil), "cloudprober.probes.ProbeDef")
	proto.RegisterEnum("cloudprober.probes.ProbeDef_Type", ProbeDef_Type_name, ProbeDef_Type_value)
}

func init() {
	proto.RegisterFile("github.com/google/cloudprober/probes/proto/config.proto", fileDescriptor_config_699221e7c78c5f06)
}

var fileDescriptor_config_699221e7c78c5f06 = []byte{
	// 685 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x5f, 0x6f, 0xd3, 0x3c,
	0x14, 0xc6, 0xd7, 0x7f, 0x6b, 0xe2, 0x76, 0x53, 0xe4, 0x77, 0x7b, 0xdf, 0xac, 0x37, 0x6f, 0x99,
	0x04, 0x74, 0x5c, 0xa4, 0xa3, 0x12, 0xa0, 0x0d, 0x24, 0x06, 0x4b, 0x61, 0x95, 0x4a, 0x56, 0xa5,
	0x1d, 0x82, 0xab, 0x28, 0x8d, 0xdd, 0xce, 0x52, 0xea, 0x54, 0x89, 0x3d, 0xb1, 0xbb, 0x7e, 0x12,
	0x3e, 0x0f, 0x1f, 0x0b, 0xd9, 0x89, 0xb7, 0x65, 0x64, 0x53, 0xc5, 0x95, 0xed, 0xe3, 0xe7, 0xfc,
	0xf4, 0x9c, 0x63, 0x1f, 0xf0, 0x66, 0x4e, 0xd8, 0x25, 0x9f, 0x5a, 0x41, 0xb4, 0xe8, 0xce, 0xa3,
	0x68, 0x1e, 0xe2, 0x6e, 0x10, 0x46, 0x1c, 0x2d, 0xe3, 0x68, 0x8a, 0xe3, 0xae, 0x5c, 0x12, 0xb1,
	0xb0, 0xa8, 0x1b, 0x44, 0x74, 0x46, 0xe6, 0x96, 0x3c, 0x40, 0x78, 0x47, 0x66, 0xa5, 0xb2, 0xd6,
	0xeb, 0xc7, 0x61, 0x0b, 0xcc, 0x62, 0x12, 0x28, 0x1a, 0x22, 0x09, 0x4b, 0x59, 0xad, 0x77, 0x6b,
	0x99, 0xb8, 0x64, 0x6c, 0x59, 0xe0, 0xa4, 0xf5, 0x76, 0xad, 0x6c, 0x44, 0x8b, 0xca, 0x68, 0x9d,
	0xac, 0x95, 0x8c, 0x7f, 0x30, 0x1c, 0x53, 0x3f, 0x2c, 0x22, 0xac, 0x67, 0x7e, 0x49, 0xe8, 0xfc,
	0xef, 0xcd, 0x73, 0x54, 0x58, 0xf9, 0xe9, 0xba, 0xc9, 0x21, 0x49, 0x18, 0xa6, 0x69, 0xe8, 0x3e,
	0xe4, 0xe8, 0x71, 0x08, 0xf3, 0xe3, 0x39, 0x66, 0xaa, 0x77, 0xd9, 0x69, 0x3d, 0xf3, 0x57, 0x7e,
	0x48, 0x90, 0xcf, 0xa2, 0xb8, 0xa8, 0xf3, 0xfb, 0x3f, 0x35, 0xa0, 0x8d, 0x84, 0xd0, 0xc6, 0x33,
	0x08, 0x41, 0x95, 0xfa, 0x0b, 0x6c, 0x96, 0xda, 0xe5, 0x8e, 0xee, 0xca, 0x3d, 0x7c, 0x05, 0xaa,
	0xec, 0x7a, 0x89, 0xcd, 0x72, 0xbb, 0xdc, 0xd9, 0xee, 0x3d, 0xb1, 0xfe, 0xfc, 0x70, 0x96, 0xca,
	0xb7, 0x26, 0xd7, 0x4b, 0xec, 0x4a, 0x39, 0xdc, 0x05, 0x9b, 0x31, 0xa7, 0x5e, 0x44, 0xcd, 0x4a,
	0xbb, 0xd4, 0xd1, 0xdd, 0x5a, 0xcc, 0xe9, 0x39, 0x85, 0x07, 0x60, 0x8b, 0x50, 0x86, 0xe3, 0x2b,
	0x3f, 0xf4, 0x16, 0x09, 0x0e, 0xcc, 0x6a, 0xbb, 0xd4, 0xa9, 0x1d, 0x57, 0x7b, 0x87, 0x87, 0x87,
	0x6e, 0x53, 0x5d, 0x7d, 0x49, 0x70, 0x00, 0x9f, 0x83, 0x26, 0x23, 0x0b, 0x1c, 0x71, 0x96, 0x2a,
	0x6b, 0xa9, 0xf2, 0xa5, 0x50, 0x36, 0xb2, 0x1b, 0x29, 0x3c, 0x02, 0xf5, 0xac, 0x21, 0xe6, 0x66,
	0xbb, 0xdc, 0x69, 0xf4, 0xfe, 0xcf, 0x99, 0x54, 0xcd, 0x9a, 0xa4, 0xab, 0x8d, 0x67, 0xae, 0xd2,
	0xc3, 0x21, 0xd8, 0x09, 0x7d, 0x86, 0x69, 0x70, 0xed, 0x89, 0x41, 0x88, 0xc9, 0x94, 0x33, 0x12,
	0x51, 0xb3, 0xde, 0x2e, 0x75, 0x1a, 0xbd, 0xbd, 0x1c, 0x27, 0x9b, 0x1b, 0xcb, 0x26, 0x09, 0x73,
	0xff, 0xc9, 0xd2, 0xec, 0x3b, 0x59, 0xf0, 0x29, 0x68, 0x2a, 0x1a, 0xa7, 0x84, 0x99, 0x9a, 0xa8,
	0xfc, 0xb8, 0xcc, 0x13, 0xb7, 0x91, 0xc5, 0x2f, 0x28, 0x61, 0xf0, 0x3d, 0xd0, 0x6f, 0xde, 0xc4,
	0xd4, 0xdb, 0x95, 0x4e, 0xe3, 0x5e, 0x5b, 0x6f, 0x5f, 0xcc, 0xfa, 0xaa, 0xb6, 0xee, 0x6d, 0x0e,
	0x3c, 0x05, 0x40, 0x7c, 0x64, 0x4f, 0xca, 0xcd, 0x1d, 0xe9, 0x75, 0xbf, 0xe8, 0x61, 0x84, 0x2a,
	0x7d, 0x9d, 0xd3, 0x88, 0xce, 0xce, 0x36, 0x5c, 0x5d, 0x44, 0x64, 0x40, 0x40, 0xc4, 0x28, 0x67,
	0x90, 0xdd, 0x87, 0x21, 0x42, 0x95, 0x87, 0x88, 0x48, 0x0a, 0x39, 0x01, 0x3a, 0xa2, 0x49, 0xc6,
	0xf8, 0x57, 0x32, 0x0a, 0x7f, 0x08, 0xa2, 0x49, 0x0e, 0xa1, 0x21, 0x9a, 0xa4, 0x84, 0x73, 0xb0,
	0xad, 0xc6, 0x3a, 0xc3, 0xfc, 0x27, 0x31, 0xcf, 0x8a, 0x30, 0x4a, 0x99, 0x63, 0x6d, 0xa9, 0xe8,
	0x8d, 0x25, 0x8e, 0x54, 0x59, 0xe6, 0xc3, 0x96, 0x38, 0xca, 0x57, 0xa5, 0x71, 0x94, 0x15, 0xf5,
	0x1d, 0x40, 0x41, 0x50, 0xd3, 0x9a, 0xa1, 0xf6, 0x24, 0xea, 0xe0, 0x01, 0x94, 0x12, 0xe7, 0x90,
	0x06, 0x47, 0xcb, 0x61, 0x76, 0x91, 0xa2, 0x2d, 0x00, 0x79, 0x82, 0x63, 0x0f, 0xe1, 0x19, 0xa1,
	0x18, 0x65, 0xe8, 0x40, 0xfc, 0x13, 0xa9, 0x4f, 0x70, 0x6c, 0xa7, 0x57, 0x52, 0xbf, 0xbf, 0x00,
	0x55, 0x31, 0x53, 0x50, 0x03, 0xd5, 0xd1, 0xc0, 0xf9, 0x6c, 0x6c, 0x88, 0xdd, 0xd9, 0x64, 0x32,
	0x32, 0x4a, 0xb0, 0x0e, 0x2a, 0xb6, 0x33, 0x36, 0xca, 0xb0, 0x09, 0xb4, 0xfe, 0xb7, 0x49, 0xdf,
	0x75, 0x3e, 0x0c, 0x8d, 0x8a, 0x08, 0x5f, 0xd8, 0x23, 0xa3, 0x0a, 0x0d, 0xd0, 0xbc, 0xb0, 0x47,
	0xde, 0x70, 0x30, 0x9e, 0xf4, 0x9d, 0xbe, 0x6b, 0xd4, 0xe0, 0x16, 0xd0, 0x85, 0xd0, 0x19, 0x0f,
	0xce, 0x1d, 0x63, 0x2a, 0x05, 0xe3, 0xbe, 0xeb, 0xd9, 0xfd, 0x4f, 0x03, 0xa7, 0x6f, 0x1b, 0xc1,
	0x0b, 0x5d, 0xfb, 0x55, 0x32, 0x56, 0xab, 0xd5, 0xaa, 0xfc, 0xb1, 0x0e, 0x6a, 0xd2, 0xdc, 0xef,
	0x00, 0x00, 0x00, 0xff, 0xff, 0xb5, 0xea, 0x13, 0x8e, 0x9b, 0x06, 0x00, 0x00,
}