gitlab.com/aquachain/aquachain@v1.17.16-rc3.0.20221018032414-e3ddf1e1c055/aqua/accounts/usbwallet/internal/trezor/messages.pb.go

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

package trezor

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

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

//*
// Mapping between Trezor wire identifier (uint) and a protobuf message
type MessageType int32

const (
	MessageType_MessageType_Initialize                MessageType = 0
	MessageType_MessageType_Ping                      MessageType = 1
	MessageType_MessageType_Success                   MessageType = 2
	MessageType_MessageType_Failure                   MessageType = 3
	MessageType_MessageType_ChangePin                 MessageType = 4
	MessageType_MessageType_WipeDevice                MessageType = 5
	MessageType_MessageType_FirmwareErase             MessageType = 6
	MessageType_MessageType_FirmwareUpload            MessageType = 7
	MessageType_MessageType_FirmwareRequest           MessageType = 8
	MessageType_MessageType_GetEntropy                MessageType = 9
	MessageType_MessageType_Entropy                   MessageType = 10
	MessageType_MessageType_GetPublicKey              MessageType = 11
	MessageType_MessageType_PublicKey                 MessageType = 12
	MessageType_MessageType_LoadDevice                MessageType = 13
	MessageType_MessageType_ResetDevice               MessageType = 14
	MessageType_MessageType_SignTx                    MessageType = 15
	MessageType_MessageType_SimpleSignTx              MessageType = 16 // Deprecated: Do not use.
	MessageType_MessageType_Features                  MessageType = 17
	MessageType_MessageType_PinMatrixRequest          MessageType = 18
	MessageType_MessageType_PinMatrixAck              MessageType = 19
	MessageType_MessageType_Cancel                    MessageType = 20
	MessageType_MessageType_TxRequest                 MessageType = 21
	MessageType_MessageType_TxAck                     MessageType = 22
	MessageType_MessageType_CipherKeyValue            MessageType = 23
	MessageType_MessageType_ClearSession              MessageType = 24
	MessageType_MessageType_ApplySettings             MessageType = 25
	MessageType_MessageType_ButtonRequest             MessageType = 26
	MessageType_MessageType_ButtonAck                 MessageType = 27
	MessageType_MessageType_ApplyFlags                MessageType = 28
	MessageType_MessageType_GetAddress                MessageType = 29
	MessageType_MessageType_Address                   MessageType = 30
	MessageType_MessageType_SelfTest                  MessageType = 32
	MessageType_MessageType_BackupDevice              MessageType = 34
	MessageType_MessageType_EntropyRequest            MessageType = 35
	MessageType_MessageType_EntropyAck                MessageType = 36
	MessageType_MessageType_SignMessage               MessageType = 38
	MessageType_MessageType_VerifyMessage             MessageType = 39
	MessageType_MessageType_MessageSignature          MessageType = 40
	MessageType_MessageType_PassphraseRequest         MessageType = 41
	MessageType_MessageType_PassphraseAck             MessageType = 42
	MessageType_MessageType_EstimateTxSize            MessageType = 43 // Deprecated: Do not use.
	MessageType_MessageType_TxSize                    MessageType = 44 // Deprecated: Do not use.
	MessageType_MessageType_RecoveryDevice            MessageType = 45
	MessageType_MessageType_WordRequest               MessageType = 46
	MessageType_MessageType_WordAck                   MessageType = 47
	MessageType_MessageType_CipheredKeyValue          MessageType = 48
	MessageType_MessageType_EncryptMessage            MessageType = 49 // Deprecated: Do not use.
	MessageType_MessageType_EncryptedMessage          MessageType = 50 // Deprecated: Do not use.
	MessageType_MessageType_DecryptMessage            MessageType = 51 // Deprecated: Do not use.
	MessageType_MessageType_DecryptedMessage          MessageType = 52 // Deprecated: Do not use.
	MessageType_MessageType_SignIdentity              MessageType = 53
	MessageType_MessageType_SignedIdentity            MessageType = 54
	MessageType_MessageType_GetFeatures               MessageType = 55
	MessageType_MessageType_AquachainGetAddress       MessageType = 56
	MessageType_MessageType_AquachainAddress          MessageType = 57
	MessageType_MessageType_AquachainSignTx           MessageType = 58
	MessageType_MessageType_AquachainTxRequest        MessageType = 59
	MessageType_MessageType_AquachainTxAck            MessageType = 60
	MessageType_MessageType_GetECDHSessionKey         MessageType = 61
	MessageType_MessageType_ECDHSessionKey            MessageType = 62
	MessageType_MessageType_SetU2FCounter             MessageType = 63
	MessageType_MessageType_AquachainSignMessage      MessageType = 64
	MessageType_MessageType_AquachainVerifyMessage    MessageType = 65
	MessageType_MessageType_AquachainMessageSignature MessageType = 66
	MessageType_MessageType_DebugLinkDecision         MessageType = 100
	MessageType_MessageType_DebugLinkGetState         MessageType = 101
	MessageType_MessageType_DebugLinkState            MessageType = 102
	MessageType_MessageType_DebugLinkStop             MessageType = 103
	MessageType_MessageType_DebugLinkLog              MessageType = 104
	MessageType_MessageType_DebugLinkMemoryRead       MessageType = 110
	MessageType_MessageType_DebugLinkMemory           MessageType = 111
	MessageType_MessageType_DebugLinkMemoryWrite      MessageType = 112
	MessageType_MessageType_DebugLinkFlashErase       MessageType = 113
)

var MessageType_name = map[int32]string{
	0:   "MessageType_Initialize",
	1:   "MessageType_Ping",
	2:   "MessageType_Success",
	3:   "MessageType_Failure",
	4:   "MessageType_ChangePin",
	5:   "MessageType_WipeDevice",
	6:   "MessageType_FirmwareErase",
	7:   "MessageType_FirmwareUpload",
	8:   "MessageType_FirmwareRequest",
	9:   "MessageType_GetEntropy",
	10:  "MessageType_Entropy",
	11:  "MessageType_GetPublicKey",
	12:  "MessageType_PublicKey",
	13:  "MessageType_LoadDevice",
	14:  "MessageType_ResetDevice",
	15:  "MessageType_SignTx",
	16:  "MessageType_SimpleSignTx",
	17:  "MessageType_Features",
	18:  "MessageType_PinMatrixRequest",
	19:  "MessageType_PinMatrixAck",
	20:  "MessageType_Cancel",
	21:  "MessageType_TxRequest",
	22:  "MessageType_TxAck",
	23:  "MessageType_CipherKeyValue",
	24:  "MessageType_ClearSession",
	25:  "MessageType_ApplySettings",
	26:  "MessageType_ButtonRequest",
	27:  "MessageType_ButtonAck",
	28:  "MessageType_ApplyFlags",
	29:  "MessageType_GetAddress",
	30:  "MessageType_Address",
	32:  "MessageType_SelfTest",
	34:  "MessageType_BackupDevice",
	35:  "MessageType_EntropyRequest",
	36:  "MessageType_EntropyAck",
	38:  "MessageType_SignMessage",
	39:  "MessageType_VerifyMessage",
	40:  "MessageType_MessageSignature",
	41:  "MessageType_PassphraseRequest",
	42:  "MessageType_PassphraseAck",
	43:  "MessageType_EstimateTxSize",
	44:  "MessageType_TxSize",
	45:  "MessageType_RecoveryDevice",
	46:  "MessageType_WordRequest",
	47:  "MessageType_WordAck",
	48:  "MessageType_CipheredKeyValue",
	49:  "MessageType_EncryptMessage",
	50:  "MessageType_EncryptedMessage",
	51:  "MessageType_DecryptMessage",
	52:  "MessageType_DecryptedMessage",
	53:  "MessageType_SignIdentity",
	54:  "MessageType_SignedIdentity",
	55:  "MessageType_GetFeatures",
	56:  "MessageType_AquachainGetAddress",
	57:  "MessageType_AquachainAddress",
	58:  "MessageType_AquachainSignTx",
	59:  "MessageType_AquachainTxRequest",
	60:  "MessageType_AquachainTxAck",
	61:  "MessageType_GetECDHSessionKey",
	62:  "MessageType_ECDHSessionKey",
	63:  "MessageType_SetU2FCounter",
	64:  "MessageType_AquachainSignMessage",
	65:  "MessageType_AquachainVerifyMessage",
	66:  "MessageType_AquachainMessageSignature",
	100: "MessageType_DebugLinkDecision",
	101: "MessageType_DebugLinkGetState",
	102: "MessageType_DebugLinkState",
	103: "MessageType_DebugLinkStop",
	104: "MessageType_DebugLinkLog",
	110: "MessageType_DebugLinkMemoryRead",
	111: "MessageType_DebugLinkMemory",
	112: "MessageType_DebugLinkMemoryWrite",
	113: "MessageType_DebugLinkFlashErase",
}

