github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/geo/geopb/geopb.pb.go

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

package geopb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"

import encoding_binary "encoding/binary"

import io "io"

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

// Shape is the type of a spatial shape. Each of these corresponds to a
// different representation and serialization format. For example, a Point is a
// pair of doubles (or more than that for geometries with Z or N), a LineString
// is an ordered series of Points, etc.
type Shape int32

const (
	Shape_Unset           Shape = 0
	Shape_Point           Shape = 1
	Shape_LineString      Shape = 2
	Shape_Polygon         Shape = 3
	Shape_MultiPoint      Shape = 4
	Shape_MultiLineString Shape = 5
	Shape_MultiPolygon    Shape = 6
	// Geometry can contain any type.
	Shape_Geometry Shape = 7
	// GeometryCollection can contain a list of any above type except for Geometry.
	Shape_GeometryCollection Shape = 8
)

var Shape_name = map[int32]string{
	0: "Unset",
	1: "Point",
	2: "LineString",
	3: "Polygon",
	4: "MultiPoint",
	5: "MultiLineString",
	6: "MultiPolygon",
	7: "Geometry",
	8: "GeometryCollection",
}
var Shape_value = map[string]int32{
	"Unset":              0,
	"Point":              1,
	"LineString":         2,
	"Polygon":            3,
	"MultiPoint":         4,
	"MultiLineString":    5,
	"MultiPolygon":       6,
	"Geometry":           7,
	"GeometryCollection": 8,
}

func (x Shape) String() string {
	return proto.EnumName(Shape_name, int32(x))
}
func (Shape) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_geopb_b9b2328b838d758d, []int{0}
}

// SpatialObject represents a serialization of a Geospatial type.
type SpatialObject struct {
	// EWKB is the EWKB representation of the spatial object.
	EWKB EWKB `protobuf:"bytes,1,opt,name=ewkb,proto3,casttype=EWKB" json:"ewkb,omitempty"`
	// SRID is the denormalized SRID derived from the EWKB.
	SRID SRID `protobuf:"varint,2,opt,name=srid,proto3,casttype=SRID" json:"srid,omitempty"`
	// Shape is denormalized Shape derived from the EWKB.
	Shape Shape `protobuf:"varint,3,opt,name=shape,proto3,enum=cockroach.geopb.Shape" json:"shape,omitempty"`
	// BoundingBox is the bounding box of the SpatialObject.
	BoundingBox *BoundingBox `protobuf:"bytes,4,opt,name=bounding_box,json=boundingBox,proto3" json:"bounding_box,omitempty"`
}

func (m *SpatialObject) Reset()         { *m = SpatialObject{} }
func (m *SpatialObject) String() string { return proto.CompactTextString(m) }
func (*SpatialObject) ProtoMessage()    {}
func (*SpatialObject) Descriptor() ([]byte, []int) {
	return fileDescriptor_geopb_b9b2328b838d758d, []int{0}
}
func (m *SpatialObject) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SpatialObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *SpatialObject) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SpatialObject.Merge(dst, src)
}
func (m *SpatialObject) XXX_Size() int {
	return m.Size()
}
func (m *SpatialObject) XXX_DiscardUnknown() {
	xxx_messageInfo_SpatialObject.DiscardUnknown(m)
}

var xxx_messageInfo_SpatialObject proto.InternalMessageInfo

// BoundingBox represents the bounding box of a Geospatial type.
type BoundingBox struct {
	MinX float64 `protobuf:"fixed64,1,opt,name=min_x,json=minX,proto3" json:"min_x,omitempty"`
	MinY float64 `protobuf:"fixed64,2,opt,name=min_y,json=minY,proto3" json:"min_y,omitempty"`
	MaxX float64 `protobuf:"fixed64,3,opt,name=max_x,json=maxX,proto3" json:"max_x,omitempty"`
	MaxY float64 `protobuf:"fixed64,4,opt,name=max_y,json=maxY,proto3" json:"max_y,omitempty"`
}

func (m *BoundingBox) Reset()         { *m = BoundingBox{} }
func (m *BoundingBox) String() string { return proto.CompactTextString(m) }
func (*BoundingBox) ProtoMessage()    {}
func (*BoundingBox) Descriptor() ([]byte, []int) {
	return fileDescriptor_geopb_b9b2328b838d758d, []int{1}
}
func (m *BoundingBox) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BoundingBox) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *BoundingBox) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BoundingBox.Merge(dst, src)
}
func (m *BoundingBox) XXX_Size() int {
	return m.Size()
}
func (m *BoundingBox) XXX_DiscardUnknown() {
	xxx_messageInfo_BoundingBox.DiscardUnknown(m)
}

