signer.pb.go

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

/*
Package proto is a generated protocol buffer package.

It is generated from these files:
	proto/signer.proto

It has these top-level messages:
	CreateKeyRequest
	KeyInfo
	KeyID
	Algorithm
	GetKeyInfoResponse
	PublicKey
	Signature
	SignatureRequest
	Void
	HealthStatus
*/
package proto

import proto1 "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.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 _ = proto1.ProtoPackageIsVersion2 // please upgrade the proto package

type CreateKeyRequest struct {
	Algorithm string `protobuf:"bytes,1,opt,name=algorithm" json:"algorithm,omitempty"`
	Gun       string `protobuf:"bytes,2,opt,name=gun" json:"gun,omitempty"`
	Role      string `protobuf:"bytes,3,opt,name=role" json:"role,omitempty"`
}

func (m *CreateKeyRequest) Reset()                    { *m = CreateKeyRequest{} }
func (m *CreateKeyRequest) String() string            { return proto1.CompactTextString(m) }
func (*CreateKeyRequest) ProtoMessage()               {}
func (*CreateKeyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

// KeyInfo holds a KeyID that is used to reference the key and it's algorithm
type KeyInfo struct {
	KeyID     *KeyID     `protobuf:"bytes,1,opt,name=keyID" json:"keyID,omitempty"`
	Algorithm *Algorithm `protobuf:"bytes,2,opt,name=algorithm" json:"algorithm,omitempty"`
}

func (m *KeyInfo) Reset()                    { *m = KeyInfo{} }
func (m *KeyInfo) String() string            { return proto1.CompactTextString(m) }
func (*KeyInfo) ProtoMessage()               {}
func (*KeyInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *KeyInfo) GetKeyID() *KeyID {
	if m != nil {
		return m.KeyID
	}
	return nil
}

func (m *KeyInfo) GetAlgorithm() *Algorithm {
	if m != nil {
		return m.Algorithm
	}
	return nil
}

// KeyID holds an ID that is used to reference the key
type KeyID struct {
	ID string `protobuf:"bytes,1,opt,name=ID,json=iD" json:"ID,omitempty"`
}

func (m *KeyID) Reset()                    { *m = KeyID{} }
func (m *KeyID) String() string            { return proto1.CompactTextString(m) }
func (*KeyID) ProtoMessage()               {}
func (*KeyID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

// Type holds the type of crypto algorithm used
type Algorithm struct {
	Algorithm string `protobuf:"bytes,1,opt,name=algorithm" json:"algorithm,omitempty"`
}

func (m *Algorithm) Reset()                    { *m = Algorithm{} }
func (m *Algorithm) String() string            { return proto1.CompactTextString(m) }
func (*Algorithm) ProtoMessage()               {}
func (*Algorithm) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

// GetKeyInfoResponse returns the public key, the role, and the algorithm and key ID.
// For backwards compatibility, it doesn't embed a PublicKey object
type GetKeyInfoResponse struct {
	KeyInfo   *KeyInfo `protobuf:"bytes,1,opt,name=keyInfo" json:"keyInfo,omitempty"`
	PublicKey []byte   `protobuf:"bytes,2,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
	Role      string   `protobuf:"bytes,3,opt,name=role" json:"role,omitempty"`
}

func (m *GetKeyInfoResponse) Reset()                    { *m = GetKeyInfoResponse{} }
func (m *GetKeyInfoResponse) String() string            { return proto1.CompactTextString(m) }
func (*GetKeyInfoResponse) ProtoMessage()               {}
func (*GetKeyInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }

func (m *GetKeyInfoResponse) GetKeyInfo() *KeyInfo {
	if m != nil {
		return m.KeyInfo
	}
	return nil
}

// PublicKey has a KeyInfo that is used to reference the key, and opaque bytes of a publicKey
type PublicKey struct {
	KeyInfo   *KeyInfo `protobuf:"bytes,1,opt,name=keyInfo" json:"keyInfo,omitempty"`
	PublicKey []byte   `protobuf:"bytes,2,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
}

func (m *PublicKey) Reset()                    { *m = PublicKey{} }
func (m *PublicKey) String() string            { return proto1.CompactTextString(m) }
func (*PublicKey) ProtoMessage()               {}
func (*PublicKey) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *PublicKey) GetKeyInfo() *KeyInfo {
	if m != nil {
		return m.KeyInfo
	}
	return nil
}

// Signature specifies a KeyInfo that was used for signing and signed content
type Signature struct {
	KeyInfo   *KeyInfo   `protobuf:"bytes,1,opt,name=keyInfo" json:"keyInfo,omitempty"`
	Algorithm *Algorithm `protobuf:"bytes,2,opt,name=algorithm" json:"algorithm,omitempty"`
	Content   []byte     `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
}

func (m *Signature) Reset()                    { *m = Signature{} }
func (m *Signature) String() string            { return proto1.CompactTextString(m) }
func (*Signature) ProtoMessage()               {}
func (*Signature) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

func (m *Signature) GetKeyInfo() *KeyInfo {
	if m != nil {
		return m.KeyInfo
	}
	return nil
}

func (m *Signature) GetAlgorithm() *Algorithm {
	if m != nil {
		return m.Algorithm
	}
	return nil
}

// SignatureRequests specifies a KeyInfo, and content to be signed
type SignatureRequest struct {
	KeyID   *KeyID `protobuf:"bytes,1,opt,name=keyID" json:"keyID,omitempty"`
	Content []byte `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
}

func (m *SignatureRequest) Reset()                    { *m = SignatureRequest{} }
func (m *SignatureRequest) String() string            { return proto1.CompactTextString(m) }
func (*SignatureRequest) ProtoMessage()               {}
func (*SignatureRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }

func (m *SignatureRequest) GetKeyID() *KeyID {
	if m != nil {
		return m.KeyID
	}
	return nil
}

// Void represents an empty message type
type Void struct {
}

func (m *Void) Reset()                    { *m = Void{} }
func (m *Void) String() string            { return proto1.CompactTextString(m) }
func (*Void) ProtoMessage()               {}
func (*Void) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }

