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

package core

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/grafana/mimir/pkg/mimirpb"
	github_com_grafana_mimir_pkg_mimirpb "github.com/grafana/mimir/pkg/mimirpb"
	functions "github.com/grafana/mimir/pkg/streamingpromql/operators/functions"
	github_com_prometheus_prometheus_model_labels "github.com/prometheus/prometheus/model/labels"
	github_com_prometheus_prometheus_promql_parser "github.com/prometheus/prometheus/promql/parser"
	github_com_prometheus_prometheus_promql_parser_posrange "github.com/prometheus/prometheus/promql/parser/posrange"
	_ "google.golang.org/protobuf/types/known/durationpb"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
	time "time"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// Why don't we just use the parser.ItemType values?
// There's no guarantee these values remain stable, so relying on them could introduce backwards compatibility issues
// if a value changes.
type AggregationOperation int32

const (
	AGGREGATION_UNKNOWN      AggregationOperation = 0
	AGGREGATION_SUM          AggregationOperation = 1
	AGGREGATION_AVG          AggregationOperation = 2
	AGGREGATION_COUNT        AggregationOperation = 3
	AGGREGATION_MIN          AggregationOperation = 4
	AGGREGATION_MAX          AggregationOperation = 5
	AGGREGATION_GROUP        AggregationOperation = 6
	AGGREGATION_STDDEV       AggregationOperation = 7
	AGGREGATION_STDVAR       AggregationOperation = 8
	AGGREGATION_TOPK         AggregationOperation = 9
	AGGREGATION_BOTTOMK      AggregationOperation = 10
	AGGREGATION_COUNT_VALUES AggregationOperation = 11
	AGGREGATION_QUANTILE     AggregationOperation = 12
	AGGREGATION_LIMITK       AggregationOperation = 13
	AGGREGATION_LIMIT_RATIO  AggregationOperation = 14
)

var AggregationOperation_name = map[int32]string{
	0:  "AGGREGATION_UNKNOWN",
	1:  "AGGREGATION_SUM",
	2:  "AGGREGATION_AVG",
	3:  "AGGREGATION_COUNT",
	4:  "AGGREGATION_MIN",
	5:  "AGGREGATION_MAX",
	6:  "AGGREGATION_GROUP",
	7:  "AGGREGATION_STDDEV",
	8:  "AGGREGATION_STDVAR",
	9:  "AGGREGATION_TOPK",
	10: "AGGREGATION_BOTTOMK",
	11: "AGGREGATION_COUNT_VALUES",
	12: "AGGREGATION_QUANTILE",
	13: "AGGREGATION_LIMITK",
	14: "AGGREGATION_LIMIT_RATIO",
}

var AggregationOperation_value = map[string]int32{
	"AGGREGATION_UNKNOWN":      0,
	"AGGREGATION_SUM":          1,
	"AGGREGATION_AVG":          2,
	"AGGREGATION_COUNT":        3,
	"AGGREGATION_MIN":          4,
	"AGGREGATION_MAX":          5,
	"AGGREGATION_GROUP":        6,
	"AGGREGATION_STDDEV":       7,
	"AGGREGATION_STDVAR":       8,
	"AGGREGATION_TOPK":         9,
	"AGGREGATION_BOTTOMK":      10,
	"AGGREGATION_COUNT_VALUES": 11,
	"AGGREGATION_QUANTILE":     12,
	"AGGREGATION_LIMITK":       13,
	"AGGREGATION_LIMIT_RATIO":  14,
}

func (AggregationOperation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f7e43720d1edc0fe, []int{0}
}

// Why don't we just use the parser.ItemType values?
// There's no guarantee these values remain stable, so relying on them could introduce backwards compatibility issues
// if a value changes.
type BinaryOperation int32

const (
	BINARY_UNKNOWN BinaryOperation = 0
	BINARY_LAND    BinaryOperation = 1
	BINARY_LOR     BinaryOperation = 2
	BINARY_LUNLESS BinaryOperation = 3
	BINARY_ATAN2   BinaryOperation = 4
	BINARY_SUB     BinaryOperation = 5
	BINARY_ADD     BinaryOperation = 6
	BINARY_MUL     BinaryOperation = 7
	BINARY_MOD     BinaryOperation = 8
	BINARY_DIV     BinaryOperation = 9
	BINARY_POW     BinaryOperation = 10
	BINARY_EQLC    BinaryOperation = 11
	BINARY_NEQ     BinaryOperation = 12
	BINARY_LTE     BinaryOperation = 13
	BINARY_LSS     BinaryOperation = 14
	BINARY_GTE     BinaryOperation = 15
	BINARY_GTR     BinaryOperation = 16
)

var BinaryOperation_name = map[int32]string{
	0:  "BINARY_UNKNOWN",
	1:  "BINARY_LAND",
	2:  "BINARY_LOR",
	3:  "BINARY_LUNLESS",
	4:  "BINARY_ATAN2",
	5:  "BINARY_SUB",
	6:  "BINARY_ADD",
	7:  "BINARY_MUL",
	8:  "BINARY_MOD",
	9:  "BINARY_DIV",
	10: "BINARY_POW",
	11: "BINARY_EQLC",
	12: "BINARY_NEQ",
	13: "BINARY_LTE",
	14: "BINARY_LSS",
	15: "BINARY_GTE",
	16: "BINARY_GTR",
}

