tofnd.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: tss/tofnd/v1beta1/tofnd.proto

package tofnd

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

type RecoverResponse_Response int32

const (
	RecoverResponse_RESPONSE_UNSPECIFIED RecoverResponse_Response = 0
	RecoverResponse_RESPONSE_SUCCESS     RecoverResponse_Response = 1
	RecoverResponse_RESPONSE_FAIL        RecoverResponse_Response = 2
)

var RecoverResponse_Response_name = map[int32]string{
	0: "RESPONSE_UNSPECIFIED",
	1: "RESPONSE_SUCCESS",
	2: "RESPONSE_FAIL",
}

var RecoverResponse_Response_value = map[string]int32{
	"RESPONSE_UNSPECIFIED": 0,
	"RESPONSE_SUCCESS":     1,
	"RESPONSE_FAIL":        2,
}

func (x RecoverResponse_Response) String() string {
	return proto.EnumName(RecoverResponse_Response_name, int32(x))
}

func (RecoverResponse_Response) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{1, 0}
}

type MessageOut_CriminalList_Criminal_CrimeType int32

const (
	CRIME_TYPE_UNSPECIFIED   MessageOut_CriminalList_Criminal_CrimeType = 0
	CRIME_TYPE_NON_MALICIOUS MessageOut_CriminalList_Criminal_CrimeType = 1
	CRIME_TYPE_MALICIOUS     MessageOut_CriminalList_Criminal_CrimeType = 2
)

var MessageOut_CriminalList_Criminal_CrimeType_name = map[int32]string{
	0: "CRIME_TYPE_UNSPECIFIED",
	1: "CRIME_TYPE_NON_MALICIOUS",
	2: "CRIME_TYPE_MALICIOUS",
}

var MessageOut_CriminalList_Criminal_CrimeType_value = map[string]int32{
	"CRIME_TYPE_UNSPECIFIED":   0,
	"CRIME_TYPE_NON_MALICIOUS": 1,
	"CRIME_TYPE_MALICIOUS":     2,
}

func (x MessageOut_CriminalList_Criminal_CrimeType) String() string {
	return proto.EnumName(MessageOut_CriminalList_Criminal_CrimeType_name, int32(x))
}

func (MessageOut_CriminalList_Criminal_CrimeType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{4, 2, 0, 0}
}

type RecoverRequest struct {
	KeygenInit   *KeygenInit   `protobuf:"bytes,1,opt,name=keygen_init,json=keygenInit,proto3" json:"keygen_init,omitempty"`
	KeygenOutput *KeygenOutput `protobuf:"bytes,2,opt,name=keygen_output,json=keygenOutput,proto3" json:"keygen_output,omitempty"`
}

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

var xxx_messageInfo_RecoverRequest proto.InternalMessageInfo

func (m *RecoverRequest) GetKeygenInit() *KeygenInit {
	if m != nil {
		return m.KeygenInit
	}
	return nil
}

func (m *RecoverRequest) GetKeygenOutput() *KeygenOutput {
	if m != nil {
		return m.KeygenOutput
	}
	return nil
}

type RecoverResponse struct {
	Response RecoverResponse_Response `protobuf:"varint,1,opt,name=response,proto3,enum=tss.tofnd.v1beta1.RecoverResponse_Response" json:"response,omitempty"`
}

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

var xxx_messageInfo_RecoverResponse proto.InternalMessageInfo

func (m *RecoverResponse) GetResponse() RecoverResponse_Response {
	if m != nil {
		return m.Response
	}
	return RecoverResponse_RESPONSE_UNSPECIFIED
}

