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

package logpattern_go_proto

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	proto "github.com/gogo/protobuf/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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// The path a package in a repo
type Package struct {
	// repo name
	// e.g. "tidb", "tikv", "github.com/pingcap/tidb"
	Repo string `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	// the path relative to repo root e.g. "pkg/util"
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// repo git hash
	Hash string `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash,omitempty"`
	// repo git tag
	Tag string `protobuf:"bytes,4,opt,name=tag,proto3" json:"tag,omitempty"`
}

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

var xxx_messageInfo_Package proto.InternalMessageInfo

func (m *Package) GetRepo() string {
	if m != nil {
		return m.Repo
	}
	return ""
}

func (m *Package) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *Package) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *Package) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

// The position of a code byte in the code file
type CodePosition struct {
	// The line number within code file
	Line int32 `protobuf:"varint,1,opt,name=line,proto3" json:"line,omitempty"`
	// The column within code file
	Column int32 `protobuf:"varint,2,opt,name=column,proto3" json:"column,omitempty"`
}

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

var xxx_messageInfo_CodePosition proto.InternalMessageInfo

func (m *CodePosition) GetLine() int32 {
	if m != nil {
		return m.Line
	}
	return 0
}

func (m *CodePosition) GetColumn() int32 {
	if m != nil {
		return m.Column
	}
	return 0
}

// A Position represents a unique location within a repo.
type Position struct {
	PackageInfo *Package `protobuf:"bytes,1,opt,name=package_info,json=packageInfo,proto3" json:"package_info,omitempty"`
	// A path-structured label describing the location of this object relative to
	// the repo. For code, this will generally be the relative
	// path to the file containing the log, e.g., "dm/dm-master/service.go" in dm.
	FilePath string `protobuf:"bytes,2,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
	// The start code byte position
	Pos *CodePosition `protobuf:"bytes,3,opt,name=pos,proto3" json:"pos,omitempty"`
	// The end code byte position
	EndPos *CodePosition `protobuf:"bytes,4,opt,name=end_pos,json=endPos,proto3" json:"end_pos,omitempty"`
}

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

var xxx_messageInfo_Position proto.InternalMessageInfo

func (m *Position) GetPackageInfo() *Package {
	if m != nil {
		return m.PackageInfo
	}
	return nil
}

func (m *Position) GetFilePath() string {
	if m != nil {
		return m.FilePath
	}
	return ""
}

func (m *Position) GetPos() *CodePosition {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *Position) GetEndPos() *CodePosition {
	if m != nil {
		return m.EndPos
	}
	return nil
}

// Function information
type FuncInfo struct {
	// The function name
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Function definied position
	Pos *Position `protobuf:"bytes,2,opt,name=pos,proto3" json:"pos,omitempty"`
	// Function code
	Code []byte `protobuf:"bytes,3,opt,name=code,proto3" json:"code,omitempty"`
}

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

var xxx_messageInfo_FuncInfo proto.InternalMessageInfo

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

func (m *FuncInfo) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *FuncInfo) GetCode() []byte {
	if m != nil {
		return m.Code
	}
	return nil
}

// A LogPattern represents a log in code file
type LogPattern struct {
	// log position
	Pos *Position `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
	// The function this log belongs to
	Func *FuncInfo `protobuf:"bytes,2,opt,name=func,proto3" json:"func,omitempty"`
	// log level "info,warn,error" if has
	Level string `protobuf:"bytes,3,opt,name=level,proto3" json:"level,omitempty"`
	// used to quickly identify the log,
	// e.g. the `format` field of Printf(format string, v ...interface{}) in
	Signature []string `protobuf:"bytes,4,rep,name=signature,proto3" json:"signature,omitempty"`
	// the defer log" defer log.Error(...)
	IsDeferLog bool `protobuf:"varint,5,opt,name=is_defer_log,json=isDeferLog,proto3" json:"is_defer_log,omitempty"`
}

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

var xxx_messageInfo_LogPattern proto.InternalMessageInfo

func (m *LogPattern) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *LogPattern) GetFunc() *FuncInfo {
	if m != nil {
		return m.Func
	}
	return nil
}

func (m *LogPattern) GetLevel() string {
	if m != nil {
		return m.Level
	}
	return ""
}

func (m *LogPattern) GetSignature() []string {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *LogPattern) GetIsDeferLog() bool {
	if m != nil {
		return m.IsDeferLog
	}
	return false
}

