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

package entity

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
	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.ProtoPackageIsVersion3 // please upgrade the proto package

type TokenType int32

const (
	TokenType_INVALID TokenType = 0
	TokenType_ETH     TokenType = 1
	TokenType_ERC20   TokenType = 2
)

var TokenType_name = map[int32]string{
	0: "INVALID",
	1: "ETH",
	2: "ERC20",
}

var TokenType_value = map[string]int32{
	"INVALID": 0,
	"ETH":     1,
	"ERC20":   2,
}

func (x TokenType) String() string {
	return proto.EnumName(TokenType_name, int32(x))
}

func (TokenType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{0}
}

type TransferFunctionType int32

const (
	TransferFunctionType_BOOLEAN_AND     TransferFunctionType = 0
	TransferFunctionType_BOOLEAN_OR      TransferFunctionType = 1
	TransferFunctionType_BOOLEAN_CIRCUIT TransferFunctionType = 2
	TransferFunctionType_NUMERIC_ADD     TransferFunctionType = 3
	TransferFunctionType_NUMERIC_MAX     TransferFunctionType = 4
	TransferFunctionType_NUMERIC_MIN     TransferFunctionType = 5
)

var TransferFunctionType_name = map[int32]string{
	0: "BOOLEAN_AND",
	1: "BOOLEAN_OR",
	2: "BOOLEAN_CIRCUIT",
	3: "NUMERIC_ADD",
	4: "NUMERIC_MAX",
	5: "NUMERIC_MIN",
}

var TransferFunctionType_value = map[string]int32{
	"BOOLEAN_AND":     0,
	"BOOLEAN_OR":      1,
	"BOOLEAN_CIRCUIT": 2,
	"NUMERIC_ADD":     3,
	"NUMERIC_MAX":     4,
	"NUMERIC_MIN":     5,
}

func (x TransferFunctionType) String() string {
	return proto.EnumName(TransferFunctionType_name, int32(x))
}

func (TransferFunctionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{1}
}

type ConditionType int32

const (
	ConditionType_HASH_LOCK         ConditionType = 0
	ConditionType_DEPLOYED_CONTRACT ConditionType = 1
	ConditionType_VIRTUAL_CONTRACT  ConditionType = 2
)

var ConditionType_name = map[int32]string{
	0: "HASH_LOCK",
	1: "DEPLOYED_CONTRACT",
	2: "VIRTUAL_CONTRACT",
}

var ConditionType_value = map[string]int32{
	"HASH_LOCK":         0,
	"DEPLOYED_CONTRACT": 1,
	"VIRTUAL_CONTRACT":  2,
}

func (x ConditionType) String() string {
	return proto.EnumName(ConditionType_name, int32(x))
}

func (ConditionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{2}
}

// Next Tag: 3
type AccountAmtPair struct {
	Account              []byte   `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	Amt                  []byte   `protobuf:"bytes,2,opt,name=amt,proto3" json:"amt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AccountAmtPair) Reset()         { *m = AccountAmtPair{} }
func (m *AccountAmtPair) String() string { return proto.CompactTextString(m) }
func (*AccountAmtPair) ProtoMessage()    {}
func (*AccountAmtPair) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{0}
}

func (m *AccountAmtPair) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AccountAmtPair.Unmarshal(m, b)
}
func (m *AccountAmtPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AccountAmtPair.Marshal(b, m, deterministic)
}
func (m *AccountAmtPair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AccountAmtPair.Merge(m, src)
}
func (m *AccountAmtPair) XXX_Size() int {
	return xxx_messageInfo_AccountAmtPair.Size(m)
}
func (m *AccountAmtPair) XXX_DiscardUnknown() {
	xxx_messageInfo_AccountAmtPair.DiscardUnknown(m)
}

var xxx_messageInfo_AccountAmtPair proto.InternalMessageInfo

func (m *AccountAmtPair) GetAccount() []byte {
	if m != nil {
		return m.Account
	}
	return nil
}

func (m *AccountAmtPair) GetAmt() []byte {
	if m != nil {
		return m.Amt
	}
	return nil
}

