event.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lookout/sdk/event.proto

package pb

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

import gopkg_in_src_d_go_git_v4_plumbing "gopkg.in/src-d/go-git.v4/plumbing"
import time "time"

import github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"

import io "io"

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

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// CommitRevision defines a range of commits, from a base to a head.
type CommitRevision struct {
	// Base of the revision range.
	Base ReferencePointer `protobuf:"bytes,1,opt,name=base,proto3" json:"base"`
	// Head of the revision range.
	Head ReferencePointer `protobuf:"bytes,2,opt,name=head,proto3" json:"head"`
}

func (m *CommitRevision) Reset()         { *m = CommitRevision{} }
func (m *CommitRevision) String() string { return proto.CompactTextString(m) }
func (*CommitRevision) ProtoMessage()    {}
func (*CommitRevision) Descriptor() ([]byte, []int) {
	return fileDescriptor_event_29c7a014c04ea3ce, []int{0}
}
func (m *CommitRevision) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CommitRevision) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommitRevision.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 *CommitRevision) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommitRevision.Merge(dst, src)
}
func (m *CommitRevision) XXX_Size() int {
	return m.Size()
}
func (m *CommitRevision) XXX_DiscardUnknown() {
	xxx_messageInfo_CommitRevision.DiscardUnknown(m)
}

var xxx_messageInfo_CommitRevision proto.InternalMessageInfo

// ReferencePointer is a pointer to a git refererence in a repository.
type ReferencePointer struct {
	// InternalRepositoryURL is the original clone URL, not canonicalized.
	InternalRepositoryURL string `protobuf:"bytes,1,opt,name=internal_repository_url,json=internalRepositoryUrl,proto3" json:"internal_repository_url,omitempty"`
	// ReferenceName is the name of the target reference.
	ReferenceName gopkg_in_src_d_go_git_v4_plumbing.ReferenceName `protobuf:"bytes,2,opt,name=reference_name,json=referenceName,proto3,casttype=gopkg.in/src-d/go-git.v4/plumbing.ReferenceName" json:"reference_name,omitempty"`
	// Hash is the full SHA1 of the target reference.
	Hash string `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash,omitempty"`
}

func (m *ReferencePointer) Reset()         { *m = ReferencePointer{} }
func (m *ReferencePointer) String() string { return proto.CompactTextString(m) }
func (*ReferencePointer) ProtoMessage()    {}
func (*ReferencePointer) Descriptor() ([]byte, []int) {
	return fileDescriptor_event_29c7a014c04ea3ce, []int{1}
}
func (m *ReferencePointer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReferencePointer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReferencePointer.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 *ReferencePointer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReferencePointer.Merge(dst, src)
}
func (m *ReferencePointer) XXX_Size() int {
	return m.Size()
}
func (m *ReferencePointer) XXX_DiscardUnknown() {
	xxx_messageInfo_ReferencePointer.DiscardUnknown(m)
}

var xxx_messageInfo_ReferencePointer proto.InternalMessageInfo

// PushEvent represents a Push to a git repository.
type PushEvent struct {
	// Provider triggering this event.
	Provider string `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"`
	// InternalId is the internal id for this event at the provider.
	InternalID string `protobuf:"bytes,2,opt,name=internal_id,json=internalId,proto3" json:"internal_id,omitempty"`
	// CreatedAt is the timestamp of the creation date of the push event.
	CreatedAt time.Time `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"`
	// Commits is the number of commits in the push.
	Commits uint32 `protobuf:"varint,4,opt,name=commits,proto3" json:"commits,omitempty"`
	// DistinctCommits is the number of distinct commits in the push.
	DistinctCommits uint32 `protobuf:"varint,5,opt,name=distinct_commits,json=distinctCommits,proto3" json:"distinct_commits,omitempty"`
	// Configuration related to the specific analyzer receiving the PushEvent.
	Configuration types.Struct `protobuf:"bytes,6,opt,name=configuration,proto3" json:"configuration"`
	// CommitRevision is the revision range of this push.
	CommitRevision `protobuf:"bytes,7,opt,name=commit_revision,json=commitRevision,proto3,embedded=commit_revision" json:"commit_revision"`
}

func (m *PushEvent) Reset()         { *m = PushEvent{} }
func (m *PushEvent) String() string { return proto.CompactTextString(m) }
func (*PushEvent) ProtoMessage()    {}
func (*PushEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_event_29c7a014c04ea3ce, []int{2}
}
func (m *PushEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushEvent.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 *PushEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushEvent.Merge(dst, src)
}
func (m *PushEvent) XXX_Size() int {
	return m.Size()
}
func (m *PushEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_PushEvent.DiscardUnknown(m)
}

