Span.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: v1/Span.proto

package v1

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

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

type PSpanMessage struct {
	// Types that are valid to be assigned to Field:
	//	*PSpanMessage_Span
	//	*PSpanMessage_SpanChunk
	Field                isPSpanMessage_Field `protobuf_oneof:"field"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

func (m *PSpanMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PSpanMessage.Unmarshal(m, b)
}
func (m *PSpanMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PSpanMessage.Marshal(b, m, deterministic)
}
func (m *PSpanMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PSpanMessage.Merge(m, src)
}
func (m *PSpanMessage) XXX_Size() int {
	return xxx_messageInfo_PSpanMessage.Size(m)
}
func (m *PSpanMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_PSpanMessage.DiscardUnknown(m)
}

var xxx_messageInfo_PSpanMessage proto.InternalMessageInfo

type isPSpanMessage_Field interface {
	isPSpanMessage_Field()
}

type PSpanMessage_Span struct {
	Span *PSpan `protobuf:"bytes,1,opt,name=span,proto3,oneof"`
}

type PSpanMessage_SpanChunk struct {
	SpanChunk *PSpanChunk `protobuf:"bytes,2,opt,name=spanChunk,proto3,oneof"`
}

func (*PSpanMessage_Span) isPSpanMessage_Field() {}

func (*PSpanMessage_SpanChunk) isPSpanMessage_Field() {}

func (m *PSpanMessage) GetField() isPSpanMessage_Field {
	if m != nil {
		return m.Field
	}
	return nil
}

func (m *PSpanMessage) GetSpan() *PSpan {
	if x, ok := m.GetField().(*PSpanMessage_Span); ok {
		return x.Span
	}
	return nil
}

func (m *PSpanMessage) GetSpanChunk() *PSpanChunk {
	if x, ok := m.GetField().(*PSpanMessage_SpanChunk); ok {
		return x.SpanChunk
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*PSpanMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*PSpanMessage_Span)(nil),
		(*PSpanMessage_SpanChunk)(nil),
	}
}

type PSpan struct {
	Version       int32           `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	TransactionId *PTransactionId `protobuf:"bytes,2,opt,name=transactionId,proto3" json:"transactionId,omitempty"`
	SpanId        int64           `protobuf:"fixed64,3,opt,name=spanId,proto3" json:"spanId,omitempty"`
	ParentSpanId  int64           `protobuf:"fixed64,4,opt,name=parentSpanId,proto3" json:"parentSpanId,omitempty"`
	// span event's startTimestamp
	StartTime              int64            `protobuf:"varint,5,opt,name=startTime,proto3" json:"startTime,omitempty"`
	Elapsed                int32            `protobuf:"varint,6,opt,name=elapsed,proto3" json:"elapsed,omitempty"`
	ApiId                  int32            `protobuf:"varint,7,opt,name=apiId,proto3" json:"apiId,omitempty"`
	ServiceType            int32            `protobuf:"varint,8,opt,name=serviceType,proto3" json:"serviceType,omitempty"`
	AcceptEvent            *PAcceptEvent    `protobuf:"bytes,9,opt,name=acceptEvent,proto3" json:"acceptEvent,omitempty"`
	Annotation             []*PAnnotation   `protobuf:"bytes,10,rep,name=annotation,proto3" json:"annotation,omitempty"`
	Flag                   int32            `protobuf:"varint,11,opt,name=flag,proto3" json:"flag,omitempty"`
	Err                    int32            `protobuf:"zigzag32,12,opt,name=err,proto3" json:"err,omitempty"`
	SpanEvent              []*PSpanEvent    `protobuf:"bytes,13,rep,name=spanEvent,proto3" json:"spanEvent,omitempty"`
	ExceptionInfo          *PIntStringValue `protobuf:"bytes,14,opt,name=exceptionInfo,proto3" json:"exceptionInfo,omitempty"`
	ApplicationServiceType int32            `protobuf:"varint,15,opt,name=applicationServiceType,proto3" json:"applicationServiceType,omitempty"`
	LoggingTransactionInfo int32            `protobuf:"varint,16,opt,name=loggingTransactionInfo,proto3" json:"loggingTransactionInfo,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}         `json:"-"`
	XXX_unrecognized       []byte           `json:"-"`
	XXX_sizecache          int32            `json:"-"`
}

func (m *PSpan) Reset()         { *m = PSpan{} }
func (m *PSpan) String() string { return proto.CompactTextString(m) }
func (*PSpan) ProtoMessage()    {}
func (*PSpan) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{1}
}

func (m *PSpan) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PSpan.Unmarshal(m, b)
}
func (m *PSpan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PSpan.Marshal(b, m, deterministic)
}
func (m *PSpan) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PSpan.Merge(m, src)
}
func (m *PSpan) XXX_Size() int {
	return xxx_messageInfo_PSpan.Size(m)
}
func (m *PSpan) XXX_DiscardUnknown() {
	xxx_messageInfo_PSpan.DiscardUnknown(m)
}

var xxx_messageInfo_PSpan proto.InternalMessageInfo

func (m *PSpan) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *PSpan) GetTransactionId() *PTransactionId {
	if m != nil {
		return m.TransactionId
	}
	return nil
}

func (m *PSpan) GetSpanId() int64 {
	if m != nil {
		return m.SpanId
	}
	return 0
}

func (m *PSpan) GetParentSpanId() int64 {
	if m != nil {
		return m.ParentSpanId
	}
	return 0
}

func (m *PSpan) GetStartTime() int64 {
	if m != nil {
		return m.StartTime
	}
	return 0
}

func (m *PSpan) GetElapsed() int32 {
	if m != nil {
		return m.Elapsed
	}
	return 0
}

func (m *PSpan) GetApiId() int32 {
	if m != nil {
		return m.ApiId
	}
	return 0
}

func (m *PSpan) GetServiceType() int32 {
	if m != nil {
		return m.ServiceType
	}
	return 0
}

func (m *PSpan) GetAcceptEvent() *PAcceptEvent {
	if m != nil {
		return m.AcceptEvent
	}
	return nil
}

func (m *PSpan) GetAnnotation() []*PAnnotation {
	if m != nil {
		return m.Annotation
	}
	return nil
}

func (m *PSpan) GetFlag() int32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

func (m *PSpan) GetErr() int32 {
	if m != nil {
		return m.Err
	}
	return 0
}

func (m *PSpan) GetSpanEvent() []*PSpanEvent {
	if m != nil {
		return m.SpanEvent
	}
	return nil
}

func (m *PSpan) GetExceptionInfo() *PIntStringValue {
	if m != nil {
		return m.ExceptionInfo
	}
	return nil
}

func (m *PSpan) GetApplicationServiceType() int32 {
	if m != nil {
		return m.ApplicationServiceType
	}
	return 0
}

func (m *PSpan) GetLoggingTransactionInfo() int32 {
	if m != nil {
		return m.LoggingTransactionInfo
	}
	return 0
}

type PTransactionId struct {
	// identical to agentId if null
	AgentId              string   `protobuf:"bytes,1,opt,name=agentId,proto3" json:"agentId,omitempty"`
	AgentStartTime       int64    `protobuf:"varint,2,opt,name=agentStartTime,proto3" json:"agentStartTime,omitempty"`
	Sequence             int64    `protobuf:"varint,3,opt,name=sequence,proto3" json:"sequence,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PTransactionId) Reset()         { *m = PTransactionId{} }
func (m *PTransactionId) String() string { return proto.CompactTextString(m) }
func (*PTransactionId) ProtoMessage()    {}
func (*PTransactionId) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{2}
}

