expression.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: capsule8/api/v0/expression.proto

package capsule8_api_v0

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"

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

type ValueType int32

const (
	ValueType_VALUETYPE_UNSPECIFIED ValueType = 0
	ValueType_STRING                ValueType = 1
	ValueType_SINT8                 ValueType = 2
	ValueType_SINT16                ValueType = 3
	ValueType_SINT32                ValueType = 4
	ValueType_SINT64                ValueType = 5
	ValueType_UINT8                 ValueType = 6
	ValueType_UINT16                ValueType = 7
	ValueType_UINT32                ValueType = 8
	ValueType_UINT64                ValueType = 9
	ValueType_BOOL                  ValueType = 10
	ValueType_DOUBLE                ValueType = 11
	ValueType_TIMESTAMP             ValueType = 12
)

var ValueType_name = map[int32]string{
	0:  "VALUETYPE_UNSPECIFIED",
	1:  "STRING",
	2:  "SINT8",
	3:  "SINT16",
	4:  "SINT32",
	5:  "SINT64",
	6:  "UINT8",
	7:  "UINT16",
	8:  "UINT32",
	9:  "UINT64",
	10: "BOOL",
	11: "DOUBLE",
	12: "TIMESTAMP",
}
var ValueType_value = map[string]int32{
	"VALUETYPE_UNSPECIFIED": 0,
	"STRING":                1,
	"SINT8":                 2,
	"SINT16":                3,
	"SINT32":                4,
	"SINT64":                5,
	"UINT8":                 6,
	"UINT16":                7,
	"UINT32":                8,
	"UINT64":                9,
	"BOOL":                  10,
	"DOUBLE":                11,
	"TIMESTAMP":             12,
}

func (x ValueType) String() string {
	return proto.EnumName(ValueType_name, int32(x))
}
func (ValueType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_expression_633ee7819f2559b3, []int{0}
}

type Expression_ExpressionType int32

const (
	Expression_EXPRESSIONTYPE_UNSPECIFIED Expression_ExpressionType = 0
	Expression_IDENTIFIER                 Expression_ExpressionType = 1
	Expression_VALUE                      Expression_ExpressionType = 2
	Expression_LOGICAL_AND                Expression_ExpressionType = 10
	Expression_LOGICAL_OR                 Expression_ExpressionType = 11
	Expression_EQ                         Expression_ExpressionType = 20
	Expression_NE                         Expression_ExpressionType = 21
	Expression_LT                         Expression_ExpressionType = 22
	Expression_LE                         Expression_ExpressionType = 23
	Expression_GT                         Expression_ExpressionType = 24
	Expression_GE                         Expression_ExpressionType = 25
	Expression_LIKE                       Expression_ExpressionType = 26
	Expression_IS_NULL                    Expression_ExpressionType = 27
	Expression_IS_NOT_NULL                Expression_ExpressionType = 28
	Expression_BITWISE_AND                Expression_ExpressionType = 30
)

var Expression_ExpressionType_name = map[int32]string{
	0:  "EXPRESSIONTYPE_UNSPECIFIED",
	1:  "IDENTIFIER",
	2:  "VALUE",
	10: "LOGICAL_AND",
	11: "LOGICAL_OR",
	20: "EQ",
	21: "NE",
	22: "LT",
	23: "LE",
	24: "GT",
	25: "GE",
	26: "LIKE",
	27: "IS_NULL",
	28: "IS_NOT_NULL",
	30: "BITWISE_AND",
}
var Expression_ExpressionType_value = map[string]int32{
	"EXPRESSIONTYPE_UNSPECIFIED": 0,
	"IDENTIFIER":                 1,
	"VALUE":                      2,
	"LOGICAL_AND":                10,
	"LOGICAL_OR":                 11,
	"EQ":                         20,
	"NE":                         21,
	"LT":                         22,
	"LE":                         23,
	"GT":                         24,
	"GE":                         25,
	"LIKE":                       26,
	"IS_NULL":                    27,
	"IS_NOT_NULL":                28,
	"BITWISE_AND":                30,
}

func (x Expression_ExpressionType) String() string {
	return proto.EnumName(Expression_ExpressionType_name, int32(x))
}
func (Expression_ExpressionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_expression_633ee7819f2559b3, []int{2, 0}
}