var xxx_messageInfo_PushEvent proto.InternalMessageInfo

// ReviewEvent represents a Review (pull request in case of GitHub) being created or updated.
type ReviewEvent struct {
	// Provider triggering this event.
	Provider string `protobuf:"bytes,1,opt,name=provider,proto3" json:"provider,omitempty"`
	// InternalId is the internal id for this event at the provider.
	InternalID string `protobuf:"bytes,2,opt,name=internal_id,json=internalId,proto3" json:"internal_id,omitempty"`
	// CreatedAt is the timestamp of the creation date of the review event.
	CreatedAt time.Time `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3,stdtime" json:"created_at"`
	// UpdatedAt is the timestamp of the last modification of the pull request.
	UpdatedAt time.Time `protobuf:"bytes,4,opt,name=updated_at,json=updatedAt,proto3,stdtime" json:"updated_at"`
	// IsMergeable, if the pull request is mergeable.
	IsMergeable bool `protobuf:"varint,5,opt,name=is_mergeable,json=isMergeable,proto3" json:"is_mergeable,omitempty"`
	// Source reference to the original branch and repository where the changes came from.
	Source ReferencePointer `protobuf:"bytes,8,opt,name=source,proto3" json:"source"`
	// Configuration related to the specific analyzer receiving the ReviewEvent.
	Configuration types.Struct `protobuf:"bytes,10,opt,name=configuration,proto3" json:"configuration"`
	// RepositoryId is internal provider repository id
	RepositoryID uint32 `protobuf:"varint,11,opt,name=repository_id,json=repositoryId,proto3" json:"repository_id,omitempty"`
	// Number is internal provider id of review scoped by repository
	Number uint32 `protobuf:"varint,12,opt,name=number,proto3" json:"number,omitempty"`
	// CommitRevision is the revision range of this review.
	CommitRevision `protobuf:"bytes,7,opt,name=commit_revision,json=commitRevision,proto3,embedded=commit_revision" json:"commit_revision"`
}

func (m *ReviewEvent) Reset()         { *m = ReviewEvent{} }
func (m *ReviewEvent) String() string { return proto.CompactTextString(m) }
func (*ReviewEvent) ProtoMessage()    {}
func (*ReviewEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_event_29c7a014c04ea3ce, []int{3}
}
func (m *ReviewEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReviewEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReviewEvent.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 *ReviewEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReviewEvent.Merge(dst, src)
}
func (m *ReviewEvent) XXX_Size() int {
	return m.Size()
}
func (m *ReviewEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_ReviewEvent.DiscardUnknown(m)
}

var xxx_messageInfo_ReviewEvent proto.InternalMessageInfo

func init() {
	proto.RegisterType((*CommitRevision)(nil), "pb.CommitRevision")
	proto.RegisterType((*ReferencePointer)(nil), "pb.ReferencePointer")
	proto.RegisterType((*PushEvent)(nil), "pb.PushEvent")
	proto.RegisterType((*ReviewEvent)(nil), "pb.ReviewEvent")
}
func (m *CommitRevision) 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 *CommitRevision) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintEvent(dAtA, i, uint64(m.Base.Size()))
	n1, err := m.Base.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	dAtA[i] = 0x12
	i++
	i = encodeVarintEvent(dAtA, i, uint64(m.Head.Size()))
	n2, err := m.Head.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	return i, nil
}

func (m *ReferencePointer) 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 *ReferencePointer) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.InternalRepositoryURL) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.InternalRepositoryURL)))
		i += copy(dAtA[i:], m.InternalRepositoryURL)
	}
	if len(m.ReferenceName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.ReferenceName)))
		i += copy(dAtA[i:], m.ReferenceName)
	}
	if len(m.Hash) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Hash)))
		i += copy(dAtA[i:], m.Hash)
	}
	return i, nil
}

func (m *PushEvent) 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 *PushEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Provider) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Provider)))
		i += copy(dAtA[i:], m.Provider)
	}
	if len(m.InternalID) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.InternalID)))
		i += copy(dAtA[i:], m.InternalID)
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
	n3, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	if m.Commits != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.Commits))
	}
	if m.DistinctCommits != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.DistinctCommits))
	}
	dAtA[i] = 0x32
	i++
	i = encodeVarintEvent(dAtA, i, uint64(m.Configuration.Size()))
	n4, err := m.Configuration.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	dAtA[i] = 0x3a
	i++
	i = encodeVarintEvent(dAtA, i, uint64(m.CommitRevision.Size()))
	n5, err := m.CommitRevision.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	return i, nil
}