// Keygen's success response
type KeygenOutput struct {
	PubKey             []byte `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
	GroupRecoverInfo   []byte `protobuf:"bytes,2,opt,name=group_recover_info,json=groupRecoverInfo,proto3" json:"group_recover_info,omitempty"`
	PrivateRecoverInfo []byte `protobuf:"bytes,3,opt,name=private_recover_info,json=privateRecoverInfo,proto3" json:"private_recover_info,omitempty"`
}

func (m *KeygenOutput) Reset()         { *m = KeygenOutput{} }
func (m *KeygenOutput) String() string { return proto.CompactTextString(m) }
func (*KeygenOutput) ProtoMessage()    {}
func (*KeygenOutput) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{2}
}
func (m *KeygenOutput) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeygenOutput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeygenOutput.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeygenOutput) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeygenOutput.Merge(m, src)
}
func (m *KeygenOutput) XXX_Size() int {
	return m.Size()
}
func (m *KeygenOutput) XXX_DiscardUnknown() {
	xxx_messageInfo_KeygenOutput.DiscardUnknown(m)
}

var xxx_messageInfo_KeygenOutput proto.InternalMessageInfo

func (m *KeygenOutput) GetPubKey() []byte {
	if m != nil {
		return m.PubKey
	}
	return nil
}

func (m *KeygenOutput) GetGroupRecoverInfo() []byte {
	if m != nil {
		return m.GroupRecoverInfo
	}
	return nil
}

func (m *KeygenOutput) GetPrivateRecoverInfo() []byte {
	if m != nil {
		return m.PrivateRecoverInfo
	}
	return nil
}

type MessageIn struct {
	// Types that are valid to be assigned to Data:
	//	*MessageIn_KeygenInit
	//	*MessageIn_SignInit
	//	*MessageIn_Traffic
	//	*MessageIn_Abort
	Data isMessageIn_Data `protobuf_oneof:"data"`
}

func (m *MessageIn) Reset()         { *m = MessageIn{} }
func (m *MessageIn) String() string { return proto.CompactTextString(m) }
func (*MessageIn) ProtoMessage()    {}
func (*MessageIn) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{3}
}
func (m *MessageIn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MessageIn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageIn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MessageIn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageIn.Merge(m, src)
}
func (m *MessageIn) XXX_Size() int {
	return m.Size()
}
func (m *MessageIn) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageIn.DiscardUnknown(m)
}

var xxx_messageInfo_MessageIn proto.InternalMessageInfo

type isMessageIn_Data interface {
	isMessageIn_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type MessageIn_KeygenInit struct {
	KeygenInit *KeygenInit `protobuf:"bytes,1,opt,name=keygen_init,json=keygenInit,proto3,oneof" json:"keygen_init,omitempty"`
}
type MessageIn_SignInit struct {
	SignInit *SignInit `protobuf:"bytes,2,opt,name=sign_init,json=signInit,proto3,oneof" json:"sign_init,omitempty"`
}
type MessageIn_Traffic struct {
	Traffic *TrafficIn `protobuf:"bytes,3,opt,name=traffic,proto3,oneof" json:"traffic,omitempty"`
}
type MessageIn_Abort struct {
	Abort bool `protobuf:"varint,4,opt,name=abort,proto3,oneof" json:"abort,omitempty"`
}

func (*MessageIn_KeygenInit) isMessageIn_Data() {}
func (*MessageIn_SignInit) isMessageIn_Data()   {}
func (*MessageIn_Traffic) isMessageIn_Data()    {}
func (*MessageIn_Abort) isMessageIn_Data()      {}

func (m *MessageIn) GetData() isMessageIn_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *MessageIn) GetKeygenInit() *KeygenInit {
	if x, ok := m.GetData().(*MessageIn_KeygenInit); ok {
		return x.KeygenInit
	}
	return nil
}

func (m *MessageIn) GetSignInit() *SignInit {
	if x, ok := m.GetData().(*MessageIn_SignInit); ok {
		return x.SignInit
	}
	return nil
}

func (m *MessageIn) GetTraffic() *TrafficIn {
	if x, ok := m.GetData().(*MessageIn_Traffic); ok {
		return x.Traffic
	}
	return nil
}

func (m *MessageIn) GetAbort() bool {
	if x, ok := m.GetData().(*MessageIn_Abort); ok {
		return x.Abort
	}
	return false
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MessageIn) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MessageIn_KeygenInit)(nil),
		(*MessageIn_SignInit)(nil),
		(*MessageIn_Traffic)(nil),
		(*MessageIn_Abort)(nil),
	}
}

type MessageOut struct {
	// Types that are valid to be assigned to Data:
	//	*MessageOut_Traffic
	//	*MessageOut_KeygenResult_
	//	*MessageOut_SignResult_
	//	*MessageOut_NeedRecover
	Data isMessageOut_Data `protobuf_oneof:"data"`
}

func (m *MessageOut) Reset()         { *m = MessageOut{} }
func (m *MessageOut) String() string { return proto.CompactTextString(m) }
func (*MessageOut) ProtoMessage()    {}
func (*MessageOut) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{4}
}
func (m *MessageOut) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MessageOut) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageOut.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MessageOut) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageOut.Merge(m, src)
}
func (m *MessageOut) XXX_Size() int {
	return m.Size()
}
func (m *MessageOut) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageOut.DiscardUnknown(m)
}

var xxx_messageInfo_MessageOut proto.InternalMessageInfo

type isMessageOut_Data interface {
	isMessageOut_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type MessageOut_Traffic struct {
	Traffic *TrafficOut `protobuf:"bytes,1,opt,name=traffic,proto3,oneof" json:"traffic,omitempty"`
}
type MessageOut_KeygenResult_ struct {
	KeygenResult *MessageOut_KeygenResult `protobuf:"bytes,2,opt,name=keygen_result,json=keygenResult,proto3,oneof" json:"keygen_result,omitempty"`
}
type MessageOut_SignResult_ struct {
	SignResult *MessageOut_SignResult `protobuf:"bytes,3,opt,name=sign_result,json=signResult,proto3,oneof" json:"sign_result,omitempty"`
}
type MessageOut_NeedRecover struct {
	NeedRecover bool `protobuf:"varint,4,opt,name=need_recover,json=needRecover,proto3,oneof" json:"need_recover,omitempty"`
}

func (*MessageOut_Traffic) isMessageOut_Data()       {}
func (*MessageOut_KeygenResult_) isMessageOut_Data() {}
func (*MessageOut_SignResult_) isMessageOut_Data()   {}
func (*MessageOut_NeedRecover) isMessageOut_Data()   {}

func (m *MessageOut) GetData() isMessageOut_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *MessageOut) GetTraffic() *TrafficOut {
	if x, ok := m.GetData().(*MessageOut_Traffic); ok {
		return x.Traffic
	}
	return nil
}

func (m *MessageOut) GetKeygenResult() *MessageOut_KeygenResult {
	if x, ok := m.GetData().(*MessageOut_KeygenResult_); ok {
		return x.KeygenResult
	}
	return nil
}

func (m *MessageOut) GetSignResult() *MessageOut_SignResult {
	if x, ok := m.GetData().(*MessageOut_SignResult_); ok {
		return x.SignResult
	}
	return nil
}

func (m *MessageOut) GetNeedRecover() bool {
	if x, ok := m.GetData().(*MessageOut_NeedRecover); ok {
		return x.NeedRecover
	}
	return false
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MessageOut) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MessageOut_Traffic)(nil),
		(*MessageOut_KeygenResult_)(nil),
		(*MessageOut_SignResult_)(nil),
		(*MessageOut_NeedRecover)(nil),
	}
}

// Keygen's response types
type MessageOut_KeygenResult struct {
	// Types that are valid to be assigned to KeygenResultData:
	//	*MessageOut_KeygenResult_Data
	//	*MessageOut_KeygenResult_Criminals
	KeygenResultData isMessageOut_KeygenResult_KeygenResultData `protobuf_oneof:"keygen_result_data"`
}

func (m *MessageOut_KeygenResult) Reset()         { *m = MessageOut_KeygenResult{} }
func (m *MessageOut_KeygenResult) String() string { return proto.CompactTextString(m) }
func (*MessageOut_KeygenResult) ProtoMessage()    {}
func (*MessageOut_KeygenResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{4, 0}
}
func (m *MessageOut_KeygenResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MessageOut_KeygenResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageOut_KeygenResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MessageOut_KeygenResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageOut_KeygenResult.Merge(m, src)
}
func (m *MessageOut_KeygenResult) XXX_Size() int {
	return m.Size()
}
func (m *MessageOut_KeygenResult) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageOut_KeygenResult.DiscardUnknown(m)
}

var xxx_messageInfo_MessageOut_KeygenResult proto.InternalMessageInfo

type isMessageOut_KeygenResult_KeygenResultData interface {
	isMessageOut_KeygenResult_KeygenResultData()
	MarshalTo([]byte) (int, error)
	Size() int
}

type MessageOut_KeygenResult_Data struct {
	Data *KeygenOutput `protobuf:"bytes,1,opt,name=data,proto3,oneof" json:"data,omitempty"`
}
type MessageOut_KeygenResult_Criminals struct {
	Criminals *MessageOut_CriminalList `protobuf:"bytes,2,opt,name=criminals,proto3,oneof" json:"criminals,omitempty"`
}

func (*MessageOut_KeygenResult_Data) isMessageOut_KeygenResult_KeygenResultData()      {}
func (*MessageOut_KeygenResult_Criminals) isMessageOut_KeygenResult_KeygenResultData() {}

func (m *MessageOut_KeygenResult) GetKeygenResultData() isMessageOut_KeygenResult_KeygenResultData {
	if m != nil {
		return m.KeygenResultData
	}
	return nil
}

func (m *MessageOut_KeygenResult) GetData() *KeygenOutput {
	if x, ok := m.GetKeygenResultData().(*MessageOut_KeygenResult_Data); ok {
		return x.Data
	}
	return nil
}

func (m *MessageOut_KeygenResult) GetCriminals() *MessageOut_CriminalList {
	if x, ok := m.GetKeygenResultData().(*MessageOut_KeygenResult_Criminals); ok {
		return x.Criminals
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MessageOut_KeygenResult) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MessageOut_KeygenResult_Data)(nil),
		(*MessageOut_KeygenResult_Criminals)(nil),
	}
}

// Sign's response types
type MessageOut_SignResult struct {
	// Types that are valid to be assigned to SignResultData:
	//	*MessageOut_SignResult_Signature
	//	*MessageOut_SignResult_Criminals
	SignResultData isMessageOut_SignResult_SignResultData `protobuf_oneof:"sign_result_data"`
}

func (m *MessageOut_SignResult) Reset()         { *m = MessageOut_SignResult{} }
func (m *MessageOut_SignResult) String() string { return proto.CompactTextString(m) }
func (*MessageOut_SignResult) ProtoMessage()    {}
func (*MessageOut_SignResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{4, 1}
}
func (m *MessageOut_SignResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MessageOut_SignResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageOut_SignResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MessageOut_SignResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageOut_SignResult.Merge(m, src)
}
func (m *MessageOut_SignResult) XXX_Size() int {
	return m.Size()
}
func (m *MessageOut_SignResult) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageOut_SignResult.DiscardUnknown(m)
}

var xxx_messageInfo_MessageOut_SignResult proto.InternalMessageInfo

type isMessageOut_SignResult_SignResultData interface {
	isMessageOut_SignResult_SignResultData()
	MarshalTo([]byte) (int, error)
	Size() int
}

type MessageOut_SignResult_Signature struct {
	Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3,oneof" json:"signature,omitempty"`
}
type MessageOut_SignResult_Criminals struct {
	Criminals *MessageOut_CriminalList `protobuf:"bytes,2,opt,name=criminals,proto3,oneof" json:"criminals,omitempty"`
}