// Coverage data
type Coverage struct {
	// code position
	Pos *Position `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
	// total count to be covered
	CovCount int32 `protobuf:"varint,2,opt,name=cov_count,json=covCount,proto3" json:"cov_count,omitempty"`
	// the count to be covered in every file
	CovCountByLog map[string]int32 `protobuf:"bytes,3,rep,name=cov_count_by_log,json=covCountByLog,proto3" json:"cov_count_by_log,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// log message contain a log example
	Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_Coverage proto.InternalMessageInfo

func (m *Coverage) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *Coverage) GetCovCount() int32 {
	if m != nil {
		return m.CovCount
	}
	return 0
}

func (m *Coverage) GetCovCountByLog() map[string]int32 {
	if m != nil {
		return m.CovCountByLog
	}
	return nil
}

func (m *Coverage) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

// An UnknowLogPattern represents a log pattern that not captured by log extractor
// but exits in log
type UnknowLogPattern struct {
	// log position
	Pos *Position `protobuf:"bytes,1,opt,name=pos,proto3" json:"pos,omitempty"`
	// log level "info,warn,error" if has
	Level string `protobuf:"bytes,2,opt,name=level,proto3" json:"level,omitempty"`
	// total count to be covered
	CovCount int32 `protobuf:"varint,3,opt,name=cov_count,json=covCount,proto3" json:"cov_count,omitempty"`
	// the count to be covered in every file
	CovCountByLog map[string]int32 `protobuf:"bytes,4,rep,name=cov_count_by_log,json=covCountByLog,proto3" json:"cov_count_by_log,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// log message contain a log example
	Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_UnknowLogPattern proto.InternalMessageInfo

func (m *UnknowLogPattern) GetPos() *Position {
	if m != nil {
		return m.Pos
	}
	return nil
}

func (m *UnknowLogPattern) GetLevel() string {
	if m != nil {
		return m.Level
	}
	return ""
}

func (m *UnknowLogPattern) GetCovCount() int32 {
	if m != nil {
		return m.CovCount
	}
	return 0
}

func (m *UnknowLogPattern) GetCovCountByLog() map[string]int32 {
	if m != nil {
		return m.CovCountByLog
	}
	return nil
}

func (m *UnknowLogPattern) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

// LogPatternRule is used to filter log printing pattern in the code,
// which is referred to as log pattern.
// usage:
// LogPatternRule.log_level = ["error", "warn"] will filter error or warn level log print pattern
// LogPatternRule.log_signatures = ["network disconnect"] will filter log contains "network disconnect"
type LogPatternRule struct {
	LogLevel      []string `protobuf:"bytes,1,rep,name=log_level,json=logLevel,proto3" json:"log_level,omitempty"`
	LogSignatures []string `protobuf:"bytes,2,rep,name=log_signatures,json=logSignatures,proto3" json:"log_signatures,omitempty"`
}

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

var xxx_messageInfo_LogPatternRule proto.InternalMessageInfo

func (m *LogPatternRule) GetLogLevel() []string {
	if m != nil {
		return m.LogLevel
	}
	return nil
}

func (m *LogPatternRule) GetLogSignatures() []string {
	if m != nil {
		return m.LogSignatures
	}
	return nil
}

func init() {
	proto.RegisterType((*Package)(nil), "logcov.proto.logpattern.Package")
	proto.RegisterType((*CodePosition)(nil), "logcov.proto.logpattern.CodePosition")
	proto.RegisterType((*Position)(nil), "logcov.proto.logpattern.Position")
	proto.RegisterType((*FuncInfo)(nil), "logcov.proto.logpattern.FuncInfo")
	proto.RegisterType((*LogPattern)(nil), "logcov.proto.logpattern.LogPattern")
	proto.RegisterType((*Coverage)(nil), "logcov.proto.logpattern.Coverage")
	proto.RegisterMapType((map[string]int32)(nil), "logcov.proto.logpattern.Coverage.CovCountByLogEntry")
	proto.RegisterType((*UnknowLogPattern)(nil), "logcov.proto.logpattern.UnknowLogPattern")
	proto.RegisterMapType((map[string]int32)(nil), "logcov.proto.logpattern.UnknowLogPattern.CovCountByLogEntry")
	proto.RegisterType((*LogPatternRule)(nil), "logcov.proto.logpattern.LogPatternRule")
}

func init() { proto.RegisterFile("logpattern.proto", fileDescriptor_9a35be2004e1e167) }

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

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

func (m *Package) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Package) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tag) > 0 {
		i -= len(m.Tag)
		copy(dAtA[i:], m.Tag)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Tag)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Path) > 0 {
		i -= len(m.Path)
		copy(dAtA[i:], m.Path)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Path)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Repo) > 0 {
		i -= len(m.Repo)
		copy(dAtA[i:], m.Repo)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Repo)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CodePosition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CodePosition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Column != 0 {
		i = encodeVarintLogpattern(dAtA, i, uint64(m.Column))
		i--
		dAtA[i] = 0x10
	}
	if m.Line != 0 {
		i = encodeVarintLogpattern(dAtA, i, uint64(m.Line))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Position) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EndPos != nil {
		{
			size, err := m.EndPos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Pos != nil {
		{
			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FilePath) > 0 {
		i -= len(m.FilePath)
		copy(dAtA[i:], m.FilePath)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.FilePath)))
		i--
		dAtA[i] = 0x12
	}
	if m.PackageInfo != nil {
		{
			size, err := m.PackageInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *FuncInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FuncInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Code) > 0 {
		i -= len(m.Code)
		copy(dAtA[i:], m.Code)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Code)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Pos != nil {
		{
			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *LogPattern) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogPattern) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsDeferLog {
		i--
		if m.IsDeferLog {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.Signature) > 0 {
		for iNdEx := len(m.Signature) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Signature[iNdEx])
			copy(dAtA[i:], m.Signature[iNdEx])
			i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Signature[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Level) > 0 {
		i -= len(m.Level)
		copy(dAtA[i:], m.Level)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Level)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Func != nil {
		{
			size, err := m.Func.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Pos != nil {
		{
			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Coverage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Coverage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.CovCountByLog) > 0 {
		for k := range m.CovCountByLog {
			v := m.CovCountByLog[k]
			baseI := i
			i = encodeVarintLogpattern(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintLogpattern(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintLogpattern(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.CovCount != 0 {
		i = encodeVarintLogpattern(dAtA, i, uint64(m.CovCount))
		i--
		dAtA[i] = 0x10
	}
	if m.Pos != nil {
		{
			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UnknowLogPattern) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UnknowLogPattern) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.CovCountByLog) > 0 {
		for k := range m.CovCountByLog {
			v := m.CovCountByLog[k]
			baseI := i
			i = encodeVarintLogpattern(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintLogpattern(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintLogpattern(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.CovCount != 0 {
		i = encodeVarintLogpattern(dAtA, i, uint64(m.CovCount))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Level) > 0 {
		i -= len(m.Level)
		copy(dAtA[i:], m.Level)
		i = encodeVarintLogpattern(dAtA, i, uint64(len(m.Level)))
		i--
		dAtA[i] = 0x12
	}
	if m.Pos != nil {
		{
			size, err := m.Pos.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogpattern(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *LogPatternRule) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogPatternRule) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LogSignatures) > 0 {
		for iNdEx := len(m.LogSignatures) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.LogSignatures[iNdEx])
			copy(dAtA[i:], m.LogSignatures[iNdEx])
			i = encodeVarintLogpattern(dAtA, i, uint64(len(m.LogSignatures[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.LogLevel) > 0 {
		for iNdEx := len(m.LogLevel) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.LogLevel[iNdEx])
			copy(dAtA[i:], m.LogLevel[iNdEx])
			i = encodeVarintLogpattern(dAtA, i, uint64(len(m.LogLevel[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintLogpattern(dAtA []byte, offset int, v uint64) int {
	offset -= sovLogpattern(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Package) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Repo)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	l = len(m.Tag)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	return n
}

func (m *CodePosition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Line != 0 {
		n += 1 + sovLogpattern(uint64(m.Line))
	}
	if m.Column != 0 {
		n += 1 + sovLogpattern(uint64(m.Column))
	}
	return n
}

func (m *Position) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PackageInfo != nil {
		l = m.PackageInfo.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	l = len(m.FilePath)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	if m.EndPos != nil {
		l = m.EndPos.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	return n
}

func (m *FuncInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	l = len(m.Code)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	return n
}

func (m *LogPattern) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	if m.Func != nil {
		l = m.Func.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	l = len(m.Level)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	if len(m.Signature) > 0 {
		for _, s := range m.Signature {
			l = len(s)
			n += 1 + l + sovLogpattern(uint64(l))
		}
	}
	if m.IsDeferLog {
		n += 2
	}
	return n
}

func (m *Coverage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	if m.CovCount != 0 {
		n += 1 + sovLogpattern(uint64(m.CovCount))
	}
	if len(m.CovCountByLog) > 0 {
		for k, v := range m.CovCountByLog {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovLogpattern(uint64(len(k))) + 1 + sovLogpattern(uint64(v))
			n += mapEntrySize + 1 + sovLogpattern(uint64(mapEntrySize))
		}
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	return n
}

func (m *UnknowLogPattern) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pos != nil {
		l = m.Pos.Size()
		n += 1 + l + sovLogpattern(uint64(l))
	}
	l = len(m.Level)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	if m.CovCount != 0 {
		n += 1 + sovLogpattern(uint64(m.CovCount))
	}
	if len(m.CovCountByLog) > 0 {
		for k, v := range m.CovCountByLog {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovLogpattern(uint64(len(k))) + 1 + sovLogpattern(uint64(v))
			n += mapEntrySize + 1 + sovLogpattern(uint64(mapEntrySize))
		}
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovLogpattern(uint64(l))
	}
	return n
}

func (m *LogPatternRule) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.LogLevel) > 0 {
		for _, s := range m.LogLevel {
			l = len(s)
			n += 1 + l + sovLogpattern(uint64(l))
		}
	}
	if len(m.LogSignatures) > 0 {
		for _, s := range m.LogSignatures {
			l = len(s)
			n += 1 + l + sovLogpattern(uint64(l))
		}
	}
	return n
}

func sovLogpattern(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLogpattern(x uint64) (n int) {
	return sovLogpattern(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Package) 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 ErrIntOverflowLogpattern
			}
			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: Package: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Package: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Repo", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Repo = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(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 ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tag = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogpattern(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogpattern
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CodePosition) 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 ErrIntOverflowLogpattern
			}
			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: CodePosition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CodePosition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Line", wireType)
			}
			m.Line = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Line |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Column", wireType)
			}
			m.Column = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Column |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLogpattern(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogpattern
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Position) 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 ErrIntOverflowLogpattern
			}
			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: Position: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PackageInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PackageInfo == nil {
				m.PackageInfo = &Package{}
			}
			if err := m.PackageInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FilePath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &CodePosition{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndPos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndPos == nil {
				m.EndPos = &CodePosition{}
			}
			if err := m.EndPos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogpattern(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogpattern
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FuncInfo) 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 ErrIntOverflowLogpattern
			}
			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: FuncInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FuncInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &Position{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Code = append(m.Code[:0], dAtA[iNdEx:postIndex]...)
			if m.Code == nil {
				m.Code = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogpattern(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogpattern
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogPattern) 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 ErrIntOverflowLogpattern
			}
			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: LogPattern: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogPattern: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &Position{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Func", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Func == nil {
				m.Func = &FuncInfo{}
			}
			if err := m.Func.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Level = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDeferLog", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDeferLog = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipLogpattern(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogpattern
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Coverage) 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 ErrIntOverflowLogpattern
			}
			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: Coverage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Coverage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &Position{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CovCount", wireType)
			}
			m.CovCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CovCount |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CovCountByLog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CovCountByLog == nil {
				m.CovCountByLog = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowLogpattern
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowLogpattern
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthLogpattern
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthLogpattern
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowLogpattern
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipLogpattern(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthLogpattern
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.CovCountByLog[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogpattern(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogpattern
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnknowLogPattern) 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 ErrIntOverflowLogpattern
			}
			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: UnknowLogPattern: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnknowLogPattern: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Pos == nil {
				m.Pos = &Position{}
			}
			if err := m.Pos.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Level = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CovCount", wireType)
			}
			m.CovCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CovCount |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CovCountByLog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CovCountByLog == nil {
				m.CovCountByLog = make(map[string]int32)
			}
			var mapkey string
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowLogpattern
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowLogpattern
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthLogpattern
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthLogpattern
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowLogpattern
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipLogpattern(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthLogpattern
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.CovCountByLog[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogpattern
				}
				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 ErrInvalidLengthLogpattern
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogpattern
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogpattern(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogpattern
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipLogpattern(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowLogpattern
			}
			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, ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowLogpattern
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthLogpattern
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupLogpattern
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthLogpattern
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthLogpattern        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLogpattern          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLogpattern = fmt.Errorf("proto: unexpected end of group")
)