condition.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: flyteidl/core/condition.proto

package core // import "github.com/lyft/flyteidl/gen/pb-go/flyteidl/core"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package

// Binary Operator for each expression
type ComparisonExpression_Operator int32

const (
	ComparisonExpression_EQ  ComparisonExpression_Operator = 0
	ComparisonExpression_NEQ ComparisonExpression_Operator = 1
	// Greater Than
	ComparisonExpression_GT  ComparisonExpression_Operator = 2
	ComparisonExpression_GTE ComparisonExpression_Operator = 3
	// Less Than
	ComparisonExpression_LT  ComparisonExpression_Operator = 4
	ComparisonExpression_LTE ComparisonExpression_Operator = 5
)

var ComparisonExpression_Operator_name = map[int32]string{
	0: "EQ",
	1: "NEQ",
	2: "GT",
	3: "GTE",
	4: "LT",
	5: "LTE",
}
var ComparisonExpression_Operator_value = map[string]int32{
	"EQ":  0,
	"NEQ": 1,
	"GT":  2,
	"GTE": 3,
	"LT":  4,
	"LTE": 5,
}

func (x ComparisonExpression_Operator) String() string {
	return proto.EnumName(ComparisonExpression_Operator_name, int32(x))
}
func (ComparisonExpression_Operator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_condition_5fe109419dcb44b0, []int{0, 0}
}

// Nested conditions. They can be conjoined using AND / OR
// Order of evaluation is not important as the operators are Commutative
type ConjunctionExpression_LogicalOperator int32

const (
	// Conjunction
	ConjunctionExpression_AND ConjunctionExpression_LogicalOperator = 0
	ConjunctionExpression_OR  ConjunctionExpression_LogicalOperator = 1
)

var ConjunctionExpression_LogicalOperator_name = map[int32]string{
	0: "AND",
	1: "OR",
}
var ConjunctionExpression_LogicalOperator_value = map[string]int32{
	"AND": 0,
	"OR":  1,
}

func (x ConjunctionExpression_LogicalOperator) String() string {
	return proto.EnumName(ConjunctionExpression_LogicalOperator_name, int32(x))
}
func (ConjunctionExpression_LogicalOperator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_condition_5fe109419dcb44b0, []int{3, 0}
}

// Defines a 2-level tree where the root is a comparison operator and Operands are primitives or known variables.
// Each expression results in a boolean result.
type ComparisonExpression struct {
	Operator             ComparisonExpression_Operator `protobuf:"varint,1,opt,name=operator,proto3,enum=flyteidl.core.ComparisonExpression_Operator" json:"operator,omitempty"`
	LeftValue            *Operand                      `protobuf:"bytes,2,opt,name=left_value,json=leftValue,proto3" json:"left_value,omitempty"`
	RightValue           *Operand                      `protobuf:"bytes,3,opt,name=right_value,json=rightValue,proto3" json:"right_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *ComparisonExpression) Reset()         { *m = ComparisonExpression{} }
func (m *ComparisonExpression) String() string { return proto.CompactTextString(m) }
func (*ComparisonExpression) ProtoMessage()    {}
func (*ComparisonExpression) Descriptor() ([]byte, []int) {
	return fileDescriptor_condition_5fe109419dcb44b0, []int{0}
}
func (m *ComparisonExpression) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ComparisonExpression.Unmarshal(m, b)
}
func (m *ComparisonExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ComparisonExpression.Marshal(b, m, deterministic)
}
func (dst *ComparisonExpression) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComparisonExpression.Merge(dst, src)
}
func (m *ComparisonExpression) XXX_Size() int {
	return xxx_messageInfo_ComparisonExpression.Size(m)
}
func (m *ComparisonExpression) XXX_DiscardUnknown() {
	xxx_messageInfo_ComparisonExpression.DiscardUnknown(m)
}

var xxx_messageInfo_ComparisonExpression proto.InternalMessageInfo

func (m *ComparisonExpression) GetOperator() ComparisonExpression_Operator {
	if m != nil {
		return m.Operator
	}
	return ComparisonExpression_EQ
}

func (m *ComparisonExpression) GetLeftValue() *Operand {
	if m != nil {
		return m.LeftValue
	}
	return nil
}

func (m *ComparisonExpression) GetRightValue() *Operand {
	if m != nil {
		return m.RightValue
	}
	return nil
}

// Defines an operand to a comparison expression.
type Operand struct {
	// Types that are valid to be assigned to Val:
	//	*Operand_Primitive
	//	*Operand_Var
	Val                  isOperand_Val `protobuf_oneof:"val"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *Operand) Reset()         { *m = Operand{} }