func (*MessageOut_SignResult_Signature) isMessageOut_SignResult_SignResultData() {}
func (*MessageOut_SignResult_Criminals) isMessageOut_SignResult_SignResultData() {}

func (m *MessageOut_SignResult) GetSignResultData() isMessageOut_SignResult_SignResultData {
	if m != nil {
		return m.SignResultData
	}
	return nil
}

func (m *MessageOut_SignResult) GetSignature() []byte {
	if x, ok := m.GetSignResultData().(*MessageOut_SignResult_Signature); ok {
		return x.Signature
	}
	return nil
}

func (m *MessageOut_SignResult) GetCriminals() *MessageOut_CriminalList {
	if x, ok := m.GetSignResultData().(*MessageOut_SignResult_Criminals); ok {
		return x.Criminals
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MessageOut_SignResult) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MessageOut_SignResult_Signature)(nil),
		(*MessageOut_SignResult_Criminals)(nil),
	}
}

// Keygen/Sign failure response message
type MessageOut_CriminalList struct {
	Criminals []*MessageOut_CriminalList_Criminal `protobuf:"bytes,1,rep,name=criminals,proto3" json:"criminals,omitempty"`
}

func (m *MessageOut_CriminalList) Reset()         { *m = MessageOut_CriminalList{} }
func (m *MessageOut_CriminalList) String() string { return proto.CompactTextString(m) }
func (*MessageOut_CriminalList) ProtoMessage()    {}
func (*MessageOut_CriminalList) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{4, 2}
}
func (m *MessageOut_CriminalList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MessageOut_CriminalList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageOut_CriminalList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MessageOut_CriminalList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageOut_CriminalList.Merge(m, src)
}
func (m *MessageOut_CriminalList) XXX_Size() int {
	return m.Size()
}
func (m *MessageOut_CriminalList) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageOut_CriminalList.DiscardUnknown(m)
}

