logical.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/stirling/source_connectors/dynamic_tracer/dynamic_tracing/ir/logicalpb/logical.proto

package logicalpb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
	sharedpb "px.dev/pixie/src/stirling/source_connectors/dynamic_tracer/dynamic_tracing/ir/sharedpb"
	reflect "reflect"
	strings "strings"
)

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

type Constant struct {
	Name     string              `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type     sharedpb.ScalarType `protobuf:"varint,2,opt,name=type,proto3,enum=px.stirling.dynamic_tracing.ir.shared.ScalarType" json:"type,omitempty"`
	Constant string              `protobuf:"bytes,3,opt,name=constant,proto3" json:"constant,omitempty"`
}

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

var xxx_messageInfo_Constant proto.InternalMessageInfo

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

func (m *Constant) GetType() sharedpb.ScalarType {
	if m != nil {
		return m.Type
	}
	return sharedpb.UNKNOWN
}

func (m *Constant) GetConstant() string {
	if m != nil {
		return m.Constant
	}
	return ""
}

type Argument struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Expr string `protobuf:"bytes,2,opt,name=expr,proto3" json:"expr,omitempty"`
}

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

var xxx_messageInfo_Argument proto.InternalMessageInfo

func (m *Argument) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Argument) GetExpr() string {
	if m != nil {
		return m.Expr
	}
	return ""
}

type ReturnValue struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Expr string `protobuf:"bytes,2,opt,name=expr,proto3" json:"expr,omitempty"`
}

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

var xxx_messageInfo_ReturnValue proto.InternalMessageInfo

func (m *ReturnValue) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ReturnValue) GetExpr() string {
	if m != nil {
		return m.Expr
	}
	return ""
}

type MapValue struct {
	MapName  string             `protobuf:"bytes,1,opt,name=map_name,json=mapName,proto3" json:"map_name,omitempty"`
	Key      sharedpb.BPFHelper `protobuf:"varint,2,opt,name=key,proto3,enum=px.stirling.dynamic_tracing.ir.shared.BPFHelper" json:"key,omitempty"`
	ValueIds []string           `protobuf:"bytes,3,rep,name=value_ids,json=valueIds,proto3" json:"value_ids,omitempty"`
}

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

var xxx_messageInfo_MapValue proto.InternalMessageInfo

func (m *MapValue) GetMapName() string {
	if m != nil {
		return m.MapName
	}
	return ""
}

func (m *MapValue) GetKey() sharedpb.BPFHelper {
	if m != nil {
		return m.Key
	}
	return sharedpb.GOID
}

func (m *MapValue) GetValueIds() []string {
	if m != nil {
		return m.ValueIds
	}
	return nil
}

type MapStashAction struct {
	MapName            string              `protobuf:"bytes,1,opt,name=map_name,json=mapName,proto3" json:"map_name,omitempty"`
	Key                sharedpb.BPFHelper  `protobuf:"varint,2,opt,name=key,proto3,enum=px.stirling.dynamic_tracing.ir.shared.BPFHelper" json:"key,omitempty"`
	ValueVariableNames []string            `protobuf:"bytes,3,rep,name=value_variable_names,json=valueVariableNames,proto3" json:"value_variable_names,omitempty"`
	Cond               *sharedpb.Condition `protobuf:"bytes,4,opt,name=cond,proto3" json:"cond,omitempty"`
}

func (m *MapStashAction) Reset()      { *m = MapStashAction{} }
func (*MapStashAction) ProtoMessage() {}
func (*MapStashAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{4}
}
func (m *MapStashAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MapStashAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MapStashAction.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 *MapStashAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MapStashAction.Merge(m, src)
}
func (m *MapStashAction) XXX_Size() int {
	return m.Size()
}
func (m *MapStashAction) XXX_DiscardUnknown() {
	xxx_messageInfo_MapStashAction.DiscardUnknown(m)
}

var xxx_messageInfo_MapStashAction proto.InternalMessageInfo

func (m *MapStashAction) GetMapName() string {
	if m != nil {
		return m.MapName
	}
	return ""
}

func (m *MapStashAction) GetKey() sharedpb.BPFHelper {
	if m != nil {
		return m.Key
	}
	return sharedpb.GOID
}

func (m *MapStashAction) GetValueVariableNames() []string {
	if m != nil {
		return m.ValueVariableNames
	}
	return nil
}

func (m *MapStashAction) GetCond() *sharedpb.Condition {
	if m != nil {
		return m.Cond
	}
	return nil
}

type MapDeleteAction struct {
	MapName string             `protobuf:"bytes,1,opt,name=map_name,json=mapName,proto3" json:"map_name,omitempty"`
	Key     sharedpb.BPFHelper `protobuf:"varint,2,opt,name=key,proto3,enum=px.stirling.dynamic_tracing.ir.shared.BPFHelper" json:"key,omitempty"`
}

func (m *MapDeleteAction) Reset()      { *m = MapDeleteAction{} }
func (*MapDeleteAction) ProtoMessage() {}
func (*MapDeleteAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{5}
}
func (m *MapDeleteAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MapDeleteAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MapDeleteAction.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 *MapDeleteAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MapDeleteAction.Merge(m, src)
}
func (m *MapDeleteAction) XXX_Size() int {
	return m.Size()
}
func (m *MapDeleteAction) XXX_DiscardUnknown() {
	xxx_messageInfo_MapDeleteAction.DiscardUnknown(m)
}

var xxx_messageInfo_MapDeleteAction proto.InternalMessageInfo

func (m *MapDeleteAction) GetMapName() string {
	if m != nil {
		return m.MapName
	}
	return ""
}

func (m *MapDeleteAction) GetKey() sharedpb.BPFHelper {
	if m != nil {
		return m.Key
	}
	return sharedpb.GOID
}

type Output struct {
	Name   string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Fields []string `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
}

func (m *Output) Reset()      { *m = Output{} }
func (*Output) ProtoMessage() {}
func (*Output) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{6}
}
func (m *Output) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Output) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Output.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 *Output) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Output.Merge(m, src)
}
func (m *Output) XXX_Size() int {
	return m.Size()
}
func (m *Output) XXX_DiscardUnknown() {
	xxx_messageInfo_Output.DiscardUnknown(m)
}