func (m *Operand) String() string { return proto.CompactTextString(m) }
func (*Operand) ProtoMessage()    {}
func (*Operand) Descriptor() ([]byte, []int) {
	return fileDescriptor_condition_5fe109419dcb44b0, []int{1}
}
func (m *Operand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Operand.Unmarshal(m, b)
}
func (m *Operand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Operand.Marshal(b, m, deterministic)
}
func (dst *Operand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Operand.Merge(dst, src)
}
func (m *Operand) XXX_Size() int {
	return xxx_messageInfo_Operand.Size(m)
}
func (m *Operand) XXX_DiscardUnknown() {
	xxx_messageInfo_Operand.DiscardUnknown(m)
}

var xxx_messageInfo_Operand proto.InternalMessageInfo

type isOperand_Val interface {
	isOperand_Val()
}

type Operand_Primitive struct {
	Primitive *Primitive `protobuf:"bytes,1,opt,name=primitive,proto3,oneof"`
}

type Operand_Var struct {
	Var string `protobuf:"bytes,2,opt,name=var,proto3,oneof"`
}

func (*Operand_Primitive) isOperand_Val() {}

func (*Operand_Var) isOperand_Val() {}

func (m *Operand) GetVal() isOperand_Val {
	if m != nil {
		return m.Val
	}
	return nil
}

func (m *Operand) GetPrimitive() *Primitive {
	if x, ok := m.GetVal().(*Operand_Primitive); ok {
		return x.Primitive
	}
	return nil
}

func (m *Operand) GetVar() string {
	if x, ok := m.GetVal().(*Operand_Var); ok {
		return x.Var
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Operand) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Operand_OneofMarshaler, _Operand_OneofUnmarshaler, _Operand_OneofSizer, []interface{}{
		(*Operand_Primitive)(nil),
		(*Operand_Var)(nil),
	}
}

func _Operand_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Operand)
	// val
	switch x := m.Val.(type) {
	case *Operand_Primitive:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Primitive); err != nil {
			return err
		}
	case *Operand_Var:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Var)
	case nil:
	default:
		return fmt.Errorf("Operand.Val has unexpected type %T", x)
	}
	return nil
}

func _Operand_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Operand)
	switch tag {
	case 1: // val.primitive
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Primitive)
		err := b.DecodeMessage(msg)
		m.Val = &Operand_Primitive{msg}
		return true, err
	case 2: // val.var
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Val = &Operand_Var{x}
		return true, err
	default:
		return false, nil
	}
}

func _Operand_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Operand)
	// val
	switch x := m.Val.(type) {
	case *Operand_Primitive:
		s := proto.Size(x.Primitive)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Operand_Var:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Var)))
		n += len(x.Var)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Defines a boolean expression tree. It can be a simple or a conjunction expression.