// Next Tag: 3
type TokenInfo struct {
	TokenType            TokenType `protobuf:"varint,1,opt,name=token_type,json=tokenType,proto3,enum=entity.TokenType" json:"token_type,omitempty"`
	TokenAddress         []byte    `protobuf:"bytes,2,opt,name=token_address,json=tokenAddress,proto3" json:"token_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *TokenInfo) Reset()         { *m = TokenInfo{} }
func (m *TokenInfo) String() string { return proto.CompactTextString(m) }
func (*TokenInfo) ProtoMessage()    {}
func (*TokenInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{1}
}

func (m *TokenInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TokenInfo.Unmarshal(m, b)
}
func (m *TokenInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TokenInfo.Marshal(b, m, deterministic)
}
func (m *TokenInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TokenInfo.Merge(m, src)
}
func (m *TokenInfo) XXX_Size() int {
	return xxx_messageInfo_TokenInfo.Size(m)
}
func (m *TokenInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TokenInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TokenInfo proto.InternalMessageInfo

func (m *TokenInfo) GetTokenType() TokenType {
	if m != nil {
		return m.TokenType
	}
	return TokenType_INVALID
}

func (m *TokenInfo) GetTokenAddress() []byte {
	if m != nil {
		return m.TokenAddress
	}
	return nil
}

// Next Tag: 3
type TokenDistribution struct {
	Token                *TokenInfo        `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Distribution         []*AccountAmtPair `protobuf:"bytes,2,rep,name=distribution,proto3" json:"distribution,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *TokenDistribution) Reset()         { *m = TokenDistribution{} }
func (m *TokenDistribution) String() string { return proto.CompactTextString(m) }
func (*TokenDistribution) ProtoMessage()    {}
func (*TokenDistribution) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{2}
}

func (m *TokenDistribution) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TokenDistribution.Unmarshal(m, b)
}
func (m *TokenDistribution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TokenDistribution.Marshal(b, m, deterministic)
}
func (m *TokenDistribution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TokenDistribution.Merge(m, src)
}
func (m *TokenDistribution) XXX_Size() int {
	return xxx_messageInfo_TokenDistribution.Size(m)
}
func (m *TokenDistribution) XXX_DiscardUnknown() {
	xxx_messageInfo_TokenDistribution.DiscardUnknown(m)
}

var xxx_messageInfo_TokenDistribution proto.InternalMessageInfo

func (m *TokenDistribution) GetToken() *TokenInfo {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *TokenDistribution) GetDistribution() []*AccountAmtPair {
	if m != nil {
		return m.Distribution
	}
	return nil
}

// Next Tag: 3
type TokenTransfer struct {
	Token                *TokenInfo      `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	Receiver             *AccountAmtPair `protobuf:"bytes,2,opt,name=receiver,proto3" json:"receiver,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *TokenTransfer) Reset()         { *m = TokenTransfer{} }
func (m *TokenTransfer) String() string { return proto.CompactTextString(m) }
func (*TokenTransfer) ProtoMessage()    {}
func (*TokenTransfer) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{3}
}

func (m *TokenTransfer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TokenTransfer.Unmarshal(m, b)
}
func (m *TokenTransfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TokenTransfer.Marshal(b, m, deterministic)
}
func (m *TokenTransfer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TokenTransfer.Merge(m, src)
}
func (m *TokenTransfer) XXX_Size() int {
	return xxx_messageInfo_TokenTransfer.Size(m)
}
func (m *TokenTransfer) XXX_DiscardUnknown() {
	xxx_messageInfo_TokenTransfer.DiscardUnknown(m)
}

var xxx_messageInfo_TokenTransfer proto.InternalMessageInfo

func (m *TokenTransfer) GetToken() *TokenInfo {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *TokenTransfer) GetReceiver() *AccountAmtPair {
	if m != nil {
		return m.Receiver
	}
	return nil
}

// Next Tag: 8
type SimplexPaymentChannel struct {
	ChannelId []byte `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// aka simplex channel owner.
	PeerFrom []byte `protobuf:"bytes,2,opt,name=peer_from,json=peerFrom,proto3" json:"peer_from,omitempty"`
	SeqNum   uint64 `protobuf:"varint,3,opt,name=seq_num,json=seqNum,proto3" json:"seq_num,omitempty"`
	// Unconditional token transfer to simplex channel peer, amount increases monotonically.
	TransferToPeer *TokenTransfer `protobuf:"bytes,4,opt,name=transfer_to_peer,json=transferToPeer,proto3" json:"transfer_to_peer,omitempty"`
	// head of the idlist chain of all pending conditional pays.
	PendingPayIds *PayIdList `protobuf:"bytes,5,opt,name=pending_pay_ids,json=pendingPayIds,proto3" json:"pending_pay_ids,omitempty"`
	// The last resolve deadline of all pending conditonal pays.
	// confirmSettle must be called after all pending pays have been finalized,
	// namely all pending pays have been resolved in the pay registry,
	// or after the last_pay_resolve_deadline.
	LastPayResolveDeadline uint64 `protobuf:"varint,6,opt,name=last_pay_resolve_deadline,json=lastPayResolveDeadline,proto3" json:"last_pay_resolve_deadline,omitempty"`
	// total amount of all pending pays.
	TotalPendingAmount   []byte   `protobuf:"bytes,7,opt,name=total_pending_amount,json=totalPendingAmount,proto3" json:"total_pending_amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SimplexPaymentChannel) Reset()         { *m = SimplexPaymentChannel{} }
func (m *SimplexPaymentChannel) String() string { return proto.CompactTextString(m) }
func (*SimplexPaymentChannel) ProtoMessage()    {}
func (*SimplexPaymentChannel) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{4}
}

func (m *SimplexPaymentChannel) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SimplexPaymentChannel.Unmarshal(m, b)
}
func (m *SimplexPaymentChannel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SimplexPaymentChannel.Marshal(b, m, deterministic)
}
func (m *SimplexPaymentChannel) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SimplexPaymentChannel.Merge(m, src)
}
func (m *SimplexPaymentChannel) XXX_Size() int {
	return xxx_messageInfo_SimplexPaymentChannel.Size(m)
}
func (m *SimplexPaymentChannel) XXX_DiscardUnknown() {
	xxx_messageInfo_SimplexPaymentChannel.DiscardUnknown(m)
}

var xxx_messageInfo_SimplexPaymentChannel proto.InternalMessageInfo

func (m *SimplexPaymentChannel) GetChannelId() []byte {
	if m != nil {
		return m.ChannelId
	}
	return nil
}

func (m *SimplexPaymentChannel) GetPeerFrom() []byte {
	if m != nil {
		return m.PeerFrom
	}
	return nil
}

func (m *SimplexPaymentChannel) GetSeqNum() uint64 {
	if m != nil {
		return m.SeqNum
	}
	return 0
}

func (m *SimplexPaymentChannel) GetTransferToPeer() *TokenTransfer {
	if m != nil {
		return m.TransferToPeer
	}
	return nil
}

func (m *SimplexPaymentChannel) GetPendingPayIds() *PayIdList {
	if m != nil {
		return m.PendingPayIds
	}
	return nil
}

func (m *SimplexPaymentChannel) GetLastPayResolveDeadline() uint64 {
	if m != nil {
		return m.LastPayResolveDeadline
	}
	return 0
}

func (m *SimplexPaymentChannel) GetTotalPendingAmount() []byte {
	if m != nil {
		return m.TotalPendingAmount
	}
	return nil
}

// Next Tag: 3
type PayIdList struct {
	// array of ids of serialized ConditionalPay
	// pay_id is computed as hash(hash(cond_pay), pay_resolver_address)
	PayIds [][]byte `protobuf:"bytes,1,rep,name=pay_ids,json=payIds,proto3" json:"pay_ids,omitempty"`
	// hash of serialized next PayIdList
	NextListHash         []byte   `protobuf:"bytes,2,opt,name=next_list_hash,json=nextListHash,proto3" json:"next_list_hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PayIdList) Reset()         { *m = PayIdList{} }
func (m *PayIdList) String() string { return proto.CompactTextString(m) }
func (*PayIdList) ProtoMessage()    {}
func (*PayIdList) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{5}
}