var MessageType_value = map[string]int32{
	"MessageType_Initialize":                0,
	"MessageType_Ping":                      1,
	"MessageType_Success":                   2,
	"MessageType_Failure":                   3,
	"MessageType_ChangePin":                 4,
	"MessageType_WipeDevice":                5,
	"MessageType_FirmwareErase":             6,
	"MessageType_FirmwareUpload":            7,
	"MessageType_FirmwareRequest":           8,
	"MessageType_GetEntropy":                9,
	"MessageType_Entropy":                   10,
	"MessageType_GetPublicKey":              11,
	"MessageType_PublicKey":                 12,
	"MessageType_LoadDevice":                13,
	"MessageType_ResetDevice":               14,
	"MessageType_SignTx":                    15,
	"MessageType_SimpleSignTx":              16,
	"MessageType_Features":                  17,
	"MessageType_PinMatrixRequest":          18,
	"MessageType_PinMatrixAck":              19,
	"MessageType_Cancel":                    20,
	"MessageType_TxRequest":                 21,
	"MessageType_TxAck":                     22,
	"MessageType_CipherKeyValue":            23,
	"MessageType_ClearSession":              24,
	"MessageType_ApplySettings":             25,
	"MessageType_ButtonRequest":             26,
	"MessageType_ButtonAck":                 27,
	"MessageType_ApplyFlags":                28,
	"MessageType_GetAddress":                29,
	"MessageType_Address":                   30,
	"MessageType_SelfTest":                  32,
	"MessageType_BackupDevice":              34,
	"MessageType_EntropyRequest":            35,
	"MessageType_EntropyAck":                36,
	"MessageType_SignMessage":               38,
	"MessageType_VerifyMessage":             39,
	"MessageType_MessageSignature":          40,
	"MessageType_PassphraseRequest":         41,
	"MessageType_PassphraseAck":             42,
	"MessageType_EstimateTxSize":            43,
	"MessageType_TxSize":                    44,
	"MessageType_RecoveryDevice":            45,
	"MessageType_WordRequest":               46,
	"MessageType_WordAck":                   47,
	"MessageType_CipheredKeyValue":          48,
	"MessageType_EncryptMessage":            49,
	"MessageType_EncryptedMessage":          50,
	"MessageType_DecryptMessage":            51,
	"MessageType_DecryptedMessage":          52,
	"MessageType_SignIdentity":              53,
	"MessageType_SignedIdentity":            54,
	"MessageType_GetFeatures":               55,
	"MessageType_AquachainGetAddress":       56,
	"MessageType_AquachainAddress":          57,
	"MessageType_AquachainSignTx":           58,
	"MessageType_AquachainTxRequest":        59,
	"MessageType_AquachainTxAck":            60,
	"MessageType_GetECDHSessionKey":         61,
	"MessageType_ECDHSessionKey":            62,
	"MessageType_SetU2FCounter":             63,
	"MessageType_AquachainSignMessage":      64,
	"MessageType_AquachainVerifyMessage":    65,
	"MessageType_AquachainMessageSignature": 66,
	"MessageType_DebugLinkDecision":         100,
	"MessageType_DebugLinkGetState":         101,
	"MessageType_DebugLinkState":            102,
	"MessageType_DebugLinkStop":             103,
	"MessageType_DebugLinkLog":              104,
	"MessageType_DebugLinkMemoryRead":       110,
	"MessageType_DebugLinkMemory":           111,
	"MessageType_DebugLinkMemoryWrite":      112,
	"MessageType_DebugLinkFlashErase":       113,
}

func (x MessageType) Enum() *MessageType {
	p := new(MessageType)
	*p = x
	return p
}

func (x MessageType) String() string {
	return proto.EnumName(MessageType_name, int32(x))
}

func (x *MessageType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
	if err != nil {
		return err
	}
	*x = MessageType(value)
	return nil
}

func (MessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_4dc296cbfe5ffcd5, []int{0}
}

//*
// Request: Reset device to default state and ask for device details
// @next Features
type Initialize struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Initialize proto.InternalMessageInfo

//*
// Request: Ask for device details (no device reset)
// @next Features
type GetFeatures struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetFeatures proto.InternalMessageInfo

//*
// Response: Reports various information about the device
// @prev Initialize
// @prev GetFeatures
type Features struct {
	Vendor               *string     `protobuf:"bytes,1,opt,name=vendor" json:"vendor,omitempty"`
	MajorVersion         *uint32     `protobuf:"varint,2,opt,name=major_version,json=majorVersion" json:"major_version,omitempty"`
	MinorVersion         *uint32     `protobuf:"varint,3,opt,name=minor_version,json=minorVersion" json:"minor_version,omitempty"`
	PatchVersion         *uint32     `protobuf:"varint,4,opt,name=patch_version,json=patchVersion" json:"patch_version,omitempty"`
	BootloaderMode       *bool       `protobuf:"varint,5,opt,name=bootloader_mode,json=bootloaderMode" json:"bootloader_mode,omitempty"`
	DeviceId             *string     `protobuf:"bytes,6,opt,name=device_id,json=deviceId" json:"device_id,omitempty"`
	PinProtection        *bool       `protobuf:"varint,7,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
	PassphraseProtection *bool       `protobuf:"varint,8,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
	Language             *string     `protobuf:"bytes,9,opt,name=language" json:"language,omitempty"`
	Label                *string     `protobuf:"bytes,10,opt,name=label" json:"label,omitempty"`
	Coins                []*CoinType `protobuf:"bytes,11,rep,name=coins" json:"coins,omitempty"`
	Initialized          *bool       `protobuf:"varint,12,opt,name=initialized" json:"initialized,omitempty"`
	Revision             []byte      `protobuf:"bytes,13,opt,name=revision" json:"revision,omitempty"`
	BootloaderHash       []byte      `protobuf:"bytes,14,opt,name=bootloader_hash,json=bootloaderHash" json:"bootloader_hash,omitempty"`
	Imported             *bool       `protobuf:"varint,15,opt,name=imported" json:"imported,omitempty"`
	PinCached            *bool       `protobuf:"varint,16,opt,name=pin_cached,json=pinCached" json:"pin_cached,omitempty"`
	PassphraseCached     *bool       `protobuf:"varint,17,opt,name=passphrase_cached,json=passphraseCached" json:"passphrase_cached,omitempty"`
	FirmwarePresent      *bool       `protobuf:"varint,18,opt,name=firmware_present,json=firmwarePresent" json:"firmware_present,omitempty"`
	NeedsBackup          *bool       `protobuf:"varint,19,opt,name=needs_backup,json=needsBackup" json:"needs_backup,omitempty"`
	Flags                *uint32     `protobuf:"varint,20,opt,name=flags" json:"flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_Features proto.InternalMessageInfo

func (m *Features) GetVendor() string {
	if m != nil && m.Vendor != nil {
		return *m.Vendor
	}
	return ""
}

func (m *Features) GetMajorVersion() uint32 {
	if m != nil && m.MajorVersion != nil {
		return *m.MajorVersion
	}
	return 0
}

func (m *Features) GetMinorVersion() uint32 {
	if m != nil && m.MinorVersion != nil {
		return *m.MinorVersion
	}
	return 0
}

func (m *Features) GetPatchVersion() uint32 {
	if m != nil && m.PatchVersion != nil {
		return *m.PatchVersion
	}
	return 0
}

func (m *Features) GetBootloaderMode() bool {
	if m != nil && m.BootloaderMode != nil {
		return *m.BootloaderMode
	}
	return false
}

func (m *Features) GetDeviceId() string {
	if m != nil && m.DeviceId != nil {
		return *m.DeviceId
	}
	return ""
}

func (m *Features) GetPinProtection() bool {
	if m != nil && m.PinProtection != nil {
		return *m.PinProtection
	}
	return false
}

func (m *Features) GetPassphraseProtection() bool {
	if m != nil && m.PassphraseProtection != nil {
		return *m.PassphraseProtection
	}
	return false
}

func (m *Features) GetLanguage() string {
	if m != nil && m.Language != nil {
		return *m.Language
	}
	return ""
}

func (m *Features) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *Features) GetCoins() []*CoinType {
	if m != nil {
		return m.Coins
	}
	return nil
}

func (m *Features) GetInitialized() bool {
	if m != nil && m.Initialized != nil {
		return *m.Initialized
	}
	return false
}

func (m *Features) GetRevision() []byte {
	if m != nil {
		return m.Revision
	}
	return nil
}

func (m *Features) GetBootloaderHash() []byte {
	if m != nil {
		return m.BootloaderHash
	}
	return nil
}

func (m *Features) GetImported() bool {
	if m != nil && m.Imported != nil {
		return *m.Imported
	}
	return false
}

func (m *Features) GetPinCached() bool {
	if m != nil && m.PinCached != nil {
		return *m.PinCached
	}
	return false
}

func (m *Features) GetPassphraseCached() bool {
	if m != nil && m.PassphraseCached != nil {
		return *m.PassphraseCached
	}
	return false
}

func (m *Features) GetFirmwarePresent() bool {
	if m != nil && m.FirmwarePresent != nil {
		return *m.FirmwarePresent
	}
	return false
}

func (m *Features) GetNeedsBackup() bool {
	if m != nil && m.NeedsBackup != nil {
		return *m.NeedsBackup
	}
	return false
}

func (m *Features) GetFlags() uint32 {
	if m != nil && m.Flags != nil {
		return *m.Flags
	}
	return 0
}

//*
// Request: clear session (removes cached PIN, passphrase, etc).
// @next Success
type ClearSession struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ClearSession proto.InternalMessageInfo

//*
// Request: change language and/or label of the device
// @next Success
// @next Failure
// @next ButtonRequest
// @next PinMatrixRequest
type ApplySettings struct {
	Language             *string  `protobuf:"bytes,1,opt,name=language" json:"language,omitempty"`
	Label                *string  `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"`
	UsePassphrase        *bool    `protobuf:"varint,3,opt,name=use_passphrase,json=usePassphrase" json:"use_passphrase,omitempty"`
	Homescreen           []byte   `protobuf:"bytes,4,opt,name=homescreen" json:"homescreen,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ApplySettings proto.InternalMessageInfo

func (m *ApplySettings) GetLanguage() string {
	if m != nil && m.Language != nil {
		return *m.Language
	}
	return ""
}

func (m *ApplySettings) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *ApplySettings) GetUsePassphrase() bool {
	if m != nil && m.UsePassphrase != nil {
		return *m.UsePassphrase
	}
	return false
}

func (m *ApplySettings) GetHomescreen() []byte {
	if m != nil {
		return m.Homescreen
	}
	return nil
}

//*
// Request: set flags of the device
// @next Success
// @next Failure
type ApplyFlags struct {
	Flags                *uint32  `protobuf:"varint,1,opt,name=flags" json:"flags,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ApplyFlags proto.InternalMessageInfo

func (m *ApplyFlags) GetFlags() uint32 {
	if m != nil && m.Flags != nil {
		return *m.Flags
	}
	return 0
}

//*
// Request: Starts workflow for setting/changing/removing the PIN
// @next ButtonRequest
// @next PinMatrixRequest
type ChangePin struct {
	Remove               *bool    `protobuf:"varint,1,opt,name=remove" json:"remove,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ChangePin proto.InternalMessageInfo

func (m *ChangePin) GetRemove() bool {
	if m != nil && m.Remove != nil {
		return *m.Remove
	}
	return false
}

//*
// Request: Test if the device is alive, device sends back the message in
// Success response
// @next Success
type Ping struct {
	Message              *string  `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
	ButtonProtection     *bool    `protobuf:"varint,2,opt,name=button_protection,json=buttonProtection" json:"button_protection,omitempty"`
	PinProtection        *bool    `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
	PassphraseProtection *bool    `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Ping proto.InternalMessageInfo

func (m *Ping) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.Message
	}
	return ""
}