// Multiple expressions can be combined using a conjunction or a disjunction to result in a final boolean result.
type BooleanExpression struct {
	// Types that are valid to be assigned to Expr:
	//	*BooleanExpression_Conjunction
	//	*BooleanExpression_Comparison
	Expr                 isBooleanExpression_Expr `protobuf_oneof:"expr"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *BooleanExpression) Reset()         { *m = BooleanExpression{} }
func (m *BooleanExpression) String() string { return proto.CompactTextString(m) }
func (*BooleanExpression) ProtoMessage()    {}
func (*BooleanExpression) Descriptor() ([]byte, []int) {
	return fileDescriptor_condition_5fe109419dcb44b0, []int{2}
}
func (m *BooleanExpression) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BooleanExpression.Unmarshal(m, b)
}
func (m *BooleanExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BooleanExpression.Marshal(b, m, deterministic)
}
func (dst *BooleanExpression) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BooleanExpression.Merge(dst, src)
}
func (m *BooleanExpression) XXX_Size() int {
	return xxx_messageInfo_BooleanExpression.Size(m)
}
func (m *BooleanExpression) XXX_DiscardUnknown() {
	xxx_messageInfo_BooleanExpression.DiscardUnknown(m)
}

var xxx_messageInfo_BooleanExpression proto.InternalMessageInfo

type isBooleanExpression_Expr interface {
	isBooleanExpression_Expr()
}

type BooleanExpression_Conjunction struct {
	Conjunction *ConjunctionExpression `protobuf:"bytes,1,opt,name=conjunction,proto3,oneof"`
}

type BooleanExpression_Comparison struct {
	Comparison *ComparisonExpression `protobuf:"bytes,2,opt,name=comparison,proto3,oneof"`
}

func (*BooleanExpression_Conjunction) isBooleanExpression_Expr() {}

func (*BooleanExpression_Comparison) isBooleanExpression_Expr() {}

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

func (m *BooleanExpression) GetConjunction() *ConjunctionExpression {
	if x, ok := m.GetExpr().(*BooleanExpression_Conjunction); ok {
		return x.Conjunction
	}
	return nil
}

func (m *BooleanExpression) GetComparison() *ComparisonExpression {
	if x, ok := m.GetExpr().(*BooleanExpression_Comparison); ok {
		return x.Comparison
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*BooleanExpression) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _BooleanExpression_OneofMarshaler, _BooleanExpression_OneofUnmarshaler, _BooleanExpression_OneofSizer, []interface{}{
		(*BooleanExpression_Conjunction)(nil),
		(*BooleanExpression_Comparison)(nil),
	}
}

func _BooleanExpression_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*BooleanExpression)
	// expr
	switch x := m.Expr.(type) {
	case *BooleanExpression_Conjunction:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Conjunction); err != nil {
			return err
		}
	case *BooleanExpression_Comparison:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Comparison); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("BooleanExpression.Expr has unexpected type %T", x)
	}
	return nil
}

func _BooleanExpression_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*BooleanExpression)
	switch tag {
	case 1: // expr.conjunction
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ConjunctionExpression)
		err := b.DecodeMessage(msg)
		m.Expr = &BooleanExpression_Conjunction{msg}
		return true, err
	case 2: // expr.comparison
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ComparisonExpression)
		err := b.DecodeMessage(msg)
		m.Expr = &BooleanExpression_Comparison{msg}
		return true, err
	default:
		return false, nil
	}
}

func _BooleanExpression_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*BooleanExpression)
	// expr
	switch x := m.Expr.(type) {
	case *BooleanExpression_Conjunction:
		s := proto.Size(x.Conjunction)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BooleanExpression_Comparison:
		s := proto.Size(x.Comparison)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// Defines a conjunction expression of two boolean expressions.
type ConjunctionExpression struct {
	Operator             ConjunctionExpression_LogicalOperator `protobuf:"varint,1,opt,name=operator,proto3,enum=flyteidl.core.ConjunctionExpression_LogicalOperator" json:"operator,omitempty"`
	LeftExpression       *BooleanExpression                    `protobuf:"bytes,2,opt,name=left_expression,json=leftExpression,proto3" json:"left_expression,omitempty"`
	RightExpression      *BooleanExpression                    `protobuf:"bytes,3,opt,name=right_expression,json=rightExpression,proto3" json:"right_expression,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                              `json:"-"`
	XXX_unrecognized     []byte                                `json:"-"`
	XXX_sizecache        int32                                 `json:"-"`
}

func (m *ConjunctionExpression) Reset()         { *m = ConjunctionExpression{} }
func (m *ConjunctionExpression) String() string { return proto.CompactTextString(m) }
func (*ConjunctionExpression) ProtoMessage()    {}
func (*ConjunctionExpression) Descriptor() ([]byte, []int) {
	return fileDescriptor_condition_5fe109419dcb44b0, []int{3}
}
func (m *ConjunctionExpression) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConjunctionExpression.Unmarshal(m, b)
}
func (m *ConjunctionExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConjunctionExpression.Marshal(b, m, deterministic)
}
func (dst *ConjunctionExpression) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConjunctionExpression.Merge(dst, src)
}
func (m *ConjunctionExpression) XXX_Size() int {
	return xxx_messageInfo_ConjunctionExpression.Size(m)
}
func (m *ConjunctionExpression) XXX_DiscardUnknown() {
	xxx_messageInfo_ConjunctionExpression.DiscardUnknown(m)
}

var xxx_messageInfo_ConjunctionExpression proto.InternalMessageInfo

func (m *ConjunctionExpression) GetOperator() ConjunctionExpression_LogicalOperator {
	if m != nil {
		return m.Operator
	}
	return ConjunctionExpression_AND
}

func (m *ConjunctionExpression) GetLeftExpression() *BooleanExpression {
	if m != nil {
		return m.LeftExpression
	}
	return nil
}

func (m *ConjunctionExpression) GetRightExpression() *BooleanExpression {
	if m != nil {
		return m.RightExpression
	}
	return nil
}

func init() {
	proto.RegisterType((*ComparisonExpression)(nil), "flyteidl.core.ComparisonExpression")
	proto.RegisterType((*Operand)(nil), "flyteidl.core.Operand")
	proto.RegisterType((*BooleanExpression)(nil), "flyteidl.core.BooleanExpression")
	proto.RegisterType((*ConjunctionExpression)(nil), "flyteidl.core.ConjunctionExpression")
	proto.RegisterEnum("flyteidl.core.ComparisonExpression_Operator", ComparisonExpression_Operator_name, ComparisonExpression_Operator_value)
	proto.RegisterEnum("flyteidl.core.ConjunctionExpression_LogicalOperator", ConjunctionExpression_LogicalOperator_name, ConjunctionExpression_LogicalOperator_value)
}

func init() {
	proto.RegisterFile("flyteidl/core/condition.proto", fileDescriptor_condition_5fe109419dcb44b0)
}

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