func (m *PTransactionId) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PTransactionId.Unmarshal(m, b)
}
func (m *PTransactionId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PTransactionId.Marshal(b, m, deterministic)
}
func (m *PTransactionId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PTransactionId.Merge(m, src)
}
func (m *PTransactionId) XXX_Size() int {
	return xxx_messageInfo_PTransactionId.Size(m)
}
func (m *PTransactionId) XXX_DiscardUnknown() {
	xxx_messageInfo_PTransactionId.DiscardUnknown(m)
}

var xxx_messageInfo_PTransactionId proto.InternalMessageInfo

func (m *PTransactionId) GetAgentId() string {
	if m != nil {
		return m.AgentId
	}
	return ""
}

func (m *PTransactionId) GetAgentStartTime() int64 {
	if m != nil {
		return m.AgentStartTime
	}
	return 0
}

func (m *PTransactionId) GetSequence() int64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

type PAcceptEvent struct {
	Rpc                  string       `protobuf:"bytes,1,opt,name=rpc,proto3" json:"rpc,omitempty"`
	EndPoint             string       `protobuf:"bytes,2,opt,name=endPoint,proto3" json:"endPoint,omitempty"`
	RemoteAddr           string       `protobuf:"bytes,3,opt,name=remoteAddr,proto3" json:"remoteAddr,omitempty"`
	ParentInfo           *PParentInfo `protobuf:"bytes,4,opt,name=parentInfo,proto3" json:"parentInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *PAcceptEvent) Reset()         { *m = PAcceptEvent{} }
func (m *PAcceptEvent) String() string { return proto.CompactTextString(m) }
func (*PAcceptEvent) ProtoMessage()    {}
func (*PAcceptEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{3}
}

func (m *PAcceptEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PAcceptEvent.Unmarshal(m, b)
}
func (m *PAcceptEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PAcceptEvent.Marshal(b, m, deterministic)
}
func (m *PAcceptEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PAcceptEvent.Merge(m, src)
}
func (m *PAcceptEvent) XXX_Size() int {
	return xxx_messageInfo_PAcceptEvent.Size(m)
}
func (m *PAcceptEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_PAcceptEvent.DiscardUnknown(m)
}

var xxx_messageInfo_PAcceptEvent proto.InternalMessageInfo

func (m *PAcceptEvent) GetRpc() string {
	if m != nil {
		return m.Rpc
	}
	return ""
}

func (m *PAcceptEvent) GetEndPoint() string {
	if m != nil {
		return m.EndPoint
	}
	return ""
}

func (m *PAcceptEvent) GetRemoteAddr() string {
	if m != nil {
		return m.RemoteAddr
	}
	return ""
}

func (m *PAcceptEvent) GetParentInfo() *PParentInfo {
	if m != nil {
		return m.ParentInfo
	}
	return nil
}

type PParentInfo struct {
	ParentApplicationName string   `protobuf:"bytes,1,opt,name=parentApplicationName,proto3" json:"parentApplicationName,omitempty"`
	ParentApplicationType int32    `protobuf:"varint,2,opt,name=parentApplicationType,proto3" json:"parentApplicationType,omitempty"`
	AcceptorHost          string   `protobuf:"bytes,3,opt,name=acceptorHost,proto3" json:"acceptorHost,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

func (m *PParentInfo) Reset()         { *m = PParentInfo{} }
func (m *PParentInfo) String() string { return proto.CompactTextString(m) }
func (*PParentInfo) ProtoMessage()    {}
func (*PParentInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{4}
}

func (m *PParentInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PParentInfo.Unmarshal(m, b)
}
func (m *PParentInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PParentInfo.Marshal(b, m, deterministic)
}
func (m *PParentInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PParentInfo.Merge(m, src)
}
func (m *PParentInfo) XXX_Size() int {
	return xxx_messageInfo_PParentInfo.Size(m)
}
func (m *PParentInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_PParentInfo.DiscardUnknown(m)
}

var xxx_messageInfo_PParentInfo proto.InternalMessageInfo

func (m *PParentInfo) GetParentApplicationName() string {
	if m != nil {
		return m.ParentApplicationName
	}
	return ""
}

func (m *PParentInfo) GetParentApplicationType() int32 {
	if m != nil {
		return m.ParentApplicationType
	}
	return 0
}

func (m *PParentInfo) GetAcceptorHost() string {
	if m != nil {
		return m.AcceptorHost
	}
	return ""
}

type PLocalAsyncId struct {
	AsyncId              int32    `protobuf:"varint,1,opt,name=asyncId,proto3" json:"asyncId,omitempty"`
	Sequence             int32    `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PLocalAsyncId) Reset()         { *m = PLocalAsyncId{} }
func (m *PLocalAsyncId) String() string { return proto.CompactTextString(m) }
func (*PLocalAsyncId) ProtoMessage()    {}
func (*PLocalAsyncId) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{5}
}

func (m *PLocalAsyncId) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PLocalAsyncId.Unmarshal(m, b)
}
func (m *PLocalAsyncId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PLocalAsyncId.Marshal(b, m, deterministic)
}
func (m *PLocalAsyncId) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PLocalAsyncId.Merge(m, src)
}
func (m *PLocalAsyncId) XXX_Size() int {
	return xxx_messageInfo_PLocalAsyncId.Size(m)
}
func (m *PLocalAsyncId) XXX_DiscardUnknown() {
	xxx_messageInfo_PLocalAsyncId.DiscardUnknown(m)
}

var xxx_messageInfo_PLocalAsyncId proto.InternalMessageInfo

func (m *PLocalAsyncId) GetAsyncId() int32 {
	if m != nil {
		return m.AsyncId
	}
	return 0
}

func (m *PLocalAsyncId) GetSequence() int32 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

type PSpanEvent struct {
	Sequence             int32            `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
	Depth                int32            `protobuf:"varint,2,opt,name=depth,proto3" json:"depth,omitempty"`
	StartElapsed         int32            `protobuf:"varint,3,opt,name=startElapsed,proto3" json:"startElapsed,omitempty"`
	EndElapsed           int32            `protobuf:"varint,4,opt,name=endElapsed,proto3" json:"endElapsed,omitempty"`
	ServiceType          int32            `protobuf:"zigzag32,5,opt,name=serviceType,proto3" json:"serviceType,omitempty"`
	Annotation           []*PAnnotation   `protobuf:"bytes,6,rep,name=annotation,proto3" json:"annotation,omitempty"`
	ApiId                int32            `protobuf:"zigzag32,10,opt,name=apiId,proto3" json:"apiId,omitempty"`
	ExceptionInfo        *PIntStringValue `protobuf:"bytes,11,opt,name=exceptionInfo,proto3" json:"exceptionInfo,omitempty"`
	NextEvent            *PNextEvent      `protobuf:"bytes,12,opt,name=nextEvent,proto3" json:"nextEvent,omitempty"`
	AsyncEvent           int32            `protobuf:"varint,13,opt,name=asyncEvent,proto3" json:"asyncEvent,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *PSpanEvent) Reset()         { *m = PSpanEvent{} }
func (m *PSpanEvent) String() string { return proto.CompactTextString(m) }
func (*PSpanEvent) ProtoMessage()    {}
func (*PSpanEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{6}
}

func (m *PSpanEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PSpanEvent.Unmarshal(m, b)
}
func (m *PSpanEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PSpanEvent.Marshal(b, m, deterministic)
}
func (m *PSpanEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PSpanEvent.Merge(m, src)
}
func (m *PSpanEvent) XXX_Size() int {
	return xxx_messageInfo_PSpanEvent.Size(m)
}
func (m *PSpanEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_PSpanEvent.DiscardUnknown(m)
}

var xxx_messageInfo_PSpanEvent proto.InternalMessageInfo

func (m *PSpanEvent) GetSequence() int32 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

func (m *PSpanEvent) GetDepth() int32 {
	if m != nil {
		return m.Depth
	}
	return 0
}

func (m *PSpanEvent) GetStartElapsed() int32 {
	if m != nil {
		return m.StartElapsed
	}
	return 0
}

func (m *PSpanEvent) GetEndElapsed() int32 {
	if m != nil {
		return m.EndElapsed
	}
	return 0
}

func (m *PSpanEvent) GetServiceType() int32 {
	if m != nil {
		return m.ServiceType
	}
	return 0
}

func (m *PSpanEvent) GetAnnotation() []*PAnnotation {
	if m != nil {
		return m.Annotation
	}
	return nil
}

func (m *PSpanEvent) GetApiId() int32 {
	if m != nil {
		return m.ApiId
	}
	return 0
}

func (m *PSpanEvent) GetExceptionInfo() *PIntStringValue {
	if m != nil {
		return m.ExceptionInfo
	}
	return nil
}

func (m *PSpanEvent) GetNextEvent() *PNextEvent {
	if m != nil {
		return m.NextEvent
	}
	return nil
}

func (m *PSpanEvent) GetAsyncEvent() int32 {
	if m != nil {
		return m.AsyncEvent
	}
	return 0
}

type PNextEvent struct {
	// Types that are valid to be assigned to Field:
	//	*PNextEvent_MessageEvent
	Field                isPNextEvent_Field `protobuf_oneof:"field"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *PNextEvent) Reset()         { *m = PNextEvent{} }
func (m *PNextEvent) String() string { return proto.CompactTextString(m) }
func (*PNextEvent) ProtoMessage()    {}
func (*PNextEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{7}
}

func (m *PNextEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PNextEvent.Unmarshal(m, b)
}
func (m *PNextEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PNextEvent.Marshal(b, m, deterministic)
}
func (m *PNextEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PNextEvent.Merge(m, src)
}
func (m *PNextEvent) XXX_Size() int {
	return xxx_messageInfo_PNextEvent.Size(m)
}
func (m *PNextEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_PNextEvent.DiscardUnknown(m)
}

var xxx_messageInfo_PNextEvent proto.InternalMessageInfo

type isPNextEvent_Field interface {
	isPNextEvent_Field()
}

type PNextEvent_MessageEvent struct {
	MessageEvent *PMessageEvent `protobuf:"bytes,1,opt,name=messageEvent,proto3,oneof"`
}

func (*PNextEvent_MessageEvent) isPNextEvent_Field() {}

func (m *PNextEvent) GetField() isPNextEvent_Field {
	if m != nil {
		return m.Field
	}
	return nil
}

func (m *PNextEvent) GetMessageEvent() *PMessageEvent {
	if x, ok := m.GetField().(*PNextEvent_MessageEvent); ok {
		return x.MessageEvent
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*PNextEvent) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*PNextEvent_MessageEvent)(nil),
	}
}