var BinaryOperation_value = map[string]int32{
	"BINARY_UNKNOWN": 0,
	"BINARY_LAND":    1,
	"BINARY_LOR":     2,
	"BINARY_LUNLESS": 3,
	"BINARY_ATAN2":   4,
	"BINARY_SUB":     5,
	"BINARY_ADD":     6,
	"BINARY_MUL":     7,
	"BINARY_MOD":     8,
	"BINARY_DIV":     9,
	"BINARY_POW":     10,
	"BINARY_EQLC":    11,
	"BINARY_NEQ":     12,
	"BINARY_LTE":     13,
	"BINARY_LSS":     14,
	"BINARY_GTE":     15,
	"BINARY_GTR":     16,
}

func (BinaryOperation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f7e43720d1edc0fe, []int{1}
}

// Why don't we just use the parser.ItemType values?
// There's no guarantee these values remain stable, so relying on them could introduce backwards compatibility issues
// if a value changes.
type UnaryOperation int32

const (
	UNARY_UNKNOWN UnaryOperation = 0
	UNARY_SUB     UnaryOperation = 1
)

var UnaryOperation_name = map[int32]string{
	0: "UNARY_UNKNOWN",
	1: "UNARY_SUB",
}

var UnaryOperation_value = map[string]int32{
	"UNARY_UNKNOWN": 0,
	"UNARY_SUB":     1,
}

func (UnaryOperation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f7e43720d1edc0fe, []int{2}
}

type PositionRange struct {
	Start github_com_prometheus_prometheus_promql_parser_posrange.Pos `protobuf:"varint,1,opt,name=start,proto3,casttype=github.com/prometheus/prometheus/promql/parser/posrange.Pos" json:"start,omitempty"`
	End   github_com_prometheus_prometheus_promql_parser_posrange.Pos `protobuf:"varint,2,opt,name=end,proto3,casttype=github.com/prometheus/prometheus/promql/parser/posrange.Pos" json:"end,omitempty"`
}

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

var xxx_messageInfo_PositionRange proto.InternalMessageInfo

func (m *PositionRange) GetStart() github_com_prometheus_prometheus_promql_parser_posrange.Pos {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *PositionRange) GetEnd() github_com_prometheus_prometheus_promql_parser_posrange.Pos {
	if m != nil {
		return m.End
	}
	return 0
}

func (*PositionRange) XXX_MessageName() string {
	return "core.PositionRange"
}

type BinaryExpressionHints struct {
	Include []string `protobuf:"bytes,1,rep,name=include,proto3" json:"include,omitempty"`
}

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

var xxx_messageInfo_BinaryExpressionHints proto.InternalMessageInfo

func (m *BinaryExpressionHints) GetInclude() []string {
	if m != nil {
		return m.Include
	}
	return nil
}

func (*BinaryExpressionHints) XXX_MessageName() string {
	return "core.BinaryExpressionHints"
}

type AggregateExpressionDetails struct {
	Op                 AggregationOperation `protobuf:"varint,1,opt,name=op,proto3,enum=core.AggregationOperation" json:"op,omitempty"`
	Grouping           []string             `protobuf:"bytes,2,rep,name=grouping,proto3" json:"grouping,omitempty"`
	Without            bool                 `protobuf:"varint,3,opt,name=without,proto3" json:"without,omitempty"`
	ExpressionPosition PositionRange        `protobuf:"bytes,4,opt,name=expressionPosition,proto3" json:"expressionPosition"`
}

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

var xxx_messageInfo_AggregateExpressionDetails proto.InternalMessageInfo

func (m *AggregateExpressionDetails) GetOp() AggregationOperation {
	if m != nil {
		return m.Op
	}
	return AGGREGATION_UNKNOWN
}

func (m *AggregateExpressionDetails) GetGrouping() []string {
	if m != nil {
		return m.Grouping
	}
	return nil
}

func (m *AggregateExpressionDetails) GetWithout() bool {
	if m != nil {
		return m.Without
	}
	return false
}

