loop/looprpc/client.pb.go

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

package looprpc

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "google.golang.org/genproto/googleapis/api/annotations"

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

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type SwapType int32

const (
	// LOOP_OUT indicates an loop out swap (off-chain to on-chain)
	SwapType_LOOP_OUT SwapType = 0
	// LOOP_IN indicates a loop in swap (on-chain to off-chain)
	SwapType_LOOP_IN SwapType = 1
)

var SwapType_name = map[int32]string{
	0: "LOOP_OUT",
	1: "LOOP_IN",
}
var SwapType_value = map[string]int32{
	"LOOP_OUT": 0,
	"LOOP_IN":  1,
}

func (x SwapType) String() string {
	return proto.EnumName(SwapType_name, int32(x))
}
func (SwapType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_client_ba4b73c10b9bbc2a, []int{0}
}

type SwapState int32

const (
	// *
	// INITIATED is the initial state of a swap. At that point, the initiation
	// call to the server has been made and the payment process has been started
	// for the swap and prepayment invoices.
	SwapState_INITIATED SwapState = 0
	// *
	// PREIMAGE_REVEALED is reached when the sweep tx publication is first
	// attempted. From that point on, we should consider the preimage to no
	// longer be secret and we need to do all we can to get the sweep confirmed.
	// This state will mostly coalesce with StateHtlcConfirmed, except in the
	// case where we wait for fees to come down before we sweep.
	SwapState_PREIMAGE_REVEALED SwapState = 1
	// *
	// HTLC_PUBLISHED is reached when the htlc tx has been published in a loop in
	// swap.
	SwapState_HTLC_PUBLISHED SwapState = 2
	// *
	// SUCCESS is the final swap state that is reached when the sweep tx has
	// the required confirmation depth.
	SwapState_SUCCESS SwapState = 3
	// *
	// FAILED is the final swap state for a failed swap with or without loss of
	// the swap amount.
	SwapState_FAILED SwapState = 4
	// *
	// INVOICE_SETTLED is reached when the swap invoice in a loop in swap has been
	// paid, but we are still waiting for the htlc spend to confirm.
	SwapState_INVOICE_SETTLED SwapState = 5
)

var SwapState_name = map[int32]string{
	0: "INITIATED",
	1: "PREIMAGE_REVEALED",
	2: "HTLC_PUBLISHED",
	3: "SUCCESS",
	4: "FAILED",
	5: "INVOICE_SETTLED",
}
var SwapState_value = map[string]int32{
	"INITIATED":         0,
	"PREIMAGE_REVEALED": 1,
	"HTLC_PUBLISHED":    2,
	"SUCCESS":           3,
	"FAILED":            4,
	"INVOICE_SETTLED":   5,
}

func (x SwapState) String() string {
	return proto.EnumName(SwapState_name, int32(x))
}
func (SwapState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_client_ba4b73c10b9bbc2a, []int{1}
}

