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

package otsprotocol

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

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

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

type VariantType int32

const (
	VariantType_VT_INTEGER VariantType = 0
	VariantType_VT_DOUBLE  VariantType = 1
	//VT_BOOLEAN = 2;
	VariantType_VT_STRING VariantType = 3
	VariantType_VT_NULL   VariantType = 6
	VariantType_VT_BLOB   VariantType = 7
)

var VariantType_name = map[int32]string{
	0: "VT_INTEGER",
	1: "VT_DOUBLE",
	3: "VT_STRING",
	6: "VT_NULL",
	7: "VT_BLOB",
}

var VariantType_value = map[string]int32{
	"VT_INTEGER": 0,
	"VT_DOUBLE":  1,
	"VT_STRING":  3,
	"VT_NULL":    6,
	"VT_BLOB":    7,
}

func (x VariantType) Enum() *VariantType {
	p := new(VariantType)
	*p = x
	return p
}

func (x VariantType) String() string {
	return proto.EnumName(VariantType_name, int32(x))
}

func (x *VariantType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(VariantType_value, data, "VariantType")
	if err != nil {
		return err
	}
	*x = VariantType(value)
	return nil
}

func (VariantType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d5eb1946c4bffb27, []int{0}
}

type FilterType int32

const (
	FilterType_FT_SINGLE_COLUMN_VALUE    FilterType = 1
	FilterType_FT_COMPOSITE_COLUMN_VALUE FilterType = 2
	FilterType_FT_COLUMN_PAGINATION      FilterType = 3
)

var FilterType_name = map[int32]string{
	1: "FT_SINGLE_COLUMN_VALUE",
	2: "FT_COMPOSITE_COLUMN_VALUE",
	3: "FT_COLUMN_PAGINATION",
}

var FilterType_value = map[string]int32{
	"FT_SINGLE_COLUMN_VALUE":    1,
	"FT_COMPOSITE_COLUMN_VALUE": 2,
	"FT_COLUMN_PAGINATION":      3,
}

func (x FilterType) Enum() *FilterType {
	p := new(FilterType)
	*p = x
	return p
}

func (x FilterType) String() string {
	return proto.EnumName(FilterType_name, int32(x))
}

func (x *FilterType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(FilterType_value, data, "FilterType")
	if err != nil {
		return err
	}
	*x = FilterType(value)
	return nil
}

func (FilterType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d5eb1946c4bffb27, []int{1}
}

type ComparatorType int32

const (
	ComparatorType_CT_EQUAL         ComparatorType = 1
	ComparatorType_CT_NOT_EQUAL     ComparatorType = 2
	ComparatorType_CT_GREATER_THAN  ComparatorType = 3
	ComparatorType_CT_GREATER_EQUAL ComparatorType = 4
	ComparatorType_CT_LESS_THAN     ComparatorType = 5
	ComparatorType_CT_LESS_EQUAL    ComparatorType = 6
)

var ComparatorType_name = map[int32]string{
	1: "CT_EQUAL",
	2: "CT_NOT_EQUAL",
	3: "CT_GREATER_THAN",
	4: "CT_GREATER_EQUAL",
	5: "CT_LESS_THAN",
	6: "CT_LESS_EQUAL",
}

var ComparatorType_value = map[string]int32{
	"CT_EQUAL":         1,
	"CT_NOT_EQUAL":     2,
	"CT_GREATER_THAN":  3,
	"CT_GREATER_EQUAL": 4,
	"CT_LESS_THAN":     5,
	"CT_LESS_EQUAL":    6,
}

func (x ComparatorType) Enum() *ComparatorType {
	p := new(ComparatorType)
	*p = x
	return p
}

func (x ComparatorType) String() string {
	return proto.EnumName(ComparatorType_name, int32(x))
}

func (x *ComparatorType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ComparatorType_value, data, "ComparatorType")
	if err != nil {
		return err
	}
	*x = ComparatorType(value)
	return nil
}

func (ComparatorType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d5eb1946c4bffb27, []int{2}
}

type LogicalOperator int32

const (
	LogicalOperator_LO_NOT LogicalOperator = 1
	LogicalOperator_LO_AND LogicalOperator = 2
	LogicalOperator_LO_OR  LogicalOperator = 3
)

var LogicalOperator_name = map[int32]string{
	1: "LO_NOT",
	2: "LO_AND",
	3: "LO_OR",
}

var LogicalOperator_value = map[string]int32{
	"LO_NOT": 1,
	"LO_AND": 2,
	"LO_OR":  3,
}

func (x LogicalOperator) Enum() *LogicalOperator {
	p := new(LogicalOperator)
	*p = x
	return p
}

func (x LogicalOperator) String() string {
	return proto.EnumName(LogicalOperator_name, int32(x))
}

func (x *LogicalOperator) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(LogicalOperator_value, data, "LogicalOperator")
	if err != nil {
		return err
	}
	*x = LogicalOperator(value)
	return nil
}

func (LogicalOperator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d5eb1946c4bffb27, []int{3}
}