func (m *AggregateExpressionDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (*AggregateExpressionDetails) XXX_MessageName() string {
	return "core.AggregateExpressionDetails"
}

type BinaryExpressionDetails struct {
	Op                 BinaryOperation        `protobuf:"varint,1,opt,name=op,proto3,enum=core.BinaryOperation" json:"op,omitempty"`
	VectorMatching     *VectorMatching        `protobuf:"bytes,2,opt,name=vectorMatching,proto3" json:"vectorMatching,omitempty"`
	ReturnBool         bool                   `protobuf:"varint,3,opt,name=returnBool,proto3" json:"returnBool,omitempty"`
	ExpressionPosition PositionRange          `protobuf:"bytes,4,opt,name=expressionPosition,proto3" json:"expressionPosition"`
	Hints              *BinaryExpressionHints `protobuf:"bytes,5,opt,name=hints,proto3" json:"hints,omitempty"`
}

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

var xxx_messageInfo_BinaryExpressionDetails proto.InternalMessageInfo

func (m *BinaryExpressionDetails) GetOp() BinaryOperation {
	if m != nil {
		return m.Op
	}
	return BINARY_UNKNOWN
}

func (m *BinaryExpressionDetails) GetVectorMatching() *VectorMatching {
	if m != nil {
		return m.VectorMatching
	}
	return nil
}

func (m *BinaryExpressionDetails) GetReturnBool() bool {
	if m != nil {
		return m.ReturnBool
	}
	return false
}

func (m *BinaryExpressionDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (m *BinaryExpressionDetails) GetHints() *BinaryExpressionHints {
	if m != nil {
		return m.Hints
	}
	return nil
}

func (*BinaryExpressionDetails) XXX_MessageName() string {
	return "core.BinaryExpressionDetails"
}

type VectorMatching struct {
	Card           github_com_prometheus_prometheus_promql_parser.VectorMatchCardinality `protobuf:"varint,1,opt,name=card,proto3,casttype=github.com/prometheus/prometheus/promql/parser.VectorMatchCardinality" json:"card,omitempty"`
	MatchingLabels []string                                                              `protobuf:"bytes,2,rep,name=matchingLabels,proto3" json:"matchingLabels,omitempty"`
	On             bool                                                                  `protobuf:"varint,3,opt,name=on,proto3" json:"on,omitempty"`
	Include        []string                                                              `protobuf:"bytes,4,rep,name=include,proto3" json:"include,omitempty"`
}

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

var xxx_messageInfo_VectorMatching proto.InternalMessageInfo

func (m *VectorMatching) GetCard() github_com_prometheus_prometheus_promql_parser.VectorMatchCardinality {
	if m != nil {
		return m.Card
	}
	return 0
}

func (m *VectorMatching) GetMatchingLabels() []string {
	if m != nil {
		return m.MatchingLabels
	}
	return nil
}

func (m *VectorMatching) GetOn() bool {
	if m != nil {
		return m.On
	}
	return false
}

func (m *VectorMatching) GetInclude() []string {
	if m != nil {
		return m.Include
	}
	return nil
}

func (*VectorMatching) XXX_MessageName() string {
	return "core.VectorMatching"
}

type FunctionCallDetails struct {
	Function functions.Function `protobuf:"varint,1,opt,name=function,proto3,enum=functions.Function" json:"function,omitempty"`
	// Labels used by absent() or absent_over_time(). Only populated if this instance is for either of these two functions.
	AbsentLabels       []github_com_grafana_mimir_pkg_mimirpb.LabelAdapter `protobuf:"bytes,2,rep,name=absentLabels,proto3,customtype=github.com/grafana/mimir/pkg/mimirpb.LabelAdapter" json:"absentLabels"`
	ExpressionPosition PositionRange                                       `protobuf:"bytes,3,opt,name=expressionPosition,proto3" json:"expressionPosition"`
}

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

var xxx_messageInfo_FunctionCallDetails proto.InternalMessageInfo

func (m *FunctionCallDetails) GetFunction() functions.Function {
	if m != nil {
		return m.Function
	}
	return functions.FUNCTION_UNKNOWN
}

func (m *FunctionCallDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (*FunctionCallDetails) XXX_MessageName() string {
	return "core.FunctionCallDetails"
}

type NumberLiteralDetails struct {
	Value              float64       `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
	ExpressionPosition PositionRange `protobuf:"bytes,2,opt,name=expressionPosition,proto3" json:"expressionPosition"`
}

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

var xxx_messageInfo_NumberLiteralDetails proto.InternalMessageInfo

func (m *NumberLiteralDetails) GetValue() float64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *NumberLiteralDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (*NumberLiteralDetails) XXX_MessageName() string {
	return "core.NumberLiteralDetails"
}

type StringLiteralDetails struct {
	Value              string        `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	ExpressionPosition PositionRange `protobuf:"bytes,2,opt,name=expressionPosition,proto3" json:"expressionPosition"`
}

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

var xxx_messageInfo_StringLiteralDetails proto.InternalMessageInfo

func (m *StringLiteralDetails) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *StringLiteralDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (*StringLiteralDetails) XXX_MessageName() string {
	return "core.StringLiteralDetails"
}

type UnaryExpressionDetails struct {
	Op                 UnaryOperation `protobuf:"varint,1,opt,name=op,proto3,enum=core.UnaryOperation" json:"op,omitempty"`
	ExpressionPosition PositionRange  `protobuf:"bytes,2,opt,name=expressionPosition,proto3" json:"expressionPosition"`
}

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

var xxx_messageInfo_UnaryExpressionDetails proto.InternalMessageInfo

func (m *UnaryExpressionDetails) GetOp() UnaryOperation {
	if m != nil {
		return m.Op
	}
	return UNARY_UNKNOWN
}

func (m *UnaryExpressionDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (*UnaryExpressionDetails) XXX_MessageName() string {
	return "core.UnaryExpressionDetails"
}

type VectorSelectorDetails struct {
	Matchers               []*LabelMatcher `protobuf:"bytes,1,rep,name=matchers,proto3" json:"matchers,omitempty"`
	Timestamp              *time.Time      `protobuf:"bytes,2,opt,name=timestamp,proto3,stdtime" json:"timestamp,omitempty"`
	Offset                 time.Duration   `protobuf:"bytes,3,opt,name=offset,proto3,stdduration" json:"offset"`
	ExpressionPosition     PositionRange   `protobuf:"bytes,4,opt,name=expressionPosition,proto3" json:"expressionPosition"`
	ReturnSampleTimestamps bool            `protobuf:"varint,5,opt,name=returnSampleTimestamps,proto3" json:"returnSampleTimestamps,omitempty"`
	SkipHistogramBuckets   bool            `protobuf:"varint,6,opt,name=skipHistogramBuckets,proto3" json:"skipHistogramBuckets,omitempty"`
}

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

var xxx_messageInfo_VectorSelectorDetails proto.InternalMessageInfo

func (m *VectorSelectorDetails) GetMatchers() []*LabelMatcher {
	if m != nil {
		return m.Matchers
	}
	return nil
}

func (m *VectorSelectorDetails) GetTimestamp() *time.Time {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *VectorSelectorDetails) GetOffset() time.Duration {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *VectorSelectorDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (m *VectorSelectorDetails) GetReturnSampleTimestamps() bool {
	if m != nil {
		return m.ReturnSampleTimestamps
	}
	return false
}

func (m *VectorSelectorDetails) GetSkipHistogramBuckets() bool {
	if m != nil {
		return m.SkipHistogramBuckets
	}
	return false
}

func (*VectorSelectorDetails) XXX_MessageName() string {
	return "core.VectorSelectorDetails"
}

type MatrixSelectorDetails struct {
	Matchers             []*LabelMatcher `protobuf:"bytes,1,rep,name=matchers,proto3" json:"matchers,omitempty"`
	Timestamp            *time.Time      `protobuf:"bytes,2,opt,name=timestamp,proto3,stdtime" json:"timestamp,omitempty"`
	Offset               time.Duration   `protobuf:"bytes,3,opt,name=offset,proto3,stdduration" json:"offset"`
	Range                time.Duration   `protobuf:"bytes,4,opt,name=range,proto3,stdduration" json:"range"`
	ExpressionPosition   PositionRange   `protobuf:"bytes,5,opt,name=expressionPosition,proto3" json:"expressionPosition"`
	SkipHistogramBuckets bool            `protobuf:"varint,6,opt,name=skipHistogramBuckets,proto3" json:"skipHistogramBuckets,omitempty"`
}

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

var xxx_messageInfo_MatrixSelectorDetails proto.InternalMessageInfo

func (m *MatrixSelectorDetails) GetMatchers() []*LabelMatcher {
	if m != nil {
		return m.Matchers
	}
	return nil
}

func (m *MatrixSelectorDetails) GetTimestamp() *time.Time {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *MatrixSelectorDetails) GetOffset() time.Duration {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *MatrixSelectorDetails) GetRange() time.Duration {
	if m != nil {
		return m.Range
	}
	return 0
}

func (m *MatrixSelectorDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (m *MatrixSelectorDetails) GetSkipHistogramBuckets() bool {
	if m != nil {
		return m.SkipHistogramBuckets
	}
	return false
}

func (*MatrixSelectorDetails) XXX_MessageName() string {
	return "core.MatrixSelectorDetails"
}

type SubqueryDetails struct {
	Timestamp          *time.Time    `protobuf:"bytes,1,opt,name=timestamp,proto3,stdtime" json:"timestamp,omitempty"`
	Offset             time.Duration `protobuf:"bytes,2,opt,name=offset,proto3,stdduration" json:"offset"`
	Range              time.Duration `protobuf:"bytes,3,opt,name=range,proto3,stdduration" json:"range"`
	Step               time.Duration `protobuf:"bytes,4,opt,name=step,proto3,stdduration" json:"step"`
	ExpressionPosition PositionRange `protobuf:"bytes,5,opt,name=expressionPosition,proto3" json:"expressionPosition"`
}

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

var xxx_messageInfo_SubqueryDetails proto.InternalMessageInfo

func (m *SubqueryDetails) GetTimestamp() *time.Time {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *SubqueryDetails) GetOffset() time.Duration {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *SubqueryDetails) GetRange() time.Duration {
	if m != nil {
		return m.Range
	}
	return 0
}

func (m *SubqueryDetails) GetStep() time.Duration {
	if m != nil {
		return m.Step
	}
	return 0
}

func (m *SubqueryDetails) GetExpressionPosition() PositionRange {
	if m != nil {
		return m.ExpressionPosition
	}
	return PositionRange{}
}

func (*SubqueryDetails) XXX_MessageName() string {
	return "core.SubqueryDetails"
}

type StepInvariantExpressionDetails struct {
}

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

var xxx_messageInfo_StepInvariantExpressionDetails proto.InternalMessageInfo

func (*StepInvariantExpressionDetails) XXX_MessageName() string {
	return "core.StepInvariantExpressionDetails"
}

type LabelMatcher struct {
	Type  github_com_prometheus_prometheus_model_labels.MatchType `protobuf:"varint,1,opt,name=type,proto3,casttype=github.com/prometheus/prometheus/model/labels.MatchType" json:"type,omitempty"`
	Name  string                                                  `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Value string                                                  `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_LabelMatcher proto.InternalMessageInfo

func (m *LabelMatcher) GetType() github_com_prometheus_prometheus_model_labels.MatchType {
	if m != nil {
		return m.Type
	}
	return 0
}

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

func (m *LabelMatcher) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (*LabelMatcher) XXX_MessageName() string {
	return "core.LabelMatcher"
}

type DeduplicateAndMergeDetails struct {
}

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

var xxx_messageInfo_DeduplicateAndMergeDetails proto.InternalMessageInfo

func (*DeduplicateAndMergeDetails) XXX_MessageName() string {
	return "core.DeduplicateAndMergeDetails"
}

type DropNameDetails struct {
}

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

var xxx_messageInfo_DropNameDetails proto.InternalMessageInfo

func (*DropNameDetails) XXX_MessageName() string {
	return "core.DropNameDetails"
}
func init() {
	proto.RegisterEnum("core.AggregationOperation", AggregationOperation_name, AggregationOperation_value)
	proto.RegisterEnum("core.BinaryOperation", BinaryOperation_name, BinaryOperation_value)
	proto.RegisterEnum("core.UnaryOperation", UnaryOperation_name, UnaryOperation_value)
	proto.RegisterType((*PositionRange)(nil), "core.PositionRange")
	proto.RegisterType((*BinaryExpressionHints)(nil), "core.BinaryExpressionHints")
	proto.RegisterType((*AggregateExpressionDetails)(nil), "core.AggregateExpressionDetails")
	proto.RegisterType((*BinaryExpressionDetails)(nil), "core.BinaryExpressionDetails")
	proto.RegisterType((*VectorMatching)(nil), "core.VectorMatching")
	proto.RegisterType((*FunctionCallDetails)(nil), "core.FunctionCallDetails")
	proto.RegisterType((*NumberLiteralDetails)(nil), "core.NumberLiteralDetails")
	proto.RegisterType((*StringLiteralDetails)(nil), "core.StringLiteralDetails")
	proto.RegisterType((*UnaryExpressionDetails)(nil), "core.UnaryExpressionDetails")
	proto.RegisterType((*VectorSelectorDetails)(nil), "core.VectorSelectorDetails")
	proto.RegisterType((*MatrixSelectorDetails)(nil), "core.MatrixSelectorDetails")
	proto.RegisterType((*SubqueryDetails)(nil), "core.SubqueryDetails")
	proto.RegisterType((*StepInvariantExpressionDetails)(nil), "core.StepInvariantExpressionDetails")
	proto.RegisterType((*LabelMatcher)(nil), "core.LabelMatcher")
	proto.RegisterType((*DeduplicateAndMergeDetails)(nil), "core.DeduplicateAndMergeDetails")
	proto.RegisterType((*DropNameDetails)(nil), "core.DropNameDetails")
}

func init() { proto.RegisterFile("core.proto", fileDescriptor_f7e43720d1edc0fe) }

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

func (x AggregationOperation) String() string {
	s, ok := AggregationOperation_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x BinaryOperation) String() string {
	s, ok := BinaryOperation_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x UnaryOperation) String() string {
	s, ok := UnaryOperation_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *PositionRange) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&core.PositionRange{")
	s = append(s, "Start: "+fmt.Sprintf("%#v", this.Start)+",\n")
	s = append(s, "End: "+fmt.Sprintf("%#v", this.End)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BinaryExpressionHints) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&core.BinaryExpressionHints{")
	s = append(s, "Include: "+fmt.Sprintf("%#v", this.Include)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AggregateExpressionDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&core.AggregateExpressionDetails{")
	s = append(s, "Op: "+fmt.Sprintf("%#v", this.Op)+",\n")
	s = append(s, "Grouping: "+fmt.Sprintf("%#v", this.Grouping)+",\n")
	s = append(s, "Without: "+fmt.Sprintf("%#v", this.Without)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BinaryExpressionDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&core.BinaryExpressionDetails{")
	s = append(s, "Op: "+fmt.Sprintf("%#v", this.Op)+",\n")
	if this.VectorMatching != nil {
		s = append(s, "VectorMatching: "+fmt.Sprintf("%#v", this.VectorMatching)+",\n")
	}
	s = append(s, "ReturnBool: "+fmt.Sprintf("%#v", this.ReturnBool)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	if this.Hints != nil {
		s = append(s, "Hints: "+fmt.Sprintf("%#v", this.Hints)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VectorMatching) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&core.VectorMatching{")
	s = append(s, "Card: "+fmt.Sprintf("%#v", this.Card)+",\n")
	s = append(s, "MatchingLabels: "+fmt.Sprintf("%#v", this.MatchingLabels)+",\n")
	s = append(s, "On: "+fmt.Sprintf("%#v", this.On)+",\n")
	s = append(s, "Include: "+fmt.Sprintf("%#v", this.Include)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *FunctionCallDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&core.FunctionCallDetails{")
	s = append(s, "Function: "+fmt.Sprintf("%#v", this.Function)+",\n")
	s = append(s, "AbsentLabels: "+fmt.Sprintf("%#v", this.AbsentLabels)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NumberLiteralDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&core.NumberLiteralDetails{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *StringLiteralDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&core.StringLiteralDetails{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UnaryExpressionDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&core.UnaryExpressionDetails{")
	s = append(s, "Op: "+fmt.Sprintf("%#v", this.Op)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *VectorSelectorDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&core.VectorSelectorDetails{")
	if this.Matchers != nil {
		s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
	}
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "ReturnSampleTimestamps: "+fmt.Sprintf("%#v", this.ReturnSampleTimestamps)+",\n")
	s = append(s, "SkipHistogramBuckets: "+fmt.Sprintf("%#v", this.SkipHistogramBuckets)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MatrixSelectorDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&core.MatrixSelectorDetails{")
	if this.Matchers != nil {
		s = append(s, "Matchers: "+fmt.Sprintf("%#v", this.Matchers)+",\n")
	}
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Range: "+fmt.Sprintf("%#v", this.Range)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "SkipHistogramBuckets: "+fmt.Sprintf("%#v", this.SkipHistogramBuckets)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SubqueryDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&core.SubqueryDetails{")
	s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Range: "+fmt.Sprintf("%#v", this.Range)+",\n")
	s = append(s, "Step: "+fmt.Sprintf("%#v", this.Step)+",\n")
	s = append(s, "ExpressionPosition: "+strings.Replace(this.ExpressionPosition.GoString(), `&`, ``, 1)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *StepInvariantExpressionDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&core.StepInvariantExpressionDetails{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LabelMatcher) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&core.LabelMatcher{")
	s = append(s, "Type: "+fmt.Sprintf("%#v", this.Type)+",\n")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeduplicateAndMergeDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&core.DeduplicateAndMergeDetails{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DropNameDetails) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&core.DropNameDetails{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringCore(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 *PositionRange) 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 *PositionRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

func (m *AggregateExpressionDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Without {
		i--
		if m.Without {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Grouping) > 0 {
		for iNdEx := len(m.Grouping) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Grouping[iNdEx])
			copy(dAtA[i:], m.Grouping[iNdEx])
			i = encodeVarintCore(dAtA, i, uint64(len(m.Grouping[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Op != 0 {
		i = encodeVarintCore(dAtA, i, uint64(m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *BinaryExpressionDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Hints != nil {
		{
			size, err := m.Hints.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCore(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.ReturnBool {
		i--
		if m.ReturnBool {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.VectorMatching != nil {
		{
			size, err := m.VectorMatching.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCore(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Op != 0 {
		i = encodeVarintCore(dAtA, i, uint64(m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *VectorMatching) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Include) > 0 {
		for iNdEx := len(m.Include) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Include[iNdEx])
			copy(dAtA[i:], m.Include[iNdEx])
			i = encodeVarintCore(dAtA, i, uint64(len(m.Include[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.On {
		i--
		if m.On {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.MatchingLabels) > 0 {
		for iNdEx := len(m.MatchingLabels) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.MatchingLabels[iNdEx])
			copy(dAtA[i:], m.MatchingLabels[iNdEx])
			i = encodeVarintCore(dAtA, i, uint64(len(m.MatchingLabels[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Card != 0 {
		i = encodeVarintCore(dAtA, i, uint64(m.Card))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *FunctionCallDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.AbsentLabels) > 0 {
		for iNdEx := len(m.AbsentLabels) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.AbsentLabels[iNdEx].Size()
				i -= size
				if _, err := m.AbsentLabels[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintCore(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Function != 0 {
		i = encodeVarintCore(dAtA, i, uint64(m.Function))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *NumberLiteralDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Value != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Value))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

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

func (m *StringLiteralDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintCore(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UnaryExpressionDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Op != 0 {
		i = encodeVarintCore(dAtA, i, uint64(m.Op))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *VectorSelectorDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SkipHistogramBuckets {
		i--
		if m.SkipHistogramBuckets {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.ReturnSampleTimestamps {
		i--
		if m.ReturnSampleTimestamps {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Offset, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Offset):])
	if err10 != nil {
		return 0, err10
	}
	i -= n10
	i = encodeVarintCore(dAtA, i, uint64(n10))
	i--
	dAtA[i] = 0x1a
	if m.Timestamp != nil {
		n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp):])
		if err11 != nil {
			return 0, err11
		}
		i -= n11
		i = encodeVarintCore(dAtA, i, uint64(n11))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Matchers) > 0 {
		for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCore(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *MatrixSelectorDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SkipHistogramBuckets {
		i--
		if m.SkipHistogramBuckets {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	n13, err13 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Range, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Range):])
	if err13 != nil {
		return 0, err13
	}
	i -= n13
	i = encodeVarintCore(dAtA, i, uint64(n13))
	i--
	dAtA[i] = 0x22
	n14, err14 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Offset, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Offset):])
	if err14 != nil {
		return 0, err14
	}
	i -= n14
	i = encodeVarintCore(dAtA, i, uint64(n14))
	i--
	dAtA[i] = 0x1a
	if m.Timestamp != nil {
		n15, err15 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp):])
		if err15 != nil {
			return 0, err15
		}
		i -= n15
		i = encodeVarintCore(dAtA, i, uint64(n15))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Matchers) > 0 {
		for iNdEx := len(m.Matchers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Matchers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCore(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SubqueryDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ExpressionPosition.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintCore(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	n17, err17 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Step, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Step):])
	if err17 != nil {
		return 0, err17
	}
	i -= n17
	i = encodeVarintCore(dAtA, i, uint64(n17))
	i--
	dAtA[i] = 0x22
	n18, err18 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Range, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Range):])
	if err18 != nil {
		return 0, err18
	}
	i -= n18
	i = encodeVarintCore(dAtA, i, uint64(n18))
	i--
	dAtA[i] = 0x1a
	n19, err19 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Offset, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Offset):])
	if err19 != nil {
		return 0, err19
	}
	i -= n19
	i = encodeVarintCore(dAtA, i, uint64(n19))
	i--
	dAtA[i] = 0x12
	if m.Timestamp != nil {
		n20, err20 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp):])
		if err20 != nil {
			return 0, err20
		}
		i -= n20
		i = encodeVarintCore(dAtA, i, uint64(n20))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StepInvariantExpressionDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *LabelMatcher) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintCore(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCore(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintCore(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *DeduplicateAndMergeDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *DropNameDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func encodeVarintCore(dAtA []byte, offset int, v uint64) int {
	offset -= sovCore(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *PositionRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start != 0 {
		n += 1 + sovCore(uint64(m.Start))
	}
	if m.End != 0 {
		n += 1 + sovCore(uint64(m.End))
	}
	return n
}

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

func (m *AggregateExpressionDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovCore(uint64(m.Op))
	}
	if len(m.Grouping) > 0 {
		for _, s := range m.Grouping {
			l = len(s)
			n += 1 + l + sovCore(uint64(l))
		}
	}
	if m.Without {
		n += 2
	}
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	return n
}

func (m *BinaryExpressionDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovCore(uint64(m.Op))
	}
	if m.VectorMatching != nil {
		l = m.VectorMatching.Size()
		n += 1 + l + sovCore(uint64(l))
	}
	if m.ReturnBool {
		n += 2
	}
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	if m.Hints != nil {
		l = m.Hints.Size()
		n += 1 + l + sovCore(uint64(l))
	}
	return n
}

func (m *VectorMatching) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Card != 0 {
		n += 1 + sovCore(uint64(m.Card))
	}
	if len(m.MatchingLabels) > 0 {
		for _, s := range m.MatchingLabels {
			l = len(s)
			n += 1 + l + sovCore(uint64(l))
		}
	}
	if m.On {
		n += 2
	}
	if len(m.Include) > 0 {
		for _, s := range m.Include {
			l = len(s)
			n += 1 + l + sovCore(uint64(l))
		}
	}
	return n
}

func (m *FunctionCallDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Function != 0 {
		n += 1 + sovCore(uint64(m.Function))
	}
	if len(m.AbsentLabels) > 0 {
		for _, e := range m.AbsentLabels {
			l = e.Size()
			n += 1 + l + sovCore(uint64(l))
		}
	}
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	return n
}

func (m *NumberLiteralDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Value != 0 {
		n += 9
	}
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	return n
}

func (m *StringLiteralDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovCore(uint64(l))
	}
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	return n
}

func (m *UnaryExpressionDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != 0 {
		n += 1 + sovCore(uint64(m.Op))
	}
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	return n
}

func (m *VectorSelectorDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Matchers) > 0 {
		for _, e := range m.Matchers {
			l = e.Size()
			n += 1 + l + sovCore(uint64(l))
		}
	}
	if m.Timestamp != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp)
		n += 1 + l + sovCore(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Offset)
	n += 1 + l + sovCore(uint64(l))
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	if m.ReturnSampleTimestamps {
		n += 2
	}
	if m.SkipHistogramBuckets {
		n += 2
	}
	return n
}

func (m *MatrixSelectorDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Matchers) > 0 {
		for _, e := range m.Matchers {
			l = e.Size()
			n += 1 + l + sovCore(uint64(l))
		}
	}
	if m.Timestamp != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp)
		n += 1 + l + sovCore(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Offset)
	n += 1 + l + sovCore(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Range)
	n += 1 + l + sovCore(uint64(l))
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	if m.SkipHistogramBuckets {
		n += 2
	}
	return n
}

func (m *SubqueryDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Timestamp != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Timestamp)
		n += 1 + l + sovCore(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Offset)
	n += 1 + l + sovCore(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Range)
	n += 1 + l + sovCore(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Step)
	n += 1 + l + sovCore(uint64(l))
	l = m.ExpressionPosition.Size()
	n += 1 + l + sovCore(uint64(l))
	return n
}

func (m *StepInvariantExpressionDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *LabelMatcher) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovCore(uint64(m.Type))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCore(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovCore(uint64(l))
	}
	return n
}

func (m *DeduplicateAndMergeDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *DropNameDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func sovCore(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCore(x uint64) (n int) {
	return sovCore(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *PositionRange) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PositionRange{`,
		`Start:` + fmt.Sprintf("%v", this.Start) + `,`,
		`End:` + fmt.Sprintf("%v", this.End) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BinaryExpressionHints) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BinaryExpressionHints{`,
		`Include:` + fmt.Sprintf("%v", this.Include) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AggregateExpressionDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AggregateExpressionDetails{`,
		`Op:` + fmt.Sprintf("%v", this.Op) + `,`,
		`Grouping:` + fmt.Sprintf("%v", this.Grouping) + `,`,
		`Without:` + fmt.Sprintf("%v", this.Without) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *BinaryExpressionDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BinaryExpressionDetails{`,
		`Op:` + fmt.Sprintf("%v", this.Op) + `,`,
		`VectorMatching:` + strings.Replace(this.VectorMatching.String(), "VectorMatching", "VectorMatching", 1) + `,`,
		`ReturnBool:` + fmt.Sprintf("%v", this.ReturnBool) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`Hints:` + strings.Replace(this.Hints.String(), "BinaryExpressionHints", "BinaryExpressionHints", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VectorMatching) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&VectorMatching{`,
		`Card:` + fmt.Sprintf("%v", this.Card) + `,`,
		`MatchingLabels:` + fmt.Sprintf("%v", this.MatchingLabels) + `,`,
		`On:` + fmt.Sprintf("%v", this.On) + `,`,
		`Include:` + fmt.Sprintf("%v", this.Include) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FunctionCallDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FunctionCallDetails{`,
		`Function:` + fmt.Sprintf("%v", this.Function) + `,`,
		`AbsentLabels:` + fmt.Sprintf("%v", this.AbsentLabels) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NumberLiteralDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NumberLiteralDetails{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StringLiteralDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StringLiteralDetails{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UnaryExpressionDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UnaryExpressionDetails{`,
		`Op:` + fmt.Sprintf("%v", this.Op) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *VectorSelectorDetails) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMatchers := "[]*LabelMatcher{"
	for _, f := range this.Matchers {
		repeatedStringForMatchers += strings.Replace(f.String(), "LabelMatcher", "LabelMatcher", 1) + ","
	}
	repeatedStringForMatchers += "}"
	s := strings.Join([]string{`&VectorSelectorDetails{`,
		`Matchers:` + repeatedStringForMatchers + `,`,
		`Timestamp:` + strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "timestamppb.Timestamp", 1) + `,`,
		`Offset:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Offset), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`ReturnSampleTimestamps:` + fmt.Sprintf("%v", this.ReturnSampleTimestamps) + `,`,
		`SkipHistogramBuckets:` + fmt.Sprintf("%v", this.SkipHistogramBuckets) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MatrixSelectorDetails) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMatchers := "[]*LabelMatcher{"
	for _, f := range this.Matchers {
		repeatedStringForMatchers += strings.Replace(f.String(), "LabelMatcher", "LabelMatcher", 1) + ","
	}
	repeatedStringForMatchers += "}"
	s := strings.Join([]string{`&MatrixSelectorDetails{`,
		`Matchers:` + repeatedStringForMatchers + `,`,
		`Timestamp:` + strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "timestamppb.Timestamp", 1) + `,`,
		`Offset:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Offset), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
		`Range:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Range), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`SkipHistogramBuckets:` + fmt.Sprintf("%v", this.SkipHistogramBuckets) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SubqueryDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SubqueryDetails{`,
		`Timestamp:` + strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "timestamppb.Timestamp", 1) + `,`,
		`Offset:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Offset), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
		`Range:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Range), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
		`Step:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Step), "Duration", "durationpb.Duration", 1), `&`, ``, 1) + `,`,
		`ExpressionPosition:` + strings.Replace(strings.Replace(this.ExpressionPosition.String(), "PositionRange", "PositionRange", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StepInvariantExpressionDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StepInvariantExpressionDetails{`,
		`}`,
	}, "")
	return s
}
func (this *LabelMatcher) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LabelMatcher{`,
		`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeduplicateAndMergeDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeduplicateAndMergeDetails{`,
		`}`,
	}, "")
	return s
}
func (this *DropNameDetails) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DropNameDetails{`,
		`}`,
	}, "")
	return s
}
func valueToStringCore(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *PositionRange) 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 ErrIntOverflowCore
			}
			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: PositionRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PositionRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			m.Start = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Start |= github_com_prometheus_prometheus_promql_parser_posrange.Pos(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			m.End = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.End |= github_com_prometheus_prometheus_promql_parser_posrange.Pos(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AggregateExpressionDetails) 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 ErrIntOverflowCore
			}
			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: AggregateExpressionDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AggregateExpressionDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= AggregationOperation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Grouping", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				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 ErrInvalidLengthCore
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Grouping = append(m.Grouping, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Without", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Without = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BinaryExpressionDetails) 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 ErrIntOverflowCore
			}
			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: BinaryExpressionDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BinaryExpressionDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= BinaryOperation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VectorMatching", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VectorMatching == nil {
				m.VectorMatching = &VectorMatching{}
			}
			if err := m.VectorMatching.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReturnBool", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReturnBool = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Hints == nil {
				m.Hints = &BinaryExpressionHints{}
			}
			if err := m.Hints.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VectorMatching) 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 ErrIntOverflowCore
			}
			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: VectorMatching: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VectorMatching: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Card", wireType)
			}
			m.Card = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Card |= github_com_prometheus_prometheus_promql_parser.VectorMatchCardinality(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchingLabels", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				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 ErrInvalidLengthCore
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MatchingLabels = append(m.MatchingLabels, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field On", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.On = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Include", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				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 ErrInvalidLengthCore
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Include = append(m.Include, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FunctionCallDetails) 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 ErrIntOverflowCore
			}
			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: FunctionCallDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FunctionCallDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Function", wireType)
			}
			m.Function = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Function |= functions.Function(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AbsentLabels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AbsentLabels = append(m.AbsentLabels, github_com_grafana_mimir_pkg_mimirpb.LabelAdapter{})
			if err := m.AbsentLabels[len(m.AbsentLabels)-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 ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NumberLiteralDetails) 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 ErrIntOverflowCore
			}
			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: NumberLiteralDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NumberLiteralDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Value = float64(math.Float64frombits(v))
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UnaryExpressionDetails) 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 ErrIntOverflowCore
			}
			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: UnaryExpressionDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnaryExpressionDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			m.Op = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Op |= UnaryOperation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VectorSelectorDetails) 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 ErrIntOverflowCore
			}
			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: VectorSelectorDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VectorSelectorDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Matchers = append(m.Matchers, &LabelMatcher{})
			if err := m.Matchers[len(m.Matchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Offset, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReturnSampleTimestamps", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReturnSampleTimestamps = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipHistogramBuckets", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipHistogramBuckets = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MatrixSelectorDetails) 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 ErrIntOverflowCore
			}
			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: MatrixSelectorDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MatrixSelectorDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Matchers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Matchers = append(m.Matchers, &LabelMatcher{})
			if err := m.Matchers[len(m.Matchers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Offset, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Range, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipHistogramBuckets", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SkipHistogramBuckets = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SubqueryDetails) 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 ErrIntOverflowCore
			}
			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: SubqueryDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubqueryDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Offset, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Range, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Step, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpressionPosition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCore
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCore
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCore
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExpressionPosition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StepInvariantExpressionDetails) 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 ErrIntOverflowCore
			}
			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: StepInvariantExpressionDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StepInvariantExpressionDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeduplicateAndMergeDetails) 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 ErrIntOverflowCore
			}
			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: DeduplicateAndMergeDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeduplicateAndMergeDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DropNameDetails) 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 ErrIntOverflowCore
			}
			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: DropNameDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DropNameDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCore(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCore
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthCore        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCore          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCore = fmt.Errorf("proto: unexpected end of group")
)