type LoopOutRequest struct {
	// *
	// Requested swap amount in sat. This does not include the swap and miner fee.
	Amt int64 `protobuf:"varint,1,opt,name=amt,proto3" json:"amt,omitempty"`
	// *
	// Base58 encoded destination address for the swap.
	Dest string `protobuf:"bytes,2,opt,name=dest,proto3" json:"dest,omitempty"`
	// *
	// Maximum off-chain fee in msat that may be paid for payment to the server.
	// This limit is applied during path finding. Typically this value is taken
	// from the response of the GetQuote call.
	MaxSwapRoutingFee int64 `protobuf:"varint,3,opt,name=max_swap_routing_fee,json=maxSwapRoutingFee,proto3" json:"max_swap_routing_fee,omitempty"`
	// *
	// Maximum off-chain fee in msat that may be paid for payment to the server.
	// This limit is applied during path finding. Typically this value is taken
	// from the response of the GetQuote call.
	MaxPrepayRoutingFee int64 `protobuf:"varint,4,opt,name=max_prepay_routing_fee,json=maxPrepayRoutingFee,proto3" json:"max_prepay_routing_fee,omitempty"`
	// *
	// Maximum we are willing to pay the server for the swap. This value is not
	// disclosed in the swap initiation call, but if the server asks for a
	// higher fee, we abort the swap. Typically this value is taken from the
	// response of the GetQuote call. It includes the prepay amount.
	MaxSwapFee int64 `protobuf:"varint,5,opt,name=max_swap_fee,json=maxSwapFee,proto3" json:"max_swap_fee,omitempty"`
	// *
	// Maximum amount of the swap fee that may be charged as a prepayment.
	MaxPrepayAmt int64 `protobuf:"varint,6,opt,name=max_prepay_amt,json=maxPrepayAmt,proto3" json:"max_prepay_amt,omitempty"`
	// *
	// Maximum in on-chain fees that we are willing to spent. If we want to
	// sweep the on-chain htlc and the fee estimate turns out higher than this
	// value, we cancel the swap. If the fee estimate is lower, we publish the
	// sweep tx.
	//
	// If the sweep tx is not confirmed, we are forced to ratchet up fees until it
	// is swept. Possibly even exceeding max_miner_fee if we get close to the htlc
	// timeout. Because the initial publication revealed the preimage, we have no
	// other choice. The server may already have pulled the off-chain htlc. Only
	// when the fee becomes higher than the swap amount, we can only wait for fees
	// to come down and hope - if we are past the timeout - that the server is not
	// publishing the revocation.
	//
	// max_miner_fee is typically taken from the response of the GetQuote call.
	MaxMinerFee int64 `protobuf:"varint,7,opt,name=max_miner_fee,json=maxMinerFee,proto3" json:"max_miner_fee,omitempty"`
	// *
	// The channel to loop out, the channel to loop out is selected based on the
	// lowest routing fee for the swap payment to the server.
	LoopOutChannel       uint64   `protobuf:"varint,8,opt,name=loop_out_channel,json=loopOutChannel,proto3" json:"loop_out_channel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_LoopOutRequest proto.InternalMessageInfo

func (m *LoopOutRequest) GetAmt() int64 {
	if m != nil {
		return m.Amt
	}
	return 0
}

func (m *LoopOutRequest) GetDest() string {
	if m != nil {
		return m.Dest
	}
	return ""
}

func (m *LoopOutRequest) GetMaxSwapRoutingFee() int64 {
	if m != nil {
		return m.MaxSwapRoutingFee
	}
	return 0
}

func (m *LoopOutRequest) GetMaxPrepayRoutingFee() int64 {
	if m != nil {
		return m.MaxPrepayRoutingFee
	}
	return 0
}

func (m *LoopOutRequest) GetMaxSwapFee() int64 {
	if m != nil {
		return m.MaxSwapFee
	}
	return 0
}

func (m *LoopOutRequest) GetMaxPrepayAmt() int64 {
	if m != nil {
		return m.MaxPrepayAmt
	}
	return 0
}

func (m *LoopOutRequest) GetMaxMinerFee() int64 {
	if m != nil {
		return m.MaxMinerFee
	}
	return 0
}

func (m *LoopOutRequest) GetLoopOutChannel() uint64 {
	if m != nil {
		return m.LoopOutChannel
	}
	return 0
}

type LoopInRequest struct {
	// *
	// Requested swap amount in sat. This does not include the swap and miner
	// fee.
	Amt int64 `protobuf:"varint,1,opt,name=amt,proto3" json:"amt,omitempty"`
	// *
	// Maximum we are willing to pay the server for the swap. This value is not
	// disclosed in the swap initiation call, but if the server asks for a
	// higher fee, we abort the swap. Typically this value is taken from the
	// response of the GetQuote call.
	MaxSwapFee int64 `protobuf:"varint,2,opt,name=max_swap_fee,json=maxSwapFee,proto3" json:"max_swap_fee,omitempty"`
	// *
	// Maximum in on-chain fees that we are willing to spent. If we want to
	// publish the on-chain htlc and the fee estimate turns out higher than this
	// value, we cancel the swap.
	//
	// max_miner_fee is typically taken from the response of the GetQuote call.
	MaxMinerFee int64 `protobuf:"varint,3,opt,name=max_miner_fee,json=maxMinerFee,proto3" json:"max_miner_fee,omitempty"`
	// *
	// The channel to loop in. If zero, the channel to loop in is selected based
	// on the lowest routing fee for the swap payment from the server.
	//
	// Note: NOT YET IMPLEMENTED
	LoopInChannel uint64 `protobuf:"varint,4,opt,name=loop_in_channel,json=loopInChannel,proto3" json:"loop_in_channel,omitempty"`
	// *
	// If external_htlc is true, we expect the htlc to be published by an external
	// actor.
	ExternalHtlc         bool     `protobuf:"varint,5,opt,name=external_htlc,json=externalHtlc,proto3" json:"external_htlc,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_LoopInRequest proto.InternalMessageInfo

func (m *LoopInRequest) GetAmt() int64 {
	if m != nil {
		return m.Amt
	}
	return 0
}

func (m *LoopInRequest) GetMaxSwapFee() int64 {
	if m != nil {
		return m.MaxSwapFee
	}
	return 0
}

func (m *LoopInRequest) GetMaxMinerFee() int64 {
	if m != nil {
		return m.MaxMinerFee
	}
	return 0
}

func (m *LoopInRequest) GetLoopInChannel() uint64 {
	if m != nil {
		return m.LoopInChannel
	}
	return 0
}

func (m *LoopInRequest) GetExternalHtlc() bool {
	if m != nil {
		return m.ExternalHtlc
	}
	return false
}

type SwapResponse struct {
	// *
	// Swap identifier to track status in the update stream that is returned from
	// the Start() call. Currently this is the hash that locks the htlcs.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// *
	// The address of the on-chain htlc.
	HtlcAddress          string   `protobuf:"bytes,2,opt,name=htlc_address,json=htlcAddress,proto3" json:"htlc_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SwapResponse proto.InternalMessageInfo

func (m *SwapResponse) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *SwapResponse) GetHtlcAddress() string {
	if m != nil {
		return m.HtlcAddress
	}
	return ""
}

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

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

var xxx_messageInfo_MonitorRequest proto.InternalMessageInfo

type SwapStatus struct {
	// *
	// Requested swap amount in sat. This does not include the swap and miner
	// fee.
	Amt int64 `protobuf:"varint,1,opt,name=amt,proto3" json:"amt,omitempty"`
	// *
	// Swap identifier to track status in the update stream that is returned from
	// the Start() call. Currently this is the hash that locks the htlcs.
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// *
	// Swap type
	Type SwapType `protobuf:"varint,3,opt,name=type,proto3,enum=looprpc.SwapType" json:"type,omitempty"`
	// *
	// State the swap is currently in, see State enum.
	State SwapState `protobuf:"varint,4,opt,name=state,proto3,enum=looprpc.SwapState" json:"state,omitempty"`
	// *
	// Initiation time of the swap.
	InitiationTime int64 `protobuf:"varint,5,opt,name=initiation_time,json=initiationTime,proto3" json:"initiation_time,omitempty"`
	// *
	// Initiation time of the swap.
	LastUpdateTime int64 `protobuf:"varint,6,opt,name=last_update_time,json=lastUpdateTime,proto3" json:"last_update_time,omitempty"`
	// *
	// Htlc address.
	HtlcAddress          string   `protobuf:"bytes,7,opt,name=htlc_address,json=htlcAddress,proto3" json:"htlc_address,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SwapStatus proto.InternalMessageInfo

func (m *SwapStatus) GetAmt() int64 {
	if m != nil {
		return m.Amt
	}
	return 0
}

func (m *SwapStatus) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *SwapStatus) GetType() SwapType {
	if m != nil {
		return m.Type
	}
	return SwapType_LOOP_OUT
}

func (m *SwapStatus) GetState() SwapState {
	if m != nil {
		return m.State
	}
	return SwapState_INITIATED
}

func (m *SwapStatus) GetInitiationTime() int64 {
	if m != nil {
		return m.InitiationTime
	}
	return 0
}

func (m *SwapStatus) GetLastUpdateTime() int64 {
	if m != nil {
		return m.LastUpdateTime
	}
	return 0
}

func (m *SwapStatus) GetHtlcAddress() string {
	if m != nil {
		return m.HtlcAddress
	}
	return ""
}

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

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

var xxx_messageInfo_TermsRequest proto.InternalMessageInfo

type TermsResponse struct {
	// *
	// The node pubkey where the swap payment needs to be paid
	// to. This can be used to test connectivity before initiating the swap.
	SwapPaymentDest string `protobuf:"bytes,1,opt,name=swap_payment_dest,json=swapPaymentDest,proto3" json:"swap_payment_dest,omitempty"`
	// *
	// The base fee for a swap (sat)
	SwapFeeBase int64 `protobuf:"varint,2,opt,name=swap_fee_base,json=swapFeeBase,proto3" json:"swap_fee_base,omitempty"`
	// *
	// The fee rate for a swap (parts per million)
	SwapFeeRate int64 `protobuf:"varint,3,opt,name=swap_fee_rate,json=swapFeeRate,proto3" json:"swap_fee_rate,omitempty"`
	// *
	// Required prepay amount
	PrepayAmt int64 `protobuf:"varint,4,opt,name=prepay_amt,json=prepayAmt,proto3" json:"prepay_amt,omitempty"`
	// *
	// Minimum swap amount (sat)
	MinSwapAmount int64 `protobuf:"varint,5,opt,name=min_swap_amount,json=minSwapAmount,proto3" json:"min_swap_amount,omitempty"`
	// *
	// Maximum swap amount (sat)
	MaxSwapAmount int64 `protobuf:"varint,6,opt,name=max_swap_amount,json=maxSwapAmount,proto3" json:"max_swap_amount,omitempty"`
	// *
	// On-chain cltv expiry delta
	CltvDelta            int32    `protobuf:"varint,7,opt,name=cltv_delta,json=cltvDelta,proto3" json:"cltv_delta,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TermsResponse proto.InternalMessageInfo

func (m *TermsResponse) GetSwapPaymentDest() string {
	if m != nil {
		return m.SwapPaymentDest
	}
	return ""
}

func (m *TermsResponse) GetSwapFeeBase() int64 {
	if m != nil {
		return m.SwapFeeBase
	}
	return 0
}

func (m *TermsResponse) GetSwapFeeRate() int64 {
	if m != nil {
		return m.SwapFeeRate
	}
	return 0
}

func (m *TermsResponse) GetPrepayAmt() int64 {
	if m != nil {
		return m.PrepayAmt
	}
	return 0
}

func (m *TermsResponse) GetMinSwapAmount() int64 {
	if m != nil {
		return m.MinSwapAmount
	}
	return 0
}

func (m *TermsResponse) GetMaxSwapAmount() int64 {
	if m != nil {
		return m.MaxSwapAmount
	}
	return 0
}

func (m *TermsResponse) GetCltvDelta() int32 {
	if m != nil {
		return m.CltvDelta
	}
	return 0
}

type QuoteRequest struct {
	// *
	// The amount to swap in satoshis.
	Amt                  int64    `protobuf:"varint,1,opt,name=amt,proto3" json:"amt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_QuoteRequest proto.InternalMessageInfo

func (m *QuoteRequest) GetAmt() int64 {
	if m != nil {
		return m.Amt
	}
	return 0
}

type QuoteResponse struct {
	// *
	// The fee that the swap server is charging for the swap.
	SwapFee int64 `protobuf:"varint,1,opt,name=swap_fee,json=swapFee,proto3" json:"swap_fee,omitempty"`
	// *
	// The part of the swap fee that is requested as a prepayment.
	PrepayAmt int64 `protobuf:"varint,2,opt,name=prepay_amt,json=prepayAmt,proto3" json:"prepay_amt,omitempty"`
	// *
	// An estimate of the on-chain fee that needs to be paid to sweep the HTLC.
	MinerFee             int64    `protobuf:"varint,3,opt,name=miner_fee,json=minerFee,proto3" json:"miner_fee,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_QuoteResponse proto.InternalMessageInfo

func (m *QuoteResponse) GetSwapFee() int64 {
	if m != nil {
		return m.SwapFee
	}
	return 0
}

func (m *QuoteResponse) GetPrepayAmt() int64 {
	if m != nil {
		return m.PrepayAmt
	}
	return 0
}

func (m *QuoteResponse) GetMinerFee() int64 {
	if m != nil {
		return m.MinerFee
	}
	return 0
}

func init() {
	proto.RegisterType((*LoopOutRequest)(nil), "looprpc.LoopOutRequest")
	proto.RegisterType((*LoopInRequest)(nil), "looprpc.LoopInRequest")
	proto.RegisterType((*SwapResponse)(nil), "looprpc.SwapResponse")
	proto.RegisterType((*MonitorRequest)(nil), "looprpc.MonitorRequest")
	proto.RegisterType((*SwapStatus)(nil), "looprpc.SwapStatus")
	proto.RegisterType((*TermsRequest)(nil), "looprpc.TermsRequest")
	proto.RegisterType((*TermsResponse)(nil), "looprpc.TermsResponse")
	proto.RegisterType((*QuoteRequest)(nil), "looprpc.QuoteRequest")
	proto.RegisterType((*QuoteResponse)(nil), "looprpc.QuoteResponse")
	proto.RegisterEnum("looprpc.SwapType", SwapType_name, SwapType_value)
	proto.RegisterEnum("looprpc.SwapState", SwapState_name, SwapState_value)
}

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

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

// SwapClientClient is the client API for SwapClient service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SwapClientClient interface {
	// * loop: `out`
	// LoopOut initiates an loop out swap with the given parameters. The call
	// returns after the swap has been set up with the swap server. From that
	// point onwards, progress can be tracked via the SwapStatus stream that is
	// returned from Monitor().
	LoopOut(ctx context.Context, in *LoopOutRequest, opts ...grpc.CallOption) (*SwapResponse, error)
	// *
	// LoopIn initiates a loop in swap with the given parameters. The call
	// returns after the swap has been set up with the swap server. From that
	// point onwards, progress can be tracked via the SwapStatus stream
	// that is returned from Monitor().
	LoopIn(ctx context.Context, in *LoopInRequest, opts ...grpc.CallOption) (*SwapResponse, error)
	// * loop: `monitor`
	// Monitor will return a stream of swap updates for currently active swaps.
	// TODO: add MonitorSync version for REST clients.
	Monitor(ctx context.Context, in *MonitorRequest, opts ...grpc.CallOption) (SwapClient_MonitorClient, error)
	// * loop: `terms`
	// LoopOutTerms returns the terms that the server enforces for a loop out swap.
	LoopOutTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error)
	// * loop: `quote`
	// LoopOutQuote returns a quote for a loop out swap with the provided
	// parameters.
	LoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error)
	// *
	// GetTerms returns the terms that the server enforces for swaps.
	GetLoopInTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error)
	// *
	// GetQuote returns a quote for a swap with the provided parameters.
	GetLoopInQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error)
}

type swapClientClient struct {
	cc *grpc.ClientConn
}

func NewSwapClientClient(cc *grpc.ClientConn) SwapClientClient {
	return &swapClientClient{cc}
}

func (c *swapClientClient) LoopOut(ctx context.Context, in *LoopOutRequest, opts ...grpc.CallOption) (*SwapResponse, error) {
	out := new(SwapResponse)
	err := c.cc.Invoke(ctx, "/looprpc.SwapClient/LoopOut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *swapClientClient) LoopIn(ctx context.Context, in *LoopInRequest, opts ...grpc.CallOption) (*SwapResponse, error) {
	out := new(SwapResponse)
	err := c.cc.Invoke(ctx, "/looprpc.SwapClient/LoopIn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *swapClientClient) Monitor(ctx context.Context, in *MonitorRequest, opts ...grpc.CallOption) (SwapClient_MonitorClient, error) {
	stream, err := c.cc.NewStream(ctx, &_SwapClient_serviceDesc.Streams[0], "/looprpc.SwapClient/Monitor", opts...)
	if err != nil {
		return nil, err
	}
	x := &swapClientMonitorClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type SwapClient_MonitorClient interface {
	Recv() (*SwapStatus, error)
	grpc.ClientStream
}

type swapClientMonitorClient struct {
	grpc.ClientStream
}

func (x *swapClientMonitorClient) Recv() (*SwapStatus, error) {
	m := new(SwapStatus)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *swapClientClient) LoopOutTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) {
	out := new(TermsResponse)
	err := c.cc.Invoke(ctx, "/looprpc.SwapClient/LoopOutTerms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *swapClientClient) LoopOutQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) {
	out := new(QuoteResponse)
	err := c.cc.Invoke(ctx, "/looprpc.SwapClient/LoopOutQuote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *swapClientClient) GetLoopInTerms(ctx context.Context, in *TermsRequest, opts ...grpc.CallOption) (*TermsResponse, error) {
	out := new(TermsResponse)
	err := c.cc.Invoke(ctx, "/looprpc.SwapClient/GetLoopInTerms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *swapClientClient) GetLoopInQuote(ctx context.Context, in *QuoteRequest, opts ...grpc.CallOption) (*QuoteResponse, error) {
	out := new(QuoteResponse)
	err := c.cc.Invoke(ctx, "/looprpc.SwapClient/GetLoopInQuote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SwapClientServer is the server API for SwapClient service.
type SwapClientServer interface {
	// * loop: `out`
	// LoopOut initiates an loop out swap with the given parameters. The call
	// returns after the swap has been set up with the swap server. From that
	// point onwards, progress can be tracked via the SwapStatus stream that is
	// returned from Monitor().
	LoopOut(context.Context, *LoopOutRequest) (*SwapResponse, error)
	// *
	// LoopIn initiates a loop in swap with the given parameters. The call
	// returns after the swap has been set up with the swap server. From that
	// point onwards, progress can be tracked via the SwapStatus stream
	// that is returned from Monitor().
	LoopIn(context.Context, *LoopInRequest) (*SwapResponse, error)
	// * loop: `monitor`
	// Monitor will return a stream of swap updates for currently active swaps.
	// TODO: add MonitorSync version for REST clients.
	Monitor(*MonitorRequest, SwapClient_MonitorServer) error
	// * loop: `terms`
	// LoopOutTerms returns the terms that the server enforces for a loop out swap.
	LoopOutTerms(context.Context, *TermsRequest) (*TermsResponse, error)
	// * loop: `quote`
	// LoopOutQuote returns a quote for a loop out swap with the provided
	// parameters.
	LoopOutQuote(context.Context, *QuoteRequest) (*QuoteResponse, error)
	// *
	// GetTerms returns the terms that the server enforces for swaps.
	GetLoopInTerms(context.Context, *TermsRequest) (*TermsResponse, error)
	// *
	// GetQuote returns a quote for a swap with the provided parameters.
	GetLoopInQuote(context.Context, *QuoteRequest) (*QuoteResponse, error)
}

func RegisterSwapClientServer(s *grpc.Server, srv SwapClientServer) {
	s.RegisterService(&_SwapClient_serviceDesc, srv)
}

func _SwapClient_LoopOut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoopOutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SwapClientServer).LoopOut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/looprpc.SwapClient/LoopOut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SwapClientServer).LoopOut(ctx, req.(*LoopOutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SwapClient_LoopIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoopInRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SwapClientServer).LoopIn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/looprpc.SwapClient/LoopIn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SwapClientServer).LoopIn(ctx, req.(*LoopInRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SwapClient_Monitor_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(MonitorRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(SwapClientServer).Monitor(m, &swapClientMonitorServer{stream})
}

type SwapClient_MonitorServer interface {
	Send(*SwapStatus) error
	grpc.ServerStream
}

type swapClientMonitorServer struct {
	grpc.ServerStream
}

func (x *swapClientMonitorServer) Send(m *SwapStatus) error {
	return x.ServerStream.SendMsg(m)
}

func _SwapClient_LoopOutTerms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TermsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SwapClientServer).LoopOutTerms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/looprpc.SwapClient/LoopOutTerms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SwapClientServer).LoopOutTerms(ctx, req.(*TermsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SwapClient_LoopOutQuote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QuoteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SwapClientServer).LoopOutQuote(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/looprpc.SwapClient/LoopOutQuote",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SwapClientServer).LoopOutQuote(ctx, req.(*QuoteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SwapClient_GetLoopInTerms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TermsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SwapClientServer).GetLoopInTerms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/looprpc.SwapClient/GetLoopInTerms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SwapClientServer).GetLoopInTerms(ctx, req.(*TermsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SwapClient_GetLoopInQuote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QuoteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SwapClientServer).GetLoopInQuote(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/looprpc.SwapClient/GetLoopInQuote",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SwapClientServer).GetLoopInQuote(ctx, req.(*QuoteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _SwapClient_serviceDesc = grpc.ServiceDesc{
	ServiceName: "looprpc.SwapClient",
	HandlerType: (*SwapClientServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "LoopOut",
			Handler:    _SwapClient_LoopOut_Handler,
		},
		{
			MethodName: "LoopIn",
			Handler:    _SwapClient_LoopIn_Handler,
		},
		{
			MethodName: "LoopOutTerms",
			Handler:    _SwapClient_LoopOutTerms_Handler,
		},
		{
			MethodName: "LoopOutQuote",
			Handler:    _SwapClient_LoopOutQuote_Handler,
		},
		{
			MethodName: "GetLoopInTerms",
			Handler:    _SwapClient_GetLoopInTerms_Handler,
		},
		{
			MethodName: "GetLoopInQuote",
			Handler:    _SwapClient_GetLoopInQuote_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Monitor",
			Handler:       _SwapClient_Monitor_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "client.proto",
}

func init() { proto.RegisterFile("client.proto", fileDescriptor_client_ba4b73c10b9bbc2a) }

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