akovalenko/lnd.xprv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #3693 from cfromknecht/tlv-invoice

Browse Source 
migrate to tlv for invoice body
This commit is contained in:
Olaoluwa Osuntokun 2019-11-25 18:00:52 -06:00 committed by GitHub
commit cb2b8b4513
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 1569 additions and 822 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
channeldb/db.go
View File

@ -13,6 +13,7 @@ import (
"github.com/btcsuite/btcd/wire"
"github.com/coreos/bbolt"
"github.com/go-errors/errors"
"github.com/lightningnetwork/lnd/channeldb/migration12"
"github.com/lightningnetwork/lnd/channeldb/migration_01_to_11"
"github.com/lightningnetwork/lnd/lnwire"
)
@ -116,6 +117,12 @@ var (
number: 11,
migration: migration_01_to_11.MigrateInvoices,
},
{
// Migrate to TLV invoice bodies, add payment address
// and features, remove receipt.
number: 12,
migration: migration12.MigrateInvoiceTLV,
},
}
// Big endian is the preferred byte order, due to cursor scans over

18
channeldb/invoice_test.go
View File

@ -10,6 +10,10 @@ import (
"github.com/lightningnetwork/lnd/lnwire"
)
var (
emptyFeatures = lnwire.NewFeatureVector(nil, lnwire.Features)
)
func randInvoice(value lnwire.MilliSatoshi) (*Invoice, error) {
var pre [32]byte
if _, err := rand.Read(pre[:]); err != nil {
@ -21,14 +25,14 @@ func randInvoice(value lnwire.MilliSatoshi) (*Invoice, error) {
// failures due to the monotonic time component.
CreationDate: time.Unix(time.Now().Unix(), 0),
Terms: ContractTerm{
Expiry: 4000,
PaymentPreimage: pre,
Value: value,
Features: emptyFeatures,
},
Htlcs: map[CircuitKey]*InvoiceHTLC{},
Expiry: 4000,
Htlcs: map[CircuitKey]*InvoiceHTLC{},
}
i.Memo = []byte("memo")
i.Receipt = []byte("receipt")
// Create a random byte slice of MaxPaymentRequestSize bytes to be used
// as a dummy paymentrequest, and determine if it should be set based
@ -64,10 +68,10 @@ func TestInvoiceWorkflow(t *testing.T) {
Htlcs: map[CircuitKey]*InvoiceHTLC{},
}
fakeInvoice.Memo = []byte("memo")
fakeInvoice.Receipt = []byte("receipt")
fakeInvoice.PaymentRequest = []byte("")
copy(fakeInvoice.Terms.PaymentPreimage[:], rev[:])
fakeInvoice.Terms.Value = lnwire.NewMSatFromSatoshis(10000)
fakeInvoice.Terms.Features = emptyFeatures
paymentHash := fakeInvoice.Terms.PaymentPreimage.Hash()
@ -110,7 +114,7 @@ func TestInvoiceWorkflow(t *testing.T) {
if err != nil {
t.Fatalf("unable to fetch invoice: %v", err)
}
if dbInvoice2.Terms.State != ContractSettled {
if dbInvoice2.State != ContractSettled {
t.Fatalf("invoice should now be settled but isn't")
}
if dbInvoice2.SettleDate.IsZero() {
@ -359,7 +363,7 @@ func TestDuplicateSettleInvoice(t *testing.T) {
// We'll update what we expect the settle invoice to be so that our
// comparison below has the correct assumption.
invoice.SettleIndex = 1
invoice.Terms.State = ContractSettled
invoice.State = ContractSettled
invoice.AmtPaid = amt
invoice.SettleDate = dbInvoice.SettleDate
invoice.Htlcs = map[CircuitKey]*InvoiceHTLC{
@ -675,7 +679,7 @@ func TestQueryInvoices(t *testing.T) {
// settles the invoice with the given amount.
func getUpdateInvoice(amt lnwire.MilliSatoshi) InvoiceUpdateCallback {
return func(invoice *Invoice) (*InvoiceUpdateDesc, error) {
if invoice.Terms.State == ContractSettled {
if invoice.State == ContractSettled {
return nil, ErrInvoiceAlreadySettled
}

327
channeldb/invoices.go
View File

@ -8,7 +8,6 @@ import (
"io"
"time"
"github.com/btcsuite/btcd/wire"
"github.com/coreos/bbolt"
"github.com/lightningnetwork/lnd/lntypes"
"github.com/lightningnetwork/lnd/lnwire"
@ -84,10 +83,6 @@ const (
// in the database.
MaxMemoSize = 1024
// MaxReceiptSize is the maximum size of the payment receipt stored
// within the database along side incoming/outgoing invoices.
MaxReceiptSize = 1024
// MaxPaymentRequestSize is the max size of a payment request for
// this invoice.
// TODO(halseth): determine the max length payment request when field
@ -96,6 +91,11 @@ const (
// A set of tlv type definitions used to serialize invoice htlcs to the
// database.
//
// NOTE: A migration should be added whenever this list changes. This
// prevents against the database being rolled back to an older
// format where the surrounding logic might assume a different set of
// fields are known.
chanIDType tlv.Type = 1
htlcIDType tlv.Type = 3
amtType tlv.Type = 5
@ -103,7 +103,28 @@ const (
acceptTimeType tlv.Type = 9
resolveTimeType tlv.Type = 11
expiryHeightType tlv.Type = 13
stateType tlv.Type = 15
htlcStateType tlv.Type = 15
// A set of tlv type definitions used to serialize invoice bodiees.
//
// NOTE: A migration should be added whenever this list changes. This
// prevents against the database being rolled back to an older
// format where the surrounding logic might assume a different set of
// fields are known.
memoType tlv.Type = 0
payReqType tlv.Type = 1
createTimeType tlv.Type = 2
settleTimeType tlv.Type = 3
addIndexType tlv.Type = 4
settleIndexType tlv.Type = 5
preimageType tlv.Type = 6
valueType tlv.Type = 7
cltvDeltaType tlv.Type = 8
expiryType tlv.Type = 9
paymentAddrType tlv.Type = 10
featuresType tlv.Type = 11
invStateType tlv.Type = 12
amtPaidType tlv.Type = 13
)
// ContractState describes the state the invoice is in.
@ -145,6 +166,13 @@ func (c ContractState) String() string {
// the necessary conditions required before the invoice can be considered fully
// settled by the payee.
type ContractTerm struct {
// FinalCltvDelta is the minimum required number of blocks before htlc
// expiry when the invoice is accepted.
FinalCltvDelta int32
// Expiry defines how long after creation this invoice should expire.
Expiry time.Duration
// PaymentPreimage is the preimage which is to be revealed in the
// occasion that an HTLC paying to the hash of this preimage is
// extended.
@ -154,8 +182,12 @@ type ContractTerm struct {
// which can be satisfied by the above preimage.
Value lnwire.MilliSatoshi
// State describes the state the invoice is in.
State ContractState
// PaymentAddr is a randomly generated value include in the MPP record
// by the sender to prevent probing of the receiver.
PaymentAddr [32]byte
// Features is the feature vectors advertised on the payment request.
Features *lnwire.FeatureVector
}
// Invoice is a payment invoice generated by a payee in order to request
@ -174,23 +206,10 @@ type Invoice struct {
// or any other message which fits within the size constraints.
Memo []byte
// Receipt is an optional field dedicated for storing a
// cryptographically binding receipt of payment.
//
// TODO(roasbeef): document scheme.
Receipt []byte
// PaymentRequest is an optional field where a payment request created
// for this invoice can be stored.
PaymentRequest []byte
// FinalCltvDelta is the minimum required number of blocks before htlc
// expiry when the invoice is accepted.
FinalCltvDelta int32
// Expiry defines how long after creation this invoice should expire.
Expiry time.Duration
// CreationDate is the exact time the invoice was created.
CreationDate time.Time
@ -223,6 +242,9 @@ type Invoice struct {
// NOTE: This index starts at 1.
SettleIndex uint64
// State describes the state the invoice is in.
State ContractState
// AmtPaid is the final amount that we ultimately accepted for pay for
// this invoice. We specify this value independently as it's possible
// that the invoice originally didn't specify an amount, or the sender
@ -312,16 +334,14 @@ func validateInvoice(i *Invoice) error {
return fmt.Errorf("max length a memo is %v, and invoice "+
"of length %v was provided", MaxMemoSize, len(i.Memo))
}
if len(i.Receipt) > MaxReceiptSize {
return fmt.Errorf("max length a receipt is %v, and invoice "+
"of length %v was provided", MaxReceiptSize,
len(i.Receipt))
}
if len(i.PaymentRequest) > MaxPaymentRequestSize {
return fmt.Errorf("max length of payment request is %v, length "+
"provided was %v", MaxPaymentRequestSize,
len(i.PaymentRequest))
}
if i.Terms.Features == nil {
return errors.New("invoice must have a feature vector")
}
return nil
}
@ -532,7 +552,7 @@ func (d *DB) FetchAllInvoices(pendingOnly bool) ([]Invoice, error) {
}
if pendingOnly &&
invoice.Terms.State == ContractSettled {
invoice.State == ContractSettled {
return nil
}
@ -682,7 +702,7 @@ func (d *DB) QueryInvoices(q InvoiceQuery) (InvoiceSlice, error) {
// Skip any settled invoices if the caller is only
// interested in unsettled.
if q.PendingOnly &&
invoice.Terms.State == ContractSettled {
invoice.State == ContractSettled {
continue
}
@ -892,71 +912,73 @@ func putInvoice(invoices, invoiceIndex, addIndex *bbolt.Bucket,
// would modify the on disk format, make a copy of the original code and store
// it with the migration.
func serializeInvoice(w io.Writer, i *Invoice) error {
if err := wire.WriteVarBytes(w, 0, i.Memo[:]); err != nil {
return err
}
if err := wire.WriteVarBytes(w, 0, i.Receipt[:]); err != nil {
return err
}
if err := wire.WriteVarBytes(w, 0, i.PaymentRequest[:]); err != nil {
return err
}
if err := binary.Write(w, byteOrder, i.FinalCltvDelta); err != nil {
return err
}
if err := binary.Write(w, byteOrder, int64(i.Expiry)); err != nil {
return err
}
birthBytes, err := i.CreationDate.MarshalBinary()
creationDateBytes, err := i.CreationDate.MarshalBinary()
if err != nil {
return err
}
if err := wire.WriteVarBytes(w, 0, birthBytes); err != nil {
return err
}
settleBytes, err := i.SettleDate.MarshalBinary()
settleDateBytes, err := i.SettleDate.MarshalBinary()
if err != nil {
return err
}
if err := wire.WriteVarBytes(w, 0, settleBytes); err != nil {
var fb bytes.Buffer
err = i.Terms.Features.EncodeBase256(&fb)
if err != nil {
return err
}
featureBytes := fb.Bytes()
preimage := [32]byte(i.Terms.PaymentPreimage)
value := uint64(i.Terms.Value)
cltvDelta := uint32(i.Terms.FinalCltvDelta)
expiry := uint64(i.Terms.Expiry)
amtPaid := uint64(i.AmtPaid)
state := uint8(i.State)
tlvStream, err := tlv.NewStream(
// Memo and payreq.
tlv.MakePrimitiveRecord(memoType, &i.Memo),
tlv.MakePrimitiveRecord(payReqType, &i.PaymentRequest),
// Add/settle metadata.
tlv.MakePrimitiveRecord(createTimeType, &creationDateBytes),
tlv.MakePrimitiveRecord(settleTimeType, &settleDateBytes),
tlv.MakePrimitiveRecord(addIndexType, &i.AddIndex),
tlv.MakePrimitiveRecord(settleIndexType, &i.SettleIndex),
// Terms.
tlv.MakePrimitiveRecord(preimageType, &preimage),
tlv.MakePrimitiveRecord(valueType, &value),
tlv.MakePrimitiveRecord(cltvDeltaType, &cltvDelta),
tlv.MakePrimitiveRecord(expiryType, &expiry),
tlv.MakePrimitiveRecord(paymentAddrType, &i.Terms.PaymentAddr),
tlv.MakePrimitiveRecord(featuresType, &featureBytes),
// Invoice state.
tlv.MakePrimitiveRecord(invStateType, &state),
tlv.MakePrimitiveRecord(amtPaidType, &amtPaid),
)
if err != nil {
return err
}
if _, err := w.Write(i.Terms.PaymentPreimage[:]); err != nil {
var b bytes.Buffer
if err = tlvStream.Encode(&b); err != nil {
return err
}
var scratch [8]byte
byteOrder.PutUint64(scratch[:], uint64(i.Terms.Value))
if _, err := w.Write(scratch[:]); err != nil {
err = binary.Write(w, byteOrder, uint64(b.Len()))
if err != nil {
return err
}
if err := binary.Write(w, byteOrder, i.Terms.State); err != nil {
if _, err = w.Write(b.Bytes()); err != nil {
return err
}
if err := binary.Write(w, byteOrder, i.AddIndex); err != nil {
return err
}
if err := binary.Write(w, byteOrder, i.SettleIndex); err != nil {
return err
}
if err := binary.Write(w, byteOrder, int64(i.AmtPaid)); err != nil {
return err
}
if err := serializeHtlcs(w, i.Htlcs); err != nil {
return err
}
return nil
return serializeHtlcs(w, i.Htlcs)
}
// serializeHtlcs serializes a map containing circuit keys and invoice htlcs to
@ -980,7 +1002,7 @@ func serializeHtlcs(w io.Writer, htlcs map[CircuitKey]*InvoiceHTLC) error {
tlv.MakePrimitiveRecord(acceptTimeType, &acceptTime),
tlv.MakePrimitiveRecord(resolveTimeType, &resolveTime),
tlv.MakePrimitiveRecord(expiryHeightType, &htlc.Expiry),
tlv.MakePrimitiveRecord(stateType, &state),
tlv.MakePrimitiveRecord(htlcStateType, &state),
)
if err != nil {
return err
@ -1018,79 +1040,89 @@ func fetchInvoice(invoiceNum []byte, invoices *bbolt.Bucket) (Invoice, error) {
}
func deserializeInvoice(r io.Reader) (Invoice, error) {
var err error
invoice := Invoice{}
var (
preimage [32]byte
value uint64
cltvDelta uint32
expiry uint64
amtPaid uint64
state uint8
// TODO(roasbeef): use read full everywhere
invoice.Memo, err = wire.ReadVarBytes(r, 0, MaxMemoSize, "")
creationDateBytes []byte
settleDateBytes []byte
featureBytes []byte
)
var i Invoice
tlvStream, err := tlv.NewStream(
// Memo and payreq.
tlv.MakePrimitiveRecord(memoType, &i.Memo),
tlv.MakePrimitiveRecord(payReqType, &i.PaymentRequest),
// Add/settle metadata.
tlv.MakePrimitiveRecord(createTimeType, &creationDateBytes),
tlv.MakePrimitiveRecord(settleTimeType, &settleDateBytes),
tlv.MakePrimitiveRecord(addIndexType, &i.AddIndex),
tlv.MakePrimitiveRecord(settleIndexType, &i.SettleIndex),
// Terms.
tlv.MakePrimitiveRecord(preimageType, &preimage),
tlv.MakePrimitiveRecord(valueType, &value),
tlv.MakePrimitiveRecord(cltvDeltaType, &cltvDelta),
tlv.MakePrimitiveRecord(expiryType, &expiry),
tlv.MakePrimitiveRecord(paymentAddrType, &i.Terms.PaymentAddr),
tlv.MakePrimitiveRecord(featuresType, &featureBytes),
// Invoice state.
tlv.MakePrimitiveRecord(invStateType, &state),
tlv.MakePrimitiveRecord(amtPaidType, &amtPaid),
)
if err != nil {
return invoice, err
return i, err
}
invoice.Receipt, err = wire.ReadVarBytes(r, 0, MaxReceiptSize, "")
var bodyLen int64
err = binary.Read(r, byteOrder, &bodyLen)
if err != nil {
return invoice, err
return i, err
}
invoice.PaymentRequest, err = wire.ReadVarBytes(r, 0, MaxPaymentRequestSize, "")
lr := io.LimitReader(r, bodyLen)
if err = tlvStream.Decode(lr); err != nil {
return i, err
}
i.Terms.PaymentPreimage = lntypes.Preimage(preimage)
i.Terms.Value = lnwire.MilliSatoshi(value)
i.Terms.FinalCltvDelta = int32(cltvDelta)
i.Terms.Expiry = time.Duration(expiry)
i.AmtPaid = lnwire.MilliSatoshi(amtPaid)
i.State = ContractState(state)
err = i.CreationDate.UnmarshalBinary(creationDateBytes)
if err != nil {
return invoice, err
return i, err
}
if err := binary.Read(r, byteOrder, &invoice.FinalCltvDelta); err != nil {
return invoice, err
}
var expiry int64
if err := binary.Read(r, byteOrder, &expiry); err != nil {
return invoice, err
}
invoice.Expiry = time.Duration(expiry)
birthBytes, err := wire.ReadVarBytes(r, 0, 300, "birth")
err = i.SettleDate.UnmarshalBinary(settleDateBytes)
if err != nil {
return invoice, err
}
if err := invoice.CreationDate.UnmarshalBinary(birthBytes); err != nil {
return invoice, err
return i, err
}
settledBytes, err := wire.ReadVarBytes(r, 0, 300, "settled")
rawFeatures := lnwire.NewRawFeatureVector()
err = rawFeatures.DecodeBase256(
bytes.NewReader(featureBytes), len(featureBytes),
)
if err != nil {
return invoice, err
}
if err := invoice.SettleDate.UnmarshalBinary(settledBytes); err != nil {
return invoice, err
return i, err
}
if _, err := io.ReadFull(r, invoice.Terms.PaymentPreimage[:]); err != nil {
return invoice, err
}
var scratch [8]byte
if _, err := io.ReadFull(r, scratch[:]); err != nil {
return invoice, err
}
invoice.Terms.Value = lnwire.MilliSatoshi(byteOrder.Uint64(scratch[:]))
i.Terms.Features = lnwire.NewFeatureVector(
rawFeatures, lnwire.Features,
)
if err := binary.Read(r, byteOrder, &invoice.Terms.State); err != nil {
return invoice, err
}
if err := binary.Read(r, byteOrder, &invoice.AddIndex); err != nil {
return invoice, err
}
if err := binary.Read(r, byteOrder, &invoice.SettleIndex); err != nil {
return invoice, err
}
if err := binary.Read(r, byteOrder, &invoice.AmtPaid); err != nil {
return invoice, err
}
invoice.Htlcs, err = deserializeHtlcs(r)
if err != nil {
return Invoice{}, err
}
return invoice, nil
i.Htlcs, err = deserializeHtlcs(r)
return i, err
}
// deserializeHtlcs reads a list of invoice htlcs from a reader and returns it
@ -1100,7 +1132,7 @@ func deserializeHtlcs(r io.Reader) (map[CircuitKey]*InvoiceHTLC, error) {
for {
// Read the length of the tlv stream for this htlc.
var streamLen uint64
var streamLen int64
if err := binary.Read(r, byteOrder, &streamLen); err != nil {
if err == io.EOF {
break
@ -1109,11 +1141,9 @@ func deserializeHtlcs(r io.Reader) (map[CircuitKey]*InvoiceHTLC, error) {
return nil, err
}
streamBytes := make([]byte, streamLen)
if _, err := r.Read(streamBytes); err != nil {
return nil, err
}
streamReader := bytes.NewReader(streamBytes)
// Limit the reader so that it stops at the end of this htlc's
// stream.
htlcReader := io.LimitReader(r, streamLen)
// Decode the contents into the htlc fields.
var (
@ -1134,13 +1164,13 @@ func deserializeHtlcs(r io.Reader) (map[CircuitKey]*InvoiceHTLC, error) {
tlv.MakePrimitiveRecord(acceptTimeType, &acceptTime),
tlv.MakePrimitiveRecord(resolveTimeType, &resolveTime),
tlv.MakePrimitiveRecord(expiryHeightType, &htlc.Expiry),
tlv.MakePrimitiveRecord(stateType, &state),
tlv.MakePrimitiveRecord(htlcStateType, &state),
)
if err != nil {
return nil, err
}
if err := tlvStream.Decode(streamReader); err != nil {
if err := tlvStream.Decode(htlcReader); err != nil {
return nil, err
}
@ -1167,20 +1197,21 @@ func copySlice(src []byte) []byte {
func copyInvoice(src *Invoice) *Invoice {
dest := Invoice{
Memo: copySlice(src.Memo),
Receipt: copySlice(src.Receipt),
PaymentRequest: copySlice(src.PaymentRequest),
FinalCltvDelta: src.FinalCltvDelta,
CreationDate: src.CreationDate,
SettleDate: src.SettleDate,
Terms: src.Terms,
AddIndex: src.AddIndex,
SettleIndex: src.SettleIndex,
State: src.State,
AmtPaid: src.AmtPaid,
Htlcs: make(
map[CircuitKey]*InvoiceHTLC, len(src.Htlcs),
),
}
dest.Terms.Features = src.Terms.Features.Clone()
for k, v := range src.Htlcs {
dest.Htlcs[k] = v
}
@ -1198,20 +1229,20 @@ func (d *DB) updateInvoice(hash lntypes.Hash, invoices, settleIndex *bbolt.Bucke
return nil, err
}
preUpdateState := invoice.Terms.State
preUpdateState := invoice.State
// Create deep copy to prevent any accidental modification in the
// callback.
copy := copyInvoice(&invoice)
invoiceCopy := copyInvoice(&invoice)
// Call the callback and obtain the update descriptor.
update, err := callback(copy)
update, err := callback(invoiceCopy)
if err != nil {
return &invoice, err
}
// Update invoice state.
invoice.Terms.State = update.State
invoice.State = update.State
now := d.now()
@ -1259,8 +1290,8 @@ func (d *DB) updateInvoice(hash lntypes.Hash, invoices, settleIndex *bbolt.Bucke
// If invoice moved to the settled state, update settle index and settle
// time.
if preUpdateState != invoice.Terms.State &&
invoice.Terms.State == ContractSettled {
if preUpdateState != invoice.State &&
invoice.State == ContractSettled {
if update.Preimage.Hash() != hash {
return nil, fmt.Errorf("preimage does not match")
@ -1312,7 +1343,7 @@ func setSettleFields(settleIndex *bbolt.Bucket, invoiceNum []byte,
return err
}
invoice.Terms.State = ContractSettled
invoice.State = ContractSettled
invoice.SettleDate = now
invoice.SettleIndex = nextSettleSeqNo

2
channeldb/log.go
View File

@ -3,6 +3,7 @@ package channeldb
import (
"github.com/btcsuite/btclog"
"github.com/lightningnetwork/lnd/build"
"github.com/lightningnetwork/lnd/channeldb/migration12"
"github.com/lightningnetwork/lnd/channeldb/migration_01_to_11"
)
@ -27,4 +28,5 @@ func DisableLog() {
func UseLogger(logger btclog.Logger) {
log = logger
migration_01_to_11.UseLogger(logger)
migration12.UseLogger(logger)
}

318
channeldb/migration12/invoices.go Normal file
View File

@ -0,0 +1,318 @@
package migration12
import (
"bytes"
"encoding/binary"
"io"
"time"
"github.com/btcsuite/btcd/wire"
"github.com/lightningnetwork/lnd/lntypes"
"github.com/lightningnetwork/lnd/lnwire"
"github.com/lightningnetwork/lnd/tlv"
)
const (
// MaxMemoSize is maximum size of the memo field within invoices stored
// in the database.
MaxMemoSize = 1024
// maxReceiptSize is the maximum size of the payment receipt stored
// within the database along side incoming/outgoing invoices.
maxReceiptSize = 1024
// MaxPaymentRequestSize is the max size of a payment request for
// this invoice.
// TODO(halseth): determine the max length payment request when field
// lengths are final.
MaxPaymentRequestSize = 4096
memoType tlv.Type = 0
payReqType tlv.Type = 1
createTimeType tlv.Type = 2
settleTimeType tlv.Type = 3
addIndexType tlv.Type = 4
settleIndexType tlv.Type = 5
preimageType tlv.Type = 6
valueType tlv.Type = 7
cltvDeltaType tlv.Type = 8
expiryType tlv.Type = 9
paymentAddrType tlv.Type = 10
featuresType tlv.Type = 11
invStateType tlv.Type = 12
amtPaidType tlv.Type = 13
)
var (
// invoiceBucket is the name of the bucket within the database that
// stores all data related to invoices no matter their final state.
// Within the invoice bucket, each invoice is keyed by its invoice ID
// which is a monotonically increasing uint32.
invoiceBucket = []byte("invoices")
// Big endian is the preferred byte order, due to cursor scans over
// integer keys iterating in order.
byteOrder = binary.BigEndian
)
// ContractState describes the state the invoice is in.
type ContractState uint8
// ContractTerm is a companion struct to the Invoice struct. This struct houses
// the necessary conditions required before the invoice can be considered fully
// settled by the payee.
type ContractTerm struct {
// PaymentPreimage is the preimage which is to be revealed in the
// occasion that an HTLC paying to the hash of this preimage is
// extended.
PaymentPreimage lntypes.Preimage
// Value is the expected amount of milli-satoshis to be paid to an HTLC
// which can be satisfied by the above preimage.
Value lnwire.MilliSatoshi
// State describes the state the invoice is in.
State ContractState
// PaymentAddr is a randomly generated value include in the MPP record
// by the sender to prevent probing of the receiver.
PaymentAddr [32]byte
// Features is the feature vectors advertised on the payment request.
Features *lnwire.FeatureVector
}
// Invoice is a payment invoice generated by a payee in order to request
// payment for some good or service. The inclusion of invoices within Lightning
// creates a payment work flow for merchants very similar to that of the
// existing financial system within PayPal, etc. Invoices are added to the
// database when a payment is requested, then can be settled manually once the
// payment is received at the upper layer. For record keeping purposes,
// invoices are never deleted from the database, instead a bit is toggled
// denoting the invoice has been fully settled. Within the database, all
// invoices must have a unique payment hash which is generated by taking the
// sha256 of the payment preimage.
type Invoice struct {
// Memo is an optional memo to be stored along side an invoice. The
// memo may contain further details pertaining to the invoice itself,
// or any other message which fits within the size constraints.
Memo []byte
// PaymentRequest is an optional field where a payment request created
// for this invoice can be stored.
PaymentRequest []byte
// FinalCltvDelta is the minimum required number of blocks before htlc
// expiry when the invoice is accepted.
FinalCltvDelta int32
// Expiry defines how long after creation this invoice should expire.
Expiry time.Duration
// CreationDate is the exact time the invoice was created.
CreationDate time.Time
// SettleDate is the exact time the invoice was settled.
SettleDate time.Time
// Terms are the contractual payment terms of the invoice. Once all the
// terms have been satisfied by the payer, then the invoice can be
// considered fully fulfilled.
//
// TODO(roasbeef): later allow for multiple terms to fulfill the final
// invoice: payment fragmentation, etc.
Terms ContractTerm
// AddIndex is an auto-incrementing integer that acts as a
// monotonically increasing sequence number for all invoices created.
// Clients can then use this field as a "checkpoint" of sorts when
// implementing a streaming RPC to notify consumers of instances where
// an invoice has been added before they re-connected.
//
// NOTE: This index starts at 1.
AddIndex uint64
// SettleIndex is an auto-incrementing integer that acts as a
// monotonically increasing sequence number for all settled invoices.
// Clients can then use this field as a "checkpoint" of sorts when
// implementing a streaming RPC to notify consumers of instances where
// an invoice has been settled before they re-connected.
//
// NOTE: This index starts at 1.
SettleIndex uint64
// AmtPaid is the final amount that we ultimately accepted for pay for
// this invoice. We specify this value independently as it's possible
// that the invoice originally didn't specify an amount, or the sender
// overpaid.
AmtPaid lnwire.MilliSatoshi
// Htlcs records all htlcs that paid to this invoice. Some of these
// htlcs may have been marked as canceled.
Htlcs []byte
}
// LegacyDeserializeInvoice decodes an invoice from the passed io.Reader using
// the pre-TLV serialization.
func LegacyDeserializeInvoice(r io.Reader) (Invoice, error) {
var err error
invoice := Invoice{}
// TODO(roasbeef): use read full everywhere
invoice.Memo, err = wire.ReadVarBytes(r, 0, MaxMemoSize, "")
if err != nil {
return invoice, err
}
_, err = wire.ReadVarBytes(r, 0, maxReceiptSize, "")
if err != nil {
return invoice, err
}
invoice.PaymentRequest, err = wire.ReadVarBytes(r, 0, MaxPaymentRequestSize, "")
if err != nil {
return invoice, err
}
if err := binary.Read(r, byteOrder, &invoice.FinalCltvDelta); err != nil {
return invoice, err
}
var expiry int64
if err := binary.Read(r, byteOrder, &expiry); err != nil {
return invoice, err
}
invoice.Expiry = time.Duration(expiry)
birthBytes, err := wire.ReadVarBytes(r, 0, 300, "birth")
if err != nil {
return invoice, err
}
if err := invoice.CreationDate.UnmarshalBinary(birthBytes); err != nil {
return invoice, err
}
settledBytes, err := wire.ReadVarBytes(r, 0, 300, "settled")
if err != nil {
return invoice, err
}
if err := invoice.SettleDate.UnmarshalBinary(settledBytes); err != nil {
return invoice, err
}
if _, err := io.ReadFull(r, invoice.Terms.PaymentPreimage[:]); err != nil {
return invoice, err
}
var scratch [8]byte
if _, err := io.ReadFull(r, scratch[:]); err != nil {
return invoice, err
}
invoice.Terms.Value = lnwire.MilliSatoshi(byteOrder.Uint64(scratch[:]))
if err := binary.Read(r, byteOrder, &invoice.Terms.State); err != nil {
return invoice, err
}
if err := binary.Read(r, byteOrder, &invoice.AddIndex); err != nil {
return invoice, err
}
if err := binary.Read(r, byteOrder, &invoice.SettleIndex); err != nil {
return invoice, err
}
if err := binary.Read(r, byteOrder, &invoice.AmtPaid); err != nil {
return invoice, err
}
invoice.Htlcs, err = deserializeHtlcs(r)
if err != nil {
return Invoice{}, err
}
return invoice, nil
}
// deserializeHtlcs reads a list of invoice htlcs from a reader and returns it
// as a flattened byte slice.
func deserializeHtlcs(r io.Reader) ([]byte, error) {
var b bytes.Buffer
_, err := io.Copy(&b, r)
return b.Bytes(), err
}
// SerializeInvoice serializes an invoice to a writer.
//
// nolint: dupl
func SerializeInvoice(w io.Writer, i *Invoice) error {
creationDateBytes, err := i.CreationDate.MarshalBinary()
if err != nil {
return err
}
settleDateBytes, err := i.SettleDate.MarshalBinary()
if err != nil {
return err
}
var fb bytes.Buffer
err = i.Terms.Features.EncodeBase256(&fb)
if err != nil {
return err
}
featureBytes := fb.Bytes()
preimage := [32]byte(i.Terms.PaymentPreimage)
value := uint64(i.Terms.Value)
cltvDelta := uint32(i.FinalCltvDelta)
expiry := uint64(i.Expiry)
amtPaid := uint64(i.AmtPaid)
state := uint8(i.Terms.State)
tlvStream, err := tlv.NewStream(
// Memo and payreq.
tlv.MakePrimitiveRecord(memoType, &i.Memo),
tlv.MakePrimitiveRecord(payReqType, &i.PaymentRequest),
// Add/settle metadata.
tlv.MakePrimitiveRecord(createTimeType, &creationDateBytes),
tlv.MakePrimitiveRecord(settleTimeType, &settleDateBytes),
tlv.MakePrimitiveRecord(addIndexType, &i.AddIndex),
tlv.MakePrimitiveRecord(settleIndexType, &i.SettleIndex),
// Terms.
tlv.MakePrimitiveRecord(preimageType, &preimage),
tlv.MakePrimitiveRecord(valueType, &value),
tlv.MakePrimitiveRecord(cltvDeltaType, &cltvDelta),
tlv.MakePrimitiveRecord(expiryType, &expiry),
tlv.MakePrimitiveRecord(paymentAddrType, &i.Terms.PaymentAddr),
tlv.MakePrimitiveRecord(featuresType, &featureBytes),
// Invoice state.
tlv.MakePrimitiveRecord(invStateType, &state),
tlv.MakePrimitiveRecord(amtPaidType, &amtPaid),
)
if err != nil {
return err
}
var b bytes.Buffer
if err = tlvStream.Encode(&b); err != nil {
return err
}
err = binary.Write(w, byteOrder, uint64(b.Len()))
if err != nil {
return err
}
if _, err = w.Write(b.Bytes()); err != nil {
return err
}
return serializeHtlcs(w, i.Htlcs)
}
// serializeHtlcs writes a serialized list of invoice htlcs into a writer.
func serializeHtlcs(w io.Writer, htlcs []byte) error {
_, err := w.Write(htlcs)
return err
}

14
channeldb/migration12/log.go Normal file
View File

@ -0,0 +1,14 @@
package migration12
import (
"github.com/btcsuite/btclog"
)
// log is a logger that is initialized as disabled. This means the package will
// not perform any logging by default until a logger is set.
var log = btclog.Disabled
// UseLogger uses a specified Logger to output package logging info.
func UseLogger(logger btclog.Logger) {
log = logger
}

74
channeldb/migration12/migration.go Normal file
View File

@ -0,0 +1,74 @@
package migration12
import (
"bytes"
"github.com/coreos/bbolt"
"github.com/lightningnetwork/lnd/lnwire"
)
var emptyFeatures = lnwire.NewFeatureVector(nil, nil)
// MigrateInvoiceTLV migrates all existing invoice bodies over to be serialized
// in a single TLV stream. In the process, we drop the Receipt field and add
// PaymentAddr and Features to the invoice Terms.
func MigrateInvoiceTLV(tx *bbolt.Tx) error {
log.Infof("Migrating invoice bodies to TLV, " +
"adding payment addresses and feature vectors.")
invoiceB := tx.Bucket(invoiceBucket)
if invoiceB == nil {
return nil
}
type keyedInvoice struct {
key []byte
invoice Invoice
}
// Read in all existing invoices using the old format.
var invoices []keyedInvoice
err := invoiceB.ForEach(func(k, v []byte) error {
if v == nil {
return nil
}
invoiceReader := bytes.NewReader(v)
invoice, err := LegacyDeserializeInvoice(invoiceReader)
if err != nil {
return err
}
// Insert an empty feature vector on all old payments.
invoice.Terms.Features = emptyFeatures
invoices = append(invoices, keyedInvoice{
key: k,
invoice: invoice,
})
return nil
})
if err != nil {
return err
}
// Write out each one under its original key using TLV.
for _, ki := range invoices {
var b bytes.Buffer
err = SerializeInvoice(&b, &ki.invoice)
if err != nil {
return err
}
err = invoiceB.Put(ki.key, b.Bytes())
if err != nil {
return err
}
}
log.Infof("Migration to TLV invoice bodies, " +
"payment address, and features complete!")
return nil
}

206
channeldb/migration12/migration_test.go Normal file
View File

@ -0,0 +1,206 @@
package migration12_test
import (
"bytes"
"fmt"
"testing"
"github.com/coreos/bbolt"
"github.com/lightningnetwork/lnd/channeldb/migration12"
"github.com/lightningnetwork/lnd/channeldb/migtest"
"github.com/lightningnetwork/lnd/lntypes"
)
var (
// invoiceBucket is the name of the bucket within the database that
// stores all data related to invoices no matter their final state.
// Within the invoice bucket, each invoice is keyed by its invoice ID
// which is a monotonically increasing uint32.
invoiceBucket = []byte("invoices")
preimage = lntypes.Preimage{
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
}
hash = preimage.Hash()
beforeInvoice0Htlcs = []byte{
0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72,
0x6c, 0x64, 0x09, 0x62, 0x79, 0x65, 0x20, 0x77, 0x6f, 0x72,
0x6c, 0x64, 0x06, 0x70, 0x61, 0x79, 0x72, 0x65, 0x71, 0x00,
0x00, 0x00, 0x20, 0x00, 0x00, 0x4e, 0x94, 0x91, 0x4f, 0x00,
0x00, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x77, 0xc4, 0xd3,
0xd5, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x20, 0x0f, 0x01, 0x00,
0x00, 0x00, 0x0e, 0x77, 0xd5, 0xc8, 0x1c, 0x00, 0x00, 0x00,
0x00, 0xfe, 0x20, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xa4,
}
afterInvoice0Htlcs = []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x0b,
0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c,
0x64, 0x01, 0x06, 0x70, 0x61, 0x79, 0x72, 0x65, 0x71, 0x02,
0x0f, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x77, 0xc4, 0xd3, 0xd5,
0x00, 0x00, 0x00, 0x00, 0xfe, 0x20, 0x03, 0x0f, 0x01, 0x00,
0x00, 0x00, 0x0e, 0x77, 0xd5, 0xc8, 0x1c, 0x00, 0x00, 0x00,
0x00, 0xfe, 0x20, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x05, 0x05, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x06, 0x06, 0x20, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x07, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe8, 0x08, 0x04, 0x00,
0x00, 0x00, 0x20, 0x09, 0x08, 0x00, 0x00, 0x4e, 0x94, 0x91,
0x4f, 0x00, 0x00, 0x0a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x0c,
0x01, 0x03, 0x0d, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0xa4,
}
testHtlc = []byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41,
0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
0x05, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64,
0x07, 0x04, 0x00, 0x00, 0x00, 0x58, 0x09, 0x08, 0x00, 0x13,
0xbc, 0xbf, 0x72, 0x4e, 0x1e, 0x00, 0x0b, 0x08, 0x00, 0x17,
0xaf, 0x4c, 0x22, 0xc4, 0x24, 0x00, 0x0d, 0x04, 0x00, 0x00,
0x23, 0x1d, 0x0f, 0x01, 0x02,
}
beforeInvoice1Htlc = append([]byte{
0x0b, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72,
0x6c, 0x64, 0x09, 0x62, 0x79, 0x65, 0x20, 0x77, 0x6f, 0x72,
0x6c, 0x64, 0x06, 0x70, 0x61, 0x79, 0x72, 0x65, 0x71, 0x00,
0x00, 0x00, 0x20, 0x00, 0x00, 0x4e, 0x94, 0x91, 0x4f, 0x00,
0x00, 0x0f, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x77, 0xc4, 0xd3,
0xd5, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x20, 0x0f, 0x01, 0x00,
0x00, 0x00, 0x0e, 0x77, 0xd5, 0xc8, 0x1c, 0x00, 0x00, 0x00,
0x00, 0xfe, 0x20, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xa4,
}, testHtlc...)
afterInvoice1Htlc = append([]byte{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x0b,
0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c,
0x64, 0x01, 0x06, 0x70, 0x61, 0x79, 0x72, 0x65, 0x71, 0x02,
0x0f, 0x01, 0x00, 0x00, 0x00, 0x0e, 0x77, 0xc4, 0xd3, 0xd5,
0x00, 0x00, 0x00, 0x00, 0xfe, 0x20, 0x03, 0x0f, 0x01, 0x00,
0x00, 0x00, 0x0e, 0x77, 0xd5, 0xc8, 0x1c, 0x00, 0x00, 0x00,
0x00, 0xfe, 0x20, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x05, 0x05, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x06, 0x06, 0x20, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x07, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe8, 0x08, 0x04, 0x00,
0x00, 0x00, 0x20, 0x09, 0x08, 0x00, 0x00, 0x4e, 0x94, 0x91,
0x4f, 0x00, 0x00, 0x0a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x0c,
0x01, 0x03, 0x0d, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0xa4,
}, testHtlc...)
)
type migrationTest struct {
name string
beforeMigration func(*bbolt.Tx) error
afterMigration func(*bbolt.Tx) error
}
var migrationTests = []migrationTest{
{
name: "no invoices",
beforeMigration: func(*bbolt.Tx) error { return nil },
afterMigration: func(*bbolt.Tx) error { return nil },
},
{
name: "zero htlcs",
beforeMigration: genBeforeMigration(beforeInvoice0Htlcs),
afterMigration: genAfterMigration(afterInvoice0Htlcs),
},
{
name: "one htlc",
beforeMigration: genBeforeMigration(beforeInvoice1Htlc),
afterMigration: genAfterMigration(afterInvoice1Htlc),
},
}
// genBeforeMigration creates a closure that inserts an invoice serialized under
// the old format under the test payment hash.
func genBeforeMigration(beforeBytes []byte) func(*bbolt.Tx) error {
return func(tx *bbolt.Tx) error {
invoices, err := tx.CreateBucketIfNotExists(
invoiceBucket,
)
if err != nil {
return err
}
return invoices.Put(hash[:], beforeBytes)
}
}
// genAfterMigration creates a closure that verifies the tlv invoice migration
// succeeded, but comparing the resulting encoding of the invoice to the
// expected serialization. In addition, the decoded invoice is compared against
// the expected invoice for equality.
func genAfterMigration(afterBytes []byte) func(*bbolt.Tx) error {
return func(tx *bbolt.Tx) error {
invoices := tx.Bucket(invoiceBucket)
if invoices == nil {
return fmt.Errorf("invoice bucket not found")
}
// Fetch the new invoice bytes and check that they match our
// expected serialization.
invoiceBytes := invoices.Get(hash[:])
if !bytes.Equal(invoiceBytes, afterBytes) {
return fmt.Errorf("invoice bytes mismatch, "+
"want: %x, got: %x",
invoiceBytes, afterBytes)
}
return nil
}
}
// TestTLVInvoiceMigration executes a suite of migration tests for moving
// invoices to use TLV for their bodies. In the process, feature bits and
// payment addresses are added to the invoice while the receipt field is
// dropped. We test a few different invoices with a varying number of HTLCs, as
// well as the case where there are no invoices present.
//
// NOTE: The test vectors each include a receipt that is not present on the
// final struct, but verifies that the field is properly removed.
func TestTLVInvoiceMigration(t *testing.T) {
for _, test := range migrationTests {
test := test
t.Run(test.name, func(t *testing.T) {
migtest.ApplyMigration(
t,
test.beforeMigration,
test.afterMigration,
migration12.MigrateInvoiceTLV,
false,
)
})
}
}

93
channeldb/migtest/migtest.go Normal file
View File

@ -0,0 +1,93 @@
package migtest
import (
"fmt"
"io/ioutil"
"os"
"testing"
"github.com/coreos/bbolt"
"github.com/lightningnetwork/lnd/channeldb"
)
// MakeDB creates a new instance of the ChannelDB for testing purposes. A
// callback which cleans up the created temporary directories is also returned
// and intended to be executed after the test completes.
func MakeDB() (*channeldb.DB, func(), error) {
// First, create a temporary directory to be used for the duration of
// this test.
tempDirName, err := ioutil.TempDir("", "channeldb")
if err != nil {
return nil, nil, err
}
// Next, create channeldb for the first time.
cdb, err := channeldb.Open(tempDirName)
if err != nil {
return nil, nil, err
}
cleanUp := func() {
cdb.Close()
os.RemoveAll(tempDirName)
}
return cdb, cleanUp, nil
}
// ApplyMigration is a helper test function that encapsulates the general steps
// which are needed to properly check the result of applying migration function.
func ApplyMigration(t *testing.T,
beforeMigration, afterMigration, migrationFunc func(tx *bbolt.Tx) error,
shouldFail bool) {
cdb, cleanUp, err := MakeDB()
defer cleanUp()
if err != nil {
t.Fatal(err)
}
// beforeMigration usually used for populating the database
// with test data.
err = cdb.Update(beforeMigration)
if err != nil {
t.Fatal(err)
}
defer func() {
if r := recover(); r != nil {
err = newError(r)
}
if err == nil && shouldFail {
t.Fatal("error wasn't received on migration stage")
} else if err != nil && !shouldFail {
t.Fatalf("error was received on migration stage: %v", err)
}
// afterMigration usually used for checking the database state and
// throwing the error if something went wrong.
err = cdb.Update(afterMigration)
if err != nil {
t.Fatal(err)
}
}()
// Apply migration.
err = cdb.Update(migrationFunc)
if err != nil {
t.Fatal(err)
}
}
func newError(e interface{}) error {
var err error
switch e := e.(type) {
case error:
err = e
default:
err = fmt.Errorf("%v", e)
}
return err
}

11
cmd/lncli/commands.go
View File

@ -2580,10 +2580,6 @@ var addInvoiceCommand = cli.Command{
Usage: "a description of the payment to attach along " +
"with the invoice (default=\"\")",
},
cli.StringFlag{
Name: "receipt",
Usage: "an optional cryptographic receipt of payment",
},
cli.StringFlag{
Name: "preimage",
Usage: "the hex-encoded preimage (32 byte) which will " +
@ -2628,7 +2624,6 @@ func addInvoice(ctx *cli.Context) error {
var (
preimage []byte
descHash []byte
receipt []byte
amt int64
err error
)
@ -2665,14 +2660,8 @@ func addInvoice(ctx *cli.Context) error {
return fmt.Errorf("unable to parse description_hash: %v", err)
}
receipt, err = hex.DecodeString(ctx.String("receipt"))
if err != nil {
return fmt.Errorf("unable to parse receipt: %v", err)
}
invoice := &lnrpc.Invoice{
Memo: ctx.String("memo"),
Receipt: receipt,
RPreimage: preimage,
Value: amt,
DescriptionHash: descHash,

16
htlcswitch/link_test.go
View File

@ -245,7 +245,7 @@ func TestChannelLinkSingleHopPayment(t *testing.T) {
if err != nil {
t.Fatalf("unable to get invoice: %v", err)
}
if invoice.Terms.State != channeldb.ContractSettled {
if invoice.State != channeldb.ContractSettled {
t.Fatal("alice invoice wasn't settled")
}
@ -505,7 +505,7 @@ func testChannelLinkMultiHopPayment(t *testing.T,
if err != nil {
t.Fatalf("unable to get invoice: %v", err)
}
if invoice.Terms.State != channeldb.ContractSettled {
if invoice.State != channeldb.ContractSettled {
t.Fatal("carol invoice haven't been settled")
}
@ -919,7 +919,7 @@ func TestUpdateForwardingPolicy(t *testing.T) {
if err != nil {
t.Fatalf("unable to get invoice: %v", err)
}
if invoice.Terms.State != channeldb.ContractSettled {
if invoice.State != channeldb.ContractSettled {
t.Fatal("carol invoice haven't been settled")
}
@ -1078,7 +1078,7 @@ func TestChannelLinkMultiHopInsufficientPayment(t *testing.T) {
if err != nil {
t.Fatalf("unable to get invoice: %v", err)
}
if invoice.Terms.State == channeldb.ContractSettled {
if invoice.State == channeldb.ContractSettled {
t.Fatal("carol invoice have been settled")
}
@ -1269,7 +1269,7 @@ func TestChannelLinkMultiHopUnknownNextHop(t *testing.T) {
if err != nil {
t.Fatalf("unable to get invoice: %v", err)
}
if invoice.Terms.State == channeldb.ContractSettled {
if invoice.State == channeldb.ContractSettled {
t.Fatal("carol invoice have been settled")
}
@ -1384,7 +1384,7 @@ func TestChannelLinkMultiHopDecodeError(t *testing.T) {
if err != nil {
t.Fatalf("unable to get invoice: %v", err)
}
if invoice.Terms.State == channeldb.ContractSettled {
if invoice.State == channeldb.ContractSettled {
t.Fatal("carol invoice have been settled")
}
@ -3518,7 +3518,7 @@ func TestChannelRetransmission(t *testing.T) {
err = errors.Errorf("unable to get invoice: %v", err)
continue
}
if invoice.Terms.State != channeldb.ContractSettled {
if invoice.State != channeldb.ContractSettled {
err = errors.Errorf("alice invoice haven't been settled")
continue
}
@ -4055,7 +4055,7 @@ func TestChannelLinkAcceptOverpay(t *testing.T) {
if err != nil {
t.Fatalf("unable to get invoice: %v", err)
}
if invoice.Terms.State != channeldb.ContractSettled {
if invoice.State != channeldb.ContractSettled {
t.Fatal("carol invoice haven't been settled")
}

5
htlcswitch/test_utils.go
View File

@ -560,10 +560,13 @@ func generatePaymentWithPreimage(invoiceAmt, htlcAmt lnwire.MilliSatoshi,
invoice := &channeldb.Invoice{
CreationDate: time.Now(),
Terms: channeldb.ContractTerm{
FinalCltvDelta: testInvoiceCltvExpiry,
Value: invoiceAmt,
PaymentPreimage: preimage,
Features: lnwire.NewFeatureVector(
nil, lnwire.Features,
),
},
FinalCltvDelta: testInvoiceCltvExpiry,
}
htlc := &lnwire.UpdateAddHTLC{

24
invoices/invoiceregistry.go
View File

@ -179,7 +179,7 @@ func (i *InvoiceRegistry) invoiceEventNotifier() {
// For backwards compatibility, do not notify
// all invoice subscribers of cancel and accept
// events.
state := e.invoice.Terms.State
state := e.invoice.State
if state != channeldb.ContractCanceled &&
state != channeldb.ContractAccepted {
@ -231,7 +231,7 @@ func (i *InvoiceRegistry) dispatchToClients(event *invoiceEvent) {
// ensure we don't duplicate any events.
// TODO(joostjager): Refactor switches.
state := event.invoice.Terms.State
state := event.invoice.State
switch {
// If we've already sent this settle event to
// the client, then we can skip this.
@ -277,14 +277,14 @@ func (i *InvoiceRegistry) dispatchToClients(event *invoiceEvent) {
// the latest add/settle index it has. We'll use this to ensure
// we don't send a notification twice, which can happen if a new
// event is added while we're catching up a new client.
switch event.invoice.Terms.State {
switch event.invoice.State {
case channeldb.ContractSettled:
client.settleIndex = invoice.SettleIndex
case channeldb.ContractOpen:
client.addIndex = invoice.AddIndex
default:
log.Errorf("unexpected invoice state: %v",
event.invoice.Terms.State)
event.invoice.State)
}
}
}
@ -467,7 +467,7 @@ func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash,
// If the invoice is already canceled, there is no further
// checking to do.
if inv.Terms.State == channeldb.ContractCanceled {
if inv.State == channeldb.ContractCanceled {
debugLog("invoice already canceled")
return nil, errNoUpdate
}
@ -486,7 +486,7 @@ func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash,
return nil, errNoUpdate
}
if expiry < uint32(currentHeight+inv.FinalCltvDelta) {
if expiry < uint32(currentHeight+inv.Terms.FinalCltvDelta) {
debugLog("expiry too soon")
return nil, errNoUpdate
}
@ -506,7 +506,7 @@ func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash,
// Don't update invoice state if we are accepting a duplicate
// payment. We do accept or settle the HTLC.
switch inv.Terms.State {
switch inv.State {
case channeldb.ContractAccepted:
debugLog("accepting duplicate payment to accepted invoice")
update.State = channeldb.ContractAccepted
@ -546,7 +546,7 @@ func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash,
}
if updateSubscribers {
i.notifyClients(rHash, invoice, invoice.Terms.State)
i.notifyClients(rHash, invoice, invoice.State)
}
// Inspect latest htlc state on the invoice.
@ -597,7 +597,7 @@ func (i *InvoiceRegistry) SettleHodlInvoice(preimage lntypes.Preimage) error {
updateInvoice := func(invoice *channeldb.Invoice) (
*channeldb.InvoiceUpdateDesc, error) {
switch invoice.Terms.State {
switch invoice.State {
case channeldb.ContractOpen:
return nil, channeldb.ErrInvoiceStillOpen
case channeldb.ContractCanceled:
@ -639,7 +639,7 @@ func (i *InvoiceRegistry) SettleHodlInvoice(preimage lntypes.Preimage) error {
AcceptHeight: int32(htlc.AcceptHeight),
})
}
i.notifyClients(hash, invoice, invoice.Terms.State)
i.notifyClients(hash, invoice, invoice.State)
return nil
}
@ -655,7 +655,7 @@ func (i *InvoiceRegistry) CancelInvoice(payHash lntypes.Hash) error {
updateInvoice := func(invoice *channeldb.Invoice) (
*channeldb.InvoiceUpdateDesc, error) {
switch invoice.Terms.State {
switch invoice.State {
case channeldb.ContractSettled:
return nil, channeldb.ErrInvoiceAlreadySettled
case channeldb.ContractCanceled:
@ -868,7 +868,7 @@ func (i *InvoiceRegistry) SubscribeNotifications(addIndex, settleIndex uint64) *
invoiceEvent := ntfn.(*invoiceEvent)
var targetChan chan *channeldb.Invoice
state := invoiceEvent.invoice.Terms.State
state := invoiceEvent.invoice.State
switch state {
case channeldb.ContractOpen:
targetChan = client.NewInvoices

79
invoices/invoiceregistry_test.go
View File

@ -28,6 +28,10 @@ var (
testFinalCltvRejectDelta = int32(4)
testCurrentHeight = int32(1)
testFeatures = lnwire.NewFeatureVector(
nil, lnwire.Features,
)
)
var (
@ -35,6 +39,15 @@ var (
Terms: channeldb.ContractTerm{
PaymentPreimage: preimage,
Value: lnwire.MilliSatoshi(100000),
Features: testFeatures,
},
}
testHodlInvoice = &channeldb.Invoice{
Terms: channeldb.ContractTerm{
PaymentPreimage: channeldb.UnknownPreimage,
Value: lnwire.MilliSatoshi(100000),
Features: testFeatures,
},
}
)
@ -102,9 +115,9 @@ func TestSettleInvoice(t *testing.T) {
// We expect the open state to be sent to the single invoice subscriber.
select {
case update := <-subscription.Updates:
if update.Terms.State != channeldb.ContractOpen {
if update.State != channeldb.ContractOpen {
t.Fatalf("expected state ContractOpen, but got %v",
update.Terms.State)
update.State)
}
case <-time.After(testTimeout):
t.Fatal("no update received")
@ -113,9 +126,9 @@ func TestSettleInvoice(t *testing.T) {
// We expect a new invoice notification to be sent out.
select {
case newInvoice := <-allSubscriptions.NewInvoices:
if newInvoice.Terms.State != channeldb.ContractOpen {
if newInvoice.State != channeldb.ContractOpen {
t.Fatalf("expected state ContractOpen, but got %v",
newInvoice.Terms.State)
newInvoice.State)
}
case <-time.After(testTimeout):
t.Fatal("no update received")
@ -154,9 +167,9 @@ func TestSettleInvoice(t *testing.T) {
// subscriber.
select {
case update := <-subscription.Updates:
if update.Terms.State != channeldb.ContractSettled {
if update.State != channeldb.ContractSettled {
t.Fatalf("expected state ContractOpen, but got %v",
update.Terms.State)
update.State)
}
if update.AmtPaid != amtPaid {
t.Fatal("invoice AmtPaid incorrect")
@ -168,9 +181,9 @@ func TestSettleInvoice(t *testing.T) {
// We expect a settled notification to be sent out.
select {
case settledInvoice := <-allSubscriptions.SettledInvoices:
if settledInvoice.Terms.State != channeldb.ContractSettled {
if settledInvoice.State != channeldb.ContractSettled {
t.Fatalf("expected state ContractOpen, but got %v",
settledInvoice.Terms.State)
settledInvoice.State)
}
case <-time.After(testTimeout):
t.Fatal("no update received")
@ -275,10 +288,10 @@ func TestCancelInvoice(t *testing.T) {
// We expect the open state to be sent to the single invoice subscriber.
select {
case update := <-subscription.Updates:
if update.Terms.State != channeldb.ContractOpen {
if update.State != channeldb.ContractOpen {
t.Fatalf(
"expected state ContractOpen, but got %v",
update.Terms.State,
update.State,
)
}
case <-time.After(testTimeout):
@ -288,10 +301,10 @@ func TestCancelInvoice(t *testing.T) {
// We expect a new invoice notification to be sent out.
select {
case newInvoice := <-allSubscriptions.NewInvoices:
if newInvoice.Terms.State != channeldb.ContractOpen {
if newInvoice.State != channeldb.ContractOpen {
t.Fatalf(
"expected state ContractOpen, but got %v",
newInvoice.Terms.State,
newInvoice.State,
)
}
case <-time.After(testTimeout):
@ -308,10 +321,10 @@ func TestCancelInvoice(t *testing.T) {
// subscriber.
select {
case update := <-subscription.Updates:
if update.Terms.State != channeldb.ContractCanceled {
if update.State != channeldb.ContractCanceled {
t.Fatalf(
"expected state ContractCanceled, but got %v",
update.Terms.State,
update.State,
)
}
case <-time.After(testTimeout):
@ -382,30 +395,23 @@ func TestSettleHoldInvoice(t *testing.T) {
}
// Add the invoice.
invoice := &channeldb.Invoice{
Terms: channeldb.ContractTerm{
PaymentPreimage: channeldb.UnknownPreimage,
Value: lnwire.MilliSatoshi(100000),
},
}
_, err = registry.AddInvoice(invoice, hash)
_, err = registry.AddInvoice(testHodlInvoice, hash)
if err != nil {
t.Fatal(err)
}
// We expect the open state to be sent to the single invoice subscriber.
update := <-subscription.Updates
if update.Terms.State != channeldb.ContractOpen {
if update.State != channeldb.ContractOpen {
t.Fatalf("expected state ContractOpen, but got %v",
update.Terms.State)
update.State)
}
// We expect a new invoice notification to be sent out.
newInvoice := <-allSubscriptions.NewInvoices
if newInvoice.Terms.State != channeldb.ContractOpen {
if newInvoice.State != channeldb.ContractOpen {
t.Fatalf("expected state ContractOpen, but got %v",
newInvoice.Terms.State)
newInvoice.State)
}
// Use slightly higher amount for accept/settle.
@ -468,9 +474,9 @@ func TestSettleHoldInvoice(t *testing.T) {
// subscriber. For all invoice subscribers, we don't expect an update.
// Those only get notified on settle.
update = <-subscription.Updates
if update.Terms.State != channeldb.ContractAccepted {
if update.State != channeldb.ContractAccepted {
t.Fatalf("expected state ContractAccepted, but got %v",
update.Terms.State)
update.State)
}
if update.AmtPaid != amtPaid {
t.Fatal("invoice AmtPaid incorrect")
@ -494,9 +500,9 @@ func TestSettleHoldInvoice(t *testing.T) {
// We expect a settled notification to be sent out for both all and
// single invoice subscribers.
settledInvoice := <-allSubscriptions.SettledInvoices
if settledInvoice.Terms.State != channeldb.ContractSettled {
if settledInvoice.State != channeldb.ContractSettled {
t.Fatalf("expected state ContractSettled, but got %v",
settledInvoice.Terms.State)
settledInvoice.State)
}
if settledInvoice.AmtPaid != amtPaid {
t.Fatalf("expected amount to be %v, but got %v",
@ -504,9 +510,9 @@ func TestSettleHoldInvoice(t *testing.T) {
}
update = <-subscription.Updates
if update.Terms.State != channeldb.ContractSettled {
if update.State != channeldb.ContractSettled {
t.Fatalf("expected state ContractSettled, but got %v",
update.Terms.State)
update.State)
}
// Idempotency.
@ -543,14 +549,7 @@ func TestCancelHoldInvoice(t *testing.T) {
defer registry.Stop()
// Add the invoice.
invoice := &channeldb.Invoice{
Terms: channeldb.ContractTerm{
PaymentPreimage: channeldb.UnknownPreimage,
Value: lnwire.MilliSatoshi(100000),
},
}
_, err = registry.AddInvoice(invoice, hash)
_, err = registry.AddInvoice(testHodlInvoice, hash)
if err != nil {
t.Fatal(err)
}

21
lnrpc/invoicesrpc/addinvoice.go
View File

@ -57,10 +57,6 @@ type AddInvoiceData struct {
// description_hash field is not being used.
Memo string
// Deprecated. An optional cryptographic receipt of payment which is not
// implemented.
Receipt []byte
// The preimage which will allow settling an incoming HTLC payable to
// this preimage. If Preimage is set, Hash should be nil. If both
// Preimage and Hash are nil, a random preimage is generated.
@ -154,10 +150,6 @@ func AddInvoice(ctx context.Context, cfg *AddInvoiceConfig,
return nil, nil, fmt.Errorf("memo too large: %v bytes "+
"(maxsize=%v)", len(invoice.Memo), channeldb.MaxMemoSize)
}
if len(invoice.Receipt) > channeldb.MaxReceiptSize {
return nil, nil, fmt.Errorf("receipt too large: %v bytes "+
"(maxsize=%v)", len(invoice.Receipt), channeldb.MaxReceiptSize)
}
if len(invoice.DescriptionHash) > 0 && len(invoice.DescriptionHash) != 32 {
return nil, nil, fmt.Errorf("description hash is %v bytes, must be 32",
len(invoice.DescriptionHash))
@ -371,6 +363,13 @@ func AddInvoice(ctx context.Context, cfg *AddInvoiceConfig,
}
// Set a blank feature vector, as our invoice generation forbids nil
// features.
invoiceFeatures := lnwire.NewFeatureVector(
lnwire.NewRawFeatureVector(), lnwire.Features,
)
options = append(options, zpay32.Features(invoiceFeatures))
// Create and encode the payment request as a bech32 (zpay32) string.
creationDate := time.Now()
payReq, err := zpay32.NewInvoice(
@ -392,13 +391,13 @@ func AddInvoice(ctx context.Context, cfg *AddInvoiceConfig,
newInvoice := &channeldb.Invoice{
CreationDate: creationDate,
Memo: []byte(invoice.Memo),
Receipt: invoice.Receipt,
PaymentRequest: []byte(payReqString),
FinalCltvDelta: int32(payReq.MinFinalCLTVExpiry()),
Expiry: payReq.Expiry(),
Terms: channeldb.ContractTerm{
FinalCltvDelta: int32(payReq.MinFinalCLTVExpiry()),
Expiry: payReq.Expiry(),
Value: amtMSat,
PaymentPreimage: paymentPreimage,
Features: invoiceFeatures,
},
}

11
lnrpc/invoicesrpc/utils.go
View File

@ -43,10 +43,10 @@ func CreateRPCInvoice(invoice *channeldb.Invoice,
satAmt := invoice.Terms.Value.ToSatoshis()
satAmtPaid := invoice.AmtPaid.ToSatoshis()
isSettled := invoice.Terms.State == channeldb.ContractSettled
isSettled := invoice.State == channeldb.ContractSettled
var state lnrpc.Invoice_InvoiceState
switch invoice.Terms.State {
switch invoice.State {
case channeldb.ContractOpen:
state = lnrpc.Invoice_OPEN
case channeldb.ContractSettled:
@ -57,7 +57,7 @@ func CreateRPCInvoice(invoice *channeldb.Invoice,
state = lnrpc.Invoice_ACCEPTED
default:
return nil, fmt.Errorf("unknown invoice state %v",
invoice.Terms.State)
invoice.State)
}
rpcHtlcs := make([]*lnrpc.InvoiceHTLC, 0, len(invoice.Htlcs))
@ -94,7 +94,6 @@ func CreateRPCInvoice(invoice *channeldb.Invoice,
rpcInvoice := &lnrpc.Invoice{
Memo: string(invoice.Memo[:]),
Receipt: invoice.Receipt[:],
RHash: decoded.PaymentHash[:],
Value: int64(satAmt),
ValueMsat: int64(invoice.Terms.Value),
@ -103,8 +102,8 @@ func CreateRPCInvoice(invoice *channeldb.Invoice,
Settled: isSettled,
PaymentRequest: paymentRequest,
DescriptionHash: descHash,
Expiry: int64(invoice.Expiry.Seconds()),
CltvExpiry: uint64(invoice.FinalCltvDelta),
Expiry: int64(invoice.Terms.Expiry.Seconds()),
CltvExpiry: uint64(invoice.Terms.FinalCltvDelta),
FallbackAddr: fallbackAddr,
RouteHints: routeHints,
AddIndex: invoice.AddIndex,

1118
lnrpc/rpc.pb.go
View File

@ -6984,9 +6984,6 @@ type Invoice struct {
//field of the encoded payment request if the description_hash field is not
//being used.
Memo string `protobuf:"bytes,1,opt,name=memo,proto3" json:"memo,omitempty"`
//* Deprecated. An optional cryptographic receipt of payment which is not
//implemented.
Receipt []byte `protobuf:"bytes,2,opt,name=receipt,proto3" json:"receipt,omitempty"` // Deprecated: Do not use.
//*
//The hex-encoded preimage (32 byte) which will allow settling an incoming
//HTLC payable to this preimage. When using REST, this field must be encoded
@ -7107,14 +7104,6 @@ func (m *Invoice) GetMemo() string {
return ""
}
// Deprecated: Do not use.
func (m *Invoice) GetReceipt() []byte {
if m != nil {
return m.Receipt
}
return nil
}
func (m *Invoice) GetRPreimage() []byte {
if m != nil {
return m.RPreimage
@ -9635,560 +9624,559 @@ func init() {
func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
var fileDescriptor_77a6da22d6a3feb1 = []byte{
// 8836 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7d, 0x5f, 0x6c, 0x1c, 0x5b,
0x9a, 0x97, 0xab, 0xbb, 0x6d, 0x77, 0x7f, 0xdd, 0xb6, 0xdb, 0xc7, 0x8e, 0xdd, 0xe9, 0x9b, 0x9b,
0x9b, 0x5b, 0x93, 0x4d, 0x32, 0x99, 0x3b, 0x4e, 0xae, 0x77, 0xe6, 0x72, 0xf7, 0x86, 0x65, 0x71,
0x6c, 0x27, 0xce, 0x5c, 0xc7, 0xf1, 0x94, 0x93, 0x09, 0x33, 0xb3, 0xab, 0x9e, 0x72, 0xf7, 0xb1,
0x5d, 0x93, 0xee, 0xaa, 0x9e, 0xaa, 0x6a, 0x27, 0x9e, 0xcb, 0x45, 0x02, 0x21, 0x84, 0x78, 0x41,
0x03, 0x42, 0x02, 0x04, 0x5a, 0x69, 0x16, 0x89, 0x5d, 0xf1, 0x00, 0x2f, 0x48, 0x0b, 0x5a, 0x9e,
0x10, 0x42, 0x42, 0x42, 0x3c, 0xf0, 0x80, 0xc4, 0x03, 0x23, 0x04, 0x12, 0x5a, 0xf1, 0x86, 0xe0,
0x1d, 0x7d, 0xdf, 0xf9, 0x53, 0xe7, 0x54, 0x55, 0xc7, 0xb9, 0x33, 0x03, 0x4f, 0xee, 0xf3, 0x3b,
0xa7, 0xce, 0xdf, 0xef, 0xfb, 0xce, 0x77, 0xbe, 0xef, 0x3b, 0xc7, 0xd0, 0x88, 0xc7, 0xfd, 0x8d,
0x71, 0x1c, 0xa5, 0x11, 0x9b, 0x1d, 0x86, 0xf1, 0xb8, 0xdf, 0xbd, 0x76, 0x1a, 0x45, 0xa7, 0x43,
0x7e, 0xcf, 0x1f, 0x07, 0xf7, 0xfc, 0x30, 0x8c, 0x52, 0x3f, 0x0d, 0xa2, 0x30, 0x11, 0x85, 0xdc,
0x1f, 0xc1, 0xe2, 0x63, 0x1e, 0x1e, 0x71, 0x3e, 0xf0, 0xf8, 0x4f, 0x26, 0x3c, 0x49, 0xd9, 0x37,
0x60, 0xd9, 0xe7, 0x3f, 0xe5, 0x7c, 0xd0, 0x1b, 0xfb, 0x49, 0x32, 0x3e, 0x8b, 0xfd, 0x84, 0x77,
0x9c, 0x1b, 0xce, 0x9d, 0x96, 0xd7, 0x16, 0x19, 0x87, 0x1a, 0x67, 0x1f, 0x42, 0x2b, 0xc1, 0xa2,
0x3c, 0x4c, 0xe3, 0x68, 0x7c, 0xd1, 0xa9, 0x50, 0xb9, 0x26, 0x62, 0xbb, 0x02, 0x72, 0x87, 0xb0,
0xa4, 0x5b, 0x48, 0xc6, 0x51, 0x98, 0x70, 0x76, 0x1f, 0x56, 0xfb, 0xc1, 0xf8, 0x8c, 0xc7, 0x3d,
0xfa, 0x78, 0x14, 0xf2, 0x51, 0x14, 0x06, 0xfd, 0x8e, 0x73, 0xa3, 0x7a, 0xa7, 0xe1, 0x31, 0x91,
0x87, 0x5f, 0x3c, 0x95, 0x39, 0xec, 0x36, 0x2c, 0xf1, 0x50, 0xe0, 0x7c, 0x40, 0x5f, 0xc9, 0xa6,
0x16, 0x33, 0x18, 0x3f, 0x70, 0xff, 0x7a, 0x05, 0x96, 0x9f, 0x84, 0x41, 0xfa, 0xd2, 0x1f, 0x0e,
0x79, 0xaa, 0xc6, 0x74, 0x1b, 0x96, 0x5e, 0x13, 0x40, 0x63, 0x7a, 0x1d, 0xc5, 0x03, 0x39, 0xa2,
0x45, 0x01, 0x1f, 0x4a, 0x74, 0x6a, 0xcf, 0x2a, 0x53, 0x7b, 0x56, 0x3a, 0x5d, 0xd5, 0x29, 0xd3,
0x75, 0x1b, 0x96, 0x62, 0xde, 0x8f, 0xce, 0x79, 0x7c, 0xd1, 0x7b, 0x1d, 0x84, 0x83, 0xe8, 0x75,
0xa7, 0x76, 0xc3, 0xb9, 0x33, 0xeb, 0x2d, 0x2a, 0xf8, 0x25, 0xa1, 0xec, 0x21, 0x2c, 0xf5, 0xcf,
0xfc, 0x30, 0xe4, 0xc3, 0xde, 0xb1, 0xdf, 0x7f, 0x35, 0x19, 0x27, 0x9d, 0xd9, 0x1b, 0xce, 0x9d,
0xe6, 0xe6, 0xd5, 0x0d, 0x5a, 0xd5, 0x8d, 0xed, 0x33, 0x3f, 0x7c, 0x48, 0x39, 0x47, 0xa1, 0x3f,
0x4e, 0xce, 0xa2, 0xd4, 0x5b, 0x94, 0x5f, 0x08, 0x38, 0x71, 0x57, 0x81, 0x99, 0x33, 0x21, 0xe6,
0xde, 0xfd, 0x27, 0x0e, 0xac, 0xbc, 0x08, 0x87, 0x51, 0xff, 0xd5, 0x2f, 0x39, 0x45, 0x25, 0x63,
0xa8, 0xbc, 0xeb, 0x18, 0xaa, 0x5f, 0x75, 0x0c, 0x6b, 0xb0, 0x6a, 0x77, 0x56, 0x8e, 0x82, 0xc3,
0x15, 0xfc, 0xfa, 0x94, 0xab, 0x6e, 0xa9, 0x61, 0x7c, 0x1d, 0xda, 0xfd, 0x49, 0x1c, 0xf3, 0xb0,
0x30, 0x8e, 0x25, 0x89, 0xeb, 0x81, 0x7c, 0x08, 0xad, 0x90, 0xbf, 0xce, 0x8a, 0x49, 0xda, 0x0d,
0xf9, 0x6b, 0x55, 0xc4, 0xed, 0xc0, 0x5a, 0xbe, 0x19, 0xd9, 0x81, 0xff, 0xea, 0x40, 0xed, 0x45,
0xfa, 0x26, 0x62, 0x1b, 0x50, 0x4b, 0x2f, 0xc6, 0x82, 0x43, 0x16, 0x37, 0x99, 0x1c, 0xda, 0xd6,
0x60, 0x10, 0xf3, 0x24, 0x79, 0x7e, 0x31, 0xe6, 0x5e, 0xcb, 0x17, 0x89, 0x1e, 0x96, 0x63, 0x1d,
0x98, 0x97, 0x69, 0x6a, 0xb0, 0xe1, 0xa9, 0x24, 0xbb, 0x0e, 0xe0, 0x8f, 0xa2, 0x49, 0x98, 0xf6,
0x12, 0x3f, 0xa5, 0xa9, 0xaa, 0x7a, 0x06, 0xc2, 0xae, 0x41, 0x63, 0xfc, 0xaa, 0x97, 0xf4, 0xe3,
0x60, 0x9c, 0x12, 0xd9, 0x34, 0xbc, 0x0c, 0x60, 0xdf, 0x80, 0x7a, 0x34, 0x49, 0xc7, 0x51, 0x10,
0xa6, 0x92, 0x54, 0x96, 0x64, 0x5f, 0x9e, 0x4d, 0xd2, 0x43, 0x84, 0x3d, 0x5d, 0x80, 0xdd, 0x84,
0x85, 0x7e, 0x14, 0x9e, 0x04, 0xf1, 0x48, 0x08, 0x83, 0xce, 0x1c, 0xb5, 0x66, 0x83, 0xee, 0xbf,
0xa8, 0x40, 0xf3, 0x79, 0xec, 0x87, 0x89, 0xdf, 0x47, 0x00, 0xbb, 0x9e, 0xbe, 0xe9, 0x9d, 0xf9,
0xc9, 0x19, 0x8d, 0xb6, 0xe1, 0xa9, 0x24, 0x5b, 0x83, 0x39, 0xd1, 0x51, 0x1a, 0x53, 0xd5, 0x93,
0x29, 0xf6, 0x11, 0x2c, 0x87, 0x93, 0x51, 0xcf, 0x6e, 0xab, 0x4a, 0xd4, 0x52, 0xcc, 0xc0, 0x09,
0x38, 0xc6, 0xb5, 0x16, 0x4d, 0x88, 0x11, 0x1a, 0x08, 0x73, 0xa1, 0x25, 0x53, 0x3c, 0x38, 0x3d,
0x13, 0xc3, 0x9c, 0xf5, 0x2c, 0x0c, 0xeb, 0x48, 0x83, 0x11, 0xef, 0x25, 0xa9, 0x3f, 0x1a, 0xcb,
0x61, 0x19, 0x08, 0xe5, 0x47, 0xa9, 0x3f, 0xec, 0x9d, 0x70, 0x9e, 0x74, 0xe6, 0x65, 0xbe, 0x46,
0xd8, 0x2d, 0x58, 0x1c, 0xf0, 0x24, 0xed, 0xc9, 0x45, 0xe1, 0x49, 0xa7, 0x4e, 0xac, 0x9f, 0x43,
0xb1, 0x9e, 0xd8, 0x7f, 0xdd, 0xc3, 0x09, 0xe0, 0x6f, 0x3a, 0x0d, 0xd1, 0xd7, 0x0c, 0x41, 0xca,
0x79, 0xcc, 0x53, 0x63, 0xf6, 0x12, 0x49, 0xa1, 0xee, 0x3e, 0x30, 0x03, 0xde, 0xe1, 0xa9, 0x1f,
0x0c, 0x13, 0xf6, 0x09, 0xb4, 0x52, 0xa3, 0x30, 0x89, 0xc2, 0xa6, 0x26, 0x27, 0xe3, 0x03, 0xcf,
0x2a, 0xe7, 0x9e, 0x41, 0xfd, 0x11, 0xe7, 0xfb, 0xc1, 0x28, 0x48, 0xd9, 0x1a, 0xcc, 0x9e, 0x04,
0x6f, 0xb8, 0x20, 0xf8, 0xea, 0xde, 0x8c, 0x27, 0x92, 0xec, 0x03, 0x00, 0xfa, 0xd1, 0x1b, 0x69,
0xc2, 0xda, 0x9b, 0xf1, 0x1a, 0x84, 0x3d, 0x45, 0xca, 0xea, 0xc2, 0xfc, 0x98, 0xc7, 0x7d, 0xae,
0xd6, 0x6f, 0x6f, 0xc6, 0x53, 0xc0, 0xc3, 0x79, 0x98, 0x1d, 0x62, 0xed, 0xee, 0x1f, 0xd7, 0xa0,
0x79, 0xc4, 0x43, 0xcd, 0x69, 0x0c, 0x6a, 0x38, 0x27, 0x92, 0xbb, 0xe8, 0x37, 0xfb, 0x1a, 0x34,
0x69, 0x9e, 0x92, 0x34, 0x0e, 0xc2, 0x53, 0x41, 0xe0, 0x0f, 0x2b, 0x1d, 0xc7, 0x03, 0x84, 0x8f,
0x08, 0x65, 0x6d, 0xa8, 0xfa, 0x23, 0x45, 0xe0, 0xf8, 0x93, 0x5d, 0x85, 0xba, 0x3f, 0x4a, 0x45,
0xf7, 0x5a, 0x04, 0xcf, 0xfb, 0xa3, 0x94, 0xba, 0xf6, 0x21, 0xb4, 0xc6, 0xfe, 0xc5, 0x08, 0xf9,
0x59, 0x53, 0x45, 0xcb, 0x6b, 0x4a, 0x6c, 0x0f, 0xc9, 0x62, 0x13, 0x56, 0xcc, 0x22, 0xaa, 0xf1,
0x59, 0xdd, 0xf8, 0xb2, 0x51, 0x5a, 0xf6, 0xe1, 0x36, 0x2c, 0xa9, 0x6f, 0x62, 0x31, 0x1e, 0xa2,
0x95, 0x86, 0xb7, 0x28, 0x61, 0x35, 0xca, 0x3b, 0xd0, 0x3e, 0x09, 0x42, 0x7f, 0xd8, 0xeb, 0x0f,
0xd3, 0xf3, 0xde, 0x80, 0x0f, 0x53, 0x9f, 0xa8, 0x66, 0xd6, 0x5b, 0x24, 0x7c, 0x7b, 0x98, 0x9e,
0xef, 0x20, 0xca, 0x3e, 0x82, 0xc6, 0x09, 0xe7, 0x3d, 0x9a, 0xac, 0x4e, 0xdd, 0xe2, 0x40, 0xb5,
0x42, 0x5e, 0xfd, 0x44, 0xad, 0xd5, 0x47, 0xd0, 0x8e, 0x26, 0xe9, 0x69, 0x14, 0x84, 0xa7, 0x3d,
0x94, 0x79, 0xbd, 0x60, 0x40, 0x54, 0x54, 0x7b, 0x58, 0xb9, 0xef, 0x78, 0x8b, 0x2a, 0x0f, 0xa5,
0xcf, 0x93, 0x01, 0xbb, 0x05, 0x4b, 0x43, 0x3f, 0x49, 0x7b, 0x67, 0xd1, 0xb8, 0x37, 0x9e, 0x1c,
0xbf, 0xe2, 0x17, 0x9d, 0x05, 0x9a, 0x88, 0x05, 0x84, 0xf7, 0xa2, 0xf1, 0x21, 0x81, 0xec, 0x7d,
0x00, 0xea, 0xa7, 0xe8, 0x04, 0xdc, 0x70, 0xee, 0x2c, 0x78, 0x0d, 0x44, 0x44, 0xa3, 0x9f, 0x41,
0x9d, 0x96, 0x27, 0x1d, 0x9e, 0x77, 0x9a, 0x44, 0x60, 0x1f, 0xc8, 0x1e, 0x1a, 0x0b, 0xbb, 0xb1,
0xc3, 0x93, 0xf4, 0xf9, 0xf0, 0x1c, 0xf7, 0xef, 0x0b, 0x6f, 0x7e, 0x20, 0x52, 0xdd, 0xcf, 0xa0,
0x65, 0x66, 0xe0, 0x2a, 0x62, 0x37, 0x70, 0xf5, 0x6b, 0x1e, 0xfe, 0x64, 0xab, 0x30, 0x7b, 0xee,
0x0f, 0x27, 0x5c, 0x0a, 0x52, 0x91, 0xf8, 0xac, 0xf2, 0xa9, 0xe3, 0xfe, 0xb1, 0x03, 0x2d, 0xd1,
0x82, 0x54, 0x00, 0x6e, 0xc2, 0x82, 0x9a, 0x7e, 0x1e, 0xc7, 0x51, 0x2c, 0xe5, 0x89, 0x0d, 0xb2,
0xbb, 0xd0, 0x56, 0xc0, 0x38, 0xe6, 0xc1, 0xc8, 0x3f, 0x55, 0x75, 0x17, 0x70, 0xb6, 0x99, 0xd5,
0x18, 0x47, 0x93, 0x94, 0xcb, 0xad, 0xa6, 0x25, 0xc7, 0xe7, 0x21, 0xe6, 0xd9, 0x45, 0x50, 0x9e,
0x94, 0xd0, 0x96, 0x85, 0xb9, 0x7f, 0xc7, 0x01, 0x86, 0x5d, 0x7f, 0x1e, 0x89, 0x2a, 0x24, 0x59,
0xe4, 0xc9, 0xd2, 0x79, 0x67, 0xb2, 0xac, 0xbc, 0x8d, 0x2c, 0x5d, 0x98, 0x15, 0xbd, 0xaf, 0x95,
0xf4, 0x5e, 0x64, 0x7d, 0xa7, 0x56, 0xaf, 0xb6, 0x6b, 0xee, 0x7f, 0xae, 0xc2, 0xea, 0xb6, 0xd8,
0x2b, 0xb7, 0xfa, 0x7d, 0x3e, 0xd6, 0x04, 0xfb, 0x01, 0x34, 0xc3, 0x68, 0xc0, 0x15, 0x99, 0x88,
0x8e, 0x01, 0x42, 0x06, 0x8d, 0x9c, 0xf9, 0x41, 0x28, 0x3a, 0x2e, 0xe6, 0xb3, 0x41, 0x08, 0x75,
0xfb, 0x16, 0x2c, 0x8d, 0x79, 0x38, 0x30, 0xe9, 0x52, 0x68, 0x33, 0x0b, 0x12, 0x96, 0x24, 0xf9,
0x01, 0x34, 0x4f, 0x26, 0xa2, 0x1c, 0x72, 0x73, 0x8d, 0xe8, 0x00, 0x24, 0xb4, 0x25, 0x98, 0x7a,
0x3c, 0x49, 0xce, 0x28, 0x77, 0x96, 0x72, 0xe7, 0x31, 0x8d, 0x59, 0xef, 0x03, 0x0c, 0x26, 0x49,
0x2a, 0xc9, 0x74, 0x8e, 0x32, 0x1b, 0x88, 0x08, 0x32, 0xfd, 0x26, 0xac, 0x8c, 0xfc, 0x37, 0x3d,
0xa2, 0x9f, 0x5e, 0x10, 0xf6, 0x4e, 0x86, 0x24, 0xee, 0xe7, 0xa9, 0x5c, 0x7b, 0xe4, 0xbf, 0xf9,
0x1e, 0xe6, 0x3c, 0x09, 0x1f, 0x11, 0x8e, 0xbc, 0xac, 0xf4, 0x8c, 0x98, 0x27, 0x3c, 0x3e, 0xe7,
0xc4, 0x7e, 0x35, 0xad, 0x4c, 0x78, 0x02, 0xc5, 0x1e, 0x8d, 0x70, 0xdc, 0xe9, 0xb0, 0x2f, 0x78,
0xcd, 0x9b, 0x1f, 0x05, 0xe1, 0x5e, 0x3a, 0xec, 0xb3, 0x6b, 0x00, 0xc8, 0xbc, 0x63, 0x1e, 0xf7,
0x5e, 0xbd, 0x26, 0xc6, 0xa9, 0x11, 0xb3, 0x1e, 0xf2, 0xf8, 0xf3, 0xd7, 0xec, 0x3d, 0x68, 0xf4,
0x13, 0xe2, 0x7e, 0xff, 0xa2, 0xd3, 0x24, 0xae, 0xaa, 0xf7, 0x13, 0xe4, 0x7b, 0xff, 0x82, 0x7d,
0x04, 0x0c, 0x7b, 0xeb, 0xd3, 0x2a, 0xf0, 0x01, 0x55, 0x9f, 0x90, 0x18, 0x5b, 0xa0, 0xce, 0x6e,
0xc9, 0x0c, 0x6c, 0x27, 0x61, 0x5f, 0x83, 0x05, 0xd5, 0xd9, 0x93, 0xa1, 0x7f, 0x9a, 0x10, 0x1f,
0x2f, 0x78, 0x2d, 0x09, 0x3e, 0x42, 0xcc, 0x7d, 0x29, 0xb4, 0x1b, 0x63, 0x6d, 0x25, 0xdf, 0xe0,
0x3e, 0x4b, 0x08, 0xad, 0x6b, 0xdd, 0x93, 0xa9, 0xb2, 0x45, 0xab, 0x94, 0x2c, 0x9a, 0xfb, 0x73,
0x07, 0x5a, 0xb2, 0x66, 0x52, 0x09, 0xd8, 0x7d, 0x60, 0x6a, 0x15, 0xd3, 0x37, 0xc1, 0xa0, 0x77,
0x7c, 0x91, 0xf2, 0x44, 0x10, 0xcd, 0xde, 0x8c, 0x57, 0x92, 0x87, 0x82, 0xcb, 0x42, 0x93, 0x34,
0x16, 0x34, 0xbd, 0x37, 0xe3, 0x15, 0x72, 0x90, 0xc5, 0x50, 0xe9, 0x98, 0xa4, 0xbd, 0x20, 0x1c,
0xf0, 0x37, 0x44, 0x4a, 0x0b, 0x9e, 0x85, 0x3d, 0x5c, 0x84, 0x96, 0xf9, 0x9d, 0xfb, 0x63, 0xa8,
0x2b, 0x95, 0x85, 0xb6, 0xeb, 0x5c, 0xbf, 0x3c, 0x03, 0x61, 0x5d, 0xa8, 0xdb, 0xbd, 0xf0, 0xea,
0x5f, 0xa5, 0x6d, 0xf7, 0xcf, 0x41, 0x7b, 0x1f, 0x89, 0x28, 0x44, 0xa2, 0x95, 0x7a, 0xd8, 0x1a,
0xcc, 0x19, 0xcc, 0xd3, 0xf0, 0x64, 0x0a, 0x37, 0xbc, 0xb3, 0x28, 0x49, 0x65, 0x3b, 0xf4, 0xdb,
0xfd, 0xb7, 0x0e, 0xb0, 0xdd, 0x24, 0x0d, 0x46, 0x7e, 0xca, 0x1f, 0x71, 0x2d, 0x1e, 0x9e, 0x41,
0x0b, 0x6b, 0x7b, 0x1e, 0x6d, 0x09, 0xad, 0x48, 0xec, 0xe6, 0xdf, 0x90, 0xec, 0x5c, 0xfc, 0x60,
0xc3, 0x2c, 0x2d, 0x04, 0xaf, 0x55, 0x01, 0x72, 0x5b, 0xea, 0xc7, 0xa7, 0x3c, 0x25, 0x95, 0x49,
0x2a, 0xdc, 0x20, 0xa0, 0xed, 0x28, 0x3c, 0xe9, 0xfe, 0x0e, 0x2c, 0x17, 0xea, 0x30, 0x65, 0x74,
0xa3, 0x44, 0x46, 0x57, 0x4d, 0x19, 0xdd, 0x87, 0x15, 0xab, 0x5f, 0x92, 0xe2, 0x3a, 0x30, 0x8f,
0x8c, 0x81, 0x3b, 0xb3, 0x23, 0x76, 0x66, 0x99, 0x64, 0x9b, 0xb0, 0x7a, 0xc2, 0x79, 0xec, 0xa7,
0x94, 0x24, 0xd6, 0xc1, 0x35, 0x91, 0x35, 0x97, 0xe6, 0xb9, 0xff, 0xcd, 0x81, 0x25, 0x94, 0xa6,
0x4f, 0xfd, 0xf0, 0x42, 0xcd, 0xd5, 0x7e, 0xe9, 0x5c, 0xdd, 0x31, 0x36, 0x26, 0xa3, 0xf4, 0x57,
0x9d, 0xa8, 0x6a, 0x7e, 0xa2, 0xd8, 0x0d, 0x68, 0x59, 0xdd, 0x9d, 0x15, 0x2a, 0x60, 0xe2, 0xa7,
0x87, 0x3c, 0x7e, 0x78, 0x91, 0xf2, 0x5f, 0x7d, 0x2a, 0x6f, 0x41, 0x3b, 0xeb, 0xb6, 0x9c, 0x47,
0x06, 0x35, 0x24, 0x4c, 0x59, 0x01, 0xfd, 0x76, 0xff, 0x81, 0x23, 0x0a, 0x6e, 0x47, 0x81, 0x56,
0x0f, 0xb1, 0x20, 0x6a, 0x99, 0xaa, 0x20, 0xfe, 0x9e, 0xaa, 0x5e, 0xff, 0xea, 0x83, 0x45, 0x99,
0x98, 0xf0, 0x70, 0xd0, 0xf3, 0x87, 0x43, 0x12, 0xc4, 0x75, 0x6f, 0x1e, 0xd3, 0x5b, 0xc3, 0xa1,
0x7b, 0x1b, 0x96, 0x8d, 0xde, 0xbd, 0x65, 0x1c, 0x07, 0xc0, 0xf6, 0x83, 0x24, 0x7d, 0x11, 0x26,
0x63, 0x43, 0x73, 0x7a, 0x0f, 0x1a, 0x28, 0x6d, 0xb1, 0x67, 0x82, 0x73, 0x67, 0x3d, 0x14, 0xbf,
0xd8, 0xaf, 0x84, 0x32, 0xfd, 0x37, 0x32, 0xb3, 0x22, 0x33, 0xfd, 0x37, 0x94, 0xe9, 0x7e, 0x0a,
0x2b, 0x56, 0x7d, 0xb2, 0xe9, 0x0f, 0x61, 0x76, 0x92, 0xbe, 0x89, 0x94, 0x6e, 0xdc, 0x94, 0x14,
0x82, 0xa7, 0x30, 0x4f, 0xe4, 0xb8, 0x0f, 0x60, 0xf9, 0x80, 0xbf, 0x96, 0x8c, 0xac, 0x3a, 0x72,
0xeb, 0xd2, 0x13, 0x1a, 0xe5, 0xbb, 0x1b, 0xc0, 0xcc, 0x8f, 0x33, 0x06, 0x50, 0xe7, 0x35, 0xc7,
0x3a, 0xaf, 0xb9, 0xb7, 0x80, 0x1d, 0x05, 0xa7, 0xe1, 0x53, 0x9e, 0x24, 0xfe, 0xa9, 0x66, 0xfd,
0x36, 0x54, 0x47, 0xc9, 0xa9, 0x14, 0x55, 0xf8, 0xd3, 0xfd, 0x4d, 0x58, 0xb1, 0xca, 0xc9, 0x8a,
0xaf, 0x41, 0x23, 0x09, 0x4e, 0x43, 0x3f, 0x9d, 0xc4, 0x5c, 0x56, 0x9d, 0x01, 0xee, 0x23, 0x58,
0xfd, 0x1e, 0x8f, 0x83, 0x93, 0x8b, 0xcb, 0xaa, 0xb7, 0xeb, 0xa9, 0xe4, 0xeb, 0xd9, 0x85, 0x2b,
0xb9, 0x7a, 0x64, 0xf3, 0x82, 0x7c, 0xe5, 0x4a, 0xd6, 0x3d, 0x91, 0x30, 0x64, 0x5f, 0xc5, 0x94,
0x7d, 0xee, 0x0b, 0x60, 0xdb, 0x51, 0x18, 0xf2, 0x7e, 0x7a, 0xc8, 0x79, 0x9c, 0x99, 0x8a, 0x32,
0x5a, 0x6d, 0x6e, 0xae, 0xcb, 0x99, 0xcd, 0x0b, 0x54, 0x49, 0xc4, 0x0c, 0x6a, 0x63, 0x1e, 0x8f,
0xa8, 0xe2, 0xba, 0x47, 0xbf, 0xdd, 0x2b, 0xb0, 0x62, 0x55, 0x2b, 0x0f, 0xd7, 0x1f, 0xc3, 0x95,
0x9d, 0x20, 0xe9, 0x17, 0x1b, 0xec, 0xc0, 0xfc, 0x78, 0x72, 0xdc, 0xcb, 0x38, 0x51, 0x25, 0xf1,
0xbc, 0x95, 0xff, 0x44, 0x56, 0xf6, 0xd7, 0x1c, 0xa8, 0xed, 0x3d, 0xdf, 0xdf, 0xc6, 0xbd, 0x22,
0x08, 0xfb, 0xd1, 0x08, 0xb5, 0x30, 0x31, 0x68, 0x9d, 0x9e, 0xca, 0x61, 0xd7, 0xa0, 0x41, 0xca,
0x1b, 0x1e, 0x31, 0xa5, 0x1e, 0x94, 0x01, 0x78, 0xbc, 0xe5, 0x6f, 0xc6, 0x41, 0x4c, 0xe7, 0x57,
0x75, 0x2a, 0xad, 0xd1, 0x36, 0x53, 0xcc, 0x70, 0x7f, 0x3e, 0x0f, 0xf3, 0x72, 0xf3, 0x15, 0x1b,
0x79, 0x1a, 0x9c, 0xf3, 0x6c, 0x23, 0xc7, 0x14, 0x2a, 0xc6, 0x31, 0x1f, 0x45, 0xa9, 0xd6, 0xdf,
0xc4, 0x32, 0xd8, 0x20, 0x1d, 0xdf, 0xa5, 0x12, 0x21, 0x0e, 0xfc, 0x55, 0x51, 0xca, 0x02, 0xd9,
0x35, 0x98, 0x57, 0xca, 0x40, 0x4d, 0x9f, 0x2c, 0x14, 0x84, 0xb3, 0xd1, 0xf7, 0xc7, 0x7e, 0x3f,
0x48, 0x2f, 0xa4, 0x58, 0xd0, 0x69, 0xac, 0x7f, 0x18, 0xf5, 0xfd, 0x61, 0xef, 0xd8, 0x1f, 0xfa,
0x61, 0x9f, 0x2b, 0xf3, 0x80, 0x05, 0xe2, 0x51, 0x59, 0x76, 0x4b, 0x15, 0x13, 0xc7, 0xe9, 0x1c,
0x8a, 0x7b, 0x78, 0x3f, 0x1a, 0x8d, 0x82, 0x14, 0x4f, 0xd8, 0xa4, 0x9a, 0x55, 0x3d, 0x03, 0x11,
0xc6, 0x08, 0x4a, 0xbd, 0x16, 0x33, 0xd8, 0x50, 0xc6, 0x08, 0x03, 0xc4, 0x5a, 0x72, 0x1a, 0x5a,
0xd5, 0x33, 0x10, 0x5c, 0x8b, 0x49, 0x98, 0xf0, 0x34, 0x1d, 0xf2, 0x81, 0xee, 0x50, 0x93, 0x8a,
0x15, 0x33, 0xd8, 0x7d, 0x58, 0x11, 0x87, 0xfe, 0xc4, 0x4f, 0xa3, 0xe4, 0x2c, 0x48, 0x7a, 0x09,
0x9e, 0x7e, 0xc5, 0xe1, 0xb3, 0x2c, 0x8b, 0x7d, 0x0a, 0xeb, 0x39, 0x38, 0xe6, 0x7d, 0x1e, 0x9c,
0xf3, 0x01, 0xa9, 0x70, 0x55, 0x6f, 0x5a, 0x36, 0xbb, 0x01, 0xcd, 0x70, 0x32, 0xea, 0x4d, 0xc6,
0x03, 0x1f, 0x95, 0x98, 0x45, 0x52, 0x2e, 0x4d, 0x88, 0x7d, 0x0c, 0x4a, 0x4f, 0x93, 0xda, 0xe3,
0x92, 0x25, 0xe1, 0x90, 0x7a, 0x3d, 0xbb, 0x04, 0x12, 0x66, 0xa6, 0x92, 0xb6, 0xe5, 0x41, 0x4f,
0x01, 0xc4, 0x27, 0x71, 0x70, 0xee, 0xa7, 0xbc, 0xb3, 0x2c, 0x84, 0xba, 0x4c, 0xe2, 0x77, 0x41,
0x18, 0xa4, 0x81, 0x9f, 0x46, 0x71, 0x87, 0x51, 0x5e, 0x06, 0xe0, 0x24, 0x12, 0x7d, 0x24, 0xa9,
0x9f, 0x4e, 0x12, 0xa9, 0xa1, 0xae, 0x10, 0x71, 0x15, 0x33, 0xd8, 0x27, 0xb0, 0x26, 0x28, 0x82,
0xb2, 0xa4, 0xee, 0x4d, 0xaa, 0xc2, 0x2a, 0xcd, 0xc8, 0x94, 0x5c, 0x9c, 0x4a, 0x49, 0x22, 0x85,
0x0f, 0xaf, 0x88, 0xa9, 0x9c, 0x92, 0x8d, 0xfd, 0xc3, 0x1e, 0x04, 0xfd, 0x9e, 0x2c, 0x81, 0x2c,
0xb2, 0x46, 0xa3, 0x28, 0x66, 0x20, 0x89, 0x0f, 0x83, 0x13, 0x9e, 0x06, 0x23, 0xde, 0x59, 0x17,
0x24, 0xae, 0xd2, 0xc8, 0x80, 0x93, 0x31, 0xe5, 0x74, 0x04, 0xc3, 0x8b, 0x94, 0xfb, 0xfb, 0x8e,
0xd8, 0x7c, 0x24, 0xa3, 0x26, 0xc6, 0xb1, 0x4a, 0xb0, 0x68, 0x2f, 0x0a, 0x87, 0x17, 0x92, 0x6b,
0x41, 0x40, 0xcf, 0xc2, 0xe1, 0x05, 0x2a, 0xf6, 0x41, 0x68, 0x16, 0x11, 0x72, 0xae, 0xa5, 0x40,
0x2a, 0xf4, 0x01, 0x34, 0xc7, 0x93, 0xe3, 0x61, 0xd0, 0x17, 0x45, 0xaa, 0xa2, 0x16, 0x01, 0x51,
0x01, 0x3c, 0x57, 0x8a, 0x95, 0x12, 0x25, 0x6a, 0x54, 0xa2, 0x29, 0x31, 0x2c, 0xe2, 0x3e, 0x84,
0x55, 0xbb, 0x83, 0x52, 0xa0, 0xdf, 0x85, 0xba, 0xe4, 0xff, 0x44, 0x1e, 0xee, 0x17, 0x0d, 0x3b,
0x2b, 0x1e, 0x83, 0x74, 0xbe, 0xfb, 0x2f, 0x6b, 0xb0, 0x22, 0xd1, 0xed, 0x61, 0x94, 0xf0, 0xa3,
0xc9, 0x68, 0xe4, 0xc7, 0x25, 0x82, 0xc5, 0xb9, 0x44, 0xb0, 0x54, 0x8a, 0x82, 0xe5, 0xba, 0x75,
0xbe, 0x14, 0x92, 0xc9, 0x40, 0xd8, 0x1d, 0x58, 0xea, 0x0f, 0xa3, 0x44, 0xa8, 0xfb, 0xa6, 0xa9,
0x2f, 0x0f, 0x17, 0x85, 0xe1, 0x6c, 0x99, 0x30, 0x34, 0x05, 0xd9, 0x5c, 0x4e, 0x90, 0xb9, 0xd0,
0xc2, 0x4a, 0xb9, 0x92, 0xcd, 0xf3, 0xf2, 0xb0, 0x65, 0x60, 0xd8, 0x9f, 0xbc, 0xd8, 0x10, 0x32,
0x6a, 0xa9, 0x4c, 0x68, 0x04, 0x23, 0x4e, 0xb2, 0xdf, 0x28, 0xdd, 0x90, 0x42, 0xa3, 0x98, 0xc5,
0x1e, 0x01, 0x88, 0xb6, 0x48, 0x01, 0x01, 0x52, 0x40, 0x6e, 0xd9, 0xab, 0x62, 0xce, 0xff, 0x06,
0x26, 0x26, 0x31, 0x27, 0xa5, 0xc4, 0xf8, 0xd2, 0xfd, 0x1b, 0x0e, 0x34, 0x8d, 0x3c, 0x76, 0x05,
0x96, 0xb7, 0x9f, 0x3d, 0x3b, 0xdc, 0xf5, 0xb6, 0x9e, 0x3f, 0xf9, 0xde, 0x6e, 0x6f, 0x7b, 0xff,
0xd9, 0xd1, 0x6e, 0x7b, 0x06, 0xe1, 0xfd, 0x67, 0xdb, 0x5b, 0xfb, 0xbd, 0x47, 0xcf, 0xbc, 0x6d,
0x05, 0x3b, 0x6c, 0x0d, 0x98, 0xb7, 0xfb, 0xf4, 0xd9, 0xf3, 0x5d, 0x0b, 0xaf, 0xb0, 0x36, 0xb4,
0x1e, 0x7a, 0xbb, 0x5b, 0xdb, 0x7b, 0x12, 0xa9, 0xb2, 0x55, 0x68, 0x3f, 0x7a, 0x71, 0xb0, 0xf3,
0xe4, 0xe0, 0x71, 0x6f, 0x7b, 0xeb, 0x60, 0x7b, 0x77, 0x7f, 0x77, 0xa7, 0x5d, 0x63, 0x0b, 0xd0,
0xd8, 0x7a, 0xb8, 0x75, 0xb0, 0xf3, 0xec, 0x60, 0x77, 0xa7, 0x3d, 0xeb, 0xfe, 0x17, 0x07, 0xae,
0x50, 0xaf, 0x07, 0x79, 0x26, 0xb9, 0x01, 0xcd, 0x7e, 0x14, 0x8d, 0x51, 0xf1, 0xcf, 0xb6, 0x36,
0x13, 0x42, 0x06, 0x10, 0x42, 0xe1, 0x24, 0x8a, 0xfb, 0x5c, 0xf2, 0x08, 0x10, 0xf4, 0x08, 0x11,
0x64, 0x00, 0xb9, 0xbc, 0xa2, 0x84, 0x60, 0x91, 0xa6, 0xc0, 0x44, 0x91, 0x35, 0x98, 0x3b, 0x8e,
0xb9, 0xdf, 0x3f, 0x93, 0xdc, 0x21, 0x53, 0xec, 0xeb, 0xd9, 0xc9, 0xb4, 0x8f, 0xb3, 0x3f, 0xe4,
0x03, 0xa2, 0x98, 0xba, 0xb7, 0x24, 0xf1, 0x6d, 0x09, 0xa3, 0x14, 0xf4, 0x8f, 0xfd, 0x70, 0x10,
0x85, 0x7c, 0x20, 0xd5, 0xde, 0x0c, 0x70, 0x0f, 0x61, 0x2d, 0x3f, 0x3e, 0xc9, 0x63, 0x9f, 0x18,
0x3c, 0x26, 0xb4, 0xd0, 0xee, 0xf4, 0xd5, 0x34, 0xf8, 0xed, 0x17, 0x15, 0xa8, 0xa1, 0x52, 0x32,
0x5d, 0x81, 0x31, 0xf5, 0xcc, 0x6a, 0xc1, 0x2f, 0x40, 0x87, 0x5d, 0xb1, 0x45, 0x49, 0x43, 0x4b,
0x86, 0x64, 0xf9, 0x31, 0xef, 0x9f, 0x4b, 0x53, 0x8b, 0x81, 0x20, 0x83, 0xe0, 0x21, 0x80, 0xbe,
0x96, 0x0c, 0xa2, 0xd2, 0x2a, 0x8f, 0xbe, 0x9c, 0xcf, 0xf2, 0xe8, 0xbb, 0x0e, 0xcc, 0x07, 0xe1,
0x71, 0x34, 0x09, 0x07, 0xc4, 0x10, 0x75, 0x4f, 0x25, 0xc9, 0x13, 0x41, 0x8c, 0x8a, 0xf2, 0x53,
0x90, 0x7f, 0x06, 0xb0, 0x4d, 0x68, 0x24, 0x17, 0x61, 0xdf, 0xa4, 0xf9, 0x55, 0x39, 0x4b, 0x38,
0x07, 0x1b, 0x47, 0x17, 0x61, 0x9f, 0x28, 0x3c, 0x2b, 0xe6, 0xfe, 0x0e, 0xd4, 0x15, 0x8c, 0x64,
0xf9, 0xe2, 0xe0, 0xf3, 0x83, 0x67, 0x2f, 0x0f, 0x7a, 0x47, 0xdf, 0x3f, 0xd8, 0x6e, 0xcf, 0xb0,
0x25, 0x68, 0x6e, 0x6d, 0x13, 0xa5, 0x13, 0xe0, 0x60, 0x91, 0xc3, 0xad, 0xa3, 0x23, 0x8d, 0x54,
0x5c, 0x86, 0x07, 0xf9, 0x84, 0x34, 0x3f, 0x6d, 0x69, 0xff, 0x04, 0x96, 0x0d, 0x2c, 0x3b, 0x45,
0x8c, 0x11, 0xc8, 0x9d, 0x22, 0x48, 0x65, 0x14, 0x39, 0x6e, 0x1b, 0x16, 0x1f, 0xf3, 0xf4, 0x49,
0x78, 0x12, 0xa9, 0x9a, 0xfe, 0x47, 0x0d, 0x96, 0x34, 0x24, 0x2b, 0xba, 0x03, 0x4b, 0xc1, 0x80,
0x87, 0x69, 0x90, 0x5e, 0xf4, 0x2c, 0x7b, 0x41, 0x1e, 0x46, 0x55, 0xdb, 0x1f, 0x06, 0xbe, 0x72,
0xf8, 0x88, 0x04, 0x9e, 0x9f, 0x51, 0x07, 0x30, 0xed, 0x36, 0x44, 0x57, 0xc2, 0x4c, 0x51, 0x9a,
0x87, 0x12, 0x08, 0x71, 0xb9, 0xcd, 0xe8, 0x4f, 0x84, 0xca, 0x59, 0x96, 0x85, 0x4b, 0x25, 0x6a,
0xc2, 0x21, 0xcf, 0x0a, 0x3d, 0x41, 0x03, 0x05, 0x8f, 0xca, 0x9c, 0x90, 0x8f, 0x79, 0x8f, 0x8a,
0xe1, 0x95, 0xa9, 0x17, 0xbc, 0x32, 0x28, 0x3f, 0x2f, 0xc2, 0x3e, 0x1f, 0xf4, 0xd2, 0xa8, 0x47,
0x72, 0x9e, 0x48, 0xa2, 0xee, 0xe5, 0x61, 0xdc, 0x37, 0x52, 0x9e, 0xa4, 0x21, 0x17, 0xa6, 0xe9,
0x3a, 0x59, 0x41, 0x15, 0x84, 0xe7, 0x83, 0x49, 0x1c, 0x24, 0x9d, 0x16, 0xf9, 0x5b, 0xe8, 0x37,
0xfb, 0x16, 0x5c, 0x39, 0xe6, 0x49, 0xda, 0x3b, 0xe3, 0xfe, 0x80, 0xc7, 0x44, 0x5e, 0xc2, 0xb1,
0x23, 0x54, 0xae, 0xf2, 0x4c, 0x24, 0xdc, 0x73, 0x1e, 0x27, 0x41, 0x14, 0x92, 0xb2, 0xd5, 0xf0,
0x54, 0x12, 0xeb, 0xc3, 0xc1, 0xeb, 0x8d, 0x5a, 0xcf, 0xe0, 0x12, 0x0d, 0xbc, 0x3c, 0x93, 0xdd,
0x84, 0x39, 0x1a, 0x40, 0xd2, 0x69, 0x13, 0xcd, 0xb4, 0x32, 0x9e, 0x0f, 0x42, 0x4f, 0xe6, 0xe1,
0x2a, 0xf7, 0xa3, 0x61, 0x14, 0x93, 0xc6, 0xd5, 0xf0, 0x44, 0xc2, 0x9e, 0x9d, 0xd3, 0xd8, 0x1f,
0x9f, 0x49, 0xad, 0x2b, 0x0f, 0x7f, 0xa7, 0x56, 0x6f, 0xb6, 0x5b, 0xee, 0x9f, 0x81, 0x59, 0xaa,
0x96, 0xaa, 0xa3, 0xc9, 0x74, 0x64, 0x75, 0x84, 0x76, 0x60, 0x3e, 0xe4, 0xe9, 0xeb, 0x28, 0x7e,
0xa5, 0xbc, 0x87, 0x32, 0xe9, 0xfe, 0x94, 0x4e, 0x68, 0xda, 0x9b, 0xf6, 0x82, 0x54, 0x4b, 0x3c,
0x67, 0x8b, 0xa5, 0x4a, 0xce, 0x7c, 0x79, 0x68, 0xac, 0x13, 0x70, 0x74, 0xe6, 0xa3, 0xac, 0xb5,
0x56, 0x5f, 0x9c, 0xc3, 0x9b, 0x84, 0xed, 0x89, 0xc5, 0xbf, 0x09, 0x8b, 0xca, 0x4f, 0x97, 0xf4,
0x86, 0xfc, 0x24, 0x55, 0x56, 0xb4, 0x70, 0x32, 0xa2, 0xc3, 0xfa, 0x3e, 0x3f, 0x49, 0xdd, 0x03,
0x58, 0x96, 0xf2, 0xef, 0xd9, 0x98, 0xab, 0xa6, 0x7f, 0xab, 0x4c, 0x97, 0x68, 0x6e, 0xae, 0xd8,
0x02, 0x53, 0x78, 0x26, 0xed, 0x92, 0xae, 0x07, 0xcc, 0x94, 0xa7, 0xb2, 0x42, 0xb9, 0x99, 0x2b,
0x3b, 0xa1, 0x1c, 0x8e, 0x85, 0xe1, 0xfc, 0x24, 0x93, 0x7e, 0x5f, 0x79, 0x57, 0xeb, 0x9e, 0x4a,
0xba, 0x7f, 0xe8, 0xc0, 0x0a, 0xd5, 0xa6, 0xb4, 0x21, 0xb9, 0x67, 0x7d, 0xfa, 0x15, 0xba, 0xa9,
0xac, 0xb4, 0xc2, 0x36, 0xb9, 0x0a, 0xb3, 0xe6, 0x2e, 0x26, 0x12, 0x5f, 0xdd, 0x26, 0x53, 0xcb,
0xdb, 0x64, 0xdc, 0xbf, 0xeb, 0xc0, 0xb2, 0xd8, 0x48, 0x48, 0xdb, 0x96, 0xc3, 0xff, 0xb3, 0xb0,
0x20, 0x34, 0x02, 0x29, 0x15, 0x64, 0x47, 0x33, 0xd1, 0x4a, 0xa8, 0x28, 0xbc, 0x37, 0xe3, 0xd9,
0x85, 0xd9, 0x03, 0xd2, 0xca, 0xc2, 0x1e, 0xa1, 0x25, 0x7e, 0x78, 0x7b, 0xae, 0xf7, 0x66, 0x3c,
0xa3, 0xf8, 0xc3, 0x3a, 0x2a, 0xcb, 0x88, 0xbb, 0x8f, 0x61, 0xc1, 0x6a, 0xc8, 0xb2, 0x07, 0xb5,
0x84, 0x3d, 0xa8, 0x60, 0x78, 0xad, 0x94, 0x18, 0x5e, 0xff, 0x79, 0x15, 0x18, 0x12, 0x4b, 0x6e,
0x35, 0x6e, 0xd8, 0xde, 0x0b, 0xe5, 0x92, 0xcf, 0x20, 0xb6, 0x09, 0xcc, 0x48, 0x2a, 0xaf, 0x4a,
0x55, 0x7b, 0x55, 0x4a, 0x72, 0x51, 0xd4, 0x4a, 0xad, 0x43, 0x7b, 0x2c, 0xe8, 0xac, 0x2f, 0xa6,
0xbe, 0x34, 0x0f, 0x77, 0x46, 0x72, 0x5f, 0xe0, 0xa9, 0x44, 0x9e, 0x8f, 0x55, 0x3a, 0xbf, 0xc6,
0x73, 0x97, 0xae, 0xf1, 0x7c, 0xc1, 0xee, 0x66, 0x9c, 0xd0, 0xea, 0xf6, 0x09, 0xed, 0x26, 0x2c,
0x28, 0x2f, 0x85, 0xf0, 0x88, 0xca, 0xe3, 0xb0, 0x05, 0xb2, 0xbb, 0xd0, 0x56, 0x87, 0x24, 0x7d,
0x0c, 0x14, 0xfe, 0xbe, 0x02, 0x8e, 0x7b, 0x40, 0x66, 0x89, 0x6b, 0x52, 0x67, 0x33, 0x80, 0xce,
0x54, 0x48, 0x25, 0xbd, 0x49, 0x28, 0xdd, 0xf1, 0x7c, 0x40, 0x07, 0x61, 0x3c, 0x53, 0xe5, 0x33,
0xdc, 0xbf, 0xe5, 0x40, 0x1b, 0xd7, 0xcd, 0x22, 0xcd, 0xcf, 0x80, 0x38, 0xe3, 0x1d, 0x29, 0xd3,
0x2a, 0xcb, 0x3e, 0x85, 0x06, 0xa5, 0xa3, 0x31, 0x0f, 0x25, 0x5d, 0x76, 0x6c, 0xba, 0xcc, 0x64,
0xca, 0xde, 0x8c, 0x97, 0x15, 0x36, 0xa8, 0xf2, 0x3f, 0x38, 0xd0, 0x94, 0xad, 0xfc, 0xd2, 0x96,
0x9e, 0xae, 0x11, 0x3f, 0x21, 0x14, 0xb0, 0x2c, 0x5c, 0xe2, 0x0e, 0x2c, 0x8d, 0xfc, 0x74, 0x12,
0xe3, 0x9e, 0x6e, 0x59, 0x79, 0xf2, 0x30, 0x6e, 0xd0, 0x24, 0x3e, 0x93, 0x5e, 0x1a, 0x0c, 0x7b,
0x2a, 0x57, 0x46, 0x2a, 0x94, 0x65, 0xa1, 0x14, 0x49, 0x52, 0xff, 0x94, 0xcb, 0xbd, 0x57, 0x24,
0xdc, 0x0e, 0xac, 0x1d, 0x66, 0x9e, 0x1b, 0x43, 0xc7, 0x76, 0xff, 0xe9, 0x02, 0xac, 0x17, 0xb2,
0x74, 0x5c, 0x95, 0x34, 0x5d, 0x0c, 0x83, 0xd1, 0x71, 0xa4, 0x0f, 0x28, 0x8e, 0x69, 0xd5, 0xb0,
0xb2, 0xd8, 0x29, 0x5c, 0x51, 0x4a, 0x06, 0xce, 0x69, 0xb6, 0x21, 0x56, 0x68, 0xa7, 0xfb, 0xd8,
0x5e, 0xc2, 0x7c, 0x83, 0x0a, 0x37, 0x19, 0xb9, 0xbc, 0x3e, 0x76, 0x06, 0x1d, 0xad, 0xcd, 0x48,
0x81, 0x6d, 0x68, 0x3c, 0xd8, 0xd6, 0x47, 0x97, 0xb4, 0x65, 0xa9, 0xe4, 0xde, 0xd4, 0xda, 0xd8,
0x05, 0x5c, 0x57, 0x79, 0x24, 0x91, 0x8b, 0xed, 0xd5, 0xde, 0x69, 0x6c, 0x74, 0xd8, 0xb0, 0x1b,
0xbd, 0xa4, 0x62, 0xf6, 0x63, 0x58, 0x7b, 0xed, 0x07, 0xa9, 0xea, 0x96, 0xa1, 0x5f, 0xcc, 0x52,
0x93, 0x9b, 0x97, 0x34, 0xf9, 0x52, 0x7c, 0x6c, 0x6d, 0x53, 0x53, 0x6a, 0xec, 0xfe, 0x49, 0x05,
0x16, 0xed, 0x7a, 0x90, 0x4c, 0x25, 0xef, 0x2b, 0x19, 0xa8, 0x34, 0xd2, 0x1c, 0x5c, 0x3c, 0xe7,
0x57, 0xca, 0xce, 0xf9, 0xe6, 0xc9, 0xba, 0x7a, 0x99, 0x89, 0xb0, 0xf6, 0x6e, 0x26, 0xc2, 0xd9,
0x52, 0x13, 0xe1, 0x74, 0x4b, 0xd2, 0xdc, 0x2f, 0x6b, 0x49, 0x9a, 0x7f, 0xab, 0x25, 0xa9, 0xfb,
0x7f, 0x1c, 0x60, 0x45, 0xea, 0x65, 0x8f, 0x85, 0x69, 0x23, 0xe4, 0x43, 0x29, 0xc4, 0xbe, 0xf9,
0x6e, 0x1c, 0xa0, 0x56, 0x4b, 0x7d, 0x8d, 0xac, 0x68, 0x06, 0x37, 0x99, 0x2a, 0xd6, 0x82, 0x57,
0x96, 0x95, 0x33, 0x93, 0xd6, 0x2e, 0x37, 0x93, 0xce, 0x5e, 0x6e, 0x26, 0x9d, 0xcb, 0x9b, 0x49,
0xbb, 0x7f, 0xd5, 0x81, 0x95, 0x12, 0x32, 0xfb, 0xf5, 0x0d, 0x1c, 0x09, 0xc3, 0x92, 0x3e, 0x15,
0x49, 0x18, 0x26, 0xd8, 0xfd, 0x8b, 0xb0, 0x60, 0xb1, 0xd6, 0xaf, 0xaf, 0xfd, 0xbc, 0x96, 0x28,
0x28, 0xdb, 0xc2, 0xba, 0xff, 0xb3, 0x02, 0xac, 0xc8, 0xde, 0xff, 0x5f, 0xfb, 0x50, 0x9c, 0xa7,
0x6a, 0xc9, 0x3c, 0xfd, 0x3f, 0xdd, 0x79, 0x3e, 0x82, 0x65, 0x19, 0xb1, 0x69, 0x18, 0xb3, 0x04,
0xc5, 0x14, 0x33, 0x50, 0x4f, 0xb6, 0x6d, 0xd4, 0x75, 0x2b, 0x42, 0xcd, 0xd8, 0x7e, 0x73, 0xa6,
0x6a, 0xb7, 0x0b, 0x1d, 0x39, 0x43, 0xbb, 0xe7, 0x3c, 0x4c, 0x8f, 0x26, 0xc7, 0x22, 0x64, 0x31,
0x88, 0x42, 0x52, 0x03, 0xcd, 0x4c, 0xa9, 0x50, 0x7c, 0x0b, 0x5a, 0xe6, 0xf6, 0x21, 0x97, 0x23,
0x67, 0xcf, 0x44, 0x55, 0xc2, 0x2c, 0xc5, 0x76, 0x60, 0x91, 0x84, 0xe4, 0x40, 0x7f, 0x57, 0xa1,
0xef, 0xde, 0x62, 0xa3, 0xd9, 0x9b, 0xf1, 0x72, 0xdf, 0xb0, 0xdf, 0x86, 0x45, 0xfb, 0x00, 0x28,
0xb5, 0x92, 0xb2, 0x13, 0x01, 0x7e, 0x6e, 0x17, 0x66, 0x5b, 0xd0, 0xce, 0x9f, 0x20, 0x65, 0x34,
0xcf, 0x94, 0x0a, 0x0a, 0xc5, 0xd9, 0xa7, 0xd2, 0x61, 0x39, 0x4b, 0xb6, 0x93, 0x9b, 0xf6, 0x67,
0xc6, 0x34, 0x6d, 0x88, 0x3f, 0x86, 0x0b, 0xf3, 0x77, 0x01, 0x32, 0x8c, 0xb5, 0xa1, 0xf5, 0xec,
0x70, 0xf7, 0xa0, 0xb7, 0xbd, 0xb7, 0x75, 0x70, 0xb0, 0xbb, 0xdf, 0x9e, 0x61, 0x0c, 0x16, 0xc9,
0xd4, 0xb7, 0xa3, 0x31, 0x07, 0x31, 0x69, 0x5c, 0x51, 0x58, 0x85, 0xad, 0x42, 0xfb, 0xc9, 0x41,
0x0e, 0xad, 0x3e, 0x6c, 0x68, 0xfe, 0x70, 0xd7, 0x60, 0x55, 0x44, 0xe4, 0x3e, 0x14, 0xe4, 0xa1,
0xb4, 0x93, 0x7f, 0xe8, 0xc0, 0x95, 0x5c, 0x46, 0x16, 0xf2, 0x25, 0x14, 0x10, 0x5b, 0x2b, 0xb1,
0x41, 0x72, 0x40, 0x28, 0x5d, 0x33, 0x27, 0x41, 0x8a, 0x19, 0x48, 0xf3, 0x86, 0x6e, 0x9a, 0xe3,
0xa4, 0xb2, 0x2c, 0x77, 0x5d, 0x47, 0xd6, 0xe4, 0x3a, 0x7e, 0x22, 0x22, 0x7d, 0xcd, 0x8c, 0xcc,
0x01, 0x6c, 0x77, 0x59, 0x25, 0xf1, 0x58, 0x61, 0x29, 0x3b, 0x76, 0x7f, 0x4b, 0xf3, 0xdc, 0x7f,
0x53, 0x05, 0xf6, 0xdd, 0x09, 0x8f, 0x2f, 0x28, 0xa6, 0x4b, 0x5b, 0x4e, 0xd7, 0xf3, 0x76, 0xc1,
0xb9, 0xf1, 0xe4, 0xf8, 0x73, 0x7e, 0xa1, 0x82, 0x25, 0x2b, 0xef, 0x14, 0x2c, 0x59, 0x16, 0xac,
0x58, 0xbb, 0x3c, 0x58, 0x71, 0xf6, 0xb2, 0x60, 0xc5, 0xaf, 0xc1, 0x42, 0x70, 0x1a, 0x46, 0x28,
0x0e, 0x50, 0x85, 0x48, 0x3a, 0x73, 0x37, 0xaa, 0x78, 0xf4, 0x96, 0xe0, 0x01, 0x62, 0xec, 0x41,
0x56, 0x88, 0x0f, 0x4e, 0x29, 0xb8, 0xd6, 0x14, 0x10, 0xbb, 0x83, 0x53, 0xbe, 0x1f, 0xf5, 0xfd,
0x34, 0x8a, 0xe9, 0x9c, 0xa6, 0x3e, 0x46, 0x3c, 0x61, 0x37, 0x61, 0x31, 0x89, 0x26, 0xa8, 0x54,
0xa9, 0x69, 0x10, 0x86, 0xa6, 0x96, 0x40, 0x0f, 0xc5, 0x64, 0x6c, 0xc0, 0xca, 0x24, 0xe1, 0xbd,
0x51, 0x90, 0x24, 0xb8, 0x71, 0xf6, 0xa3, 0x30, 0x8d, 0xa3, 0xa1, 0x34, 0x37, 0x2d, 0x4f, 0x12,
0xfe, 0x54, 0xe4, 0x6c, 0x8b, 0x0c, 0xf6, 0xad, 0xac, 0x4b, 0x63, 0x3f, 0x88, 0x93, 0x0e, 0x50,
0x97, 0xd4, 0x48, 0xb1, 0xdf, 0x87, 0x7e, 0x10, 0xeb, 0xbe, 0x60, 0x22, 0xc9, 0x05, 0x51, 0x36,
0x73, 0x41, 0x94, 0x32, 0xfe, 0x6e, 0x03, 0xea, 0xea, 0x73, 0x3c, 0x03, 0x9f, 0xc4, 0xd1, 0x48,
0x9d, 0x81, 0xf1, 0x37, 0x5b, 0x84, 0x4a, 0x1a, 0xc9, 0xf3, 0x6b, 0x25, 0x8d, 0xdc, 0xdf, 0x83,
0xa6, 0x31, 0x03, 0xec, 0x43, 0x71, 0x1c, 0x47, 0x5d, 0x4b, 0x1e, 0x9e, 0x85, 0x17, 0xa5, 0x21,
0xd1, 0x27, 0x03, 0xf6, 0x0d, 0x58, 0x1e, 0x04, 0x31, 0xa7, 0x38, 0xdf, 0x5e, 0xcc, 0xcf, 0x79,
0x9c, 0x28, 0x53, 0x43, 0x5b, 0x67, 0x78, 0x02, 0x77, 0x7b, 0xb0, 0x62, 0x51, 0x95, 0x66, 0xba,
0x39, 0x0a, 0x1a, 0x54, 0xd6, 0x4e, 0x3b, 0xa0, 0x50, 0xe6, 0xe1, 0x76, 0x25, 0xad, 0x24, 0xbd,
0x71, 0x1c, 0x1d, 0x53, 0x23, 0x8e, 0x67, 0x61, 0xee, 0x2f, 0x2a, 0x50, 0xdd, 0x8b, 0xc6, 0xa6,
0xef, 0xc7, 0x29, 0xfa, 0x7e, 0xa4, 0x5e, 0xd9, 0xd3, 0x6a, 0xa3, 0xdc, 0xfc, 0x2d, 0x90, 0xdd,
0x85, 0x45, 0xa4, 0xe0, 0x34, 0x42, 0x3d, 0xfa, 0xb5, 0x1f, 0x8b, 0x08, 0xc3, 0x2a, 0x91, 0x45,
0x2e, 0x87, 0xad, 0x42, 0x55, 0xab, 0x43, 0x54, 0x00, 0x93, 0x78, 0x88, 0x23, 0xff, 0xfa, 0x85,
0x34, 0x69, 0xca, 0x14, 0x0a, 0x04, 0xfb, 0x7b, 0xc1, 0x26, 0x62, 0x53, 0x2b, 0xcb, 0x42, 0x1d,
0x17, 0x19, 0x61, 0x94, 0xa9, 0x8c, 0x3a, 0x6d, 0x1a, 0xeb, 0xeb, 0xb6, 0xb1, 0xfe, 0x06, 0x34,
0xd3, 0xe1, 0x79, 0x6f, 0xec, 0x5f, 0x0c, 0x23, 0x7f, 0x20, 0x09, 0xd0, 0x84, 0xd8, 0x7d, 0x80,
0xd1, 0x78, 0xdc, 0xc3, 0x7d, 0x34, 0x1e, 0xd0, 0xc9, 0xbc, 0xb9, 0xd9, 0x96, 0xb3, 0xff, 0xf4,
0xf0, 0xd0, 0x23, 0xdc, 0x33, 0xca, 0xb8, 0x2f, 0xa1, 0xa1, 0x33, 0xcc, 0xd0, 0x54, 0x8a, 0xb0,
0x68, 0xda, 0xa1, 0xa9, 0x14, 0x50, 0x71, 0x0b, 0x16, 0x85, 0xf0, 0xd4, 0xe2, 0x40, 0x78, 0xc5,
0x73, 0xa8, 0xfb, 0xa7, 0x0e, 0xcc, 0xd2, 0x82, 0xa3, 0x36, 0x21, 0xf2, 0xb4, 0xaf, 0x8a, 0x16,
0x71, 0xc1, 0xcb, 0xc3, 0xcc, 0xb5, 0xc2, 0xe4, 0x2b, 0x7a, 0xf6, 0xcd, 0x50, 0xf9, 0x1b, 0xd0,
0xd0, 0x2d, 0x19, 0x2b, 0x98, 0x81, 0xec, 0x3a, 0xd4, 0xce, 0xa2, 0xb1, 0x3a, 0x70, 0x81, 0x72,
0x67, 0x47, 0x63, 0x8f, 0xf0, 0xac, 0x3f, 0x58, 0x9f, 0x18, 0x82, 0x50, 0x6a, 0xf3, 0x70, 0xc9,
0x58, 0xe7, 0x4a, 0xc7, 0xfa, 0x02, 0x96, 0x90, 0x2d, 0x0d, 0xdb, 0xfd, 0x74, 0xd1, 0xfa, 0x75,
0xdc, 0xa9, 0xfb, 0xc3, 0xc9, 0x80, 0x9b, 0xc7, 0x5e, 0xb2, 0xcd, 0x4a, 0x5c, 0x29, 0x7c, 0xee,
0x3f, 0x73, 0x04, 0xbb, 0x63, 0xbd, 0xec, 0x0e, 0xd4, 0x50, 0x0a, 0xe6, 0xac, 0x1c, 0x3a, 0xea,
0x05, 0xcb, 0x79, 0x54, 0x02, 0x57, 0x91, 0xac, 0xa7, 0x66, 0xed, 0xc2, 0x76, 0x9a, 0x9d, 0x19,
0xf5, 0xc8, 0x72, 0x47, 0xad, 0x1c, 0xca, 0x36, 0x0c, 0xd7, 0x53, 0xcd, 0x92, 0xac, 0x4a, 0x31,
0x18, 0x9c, 0x72, 0xc3, 0xe5, 0xf4, 0x47, 0x0e, 0x2c, 0x58, 0x7d, 0x42, 0xa2, 0xa5, 0x20, 0x72,
0x61, 0x34, 0x91, 0x2b, 0x6f, 0x42, 0x26, 0xc1, 0x57, 0x6c, 0x82, 0xd7, 0x2e, 0x8c, 0xaa, 0xe9,
0xc2, 0xb8, 0x0f, 0x8d, 0xec, 0x9e, 0x84, 0xdd, 0x29, 0x6c, 0x51, 0xc5, 0xff, 0x64, 0x85, 0x32,
0x23, 0xf9, 0xac, 0x61, 0x24, 0x77, 0x1f, 0x40, 0xd3, 0x28, 0x6f, 0x1a, 0xb9, 0x1d, 0xcb, 0xc8,
0xad, 0x83, 0xe3, 0x2a, 0x59, 0x70, 0x9c, 0xfb, 0xb3, 0x0a, 0x2c, 0x20, 0x79, 0x07, 0xe1, 0xe9,
0x61, 0x34, 0x0c, 0xfa, 0x17, 0x44, 0x56, 0x8a, 0x92, 0xe5, 0x2e, 0xa8, 0xc8, 0xdc, 0x86, 0x91,
0xfb, 0x75, 0x44, 0xb0, 0x10, 0x55, 0x3a, 0x8d, 0xb2, 0x0c, 0x25, 0xc1, 0xb1, 0x9f, 0x70, 0xe3,
0xe2, 0x84, 0x67, 0x83, 0x28, 0x71, 0x10, 0xa0, 0x50, 0xc7, 0x51, 0x30, 0x1c, 0x06, 0xa2, 0xac,
0x38, 0xbe, 0x95, 0x65, 0x61, 0x9b, 0x83, 0x20, 0xf1, 0x8f, 0x33, 0xf7, 0xa4, 0x4e, 0x93, 0xed,
0xcf, 0x7f, 0x63, 0xd8, 0xfe, 0x44, 0x6c, 0xb4, 0x0d, 0xe6, 0x17, 0x72, 0xbe, 0xb0, 0x90, 0xee,
0xbf, 0xae, 0x40, 0xd3, 0x20, 0x0b, 0x64, 0xe7, 0xd2, 0xed, 0xc6, 0x40, 0xa5, 0xdf, 0x3e, 0xb4,
0x0c, 0x02, 0x06, 0xc2, 0x6e, 0xda, 0xad, 0x92, 0x1f, 0x80, 0x18, 0xde, 0x22, 0xa1, 0x6b, 0xd0,
0x40, 0xd2, 0xff, 0x98, 0xac, 0x0f, 0xf2, 0x92, 0x92, 0x06, 0x54, 0xee, 0x26, 0xe5, 0xce, 0x66,
0xb9, 0x04, 0xbc, 0xd5, 0x93, 0xff, 0x29, 0xb4, 0x64, 0x35, 0xb4, 0xc6, 0x34, 0xe8, 0x8c, 0xf9,
0xac, 0xf5, 0xf7, 0xac, 0x92, 0xea, 0xcb, 0x4d, 0xf5, 0x65, 0xfd, 0xb2, 0x2f, 0x55, 0x49, 0xf7,
0xb1, 0x0e, 0x92, 0x78, 0x1c, 0xfb, 0xe3, 0x33, 0x25, 0x50, 0xee, 0xc3, 0x8a, 0x92, 0x1b, 0x93,
0xd0, 0x0f, 0xc3, 0x68, 0x12, 0xf6, 0xb9, 0x8a, 0xa3, 0x2b, 0xcb, 0x72, 0x07, 0x3a, 0xea, 0x9a,
0x2a, 0x62, 0x77, 0x61, 0x56, 0xe8, 0x51, 0x62, 0x57, 0x2e, 0x17, 0x21, 0xa2, 0x08, 0xbb, 0x03,
0xb3, 0x42, 0x9d, 0xaa, 0x4c, 0x65, 0x7a, 0x51, 0xc0, 0xdd, 0x80, 0x25, 0x0a, 0xf3, 0x36, 0x64,
0xdf, 0x7b, 0x65, 0xbb, 0xf5, 0x5c, 0x5f, 0x04, 0x83, 0xaf, 0x02, 0x3b, 0x10, 0x7c, 0x65, 0xba,
0x3a, 0xff, 0xb4, 0x0a, 0x4d, 0x03, 0x46, 0xf9, 0x44, 0xfe, 0xa9, 0xde, 0x20, 0xf0, 0x47, 0x3c,
0xe5, 0xb1, 0xe4, 0xa5, 0x1c, 0x8a, 0xe5, 0xfc, 0xf3, 0xd3, 0x5e, 0x34, 0x49, 0x7b, 0x03, 0x7e,
0x1a, 0x73, 0x2e, 0xd5, 0x88, 0x1c, 0x8a, 0xe5, 0x90, 0x9a, 0x8d, 0x72, 0xc2, 0xa3, 0x94, 0x43,
0x95, 0xe3, 0x52, 0xcc, 0x53, 0x2d, 0x73, 0x5c, 0x8a, 0x59, 0xc9, 0x4b, 0xd6, 0xd9, 0x12, 0xc9,
0xfa, 0x09, 0xac, 0x09, 0x19, 0x2a, 0xa5, 0x47, 0x2f, 0x47, 0x5c, 0x53, 0x72, 0xd9, 0x5d, 0x68,
0x63, 0x9f, 0x15, 0x6b, 0x24, 0xc1, 0x4f, 0x05, 0x8f, 0x39, 0x5e, 0x01, 0xc7, 0xb2, 0x64, 0x49,
0x37, 0xcb, 0x8a, 0xe8, 0x91, 0x02, 0x4e, 0x65, 0xfd, 0x37, 0x76, 0xd9, 0x86, 0x2c, 0x9b, 0xc3,
0xd9, 0xa7, 0xb0, 0x3e, 0xe2, 0x83, 0xc0, 0xb7, 0xab, 0xe8, 0x65, 0x9b, 0xfc, 0xb4, 0x6c, 0x6c,
0x05, 0x67, 0xe1, 0xa7, 0xd1, 0xe8, 0x38, 0x10, 0x1b, 0x9b, 0xb0, 0xf9, 0xd7, 0xbc, 0x02, 0xee,
0x2e, 0x40, 0xf3, 0x28, 0x8d, 0xc6, 0x6a, 0xe9, 0x17, 0xa1, 0x25, 0x92, 0x32, 0x72, 0xf2, 0x3d,
0xb8, 0x4a, 0xf4, 0xfa, 0x3c, 0x1a, 0x47, 0xc3, 0xe8, 0xf4, 0xc2, 0x3a, 0xb9, 0xff, 0x7b, 0x07,
0x56, 0xac, 0xdc, 0xec, 0xe8, 0x4e, 0x66, 0x46, 0x15, 0xee, 0x26, 0x48, 0x7c, 0xd9, 0xd8, 0x16,
0x44, 0x41, 0xe1, 0xd5, 0x79, 0x21, 0x23, 0xe0, 0xb6, 0xb2, 0x3b, 0x1c, 0xea, 0x43, 0x41, 0xef,
0x9d, 0x22, 0xbd, 0xcb, 0xef, 0xd5, 0xed, 0x0e, 0x55, 0xc5, 0x6f, 0xcb, 0x58, 0x9f, 0x81, 0x1c,
0x74, 0xd5, 0x8e, 0xcf, 0x30, 0x2d, 0x3d, 0xaa, 0x07, 0x7d, 0x0d, 0x26, 0xee, 0xcf, 0x1d, 0x80,
0xac, 0x77, 0x14, 0x21, 0xa2, 0xb7, 0x36, 0x71, 0x2f, 0xd9, 0xd8, 0xc6, 0x3e, 0x84, 0x96, 0x76,
0xf2, 0x67, 0xbb, 0x65, 0x53, 0x61, 0xa8, 0x5d, 0xdc, 0x86, 0xa5, 0xd3, 0x61, 0x74, 0x4c, 0x5a,
0x0c, 0x85, 0xe2, 0x26, 0x32, 0x7e, 0x74, 0x51, 0xc0, 0x8f, 0x24, 0x9a, 0x6d, 0xad, 0x35, 0x73,
0x6b, 0x2d, 0xdf, 0x28, 0x7f, 0x56, 0xd1, 0x9e, 0xd6, 0x6c, 0x26, 0xde, 0xca, 0xe5, 0x6c, 0xb3,
0x20, 0xd6, 0xa7, 0x38, 0x37, 0xe9, 0xe8, 0x71, 0x78, 0xa9, 0xe1, 0xf7, 0x01, 0x2c, 0xc6, 0x42,
0x66, 0x2a, 0x81, 0x5a, 0x7b, 0x8b, 0x40, 0x5d, 0x88, 0xad, 0x9d, 0xf9, 0xeb, 0xd0, 0xf6, 0x07,
0xe7, 0x3c, 0x4e, 0x03, 0x32, 0x84, 0x91, 0x1a, 0x25, 0x06, 0xb8, 0x64, 0xe0, 0xa4, 0xad, 0xdc,
0x86, 0x25, 0x19, 0xcd, 0xab, 0x4b, 0xca, 0x1b, 0x7a, 0x19, 0x8c, 0x05, 0xdd, 0x7f, 0xac, 0x1c,
0xbb, 0xf6, 0xea, 0xbe, 0x7d, 0x56, 0xcc, 0x11, 0x56, 0x72, 0x23, 0xfc, 0x9a, 0x74, 0xb4, 0x0e,
0x94, 0xc5, 0xad, 0x6a, 0x44, 0x8d, 0x0d, 0xa4, 0x63, 0xdc, 0x9e, 0xd6, 0xda, 0xbb, 0x4c, 0xab,
0xfb, 0x9f, 0x1c, 0x98, 0xdf, 0x8b, 0xc6, 0x7b, 0x38, 0xc5, 0xa8, 0xe3, 0x20, 0x9b, 0xe8, 0x50,
0x7a, 0x95, 0xbc, 0x24, 0xba, 0xae, 0x54, 0x2b, 0x59, 0xc8, 0x6b, 0x25, 0x7f, 0x1e, 0xde, 0x23,
0x9b, 0x6f, 0x1c, 0x8d, 0xa3, 0x18, 0xd9, 0xd5, 0x1f, 0x0a, 0x15, 0x24, 0x0a, 0xd3, 0x33, 0x25,
0x4e, 0xdf, 0x56, 0x84, 0x0c, 0x31, 0x78, 0x08, 0x16, 0x07, 0x2b, 0xa9, 0x45, 0x09, 0x29, 0x5b,
0xcc, 0x70, 0x7f, 0x0b, 0x1a, 0x74, 0xc2, 0xa0, 0xa1, 0x7d, 0x04, 0x8d, 0xb3, 0x68, 0xdc, 0x3b,
0x0b, 0xc2, 0x54, 0xb1, 0xff, 0x62, 0xa6, 0xfa, 0xef, 0xd1, 0xa4, 0xe8, 0x02, 0xee, 0x2f, 0xe6,
0x60, 0xfe, 0x49, 0x78, 0x1e, 0x05, 0x7d, 0x72, 0x26, 0x8f, 0xf8, 0x28, 0x52, 0x97, 0x0b, 0xf0,
0x37, 0x4e, 0x07, 0x45, 0xd2, 0x8e, 0x05, 0xf1, 0xb6, 0x44, 0xd0, 0x88, 0x84, 0xe8, 0x1a, 0x6e,
0x76, 0x39, 0x50, 0x30, 0x98, 0x81, 0xe0, 0x41, 0x31, 0x36, 0x2f, 0xf7, 0xc9, 0x54, 0x76, 0x79,
0x63, 0xd6, 0xb8, 0xbc, 0x81, 0xb5, 0x89, 0x4b, 0x67, 0x34, 0xb3, 0x22, 0x64, 0xd4, 0x40, 0xb0,
0x2f, 0x32, 0x26, 0x50, 0x04, 0x8d, 0x89, 0xbe, 0x48, 0x88, 0x0e, 0xbf, 0x31, 0x17, 0x36, 0x7d,
0xad, 0x98, 0xe1, 0xe1, 0xd7, 0x04, 0x51, 0x79, 0x13, 0x1f, 0x88, 0x32, 0x62, 0xb3, 0x30, 0x21,
0x54, 0x5f, 0xf3, 0x77, 0x53, 0xc5, 0xfd, 0xe2, 0x3c, 0x8c, 0xb2, 0x7e, 0xc0, 0xb5, 0x48, 0x16,
0xe3, 0x04, 0x71, 0x41, 0x32, 0x8f, 0x1b, 0x47, 0x66, 0x11, 0x14, 0xad, 0x8e, 0xcc, 0x48, 0x50,
0xfe, 0x70, 0x78, 0xec, 0xf7, 0x5f, 0x89, 0xa3, 0x66, 0x4b, 0xb8, 0x82, 0x2c, 0x90, 0x22, 0xfb,
0xb2, 0x55, 0xa7, 0xf0, 0x9b, 0x9a, 0x67, 0x42, 0x6c, 0x13, 0x9a, 0x64, 0x4e, 0x90, 0xeb, 0xbe,
0x48, 0xeb, 0xde, 0x36, 0xed, 0x0d, 0xb4, 0xf2, 0x66, 0x21, 0xd3, 0x09, 0xbe, 0x54, 0x08, 0x53,
0xf6, 0x07, 0x03, 0x19, 0x3f, 0xd0, 0x16, 0x17, 0x04, 0x35, 0x40, 0x06, 0x0b, 0x31, 0x61, 0xa2,
0xc0, 0x32, 0x15, 0xb0, 0x30, 0x76, 0x5d, 0x98, 0xc9, 0xc6, 0x7e, 0x30, 0xa0, 0x88, 0x1b, 0x71,
0x38, 0xd5, 0x18, 0xd6, 0xa1, 0x7e, 0xd3, 0xb6, 0xba, 0x42, 0xb3, 0x62, 0x61, 0x38, 0x37, 0x3a,
0x3d, 0xca, 0xe2, 0x9a, 0x6d, 0x90, 0x7d, 0x4c, 0x1e, 0xdc, 0x94, 0x53, 0xf0, 0xf2, 0xe2, 0xe6,
0x7b, 0x72, 0xcc, 0x92, 0xa8, 0xd5, 0xdf, 0x23, 0x2c, 0xe2, 0x89, 0x92, 0xa8, 0xd4, 0x09, 0x23,
0xfa, 0x9a, 0xa5, 0xd4, 0xc9, 0xa2, 0x64, 0x44, 0x17, 0x05, 0xdc, 0x2d, 0x68, 0x99, 0x15, 0xb0,
0x3a, 0xd4, 0x9e, 0x1d, 0xee, 0x1e, 0xb4, 0x67, 0x58, 0x13, 0xe6, 0x8f, 0x76, 0x9f, 0x3f, 0xdf,
0xdf, 0xdd, 0x69, 0x3b, 0xac, 0x05, 0x75, 0x1d, 0xb0, 0x59, 0xc1, 0xd4, 0xd6, 0xf6, 0xf6, 0xee,
0xe1, 0xf3, 0xdd, 0x9d, 0x76, 0xd5, 0xfd, 0xc3, 0x0a, 0x34, 0x8d, 0x9a, 0x2f, 0x31, 0xe1, 0x5c,
0x07, 0xa0, 0x93, 0x46, 0x16, 0xba, 0x51, 0xf3, 0x0c, 0x04, 0x25, 0xa7, 0x3e, 0x83, 0x57, 0xc5,
0x3d, 0x49, 0x95, 0xa6, 0xf9, 0xa2, 0x0b, 0x89, 0xa6, 0xaf, 0x62, 0xd6, 0xb3, 0x41, 0xa4, 0x25,
0x09, 0x50, 0xfc, 0xa0, 0xe0, 0x40, 0x13, 0xc2, 0xb5, 0x89, 0x79, 0x12, 0x0d, 0xcf, 0xb9, 0x28,
0x22, 0xf4, 0x35, 0x0b, 0xc3, 0xb6, 0xa4, 0x08, 0x32, 0x62, 0x7b, 0x67, 0x3d, 0x1b, 0x64, 0xdf,
0x54, 0x6b, 0x53, 0xa7, 0xb5, 0x59, 0x2f, 0x4e, 0xb4, 0xb9, 0x2e, 0x6e, 0x0a, 0x6c, 0x6b, 0x30,
0x90, 0xb9, 0xe6, 0xad, 0xcb, 0xd8, 0xbc, 0xe6, 0xab, 0x84, 0x48, 0x09, 0xa3, 0x56, 0xca, 0x19,
0xf5, 0xad, 0xe4, 0xec, 0x3e, 0x81, 0xe6, 0xa1, 0x71, 0x71, 0xd8, 0x45, 0x99, 0xa6, 0xae, 0x0c,
0x0b, 0x59, 0x28, 0x6c, 0x2f, 0x19, 0x6a, 0x74, 0xa9, 0x62, 0x76, 0xc9, 0xfd, 0x47, 0x8e, 0xb8,
0x8b, 0xa5, 0x87, 0x20, 0xda, 0x77, 0xa1, 0xa5, 0xad, 0xd1, 0x59, 0xf8, 0xba, 0x85, 0x61, 0x19,
0xea, 0x4e, 0x2f, 0x3a, 0x39, 0x49, 0xb8, 0x0a, 0x34, 0xb5, 0x30, 0xa5, 0x5c, 0xa2, 0xba, 0x1a,
0x88, 0x16, 0x12, 0x19, 0x70, 0x5a, 0xc0, 0x91, 0x50, 0xa4, 0xd5, 0x52, 0x85, 0xd8, 0xea, 0xb4,
0x8e, 0xb2, 0xcf, 0xcf, 0xf4, 0x5d, 0xa8, 0xeb, 0x7a, 0xed, 0x9d, 0x43, 0x95, 0xd4, 0xf9, 0xb8,
0x43, 0xd1, 0xc1, 0xd3, 0xea, 0xb4, 0xa0, 0xd7, 0x62, 0x06, 0xdb, 0x00, 0x76, 0x12, 0xc4, 0xf9,
0xe2, 0x82, 0x80, 0x4b, 0x72, 0xdc, 0x97, 0xb0, 0xa2, 0xf8, 0xce, 0xd0, 0x7a, 0xed, 0x85, 0x74,
0x2e, 0x93, 0x4b, 0x95, 0xa2, 0x5c, 0x72, 0xff, 0x55, 0x0d, 0xe6, 0xe5, 0x6a, 0x17, 0x2e, 0xa0,
0x8b, 0x7d, 0xcf, 0xc2, 0x58, 0xc7, 0xba, 0x66, 0x48, 0x84, 0x20, 0x77, 0xab, 0x3b, 0xf9, 0xfd,
0x26, 0xb3, 0xc1, 0xe5, 0xf6, 0x9c, 0x35, 0xa8, 0x8d, 0xfd, 0xf4, 0x8c, 0x4c, 0x34, 0x82, 0x96,
0x28, 0xad, 0x8c, 0xab, 0xb3, 0xb6, 0x71, 0xb5, 0xec, 0xda, 0xbd, 0x50, 0xbd, 0x8a, 0xd7, 0xee,
0xaf, 0x41, 0x43, 0xec, 0x8f, 0x99, 0xfd, 0x34, 0x03, 0x72, 0xfb, 0x69, 0xbd, 0xb0, 0x9f, 0xbe,
0xfb, 0x4e, 0xf7, 0x2d, 0x98, 0x13, 0x57, 0x4f, 0x64, 0x40, 0xf1, 0x35, 0xe5, 0x76, 0x14, 0xe5,
0xd4, 0x5f, 0x11, 0x95, 0xe4, 0xc9, 0xb2, 0xe6, 0xe5, 0xd5, 0xa6, 0x7d, 0x79, 0xd5, 0x34, 0xfb,
0xb6, 0x72, 0x66, 0xdf, 0xbb, 0xd0, 0xd6, 0xd3, 0x47, 0x06, 0xa3, 0x30, 0x91, 0xf1, 0xa6, 0x05,
0x3c, 0x13, 0xe4, 0x8b, 0x96, 0x20, 0x47, 0xc1, 0xb2, 0x95, 0xa6, 0x7c, 0x34, 0x4e, 0x95, 0x20,
0x7f, 0x04, 0x0b, 0x56, 0x27, 0x51, 0x7e, 0xcb, 0x30, 0xe7, 0xf6, 0x0c, 0x5b, 0x80, 0xc6, 0x93,
0x83, 0xde, 0xa3, 0xfd, 0x27, 0x8f, 0xf7, 0x9e, 0xb7, 0x1d, 0x4c, 0x1e, 0xbd, 0xd8, 0xde, 0xde,
0xdd, 0xdd, 0x21, 0x79, 0x0e, 0x30, 0xf7, 0x68, 0xeb, 0xc9, 0x3e, 0x49, 0xf3, 0xff, 0xed, 0x40,
0xd3, 0xa8, 0x9e, 0x7d, 0x5b, 0xcf, 0x8c, 0xb8, 0xdf, 0xf8, 0x7e, 0xb1, 0x0b, 0x1b, 0x4a, 0xce,
0x19, 0x53, 0xa3, 0x5f, 0x1a, 0xa8, 0x4c, 0x7d, 0x69, 0x00, 0x97, 0xc7, 0x17, 0x35, 0xe8, 0x79,
0x10, 0xa7, 0x81, 0x3c, 0x2c, 0x22, 0x4f, 0x32, 0xe1, 0x8c, 0x25, 0x85, 0x05, 0x2c, 0x0f, 0xbb,
0x9f, 0x00, 0x64, 0xbd, 0xb1, 0x87, 0x3d, 0x63, 0x0f, 0xdb, 0x31, 0x86, 0x5d, 0x71, 0x77, 0x84,
0xc0, 0x90, 0x53, 0xa8, 0xfd, 0x66, 0xdf, 0x04, 0xa6, 0x0c, 0x2e, 0x14, 0xe1, 0x35, 0x1e, 0xf2,
0x54, 0x5d, 0x3c, 0x58, 0x96, 0x39, 0x4f, 0x74, 0x86, 0xba, 0x3b, 0x93, 0xd5, 0x92, 0xc9, 0x1d,
0x49, 0x71, 0x79, 0xb9, 0x23, 0x8b, 0x7a, 0x3a, 0xdf, 0xed, 0x42, 0x67, 0x87, 0x63, 0x6d, 0x5b,
0xc3, 0x61, 0xae, 0x3b, 0x78, 0x62, 0x2e, 0xc9, 0x93, 0xc7, 0xe9, 0xef, 0xc2, 0x95, 0x2d, 0x71,
0xc7, 0xe0, 0xd7, 0x15, 0x82, 0xea, 0x76, 0x60, 0x2d, 0x5f, 0xa5, 0x6c, 0xec, 0x11, 0x2c, 0xef,
0xf0, 0xe3, 0xc9, 0xe9, 0x3e, 0x3f, 0xcf, 0x1a, 0x62, 0x50, 0x4b, 0xce, 0xa2, 0xd7, 0x72, 0x7e,
0xe8, 0x37, 0x7b, 0x1f, 0x60, 0x88, 0x65, 0x7a, 0xc9, 0x98, 0xf7, 0xd5, 0xfd, 0x51, 0x42, 0x8e,
0xc6, 0xbc, 0xef, 0x7e, 0x02, 0xcc, 0xac, 0x47, 0xce, 0x17, 0x2a, 0xb1, 0x93, 0xe3, 0x5e, 0x72,
0x91, 0xa4, 0x7c, 0xa4, 0x2e, 0xc6, 0x9a, 0x90, 0x7b, 0x1b, 0x5a, 0x87, 0xfe, 0x85, 0xc7, 0x7f,
0x22, 0x5f, 0xb6, 0x58, 0x87, 0xf9, 0xb1, 0x7f, 0x81, 0xfc, 0xac, 0xad, 0xf0, 0x94, 0xed, 0xfe,
0xaf, 0x0a, 0xcc, 0x89, 0x92, 0x58, 0xeb, 0x80, 0x27, 0x69, 0x10, 0x12, 0x8f, 0xa9, 0x5a, 0x0d,
0xa8, 0x20, 0x30, 0x2b, 0x25, 0x02, 0x53, 0x9a, 0x86, 0xd4, 0x3d, 0x3c, 0x49, 0xb2, 0x16, 0x86,
0x62, 0x2b, 0x8b, 0x25, 0x17, 0x94, 0x9a, 0x01, 0x39, 0xef, 0x52, 0xa6, 0x2a, 0x8b, 0xfe, 0xa9,
0xbd, 0x40, 0xca, 0x44, 0x13, 0x2a, 0x55, 0xc8, 0xe7, 0x85, 0xe8, 0x2c, 0x28, 0xe4, 0x05, 0xc5,
0xbb, 0xfe, 0x0e, 0x8a, 0xb7, 0xb0, 0x17, 0xbd, 0x4d, 0xf1, 0x86, 0x77, 0x50, 0xbc, 0x5d, 0x06,
0x6d, 0xba, 0xe4, 0x8f, 0x47, 0x3f, 0x45, 0xbb, 0x7f, 0xcf, 0x81, 0xb6, 0xa4, 0x22, 0x9d, 0xa7,
0xfc, 0x94, 0x6f, 0xbb, 0x0d, 0x76, 0x13, 0x16, 0xe8, 0xe0, 0xa9, 0xe5, 0xa9, 0xf4, 0xf9, 0x59,
0x20, 0x8e, 0x43, 0x45, 0x21, 0x8d, 0x82, 0xa1, 0x5c, 0x14, 0x13, 0x52, 0x22, 0x39, 0xf6, 0x65,
0x4c, 0xb4, 0xe3, 0xe9, 0xb4, 0xfb, 0x27, 0x0e, 0x2c, 0x1b, 0x1d, 0x96, 0x54, 0xf8, 0x00, 0x5a,
0xfa, 0x2d, 0x0d, 0xae, 0x35, 0x86, 0x75, 0x9b, 0x6d, 0xb2, 0xcf, 0xac, 0xc2, 0xb4, 0x98, 0xfe,
0x05, 0x75, 0x30, 0x99, 0x8c, 0xe4, 0x56, 0x6d, 0x42, 0x48, 0x48, 0xaf, 0x39, 0x7f, 0xa5, 0x8b,
0x08, 0x65, 0xc1, 0xc2, 0xc8, 0x60, 0x8f, 0x07, 0x66, 0x5d, 0xa8, 0x26, 0x0d, 0xf6, 0x26, 0xe8,
0xfe, 0xe5, 0x0a, 0xac, 0x08, 0x0b, 0x88, 0xb4, 0x3c, 0xe9, 0xeb, 0xcc, 0x73, 0xc2, 0x18, 0x24,
0x38, 0x72, 0x6f, 0xc6, 0x93, 0x69, 0xf6, 0xed, 0x77, 0xb4, 0xda, 0xe8, 0x40, 0xed, 0x29, 0x6b,
0x51, 0x2d, 0x5b, 0x8b, 0xb7, 0xcc, 0x74, 0x99, 0xef, 0x64, 0xb6, 0xdc, 0x77, 0xf2, 0x4e, 0xbe,
0x8a, 0x87, 0xf3, 0x30, 0x9b, 0xf4, 0xa3, 0x31, 0x77, 0xd7, 0x60, 0xd5, 0x9e, 0x02, 0x29, 0xa8,
0x7e, 0xee, 0x40, 0xe7, 0x91, 0xf0, 0xc8, 0x06, 0xe1, 0xe9, 0x5e, 0x90, 0xa4, 0x51, 0xac, 0xdf,
0x86, 0xb8, 0x0e, 0x90, 0xa4, 0x7e, 0x2c, 0x4f, 0x0a, 0x42, 0xdf, 0x32, 0x10, 0x1c, 0x09, 0x0f,
0x07, 0x22, 0x57, 0xac, 0xa0, 0x4e, 0x17, 0xf4, 0x59, 0x69, 0xc5, 0xb1, 0xb4, 0xc2, 0x5b, 0xe2,
0x7a, 0x03, 0x76, 0x99, 0x9f, 0x93, 0xf4, 0x17, 0xa6, 0x91, 0x1c, 0xea, 0xfe, 0x7e, 0x05, 0x96,
0xb2, 0x4e, 0x52, 0x08, 0x8e, 0x2d, 0x43, 0xa4, 0x2a, 0x98, 0xc9, 0x10, 0xe9, 0x71, 0xe9, 0x05,
0xa8, 0x1b, 0x1a, 0x86, 0x1c, 0x03, 0x65, 0x37, 0xa1, 0xa9, 0x52, 0xd1, 0x24, 0x35, 0x2e, 0x69,
0x9b, 0xb0, 0x08, 0x58, 0x46, 0xed, 0x54, 0x6a, 0xda, 0x32, 0x45, 0x17, 0xc6, 0x46, 0x29, 0x7d,
0x29, 0x66, 0x5e, 0x25, 0x59, 0x5b, 0xa8, 0x75, 0xe2, 0xbd, 0x1c, 0x52, 0xe9, 0x4c, 0x75, 0xa7,
0xae, 0x1f, 0xb7, 0xd1, 0x9c, 0x29, 0x6a, 0xcc, 0xa2, 0xcd, 0x6b, 0x9e, 0x09, 0xa9, 0xa3, 0x72,
0x34, 0x31, 0xdc, 0xcc, 0x35, 0xcf, 0xc2, 0xdc, 0xbf, 0xe9, 0xc0, 0xd5, 0x92, 0x65, 0x94, 0x9c,
0xba, 0x03, 0xcb, 0x27, 0x3a, 0x53, 0x4d, 0xb5, 0x60, 0xd7, 0x35, 0x15, 0x76, 0x62, 0x4f, 0xaf,
0x57, 0xfc, 0x40, 0x6b, 0xfc, 0x62, 0xf1, 0xac, 0xcb, 0x05, 0xc5, 0x0c, 0xf7, 0x10, 0xba, 0xbb,
0x6f, 0x90, 0xf1, 0xb7, 0xcd, 0x27, 0x05, 0x15, 0x65, 0x6d, 0x16, 0x04, 0xdb, 0xe5, 0xf6, 0xbb,
0x13, 0x58, 0xb0, 0xea, 0x62, 0xbf, 0xf9, 0xae, 0x95, 0x98, 0x3c, 0x7a, 0x43, 0xae, 0xba, 0x78,
0x13, 0x51, 0x5d, 0x71, 0x30, 0x20, 0xf7, 0x1c, 0x96, 0x9e, 0x4e, 0x86, 0x69, 0x90, 0xbd, 0x8f,
0xc8, 0xbe, 0x2d, 0x3f, 0xa2, 0x2a, 0xd4, 0xd4, 0x95, 0x36, 0x65, 0x96, 0xc3, 0x19, 0x1b, 0x61,
0x4d, 0xbd, 0x62, 0x8b, 0xc5, 0x0c, 0xf7, 0x2a, 0xac, 0x67, 0x4d, 0x8a, 0xb9, 0x53, 0x9b, 0xc3,
0x1f, 0x38, 0x22, 0x4e, 0xcf, 0x7e, 0xae, 0x91, 0x3d, 0x86, 0x95, 0x24, 0x08, 0x4f, 0x87, 0xdc,
0xac, 0x27, 0x91, 0x33, 0x71, 0xc5, 0xee, 0x9e, 0x7c, 0xd2, 0xd1, 0x2b, 0xfb, 0x02, 0x09, 0xa4,
0xbc, 0xa3, 0x19, 0x81, 0xe4, 0xa6, 0xa4, 0x6c, 0x00, 0xdf, 0x81, 0x45, 0xbb, 0x31, 0xf6, 0xa9,
0xbc, 0x99, 0x90, 0xf5, 0xcc, 0x74, 0xb8, 0xd9, 0x94, 0x61, 0x95, 0x74, 0x7f, 0xe6, 0x40, 0xc7,
0xe3, 0x48, 0xc6, 0xdc, 0x68, 0x54, 0x52, 0xcf, 0x83, 0x42, 0xb5, 0xd3, 0x07, 0xac, 0x6f, 0x3c,
0xa8, 0xb1, 0x6e, 0x4c, 0x5d, 0x94, 0xbd, 0x99, 0x92, 0x51, 0x3d, 0xac, 0xc3, 0x9c, 0x1c, 0xdf,
0x3a, 0x5c, 0x91, 0x5d, 0x52, 0xdd, 0xc9, 0x3c, 0x35, 0x56, 0xa3, 0x96, 0xa7, 0xa6, 0x0b, 0x1d,
0xf1, 0x04, 0x88, 0x39, 0x0e, 0xf9, 0xe1, 0x0e, 0xb0, 0xa7, 0x7e, 0xdf, 0x8f, 0xa3, 0x28, 0x3c,
0xe4, 0xb1, 0x0c, 0xac, 0x22, 0x05, 0x88, 0x1c, 0x19, 0x4a, 0x57, 0x13, 0x29, 0xf5, 0x6a, 0x45,
0x14, 0xaa, 0xd7, 0x41, 0x44, 0xca, 0xf5, 0x60, 0xe5, 0xa1, 0xff, 0x8a, 0xab, 0x9a, 0xb2, 0x59,
0x6a, 0x8e, 0x75, 0xa5, 0x6a, 0xee, 0xd5, 0xa5, 0xa3, 0x62, 0xb3, 0x9e, 0x59, 0xda, 0xdd, 0x84,
0x55, 0xbb, 0x4e, 0x29, 0x4a, 0xba, 0x50, 0x1f, 0x49, 0x4c, 0xf6, 0x4e, 0xa7, 0xef, 0x7e, 0x09,
0x4d, 0xe3, 0x59, 0x17, 0xb6, 0x0e, 0x2b, 0x2f, 0x9f, 0x3c, 0x3f, 0xd8, 0x3d, 0x3a, 0xea, 0x1d,
0xbe, 0x78, 0xf8, 0xf9, 0xee, 0xf7, 0x7b, 0x7b, 0x5b, 0x47, 0x7b, 0xed, 0x19, 0xb6, 0x06, 0xec,
0x60, 0xf7, 0xe8, 0xf9, 0xee, 0x8e, 0x85, 0x3b, 0xec, 0x3a, 0x74, 0x5f, 0x1c, 0xbc, 0x38, 0xda,
0xdd, 0xe9, 0x95, 0x7d, 0x57, 0x61, 0xef, 0xc3, 0x55, 0x99, 0x5f, 0xf2, 0x79, 0xf5, 0xee, 0x03,
0x68, 0xe7, 0x0d, 0x4b, 0x96, 0x29, 0xee, 0x6d, 0x36, 0xbb, 0xcd, 0x9f, 0x55, 0x61, 0x51, 0x44,
0x4e, 0x8a, 0x07, 0x4f, 0x79, 0xcc, 0x9e, 0xc2, 0xbc, 0x7c, 0x39, 0x97, 0x29, 0xd2, 0xb2, 0xdf,
0xea, 0xed, 0xae, 0xe5, 0x61, 0xb9, 0xac, 0x2b, 0x7f, 0xe5, 0x3f, 0xfe, 0xf7, 0xbf, 0x5d, 0x59,
0x60, 0xcd, 0x7b, 0xe7, 0x1f, 0xdf, 0x3b, 0xe5, 0x61, 0x82, 0x75, 0xfc, 0x2e, 0x40, 0xf6, 0x1e,
0x2c, 0xeb, 0x68, 0xc3, 0x4a, 0xee, 0xb1, 0xdc, 0xee, 0xd5, 0x92, 0x1c, 0x59, 0xef, 0x55, 0xaa,
0x77, 0xc5, 0x5d, 0xc4, 0x7a, 0x83, 0x30, 0x48, 0xc5, 0xdb, 0xb0, 0x9f, 0x39, 0x77, 0xd9, 0x00,
0x5a, 0xe6, 0x4b, 0xad, 0x4c, 0x39, 0xde, 0x4a, 0xde, 0x9a, 0xed, 0xbe, 0x57, 0x9a, 0xa7, 0x68,
0x99, 0xda, 0xb8, 0xe2, 0xb6, 0xb1, 0x8d, 0x09, 0x95, 0xc8, 0x5a, 0x19, 0x0a, 0x0e, 0xcf, 0x1e,
0x64, 0x65, 0xd7, 0x0c, 0xa6, 0x2b, 0x3c, 0x07, 0xdb, 0x7d, 0x7f, 0x4a, 0xae, 0x6c, 0xeb, 0x7d,
0x6a, 0x6b, 0xdd, 0x65, 0xd8, 0x56, 0x9f, 0xca, 0xa8, 0xe7, 0x60, 0x3f, 0x73, 0xee, 0x6e, 0xfe,
0xbb, 0xdb, 0xd0, 0xd0, 0x4e, 0x79, 0xf6, 0x63, 0x58, 0xb0, 0x42, 0x5b, 0x99, 0x1a, 0x46, 0x59,
0x24, 0x6c, 0xf7, 0x5a, 0x79, 0xa6, 0x6c, 0xf8, 0x3a, 0x35, 0xdc, 0x61, 0x6b, 0xd8, 0xb0, 0x8c,
0x0d, 0xbd, 0x47, 0x41, 0xda, 0xe2, 0x9e, 0xe7, 0x2b, 0x43, 0x92, 0x89, 0xc6, 0xae, 0xe5, 0x85,
0x8b, 0xd5, 0xda, 0xfb, 0x53, 0x72, 0x65, 0x73, 0xd7, 0xa8, 0xb9, 0x35, 0xb6, 0x6a, 0x36, 0xa7,
0x1d, 0xe5, 0x9c, 0x2e, 0x37, 0x9b, 0x6f, 0x95, 0xb2, 0xf7, 0x35, 0x61, 0x95, 0xbd, 0x61, 0xaa,
0x49, 0xa4, 0xf8, 0x90, 0xa9, 0xdb, 0xa1, 0xa6, 0x18, 0xa3, 0xe5, 0x33, 0x9f, 0x2a, 0x65, 0xc7,
0xd0, 0x34, 0x5e, 0x18, 0x63, 0x57, 0xa7, 0xbe, 0x86, 0xd6, 0xed, 0x96, 0x65, 0x95, 0x0d, 0xc5,
0xac, 0xff, 0x1e, 0x2a, 0x3a, 0x3f, 0x84, 0x86, 0x7e, 0xb3, 0x8a, 0xad, 0x1b, 0x6f, 0x88, 0x99,
0x6f, 0x6c, 0x75, 0x3b, 0xc5, 0x8c, 0x32, 0xe2, 0x33, 0x6b, 0x47, 0xe2, 0x7b, 0x09, 0x4d, 0xe3,
0x5d, 0x2a, 0x3d, 0x80, 0xe2, 0xdb, 0x57, 0x7a, 0x00, 0x25, 0xcf, 0x58, 0xb9, 0xcb, 0xd4, 0x44,
0x93, 0x35, 0x88, 0xbe, 0xd3, 0x37, 0x51, 0xc2, 0xf6, 0xe1, 0x8a, 0x94, 0xd8, 0xc7, 0xfc, 0xab,
0x2c, 0x43, 0xc9, 0xf3, 0xb0, 0xf7, 0x1d, 0xf6, 0x00, 0xea, 0xea, 0xf9, 0x31, 0xb6, 0x56, 0xfe,
0x8c, 0x5a, 0x77, 0xbd, 0x80, 0x4b, 0xf1, 0xfa, 0x7d, 0x80, 0xec, 0x11, 0x2c, 0x2d, 0x24, 0x0a,
0x8f, 0x6a, 0x69, 0x0a, 0x28, 0xbe, 0x98, 0xe5, 0xae, 0xd1, 0x00, 0xdb, 0x8c, 0x84, 0x44, 0xc8,
0x5f, 0xab, 0x77, 0x0c, 0x7e, 0x04, 0x4d, 0xe3, 0x1d, 0x2c, 0x3d, 0x7d, 0xc5, 0x37, 0xb4, 0xf4,
0xf4, 0x95, 0x3c, 0x9b, 0xe5, 0x76, 0xa9, 0xf6, 0x55, 0x77, 0x09, 0x6b, 0x4f, 0x82, 0xd3, 0x70,
0x24, 0x0a, 0xe0, 0x02, 0x9d, 0xc1, 0x82, 0xf5, 0xd8, 0x95, 0xe6, 0xd0, 0xb2, 0xa7, 0xb4, 0x34,
0x87, 0x96, 0xbe, 0x8f, 0xa5, 0xe8, 0xcc, 0x5d, 0xc6, 0x76, 0xce, 0xa9, 0x88, 0xd1, 0xd2, 0x0f,
0xa0, 0x69, 0x3c, 0x5c, 0xa5, 0xc7, 0x52, 0x7c, 0x23, 0x4b, 0x8f, 0xa5, 0xec, 0x9d, 0xab, 0x55,
0x6a, 0x63, 0xd1, 0x25, 0x52, 0xa0, 0x1b, 0xf9, 0x58, 0xf7, 0x8f, 0x61, 0xd1, 0x7e, 0xca, 0x4a,
0xf3, 0x7e, 0xe9, 0xa3, 0x58, 0x9a, 0xf7, 0xa7, 0xbc, 0x7f, 0x25, 0x49, 0xfa, 0xee, 0x8a, 0x6e,
0xe4, 0xde, 0x17, 0x32, 0xac, 0xef, 0x4b, 0xf6, 0x5d, 0x14, 0x70, 0xf2, 0x89, 0x04, 0xb6, 0x6e,
0x50, 0xad, 0xf9, 0x90, 0x82, 0xe6, 0x97, 0xc2, 0x6b, 0x0a, 0x36, 0x31, 0x8b, 0x37, 0x05, 0x68,
0xd7, 0xa2, 0xa7, 0x12, 0x8c, 0x5d, 0xcb, 0x7c, 0x4d, 0xc1, 0xd8, 0xb5, 0xac, 0x17, 0x15, 0xf2,
0xbb, 0x56, 0x1a, 0x60, 0x1d, 0x21, 0x2c, 0xe5, 0xae, 0xdf, 0x68, 0xae, 0x28, 0xbf, 0x21, 0xd9,
0xbd, 0xfe, 0xf6, 0x5b, 0x3b, 0xb6, 0x04, 0x51, 0x42, 0xf0, 0x9e, 0xba, 0x8f, 0xfa, 0x7b, 0xd0,
0x32, 0x9f, 0xd7, 0x61, 0x26, 0x2b, 0xe7, 0x5b, 0x7a, 0xaf, 0x34, 0xcf, 0x5e, 0x5c, 0xd6, 0x32,
0x9b, 0x61, 0xdf, 0x83, 0x35, 0xcd, 0xea, 0xe6, 0x8d, 0x8e, 0x84, 0x7d, 0x50, 0x72, 0xcf, 0xc3,
0xd4, 0xe3, 0xba, 0x57, 0xa7, 0x5e, 0x04, 0xb9, 0xef, 0x20, 0xd1, 0xd8, 0x6f, 0x96, 0x64, 0x1b,
0x46, 0xd9, 0x53, 0x2d, 0xd9, 0x86, 0x51, 0xfa, 0xd0, 0x89, 0x22, 0x1a, 0xb6, 0x62, 0xcd, 0x91,
0x88, 0x80, 0x60, 0x3f, 0x80, 0x25, 0xe3, 0xce, 0xdc, 0xd1, 0x45, 0xd8, 0xd7, 0x0c, 0x50, 0xbc,
0xd2, 0xdd, 0x2d, 0x3b, 0xa5, 0xb8, 0xeb, 0x54, 0xff, 0xb2, 0x6b, 0x4d, 0x0e, 0x12, 0xff, 0x36,
0x34, 0xcd, 0xfb, 0x78, 0x6f, 0xa9, 0x77, 0xdd, 0xc8, 0x32, 0x6f, 0x23, 0xdf, 0x77, 0xd8, 0xa1,
0x88, 0x84, 0xd3, 0xef, 0xa7, 0x46, 0x71, 0x7e, 0xfb, 0xb4, 0xdf, 0x55, 0xd5, 0x0b, 0x59, 0xf6,
0xa2, 0xee, 0x1d, 0xe7, 0xbe, 0xc3, 0xfe, 0xbe, 0x03, 0x2d, 0xeb, 0xbe, 0x9c, 0x15, 0x57, 0x94,
0xeb, 0x59, 0xc7, 0xcc, 0x33, 0xbb, 0xe6, 0x7a, 0x34, 0xec, 0xfd, 0xbb, 0xdf, 0xb1, 0xa6, 0xf5,
0x0b, 0xcb, 0xa0, 0xb6, 0x91, 0x7f, 0x44, 0xf5, 0xcb, 0x7c, 0x01, 0xf3, 0x22, 0xfd, 0x97, 0xf7,
0x1d, 0xf6, 0x47, 0x0e, 0x2c, 0xda, 0x66, 0x60, 0x3d, 0xdc, 0x52, 0x83, 0xb3, 0x5e, 0xfc, 0x29,
0xb6, 0xe3, 0x1f, 0x50, 0x2f, 0x9f, 0xdf, 0xf5, 0xac, 0x5e, 0xca, 0xf7, 0x71, 0x7e, 0xb5, 0xde,
0xb2, 0xcf, 0xc4, 0x23, 0xe2, 0xca, 0x03, 0xc6, 0x8a, 0xef, 0x4f, 0x6b, 0x82, 0x31, 0x5f, 0x8c,
0xa6, 0x45, 0xf8, 0x91, 0x78, 0x3c, 0x54, 0xb9, 0x51, 0x90, 0xee, 0xde, 0xf5, 0x7b, 0xf7, 0x26,
0x8d, 0xe9, 0xba, 0x7b, 0xd5, 0x1a, 0x53, 0x7e, 0x87, 0xdf, 0x12, 0xbd, 0x93, 0x8f, 0x3d, 0x67,
0x5b, 0x54, 0xe1, 0x01, 0xe8, 0xe9, 0x9d, 0x1c, 0x89, 0x4e, 0xca, 0xe2, 0x16, 0x73, 0xbc, 0x63,
0x35, 0xee, 0x5d, 0xea, 0xeb, 0x4d, 0xf7, 0x83, 0xa9, 0x7d, 0xbd, 0x47, 0xc6, 0x5c, 0xec, 0xf1,
0x21, 0x40, 0xe6, 0xb1, 0x66, 0x39, 0x6f, 0xa9, 0x16, 0x19, 0x45, 0xa7, 0xb6, 0xcd, 0x81, 0xca,
0xa9, 0x8a, 0x35, 0xfe, 0x50, 0x08, 0xc0, 0x27, 0xca, 0xcf, 0x6a, 0xaa, 0x39, 0xb6, 0x5b, 0xd9,
0x52, 0x73, 0xf2, 0xf5, 0x5b, 0xe2, 0x4f, 0x3b, 0x6d, 0x5f, 0xc0, 0xc2, 0x7e, 0x14, 0xbd, 0x9a,
0x8c, 0x75, 0xc8, 0x8f, 0xed, 0x67, 0xd9, 0xf3, 0x93, 0xb3, 0x6e, 0x6e, 0x14, 0xee, 0x0d, 0xaa,
0xaa, 0xcb, 0x3a, 0x46, 0x55, 0xf7, 0xbe, 0xc8, 0xbc, 0xe1, 0x5f, 0x32, 0x1f, 0x96, 0xb5, 0x54,
0xd5, 0x1d, 0xef, 0xda, 0xd5, 0x58, 0xb2, 0x34, 0xdf, 0x84, 0xa5, 0x8f, 0xab, 0xde, 0xde, 0x4b,
0x54, 0x9d, 0x24, 0x53, 0x5a, 0x3b, 0xbc, 0x4f, 0x57, 0x7e, 0xc8, 0x59, 0xb1, 0x92, 0x75, 0x5c,
0x7b, 0x39, 0xba, 0x0b, 0x16, 0x68, 0xef, 0x34, 0x63, 0xff, 0x22, 0xe6, 0x3f, 0xb9, 0xf7, 0x85,
0x74, 0x83, 0x7c, 0xa9, 0x76, 0x1a, 0xe5, 0x27, 0xb2, 0x76, 0x9a, 0x9c, 0x63, 0xc9, 0xda, 0x69,
0x0a, 0x8e, 0x25, 0x6b, 0xaa, 0x95, 0x9f, 0x8a, 0x0d, 0x61, 0xb9, 0xe0, 0x8b, 0xd2, 0x9b, 0xcc,
0x34, 0x0f, 0x56, 0xf7, 0xc6, 0xf4, 0x02, 0x76, 0x6b, 0x77, 0xed, 0xd6, 0x8e, 0x60, 0x61, 0x87,
0x8b, 0xc9, 0x12, 0x31, 0xce, 0xb9, 0x4b, 0x97, 0x66, 0x04, 0x75, 0x7e, 0x4b, 0xa0, 0x3c, 0x5b,
0x95, 0xa0, 0xe0, 0x62, 0xf6, 0x43, 0x68, 0x3e, 0xe6, 0xa9, 0x0a, 0x6a, 0xd6, 0xca, 0x6c, 0x2e,
0xca, 0xb9, 0x5b, 0x12, 0x13, 0x6d, 0xd3, 0x0c, 0xd5, 0x76, 0x8f, 0x0f, 0x4e, 0xb9, 0x10, 0x4e,
0xbd, 0x60, 0xf0, 0x25, 0xfb, 0x0b, 0x54, 0xb9, 0xbe, 0xd5, 0xb1, 0x66, 0x44, 0xa8, 0x9a, 0x95,
0x2f, 0xe5, 0xf0, 0xb2, 0x9a, 0xc3, 0x68, 0xc0, 0x0d, 0xa5, 0x2a, 0x84, 0xa6, 0x71, 0x19, 0x4b,
0x33, 0x50, 0xf1, 0xda, 0x9f, 0x66, 0xa0, 0x92, 0xbb, 0x5b, 0xee, 0x1d, 0x6a, 0xc7, 0x65, 0x37,
0xb2, 0x76, 0xc4, 0x7d, 0xad, 0xac, 0xa5, 0x7b, 0x5f, 0xf8, 0xa3, 0xf4, 0x4b, 0xf6, 0x92, 0xde,
0xab, 0x32, 0x83, 0xb6, 0x33, 0xed, 0x3c, 0x1f, 0xdf, 0xad, 0x27, 0xcb, 0xc8, 0xb2, 0x35, 0x76,
0xd1, 0x14, 0xe9, 0x5e, 0xdf, 0x06, 0x38, 0x4a, 0xa3, 0xf1, 0x8e, 0xcf, 0x47, 0x51, 0x98, 0xc9,
0xda, 0x2c, 0x64, 0x38, 0x93, 0x5f, 0x46, 0xdc, 0x30, 0x7b, 0x69, 0x1c, 0x67, 0xac, 0xb8, 0x77,
0x45, 0x5c, 0x53, 0xa3, 0x8a, 0xf5, 0x84, 0x94, 0x44, 0x16, 0xdf, 0x77, 0xd8, 0x16, 0x40, 0xe6,
0x8c, 0xd4, 0x87, 0x93, 0x82, 0x9f, 0x53, 0x8b, 0xbd, 0x12, 0xcf, 0xe5, 0x21, 0x34, 0x32, 0xef,
0xd6, 0x7a, 0x76, 0xe5, 0xd1, 0xf2, 0x85, 0xe9, 0x1d, 0xbc, 0xe0, 0x73, 0x72, 0xdb, 0x34, 0x55,
0xc0, 0xea, 0x38, 0x55, 0xe4, 0x48, 0x0a, 0x60, 0x45, 0x74, 0x50, 0x2b, 0x38, 0x14, 0xea, 0xaa,
0x46, 0x52, 0xe2, 0xf7, 0xd1, 0xdc, 0x5c, 0xea, 0x10, 0xb1, 0x6c, 0x2c, 0x48, 0xad, 0x22, 0xcc,
0x16, 0x45, 0xf3, 0x08, 0x96, 0x0b, 0x36, 0x76, 0xcd, 0xd2, 0xd3, 0x9c, 0x28, 0x9a, 0xa5, 0xa7,
0x9a, 0xe7, 0xdd, 0x2b, 0xd4, 0xe4, 0x92, 0x0b, 0x74, 0xa6, 0x7a, 0x1d, 0xa4, 0xfd, 0x33, 0x6c,
0xee, 0x0f, 0x1c, 0x58, 0x29, 0x31, 0xa1, 0xb3, 0x0f, 0xd5, 0xf1, 0x7c, 0xaa, 0x79, 0xbd, 0x5b,
0x6a, 0x61, 0x75, 0x8f, 0xa8, 0x9d, 0xa7, 0xec, 0x73, 0x6b, 0x63, 0x13, 0xc6, 0x4d, 0xc9, 0x99,
0x6f, 0x55, 0x2a, 0x4a, 0x35, 0x8a, 0x9f, 0xc0, 0xba, 0xe8, 0xc8, 0xd6, 0x70, 0x98, 0xb3, 0xfe,
0x5e, 0x2f, 0xfc, 0xa3, 0x21, 0xcb, 0xaa, 0xdd, 0x9d, 0xfe, 0x8f, 0x88, 0xa6, 0x28, 0xc0, 0xa2,
0xab, 0x6c, 0x02, 0xed, 0xbc, 0x45, 0x95, 0x4d, 0xaf, 0xab, 0xfb, 0x81, 0x75, 0xd0, 0x2c, 0xb1,
0xc2, 0xfe, 0x06, 0x35, 0xf6, 0x81, 0xdb, 0x2d, 0x9b, 0x17, 0x71, 0xf6, 0xc4, 0xf5, 0xf8, 0x4b,
0xda, 0xfc, 0x9b, 0x1b, 0xa7, 0x6a, 0x60, 0x9a, 0xbd, 0x5a, 0x1f, 0x75, 0xcb, 0xad, 0xc7, 0xb7,
0xa8, 0xf9, 0x1b, 0xee, 0x7b, 0x65, 0xcd, 0xc7, 0xe2, 0x13, 0x71, 0xe8, 0x5d, 0xcf, 0xf3, 0xb5,
0xea, 0xc1, 0x8d, 0xb2, 0xf5, 0x9e, 0x7a, 0x7a, 0xc9, 0xcd, 0xf5, 0x0c, 0xe9, 0x76, 0x2d, 0xd3,
0xdc, 0xab, 0xd9, 0xa7, 0xc4, 0xae, 0xac, 0xd9, 0xa7, 0xcc, 0x3e, 0x6c, 0xeb, 0x35, 0xca, 0x32,
0xfc, 0x99, 0x73, 0xf7, 0xe1, 0xed, 0x1f, 0xfc, 0xc6, 0x69, 0x90, 0x9e, 0x4d, 0x8e, 0x37, 0xfa,
0xd1, 0xe8, 0xde, 0x50, 0x99, 0xf5, 0xe4, 0xf5, 0x8f, 0x7b, 0xc3, 0x70, 0x70, 0x8f, 0xaa, 0x3d,
0x9e, 0xa3, 0xff, 0x8c, 0xf6, 0x9b, 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x2a, 0xd4, 0x19,
0x4b, 0x6d, 0x00, 0x00,
// 8832 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7d, 0x5f, 0x6c, 0x24, 0x49,
0x9a, 0x97, 0xb3, 0xaa, 0x6c, 0x57, 0x7d, 0x55, 0xb6, 0xcb, 0x61, 0xb7, 0x5d, 0x5d, 0xd3, 0xd3,
0xd3, 0x93, 0xdb, 0xd7, 0xdd, 0xdb, 0x3b, 0xeb, 0xee, 0xf1, 0xee, 0x0e, 0x73, 0x33, 0x1c, 0x87,
0xdb, 0x76, 0xb7, 0x7b, 0xc6, 0xed, 0xf6, 0xa6, 0xbb, 0xb7, 0xd9, 0xdd, 0x3b, 0xd5, 0xa6, 0xab,
0xc2, 0x76, 0x6e, 0x57, 0x65, 0xd6, 0x66, 0x66, 0xb9, 0xdb, 0x3b, 0x0c, 0x12, 0x08, 0x21, 0xc4,
0x0b, 0x5a, 0x10, 0x12, 0x20, 0xd0, 0x49, 0x7b, 0x48, 0xdc, 0x89, 0x07, 0x78, 0x41, 0x3a, 0xd0,
0xf1, 0x84, 0xd0, 0x49, 0x48, 0x88, 0x07, 0x1e, 0x90, 0x78, 0xe0, 0x84, 0x40, 0x42, 0x2b, 0xde,
0x10, 0xbc, 0xa3, 0xef, 0x8b, 0x3f, 0x19, 0x91, 0x99, 0xd5, 0xee, 0xd9, 0x5d, 0xee, 0xc9, 0x15,
0xbf, 0x88, 0x8c, 0xbf, 0xdf, 0xf7, 0xc5, 0x17, 0xdf, 0xf7, 0x45, 0x18, 0x1a, 0xf1, 0xb8, 0xbf,
0x31, 0x8e, 0xa3, 0x34, 0x62, 0xb3, 0xc3, 0x30, 0x1e, 0xf7, 0xbb, 0xd7, 0x4e, 0xa3, 0xe8, 0x74,
0xc8, 0xef, 0xf9, 0xe3, 0xe0, 0x9e, 0x1f, 0x86, 0x51, 0xea, 0xa7, 0x41, 0x14, 0x26, 0xa2, 0x90,
0xfb, 0x23, 0x58, 0x7c, 0xc4, 0xc3, 0x23, 0xce, 0x07, 0x1e, 0xff, 0xc9, 0x84, 0x27, 0x29, 0xfb,
0x06, 0x2c, 0xfb, 0xfc, 0xa7, 0x9c, 0x0f, 0x7a, 0x63, 0x3f, 0x49, 0xc6, 0x67, 0xb1, 0x9f, 0xf0,
0x8e, 0x73, 0xc3, 0xb9, 0xd3, 0xf2, 0xda, 0x22, 0xe3, 0x50, 0xe3, 0xec, 0x7d, 0x68, 0x25, 0x58,
0x94, 0x87, 0x69, 0x1c, 0x8d, 0x2f, 0x3a, 0x15, 0x2a, 0xd7, 0x44, 0x6c, 0x57, 0x40, 0xee, 0x10,
0x96, 0x74, 0x0b, 0xc9, 0x38, 0x0a, 0x13, 0xce, 0xee, 0xc3, 0x6a, 0x3f, 0x18, 0x9f, 0xf1, 0xb8,
0x47, 0x1f, 0x8f, 0x42, 0x3e, 0x8a, 0xc2, 0xa0, 0xdf, 0x71, 0x6e, 0x54, 0xef, 0x34, 0x3c, 0x26,
0xf2, 0xf0, 0x8b, 0x27, 0x32, 0x87, 0xdd, 0x86, 0x25, 0x1e, 0x0a, 0x9c, 0x0f, 0xe8, 0x2b, 0xd9,
0xd4, 0x62, 0x06, 0xe3, 0x07, 0xee, 0xdf, 0xac, 0xc0, 0xf2, 0xe3, 0x30, 0x48, 0x5f, 0xf8, 0xc3,
0x21, 0x4f, 0xd5, 0x98, 0x6e, 0xc3, 0xd2, 0x2b, 0x02, 0x68, 0x4c, 0xaf, 0xa2, 0x78, 0x20, 0x47,
0xb4, 0x28, 0xe0, 0x43, 0x89, 0x4e, 0xed, 0x59, 0x65, 0x6a, 0xcf, 0x4a, 0xa7, 0xab, 0x3a, 0x65,
0xba, 0x6e, 0xc3, 0x52, 0xcc, 0xfb, 0xd1, 0x39, 0x8f, 0x2f, 0x7a, 0xaf, 0x82, 0x70, 0x10, 0xbd,
0xea, 0xd4, 0x6e, 0x38, 0x77, 0x66, 0xbd, 0x45, 0x05, 0xbf, 0x20, 0x94, 0x3d, 0x80, 0xa5, 0xfe,
0x99, 0x1f, 0x86, 0x7c, 0xd8, 0x3b, 0xf6, 0xfb, 0x2f, 0x27, 0xe3, 0xa4, 0x33, 0x7b, 0xc3, 0xb9,
0xd3, 0xdc, 0xbc, 0xba, 0x41, 0xab, 0xba, 0xb1, 0x7d, 0xe6, 0x87, 0x0f, 0x28, 0xe7, 0x28, 0xf4,
0xc7, 0xc9, 0x59, 0x94, 0x7a, 0x8b, 0xf2, 0x0b, 0x01, 0x27, 0xee, 0x2a, 0x30, 0x73, 0x26, 0xc4,
0xdc, 0xbb, 0xff, 0xcc, 0x81, 0x95, 0xe7, 0xe1, 0x30, 0xea, 0xbf, 0xfc, 0x25, 0xa7, 0xa8, 0x64,
0x0c, 0x95, 0xb7, 0x1d, 0x43, 0xf5, 0xab, 0x8e, 0x61, 0x0d, 0x56, 0xed, 0xce, 0xca, 0x51, 0x70,
0xb8, 0x82, 0x5f, 0x9f, 0x72, 0xd5, 0x2d, 0x35, 0x8c, 0xaf, 0x43, 0xbb, 0x3f, 0x89, 0x63, 0x1e,
0x16, 0xc6, 0xb1, 0x24, 0x71, 0x3d, 0x90, 0xf7, 0xa1, 0x15, 0xf2, 0x57, 0x59, 0x31, 0x49, 0xbb,
0x21, 0x7f, 0xa5, 0x8a, 0xb8, 0x1d, 0x58, 0xcb, 0x37, 0x23, 0x3b, 0xf0, 0xdf, 0x1c, 0xa8, 0x3d,
0x4f, 0x5f, 0x47, 0x6c, 0x03, 0x6a, 0xe9, 0xc5, 0x58, 0x70, 0xc8, 0xe2, 0x26, 0x93, 0x43, 0xdb,
0x1a, 0x0c, 0x62, 0x9e, 0x24, 0xcf, 0x2e, 0xc6, 0xdc, 0x6b, 0xf9, 0x22, 0xd1, 0xc3, 0x72, 0xac,
0x03, 0xf3, 0x32, 0x4d, 0x0d, 0x36, 0x3c, 0x95, 0x64, 0xd7, 0x01, 0xfc, 0x51, 0x34, 0x09, 0xd3,
0x5e, 0xe2, 0xa7, 0x34, 0x55, 0x55, 0xcf, 0x40, 0xd8, 0x35, 0x68, 0x8c, 0x5f, 0xf6, 0x92, 0x7e,
0x1c, 0x8c, 0x53, 0x22, 0x9b, 0x86, 0x97, 0x01, 0xec, 0x1b, 0x50, 0x8f, 0x26, 0xe9, 0x38, 0x0a,
0xc2, 0x54, 0x92, 0xca, 0x92, 0xec, 0xcb, 0xd3, 0x49, 0x7a, 0x88, 0xb0, 0xa7, 0x0b, 0xb0, 0x9b,
0xb0, 0xd0, 0x8f, 0xc2, 0x93, 0x20, 0x1e, 0x09, 0x61, 0xd0, 0x99, 0xa3, 0xd6, 0x6c, 0xd0, 0xfd,
0x57, 0x15, 0x68, 0x3e, 0x8b, 0xfd, 0x30, 0xf1, 0xfb, 0x08, 0x60, 0xd7, 0xd3, 0xd7, 0xbd, 0x33,
0x3f, 0x39, 0xa3, 0xd1, 0x36, 0x3c, 0x95, 0x64, 0x6b, 0x30, 0x27, 0x3a, 0x4a, 0x63, 0xaa, 0x7a,
0x32, 0xc5, 0x3e, 0x80, 0xe5, 0x70, 0x32, 0xea, 0xd9, 0x6d, 0x55, 0x89, 0x5a, 0x8a, 0x19, 0x38,
0x01, 0xc7, 0xb8, 0xd6, 0xa2, 0x09, 0x31, 0x42, 0x03, 0x61, 0x2e, 0xb4, 0x64, 0x8a, 0x07, 0xa7,
0x67, 0x62, 0x98, 0xb3, 0x9e, 0x85, 0x61, 0x1d, 0x69, 0x30, 0xe2, 0xbd, 0x24, 0xf5, 0x47, 0x63,
0x39, 0x2c, 0x03, 0xa1, 0xfc, 0x28, 0xf5, 0x87, 0xbd, 0x13, 0xce, 0x93, 0xce, 0xbc, 0xcc, 0xd7,
0x08, 0xbb, 0x05, 0x8b, 0x03, 0x9e, 0xa4, 0x3d, 0xb9, 0x28, 0x3c, 0xe9, 0xd4, 0x89, 0xf5, 0x73,
0x28, 0xd6, 0x13, 0xfb, 0xaf, 0x7a, 0x38, 0x01, 0xfc, 0x75, 0xa7, 0x21, 0xfa, 0x9a, 0x21, 0x48,
0x39, 0x8f, 0x78, 0x6a, 0xcc, 0x5e, 0x22, 0x29, 0xd4, 0xdd, 0x07, 0x66, 0xc0, 0x3b, 0x3c, 0xf5,
0x83, 0x61, 0xc2, 0x3e, 0x82, 0x56, 0x6a, 0x14, 0x26, 0x51, 0xd8, 0xd4, 0xe4, 0x64, 0x7c, 0xe0,
0x59, 0xe5, 0xdc, 0x33, 0xa8, 0x3f, 0xe4, 0x7c, 0x3f, 0x18, 0x05, 0x29, 0x5b, 0x83, 0xd9, 0x93,
0xe0, 0x35, 0x17, 0x04, 0x5f, 0xdd, 0x9b, 0xf1, 0x44, 0x92, 0xbd, 0x07, 0x40, 0x3f, 0x7a, 0x23,
0x4d, 0x58, 0x7b, 0x33, 0x5e, 0x83, 0xb0, 0x27, 0x48, 0x59, 0x5d, 0x98, 0x1f, 0xf3, 0xb8, 0xcf,
0xd5, 0xfa, 0xed, 0xcd, 0x78, 0x0a, 0x78, 0x30, 0x0f, 0xb3, 0x43, 0xac, 0xdd, 0xfd, 0xa3, 0x1a,
0x34, 0x8f, 0x78, 0xa8, 0x39, 0x8d, 0x41, 0x0d, 0xe7, 0x44, 0x72, 0x17, 0xfd, 0x66, 0x5f, 0x83,
0x26, 0xcd, 0x53, 0x92, 0xc6, 0x41, 0x78, 0x2a, 0x08, 0xfc, 0x41, 0xa5, 0xe3, 0x78, 0x80, 0xf0,
0x11, 0xa1, 0xac, 0x0d, 0x55, 0x7f, 0xa4, 0x08, 0x1c, 0x7f, 0xb2, 0xab, 0x50, 0xf7, 0x47, 0xa9,
0xe8, 0x5e, 0x8b, 0xe0, 0x79, 0x7f, 0x94, 0x52, 0xd7, 0xde, 0x87, 0xd6, 0xd8, 0xbf, 0x18, 0x21,
0x3f, 0x6b, 0xaa, 0x68, 0x79, 0x4d, 0x89, 0xed, 0x21, 0x59, 0x6c, 0xc2, 0x8a, 0x59, 0x44, 0x35,
0x3e, 0xab, 0x1b, 0x5f, 0x36, 0x4a, 0xcb, 0x3e, 0xdc, 0x86, 0x25, 0xf5, 0x4d, 0x2c, 0xc6, 0x43,
0xb4, 0xd2, 0xf0, 0x16, 0x25, 0xac, 0x46, 0x79, 0x07, 0xda, 0x27, 0x41, 0xe8, 0x0f, 0x7b, 0xfd,
0x61, 0x7a, 0xde, 0x1b, 0xf0, 0x61, 0xea, 0x13, 0xd5, 0xcc, 0x7a, 0x8b, 0x84, 0x6f, 0x0f, 0xd3,
0xf3, 0x1d, 0x44, 0xd9, 0x07, 0xd0, 0x38, 0xe1, 0xbc, 0x47, 0x93, 0xd5, 0xa9, 0x5b, 0x1c, 0xa8,
0x56, 0xc8, 0xab, 0x9f, 0xa8, 0xb5, 0xfa, 0x00, 0xda, 0xd1, 0x24, 0x3d, 0x8d, 0x82, 0xf0, 0xb4,
0x87, 0x32, 0xaf, 0x17, 0x0c, 0x88, 0x8a, 0x6a, 0x0f, 0x2a, 0xf7, 0x1d, 0x6f, 0x51, 0xe5, 0xa1,
0xf4, 0x79, 0x3c, 0x60, 0xb7, 0x60, 0x69, 0xe8, 0x27, 0x69, 0xef, 0x2c, 0x1a, 0xf7, 0xc6, 0x93,
0xe3, 0x97, 0xfc, 0xa2, 0xb3, 0x40, 0x13, 0xb1, 0x80, 0xf0, 0x5e, 0x34, 0x3e, 0x24, 0x90, 0xbd,
0x0b, 0x40, 0xfd, 0x14, 0x9d, 0x80, 0x1b, 0xce, 0x9d, 0x05, 0xaf, 0x81, 0x88, 0x68, 0xf4, 0x13,
0xa8, 0xd3, 0xf2, 0xa4, 0xc3, 0xf3, 0x4e, 0x93, 0x08, 0xec, 0x3d, 0xd9, 0x43, 0x63, 0x61, 0x37,
0x76, 0x78, 0x92, 0x3e, 0x1b, 0x9e, 0xe3, 0xfe, 0x7d, 0xe1, 0xcd, 0x0f, 0x44, 0xaa, 0xfb, 0x09,
0xb4, 0xcc, 0x0c, 0x5c, 0x45, 0xec, 0x06, 0xae, 0x7e, 0xcd, 0xc3, 0x9f, 0x6c, 0x15, 0x66, 0xcf,
0xfd, 0xe1, 0x84, 0x4b, 0x41, 0x2a, 0x12, 0x9f, 0x54, 0x3e, 0x76, 0xdc, 0x3f, 0x72, 0xa0, 0x25,
0x5a, 0x90, 0x0a, 0xc0, 0x4d, 0x58, 0x50, 0xd3, 0xcf, 0xe3, 0x38, 0x8a, 0xa5, 0x3c, 0xb1, 0x41,
0x76, 0x17, 0xda, 0x0a, 0x18, 0xc7, 0x3c, 0x18, 0xf9, 0xa7, 0xaa, 0xee, 0x02, 0xce, 0x36, 0xb3,
0x1a, 0xe3, 0x68, 0x92, 0x72, 0xb9, 0xd5, 0xb4, 0xe4, 0xf8, 0x3c, 0xc4, 0x3c, 0xbb, 0x08, 0xca,
0x93, 0x12, 0xda, 0xb2, 0x30, 0xf7, 0xef, 0x39, 0xc0, 0xb0, 0xeb, 0xcf, 0x22, 0x51, 0x85, 0x24,
0x8b, 0x3c, 0x59, 0x3a, 0x6f, 0x4d, 0x96, 0x95, 0x37, 0x91, 0xa5, 0x0b, 0xb3, 0xa2, 0xf7, 0xb5,
0x92, 0xde, 0x8b, 0xac, 0xcf, 0x6a, 0xf5, 0x6a, 0xbb, 0xe6, 0xfe, 0x97, 0x2a, 0xac, 0x6e, 0x8b,
0xbd, 0x72, 0xab, 0xdf, 0xe7, 0x63, 0x4d, 0xb0, 0xef, 0x41, 0x33, 0x8c, 0x06, 0x5c, 0x91, 0x89,
0xe8, 0x18, 0x20, 0x64, 0xd0, 0xc8, 0x99, 0x1f, 0x84, 0xa2, 0xe3, 0x62, 0x3e, 0x1b, 0x84, 0x50,
0xb7, 0x6f, 0xc1, 0xd2, 0x98, 0x87, 0x03, 0x93, 0x2e, 0x85, 0x36, 0xb3, 0x20, 0x61, 0x49, 0x92,
0xef, 0x41, 0xf3, 0x64, 0x22, 0xca, 0x21, 0x37, 0xd7, 0x88, 0x0e, 0x40, 0x42, 0x5b, 0x82, 0xa9,
0xc7, 0x93, 0xe4, 0x8c, 0x72, 0x67, 0x29, 0x77, 0x1e, 0xd3, 0x98, 0xf5, 0x2e, 0xc0, 0x60, 0x92,
0xa4, 0x92, 0x4c, 0xe7, 0x28, 0xb3, 0x81, 0x88, 0x20, 0xd3, 0x6f, 0xc2, 0xca, 0xc8, 0x7f, 0xdd,
0x23, 0xfa, 0xe9, 0x05, 0x61, 0xef, 0x64, 0x48, 0xe2, 0x7e, 0x9e, 0xca, 0xb5, 0x47, 0xfe, 0xeb,
0xef, 0x61, 0xce, 0xe3, 0xf0, 0x21, 0xe1, 0xc8, 0xcb, 0x4a, 0xcf, 0x88, 0x79, 0xc2, 0xe3, 0x73,
0x4e, 0xec, 0x57, 0xd3, 0xca, 0x84, 0x27, 0x50, 0xec, 0xd1, 0x08, 0xc7, 0x9d, 0x0e, 0xfb, 0x82,
0xd7, 0xbc, 0xf9, 0x51, 0x10, 0xee, 0xa5, 0xc3, 0x3e, 0xbb, 0x06, 0x80, 0xcc, 0x3b, 0xe6, 0x71,
0xef, 0xe5, 0x2b, 0x62, 0x9c, 0x1a, 0x31, 0xeb, 0x21, 0x8f, 0x3f, 0x7f, 0xc5, 0xde, 0x81, 0x46,
0x3f, 0x21, 0xee, 0xf7, 0x2f, 0x3a, 0x4d, 0xe2, 0xaa, 0x7a, 0x3f, 0x41, 0xbe, 0xf7, 0x2f, 0xd8,
0x07, 0xc0, 0xb0, 0xb7, 0x3e, 0xad, 0x02, 0x1f, 0x50, 0xf5, 0x09, 0x89, 0xb1, 0x05, 0xea, 0xec,
0x96, 0xcc, 0xc0, 0x76, 0x12, 0xf6, 0x35, 0x58, 0x50, 0x9d, 0x3d, 0x19, 0xfa, 0xa7, 0x09, 0xf1,
0xf1, 0x82, 0xd7, 0x92, 0xe0, 0x43, 0xc4, 0xdc, 0x17, 0x42, 0xbb, 0x31, 0xd6, 0x56, 0xf2, 0x0d,
0xee, 0xb3, 0x84, 0xd0, 0xba, 0xd6, 0x3d, 0x99, 0x2a, 0x5b, 0xb4, 0x4a, 0xc9, 0xa2, 0xb9, 0x3f,
0x77, 0xa0, 0x25, 0x6b, 0x26, 0x95, 0x80, 0xdd, 0x07, 0xa6, 0x56, 0x31, 0x7d, 0x1d, 0x0c, 0x7a,
0xc7, 0x17, 0x29, 0x4f, 0x04, 0xd1, 0xec, 0xcd, 0x78, 0x25, 0x79, 0x28, 0xb8, 0x2c, 0x34, 0x49,
0x63, 0x41, 0xd3, 0x7b, 0x33, 0x5e, 0x21, 0x07, 0x59, 0x0c, 0x95, 0x8e, 0x49, 0xda, 0x0b, 0xc2,
0x01, 0x7f, 0x4d, 0xa4, 0xb4, 0xe0, 0x59, 0xd8, 0x83, 0x45, 0x68, 0x99, 0xdf, 0xb9, 0x3f, 0x86,
0xba, 0x52, 0x59, 0x68, 0xbb, 0xce, 0xf5, 0xcb, 0x33, 0x10, 0xd6, 0x85, 0xba, 0xdd, 0x0b, 0xaf,
0xfe, 0x55, 0xda, 0x76, 0xff, 0x02, 0xb4, 0xf7, 0x91, 0x88, 0x42, 0x24, 0x5a, 0xa9, 0x87, 0xad,
0xc1, 0x9c, 0xc1, 0x3c, 0x0d, 0x4f, 0xa6, 0x70, 0xc3, 0x3b, 0x8b, 0x92, 0x54, 0xb6, 0x43, 0xbf,
0xdd, 0x3f, 0x71, 0x80, 0xed, 0x26, 0x69, 0x30, 0xf2, 0x53, 0xfe, 0x90, 0x6b, 0xf1, 0xf0, 0x14,
0x5a, 0x58, 0xdb, 0xb3, 0x68, 0x4b, 0x68, 0x45, 0x62, 0x37, 0xff, 0x86, 0x64, 0xe7, 0xe2, 0x07,
0x1b, 0x66, 0x69, 0x21, 0x78, 0xad, 0x0a, 0x90, 0xdb, 0x52, 0x3f, 0x3e, 0xe5, 0x29, 0xa9, 0x4c,
0x52, 0xe1, 0x06, 0x01, 0x6d, 0x47, 0xe1, 0x49, 0xf7, 0xb7, 0x61, 0xb9, 0x50, 0x87, 0x29, 0xa3,
0x1b, 0x25, 0x32, 0xba, 0x6a, 0xca, 0xe8, 0x3e, 0xac, 0x58, 0xfd, 0x92, 0x14, 0xd7, 0x81, 0x79,
0x64, 0x0c, 0xdc, 0x99, 0x1d, 0xb1, 0x33, 0xcb, 0x24, 0xdb, 0x84, 0xd5, 0x13, 0xce, 0x63, 0x3f,
0xa5, 0x24, 0xb1, 0x0e, 0xae, 0x89, 0xac, 0xb9, 0x34, 0xcf, 0xfd, 0xef, 0x0e, 0x2c, 0xa1, 0x34,
0x7d, 0xe2, 0x87, 0x17, 0x6a, 0xae, 0xf6, 0x4b, 0xe7, 0xea, 0x8e, 0xb1, 0x31, 0x19, 0xa5, 0xbf,
0xea, 0x44, 0x55, 0xf3, 0x13, 0xc5, 0x6e, 0x40, 0xcb, 0xea, 0xee, 0xac, 0x50, 0x01, 0x13, 0x3f,
0x3d, 0xe4, 0xf1, 0x83, 0x8b, 0x94, 0xff, 0xea, 0x53, 0x79, 0x0b, 0xda, 0x59, 0xb7, 0xe5, 0x3c,
0x32, 0xa8, 0x21, 0x61, 0xca, 0x0a, 0xe8, 0xb7, 0xfb, 0x8f, 0x1c, 0x51, 0x70, 0x3b, 0x0a, 0xb4,
0x7a, 0x88, 0x05, 0x51, 0xcb, 0x54, 0x05, 0xf1, 0xf7, 0x54, 0xf5, 0xfa, 0x57, 0x1f, 0x2c, 0xca,
0xc4, 0x84, 0x87, 0x83, 0x9e, 0x3f, 0x1c, 0x92, 0x20, 0xae, 0x7b, 0xf3, 0x98, 0xde, 0x1a, 0x0e,
0xdd, 0xdb, 0xb0, 0x6c, 0xf4, 0xee, 0x0d, 0xe3, 0x38, 0x00, 0xb6, 0x1f, 0x24, 0xe9, 0xf3, 0x30,
0x19, 0x1b, 0x9a, 0xd3, 0x3b, 0xd0, 0x40, 0x69, 0x8b, 0x3d, 0x13, 0x9c, 0x3b, 0xeb, 0xa1, 0xf8,
0xc5, 0x7e, 0x25, 0x94, 0xe9, 0xbf, 0x96, 0x99, 0x15, 0x99, 0xe9, 0xbf, 0xa6, 0x4c, 0xf7, 0x63,
0x58, 0xb1, 0xea, 0x93, 0x4d, 0xbf, 0x0f, 0xb3, 0x93, 0xf4, 0x75, 0xa4, 0x74, 0xe3, 0xa6, 0xa4,
0x10, 0x3c, 0x85, 0x79, 0x22, 0xc7, 0xfd, 0x14, 0x96, 0x0f, 0xf8, 0x2b, 0xc9, 0xc8, 0xaa, 0x23,
0xb7, 0x2e, 0x3d, 0xa1, 0x51, 0xbe, 0xbb, 0x01, 0xcc, 0xfc, 0x38, 0x63, 0x00, 0x75, 0x5e, 0x73,
0xac, 0xf3, 0x9a, 0x7b, 0x0b, 0xd8, 0x51, 0x70, 0x1a, 0x3e, 0xe1, 0x49, 0xe2, 0x9f, 0x6a, 0xd6,
0x6f, 0x43, 0x75, 0x94, 0x9c, 0x4a, 0x51, 0x85, 0x3f, 0xdd, 0x6f, 0xc1, 0x8a, 0x55, 0x4e, 0x56,
0x7c, 0x0d, 0x1a, 0x49, 0x70, 0x1a, 0xfa, 0xe9, 0x24, 0xe6, 0xb2, 0xea, 0x0c, 0x70, 0x1f, 0xc2,
0xea, 0xf7, 0x78, 0x1c, 0x9c, 0x5c, 0x5c, 0x56, 0xbd, 0x5d, 0x4f, 0x25, 0x5f, 0xcf, 0x2e, 0x5c,
0xc9, 0xd5, 0x23, 0x9b, 0x17, 0xe4, 0x2b, 0x57, 0xb2, 0xee, 0x89, 0x84, 0x21, 0xfb, 0x2a, 0xa6,
0xec, 0x73, 0x9f, 0x03, 0xdb, 0x8e, 0xc2, 0x90, 0xf7, 0xd3, 0x43, 0xce, 0xe3, 0xcc, 0x54, 0x94,
0xd1, 0x6a, 0x73, 0x73, 0x5d, 0xce, 0x6c, 0x5e, 0xa0, 0x4a, 0x22, 0x66, 0x50, 0x1b, 0xf3, 0x78,
0x44, 0x15, 0xd7, 0x3d, 0xfa, 0xed, 0x5e, 0x81, 0x15, 0xab, 0x5a, 0x79, 0xb8, 0xfe, 0x10, 0xae,
0xec, 0x04, 0x49, 0xbf, 0xd8, 0x60, 0x07, 0xe6, 0xc7, 0x93, 0xe3, 0x5e, 0xc6, 0x89, 0x2a, 0x89,
0xe7, 0xad, 0xfc, 0x27, 0xb2, 0xb2, 0xbf, 0xe1, 0x40, 0x6d, 0xef, 0xd9, 0xfe, 0x36, 0xee, 0x15,
0x41, 0xd8, 0x8f, 0x46, 0xa8, 0x85, 0x89, 0x41, 0xeb, 0xf4, 0x54, 0x0e, 0xbb, 0x06, 0x0d, 0x52,
0xde, 0xf0, 0x88, 0x29, 0xf5, 0xa0, 0x0c, 0xc0, 0xe3, 0x2d, 0x7f, 0x3d, 0x0e, 0x62, 0x3a, 0xbf,
0xaa, 0x53, 0x69, 0x8d, 0xb6, 0x99, 0x62, 0x86, 0xfb, 0xf3, 0x79, 0x98, 0x97, 0x9b, 0xaf, 0xd8,
0xc8, 0xd3, 0xe0, 0x9c, 0x67, 0x1b, 0x39, 0xa6, 0x50, 0x31, 0x8e, 0xf9, 0x28, 0x4a, 0xb5, 0xfe,
0x26, 0x96, 0xc1, 0x06, 0xe9, 0xf8, 0x2e, 0x95, 0x08, 0x71, 0xe0, 0xaf, 0x8a, 0x52, 0x16, 0xc8,
0xae, 0xc1, 0xbc, 0x52, 0x06, 0x6a, 0xfa, 0x64, 0xa1, 0x20, 0x9c, 0x8d, 0xbe, 0x3f, 0xf6, 0xfb,
0x41, 0x7a, 0x21, 0xc5, 0x82, 0x4e, 0x63, 0xfd, 0xc3, 0xa8, 0xef, 0x0f, 0x7b, 0xc7, 0xfe, 0xd0,
0x0f, 0xfb, 0x5c, 0x99, 0x07, 0x2c, 0x10, 0x8f, 0xca, 0xb2, 0x5b, 0xaa, 0x98, 0x38, 0x4e, 0xe7,
0x50, 0xdc, 0xc3, 0xfb, 0xd1, 0x68, 0x14, 0xa4, 0x78, 0xc2, 0x26, 0xd5, 0xac, 0xea, 0x19, 0x88,
0x30, 0x46, 0x50, 0xea, 0x95, 0x98, 0xc1, 0x86, 0x32, 0x46, 0x18, 0x20, 0xd6, 0x92, 0xd3, 0xd0,
0xaa, 0x9e, 0x81, 0xe0, 0x5a, 0x4c, 0xc2, 0x84, 0xa7, 0xe9, 0x90, 0x0f, 0x74, 0x87, 0x9a, 0x54,
0xac, 0x98, 0xc1, 0xee, 0xc3, 0x8a, 0x38, 0xf4, 0x27, 0x7e, 0x1a, 0x25, 0x67, 0x41, 0xd2, 0x4b,
0xf0, 0xf4, 0x2b, 0x0e, 0x9f, 0x65, 0x59, 0xec, 0x63, 0x58, 0xcf, 0xc1, 0x31, 0xef, 0xf3, 0xe0,
0x9c, 0x0f, 0x48, 0x85, 0xab, 0x7a, 0xd3, 0xb2, 0xd9, 0x0d, 0x68, 0x86, 0x93, 0x51, 0x6f, 0x32,
0x1e, 0xf8, 0xa8, 0xc4, 0x2c, 0x92, 0x72, 0x69, 0x42, 0xec, 0x43, 0x50, 0x7a, 0x9a, 0xd4, 0x1e,
0x97, 0x2c, 0x09, 0x87, 0xd4, 0xeb, 0xd9, 0x25, 0x90, 0x30, 0x33, 0x95, 0xb4, 0x2d, 0x0f, 0x7a,
0x0a, 0x20, 0x3e, 0x89, 0x83, 0x73, 0x3f, 0xe5, 0x9d, 0x65, 0x21, 0xd4, 0x65, 0x12, 0xbf, 0x0b,
0xc2, 0x20, 0x0d, 0xfc, 0x34, 0x8a, 0x3b, 0x8c, 0xf2, 0x32, 0x00, 0x27, 0x91, 0xe8, 0x23, 0x49,
0xfd, 0x74, 0x92, 0x48, 0x0d, 0x75, 0x85, 0x88, 0xab, 0x98, 0xc1, 0x3e, 0x82, 0x35, 0x41, 0x11,
0x94, 0x25, 0x75, 0x6f, 0x52, 0x15, 0x56, 0x69, 0x46, 0xa6, 0xe4, 0xe2, 0x54, 0x4a, 0x12, 0x29,
0x7c, 0x78, 0x45, 0x4c, 0xe5, 0x94, 0x6c, 0xec, 0x1f, 0xf6, 0x20, 0xe8, 0xf7, 0x64, 0x09, 0x64,
0x91, 0x35, 0x1a, 0x45, 0x31, 0x03, 0x49, 0x7c, 0x18, 0x9c, 0xf0, 0x34, 0x18, 0xf1, 0xce, 0xba,
0x20, 0x71, 0x95, 0x46, 0x06, 0x9c, 0x8c, 0x29, 0xa7, 0x23, 0x18, 0x5e, 0xa4, 0xdc, 0xdf, 0x73,
0xc4, 0xe6, 0x23, 0x19, 0x35, 0x31, 0x8e, 0x55, 0x82, 0x45, 0x7b, 0x51, 0x38, 0xbc, 0x90, 0x5c,
0x0b, 0x02, 0x7a, 0x1a, 0x0e, 0x2f, 0x50, 0xb1, 0x0f, 0x42, 0xb3, 0x88, 0x90, 0x73, 0x2d, 0x05,
0x52, 0xa1, 0xf7, 0xa0, 0x39, 0x9e, 0x1c, 0x0f, 0x83, 0xbe, 0x28, 0x52, 0x15, 0xb5, 0x08, 0x88,
0x0a, 0xe0, 0xb9, 0x52, 0xac, 0x94, 0x28, 0x51, 0xa3, 0x12, 0x4d, 0x89, 0x61, 0x11, 0xf7, 0x01,
0xac, 0xda, 0x1d, 0x94, 0x02, 0xfd, 0x2e, 0xd4, 0x25, 0xff, 0x27, 0xf2, 0x70, 0xbf, 0x68, 0xd8,
0x59, 0xf1, 0x18, 0xa4, 0xf3, 0xdd, 0x7f, 0x5d, 0x83, 0x15, 0x89, 0x6e, 0x0f, 0xa3, 0x84, 0x1f,
0x4d, 0x46, 0x23, 0x3f, 0x2e, 0x11, 0x2c, 0xce, 0x25, 0x82, 0xa5, 0x52, 0x14, 0x2c, 0xd7, 0xad,
0xf3, 0xa5, 0x90, 0x4c, 0x06, 0xc2, 0xee, 0xc0, 0x52, 0x7f, 0x18, 0x25, 0x42, 0xdd, 0x37, 0x4d,
0x7d, 0x79, 0xb8, 0x28, 0x0c, 0x67, 0xcb, 0x84, 0xa1, 0x29, 0xc8, 0xe6, 0x72, 0x82, 0xcc, 0x85,
0x16, 0x56, 0xca, 0x95, 0x6c, 0x9e, 0x97, 0x87, 0x2d, 0x03, 0xc3, 0xfe, 0xe4, 0xc5, 0x86, 0x90,
0x51, 0x4b, 0x65, 0x42, 0x23, 0x18, 0x71, 0x92, 0xfd, 0x46, 0xe9, 0x86, 0x14, 0x1a, 0xc5, 0x2c,
0xf6, 0x10, 0x40, 0xb4, 0x45, 0x0a, 0x08, 0x90, 0x02, 0x72, 0xcb, 0x5e, 0x15, 0x73, 0xfe, 0x37,
0x30, 0x31, 0x89, 0x39, 0x29, 0x25, 0xc6, 0x97, 0xee, 0xdf, 0x72, 0xa0, 0x69, 0xe4, 0xb1, 0x2b,
0xb0, 0xbc, 0xfd, 0xf4, 0xe9, 0xe1, 0xae, 0xb7, 0xf5, 0xec, 0xf1, 0xf7, 0x76, 0x7b, 0xdb, 0xfb,
0x4f, 0x8f, 0x76, 0xdb, 0x33, 0x08, 0xef, 0x3f, 0xdd, 0xde, 0xda, 0xef, 0x3d, 0x7c, 0xea, 0x6d,
0x2b, 0xd8, 0x61, 0x6b, 0xc0, 0xbc, 0xdd, 0x27, 0x4f, 0x9f, 0xed, 0x5a, 0x78, 0x85, 0xb5, 0xa1,
0xf5, 0xc0, 0xdb, 0xdd, 0xda, 0xde, 0x93, 0x48, 0x95, 0xad, 0x42, 0xfb, 0xe1, 0xf3, 0x83, 0x9d,
0xc7, 0x07, 0x8f, 0x7a, 0xdb, 0x5b, 0x07, 0xdb, 0xbb, 0xfb, 0xbb, 0x3b, 0xed, 0x1a, 0x5b, 0x80,
0xc6, 0xd6, 0x83, 0xad, 0x83, 0x9d, 0xa7, 0x07, 0xbb, 0x3b, 0xed, 0x59, 0xf7, 0xbf, 0x3a, 0x70,
0x85, 0x7a, 0x3d, 0xc8, 0x33, 0xc9, 0x0d, 0x68, 0xf6, 0xa3, 0x68, 0x8c, 0x8a, 0x7f, 0xb6, 0xb5,
0x99, 0x10, 0x32, 0x80, 0x10, 0x0a, 0x27, 0x51, 0xdc, 0xe7, 0x92, 0x47, 0x80, 0xa0, 0x87, 0x88,
0x20, 0x03, 0xc8, 0xe5, 0x15, 0x25, 0x04, 0x8b, 0x34, 0x05, 0x26, 0x8a, 0xac, 0xc1, 0xdc, 0x71,
0xcc, 0xfd, 0xfe, 0x99, 0xe4, 0x0e, 0x99, 0x62, 0x5f, 0xcf, 0x4e, 0xa6, 0x7d, 0x9c, 0xfd, 0x21,
0x1f, 0x10, 0xc5, 0xd4, 0xbd, 0x25, 0x89, 0x6f, 0x4b, 0x18, 0xa5, 0xa0, 0x7f, 0xec, 0x87, 0x83,
0x28, 0xe4, 0x03, 0xa9, 0xf6, 0x66, 0x80, 0x7b, 0x08, 0x6b, 0xf9, 0xf1, 0x49, 0x1e, 0xfb, 0xc8,
0xe0, 0x31, 0xa1, 0x85, 0x76, 0xa7, 0xaf, 0xa6, 0xc1, 0x6f, 0x7f, 0x5a, 0x81, 0x1a, 0x2a, 0x25,
0xd3, 0x15, 0x18, 0x53, 0xcf, 0xac, 0x16, 0xfc, 0x02, 0x74, 0xd8, 0x15, 0x5b, 0x94, 0x34, 0xb4,
0x64, 0x48, 0x96, 0x1f, 0xf3, 0xfe, 0xb9, 0x34, 0xb5, 0x18, 0x08, 0x32, 0x08, 0x1e, 0x02, 0xe8,
0x6b, 0xc9, 0x20, 0x2a, 0xad, 0xf2, 0xe8, 0xcb, 0xf9, 0x2c, 0x8f, 0xbe, 0xeb, 0xc0, 0x7c, 0x10,
0x1e, 0x47, 0x93, 0x70, 0x40, 0x0c, 0x51, 0xf7, 0x54, 0x92, 0x3c, 0x11, 0xc4, 0xa8, 0x28, 0x3f,
0x05, 0xf9, 0x67, 0x00, 0xdb, 0x84, 0x46, 0x72, 0x11, 0xf6, 0x4d, 0x9a, 0x5f, 0x95, 0xb3, 0x84,
0x73, 0xb0, 0x71, 0x74, 0x11, 0xf6, 0x89, 0xc2, 0xb3, 0x62, 0xee, 0x6f, 0x43, 0x5d, 0xc1, 0x48,
0x96, 0xcf, 0x0f, 0x3e, 0x3f, 0x78, 0xfa, 0xe2, 0xa0, 0x77, 0xf4, 0xfd, 0x83, 0xed, 0xf6, 0x0c,
0x5b, 0x82, 0xe6, 0xd6, 0x36, 0x51, 0x3a, 0x01, 0x0e, 0x16, 0x39, 0xdc, 0x3a, 0x3a, 0xd2, 0x48,
0xc5, 0x65, 0x78, 0x90, 0x4f, 0x48, 0xf3, 0xd3, 0x96, 0xf6, 0x8f, 0x60, 0xd9, 0xc0, 0xb2, 0x53,
0xc4, 0x18, 0x81, 0xdc, 0x29, 0x82, 0x54, 0x46, 0x91, 0xe3, 0xb6, 0x61, 0xf1, 0x11, 0x4f, 0x1f,
0x87, 0x27, 0x91, 0xaa, 0xe9, 0x7f, 0xd6, 0x60, 0x49, 0x43, 0xb2, 0xa2, 0x3b, 0xb0, 0x14, 0x0c,
0x78, 0x98, 0x06, 0xe9, 0x45, 0xcf, 0xb2, 0x17, 0xe4, 0x61, 0x54, 0xb5, 0xfd, 0x61, 0xe0, 0x2b,
0x87, 0x8f, 0x48, 0xe0, 0xf9, 0x19, 0x75, 0x00, 0xd3, 0x6e, 0x43, 0x74, 0x25, 0xcc, 0x14, 0xa5,
0x79, 0x28, 0x81, 0x10, 0x97, 0xdb, 0x8c, 0xfe, 0x44, 0xa8, 0x9c, 0x65, 0x59, 0xb8, 0x54, 0xa2,
0x26, 0x1c, 0xf2, 0xac, 0xd0, 0x13, 0x34, 0x50, 0xf0, 0xa8, 0xcc, 0x09, 0xf9, 0x98, 0xf7, 0xa8,
0x18, 0x5e, 0x99, 0x7a, 0xc1, 0x2b, 0x83, 0xf2, 0xf3, 0x22, 0xec, 0xf3, 0x41, 0x2f, 0x8d, 0x7a,
0x24, 0xe7, 0x89, 0x24, 0xea, 0x5e, 0x1e, 0xc6, 0x7d, 0x23, 0xe5, 0x49, 0x1a, 0x72, 0x61, 0x9a,
0xae, 0x93, 0x15, 0x54, 0x41, 0x78, 0x3e, 0x98, 0xc4, 0x41, 0xd2, 0x69, 0x91, 0xbf, 0x85, 0x7e,
0xb3, 0x6f, 0xc3, 0x95, 0x63, 0x9e, 0xa4, 0xbd, 0x33, 0xee, 0x0f, 0x78, 0x4c, 0xe4, 0x25, 0x1c,
0x3b, 0x42, 0xe5, 0x2a, 0xcf, 0x44, 0xc2, 0x3d, 0xe7, 0x71, 0x12, 0x44, 0x21, 0x29, 0x5b, 0x0d,
0x4f, 0x25, 0xb1, 0x3e, 0x1c, 0xbc, 0xde, 0xa8, 0xf5, 0x0c, 0x2e, 0xd1, 0xc0, 0xcb, 0x33, 0xd9,
0x4d, 0x98, 0xa3, 0x01, 0x24, 0x9d, 0x36, 0xd1, 0x4c, 0x2b, 0xe3, 0xf9, 0x20, 0xf4, 0x64, 0x1e,
0xae, 0x72, 0x3f, 0x1a, 0x46, 0x31, 0x69, 0x5c, 0x0d, 0x4f, 0x24, 0xec, 0xd9, 0x39, 0x8d, 0xfd,
0xf1, 0x99, 0xd4, 0xba, 0xf2, 0xf0, 0x67, 0xb5, 0x7a, 0xb3, 0xdd, 0x72, 0xff, 0x1c, 0xcc, 0x52,
0xb5, 0x54, 0x1d, 0x4d, 0xa6, 0x23, 0xab, 0x23, 0xb4, 0x03, 0xf3, 0x21, 0x4f, 0x5f, 0x45, 0xf1,
0x4b, 0xe5, 0x3d, 0x94, 0x49, 0xf7, 0xa7, 0x74, 0x42, 0xd3, 0xde, 0xb4, 0xe7, 0xa4, 0x5a, 0xe2,
0x39, 0x5b, 0x2c, 0x55, 0x72, 0xe6, 0xcb, 0x43, 0x63, 0x9d, 0x80, 0xa3, 0x33, 0x1f, 0x65, 0xad,
0xb5, 0xfa, 0xe2, 0x1c, 0xde, 0x24, 0x6c, 0x4f, 0x2c, 0xfe, 0x4d, 0x58, 0x54, 0x7e, 0xba, 0xa4,
0x37, 0xe4, 0x27, 0xa9, 0xb2, 0xa2, 0x85, 0x93, 0x11, 0x1d, 0xd6, 0xf7, 0xf9, 0x49, 0xea, 0x1e,
0xc0, 0xb2, 0x94, 0x7f, 0x4f, 0xc7, 0x5c, 0x35, 0xfd, 0x9b, 0x65, 0xba, 0x44, 0x73, 0x73, 0xc5,
0x16, 0x98, 0xc2, 0x33, 0x69, 0x97, 0x74, 0x3d, 0x60, 0xa6, 0x3c, 0x95, 0x15, 0xca, 0xcd, 0x5c,
0xd9, 0x09, 0xe5, 0x70, 0x2c, 0x0c, 0xe7, 0x27, 0x99, 0xf4, 0xfb, 0xca, 0xbb, 0x5a, 0xf7, 0x54,
0xd2, 0xfd, 0x03, 0x07, 0x56, 0xa8, 0x36, 0xa5, 0x0d, 0xc9, 0x3d, 0xeb, 0xe3, 0xaf, 0xd0, 0x4d,
0x65, 0xa5, 0x15, 0xb6, 0xc9, 0x55, 0x98, 0x35, 0x77, 0x31, 0x91, 0xf8, 0xea, 0x36, 0x99, 0x5a,
0xde, 0x26, 0xe3, 0xfe, 0x7d, 0x07, 0x96, 0xc5, 0x46, 0x42, 0xda, 0xb6, 0x1c, 0xfe, 0x9f, 0x87,
0x05, 0xa1, 0x11, 0x48, 0xa9, 0x20, 0x3b, 0x9a, 0x89, 0x56, 0x42, 0x45, 0xe1, 0xbd, 0x19, 0xcf,
0x2e, 0xcc, 0x3e, 0x25, 0xad, 0x2c, 0xec, 0x11, 0x5a, 0xe2, 0x87, 0xb7, 0xe7, 0x7a, 0x6f, 0xc6,
0x33, 0x8a, 0x3f, 0xa8, 0xa3, 0xb2, 0x8c, 0xb8, 0xfb, 0x08, 0x16, 0xac, 0x86, 0x2c, 0x7b, 0x50,
0x4b, 0xd8, 0x83, 0x0a, 0x86, 0xd7, 0x4a, 0x89, 0xe1, 0xf5, 0x5f, 0x56, 0x81, 0x21, 0xb1, 0xe4,
0x56, 0xe3, 0x86, 0xed, 0xbd, 0x50, 0x2e, 0xf9, 0x0c, 0x62, 0x9b, 0xc0, 0x8c, 0xa4, 0xf2, 0xaa,
0x54, 0xb5, 0x57, 0xa5, 0x24, 0x17, 0x45, 0xad, 0xd4, 0x3a, 0xb4, 0xc7, 0x82, 0xce, 0xfa, 0x62,
0xea, 0x4b, 0xf3, 0x70, 0x67, 0x24, 0xf7, 0x05, 0x9e, 0x4a, 0xe4, 0xf9, 0x58, 0xa5, 0xf3, 0x6b,
0x3c, 0x77, 0xe9, 0x1a, 0xcf, 0x17, 0xec, 0x6e, 0xc6, 0x09, 0xad, 0x6e, 0x9f, 0xd0, 0x6e, 0xc2,
0x82, 0xf2, 0x52, 0x08, 0x8f, 0xa8, 0x3c, 0x0e, 0x5b, 0x20, 0xbb, 0x0b, 0x6d, 0x75, 0x48, 0xd2,
0xc7, 0x40, 0xe1, 0xef, 0x2b, 0xe0, 0xb8, 0x07, 0x64, 0x96, 0xb8, 0x26, 0x75, 0x36, 0x03, 0xe8,
0x4c, 0x85, 0x54, 0xd2, 0x9b, 0x84, 0xd2, 0x1d, 0xcf, 0x07, 0x74, 0x10, 0xc6, 0x33, 0x55, 0x3e,
0xc3, 0xfd, 0x3b, 0x0e, 0xb4, 0x71, 0xdd, 0x2c, 0xd2, 0xfc, 0x04, 0x88, 0x33, 0xde, 0x92, 0x32,
0xad, 0xb2, 0xec, 0x63, 0x68, 0x50, 0x3a, 0x1a, 0xf3, 0x50, 0xd2, 0x65, 0xc7, 0xa6, 0xcb, 0x4c,
0xa6, 0xec, 0xcd, 0x78, 0x59, 0x61, 0x83, 0x2a, 0xff, 0xa3, 0x03, 0x4d, 0xd9, 0xca, 0x2f, 0x6d,
0xe9, 0xe9, 0x1a, 0xf1, 0x13, 0x42, 0x01, 0xcb, 0xc2, 0x25, 0xee, 0xc0, 0xd2, 0xc8, 0x4f, 0x27,
0x31, 0xee, 0xe9, 0x96, 0x95, 0x27, 0x0f, 0xe3, 0x06, 0x4d, 0xe2, 0x33, 0xe9, 0xa5, 0xc1, 0xb0,
0xa7, 0x72, 0x65, 0xa4, 0x42, 0x59, 0x16, 0x4a, 0x91, 0x24, 0xf5, 0x4f, 0xb9, 0xdc, 0x7b, 0x45,
0xc2, 0xed, 0xc0, 0xda, 0x61, 0xe6, 0xb9, 0x31, 0x74, 0x6c, 0xf7, 0x9f, 0x2f, 0xc0, 0x7a, 0x21,
0x4b, 0xc7, 0x55, 0x49, 0xd3, 0xc5, 0x30, 0x18, 0x1d, 0x47, 0xfa, 0x80, 0xe2, 0x98, 0x56, 0x0d,
0x2b, 0x8b, 0x9d, 0xc2, 0x15, 0xa5, 0x64, 0xe0, 0x9c, 0x66, 0x1b, 0x62, 0x85, 0x76, 0xba, 0x0f,
0xed, 0x25, 0xcc, 0x37, 0xa8, 0x70, 0x93, 0x91, 0xcb, 0xeb, 0x63, 0x67, 0xd0, 0xd1, 0xda, 0x8c,
0x14, 0xd8, 0x86, 0xc6, 0x83, 0x6d, 0x7d, 0x70, 0x49, 0x5b, 0x96, 0x4a, 0xee, 0x4d, 0xad, 0x8d,
0x5d, 0xc0, 0x75, 0x95, 0x47, 0x12, 0xb9, 0xd8, 0x5e, 0xed, 0xad, 0xc6, 0x46, 0x87, 0x0d, 0xbb,
0xd1, 0x4b, 0x2a, 0x66, 0x3f, 0x86, 0xb5, 0x57, 0x7e, 0x90, 0xaa, 0x6e, 0x19, 0xfa, 0xc5, 0x2c,
0x35, 0xb9, 0x79, 0x49, 0x93, 0x2f, 0xc4, 0xc7, 0xd6, 0x36, 0x35, 0xa5, 0xc6, 0xee, 0x1f, 0x57,
0x60, 0xd1, 0xae, 0x07, 0xc9, 0x54, 0xf2, 0xbe, 0x92, 0x81, 0x4a, 0x23, 0xcd, 0xc1, 0xc5, 0x73,
0x7e, 0xa5, 0xec, 0x9c, 0x6f, 0x9e, 0xac, 0xab, 0x97, 0x99, 0x08, 0x6b, 0x6f, 0x67, 0x22, 0x9c,
0x2d, 0x35, 0x11, 0x4e, 0xb7, 0x24, 0xcd, 0xfd, 0xb2, 0x96, 0xa4, 0xf9, 0x37, 0x5a, 0x92, 0xba,
0xff, 0xd7, 0x01, 0x56, 0xa4, 0x5e, 0xf6, 0x48, 0x98, 0x36, 0x42, 0x3e, 0x94, 0x42, 0xec, 0x9b,
0x6f, 0xc7, 0x01, 0x6a, 0xb5, 0xd4, 0xd7, 0xc8, 0x8a, 0x66, 0x70, 0x93, 0xa9, 0x62, 0x2d, 0x78,
0x65, 0x59, 0x39, 0x33, 0x69, 0xed, 0x72, 0x33, 0xe9, 0xec, 0xe5, 0x66, 0xd2, 0xb9, 0xbc, 0x99,
0xb4, 0xfb, 0xd7, 0x1d, 0x58, 0x29, 0x21, 0xb3, 0x5f, 0xdf, 0xc0, 0x91, 0x30, 0x2c, 0xe9, 0x53,
0x91, 0x84, 0x61, 0x82, 0xdd, 0xbf, 0x0c, 0x0b, 0x16, 0x6b, 0xfd, 0xfa, 0xda, 0xcf, 0x6b, 0x89,
0x82, 0xb2, 0x2d, 0xac, 0xfb, 0xbf, 0x2a, 0xc0, 0x8a, 0xec, 0xfd, 0x67, 0xda, 0x87, 0xe2, 0x3c,
0x55, 0x4b, 0xe6, 0xe9, 0xff, 0xeb, 0xce, 0xf3, 0x01, 0x2c, 0xcb, 0x88, 0x4d, 0xc3, 0x98, 0x25,
0x28, 0xa6, 0x98, 0x81, 0x7a, 0xb2, 0x6d, 0xa3, 0xae, 0x5b, 0x11, 0x6a, 0xc6, 0xf6, 0x9b, 0x33,
0x55, 0xbb, 0x5d, 0xe8, 0xc8, 0x19, 0xda, 0x3d, 0xe7, 0x61, 0x7a, 0x34, 0x39, 0x16, 0x21, 0x8b,
0x41, 0x14, 0x92, 0x1a, 0x68, 0x66, 0x4a, 0x85, 0xe2, 0xdb, 0xd0, 0x32, 0xb7, 0x0f, 0xb9, 0x1c,
0x39, 0x7b, 0x26, 0xaa, 0x12, 0x66, 0x29, 0xb6, 0x03, 0x8b, 0x24, 0x24, 0x07, 0xfa, 0xbb, 0x0a,
0x7d, 0xf7, 0x06, 0x1b, 0xcd, 0xde, 0x8c, 0x97, 0xfb, 0x86, 0xfd, 0x16, 0x2c, 0xda, 0x07, 0x40,
0xa9, 0x95, 0x94, 0x9d, 0x08, 0xf0, 0x73, 0xbb, 0x30, 0xdb, 0x82, 0x76, 0xfe, 0x04, 0x29, 0xa3,
0x79, 0xa6, 0x54, 0x50, 0x28, 0xce, 0x3e, 0x96, 0x0e, 0xcb, 0x59, 0xb2, 0x9d, 0xdc, 0xb4, 0x3f,
0x33, 0xa6, 0x69, 0x43, 0xfc, 0x31, 0x5c, 0x98, 0xbf, 0x03, 0x90, 0x61, 0xac, 0x0d, 0xad, 0xa7,
0x87, 0xbb, 0x07, 0xbd, 0xed, 0xbd, 0xad, 0x83, 0x83, 0xdd, 0xfd, 0xf6, 0x0c, 0x63, 0xb0, 0x48,
0xa6, 0xbe, 0x1d, 0x8d, 0x39, 0x88, 0x49, 0xe3, 0x8a, 0xc2, 0x2a, 0x6c, 0x15, 0xda, 0x8f, 0x0f,
0x72, 0x68, 0xf5, 0x41, 0x43, 0xf3, 0x87, 0xbb, 0x06, 0xab, 0x22, 0x22, 0xf7, 0x81, 0x20, 0x0f,
0xa5, 0x9d, 0xfc, 0x63, 0x07, 0xae, 0xe4, 0x32, 0xb2, 0x90, 0x2f, 0xa1, 0x80, 0xd8, 0x5a, 0x89,
0x0d, 0x92, 0x03, 0x42, 0xe9, 0x9a, 0x39, 0x09, 0x52, 0xcc, 0x40, 0x9a, 0x37, 0x74, 0xd3, 0x1c,
0x27, 0x95, 0x65, 0xb9, 0xeb, 0x3a, 0xb2, 0x26, 0xd7, 0xf1, 0x13, 0x11, 0xe9, 0x6b, 0x66, 0x64,
0x0e, 0x60, 0xbb, 0xcb, 0x2a, 0x89, 0xc7, 0x0a, 0x4b, 0xd9, 0xb1, 0xfb, 0x5b, 0x9a, 0xe7, 0xfe,
0xbb, 0x2a, 0xb0, 0xef, 0x4e, 0x78, 0x7c, 0x41, 0x31, 0x5d, 0xda, 0x72, 0xba, 0x9e, 0xb7, 0x0b,
0xce, 0x8d, 0x27, 0xc7, 0x9f, 0xf3, 0x0b, 0x15, 0x2c, 0x59, 0x79, 0xab, 0x60, 0xc9, 0xb2, 0x60,
0xc5, 0xda, 0xe5, 0xc1, 0x8a, 0xb3, 0x97, 0x05, 0x2b, 0x7e, 0x0d, 0x16, 0x82, 0xd3, 0x30, 0x42,
0x71, 0x80, 0x2a, 0x44, 0xd2, 0x99, 0xbb, 0x51, 0xc5, 0xa3, 0xb7, 0x04, 0x0f, 0x10, 0x63, 0x9f,
0x66, 0x85, 0xf8, 0xe0, 0x94, 0x82, 0x6b, 0x4d, 0x01, 0xb1, 0x3b, 0x38, 0xe5, 0xfb, 0x51, 0xdf,
0x4f, 0xa3, 0x98, 0xce, 0x69, 0xea, 0x63, 0xc4, 0x13, 0x76, 0x13, 0x16, 0x93, 0x68, 0x82, 0x4a,
0x95, 0x9a, 0x06, 0x61, 0x68, 0x6a, 0x09, 0xf4, 0x50, 0x4c, 0xc6, 0x06, 0xac, 0x4c, 0x12, 0xde,
0x1b, 0x05, 0x49, 0x82, 0x1b, 0x67, 0x3f, 0x0a, 0xd3, 0x38, 0x1a, 0x4a, 0x73, 0xd3, 0xf2, 0x24,
0xe1, 0x4f, 0x44, 0xce, 0xb6, 0xc8, 0x60, 0xdf, 0xce, 0xba, 0x34, 0xf6, 0x83, 0x38, 0xe9, 0x00,
0x75, 0x49, 0x8d, 0x14, 0xfb, 0x7d, 0xe8, 0x07, 0xb1, 0xee, 0x0b, 0x26, 0x92, 0x5c, 0x10, 0x65,
0x33, 0x17, 0x44, 0x29, 0xe3, 0xef, 0x36, 0xa0, 0xae, 0x3e, 0xc7, 0x33, 0xf0, 0x49, 0x1c, 0x8d,
0xd4, 0x19, 0x18, 0x7f, 0xb3, 0x45, 0xa8, 0xa4, 0x91, 0x3c, 0xbf, 0x56, 0xd2, 0xc8, 0xfd, 0x5d,
0x68, 0x1a, 0x33, 0xc0, 0xde, 0x17, 0xc7, 0x71, 0xd4, 0xb5, 0xe4, 0xe1, 0x59, 0x78, 0x51, 0x1a,
0x12, 0x7d, 0x3c, 0x60, 0xdf, 0x80, 0xe5, 0x41, 0x10, 0x73, 0x8a, 0xf3, 0xed, 0xc5, 0xfc, 0x9c,
0xc7, 0x89, 0x32, 0x35, 0xb4, 0x75, 0x86, 0x27, 0x70, 0xb7, 0x07, 0x2b, 0x16, 0x55, 0x69, 0xa6,
0x9b, 0xa3, 0xa0, 0x41, 0x65, 0xed, 0xb4, 0x03, 0x0a, 0x65, 0x1e, 0x6e, 0x57, 0xd2, 0x4a, 0xd2,
0x1b, 0xc7, 0xd1, 0x31, 0x35, 0xe2, 0x78, 0x16, 0xe6, 0xfe, 0x69, 0x05, 0xaa, 0x7b, 0xd1, 0xd8,
0xf4, 0xfd, 0x38, 0x45, 0xdf, 0x8f, 0xd4, 0x2b, 0x7b, 0x5a, 0x6d, 0x94, 0x9b, 0xbf, 0x05, 0xb2,
0xbb, 0xb0, 0x88, 0x14, 0x9c, 0x46, 0xa8, 0x47, 0xbf, 0xf2, 0x63, 0x11, 0x61, 0x58, 0x25, 0xb2,
0xc8, 0xe5, 0xb0, 0x55, 0xa8, 0x6a, 0x75, 0x88, 0x0a, 0x60, 0x12, 0x0f, 0x71, 0xe4, 0x5f, 0xbf,
0x90, 0x26, 0x4d, 0x99, 0x42, 0x81, 0x60, 0x7f, 0x2f, 0xd8, 0x44, 0x6c, 0x6a, 0x65, 0x59, 0xa8,
0xe3, 0x22, 0x23, 0x8c, 0x32, 0x95, 0x51, 0xa7, 0x4d, 0x63, 0x7d, 0xdd, 0x36, 0xd6, 0xdf, 0x80,
0x66, 0x3a, 0x3c, 0xef, 0x8d, 0xfd, 0x8b, 0x61, 0xe4, 0x0f, 0x24, 0x01, 0x9a, 0x10, 0xbb, 0x0f,
0x30, 0x1a, 0x8f, 0x7b, 0xb8, 0x8f, 0xc6, 0x03, 0x3a, 0x99, 0x37, 0x37, 0xdb, 0x72, 0xf6, 0x9f,
0x1c, 0x1e, 0x7a, 0x84, 0x7b, 0x46, 0x19, 0xf7, 0x05, 0x34, 0x74, 0x86, 0x19, 0x9a, 0x4a, 0x11,
0x16, 0x4d, 0x3b, 0x34, 0x95, 0x02, 0x2a, 0x6e, 0xc1, 0xa2, 0x10, 0x9e, 0x5a, 0x1c, 0x08, 0xaf,
0x78, 0x0e, 0x75, 0x7f, 0xe1, 0xc0, 0x2c, 0x2d, 0x38, 0x6a, 0x13, 0x22, 0x4f, 0xfb, 0xaa, 0x68,
0x11, 0x17, 0xbc, 0x3c, 0xcc, 0x5c, 0x2b, 0x4c, 0xbe, 0xa2, 0x67, 0xdf, 0x0c, 0x95, 0xbf, 0x01,
0x0d, 0xdd, 0x92, 0xb1, 0x82, 0x19, 0xc8, 0xae, 0x43, 0xed, 0x2c, 0x1a, 0xab, 0x03, 0x17, 0x28,
0x77, 0x76, 0x34, 0xf6, 0x08, 0xcf, 0xfa, 0x83, 0xf5, 0x89, 0x21, 0x08, 0xa5, 0x36, 0x0f, 0x97,
0x8c, 0x75, 0xae, 0x74, 0xac, 0xcf, 0x61, 0x09, 0xd9, 0xd2, 0xb0, 0xdd, 0x4f, 0x17, 0xad, 0x5f,
0xc7, 0x9d, 0xba, 0x3f, 0x9c, 0x0c, 0xb8, 0x79, 0xec, 0x25, 0xdb, 0xac, 0xc4, 0x95, 0xc2, 0xe7,
0xfe, 0x0b, 0x47, 0xb0, 0x3b, 0xd6, 0xcb, 0xee, 0x40, 0x0d, 0xa5, 0x60, 0xce, 0xca, 0xa1, 0xa3,
0x5e, 0xb0, 0x9c, 0x47, 0x25, 0x70, 0x15, 0xc9, 0x7a, 0x6a, 0xd6, 0x2e, 0x6c, 0xa7, 0xd9, 0x99,
0x51, 0x8f, 0x2c, 0x77, 0xd4, 0xca, 0xa1, 0x6c, 0xc3, 0x70, 0x3d, 0xd5, 0x2c, 0xc9, 0xaa, 0x14,
0x83, 0xc1, 0x29, 0x37, 0x5c, 0x4e, 0x7f, 0xe8, 0xc0, 0x82, 0xd5, 0x27, 0x24, 0x5a, 0x0a, 0x22,
0x17, 0x46, 0x13, 0xb9, 0xf2, 0x26, 0x64, 0x12, 0x7c, 0xc5, 0x26, 0x78, 0xed, 0xc2, 0xa8, 0x9a,
0x2e, 0x8c, 0xfb, 0xd0, 0xc8, 0xee, 0x49, 0xd8, 0x9d, 0xc2, 0x16, 0x55, 0xfc, 0x4f, 0x56, 0x28,
0x33, 0x92, 0xcf, 0x1a, 0x46, 0x72, 0xf7, 0x53, 0x68, 0x1a, 0xe5, 0x4d, 0x23, 0xb7, 0x63, 0x19,
0xb9, 0x75, 0x70, 0x5c, 0x25, 0x0b, 0x8e, 0x73, 0x7f, 0x56, 0x81, 0x05, 0x24, 0xef, 0x20, 0x3c,
0x3d, 0x8c, 0x86, 0x41, 0xff, 0x82, 0xc8, 0x4a, 0x51, 0xb2, 0xdc, 0x05, 0x15, 0x99, 0xdb, 0x30,
0x72, 0xbf, 0x8e, 0x08, 0x16, 0xa2, 0x4a, 0xa7, 0x51, 0x96, 0xa1, 0x24, 0x38, 0xf6, 0x13, 0x6e,
0x5c, 0x9c, 0xf0, 0x6c, 0x10, 0x25, 0x0e, 0x02, 0x14, 0xea, 0x38, 0x0a, 0x86, 0xc3, 0x40, 0x94,
0x15, 0xc7, 0xb7, 0xb2, 0x2c, 0x6c, 0x73, 0x10, 0x24, 0xfe, 0x71, 0xe6, 0x9e, 0xd4, 0x69, 0xb2,
0xfd, 0xf9, 0xaf, 0x0d, 0xdb, 0x9f, 0x88, 0x8d, 0xb6, 0xc1, 0xfc, 0x42, 0xce, 0x17, 0x16, 0xd2,
0xfd, 0xb7, 0x15, 0x68, 0x1a, 0x64, 0x81, 0xec, 0x5c, 0xba, 0xdd, 0x18, 0xa8, 0xf4, 0xdb, 0x87,
0x96, 0x41, 0xc0, 0x40, 0xd8, 0x4d, 0xbb, 0x55, 0xf2, 0x03, 0x10, 0xc3, 0x5b, 0x24, 0x74, 0x0d,
0x1a, 0x48, 0xfa, 0x1f, 0x92, 0xf5, 0x41, 0x5e, 0x52, 0xd2, 0x80, 0xca, 0xdd, 0xa4, 0xdc, 0xd9,
0x2c, 0x97, 0x80, 0x37, 0x7a, 0xf2, 0x3f, 0x86, 0x96, 0xac, 0x86, 0xd6, 0x98, 0x06, 0x9d, 0x31,
0x9f, 0xb5, 0xfe, 0x9e, 0x55, 0x52, 0x7d, 0xb9, 0xa9, 0xbe, 0xac, 0x5f, 0xf6, 0xa5, 0x2a, 0xe9,
0x3e, 0xd2, 0x41, 0x12, 0x8f, 0x62, 0x7f, 0x7c, 0xa6, 0x04, 0xca, 0x7d, 0x58, 0x51, 0x72, 0x63,
0x12, 0xfa, 0x61, 0x18, 0x4d, 0xc2, 0x3e, 0x57, 0x71, 0x74, 0x65, 0x59, 0xee, 0x40, 0x47, 0x5d,
0x53, 0x45, 0xec, 0x2e, 0xcc, 0x0a, 0x3d, 0x4a, 0xec, 0xca, 0xe5, 0x22, 0x44, 0x14, 0x61, 0x77,
0x60, 0x56, 0xa8, 0x53, 0x95, 0xa9, 0x4c, 0x2f, 0x0a, 0xb8, 0x1b, 0xb0, 0x44, 0x61, 0xde, 0x86,
0xec, 0x7b, 0xa7, 0x6c, 0xb7, 0x9e, 0xeb, 0x8b, 0x60, 0xf0, 0x55, 0x60, 0x07, 0x82, 0xaf, 0x4c,
0x57, 0xe7, 0x2f, 0xaa, 0xd0, 0x34, 0x60, 0x94, 0x4f, 0xe4, 0x9f, 0xea, 0x0d, 0x02, 0x7f, 0xc4,
0x53, 0x1e, 0x4b, 0x5e, 0xca, 0xa1, 0x58, 0xce, 0x3f, 0x3f, 0xed, 0x45, 0x93, 0xb4, 0x37, 0xe0,
0xa7, 0x31, 0xe7, 0x52, 0x8d, 0xc8, 0xa1, 0x58, 0x0e, 0xa9, 0xd9, 0x28, 0x27, 0x3c, 0x4a, 0x39,
0x54, 0x39, 0x2e, 0xc5, 0x3c, 0xd5, 0x32, 0xc7, 0xa5, 0x98, 0x95, 0xbc, 0x64, 0x9d, 0x2d, 0x91,
0xac, 0x1f, 0xc1, 0x9a, 0x90, 0xa1, 0x52, 0x7a, 0xf4, 0x72, 0xc4, 0x35, 0x25, 0x97, 0xdd, 0x85,
0x36, 0xf6, 0x59, 0xb1, 0x46, 0x12, 0xfc, 0x54, 0xf0, 0x98, 0xe3, 0x15, 0x70, 0x2c, 0x4b, 0x96,
0x74, 0xb3, 0xac, 0x88, 0x1e, 0x29, 0xe0, 0x54, 0xd6, 0x7f, 0x6d, 0x97, 0x6d, 0xc8, 0xb2, 0x39,
0x9c, 0x7d, 0x0c, 0xeb, 0x23, 0x3e, 0x08, 0x7c, 0xbb, 0x8a, 0x5e, 0xb6, 0xc9, 0x4f, 0xcb, 0xc6,
0x56, 0x70, 0x16, 0x7e, 0x1a, 0x8d, 0x8e, 0x03, 0xb1, 0xb1, 0x09, 0x9b, 0x7f, 0xcd, 0x2b, 0xe0,
0xee, 0x02, 0x34, 0x8f, 0xd2, 0x68, 0xac, 0x96, 0x7e, 0x11, 0x5a, 0x22, 0x29, 0x23, 0x27, 0xdf,
0x81, 0xab, 0x44, 0xaf, 0xcf, 0xa2, 0x71, 0x34, 0x8c, 0x4e, 0x2f, 0xac, 0x93, 0xfb, 0x7f, 0x70,
0x60, 0xc5, 0xca, 0xcd, 0x8e, 0xee, 0x64, 0x66, 0x54, 0xe1, 0x6e, 0x82, 0xc4, 0x97, 0x8d, 0x6d,
0x41, 0x14, 0x14, 0x5e, 0x9d, 0xe7, 0x32, 0x02, 0x6e, 0x2b, 0xbb, 0xc3, 0xa1, 0x3e, 0x14, 0xf4,
0xde, 0x29, 0xd2, 0xbb, 0xfc, 0x5e, 0xdd, 0xee, 0x50, 0x55, 0xfc, 0x96, 0x8c, 0xf5, 0x19, 0xc8,
0x41, 0x57, 0xed, 0xf8, 0x0c, 0xd3, 0xd2, 0xa3, 0x7a, 0xd0, 0xd7, 0x60, 0xe2, 0xfe, 0xdc, 0x01,
0xc8, 0x7a, 0x47, 0x11, 0x22, 0x7a, 0x6b, 0x13, 0xf7, 0x92, 0x8d, 0x6d, 0xec, 0x7d, 0x68, 0x69,
0x27, 0x7f, 0xb6, 0x5b, 0x36, 0x15, 0x86, 0xda, 0xc5, 0x6d, 0x58, 0x3a, 0x1d, 0x46, 0xc7, 0xa4,
0xc5, 0x50, 0x28, 0x6e, 0x22, 0xe3, 0x47, 0x17, 0x05, 0xfc, 0x50, 0xa2, 0xd9, 0xd6, 0x5a, 0x33,
0xb7, 0xd6, 0xf2, 0x8d, 0xf2, 0x67, 0x15, 0xed, 0x69, 0xcd, 0x66, 0xe2, 0x8d, 0x5c, 0xce, 0x36,
0x0b, 0x62, 0x7d, 0x8a, 0x73, 0x93, 0x8e, 0x1e, 0x87, 0x97, 0x1a, 0x7e, 0x3f, 0x85, 0xc5, 0x58,
0xc8, 0x4c, 0x25, 0x50, 0x6b, 0x6f, 0x10, 0xa8, 0x0b, 0xb1, 0xb5, 0x33, 0x7f, 0x1d, 0xda, 0xfe,
0xe0, 0x9c, 0xc7, 0x69, 0x40, 0x86, 0x30, 0x52, 0xa3, 0xc4, 0x00, 0x97, 0x0c, 0x9c, 0xb4, 0x95,
0xdb, 0xb0, 0x24, 0xa3, 0x79, 0x75, 0x49, 0x79, 0x43, 0x2f, 0x83, 0xb1, 0xa0, 0xfb, 0x4f, 0x95,
0x63, 0xd7, 0x5e, 0xdd, 0x37, 0xcf, 0x8a, 0x39, 0xc2, 0x4a, 0x6e, 0x84, 0x5f, 0x93, 0x8e, 0xd6,
0x81, 0xb2, 0xb8, 0x55, 0x8d, 0xa8, 0xb1, 0x81, 0x74, 0x8c, 0xdb, 0xd3, 0x5a, 0x7b, 0x9b, 0x69,
0x75, 0xff, 0xb3, 0x03, 0xf3, 0x7b, 0xd1, 0x78, 0x0f, 0xa7, 0x18, 0x75, 0x1c, 0x64, 0x13, 0x1d,
0x4a, 0xaf, 0x92, 0x97, 0x44, 0xd7, 0x95, 0x6a, 0x25, 0x0b, 0x79, 0xad, 0xe4, 0x2f, 0xc2, 0x3b,
0x64, 0xf3, 0x8d, 0xa3, 0x71, 0x14, 0x23, 0xbb, 0xfa, 0x43, 0xa1, 0x82, 0x44, 0x61, 0x7a, 0xa6,
0xc4, 0xe9, 0x9b, 0x8a, 0x90, 0x21, 0x06, 0x0f, 0xc1, 0xe2, 0x60, 0x25, 0xb5, 0x28, 0x21, 0x65,
0x8b, 0x19, 0xee, 0x6f, 0x42, 0x83, 0x4e, 0x18, 0x34, 0xb4, 0x0f, 0xa0, 0x71, 0x16, 0x8d, 0x7b,
0x67, 0x41, 0x98, 0x2a, 0xf6, 0x5f, 0xcc, 0x54, 0xff, 0x3d, 0x9a, 0x14, 0x5d, 0xc0, 0xfd, 0x93,
0x39, 0x98, 0x7f, 0x1c, 0x9e, 0x47, 0x41, 0x9f, 0x9c, 0xc9, 0x23, 0x3e, 0x8a, 0xd4, 0xe5, 0x02,
0xfc, 0x4d, 0x17, 0x6d, 0xb3, 0xeb, 0x7f, 0x82, 0x85, 0x0c, 0x04, 0x8f, 0x82, 0xb1, 0x79, 0x7d,
0x4f, 0xa6, 0xb2, 0xeb, 0x19, 0xb3, 0xc6, 0xf5, 0x0c, 0xac, 0x4d, 0x5c, 0x2b, 0xa3, 0xb9, 0x13,
0x41, 0xa1, 0x06, 0x82, 0x93, 0x2f, 0xa3, 0xfe, 0x44, 0x58, 0x98, 0x08, 0x51, 0x91, 0x10, 0x1d,
0x6f, 0x63, 0x2e, 0xac, 0xf6, 0x5a, 0xf5, 0xc2, 0xe3, 0xad, 0x09, 0xa2, 0x7a, 0x26, 0x3e, 0x10,
0x65, 0xc4, 0x76, 0x60, 0x42, 0xa8, 0xa0, 0xe6, 0x6f, 0x9f, 0x8a, 0x1b, 0xc4, 0x79, 0x18, 0xa5,
0xf9, 0x80, 0x6b, 0xa1, 0x2b, 0xc6, 0x09, 0xe2, 0x0a, 0x64, 0x1e, 0x37, 0x0e, 0xc5, 0x22, 0xec,
0x59, 0x1d, 0x8a, 0x91, 0x64, 0xfc, 0xe1, 0xf0, 0xd8, 0xef, 0xbf, 0x14, 0x87, 0xc9, 0x96, 0x70,
0xf6, 0x58, 0x20, 0xc5, 0xee, 0x65, 0xeb, 0x4a, 0x01, 0x36, 0x35, 0xcf, 0x84, 0xd8, 0x26, 0x34,
0xc9, 0x60, 0x20, 0x57, 0x76, 0x91, 0x56, 0xb6, 0x6d, 0x5a, 0x14, 0x68, 0x6d, 0xcd, 0x42, 0xa6,
0x9b, 0x7b, 0xa9, 0x10, 0x88, 0xec, 0x0f, 0x06, 0x32, 0x42, 0xa0, 0x2d, 0xae, 0x00, 0x6a, 0x80,
0x4c, 0x12, 0x62, 0xc2, 0x44, 0x81, 0x65, 0x2a, 0x60, 0x61, 0xec, 0xba, 0x30, 0x84, 0x8d, 0xfd,
0x60, 0x40, 0x31, 0x35, 0xe2, 0xf8, 0xa9, 0x31, 0xac, 0x43, 0xfd, 0xa6, 0x8d, 0x73, 0x85, 0x66,
0xc5, 0xc2, 0x70, 0x6e, 0x74, 0x7a, 0x94, 0x45, 0x2e, 0xdb, 0x20, 0xfb, 0x90, 0x7c, 0xb4, 0x29,
0xa7, 0xf0, 0xe4, 0xc5, 0xcd, 0x77, 0xe4, 0x98, 0x25, 0xd9, 0xaa, 0xbf, 0x47, 0x58, 0xc4, 0x13,
0x25, 0x51, 0x6d, 0x13, 0x66, 0xf2, 0x35, 0x4b, 0x6d, 0x93, 0x45, 0xc9, 0x4c, 0x2e, 0x0a, 0xb8,
0x5b, 0xd0, 0x32, 0x2b, 0x60, 0x75, 0xa8, 0x3d, 0x3d, 0xdc, 0x3d, 0x68, 0xcf, 0xb0, 0x26, 0xcc,
0x1f, 0xed, 0x3e, 0x7b, 0xb6, 0xbf, 0xbb, 0xd3, 0x76, 0x58, 0x0b, 0xea, 0x3a, 0x24, 0xb3, 0x82,
0xa9, 0xad, 0xed, 0xed, 0xdd, 0xc3, 0x67, 0xbb, 0x3b, 0xed, 0xea, 0x67, 0xb5, 0x7a, 0xa5, 0x5d,
0x75, 0xff, 0xa0, 0x02, 0x4d, 0xa3, 0xfe, 0x4b, 0x4c, 0x35, 0xd7, 0x01, 0xe8, 0x44, 0x91, 0x85,
0x68, 0xd4, 0x3c, 0x03, 0x41, 0x09, 0xa9, 0xcf, 0xda, 0x55, 0x71, 0x1f, 0x52, 0xa5, 0x69, 0xd6,
0xe8, 0xe2, 0xa1, 0xe9, 0x93, 0x98, 0xf5, 0x6c, 0x10, 0x29, 0x4a, 0x02, 0x14, 0x27, 0x28, 0xf8,
0xd0, 0x84, 0x70, 0x85, 0x62, 0x9e, 0x44, 0xc3, 0x73, 0x2e, 0x8a, 0x08, 0xbd, 0xcc, 0xc2, 0xb0,
0x2d, 0x29, 0x6a, 0x8c, 0x18, 0xde, 0x59, 0xcf, 0x06, 0xd9, 0x37, 0xd5, 0x0a, 0xd5, 0x69, 0x85,
0xd6, 0x8b, 0xd3, 0x6d, 0xae, 0x8e, 0x9b, 0x02, 0xdb, 0x1a, 0x0c, 0x64, 0xae, 0x79, 0xbb, 0x32,
0x36, 0xaf, 0xf3, 0x2a, 0x51, 0x52, 0xc2, 0xae, 0x95, 0x72, 0x76, 0x7d, 0x23, 0x51, 0xbb, 0x8f,
0xa1, 0x79, 0x68, 0x5c, 0x10, 0x76, 0x51, 0xb2, 0xa9, 0xab, 0xc1, 0x42, 0xe6, 0x09, 0x1b, 0x4b,
0x86, 0x1a, 0x5d, 0xaa, 0x98, 0x5d, 0x72, 0xff, 0x89, 0x23, 0xee, 0x5c, 0xe9, 0x21, 0x88, 0xf6,
0x5d, 0x68, 0x69, 0xab, 0x73, 0x16, 0xa6, 0x6e, 0x61, 0x58, 0x86, 0xba, 0xd3, 0x8b, 0x4e, 0x4e,
0x12, 0xae, 0x02, 0x4a, 0x2d, 0x4c, 0x29, 0x91, 0xa8, 0x96, 0x06, 0xa2, 0x85, 0x44, 0x06, 0x96,
0x16, 0x70, 0x24, 0x14, 0x69, 0x9d, 0x54, 0xa1, 0xb4, 0x3a, 0xad, 0xa3, 0xe9, 0xf3, 0x33, 0x7d,
0x17, 0xea, 0xba, 0x5e, 0x7b, 0x87, 0x50, 0x25, 0x75, 0x3e, 0xee, 0x44, 0x74, 0xc0, 0xb4, 0x3a,
0x2d, 0xe8, 0xb5, 0x98, 0xc1, 0x36, 0x80, 0x9d, 0x04, 0x71, 0xbe, 0xb8, 0x20, 0xe0, 0x92, 0x1c,
0xf7, 0x05, 0xac, 0x28, 0xee, 0x33, 0xb4, 0x5b, 0x7b, 0x21, 0x9d, 0xcb, 0xa4, 0x53, 0xa5, 0x28,
0x9d, 0xdc, 0x7f, 0x53, 0x83, 0x79, 0xb9, 0xda, 0x85, 0x8b, 0xe6, 0x62, 0x7f, 0xb3, 0x30, 0xd6,
0xb1, 0xae, 0x13, 0x12, 0x21, 0xc8, 0x3d, 0xeb, 0x4e, 0x7e, 0xd7, 0xc9, 0x6c, 0x6d, 0xb9, 0x9d,
0x67, 0x0d, 0x6a, 0x63, 0x3f, 0x3d, 0x23, 0x53, 0x8c, 0xa0, 0x25, 0x4a, 0x2b, 0x23, 0xea, 0xac,
0x6d, 0x44, 0x2d, 0xbb, 0x5e, 0x2f, 0x54, 0xac, 0xe2, 0xf5, 0xfa, 0x6b, 0xd0, 0x10, 0xbb, 0x64,
0x66, 0x27, 0xcd, 0x80, 0xdc, 0xae, 0x5a, 0x2f, 0xec, 0xaa, 0x6f, 0xbf, 0xdf, 0x7d, 0x1b, 0xe6,
0xc4, 0x15, 0x13, 0x19, 0x38, 0x7c, 0x4d, 0xb9, 0x17, 0x45, 0x39, 0xf5, 0x57, 0x44, 0x1f, 0x79,
0xb2, 0xac, 0x79, 0x49, 0xb5, 0x69, 0x5f, 0x52, 0x35, 0xcd, 0xbb, 0xad, 0x9c, 0x79, 0xf7, 0x2e,
0xb4, 0xf5, 0xf4, 0x91, 0x61, 0x28, 0x4c, 0x64, 0x5c, 0x69, 0x01, 0xcf, 0xc4, 0xf9, 0xa2, 0x25,
0xce, 0x51, 0xb0, 0x6c, 0xa5, 0x29, 0x1f, 0x8d, 0x53, 0x25, 0xce, 0x1f, 0xc2, 0x82, 0xd5, 0x49,
0x94, 0xe2, 0x32, 0x9c, 0xb9, 0x3d, 0xc3, 0x16, 0xa0, 0xf1, 0xf8, 0xa0, 0xf7, 0x70, 0xff, 0xf1,
0xa3, 0xbd, 0x67, 0x6d, 0x07, 0x93, 0x47, 0xcf, 0xb7, 0xb7, 0x77, 0x77, 0x77, 0x48, 0xaa, 0x03,
0xcc, 0x3d, 0xdc, 0x7a, 0x8c, 0x12, 0xbe, 0xea, 0xfe, 0x1f, 0x07, 0x9a, 0x46, 0xf5, 0xec, 0x3b,
0x7a, 0x66, 0xc4, 0x3d, 0xc6, 0x77, 0x8b, 0x5d, 0xd8, 0x50, 0x72, 0xce, 0x98, 0x1a, 0xfd, 0xa2,
0x40, 0x65, 0xea, 0x8b, 0x02, 0xb8, 0x3c, 0xbe, 0xa8, 0x41, 0xcf, 0x83, 0xd0, 0xfa, 0xf3, 0xb0,
0x88, 0x30, 0xc9, 0x84, 0x33, 0x96, 0x14, 0x96, 0xae, 0x3c, 0xec, 0x7e, 0x04, 0x90, 0xf5, 0xc6,
0x1e, 0xf6, 0x8c, 0x3d, 0x6c, 0xc7, 0x18, 0x76, 0xc5, 0xdd, 0x11, 0x02, 0x43, 0x4e, 0xa1, 0xf6,
0x8f, 0x7d, 0x13, 0x98, 0x32, 0xac, 0x50, 0x24, 0xd7, 0x78, 0xc8, 0x53, 0x75, 0xc1, 0x60, 0x59,
0xe6, 0x3c, 0xd6, 0x19, 0xea, 0x8e, 0x4c, 0x56, 0x4b, 0x26, 0x77, 0x24, 0xc5, 0xe5, 0xe5, 0x8e,
0x2c, 0xea, 0xe9, 0x7c, 0xb7, 0x0b, 0x9d, 0x1d, 0x8e, 0xb5, 0x6d, 0x0d, 0x87, 0xb9, 0xee, 0xe0,
0xc9, 0xb8, 0x24, 0x4f, 0x1e, 0x9b, 0xbf, 0x0b, 0x57, 0xb6, 0xc4, 0x5d, 0x82, 0x5f, 0x57, 0xa8,
0xa9, 0xdb, 0x81, 0xb5, 0x7c, 0x95, 0xb2, 0xb1, 0x87, 0xb0, 0xbc, 0xc3, 0x8f, 0x27, 0xa7, 0xfb,
0xfc, 0x3c, 0x6b, 0x88, 0x41, 0x2d, 0x39, 0x8b, 0x5e, 0xc9, 0xf9, 0xa1, 0xdf, 0xec, 0x5d, 0x80,
0x21, 0x96, 0xe9, 0x25, 0x63, 0xde, 0x57, 0xf7, 0x44, 0x09, 0x39, 0x1a, 0xf3, 0xbe, 0xfb, 0x11,
0x30, 0xb3, 0x1e, 0x39, 0x5f, 0xa8, 0xca, 0x4e, 0x8e, 0x7b, 0xc9, 0x45, 0x92, 0xf2, 0x91, 0xba,
0x00, 0x6b, 0x42, 0xee, 0x6d, 0x68, 0x1d, 0xfa, 0x17, 0x1e, 0xff, 0x89, 0x7c, 0xc1, 0x62, 0x1d,
0xe6, 0xc7, 0xfe, 0x05, 0xf2, 0xb3, 0xb6, 0xb6, 0x53, 0xb6, 0xfb, 0xbf, 0x2b, 0x30, 0x27, 0x4a,
0x62, 0xad, 0x03, 0x9e, 0xa4, 0x41, 0x48, 0x3c, 0xa6, 0x6a, 0x35, 0xa0, 0x82, 0xc0, 0xac, 0x94,
0x08, 0x4c, 0x69, 0x02, 0x52, 0xf7, 0xed, 0x24, 0xc9, 0x5a, 0x18, 0x8a, 0xad, 0x2c, 0x66, 0x5c,
0x50, 0x6a, 0x06, 0xe4, 0xbc, 0x48, 0x99, 0xc2, 0x2c, 0xfa, 0xa7, 0xf6, 0x02, 0x29, 0x13, 0x4d,
0xa8, 0x54, 0x2d, 0x9f, 0x17, 0xa2, 0xb3, 0xa0, 0x96, 0x17, 0xd4, 0xef, 0xfa, 0x5b, 0xa8, 0xdf,
0xc2, 0x2e, 0xf4, 0x26, 0xf5, 0x1b, 0xde, 0x42, 0xfd, 0x76, 0x19, 0xb4, 0xe9, 0x32, 0x3f, 0x1e,
0xf1, 0x14, 0xed, 0xfe, 0x03, 0x07, 0xda, 0x92, 0x8a, 0x74, 0x9e, 0xf2, 0x47, 0xbe, 0xe9, 0xd6,
0xd7, 0x4d, 0x58, 0xa0, 0x03, 0xa6, 0x96, 0xa7, 0xd2, 0xb7, 0x67, 0x81, 0x38, 0x0e, 0x15, 0x6d,
0x34, 0x0a, 0x86, 0x72, 0x51, 0x4c, 0x48, 0x89, 0xe4, 0xd8, 0x97, 0xb1, 0xcf, 0x8e, 0xa7, 0xd3,
0xee, 0x1f, 0x3b, 0xb0, 0x6c, 0x74, 0x58, 0x52, 0xe1, 0xa7, 0xd0, 0xd2, 0x6f, 0x66, 0x70, 0xad,
0x31, 0xac, 0xdb, 0x6c, 0x93, 0x7d, 0x66, 0x15, 0xa6, 0xc5, 0xf4, 0x2f, 0xa8, 0x83, 0xc9, 0x64,
0x24, 0xb7, 0x6a, 0x13, 0x42, 0x42, 0x7a, 0xc5, 0xf9, 0x4b, 0x5d, 0x44, 0x28, 0x0b, 0x16, 0x46,
0x86, 0x79, 0x3c, 0x18, 0xeb, 0x42, 0x35, 0x69, 0x98, 0x37, 0x41, 0xf7, 0xaf, 0x56, 0x60, 0x45,
0x58, 0x3a, 0xa4, 0x85, 0x49, 0x5f, 0x5b, 0x9e, 0x13, 0x46, 0x1f, 0xc1, 0x91, 0x7b, 0x33, 0x9e,
0x4c, 0xb3, 0xef, 0xbc, 0xa5, 0x75, 0x46, 0x07, 0x64, 0x4f, 0x59, 0x8b, 0x6a, 0xd9, 0x5a, 0xbc,
0x61, 0xa6, 0xcb, 0x7c, 0x24, 0xb3, 0xe5, 0x3e, 0x92, 0xb7, 0xf2, 0x49, 0x3c, 0x98, 0x87, 0xd9,
0xa4, 0x1f, 0x8d, 0xb9, 0xbb, 0x06, 0xab, 0xf6, 0x14, 0x48, 0x41, 0xf5, 0x73, 0x07, 0x3a, 0x0f,
0x85, 0xe7, 0x35, 0x08, 0x4f, 0xf7, 0x82, 0x24, 0x8d, 0x62, 0xfd, 0x06, 0xc4, 0x75, 0x80, 0x24,
0xf5, 0x63, 0x79, 0x52, 0x10, 0xfa, 0x96, 0x81, 0xe0, 0x48, 0x78, 0x38, 0x10, 0xb9, 0x62, 0x05,
0x75, 0xba, 0xa0, 0xcf, 0x4a, 0x6b, 0x8d, 0xa5, 0x15, 0xde, 0x12, 0xd7, 0x18, 0xb0, 0xcb, 0xfc,
0x9c, 0xa4, 0xbf, 0x30, 0x81, 0xe4, 0x50, 0xf7, 0xf7, 0x2a, 0xb0, 0x94, 0x75, 0x92, 0x42, 0x6d,
0x6c, 0x19, 0x22, 0x55, 0xc1, 0x4c, 0x86, 0x48, 0xcf, 0x4a, 0x2f, 0x40, 0xdd, 0xd0, 0x30, 0xd8,
0x18, 0x28, 0xbb, 0x09, 0x4d, 0x95, 0x8a, 0x26, 0xa9, 0x71, 0x19, 0xdb, 0x84, 0x45, 0x60, 0x32,
0x6a, 0xa7, 0x52, 0xd3, 0x96, 0x29, 0xba, 0x18, 0x36, 0x4a, 0xe9, 0x4b, 0x31, 0xf3, 0x2a, 0xc9,
0xda, 0x42, 0xad, 0x13, 0xef, 0xe2, 0x90, 0x4a, 0x67, 0xaa, 0x3b, 0x75, 0xfd, 0x88, 0x8d, 0xe6,
0x4c, 0x51, 0x63, 0x16, 0x55, 0x5e, 0xf3, 0x4c, 0x48, 0x1d, 0x98, 0xa3, 0x89, 0xe1, 0x4e, 0xae,
0x79, 0x16, 0xe6, 0xfe, 0x6d, 0x07, 0xae, 0x96, 0x2c, 0xa3, 0xe4, 0xd4, 0x1d, 0x58, 0x3e, 0xd1,
0x99, 0x6a, 0xaa, 0x05, 0xbb, 0xae, 0xa9, 0xf0, 0x12, 0x7b, 0x7a, 0xbd, 0xe2, 0x07, 0x5a, 0xe3,
0x17, 0x8b, 0x67, 0x5d, 0x22, 0x28, 0x66, 0xb8, 0x87, 0xd0, 0xdd, 0x7d, 0x8d, 0x8c, 0xbf, 0x6d,
0x3e, 0x1d, 0xa8, 0x28, 0x6b, 0xb3, 0x20, 0xd8, 0x2e, 0xb7, 0xd3, 0x9d, 0xc0, 0x82, 0x55, 0x17,
0xfb, 0xd6, 0xdb, 0x56, 0x62, 0xf2, 0xe8, 0x0d, 0xb9, 0xea, 0xe2, 0xed, 0x43, 0x75, 0x95, 0xc1,
0x80, 0xdc, 0x73, 0x58, 0x7a, 0x32, 0x19, 0xa6, 0x41, 0xf6, 0x0e, 0x22, 0xfb, 0x8e, 0xfc, 0x88,
0xaa, 0x50, 0x53, 0x57, 0xda, 0x94, 0x59, 0x0e, 0x67, 0x6c, 0x84, 0x35, 0xf5, 0x8a, 0x2d, 0x16,
0x33, 0xdc, 0xab, 0xb0, 0x9e, 0x35, 0x29, 0xe6, 0x4e, 0x6d, 0x0e, 0xbf, 0xef, 0x88, 0x78, 0x3c,
0xfb, 0x59, 0x46, 0xf6, 0x08, 0x56, 0x92, 0x20, 0x3c, 0x1d, 0x72, 0xb3, 0x9e, 0x44, 0xce, 0xc4,
0x15, 0xbb, 0x7b, 0xf2, 0xe9, 0x46, 0xaf, 0xec, 0x0b, 0x24, 0x90, 0xf2, 0x8e, 0x66, 0x04, 0x92,
0x9b, 0x92, 0xb2, 0x01, 0x7c, 0x06, 0x8b, 0x76, 0x63, 0xec, 0x63, 0x79, 0x03, 0x21, 0xeb, 0x99,
0xe9, 0x58, 0xb3, 0x29, 0xc3, 0x2a, 0xe9, 0xfe, 0xcc, 0x81, 0x8e, 0xc7, 0x91, 0x8c, 0xb9, 0xd1,
0xa8, 0xa4, 0x9e, 0x4f, 0x0b, 0xd5, 0x4e, 0x1f, 0xb0, 0xbe, 0xd9, 0xa0, 0xc6, 0xba, 0x31, 0x75,
0x51, 0xf6, 0x66, 0x4a, 0x46, 0xf5, 0xa0, 0x0e, 0x73, 0x72, 0x7c, 0xeb, 0x70, 0x45, 0x76, 0x49,
0x75, 0x27, 0xf3, 0xc8, 0x58, 0x8d, 0x5a, 0x1e, 0x99, 0x2e, 0x74, 0xc4, 0x53, 0x1f, 0xe6, 0x38,
0xe4, 0x87, 0x3b, 0xc0, 0x9e, 0xf8, 0x7d, 0x3f, 0x8e, 0xa2, 0xf0, 0x90, 0xc7, 0x32, 0x80, 0x8a,
0x14, 0x20, 0x72, 0x58, 0x28, 0x5d, 0x4d, 0xa4, 0xd4, 0xeb, 0x14, 0x51, 0xa8, 0x5e, 0x01, 0x11,
0x29, 0xd7, 0x83, 0x95, 0x07, 0xfe, 0x4b, 0xae, 0x6a, 0xca, 0x66, 0xa9, 0x39, 0xd6, 0x95, 0xaa,
0xb9, 0x57, 0x97, 0x8b, 0x8a, 0xcd, 0x7a, 0x66, 0x69, 0x77, 0x13, 0x56, 0xed, 0x3a, 0xa5, 0x28,
0xe9, 0x42, 0x7d, 0x24, 0x31, 0xd9, 0x3b, 0x9d, 0xbe, 0xfb, 0x25, 0x34, 0x8d, 0xe7, 0x5b, 0xd8,
0x3a, 0xac, 0xbc, 0x78, 0xfc, 0xec, 0x60, 0xf7, 0xe8, 0xa8, 0x77, 0xf8, 0xfc, 0xc1, 0xe7, 0xbb,
0xdf, 0xef, 0xed, 0x6d, 0x1d, 0xed, 0xb5, 0x67, 0xd8, 0x1a, 0xb0, 0x83, 0xdd, 0xa3, 0x67, 0xbb,
0x3b, 0x16, 0xee, 0xb0, 0xeb, 0xd0, 0x7d, 0x7e, 0xf0, 0xfc, 0x68, 0x77, 0xa7, 0x57, 0xf6, 0x5d,
0x85, 0xbd, 0x0b, 0x57, 0x65, 0x7e, 0xc9, 0xe7, 0xd5, 0xbb, 0x9f, 0x42, 0x3b, 0x6f, 0x58, 0xb2,
0x0c, 0x72, 0x6f, 0xb2, 0xdc, 0x6d, 0xfe, 0xac, 0x0a, 0x8b, 0x22, 0x42, 0x52, 0x3c, 0x6c, 0xca,
0x63, 0xf6, 0x04, 0xe6, 0xe5, 0x0b, 0xb9, 0x4c, 0x91, 0x96, 0xfd, 0x26, 0x6f, 0x77, 0x2d, 0x0f,
0xcb, 0x65, 0x5d, 0xf9, 0x6b, 0xff, 0xe9, 0x7f, 0xfc, 0xdd, 0xca, 0x02, 0x6b, 0xde, 0x3b, 0xff,
0xf0, 0xde, 0x29, 0x0f, 0x13, 0xac, 0xe3, 0x77, 0x00, 0xb2, 0x77, 0x5f, 0x59, 0x47, 0x1b, 0x56,
0x72, 0x8f, 0xe2, 0x76, 0xaf, 0x96, 0xe4, 0xc8, 0x7a, 0xaf, 0x52, 0xbd, 0x2b, 0xee, 0x22, 0xd6,
0x1b, 0x84, 0x41, 0x2a, 0xde, 0x80, 0xfd, 0xc4, 0xb9, 0xcb, 0x06, 0xd0, 0x32, 0x5f, 0x64, 0x65,
0xca, 0xc1, 0x56, 0xf2, 0xa6, 0x6c, 0xf7, 0x9d, 0xd2, 0x3c, 0x45, 0xcb, 0xd4, 0xc6, 0x15, 0xb7,
0x8d, 0x6d, 0x4c, 0xa8, 0x44, 0xd6, 0xca, 0x50, 0x70, 0x78, 0xf6, 0xf0, 0x2a, 0xbb, 0x66, 0x30,
0x5d, 0xe1, 0xd9, 0xd7, 0xee, 0xbb, 0x53, 0x72, 0x65, 0x5b, 0xef, 0x52, 0x5b, 0xeb, 0x2e, 0xc3,
0xb6, 0xfa, 0x54, 0x46, 0x3d, 0xfb, 0xfa, 0x89, 0x73, 0x77, 0xf3, 0xdf, 0xdf, 0x86, 0x86, 0x76,
0xbe, 0xb3, 0x1f, 0xc3, 0x82, 0x15, 0xc2, 0xca, 0xd4, 0x30, 0xca, 0x22, 0x5e, 0xbb, 0xd7, 0xca,
0x33, 0x65, 0xc3, 0xd7, 0xa9, 0xe1, 0x0e, 0x5b, 0xc3, 0x86, 0x65, 0x0c, 0xe8, 0x3d, 0x0a, 0xc6,
0x16, 0xf7, 0x39, 0x5f, 0x1a, 0x92, 0x4c, 0x34, 0x76, 0x2d, 0x2f, 0x5c, 0xac, 0xd6, 0xde, 0x9d,
0x92, 0x2b, 0x9b, 0xbb, 0x46, 0xcd, 0xad, 0xb1, 0x55, 0xb3, 0x39, 0xed, 0x10, 0xe7, 0x74, 0x89,
0xd9, 0x7c, 0x93, 0x94, 0xbd, 0xab, 0x09, 0xab, 0xec, 0xad, 0x52, 0x4d, 0x22, 0xc5, 0x07, 0x4b,
0xdd, 0x0e, 0x35, 0xc5, 0x18, 0x2d, 0x9f, 0xf9, 0x24, 0x29, 0x3b, 0x86, 0xa6, 0xf1, 0x92, 0x18,
0xbb, 0x3a, 0xf5, 0xd5, 0xb3, 0x6e, 0xb7, 0x2c, 0xab, 0x6c, 0x28, 0x66, 0xfd, 0xf7, 0x50, 0xd1,
0xf9, 0x21, 0x34, 0xf4, 0xdb, 0x54, 0x6c, 0xdd, 0x78, 0x2b, 0xcc, 0x7c, 0x4b, 0xab, 0xdb, 0x29,
0x66, 0x94, 0x11, 0x9f, 0x59, 0x3b, 0x12, 0xdf, 0x0b, 0x68, 0x1a, 0xef, 0x4f, 0xe9, 0x01, 0x14,
0xdf, 0xb8, 0xd2, 0x03, 0x28, 0x79, 0xae, 0xca, 0x5d, 0xa6, 0x26, 0x9a, 0xac, 0x41, 0xf4, 0x9d,
0xbe, 0x8e, 0x12, 0xb6, 0x0f, 0x57, 0xa4, 0xc4, 0x3e, 0xe6, 0x5f, 0x65, 0x19, 0x4a, 0x9e, 0x81,
0xbd, 0xef, 0xb0, 0x4f, 0xa1, 0xae, 0x9e, 0x19, 0x63, 0x6b, 0xe5, 0xcf, 0xa5, 0x75, 0xd7, 0x0b,
0xb8, 0x14, 0xaf, 0xdf, 0x07, 0xc8, 0x1e, 0xbb, 0xd2, 0x42, 0xa2, 0xf0, 0x78, 0x96, 0xa6, 0x80,
0xe2, 0xcb, 0x58, 0xee, 0x1a, 0x0d, 0xb0, 0xcd, 0x48, 0x48, 0x84, 0xfc, 0x95, 0x7a, 0xaf, 0xe0,
0x47, 0xd0, 0x34, 0xde, 0xbb, 0xd2, 0xd3, 0x57, 0x7c, 0x2b, 0x4b, 0x4f, 0x5f, 0xc9, 0xf3, 0x58,
0x6e, 0x97, 0x6a, 0x5f, 0x75, 0x97, 0xb0, 0xf6, 0x24, 0x38, 0x0d, 0x47, 0xa2, 0x00, 0x2e, 0xd0,
0x19, 0x2c, 0x58, 0x8f, 0x5a, 0x69, 0x0e, 0x2d, 0x7b, 0x32, 0x4b, 0x73, 0x68, 0xe9, 0x3b, 0x58,
0x8a, 0xce, 0xdc, 0x65, 0x6c, 0xe7, 0x9c, 0x8a, 0x18, 0x2d, 0xfd, 0x00, 0x9a, 0xc6, 0x03, 0x55,
0x7a, 0x2c, 0xc5, 0xb7, 0xb0, 0xf4, 0x58, 0xca, 0xde, 0xb3, 0x5a, 0xa5, 0x36, 0x16, 0x5d, 0x22,
0x05, 0xba, 0x79, 0x8f, 0x75, 0xff, 0x18, 0x16, 0xed, 0x27, 0xab, 0x34, 0xef, 0x97, 0x3e, 0x7e,
0xa5, 0x79, 0x7f, 0xca, 0x3b, 0x57, 0x92, 0xa4, 0xef, 0xae, 0xe8, 0x46, 0xee, 0x7d, 0x21, 0xc3,
0xf7, 0xbe, 0x64, 0xdf, 0x45, 0x01, 0x27, 0x9f, 0x42, 0x60, 0xeb, 0x06, 0xd5, 0x9a, 0x0f, 0x26,
0x68, 0x7e, 0x29, 0xbc, 0x9a, 0x60, 0x13, 0xb3, 0x78, 0x3b, 0x80, 0x76, 0x2d, 0x7a, 0x12, 0xc1,
0xd8, 0xb5, 0xcc, 0x57, 0x13, 0x8c, 0x5d, 0xcb, 0x7a, 0x39, 0x21, 0xbf, 0x6b, 0xa5, 0x01, 0xd6,
0x11, 0xc2, 0x52, 0xee, 0x9a, 0x8d, 0xe6, 0x8a, 0xf2, 0x9b, 0x90, 0xdd, 0xeb, 0x6f, 0xbe, 0x9d,
0x63, 0x4b, 0x10, 0x25, 0x04, 0xef, 0xa9, 0x7b, 0xa7, 0xbf, 0x0b, 0x2d, 0xf3, 0x19, 0x1d, 0x66,
0xb2, 0x72, 0xbe, 0xa5, 0x77, 0x4a, 0xf3, 0xec, 0xc5, 0x65, 0x2d, 0xb3, 0x19, 0xf6, 0x3d, 0x58,
0xd3, 0xac, 0x6e, 0xde, 0xdc, 0x48, 0xd8, 0x7b, 0x25, 0xf7, 0x39, 0x4c, 0x3d, 0xae, 0x7b, 0x75,
0xea, 0x85, 0x8f, 0xfb, 0x0e, 0x12, 0x8d, 0xfd, 0x36, 0x49, 0xb6, 0x61, 0x94, 0x3d, 0xc9, 0x92,
0x6d, 0x18, 0xa5, 0x0f, 0x9a, 0x28, 0xa2, 0x61, 0x2b, 0xd6, 0x1c, 0x89, 0x48, 0x07, 0xf6, 0x03,
0x58, 0x32, 0xee, 0xc6, 0x1d, 0x5d, 0x84, 0x7d, 0xcd, 0x00, 0xc5, 0xab, 0xdb, 0xdd, 0xb2, 0x53,
0x8a, 0xbb, 0x4e, 0xf5, 0x2f, 0xbb, 0xd6, 0xe4, 0x20, 0xf1, 0x6f, 0x43, 0xd3, 0xbc, 0x77, 0xf7,
0x86, 0x7a, 0xd7, 0x8d, 0x2c, 0xf3, 0xd6, 0xf1, 0x7d, 0x87, 0x1d, 0x8a, 0x88, 0x37, 0xfd, 0x4e,
0x6a, 0x14, 0xe7, 0xb7, 0x4f, 0xfb, 0xfd, 0x54, 0xbd, 0x90, 0x65, 0x2f, 0xe7, 0xde, 0x71, 0xee,
0x3b, 0xec, 0x1f, 0x3a, 0xd0, 0xb2, 0xee, 0xc5, 0x59, 0xf1, 0x43, 0xb9, 0x9e, 0x75, 0xcc, 0x3c,
0xb3, 0x6b, 0xae, 0x47, 0xc3, 0xde, 0xbf, 0xfb, 0x99, 0x35, 0xad, 0x5f, 0x58, 0x06, 0xb5, 0x8d,
0xfc, 0x63, 0xa9, 0x5f, 0xe6, 0x0b, 0x98, 0x17, 0xe6, 0xbf, 0xbc, 0xef, 0xb0, 0x3f, 0x74, 0x60,
0xd1, 0x36, 0x03, 0xeb, 0xe1, 0x96, 0x1a, 0x9c, 0xf5, 0xe2, 0x4f, 0xb1, 0x1d, 0xff, 0x80, 0x7a,
0xf9, 0xec, 0xae, 0x67, 0xf5, 0x52, 0xbe, 0x83, 0xf3, 0xab, 0xf5, 0x96, 0x7d, 0x22, 0x1e, 0x0b,
0x57, 0x1e, 0x30, 0x56, 0x7c, 0x67, 0x5a, 0x13, 0x8c, 0xf9, 0x32, 0x34, 0x2d, 0xc2, 0x8f, 0xc4,
0x23, 0xa1, 0xca, 0x8d, 0x82, 0x74, 0xf7, 0xb6, 0xdf, 0xbb, 0x37, 0x69, 0x4c, 0xd7, 0xdd, 0xab,
0xd6, 0x98, 0xf2, 0x3b, 0xfc, 0x96, 0xe8, 0x9d, 0x7c, 0xd4, 0x39, 0xdb, 0xa2, 0x0a, 0x0f, 0x3d,
0x4f, 0xef, 0xe4, 0x48, 0x74, 0x52, 0x16, 0xb7, 0x98, 0xe3, 0x2d, 0xab, 0x71, 0xef, 0x52, 0x5f,
0x6f, 0xba, 0xef, 0x4d, 0xed, 0xeb, 0x3d, 0x32, 0xe6, 0x62, 0x8f, 0x0f, 0x01, 0x32, 0x8f, 0x35,
0xcb, 0x79, 0x4b, 0xb5, 0xc8, 0x28, 0x3a, 0xb5, 0x6d, 0x0e, 0x54, 0x4e, 0x55, 0xac, 0xf1, 0x87,
0x42, 0x00, 0x3e, 0x56, 0x7e, 0x56, 0x53, 0xcd, 0xb1, 0xdd, 0xca, 0x96, 0x9a, 0x93, 0xaf, 0xdf,
0x12, 0x7f, 0xda, 0x69, 0xfb, 0x1c, 0x16, 0xf6, 0xa3, 0xe8, 0xe5, 0x64, 0xac, 0x43, 0x7b, 0x6c,
0x3f, 0xcb, 0x9e, 0x9f, 0x9c, 0x75, 0x73, 0xa3, 0x70, 0x6f, 0x50, 0x55, 0x5d, 0xd6, 0x31, 0xaa,
0xba, 0xf7, 0x45, 0xe6, 0x0d, 0xff, 0x92, 0xf9, 0xb0, 0xac, 0xa5, 0xaa, 0xee, 0x78, 0xd7, 0xae,
0xc6, 0x92, 0xa5, 0xf9, 0x26, 0x2c, 0x7d, 0x5c, 0xf5, 0xf6, 0x5e, 0xa2, 0xea, 0x24, 0x99, 0xd2,
0xda, 0xe1, 0x7d, 0xba, 0xda, 0x43, 0xce, 0x8a, 0x95, 0xac, 0xe3, 0xda, 0xcb, 0xd1, 0x5d, 0xb0,
0x40, 0x7b, 0xa7, 0x19, 0xfb, 0x17, 0x31, 0xff, 0xc9, 0xbd, 0x2f, 0xa4, 0x1b, 0xe4, 0x4b, 0xb5,
0xd3, 0x28, 0x3f, 0x91, 0xb5, 0xd3, 0xe4, 0x1c, 0x4b, 0xd6, 0x4e, 0x53, 0x70, 0x2c, 0x59, 0x53,
0xad, 0xfc, 0x54, 0x6c, 0x08, 0xcb, 0x05, 0x5f, 0x94, 0xde, 0x64, 0xa6, 0x79, 0xb0, 0xba, 0x37,
0xa6, 0x17, 0xb0, 0x5b, 0xbb, 0x6b, 0xb7, 0x76, 0x04, 0x0b, 0x3b, 0x5c, 0x4c, 0x96, 0x88, 0x65,
0xce, 0x5d, 0xae, 0x34, 0x23, 0xa5, 0xf3, 0x5b, 0x02, 0xe5, 0xd9, 0xaa, 0x04, 0x05, 0x11, 0xb3,
0x1f, 0x42, 0xf3, 0x11, 0x4f, 0x55, 0xf0, 0xb2, 0x56, 0x66, 0x73, 0xd1, 0xcc, 0xdd, 0x92, 0xd8,
0x67, 0x9b, 0x66, 0xa8, 0xb6, 0x7b, 0x7c, 0x70, 0xca, 0x85, 0x70, 0xea, 0x05, 0x83, 0x2f, 0xd9,
0x5f, 0xa2, 0xca, 0xf5, 0xed, 0x8d, 0x35, 0x23, 0x12, 0xd5, 0xac, 0x7c, 0x29, 0x87, 0x97, 0xd5,
0x1c, 0x46, 0x03, 0x6e, 0x28, 0x55, 0x21, 0x34, 0x8d, 0x4b, 0x57, 0x9a, 0x81, 0x8a, 0xd7, 0xfb,
0x34, 0x03, 0x95, 0xdc, 0xd1, 0x72, 0xef, 0x50, 0x3b, 0x2e, 0xbb, 0x91, 0xb5, 0x23, 0xee, 0x65,
0x65, 0x2d, 0xdd, 0xfb, 0xc2, 0x1f, 0xa5, 0x5f, 0xb2, 0x17, 0xf4, 0x2e, 0x95, 0x19, 0x9c, 0x9d,
0x69, 0xe7, 0xf9, 0x38, 0x6e, 0x3d, 0x59, 0x46, 0x96, 0xad, 0xb1, 0x8b, 0xa6, 0x48, 0xf7, 0xfa,
0x0e, 0xc0, 0x51, 0x1a, 0x8d, 0x77, 0x7c, 0x3e, 0x8a, 0xc2, 0x4c, 0xd6, 0x66, 0xa1, 0xc1, 0x99,
0xfc, 0x32, 0xe2, 0x83, 0xd9, 0x0b, 0xe3, 0x38, 0x63, 0xc5, 0xb7, 0x2b, 0xe2, 0x9a, 0x1a, 0x3d,
0xac, 0x27, 0xa4, 0x24, 0x82, 0xf8, 0xbe, 0xc3, 0xb6, 0x00, 0x32, 0x67, 0xa4, 0x3e, 0x9c, 0x14,
0xfc, 0x9c, 0x5a, 0xec, 0x95, 0x78, 0x2e, 0x0f, 0xa1, 0x91, 0x79, 0xb7, 0xd6, 0xb3, 0xab, 0x8d,
0x96, 0x2f, 0x4c, 0xef, 0xe0, 0x05, 0x9f, 0x93, 0xdb, 0xa6, 0xa9, 0x02, 0x56, 0xc7, 0xa9, 0x22,
0x47, 0x52, 0x00, 0x2b, 0xa2, 0x83, 0x5a, 0xc1, 0xa1, 0x90, 0x56, 0x35, 0x92, 0x12, 0xbf, 0x8f,
0xe6, 0xe6, 0x52, 0x87, 0x88, 0x65, 0x63, 0x41, 0x6a, 0x15, 0xe1, 0xb4, 0x28, 0x9a, 0x47, 0xb0,
0x5c, 0xb0, 0xb1, 0x6b, 0x96, 0x9e, 0xe6, 0x44, 0xd1, 0x2c, 0x3d, 0xd5, 0x3c, 0xef, 0x5e, 0xa1,
0x26, 0x97, 0x5c, 0xa0, 0x33, 0xd5, 0xab, 0x20, 0xed, 0x9f, 0x61, 0x73, 0xbf, 0xef, 0xc0, 0x4a,
0x89, 0x09, 0x9d, 0xbd, 0xaf, 0x8e, 0xe7, 0x53, 0xcd, 0xeb, 0xdd, 0x52, 0x0b, 0xab, 0x7b, 0x44,
0xed, 0x3c, 0x61, 0x9f, 0x5b, 0x1b, 0x9b, 0x30, 0x6e, 0x4a, 0xce, 0x7c, 0xa3, 0x52, 0x51, 0xaa,
0x51, 0xfc, 0x04, 0xd6, 0x45, 0x47, 0xb6, 0x86, 0xc3, 0x9c, 0xf5, 0xf7, 0x7a, 0xe1, 0x1f, 0x0a,
0x59, 0x56, 0xed, 0xee, 0xf4, 0x7f, 0x38, 0x34, 0x45, 0x01, 0x16, 0x5d, 0x65, 0x13, 0x68, 0xe7,
0x2d, 0xaa, 0x6c, 0x7a, 0x5d, 0xdd, 0xf7, 0xac, 0x83, 0x66, 0x89, 0x15, 0xf6, 0x37, 0xa8, 0xb1,
0xf7, 0xdc, 0x6e, 0xd9, 0xbc, 0x88, 0xb3, 0x27, 0xae, 0xc7, 0x5f, 0xd1, 0xe6, 0xdf, 0xdc, 0x38,
0x55, 0x03, 0xd3, 0xec, 0xd5, 0xfa, 0xa8, 0x5b, 0x6e, 0x3d, 0xbe, 0x45, 0xcd, 0xdf, 0x70, 0xdf,
0x29, 0x6b, 0x3e, 0x16, 0x9f, 0x88, 0x43, 0xef, 0x7a, 0x9e, 0xaf, 0x55, 0x0f, 0x6e, 0x94, 0xad,
0xf7, 0xd4, 0xd3, 0x4b, 0x6e, 0xae, 0x67, 0x48, 0xb7, 0x6b, 0x99, 0xe6, 0x5e, 0xcd, 0x3e, 0x25,
0x76, 0x65, 0xcd, 0x3e, 0x65, 0xf6, 0x61, 0x5b, 0xaf, 0x51, 0x96, 0xe1, 0x4f, 0x9c, 0xbb, 0x0f,
0x6e, 0xff, 0xe0, 0x37, 0x4e, 0x83, 0xf4, 0x6c, 0x72, 0xbc, 0xd1, 0x8f, 0x46, 0xf7, 0x86, 0xca,
0xac, 0x27, 0xaf, 0x79, 0xdc, 0x1b, 0x86, 0x83, 0x7b, 0x54, 0xed, 0xf1, 0x1c, 0xfd, 0x07, 0xb4,
0x6f, 0xfd, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa4, 0x9a, 0x49, 0x69, 0x33, 0x6d, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

5
lnrpc/rpc.proto
View File

@ -2217,10 +2217,7 @@ message Invoice {
*/
string memo = 1 [json_name = "memo"];
/** Deprecated. An optional cryptographic receipt of payment which is not
implemented.
*/
bytes receipt = 2 [json_name = "receipt", deprecated = true];
reserved 2;
/**
The hex-encoded preimage (32 byte) which will allow settling an incoming

5
lnrpc/rpc.swagger.json
View File

@ -2660,11 +2660,6 @@
"type": "string",
"description": "*\nAn optional memo to attach along with the invoice. Used for record keeping\npurposes for the invoice's creator, and will also be set in the description\nfield of the encoded payment request if the description_hash field is not\nbeing used."
},
"receipt": {
"type": "string",
"format": "byte",
"description": "* Deprecated. An optional cryptographic receipt of payment which is not\nimplemented."
},
"r_preimage": {
"type": "string",
"format": "byte",

28
lnwire/features.go
View File

@ -216,8 +216,16 @@ func (fv *RawFeatureVector) Encode(w io.Writer) error {
return fv.encode(w, length, 8)
}
// EncodeBase256 writes the feature vector in base256 representation. Every
// feature is encoded as a bit, and the bit vector is serialized using the least
// number of bytes.
func (fv *RawFeatureVector) EncodeBase256(w io.Writer) error {
length := fv.SerializeSize()
return fv.encode(w, length, 8)
}
// EncodeBase32 writes the feature vector in base32 representation. Every feature
// encoded as a bit, and the bit vector is serialized using the least number of
// is encoded as a bit, and the bit vector is serialized using the least number of
// bytes.
func (fv *RawFeatureVector) EncodeBase32(w io.Writer) error {
length := fv.SerializeSize32()
@ -239,8 +247,8 @@ func (fv *RawFeatureVector) encode(w io.Writer, length, width int) error {
}
// Decode reads the feature vector from its byte representation. Every feature
// encoded as a bit, and the bit vector is serialized using the least number of
// bytes. Since the bit vector length is variable, the first two bytes of the
// is encoded as a bit, and the bit vector is serialized using the least number
// of bytes. Since the bit vector length is variable, the first two bytes of the
// serialization represent the length.
func (fv *RawFeatureVector) Decode(r io.Reader) error {
// Read the length of the feature vector.
@ -253,6 +261,13 @@ func (fv *RawFeatureVector) Decode(r io.Reader) error {
return fv.decode(r, int(length), 8)
}
// DecodeBase256 reads the feature vector from its base256 representation. Every
// feature encoded as a bit, and the bit vector is serialized using the least
// number of bytes.
func (fv *RawFeatureVector) DecodeBase256(r io.Reader, length int) error {
return fv.decode(r, length, 8)
}
// DecodeBase32 reads the feature vector from its base32 representation. Every
// feature encoded as a bit, and the bit vector is serialized using the least
// number of bytes.
@ -356,3 +371,10 @@ func (fv *FeatureVector) isFeatureBitPair(bit FeatureBit) bool {
name2, known2 := fv.featureNames[bit^1]
return known1 && known2 && name1 == name2
}
// Clone copies a feature vector, carrying over its feature bits. The feature
// names are not copied.
func (fv *FeatureVector) Clone() *FeatureVector {
features := fv.RawFeatureVector.Clone()
return NewFeatureVector(features, fv.featureNames)
}

1
rpcserver.go
View File

@ -3599,7 +3599,6 @@ func (r *rpcServer) AddInvoice(ctx context.Context,
addInvoiceData := &invoicesrpc.AddInvoiceData{
Memo: invoice.Memo,
Receipt: invoice.Receipt,
Value: value,
DescriptionHash: invoice.DescriptionHash,
Expiry: invoice.Expiry,

8
zpay32/invoice.go
View File

@ -242,6 +242,14 @@ func RouteHint(routeHint []HopHint) func(*Invoice) {
}
}
// Features is a functional option that allows callers of NewInvoice to set the
// desired feature bits that are advertised on the invoice.
func Features(features *lnwire.FeatureVector) func(*Invoice) {
return func(i *Invoice) {
i.Features = features
}
}
// NewInvoice creates a new Invoice object. The last parameter is a set of
// variadic arguments for setting optional fields of the invoice.
//