var xxx_messageInfo_Output proto.InternalMessageInfo

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

func (m *Output) GetFields() []string {
	if m != nil {
		return m.Fields
	}
	return nil
}

type OutputAction struct {
	OutputName    string   `protobuf:"bytes,1,opt,name=output_name,json=outputName,proto3" json:"output_name,omitempty"`
	VariableNames []string `protobuf:"bytes,3,rep,name=variable_names,json=variableNames,proto3" json:"variable_names,omitempty"`
}

func (m *OutputAction) Reset()      { *m = OutputAction{} }
func (*OutputAction) ProtoMessage() {}
func (*OutputAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{7}
}
func (m *OutputAction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutputAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutputAction.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 *OutputAction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutputAction.Merge(m, src)
}
func (m *OutputAction) XXX_Size() int {
	return m.Size()
}
func (m *OutputAction) XXX_DiscardUnknown() {
	xxx_messageInfo_OutputAction.DiscardUnknown(m)
}

var xxx_messageInfo_OutputAction proto.InternalMessageInfo

func (m *OutputAction) GetOutputName() string {
	if m != nil {
		return m.OutputName
	}
	return ""
}

func (m *OutputAction) GetVariableNames() []string {
	if m != nil {
		return m.VariableNames
	}
	return nil
}

type Probe struct {
	Name       string               `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Tracepoint *sharedpb.Tracepoint `protobuf:"bytes,2,opt,name=tracepoint,proto3" json:"tracepoint,omitempty"`
	Consts     []*Constant          `protobuf:"bytes,3,rep,name=consts,proto3" json:"consts,omitempty"`
	Args       []*Argument          `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
	RetVals    []*ReturnValue       `protobuf:"bytes,5,rep,name=ret_vals,json=retVals,proto3" json:"ret_vals,omitempty"`
	MapVals    []*MapValue          `protobuf:"bytes,6,rep,name=map_vals,json=mapVals,proto3" json:"map_vals,omitempty"`
	// Types that are valid to be assigned to FunctionLatencyOneof:
	//
	//	*Probe_FunctionLatency
	FunctionLatencyOneof isProbe_FunctionLatencyOneof `protobuf_oneof:"function_latency_oneof"`
	MapStashActions      []*MapStashAction            `protobuf:"bytes,8,rep,name=map_stash_actions,json=mapStashActions,proto3" json:"map_stash_actions,omitempty"`
	MapDeleteActions     []*MapDeleteAction           `protobuf:"bytes,11,rep,name=map_delete_actions,json=mapDeleteActions,proto3" json:"map_delete_actions,omitempty"`
	OutputActions        []*OutputAction              `protobuf:"bytes,9,rep,name=output_actions,json=outputActions,proto3" json:"output_actions,omitempty"`
	Printks              []*sharedpb.Printk           `protobuf:"bytes,10,rep,name=printks,proto3" json:"printks,omitempty"`
}

func (m *Probe) Reset()      { *m = Probe{} }
func (*Probe) ProtoMessage() {}
func (*Probe) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{8}
}
func (m *Probe) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Probe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Probe.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 *Probe) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Probe.Merge(m, src)
}
func (m *Probe) XXX_Size() int {
	return m.Size()
}
func (m *Probe) XXX_DiscardUnknown() {
	xxx_messageInfo_Probe.DiscardUnknown(m)
}

var xxx_messageInfo_Probe proto.InternalMessageInfo

type isProbe_FunctionLatencyOneof interface {
	isProbe_FunctionLatencyOneof()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Probe_FunctionLatency struct {
	FunctionLatency *sharedpb.FunctionLatency `protobuf:"bytes,7,opt,name=function_latency,json=functionLatency,proto3,oneof" json:"function_latency,omitempty"`
}

func (*Probe_FunctionLatency) isProbe_FunctionLatencyOneof() {}

func (m *Probe) GetFunctionLatencyOneof() isProbe_FunctionLatencyOneof {
	if m != nil {
		return m.FunctionLatencyOneof
	}
	return nil
}

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

func (m *Probe) GetTracepoint() *sharedpb.Tracepoint {
	if m != nil {
		return m.Tracepoint
	}
	return nil
}

func (m *Probe) GetConsts() []*Constant {
	if m != nil {
		return m.Consts
	}
	return nil
}

func (m *Probe) GetArgs() []*Argument {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *Probe) GetRetVals() []*ReturnValue {
	if m != nil {
		return m.RetVals
	}
	return nil
}

func (m *Probe) GetMapVals() []*MapValue {
	if m != nil {
		return m.MapVals
	}
	return nil
}

func (m *Probe) GetFunctionLatency() *sharedpb.FunctionLatency {
	if x, ok := m.GetFunctionLatencyOneof().(*Probe_FunctionLatency); ok {
		return x.FunctionLatency
	}
	return nil
}

func (m *Probe) GetMapStashActions() []*MapStashAction {
	if m != nil {
		return m.MapStashActions
	}
	return nil
}

func (m *Probe) GetMapDeleteActions() []*MapDeleteAction {
	if m != nil {
		return m.MapDeleteActions
	}
	return nil
}

func (m *Probe) GetOutputActions() []*OutputAction {
	if m != nil {
		return m.OutputActions
	}
	return nil
}

func (m *Probe) GetPrintks() []*sharedpb.Printk {
	if m != nil {
		return m.Printks
	}
	return nil
}

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

type TracepointSpec struct {
	Language sharedpb.Language `protobuf:"varint,1,opt,name=language,proto3,enum=px.stirling.dynamic_tracing.ir.shared.Language" json:"language,omitempty"`
	Maps     []*sharedpb.Map   `protobuf:"bytes,2,rep,name=maps,proto3" json:"maps,omitempty"`
	Outputs  []*Output         `protobuf:"bytes,3,rep,name=outputs,proto3" json:"outputs,omitempty"`
	Probes   []*Probe          `protobuf:"bytes,4,rep,name=probes,proto3" json:"probes,omitempty"`
}

func (m *TracepointSpec) Reset()      { *m = TracepointSpec{} }
func (*TracepointSpec) ProtoMessage() {}
func (*TracepointSpec) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{9}
}
func (m *TracepointSpec) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointSpec.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 *TracepointSpec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointSpec.Merge(m, src)
}
func (m *TracepointSpec) XXX_Size() int {
	return m.Size()
}
func (m *TracepointSpec) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointSpec.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointSpec proto.InternalMessageInfo

