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

package planpb

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	schemapb "github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
	math "math"
)

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

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

type OpType int32

const (
	OpType_Invalid      OpType = 0
	OpType_GreaterThan  OpType = 1
	OpType_GreaterEqual OpType = 2
	OpType_LessThan     OpType = 3
	OpType_LessEqual    OpType = 4
	OpType_Equal        OpType = 5
	OpType_NotEqual     OpType = 6
	OpType_PrefixMatch  OpType = 7
	OpType_PostfixMatch OpType = 8
	OpType_Match        OpType = 9
	OpType_Range        OpType = 10
	OpType_In           OpType = 11
	OpType_NotIn        OpType = 12
)

var OpType_name = map[int32]string{
	0:  "Invalid",
	1:  "GreaterThan",
	2:  "GreaterEqual",
	3:  "LessThan",
	4:  "LessEqual",
	5:  "Equal",
	6:  "NotEqual",
	7:  "PrefixMatch",
	8:  "PostfixMatch",
	9:  "Match",
	10: "Range",
	11: "In",
	12: "NotIn",
}

var OpType_value = map[string]int32{
	"Invalid":      0,
	"GreaterThan":  1,
	"GreaterEqual": 2,
	"LessThan":     3,
	"LessEqual":    4,
	"Equal":        5,
	"NotEqual":     6,
	"PrefixMatch":  7,
	"PostfixMatch": 8,
	"Match":        9,
	"Range":        10,
	"In":           11,
	"NotIn":        12,
}

func (x OpType) String() string {
	return proto.EnumName(OpType_name, int32(x))
}

func (OpType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{0}
}

type ArithOpType int32

const (
	ArithOpType_Unknown ArithOpType = 0
	ArithOpType_Add     ArithOpType = 1
	ArithOpType_Sub     ArithOpType = 2
	ArithOpType_Mul     ArithOpType = 3
	ArithOpType_Div     ArithOpType = 4
	ArithOpType_Mod     ArithOpType = 5
)

var ArithOpType_name = map[int32]string{
	0: "Unknown",
	1: "Add",
	2: "Sub",
	3: "Mul",
	4: "Div",
	5: "Mod",
}

var ArithOpType_value = map[string]int32{
	"Unknown": 0,
	"Add":     1,
	"Sub":     2,
	"Mul":     3,
	"Div":     4,
	"Mod":     5,
}

func (x ArithOpType) String() string {
	return proto.EnumName(ArithOpType_name, int32(x))
}

func (ArithOpType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{1}
}

// 0: invalid
// 1: json_contains
// 2: json_contains_all
// 3: json_contains_any
type JSONContainsExpr_JSONOp int32

const (
	JSONContainsExpr_Invalid     JSONContainsExpr_JSONOp = 0
	JSONContainsExpr_Contains    JSONContainsExpr_JSONOp = 1
	JSONContainsExpr_ContainsAll JSONContainsExpr_JSONOp = 2
	JSONContainsExpr_ContainsAny JSONContainsExpr_JSONOp = 3
)

var JSONContainsExpr_JSONOp_name = map[int32]string{
	0: "Invalid",
	1: "Contains",
	2: "ContainsAll",
	3: "ContainsAny",
}

var JSONContainsExpr_JSONOp_value = map[string]int32{
	"Invalid":     0,
	"Contains":    1,
	"ContainsAll": 2,
	"ContainsAny": 3,
}

func (x JSONContainsExpr_JSONOp) String() string {
	return proto.EnumName(JSONContainsExpr_JSONOp_name, int32(x))
}

func (JSONContainsExpr_JSONOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{11, 0}
}

type UnaryExpr_UnaryOp int32

const (
	UnaryExpr_Invalid UnaryExpr_UnaryOp = 0
	UnaryExpr_Not     UnaryExpr_UnaryOp = 1
)

var UnaryExpr_UnaryOp_name = map[int32]string{
	0: "Invalid",
	1: "Not",
}

var UnaryExpr_UnaryOp_value = map[string]int32{
	"Invalid": 0,
	"Not":     1,
}

func (x UnaryExpr_UnaryOp) String() string {
	return proto.EnumName(UnaryExpr_UnaryOp_name, int32(x))
}

func (UnaryExpr_UnaryOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{12, 0}
}

type BinaryExpr_BinaryOp int32

const (
	BinaryExpr_Invalid    BinaryExpr_BinaryOp = 0
	BinaryExpr_LogicalAnd BinaryExpr_BinaryOp = 1
	BinaryExpr_LogicalOr  BinaryExpr_BinaryOp = 2
)

var BinaryExpr_BinaryOp_name = map[int32]string{
	0: "Invalid",
	1: "LogicalAnd",
	2: "LogicalOr",
}

var BinaryExpr_BinaryOp_value = map[string]int32{
	"Invalid":    0,
	"LogicalAnd": 1,
	"LogicalOr":  2,
}

