silenced.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: silenced.proto

package v2

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import bytes "bytes"

import github_com_golang_protobuf_proto "github.com/golang/protobuf/proto"

import io "io"

// 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

// Silenced is the representation of a silence entry.
type Silenced struct {
	// Metadata contains the name, namespace, labels and annotations of the silenced
	ObjectMeta `protobuf:"bytes,1,opt,name=metadata,embedded=metadata" json:"metadata,omitempty"`
	// Expire is the number of seconds the entry will live
	Expire int64 `protobuf:"varint,2,opt,name=expire,proto3" json:"expire"`
	// ExpireOnResolve defaults to false, clears the entry on resolution when set
	// to true
	ExpireOnResolve bool `protobuf:"varint,3,opt,name=expire_on_resolve,json=expireOnResolve,proto3" json:"expire_on_resolve"`
	// Creator is the author of the silenced entry
	Creator string `protobuf:"bytes,4,opt,name=creator,proto3" json:"creator,omitempty"`
	// Check is the name of the check event to be silenced.
	Check string `protobuf:"bytes,5,opt,name=check,proto3" json:"check,omitempty"`
	// Reason is used to provide context to the entry
	Reason string `protobuf:"bytes,6,opt,name=reason,proto3" json:"reason,omitempty"`
	// Subscription is the name of the subscription to which the entry applies.
	Subscription string `protobuf:"bytes,7,opt,name=subscription,proto3" json:"subscription,omitempty"`
	// Begin is a timestamp at which the silenced entry takes effect.
	Begin                int64    `protobuf:"varint,10,opt,name=begin,proto3" json:"begin"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Silenced) Reset()         { *m = Silenced{} }
func (m *Silenced) String() string { return proto.CompactTextString(m) }
func (*Silenced) ProtoMessage()    {}
func (*Silenced) Descriptor() ([]byte, []int) {
	return fileDescriptor_silenced_a3ec7114335df4ca, []int{0}
}
func (m *Silenced) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Silenced) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Silenced.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Silenced) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Silenced.Merge(dst, src)
}
func (m *Silenced) XXX_Size() int {
	return m.Size()
}
func (m *Silenced) XXX_DiscardUnknown() {
	xxx_messageInfo_Silenced.DiscardUnknown(m)
}

var xxx_messageInfo_Silenced proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Silenced)(nil), "sensu.core.v2.Silenced")
}
func (this *Silenced) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Silenced)
	if !ok {
		that2, ok := that.(Silenced)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ObjectMeta.Equal(&that1.ObjectMeta) {
		return false
	}
	if this.Expire != that1.Expire {
		return false
	}
	if this.ExpireOnResolve != that1.ExpireOnResolve {
		return false
	}
	if this.Creator != that1.Creator {
		return false
	}
	if this.Check != that1.Check {
		return false
	}
	if this.Reason != that1.Reason {
		return false
	}
	if this.Subscription != that1.Subscription {
		return false
	}
	if this.Begin != that1.Begin {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}

type SilencedFace interface {
	Proto() github_com_golang_protobuf_proto.Message
	GetObjectMeta() ObjectMeta
	GetExpire() int64
	GetExpireOnResolve() bool
	GetCreator() string
	GetCheck() string
	GetReason() string
	GetSubscription() string
	GetBegin() int64
}

func (this *Silenced) Proto() github_com_golang_protobuf_proto.Message {
	return this
}

func (this *Silenced) TestProto() github_com_golang_protobuf_proto.Message {
	return NewSilencedFromFace(this)
}

func (this *Silenced) GetObjectMeta() ObjectMeta {
	return this.ObjectMeta
}

func (this *Silenced) GetExpire() int64 {
	return this.Expire
}

func (this *Silenced) GetExpireOnResolve() bool {
	return this.ExpireOnResolve
}

func (this *Silenced) GetCreator() string {
	return this.Creator
}

func (this *Silenced) GetCheck() string {
	return this.Check
}

func (this *Silenced) GetReason() string {
	return this.Reason
}

func (this *Silenced) GetSubscription() string {
	return this.Subscription
}

func (this *Silenced) GetBegin() int64 {
	return this.Begin
}

func NewSilencedFromFace(that SilencedFace) *Silenced {
	this := &Silenced{}
	this.ObjectMeta = that.GetObjectMeta()
	this.Expire = that.GetExpire()
	this.ExpireOnResolve = that.GetExpireOnResolve()
	this.Creator = that.GetCreator()
	this.Check = that.GetCheck()
	this.Reason = that.GetReason()
	this.Subscription = that.GetSubscription()
	this.Begin = that.GetBegin()
	return this
}

func (m *Silenced) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Silenced) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintSilenced(dAtA, i, uint64(m.ObjectMeta.Size()))
	n1, err := m.ObjectMeta.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	if m.Expire != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintSilenced(dAtA, i, uint64(m.Expire))
	}
	if m.ExpireOnResolve {
		dAtA[i] = 0x18
		i++
		if m.ExpireOnResolve {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.Creator) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintSilenced(dAtA, i, uint64(len(m.Creator)))
		i += copy(dAtA[i:], m.Creator)
	}
	if len(m.Check) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintSilenced(dAtA, i, uint64(len(m.Check)))
		i += copy(dAtA[i:], m.Check)
	}
	if len(m.Reason) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintSilenced(dAtA, i, uint64(len(m.Reason)))
		i += copy(dAtA[i:], m.Reason)
	}
	if len(m.Subscription) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintSilenced(dAtA, i, uint64(len(m.Subscription)))
		i += copy(dAtA[i:], m.Subscription)
	}
	if m.Begin != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintSilenced(dAtA, i, uint64(m.Begin))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintSilenced(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func NewPopulatedSilenced(r randySilenced, easy bool) *Silenced {
	this := &Silenced{}
	v1 := NewPopulatedObjectMeta(r, easy)
	this.ObjectMeta = *v1
	this.Expire = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Expire *= -1
	}
	this.ExpireOnResolve = bool(bool(r.Intn(2) == 0))
	this.Creator = string(randStringSilenced(r))
	this.Check = string(randStringSilenced(r))
	this.Reason = string(randStringSilenced(r))
	this.Subscription = string(randStringSilenced(r))
	this.Begin = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Begin *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedSilenced(r, 11)
	}
	return this
}

type randySilenced interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneSilenced(r randySilenced) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringSilenced(r randySilenced) string {
	v2 := r.Intn(100)
	tmps := make([]rune, v2)
	for i := 0; i < v2; i++ {
		tmps[i] = randUTF8RuneSilenced(r)
	}
	return string(tmps)
}
func randUnrecognizedSilenced(r randySilenced, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldSilenced(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldSilenced(dAtA []byte, r randySilenced, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateSilenced(dAtA, uint64(key))
		v3 := r.Int63()
		if r.Intn(2) == 0 {
			v3 *= -1
		}
		dAtA = encodeVarintPopulateSilenced(dAtA, uint64(v3))
	case 1:
		dAtA = encodeVarintPopulateSilenced(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateSilenced(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateSilenced(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateSilenced(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateSilenced(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Silenced) Size() (n int) {
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovSilenced(uint64(l))
	if m.Expire != 0 {
		n += 1 + sovSilenced(uint64(m.Expire))
	}
	if m.ExpireOnResolve {
		n += 2
	}
	l = len(m.Creator)
	if l > 0 {
		n += 1 + l + sovSilenced(uint64(l))
	}
	l = len(m.Check)
	if l > 0 {
		n += 1 + l + sovSilenced(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovSilenced(uint64(l))
	}
	l = len(m.Subscription)
	if l > 0 {
		n += 1 + l + sovSilenced(uint64(l))
	}
	if m.Begin != 0 {
		n += 1 + sovSilenced(uint64(m.Begin))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovSilenced(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozSilenced(x uint64) (n int) {
	return sovSilenced(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Silenced) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSilenced
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Silenced: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Silenced: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSilenced
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Expire", wireType)
			}
			m.Expire = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Expire |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpireOnResolve", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ExpireOnResolve = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSilenced
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Creator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Check", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSilenced
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Check = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSilenced
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subscription", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSilenced
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subscription = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Begin", wireType)
			}
			m.Begin = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Begin |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSilenced(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthSilenced
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipSilenced(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowSilenced
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowSilenced
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthSilenced
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowSilenced
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipSilenced(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthSilenced = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSilenced   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("silenced.proto", fileDescriptor_silenced_a3ec7114335df4ca) }

var fileDescriptor_silenced_a3ec7114335df4ca = []byte{
	// 370 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0x3f, 0x8e, 0xd3, 0x40,
	0x14, 0x87, 0x33, 0xf9, 0xe3, 0x38, 0x03, 0x04, 0x31, 0xa2, 0x98, 0x44, 0x68, 0x6c, 0x51, 0x20,
	0x17, 0xe0, 0x48, 0xa1, 0xa3, 0xb4, 0x44, 0x89, 0x22, 0x19, 0xd1, 0xd0, 0x44, 0xf6, 0xe4, 0xe1,
	0x18, 0x62, 0x8f, 0x35, 0x1e, 0x47, 0x70, 0x03, 0x8e, 0xb0, 0x65, 0xca, 0x1c, 0x61, 0x8f, 0x90,
	0x32, 0x27, 0xb0, 0x76, 0xbd, 0x5d, 0x4e, 0xb0, 0xdb, 0xad, 0xe2, 0x71, 0x56, 0x89, 0xb6, 0x7a,
	0xef, 0x7d, 0xef, 0xf7, 0x3d, 0xcb, 0x1a, 0x3c, 0xcc, 0xe3, 0x15, 0xa4, 0x1c, 0x16, 0x6e, 0x26,
	0x85, 0x12, 0xe4, 0x55, 0x0e, 0x69, 0x5e, 0xb8, 0x5c, 0x48, 0x70, 0xd7, 0xd3, 0xf1, 0xa7, 0x28,
	0x56, 0xcb, 0x22, 0x74, 0xb9, 0x48, 0x26, 0x91, 0x88, 0xc4, 0xa4, 0x4e, 0x85, 0xc5, 0xaf, 0x7a,
	0xaa, 0x87, 0xba, 0xd3, 0xf6, 0x18, 0x27, 0xa0, 0x02, 0xdd, 0xbf, 0x7f, 0x68, 0x63, 0xf3, 0x7b,
	0x73, 0x9c, 0xfc, 0xc0, 0xe6, 0x71, 0xb5, 0x08, 0x54, 0x40, 0x91, 0x8d, 0x9c, 0x17, 0xd3, 0x91,
	0x7b, 0xf1, 0x25, 0x77, 0x16, 0xfe, 0x06, 0xae, 0xbe, 0x81, 0x0a, 0x3c, 0xb6, 0x2b, 0xad, 0xd6,
	0xbe, 0xb4, 0xd0, 0xa1, 0xb4, 0xc8, 0x49, 0xfb, 0x28, 0x92, 0x58, 0x41, 0x92, 0xa9, 0x7f, 0xfe,
	0xd3, 0x29, 0xf2, 0x01, 0x1b, 0xf0, 0x37, 0x8b, 0x25, 0xd0, 0xb6, 0x8d, 0x9c, 0x8e, 0x37, 0xdc,
	0x69, 0xab, 0xa1, 0x7e, 0x53, 0xc9, 0x57, 0xfc, 0x46, 0x77, 0x73, 0x91, 0xce, 0x25, 0xe4, 0x62,
	0xb5, 0x06, 0xda, 0xb1, 0x91, 0x63, 0x7a, 0xa3, 0x46, 0x79, 0x1e, 0xf0, 0x5f, 0x6b, 0x34, 0x4b,
	0x7d, 0x0d, 0x08, 0xc3, 0x7d, 0x2e, 0x21, 0x50, 0x42, 0xd2, 0xae, 0x8d, 0x9c, 0x81, 0xd7, 0x3d,
	0xca, 0xfe, 0x09, 0x92, 0xb7, 0xb8, 0xc7, 0x97, 0xc0, 0xff, 0xd0, 0xde, 0x71, 0xeb, 0xeb, 0x81,
	0xbc, 0xc3, 0x86, 0x84, 0x20, 0x17, 0x29, 0x35, 0xce, 0xa4, 0x86, 0x11, 0x07, 0xbf, 0xcc, 0x8b,
	0x30, 0xe7, 0x32, 0xce, 0x54, 0x2c, 0x52, 0xda, 0x3f, 0xcb, 0x5c, 0x6c, 0x88, 0x85, 0x7b, 0x21,
	0x44, 0x71, 0x4a, 0x71, 0xfd, 0xaf, 0x83, 0x43, 0x69, 0x69, 0xe0, 0xeb, 0xf2, 0xc5, 0xfc, 0xbf,
	0xb1, 0x5a, 0xdb, 0x8d, 0x85, 0x3c, 0xfb, 0xfe, 0x96, 0xa1, 0x6d, 0xc5, 0xd0, 0x75, 0xc5, 0xd0,
	0xae, 0x62, 0x68, 0x5f, 0x31, 0x74, 0x53, 0x31, 0x74, 0x75, 0xc7, 0x5a, 0x3f, 0xdb, 0xeb, 0x69,
	0x68, 0xd4, 0x8f, 0xf4, 0xf9, 0x31, 0x00, 0x00, 0xff, 0xff, 0xf7, 0x99, 0xfa, 0x6d, 0x00, 0x02,
	0x00, 0x00,
}