var xxx_messageInfo_MessageOut_CriminalList proto.InternalMessageInfo

func (m *MessageOut_CriminalList) GetCriminals() []*MessageOut_CriminalList_Criminal {
	if m != nil {
		return m.Criminals
	}
	return nil
}

type MessageOut_CriminalList_Criminal struct {
	PartyUid  string                                     `protobuf:"bytes,1,opt,name=party_uid,json=partyUid,proto3" json:"party_uid,omitempty"`
	CrimeType MessageOut_CriminalList_Criminal_CrimeType `protobuf:"varint,2,opt,name=crime_type,json=crimeType,proto3,enum=tss.tofnd.v1beta1.MessageOut_CriminalList_Criminal_CrimeType" json:"crime_type,omitempty"`
}

func (m *MessageOut_CriminalList_Criminal) Reset()         { *m = MessageOut_CriminalList_Criminal{} }
func (m *MessageOut_CriminalList_Criminal) String() string { return proto.CompactTextString(m) }
func (*MessageOut_CriminalList_Criminal) ProtoMessage()    {}
func (*MessageOut_CriminalList_Criminal) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{4, 2, 0}
}
func (m *MessageOut_CriminalList_Criminal) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MessageOut_CriminalList_Criminal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageOut_CriminalList_Criminal.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MessageOut_CriminalList_Criminal) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageOut_CriminalList_Criminal.Merge(m, src)
}
func (m *MessageOut_CriminalList_Criminal) XXX_Size() int {
	return m.Size()
}
func (m *MessageOut_CriminalList_Criminal) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageOut_CriminalList_Criminal.DiscardUnknown(m)
}

var xxx_messageInfo_MessageOut_CriminalList_Criminal proto.InternalMessageInfo

func (m *MessageOut_CriminalList_Criminal) GetPartyUid() string {
	if m != nil {
		return m.PartyUid
	}
	return ""
}

func (m *MessageOut_CriminalList_Criminal) GetCrimeType() MessageOut_CriminalList_Criminal_CrimeType {
	if m != nil {
		return m.CrimeType
	}
	return CRIME_TYPE_UNSPECIFIED
}

type TrafficIn struct {
	FromPartyUid string `protobuf:"bytes,1,opt,name=from_party_uid,json=fromPartyUid,proto3" json:"from_party_uid,omitempty"`
	Payload      []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	IsBroadcast  bool   `protobuf:"varint,3,opt,name=is_broadcast,json=isBroadcast,proto3" json:"is_broadcast,omitempty"`
}

func (m *TrafficIn) Reset()         { *m = TrafficIn{} }
func (m *TrafficIn) String() string { return proto.CompactTextString(m) }
func (*TrafficIn) ProtoMessage()    {}
func (*TrafficIn) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{5}
}
func (m *TrafficIn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TrafficIn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TrafficIn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TrafficIn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrafficIn.Merge(m, src)
}
func (m *TrafficIn) XXX_Size() int {
	return m.Size()
}
func (m *TrafficIn) XXX_DiscardUnknown() {
	xxx_messageInfo_TrafficIn.DiscardUnknown(m)
}

var xxx_messageInfo_TrafficIn proto.InternalMessageInfo

func (m *TrafficIn) GetFromPartyUid() string {
	if m != nil {
		return m.FromPartyUid
	}
	return ""
}

func (m *TrafficIn) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *TrafficIn) GetIsBroadcast() bool {
	if m != nil {
		return m.IsBroadcast
	}
	return false
}

type TrafficOut struct {
	ToPartyUid  string `protobuf:"bytes,1,opt,name=to_party_uid,json=toPartyUid,proto3" json:"to_party_uid,omitempty"`
	Payload     []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
	IsBroadcast bool   `protobuf:"varint,3,opt,name=is_broadcast,json=isBroadcast,proto3" json:"is_broadcast,omitempty"`
}