func (m *PayIdList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PayIdList.Unmarshal(m, b)
}
func (m *PayIdList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PayIdList.Marshal(b, m, deterministic)
}
func (m *PayIdList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PayIdList.Merge(m, src)
}
func (m *PayIdList) XXX_Size() int {
	return xxx_messageInfo_PayIdList.Size(m)
}
func (m *PayIdList) XXX_DiscardUnknown() {
	xxx_messageInfo_PayIdList.DiscardUnknown(m)
}

var xxx_messageInfo_PayIdList proto.InternalMessageInfo

func (m *PayIdList) GetPayIds() [][]byte {
	if m != nil {
		return m.PayIds
	}
	return nil
}

func (m *PayIdList) GetNextListHash() []byte {
	if m != nil {
		return m.NextListHash
	}
	return nil
}

// Next Tag: 3
type TransferFunction struct {
	// Return transfer amount based on condition results.
	// TransferFunctionType is sufficient for simple functions such as
	// BOOLEAN_AND, BOOLEAN_OR, NUMERIC_ADD, NUMERIC_MAX, and NUMERIC_MIN.
	// When logic_type is NUMERIC_*, hashlock condition is always treated as BOOLEAN_AND
	// to other conditions, i.e., payment only happens when hash preimages are revealed.
	LogicType            TransferFunctionType `protobuf:"varint,1,opt,name=logic_type,json=logicType,proto3,enum=entity.TransferFunctionType" json:"logic_type,omitempty"`
	MaxTransfer          *TokenTransfer       `protobuf:"bytes,2,opt,name=max_transfer,json=maxTransfer,proto3" json:"max_transfer,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *TransferFunction) Reset()         { *m = TransferFunction{} }
func (m *TransferFunction) String() string { return proto.CompactTextString(m) }
func (*TransferFunction) ProtoMessage()    {}
func (*TransferFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{6}
}

func (m *TransferFunction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TransferFunction.Unmarshal(m, b)
}
func (m *TransferFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TransferFunction.Marshal(b, m, deterministic)
}
func (m *TransferFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransferFunction.Merge(m, src)
}
func (m *TransferFunction) XXX_Size() int {
	return xxx_messageInfo_TransferFunction.Size(m)
}
func (m *TransferFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_TransferFunction.DiscardUnknown(m)
}

var xxx_messageInfo_TransferFunction proto.InternalMessageInfo

func (m *TransferFunction) GetLogicType() TransferFunctionType {
	if m != nil {
		return m.LogicType
	}
	return TransferFunctionType_BOOLEAN_AND
}

func (m *TransferFunction) GetMaxTransfer() *TokenTransfer {
	if m != nil {
		return m.MaxTransfer
	}
	return nil
}

// Next Tag: 9
type ConditionalPay struct {
	// pay_timestamp is set by payment source, to ensure no same condpay between src-dst
	// global unique pay id used on-chain is computed as hash(hash(cond_pay), pay_resolver_address)
	PayTimestamp uint64 `protobuf:"varint,1,opt,name=pay_timestamp,json=payTimestamp,proto3" json:"pay_timestamp,omitempty"`
	// src and dest are public keys of payment sender and receiver used to vouch the payment result.
	// For simplicity, current off-chain backend implementation requires these two fields to be the
	// sender and receiver account addresses. With better off-chain communication protocols in the
	// future, these two fields will not need to be the same with the actual sender and receiver
	// account addresses, and can be randomly changed by the sender and receiver to preserve privacy.
	Src  []byte `protobuf:"bytes,2,opt,name=src,proto3" json:"src,omitempty"`
	Dest []byte `protobuf:"bytes,3,opt,name=dest,proto3" json:"dest,omitempty"`
	// list of generic conditions for the payment
	Conditions []*Condition `protobuf:"bytes,4,rep,name=conditions,proto3" json:"conditions,omitempty"`
	// transfer_func :: [ConditionResult] -> TokenTransfer
	// transfer_func.max_transfer.receiver.account is not needed for unicast payment
	TransferFunc *TransferFunction `protobuf:"bytes,5,opt,name=transfer_func,json=transferFunc,proto3" json:"transfer_func,omitempty"`
	// resolve_deadline is the deadline for a cond_pay to be resolved on chain in the
	// pay resgistry by either condition or vouched results, and the payment result
	// is finalized after resolve_deadline.
	// Payment channel peers should apply a safe_margin for off-chain processing,
	// i.e., should take dispute action before [resolve_deadline - safe_margin]
	ResolveDeadline uint64 `protobuf:"varint,6,opt,name=resolve_deadline,json=resolveDeadline,proto3" json:"resolve_deadline,omitempty"`
	// resolve_timeout is the dispute window after a resolve payment request is submitted
	ResolveTimeout       uint64   `protobuf:"varint,7,opt,name=resolve_timeout,json=resolveTimeout,proto3" json:"resolve_timeout,omitempty"`
	PayResolver          []byte   `protobuf:"bytes,8,opt,name=pay_resolver,json=payResolver,proto3" json:"pay_resolver,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConditionalPay) Reset()         { *m = ConditionalPay{} }
func (m *ConditionalPay) String() string { return proto.CompactTextString(m) }
func (*ConditionalPay) ProtoMessage()    {}
func (*ConditionalPay) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{7}
}

