Merge pull request #4157 from carlaKC/2472-newbucketforresolutions

contractcourt: Persist Resolution Outcomes

channeldb/db.go

@@ -157,6 +157,12 @@ var (
 			number:    16,
 			migration: migration16.MigrateSequenceIndex,
 		},
+		{
+			// Create a top level bucket which will store extra
+			// information about channel closes.
+			number:    17,
+			migration: mig.CreateTLB(closeSummaryBucket),
+		},
 	}
 
 	// Big endian is the preferred byte order, due to cursor scans over
@@ -277,6 +283,7 @@ var topLevelBuckets = [][]byte{
 	edgeIndexBucket,
 	graphMetaBucket,
 	metaBucket,
+	closeSummaryBucket,
 }
 
 // Wipe completely deletes all saved state within all used buckets within the

channeldb/reports.go

@@ -0,0 +1,352 @@
+package channeldb
+
+import (
+	"bytes"
+	"errors"
+	"io"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
+	"github.com/lightningnetwork/lnd/tlv"
+)
+
+var (
+	// closeSummaryBucket is a top level bucket which holds additional
+	// information about channel closes. It nests channels by chainhash
+	// and channel point.
+	// [closeSummaryBucket]
+	//	[chainHashBucket]
+	//		[channelBucket]
+	//			[resolversBucket]
+	closeSummaryBucket = []byte("close-summaries")
+
+	// resolversBucket holds the outcome of a channel's resolvers. It is
+	// nested under a channel and chainhash bucket in the close summaries
+	// bucket.
+	resolversBucket = []byte("resolvers-bucket")
+)
+
+var (
+	// ErrNoChainHashBucket is returned when we have not created a bucket
+	// for the current chain hash.
+	ErrNoChainHashBucket = errors.New("no chain hash bucket")
+
+	// ErrNoChannelSummaries is returned when a channel is not found in the
+	// chain hash bucket.
+	ErrNoChannelSummaries = errors.New("channel bucket not found")
+
+	amountType    tlv.Type = 1
+	resolverType  tlv.Type = 2
+	outcomeType   tlv.Type = 3
+	spendTxIDType tlv.Type = 4
+)
+
+// ResolverType indicates the type of resolver that was resolved on chain.
+type ResolverType uint8
+
+const (
+	// ResolverTypeAnchor represents a resolver for an anchor output.
+	ResolverTypeAnchor ResolverType = 0
+
+	// ResolverTypeIncomingHtlc represents resolution of an incoming htlc.
+	ResolverTypeIncomingHtlc ResolverType = 1
+
+	// ResolverTypeOutgoingHtlc represents resolution of an outgoing htlc.
+	ResolverTypeOutgoingHtlc ResolverType = 2
+
+	// ResolverTypeCommit represents resolution of our time locked commit
+	// when we force close.
+	ResolverTypeCommit ResolverType = 3
+)
+
+// ResolverOutcome indicates the outcome for the resolver that that the contract
+// court reached. This state is not necessarily final, since htlcs on our own
+// commitment are resolved across two resolvers.
+type ResolverOutcome uint8
+
+const (
+	// ResolverOutcomeClaimed indicates that funds were claimed on chain.
+	ResolverOutcomeClaimed ResolverOutcome = 0
+
+	// ResolverOutcomeUnclaimed indicates that we did not claim our funds on
+	// chain. This may be the case for anchors that we did not sweep, or
+	// outputs that were not economical to sweep.
+	ResolverOutcomeUnclaimed ResolverOutcome = 1
+
+	// ResolverOutcomeAbandoned indicates that we did not attempt to claim
+	// an output on chain. This is the case for htlcs that we could not
+	// decode to claim, or invoice which we fail when an attempt is made
+	// to settle them on chain.
+	ResolverOutcomeAbandoned ResolverOutcome = 2
+
+	// ResolverOutcomeTimeout indicates that a contract was timed out on
+	// chain.
+	ResolverOutcomeTimeout ResolverOutcome = 3
+
+	// ResolverOutcomeFirstStage indicates that a htlc had to be claimed
+	// over two stages, with this outcome representing the confirmation
+	// of our success/timeout tx.
+	ResolverOutcomeFirstStage ResolverOutcome = 4
+)
+
+// ResolverReport provides an account of the outcome of a resolver. This differs
+// from a ContractReport because it does not necessarily fully resolve the
+// contract; each step of two stage htlc resolution is included.
+type ResolverReport struct {
+	// OutPoint is the on chain outpoint that was spent as a result of this
+	// resolution. When an output is directly resolved (eg, commitment
+	// sweeps and single stage htlcs on the remote party's output) this
+	// is an output on the commitment tx that was broadcast. When we resolve
+	// across two stages (eg, htlcs on our own force close commit), the
+	// first stage outpoint is the output on our commitment and the second
+	// stage output is the spend from our htlc success/timeout tx.
+	OutPoint wire.OutPoint
+
+	// Amount is the value of the output referenced above.
+	Amount btcutil.Amount
+
+	// ResolverType indicates the type of resolution that occurred.
+	ResolverType
+
+	// ResolverOutcome indicates the outcome of the resolver.
+	ResolverOutcome
+
+	// SpendTxID is the transaction ID of the spending transaction that
+	// claimed the outpoint. This may be a sweep transaction, or a first
+	// stage success/timeout transaction.
+	SpendTxID *chainhash.Hash
+}
+
+// PutResolverReport creates and commits a transaction that is used to write a
+// resolver report to disk.
+func (d *DB) PutResolverReport(tx kvdb.RwTx, chainHash chainhash.Hash,
+	channelOutpoint *wire.OutPoint, report *ResolverReport) error {
+
+	putReportFunc := func(tx kvdb.RwTx) error {
+		return putReport(tx, chainHash, channelOutpoint, report)
+	}
+
+	// If the transaction is nil, we'll create a new one.
+	if tx == nil {
+		return kvdb.Update(d, putReportFunc)
+	}
+
+	// Otherwise, we can write the report to disk using the existing
+	// transaction.
+	return putReportFunc(tx)
+}
+
+// putReport puts a report in the bucket provided, with its outpoint as its key.
+func putReport(tx kvdb.RwTx, chainHash chainhash.Hash,
+	channelOutpoint *wire.OutPoint, report *ResolverReport) error {
+
+	channelBucket, err := fetchReportWriteBucket(
+		tx, chainHash, channelOutpoint,
+	)
+	if err != nil {
+		return err
+	}
+
+	// If the resolvers bucket does not exist yet, create it.
+	resolvers, err := channelBucket.CreateBucketIfNotExists(
+		resolversBucket,
+	)
+	if err != nil {
+		return err
+	}
+
+	var valueBuf bytes.Buffer
+	if err := serializeReport(&valueBuf, report); err != nil {
+		return err
+	}
+
+	// Finally write our outpoint to be used as the key for this record.
+	var keyBuf bytes.Buffer
+	if err := writeOutpoint(&keyBuf, &report.OutPoint); err != nil {
+		return err
+	}
+
+	return resolvers.Put(keyBuf.Bytes(), valueBuf.Bytes())
+}
+
+// serializeReport serialized a report using a TLV stream to allow for optional
+// fields.
+func serializeReport(w io.Writer, report *ResolverReport) error {
+	amt := uint64(report.Amount)
+	resolver := uint8(report.ResolverType)
+	outcome := uint8(report.ResolverOutcome)
+
+	// Create a set of TLV records for the values we know to be present.
+	records := []tlv.Record{
+		tlv.MakePrimitiveRecord(amountType, &amt),
+		tlv.MakePrimitiveRecord(resolverType, &resolver),
+		tlv.MakePrimitiveRecord(outcomeType, &outcome),
+	}
+
+	// If our spend txid is non-nil, we add a tlv entry for it.
+	if report.SpendTxID != nil {
+		var spendBuf bytes.Buffer
+		err := WriteElement(&spendBuf, *report.SpendTxID)
+		if err != nil {
+			return err
+		}
+		spendBytes := spendBuf.Bytes()
+
+		records = append(records, tlv.MakePrimitiveRecord(
+			spendTxIDType, &spendBytes,
+		))
+	}
+
+	// Create our stream and encode it.
+	tlvStream, err := tlv.NewStream(records...)
+	if err != nil {
+		return err
+	}
+
+	return tlvStream.Encode(w)
+}
+
+// FetchChannelReports fetches the set of reports for a channel.
+func (d DB) FetchChannelReports(chainHash chainhash.Hash,
+	outPoint *wire.OutPoint) ([]*ResolverReport, error) {
+
+	var reports []*ResolverReport
+
+	if err := kvdb.View(d, func(tx kvdb.RTx) error {
+		chanBucket, err := fetchReportReadBucket(
+			tx, chainHash, outPoint,
+		)
+		if err != nil {
+			return err
+		}
+
+		// If there are no resolvers for this channel, we simply
+		// return nil, because nothing has been persisted yet.
+		resolvers := chanBucket.NestedReadBucket(resolversBucket)
+		if resolvers == nil {
+			return nil
+		}
+
+		// Run through each resolution and add it to our set of
+		// resolutions.
+		return resolvers.ForEach(func(k, v []byte) error {
+			// Deserialize the contents of our field.
+			r := bytes.NewReader(v)
+			report, err := deserializeReport(r)
+			if err != nil {
+				return err
+			}
+
+			// Once we have read our values out, set the outpoint
+			// on the report using the key.
+			r = bytes.NewReader(k)
+			if err := ReadElement(r, &report.OutPoint); err != nil {
+				return err
+			}
+
+			reports = append(reports, report)
+
+			return nil
+		})
+	}); err != nil {
+		return nil, err
+	}
+
+	return reports, nil
+}
+
+// deserializeReport gets a resolver report from a tlv stream. The outpoint on
+// the resolver will not be set because we key reports by their outpoint, and
+// this function reads only the values saved in the stream.
+func deserializeReport(r io.Reader) (*ResolverReport, error) {
+	var (
+		resolver, outcome uint8
+		amt               uint64
+		spentTx           []byte
+	)
+
+	tlvStream, err := tlv.NewStream(
+		tlv.MakePrimitiveRecord(amountType, &amt),
+		tlv.MakePrimitiveRecord(resolverType, &resolver),
+		tlv.MakePrimitiveRecord(outcomeType, &outcome),
+		tlv.MakePrimitiveRecord(spendTxIDType, &spentTx),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := tlvStream.Decode(r); err != nil {
+		return nil, err
+	}
+
+	report := &ResolverReport{
+		Amount:          btcutil.Amount(amt),
+		ResolverOutcome: ResolverOutcome(outcome),
+		ResolverType:    ResolverType(resolver),
+	}
+
+	// If our spend tx is set, we set it on our report.
+	if len(spentTx) != 0 {
+		spendTx, err := chainhash.NewHash(spentTx)
+		if err != nil {
+			return nil, err
+		}
+		report.SpendTxID = spendTx
+	}
+
+	return report, nil
+}
+
+// fetchReportWriteBucket returns a write channel bucket within the reports
+// top level bucket. If the channel's bucket does not yet exist, it will be
+// created.
+func fetchReportWriteBucket(tx kvdb.RwTx, chainHash chainhash.Hash,
+	outPoint *wire.OutPoint) (kvdb.RwBucket, error) {
+
+	// Get the channel close summary bucket.
+	closedBucket := tx.ReadWriteBucket(closeSummaryBucket)
+
+	// Create the chain hash bucket if it does not exist.
+	chainHashBkt, err := closedBucket.CreateBucketIfNotExists(chainHash[:])
+	if err != nil {
+		return nil, err
+	}
+
+	var chanPointBuf bytes.Buffer
+	if err := writeOutpoint(&chanPointBuf, outPoint); err != nil {
+		return nil, err
+	}
+
+	return chainHashBkt.CreateBucketIfNotExists(chanPointBuf.Bytes())
+}
+
+// fetchReportReadBucket returns a read channel bucket within the reports
+// top level bucket. If any bucket along the way does not exist, it will error.
+func fetchReportReadBucket(tx kvdb.RTx, chainHash chainhash.Hash,
+	outPoint *wire.OutPoint) (kvdb.RBucket, error) {
+
+	// First fetch the top level channel close summary bucket.
+	closeBucket := tx.ReadBucket(closeSummaryBucket)
+
+	// Next we get the chain hash bucket for our current chain.
+	chainHashBucket := closeBucket.NestedReadBucket(chainHash[:])
+	if chainHashBucket == nil {
+		return nil, ErrNoChainHashBucket
+	}
+
+	// With the bucket for the node and chain fetched, we can now go down
+	// another level, for the channel itself.
+	var chanPointBuf bytes.Buffer
+	if err := writeOutpoint(&chanPointBuf, outPoint); err != nil {
+		return nil, err
+	}
+
+	chanBucket := chainHashBucket.NestedReadBucket(chanPointBuf.Bytes())
+	if chanBucket == nil {
+		return nil, ErrNoChannelSummaries
+	}
+
+	return chanBucket, nil
+}

channeldb/reports_test.go

@@ -0,0 +1,218 @@
+package channeldb
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	testChainHash = [chainhash.HashSize]byte{
+		0x51, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
+		0x48, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
+		0x2d, 0xe7, 0x93, 0xe4,
+	}
+
+	testChanPoint1 = wire.OutPoint{
+		Hash: chainhash.Hash{
+			0x51, 0xb6, 0x37, 0xd8, 0xfc, 0xd2, 0xc6, 0xda,
+			0x48, 0x59, 0xe6, 0x96, 0x31, 0x13, 0xa1, 0x17,
+			0x2d, 0xe7, 0x93, 0xe4,
+		},
+		Index: 1,
+	}
+)
+
+// TestPersistReport tests the writing and retrieval of a report on disk with
+// and without a spend txid.
+func TestPersistReport(t *testing.T) {
+	tests := []struct {
+		name      string
+		spendTxID *chainhash.Hash
+	}{
+		{
+			name:      "Non-nil spend txid",
+			spendTxID: &testChanPoint1.Hash,
+		},
+		{
+			name:      "Nil spend txid",
+			spendTxID: nil,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			db, cleanup, err := makeTestDB()
+			require.NoError(t, err)
+			defer cleanup()
+
+			channelOutpoint := testChanPoint1
+
+			testOutpoint := testChanPoint1
+			testOutpoint.Index++
+
+			report := &ResolverReport{
+				OutPoint:        testOutpoint,
+				Amount:          2,
+				ResolverType:    1,
+				ResolverOutcome: 2,
+				SpendTxID:       test.spendTxID,
+			}
+
+			// Write report to disk, and ensure it is identical when
+			// it is read.
+			err = db.PutResolverReport(
+				nil, testChainHash, &channelOutpoint, report,
+			)
+			require.NoError(t, err)
+
+			reports, err := db.FetchChannelReports(
+				testChainHash, &channelOutpoint,
+			)
+			require.NoError(t, err)
+			require.Equal(t, report, reports[0])
+		})
+	}
+}
+
+// TestFetchChannelReadBucket tests retrieval of the reports bucket for a
+// channel, testing that the appropriate error is returned based on the state
+// of the existing bucket.
+func TestFetchChannelReadBucket(t *testing.T) {
+	db, cleanup, err := makeTestDB()
+	require.NoError(t, err)
+	defer cleanup()
+
+	channelOutpoint := testChanPoint1
+
+	testOutpoint := testChanPoint1
+	testOutpoint.Index++
+
+	// If we attempt to get reports when we do not have any present, we
+	// expect to fail because our chain hash bucket is not present.
+	_, err = db.FetchChannelReports(
+		testChainHash, &channelOutpoint,
+	)
+	require.Equal(t, ErrNoChainHashBucket, err)
+
+	// Finally we write a report to disk and check that we can fetch it.
+	report := &ResolverReport{
+		OutPoint:        testOutpoint,
+		Amount:          2,
+		ResolverOutcome: 1,
+		ResolverType:    2,
+		SpendTxID:       nil,
+	}
+
+	err = db.PutResolverReport(
+		nil, testChainHash, &channelOutpoint, report,
+	)
+	require.NoError(t, err)
+
+	// Now that the channel bucket exists, we expect the channel to be
+	// successfully fetched, with no reports.
+	reports, err := db.FetchChannelReports(testChainHash, &testChanPoint1)
+	require.NoError(t, err)
+	require.Equal(t, report, reports[0])
+}
+
+// TestFetchChannelWriteBucket tests the creation of missing buckets when
+// retrieving the reports bucket.
+func TestFetchChannelWriteBucket(t *testing.T) {
+	createReportsBucket := func(tx kvdb.RwTx) (kvdb.RwBucket, error) {
+		return tx.CreateTopLevelBucket(closedChannelBucket)
+	}
+
+	createChainHashBucket := func(reports kvdb.RwBucket) (kvdb.RwBucket,
+		error) {
+
+		return reports.CreateBucketIfNotExists(testChainHash[:])
+	}
+
+	createChannelBucket := func(chainHash kvdb.RwBucket) (kvdb.RwBucket,
+		error) {
+
+		var chanPointBuf bytes.Buffer
+		err := writeOutpoint(&chanPointBuf, &testChanPoint1)
+		require.NoError(t, err)
+
+		return chainHash.CreateBucketIfNotExists(chanPointBuf.Bytes())
+	}
+
+	tests := []struct {
+		name  string
+		setup func(tx kvdb.RwTx) error
+	}{
+		{
+			name: "no existing buckets",
+			setup: func(tx kvdb.RwTx) error {
+				return nil
+			},
+		},
+		{
+			name: "reports bucket exists",
+			setup: func(tx kvdb.RwTx) error {
+				_, err := createReportsBucket(tx)
+				return err
+			},
+		},
+		{
+			name: "chainhash bucket exists",
+			setup: func(tx kvdb.RwTx) error {
+				reports, err := createReportsBucket(tx)
+				if err != nil {
+					return err
+				}
+
+				_, err = createChainHashBucket(reports)
+				return err
+			},
+		},
+		{
+			name: "channel bucket exists",
+			setup: func(tx kvdb.RwTx) error {
+				reports, err := createReportsBucket(tx)
+				if err != nil {
+					return err
+				}
+
+				chainHash, err := createChainHashBucket(reports)
+				if err != nil {
+					return err
+				}
+
+				_, err = createChannelBucket(chainHash)
+				return err
+			},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			db, cleanup, err := makeTestDB()
+			require.NoError(t, err)
+			defer cleanup()
+
+			// Update our db to the starting state we expect.
+			err = kvdb.Update(db, test.setup)
+			require.NoError(t, err)
+
+			// Try to get our report bucket.
+			err = kvdb.Update(db, func(tx kvdb.RwTx) error {
+				_, err := fetchReportWriteBucket(
+					tx, testChainHash, &testChanPoint1,
+				)
+				return err
+			})
+			require.NoError(t, err)
+		})
+	}
+}

contractcourt/anchor_resolver.go

@@ -5,8 +5,10 @@ import (
 	"io"
 	"sync"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
+	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/sweep"
@@ -121,22 +123,27 @@ func (c *anchorResolver) Resolve() (ContractResolver, error) {
 		}
 	}
 
-	var anchorRecovered bool
+	var (
+		outcome channeldb.ResolverOutcome
+		spendTx *chainhash.Hash
+	)
+
 	select {
 	case sweepRes := <-resultChan:
 		switch sweepRes.Err {
 
 		// Anchor was swept successfully.
 		case nil:
-			c.log.Debugf("anchor swept by tx %v",
-				sweepRes.Tx.TxHash())
+			sweepTxID := sweepRes.Tx.TxHash()
 
-			anchorRecovered = true
+			spendTx = &sweepTxID
+			outcome = channeldb.ResolverOutcomeClaimed
 
 		// Anchor was swept by someone else. This is possible after the
 		// 16 block csv lock.
 		case sweep.ErrRemoteSpend:
 			c.log.Warnf("our anchor spent by someone else")
+			outcome = channeldb.ResolverOutcomeUnclaimed
 
 		// The sweeper gave up on sweeping the anchor. This happens
 		// after the maximum number of sweep attempts has been reached.
@@ -147,6 +154,7 @@ func (c *anchorResolver) Resolve() (ContractResolver, error) {
 		// We consider the anchor as being lost.
 		case sweep.ErrTooManyAttempts:
 			c.log.Warnf("anchor sweep abandoned")
+			outcome = channeldb.ResolverOutcomeUnclaimed
 
 		// An unexpected error occurred.
 		default:
@@ -161,14 +169,17 @@ func (c *anchorResolver) Resolve() (ContractResolver, error) {
 
 	// Update report to reflect that funds are no longer in limbo.
 	c.reportLock.Lock()
-	if anchorRecovered {
+	if outcome == channeldb.ResolverOutcomeClaimed {
 		c.currentReport.RecoveredBalance = c.currentReport.LimboBalance
 	}
 	c.currentReport.LimboBalance = 0
+	report := c.currentReport.resolverReport(
+		spendTx, channeldb.ResolverTypeAnchor, outcome,
+	)
 	c.reportLock.Unlock()
 
 	c.resolved = true
-	return nil, nil
+	return nil, c.PutResolverReport(nil, report)
 }
 
 // Stop signals the resolver to cancel any current resolution processes, and

contractcourt/briefcase.go

@@ -62,8 +62,10 @@ type ArbitratorLog interface {
 
 	// InsertUnresolvedContracts inserts a set of unresolved contracts into
 	// the log. The log will then persistently store each contract until
-	// they've been swapped out, or resolved.
-	InsertUnresolvedContracts(...ContractResolver) error
+	// they've been swapped out, or resolved. It takes a set of report which
+	// should be written to disk if as well if it is non-nil.
+	InsertUnresolvedContracts(reports []*channeldb.ResolverReport,
+		resolvers ...ContractResolver) error
 
 	// FetchUnresolvedContracts returns all unresolved contracts that have
 	// been previously written to the log.
@@ -533,7 +535,9 @@ func (b *boltArbitratorLog) FetchUnresolvedContracts() ([]ContractResolver, erro
 // swapped out, or resolved.
 //
 // NOTE: Part of the ContractResolver interface.
-func (b *boltArbitratorLog) InsertUnresolvedContracts(resolvers ...ContractResolver) error {
+func (b *boltArbitratorLog) InsertUnresolvedContracts(reports []*channeldb.ResolverReport,
+	resolvers ...ContractResolver) error {
+
 	return kvdb.Batch(b.db, func(tx kvdb.RwTx) error {
 		contractBucket, err := fetchContractWriteBucket(tx, b.scopeKey[:])
 		if err != nil {
@@ -547,6 +551,14 @@ func (b *boltArbitratorLog) InsertUnresolvedContracts(resolvers ...ContractResol
 			}
 		}
 
+		// Persist any reports that are present.
+		for _, report := range reports {
+			err := b.cfg.PutResolverReport(tx, report)
+			if err != nil {
+				return err
+			}
+		}
+
 		return nil
 	})
 }
@@ -908,15 +920,28 @@ func (b *boltArbitratorLog) WipeHistory() error {
 
 // checkpointContract is a private method that will be fed into
 // ContractResolver instances to checkpoint their state once they reach
-// milestones during contract resolution.
-func (b *boltArbitratorLog) checkpointContract(c ContractResolver) error {
+// milestones during contract resolution. If the report provided is non-nil,
+// it should also be recorded.
+func (b *boltArbitratorLog) checkpointContract(c ContractResolver,
+	reports ...*channeldb.ResolverReport) error {
+
 	return kvdb.Update(b.db, func(tx kvdb.RwTx) error {
 		contractBucket, err := fetchContractWriteBucket(tx, b.scopeKey[:])
 		if err != nil {
 			return err
 		}
 
-		return b.writeResolver(contractBucket, c)
+		if err := b.writeResolver(contractBucket, c); err != nil {
+			return err
+		}
+
+		for _, report := range reports {
+			if err := b.cfg.PutResolverReport(tx, report); err != nil {
+				return err
+			}
+		}
+
+		return nil
 	})
 }
 

contractcourt/briefcase_test.go

@@ -133,7 +133,12 @@ func newTestBoltArbLog(chainhash chainhash.Hash,
 		return nil, nil, err
 	}
 
-	testArbCfg := ChannelArbitratorConfig{}
+	testArbCfg := ChannelArbitratorConfig{
+		PutResolverReport: func(_ kvdb.RwTx,
+			_ *channeldb.ResolverReport) error {
+			return nil
+		},
+	}
 	testLog, err := newBoltArbitratorLog(testDB, testArbCfg, chainhash, op)
 	if err != nil {
 		return nil, nil, err
@@ -333,8 +338,10 @@ func TestContractInsertionRetrieval(t *testing.T) {
 	resolverMap[string(resolvers[3].ResolverKey())] = resolvers[3]
 	resolverMap[string(resolvers[4].ResolverKey())] = resolvers[4]
 
-	// Now, we'll insert the resolver into the log.
-	if err := testLog.InsertUnresolvedContracts(resolvers...); err != nil {
+	// Now, we'll insert the resolver into the log, we do not need to apply
+	// any closures, so we will pass in nil.
+	err = testLog.InsertUnresolvedContracts(nil, resolvers...)
+	if err != nil {
 		t.Fatalf("unable to insert resolvers: %v", err)
 	}
 
@@ -414,8 +421,9 @@ func TestContractResolution(t *testing.T) {
 	}
 
 	// First, we'll insert the resolver into the database and ensure that
-	// we get the same resolver out the other side.
-	err = testLog.InsertUnresolvedContracts(timeoutResolver)
+	// we get the same resolver out the other side. We do not need to apply
+	// any closures.
+	err = testLog.InsertUnresolvedContracts(nil, timeoutResolver)
 	if err != nil {
 		t.Fatalf("unable to insert contract into db: %v", err)
 	}
@@ -477,8 +485,9 @@ func TestContractSwapping(t *testing.T) {
 		htlcTimeoutResolver: timeoutResolver,
 	}
 
-	// We'll first insert the contest resolver into the log.
-	err = testLog.InsertUnresolvedContracts(contestResolver)
+	// We'll first insert the contest resolver into the log with no
+	// additional updates.
+	err = testLog.InsertUnresolvedContracts(nil, contestResolver)
 	if err != nil {
 		t.Fatalf("unable to insert contract into db: %v", err)
 	}

contractcourt/chain_arbitrator.go

@@ -12,6 +12,7 @@ import (
 	"github.com/btcsuite/btcutil"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
 	"github.com/lightningnetwork/lnd/clock"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lnwallet"
@@ -347,6 +348,14 @@ func newActiveChannelArbitrator(channel *channeldb.OpenChannel,
 		IsPendingClose:        false,
 		ChainArbitratorConfig: c.cfg,
 		ChainEvents:           chanEvents,
+		PutResolverReport: func(tx kvdb.RwTx,
+			report *channeldb.ResolverReport) error {
+
+			return c.chanSource.PutResolverReport(
+				tx, c.cfg.ChainHash, &channel.FundingOutpoint,
+				report,
+			)
+		},
 	}
 
 	// The final component needed is an arbitrator log that the arbitrator
@@ -552,6 +561,13 @@ func (c *ChainArbitrator) Start() error {
 			IsPendingClose:        true,
 			ClosingHeight:         closeChanInfo.CloseHeight,
 			CloseType:             closeChanInfo.CloseType,
+			PutResolverReport: func(tx kvdb.RwTx,
+				report *channeldb.ResolverReport) error {
+
+				return c.chanSource.PutResolverReport(
+					tx, c.cfg.ChainHash, &chanPoint, report,
+				)
+			},
 		}
 		chanLog, err := newBoltArbitratorLog(
 			c.chanSource.Backend, arbCfg, c.cfg.ChainHash, chanPoint,

contractcourt/channel_arbitrator.go

@@ -8,11 +8,13 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwallet"
@@ -143,6 +145,12 @@ type ChannelArbitratorConfig struct {
 	// TODO(roasbeef): need RPC's to combine for pendingchannels RPC
 	MarkChannelResolved func() error
 
+	// PutResolverReport records a resolver report for the channel. If the
+	// transaction provided is nil, the function should write the report
+	// in a new transaction.
+	PutResolverReport func(tx kvdb.RwTx,
+		report *channeldb.ResolverReport) error
+
 	ChainArbitratorConfig
 }
 
@@ -197,6 +205,21 @@ type ContractReport struct {
 	RecoveredBalance btcutil.Amount
 }
 
+// resolverReport creates a resolve report using some of the information in the
+// contract report.
+func (c *ContractReport) resolverReport(spendTx *chainhash.Hash,
+	resolverType channeldb.ResolverType,
+	outcome channeldb.ResolverOutcome) *channeldb.ResolverReport {
+
+	return &channeldb.ResolverReport{
+		OutPoint:        c.Outpoint,
+		Amount:          c.Amount,
+		ResolverType:    resolverType,
+		ResolverOutcome: outcome,
+		SpendTxID:       spendTx,
+	}
+}
+
 // htlcSet represents the set of active HTLCs on a given commitment
 // transaction.
 type htlcSet struct {
@@ -969,7 +992,7 @@ func (c *ChannelArbitrator) stateStep(
 		log.Debugf("ChannelArbitrator(%v): inserting %v contract "+
 			"resolvers", c.cfg.ChanPoint, len(htlcResolvers))
 
-		err = c.log.InsertUnresolvedContracts(htlcResolvers...)
+		err = c.log.InsertUnresolvedContracts(nil, htlcResolvers...)
 		if err != nil {
 			return StateError, closeTx, err
 		}
@@ -1737,8 +1760,10 @@ func (c *ChannelArbitrator) prepContractResolutions(
 	// resolver so they each can do their duty.
 	resolverCfg := ResolverConfig{
 		ChannelArbitratorConfig: c.cfg,
-		Checkpoint: func(res ContractResolver) error {
-			return c.log.InsertUnresolvedContracts(res)
+		Checkpoint: func(res ContractResolver,
+			reports ...*channeldb.ResolverReport) error {
+
+			return c.log.InsertUnresolvedContracts(reports, res)
 		},
 	}
 

contractcourt/channel_arbitrator_test.go

@@ -6,6 +6,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"reflect"
 	"sync"
 	"testing"
 	"time"
@@ -78,7 +79,7 @@ func (b *mockArbitratorLog) FetchUnresolvedContracts() ([]ContractResolver,
 	return v, nil
 }
 
-func (b *mockArbitratorLog) InsertUnresolvedContracts(
+func (b *mockArbitratorLog) InsertUnresolvedContracts(_ []*channeldb.ResolverReport,
 	resolvers ...ContractResolver) error {
 
 	b.Lock()
@@ -380,6 +381,11 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog,
 		IsPendingClose:        false,
 		ChainArbitratorConfig: chainArbCfg,
 		ChainEvents:           chanEvents,
+		PutResolverReport: func(_ kvdb.RwTx,
+			_ *channeldb.ResolverReport) error {
+
+			return nil
+		},
 	}
 
 	// Apply all custom options to the config struct.
@@ -2104,6 +2110,15 @@ func TestChannelArbitratorAnchors(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unable to create ChannelArbitrator: %v", err)
 	}
+
+	// Replace our mocked put report function with one which will push
+	// reports into a channel for us to consume. We update this function
+	// because our resolver will be created from the existing chanArb cfg.
+	reports := make(chan *channeldb.ResolverReport)
+	chanArbCtx.chanArb.cfg.PutResolverReport = putResolverReportInChannel(
+		reports,
+	)
+
 	chanArb := chanArbCtx.chanArb
 	chanArb.cfg.PreimageDB = newMockWitnessBeacon()
 	chanArb.cfg.Registry = &mockRegistry{}
@@ -2182,18 +2197,20 @@ func TestChannelArbitratorAnchors(t *testing.T) {
 		},
 	}
 
+	anchorResolution := &lnwallet.AnchorResolution{
+		AnchorSignDescriptor: input.SignDescriptor{
+			Output: &wire.TxOut{
+				Value: 1,
+			},
+		},
+	}
+
 	chanArb.cfg.ChainEvents.LocalUnilateralClosure <- &LocalUnilateralCloseInfo{
 		SpendDetail: &chainntnfs.SpendDetail{},
 		LocalForceCloseSummary: &lnwallet.LocalForceCloseSummary{
-			CloseTx:         closeTx,
-			HtlcResolutions: &lnwallet.HtlcResolutions{},
-			AnchorResolution: &lnwallet.AnchorResolution{
-				AnchorSignDescriptor: input.SignDescriptor{
-					Output: &wire.TxOut{
-						Value: 1,
-					},
-				},
-			},
+			CloseTx:          closeTx,
+			HtlcResolutions:  &lnwallet.HtlcResolutions{},
+			AnchorResolution: anchorResolution,
 		},
 		ChannelCloseSummary: &channeldb.ChannelCloseSummary{},
 		CommitSet: CommitSet{
@@ -2231,6 +2248,47 @@ func TestChannelArbitratorAnchors(t *testing.T) {
 	case <-time.After(5 * time.Second):
 		t.Fatalf("contract was not resolved")
 	}
+
+	anchorAmt := btcutil.Amount(
+		anchorResolution.AnchorSignDescriptor.Output.Value,
+	)
+	spendTx := chanArbCtx.sweeper.sweepTx.TxHash()
+	expectedReport := &channeldb.ResolverReport{
+		OutPoint:        anchorResolution.CommitAnchor,
+		Amount:          anchorAmt,
+		ResolverType:    channeldb.ResolverTypeAnchor,
+		ResolverOutcome: channeldb.ResolverOutcomeClaimed,
+		SpendTxID:       &spendTx,
+	}
+
+	assertResolverReport(t, reports, expectedReport)
+}
+
+// putResolverReportInChannel returns a put report function which will pipe
+// reports into the channel provided.
+func putResolverReportInChannel(reports chan *channeldb.ResolverReport) func(
+	_ kvdb.RwTx, report *channeldb.ResolverReport) error {
+
+	return func(_ kvdb.RwTx, report *channeldb.ResolverReport) error {
+		reports <- report
+		return nil
+	}
+}
+
+// assertResolverReport checks that  a set of reports only contains a single
+// report, and that it is equal to the expected report passed in.
+func assertResolverReport(t *testing.T, reports chan *channeldb.ResolverReport,
+	expected *channeldb.ResolverReport) {
+
+	select {
+	case report := <-reports:
+		if !reflect.DeepEqual(report, expected) {
+			t.Fatalf("expected: %v, got: %v", expected, report)
+		}
+
+	case <-time.After(defaultTimeout):
+		t.Fatalf("no reports present")
+	}
 }
 
 type mockChannel struct {

contractcourt/commit_sweep_resolver.go

@@ -6,9 +6,11 @@ import (
 	"io"
 	"sync"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
+	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/sweep"
@@ -235,11 +237,13 @@ func (c *commitSweepResolver) Resolve() (ContractResolver, error) {
 		return nil, err
 	}
 
+	var sweepTxID chainhash.Hash
+
 	// Sweeper is going to join this input with other inputs if
 	// possible and publish the sweep tx. When the sweep tx
 	// confirms, it signals us through the result channel with the
 	// outcome. Wait for this to happen.
-	recovered := true
+	outcome := channeldb.ResolverOutcomeClaimed
 	select {
 	case sweepResult := <-resultChan:
 		switch sweepResult.Err {
@@ -250,7 +254,7 @@ func (c *commitSweepResolver) Resolve() (ContractResolver, error) {
 			// the contract.
 			c.log.Warnf("local commitment output was swept by "+
 				"remote party via %v", sweepResult.Tx.TxHash())
-			recovered = false
+			outcome = channeldb.ResolverOutcomeUnclaimed
 		case nil:
 			// No errors, therefore continue processing.
 			c.log.Infof("local commitment output fully resolved by "+
@@ -262,22 +266,30 @@ func (c *commitSweepResolver) Resolve() (ContractResolver, error) {
 
 			return nil, sweepResult.Err
 		}
+
+		sweepTxID = sweepResult.Tx.TxHash()
+
 	case <-c.quit:
 		return nil, errResolverShuttingDown
 	}
 
 	// Funds have been swept and balance is no longer in limbo.
 	c.reportLock.Lock()
-	if recovered {
+	if outcome == channeldb.ResolverOutcomeClaimed {
 		// We only record the balance as recovered if it actually came
 		// back to us.
 		c.currentReport.RecoveredBalance = c.currentReport.LimboBalance
 	}
 	c.currentReport.LimboBalance = 0
 	c.reportLock.Unlock()
-
+	report := c.currentReport.resolverReport(
+		&sweepTxID, channeldb.ResolverTypeCommit, outcome,
+	)
 	c.resolved = true
-	return nil, c.Checkpoint(c)
+
+	// Checkpoint the resolver with a closure that will write the outcome
+	// of the resolver and its sweep transaction to disk.
+	return nil, c.Checkpoint(c, report)
 }
 
 // Stop signals the resolver to cancel any current resolution processes, and

contractcourt/commit_sweep_resolver_test.go

@@ -7,6 +7,8 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/btcsuite/btcutil"
 	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
@@ -39,11 +41,18 @@ func newCommitSweepResolverTestContext(t *testing.T,
 			Notifier: notifier,
 			Sweeper:  sweeper,
 		},
+		PutResolverReport: func(_ kvdb.RwTx,
+			_ *channeldb.ResolverReport) error {
+
+			return nil
+		},
 	}
 
 	cfg := ResolverConfig{
 		ChannelArbitratorConfig: chainCfg,
-		Checkpoint: func(_ ContractResolver) error {
+		Checkpoint: func(_ ContractResolver,
+			_ ...*channeldb.ResolverReport) error {
+
 			checkPointChan <- struct{}{}
 			return nil
 		},
@@ -95,6 +104,7 @@ func (i *commitSweepResolverTestContext) waitForResult() {
 type mockSweeper struct {
 	sweptInputs   chan input.Input
 	updatedInputs chan wire.OutPoint
+	sweepTx       *wire.MsgTx
 	sweepErr      error
 }
 
@@ -102,6 +112,7 @@ func newMockSweeper() *mockSweeper {
 	return &mockSweeper{
 		sweptInputs:   make(chan input.Input),
 		updatedInputs: make(chan wire.OutPoint),
+		sweepTx:       &wire.MsgTx{},
 	}
 }
 
@@ -112,7 +123,7 @@ func (s *mockSweeper) SweepInput(input input.Input, params sweep.Params) (
 
 	result := make(chan sweep.Result, 1)
 	result <- sweep.Result{
-		Tx:  &wire.MsgTx{},
+		Tx:  s.sweepTx,
 		Err: s.sweepErr,
 	}
 	return result, nil
@@ -135,7 +146,7 @@ func (s *mockSweeper) UpdateParams(input wire.OutPoint,
 
 	result := make(chan sweep.Result, 1)
 	result <- sweep.Result{
-		Tx: &wire.MsgTx{},
+		Tx: s.sweepTx,
 	}
 	return result, nil
 }
@@ -158,13 +169,44 @@ func TestCommitSweepResolverNoDelay(t *testing.T) {
 	}
 
 	ctx := newCommitSweepResolverTestContext(t, &res)
+
+	// Replace our checkpoint with one which will push reports into a
+	// channel for us to consume. We replace this function on the resolver
+	// itself because it is created by the test context.
+	reportChan := make(chan *channeldb.ResolverReport)
+	ctx.resolver.Checkpoint = func(_ ContractResolver,
+		reports ...*channeldb.ResolverReport) error {
+
+		// Send all of our reports into the channel.
+		for _, report := range reports {
+			reportChan <- report
+		}
+
+		return nil
+	}
+
 	ctx.resolve()
 
-	ctx.notifier.confChan <- &chainntnfs.TxConfirmation{}
+	spendTx := &wire.MsgTx{}
+	spendHash := spendTx.TxHash()
+	ctx.notifier.confChan <- &chainntnfs.TxConfirmation{
+		Tx: spendTx,
+	}
 
 	// No csv delay, so the input should be swept immediately.
 	<-ctx.sweeper.sweptInputs
 
+	amt := btcutil.Amount(res.SelfOutputSignDesc.Output.Value)
+	expectedReport := &channeldb.ResolverReport{
+		OutPoint:        wire.OutPoint{},
+		Amount:          amt,
+		ResolverType:    channeldb.ResolverTypeCommit,
+		ResolverOutcome: channeldb.ResolverOutcomeClaimed,
+		SpendTxID:       &spendHash,
+	}
+
+	assertResolverReport(t, reportChan, expectedReport)
+
 	ctx.waitForResult()
 }
 
@@ -192,6 +234,21 @@ func testCommitSweepResolverDelay(t *testing.T, sweepErr error) {
 
 	ctx := newCommitSweepResolverTestContext(t, &res)
 
+	// Replace our checkpoint with one which will push reports into a
+	// channel for us to consume. We replace this function on the resolver
+	// itself because it is created by the test context.
+	reportChan := make(chan *channeldb.ResolverReport)
+	ctx.resolver.Checkpoint = func(_ ContractResolver,
+		reports ...*channeldb.ResolverReport) error {
+
+		// Send all of our reports into the channel.
+		for _, report := range reports {
+			reportChan <- report
+		}
+
+		return nil
+	}
+
 	// Setup whether we expect the sweeper to receive a sweep error in this
 	// test case.
 	ctx.sweeper.sweepErr = sweepErr
@@ -239,6 +296,22 @@ func testCommitSweepResolverDelay(t *testing.T, sweepErr error) {
 
 	<-ctx.sweeper.sweptInputs
 
+	// Set the resolution report outcome based on whether our sweep
+	// succeeded.
+	outcome := channeldb.ResolverOutcomeClaimed
+	if sweepErr != nil {
+		outcome = channeldb.ResolverOutcomeUnclaimed
+	}
+	sweepTx := ctx.sweeper.sweepTx.TxHash()
+
+	assertResolverReport(t, reportChan, &channeldb.ResolverReport{
+		OutPoint:        outpoint,
+		ResolverType:    channeldb.ResolverTypeCommit,
+		ResolverOutcome: outcome,
+		Amount:          btcutil.Amount(amt),
+		SpendTxID:       &sweepTx,
+	})
+
 	ctx.waitForResult()
 
 	// If this test case generates a sweep error, we don't expect to be

contractcourt/contract_resolvers.go

@@ -86,8 +86,10 @@ type ResolverConfig struct {
 
 	// Checkpoint allows a resolver to check point its state. This function
 	// should write the state of the resolver to persistent storage, and
-	// return a non-nil error upon success.
-	Checkpoint func(ContractResolver) error
+	// return a non-nil error upon success. It takes a resolver report,
+	// which contains information about the outcome and should be written
+	// to disk if non-nil.
+	Checkpoint func(ContractResolver, ...*channeldb.ResolverReport) error
 }
 
 // contractResolverKit is meant to be used as a mix-in struct to be embedded within a

contractcourt/htlc_incoming_contest_resolver.go

@@ -81,7 +81,14 @@ func (h *htlcIncomingContestResolver) Resolve() (ContractResolver, error) {
 		// present itself when we crash before processRemoteAdds in the
 		// link has ran.
 		h.resolved = true
-		return nil, nil
+
+		// We write a report to disk that indicates we could not decode
+		// the htlc.
+		resReport := h.report().resolverReport(
+			nil, channeldb.ResolverTypeIncomingHtlc,
+			channeldb.ResolverOutcomeAbandoned,
+		)
+		return nil, h.PutResolverReport(nil, resReport)
 	}
 
 	// Register for block epochs. After registration, the current height
@@ -120,7 +127,14 @@ func (h *htlcIncomingContestResolver) Resolve() (ContractResolver, error) {
 			"abandoning", h, h.htlcResolution.ClaimOutpoint,
 			h.htlcExpiry, currentHeight)
 		h.resolved = true
-		return nil, h.Checkpoint(h)
+
+		// Finally, get our report and checkpoint our resolver with a
+		// timeout outcome report.
+		report := h.report().resolverReport(
+			nil, channeldb.ResolverTypeIncomingHtlc,
+			channeldb.ResolverOutcomeTimeout,
+		)
+		return nil, h.Checkpoint(h, report)
 	}
 
 	// applyPreimage is a helper function that will populate our internal
@@ -158,16 +172,6 @@ func (h *htlcIncomingContestResolver) Resolve() (ContractResolver, error) {
 		return nil
 	}
 
-	// If the HTLC hasn't expired yet, then we may still be able to claim
-	// it if we learn of the pre-image, so we'll subscribe to the preimage
-	// database to see if it turns up, or the HTLC times out.
-	//
-	// NOTE: This is done BEFORE opportunistically querying the db, to
-	// ensure the preimage can't be delivered between querying and
-	// registering for the preimage subscription.
-	preimageSubscription := h.PreimageDB.SubscribeUpdates()
-	defer preimageSubscription.CancelSubscription()
-
 	// Define a closure to process htlc resolutions either directly or
 	// triggered by future notifications.
 	processHtlcResolution := func(e invoices.HtlcResolution) (
@@ -196,7 +200,14 @@ func (h *htlcIncomingContestResolver) Resolve() (ContractResolver, error) {
 				h.htlcExpiry, currentHeight)
 
 			h.resolved = true
-			return nil, h.Checkpoint(h)
+
+			// Checkpoint our resolver with an abandoned outcome
+			// because we take no further action on this htlc.
+			report := h.report().resolverReport(
+				nil, channeldb.ResolverTypeIncomingHtlc,
+				channeldb.ResolverOutcomeAbandoned,
+			)
+			return nil, h.Checkpoint(h, report)
 
 		// Error if the resolution type is unknown, we are only
 		// expecting settles and fails.
@@ -206,71 +217,91 @@ func (h *htlcIncomingContestResolver) Resolve() (ContractResolver, error) {
 		}
 	}
 
-	// Create a buffered hodl chan to prevent deadlock.
-	hodlChan := make(chan interface{}, 1)
-
-	// Notify registry that we are potentially resolving as an exit hop
-	// on-chain. If this HTLC indeed pays to an existing invoice, the
-	// invoice registry will tell us what to do with the HTLC. This is
-	// identical to HTLC resolution in the link.
-	circuitKey := channeldb.CircuitKey{
-		ChanID: h.ShortChanID,
-		HtlcID: h.htlc.HtlcIndex,
-	}
-
-	resolution, err := h.Registry.NotifyExitHopHtlc(
-		h.htlc.RHash, h.htlc.Amt, h.htlcExpiry, currentHeight,
-		circuitKey, hodlChan, payload,
+	var (
+		hodlChan       chan interface{}
+		witnessUpdates <-chan lntypes.Preimage
 	)
-	if err != nil {
-		return nil, err
-	}
+	if payload.FwdInfo.NextHop == hop.Exit {
+		// Create a buffered hodl chan to prevent deadlock.
+		hodlChan = make(chan interface{}, 1)
 
-	defer h.Registry.HodlUnsubscribeAll(hodlChan)
-
-	// Take action based on the resolution we received. If the htlc was
-	// settled, or a htlc for a known invoice failed we can resolve it
-	// directly. If the resolution is nil, the htlc was neither accepted
-	// nor failed, so we cannot take action yet.
-	switch res := resolution.(type) {
-	case *invoices.HtlcFailResolution:
-		// In the case where the htlc failed, but the invoice was known
-		// to the registry, we can directly resolve the htlc.
-		if res.Outcome != invoices.ResultInvoiceNotFound {
-			return processHtlcResolution(resolution)
+		// Notify registry that we are potentially resolving as an exit
+		// hop on-chain. If this HTLC indeed pays to an existing
+		// invoice, the invoice registry will tell us what to do with
+		// the HTLC. This is identical to HTLC resolution in the link.
+		circuitKey := channeldb.CircuitKey{
+			ChanID: h.ShortChanID,
+			HtlcID: h.htlc.HtlcIndex,
 		}
 
-	// If we settled the htlc, we can resolve it.
-	case *invoices.HtlcSettleResolution:
-		return processHtlcResolution(resolution)
-
-	// If the resolution is nil, the htlc was neither settled nor failed so
-	// we cannot take action at present.
-	case nil:
-
-	default:
-		return nil, fmt.Errorf("unknown htlc resolution type: %T",
-			resolution)
-	}
-
-	// With the epochs and preimage subscriptions initialized, we'll query
-	// to see if we already know the preimage.
-	preimage, ok := h.PreimageDB.LookupPreimage(h.htlc.RHash)
-	if ok {
-		// If we do, then this means we can claim the HTLC!  However,
-		// we don't know how to ourselves, so we'll return our inner
-		// resolver which has the knowledge to do so.
-		if err := applyPreimage(preimage); err != nil {
+		resolution, err := h.Registry.NotifyExitHopHtlc(
+			h.htlc.RHash, h.htlc.Amt, h.htlcExpiry, currentHeight,
+			circuitKey, hodlChan, payload,
+		)
+		if err != nil {
 			return nil, err
 		}
 
-		return &h.htlcSuccessResolver, nil
+		defer h.Registry.HodlUnsubscribeAll(hodlChan)
+
+		// Take action based on the resolution we received. If the htlc
+		// was settled, or a htlc for a known invoice failed we can
+		// resolve it directly. If the resolution is nil, the htlc was
+		// neither accepted nor failed, so we cannot take action yet.
+		switch res := resolution.(type) {
+		case *invoices.HtlcFailResolution:
+			// In the case where the htlc failed, but the invoice
+			// was known to the registry, we can directly resolve
+			// the htlc.
+			if res.Outcome != invoices.ResultInvoiceNotFound {
+				return processHtlcResolution(resolution)
+			}
+
+		// If we settled the htlc, we can resolve it.
+		case *invoices.HtlcSettleResolution:
+			return processHtlcResolution(resolution)
+
+		// If the resolution is nil, the htlc was neither settled nor
+		// failed so we cannot take action at present.
+		case nil:
+
+		default:
+			return nil, fmt.Errorf("unknown htlc resolution type: %T",
+				resolution)
+		}
+	} else {
+		// If the HTLC hasn't expired yet, then we may still be able to
+		// claim it if we learn of the pre-image, so we'll subscribe to
+		// the preimage database to see if it turns up, or the HTLC
+		// times out.
+		//
+		// NOTE: This is done BEFORE opportunistically querying the db,
+		// to ensure the preimage can't be delivered between querying
+		// and registering for the preimage subscription.
+		preimageSubscription := h.PreimageDB.SubscribeUpdates()
+		defer preimageSubscription.CancelSubscription()
+
+		// With the epochs and preimage subscriptions initialized, we'll
+		// query to see if we already know the preimage.
+		preimage, ok := h.PreimageDB.LookupPreimage(h.htlc.RHash)
+		if ok {
+			// If we do, then this means we can claim the HTLC!
+			// However, we don't know how to ourselves, so we'll
+			// return our inner resolver which has the knowledge to
+			// do so.
+			if err := applyPreimage(preimage); err != nil {
+				return nil, err
+			}
+
+			return &h.htlcSuccessResolver, nil
+		}
+
+		witnessUpdates = preimageSubscription.WitnessUpdates
 	}
 
 	for {
-
 		select {
-		case preimage := <-preimageSubscription.WitnessUpdates:
+		case preimage := <-witnessUpdates:
 			// We received a new preimage, but we need to ignore
 			// all except the preimage we are waiting for.
 			if !preimage.Matches(h.htlc.RHash) {
@@ -305,7 +336,13 @@ func (h *htlcIncomingContestResolver) Resolve() (ContractResolver, error) {
 					h.htlcResolution.ClaimOutpoint,
 					h.htlcExpiry, currentHeight)
 				h.resolved = true
-				return nil, h.Checkpoint(h)
+
+				report := h.report().resolverReport(
+					nil,
+					channeldb.ResolverTypeIncomingHtlc,
+					channeldb.ResolverOutcomeTimeout,
+				)
+				return nil, h.Checkpoint(h, report)
 			}
 
 		case <-h.quit:

contractcourt/htlc_incoming_resolver_test.go

@@ -6,13 +6,15 @@ import (
 	"io/ioutil"
 	"testing"
 
+	sphinx "github.com/lightningnetwork/lightning-onion"
+	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
 	"github.com/lightningnetwork/lnd/htlcswitch/hop"
 	"github.com/lightningnetwork/lnd/invoices"
-	"github.com/lightningnetwork/lnd/lnwallet"
-
-	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/lntypes"
+	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/lightningnetwork/lnd/lnwire"
 )
 
 const (
@@ -26,6 +28,7 @@ var (
 	testResCircuitKey       = channeldb.CircuitKey{}
 	testOnionBlob           = []byte{4, 5, 6}
 	testAcceptHeight  int32 = 1234
+	testHtlcAmount          = 2300
 )
 
 // TestHtlcIncomingResolverFwdPreimageKnown tests resolution of a forwarded htlc
@@ -34,11 +37,7 @@ func TestHtlcIncomingResolverFwdPreimageKnown(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
-	ctx.registry.notifyResolution = invoices.NewFailResolution(
-		testResCircuitKey, testHtlcExpiry,
-		invoices.ResultInvoiceNotFound,
-	)
+	ctx := newIncomingResolverTestContext(t, false)
 	ctx.witnessBeacon.lookupPreimage[testResHash] = testResPreimage
 	ctx.resolve()
 	ctx.waitForResult(true)
@@ -51,11 +50,7 @@ func TestHtlcIncomingResolverFwdContestedSuccess(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
-	ctx.registry.notifyResolution = invoices.NewFailResolution(
-		testResCircuitKey, testHtlcExpiry,
-		invoices.ResultInvoiceNotFound,
-	)
+	ctx := newIncomingResolverTestContext(t, false)
 	ctx.resolve()
 
 	// Simulate a new block coming in. HTLC is not yet expired.
@@ -71,16 +66,36 @@ func TestHtlcIncomingResolverFwdContestedTimeout(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
-	ctx.registry.notifyResolution = invoices.NewFailResolution(
-		testResCircuitKey, testHtlcExpiry,
-		invoices.ResultInvoiceNotFound,
-	)
+	ctx := newIncomingResolverTestContext(t, false)
+
+	// Replace our checkpoint with one which will push reports into a
+	// channel for us to consume. We replace this function on the resolver
+	// itself because it is created by the test context.
+	reportChan := make(chan *channeldb.ResolverReport)
+	ctx.resolver.Checkpoint = func(_ ContractResolver,
+		reports ...*channeldb.ResolverReport) error {
+
+		// Send all of our reports into the channel.
+		for _, report := range reports {
+			reportChan <- report
+		}
+
+		return nil
+	}
+
 	ctx.resolve()
 
 	// Simulate a new block coming in. HTLC expires.
 	ctx.notifyEpoch(testHtlcExpiry)
 
+	// Assert that we have a failure resolution because our invoice was
+	// cancelled.
+	assertResolverReport(t, reportChan, &channeldb.ResolverReport{
+		Amount:          lnwire.MilliSatoshi(testHtlcAmount).ToSatoshis(),
+		ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeTimeout,
+	})
+
 	ctx.waitForResult(false)
 }
 
@@ -90,11 +105,7 @@ func TestHtlcIncomingResolverFwdTimeout(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
-	ctx.registry.notifyResolution = invoices.NewFailResolution(
-		testResCircuitKey, testHtlcExpiry,
-		invoices.ResultInvoiceNotFound,
-	)
+	ctx := newIncomingResolverTestContext(t, true)
 	ctx.witnessBeacon.lookupPreimage[testResHash] = testResPreimage
 	ctx.resolver.htlcExpiry = 90
 	ctx.resolve()
@@ -107,7 +118,7 @@ func TestHtlcIncomingResolverExitSettle(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
+	ctx := newIncomingResolverTestContext(t, true)
 	ctx.registry.notifyResolution = invoices.NewSettleResolution(
 		testResPreimage, testResCircuitKey, testAcceptHeight,
 		invoices.ResultReplayToSettled,
@@ -138,7 +149,7 @@ func TestHtlcIncomingResolverExitCancel(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
+	ctx := newIncomingResolverTestContext(t, true)
 	ctx.registry.notifyResolution = invoices.NewFailResolution(
 		testResCircuitKey, testAcceptHeight,
 		invoices.ResultInvoiceAlreadyCanceled,
@@ -154,7 +165,7 @@ func TestHtlcIncomingResolverExitSettleHodl(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
+	ctx := newIncomingResolverTestContext(t, true)
 	ctx.resolve()
 
 	notifyData := <-ctx.registry.notifyChan
@@ -172,9 +183,34 @@ func TestHtlcIncomingResolverExitTimeoutHodl(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
+	ctx := newIncomingResolverTestContext(t, true)
+
+	// Replace our checkpoint with one which will push reports into a
+	// channel for us to consume. We replace this function on the resolver
+	// itself because it is created by the test context.
+	reportChan := make(chan *channeldb.ResolverReport)
+	ctx.resolver.Checkpoint = func(_ ContractResolver,
+		reports ...*channeldb.ResolverReport) error {
+
+		// Send all of our reports into the channel.
+		for _, report := range reports {
+			reportChan <- report
+		}
+
+		return nil
+	}
+
 	ctx.resolve()
 	ctx.notifyEpoch(testHtlcExpiry)
+
+	// Assert that we have a failure resolution because our invoice was
+	// cancelled.
+	assertResolverReport(t, reportChan, &channeldb.ResolverReport{
+		Amount:          lnwire.MilliSatoshi(testHtlcAmount).ToSatoshis(),
+		ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeTimeout,
+	})
+
 	ctx.waitForResult(false)
 }
 
@@ -184,25 +220,62 @@ func TestHtlcIncomingResolverExitCancelHodl(t *testing.T) {
 	t.Parallel()
 	defer timeout(t)()
 
-	ctx := newIncomingResolverTestContext(t)
+	ctx := newIncomingResolverTestContext(t, true)
+
+	// Replace our checkpoint with one which will push reports into a
+	// channel for us to consume. We replace this function on the resolver
+	// itself because it is created by the test context.
+	reportChan := make(chan *channeldb.ResolverReport)
+	ctx.resolver.Checkpoint = func(_ ContractResolver,
+		reports ...*channeldb.ResolverReport) error {
+
+		// Send all of our reports into the channel.
+		for _, report := range reports {
+			reportChan <- report
+		}
+
+		return nil
+	}
+
 	ctx.resolve()
 	notifyData := <-ctx.registry.notifyChan
 	notifyData.hodlChan <- invoices.NewFailResolution(
 		testResCircuitKey, testAcceptHeight, invoices.ResultCanceled,
 	)
 
+	// Assert that we have a failure resolution because our invoice was
+	// cancelled.
+	assertResolverReport(t, reportChan, &channeldb.ResolverReport{
+		Amount:          lnwire.MilliSatoshi(testHtlcAmount).ToSatoshis(),
+		ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeAbandoned,
+	})
+
 	ctx.waitForResult(false)
 }
 
 type mockHopIterator struct {
+	isExit bool
 	hop.Iterator
 }
 
 func (h *mockHopIterator) HopPayload() (*hop.Payload, error) {
-	return nil, nil
+	var nextAddress [8]byte
+	if !h.isExit {
+		nextAddress = [8]byte{0x01}
+	}
+
+	return hop.NewLegacyPayload(&sphinx.HopData{
+		Realm:         [1]byte{},
+		NextAddress:   nextAddress,
+		ForwardAmount: 100,
+		OutgoingCltv:  40,
+		ExtraBytes:    [12]byte{},
+	}), nil
 }
 
 type mockOnionProcessor struct {
+	isExit           bool
 	offeredOnionBlob []byte
 }
 
@@ -215,7 +288,7 @@ func (o *mockOnionProcessor) ReconstructHopIterator(r io.Reader, rHash []byte) (
 	}
 	o.offeredOnionBlob = data
 
-	return &mockHopIterator{}, nil
+	return &mockHopIterator{isExit: o.isExit}, nil
 }
 
 type incomingResolverTestContext struct {
@@ -229,7 +302,7 @@ type incomingResolverTestContext struct {
 	t              *testing.T
 }
 
-func newIncomingResolverTestContext(t *testing.T) *incomingResolverTestContext {
+func newIncomingResolverTestContext(t *testing.T, isExit bool) *incomingResolverTestContext {
 	notifier := &mockNotifier{
 		epochChan: make(chan *chainntnfs.BlockEpoch),
 		spendChan: make(chan *chainntnfs.SpendDetail),
@@ -240,7 +313,7 @@ func newIncomingResolverTestContext(t *testing.T) *incomingResolverTestContext {
 		notifyChan: make(chan notifyExitHopData, 1),
 	}
 
-	onionProcessor := &mockOnionProcessor{}
+	onionProcessor := &mockOnionProcessor{isExit: isExit}
 
 	checkPointChan := make(chan struct{}, 1)
 
@@ -251,11 +324,18 @@ func newIncomingResolverTestContext(t *testing.T) *incomingResolverTestContext {
 			Registry:       registry,
 			OnionProcessor: onionProcessor,
 		},
+		PutResolverReport: func(_ kvdb.RwTx,
+			_ *channeldb.ResolverReport) error {
+
+			return nil
+		},
 	}
 
 	cfg := ResolverConfig{
 		ChannelArbitratorConfig: chainCfg,
-		Checkpoint: func(_ ContractResolver) error {
+		Checkpoint: func(_ ContractResolver,
+			_ ...*channeldb.ResolverReport) error {
+
 			checkPointChan <- struct{}{}
 			return nil
 		},
@@ -265,6 +345,7 @@ func newIncomingResolverTestContext(t *testing.T) *incomingResolverTestContext {
 			contractResolverKit: *newContractResolverKit(cfg),
 			htlcResolution:      lnwallet.IncomingHtlcResolution{},
 			htlc: channeldb.HTLC{
+				Amt:       lnwire.MilliSatoshi(testHtlcAmount),
 				RHash:     testResHash,
 				OnionBlob: testOnionBlob,
 			},

contractcourt/htlc_outgoing_contest_resolver_test.go

@@ -7,9 +7,11 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/lightningnetwork/lnd/lnwire"
 )
 
 const (
@@ -46,22 +48,43 @@ func TestHtlcOutgoingResolverRemoteClaim(t *testing.T) {
 	// Setup the resolver with our test resolution and start the resolution
 	// process.
 	ctx := newOutgoingResolverTestContext(t)
+
+	// Replace our mocked checkpoint function with one which will push
+	// reports into a channel for us to consume. We do so on the resolver
+	// level because our test context has already created the resolver.
+	reportChan := make(chan *channeldb.ResolverReport)
+	ctx.resolver.Checkpoint = func(_ ContractResolver,
+		reports ...*channeldb.ResolverReport) error {
+
+		// Send all of our reports into the channel.
+		for _, report := range reports {
+			reportChan <- report
+		}
+
+		return nil
+	}
+
 	ctx.resolve()
 
 	// The remote party sweeps the htlc. Notify our resolver of this event.
 	preimage := lntypes.Preimage{}
-	ctx.notifier.spendChan <- &chainntnfs.SpendDetail{
-		SpendingTx: &wire.MsgTx{
-			TxIn: []*wire.TxIn{
-				{
-					Witness: [][]byte{
-						{0}, {1}, {2}, preimage[:],
-					},
+	spendTx := &wire.MsgTx{
+		TxIn: []*wire.TxIn{
+			{
+				Witness: [][]byte{
+					{0}, {1}, {2}, preimage[:],
 				},
 			},
 		},
 	}
 
+	spendHash := spendTx.TxHash()
+
+	ctx.notifier.spendChan <- &chainntnfs.SpendDetail{
+		SpendingTx:    spendTx,
+		SpenderTxHash: &spendHash,
+	}
+
 	// We expect the extracted preimage to be added to the witness beacon.
 	<-ctx.preimageDB.newPreimages
 
@@ -69,6 +92,17 @@ func TestHtlcOutgoingResolverRemoteClaim(t *testing.T) {
 	// circuit.
 	<-ctx.resolutionChan
 
+	// Finally, check that we have a report as expected.
+	expectedReport := &channeldb.ResolverReport{
+		OutPoint:        wire.OutPoint{},
+		Amount:          0,
+		ResolverType:    channeldb.ResolverTypeOutgoingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeClaimed,
+		SpendTxID:       &spendHash,
+	}
+
+	assertResolverReport(t, reportChan, expectedReport)
+
 	// Assert that the resolver finishes without error.
 	ctx.waitForResult(false)
 }
@@ -117,6 +151,11 @@ func newOutgoingResolverTestContext(t *testing.T) *outgoingResolverTestContext {
 			},
 			OnionProcessor: onionProcessor,
 		},
+		PutResolverReport: func(_ kvdb.RwTx,
+			_ *channeldb.ResolverReport) error {
+
+			return nil
+		},
 	}
 
 	outgoingRes := lnwallet.OutgoingHtlcResolution{
@@ -128,7 +167,9 @@ func newOutgoingResolverTestContext(t *testing.T) *outgoingResolverTestContext {
 
 	cfg := ResolverConfig{
 		ChannelArbitratorConfig: chainCfg,
-		Checkpoint: func(_ ContractResolver) error {
+		Checkpoint: func(_ ContractResolver,
+			_ ...*channeldb.ResolverReport) error {
+
 			checkPointChan <- struct{}{}
 			return nil
 		},
@@ -139,6 +180,7 @@ func newOutgoingResolverTestContext(t *testing.T) *outgoingResolverTestContext {
 			contractResolverKit: *newContractResolverKit(cfg),
 			htlcResolution:      outgoingRes,
 			htlc: channeldb.HTLC{
+				Amt:       lnwire.MilliSatoshi(testHtlcAmount),
 				RHash:     testResHash,
 				OnionBlob: testOnionBlob,
 			},

contractcourt/htlc_success_resolver.go

@@ -4,7 +4,9 @@ import (
 	"encoding/binary"
 	"io"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/input"
@@ -189,7 +191,12 @@ func (h *htlcSuccessResolver) Resolve() (ContractResolver, error) {
 		// Once the transaction has received a sufficient number of
 		// confirmations, we'll mark ourselves as fully resolved and exit.
 		h.resolved = true
-		return nil, h.Checkpoint(h)
+
+		// Checkpoint the resolver, and write the outcome to disk.
+		return nil, h.checkpointClaim(
+			&sweepTXID,
+			channeldb.ResolverOutcomeClaimed,
+		)
 	}
 
 	log.Infof("%T(%x): broadcasting second-layer transition tx: %v",
@@ -241,18 +248,63 @@ func (h *htlcSuccessResolver) Resolve() (ContractResolver, error) {
 	log.Infof("%T(%x): waiting for second-level HTLC output to be spent "+
 		"after csv_delay=%v", h, h.htlc.RHash[:], h.htlcResolution.CsvDelay)
 
+	var spendTxid *chainhash.Hash
 	select {
-	case _, ok := <-spendNtfn.Spend:
+	case spend, ok := <-spendNtfn.Spend:
 		if !ok {
 			return nil, errResolverShuttingDown
 		}
+		spendTxid = spend.SpenderTxHash
 
 	case <-h.quit:
 		return nil, errResolverShuttingDown
 	}
 
 	h.resolved = true
-	return nil, h.Checkpoint(h)
+	return nil, h.checkpointClaim(
+		spendTxid, channeldb.ResolverOutcomeClaimed,
+	)
+}
+
+// checkpointClaim checkpoints the success resolver with the reports it needs.
+// If this htlc was claimed two stages, it will write reports for both stages,
+// otherwise it will just write for the single htlc claim.
+func (h *htlcSuccessResolver) checkpointClaim(spendTx *chainhash.Hash,
+	outcome channeldb.ResolverOutcome) error {
+
+	// Create a resolver report for claiming of the htlc itself.
+	amt := btcutil.Amount(h.htlcResolution.SweepSignDesc.Output.Value)
+	reports := []*channeldb.ResolverReport{
+		{
+			OutPoint:        h.htlcResolution.ClaimOutpoint,
+			Amount:          amt,
+			ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+			ResolverOutcome: outcome,
+			SpendTxID:       spendTx,
+		},
+	}
+
+	// If we have a success tx, we append a report to represent our first
+	// stage claim.
+	if h.htlcResolution.SignedSuccessTx != nil {
+		// If the SignedSuccessTx is not nil, we are claiming the htlc
+		// in two stages, so we need to create a report for the first
+		// stage transaction as well.
+		spendTx := h.htlcResolution.SignedSuccessTx
+		spendTxID := spendTx.TxHash()
+
+		report := &channeldb.ResolverReport{
+			OutPoint:        spendTx.TxIn[0].PreviousOutPoint,
+			Amount:          h.htlc.Amt.ToSatoshis(),
+			ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+			ResolverOutcome: channeldb.ResolverOutcomeFirstStage,
+			SpendTxID:       &spendTxID,
+		}
+		reports = append(reports, report)
+	}
+
+	// Finally, we checkpoint the resolver with our report(s).
+	return h.Checkpoint(h, reports...)
 }
 
 // Stop signals the resolver to cancel any current resolution processes, and

contractcourt/htlc_success_resolver_test.go

@@ -0,0 +1,241 @@
+package contractcourt
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
+	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
+	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/lightningnetwork/lnd/lnwire"
+)
+
+var testHtlcAmt = lnwire.MilliSatoshi(200000)
+
+type htlcSuccessResolverTestContext struct {
+	resolver           *htlcSuccessResolver
+	notifier           *mockNotifier
+	resolverResultChan chan resolveResult
+	t                  *testing.T
+}
+
+func newHtlcSuccessResolverTextContext(t *testing.T) *htlcSuccessResolverTestContext {
+	notifier := &mockNotifier{
+		epochChan: make(chan *chainntnfs.BlockEpoch),
+		spendChan: make(chan *chainntnfs.SpendDetail),
+		confChan:  make(chan *chainntnfs.TxConfirmation),
+	}
+
+	checkPointChan := make(chan struct{}, 1)
+
+	testCtx := &htlcSuccessResolverTestContext{
+		notifier: notifier,
+		t:        t,
+	}
+
+	chainCfg := ChannelArbitratorConfig{
+		ChainArbitratorConfig: ChainArbitratorConfig{
+			Notifier: notifier,
+			PublishTx: func(_ *wire.MsgTx, _ string) error {
+				return nil
+			},
+		},
+		PutResolverReport: func(_ kvdb.RwTx,
+			report *channeldb.ResolverReport) error {
+
+			return nil
+		},
+	}
+
+	cfg := ResolverConfig{
+		ChannelArbitratorConfig: chainCfg,
+		Checkpoint: func(_ ContractResolver,
+			_ ...*channeldb.ResolverReport) error {
+
+			checkPointChan <- struct{}{}
+			return nil
+		},
+	}
+
+	testCtx.resolver = &htlcSuccessResolver{
+		contractResolverKit: *newContractResolverKit(cfg),
+		htlcResolution:      lnwallet.IncomingHtlcResolution{},
+		htlc: channeldb.HTLC{
+			RHash:     testResHash,
+			OnionBlob: testOnionBlob,
+			Amt:       testHtlcAmt,
+		},
+	}
+
+	return testCtx
+}
+
+func (i *htlcSuccessResolverTestContext) resolve() {
+	// Start resolver.
+	i.resolverResultChan = make(chan resolveResult, 1)
+	go func() {
+		nextResolver, err := i.resolver.Resolve()
+		i.resolverResultChan <- resolveResult{
+			nextResolver: nextResolver,
+			err:          err,
+		}
+	}()
+}
+
+func (i *htlcSuccessResolverTestContext) waitForResult() {
+	i.t.Helper()
+
+	result := <-i.resolverResultChan
+	if result.err != nil {
+		i.t.Fatal(result.err)
+	}
+
+	if result.nextResolver != nil {
+		i.t.Fatal("expected no next resolver")
+	}
+}
+
+// TestSingleStageSuccess tests successful sweep of a single stage htlc claim.
+func TestSingleStageSuccess(t *testing.T) {
+	htlcOutpoint := wire.OutPoint{Index: 3}
+
+	sweepTx := &wire.MsgTx{
+		TxIn:  []*wire.TxIn{{}},
+		TxOut: []*wire.TxOut{{}},
+	}
+
+	// singleStageResolution is a resolution for a htlc on the remote
+	// party's commitment.
+	singleStageResolution := lnwallet.IncomingHtlcResolution{
+		SweepSignDesc: testSignDesc,
+		ClaimOutpoint: htlcOutpoint,
+	}
+
+	// We send a confirmation for our sweep tx to indicate that our sweep
+	// succeeded.
+	resolve := func(ctx *htlcSuccessResolverTestContext) {
+		ctx.notifier.confChan <- &chainntnfs.TxConfirmation{
+			Tx:          ctx.resolver.sweepTx,
+			BlockHeight: testInitialBlockHeight - 1,
+		}
+	}
+
+	sweepTxid := sweepTx.TxHash()
+	claim := &channeldb.ResolverReport{
+		OutPoint:        htlcOutpoint,
+		Amount:          btcutil.Amount(testSignDesc.Output.Value),
+		ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeClaimed,
+		SpendTxID:       &sweepTxid,
+	}
+	testHtlcSuccess(
+		t, singleStageResolution, resolve, sweepTx, claim,
+	)
+}
+
+// TestSecondStageResolution tests successful sweep of a second stage htlc
+// claim.
+func TestSecondStageResolution(t *testing.T) {
+	commitOutpoint := wire.OutPoint{Index: 2}
+	htlcOutpoint := wire.OutPoint{Index: 3}
+
+	sweepTx := &wire.MsgTx{
+		TxIn:  []*wire.TxIn{{}},
+		TxOut: []*wire.TxOut{{}},
+	}
+	sweepHash := sweepTx.TxHash()
+
+	// twoStageResolution is a resolution for htlc on our own commitment
+	// which is spent from the signed success tx.
+	twoStageResolution := lnwallet.IncomingHtlcResolution{
+		Preimage: [32]byte{},
+		SignedSuccessTx: &wire.MsgTx{
+			TxIn: []*wire.TxIn{
+				{
+					PreviousOutPoint: commitOutpoint,
+				},
+			},
+			TxOut: []*wire.TxOut{},
+		},
+		ClaimOutpoint: htlcOutpoint,
+		SweepSignDesc: testSignDesc,
+	}
+
+	// We send a spend notification for our output to resolve our htlc.
+	resolve := func(ctx *htlcSuccessResolverTestContext) {
+		ctx.notifier.spendChan <- &chainntnfs.SpendDetail{
+			SpendingTx:    sweepTx,
+			SpenderTxHash: &sweepHash,
+		}
+	}
+
+	successTx := twoStageResolution.SignedSuccessTx.TxHash()
+	firstStage := &channeldb.ResolverReport{
+		OutPoint:        commitOutpoint,
+		Amount:          testHtlcAmt.ToSatoshis(),
+		ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeFirstStage,
+		SpendTxID:       &successTx,
+	}
+
+	secondStage := &channeldb.ResolverReport{
+		OutPoint:        htlcOutpoint,
+		Amount:          btcutil.Amount(testSignDesc.Output.Value),
+		ResolverType:    channeldb.ResolverTypeIncomingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeClaimed,
+		SpendTxID:       &sweepHash,
+	}
+
+	testHtlcSuccess(
+		t, twoStageResolution, resolve, sweepTx, secondStage, firstStage,
+	)
+}
+
+// testHtlcSuccess tests resolution of a success resolver. It takes a resolve
+// function which triggers resolution and the sweeptxid that will resolve it.
+func testHtlcSuccess(t *testing.T, resolution lnwallet.IncomingHtlcResolution,
+	resolve func(*htlcSuccessResolverTestContext),
+	sweepTx *wire.MsgTx, reports ...*channeldb.ResolverReport) {
+
+	defer timeout(t)()
+
+	ctx := newHtlcSuccessResolverTextContext(t)
+
+	// Replace our checkpoint with one which will push reports into a
+	// channel for us to consume. We replace this function on the resolver
+	// itself because it is created by the test context.
+	reportChan := make(chan *channeldb.ResolverReport)
+	ctx.resolver.Checkpoint = func(_ ContractResolver,
+		reports ...*channeldb.ResolverReport) error {
+
+		// Send all of our reports into the channel.
+		for _, report := range reports {
+			reportChan <- report
+		}
+
+		return nil
+	}
+
+	ctx.resolver.htlcResolution = resolution
+
+	// We set the sweepTx to be non-nil and mark the output as already
+	// incubating so that we do not need to set test values for crafting
+	// our own sweep transaction.
+	ctx.resolver.sweepTx = sweepTx
+	ctx.resolver.outputIncubating = true
+
+	// Start the htlc success resolver.
+	ctx.resolve()
+
+	// Trigger and event that will resolve our test context.
+	resolve(ctx)
+
+	for _, report := range reports {
+		assertResolverReport(t, reportChan, report)
+	}
+
+	// Wait for the resolver to fully complete.
+	ctx.waitForResult()
+}

contractcourt/htlc_timeout_resolver.go

@@ -5,7 +5,9 @@ import (
 	"fmt"
 	"io"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
 	"github.com/davecgh/go-spew/spew"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
@@ -157,7 +159,19 @@ func (h *htlcTimeoutResolver) claimCleanUp(
 		return nil, err
 	}
 	h.resolved = true
-	return nil, h.Checkpoint(h)
+
+	// Checkpoint our resolver with a report which reflects the preimage
+	// claim by the remote party.
+	amt := btcutil.Amount(h.htlcResolution.SweepSignDesc.Output.Value)
+	report := &channeldb.ResolverReport{
+		OutPoint:        h.htlcResolution.ClaimOutpoint,
+		Amount:          amt,
+		ResolverType:    channeldb.ResolverTypeOutgoingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeClaimed,
+		SpendTxID:       commitSpend.SpenderTxHash,
+	}
+
+	return nil, h.Checkpoint(h, report)
 }
 
 // chainDetailsToWatch returns the output and script which we use to watch for
@@ -262,6 +276,8 @@ func (h *htlcTimeoutResolver) Resolve() (ContractResolver, error) {
 		}
 	}
 
+	var spendTxID *chainhash.Hash
+
 	// waitForOutputResolution waits for the HTLC output to be fully
 	// resolved. The output is considered fully resolved once it has been
 	// spent, and the spending transaction has been fully confirmed.
@@ -278,10 +294,11 @@ func (h *htlcTimeoutResolver) Resolve() (ContractResolver, error) {
 		}
 
 		select {
-		case _, ok := <-spendNtfn.Spend:
+		case spendDetail, ok := <-spendNtfn.Spend:
 			if !ok {
 				return errResolverShuttingDown
 			}
+			spendTxID = spendDetail.SpenderTxHash
 
 		case <-h.quit:
 			return errResolverShuttingDown
@@ -320,6 +337,7 @@ func (h *htlcTimeoutResolver) Resolve() (ContractResolver, error) {
 		if !ok {
 			return nil, errResolverShuttingDown
 		}
+		spendTxID = spend.SpenderTxHash
 
 	case <-h.quit:
 		return nil, errResolverShuttingDown
@@ -352,6 +370,8 @@ func (h *htlcTimeoutResolver) Resolve() (ContractResolver, error) {
 		return nil, err
 	}
 
+	var reports []*channeldb.ResolverReport
+
 	// Finally, if this was an output on our commitment transaction, we'll
 	// wait for the second-level HTLC output to be spent, and for that
 	// transaction itself to confirm.
@@ -361,12 +381,35 @@ func (h *htlcTimeoutResolver) Resolve() (ContractResolver, error) {
 		if err := waitForOutputResolution(); err != nil {
 			return nil, err
 		}
+
+		// Once our timeout tx has confirmed, we add a resolution for
+		// our timeoutTx tx first stage transaction.
+		timeoutTx := h.htlcResolution.SignedTimeoutTx
+		spendHash := timeoutTx.TxHash()
+
+		reports = append(reports, &channeldb.ResolverReport{
+			OutPoint:        timeoutTx.TxIn[0].PreviousOutPoint,
+			Amount:          h.htlc.Amt.ToSatoshis(),
+			ResolverType:    channeldb.ResolverTypeOutgoingHtlc,
+			ResolverOutcome: channeldb.ResolverOutcomeFirstStage,
+			SpendTxID:       &spendHash,
+		})
 	}
 
 	// With the clean up message sent, we'll now mark the contract
-	// resolved, and wait.
+	// resolved, record the timeout and the sweep txid on disk, and wait.
 	h.resolved = true
-	return nil, h.Checkpoint(h)
+
+	amt := btcutil.Amount(h.htlcResolution.SweepSignDesc.Output.Value)
+	reports = append(reports, &channeldb.ResolverReport{
+		OutPoint:        h.htlcResolution.ClaimOutpoint,
+		Amount:          amt,
+		ResolverType:    channeldb.ResolverTypeOutgoingHtlc,
+		ResolverOutcome: channeldb.ResolverOutcomeTimeout,
+		SpendTxID:       spendTxID,
+	})
+
+	return nil, h.Checkpoint(h, reports...)
 }
 
 // Stop signals the resolver to cancel any current resolution processes, and

contractcourt/htlc_timeout_resolver_test.go

@@ -10,7 +10,10 @@ import (
 	"github.com/btcsuite/btcd/btcec"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
 	"github.com/lightningnetwork/lnd/chainntnfs"
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channeldb/kvdb"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwallet"
@@ -127,6 +130,10 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 		// can use this to customize the witness used when spending to
 		// trigger various redemption cases.
 		txToBroadcast func() (*wire.MsgTx, error)
+
+		// outcome is the resolver outcome that we expect to be reported
+		// once the contract is fully resolved.
+		outcome channeldb.ResolverOutcome
 	}{
 		// Remote commitment is broadcast, we time out the HTLC on
 		// chain, and should expect a fail HTLC resolution.
@@ -146,6 +153,7 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 				templateTx.TxIn[0].Witness = witness
 				return templateTx, nil
 			},
+			outcome: channeldb.ResolverOutcomeTimeout,
 		},
 
 		// Our local commitment is broadcast, we timeout the HTLC and
@@ -164,8 +172,13 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 				}
 
 				templateTx.TxIn[0].Witness = witness
+
+				// Set the outpoint to be on our commitment, since
+				// we need to claim in two stages.
+				templateTx.TxIn[0].PreviousOutPoint = testChanPoint1
 				return templateTx, nil
 			},
+			outcome: channeldb.ResolverOutcomeTimeout,
 		},
 
 		// The remote commitment is broadcast, they sweep with the
@@ -187,6 +200,7 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 				templateTx.TxIn[0].Witness = witness
 				return templateTx, nil
 			},
+			outcome: channeldb.ResolverOutcomeClaimed,
 		},
 
 		// The local commitment is broadcast, they sweep it with a
@@ -208,6 +222,7 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 				templateTx.TxIn[0].Witness = witness
 				return templateTx, nil
 			},
+			outcome: channeldb.ResolverOutcomeClaimed,
 		},
 	}
 
@@ -224,6 +239,7 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 		checkPointChan := make(chan struct{}, 1)
 		incubateChan := make(chan struct{}, 1)
 		resolutionChan := make(chan ResolutionMsg, 1)
+		reportChan := make(chan *channeldb.ResolverReport)
 
 		chainCfg := ChannelArbitratorConfig{
 			ChainArbitratorConfig: ChainArbitratorConfig{
@@ -248,27 +264,59 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 					return nil
 				},
 			},
+			PutResolverReport: func(_ kvdb.RwTx,
+				_ *channeldb.ResolverReport) error {
+
+				return nil
+			},
 		}
 
 		cfg := ResolverConfig{
 			ChannelArbitratorConfig: chainCfg,
-			Checkpoint: func(_ ContractResolver) error {
+			Checkpoint: func(_ ContractResolver,
+				reports ...*channeldb.ResolverReport) error {
+
 				checkPointChan <- struct{}{}
+
+				// Send all of our reports into the channel.
+				for _, report := range reports {
+					reportChan <- report
+				}
+
 				return nil
 			},
 		}
 		resolver := &htlcTimeoutResolver{
+			htlcResolution: lnwallet.OutgoingHtlcResolution{
+				ClaimOutpoint: testChanPoint2,
+				SweepSignDesc: *fakeSignDesc,
+			},
 			contractResolverKit: *newContractResolverKit(
 				cfg,
 			),
+			htlc: channeldb.HTLC{
+				Amt: testHtlcAmt,
+			},
 		}
-		resolver.htlcResolution.SweepSignDesc = *fakeSignDesc
+
+		var reports []*channeldb.ResolverReport
 
 		// If the test case needs the remote commitment to be
 		// broadcast, then we'll set the timeout commit to a fake
 		// transaction to force the code path.
 		if !testCase.remoteCommit {
 			resolver.htlcResolution.SignedTimeoutTx = sweepTx
+
+			if testCase.timeout {
+				success := sweepTx.TxHash()
+				reports = append(reports, &channeldb.ResolverReport{
+					OutPoint:        sweepTx.TxIn[0].PreviousOutPoint,
+					Amount:          testHtlcAmt.ToSatoshis(),
+					ResolverType:    channeldb.ResolverTypeOutgoingHtlc,
+					ResolverOutcome: channeldb.ResolverOutcomeFirstStage,
+					SpendTxID:       &success,
+				})
+			}
 		}
 
 		// With all the setup above complete, we can initiate the
@@ -303,9 +351,12 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 		if err != nil {
 			t.Fatalf("unable to generate tx: %v", err)
 		}
+		spendTxHash := spendingTx.TxHash()
+
 		select {
 		case notifier.spendChan <- &chainntnfs.SpendDetail{
-			SpendingTx: spendingTx,
+			SpendingTx:    spendingTx,
+			SpenderTxHash: &spendTxHash,
 		}:
 		case <-time.After(time.Second * 5):
 			t.Fatalf("failed to request spend ntfn")
@@ -361,7 +412,8 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 			if !testCase.remoteCommit {
 				select {
 				case notifier.spendChan <- &chainntnfs.SpendDetail{
-					SpendingTx: spendingTx,
+					SpendingTx:    spendingTx,
+					SpenderTxHash: &spendTxHash,
 				}:
 				case <-time.After(time.Second * 5):
 					t.Fatalf("failed to request spend ntfn")
@@ -379,6 +431,23 @@ func TestHtlcTimeoutResolver(t *testing.T) {
 			t.Fatalf("check point not received")
 		}
 
+		// Add a report to our set of expected reports with the outcome
+		// that the test specifies (either success or timeout).
+		spendTxID := spendingTx.TxHash()
+		amt := btcutil.Amount(fakeSignDesc.Output.Value)
+
+		reports = append(reports, &channeldb.ResolverReport{
+			OutPoint:        testChanPoint2,
+			Amount:          amt,
+			ResolverType:    channeldb.ResolverTypeOutgoingHtlc,
+			ResolverOutcome: testCase.outcome,
+			SpendTxID:       &spendTxID,
+		})
+
+		for _, report := range reports {
+			assertResolverReport(t, reportChan, report)
+		}
+
 		wg.Wait()
 
 		// Finally, the resolver should be marked as resolved.

lnrpc/rpc.pb.go

@@ -136,6 +136,100 @@ func (Initiator) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_77a6da22d6a3feb1, []int{2}
 }
 
+type ResolutionType int32
+
+const (
+	ResolutionType_TYPE_UNKNOWN ResolutionType = 0
+	// We resolved an anchor output.
+	ResolutionType_ANCHOR ResolutionType = 1
+	//
+	//We are resolving an incoming htlc on chain. This if this htlc is
+	//claimed, we swept the incoming htlc with the preimage. If it is timed
+	//out, our peer swept the timeout path.
+	ResolutionType_INCOMING_HTLC ResolutionType = 2
+	//
+	//We are resolving an outgoing htlc on chain. If this htlc is claimed,
+	//the remote party swept the htlc with the preimage. If it is timed out,
+	//we swept it with the timeout path.
+	ResolutionType_OUTGOING_HTLC ResolutionType = 3
+	// We force closed and need to sweep our time locked commitment output.
+	ResolutionType_COMMIT ResolutionType = 4
+)
+
+var ResolutionType_name = map[int32]string{
+	0: "TYPE_UNKNOWN",
+	1: "ANCHOR",
+	2: "INCOMING_HTLC",
+	3: "OUTGOING_HTLC",
+	4: "COMMIT",
+}
+
+var ResolutionType_value = map[string]int32{
+	"TYPE_UNKNOWN":  0,
+	"ANCHOR":        1,
+	"INCOMING_HTLC": 2,
+	"OUTGOING_HTLC": 3,
+	"COMMIT":        4,
+}
+
+func (x ResolutionType) String() string {
+	return proto.EnumName(ResolutionType_name, int32(x))
+}
+
+func (ResolutionType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_77a6da22d6a3feb1, []int{3}
+}
+
+type ResolutionOutcome int32
+
+const (
+	// Outcome unknown.
+	ResolutionOutcome_OUTCOME_UNKNOWN ResolutionOutcome = 0
+	// An output was claimed on chain.
+	ResolutionOutcome_CLAIMED ResolutionOutcome = 1
+	// An output was left unclaimed on chain.
+	ResolutionOutcome_UNCLAIMED ResolutionOutcome = 2
+	//
+	//ResolverOutcomeAbandoned indicates that an output that we did not
+	//claim on chain, for example an anchor that we did not sweep and a
+	//third party claimed on chain, or a htlc that we could not decode
+	//so left unclaimed.
+	ResolutionOutcome_ABANDONED ResolutionOutcome = 3
+	//
+	//If we force closed our channel, our htlcs need to be claimed in two
+	//stages. This outcome represents the broadcast of a timeout or success
+	//transaction for this two stage htlc claim.
+	ResolutionOutcome_FIRST_STAGE ResolutionOutcome = 4
+	// A htlc was timed out on chain.
+	ResolutionOutcome_TIMEOUT ResolutionOutcome = 5
+)
+
+var ResolutionOutcome_name = map[int32]string{
+	0: "OUTCOME_UNKNOWN",
+	1: "CLAIMED",
+	2: "UNCLAIMED",
+	3: "ABANDONED",
+	4: "FIRST_STAGE",
+	5: "TIMEOUT",
+}
+
+var ResolutionOutcome_value = map[string]int32{
+	"OUTCOME_UNKNOWN": 0,
+	"CLAIMED":         1,
+	"UNCLAIMED":       2,
+	"ABANDONED":       3,
+	"FIRST_STAGE":     4,
+	"TIMEOUT":         5,
+}
+
+func (x ResolutionOutcome) String() string {
+	return proto.EnumName(ResolutionOutcome_name, int32(x))
+}
+
+func (ResolutionOutcome) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_77a6da22d6a3feb1, []int{4}
+}
+
 type NodeMetricType int32
 
 const (
@@ -158,7 +252,7 @@ func (x NodeMetricType) String() string {
 }
 
 func (NodeMetricType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{3}
+	return fileDescriptor_77a6da22d6a3feb1, []int{5}
 }
 
 type InvoiceHTLCState int32
@@ -186,7 +280,7 @@ func (x InvoiceHTLCState) String() string {
 }
 
 func (InvoiceHTLCState) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{4}
+	return fileDescriptor_77a6da22d6a3feb1, []int{6}
 }
 
 type PaymentFailureReason int32
@@ -237,7 +331,7 @@ func (x PaymentFailureReason) String() string {
 }
 
 func (PaymentFailureReason) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{5}
+	return fileDescriptor_77a6da22d6a3feb1, []int{7}
 }
 
 type FeatureBit int32
@@ -307,7 +401,7 @@ func (x FeatureBit) String() string {
 }
 
 func (FeatureBit) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{6}
+	return fileDescriptor_77a6da22d6a3feb1, []int{8}
 }
 
 type ChannelCloseSummary_ClosureType int32
@@ -378,7 +472,7 @@ func (x Peer_SyncType) String() string {
 }
 
 func (Peer_SyncType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{39, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{40, 0}
 }
 
 type PeerEvent_EventType int32
@@ -403,7 +497,7 @@ func (x PeerEvent_EventType) String() string {
 }
 
 func (PeerEvent_EventType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{44, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{45, 0}
 }
 
 type PendingChannelsResponse_ForceClosedChannel_AnchorState int32
@@ -431,7 +525,7 @@ func (x PendingChannelsResponse_ForceClosedChannel_AnchorState) String() string
 }
 
 func (PendingChannelsResponse_ForceClosedChannel_AnchorState) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71, 5, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72, 5, 0}
 }
 
 type ChannelEventUpdate_UpdateType int32
@@ -465,7 +559,7 @@ func (x ChannelEventUpdate_UpdateType) String() string {
 }
 
 func (ChannelEventUpdate_UpdateType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{73, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{74, 0}
 }
 
 type Invoice_InvoiceState int32
@@ -496,7 +590,7 @@ func (x Invoice_InvoiceState) String() string {
 }
 
 func (Invoice_InvoiceState) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{108, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{109, 0}
 }
 
 type Payment_PaymentStatus int32
@@ -527,7 +621,7 @@ func (x Payment_PaymentStatus) String() string {
 }
 
 func (Payment_PaymentStatus) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{115, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{116, 0}
 }
 
 type HTLCAttempt_HTLCStatus int32
@@ -555,7 +649,7 @@ func (x HTLCAttempt_HTLCStatus) String() string {
 }
 
 func (HTLCAttempt_HTLCStatus) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{116, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{117, 0}
 }
 
 type Failure_FailureCode int32
@@ -666,7 +760,7 @@ func (x Failure_FailureCode) String() string {
 }
 
 func (Failure_FailureCode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{149, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{150, 0}
 }
 
 type Utxo struct {
@@ -3289,10 +3383,11 @@ type ChannelCloseSummary struct {
 	//tracking cooperative close initiators. Note that this indicates which party
 	//initiated a close, and it is possible for both to initiate cooperative or
 	//force closes, although only one party's close will be confirmed on chain.
-	CloseInitiator       Initiator `protobuf:"varint,12,opt,name=close_initiator,json=closeInitiator,proto3,enum=lnrpc.Initiator" json:"close_initiator,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	CloseInitiator       Initiator     `protobuf:"varint,12,opt,name=close_initiator,json=closeInitiator,proto3,enum=lnrpc.Initiator" json:"close_initiator,omitempty"`
+	Resolutions          []*Resolution `protobuf:"bytes,13,rep,name=resolutions,proto3" json:"resolutions,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
+	XXX_unrecognized     []byte        `json:"-"`
+	XXX_sizecache        int32         `json:"-"`
 }
 
 func (m *ChannelCloseSummary) Reset()         { *m = ChannelCloseSummary{} }
@@ -3404,6 +3499,90 @@ func (m *ChannelCloseSummary) GetCloseInitiator() Initiator {
 	return Initiator_INITIATOR_UNKNOWN
 }
 
+func (m *ChannelCloseSummary) GetResolutions() []*Resolution {
+	if m != nil {
+		return m.Resolutions
+	}
+	return nil
+}
+
+type Resolution struct {
+	// The type of output we are resolving.
+	ResolutionType ResolutionType `protobuf:"varint,1,opt,name=resolution_type,json=resolutionType,proto3,enum=lnrpc.ResolutionType" json:"resolution_type,omitempty"`
+	// The outcome of our on chain action that resolved the outpoint.
+	Outcome ResolutionOutcome `protobuf:"varint,2,opt,name=outcome,proto3,enum=lnrpc.ResolutionOutcome" json:"outcome,omitempty"`
+	// The outpoint that was spent by the resolution.
+	Outpoint *OutPoint `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"`
+	// The amount that was claimed by the resolution.
+	AmountSat uint64 `protobuf:"varint,4,opt,name=amount_sat,json=amountSat,proto3" json:"amount_sat,omitempty"`
+	// The hex-encoded transaction ID of the sweep transaction that spent the
+	// output.
+	SweepTxid            string   `protobuf:"bytes,5,opt,name=sweep_txid,json=sweepTxid,proto3" json:"sweep_txid,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Resolution) Reset()         { *m = Resolution{} }
+func (m *Resolution) String() string { return proto.CompactTextString(m) }
+func (*Resolution) ProtoMessage()    {}
+func (*Resolution) Descriptor() ([]byte, []int) {
+	return fileDescriptor_77a6da22d6a3feb1, []int{37}
+}
+
+func (m *Resolution) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Resolution.Unmarshal(m, b)
+}
+func (m *Resolution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Resolution.Marshal(b, m, deterministic)
+}
+func (m *Resolution) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Resolution.Merge(m, src)
+}
+func (m *Resolution) XXX_Size() int {
+	return xxx_messageInfo_Resolution.Size(m)
+}
+func (m *Resolution) XXX_DiscardUnknown() {
+	xxx_messageInfo_Resolution.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Resolution proto.InternalMessageInfo
+
+func (m *Resolution) GetResolutionType() ResolutionType {
+	if m != nil {
+		return m.ResolutionType
+	}
+	return ResolutionType_TYPE_UNKNOWN
+}
+
+func (m *Resolution) GetOutcome() ResolutionOutcome {
+	if m != nil {
+		return m.Outcome
+	}
+	return ResolutionOutcome_OUTCOME_UNKNOWN
+}
+
+func (m *Resolution) GetOutpoint() *OutPoint {
+	if m != nil {
+		return m.Outpoint
+	}
+	return nil
+}
+
+func (m *Resolution) GetAmountSat() uint64 {
+	if m != nil {
+		return m.AmountSat
+	}
+	return 0
+}
+
+func (m *Resolution) GetSweepTxid() string {
+	if m != nil {
+		return m.SweepTxid
+	}
+	return ""
+}
+
 type ClosedChannelsRequest struct {
 	Cooperative          bool     `protobuf:"varint,1,opt,name=cooperative,proto3" json:"cooperative,omitempty"`
 	LocalForce           bool     `protobuf:"varint,2,opt,name=local_force,json=localForce,proto3" json:"local_force,omitempty"`
@@ -3420,7 +3599,7 @@ func (m *ClosedChannelsRequest) Reset()         { *m = ClosedChannelsRequest{} }
 func (m *ClosedChannelsRequest) String() string { return proto.CompactTextString(m) }
 func (*ClosedChannelsRequest) ProtoMessage()    {}
 func (*ClosedChannelsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{37}
+	return fileDescriptor_77a6da22d6a3feb1, []int{38}
 }
 
 func (m *ClosedChannelsRequest) XXX_Unmarshal(b []byte) error {
@@ -3494,7 +3673,7 @@ func (m *ClosedChannelsResponse) Reset()         { *m = ClosedChannelsResponse{}
 func (m *ClosedChannelsResponse) String() string { return proto.CompactTextString(m) }
 func (*ClosedChannelsResponse) ProtoMessage()    {}
 func (*ClosedChannelsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{38}
+	return fileDescriptor_77a6da22d6a3feb1, []int{39}
 }
 
 func (m *ClosedChannelsResponse) XXX_Unmarshal(b []byte) error {
@@ -3559,7 +3738,7 @@ func (m *Peer) Reset()         { *m = Peer{} }
 func (m *Peer) String() string { return proto.CompactTextString(m) }
 func (*Peer) ProtoMessage()    {}
 func (*Peer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{39}
+	return fileDescriptor_77a6da22d6a3feb1, []int{40}
 }
 
 func (m *Peer) XXX_Unmarshal(b []byte) error {
@@ -3671,7 +3850,7 @@ func (m *TimestampedError) Reset()         { *m = TimestampedError{} }
 func (m *TimestampedError) String() string { return proto.CompactTextString(m) }
 func (*TimestampedError) ProtoMessage()    {}
 func (*TimestampedError) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{40}
+	return fileDescriptor_77a6da22d6a3feb1, []int{41}
 }
 
 func (m *TimestampedError) XXX_Unmarshal(b []byte) error {
@@ -3721,7 +3900,7 @@ func (m *ListPeersRequest) Reset()         { *m = ListPeersRequest{} }
 func (m *ListPeersRequest) String() string { return proto.CompactTextString(m) }
 func (*ListPeersRequest) ProtoMessage()    {}
 func (*ListPeersRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{41}
+	return fileDescriptor_77a6da22d6a3feb1, []int{42}
 }
 
 func (m *ListPeersRequest) XXX_Unmarshal(b []byte) error {
@@ -3761,7 +3940,7 @@ func (m *ListPeersResponse) Reset()         { *m = ListPeersResponse{} }
 func (m *ListPeersResponse) String() string { return proto.CompactTextString(m) }
 func (*ListPeersResponse) ProtoMessage()    {}
 func (*ListPeersResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{42}
+	return fileDescriptor_77a6da22d6a3feb1, []int{43}
 }
 
 func (m *ListPeersResponse) XXX_Unmarshal(b []byte) error {
@@ -3799,7 +3978,7 @@ func (m *PeerEventSubscription) Reset()         { *m = PeerEventSubscription{} }
 func (m *PeerEventSubscription) String() string { return proto.CompactTextString(m) }
 func (*PeerEventSubscription) ProtoMessage()    {}
 func (*PeerEventSubscription) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{43}
+	return fileDescriptor_77a6da22d6a3feb1, []int{44}
 }
 
 func (m *PeerEventSubscription) XXX_Unmarshal(b []byte) error {
@@ -3833,7 +4012,7 @@ func (m *PeerEvent) Reset()         { *m = PeerEvent{} }
 func (m *PeerEvent) String() string { return proto.CompactTextString(m) }
 func (*PeerEvent) ProtoMessage()    {}
 func (*PeerEvent) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{44}
+	return fileDescriptor_77a6da22d6a3feb1, []int{45}
 }
 
 func (m *PeerEvent) XXX_Unmarshal(b []byte) error {
@@ -3878,7 +4057,7 @@ func (m *GetInfoRequest) Reset()         { *m = GetInfoRequest{} }
 func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*GetInfoRequest) ProtoMessage()    {}
 func (*GetInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{45}
+	return fileDescriptor_77a6da22d6a3feb1, []int{46}
 }
 
 func (m *GetInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -3949,7 +4128,7 @@ func (m *GetInfoResponse) Reset()         { *m = GetInfoResponse{} }
 func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*GetInfoResponse) ProtoMessage()    {}
 func (*GetInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{46}
+	return fileDescriptor_77a6da22d6a3feb1, []int{47}
 }
 
 func (m *GetInfoResponse) XXX_Unmarshal(b []byte) error {
@@ -4107,7 +4286,7 @@ func (m *GetRecoveryInfoRequest) Reset()         { *m = GetRecoveryInfoRequest{}
 func (m *GetRecoveryInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*GetRecoveryInfoRequest) ProtoMessage()    {}
 func (*GetRecoveryInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{47}
+	return fileDescriptor_77a6da22d6a3feb1, []int{48}
 }
 
 func (m *GetRecoveryInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -4144,7 +4323,7 @@ func (m *GetRecoveryInfoResponse) Reset()         { *m = GetRecoveryInfoResponse
 func (m *GetRecoveryInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*GetRecoveryInfoResponse) ProtoMessage()    {}
 func (*GetRecoveryInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{48}
+	return fileDescriptor_77a6da22d6a3feb1, []int{49}
 }
 
 func (m *GetRecoveryInfoResponse) XXX_Unmarshal(b []byte) error {
@@ -4200,7 +4379,7 @@ func (m *Chain) Reset()         { *m = Chain{} }
 func (m *Chain) String() string { return proto.CompactTextString(m) }
 func (*Chain) ProtoMessage()    {}
 func (*Chain) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{49}
+	return fileDescriptor_77a6da22d6a3feb1, []int{50}
 }
 
 func (m *Chain) XXX_Unmarshal(b []byte) error {
@@ -4248,7 +4427,7 @@ func (m *ConfirmationUpdate) Reset()         { *m = ConfirmationUpdate{} }
 func (m *ConfirmationUpdate) String() string { return proto.CompactTextString(m) }
 func (*ConfirmationUpdate) ProtoMessage()    {}
 func (*ConfirmationUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{50}
+	return fileDescriptor_77a6da22d6a3feb1, []int{51}
 }
 
 func (m *ConfirmationUpdate) XXX_Unmarshal(b []byte) error {
@@ -4301,7 +4480,7 @@ func (m *ChannelOpenUpdate) Reset()         { *m = ChannelOpenUpdate{} }
 func (m *ChannelOpenUpdate) String() string { return proto.CompactTextString(m) }
 func (*ChannelOpenUpdate) ProtoMessage()    {}
 func (*ChannelOpenUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{51}
+	return fileDescriptor_77a6da22d6a3feb1, []int{52}
 }
 
 func (m *ChannelOpenUpdate) XXX_Unmarshal(b []byte) error {
@@ -4341,7 +4520,7 @@ func (m *ChannelCloseUpdate) Reset()         { *m = ChannelCloseUpdate{} }
 func (m *ChannelCloseUpdate) String() string { return proto.CompactTextString(m) }
 func (*ChannelCloseUpdate) ProtoMessage()    {}
 func (*ChannelCloseUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{52}
+	return fileDescriptor_77a6da22d6a3feb1, []int{53}
 }
 
 func (m *ChannelCloseUpdate) XXX_Unmarshal(b []byte) error {
@@ -4406,7 +4585,7 @@ func (m *CloseChannelRequest) Reset()         { *m = CloseChannelRequest{} }
 func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) }
 func (*CloseChannelRequest) ProtoMessage()    {}
 func (*CloseChannelRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{53}
+	return fileDescriptor_77a6da22d6a3feb1, []int{54}
 }
 
 func (m *CloseChannelRequest) XXX_Unmarshal(b []byte) error {
@@ -4476,7 +4655,7 @@ func (m *CloseStatusUpdate) Reset()         { *m = CloseStatusUpdate{} }
 func (m *CloseStatusUpdate) String() string { return proto.CompactTextString(m) }
 func (*CloseStatusUpdate) ProtoMessage()    {}
 func (*CloseStatusUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{54}
+	return fileDescriptor_77a6da22d6a3feb1, []int{55}
 }
 
 func (m *CloseStatusUpdate) XXX_Unmarshal(b []byte) error {
@@ -4554,7 +4733,7 @@ func (m *PendingUpdate) Reset()         { *m = PendingUpdate{} }
 func (m *PendingUpdate) String() string { return proto.CompactTextString(m) }
 func (*PendingUpdate) ProtoMessage()    {}
 func (*PendingUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{55}
+	return fileDescriptor_77a6da22d6a3feb1, []int{56}
 }
 
 func (m *PendingUpdate) XXX_Unmarshal(b []byte) error {
@@ -4613,7 +4792,7 @@ func (m *ReadyForPsbtFunding) Reset()         { *m = ReadyForPsbtFunding{} }
 func (m *ReadyForPsbtFunding) String() string { return proto.CompactTextString(m) }
 func (*ReadyForPsbtFunding) ProtoMessage()    {}
 func (*ReadyForPsbtFunding) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{56}
+	return fileDescriptor_77a6da22d6a3feb1, []int{57}
 }
 
 func (m *ReadyForPsbtFunding) XXX_Unmarshal(b []byte) error {
@@ -4720,7 +4899,7 @@ func (m *OpenChannelRequest) Reset()         { *m = OpenChannelRequest{} }
 func (m *OpenChannelRequest) String() string { return proto.CompactTextString(m) }
 func (*OpenChannelRequest) ProtoMessage()    {}
 func (*OpenChannelRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{57}
+	return fileDescriptor_77a6da22d6a3feb1, []int{58}
 }
 
 func (m *OpenChannelRequest) XXX_Unmarshal(b []byte) error {
@@ -4859,7 +5038,7 @@ func (m *OpenStatusUpdate) Reset()         { *m = OpenStatusUpdate{} }
 func (m *OpenStatusUpdate) String() string { return proto.CompactTextString(m) }
 func (*OpenStatusUpdate) ProtoMessage()    {}
 func (*OpenStatusUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{58}
+	return fileDescriptor_77a6da22d6a3feb1, []int{59}
 }
 
 func (m *OpenStatusUpdate) XXX_Unmarshal(b []byte) error {
@@ -4960,7 +5139,7 @@ func (m *KeyLocator) Reset()         { *m = KeyLocator{} }
 func (m *KeyLocator) String() string { return proto.CompactTextString(m) }
 func (*KeyLocator) ProtoMessage()    {}
 func (*KeyLocator) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{59}
+	return fileDescriptor_77a6da22d6a3feb1, []int{60}
 }
 
 func (m *KeyLocator) XXX_Unmarshal(b []byte) error {
@@ -5011,7 +5190,7 @@ func (m *KeyDescriptor) Reset()         { *m = KeyDescriptor{} }
 func (m *KeyDescriptor) String() string { return proto.CompactTextString(m) }
 func (*KeyDescriptor) ProtoMessage()    {}
 func (*KeyDescriptor) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{60}
+	return fileDescriptor_77a6da22d6a3feb1, []int{61}
 }
 
 func (m *KeyDescriptor) XXX_Unmarshal(b []byte) error {
@@ -5079,7 +5258,7 @@ func (m *ChanPointShim) Reset()         { *m = ChanPointShim{} }
 func (m *ChanPointShim) String() string { return proto.CompactTextString(m) }
 func (*ChanPointShim) ProtoMessage()    {}
 func (*ChanPointShim) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{61}
+	return fileDescriptor_77a6da22d6a3feb1, []int{62}
 }
 
 func (m *ChanPointShim) XXX_Unmarshal(b []byte) error {
@@ -5161,7 +5340,7 @@ func (m *PsbtShim) Reset()         { *m = PsbtShim{} }
 func (m *PsbtShim) String() string { return proto.CompactTextString(m) }
 func (*PsbtShim) ProtoMessage()    {}
 func (*PsbtShim) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{62}
+	return fileDescriptor_77a6da22d6a3feb1, []int{63}
 }
 
 func (m *PsbtShim) XXX_Unmarshal(b []byte) error {
@@ -5210,7 +5389,7 @@ func (m *FundingShim) Reset()         { *m = FundingShim{} }
 func (m *FundingShim) String() string { return proto.CompactTextString(m) }
 func (*FundingShim) ProtoMessage()    {}
 func (*FundingShim) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{63}
+	return fileDescriptor_77a6da22d6a3feb1, []int{64}
 }
 
 func (m *FundingShim) XXX_Unmarshal(b []byte) error {
@@ -5288,7 +5467,7 @@ func (m *FundingShimCancel) Reset()         { *m = FundingShimCancel{} }
 func (m *FundingShimCancel) String() string { return proto.CompactTextString(m) }
 func (*FundingShimCancel) ProtoMessage()    {}
 func (*FundingShimCancel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{64}
+	return fileDescriptor_77a6da22d6a3feb1, []int{65}
 }
 
 func (m *FundingShimCancel) XXX_Unmarshal(b []byte) error {
@@ -5333,7 +5512,7 @@ func (m *FundingPsbtVerify) Reset()         { *m = FundingPsbtVerify{} }
 func (m *FundingPsbtVerify) String() string { return proto.CompactTextString(m) }
 func (*FundingPsbtVerify) ProtoMessage()    {}
 func (*FundingPsbtVerify) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{65}
+	return fileDescriptor_77a6da22d6a3feb1, []int{66}
 }
 
 func (m *FundingPsbtVerify) XXX_Unmarshal(b []byte) error {
@@ -5385,7 +5564,7 @@ func (m *FundingPsbtFinalize) Reset()         { *m = FundingPsbtFinalize{} }
 func (m *FundingPsbtFinalize) String() string { return proto.CompactTextString(m) }
 func (*FundingPsbtFinalize) ProtoMessage()    {}
 func (*FundingPsbtFinalize) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{66}
+	return fileDescriptor_77a6da22d6a3feb1, []int{67}
 }
 
 func (m *FundingPsbtFinalize) XXX_Unmarshal(b []byte) error {
@@ -5436,7 +5615,7 @@ func (m *FundingTransitionMsg) Reset()         { *m = FundingTransitionMsg{} }
 func (m *FundingTransitionMsg) String() string { return proto.CompactTextString(m) }
 func (*FundingTransitionMsg) ProtoMessage()    {}
 func (*FundingTransitionMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{67}
+	return fileDescriptor_77a6da22d6a3feb1, []int{68}
 }
 
 func (m *FundingTransitionMsg) XXX_Unmarshal(b []byte) error {
@@ -5540,7 +5719,7 @@ func (m *FundingStateStepResp) Reset()         { *m = FundingStateStepResp{} }
 func (m *FundingStateStepResp) String() string { return proto.CompactTextString(m) }
 func (*FundingStateStepResp) ProtoMessage()    {}
 func (*FundingStateStepResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{68}
+	return fileDescriptor_77a6da22d6a3feb1, []int{69}
 }
 
 func (m *FundingStateStepResp) XXX_Unmarshal(b []byte) error {
@@ -5586,7 +5765,7 @@ func (m *PendingHTLC) Reset()         { *m = PendingHTLC{} }
 func (m *PendingHTLC) String() string { return proto.CompactTextString(m) }
 func (*PendingHTLC) ProtoMessage()    {}
 func (*PendingHTLC) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{69}
+	return fileDescriptor_77a6da22d6a3feb1, []int{70}
 }
 
 func (m *PendingHTLC) XXX_Unmarshal(b []byte) error {
@@ -5659,7 +5838,7 @@ func (m *PendingChannelsRequest) Reset()         { *m = PendingChannelsRequest{}
 func (m *PendingChannelsRequest) String() string { return proto.CompactTextString(m) }
 func (*PendingChannelsRequest) ProtoMessage()    {}
 func (*PendingChannelsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{70}
+	return fileDescriptor_77a6da22d6a3feb1, []int{71}
 }
 
 func (m *PendingChannelsRequest) XXX_Unmarshal(b []byte) error {
@@ -5703,7 +5882,7 @@ func (m *PendingChannelsResponse) Reset()         { *m = PendingChannelsResponse
 func (m *PendingChannelsResponse) String() string { return proto.CompactTextString(m) }
 func (*PendingChannelsResponse) ProtoMessage()    {}
 func (*PendingChannelsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72}
 }
 
 func (m *PendingChannelsResponse) XXX_Unmarshal(b []byte) error {
@@ -5788,7 +5967,7 @@ func (m *PendingChannelsResponse_PendingChannel) Reset() {
 func (m *PendingChannelsResponse_PendingChannel) String() string { return proto.CompactTextString(m) }
 func (*PendingChannelsResponse_PendingChannel) ProtoMessage()    {}
 func (*PendingChannelsResponse_PendingChannel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71, 0}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72, 0}
 }
 
 func (m *PendingChannelsResponse_PendingChannel) XXX_Unmarshal(b []byte) error {
@@ -5904,7 +6083,7 @@ func (m *PendingChannelsResponse_PendingOpenChannel) String() string {
 }
 func (*PendingChannelsResponse_PendingOpenChannel) ProtoMessage() {}
 func (*PendingChannelsResponse_PendingOpenChannel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71, 1}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72, 1}
 }
 
 func (m *PendingChannelsResponse_PendingOpenChannel) XXX_Unmarshal(b []byte) error {
@@ -5982,7 +6161,7 @@ func (m *PendingChannelsResponse_WaitingCloseChannel) String() string {
 }
 func (*PendingChannelsResponse_WaitingCloseChannel) ProtoMessage() {}
 func (*PendingChannelsResponse_WaitingCloseChannel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71, 2}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72, 2}
 }
 
 func (m *PendingChannelsResponse_WaitingCloseChannel) XXX_Unmarshal(b []byte) error {
@@ -6052,7 +6231,7 @@ func (m *PendingChannelsResponse_Commitments) Reset()         { *m = PendingChan
 func (m *PendingChannelsResponse_Commitments) String() string { return proto.CompactTextString(m) }
 func (*PendingChannelsResponse_Commitments) ProtoMessage()    {}
 func (*PendingChannelsResponse_Commitments) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71, 3}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72, 3}
 }
 
 func (m *PendingChannelsResponse_Commitments) XXX_Unmarshal(b []byte) error {
@@ -6129,7 +6308,7 @@ func (m *PendingChannelsResponse_ClosedChannel) Reset()         { *m = PendingCh
 func (m *PendingChannelsResponse_ClosedChannel) String() string { return proto.CompactTextString(m) }
 func (*PendingChannelsResponse_ClosedChannel) ProtoMessage()    {}
 func (*PendingChannelsResponse_ClosedChannel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71, 4}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72, 4}
 }
 
 func (m *PendingChannelsResponse_ClosedChannel) XXX_Unmarshal(b []byte) error {
@@ -6195,7 +6374,7 @@ func (m *PendingChannelsResponse_ForceClosedChannel) String() string {
 }
 func (*PendingChannelsResponse_ForceClosedChannel) ProtoMessage() {}
 func (*PendingChannelsResponse_ForceClosedChannel) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{71, 5}
+	return fileDescriptor_77a6da22d6a3feb1, []int{72, 5}
 }
 
 func (m *PendingChannelsResponse_ForceClosedChannel) XXX_Unmarshal(b []byte) error {
@@ -6282,7 +6461,7 @@ func (m *ChannelEventSubscription) Reset()         { *m = ChannelEventSubscripti
 func (m *ChannelEventSubscription) String() string { return proto.CompactTextString(m) }
 func (*ChannelEventSubscription) ProtoMessage()    {}
 func (*ChannelEventSubscription) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{72}
+	return fileDescriptor_77a6da22d6a3feb1, []int{73}
 }
 
 func (m *ChannelEventSubscription) XXX_Unmarshal(b []byte) error {
@@ -6321,7 +6500,7 @@ func (m *ChannelEventUpdate) Reset()         { *m = ChannelEventUpdate{} }
 func (m *ChannelEventUpdate) String() string { return proto.CompactTextString(m) }
 func (*ChannelEventUpdate) ProtoMessage()    {}
 func (*ChannelEventUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{73}
+	return fileDescriptor_77a6da22d6a3feb1, []int{74}
 }
 
 func (m *ChannelEventUpdate) XXX_Unmarshal(b []byte) error {
@@ -6446,7 +6625,7 @@ func (m *WalletBalanceRequest) Reset()         { *m = WalletBalanceRequest{} }
 func (m *WalletBalanceRequest) String() string { return proto.CompactTextString(m) }
 func (*WalletBalanceRequest) ProtoMessage()    {}
 func (*WalletBalanceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{74}
+	return fileDescriptor_77a6da22d6a3feb1, []int{75}
 }
 
 func (m *WalletBalanceRequest) XXX_Unmarshal(b []byte) error {
@@ -6483,7 +6662,7 @@ func (m *WalletBalanceResponse) Reset()         { *m = WalletBalanceResponse{} }
 func (m *WalletBalanceResponse) String() string { return proto.CompactTextString(m) }
 func (*WalletBalanceResponse) ProtoMessage()    {}
 func (*WalletBalanceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{75}
+	return fileDescriptor_77a6da22d6a3feb1, []int{76}
 }
 
 func (m *WalletBalanceResponse) XXX_Unmarshal(b []byte) error {
@@ -6535,7 +6714,7 @@ func (m *ChannelBalanceRequest) Reset()         { *m = ChannelBalanceRequest{} }
 func (m *ChannelBalanceRequest) String() string { return proto.CompactTextString(m) }
 func (*ChannelBalanceRequest) ProtoMessage()    {}
 func (*ChannelBalanceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{76}
+	return fileDescriptor_77a6da22d6a3feb1, []int{77}
 }
 
 func (m *ChannelBalanceRequest) XXX_Unmarshal(b []byte) error {
@@ -6570,7 +6749,7 @@ func (m *ChannelBalanceResponse) Reset()         { *m = ChannelBalanceResponse{}
 func (m *ChannelBalanceResponse) String() string { return proto.CompactTextString(m) }
 func (*ChannelBalanceResponse) ProtoMessage()    {}
 func (*ChannelBalanceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{77}
+	return fileDescriptor_77a6da22d6a3feb1, []int{78}
 }
 
 func (m *ChannelBalanceResponse) XXX_Unmarshal(b []byte) error {
@@ -6688,7 +6867,7 @@ func (m *QueryRoutesRequest) Reset()         { *m = QueryRoutesRequest{} }
 func (m *QueryRoutesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryRoutesRequest) ProtoMessage()    {}
 func (*QueryRoutesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{78}
+	return fileDescriptor_77a6da22d6a3feb1, []int{79}
 }
 
 func (m *QueryRoutesRequest) XXX_Unmarshal(b []byte) error {
@@ -6840,7 +7019,7 @@ func (m *NodePair) Reset()         { *m = NodePair{} }
 func (m *NodePair) String() string { return proto.CompactTextString(m) }
 func (*NodePair) ProtoMessage()    {}
 func (*NodePair) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{79}
+	return fileDescriptor_77a6da22d6a3feb1, []int{80}
 }
 
 func (m *NodePair) XXX_Unmarshal(b []byte) error {
@@ -6893,7 +7072,7 @@ func (m *EdgeLocator) Reset()         { *m = EdgeLocator{} }
 func (m *EdgeLocator) String() string { return proto.CompactTextString(m) }
 func (*EdgeLocator) ProtoMessage()    {}
 func (*EdgeLocator) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{80}
+	return fileDescriptor_77a6da22d6a3feb1, []int{81}
 }
 
 func (m *EdgeLocator) XXX_Unmarshal(b []byte) error {
@@ -6946,7 +7125,7 @@ func (m *QueryRoutesResponse) Reset()         { *m = QueryRoutesResponse{} }
 func (m *QueryRoutesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryRoutesResponse) ProtoMessage()    {}
 func (*QueryRoutesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{81}
+	return fileDescriptor_77a6da22d6a3feb1, []int{82}
 }
 
 func (m *QueryRoutesResponse) XXX_Unmarshal(b []byte) error {
@@ -7022,7 +7201,7 @@ func (m *Hop) Reset()         { *m = Hop{} }
 func (m *Hop) String() string { return proto.CompactTextString(m) }
 func (*Hop) ProtoMessage()    {}
 func (*Hop) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{82}
+	return fileDescriptor_77a6da22d6a3feb1, []int{83}
 }
 
 func (m *Hop) XXX_Unmarshal(b []byte) error {
@@ -7144,7 +7323,7 @@ func (m *MPPRecord) Reset()         { *m = MPPRecord{} }
 func (m *MPPRecord) String() string { return proto.CompactTextString(m) }
 func (*MPPRecord) ProtoMessage()    {}
 func (*MPPRecord) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{83}
+	return fileDescriptor_77a6da22d6a3feb1, []int{84}
 }
 
 func (m *MPPRecord) XXX_Unmarshal(b []byte) error {
@@ -7222,7 +7401,7 @@ func (m *Route) Reset()         { *m = Route{} }
 func (m *Route) String() string { return proto.CompactTextString(m) }
 func (*Route) ProtoMessage()    {}
 func (*Route) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{84}
+	return fileDescriptor_77a6da22d6a3feb1, []int{85}
 }
 
 func (m *Route) XXX_Unmarshal(b []byte) error {
@@ -7301,7 +7480,7 @@ func (m *NodeInfoRequest) Reset()         { *m = NodeInfoRequest{} }
 func (m *NodeInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*NodeInfoRequest) ProtoMessage()    {}
 func (*NodeInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{85}
+	return fileDescriptor_77a6da22d6a3feb1, []int{86}
 }
 
 func (m *NodeInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -7358,7 +7537,7 @@ func (m *NodeInfo) Reset()         { *m = NodeInfo{} }
 func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
 func (*NodeInfo) ProtoMessage()    {}
 func (*NodeInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{86}
+	return fileDescriptor_77a6da22d6a3feb1, []int{87}
 }
 
 func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
@@ -7428,7 +7607,7 @@ func (m *LightningNode) Reset()         { *m = LightningNode{} }
 func (m *LightningNode) String() string { return proto.CompactTextString(m) }
 func (*LightningNode) ProtoMessage()    {}
 func (*LightningNode) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{87}
+	return fileDescriptor_77a6da22d6a3feb1, []int{88}
 }
 
 func (m *LightningNode) XXX_Unmarshal(b []byte) error {
@@ -7503,7 +7682,7 @@ func (m *NodeAddress) Reset()         { *m = NodeAddress{} }
 func (m *NodeAddress) String() string { return proto.CompactTextString(m) }
 func (*NodeAddress) ProtoMessage()    {}
 func (*NodeAddress) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{88}
+	return fileDescriptor_77a6da22d6a3feb1, []int{89}
 }
 
 func (m *NodeAddress) XXX_Unmarshal(b []byte) error {
@@ -7555,7 +7734,7 @@ func (m *RoutingPolicy) Reset()         { *m = RoutingPolicy{} }
 func (m *RoutingPolicy) String() string { return proto.CompactTextString(m) }
 func (*RoutingPolicy) ProtoMessage()    {}
 func (*RoutingPolicy) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{89}
+	return fileDescriptor_77a6da22d6a3feb1, []int{90}
 }
 
 func (m *RoutingPolicy) XXX_Unmarshal(b []byte) error {
@@ -7653,7 +7832,7 @@ func (m *ChannelEdge) Reset()         { *m = ChannelEdge{} }
 func (m *ChannelEdge) String() string { return proto.CompactTextString(m) }
 func (*ChannelEdge) ProtoMessage()    {}
 func (*ChannelEdge) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{90}
+	return fileDescriptor_77a6da22d6a3feb1, []int{91}
 }
 
 func (m *ChannelEdge) XXX_Unmarshal(b []byte) error {
@@ -7746,7 +7925,7 @@ func (m *ChannelGraphRequest) Reset()         { *m = ChannelGraphRequest{} }
 func (m *ChannelGraphRequest) String() string { return proto.CompactTextString(m) }
 func (*ChannelGraphRequest) ProtoMessage()    {}
 func (*ChannelGraphRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{91}
+	return fileDescriptor_77a6da22d6a3feb1, []int{92}
 }
 
 func (m *ChannelGraphRequest) XXX_Unmarshal(b []byte) error {
@@ -7789,7 +7968,7 @@ func (m *ChannelGraph) Reset()         { *m = ChannelGraph{} }
 func (m *ChannelGraph) String() string { return proto.CompactTextString(m) }
 func (*ChannelGraph) ProtoMessage()    {}
 func (*ChannelGraph) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{92}
+	return fileDescriptor_77a6da22d6a3feb1, []int{93}
 }
 
 func (m *ChannelGraph) XXX_Unmarshal(b []byte) error {
@@ -7836,7 +8015,7 @@ func (m *NodeMetricsRequest) Reset()         { *m = NodeMetricsRequest{} }
 func (m *NodeMetricsRequest) String() string { return proto.CompactTextString(m) }
 func (*NodeMetricsRequest) ProtoMessage()    {}
 func (*NodeMetricsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{93}
+	return fileDescriptor_77a6da22d6a3feb1, []int{94}
 }
 
 func (m *NodeMetricsRequest) XXX_Unmarshal(b []byte) error {
@@ -7881,7 +8060,7 @@ func (m *NodeMetricsResponse) Reset()         { *m = NodeMetricsResponse{} }
 func (m *NodeMetricsResponse) String() string { return proto.CompactTextString(m) }
 func (*NodeMetricsResponse) ProtoMessage()    {}
 func (*NodeMetricsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{94}
+	return fileDescriptor_77a6da22d6a3feb1, []int{95}
 }
 
 func (m *NodeMetricsResponse) XXX_Unmarshal(b []byte) error {
@@ -7923,7 +8102,7 @@ func (m *FloatMetric) Reset()         { *m = FloatMetric{} }
 func (m *FloatMetric) String() string { return proto.CompactTextString(m) }
 func (*FloatMetric) ProtoMessage()    {}
 func (*FloatMetric) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{95}
+	return fileDescriptor_77a6da22d6a3feb1, []int{96}
 }
 
 func (m *FloatMetric) XXX_Unmarshal(b []byte) error {
@@ -7973,7 +8152,7 @@ func (m *ChanInfoRequest) Reset()         { *m = ChanInfoRequest{} }
 func (m *ChanInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*ChanInfoRequest) ProtoMessage()    {}
 func (*ChanInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{96}
+	return fileDescriptor_77a6da22d6a3feb1, []int{97}
 }
 
 func (m *ChanInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -8011,7 +8190,7 @@ func (m *NetworkInfoRequest) Reset()         { *m = NetworkInfoRequest{} }
 func (m *NetworkInfoRequest) String() string { return proto.CompactTextString(m) }
 func (*NetworkInfoRequest) ProtoMessage()    {}
 func (*NetworkInfoRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{97}
+	return fileDescriptor_77a6da22d6a3feb1, []int{98}
 }
 
 func (m *NetworkInfoRequest) XXX_Unmarshal(b []byte) error {
@@ -8054,7 +8233,7 @@ func (m *NetworkInfo) Reset()         { *m = NetworkInfo{} }
 func (m *NetworkInfo) String() string { return proto.CompactTextString(m) }
 func (*NetworkInfo) ProtoMessage()    {}
 func (*NetworkInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{98}
+	return fileDescriptor_77a6da22d6a3feb1, []int{99}
 }
 
 func (m *NetworkInfo) XXX_Unmarshal(b []byte) error {
@@ -8162,7 +8341,7 @@ func (m *StopRequest) Reset()         { *m = StopRequest{} }
 func (m *StopRequest) String() string { return proto.CompactTextString(m) }
 func (*StopRequest) ProtoMessage()    {}
 func (*StopRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{99}
+	return fileDescriptor_77a6da22d6a3feb1, []int{100}
 }
 
 func (m *StopRequest) XXX_Unmarshal(b []byte) error {
@@ -8193,7 +8372,7 @@ func (m *StopResponse) Reset()         { *m = StopResponse{} }
 func (m *StopResponse) String() string { return proto.CompactTextString(m) }
 func (*StopResponse) ProtoMessage()    {}
 func (*StopResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{100}
+	return fileDescriptor_77a6da22d6a3feb1, []int{101}
 }
 
 func (m *StopResponse) XXX_Unmarshal(b []byte) error {
@@ -8224,7 +8403,7 @@ func (m *GraphTopologySubscription) Reset()         { *m = GraphTopologySubscrip
 func (m *GraphTopologySubscription) String() string { return proto.CompactTextString(m) }
 func (*GraphTopologySubscription) ProtoMessage()    {}
 func (*GraphTopologySubscription) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{101}
+	return fileDescriptor_77a6da22d6a3feb1, []int{102}
 }
 
 func (m *GraphTopologySubscription) XXX_Unmarshal(b []byte) error {
@@ -8258,7 +8437,7 @@ func (m *GraphTopologyUpdate) Reset()         { *m = GraphTopologyUpdate{} }
 func (m *GraphTopologyUpdate) String() string { return proto.CompactTextString(m) }
 func (*GraphTopologyUpdate) ProtoMessage()    {}
 func (*GraphTopologyUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{102}
+	return fileDescriptor_77a6da22d6a3feb1, []int{103}
 }
 
 func (m *GraphTopologyUpdate) XXX_Unmarshal(b []byte) error {
@@ -8315,7 +8494,7 @@ func (m *NodeUpdate) Reset()         { *m = NodeUpdate{} }
 func (m *NodeUpdate) String() string { return proto.CompactTextString(m) }
 func (*NodeUpdate) ProtoMessage()    {}
 func (*NodeUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{103}
+	return fileDescriptor_77a6da22d6a3feb1, []int{104}
 }
 
 func (m *NodeUpdate) XXX_Unmarshal(b []byte) error {
@@ -8391,7 +8570,7 @@ func (m *ChannelEdgeUpdate) Reset()         { *m = ChannelEdgeUpdate{} }
 func (m *ChannelEdgeUpdate) String() string { return proto.CompactTextString(m) }
 func (*ChannelEdgeUpdate) ProtoMessage()    {}
 func (*ChannelEdgeUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{104}
+	return fileDescriptor_77a6da22d6a3feb1, []int{105}
 }
 
 func (m *ChannelEdgeUpdate) XXX_Unmarshal(b []byte) error {
@@ -8472,7 +8651,7 @@ func (m *ClosedChannelUpdate) Reset()         { *m = ClosedChannelUpdate{} }
 func (m *ClosedChannelUpdate) String() string { return proto.CompactTextString(m) }
 func (*ClosedChannelUpdate) ProtoMessage()    {}
 func (*ClosedChannelUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{105}
+	return fileDescriptor_77a6da22d6a3feb1, []int{106}
 }
 
 func (m *ClosedChannelUpdate) XXX_Unmarshal(b []byte) error {
@@ -8543,7 +8722,7 @@ func (m *HopHint) Reset()         { *m = HopHint{} }
 func (m *HopHint) String() string { return proto.CompactTextString(m) }
 func (*HopHint) ProtoMessage()    {}
 func (*HopHint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{106}
+	return fileDescriptor_77a6da22d6a3feb1, []int{107}
 }
 
 func (m *HopHint) XXX_Unmarshal(b []byte) error {
@@ -8613,7 +8792,7 @@ func (m *RouteHint) Reset()         { *m = RouteHint{} }
 func (m *RouteHint) String() string { return proto.CompactTextString(m) }
 func (*RouteHint) ProtoMessage()    {}
 func (*RouteHint) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{107}
+	return fileDescriptor_77a6da22d6a3feb1, []int{108}
 }
 
 func (m *RouteHint) XXX_Unmarshal(b []byte) error {
@@ -8746,7 +8925,7 @@ func (m *Invoice) Reset()         { *m = Invoice{} }
 func (m *Invoice) String() string { return proto.CompactTextString(m) }
 func (*Invoice) ProtoMessage()    {}
 func (*Invoice) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{108}
+	return fileDescriptor_77a6da22d6a3feb1, []int{109}
 }
 
 func (m *Invoice) XXX_Unmarshal(b []byte) error {
@@ -8968,7 +9147,7 @@ func (m *InvoiceHTLC) Reset()         { *m = InvoiceHTLC{} }
 func (m *InvoiceHTLC) String() string { return proto.CompactTextString(m) }
 func (*InvoiceHTLC) ProtoMessage()    {}
 func (*InvoiceHTLC) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{109}
+	return fileDescriptor_77a6da22d6a3feb1, []int{110}
 }
 
 func (m *InvoiceHTLC) XXX_Unmarshal(b []byte) error {
@@ -9081,7 +9260,7 @@ func (m *AddInvoiceResponse) Reset()         { *m = AddInvoiceResponse{} }
 func (m *AddInvoiceResponse) String() string { return proto.CompactTextString(m) }
 func (*AddInvoiceResponse) ProtoMessage()    {}
 func (*AddInvoiceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{110}
+	return fileDescriptor_77a6da22d6a3feb1, []int{111}
 }
 
 func (m *AddInvoiceResponse) XXX_Unmarshal(b []byte) error {
@@ -9143,7 +9322,7 @@ func (m *PaymentHash) Reset()         { *m = PaymentHash{} }
 func (m *PaymentHash) String() string { return proto.CompactTextString(m) }
 func (*PaymentHash) ProtoMessage()    {}
 func (*PaymentHash) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{111}
+	return fileDescriptor_77a6da22d6a3feb1, []int{112}
 }
 
 func (m *PaymentHash) XXX_Unmarshal(b []byte) error {
@@ -9203,7 +9382,7 @@ func (m *ListInvoiceRequest) Reset()         { *m = ListInvoiceRequest{} }
 func (m *ListInvoiceRequest) String() string { return proto.CompactTextString(m) }
 func (*ListInvoiceRequest) ProtoMessage()    {}
 func (*ListInvoiceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{112}
+	return fileDescriptor_77a6da22d6a3feb1, []int{113}
 }
 
 func (m *ListInvoiceRequest) XXX_Unmarshal(b []byte) error {
@@ -9274,7 +9453,7 @@ func (m *ListInvoiceResponse) Reset()         { *m = ListInvoiceResponse{} }
 func (m *ListInvoiceResponse) String() string { return proto.CompactTextString(m) }
 func (*ListInvoiceResponse) ProtoMessage()    {}
 func (*ListInvoiceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{113}
+	return fileDescriptor_77a6da22d6a3feb1, []int{114}
 }
 
 func (m *ListInvoiceResponse) XXX_Unmarshal(b []byte) error {
@@ -9338,7 +9517,7 @@ func (m *InvoiceSubscription) Reset()         { *m = InvoiceSubscription{} }
 func (m *InvoiceSubscription) String() string { return proto.CompactTextString(m) }
 func (*InvoiceSubscription) ProtoMessage()    {}
 func (*InvoiceSubscription) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{114}
+	return fileDescriptor_77a6da22d6a3feb1, []int{115}
 }
 
 func (m *InvoiceSubscription) XXX_Unmarshal(b []byte) error {
@@ -9415,7 +9594,7 @@ func (m *Payment) Reset()         { *m = Payment{} }
 func (m *Payment) String() string { return proto.CompactTextString(m) }
 func (*Payment) ProtoMessage()    {}
 func (*Payment) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{115}
+	return fileDescriptor_77a6da22d6a3feb1, []int{116}
 }
 
 func (m *Payment) XXX_Unmarshal(b []byte) error {
@@ -9568,7 +9747,7 @@ func (m *HTLCAttempt) Reset()         { *m = HTLCAttempt{} }
 func (m *HTLCAttempt) String() string { return proto.CompactTextString(m) }
 func (*HTLCAttempt) ProtoMessage()    {}
 func (*HTLCAttempt) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{116}
+	return fileDescriptor_77a6da22d6a3feb1, []int{117}
 }
 
 func (m *HTLCAttempt) XXX_Unmarshal(b []byte) error {
@@ -9661,7 +9840,7 @@ func (m *ListPaymentsRequest) Reset()         { *m = ListPaymentsRequest{} }
 func (m *ListPaymentsRequest) String() string { return proto.CompactTextString(m) }
 func (*ListPaymentsRequest) ProtoMessage()    {}
 func (*ListPaymentsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{117}
+	return fileDescriptor_77a6da22d6a3feb1, []int{118}
 }
 
 func (m *ListPaymentsRequest) XXX_Unmarshal(b []byte) error {
@@ -9730,7 +9909,7 @@ func (m *ListPaymentsResponse) Reset()         { *m = ListPaymentsResponse{} }
 func (m *ListPaymentsResponse) String() string { return proto.CompactTextString(m) }
 func (*ListPaymentsResponse) ProtoMessage()    {}
 func (*ListPaymentsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{118}
+	return fileDescriptor_77a6da22d6a3feb1, []int{119}
 }
 
 func (m *ListPaymentsResponse) XXX_Unmarshal(b []byte) error {
@@ -9782,7 +9961,7 @@ func (m *DeleteAllPaymentsRequest) Reset()         { *m = DeleteAllPaymentsReque
 func (m *DeleteAllPaymentsRequest) String() string { return proto.CompactTextString(m) }
 func (*DeleteAllPaymentsRequest) ProtoMessage()    {}
 func (*DeleteAllPaymentsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{119}
+	return fileDescriptor_77a6da22d6a3feb1, []int{120}
 }
 
 func (m *DeleteAllPaymentsRequest) XXX_Unmarshal(b []byte) error {
@@ -9813,7 +9992,7 @@ func (m *DeleteAllPaymentsResponse) Reset()         { *m = DeleteAllPaymentsResp
 func (m *DeleteAllPaymentsResponse) String() string { return proto.CompactTextString(m) }
 func (*DeleteAllPaymentsResponse) ProtoMessage()    {}
 func (*DeleteAllPaymentsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{120}
+	return fileDescriptor_77a6da22d6a3feb1, []int{121}
 }
 
 func (m *DeleteAllPaymentsResponse) XXX_Unmarshal(b []byte) error {
@@ -9845,7 +10024,7 @@ func (m *AbandonChannelRequest) Reset()         { *m = AbandonChannelRequest{} }
 func (m *AbandonChannelRequest) String() string { return proto.CompactTextString(m) }
 func (*AbandonChannelRequest) ProtoMessage()    {}
 func (*AbandonChannelRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{121}
+	return fileDescriptor_77a6da22d6a3feb1, []int{122}
 }
 
 func (m *AbandonChannelRequest) XXX_Unmarshal(b []byte) error {
@@ -9883,7 +10062,7 @@ func (m *AbandonChannelResponse) Reset()         { *m = AbandonChannelResponse{}
 func (m *AbandonChannelResponse) String() string { return proto.CompactTextString(m) }
 func (*AbandonChannelResponse) ProtoMessage()    {}
 func (*AbandonChannelResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{122}
+	return fileDescriptor_77a6da22d6a3feb1, []int{123}
 }
 
 func (m *AbandonChannelResponse) XXX_Unmarshal(b []byte) error {
@@ -9916,7 +10095,7 @@ func (m *DebugLevelRequest) Reset()         { *m = DebugLevelRequest{} }
 func (m *DebugLevelRequest) String() string { return proto.CompactTextString(m) }
 func (*DebugLevelRequest) ProtoMessage()    {}
 func (*DebugLevelRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{123}
+	return fileDescriptor_77a6da22d6a3feb1, []int{124}
 }
 
 func (m *DebugLevelRequest) XXX_Unmarshal(b []byte) error {
@@ -9962,7 +10141,7 @@ func (m *DebugLevelResponse) Reset()         { *m = DebugLevelResponse{} }
 func (m *DebugLevelResponse) String() string { return proto.CompactTextString(m) }
 func (*DebugLevelResponse) ProtoMessage()    {}
 func (*DebugLevelResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{124}
+	return fileDescriptor_77a6da22d6a3feb1, []int{125}
 }
 
 func (m *DebugLevelResponse) XXX_Unmarshal(b []byte) error {
@@ -10002,7 +10181,7 @@ func (m *PayReqString) Reset()         { *m = PayReqString{} }
 func (m *PayReqString) String() string { return proto.CompactTextString(m) }
 func (*PayReqString) ProtoMessage()    {}
 func (*PayReqString) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{125}
+	return fileDescriptor_77a6da22d6a3feb1, []int{126}
 }
 
 func (m *PayReqString) XXX_Unmarshal(b []byte) error {
@@ -10053,7 +10232,7 @@ func (m *PayReq) Reset()         { *m = PayReq{} }
 func (m *PayReq) String() string { return proto.CompactTextString(m) }
 func (*PayReq) ProtoMessage()    {}
 func (*PayReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{126}
+	return fileDescriptor_77a6da22d6a3feb1, []int{127}
 }
 
 func (m *PayReq) XXX_Unmarshal(b []byte) error {
@@ -10178,7 +10357,7 @@ func (m *Feature) Reset()         { *m = Feature{} }
 func (m *Feature) String() string { return proto.CompactTextString(m) }
 func (*Feature) ProtoMessage()    {}
 func (*Feature) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{127}
+	return fileDescriptor_77a6da22d6a3feb1, []int{128}
 }
 
 func (m *Feature) XXX_Unmarshal(b []byte) error {
@@ -10230,7 +10409,7 @@ func (m *FeeReportRequest) Reset()         { *m = FeeReportRequest{} }
 func (m *FeeReportRequest) String() string { return proto.CompactTextString(m) }
 func (*FeeReportRequest) ProtoMessage()    {}
 func (*FeeReportRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{128}
+	return fileDescriptor_77a6da22d6a3feb1, []int{129}
 }
 
 func (m *FeeReportRequest) XXX_Unmarshal(b []byte) error {
@@ -10273,7 +10452,7 @@ func (m *ChannelFeeReport) Reset()         { *m = ChannelFeeReport{} }
 func (m *ChannelFeeReport) String() string { return proto.CompactTextString(m) }
 func (*ChannelFeeReport) ProtoMessage()    {}
 func (*ChannelFeeReport) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{129}
+	return fileDescriptor_77a6da22d6a3feb1, []int{130}
 }
 
 func (m *ChannelFeeReport) XXX_Unmarshal(b []byte) error {
@@ -10351,7 +10530,7 @@ func (m *FeeReportResponse) Reset()         { *m = FeeReportResponse{} }
 func (m *FeeReportResponse) String() string { return proto.CompactTextString(m) }
 func (*FeeReportResponse) ProtoMessage()    {}
 func (*FeeReportResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{130}
+	return fileDescriptor_77a6da22d6a3feb1, []int{131}
 }
 
 func (m *FeeReportResponse) XXX_Unmarshal(b []byte) error {
@@ -10429,7 +10608,7 @@ func (m *PolicyUpdateRequest) Reset()         { *m = PolicyUpdateRequest{} }
 func (m *PolicyUpdateRequest) String() string { return proto.CompactTextString(m) }
 func (*PolicyUpdateRequest) ProtoMessage()    {}
 func (*PolicyUpdateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{131}
+	return fileDescriptor_77a6da22d6a3feb1, []int{132}
 }
 
 func (m *PolicyUpdateRequest) XXX_Unmarshal(b []byte) error {
@@ -10547,7 +10726,7 @@ func (m *PolicyUpdateResponse) Reset()         { *m = PolicyUpdateResponse{} }
 func (m *PolicyUpdateResponse) String() string { return proto.CompactTextString(m) }
 func (*PolicyUpdateResponse) ProtoMessage()    {}
 func (*PolicyUpdateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{132}
+	return fileDescriptor_77a6da22d6a3feb1, []int{133}
 }
 
 func (m *PolicyUpdateResponse) XXX_Unmarshal(b []byte) error {
@@ -10592,7 +10771,7 @@ func (m *ForwardingHistoryRequest) Reset()         { *m = ForwardingHistoryReque
 func (m *ForwardingHistoryRequest) String() string { return proto.CompactTextString(m) }
 func (*ForwardingHistoryRequest) ProtoMessage()    {}
 func (*ForwardingHistoryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{133}
+	return fileDescriptor_77a6da22d6a3feb1, []int{134}
 }
 
 func (m *ForwardingHistoryRequest) XXX_Unmarshal(b []byte) error {
@@ -10675,7 +10854,7 @@ func (m *ForwardingEvent) Reset()         { *m = ForwardingEvent{} }
 func (m *ForwardingEvent) String() string { return proto.CompactTextString(m) }
 func (*ForwardingEvent) ProtoMessage()    {}
 func (*ForwardingEvent) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{134}
+	return fileDescriptor_77a6da22d6a3feb1, []int{135}
 }
 
 func (m *ForwardingEvent) XXX_Unmarshal(b []byte) error {
@@ -10775,7 +10954,7 @@ func (m *ForwardingHistoryResponse) Reset()         { *m = ForwardingHistoryResp
 func (m *ForwardingHistoryResponse) String() string { return proto.CompactTextString(m) }
 func (*ForwardingHistoryResponse) ProtoMessage()    {}
 func (*ForwardingHistoryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{135}
+	return fileDescriptor_77a6da22d6a3feb1, []int{136}
 }
 
 func (m *ForwardingHistoryResponse) XXX_Unmarshal(b []byte) error {
@@ -10822,7 +11001,7 @@ func (m *ExportChannelBackupRequest) Reset()         { *m = ExportChannelBackupR
 func (m *ExportChannelBackupRequest) String() string { return proto.CompactTextString(m) }
 func (*ExportChannelBackupRequest) ProtoMessage()    {}
 func (*ExportChannelBackupRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{136}
+	return fileDescriptor_77a6da22d6a3feb1, []int{137}
 }
 
 func (m *ExportChannelBackupRequest) XXX_Unmarshal(b []byte) error {
@@ -10869,7 +11048,7 @@ func (m *ChannelBackup) Reset()         { *m = ChannelBackup{} }
 func (m *ChannelBackup) String() string { return proto.CompactTextString(m) }
 func (*ChannelBackup) ProtoMessage()    {}
 func (*ChannelBackup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{137}
+	return fileDescriptor_77a6da22d6a3feb1, []int{138}
 }
 
 func (m *ChannelBackup) XXX_Unmarshal(b []byte) error {
@@ -10923,7 +11102,7 @@ func (m *MultiChanBackup) Reset()         { *m = MultiChanBackup{} }
 func (m *MultiChanBackup) String() string { return proto.CompactTextString(m) }
 func (*MultiChanBackup) ProtoMessage()    {}
 func (*MultiChanBackup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{138}
+	return fileDescriptor_77a6da22d6a3feb1, []int{139}
 }
 
 func (m *MultiChanBackup) XXX_Unmarshal(b []byte) error {
@@ -10968,7 +11147,7 @@ func (m *ChanBackupExportRequest) Reset()         { *m = ChanBackupExportRequest
 func (m *ChanBackupExportRequest) String() string { return proto.CompactTextString(m) }
 func (*ChanBackupExportRequest) ProtoMessage()    {}
 func (*ChanBackupExportRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{139}
+	return fileDescriptor_77a6da22d6a3feb1, []int{140}
 }
 
 func (m *ChanBackupExportRequest) XXX_Unmarshal(b []byte) error {
@@ -11007,7 +11186,7 @@ func (m *ChanBackupSnapshot) Reset()         { *m = ChanBackupSnapshot{} }
 func (m *ChanBackupSnapshot) String() string { return proto.CompactTextString(m) }
 func (*ChanBackupSnapshot) ProtoMessage()    {}
 func (*ChanBackupSnapshot) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{140}
+	return fileDescriptor_77a6da22d6a3feb1, []int{141}
 }
 
 func (m *ChanBackupSnapshot) XXX_Unmarshal(b []byte) error {
@@ -11055,7 +11234,7 @@ func (m *ChannelBackups) Reset()         { *m = ChannelBackups{} }
 func (m *ChannelBackups) String() string { return proto.CompactTextString(m) }
 func (*ChannelBackups) ProtoMessage()    {}
 func (*ChannelBackups) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{141}
+	return fileDescriptor_77a6da22d6a3feb1, []int{142}
 }
 
 func (m *ChannelBackups) XXX_Unmarshal(b []byte) error {
@@ -11097,7 +11276,7 @@ func (m *RestoreChanBackupRequest) Reset()         { *m = RestoreChanBackupReque
 func (m *RestoreChanBackupRequest) String() string { return proto.CompactTextString(m) }
 func (*RestoreChanBackupRequest) ProtoMessage()    {}
 func (*RestoreChanBackupRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{142}
+	return fileDescriptor_77a6da22d6a3feb1, []int{143}
 }
 
 func (m *RestoreChanBackupRequest) XXX_Unmarshal(b []byte) error {
@@ -11173,7 +11352,7 @@ func (m *RestoreBackupResponse) Reset()         { *m = RestoreBackupResponse{} }
 func (m *RestoreBackupResponse) String() string { return proto.CompactTextString(m) }
 func (*RestoreBackupResponse) ProtoMessage()    {}
 func (*RestoreBackupResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{143}
+	return fileDescriptor_77a6da22d6a3feb1, []int{144}
 }
 
 func (m *RestoreBackupResponse) XXX_Unmarshal(b []byte) error {
@@ -11204,7 +11383,7 @@ func (m *ChannelBackupSubscription) Reset()         { *m = ChannelBackupSubscrip
 func (m *ChannelBackupSubscription) String() string { return proto.CompactTextString(m) }
 func (*ChannelBackupSubscription) ProtoMessage()    {}
 func (*ChannelBackupSubscription) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{144}
+	return fileDescriptor_77a6da22d6a3feb1, []int{145}
 }
 
 func (m *ChannelBackupSubscription) XXX_Unmarshal(b []byte) error {
@@ -11235,7 +11414,7 @@ func (m *VerifyChanBackupResponse) Reset()         { *m = VerifyChanBackupRespon
 func (m *VerifyChanBackupResponse) String() string { return proto.CompactTextString(m) }
 func (*VerifyChanBackupResponse) ProtoMessage()    {}
 func (*VerifyChanBackupResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{145}
+	return fileDescriptor_77a6da22d6a3feb1, []int{146}
 }
 
 func (m *VerifyChanBackupResponse) XXX_Unmarshal(b []byte) error {
@@ -11270,7 +11449,7 @@ func (m *MacaroonPermission) Reset()         { *m = MacaroonPermission{} }
 func (m *MacaroonPermission) String() string { return proto.CompactTextString(m) }
 func (*MacaroonPermission) ProtoMessage()    {}
 func (*MacaroonPermission) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{146}
+	return fileDescriptor_77a6da22d6a3feb1, []int{147}
 }
 
 func (m *MacaroonPermission) XXX_Unmarshal(b []byte) error {
@@ -11317,7 +11496,7 @@ func (m *BakeMacaroonRequest) Reset()         { *m = BakeMacaroonRequest{} }
 func (m *BakeMacaroonRequest) String() string { return proto.CompactTextString(m) }
 func (*BakeMacaroonRequest) ProtoMessage()    {}
 func (*BakeMacaroonRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{147}
+	return fileDescriptor_77a6da22d6a3feb1, []int{148}
 }
 
 func (m *BakeMacaroonRequest) XXX_Unmarshal(b []byte) error {
@@ -11357,7 +11536,7 @@ func (m *BakeMacaroonResponse) Reset()         { *m = BakeMacaroonResponse{} }
 func (m *BakeMacaroonResponse) String() string { return proto.CompactTextString(m) }
 func (*BakeMacaroonResponse) ProtoMessage()    {}
 func (*BakeMacaroonResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{148}
+	return fileDescriptor_77a6da22d6a3feb1, []int{149}
 }
 
 func (m *BakeMacaroonResponse) XXX_Unmarshal(b []byte) error {
@@ -11413,7 +11592,7 @@ func (m *Failure) Reset()         { *m = Failure{} }
 func (m *Failure) String() string { return proto.CompactTextString(m) }
 func (*Failure) ProtoMessage()    {}
 func (*Failure) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{149}
+	return fileDescriptor_77a6da22d6a3feb1, []int{150}
 }
 
 func (m *Failure) XXX_Unmarshal(b []byte) error {
@@ -11557,7 +11736,7 @@ func (m *ChannelUpdate) Reset()         { *m = ChannelUpdate{} }
 func (m *ChannelUpdate) String() string { return proto.CompactTextString(m) }
 func (*ChannelUpdate) ProtoMessage()    {}
 func (*ChannelUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_77a6da22d6a3feb1, []int{150}
+	return fileDescriptor_77a6da22d6a3feb1, []int{151}
 }
 
 func (m *ChannelUpdate) XXX_Unmarshal(b []byte) error {
@@ -11666,6 +11845,8 @@ func init() {
 	proto.RegisterEnum("lnrpc.AddressType", AddressType_name, AddressType_value)
 	proto.RegisterEnum("lnrpc.CommitmentType", CommitmentType_name, CommitmentType_value)
 	proto.RegisterEnum("lnrpc.Initiator", Initiator_name, Initiator_value)
+	proto.RegisterEnum("lnrpc.ResolutionType", ResolutionType_name, ResolutionType_value)
+	proto.RegisterEnum("lnrpc.ResolutionOutcome", ResolutionOutcome_name, ResolutionOutcome_value)
 	proto.RegisterEnum("lnrpc.NodeMetricType", NodeMetricType_name, NodeMetricType_value)
 	proto.RegisterEnum("lnrpc.InvoiceHTLCState", InvoiceHTLCState_name, InvoiceHTLCState_value)
 	proto.RegisterEnum("lnrpc.PaymentFailureReason", PaymentFailureReason_name, PaymentFailureReason_value)
@@ -11719,6 +11900,7 @@ func init() {
 	proto.RegisterType((*ListChannelsRequest)(nil), "lnrpc.ListChannelsRequest")
 	proto.RegisterType((*ListChannelsResponse)(nil), "lnrpc.ListChannelsResponse")
 	proto.RegisterType((*ChannelCloseSummary)(nil), "lnrpc.ChannelCloseSummary")
+	proto.RegisterType((*Resolution)(nil), "lnrpc.Resolution")
 	proto.RegisterType((*ClosedChannelsRequest)(nil), "lnrpc.ClosedChannelsRequest")
 	proto.RegisterType((*ClosedChannelsResponse)(nil), "lnrpc.ClosedChannelsResponse")
 	proto.RegisterType((*Peer)(nil), "lnrpc.Peer")
@@ -11853,722 +12035,734 @@ func init() {
 func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
 
 var fileDescriptor_77a6da22d6a3feb1 = []byte{
-	// 11427 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0xbd, 0x59, 0x6c, 0x23, 0x49,
-	0x9a, 0x18, 0x5c, 0xbc, 0x44, 0xf2, 0xe3, 0x21, 0x2a, 0x74, 0xb1, 0x54, 0x5d, 0x5d, 0xd5, 0xd9,
-	0x3d, 0xdd, 0x35, 0xd5, 0x3d, 0xea, 0xea, 0x9a, 0xae, 0x3e, 0xa6, 0xfe, 0xed, 0x19, 0x8a, 0xa2,
-	0x4a, 0x9c, 0x92, 0x48, 0x75, 0x92, 0xaa, 0xde, 0x5e, 0xec, 0xbf, 0xe9, 0x14, 0x19, 0x92, 0xd2,
-	0x45, 0x66, 0xb2, 0x33, 0x93, 0x2a, 0x69, 0x0c, 0xbf, 0xad, 0x0f, 0x2c, 0x6c, 0x03, 0x06, 0xbc,
-	0x06, 0x7c, 0x2c, 0x7c, 0x2c, 0x6c, 0xbf, 0x2d, 0x0c, 0xef, 0xda, 0x4f, 0x7e, 0xf6, 0x02, 0x86,
-	0x0d, 0xdb, 0xf0, 0x1a, 0x86, 0x8d, 0xc5, 0x02, 0x7e, 0xf0, 0xfa, 0xcd, 0x58, 0xc0, 0x4f, 0x7e,
-	0x30, 0x60, 0xc4, 0x17, 0x47, 0x46, 0x26, 0x53, 0x55, 0xd5, 0xb3, 0xed, 0x79, 0x91, 0x98, 0xdf,
-	0xf7, 0xc5, 0x91, 0x11, 0x5f, 0x7c, 0xf1, 0x5d, 0x11, 0x09, 0x65, 0x7f, 0x36, 0xda, 0x9e, 0xf9,
-	0x5e, 0xe8, 0x91, 0xc2, 0xc4, 0xf5, 0x67, 0x23, 0xe3, 0x8f, 0x33, 0x90, 0x3f, 0x0e, 0x2f, 0x3d,
-	0xf2, 0x08, 0xaa, 0xf6, 0x78, 0xec, 0xd3, 0x20, 0xb0, 0xc2, 0xab, 0x19, 0x6d, 0x66, 0xee, 0x66,
-	0xee, 0xd5, 0x1f, 0x92, 0x6d, 0x24, 0xdb, 0x6e, 0x71, 0xd4, 0xf0, 0x6a, 0x46, 0xcd, 0x8a, 0x1d,
-	0x3d, 0x90, 0x26, 0x14, 0xc5, 0x63, 0x33, 0x7b, 0x37, 0x73, 0xaf, 0x6c, 0xca, 0x47, 0x72, 0x1b,
-	0xc0, 0x9e, 0x7a, 0x73, 0x37, 0xb4, 0x02, 0x3b, 0x6c, 0xe6, 0xee, 0x66, 0xee, 0xe5, 0xcc, 0x32,
-	0x87, 0x0c, 0xec, 0x90, 0xdc, 0x82, 0xf2, 0xec, 0xb9, 0x15, 0x8c, 0x7c, 0x67, 0x16, 0x36, 0xf3,
-	0x58, 0xb4, 0x34, 0x7b, 0x3e, 0xc0, 0x67, 0xf2, 0x3e, 0x94, 0xbc, 0x79, 0x38, 0xf3, 0x1c, 0x37,
-	0x6c, 0x16, 0xee, 0x66, 0xee, 0x55, 0x1e, 0x2e, 0x8b, 0x8e, 0xf4, 0xe7, 0xe1, 0x11, 0x03, 0x9b,
-	0x8a, 0x80, 0xbc, 0x03, 0xb5, 0x91, 0xe7, 0x9e, 0x3a, 0xfe, 0xd4, 0x0e, 0x1d, 0xcf, 0x0d, 0x9a,
-	0x4b, 0xd8, 0x56, 0x1c, 0x68, 0xfc, 0xab, 0x2c, 0x54, 0x86, 0xbe, 0xed, 0x06, 0xf6, 0x88, 0x01,
-	0xc8, 0x26, 0x14, 0xc3, 0x4b, 0xeb, 0xdc, 0x0e, 0xce, 0xf1, 0x55, 0xcb, 0xe6, 0x52, 0x78, 0xb9,
-	0x6f, 0x07, 0xe7, 0x64, 0x03, 0x96, 0x78, 0x2f, 0xf1, 0x85, 0x72, 0xa6, 0x78, 0x22, 0xef, 0xc3,
-	0x8a, 0x3b, 0x9f, 0x5a, 0xf1, 0xa6, 0xd8, 0x6b, 0x15, 0xcc, 0x86, 0x3b, 0x9f, 0xb6, 0x75, 0x38,
-	0x7b, 0xf9, 0x93, 0x89, 0x37, 0x7a, 0xce, 0x1b, 0xe0, 0xaf, 0x57, 0x46, 0x08, 0xb6, 0xf1, 0x16,
-	0x54, 0x05, 0x9a, 0x3a, 0x67, 0xe7, 0xfc, 0x1d, 0x0b, 0x66, 0x85, 0x13, 0x20, 0x88, 0xd5, 0x10,
-	0x3a, 0x53, 0x6a, 0x05, 0xa1, 0x3d, 0x9d, 0x89, 0x57, 0x2a, 0x33, 0xc8, 0x80, 0x01, 0x10, 0xed,
-	0x85, 0xf6, 0xc4, 0x3a, 0xa5, 0x34, 0x68, 0x16, 0x05, 0x9a, 0x41, 0xf6, 0x28, 0x0d, 0xc8, 0xf7,
-	0xa0, 0x3e, 0xa6, 0x41, 0x68, 0x89, 0xc9, 0xa0, 0x41, 0xb3, 0x74, 0x37, 0x77, 0xaf, 0x6c, 0xd6,
-	0x18, 0xb4, 0x25, 0x81, 0xe4, 0x0d, 0x00, 0xdf, 0x7e, 0x61, 0xb1, 0x81, 0xa0, 0x97, 0xcd, 0x32,
-	0x9f, 0x05, 0xdf, 0x7e, 0x31, 0xbc, 0xdc, 0xa7, 0x97, 0x64, 0x0d, 0x0a, 0x13, 0xfb, 0x84, 0x4e,
-	0x9a, 0x80, 0x08, 0xfe, 0x60, 0xfc, 0x0a, 0x6c, 0x3c, 0xa1, 0xa1, 0x36, 0x94, 0x81, 0x49, 0xbf,
-	0x99, 0xd3, 0x20, 0x64, 0x6f, 0x15, 0x84, 0xb6, 0x1f, 0xca, 0xb7, 0xca, 0xf0, 0xb7, 0x42, 0x58,
-	0xf4, 0x56, 0xd4, 0x1d, 0x4b, 0x82, 0x2c, 0x12, 0x94, 0xa9, 0x3b, 0xe6, 0x68, 0xe3, 0x00, 0x88,
-	0x56, 0xf1, 0x2e, 0x0d, 0x6d, 0x67, 0x12, 0x90, 0x4f, 0xa0, 0x1a, 0x6a, 0xcd, 0x35, 0x33, 0x77,
-	0x73, 0xf7, 0x2a, 0x8a, 0x35, 0xb5, 0x02, 0x66, 0x8c, 0xce, 0x38, 0x87, 0xd2, 0x1e, 0xa5, 0x07,
-	0xce, 0xd4, 0x09, 0xc9, 0x06, 0x14, 0x4e, 0x9d, 0x4b, 0x3a, 0xc6, 0x4e, 0xe5, 0xf6, 0x6f, 0x98,
-	0xfc, 0x91, 0xdc, 0x01, 0xc0, 0x1f, 0xd6, 0x54, 0x71, 0xe9, 0xfe, 0x0d, 0xb3, 0x8c, 0xb0, 0xc3,
-	0xc0, 0x0e, 0xc9, 0x16, 0x14, 0x67, 0xd4, 0x1f, 0x51, 0xc9, 0x0f, 0xfb, 0x37, 0x4c, 0x09, 0xd8,
-	0x29, 0x42, 0x61, 0xc2, 0x6a, 0x37, 0x7e, 0xbf, 0x00, 0x95, 0x01, 0x75, 0xc7, 0x72, 0x24, 0x08,
-	0xe4, 0xd9, 0x40, 0x63, 0x63, 0x55, 0x13, 0x7f, 0x93, 0xb7, 0xa1, 0x82, 0x53, 0x12, 0x84, 0xbe,
-	0xe3, 0x9e, 0xf1, 0xd5, 0xb2, 0x93, 0x6d, 0x66, 0x4c, 0x60, 0xe0, 0x01, 0x42, 0x49, 0x03, 0x72,
-	0xf6, 0x54, 0xae, 0x16, 0xf6, 0x93, 0xdc, 0x84, 0x92, 0x3d, 0x0d, 0x79, 0xf7, 0xaa, 0x08, 0x2e,
-	0xda, 0xd3, 0x10, 0xbb, 0xf6, 0x16, 0x54, 0x67, 0xf6, 0xd5, 0x94, 0xba, 0x61, 0xc4, 0x66, 0x55,
-	0xb3, 0x22, 0x60, 0xc8, 0x68, 0x0f, 0x61, 0x55, 0x27, 0x91, 0x8d, 0x17, 0x54, 0xe3, 0x2b, 0x1a,
-	0xb5, 0xe8, 0xc3, 0x7b, 0xb0, 0x2c, 0xcb, 0xf8, 0xfc, 0x7d, 0x90, 0xfd, 0xca, 0x66, 0x5d, 0x80,
-	0xe5, 0x5b, 0xde, 0x83, 0xc6, 0xa9, 0xe3, 0xda, 0x13, 0x6b, 0x34, 0x09, 0x2f, 0xac, 0x31, 0x9d,
-	0x84, 0x36, 0x72, 0x62, 0xc1, 0xac, 0x23, 0xbc, 0x3d, 0x09, 0x2f, 0x76, 0x19, 0x94, 0x7c, 0x00,
-	0xe5, 0x53, 0x4a, 0x2d, 0x1c, 0xac, 0x66, 0x29, 0xb6, 0xa0, 0xe5, 0x0c, 0x99, 0xa5, 0x53, 0x39,
-	0x57, 0x1f, 0x40, 0xc3, 0x9b, 0x87, 0x67, 0x9e, 0xe3, 0x9e, 0x59, 0xa3, 0x73, 0xdb, 0xb5, 0x9c,
-	0x31, 0xf2, 0x66, 0x7e, 0x27, 0xfb, 0x20, 0x63, 0xd6, 0x25, 0xae, 0x7d, 0x6e, 0xbb, 0xdd, 0x31,
-	0x79, 0x17, 0x96, 0x27, 0x76, 0x10, 0x5a, 0xe7, 0xde, 0xcc, 0x9a, 0xcd, 0x4f, 0x9e, 0xd3, 0xab,
-	0x66, 0x0d, 0x07, 0xa2, 0xc6, 0xc0, 0xfb, 0xde, 0xec, 0x08, 0x81, 0x8c, 0xf5, 0xb0, 0x9f, 0xbc,
-	0x13, 0x8c, 0xa5, 0x6b, 0x66, 0x99, 0x41, 0x78, 0xa3, 0x5f, 0xc3, 0x2a, 0x4e, 0xcf, 0x68, 0x1e,
-	0x84, 0xde, 0xd4, 0xf2, 0xe9, 0xc8, 0xf3, 0xc7, 0x41, 0xb3, 0x82, 0xbc, 0xf6, 0x7d, 0xd1, 0x59,
-	0x6d, 0x8e, 0xb7, 0x77, 0x69, 0x10, 0xb6, 0x91, 0xd8, 0xe4, 0xb4, 0x1d, 0x37, 0xf4, 0xaf, 0xcc,
-	0x95, 0x71, 0x12, 0x4e, 0x3e, 0x00, 0x62, 0x4f, 0x26, 0xde, 0x0b, 0x2b, 0xa0, 0x93, 0x53, 0x4b,
-	0x0c, 0x62, 0xb3, 0x7e, 0x37, 0x73, 0xaf, 0x64, 0x36, 0x10, 0x33, 0xa0, 0x93, 0xd3, 0x23, 0x0e,
-	0x27, 0x9f, 0x00, 0x2e, 0x52, 0xeb, 0x94, 0xda, 0xe1, 0xdc, 0xa7, 0x41, 0x73, 0xf9, 0x6e, 0xee,
-	0x5e, 0xfd, 0xe1, 0x8a, 0x1a, 0x2f, 0x04, 0xef, 0x38, 0xa1, 0x59, 0x65, 0x74, 0xe2, 0x39, 0xd8,
-	0xda, 0x85, 0x8d, 0xf4, 0x2e, 0x31, 0xa6, 0x62, 0xa3, 0xc2, 0x98, 0x31, 0x6f, 0xb2, 0x9f, 0x6c,
-	0x65, 0x5f, 0xd8, 0x93, 0x39, 0x45, 0x2e, 0xac, 0x9a, 0xfc, 0xe1, 0x47, 0xd9, 0xcf, 0x32, 0xc6,
-	0xef, 0x65, 0xa0, 0xca, 0xdf, 0x32, 0x98, 0x79, 0x6e, 0x40, 0xc9, 0xdb, 0x50, 0x93, 0xdc, 0x40,
-	0x7d, 0xdf, 0xf3, 0x85, 0xb4, 0x94, 0x9c, 0xd7, 0x61, 0x30, 0xf2, 0x7d, 0x68, 0x48, 0xa2, 0x99,
-	0x4f, 0x9d, 0xa9, 0x7d, 0x26, 0xab, 0x96, 0xac, 0x74, 0x24, 0xc0, 0xe4, 0xa3, 0xa8, 0x3e, 0xdf,
-	0x9b, 0x87, 0x14, 0x79, 0xbd, 0xf2, 0xb0, 0x2a, 0x5e, 0xcf, 0x64, 0x30, 0x55, 0x3b, 0x3e, 0xbd,
-	0x06, 0x9f, 0x1b, 0xbf, 0x99, 0x01, 0xc2, 0xba, 0x3d, 0xf4, 0x78, 0x05, 0x91, 0x44, 0x8a, 0x95,
-	0xcc, 0xbc, 0xf6, 0x0a, 0xc9, 0xbe, 0x6c, 0x85, 0x18, 0x50, 0xe0, 0x7d, 0xcf, 0xa7, 0xf4, 0x9d,
-	0xa3, 0x7e, 0x9a, 0x2f, 0xe5, 0x1a, 0x79, 0xe3, 0xbf, 0xe6, 0x60, 0x8d, 0xf1, 0xa9, 0x4b, 0x27,
-	0xad, 0xd1, 0x88, 0xce, 0xd4, 0xda, 0xb9, 0x03, 0x15, 0xd7, 0x1b, 0x53, 0xc9, 0xb1, 0xbc, 0x63,
-	0xc0, 0x40, 0x1a, 0xbb, 0x9e, 0xdb, 0x8e, 0xcb, 0x3b, 0xce, 0x07, 0xb3, 0x8c, 0x10, 0xec, 0xf6,
-	0xbb, 0xb0, 0x3c, 0xa3, 0xee, 0x58, 0x5f, 0x22, 0x39, 0xce, 0xf5, 0x02, 0x2c, 0x56, 0xc7, 0x1d,
-	0xa8, 0x9c, 0xce, 0x39, 0x1d, 0x13, 0x2c, 0x79, 0xe4, 0x01, 0x10, 0xa0, 0x16, 0x97, 0x2f, 0xb3,
-	0x79, 0x70, 0x8e, 0xd8, 0x02, 0x62, 0x8b, 0xec, 0x99, 0xa1, 0x6e, 0x03, 0x8c, 0xe7, 0x41, 0x28,
-	0x56, 0xcc, 0x12, 0x22, 0xcb, 0x0c, 0xc2, 0x57, 0xcc, 0x0f, 0x60, 0x75, 0x6a, 0x5f, 0x5a, 0xc8,
-	0x3b, 0x96, 0xe3, 0x5a, 0xa7, 0x13, 0x14, 0xea, 0x45, 0xa4, 0x6b, 0x4c, 0xed, 0xcb, 0x67, 0x0c,
-	0xd3, 0x75, 0xf7, 0x10, 0xce, 0xc4, 0xca, 0x88, 0x8f, 0x84, 0xe5, 0xd3, 0x80, 0xfa, 0x17, 0x14,
-	0x25, 0x41, 0xde, 0xac, 0x0b, 0xb0, 0xc9, 0xa1, 0xac, 0x47, 0x53, 0xf6, 0xde, 0xe1, 0x64, 0xc4,
-	0x97, 0xbd, 0x59, 0x9c, 0x3a, 0xee, 0x7e, 0x38, 0x19, 0xb1, 0xfd, 0x8a, 0xc9, 0x91, 0x19, 0xf5,
-	0xad, 0xe7, 0x2f, 0x70, 0x0d, 0xe7, 0x51, 0x6e, 0x1c, 0x51, 0xff, 0xe9, 0x0b, 0xa6, 0x52, 0x8c,
-	0x02, 0x14, 0x44, 0xf6, 0x55, 0xb3, 0x82, 0x0b, 0xbc, 0x34, 0x0a, 0x98, 0x08, 0xb2, 0xaf, 0xd8,
-	0x22, 0x64, 0xbd, 0xb5, 0x71, 0x16, 0xe8, 0x18, 0xab, 0x0f, 0x50, 0xa2, 0xd6, 0xb0, 0xb3, 0x2d,
-	0x81, 0x60, 0xed, 0x04, 0x8c, 0xeb, 0x65, 0x67, 0x4f, 0x27, 0xf6, 0x59, 0x80, 0x22, 0xa5, 0x66,
-	0x56, 0x05, 0x70, 0x8f, 0xc1, 0x8c, 0xaf, 0x60, 0x3d, 0x31, 0xb7, 0x62, 0xcd, 0x30, 0x15, 0x02,
-	0x21, 0x38, 0xaf, 0x25, 0x53, 0x3c, 0xa5, 0x4d, 0x5a, 0x36, 0x65, 0xd2, 0x8c, 0xdf, 0xca, 0x40,
-	0x55, 0xd4, 0x8c, 0xca, 0x0e, 0xd9, 0x06, 0x22, 0x67, 0x31, 0xbc, 0x74, 0xc6, 0xd6, 0xc9, 0x55,
-	0x48, 0x03, 0xce, 0x34, 0xfb, 0x37, 0xcc, 0x86, 0xc0, 0x0d, 0x2f, 0x9d, 0xf1, 0x0e, 0xc3, 0x90,
-	0xfb, 0xd0, 0x88, 0xd1, 0x07, 0xa1, 0xcf, 0x39, 0x7a, 0xff, 0x86, 0x59, 0xd7, 0xa8, 0x07, 0xa1,
-	0xcf, 0xd6, 0x08, 0x53, 0xa5, 0xe6, 0xa1, 0xe5, 0xb8, 0x63, 0x7a, 0x89, 0x6c, 0x54, 0x33, 0x2b,
-	0x1c, 0xd6, 0x65, 0xa0, 0x9d, 0x3a, 0x54, 0xf5, 0xea, 0x8c, 0x33, 0x28, 0x49, 0x3d, 0x0c, 0x15,
-	0x91, 0x44, 0x97, 0xcc, 0x72, 0xa8, 0x7a, 0x72, 0x13, 0x4a, 0xf1, 0x1e, 0x98, 0xc5, 0xf0, 0xb5,
-	0x1b, 0x36, 0xbe, 0x80, 0xc6, 0x01, 0x63, 0x1e, 0x97, 0x31, 0xab, 0xd0, 0x2b, 0x37, 0x60, 0x49,
-	0x5b, 0x34, 0x65, 0x53, 0x3c, 0xb1, 0x3d, 0xf7, 0xdc, 0x0b, 0x42, 0xd1, 0x0a, 0xfe, 0x36, 0x7e,
-	0x3f, 0x03, 0xa4, 0x13, 0x84, 0xce, 0xd4, 0x0e, 0xe9, 0x1e, 0x55, 0x62, 0xa1, 0x0f, 0x55, 0x56,
-	0xdb, 0xd0, 0x6b, 0x71, 0x45, 0x8f, 0x2b, 0x14, 0xef, 0x8b, 0x65, 0xbc, 0x58, 0x60, 0x5b, 0xa7,
-	0xe6, 0x62, 0x3e, 0x56, 0x01, 0x5b, 0x65, 0xa1, 0xed, 0x9f, 0xd1, 0x10, 0xd5, 0x43, 0xa1, 0xd7,
-	0x00, 0x07, 0x31, 0xc5, 0x70, 0xeb, 0xc7, 0xb0, 0xb2, 0x50, 0x87, 0x2e, 0x97, 0xcb, 0x29, 0x72,
-	0x39, 0xa7, 0xcb, 0x65, 0x0b, 0x56, 0x63, 0xfd, 0x12, 0x9c, 0xb6, 0x09, 0x45, 0xb6, 0x20, 0x98,
-	0x72, 0x90, 0xe1, 0xda, 0xea, 0x29, 0xa5, 0x4c, 0xbd, 0xfe, 0x10, 0xd6, 0x4e, 0x29, 0xf5, 0xed,
-	0x10, 0x91, 0xb8, 0x62, 0xd8, 0x0c, 0x89, 0x8a, 0x57, 0x04, 0x6e, 0x60, 0x87, 0x47, 0xd4, 0x67,
-	0x33, 0x65, 0xfc, 0xef, 0x0c, 0x2c, 0x33, 0x09, 0x7a, 0x68, 0xbb, 0x57, 0x72, 0x9c, 0x0e, 0x52,
-	0xc7, 0xe9, 0x9e, 0xb6, 0x19, 0x6a, 0xd4, 0xdf, 0x76, 0x90, 0x72, 0xc9, 0x41, 0x22, 0x77, 0xa1,
-	0x1a, 0xeb, 0x6b, 0x01, 0xfb, 0x0a, 0x81, 0xea, 0x64, 0xa4, 0x91, 0x2e, 0x69, 0x1a, 0xe9, 0x9f,
-	0x7e, 0x70, 0xdf, 0x85, 0x46, 0xf4, 0x32, 0x62, 0x64, 0x09, 0xe4, 0x19, 0xa3, 0x8a, 0x0a, 0xf0,
-	0xb7, 0xf1, 0xcf, 0x32, 0x9c, 0xb0, 0xed, 0x39, 0x91, 0xd6, 0x4b, 0x20, 0xcf, 0xb4, 0x6c, 0x49,
-	0xc8, 0x7e, 0x5f, 0x6b, 0x43, 0x7c, 0x07, 0x43, 0x70, 0x13, 0x4a, 0x01, 0x53, 0xa1, 0xed, 0x09,
-	0x1f, 0x85, 0x92, 0x59, 0x64, 0xcf, 0xad, 0xc9, 0x24, 0x1a, 0x9d, 0xa2, 0xae, 0xaf, 0xbf, 0x07,
-	0x2b, 0x5a, 0x9f, 0x5f, 0xf2, 0x76, 0x3d, 0x20, 0x07, 0x4e, 0x10, 0x1e, 0xbb, 0xc1, 0x4c, 0x53,
-	0xf2, 0x6e, 0x41, 0x99, 0x49, 0x63, 0xd6, 0xdf, 0x40, 0x68, 0xf4, 0x4c, 0x3c, 0xb3, 0xde, 0x06,
-	0x88, 0xb4, 0x2f, 0x05, 0x32, 0x2b, 0x90, 0xf6, 0x25, 0x22, 0x8d, 0xcf, 0x60, 0x35, 0x56, 0x9f,
-	0x68, 0xfa, 0x2d, 0x28, 0xcc, 0xc3, 0x4b, 0x4f, 0xaa, 0xf1, 0x15, 0xc1, 0x4d, 0xcc, 0x08, 0x35,
-	0x39, 0xc6, 0x78, 0x0c, 0x2b, 0x3d, 0xfa, 0x42, 0x2c, 0x78, 0xd9, 0x91, 0x77, 0x21, 0xff, 0x0a,
-	0xc3, 0x14, 0xf1, 0xc6, 0x36, 0x10, 0xbd, 0xb0, 0x68, 0x55, 0xb3, 0x53, 0x33, 0x31, 0x3b, 0xd5,
-	0x78, 0x17, 0xc8, 0xc0, 0x39, 0x73, 0x0f, 0x69, 0x10, 0xd8, 0x67, 0x4a, 0x44, 0x34, 0x20, 0x37,
-	0x0d, 0xce, 0x84, 0x3c, 0x63, 0x3f, 0x8d, 0x1f, 0xc2, 0x6a, 0x8c, 0x4e, 0x54, 0xfc, 0x06, 0x94,
-	0x03, 0xe7, 0xcc, 0x45, 0x25, 0x4c, 0x54, 0x1d, 0x01, 0x8c, 0x3d, 0x58, 0x7b, 0x46, 0x7d, 0xe7,
-	0xf4, 0xea, 0x55, 0xd5, 0xc7, 0xeb, 0xc9, 0x26, 0xeb, 0xe9, 0xc0, 0x7a, 0xa2, 0x1e, 0xd1, 0x3c,
-	0x67, 0x6a, 0x31, 0x93, 0x25, 0x93, 0x3f, 0x68, 0x32, 0x32, 0xab, 0xcb, 0x48, 0xe3, 0x18, 0x48,
-	0xdb, 0x73, 0x5d, 0x3a, 0x0a, 0x8f, 0x28, 0xf5, 0x65, 0x67, 0xde, 0xd7, 0x38, 0xb8, 0xf2, 0x70,
-	0x53, 0x8c, 0x6c, 0x52, 0xf0, 0x0a, 0xd6, 0x26, 0x90, 0x9f, 0x51, 0x7f, 0x8a, 0x15, 0x97, 0x4c,
-	0xfc, 0x6d, 0xac, 0xc3, 0x6a, 0xac, 0x5a, 0xde, 0x37, 0xe3, 0x01, 0xac, 0xef, 0x3a, 0xc1, 0x68,
-	0xb1, 0xc1, 0x4d, 0x28, 0xce, 0xe6, 0x27, 0x56, 0x5c, 0x86, 0x3f, 0xa5, 0x57, 0x46, 0x13, 0x36,
-	0x92, 0x25, 0x44, 0x5d, 0xbf, 0x9e, 0x81, 0xfc, 0xfe, 0xf0, 0xa0, 0x4d, 0xb6, 0xa0, 0xe4, 0xb8,
-	0x23, 0x6f, 0xca, 0x94, 0x34, 0xfe, 0xce, 0xea, 0xf9, 0xda, 0x65, 0x77, 0x0b, 0xca, 0xa8, 0xdb,
-	0x31, 0xf3, 0x5a, 0xa8, 0x49, 0x25, 0x06, 0x38, 0xf0, 0x46, 0xcf, 0x99, 0x5d, 0x4f, 0x2f, 0x67,
-	0x8e, 0x8f, 0x96, 0xbb, 0xb4, 0x4c, 0xf3, 0x5c, 0x2f, 0x88, 0x10, 0xc2, 0x40, 0xfd, 0xf5, 0x2c,
-	0x10, 0xb1, 0x33, 0xb7, 0x3d, 0x37, 0x08, 0x7d, 0xdb, 0x71, 0xc3, 0x20, 0xae, 0x79, 0x64, 0x12,
-	0x9a, 0xc7, 0x3d, 0x68, 0xe0, 0x6e, 0x2f, 0xb4, 0x1e, 0x14, 0xd6, 0xd9, 0x48, 0xf3, 0x11, 0x6a,
-	0x0f, 0x13, 0xda, 0xef, 0x40, 0x3d, 0x52, 0xb8, 0x94, 0xdb, 0x24, 0x6f, 0x56, 0x95, 0xd2, 0x25,
-	0x44, 0x3b, 0x5b, 0x74, 0x52, 0x93, 0x50, 0xd6, 0x21, 0xd7, 0xed, 0x56, 0xa6, 0xf6, 0xe5, 0x11,
-	0x95, 0xea, 0x1d, 0xda, 0x89, 0x06, 0xd4, 0xa4, 0x42, 0xc5, 0x29, 0xb9, 0x9e, 0x57, 0x11, 0x5a,
-	0x15, 0xd2, 0xa4, 0xab, 0x47, 0x4b, 0xe9, 0xea, 0x91, 0xf1, 0x9f, 0xcb, 0x50, 0x14, 0xc3, 0xc0,
-	0x95, 0x9d, 0xd0, 0xb9, 0xa0, 0x91, 0xb2, 0xc3, 0x9e, 0x98, 0x0a, 0xe5, 0xd3, 0xa9, 0x17, 0x2a,
-	0x1d, 0x97, 0xb3, 0x62, 0x95, 0x03, 0x85, 0x96, 0xab, 0xe9, 0x59, 0xdc, 0xdb, 0x93, 0xe3, 0x44,
-	0x23, 0x5d, 0xfb, 0xb9, 0x05, 0x45, 0xa9, 0x2e, 0xe5, 0x95, 0x19, 0xb8, 0x34, 0xe2, 0x0a, 0xee,
-	0x16, 0x94, 0x46, 0xf6, 0xcc, 0x1e, 0x39, 0xe1, 0x95, 0x90, 0x96, 0xea, 0x99, 0xd5, 0x3e, 0xf1,
-	0x46, 0xf6, 0xc4, 0x3a, 0xb1, 0x27, 0xb6, 0x3b, 0xa2, 0xc2, 0x8d, 0x52, 0x45, 0xe0, 0x0e, 0x87,
-	0x91, 0xef, 0x41, 0x5d, 0xf4, 0x53, 0x52, 0x71, 0x6f, 0x8a, 0xe8, 0xbd, 0x24, 0x63, 0xfa, 0xb8,
-	0x37, 0x65, 0xf3, 0x72, 0x4a, 0xb9, 0xe6, 0x9a, 0x33, 0xcb, 0x1c, 0xb2, 0x47, 0xf1, 0x6d, 0x05,
-	0xfa, 0x05, 0xe7, 0xa0, 0x32, 0x6f, 0x8a, 0x03, 0xbf, 0xe2, 0xde, 0x8f, 0x45, 0xf5, 0x35, 0xa7,
-	0xa9, 0xaf, 0xef, 0xc3, 0xca, 0xdc, 0x0d, 0x68, 0x18, 0x4e, 0xe8, 0x58, 0xf5, 0xa5, 0x82, 0x44,
-	0x0d, 0x85, 0x90, 0xdd, 0xd9, 0x86, 0x55, 0xee, 0xff, 0x09, 0xec, 0xd0, 0x0b, 0xce, 0x9d, 0xc0,
-	0x0a, 0x98, 0x51, 0xc9, 0x3d, 0x04, 0x2b, 0x88, 0x1a, 0x08, 0xcc, 0x80, 0x5b, 0x95, 0x9b, 0x09,
-	0x7a, 0x9f, 0x8e, 0xa8, 0x73, 0x41, 0xc7, 0xa8, 0xda, 0xe6, 0xcc, 0xf5, 0x58, 0x19, 0x53, 0x20,
-	0xd1, 0x4e, 0x99, 0x4f, 0xad, 0xf9, 0x6c, 0x6c, 0x33, 0xfd, 0xae, 0xce, 0xed, 0x07, 0x77, 0x3e,
-	0x3d, 0xe6, 0x10, 0xf2, 0x00, 0xa4, 0xf2, 0x2a, 0x78, 0x66, 0x39, 0x26, 0xd6, 0xd9, 0x9a, 0x35,
-	0xab, 0x82, 0x82, 0xeb, 0xd6, 0x77, 0xf4, 0xc5, 0xd2, 0x60, 0x1c, 0x86, 0x76, 0x56, 0xb4, 0x60,
-	0x9a, 0x50, 0x9c, 0xf9, 0xce, 0x85, 0x1d, 0xd2, 0xe6, 0x0a, 0xdf, 0xe1, 0xc4, 0x23, 0x13, 0x92,
-	0x8e, 0xeb, 0x84, 0x8e, 0x1d, 0x7a, 0x7e, 0x93, 0x20, 0x2e, 0x02, 0x90, 0xfb, 0xb0, 0x82, 0x7c,
-	0x12, 0x84, 0x76, 0x38, 0x0f, 0x84, 0xe2, 0xbe, 0x8a, 0x0c, 0x85, 0xa6, 0xc7, 0x00, 0xe1, 0xa8,
-	0xbb, 0x93, 0x4f, 0x61, 0x83, 0xb3, 0xc6, 0xc2, 0xd2, 0x5c, 0x63, 0xc3, 0x81, 0x3d, 0x5a, 0x45,
-	0x8a, 0x76, 0x7c, 0x8d, 0x7e, 0x0e, 0x9b, 0x82, 0x5d, 0x16, 0x4a, 0xae, 0xab, 0x92, 0x6b, 0x9c,
-	0x24, 0x51, 0x74, 0x1b, 0x56, 0x58, 0xd7, 0x9c, 0x91, 0x25, 0x6a, 0x60, 0xab, 0x62, 0x83, 0xbd,
-	0x05, 0x16, 0x5a, 0xe6, 0x48, 0x13, 0x71, 0x4f, 0xe9, 0x15, 0xf9, 0x02, 0x96, 0x39, 0xfb, 0xa0,
-	0x75, 0x8a, 0x9b, 0xdf, 0x16, 0x6e, 0x7e, 0xeb, 0x62, 0x70, 0xdb, 0x0a, 0x8b, 0xfb, 0x5f, 0x7d,
-	0x14, 0x7b, 0x66, 0x4b, 0x63, 0xe2, 0x9c, 0xd2, 0xd0, 0x99, 0xd2, 0xe6, 0x26, 0x67, 0x36, 0xf9,
-	0xcc, 0x56, 0xed, 0x7c, 0x86, 0x98, 0x26, 0x17, 0x95, 0xfc, 0x09, 0xf9, 0x78, 0xe2, 0x05, 0x54,
-	0x7a, 0x0e, 0x9b, 0x37, 0xc5, 0x82, 0x64, 0x40, 0xa9, 0x82, 0x33, 0x3b, 0x86, 0xdb, 0x8c, 0xca,
-	0xbf, 0x7b, 0x0b, 0x19, 0xa3, 0xc6, 0x4d, 0x47, 0xe9, 0xe3, 0x65, 0xea, 0xce, 0xb9, 0xfd, 0x42,
-	0x0a, 0xd5, 0x37, 0x50, 0x9a, 0x00, 0x03, 0x09, 0x77, 0xe0, 0x1e, 0xac, 0x88, 0x59, 0x88, 0x84,
-	0x69, 0xf3, 0x36, 0x6e, 0x43, 0x37, 0xe5, 0x3b, 0x2e, 0x48, 0x5b, 0xb3, 0xc1, 0xe7, 0x45, 0x93,
-	0xbf, 0xfb, 0x40, 0xe4, 0xa4, 0x68, 0x15, 0xbd, 0xf9, 0xaa, 0x8a, 0x56, 0xc4, 0x34, 0x45, 0x20,
-	0xe3, 0x77, 0x33, 0x5c, 0x6b, 0x11, 0xd4, 0x81, 0x66, 0xaf, 0x73, 0xb9, 0x66, 0x79, 0xee, 0xe4,
-	0x4a, 0x88, 0x3a, 0xe0, 0xa0, 0xbe, 0x3b, 0x41, 0x59, 0xe3, 0xb8, 0x3a, 0x09, 0xdf, 0x20, 0xab,
-	0x12, 0x88, 0x44, 0x77, 0xa0, 0x32, 0x9b, 0x9f, 0x4c, 0x9c, 0x11, 0x27, 0xc9, 0xf1, 0x5a, 0x38,
-	0x08, 0x09, 0xde, 0x82, 0xaa, 0xe0, 0x75, 0x4e, 0x91, 0x47, 0x8a, 0x8a, 0x80, 0x21, 0x09, 0x6e,
-	0xc0, 0xd4, 0x47, 0x61, 0x57, 0x35, 0xf1, 0xb7, 0xb1, 0x03, 0x6b, 0xf1, 0x4e, 0x0b, 0xed, 0xe0,
-	0x3e, 0x94, 0x84, 0x24, 0x95, 0x9e, 0xac, 0x7a, 0x7c, 0x34, 0x4c, 0x85, 0x37, 0x7e, 0xbb, 0x00,
-	0xab, 0x72, 0x8c, 0xd8, 0x64, 0x0f, 0xe6, 0xd3, 0xa9, 0xed, 0xa7, 0x88, 0xe8, 0xcc, 0xcb, 0x45,
-	0x74, 0x76, 0x41, 0x44, 0xc7, 0x5d, 0x19, 0x5c, 0xc2, 0xc7, 0x5d, 0x19, 0x8c, 0xbb, 0xb8, 0x75,
-	0xa9, 0x3b, 0xcc, 0x6b, 0x02, 0x3c, 0xe4, 0x8e, 0xf9, 0x85, 0x0d, 0xa5, 0x90, 0xb2, 0xa1, 0xe8,
-	0xdb, 0xc1, 0x52, 0x62, 0x3b, 0x78, 0x0b, 0x38, 0x1b, 0x4b, 0x7e, 0x2c, 0x72, 0x83, 0x13, 0x61,
-	0x82, 0x21, 0xdf, 0x83, 0xe5, 0xa4, 0x04, 0xe6, 0xa2, 0xbe, 0x9e, 0x22, 0x7f, 0x9d, 0x29, 0x45,
-	0x95, 0x42, 0x23, 0x2e, 0x0b, 0xf9, 0xeb, 0x4c, 0xe9, 0x01, 0x62, 0x24, 0x7d, 0x07, 0x80, 0xb7,
-	0x8d, 0xcb, 0x18, 0x70, 0x19, 0xbf, 0x9b, 0xe0, 0x4c, 0x6d, 0xd4, 0xb7, 0xd9, 0xc3, 0xdc, 0xa7,
-	0xb8, 0xae, 0xcb, 0x58, 0x12, 0x97, 0xf4, 0xa7, 0x50, 0xf7, 0x66, 0xd4, 0xb5, 0x22, 0x29, 0x58,
-	0xc1, 0xaa, 0x1a, 0xa2, 0xaa, 0xae, 0x84, 0x9b, 0x35, 0x46, 0xa7, 0x1e, 0xc9, 0xe7, 0x7c, 0x90,
-	0xa9, 0x56, 0xb2, 0x7a, 0x4d, 0xc9, 0x3a, 0x12, 0xaa, 0x67, 0xe3, 0x37, 0x32, 0x50, 0xd1, 0xba,
-	0x43, 0xd6, 0x61, 0xa5, 0xdd, 0xef, 0x1f, 0x75, 0xcc, 0xd6, 0xb0, 0xfb, 0xac, 0x63, 0xb5, 0x0f,
-	0xfa, 0x83, 0x4e, 0xe3, 0x06, 0x03, 0x1f, 0xf4, 0xdb, 0xad, 0x03, 0x6b, 0xaf, 0x6f, 0xb6, 0x25,
-	0x38, 0x43, 0x36, 0x80, 0x98, 0x9d, 0xc3, 0xfe, 0xb0, 0x13, 0x83, 0x67, 0x49, 0x03, 0xaa, 0x3b,
-	0x66, 0xa7, 0xd5, 0xde, 0x17, 0x90, 0x1c, 0x59, 0x83, 0xc6, 0xde, 0x71, 0x6f, 0xb7, 0xdb, 0x7b,
-	0x62, 0xb5, 0x5b, 0xbd, 0x76, 0xe7, 0xa0, 0xb3, 0xdb, 0xc8, 0x93, 0x1a, 0x94, 0x5b, 0x3b, 0xad,
-	0xde, 0x6e, 0xbf, 0xd7, 0xd9, 0x6d, 0x14, 0x8c, 0x3f, 0xca, 0xc0, 0x3a, 0x0e, 0xd4, 0x38, 0xb9,
-	0x42, 0xef, 0x42, 0x65, 0xe4, 0x79, 0x33, 0x66, 0xd7, 0x46, 0xca, 0x88, 0x0e, 0x62, 0xab, 0x8f,
-	0x4b, 0x9b, 0x53, 0xcf, 0x1f, 0x51, 0xb1, 0x40, 0x01, 0x41, 0x7b, 0x0c, 0xc2, 0x18, 0x44, 0x70,
-	0x18, 0xa7, 0xe0, 0xeb, 0xb3, 0xc2, 0x61, 0x9c, 0x64, 0x03, 0x96, 0x4e, 0x7c, 0x6a, 0x8f, 0xce,
-	0xc5, 0xd2, 0x14, 0x4f, 0xe4, 0xfb, 0x91, 0xc7, 0x65, 0xc4, 0x26, 0x7c, 0x42, 0xc7, 0xc8, 0x9f,
-	0x25, 0x73, 0x59, 0xc0, 0xdb, 0x02, 0xcc, 0x36, 0x31, 0xfb, 0xc4, 0x76, 0xc7, 0x9e, 0x4b, 0xc7,
-	0xc2, 0x84, 0x8b, 0x00, 0xc6, 0x11, 0x6c, 0x24, 0xdf, 0x4f, 0x2c, 0xe6, 0x4f, 0xb4, 0xc5, 0xcc,
-	0x6d, 0xa7, 0xad, 0xeb, 0x19, 0x48, 0x5b, 0xd8, 0x7f, 0x35, 0x0f, 0x79, 0xa6, 0x4b, 0x5f, 0xab,
-	0x76, 0xeb, 0xc6, 0x51, 0x6e, 0x21, 0x88, 0x87, 0x8e, 0x1d, 0xae, 0x5d, 0x70, 0x0d, 0xb3, 0x8c,
-	0x10, 0xd4, 0x2a, 0x14, 0xda, 0xa7, 0xa3, 0x0b, 0xa1, 0x56, 0x72, 0xb4, 0x49, 0x47, 0x17, 0x68,
-	0xab, 0xda, 0x21, 0x2f, 0xcb, 0x17, 0x63, 0x31, 0xb0, 0x43, 0x2c, 0x29, 0x50, 0x58, 0xae, 0xa8,
-	0x50, 0x58, 0xaa, 0x09, 0x45, 0xc7, 0x3d, 0xf1, 0xe6, 0xee, 0x18, 0xd7, 0x5e, 0xc9, 0x94, 0x8f,
-	0x18, 0x33, 0x44, 0x31, 0xc1, 0xf6, 0x2d, 0xbe, 0xd4, 0x4a, 0x0c, 0x30, 0x64, 0x3b, 0xd7, 0x47,
-	0x50, 0x0e, 0xae, 0xdc, 0x91, 0xbe, 0xc0, 0xd6, 0xc4, 0xf8, 0xb0, 0xb7, 0xdf, 0x1e, 0x5c, 0xb9,
-	0x23, 0x5c, 0x4e, 0xa5, 0x40, 0xfc, 0x22, 0x8f, 0xa0, 0xa4, 0xbc, 0xec, 0x5c, 0x3c, 0xde, 0xd4,
-	0x4b, 0x48, 0xd7, 0x3a, 0x77, 0x66, 0x28, 0x52, 0xf2, 0x21, 0x2c, 0xa1, 0x2b, 0x3c, 0x68, 0x56,
-	0xb1, 0x90, 0xb4, 0x98, 0x58, 0x37, 0x30, 0x5c, 0x47, 0xc7, 0xe8, 0x16, 0x37, 0x05, 0xd9, 0xd6,
-	0x53, 0xa8, 0xc5, 0xea, 0xd2, 0x9d, 0x13, 0x35, 0xee, 0x9c, 0x78, 0x47, 0x77, 0x4e, 0x44, 0x62,
-	0x5a, 0x14, 0xd3, 0x9d, 0x15, 0x3f, 0x86, 0x92, 0x7c, 0x15, 0xb6, 0x88, 0x8e, 0x7b, 0x4f, 0x7b,
-	0xfd, 0xaf, 0x7a, 0xd6, 0xe0, 0xeb, 0x5e, 0xbb, 0x71, 0x83, 0x2c, 0x43, 0xa5, 0xd5, 0xc6, 0x75,
-	0x89, 0x80, 0x0c, 0x23, 0x39, 0x6a, 0x0d, 0x06, 0x0a, 0x92, 0x35, 0xf6, 0xa0, 0x91, 0xec, 0x29,
-	0xe3, 0xc9, 0x50, 0xc2, 0x44, 0xa0, 0x20, 0x02, 0x30, 0x23, 0x93, 0xfb, 0xfe, 0xb9, 0x0a, 0xcf,
-	0x1f, 0x8c, 0x47, 0xd0, 0x60, 0x9b, 0x0e, 0x1b, 0x2a, 0x3d, 0x04, 0x38, 0x61, 0x6a, 0xa1, 0x1e,
-	0x2c, 0x28, 0x99, 0x15, 0x0e, 0xc3, 0xa6, 0x8c, 0x4f, 0x60, 0x45, 0x2b, 0x16, 0x39, 0x05, 0xd8,
-	0x46, 0x96, 0x74, 0x0a, 0xa0, 0x09, 0xc8, 0x31, 0xc6, 0x26, 0xac, 0xb3, 0xc7, 0xce, 0x05, 0x75,
-	0xc3, 0xc1, 0xfc, 0x84, 0x47, 0x8e, 0x1d, 0xcf, 0x65, 0xa6, 0x61, 0x59, 0x61, 0xae, 0x67, 0xf2,
-	0x6d, 0xe1, 0x3f, 0xc8, 0x22, 0x6b, 0x6c, 0x69, 0x2d, 0x60, 0xc1, 0x6d, 0xfc, 0x1b, 0xf3, 0x23,
-	0x94, 0x15, 0x88, 0x0d, 0xeb, 0x51, 0xa7, 0x63, 0x5a, 0xfd, 0xde, 0x41, 0xb7, 0xc7, 0xa4, 0x1d,
-	0x1b, 0x56, 0x04, 0xec, 0xed, 0x21, 0x24, 0x63, 0x34, 0xa0, 0xfe, 0x84, 0x86, 0x5d, 0xf7, 0xd4,
-	0x13, 0x83, 0x61, 0xfc, 0xa5, 0x25, 0x58, 0x56, 0xa0, 0xc8, 0x0f, 0x71, 0x41, 0xfd, 0xc0, 0xf1,
-	0x5c, 0xd4, 0xa5, 0xcb, 0xa6, 0x7c, 0x64, 0xd2, 0x49, 0x58, 0x10, 0xb8, 0x05, 0xae, 0x21, 0x56,
-	0xd8, 0x1c, 0xb8, 0xff, 0xbd, 0x07, 0xcb, 0xce, 0x98, 0xba, 0xa1, 0x13, 0x5e, 0x59, 0x31, 0x0f,
-	0x68, 0x5d, 0x82, 0xc5, 0x1e, 0xb8, 0x06, 0x05, 0x7b, 0xe2, 0xd8, 0x32, 0x22, 0xcf, 0x1f, 0x18,
-	0x74, 0xe4, 0x4d, 0x3c, 0x1f, 0x75, 0xea, 0xb2, 0xc9, 0x1f, 0xc8, 0x03, 0x58, 0x63, 0xfa, 0xbd,
-	0xee, 0x96, 0x46, 0x01, 0xc3, 0x9d, 0xb1, 0xc4, 0x9d, 0x4f, 0x8f, 0x22, 0xd7, 0x34, 0xc3, 0xb0,
-	0x9d, 0x8f, 0x95, 0x10, 0xaa, 0x8e, 0x2a, 0xc0, 0x2d, 0xe6, 0x15, 0x77, 0x3e, 0x6d, 0x21, 0x46,
-	0xd1, 0x3f, 0x84, 0x75, 0x46, 0xaf, 0x94, 0x23, 0x55, 0x62, 0x19, 0x4b, 0xb0, 0xca, 0xba, 0x02,
-	0xa7, 0xca, 0xdc, 0x82, 0x32, 0xef, 0x15, 0x63, 0x89, 0x02, 0xb7, 0xa7, 0xb1, 0x2b, 0xd4, 0x0f,
-	0x16, 0x82, 0xe7, 0xdc, 0x48, 0x4d, 0x06, 0xcf, 0xb5, 0xf0, 0x7b, 0x29, 0x19, 0x7e, 0x7f, 0x08,
-	0xeb, 0x27, 0x8c, 0x47, 0xcf, 0xa9, 0x3d, 0xa6, 0xbe, 0x15, 0x71, 0x3e, 0x37, 0x85, 0x56, 0x19,
-	0x72, 0x1f, 0x71, 0x6a, 0xa1, 0x30, 0x2d, 0x85, 0xc9, 0x0d, 0x3a, 0xb6, 0x42, 0xcf, 0x42, 0xe5,
-	0x05, 0x25, 0x50, 0xc9, 0xac, 0x71, 0xf0, 0xd0, 0x6b, 0x33, 0x60, 0x9c, 0xee, 0xcc, 0xb7, 0x67,
-	0xe7, 0xc2, 0x50, 0x51, 0x74, 0x4f, 0x18, 0x90, 0xbc, 0x01, 0x45, 0xb6, 0x26, 0x5c, 0xca, 0x63,
-	0x91, 0xdc, 0x04, 0x90, 0x20, 0xf2, 0x0e, 0x2c, 0x61, 0x1b, 0x41, 0xb3, 0x81, 0x0b, 0xa2, 0x1a,
-	0x49, 0x7a, 0xc7, 0x35, 0x05, 0x8e, 0xa9, 0x82, 0x73, 0xdf, 0xe1, 0x62, 0xa8, 0x6c, 0xe2, 0x6f,
-	0xf2, 0x13, 0x4d, 0xa6, 0xad, 0x62, 0xd9, 0x77, 0x44, 0xd9, 0x04, 0x2b, 0x5e, 0x27, 0xde, 0xbe,
-	0x53, 0x69, 0xf5, 0xd3, 0x7c, 0xa9, 0xd2, 0xa8, 0x1a, 0x4d, 0xcc, 0x19, 0x30, 0xe9, 0xc8, 0xbb,
-	0xa0, 0xfe, 0x55, 0x6c, 0x8d, 0x64, 0x60, 0x73, 0x01, 0x15, 0x85, 0x1e, 0x7d, 0x01, 0xb7, 0xa6,
-	0xde, 0x58, 0xee, 0xe9, 0x55, 0x09, 0x3c, 0xf4, 0xc6, 0x94, 0x59, 0xcd, 0x8a, 0xe8, 0xd4, 0x71,
-	0x9d, 0xe0, 0x9c, 0x8e, 0xc5, 0xd6, 0xde, 0x90, 0x88, 0x3d, 0x01, 0x67, 0xda, 0xe1, 0xcc, 0xf7,
-	0xce, 0xd4, 0x4e, 0x97, 0x31, 0xd5, 0xb3, 0xf1, 0x29, 0x14, 0xf8, 0x0c, 0xb2, 0x85, 0x82, 0xf3,
-	0x9b, 0x11, 0x0b, 0x05, 0xa1, 0x4d, 0x28, 0xba, 0x34, 0x7c, 0xe1, 0xf9, 0xcf, 0x65, 0x1c, 0x43,
-	0x3c, 0x1a, 0x3f, 0x43, 0xa7, 0x9a, 0x4a, 0xfe, 0xe0, 0x86, 0x31, 0x63, 0x61, 0xce, 0x82, 0xc1,
-	0xb9, 0x2d, 0xfc, 0x7c, 0x25, 0x04, 0x0c, 0xce, 0xed, 0x05, 0x16, 0xce, 0x2e, 0xe6, 0x7f, 0xbc,
-	0x03, 0x75, 0x99, 0x6e, 0x12, 0x58, 0x13, 0x7a, 0x1a, 0x8a, 0x25, 0x59, 0x15, 0xb9, 0x26, 0xc1,
-	0x01, 0x3d, 0x0d, 0x8d, 0x43, 0x58, 0x11, 0x8b, 0xa6, 0x3f, 0xa3, 0xb2, 0xe9, 0xcf, 0xd2, 0x34,
-	0xf6, 0xca, 0xc3, 0xd5, 0xb8, 0xb6, 0xc0, 0xd3, 0x68, 0x62, 0x6a, 0xbc, 0xf1, 0x65, 0xe4, 0xdd,
-	0x62, 0xba, 0x84, 0xa8, 0x4f, 0xe8, 0xcd, 0x32, 0xfc, 0x23, 0xa3, 0xa8, 0x4a, 0x3b, 0x77, 0xc6,
-	0x6c, 0x74, 0x82, 0xf9, 0x68, 0x24, 0xd3, 0x80, 0x4a, 0xa6, 0x7c, 0x34, 0xfe, 0x63, 0x06, 0x56,
-	0xb1, 0x32, 0x69, 0x71, 0x88, 0x9d, 0xe2, 0xe7, 0xee, 0x24, 0x9b, 0x1f, 0x5d, 0x81, 0xe3, 0x0f,
-	0xdf, 0xde, 0xb5, 0x9e, 0x5f, 0x70, 0xad, 0x7f, 0x1f, 0x1a, 0x63, 0x3a, 0x71, 0x90, 0x95, 0xa4,
-	0x3e, 0xc4, 0x6d, 0x8c, 0x65, 0x09, 0x17, 0x16, 0xb0, 0xf1, 0x37, 0x33, 0xb0, 0xc2, 0xd5, 0x2d,
-	0xf4, 0x29, 0x88, 0x81, 0x7a, 0x2c, 0x8d, 0x67, 0x21, 0x4e, 0xc5, 0x3b, 0x45, 0x6a, 0x08, 0x42,
-	0x39, 0xf1, 0xfe, 0x0d, 0x61, 0x54, 0x0b, 0x28, 0xf9, 0x11, 0x5a, 0x49, 0xae, 0x85, 0x40, 0x11,
-	0x15, 0xbf, 0x99, 0xa2, 0xe0, 0xa9, 0xe2, 0xcc, 0x84, 0x72, 0x11, 0xb4, 0x53, 0x62, 0xd6, 0x3c,
-	0x03, 0x1b, 0x7b, 0x50, 0x8b, 0x35, 0x13, 0xf3, 0xf4, 0x57, 0xb9, 0xa7, 0x7f, 0x21, 0xf2, 0x96,
-	0x5d, 0x8c, 0xbc, 0x5d, 0xc1, 0xaa, 0x49, 0xed, 0xf1, 0xd5, 0x9e, 0xe7, 0x1f, 0x05, 0x27, 0xe1,
-	0x1e, 0xd7, 0x61, 0xd9, 0x1e, 0xa4, 0xc2, 0xc9, 0x31, 0x77, 0xba, 0x8c, 0x2a, 0x4a, 0x17, 0xc1,
-	0xf7, 0xa0, 0x1e, 0xc5, 0x9d, 0x35, 0x97, 0x6c, 0x4d, 0x85, 0x9e, 0xd1, 0x33, 0xcb, 0x8c, 0xd9,
-	0xe0, 0x24, 0x14, 0x4e, 0x59, 0xfc, 0x6d, 0xfc, 0xeb, 0x3c, 0x10, 0xc6, 0xcd, 0x09, 0x86, 0x49,
-	0x44, 0xcc, 0xb3, 0x0b, 0x11, 0xf3, 0x07, 0x40, 0x34, 0x02, 0x19, 0xc8, 0xcf, 0xa9, 0x40, 0x7e,
-	0x23, 0xa2, 0x15, 0x71, 0xfc, 0x07, 0xb0, 0x26, 0x0c, 0x82, 0x78, 0x57, 0x39, 0x6b, 0x10, 0x6e,
-	0x19, 0xc4, 0xfa, 0x2b, 0xa3, 0xe5, 0xd2, 0x8b, 0x9a, 0xe3, 0xd1, 0x72, 0xe9, 0xec, 0xd0, 0x18,
-	0x70, 0xe9, 0x95, 0x0c, 0x58, 0x5c, 0x60, 0x40, 0xcd, 0xf1, 0x55, 0x8a, 0x3b, 0xbe, 0x16, 0x5c,
-	0xb8, 0x5c, 0xfb, 0x8d, 0xb9, 0x70, 0xef, 0x41, 0x43, 0x3a, 0x41, 0x94, 0x7b, 0x8d, 0xa7, 0xb9,
-	0x08, 0x07, 0x67, 0x5b, 0x3a, 0xd8, 0x62, 0x31, 0x9d, 0x4a, 0x22, 0xa6, 0xf3, 0x3e, 0xac, 0x04,
-	0x8c, 0x7f, 0xad, 0xb9, 0x2b, 0x72, 0xdd, 0xe8, 0x18, 0x6d, 0xc5, 0x92, 0xd9, 0x40, 0xc4, 0x71,
-	0x04, 0x5f, 0x74, 0x17, 0xd5, 0x52, 0xdc, 0x45, 0x8f, 0xa2, 0xf0, 0x71, 0x70, 0xee, 0x4c, 0x51,
-	0xf1, 0x89, 0xf2, 0xb7, 0xc4, 0x00, 0x0f, 0xce, 0x9d, 0xa9, 0x29, 0x73, 0x15, 0xd8, 0x03, 0x69,
-	0xc3, 0x1d, 0xf1, 0x3e, 0x29, 0x69, 0x06, 0x7c, 0x14, 0x96, 0x51, 0x53, 0xdd, 0xe2, 0x64, 0x87,
-	0x89, 0x8c, 0x03, 0x36, 0x28, 0xc6, 0xff, 0xca, 0x40, 0x83, 0x31, 0x53, 0x6c, 0x9d, 0x7e, 0x0e,
-	0x28, 0x51, 0x5e, 0x73, 0x99, 0x56, 0x18, 0xad, 0x5c, 0xa5, 0x9f, 0x02, 0x2e, 0x3b, 0x8b, 0x59,
-	0xd7, 0x62, 0x91, 0x36, 0xe3, 0x8b, 0x34, 0x12, 0xc4, 0xfb, 0x37, 0xb8, 0x15, 0xc6, 0x20, 0xe4,
-	0x73, 0x28, 0x33, 0xee, 0x46, 0x56, 0x13, 0x39, 0x8d, 0x52, 0x07, 0x4d, 0x59, 0x68, 0xac, 0xe8,
-	0x4c, 0x3c, 0xa6, 0xa5, 0x0d, 0xe4, 0x53, 0xd2, 0x06, 0x34, 0x29, 0xb0, 0x0f, 0xf0, 0x94, 0x5e,
-	0x1d, 0x78, 0x23, 0xb4, 0xfd, 0x6f, 0x03, 0xb0, 0x05, 0x71, 0x6a, 0x4f, 0x1d, 0xe1, 0xba, 0x2a,
-	0x98, 0xe5, 0xe7, 0xf4, 0x6a, 0x0f, 0x01, 0x8c, 0x1b, 0x18, 0x3a, 0x12, 0x05, 0x05, 0xb3, 0xf4,
-	0x9c, 0x5e, 0x71, 0x39, 0x60, 0x41, 0xed, 0x29, 0xbd, 0xda, 0xa5, 0x5c, 0xdd, 0xf6, 0x7c, 0xc6,
-	0x89, 0xbe, 0xfd, 0x82, 0xe9, 0xd7, 0xb1, 0x90, 0x7f, 0xc5, 0xb7, 0x5f, 0x3c, 0xa5, 0x57, 0x32,
-	0xfd, 0xa0, 0xc8, 0xf0, 0x13, 0x6f, 0x24, 0x14, 0x04, 0x99, 0xbc, 0x14, 0x75, 0xca, 0x5c, 0x7a,
-	0x8e, 0xbf, 0x8d, 0x3f, 0xc9, 0x40, 0x8d, 0xf5, 0x1f, 0x65, 0x3b, 0xce, 0xbb, 0xc8, 0x81, 0xcb,
-	0x44, 0x39, 0x70, 0x0f, 0x85, 0x68, 0xe4, 0x1b, 0x45, 0xf6, 0xfa, 0x8d, 0x02, 0xe7, 0x86, 0xef,
-	0x12, 0x1f, 0x41, 0x99, 0xaf, 0x6d, 0x26, 0x2c, 0x72, 0xb1, 0x09, 0x8e, 0xbd, 0x90, 0x59, 0x42,
-	0xb2, 0xa7, 0x3c, 0xe5, 0x46, 0x73, 0xcc, 0xf2, 0x21, 0x2e, 0xfb, 0xca, 0x1d, 0x9b, 0x32, 0x0d,
-	0x85, 0x6b, 0x52, 0x6e, 0x74, 0xaf, 0xe7, 0x52, 0xd2, 0xeb, 0x69, 0xf4, 0xa1, 0xc4, 0xa6, 0x1a,
-	0x5f, 0x36, 0xa5, 0xd2, 0x4c, 0x5a, 0xa5, 0x4c, 0x9d, 0xb0, 0xd9, 0xce, 0xc2, 0xa4, 0x65, 0x56,
-	0xa8, 0x13, 0x76, 0x40, 0x59, 0x45, 0xc6, 0x5f, 0xc8, 0x40, 0x45, 0x5b, 0x46, 0xe8, 0x38, 0x56,
-	0xe3, 0xc5, 0xd7, 0x5c, 0x9c, 0xc5, 0x63, 0x03, 0xbe, 0x7f, 0xc3, 0xac, 0x8d, 0x62, 0x33, 0xb0,
-	0x2d, 0x78, 0x15, 0x4b, 0x66, 0x63, 0xe9, 0x7a, 0xb2, 0xe3, 0x92, 0x41, 0xd9, 0xef, 0x9d, 0x25,
-	0xc8, 0x33, 0x52, 0xe3, 0x31, 0xac, 0x68, 0xdd, 0xe0, 0x0e, 0x8f, 0xd7, 0x7d, 0x43, 0xe3, 0x57,
-	0x55, 0x61, 0xd6, 0x06, 0x8f, 0x76, 0xca, 0xf4, 0x25, 0x3a, 0xe6, 0x2f, 0x2e, 0xd2, 0xa4, 0x38,
-	0x88, 0x91, 0xbd, 0x76, 0x4a, 0xcd, 0xaf, 0xc1, 0xaa, 0x56, 0xfb, 0x9e, 0xe3, 0xda, 0x13, 0xe7,
-	0x67, 0xa8, 0x35, 0x04, 0xce, 0x99, 0x9b, 0xa8, 0x9f, 0x83, 0xbe, 0x55, 0xfd, 0x7f, 0x2b, 0x0b,
-	0x6b, 0xa2, 0x01, 0x4c, 0x48, 0x75, 0x98, 0x2a, 0x78, 0x18, 0x9c, 0x91, 0xcf, 0xa1, 0xc6, 0xc6,
-	0xc6, 0xf2, 0xe9, 0x99, 0x13, 0x84, 0x54, 0x46, 0x59, 0x53, 0xa4, 0x1f, 0xd3, 0x08, 0x18, 0xa9,
-	0x29, 0x28, 0xc9, 0x63, 0xa8, 0x60, 0x51, 0xee, 0x50, 0x12, 0x13, 0xd1, 0x5c, 0x2c, 0xc8, 0x07,
-	0x7a, 0xff, 0x86, 0x09, 0x41, 0x34, 0xec, 0x8f, 0xa1, 0x82, 0x73, 0x78, 0x81, 0x03, 0x99, 0x10,
-	0x55, 0x0b, 0x03, 0xcd, 0x0a, 0xcf, 0xa2, 0x61, 0x6f, 0x41, 0x8d, 0x0b, 0x2b, 0x31, 0x4e, 0x22,
-	0xd1, 0x6d, 0x6b, 0xb1, 0xb8, 0x1c, 0x49, 0xd6, 0xf9, 0x99, 0xf6, 0xbc, 0x53, 0x86, 0x62, 0xe8,
-	0x3b, 0x67, 0x67, 0xd4, 0x37, 0x36, 0xd4, 0xd0, 0x30, 0x29, 0x4c, 0x07, 0x21, 0x9d, 0x31, 0x1d,
-	0xdf, 0xf8, 0x37, 0x19, 0xa8, 0x08, 0xb9, 0xfa, 0x73, 0x87, 0x76, 0xb7, 0xb4, 0x4c, 0x71, 0xee,
-	0xbb, 0x8a, 0x12, 0xc3, 0xdf, 0x83, 0xe5, 0x29, 0x33, 0x48, 0x98, 0xc1, 0x1c, 0x8b, 0xeb, 0xd6,
-	0x25, 0x58, 0xe8, 0xda, 0xdb, 0xb0, 0x8a, 0xaa, 0x77, 0x60, 0x85, 0xce, 0xc4, 0x92, 0x48, 0x91,
-	0x95, 0xbd, 0xc2, 0x51, 0x43, 0x67, 0x72, 0x28, 0x10, 0x4c, 0x03, 0x0d, 0x42, 0xfb, 0x8c, 0x8a,
-	0xb5, 0xcd, 0x1f, 0x98, 0x91, 0x93, 0xb0, 0x95, 0xa5, 0x91, 0xf3, 0x7f, 0x56, 0x60, 0x73, 0x01,
-	0x25, 0x8c, 0x1c, 0x15, 0xc8, 0x9b, 0x38, 0xd3, 0x13, 0x4f, 0x39, 0x92, 0x33, 0x5a, 0x20, 0xef,
-	0x80, 0x61, 0xa4, 0x23, 0x99, 0xc2, 0xba, 0x64, 0x48, 0xf4, 0x04, 0x2b, 0x73, 0x3a, 0x8b, 0xc6,
-	0xde, 0x47, 0xf1, 0x4d, 0x2c, 0xd9, 0x9c, 0x84, 0xeb, 0xfa, 0xd5, 0xea, 0x6c, 0x01, 0x16, 0x90,
-	0x3f, 0x0b, 0x4d, 0xc5, 0xf7, 0x42, 0xf7, 0xd7, 0x7c, 0x03, 0xac, 0xa5, 0x0f, 0x5e, 0xd1, 0x52,
-	0xcc, 0x8b, 0x89, 0x0a, 0xd8, 0x86, 0x5c, 0x32, 0xbc, 0x42, 0xd5, 0xd6, 0x05, 0xbc, 0x29, 0xdb,
-	0x42, 0x5d, 0x7e, 0xb1, 0xc5, 0xfc, 0x6b, 0xbd, 0x1b, 0x7a, 0x68, 0x63, 0xcd, 0x9a, 0xb7, 0x44,
-	0xc5, 0x0a, 0xa5, 0xb7, 0x7b, 0x0e, 0x1b, 0x2f, 0x6c, 0x27, 0x94, 0xef, 0xa8, 0xb9, 0x26, 0x0a,
-	0xd8, 0xde, 0xc3, 0x57, 0xb4, 0xf7, 0x15, 0x2f, 0x1c, 0xb3, 0x6e, 0xd6, 0x5e, 0x2c, 0x02, 0x83,
-	0xad, 0x7f, 0x90, 0x83, 0x7a, 0xbc, 0x16, 0x26, 0x58, 0xc4, 0x66, 0x23, 0x95, 0x56, 0xa1, 0x49,
-	0x8b, 0x20, 0x47, 0x8f, 0x2b, 0xab, 0x8b, 0xe1, 0x97, 0x6c, 0x4a, 0xf8, 0x45, 0x8f, 0x7a, 0xe4,
-	0x5e, 0x15, 0x04, 0xcf, 0xbf, 0x56, 0x10, 0xbc, 0x90, 0x16, 0x04, 0xff, 0xe1, 0xb5, 0x51, 0x53,
-	0xee, 0xde, 0x4d, 0x8d, 0x98, 0x3e, 0xba, 0x3e, 0x62, 0xca, 0x55, 0xe0, 0xeb, 0xa2, 0xa5, 0x5a,
-	0xac, 0xb7, 0x74, 0x4d, 0xac, 0x42, 0x8b, 0xfe, 0xa6, 0x44, 0x4b, 0xcb, 0xdf, 0x22, 0x5a, 0xba,
-	0xf5, 0x27, 0x19, 0x20, 0x8b, 0xab, 0x83, 0x3c, 0xe1, 0x91, 0x2d, 0x97, 0x4e, 0x84, 0xe4, 0xfe,
-	0xc1, 0xeb, 0xad, 0x30, 0xc9, 0x10, 0xb2, 0x34, 0xf9, 0x10, 0x56, 0xf5, 0xb3, 0x23, 0xba, 0xe9,
-	0x5f, 0x33, 0x89, 0x8e, 0x8a, 0x9c, 0x58, 0x5a, 0xc6, 0x41, 0xfe, 0x95, 0x19, 0x07, 0x85, 0x57,
-	0x66, 0x1c, 0x2c, 0xc5, 0x33, 0x0e, 0xb6, 0xfe, 0x43, 0x06, 0x56, 0x53, 0x98, 0xf8, 0xbb, 0x7b,
-	0x67, 0xc6, 0x7b, 0x31, 0xb1, 0x96, 0x15, 0xbc, 0xa7, 0x4b, 0xb4, 0x03, 0xe9, 0xf8, 0x64, 0x53,
-	0x11, 0x88, 0x9d, 0xea, 0xfe, 0xab, 0xa4, 0x4b, 0x54, 0xc2, 0xd4, 0x8b, 0x6f, 0xfd, 0x76, 0x16,
-	0x2a, 0x1a, 0x92, 0x8d, 0x22, 0x67, 0x59, 0x2d, 0xdf, 0x8d, 0x6b, 0x86, 0xe8, 0xb8, 0xb8, 0x03,
-	0x22, 0xbc, 0xc3, 0xf1, 0x7c, 0x71, 0x09, 0x35, 0x10, 0x09, 0xb6, 0x61, 0x55, 0x46, 0x1d, 0x69,
-	0x94, 0x02, 0x2b, 0xf6, 0x1a, 0x11, 0x40, 0x16, 0x9d, 0x44, 0xfa, 0x0f, 0xa5, 0x4d, 0x19, 0xcd,
-	0x9d, 0xa5, 0x65, 0xe7, 0x88, 0xd0, 0xb5, 0x98, 0x44, 0xc6, 0xe7, 0x1f, 0xc1, 0xba, 0x8a, 0x5d,
-	0xc7, 0x4a, 0xf0, 0x70, 0x0a, 0x91, 0x31, 0x6a, 0xad, 0xc8, 0x4f, 0xe0, 0x76, 0xa2, 0x4f, 0x89,
-	0xa2, 0x3c, 0x57, 0xfb, 0x66, 0xac, 0x77, 0x7a, 0x0d, 0x5b, 0x7f, 0x0e, 0x6a, 0x31, 0x41, 0xf9,
-	0xdd, 0x4d, 0x79, 0xd2, 0x59, 0xc4, 0x47, 0x54, 0x77, 0x16, 0x6d, 0xfd, 0xcf, 0x1c, 0x90, 0x45,
-	0x59, 0xfd, 0x8b, 0xec, 0xc2, 0x22, 0x63, 0xe6, 0x52, 0x18, 0xf3, 0xff, 0x99, 0xfe, 0x10, 0xf9,
-	0x2c, 0xb5, 0xd0, 0x31, 0x5f, 0x9c, 0x0d, 0x85, 0x90, 0xbd, 0xf8, 0x34, 0x99, 0x60, 0x53, 0x8a,
-	0x1d, 0x7f, 0xd2, 0x14, 0xa8, 0x44, 0x9e, 0xcd, 0x31, 0x2c, 0xd9, 0xee, 0xe8, 0xdc, 0xf3, 0x85,
-	0x1c, 0xfc, 0xa5, 0x6f, 0xbd, 0x7d, 0x6e, 0xb7, 0xb0, 0x3c, 0x6a, 0x6d, 0xa6, 0xa8, 0xcc, 0xf8,
-	0x08, 0x2a, 0x1a, 0x98, 0x94, 0xa1, 0x70, 0xd0, 0x3d, 0xdc, 0xe9, 0x37, 0x6e, 0x90, 0x1a, 0x94,
-	0xcd, 0x4e, 0xbb, 0xff, 0xac, 0x63, 0x76, 0x76, 0x1b, 0x19, 0x52, 0x82, 0xfc, 0x41, 0x7f, 0x30,
-	0x6c, 0x64, 0x8d, 0x2d, 0x68, 0x8a, 0x1a, 0x17, 0xa3, 0x37, 0xbf, 0x99, 0x57, 0x3e, 0x47, 0x44,
-	0x0a, 0x13, 0xfd, 0x87, 0x50, 0xd5, 0xd5, 0x1b, 0xc1, 0x11, 0x89, 0xec, 0x05, 0x66, 0x9c, 0x7b,
-	0x9a, 0xac, 0x6e, 0x03, 0x8f, 0x5d, 0x8f, 0x55, 0xb1, 0x6c, 0x4c, 0x6f, 0x4d, 0x89, 0x93, 0xa2,
-	0xf1, 0x13, 0x63, 0xc3, 0xff, 0x0f, 0xea, 0xf1, 0x48, 0x85, 0x90, 0x48, 0x69, 0x06, 0x27, 0x2b,
-	0x1d, 0x0b, 0x5d, 0x90, 0x9f, 0x40, 0x23, 0x19, 0xe9, 0x10, 0xca, 0xf3, 0x35, 0xe5, 0x97, 0x9d,
-	0x78, 0xf0, 0x83, 0xec, 0xc3, 0x5a, 0x9a, 0x82, 0x87, 0xfc, 0x71, 0xbd, 0x93, 0x82, 0x2c, 0x2a,
-	0x71, 0xe4, 0x33, 0x11, 0xf1, 0x2a, 0xe0, 0xf4, 0xbf, 0x13, 0x6f, 0x5f, 0x1b, 0xec, 0x6d, 0xfe,
-	0x4f, 0x8b, 0x7d, 0x5d, 0x00, 0x44, 0x30, 0xd2, 0x80, 0x6a, 0xff, 0xa8, 0xd3, 0xb3, 0xda, 0xfb,
-	0xad, 0x5e, 0xaf, 0x73, 0xd0, 0xb8, 0x41, 0x08, 0xd4, 0x31, 0x6a, 0xbf, 0xab, 0x60, 0x19, 0x06,
-	0x13, 0x91, 0x47, 0x09, 0xcb, 0x92, 0x35, 0x68, 0x74, 0x7b, 0x09, 0x68, 0x8e, 0x34, 0x61, 0xed,
-	0xa8, 0xc3, 0x03, 0xfd, 0xb1, 0x7a, 0xf3, 0xcc, 0x68, 0x10, 0xaf, 0xcb, 0x8c, 0x86, 0xaf, 0xec,
-	0xc9, 0x84, 0x86, 0x62, 0x1d, 0x48, 0x5d, 0xfa, 0x6f, 0x67, 0x60, 0x3d, 0x81, 0x88, 0xc2, 0x05,
-	0x5c, 0x93, 0x8e, 0xeb, 0xd0, 0x55, 0x04, 0xca, 0xd5, 0xf4, 0x3e, 0xac, 0x28, 0xef, 0x55, 0x62,
-	0x57, 0x6a, 0x28, 0x84, 0x24, 0xfe, 0x10, 0x56, 0x35, 0x27, 0x58, 0x42, 0x56, 0x10, 0x0d, 0x25,
-	0x0a, 0x18, 0x9b, 0xea, 0x44, 0x48, 0xa2, 0xd7, 0x63, 0xd8, 0x48, 0x22, 0xa2, 0x80, 0x60, 0xbc,
-	0xbf, 0xf2, 0x91, 0x3c, 0x48, 0x30, 0x42, 0xbc, 0xb7, 0xfa, 0x84, 0xcb, 0xe6, 0x7f, 0x67, 0x09,
-	0xc8, 0x97, 0x73, 0xea, 0x5f, 0xe1, 0x49, 0xa4, 0xe0, 0x55, 0xe9, 0xb6, 0xd2, 0xd3, 0x92, 0x7d,
-	0xad, 0xd3, 0x86, 0x69, 0xa7, 0xfd, 0xf2, 0xaf, 0x3e, 0xed, 0x57, 0x78, 0xd5, 0x69, 0xbf, 0xb7,
-	0xa1, 0xe6, 0x9c, 0xb9, 0x1e, 0x13, 0x85, 0x4c, 0x13, 0x0e, 0x9a, 0x4b, 0x77, 0x73, 0xf7, 0xaa,
-	0x66, 0x55, 0x00, 0x99, 0x1e, 0x1c, 0x90, 0xc7, 0x11, 0x11, 0x1d, 0x9f, 0xe1, 0x89, 0x57, 0x5d,
-	0x08, 0x76, 0xc6, 0x67, 0x54, 0x38, 0x96, 0xd0, 0xd2, 0x90, 0x85, 0x19, 0x3c, 0x20, 0xef, 0x40,
-	0x3d, 0xf0, 0xe6, 0xcc, 0xb0, 0x90, 0xc3, 0xc0, 0x23, 0x82, 0x55, 0x0e, 0x3d, 0x92, 0xf1, 0xe1,
-	0xd5, 0x79, 0x40, 0xad, 0xa9, 0x13, 0x04, 0x4c, 0x3d, 0x1b, 0x79, 0x6e, 0xe8, 0x7b, 0x13, 0x11,
-	0xe4, 0x5b, 0x99, 0x07, 0xf4, 0x90, 0x63, 0xda, 0x1c, 0x41, 0x3e, 0x8e, 0xba, 0x34, 0xb3, 0x1d,
-	0x3f, 0x68, 0x02, 0x76, 0x49, 0xbe, 0x29, 0xea, 0xef, 0xb6, 0xe3, 0xab, 0xbe, 0xb0, 0x87, 0x20,
-	0x71, 0x0a, 0xb1, 0x92, 0x3c, 0x85, 0xf8, 0x67, 0xd2, 0x4f, 0x21, 0xd6, 0xb0, 0xea, 0x07, 0xa2,
-	0xea, 0xc5, 0x29, 0xfe, 0x56, 0x87, 0x11, 0x17, 0x0f, 0x57, 0xd6, 0xbf, 0xcd, 0xe1, 0xca, 0xe5,
-	0xb4, 0xc3, 0x95, 0x1f, 0x41, 0x05, 0x8f, 0xbd, 0x59, 0xe7, 0x98, 0x79, 0xc7, 0x83, 0x96, 0x0d,
-	0xfd, 0x5c, 0xdc, 0xbe, 0xe3, 0x86, 0x26, 0xf8, 0xf2, 0x67, 0xb0, 0x78, 0xce, 0x71, 0xe5, 0x17,
-	0x78, 0xce, 0x51, 0x1c, 0xcf, 0xdb, 0x86, 0x92, 0x9c, 0x27, 0x42, 0x20, 0x7f, 0xea, 0x7b, 0x53,
-	0x19, 0x28, 0x61, 0xbf, 0x49, 0x1d, 0xb2, 0xa1, 0x27, 0x0a, 0x67, 0x43, 0xcf, 0xf8, 0xff, 0xa1,
-	0xa2, 0xb1, 0x1a, 0x79, 0x8b, 0xfb, 0x25, 0x99, 0x6d, 0x26, 0x74, 0x4b, 0x3e, 0x8a, 0x65, 0x01,
-	0xed, 0x8e, 0x99, 0xbc, 0x19, 0x3b, 0x3e, 0xc5, 0x13, 0xc9, 0x96, 0x4f, 0x2f, 0xa8, 0x1f, 0xc8,
-	0xc0, 0x55, 0x43, 0x21, 0x4c, 0x0e, 0x37, 0x7e, 0x0d, 0x56, 0x63, 0x73, 0x2b, 0x44, 0xc4, 0x3b,
-	0xb0, 0x84, 0xe3, 0x26, 0xb3, 0x23, 0xe2, 0xe7, 0x0d, 0x05, 0x0e, 0x4f, 0x5f, 0xf3, 0x98, 0x9b,
-	0x35, 0xf3, 0xbd, 0x13, 0x6c, 0x24, 0x63, 0x56, 0x04, 0xec, 0xc8, 0xf7, 0x4e, 0x8c, 0x3f, 0xcc,
-	0x41, 0x6e, 0xdf, 0x9b, 0xe9, 0xd9, 0x7a, 0x99, 0x85, 0x6c, 0x3d, 0x61, 0x70, 0x5a, 0xca, 0xa0,
-	0x14, 0x3a, 0x3b, 0x46, 0x9b, 0xa4, 0x51, 0x79, 0x0f, 0xea, 0x4c, 0x4e, 0x84, 0x1e, 0xb3, 0xd8,
-	0x5f, 0xd8, 0x3e, 0x57, 0x88, 0x79, 0xf2, 0x6b, 0xd5, 0x9e, 0x86, 0x43, 0x6f, 0x8f, 0xc3, 0xc9,
-	0x1a, 0xe4, 0x94, 0xf9, 0x82, 0x68, 0xf6, 0x48, 0x36, 0x60, 0x09, 0x73, 0xeb, 0xaf, 0x44, 0x74,
-	0x5f, 0x3c, 0x91, 0x1f, 0xc0, 0x6a, 0xbc, 0x5e, 0x2e, 0x8a, 0x84, 0x6e, 0xa4, 0x57, 0x8c, 0x32,
-	0xe9, 0x26, 0x30, 0x39, 0xc2, 0x69, 0x44, 0x16, 0xd1, 0x29, 0xa5, 0x88, 0xd2, 0x84, 0x5e, 0x29,
-	0x26, 0xf4, 0xee, 0x40, 0x25, 0x9c, 0x5c, 0x58, 0x33, 0xfb, 0x6a, 0xe2, 0xd9, 0x63, 0xb1, 0xbe,
-	0x21, 0x9c, 0x5c, 0x1c, 0x71, 0x08, 0xf9, 0x10, 0x60, 0x3a, 0x9b, 0x89, 0xb5, 0x87, 0x11, 0x94,
-	0x88, 0x95, 0x0f, 0x8f, 0x8e, 0x38, 0xcb, 0x99, 0xe5, 0xe9, 0x6c, 0xc6, 0x7f, 0x92, 0x5d, 0xa8,
-	0xa7, 0x9e, 0x1a, 0xbe, 0x2d, 0x73, 0xa0, 0xbd, 0xd9, 0x76, 0xca, 0xe2, 0xac, 0x8d, 0x74, 0xd8,
-	0xd6, 0x4f, 0x80, 0xfc, 0x29, 0xcf, 0xee, 0x0e, 0xa1, 0xac, 0xfa, 0xa7, 0x1f, 0x7d, 0xc5, 0xc3,
-	0x1d, 0x95, 0xd8, 0xd1, 0xd7, 0xd6, 0x78, 0xec, 0x33, 0xb9, 0xc8, 0x37, 0x4c, 0x25, 0xf2, 0x41,
-	0xdb, 0x31, 0xc5, 0xe9, 0x01, 0xe3, 0xbf, 0x65, 0xa0, 0xc0, 0xcf, 0xe1, 0xbe, 0x0b, 0xcb, 0x9c,
-	0x5e, 0x65, 0x3e, 0x8a, 0x9c, 0x00, 0xbe, 0xef, 0x0e, 0x45, 0xd2, 0x23, 0x5b, 0x16, 0xda, 0xdd,
-	0x04, 0x59, 0x35, 0xf3, 0xda, 0xfd, 0x04, 0x77, 0xa0, 0xac, 0x9a, 0xd6, 0x58, 0xa7, 0x24, 0x5b,
-	0x26, 0x6f, 0x42, 0xfe, 0xdc, 0x9b, 0x49, 0xcf, 0x0f, 0x44, 0x23, 0x69, 0x22, 0x3c, 0xea, 0x0b,
-	0x6b, 0x23, 0x3a, 0xd5, 0x90, 0x13, 0x7d, 0x61, 0x8d, 0x20, 0x1b, 0x2c, 0xbe, 0xe3, 0x52, 0xca,
-	0x3b, 0x1e, 0xc3, 0x32, 0x93, 0x03, 0x5a, 0x62, 0xc2, 0xf5, 0x9b, 0xe6, 0xf7, 0x99, 0x86, 0x37,
-	0x9a, 0xcc, 0xc7, 0x54, 0xf7, 0xbd, 0x61, 0xa6, 0x9f, 0x80, 0x4b, 0xcd, 0xda, 0xf8, 0x9d, 0x0c,
-	0x97, 0x2f, 0xac, 0x5e, 0x72, 0x0f, 0xf2, 0xae, 0x4c, 0x62, 0x88, 0xf4, 0x38, 0x75, 0xca, 0x86,
-	0xd1, 0x99, 0x48, 0xc1, 0xa6, 0x0e, 0x43, 0xff, 0x7a, 0xed, 0x35, 0xb3, 0xe2, 0xce, 0xa7, 0xca,
-	0x75, 0xf5, 0x3d, 0xf9, 0x5a, 0x09, 0xb7, 0x0f, 0x7f, 0x7b, 0xb5, 0x4c, 0xb7, 0xb5, 0x94, 0xc1,
-	0x7c, 0x6c, 0xc7, 0x94, 0x5a, 0xe0, 0xf8, 0x8c, 0x6a, 0xa9, 0x82, 0xbf, 0x97, 0x85, 0x5a, 0xac,
-	0x47, 0x98, 0x33, 0xc9, 0x36, 0x00, 0x1e, 0x58, 0x12, 0xf3, 0x0d, 0x0c, 0x24, 0x14, 0x75, 0x6d,
-	0x9c, 0xb2, 0xb1, 0x71, 0x52, 0x59, 0x48, 0x39, 0x3d, 0x0b, 0xe9, 0x01, 0x94, 0xa3, 0x3b, 0x29,
-	0xe2, 0x5d, 0x62, 0xed, 0xc9, 0xb3, 0x46, 0x11, 0x51, 0x94, 0xb7, 0x54, 0xd0, 0xf3, 0x96, 0xbe,
-	0xd0, 0xd2, 0x5c, 0x96, 0xb0, 0x1a, 0x23, 0x6d, 0x44, 0x7f, 0x21, 0x49, 0x2e, 0xc6, 0x63, 0xa8,
-	0x68, 0x9d, 0xd7, 0x53, 0x45, 0x32, 0xb1, 0x54, 0x11, 0x75, 0x56, 0x30, 0x1b, 0x9d, 0x15, 0x34,
-	0xfe, 0x62, 0x16, 0x6a, 0x6c, 0x7d, 0x39, 0xee, 0xd9, 0x91, 0x37, 0x71, 0x46, 0x18, 0x68, 0x52,
-	0x2b, 0x4c, 0x28, 0x5a, 0x72, 0x9d, 0x89, 0x25, 0xc6, 0xf5, 0x2c, 0xfd, 0xa0, 0x34, 0x17, 0xd2,
-	0xea, 0xa0, 0xb4, 0x01, 0x35, 0x26, 0x18, 0x31, 0x64, 0x14, 0xdd, 0x6c, 0x61, 0x56, 0x4e, 0x29,
-	0xdd, 0xb1, 0x03, 0x2e, 0x21, 0x7f, 0x00, 0xab, 0x8c, 0x06, 0xcf, 0x88, 0x4e, 0x9d, 0xc9, 0xc4,
-	0x89, 0x8e, 0x11, 0xe5, 0xcc, 0xc6, 0x29, 0xa5, 0xa6, 0x1d, 0xd2, 0x43, 0x86, 0x10, 0x17, 0x61,
-	0x94, 0xc6, 0x4e, 0x60, 0x9f, 0x44, 0x99, 0xad, 0xea, 0x19, 0xc3, 0xd3, 0xf6, 0xa5, 0x16, 0x9e,
-	0x5e, 0x12, 0x27, 0x8c, 0xec, 0x4b, 0x15, 0x9e, 0x4e, 0x70, 0x52, 0x31, 0xc9, 0x49, 0xc6, 0xbf,
-	0xcc, 0x42, 0x45, 0x63, 0xcb, 0xd7, 0xd9, 0x5d, 0x6f, 0x2f, 0x04, 0x06, 0xcb, 0x7a, 0x0c, 0xf0,
-	0xed, 0x78, 0x93, 0x39, 0x75, 0xd6, 0x44, 0x67, 0xe0, 0x5b, 0x50, 0x66, 0xab, 0xee, 0x23, 0x74,
-	0xc1, 0x8a, 0x8b, 0x68, 0x10, 0x70, 0x34, 0x3f, 0x91, 0xc8, 0x87, 0x88, 0x2c, 0x44, 0xc8, 0x87,
-	0x0c, 0xf9, 0xb2, 0x5c, 0xf3, 0x4f, 0xa1, 0x2a, 0x6a, 0xc5, 0x39, 0xc5, 0xd7, 0x8d, 0x56, 0x7d,
-	0x6c, 0xbe, 0xcd, 0x0a, 0x6f, 0x8e, 0x4f, 0xbe, 0x28, 0xf8, 0x50, 0x16, 0x2c, 0xbd, 0xaa, 0xe0,
-	0x43, 0xfe, 0x60, 0xec, 0xa9, 0xf4, 0x7d, 0x4c, 0x30, 0x93, 0x72, 0xec, 0x43, 0x58, 0x95, 0xe2,
-	0x6a, 0xee, 0xda, 0xae, 0xeb, 0xcd, 0xdd, 0x11, 0x95, 0xc7, 0x05, 0x89, 0x40, 0x1d, 0x47, 0x18,
-	0x63, 0xac, 0xce, 0x9e, 0xf3, 0x44, 0xb5, 0xfb, 0x50, 0xe0, 0x7a, 0x39, 0x57, 0x3e, 0xd2, 0x05,
-	0x17, 0x27, 0x21, 0xf7, 0xa0, 0xc0, 0xd5, 0xf3, 0xec, 0xb5, 0xc2, 0x86, 0x13, 0x18, 0x2d, 0x20,
-	0xac, 0xe0, 0x21, 0x0d, 0x7d, 0x67, 0x14, 0x44, 0x27, 0x11, 0x0b, 0xcc, 0xfe, 0xe4, 0x6d, 0x45,
-	0x9e, 0xdb, 0x88, 0x12, 0x6d, 0x54, 0x4e, 0xc3, 0x36, 0xa6, 0xd5, 0x58, 0x1d, 0x42, 0x5d, 0x9a,
-	0xc0, 0xc6, 0x09, 0x0d, 0x5f, 0x50, 0xea, 0xba, 0x4c, 0x19, 0x1a, 0x51, 0x37, 0xf4, 0xed, 0x09,
-	0x9b, 0x24, 0xfe, 0x06, 0x8f, 0x16, 0x6a, 0x8d, 0x7c, 0x20, 0x3b, 0x51, 0xc1, 0xb6, 0x2a, 0xc7,
-	0x65, 0xc7, 0xfa, 0x49, 0x1a, 0x6e, 0xeb, 0x57, 0x61, 0xeb, 0xfa, 0x42, 0x29, 0xa7, 0x90, 0xef,
-	0xc5, 0xa5, 0x8a, 0x8a, 0x03, 0x4e, 0x3c, 0x3b, 0xe4, 0xbd, 0xd1, 0x25, 0x4b, 0x0f, 0x2a, 0x1a,
-	0x26, 0xda, 0xfb, 0x33, 0xa8, 0xdc, 0xf1, 0x07, 0xb6, 0x23, 0xb9, 0x9e, 0x3f, 0xc5, 0xb8, 0xdb,
-	0xd8, 0x8a, 0x6a, 0xcf, 0x98, 0xcb, 0x11, 0x1c, 0x53, 0x23, 0x8c, 0x6d, 0x58, 0x46, 0xcd, 0x5e,
-	0xdb, 0xe8, 0x5e, 0xa6, 0x0c, 0x1a, 0x6b, 0x40, 0x7a, 0x5c, 0x76, 0xe9, 0x49, 0x7b, 0xff, 0x29,
-	0x07, 0x15, 0x0d, 0xcc, 0x76, 0x23, 0xcc, 0x74, 0xb4, 0xc6, 0x8e, 0x3d, 0xa5, 0x32, 0xc8, 0x59,
-	0x33, 0x6b, 0x08, 0xdd, 0x15, 0x40, 0xb6, 0x17, 0xdb, 0x17, 0x67, 0x96, 0x37, 0x0f, 0xad, 0x31,
-	0x3d, 0xf3, 0xa9, 0xec, 0x65, 0xd5, 0xbe, 0x38, 0xeb, 0xcf, 0xc3, 0x5d, 0x84, 0x31, 0x2a, 0x26,
-	0x4b, 0x34, 0x2a, 0x91, 0xf8, 0x36, 0xb5, 0x2f, 0x23, 0x2a, 0x91, 0x21, 0xca, 0x39, 0x33, 0xaf,
-	0x32, 0x44, 0xb9, 0xb5, 0x98, 0xdc, 0x40, 0x0b, 0x8b, 0x1b, 0xe8, 0xc7, 0xb0, 0xc1, 0x37, 0x50,
-	0x21, 0x9a, 0xad, 0xc4, 0x4a, 0x5e, 0x43, 0xac, 0x78, 0x49, 0x4d, 0xed, 0x6d, 0xb0, 0x37, 0x90,
-	0x62, 0x29, 0x70, 0x7e, 0xc6, 0x05, 0x59, 0xc6, 0x64, 0x6f, 0x26, 0x2a, 0x1f, 0x38, 0x3f, 0xa3,
-	0x8c, 0x12, 0x53, 0x6c, 0x74, 0x4a, 0x71, 0x92, 0x64, 0xea, 0xb8, 0x49, 0x4a, 0xfb, 0x32, 0x4e,
-	0x59, 0x16, 0x94, 0xf6, 0xa5, 0x4e, 0xf9, 0x08, 0x36, 0xa7, 0x74, 0xec, 0xd8, 0xf1, 0x6a, 0xad,
-	0x48, 0x71, 0x5b, 0xe3, 0x68, 0xad, 0xcc, 0x80, 0x1b, 0xee, 0x6c, 0x34, 0x7e, 0xe6, 0x4d, 0x4f,
-	0x1c, 0xae, 0xb3, 0xf0, 0xa4, 0x9f, 0xbc, 0x59, 0x77, 0xe7, 0xd3, 0x5f, 0x41, 0x30, 0x2b, 0x12,
-	0x18, 0x35, 0xa8, 0x0c, 0x42, 0x6f, 0x26, 0xa7, 0xb9, 0x0e, 0x55, 0xfe, 0x28, 0xce, 0xe0, 0xde,
-	0x82, 0x9b, 0x28, 0x12, 0x86, 0xde, 0xcc, 0x9b, 0x78, 0x67, 0x57, 0x31, 0x3f, 0xde, 0xbf, 0xcd,
-	0xc0, 0x6a, 0x0c, 0x2b, 0xc4, 0xeb, 0xc7, 0x5c, 0x9e, 0xa9, 0x13, 0x84, 0x7c, 0x0d, 0xae, 0x68,
-	0x6b, 0x90, 0x13, 0x72, 0x61, 0x26, 0x4f, 0x15, 0xb6, 0xa2, 0xcb, 0x42, 0x64, 0x41, 0x2e, 0x52,
-	0x9a, 0x8b, 0x22, 0x45, 0x94, 0x97, 0xd7, 0x88, 0xc8, 0x2a, 0x7e, 0x49, 0x9c, 0xf6, 0x19, 0x8b,
-	0x57, 0xce, 0xc5, 0x8f, 0x4c, 0xe8, 0x3e, 0x3f, 0xd9, 0x83, 0xc8, 0x11, 0x18, 0x18, 0xff, 0x30,
-	0x03, 0x10, 0xf5, 0x0e, 0x0f, 0x6d, 0x28, 0xbd, 0x25, 0x83, 0xf9, 0xb6, 0x9a, 0x8e, 0xf2, 0x16,
-	0x54, 0x55, 0x6a, 0x76, 0xa4, 0x09, 0x55, 0x24, 0x8c, 0xa9, 0x43, 0xef, 0xc1, 0xf2, 0xd9, 0xc4,
-	0x3b, 0x41, 0x8d, 0x55, 0xe8, 0x2d, 0x3c, 0xe9, 0xad, 0xce, 0xc1, 0x52, 0x1b, 0x89, 0xf4, 0xa6,
-	0x7c, 0x6a, 0xf6, 0xb6, 0xae, 0x05, 0x19, 0x7f, 0x3d, 0xab, 0xf2, 0x3f, 0xa3, 0x91, 0x78, 0xb9,
-	0x79, 0xf7, 0xf3, 0xe4, 0xd2, 0xbc, 0x2c, 0xbc, 0xf8, 0x18, 0xea, 0x3e, 0xdf, 0x94, 0xe4, 0x8e,
-	0x95, 0x7f, 0xc9, 0x8e, 0x55, 0xf3, 0x63, 0x9a, 0xce, 0xf7, 0xa1, 0x61, 0x8f, 0x2f, 0xa8, 0x1f,
-	0x3a, 0xe8, 0xad, 0x47, 0xfd, 0x58, 0x64, 0x5c, 0x6a, 0x70, 0x54, 0x44, 0xdf, 0x83, 0x65, 0x71,
-	0x2e, 0x5c, 0x51, 0x8a, 0x5b, 0xa9, 0x22, 0x30, 0x23, 0x34, 0xfe, 0x89, 0x4c, 0x38, 0x8d, 0xcf,
-	0xee, 0xcb, 0x47, 0x45, 0x7f, 0xc3, 0xec, 0x62, 0x00, 0x55, 0x30, 0x92, 0x08, 0x02, 0x08, 0x79,
-	0xc4, 0x81, 0x22, 0x04, 0x10, 0x1f, 0xd6, 0xfc, 0xeb, 0x0c, 0xab, 0xf1, 0xef, 0x32, 0x50, 0xdc,
-	0xf7, 0x66, 0xfb, 0x0e, 0x3f, 0xb6, 0x80, 0xcb, 0x44, 0xc5, 0xa8, 0x96, 0xd8, 0x23, 0x26, 0xfe,
-	0xbc, 0xe4, 0x64, 0x5d, 0xaa, 0x9a, 0x57, 0x8b, 0xab, 0x79, 0x5f, 0xc0, 0x2d, 0x0c, 0x01, 0xfa,
-	0xde, 0xcc, 0xf3, 0xd9, 0x52, 0xb5, 0x27, 0x5c, 0xdd, 0xf3, 0xdc, 0xf0, 0x5c, 0xca, 0xce, 0x9b,
-	0xa7, 0x94, 0x1e, 0x69, 0x14, 0x87, 0x8a, 0x00, 0x4f, 0xd5, 0x4e, 0xc2, 0x0b, 0x8b, 0x5b, 0xe8,
-	0x42, 0x1f, 0xe5, 0x12, 0x75, 0x99, 0x21, 0x3a, 0x08, 0x47, 0x8d, 0xd4, 0xf8, 0x0c, 0xca, 0xca,
-	0xd9, 0x43, 0xde, 0x87, 0xf2, 0xb9, 0x37, 0x13, 0x1e, 0xa1, 0x4c, 0xec, 0xf4, 0xa1, 0x78, 0x6b,
-	0xb3, 0x74, 0xce, 0x7f, 0x04, 0xc6, 0x1f, 0x16, 0xa1, 0xd8, 0x75, 0x2f, 0x3c, 0x67, 0x84, 0x29,
-	0xab, 0x53, 0x3a, 0xf5, 0xe4, 0xe5, 0x14, 0xec, 0x37, 0xe6, 0x66, 0x45, 0x77, 0x4b, 0xe5, 0x44,
-	0x6e, 0x96, 0xba, 0x55, 0x6a, 0x1d, 0x96, 0x7c, 0xfd, 0x72, 0xa8, 0x82, 0x8f, 0x89, 0xfe, 0x6a,
-	0xbf, 0x2c, 0x68, 0x57, 0x7e, 0xb0, 0xba, 0x78, 0x36, 0x21, 0x0e, 0x19, 0x3f, 0x19, 0x5b, 0x46,
-	0x08, 0x0e, 0xd8, 0x1b, 0x50, 0x14, 0x87, 0xfd, 0xf8, 0xe9, 0x2c, 0x9e, 0x99, 0x2f, 0x40, 0xc8,
-	0x0d, 0x3e, 0xe5, 0x21, 0x5c, 0xa5, 0xc8, 0xe6, 0xcc, 0xaa, 0x04, 0xee, 0x32, 0x5e, 0xbb, 0x03,
-	0x15, 0x4e, 0xcf, 0x49, 0x4a, 0x22, 0xd3, 0x13, 0x41, 0x48, 0x90, 0x72, 0xc7, 0x5a, 0x39, 0xf5,
-	0x8e, 0x35, 0xcc, 0x49, 0x56, 0x52, 0x96, 0xbf, 0x22, 0xf0, 0x9b, 0xb5, 0x34, 0xb8, 0xbc, 0xb8,
-	0x50, 0xf8, 0x54, 0xf8, 0xa1, 0x71, 0xe9, 0x53, 0x79, 0x1b, 0x6a, 0xa7, 0xf6, 0x64, 0x72, 0x62,
-	0x8f, 0x9e, 0x73, 0x57, 0x40, 0x95, 0x7b, 0x3f, 0x25, 0x10, 0x7d, 0x01, 0x77, 0xa0, 0xa2, 0xcd,
-	0x32, 0xa6, 0x71, 0xe6, 0x4d, 0x88, 0xe6, 0x37, 0xe9, 0xe1, 0xab, 0xbf, 0x86, 0x87, 0x4f, 0x4b,
-	0x67, 0x5d, 0x8e, 0xa7, 0xb3, 0xde, 0x42, 0x69, 0x2a, 0x52, 0x0e, 0x1b, 0xfc, 0x1a, 0x27, 0x7b,
-	0x3c, 0xc6, 0x94, 0x43, 0x74, 0x64, 0xf1, 0xc1, 0xe3, 0xf8, 0x15, 0x6e, 0x4b, 0x70, 0x18, 0x27,
-	0xb9, 0xcd, 0xdd, 0xd4, 0x33, 0xdb, 0x19, 0xe3, 0xe9, 0x0a, 0xee, 0x3d, 0x28, 0xda, 0xd3, 0xf0,
-	0xc8, 0x76, 0xc6, 0xe4, 0x2e, 0x54, 0x25, 0x1a, 0x77, 0xc7, 0x55, 0x3e, 0xfe, 0x02, 0x3d, 0xe0,
-	0x57, 0x22, 0x28, 0x8a, 0xa9, 0x3a, 0xf5, 0x6d, 0x56, 0x04, 0x09, 0xf2, 0xc1, 0x47, 0x98, 0xe5,
-	0x13, 0x52, 0x3c, 0xd7, 0x5d, 0x7f, 0x78, 0x4b, 0x25, 0x1f, 0x20, 0x97, 0xca, 0xff, 0x3c, 0x38,
-	0xc6, 0x29, 0x99, 0x72, 0xc7, 0x63, 0x74, 0x1b, 0x31, 0xfd, 0x57, 0x90, 0x62, 0x8c, 0x8e, 0x13,
-	0x90, 0xcf, 0x34, 0xfb, 0xb5, 0x89, 0xc4, 0x6f, 0x24, 0xea, 0xbf, 0xee, 0xf4, 0xd9, 0x6d, 0x00,
-	0x27, 0x60, 0xbb, 0x4c, 0x40, 0xdd, 0x31, 0x1e, 0xcf, 0x2e, 0x99, 0x65, 0x27, 0x78, 0xca, 0x01,
-	0xdf, 0xad, 0x61, 0xdb, 0x82, 0xaa, 0xfe, 0x9a, 0xa4, 0x04, 0xf9, 0xfe, 0x51, 0xa7, 0xd7, 0xb8,
-	0x41, 0x2a, 0x50, 0x1c, 0x74, 0x86, 0xc3, 0x03, 0x8c, 0xf4, 0x55, 0xa1, 0xa4, 0x4e, 0x6c, 0x66,
-	0xd9, 0x53, 0xab, 0xdd, 0xee, 0x1c, 0x0d, 0x3b, 0xbb, 0x8d, 0xdc, 0x4f, 0xf3, 0xa5, 0x6c, 0x23,
-	0x67, 0xfc, 0x51, 0x0e, 0x2a, 0xda, 0x28, 0xbc, 0x5c, 0x18, 0xdf, 0x06, 0x40, 0x4b, 0x32, 0xca,
-	0x48, 0xcd, 0x9b, 0x65, 0x06, 0xe1, 0x93, 0xaf, 0xc7, 0x28, 0xf8, 0xfd, 0x18, 0x2a, 0x46, 0xf1,
-	0x36, 0xd4, 0xf8, 0x0d, 0x16, 0x7a, 0xbc, 0xb6, 0x60, 0x56, 0x39, 0x50, 0x88, 0x6a, 0x3c, 0xca,
-	0x8d, 0x44, 0x78, 0x8e, 0x50, 0x5c, 0xb1, 0xc3, 0x41, 0x78, 0x92, 0x10, 0x8f, 0x81, 0x06, 0xde,
-	0xe4, 0x82, 0x72, 0x0a, 0xae, 0x11, 0x56, 0x04, 0x6c, 0x28, 0x8e, 0xc9, 0x0b, 0x79, 0xa8, 0x9d,
-	0x25, 0x2e, 0x98, 0x55, 0x0e, 0x14, 0x0d, 0xfd, 0x40, 0x32, 0x10, 0xcf, 0x5e, 0xd9, 0x5c, 0xe4,
-	0x86, 0x18, 0xf3, 0x1c, 0x2c, 0xb8, 0x11, 0xcb, 0xc8, 0x18, 0xdf, 0x5b, 0x2c, 0xf7, 0x6a, 0x77,
-	0x22, 0x79, 0x1f, 0xc8, 0x74, 0x36, 0xb3, 0x52, 0x1c, 0x7c, 0x79, 0x73, 0x79, 0x3a, 0x9b, 0x0d,
-	0x35, 0xff, 0xd7, 0x77, 0xe0, 0x7b, 0xfc, 0x06, 0x48, 0x8b, 0x2d, 0x60, 0xec, 0xa2, 0x32, 0xc5,
-	0x22, 0xb1, 0x9c, 0xd1, 0xc5, 0x72, 0x8a, 0xf4, 0xcb, 0xa6, 0x4a, 0xbf, 0x97, 0xc9, 0x09, 0x63,
-	0x0f, 0x2a, 0x47, 0xda, 0x45, 0x7e, 0x77, 0xd9, 0x0e, 0x21, 0xaf, 0xf0, 0xe3, 0x7b, 0x07, 0xf7,
-	0x29, 0xfa, 0xe2, 0xe6, 0x3e, 0xad, 0x37, 0x59, 0xad, 0x37, 0xc6, 0xdf, 0xcf, 0xf0, 0x8b, 0x8f,
-	0x54, 0xe7, 0xa3, 0xbb, 0x03, 0x65, 0xf8, 0x2d, 0x3a, 0xf2, 0x5f, 0x91, 0x61, 0x37, 0x71, 0x5a,
-	0x1f, 0xbb, 0x66, 0x79, 0xa7, 0xa7, 0x01, 0x95, 0x39, 0x1e, 0x15, 0x84, 0xf5, 0x11, 0x24, 0x95,
-	0x6f, 0xa6, 0xe1, 0x3b, 0xbc, 0xfe, 0x40, 0x24, 0x76, 0x30, 0xe5, 0xfb, 0xd0, 0xbe, 0x14, 0xad,
-	0x06, 0x4c, 0x05, 0x11, 0xf1, 0x01, 0x79, 0x2a, 0x58, 0x3d, 0x1b, 0x7f, 0x47, 0xdc, 0x4a, 0x90,
-	0x1c, 0xdf, 0xfb, 0x50, 0x52, 0xb5, 0xc6, 0x77, 0x58, 0x49, 0xa9, 0xf0, 0x6c, 0x1f, 0x47, 0x67,
-	0x48, 0xac, 0xc7, 0x7c, 0x71, 0x61, 0x8c, 0xa7, 0xab, 0xf5, 0xfa, 0x03, 0x20, 0xa7, 0x8e, 0x9f,
-	0x24, 0xe6, 0x8b, 0xad, 0x81, 0x18, 0x8d, 0xda, 0x38, 0x86, 0x55, 0x29, 0x25, 0x34, 0x8b, 0x20,
-	0x3e, 0x79, 0x99, 0x57, 0x08, 0xf9, 0xec, 0x82, 0x90, 0x37, 0x7e, 0xa3, 0x00, 0x45, 0x79, 0x29,
-	0x66, 0xda, 0x45, 0x8e, 0xe5, 0xf8, 0x45, 0x8e, 0xcd, 0xd8, 0xf5, 0x5e, 0x38, 0xf5, 0x62, 0xbf,
-	0x7f, 0x2f, 0xb9, 0x65, 0x6b, 0xb1, 0x8a, 0xd8, 0xb6, 0x2d, 0x62, 0x15, 0x85, 0x78, 0xac, 0x22,
-	0xed, 0x72, 0x4b, 0xae, 0x7a, 0x2e, 0x5c, 0x6e, 0x79, 0x0b, 0xb8, 0x1e, 0xa1, 0x25, 0xb7, 0x95,
-	0x10, 0xc0, 0xf6, 0x9c, 0xb8, 0xda, 0x51, 0x4a, 0xaa, 0x1d, 0xaf, 0xad, 0x12, 0x7c, 0x0c, 0x4b,
-	0xfc, 0x86, 0x13, 0x71, 0xca, 0x59, 0x6e, 0x1c, 0x62, 0xac, 0xe4, 0x7f, 0x7e, 0xe2, 0xc1, 0x14,
-	0xb4, 0xfa, 0x4d, 0x71, 0x95, 0xd8, 0x4d, 0x71, 0x7a, 0x0c, 0xa5, 0x1a, 0x8f, 0xa1, 0xdc, 0x83,
-	0x86, 0x1a, 0x38, 0xf4, 0x48, 0xba, 0x81, 0x38, 0x22, 0x59, 0x97, 0x70, 0x26, 0x0d, 0x7b, 0x41,
-	0xb4, 0xf1, 0xd5, 0x63, 0x1b, 0x1f, 0x93, 0x55, 0xad, 0x30, 0xa4, 0xd3, 0x59, 0x28, 0x37, 0x3e,
-	0xed, 0x3e, 0x51, 0x3e, 0xf3, 0xfc, 0x0c, 0x87, 0x9c, 0x5e, 0xce, 0x1d, 0x3b, 0x50, 0x3f, 0xb5,
-	0x9d, 0xc9, 0xdc, 0xa7, 0x96, 0x4f, 0xed, 0xc0, 0x73, 0x71, 0xf1, 0x47, 0x7b, 0xb0, 0x78, 0xc5,
-	0x3d, 0x4e, 0x63, 0x22, 0x89, 0x59, 0x3b, 0xd5, 0x1f, 0xf1, 0x24, 0x94, 0x3e, 0x12, 0x6c, 0xcb,
-	0x12, 0x87, 0xa5, 0x79, 0xae, 0x4a, 0xb7, 0x67, 0xed, 0x1d, 0x74, 0x9f, 0xec, 0x0f, 0x1b, 0x19,
-	0xf6, 0x38, 0x38, 0x6e, 0xb7, 0x3b, 0x9d, 0x5d, 0xdc, 0xc2, 0x00, 0x96, 0xf6, 0x5a, 0xdd, 0x03,
-	0xb1, 0x81, 0xe5, 0x1b, 0x05, 0xe3, 0x5f, 0x64, 0xa1, 0xa2, 0xbd, 0x0d, 0x79, 0xa4, 0x26, 0x81,
-	0xdf, 0x47, 0x76, 0x7b, 0xf1, 0x8d, 0xb7, 0xa5, 0x84, 0xd7, 0x66, 0x41, 0xdd, 0x1c, 0x9a, 0xbd,
-	0xf6, 0xe6, 0x50, 0xf2, 0x2e, 0x2c, 0xdb, 0xbc, 0x06, 0x35, 0xe8, 0xc2, 0xb9, 0x2f, 0xc0, 0x62,
-	0xcc, 0x31, 0x83, 0x34, 0xda, 0xa6, 0x18, 0x5d, 0x5e, 0x26, 0x6d, 0xaa, 0x9d, 0x0a, 0xe7, 0xa6,
-	0x28, 0x46, 0x46, 0x04, 0xe3, 0xd5, 0x86, 0x2f, 0xc6, 0x4b, 0xa2, 0xf9, 0xf1, 0x48, 0x8d, 0xc3,
-	0xab, 0xa6, 0x7a, 0x36, 0x3e, 0x01, 0x88, 0xde, 0x27, 0x3e, 0x7c, 0x37, 0xe2, 0xc3, 0x97, 0xd1,
-	0x86, 0x2f, 0x6b, 0xfc, 0x63, 0x21, 0xba, 0xc4, 0x5c, 0x28, 0x57, 0xdf, 0x0f, 0x40, 0x3a, 0x1f,
-	0x2d, 0x4c, 0xf2, 0x9e, 0x4d, 0x68, 0x28, 0x4f, 0x78, 0xae, 0x08, 0x4c, 0x57, 0x21, 0x16, 0x44,
-	0x6d, 0x76, 0x51, 0xd4, 0xbe, 0x05, 0x55, 0xbc, 0x17, 0x4b, 0x34, 0x24, 0xc4, 0x55, 0x65, 0x6a,
-	0x5f, 0xca, 0xb6, 0x63, 0x32, 0x36, 0x9f, 0x90, 0xb1, 0x7f, 0x37, 0xc3, 0x2f, 0x51, 0x89, 0x3a,
-	0x1a, 0x09, 0x59, 0x55, 0x67, 0x5c, 0xc8, 0x0a, 0x52, 0x53, 0xe1, 0xaf, 0x11, 0x9c, 0xd9, 0x74,
-	0xc1, 0x99, 0x2e, 0x92, 0x73, 0xa9, 0x22, 0xd9, 0xd8, 0x82, 0xe6, 0x2e, 0x65, 0x43, 0xd1, 0x9a,
-	0x4c, 0x12, 0x63, 0x69, 0xdc, 0x82, 0x9b, 0x29, 0x38, 0xe1, 0xb5, 0xf9, 0x12, 0xd6, 0x5b, 0xfc,
-	0x76, 0x89, 0xef, 0xea, 0x04, 0xa6, 0xd1, 0x84, 0x8d, 0x64, 0x95, 0xa2, 0xb1, 0x3d, 0x58, 0xd9,
-	0xa5, 0x27, 0xf3, 0xb3, 0x03, 0x7a, 0x11, 0x35, 0x44, 0x20, 0x1f, 0x9c, 0x7b, 0x2f, 0xc4, 0xe4,
-	0xe2, 0x6f, 0x4c, 0xcb, 0x64, 0x34, 0x56, 0x30, 0xa3, 0x23, 0xe9, 0xb9, 0x47, 0xc8, 0x60, 0x46,
-	0x47, 0xc6, 0x23, 0x20, 0x7a, 0x3d, 0x62, 0x26, 0x98, 0x59, 0x35, 0x3f, 0xb1, 0x82, 0xab, 0x20,
-	0xa4, 0x53, 0x79, 0xf2, 0x10, 0x82, 0xf9, 0xc9, 0x80, 0x43, 0x8c, 0xf7, 0xa0, 0x7a, 0x64, 0x5f,
-	0x99, 0xf4, 0x1b, 0x71, 0xc0, 0x6f, 0x13, 0x8a, 0x33, 0xfb, 0x8a, 0xc9, 0x53, 0x15, 0xc4, 0x43,
-	0xb4, 0xf1, 0x4f, 0xf3, 0xb0, 0xc4, 0x29, 0xc9, 0x5d, 0x7e, 0x2f, 0xb7, 0xe3, 0xa2, 0x3c, 0x93,
-	0x3b, 0x8b, 0x06, 0x5a, 0xd8, 0x7c, 0xb2, 0x8b, 0x9b, 0x8f, 0xf0, 0x38, 0xca, 0xcb, 0xb5, 0x64,
-	0xb8, 0xc5, 0x9d, 0x4f, 0xe5, 0x8d, 0x5a, 0xf1, 0x2b, 0x16, 0xf2, 0xd1, 0x7d, 0xee, 0xfc, 0x78,
-	0x79, 0x3c, 0x20, 0x1e, 0x19, 0x6f, 0xbc, 0x77, 0x72, 0x4f, 0x15, 0xfb, 0x8e, 0x0e, 0x4a, 0xb5,
-	0x10, 0x8b, 0xf2, 0xd4, 0x6a, 0xdc, 0x42, 0x5c, 0xb0, 0x04, 0x4b, 0xaf, 0xb6, 0x04, 0xb9, 0x2b,
-	0xf2, 0x25, 0x96, 0x20, 0xbc, 0x86, 0x25, 0xf8, 0x1a, 0xc1, 0xe8, 0x9b, 0x50, 0x42, 0x45, 0x49,
-	0xdb, 0x86, 0x98, 0x82, 0xc4, 0xb6, 0xa1, 0x4f, 0x35, 0x5b, 0x89, 0x67, 0xc2, 0x68, 0xfb, 0x80,
-	0x49, 0xbf, 0xf9, 0xc5, 0x04, 0xf9, 0xbe, 0x86, 0xa2, 0x80, 0x32, 0x86, 0x76, 0xed, 0xa9, 0xbc,
-	0xa6, 0x11, 0x7f, 0xb3, 0x61, 0xc3, 0x4b, 0xd5, 0xbe, 0x99, 0x3b, 0x3e, 0x1d, 0xcb, 0xab, 0x9d,
-	0x1c, 0x5c, 0xa3, 0x0c, 0xc2, 0x5e, 0x90, 0xd9, 0x6d, 0xae, 0xf7, 0xc2, 0x15, 0xb2, 0xa7, 0xe8,
-	0x04, 0x4f, 0xd9, 0xa3, 0x41, 0xa0, 0x81, 0x97, 0xba, 0xce, 0x3c, 0x5f, 0xee, 0xf2, 0xc6, 0xef,
-	0x66, 0xa0, 0x21, 0x56, 0x97, 0xc2, 0xe9, 0x66, 0x53, 0xe1, 0xba, 0xc4, 0x8d, 0x97, 0x5f, 0xd4,
-	0x64, 0x40, 0x0d, 0xbd, 0x45, 0x6a, 0xcb, 0xe7, 0xde, 0xae, 0x0a, 0x03, 0xee, 0x89, 0x6d, 0xff,
-	0x4d, 0xa8, 0xc8, 0xa4, 0xf1, 0xa9, 0x33, 0x91, 0x9f, 0x6e, 0xe0, 0x59, 0xe3, 0x87, 0xce, 0x44,
-	0x6a, 0x0c, 0xbe, 0x2d, 0x4e, 0x51, 0x67, 0x50, 0x63, 0x30, 0xed, 0x90, 0x1a, 0xff, 0x3c, 0x03,
-	0x2b, 0xda, 0xab, 0x88, 0x75, 0xfb, 0x23, 0xa8, 0xaa, 0xdb, 0x94, 0xa9, 0x52, 0x55, 0x37, 0xe3,
-	0x82, 0x26, 0x2a, 0x56, 0x19, 0x29, 0x48, 0xc0, 0x3a, 0x33, 0xb6, 0xaf, 0x78, 0x66, 0xf3, 0x7c,
-	0x2a, 0xad, 0xc1, 0xb1, 0x7d, 0xb5, 0x47, 0xe9, 0x60, 0x3e, 0x65, 0xb6, 0xfe, 0x0b, 0x4a, 0x9f,
-	0x2b, 0x02, 0x2e, 0x3e, 0x81, 0xc1, 0x04, 0x85, 0x01, 0xb5, 0xa9, 0xe7, 0x86, 0xe7, 0x8a, 0x44,
-	0xa8, 0xe9, 0x08, 0xe4, 0x34, 0xc6, 0x1f, 0x64, 0x61, 0x95, 0xfb, 0x24, 0x85, 0x2f, 0x58, 0x88,
-	0xae, 0x26, 0x2c, 0x71, 0xf7, 0x2c, 0x17, 0x5e, 0xfb, 0x37, 0x4c, 0xf1, 0x4c, 0x3e, 0x7e, 0x4d,
-	0x3f, 0xaa, 0x3c, 0xa8, 0x7d, 0xcd, 0xf0, 0xe7, 0x16, 0x87, 0xff, 0xfa, 0xe1, 0x4d, 0x8b, 0x0c,
-	0x17, 0xd2, 0x22, 0xc3, 0xaf, 0x13, 0x8f, 0x5d, 0x38, 0x52, 0x5c, 0x5c, 0xbc, 0x15, 0xf2, 0x11,
-	0x6c, 0xc6, 0x68, 0x50, 0x5a, 0x3b, 0xa7, 0x0e, 0x95, 0x57, 0xf3, 0xac, 0x69, 0xd4, 0x03, 0x89,
-	0xdb, 0x29, 0x42, 0x21, 0x18, 0x79, 0x33, 0x6a, 0x6c, 0xc0, 0x5a, 0x7c, 0x54, 0xc5, 0x36, 0xf1,
-	0x5b, 0x19, 0x68, 0x8a, 0x3c, 0x1e, 0xc7, 0x3d, 0xdb, 0x77, 0x82, 0xd0, 0xf3, 0xd5, 0xad, 0xc3,
-	0xb7, 0x01, 0xf8, 0x67, 0x24, 0xd0, 0xf8, 0x16, 0x97, 0xd1, 0x20, 0x04, 0x4d, 0xef, 0x9b, 0x50,
-	0xa2, 0xee, 0x98, 0x23, 0x39, 0x37, 0x14, 0xa9, 0x3b, 0x96, 0x86, 0xfb, 0xc2, 0x56, 0x5a, 0x8b,
-	0x2b, 0x09, 0xe2, 0x5a, 0x05, 0x36, 0x3a, 0xf4, 0x02, 0xb7, 0xf4, 0xbc, 0xba, 0x56, 0xe1, 0xd0,
-	0xbe, 0xc4, 0xac, 0xd8, 0xc0, 0xf8, 0x1b, 0x59, 0x58, 0x8e, 0xfa, 0xc7, 0x2f, 0x96, 0x79, 0xf9,
-	0x15, 0x39, 0x77, 0x05, 0x3b, 0x38, 0xcc, 0xe0, 0xd1, 0x3c, 0xb5, 0x25, 0xbe, 0x38, 0xbb, 0x2e,
-	0x31, 0xa0, 0x22, 0x29, 0xbc, 0x79, 0xa8, 0xdd, 0x64, 0x59, 0xe6, 0x24, 0xfd, 0x79, 0xc8, 0x2c,
-	0x54, 0x66, 0xaa, 0x3b, 0xae, 0xb0, 0x11, 0x0b, 0xf6, 0x34, 0xec, 0xe2, 0xb7, 0x4a, 0x18, 0x98,
-	0x15, 0xe3, 0x13, 0xc9, 0xa8, 0x18, 0x7d, 0x83, 0x1b, 0x2c, 0x7c, 0xe6, 0xd0, 0x58, 0xd1, 0xb5,
-	0x79, 0x7e, 0xbd, 0xba, 0xd2, 0xe6, 0xdf, 0x84, 0x0a, 0xaf, 0x3c, 0x3a, 0x41, 0x9e, 0x37, 0xcb,
-	0xd8, 0x02, 0xe2, 0x85, 0xd7, 0xcc, 0x9b, 0xc7, 0x7c, 0x05, 0xc0, 0x9b, 0xc2, 0x34, 0x99, 0xbf,
-	0x92, 0x81, 0x9b, 0x29, 0xd3, 0x26, 0x56, 0x79, 0x1b, 0x56, 0x4e, 0x15, 0x52, 0x8e, 0x2e, 0x5f,
-	0xea, 0x1b, 0x52, 0xac, 0xc6, 0xc7, 0xd4, 0x6c, 0x9c, 0xc6, 0x01, 0x91, 0x95, 0xca, 0x67, 0x30,
-	0x76, 0x3f, 0x01, 0xaa, 0x44, 0x7c, 0x1a, 0xb9, 0x81, 0x78, 0x04, 0x5b, 0x9d, 0x4b, 0x26, 0x31,
-	0x54, 0x6a, 0xed, 0xe8, 0xf9, 0x5c, 0x46, 0xaf, 0x12, 0x1e, 0xf9, 0xcc, 0x6b, 0x79, 0xe4, 0xc7,
-	0xfc, 0x2c, 0xb2, 0xaa, 0xeb, 0xe7, 0xa9, 0x04, 0x37, 0x50, 0x56, 0xe6, 0x04, 0xab, 0x90, 0x17,
-	0x15, 0x30, 0x10, 0xaf, 0xd4, 0x08, 0x60, 0xf9, 0x70, 0x3e, 0x09, 0x9d, 0xb6, 0x02, 0x91, 0x8f,
-	0x45, 0x19, 0x6c, 0x47, 0x8e, 0x5a, 0x6a, 0x43, 0xa0, 0x1a, 0xc2, 0xc1, 0x9a, 0xb2, 0x8a, 0xac,
-	0xc5, 0xf6, 0x96, 0xa7, 0xf1, 0x16, 0x8c, 0x9b, 0xb0, 0x19, 0x3d, 0xf1, 0x61, 0x93, 0x5b, 0xcd,
-	0xdf, 0xcb, 0xf0, 0x14, 0x7c, 0x8e, 0x1b, 0xb8, 0xf6, 0x2c, 0x38, 0xf7, 0x42, 0xd2, 0x81, 0xd5,
-	0xc0, 0x71, 0xcf, 0x26, 0x54, 0xaf, 0x3e, 0x10, 0x83, 0xb0, 0x1e, 0xef, 0x1b, 0x2f, 0x1a, 0x98,
-	0x2b, 0xbc, 0x44, 0x54, 0x5b, 0x40, 0x76, 0xae, 0xeb, 0x64, 0xc4, 0x16, 0x89, 0xd1, 0x58, 0xec,
-	0x7c, 0x17, 0xea, 0xf1, 0x86, 0xc8, 0xa7, 0xe2, 0x08, 0x7f, 0xd4, 0xab, 0x5c, 0xe2, 0x7c, 0x73,
-	0xc4, 0x10, 0x95, 0x68, 0xec, 0x03, 0xe3, 0xaf, 0x65, 0xa0, 0x69, 0x52, 0xc6, 0xb9, 0x5a, 0x2f,
-	0x25, 0xcf, 0xfc, 0x68, 0xa1, 0xd6, 0xeb, 0xdf, 0x55, 0xde, 0x0c, 0x20, 0x7b, 0xf4, 0xc1, 0xb5,
-	0x93, 0xb1, 0x7f, 0x63, 0xe1, 0x8d, 0x76, 0x4a, 0xb0, 0xc4, 0x49, 0x8c, 0x4d, 0x58, 0x17, 0xfd,
-	0x91, 0x7d, 0x89, 0xc2, 0xad, 0xb1, 0x16, 0x63, 0xe1, 0xd6, 0x2d, 0x68, 0xf2, 0xb3, 0xba, 0xfa,
-	0x4b, 0x88, 0x82, 0xbb, 0x40, 0x0e, 0xed, 0x91, 0xed, 0x7b, 0x9e, 0x7b, 0x44, 0x7d, 0x91, 0xd0,
-	0x8c, 0x1a, 0x26, 0x46, 0x23, 0xa5, 0x2a, 0xcc, 0x9f, 0xe4, 0xfd, 0xbd, 0x9e, 0x2b, 0xf3, 0xb7,
-	0xf8, 0x93, 0x61, 0xc2, 0xea, 0x8e, 0xfd, 0x9c, 0xca, 0x9a, 0xe4, 0x10, 0x3d, 0x86, 0xca, 0x4c,
-	0x55, 0x2a, 0xc7, 0x5d, 0xde, 0x53, 0xb2, 0xd8, 0xac, 0xa9, 0x53, 0x1b, 0x0f, 0x61, 0x2d, 0x5e,
-	0xa7, 0x10, 0x1d, 0x5b, 0x50, 0x9a, 0x0a, 0x98, 0xe8, 0x9d, 0x7a, 0x36, 0x7e, 0xb3, 0x04, 0x45,
-	0x61, 0xa9, 0x92, 0x6d, 0xc8, 0x8f, 0x64, 0x0e, 0x5d, 0x74, 0x87, 0x97, 0xc0, 0xca, 0xff, 0x6d,
-	0xcc, 0xa4, 0x63, 0x74, 0xe4, 0x31, 0xd4, 0xe3, 0x61, 0xe4, 0xc4, 0x4d, 0x00, 0xf1, 0xf8, 0x6f,
-	0x6d, 0x94, 0x08, 0x18, 0x96, 0xa3, 0xcd, 0x91, 0xeb, 0x0c, 0xa5, 0x73, 0x6d, 0xf7, 0xf4, 0x5c,
-	0xa6, 0x6f, 0x07, 0xe7, 0xb6, 0xf5, 0xf0, 0xd1, 0x27, 0xe2, 0x2a, 0x80, 0x0a, 0x02, 0x07, 0xe7,
-	0xf6, 0xc3, 0x47, 0x9f, 0x24, 0x35, 0x69, 0x71, 0x11, 0x80, 0xa6, 0x49, 0xaf, 0x41, 0x81, 0x5f,
-	0x52, 0xcb, 0x93, 0xa1, 0xf8, 0x03, 0x79, 0x00, 0x6b, 0xd2, 0xf9, 0x21, 0xd2, 0xd6, 0xb9, 0x14,
-	0x2c, 0xf1, 0x93, 0x82, 0x02, 0x37, 0x40, 0x14, 0x77, 0x97, 0x6c, 0xc0, 0xd2, 0x79, 0x74, 0xeb,
-	0x70, 0xcd, 0x14, 0x4f, 0xc6, 0x1f, 0x14, 0xa0, 0xa2, 0x0d, 0x0a, 0xa9, 0x42, 0xc9, 0xec, 0x0c,
-	0x3a, 0xe6, 0xb3, 0xce, 0x6e, 0xe3, 0x06, 0xb9, 0x07, 0xef, 0x74, 0x7b, 0xed, 0xbe, 0x69, 0x76,
-	0xda, 0x43, 0xab, 0x6f, 0x5a, 0xf2, 0x26, 0xb9, 0xa3, 0xd6, 0xd7, 0x87, 0x9d, 0xde, 0xd0, 0xda,
-	0xed, 0x0c, 0x5b, 0xdd, 0x83, 0x41, 0x23, 0x43, 0xde, 0x80, 0x66, 0x44, 0x29, 0xd1, 0xad, 0xc3,
-	0xfe, 0x71, 0x6f, 0xd8, 0xc8, 0x92, 0x3b, 0x70, 0x6b, 0xaf, 0xdb, 0x6b, 0x1d, 0x58, 0x11, 0x4d,
-	0xfb, 0x60, 0xf8, 0xcc, 0xea, 0xfc, 0xf2, 0x51, 0xd7, 0xfc, 0xba, 0x91, 0x4b, 0x23, 0xd8, 0x1f,
-	0x1e, 0xb4, 0x65, 0x0d, 0x79, 0x72, 0x13, 0xd6, 0x39, 0x01, 0x2f, 0x62, 0x0d, 0xfb, 0x7d, 0x6b,
-	0xd0, 0xef, 0xf7, 0x1a, 0x05, 0xb2, 0x02, 0xb5, 0x6e, 0xef, 0x59, 0xeb, 0xa0, 0xbb, 0x6b, 0x99,
-	0x9d, 0xd6, 0xc1, 0x61, 0x63, 0x89, 0xac, 0xc2, 0x72, 0x92, 0xae, 0xc8, 0xaa, 0x90, 0x74, 0xfd,
-	0x5e, 0xb7, 0xdf, 0xb3, 0x9e, 0x75, 0xcc, 0x41, 0xb7, 0xdf, 0x6b, 0x94, 0xc8, 0x06, 0x90, 0x38,
-	0x6a, 0xff, 0xb0, 0xd5, 0x6e, 0x94, 0xc9, 0x3a, 0xac, 0xc4, 0xe1, 0x4f, 0x3b, 0x5f, 0x37, 0x80,
-	0x34, 0x61, 0x8d, 0x77, 0xcc, 0xda, 0xe9, 0x1c, 0xf4, 0xbf, 0xb2, 0x0e, 0xbb, 0xbd, 0xee, 0xe1,
-	0xf1, 0x61, 0xa3, 0x82, 0x17, 0x54, 0x76, 0x3a, 0x56, 0xb7, 0x37, 0x38, 0xde, 0xdb, 0xeb, 0xb6,
-	0xbb, 0x9d, 0xde, 0xb0, 0x51, 0xe5, 0x2d, 0xa7, 0xbd, 0x78, 0x8d, 0x15, 0x10, 0x67, 0x5b, 0xac,
-	0xdd, 0xee, 0xa0, 0xb5, 0x73, 0xd0, 0xd9, 0x6d, 0xd4, 0xc9, 0x6d, 0xb8, 0x39, 0xec, 0x1c, 0x1e,
-	0xf5, 0xcd, 0x96, 0xf9, 0xb5, 0x3c, 0xfb, 0x62, 0xed, 0xb5, 0xba, 0x07, 0xc7, 0x66, 0xa7, 0xb1,
-	0x4c, 0xde, 0x82, 0xdb, 0x66, 0xe7, 0xcb, 0xe3, 0xae, 0xd9, 0xd9, 0xb5, 0x7a, 0xfd, 0xdd, 0x8e,
-	0xb5, 0xd7, 0x69, 0x0d, 0x8f, 0xcd, 0x8e, 0x75, 0xd8, 0x1d, 0x0c, 0xba, 0xbd, 0x27, 0x8d, 0x06,
-	0x79, 0x07, 0xee, 0x2a, 0x12, 0x55, 0x41, 0x82, 0x6a, 0x85, 0xbd, 0x9f, 0x9c, 0xd2, 0x5e, 0xe7,
-	0x97, 0x87, 0xd6, 0x51, 0xa7, 0x63, 0x36, 0x08, 0xd9, 0x82, 0x8d, 0xa8, 0x79, 0xde, 0x80, 0x68,
-	0x7b, 0x95, 0xe1, 0x8e, 0x3a, 0xe6, 0x61, 0xab, 0xc7, 0x26, 0x38, 0x86, 0x5b, 0x63, 0xdd, 0x8e,
-	0x70, 0xc9, 0x6e, 0xaf, 0x13, 0x02, 0x75, 0x6d, 0x56, 0xf6, 0x5a, 0x66, 0x63, 0x83, 0x2c, 0x43,
-	0xe5, 0xf0, 0xe8, 0xc8, 0x1a, 0x76, 0x0f, 0x3b, 0xfd, 0xe3, 0x61, 0x63, 0x93, 0xac, 0x43, 0xa3,
-	0xdb, 0x1b, 0x76, 0x4c, 0x36, 0xd7, 0xb2, 0xe8, 0x7f, 0x2f, 0x92, 0x35, 0x58, 0x96, 0x3d, 0x95,
-	0xd0, 0x3f, 0x2e, 0x92, 0x4d, 0x20, 0xc7, 0x3d, 0xb3, 0xd3, 0xda, 0x65, 0x03, 0xa7, 0x10, 0xff,
-	0xa3, 0x28, 0x42, 0x4a, 0xbf, 0x9b, 0x53, 0x9b, 0x75, 0x94, 0xa3, 0x11, 0xbf, 0x8a, 0xbf, 0xaa,
-	0x5d, 0xa1, 0xff, 0xaa, 0x0f, 0xea, 0x68, 0xa6, 0x55, 0x6e, 0xc1, 0xb4, 0x5a, 0xb0, 0xdd, 0x6b,
-	0xba, 0xee, 0xf7, 0x36, 0xd4, 0xa6, 0xfc, 0x5a, 0x7e, 0x71, 0xe7, 0x34, 0x88, 0x84, 0x25, 0x0e,
-	0xe4, 0x17, 0x4e, 0x2f, 0x7c, 0x51, 0xa6, 0xb0, 0xf8, 0x45, 0x99, 0x34, 0xfd, 0x7e, 0x29, 0x4d,
-	0xbf, 0xbf, 0x0f, 0x2b, 0x5c, 0x34, 0x39, 0xae, 0x33, 0x95, 0x56, 0x33, 0xd7, 0x02, 0x97, 0x51,
-	0x44, 0x71, 0xb8, 0x34, 0x27, 0xa4, 0xc9, 0x21, 0x44, 0x48, 0x51, 0x58, 0x1b, 0x31, 0x4b, 0x83,
-	0x4b, 0x0e, 0x65, 0x69, 0xa8, 0x16, 0xec, 0xcb, 0xa8, 0x85, 0x8a, 0xd6, 0x02, 0x87, 0x63, 0x0b,
-	0xf7, 0x61, 0x85, 0x5e, 0x86, 0xbe, 0x6d, 0x79, 0x33, 0xfb, 0x9b, 0x39, 0xc6, 0xbc, 0x6d, 0xb4,
-	0xe1, 0xab, 0xe6, 0x32, 0x22, 0xfa, 0x08, 0xdf, 0xb5, 0x43, 0xfb, 0xfe, 0x9f, 0x87, 0x8a, 0xf6,
-	0xc9, 0x06, 0xb2, 0x09, 0xab, 0x5f, 0x75, 0x87, 0xbd, 0xce, 0x60, 0x60, 0x1d, 0x1d, 0xef, 0x3c,
-	0xed, 0x7c, 0x6d, 0xed, 0xb7, 0x06, 0xfb, 0x8d, 0x1b, 0x6c, 0xd1, 0xf6, 0x3a, 0x83, 0x61, 0x67,
-	0x37, 0x06, 0xcf, 0x90, 0x37, 0x61, 0xeb, 0xb8, 0x77, 0x3c, 0xe8, 0xec, 0x5a, 0x69, 0xe5, 0xb2,
-	0x8c, 0x4b, 0x05, 0x3e, 0xa5, 0x78, 0xee, 0xfe, 0xaf, 0x41, 0x3d, 0x7e, 0x0c, 0x9c, 0x00, 0x2c,
-	0x1d, 0x74, 0x9e, 0xb4, 0xda, 0x5f, 0xf3, 0x2b, 0x6c, 0x07, 0xc3, 0xd6, 0xb0, 0xdb, 0xb6, 0xc4,
-	0x95, 0xb5, 0x4c, 0x22, 0x64, 0x48, 0x05, 0x8a, 0xad, 0x5e, 0x7b, 0xbf, 0x6f, 0x0e, 0x1a, 0x59,
-	0xf2, 0x06, 0x6c, 0x4a, 0x5e, 0x6d, 0xf7, 0x0f, 0x0f, 0xbb, 0x43, 0x14, 0x86, 0xc3, 0xaf, 0x8f,
-	0x18, 0x6b, 0xde, 0xb7, 0xa1, 0x1c, 0xdd, 0xb9, 0x8b, 0x02, 0xa6, 0x3b, 0xec, 0xb6, 0x86, 0x91,
-	0x74, 0x6d, 0xdc, 0x60, 0xf2, 0x2b, 0x02, 0xe3, 0x95, 0xb9, 0x8d, 0x0c, 0x3f, 0x29, 0x27, 0x81,
-	0xbc, 0xf5, 0x46, 0x96, 0x2d, 0xaa, 0x08, 0xba, 0xd3, 0x1f, 0xb2, 0x57, 0xf8, 0x1c, 0xea, 0xf1,
-	0x7c, 0xc8, 0xb8, 0x63, 0x7b, 0x0b, 0x36, 0x76, 0x3a, 0xc3, 0xaf, 0x3a, 0x9d, 0x1e, 0x8e, 0x4e,
-	0xbb, 0xd3, 0x1b, 0x9a, 0xad, 0x83, 0xee, 0xf0, 0xeb, 0x46, 0xe6, 0xfe, 0x63, 0x68, 0x24, 0x83,
-	0x8f, 0xb1, 0x68, 0xed, 0xcb, 0xc2, 0xba, 0xf7, 0xff, 0x4b, 0x06, 0xd6, 0xd2, 0xfc, 0xee, 0x6c,
-	0x0e, 0xc5, 0xe2, 0x64, 0x22, 0x7a, 0xd0, 0xef, 0x59, 0xbd, 0x3e, 0xde, 0x91, 0xb9, 0x05, 0x1b,
-	0x09, 0x84, 0x94, 0x04, 0x19, 0x72, 0x0b, 0x36, 0x17, 0x0a, 0x59, 0x66, 0xff, 0x18, 0x5f, 0xbb,
-	0x09, 0x6b, 0x09, 0x64, 0xc7, 0x34, 0xfb, 0x66, 0x23, 0x47, 0x3e, 0x80, 0x7b, 0x09, 0xcc, 0xe2,
-	0xc6, 0x24, 0xf7, 0xad, 0x3c, 0x79, 0x0f, 0xde, 0x5e, 0xa0, 0x8e, 0x64, 0xb7, 0xb5, 0xd3, 0x3a,
-	0x60, 0xaf, 0xd7, 0x28, 0xdc, 0xff, 0x47, 0x39, 0x80, 0xe8, 0xc0, 0x11, 0x6b, 0x7f, 0xb7, 0x35,
-	0x6c, 0x1d, 0xf4, 0x19, 0x7b, 0x99, 0xfd, 0x21, 0xab, 0xdd, 0xec, 0x7c, 0xd9, 0xb8, 0x91, 0x8a,
-	0xe9, 0x1f, 0xb1, 0x17, 0xda, 0x84, 0x55, 0x3e, 0x55, 0x07, 0xec, 0x35, 0xba, 0xbd, 0x27, 0xfc,
-	0xba, 0x55, 0xdc, 0xfd, 0x8e, 0x8f, 0xf6, 0xcc, 0x7e, 0x6f, 0x68, 0x0d, 0xf6, 0x8f, 0x87, 0xbb,
-	0x78, 0x59, 0x6b, 0xdb, 0xec, 0x1e, 0xf1, 0x3a, 0xf3, 0x2f, 0x23, 0x60, 0x55, 0x17, 0xd8, 0x5a,
-	0x78, 0xd2, 0x1f, 0x0c, 0xba, 0x47, 0xd6, 0x97, 0xc7, 0x1d, 0xb3, 0xdb, 0x19, 0x60, 0xc1, 0xa5,
-	0x14, 0x38, 0xa3, 0x2f, 0xb2, 0x3d, 0x73, 0x78, 0xf0, 0x4c, 0x6c, 0x6a, 0x8c, 0xb4, 0x14, 0x07,
-	0x31, 0xaa, 0x32, 0x9b, 0x1d, 0xb6, 0x2b, 0xa4, 0xd4, 0x0c, 0xd7, 0xe0, 0x58, 0xb9, 0x0a, 0xdb,
-	0xef, 0x16, 0x16, 0x09, 0x16, 0xab, 0xa6, 0xa3, 0x58, 0x29, 0xdc, 0x0a, 0x95, 0xe2, 0xb0, 0xbb,
-	0x6b, 0x62, 0x81, 0xfa, 0x02, 0x94, 0xd1, 0x2e, 0x33, 0x26, 0x64, 0xdb, 0x06, 0x23, 0x69, 0xc8,
-	0x07, 0x86, 0x59, 0x79, 0xf8, 0xef, 0xef, 0x40, 0x59, 0x25, 0x1e, 0x93, 0x9f, 0x42, 0x2d, 0x76,
-	0x12, 0x94, 0x48, 0xb7, 0x60, 0xda, 0xc1, 0xd1, 0xad, 0x37, 0xd2, 0x91, 0x42, 0x03, 0x3d, 0xd4,
-	0x2c, 0x0c, 0x5e, 0xd9, 0x1b, 0x49, 0xad, 0x3f, 0x56, 0xdb, 0xed, 0x6b, 0xb0, 0xa2, 0xba, 0xa7,
-	0x78, 0xf3, 0xab, 0xfe, 0x91, 0x4c, 0x72, 0x3b, 0xba, 0x86, 0x33, 0xe5, 0xe3, 0x99, 0x5b, 0x37,
-	0x17, 0x3f, 0x67, 0x29, 0xbf, 0x7f, 0xb9, 0x0b, 0x15, 0xed, 0xdb, 0x4f, 0xe4, 0xe6, 0xb5, 0xdf,
-	0xa9, 0xda, 0xda, 0x4a, 0x43, 0x89, 0x2e, 0x7d, 0x01, 0x65, 0xf5, 0x1d, 0x20, 0xb2, 0xa9, 0x7d,
-	0xc3, 0x49, 0xff, 0x9a, 0xd1, 0x56, 0x73, 0x11, 0x21, 0xca, 0xef, 0x42, 0x45, 0xfb, 0x9c, 0x8f,
-	0xea, 0xc5, 0xe2, 0x27, 0x83, 0x54, 0x2f, 0xd2, 0xbe, 0xfe, 0x73, 0x00, 0xeb, 0xc2, 0x8e, 0x39,
-	0xa1, 0xdf, 0x66, 0x78, 0x52, 0xbe, 0xf6, 0xf9, 0x20, 0x43, 0x1e, 0x43, 0x49, 0x7e, 0xb8, 0x89,
-	0x6c, 0xa4, 0x7f, 0x96, 0x6a, 0x6b, 0x73, 0x01, 0x2e, 0xba, 0xd2, 0x02, 0x88, 0x3e, 0x14, 0x44,
-	0xe4, 0x8b, 0x2f, 0x7c, 0x78, 0x48, 0xcd, 0x4c, 0xca, 0x57, 0x85, 0x76, 0xa1, 0xa2, 0x7d, 0x13,
-	0x48, 0x8d, 0xc9, 0xe2, 0xf7, 0x84, 0xd4, 0x98, 0xa4, 0x7d, 0x42, 0xe8, 0xa7, 0x50, 0x8b, 0x7d,
-	0xdc, 0x47, 0xf1, 0x71, 0xda, 0xa7, 0x83, 0x14, 0x1f, 0xa7, 0x7f, 0x0f, 0x68, 0x17, 0x2a, 0xda,
-	0xa7, 0x78, 0x54, 0x8f, 0x16, 0xbf, 0xfa, 0xa3, 0x7a, 0x94, 0xf2, 0xe5, 0x1e, 0xb6, 0x1a, 0xe2,
-	0xdf, 0xe1, 0x51, 0xab, 0x21, 0xf5, 0x83, 0x3e, 0x6a, 0x35, 0xa4, 0x7f, 0xbc, 0x87, 0xb1, 0x9e,
-	0xba, 0xf2, 0x99, 0x6c, 0x6a, 0xdc, 0xa1, 0xdf, 0x1d, 0xad, 0x58, 0x6f, 0xf1, 0x76, 0xe8, 0x27,
-	0xb0, 0xaa, 0x98, 0x46, 0x5d, 0xd8, 0x1c, 0xa8, 0x3e, 0xa5, 0x5e, 0x0b, 0xbd, 0xd5, 0x48, 0x62,
-	0x1f, 0x64, 0xc8, 0x67, 0x50, 0x14, 0xb7, 0xe0, 0x92, 0xf5, 0xe4, 0xad, 0xb8, 0xbc, 0x13, 0x1b,
-	0xe9, 0x97, 0xe5, 0x92, 0x23, 0x5c, 0xd0, 0xfa, 0x35, 0xb5, 0x3a, 0xc7, 0xa6, 0xdc, 0x6c, 0xbb,
-	0xf5, 0xe6, 0x75, 0xe8, 0xa8, 0xc6, 0xe4, 0xd5, 0xca, 0xb7, 0xaf, 0xbb, 0xa1, 0x21, 0x5e, 0xe3,
-	0x75, 0x57, 0x49, 0x3d, 0x81, 0xaa, 0xfe, 0x15, 0x08, 0xa2, 0xaf, 0xc3, 0x64, 0x5d, 0xb7, 0x52,
-	0x71, 0xa2, 0xa2, 0x67, 0xb0, 0xa1, 0xc6, 0x5b, 0xbf, 0x2e, 0x20, 0x20, 0x77, 0x52, 0x2e, 0x11,
-	0x88, 0x8d, 0xfa, 0xcd, 0x6b, 0x6f, 0x19, 0x78, 0x90, 0x41, 0x21, 0x1b, 0xbb, 0xdb, 0x3e, 0x12,
-	0xb2, 0x69, 0x57, 0xfa, 0x47, 0x42, 0x36, 0xfd, 0x42, 0xfc, 0x16, 0x2c, 0x6b, 0xd7, 0x1d, 0x0c,
-	0xae, 0xdc, 0x91, 0xe2, 0xf7, 0xc5, 0xfb, 0x43, 0xb7, 0xd2, 0xbc, 0x69, 0xa4, 0x0d, 0x15, 0xfd,
-	0xc6, 0x84, 0x97, 0x14, 0xdf, 0xd4, 0x50, 0xfa, 0x65, 0x92, 0x0f, 0x32, 0xe4, 0x00, 0x1a, 0xc9,
-	0xfb, 0xcd, 0xd4, 0x12, 0x4e, 0xbb, 0x13, 0x6e, 0x2b, 0x81, 0x8c, 0xdd, 0x8a, 0xc6, 0xf8, 0x22,
-	0xf6, 0x55, 0x49, 0xcf, 0x4f, 0x6e, 0x45, 0xf1, 0xaf, 0x4d, 0xaa, 0xda, 0xd2, 0xbe, 0x33, 0x7a,
-	0x2f, 0xf3, 0x20, 0x43, 0xf6, 0xa0, 0x1a, 0xbb, 0xde, 0x27, 0x96, 0x03, 0x9f, 0x78, 0xcd, 0xa6,
-	0x8e, 0x4b, 0xbc, 0xe7, 0x21, 0xd4, 0xe3, 0x61, 0x5f, 0xd5, 0xb1, 0xd4, 0x00, 0xb3, 0x9a, 0xbe,
-	0xf4, 0x58, 0x31, 0xf9, 0x31, 0xff, 0x66, 0xb2, 0x4c, 0xf1, 0x21, 0x8b, 0xdf, 0xd8, 0x55, 0x73,
-	0xa6, 0x7f, 0x91, 0xd6, 0xc8, 0xfd, 0xe5, 0x6c, 0x06, 0xdf, 0xeb, 0x47, 0xfc, 0x8b, 0x85, 0x32,
-	0xcb, 0x83, 0xcd, 0xff, 0xeb, 0x56, 0x42, 0xf6, 0x78, 0xe3, 0xe2, 0x7b, 0xb1, 0x91, 0xe4, 0x5e,
-	0xf8, 0x86, 0xec, 0x2b, 0xfa, 0xd0, 0xe2, 0x7d, 0x10, 0x65, 0x62, 0x3c, 0xf8, 0x9a, 0x75, 0x91,
-	0x4f, 0x01, 0xa2, 0xd4, 0x39, 0x92, 0x48, 0xe0, 0x52, 0x0b, 0x2a, 0x25, 0xbb, 0xae, 0xc3, 0xd7,
-	0xbb, 0xca, 0x20, 0xd3, 0xb7, 0xe4, 0x78, 0x32, 0x5b, 0x6c, 0x4b, 0x4e, 0x56, 0xf3, 0x43, 0xa8,
-	0x1d, 0x78, 0xde, 0xf3, 0xf9, 0x4c, 0xe5, 0x5f, 0xc7, 0xd3, 0x1b, 0x98, 0x79, 0xbc, 0x95, 0xe8,
-	0x16, 0x69, 0xc1, 0x8a, 0x12, 0x11, 0x51, 0x0a, 0x5b, 0x9c, 0x28, 0x26, 0x18, 0x12, 0x15, 0x3c,
-	0xc8, 0x90, 0x87, 0x50, 0xdd, 0xa5, 0x23, 0x3c, 0x7e, 0x8f, 0x81, 0xf8, 0xd5, 0x58, 0x50, 0x97,
-	0x47, 0xf0, 0xb7, 0x6a, 0x31, 0xa0, 0x14, 0x71, 0x51, 0x42, 0x87, 0xbe, 0x67, 0xc4, 0xb3, 0x22,
-	0x62, 0x22, 0x6e, 0x21, 0xa9, 0xe3, 0x19, 0xac, 0x2c, 0xa4, 0x4c, 0x28, 0xe9, 0x76, 0x5d, 0xa2,
-	0xc5, 0xd6, 0xdd, 0xeb, 0x09, 0x44, 0xbd, 0x3f, 0x81, 0x1a, 0xbf, 0x5b, 0xf4, 0x84, 0xf2, 0xe3,
-	0x73, 0x89, 0xbb, 0x67, 0xf4, 0xb3, 0x79, 0x49, 0x91, 0xc4, 0x0b, 0x3c, 0xc1, 0xef, 0x08, 0x68,
-	0x87, 0xd3, 0xd4, 0xbc, 0x2e, 0x1e, 0x98, 0x53, 0xf3, 0x9a, 0x76, 0x0e, 0xee, 0x73, 0xa8, 0x3c,
-	0xa1, 0xa1, 0x3c, 0xee, 0xa5, 0xf4, 0xa3, 0xc4, 0xf9, 0xaf, 0xad, 0x94, 0x43, 0x7a, 0xe4, 0x13,
-	0x2c, 0xaa, 0x8e, 0x2e, 0x6f, 0x68, 0xad, 0xe8, 0x45, 0x97, 0x13, 0x70, 0xa6, 0x7d, 0x68, 0x17,
-	0x18, 0xa8, 0x8e, 0x2f, 0x5e, 0x58, 0xa1, 0x3a, 0x9e, 0x76, 0xdf, 0xc1, 0x8f, 0xf9, 0x08, 0x68,
-	0x07, 0xcc, 0x22, 0x15, 0x2c, 0x79, 0x16, 0x4d, 0x75, 0x5f, 0x27, 0x7f, 0x04, 0x30, 0x08, 0xbd,
-	0xd9, 0xae, 0x4d, 0xa7, 0x9e, 0x1b, 0xc9, 0x84, 0xe8, 0x68, 0x53, 0xb4, 0x10, 0xb5, 0xf3, 0x4d,
-	0xe4, 0x2b, 0x4d, 0x37, 0x8d, 0x4d, 0x89, 0x9c, 0xf6, 0x6b, 0x4f, 0x3f, 0xa9, 0xd7, 0x49, 0x39,
-	0x01, 0x85, 0x42, 0x02, 0xa2, 0x6c, 0x16, 0xa5, 0x69, 0x2e, 0x24, 0xca, 0xa8, 0xb5, 0x9e, 0x92,
-	0xfa, 0xf2, 0x05, 0x94, 0xa3, 0x34, 0x80, 0xcd, 0xe8, 0x36, 0x95, 0x58, 0xd2, 0x80, 0x92, 0xde,
-	0x8b, 0x21, 0xf8, 0x1e, 0xac, 0xf2, 0xee, 0xa8, 0xed, 0x0f, 0x0f, 0xe0, 0xa8, 0xcf, 0x60, 0x2c,
-	0xc6, 0xbe, 0xd5, 0xfa, 0x49, 0x8b, 0xe0, 0xb2, 0xf5, 0xb3, 0x10, 0x09, 0x54, 0xeb, 0xe7, 0xba,
-	0xd0, 0xae, 0x5a, 0x3f, 0xd7, 0x07, 0x11, 0x7b, 0xb0, 0x9a, 0x12, 0xd3, 0x23, 0x6f, 0x49, 0xc3,
-	0xe6, 0xda, 0x78, 0xdf, 0x56, 0x6a, 0xec, 0x87, 0x0c, 0x61, 0x93, 0x97, 0x69, 0x4d, 0x26, 0x89,
-	0x10, 0xd2, 0x9b, 0x5a, 0x81, 0x94, 0xb0, 0x58, 0x4c, 0x95, 0x49, 0x84, 0xc6, 0x7a, 0xd0, 0x48,
-	0x46, 0x5f, 0xc8, 0xf5, 0xe4, 0x5b, 0x77, 0x62, 0x2a, 0xfb, 0x62, 0xc4, 0x86, 0x3c, 0x53, 0x31,
-	0xa0, 0x44, 0x1f, 0xef, 0xa8, 0x2b, 0xa2, 0xd3, 0x23, 0x56, 0xca, 0x1a, 0x48, 0x0d, 0x21, 0x91,
-	0x5f, 0x86, 0xcd, 0x24, 0x47, 0xcb, 0x9a, 0xef, 0xa6, 0x0d, 0xd7, 0xb5, 0xaa, 0x5c, 0xfc, 0x85,
-	0x1e, 0x64, 0x98, 0x20, 0xd6, 0x23, 0x39, 0x8a, 0x91, 0x52, 0x42, 0x46, 0x8a, 0x91, 0xd2, 0x42,
-	0x3f, 0x3b, 0xef, 0xfd, 0xca, 0xf7, 0xce, 0x9c, 0xf0, 0x7c, 0x7e, 0xb2, 0x3d, 0xf2, 0xa6, 0x1f,
-	0x4e, 0xa4, 0x71, 0x2f, 0x8e, 0x65, 0x7e, 0x38, 0x71, 0xc7, 0x1f, 0x62, 0xe9, 0x93, 0xa5, 0x99,
-	0xef, 0x85, 0xde, 0x0f, 0xff, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x32, 0xcd, 0x68, 0x3f, 0xc4,
-	0x84, 0x00, 0x00,
+	// 11624 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0xbd, 0x4b, 0x6c, 0x23, 0x49,
+	0x9a, 0x18, 0x5c, 0x7c, 0x89, 0xe4, 0x47, 0x52, 0x4a, 0x85, 0x5e, 0x2c, 0x55, 0x57, 0x57, 0x75,
+	0x76, 0x4f, 0x77, 0x4d, 0x75, 0x8f, 0xba, 0xba, 0x66, 0xfa, 0x35, 0xfd, 0xef, 0xcc, 0x50, 0x14,
+	0x55, 0xe2, 0x94, 0x44, 0x6a, 0x92, 0x54, 0xf7, 0xf6, 0x62, 0xff, 0xcd, 0x4d, 0x91, 0x21, 0x29,
+	0x5d, 0x64, 0x26, 0x3b, 0x33, 0xa9, 0x92, 0xc6, 0xf0, 0x6d, 0xfd, 0xc0, 0xc2, 0x36, 0x60, 0xc0,
+	0x6b, 0xc0, 0x8f, 0x85, 0x5f, 0xb0, 0x7d, 0x5b, 0x18, 0x9e, 0xb5, 0x4f, 0x3e, 0x7b, 0x01, 0xc3,
+	0x86, 0x6d, 0x78, 0x0d, 0x3f, 0xb0, 0x58, 0xc0, 0x07, 0xaf, 0x0f, 0x06, 0x8c, 0x05, 0x7c, 0xf2,
+	0xc1, 0x80, 0x11, 0xf1, 0x45, 0x44, 0x46, 0x26, 0x53, 0x55, 0xd5, 0xb3, 0xed, 0xb9, 0x48, 0x8c,
+	0x2f, 0xbe, 0x78, 0x7f, 0xf1, 0xc5, 0xf7, 0x8a, 0x48, 0xa8, 0x06, 0xb3, 0xd1, 0xce, 0x2c, 0xf0,
+	0x23, 0x9f, 0x94, 0x26, 0x5e, 0x30, 0x1b, 0x99, 0x7f, 0x94, 0x83, 0xe2, 0x49, 0x74, 0xe5, 0x93,
+	0x0f, 0xa1, 0xee, 0x8c, 0xc7, 0x01, 0x0d, 0x43, 0x3b, 0xba, 0x9e, 0xd1, 0x66, 0xee, 0x7e, 0xee,
+	0xc1, 0xf2, 0x63, 0xb2, 0xc3, 0xd1, 0x76, 0x5a, 0x98, 0x35, 0xbc, 0x9e, 0x51, 0xab, 0xe6, 0xc4,
+	0x09, 0xd2, 0x84, 0xb2, 0x48, 0x36, 0xf3, 0xf7, 0x73, 0x0f, 0xaa, 0x96, 0x4c, 0x92, 0xbb, 0x00,
+	0xce, 0xd4, 0x9f, 0x7b, 0x91, 0x1d, 0x3a, 0x51, 0xb3, 0x70, 0x3f, 0xf7, 0xa0, 0x60, 0x55, 0x11,
+	0x32, 0x70, 0x22, 0x72, 0x07, 0xaa, 0xb3, 0x67, 0x76, 0x38, 0x0a, 0xdc, 0x59, 0xd4, 0x2c, 0xf2,
+	0xa2, 0x95, 0xd9, 0xb3, 0x01, 0x4f, 0x93, 0x77, 0xa1, 0xe2, 0xcf, 0xa3, 0x99, 0xef, 0x7a, 0x51,
+	0xb3, 0x74, 0x3f, 0xf7, 0xa0, 0xf6, 0x78, 0x45, 0x74, 0xa4, 0x3f, 0x8f, 0x8e, 0x19, 0xd8, 0x52,
+	0x08, 0xe4, 0x2d, 0x68, 0x8c, 0x7c, 0xef, 0xcc, 0x0d, 0xa6, 0x4e, 0xe4, 0xfa, 0x5e, 0xd8, 0x5c,
+	0xe2, 0x6d, 0x25, 0x81, 0xe6, 0xbf, 0xc8, 0x43, 0x6d, 0x18, 0x38, 0x5e, 0xe8, 0x8c, 0x18, 0x80,
+	0x6c, 0x41, 0x39, 0xba, 0xb2, 0x2f, 0x9c, 0xf0, 0x82, 0x0f, 0xb5, 0x6a, 0x2d, 0x45, 0x57, 0x07,
+	0x4e, 0x78, 0x41, 0x36, 0x61, 0x09, 0x7b, 0xc9, 0x07, 0x54, 0xb0, 0x44, 0x8a, 0xbc, 0x0b, 0xab,
+	0xde, 0x7c, 0x6a, 0x27, 0x9b, 0x62, 0xc3, 0x2a, 0x59, 0x86, 0x37, 0x9f, 0xb6, 0x75, 0x38, 0x1b,
+	0xfc, 0xe9, 0xc4, 0x1f, 0x3d, 0xc3, 0x06, 0x70, 0x78, 0x55, 0x0e, 0xe1, 0x6d, 0xbc, 0x01, 0x75,
+	0x91, 0x4d, 0xdd, 0xf3, 0x0b, 0x1c, 0x63, 0xc9, 0xaa, 0x21, 0x02, 0x07, 0xb1, 0x1a, 0x22, 0x77,
+	0x4a, 0xed, 0x30, 0x72, 0xa6, 0x33, 0x31, 0xa4, 0x2a, 0x83, 0x0c, 0x18, 0x80, 0x67, 0xfb, 0x91,
+	0x33, 0xb1, 0xcf, 0x28, 0x0d, 0x9b, 0x65, 0x91, 0xcd, 0x20, 0xfb, 0x94, 0x86, 0xe4, 0x5b, 0xb0,
+	0x3c, 0xa6, 0x61, 0x64, 0x8b, 0xc5, 0xa0, 0x61, 0xb3, 0x72, 0xbf, 0xf0, 0xa0, 0x6a, 0x35, 0x18,
+	0xb4, 0x25, 0x81, 0xe4, 0x35, 0x80, 0xc0, 0x79, 0x6e, 0xb3, 0x89, 0xa0, 0x57, 0xcd, 0x2a, 0xae,
+	0x42, 0xe0, 0x3c, 0x1f, 0x5e, 0x1d, 0xd0, 0x2b, 0xb2, 0x0e, 0xa5, 0x89, 0x73, 0x4a, 0x27, 0x4d,
+	0xe0, 0x19, 0x98, 0x30, 0x7f, 0x05, 0x36, 0x9f, 0xd0, 0x48, 0x9b, 0xca, 0xd0, 0xa2, 0x5f, 0xcd,
+	0x69, 0x18, 0xb1, 0x51, 0x85, 0x91, 0x13, 0x44, 0x72, 0x54, 0x39, 0x1c, 0x15, 0x87, 0xc5, 0xa3,
+	0xa2, 0xde, 0x58, 0x22, 0xe4, 0x39, 0x42, 0x95, 0x7a, 0x63, 0xcc, 0x36, 0x0f, 0x81, 0x68, 0x15,
+	0xef, 0xd1, 0xc8, 0x71, 0x27, 0x21, 0xf9, 0x08, 0xea, 0x91, 0xd6, 0x5c, 0x33, 0x77, 0xbf, 0xf0,
+	0xa0, 0xa6, 0x48, 0x53, 0x2b, 0x60, 0x25, 0xf0, 0xcc, 0x0b, 0xa8, 0xec, 0x53, 0x7a, 0xe8, 0x4e,
+	0xdd, 0x88, 0x6c, 0x42, 0xe9, 0xcc, 0xbd, 0xa2, 0x63, 0xde, 0xa9, 0xc2, 0xc1, 0x2d, 0x0b, 0x93,
+	0xe4, 0x1e, 0x00, 0xff, 0x61, 0x4f, 0x15, 0x95, 0x1e, 0xdc, 0xb2, 0xaa, 0x1c, 0x76, 0x14, 0x3a,
+	0x11, 0xd9, 0x86, 0xf2, 0x8c, 0x06, 0x23, 0x2a, 0xe9, 0xe1, 0xe0, 0x96, 0x25, 0x01, 0xbb, 0x65,
+	0x28, 0x4d, 0x58, 0xed, 0xe6, 0xef, 0x95, 0xa0, 0x36, 0xa0, 0xde, 0x58, 0xce, 0x04, 0x81, 0x22,
+	0x9b, 0x68, 0xde, 0x58, 0xdd, 0xe2, 0xbf, 0xc9, 0x9b, 0x50, 0xe3, 0x4b, 0x12, 0x46, 0x81, 0xeb,
+	0x9d, 0xe3, 0x6e, 0xd9, 0xcd, 0x37, 0x73, 0x16, 0x30, 0xf0, 0x80, 0x43, 0x89, 0x01, 0x05, 0x67,
+	0x2a, 0x77, 0x0b, 0xfb, 0x49, 0x6e, 0x43, 0xc5, 0x99, 0x46, 0xd8, 0xbd, 0x3a, 0x07, 0x97, 0x9d,
+	0x69, 0xc4, 0xbb, 0xf6, 0x06, 0xd4, 0x67, 0xce, 0xf5, 0x94, 0x7a, 0x51, 0x4c, 0x66, 0x75, 0xab,
+	0x26, 0x60, 0x9c, 0xd0, 0x1e, 0xc3, 0x9a, 0x8e, 0x22, 0x1b, 0x2f, 0xa9, 0xc6, 0x57, 0x35, 0x6c,
+	0xd1, 0x87, 0x77, 0x60, 0x45, 0x96, 0x09, 0x70, 0x3c, 0x9c, 0xfc, 0xaa, 0xd6, 0xb2, 0x00, 0xcb,
+	0x51, 0x3e, 0x00, 0xe3, 0xcc, 0xf5, 0x9c, 0x89, 0x3d, 0x9a, 0x44, 0x97, 0xf6, 0x98, 0x4e, 0x22,
+	0x87, 0x53, 0x62, 0xc9, 0x5a, 0xe6, 0xf0, 0xf6, 0x24, 0xba, 0xdc, 0x63, 0x50, 0xf2, 0x1e, 0x54,
+	0xcf, 0x28, 0xb5, 0xf9, 0x64, 0x35, 0x2b, 0x89, 0x0d, 0x2d, 0x57, 0xc8, 0xaa, 0x9c, 0xc9, 0xb5,
+	0x7a, 0x0f, 0x0c, 0x7f, 0x1e, 0x9d, 0xfb, 0xae, 0x77, 0x6e, 0x8f, 0x2e, 0x1c, 0xcf, 0x76, 0xc7,
+	0x9c, 0x36, 0x8b, 0xbb, 0xf9, 0x47, 0x39, 0x6b, 0x59, 0xe6, 0xb5, 0x2f, 0x1c, 0xaf, 0x3b, 0x26,
+	0x6f, 0xc3, 0xca, 0xc4, 0x09, 0x23, 0xfb, 0xc2, 0x9f, 0xd9, 0xb3, 0xf9, 0xe9, 0x33, 0x7a, 0xdd,
+	0x6c, 0xf0, 0x89, 0x68, 0x30, 0xf0, 0x81, 0x3f, 0x3b, 0xe6, 0x40, 0x46, 0x7a, 0xbc, 0x9f, 0xd8,
+	0x09, 0x46, 0xd2, 0x0d, 0xab, 0xca, 0x20, 0xd8, 0xe8, 0x97, 0xb0, 0xc6, 0x97, 0x67, 0x34, 0x0f,
+	0x23, 0x7f, 0x6a, 0x07, 0x74, 0xe4, 0x07, 0xe3, 0xb0, 0x59, 0xe3, 0xb4, 0xf6, 0x6d, 0xd1, 0x59,
+	0x6d, 0x8d, 0x77, 0xf6, 0x68, 0x18, 0xb5, 0x39, 0xb2, 0x85, 0xb8, 0x1d, 0x2f, 0x0a, 0xae, 0xad,
+	0xd5, 0x71, 0x1a, 0x4e, 0xde, 0x03, 0xe2, 0x4c, 0x26, 0xfe, 0x73, 0x3b, 0xa4, 0x93, 0x33, 0x5b,
+	0x4c, 0x62, 0x73, 0xf9, 0x7e, 0xee, 0x41, 0xc5, 0x32, 0x78, 0xce, 0x80, 0x4e, 0xce, 0x8e, 0x11,
+	0x4e, 0x3e, 0x02, 0xbe, 0x49, 0xed, 0x33, 0xea, 0x44, 0xf3, 0x80, 0x86, 0xcd, 0x95, 0xfb, 0x85,
+	0x07, 0xcb, 0x8f, 0x57, 0xd5, 0x7c, 0x71, 0xf0, 0xae, 0x1b, 0x59, 0x75, 0x86, 0x27, 0xd2, 0xe1,
+	0xf6, 0x1e, 0x6c, 0x66, 0x77, 0x89, 0x11, 0x15, 0x9b, 0x15, 0x46, 0x8c, 0x45, 0x8b, 0xfd, 0x64,
+	0x3b, 0xfb, 0xd2, 0x99, 0xcc, 0x29, 0xa7, 0xc2, 0xba, 0x85, 0x89, 0xef, 0xe7, 0x3f, 0xc9, 0x99,
+	0xbf, 0x9b, 0x83, 0x3a, 0x8e, 0x32, 0x9c, 0xf9, 0x5e, 0x48, 0xc9, 0x9b, 0xd0, 0x90, 0xd4, 0x40,
+	0x83, 0xc0, 0x0f, 0x04, 0xb7, 0x94, 0x94, 0xd7, 0x61, 0x30, 0xf2, 0x6d, 0x30, 0x24, 0xd2, 0x2c,
+	0xa0, 0xee, 0xd4, 0x39, 0x97, 0x55, 0x4b, 0x52, 0x3a, 0x16, 0x60, 0xf2, 0x41, 0x5c, 0x5f, 0xe0,
+	0xcf, 0x23, 0xca, 0x69, 0xbd, 0xf6, 0xb8, 0x2e, 0x86, 0x67, 0x31, 0x98, 0xaa, 0x9d, 0xa7, 0x5e,
+	0x81, 0xce, 0xcd, 0xdf, 0xca, 0x01, 0x61, 0xdd, 0x1e, 0xfa, 0x58, 0x41, 0xcc, 0x91, 0x12, 0x25,
+	0x73, 0xaf, 0xbc, 0x43, 0xf2, 0x2f, 0xda, 0x21, 0x26, 0x94, 0xb0, 0xef, 0xc5, 0x8c, 0xbe, 0x63,
+	0xd6, 0x8f, 0x8b, 0x95, 0x82, 0x51, 0x34, 0xff, 0x4b, 0x01, 0xd6, 0x19, 0x9d, 0x7a, 0x74, 0xd2,
+	0x1a, 0x8d, 0xe8, 0x4c, 0xed, 0x9d, 0x7b, 0x50, 0xf3, 0xfc, 0x31, 0x95, 0x14, 0x8b, 0x1d, 0x03,
+	0x06, 0xd2, 0xc8, 0xf5, 0xc2, 0x71, 0x3d, 0xec, 0x38, 0x4e, 0x66, 0x95, 0x43, 0x78, 0xb7, 0xdf,
+	0x86, 0x95, 0x19, 0xf5, 0xc6, 0xfa, 0x16, 0x29, 0x20, 0xd5, 0x0b, 0xb0, 0xd8, 0x1d, 0xf7, 0xa0,
+	0x76, 0x36, 0x47, 0x3c, 0xc6, 0x58, 0x8a, 0x9c, 0x06, 0x40, 0x80, 0x5a, 0xc8, 0x5f, 0x66, 0xf3,
+	0xf0, 0x82, 0xe7, 0x96, 0x78, 0x6e, 0x99, 0xa5, 0x59, 0xd6, 0x5d, 0x80, 0xf1, 0x3c, 0x8c, 0xc4,
+	0x8e, 0x59, 0xe2, 0x99, 0x55, 0x06, 0xc1, 0x1d, 0xf3, 0x1d, 0x58, 0x9b, 0x3a, 0x57, 0x36, 0xa7,
+	0x1d, 0xdb, 0xf5, 0xec, 0xb3, 0x09, 0x67, 0xea, 0x65, 0x8e, 0x67, 0x4c, 0x9d, 0xab, 0xcf, 0x59,
+	0x4e, 0xd7, 0xdb, 0xe7, 0x70, 0xc6, 0x56, 0x46, 0x38, 0x13, 0x76, 0x40, 0x43, 0x1a, 0x5c, 0x52,
+	0xce, 0x09, 0x8a, 0xd6, 0xb2, 0x00, 0x5b, 0x08, 0x65, 0x3d, 0x9a, 0xb2, 0x71, 0x47, 0x93, 0x11,
+	0x6e, 0x7b, 0xab, 0x3c, 0x75, 0xbd, 0x83, 0x68, 0x32, 0x62, 0xe7, 0x15, 0xe3, 0x23, 0x33, 0x1a,
+	0xd8, 0xcf, 0x9e, 0xf3, 0x3d, 0x5c, 0xe4, 0x7c, 0xe3, 0x98, 0x06, 0x4f, 0x9f, 0x33, 0x91, 0x62,
+	0x14, 0x72, 0x46, 0xe4, 0x5c, 0x37, 0x6b, 0x7c, 0x83, 0x57, 0x46, 0x21, 0x63, 0x41, 0xce, 0x35,
+	0xdb, 0x84, 0xac, 0xb7, 0x0e, 0x5f, 0x05, 0x3a, 0xe6, 0xd5, 0x87, 0x9c, 0xa3, 0x36, 0x78, 0x67,
+	0x5b, 0x22, 0x83, 0xb5, 0x13, 0x32, 0xaa, 0x97, 0x9d, 0x3d, 0x9b, 0x38, 0xe7, 0x21, 0x67, 0x29,
+	0x0d, 0xab, 0x2e, 0x80, 0xfb, 0x0c, 0x66, 0x7e, 0x01, 0x1b, 0xa9, 0xb5, 0x15, 0x7b, 0x86, 0x89,
+	0x10, 0x1c, 0xc2, 0xd7, 0xb5, 0x62, 0x89, 0x54, 0xd6, 0xa2, 0xe5, 0x33, 0x16, 0xcd, 0xfc, 0xed,
+	0x1c, 0xd4, 0x45, 0xcd, 0x5c, 0xd8, 0x21, 0x3b, 0x40, 0xe4, 0x2a, 0x46, 0x57, 0xee, 0xd8, 0x3e,
+	0xbd, 0x8e, 0x68, 0x88, 0x44, 0x73, 0x70, 0xcb, 0x32, 0x44, 0xde, 0xf0, 0xca, 0x1d, 0xef, 0xb2,
+	0x1c, 0xf2, 0x10, 0x8c, 0x04, 0x7e, 0x18, 0x05, 0x48, 0xd1, 0x07, 0xb7, 0xac, 0x65, 0x0d, 0x7b,
+	0x10, 0x05, 0x6c, 0x8f, 0x30, 0x51, 0x6a, 0x1e, 0xd9, 0xae, 0x37, 0xa6, 0x57, 0x9c, 0x8c, 0x1a,
+	0x56, 0x0d, 0x61, 0x5d, 0x06, 0xda, 0x5d, 0x86, 0xba, 0x5e, 0x9d, 0x79, 0x0e, 0x15, 0x29, 0x87,
+	0x71, 0x41, 0x24, 0xd5, 0x25, 0xab, 0x1a, 0xa9, 0x9e, 0xdc, 0x86, 0x4a, 0xb2, 0x07, 0x56, 0x39,
+	0x7a, 0xe5, 0x86, 0xcd, 0x1f, 0x80, 0x71, 0xc8, 0x88, 0xc7, 0x63, 0xc4, 0x2a, 0xe4, 0xca, 0x4d,
+	0x58, 0xd2, 0x36, 0x4d, 0xd5, 0x12, 0x29, 0x76, 0xe6, 0x5e, 0xf8, 0x61, 0x24, 0x5a, 0xe1, 0xbf,
+	0xcd, 0xdf, 0xcb, 0x01, 0xe9, 0x84, 0x91, 0x3b, 0x75, 0x22, 0xba, 0x4f, 0x15, 0x5b, 0xe8, 0x43,
+	0x9d, 0xd5, 0x36, 0xf4, 0x5b, 0x28, 0xe8, 0xa1, 0x40, 0xf1, 0xae, 0xd8, 0xc6, 0x8b, 0x05, 0x76,
+	0x74, 0x6c, 0x64, 0xf3, 0x89, 0x0a, 0xd8, 0x2e, 0x8b, 0x9c, 0xe0, 0x9c, 0x46, 0x5c, 0x3c, 0x14,
+	0x72, 0x0d, 0x20, 0x88, 0x09, 0x86, 0xdb, 0x3f, 0x84, 0xd5, 0x85, 0x3a, 0x74, 0xbe, 0x5c, 0xcd,
+	0xe0, 0xcb, 0x05, 0x9d, 0x2f, 0xdb, 0xb0, 0x96, 0xe8, 0x97, 0xa0, 0xb4, 0x2d, 0x28, 0xb3, 0x0d,
+	0xc1, 0x84, 0x83, 0x1c, 0x4a, 0xab, 0x67, 0x94, 0x32, 0xf1, 0xfa, 0x7d, 0x58, 0x3f, 0xa3, 0x34,
+	0x70, 0x22, 0x9e, 0xc9, 0x77, 0x0c, 0x5b, 0x21, 0x51, 0xf1, 0xaa, 0xc8, 0x1b, 0x38, 0xd1, 0x31,
+	0x0d, 0xd8, 0x4a, 0x99, 0xff, 0x3b, 0x07, 0x2b, 0x8c, 0x83, 0x1e, 0x39, 0xde, 0xb5, 0x9c, 0xa7,
+	0xc3, 0xcc, 0x79, 0x7a, 0xa0, 0x1d, 0x86, 0x1a, 0xf6, 0xd7, 0x9d, 0xa4, 0x42, 0x7a, 0x92, 0xc8,
+	0x7d, 0xa8, 0x27, 0xfa, 0x5a, 0xe2, 0x7d, 0x85, 0x50, 0x75, 0x32, 0x96, 0x48, 0x97, 0x34, 0x89,
+	0xf4, 0x4f, 0x3e, 0xb9, 0x6f, 0x83, 0x11, 0x0f, 0x46, 0xcc, 0x2c, 0x81, 0x22, 0x23, 0x54, 0x51,
+	0x01, 0xff, 0x6d, 0xfe, 0x93, 0x1c, 0x22, 0xb6, 0x7d, 0x37, 0x96, 0x7a, 0x09, 0x14, 0x99, 0x94,
+	0x2d, 0x11, 0xd9, 0xef, 0x1b, 0x75, 0x88, 0x6f, 0x60, 0x0a, 0x6e, 0x43, 0x25, 0x64, 0x22, 0xb4,
+	0x33, 0xc1, 0x59, 0xa8, 0x58, 0x65, 0x96, 0x6e, 0x4d, 0x26, 0xf1, 0xec, 0x94, 0x75, 0x79, 0xfd,
+	0x1d, 0x58, 0xd5, 0xfa, 0xfc, 0x82, 0xd1, 0xf5, 0x80, 0x1c, 0xba, 0x61, 0x74, 0xe2, 0x85, 0x33,
+	0x4d, 0xc8, 0xbb, 0x03, 0x55, 0xc6, 0x8d, 0x59, 0x7f, 0x43, 0x21, 0xd1, 0x33, 0xf6, 0xcc, 0x7a,
+	0x1b, 0xf2, 0x4c, 0xe7, 0x4a, 0x64, 0xe6, 0x45, 0xa6, 0x73, 0xc5, 0x33, 0xcd, 0x4f, 0x60, 0x2d,
+	0x51, 0x9f, 0x68, 0xfa, 0x0d, 0x28, 0xcd, 0xa3, 0x2b, 0x5f, 0x8a, 0xf1, 0x35, 0x41, 0x4d, 0x4c,
+	0x09, 0xb5, 0x30, 0xc7, 0xfc, 0x0c, 0x56, 0x7b, 0xf4, 0xb9, 0xd8, 0xf0, 0xb2, 0x23, 0x6f, 0x43,
+	0xf1, 0x25, 0x8a, 0x29, 0xcf, 0x37, 0x77, 0x80, 0xe8, 0x85, 0x45, 0xab, 0x9a, 0x9e, 0x9a, 0x4b,
+	0xe8, 0xa9, 0xe6, 0xdb, 0x40, 0x06, 0xee, 0xb9, 0x77, 0x44, 0xc3, 0xd0, 0x39, 0x57, 0x2c, 0xc2,
+	0x80, 0xc2, 0x34, 0x3c, 0x17, 0xfc, 0x8c, 0xfd, 0x34, 0xbf, 0x0b, 0x6b, 0x09, 0x3c, 0x51, 0xf1,
+	0x6b, 0x50, 0x0d, 0xdd, 0x73, 0x8f, 0x0b, 0x61, 0xa2, 0xea, 0x18, 0x60, 0xee, 0xc3, 0xfa, 0xe7,
+	0x34, 0x70, 0xcf, 0xae, 0x5f, 0x56, 0x7d, 0xb2, 0x9e, 0x7c, 0xba, 0x9e, 0x0e, 0x6c, 0xa4, 0xea,
+	0x11, 0xcd, 0x23, 0x51, 0x8b, 0x95, 0xac, 0x58, 0x98, 0xd0, 0x78, 0x64, 0x5e, 0xe7, 0x91, 0xe6,
+	0x09, 0x90, 0xb6, 0xef, 0x79, 0x74, 0x14, 0x1d, 0x53, 0x1a, 0xc8, 0xce, 0xbc, 0xab, 0x51, 0x70,
+	0xed, 0xf1, 0x96, 0x98, 0xd9, 0x34, 0xe3, 0x15, 0xa4, 0x4d, 0xa0, 0x38, 0xa3, 0xc1, 0x94, 0x57,
+	0x5c, 0xb1, 0xf8, 0x6f, 0x73, 0x03, 0xd6, 0x12, 0xd5, 0x62, 0xdf, 0xcc, 0x47, 0xb0, 0xb1, 0xe7,
+	0x86, 0xa3, 0xc5, 0x06, 0xb7, 0xa0, 0x3c, 0x9b, 0x9f, 0xda, 0x49, 0x1e, 0xfe, 0x94, 0x5e, 0x9b,
+	0x4d, 0xd8, 0x4c, 0x97, 0x10, 0x75, 0xfd, 0x46, 0x0e, 0x8a, 0x07, 0xc3, 0xc3, 0x36, 0xd9, 0x86,
+	0x8a, 0xeb, 0x8d, 0xfc, 0x29, 0x13, 0xd2, 0x70, 0xcc, 0x2a, 0x7d, 0xe3, 0xb6, 0xbb, 0x03, 0x55,
+	0x2e, 0xdb, 0x31, 0xf5, 0x5a, 0x88, 0x49, 0x15, 0x06, 0x38, 0xf4, 0x47, 0xcf, 0x98, 0x5e, 0x4f,
+	0xaf, 0x66, 0x6e, 0xc0, 0x35, 0x77, 0xa9, 0x99, 0x16, 0x51, 0x2e, 0x88, 0x33, 0x84, 0x82, 0xfa,
+	0x1b, 0x79, 0x20, 0xe2, 0x64, 0x6e, 0xfb, 0x5e, 0x18, 0x05, 0x8e, 0xeb, 0x45, 0x61, 0x52, 0xf2,
+	0xc8, 0xa5, 0x24, 0x8f, 0x07, 0x60, 0xf0, 0xd3, 0x5e, 0x48, 0x3d, 0x9c, 0x59, 0xe7, 0x63, 0xc9,
+	0x47, 0x88, 0x3d, 0x8c, 0x69, 0xbf, 0x05, 0xcb, 0xb1, 0xc0, 0xa5, 0xcc, 0x26, 0x45, 0xab, 0xae,
+	0x84, 0x2e, 0xc1, 0xda, 0xd9, 0xa6, 0x93, 0x92, 0x84, 0xd2, 0x0e, 0x51, 0xb6, 0x5b, 0x9d, 0x3a,
+	0x57, 0xc7, 0x54, 0x8a, 0x77, 0x5c, 0x4f, 0x34, 0xa1, 0x21, 0x05, 0x2a, 0xc4, 0x44, 0x39, 0xaf,
+	0x26, 0xa4, 0x2a, 0x8e, 0x93, 0x2d, 0x1e, 0x2d, 0x65, 0x8b, 0x47, 0xe6, 0x7f, 0xac, 0x42, 0x59,
+	0x4c, 0x03, 0x0a, 0x3b, 0x91, 0x7b, 0x49, 0x63, 0x61, 0x87, 0xa5, 0x98, 0x08, 0x15, 0xd0, 0xa9,
+	0x1f, 0x29, 0x19, 0x17, 0x49, 0xb1, 0x8e, 0x40, 0x21, 0xe5, 0x6a, 0x72, 0x16, 0x5a, 0x7b, 0x0a,
+	0x88, 0x34, 0xd2, 0xa5, 0x9f, 0x3b, 0x50, 0x96, 0xe2, 0x52, 0x51, 0xa9, 0x81, 0x4b, 0x23, 0x14,
+	0x70, 0xb7, 0xa1, 0x32, 0x72, 0x66, 0xce, 0xc8, 0x8d, 0xae, 0x05, 0xb7, 0x54, 0x69, 0x56, 0xfb,
+	0xc4, 0x1f, 0x39, 0x13, 0xfb, 0xd4, 0x99, 0x38, 0xde, 0x88, 0x0a, 0x33, 0x4a, 0x9d, 0x03, 0x77,
+	0x11, 0x46, 0xbe, 0x05, 0xcb, 0xa2, 0x9f, 0x12, 0x0b, 0xad, 0x29, 0xa2, 0xf7, 0x12, 0x8d, 0xc9,
+	0xe3, 0xfe, 0x94, 0xad, 0xcb, 0x19, 0x45, 0xc9, 0xb5, 0x60, 0x55, 0x11, 0xb2, 0x4f, 0xf9, 0x68,
+	0x45, 0xf6, 0x73, 0xa4, 0xa0, 0x2a, 0x36, 0x85, 0xc0, 0x2f, 0xd0, 0xfa, 0xb1, 0x28, 0xbe, 0x16,
+	0x34, 0xf1, 0xf5, 0x5d, 0x58, 0x9d, 0x7b, 0x21, 0x8d, 0xa2, 0x09, 0x1d, 0xab, 0xbe, 0xd4, 0x38,
+	0x92, 0xa1, 0x32, 0x64, 0x77, 0x76, 0x60, 0x0d, 0xed, 0x3f, 0xa1, 0x13, 0xf9, 0xe1, 0x85, 0x1b,
+	0xda, 0x21, 0x53, 0x2a, 0xd1, 0x42, 0xb0, 0xca, 0xb3, 0x06, 0x22, 0x67, 0x80, 0x5a, 0xe5, 0x56,
+	0x0a, 0x3f, 0xa0, 0x23, 0xea, 0x5e, 0xd2, 0x31, 0x17, 0x6d, 0x0b, 0xd6, 0x46, 0xa2, 0x8c, 0x25,
+	0x32, 0xb9, 0x9e, 0x32, 0x9f, 0xda, 0xf3, 0xd9, 0xd8, 0x61, 0xf2, 0xdd, 0x32, 0xea, 0x0f, 0xde,
+	0x7c, 0x7a, 0x82, 0x10, 0xf2, 0x08, 0xa4, 0xf0, 0x2a, 0x68, 0x66, 0x25, 0xc1, 0xd6, 0xd9, 0x9e,
+	0xb5, 0xea, 0x02, 0x03, 0x65, 0xeb, 0x7b, 0xfa, 0x66, 0x31, 0x18, 0x85, 0x71, 0x3d, 0x2b, 0xde,
+	0x30, 0x4d, 0x28, 0xcf, 0x02, 0xf7, 0xd2, 0x89, 0x68, 0x73, 0x15, 0x4f, 0x38, 0x91, 0x64, 0x4c,
+	0xd2, 0xf5, 0xdc, 0xc8, 0x75, 0x22, 0x3f, 0x68, 0x12, 0x9e, 0x17, 0x03, 0xc8, 0x43, 0x58, 0xe5,
+	0x74, 0x12, 0x46, 0x4e, 0x34, 0x0f, 0x85, 0xe0, 0xbe, 0xc6, 0x09, 0x8a, 0xab, 0x1e, 0x03, 0x0e,
+	0xe7, 0xb2, 0x3b, 0xf9, 0x18, 0x36, 0x91, 0x34, 0x16, 0xb6, 0xe6, 0x3a, 0x9b, 0x0e, 0xde, 0xa3,
+	0x35, 0x8e, 0xd1, 0x4e, 0xee, 0xd1, 0x4f, 0x61, 0x4b, 0x90, 0xcb, 0x42, 0xc9, 0x0d, 0x55, 0x72,
+	0x1d, 0x51, 0x52, 0x45, 0x77, 0x60, 0x95, 0x75, 0xcd, 0x1d, 0xd9, 0xa2, 0x06, 0xb6, 0x2b, 0x36,
+	0xd9, 0x28, 0x78, 0xa1, 0x15, 0xcc, 0xb4, 0x78, 0xde, 0x53, 0x7a, 0x4d, 0x7e, 0x00, 0x2b, 0x48,
+	0x3e, 0x5c, 0x3b, 0xe5, 0x87, 0xdf, 0x36, 0x3f, 0xfc, 0x36, 0xc4, 0xe4, 0xb6, 0x55, 0x2e, 0x3f,
+	0xff, 0x96, 0x47, 0x89, 0x34, 0xdb, 0x1a, 0x13, 0xf7, 0x8c, 0x46, 0xee, 0x94, 0x36, 0xb7, 0x90,
+	0xd8, 0x64, 0x9a, 0xed, 0xda, 0xf9, 0x8c, 0xe7, 0x34, 0x91, 0x55, 0x62, 0x8a, 0xd3, 0xf1, 0xc4,
+	0x0f, 0xa9, 0xb4, 0x1c, 0x36, 0x6f, 0x8b, 0x0d, 0xc9, 0x80, 0x52, 0x04, 0x67, 0x7a, 0x0c, 0xea,
+	0x8c, 0xca, 0xbe, 0x7b, 0x87, 0x13, 0x46, 0x03, 0x55, 0x47, 0x69, 0xe3, 0x65, 0xe2, 0xce, 0x85,
+	0xf3, 0x5c, 0x32, 0xd5, 0xd7, 0x38, 0x37, 0x01, 0x06, 0x12, 0xe6, 0xc0, 0x7d, 0x58, 0x15, 0xab,
+	0x10, 0x33, 0xd3, 0xe6, 0x5d, 0x7e, 0x0c, 0xdd, 0x96, 0x63, 0x5c, 0xe0, 0xb6, 0x96, 0x81, 0xeb,
+	0xa2, 0xf1, 0xdf, 0x03, 0x20, 0x72, 0x51, 0xb4, 0x8a, 0x5e, 0x7f, 0x59, 0x45, 0xab, 0x62, 0x99,
+	0x62, 0x90, 0xf9, 0xb3, 0x1c, 0x4a, 0x2d, 0x02, 0x3b, 0xd4, 0xf4, 0x75, 0xe4, 0x6b, 0xb6, 0xef,
+	0x4d, 0xae, 0x05, 0xab, 0x03, 0x04, 0xf5, 0xbd, 0x09, 0xe7, 0x35, 0xae, 0xa7, 0xa3, 0xe0, 0x01,
+	0x59, 0x97, 0x40, 0x8e, 0x74, 0x0f, 0x6a, 0xb3, 0xf9, 0xe9, 0xc4, 0x1d, 0x21, 0x4a, 0x01, 0x6b,
+	0x41, 0x10, 0x47, 0x78, 0x03, 0xea, 0x82, 0xd6, 0x11, 0xa3, 0xc8, 0x31, 0x6a, 0x02, 0xc6, 0x51,
+	0xf8, 0x01, 0x4c, 0x03, 0xce, 0xec, 0xea, 0x16, 0xff, 0x6d, 0xee, 0xc2, 0x7a, 0xb2, 0xd3, 0x42,
+	0x3a, 0x78, 0x08, 0x15, 0xc1, 0x49, 0xa5, 0x25, 0x6b, 0x39, 0x39, 0x1b, 0x96, 0xca, 0x37, 0xff,
+	0x53, 0x09, 0xd6, 0xe4, 0x1c, 0xb1, 0xc5, 0x1e, 0xcc, 0xa7, 0x53, 0x27, 0xc8, 0x60, 0xd1, 0xb9,
+	0x17, 0xb3, 0xe8, 0xfc, 0x02, 0x8b, 0x4e, 0x9a, 0x32, 0x90, 0xc3, 0x27, 0x4d, 0x19, 0x8c, 0xba,
+	0x50, 0xbb, 0xd4, 0x0d, 0xe6, 0x0d, 0x01, 0x1e, 0xa2, 0x61, 0x7e, 0xe1, 0x40, 0x29, 0x65, 0x1c,
+	0x28, 0xfa, 0x71, 0xb0, 0x94, 0x3a, 0x0e, 0xde, 0x00, 0x24, 0x63, 0x49, 0x8f, 0x65, 0x54, 0x38,
+	0x39, 0x4c, 0x10, 0xe4, 0x3b, 0xb0, 0x92, 0xe6, 0xc0, 0xc8, 0xea, 0x97, 0x33, 0xf8, 0xaf, 0x3b,
+	0xa5, 0x5c, 0xa4, 0xd0, 0x90, 0xab, 0x82, 0xff, 0xba, 0x53, 0x7a, 0xc8, 0x73, 0x24, 0x7e, 0x07,
+	0x00, 0xdb, 0xe6, 0xdb, 0x18, 0xf8, 0x36, 0x7e, 0x3b, 0x45, 0x99, 0xda, 0xac, 0xef, 0xb0, 0xc4,
+	0x3c, 0xa0, 0x7c, 0x5f, 0x57, 0x79, 0x49, 0xbe, 0xa5, 0x3f, 0x86, 0x65, 0x7f, 0x46, 0x3d, 0x3b,
+	0xe6, 0x82, 0x35, 0x5e, 0x95, 0x21, 0xaa, 0xea, 0x4a, 0xb8, 0xd5, 0x60, 0x78, 0x2a, 0x49, 0x3e,
+	0xc5, 0x49, 0xa6, 0x5a, 0xc9, 0xfa, 0x0d, 0x25, 0x97, 0x39, 0x62, 0x5c, 0xf4, 0xbb, 0x50, 0x0b,
+	0x68, 0xe8, 0x4f, 0xe6, 0x68, 0x7d, 0x6f, 0x70, 0x3a, 0x92, 0xe6, 0x48, 0x4b, 0xe5, 0x58, 0x3a,
+	0x96, 0xf9, 0x9b, 0x39, 0xa8, 0x69, 0x63, 0x20, 0x1b, 0xb0, 0xda, 0xee, 0xf7, 0x8f, 0x3b, 0x56,
+	0x6b, 0xd8, 0xfd, 0xbc, 0x63, 0xb7, 0x0f, 0xfb, 0x83, 0x8e, 0x71, 0x8b, 0x81, 0x0f, 0xfb, 0xed,
+	0xd6, 0xa1, 0xbd, 0xdf, 0xb7, 0xda, 0x12, 0x9c, 0x23, 0x9b, 0x40, 0xac, 0xce, 0x51, 0x7f, 0xd8,
+	0x49, 0xc0, 0xf3, 0xc4, 0x80, 0xfa, 0xae, 0xd5, 0x69, 0xb5, 0x0f, 0x04, 0xa4, 0x40, 0xd6, 0xc1,
+	0xd8, 0x3f, 0xe9, 0xed, 0x75, 0x7b, 0x4f, 0xec, 0x76, 0xab, 0xd7, 0xee, 0x1c, 0x76, 0xf6, 0x8c,
+	0x22, 0x69, 0x40, 0xb5, 0xb5, 0xdb, 0xea, 0xed, 0xf5, 0x7b, 0x9d, 0x3d, 0xa3, 0x64, 0xfe, 0x8f,
+	0x1c, 0x40, 0xdc, 0x51, 0xc6, 0x57, 0xe3, 0xae, 0xea, 0xde, 0xae, 0x8d, 0x85, 0x41, 0x21, 0x5f,
+	0x0d, 0x12, 0x69, 0xf2, 0x18, 0xca, 0xfe, 0x3c, 0x1a, 0xf9, 0x53, 0x14, 0xd4, 0x97, 0x1f, 0x37,
+	0x17, 0xca, 0xf5, 0x31, 0xdf, 0x92, 0x88, 0x09, 0x8f, 0x56, 0xe1, 0x65, 0x1e, 0xad, 0xa4, 0xeb,
+	0x0c, 0xe5, 0x3a, 0xcd, 0x75, 0x76, 0x17, 0x20, 0x7c, 0x4e, 0xe9, 0x8c, 0x1b, 0x63, 0xc4, 0x2e,
+	0xa8, 0x72, 0xc8, 0x90, 0xe9, 0x71, 0x7f, 0x98, 0x83, 0x0d, 0x4e, 0x4b, 0xe3, 0x34, 0x13, 0xbb,
+	0x0f, 0xb5, 0x91, 0xef, 0xcf, 0x98, 0xea, 0x1f, 0xcb, 0x6b, 0x3a, 0x88, 0x31, 0x28, 0x64, 0xc8,
+	0x67, 0x7e, 0x30, 0xa2, 0x82, 0x87, 0x01, 0x07, 0xed, 0x33, 0x08, 0xdb, 0x43, 0x62, 0x13, 0x22,
+	0x06, 0xb2, 0xb0, 0x1a, 0xc2, 0x10, 0x65, 0x13, 0x96, 0x4e, 0x03, 0xea, 0x8c, 0x2e, 0x04, 0xf7,
+	0x12, 0x29, 0xf2, 0xed, 0xd8, 0x28, 0x35, 0x62, 0x7b, 0x62, 0x42, 0xb1, 0xf3, 0x15, 0x6b, 0x45,
+	0xc0, 0xdb, 0x02, 0xcc, 0xce, 0x79, 0xe7, 0xd4, 0xf1, 0xc6, 0xbe, 0x47, 0xc7, 0x42, 0xcb, 0x8d,
+	0x01, 0xe6, 0x31, 0x6c, 0xa6, 0xc7, 0x27, 0xf8, 0xdd, 0x47, 0x1a, 0xbf, 0x43, 0xf5, 0x72, 0xfb,
+	0xe6, 0x3d, 0xa6, 0xf1, 0xbe, 0xbf, 0x54, 0x84, 0x22, 0x53, 0x37, 0x6e, 0xd4, 0x4c, 0x74, 0xfd,
+	0xb1, 0xb0, 0xe0, 0xe7, 0xe4, 0xb6, 0x2f, 0x14, 0xc0, 0xc4, 0x62, 0x71, 0x08, 0x17, 0xbc, 0x54,
+	0x76, 0x40, 0x47, 0x97, 0x42, 0xf2, 0xc6, 0x6c, 0x8b, 0x8e, 0x2e, 0xb9, 0x3a, 0xef, 0x44, 0x58,
+	0x16, 0xf9, 0x55, 0x39, 0x74, 0x22, 0x5e, 0x52, 0x64, 0xf1, 0x72, 0x65, 0x95, 0xc5, 0x4b, 0x35,
+	0xa1, 0xec, 0x7a, 0xa7, 0xfe, 0xdc, 0x1b, 0x73, 0xf6, 0x54, 0xb1, 0x64, 0x92, 0xbb, 0x55, 0x39,
+	0x27, 0x65, 0x47, 0x3b, 0x72, 0xa3, 0x0a, 0x03, 0x0c, 0xd9, 0xe1, 0xfe, 0x01, 0x54, 0xc3, 0x6b,
+	0x6f, 0xa4, 0xf3, 0xa0, 0x75, 0x31, 0x3f, 0x6c, 0xf4, 0x3b, 0x83, 0x6b, 0x6f, 0xc4, 0x29, 0xbe,
+	0x12, 0x8a, 0x5f, 0xe4, 0x43, 0xa8, 0x28, 0x47, 0x04, 0x9e, 0x20, 0xb7, 0xf5, 0x12, 0xd2, 0xfb,
+	0x80, 0xf6, 0x1e, 0x85, 0x4a, 0xde, 0x87, 0x25, 0xee, 0x2d, 0x08, 0x9b, 0x75, 0x5e, 0x48, 0x2a,
+	0x95, 0xac, 0x1b, 0xdc, 0xa3, 0x49, 0xc7, 0xdc, 0x73, 0x60, 0x09, 0xb4, 0xed, 0xa7, 0xd0, 0x48,
+	0xd4, 0xa5, 0xdb, 0x6f, 0x1a, 0x68, 0xbf, 0x79, 0x4b, 0xb7, 0xdf, 0xc4, 0x27, 0x99, 0x28, 0xa6,
+	0xdb, 0x73, 0x7e, 0x08, 0x15, 0x39, 0x14, 0xc6, 0x32, 0x4e, 0x7a, 0x4f, 0x7b, 0xfd, 0x2f, 0x7a,
+	0xf6, 0xe0, 0xcb, 0x5e, 0xdb, 0xb8, 0x45, 0x56, 0xa0, 0xd6, 0x6a, 0x73, 0x2e, 0xc4, 0x01, 0x39,
+	0x86, 0x72, 0xdc, 0x1a, 0x0c, 0x14, 0x24, 0x6f, 0xee, 0x83, 0x91, 0xee, 0x29, 0xa3, 0xc9, 0x48,
+	0xc2, 0x84, 0x2f, 0x25, 0x06, 0x30, 0x3d, 0x1c, 0xdd, 0x23, 0xa8, 0xe5, 0x60, 0xc2, 0xfc, 0x10,
+	0x0c, 0x76, 0x2e, 0xb3, 0xa9, 0xd2, 0xbd, 0xa4, 0x13, 0x26, 0x39, 0xeb, 0xfe, 0x94, 0x8a, 0x55,
+	0x43, 0x18, 0x6f, 0xca, 0xfc, 0x08, 0x56, 0xb5, 0x62, 0xb1, 0xdd, 0x84, 0x9d, 0xf5, 0x69, 0xbb,
+	0x09, 0xd7, 0x92, 0x31, 0xc7, 0xdc, 0x82, 0x0d, 0x96, 0xec, 0x5c, 0x52, 0x2f, 0x1a, 0xcc, 0x4f,
+	0xd1, 0xb9, 0xee, 0xfa, 0x1e, 0xd3, 0x9e, 0xab, 0x2a, 0xe7, 0x66, 0x22, 0xdf, 0x11, 0x26, 0x16,
+	0xe4, 0x6a, 0xdb, 0x5a, 0x0b, 0xbc, 0xe0, 0x0e, 0xff, 0x9b, 0x30, 0xb5, 0x54, 0x15, 0x88, 0x4d,
+	0xeb, 0x71, 0xa7, 0x63, 0xd9, 0xfd, 0xde, 0x61, 0xb7, 0xc7, 0x78, 0x3b, 0x9b, 0x56, 0x0e, 0xd8,
+	0xdf, 0xe7, 0x90, 0x9c, 0x69, 0xc0, 0xf2, 0x13, 0x1a, 0x75, 0xbd, 0x33, 0x5f, 0x4c, 0x86, 0xf9,
+	0xe7, 0x97, 0x60, 0x45, 0x81, 0x62, 0x53, 0xcd, 0x25, 0x0d, 0x42, 0xd7, 0xf7, 0xb8, 0xba, 0x51,
+	0xb5, 0x64, 0x92, 0x71, 0x27, 0xa1, 0x64, 0x71, 0x29, 0x61, 0x9d, 0xe7, 0x0a, 0xb5, 0x8c, 0x8b,
+	0x08, 0xef, 0xc0, 0x8a, 0x3b, 0xa6, 0x5e, 0xe4, 0x46, 0xd7, 0x76, 0xc2, 0x48, 0xbc, 0x2c, 0xc1,
+	0x42, 0x4c, 0x58, 0x87, 0x92, 0x33, 0x71, 0x1d, 0x19, 0xb4, 0x80, 0x09, 0x06, 0x1d, 0xf9, 0x13,
+	0x3f, 0xe0, 0x6a, 0x47, 0xd5, 0xc2, 0x04, 0x79, 0x04, 0xeb, 0x4c, 0x05, 0xd2, 0x2d, 0xf7, 0x9c,
+	0xc1, 0xa0, 0xbd, 0x9a, 0x78, 0xf3, 0xe9, 0x71, 0x6c, 0xbd, 0x67, 0x39, 0x4c, 0x38, 0x60, 0x25,
+	0x84, 0x34, 0xa8, 0x0a, 0xa0, 0x51, 0x61, 0xd5, 0x9b, 0x4f, 0x5b, 0x3c, 0x47, 0xe1, 0x3f, 0x86,
+	0x0d, 0x86, 0xaf, 0xe4, 0x47, 0x55, 0x62, 0x85, 0x97, 0x60, 0x95, 0x75, 0x45, 0x9e, 0x2a, 0x73,
+	0x07, 0xaa, 0xd8, 0x2b, 0x46, 0x12, 0x25, 0x34, 0x39, 0xf0, 0xae, 0xd0, 0x20, 0x5c, 0x88, 0x2f,
+	0x40, 0x3d, 0x3e, 0x1d, 0x5f, 0xa0, 0x45, 0x28, 0x54, 0xd2, 0x11, 0x0a, 0x8f, 0x61, 0xe3, 0x94,
+	0xd1, 0xe8, 0x05, 0x75, 0xc6, 0x34, 0xb0, 0x63, 0xca, 0x47, 0x6d, 0x71, 0x8d, 0x65, 0x1e, 0xf0,
+	0x3c, 0xb5, 0x51, 0x98, 0x20, 0xc7, 0xf8, 0x06, 0x1d, 0xdb, 0x91, 0x6f, 0x73, 0xf9, 0x8e, 0x73,
+	0xa0, 0x8a, 0xd5, 0x40, 0xf0, 0xd0, 0x6f, 0x33, 0x60, 0x12, 0xef, 0x3c, 0x70, 0x66, 0x17, 0x42,
+	0x97, 0x53, 0x78, 0x4f, 0x18, 0x90, 0xbc, 0x06, 0x65, 0xb6, 0x27, 0x3c, 0x8a, 0xee, 0x5a, 0xd4,
+	0x92, 0x24, 0x88, 0xbc, 0x05, 0x4b, 0xbc, 0x8d, 0xb0, 0x69, 0xf0, 0x0d, 0x51, 0x8f, 0x39, 0xbd,
+	0xeb, 0x59, 0x22, 0x8f, 0x49, 0xcb, 0xf3, 0xc0, 0x45, 0x36, 0x54, 0xb5, 0xf8, 0x6f, 0xf2, 0x23,
+	0x8d, 0xa7, 0xad, 0xf1, 0xb2, 0x6f, 0x89, 0xb2, 0x29, 0x52, 0xbc, 0x89, 0xbd, 0x7d, 0xa3, 0xdc,
+	0xea, 0xc7, 0xc5, 0x4a, 0xcd, 0xa8, 0x9b, 0x4d, 0x1e, 0x56, 0x61, 0xd1, 0x91, 0x7f, 0x49, 0x83,
+	0xeb, 0xc4, 0x1e, 0xc9, 0xc1, 0xd6, 0x42, 0x56, 0xec, 0x9d, 0x0d, 0x04, 0xdc, 0x9e, 0xfa, 0x63,
+	0x79, 0xa6, 0xd7, 0x25, 0xf0, 0xc8, 0x1f, 0x33, 0xd9, 0x63, 0x55, 0x21, 0x9d, 0xb9, 0x9e, 0x1b,
+	0x5e, 0xd0, 0xb1, 0x38, 0xda, 0x0d, 0x99, 0xb1, 0x2f, 0xe0, 0x4c, 0x80, 0x9e, 0x05, 0xfe, 0xb9,
+	0x3a, 0xe9, 0x72, 0x96, 0x4a, 0x9b, 0x1f, 0x43, 0x09, 0x57, 0x90, 0x6d, 0x14, 0xbe, 0xbe, 0x39,
+	0xb1, 0x51, 0x38, 0xb4, 0x09, 0x65, 0x8f, 0x46, 0xcf, 0xfd, 0xe0, 0x99, 0x74, 0xf5, 0x88, 0xa4,
+	0xf9, 0x53, 0x6e, 0x77, 0x54, 0xf1, 0x31, 0x68, 0x3b, 0x60, 0x24, 0x8c, 0x24, 0x18, 0x5e, 0x38,
+	0xc2, 0x14, 0x5a, 0xe1, 0x80, 0xc1, 0x85, 0xb3, 0x40, 0xc2, 0xf9, 0xc5, 0x10, 0x99, 0xb7, 0x60,
+	0x59, 0x46, 0xe4, 0x84, 0xf6, 0x84, 0x9e, 0x45, 0x62, 0x4b, 0xd6, 0x45, 0x38, 0x4e, 0x78, 0x48,
+	0xcf, 0x22, 0xf3, 0x08, 0x56, 0xc5, 0xa6, 0xe9, 0xcf, 0xa8, 0x6c, 0xfa, 0x93, 0x2c, 0xa5, 0xa6,
+	0xf6, 0x78, 0x2d, 0x29, 0x2d, 0xa0, 0x5c, 0x96, 0xd0, 0x74, 0xcc, 0x9f, 0xc4, 0x06, 0x40, 0x26,
+	0x4b, 0x88, 0xfa, 0x84, 0x6a, 0x21, 0x3d, 0x64, 0xd2, 0xd1, 0xac, 0x14, 0x18, 0x77, 0xcc, 0x66,
+	0x27, 0x9c, 0x8f, 0x46, 0x32, 0x52, 0xaa, 0x62, 0xc9, 0xa4, 0xf9, 0xef, 0x73, 0xb0, 0xc6, 0x2b,
+	0x93, 0x4a, 0x99, 0x38, 0x29, 0x7e, 0xee, 0x4e, 0xb2, 0xf5, 0xd1, 0x05, 0x38, 0x4c, 0x7c, 0x7d,
+	0xef, 0x43, 0x71, 0xc1, 0xfb, 0xf0, 0x6d, 0x30, 0xc6, 0x74, 0xe2, 0x72, 0x52, 0x92, 0xf2, 0x10,
+	0x0a, 0xa0, 0x2b, 0x12, 0x2e, 0x8c, 0x04, 0xe6, 0x5f, 0xcb, 0xc1, 0x2a, 0x8a, 0x5b, 0xdc, 0xec,
+	0x22, 0x26, 0xea, 0x33, 0x69, 0x5f, 0x10, 0xec, 0x54, 0x8c, 0x29, 0x16, 0x43, 0x38, 0x14, 0x91,
+	0x0f, 0x6e, 0x09, 0xbb, 0x83, 0x80, 0x92, 0xef, 0x73, 0x45, 0xd2, 0xb3, 0x39, 0x50, 0x88, 0xd1,
+	0xb7, 0x33, 0x04, 0x3c, 0x55, 0x9c, 0x69, 0x99, 0x1e, 0x07, 0xed, 0x56, 0x60, 0x09, 0x8d, 0x58,
+	0xe6, 0x3e, 0x34, 0x12, 0xcd, 0x24, 0x9c, 0x21, 0x75, 0x74, 0x86, 0x2c, 0x38, 0x27, 0xf3, 0x8b,
+	0xce, 0xc9, 0x6b, 0x58, 0xb3, 0xa8, 0x33, 0xbe, 0xde, 0xf7, 0x83, 0xe3, 0xf0, 0x34, 0xda, 0x47,
+	0x19, 0x96, 0x9d, 0x41, 0xca, 0xe3, 0x9e, 0xf0, 0x38, 0x48, 0xc7, 0xab, 0xb4, 0xa2, 0x7c, 0x0b,
+	0x96, 0x63, 0xd7, 0xbc, 0x66, 0xb5, 0x6e, 0x28, 0xef, 0x3c, 0x37, 0x5e, 0x33, 0x7d, 0x3f, 0x3c,
+	0x8d, 0x84, 0xdd, 0x9a, 0xff, 0x36, 0xff, 0x65, 0x11, 0x08, 0xa3, 0xe6, 0x14, 0xc1, 0xa4, 0x82,
+	0x0a, 0xf2, 0x0b, 0x41, 0x05, 0x8f, 0x80, 0x68, 0x08, 0x32, 0xd6, 0xa1, 0xa0, 0x62, 0x1d, 0x8c,
+	0x18, 0x57, 0x84, 0x3a, 0x3c, 0x82, 0x75, 0xa1, 0x10, 0x24, 0xbb, 0x8a, 0xa4, 0x41, 0x50, 0x33,
+	0x48, 0xf4, 0x57, 0x06, 0x14, 0x48, 0x43, 0x73, 0x01, 0x03, 0x0a, 0xa4, 0x3d, 0x48, 0x23, 0xc0,
+	0xa5, 0x97, 0x12, 0x60, 0x79, 0x81, 0x00, 0x35, 0xdb, 0x60, 0x25, 0x69, 0x1b, 0x5c, 0xb0, 0x72,
+	0xa3, 0xf4, 0x9b, 0xb0, 0x72, 0x3f, 0x00, 0x43, 0xda, 0x89, 0x94, 0x05, 0x12, 0x23, 0x81, 0x84,
+	0x0d, 0xb8, 0x2d, 0x6d, 0x90, 0x09, 0xb7, 0x57, 0x2d, 0xe5, 0xf6, 0x7a, 0x17, 0x56, 0x43, 0x46,
+	0xbf, 0xf6, 0xdc, 0x13, 0xe1, 0x80, 0x74, 0xcc, 0xd5, 0xe9, 0x8a, 0x65, 0xf0, 0x8c, 0x93, 0x18,
+	0xbe, 0x68, 0x51, 0x6b, 0x64, 0x58, 0xd4, 0x3e, 0x8c, 0x3d, 0xec, 0xe1, 0x85, 0x3b, 0xe5, 0x82,
+	0x4f, 0x1c, 0xe2, 0x26, 0x26, 0x78, 0x70, 0xe1, 0x4e, 0x2d, 0x19, 0xce, 0xc1, 0x12, 0xa4, 0x0d,
+	0xf7, 0xc4, 0x78, 0x32, 0x22, 0x31, 0x70, 0x16, 0x56, 0xb8, 0xa4, 0xba, 0x8d, 0x68, 0x47, 0xa9,
+	0xa0, 0x0c, 0x36, 0x29, 0xe6, 0xff, 0xca, 0x81, 0xc1, 0x88, 0x29, 0xb1, 0x4f, 0x3f, 0x05, 0xce,
+	0x51, 0x5e, 0x71, 0x9b, 0xd6, 0x18, 0xae, 0xdc, 0xa5, 0x1f, 0x03, 0xdf, 0x76, 0xb6, 0x3f, 0xa3,
+	0x9e, 0xd8, 0xa4, 0xcd, 0xe4, 0x26, 0x8d, 0x19, 0xf1, 0xc1, 0x2d, 0xd4, 0xc2, 0x18, 0x84, 0x7c,
+	0x0a, 0x55, 0x46, 0xdd, 0x9c, 0xd4, 0x44, 0xd8, 0xe7, 0xb6, 0xd2, 0xac, 0x17, 0x36, 0x1a, 0x2b,
+	0x3a, 0x13, 0xc9, 0xac, 0xc8, 0x8a, 0x62, 0x46, 0x64, 0x85, 0xc6, 0x05, 0x0e, 0x00, 0x9e, 0xd2,
+	0xeb, 0x43, 0x7f, 0xc4, 0x6d, 0x1c, 0x77, 0x01, 0xd8, 0x86, 0x38, 0x73, 0xa6, 0xae, 0xb0, 0xee,
+	0x95, 0xac, 0xea, 0x33, 0x7a, 0xbd, 0xcf, 0x01, 0x8c, 0x1a, 0x58, 0x76, 0xcc, 0x0a, 0x4a, 0x56,
+	0xe5, 0x19, 0xbd, 0x46, 0x3e, 0x60, 0x43, 0xe3, 0x29, 0xbd, 0xde, 0xa3, 0x28, 0x6e, 0xfb, 0x01,
+	0xa3, 0xc4, 0xc0, 0x79, 0xce, 0xe4, 0xeb, 0x44, 0x54, 0x44, 0x2d, 0x70, 0x9e, 0x3f, 0xa5, 0xd7,
+	0x32, 0x42, 0xa3, 0xcc, 0xf2, 0x27, 0xfe, 0x48, 0x08, 0x08, 0xd2, 0xa0, 0x12, 0x77, 0xca, 0x5a,
+	0x7a, 0xc6, 0x7f, 0x9b, 0x7f, 0x9c, 0x83, 0x06, 0xeb, 0x3f, 0xe7, 0xed, 0x7c, 0xdd, 0x45, 0x98,
+	0x60, 0x2e, 0x0e, 0x13, 0x7c, 0x2c, 0x58, 0x23, 0x1e, 0x14, 0xf9, 0x9b, 0x0f, 0x0a, 0xbe, 0x36,
+	0x78, 0x4a, 0x7c, 0x00, 0x55, 0xdc, 0xdb, 0x8c, 0x59, 0x14, 0x12, 0x0b, 0x9c, 0x18, 0x90, 0x55,
+	0xe1, 0x68, 0x4f, 0x31, 0x2a, 0x49, 0xb3, 0x5d, 0xe3, 0x14, 0x57, 0x03, 0x65, 0xb1, 0xce, 0x58,
+	0x86, 0xd2, 0x0d, 0x51, 0x49, 0xba, 0x61, 0x78, 0x29, 0x6d, 0x18, 0x36, 0xfb, 0x50, 0x61, 0x4b,
+	0xcd, 0x07, 0x9b, 0x51, 0x69, 0x2e, 0xab, 0x52, 0x26, 0x4e, 0x38, 0xec, 0x64, 0x61, 0xdc, 0x32,
+	0x2f, 0xc4, 0x09, 0x27, 0xa4, 0xac, 0x22, 0xf3, 0xcf, 0xe6, 0xa0, 0xa6, 0x6d, 0x23, 0x6e, 0x5b,
+	0x57, 0xf3, 0x85, 0x7b, 0x2e, 0x49, 0xe2, 0x89, 0x09, 0x3f, 0xb8, 0x65, 0x35, 0x46, 0x89, 0x15,
+	0xd8, 0x11, 0xb4, 0xca, 0x4b, 0xe6, 0x13, 0x06, 0x1d, 0xd9, 0x71, 0x49, 0xa0, 0xec, 0xf7, 0xee,
+	0x12, 0x14, 0x19, 0xaa, 0xf9, 0x19, 0xac, 0x6a, 0xdd, 0x40, 0x83, 0xc7, 0xab, 0x8e, 0xd0, 0xfc,
+	0x55, 0x55, 0x98, 0xb5, 0x81, 0x0e, 0x61, 0x19, 0xe1, 0x45, 0xc7, 0x38, 0x70, 0x11, 0x49, 0x86,
+	0x20, 0x86, 0xf6, 0xca, 0x51, 0x47, 0xbf, 0x06, 0x6b, 0x5a, 0xed, 0xfb, 0xae, 0xe7, 0x4c, 0xdc,
+	0x9f, 0x72, 0xa9, 0x21, 0x74, 0xcf, 0xbd, 0x54, 0xfd, 0x08, 0xfa, 0x5a, 0xf5, 0xff, 0xf5, 0x3c,
+	0xac, 0x8b, 0x06, 0x78, 0xcc, 0xae, 0xcb, 0x44, 0xc1, 0xa3, 0xf0, 0x9c, 0x7c, 0x0a, 0x0d, 0x36,
+	0x37, 0x76, 0x40, 0xcf, 0xdd, 0x30, 0xa2, 0xd2, 0x11, 0x9d, 0xc1, 0xfd, 0x98, 0x44, 0xc0, 0x50,
+	0x2d, 0x81, 0x49, 0x3e, 0x83, 0x1a, 0x2f, 0x8a, 0x06, 0x25, 0xb1, 0x10, 0xcd, 0xc5, 0x82, 0x38,
+	0xd1, 0x07, 0xb7, 0x2c, 0x08, 0xe3, 0x69, 0xff, 0x0c, 0x6a, 0x7c, 0x0d, 0x2f, 0xf9, 0x44, 0xa6,
+	0x58, 0xd5, 0xc2, 0x44, 0xb3, 0xc2, 0xb3, 0x78, 0xda, 0x5b, 0xd0, 0x40, 0x66, 0x25, 0xe6, 0x49,
+	0xc4, 0x02, 0x6e, 0x2f, 0x16, 0x97, 0x33, 0xc9, 0x3a, 0x3f, 0xd3, 0xd2, 0xbb, 0x55, 0x28, 0x47,
+	0x81, 0x7b, 0x7e, 0x4e, 0x03, 0x73, 0x53, 0x4d, 0x0d, 0xe3, 0xc2, 0x74, 0x10, 0xd1, 0x19, 0x93,
+	0xf1, 0xcd, 0x7f, 0x95, 0x83, 0x9a, 0xe0, 0xab, 0x3f, 0xb7, 0xf7, 0x7b, 0x3b, 0x65, 0x7a, 0xac,
+	0x6a, 0x96, 0xc6, 0x77, 0x60, 0x65, 0xca, 0x14, 0x12, 0xa6, 0x30, 0x27, 0x5c, 0xdf, 0xcb, 0x12,
+	0x2c, 0x64, 0xed, 0x1d, 0x58, 0xe3, 0xa2, 0x77, 0x68, 0x47, 0xee, 0xc4, 0x96, 0x99, 0x22, 0x70,
+	0x7d, 0x15, 0xb3, 0x86, 0xee, 0xe4, 0x48, 0x64, 0x30, 0x09, 0x34, 0x8c, 0x9c, 0x73, 0x2a, 0xf6,
+	0x36, 0x26, 0x98, 0x92, 0x93, 0xd2, 0x95, 0xa5, 0x92, 0xf3, 0x7f, 0x56, 0x61, 0x6b, 0x21, 0x4b,
+	0x28, 0x39, 0xca, 0xd7, 0x39, 0x71, 0xa7, 0xa7, 0xbe, 0xb2, 0xb5, 0xe7, 0x34, 0x5f, 0xe7, 0x21,
+	0xcb, 0x91, 0xb6, 0x76, 0x0a, 0x1b, 0x92, 0x20, 0xb9, 0xb1, 0x5c, 0xa9, 0xd3, 0x79, 0xae, 0xec,
+	0x7d, 0x90, 0x3c, 0xc4, 0xd2, 0xcd, 0x49, 0xb8, 0x2e, 0x5f, 0xad, 0xcd, 0x16, 0x60, 0x21, 0xf9,
+	0x53, 0xd0, 0x54, 0x74, 0x2f, 0x64, 0x7f, 0xcd, 0x36, 0xc0, 0x5a, 0x7a, 0xef, 0x25, 0x2d, 0x25,
+	0xac, 0x98, 0x5c, 0x00, 0xdb, 0x94, 0x5b, 0x06, 0x2b, 0x54, 0x6d, 0x5d, 0xc2, 0xeb, 0xb2, 0x2d,
+	0x2e, 0xcb, 0x2f, 0xb6, 0x58, 0x7c, 0xa5, 0xb1, 0x71, 0x0b, 0x6d, 0xa2, 0x59, 0xeb, 0x8e, 0xa8,
+	0x58, 0x65, 0xe9, 0xed, 0x5e, 0xc0, 0xe6, 0x73, 0xc7, 0x8d, 0xe4, 0x18, 0x35, 0xd3, 0x44, 0x89,
+	0xb7, 0xf7, 0xf8, 0x25, 0xed, 0x7d, 0x81, 0x85, 0x13, 0xda, 0xcd, 0xfa, 0xf3, 0x45, 0x60, 0xb8,
+	0xfd, 0x77, 0x0b, 0xb0, 0x9c, 0xac, 0x85, 0x31, 0x16, 0x71, 0xd8, 0x48, 0xa1, 0x55, 0x48, 0xd2,
+	0xc2, 0x0f, 0xd4, 0x43, 0x61, 0x75, 0xd1, 0x43, 0x95, 0xcf, 0xf0, 0x50, 0xe9, 0x8e, 0xa1, 0xc2,
+	0xcb, 0xe2, 0x04, 0x8a, 0xaf, 0x14, 0x27, 0x50, 0xca, 0x8a, 0x13, 0xf8, 0xee, 0x8d, 0x8e, 0x65,
+	0x34, 0xef, 0x66, 0x3a, 0x95, 0x3f, 0xbc, 0xd9, 0xa9, 0x8c, 0x22, 0xf0, 0x4d, 0x0e, 0x65, 0xcd,
+	0x1d, 0x5e, 0xb9, 0xc1, 0x9d, 0xa3, 0x39, 0xc8, 0x33, 0x1c, 0xca, 0xd5, 0xaf, 0xe1, 0x50, 0xde,
+	0xfe, 0xe3, 0x1c, 0x90, 0xc5, 0xdd, 0x41, 0x9e, 0xa0, 0xf3, 0xcf, 0xa3, 0x13, 0xc1, 0xb9, 0xbf,
+	0xf3, 0x6a, 0x3b, 0x4c, 0x12, 0x84, 0x2c, 0x4d, 0xde, 0x87, 0x35, 0xfd, 0x7a, 0x8d, 0xae, 0xfa,
+	0x37, 0x2c, 0xa2, 0x67, 0xc5, 0x46, 0x2c, 0x2d, 0x28, 0xa3, 0xf8, 0xd2, 0xa0, 0x8c, 0xd2, 0x4b,
+	0x83, 0x32, 0x96, 0x92, 0x41, 0x19, 0xdb, 0xff, 0x2e, 0x07, 0x6b, 0x19, 0x44, 0xfc, 0xcd, 0x8d,
+	0x99, 0xd1, 0x5e, 0x82, 0xad, 0xe5, 0x05, 0xed, 0xe9, 0x1c, 0xed, 0x50, 0x1a, 0x3e, 0xd9, 0x52,
+	0x84, 0xe2, 0xa4, 0x7a, 0xf8, 0x32, 0xee, 0x12, 0x97, 0xb0, 0xf4, 0xe2, 0xdb, 0x7f, 0x3f, 0x0f,
+	0x35, 0x2d, 0x93, 0xcd, 0x22, 0x92, 0xac, 0x16, 0x12, 0x88, 0x92, 0x21, 0x37, 0x5c, 0xdc, 0x03,
+	0xe1, 0xde, 0xc1, 0x7c, 0xdc, 0x5c, 0x42, 0x0c, 0xe4, 0x08, 0x3b, 0xb0, 0x26, 0x1d, 0xb3, 0x34,
+	0x8e, 0x12, 0x16, 0x67, 0x8d, 0xf0, 0xb1, 0x8b, 0x4e, 0x72, 0xfc, 0xf7, 0xa5, 0x4e, 0x19, 0xaf,
+	0x9d, 0xe6, 0xe8, 0x5a, 0x15, 0xde, 0x7d, 0xb1, 0x88, 0x8c, 0xce, 0x3f, 0x80, 0x0d, 0xe5, 0xde,
+	0x4f, 0x94, 0x40, 0x77, 0x0a, 0x91, 0x6e, 0x7c, 0xad, 0xc8, 0x8f, 0xe0, 0x6e, 0xaa, 0x4f, 0xa9,
+	0xa2, 0x18, 0xce, 0x7e, 0x3b, 0xd1, 0x3b, 0xbd, 0x86, 0xed, 0x3f, 0x0d, 0x8d, 0x04, 0xa3, 0xfc,
+	0xe6, 0x96, 0x3c, 0x6d, 0x2c, 0xc2, 0x19, 0xd5, 0x8d, 0x45, 0xdb, 0xff, 0xb3, 0x00, 0x64, 0x91,
+	0x57, 0xff, 0x22, 0xbb, 0xb0, 0x48, 0x98, 0x85, 0x0c, 0xc2, 0xfc, 0x7f, 0x26, 0x3f, 0xc4, 0x36,
+	0x4b, 0xcd, 0xbb, 0x8e, 0x9b, 0xd3, 0x50, 0x19, 0xb2, 0x17, 0x1f, 0xa7, 0x63, 0x90, 0x2a, 0x89,
+	0x1b, 0x62, 0x9a, 0x00, 0x95, 0x0a, 0x45, 0x3a, 0x81, 0x25, 0xc7, 0x1b, 0x5d, 0xf8, 0x81, 0xe0,
+	0x83, 0xbf, 0xf4, 0xb5, 0x8f, 0xcf, 0x9d, 0x16, 0x2f, 0xcf, 0xa5, 0x36, 0x4b, 0x54, 0x66, 0x7e,
+	0x00, 0x35, 0x0d, 0x4c, 0xaa, 0x50, 0x3a, 0xec, 0x1e, 0xed, 0xf6, 0x8d, 0x5b, 0xa4, 0x01, 0x55,
+	0xab, 0xd3, 0xee, 0x7f, 0xde, 0xb1, 0x3a, 0x7b, 0x46, 0x8e, 0x54, 0xa0, 0x78, 0xd8, 0x1f, 0x0c,
+	0x8d, 0xbc, 0xb9, 0x0d, 0x4d, 0x51, 0xe3, 0xa2, 0xf7, 0xe6, 0xb7, 0x8a, 0xca, 0xe6, 0xc8, 0x33,
+	0x85, 0x8a, 0xfe, 0x5d, 0xa8, 0xeb, 0xe2, 0x8d, 0xa0, 0x88, 0x54, 0x80, 0x07, 0x53, 0xce, 0x7d,
+	0x8d, 0x57, 0xb7, 0x01, 0xdd, 0xfb, 0x63, 0x55, 0x2c, 0x9f, 0x90, 0x5b, 0x33, 0xfc, 0xa4, 0x5c,
+	0xf9, 0x49, 0x90, 0xe1, 0xff, 0x07, 0xcb, 0x49, 0x4f, 0x85, 0xe0, 0x48, 0x59, 0x0a, 0x27, 0x2b,
+	0x9d, 0x70, 0x5d, 0x90, 0x1f, 0x81, 0x91, 0xf6, 0x74, 0x08, 0xe1, 0xf9, 0x86, 0xf2, 0x2b, 0x6e,
+	0xd2, 0xf9, 0x41, 0x0e, 0x60, 0x3d, 0x4b, 0xc0, 0xe3, 0xf4, 0x71, 0xb3, 0x91, 0x82, 0x2c, 0x0a,
+	0x71, 0xe4, 0x13, 0xe1, 0xf1, 0x2a, 0xf1, 0xe5, 0x7f, 0x2b, 0xd9, 0xbe, 0x36, 0xd9, 0x3b, 0xf8,
+	0x4f, 0xf3, 0x7d, 0x5d, 0x02, 0xc4, 0x30, 0x62, 0x40, 0xbd, 0x7f, 0xdc, 0xe9, 0xd9, 0xed, 0x83,
+	0x56, 0xaf, 0xd7, 0x39, 0x34, 0x6e, 0x11, 0x02, 0xcb, 0x3c, 0x46, 0x61, 0x4f, 0xc1, 0x72, 0x0c,
+	0x26, 0x3c, 0x8f, 0x12, 0x96, 0x27, 0xeb, 0x60, 0x74, 0x7b, 0x29, 0x68, 0x81, 0x34, 0x61, 0xfd,
+	0xb8, 0x83, 0x61, 0x0d, 0x89, 0x7a, 0x8b, 0x4c, 0x69, 0x10, 0xc3, 0x65, 0x4a, 0xc3, 0x17, 0xce,
+	0x64, 0x42, 0x23, 0xb1, 0x0f, 0xa4, 0x2c, 0xfd, 0x37, 0x72, 0xb0, 0x91, 0xca, 0x88, 0xdd, 0x05,
+	0x28, 0x49, 0x27, 0x65, 0xe8, 0x3a, 0x07, 0xca, 0xdd, 0xf4, 0x2e, 0xac, 0x2a, 0xeb, 0x55, 0xea,
+	0x54, 0x32, 0x54, 0x86, 0x44, 0x7e, 0x1f, 0xd6, 0x34, 0x23, 0x58, 0x8a, 0x57, 0x10, 0x2d, 0x4b,
+	0x14, 0x30, 0xb7, 0xd4, 0xa5, 0x99, 0x54, 0xaf, 0xc7, 0xb0, 0x99, 0xce, 0x88, 0x1d, 0x82, 0xc9,
+	0xfe, 0xca, 0x24, 0x79, 0x94, 0x22, 0x84, 0x64, 0x6f, 0xf5, 0x05, 0x97, 0xcd, 0xff, 0xce, 0x12,
+	0x90, 0x9f, 0xcc, 0x69, 0x70, 0xcd, 0x2f, 0x6b, 0x85, 0x2f, 0x8b, 0x48, 0x96, 0x96, 0x96, 0xfc,
+	0x2b, 0x5d, 0xc8, 0xcc, 0xba, 0x10, 0x59, 0x7c, 0xf9, 0x85, 0xc8, 0xd2, 0xcb, 0x2e, 0x44, 0xbe,
+	0x09, 0x0d, 0xf7, 0xdc, 0xf3, 0x19, 0x2b, 0x64, 0x92, 0x70, 0xd8, 0x5c, 0xba, 0x5f, 0x78, 0x50,
+	0xb7, 0xea, 0x02, 0xc8, 0xe4, 0xe0, 0x90, 0x7c, 0x16, 0x23, 0xd1, 0xf1, 0x39, 0xbf, 0x14, 0xac,
+	0x33, 0xc1, 0xce, 0xf8, 0x9c, 0x0a, 0xc3, 0x12, 0xd7, 0x34, 0x64, 0x61, 0x06, 0x0f, 0xc9, 0x5b,
+	0xb0, 0x1c, 0xfa, 0x73, 0xa6, 0x58, 0xc8, 0x69, 0x40, 0x8f, 0x60, 0x1d, 0xa1, 0xc7, 0xd2, 0x3f,
+	0xbc, 0x36, 0x0f, 0xa9, 0x3d, 0x75, 0xc3, 0x90, 0x89, 0x67, 0x23, 0xdf, 0x8b, 0x02, 0x7f, 0x22,
+	0x9c, 0x7c, 0xab, 0xf3, 0x90, 0x1e, 0x61, 0x4e, 0x1b, 0x33, 0xc8, 0xf7, 0xe2, 0x2e, 0xcd, 0x1c,
+	0x37, 0x08, 0x9b, 0xc0, 0xbb, 0x24, 0x47, 0xca, 0xe5, 0x77, 0xc7, 0x0d, 0x54, 0x5f, 0x58, 0x22,
+	0x4c, 0x5d, 0xd4, 0xac, 0xa5, 0x2f, 0x6a, 0xfe, 0x7a, 0xf6, 0x45, 0x4d, 0x0c, 0x4b, 0x7a, 0x24,
+	0xaa, 0x5e, 0x5c, 0xe2, 0xaf, 0x75, 0x5f, 0x73, 0xf1, 0xfe, 0xe9, 0xf2, 0xd7, 0xb9, 0x7f, 0xba,
+	0x92, 0x75, 0xff, 0xf4, 0x03, 0xa8, 0xf1, 0x9b, 0x81, 0xf6, 0x05, 0x0f, 0x4e, 0x44, 0xa7, 0xa5,
+	0xa1, 0x5f, 0x1d, 0x3c, 0x70, 0xbd, 0xc8, 0x82, 0x40, 0xfe, 0x0c, 0x17, 0xaf, 0x82, 0xae, 0xfe,
+	0x02, 0xaf, 0x82, 0x8a, 0x1b, 0x8c, 0x3b, 0x50, 0x91, 0xeb, 0x44, 0x08, 0x14, 0xcf, 0x02, 0x7f,
+	0x2a, 0x1d, 0x25, 0xec, 0x37, 0x59, 0x86, 0x7c, 0xe4, 0x8b, 0xc2, 0xf9, 0xc8, 0x37, 0xff, 0x7f,
+	0xa8, 0x69, 0xa4, 0x46, 0xde, 0x40, 0xbb, 0x24, 0xd3, 0xcd, 0x84, 0x6c, 0x89, 0xb3, 0x58, 0x15,
+	0xd0, 0xee, 0x98, 0xf1, 0x9b, 0xb1, 0x1b, 0x50, 0x7e, 0x69, 0xdb, 0x0e, 0xe8, 0x25, 0x0d, 0x42,
+	0xe9, 0xb8, 0x32, 0x54, 0x86, 0x85, 0x70, 0xf3, 0xd7, 0x60, 0x2d, 0xb1, 0xb6, 0x82, 0x45, 0xbc,
+	0x05, 0x4b, 0x7c, 0xde, 0x64, 0x74, 0x44, 0xf2, 0x4a, 0xa6, 0xc8, 0xe3, 0x17, 0xd4, 0xd1, 0xe7,
+	0x66, 0xcf, 0x02, 0xff, 0x94, 0x37, 0x92, 0xb3, 0x6a, 0x02, 0x76, 0x1c, 0xf8, 0xa7, 0xe6, 0x1f,
+	0x14, 0xa0, 0x70, 0xe0, 0xcf, 0xf4, 0x80, 0xc6, 0xdc, 0x42, 0x40, 0xa3, 0x50, 0x38, 0x6d, 0xa5,
+	0x50, 0x0a, 0x99, 0x9d, 0x7b, 0x9b, 0xa4, 0x52, 0xf9, 0x00, 0x96, 0x19, 0x9f, 0x88, 0x7c, 0xa6,
+	0xb1, 0x3f, 0x77, 0x02, 0x14, 0x88, 0x31, 0x3e, 0xb8, 0xee, 0x4c, 0xa3, 0xa1, 0xbf, 0x8f, 0x70,
+	0xb2, 0x0e, 0x05, 0xa5, 0xbe, 0xf0, 0x6c, 0x96, 0x24, 0x9b, 0xb0, 0xc4, 0xaf, 0x1f, 0x5c, 0x0b,
+	0xef, 0xbe, 0x48, 0x91, 0xef, 0xc0, 0x5a, 0xb2, 0x5e, 0x64, 0x45, 0x42, 0x36, 0xd2, 0x2b, 0xe6,
+	0x3c, 0xe9, 0x36, 0x30, 0x3e, 0x82, 0x38, 0x22, 0x8a, 0xe8, 0x8c, 0x52, 0x9e, 0xa5, 0x31, 0xbd,
+	0x4a, 0x82, 0xe9, 0xdd, 0x83, 0x5a, 0x34, 0xb9, 0xb4, 0x67, 0xce, 0xf5, 0xc4, 0x77, 0xc6, 0x62,
+	0x7f, 0x43, 0x34, 0xb9, 0x3c, 0x46, 0x08, 0x79, 0x1f, 0x60, 0x3a, 0x9b, 0x89, 0xbd, 0xc7, 0x3d,
+	0x28, 0x31, 0x29, 0x1f, 0x1d, 0x1f, 0x23, 0xc9, 0x59, 0xd5, 0xe9, 0x6c, 0x86, 0x3f, 0xc9, 0x1e,
+	0x2c, 0x67, 0x5e, 0xac, 0xbe, 0x2b, 0xc3, 0xc4, 0xfd, 0xd9, 0x4e, 0xc6, 0xe6, 0x6c, 0x8c, 0x74,
+	0xd8, 0xf6, 0x8f, 0x80, 0xfc, 0x09, 0xaf, 0x37, 0x0f, 0xa1, 0xaa, 0xfa, 0xa7, 0xdf, 0x0e, 0xe6,
+	0xf7, 0x5f, 0x6a, 0x89, 0xdb, 0xc1, 0xad, 0xf1, 0x38, 0x60, 0x7c, 0x11, 0x0f, 0x4c, 0xc5, 0xf2,
+	0x41, 0x3b, 0x31, 0xc5, 0x05, 0x0b, 0xf3, 0xbf, 0xe6, 0xa0, 0x84, 0x57, 0x95, 0xdf, 0x86, 0x15,
+	0xc4, 0x57, 0xc1, 0xa1, 0x22, 0x26, 0x00, 0xcf, 0xdd, 0xa1, 0x88, 0x0b, 0x65, 0xdb, 0x42, 0x7b,
+	0xbe, 0x21, 0xaf, 0x56, 0x5e, 0x7b, 0xc2, 0xe1, 0x1e, 0x54, 0x55, 0xd3, 0x1a, 0xe9, 0x54, 0x64,
+	0xcb, 0xe4, 0x75, 0x28, 0x5e, 0xf8, 0x33, 0x69, 0xf9, 0x81, 0x78, 0x26, 0x2d, 0x0e, 0x8f, 0xfb,
+	0xc2, 0xda, 0x88, 0x2f, 0x7e, 0x14, 0x44, 0x5f, 0x58, 0x23, 0x9c, 0x0c, 0x16, 0xc7, 0xb8, 0x94,
+	0x31, 0xc6, 0x13, 0x58, 0x61, 0x7c, 0x40, 0x0b, 0x4c, 0xb8, 0xf9, 0xd0, 0xfc, 0x36, 0x93, 0xf0,
+	0x46, 0x93, 0xf9, 0x98, 0xea, 0xb6, 0x37, 0x1e, 0xe9, 0x27, 0xe0, 0x52, 0xb2, 0x36, 0x7f, 0x27,
+	0x87, 0xfc, 0x85, 0xd5, 0x4b, 0x1e, 0x40, 0xd1, 0x93, 0x41, 0x0c, 0xb1, 0x1c, 0xa7, 0x2e, 0x22,
+	0x31, 0x3c, 0x8b, 0x63, 0xb0, 0xa5, 0xe3, 0xae, 0x7f, 0xbd, 0xf6, 0x86, 0x55, 0xf3, 0xe6, 0x53,
+	0x65, 0xba, 0xfa, 0x96, 0x1c, 0x56, 0xca, 0xec, 0x83, 0xa3, 0x57, 0xdb, 0x74, 0x47, 0x0b, 0x19,
+	0x2c, 0x26, 0x4e, 0x4c, 0x29, 0x05, 0x8e, 0xcf, 0xa9, 0x16, 0x2a, 0xf8, 0xbb, 0x79, 0x68, 0x24,
+	0x7a, 0xc4, 0x63, 0x26, 0xd9, 0x01, 0x80, 0x8e, 0x25, 0xb1, 0xde, 0xc0, 0x40, 0x42, 0x50, 0xd7,
+	0xe6, 0x29, 0x9f, 0x98, 0x27, 0x15, 0x85, 0x54, 0xd0, 0xa3, 0x90, 0x1e, 0x41, 0x35, 0x7e, 0xb6,
+	0x23, 0xd9, 0x25, 0xd6, 0x9e, 0xbc, 0x8e, 0x15, 0x23, 0xc5, 0x71, 0x4b, 0x25, 0x3d, 0x6e, 0xe9,
+	0x07, 0x5a, 0x98, 0xcb, 0x12, 0xaf, 0xc6, 0xcc, 0x9a, 0xd1, 0x5f, 0x48, 0x90, 0x8b, 0xf9, 0x19,
+	0xd4, 0xb4, 0xce, 0xeb, 0xa1, 0x22, 0xb9, 0x44, 0xa8, 0x88, 0xba, 0x4e, 0x99, 0x8f, 0xaf, 0x53,
+	0x9a, 0x7f, 0x2e, 0x0f, 0x0d, 0xb6, 0xbf, 0x5c, 0xef, 0xfc, 0xd8, 0x9f, 0xb8, 0x23, 0xee, 0x68,
+	0x52, 0x3b, 0x4c, 0x08, 0x5a, 0x72, 0x9f, 0x89, 0x2d, 0x86, 0x72, 0x96, 0x7e, 0x97, 0x1c, 0x99,
+	0xb4, 0xba, 0x4b, 0x6e, 0x42, 0x83, 0x31, 0x46, 0xee, 0x32, 0x8a, 0x1f, 0xff, 0xb0, 0x6a, 0x67,
+	0x94, 0xee, 0x3a, 0x21, 0x72, 0xc8, 0xef, 0xc0, 0x1a, 0xc3, 0xe1, 0xd7, 0x68, 0xa7, 0xee, 0x64,
+	0xe2, 0xc6, 0x37, 0xad, 0x0a, 0x96, 0x71, 0x46, 0xa9, 0xe5, 0x44, 0xf4, 0x88, 0x65, 0x88, 0xb7,
+	0x42, 0x2a, 0x63, 0x37, 0x74, 0x4e, 0xe3, 0xc8, 0x56, 0x95, 0xe6, 0xee, 0x69, 0xe7, 0x4a, 0x73,
+	0x4f, 0x2f, 0x89, 0x4b, 0x58, 0xce, 0x95, 0x72, 0x4f, 0xa7, 0x28, 0xa9, 0x9c, 0xa6, 0x24, 0xf3,
+	0x9f, 0xe7, 0xa1, 0xa6, 0x91, 0xe5, 0xab, 0x9c, 0xae, 0x77, 0x17, 0x1c, 0x83, 0x55, 0xdd, 0x07,
+	0xf8, 0x66, 0xb2, 0xc9, 0x82, 0xba, 0x8e, 0xa3, 0x13, 0xf0, 0x1d, 0xa8, 0xb2, 0x5d, 0xf7, 0x01,
+	0x37, 0xc1, 0x8a, 0xb7, 0x7a, 0x38, 0xe0, 0x78, 0x7e, 0x2a, 0x33, 0x1f, 0xf3, 0xcc, 0x52, 0x9c,
+	0xf9, 0x98, 0x65, 0xbe, 0x28, 0x1c, 0xff, 0x63, 0xa8, 0x8b, 0x5a, 0xf9, 0x9a, 0xf2, 0xe1, 0xc6,
+	0xbb, 0x3e, 0xb1, 0xde, 0x56, 0x0d, 0x9b, 0xc3, 0xc5, 0x17, 0x05, 0x1f, 0xcb, 0x82, 0x95, 0x97,
+	0x15, 0x7c, 0x8c, 0x09, 0x73, 0x5f, 0xdd, 0x70, 0xe0, 0x01, 0x66, 0x92, 0x8f, 0xbd, 0x0f, 0x6b,
+	0x92, 0x5d, 0xcd, 0x3d, 0xc7, 0xf3, 0xfc, 0xb9, 0x37, 0xa2, 0xf2, 0x46, 0x25, 0x11, 0x59, 0x27,
+	0x71, 0x8e, 0x39, 0x56, 0xd7, 0xf3, 0x31, 0x50, 0xed, 0x21, 0x94, 0x50, 0x2e, 0x47, 0xe1, 0x23,
+	0x9b, 0x71, 0x21, 0x0a, 0x79, 0x00, 0x25, 0x14, 0xcf, 0xf3, 0x37, 0x32, 0x1b, 0x44, 0x30, 0x5b,
+	0x40, 0x58, 0xc1, 0x23, 0x1a, 0x05, 0xee, 0x28, 0x8c, 0x2f, 0x6b, 0x96, 0x98, 0xfe, 0x89, 0x6d,
+	0xc5, 0x96, 0xdb, 0x18, 0x93, 0xeb, 0xa8, 0x88, 0xc3, 0x0e, 0xa6, 0xb5, 0x44, 0x1d, 0x42, 0x5c,
+	0x9a, 0xc0, 0xe6, 0x29, 0x8d, 0x9e, 0x53, 0xea, 0x79, 0x4c, 0x18, 0x1a, 0x51, 0x2f, 0x0a, 0x9c,
+	0x09, 0x5b, 0x24, 0x1c, 0xc1, 0x87, 0x0b, 0xb5, 0xc6, 0x36, 0x90, 0xdd, 0xb8, 0x60, 0x5b, 0x95,
+	0x43, 0xde, 0xb1, 0x71, 0x9a, 0x95, 0xb7, 0xfd, 0xab, 0xb0, 0x7d, 0x73, 0xa1, 0x8c, 0x8b, 0xda,
+	0x0f, 0x92, 0x5c, 0x45, 0xf9, 0x01, 0x27, 0xbe, 0x13, 0x61, 0x6f, 0x74, 0xce, 0xd2, 0x83, 0x9a,
+	0x96, 0x13, 0x9f, 0xfd, 0x39, 0x2e, 0xdc, 0x61, 0x82, 0x9d, 0x48, 0x9e, 0x1f, 0x4c, 0xb9, 0xdf,
+	0x6d, 0x6c, 0xc7, 0xb5, 0xe7, 0xac, 0x95, 0x18, 0xce, 0x43, 0x23, 0xcc, 0x1d, 0x58, 0xe1, 0x92,
+	0xbd, 0x76, 0xd0, 0xbd, 0x48, 0x18, 0x34, 0xd7, 0x81, 0xf4, 0x90, 0x77, 0xe9, 0x41, 0x7b, 0xff,
+	0xa1, 0x00, 0x35, 0x0d, 0xcc, 0x4e, 0x23, 0x1e, 0xe9, 0x68, 0x8f, 0x5d, 0x67, 0x4a, 0xa5, 0x93,
+	0xb3, 0x61, 0x35, 0x38, 0x74, 0x4f, 0x00, 0xd9, 0x59, 0xec, 0x5c, 0x9e, 0xdb, 0xfe, 0x3c, 0xb2,
+	0xc7, 0xf4, 0x3c, 0xa0, 0xb2, 0x97, 0x75, 0xe7, 0xf2, 0xbc, 0x3f, 0x8f, 0xf6, 0x38, 0x8c, 0x61,
+	0x31, 0x5e, 0xa2, 0x61, 0x89, 0xc0, 0xb7, 0xa9, 0x73, 0x15, 0x63, 0x89, 0x08, 0x51, 0xa4, 0xcc,
+	0xa2, 0x8a, 0x10, 0x45, 0x6d, 0x31, 0x7d, 0x80, 0x96, 0x16, 0x0f, 0xd0, 0xef, 0xc1, 0x26, 0x1e,
+	0xa0, 0x82, 0x35, 0xdb, 0xa9, 0x9d, 0xbc, 0xce, 0x73, 0xc5, 0x20, 0x35, 0xb1, 0xd7, 0x60, 0x23,
+	0x90, 0x6c, 0x29, 0x74, 0x7f, 0x8a, 0x8c, 0x2c, 0x67, 0xb1, 0x91, 0x89, 0xca, 0x07, 0xee, 0x4f,
+	0x29, 0xc3, 0xe4, 0x21, 0x36, 0x3a, 0xa6, 0xb8, 0x6c, 0x33, 0x75, 0xbd, 0x34, 0xa6, 0x73, 0x95,
+	0xc4, 0xac, 0x0a, 0x4c, 0xe7, 0x4a, 0xc7, 0xfc, 0x10, 0xb6, 0xa6, 0x74, 0xec, 0x3a, 0xc9, 0x6a,
+	0xed, 0x58, 0x70, 0x5b, 0xc7, 0x6c, 0xad, 0xcc, 0x00, 0x15, 0x77, 0x36, 0x1b, 0x3f, 0xf5, 0xa7,
+	0xa7, 0x2e, 0xca, 0x2c, 0x18, 0xf4, 0x53, 0xb4, 0x96, 0xbd, 0xf9, 0xf4, 0x57, 0x38, 0x98, 0x15,
+	0x09, 0xcd, 0x06, 0xd4, 0x06, 0x91, 0x3f, 0x93, 0xcb, 0xbc, 0x0c, 0x75, 0x4c, 0x8a, 0x6b, 0xca,
+	0x77, 0xe0, 0x36, 0x67, 0x09, 0x43, 0x7f, 0xe6, 0x4f, 0xfc, 0xf3, 0xeb, 0x84, 0x1d, 0xef, 0x5f,
+	0xe7, 0x60, 0x2d, 0x91, 0x2b, 0xd8, 0xeb, 0xf7, 0x90, 0x9f, 0xa9, 0x4b, 0x96, 0xb9, 0xc4, 0x0d,
+	0x1b, 0xb6, 0x5e, 0x88, 0x88, 0xcc, 0x4c, 0x5e, 0xbc, 0x6c, 0xc5, 0xef, 0xa9, 0xc8, 0x82, 0xc8,
+	0x52, 0x9a, 0x8b, 0x2c, 0x45, 0x94, 0x97, 0x2f, 0xad, 0xc8, 0x2a, 0x7e, 0x49, 0x5c, 0x88, 0x1a,
+	0x8b, 0x21, 0x17, 0x92, 0x57, 0x26, 0x74, 0x9b, 0x9f, 0xec, 0x41, 0x6c, 0x08, 0x0c, 0xcd, 0xbf,
+	0x97, 0x03, 0x88, 0x7b, 0xc7, 0x2f, 0x6d, 0x28, 0xb9, 0x25, 0xc7, 0xe3, 0x6d, 0x35, 0x19, 0xe5,
+	0x0d, 0xa8, 0xab, 0xd0, 0xec, 0x58, 0x12, 0xaa, 0x49, 0x18, 0x13, 0x87, 0xde, 0x81, 0x95, 0xf3,
+	0x89, 0x7f, 0xca, 0x25, 0x56, 0x21, 0xb7, 0x60, 0xd0, 0xdb, 0x32, 0x82, 0xa5, 0x34, 0x12, 0xcb,
+	0x4d, 0xc5, 0xcc, 0xe8, 0x6d, 0x5d, 0x0a, 0x32, 0xff, 0x4a, 0x5e, 0xc5, 0x7f, 0xc6, 0x33, 0xf1,
+	0x62, 0xf5, 0xee, 0xe7, 0x89, 0xa5, 0x79, 0x91, 0x7b, 0xf1, 0x33, 0x58, 0x0e, 0xf0, 0x50, 0x92,
+	0x27, 0x56, 0xf1, 0x05, 0x27, 0x56, 0x23, 0x48, 0x48, 0x3a, 0xdf, 0x06, 0xc3, 0x19, 0x5f, 0xd2,
+	0x20, 0x72, 0xb9, 0xb5, 0x9e, 0xcb, 0xc7, 0x22, 0xe2, 0x52, 0x83, 0x73, 0x41, 0xf4, 0x1d, 0x58,
+	0x11, 0x57, 0xe7, 0x15, 0xa6, 0x78, 0xb8, 0x2b, 0x06, 0x33, 0x44, 0xf3, 0x1f, 0xc9, 0x80, 0xd3,
+	0xe4, 0xea, 0xbe, 0x78, 0x56, 0xf4, 0x11, 0xe6, 0x17, 0x1d, 0xa8, 0x82, 0x90, 0x84, 0x13, 0x40,
+	0xf0, 0x23, 0x04, 0x0a, 0x17, 0x40, 0x72, 0x5a, 0x8b, 0xaf, 0x32, 0xad, 0xe6, 0xbf, 0xc9, 0x41,
+	0xf9, 0xc0, 0x9f, 0x1d, 0xb8, 0x78, 0x6d, 0x81, 0x6f, 0x13, 0xe5, 0xa3, 0x5a, 0x62, 0x49, 0x1e,
+	0xf8, 0xf3, 0x82, 0xcb, 0x87, 0x99, 0x62, 0x5e, 0x23, 0x29, 0xe6, 0xfd, 0x00, 0xee, 0x70, 0x17,
+	0x60, 0xe0, 0xcf, 0xfc, 0x80, 0x6d, 0x55, 0x67, 0x82, 0xe2, 0x9e, 0xef, 0x45, 0x17, 0x92, 0x77,
+	0xde, 0x3e, 0xa3, 0xf4, 0x58, 0xc3, 0x38, 0x52, 0x08, 0xfc, 0xe2, 0xf1, 0x24, 0xba, 0xb4, 0x51,
+	0x43, 0x17, 0xf2, 0x28, 0x72, 0xd4, 0x15, 0x96, 0xd1, 0xe1, 0x70, 0x2e, 0x91, 0x9a, 0x9f, 0x40,
+	0x55, 0x19, 0x7b, 0xc8, 0xbb, 0x50, 0xbd, 0xf0, 0x67, 0xc2, 0x22, 0x94, 0x4b, 0x5c, 0xd0, 0x14,
+	0xa3, 0xb6, 0x2a, 0x17, 0xf8, 0x23, 0x34, 0xff, 0xa0, 0x0c, 0xe5, 0xae, 0x77, 0xe9, 0xbb, 0x23,
+	0x1e, 0xb2, 0x3a, 0xa5, 0x53, 0x5f, 0xbe, 0xdf, 0xc1, 0x7e, 0xf3, 0xd8, 0xac, 0xf8, 0xf9, 0xad,
+	0x82, 0x88, 0xcd, 0x52, 0x0f, 0x6f, 0x6d, 0xc0, 0x52, 0xa0, 0xbf, 0x9f, 0x55, 0x0a, 0x78, 0xa0,
+	0xbf, 0x3a, 0x2f, 0x4b, 0xda, 0xab, 0x28, 0xac, 0x2e, 0x8c, 0x26, 0xe4, 0x53, 0x86, 0x97, 0x87,
+	0xab, 0x1c, 0xc2, 0x27, 0xec, 0x35, 0x28, 0x8b, 0xfb, 0x90, 0x78, 0x3b, 0x0b, 0x23, 0xf3, 0x05,
+	0x88, 0x53, 0x43, 0x40, 0xd1, 0x85, 0xab, 0x04, 0xd9, 0x82, 0x55, 0x97, 0xc0, 0x3d, 0x46, 0x6b,
+	0xf7, 0xa0, 0x86, 0xf8, 0x88, 0x52, 0x11, 0x91, 0x9e, 0x1c, 0xc4, 0x11, 0x32, 0x9e, 0xa1, 0xab,
+	0x66, 0x3e, 0x43, 0xc7, 0x63, 0x92, 0x15, 0x97, 0xc5, 0x21, 0x02, 0x3e, 0x3e, 0xa6, 0xc1, 0xe5,
+	0xdb, 0x8e, 0xc2, 0xa6, 0x82, 0xf7, 0xea, 0xa5, 0x4d, 0xe5, 0x4d, 0x68, 0x9c, 0x39, 0x93, 0xc9,
+	0xa9, 0x33, 0x7a, 0x86, 0xa6, 0x80, 0x3a, 0x5a, 0x3f, 0x25, 0x90, 0xdb, 0x02, 0xee, 0x41, 0x4d,
+	0x5b, 0x65, 0x1e, 0xc6, 0x59, 0xb4, 0x20, 0x5e, 0xdf, 0xb4, 0x85, 0x6f, 0xf9, 0x15, 0x2c, 0x7c,
+	0x5a, 0x38, 0xeb, 0x4a, 0x32, 0x9c, 0xf5, 0x0e, 0xe7, 0xa6, 0x22, 0xe4, 0xd0, 0xc0, 0x97, 0xae,
+	0x9c, 0xf1, 0x98, 0x87, 0x1c, 0x72, 0x43, 0x16, 0x4e, 0x1e, 0xe6, 0xaf, 0xa2, 0x2e, 0x81, 0x30,
+	0x44, 0xb9, 0x8b, 0x66, 0xea, 0x99, 0xe3, 0x8e, 0xf9, 0xed, 0x0a, 0xb4, 0x1e, 0x94, 0x9d, 0x69,
+	0x74, 0xec, 0xb8, 0x63, 0x72, 0x1f, 0xea, 0x32, 0x9b, 0x9f, 0x8e, 0x6b, 0x38, 0xff, 0x22, 0x7b,
+	0x80, 0xaf, 0x46, 0x28, 0x8c, 0xa9, 0xba, 0x18, 0x6f, 0xd5, 0x04, 0x0a, 0xa7, 0x83, 0x0f, 0x78,
+	0x94, 0x4f, 0x44, 0xf9, 0xd5, 0xf7, 0xe5, 0xc7, 0x77, 0x54, 0xf0, 0x01, 0xa7, 0x52, 0xf9, 0x1f,
+	0x9d, 0x63, 0x88, 0xc9, 0x84, 0x3b, 0xf4, 0xd1, 0x6d, 0x26, 0xe4, 0x5f, 0x81, 0xca, 0x7d, 0x74,
+	0x88, 0x40, 0x3e, 0xd1, 0xf4, 0xd7, 0x26, 0x47, 0x7e, 0x2d, 0x55, 0xff, 0x4d, 0xb7, 0xcf, 0xee,
+	0x02, 0xb8, 0x21, 0x3b, 0x65, 0x42, 0xea, 0x8d, 0xf9, 0x0d, 0xf6, 0x8a, 0x55, 0x75, 0xc3, 0xa7,
+	0x08, 0xf8, 0x66, 0x15, 0xdb, 0x16, 0xd4, 0xf5, 0x61, 0x92, 0x0a, 0x14, 0xfb, 0xc7, 0x9d, 0x9e,
+	0x71, 0x8b, 0xd4, 0xa0, 0x3c, 0xe8, 0x0c, 0x87, 0x87, 0xdc, 0xd3, 0x57, 0x87, 0x8a, 0xba, 0x9f,
+	0x9a, 0x67, 0xa9, 0x56, 0xbb, 0xdd, 0x39, 0x1e, 0x76, 0xf6, 0x8c, 0xc2, 0x8f, 0x8b, 0x95, 0xbc,
+	0x51, 0x30, 0xff, 0xb0, 0x00, 0x35, 0x6d, 0x16, 0x5e, 0xcc, 0x8c, 0xef, 0x02, 0x70, 0x4d, 0x32,
+	0x8e, 0x48, 0x2d, 0x5a, 0x55, 0x06, 0xc1, 0xc5, 0xd7, 0x7d, 0x14, 0xf8, 0x84, 0x88, 0xf2, 0x51,
+	0xbc, 0x09, 0x0d, 0x7c, 0xe4, 0x43, 0xf7, 0xd7, 0x96, 0xac, 0x3a, 0x02, 0x05, 0xab, 0xe6, 0xb7,
+	0xdd, 0x39, 0x12, 0xbf, 0x47, 0x28, 0x5e, 0x21, 0x42, 0x10, 0xbf, 0x49, 0xc8, 0xaf, 0x81, 0x86,
+	0xfe, 0xe4, 0x92, 0x22, 0x06, 0x4a, 0x84, 0x35, 0x01, 0x1b, 0x8a, 0x97, 0x04, 0x04, 0x3f, 0xd4,
+	0xae, 0x5b, 0x97, 0xac, 0x3a, 0x02, 0x45, 0x43, 0xdf, 0x91, 0x04, 0x84, 0xd1, 0x2b, 0x5b, 0x8b,
+	0xd4, 0x90, 0x20, 0x9e, 0xc3, 0x05, 0x33, 0x62, 0x95, 0x13, 0xc6, 0xb7, 0x16, 0xcb, 0xbd, 0xdc,
+	0x9c, 0x48, 0xde, 0x05, 0x32, 0x9d, 0xcd, 0xec, 0x0c, 0x03, 0x5f, 0xd1, 0x5a, 0x99, 0xce, 0x66,
+	0x43, 0xcd, 0xfe, 0xf5, 0x0d, 0xd8, 0x1e, 0xbf, 0x02, 0xd2, 0x62, 0x1b, 0x98, 0x77, 0x51, 0xa9,
+	0x62, 0x31, 0x5b, 0xce, 0xe9, 0x6c, 0x39, 0x83, 0xfb, 0xe5, 0x33, 0xb9, 0xdf, 0x8b, 0xf8, 0x84,
+	0xb9, 0x0f, 0xb5, 0x63, 0xed, 0xad, 0xc3, 0xfb, 0xec, 0x84, 0x90, 0xaf, 0x1c, 0xe2, 0xd9, 0x81,
+	0x36, 0xc5, 0x40, 0x3c, 0x6e, 0xa8, 0xf5, 0x26, 0xaf, 0xf5, 0xc6, 0xfc, 0x3b, 0x39, 0x7c, 0x1b,
+	0x4a, 0x75, 0x3e, 0x7e, 0x5e, 0x51, 0xba, 0xdf, 0xe2, 0x57, 0x11, 0x6a, 0xd2, 0xed, 0x26, 0x1e,
+	0x34, 0xe0, 0x5d, 0xb3, 0xfd, 0xb3, 0xb3, 0x90, 0xca, 0x18, 0x8f, 0x1a, 0x87, 0xf5, 0x39, 0x48,
+	0x0a, 0xdf, 0x4c, 0xc2, 0x77, 0xb1, 0xfe, 0x50, 0x04, 0x76, 0x30, 0xe1, 0xfb, 0xc8, 0xb9, 0x12,
+	0xad, 0x86, 0x4c, 0x04, 0x11, 0xfe, 0x01, 0x79, 0x2b, 0x58, 0xa5, 0xcd, 0xbf, 0x29, 0x1e, 0x6e,
+	0x48, 0xcf, 0xef, 0x43, 0xa8, 0xa8, 0x5a, 0x93, 0x27, 0xac, 0xc4, 0x54, 0xf9, 0xec, 0x1c, 0xe7,
+	0xc6, 0x90, 0x44, 0x8f, 0x71, 0x73, 0x71, 0x1f, 0x4f, 0x57, 0xeb, 0xf5, 0x7b, 0x40, 0xce, 0xdc,
+	0x20, 0x8d, 0x8c, 0x9b, 0xcd, 0xe0, 0x39, 0x1a, 0xb6, 0x79, 0x02, 0x6b, 0x92, 0x4b, 0x68, 0x1a,
+	0x41, 0x72, 0xf1, 0x72, 0x2f, 0x61, 0xf2, 0xf9, 0x05, 0x26, 0x6f, 0xfe, 0x66, 0x09, 0xca, 0xf2,
+	0xdd, 0xd0, 0xac, 0xb7, 0x2e, 0xab, 0xc9, 0xb7, 0x2e, 0x9b, 0x89, 0x17, 0xd0, 0xf8, 0xd2, 0x8b,
+	0xf3, 0xfe, 0x9d, 0xf4, 0x91, 0xad, 0xf9, 0x2a, 0x12, 0xc7, 0xb6, 0xf0, 0x55, 0x94, 0x92, 0xbe,
+	0x8a, 0xac, 0xf7, 0x3f, 0x51, 0xf4, 0x5c, 0x78, 0xff, 0xf3, 0x0e, 0xa0, 0x1c, 0xa1, 0x05, 0xb7,
+	0x55, 0x38, 0x40, 0xdc, 0x6c, 0xd7, 0xc4, 0x8e, 0x4a, 0x5a, 0xec, 0x78, 0x65, 0x91, 0xe0, 0x7b,
+	0xb0, 0x84, 0x8f, 0xc0, 0x88, 0x5b, 0xce, 0xf2, 0xe0, 0x10, 0x73, 0x25, 0xff, 0xe3, 0x8d, 0x07,
+	0x4b, 0xe0, 0xea, 0x8f, 0xe9, 0xd5, 0x12, 0x8f, 0xe9, 0xe9, 0x3e, 0x94, 0x7a, 0xd2, 0x87, 0xf2,
+	0x00, 0x0c, 0x35, 0x71, 0xdc, 0x22, 0xe9, 0x85, 0xe2, 0x8a, 0xe4, 0xb2, 0x84, 0x33, 0x6e, 0xd8,
+	0x0b, 0xe3, 0x83, 0x6f, 0x39, 0x71, 0xf0, 0x31, 0x5e, 0xd5, 0x8a, 0x22, 0x3a, 0x9d, 0x45, 0xf2,
+	0xe0, 0xd3, 0x9e, 0x5c, 0xc5, 0x95, 0xc7, 0x3b, 0x1c, 0x72, 0x79, 0x91, 0x3a, 0x76, 0x61, 0xf9,
+	0xcc, 0x71, 0x27, 0xf3, 0x80, 0xda, 0x01, 0x75, 0x42, 0xdf, 0xe3, 0x9b, 0x3f, 0x3e, 0x83, 0xc5,
+	0x10, 0xf7, 0x11, 0xc7, 0xe2, 0x28, 0x56, 0xe3, 0x4c, 0x4f, 0xf2, 0x9b, 0x50, 0xfa, 0x4c, 0xb0,
+	0x23, 0x4b, 0x5c, 0x96, 0xc6, 0x58, 0x95, 0x6e, 0xcf, 0xde, 0x3f, 0xec, 0x3e, 0x39, 0x18, 0x1a,
+	0x39, 0x96, 0x1c, 0x9c, 0xb4, 0xdb, 0x9d, 0xce, 0x1e, 0x3f, 0xc2, 0x00, 0x96, 0xf6, 0x5b, 0xdd,
+	0x43, 0x71, 0x80, 0x15, 0x8d, 0x92, 0xf9, 0xcf, 0xf2, 0x50, 0xd3, 0x46, 0x43, 0x3e, 0x54, 0x8b,
+	0x80, 0xaf, 0x2b, 0xdc, 0x5d, 0x1c, 0xf1, 0x8e, 0xe4, 0xf0, 0xda, 0x2a, 0xa8, 0xc7, 0x55, 0xf3,
+	0x37, 0x3e, 0xae, 0x4a, 0xde, 0x86, 0x15, 0x07, 0x6b, 0x50, 0x93, 0x2e, 0x8c, 0xfb, 0x02, 0x2c,
+	0xe6, 0xfc, 0x6d, 0xf1, 0xd2, 0x83, 0x38, 0xa6, 0x18, 0x5e, 0x51, 0x06, 0x6d, 0xaa, 0x93, 0x8a,
+	0xaf, 0x4d, 0x59, 0xcc, 0x8c, 0x70, 0xc6, 0xab, 0x03, 0x5f, 0xcc, 0x97, 0xcc, 0xc6, 0xeb, 0x91,
+	0x1a, 0x85, 0xd7, 0x2d, 0x95, 0x36, 0x3f, 0x02, 0x88, 0xc7, 0x93, 0x9c, 0xbe, 0x5b, 0xc9, 0xe9,
+	0xcb, 0x69, 0xd3, 0x97, 0x37, 0xff, 0xa1, 0x60, 0x5d, 0x62, 0x2d, 0x94, 0xa9, 0xef, 0x3b, 0x20,
+	0x8d, 0x8f, 0x36, 0x0f, 0xf2, 0x9e, 0x4d, 0x68, 0x24, 0x6f, 0x78, 0xae, 0x8a, 0x9c, 0xae, 0xca,
+	0x58, 0x60, 0xb5, 0xf9, 0x45, 0x56, 0xfb, 0x06, 0xd4, 0xf9, 0xd3, 0x61, 0xa2, 0x21, 0xc1, 0xae,
+	0x6a, 0x53, 0xe7, 0x4a, 0xb6, 0x9d, 0xe0, 0xb1, 0xc5, 0x14, 0x8f, 0xfd, 0x5b, 0x39, 0x7c, 0x67,
+	0x26, 0xee, 0x68, 0xcc, 0x64, 0x55, 0x9d, 0x49, 0x26, 0x2b, 0x50, 0x2d, 0x95, 0x7f, 0x03, 0xe3,
+	0xcc, 0x67, 0x33, 0xce, 0x6c, 0x96, 0x5c, 0xc8, 0x64, 0xc9, 0xe6, 0x36, 0x34, 0xf7, 0x28, 0x9b,
+	0x8a, 0xd6, 0x64, 0x92, 0x9a, 0x4b, 0xf3, 0x0e, 0xdc, 0xce, 0xc8, 0x13, 0x56, 0x9b, 0x9f, 0xc0,
+	0x46, 0x0b, 0x5f, 0x97, 0xf8, 0xa6, 0x6e, 0x60, 0x9a, 0x4d, 0xd8, 0x4c, 0x57, 0x29, 0x1a, 0xdb,
+	0x87, 0xd5, 0x3d, 0x7a, 0x3a, 0x3f, 0x3f, 0xa4, 0x97, 0x71, 0x43, 0x04, 0x8a, 0xe1, 0x85, 0xff,
+	0x5c, 0x2c, 0x2e, 0xff, 0xcd, 0xc3, 0x32, 0x19, 0x8e, 0x1d, 0xce, 0xe8, 0x48, 0x5a, 0xee, 0x39,
+	0x64, 0x30, 0xa3, 0x23, 0xf3, 0x43, 0x20, 0x7a, 0x3d, 0x62, 0x25, 0x98, 0x5a, 0x35, 0x3f, 0xb5,
+	0xc3, 0xeb, 0x30, 0xa2, 0x53, 0x79, 0xf3, 0x10, 0xc2, 0xf9, 0xe9, 0x00, 0x21, 0xe6, 0x3b, 0x50,
+	0x3f, 0x76, 0xae, 0x2d, 0xfa, 0x95, 0xb8, 0xe0, 0xb7, 0x05, 0xe5, 0x99, 0x73, 0xcd, 0xf8, 0xa9,
+	0x72, 0xe2, 0xf1, 0x6c, 0xf3, 0x1f, 0x17, 0x61, 0x09, 0x31, 0xc9, 0x7d, 0x7c, 0xba, 0xdc, 0xf5,
+	0x38, 0x3f, 0x93, 0x27, 0x8b, 0x06, 0x5a, 0x38, 0x7c, 0xf2, 0x8b, 0x87, 0x8f, 0xb0, 0x38, 0xca,
+	0xf7, 0xc7, 0xa4, 0xbb, 0xc5, 0x9b, 0x4f, 0xe5, 0xa3, 0x63, 0xc9, 0x27, 0x16, 0x8a, 0xf1, 0x93,
+	0xf7, 0x78, 0xbd, 0x3c, 0xe9, 0x10, 0x8f, 0x95, 0x37, 0xec, 0x9d, 0x3c, 0x53, 0xc5, 0xb9, 0xa3,
+	0x83, 0x32, 0x35, 0xc4, 0xb2, 0xbc, 0xb5, 0x9a, 0xd4, 0x10, 0x17, 0x34, 0xc1, 0xca, 0xcb, 0x35,
+	0x41, 0x34, 0x45, 0xbe, 0x40, 0x13, 0x84, 0x57, 0xd0, 0x04, 0x5f, 0xc1, 0x19, 0x7d, 0x1b, 0x2a,
+	0x5c, 0x50, 0xd2, 0x8e, 0x21, 0x26, 0x20, 0xb1, 0x63, 0xe8, 0x63, 0x4d, 0x57, 0xc2, 0x48, 0x18,
+	0xed, 0x1c, 0xb0, 0xe8, 0x57, 0xbf, 0x18, 0x27, 0xdf, 0x97, 0x50, 0x16, 0x50, 0x46, 0xd0, 0x9e,
+	0x33, 0x95, 0x2f, 0x59, 0xf2, 0xdf, 0x6c, 0xda, 0xf8, 0xbb, 0x73, 0x5f, 0xcd, 0xdd, 0x80, 0x8e,
+	0xe5, 0xeb, 0x57, 0x2e, 0xdf, 0xa3, 0x0c, 0xc2, 0x06, 0xc8, 0xf4, 0x36, 0xcf, 0x7f, 0xee, 0x09,
+	0xde, 0x53, 0x76, 0xc3, 0xa7, 0x2c, 0x69, 0x12, 0x30, 0xf8, 0xbb, 0xb7, 0x33, 0x3f, 0x90, 0xa7,
+	0xbc, 0xf9, 0xb3, 0x1c, 0x18, 0x62, 0x77, 0xa9, 0x3c, 0x5d, 0x6d, 0x2a, 0xdd, 0x14, 0xb8, 0xf1,
+	0xe2, 0xb7, 0xac, 0x4c, 0x68, 0x70, 0x6b, 0x91, 0x3a, 0xf2, 0xd1, 0xda, 0x55, 0x63, 0xc0, 0x7d,
+	0x71, 0xec, 0xbf, 0x0e, 0x35, 0x19, 0x34, 0x3e, 0x75, 0x27, 0xf2, 0xeb, 0x16, 0x18, 0x35, 0x7e,
+	0xe4, 0x4e, 0xa4, 0xc4, 0x10, 0x38, 0xe2, 0x16, 0x75, 0x8e, 0x4b, 0x0c, 0x96, 0x13, 0x51, 0xf3,
+	0x9f, 0xe6, 0x60, 0x55, 0x1b, 0x8a, 0xd8, 0xb7, 0xdf, 0x87, 0xba, 0x7a, 0x70, 0x9a, 0x2a, 0x51,
+	0x75, 0x2b, 0xc9, 0x68, 0xe2, 0x62, 0xb5, 0x91, 0x82, 0x84, 0xac, 0x33, 0x63, 0xe7, 0x1a, 0x23,
+	0x9b, 0xe7, 0x53, 0xa9, 0x0d, 0x8e, 0x9d, 0xeb, 0x7d, 0x4a, 0x07, 0xf3, 0x29, 0xd3, 0xf5, 0x9f,
+	0x53, 0xfa, 0x4c, 0x21, 0x20, 0xfb, 0x04, 0x06, 0x13, 0x18, 0x26, 0x34, 0xa6, 0xbe, 0x17, 0x5d,
+	0x28, 0x14, 0x21, 0xa6, 0x73, 0x20, 0xe2, 0x98, 0xbf, 0x9f, 0x87, 0x35, 0xb4, 0x49, 0x0a, 0x5b,
+	0xb0, 0x60, 0x5d, 0x4d, 0x58, 0x42, 0xf3, 0x2c, 0x32, 0xaf, 0x83, 0x5b, 0x96, 0x48, 0x93, 0xef,
+	0xbd, 0xa2, 0x1d, 0x55, 0x5e, 0xd4, 0xbe, 0x61, 0xfa, 0x0b, 0x8b, 0xd3, 0x7f, 0xf3, 0xf4, 0x66,
+	0x79, 0x86, 0x4b, 0x59, 0x9e, 0xe1, 0x57, 0xf1, 0xc7, 0x2e, 0x5c, 0x29, 0x2e, 0x2f, 0x3e, 0x9c,
+	0xf9, 0x21, 0x6c, 0x25, 0x70, 0x38, 0xb7, 0x76, 0xcf, 0x5c, 0x2a, 0x9f, 0xe6, 0x59, 0xd7, 0xb0,
+	0x07, 0x32, 0x6f, 0xb7, 0x0c, 0xa5, 0x70, 0xe4, 0xcf, 0xa8, 0xb9, 0x09, 0xeb, 0xc9, 0x59, 0x15,
+	0xc7, 0xc4, 0x6f, 0xe7, 0xa0, 0x29, 0xe2, 0x78, 0x5c, 0xef, 0xfc, 0xc0, 0x0d, 0x23, 0x3f, 0x50,
+	0x0f, 0x33, 0xdf, 0x05, 0xc0, 0x2f, 0x6d, 0x70, 0xe5, 0x5b, 0x3c, 0x46, 0xc3, 0x21, 0x5c, 0xf5,
+	0xbe, 0x0d, 0x15, 0xea, 0x8d, 0x31, 0x13, 0xa9, 0xa1, 0x4c, 0xbd, 0xb1, 0x54, 0xdc, 0x17, 0x8e,
+	0xd2, 0x46, 0x52, 0x48, 0x10, 0xcf, 0x2a, 0xb0, 0xd9, 0xa1, 0x97, 0xfc, 0x48, 0x2f, 0xaa, 0x67,
+	0x15, 0x8e, 0x9c, 0x2b, 0x1e, 0x15, 0x1b, 0x9a, 0x7f, 0x35, 0x0f, 0x2b, 0x71, 0xff, 0xf0, 0x61,
+	0x99, 0x17, 0x3f, 0x91, 0x73, 0x5f, 0x90, 0x83, 0xcb, 0x14, 0x1e, 0xcd, 0x52, 0x5b, 0xc1, 0xcd,
+	0xd9, 0xf5, 0x88, 0x09, 0x35, 0x89, 0xe1, 0xcf, 0x23, 0xed, 0xb1, 0xcf, 0x2a, 0xa2, 0xf4, 0xe7,
+	0x11, 0xd3, 0x50, 0x99, 0xaa, 0xee, 0x7a, 0x42, 0x47, 0x2c, 0x39, 0xd3, 0xa8, 0xcb, 0x3f, 0xe7,
+	0xc2, 0xc0, 0xac, 0x18, 0x2e, 0x24, 0xc3, 0x62, 0xf8, 0x06, 0x2a, 0x2c, 0xb8, 0x72, 0x5c, 0x59,
+	0xd1, 0xa5, 0x79, 0x7c, 0x81, 0x5e, 0x49, 0xf3, 0xaf, 0x43, 0x0d, 0x2b, 0x8f, 0x6f, 0x90, 0xf3,
+	0x97, 0xb7, 0xa2, 0xae, 0xc7, 0xf3, 0x85, 0xd5, 0xcc, 0x9f, 0x27, 0x6c, 0x05, 0x80, 0x4d, 0xf1,
+	0x30, 0x99, 0xbf, 0x98, 0x83, 0xdb, 0x19, 0xcb, 0x26, 0x76, 0x79, 0x1b, 0x56, 0xcf, 0x54, 0xa6,
+	0x9c, 0x5d, 0xdc, 0xea, 0x9b, 0x92, 0xad, 0x26, 0xe7, 0xd4, 0x32, 0xce, 0x92, 0x80, 0x58, 0x4b,
+	0xc5, 0x15, 0x4c, 0xbc, 0x4f, 0xc0, 0x45, 0x22, 0x5c, 0x46, 0x54, 0x10, 0x8f, 0x61, 0xbb, 0x73,
+	0xc5, 0x38, 0x86, 0x0a, 0xad, 0x1d, 0x3d, 0x9b, 0x4b, 0xef, 0x55, 0xca, 0x22, 0x9f, 0x7b, 0x25,
+	0x8b, 0xfc, 0x18, 0xef, 0x22, 0xab, 0xba, 0x7e, 0x9e, 0x4a, 0xf8, 0x01, 0xca, 0xca, 0x9c, 0xf2,
+	0x2a, 0xe4, 0x43, 0x05, 0x0c, 0x84, 0x95, 0x9a, 0x21, 0xac, 0x1c, 0xcd, 0x27, 0x91, 0xdb, 0x56,
+	0x20, 0xf2, 0x3d, 0x51, 0x86, 0xb7, 0x23, 0x67, 0x2d, 0xb3, 0x21, 0x50, 0x0d, 0xf1, 0xc9, 0x9a,
+	0xb2, 0x8a, 0xec, 0xc5, 0xf6, 0x56, 0xa6, 0xc9, 0x16, 0xcc, 0xdb, 0xb0, 0x15, 0xa7, 0x70, 0xda,
+	0xe4, 0x51, 0xf3, 0xb7, 0x73, 0x18, 0x82, 0x8f, 0x79, 0x03, 0xcf, 0x99, 0x85, 0x17, 0x7e, 0x44,
+	0x3a, 0xb0, 0x16, 0xba, 0xde, 0xf9, 0x84, 0xea, 0xd5, 0x87, 0x62, 0x12, 0x36, 0x92, 0x7d, 0xc3,
+	0xa2, 0xa1, 0xb5, 0x8a, 0x25, 0xe2, 0xda, 0x42, 0xb2, 0x7b, 0x53, 0x27, 0x63, 0xb2, 0x48, 0xcd,
+	0xc6, 0x62, 0xe7, 0xbb, 0xb0, 0x9c, 0x6c, 0x88, 0x7c, 0x2c, 0xae, 0xf0, 0xc7, 0xbd, 0x2a, 0xa4,
+	0xee, 0x37, 0xc7, 0x04, 0x51, 0x8b, 0xe7, 0x3e, 0x34, 0xff, 0x72, 0x0e, 0x9a, 0x16, 0x65, 0x94,
+	0xab, 0xf5, 0x52, 0xd2, 0xcc, 0xf7, 0x17, 0x6a, 0xbd, 0x79, 0xac, 0xf2, 0x65, 0x00, 0xd9, 0xa3,
+	0xf7, 0x6e, 0x5c, 0x8c, 0x83, 0x5b, 0x0b, 0x23, 0xda, 0xad, 0xc0, 0x12, 0xa2, 0x98, 0x5b, 0xb0,
+	0x21, 0xfa, 0x23, 0xfb, 0x12, 0xbb, 0x5b, 0x13, 0x2d, 0x26, 0xdc, 0xad, 0xdb, 0xd0, 0xc4, 0xbb,
+	0xba, 0xfa, 0x20, 0x44, 0xc1, 0x3d, 0x20, 0x47, 0xce, 0xc8, 0x09, 0x7c, 0xdf, 0x3b, 0xa6, 0x81,
+	0x08, 0x68, 0xe6, 0x12, 0x26, 0xf7, 0x46, 0x4a, 0x51, 0x18, 0x53, 0xf2, 0x89, 0x63, 0xdf, 0x93,
+	0xf1, 0x5b, 0x98, 0x32, 0x2d, 0x58, 0xdb, 0x75, 0x9e, 0x51, 0x59, 0x93, 0x9c, 0xa2, 0xcf, 0xa0,
+	0x36, 0x53, 0x95, 0xca, 0x79, 0x97, 0xef, 0x94, 0x2c, 0x36, 0x6b, 0xe9, 0xd8, 0xe6, 0x63, 0x58,
+	0x4f, 0xd6, 0x29, 0x58, 0xc7, 0x36, 0x54, 0xa6, 0x02, 0x26, 0x7a, 0xa7, 0xd2, 0xe6, 0x6f, 0x55,
+	0xa0, 0x2c, 0x34, 0x55, 0xb2, 0x03, 0xc5, 0x91, 0x8c, 0xa1, 0x8b, 0xdf, 0xf0, 0x12, 0xb9, 0xf2,
+	0x7f, 0x9b, 0x47, 0xd2, 0x31, 0x3c, 0xf2, 0x19, 0x2c, 0x27, 0xdd, 0xc8, 0xa9, 0x97, 0x00, 0x92,
+	0xfe, 0xdf, 0xc6, 0x28, 0xe5, 0x30, 0xac, 0xc6, 0x87, 0x23, 0xca, 0x0c, 0x95, 0x0b, 0xed, 0xf4,
+	0xf4, 0x3d, 0x26, 0x6f, 0x87, 0x17, 0x8e, 0xfd, 0xf8, 0xc3, 0x8f, 0xc4, 0x53, 0x00, 0x35, 0x0e,
+	0x1c, 0x5c, 0x38, 0x8f, 0x3f, 0xfc, 0x28, 0x2d, 0x49, 0x8b, 0x87, 0x00, 0x34, 0x49, 0x7a, 0x1d,
+	0x4a, 0xf8, 0x8e, 0x2f, 0x06, 0x43, 0x61, 0x82, 0x3c, 0x82, 0x75, 0x69, 0xfc, 0x10, 0x61, 0xeb,
+	0xc8, 0x05, 0x2b, 0x78, 0x53, 0x50, 0xe4, 0x0d, 0x78, 0x16, 0x9a, 0x4b, 0x36, 0x61, 0xe9, 0x22,
+	0x7e, 0x98, 0xb9, 0x61, 0x89, 0x94, 0xf9, 0xfb, 0x25, 0xa8, 0x69, 0x93, 0x42, 0xea, 0x50, 0xb1,
+	0x3a, 0x83, 0x8e, 0xf5, 0x79, 0x67, 0xcf, 0xb8, 0x45, 0x1e, 0xc0, 0x5b, 0xdd, 0x5e, 0xbb, 0x6f,
+	0x59, 0x9d, 0xf6, 0xd0, 0xee, 0x5b, 0xb6, 0x7c, 0x49, 0xee, 0xb8, 0xf5, 0xe5, 0x51, 0xa7, 0x37,
+	0xb4, 0xf7, 0x3a, 0xc3, 0x56, 0xf7, 0x70, 0x60, 0xe4, 0xc8, 0x6b, 0xd0, 0x8c, 0x31, 0x65, 0x76,
+	0xeb, 0xa8, 0x7f, 0xd2, 0x1b, 0x1a, 0x79, 0x72, 0x0f, 0xee, 0xec, 0x77, 0x7b, 0xad, 0x43, 0x3b,
+	0xc6, 0x69, 0x1f, 0x0e, 0x3f, 0xb7, 0x3b, 0xbf, 0x7c, 0xdc, 0xb5, 0xbe, 0x34, 0x0a, 0x59, 0x08,
+	0x07, 0xc3, 0xc3, 0xb6, 0xac, 0xa1, 0x48, 0x6e, 0xc3, 0x06, 0x22, 0x60, 0x11, 0x7b, 0xd8, 0xef,
+	0xdb, 0x83, 0x7e, 0xbf, 0x67, 0x94, 0xc8, 0x2a, 0x34, 0xba, 0xbd, 0xcf, 0x5b, 0x87, 0xdd, 0x3d,
+	0xdb, 0xea, 0xb4, 0x0e, 0x8f, 0x8c, 0x25, 0xb2, 0x06, 0x2b, 0x69, 0xbc, 0x32, 0xab, 0x42, 0xe2,
+	0xf5, 0x7b, 0xdd, 0x7e, 0xcf, 0xfe, 0xbc, 0x63, 0x0d, 0xba, 0xfd, 0x9e, 0x51, 0x21, 0x9b, 0x40,
+	0x92, 0x59, 0x07, 0x47, 0xad, 0xb6, 0x51, 0x25, 0x1b, 0xb0, 0x9a, 0x84, 0x3f, 0xed, 0x7c, 0x69,
+	0x00, 0x69, 0xc2, 0x3a, 0x76, 0xcc, 0xde, 0xed, 0x1c, 0xf6, 0xbf, 0xb0, 0x8f, 0xba, 0xbd, 0xee,
+	0xd1, 0xc9, 0x91, 0x51, 0xe3, 0xcf, 0x71, 0x76, 0x3a, 0x76, 0xb7, 0x37, 0x38, 0xd9, 0xdf, 0xef,
+	0xb6, 0xbb, 0x9d, 0xde, 0xd0, 0xa8, 0x63, 0xcb, 0x59, 0x03, 0x6f, 0xb0, 0x02, 0xe2, 0x6e, 0x8b,
+	0xbd, 0xd7, 0x1d, 0xb4, 0x76, 0x0f, 0x3b, 0x7b, 0xc6, 0x32, 0xb9, 0x0b, 0xb7, 0x87, 0x9d, 0xa3,
+	0xe3, 0xbe, 0xd5, 0xb2, 0xbe, 0x94, 0x77, 0x5f, 0xec, 0xfd, 0x56, 0xf7, 0xf0, 0xc4, 0xea, 0x18,
+	0x2b, 0xe4, 0x0d, 0xb8, 0x6b, 0x75, 0x7e, 0x72, 0xd2, 0xb5, 0x3a, 0x7b, 0x76, 0xaf, 0xbf, 0xd7,
+	0xb1, 0xf7, 0x3b, 0xad, 0xe1, 0x89, 0xd5, 0xb1, 0x8f, 0xba, 0x83, 0x41, 0xb7, 0xf7, 0xc4, 0x30,
+	0xc8, 0x5b, 0x70, 0x5f, 0xa1, 0xa8, 0x0a, 0x52, 0x58, 0xab, 0x6c, 0x7c, 0x72, 0x49, 0x7b, 0x9d,
+	0x5f, 0x1e, 0xda, 0xc7, 0x9d, 0x8e, 0x65, 0x10, 0xb2, 0x0d, 0x9b, 0x71, 0xf3, 0xd8, 0x80, 0x68,
+	0x7b, 0x8d, 0xe5, 0x1d, 0x77, 0xac, 0xa3, 0x56, 0x8f, 0x2d, 0x70, 0x22, 0x6f, 0x9d, 0x75, 0x3b,
+	0xce, 0x4b, 0x77, 0x7b, 0x83, 0x10, 0x58, 0xd6, 0x56, 0x65, 0xbf, 0x65, 0x19, 0x9b, 0x64, 0x05,
+	0x6a, 0x47, 0xc7, 0xc7, 0xf6, 0xb0, 0x7b, 0xd4, 0xe9, 0x9f, 0x0c, 0x8d, 0x2d, 0xb2, 0x01, 0x46,
+	0xb7, 0x37, 0xec, 0x58, 0x6c, 0xad, 0x65, 0xd1, 0xff, 0x56, 0x26, 0xeb, 0xb0, 0x22, 0x7b, 0x2a,
+	0xa1, 0x7f, 0x54, 0x26, 0x5b, 0x40, 0x4e, 0x7a, 0x56, 0xa7, 0xb5, 0xc7, 0x26, 0x4e, 0x65, 0xfc,
+	0xf7, 0xb2, 0x70, 0x29, 0xfd, 0xac, 0xa0, 0x0e, 0xeb, 0x38, 0x46, 0x23, 0xf9, 0xb5, 0x82, 0xba,
+	0xf6, 0x95, 0x81, 0x97, 0x7d, 0x73, 0x48, 0x53, 0xad, 0x0a, 0x0b, 0xaa, 0xd5, 0x82, 0xee, 0xde,
+	0xd0, 0x65, 0xbf, 0x37, 0xa1, 0x31, 0xc5, 0x2f, 0x17, 0x88, 0x67, 0xb9, 0x41, 0x04, 0x2c, 0x21,
+	0x10, 0xdf, 0xe4, 0x5e, 0xf8, 0xe8, 0x4e, 0x69, 0xf1, 0xa3, 0x3b, 0x59, 0xf2, 0xfd, 0x52, 0x96,
+	0x7c, 0xff, 0x10, 0x56, 0x91, 0x35, 0xb9, 0x9e, 0x3b, 0x95, 0x5a, 0x33, 0x4a, 0x81, 0x2b, 0x9c,
+	0x45, 0x21, 0x5c, 0xaa, 0x13, 0x52, 0xe5, 0x10, 0x2c, 0xa4, 0x2c, 0xb4, 0x8d, 0x84, 0xa6, 0x81,
+	0x9c, 0x43, 0x69, 0x1a, 0xaa, 0x05, 0xe7, 0x2a, 0x6e, 0xa1, 0xa6, 0xb5, 0x80, 0x70, 0xde, 0xc2,
+	0x43, 0x58, 0xa5, 0x57, 0x51, 0xe0, 0xd8, 0xfe, 0xcc, 0xf9, 0x6a, 0xce, 0x7d, 0xde, 0x0e, 0xd7,
+	0xe1, 0xeb, 0xd6, 0x0a, 0xcf, 0xe8, 0x73, 0xf8, 0x9e, 0x13, 0x39, 0x0f, 0xff, 0x0c, 0xd4, 0xb4,
+	0xaf, 0x5a, 0x90, 0x2d, 0x58, 0xfb, 0xa2, 0x3b, 0xec, 0x75, 0x06, 0x03, 0xfb, 0xf8, 0x64, 0xf7,
+	0x69, 0xe7, 0x4b, 0xfb, 0xa0, 0x35, 0x38, 0x30, 0x6e, 0xb1, 0x4d, 0xdb, 0xeb, 0x0c, 0x86, 0x9d,
+	0xbd, 0x04, 0x3c, 0x47, 0x5e, 0x87, 0xed, 0x93, 0xde, 0xc9, 0xa0, 0xb3, 0x67, 0x67, 0x95, 0xcb,
+	0x33, 0x2a, 0x15, 0xf9, 0x19, 0xc5, 0x0b, 0x0f, 0x7f, 0x0d, 0x96, 0x93, 0xd7, 0xc0, 0x09, 0xc0,
+	0xd2, 0x61, 0xe7, 0x49, 0xab, 0xfd, 0x25, 0x3e, 0xd8, 0x3b, 0x18, 0xb6, 0x86, 0xdd, 0xb6, 0x2d,
+	0x1e, 0xe8, 0x65, 0x1c, 0x21, 0x47, 0x6a, 0x50, 0x6e, 0xf5, 0xda, 0x07, 0x7d, 0x6b, 0x60, 0xe4,
+	0xc9, 0x6b, 0xb0, 0x25, 0x69, 0xb5, 0xdd, 0x3f, 0x3a, 0xea, 0x0e, 0x39, 0x33, 0x1c, 0x7e, 0x79,
+	0xcc, 0x48, 0xf3, 0xa1, 0x03, 0xd5, 0xf8, 0x6d, 0x61, 0xce, 0x60, 0xba, 0xc3, 0x6e, 0x6b, 0x18,
+	0x73, 0x57, 0xe3, 0x16, 0xe3, 0x5f, 0x31, 0x98, 0x3f, 0x10, 0x6c, 0xe4, 0xf0, 0xa6, 0x9c, 0x04,
+	0x62, 0xeb, 0x46, 0x9e, 0x6d, 0xaa, 0x18, 0xba, 0xdb, 0x1f, 0xb2, 0x21, 0xfc, 0x3a, 0x2c, 0x27,
+	0x9f, 0xf0, 0x25, 0x06, 0xd4, 0x59, 0xfb, 0x5a, 0x13, 0x00, 0x4b, 0xd8, 0x63, 0x23, 0x87, 0x1c,
+	0xb4, 0xdd, 0x3f, 0xea, 0xf6, 0x9e, 0x70, 0xb6, 0x6b, 0xe4, 0x19, 0xa8, 0x7f, 0x32, 0x7c, 0xd2,
+	0x57, 0xa0, 0x02, 0x2b, 0x81, 0xc3, 0x31, 0x8a, 0x0f, 0xbf, 0x82, 0xd5, 0x85, 0xc7, 0x7e, 0x59,
+	0xaf, 0xfb, 0x27, 0xc3, 0x76, 0xff, 0x48, 0x6f, 0xa7, 0x06, 0xe5, 0xf6, 0x61, 0xab, 0x7b, 0xc4,
+	0xad, 0xbe, 0x0d, 0xa8, 0x9e, 0xf4, 0x64, 0x32, 0x9f, 0x7c, 0xa6, 0xb8, 0xc0, 0x78, 0xc1, 0x7e,
+	0xd7, 0x1a, 0x0c, 0xed, 0xc1, 0xb0, 0xf5, 0xa4, 0x63, 0x14, 0x59, 0x59, 0xc9, 0x18, 0x4a, 0x0f,
+	0x3f, 0x85, 0xe5, 0x64, 0x90, 0x67, 0xd2, 0x5a, 0xbf, 0x0d, 0x9b, 0xbb, 0x9d, 0xe1, 0x17, 0x9d,
+	0x4e, 0x8f, 0x2f, 0x79, 0xbb, 0xd3, 0x1b, 0x5a, 0xad, 0xc3, 0xee, 0xf0, 0x4b, 0x23, 0xf7, 0xf0,
+	0x33, 0x30, 0xd2, 0x1e, 0xd5, 0x84, 0x0b, 0xfa, 0x45, 0xbe, 0xea, 0x87, 0xff, 0x39, 0x07, 0xeb,
+	0x59, 0xce, 0x04, 0x46, 0x98, 0x82, 0xe3, 0xb0, 0x73, 0x67, 0xd0, 0xef, 0xd9, 0xbd, 0x3e, 0x7f,
+	0xf8, 0x73, 0x1b, 0x36, 0x53, 0x19, 0x72, 0x14, 0x39, 0x72, 0x07, 0xb6, 0x16, 0x0a, 0xd9, 0x56,
+	0xff, 0x84, 0xaf, 0x65, 0x13, 0xd6, 0x53, 0x99, 0x1d, 0xcb, 0xea, 0x5b, 0x46, 0x81, 0xbc, 0x07,
+	0x0f, 0x52, 0x39, 0x8b, 0xa7, 0xad, 0x3c, 0x8c, 0x8b, 0xe4, 0x1d, 0x78, 0x73, 0x01, 0x3b, 0x3e,
+	0x90, 0xec, 0xdd, 0xd6, 0x21, 0x1b, 0x9e, 0x51, 0x7a, 0xf8, 0x0f, 0x0a, 0x00, 0xf1, 0x2d, 0x2a,
+	0xd6, 0xfe, 0x5e, 0x6b, 0xd8, 0x3a, 0xec, 0xb3, 0x3d, 0x63, 0xf5, 0x87, 0xac, 0x76, 0xab, 0xf3,
+	0x13, 0xe3, 0x56, 0x66, 0x4e, 0xff, 0x98, 0x0d, 0x68, 0x0b, 0xd6, 0x90, 0xfe, 0x0e, 0xd9, 0x30,
+	0x18, 0xb9, 0xf0, 0x37, 0x64, 0xf9, 0x91, 0x7e, 0x72, 0xbc, 0x6f, 0xf5, 0x7b, 0x43, 0x7b, 0x70,
+	0x70, 0x32, 0xdc, 0xe3, 0x2f, 0xd0, 0xb6, 0xad, 0xee, 0x31, 0xd6, 0x59, 0x7c, 0x11, 0x02, 0xab,
+	0xba, 0xc4, 0x36, 0xf8, 0x93, 0xfe, 0x60, 0xd0, 0x3d, 0xb6, 0x7f, 0x72, 0xd2, 0xb1, 0xba, 0x9d,
+	0x01, 0x2f, 0xb8, 0x94, 0x01, 0x67, 0xf8, 0x65, 0x46, 0xb3, 0xc3, 0xc3, 0xcf, 0xc5, 0x49, 0xcd,
+	0x50, 0x2b, 0x49, 0x10, 0xc3, 0xaa, 0xb2, 0xd5, 0x61, 0x47, 0x5d, 0x46, 0xcd, 0x70, 0x43, 0x1e,
+	0x2b, 0x57, 0x63, 0x87, 0xf8, 0xc2, 0xce, 0xe7, 0xc5, 0xea, 0xd9, 0x59, 0xac, 0x14, 0x3f, 0xdf,
+	0x95, 0x34, 0xb4, 0xb7, 0x67, 0xf1, 0x02, 0xcb, 0x0b, 0x50, 0x86, 0xbb, 0xc2, 0x88, 0x90, 0x9d,
+	0x85, 0x0c, 0xc5, 0x90, 0x09, 0x96, 0xb3, 0xfa, 0xf8, 0xdf, 0xde, 0x83, 0xaa, 0x8a, 0xa6, 0x26,
+	0x3f, 0x86, 0x46, 0xe2, 0x7a, 0x2b, 0x91, 0xb6, 0xce, 0xac, 0xdb, 0xb0, 0xdb, 0xaf, 0x65, 0x67,
+	0x0a, 0xb1, 0xfa, 0x48, 0x53, 0x9b, 0xb0, 0xb2, 0xd7, 0xd2, 0xaa, 0x4c, 0xa2, 0xb6, 0xbb, 0x37,
+	0xe4, 0x8a, 0xea, 0x9e, 0xf2, 0xe7, 0x6c, 0xf5, 0x8f, 0xa3, 0x92, 0xbb, 0xf1, 0xdb, 0xa2, 0x19,
+	0x1f, 0x4d, 0xdd, 0xbe, 0xbd, 0xf8, 0x19, 0x53, 0xf9, 0xdd, 0xd3, 0x3d, 0xa8, 0x69, 0xdf, 0xfc,
+	0x22, 0xb7, 0x6f, 0xfc, 0x3e, 0xd9, 0xf6, 0x76, 0x56, 0x96, 0xe8, 0xd2, 0x0f, 0xa0, 0xaa, 0xbe,
+	0xff, 0x44, 0xb6, 0xb4, 0x6f, 0x77, 0xe9, 0x5f, 0xb1, 0xda, 0x6e, 0x2e, 0x66, 0x88, 0xf2, 0x7b,
+	0x50, 0xd3, 0x3e, 0xe3, 0xa4, 0x7a, 0xb1, 0xf8, 0xa9, 0x28, 0xd5, 0x8b, 0xac, 0xaf, 0x3e, 0x1d,
+	0xc2, 0x86, 0x50, 0xce, 0x4e, 0xe9, 0xd7, 0x99, 0x9e, 0x8c, 0xaf, 0xbc, 0x3e, 0xca, 0x91, 0xcf,
+	0xa0, 0x22, 0x3f, 0xd8, 0x45, 0x36, 0xb3, 0x3f, 0x47, 0xb6, 0xbd, 0xb5, 0x00, 0x17, 0x5d, 0x69,
+	0x01, 0xc4, 0x1f, 0x88, 0x22, 0x72, 0xe0, 0x0b, 0x1f, 0x9c, 0x52, 0x2b, 0x93, 0xf1, 0x35, 0xa9,
+	0x3d, 0xa8, 0x69, 0xdf, 0x82, 0x52, 0x73, 0xb2, 0xf8, 0x1d, 0x29, 0x35, 0x27, 0x59, 0x9f, 0x8e,
+	0xfa, 0x31, 0x34, 0x12, 0x1f, 0x75, 0x52, 0x74, 0x9c, 0xf5, 0xc9, 0x28, 0x45, 0xc7, 0xd9, 0xdf,
+	0x81, 0xda, 0x83, 0x9a, 0xf6, 0x09, 0x26, 0xd5, 0xa3, 0xc5, 0xaf, 0x3d, 0xa9, 0x1e, 0x65, 0x7c,
+	0xb1, 0x89, 0xed, 0x86, 0xe4, 0xf7, 0x97, 0xd4, 0x6e, 0xc8, 0xfc, 0x90, 0x93, 0xda, 0x0d, 0xd9,
+	0x1f, 0x6d, 0x62, 0xa4, 0xa7, 0xde, 0xb1, 0x26, 0x5b, 0x1a, 0x75, 0xe8, 0x0f, 0x62, 0x2b, 0xd2,
+	0x5b, 0x7c, 0xf2, 0xfa, 0x09, 0xac, 0x29, 0xa2, 0x51, 0xaf, 0x50, 0x87, 0xaa, 0x4f, 0x99, 0x6f,
+	0x5d, 0x6f, 0x1b, 0xe9, 0xdc, 0x47, 0x39, 0xf2, 0x09, 0x94, 0xc5, 0xd3, 0xbe, 0x64, 0x23, 0xfd,
+	0xd4, 0x2f, 0x76, 0x62, 0x33, 0xfb, 0x05, 0x60, 0x72, 0xcc, 0x37, 0xb4, 0xfe, 0xf6, 0xae, 0x4e,
+	0xb1, 0x19, 0xcf, 0xf5, 0x6e, 0xbf, 0x7e, 0x53, 0x76, 0x5c, 0x63, 0xfa, 0xbd, 0xe8, 0xbb, 0x37,
+	0x3d, 0x3b, 0x91, 0xac, 0xf1, 0xa6, 0xf7, 0xb1, 0x9e, 0x40, 0x5d, 0xff, 0xfa, 0x07, 0xd1, 0xf7,
+	0x61, 0xba, 0xae, 0x3b, 0x99, 0x79, 0xa2, 0xa2, 0xcf, 0x61, 0x53, 0xcd, 0xb7, 0xfe, 0x06, 0x42,
+	0x48, 0xee, 0x65, 0xbc, 0x8c, 0x90, 0x98, 0xf5, 0xdb, 0x37, 0x3e, 0x9d, 0xf0, 0x28, 0xc7, 0x99,
+	0x6c, 0xe2, 0xc1, 0xfe, 0x98, 0xc9, 0x66, 0x7d, 0xa7, 0x20, 0x66, 0xb2, 0xd9, 0xaf, 0xfc, 0xb7,
+	0x60, 0x45, 0x7b, 0xc3, 0x61, 0x70, 0xed, 0x8d, 0x14, 0xbd, 0x2f, 0x3e, 0x8a, 0xba, 0x9d, 0x65,
+	0x22, 0x24, 0x6d, 0xa8, 0xe9, 0xcf, 0x40, 0xbc, 0xa0, 0xf8, 0x96, 0x96, 0xa5, 0xbf, 0x90, 0xf9,
+	0x28, 0x47, 0x0e, 0xc1, 0x48, 0x3f, 0xda, 0xa6, 0xb6, 0x70, 0xd6, 0x43, 0x77, 0xdb, 0xa9, 0xcc,
+	0xc4, 0x53, 0x6f, 0x8c, 0x2e, 0x12, 0x5f, 0x13, 0xf5, 0x83, 0xf4, 0x51, 0x94, 0xfc, 0xca, 0xa8,
+	0xaa, 0x2d, 0xeb, 0xfb, 0xb2, 0x0f, 0x72, 0x8f, 0x72, 0x64, 0x1f, 0xea, 0x89, 0x37, 0x8b, 0x12,
+	0x81, 0xfd, 0xa9, 0x61, 0x36, 0xf5, 0xbc, 0xd4, 0x38, 0x8f, 0x60, 0x39, 0xe9, 0xcb, 0x56, 0x1d,
+	0xcb, 0xf4, 0x9a, 0xab, 0xe5, 0xcb, 0x76, 0x80, 0x93, 0x1f, 0xe2, 0xb7, 0xb2, 0x65, 0xdc, 0x12,
+	0x59, 0xfc, 0xb6, 0xb2, 0x5a, 0x33, 0xfd, 0x4b, 0xc4, 0x66, 0xe1, 0x2f, 0xe4, 0x73, 0x7c, 0x5c,
+	0xdf, 0xc7, 0x2f, 0x55, 0xca, 0xd0, 0x15, 0xb6, 0xfe, 0xaf, 0x5a, 0x09, 0xd9, 0xc7, 0xc6, 0xc5,
+	0x77, 0x82, 0x63, 0xce, 0xbd, 0xf0, 0xed, 0xe0, 0x97, 0xf4, 0xa1, 0x85, 0x7d, 0x10, 0x65, 0x12,
+	0x34, 0xf8, 0x8a, 0x75, 0x91, 0x8f, 0x01, 0xe2, 0x78, 0x40, 0x92, 0x8a, 0x4a, 0x53, 0x1b, 0x2a,
+	0x23, 0x64, 0xb0, 0x83, 0xfb, 0x5d, 0x85, 0xc5, 0xe9, 0x47, 0x72, 0x32, 0x42, 0x2f, 0x71, 0x24,
+	0xa7, 0xab, 0xf9, 0x2e, 0x34, 0x0e, 0x7d, 0xff, 0xd9, 0x7c, 0xa6, 0x82, 0xca, 0x93, 0x31, 0x1b,
+	0x4c, 0xe7, 0xdf, 0x4e, 0x75, 0x8b, 0xb4, 0x60, 0x55, 0xb1, 0x88, 0x38, 0x2e, 0x2f, 0x89, 0x94,
+	0x60, 0x0c, 0xa9, 0x0a, 0x1e, 0xe5, 0xc8, 0x63, 0xa8, 0xef, 0xd1, 0x11, 0x7f, 0x53, 0x80, 0x47,
+	0x17, 0xac, 0x25, 0x3c, 0xd5, 0x18, 0x96, 0xb0, 0xdd, 0x48, 0x00, 0x25, 0x8b, 0x8b, 0xa3, 0x54,
+	0xf4, 0x33, 0x23, 0x19, 0xea, 0x91, 0x60, 0x71, 0x0b, 0x91, 0x2a, 0x9f, 0xc3, 0xea, 0x42, 0x1c,
+	0x88, 0xe2, 0x6e, 0x37, 0x45, 0x8f, 0x6c, 0xdf, 0xbf, 0x19, 0x41, 0xd4, 0xfb, 0x23, 0x68, 0xe0,
+	0x83, 0xa9, 0xa7, 0x14, 0xef, 0x04, 0xa6, 0x1e, 0xd4, 0xd1, 0x2f, 0x1c, 0xa6, 0x59, 0x12, 0x16,
+	0x78, 0xc2, 0x3f, 0x8e, 0xa0, 0xdd, 0xb8, 0x53, 0xeb, 0xba, 0x78, 0x0b, 0x50, 0xad, 0x6b, 0xd6,
+	0xe5, 0xbe, 0x4f, 0xa1, 0xf6, 0x84, 0x46, 0xf2, 0x0e, 0x9b, 0x92, 0x8f, 0x52, 0x97, 0xda, 0xb6,
+	0x33, 0x6e, 0x1e, 0x92, 0x8f, 0x78, 0x51, 0x75, 0x1f, 0x7b, 0x53, 0x6b, 0x45, 0x2f, 0xba, 0x92,
+	0x82, 0x33, 0xe9, 0x43, 0x7b, 0x95, 0x41, 0x75, 0x7c, 0xf1, 0x15, 0x0e, 0xd5, 0xf1, 0xac, 0x47,
+	0x1c, 0x7e, 0x88, 0x33, 0xa0, 0xdd, 0x9a, 0x8b, 0x45, 0xb0, 0xf4, 0x05, 0x3b, 0xd5, 0x7d, 0x1d,
+	0xfd, 0x43, 0x80, 0x41, 0xe4, 0xcf, 0xf6, 0x1c, 0x3a, 0xf5, 0xbd, 0x98, 0x27, 0xc4, 0xf7, 0xb5,
+	0xe2, 0x8d, 0xa8, 0x5d, 0xda, 0x22, 0x5f, 0x68, 0xb2, 0x69, 0x62, 0x49, 0xe4, 0xb2, 0xdf, 0x78,
+	0xa5, 0x4b, 0x0d, 0x27, 0xe3, 0x5a, 0x17, 0x67, 0x12, 0x10, 0x87, 0xe8, 0x28, 0x49, 0x73, 0x21,
+	0xfa, 0x47, 0xed, 0xf5, 0x8c, 0x78, 0x9e, 0x1f, 0x40, 0x35, 0x8e, 0x6d, 0xd8, 0x8a, 0x9f, 0x88,
+	0x49, 0x44, 0x42, 0x28, 0xee, 0xbd, 0x18, 0x57, 0xd0, 0x83, 0x35, 0xec, 0x8e, 0x3a, 0xfe, 0xf8,
+	0xad, 0x22, 0xf5, 0x6d, 0x8f, 0x45, 0x87, 0xbe, 0xda, 0x3f, 0x59, 0x6e, 0x69, 0xb6, 0x7f, 0x16,
+	0xdc, 0x9b, 0x6a, 0xff, 0xdc, 0xe4, 0xaf, 0x56, 0xfb, 0xe7, 0x66, 0xcf, 0x68, 0x0f, 0xd6, 0x32,
+	0x1c, 0x95, 0xe4, 0x0d, 0xa9, 0xd8, 0xdc, 0xe8, 0xc4, 0xdc, 0xce, 0x74, 0x68, 0x91, 0x21, 0x6c,
+	0x61, 0x99, 0xd6, 0x64, 0x92, 0xf2, 0x8b, 0xbd, 0xae, 0x15, 0xc8, 0xf0, 0xf5, 0x25, 0x44, 0x99,
+	0x94, 0xbf, 0xaf, 0x07, 0x46, 0xda, 0xa5, 0x44, 0x6e, 0x46, 0xdf, 0xbe, 0x97, 0x10, 0xd9, 0x17,
+	0xdd, 0x50, 0xe4, 0x73, 0xe5, 0xd8, 0x4a, 0xf5, 0xf1, 0x5e, 0xfc, 0x45, 0xa9, 0x4c, 0x37, 0x9c,
+	0xd2, 0x06, 0x32, 0xfd, 0x62, 0xe4, 0x97, 0x61, 0x2b, 0x4d, 0xd1, 0xb2, 0xe6, 0xfb, 0x59, 0xd3,
+	0x75, 0xa3, 0x28, 0x97, 0x1c, 0xd0, 0xa3, 0x1c, 0x63, 0xc4, 0xba, 0x7b, 0x4a, 0x11, 0x52, 0x86,
+	0x1f, 0x4c, 0x11, 0x52, 0x96, 0x3f, 0x6b, 0xf7, 0x9d, 0x5f, 0xf9, 0xd6, 0xb9, 0x1b, 0x5d, 0xcc,
+	0x4f, 0x77, 0x46, 0xfe, 0xf4, 0xfd, 0x89, 0x54, 0xee, 0xc5, 0x5d, 0xd3, 0xf7, 0x27, 0xde, 0xf8,
+	0x7d, 0x5e, 0xfa, 0x74, 0x69, 0x16, 0xf8, 0x91, 0xff, 0xdd, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff,
+	0x3c, 0xde, 0xb8, 0xe3, 0xbc, 0x86, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

lnrpc/rpc.proto

@@ -1249,6 +1249,79 @@ message ChannelCloseSummary {
     force closes, although only one party's close will be confirmed on chain.
     */
     Initiator close_initiator = 12;
+
+    repeated Resolution resolutions = 13;
+}
+
+enum ResolutionType{
+    TYPE_UNKNOWN = 0;
+
+    // We resolved an anchor output.
+    ANCHOR = 1;
+
+    /*
+    We are resolving an incoming htlc on chain. This if this htlc is
+    claimed, we swept the incoming htlc with the preimage. If it is timed
+    out, our peer swept the timeout path.
+    */
+    INCOMING_HTLC = 2;
+
+    /*
+    We are resolving an outgoing htlc on chain. If this htlc is claimed,
+    the remote party swept the htlc with the preimage. If it is timed out,
+    we swept it with the timeout path.
+    */
+    OUTGOING_HTLC = 3;
+
+    // We force closed and need to sweep our time locked commitment output.
+    COMMIT = 4;
+}
+
+enum ResolutionOutcome {
+    // Outcome unknown.
+    OUTCOME_UNKNOWN = 0;
+
+    // An output was claimed on chain.
+    CLAIMED = 1;
+
+    // An output was left unclaimed on chain.
+    UNCLAIMED = 2;
+
+    /*
+    ResolverOutcomeAbandoned indicates that an output that we did not
+    claim on chain, for example an anchor that we did not sweep and a
+    third party claimed on chain, or a htlc that we could not decode
+    so left unclaimed.
+    */
+    ABANDONED = 3;
+
+    /*
+    If we force closed our channel, our htlcs need to be claimed in two
+    stages. This outcome represents the broadcast of a timeout or success
+    transaction for this two stage htlc claim.
+    */
+    FIRST_STAGE = 4;
+
+    // A htlc was timed out on chain.
+    TIMEOUT = 5;
+}
+
+message Resolution {
+    // The type of output we are resolving.
+    ResolutionType resolution_type = 1;
+
+    // The outcome of our on chain action that resolved the outpoint.
+    ResolutionOutcome outcome = 2;
+
+    // The outpoint that was spent by the resolution.
+    OutPoint outpoint = 3;
+
+    // The amount that was claimed by the resolution.
+    uint64 amount_sat = 4;
+
+    // The hex-encoded transaction ID of the sweep transaction that spent the
+    // output.
+    string sweep_txid = 5;
 }
 
 message ClosedChannelsRequest {

lnrpc/rpc.swagger.json

@@ -2786,6 +2786,12 @@
         "close_initiator": {
           "$ref": "#/definitions/lnrpcInitiator",
           "description": "Close initiator indicates which party initiated the close. This value will\nbe unknown for channels that were cooperatively closed before we started\ntracking cooperative close initiators. Note that this indicates which party\ninitiated a close, and it is possible for both to initiate cooperative or\nforce closes, although only one party's close will be confirmed on chain."
+        },
+        "resolutions": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/lnrpcResolution"
+          }
         }
       }
     },
@@ -4849,6 +4855,57 @@
         }
       }
     },
+    "lnrpcResolution": {
+      "type": "object",
+      "properties": {
+        "resolution_type": {
+          "$ref": "#/definitions/lnrpcResolutionType",
+          "description": "The type of output we are resolving."
+        },
+        "outcome": {
+          "$ref": "#/definitions/lnrpcResolutionOutcome",
+          "description": "The outcome of our on chain action that resolved the outpoint."
+        },
+        "outpoint": {
+          "$ref": "#/definitions/lnrpcOutPoint",
+          "description": "The outpoint that was spent by the resolution."
+        },
+        "amount_sat": {
+          "type": "string",
+          "format": "uint64",
+          "description": "The amount that was claimed by the resolution."
+        },
+        "sweep_txid": {
+          "type": "string",
+          "description": "The hex-encoded transaction ID of the sweep transaction that spent the\noutput."
+        }
+      }
+    },
+    "lnrpcResolutionOutcome": {
+      "type": "string",
+      "enum": [
+        "OUTCOME_UNKNOWN",
+        "CLAIMED",
+        "UNCLAIMED",
+        "ABANDONED",
+        "FIRST_STAGE",
+        "TIMEOUT"
+      ],
+      "default": "OUTCOME_UNKNOWN",
+      "description": " - OUTCOME_UNKNOWN: Outcome unknown.\n - CLAIMED: An output was claimed on chain.\n - UNCLAIMED: An output was left unclaimed on chain.\n - ABANDONED: ResolverOutcomeAbandoned indicates that an output that we did not\nclaim on chain, for example an anchor that we did not sweep and a\nthird party claimed on chain, or a htlc that we could not decode\nso left unclaimed.\n - FIRST_STAGE: If we force closed our channel, our htlcs need to be claimed in two\nstages. This outcome represents the broadcast of a timeout or success\ntransaction for this two stage htlc claim.\n - TIMEOUT: A htlc was timed out on chain."
+    },
+    "lnrpcResolutionType": {
+      "type": "string",
+      "enum": [
+        "TYPE_UNKNOWN",
+        "ANCHOR",
+        "INCOMING_HTLC",
+        "OUTGOING_HTLC",
+        "COMMIT"
+      ],
+      "default": "TYPE_UNKNOWN",
+      "description": " - ANCHOR: We resolved an anchor output.\n - INCOMING_HTLC: We are resolving an incoming htlc on chain. This if this htlc is\nclaimed, we swept the incoming htlc with the preimage. If it is timed\nout, our peer swept the timeout path.\n - OUTGOING_HTLC: We are resolving an outgoing htlc on chain. If this htlc is claimed,\nthe remote party swept the htlc with the preimage. If it is timed out,\nwe swept it with the timeout path.\n - COMMIT: We force closed and need to sweep our time locked commitment output."
+    },
     "lnrpcRestoreBackupResponse": {
       "type": "object"
     },

lntest/itest/lnd_test.go

@@ -50,6 +50,7 @@ import (
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing"
+	"github.com/stretchr/testify/require"
 )
 
 var (
@@ -3512,6 +3513,13 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 		t.Fatalf("all funds should still be in limbo")
 	}
 
+	// Create a map of outpoints to expected resolutions for alice and carol
+	// which we will add reports to as we sweep outputs.
+	var (
+		aliceReports = make(map[string]*lnrpc.Resolution)
+		carolReports = make(map[string]*lnrpc.Resolution)
+	)
+
 	// The several restarts in this test are intended to ensure that when a
 	// channel is force-closed, the UTXO nursery has persisted the state of
 	// the channel in the closure process and will recover the correct state
@@ -3530,13 +3538,36 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 		expectedTxes = 2
 	}
 
-	_, err = waitForNTxsInMempool(
+	sweepTxns, err := waitForNTxsInMempool(
 		net.Miner.Node, expectedTxes, minerMempoolTimeout,
 	)
 	if err != nil {
 		t.Fatalf("failed to find commitment in miner mempool: %v", err)
 	}
 
+	// Find alice's commit sweep and anchor sweep (if present) in the
+	// mempool.
+	aliceCloseTx := waitingClose.Commitments.LocalTxid
+	_, aliceAnchor := findCommitAndAnchor(
+		t, net, sweepTxns, aliceCloseTx,
+	)
+
+	// If we expect anchors, add alice's anchor to our expected set of
+	// reports.
+	if channelType == commitTypeAnchors {
+		aliceReports[aliceAnchor.OutPoint.String()] = &lnrpc.Resolution{
+			ResolutionType: lnrpc.ResolutionType_ANCHOR,
+			Outcome:        lnrpc.ResolutionOutcome_CLAIMED,
+			SweepTxid:      aliceAnchor.SweepTx,
+			Outpoint: &lnrpc.OutPoint{
+				TxidBytes:   aliceAnchor.OutPoint.Hash[:],
+				TxidStr:     aliceAnchor.OutPoint.Hash.String(),
+				OutputIndex: aliceAnchor.OutPoint.Index,
+			},
+			AmountSat: uint64(anchorSize),
+		}
+	}
+
 	if _, err := net.Miner.Node.Generate(1); err != nil {
 		t.Fatalf("unable to generate block: %v", err)
 	}
@@ -3605,7 +3636,7 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 	// Carol's sweep tx should be in the mempool already, as her output is
 	// not timelocked. If there are anchors, we also expect Carol's anchor
 	// sweep now.
-	_, err = waitForNTxsInMempool(
+	sweepTxns, err = waitForNTxsInMempool(
 		net.Miner.Node, expectedTxes, minerMempoolTimeout,
 	)
 	if err != nil {
@@ -3613,6 +3644,27 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 			err)
 	}
 
+	// We look up the sweep txns we have found in mempool and create
+	// expected resolutions for carol.
+	carolCommit, carolAnchor := findCommitAndAnchor(
+		t, net, sweepTxns, aliceCloseTx,
+	)
+
+	// If we have anchors, add an anchor resolution for carol.
+	if channelType == commitTypeAnchors {
+		carolReports[carolAnchor.OutPoint.String()] = &lnrpc.Resolution{
+			ResolutionType: lnrpc.ResolutionType_ANCHOR,
+			Outcome:        lnrpc.ResolutionOutcome_CLAIMED,
+			SweepTxid:      carolAnchor.SweepTx,
+			AmountSat:      anchorSize,
+			Outpoint: &lnrpc.OutPoint{
+				TxidBytes:   carolAnchor.OutPoint.Hash[:],
+				TxidStr:     carolAnchor.OutPoint.Hash.String(),
+				OutputIndex: carolAnchor.OutPoint.Index,
+			},
+		}
+	}
+
 	// Currently within the codebase, the default CSV is 4 relative blocks.
 	// For the persistence test, we generate two blocks, then trigger
 	// a restart and then generate the final block that should trigger
@@ -3630,6 +3682,7 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 
 	// Alice should see the channel in her set of pending force closed
 	// channels with her funds still in limbo.
+	var aliceBalance int64
 	err = wait.NoError(func() error {
 		ctxt, _ := context.WithTimeout(ctxb, defaultTimeout)
 		pendingChanResp, err := alice.PendingChannels(
@@ -3652,6 +3705,9 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 			return err
 		}
 
+		// Make a record of the balances we expect for alice and carol.
+		aliceBalance = forceClose.Channel.LocalBalance
+
 		// At this point, the nursery should show that the commitment
 		// output has 2 block left before its CSV delay expires. In
 		// total, we have mined exactly defaultCSV blocks, so the htlc
@@ -3712,6 +3768,32 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 		}
 	}
 
+	// We expect a resolution which spends our commit output.
+	output := sweepTx.MsgTx().TxIn[0].PreviousOutPoint
+	aliceReports[output.String()] = &lnrpc.Resolution{
+		ResolutionType: lnrpc.ResolutionType_COMMIT,
+		Outcome:        lnrpc.ResolutionOutcome_CLAIMED,
+		SweepTxid:      sweepingTXID.String(),
+		Outpoint: &lnrpc.OutPoint{
+			TxidBytes:   output.Hash[:],
+			TxidStr:     output.Hash.String(),
+			OutputIndex: output.Index,
+		},
+		AmountSat: uint64(aliceBalance),
+	}
+
+	carolReports[carolCommit.OutPoint.String()] = &lnrpc.Resolution{
+		ResolutionType: lnrpc.ResolutionType_COMMIT,
+		Outcome:        lnrpc.ResolutionOutcome_CLAIMED,
+		Outpoint: &lnrpc.OutPoint{
+			TxidBytes:   carolCommit.OutPoint.Hash[:],
+			TxidStr:     carolCommit.OutPoint.Hash.String(),
+			OutputIndex: carolCommit.OutPoint.Index,
+		},
+		AmountSat: uint64(pushAmt),
+		SweepTxid: carolCommit.SweepTx,
+	}
+
 	// Check that we can find the commitment sweep in our set of known
 	// sweeps.
 	err = findSweep(ctxb, alice, sweepingTXID)
@@ -3890,6 +3972,7 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 	// the sweeper check for these timeout transactions because they are
 	// not swept by the sweeper; the nursery broadcasts the pre-signed
 	// transaction.
+	var htlcLessFees uint64
 	for _, htlcTxID := range htlcTxIDs {
 		// Fetch the sweep transaction, all input it's spending should
 		// be from the commitment transaction which was broadcast
@@ -3899,18 +3982,62 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 			t.Fatalf("unable to fetch sweep tx: %v", err)
 		}
 		// Ensure the htlc transaction only has one input.
-		if len(htlcTx.MsgTx().TxIn) != 1 {
+		inputs := htlcTx.MsgTx().TxIn
+		if len(inputs) != 1 {
 			t.Fatalf("htlc transaction should only have one txin, "+
 				"has %d", len(htlcTx.MsgTx().TxIn))
 		}
 		// Ensure the htlc transaction is spending from the commitment
 		// transaction.
-		txIn := htlcTx.MsgTx().TxIn[0]
+		txIn := inputs[0]
 		if !closingTxID.IsEqual(&txIn.PreviousOutPoint.Hash) {
 			t.Fatalf("htlc transaction not spending from commit "+
 				"tx %v, instead spending %v",
 				closingTxID, txIn.PreviousOutPoint)
 		}
+
+		outputs := htlcTx.MsgTx().TxOut
+		if len(outputs) != 1 {
+			t.Fatalf("htlc transaction should only have one "+
+				"txout, has: %v", len(outputs))
+		}
+
+		// For each htlc timeout transaction, we expect a resolver
+		// report recording this on chain resolution for both alice and
+		// carol.
+		outpoint := txIn.PreviousOutPoint
+		resolutionOutpoint := &lnrpc.OutPoint{
+			TxidBytes:   outpoint.Hash[:],
+			TxidStr:     outpoint.Hash.String(),
+			OutputIndex: outpoint.Index,
+		}
+
+		// We expect alice to have a timeout tx resolution with an
+		// amount equal to the payment amount.
+		aliceReports[outpoint.String()] = &lnrpc.Resolution{
+			ResolutionType: lnrpc.ResolutionType_OUTGOING_HTLC,
+			Outcome:        lnrpc.ResolutionOutcome_FIRST_STAGE,
+			SweepTxid:      htlcTx.Hash().String(),
+			Outpoint:       resolutionOutpoint,
+			AmountSat:      uint64(paymentAmt),
+		}
+
+		// We expect carol to have a resolution with an incoming htlc
+		// timeout which reflects the full amount of the htlc. It has
+		// no spend tx, because carol stops monitoring the htlc once
+		// it has timed out.
+		carolReports[outpoint.String()] = &lnrpc.Resolution{
+			ResolutionType: lnrpc.ResolutionType_INCOMING_HTLC,
+			Outcome:        lnrpc.ResolutionOutcome_TIMEOUT,
+			SweepTxid:      "",
+			Outpoint:       resolutionOutpoint,
+			AmountSat:      uint64(paymentAmt),
+		}
+
+		// We record the htlc amount less fees here, so that we know
+		// what value to expect for the second stage of our htlc
+		// htlc resolution.
+		htlcLessFees = uint64(outputs[0].Value)
 	}
 
 	// With the htlc timeout txns still in the mempool, we restart Alice to
@@ -4022,6 +4149,12 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 		t.Fatalf("htlc transaction should have %d txin, "+
 			"has %d", numInvoices, len(htlcSweepTx.MsgTx().TxIn))
 	}
+	outputCount := len(htlcSweepTx.MsgTx().TxOut)
+	if outputCount != 1 {
+		t.Fatalf("htlc sweep transaction should have one output, has: "+
+			"%v", outputCount)
+	}
+
 	// Ensure that each output spends from exactly one htlc timeout txn.
 	for _, txIn := range htlcSweepTx.MsgTx().TxIn {
 		outpoint := txIn.PreviousOutPoint.Hash
@@ -4038,6 +4171,21 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 			t.Fatalf("htlc sweep tx has multiple spends from "+
 				"outpoint %v", outpoint)
 		}
+
+		// Since we have now swept our htlc timeout tx, we expect to
+		// have timeout resolutions for each of our htlcs.
+		output := txIn.PreviousOutPoint
+		aliceReports[output.String()] = &lnrpc.Resolution{
+			ResolutionType: lnrpc.ResolutionType_OUTGOING_HTLC,
+			Outcome:        lnrpc.ResolutionOutcome_TIMEOUT,
+			SweepTxid:      htlcSweepTx.Hash().String(),
+			Outpoint: &lnrpc.OutPoint{
+				TxidBytes:   output.Hash[:],
+				TxidStr:     output.Hash.String(),
+				OutputIndex: output.Index,
+			},
+			AmountSat: uint64(htlcLessFees),
+		}
 	}
 
 	// Check that we can find the htlc sweep in our set of sweeps.
@@ -4150,6 +4298,96 @@ func channelForceClosureTest(net *lntest.NetworkHarness, t *harnessTest,
 			carolExpectedBalance,
 			carolBalResp.ConfirmedBalance)
 	}
+
+	// Finally, we check that alice and carol have the set of resolutions
+	// we expect.
+	assertReports(ctxb, t, alice, op, aliceReports)
+	assertReports(ctxb, t, carol, op, carolReports)
+}
+
+type sweptOutput struct {
+	OutPoint wire.OutPoint
+	SweepTx  string
+}
+
+// findCommitAndAnchor looks for a commitment sweep and anchor sweep in the
+// mempool. Our anchor output is identified by having multiple inputs, because
+// we have to bring another input to add fees to the anchor. Note that the
+// anchor swept output may be nil if the channel did not have anchors.
+func findCommitAndAnchor(t *harnessTest, net *lntest.NetworkHarness,
+	sweepTxns []*chainhash.Hash, closeTx string) (*sweptOutput, *sweptOutput) {
+
+	var commitSweep, anchorSweep *sweptOutput
+
+	for _, tx := range sweepTxns {
+		sweepTx, err := net.Miner.Node.GetRawTransaction(tx)
+		require.NoError(t.t, err)
+
+		// We expect our commitment sweep to have a single input, and,
+		// our anchor sweep to have more inputs (because the wallet
+		// needs to add balance to the anchor amount). We find their
+		// sweep txids here to setup appropriate resolutions. We also
+		// need to find the outpoint for our resolution, which we do by
+		// matching the inputs to the sweep to the close transaction.
+		inputs := sweepTx.MsgTx().TxIn
+		if len(inputs) == 1 {
+			commitSweep = &sweptOutput{
+				OutPoint: inputs[0].PreviousOutPoint,
+				SweepTx:  tx.String(),
+			}
+		} else {
+			// Since we have more than one input, we run through
+			// them to find the outpoint that spends from the close
+			// tx. This will be our anchor output.
+			for _, txin := range inputs {
+				outpointStr := txin.PreviousOutPoint.Hash.String()
+				if outpointStr == closeTx {
+					anchorSweep = &sweptOutput{
+						OutPoint: txin.PreviousOutPoint,
+						SweepTx:  tx.String(),
+					}
+				}
+			}
+		}
+	}
+
+	return commitSweep, anchorSweep
+}
+
+// assertReports checks that the count of resolutions we have present per
+// type matches a set of expected resolutions.
+func assertReports(ctxb context.Context, t *harnessTest,
+	node *lntest.HarnessNode, channelPoint wire.OutPoint,
+	expected map[string]*lnrpc.Resolution) {
+
+	// Get our node's closed channels.
+	ctxt, cancel := context.WithTimeout(ctxb, defaultTimeout)
+	defer cancel()
+
+	closed, err := node.ClosedChannels(
+		ctxt, &lnrpc.ClosedChannelsRequest{},
+	)
+	require.NoError(t.t, err)
+
+	var resolutions []*lnrpc.Resolution
+	for _, close := range closed.Channels {
+		if close.ChannelPoint == channelPoint.String() {
+			resolutions = close.Resolutions
+			break
+		}
+	}
+
+	require.NotNil(t.t, resolutions)
+	require.Equal(t.t, len(expected), len(resolutions))
+
+	for _, res := range resolutions {
+		outPointStr := fmt.Sprintf("%v:%v", res.Outpoint.TxidStr,
+			res.Outpoint.OutputIndex)
+
+		expected, ok := expected[outPointStr]
+		require.True(t.t, ok)
+		require.Equal(t.t, expected, res)
+	}
 }
 
 // findSweep looks up a sweep in a nodes list of broadcast sweeps.

rpcserver.go

@@ -3528,7 +3528,7 @@ func (r *rpcServer) createRPCClosedChannel(
 		closeType = lnrpc.ChannelCloseSummary_ABANDONED
 	}
 
-	return &lnrpc.ChannelCloseSummary{
+	channel := &lnrpc.ChannelCloseSummary{
 		Capacity:          int64(dbChannel.Capacity),
 		RemotePubkey:      nodeID,
 		CloseHeight:       dbChannel.CloseHeight,
@@ -3541,7 +3541,95 @@ func (r *rpcServer) createRPCClosedChannel(
 		ClosingTxHash:     dbChannel.ClosingTXID.String(),
 		OpenInitiator:     openInit,
 		CloseInitiator:    closeInitiator,
-	}, nil
+	}
+
+	reports, err := r.server.chanDB.FetchChannelReports(
+		*activeNetParams.GenesisHash, &dbChannel.ChanPoint,
+	)
+	switch err {
+	// If the channel does not have its resolver outcomes stored,
+	// ignore it.
+	case channeldb.ErrNoChainHashBucket:
+		fallthrough
+	case channeldb.ErrNoChannelSummaries:
+		return channel, nil
+
+	// If there is no error, fallthrough the switch to process reports.
+	case nil:
+
+	// If another error occurred, return it.
+	default:
+		return nil, err
+	}
+
+	for _, report := range reports {
+		rpcResolution, err := rpcChannelResolution(report)
+		if err != nil {
+			return nil, err
+		}
+
+		channel.Resolutions = append(channel.Resolutions, rpcResolution)
+	}
+
+	return channel, nil
+}
+
+func rpcChannelResolution(report *channeldb.ResolverReport) (*lnrpc.Resolution,
+	error) {
+
+	res := &lnrpc.Resolution{
+		AmountSat: uint64(report.Amount),
+		Outpoint: &lnrpc.OutPoint{
+			OutputIndex: report.OutPoint.Index,
+			TxidStr:     report.OutPoint.Hash.String(),
+			TxidBytes:   report.OutPoint.Hash[:],
+		},
+	}
+
+	if report.SpendTxID != nil {
+		res.SweepTxid = report.SpendTxID.String()
+	}
+
+	switch report.ResolverType {
+	case channeldb.ResolverTypeAnchor:
+		res.ResolutionType = lnrpc.ResolutionType_ANCHOR
+
+	case channeldb.ResolverTypeIncomingHtlc:
+		res.ResolutionType = lnrpc.ResolutionType_INCOMING_HTLC
+
+	case channeldb.ResolverTypeOutgoingHtlc:
+		res.ResolutionType = lnrpc.ResolutionType_OUTGOING_HTLC
+
+	case channeldb.ResolverTypeCommit:
+		res.ResolutionType = lnrpc.ResolutionType_COMMIT
+
+	default:
+		return nil, fmt.Errorf("unknown resolver type: %v",
+			report.ResolverType)
+	}
+
+	switch report.ResolverOutcome {
+	case channeldb.ResolverOutcomeClaimed:
+		res.Outcome = lnrpc.ResolutionOutcome_CLAIMED
+
+	case channeldb.ResolverOutcomeUnclaimed:
+		res.Outcome = lnrpc.ResolutionOutcome_UNCLAIMED
+
+	case channeldb.ResolverOutcomeAbandoned:
+		res.Outcome = lnrpc.ResolutionOutcome_ABANDONED
+
+	case channeldb.ResolverOutcomeFirstStage:
+		res.Outcome = lnrpc.ResolutionOutcome_FIRST_STAGE
+
+	case channeldb.ResolverOutcomeTimeout:
+		res.Outcome = lnrpc.ResolutionOutcome_TIMEOUT
+
+	default:
+		return nil, fmt.Errorf("unknown outcome: %v",
+			report.ResolverOutcome)
+	}
+
+	return res, nil
 }
 
 // getInitiators returns an initiator enum that provides information about the