func (m *TrafficOut) Reset()         { *m = TrafficOut{} }
func (m *TrafficOut) String() string { return proto.CompactTextString(m) }
func (*TrafficOut) ProtoMessage()    {}
func (*TrafficOut) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{6}
}
func (m *TrafficOut) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TrafficOut) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TrafficOut.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TrafficOut) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrafficOut.Merge(m, src)
}
func (m *TrafficOut) XXX_Size() int {
	return m.Size()
}
func (m *TrafficOut) XXX_DiscardUnknown() {
	xxx_messageInfo_TrafficOut.DiscardUnknown(m)
}

var xxx_messageInfo_TrafficOut proto.InternalMessageInfo

func (m *TrafficOut) GetToPartyUid() string {
	if m != nil {
		return m.ToPartyUid
	}
	return ""
}

func (m *TrafficOut) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *TrafficOut) GetIsBroadcast() bool {
	if m != nil {
		return m.IsBroadcast
	}
	return false
}

type KeygenInit struct {
	NewKeyUid        string   `protobuf:"bytes,1,opt,name=new_key_uid,json=newKeyUid,proto3" json:"new_key_uid,omitempty"`
	PartyUids        []string `protobuf:"bytes,2,rep,name=party_uids,json=partyUids,proto3" json:"party_uids,omitempty"`
	PartyShareCounts []uint32 `protobuf:"varint,5,rep,packed,name=party_share_counts,json=partyShareCounts,proto3" json:"party_share_counts,omitempty"`
	MyPartyIndex     uint32   `protobuf:"varint,3,opt,name=my_party_index,json=myPartyIndex,proto3" json:"my_party_index,omitempty"`
	Threshold        uint32   `protobuf:"varint,4,opt,name=threshold,proto3" json:"threshold,omitempty"`
}

func (m *KeygenInit) Reset()         { *m = KeygenInit{} }
func (m *KeygenInit) String() string { return proto.CompactTextString(m) }
func (*KeygenInit) ProtoMessage()    {}
func (*KeygenInit) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{7}
}
func (m *KeygenInit) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeygenInit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeygenInit.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeygenInit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeygenInit.Merge(m, src)
}
func (m *KeygenInit) XXX_Size() int {
	return m.Size()
}
func (m *KeygenInit) XXX_DiscardUnknown() {
	xxx_messageInfo_KeygenInit.DiscardUnknown(m)
}

var xxx_messageInfo_KeygenInit proto.InternalMessageInfo

func (m *KeygenInit) GetNewKeyUid() string {
	if m != nil {
		return m.NewKeyUid
	}
	return ""
}

func (m *KeygenInit) GetPartyUids() []string {
	if m != nil {
		return m.PartyUids
	}
	return nil
}

func (m *KeygenInit) GetPartyShareCounts() []uint32 {
	if m != nil {
		return m.PartyShareCounts
	}
	return nil
}

func (m *KeygenInit) GetMyPartyIndex() uint32 {
	if m != nil {
		return m.MyPartyIndex
	}
	return 0
}

func (m *KeygenInit) GetThreshold() uint32 {
	if m != nil {
		return m.Threshold
	}
	return 0
}

type SignInit struct {
	NewSigUid     string   `protobuf:"bytes,1,opt,name=new_sig_uid,json=newSigUid,proto3" json:"new_sig_uid,omitempty"`
	KeyUid        string   `protobuf:"bytes,2,opt,name=key_uid,json=keyUid,proto3" json:"key_uid,omitempty"`
	PartyUids     []string `protobuf:"bytes,3,rep,name=party_uids,json=partyUids,proto3" json:"party_uids,omitempty"`
	MessageToSign []byte   `protobuf:"bytes,4,opt,name=message_to_sign,json=messageToSign,proto3" json:"message_to_sign,omitempty"`
}

func (m *SignInit) Reset()         { *m = SignInit{} }
func (m *SignInit) String() string { return proto.CompactTextString(m) }
func (*SignInit) ProtoMessage()    {}
func (*SignInit) Descriptor() ([]byte, []int) {
	return fileDescriptor_762181cc22940332, []int{8}
}
func (m *SignInit) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignInit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignInit.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SignInit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignInit.Merge(m, src)
}
func (m *SignInit) XXX_Size() int {
	return m.Size()
}
func (m *SignInit) XXX_DiscardUnknown() {
	xxx_messageInfo_SignInit.DiscardUnknown(m)
}

var xxx_messageInfo_SignInit proto.InternalMessageInfo

func (m *SignInit) GetNewSigUid() string {
	if m != nil {
		return m.NewSigUid
	}
	return ""
}

func (m *SignInit) GetKeyUid() string {
	if m != nil {
		return m.KeyUid
	}
	return ""
}

func (m *SignInit) GetPartyUids() []string {
	if m != nil {
		return m.PartyUids
	}
	return nil
}

func (m *SignInit) GetMessageToSign() []byte {
	if m != nil {
		return m.MessageToSign
	}
	return nil
}