var xxx_messageInfo_BoundingBox proto.InternalMessageInfo

func init() {
	proto.RegisterType((*SpatialObject)(nil), "cockroach.geopb.SpatialObject")
	proto.RegisterType((*BoundingBox)(nil), "cockroach.geopb.BoundingBox")
	proto.RegisterEnum("cockroach.geopb.Shape", Shape_name, Shape_value)
}
func (m *SpatialObject) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SpatialObject) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.EWKB) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintGeopb(dAtA, i, uint64(len(m.EWKB)))
		i += copy(dAtA[i:], m.EWKB)
	}
	if m.SRID != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintGeopb(dAtA, i, uint64(m.SRID))
	}
	if m.Shape != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintGeopb(dAtA, i, uint64(m.Shape))
	}
	if m.BoundingBox != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintGeopb(dAtA, i, uint64(m.BoundingBox.Size()))
		n1, err := m.BoundingBox.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	return i, nil
}

func (m *BoundingBox) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BoundingBox) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.MinX != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MinX))))
		i += 8
	}
	if m.MinY != 0 {
		dAtA[i] = 0x11
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MinY))))
		i += 8
	}
	if m.MaxX != 0 {
		dAtA[i] = 0x19
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MaxX))))
		i += 8
	}
	if m.MaxY != 0 {
		dAtA[i] = 0x21
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.MaxY))))
		i += 8
	}
	return i, nil
}

func encodeVarintGeopb(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *SpatialObject) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.EWKB)
	if l > 0 {
		n += 1 + l + sovGeopb(uint64(l))
	}
	if m.SRID != 0 {
		n += 1 + sovGeopb(uint64(m.SRID))
	}
	if m.Shape != 0 {
		n += 1 + sovGeopb(uint64(m.Shape))
	}
	if m.BoundingBox != nil {
		l = m.BoundingBox.Size()
		n += 1 + l + sovGeopb(uint64(l))
	}
	return n
}

func (m *BoundingBox) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MinX != 0 {
		n += 9
	}
	if m.MinY != 0 {
		n += 9
	}
	if m.MaxX != 0 {
		n += 9
	}
	if m.MaxY != 0 {
		n += 9
	}
	return n
}