type PMessageEvent struct {
	NextSpanId           int64    `protobuf:"fixed64,1,opt,name=nextSpanId,proto3" json:"nextSpanId,omitempty"`
	EndPoint             string   `protobuf:"bytes,2,opt,name=endPoint,proto3" json:"endPoint,omitempty"`
	DestinationId        string   `protobuf:"bytes,3,opt,name=destinationId,proto3" json:"destinationId,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PMessageEvent) Reset()         { *m = PMessageEvent{} }
func (m *PMessageEvent) String() string { return proto.CompactTextString(m) }
func (*PMessageEvent) ProtoMessage()    {}
func (*PMessageEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{8}
}

func (m *PMessageEvent) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PMessageEvent.Unmarshal(m, b)
}
func (m *PMessageEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PMessageEvent.Marshal(b, m, deterministic)
}
func (m *PMessageEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PMessageEvent.Merge(m, src)
}
func (m *PMessageEvent) XXX_Size() int {
	return xxx_messageInfo_PMessageEvent.Size(m)
}
func (m *PMessageEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_PMessageEvent.DiscardUnknown(m)
}

var xxx_messageInfo_PMessageEvent proto.InternalMessageInfo

func (m *PMessageEvent) GetNextSpanId() int64 {
	if m != nil {
		return m.NextSpanId
	}
	return 0
}

func (m *PMessageEvent) GetEndPoint() string {
	if m != nil {
		return m.EndPoint
	}
	return ""
}

func (m *PMessageEvent) GetDestinationId() string {
	if m != nil {
		return m.DestinationId
	}
	return ""
}

type PSpanChunk struct {
	Version                int32           `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	TransactionId          *PTransactionId `protobuf:"bytes,2,opt,name=transactionId,proto3" json:"transactionId,omitempty"`
	SpanId                 int64           `protobuf:"fixed64,3,opt,name=spanId,proto3" json:"spanId,omitempty"`
	EndPoint               string          `protobuf:"bytes,4,opt,name=endPoint,proto3" json:"endPoint,omitempty"`
	SpanEvent              []*PSpanEvent   `protobuf:"bytes,5,rep,name=spanEvent,proto3" json:"spanEvent,omitempty"`
	ApplicationServiceType int32           `protobuf:"varint,6,opt,name=applicationServiceType,proto3" json:"applicationServiceType,omitempty"`
	KeyTime                int64           `protobuf:"varint,7,opt,name=keyTime,proto3" json:"keyTime,omitempty"`
	LocalAsyncId           *PLocalAsyncId  `protobuf:"bytes,8,opt,name=localAsyncId,proto3" json:"localAsyncId,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}        `json:"-"`
	XXX_unrecognized       []byte          `json:"-"`
	XXX_sizecache          int32           `json:"-"`
}

func (m *PSpanChunk) Reset()         { *m = PSpanChunk{} }
func (m *PSpanChunk) String() string { return proto.CompactTextString(m) }
func (*PSpanChunk) ProtoMessage()    {}
func (*PSpanChunk) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{9}
}

func (m *PSpanChunk) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PSpanChunk.Unmarshal(m, b)
}
func (m *PSpanChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PSpanChunk.Marshal(b, m, deterministic)
}
func (m *PSpanChunk) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PSpanChunk.Merge(m, src)
}
func (m *PSpanChunk) XXX_Size() int {
	return xxx_messageInfo_PSpanChunk.Size(m)
}
func (m *PSpanChunk) XXX_DiscardUnknown() {
	xxx_messageInfo_PSpanChunk.DiscardUnknown(m)
}

var xxx_messageInfo_PSpanChunk proto.InternalMessageInfo

func (m *PSpanChunk) GetVersion() int32 {
	if m != nil {
		return m.Version
	}
	return 0
}

func (m *PSpanChunk) GetTransactionId() *PTransactionId {
	if m != nil {
		return m.TransactionId
	}
	return nil
}

func (m *PSpanChunk) GetSpanId() int64 {
	if m != nil {
		return m.SpanId
	}
	return 0
}

func (m *PSpanChunk) GetEndPoint() string {
	if m != nil {
		return m.EndPoint
	}
	return ""
}

func (m *PSpanChunk) GetSpanEvent() []*PSpanEvent {
	if m != nil {
		return m.SpanEvent
	}
	return nil
}

func (m *PSpanChunk) GetApplicationServiceType() int32 {
	if m != nil {
		return m.ApplicationServiceType
	}
	return 0
}

func (m *PSpanChunk) GetKeyTime() int64 {
	if m != nil {
		return m.KeyTime
	}
	return 0
}

func (m *PSpanChunk) GetLocalAsyncId() *PLocalAsyncId {
	if m != nil {
		return m.LocalAsyncId
	}
	return nil
}

type PResult struct {
	Success              bool     `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
	Message              string   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PResult) Reset()         { *m = PResult{} }