func (m *ConditionalPay) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConditionalPay.Unmarshal(m, b)
}
func (m *ConditionalPay) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConditionalPay.Marshal(b, m, deterministic)
}
func (m *ConditionalPay) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConditionalPay.Merge(m, src)
}
func (m *ConditionalPay) XXX_Size() int {
	return xxx_messageInfo_ConditionalPay.Size(m)
}
func (m *ConditionalPay) XXX_DiscardUnknown() {
	xxx_messageInfo_ConditionalPay.DiscardUnknown(m)
}

var xxx_messageInfo_ConditionalPay proto.InternalMessageInfo

func (m *ConditionalPay) GetPayTimestamp() uint64 {
	if m != nil {
		return m.PayTimestamp
	}
	return 0
}

func (m *ConditionalPay) GetSrc() []byte {
	if m != nil {
		return m.Src
	}
	return nil
}

func (m *ConditionalPay) GetDest() []byte {
	if m != nil {
		return m.Dest
	}
	return nil
}

func (m *ConditionalPay) GetConditions() []*Condition {
	if m != nil {
		return m.Conditions
	}
	return nil
}

func (m *ConditionalPay) GetTransferFunc() *TransferFunction {
	if m != nil {
		return m.TransferFunc
	}
	return nil
}

func (m *ConditionalPay) GetResolveDeadline() uint64 {
	if m != nil {
		return m.ResolveDeadline
	}
	return 0
}