type Value struct {
	Type ValueType `protobuf:"varint,1,opt,name=type,proto3,enum=capsule8.api.v0.ValueType" json:"type,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*Value_SignedValue
	//	*Value_UnsignedValue
	//	*Value_StringValue
	//	*Value_BoolValue
	//	*Value_DoubleValue
	//	*Value_TimestampValue
	Value                isValue_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Value proto.InternalMessageInfo

func (m *Value) GetType() ValueType {
	if m != nil {
		return m.Type
	}
	return ValueType_VALUETYPE_UNSPECIFIED
}

type isValue_Value interface {
	isValue_Value()
}

type Value_SignedValue struct {
	SignedValue int64 `protobuf:"zigzag64,10,opt,name=signed_value,json=signedValue,proto3,oneof"`
}

type Value_UnsignedValue struct {
	UnsignedValue uint64 `protobuf:"varint,11,opt,name=unsigned_value,json=unsignedValue,proto3,oneof"`
}

type Value_StringValue struct {
	StringValue string `protobuf:"bytes,12,opt,name=string_value,json=stringValue,proto3,oneof"`
}

type Value_BoolValue struct {
	BoolValue bool `protobuf:"varint,13,opt,name=bool_value,json=boolValue,proto3,oneof"`
}

type Value_DoubleValue struct {
	DoubleValue float64 `protobuf:"fixed64,14,opt,name=double_value,json=doubleValue,proto3,oneof"`
}

type Value_TimestampValue struct {
	TimestampValue *timestamp.Timestamp `protobuf:"bytes,15,opt,name=timestamp_value,json=timestampValue,proto3,oneof"`
}

func (*Value_SignedValue) isValue_Value() {}

func (*Value_UnsignedValue) isValue_Value() {}

func (*Value_StringValue) isValue_Value() {}

func (*Value_BoolValue) isValue_Value() {}

func (*Value_DoubleValue) isValue_Value() {}

func (*Value_TimestampValue) isValue_Value() {}

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

func (m *Value) GetSignedValue() int64 {
	if x, ok := m.GetValue().(*Value_SignedValue); ok {
		return x.SignedValue
	}
	return 0
}

func (m *Value) GetUnsignedValue() uint64 {
	if x, ok := m.GetValue().(*Value_UnsignedValue); ok {
		return x.UnsignedValue
	}
	return 0
}

func (m *Value) GetStringValue() string {
	if x, ok := m.GetValue().(*Value_StringValue); ok {
		return x.StringValue
	}
	return ""
}

func (m *Value) GetBoolValue() bool {
	if x, ok := m.GetValue().(*Value_BoolValue); ok {
		return x.BoolValue
	}
	return false
}

func (m *Value) GetDoubleValue() float64 {
	if x, ok := m.GetValue().(*Value_DoubleValue); ok {
		return x.DoubleValue
	}
	return 0
}

func (m *Value) GetTimestampValue() *timestamp.Timestamp {
	if x, ok := m.GetValue().(*Value_TimestampValue); ok {
		return x.TimestampValue
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Value) 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 _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
		(*Value_SignedValue)(nil),
		(*Value_UnsignedValue)(nil),
		(*Value_StringValue)(nil),
		(*Value_BoolValue)(nil),
		(*Value_DoubleValue)(nil),
		(*Value_TimestampValue)(nil),
	}
}

func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Value)
	// value
	switch x := m.Value.(type) {
	case *Value_SignedValue:
		b.EncodeVarint(10<<3 | proto.WireVarint)
		b.EncodeZigzag64(uint64(x.SignedValue))
	case *Value_UnsignedValue:
		b.EncodeVarint(11<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.UnsignedValue))
	case *Value_StringValue:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.StringValue)
	case *Value_BoolValue:
		t := uint64(0)
		if x.BoolValue {
			t = 1
		}
		b.EncodeVarint(13<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *Value_DoubleValue:
		b.EncodeVarint(14<<3 | proto.WireFixed64)
		b.EncodeFixed64(math.Float64bits(x.DoubleValue))
	case *Value_TimestampValue:
		b.EncodeVarint(15<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TimestampValue); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Value.Value has unexpected type %T", x)
	}
	return nil
}

func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Value)
	switch tag {
	case 10: // value.signed_value
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeZigzag64()
		m.Value = &Value_SignedValue{int64(x)}
		return true, err
	case 11: // value.unsigned_value
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &Value_UnsignedValue{x}
		return true, err
	case 12: // value.string_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Value = &Value_StringValue{x}
		return true, err
	case 13: // value.bool_value
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &Value_BoolValue{x != 0}
		return true, err
	case 14: // value.double_value
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.Value = &Value_DoubleValue{math.Float64frombits(x)}
		return true, err
	case 15: // value.timestamp_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(timestamp.Timestamp)
		err := b.DecodeMessage(msg)
		m.Value = &Value_TimestampValue{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Value_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Value)
	// value
	switch x := m.Value.(type) {
	case *Value_SignedValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(uint64(x.SignedValue<<1) ^ uint64((int64(x.SignedValue) >> 63))))
	case *Value_UnsignedValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.UnsignedValue))
	case *Value_StringValue:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.StringValue)))
		n += len(x.StringValue)
	case *Value_BoolValue:
		n += 1 // tag and wire
		n += 1
	case *Value_DoubleValue:
		n += 1 // tag and wire
		n += 8
	case *Value_TimestampValue:
		s := proto.Size(x.TimestampValue)
		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
}

type BinaryOp struct {
	Lhs                  *Expression `protobuf:"bytes,1,opt,name=lhs,proto3" json:"lhs,omitempty"`
	Rhs                  *Expression `protobuf:"bytes,2,opt,name=rhs,proto3" json:"rhs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_BinaryOp proto.InternalMessageInfo

func (m *BinaryOp) GetLhs() *Expression {
	if m != nil {
		return m.Lhs
	}
	return nil
}

func (m *BinaryOp) GetRhs() *Expression {
	if m != nil {
		return m.Rhs
	}
	return nil
}

type Expression struct {
	Type Expression_ExpressionType `protobuf:"varint,1,opt,name=type,proto3,enum=capsule8.api.v0.Expression_ExpressionType" json:"type,omitempty"`
	// Types that are valid to be assigned to Expr:
	//	*Expression_Identifier
	//	*Expression_Value
	//	*Expression_BinaryOp
	//	*Expression_UnaryOp
	Expr                 isExpression_Expr `protobuf_oneof:"expr"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_Expression proto.InternalMessageInfo

func (m *Expression) GetType() Expression_ExpressionType {
	if m != nil {
		return m.Type
	}
	return Expression_EXPRESSIONTYPE_UNSPECIFIED
}

type isExpression_Expr interface {
	isExpression_Expr()
}

type Expression_Identifier struct {
	Identifier string `protobuf:"bytes,10,opt,name=identifier,proto3,oneof"`
}

type Expression_Value struct {
	Value *Value `protobuf:"bytes,11,opt,name=value,proto3,oneof"`
}

type Expression_BinaryOp struct {
	BinaryOp *BinaryOp `protobuf:"bytes,12,opt,name=binary_op,json=binaryOp,proto3,oneof"`
}

type Expression_UnaryOp struct {
	UnaryOp *Expression `protobuf:"bytes,13,opt,name=unary_op,json=unaryOp,proto3,oneof"`
}

func (*Expression_Identifier) isExpression_Expr() {}

func (*Expression_Value) isExpression_Expr() {}

func (*Expression_BinaryOp) isExpression_Expr() {}

func (*Expression_UnaryOp) isExpression_Expr() {}

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

func (m *Expression) GetIdentifier() string {
	if x, ok := m.GetExpr().(*Expression_Identifier); ok {
		return x.Identifier
	}
	return ""
}

func (m *Expression) GetValue() *Value {
	if x, ok := m.GetExpr().(*Expression_Value); ok {
		return x.Value
	}
	return nil
}

func (m *Expression) GetBinaryOp() *BinaryOp {
	if x, ok := m.GetExpr().(*Expression_BinaryOp); ok {
		return x.BinaryOp
	}
	return nil
}

func (m *Expression) GetUnaryOp() *Expression {
	if x, ok := m.GetExpr().(*Expression_UnaryOp); ok {
		return x.UnaryOp
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Expression) 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 _Expression_OneofMarshaler, _Expression_OneofUnmarshaler, _Expression_OneofSizer, []interface{}{
		(*Expression_Identifier)(nil),
		(*Expression_Value)(nil),
		(*Expression_BinaryOp)(nil),
		(*Expression_UnaryOp)(nil),
	}
}

func _Expression_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Expression)
	// expr
	switch x := m.Expr.(type) {
	case *Expression_Identifier:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Identifier)
	case *Expression_Value:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Value); err != nil {
			return err
		}
	case *Expression_BinaryOp:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BinaryOp); err != nil {
			return err
		}
	case *Expression_UnaryOp:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.UnaryOp); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Expression.Expr has unexpected type %T", x)
	}
	return nil
}

func _Expression_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Expression)
	switch tag {
	case 10: // expr.identifier
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Expr = &Expression_Identifier{x}
		return true, err
	case 11: // expr.value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Value)
		err := b.DecodeMessage(msg)
		m.Expr = &Expression_Value{msg}
		return true, err
	case 12: // expr.binary_op
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BinaryOp)
		err := b.DecodeMessage(msg)
		m.Expr = &Expression_BinaryOp{msg}
		return true, err
	case 13: // expr.unary_op
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Expression)
		err := b.DecodeMessage(msg)
		m.Expr = &Expression_UnaryOp{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Expression_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Expression)
	// expr
	switch x := m.Expr.(type) {
	case *Expression_Identifier:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Identifier)))
		n += len(x.Identifier)
	case *Expression_Value:
		s := proto.Size(x.Value)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Expression_BinaryOp:
		s := proto.Size(x.BinaryOp)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Expression_UnaryOp:
		s := proto.Size(x.UnaryOp)
		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
}

func init() {
	proto.RegisterType((*Value)(nil), "capsule8.api.v0.Value")
	proto.RegisterType((*BinaryOp)(nil), "capsule8.api.v0.BinaryOp")
	proto.RegisterType((*Expression)(nil), "capsule8.api.v0.Expression")
	proto.RegisterEnum("capsule8.api.v0.ValueType", ValueType_name, ValueType_value)
	proto.RegisterEnum("capsule8.api.v0.Expression_ExpressionType", Expression_ExpressionType_name, Expression_ExpressionType_value)
}

func init() {
	proto.RegisterFile("capsule8/api/v0/expression.proto", fileDescriptor_expression_633ee7819f2559b3)
}

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