func (x BinaryExpr_BinaryOp) String() string {
	return proto.EnumName(BinaryExpr_BinaryOp_name, int32(x))
}

func (BinaryExpr_BinaryOp) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{13, 0}
}

type GenericValue struct {
	// Types that are valid to be assigned to Val:
	//	*GenericValue_BoolVal
	//	*GenericValue_Int64Val
	//	*GenericValue_FloatVal
	//	*GenericValue_StringVal
	//	*GenericValue_ArrayVal
	Val                  isGenericValue_Val `protobuf_oneof:"val"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_GenericValue proto.InternalMessageInfo

type isGenericValue_Val interface {
	isGenericValue_Val()
}

type GenericValue_BoolVal struct {
	BoolVal bool `protobuf:"varint,1,opt,name=bool_val,json=boolVal,proto3,oneof"`
}

type GenericValue_Int64Val struct {
	Int64Val int64 `protobuf:"varint,2,opt,name=int64_val,json=int64Val,proto3,oneof"`
}

type GenericValue_FloatVal struct {
	FloatVal float64 `protobuf:"fixed64,3,opt,name=float_val,json=floatVal,proto3,oneof"`
}

type GenericValue_StringVal struct {
	StringVal string `protobuf:"bytes,4,opt,name=string_val,json=stringVal,proto3,oneof"`
}

type GenericValue_ArrayVal struct {
	ArrayVal *Array `protobuf:"bytes,5,opt,name=array_val,json=arrayVal,proto3,oneof"`
}

func (*GenericValue_BoolVal) isGenericValue_Val() {}

func (*GenericValue_Int64Val) isGenericValue_Val() {}

func (*GenericValue_FloatVal) isGenericValue_Val() {}

func (*GenericValue_StringVal) isGenericValue_Val() {}

func (*GenericValue_ArrayVal) isGenericValue_Val() {}

func (m *GenericValue) GetVal() isGenericValue_Val {
	if m != nil {
		return m.Val
	}
	return nil
}

func (m *GenericValue) GetBoolVal() bool {
	if x, ok := m.GetVal().(*GenericValue_BoolVal); ok {
		return x.BoolVal
	}
	return false
}

func (m *GenericValue) GetInt64Val() int64 {
	if x, ok := m.GetVal().(*GenericValue_Int64Val); ok {
		return x.Int64Val
	}
	return 0
}

func (m *GenericValue) GetFloatVal() float64 {
	if x, ok := m.GetVal().(*GenericValue_FloatVal); ok {
		return x.FloatVal
	}
	return 0
}

func (m *GenericValue) GetStringVal() string {
	if x, ok := m.GetVal().(*GenericValue_StringVal); ok {
		return x.StringVal
	}
	return ""
}

func (m *GenericValue) GetArrayVal() *Array {
	if x, ok := m.GetVal().(*GenericValue_ArrayVal); ok {
		return x.ArrayVal
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*GenericValue) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*GenericValue_BoolVal)(nil),
		(*GenericValue_Int64Val)(nil),
		(*GenericValue_FloatVal)(nil),
		(*GenericValue_StringVal)(nil),
		(*GenericValue_ArrayVal)(nil),
	}
}

type Array struct {
	Array                []*GenericValue `protobuf:"bytes,1,rep,name=array,proto3" json:"array,omitempty"`
	SameType             bool            `protobuf:"varint,2,opt,name=same_type,json=sameType,proto3" json:"same_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_Array proto.InternalMessageInfo

func (m *Array) GetArray() []*GenericValue {
	if m != nil {
		return m.Array
	}
	return nil
}

func (m *Array) GetSameType() bool {
	if m != nil {
		return m.SameType
	}
	return false
}

type QueryInfo struct {
	Topk                 int64    `protobuf:"varint,1,opt,name=topk,proto3" json:"topk,omitempty"`
	MetricType           string   `protobuf:"bytes,3,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"`
	SearchParams         string   `protobuf:"bytes,4,opt,name=search_params,json=searchParams,proto3" json:"search_params,omitempty"`
	RoundDecimal         int64    `protobuf:"varint,5,opt,name=round_decimal,json=roundDecimal,proto3" json:"round_decimal,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_QueryInfo proto.InternalMessageInfo

func (m *QueryInfo) GetTopk() int64 {
	if m != nil {
		return m.Topk
	}
	return 0
}

func (m *QueryInfo) GetMetricType() string {
	if m != nil {
		return m.MetricType
	}
	return ""
}

func (m *QueryInfo) GetSearchParams() string {
	if m != nil {
		return m.SearchParams
	}
	return ""
}

func (m *QueryInfo) GetRoundDecimal() int64 {
	if m != nil {
		return m.RoundDecimal
	}
	return 0
}

type ColumnInfo struct {
	FieldId              int64             `protobuf:"varint,1,opt,name=field_id,json=fieldId,proto3" json:"field_id,omitempty"`
	DataType             schemapb.DataType `protobuf:"varint,2,opt,name=data_type,json=dataType,proto3,enum=milvus.proto.schema.DataType" json:"data_type,omitempty"`
	IsPrimaryKey         bool              `protobuf:"varint,3,opt,name=is_primary_key,json=isPrimaryKey,proto3" json:"is_primary_key,omitempty"`
	IsAutoID             bool              `protobuf:"varint,4,opt,name=is_autoID,json=isAutoID,proto3" json:"is_autoID,omitempty"`
	NestedPath           []string          `protobuf:"bytes,5,rep,name=nested_path,json=nestedPath,proto3" json:"nested_path,omitempty"`
	IsPartitionKey       bool              `protobuf:"varint,6,opt,name=is_partition_key,json=isPartitionKey,proto3" json:"is_partition_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_ColumnInfo proto.InternalMessageInfo

func (m *ColumnInfo) GetFieldId() int64 {
	if m != nil {
		return m.FieldId
	}
	return 0
}

func (m *ColumnInfo) GetDataType() schemapb.DataType {
	if m != nil {
		return m.DataType
	}
	return schemapb.DataType_None
}

func (m *ColumnInfo) GetIsPrimaryKey() bool {
	if m != nil {
		return m.IsPrimaryKey
	}
	return false
}

func (m *ColumnInfo) GetIsAutoID() bool {
	if m != nil {
		return m.IsAutoID
	}
	return false
}

func (m *ColumnInfo) GetNestedPath() []string {
	if m != nil {
		return m.NestedPath
	}
	return nil
}

func (m *ColumnInfo) GetIsPartitionKey() bool {
	if m != nil {
		return m.IsPartitionKey
	}
	return false
}

type ColumnExpr struct {
	Info                 *ColumnInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_ColumnExpr proto.InternalMessageInfo

func (m *ColumnExpr) GetInfo() *ColumnInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

type ExistsExpr struct {
	Info                 *ColumnInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_ExistsExpr proto.InternalMessageInfo

func (m *ExistsExpr) GetInfo() *ColumnInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

type ValueExpr struct {
	Value                *GenericValue `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_ValueExpr proto.InternalMessageInfo

func (m *ValueExpr) GetValue() *GenericValue {
	if m != nil {
		return m.Value
	}
	return nil
}

type UnaryRangeExpr struct {
	ColumnInfo           *ColumnInfo   `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"`
	Op                   OpType        `protobuf:"varint,2,opt,name=op,proto3,enum=milvus.proto.plan.OpType" json:"op,omitempty"`
	Value                *GenericValue `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_UnaryRangeExpr proto.InternalMessageInfo

func (m *UnaryRangeExpr) GetColumnInfo() *ColumnInfo {
	if m != nil {
		return m.ColumnInfo
	}
	return nil
}

func (m *UnaryRangeExpr) GetOp() OpType {
	if m != nil {
		return m.Op
	}
	return OpType_Invalid
}

func (m *UnaryRangeExpr) GetValue() *GenericValue {
	if m != nil {
		return m.Value
	}
	return nil
}

type BinaryRangeExpr struct {
	ColumnInfo           *ColumnInfo   `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"`
	LowerInclusive       bool          `protobuf:"varint,2,opt,name=lower_inclusive,json=lowerInclusive,proto3" json:"lower_inclusive,omitempty"`
	UpperInclusive       bool          `protobuf:"varint,3,opt,name=upper_inclusive,json=upperInclusive,proto3" json:"upper_inclusive,omitempty"`
	LowerValue           *GenericValue `protobuf:"bytes,4,opt,name=lower_value,json=lowerValue,proto3" json:"lower_value,omitempty"`
	UpperValue           *GenericValue `protobuf:"bytes,5,opt,name=upper_value,json=upperValue,proto3" json:"upper_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_BinaryRangeExpr proto.InternalMessageInfo

func (m *BinaryRangeExpr) GetColumnInfo() *ColumnInfo {
	if m != nil {
		return m.ColumnInfo
	}
	return nil
}

func (m *BinaryRangeExpr) GetLowerInclusive() bool {
	if m != nil {
		return m.LowerInclusive
	}
	return false
}

func (m *BinaryRangeExpr) GetUpperInclusive() bool {
	if m != nil {
		return m.UpperInclusive
	}
	return false
}

func (m *BinaryRangeExpr) GetLowerValue() *GenericValue {
	if m != nil {
		return m.LowerValue
	}
	return nil
}

func (m *BinaryRangeExpr) GetUpperValue() *GenericValue {
	if m != nil {
		return m.UpperValue
	}
	return nil
}

type CompareExpr struct {
	LeftColumnInfo       *ColumnInfo `protobuf:"bytes,1,opt,name=left_column_info,json=leftColumnInfo,proto3" json:"left_column_info,omitempty"`
	RightColumnInfo      *ColumnInfo `protobuf:"bytes,2,opt,name=right_column_info,json=rightColumnInfo,proto3" json:"right_column_info,omitempty"`
	Op                   OpType      `protobuf:"varint,3,opt,name=op,proto3,enum=milvus.proto.plan.OpType" json:"op,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_CompareExpr proto.InternalMessageInfo

func (m *CompareExpr) GetLeftColumnInfo() *ColumnInfo {
	if m != nil {
		return m.LeftColumnInfo
	}
	return nil
}

func (m *CompareExpr) GetRightColumnInfo() *ColumnInfo {
	if m != nil {
		return m.RightColumnInfo
	}
	return nil
}

func (m *CompareExpr) GetOp() OpType {
	if m != nil {
		return m.Op
	}
	return OpType_Invalid
}

type TermExpr struct {
	ColumnInfo           *ColumnInfo     `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"`
	Values               []*GenericValue `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
	IsInField            bool            `protobuf:"varint,3,opt,name=is_in_field,json=isInField,proto3" json:"is_in_field,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_TermExpr proto.InternalMessageInfo

func (m *TermExpr) GetColumnInfo() *ColumnInfo {
	if m != nil {
		return m.ColumnInfo
	}
	return nil
}

func (m *TermExpr) GetValues() []*GenericValue {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *TermExpr) GetIsInField() bool {
	if m != nil {
		return m.IsInField
	}
	return false
}

type JSONContainsExpr struct {
	ColumnInfo           *ColumnInfo             `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"`
	Elements             []*GenericValue         `protobuf:"bytes,2,rep,name=elements,proto3" json:"elements,omitempty"`
	Op                   JSONContainsExpr_JSONOp `protobuf:"varint,3,opt,name=op,proto3,enum=milvus.proto.plan.JSONContainsExpr_JSONOp" json:"op,omitempty"`
	ElementsSameType     bool                    `protobuf:"varint,4,opt,name=elements_same_type,json=elementsSameType,proto3" json:"elements_same_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

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

var xxx_messageInfo_JSONContainsExpr proto.InternalMessageInfo

func (m *JSONContainsExpr) GetColumnInfo() *ColumnInfo {
	if m != nil {
		return m.ColumnInfo
	}
	return nil
}

func (m *JSONContainsExpr) GetElements() []*GenericValue {
	if m != nil {
		return m.Elements
	}
	return nil
}

func (m *JSONContainsExpr) GetOp() JSONContainsExpr_JSONOp {
	if m != nil {
		return m.Op
	}
	return JSONContainsExpr_Invalid
}

func (m *JSONContainsExpr) GetElementsSameType() bool {
	if m != nil {
		return m.ElementsSameType
	}
	return false
}

type UnaryExpr struct {
	Op                   UnaryExpr_UnaryOp `protobuf:"varint,1,opt,name=op,proto3,enum=milvus.proto.plan.UnaryExpr_UnaryOp" json:"op,omitempty"`
	Child                *Expr             `protobuf:"bytes,2,opt,name=child,proto3" json:"child,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_UnaryExpr proto.InternalMessageInfo

func (m *UnaryExpr) GetOp() UnaryExpr_UnaryOp {
	if m != nil {
		return m.Op
	}
	return UnaryExpr_Invalid
}

func (m *UnaryExpr) GetChild() *Expr {
	if m != nil {
		return m.Child
	}
	return nil
}

type BinaryExpr struct {
	Op                   BinaryExpr_BinaryOp `protobuf:"varint,1,opt,name=op,proto3,enum=milvus.proto.plan.BinaryExpr_BinaryOp" json:"op,omitempty"`
	Left                 *Expr               `protobuf:"bytes,2,opt,name=left,proto3" json:"left,omitempty"`
	Right                *Expr               `protobuf:"bytes,3,opt,name=right,proto3" json:"right,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_BinaryExpr proto.InternalMessageInfo

func (m *BinaryExpr) GetOp() BinaryExpr_BinaryOp {
	if m != nil {
		return m.Op
	}
	return BinaryExpr_Invalid
}

func (m *BinaryExpr) GetLeft() *Expr {
	if m != nil {
		return m.Left
	}
	return nil
}

func (m *BinaryExpr) GetRight() *Expr {
	if m != nil {
		return m.Right
	}
	return nil
}

type BinaryArithOp struct {
	ColumnInfo           *ColumnInfo   `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"`
	ArithOp              ArithOpType   `protobuf:"varint,2,opt,name=arith_op,json=arithOp,proto3,enum=milvus.proto.plan.ArithOpType" json:"arith_op,omitempty"`
	RightOperand         *GenericValue `protobuf:"bytes,3,opt,name=right_operand,json=rightOperand,proto3" json:"right_operand,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_BinaryArithOp proto.InternalMessageInfo

func (m *BinaryArithOp) GetColumnInfo() *ColumnInfo {
	if m != nil {
		return m.ColumnInfo
	}
	return nil
}

func (m *BinaryArithOp) GetArithOp() ArithOpType {
	if m != nil {
		return m.ArithOp
	}
	return ArithOpType_Unknown
}

func (m *BinaryArithOp) GetRightOperand() *GenericValue {
	if m != nil {
		return m.RightOperand
	}
	return nil
}

type BinaryArithExpr struct {
	Left                 *Expr       `protobuf:"bytes,1,opt,name=left,proto3" json:"left,omitempty"`
	Right                *Expr       `protobuf:"bytes,2,opt,name=right,proto3" json:"right,omitempty"`
	Op                   ArithOpType `protobuf:"varint,3,opt,name=op,proto3,enum=milvus.proto.plan.ArithOpType" json:"op,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_BinaryArithExpr proto.InternalMessageInfo

func (m *BinaryArithExpr) GetLeft() *Expr {
	if m != nil {
		return m.Left
	}
	return nil
}

func (m *BinaryArithExpr) GetRight() *Expr {
	if m != nil {
		return m.Right
	}
	return nil
}

func (m *BinaryArithExpr) GetOp() ArithOpType {
	if m != nil {
		return m.Op
	}
	return ArithOpType_Unknown
}

type BinaryArithOpEvalRangeExpr struct {
	ColumnInfo           *ColumnInfo   `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"`
	ArithOp              ArithOpType   `protobuf:"varint,2,opt,name=arith_op,json=arithOp,proto3,enum=milvus.proto.plan.ArithOpType" json:"arith_op,omitempty"`
	RightOperand         *GenericValue `protobuf:"bytes,3,opt,name=right_operand,json=rightOperand,proto3" json:"right_operand,omitempty"`
	Op                   OpType        `protobuf:"varint,4,opt,name=op,proto3,enum=milvus.proto.plan.OpType" json:"op,omitempty"`
	Value                *GenericValue `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_BinaryArithOpEvalRangeExpr proto.InternalMessageInfo

func (m *BinaryArithOpEvalRangeExpr) GetColumnInfo() *ColumnInfo {
	if m != nil {
		return m.ColumnInfo
	}
	return nil
}

func (m *BinaryArithOpEvalRangeExpr) GetArithOp() ArithOpType {
	if m != nil {
		return m.ArithOp
	}
	return ArithOpType_Unknown
}

func (m *BinaryArithOpEvalRangeExpr) GetRightOperand() *GenericValue {
	if m != nil {
		return m.RightOperand
	}
	return nil
}

func (m *BinaryArithOpEvalRangeExpr) GetOp() OpType {
	if m != nil {
		return m.Op
	}
	return OpType_Invalid
}

func (m *BinaryArithOpEvalRangeExpr) GetValue() *GenericValue {
	if m != nil {
		return m.Value
	}
	return nil
}

type AlwaysTrueExpr struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_AlwaysTrueExpr proto.InternalMessageInfo

type Expr struct {
	// Types that are valid to be assigned to Expr:
	//	*Expr_TermExpr
	//	*Expr_UnaryExpr
	//	*Expr_BinaryExpr
	//	*Expr_CompareExpr
	//	*Expr_UnaryRangeExpr
	//	*Expr_BinaryRangeExpr
	//	*Expr_BinaryArithOpEvalRangeExpr
	//	*Expr_BinaryArithExpr
	//	*Expr_ValueExpr
	//	*Expr_ColumnExpr
	//	*Expr_ExistsExpr
	//	*Expr_AlwaysTrueExpr
	//	*Expr_JsonContainsExpr
	Expr                 isExpr_Expr `protobuf_oneof:"expr"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *Expr) Reset()         { *m = Expr{} }
func (m *Expr) String() string { return proto.CompactTextString(m) }
func (*Expr) ProtoMessage()    {}
func (*Expr) Descriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{18}
}

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

var xxx_messageInfo_Expr proto.InternalMessageInfo

type isExpr_Expr interface {
	isExpr_Expr()
}

type Expr_TermExpr struct {
	TermExpr *TermExpr `protobuf:"bytes,1,opt,name=term_expr,json=termExpr,proto3,oneof"`
}

type Expr_UnaryExpr struct {
	UnaryExpr *UnaryExpr `protobuf:"bytes,2,opt,name=unary_expr,json=unaryExpr,proto3,oneof"`
}

type Expr_BinaryExpr struct {
	BinaryExpr *BinaryExpr `protobuf:"bytes,3,opt,name=binary_expr,json=binaryExpr,proto3,oneof"`
}

type Expr_CompareExpr struct {
	CompareExpr *CompareExpr `protobuf:"bytes,4,opt,name=compare_expr,json=compareExpr,proto3,oneof"`
}

type Expr_UnaryRangeExpr struct {
	UnaryRangeExpr *UnaryRangeExpr `protobuf:"bytes,5,opt,name=unary_range_expr,json=unaryRangeExpr,proto3,oneof"`
}

type Expr_BinaryRangeExpr struct {
	BinaryRangeExpr *BinaryRangeExpr `protobuf:"bytes,6,opt,name=binary_range_expr,json=binaryRangeExpr,proto3,oneof"`
}

type Expr_BinaryArithOpEvalRangeExpr struct {
	BinaryArithOpEvalRangeExpr *BinaryArithOpEvalRangeExpr `protobuf:"bytes,7,opt,name=binary_arith_op_eval_range_expr,json=binaryArithOpEvalRangeExpr,proto3,oneof"`
}

type Expr_BinaryArithExpr struct {
	BinaryArithExpr *BinaryArithExpr `protobuf:"bytes,8,opt,name=binary_arith_expr,json=binaryArithExpr,proto3,oneof"`
}

type Expr_ValueExpr struct {
	ValueExpr *ValueExpr `protobuf:"bytes,9,opt,name=value_expr,json=valueExpr,proto3,oneof"`
}

type Expr_ColumnExpr struct {
	ColumnExpr *ColumnExpr `protobuf:"bytes,10,opt,name=column_expr,json=columnExpr,proto3,oneof"`
}

type Expr_ExistsExpr struct {
	ExistsExpr *ExistsExpr `protobuf:"bytes,11,opt,name=exists_expr,json=existsExpr,proto3,oneof"`
}

type Expr_AlwaysTrueExpr struct {
	AlwaysTrueExpr *AlwaysTrueExpr `protobuf:"bytes,12,opt,name=always_true_expr,json=alwaysTrueExpr,proto3,oneof"`
}

type Expr_JsonContainsExpr struct {
	JsonContainsExpr *JSONContainsExpr `protobuf:"bytes,13,opt,name=json_contains_expr,json=jsonContainsExpr,proto3,oneof"`
}

func (*Expr_TermExpr) isExpr_Expr() {}

func (*Expr_UnaryExpr) isExpr_Expr() {}

func (*Expr_BinaryExpr) isExpr_Expr() {}

func (*Expr_CompareExpr) isExpr_Expr() {}

func (*Expr_UnaryRangeExpr) isExpr_Expr() {}

func (*Expr_BinaryRangeExpr) isExpr_Expr() {}

func (*Expr_BinaryArithOpEvalRangeExpr) isExpr_Expr() {}

func (*Expr_BinaryArithExpr) isExpr_Expr() {}

func (*Expr_ValueExpr) isExpr_Expr() {}

func (*Expr_ColumnExpr) isExpr_Expr() {}

func (*Expr_ExistsExpr) isExpr_Expr() {}

func (*Expr_AlwaysTrueExpr) isExpr_Expr() {}

func (*Expr_JsonContainsExpr) isExpr_Expr() {}

func (m *Expr) GetExpr() isExpr_Expr {
	if m != nil {
		return m.Expr
	}
	return nil
}

func (m *Expr) GetTermExpr() *TermExpr {
	if x, ok := m.GetExpr().(*Expr_TermExpr); ok {
		return x.TermExpr
	}
	return nil
}

func (m *Expr) GetUnaryExpr() *UnaryExpr {
	if x, ok := m.GetExpr().(*Expr_UnaryExpr); ok {
		return x.UnaryExpr
	}
	return nil
}

func (m *Expr) GetBinaryExpr() *BinaryExpr {
	if x, ok := m.GetExpr().(*Expr_BinaryExpr); ok {
		return x.BinaryExpr
	}
	return nil
}

func (m *Expr) GetCompareExpr() *CompareExpr {
	if x, ok := m.GetExpr().(*Expr_CompareExpr); ok {
		return x.CompareExpr
	}
	return nil
}

func (m *Expr) GetUnaryRangeExpr() *UnaryRangeExpr {
	if x, ok := m.GetExpr().(*Expr_UnaryRangeExpr); ok {
		return x.UnaryRangeExpr
	}
	return nil
}

func (m *Expr) GetBinaryRangeExpr() *BinaryRangeExpr {
	if x, ok := m.GetExpr().(*Expr_BinaryRangeExpr); ok {
		return x.BinaryRangeExpr
	}
	return nil
}

func (m *Expr) GetBinaryArithOpEvalRangeExpr() *BinaryArithOpEvalRangeExpr {
	if x, ok := m.GetExpr().(*Expr_BinaryArithOpEvalRangeExpr); ok {
		return x.BinaryArithOpEvalRangeExpr
	}
	return nil
}

func (m *Expr) GetBinaryArithExpr() *BinaryArithExpr {
	if x, ok := m.GetExpr().(*Expr_BinaryArithExpr); ok {
		return x.BinaryArithExpr
	}
	return nil
}

func (m *Expr) GetValueExpr() *ValueExpr {
	if x, ok := m.GetExpr().(*Expr_ValueExpr); ok {
		return x.ValueExpr
	}
	return nil
}

func (m *Expr) GetColumnExpr() *ColumnExpr {
	if x, ok := m.GetExpr().(*Expr_ColumnExpr); ok {
		return x.ColumnExpr
	}
	return nil
}

func (m *Expr) GetExistsExpr() *ExistsExpr {
	if x, ok := m.GetExpr().(*Expr_ExistsExpr); ok {
		return x.ExistsExpr
	}
	return nil
}

func (m *Expr) GetAlwaysTrueExpr() *AlwaysTrueExpr {
	if x, ok := m.GetExpr().(*Expr_AlwaysTrueExpr); ok {
		return x.AlwaysTrueExpr
	}
	return nil
}

func (m *Expr) GetJsonContainsExpr() *JSONContainsExpr {
	if x, ok := m.GetExpr().(*Expr_JsonContainsExpr); ok {
		return x.JsonContainsExpr
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Expr) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Expr_TermExpr)(nil),
		(*Expr_UnaryExpr)(nil),
		(*Expr_BinaryExpr)(nil),
		(*Expr_CompareExpr)(nil),
		(*Expr_UnaryRangeExpr)(nil),
		(*Expr_BinaryRangeExpr)(nil),
		(*Expr_BinaryArithOpEvalRangeExpr)(nil),
		(*Expr_BinaryArithExpr)(nil),
		(*Expr_ValueExpr)(nil),
		(*Expr_ColumnExpr)(nil),
		(*Expr_ExistsExpr)(nil),
		(*Expr_AlwaysTrueExpr)(nil),
		(*Expr_JsonContainsExpr)(nil),
	}
}

type VectorANNS struct {
	IsBinary             bool       `protobuf:"varint,1,opt,name=is_binary,json=isBinary,proto3" json:"is_binary,omitempty"`
	FieldId              int64      `protobuf:"varint,2,opt,name=field_id,json=fieldId,proto3" json:"field_id,omitempty"`
	Predicates           *Expr      `protobuf:"bytes,3,opt,name=predicates,proto3" json:"predicates,omitempty"`
	QueryInfo            *QueryInfo `protobuf:"bytes,4,opt,name=query_info,json=queryInfo,proto3" json:"query_info,omitempty"`
	PlaceholderTag       string     `protobuf:"bytes,5,opt,name=placeholder_tag,json=placeholderTag,proto3" json:"placeholder_tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *VectorANNS) Reset()         { *m = VectorANNS{} }
func (m *VectorANNS) String() string { return proto.CompactTextString(m) }
func (*VectorANNS) ProtoMessage()    {}
func (*VectorANNS) Descriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{19}
}

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

var xxx_messageInfo_VectorANNS proto.InternalMessageInfo

func (m *VectorANNS) GetIsBinary() bool {
	if m != nil {
		return m.IsBinary
	}
	return false
}

func (m *VectorANNS) GetFieldId() int64 {
	if m != nil {
		return m.FieldId
	}
	return 0
}

func (m *VectorANNS) GetPredicates() *Expr {
	if m != nil {
		return m.Predicates
	}
	return nil
}

func (m *VectorANNS) GetQueryInfo() *QueryInfo {
	if m != nil {
		return m.QueryInfo
	}
	return nil
}

func (m *VectorANNS) GetPlaceholderTag() string {
	if m != nil {
		return m.PlaceholderTag
	}
	return ""
}

type QueryPlanNode struct {
	Predicates           *Expr    `protobuf:"bytes,1,opt,name=predicates,proto3" json:"predicates,omitempty"`
	IsCount              bool     `protobuf:"varint,2,opt,name=is_count,json=isCount,proto3" json:"is_count,omitempty"`
	Limit                int64    `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *QueryPlanNode) Reset()         { *m = QueryPlanNode{} }
func (m *QueryPlanNode) String() string { return proto.CompactTextString(m) }
func (*QueryPlanNode) ProtoMessage()    {}
func (*QueryPlanNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{20}
}

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

var xxx_messageInfo_QueryPlanNode proto.InternalMessageInfo

func (m *QueryPlanNode) GetPredicates() *Expr {
	if m != nil {
		return m.Predicates
	}
	return nil
}

func (m *QueryPlanNode) GetIsCount() bool {
	if m != nil {
		return m.IsCount
	}
	return false
}

func (m *QueryPlanNode) GetLimit() int64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

type PlanNode struct {
	// Types that are valid to be assigned to Node:
	//	*PlanNode_VectorAnns
	//	*PlanNode_Predicates
	//	*PlanNode_Query
	Node                 isPlanNode_Node `protobuf_oneof:"node"`
	OutputFieldIds       []int64         `protobuf:"varint,3,rep,packed,name=output_field_ids,json=outputFieldIds,proto3" json:"output_field_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *PlanNode) Reset()         { *m = PlanNode{} }
func (m *PlanNode) String() string { return proto.CompactTextString(m) }
func (*PlanNode) ProtoMessage()    {}
func (*PlanNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_2d655ab2f7683c23, []int{21}
}

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

var xxx_messageInfo_PlanNode proto.InternalMessageInfo

type isPlanNode_Node interface {
	isPlanNode_Node()
}

type PlanNode_VectorAnns struct {
	VectorAnns *VectorANNS `protobuf:"bytes,1,opt,name=vector_anns,json=vectorAnns,proto3,oneof"`
}

type PlanNode_Predicates struct {
	Predicates *Expr `protobuf:"bytes,2,opt,name=predicates,proto3,oneof"`
}

type PlanNode_Query struct {
	Query *QueryPlanNode `protobuf:"bytes,4,opt,name=query,proto3,oneof"`
}

func (*PlanNode_VectorAnns) isPlanNode_Node() {}

func (*PlanNode_Predicates) isPlanNode_Node() {}

func (*PlanNode_Query) isPlanNode_Node() {}

func (m *PlanNode) GetNode() isPlanNode_Node {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *PlanNode) GetVectorAnns() *VectorANNS {
	if x, ok := m.GetNode().(*PlanNode_VectorAnns); ok {
		return x.VectorAnns
	}
	return nil
}

func (m *PlanNode) GetPredicates() *Expr {
	if x, ok := m.GetNode().(*PlanNode_Predicates); ok {
		return x.Predicates
	}
	return nil
}

func (m *PlanNode) GetQuery() *QueryPlanNode {
	if x, ok := m.GetNode().(*PlanNode_Query); ok {
		return x.Query
	}
	return nil
}

func (m *PlanNode) GetOutputFieldIds() []int64 {
	if m != nil {
		return m.OutputFieldIds
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*PlanNode) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*PlanNode_VectorAnns)(nil),
		(*PlanNode_Predicates)(nil),
		(*PlanNode_Query)(nil),
	}
}

func init() {
	proto.RegisterEnum("milvus.proto.plan.OpType", OpType_name, OpType_value)
	proto.RegisterEnum("milvus.proto.plan.ArithOpType", ArithOpType_name, ArithOpType_value)
	proto.RegisterEnum("milvus.proto.plan.JSONContainsExpr_JSONOp", JSONContainsExpr_JSONOp_name, JSONContainsExpr_JSONOp_value)
	proto.RegisterEnum("milvus.proto.plan.UnaryExpr_UnaryOp", UnaryExpr_UnaryOp_name, UnaryExpr_UnaryOp_value)
	proto.RegisterEnum("milvus.proto.plan.BinaryExpr_BinaryOp", BinaryExpr_BinaryOp_name, BinaryExpr_BinaryOp_value)
	proto.RegisterType((*GenericValue)(nil), "milvus.proto.plan.GenericValue")
	proto.RegisterType((*Array)(nil), "milvus.proto.plan.Array")
	proto.RegisterType((*QueryInfo)(nil), "milvus.proto.plan.QueryInfo")
	proto.RegisterType((*ColumnInfo)(nil), "milvus.proto.plan.ColumnInfo")
	proto.RegisterType((*ColumnExpr)(nil), "milvus.proto.plan.ColumnExpr")
	proto.RegisterType((*ExistsExpr)(nil), "milvus.proto.plan.ExistsExpr")
	proto.RegisterType((*ValueExpr)(nil), "milvus.proto.plan.ValueExpr")
	proto.RegisterType((*UnaryRangeExpr)(nil), "milvus.proto.plan.UnaryRangeExpr")
	proto.RegisterType((*BinaryRangeExpr)(nil), "milvus.proto.plan.BinaryRangeExpr")
	proto.RegisterType((*CompareExpr)(nil), "milvus.proto.plan.CompareExpr")
	proto.RegisterType((*TermExpr)(nil), "milvus.proto.plan.TermExpr")
	proto.RegisterType((*JSONContainsExpr)(nil), "milvus.proto.plan.JSONContainsExpr")
	proto.RegisterType((*UnaryExpr)(nil), "milvus.proto.plan.UnaryExpr")
	proto.RegisterType((*BinaryExpr)(nil), "milvus.proto.plan.BinaryExpr")
	proto.RegisterType((*BinaryArithOp)(nil), "milvus.proto.plan.BinaryArithOp")
	proto.RegisterType((*BinaryArithExpr)(nil), "milvus.proto.plan.BinaryArithExpr")
	proto.RegisterType((*BinaryArithOpEvalRangeExpr)(nil), "milvus.proto.plan.BinaryArithOpEvalRangeExpr")
	proto.RegisterType((*AlwaysTrueExpr)(nil), "milvus.proto.plan.AlwaysTrueExpr")
	proto.RegisterType((*Expr)(nil), "milvus.proto.plan.Expr")
	proto.RegisterType((*VectorANNS)(nil), "milvus.proto.plan.VectorANNS")
	proto.RegisterType((*QueryPlanNode)(nil), "milvus.proto.plan.QueryPlanNode")
	proto.RegisterType((*PlanNode)(nil), "milvus.proto.plan.PlanNode")
}

func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) }

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