func (m *ConditionalPay) GetResolveTimeout() uint64 {
	if m != nil {
		return m.ResolveTimeout
	}
	return 0
}

func (m *ConditionalPay) GetPayResolver() []byte {
	if m != nil {
		return m.PayResolver
	}
	return nil
}

// Next Tag: 3
type CondPayResult struct {
	// serialized ConditionalPay
	CondPay              []byte   `protobuf:"bytes,1,opt,name=cond_pay,json=condPay,proto3" json:"cond_pay,omitempty"`
	Amount               []byte   `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CondPayResult) Reset()         { *m = CondPayResult{} }
func (m *CondPayResult) String() string { return proto.CompactTextString(m) }
func (*CondPayResult) ProtoMessage()    {}
func (*CondPayResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{8}
}

func (m *CondPayResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CondPayResult.Unmarshal(m, b)
}
func (m *CondPayResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CondPayResult.Marshal(b, m, deterministic)
}
func (m *CondPayResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CondPayResult.Merge(m, src)
}
func (m *CondPayResult) XXX_Size() int {
	return xxx_messageInfo_CondPayResult.Size(m)
}
func (m *CondPayResult) XXX_DiscardUnknown() {
	xxx_messageInfo_CondPayResult.DiscardUnknown(m)
}

var xxx_messageInfo_CondPayResult proto.InternalMessageInfo

func (m *CondPayResult) GetCondPay() []byte {
	if m != nil {
		return m.CondPay
	}
	return nil
}

func (m *CondPayResult) GetAmount() []byte {
	if m != nil {
		return m.Amount
	}
	return nil
}

// Next Tag: 4
type VouchedCondPayResult struct {
	// serialized CondPayResult
	CondPayResult        []byte   `protobuf:"bytes,1,opt,name=cond_pay_result,json=condPayResult,proto3" json:"cond_pay_result,omitempty"`
	SigOfSrc             []byte   `protobuf:"bytes,2,opt,name=sig_of_src,json=sigOfSrc,proto3" json:"sig_of_src,omitempty"`
	SigOfDest            []byte   `protobuf:"bytes,3,opt,name=sig_of_dest,json=sigOfDest,proto3" json:"sig_of_dest,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VouchedCondPayResult) Reset()         { *m = VouchedCondPayResult{} }
func (m *VouchedCondPayResult) String() string { return proto.CompactTextString(m) }
func (*VouchedCondPayResult) ProtoMessage()    {}
func (*VouchedCondPayResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{9}
}

func (m *VouchedCondPayResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VouchedCondPayResult.Unmarshal(m, b)
}
func (m *VouchedCondPayResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VouchedCondPayResult.Marshal(b, m, deterministic)
}
func (m *VouchedCondPayResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VouchedCondPayResult.Merge(m, src)
}
func (m *VouchedCondPayResult) XXX_Size() int {
	return xxx_messageInfo_VouchedCondPayResult.Size(m)
}
func (m *VouchedCondPayResult) XXX_DiscardUnknown() {
	xxx_messageInfo_VouchedCondPayResult.DiscardUnknown(m)
}

var xxx_messageInfo_VouchedCondPayResult proto.InternalMessageInfo

func (m *VouchedCondPayResult) GetCondPayResult() []byte {
	if m != nil {
		return m.CondPayResult
	}
	return nil
}

func (m *VouchedCondPayResult) GetSigOfSrc() []byte {
	if m != nil {
		return m.SigOfSrc
	}
	return nil
}

func (m *VouchedCondPayResult) GetSigOfDest() []byte {
	if m != nil {
		return m.SigOfDest
	}
	return nil
}

// Next Tag: 7
type Condition struct {
	ConditionType ConditionType `protobuf:"varint,1,opt,name=condition_type,json=conditionType,proto3,enum=entity.ConditionType" json:"condition_type,omitempty"`
	// one of the following:
	// 1. hash of the secret preimage
	HashLock []byte `protobuf:"bytes,2,opt,name=hash_lock,json=hashLock,proto3" json:"hash_lock,omitempty"`
	// 2. onchain deployed contract
	DeployedContractAddress []byte `protobuf:"bytes,3,opt,name=deployed_contract_address,json=deployedContractAddress,proto3" json:"deployed_contract_address,omitempty"`
	// 3. offchain virtual contract
	VirtualContractAddress []byte   `protobuf:"bytes,4,opt,name=virtual_contract_address,json=virtualContractAddress,proto3" json:"virtual_contract_address,omitempty"`
	ArgsQueryFinalization  []byte   `protobuf:"bytes,5,opt,name=args_query_finalization,json=argsQueryFinalization,proto3" json:"args_query_finalization,omitempty"`
	ArgsQueryOutcome       []byte   `protobuf:"bytes,6,opt,name=args_query_outcome,json=argsQueryOutcome,proto3" json:"args_query_outcome,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

func (m *Condition) Reset()         { *m = Condition{} }
func (m *Condition) String() string { return proto.CompactTextString(m) }
func (*Condition) ProtoMessage()    {}
func (*Condition) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{10}
}

func (m *Condition) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Condition.Unmarshal(m, b)
}
func (m *Condition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Condition.Marshal(b, m, deterministic)
}
func (m *Condition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Condition.Merge(m, src)
}
func (m *Condition) XXX_Size() int {
	return xxx_messageInfo_Condition.Size(m)
}
func (m *Condition) XXX_DiscardUnknown() {
	xxx_messageInfo_Condition.DiscardUnknown(m)
}

var xxx_messageInfo_Condition proto.InternalMessageInfo

func (m *Condition) GetConditionType() ConditionType {
	if m != nil {
		return m.ConditionType
	}
	return ConditionType_HASH_LOCK
}

func (m *Condition) GetHashLock() []byte {
	if m != nil {
		return m.HashLock
	}
	return nil
}

func (m *Condition) GetDeployedContractAddress() []byte {
	if m != nil {
		return m.DeployedContractAddress
	}
	return nil
}

func (m *Condition) GetVirtualContractAddress() []byte {
	if m != nil {
		return m.VirtualContractAddress
	}
	return nil
}

func (m *Condition) GetArgsQueryFinalization() []byte {
	if m != nil {
		return m.ArgsQueryFinalization
	}
	return nil
}

func (m *Condition) GetArgsQueryOutcome() []byte {
	if m != nil {
		return m.ArgsQueryOutcome
	}
	return nil
}

// Next Tag: 6
type CooperativeWithdrawInfo struct {
	ChannelId        []byte          `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	SeqNum           uint64          `protobuf:"varint,2,opt,name=seq_num,json=seqNum,proto3" json:"seq_num,omitempty"`
	Withdraw         *AccountAmtPair `protobuf:"bytes,3,opt,name=withdraw,proto3" json:"withdraw,omitempty"`
	WithdrawDeadline uint64          `protobuf:"varint,4,opt,name=withdraw_deadline,json=withdrawDeadline,proto3" json:"withdraw_deadline,omitempty"`
	// if non-zero, do balance transfer to the recipient channel
	// instead of withdraw to the account
	RecipientChannelId   []byte   `protobuf:"bytes,5,opt,name=recipient_channel_id,json=recipientChannelId,proto3" json:"recipient_channel_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CooperativeWithdrawInfo) Reset()         { *m = CooperativeWithdrawInfo{} }
func (m *CooperativeWithdrawInfo) String() string { return proto.CompactTextString(m) }
func (*CooperativeWithdrawInfo) ProtoMessage()    {}
func (*CooperativeWithdrawInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{11}
}

func (m *CooperativeWithdrawInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CooperativeWithdrawInfo.Unmarshal(m, b)
}
func (m *CooperativeWithdrawInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CooperativeWithdrawInfo.Marshal(b, m, deterministic)
}
func (m *CooperativeWithdrawInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CooperativeWithdrawInfo.Merge(m, src)
}
func (m *CooperativeWithdrawInfo) XXX_Size() int {
	return xxx_messageInfo_CooperativeWithdrawInfo.Size(m)
}
func (m *CooperativeWithdrawInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_CooperativeWithdrawInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CooperativeWithdrawInfo proto.InternalMessageInfo

func (m *CooperativeWithdrawInfo) GetChannelId() []byte {
	if m != nil {
		return m.ChannelId
	}
	return nil
}

func (m *CooperativeWithdrawInfo) GetSeqNum() uint64 {
	if m != nil {
		return m.SeqNum
	}
	return 0
}

func (m *CooperativeWithdrawInfo) GetWithdraw() *AccountAmtPair {
	if m != nil {
		return m.Withdraw
	}
	return nil
}

func (m *CooperativeWithdrawInfo) GetWithdrawDeadline() uint64 {
	if m != nil {
		return m.WithdrawDeadline
	}
	return 0
}

func (m *CooperativeWithdrawInfo) GetRecipientChannelId() []byte {
	if m != nil {
		return m.RecipientChannelId
	}
	return nil
}

// Next Tag: 5
type PaymentChannelInitializer struct {
	// require an ascending order based on addresses of init_distribution.distribution[].account
	InitDistribution *TokenDistribution `protobuf:"bytes,1,opt,name=init_distribution,json=initDistribution,proto3" json:"init_distribution,omitempty"`
	OpenDeadline     uint64             `protobuf:"varint,2,opt,name=open_deadline,json=openDeadline,proto3" json:"open_deadline,omitempty"`
	DisputeTimeout   uint64             `protobuf:"varint,3,opt,name=dispute_timeout,json=disputeTimeout,proto3" json:"dispute_timeout,omitempty"`
	// index of channel peer who receives the blockchain native token
	// associated with the transaction (msg.value in case of ETH)
	MsgValueReceiver     uint64   `protobuf:"varint,4,opt,name=msg_value_receiver,json=msgValueReceiver,proto3" json:"msg_value_receiver,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PaymentChannelInitializer) Reset()         { *m = PaymentChannelInitializer{} }
func (m *PaymentChannelInitializer) String() string { return proto.CompactTextString(m) }
func (*PaymentChannelInitializer) ProtoMessage()    {}
func (*PaymentChannelInitializer) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{12}
}

func (m *PaymentChannelInitializer) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PaymentChannelInitializer.Unmarshal(m, b)
}
func (m *PaymentChannelInitializer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PaymentChannelInitializer.Marshal(b, m, deterministic)
}
func (m *PaymentChannelInitializer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PaymentChannelInitializer.Merge(m, src)
}
func (m *PaymentChannelInitializer) XXX_Size() int {
	return xxx_messageInfo_PaymentChannelInitializer.Size(m)
}
func (m *PaymentChannelInitializer) XXX_DiscardUnknown() {
	xxx_messageInfo_PaymentChannelInitializer.DiscardUnknown(m)
}