func sovGeopb(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozGeopb(x uint64) (n int) {
	return sovGeopb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SpatialObject) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGeopb
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SpatialObject: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SpatialObject: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EWKB", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGeopb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGeopb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EWKB = append(m.EWKB[:0], dAtA[iNdEx:postIndex]...)
			if m.EWKB == nil {
				m.EWKB = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SRID", wireType)
			}
			m.SRID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGeopb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SRID |= (SRID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shape", wireType)
			}
			m.Shape = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGeopb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Shape |= (Shape(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoundingBox", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGeopb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGeopb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BoundingBox == nil {
				m.BoundingBox = &BoundingBox{}
			}
			if err := m.BoundingBox.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGeopb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGeopb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BoundingBox) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGeopb
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BoundingBox: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BoundingBox: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinX", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.MinX = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinY", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.MinY = float64(math.Float64frombits(v))
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxX", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.MaxX = float64(math.Float64frombits(v))
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxY", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.MaxY = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipGeopb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGeopb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGeopb(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGeopb
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGeopb
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGeopb
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthGeopb
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowGeopb
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipGeopb(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthGeopb = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGeopb   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("geo/geopb/geopb.proto", fileDescriptor_geopb_b9b2328b838d758d) }

var fileDescriptor_geopb_b9b2328b838d758d = []byte{
	// 406 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x91, 0xd1, 0x6a, 0xd4, 0x40,
	0x14, 0x86, 0x33, 0x6d, 0xd2, 0xd6, 0xb3, 0x6b, 0x3b, 0x4c, 0xb5, 0x2c, 0x22, 0x63, 0x28, 0x82,
	0x41, 0x24, 0x85, 0xfa, 0x00, 0x42, 0x54, 0x44, 0x54, 0x2c, 0x09, 0x62, 0xeb, 0xcd, 0x92, 0xa4,
	0x43, 0x3a, 0x36, 0x3b, 0x27, 0x64, 0xa7, 0x98, 0xbc, 0x85, 0x77, 0xbe, 0x52, 0xf1, 0xaa, 0x97,
	0xbd, 0x12, 0xcd, 0xbe, 0x45, 0xaf, 0x24, 0x33, 0x59, 0x5c, 0xec, 0xcd, 0x9c, 0x73, 0xfe, 0xff,
	0x3b, 0xf0, 0xcf, 0x0c, 0xdc, 0x2f, 0x04, 0x1e, 0x14, 0x02, 0xab, 0xcc, 0x9e, 0x61, 0x55, 0xa3,
	0x46, 0xb6, 0x93, 0x63, 0x7e, 0x5e, 0x63, 0x9a, 0x9f, 0x85, 0x46, 0x7e, 0x70, 0xaf, 0xc0, 0x02,
	0x8d, 0x77, 0xd0, 0x77, 0x16, 0xdb, 0xff, 0x49, 0xe0, 0x6e, 0x52, 0xa5, 0x5a, 0xa6, 0xe5, 0xc7,
	0xec, 0xab, 0xc8, 0x35, 0x7b, 0x0c, 0xae, 0xf8, 0x76, 0x9e, 0x4d, 0x88, 0x4f, 0x82, 0x71, 0x44,
	0xbb, 0x5f, 0x8f, 0xdc, 0xd7, 0x9f, 0xdf, 0x45, 0x37, 0x43, 0x8d, 0x8d, 0xdb, 0x53, 0xf3, 0x5a,
	0x9e, 0x4e, 0xd6, 0x7c, 0x12, 0x78, 0x96, 0x4a, 0xe2, 0xb7, 0xaf, 0x6e, 0x86, 0x1a, 0x1b, 0x97,
	0x3d, 0x03, 0x6f, 0x7e, 0x96, 0x56, 0x62, 0xb2, 0xee, 0x93, 0x60, 0xfb, 0x70, 0x2f, 0xfc, 0x2f,
	0x54, 0x98, 0xf4, 0x6e, 0x6c, 0x21, 0xf6, 0x02, 0xc6, 0x19, 0x5e, 0xa8, 0x53, 0xa9, 0x8a, 0x69,
	0x86, 0xcd, 0xc4, 0xf5, 0x49, 0x30, 0x3a, 0x7c, 0x78, 0x6b, 0x29, 0x1a, 0xa0, 0x08, 0x9b, 0x78,
	0x94, 0xfd, 0x1b, 0xf6, 0x53, 0x18, 0xad, 0x78, 0x6c, 0x17, 0xbc, 0x99, 0x54, 0xd3, 0xc6, 0x5c,
	0x85, 0xc4, 0xee, 0x4c, 0xaa, 0xe3, 0xa5, 0xd8, 0x9a, 0xe4, 0x56, 0x3c, 0x31, 0x62, 0xda, 0x4c,
	0x1b, 0x93, 0xb3, 0x17, 0xd3, 0xe6, 0x78, 0x29, 0xb6, 0x26, 0x87, 0x15, 0x4f, 0x9e, 0xfe, 0x20,
	0xe0, 0x99, 0xd0, 0xec, 0x0e, 0x78, 0x9f, 0xd4, 0x5c, 0x68, 0xea, 0xf4, 0xed, 0x11, 0x4a, 0xa5,
	0x29, 0x61, 0xdb, 0x00, 0xef, 0xa5, 0x12, 0x89, 0xae, 0xa5, 0x2a, 0xe8, 0x1a, 0x1b, 0xc1, 0xe6,
	0x11, 0x96, 0x6d, 0x81, 0x8a, 0xae, 0xf7, 0xe6, 0x87, 0x8b, 0x52, 0x4b, 0x0b, 0xbb, 0x6c, 0x17,
	0x76, 0xcc, 0xbc, 0xb2, 0xe1, 0x31, 0x0a, 0xe3, 0x01, 0xb2, 0x6b, 0x1b, 0x6c, 0x0c, 0x5b, 0x6f,
	0x04, 0xce, 0x84, 0xae, 0x5b, 0xba, 0xc9, 0xf6, 0x80, 0x2d, 0xa7, 0x97, 0x58, 0x96, 0x22, 0xd7,
	0x12, 0x15, 0xdd, 0x8a, 0x9e, 0x5c, 0xfe, 0xe1, 0xce, 0x65, 0xc7, 0xc9, 0x55, 0xc7, 0xc9, 0x75,
	0xc7, 0xc9, 0xef, 0x8e, 0x93, 0xef, 0x0b, 0xee, 0x5c, 0x2d, 0xb8, 0x73, 0xbd, 0xe0, 0xce, 0x17,
	0xcf, 0x3c, 0x5f, 0xb6, 0x61, 0x7e, 0xfe, 0xf9, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x51, 0xa8,
	0xbe, 0x84, 0x39, 0x02, 0x00, 0x00,
}