func (m *TracepointSpec) GetLanguage() sharedpb.Language {
	if m != nil {
		return m.Language
	}
	return sharedpb.LANG_UNKNOWN
}

func (m *TracepointSpec) GetMaps() []*sharedpb.Map {
	if m != nil {
		return m.Maps
	}
	return nil
}

func (m *TracepointSpec) GetOutputs() []*Output {
	if m != nil {
		return m.Outputs
	}
	return nil
}

func (m *TracepointSpec) GetProbes() []*Probe {
	if m != nil {
		return m.Probes
	}
	return nil
}

type BPFTrace struct {
	Program string `protobuf:"bytes,1,opt,name=program,proto3" json:"program,omitempty"`
}

func (m *BPFTrace) Reset()      { *m = BPFTrace{} }
func (*BPFTrace) ProtoMessage() {}
func (*BPFTrace) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{10}
}
func (m *BPFTrace) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BPFTrace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BPFTrace.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 *BPFTrace) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BPFTrace.Merge(m, src)
}
func (m *BPFTrace) XXX_Size() int {
	return m.Size()
}
func (m *BPFTrace) XXX_DiscardUnknown() {
	xxx_messageInfo_BPFTrace.DiscardUnknown(m)
}

var xxx_messageInfo_BPFTrace proto.InternalMessageInfo

func (m *BPFTrace) GetProgram() string {
	if m != nil {
		return m.Program
	}
	return ""
}

type TracepointDeployment struct {
	Name           string                             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	TTL            *types.Duration                    `protobuf:"bytes,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
	DeploymentSpec *sharedpb.DeploymentSpec           `protobuf:"bytes,3,opt,name=deployment_spec,json=deploymentSpec,proto3" json:"deployment_spec,omitempty"`
	Tracepoints    []*TracepointDeployment_Tracepoint `protobuf:"bytes,4,rep,name=tracepoints,proto3" json:"tracepoints,omitempty"`
}

func (m *TracepointDeployment) Reset()      { *m = TracepointDeployment{} }
func (*TracepointDeployment) ProtoMessage() {}
func (*TracepointDeployment) Descriptor() ([]byte, []int) {
	return fileDescriptor_f7e5876dffcc11b4, []int{11}
}
func (m *TracepointDeployment) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointDeployment.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 *TracepointDeployment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointDeployment.Merge(m, src)
}
func (m *TracepointDeployment) XXX_Size() int {
	return m.Size()
}
func (m *TracepointDeployment) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointDeployment.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointDeployment proto.InternalMessageInfo

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

func (m *TracepointDeployment) GetTTL() *types.Duration {
	if m != nil {
		return m.TTL
	}
	return nil
}

func (m *TracepointDeployment) GetDeploymentSpec() *sharedpb.DeploymentSpec {
	if m != nil {
		return m.DeploymentSpec
	}
	return nil
}

func (m *TracepointDeployment) GetTracepoints() []*TracepointDeployment_Tracepoint {
	if m != nil {
		return m.Tracepoints
	}
	return nil
}

type TracepointDeployment_Tracepoint struct {
	TableName string          `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
	Program   *TracepointSpec `protobuf:"bytes,2,opt,name=program,proto3" json:"program,omitempty"`
	BPFTrace  *BPFTrace       `protobuf:"bytes,5,opt,name=bpftrace,proto3" json:"bpftrace,omitempty"`
}

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

var xxx_messageInfo_TracepointDeployment_Tracepoint proto.InternalMessageInfo

func (m *TracepointDeployment_Tracepoint) GetTableName() string {
	if m != nil {
		return m.TableName
	}
	return ""
}

func (m *TracepointDeployment_Tracepoint) GetProgram() *TracepointSpec {
	if m != nil {
		return m.Program
	}
	return nil
}

func (m *TracepointDeployment_Tracepoint) GetBPFTrace() *BPFTrace {
	if m != nil {
		return m.BPFTrace
	}
	return nil
}

func init() {
	proto.RegisterType((*Constant)(nil), "px.stirling.dynamic_tracing.ir.logical.Constant")
	proto.RegisterType((*Argument)(nil), "px.stirling.dynamic_tracing.ir.logical.Argument")
	proto.RegisterType((*ReturnValue)(nil), "px.stirling.dynamic_tracing.ir.logical.ReturnValue")
	proto.RegisterType((*MapValue)(nil), "px.stirling.dynamic_tracing.ir.logical.MapValue")
	proto.RegisterType((*MapStashAction)(nil), "px.stirling.dynamic_tracing.ir.logical.MapStashAction")
	proto.RegisterType((*MapDeleteAction)(nil), "px.stirling.dynamic_tracing.ir.logical.MapDeleteAction")
	proto.RegisterType((*Output)(nil), "px.stirling.dynamic_tracing.ir.logical.Output")
	proto.RegisterType((*OutputAction)(nil), "px.stirling.dynamic_tracing.ir.logical.OutputAction")
	proto.RegisterType((*Probe)(nil), "px.stirling.dynamic_tracing.ir.logical.Probe")
	proto.RegisterType((*TracepointSpec)(nil), "px.stirling.dynamic_tracing.ir.logical.TracepointSpec")
	proto.RegisterType((*BPFTrace)(nil), "px.stirling.dynamic_tracing.ir.logical.BPFTrace")
	proto.RegisterType((*TracepointDeployment)(nil), "px.stirling.dynamic_tracing.ir.logical.TracepointDeployment")
	proto.RegisterType((*TracepointDeployment_Tracepoint)(nil), "px.stirling.dynamic_tracing.ir.logical.TracepointDeployment.Tracepoint")
}

