control.pb.go

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

package control // import "github.com/dedis/drand/protobuf/control"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import crypto "github.com/dedis/drand/protobuf/crypto"

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

// 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 DKGRequest struct {
	DkgGroup             *GroupInfo `protobuf:"bytes,1,opt,name=dkg_group,json=dkgGroup,proto3" json:"dkg_group,omitempty"`
	IsLeader             bool       `protobuf:"varint,2,opt,name=is_leader,json=isLeader,proto3" json:"is_leader,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_DKGRequest proto.InternalMessageInfo

func (m *DKGRequest) GetDkgGroup() *GroupInfo {
	if m != nil {
		return m.DkgGroup
	}
	return nil
}

func (m *DKGRequest) GetIsLeader() bool {
	if m != nil {
		return m.IsLeader
	}
	return false
}

type DKGResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DKGResponse proto.InternalMessageInfo

// ReshareRequest contains references to the old and new group to perform the
// resharing protocol.
type ReshareRequest struct {
	// Old group that needs to issue the shares for the new group
	// NOTE: It can be empty / nil. In that case, the drand node will try to
	// load the group he belongs to at the moment, if any, and use it as the old
	// group.
	Old                  *GroupInfo `protobuf:"bytes,1,opt,name=old,proto3" json:"old,omitempty"`
	New                  *GroupInfo `protobuf:"bytes,2,opt,name=new,proto3" json:"new,omitempty"`
	IsLeader             bool       `protobuf:"varint,3,opt,name=is_leader,json=isLeader,proto3" json:"is_leader,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_ReshareRequest proto.InternalMessageInfo

func (m *ReshareRequest) GetOld() *GroupInfo {
	if m != nil {
		return m.Old
	}
	return nil
}

func (m *ReshareRequest) GetNew() *GroupInfo {
	if m != nil {
		return m.New
	}
	return nil
}

func (m *ReshareRequest) GetIsLeader() bool {
	if m != nil {
		return m.IsLeader
	}
	return false
}