func (m *PResult) String() string { return proto.CompactTextString(m) }
func (*PResult) ProtoMessage()    {}
func (*PResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{10}
}

func (m *PResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PResult.Unmarshal(m, b)
}
func (m *PResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PResult.Marshal(b, m, deterministic)
}
func (m *PResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PResult.Merge(m, src)
}
func (m *PResult) XXX_Size() int {
	return xxx_messageInfo_PResult.Size(m)
}
func (m *PResult) XXX_DiscardUnknown() {
	xxx_messageInfo_PResult.DiscardUnknown(m)
}

var xxx_messageInfo_PResult proto.InternalMessageInfo

func (m *PResult) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

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

type PSqlMetaData struct {
	SqlId                int32    `protobuf:"varint,1,opt,name=sqlId,proto3" json:"sqlId,omitempty"`
	Sql                  string   `protobuf:"bytes,2,opt,name=sql,proto3" json:"sql,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PSqlMetaData) Reset()         { *m = PSqlMetaData{} }
func (m *PSqlMetaData) String() string { return proto.CompactTextString(m) }
func (*PSqlMetaData) ProtoMessage()    {}
func (*PSqlMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{11}
}

func (m *PSqlMetaData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PSqlMetaData.Unmarshal(m, b)
}
func (m *PSqlMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PSqlMetaData.Marshal(b, m, deterministic)
}
func (m *PSqlMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PSqlMetaData.Merge(m, src)
}
func (m *PSqlMetaData) XXX_Size() int {
	return xxx_messageInfo_PSqlMetaData.Size(m)
}
func (m *PSqlMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_PSqlMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_PSqlMetaData proto.InternalMessageInfo

func (m *PSqlMetaData) GetSqlId() int32 {
	if m != nil {
		return m.SqlId
	}
	return 0
}

func (m *PSqlMetaData) GetSql() string {
	if m != nil {
		return m.Sql
	}
	return ""
}

type PSqlUidMetaData struct {
	SqlUid               []byte   `protobuf:"bytes,1,opt,name=sqlUid,proto3" json:"sqlUid,omitempty"`
	Sql                  string   `protobuf:"bytes,2,opt,name=sql,proto3" json:"sql,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PSqlUidMetaData) Reset()         { *m = PSqlUidMetaData{} }
func (m *PSqlUidMetaData) String() string { return proto.CompactTextString(m) }
func (*PSqlUidMetaData) ProtoMessage()    {}
func (*PSqlUidMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{12}
}

func (m *PSqlUidMetaData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PSqlUidMetaData.Unmarshal(m, b)
}
func (m *PSqlUidMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PSqlUidMetaData.Marshal(b, m, deterministic)
}
func (m *PSqlUidMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PSqlUidMetaData.Merge(m, src)
}
func (m *PSqlUidMetaData) XXX_Size() int {
	return xxx_messageInfo_PSqlUidMetaData.Size(m)
}
func (m *PSqlUidMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_PSqlUidMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_PSqlUidMetaData proto.InternalMessageInfo

func (m *PSqlUidMetaData) GetSqlUid() []byte {
	if m != nil {
		return m.SqlUid
	}
	return nil
}

func (m *PSqlUidMetaData) GetSql() string {
	if m != nil {
		return m.Sql
	}
	return ""
}

type PApiMetaData struct {
	ApiId                int32    `protobuf:"varint,1,opt,name=apiId,proto3" json:"apiId,omitempty"`
	ApiInfo              string   `protobuf:"bytes,2,opt,name=apiInfo,proto3" json:"apiInfo,omitempty"`
	Line                 int32    `protobuf:"varint,3,opt,name=line,proto3" json:"line,omitempty"`
	Type                 int32    `protobuf:"varint,4,opt,name=type,proto3" json:"type,omitempty"`
	Location             string   `protobuf:"bytes,5,opt,name=location,proto3" json:"location,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PApiMetaData) Reset()         { *m = PApiMetaData{} }
func (m *PApiMetaData) String() string { return proto.CompactTextString(m) }
func (*PApiMetaData) ProtoMessage()    {}
func (*PApiMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{13}
}

func (m *PApiMetaData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PApiMetaData.Unmarshal(m, b)
}
func (m *PApiMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PApiMetaData.Marshal(b, m, deterministic)
}
func (m *PApiMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PApiMetaData.Merge(m, src)
}
func (m *PApiMetaData) XXX_Size() int {
	return xxx_messageInfo_PApiMetaData.Size(m)
}
func (m *PApiMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_PApiMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_PApiMetaData proto.InternalMessageInfo

func (m *PApiMetaData) GetApiId() int32 {
	if m != nil {
		return m.ApiId
	}
	return 0
}

func (m *PApiMetaData) GetApiInfo() string {
	if m != nil {
		return m.ApiInfo
	}
	return ""
}

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

func (m *PApiMetaData) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *PApiMetaData) GetLocation() string {
	if m != nil {
		return m.Location
	}
	return ""
}

type PStringMetaData struct {
	StringId             int32    `protobuf:"varint,1,opt,name=stringId,proto3" json:"stringId,omitempty"`
	StringValue          string   `protobuf:"bytes,2,opt,name=stringValue,proto3" json:"stringValue,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PStringMetaData) Reset()         { *m = PStringMetaData{} }
func (m *PStringMetaData) String() string { return proto.CompactTextString(m) }
func (*PStringMetaData) ProtoMessage()    {}
func (*PStringMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{14}
}

func (m *PStringMetaData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PStringMetaData.Unmarshal(m, b)
}
func (m *PStringMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PStringMetaData.Marshal(b, m, deterministic)
}
func (m *PStringMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PStringMetaData.Merge(m, src)
}
func (m *PStringMetaData) XXX_Size() int {
	return xxx_messageInfo_PStringMetaData.Size(m)
}
func (m *PStringMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_PStringMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_PStringMetaData proto.InternalMessageInfo

func (m *PStringMetaData) GetStringId() int32 {
	if m != nil {
		return m.StringId
	}
	return 0
}

func (m *PStringMetaData) GetStringValue() string {
	if m != nil {
		return m.StringValue
	}
	return ""
}

type PExceptionMetaData struct {
	Exceptions           []*PException   `protobuf:"bytes,1,rep,name=exceptions,proto3" json:"exceptions,omitempty"`
	TransactionId        *PTransactionId `protobuf:"bytes,2,opt,name=transactionId,proto3" json:"transactionId,omitempty"`
	SpanId               int64           `protobuf:"fixed64,3,opt,name=spanId,proto3" json:"spanId,omitempty"`
	UriTemplate          string          `protobuf:"bytes,4,opt,name=uriTemplate,proto3" json:"uriTemplate,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *PExceptionMetaData) Reset()         { *m = PExceptionMetaData{} }
func (m *PExceptionMetaData) String() string { return proto.CompactTextString(m) }
func (*PExceptionMetaData) ProtoMessage()    {}
func (*PExceptionMetaData) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{15}
}

func (m *PExceptionMetaData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PExceptionMetaData.Unmarshal(m, b)
}
func (m *PExceptionMetaData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PExceptionMetaData.Marshal(b, m, deterministic)
}
func (m *PExceptionMetaData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PExceptionMetaData.Merge(m, src)
}
func (m *PExceptionMetaData) XXX_Size() int {
	return xxx_messageInfo_PExceptionMetaData.Size(m)
}
func (m *PExceptionMetaData) XXX_DiscardUnknown() {
	xxx_messageInfo_PExceptionMetaData.DiscardUnknown(m)
}

var xxx_messageInfo_PExceptionMetaData proto.InternalMessageInfo

func (m *PExceptionMetaData) GetExceptions() []*PException {
	if m != nil {
		return m.Exceptions
	}
	return nil
}

func (m *PExceptionMetaData) GetTransactionId() *PTransactionId {
	if m != nil {
		return m.TransactionId
	}
	return nil
}

func (m *PExceptionMetaData) GetSpanId() int64 {
	if m != nil {
		return m.SpanId
	}
	return 0
}

func (m *PExceptionMetaData) GetUriTemplate() string {
	if m != nil {
		return m.UriTemplate
	}
	return ""
}

type PException struct {
	ExceptionClassName   string                `protobuf:"bytes,1,opt,name=exceptionClassName,proto3" json:"exceptionClassName,omitempty"`
	ExceptionMessage     string                `protobuf:"bytes,2,opt,name=exceptionMessage,proto3" json:"exceptionMessage,omitempty"`
	StartTime            int64                 `protobuf:"varint,3,opt,name=startTime,proto3" json:"startTime,omitempty"`
	ExceptionId          int64                 `protobuf:"varint,4,opt,name=exceptionId,proto3" json:"exceptionId,omitempty"`
	ExceptionDepth       int32                 `protobuf:"varint,5,opt,name=exceptionDepth,proto3" json:"exceptionDepth,omitempty"`
	StackTraceElement    []*PStackTraceElement `protobuf:"bytes,6,rep,name=stackTraceElement,proto3" json:"stackTraceElement,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *PException) Reset()         { *m = PException{} }
func (m *PException) String() string { return proto.CompactTextString(m) }
func (*PException) ProtoMessage()    {}
func (*PException) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{16}
}

func (m *PException) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PException.Unmarshal(m, b)
}
func (m *PException) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PException.Marshal(b, m, deterministic)
}
func (m *PException) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PException.Merge(m, src)
}
func (m *PException) XXX_Size() int {
	return xxx_messageInfo_PException.Size(m)
}
func (m *PException) XXX_DiscardUnknown() {
	xxx_messageInfo_PException.DiscardUnknown(m)
}

var xxx_messageInfo_PException proto.InternalMessageInfo

func (m *PException) GetExceptionClassName() string {
	if m != nil {
		return m.ExceptionClassName
	}
	return ""
}

func (m *PException) GetExceptionMessage() string {
	if m != nil {
		return m.ExceptionMessage
	}
	return ""
}

func (m *PException) GetStartTime() int64 {
	if m != nil {
		return m.StartTime
	}
	return 0
}

func (m *PException) GetExceptionId() int64 {
	if m != nil {
		return m.ExceptionId
	}
	return 0
}

func (m *PException) GetExceptionDepth() int32 {
	if m != nil {
		return m.ExceptionDepth
	}
	return 0
}

func (m *PException) GetStackTraceElement() []*PStackTraceElement {
	if m != nil {
		return m.StackTraceElement
	}
	return nil
}

type PStackTraceElement struct {
	ClassName            string   `protobuf:"bytes,1,opt,name=className,proto3" json:"className,omitempty"`
	FileName             string   `protobuf:"bytes,2,opt,name=fileName,proto3" json:"fileName,omitempty"`
	LineNumber           int32    `protobuf:"varint,3,opt,name=lineNumber,proto3" json:"lineNumber,omitempty"`
	MethodName           string   `protobuf:"bytes,4,opt,name=methodName,proto3" json:"methodName,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PStackTraceElement) Reset()         { *m = PStackTraceElement{} }
func (m *PStackTraceElement) String() string { return proto.CompactTextString(m) }
func (*PStackTraceElement) ProtoMessage()    {}
func (*PStackTraceElement) Descriptor() ([]byte, []int) {
	return fileDescriptor_8bd3588c698d8223, []int{17}
}

func (m *PStackTraceElement) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PStackTraceElement.Unmarshal(m, b)
}
func (m *PStackTraceElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PStackTraceElement.Marshal(b, m, deterministic)
}
func (m *PStackTraceElement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PStackTraceElement.Merge(m, src)
}
func (m *PStackTraceElement) XXX_Size() int {
	return xxx_messageInfo_PStackTraceElement.Size(m)
}
func (m *PStackTraceElement) XXX_DiscardUnknown() {
	xxx_messageInfo_PStackTraceElement.DiscardUnknown(m)
}

var xxx_messageInfo_PStackTraceElement proto.InternalMessageInfo

func (m *PStackTraceElement) GetClassName() string {
	if m != nil {
		return m.ClassName
	}
	return ""
}

func (m *PStackTraceElement) GetFileName() string {
	if m != nil {
		return m.FileName
	}
	return ""
}

func (m *PStackTraceElement) GetLineNumber() int32 {
	if m != nil {
		return m.LineNumber
	}
	return 0
}

func (m *PStackTraceElement) GetMethodName() string {
	if m != nil {
		return m.MethodName
	}
	return ""
}

func init() {
	proto.RegisterType((*PSpanMessage)(nil), "v1.PSpanMessage")
	proto.RegisterType((*PSpan)(nil), "v1.PSpan")
	proto.RegisterType((*PTransactionId)(nil), "v1.PTransactionId")
	proto.RegisterType((*PAcceptEvent)(nil), "v1.PAcceptEvent")
	proto.RegisterType((*PParentInfo)(nil), "v1.PParentInfo")
	proto.RegisterType((*PLocalAsyncId)(nil), "v1.PLocalAsyncId")
	proto.RegisterType((*PSpanEvent)(nil), "v1.PSpanEvent")
	proto.RegisterType((*PNextEvent)(nil), "v1.PNextEvent")
	proto.RegisterType((*PMessageEvent)(nil), "v1.PMessageEvent")
	proto.RegisterType((*PSpanChunk)(nil), "v1.PSpanChunk")
	proto.RegisterType((*PResult)(nil), "v1.PResult")
	proto.RegisterType((*PSqlMetaData)(nil), "v1.PSqlMetaData")
	proto.RegisterType((*PSqlUidMetaData)(nil), "v1.PSqlUidMetaData")
	proto.RegisterType((*PApiMetaData)(nil), "v1.PApiMetaData")
	proto.RegisterType((*PStringMetaData)(nil), "v1.PStringMetaData")
	proto.RegisterType((*PExceptionMetaData)(nil), "v1.PExceptionMetaData")
	proto.RegisterType((*PException)(nil), "v1.PException")
	proto.RegisterType((*PStackTraceElement)(nil), "v1.PStackTraceElement")
}

func init() { proto.RegisterFile("v1/Span.proto", fileDescriptor_8bd3588c698d8223) }

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