func init() {
	proto.RegisterFile("src/stirling/source_connectors/dynamic_tracer/dynamic_tracing/ir/logicalpb/logical.proto", fileDescriptor_f7e5876dffcc11b4)
}

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

func (this *Constant) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Constant)
	if !ok {
		that2, ok := that.(Constant)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Type != that1.Type {
		return false
	}
	if this.Constant != that1.Constant {
		return false
	}
	return true
}
func (this *Argument) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Argument)
	if !ok {
		that2, ok := that.(Argument)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.Expr != that1.Expr {
		return false
	}
	return true
}
func (this *ReturnValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReturnValue)
	if !ok {
		that2, ok := that.(ReturnValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.Expr != that1.Expr {
		return false
	}
	return true
}
func (this *MapValue) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapValue)
	if !ok {
		that2, ok := that.(MapValue)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MapName != that1.MapName {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if len(this.ValueIds) != len(that1.ValueIds) {
		return false
	}
	for i := range this.ValueIds {
		if this.ValueIds[i] != that1.ValueIds[i] {
			return false
		}
	}
	return true
}
func (this *MapStashAction) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapStashAction)
	if !ok {
		that2, ok := that.(MapStashAction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MapName != that1.MapName {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if len(this.ValueVariableNames) != len(that1.ValueVariableNames) {
		return false
	}
	for i := range this.ValueVariableNames {
		if this.ValueVariableNames[i] != that1.ValueVariableNames[i] {
			return false
		}
	}
	if !this.Cond.Equal(that1.Cond) {
		return false
	}
	return true
}
func (this *MapDeleteAction) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MapDeleteAction)
	if !ok {
		that2, ok := that.(MapDeleteAction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MapName != that1.MapName {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	return true
}
func (this *Output) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Output)
	if !ok {
		that2, ok := that.(Output)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if len(this.Fields) != len(that1.Fields) {
		return false
	}
	for i := range this.Fields {
		if this.Fields[i] != that1.Fields[i] {
			return false
		}
	}
	return true
}
func (this *OutputAction) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OutputAction)
	if !ok {
		that2, ok := that.(OutputAction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OutputName != that1.OutputName {
		return false
	}
	if len(this.VariableNames) != len(that1.VariableNames) {
		return false
	}
	for i := range this.VariableNames {
		if this.VariableNames[i] != that1.VariableNames[i] {
			return false
		}
	}
	return true
}
func (this *Probe) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Probe)
	if !ok {
		that2, ok := that.(Probe)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.Tracepoint.Equal(that1.Tracepoint) {
		return false
	}
	if len(this.Consts) != len(that1.Consts) {
		return false
	}
	for i := range this.Consts {
		if !this.Consts[i].Equal(that1.Consts[i]) {
			return false
		}
	}
	if len(this.Args) != len(that1.Args) {
		return false
	}
	for i := range this.Args {
		if !this.Args[i].Equal(that1.Args[i]) {
			return false
		}
	}
	if len(this.RetVals) != len(that1.RetVals) {
		return false
	}
	for i := range this.RetVals {
		if !this.RetVals[i].Equal(that1.RetVals[i]) {
			return false
		}
	}
	if len(this.MapVals) != len(that1.MapVals) {
		return false
	}
	for i := range this.MapVals {
		if !this.MapVals[i].Equal(that1.MapVals[i]) {
			return false
		}
	}
	if that1.FunctionLatencyOneof == nil {
		if this.FunctionLatencyOneof != nil {
			return false
		}
	} else if this.FunctionLatencyOneof == nil {
		return false
	} else if !this.FunctionLatencyOneof.Equal(that1.FunctionLatencyOneof) {
		return false
	}
	if len(this.MapStashActions) != len(that1.MapStashActions) {
		return false
	}
	for i := range this.MapStashActions {
		if !this.MapStashActions[i].Equal(that1.MapStashActions[i]) {
			return false
		}
	}
	if len(this.MapDeleteActions) != len(that1.MapDeleteActions) {
		return false
	}
	for i := range this.MapDeleteActions {
		if !this.MapDeleteActions[i].Equal(that1.MapDeleteActions[i]) {
			return false
		}
	}
	if len(this.OutputActions) != len(that1.OutputActions) {
		return false
	}
	for i := range this.OutputActions {
		if !this.OutputActions[i].Equal(that1.OutputActions[i]) {
			return false
		}
	}
	if len(this.Printks) != len(that1.Printks) {
		return false
	}
	for i := range this.Printks {
		if !this.Printks[i].Equal(that1.Printks[i]) {
			return false
		}
	}
	return true
}
func (this *Probe_FunctionLatency) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Probe_FunctionLatency)
	if !ok {
		that2, ok := that.(Probe_FunctionLatency)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.FunctionLatency.Equal(that1.FunctionLatency) {
		return false
	}
	return true
}
func (this *TracepointSpec) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointSpec)
	if !ok {
		that2, ok := that.(TracepointSpec)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Language != that1.Language {
		return false
	}
	if len(this.Maps) != len(that1.Maps) {
		return false
	}
	for i := range this.Maps {
		if !this.Maps[i].Equal(that1.Maps[i]) {
			return false
		}
	}
	if len(this.Outputs) != len(that1.Outputs) {
		return false
	}
	for i := range this.Outputs {
		if !this.Outputs[i].Equal(that1.Outputs[i]) {
			return false
		}
	}
	if len(this.Probes) != len(that1.Probes) {
		return false
	}
	for i := range this.Probes {
		if !this.Probes[i].Equal(that1.Probes[i]) {
			return false
		}
	}
	return true
}
func (this *BPFTrace) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BPFTrace)
	if !ok {
		that2, ok := that.(BPFTrace)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Program != that1.Program {
		return false
	}
	return true
}
func (this *TracepointDeployment) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointDeployment)
	if !ok {
		that2, ok := that.(TracepointDeployment)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.TTL.Equal(that1.TTL) {
		return false
	}
	if !this.DeploymentSpec.Equal(that1.DeploymentSpec) {
		return false
	}
	if len(this.Tracepoints) != len(that1.Tracepoints) {
		return false
	}
	for i := range this.Tracepoints {
		if !this.Tracepoints[i].Equal(that1.Tracepoints[i]) {
			return false
		}
	}
	return true
}
func (this *TracepointDeployment_Tracepoint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointDeployment_Tracepoint)
	if !ok {
		that2, ok := that.(TracepointDeployment_Tracepoint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TableName != that1.TableName {
		return false
	}
	if !this.Program.Equal(that1.Program) {
		return false
	}
	if !this.BPFTrace.Equal(that1.BPFTrace) {
		return false
	}
	return true
}
func (this *Constant) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&logicalpb.Constant{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Constant: "+fmt.Sprintf("%#v", this.Constant)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Argument) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.Argument{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "Expr: "+fmt.Sprintf("%#v", this.Expr)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ReturnValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.ReturnValue{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "Expr: "+fmt.Sprintf("%#v", this.Expr)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MapValue) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&logicalpb.MapValue{")
	s = append(s, "MapName: "+fmt.Sprintf("%#v", this.MapName)+",\n")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "ValueIds: "+fmt.Sprintf("%#v", this.ValueIds)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MapStashAction) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&logicalpb.MapStashAction{")
	s = append(s, "MapName: "+fmt.Sprintf("%#v", this.MapName)+",\n")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "ValueVariableNames: "+fmt.Sprintf("%#v", this.ValueVariableNames)+",\n")
	if this.Cond != nil {
		s = append(s, "Cond: "+fmt.Sprintf("%#v", this.Cond)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MapDeleteAction) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.MapDeleteAction{")
	s = append(s, "MapName: "+fmt.Sprintf("%#v", this.MapName)+",\n")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Output) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.Output{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Fields: "+fmt.Sprintf("%#v", this.Fields)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OutputAction) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&logicalpb.OutputAction{")
	s = append(s, "OutputName: "+fmt.Sprintf("%#v", this.OutputName)+",\n")
	s = append(s, "VariableNames: "+fmt.Sprintf("%#v", this.VariableNames)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Probe) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&logicalpb.Probe{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.Tracepoint != nil {
		s = append(s, "Tracepoint: "+fmt.Sprintf("%#v", this.Tracepoint)+",\n")
	}
	if this.Consts != nil {
		s = append(s, "Consts: "+fmt.Sprintf("%#v", this.Consts)+",\n")
	}
	if this.Args != nil {
		s = append(s, "Args: "+fmt.Sprintf("%#v", this.Args)+",\n")
	}
	if this.RetVals != nil {
		s = append(s, "RetVals: "+fmt.Sprintf("%#v", this.RetVals)+",\n")
	}
	if this.MapVals != nil {
		s = append(s, "MapVals: "+fmt.Sprintf("%#v", this.MapVals)+",\n")
	}
	if this.FunctionLatencyOneof != nil {
		s = append(s, "FunctionLatencyOneof: "+fmt.Sprintf("%#v", this.FunctionLatencyOneof)+",\n")
	}
	if this.MapStashActions != nil {
		s = append(s, "MapStashActions: "+fmt.Sprintf("%#v", this.MapStashActions)+",\n")
	}
	if this.MapDeleteActions != nil {
		s = append(s, "MapDeleteActions: "+fmt.Sprintf("%#v", this.MapDeleteActions)+",\n")
	}
	if this.OutputActions != nil {
		s = append(s, "OutputActions: "+fmt.Sprintf("%#v", this.OutputActions)+",\n")
	}
	if this.Printks != nil {
		s = append(s, "Printks: "+fmt.Sprintf("%#v", this.Printks)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Probe_FunctionLatency) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&logicalpb.Probe_FunctionLatency{` +
		`FunctionLatency:` + fmt.Sprintf("%#v", this.FunctionLatency) + `}`}, ", ")
	return s
}
func (this *TracepointSpec) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&logicalpb.TracepointSpec{")
	s = append(s, "Language: "+fmt.Sprintf("%#v", this.Language)+",\n")
	if this.Maps != nil {
		s = append(s, "Maps: "+fmt.Sprintf("%#v", this.Maps)+",\n")
	}
	if this.Outputs != nil {
		s = append(s, "Outputs: "+fmt.Sprintf("%#v", this.Outputs)+",\n")
	}
	if this.Probes != nil {
		s = append(s, "Probes: "+fmt.Sprintf("%#v", this.Probes)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BPFTrace) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&logicalpb.BPFTrace{")
	s = append(s, "Program: "+fmt.Sprintf("%#v", this.Program)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointDeployment) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&logicalpb.TracepointDeployment{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.TTL != nil {
		s = append(s, "TTL: "+fmt.Sprintf("%#v", this.TTL)+",\n")
	}
	if this.DeploymentSpec != nil {
		s = append(s, "DeploymentSpec: "+fmt.Sprintf("%#v", this.DeploymentSpec)+",\n")
	}
	if this.Tracepoints != nil {
		s = append(s, "Tracepoints: "+fmt.Sprintf("%#v", this.Tracepoints)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointDeployment_Tracepoint) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&logicalpb.TracepointDeployment_Tracepoint{")
	s = append(s, "TableName: "+fmt.Sprintf("%#v", this.TableName)+",\n")
	if this.Program != nil {
		s = append(s, "Program: "+fmt.Sprintf("%#v", this.Program)+",\n")
	}
	if this.BPFTrace != nil {
		s = append(s, "BPFTrace: "+fmt.Sprintf("%#v", this.BPFTrace)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringLogical(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Constant) 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 *Constant) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Constant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Constant) > 0 {
		i -= len(m.Constant)
		copy(dAtA[i:], m.Constant)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Constant)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Type != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Argument) 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 *Argument) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Argument) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Expr) > 0 {
		i -= len(m.Expr)
		copy(dAtA[i:], m.Expr)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Expr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ReturnValue) 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 *ReturnValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReturnValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Expr) > 0 {
		i -= len(m.Expr)
		copy(dAtA[i:], m.Expr)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Expr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MapValue) 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 *MapValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MapValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ValueIds) > 0 {
		for iNdEx := len(m.ValueIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ValueIds[iNdEx])
			copy(dAtA[i:], m.ValueIds[iNdEx])
			i = encodeVarintLogical(dAtA, i, uint64(len(m.ValueIds[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Key != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.Key))
		i--
		dAtA[i] = 0x10
	}
	if len(m.MapName) > 0 {
		i -= len(m.MapName)
		copy(dAtA[i:], m.MapName)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.MapName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MapStashAction) 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 *MapStashAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MapStashAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Cond != nil {
		{
			size, err := m.Cond.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.ValueVariableNames) > 0 {
		for iNdEx := len(m.ValueVariableNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ValueVariableNames[iNdEx])
			copy(dAtA[i:], m.ValueVariableNames[iNdEx])
			i = encodeVarintLogical(dAtA, i, uint64(len(m.ValueVariableNames[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Key != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.Key))
		i--
		dAtA[i] = 0x10
	}
	if len(m.MapName) > 0 {
		i -= len(m.MapName)
		copy(dAtA[i:], m.MapName)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.MapName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MapDeleteAction) 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 *MapDeleteAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MapDeleteAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Key != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.Key))
		i--
		dAtA[i] = 0x10
	}
	if len(m.MapName) > 0 {
		i -= len(m.MapName)
		copy(dAtA[i:], m.MapName)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.MapName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Output) 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 *Output) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *OutputAction) 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 *OutputAction) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutputAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.VariableNames) > 0 {
		for iNdEx := len(m.VariableNames) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.VariableNames[iNdEx])
			copy(dAtA[i:], m.VariableNames[iNdEx])
			i = encodeVarintLogical(dAtA, i, uint64(len(m.VariableNames[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.OutputName) > 0 {
		i -= len(m.OutputName)
		copy(dAtA[i:], m.OutputName)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.OutputName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Probe) 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 *Probe) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Probe) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MapDeleteActions) > 0 {
		for iNdEx := len(m.MapDeleteActions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MapDeleteActions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.Printks) > 0 {
		for iNdEx := len(m.Printks) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Printks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.OutputActions) > 0 {
		for iNdEx := len(m.OutputActions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutputActions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.MapStashActions) > 0 {
		for iNdEx := len(m.MapStashActions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MapStashActions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if m.FunctionLatencyOneof != nil {
		{
			size := m.FunctionLatencyOneof.Size()
			i -= size
			if _, err := m.FunctionLatencyOneof.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.MapVals) > 0 {
		for iNdEx := len(m.MapVals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MapVals[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.RetVals) > 0 {
		for iNdEx := len(m.RetVals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RetVals[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Consts) > 0 {
		for iNdEx := len(m.Consts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Consts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Tracepoint != nil {
		{
			size, err := m.Tracepoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Probe_FunctionLatency) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FunctionLatency != nil {
		{
			size, err := m.FunctionLatency.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *TracepointSpec) 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 *TracepointSpec) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Probes) > 0 {
		for iNdEx := len(m.Probes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Probes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Outputs) > 0 {
		for iNdEx := len(m.Outputs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Outputs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Maps) > 0 {
		for iNdEx := len(m.Maps) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Maps[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Language != 0 {
		i = encodeVarintLogical(dAtA, i, uint64(m.Language))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *BPFTrace) 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 *BPFTrace) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BPFTrace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Program) > 0 {
		i -= len(m.Program)
		copy(dAtA[i:], m.Program)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Program)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TracepointDeployment) 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 *TracepointDeployment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointDeployment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tracepoints) > 0 {
		for iNdEx := len(m.Tracepoints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tracepoints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintLogical(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.DeploymentSpec != nil {
		{
			size, err := m.DeploymentSpec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.TTL != nil {
		{
			size, err := m.TTL.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TracepointDeployment_Tracepoint) 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 *TracepointDeployment_Tracepoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointDeployment_Tracepoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BPFTrace != nil {
		{
			size, err := m.BPFTrace.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Program != nil {
		{
			size, err := m.Program.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLogical(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.TableName) > 0 {
		i -= len(m.TableName)
		copy(dAtA[i:], m.TableName)
		i = encodeVarintLogical(dAtA, i, uint64(len(m.TableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintLogical(dAtA []byte, offset int, v uint64) int {
	offset -= sovLogical(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Constant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovLogical(uint64(m.Type))
	}
	l = len(m.Constant)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *Argument) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	l = len(m.Expr)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *ReturnValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	l = len(m.Expr)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *MapValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MapName)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Key != 0 {
		n += 1 + sovLogical(uint64(m.Key))
	}
	if len(m.ValueIds) > 0 {
		for _, s := range m.ValueIds {
			l = len(s)
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *MapStashAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MapName)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Key != 0 {
		n += 1 + sovLogical(uint64(m.Key))
	}
	if len(m.ValueVariableNames) > 0 {
		for _, s := range m.ValueVariableNames {
			l = len(s)
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if m.Cond != nil {
		l = m.Cond.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *MapDeleteAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MapName)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Key != 0 {
		n += 1 + sovLogical(uint64(m.Key))
	}
	return n
}

func (m *Output) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.Fields) > 0 {
		for _, s := range m.Fields {
			l = len(s)
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *OutputAction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OutputName)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.VariableNames) > 0 {
		for _, s := range m.VariableNames {
			l = len(s)
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *Probe) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Tracepoint != nil {
		l = m.Tracepoint.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.Consts) > 0 {
		for _, e := range m.Consts {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.RetVals) > 0 {
		for _, e := range m.RetVals {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.MapVals) > 0 {
		for _, e := range m.MapVals {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if m.FunctionLatencyOneof != nil {
		n += m.FunctionLatencyOneof.Size()
	}
	if len(m.MapStashActions) > 0 {
		for _, e := range m.MapStashActions {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.OutputActions) > 0 {
		for _, e := range m.OutputActions {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.Printks) > 0 {
		for _, e := range m.Printks {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.MapDeleteActions) > 0 {
		for _, e := range m.MapDeleteActions {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *Probe_FunctionLatency) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FunctionLatency != nil {
		l = m.FunctionLatency.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}
func (m *TracepointSpec) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Language != 0 {
		n += 1 + sovLogical(uint64(m.Language))
	}
	if len(m.Maps) > 0 {
		for _, e := range m.Maps {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.Outputs) > 0 {
		for _, e := range m.Outputs {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	if len(m.Probes) > 0 {
		for _, e := range m.Probes {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *BPFTrace) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Program)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func (m *TracepointDeployment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.TTL != nil {
		l = m.TTL.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.DeploymentSpec != nil {
		l = m.DeploymentSpec.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if len(m.Tracepoints) > 0 {
		for _, e := range m.Tracepoints {
			l = e.Size()
			n += 1 + l + sovLogical(uint64(l))
		}
	}
	return n
}

func (m *TracepointDeployment_Tracepoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TableName)
	if l > 0 {
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.Program != nil {
		l = m.Program.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	if m.BPFTrace != nil {
		l = m.BPFTrace.Size()
		n += 1 + l + sovLogical(uint64(l))
	}
	return n
}

func sovLogical(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozLogical(x uint64) (n int) {
	return sovLogical(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Constant) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Constant{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Constant:` + fmt.Sprintf("%v", this.Constant) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Argument) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Argument{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Expr:` + fmt.Sprintf("%v", this.Expr) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReturnValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ReturnValue{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`Expr:` + fmt.Sprintf("%v", this.Expr) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MapValue) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MapValue{`,
		`MapName:` + fmt.Sprintf("%v", this.MapName) + `,`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`ValueIds:` + fmt.Sprintf("%v", this.ValueIds) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MapStashAction) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MapStashAction{`,
		`MapName:` + fmt.Sprintf("%v", this.MapName) + `,`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`ValueVariableNames:` + fmt.Sprintf("%v", this.ValueVariableNames) + `,`,
		`Cond:` + strings.Replace(fmt.Sprintf("%v", this.Cond), "Condition", "sharedpb.Condition", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MapDeleteAction) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MapDeleteAction{`,
		`MapName:` + fmt.Sprintf("%v", this.MapName) + `,`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Output) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Output{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Fields:` + fmt.Sprintf("%v", this.Fields) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OutputAction) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OutputAction{`,
		`OutputName:` + fmt.Sprintf("%v", this.OutputName) + `,`,
		`VariableNames:` + fmt.Sprintf("%v", this.VariableNames) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Probe) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForConsts := "[]*Constant{"
	for _, f := range this.Consts {
		repeatedStringForConsts += strings.Replace(f.String(), "Constant", "Constant", 1) + ","
	}
	repeatedStringForConsts += "}"
	repeatedStringForArgs := "[]*Argument{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(f.String(), "Argument", "Argument", 1) + ","
	}
	repeatedStringForArgs += "}"
	repeatedStringForRetVals := "[]*ReturnValue{"
	for _, f := range this.RetVals {
		repeatedStringForRetVals += strings.Replace(f.String(), "ReturnValue", "ReturnValue", 1) + ","
	}
	repeatedStringForRetVals += "}"
	repeatedStringForMapVals := "[]*MapValue{"
	for _, f := range this.MapVals {
		repeatedStringForMapVals += strings.Replace(f.String(), "MapValue", "MapValue", 1) + ","
	}
	repeatedStringForMapVals += "}"
	repeatedStringForMapStashActions := "[]*MapStashAction{"
	for _, f := range this.MapStashActions {
		repeatedStringForMapStashActions += strings.Replace(f.String(), "MapStashAction", "MapStashAction", 1) + ","
	}
	repeatedStringForMapStashActions += "}"
	repeatedStringForOutputActions := "[]*OutputAction{"
	for _, f := range this.OutputActions {
		repeatedStringForOutputActions += strings.Replace(f.String(), "OutputAction", "OutputAction", 1) + ","
	}
	repeatedStringForOutputActions += "}"
	repeatedStringForPrintks := "[]*Printk{"
	for _, f := range this.Printks {
		repeatedStringForPrintks += strings.Replace(fmt.Sprintf("%v", f), "Printk", "sharedpb.Printk", 1) + ","
	}
	repeatedStringForPrintks += "}"
	repeatedStringForMapDeleteActions := "[]*MapDeleteAction{"
	for _, f := range this.MapDeleteActions {
		repeatedStringForMapDeleteActions += strings.Replace(f.String(), "MapDeleteAction", "MapDeleteAction", 1) + ","
	}
	repeatedStringForMapDeleteActions += "}"
	s := strings.Join([]string{`&Probe{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Tracepoint:` + strings.Replace(fmt.Sprintf("%v", this.Tracepoint), "Tracepoint", "sharedpb.Tracepoint", 1) + `,`,
		`Consts:` + repeatedStringForConsts + `,`,
		`Args:` + repeatedStringForArgs + `,`,
		`RetVals:` + repeatedStringForRetVals + `,`,
		`MapVals:` + repeatedStringForMapVals + `,`,
		`FunctionLatencyOneof:` + fmt.Sprintf("%v", this.FunctionLatencyOneof) + `,`,
		`MapStashActions:` + repeatedStringForMapStashActions + `,`,
		`OutputActions:` + repeatedStringForOutputActions + `,`,
		`Printks:` + repeatedStringForPrintks + `,`,
		`MapDeleteActions:` + repeatedStringForMapDeleteActions + `,`,
		`}`,
	}, "")
	return s
}
func (this *Probe_FunctionLatency) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Probe_FunctionLatency{`,
		`FunctionLatency:` + strings.Replace(fmt.Sprintf("%v", this.FunctionLatency), "FunctionLatency", "sharedpb.FunctionLatency", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointSpec) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMaps := "[]*Map{"
	for _, f := range this.Maps {
		repeatedStringForMaps += strings.Replace(fmt.Sprintf("%v", f), "Map", "sharedpb.Map", 1) + ","
	}
	repeatedStringForMaps += "}"
	repeatedStringForOutputs := "[]*Output{"
	for _, f := range this.Outputs {
		repeatedStringForOutputs += strings.Replace(f.String(), "Output", "Output", 1) + ","
	}
	repeatedStringForOutputs += "}"
	repeatedStringForProbes := "[]*Probe{"
	for _, f := range this.Probes {
		repeatedStringForProbes += strings.Replace(f.String(), "Probe", "Probe", 1) + ","
	}
	repeatedStringForProbes += "}"
	s := strings.Join([]string{`&TracepointSpec{`,
		`Language:` + fmt.Sprintf("%v", this.Language) + `,`,
		`Maps:` + repeatedStringForMaps + `,`,
		`Outputs:` + repeatedStringForOutputs + `,`,
		`Probes:` + repeatedStringForProbes + `,`,
		`}`,
	}, "")
	return s
}
func (this *BPFTrace) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BPFTrace{`,
		`Program:` + fmt.Sprintf("%v", this.Program) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointDeployment) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTracepoints := "[]*TracepointDeployment_Tracepoint{"
	for _, f := range this.Tracepoints {
		repeatedStringForTracepoints += strings.Replace(fmt.Sprintf("%v", f), "TracepointDeployment_Tracepoint", "TracepointDeployment_Tracepoint", 1) + ","
	}
	repeatedStringForTracepoints += "}"
	s := strings.Join([]string{`&TracepointDeployment{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`TTL:` + strings.Replace(fmt.Sprintf("%v", this.TTL), "Duration", "types.Duration", 1) + `,`,
		`DeploymentSpec:` + strings.Replace(fmt.Sprintf("%v", this.DeploymentSpec), "DeploymentSpec", "sharedpb.DeploymentSpec", 1) + `,`,
		`Tracepoints:` + repeatedStringForTracepoints + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointDeployment_Tracepoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointDeployment_Tracepoint{`,
		`TableName:` + fmt.Sprintf("%v", this.TableName) + `,`,
		`Program:` + strings.Replace(this.Program.String(), "TracepointSpec", "TracepointSpec", 1) + `,`,
		`BPFTrace:` + strings.Replace(this.BPFTrace.String(), "BPFTrace", "BPFTrace", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringLogical(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Constant) 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 ErrIntOverflowLogical
			}
			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: Constant: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Constant: 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 ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= sharedpb.ScalarType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Constant", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Constant = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MapValue) 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 ErrIntOverflowLogical
			}
			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: MapValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MapValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			m.Key = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Key |= sharedpb.BPFHelper(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValueIds = append(m.ValueIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MapStashAction) 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 ErrIntOverflowLogical
			}
			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: MapStashAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MapStashAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			m.Key = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Key |= sharedpb.BPFHelper(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueVariableNames", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValueVariableNames = append(m.ValueVariableNames, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cond", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cond == nil {
				m.Cond = &sharedpb.Condition{}
			}
			if err := m.Cond.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MapDeleteAction) 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 ErrIntOverflowLogical
			}
			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: MapDeleteAction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MapDeleteAction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			m.Key = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Key |= sharedpb.BPFHelper(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Output) 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 ErrIntOverflowLogical
			}
			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: Output: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Output: 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 ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			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 Fields", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = append(m.Fields, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Probe) 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 ErrIntOverflowLogical
			}
			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: Probe: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Probe: 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 ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			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 Tracepoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tracepoint == nil {
				m.Tracepoint = &sharedpb.Tracepoint{}
			}
			if err := m.Tracepoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Consts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Consts = append(m.Consts, &Constant{})
			if err := m.Consts[len(m.Consts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &Argument{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RetVals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RetVals = append(m.RetVals, &ReturnValue{})
			if err := m.RetVals[len(m.RetVals)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapVals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapVals = append(m.MapVals, &MapValue{})
			if err := m.MapVals[len(m.MapVals)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionLatency", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &sharedpb.FunctionLatency{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.FunctionLatencyOneof = &Probe_FunctionLatency{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapStashActions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapStashActions = append(m.MapStashActions, &MapStashAction{})
			if err := m.MapStashActions[len(m.MapStashActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputActions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutputActions = append(m.OutputActions, &OutputAction{})
			if err := m.OutputActions[len(m.OutputActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Printks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Printks = append(m.Printks, &sharedpb.Printk{})
			if err := m.Printks[len(m.Printks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MapDeleteActions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MapDeleteActions = append(m.MapDeleteActions, &MapDeleteAction{})
			if err := m.MapDeleteActions[len(m.MapDeleteActions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointSpec) 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 ErrIntOverflowLogical
			}
			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: TracepointSpec: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointSpec: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Language", wireType)
			}
			m.Language = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Language |= sharedpb.Language(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Maps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Maps = append(m.Maps, &sharedpb.Map{})
			if err := m.Maps[len(m.Maps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Outputs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Outputs = append(m.Outputs, &Output{})
			if err := m.Outputs[len(m.Outputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Probes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Probes = append(m.Probes, &Probe{})
			if err := m.Probes[len(m.Probes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointDeployment) 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 ErrIntOverflowLogical
			}
			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: TracepointDeployment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointDeployment: 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 ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			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 TTL", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TTL == nil {
				m.TTL = &types.Duration{}
			}
			if err := m.TTL.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeploymentSpec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeploymentSpec == nil {
				m.DeploymentSpec = &sharedpb.DeploymentSpec{}
			}
			if err := m.DeploymentSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tracepoints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tracepoints = append(m.Tracepoints, &TracepointDeployment_Tracepoint{})
			if err := m.Tracepoints[len(m.Tracepoints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointDeployment_Tracepoint) 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 ErrIntOverflowLogical
			}
			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: Tracepoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tracepoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				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 ErrInvalidLengthLogical
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Program", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Program == nil {
				m.Program = &TracepointSpec{}
			}
			if err := m.Program.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BPFTrace", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLogical
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLogical
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLogical
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BPFTrace == nil {
				m.BPFTrace = &BPFTrace{}
			}
			if err := m.BPFTrace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLogical(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthLogical
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipLogical(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, ErrIntOverflowLogical
			}
			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, ErrIntOverflowLogical
				}
				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, ErrIntOverflowLogical
				}
				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, ErrInvalidLengthLogical
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupLogical
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthLogical
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthLogical        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLogical          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLogical = fmt.Errorf("proto: unexpected end of group")
)