type ValueTransferRule struct {
	Regex                *string      `protobuf:"bytes,1,req,name=regex" json:"regex,omitempty"`
	CastType             *VariantType `protobuf:"varint,2,opt,name=cast_type,json=castType,enum=otsprotocol.VariantType" json:"cast_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_ValueTransferRule proto.InternalMessageInfo

func (m *ValueTransferRule) GetRegex() string {
	if m != nil && m.Regex != nil {
		return *m.Regex
	}
	return ""
}

func (m *ValueTransferRule) GetCastType() VariantType {
	if m != nil && m.CastType != nil {
		return *m.CastType
	}
	return VariantType_VT_INTEGER
}

type SingleColumnValueFilter struct {
	Comparator           *ComparatorType    `protobuf:"varint,1,req,name=comparator,enum=otsprotocol.ComparatorType" json:"comparator,omitempty"`
	ColumnName           *string            `protobuf:"bytes,2,req,name=column_name,json=columnName" json:"column_name,omitempty"`
	ColumnValue          []byte             `protobuf:"bytes,3,req,name=column_value,json=columnValue" json:"column_value,omitempty"`
	FilterIfMissing      *bool              `protobuf:"varint,4,req,name=filter_if_missing,json=filterIfMissing" json:"filter_if_missing,omitempty"`
	LatestVersionOnly    *bool              `protobuf:"varint,5,req,name=latest_version_only,json=latestVersionOnly" json:"latest_version_only,omitempty"`
	ValueTransRule       *ValueTransferRule `protobuf:"bytes,6,opt,name=value_trans_rule,json=valueTransRule" json:"value_trans_rule,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

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

var xxx_messageInfo_SingleColumnValueFilter proto.InternalMessageInfo

func (m *SingleColumnValueFilter) GetComparator() ComparatorType {
	if m != nil && m.Comparator != nil {
		return *m.Comparator
	}
	return ComparatorType_CT_EQUAL
}

func (m *SingleColumnValueFilter) GetColumnName() string {
	if m != nil && m.ColumnName != nil {
		return *m.ColumnName
	}
	return ""
}

func (m *SingleColumnValueFilter) GetColumnValue() []byte {
	if m != nil {
		return m.ColumnValue
	}
	return nil
}

func (m *SingleColumnValueFilter) GetFilterIfMissing() bool {
	if m != nil && m.FilterIfMissing != nil {
		return *m.FilterIfMissing
	}
	return false
}

func (m *SingleColumnValueFilter) GetLatestVersionOnly() bool {
	if m != nil && m.LatestVersionOnly != nil {
		return *m.LatestVersionOnly
	}
	return false
}

func (m *SingleColumnValueFilter) GetValueTransRule() *ValueTransferRule {
	if m != nil {
		return m.ValueTransRule
	}
	return nil
}

type CompositeColumnValueFilter struct {
	Combinator           *LogicalOperator `protobuf:"varint,1,req,name=combinator,enum=otsprotocol.LogicalOperator" json:"combinator,omitempty"`
	SubFilters           []*Filter        `protobuf:"bytes,2,rep,name=sub_filters,json=subFilters" json:"sub_filters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

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

var xxx_messageInfo_CompositeColumnValueFilter proto.InternalMessageInfo

func (m *CompositeColumnValueFilter) GetCombinator() LogicalOperator {
	if m != nil && m.Combinator != nil {
		return *m.Combinator
	}
	return LogicalOperator_LO_NOT
}

func (m *CompositeColumnValueFilter) GetSubFilters() []*Filter {
	if m != nil {
		return m.SubFilters
	}
	return nil
}

type ColumnPaginationFilter struct {
	Offset               *int32   `protobuf:"varint,1,req,name=offset" json:"offset,omitempty"`
	Limit                *int32   `protobuf:"varint,2,req,name=limit" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ColumnPaginationFilter proto.InternalMessageInfo

func (m *ColumnPaginationFilter) GetOffset() int32 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

func (m *ColumnPaginationFilter) GetLimit() int32 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

type Filter struct {
	Type                 *FilterType `protobuf:"varint,1,req,name=type,enum=otsprotocol.FilterType" json:"type,omitempty"`
	Filter               []byte      `protobuf:"bytes,2,req,name=filter" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

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

var xxx_messageInfo_Filter proto.InternalMessageInfo

func (m *Filter) GetType() FilterType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return FilterType_FT_SINGLE_COLUMN_VALUE
}

func (m *Filter) GetFilter() []byte {
	if m != nil {
		return m.Filter
	}
	return nil
}

func init() {
	proto.RegisterEnum("otsprotocol.VariantType", VariantType_name, VariantType_value)
	proto.RegisterEnum("otsprotocol.FilterType", FilterType_name, FilterType_value)
	proto.RegisterEnum("otsprotocol.ComparatorType", ComparatorType_name, ComparatorType_value)
	proto.RegisterEnum("otsprotocol.LogicalOperator", LogicalOperator_name, LogicalOperator_value)
	proto.RegisterType((*ValueTransferRule)(nil), "otsprotocol.ValueTransferRule")
	proto.RegisterType((*SingleColumnValueFilter)(nil), "otsprotocol.SingleColumnValueFilter")
	proto.RegisterType((*CompositeColumnValueFilter)(nil), "otsprotocol.CompositeColumnValueFilter")
	proto.RegisterType((*ColumnPaginationFilter)(nil), "otsprotocol.ColumnPaginationFilter")
	proto.RegisterType((*Filter)(nil), "otsprotocol.Filter")
}

func init() { proto.RegisterFile("ots_filter.proto", fileDescriptor_d5eb1946c4bffb27) }

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