func (m *Ping) GetButtonProtection() bool {
	if m != nil && m.ButtonProtection != nil {
		return *m.ButtonProtection
	}
	return false
}

func (m *Ping) GetPinProtection() bool {
	if m != nil && m.PinProtection != nil {
		return *m.PinProtection
	}
	return false
}

func (m *Ping) GetPassphraseProtection() bool {
	if m != nil && m.PassphraseProtection != nil {
		return *m.PassphraseProtection
	}
	return false
}

//*
// Response: Success of the previous request
type Success struct {
	Message              *string  `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Success proto.InternalMessageInfo

func (m *Success) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.Message
	}
	return ""
}

//*
// Response: Failure of the previous request
type Failure struct {
	Code                 *FailureType `protobuf:"varint,1,opt,name=code,enum=FailureType" json:"code,omitempty"`
	Message              *string      `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_Failure proto.InternalMessageInfo

func (m *Failure) GetCode() FailureType {
	if m != nil && m.Code != nil {
		return *m.Code
	}
	return FailureType_Failure_UnexpectedMessage
}

func (m *Failure) GetMessage() string {
	if m != nil && m.Message != nil {
		return *m.Message
	}
	return ""
}

//*
// Response: Device is waiting for HW button press.
// @next ButtonAck
// @next Cancel
type ButtonRequest struct {
	Code                 *ButtonRequestType `protobuf:"varint,1,opt,name=code,enum=ButtonRequestType" json:"code,omitempty"`
	Data                 *string            `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_ButtonRequest proto.InternalMessageInfo

func (m *ButtonRequest) GetCode() ButtonRequestType {
	if m != nil && m.Code != nil {
		return *m.Code
	}
	return ButtonRequestType_ButtonRequest_Other
}

func (m *ButtonRequest) GetData() string {
	if m != nil && m.Data != nil {
		return *m.Data
	}
	return ""
}

//*
// Request: Computer agrees to wait for HW button press
// @prev ButtonRequest
type ButtonAck struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ButtonAck proto.InternalMessageInfo

//*
// Response: Device is asking computer to show PIN matrix and awaits PIN encoded
// using this matrix scheme
// @next PinMatrixAck
// @next Cancel
type PinMatrixRequest struct {
	Type                 *PinMatrixRequestType `protobuf:"varint,1,opt,name=type,enum=PinMatrixRequestType" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

var xxx_messageInfo_PinMatrixRequest proto.InternalMessageInfo

func (m *PinMatrixRequest) GetType() PinMatrixRequestType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return PinMatrixRequestType_PinMatrixRequestType_Current
}

//*
// Request: Computer responds with encoded PIN
// @prev PinMatrixRequest
type PinMatrixAck struct {
	Pin                  *string  `protobuf:"bytes,1,req,name=pin" json:"pin,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PinMatrixAck proto.InternalMessageInfo

func (m *PinMatrixAck) GetPin() string {
	if m != nil && m.Pin != nil {
		return *m.Pin
	}
	return ""
}

//*
// Request: Abort last operation that required user interaction
// @prev ButtonRequest
// @prev PinMatrixRequest
// @prev PassphraseRequest
type Cancel struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Cancel proto.InternalMessageInfo

//*
// Response: Device awaits encryption passphrase
// @next PassphraseAck
// @next Cancel
type PassphraseRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PassphraseRequest proto.InternalMessageInfo

//*
// Request: Send passphrase back
// @prev PassphraseRequest
type PassphraseAck struct {
	Passphrase           *string  `protobuf:"bytes,1,req,name=passphrase" json:"passphrase,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_PassphraseAck proto.InternalMessageInfo

func (m *PassphraseAck) GetPassphrase() string {
	if m != nil && m.Passphrase != nil {
		return *m.Passphrase
	}
	return ""
}

//*
// Request: Request a sample of random data generated by hardware RNG. May be
// used for testing.
// @next ButtonRequest
// @next Entropy
// @next Failure
type GetEntropy struct {
	Size_                *uint32  `protobuf:"varint,1,req,name=size" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetEntropy proto.InternalMessageInfo

func (m *GetEntropy) GetSize_() uint32 {
	if m != nil && m.Size_ != nil {
		return *m.Size_
	}
	return 0
}

//*
// Response: Reply with random data generated by internal RNG
// @prev GetEntropy
type Entropy struct {
	Entropy              []byte   `protobuf:"bytes,1,req,name=entropy" json:"entropy,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Entropy proto.InternalMessageInfo

func (m *Entropy) GetEntropy() []byte {
	if m != nil {
		return m.Entropy
	}
	return nil
}

//*
// Request: Ask device for public key corresponding to address_n path
// @next PassphraseRequest
// @next PublicKey
// @next Failure
type GetPublicKey struct {
	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	EcdsaCurveName       *string  `protobuf:"bytes,2,opt,name=ecdsa_curve_name,json=ecdsaCurveName" json:"ecdsa_curve_name,omitempty"`
	ShowDisplay          *bool    `protobuf:"varint,3,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
	CoinName             *string  `protobuf:"bytes,4,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetPublicKey proto.InternalMessageInfo

const Default_GetPublicKey_CoinName string = "Bitcoin"

func (m *GetPublicKey) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *GetPublicKey) GetEcdsaCurveName() string {
	if m != nil && m.EcdsaCurveName != nil {
		return *m.EcdsaCurveName
	}
	return ""
}

func (m *GetPublicKey) GetShowDisplay() bool {
	if m != nil && m.ShowDisplay != nil {
		return *m.ShowDisplay
	}
	return false
}

func (m *GetPublicKey) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_GetPublicKey_CoinName
}

//*
// Response: Contains public key derived from device private seed
// @prev GetPublicKey
type PublicKey struct {
	Node                 *HDNodeType `protobuf:"bytes,1,req,name=node" json:"node,omitempty"`
	Xpub                 *string     `protobuf:"bytes,2,opt,name=xpub" json:"xpub,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_PublicKey proto.InternalMessageInfo

func (m *PublicKey) GetNode() *HDNodeType {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *PublicKey) GetXpub() string {
	if m != nil && m.Xpub != nil {
		return *m.Xpub
	}
	return ""
}

//*
// Request: Ask device for address corresponding to address_n path
// @next PassphraseRequest
// @next Address
// @next Failure
type GetAddress struct {
	AddressN             []uint32                  `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	CoinName             *string                   `protobuf:"bytes,2,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	ShowDisplay          *bool                     `protobuf:"varint,3,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
	Multisig             *MultisigRedeemScriptType `protobuf:"bytes,4,opt,name=multisig" json:"multisig,omitempty"`
	ScriptType           *InputScriptType          `protobuf:"varint,5,opt,name=script_type,json=scriptType,enum=InputScriptType,def=0" json:"script_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

var xxx_messageInfo_GetAddress proto.InternalMessageInfo

const Default_GetAddress_CoinName string = "Bitcoin"
const Default_GetAddress_ScriptType InputScriptType = InputScriptType_SPENDADDRESS

func (m *GetAddress) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *GetAddress) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_GetAddress_CoinName
}

func (m *GetAddress) GetShowDisplay() bool {
	if m != nil && m.ShowDisplay != nil {
		return *m.ShowDisplay
	}
	return false
}

func (m *GetAddress) GetMultisig() *MultisigRedeemScriptType {
	if m != nil {
		return m.Multisig
	}
	return nil
}

func (m *GetAddress) GetScriptType() InputScriptType {
	if m != nil && m.ScriptType != nil {
		return *m.ScriptType
	}
	return Default_GetAddress_ScriptType
}

//*
// Request: Ask device for Aquachain address corresponding to address_n path
// @next PassphraseRequest
// @next AquachainAddress
// @next Failure
type AquachainGetAddress struct {
	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	ShowDisplay          *bool    `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainGetAddress proto.InternalMessageInfo

func (m *AquachainGetAddress) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *AquachainGetAddress) GetShowDisplay() bool {
	if m != nil && m.ShowDisplay != nil {
		return *m.ShowDisplay
	}
	return false
}

//*
// Response: Contains address derived from device private seed
// @prev GetAddress
type Address struct {
	Address              *string  `protobuf:"bytes,1,req,name=address" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Address proto.InternalMessageInfo

func (m *Address) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

//*
// Response: Contains an Aquachain address derived from device private seed
// @prev AquachainGetAddress
type AquachainAddress struct {
	Address              []byte   `protobuf:"bytes,1,req,name=address" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainAddress proto.InternalMessageInfo

func (m *AquachainAddress) GetAddress() []byte {
	if m != nil {
		return m.Address
	}
	return nil
}

//*
// Request: Request device to wipe all sensitive data and settings
// @next ButtonRequest
type WipeDevice struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WipeDevice proto.InternalMessageInfo

//*
// Request: Load seed and related internal settings from the computer
// @next ButtonRequest
// @next Success
// @next Failure
type LoadDevice struct {
	Mnemonic             *string     `protobuf:"bytes,1,opt,name=mnemonic" json:"mnemonic,omitempty"`
	Node                 *HDNodeType `protobuf:"bytes,2,opt,name=node" json:"node,omitempty"`
	Pin                  *string     `protobuf:"bytes,3,opt,name=pin" json:"pin,omitempty"`
	PassphraseProtection *bool       `protobuf:"varint,4,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
	Language             *string     `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
	Label                *string     `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
	SkipChecksum         *bool       `protobuf:"varint,7,opt,name=skip_checksum,json=skipChecksum" json:"skip_checksum,omitempty"`
	U2FCounter           *uint32     `protobuf:"varint,8,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_LoadDevice proto.InternalMessageInfo

const Default_LoadDevice_Language string = "english"

func (m *LoadDevice) GetMnemonic() string {
	if m != nil && m.Mnemonic != nil {
		return *m.Mnemonic
	}
	return ""
}

func (m *LoadDevice) GetNode() *HDNodeType {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *LoadDevice) GetPin() string {
	if m != nil && m.Pin != nil {
		return *m.Pin
	}
	return ""
}

func (m *LoadDevice) GetPassphraseProtection() bool {
	if m != nil && m.PassphraseProtection != nil {
		return *m.PassphraseProtection
	}
	return false
}

func (m *LoadDevice) GetLanguage() string {
	if m != nil && m.Language != nil {
		return *m.Language
	}
	return Default_LoadDevice_Language
}

func (m *LoadDevice) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *LoadDevice) GetSkipChecksum() bool {
	if m != nil && m.SkipChecksum != nil {
		return *m.SkipChecksum
	}
	return false
}

func (m *LoadDevice) GetU2FCounter() uint32 {
	if m != nil && m.U2FCounter != nil {
		return *m.U2FCounter
	}
	return 0
}

//*
// Request: Ask device to do initialization involving user interaction
// @next EntropyRequest
// @next Failure
type ResetDevice struct {
	DisplayRandom *bool `protobuf:"varint,1,opt,name=display_random,json=displayRandom" json:"display_random,omitempty"`
	// before asking for additional entropy
	Strength             *uint32  `protobuf:"varint,2,opt,name=strength,def=256" json:"strength,omitempty"`
	PassphraseProtection *bool    `protobuf:"varint,3,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
	PinProtection        *bool    `protobuf:"varint,4,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
	Language             *string  `protobuf:"bytes,5,opt,name=language,def=english" json:"language,omitempty"`
	Label                *string  `protobuf:"bytes,6,opt,name=label" json:"label,omitempty"`
	U2FCounter           *uint32  `protobuf:"varint,7,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
	SkipBackup           *bool    `protobuf:"varint,8,opt,name=skip_backup,json=skipBackup" json:"skip_backup,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ResetDevice proto.InternalMessageInfo

const Default_ResetDevice_Strength uint32 = 256
const Default_ResetDevice_Language string = "english"

func (m *ResetDevice) GetDisplayRandom() bool {
	if m != nil && m.DisplayRandom != nil {
		return *m.DisplayRandom
	}
	return false
}

func (m *ResetDevice) GetStrength() uint32 {
	if m != nil && m.Strength != nil {
		return *m.Strength
	}
	return Default_ResetDevice_Strength
}

func (m *ResetDevice) GetPassphraseProtection() bool {
	if m != nil && m.PassphraseProtection != nil {
		return *m.PassphraseProtection
	}
	return false
}

func (m *ResetDevice) GetPinProtection() bool {
	if m != nil && m.PinProtection != nil {
		return *m.PinProtection
	}
	return false
}

func (m *ResetDevice) GetLanguage() string {
	if m != nil && m.Language != nil {
		return *m.Language
	}
	return Default_ResetDevice_Language
}

func (m *ResetDevice) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *ResetDevice) GetU2FCounter() uint32 {
	if m != nil && m.U2FCounter != nil {
		return *m.U2FCounter
	}
	return 0
}

func (m *ResetDevice) GetSkipBackup() bool {
	if m != nil && m.SkipBackup != nil {
		return *m.SkipBackup
	}
	return false
}

//*
// Request: Perform backup of the device seed if not backed up using ResetDevice
// @next ButtonRequest
type BackupDevice struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_BackupDevice proto.InternalMessageInfo

//*
// Response: Ask for additional entropy from host computer
// @prev ResetDevice
// @next EntropyAck
type EntropyRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EntropyRequest proto.InternalMessageInfo

//*
// Request: Provide additional entropy for seed generation function
// @prev EntropyRequest
// @next ButtonRequest
type EntropyAck struct {
	Entropy              []byte   `protobuf:"bytes,1,opt,name=entropy" json:"entropy,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EntropyAck proto.InternalMessageInfo

func (m *EntropyAck) GetEntropy() []byte {
	if m != nil {
		return m.Entropy
	}
	return nil
}

//*
// Request: Start recovery workflow asking user for specific words of mnemonic
// Used to recovery device safely even on untrusted computer.
// @next WordRequest
type RecoveryDevice struct {
	WordCount            *uint32 `protobuf:"varint,1,opt,name=word_count,json=wordCount" json:"word_count,omitempty"`
	PassphraseProtection *bool   `protobuf:"varint,2,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
	PinProtection        *bool   `protobuf:"varint,3,opt,name=pin_protection,json=pinProtection" json:"pin_protection,omitempty"`
	Language             *string `protobuf:"bytes,4,opt,name=language,def=english" json:"language,omitempty"`
	Label                *string `protobuf:"bytes,5,opt,name=label" json:"label,omitempty"`
	EnforceWordlist      *bool   `protobuf:"varint,6,opt,name=enforce_wordlist,json=enforceWordlist" json:"enforce_wordlist,omitempty"`
	// 7 reserved for unused recovery method
	Type                 *uint32  `protobuf:"varint,8,opt,name=type" json:"type,omitempty"`
	U2FCounter           *uint32  `protobuf:"varint,9,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
	DryRun               *bool    `protobuf:"varint,10,opt,name=dry_run,json=dryRun" json:"dry_run,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecoveryDevice proto.InternalMessageInfo

const Default_RecoveryDevice_Language string = "english"

func (m *RecoveryDevice) GetWordCount() uint32 {
	if m != nil && m.WordCount != nil {
		return *m.WordCount
	}
	return 0
}

func (m *RecoveryDevice) GetPassphraseProtection() bool {
	if m != nil && m.PassphraseProtection != nil {
		return *m.PassphraseProtection
	}
	return false
}

func (m *RecoveryDevice) GetPinProtection() bool {
	if m != nil && m.PinProtection != nil {
		return *m.PinProtection
	}
	return false
}

func (m *RecoveryDevice) GetLanguage() string {
	if m != nil && m.Language != nil {
		return *m.Language
	}
	return Default_RecoveryDevice_Language
}

func (m *RecoveryDevice) GetLabel() string {
	if m != nil && m.Label != nil {
		return *m.Label
	}
	return ""
}

func (m *RecoveryDevice) GetEnforceWordlist() bool {
	if m != nil && m.EnforceWordlist != nil {
		return *m.EnforceWordlist
	}
	return false
}

func (m *RecoveryDevice) GetType() uint32 {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return 0
}

func (m *RecoveryDevice) GetU2FCounter() uint32 {
	if m != nil && m.U2FCounter != nil {
		return *m.U2FCounter
	}
	return 0
}

func (m *RecoveryDevice) GetDryRun() bool {
	if m != nil && m.DryRun != nil {
		return *m.DryRun
	}
	return false
}

//*
// Response: Device is waiting for user to enter word of the mnemonic
// Its position is shown only on device's internal display.
// @prev RecoveryDevice
// @prev WordAck
type WordRequest struct {
	Type                 *WordRequestType `protobuf:"varint,1,opt,name=type,enum=WordRequestType" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_WordRequest proto.InternalMessageInfo

func (m *WordRequest) GetType() WordRequestType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return WordRequestType_WordRequestType_Plain
}

//*
// Request: Computer replies with word from the mnemonic
// @prev WordRequest
// @next WordRequest
// @next Success
// @next Failure
type WordAck struct {
	Word                 *string  `protobuf:"bytes,1,req,name=word" json:"word,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WordAck proto.InternalMessageInfo

func (m *WordAck) GetWord() string {
	if m != nil && m.Word != nil {
		return *m.Word
	}
	return ""
}

//*
// Request: Ask device to sign message
// @next MessageSignature
// @next Failure
type SignMessage struct {
	AddressN             []uint32         `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	Message              []byte           `protobuf:"bytes,2,req,name=message" json:"message,omitempty"`
	CoinName             *string          `protobuf:"bytes,3,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	ScriptType           *InputScriptType `protobuf:"varint,4,opt,name=script_type,json=scriptType,enum=InputScriptType,def=0" json:"script_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_SignMessage proto.InternalMessageInfo

const Default_SignMessage_CoinName string = "Bitcoin"
const Default_SignMessage_ScriptType InputScriptType = InputScriptType_SPENDADDRESS

func (m *SignMessage) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *SignMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *SignMessage) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_SignMessage_CoinName
}

func (m *SignMessage) GetScriptType() InputScriptType {
	if m != nil && m.ScriptType != nil {
		return *m.ScriptType
	}
	return Default_SignMessage_ScriptType
}

//*
// Request: Ask device to verify message
// @next Success
// @next Failure
type VerifyMessage struct {
	Address              *string  `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
	Message              []byte   `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
	CoinName             *string  `protobuf:"bytes,4,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_VerifyMessage proto.InternalMessageInfo

const Default_VerifyMessage_CoinName string = "Bitcoin"

func (m *VerifyMessage) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

func (m *VerifyMessage) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *VerifyMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *VerifyMessage) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_VerifyMessage_CoinName
}

//*
// Response: Signed message
// @prev SignMessage
type MessageSignature struct {
	Address              *string  `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MessageSignature proto.InternalMessageInfo

func (m *MessageSignature) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

func (m *MessageSignature) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

//*
// Request: Ask device to encrypt message
// @next EncryptedMessage
// @next Failure
type EncryptMessage struct {
	Pubkey               []byte   `protobuf:"bytes,1,opt,name=pubkey" json:"pubkey,omitempty"`
	Message              []byte   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	DisplayOnly          *bool    `protobuf:"varint,3,opt,name=display_only,json=displayOnly" json:"display_only,omitempty"`
	AddressN             []uint32 `protobuf:"varint,4,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	CoinName             *string  `protobuf:"bytes,5,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EncryptMessage proto.InternalMessageInfo

const Default_EncryptMessage_CoinName string = "Bitcoin"

func (m *EncryptMessage) GetPubkey() []byte {
	if m != nil {
		return m.Pubkey
	}
	return nil
}

func (m *EncryptMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *EncryptMessage) GetDisplayOnly() bool {
	if m != nil && m.DisplayOnly != nil {
		return *m.DisplayOnly
	}
	return false
}

func (m *EncryptMessage) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *EncryptMessage) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_EncryptMessage_CoinName
}

//*
// Response: Encrypted message
// @prev EncryptMessage
type EncryptedMessage struct {
	Nonce                []byte   `protobuf:"bytes,1,opt,name=nonce" json:"nonce,omitempty"`
	Message              []byte   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	Hmac                 []byte   `protobuf:"bytes,3,opt,name=hmac" json:"hmac,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EncryptedMessage proto.InternalMessageInfo

func (m *EncryptedMessage) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

func (m *EncryptedMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *EncryptedMessage) GetHmac() []byte {
	if m != nil {
		return m.Hmac
	}
	return nil
}

//*
// Request: Ask device to decrypt message
// @next Success
// @next Failure
type DecryptMessage struct {
	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	Nonce                []byte   `protobuf:"bytes,2,opt,name=nonce" json:"nonce,omitempty"`
	Message              []byte   `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
	Hmac                 []byte   `protobuf:"bytes,4,opt,name=hmac" json:"hmac,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DecryptMessage proto.InternalMessageInfo

func (m *DecryptMessage) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *DecryptMessage) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

func (m *DecryptMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *DecryptMessage) GetHmac() []byte {
	if m != nil {
		return m.Hmac
	}
	return nil
}

//*
// Response: Decrypted message
// @prev DecryptedMessage
type DecryptedMessage struct {
	Message              []byte   `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
	Address              *string  `protobuf:"bytes,2,opt,name=address" json:"address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DecryptedMessage proto.InternalMessageInfo

func (m *DecryptedMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *DecryptedMessage) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

//*
// Request: Ask device to encrypt or decrypt value of given key
// @next CipheredKeyValue
// @next Failure
type CipherKeyValue struct {
	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	Key                  *string  `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,3,opt,name=value" json:"value,omitempty"`
	Encrypt              *bool    `protobuf:"varint,4,opt,name=encrypt" json:"encrypt,omitempty"`
	AskOnEncrypt         *bool    `protobuf:"varint,5,opt,name=ask_on_encrypt,json=askOnEncrypt" json:"ask_on_encrypt,omitempty"`
	AskOnDecrypt         *bool    `protobuf:"varint,6,opt,name=ask_on_decrypt,json=askOnDecrypt" json:"ask_on_decrypt,omitempty"`
	Iv                   []byte   `protobuf:"bytes,7,opt,name=iv" json:"iv,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CipherKeyValue proto.InternalMessageInfo

func (m *CipherKeyValue) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *CipherKeyValue) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

func (m *CipherKeyValue) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *CipherKeyValue) GetEncrypt() bool {
	if m != nil && m.Encrypt != nil {
		return *m.Encrypt
	}
	return false
}

func (m *CipherKeyValue) GetAskOnEncrypt() bool {
	if m != nil && m.AskOnEncrypt != nil {
		return *m.AskOnEncrypt
	}
	return false
}

func (m *CipherKeyValue) GetAskOnDecrypt() bool {
	if m != nil && m.AskOnDecrypt != nil {
		return *m.AskOnDecrypt
	}
	return false
}

func (m *CipherKeyValue) GetIv() []byte {
	if m != nil {
		return m.Iv
	}
	return nil
}

//*
// Response: Return ciphered/deciphered value
// @prev CipherKeyValue
type CipheredKeyValue struct {
	Value                []byte   `protobuf:"bytes,1,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CipheredKeyValue proto.InternalMessageInfo

func (m *CipheredKeyValue) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

//*
// Request: Estimated size of the transaction
// This behaves exactly like SignTx, which means that it can ask using TxRequest
// This call is non-blocking (except possible PassphraseRequest to unlock the
// seed)
// @next TxSize
// @next Failure
type EstimateTxSize struct {
	OutputsCount         *uint32  `protobuf:"varint,1,req,name=outputs_count,json=outputsCount" json:"outputs_count,omitempty"`
	InputsCount          *uint32  `protobuf:"varint,2,req,name=inputs_count,json=inputsCount" json:"inputs_count,omitempty"`
	CoinName             *string  `protobuf:"bytes,3,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EstimateTxSize proto.InternalMessageInfo

const Default_EstimateTxSize_CoinName string = "Bitcoin"

func (m *EstimateTxSize) GetOutputsCount() uint32 {
	if m != nil && m.OutputsCount != nil {
		return *m.OutputsCount
	}
	return 0
}

func (m *EstimateTxSize) GetInputsCount() uint32 {
	if m != nil && m.InputsCount != nil {
		return *m.InputsCount
	}
	return 0
}

func (m *EstimateTxSize) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_EstimateTxSize_CoinName
}

//*
// Response: Estimated size of the transaction
// @prev EstimateTxSize
type TxSize struct {
	TxSize               *uint32  `protobuf:"varint,1,opt,name=tx_size,json=txSize" json:"tx_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxSize proto.InternalMessageInfo

func (m *TxSize) GetTxSize() uint32 {
	if m != nil && m.TxSize != nil {
		return *m.TxSize
	}
	return 0
}

//*
// Request: Ask device to sign transaction
// @next PassphraseRequest
// @next PinMatrixRequest
// @next TxRequest
// @next Failure
type SignTx struct {
	OutputsCount         *uint32  `protobuf:"varint,1,req,name=outputs_count,json=outputsCount" json:"outputs_count,omitempty"`
	InputsCount          *uint32  `protobuf:"varint,2,req,name=inputs_count,json=inputsCount" json:"inputs_count,omitempty"`
	CoinName             *string  `protobuf:"bytes,3,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	Version              *uint32  `protobuf:"varint,4,opt,name=version,def=1" json:"version,omitempty"`
	LockTime             *uint32  `protobuf:"varint,5,opt,name=lock_time,json=lockTime,def=0" json:"lock_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SignTx proto.InternalMessageInfo

const Default_SignTx_CoinName string = "Bitcoin"
const Default_SignTx_Version uint32 = 1
const Default_SignTx_LockTime uint32 = 0

func (m *SignTx) GetOutputsCount() uint32 {
	if m != nil && m.OutputsCount != nil {
		return *m.OutputsCount
	}
	return 0
}

func (m *SignTx) GetInputsCount() uint32 {
	if m != nil && m.InputsCount != nil {
		return *m.InputsCount
	}
	return 0
}

func (m *SignTx) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_SignTx_CoinName
}

func (m *SignTx) GetVersion() uint32 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return Default_SignTx_Version
}

func (m *SignTx) GetLockTime() uint32 {
	if m != nil && m.LockTime != nil {
		return *m.LockTime
	}
	return Default_SignTx_LockTime
}

//*
// Request: Simplified transaction signing
// This method doesn't support streaming, so there are hardware limits in number
// of inputs and outputs. In case of success, the result is returned using
// TxRequest message.
// @next PassphraseRequest
// @next PinMatrixRequest
// @next TxRequest
// @next Failure
type SimpleSignTx struct {
	Inputs               []*TxInputType     `protobuf:"bytes,1,rep,name=inputs" json:"inputs,omitempty"`
	Outputs              []*TxOutputType    `protobuf:"bytes,2,rep,name=outputs" json:"outputs,omitempty"`
	Transactions         []*TransactionType `protobuf:"bytes,3,rep,name=transactions" json:"transactions,omitempty"`
	CoinName             *string            `protobuf:"bytes,4,opt,name=coin_name,json=coinName,def=Bitcoin" json:"coin_name,omitempty"`
	Version              *uint32            `protobuf:"varint,5,opt,name=version,def=1" json:"version,omitempty"`
	LockTime             *uint32            `protobuf:"varint,6,opt,name=lock_time,json=lockTime,def=0" json:"lock_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_SimpleSignTx proto.InternalMessageInfo

const Default_SimpleSignTx_CoinName string = "Bitcoin"
const Default_SimpleSignTx_Version uint32 = 1
const Default_SimpleSignTx_LockTime uint32 = 0

func (m *SimpleSignTx) GetInputs() []*TxInputType {
	if m != nil {
		return m.Inputs
	}
	return nil
}

func (m *SimpleSignTx) GetOutputs() []*TxOutputType {
	if m != nil {
		return m.Outputs
	}
	return nil
}

func (m *SimpleSignTx) GetTransactions() []*TransactionType {
	if m != nil {
		return m.Transactions
	}
	return nil
}

func (m *SimpleSignTx) GetCoinName() string {
	if m != nil && m.CoinName != nil {
		return *m.CoinName
	}
	return Default_SimpleSignTx_CoinName
}

func (m *SimpleSignTx) GetVersion() uint32 {
	if m != nil && m.Version != nil {
		return *m.Version
	}
	return Default_SimpleSignTx_Version
}

func (m *SimpleSignTx) GetLockTime() uint32 {
	if m != nil && m.LockTime != nil {
		return *m.LockTime
	}
	return Default_SimpleSignTx_LockTime
}

//*
// Response: Device asks for information for signing transaction or returns the
// last result If request_index is set, device awaits TxAck message (with fields
// filled in according to request_type) If signature_index is set, 'signature'
// contains signed input of signature_index's input
// @prev SignTx
// @prev SimpleSignTx
// @prev TxAck
type TxRequest struct {
	RequestType          *RequestType             `protobuf:"varint,1,opt,name=request_type,json=requestType,enum=RequestType" json:"request_type,omitempty"`
	Details              *TxRequestDetailsType    `protobuf:"bytes,2,opt,name=details" json:"details,omitempty"`
	Serialized           *TxRequestSerializedType `protobuf:"bytes,3,opt,name=serialized" json:"serialized,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

var xxx_messageInfo_TxRequest proto.InternalMessageInfo

func (m *TxRequest) GetRequestType() RequestType {
	if m != nil && m.RequestType != nil {
		return *m.RequestType
	}
	return RequestType_TXINPUT
}

func (m *TxRequest) GetDetails() *TxRequestDetailsType {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *TxRequest) GetSerialized() *TxRequestSerializedType {
	if m != nil {
		return m.Serialized
	}
	return nil
}

//*
// Request: Reported transaction data
// @prev TxRequest
// @next TxRequest
type TxAck struct {
	Tx                   *TransactionType `protobuf:"bytes,1,opt,name=tx" json:"tx,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_TxAck proto.InternalMessageInfo

func (m *TxAck) GetTx() *TransactionType {
	if m != nil {
		return m.Tx
	}
	return nil
}

//*
// Request: Ask device to sign transaction
// All fields are optional from the protocol's point of view. Each field
// defaults to value `0` if missing. Note: the first at most 1024 bytes of data
// MUST be transmitted as part of this message.
// @next PassphraseRequest
// @next PinMatrixRequest
// @next AquachainTxRequest
// @next Failure
type AquachainSignTx struct {
	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	Nonce                []byte   `protobuf:"bytes,2,opt,name=nonce" json:"nonce,omitempty"`
	GasPrice             []byte   `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice" json:"gas_price,omitempty"`
	GasLimit             []byte   `protobuf:"bytes,4,opt,name=gas_limit,json=gasLimit" json:"gas_limit,omitempty"`
	To                   []byte   `protobuf:"bytes,5,opt,name=to" json:"to,omitempty"`
	Value                []byte   `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
	DataInitialChunk     []byte   `protobuf:"bytes,7,opt,name=data_initial_chunk,json=dataInitialChunk" json:"data_initial_chunk,omitempty"`
	DataLength           *uint32  `protobuf:"varint,8,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
	ChainId              *uint32  `protobuf:"varint,9,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainSignTx proto.InternalMessageInfo

func (m *AquachainSignTx) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *AquachainSignTx) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

func (m *AquachainSignTx) GetGasPrice() []byte {
	if m != nil {
		return m.GasPrice
	}
	return nil
}

func (m *AquachainSignTx) GetGasLimit() []byte {
	if m != nil {
		return m.GasLimit
	}
	return nil
}

func (m *AquachainSignTx) GetTo() []byte {
	if m != nil {
		return m.To
	}
	return nil
}

func (m *AquachainSignTx) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *AquachainSignTx) GetDataInitialChunk() []byte {
	if m != nil {
		return m.DataInitialChunk
	}
	return nil
}

func (m *AquachainSignTx) GetDataLength() uint32 {
	if m != nil && m.DataLength != nil {
		return *m.DataLength
	}
	return 0
}

func (m *AquachainSignTx) GetChainId() uint32 {
	if m != nil && m.ChainId != nil {
		return *m.ChainId
	}
	return 0
}

//*
// Response: Device asks for more data from transaction payload, or returns the
// signature. If data_length is set, device awaits that many more bytes of
// payload. Otherwise, the signature_* fields contain the computed transaction
// signature. All three fields will be present.
// @prev AquachainSignTx
// @next AquachainTxAck
type AquachainTxRequest struct {
	DataLength           *uint32  `protobuf:"varint,1,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
	SignatureV           *uint32  `protobuf:"varint,2,opt,name=signature_v,json=signatureV" json:"signature_v,omitempty"`
	SignatureR           []byte   `protobuf:"bytes,3,opt,name=signature_r,json=signatureR" json:"signature_r,omitempty"`
	SignatureS           []byte   `protobuf:"bytes,4,opt,name=signature_s,json=signatureS" json:"signature_s,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainTxRequest proto.InternalMessageInfo

func (m *AquachainTxRequest) GetDataLength() uint32 {
	if m != nil && m.DataLength != nil {
		return *m.DataLength
	}
	return 0
}

func (m *AquachainTxRequest) GetSignatureV() uint32 {
	if m != nil && m.SignatureV != nil {
		return *m.SignatureV
	}
	return 0
}

func (m *AquachainTxRequest) GetSignatureR() []byte {
	if m != nil {
		return m.SignatureR
	}
	return nil
}

func (m *AquachainTxRequest) GetSignatureS() []byte {
	if m != nil {
		return m.SignatureS
	}
	return nil
}

//*
// Request: Transaction payload data.
// @prev AquachainTxRequest
// @next AquachainTxRequest
type AquachainTxAck struct {
	DataChunk            []byte   `protobuf:"bytes,1,opt,name=data_chunk,json=dataChunk" json:"data_chunk,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainTxAck proto.InternalMessageInfo

func (m *AquachainTxAck) GetDataChunk() []byte {
	if m != nil {
		return m.DataChunk
	}
	return nil
}

//*
// Request: Ask device to sign message
// @next AquachainMessageSignature
// @next Failure
type AquachainSignMessage struct {
	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
	Message              []byte   `protobuf:"bytes,2,req,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainSignMessage proto.InternalMessageInfo

func (m *AquachainSignMessage) GetAddressN() []uint32 {
	if m != nil {
		return m.AddressN
	}
	return nil
}

func (m *AquachainSignMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

//*
// Request: Ask device to verify message
// @next Success
// @next Failure
type AquachainVerifyMessage struct {
	Address              []byte   `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
	Message              []byte   `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainVerifyMessage proto.InternalMessageInfo

func (m *AquachainVerifyMessage) GetAddress() []byte {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *AquachainVerifyMessage) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *AquachainVerifyMessage) GetMessage() []byte {
	if m != nil {
		return m.Message
	}
	return nil
}

//*
// Response: Signed message
// @prev AquachainSignMessage
type AquachainMessageSignature struct {
	Address              []byte   `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AquachainMessageSignature proto.InternalMessageInfo

func (m *AquachainMessageSignature) GetAddress() []byte {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *AquachainMessageSignature) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

//*
// Request: Ask device to sign identity
// @next SignedIdentity
// @next Failure
type SignIdentity struct {
	Identity             *IdentityType `protobuf:"bytes,1,opt,name=identity" json:"identity,omitempty"`
	ChallengeHidden      []byte        `protobuf:"bytes,2,opt,name=challenge_hidden,json=challengeHidden" json:"challenge_hidden,omitempty"`
	ChallengeVisual      *string       `protobuf:"bytes,3,opt,name=challenge_visual,json=challengeVisual" json:"challenge_visual,omitempty"`
	EcdsaCurveName       *string       `protobuf:"bytes,4,opt,name=ecdsa_curve_name,json=ecdsaCurveName" json:"ecdsa_curve_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_SignIdentity proto.InternalMessageInfo

func (m *SignIdentity) GetIdentity() *IdentityType {
	if m != nil {
		return m.Identity
	}
	return nil
}

func (m *SignIdentity) GetChallengeHidden() []byte {
	if m != nil {
		return m.ChallengeHidden
	}
	return nil
}

func (m *SignIdentity) GetChallengeVisual() string {
	if m != nil && m.ChallengeVisual != nil {
		return *m.ChallengeVisual
	}
	return ""
}

func (m *SignIdentity) GetEcdsaCurveName() string {
	if m != nil && m.EcdsaCurveName != nil {
		return *m.EcdsaCurveName
	}
	return ""
}

//*
// Response: Device provides signed identity
// @prev SignIdentity
type SignedIdentity struct {
	Address              *string  `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
	PublicKey            []byte   `protobuf:"bytes,2,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
	Signature            []byte   `protobuf:"bytes,3,opt,name=signature" json:"signature,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SignedIdentity proto.InternalMessageInfo

func (m *SignedIdentity) GetAddress() string {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return ""
}

func (m *SignedIdentity) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *SignedIdentity) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

//*
// Request: Ask device to generate ECDH session key
// @next ECDHSessionKey
// @next Failure
type GetECDHSessionKey struct {
	Identity             *IdentityType `protobuf:"bytes,1,opt,name=identity" json:"identity,omitempty"`
	PeerPublicKey        []byte        `protobuf:"bytes,2,opt,name=peer_public_key,json=peerPublicKey" json:"peer_public_key,omitempty"`
	EcdsaCurveName       *string       `protobuf:"bytes,3,opt,name=ecdsa_curve_name,json=ecdsaCurveName" json:"ecdsa_curve_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_GetECDHSessionKey proto.InternalMessageInfo

func (m *GetECDHSessionKey) GetIdentity() *IdentityType {
	if m != nil {
		return m.Identity
	}
	return nil
}

func (m *GetECDHSessionKey) GetPeerPublicKey() []byte {
	if m != nil {
		return m.PeerPublicKey
	}
	return nil
}

func (m *GetECDHSessionKey) GetEcdsaCurveName() string {
	if m != nil && m.EcdsaCurveName != nil {
		return *m.EcdsaCurveName
	}
	return ""
}

//*
// Response: Device provides ECDH session key
// @prev GetECDHSessionKey
type ECDHSessionKey struct {
	SessionKey           []byte   `protobuf:"bytes,1,opt,name=session_key,json=sessionKey" json:"session_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ECDHSessionKey proto.InternalMessageInfo

func (m *ECDHSessionKey) GetSessionKey() []byte {
	if m != nil {
		return m.SessionKey
	}
	return nil
}

//*
// Request: Set U2F counter
// @next Success
type SetU2FCounter struct {
	U2FCounter           *uint32  `protobuf:"varint,1,opt,name=u2f_counter,json=u2fCounter" json:"u2f_counter,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SetU2FCounter proto.InternalMessageInfo

func (m *SetU2FCounter) GetU2FCounter() uint32 {
	if m != nil && m.U2FCounter != nil {
		return *m.U2FCounter
	}
	return 0
}

//*
// Request: Ask device to erase its firmware (so it can be replaced via
// FirmwareUpload)
// @next Success
// @next FirmwareRequest
// @next Failure
type FirmwareErase struct {
	Length               *uint32  `protobuf:"varint,1,opt,name=length" json:"length,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FirmwareErase proto.InternalMessageInfo

func (m *FirmwareErase) GetLength() uint32 {
	if m != nil && m.Length != nil {
		return *m.Length
	}
	return 0
}

//*
// Response: Ask for firmware chunk
// @next FirmwareUpload
type FirmwareRequest struct {
	Offset               *uint32  `protobuf:"varint,1,opt,name=offset" json:"offset,omitempty"`
	Length               *uint32  `protobuf:"varint,2,opt,name=length" json:"length,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FirmwareRequest proto.InternalMessageInfo

func (m *FirmwareRequest) GetOffset() uint32 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

func (m *FirmwareRequest) GetLength() uint32 {
	if m != nil && m.Length != nil {
		return *m.Length
	}
	return 0
}

//*
// Request: Send firmware in binary form to the device
// @next Success
// @next Failure
type FirmwareUpload struct {
	Payload              []byte   `protobuf:"bytes,1,req,name=payload" json:"payload,omitempty"`
	Hash                 []byte   `protobuf:"bytes,2,opt,name=hash" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FirmwareUpload proto.InternalMessageInfo

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

func (m *FirmwareUpload) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

//*
// Request: Perform a device self-test
// @next Success
// @next Failure
type SelfTest struct {
	Payload              []byte   `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SelfTest proto.InternalMessageInfo

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

//*
// Request: "Press" the button on the device
// @next Success
type DebugLinkDecision struct {
	YesNo                *bool    `protobuf:"varint,1,req,name=yes_no,json=yesNo" json:"yes_no,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkDecision proto.InternalMessageInfo

func (m *DebugLinkDecision) GetYesNo() bool {
	if m != nil && m.YesNo != nil {
		return *m.YesNo
	}
	return false
}

//*
// Request: Computer asks for device state
// @next DebugLinkState
type DebugLinkGetState struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkGetState proto.InternalMessageInfo

//*
// Response: Device current state
// @prev DebugLinkGetState
type DebugLinkState struct {
	Layout               []byte      `protobuf:"bytes,1,opt,name=layout" json:"layout,omitempty"`
	Pin                  *string     `protobuf:"bytes,2,opt,name=pin" json:"pin,omitempty"`
	Matrix               *string     `protobuf:"bytes,3,opt,name=matrix" json:"matrix,omitempty"`
	Mnemonic             *string     `protobuf:"bytes,4,opt,name=mnemonic" json:"mnemonic,omitempty"`
	Node                 *HDNodeType `protobuf:"bytes,5,opt,name=node" json:"node,omitempty"`
	PassphraseProtection *bool       `protobuf:"varint,6,opt,name=passphrase_protection,json=passphraseProtection" json:"passphrase_protection,omitempty"`
	ResetWord            *string     `protobuf:"bytes,7,opt,name=reset_word,json=resetWord" json:"reset_word,omitempty"`
	ResetEntropy         []byte      `protobuf:"bytes,8,opt,name=reset_entropy,json=resetEntropy" json:"reset_entropy,omitempty"`
	RecoveryFakeWord     *string     `protobuf:"bytes,9,opt,name=recovery_fake_word,json=recoveryFakeWord" json:"recovery_fake_word,omitempty"`
	RecoveryWordPos      *uint32     `protobuf:"varint,10,opt,name=recovery_word_pos,json=recoveryWordPos" json:"recovery_word_pos,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_DebugLinkState proto.InternalMessageInfo

func (m *DebugLinkState) GetLayout() []byte {
	if m != nil {
		return m.Layout
	}
	return nil
}

func (m *DebugLinkState) GetPin() string {
	if m != nil && m.Pin != nil {
		return *m.Pin
	}
	return ""
}

func (m *DebugLinkState) GetMatrix() string {
	if m != nil && m.Matrix != nil {
		return *m.Matrix
	}
	return ""
}

func (m *DebugLinkState) GetMnemonic() string {
	if m != nil && m.Mnemonic != nil {
		return *m.Mnemonic
	}
	return ""
}

func (m *DebugLinkState) GetNode() *HDNodeType {
	if m != nil {
		return m.Node
	}
	return nil
}

func (m *DebugLinkState) GetPassphraseProtection() bool {
	if m != nil && m.PassphraseProtection != nil {
		return *m.PassphraseProtection
	}
	return false
}

func (m *DebugLinkState) GetResetWord() string {
	if m != nil && m.ResetWord != nil {
		return *m.ResetWord
	}
	return ""
}

func (m *DebugLinkState) GetResetEntropy() []byte {
	if m != nil {
		return m.ResetEntropy
	}
	return nil
}

func (m *DebugLinkState) GetRecoveryFakeWord() string {
	if m != nil && m.RecoveryFakeWord != nil {
		return *m.RecoveryFakeWord
	}
	return ""
}

func (m *DebugLinkState) GetRecoveryWordPos() uint32 {
	if m != nil && m.RecoveryWordPos != nil {
		return *m.RecoveryWordPos
	}
	return 0
}

//*
// Request: Ask device to restart
type DebugLinkStop struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkStop proto.InternalMessageInfo

//*
// Response: Device wants host to log event
type DebugLinkLog struct {
	Level                *uint32  `protobuf:"varint,1,opt,name=level" json:"level,omitempty"`
	Bucket               *string  `protobuf:"bytes,2,opt,name=bucket" json:"bucket,omitempty"`
	Text                 *string  `protobuf:"bytes,3,opt,name=text" json:"text,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkLog proto.InternalMessageInfo

func (m *DebugLinkLog) GetLevel() uint32 {
	if m != nil && m.Level != nil {
		return *m.Level
	}
	return 0
}

func (m *DebugLinkLog) GetBucket() string {
	if m != nil && m.Bucket != nil {
		return *m.Bucket
	}
	return ""
}

func (m *DebugLinkLog) GetText() string {
	if m != nil && m.Text != nil {
		return *m.Text
	}
	return ""
}

//*
// Request: Read memory from device
// @next DebugLinkMemory
type DebugLinkMemoryRead struct {
	Address              *uint32  `protobuf:"varint,1,opt,name=address" json:"address,omitempty"`
	Length               *uint32  `protobuf:"varint,2,opt,name=length" json:"length,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkMemoryRead proto.InternalMessageInfo

func (m *DebugLinkMemoryRead) GetAddress() uint32 {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return 0
}

func (m *DebugLinkMemoryRead) GetLength() uint32 {
	if m != nil && m.Length != nil {
		return *m.Length
	}
	return 0
}

//*
// Response: Device sends memory back
// @prev DebugLinkMemoryRead
type DebugLinkMemory struct {
	Memory               []byte   `protobuf:"bytes,1,opt,name=memory" json:"memory,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkMemory proto.InternalMessageInfo

func (m *DebugLinkMemory) GetMemory() []byte {
	if m != nil {
		return m.Memory
	}
	return nil
}

//*
// Request: Write memory to device.
// WARNING: Writing to the wrong location can irreparably break the device.
type DebugLinkMemoryWrite struct {
	Address              *uint32  `protobuf:"varint,1,opt,name=address" json:"address,omitempty"`
	Memory               []byte   `protobuf:"bytes,2,opt,name=memory" json:"memory,omitempty"`
	Flash                *bool    `protobuf:"varint,3,opt,name=flash" json:"flash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkMemoryWrite proto.InternalMessageInfo

func (m *DebugLinkMemoryWrite) GetAddress() uint32 {
	if m != nil && m.Address != nil {
		return *m.Address
	}
	return 0
}

func (m *DebugLinkMemoryWrite) GetMemory() []byte {
	if m != nil {
		return m.Memory
	}
	return nil
}

func (m *DebugLinkMemoryWrite) GetFlash() bool {
	if m != nil && m.Flash != nil {
		return *m.Flash
	}
	return false
}

//*
// Request: Erase block of flash on device
// WARNING: Writing to the wrong location can irreparably break the device.
type DebugLinkFlashErase struct {
	Sector               *uint32  `protobuf:"varint,1,opt,name=sector" json:"sector,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DebugLinkFlashErase proto.InternalMessageInfo

func (m *DebugLinkFlashErase) GetSector() uint32 {
	if m != nil && m.Sector != nil {
		return *m.Sector
	}
	return 0
}

func init() {
	proto.RegisterEnum("MessageType", MessageType_name, MessageType_value)
	proto.RegisterType((*Initialize)(nil), "Initialize")
	proto.RegisterType((*GetFeatures)(nil), "GetFeatures")
	proto.RegisterType((*Features)(nil), "Features")
	proto.RegisterType((*ClearSession)(nil), "ClearSession")
	proto.RegisterType((*ApplySettings)(nil), "ApplySettings")
	proto.RegisterType((*ApplyFlags)(nil), "ApplyFlags")
	proto.RegisterType((*ChangePin)(nil), "ChangePin")
	proto.RegisterType((*Ping)(nil), "Ping")
	proto.RegisterType((*Success)(nil), "Success")
	proto.RegisterType((*Failure)(nil), "Failure")
	proto.RegisterType((*ButtonRequest)(nil), "ButtonRequest")
	proto.RegisterType((*ButtonAck)(nil), "ButtonAck")
	proto.RegisterType((*PinMatrixRequest)(nil), "PinMatrixRequest")
	proto.RegisterType((*PinMatrixAck)(nil), "PinMatrixAck")
	proto.RegisterType((*Cancel)(nil), "Cancel")
	proto.RegisterType((*PassphraseRequest)(nil), "PassphraseRequest")
	proto.RegisterType((*PassphraseAck)(nil), "PassphraseAck")
	proto.RegisterType((*GetEntropy)(nil), "GetEntropy")
	proto.RegisterType((*Entropy)(nil), "Entropy")
	proto.RegisterType((*GetPublicKey)(nil), "GetPublicKey")
	proto.RegisterType((*PublicKey)(nil), "PublicKey")
	proto.RegisterType((*GetAddress)(nil), "GetAddress")
	proto.RegisterType((*AquachainGetAddress)(nil), "AquachainGetAddress")
	proto.RegisterType((*Address)(nil), "Address")
	proto.RegisterType((*AquachainAddress)(nil), "AquachainAddress")
	proto.RegisterType((*WipeDevice)(nil), "WipeDevice")
	proto.RegisterType((*LoadDevice)(nil), "LoadDevice")
	proto.RegisterType((*ResetDevice)(nil), "ResetDevice")
	proto.RegisterType((*BackupDevice)(nil), "BackupDevice")
	proto.RegisterType((*EntropyRequest)(nil), "EntropyRequest")
	proto.RegisterType((*EntropyAck)(nil), "EntropyAck")
	proto.RegisterType((*RecoveryDevice)(nil), "RecoveryDevice")
	proto.RegisterType((*WordRequest)(nil), "WordRequest")
	proto.RegisterType((*WordAck)(nil), "WordAck")
	proto.RegisterType((*SignMessage)(nil), "SignMessage")
	proto.RegisterType((*VerifyMessage)(nil), "VerifyMessage")
	proto.RegisterType((*MessageSignature)(nil), "MessageSignature")
	proto.RegisterType((*EncryptMessage)(nil), "EncryptMessage")
	proto.RegisterType((*EncryptedMessage)(nil), "EncryptedMessage")
	proto.RegisterType((*DecryptMessage)(nil), "DecryptMessage")
	proto.RegisterType((*DecryptedMessage)(nil), "DecryptedMessage")
	proto.RegisterType((*CipherKeyValue)(nil), "CipherKeyValue")
	proto.RegisterType((*CipheredKeyValue)(nil), "CipheredKeyValue")
	proto.RegisterType((*EstimateTxSize)(nil), "EstimateTxSize")
	proto.RegisterType((*TxSize)(nil), "TxSize")
	proto.RegisterType((*SignTx)(nil), "SignTx")
	proto.RegisterType((*SimpleSignTx)(nil), "SimpleSignTx")
	proto.RegisterType((*TxRequest)(nil), "TxRequest")
	proto.RegisterType((*TxAck)(nil), "TxAck")
	proto.RegisterType((*AquachainSignTx)(nil), "AquachainSignTx")
	proto.RegisterType((*AquachainTxRequest)(nil), "AquachainTxRequest")
	proto.RegisterType((*AquachainTxAck)(nil), "AquachainTxAck")
	proto.RegisterType((*AquachainSignMessage)(nil), "AquachainSignMessage")
	proto.RegisterType((*AquachainVerifyMessage)(nil), "AquachainVerifyMessage")
	proto.RegisterType((*AquachainMessageSignature)(nil), "AquachainMessageSignature")
	proto.RegisterType((*SignIdentity)(nil), "SignIdentity")
	proto.RegisterType((*SignedIdentity)(nil), "SignedIdentity")
	proto.RegisterType((*GetECDHSessionKey)(nil), "GetECDHSessionKey")
	proto.RegisterType((*ECDHSessionKey)(nil), "ECDHSessionKey")
	proto.RegisterType((*SetU2FCounter)(nil), "SetU2FCounter")
	proto.RegisterType((*FirmwareErase)(nil), "FirmwareErase")
	proto.RegisterType((*FirmwareRequest)(nil), "FirmwareRequest")
	proto.RegisterType((*FirmwareUpload)(nil), "FirmwareUpload")
	proto.RegisterType((*SelfTest)(nil), "SelfTest")
	proto.RegisterType((*DebugLinkDecision)(nil), "DebugLinkDecision")
	proto.RegisterType((*DebugLinkGetState)(nil), "DebugLinkGetState")
	proto.RegisterType((*DebugLinkState)(nil), "DebugLinkState")
	proto.RegisterType((*DebugLinkStop)(nil), "DebugLinkStop")
	proto.RegisterType((*DebugLinkLog)(nil), "DebugLinkLog")
	proto.RegisterType((*DebugLinkMemoryRead)(nil), "DebugLinkMemoryRead")
	proto.RegisterType((*DebugLinkMemory)(nil), "DebugLinkMemory")
	proto.RegisterType((*DebugLinkMemoryWrite)(nil), "DebugLinkMemoryWrite")
	proto.RegisterType((*DebugLinkFlashErase)(nil), "DebugLinkFlashErase")
}

func init() { proto.RegisterFile("messages.proto", fileDescriptor_4dc296cbfe5ffcd5) }

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