func init() {
	proto.RegisterEnum("tss.tofnd.v1beta1.RecoverResponse_Response", RecoverResponse_Response_name, RecoverResponse_Response_value)
	proto.RegisterEnum("tss.tofnd.v1beta1.MessageOut_CriminalList_Criminal_CrimeType", MessageOut_CriminalList_Criminal_CrimeType_name, MessageOut_CriminalList_Criminal_CrimeType_value)
	proto.RegisterType((*RecoverRequest)(nil), "tss.tofnd.v1beta1.RecoverRequest")
	proto.RegisterType((*RecoverResponse)(nil), "tss.tofnd.v1beta1.RecoverResponse")
	proto.RegisterType((*KeygenOutput)(nil), "tss.tofnd.v1beta1.KeygenOutput")
	proto.RegisterType((*MessageIn)(nil), "tss.tofnd.v1beta1.MessageIn")
	proto.RegisterType((*MessageOut)(nil), "tss.tofnd.v1beta1.MessageOut")
	proto.RegisterType((*MessageOut_KeygenResult)(nil), "tss.tofnd.v1beta1.MessageOut.KeygenResult")
	proto.RegisterType((*MessageOut_SignResult)(nil), "tss.tofnd.v1beta1.MessageOut.SignResult")
	proto.RegisterType((*MessageOut_CriminalList)(nil), "tss.tofnd.v1beta1.MessageOut.CriminalList")
	proto.RegisterType((*MessageOut_CriminalList_Criminal)(nil), "tss.tofnd.v1beta1.MessageOut.CriminalList.Criminal")
	proto.RegisterType((*TrafficIn)(nil), "tss.tofnd.v1beta1.TrafficIn")
	proto.RegisterType((*TrafficOut)(nil), "tss.tofnd.v1beta1.TrafficOut")
	proto.RegisterType((*KeygenInit)(nil), "tss.tofnd.v1beta1.KeygenInit")
	proto.RegisterType((*SignInit)(nil), "tss.tofnd.v1beta1.SignInit")
}

func init() { proto.RegisterFile("tss/tofnd/v1beta1/tofnd.proto", fileDescriptor_762181cc22940332) }

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

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