func (m *ReviewEvent) 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 *ReviewEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Provider) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.Provider)))
		i += copy(dAtA[i:], m.Provider)
	}
	if len(m.InternalID) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEvent(dAtA, i, uint64(len(m.InternalID)))
		i += copy(dAtA[i:], m.InternalID)
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)))
	n6, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	dAtA[i] = 0x22
	i++
	i = encodeVarintEvent(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)))
	n7, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdatedAt, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	if m.IsMergeable {
		dAtA[i] = 0x28
		i++
		if m.IsMergeable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	dAtA[i] = 0x3a
	i++
	i = encodeVarintEvent(dAtA, i, uint64(m.CommitRevision.Size()))
	n8, err := m.CommitRevision.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n8
	dAtA[i] = 0x42
	i++
	i = encodeVarintEvent(dAtA, i, uint64(m.Source.Size()))
	n9, err := m.Source.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	dAtA[i] = 0x52
	i++
	i = encodeVarintEvent(dAtA, i, uint64(m.Configuration.Size()))
	n10, err := m.Configuration.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n10
	if m.RepositoryID != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.RepositoryID))
	}
	if m.Number != 0 {
		dAtA[i] = 0x60
		i++
		i = encodeVarintEvent(dAtA, i, uint64(m.Number))
	}
	return i, nil
}

func encodeVarintEvent(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 (m *CommitRevision) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Base.Size()
	n += 1 + l + sovEvent(uint64(l))
	l = m.Head.Size()
	n += 1 + l + sovEvent(uint64(l))
	return n
}

func (m *ReferencePointer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.InternalRepositoryURL)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.ReferenceName)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	return n
}

func (m *PushEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Provider)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.InternalID)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
	n += 1 + l + sovEvent(uint64(l))
	if m.Commits != 0 {
		n += 1 + sovEvent(uint64(m.Commits))
	}
	if m.DistinctCommits != 0 {
		n += 1 + sovEvent(uint64(m.DistinctCommits))
	}
	l = m.Configuration.Size()
	n += 1 + l + sovEvent(uint64(l))
	l = m.CommitRevision.Size()
	n += 1 + l + sovEvent(uint64(l))
	return n
}

func (m *ReviewEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Provider)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = len(m.InternalID)
	if l > 0 {
		n += 1 + l + sovEvent(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreatedAt)
	n += 1 + l + sovEvent(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdatedAt)
	n += 1 + l + sovEvent(uint64(l))
	if m.IsMergeable {
		n += 2
	}
	l = m.CommitRevision.Size()
	n += 1 + l + sovEvent(uint64(l))
	l = m.Source.Size()
	n += 1 + l + sovEvent(uint64(l))
	l = m.Configuration.Size()
	n += 1 + l + sovEvent(uint64(l))
	if m.RepositoryID != 0 {
		n += 1 + sovEvent(uint64(m.RepositoryID))
	}
	if m.Number != 0 {
		n += 1 + sovEvent(uint64(m.Number))
	}
	return n
}

func sovEvent(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozEvent(x uint64) (n int) {
	return sovEvent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *CommitRevision) 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 ErrIntOverflowEvent
			}
			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: CommitRevision: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommitRevision: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Base.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Head", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Head.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReferencePointer) 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 ErrIntOverflowEvent
			}
			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: ReferencePointer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReferencePointer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalRepositoryURL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InternalRepositoryURL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReferenceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReferenceName = gopkg_in_src_d_go_git_v4_plumbing.ReferenceName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushEvent) 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 ErrIntOverflowEvent
			}
			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: PushEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Provider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InternalID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commits", wireType)
			}
			m.Commits = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Commits |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DistinctCommits", wireType)
			}
			m.DistinctCommits = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DistinctCommits |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Configuration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Configuration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitRevision", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CommitRevision.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReviewEvent) 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 ErrIntOverflowEvent
			}
			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: ReviewEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReviewEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Provider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InternalID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				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 ErrInvalidLengthEvent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InternalID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdatedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsMergeable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsMergeable = bool(v != 0)
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitRevision", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CommitRevision.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Configuration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEvent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Configuration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepositoryID", wireType)
			}
			m.RepositoryID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RepositoryID |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
			}
			m.Number = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Number |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEvent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEvent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEvent(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, ErrIntOverflowEvent
			}
			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, ErrIntOverflowEvent
				}
				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, ErrIntOverflowEvent
				}
				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, ErrInvalidLengthEvent
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowEvent
					}
					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 := skipEvent(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 (
	ErrInvalidLengthEvent = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvent   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("lookout/sdk/event.proto", fileDescriptor_event_29c7a014c04ea3ce) }

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