var xxx_messageInfo_PaymentChannelInitializer proto.InternalMessageInfo

func (m *PaymentChannelInitializer) GetInitDistribution() *TokenDistribution {
	if m != nil {
		return m.InitDistribution
	}
	return nil
}

func (m *PaymentChannelInitializer) GetOpenDeadline() uint64 {
	if m != nil {
		return m.OpenDeadline
	}
	return 0
}

func (m *PaymentChannelInitializer) GetDisputeTimeout() uint64 {
	if m != nil {
		return m.DisputeTimeout
	}
	return 0
}

func (m *PaymentChannelInitializer) GetMsgValueReceiver() uint64 {
	if m != nil {
		return m.MsgValueReceiver
	}
	return 0
}

// Next Tag: 5
type CooperativeSettleInfo struct {
	ChannelId []byte `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// contracts should require seq_num > both seq_nums of two SimplexPaymentChannel
	SeqNum uint64 `protobuf:"varint,2,opt,name=seq_num,json=seqNum,proto3" json:"seq_num,omitempty"`
	// final balance distribution without any conditional payments
	SettleBalance        []*AccountAmtPair `protobuf:"bytes,3,rep,name=settle_balance,json=settleBalance,proto3" json:"settle_balance,omitempty"`
	SettleDeadline       uint64            `protobuf:"varint,4,opt,name=settle_deadline,json=settleDeadline,proto3" json:"settle_deadline,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *CooperativeSettleInfo) Reset()         { *m = CooperativeSettleInfo{} }
func (m *CooperativeSettleInfo) String() string { return proto.CompactTextString(m) }
func (*CooperativeSettleInfo) ProtoMessage()    {}
func (*CooperativeSettleInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{13}
}

func (m *CooperativeSettleInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CooperativeSettleInfo.Unmarshal(m, b)
}
func (m *CooperativeSettleInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CooperativeSettleInfo.Marshal(b, m, deterministic)
}
func (m *CooperativeSettleInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CooperativeSettleInfo.Merge(m, src)
}
func (m *CooperativeSettleInfo) XXX_Size() int {
	return xxx_messageInfo_CooperativeSettleInfo.Size(m)
}
func (m *CooperativeSettleInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_CooperativeSettleInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CooperativeSettleInfo proto.InternalMessageInfo

func (m *CooperativeSettleInfo) GetChannelId() []byte {
	if m != nil {
		return m.ChannelId
	}
	return nil
}

func (m *CooperativeSettleInfo) GetSeqNum() uint64 {
	if m != nil {
		return m.SeqNum
	}
	return 0
}

func (m *CooperativeSettleInfo) GetSettleBalance() []*AccountAmtPair {
	if m != nil {
		return m.SettleBalance
	}
	return nil
}

func (m *CooperativeSettleInfo) GetSettleDeadline() uint64 {
	if m != nil {
		return m.SettleDeadline
	}
	return 0
}

// Next Tag: 5
type ChannelMigrationInfo struct {
	ChannelId            []byte   `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	FromLedgerAddress    []byte   `protobuf:"bytes,2,opt,name=from_ledger_address,json=fromLedgerAddress,proto3" json:"from_ledger_address,omitempty"`
	ToLedgerAddress      []byte   `protobuf:"bytes,3,opt,name=to_ledger_address,json=toLedgerAddress,proto3" json:"to_ledger_address,omitempty"`
	MigrationDeadline    uint64   `protobuf:"varint,4,opt,name=migration_deadline,json=migrationDeadline,proto3" json:"migration_deadline,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChannelMigrationInfo) Reset()         { *m = ChannelMigrationInfo{} }
func (m *ChannelMigrationInfo) String() string { return proto.CompactTextString(m) }
func (*ChannelMigrationInfo) ProtoMessage()    {}
func (*ChannelMigrationInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_cf50d946d740d100, []int{14}
}

func (m *ChannelMigrationInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ChannelMigrationInfo.Unmarshal(m, b)
}
func (m *ChannelMigrationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ChannelMigrationInfo.Marshal(b, m, deterministic)
}
func (m *ChannelMigrationInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelMigrationInfo.Merge(m, src)
}
func (m *ChannelMigrationInfo) XXX_Size() int {
	return xxx_messageInfo_ChannelMigrationInfo.Size(m)
}
func (m *ChannelMigrationInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelMigrationInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelMigrationInfo proto.InternalMessageInfo

func (m *ChannelMigrationInfo) GetChannelId() []byte {
	if m != nil {
		return m.ChannelId
	}
	return nil
}

func (m *ChannelMigrationInfo) GetFromLedgerAddress() []byte {
	if m != nil {
		return m.FromLedgerAddress
	}
	return nil
}

func (m *ChannelMigrationInfo) GetToLedgerAddress() []byte {
	if m != nil {
		return m.ToLedgerAddress
	}
	return nil
}

func (m *ChannelMigrationInfo) GetMigrationDeadline() uint64 {
	if m != nil {
		return m.MigrationDeadline
	}
	return 0
}

var E_Soltype = &proto.ExtensionDesc{
	ExtendedType:  (*descriptor.FieldOptions)(nil),
	ExtensionType: (*string)(nil),
	Field:         1001,
	Name:          "entity.soltype",
	Tag:           "bytes,1001,opt,name=soltype",
	Filename:      "entity.proto",
}

func init() {
	proto.RegisterEnum("entity.TokenType", TokenType_name, TokenType_value)
	proto.RegisterEnum("entity.TransferFunctionType", TransferFunctionType_name, TransferFunctionType_value)
	proto.RegisterEnum("entity.ConditionType", ConditionType_name, ConditionType_value)
	proto.RegisterType((*AccountAmtPair)(nil), "entity.AccountAmtPair")
	proto.RegisterType((*TokenInfo)(nil), "entity.TokenInfo")
	proto.RegisterType((*TokenDistribution)(nil), "entity.TokenDistribution")
	proto.RegisterType((*TokenTransfer)(nil), "entity.TokenTransfer")
	proto.RegisterType((*SimplexPaymentChannel)(nil), "entity.SimplexPaymentChannel")
	proto.RegisterType((*PayIdList)(nil), "entity.PayIdList")
	proto.RegisterType((*TransferFunction)(nil), "entity.TransferFunction")
	proto.RegisterType((*ConditionalPay)(nil), "entity.ConditionalPay")
	proto.RegisterType((*CondPayResult)(nil), "entity.CondPayResult")
	proto.RegisterType((*VouchedCondPayResult)(nil), "entity.VouchedCondPayResult")
	proto.RegisterType((*Condition)(nil), "entity.Condition")
	proto.RegisterType((*CooperativeWithdrawInfo)(nil), "entity.CooperativeWithdrawInfo")
	proto.RegisterType((*PaymentChannelInitializer)(nil), "entity.PaymentChannelInitializer")
	proto.RegisterType((*CooperativeSettleInfo)(nil), "entity.CooperativeSettleInfo")
	proto.RegisterType((*ChannelMigrationInfo)(nil), "entity.ChannelMigrationInfo")
	proto.RegisterExtension(E_Soltype)
}

func init() { proto.RegisterFile("entity.proto", fileDescriptor_cf50d946d740d100) }

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