func (m *RecoverRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecoverRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeygenOutput != nil {
		{
			size, err := m.KeygenOutput.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.KeygenInit != nil {
		{
			size, err := m.KeygenInit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RecoverResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecoverResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != 0 {
		i = encodeVarintTofnd(dAtA, i, uint64(m.Response))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *KeygenOutput) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeygenOutput) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PrivateRecoverInfo) > 0 {
		i -= len(m.PrivateRecoverInfo)
		copy(dAtA[i:], m.PrivateRecoverInfo)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.PrivateRecoverInfo)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.GroupRecoverInfo) > 0 {
		i -= len(m.GroupRecoverInfo)
		copy(dAtA[i:], m.GroupRecoverInfo)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.GroupRecoverInfo)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PubKey) > 0 {
		i -= len(m.PubKey)
		copy(dAtA[i:], m.PubKey)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.PubKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MessageIn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageIn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		{
			size := m.Data.Size()
			i -= size
			if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *MessageIn_KeygenInit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageIn_KeygenInit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.KeygenInit != nil {
		{
			size, err := m.KeygenInit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *MessageIn_SignInit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageIn_SignInit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SignInit != nil {
		{
			size, err := m.SignInit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *MessageIn_Traffic) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageIn_Traffic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Traffic != nil {
		{
			size, err := m.Traffic.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *MessageIn_Abort) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageIn_Abort) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.Abort {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x20
	return len(dAtA) - i, nil
}
func (m *MessageOut) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MessageOut) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		{
			size := m.Data.Size()
			i -= size
			if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *MessageOut_Traffic) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_Traffic) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Traffic != nil {
		{
			size, err := m.Traffic.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *MessageOut_KeygenResult_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_KeygenResult_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.KeygenResult != nil {
		{
			size, err := m.KeygenResult.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *MessageOut_SignResult_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_SignResult_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.SignResult != nil {
		{
			size, err := m.SignResult.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *MessageOut_NeedRecover) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_NeedRecover) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i--
	if m.NeedRecover {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x20
	return len(dAtA) - i, nil
}
func (m *MessageOut_KeygenResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MessageOut_KeygenResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_KeygenResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.KeygenResultData != nil {
		{
			size := m.KeygenResultData.Size()
			i -= size
			if _, err := m.KeygenResultData.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *MessageOut_KeygenResult_Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_KeygenResult_Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *MessageOut_KeygenResult_Criminals) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_KeygenResult_Criminals) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Criminals != nil {
		{
			size, err := m.Criminals.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *MessageOut_SignResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MessageOut_SignResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_SignResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SignResultData != nil {
		{
			size := m.SignResultData.Size()
			i -= size
			if _, err := m.SignResultData.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *MessageOut_SignResult_Signature) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_SignResult_Signature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Signature != nil {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *MessageOut_SignResult_Criminals) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_SignResult_Criminals) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Criminals != nil {
		{
			size, err := m.Criminals.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTofnd(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *MessageOut_CriminalList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MessageOut_CriminalList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_CriminalList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Criminals) > 0 {
		for iNdEx := len(m.Criminals) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Criminals[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTofnd(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *MessageOut_CriminalList_Criminal) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageOut_CriminalList_Criminal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CrimeType != 0 {
		i = encodeVarintTofnd(dAtA, i, uint64(m.CrimeType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PartyUid) > 0 {
		i -= len(m.PartyUid)
		copy(dAtA[i:], m.PartyUid)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.PartyUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TrafficIn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TrafficIn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsBroadcast {
		i--
		if m.IsBroadcast {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.FromPartyUid) > 0 {
		i -= len(m.FromPartyUid)
		copy(dAtA[i:], m.FromPartyUid)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.FromPartyUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TrafficOut) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TrafficOut) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsBroadcast {
		i--
		if m.IsBroadcast {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ToPartyUid) > 0 {
		i -= len(m.ToPartyUid)
		copy(dAtA[i:], m.ToPartyUid)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.ToPartyUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *KeygenInit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeygenInit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PartyShareCounts) > 0 {
		dAtA13 := make([]byte, len(m.PartyShareCounts)*10)
		var j12 int
		for _, num := range m.PartyShareCounts {
			for num >= 1<<7 {
				dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j12++
			}
			dAtA13[j12] = uint8(num)
			j12++
		}
		i -= j12
		copy(dAtA[i:], dAtA13[:j12])
		i = encodeVarintTofnd(dAtA, i, uint64(j12))
		i--
		dAtA[i] = 0x2a
	}
	if m.Threshold != 0 {
		i = encodeVarintTofnd(dAtA, i, uint64(m.Threshold))
		i--
		dAtA[i] = 0x20
	}
	if m.MyPartyIndex != 0 {
		i = encodeVarintTofnd(dAtA, i, uint64(m.MyPartyIndex))
		i--
		dAtA[i] = 0x18
	}
	if len(m.PartyUids) > 0 {
		for iNdEx := len(m.PartyUids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PartyUids[iNdEx])
			copy(dAtA[i:], m.PartyUids[iNdEx])
			i = encodeVarintTofnd(dAtA, i, uint64(len(m.PartyUids[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NewKeyUid) > 0 {
		i -= len(m.NewKeyUid)
		copy(dAtA[i:], m.NewKeyUid)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.NewKeyUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignInit) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SignInit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MessageToSign) > 0 {
		i -= len(m.MessageToSign)
		copy(dAtA[i:], m.MessageToSign)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.MessageToSign)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.PartyUids) > 0 {
		for iNdEx := len(m.PartyUids) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PartyUids[iNdEx])
			copy(dAtA[i:], m.PartyUids[iNdEx])
			i = encodeVarintTofnd(dAtA, i, uint64(len(m.PartyUids[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.KeyUid) > 0 {
		i -= len(m.KeyUid)
		copy(dAtA[i:], m.KeyUid)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.KeyUid)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.NewSigUid) > 0 {
		i -= len(m.NewSigUid)
		copy(dAtA[i:], m.NewSigUid)
		i = encodeVarintTofnd(dAtA, i, uint64(len(m.NewSigUid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintTofnd(dAtA []byte, offset int, v uint64) int {
	offset -= sovTofnd(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *RecoverRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.KeygenInit != nil {
		l = m.KeygenInit.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	if m.KeygenOutput != nil {
		l = m.KeygenOutput.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}

func (m *RecoverResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Response != 0 {
		n += 1 + sovTofnd(uint64(m.Response))
	}
	return n
}

func (m *KeygenOutput) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PubKey)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	l = len(m.GroupRecoverInfo)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	l = len(m.PrivateRecoverInfo)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}

func (m *MessageIn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	return n
}

func (m *MessageIn_KeygenInit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.KeygenInit != nil {
		l = m.KeygenInit.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageIn_SignInit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignInit != nil {
		l = m.SignInit.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageIn_Traffic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Traffic != nil {
		l = m.Traffic.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageIn_Abort) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *MessageOut) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		n += m.Data.Size()
	}
	return n
}

func (m *MessageOut_Traffic) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Traffic != nil {
		l = m.Traffic.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageOut_KeygenResult_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.KeygenResult != nil {
		l = m.KeygenResult.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageOut_SignResult_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignResult != nil {
		l = m.SignResult.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageOut_NeedRecover) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2
	return n
}
func (m *MessageOut_KeygenResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.KeygenResultData != nil {
		n += m.KeygenResultData.Size()
	}
	return n
}

func (m *MessageOut_KeygenResult_Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageOut_KeygenResult_Criminals) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Criminals != nil {
		l = m.Criminals.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageOut_SignResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SignResultData != nil {
		n += m.SignResultData.Size()
	}
	return n
}

func (m *MessageOut_SignResult_Signature) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Signature != nil {
		l = len(m.Signature)
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageOut_SignResult_Criminals) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Criminals != nil {
		l = m.Criminals.Size()
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}
func (m *MessageOut_CriminalList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Criminals) > 0 {
		for _, e := range m.Criminals {
			l = e.Size()
			n += 1 + l + sovTofnd(uint64(l))
		}
	}
	return n
}

func (m *MessageOut_CriminalList_Criminal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PartyUid)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	if m.CrimeType != 0 {
		n += 1 + sovTofnd(uint64(m.CrimeType))
	}
	return n
}

func (m *TrafficIn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FromPartyUid)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	if m.IsBroadcast {
		n += 2
	}
	return n
}

func (m *TrafficOut) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToPartyUid)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	if m.IsBroadcast {
		n += 2
	}
	return n
}

func (m *KeygenInit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NewKeyUid)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	if len(m.PartyUids) > 0 {
		for _, s := range m.PartyUids {
			l = len(s)
			n += 1 + l + sovTofnd(uint64(l))
		}
	}
	if m.MyPartyIndex != 0 {
		n += 1 + sovTofnd(uint64(m.MyPartyIndex))
	}
	if m.Threshold != 0 {
		n += 1 + sovTofnd(uint64(m.Threshold))
	}
	if len(m.PartyShareCounts) > 0 {
		l = 0
		for _, e := range m.PartyShareCounts {
			l += sovTofnd(uint64(e))
		}
		n += 1 + sovTofnd(uint64(l)) + l
	}
	return n
}

func (m *SignInit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NewSigUid)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	l = len(m.KeyUid)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	if len(m.PartyUids) > 0 {
		for _, s := range m.PartyUids {
			l = len(s)
			n += 1 + l + sovTofnd(uint64(l))
		}
	}
	l = len(m.MessageToSign)
	if l > 0 {
		n += 1 + l + sovTofnd(uint64(l))
	}
	return n
}

func sovTofnd(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTofnd(x uint64) (n int) {
	return sovTofnd(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RecoverRequest) 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 ErrIntOverflowTofnd
			}
			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: RecoverRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecoverRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeygenInit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KeygenInit == nil {
				m.KeygenInit = &KeygenInit{}
			}
			if err := m.KeygenInit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeygenOutput", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KeygenOutput == nil {
				m.KeygenOutput = &KeygenOutput{}
			}
			if err := m.KeygenOutput.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecoverResponse) 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 ErrIntOverflowTofnd
			}
			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: RecoverResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecoverResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType)
			}
			m.Response = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Response |= RecoverResponse_Response(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeygenOutput) 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 ErrIntOverflowTofnd
			}
			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: KeygenOutput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeygenOutput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PubKey = append(m.PubKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PubKey == nil {
				m.PubKey = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupRecoverInfo", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupRecoverInfo = append(m.GroupRecoverInfo[:0], dAtA[iNdEx:postIndex]...)
			if m.GroupRecoverInfo == nil {
				m.GroupRecoverInfo = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrivateRecoverInfo", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrivateRecoverInfo = append(m.PrivateRecoverInfo[:0], dAtA[iNdEx:postIndex]...)
			if m.PrivateRecoverInfo == nil {
				m.PrivateRecoverInfo = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageIn) 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 ErrIntOverflowTofnd
			}
			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: MessageIn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageIn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeygenInit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &KeygenInit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &MessageIn_KeygenInit{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignInit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &SignInit{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &MessageIn_SignInit{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Traffic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TrafficIn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &MessageIn_Traffic{v}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Abort", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Data = &MessageIn_Abort{b}
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageOut) 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 ErrIntOverflowTofnd
			}
			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: MessageOut: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageOut: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Traffic", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &TrafficOut{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &MessageOut_Traffic{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeygenResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MessageOut_KeygenResult{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &MessageOut_KeygenResult_{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MessageOut_SignResult{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &MessageOut_SignResult_{v}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NeedRecover", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Data = &MessageOut_NeedRecover{b}
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageOut_KeygenResult) 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 ErrIntOverflowTofnd
			}
			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: KeygenResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeygenResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &KeygenOutput{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.KeygenResultData = &MessageOut_KeygenResult_Data{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Criminals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MessageOut_CriminalList{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.KeygenResultData = &MessageOut_KeygenResult_Criminals{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageOut_SignResult) 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 ErrIntOverflowTofnd
			}
			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: SignResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := make([]byte, postIndex-iNdEx)
			copy(v, dAtA[iNdEx:postIndex])
			m.SignResultData = &MessageOut_SignResult_Signature{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Criminals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MessageOut_CriminalList{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.SignResultData = &MessageOut_SignResult_Criminals{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageOut_CriminalList) 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 ErrIntOverflowTofnd
			}
			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: CriminalList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CriminalList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Criminals", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Criminals = append(m.Criminals, &MessageOut_CriminalList_Criminal{})
			if err := m.Criminals[len(m.Criminals)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageOut_CriminalList_Criminal) 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 ErrIntOverflowTofnd
			}
			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: Criminal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Criminal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartyUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PartyUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CrimeType", wireType)
			}
			m.CrimeType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CrimeType |= MessageOut_CriminalList_Criminal_CrimeType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TrafficIn) 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 ErrIntOverflowTofnd
			}
			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: TrafficIn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TrafficIn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromPartyUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromPartyUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsBroadcast", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsBroadcast = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TrafficOut) 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 ErrIntOverflowTofnd
			}
			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: TrafficOut: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TrafficOut: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToPartyUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToPartyUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsBroadcast", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsBroadcast = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeygenInit) 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 ErrIntOverflowTofnd
			}
			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: KeygenInit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeygenInit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewKeyUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewKeyUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartyUids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PartyUids = append(m.PartyUids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MyPartyIndex", wireType)
			}
			m.MyPartyIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MyPartyIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threshold", wireType)
			}
			m.Threshold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Threshold |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTofnd
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PartyShareCounts = append(m.PartyShareCounts, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTofnd
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTofnd
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTofnd
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PartyShareCounts) == 0 {
					m.PartyShareCounts = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTofnd
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PartyShareCounts = append(m.PartyShareCounts, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PartyShareCounts", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SignInit) 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 ErrIntOverflowTofnd
			}
			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: SignInit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignInit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewSigUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewSigUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KeyUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartyUids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PartyUids = append(m.PartyUids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageToSign", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTofnd
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTofnd
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MessageToSign = append(m.MessageToSign[:0], dAtA[iNdEx:postIndex]...)
			if m.MessageToSign == nil {
				m.MessageToSign = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTofnd(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTofnd
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTofnd(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTofnd
			}
			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, ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTofnd
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTofnd
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTofnd
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTofnd
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTofnd        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTofnd          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTofnd = fmt.Errorf("proto: unexpected end of group")
)