// A mapping of health check name to the check result message
type HealthStatus struct {
	Status map[string]string `protobuf:"bytes,1,rep,name=status" json:"status,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *HealthStatus) Reset()                    { *m = HealthStatus{} }
func (m *HealthStatus) String() string            { return proto1.CompactTextString(m) }
func (*HealthStatus) ProtoMessage()               {}
func (*HealthStatus) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }

func (m *HealthStatus) GetStatus() map[string]string {
	if m != nil {
		return m.Status
	}
	return nil
}

func init() {
	proto1.RegisterType((*CreateKeyRequest)(nil), "proto.CreateKeyRequest")
	proto1.RegisterType((*KeyInfo)(nil), "proto.KeyInfo")
	proto1.RegisterType((*KeyID)(nil), "proto.KeyID")
	proto1.RegisterType((*Algorithm)(nil), "proto.Algorithm")
	proto1.RegisterType((*GetKeyInfoResponse)(nil), "proto.GetKeyInfoResponse")
	proto1.RegisterType((*PublicKey)(nil), "proto.PublicKey")
	proto1.RegisterType((*Signature)(nil), "proto.Signature")
	proto1.RegisterType((*SignatureRequest)(nil), "proto.SignatureRequest")
	proto1.RegisterType((*Void)(nil), "proto.Void")
	proto1.RegisterType((*HealthStatus)(nil), "proto.HealthStatus")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion3

// Client API for KeyManagement service

type KeyManagementClient interface {
	// CreateKey creates as asymmetric key pair and returns the PublicKey
	CreateKey(ctx context.Context, in *CreateKeyRequest, opts ...grpc.CallOption) (*PublicKey, error)
	// DeleteKey deletes the key associated with a KeyID
	DeleteKey(ctx context.Context, in *KeyID, opts ...grpc.CallOption) (*Void, error)
	// GetKeyInfo returns the PublicKey associated with a KeyID
	GetKeyInfo(ctx context.Context, in *KeyID, opts ...grpc.CallOption) (*GetKeyInfoResponse, error)
	// CheckHealth returns the HealthStatus with the service - note: since the
	// KeyManagement service is probably deployed on the same server as the Signer
	// service, we're only putting the CheckHealth function on the KeyManagement
	// service, to avoid confusion and to avoid clients polling both.
	CheckHealth(ctx context.Context, in *Void, opts ...grpc.CallOption) (*HealthStatus, error)
}

type keyManagementClient struct {
	cc *grpc.ClientConn
}

func NewKeyManagementClient(cc *grpc.ClientConn) KeyManagementClient {
	return &keyManagementClient{cc}
}

func (c *keyManagementClient) CreateKey(ctx context.Context, in *CreateKeyRequest, opts ...grpc.CallOption) (*PublicKey, error) {
	out := new(PublicKey)
	err := grpc.Invoke(ctx, "/proto.KeyManagement/CreateKey", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keyManagementClient) DeleteKey(ctx context.Context, in *KeyID, opts ...grpc.CallOption) (*Void, error) {
	out := new(Void)
	err := grpc.Invoke(ctx, "/proto.KeyManagement/DeleteKey", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keyManagementClient) GetKeyInfo(ctx context.Context, in *KeyID, opts ...grpc.CallOption) (*GetKeyInfoResponse, error) {
	out := new(GetKeyInfoResponse)
	err := grpc.Invoke(ctx, "/proto.KeyManagement/GetKeyInfo", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keyManagementClient) CheckHealth(ctx context.Context, in *Void, opts ...grpc.CallOption) (*HealthStatus, error) {
	out := new(HealthStatus)
	err := grpc.Invoke(ctx, "/proto.KeyManagement/CheckHealth", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for KeyManagement service

type KeyManagementServer interface {
	// CreateKey creates as asymmetric key pair and returns the PublicKey
	CreateKey(context.Context, *CreateKeyRequest) (*PublicKey, error)
	// DeleteKey deletes the key associated with a KeyID
	DeleteKey(context.Context, *KeyID) (*Void, error)
	// GetKeyInfo returns the PublicKey associated with a KeyID
	GetKeyInfo(context.Context, *KeyID) (*GetKeyInfoResponse, error)
	// CheckHealth returns the HealthStatus with the service - note: since the
	// KeyManagement service is probably deployed on the same server as the Signer
	// service, we're only putting the CheckHealth function on the KeyManagement
	// service, to avoid confusion and to avoid clients polling both.
	CheckHealth(context.Context, *Void) (*HealthStatus, error)
}

func RegisterKeyManagementServer(s *grpc.Server, srv KeyManagementServer) {
	s.RegisterService(&_KeyManagement_serviceDesc, srv)
}

func _KeyManagement_CreateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeyManagementServer).CreateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.KeyManagement/CreateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeyManagementServer).CreateKey(ctx, req.(*CreateKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _KeyManagement_DeleteKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeyManagementServer).DeleteKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.KeyManagement/DeleteKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeyManagementServer).DeleteKey(ctx, req.(*KeyID))
	}
	return interceptor(ctx, in, info, handler)
}

func _KeyManagement_GetKeyInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeyID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeyManagementServer).GetKeyInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.KeyManagement/GetKeyInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeyManagementServer).GetKeyInfo(ctx, req.(*KeyID))
	}
	return interceptor(ctx, in, info, handler)
}

func _KeyManagement_CheckHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Void)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeyManagementServer).CheckHealth(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.KeyManagement/CheckHealth",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeyManagementServer).CheckHealth(ctx, req.(*Void))
	}
	return interceptor(ctx, in, info, handler)
}

var _KeyManagement_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.KeyManagement",
	HandlerType: (*KeyManagementServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateKey",
			Handler:    _KeyManagement_CreateKey_Handler,
		},
		{
			MethodName: "DeleteKey",
			Handler:    _KeyManagement_DeleteKey_Handler,
		},
		{
			MethodName: "GetKeyInfo",
			Handler:    _KeyManagement_GetKeyInfo_Handler,
		},
		{
			MethodName: "CheckHealth",
			Handler:    _KeyManagement_CheckHealth_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: fileDescriptor0,
}

// Client API for Signer service

type SignerClient interface {
	// Sign calculates a cryptographic signature using the Key associated with a KeyID and returns the signature
	Sign(ctx context.Context, in *SignatureRequest, opts ...grpc.CallOption) (*Signature, error)
}

type signerClient struct {
	cc *grpc.ClientConn
}

func NewSignerClient(cc *grpc.ClientConn) SignerClient {
	return &signerClient{cc}
}

func (c *signerClient) Sign(ctx context.Context, in *SignatureRequest, opts ...grpc.CallOption) (*Signature, error) {
	out := new(Signature)
	err := grpc.Invoke(ctx, "/proto.Signer/Sign", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Signer service

type SignerServer interface {
	// Sign calculates a cryptographic signature using the Key associated with a KeyID and returns the signature
	Sign(context.Context, *SignatureRequest) (*Signature, error)
}

func RegisterSignerServer(s *grpc.Server, srv SignerServer) {
	s.RegisterService(&_Signer_serviceDesc, srv)
}

func _Signer_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignatureRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SignerServer).Sign(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.Signer/Sign",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SignerServer).Sign(ctx, req.(*SignatureRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Signer_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.Signer",
	HandlerType: (*SignerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Sign",
			Handler:    _Signer_Sign_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: fileDescriptor0,
}

func init() { proto1.RegisterFile("proto/signer.proto", fileDescriptor0) }

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