type GroupInfo struct {
	// Types that are valid to be assigned to Location:
	//	*GroupInfo_Path
	//	*GroupInfo_Url
	Location             isGroupInfo_Location `protobuf_oneof:"location"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_GroupInfo proto.InternalMessageInfo

type isGroupInfo_Location interface {
	isGroupInfo_Location()
}

type GroupInfo_Path struct {
	Path string `protobuf:"bytes,1,opt,name=path,proto3,oneof"`
}

type GroupInfo_Url struct {
	Url string `protobuf:"bytes,2,opt,name=url,proto3,oneof"`
}

func (*GroupInfo_Path) isGroupInfo_Location() {}

func (*GroupInfo_Url) isGroupInfo_Location() {}

func (m *GroupInfo) GetLocation() isGroupInfo_Location {
	if m != nil {
		return m.Location
	}
	return nil
}

func (m *GroupInfo) GetPath() string {
	if x, ok := m.GetLocation().(*GroupInfo_Path); ok {
		return x.Path
	}
	return ""
}

func (m *GroupInfo) GetUrl() string {
	if x, ok := m.GetLocation().(*GroupInfo_Url); ok {
		return x.Url
	}
	return ""
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*GroupInfo) 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 _GroupInfo_OneofMarshaler, _GroupInfo_OneofUnmarshaler, _GroupInfo_OneofSizer, []interface{}{
		(*GroupInfo_Path)(nil),
		(*GroupInfo_Url)(nil),
	}
}

func _GroupInfo_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*GroupInfo)
	// location
	switch x := m.Location.(type) {
	case *GroupInfo_Path:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Path)
	case *GroupInfo_Url:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.Url)
	case nil:
	default:
		return fmt.Errorf("GroupInfo.Location has unexpected type %T", x)
	}
	return nil
}

func _GroupInfo_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*GroupInfo)
	switch tag {
	case 1: // location.path
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Location = &GroupInfo_Path{x}
		return true, err
	case 2: // location.url
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.Location = &GroupInfo_Url{x}
		return true, err
	default:
		return false, nil
	}
}

func _GroupInfo_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*GroupInfo)
	// location
	switch x := m.Location.(type) {
	case *GroupInfo_Path:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Path)))
		n += len(x.Path)
	case *GroupInfo_Url:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Url)))
		n += len(x.Url)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type ReshareResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ReshareResponse proto.InternalMessageInfo

// ShareRequest requests the private share of a drand node
type ShareRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ShareRequest proto.InternalMessageInfo

// ShareResponse holds the private share of a drand node
type ShareResponse struct {
	Index                uint32         `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Share                *crypto.Scalar `protobuf:"bytes,2,opt,name=share,proto3" json:"share,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_ShareResponse proto.InternalMessageInfo

func (m *ShareResponse) GetIndex() uint32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *ShareResponse) GetShare() *crypto.Scalar {
	if m != nil {
		return m.Share
	}
	return nil
}

type Ping struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Ping proto.InternalMessageInfo

type Pong struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Pong proto.InternalMessageInfo

// PublicKeyRequest requests the public key of a drand node
type PublicKeyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PublicKeyRequest proto.InternalMessageInfo

// PublicKeyResponse holds the public key of a drand node
type PublicKeyResponse struct {
	PubKey               *crypto.Point `protobuf:"bytes,1,opt,name=pubKey,proto3" json:"pubKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_PublicKeyResponse proto.InternalMessageInfo

func (m *PublicKeyResponse) GetPubKey() *crypto.Point {
	if m != nil {
		return m.PubKey
	}
	return nil
}

// PrivateKeyRequest requests the private key of a drand node
type PrivateKeyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PrivateKeyRequest proto.InternalMessageInfo

// PrivateKeyResponse holds the private key of a drand node
type PrivateKeyResponse struct {
	PriKey               *crypto.Scalar `protobuf:"bytes,1,opt,name=priKey,proto3" json:"priKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_PrivateKeyResponse proto.InternalMessageInfo

func (m *PrivateKeyResponse) GetPriKey() *crypto.Scalar {
	if m != nil {
		return m.PriKey
	}
	return nil
}

// CokeyRequest requests the collective key of a drand node
type CokeyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CokeyRequest proto.InternalMessageInfo

// CokeyResponse holds the collective key of a drand node
type CokeyResponse struct {
	CoKey                *crypto.Point `protobuf:"bytes,1,opt,name=coKey,proto3" json:"coKey,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_CokeyResponse proto.InternalMessageInfo

func (m *CokeyResponse) GetCoKey() *crypto.Point {
	if m != nil {
		return m.CoKey
	}
	return nil
}

type GroupRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GroupRequest proto.InternalMessageInfo

type GroupResponse struct {
	// TOML-encoded group file
	GroupToml            string   `protobuf:"bytes,1,opt,name=groupToml,proto3" json:"groupToml,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GroupResponse proto.InternalMessageInfo

func (m *GroupResponse) GetGroupToml() string {
	if m != nil {
		return m.GroupToml
	}
	return ""
}

func init() {
	proto.RegisterType((*DKGRequest)(nil), "control.DKGRequest")
	proto.RegisterType((*DKGResponse)(nil), "control.DKGResponse")
	proto.RegisterType((*ReshareRequest)(nil), "control.ReshareRequest")
	proto.RegisterType((*GroupInfo)(nil), "control.GroupInfo")
	proto.RegisterType((*ReshareResponse)(nil), "control.ReshareResponse")
	proto.RegisterType((*ShareRequest)(nil), "control.ShareRequest")
	proto.RegisterType((*ShareResponse)(nil), "control.ShareResponse")
	proto.RegisterType((*Ping)(nil), "control.Ping")
	proto.RegisterType((*Pong)(nil), "control.Pong")
	proto.RegisterType((*PublicKeyRequest)(nil), "control.PublicKeyRequest")
	proto.RegisterType((*PublicKeyResponse)(nil), "control.PublicKeyResponse")
	proto.RegisterType((*PrivateKeyRequest)(nil), "control.PrivateKeyRequest")
	proto.RegisterType((*PrivateKeyResponse)(nil), "control.PrivateKeyResponse")
	proto.RegisterType((*CokeyRequest)(nil), "control.CokeyRequest")
	proto.RegisterType((*CokeyResponse)(nil), "control.CokeyResponse")
	proto.RegisterType((*GroupRequest)(nil), "control.GroupRequest")
	proto.RegisterType((*GroupResponse)(nil), "control.GroupResponse")
}

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

// ControlClient is the client API for Control service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ControlClient interface {
	// PingPong returns an empty message. Purpose is to test the control port.
	PingPong(ctx context.Context, in *Ping, opts ...grpc.CallOption) (*Pong, error)
	// InitDKG sends information to daemon to start a fresh DKG protocol
	InitDKG(ctx context.Context, in *DKGRequest, opts ...grpc.CallOption) (*DKGResponse, error)
	// InitReshares sends all informations so that the drand node knows how to
	// proceeed during the next resharing protocol.
	InitReshare(ctx context.Context, in *ReshareRequest, opts ...grpc.CallOption) (*ReshareResponse, error)
	// Share returns the current private share used by the node
	Share(ctx context.Context, in *ShareRequest, opts ...grpc.CallOption) (*ShareResponse, error)
	// PublicKey returns the longterm public key of the drand node
	PublicKey(ctx context.Context, in *PublicKeyRequest, opts ...grpc.CallOption) (*PublicKeyResponse, error)
	// PrivateKey returns the longterm private key of the drand node
	PrivateKey(ctx context.Context, in *PrivateKeyRequest, opts ...grpc.CallOption) (*PrivateKeyResponse, error)
	// CollectiveKey returns the distributed public key used by the node
	CollectiveKey(ctx context.Context, in *CokeyRequest, opts ...grpc.CallOption) (*CokeyResponse, error)
	// Group returns the current group file used
	Group(ctx context.Context, in *GroupRequest, opts ...grpc.CallOption) (*GroupResponse, error)
}

type controlClient struct {
	cc *grpc.ClientConn
}

func NewControlClient(cc *grpc.ClientConn) ControlClient {
	return &controlClient{cc}
}

func (c *controlClient) PingPong(ctx context.Context, in *Ping, opts ...grpc.CallOption) (*Pong, error) {
	out := new(Pong)
	err := c.cc.Invoke(ctx, "/control.Control/PingPong", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) InitDKG(ctx context.Context, in *DKGRequest, opts ...grpc.CallOption) (*DKGResponse, error) {
	out := new(DKGResponse)
	err := c.cc.Invoke(ctx, "/control.Control/InitDKG", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) InitReshare(ctx context.Context, in *ReshareRequest, opts ...grpc.CallOption) (*ReshareResponse, error) {
	out := new(ReshareResponse)
	err := c.cc.Invoke(ctx, "/control.Control/InitReshare", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Share(ctx context.Context, in *ShareRequest, opts ...grpc.CallOption) (*ShareResponse, error) {
	out := new(ShareResponse)
	err := c.cc.Invoke(ctx, "/control.Control/Share", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) PublicKey(ctx context.Context, in *PublicKeyRequest, opts ...grpc.CallOption) (*PublicKeyResponse, error) {
	out := new(PublicKeyResponse)
	err := c.cc.Invoke(ctx, "/control.Control/PublicKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) PrivateKey(ctx context.Context, in *PrivateKeyRequest, opts ...grpc.CallOption) (*PrivateKeyResponse, error) {
	out := new(PrivateKeyResponse)
	err := c.cc.Invoke(ctx, "/control.Control/PrivateKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) CollectiveKey(ctx context.Context, in *CokeyRequest, opts ...grpc.CallOption) (*CokeyResponse, error) {
	out := new(CokeyResponse)
	err := c.cc.Invoke(ctx, "/control.Control/CollectiveKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *controlClient) Group(ctx context.Context, in *GroupRequest, opts ...grpc.CallOption) (*GroupResponse, error) {
	out := new(GroupResponse)
	err := c.cc.Invoke(ctx, "/control.Control/Group", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ControlServer is the server API for Control service.
type ControlServer interface {
	// PingPong returns an empty message. Purpose is to test the control port.
	PingPong(context.Context, *Ping) (*Pong, error)
	// InitDKG sends information to daemon to start a fresh DKG protocol
	InitDKG(context.Context, *DKGRequest) (*DKGResponse, error)
	// InitReshares sends all informations so that the drand node knows how to
	// proceeed during the next resharing protocol.
	InitReshare(context.Context, *ReshareRequest) (*ReshareResponse, error)
	// Share returns the current private share used by the node
	Share(context.Context, *ShareRequest) (*ShareResponse, error)
	// PublicKey returns the longterm public key of the drand node
	PublicKey(context.Context, *PublicKeyRequest) (*PublicKeyResponse, error)
	// PrivateKey returns the longterm private key of the drand node
	PrivateKey(context.Context, *PrivateKeyRequest) (*PrivateKeyResponse, error)
	// CollectiveKey returns the distributed public key used by the node
	CollectiveKey(context.Context, *CokeyRequest) (*CokeyResponse, error)
	// Group returns the current group file used
	Group(context.Context, *GroupRequest) (*GroupResponse, error)
}

func RegisterControlServer(s *grpc.Server, srv ControlServer) {
	s.RegisterService(&_Control_serviceDesc, srv)
}

func _Control_PingPong_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Ping)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PingPong(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/PingPong",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PingPong(ctx, req.(*Ping))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_InitDKG_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DKGRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).InitDKG(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/InitDKG",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).InitDKG(ctx, req.(*DKGRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_InitReshare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReshareRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).InitReshare(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/InitReshare",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).InitReshare(ctx, req.(*ReshareRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Share_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ShareRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Share(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/Share",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Share(ctx, req.(*ShareRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_PublicKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PublicKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/PublicKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PublicKey(ctx, req.(*PublicKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_PrivateKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrivateKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).PrivateKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/PrivateKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).PrivateKey(ctx, req.(*PrivateKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_CollectiveKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CokeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).CollectiveKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/CollectiveKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).CollectiveKey(ctx, req.(*CokeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Control_Group_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GroupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ControlServer).Group(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.Control/Group",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ControlServer).Group(ctx, req.(*GroupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Control_serviceDesc = grpc.ServiceDesc{
	ServiceName: "control.Control",
	HandlerType: (*ControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PingPong",
			Handler:    _Control_PingPong_Handler,
		},
		{
			MethodName: "InitDKG",
			Handler:    _Control_InitDKG_Handler,
		},
		{
			MethodName: "InitReshare",
			Handler:    _Control_InitReshare_Handler,
		},
		{
			MethodName: "Share",
			Handler:    _Control_Share_Handler,
		},
		{
			MethodName: "PublicKey",
			Handler:    _Control_PublicKey_Handler,
		},
		{
			MethodName: "PrivateKey",
			Handler:    _Control_PrivateKey_Handler,
		},
		{
			MethodName: "CollectiveKey",
			Handler:    _Control_CollectiveKey_Handler,
		},
		{
			MethodName: "Group",
			Handler:    _Control_Group_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "control/control.proto",
}

func init() { proto.RegisterFile("control/control.proto", fileDescriptor_control_b022c2360c3627d6) }

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