From 8d632b80220fe7676360fb52fdf4e12826cc12ba Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:23:30 +0200
Subject: [PATCH 1/8] channeldb: add historical channel bucket lookup

---
 channeldb/db.go      | 47 ++++++++++++++++++++++++++++++++++++++
 channeldb/db_test.go | 54 ++++++++++++++++++++++++++++++++++++++++++++
 channeldb/error.go   |  5 ++++
 3 files changed, 106 insertions(+)

diff --git a/channeldb/db.go b/channeldb/db.go
index 696f3f0086..6377df63a3 100644
--- a/channeldb/db.go
+++ b/channeldb/db.go
@@ -1249,3 +1249,50 @@ func getMigrationsToApply(versions []version, version uint32) ([]migration, []ui
 
 	return migrations, migrationVersions
 }
+
+// fetchHistoricalChanBucket returns a the channel bucket for a given outpoint
+// from the historical channel bucket. If the bucket does not exist,
+// ErrNoHistoricalBucket is returned.
+func fetchHistoricalChanBucket(tx *bbolt.Tx,
+	outPoint *wire.OutPoint) (*bbolt.Bucket, error) {
+
+	// First fetch the top level bucket which stores all data related to
+	// historically stored channels.
+	historicalChanBucket := tx.Bucket(historicalChannelBucket)
+	if historicalChanBucket == nil {
+		return nil, ErrNoHistoricalBucket
+	}
+
+	// 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 := historicalChanBucket.Bucket(chanPointBuf.Bytes())
+	if chanBucket == nil {
+		return nil, ErrChannelNotFound
+	}
+
+	return chanBucket, nil
+}
+
+// FetchHistoricalChannel fetches open channel data from the historical channel
+// bucket.
+func (d *DB) FetchHistoricalChannel(outPoint *wire.OutPoint) (*OpenChannel, error) {
+	var channel *OpenChannel
+	err := d.View(func(tx *bbolt.Tx) error {
+		chanBucket, err := fetchHistoricalChanBucket(tx, outPoint)
+		if err != nil {
+			return err
+		}
+
+		channel, err = fetchOpenChannel(chanBucket, outPoint)
+		return err
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return channel, nil
+}
diff --git a/channeldb/db_test.go b/channeldb/db_test.go
index 935a287ced..4d678303aa 100644
--- a/channeldb/db_test.go
+++ b/channeldb/db_test.go
@@ -693,3 +693,57 @@ func TestFetchChannels(t *testing.T) {
 		})
 	}
 }
+
+// TestFetchHistoricalChannel tests lookup of historical channels.
+func TestFetchHistoricalChannel(t *testing.T) {
+	cdb, cleanUp, err := makeTestDB()
+	if err != nil {
+		t.Fatalf("unable to make test database: %v", err)
+	}
+	defer cleanUp()
+
+	// Create a an open channel in the database.
+	channel := createTestChannel(t, cdb, openChannelOption())
+
+	// First, try to lookup a channel when the bucket does not
+	// exist.
+	_, err = cdb.FetchHistoricalChannel(&channel.FundingOutpoint)
+	if err != ErrNoHistoricalBucket {
+		t.Fatalf("expected no bucket, got: %v", err)
+	}
+
+	// Close the channel so that it will be written to the historical
+	// bucket. The values provided in the channel close summary are the
+	// minimum required for this call to run without panicking.
+	if err := channel.CloseChannel(&ChannelCloseSummary{
+		ChanPoint:      channel.FundingOutpoint,
+		RemotePub:      channel.IdentityPub,
+		SettledBalance: btcutil.Amount(500),
+	}); err != nil {
+		t.Fatalf("unexpected error closing channel: %v", err)
+	}
+
+	histChannel, err := cdb.FetchHistoricalChannel(&channel.FundingOutpoint)
+	if err != nil {
+		t.Fatalf("unexepected error getting channel: %v", err)
+	}
+
+	// Set the db on our channel to nil so that we can check that all other
+	// fields on the channel equal those on the historical channel.
+	channel.Db = nil
+
+	if !reflect.DeepEqual(histChannel, channel) {
+		t.Fatalf("expected: %v, got: %v", channel, histChannel)
+	}
+
+	// Create an outpoint that will not be in the db and look it up.
+	badOutpoint := &wire.OutPoint{
+		Hash:  channel.FundingOutpoint.Hash,
+		Index: channel.FundingOutpoint.Index + 1,
+	}
+	_, err = cdb.FetchHistoricalChannel(badOutpoint)
+	if err != ErrChannelNotFound {
+		t.Fatalf("expected chan not found, got: %v", err)
+	}
+
+}
diff --git a/channeldb/error.go b/channeldb/error.go
index e0e7545220..b1364fb4ba 100644
--- a/channeldb/error.go
+++ b/channeldb/error.go
@@ -10,6 +10,11 @@ var (
 	// created.
 	ErrNoChanDBExists = fmt.Errorf("channel db has not yet been created")
 
+	// ErrNoHistoricalBucket is returned when the historical channel bucket
+	// not been created yet.
+	ErrNoHistoricalBucket = fmt.Errorf("historical channel bucket has " +
+		"not yet been created")
+
 	// ErrDBReversion is returned when detecting an attempt to revert to a
 	// prior database version.
 	ErrDBReversion = fmt.Errorf("channel db cannot revert to prior version")

From d3cb6ad869749d5a72de55a543c912a237e7d6f0 Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:24:23 +0200
Subject: [PATCH 2/8] channeldb: store close initiator status

This commit adds two new channel statuses which indicate the party that
initatited closing the channel. These statuses are set in conjunction
with the existing commit broadcast status so that we do not need to
migrate existing logic to handle multiple types of closes. This status
is set for locally initiated force closes in this commit because they
follow a similar pattern to cooparative closes, marking the commitment
broadcast then proceeding with tx broadcast. Remote force closes are
added in the following commit, as they are handled differently.
---
 chancloser.go                            |  12 ++-
 channeldb/channel.go                     |  63 +++++++++----
 channeldb/channel_test.go                | 108 ++++++++++++++++++++++-
 channeldb/db_test.go                     |   4 +-
 contractcourt/chain_arbitrator_test.go   |   4 +-
 contractcourt/channel_arbitrator.go      |   8 +-
 contractcourt/channel_arbitrator_test.go |   2 +-
 lnwallet/channel.go                      |  18 ++--
 peer.go                                  |   2 +
 9 files changed, 186 insertions(+), 35 deletions(-)

diff --git a/chancloser.go b/chancloser.go
index 3536f1ce88..00dff1bf74 100644
--- a/chancloser.go
+++ b/chancloser.go
@@ -155,6 +155,9 @@ type channelCloser struct {
 	// remoteDeliveryScript is the script that we'll send the remote
 	// party's settled channel funds to.
 	remoteDeliveryScript []byte
+
+	// locallyInitiated is true if we initiated the channel close.
+	locallyInitiated bool
 }
 
 // newChannelCloser creates a new instance of the channel closure given the
@@ -162,7 +165,7 @@ type channelCloser struct {
 // only be populated iff, we're the initiator of this closing request.
 func newChannelCloser(cfg chanCloseCfg, deliveryScript []byte,
 	idealFeePerKw chainfee.SatPerKWeight, negotiationHeight uint32,
-	closeReq *htlcswitch.ChanClose) *channelCloser {
+	closeReq *htlcswitch.ChanClose, locallyInitiated bool) *channelCloser {
 
 	// Given the target fee-per-kw, we'll compute what our ideal _total_
 	// fee will be starting at for this fee negotiation.
@@ -198,6 +201,7 @@ func newChannelCloser(cfg chanCloseCfg, deliveryScript []byte,
 		idealFeeSat:         idealFeeSat,
 		localDeliveryScript: deliveryScript,
 		priorFeeOffers:      make(map[btcutil.Amount]*lnwire.ClosingSigned),
+		locallyInitiated:    locallyInitiated,
 	}
 }
 
@@ -224,7 +228,7 @@ func (c *channelCloser) initChanShutdown() (*lnwire.Shutdown, error) {
 	// guarantees that our listchannels rpc will be externally consistent,
 	// and reflect that the channel is being shutdown by the time the
 	// closing request returns.
-	err := c.cfg.channel.MarkCoopBroadcasted(nil)
+	err := c.cfg.channel.MarkCoopBroadcasted(nil, c.locallyInitiated)
 	if err != nil {
 		return nil, err
 	}
@@ -511,7 +515,9 @@ func (c *channelCloser) ProcessCloseMsg(msg lnwire.Message) ([]lnwire.Message, b
 		// Before publishing the closing tx, we persist it to the
 		// database, such that it can be republished if something goes
 		// wrong.
-		err = c.cfg.channel.MarkCoopBroadcasted(closeTx)
+		err = c.cfg.channel.MarkCoopBroadcasted(
+			closeTx, c.locallyInitiated,
+		)
 		if err != nil {
 			return nil, false, err
 		}
diff --git a/channeldb/channel.go b/channeldb/channel.go
index 3e3403905d..bc20548866 100644
--- a/channeldb/channel.go
+++ b/channeldb/channel.go
@@ -401,20 +401,35 @@ var (
 	// will have.
 	ChanStatusRestored ChannelStatus = 1 << 3
 
-	// ChanStatusCoopBroadcasted indicates that a cooperative close for this
-	// channel has been broadcasted.
+	// ChanStatusCoopBroadcasted indicates that a cooperative close for
+	// this channel has been broadcasted. Older cooperatively closed
+	// channels will only have this status set. Newer ones will also have
+	// close initiator information stored using the local/remote initiator
+	// status. This status is set in conjunction with the initiator status
+	// so that we do not need to check multiple channel statues for
+	// cooperative closes.
 	ChanStatusCoopBroadcasted ChannelStatus = 1 << 4
+
+	// ChanStatusLocalCloseInitiator indicates that we initiated closing
+	// the channel.
+	ChanStatusLocalCloseInitiator ChannelStatus = 1 << 5
+
+	// ChanStatusRemoteCloseInitiator indicates that the remote node
+	// initiated closing the channel.
+	ChanStatusRemoteCloseInitiator ChannelStatus = 1 << 6
 )
 
 // chanStatusStrings maps a ChannelStatus to a human friendly string that
 // describes that status.
 var chanStatusStrings = map[ChannelStatus]string{
-	ChanStatusDefault:           "ChanStatusDefault",
-	ChanStatusBorked:            "ChanStatusBorked",
-	ChanStatusCommitBroadcasted: "ChanStatusCommitBroadcasted",
-	ChanStatusLocalDataLoss:     "ChanStatusLocalDataLoss",
-	ChanStatusRestored:          "ChanStatusRestored",
-	ChanStatusCoopBroadcasted:   "ChanStatusCoopBroadcasted",
+	ChanStatusDefault:              "ChanStatusDefault",
+	ChanStatusBorked:               "ChanStatusBorked",
+	ChanStatusCommitBroadcasted:    "ChanStatusCommitBroadcasted",
+	ChanStatusLocalDataLoss:        "ChanStatusLocalDataLoss",
+	ChanStatusRestored:             "ChanStatusRestored",
+	ChanStatusCoopBroadcasted:      "ChanStatusCoopBroadcasted",
+	ChanStatusLocalCloseInitiator:  "ChanStatusLocalCloseInitiator",
+	ChanStatusRemoteCloseInitiator: "ChanStatusRemoteCloseInitiator",
 }
 
 // orderedChanStatusFlags is an in-order list of all that channel status flags.
@@ -425,6 +440,8 @@ var orderedChanStatusFlags = []ChannelStatus{
 	ChanStatusLocalDataLoss,
 	ChanStatusRestored,
 	ChanStatusCoopBroadcasted,
+	ChanStatusLocalCloseInitiator,
+	ChanStatusRemoteCloseInitiator,
 }
 
 // String returns a human-readable representation of the ChannelStatus.
@@ -974,30 +991,37 @@ func (c *OpenChannel) isBorked(chanBucket *bbolt.Bucket) (bool, error) {
 // closing tx _we believe_ will appear in the chain. This is only used to
 // republish this tx at startup to ensure propagation, and we should still
 // handle the case where a different tx actually hits the chain.
-func (c *OpenChannel) MarkCommitmentBroadcasted(closeTx *wire.MsgTx) error {
+func (c *OpenChannel) MarkCommitmentBroadcasted(closeTx *wire.MsgTx,
+	locallyInitiated bool) error {
+
 	return c.markBroadcasted(
 		ChanStatusCommitBroadcasted, forceCloseTxKey, closeTx,
+		locallyInitiated,
 	)
 }
 
 // MarkCoopBroadcasted marks the channel to indicate that a cooperative close
 // transaction has been broadcast, either our own or the remote, and that we
-// should wach the chain for it to confirm before taking further action. It
+// should watch the chain for it to confirm before taking further action. It
 // takes as argument a cooperative close tx that could appear on chain, and
-// should be rebroadcast upon startup. This is only used to republish and ensure
-// propagation, and we should still handle the case where a different tx
+// should be rebroadcast upon startup. This is only used to republish and
+// ensure propagation, and we should still handle the case where a different tx
 // actually hits the chain.
-func (c *OpenChannel) MarkCoopBroadcasted(closeTx *wire.MsgTx) error {
+func (c *OpenChannel) MarkCoopBroadcasted(closeTx *wire.MsgTx,
+	locallyInitiated bool) error {
+
 	return c.markBroadcasted(
 		ChanStatusCoopBroadcasted, coopCloseTxKey, closeTx,
+		locallyInitiated,
 	)
 }
 
 // markBroadcasted is a helper function which modifies the channel status of the
 // receiving channel and inserts a close transaction under the requested key,
-// which should specify either a coop or force close.
+// which should specify either a coop or force close. It adds a status which
+// indicates the party that initiated the channel close.
 func (c *OpenChannel) markBroadcasted(status ChannelStatus, key []byte,
-	closeTx *wire.MsgTx) error {
+	closeTx *wire.MsgTx, locallyInitiated bool) error {
 
 	c.Lock()
 	defer c.Unlock()
@@ -1016,6 +1040,15 @@ func (c *OpenChannel) markBroadcasted(status ChannelStatus, key []byte,
 		}
 	}
 
+	// Add the initiator status to the status provided. These statuses are
+	// set in addition to the broadcast status so that we do not need to
+	// migrate the original logic which does not store initiator.
+	if locallyInitiated {
+		status |= ChanStatusLocalCloseInitiator
+	} else {
+		status |= ChanStatusRemoteCloseInitiator
+	}
+
 	return c.putChanStatus(status, putClosingTx)
 }
 
diff --git a/channeldb/channel_test.go b/channeldb/channel_test.go
index cb29b52131..ad7a69755b 100644
--- a/channeldb/channel_test.go
+++ b/channeldb/channel_test.go
@@ -1089,13 +1089,13 @@ func TestFetchWaitingCloseChannels(t *testing.T) {
 			},
 		)
 
-		if err := channel.MarkCommitmentBroadcasted(closeTx); err != nil {
+		if err := channel.MarkCommitmentBroadcasted(closeTx, true); err != nil {
 			t.Fatalf("unable to mark commitment broadcast: %v", err)
 		}
 
 		// Now try to marking a coop close with a nil tx. This should
 		// succeed, but it shouldn't exit when queried.
-		if err = channel.MarkCoopBroadcasted(nil); err != nil {
+		if err = channel.MarkCoopBroadcasted(nil, true); err != nil {
 			t.Fatalf("unable to mark nil coop broadcast: %v", err)
 		}
 		_, err := channel.BroadcastedCooperative()
@@ -1107,7 +1107,7 @@ func TestFetchWaitingCloseChannels(t *testing.T) {
 		// it as coop closed. Later we will test that distinct
 		// transactions are returned for both coop and force closes.
 		closeTx.TxIn[0].PreviousOutPoint.Index ^= 1
-		if err := channel.MarkCoopBroadcasted(closeTx); err != nil {
+		if err := channel.MarkCoopBroadcasted(closeTx, true); err != nil {
 			t.Fatalf("unable to mark coop broadcast: %v", err)
 		}
 	}
@@ -1255,3 +1255,105 @@ func TestRefreshShortChanID(t *testing.T) {
 		t.Fatalf("channel pending state wasn't updated: want false got true")
 	}
 }
+
+// TestCloseInitiator tests the setting of close initiator statuses for
+// cooperative closes and local force closes.
+func TestCloseInitiator(t *testing.T) {
+	tests := []struct {
+		name string
+		// updateChannel is called to update the channel as broadcast,
+		// cooperatively or not, based on the test's requirements.
+		updateChannel    func(c *OpenChannel) error
+		expectedStatuses []ChannelStatus
+	}{
+		{
+			name: "local coop close",
+			// Mark the channel as cooperatively closed, initiated
+			// by the local party.
+			updateChannel: func(c *OpenChannel) error {
+				return c.MarkCoopBroadcasted(
+					&wire.MsgTx{}, true,
+				)
+			},
+			expectedStatuses: []ChannelStatus{
+				ChanStatusLocalCloseInitiator,
+				ChanStatusCoopBroadcasted,
+			},
+		},
+		{
+			name: "remote coop close",
+			// Mark the channel as cooperatively closed, initiated
+			// by the remote party.
+			updateChannel: func(c *OpenChannel) error {
+				return c.MarkCoopBroadcasted(
+					&wire.MsgTx{}, false,
+				)
+			},
+			expectedStatuses: []ChannelStatus{
+				ChanStatusRemoteCloseInitiator,
+				ChanStatusCoopBroadcasted,
+			},
+		},
+		{
+			name: "local force close",
+			// Mark the channel's commitment as broadcast with
+			// local initiator.
+			updateChannel: func(c *OpenChannel) error {
+				return c.MarkCommitmentBroadcasted(
+					&wire.MsgTx{}, true,
+				)
+			},
+			expectedStatuses: []ChannelStatus{
+				ChanStatusLocalCloseInitiator,
+				ChanStatusCommitBroadcasted,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			cdb, cleanUp, err := makeTestDB()
+			if err != nil {
+				t.Fatalf("unable to make test database: %v",
+					err)
+			}
+			defer cleanUp()
+
+			// Create an open channel.
+			channel := createTestChannel(
+				t, cdb, openChannelOption(),
+			)
+
+			err = test.updateChannel(channel)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			// Lookup open channels in the database.
+			dbChans, err := fetchChannels(
+				cdb, pendingChannelFilter(false),
+			)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if len(dbChans) != 1 {
+				t.Fatalf("expected 1 channel, got: %v",
+					len(dbChans))
+			}
+
+			// Check that the statuses that we expect were written
+			// to disk.
+			for _, status := range test.expectedStatuses {
+				if !dbChans[0].HasChanStatus(status) {
+					t.Fatalf("expected channel to have "+
+						"status: %v, has status: %v",
+						status, dbChans[0].chanStatus)
+				}
+			}
+		})
+	}
+}
diff --git a/channeldb/db_test.go b/channeldb/db_test.go
index 4d678303aa..e678d2a504 100644
--- a/channeldb/db_test.go
+++ b/channeldb/db_test.go
@@ -647,7 +647,7 @@ func TestFetchChannels(t *testing.T) {
 				channelIDOption(pendingWaitingChan),
 			)
 
-			err = pendingClosing.MarkCoopBroadcasted(nil)
+			err = pendingClosing.MarkCoopBroadcasted(nil, true)
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
@@ -667,7 +667,7 @@ func TestFetchChannels(t *testing.T) {
 				channelIDOption(openWaitingChan),
 				openChannelOption(),
 			)
-			err = openClosing.MarkCoopBroadcasted(nil)
+			err = openClosing.MarkCoopBroadcasted(nil, true)
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
diff --git a/contractcourt/chain_arbitrator_test.go b/contractcourt/chain_arbitrator_test.go
index 5710b14ae3..0ac7484a50 100644
--- a/contractcourt/chain_arbitrator_test.go
+++ b/contractcourt/chain_arbitrator_test.go
@@ -62,12 +62,12 @@ func TestChainArbitratorRepublishCloses(t *testing.T) {
 	for i := 0; i < numChans/2; i++ {
 		closeTx := channels[i].FundingTxn.Copy()
 		closeTx.TxIn[0].PreviousOutPoint = channels[i].FundingOutpoint
-		err := channels[i].MarkCommitmentBroadcasted(closeTx)
+		err := channels[i].MarkCommitmentBroadcasted(closeTx, true)
 		if err != nil {
 			t.Fatal(err)
 		}
 
-		err = channels[i].MarkCoopBroadcasted(closeTx)
+		err = channels[i].MarkCoopBroadcasted(closeTx, true)
 		if err != nil {
 			t.Fatal(err)
 		}
diff --git a/contractcourt/channel_arbitrator.go b/contractcourt/channel_arbitrator.go
index b11c81aab9..6db666c909 100644
--- a/contractcourt/channel_arbitrator.go
+++ b/contractcourt/channel_arbitrator.go
@@ -98,7 +98,7 @@ type ChannelArbitratorConfig struct {
 
 	// MarkCommitmentBroadcasted should mark the channel as the commitment
 	// being broadcast, and we are waiting for the commitment to confirm.
-	MarkCommitmentBroadcasted func(*wire.MsgTx) error
+	MarkCommitmentBroadcasted func(*wire.MsgTx, bool) error
 
 	// MarkChannelClosed marks the channel closed in the database, with the
 	// passed close summary. After this method successfully returns we can
@@ -797,8 +797,10 @@ func (c *ChannelArbitrator) stateStep(
 
 		// Before publishing the transaction, we store it to the
 		// database, such that we can re-publish later in case it
-		// didn't propagate.
-		if err := c.cfg.MarkCommitmentBroadcasted(closeTx); err != nil {
+		// didn't propagate. We initiated the force close, so we
+		// mark broadcast with local initiator set to true.
+		err = c.cfg.MarkCommitmentBroadcasted(closeTx, true)
+		if err != nil {
 			log.Errorf("ChannelArbitrator(%v): unable to "+
 				"mark commitment broadcasted: %v",
 				c.cfg.ChanPoint, err)
diff --git a/contractcourt/channel_arbitrator_test.go b/contractcourt/channel_arbitrator_test.go
index 9375d895bb..0abfb381a2 100644
--- a/contractcourt/channel_arbitrator_test.go
+++ b/contractcourt/channel_arbitrator_test.go
@@ -339,7 +339,7 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog) (*chanArbTestC
 			}
 			return summary, nil
 		},
-		MarkCommitmentBroadcasted: func(_ *wire.MsgTx) error {
+		MarkCommitmentBroadcasted: func(_ *wire.MsgTx, _ bool) error {
 			return nil
 		},
 		MarkChannelClosed: func(*channeldb.ChannelCloseSummary) error {
diff --git a/lnwallet/channel.go b/lnwallet/channel.go
index 08ec5ebcaf..fa96f8c4a0 100644
--- a/lnwallet/channel.go
+++ b/lnwallet/channel.go
@@ -6433,22 +6433,28 @@ func (lc *LightningChannel) MarkBorked() error {
 
 // MarkCommitmentBroadcasted marks the channel as a commitment transaction has
 // been broadcast, either our own or the remote, and we should watch the chain
-// for it to confirm before taking any further action.
-func (lc *LightningChannel) MarkCommitmentBroadcasted(tx *wire.MsgTx) error {
+// for it to confirm before taking any further action. It takes a boolean which
+// indicates whether we initiated the close.
+func (lc *LightningChannel) MarkCommitmentBroadcasted(tx *wire.MsgTx,
+	locallyInitiated bool) error {
+
 	lc.Lock()
 	defer lc.Unlock()
 
-	return lc.channelState.MarkCommitmentBroadcasted(tx)
+	return lc.channelState.MarkCommitmentBroadcasted(tx, locallyInitiated)
 }
 
 // MarkCoopBroadcasted marks the channel as a cooperative close transaction has
 // been broadcast, and that we should watch the chain for it to confirm before
-// taking any further action.
-func (lc *LightningChannel) MarkCoopBroadcasted(tx *wire.MsgTx) error {
+// taking any further action. It takes a locally initiated bool which is true
+// if we initiated the cooperative close.
+func (lc *LightningChannel) MarkCoopBroadcasted(tx *wire.MsgTx,
+	localInitiated bool) error {
+
 	lc.Lock()
 	defer lc.Unlock()
 
-	return lc.channelState.MarkCoopBroadcasted(tx)
+	return lc.channelState.MarkCoopBroadcasted(tx, localInitiated)
 }
 
 // MarkDataLoss marks sets the channel status to LocalDataLoss and stores the
diff --git a/peer.go b/peer.go
index ea482d1f51..02544fe4f2 100644
--- a/peer.go
+++ b/peer.go
@@ -2119,6 +2119,7 @@ func (p *peer) fetchActiveChanCloser(chanID lnwire.ChannelID) (*channelCloser, e
 			feePerKw,
 			uint32(startingHeight),
 			nil,
+			false,
 		)
 		p.activeChanCloses[chanID] = chanCloser
 	}
@@ -2231,6 +2232,7 @@ func (p *peer) handleLocalCloseReq(req *htlcswitch.ChanClose) {
 			req.TargetFeePerKw,
 			uint32(startingHeight),
 			req,
+			true,
 		)
 		p.activeChanCloses[chanID] = chanCloser
 

From 11d975bd131bc0a5e49903e67714c74d6bd0d0a3 Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:24:23 +0200
Subject: [PATCH 3/8] channeldb: save channel status on channel close

Add an optional channel status CloseChannel which will be stored on the
hitsorical channel which is persisted at channel close. This status is
used to set the close initiator for channels that do not complete the
funding flow or we abandon. In follow up commits, this status will be
used to record force and breach closes. The value is written to the
historical channel bucket for diplay over rpc.
---
 channeldb/channel.go      | 13 +++++++++++--
 channeldb/channel_test.go | 36 ++++++++++++++++++++++++++++++++++++
 channeldb/db.go           |  5 +++--
 fundingmanager.go         | 12 ++++++++++--
 4 files changed, 60 insertions(+), 6 deletions(-)

diff --git a/channeldb/channel.go b/channeldb/channel.go
index bc20548866..0914f24244 100644
--- a/channeldb/channel.go
+++ b/channeldb/channel.go
@@ -2382,8 +2382,12 @@ type ChannelCloseSummary struct {
 // entails deleting all saved state within the database concerning this
 // channel. This method also takes a struct that summarizes the state of the
 // channel at closing, this compact representation will be the only component
-// of a channel left over after a full closing.
-func (c *OpenChannel) CloseChannel(summary *ChannelCloseSummary) error {
+// of a channel left over after a full closing. It takes an optional set of
+// channel statuses which will be written to the historical channel bucket.
+// These statuses are used to record close initiators.
+func (c *OpenChannel) CloseChannel(summary *ChannelCloseSummary,
+	statuses ...ChannelStatus) error {
+
 	c.Lock()
 	defer c.Unlock()
 
@@ -2461,6 +2465,11 @@ func (c *OpenChannel) CloseChannel(summary *ChannelCloseSummary) error {
 			return err
 		}
 
+		// Apply any additional statuses to the channel state.
+		for _, status := range statuses {
+			chanState.chanStatus |= status
+		}
+
 		err = putOpenChannel(historicalChanBucket, chanState)
 		if err != nil {
 			return err
diff --git a/channeldb/channel_test.go b/channeldb/channel_test.go
index ad7a69755b..bd2ab8b732 100644
--- a/channeldb/channel_test.go
+++ b/channeldb/channel_test.go
@@ -1357,3 +1357,39 @@ func TestCloseInitiator(t *testing.T) {
 		})
 	}
 }
+
+// TestCloseChannelStatus tests setting of a channel status on the historical
+// channel on channel close.
+func TestCloseChannelStatus(t *testing.T) {
+	cdb, cleanUp, err := makeTestDB()
+	if err != nil {
+		t.Fatalf("unable to make test database: %v",
+			err)
+	}
+	defer cleanUp()
+
+	// Create an open channel.
+	channel := createTestChannel(
+		t, cdb, openChannelOption(),
+	)
+
+	if err := channel.CloseChannel(
+		&ChannelCloseSummary{
+			ChanPoint: channel.FundingOutpoint,
+			RemotePub: channel.IdentityPub,
+		}, ChanStatusRemoteCloseInitiator,
+	); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	histChan, err := channel.Db.FetchHistoricalChannel(
+		&channel.FundingOutpoint,
+	)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if !histChan.HasChanStatus(ChanStatusRemoteCloseInitiator) {
+		t.Fatalf("channel should have status")
+	}
+}
diff --git a/channeldb/db.go b/channeldb/db.go
index 6377df63a3..c1cf46ba80 100644
--- a/channeldb/db.go
+++ b/channeldb/db.go
@@ -1159,8 +1159,9 @@ func (d *DB) AbandonChannel(chanPoint *wire.OutPoint, bestHeight uint32) error {
 	}
 
 	// Finally, we'll close the channel in the DB, and return back to the
-	// caller.
-	return dbChan.CloseChannel(summary)
+	// caller. We set ourselves as the close initiator because we abandoned
+	// the channel.
+	return dbChan.CloseChannel(summary, ChanStatusLocalCloseInitiator)
 }
 
 // syncVersions function is used for safe db version synchronization. It
diff --git a/fundingmanager.go b/fundingmanager.go
index 8484b94554..7913a11f66 100644
--- a/fundingmanager.go
+++ b/fundingmanager.go
@@ -1009,7 +1009,11 @@ func (f *fundingManager) advancePendingChannelState(
 			LocalChanConfig:         ch.LocalChanCfg,
 		}
 
-		if err := ch.CloseChannel(closeInfo); err != nil {
+		// Close the channel with us as the initiator because we are
+		// timing the channel out.
+		if err := ch.CloseChannel(
+			closeInfo, channeldb.ChanStatusLocalCloseInitiator,
+		); err != nil {
 			return fmt.Errorf("failed closing channel "+
 				"%v: %v", ch.FundingOutpoint, err)
 		}
@@ -1639,7 +1643,11 @@ func (f *fundingManager) handleFundingCreated(fmsg *fundingCreatedMsg) {
 			LocalChanConfig:         completeChan.LocalChanCfg,
 		}
 
-		if err := completeChan.CloseChannel(closeInfo); err != nil {
+		// Close the channel with us as the initiator because we are
+		// deciding to exit the funding flow due to an internal error.
+		if err := completeChan.CloseChannel(
+			closeInfo, channeldb.ChanStatusLocalCloseInitiator,
+		); err != nil {
 			fndgLog.Errorf("Failed closing channel %v: %v",
 				completeChan.FundingOutpoint, err)
 		}

From c9915e027e02b21e01222c40afd8e6259592ab34 Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:24:23 +0200
Subject: [PATCH 4/8] contractcourt/test: replace timeouts with constants

---
 contractcourt/channel_arbitrator_test.go | 68 +++++++++++++-----------
 1 file changed, 38 insertions(+), 30 deletions(-)

diff --git a/contractcourt/channel_arbitrator_test.go b/contractcourt/channel_arbitrator_test.go
index 0abfb381a2..2e7d40632a 100644
--- a/contractcourt/channel_arbitrator_test.go
+++ b/contractcourt/channel_arbitrator_test.go
@@ -21,6 +21,14 @@ import (
 	"github.com/lightningnetwork/lnd/lnwire"
 )
 
+const (
+	defaultTimeout = time.Second * 5
+
+	// stateTimeout is the timeout we allow when waiting for state
+	// transitions.
+	stateTimeout = time.Second * 15
+)
+
 type mockArbitratorLog struct {
 	state           ArbitratorState
 	newStates       chan ArbitratorState
@@ -221,7 +229,7 @@ func (c *chanArbTestCtx) AssertStateTransitions(expectedStates ...ArbitratorStat
 		var state ArbitratorState
 		select {
 		case state = <-newStatesChan:
-		case <-time.After(5 * time.Second):
+		case <-time.After(defaultTimeout):
 			c.t.Fatalf("new state not received")
 		}
 
@@ -441,7 +449,7 @@ func TestChannelArbitratorCooperativeClose(t *testing.T) {
 		if c.CloseType != channeldb.CooperativeClose {
 			t.Fatalf("expected cooperative close, got %v", c.CloseType)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("timeout waiting for channel close")
 	}
 
@@ -449,7 +457,7 @@ func TestChannelArbitratorCooperativeClose(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -504,7 +512,7 @@ func TestChannelArbitratorRemoteForceClose(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -566,7 +574,7 @@ func TestChannelArbitratorLocalForceClose(t *testing.T) {
 		if state != StateBroadcastCommit {
 			t.Fatalf("state during PublishTx was %v", state)
 		}
-	case <-time.After(15 * time.Second):
+	case <-time.After(stateTimeout):
 		t.Fatalf("did not get state update")
 	}
 
@@ -576,7 +584,7 @@ func TestChannelArbitratorLocalForceClose(t *testing.T) {
 
 	select {
 	case <-respChan:
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -585,7 +593,7 @@ func TestChannelArbitratorLocalForceClose(t *testing.T) {
 		if err != nil {
 			t.Fatalf("error force closing channel: %v", err)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -610,7 +618,7 @@ func TestChannelArbitratorLocalForceClose(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -654,7 +662,7 @@ func TestChannelArbitratorBreachClose(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -738,7 +746,7 @@ func TestChannelArbitratorLocalForceClosePendingHtlc(t *testing.T) {
 	)
 	select {
 	case <-respChan:
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -747,7 +755,7 @@ func TestChannelArbitratorLocalForceClosePendingHtlc(t *testing.T) {
 		if err != nil {
 			t.Fatalf("error force closing channel: %v", err)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -825,7 +833,7 @@ func TestChannelArbitratorLocalForceClosePendingHtlc(t *testing.T) {
 			t.Fatalf("wrong htlc index: expected %v, got %v",
 				outgoingDustHtlc.HtlcIndex, msgs[0].HtlcIndex)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("resolution msgs not sent")
 	}
 
@@ -887,7 +895,7 @@ func TestChannelArbitratorLocalForceClosePendingHtlc(t *testing.T) {
 	// htlcTimeoutResolver and should send the contract off for incubation.
 	select {
 	case <-chanArbCtx.incubationRequests:
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -907,7 +915,7 @@ func TestChannelArbitratorLocalForceClosePendingHtlc(t *testing.T) {
 			t.Fatalf("wrong htlc index: expected %v, got %v",
 				htlc.HtlcIndex, msgs[0].HtlcIndex)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("resolution msgs not sent")
 	}
 
@@ -927,7 +935,7 @@ func TestChannelArbitratorLocalForceClosePendingHtlc(t *testing.T) {
 	chanArbCtxNew.AssertStateTransitions(StateFullyResolved)
 	select {
 	case <-chanArbCtxNew.resolvedChan:
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -989,7 +997,7 @@ func TestChannelArbitratorLocalForceCloseRemoteConfirmed(t *testing.T) {
 		if state != StateBroadcastCommit {
 			t.Fatalf("state during PublishTx was %v", state)
 		}
-	case <-time.After(15 * time.Second):
+	case <-time.After(stateTimeout):
 		t.Fatalf("no state update received")
 	}
 
@@ -1000,7 +1008,7 @@ func TestChannelArbitratorLocalForceCloseRemoteConfirmed(t *testing.T) {
 	// Wait for a response to the force close.
 	select {
 	case <-respChan:
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -1009,7 +1017,7 @@ func TestChannelArbitratorLocalForceCloseRemoteConfirmed(t *testing.T) {
 		if err != nil {
 			t.Fatalf("error force closing channel: %v", err)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -1035,7 +1043,7 @@ func TestChannelArbitratorLocalForceCloseRemoteConfirmed(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(15 * time.Second):
+	case <-time.After(stateTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -1097,7 +1105,7 @@ func TestChannelArbitratorLocalForceDoubleSpend(t *testing.T) {
 		if state != StateBroadcastCommit {
 			t.Fatalf("state during PublishTx was %v", state)
 		}
-	case <-time.After(15 * time.Second):
+	case <-time.After(stateTimeout):
 		t.Fatalf("no state update received")
 	}
 
@@ -1108,7 +1116,7 @@ func TestChannelArbitratorLocalForceDoubleSpend(t *testing.T) {
 	// Wait for a response to the force close.
 	select {
 	case <-respChan:
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -1117,7 +1125,7 @@ func TestChannelArbitratorLocalForceDoubleSpend(t *testing.T) {
 		if err != nil {
 			t.Fatalf("error force closing channel: %v", err)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -1143,7 +1151,7 @@ func TestChannelArbitratorLocalForceDoubleSpend(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(15 * time.Second):
+	case <-time.After(stateTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -1264,7 +1272,7 @@ func TestChannelArbitratorPersistence(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -1328,7 +1336,7 @@ func TestChannelArbitratorForceCloseBreachedChannel(t *testing.T) {
 		if state != StateBroadcastCommit {
 			t.Fatalf("state during PublishTx was %v", state)
 		}
-	case <-time.After(15 * time.Second):
+	case <-time.After(stateTimeout):
 		t.Fatalf("no state update received")
 	}
 
@@ -1339,7 +1347,7 @@ func TestChannelArbitratorForceCloseBreachedChannel(t *testing.T) {
 			t.Fatalf("unexpected error force closing channel: %v",
 				err)
 		}
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("no response received")
 	}
 
@@ -1363,7 +1371,7 @@ func TestChannelArbitratorForceCloseBreachedChannel(t *testing.T) {
 	select {
 	case <-chanArbCtx.resolvedChan:
 		// Expected.
-	case <-time.After(5 * time.Second):
+	case <-time.After(defaultTimeout):
 		t.Fatalf("contract was not resolved")
 	}
 }
@@ -1467,7 +1475,7 @@ func TestChannelArbitratorCommitFailure(t *testing.T) {
 
 		select {
 		case <-closed:
-		case <-time.After(5 * time.Second):
+		case <-time.After(defaultTimeout):
 			t.Fatalf("channel was not marked closed")
 		}
 
@@ -1501,7 +1509,7 @@ func TestChannelArbitratorCommitFailure(t *testing.T) {
 		select {
 		case <-chanArbCtx.resolvedChan:
 			// Expected.
-		case <-time.After(5 * time.Second):
+		case <-time.After(defaultTimeout):
 			t.Fatalf("contract was not resolved")
 		}
 	}
@@ -1805,7 +1813,7 @@ func TestChannelArbitratorDanglingCommitForceClose(t *testing.T) {
 					t.Fatalf("wrong htlc index: expected %v, got %v",
 						htlcIndex, msgs[0].HtlcIndex)
 				}
-			case <-time.After(5 * time.Second):
+			case <-time.After(defaultTimeout):
 				t.Fatalf("resolution msgs not sent")
 			}
 

From 4eb3036f6773a5b0881ea007e3022e8fd05a59b4 Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:49:12 +0200
Subject: [PATCH 5/8] contractcourt: record force and breach close initiator

---
 contractcourt/chain_arbitrator.go        |   7 +-
 contractcourt/chain_watcher.go           |   4 +-
 contractcourt/channel_arbitrator.go      |  11 +-
 contractcourt/channel_arbitrator_test.go | 194 ++++++++++++++++++++++-
 4 files changed, 202 insertions(+), 14 deletions(-)

diff --git a/contractcourt/chain_arbitrator.go b/contractcourt/chain_arbitrator.go
index 552549f463..7a9cb3095c 100644
--- a/contractcourt/chain_arbitrator.go
+++ b/contractcourt/chain_arbitrator.go
@@ -284,8 +284,11 @@ func newActiveChannelArbitrator(channel *channeldb.OpenChannel,
 			return chanMachine.ForceClose()
 		},
 		MarkCommitmentBroadcasted: channel.MarkCommitmentBroadcasted,
-		MarkChannelClosed: func(summary *channeldb.ChannelCloseSummary) error {
-			if err := channel.CloseChannel(summary); err != nil {
+		MarkChannelClosed: func(summary *channeldb.ChannelCloseSummary,
+			statuses ...channeldb.ChannelStatus) error {
+
+			err := channel.CloseChannel(summary, statuses...)
+			if err != nil {
 				return err
 			}
 			c.cfg.NotifyClosedChannel(summary.ChanPoint)
diff --git a/contractcourt/chain_watcher.go b/contractcourt/chain_watcher.go
index c08916d010..3012376b39 100644
--- a/contractcourt/chain_watcher.go
+++ b/contractcourt/chain_watcher.go
@@ -985,7 +985,9 @@ func (c *chainWatcher) dispatchContractBreach(spendEvent *chainntnfs.SpendDetail
 		closeSummary.LastChanSyncMsg = chanSync
 	}
 
-	if err := c.cfg.chanState.CloseChannel(&closeSummary); err != nil {
+	if err := c.cfg.chanState.CloseChannel(
+		&closeSummary, channeldb.ChanStatusRemoteCloseInitiator,
+	); err != nil {
 		return err
 	}
 
diff --git a/contractcourt/channel_arbitrator.go b/contractcourt/channel_arbitrator.go
index 6db666c909..2a58ea523e 100644
--- a/contractcourt/channel_arbitrator.go
+++ b/contractcourt/channel_arbitrator.go
@@ -104,8 +104,10 @@ type ChannelArbitratorConfig struct {
 	// passed close summary. After this method successfully returns we can
 	// no longer expect to receive chain events for this channel, and must
 	// be able to recover from a failure without getting the close event
-	// again.
-	MarkChannelClosed func(*channeldb.ChannelCloseSummary) error
+	// again. It takes an optional channel status which will update the
+	// channel status in the record that we keep of historical channels.
+	MarkChannelClosed func(*channeldb.ChannelCloseSummary,
+		...channeldb.ChannelStatus) error
 
 	// IsPendingClose is a boolean indicating whether the channel is marked
 	// as pending close in the database.
@@ -2178,7 +2180,10 @@ func (c *ChannelArbitrator) channelAttendant(bestHeight int32) {
 			// transition into StateContractClosed based on the
 			// close status of the channel.
 			closeSummary := &uniClosure.ChannelCloseSummary
-			err = c.cfg.MarkChannelClosed(closeSummary)
+			err = c.cfg.MarkChannelClosed(
+				closeSummary,
+				channeldb.ChanStatusRemoteCloseInitiator,
+			)
 			if err != nil {
 				log.Errorf("Unable to mark channel closed: %v",
 					err)
diff --git a/contractcourt/channel_arbitrator_test.go b/contractcourt/channel_arbitrator_test.go
index 2e7d40632a..0a73cd5e90 100644
--- a/contractcourt/channel_arbitrator_test.go
+++ b/contractcourt/channel_arbitrator_test.go
@@ -12,6 +12,7 @@ import (
 
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
+	"github.com/btcsuite/btcutil"
 	"github.com/coreos/bbolt"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/channeldb"
@@ -274,7 +275,26 @@ func (c *chanArbTestCtx) Restart(restartClosure func(*chanArbTestCtx)) (*chanArb
 	return newCtx, nil
 }
 
-func createTestChannelArbitrator(t *testing.T, log ArbitratorLog) (*chanArbTestCtx, error) {
+// testChanArbOption applies custom settings to a channel arbitrator config for
+// testing purposes.
+type testChanArbOption func(cfg *ChannelArbitratorConfig)
+
+// remoteInitiatorOption sets the MarkChannelClosed function in the
+// Channel Arbitrator's config.
+func withMarkClosed(markClosed func(*channeldb.ChannelCloseSummary,
+	...channeldb.ChannelStatus) error) testChanArbOption {
+
+	return func(cfg *ChannelArbitratorConfig) {
+		cfg.MarkChannelClosed = markClosed
+	}
+}
+
+// createTestChannelArbitrator returns a channel arbitrator test context which
+// contains a channel arbitrator with default values. These values can be
+// changed by providing options which overwrite the default config.
+func createTestChannelArbitrator(t *testing.T, log ArbitratorLog,
+	opts ...testChanArbOption) (*chanArbTestCtx, error) {
+
 	blockEpochs := make(chan *chainntnfs.BlockEpoch)
 	blockEpoch := &chainntnfs.BlockEpochEvent{
 		Epochs: blockEpochs,
@@ -332,7 +352,7 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog) (*chanArbTestC
 
 	// Next we'll create the matching configuration struct that contains
 	// all interfaces and methods the arbitrator needs to do its job.
-	arbCfg := ChannelArbitratorConfig{
+	arbCfg := &ChannelArbitratorConfig{
 		ChanPoint:   chanPoint,
 		ShortChanID: shortChanID,
 		BlockEpochs: blockEpoch,
@@ -350,7 +370,8 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog) (*chanArbTestC
 		MarkCommitmentBroadcasted: func(_ *wire.MsgTx, _ bool) error {
 			return nil
 		},
-		MarkChannelClosed: func(*channeldb.ChannelCloseSummary) error {
+		MarkChannelClosed: func(*channeldb.ChannelCloseSummary,
+			...channeldb.ChannelStatus) error {
 			return nil
 		},
 		IsPendingClose:        false,
@@ -358,6 +379,11 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog) (*chanArbTestC
 		ChainEvents:           chanEvents,
 	}
 
+	// Apply all custom options to the config struct.
+	for _, option := range opts {
+		option(arbCfg)
+	}
+
 	var cleanUp func()
 	if log == nil {
 		dbDir, err := ioutil.TempDir("", "chanArb")
@@ -371,7 +397,7 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog) (*chanArbTestC
 		}
 
 		backingLog, err := newBoltArbitratorLog(
-			db, arbCfg, chainhash.Hash{}, chanPoint,
+			db, *arbCfg, chainhash.Hash{}, chanPoint,
 		)
 		if err != nil {
 			return nil, err
@@ -389,7 +415,7 @@ func createTestChannelArbitrator(t *testing.T, log ArbitratorLog) (*chanArbTestC
 
 	htlcSets := make(map[HtlcSetKey]htlcSet)
 
-	chanArb := NewChannelArbitrator(arbCfg, htlcSets, log)
+	chanArb := NewChannelArbitrator(*arbCfg, htlcSets, log)
 
 	return &chanArbTestCtx{
 		t:                  t,
@@ -432,7 +458,9 @@ func TestChannelArbitratorCooperativeClose(t *testing.T) {
 	// We set up a channel to detect when MarkChannelClosed is called.
 	closeInfos := make(chan *channeldb.ChannelCloseSummary)
 	chanArbCtx.chanArb.cfg.MarkChannelClosed = func(
-		closeInfo *channeldb.ChannelCloseSummary) error {
+		closeInfo *channeldb.ChannelCloseSummary,
+		statuses ...channeldb.ChannelStatus) error {
+
 		closeInfos <- closeInfo
 		return nil
 	}
@@ -1213,7 +1241,9 @@ func TestChannelArbitratorPersistence(t *testing.T) {
 	// Now we make the log succeed writing the resolutions, but fail when
 	// attempting to close the channel.
 	log.failLog = false
-	chanArb.cfg.MarkChannelClosed = func(*channeldb.ChannelCloseSummary) error {
+	chanArb.cfg.MarkChannelClosed = func(*channeldb.ChannelCloseSummary,
+		...channeldb.ChannelStatus) error {
+
 		return fmt.Errorf("intentional close error")
 	}
 
@@ -1465,7 +1495,8 @@ func TestChannelArbitratorCommitFailure(t *testing.T) {
 
 		closed := make(chan struct{})
 		chanArb.cfg.MarkChannelClosed = func(
-			*channeldb.ChannelCloseSummary) error {
+			*channeldb.ChannelCloseSummary,
+			...channeldb.ChannelStatus) error {
 			close(closed)
 			return nil
 		}
@@ -1910,3 +1941,150 @@ func TestChannelArbitratorPendingExpiredHTLC(t *testing.T) {
 		StateCommitmentBroadcasted,
 	)
 }
+
+// TestRemoteCloseInitiator tests the setting of close initiator statuses
+// for remote force closes and breaches.
+func TestRemoteCloseInitiator(t *testing.T) {
+	// getCloseSummary returns a unilateral close summary for the channel
+	// provided.
+	getCloseSummary := func(channel *channeldb.OpenChannel) *RemoteUnilateralCloseInfo {
+		return &RemoteUnilateralCloseInfo{
+			UnilateralCloseSummary: &lnwallet.UnilateralCloseSummary{
+				SpendDetail: &chainntnfs.SpendDetail{
+					SpenderTxHash: &chainhash.Hash{},
+					SpendingTx: &wire.MsgTx{
+						TxIn:  []*wire.TxIn{},
+						TxOut: []*wire.TxOut{},
+					},
+				},
+				ChannelCloseSummary: channeldb.ChannelCloseSummary{
+					ChanPoint:         channel.FundingOutpoint,
+					RemotePub:         channel.IdentityPub,
+					SettledBalance:    btcutil.Amount(500),
+					TimeLockedBalance: btcutil.Amount(10000),
+					IsPending:         false,
+				},
+				HtlcResolutions: &lnwallet.HtlcResolutions{},
+			},
+		}
+	}
+
+	tests := []struct {
+		name string
+
+		// notifyClose sends the appropriate chain event to indicate
+		// that the channel has closed. The event subscription channel
+		// is expected to be buffered, as is the default for test
+		// channel arbitrators.
+		notifyClose func(sub *ChainEventSubscription,
+			channel *channeldb.OpenChannel)
+
+		// expectedStates is the set of states we expect the arbitrator
+		// to progress through.
+		expectedStates []ArbitratorState
+	}{
+		{
+			name: "force close",
+			notifyClose: func(sub *ChainEventSubscription,
+				channel *channeldb.OpenChannel) {
+
+				s := getCloseSummary(channel)
+				sub.RemoteUnilateralClosure <- s
+			},
+			expectedStates: []ArbitratorState{
+				StateContractClosed, StateFullyResolved,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			// First, create alice's channel.
+			alice, _, cleanUp, err := lnwallet.CreateTestChannels(
+				true,
+			)
+			if err != nil {
+				t.Fatalf("unable to create test channels: %v",
+					err)
+			}
+			defer cleanUp()
+
+			// Create a mock log which will not block the test's
+			// expected number of transitions transitions, and has
+			// no commit resolutions so that the channel will
+			// resolve immediately.
+			log := &mockArbitratorLog{
+				state: StateDefault,
+				newStates: make(chan ArbitratorState,
+					len(test.expectedStates)),
+				resolutions: &ContractResolutions{
+					CommitHash:       chainhash.Hash{},
+					CommitResolution: nil,
+				},
+			}
+
+			// Mock marking the channel as closed, we only care
+			// about setting of channel status.
+			mockMarkClosed := func(_ *channeldb.ChannelCloseSummary,
+				statuses ...channeldb.ChannelStatus) error {
+				for _, status := range statuses {
+					err := alice.State().ApplyChanStatus(status)
+					if err != nil {
+						return err
+					}
+				}
+				return nil
+			}
+
+			chanArbCtx, err := createTestChannelArbitrator(
+				t, log, withMarkClosed(mockMarkClosed),
+			)
+			if err != nil {
+				t.Fatalf("unable to create "+
+					"ChannelArbitrator: %v", err)
+			}
+			chanArb := chanArbCtx.chanArb
+
+			if err := chanArb.Start(); err != nil {
+				t.Fatalf("unable to start "+
+					"ChannelArbitrator: %v", err)
+			}
+			defer func() {
+				if err := chanArb.Stop(); err != nil {
+					t.Fatal(err)
+				}
+			}()
+
+			// It should start out in the default state.
+			chanArbCtx.AssertState(StateDefault)
+
+			// Notify the close event.
+			test.notifyClose(chanArb.cfg.ChainEvents, alice.State())
+
+			// Check that the channel transitions as expected.
+			chanArbCtx.AssertStateTransitions(
+				test.expectedStates...,
+			)
+
+			// It should also mark the channel as resolved.
+			select {
+			case <-chanArbCtx.resolvedChan:
+				// Expected.
+			case <-time.After(defaultTimeout):
+				t.Fatalf("contract was not resolved")
+			}
+
+			// Check that alice has the status we expect.
+			if !alice.State().HasChanStatus(
+				channeldb.ChanStatusRemoteCloseInitiator,
+			) {
+				t.Fatalf("expected remote close initiator, "+
+					"got: %v", alice.State().ChanStatus())
+			}
+		})
+	}
+}

From b55470e9a9076c7f3a07a84318b7af7e138da1d8 Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:24:24 +0200
Subject: [PATCH 6/8] lnrpc: add open and close initiator to close summary

Add an initiator enum which allows up to display an unknown value for
channels that are not in the historical chan bucket, rather than having
and ambiguous false value also representing no-value. A both option is
added to cover the case where both parties initiated a close on chain.
---
 lnrpc/rpc.pb.go        | 1304 +++++++++++++++++++++-------------------
 lnrpc/rpc.proto        |   23 +
 lnrpc/rpc.swagger.json |   18 +
 3 files changed, 724 insertions(+), 621 deletions(-)

diff --git a/lnrpc/rpc.pb.go b/lnrpc/rpc.pb.go
index fa2d711766..7ee3b08b6e 100644
--- a/lnrpc/rpc.pb.go
+++ b/lnrpc/rpc.pb.go
@@ -194,6 +194,37 @@ func (ChannelCloseSummary_ClosureType) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_77a6da22d6a3feb1, []int{43, 0}
 }
 
+type ChannelCloseSummary_Initiator int32
+
+const (
+	ChannelCloseSummary_UNKNOWN ChannelCloseSummary_Initiator = 0
+	ChannelCloseSummary_LOCAL   ChannelCloseSummary_Initiator = 1
+	ChannelCloseSummary_REMOTE  ChannelCloseSummary_Initiator = 2
+	ChannelCloseSummary_BOTH    ChannelCloseSummary_Initiator = 3
+)
+
+var ChannelCloseSummary_Initiator_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "LOCAL",
+	2: "REMOTE",
+	3: "BOTH",
+}
+
+var ChannelCloseSummary_Initiator_value = map[string]int32{
+	"UNKNOWN": 0,
+	"LOCAL":   1,
+	"REMOTE":  2,
+	"BOTH":    3,
+}
+
+func (x ChannelCloseSummary_Initiator) String() string {
+	return proto.EnumName(ChannelCloseSummary_Initiator_name, int32(x))
+}
+
+func (ChannelCloseSummary_Initiator) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_77a6da22d6a3feb1, []int{43, 1}
+}
+
 type Peer_SyncType int32
 
 const (
@@ -3188,10 +3219,22 @@ type ChannelCloseSummary struct {
 	/// The sum of all the time-locked outputs at the time of channel closure
 	TimeLockedBalance int64 `protobuf:"varint,9,opt,name=time_locked_balance,proto3" json:"time_locked_balance,omitempty"`
 	/// Details on how the channel was closed.
-	CloseType            ChannelCloseSummary_ClosureType `protobuf:"varint,10,opt,name=close_type,proto3,enum=lnrpc.ChannelCloseSummary_ClosureType" json:"close_type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
-	XXX_unrecognized     []byte                          `json:"-"`
-	XXX_sizecache        int32                           `json:"-"`
+	CloseType ChannelCloseSummary_ClosureType `protobuf:"varint,10,opt,name=close_type,proto3,enum=lnrpc.ChannelCloseSummary_ClosureType" json:"close_type,omitempty"`
+	//*
+	//Open initiator is the party that initiated opening the channel. Note that
+	//this value may be unknown if the channel was closed before we migrated to
+	//store open channel information after close.
+	OpenInitiator ChannelCloseSummary_Initiator `protobuf:"varint,11,opt,name=open_initiator,proto3,enum=lnrpc.ChannelCloseSummary_Initiator" json:"open_initiator,omitempty"`
+	//*
+	//Close initiator indicates which party initiated the close. This value will
+	//be unknown for channels that were cooperatively closed before we started
+	//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       ChannelCloseSummary_Initiator `protobuf:"varint,12,opt,name=close_initiator,proto3,enum=lnrpc.ChannelCloseSummary_Initiator" json:"close_initiator,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
+	XXX_unrecognized     []byte                        `json:"-"`
+	XXX_sizecache        int32                         `json:"-"`
 }
 
 func (m *ChannelCloseSummary) Reset()         { *m = ChannelCloseSummary{} }
@@ -3289,6 +3332,20 @@ func (m *ChannelCloseSummary) GetCloseType() ChannelCloseSummary_ClosureType {
 	return ChannelCloseSummary_COOPERATIVE_CLOSE
 }
 
+func (m *ChannelCloseSummary) GetOpenInitiator() ChannelCloseSummary_Initiator {
+	if m != nil {
+		return m.OpenInitiator
+	}
+	return ChannelCloseSummary_UNKNOWN
+}
+
+func (m *ChannelCloseSummary) GetCloseInitiator() ChannelCloseSummary_Initiator {
+	if m != nil {
+		return m.CloseInitiator
+	}
+	return ChannelCloseSummary_UNKNOWN
+}
+
 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"`
@@ -10397,6 +10454,7 @@ func init() {
 	proto.RegisterEnum("lnrpc.InvoiceHTLCState", InvoiceHTLCState_name, InvoiceHTLCState_value)
 	proto.RegisterEnum("lnrpc.FeatureBit", FeatureBit_name, FeatureBit_value)
 	proto.RegisterEnum("lnrpc.ChannelCloseSummary_ClosureType", ChannelCloseSummary_ClosureType_name, ChannelCloseSummary_ClosureType_value)
+	proto.RegisterEnum("lnrpc.ChannelCloseSummary_Initiator", ChannelCloseSummary_Initiator_name, ChannelCloseSummary_Initiator_value)
 	proto.RegisterEnum("lnrpc.Peer_SyncType", Peer_SyncType_name, Peer_SyncType_value)
 	proto.RegisterEnum("lnrpc.PeerEvent_EventType", PeerEvent_EventType_name, PeerEvent_EventType_value)
 	proto.RegisterEnum("lnrpc.ChannelEventUpdate_UpdateType", ChannelEventUpdate_UpdateType_name, ChannelEventUpdate_UpdateType_value)
@@ -10570,624 +10628,628 @@ func init() {
 func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
 
 var fileDescriptor_77a6da22d6a3feb1 = []byte{
-	// 9864 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7d, 0x5b, 0x6c, 0x1c, 0xd9,
-	0x95, 0x98, 0xaa, 0x1f, 0x64, 0xf7, 0xe9, 0x07, 0x9b, 0x97, 0x14, 0xd9, 0x6a, 0x3d, 0x46, 0x53,
-	0xd6, 0xce, 0xc8, 0xf2, 0x98, 0xd2, 0xd0, 0xf6, 0xac, 0x76, 0x94, 0xf5, 0x9a, 0x2f, 0x89, 0x9c,
-	0xa1, 0x48, 0xba, 0x48, 0x59, 0x6b, 0x3b, 0x8b, 0x72, 0xb1, 0xfb, 0x92, 0x2c, 0xab, 0xbb, 0xaa,
-	0xa7, 0xaa, 0x9a, 0x14, 0xed, 0x4c, 0x3e, 0x82, 0x24, 0x08, 0xf2, 0x13, 0x18, 0x8b, 0x00, 0xd9,
-	0x3c, 0xb0, 0x80, 0x37, 0x41, 0x10, 0x04, 0x48, 0xf2, 0x15, 0x6c, 0x02, 0xe7, 0x2b, 0x1f, 0x9b,
-	0x9f, 0x20, 0x1f, 0x09, 0x10, 0x20, 0x01, 0x02, 0x2c, 0x36, 0x1f, 0x59, 0x04, 0xc8, 0x57, 0x92,
-	0xef, 0xe0, 0x9e, 0xfb, 0xa8, 0x7b, 0xab, 0xaa, 0x29, 0x8d, 0xed, 0xcc, 0x8f, 0xc4, 0x7b, 0xce,
-	0xad, 0xfb, 0x3c, 0xe7, 0xdc, 0xf3, 0xba, 0xb7, 0xa1, 0x1e, 0x8d, 0xfb, 0x2b, 0xe3, 0x28, 0x4c,
-	0x42, 0x52, 0x1d, 0x06, 0xd1, 0xb8, 0xdf, 0xbb, 0x75, 0x1a, 0x86, 0xa7, 0x43, 0xfa, 0xd0, 0x1b,
-	0xfb, 0x0f, 0xbd, 0x20, 0x08, 0x13, 0x2f, 0xf1, 0xc3, 0x20, 0xe6, 0x95, 0xec, 0x1f, 0x41, 0xfb,
-	0x19, 0x0d, 0x0e, 0x29, 0x1d, 0x38, 0xf4, 0xb3, 0x09, 0x8d, 0x13, 0xf2, 0x35, 0x98, 0xf7, 0xe8,
-	0x4f, 0x28, 0x1d, 0xb8, 0x63, 0x2f, 0x8e, 0xc7, 0x67, 0x91, 0x17, 0xd3, 0xae, 0x75, 0xd7, 0xba,
-	0xdf, 0x74, 0x3a, 0x1c, 0x71, 0xa0, 0xe0, 0xe4, 0x5d, 0x68, 0xc6, 0xac, 0x2a, 0x0d, 0x92, 0x28,
-	0x1c, 0x5f, 0x76, 0x4b, 0x58, 0xaf, 0xc1, 0x60, 0x5b, 0x1c, 0x64, 0x0f, 0x61, 0x4e, 0xf5, 0x10,
-	0x8f, 0xc3, 0x20, 0xa6, 0xe4, 0x11, 0x2c, 0xf6, 0xfd, 0xf1, 0x19, 0x8d, 0x5c, 0xfc, 0x78, 0x14,
-	0xd0, 0x51, 0x18, 0xf8, 0xfd, 0xae, 0x75, 0xb7, 0x7c, 0xbf, 0xee, 0x10, 0x8e, 0x63, 0x5f, 0x3c,
-	0x17, 0x18, 0xf2, 0x3e, 0xcc, 0xd1, 0x80, 0xc3, 0xe9, 0x00, 0xbf, 0x12, 0x5d, 0xb5, 0x53, 0x30,
-	0xfb, 0xc0, 0xfe, 0x1b, 0x25, 0x98, 0xdf, 0x09, 0xfc, 0xe4, 0xa5, 0x37, 0x1c, 0xd2, 0x44, 0xce,
-	0xe9, 0x7d, 0x98, 0xbb, 0x40, 0x00, 0xce, 0xe9, 0x22, 0x8c, 0x06, 0x62, 0x46, 0x6d, 0x0e, 0x3e,
-	0x10, 0xd0, 0xa9, 0x23, 0x2b, 0x4d, 0x1d, 0x59, 0xe1, 0x72, 0x95, 0xa7, 0x2c, 0xd7, 0xfb, 0x30,
-	0x17, 0xd1, 0x7e, 0x78, 0x4e, 0xa3, 0x4b, 0xf7, 0xc2, 0x0f, 0x06, 0xe1, 0x45, 0xb7, 0x72, 0xd7,
-	0xba, 0x5f, 0x75, 0xda, 0x12, 0xfc, 0x12, 0xa1, 0x64, 0x1d, 0xe6, 0xfa, 0x67, 0x5e, 0x10, 0xd0,
-	0xa1, 0x7b, 0xec, 0xf5, 0x5f, 0x4d, 0xc6, 0x71, 0xb7, 0x7a, 0xd7, 0xba, 0xdf, 0x58, 0xbd, 0xb1,
-	0x82, 0xbb, 0xba, 0xb2, 0x71, 0xe6, 0x05, 0xeb, 0x88, 0x39, 0x0c, 0xbc, 0x71, 0x7c, 0x16, 0x26,
-	0x4e, 0x5b, 0x7c, 0xc1, 0xc1, 0xb1, 0xbd, 0x08, 0x44, 0x5f, 0x09, 0xbe, 0xf6, 0xf6, 0x3f, 0xb5,
-	0x60, 0xe1, 0x45, 0x30, 0x0c, 0xfb, 0xaf, 0x7e, 0xc9, 0x25, 0x2a, 0x98, 0x43, 0xe9, 0x6d, 0xe7,
-	0x50, 0xfe, 0xa2, 0x73, 0x58, 0x82, 0x45, 0x73, 0xb0, 0x62, 0x16, 0x14, 0xae, 0xb3, 0xaf, 0x4f,
-	0xa9, 0x1c, 0x96, 0x9c, 0xc6, 0x57, 0xa1, 0xd3, 0x9f, 0x44, 0x11, 0x0d, 0x72, 0xf3, 0x98, 0x13,
-	0x70, 0x35, 0x91, 0x77, 0xa1, 0x19, 0xd0, 0x8b, 0xb4, 0x9a, 0xa0, 0xdd, 0x80, 0x5e, 0xc8, 0x2a,
-	0x76, 0x17, 0x96, 0xb2, 0xdd, 0x88, 0x01, 0xfc, 0xa9, 0x05, 0x95, 0x17, 0xc9, 0xeb, 0x90, 0xac,
-	0x40, 0x25, 0xb9, 0x1c, 0x73, 0x0e, 0x69, 0xaf, 0x12, 0x31, 0xb5, 0xb5, 0xc1, 0x20, 0xa2, 0x71,
-	0x7c, 0x74, 0x39, 0xa6, 0x4e, 0xd3, 0xe3, 0x05, 0x97, 0xd5, 0x23, 0x5d, 0x98, 0x15, 0x65, 0xec,
-	0xb0, 0xee, 0xc8, 0x22, 0xb9, 0x03, 0xe0, 0x8d, 0xc2, 0x49, 0x90, 0xb8, 0xb1, 0x97, 0xe0, 0x52,
-	0x95, 0x1d, 0x0d, 0x42, 0x6e, 0x41, 0x7d, 0xfc, 0xca, 0x8d, 0xfb, 0x91, 0x3f, 0x4e, 0x90, 0x6c,
-	0xea, 0x4e, 0x0a, 0x20, 0x5f, 0x83, 0x5a, 0x38, 0x49, 0xc6, 0xa1, 0x1f, 0x24, 0x82, 0x54, 0xe6,
-	0xc4, 0x58, 0xf6, 0x27, 0xc9, 0x01, 0x03, 0x3b, 0xaa, 0x02, 0xb9, 0x07, 0xad, 0x7e, 0x18, 0x9c,
-	0xf8, 0xd1, 0x88, 0x0b, 0x83, 0xee, 0x0c, 0xf6, 0x66, 0x02, 0xed, 0x7f, 0x55, 0x82, 0xc6, 0x51,
-	0xe4, 0x05, 0xb1, 0xd7, 0x67, 0x00, 0x36, 0xf4, 0xe4, 0xb5, 0x7b, 0xe6, 0xc5, 0x67, 0x38, 0xdb,
-	0xba, 0x23, 0x8b, 0x64, 0x09, 0x66, 0xf8, 0x40, 0x71, 0x4e, 0x65, 0x47, 0x94, 0xc8, 0x07, 0x30,
-	0x1f, 0x4c, 0x46, 0xae, 0xd9, 0x57, 0x19, 0xa9, 0x25, 0x8f, 0x60, 0x0b, 0x70, 0xcc, 0xf6, 0x9a,
-	0x77, 0xc1, 0x67, 0xa8, 0x41, 0x88, 0x0d, 0x4d, 0x51, 0xa2, 0xfe, 0xe9, 0x19, 0x9f, 0x66, 0xd5,
-	0x31, 0x60, 0xac, 0x8d, 0xc4, 0x1f, 0x51, 0x37, 0x4e, 0xbc, 0xd1, 0x58, 0x4c, 0x4b, 0x83, 0x20,
-	0x3e, 0x4c, 0xbc, 0xa1, 0x7b, 0x42, 0x69, 0xdc, 0x9d, 0x15, 0x78, 0x05, 0x21, 0xef, 0x41, 0x7b,
-	0x40, 0xe3, 0xc4, 0x15, 0x9b, 0x42, 0xe3, 0x6e, 0x0d, 0x59, 0x3f, 0x03, 0x65, 0xed, 0x44, 0xde,
-	0x85, 0xcb, 0x16, 0x80, 0xbe, 0xee, 0xd6, 0xf9, 0x58, 0x53, 0x08, 0xa3, 0x9c, 0x67, 0x34, 0xd1,
-	0x56, 0x2f, 0x16, 0x14, 0x6a, 0xef, 0x02, 0xd1, 0xc0, 0x9b, 0x34, 0xf1, 0xfc, 0x61, 0x4c, 0x3e,
-	0x82, 0x66, 0xa2, 0x55, 0x46, 0x51, 0xd8, 0x50, 0xe4, 0xa4, 0x7d, 0xe0, 0x18, 0xf5, 0xec, 0x33,
-	0xa8, 0x3d, 0xa5, 0x74, 0xd7, 0x1f, 0xf9, 0x09, 0x59, 0x82, 0xea, 0x89, 0xff, 0x9a, 0x72, 0x82,
-	0x2f, 0x6f, 0x5f, 0x73, 0x78, 0x91, 0xbc, 0x03, 0x80, 0x7f, 0xb8, 0x23, 0x45, 0x58, 0xdb, 0xd7,
-	0x9c, 0x3a, 0xc2, 0x9e, 0x33, 0xca, 0xea, 0xc1, 0xec, 0x98, 0x46, 0x7d, 0x2a, 0xf7, 0x6f, 0xfb,
-	0x9a, 0x23, 0x01, 0xeb, 0xb3, 0x50, 0x1d, 0xb2, 0xd6, 0xed, 0x3f, 0xa9, 0x42, 0xe3, 0x90, 0x06,
-	0x8a, 0xd3, 0x08, 0x54, 0xd8, 0x9a, 0x08, 0xee, 0xc2, 0xbf, 0xc9, 0x57, 0xa0, 0x81, 0xeb, 0x14,
-	0x27, 0x91, 0x1f, 0x9c, 0x72, 0x02, 0x5f, 0x2f, 0x75, 0x2d, 0x07, 0x18, 0xf8, 0x10, 0xa1, 0xa4,
-	0x03, 0x65, 0x6f, 0x24, 0x09, 0x9c, 0xfd, 0x49, 0x6e, 0x40, 0xcd, 0x1b, 0x25, 0x7c, 0x78, 0x4d,
-	0x04, 0xcf, 0x7a, 0xa3, 0x04, 0x87, 0xf6, 0x2e, 0x34, 0xc7, 0xde, 0xe5, 0x88, 0xf1, 0xb3, 0xa2,
-	0x8a, 0xa6, 0xd3, 0x10, 0xb0, 0x6d, 0x46, 0x16, 0xab, 0xb0, 0xa0, 0x57, 0x91, 0x9d, 0x57, 0x55,
-	0xe7, 0xf3, 0x5a, 0x6d, 0x31, 0x86, 0xf7, 0x61, 0x4e, 0x7e, 0x13, 0xf1, 0xf9, 0x20, 0xad, 0xd4,
-	0x9d, 0xb6, 0x00, 0xcb, 0x59, 0xde, 0x87, 0xce, 0x89, 0x1f, 0x78, 0x43, 0xb7, 0x3f, 0x4c, 0xce,
-	0xdd, 0x01, 0x1d, 0x26, 0x1e, 0x52, 0x4d, 0xd5, 0x69, 0x23, 0x7c, 0x63, 0x98, 0x9c, 0x6f, 0x32,
-	0x28, 0xf9, 0x00, 0xea, 0x27, 0x94, 0xba, 0xb8, 0x58, 0xdd, 0x9a, 0xc1, 0x81, 0x72, 0x87, 0x9c,
-	0xda, 0x89, 0xdc, 0xab, 0x0f, 0xa0, 0x13, 0x4e, 0x92, 0xd3, 0xd0, 0x0f, 0x4e, 0x5d, 0x26, 0xf3,
-	0x5c, 0x7f, 0x80, 0x54, 0x54, 0x59, 0x2f, 0x3d, 0xb2, 0x9c, 0xb6, 0xc4, 0x31, 0xe9, 0xb3, 0x33,
-	0x20, 0xef, 0xc1, 0xdc, 0xd0, 0x8b, 0x13, 0xf7, 0x2c, 0x1c, 0xbb, 0xe3, 0xc9, 0xf1, 0x2b, 0x7a,
-	0xd9, 0x6d, 0xe1, 0x42, 0xb4, 0x18, 0x78, 0x3b, 0x1c, 0x1f, 0x20, 0x90, 0xdc, 0x06, 0xc0, 0x71,
-	0xf2, 0x41, 0xc0, 0x5d, 0xeb, 0x7e, 0xcb, 0xa9, 0x33, 0x08, 0xef, 0xf4, 0xfb, 0xb0, 0x80, 0xdb,
-	0xd3, 0x9f, 0xc4, 0x49, 0x38, 0x72, 0x99, 0xbc, 0x8e, 0x06, 0x71, 0xb7, 0x81, 0xb4, 0xf6, 0x55,
-	0x31, 0x58, 0x6d, 0x8f, 0x57, 0x36, 0x69, 0x9c, 0x6c, 0x60, 0x65, 0x87, 0xd7, 0x65, 0x87, 0xfa,
-	0xa5, 0x33, 0x3f, 0xc8, 0xc2, 0xc9, 0x07, 0x40, 0xbc, 0xe1, 0x30, 0xbc, 0x70, 0x63, 0x3a, 0x3c,
-	0x71, 0xc5, 0x22, 0x76, 0xdb, 0x77, 0xad, 0xfb, 0x35, 0xa7, 0x83, 0x98, 0x43, 0x3a, 0x3c, 0x39,
-	0xe0, 0x70, 0xf2, 0x11, 0xb4, 0x70, 0x20, 0x27, 0xd4, 0x4b, 0x26, 0x11, 0x8d, 0xbb, 0x73, 0x77,
-	0xcb, 0xf7, 0xdb, 0xab, 0xf3, 0x6a, 0xbd, 0x10, 0xbc, 0xee, 0x27, 0x4e, 0x93, 0xd5, 0x13, 0xe5,
-	0xb8, 0xb7, 0x09, 0x4b, 0xc5, 0x43, 0x62, 0x44, 0xc5, 0x56, 0x85, 0x11, 0x63, 0xc5, 0x61, 0x7f,
-	0x92, 0x45, 0xa8, 0x9e, 0x7b, 0xc3, 0x09, 0x15, 0x72, 0x9d, 0x17, 0x3e, 0x2e, 0x3d, 0xb6, 0xec,
-	0x3f, 0xb6, 0xa0, 0xc9, 0x67, 0x29, 0xf4, 0x91, 0x7b, 0xd0, 0x92, 0xd4, 0x40, 0xa3, 0x28, 0x8c,
-	0x84, 0x78, 0x33, 0x81, 0xe4, 0x01, 0x74, 0x24, 0x60, 0x1c, 0x51, 0x7f, 0xe4, 0x9d, 0xca, 0xb6,
-	0x73, 0x70, 0xb2, 0x9a, 0xb6, 0x18, 0x85, 0x93, 0x84, 0x8a, 0x93, 0xaf, 0x29, 0x26, 0xe8, 0x30,
-	0x98, 0x63, 0x56, 0x61, 0xe2, 0xad, 0x80, 0xd4, 0x0d, 0x98, 0xfd, 0xb7, 0x2d, 0x20, 0x6c, 0xe8,
-	0x47, 0x21, 0x6f, 0x42, 0x50, 0x69, 0x96, 0x4b, 0xac, 0xb7, 0xe6, 0x92, 0xd2, 0x55, 0x5c, 0x62,
-	0x43, 0x95, 0x8f, 0xbe, 0x52, 0x30, 0x7a, 0x8e, 0xfa, 0xa4, 0x52, 0x2b, 0x77, 0x2a, 0xf6, 0x7f,
-	0x29, 0xc3, 0xe2, 0x06, 0x3f, 0xba, 0xd7, 0xfa, 0x7d, 0x3a, 0x56, 0xfc, 0xf3, 0x0e, 0x34, 0x82,
-	0x70, 0x40, 0x25, 0xd5, 0xf2, 0x81, 0x01, 0x03, 0x69, 0x24, 0x7b, 0xe6, 0xf9, 0x01, 0x1f, 0x38,
-	0x5f, 0xcf, 0x3a, 0x42, 0x70, 0xd8, 0xef, 0xc1, 0xdc, 0x98, 0x06, 0x03, 0x9d, 0x4d, 0xb8, 0x72,
-	0xd5, 0x12, 0x60, 0xc1, 0x21, 0xef, 0x40, 0xe3, 0x64, 0xc2, 0xeb, 0x31, 0xe1, 0x52, 0x41, 0x3a,
-	0x00, 0x01, 0x5a, 0xe3, 0x32, 0x66, 0x3c, 0x89, 0xcf, 0x10, 0x5b, 0x45, 0xec, 0x2c, 0x2b, 0x33,
-	0xd4, 0x6d, 0x80, 0xc1, 0x24, 0x4e, 0x04, 0xd7, 0xcc, 0x20, 0xb2, 0xce, 0x20, 0x9c, 0x6b, 0xbe,
-	0x0e, 0x0b, 0x23, 0xef, 0xb5, 0x8b, 0xf4, 0xe3, 0xfa, 0x81, 0x7b, 0x32, 0xc4, 0xd3, 0x67, 0x16,
-	0xeb, 0x75, 0x46, 0xde, 0xeb, 0xef, 0x31, 0xcc, 0x4e, 0xf0, 0x14, 0xe1, 0x4c, 0xb4, 0x48, 0xb5,
-	0x27, 0xa2, 0x31, 0x8d, 0xce, 0x29, 0x4a, 0x83, 0x8a, 0xd2, 0x6d, 0x1c, 0x0e, 0x65, 0x23, 0x1a,
-	0xb1, 0x79, 0x27, 0xc3, 0x3e, 0x67, 0x7d, 0x67, 0x76, 0xe4, 0x07, 0xdb, 0xc9, 0xb0, 0x4f, 0x6e,
-	0x01, 0x30, 0x59, 0x32, 0xa6, 0x91, 0xfb, 0xea, 0x02, 0xf9, 0xb8, 0x82, 0xb2, 0xe3, 0x80, 0x46,
-	0x9f, 0x5e, 0x90, 0x9b, 0x50, 0xef, 0xc7, 0x28, 0x8c, 0xbc, 0xcb, 0x6e, 0x03, 0x99, 0xbc, 0xd6,
-	0x8f, 0x99, 0x18, 0xf2, 0x2e, 0x19, 0x23, 0xb2, 0xd1, 0x7a, 0xb8, 0x0b, 0x74, 0x80, 0xcd, 0xc7,
-	0x28, 0x55, 0x5b, 0x38, 0xd8, 0x35, 0x81, 0x60, 0xfd, 0xc4, 0xe4, 0x2b, 0xd0, 0x92, 0x83, 0x3d,
-	0x19, 0x7a, 0xa7, 0x31, 0x8a, 0x95, 0x96, 0xd3, 0x14, 0xc0, 0xa7, 0x0c, 0x66, 0xbf, 0xe4, 0xca,
-	0x96, 0xb6, 0xb7, 0x82, 0x6f, 0xd8, 0xb1, 0x8f, 0x10, 0xdc, 0xd7, 0x9a, 0x23, 0x4a, 0x45, 0x9b,
-	0x56, 0x2a, 0xd8, 0x34, 0xfb, 0xe7, 0x16, 0x34, 0x45, 0xcb, 0xa8, 0xa1, 0x90, 0x47, 0x40, 0xe4,
-	0x2e, 0x26, 0xaf, 0xfd, 0x81, 0x7b, 0x7c, 0x99, 0xd0, 0x98, 0x13, 0xcd, 0xf6, 0x35, 0xa7, 0x00,
-	0xc7, 0xe4, 0xa8, 0x01, 0x8d, 0x93, 0x88, 0xd3, 0xf4, 0xf6, 0x35, 0x27, 0x87, 0x61, 0x2c, 0xc6,
-	0x74, 0xa0, 0x49, 0xe2, 0xfa, 0xc1, 0x80, 0xbe, 0x46, 0x52, 0x6a, 0x39, 0x06, 0x6c, 0xbd, 0x0d,
-	0x4d, 0xfd, 0x3b, 0xfb, 0xc7, 0x50, 0x93, 0x1a, 0x14, 0x6a, 0x0f, 0x99, 0x71, 0x39, 0x1a, 0x84,
-	0xf4, 0xa0, 0x66, 0x8e, 0xc2, 0xa9, 0x7d, 0x91, 0xbe, 0xed, 0x6f, 0x43, 0x67, 0x97, 0x11, 0x51,
-	0xc0, 0x88, 0x56, 0xa8, 0x85, 0x4b, 0x30, 0xa3, 0x31, 0x4f, 0xdd, 0x11, 0x25, 0x76, 0xfe, 0x9e,
-	0x85, 0x71, 0x22, 0xfa, 0xc1, 0xbf, 0xed, 0x3f, 0xb1, 0x80, 0x6c, 0xc5, 0x89, 0x3f, 0xf2, 0x12,
-	0xfa, 0x94, 0x2a, 0xf1, 0xb0, 0x0f, 0x4d, 0xd6, 0xda, 0x51, 0xb8, 0xc6, 0x95, 0x34, 0xae, 0x5c,
-	0x7c, 0x4d, 0xb0, 0x73, 0xfe, 0x83, 0x15, 0xbd, 0x36, 0x17, 0xf9, 0x46, 0x03, 0x8c, 0xdb, 0x12,
-	0x2f, 0x3a, 0xa5, 0x09, 0x6a, 0x70, 0x42, 0xff, 0x07, 0x0e, 0xda, 0x08, 0x83, 0x93, 0xde, 0xef,
-	0xc0, 0x7c, 0xae, 0x0d, 0x5d, 0x46, 0xd7, 0x0b, 0x64, 0x74, 0x59, 0x97, 0xd1, 0x7d, 0x58, 0x30,
-	0xc6, 0x25, 0x28, 0xae, 0x0b, 0xb3, 0x8c, 0x31, 0x98, 0xa2, 0x60, 0x71, 0x45, 0x41, 0x14, 0xc9,
-	0x2a, 0x2c, 0x9e, 0x50, 0x1a, 0x79, 0x09, 0x16, 0x91, 0x75, 0xd8, 0x9e, 0x88, 0x96, 0x0b, 0x71,
-	0xf6, 0x9f, 0x59, 0x30, 0xc7, 0xa4, 0xe9, 0x73, 0x2f, 0xb8, 0x94, 0x6b, 0xb5, 0x5b, 0xb8, 0x56,
-	0xf7, 0xb5, 0xc3, 0x51, 0xab, 0xfd, 0x45, 0x17, 0xaa, 0x9c, 0x5d, 0x28, 0x72, 0x17, 0x9a, 0xc6,
-	0x70, 0xab, 0x5c, 0x23, 0x8d, 0xbd, 0xe4, 0x80, 0x46, 0xeb, 0x97, 0x09, 0xfd, 0xd5, 0x97, 0xf2,
-	0x3d, 0xe8, 0xa4, 0xc3, 0x16, 0xeb, 0x48, 0xa0, 0xc2, 0x08, 0x53, 0x34, 0x80, 0x7f, 0xdb, 0x7f,
-	0xdf, 0xe2, 0x15, 0x37, 0x42, 0x5f, 0x69, 0xab, 0xac, 0x22, 0x53, 0x7a, 0x65, 0x45, 0xf6, 0xf7,
-	0x54, 0x6d, 0xff, 0x57, 0x9f, 0x2c, 0x93, 0x89, 0x31, 0x0d, 0x06, 0xae, 0x37, 0x1c, 0xa2, 0x20,
-	0xae, 0x39, 0xb3, 0xac, 0xbc, 0x36, 0x1c, 0xda, 0xef, 0xc3, 0xbc, 0x36, 0xba, 0x2b, 0xe6, 0xb1,
-	0x07, 0x64, 0xd7, 0x8f, 0x93, 0x17, 0x41, 0x3c, 0xd6, 0x14, 0xb9, 0x9b, 0x50, 0x67, 0xd2, 0x96,
-	0x8d, 0x8c, 0x73, 0x6e, 0xd5, 0x61, 0xe2, 0x97, 0x8d, 0x2b, 0x46, 0xa4, 0xf7, 0x5a, 0x20, 0x4b,
-	0x02, 0xe9, 0xbd, 0x46, 0xa4, 0xfd, 0x18, 0x16, 0x8c, 0xf6, 0x44, 0xd7, 0xef, 0x42, 0x75, 0x92,
-	0xbc, 0x0e, 0xa5, 0xaa, 0xde, 0x10, 0x14, 0xc2, 0x8c, 0x42, 0x87, 0x63, 0xec, 0x27, 0x30, 0xbf,
-	0x47, 0x2f, 0x04, 0x23, 0xcb, 0x81, 0xbc, 0xf7, 0x46, 0x83, 0x11, 0xf1, 0xf6, 0x0a, 0x10, 0xfd,
-	0xe3, 0x94, 0x01, 0xa4, 0xf9, 0x68, 0x19, 0xe6, 0xa3, 0xfd, 0x1e, 0x90, 0x43, 0xff, 0x34, 0x78,
-	0x4e, 0xe3, 0xd8, 0x3b, 0x55, 0xac, 0xdf, 0x81, 0xf2, 0x28, 0x3e, 0x15, 0xa2, 0x8a, 0xfd, 0x69,
-	0x7f, 0x03, 0x16, 0x8c, 0x7a, 0xa2, 0xe1, 0x5b, 0x50, 0x8f, 0xfd, 0xd3, 0x00, 0x15, 0x2d, 0xd1,
-	0x74, 0x0a, 0xb0, 0x9f, 0xc2, 0xe2, 0xf7, 0x68, 0xe4, 0x9f, 0x5c, 0xbe, 0xa9, 0x79, 0xb3, 0x9d,
-	0x52, 0xb6, 0x9d, 0x2d, 0xb8, 0x9e, 0x69, 0x47, 0x74, 0xcf, 0xc9, 0x57, 0xec, 0x64, 0xcd, 0xe1,
-	0x05, 0x4d, 0xf6, 0x95, 0x74, 0xd9, 0x67, 0xbf, 0x00, 0xb2, 0x11, 0x06, 0x01, 0xed, 0x27, 0x07,
-	0x94, 0x46, 0xa9, 0xe7, 0x2a, 0xa5, 0xd5, 0xc6, 0xea, 0xb2, 0x58, 0xd9, 0xac, 0x40, 0x15, 0x44,
-	0x4c, 0xa0, 0x32, 0xa6, 0xd1, 0x08, 0x1b, 0xae, 0x39, 0xf8, 0xb7, 0x7d, 0x1d, 0x16, 0x8c, 0x66,
-	0x85, 0xad, 0xff, 0x21, 0x5c, 0xdf, 0xf4, 0xe3, 0x7e, 0xbe, 0xc3, 0x2e, 0xcc, 0x8e, 0x27, 0xc7,
-	0x6e, 0xca, 0x89, 0xb2, 0xc8, 0xcc, 0xbf, 0xec, 0x27, 0xa2, 0xb1, 0xbf, 0x6e, 0x41, 0x65, 0xfb,
-	0x68, 0x77, 0x83, 0x9d, 0x15, 0x7e, 0xd0, 0x0f, 0x47, 0x4c, 0x0b, 0xe3, 0x93, 0x56, 0xe5, 0xa9,
-	0x1c, 0x76, 0x0b, 0xea, 0xa8, 0xbc, 0x31, 0x8b, 0x57, 0xe8, 0x41, 0x29, 0x80, 0x59, 0xdb, 0xf4,
-	0xf5, 0xd8, 0x8f, 0xd0, 0x9c, 0x96, 0x46, 0x72, 0x05, 0x8f, 0x99, 0x3c, 0xc2, 0xfe, 0x77, 0xb3,
-	0x30, 0x2b, 0x0e, 0x5f, 0x7e, 0x90, 0x27, 0xfe, 0x39, 0x4d, 0x0f, 0x72, 0x56, 0x62, 0x8a, 0x71,
-	0x44, 0x47, 0x61, 0xa2, 0xf4, 0x37, 0xbe, 0x0d, 0x26, 0x10, 0xbd, 0x09, 0x42, 0x89, 0xe0, 0xfe,
-	0x87, 0x32, 0xaf, 0x65, 0x00, 0xc9, 0x2d, 0x98, 0x95, 0xca, 0x40, 0x45, 0x19, 0x3a, 0x12, 0xc4,
-	0x56, 0xa3, 0xef, 0x8d, 0xbd, 0xbe, 0x9f, 0x5c, 0x0a, 0xb1, 0xa0, 0xca, 0xac, 0xfd, 0x61, 0xd8,
-	0xf7, 0x86, 0xee, 0xb1, 0x37, 0xf4, 0x82, 0x3e, 0x95, 0xde, 0x0a, 0x03, 0xc8, 0x2c, 0x77, 0x31,
-	0x2c, 0x59, 0x8d, 0x5b, 0xf7, 0x19, 0x28, 0x3b, 0xc3, 0xfb, 0xe1, 0x68, 0xe4, 0x33, 0xeb, 0x83,
-	0xab, 0x66, 0x65, 0x47, 0x83, 0x70, 0xdf, 0x08, 0x96, 0x2e, 0xf8, 0x0a, 0xd6, 0xa5, 0x6f, 0x44,
-	0x03, 0xb2, 0x56, 0x32, 0x1a, 0x5a, 0xd9, 0xd1, 0x20, 0x6c, 0x2f, 0x26, 0x41, 0x4c, 0x93, 0x64,
-	0x48, 0x07, 0x6a, 0x40, 0x0d, 0xac, 0x96, 0x47, 0x90, 0x47, 0xb0, 0xc0, 0x7d, 0x10, 0xb1, 0x97,
-	0x84, 0xf1, 0x99, 0x1f, 0xbb, 0x31, 0x33, 0x9f, 0xb8, 0x2d, 0x5c, 0x84, 0x22, 0x8f, 0x61, 0x39,
-	0x03, 0x8e, 0x68, 0x9f, 0xfa, 0xe7, 0x74, 0x80, 0x2a, 0x5c, 0xd9, 0x99, 0x86, 0x26, 0x77, 0xa1,
-	0x11, 0x4c, 0x46, 0xee, 0x64, 0x3c, 0xf0, 0x98, 0x12, 0xd3, 0x46, 0xe5, 0x52, 0x07, 0x91, 0x0f,
-	0x41, 0xea, 0x69, 0x42, 0x7b, 0x9c, 0x33, 0x24, 0x1c, 0xa3, 0x5e, 0xc7, 0xac, 0xc1, 0x08, 0x33,
-	0x55, 0x49, 0x3b, 0xc2, 0xee, 0x94, 0x00, 0xe4, 0x93, 0xc8, 0x3f, 0xf7, 0x12, 0xda, 0x9d, 0xe7,
-	0x42, 0x5d, 0x14, 0xd9, 0x77, 0x7e, 0xe0, 0x27, 0xbe, 0x97, 0x84, 0x51, 0x97, 0x20, 0x2e, 0x05,
-	0xb0, 0x45, 0x44, 0xfa, 0x88, 0x13, 0x2f, 0x99, 0xc4, 0x42, 0x43, 0x5d, 0x40, 0xe2, 0xca, 0x23,
-	0xc8, 0x47, 0xb0, 0xc4, 0x29, 0x02, 0x51, 0x42, 0xf7, 0x46, 0x55, 0x61, 0x11, 0x57, 0x64, 0x0a,
-	0x96, 0x2d, 0xa5, 0x20, 0x91, 0xdc, 0x87, 0xd7, 0xf9, 0x52, 0x4e, 0x41, 0xb3, 0xf1, 0xb1, 0x11,
-	0xf8, 0x7d, 0x57, 0xd4, 0x60, 0x2c, 0xb2, 0x84, 0xb3, 0xc8, 0x23, 0x18, 0x89, 0x0f, 0xfd, 0x13,
-	0x9a, 0xf8, 0x23, 0xda, 0x5d, 0xe6, 0x24, 0x2e, 0xcb, 0x8c, 0x01, 0x27, 0x63, 0xc4, 0x74, 0x39,
-	0xc3, 0xf3, 0x12, 0x12, 0xe3, 0x30, 0x8c, 0xa9, 0xf4, 0x3c, 0x75, 0x6f, 0x08, 0xd6, 0xd2, 0x81,
-	0xf6, 0x1f, 0x5a, 0xfc, 0x88, 0x12, 0xec, 0x1c, 0x6b, 0xc6, 0x17, 0x67, 0x64, 0x37, 0x0c, 0x86,
-	0x97, 0x82, 0xb7, 0x81, 0x83, 0xf6, 0x83, 0xe1, 0x25, 0x53, 0xff, 0xfd, 0x40, 0xaf, 0xc2, 0xa5,
-	0x61, 0x53, 0x02, 0xb1, 0xd2, 0x3b, 0xd0, 0x18, 0x4f, 0x8e, 0x87, 0x7e, 0x9f, 0x57, 0x29, 0xf3,
-	0x56, 0x38, 0x08, 0x2b, 0x30, 0xeb, 0x93, 0xef, 0x27, 0xaf, 0x51, 0xc1, 0x1a, 0x0d, 0x01, 0x63,
-	0x55, 0xec, 0x75, 0x58, 0x34, 0x07, 0x28, 0xc4, 0xfe, 0x03, 0xa8, 0x09, 0x29, 0x21, 0xdd, 0x10,
-	0x6d, 0xcd, 0x39, 0xcc, 0x8c, 0x25, 0x85, 0xb7, 0xff, 0x75, 0x05, 0x16, 0x04, 0x74, 0x83, 0x4d,
-	0xff, 0x70, 0x32, 0x1a, 0x79, 0x51, 0x81, 0xf8, 0xb1, 0xde, 0x20, 0x7e, 0x4a, 0x79, 0xf1, 0x73,
-	0xc7, 0xb0, 0x42, 0xb9, 0xfc, 0xd2, 0x20, 0xe4, 0x3e, 0xcc, 0xb1, 0x25, 0xe7, 0x46, 0x81, 0xee,
-	0x9f, 0xcc, 0x82, 0xf3, 0x22, 0xb3, 0x5a, 0x24, 0x32, 0x75, 0x71, 0x37, 0x93, 0x11, 0x77, 0x36,
-	0x34, 0xf9, 0xf6, 0x0a, 0x09, 0x3e, 0x2b, 0x4c, 0x32, 0x0d, 0xc6, 0xc6, 0x93, 0x15, 0x2e, 0x5c,
-	0x92, 0xcd, 0x15, 0x89, 0x16, 0x7f, 0x44, 0xf1, 0x84, 0xd0, 0x6a, 0xd7, 0x85, 0x68, 0xc9, 0xa3,
-	0xc8, 0x53, 0x00, 0xde, 0x17, 0xaa, 0x29, 0x80, 0x6a, 0xca, 0x7b, 0xe6, 0xae, 0xe8, 0xeb, 0xbf,
-	0xc2, 0x0a, 0x93, 0x88, 0xa2, 0xea, 0xa2, 0x7d, 0x69, 0xff, 0x4d, 0x0b, 0x1a, 0x1a, 0x8e, 0x5c,
-	0x87, 0xf9, 0x8d, 0xfd, 0xfd, 0x83, 0x2d, 0x67, 0xed, 0x68, 0xe7, 0x7b, 0x5b, 0xee, 0xc6, 0xee,
-	0xfe, 0xe1, 0x56, 0xe7, 0x1a, 0x03, 0xef, 0xee, 0x6f, 0xac, 0xed, 0xba, 0x4f, 0xf7, 0x9d, 0x0d,
-	0x09, 0xb6, 0xc8, 0x12, 0x10, 0x67, 0xeb, 0xf9, 0xfe, 0xd1, 0x96, 0x01, 0x2f, 0x91, 0x0e, 0x34,
-	0xd7, 0x9d, 0xad, 0xb5, 0x8d, 0x6d, 0x01, 0x29, 0x93, 0x45, 0xe8, 0x3c, 0x7d, 0xb1, 0xb7, 0xb9,
-	0xb3, 0xf7, 0xcc, 0xdd, 0x58, 0xdb, 0xdb, 0xd8, 0xda, 0xdd, 0xda, 0xec, 0x54, 0x48, 0x0b, 0xea,
-	0x6b, 0xeb, 0x6b, 0x7b, 0x9b, 0xfb, 0x7b, 0x5b, 0x9b, 0x9d, 0xaa, 0xfd, 0xdf, 0x2c, 0xb8, 0x8e,
-	0xa3, 0x1e, 0x64, 0x99, 0xe4, 0x2e, 0x34, 0xfa, 0x61, 0x38, 0x66, 0xe6, 0x41, 0x7a, 0x00, 0xea,
-	0x20, 0xc6, 0x00, 0x5c, 0x74, 0x9c, 0x84, 0x51, 0x9f, 0x0a, 0x1e, 0x01, 0x04, 0x3d, 0x65, 0x10,
-	0xc6, 0x00, 0x62, 0x7b, 0x79, 0x0d, 0xce, 0x22, 0x0d, 0x0e, 0xe3, 0x55, 0x96, 0x60, 0xe6, 0x38,
-	0xa2, 0x5e, 0xff, 0x4c, 0x70, 0x87, 0x28, 0x91, 0xaf, 0xa6, 0xf6, 0x6b, 0x9f, 0xad, 0xfe, 0x90,
-	0x0e, 0x90, 0x62, 0x6a, 0xce, 0x9c, 0x80, 0x6f, 0x08, 0x30, 0x93, 0x95, 0xde, 0xb1, 0x17, 0x0c,
-	0xc2, 0x80, 0x0e, 0x84, 0x72, 0x9c, 0x02, 0xec, 0x03, 0x58, 0xca, 0xce, 0x4f, 0xf0, 0xd8, 0x47,
-	0x1a, 0x8f, 0x71, 0x5d, 0xb5, 0x37, 0x7d, 0x37, 0x35, 0x7e, 0xfb, 0xb3, 0x32, 0x54, 0x98, 0xea,
-	0x32, 0x5d, 0xcd, 0xd1, 0xb5, 0xd1, 0x72, 0x2e, 0x98, 0x81, 0x26, 0x31, 0x3f, 0xc8, 0x84, 0x3b,
-	0x26, 0x85, 0xa4, 0xf8, 0x88, 0xf6, 0xcf, 0x85, 0x43, 0x46, 0x83, 0x30, 0x06, 0x61, 0xa6, 0x02,
-	0x7e, 0x2d, 0x18, 0x44, 0x96, 0x25, 0x0e, 0xbf, 0x9c, 0x4d, 0x71, 0xf8, 0x5d, 0x17, 0x66, 0xfd,
-	0xe0, 0x38, 0x9c, 0x04, 0x03, 0x64, 0x88, 0x9a, 0x23, 0x8b, 0x18, 0x3e, 0x41, 0x46, 0x65, 0x52,
-	0x96, 0x93, 0x7f, 0x0a, 0x20, 0xab, 0x50, 0x8f, 0x2f, 0x83, 0xbe, 0x4e, 0xf3, 0x8b, 0x62, 0x95,
-	0xd8, 0x1a, 0xac, 0x1c, 0x5e, 0x06, 0x7d, 0xa4, 0xf0, 0xb4, 0x1a, 0xf9, 0x16, 0xd4, 0x94, 0x03,
-	0x93, 0x0b, 0xaf, 0x1b, 0xfa, 0x27, 0xd2, 0x6b, 0xc9, 0xed, 0x42, 0x55, 0xb5, 0xf7, 0x29, 0xb4,
-	0x0c, 0x94, 0x6e, 0xcc, 0xb5, 0xb8, 0x31, 0x77, 0x4f, 0x37, 0xe6, 0x52, 0x99, 0x28, 0x3e, 0xd3,
-	0x8d, 0xbb, 0xdf, 0x81, 0x9a, 0x1c, 0x1a, 0x63, 0x8d, 0x17, 0x7b, 0x9f, 0xee, 0xed, 0xbf, 0xdc,
-	0x73, 0x0f, 0xbf, 0xbf, 0xb7, 0xd1, 0xb9, 0x46, 0xe6, 0xa0, 0xb1, 0xb6, 0x81, 0xdc, 0x86, 0x00,
-	0x8b, 0x55, 0x39, 0x58, 0x3b, 0x3c, 0x54, 0x90, 0x92, 0x4d, 0xa0, 0xc3, 0x24, 0x33, 0x1b, 0xb1,
-	0x0a, 0x51, 0x7c, 0x04, 0xf3, 0x1a, 0x2c, 0xb5, 0x77, 0xc6, 0x0c, 0x90, 0xb1, 0x77, 0x50, 0xb9,
-	0xe5, 0x18, 0x7b, 0x19, 0xae, 0xb3, 0xe2, 0xd6, 0x39, 0x0d, 0x92, 0xc3, 0xc9, 0x31, 0x8f, 0x4c,
-	0xf9, 0x61, 0x60, 0xff, 0x35, 0x0b, 0xea, 0x0a, 0x73, 0x05, 0x3d, 0xc9, 0x60, 0x5a, 0x09, 0x37,
-	0xa0, 0xa7, 0x75, 0x81, 0x5f, 0xae, 0xe0, 0xbf, 0x86, 0x8d, 0x54, 0x57, 0x20, 0x36, 0xd9, 0x83,
-	0xad, 0x2d, 0xc7, 0xdd, 0xdf, 0xdb, 0xdd, 0xd9, 0x63, 0x92, 0x85, 0x4d, 0x16, 0x01, 0x4f, 0x9f,
-	0x22, 0xc4, 0xb2, 0x3b, 0xd0, 0x7e, 0x46, 0x93, 0x9d, 0xe0, 0x24, 0x94, 0x53, 0xfd, 0xbf, 0x55,
-	0x98, 0x53, 0xa0, 0xd4, 0xc6, 0x3a, 0xa7, 0x51, 0xec, 0x87, 0x01, 0x6a, 0x47, 0x75, 0x47, 0x16,
-	0x99, 0xd8, 0xf5, 0x07, 0x34, 0x48, 0xfc, 0xe4, 0xd2, 0x35, 0x9c, 0x32, 0x59, 0x30, 0xb3, 0x67,
-	0xbc, 0xa1, 0xef, 0xc9, 0x20, 0x1f, 0x2f, 0x30, 0x68, 0x3f, 0x1c, 0x86, 0x11, 0xaa, 0x41, 0x75,
-	0x87, 0x17, 0xc8, 0x2a, 0x2c, 0x32, 0xf5, 0x4b, 0x77, 0x99, 0x21, 0xb3, 0x72, 0x0f, 0x51, 0x21,
-	0x8e, 0x89, 0x75, 0x06, 0x17, 0x67, 0xb7, 0xfa, 0x84, 0x6b, 0xfb, 0x45, 0x28, 0xf2, 0x4d, 0xb8,
-	0xce, 0xc0, 0xea, 0xbc, 0x57, 0xdf, 0xcc, 0xe1, 0x37, 0xc5, 0x48, 0xc6, 0x35, 0xbc, 0x7f, 0xb6,
-	0xf3, 0x55, 0xae, 0xd8, 0x29, 0x40, 0x2e, 0x22, 0x37, 0xc3, 0x8f, 0xaa, 0x6c, 0x44, 0x4e, 0x8b,
-	0xea, 0xd5, 0x72, 0x51, 0xbd, 0x6f, 0xc2, 0xf5, 0x63, 0x1a, 0x27, 0xee, 0x19, 0xf5, 0x06, 0x34,
-	0x42, 0x6e, 0xe4, 0xc1, 0x3b, 0xae, 0xc7, 0x16, 0x23, 0xf1, 0x00, 0xbc, 0x0c, 0xfa, 0x74, 0xe0,
-	0x26, 0xa1, 0x8b, 0x07, 0x35, 0xf2, 0x74, 0xcd, 0xc9, 0x82, 0xcd, 0x9a, 0xa7, 0x91, 0x37, 0x3e,
-	0x13, 0x8a, 0x66, 0x16, 0xcc, 0x54, 0x84, 0x84, 0xc6, 0x49, 0x40, 0x79, 0xe8, 0xa4, 0x86, 0x6e,
-	0x71, 0x09, 0x22, 0xf7, 0x60, 0x06, 0x1b, 0x8c, 0xbb, 0x1d, 0x64, 0x80, 0x66, 0x2a, 0x44, 0xfd,
-	0xc0, 0x11, 0x38, 0x66, 0x56, 0x4e, 0x22, 0x3f, 0xee, 0x36, 0x31, 0x6a, 0x88, 0x7f, 0x93, 0xef,
-	0x68, 0x72, 0x62, 0x01, 0xbf, 0xbd, 0x27, 0xbe, 0xcd, 0x50, 0xde, 0x97, 0x22, 0x32, 0x3e, 0xa9,
-	0xd4, 0x1a, 0x9d, 0xa6, 0xfd, 0x9b, 0x50, 0xc5, 0x91, 0x23, 0x4d, 0xe2, 0xfa, 0x59, 0x82, 0x26,
-	0x11, 0xda, 0x85, 0xd9, 0x80, 0x26, 0x17, 0x61, 0xf4, 0x4a, 0x86, 0xa9, 0x45, 0xd1, 0xfe, 0x09,
-	0xda, 0xde, 0x2a, 0x6c, 0xfb, 0x02, 0x8d, 0x06, 0x72, 0x13, 0xea, 0x7c, 0x4f, 0xe3, 0x33, 0x4f,
-	0xb8, 0x03, 0x6a, 0x08, 0x38, 0x3c, 0xf3, 0xd8, 0xf9, 0x68, 0x90, 0x09, 0xf7, 0xb0, 0x34, 0x10,
-	0xb6, 0xcd, 0xa9, 0xe4, 0x1e, 0xb4, 0x65, 0x40, 0x38, 0x76, 0x87, 0xf4, 0x24, 0x91, 0xfe, 0xd1,
-	0x60, 0x32, 0x42, 0x37, 0xcc, 0x2e, 0x3d, 0x49, 0xec, 0x3d, 0x98, 0x17, 0x67, 0xd6, 0xfe, 0x98,
-	0xca, 0xae, 0x7f, 0xab, 0x48, 0xff, 0x6b, 0xac, 0x2e, 0x98, 0x87, 0x1c, 0x0f, 0x81, 0x9b, 0x35,
-	0x6d, 0x07, 0x88, 0x7e, 0x06, 0x8a, 0x06, 0x85, 0x02, 0x26, 0x3d, 0xc0, 0x62, 0x3a, 0x06, 0x8c,
-	0xad, 0x4f, 0x3c, 0xe9, 0xf7, 0x65, 0x18, 0xbf, 0xe6, 0xc8, 0xa2, 0xfd, 0x9f, 0x2c, 0x58, 0xc0,
-	0xd6, 0xa4, 0x06, 0x2b, 0xf4, 0x8c, 0xc7, 0x5f, 0x60, 0x98, 0xd2, 0xff, 0xce, 0xbd, 0xce, 0x8b,
-	0x50, 0xd5, 0x35, 0x0f, 0x5e, 0xf8, 0xe2, 0xde, 0xb6, 0x4a, 0xce, 0xdb, 0xf6, 0x00, 0x3a, 0x03,
-	0x3a, 0xf4, 0x31, 0x95, 0x43, 0x9e, 0xe3, 0x5c, 0x5d, 0xcd, 0xc1, 0xed, 0xbf, 0x63, 0xc1, 0x3c,
-	0x57, 0x14, 0xd0, 0xe6, 0x12, 0x4b, 0xf5, 0x17, 0xa4, 0x7d, 0x22, 0x04, 0x94, 0x98, 0x54, 0x7a,
-	0x74, 0x22, 0x94, 0x57, 0xde, 0xbe, 0xe6, 0x98, 0x95, 0xc9, 0x13, 0xd4, 0xba, 0x03, 0x17, 0xa1,
-	0x05, 0xc9, 0x21, 0xe6, 0xbe, 0x6c, 0x5f, 0x73, 0xb4, 0xea, 0xeb, 0x35, 0x66, 0x32, 0x31, 0xb8,
-	0xfd, 0x0c, 0x5a, 0x46, 0x47, 0x86, 0x57, 0xb0, 0xc9, 0xbd, 0x82, 0x39, 0xf7, 0x7b, 0xa9, 0xc0,
-	0xfd, 0xfe, 0xfb, 0x15, 0x20, 0x8c, 0xb0, 0x32, 0x3b, 0x77, 0xd7, 0x8c, 0x61, 0xc9, 0x3c, 0x91,
-	0x14, 0x44, 0x56, 0x81, 0x68, 0x45, 0x19, 0x5b, 0x2b, 0xab, 0xd8, 0x5a, 0x01, 0x96, 0x49, 0x7d,
-	0xa1, 0x55, 0xaa, 0xb8, 0x15, 0x7a, 0x7c, 0xf8, 0x36, 0x15, 0xe2, 0x98, 0xe6, 0x83, 0x41, 0x2c,
-	0x66, 0x9b, 0x0a, 0x2f, 0x89, 0x2c, 0x67, 0xe9, 0x61, 0xe6, 0x8d, 0xf4, 0x30, 0x9b, 0xa3, 0x07,
-	0xcd, 0x4e, 0xaf, 0x99, 0x76, 0xfa, 0x3d, 0x68, 0xc9, 0x58, 0x15, 0x0f, 0xd3, 0x0b, 0xa7, 0x88,
-	0x01, 0x64, 0xf4, 0x24, 0x4d, 0x65, 0xe5, 0x0c, 0xe0, 0x41, 0xe8, 0x1c, 0x9c, 0x1d, 0x2c, 0xa9,
-	0x3f, 0xb6, 0x81, 0x83, 0x4d, 0x01, 0x68, 0x59, 0x33, 0x2a, 0x71, 0x27, 0x81, 0xc8, 0x11, 0xa1,
-	0x03, 0x74, 0x87, 0x30, 0xcb, 0x3a, 0x8b, 0xc8, 0x5b, 0xc9, 0xad, 0x02, 0x2b, 0x99, 0x7c, 0x94,
-	0x06, 0x76, 0xe2, 0x33, 0x7f, 0x84, 0x67, 0x7b, 0x9a, 0x62, 0xf1, 0x94, 0xa3, 0x0e, 0xcf, 0xfc,
-	0x91, 0x63, 0xd4, 0xb3, 0x7f, 0x61, 0x41, 0x87, 0x51, 0x85, 0x41, 0xf8, 0x1f, 0x03, 0xf2, 0xe8,
-	0x5b, 0xd2, 0xbd, 0x51, 0x97, 0x3c, 0x86, 0x3a, 0x96, 0xc3, 0x31, 0x0d, 0x04, 0xd5, 0x77, 0x4d,
-	0xaa, 0x4f, 0xa5, 0xdb, 0xf6, 0x35, 0x27, 0xad, 0xcc, 0xce, 0xb2, 0x6c, 0x60, 0x8d, 0x47, 0x89,
-	0xb3, 0x60, 0x8d, 0x3b, 0xb6, 0x01, 0x3e, 0xa5, 0x97, 0xbb, 0x61, 0x1f, 0x5d, 0x2a, 0xb7, 0x01,
-	0x18, 0x0d, 0x9e, 0x78, 0x23, 0x5f, 0x78, 0x04, 0xaa, 0x4e, 0xfd, 0x15, 0xbd, 0x7c, 0x8a, 0x00,
-	0x26, 0xc6, 0x19, 0x3a, 0x65, 0x91, 0xaa, 0x53, 0x7b, 0x45, 0x2f, 0x77, 0x90, 0x3d, 0x5c, 0x68,
-	0x7d, 0x4a, 0x2f, 0x37, 0x29, 0xd7, 0xeb, 0xc2, 0x88, 0xd8, 0xd0, 0x8a, 0xbc, 0x0b, 0xa6, 0xb9,
-	0x19, 0x11, 0xb1, 0x46, 0xe4, 0x5d, 0x7c, 0x4a, 0x2f, 0xd7, 0x31, 0x24, 0xf6, 0x00, 0x66, 0x19,
-	0x7e, 0x18, 0xf6, 0xc5, 0xc9, 0x24, 0x83, 0xfc, 0xe9, 0xa0, 0x9c, 0x99, 0x57, 0xf8, 0xb7, 0xfd,
-	0x1f, 0x2c, 0x68, 0xb1, 0x15, 0x40, 0xb1, 0xc7, 0x76, 0x42, 0xe6, 0x8a, 0x58, 0x69, 0xae, 0xc8,
-	0xaa, 0x90, 0x19, 0x5c, 0x86, 0x96, 0xa6, 0xcb, 0x50, 0x5c, 0x36, 0x2e, 0x40, 0x3f, 0x84, 0x3a,
-	0x67, 0x27, 0xc6, 0xbe, 0x65, 0x63, 0xa7, 0x8c, 0x09, 0x39, 0x35, 0xac, 0xf6, 0x29, 0x0f, 0x4b,
-	0x6b, 0x3e, 0x1d, 0xbe, 0xc8, 0x75, 0x0e, 0x61, 0xe8, 0x82, 0x08, 0x67, 0xb5, 0x28, 0xc2, 0xf9,
-	0x02, 0x1a, 0x1a, 0x61, 0x91, 0x6f, 0xf3, 0xd8, 0x30, 0x1f, 0x3c, 0xa7, 0x42, 0x93, 0x70, 0x8c,
-	0xd9, 0xa3, 0xc0, 0xd4, 0x01, 0xeb, 0x33, 0x50, 0x41, 0x92, 0x7c, 0x02, 0xf3, 0x5a, 0xb3, 0xdc,
-	0x42, 0x2c, 0x1a, 0x93, 0x55, 0x34, 0xa6, 0x3f, 0xb0, 0x60, 0x51, 0x7c, 0x8d, 0x79, 0x45, 0x3e,
-	0x3b, 0xc6, 0x9f, 0xc7, 0xa7, 0xec, 0x20, 0x65, 0xad, 0xbb, 0x11, 0x3d, 0xf5, 0xe3, 0x84, 0x4a,
-	0x47, 0x7a, 0x01, 0x87, 0x30, 0x92, 0x66, 0x55, 0x1d, 0x51, 0x93, 0x3c, 0x81, 0x06, 0x7e, 0xca,
-	0x6d, 0x58, 0xb1, 0x2d, 0xdd, 0xfc, 0x87, 0x7c, 0xa8, 0x4c, 0x92, 0xc7, 0xaa, 0xb4, 0x5e, 0x87,
-	0xd9, 0x24, 0xf2, 0x4f, 0x4f, 0x69, 0x64, 0x2f, 0xa9, 0xa1, 0x31, 0x6e, 0xa3, 0x87, 0x09, 0x1d,
-	0x33, 0xe5, 0x88, 0x51, 0x46, 0x43, 0x30, 0xd5, 0x2f, 0xed, 0x3c, 0xef, 0x69, 0x19, 0x72, 0xdc,
-	0x5a, 0x4d, 0x13, 0xe2, 0xee, 0xc3, 0xdc, 0x88, 0x29, 0x4a, 0x4c, 0x83, 0x37, 0x1c, 0xe7, 0x59,
-	0x30, 0x53, 0xbc, 0x51, 0x6f, 0x89, 0xdd, 0xc4, 0x1f, 0xba, 0x12, 0x2b, 0x72, 0xd1, 0x8a, 0x50,
-	0xec, 0xf8, 0x8e, 0x13, 0xef, 0x94, 0x0a, 0xed, 0x98, 0x17, 0xec, 0x2e, 0x2c, 0x1d, 0xa4, 0xdb,
-	0xa2, 0x39, 0x24, 0xec, 0x7f, 0xde, 0x82, 0xe5, 0x1c, 0x4a, 0x65, 0xce, 0x0a, 0x6f, 0xf0, 0xd0,
-	0x1f, 0x1d, 0x87, 0xca, 0x9b, 0x63, 0xe9, 0x8e, 0x62, 0x03, 0x45, 0x4e, 0xe1, 0xba, 0xa4, 0x0a,
-	0x26, 0x42, 0x52, 0xb5, 0xbf, 0x84, 0x9a, 0xe8, 0x87, 0xa6, 0xc4, 0xca, 0x76, 0x28, 0xe1, 0xfa,
-	0xa9, 0x58, 0xdc, 0x1e, 0x39, 0x83, 0xae, 0x22, 0x3f, 0xa1, 0x29, 0x69, 0x96, 0x0c, 0xeb, 0xeb,
-	0x83, 0x37, 0xf4, 0x65, 0xf8, 0x2f, 0x9c, 0xa9, 0xad, 0x91, 0x4b, 0xb8, 0x23, 0x71, 0xa8, 0x0a,
-	0xe5, 0xfb, 0xab, 0xbc, 0xd5, 0xdc, 0xd0, 0x33, 0x63, 0x76, 0xfa, 0x86, 0x86, 0xc9, 0x8f, 0x61,
-	0xe9, 0xc2, 0xf3, 0x13, 0x39, 0x2c, 0xcd, 0x8a, 0xaa, 0x62, 0x97, 0xab, 0x6f, 0xe8, 0xf2, 0x25,
-	0xff, 0xd8, 0xd0, 0x0f, 0xa7, 0xb4, 0xd8, 0xfb, 0x45, 0x09, 0xda, 0x66, 0x3b, 0x8c, 0x4c, 0x85,
-	0x54, 0x92, 0x0a, 0x85, 0xb4, 0x3f, 0x33, 0xe0, 0xbc, 0x53, 0xb4, 0x54, 0xe4, 0x14, 0xd5, 0xdd,
-	0x90, 0xe5, 0x37, 0x45, 0x5d, 0x2a, 0x6f, 0x17, 0x75, 0xa9, 0x16, 0x46, 0x5d, 0xa6, 0x3b, 0xe7,
-	0x67, 0x7e, 0x59, 0xe7, 0xfc, 0xec, 0x95, 0xce, 0xf9, 0xde, 0xff, 0xb1, 0x80, 0xe4, 0xa9, 0x97,
-	0x3c, 0xe3, 0x7e, 0xe0, 0x80, 0x0e, 0x85, 0x78, 0xfb, 0xfa, 0xdb, 0x71, 0x80, 0xdc, 0x2d, 0xf9,
-	0x35, 0x63, 0x45, 0x3d, 0x7d, 0x55, 0xb7, 0x6d, 0x5a, 0x4e, 0x11, 0x2a, 0x13, 0x79, 0xaa, 0xbc,
-	0x39, 0xf2, 0x54, 0x7d, 0x73, 0xe4, 0x69, 0x26, 0x1b, 0x79, 0xea, 0xfd, 0x55, 0x0b, 0x16, 0x0a,
-	0xc8, 0xec, 0xd7, 0x37, 0x71, 0x46, 0x18, 0x86, 0xf4, 0x29, 0x09, 0xc2, 0xd0, 0x81, 0xbd, 0xbf,
-	0x04, 0x2d, 0x83, 0xb5, 0x7e, 0x7d, 0xfd, 0x67, 0xcd, 0x33, 0x4e, 0xd9, 0x06, 0xac, 0xf7, 0x3f,
-	0x4b, 0x40, 0xf2, 0xec, 0xfd, 0xa5, 0x8e, 0x21, 0xbf, 0x4e, 0xe5, 0x82, 0x75, 0xfa, 0xff, 0x7a,
-	0xf2, 0x7c, 0x00, 0xf3, 0x22, 0x27, 0x5f, 0xf3, 0xfc, 0x73, 0x8a, 0xc9, 0x23, 0x98, 0x81, 0x6a,
-	0x86, 0xfd, 0x6a, 0x46, 0x0e, 0xb2, 0x76, 0xfc, 0x66, 0xa2, 0x7f, 0x76, 0x0f, 0xba, 0x62, 0x85,
-	0xf2, 0xae, 0xbf, 0xbf, 0x57, 0x51, 0x36, 0x36, 0x22, 0x85, 0xfe, 0xfc, 0x4d, 0x68, 0xea, 0xc7,
-	0x87, 0xd8, 0x8e, 0x4c, 0xf0, 0x87, 0xa9, 0x19, 0x7a, 0x2d, 0xb2, 0x09, 0x6d, 0x14, 0x92, 0x03,
-	0xf5, 0x1d, 0xd7, 0x34, 0xae, 0x70, 0x68, 0x6f, 0x5f, 0x73, 0x32, 0xdf, 0x90, 0xdf, 0x86, 0xb6,
-	0xe9, 0xe6, 0x12, 0x3a, 0x61, 0x91, 0x1a, 0xc9, 0x3e, 0x37, 0x2b, 0x93, 0x35, 0xe8, 0x64, 0xfd,
-	0x64, 0x22, 0x41, 0x72, 0x4a, 0x03, 0xb9, 0xea, 0xe4, 0x13, 0x58, 0x2c, 0x3a, 0x44, 0x71, 0x6f,
-	0xa6, 0x5b, 0x11, 0x85, 0xdf, 0x90, 0xc7, 0xc2, 0x67, 0x5a, 0x45, 0x9f, 0xe9, 0x3d, 0x73, 0x08,
-	0xda, 0x92, 0xaf, 0xf0, 0xff, 0x34, 0xef, 0xe9, 0x39, 0x40, 0x0a, 0x23, 0x1d, 0x68, 0xee, 0x1f,
-	0x6c, 0xed, 0xb9, 0x1b, 0xdb, 0x6b, 0x7b, 0x7b, 0x5b, 0xbb, 0x9d, 0x6b, 0x84, 0x40, 0x1b, 0x63,
-	0x2c, 0x9b, 0x0a, 0x66, 0x31, 0x98, 0xf0, 0x28, 0x4b, 0x58, 0x89, 0x2c, 0x42, 0x67, 0x67, 0x2f,
-	0x03, 0x2d, 0x93, 0x2e, 0x2c, 0x1e, 0x6c, 0xf1, 0xb0, 0x8c, 0xd1, 0x6e, 0x85, 0xe9, 0x7b, 0x62,
-	0xf0, 0x4c, 0xdf, 0xe3, 0x37, 0x3b, 0xd6, 0x39, 0x11, 0x4a, 0x1d, 0xe8, 0x1f, 0x58, 0x70, 0x3d,
-	0x83, 0x48, 0x73, 0x75, 0xb9, 0x9a, 0x63, 0xea, 0x3e, 0x26, 0x10, 0x23, 0xc7, 0xd2, 0x3c, 0xcc,
-	0xc8, 0xa9, 0x3c, 0x82, 0x71, 0x96, 0x66, 0x4e, 0x66, 0xf8, 0xb5, 0x08, 0x65, 0x2f, 0xab, 0x94,
-	0xc8, 0xcc, 0xc0, 0x4f, 0xf8, 0x8d, 0x11, 0x1d, 0x91, 0x7a, 0x95, 0xcd, 0x21, 0xcb, 0x22, 0x59,
-	0xcd, 0x50, 0x83, 0x39, 0xde, 0x42, 0x9c, 0xfd, 0xcf, 0x66, 0x80, 0x7c, 0x77, 0x42, 0xa3, 0x4b,
-	0x4c, 0xc6, 0x55, 0xc1, 0xac, 0xe5, 0xac, 0x6b, 0x7d, 0x66, 0x3c, 0x39, 0x66, 0x06, 0x8b, 0x30,
-	0xa4, 0x4a, 0x6f, 0x95, 0x74, 0x5f, 0x94, 0xf4, 0x5e, 0x79, 0x73, 0xd2, 0x7b, 0xf5, 0x4d, 0x49,
-	0xef, 0x5f, 0x81, 0x96, 0x7f, 0x1a, 0x84, 0x4c, 0xe8, 0x30, 0x45, 0x25, 0xee, 0xce, 0xdc, 0x2d,
-	0xdf, 0x6f, 0x3a, 0x4d, 0x01, 0xdc, 0x63, 0x30, 0xf2, 0x24, 0xad, 0x44, 0x07, 0xa7, 0x78, 0x49,
-	0x43, 0x17, 0x43, 0x5b, 0x83, 0x53, 0x2a, 0xec, 0x46, 0x74, 0xad, 0xc8, 0x8f, 0x19, 0x3c, 0x26,
-	0xf7, 0xa0, 0x1d, 0x87, 0x13, 0xa6, 0xba, 0xc9, 0x65, 0xe0, 0x0e, 0xe7, 0x26, 0x87, 0x1e, 0xf0,
-	0xc5, 0x58, 0x81, 0x85, 0x49, 0x4c, 0xdd, 0x91, 0x1f, 0xc7, 0xec, 0x78, 0xee, 0x87, 0x41, 0x12,
-	0x85, 0x43, 0xe1, 0x40, 0x9e, 0x9f, 0xc4, 0xf4, 0x39, 0xc7, 0x6c, 0x70, 0x04, 0xf9, 0x66, 0x3a,
-	0xa4, 0xb1, 0xe7, 0x47, 0x71, 0x17, 0x70, 0x48, 0x72, 0xa6, 0x6c, 0xdc, 0x07, 0x9e, 0x1f, 0xa9,
-	0xb1, 0xb0, 0x42, 0x9c, 0x49, 0xc6, 0x6f, 0x64, 0x93, 0xf1, 0x7f, 0x54, 0x9c, 0x8c, 0xdf, 0xc2,
-	0xa6, 0x1f, 0x89, 0xa6, 0xf3, 0x5b, 0xfc, 0x85, 0x72, 0xf2, 0xf3, 0x77, 0x0c, 0xda, 0x5f, 0xe4,
-	0x8e, 0xc1, 0x5c, 0xd1, 0x1d, 0x83, 0x0f, 0xa1, 0x81, 0x99, 0xdf, 0xee, 0x99, 0x1f, 0x24, 0xd2,
-	0x19, 0xde, 0xd1, 0x53, 0xc3, 0xb7, 0x99, 0xf9, 0x0d, 0x91, 0xfc, 0x33, 0xce, 0xa7, 0xfb, 0xcf,
-	0x7f, 0x89, 0xe9, 0xfe, 0x22, 0x43, 0x7d, 0x05, 0x6a, 0x72, 0x9f, 0x08, 0x81, 0xca, 0x49, 0x14,
-	0x8e, 0xa4, 0x7f, 0x90, 0xfd, 0x4d, 0xda, 0x50, 0x4a, 0x42, 0xf1, 0x71, 0x29, 0x09, 0xed, 0xdf,
-	0x83, 0x86, 0x46, 0x6a, 0xe4, 0x5d, 0xee, 0x76, 0x60, 0xaa, 0xb3, 0xb0, 0xab, 0xf9, 0x2a, 0xd6,
-	0x05, 0x74, 0x67, 0x40, 0xbe, 0x06, 0xf3, 0x03, 0x3f, 0xa2, 0x78, 0x31, 0xc7, 0x8d, 0xe8, 0x39,
-	0x8d, 0x62, 0xe9, 0xb2, 0xed, 0x28, 0x84, 0xc3, 0xe1, 0xb6, 0x0b, 0x0b, 0xc6, 0xde, 0x2a, 0xe9,
-	0x36, 0x83, 0xeb, 0x26, 0xa3, 0x6c, 0x66, 0xca, 0xbd, 0xc0, 0x31, 0xed, 0x43, 0x78, 0x9b, 0xdd,
-	0x71, 0x14, 0x1e, 0x63, 0x27, 0x96, 0x63, 0xc0, 0xec, 0xff, 0x51, 0x86, 0xf2, 0x76, 0x38, 0xd6,
-	0xf3, 0x1e, 0xac, 0x7c, 0xde, 0x83, 0x30, 0x13, 0x5c, 0x65, 0x05, 0x08, 0x5d, 0xce, 0x00, 0x92,
-	0x07, 0xd0, 0x66, 0xa2, 0x22, 0x09, 0x99, 0x59, 0x74, 0xe1, 0x45, 0x3c, 0x07, 0xbf, 0x8c, 0xfc,
-	0x97, 0xc1, 0x90, 0x45, 0x28, 0x2b, 0xed, 0x16, 0x2b, 0xb0, 0x22, 0xb3, 0xc9, 0x31, 0x03, 0xed,
-	0x52, 0xc4, 0x90, 0x44, 0x89, 0x49, 0x5e, 0xf3, 0x7b, 0x2e, 0x8f, 0xb8, 0x8e, 0x52, 0x84, 0x62,
-	0x26, 0x0b, 0x93, 0x38, 0xa3, 0xd4, 0x02, 0x50, 0x65, 0x3d, 0xb0, 0x58, 0x33, 0x03, 0x8b, 0x77,
-	0xa1, 0x91, 0x0c, 0xcf, 0xdd, 0xb1, 0x77, 0x39, 0x0c, 0xbd, 0x81, 0xe0, 0x74, 0x1d, 0x44, 0x1e,
-	0x01, 0x8c, 0xc6, 0x63, 0xc1, 0x86, 0xe8, 0xb5, 0x4c, 0xa9, 0xfa, 0xf9, 0xc1, 0x01, 0xa7, 0x3e,
-	0x47, 0xab, 0x43, 0xb6, 0xa0, 0x5d, 0x78, 0x91, 0xe6, 0xb6, 0xcc, 0x93, 0x0a, 0xc7, 0x2b, 0x05,
-	0x8c, 0x9a, 0xf9, 0xa8, 0xf7, 0x1d, 0x20, 0xbf, 0xe2, 0x7d, 0x96, 0x97, 0x50, 0x57, 0x23, 0xd4,
-	0x6f, 0x91, 0x60, 0x32, 0x64, 0xc3, 0xbc, 0x45, 0x82, 0xb9, 0x8f, 0xef, 0x41, 0x9b, 0x1f, 0x97,
-	0xea, 0x00, 0xe0, 0x09, 0x6c, 0x19, 0xa8, 0xfd, 0xe7, 0x16, 0x54, 0x91, 0xf2, 0x98, 0x96, 0xca,
-	0x71, 0x2a, 0x61, 0x44, 0xc4, 0x9e, 0xb2, 0x60, 0x62, 0x1b, 0x17, 0xec, 0x4a, 0x8a, 0x0c, 0xf4,
-	0x4b, 0x76, 0x77, 0xa1, 0xae, 0x7a, 0xd2, 0x48, 0x29, 0x05, 0x92, 0x3b, 0x50, 0x39, 0x0b, 0xc7,
-	0xd2, 0x90, 0x87, 0x74, 0x45, 0x1d, 0x84, 0xa7, 0xe3, 0x61, 0xed, 0xf1, 0x29, 0x70, 0x63, 0x29,
-	0x0b, 0x2e, 0x98, 0xeb, 0x4c, 0xe1, 0x5c, 0x5f, 0xc0, 0x1c, 0x93, 0x0f, 0x5a, 0x6c, 0x78, 0xfa,
-	0x61, 0xfa, 0x55, 0xa6, 0x01, 0xf6, 0x87, 0x93, 0x01, 0xd5, 0xdd, 0x29, 0x18, 0x53, 0x14, 0x70,
-	0x69, 0x48, 0xd8, 0xff, 0xc2, 0xe2, 0x72, 0x87, 0xb5, 0x4b, 0xee, 0x43, 0x85, 0x9d, 0x7b, 0x19,
-	0x9f, 0x9f, 0x4a, 0x50, 0x65, 0xf5, 0x1c, 0xac, 0xc1, 0x76, 0x11, 0xc3, 0x61, 0x7a, 0xeb, 0x3c,
-	0x18, 0x96, 0xfa, 0x22, 0xd4, 0xcc, 0x32, 0x26, 0x7c, 0x06, 0x4a, 0x56, 0xb4, 0xfc, 0x8f, 0x8a,
-	0x71, 0x96, 0x4a, 0x25, 0x71, 0x70, 0x4a, 0xb5, 0xbc, 0x8f, 0x7f, 0x59, 0x82, 0x96, 0x31, 0x26,
-	0xc6, 0x3d, 0x78, 0x34, 0x70, 0x8f, 0xb2, 0xd8, 0x79, 0x1d, 0xa4, 0x73, 0x5e, 0xc9, 0xe4, 0x3c,
-	0x15, 0x08, 0x2f, 0xeb, 0x81, 0xf0, 0x47, 0x50, 0x4f, 0x6f, 0x58, 0x9a, 0x83, 0x62, 0x3d, 0xca,
-	0x54, 0xdd, 0xb4, 0x52, 0x1a, 0x3a, 0xaf, 0xea, 0xa1, 0xf3, 0x6f, 0x6b, 0xa1, 0xd5, 0x19, 0x6c,
-	0xc6, 0x2e, 0x5a, 0xd5, 0x2f, 0x27, 0x17, 0xe3, 0x09, 0x34, 0xb4, 0xc1, 0xeb, 0x21, 0x54, 0xcb,
-	0x08, 0xa1, 0xaa, 0xa4, 0xfa, 0x52, 0x9a, 0x54, 0x6f, 0xff, 0xac, 0x04, 0x2d, 0xc6, 0x6b, 0x7e,
-	0x70, 0x7a, 0x10, 0x0e, 0xfd, 0xfe, 0x25, 0xd2, 0xb8, 0x64, 0x2b, 0xa1, 0x84, 0x49, 0x9e, 0x33,
-	0xc1, 0x4c, 0x26, 0xaa, 0x9b, 0x44, 0x5c, 0x80, 0xab, 0x32, 0x93, 0xf0, 0x4c, 0x3e, 0x1e, 0x7b,
-	0x31, 0xd5, 0xee, 0x7f, 0x3a, 0x26, 0x90, 0xc9, 0x61, 0x06, 0xc0, 0x2b, 0x12, 0x23, 0x7f, 0x38,
-	0xf4, 0x79, 0x5d, 0xee, 0xa3, 0x28, 0x42, 0xb1, 0x3e, 0x07, 0x7e, 0xec, 0x1d, 0xa7, 0x09, 0x4b,
-	0xaa, 0x8c, 0xd1, 0x22, 0xef, 0xb5, 0x16, 0x2d, 0xe2, 0x77, 0xaa, 0x4c, 0x60, 0x96, 0xaa, 0x66,
-	0x73, 0x54, 0x65, 0xff, 0xdb, 0x12, 0x34, 0x34, 0x1a, 0x65, 0xb2, 0xa5, 0xf0, 0x10, 0xd6, 0xa0,
-	0x22, 0x93, 0x2f, 0x30, 0xbc, 0x5e, 0x1a, 0x84, 0xdc, 0x33, 0x7b, 0xc5, 0x28, 0x33, 0x4a, 0x1f,
-	0x83, 0x9e, 0x6f, 0x41, 0x9d, 0xf1, 0xe1, 0x87, 0xe8, 0x62, 0x13, 0x77, 0xad, 0x15, 0x40, 0x62,
-	0x57, 0x11, 0x5b, 0x4d, 0xb1, 0x08, 0xb8, 0x32, 0xb7, 0xef, 0x31, 0x34, 0x45, 0x33, 0xb8, 0xc7,
-	0x38, 0xe9, 0x54, 0x12, 0x18, 0xfb, 0xef, 0x18, 0x35, 0xe5, 0x97, 0xab, 0xf2, 0xcb, 0xda, 0x9b,
-	0xbe, 0x94, 0x35, 0xed, 0x67, 0x2a, 0x6d, 0xf2, 0x59, 0xe4, 0x8d, 0xcf, 0xa4, 0x74, 0x7b, 0x04,
-	0x0b, 0x52, 0x88, 0x4d, 0x02, 0x2f, 0x08, 0xc2, 0x49, 0xd0, 0xa7, 0x32, 0xff, 0xbe, 0x08, 0x65,
-	0x0f, 0xd4, 0x6d, 0x2d, 0x6c, 0x88, 0x3c, 0x80, 0x2a, 0x57, 0xe3, 0xb9, 0xae, 0x52, 0x2c, 0xcf,
-	0x78, 0x15, 0x72, 0x1f, 0xaa, 0x5c, 0x9b, 0x2f, 0x4d, 0x95, 0x40, 0xbc, 0x82, 0xbd, 0x02, 0x73,
-	0xa8, 0x91, 0x6a, 0x82, 0xf8, 0x66, 0x91, 0x0e, 0x33, 0xd3, 0xe7, 0xe1, 0x8c, 0x45, 0x20, 0x7b,
-	0x9c, 0xaf, 0xf4, 0xbc, 0x9e, 0x3f, 0x2f, 0x43, 0x43, 0x03, 0x33, 0x61, 0x89, 0x49, 0x1e, 0xee,
-	0xc0, 0xf7, 0x46, 0x54, 0x06, 0x37, 0x5a, 0x4e, 0x06, 0xca, 0xea, 0x79, 0xe7, 0xa7, 0x6e, 0x38,
-	0x49, 0xdc, 0x01, 0x3d, 0x8d, 0x28, 0x15, 0xca, 0x55, 0x06, 0xca, 0xea, 0x31, 0x6a, 0xd6, 0xea,
-	0xf1, 0x7c, 0x85, 0x0c, 0x54, 0xe6, 0xcf, 0xf0, 0x75, 0xaa, 0xa4, 0xf9, 0x33, 0x7c, 0x55, 0xb2,
-	0x62, 0xbe, 0x5a, 0x20, 0xe6, 0x3f, 0x82, 0x25, 0x2e, 0xd0, 0x85, 0xf4, 0x70, 0x33, 0xc4, 0x35,
-	0x05, 0x4b, 0x1e, 0x40, 0x87, 0x8d, 0x59, 0xb2, 0x46, 0xec, 0xff, 0x84, 0xf3, 0x98, 0xe5, 0xe4,
-	0xe0, 0xac, 0x2e, 0xc6, 0x5e, 0xf5, 0xba, 0x3c, 0x9f, 0x34, 0x07, 0xc7, 0xba, 0xde, 0x6b, 0xb3,
-	0x6e, 0x5d, 0xd4, 0xcd, 0xc0, 0xc9, 0x63, 0x58, 0x1e, 0xd1, 0x81, 0xef, 0x99, 0x4d, 0xb8, 0xa9,
-	0xc6, 0x31, 0x0d, 0xcd, 0x7a, 0x61, 0xab, 0xf0, 0x93, 0x70, 0x74, 0xec, 0xf3, 0x53, 0x96, 0x47,
-	0x89, 0x2b, 0x4e, 0x0e, 0x6e, 0xb7, 0xa0, 0x71, 0x98, 0x84, 0x63, 0xb9, 0xf5, 0x6d, 0x68, 0xf2,
-	0xa2, 0xb8, 0x71, 0x71, 0x13, 0x6e, 0x20, 0xbd, 0x1e, 0x85, 0xe3, 0x70, 0x18, 0x9e, 0x5e, 0x1a,
-	0xee, 0xa9, 0x7f, 0x6f, 0xc1, 0x82, 0x81, 0x4d, 0xfd, 0x53, 0xe8, 0x4b, 0x97, 0x69, 0xf2, 0x9c,
-	0xc4, 0xe7, 0xb5, 0x33, 0x8a, 0x57, 0xe4, 0x79, 0x00, 0x2f, 0x44, 0xe6, 0xfc, 0x5a, 0x7a, 0xf7,
-	0x53, 0x7e, 0xc8, 0xe9, 0xbd, 0x9b, 0xa7, 0x77, 0xf1, 0xbd, 0xbc, 0x15, 0x2a, 0x9b, 0xf8, 0x6d,
-	0x91, 0xfd, 0x3b, 0x10, 0x93, 0x2e, 0x9b, 0x19, 0x9b, 0xba, 0x3b, 0x53, 0x8e, 0xa0, 0xaf, 0x80,
-	0xb1, 0xfd, 0x73, 0x0b, 0x20, 0x1d, 0x1d, 0xe6, 0x8c, 0xaa, 0x73, 0x96, 0x3f, 0xaf, 0xa2, 0x9d,
-	0xa9, 0xef, 0x42, 0x53, 0xe5, 0xad, 0xa5, 0x47, 0x77, 0x43, 0xc2, 0x98, 0xaa, 0xf3, 0x3e, 0xcc,
-	0x9d, 0x0e, 0xc3, 0x63, 0x54, 0xa9, 0xc4, 0x39, 0xcb, 0xef, 0x9d, 0xb4, 0x39, 0x58, 0x9e, 0x9e,
-	0xe9, 0x39, 0x5f, 0x29, 0x4c, 0x78, 0xd3, 0x4f, 0x6d, 0x76, 0xd6, 0xcd, 0xe7, 0x56, 0xe2, 0x4a,
-	0x2e, 0xff, 0xa5, 0xc2, 0xbe, 0x57, 0x45, 0x37, 0x9e, 0x40, 0x3b, 0xe2, 0x32, 0x53, 0x0a, 0xd4,
-	0xca, 0x15, 0x02, 0xb5, 0x15, 0x19, 0x27, 0xf3, 0x57, 0xa1, 0xe3, 0x0d, 0xce, 0x69, 0x94, 0xf8,
-	0xe8, 0xed, 0x45, 0x9d, 0x8e, 0x4f, 0x70, 0x4e, 0x83, 0xa3, 0xea, 0xf4, 0x3e, 0xcc, 0x89, 0x5b,
-	0x40, 0xaa, 0xa6, 0x78, 0x68, 0x20, 0x05, 0xb3, 0x8a, 0xf6, 0x3f, 0x96, 0x69, 0x43, 0xe6, 0xee,
-	0x5e, 0xbd, 0x2a, 0xfa, 0x0c, 0x4b, 0x99, 0x19, 0x7e, 0x45, 0x24, 0x45, 0x0c, 0xa4, 0x5b, 0xb9,
-	0xac, 0xe5, 0x91, 0x0f, 0x44, 0xda, 0x95, 0xb9, 0xac, 0x95, 0xb7, 0x59, 0x56, 0xfb, 0x3f, 0x5b,
-	0x30, 0xbb, 0x1d, 0x8e, 0x99, 0x69, 0x8f, 0x3a, 0x0e, 0x63, 0x13, 0x75, 0x05, 0x4f, 0x16, 0xdf,
-	0x90, 0x6f, 0x5f, 0xa8, 0x95, 0xb4, 0xb2, 0x5a, 0xc9, 0x77, 0xe0, 0x26, 0x06, 0x36, 0xa2, 0x70,
-	0x1c, 0x46, 0x8c, 0x5d, 0xbd, 0x21, 0x57, 0x41, 0xc2, 0x20, 0x39, 0x93, 0xe2, 0xf4, 0xaa, 0x2a,
-	0xe8, 0x07, 0x1c, 0x26, 0xe7, 0x2e, 0x37, 0x37, 0x85, 0x16, 0xc5, 0xa5, 0x6c, 0x1e, 0x61, 0xff,
-	0x16, 0xd4, 0x95, 0x03, 0x83, 0x7c, 0x00, 0xf5, 0xb3, 0x70, 0x2c, 0xbc, 0x1c, 0x96, 0x71, 0x37,
-	0x41, 0xcc, 0xde, 0x49, 0x2b, 0xd8, 0xff, 0x6b, 0x16, 0x66, 0x77, 0x82, 0xf3, 0xd0, 0xef, 0x63,
-	0xfa, 0xd1, 0x88, 0x8e, 0x42, 0x79, 0x29, 0x91, 0xfd, 0x8d, 0xef, 0x85, 0xa4, 0xcf, 0x06, 0x70,
-	0x16, 0xd2, 0x20, 0xcc, 0x40, 0x8e, 0xf4, 0x6b, 0xff, 0xa2, 0x94, 0x5a, 0x7d, 0x55, 0xed, 0x5a,
-	0x27, 0x6b, 0x8d, 0x5f, 0x47, 0xc7, 0xb5, 0xe3, 0x97, 0x49, 0x34, 0x08, 0x5b, 0x7c, 0x71, 0x0f,
-	0x80, 0x27, 0x8a, 0xf3, 0x4c, 0x46, 0x01, 0x42, 0xa3, 0x3f, 0xa2, 0x3c, 0x34, 0xa5, 0x54, 0x2f,
-	0x66, 0xf4, 0xeb, 0x40, 0xa6, 0x9e, 0xf1, 0x0f, 0x78, 0x1d, 0x7e, 0x1c, 0xe8, 0x20, 0xcc, 0x46,
-	0xc9, 0x3c, 0xa2, 0xc1, 0x1f, 0x42, 0xc9, 0x82, 0x79, 0xa2, 0x99, 0x12, 0xba, 0x7c, 0x9e, 0xc0,
-	0x9f, 0x4e, 0xc8, 0xc2, 0x35, 0x57, 0x01, 0xbf, 0x2e, 0x25, 0x5d, 0x05, 0x8c, 0x64, 0xbc, 0xe1,
-	0xf0, 0xd8, 0xeb, 0xbf, 0xe2, 0x96, 0x6d, 0x93, 0x47, 0x34, 0x0d, 0x20, 0x66, 0xf3, 0xa7, 0xfb,
-	0x8a, 0x89, 0x40, 0x15, 0x47, 0x07, 0x91, 0x55, 0xd3, 0x7f, 0xd5, 0x9e, 0xe2, 0xbf, 0xd2, 0x2b,
-	0xe9, 0x89, 0x51, 0x73, 0xb9, 0x0b, 0x4c, 0xde, 0x60, 0x20, 0x12, 0x66, 0x3a, 0xfc, 0xe9, 0x00,
-	0x05, 0x40, 0x47, 0x0d, 0x5f, 0x30, 0x5e, 0x61, 0x1e, 0x2b, 0x18, 0x30, 0x72, 0x87, 0xfb, 0x61,
-	0xc7, 0x9e, 0x3f, 0xc0, 0xc4, 0x54, 0x6e, 0x0b, 0x2b, 0x18, 0x6b, 0x43, 0xfe, 0x8d, 0x07, 0xe7,
-	0x02, 0xae, 0x8a, 0x01, 0x63, 0x6b, 0xa3, 0xca, 0xa3, 0xf4, 0xc6, 0x93, 0x09, 0x24, 0x1f, 0x62,
-	0x22, 0x42, 0x42, 0xf1, 0x5a, 0x53, 0x7b, 0xf5, 0xa6, 0x98, 0xb3, 0x20, 0x5b, 0xf9, 0x3f, 0x26,
-	0x5e, 0x38, 0xbc, 0x26, 0x53, 0xdb, 0x78, 0x2c, 0x68, 0xc9, 0x50, 0xdb, 0x44, 0x55, 0x8c, 0x05,
-	0xf1, 0x0a, 0xe4, 0xb1, 0x66, 0x89, 0x75, 0xb1, 0xf2, 0xad, 0x4c, 0xfb, 0x53, 0x6c, 0x30, 0x46,
-	0xcc, 0x7e, 0xcc, 0xce, 0x9f, 0x98, 0x06, 0x03, 0xbc, 0xe0, 0x54, 0x73, 0x34, 0xc8, 0xaf, 0xd7,
-	0x46, 0x5b, 0x83, 0xa6, 0x3e, 0x4f, 0x52, 0x83, 0xca, 0xfe, 0xc1, 0xd6, 0x5e, 0xe7, 0x1a, 0x69,
-	0xc0, 0xec, 0xe1, 0xd6, 0xd1, 0xd1, 0xee, 0xd6, 0x66, 0xc7, 0x22, 0x4d, 0xa8, 0xa9, 0xbb, 0x24,
-	0x25, 0x56, 0x5a, 0xdb, 0xd8, 0xd8, 0x3a, 0x38, 0xda, 0xda, 0xec, 0x94, 0x3f, 0xa9, 0xd4, 0x4a,
-	0x9d, 0x32, 0x2a, 0x98, 0xda, 0x32, 0xbc, 0xc1, 0xcf, 0x76, 0x07, 0x00, 0x0d, 0x9f, 0x34, 0xb1,
-	0xaa, 0xe2, 0x68, 0x10, 0x26, 0xc8, 0x95, 0x7f, 0xa2, 0xcc, 0x9f, 0x7b, 0x90, 0x65, 0xdc, 0x5c,
-	0x7c, 0x57, 0x41, 0x8f, 0x0f, 0x56, 0x1d, 0x13, 0xc8, 0x08, 0x5f, 0x00, 0xf0, 0x82, 0x03, 0x17,
-	0x17, 0x3a, 0x88, 0x11, 0x52, 0x44, 0xe3, 0x70, 0x78, 0x4e, 0x79, 0x15, 0xae, 0x3e, 0x1a, 0x30,
-	0xd6, 0x97, 0x90, 0x88, 0xda, 0xe5, 0xa3, 0xaa, 0x63, 0x02, 0xc9, 0xd7, 0x25, 0x21, 0xd5, 0x90,
-	0x90, 0x96, 0xf3, 0x54, 0x61, 0x10, 0xd1, 0xf3, 0x9c, 0xa3, 0xac, 0x8e, 0x04, 0xf2, 0x1b, 0xf9,
-	0xef, 0xde, 0xc2, 0x61, 0x46, 0x56, 0x80, 0x8c, 0xc6, 0x63, 0xb7, 0xc0, 0x83, 0x55, 0x71, 0x0a,
-	0x30, 0xbf, 0x06, 0x07, 0x5b, 0x02, 0x64, 0x6d, 0x30, 0x10, 0xc3, 0xd4, 0x5f, 0xbf, 0x88, 0xf4,
-	0xe7, 0x56, 0xa4, 0xc8, 0x2e, 0x10, 0x8b, 0xa5, 0x62, 0xb1, 0x78, 0xa5, 0xf0, 0xb0, 0x77, 0xa0,
-	0x71, 0xa0, 0x3d, 0xe0, 0x62, 0xb3, 0x13, 0x44, 0x3e, 0xdd, 0xc2, 0xcf, 0x16, 0xee, 0x58, 0x4b,
-	0xa1, 0xda, 0x90, 0x4a, 0xfa, 0x90, 0xec, 0x7f, 0x68, 0xf1, 0x3b, 0xf1, 0x6a, 0x0a, 0xbc, 0x7f,
-	0x1b, 0x9a, 0x2a, 0xb8, 0x94, 0x5e, 0x10, 0x34, 0x60, 0xac, 0x0e, 0x0e, 0xc7, 0x0d, 0x4f, 0x4e,
-	0x62, 0x2a, 0xaf, 0xf2, 0x18, 0x30, 0xa9, 0xac, 0x33, 0xf5, 0xdf, 0xe7, 0x3d, 0xc4, 0xe2, 0x4a,
-	0x4f, 0x0e, 0xce, 0x28, 0x5d, 0xf8, 0xc6, 0xe5, 0x25, 0x26, 0x55, 0x56, 0xf7, 0x18, 0xb3, 0x2b,
-	0xfd, 0x00, 0x6a, 0xaa, 0x5d, 0xf3, 0x24, 0x96, 0x35, 0x15, 0x9e, 0x9d, 0xf8, 0x68, 0xc8, 0x1b,
-	0x83, 0xe6, 0x0c, 0x97, 0x47, 0x30, 0x5a, 0x3a, 0xf1, 0xa3, 0x6c, 0x75, 0xce, 0x81, 0x05, 0x18,
-	0xfb, 0x25, 0x2c, 0x48, 0xf1, 0xa1, 0x59, 0x11, 0xe6, 0x46, 0x5a, 0x6f, 0x3a, 0x05, 0x4a, 0xf9,
-	0x53, 0xc0, 0xfe, 0x37, 0x15, 0x98, 0x95, 0xaf, 0x23, 0xd9, 0x05, 0xaf, 0xf9, 0xd4, 0xcd, 0x87,
-	0x80, 0x48, 0xd7, 0x78, 0xee, 0x01, 0x09, 0x41, 0xe8, 0x06, 0xf7, 0xb3, 0xa7, 0x7b, 0xea, 0x60,
-	0xcd, 0x9c, 0xf0, 0x4b, 0x50, 0x19, 0x7b, 0xc9, 0x19, 0xfa, 0xdf, 0x38, 0x2d, 0x61, 0x59, 0xba,
-	0xf0, 0xab, 0xa6, 0x0b, 0xbf, 0xe8, 0xf9, 0x23, 0xae, 0xca, 0xe6, 0x9f, 0x3f, 0xba, 0x05, 0x75,
-	0xae, 0x8d, 0xa4, 0x5e, 0xfa, 0x14, 0x90, 0xd1, 0x5e, 0x6a, 0x39, 0xed, 0xe5, 0xed, 0xf5, 0x8a,
-	0x6f, 0xc2, 0x0c, 0xbf, 0x02, 0x2c, 0xae, 0x6c, 0xc9, 0x23, 0x47, 0xac, 0xa4, 0xfc, 0x9f, 0x67,
-	0xee, 0x3a, 0xa2, 0xae, 0xfe, 0x88, 0x48, 0xc3, 0x7c, 0x44, 0x44, 0x0f, 0x2e, 0x34, 0x33, 0xc1,
-	0x85, 0x07, 0xd0, 0x51, 0xcb, 0x87, 0x0e, 0xb8, 0x20, 0x16, 0x57, 0x54, 0x72, 0xf0, 0xf4, 0xd8,
-	0x6c, 0x1b, 0xc7, 0x26, 0x93, 0x70, 0x6b, 0x49, 0x42, 0x47, 0xe3, 0x44, 0x1c, 0x9b, 0xf6, 0x53,
-	0x68, 0x19, 0x83, 0x64, 0xc7, 0x90, 0xb8, 0xc4, 0xd5, 0xb9, 0x46, 0x5a, 0x50, 0xdf, 0xd9, 0x73,
-	0x9f, 0xee, 0xee, 0x3c, 0xdb, 0x3e, 0xea, 0x58, 0xac, 0x78, 0xf8, 0x62, 0x63, 0x63, 0x6b, 0x6b,
-	0x13, 0x8f, 0x25, 0x80, 0x99, 0xa7, 0x6b, 0x3b, 0xec, 0x88, 0x2a, 0xdb, 0xff, 0xdb, 0x82, 0x86,
-	0xd6, 0x3c, 0xf9, 0x96, 0x5a, 0x19, 0xfe, 0xce, 0xc4, 0xed, 0xfc, 0x10, 0x56, 0xa4, 0xa0, 0xd6,
-	0x96, 0x46, 0xbd, 0xf8, 0x54, 0x9a, 0xfa, 0xe2, 0x13, 0xdb, 0x1e, 0x8f, 0xb7, 0xa0, 0xd6, 0x81,
-	0x5b, 0x57, 0x59, 0x30, 0x4f, 0x57, 0x4b, 0x4f, 0x17, 0x56, 0x93, 0x7b, 0x14, 0xb3, 0x60, 0xfb,
-	0x23, 0x80, 0x74, 0x34, 0xe6, 0xb4, 0xaf, 0x99, 0xd3, 0xb6, 0xb4, 0x69, 0x97, 0xec, 0x4d, 0x2e,
-	0x30, 0xc4, 0x12, 0xaa, 0x30, 0xf8, 0xd7, 0x81, 0x48, 0x07, 0x16, 0xa6, 0x85, 0x8e, 0x87, 0x34,
-	0x91, 0x57, 0x3b, 0xe7, 0x05, 0x66, 0x47, 0x21, 0xe4, 0xed, 0xe4, 0xb4, 0x95, 0x54, 0xee, 0x08,
-	0x8a, 0xcb, 0xca, 0x1d, 0x51, 0xd5, 0x51, 0x78, 0xbb, 0x07, 0xdd, 0x4d, 0xca, 0x5a, 0x5b, 0x1b,
-	0x0e, 0x33, 0xc3, 0xb1, 0x6f, 0xc2, 0x8d, 0x02, 0x9c, 0x70, 0x4f, 0x7c, 0x17, 0xae, 0xaf, 0xf1,
-	0x5b, 0x9c, 0xbf, 0xae, 0x0b, 0x23, 0x76, 0x17, 0x96, 0xb2, 0x4d, 0x8a, 0xce, 0x9e, 0xc2, 0xfc,
-	0x26, 0x3d, 0x9e, 0x9c, 0xee, 0xd2, 0xf3, 0xb4, 0x23, 0x02, 0x95, 0xf8, 0x2c, 0xbc, 0x10, 0xeb,
-	0x83, 0x7f, 0x93, 0xdb, 0x00, 0x43, 0x56, 0xc7, 0x8d, 0xc7, 0xb4, 0x2f, 0xdf, 0xf1, 0x40, 0xc8,
-	0xe1, 0x98, 0xf6, 0xed, 0x8f, 0x80, 0xe8, 0xed, 0x88, 0xf5, 0x62, 0x26, 0xc3, 0xe4, 0xd8, 0x8d,
-	0x2f, 0xe3, 0x84, 0x8e, 0xe4, 0x03, 0x25, 0x3a, 0xc8, 0x7e, 0x1f, 0x9a, 0x07, 0xde, 0xa5, 0x43,
-	0x3f, 0x13, 0x2f, 0x8c, 0x2d, 0xc3, 0xec, 0xd8, 0xbb, 0x64, 0xfc, 0xac, 0x42, 0x2c, 0x88, 0xb6,
-	0xff, 0xb8, 0x02, 0x33, 0xbc, 0x26, 0x6b, 0x75, 0x40, 0xe3, 0xc4, 0x0f, 0x90, 0xc7, 0x64, 0xab,
-	0x1a, 0x28, 0x27, 0x30, 0x4b, 0x05, 0x02, 0x53, 0xb8, 0xda, 0xe4, 0x7b, 0x08, 0x82, 0x64, 0x0d,
-	0x18, 0x13, 0x5b, 0xe9, 0xf5, 0x33, 0x4e, 0xa9, 0x29, 0x20, 0x13, 0xc3, 0x4c, 0x0d, 0x13, 0x3e,
-	0x3e, 0x79, 0x16, 0x08, 0x99, 0xa8, 0x83, 0x0a, 0xcd, 0x9f, 0x59, 0x79, 0xcf, 0x26, 0x63, 0xfe,
-	0xe4, 0xcc, 0x9c, 0xda, 0x5b, 0x98, 0x39, 0xdc, 0xff, 0x76, 0x95, 0x99, 0x03, 0x6f, 0x63, 0xe6,
-	0xbc, 0x4d, 0xec, 0xb0, 0x07, 0x35, 0x3c, 0xd3, 0x35, 0x11, 0x29, 0xcb, 0xe4, 0x37, 0x35, 0x1b,
-	0x80, 0xe7, 0x31, 0xdc, 0x4c, 0xf9, 0xc5, 0xa1, 0x9f, 0x7d, 0x39, 0x61, 0x98, 0x1f, 0xc2, 0xac,
-	0x80, 0x32, 0xca, 0x0e, 0xbc, 0x91, 0x7c, 0x87, 0x06, 0xff, 0x66, 0x4b, 0x87, 0xcf, 0x61, 0x7c,
-	0x36, 0xf1, 0x23, 0x3a, 0x90, 0x77, 0xb5, 0x35, 0x10, 0x26, 0x97, 0xc7, 0xee, 0xab, 0x20, 0xbc,
-	0x08, 0xc4, 0x6d, 0x6d, 0x55, 0xb6, 0x09, 0x74, 0xf0, 0x3d, 0xaa, 0x71, 0x18, 0xc9, 0xa7, 0x85,
-	0xec, 0x3f, 0xb0, 0xa0, 0x23, 0x18, 0x4d, 0xe1, 0x64, 0xc2, 0xc0, 0x55, 0x4f, 0x12, 0xdc, 0x83,
-	0x16, 0xfa, 0x3a, 0xd4, 0x91, 0x23, 0x82, 0xef, 0x06, 0x90, 0x8d, 0x57, 0x66, 0x77, 0x8e, 0xfc,
-	0xa1, 0xa0, 0x5b, 0x1d, 0x24, 0x4f, 0xad, 0xc8, 0x13, 0x97, 0xbc, 0x2c, 0x47, 0x95, 0xed, 0x5f,
-	0x58, 0x30, 0xaf, 0x0d, 0x58, 0x30, 0xea, 0x13, 0x68, 0xaa, 0x67, 0xdf, 0xa8, 0x52, 0xaa, 0x96,
-	0x4d, 0xc9, 0x92, 0x7e, 0x66, 0x54, 0x46, 0x7a, 0xf7, 0x2e, 0x71, 0x80, 0xf1, 0x64, 0x24, 0xb4,
-	0x19, 0x1d, 0xc4, 0xe8, 0xe8, 0x82, 0xd2, 0x57, 0xaa, 0x0a, 0xd7, 0xa7, 0x0c, 0x18, 0xc6, 0x88,
-	0xc2, 0x20, 0x39, 0x53, 0x95, 0x2a, 0x22, 0x46, 0xa4, 0x03, 0xed, 0xff, 0x5a, 0x82, 0x05, 0xee,
-	0x74, 0x13, 0xce, 0x4e, 0xf5, 0xf2, 0xce, 0x0c, 0xf7, 0x3f, 0x72, 0xa1, 0xb5, 0x7d, 0xcd, 0x11,
-	0x65, 0xf2, 0xad, 0xb7, 0x74, 0x14, 0xaa, 0xdb, 0x64, 0x53, 0xf6, 0xa2, 0x5c, 0xb4, 0x17, 0x57,
-	0xac, 0x74, 0x51, 0xb8, 0xae, 0x5a, 0x1c, 0xae, 0x7b, 0xbb, 0xf0, 0x58, 0xee, 0xca, 0xd5, 0xac,
-	0xa8, 0x65, 0x5c, 0xb9, 0x5a, 0x85, 0x65, 0x03, 0x80, 0xf2, 0xda, 0x3f, 0xf1, 0xa9, 0xbc, 0xff,
-	0x3e, 0x1f, 0xd3, 0xc4, 0x35, 0xaa, 0xac, 0xcf, 0x42, 0x35, 0xee, 0x87, 0x63, 0x6a, 0x2f, 0xc1,
-	0xa2, 0xb9, 0xb8, 0xe2, 0x94, 0xf8, 0xb9, 0x05, 0xdd, 0xa7, 0x3c, 0xe9, 0xc2, 0x0f, 0x4e, 0xb7,
-	0xfd, 0x38, 0x09, 0x23, 0xf5, 0x40, 0xda, 0x1d, 0x80, 0x38, 0xf1, 0x22, 0x61, 0x67, 0x72, 0x65,
-	0x57, 0x83, 0xb0, 0x35, 0xa2, 0xc1, 0x80, 0x63, 0x39, 0x6d, 0xa8, 0x72, 0xce, 0x98, 0x10, 0x2e,
-	0x49, 0x43, 0x25, 0x7f, 0x8f, 0xdf, 0x04, 0x65, 0x8b, 0x41, 0xcf, 0xf1, 0xe8, 0xe5, 0x7e, 0xbe,
-	0x0c, 0xd4, 0xfe, 0xc3, 0x12, 0xcc, 0xa5, 0x83, 0xe4, 0x37, 0xcb, 0x0d, 0x01, 0x2e, 0xf4, 0xf0,
-	0x54, 0x80, 0x8b, 0xf0, 0xa1, 0xeb, 0x33, 0xc5, 0x5c, 0xf3, 0x4a, 0x6a, 0x50, 0x72, 0x0f, 0x1a,
-	0xb2, 0x14, 0x4e, 0x12, 0xed, 0xa5, 0x22, 0x1d, 0xcc, 0xaf, 0x98, 0x30, 0xd3, 0x40, 0x98, 0x39,
-	0xa2, 0x84, 0xef, 0x21, 0x8c, 0x12, 0xfc, 0x92, 0xef, 0xa9, 0x2c, 0x32, 0x81, 0xc6, 0x74, 0x6a,
-	0xbe, 0x87, 0xa8, 0x4f, 0xeb, 0xba, 0x66, 0x4d, 0xbd, 0xf0, 0xa8, 0x78, 0x9e, 0xb7, 0x98, 0x5e,
-	0xb6, 0xab, 0x38, 0x3a, 0x48, 0x7a, 0x85, 0xc2, 0x89, 0x61, 0xfe, 0x1a, 0x30, 0xfb, 0x6f, 0x59,
-	0x70, 0xa3, 0x60, 0x1b, 0x85, 0x0c, 0xd8, 0x84, 0xf9, 0x13, 0x85, 0x94, 0x4b, 0xcd, 0x05, 0xc1,
-	0x92, 0x14, 0xae, 0xe6, 0xf2, 0x3a, 0xf9, 0x0f, 0x94, 0xb9, 0xc5, 0x37, 0xcf, 0xb8, 0x5b, 0x99,
-	0x47, 0xd8, 0x07, 0xd0, 0xdb, 0x7a, 0xcd, 0x44, 0xca, 0x86, 0xfe, 0xcc, 0xb7, 0xa4, 0xac, 0xd5,
-	0x9c, 0xc8, 0x7c, 0xb3, 0x33, 0xfa, 0x84, 0xdf, 0x18, 0x53, 0x6d, 0x91, 0x6f, 0xbc, 0x6d, 0x23,
-	0x3a, 0xf7, 0xdf, 0x15, 0xbb, 0xce, 0xdf, 0x29, 0x97, 0x37, 0x3c, 0x35, 0x90, 0x7d, 0x0e, 0x73,
-	0xcf, 0x27, 0xc3, 0xc4, 0x4f, 0xdf, 0x2c, 0x27, 0xdf, 0x12, 0x1f, 0x61, 0x13, 0x72, 0xe9, 0x0a,
-	0xbb, 0xd2, 0xeb, 0xb1, 0x15, 0x1b, 0xb1, 0x96, 0xdc, 0x7c, 0x8f, 0x79, 0x84, 0x7d, 0x03, 0x96,
-	0xd3, 0x2e, 0xf9, 0xda, 0xc9, 0x63, 0xe7, 0x8f, 0x2c, 0x9e, 0x59, 0x6d, 0x3e, 0xa1, 0x4e, 0x9e,
-	0xc1, 0x42, 0xec, 0x07, 0xa7, 0x43, 0xaa, 0xb7, 0x13, 0x8b, 0x95, 0xb8, 0x6e, 0x0e, 0x4f, 0x3c,
-	0xb3, 0xee, 0x14, 0x7d, 0xc1, 0x08, 0xa4, 0x78, 0xa0, 0x29, 0x81, 0x64, 0x96, 0xa4, 0x68, 0x02,
-	0x9f, 0x40, 0xdb, 0xec, 0x8c, 0x3c, 0x16, 0x57, 0x27, 0xd3, 0x91, 0x95, 0x33, 0x37, 0xe0, 0x52,
-	0xca, 0x30, 0x6a, 0xda, 0x3f, 0xb3, 0xa0, 0xeb, 0x50, 0x46, 0xc6, 0x54, 0xeb, 0x54, 0x50, 0xcf,
-	0x93, 0x5c, 0xb3, 0xd3, 0x27, 0xac, 0xae, 0x64, 0xca, 0xb9, 0xae, 0x4c, 0xdd, 0x94, 0xed, 0x6b,
-	0x05, 0xb3, 0x5a, 0xaf, 0xc1, 0x8c, 0x98, 0xdf, 0x32, 0x5c, 0x17, 0x43, 0x92, 0xc3, 0x49, 0xc3,
-	0x8e, 0x46, 0xa7, 0x46, 0xd8, 0xb1, 0x07, 0x5d, 0xfe, 0x0e, 0x9e, 0x3e, 0x0f, 0xf1, 0xe1, 0x26,
-	0x90, 0xe7, 0x5e, 0xdf, 0x8b, 0xc2, 0x30, 0x38, 0xa0, 0x91, 0x48, 0x52, 0x45, 0xed, 0x13, 0xa3,
-	0x72, 0x52, 0x51, 0xe6, 0x25, 0xf9, 0x74, 0x5b, 0x18, 0xc8, 0x27, 0xf2, 0x78, 0xc9, 0x76, 0x60,
-	0x61, 0xdd, 0x7b, 0x45, 0x65, 0x4b, 0xe9, 0x2a, 0x35, 0xc6, 0xaa, 0x51, 0xb9, 0xf6, 0xf2, 0xce,
-	0x75, 0xbe, 0x5b, 0x47, 0xaf, 0x6d, 0xaf, 0xc2, 0xa2, 0xd9, 0xa6, 0x10, 0x25, 0x3d, 0xa8, 0x8d,
-	0x04, 0x4c, 0x8c, 0x4e, 0x95, 0x1f, 0x7c, 0x0e, 0x0d, 0xed, 0x6d, 0x43, 0xb2, 0x0c, 0x0b, 0x2f,
-	0x77, 0x8e, 0xf6, 0xb6, 0x0e, 0x0f, 0xdd, 0x83, 0x17, 0xeb, 0x9f, 0x6e, 0x7d, 0xdf, 0xdd, 0x5e,
-	0x3b, 0xdc, 0xee, 0x5c, 0x23, 0x4b, 0x40, 0xf6, 0xb6, 0x0e, 0x8f, 0xb6, 0x36, 0x0d, 0xb8, 0x45,
-	0xee, 0x40, 0xef, 0xc5, 0xde, 0x8b, 0xc3, 0xad, 0x4d, 0xb7, 0xe8, 0xbb, 0x12, 0xb9, 0x0d, 0x37,
-	0x04, 0xbe, 0xe0, 0xf3, 0xf2, 0x83, 0x27, 0xd0, 0xc9, 0xba, 0x25, 0x0d, 0x77, 0xee, 0x55, 0x7e,
-	0xdf, 0x07, 0xff, 0xa8, 0x0c, 0x90, 0x26, 0xa7, 0x92, 0x2e, 0x2c, 0x6e, 0xae, 0x1d, 0xad, 0xed,
-	0xee, 0xb3, 0x41, 0x38, 0xfb, 0x47, 0x5b, 0x1b, 0x47, 0xae, 0xb3, 0xf5, 0xdd, 0xce, 0xb5, 0x42,
-	0xcc, 0xfe, 0x01, 0x33, 0xd9, 0x97, 0x61, 0x61, 0x67, 0x6f, 0xe7, 0x68, 0x67, 0x6d, 0xd7, 0x75,
-	0xf6, 0x5f, 0xec, 0xec, 0x3d, 0xe3, 0xef, 0xae, 0x94, 0xc9, 0x3b, 0x70, 0xf3, 0xc5, 0xc1, 0x53,
-	0x67, 0x7f, 0xef, 0xc8, 0x3d, 0xdc, 0x7e, 0x71, 0xb4, 0x89, 0xaf, 0xb6, 0x6c, 0x38, 0x3b, 0x07,
-	0xbc, 0xcd, 0xca, 0x55, 0x15, 0x58, 0xd3, 0x55, 0xb6, 0x62, 0xcf, 0xf6, 0x0f, 0x0f, 0x77, 0x0e,
-	0xdc, 0xef, 0xbe, 0xd8, 0x72, 0x76, 0xb6, 0x0e, 0xf1, 0xc3, 0x99, 0x02, 0x38, 0xab, 0x3f, 0x4b,
-	0xe6, 0xa1, 0x75, 0xb4, 0xfb, 0x3d, 0x77, 0x7f, 0x6f, 0x67, 0x7f, 0x0f, 0xab, 0xd6, 0x4c, 0x10,
-	0xab, 0x55, 0x27, 0x3d, 0x58, 0xda, 0xfa, 0xdd, 0x23, 0xb7, 0xa0, 0x65, 0x98, 0x82, 0x63, 0xdf,
-	0x35, 0xc8, 0x0d, 0xb8, 0x7e, 0x78, 0xb4, 0x76, 0xb4, 0xb3, 0xe1, 0x8a, 0x67, 0x9b, 0xd8, 0x26,
-	0xb0, 0xcf, 0x9a, 0xc5, 0x28, 0xf6, 0x55, 0x8b, 0x2c, 0x42, 0xe7, 0x60, 0xed, 0xfb, 0xcf, 0xb7,
-	0xf6, 0x8e, 0xdc, 0xb5, 0xcd, 0x4d, 0x07, 0x3f, 0x68, 0xe7, 0xa0, 0xac, 0xee, 0x1c, 0xdb, 0xa8,
-	0xe7, 0x07, 0x07, 0x58, 0xa5, 0x23, 0x0b, 0x0c, 0x33, 0xbf, 0xfa, 0xb3, 0x32, 0xb4, 0xf9, 0x6d,
-	0x01, 0xfe, 0x63, 0x11, 0x34, 0x22, 0xcf, 0x61, 0x56, 0xfc, 0xea, 0x08, 0xb9, 0xae, 0x1e, 0xdb,
-	0xd0, 0x7f, 0xe7, 0xa4, 0xb7, 0x94, 0x05, 0x0b, 0xf6, 0x5b, 0xf8, 0x2b, 0xff, 0xf1, 0xbf, 0xff,
-	0x7e, 0xa9, 0x45, 0x1a, 0x0f, 0xcf, 0x3f, 0x7c, 0x78, 0x4a, 0x83, 0x98, 0xb5, 0xf1, 0x17, 0x01,
-	0xd2, 0xdf, 0xd2, 0x20, 0x5d, 0xe5, 0x7d, 0xcc, 0xfc, 0xd0, 0x48, 0xef, 0x46, 0x01, 0x46, 0xb4,
-	0x7b, 0x03, 0xdb, 0x5d, 0xb0, 0xdb, 0xac, 0x5d, 0x3f, 0xf0, 0x13, 0xfe, 0xbb, 0x1a, 0x1f, 0x5b,
-	0x0f, 0xc8, 0x00, 0x9a, 0xfa, 0xaf, 0x5c, 0x10, 0x19, 0xed, 0x2f, 0xf8, 0x9d, 0x8e, 0xde, 0xcd,
-	0x42, 0x9c, 0x94, 0x39, 0xd8, 0xc7, 0x75, 0xbb, 0xc3, 0xfa, 0x98, 0x60, 0x8d, 0xb4, 0x97, 0x21,
-	0x97, 0xc4, 0xe9, 0x8f, 0x59, 0x90, 0x5b, 0x9a, 0x70, 0xcc, 0xfd, 0x94, 0x46, 0xef, 0xf6, 0x14,
-	0xac, 0xe8, 0xeb, 0x36, 0xf6, 0xb5, 0x6c, 0x13, 0xd6, 0x57, 0x1f, 0xeb, 0xc8, 0x9f, 0xd2, 0xf8,
-	0xd8, 0x7a, 0xb0, 0xfa, 0xa7, 0xf7, 0xa1, 0xae, 0x32, 0x81, 0xc8, 0x8f, 0xa1, 0x65, 0x5c, 0xe7,
-	0x20, 0x72, 0x1a, 0x45, 0xb7, 0x3f, 0x7a, 0xb7, 0x8a, 0x91, 0xa2, 0xe3, 0x3b, 0xd8, 0x71, 0x97,
-	0x2c, 0xb1, 0x8e, 0xc5, 0x7d, 0x88, 0x87, 0x78, 0xfd, 0x89, 0x3f, 0x5d, 0xf2, 0x4a, 0x3b, 0x71,
-	0x78, 0x67, 0xb7, 0xb2, 0x87, 0x80, 0xd1, 0xdb, 0xed, 0x29, 0x58, 0xd1, 0xdd, 0x2d, 0xec, 0x6e,
-	0x89, 0x2c, 0xea, 0xdd, 0xa9, 0xec, 0x1c, 0x8a, 0xcf, 0x07, 0xe9, 0xbf, 0xf3, 0x40, 0x6e, 0xa7,
-	0x8f, 0xbb, 0x14, 0xfc, 0xfe, 0x83, 0x22, 0x91, 0xfc, 0x8f, 0x40, 0xd8, 0x5d, 0xec, 0x8a, 0x10,
-	0xdc, 0x3e, 0xfd, 0x67, 0x1e, 0xc8, 0x31, 0x34, 0xb4, 0xe7, 0x90, 0xc9, 0x8d, 0xa9, 0x4f, 0x37,
-	0xf7, 0x7a, 0x45, 0xa8, 0xa2, 0xa9, 0xe8, 0xed, 0x3f, 0x64, 0x0a, 0xe9, 0x0f, 0xa1, 0xae, 0x1e,
-	0xd8, 0x25, 0xcb, 0xda, 0x83, 0xc7, 0xfa, 0x83, 0xc0, 0xbd, 0x6e, 0x1e, 0x51, 0x44, 0x7c, 0x7a,
-	0xeb, 0x8c, 0xf8, 0x5e, 0x42, 0x43, 0x7b, 0x44, 0x57, 0x4d, 0x20, 0xff, 0x50, 0xaf, 0x9a, 0x40,
-	0xc1, 0x9b, 0xbb, 0xf6, 0x3c, 0x76, 0xd1, 0x20, 0x75, 0xa4, 0xef, 0xe4, 0x75, 0x18, 0x93, 0x5d,
-	0xb8, 0x2e, 0x4e, 0xd6, 0x63, 0xfa, 0x45, 0xb6, 0xa1, 0xe0, 0xa7, 0x35, 0x1e, 0x59, 0xe4, 0x09,
-	0xd4, 0xe4, 0x5b, 0xc9, 0x64, 0xa9, 0xf8, 0xcd, 0xe7, 0xde, 0x72, 0x0e, 0x2e, 0x8e, 0xc1, 0xef,
-	0x03, 0xa4, 0x2f, 0xf6, 0x2a, 0x21, 0x91, 0x7b, 0x01, 0x58, 0x51, 0x40, 0xfe, 0x79, 0x5f, 0x7b,
-	0x09, 0x27, 0xd8, 0x21, 0x28, 0x24, 0x02, 0x7a, 0x21, 0xdf, 0xae, 0xf8, 0x11, 0x34, 0xb4, 0x47,
-	0x7b, 0xd5, 0xf2, 0xe5, 0x1f, 0xfc, 0x55, 0xcb, 0x57, 0xf0, 0xc6, 0xaf, 0xdd, 0xc3, 0xd6, 0x17,
-	0xed, 0x39, 0xd6, 0x7a, 0xec, 0x9f, 0x06, 0x23, 0x5e, 0x81, 0x6d, 0xd0, 0x19, 0xb4, 0x8c, 0x97,
-	0x79, 0x15, 0x87, 0x16, 0xbd, 0xfb, 0xab, 0x38, 0xb4, 0xf0, 0x31, 0x5f, 0x49, 0x67, 0xf6, 0x3c,
-	0xeb, 0xe7, 0x1c, 0xab, 0x68, 0x3d, 0xfd, 0x00, 0x1a, 0xda, 0x2b, 0xbb, 0x6a, 0x2e, 0xf9, 0x07,
-	0x7d, 0xd5, 0x5c, 0x8a, 0x1e, 0xe5, 0x5d, 0xc4, 0x3e, 0xda, 0x36, 0x92, 0x02, 0xbe, 0x46, 0xc5,
-	0xda, 0xfe, 0x31, 0xb4, 0xcd, 0x77, 0x77, 0x15, 0xef, 0x17, 0xbe, 0xe0, 0xab, 0x78, 0x7f, 0xca,
-	0x63, 0xbd, 0x82, 0xa4, 0x1f, 0x2c, 0xa8, 0x4e, 0x1e, 0xfe, 0x54, 0x24, 0x36, 0x7f, 0x4e, 0xbe,
-	0xcb, 0x04, 0x9c, 0x78, 0x25, 0x8d, 0x2c, 0x6b, 0x54, 0xab, 0xbf, 0xa5, 0xa6, 0xf8, 0x25, 0xf7,
-	0xa0, 0x9a, 0x49, 0xcc, 0xfc, 0x3d, 0xad, 0x67, 0xb0, 0xa0, 0x88, 0x59, 0xbd, 0x7a, 0x16, 0xab,
-	0x39, 0x14, 0x3e, 0xae, 0xd6, 0xeb, 0x64, 0xb1, 0x8f, 0x2c, 0x7e, 0xfc, 0xe1, 0xdb, 0x52, 0xda,
-	0xf1, 0xa7, 0x3f, 0x7c, 0xa6, 0x1d, 0x7f, 0xc6, 0x13, 0x54, 0xd9, 0xe3, 0x2f, 0xf1, 0x59, 0x1b,
-	0x01, 0xcc, 0x65, 0x6e, 0xc8, 0x2a, 0xf6, 0x2a, 0x7e, 0xc4, 0xa0, 0x77, 0xe7, 0xea, 0x8b, 0xb5,
-	0xa6, 0x28, 0x92, 0xd2, 0xf4, 0xa1, 0x7c, 0x21, 0xe5, 0xf7, 0xa0, 0xa9, 0x3f, 0x17, 0x4a, 0x74,
-	0x99, 0x90, 0xed, 0xe9, 0x66, 0x21, 0xce, 0xa4, 0x12, 0xd2, 0xd4, 0xbb, 0x21, 0xdf, 0x83, 0x25,
-	0xb5, 0xcc, 0xfa, 0x45, 0xc9, 0x98, 0xbc, 0x53, 0x70, 0x7d, 0xd2, 0x58, 0xec, 0x1b, 0x53, 0xef,
-	0x57, 0x3e, 0xb2, 0x18, 0xf5, 0x99, 0x6f, 0x30, 0xa6, 0x27, 0x4f, 0xd1, 0xd3, 0x93, 0xe9, 0xc9,
-	0x53, 0xf8, 0x70, 0xa3, 0xa4, 0x3e, 0xb2, 0x60, 0xac, 0x11, 0xcf, 0xdf, 0x22, 0x3f, 0x80, 0x39,
-	0xed, 0x5a, 0xfb, 0xe1, 0x65, 0xd0, 0x57, 0x9c, 0x94, 0x7f, 0xc2, 0xa8, 0x57, 0x64, 0x96, 0xda,
-	0xcb, 0xd8, 0xfe, 0xbc, 0x6d, 0x2c, 0x0e, 0xe3, 0xa2, 0x0d, 0x68, 0xe8, 0x57, 0xe6, 0xaf, 0x68,
-	0x77, 0x59, 0x43, 0xe9, 0xef, 0xe3, 0x3c, 0xb2, 0xc8, 0x2e, 0x74, 0xb2, 0x4f, 0x79, 0x28, 0x99,
-	0x52, 0xf4, 0xfc, 0x48, 0x2f, 0x83, 0x34, 0x1e, 0x00, 0x21, 0x07, 0x3c, 0x2b, 0x58, 0xfd, 0x06,
-	0x45, 0x18, 0x65, 0x4f, 0x75, 0xf3, 0xb7, 0x29, 0x54, 0x6b, 0x45, 0xbf, 0x4a, 0x72, 0xdf, 0x7a,
-	0x64, 0x91, 0xbf, 0x6b, 0x41, 0xd3, 0xb8, 0x20, 0x6f, 0xe4, 0x58, 0x66, 0xe6, 0xd9, 0xd5, 0x71,
-	0xfa, 0x44, 0x6d, 0x07, 0x17, 0x71, 0xf7, 0xc1, 0x27, 0xc6, 0x26, 0xfd, 0xd4, 0xf0, 0xf4, 0xae,
-	0x64, 0x7f, 0x88, 0xe2, 0xf3, 0x6c, 0x05, 0xfd, 0x19, 0xaa, 0xcf, 0x1f, 0x59, 0xe4, 0x9f, 0x58,
-	0xd0, 0x36, 0x43, 0x38, 0x6a, 0xba, 0x85, 0xc1, 0x22, 0x45, 0x4a, 0x53, 0xe2, 0x3e, 0x3f, 0xc0,
-	0x51, 0x1e, 0x3d, 0x70, 0x8c, 0x51, 0x8a, 0xd7, 0x43, 0x7f, 0xb5, 0xd1, 0x92, 0x8f, 0xf9, 0xef,
-	0x42, 0xc9, 0xe8, 0x35, 0xc9, 0xff, 0x8e, 0x90, 0x22, 0x3f, 0xfd, 0x57, 0x77, 0x70, 0x13, 0x7e,
-	0xc4, 0x7f, 0x80, 0x41, 0x86, 0x40, 0x19, 0x15, 0xbf, 0xed, 0xf7, 0xf6, 0x3d, 0x9c, 0xd3, 0x1d,
-	0xfb, 0x86, 0x31, 0xa7, 0xac, 0xe2, 0xb1, 0xc6, 0x47, 0x27, 0x7e, 0x30, 0x27, 0x3d, 0x39, 0x73,
-	0x3f, 0xa2, 0x33, 0x7d, 0x90, 0x23, 0x3e, 0x48, 0x51, 0xdd, 0x60, 0xb5, 0xb7, 0x6c, 0xc6, 0x7e,
-	0x80, 0x63, 0xbd, 0x67, 0xbf, 0x33, 0x75, 0xac, 0x0f, 0x31, 0x10, 0xc3, 0x46, 0x7c, 0x00, 0x90,
-	0x66, 0x9b, 0x90, 0x4c, 0xa6, 0x83, 0x12, 0x40, 0xf9, 0x84, 0x14, 0x93, 0x9f, 0x65, 0x42, 0x04,
-	0x6b, 0xf1, 0x87, 0x5c, 0x9c, 0xee, 0xc8, 0x1c, 0x09, 0x5d, 0xfb, 0x32, 0x53, 0x42, 0x0c, 0xed,
-	0x2b, 0xdb, 0xbe, 0x21, 0x4c, 0x55, 0xc2, 0xc5, 0x0b, 0x68, 0xed, 0x86, 0xe1, 0xab, 0xc9, 0x58,
-	0xa5, 0x3f, 0x9a, 0x31, 0xd2, 0x6d, 0x2f, 0x3e, 0xeb, 0x65, 0x66, 0x61, 0xdf, 0xc5, 0xa6, 0x7a,
-	0xa4, 0xab, 0x35, 0xf5, 0xf0, 0xa7, 0x69, 0x26, 0xcb, 0xe7, 0xc4, 0x83, 0x79, 0x25, 0xa3, 0xd5,
+	// 9926 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0xbd, 0x5d, 0x6c, 0x1c, 0xd9,
+	0x95, 0x18, 0xac, 0xea, 0x1f, 0xb2, 0xfb, 0xf4, 0x0f, 0x9b, 0x97, 0x14, 0xd9, 0x6a, 0xfd, 0x8c,
+	0xa6, 0x2c, 0xcf, 0xc8, 0xf2, 0x98, 0xd2, 0xd0, 0xf6, 0xac, 0x3c, 0xfa, 0xd6, 0x6b, 0xfe, 0x49,
+	0xe4, 0x0c, 0x45, 0xd2, 0x45, 0xca, 0x5a, 0xdb, 0xdf, 0xa2, 0x5c, 0xec, 0xbe, 0x24, 0xcb, 0xea,
+	0xae, 0xea, 0xa9, 0xaa, 0x26, 0x45, 0x3b, 0x93, 0x87, 0x20, 0x09, 0x82, 0xbc, 0x04, 0x86, 0x11,
+	0x20, 0x9b, 0x1f, 0x2c, 0xe0, 0x4d, 0x10, 0x04, 0x01, 0x92, 0x3c, 0x05, 0x1b, 0xc0, 0x79, 0xca,
+	0xc3, 0xe6, 0x25, 0xc8, 0x43, 0x02, 0x04, 0x48, 0x80, 0x00, 0x8b, 0xcd, 0x43, 0x16, 0x01, 0xf2,
+	0x94, 0xe4, 0x39, 0xb8, 0xe7, 0xfe, 0xd4, 0xbd, 0x55, 0xd5, 0x94, 0xc6, 0x76, 0xfc, 0x22, 0xf1,
+	0x9e, 0x7b, 0xea, 0xfe, 0x9e, 0x73, 0xee, 0xf9, 0xb9, 0xe7, 0x36, 0xd4, 0xa3, 0x71, 0x7f, 0x65,
+	0x1c, 0x85, 0x49, 0x48, 0xaa, 0xc3, 0x20, 0x1a, 0xf7, 0x7b, 0xb7, 0x4e, 0xc3, 0xf0, 0x74, 0x48,
+	0x1f, 0x7a, 0x63, 0xff, 0xa1, 0x17, 0x04, 0x61, 0xe2, 0x25, 0x7e, 0x18, 0xc4, 0x1c, 0xc9, 0xfe,
+	0x11, 0xb4, 0x9f, 0xd1, 0xe0, 0x90, 0xd2, 0x81, 0x43, 0x3f, 0x9b, 0xd0, 0x38, 0x21, 0x5f, 0x85,
+	0x79, 0x8f, 0xfe, 0x84, 0xd2, 0x81, 0x3b, 0xf6, 0xe2, 0x78, 0x7c, 0x16, 0x79, 0x31, 0xed, 0x5a,
+	0x77, 0xad, 0xfb, 0x4d, 0xa7, 0xc3, 0x2b, 0x0e, 0x14, 0x9c, 0xbc, 0x0b, 0xcd, 0x98, 0xa1, 0xd2,
+	0x20, 0x89, 0xc2, 0xf1, 0x65, 0xb7, 0x84, 0x78, 0x0d, 0x06, 0xdb, 0xe2, 0x20, 0x7b, 0x08, 0x73,
+	0xaa, 0x87, 0x78, 0x1c, 0x06, 0x31, 0x25, 0x8f, 0x60, 0xb1, 0xef, 0x8f, 0xcf, 0x68, 0xe4, 0xe2,
+	0xc7, 0xa3, 0x80, 0x8e, 0xc2, 0xc0, 0xef, 0x77, 0xad, 0xbb, 0xe5, 0xfb, 0x75, 0x87, 0xf0, 0x3a,
+	0xf6, 0xc5, 0x73, 0x51, 0x43, 0xde, 0x87, 0x39, 0x1a, 0x70, 0x38, 0x1d, 0xe0, 0x57, 0xa2, 0xab,
+	0x76, 0x0a, 0x66, 0x1f, 0xd8, 0x7f, 0xa3, 0x04, 0xf3, 0x3b, 0x81, 0x9f, 0xbc, 0xf4, 0x86, 0x43,
+	0x9a, 0xc8, 0x39, 0xbd, 0x0f, 0x73, 0x17, 0x08, 0xc0, 0x39, 0x5d, 0x84, 0xd1, 0x40, 0xcc, 0xa8,
+	0xcd, 0xc1, 0x07, 0x02, 0x3a, 0x75, 0x64, 0xa5, 0xa9, 0x23, 0x2b, 0x5c, 0xae, 0xf2, 0x94, 0xe5,
+	0x7a, 0x1f, 0xe6, 0x22, 0xda, 0x0f, 0xcf, 0x69, 0x74, 0xe9, 0x5e, 0xf8, 0xc1, 0x20, 0xbc, 0xe8,
+	0x56, 0xee, 0x5a, 0xf7, 0xab, 0x4e, 0x5b, 0x82, 0x5f, 0x22, 0x94, 0xac, 0xc3, 0x5c, 0xff, 0xcc,
+	0x0b, 0x02, 0x3a, 0x74, 0x8f, 0xbd, 0xfe, 0xab, 0xc9, 0x38, 0xee, 0x56, 0xef, 0x5a, 0xf7, 0x1b,
+	0xab, 0x37, 0x56, 0x70, 0x57, 0x57, 0x36, 0xce, 0xbc, 0x60, 0x1d, 0x6b, 0x0e, 0x03, 0x6f, 0x1c,
+	0x9f, 0x85, 0x89, 0xd3, 0x16, 0x5f, 0x70, 0x70, 0x6c, 0x2f, 0x02, 0xd1, 0x57, 0x82, 0xaf, 0xbd,
+	0xfd, 0x4f, 0x2d, 0x58, 0x78, 0x11, 0x0c, 0xc3, 0xfe, 0xab, 0x5f, 0x71, 0x89, 0x0a, 0xe6, 0x50,
+	0x7a, 0xdb, 0x39, 0x94, 0xbf, 0xe8, 0x1c, 0x96, 0x60, 0xd1, 0x1c, 0xac, 0x98, 0x05, 0x85, 0xeb,
+	0xec, 0xeb, 0x53, 0x2a, 0x87, 0x25, 0xa7, 0xf1, 0x15, 0xe8, 0xf4, 0x27, 0x51, 0x44, 0x83, 0xdc,
+	0x3c, 0xe6, 0x04, 0x5c, 0x4d, 0xe4, 0x5d, 0x68, 0x06, 0xf4, 0x22, 0x45, 0x13, 0xb4, 0x1b, 0xd0,
+	0x0b, 0x89, 0x62, 0x77, 0x61, 0x29, 0xdb, 0x8d, 0x18, 0xc0, 0x9f, 0x59, 0x50, 0x79, 0x91, 0xbc,
+	0x0e, 0xc9, 0x0a, 0x54, 0x92, 0xcb, 0x31, 0xe7, 0x90, 0xf6, 0x2a, 0x11, 0x53, 0x5b, 0x1b, 0x0c,
+	0x22, 0x1a, 0xc7, 0x47, 0x97, 0x63, 0xea, 0x34, 0x3d, 0x5e, 0x70, 0x19, 0x1e, 0xe9, 0xc2, 0xac,
+	0x28, 0x63, 0x87, 0x75, 0x47, 0x16, 0xc9, 0x1d, 0x00, 0x6f, 0x14, 0x4e, 0x82, 0xc4, 0x8d, 0xbd,
+	0x04, 0x97, 0xaa, 0xec, 0x68, 0x10, 0x72, 0x0b, 0xea, 0xe3, 0x57, 0x6e, 0xdc, 0x8f, 0xfc, 0x71,
+	0x82, 0x64, 0x53, 0x77, 0x52, 0x00, 0xf9, 0x2a, 0xd4, 0xc2, 0x49, 0x32, 0x0e, 0xfd, 0x20, 0x11,
+	0xa4, 0x32, 0x27, 0xc6, 0xb2, 0x3f, 0x49, 0x0e, 0x18, 0xd8, 0x51, 0x08, 0xe4, 0x1e, 0xb4, 0xfa,
+	0x61, 0x70, 0xe2, 0x47, 0x23, 0x2e, 0x0c, 0xba, 0x33, 0xd8, 0x9b, 0x09, 0xb4, 0xff, 0x55, 0x09,
+	0x1a, 0x47, 0x91, 0x17, 0xc4, 0x5e, 0x9f, 0x01, 0xd8, 0xd0, 0x93, 0xd7, 0xee, 0x99, 0x17, 0x9f,
+	0xe1, 0x6c, 0xeb, 0x8e, 0x2c, 0x92, 0x25, 0x98, 0xe1, 0x03, 0xc5, 0x39, 0x95, 0x1d, 0x51, 0x22,
+	0x1f, 0xc0, 0x7c, 0x30, 0x19, 0xb9, 0x66, 0x5f, 0x65, 0xa4, 0x96, 0x7c, 0x05, 0x5b, 0x80, 0x63,
+	0xb6, 0xd7, 0xbc, 0x0b, 0x3e, 0x43, 0x0d, 0x42, 0x6c, 0x68, 0x8a, 0x12, 0xf5, 0x4f, 0xcf, 0xf8,
+	0x34, 0xab, 0x8e, 0x01, 0x63, 0x6d, 0x24, 0xfe, 0x88, 0xba, 0x71, 0xe2, 0x8d, 0xc6, 0x62, 0x5a,
+	0x1a, 0x04, 0xeb, 0xc3, 0xc4, 0x1b, 0xba, 0x27, 0x94, 0xc6, 0xdd, 0x59, 0x51, 0xaf, 0x20, 0xe4,
+	0x3d, 0x68, 0x0f, 0x68, 0x9c, 0xb8, 0x62, 0x53, 0x68, 0xdc, 0xad, 0x21, 0xeb, 0x67, 0xa0, 0xac,
+	0x9d, 0xc8, 0xbb, 0x70, 0xd9, 0x02, 0xd0, 0xd7, 0xdd, 0x3a, 0x1f, 0x6b, 0x0a, 0x61, 0x94, 0xf3,
+	0x8c, 0x26, 0xda, 0xea, 0xc5, 0x82, 0x42, 0xed, 0x5d, 0x20, 0x1a, 0x78, 0x93, 0x26, 0x9e, 0x3f,
+	0x8c, 0xc9, 0x47, 0xd0, 0x4c, 0x34, 0x64, 0x14, 0x85, 0x0d, 0x45, 0x4e, 0xda, 0x07, 0x8e, 0x81,
+	0x67, 0x9f, 0x41, 0xed, 0x29, 0xa5, 0xbb, 0xfe, 0xc8, 0x4f, 0xc8, 0x12, 0x54, 0x4f, 0xfc, 0xd7,
+	0x94, 0x13, 0x7c, 0x79, 0xfb, 0x9a, 0xc3, 0x8b, 0xe4, 0x1d, 0x00, 0xfc, 0xc3, 0x1d, 0x29, 0xc2,
+	0xda, 0xbe, 0xe6, 0xd4, 0x11, 0xf6, 0x9c, 0x51, 0x56, 0x0f, 0x66, 0xc7, 0x34, 0xea, 0x53, 0xb9,
+	0x7f, 0xdb, 0xd7, 0x1c, 0x09, 0x58, 0x9f, 0x85, 0xea, 0x90, 0xb5, 0x6e, 0xff, 0x69, 0x15, 0x1a,
+	0x87, 0x34, 0x50, 0x9c, 0x46, 0xa0, 0xc2, 0xd6, 0x44, 0x70, 0x17, 0xfe, 0x4d, 0xbe, 0x04, 0x0d,
+	0x5c, 0xa7, 0x38, 0x89, 0xfc, 0xe0, 0x94, 0x13, 0xf8, 0x7a, 0xa9, 0x6b, 0x39, 0xc0, 0xc0, 0x87,
+	0x08, 0x25, 0x1d, 0x28, 0x7b, 0x23, 0x49, 0xe0, 0xec, 0x4f, 0x72, 0x03, 0x6a, 0xde, 0x28, 0xe1,
+	0xc3, 0x6b, 0x22, 0x78, 0xd6, 0x1b, 0x25, 0x38, 0xb4, 0x77, 0xa1, 0x39, 0xf6, 0x2e, 0x47, 0x8c,
+	0x9f, 0x15, 0x55, 0x34, 0x9d, 0x86, 0x80, 0x6d, 0x33, 0xb2, 0x58, 0x85, 0x05, 0x1d, 0x45, 0x76,
+	0x5e, 0x55, 0x9d, 0xcf, 0x6b, 0xd8, 0x62, 0x0c, 0xef, 0xc3, 0x9c, 0xfc, 0x26, 0xe2, 0xf3, 0x41,
+	0x5a, 0xa9, 0x3b, 0x6d, 0x01, 0x96, 0xb3, 0xbc, 0x0f, 0x9d, 0x13, 0x3f, 0xf0, 0x86, 0x6e, 0x7f,
+	0x98, 0x9c, 0xbb, 0x03, 0x3a, 0x4c, 0x3c, 0xa4, 0x9a, 0xaa, 0xd3, 0x46, 0xf8, 0xc6, 0x30, 0x39,
+	0xdf, 0x64, 0x50, 0xf2, 0x01, 0xd4, 0x4f, 0x28, 0x75, 0x71, 0xb1, 0xba, 0x35, 0x83, 0x03, 0xe5,
+	0x0e, 0x39, 0xb5, 0x13, 0xb9, 0x57, 0x1f, 0x40, 0x27, 0x9c, 0x24, 0xa7, 0xa1, 0x1f, 0x9c, 0xba,
+	0x4c, 0xe6, 0xb9, 0xfe, 0x00, 0xa9, 0xa8, 0xb2, 0x5e, 0x7a, 0x64, 0x39, 0x6d, 0x59, 0xc7, 0xa4,
+	0xcf, 0xce, 0x80, 0xbc, 0x07, 0x73, 0x43, 0x2f, 0x4e, 0xdc, 0xb3, 0x70, 0xec, 0x8e, 0x27, 0xc7,
+	0xaf, 0xe8, 0x65, 0xb7, 0x85, 0x0b, 0xd1, 0x62, 0xe0, 0xed, 0x70, 0x7c, 0x80, 0x40, 0x72, 0x1b,
+	0x00, 0xc7, 0xc9, 0x07, 0x01, 0x77, 0xad, 0xfb, 0x2d, 0xa7, 0xce, 0x20, 0xbc, 0xd3, 0xef, 0xc3,
+	0x02, 0x6e, 0x4f, 0x7f, 0x12, 0x27, 0xe1, 0xc8, 0x65, 0xf2, 0x3a, 0x1a, 0xc4, 0xdd, 0x06, 0xd2,
+	0xda, 0x57, 0xc4, 0x60, 0xb5, 0x3d, 0x5e, 0xd9, 0xa4, 0x71, 0xb2, 0x81, 0xc8, 0x0e, 0xc7, 0x65,
+	0x87, 0xfa, 0xa5, 0x33, 0x3f, 0xc8, 0xc2, 0xc9, 0x07, 0x40, 0xbc, 0xe1, 0x30, 0xbc, 0x70, 0x63,
+	0x3a, 0x3c, 0x71, 0xc5, 0x22, 0x76, 0xdb, 0x77, 0xad, 0xfb, 0x35, 0xa7, 0x83, 0x35, 0x87, 0x74,
+	0x78, 0x72, 0xc0, 0xe1, 0xe4, 0x23, 0x68, 0xe1, 0x40, 0x4e, 0xa8, 0x97, 0x4c, 0x22, 0x1a, 0x77,
+	0xe7, 0xee, 0x96, 0xef, 0xb7, 0x57, 0xe7, 0xd5, 0x7a, 0x21, 0x78, 0xdd, 0x4f, 0x9c, 0x26, 0xc3,
+	0x13, 0xe5, 0xb8, 0xb7, 0x09, 0x4b, 0xc5, 0x43, 0x62, 0x44, 0xc5, 0x56, 0x85, 0x11, 0x63, 0xc5,
+	0x61, 0x7f, 0x92, 0x45, 0xa8, 0x9e, 0x7b, 0xc3, 0x09, 0x15, 0x72, 0x9d, 0x17, 0x3e, 0x2e, 0x3d,
+	0xb6, 0xec, 0x3f, 0xb1, 0xa0, 0xc9, 0x67, 0x29, 0xf4, 0x91, 0x7b, 0xd0, 0x92, 0xd4, 0x40, 0xa3,
+	0x28, 0x8c, 0x84, 0x78, 0x33, 0x81, 0xe4, 0x01, 0x74, 0x24, 0x60, 0x1c, 0x51, 0x7f, 0xe4, 0x9d,
+	0xca, 0xb6, 0x73, 0x70, 0xb2, 0x9a, 0xb6, 0x18, 0x85, 0x93, 0x84, 0x8a, 0x93, 0xaf, 0x29, 0x26,
+	0xe8, 0x30, 0x98, 0x63, 0xa2, 0x30, 0xf1, 0x56, 0x40, 0xea, 0x06, 0xcc, 0xfe, 0xdb, 0x16, 0x10,
+	0x36, 0xf4, 0xa3, 0x90, 0x37, 0x21, 0xa8, 0x34, 0xcb, 0x25, 0xd6, 0x5b, 0x73, 0x49, 0xe9, 0x2a,
+	0x2e, 0xb1, 0xa1, 0xca, 0x47, 0x5f, 0x29, 0x18, 0x3d, 0xaf, 0xfa, 0xa4, 0x52, 0x2b, 0x77, 0x2a,
+	0xf6, 0x7f, 0x2e, 0xc3, 0xe2, 0x06, 0x3f, 0xba, 0xd7, 0xfa, 0x7d, 0x3a, 0x56, 0xfc, 0xf3, 0x0e,
+	0x34, 0x82, 0x70, 0x40, 0x25, 0xd5, 0xf2, 0x81, 0x01, 0x03, 0x69, 0x24, 0x7b, 0xe6, 0xf9, 0x01,
+	0x1f, 0x38, 0x5f, 0xcf, 0x3a, 0x42, 0x70, 0xd8, 0xef, 0xc1, 0xdc, 0x98, 0x06, 0x03, 0x9d, 0x4d,
+	0xb8, 0x72, 0xd5, 0x12, 0x60, 0xc1, 0x21, 0xef, 0x40, 0xe3, 0x64, 0xc2, 0xf1, 0x98, 0x70, 0xa9,
+	0x20, 0x1d, 0x80, 0x00, 0xad, 0x71, 0x19, 0x33, 0x9e, 0xc4, 0x67, 0x58, 0x5b, 0xc5, 0xda, 0x59,
+	0x56, 0x66, 0x55, 0xb7, 0x01, 0x06, 0x93, 0x38, 0x11, 0x5c, 0x33, 0x83, 0x95, 0x75, 0x06, 0xe1,
+	0x5c, 0xf3, 0x35, 0x58, 0x18, 0x79, 0xaf, 0x5d, 0xa4, 0x1f, 0xd7, 0x0f, 0xdc, 0x93, 0x21, 0x9e,
+	0x3e, 0xb3, 0x88, 0xd7, 0x19, 0x79, 0xaf, 0xbf, 0xc7, 0x6a, 0x76, 0x82, 0xa7, 0x08, 0x67, 0xa2,
+	0x45, 0xaa, 0x3d, 0x11, 0x8d, 0x69, 0x74, 0x4e, 0x51, 0x1a, 0x54, 0x94, 0x6e, 0xe3, 0x70, 0x28,
+	0x1b, 0xd1, 0x88, 0xcd, 0x3b, 0x19, 0xf6, 0x39, 0xeb, 0x3b, 0xb3, 0x23, 0x3f, 0xd8, 0x4e, 0x86,
+	0x7d, 0x72, 0x0b, 0x80, 0xc9, 0x92, 0x31, 0x8d, 0xdc, 0x57, 0x17, 0xc8, 0xc7, 0x15, 0x94, 0x1d,
+	0x07, 0x34, 0xfa, 0xf4, 0x82, 0xdc, 0x84, 0x7a, 0x3f, 0x46, 0x61, 0xe4, 0x5d, 0x76, 0x1b, 0xc8,
+	0xe4, 0xb5, 0x7e, 0xcc, 0xc4, 0x90, 0x77, 0xc9, 0x18, 0x91, 0x8d, 0xd6, 0xc3, 0x5d, 0xa0, 0x03,
+	0x6c, 0x3e, 0x46, 0xa9, 0xda, 0xc2, 0xc1, 0xae, 0x89, 0x0a, 0xd6, 0x4f, 0x4c, 0xbe, 0x04, 0x2d,
+	0x39, 0xd8, 0x93, 0xa1, 0x77, 0x1a, 0xa3, 0x58, 0x69, 0x39, 0x4d, 0x01, 0x7c, 0xca, 0x60, 0xf6,
+	0x4b, 0xae, 0x6c, 0x69, 0x7b, 0x2b, 0xf8, 0x86, 0x1d, 0xfb, 0x08, 0xc1, 0x7d, 0xad, 0x39, 0xa2,
+	0x54, 0xb4, 0x69, 0xa5, 0x82, 0x4d, 0xb3, 0x7f, 0x61, 0x41, 0x53, 0xb4, 0x8c, 0x1a, 0x0a, 0x79,
+	0x04, 0x44, 0xee, 0x62, 0xf2, 0xda, 0x1f, 0xb8, 0xc7, 0x97, 0x09, 0x8d, 0x39, 0xd1, 0x6c, 0x5f,
+	0x73, 0x0a, 0xea, 0x98, 0x1c, 0x35, 0xa0, 0x71, 0x12, 0x71, 0x9a, 0xde, 0xbe, 0xe6, 0xe4, 0x6a,
+	0x18, 0x8b, 0x31, 0x1d, 0x68, 0x92, 0xb8, 0x7e, 0x30, 0xa0, 0xaf, 0x91, 0x94, 0x5a, 0x8e, 0x01,
+	0x5b, 0x6f, 0x43, 0x53, 0xff, 0xce, 0xfe, 0x31, 0xd4, 0xa4, 0x06, 0x85, 0xda, 0x43, 0x66, 0x5c,
+	0x8e, 0x06, 0x21, 0x3d, 0xa8, 0x99, 0xa3, 0x70, 0x6a, 0x5f, 0xa4, 0x6f, 0xfb, 0xdb, 0xd0, 0xd9,
+	0x65, 0x44, 0x14, 0x30, 0xa2, 0x15, 0x6a, 0xe1, 0x12, 0xcc, 0x68, 0xcc, 0x53, 0x77, 0x44, 0x89,
+	0x9d, 0xbf, 0x67, 0x61, 0x9c, 0x88, 0x7e, 0xf0, 0x6f, 0xfb, 0x4f, 0x2d, 0x20, 0x5b, 0x71, 0xe2,
+	0x8f, 0xbc, 0x84, 0x3e, 0xa5, 0x4a, 0x3c, 0xec, 0x43, 0x93, 0xb5, 0x76, 0x14, 0xae, 0x71, 0x25,
+	0x8d, 0x2b, 0x17, 0x5f, 0x15, 0xec, 0x9c, 0xff, 0x60, 0x45, 0xc7, 0xe6, 0x22, 0xdf, 0x68, 0x80,
+	0x71, 0x5b, 0xe2, 0x45, 0xa7, 0x34, 0x41, 0x0d, 0x4e, 0xe8, 0xff, 0xc0, 0x41, 0x1b, 0x61, 0x70,
+	0xd2, 0xfb, 0x3d, 0x98, 0xcf, 0xb5, 0xa1, 0xcb, 0xe8, 0x7a, 0x81, 0x8c, 0x2e, 0xeb, 0x32, 0xba,
+	0x0f, 0x0b, 0xc6, 0xb8, 0x04, 0xc5, 0x75, 0x61, 0x96, 0x31, 0x06, 0x53, 0x14, 0x2c, 0xae, 0x28,
+	0x88, 0x22, 0x59, 0x85, 0xc5, 0x13, 0x4a, 0x23, 0x2f, 0xc1, 0x22, 0xb2, 0x0e, 0xdb, 0x13, 0xd1,
+	0x72, 0x61, 0x9d, 0xfd, 0xe7, 0x16, 0xcc, 0x31, 0x69, 0xfa, 0xdc, 0x0b, 0x2e, 0xe5, 0x5a, 0xed,
+	0x16, 0xae, 0xd5, 0x7d, 0xed, 0x70, 0xd4, 0xb0, 0xbf, 0xe8, 0x42, 0x95, 0xb3, 0x0b, 0x45, 0xee,
+	0x42, 0xd3, 0x18, 0x6e, 0x95, 0x6b, 0xa4, 0xb1, 0x97, 0x1c, 0xd0, 0x68, 0xfd, 0x32, 0xa1, 0xbf,
+	0xfe, 0x52, 0xbe, 0x07, 0x9d, 0x74, 0xd8, 0x62, 0x1d, 0x09, 0x54, 0x18, 0x61, 0x8a, 0x06, 0xf0,
+	0x6f, 0xfb, 0xef, 0x5b, 0x1c, 0x71, 0x23, 0xf4, 0x95, 0xb6, 0xca, 0x10, 0x99, 0xd2, 0x2b, 0x11,
+	0xd9, 0xdf, 0x53, 0xb5, 0xfd, 0x5f, 0x7f, 0xb2, 0x4c, 0x26, 0xc6, 0x34, 0x18, 0xb8, 0xde, 0x70,
+	0x88, 0x82, 0xb8, 0xe6, 0xcc, 0xb2, 0xf2, 0xda, 0x70, 0x68, 0xbf, 0x0f, 0xf3, 0xda, 0xe8, 0xae,
+	0x98, 0xc7, 0x1e, 0x90, 0x5d, 0x3f, 0x4e, 0x5e, 0x04, 0xf1, 0x58, 0x53, 0xe4, 0x6e, 0x42, 0x9d,
+	0x49, 0x5b, 0x36, 0x32, 0xce, 0xb9, 0x55, 0x87, 0x89, 0x5f, 0x36, 0xae, 0x18, 0x2b, 0xbd, 0xd7,
+	0xa2, 0xb2, 0x24, 0x2a, 0xbd, 0xd7, 0x58, 0x69, 0x3f, 0x86, 0x05, 0xa3, 0x3d, 0xd1, 0xf5, 0xbb,
+	0x50, 0x9d, 0x24, 0xaf, 0x43, 0xa9, 0xaa, 0x37, 0x04, 0x85, 0x30, 0xa3, 0xd0, 0xe1, 0x35, 0xf6,
+	0x13, 0x98, 0xdf, 0xa3, 0x17, 0x82, 0x91, 0xe5, 0x40, 0xde, 0x7b, 0xa3, 0xc1, 0x88, 0xf5, 0xf6,
+	0x0a, 0x10, 0xfd, 0xe3, 0x94, 0x01, 0xa4, 0xf9, 0x68, 0x19, 0xe6, 0xa3, 0xfd, 0x1e, 0x90, 0x43,
+	0xff, 0x34, 0x78, 0x4e, 0xe3, 0xd8, 0x3b, 0x55, 0xac, 0xdf, 0x81, 0xf2, 0x28, 0x3e, 0x15, 0xa2,
+	0x8a, 0xfd, 0x69, 0x7f, 0x1d, 0x16, 0x0c, 0x3c, 0xd1, 0xf0, 0x2d, 0xa8, 0xc7, 0xfe, 0x69, 0x80,
+	0x8a, 0x96, 0x68, 0x3a, 0x05, 0xd8, 0x4f, 0x61, 0xf1, 0x7b, 0x34, 0xf2, 0x4f, 0x2e, 0xdf, 0xd4,
+	0xbc, 0xd9, 0x4e, 0x29, 0xdb, 0xce, 0x16, 0x5c, 0xcf, 0xb4, 0x23, 0xba, 0xe7, 0xe4, 0x2b, 0x76,
+	0xb2, 0xe6, 0xf0, 0x82, 0x26, 0xfb, 0x4a, 0xba, 0xec, 0xb3, 0x5f, 0x00, 0xd9, 0x08, 0x83, 0x80,
+	0xf6, 0x93, 0x03, 0x4a, 0xa3, 0xd4, 0x73, 0x95, 0xd2, 0x6a, 0x63, 0x75, 0x59, 0xac, 0x6c, 0x56,
+	0xa0, 0x0a, 0x22, 0x26, 0x50, 0x19, 0xd3, 0x68, 0x84, 0x0d, 0xd7, 0x1c, 0xfc, 0xdb, 0xbe, 0x0e,
+	0x0b, 0x46, 0xb3, 0xc2, 0xd6, 0xff, 0x10, 0xae, 0x6f, 0xfa, 0x71, 0x3f, 0xdf, 0x61, 0x17, 0x66,
+	0xc7, 0x93, 0x63, 0x37, 0xe5, 0x44, 0x59, 0x64, 0xe6, 0x5f, 0xf6, 0x13, 0xd1, 0xd8, 0x5f, 0xb7,
+	0xa0, 0xb2, 0x7d, 0xb4, 0xbb, 0xc1, 0xce, 0x0a, 0x3f, 0xe8, 0x87, 0x23, 0xa6, 0x85, 0xf1, 0x49,
+	0xab, 0xf2, 0x54, 0x0e, 0xbb, 0x05, 0x75, 0x54, 0xde, 0x98, 0xc5, 0x2b, 0xf4, 0xa0, 0x14, 0xc0,
+	0xac, 0x6d, 0xfa, 0x7a, 0xec, 0x47, 0x68, 0x4e, 0x4b, 0x23, 0xb9, 0x82, 0xc7, 0x4c, 0xbe, 0xc2,
+	0xfe, 0xb7, 0xb3, 0x30, 0x2b, 0x0e, 0x5f, 0x7e, 0x90, 0x27, 0xfe, 0x39, 0x4d, 0x0f, 0x72, 0x56,
+	0x62, 0x8a, 0x71, 0x44, 0x47, 0x61, 0xa2, 0xf4, 0x37, 0xbe, 0x0d, 0x26, 0x10, 0xbd, 0x09, 0x42,
+	0x89, 0xe0, 0xfe, 0x87, 0x32, 0xc7, 0x32, 0x80, 0xe4, 0x16, 0xcc, 0x4a, 0x65, 0xa0, 0xa2, 0x0c,
+	0x1d, 0x09, 0x62, 0xab, 0xd1, 0xf7, 0xc6, 0x5e, 0xdf, 0x4f, 0x2e, 0x85, 0x58, 0x50, 0x65, 0xd6,
+	0xfe, 0x30, 0xec, 0x7b, 0x43, 0xf7, 0xd8, 0x1b, 0x7a, 0x41, 0x9f, 0x4a, 0x6f, 0x85, 0x01, 0x64,
+	0x96, 0xbb, 0x18, 0x96, 0x44, 0xe3, 0xd6, 0x7d, 0x06, 0xca, 0xce, 0xf0, 0x7e, 0x38, 0x1a, 0xf9,
+	0xcc, 0xfa, 0xe0, 0xaa, 0x59, 0xd9, 0xd1, 0x20, 0xdc, 0x37, 0x82, 0xa5, 0x0b, 0xbe, 0x82, 0x75,
+	0xe9, 0x1b, 0xd1, 0x80, 0xac, 0x95, 0x8c, 0x86, 0x56, 0x76, 0x34, 0x08, 0xdb, 0x8b, 0x49, 0x10,
+	0xd3, 0x24, 0x19, 0xd2, 0x81, 0x1a, 0x50, 0x03, 0xd1, 0xf2, 0x15, 0xe4, 0x11, 0x2c, 0x70, 0x1f,
+	0x44, 0xec, 0x25, 0x61, 0x7c, 0xe6, 0xc7, 0x6e, 0xcc, 0xcc, 0x27, 0x6e, 0x0b, 0x17, 0x55, 0x91,
+	0xc7, 0xb0, 0x9c, 0x01, 0x47, 0xb4, 0x4f, 0xfd, 0x73, 0x3a, 0x40, 0x15, 0xae, 0xec, 0x4c, 0xab,
+	0x26, 0x77, 0xa1, 0x11, 0x4c, 0x46, 0xee, 0x64, 0x3c, 0xf0, 0x98, 0x12, 0xd3, 0x46, 0xe5, 0x52,
+	0x07, 0x91, 0x0f, 0x41, 0xea, 0x69, 0x42, 0x7b, 0x9c, 0x33, 0x24, 0x1c, 0xa3, 0x5e, 0xc7, 0xc4,
+	0x60, 0x84, 0x99, 0xaa, 0xa4, 0x1d, 0x61, 0x77, 0x4a, 0x00, 0xf2, 0x49, 0xe4, 0x9f, 0x7b, 0x09,
+	0xed, 0xce, 0x73, 0xa1, 0x2e, 0x8a, 0xec, 0x3b, 0x3f, 0xf0, 0x13, 0xdf, 0x4b, 0xc2, 0xa8, 0x4b,
+	0xb0, 0x2e, 0x05, 0xb0, 0x45, 0x44, 0xfa, 0x88, 0x13, 0x2f, 0x99, 0xc4, 0x42, 0x43, 0x5d, 0x40,
+	0xe2, 0xca, 0x57, 0x90, 0x8f, 0x60, 0x89, 0x53, 0x04, 0x56, 0x09, 0xdd, 0x1b, 0x55, 0x85, 0x45,
+	0x5c, 0x91, 0x29, 0xb5, 0x6c, 0x29, 0x05, 0x89, 0xe4, 0x3e, 0xbc, 0xce, 0x97, 0x72, 0x4a, 0x35,
+	0x1b, 0x1f, 0x1b, 0x81, 0xdf, 0x77, 0x05, 0x06, 0x63, 0x91, 0x25, 0x9c, 0x45, 0xbe, 0x82, 0x91,
+	0xf8, 0xd0, 0x3f, 0xa1, 0x89, 0x3f, 0xa2, 0xdd, 0x65, 0x4e, 0xe2, 0xb2, 0xcc, 0x18, 0x70, 0x32,
+	0xc6, 0x9a, 0x2e, 0x67, 0x78, 0x5e, 0x42, 0x62, 0x1c, 0x86, 0x31, 0x95, 0x9e, 0xa7, 0xee, 0x0d,
+	0xc1, 0x5a, 0x3a, 0xd0, 0xfe, 0x23, 0x8b, 0x1f, 0x51, 0x82, 0x9d, 0x63, 0xcd, 0xf8, 0xe2, 0x8c,
+	0xec, 0x86, 0xc1, 0xf0, 0x52, 0xf0, 0x36, 0x70, 0xd0, 0x7e, 0x30, 0xbc, 0x64, 0xea, 0xbf, 0x1f,
+	0xe8, 0x28, 0x5c, 0x1a, 0x36, 0x25, 0x10, 0x91, 0xde, 0x81, 0xc6, 0x78, 0x72, 0x3c, 0xf4, 0xfb,
+	0x1c, 0xa5, 0xcc, 0x5b, 0xe1, 0x20, 0x44, 0x60, 0xd6, 0x27, 0xdf, 0x4f, 0x8e, 0x51, 0x41, 0x8c,
+	0x86, 0x80, 0x31, 0x14, 0x7b, 0x1d, 0x16, 0xcd, 0x01, 0x0a, 0xb1, 0xff, 0x00, 0x6a, 0x42, 0x4a,
+	0x48, 0x37, 0x44, 0x5b, 0x73, 0x0e, 0x33, 0x63, 0x49, 0xd5, 0xdb, 0x3f, 0x9f, 0x81, 0x05, 0x01,
+	0xdd, 0x60, 0xd3, 0x3f, 0x9c, 0x8c, 0x46, 0x5e, 0x54, 0x20, 0x7e, 0xac, 0x37, 0x88, 0x9f, 0x52,
+	0x5e, 0xfc, 0xdc, 0x31, 0xac, 0x50, 0x2e, 0xbf, 0x34, 0x08, 0xb9, 0x0f, 0x73, 0x6c, 0xc9, 0xb9,
+	0x51, 0xa0, 0xfb, 0x27, 0xb3, 0xe0, 0xbc, 0xc8, 0xac, 0x16, 0x89, 0x4c, 0x5d, 0xdc, 0xcd, 0x64,
+	0xc4, 0x9d, 0x0d, 0x4d, 0xbe, 0xbd, 0x42, 0x82, 0xcf, 0x0a, 0x93, 0x4c, 0x83, 0xb1, 0xf1, 0x64,
+	0x85, 0x0b, 0x97, 0x64, 0x73, 0x45, 0xa2, 0xc5, 0x1f, 0x51, 0x3c, 0x21, 0x34, 0xec, 0xba, 0x10,
+	0x2d, 0xf9, 0x2a, 0xf2, 0x14, 0x80, 0xf7, 0x85, 0x6a, 0x0a, 0xa0, 0x9a, 0xf2, 0x9e, 0xb9, 0x2b,
+	0xfa, 0xfa, 0xaf, 0xb0, 0xc2, 0x24, 0xa2, 0xa8, 0xba, 0x68, 0x5f, 0x92, 0x5d, 0x68, 0x87, 0x63,
+	0x1a, 0xb8, 0x29, 0x83, 0x37, 0xb0, 0xad, 0x7b, 0x57, 0xb4, 0xb5, 0x23, 0x71, 0x9d, 0xcc, 0xb7,
+	0x64, 0x8f, 0xef, 0x00, 0xd5, 0x9a, 0x6b, 0x7e, 0x81, 0xe6, 0xb2, 0x1f, 0xdb, 0x7f, 0xd3, 0x82,
+	0x86, 0x36, 0x72, 0x72, 0x1d, 0xe6, 0x37, 0xf6, 0xf7, 0x0f, 0xb6, 0x9c, 0xb5, 0xa3, 0x9d, 0xef,
+	0x6d, 0xb9, 0x1b, 0xbb, 0xfb, 0x87, 0x5b, 0x9d, 0x6b, 0x0c, 0xbc, 0xbb, 0xbf, 0xb1, 0xb6, 0xeb,
+	0x3e, 0xdd, 0x77, 0x36, 0x24, 0xd8, 0x22, 0x4b, 0x40, 0x9c, 0xad, 0xe7, 0xfb, 0x47, 0x5b, 0x06,
+	0xbc, 0x44, 0x3a, 0xd0, 0x5c, 0x77, 0xb6, 0xd6, 0x36, 0xb6, 0x05, 0xa4, 0x4c, 0x16, 0xa1, 0xf3,
+	0xf4, 0xc5, 0xde, 0xe6, 0xce, 0xde, 0x33, 0x77, 0x63, 0x6d, 0x6f, 0x63, 0x6b, 0x77, 0x6b, 0xb3,
+	0x53, 0x21, 0x2d, 0xa8, 0xaf, 0xad, 0xaf, 0xed, 0x6d, 0xee, 0xef, 0x6d, 0x6d, 0x76, 0xaa, 0xf6,
+	0xb7, 0xa0, 0xae, 0x86, 0x4a, 0x1a, 0x30, 0xfb, 0x62, 0xef, 0xd3, 0xbd, 0xfd, 0x97, 0x7b, 0x9d,
+	0x6b, 0xa4, 0x0e, 0x55, 0xec, 0xbf, 0x63, 0x11, 0x80, 0x19, 0xde, 0x67, 0xa7, 0x44, 0x6a, 0x50,
+	0x59, 0xdf, 0x3f, 0xda, 0xee, 0x94, 0xed, 0xff, 0x6a, 0xc1, 0x75, 0x9c, 0xf3, 0x20, 0xcb, 0xfd,
+	0x77, 0xa1, 0xd1, 0x0f, 0xc3, 0x31, 0xb3, 0x7b, 0xd2, 0x93, 0x5d, 0x07, 0x31, 0xce, 0xe6, 0x32,
+	0xf1, 0x24, 0x8c, 0xfa, 0x54, 0x30, 0x3f, 0x20, 0xe8, 0x29, 0x83, 0x30, 0xce, 0x16, 0x74, 0xcb,
+	0x31, 0x38, 0xef, 0x37, 0x38, 0x8c, 0xa3, 0x2c, 0xc1, 0xcc, 0x71, 0x44, 0xbd, 0xfe, 0x99, 0x60,
+	0x7b, 0x51, 0x22, 0x5f, 0x49, 0x0d, 0xf3, 0x3e, 0x23, 0xab, 0x21, 0x1d, 0x20, 0x2b, 0xd4, 0x9c,
+	0x39, 0x01, 0xdf, 0x10, 0x60, 0x76, 0x08, 0x78, 0xc7, 0x5e, 0x30, 0x08, 0x03, 0x3a, 0x10, 0x5a,
+	0x7f, 0x0a, 0xb0, 0x0f, 0x60, 0x29, 0x3b, 0x3f, 0x21, 0x3c, 0x3e, 0xd2, 0x84, 0x07, 0x57, 0xc2,
+	0x7b, 0xd3, 0x69, 0x41, 0x13, 0x24, 0x7f, 0x5e, 0x86, 0x0a, 0xd3, 0xc9, 0xa6, 0xeb, 0x6f, 0xba,
+	0x9a, 0x5d, 0xce, 0x45, 0x69, 0xd0, 0xd6, 0xe7, 0x27, 0xb4, 0xf0, 0x33, 0xa5, 0x90, 0xb4, 0x3e,
+	0xa2, 0xfd, 0x73, 0xe1, 0x69, 0xd2, 0x20, 0x8c, 0xf3, 0x99, 0x0d, 0x84, 0x5f, 0x0b, 0xce, 0x97,
+	0x65, 0x59, 0x87, 0x5f, 0xce, 0xa6, 0x75, 0xf8, 0x5d, 0x17, 0x66, 0xfd, 0xe0, 0x38, 0x9c, 0x04,
+	0x03, 0xe4, 0xf4, 0x9a, 0x23, 0x8b, 0x18, 0x17, 0x42, 0x09, 0xc4, 0x8e, 0x0f, 0xce, 0xd7, 0x29,
+	0x80, 0xac, 0x42, 0x3d, 0xbe, 0x0c, 0xfa, 0x3a, 0x33, 0x2f, 0x8a, 0x55, 0x62, 0x6b, 0xb0, 0x72,
+	0x78, 0x19, 0xf4, 0x91, 0x75, 0x53, 0x34, 0xf2, 0x4d, 0xa8, 0x29, 0xcf, 0x2c, 0x97, 0xca, 0x37,
+	0xf4, 0x4f, 0xa4, 0x3b, 0x96, 0x1b, 0xbc, 0x0a, 0xb5, 0xf7, 0x29, 0xb4, 0x8c, 0x2a, 0xdd, 0x4a,
+	0x6d, 0x71, 0x2b, 0xf5, 0x9e, 0x6e, 0xa5, 0xa6, 0xc2, 0x5e, 0x7c, 0xa6, 0x5b, 0xad, 0xbf, 0x07,
+	0x35, 0x39, 0x34, 0xc6, 0x55, 0x82, 0x23, 0xdc, 0xc3, 0xef, 0xef, 0x6d, 0x74, 0xae, 0x91, 0x39,
+	0x68, 0xac, 0x6d, 0x20, 0xa3, 0x22, 0xc0, 0x62, 0x28, 0x07, 0x6b, 0x87, 0x87, 0x0a, 0x52, 0xb2,
+	0x09, 0x74, 0xd8, 0x91, 0xc3, 0x46, 0xac, 0x62, 0x2f, 0x1f, 0xc1, 0xbc, 0x06, 0x4b, 0x0d, 0xb9,
+	0x31, 0x03, 0x64, 0x0c, 0x39, 0xd4, 0xda, 0x79, 0x8d, 0xbd, 0x0c, 0xd7, 0x59, 0x71, 0xeb, 0x9c,
+	0x06, 0xc9, 0xe1, 0xe4, 0x98, 0x87, 0xdc, 0xfc, 0x30, 0xb0, 0xff, 0x9a, 0x05, 0x75, 0x55, 0x73,
+	0x05, 0x3d, 0xc9, 0x28, 0x61, 0x09, 0x37, 0xa0, 0xa7, 0x75, 0x81, 0x5f, 0xae, 0xe0, 0xbf, 0x86,
+	0xf1, 0x57, 0x57, 0x20, 0x36, 0xd9, 0x83, 0xad, 0x2d, 0xc7, 0xdd, 0xdf, 0xdb, 0xdd, 0xd9, 0x63,
+	0x42, 0x89, 0x4d, 0x16, 0x01, 0x4f, 0x9f, 0x22, 0xc4, 0xb2, 0x3b, 0xd0, 0x7e, 0x46, 0x93, 0x9d,
+	0xe0, 0x24, 0x94, 0x53, 0xfd, 0x3f, 0x55, 0x98, 0x53, 0xa0, 0xd4, 0x78, 0x3c, 0xa7, 0x51, 0xec,
+	0x87, 0x01, 0xaa, 0x7d, 0x75, 0x47, 0x16, 0xd9, 0x79, 0xe2, 0x0f, 0x68, 0x90, 0xf8, 0xc9, 0xa5,
+	0x6b, 0x78, 0x9b, 0xb2, 0x60, 0x66, 0xa8, 0x79, 0x43, 0xdf, 0x93, 0xd1, 0x4b, 0x5e, 0x60, 0xd0,
+	0x7e, 0x38, 0x0c, 0x23, 0xd4, 0xef, 0xea, 0x0e, 0x2f, 0x90, 0x55, 0x58, 0x64, 0x7a, 0xa5, 0xee,
+	0x0b, 0x44, 0x66, 0xe5, 0xae, 0xaf, 0xc2, 0x3a, 0x76, 0x5e, 0x31, 0xb8, 0x50, 0x4a, 0xd4, 0x27,
+	0xdc, 0x8c, 0x29, 0xaa, 0x22, 0xdf, 0x80, 0xeb, 0x0c, 0xac, 0x14, 0x19, 0xf5, 0xcd, 0x1c, 0x7e,
+	0x53, 0x5c, 0xc9, 0xb8, 0x86, 0xf7, 0xcf, 0x76, 0xbe, 0xca, 0x35, 0x56, 0x05, 0xc8, 0x85, 0x1a,
+	0x67, 0xf8, 0x19, 0x9c, 0x0d, 0x35, 0x6a, 0xe1, 0xca, 0x5a, 0x2e, 0x5c, 0xf9, 0x0d, 0xb8, 0x7e,
+	0x4c, 0xe3, 0xc4, 0x3d, 0xa3, 0xde, 0x80, 0x46, 0xc8, 0x8d, 0x3c, 0x2a, 0xc9, 0x15, 0xf4, 0xe2,
+	0x4a, 0x3c, 0xd9, 0x2f, 0x83, 0x3e, 0x1d, 0xb8, 0x49, 0xe8, 0xa2, 0x06, 0x82, 0x3c, 0x5d, 0x73,
+	0xb2, 0x60, 0x13, 0xf3, 0x34, 0xf2, 0xc6, 0x67, 0x42, 0x83, 0xce, 0x82, 0x99, 0xee, 0x93, 0xd0,
+	0x38, 0x09, 0x28, 0x8f, 0x09, 0xd5, 0xd0, 0xdf, 0x2f, 0x41, 0xe4, 0x1e, 0xcc, 0x60, 0x83, 0x71,
+	0xb7, 0x83, 0x0c, 0xd0, 0x4c, 0x85, 0xa8, 0x1f, 0x38, 0xa2, 0x8e, 0xd9, 0xcb, 0x93, 0xc8, 0x8f,
+	0xbb, 0x4d, 0x0c, 0x87, 0xe2, 0xdf, 0xe4, 0x3b, 0x9a, 0x9c, 0x58, 0xc0, 0x6f, 0xe5, 0x61, 0x9c,
+	0xa1, 0xbc, 0xdf, 0x8a, 0xc8, 0xf8, 0xa4, 0x52, 0x6b, 0x74, 0x9a, 0xf6, 0xef, 0x40, 0x15, 0x47,
+	0x8e, 0x34, 0x89, 0xeb, 0x67, 0x09, 0x9a, 0x44, 0x68, 0x17, 0x66, 0x03, 0x9a, 0x5c, 0x84, 0xd1,
+	0x2b, 0x19, 0x7f, 0x17, 0x45, 0xfb, 0x27, 0xe8, 0x54, 0x50, 0xf1, 0xe8, 0x17, 0x68, 0x0d, 0x91,
+	0x9b, 0x50, 0xe7, 0x7b, 0x1a, 0x9f, 0x79, 0xc2, 0xcf, 0x51, 0x43, 0xc0, 0xe1, 0x99, 0xc7, 0xce,
+	0x47, 0x83, 0x4c, 0xb8, 0xeb, 0xa8, 0x81, 0xb0, 0x6d, 0x4e, 0x25, 0xf7, 0xa0, 0x2d, 0x23, 0xdd,
+	0xb1, 0x3b, 0xa4, 0x27, 0x89, 0x74, 0xfc, 0x06, 0x93, 0x11, 0xfa, 0x97, 0x76, 0xe9, 0x49, 0x62,
+	0xef, 0xc1, 0xbc, 0x38, 0xb3, 0xf6, 0xc7, 0x54, 0x76, 0xfd, 0xad, 0x22, 0xc5, 0xb6, 0xb1, 0xba,
+	0x60, 0x1e, 0x72, 0x3c, 0xb6, 0x6f, 0x62, 0xda, 0x0e, 0x10, 0xfd, 0x0c, 0x14, 0x0d, 0x0a, 0xcd,
+	0x52, 0xba, 0xb6, 0xc5, 0x74, 0x0c, 0x18, 0x5b, 0x9f, 0x78, 0xd2, 0xef, 0xcb, 0xfb, 0x09, 0x35,
+	0x47, 0x16, 0xed, 0xff, 0x68, 0xc1, 0x02, 0xb6, 0x26, 0x55, 0x73, 0xa1, 0x67, 0x3c, 0xfe, 0x02,
+	0xc3, 0x94, 0x81, 0x05, 0xee, 0x4e, 0x5f, 0x84, 0xaa, 0xae, 0x79, 0xf0, 0xc2, 0x17, 0x77, 0x23,
+	0x56, 0x72, 0x6e, 0xc4, 0x07, 0xd0, 0x19, 0xd0, 0xa1, 0x8f, 0x77, 0x54, 0xe4, 0x39, 0xce, 0xf5,
+	0xf0, 0x1c, 0xdc, 0xfe, 0x3b, 0x16, 0xcc, 0x73, 0x45, 0x01, 0x8d, 0x49, 0xb1, 0x54, 0xff, 0x9f,
+	0x34, 0xbc, 0x84, 0x80, 0x12, 0x93, 0x4a, 0x8f, 0x4e, 0x84, 0x72, 0xe4, 0xed, 0x6b, 0x8e, 0x89,
+	0x4c, 0x9e, 0xa0, 0x39, 0x11, 0xb8, 0x08, 0x2d, 0xb8, 0xf5, 0x62, 0xee, 0xcb, 0xf6, 0x35, 0x47,
+	0x43, 0x5f, 0xaf, 0x31, 0x5b, 0x90, 0xc1, 0xed, 0x67, 0xd0, 0x32, 0x3a, 0x32, 0xdc, 0x9d, 0x4d,
+	0xee, 0xee, 0xcc, 0xc5, 0x15, 0x4a, 0x05, 0x71, 0x85, 0x9f, 0x57, 0x80, 0x30, 0xc2, 0xca, 0xec,
+	0xdc, 0x5d, 0x33, 0x38, 0x27, 0x2f, 0xc0, 0xa4, 0x20, 0xb2, 0x0a, 0x44, 0x2b, 0xca, 0xa0, 0x61,
+	0x59, 0x05, 0x0d, 0x0b, 0x6a, 0x99, 0xd4, 0x17, 0x5a, 0xa5, 0x0a, 0xc8, 0xa1, 0x2b, 0x8b, 0x6f,
+	0x53, 0x61, 0x1d, 0xd3, 0x7c, 0x30, 0x3a, 0xc7, 0x8c, 0x6e, 0xe1, 0xfe, 0x91, 0xe5, 0x2c, 0x3d,
+	0xcc, 0xbc, 0x91, 0x1e, 0x66, 0x73, 0xf4, 0xa0, 0x39, 0x20, 0x6a, 0xa6, 0x03, 0xe2, 0x1e, 0xb4,
+	0x64, 0x10, 0x8e, 0xdf, 0x3f, 0x10, 0xde, 0x1e, 0x03, 0xc8, 0xe8, 0x49, 0xfa, 0x00, 0x94, 0x97,
+	0x83, 0x47, 0xd7, 0x73, 0x70, 0x76, 0xb0, 0xa4, 0x8e, 0xe6, 0x06, 0x0e, 0x36, 0x05, 0xa0, 0xcb,
+	0x80, 0x51, 0x89, 0x3b, 0x09, 0xc4, 0xe5, 0x17, 0x3a, 0x40, 0x43, 0xa6, 0xe6, 0xe4, 0x2b, 0xf2,
+	0xe6, 0x7f, 0xab, 0xc0, 0xfc, 0x27, 0x1f, 0xa5, 0x11, 0xab, 0xf8, 0xcc, 0x1f, 0xe1, 0xd9, 0x9e,
+	0xde, 0x1d, 0x79, 0xca, 0xab, 0x0e, 0xcf, 0xfc, 0x91, 0x63, 0xe0, 0xd9, 0xbf, 0xb4, 0xa0, 0xc3,
+	0xa8, 0xc2, 0x20, 0xfc, 0x8f, 0x01, 0x79, 0xf4, 0x2d, 0xe9, 0xde, 0xc0, 0x25, 0x8f, 0xa1, 0x8e,
+	0x65, 0x66, 0xba, 0x09, 0xaa, 0xef, 0x9a, 0x54, 0x9f, 0x4a, 0xb7, 0xed, 0x6b, 0x4e, 0x8a, 0xcc,
+	0xce, 0xb2, 0x6c, 0xc4, 0x90, 0x87, 0xbf, 0xb3, 0x60, 0x8d, 0x3b, 0xb6, 0x01, 0x3e, 0xa5, 0x97,
+	0xbb, 0x61, 0x1f, 0xad, 0xa6, 0xdb, 0x00, 0x8c, 0x06, 0x4f, 0xbc, 0x91, 0x2f, 0x5c, 0x1d, 0x55,
+	0xa7, 0xfe, 0x8a, 0x5e, 0x3e, 0x45, 0x00, 0x13, 0xe3, 0xac, 0x3a, 0x65, 0x91, 0xaa, 0x53, 0x7b,
+	0x45, 0x2f, 0x77, 0x90, 0x3d, 0x5c, 0x68, 0x7d, 0x4a, 0x2f, 0x37, 0x29, 0xd7, 0xeb, 0xc2, 0x88,
+	0xd8, 0xd0, 0x8a, 0xbc, 0x0b, 0xa6, 0xb9, 0x19, 0xa1, 0xbe, 0x46, 0xe4, 0x5d, 0x7c, 0x4a, 0x2f,
+	0xd7, 0x31, 0xd6, 0xf7, 0x00, 0x66, 0x59, 0xfd, 0x30, 0xec, 0x8b, 0x93, 0x49, 0xde, 0x5e, 0x48,
+	0x07, 0xe5, 0xcc, 0xbc, 0xc2, 0xbf, 0xed, 0x7f, 0x6f, 0x41, 0x8b, 0xad, 0x00, 0x8a, 0x3d, 0xb6,
+	0x13, 0xf2, 0x12, 0x8c, 0x95, 0x5e, 0x82, 0x59, 0x15, 0x32, 0x83, 0xcb, 0xd0, 0xd2, 0x74, 0x19,
+	0x8a, 0xcb, 0xc6, 0x05, 0xe8, 0x87, 0x50, 0xe7, 0xec, 0xc4, 0xd8, 0xb7, 0x6c, 0xec, 0x94, 0x31,
+	0x21, 0xa7, 0x86, 0x68, 0x9f, 0xf2, 0x78, 0xbb, 0xe6, 0xac, 0xe2, 0x8b, 0x5c, 0xe7, 0x10, 0x56,
+	0x5d, 0x10, 0xba, 0xad, 0x16, 0x85, 0x6e, 0x5f, 0x40, 0x43, 0x23, 0x2c, 0xf2, 0x6d, 0x1e, 0xf4,
+	0xe6, 0x83, 0xe7, 0x54, 0x68, 0x12, 0x8e, 0x31, 0x7b, 0x14, 0x98, 0x3a, 0x60, 0x7d, 0x06, 0x2a,
+	0x48, 0x92, 0x4f, 0x60, 0x5e, 0x6b, 0x96, 0x5b, 0x88, 0x45, 0x63, 0xb2, 0x8a, 0xc6, 0xf4, 0x87,
+	0x16, 0x2c, 0x8a, 0xaf, 0xf1, 0xc2, 0x94, 0xcf, 0x8e, 0xf1, 0xe7, 0xf1, 0x29, 0x3b, 0x48, 0x59,
+	0xeb, 0x6e, 0x44, 0x4f, 0xfd, 0x38, 0xa1, 0x32, 0x42, 0x50, 0xc0, 0x21, 0x8c, 0xa4, 0x19, 0xaa,
+	0x23, 0x30, 0xc9, 0x13, 0x68, 0xe0, 0xa7, 0xdc, 0x86, 0x15, 0xdb, 0xd2, 0xcd, 0x7f, 0xc8, 0x87,
+	0xca, 0x24, 0x79, 0xac, 0x4a, 0xeb, 0x75, 0x98, 0x4d, 0x22, 0xff, 0xf4, 0x94, 0x46, 0xf6, 0x92,
+	0x1a, 0x1a, 0xe3, 0x36, 0x7a, 0x98, 0xd0, 0x31, 0x53, 0x8e, 0x18, 0x65, 0x34, 0x04, 0x53, 0xfd,
+	0xca, 0x51, 0x81, 0x9e, 0x76, 0xf5, 0x8f, 0x5b, 0xab, 0xe9, 0x4d, 0xbf, 0xfb, 0x30, 0x37, 0x62,
+	0x8a, 0x12, 0xd3, 0xe0, 0x8d, 0x88, 0x40, 0x16, 0xcc, 0x14, 0x6f, 0xd4, 0x5b, 0x62, 0x37, 0xf1,
+	0x87, 0xae, 0xac, 0x15, 0x97, 0xec, 0x8a, 0xaa, 0xd8, 0xf1, 0x1d, 0x27, 0xde, 0x29, 0x15, 0xda,
+	0x31, 0x2f, 0xd8, 0x5d, 0x58, 0x3a, 0x48, 0xb7, 0x45, 0x73, 0x48, 0xd8, 0xff, 0xbc, 0x05, 0xcb,
+	0xb9, 0x2a, 0x75, 0x25, 0x58, 0xb8, 0xb9, 0x87, 0xfe, 0xe8, 0x38, 0x54, 0x6e, 0x2a, 0x4b, 0xf7,
+	0x80, 0x1b, 0x55, 0xe4, 0x14, 0xae, 0x4b, 0xaa, 0x40, 0x57, 0x91, 0x52, 0xfb, 0x4b, 0xa8, 0x89,
+	0x7e, 0x68, 0x4a, 0xac, 0x6c, 0x87, 0x12, 0xae, 0x9f, 0x8a, 0xc5, 0xed, 0x91, 0x33, 0xe8, 0x2a,
+	0xf2, 0x13, 0x9a, 0x92, 0x66, 0xc9, 0xb0, 0xbe, 0x3e, 0x78, 0x43, 0x5f, 0x86, 0xff, 0xc2, 0x99,
+	0xda, 0x1a, 0xb9, 0x84, 0x3b, 0xb2, 0x0e, 0x55, 0xa1, 0x7c, 0x7f, 0x95, 0xb7, 0x9a, 0x1b, 0x7a,
+	0x66, 0xcc, 0x4e, 0xdf, 0xd0, 0x30, 0xf9, 0x31, 0x2c, 0x5d, 0x78, 0x7e, 0x22, 0x87, 0xa5, 0x59,
+	0x51, 0x55, 0xec, 0x72, 0xf5, 0x0d, 0x5d, 0xbe, 0xe4, 0x1f, 0x1b, 0xfa, 0xe1, 0x94, 0x16, 0x7b,
+	0xbf, 0x2c, 0x41, 0xdb, 0x6c, 0x87, 0x91, 0xa9, 0x90, 0x4a, 0x52, 0xa1, 0x90, 0xf6, 0x67, 0x06,
+	0x9c, 0xf7, 0xf6, 0x96, 0x8a, 0xbc, 0xbd, 0xba, 0x7f, 0xb5, 0xfc, 0xa6, 0x70, 0x52, 0xe5, 0xed,
+	0xc2, 0x49, 0xd5, 0xc2, 0x70, 0xd2, 0xf4, 0xa8, 0xc3, 0xcc, 0xaf, 0x1a, 0x75, 0x98, 0xbd, 0x32,
+	0xea, 0xd0, 0xfb, 0xdf, 0x16, 0x90, 0x3c, 0xf5, 0x92, 0x67, 0xdc, 0xc1, 0x1d, 0xd0, 0xa1, 0x10,
+	0x6f, 0x5f, 0x7b, 0x3b, 0x0e, 0x90, 0xbb, 0x25, 0xbf, 0x66, 0xac, 0xa8, 0xdf, 0xcb, 0xd5, 0x6d,
+	0x9b, 0x96, 0x53, 0x54, 0x95, 0x09, 0xa9, 0x55, 0xde, 0x1c, 0x52, 0xab, 0xbe, 0x39, 0xa4, 0x36,
+	0x93, 0x0d, 0xa9, 0xf5, 0xfe, 0xaa, 0x05, 0x0b, 0x05, 0x64, 0xf6, 0x9b, 0x9b, 0x38, 0x23, 0x0c,
+	0x43, 0xfa, 0x94, 0x04, 0x61, 0xe8, 0xc0, 0xde, 0x5f, 0x82, 0x96, 0xc1, 0x5a, 0xbf, 0xb9, 0xfe,
+	0xb3, 0xe6, 0x19, 0xa7, 0x6c, 0x03, 0xd6, 0xfb, 0x1f, 0x25, 0x20, 0x79, 0xf6, 0xfe, 0xad, 0x8e,
+	0x21, 0xbf, 0x4e, 0xe5, 0x82, 0x75, 0xfa, 0x7f, 0x7a, 0xf2, 0x7c, 0x00, 0xf3, 0x22, 0xd9, 0x40,
+	0x0b, 0x69, 0x70, 0x8a, 0xc9, 0x57, 0x30, 0x03, 0xd5, 0x8c, 0x67, 0xd6, 0x8c, 0xcb, 0xd5, 0xda,
+	0xf1, 0x9b, 0x09, 0x6b, 0xda, 0x3d, 0xe8, 0x8a, 0x15, 0xca, 0xbb, 0xfe, 0xfe, 0x5e, 0x45, 0xd9,
+	0xd8, 0x58, 0x29, 0xf4, 0xe7, 0x6f, 0x40, 0x53, 0x3f, 0x3e, 0xc4, 0x76, 0x64, 0xa2, 0x5a, 0x4c,
+	0xcd, 0xd0, 0xb1, 0xc8, 0x26, 0xb4, 0x51, 0x48, 0x0e, 0xd4, 0x77, 0x5c, 0xd3, 0xb8, 0xc2, 0xa1,
+	0xbd, 0x7d, 0xcd, 0xc9, 0x7c, 0x43, 0x7e, 0x17, 0xda, 0xa6, 0x9b, 0x4b, 0xe8, 0x84, 0x45, 0x6a,
+	0x24, 0xfb, 0xdc, 0x44, 0x26, 0x6b, 0xd0, 0xc9, 0xfa, 0xc9, 0xc4, 0xcd, 0xcf, 0x29, 0x0d, 0xe4,
+	0xd0, 0xc9, 0x27, 0xb0, 0x58, 0x74, 0x88, 0xe2, 0xde, 0x4c, 0xb7, 0x22, 0x0a, 0xbf, 0x21, 0x8f,
+	0x85, 0xcf, 0xb4, 0x5a, 0x14, 0xe6, 0xd1, 0x96, 0x7c, 0x85, 0xff, 0xa7, 0x79, 0x4f, 0xcf, 0x01,
+	0x52, 0x18, 0xe9, 0x40, 0x73, 0xff, 0x60, 0x6b, 0xcf, 0xdd, 0xd8, 0x5e, 0xdb, 0xdb, 0xdb, 0xda,
+	0xed, 0x5c, 0x23, 0x04, 0xda, 0x18, 0x9e, 0xd9, 0x54, 0x30, 0x8b, 0xc1, 0x84, 0x47, 0x59, 0xc2,
+	0x4a, 0x64, 0x11, 0x3a, 0x3b, 0x7b, 0x19, 0x68, 0x99, 0x74, 0x61, 0xf1, 0x60, 0x8b, 0x47, 0x74,
+	0x8c, 0x76, 0x2b, 0x4c, 0xdf, 0x13, 0x83, 0x67, 0xfa, 0x1e, 0x4f, 0x59, 0x59, 0xe7, 0x44, 0x28,
+	0x75, 0xa0, 0x7f, 0x60, 0xc1, 0xf5, 0x4c, 0x45, 0x7a, 0x09, 0x99, 0xab, 0x39, 0xa6, 0xee, 0x63,
+	0x02, 0x31, 0x24, 0x2e, 0xcd, 0xc3, 0x8c, 0x9c, 0xca, 0x57, 0x30, 0xce, 0xd2, 0xcc, 0xc9, 0x0c,
+	0xbf, 0x16, 0x55, 0xd9, 0xcb, 0xea, 0xae, 0x67, 0x66, 0xe0, 0x27, 0x3c, 0x15, 0x46, 0xaf, 0x48,
+	0xbd, 0xca, 0xe6, 0x90, 0x65, 0x91, 0xac, 0x66, 0xa8, 0xc1, 0x1c, 0x6f, 0x61, 0x9d, 0xfd, 0xcf,
+	0x66, 0x80, 0x7c, 0x77, 0x42, 0xa3, 0x4b, 0xbc, 0x65, 0xac, 0x82, 0x59, 0xcb, 0x59, 0xd7, 0xfa,
+	0xcc, 0x78, 0x72, 0xcc, 0x0c, 0x16, 0x61, 0x48, 0x95, 0xde, 0x2a, 0x9b, 0xa0, 0xe8, 0x36, 0x7f,
+	0xe5, 0xcd, 0xb7, 0xf9, 0xab, 0x6f, 0xba, 0xcd, 0xff, 0x25, 0x68, 0xf9, 0xa7, 0x41, 0xc8, 0x84,
+	0x0e, 0x53, 0x54, 0xe2, 0xee, 0xcc, 0xdd, 0xf2, 0xfd, 0xa6, 0xd3, 0x14, 0xc0, 0x3d, 0x06, 0x23,
+	0x4f, 0x52, 0x24, 0x3a, 0x38, 0xc5, 0xec, 0x13, 0x5d, 0x0c, 0x6d, 0x0d, 0x4e, 0xa9, 0xb0, 0x1b,
+	0xd1, 0xb5, 0x22, 0x3f, 0x66, 0xf0, 0x98, 0xdc, 0x83, 0x76, 0x1c, 0x4e, 0x98, 0xea, 0x26, 0x97,
+	0x81, 0x3b, 0x9c, 0x9b, 0x1c, 0x7a, 0xc0, 0x17, 0x63, 0x05, 0x16, 0x26, 0x31, 0x75, 0x47, 0x7e,
+	0x1c, 0xb3, 0xe3, 0xb9, 0x1f, 0x06, 0x49, 0x14, 0x0e, 0x85, 0x03, 0x79, 0x7e, 0x12, 0xd3, 0xe7,
+	0xbc, 0x66, 0x83, 0x57, 0x90, 0x6f, 0xa4, 0x43, 0x1a, 0x7b, 0x7e, 0x14, 0x77, 0x01, 0x87, 0x24,
+	0x67, 0xca, 0xc6, 0x7d, 0xe0, 0xf9, 0x91, 0x1a, 0x0b, 0x2b, 0xc4, 0x99, 0x2c, 0x83, 0x46, 0x36,
+	0xcb, 0xe0, 0x47, 0xc5, 0x59, 0x06, 0x2d, 0x6c, 0xfa, 0x91, 0x68, 0x3a, 0xbf, 0xc5, 0x5f, 0x28,
+	0xd9, 0x20, 0x9f, 0x3c, 0xd1, 0xfe, 0x22, 0xc9, 0x13, 0x73, 0x45, 0xc9, 0x13, 0x1f, 0x42, 0x03,
+	0xaf, 0xb4, 0xbb, 0x67, 0x7e, 0x90, 0x48, 0x67, 0x78, 0x47, 0xbf, 0xf3, 0xbe, 0xcd, 0xcc, 0x6f,
+	0x88, 0xe4, 0x9f, 0x71, 0x3e, 0x8f, 0x61, 0xfe, 0xb7, 0x98, 0xc7, 0x20, 0xae, 0xde, 0xaf, 0x40,
+	0x4d, 0xee, 0x13, 0x21, 0x50, 0x39, 0x89, 0xc2, 0x91, 0xf4, 0x0f, 0xb2, 0xbf, 0x49, 0x1b, 0x4a,
+	0x49, 0x28, 0x3e, 0x2e, 0x25, 0xa1, 0xfd, 0x07, 0xd0, 0xd0, 0x48, 0x8d, 0xbc, 0xcb, 0xdd, 0x0e,
+	0x4c, 0x75, 0x16, 0x76, 0x35, 0x5f, 0xc5, 0xba, 0x80, 0xee, 0x0c, 0xc8, 0x57, 0x61, 0x7e, 0xe0,
+	0x47, 0x14, 0x33, 0x8e, 0xdc, 0x88, 0x9e, 0xd3, 0x28, 0x96, 0x2e, 0xdb, 0x8e, 0xaa, 0x70, 0x38,
+	0xdc, 0x76, 0x61, 0xc1, 0xd8, 0x5b, 0x25, 0xdd, 0x66, 0x70, 0xdd, 0x64, 0x94, 0xcd, 0xcc, 0x25,
+	0x10, 0x75, 0x4c, 0xfb, 0x10, 0xde, 0x66, 0x77, 0x1c, 0x85, 0xc7, 0xd8, 0x89, 0xe5, 0x18, 0x30,
+	0xfb, 0xbf, 0x97, 0xa1, 0xbc, 0x1d, 0x8e, 0xf5, 0x0b, 0x1d, 0x56, 0xfe, 0x42, 0x87, 0x30, 0x13,
+	0x5c, 0x65, 0x05, 0x08, 0x5d, 0xce, 0x00, 0x92, 0x07, 0xd0, 0x66, 0xa2, 0x22, 0x09, 0x99, 0x59,
+	0x74, 0xe1, 0x45, 0x3c, 0xb9, 0xa0, 0x8c, 0xfc, 0x97, 0xa9, 0x21, 0x8b, 0x50, 0x56, 0xda, 0x2d,
+	0x22, 0xb0, 0x22, 0xb3, 0xc9, 0xf1, 0x6a, 0xdd, 0xa5, 0x88, 0x21, 0x89, 0x12, 0x93, 0xbc, 0xe6,
+	0xf7, 0x5c, 0x1e, 0x71, 0x1d, 0xa5, 0xa8, 0x8a, 0x99, 0x2c, 0x4c, 0xe2, 0x8c, 0x52, 0x0b, 0x40,
+	0x95, 0xf5, 0xc0, 0x62, 0xcd, 0x0c, 0x2c, 0xde, 0x85, 0x46, 0x32, 0x3c, 0x77, 0xc7, 0xde, 0xe5,
+	0x30, 0xf4, 0x06, 0x82, 0xd3, 0x75, 0x10, 0x79, 0x04, 0x30, 0x1a, 0x8f, 0x05, 0x1b, 0xa2, 0xd7,
+	0x32, 0xa5, 0xea, 0xe7, 0x07, 0x07, 0x9c, 0xfa, 0x1c, 0x0d, 0x87, 0x6c, 0x41, 0xbb, 0x30, 0x43,
+	0xe8, 0xb6, 0xbc, 0x00, 0x16, 0x8e, 0x57, 0x0a, 0x18, 0x35, 0xf3, 0x51, 0xef, 0x3b, 0x40, 0x7e,
+	0xcd, 0x44, 0x9d, 0x97, 0x50, 0x57, 0x23, 0xd4, 0xd3, 0x63, 0xf0, 0x96, 0x67, 0xc3, 0x4c, 0x8f,
+	0xc1, 0x4b, 0x9d, 0xef, 0x41, 0x9b, 0x1f, 0x97, 0xea, 0x00, 0xe0, 0x37, 0xf3, 0x32, 0x50, 0xfb,
+	0x2f, 0x2c, 0xa8, 0x22, 0xe5, 0x31, 0x2d, 0x95, 0xd7, 0xa9, 0x9b, 0x30, 0x22, 0xf6, 0x94, 0x05,
+	0x13, 0xdb, 0xc8, 0x1c, 0x2c, 0x29, 0x32, 0xd0, 0xb3, 0x07, 0xef, 0x42, 0x5d, 0xf5, 0xa4, 0x91,
+	0x52, 0x0a, 0x24, 0x77, 0xa0, 0x72, 0x16, 0x8e, 0xa5, 0x21, 0x0f, 0xe9, 0x8a, 0x3a, 0x08, 0x4f,
+	0xc7, 0xc3, 0xda, 0xe3, 0x53, 0xe0, 0xc6, 0x52, 0x16, 0x5c, 0x30, 0xd7, 0x99, 0xc2, 0xb9, 0xbe,
+	0x80, 0x39, 0x26, 0x1f, 0xb4, 0xd8, 0xf0, 0xf4, 0xc3, 0xf4, 0x2b, 0x4c, 0x03, 0xec, 0x0f, 0x27,
+	0x03, 0xaa, 0xbb, 0x53, 0x30, 0xa6, 0x28, 0xe0, 0xd2, 0x90, 0xb0, 0xff, 0x85, 0xc5, 0xe5, 0x0e,
+	0x6b, 0x97, 0xdc, 0x87, 0x0a, 0x3b, 0xf7, 0x32, 0x3e, 0x3f, 0x75, 0xf3, 0x96, 0xe1, 0x39, 0x88,
+	0xc1, 0x76, 0x11, 0xc3, 0x61, 0x7a, 0xeb, 0x3c, 0x18, 0x96, 0xfa, 0x22, 0xd4, 0xcc, 0x32, 0x26,
+	0x7c, 0x06, 0x4a, 0x56, 0xb4, 0xfb, 0x1f, 0x15, 0xe3, 0x2c, 0x95, 0x4a, 0xe2, 0xe0, 0x94, 0x6a,
+	0xf7, 0x3e, 0xfe, 0x65, 0x09, 0x5a, 0xc6, 0x98, 0x18, 0xf7, 0xe0, 0xd1, 0xc0, 0x3d, 0xca, 0x62,
+	0xe7, 0x75, 0x90, 0xce, 0x79, 0x25, 0x93, 0xf3, 0x54, 0x20, 0xbc, 0xac, 0x07, 0xc2, 0x1f, 0x41,
+	0x3d, 0x4d, 0x1d, 0x35, 0x07, 0xc5, 0x7a, 0x94, 0x77, 0x90, 0x53, 0xa4, 0x34, 0x74, 0x5e, 0xd5,
+	0x43, 0xe7, 0xdf, 0xd6, 0x42, 0xab, 0x33, 0xd8, 0x8c, 0x5d, 0xb4, 0xaa, 0xbf, 0x9d, 0xbb, 0x18,
+	0x4f, 0xa0, 0xa1, 0x0d, 0x5e, 0x0f, 0xa1, 0x5a, 0x46, 0x08, 0x55, 0x65, 0x0b, 0x94, 0xd2, 0x6c,
+	0x01, 0xfb, 0x67, 0x25, 0x68, 0x31, 0x5e, 0xf3, 0x83, 0xd3, 0x83, 0x70, 0xe8, 0xf7, 0x2f, 0x91,
+	0xc6, 0x25, 0x5b, 0x09, 0x25, 0x4c, 0xf2, 0x9c, 0x09, 0x66, 0x32, 0x51, 0xa5, 0x48, 0x71, 0x01,
+	0xae, 0xca, 0x4c, 0xc2, 0x33, 0xf9, 0x78, 0xec, 0xc5, 0x54, 0x4b, 0x6c, 0x75, 0x4c, 0x20, 0x93,
+	0xc3, 0x0c, 0x80, 0xb9, 0x1f, 0x23, 0x7f, 0x38, 0xf4, 0x39, 0x2e, 0xf7, 0x51, 0x14, 0x55, 0xb1,
+	0x3e, 0x07, 0x7e, 0xec, 0x1d, 0xa7, 0x17, 0x96, 0x54, 0x19, 0xa3, 0x45, 0xde, 0x6b, 0x2d, 0x5a,
+	0xc4, 0x93, 0xc5, 0x4c, 0x60, 0x96, 0xaa, 0x66, 0x73, 0x54, 0x65, 0xff, 0x9b, 0x12, 0x34, 0x34,
+	0x1a, 0x65, 0xb2, 0xa5, 0xf0, 0x10, 0xd6, 0xa0, 0xe2, 0x8a, 0x62, 0x60, 0x78, 0xbd, 0x34, 0x08,
+	0xb9, 0x67, 0xf6, 0x8a, 0x51, 0x66, 0x94, 0x3e, 0x06, 0x3d, 0xdf, 0x82, 0x3a, 0xe3, 0xc3, 0x0f,
+	0xd1, 0xc5, 0x26, 0x92, 0xc8, 0x15, 0x40, 0xd6, 0xae, 0x62, 0x6d, 0x35, 0xad, 0x45, 0xc0, 0x95,
+	0x97, 0x16, 0x1f, 0x43, 0x53, 0x34, 0x83, 0x7b, 0x8c, 0x93, 0x4e, 0x25, 0x81, 0xb1, 0xff, 0x8e,
+	0x81, 0x29, 0xbf, 0x5c, 0x95, 0x5f, 0xd6, 0xde, 0xf4, 0xa5, 0xc4, 0xb4, 0x9f, 0xa9, 0xfb, 0xa0,
+	0xcf, 0x22, 0x6f, 0x7c, 0x26, 0xa5, 0xdb, 0x23, 0x58, 0x90, 0x42, 0x6c, 0x12, 0x78, 0x41, 0x10,
+	0x4e, 0x82, 0x3e, 0x95, 0x89, 0x05, 0x45, 0x55, 0xf6, 0x40, 0xa5, 0xa1, 0x61, 0x43, 0xe4, 0x01,
+	0x54, 0xb9, 0x1a, 0xcf, 0x75, 0x95, 0x62, 0x79, 0xc6, 0x51, 0xc8, 0x7d, 0xa8, 0x72, 0x6d, 0xbe,
+	0x34, 0x55, 0x02, 0x71, 0x04, 0x7b, 0x05, 0xe6, 0x50, 0x23, 0xd5, 0x04, 0xf1, 0xcd, 0x22, 0x1d,
+	0x66, 0xa6, 0xcf, 0xc3, 0x19, 0x8b, 0x40, 0xf6, 0x38, 0x5f, 0xe9, 0xf7, 0x7a, 0xfe, 0xa2, 0x0c,
+	0x0d, 0x0d, 0xcc, 0x84, 0x25, 0x5e, 0xf2, 0x70, 0x07, 0xbe, 0x37, 0xa2, 0x32, 0xb8, 0xd1, 0x72,
+	0x32, 0x50, 0x86, 0xe7, 0x9d, 0x9f, 0xba, 0xe1, 0x24, 0x71, 0x07, 0xf4, 0x34, 0xa2, 0x54, 0x28,
+	0x57, 0x19, 0x28, 0xc3, 0x63, 0xd4, 0xac, 0xe1, 0xf1, 0xfb, 0x0a, 0x19, 0xa8, 0xbc, 0x3f, 0xc3,
+	0xd7, 0xa9, 0x92, 0xde, 0x9f, 0xe1, 0xab, 0x92, 0x15, 0xf3, 0xd5, 0x02, 0x31, 0xff, 0x11, 0x2c,
+	0x71, 0x81, 0x2e, 0xa4, 0x87, 0x9b, 0x21, 0xae, 0x29, 0xb5, 0xe4, 0x01, 0x74, 0xd8, 0x98, 0x25,
+	0x6b, 0xc4, 0xfe, 0x4f, 0x38, 0x8f, 0x59, 0x4e, 0x0e, 0xce, 0x70, 0x31, 0xf6, 0xaa, 0xe3, 0xf2,
+	0x8b, 0xb2, 0x39, 0x38, 0xe2, 0x7a, 0xaf, 0x4d, 0xdc, 0xba, 0xc0, 0xcd, 0xc0, 0xc9, 0x63, 0x58,
+	0x1e, 0xd1, 0x81, 0xef, 0x99, 0x4d, 0xb8, 0xa9, 0xc6, 0x31, 0xad, 0x9a, 0xf5, 0xc2, 0x56, 0xe1,
+	0x27, 0xe1, 0xe8, 0xd8, 0xe7, 0xa7, 0x2c, 0x8f, 0x12, 0x57, 0x9c, 0x1c, 0xdc, 0x6e, 0x41, 0xe3,
+	0x30, 0x09, 0xc7, 0x72, 0xeb, 0xdb, 0xd0, 0xe4, 0x45, 0x91, 0x4a, 0x72, 0x13, 0x6e, 0x20, 0xbd,
+	0x1e, 0x85, 0xe3, 0x70, 0x18, 0x9e, 0x5e, 0x1a, 0xee, 0xa9, 0x7f, 0x67, 0xc1, 0x82, 0x51, 0x9b,
+	0xfa, 0xa7, 0xd0, 0x97, 0x2e, 0xef, 0xff, 0x73, 0x12, 0x9f, 0xd7, 0xce, 0x28, 0x8e, 0xc8, 0xef,
+	0x01, 0xbc, 0x10, 0x29, 0x01, 0x6b, 0x69, 0x52, 0xab, 0xfc, 0x90, 0xd3, 0x7b, 0x37, 0x4f, 0xef,
+	0xe2, 0x7b, 0x99, 0xee, 0x2a, 0x9b, 0xf8, 0x5d, 0x71, 0xad, 0x79, 0x20, 0x26, 0x5d, 0x36, 0x6f,
+	0x6c, 0xea, 0xee, 0x4c, 0x39, 0x82, 0xbe, 0x02, 0xc6, 0xf6, 0x2f, 0x2c, 0x80, 0x74, 0x74, 0x78,
+	0x67, 0x54, 0x9d, 0xb3, 0xfc, 0xdd, 0x18, 0xed, 0x4c, 0x7d, 0x17, 0x9a, 0xea, 0xde, 0x5a, 0x7a,
+	0x74, 0x37, 0x24, 0x8c, 0xa9, 0x3a, 0xef, 0xc3, 0xdc, 0xe9, 0x30, 0x3c, 0x46, 0x95, 0x4a, 0x9c,
+	0xb3, 0x3c, 0xa1, 0xa6, 0xcd, 0xc1, 0xf2, 0xf4, 0x4c, 0xcf, 0xf9, 0x4a, 0xe1, 0x85, 0x37, 0xfd,
+	0xd4, 0x66, 0x67, 0xdd, 0x7c, 0x6e, 0x25, 0xae, 0xe4, 0xf2, 0x5f, 0x29, 0xec, 0x7b, 0x55, 0x74,
+	0xe3, 0x09, 0xb4, 0x23, 0x2e, 0x33, 0xa5, 0x40, 0xad, 0x5c, 0x21, 0x50, 0x5b, 0x91, 0x71, 0x32,
+	0x7f, 0x05, 0x3a, 0xde, 0xe0, 0x9c, 0x46, 0x89, 0x8f, 0xde, 0x5e, 0xd4, 0xe9, 0xf8, 0x04, 0xe7,
+	0x34, 0x38, 0xaa, 0x4e, 0xef, 0xc3, 0x9c, 0x48, 0x6f, 0x52, 0x98, 0xe2, 0x05, 0x85, 0x14, 0xcc,
+	0x10, 0xed, 0x7f, 0x2c, 0xaf, 0x0d, 0x99, 0xbb, 0x7b, 0xf5, 0xaa, 0xe8, 0x33, 0x2c, 0x65, 0x66,
+	0xf8, 0x25, 0x71, 0x29, 0x62, 0x20, 0xdd, 0xca, 0x65, 0xed, 0x82, 0xfc, 0x40, 0x5c, 0xbb, 0x32,
+	0x97, 0xb5, 0xf2, 0x36, 0xcb, 0x6a, 0xff, 0x27, 0x0b, 0x66, 0xb7, 0xc3, 0x31, 0x33, 0xed, 0x51,
+	0xc7, 0x61, 0x6c, 0xa2, 0x72, 0x0b, 0x65, 0xf1, 0x0d, 0x89, 0x04, 0x85, 0x5a, 0x49, 0x2b, 0xab,
+	0x95, 0x7c, 0x07, 0x6e, 0x62, 0x60, 0x23, 0x0a, 0xc7, 0x61, 0xc4, 0xd8, 0xd5, 0x1b, 0x72, 0x15,
+	0x24, 0x0c, 0x92, 0x33, 0x29, 0x4e, 0xaf, 0x42, 0x41, 0x3f, 0xe0, 0x30, 0x39, 0x77, 0xb9, 0xb9,
+	0x29, 0xb4, 0x28, 0x2e, 0x65, 0xf3, 0x15, 0xf6, 0xb7, 0xa0, 0xae, 0x1c, 0x18, 0xe4, 0x03, 0xa8,
+	0x9f, 0x85, 0x63, 0xe1, 0xe5, 0xb0, 0x8c, 0xa4, 0x0b, 0x31, 0x7b, 0x27, 0x45, 0xb0, 0xff, 0xe7,
+	0x2c, 0xcc, 0xee, 0x04, 0xe7, 0xa1, 0xdf, 0xc7, 0xeb, 0x47, 0x23, 0x3a, 0x0a, 0x65, 0xb6, 0x25,
+	0xfb, 0x1b, 0x1f, 0x42, 0x49, 0xdf, 0x43, 0xe0, 0x2c, 0xa4, 0x41, 0x98, 0x81, 0x1c, 0xe9, 0xef,
+	0x19, 0x88, 0x52, 0x6a, 0xf5, 0x55, 0xb5, 0x7c, 0x55, 0xd6, 0x1a, 0xcf, 0xb3, 0xc7, 0xb5, 0xe3,
+	0x59, 0x32, 0x1a, 0x84, 0x2d, 0xbe, 0x48, 0x70, 0xe0, 0x17, 0xc5, 0xf9, 0x4d, 0x46, 0x01, 0x42,
+	0xa3, 0x3f, 0xa2, 0x3c, 0x34, 0xa5, 0x54, 0x2f, 0x66, 0xf4, 0xeb, 0x40, 0xa6, 0x9e, 0xf1, 0x0f,
+	0x38, 0x0e, 0x3f, 0x0e, 0x74, 0x10, 0xde, 0x46, 0xc9, 0xbc, 0x0e, 0xc2, 0x5f, 0x78, 0xc9, 0x82,
+	0xf9, 0x45, 0x33, 0x25, 0x74, 0xf9, 0x3c, 0x81, 0xbf, 0x09, 0x91, 0x85, 0x6b, 0xae, 0x02, 0x9e,
+	0x07, 0x26, 0x5d, 0x05, 0x8c, 0x64, 0xbc, 0xe1, 0xf0, 0xd8, 0xeb, 0xbf, 0xe2, 0x96, 0x6d, 0x93,
+	0x47, 0x34, 0x0d, 0x20, 0xde, 0xe6, 0x4f, 0xf7, 0x15, 0x2f, 0x02, 0x55, 0x1c, 0x1d, 0x44, 0x56,
+	0x4d, 0xff, 0x55, 0x7b, 0x8a, 0xff, 0x4a, 0x47, 0xd2, 0x2f, 0x46, 0xcd, 0xe5, 0x32, 0xb3, 0xbc,
+	0xc1, 0x40, 0x5c, 0x98, 0xe9, 0xf0, 0x37, 0x11, 0x14, 0x00, 0x1d, 0x35, 0x7c, 0xc1, 0x38, 0xc2,
+	0x3c, 0x22, 0x18, 0x30, 0x72, 0x87, 0xfb, 0x61, 0xc7, 0x9e, 0x3f, 0xc0, 0x8b, 0xa9, 0xdc, 0x16,
+	0x56, 0x30, 0xd6, 0x86, 0xfc, 0x1b, 0x0f, 0xce, 0x05, 0x5c, 0x15, 0x03, 0xc6, 0xd6, 0x46, 0x95,
+	0x47, 0x69, 0x2a, 0x97, 0x09, 0x24, 0x1f, 0xe2, 0x45, 0x84, 0x84, 0x62, 0xbe, 0x56, 0x7b, 0xf5,
+	0xa6, 0x98, 0xb3, 0x20, 0x5b, 0xf9, 0x3f, 0x5e, 0xbc, 0x70, 0x38, 0x26, 0x53, 0xdb, 0x78, 0x2c,
+	0x68, 0xc9, 0x50, 0xdb, 0x04, 0x2a, 0xc6, 0x82, 0x38, 0x02, 0x79, 0xac, 0x59, 0x62, 0x5d, 0x44,
+	0xbe, 0x95, 0x69, 0x7f, 0x8a, 0x0d, 0xc6, 0x88, 0xd9, 0x8f, 0xd9, 0xf9, 0x13, 0xd3, 0x60, 0x80,
+	0x99, 0x5b, 0x35, 0x47, 0x83, 0xfc, 0x66, 0x6d, 0xb4, 0x35, 0x68, 0xea, 0xf3, 0x24, 0x35, 0xa8,
+	0xec, 0x1f, 0x6c, 0xed, 0x75, 0xae, 0x91, 0x06, 0xcc, 0x1e, 0x6e, 0x1d, 0x1d, 0xed, 0x6e, 0x6d,
+	0x76, 0x2c, 0xd2, 0x84, 0x9a, 0x4a, 0x43, 0x29, 0xb1, 0xd2, 0xda, 0xc6, 0xc6, 0xd6, 0xc1, 0xd1,
+	0xd6, 0x66, 0xa7, 0xfc, 0x49, 0xa5, 0x56, 0xea, 0x94, 0x51, 0xc1, 0xd4, 0x96, 0xe1, 0x0d, 0x7e,
+	0xb6, 0x3b, 0x00, 0x68, 0xf8, 0xa4, 0x17, 0xab, 0x2a, 0x8e, 0x06, 0x61, 0x82, 0x5c, 0xf9, 0x27,
+	0xca, 0xfc, 0x1d, 0x0b, 0x59, 0xc6, 0xcd, 0xc5, 0x07, 0x23, 0xf4, 0xf8, 0x60, 0xd5, 0x31, 0x81,
+	0x8c, 0xf0, 0x05, 0x00, 0x13, 0x1c, 0xb8, 0xb8, 0xd0, 0x41, 0x8c, 0x90, 0x22, 0x1a, 0x87, 0xc3,
+	0x73, 0xca, 0x51, 0xb8, 0xfa, 0x68, 0xc0, 0x58, 0x5f, 0x42, 0x22, 0x6a, 0x59, 0x55, 0x55, 0xc7,
+	0x04, 0x92, 0xaf, 0x49, 0x42, 0xaa, 0x21, 0x21, 0x2d, 0xe7, 0xa9, 0xc2, 0x20, 0xa2, 0xe7, 0x39,
+	0x47, 0x59, 0x1d, 0x09, 0xe4, 0xcb, 0xf9, 0xef, 0xde, 0xc2, 0x61, 0x46, 0x56, 0x80, 0x8c, 0xc6,
+	0x63, 0xb7, 0xc0, 0x83, 0x55, 0x71, 0x0a, 0x6a, 0x7e, 0x03, 0x0e, 0xb6, 0x04, 0xc8, 0xda, 0x60,
+	0x20, 0x86, 0xa9, 0x3f, 0xeb, 0x11, 0xe9, 0xef, 0xc8, 0x48, 0x91, 0x5d, 0x20, 0x16, 0x4b, 0xc5,
+	0x62, 0xf1, 0x4a, 0xe1, 0x61, 0xef, 0x40, 0xe3, 0x40, 0x7b, 0x99, 0xc6, 0x66, 0x27, 0x88, 0x7c,
+	0x93, 0x86, 0x9f, 0x2d, 0xdc, 0xb1, 0x96, 0x42, 0xb5, 0x21, 0x95, 0xf4, 0x21, 0xd9, 0xff, 0xd0,
+	0xe2, 0xc9, 0xfe, 0x6a, 0x0a, 0xbc, 0x7f, 0x1b, 0x9a, 0x2a, 0xb8, 0x94, 0x66, 0x3e, 0x1a, 0x30,
+	0x86, 0x83, 0xc3, 0x71, 0xc3, 0x93, 0x93, 0x98, 0xca, 0x54, 0x1e, 0x03, 0x26, 0x95, 0x75, 0xa6,
+	0xfe, 0xfb, 0xbc, 0x87, 0x58, 0xa4, 0xf4, 0xe4, 0xe0, 0x8c, 0xd2, 0x85, 0x6f, 0x5c, 0x26, 0x31,
+	0xa9, 0xb2, 0x4a, 0xd0, 0xcc, 0xae, 0xf4, 0x03, 0xa8, 0xa9, 0x76, 0xcd, 0x93, 0x58, 0x62, 0xaa,
+	0x7a, 0x76, 0xe2, 0xa3, 0x21, 0x6f, 0x0c, 0x9a, 0x33, 0x5c, 0xbe, 0x82, 0xd1, 0xd2, 0x89, 0x1f,
+	0x65, 0xd1, 0x39, 0x07, 0x16, 0xd4, 0xd8, 0x2f, 0x61, 0x41, 0x8a, 0x0f, 0xcd, 0x8a, 0x30, 0x37,
+	0xd2, 0x7a, 0xd3, 0x29, 0x50, 0xca, 0x9f, 0x02, 0xf6, 0xbf, 0xae, 0xc0, 0xac, 0x7c, 0xf6, 0xc9,
+	0x2e, 0x78, 0xa6, 0xa8, 0x6e, 0xbe, 0x70, 0x44, 0xba, 0xc6, 0x3b, 0x16, 0x48, 0x08, 0x42, 0x37,
+	0xb8, 0x9f, 0x3d, 0xdd, 0x53, 0x07, 0x6b, 0xe6, 0x84, 0x5f, 0x82, 0xca, 0xd8, 0x4b, 0xce, 0xd0,
+	0xff, 0xc6, 0x69, 0x09, 0xcb, 0xd2, 0x85, 0x5f, 0x35, 0x5d, 0xf8, 0x45, 0xef, 0x3a, 0x71, 0x55,
+	0x36, 0xff, 0xae, 0xd3, 0x2d, 0xa8, 0x73, 0x6d, 0x24, 0xf5, 0xd2, 0xa7, 0x80, 0x8c, 0xf6, 0x52,
+	0xcb, 0x69, 0x2f, 0x6f, 0xaf, 0x57, 0x7c, 0x03, 0x66, 0x78, 0x6e, 0xb3, 0x48, 0xd9, 0x92, 0x47,
+	0x8e, 0x58, 0x49, 0xf9, 0x3f, 0xbf, 0xb9, 0xeb, 0x08, 0x5c, 0xfd, 0x75, 0x94, 0x86, 0xf9, 0x3a,
+	0x8a, 0x1e, 0x5c, 0x68, 0x66, 0x82, 0x0b, 0x0f, 0xa0, 0xa3, 0x96, 0x0f, 0x1d, 0x70, 0x41, 0x2c,
+	0x52, 0x54, 0x72, 0xf0, 0xf4, 0xd8, 0x6c, 0x1b, 0xc7, 0x26, 0x93, 0x70, 0x6b, 0x49, 0x42, 0x47,
+	0xe3, 0x44, 0x1c, 0x9b, 0xf6, 0x53, 0x68, 0x19, 0x83, 0x34, 0xd3, 0x1a, 0x5b, 0x50, 0xdf, 0xd9,
+	0x73, 0x9f, 0xee, 0xee, 0x3c, 0xdb, 0x3e, 0xea, 0x58, 0xac, 0x78, 0xf8, 0x62, 0x63, 0x63, 0x6b,
+	0x6b, 0x13, 0x8f, 0x25, 0x80, 0x99, 0xa7, 0x6b, 0x3b, 0xec, 0x88, 0x2a, 0xdb, 0xff, 0xcb, 0x82,
+	0x86, 0xd6, 0x3c, 0xf9, 0xa6, 0x5a, 0x19, 0xfe, 0x80, 0xc6, 0xed, 0xfc, 0x10, 0x56, 0xa4, 0xa0,
+	0xd6, 0x96, 0x46, 0x3d, 0x65, 0x55, 0x9a, 0xfa, 0x94, 0x15, 0xdb, 0x1e, 0x8f, 0xb7, 0xa0, 0xd6,
+	0x81, 0x5b, 0x57, 0x59, 0x30, 0xbf, 0xae, 0x96, 0x9e, 0x2e, 0x0c, 0x93, 0x7b, 0x14, 0xb3, 0x60,
+	0xfb, 0x23, 0x80, 0x74, 0x34, 0xe6, 0xb4, 0xaf, 0x99, 0xd3, 0xb6, 0xb4, 0x69, 0x97, 0xec, 0x4d,
+	0x2e, 0x30, 0xc4, 0x12, 0xaa, 0x30, 0xf8, 0xd7, 0x80, 0x48, 0x07, 0x16, 0x5e, 0x0b, 0x1d, 0x0f,
+	0x69, 0x22, 0x53, 0x3b, 0xe7, 0x45, 0xcd, 0x8e, 0xaa, 0x90, 0x69, 0xd7, 0x69, 0x2b, 0xa9, 0xdc,
+	0x11, 0x14, 0x97, 0x95, 0x3b, 0x02, 0xd5, 0x51, 0xf5, 0x76, 0x0f, 0xba, 0x9b, 0x94, 0xb5, 0xb6,
+	0x36, 0x1c, 0x66, 0x86, 0x63, 0xdf, 0x84, 0x1b, 0x05, 0x75, 0xc2, 0x3d, 0xf1, 0x5d, 0xb8, 0xbe,
+	0xc6, 0xb3, 0x38, 0x7f, 0x53, 0x09, 0x23, 0x76, 0x17, 0x96, 0xb2, 0x4d, 0x8a, 0xce, 0x9e, 0xc2,
+	0xfc, 0x26, 0x3d, 0x9e, 0x9c, 0xee, 0xd2, 0xf3, 0xb4, 0x23, 0x02, 0x95, 0xf8, 0x2c, 0xbc, 0x10,
+	0xeb, 0x83, 0x7f, 0x93, 0xdb, 0x00, 0x43, 0x86, 0xe3, 0xc6, 0x63, 0xda, 0x97, 0x0f, 0x94, 0x20,
+	0xe4, 0x70, 0x4c, 0xfb, 0xf6, 0x47, 0x40, 0xf4, 0x76, 0xc4, 0x7a, 0x31, 0x93, 0x61, 0x72, 0xec,
+	0xc6, 0x97, 0x71, 0x42, 0x47, 0xf2, 0xe5, 0x15, 0x1d, 0x64, 0xbf, 0x0f, 0xcd, 0x03, 0xef, 0xd2,
+	0xa1, 0x9f, 0x89, 0xa7, 0xd3, 0x96, 0x61, 0x76, 0xec, 0x5d, 0x32, 0x7e, 0x56, 0x21, 0x16, 0xac,
+	0xb6, 0xff, 0xa4, 0x02, 0x33, 0x1c, 0x93, 0xb5, 0x3a, 0xa0, 0x71, 0xe2, 0x07, 0xc8, 0x63, 0xb2,
+	0x55, 0x0d, 0x94, 0x13, 0x98, 0xa5, 0x02, 0x81, 0x29, 0x5c, 0x6d, 0xf2, 0xa1, 0x07, 0x41, 0xb2,
+	0x06, 0x8c, 0x89, 0xad, 0x34, 0xfd, 0x8c, 0x53, 0x6a, 0x0a, 0xc8, 0xc4, 0x30, 0x53, 0xc3, 0x84,
+	0x8f, 0x4f, 0x9e, 0x05, 0x42, 0x26, 0xea, 0xa0, 0x42, 0xf3, 0x67, 0x56, 0xe6, 0xd9, 0x64, 0xcc,
+	0x9f, 0x9c, 0x99, 0x53, 0x7b, 0x0b, 0x33, 0x87, 0xfb, 0xdf, 0xae, 0x32, 0x73, 0xe0, 0x6d, 0xcc,
+	0x9c, 0xb7, 0x89, 0x1d, 0xf6, 0xa0, 0x86, 0x67, 0xba, 0x26, 0x22, 0x65, 0x99, 0xfc, 0x8e, 0x66,
+	0x03, 0xf0, 0x7b, 0x0c, 0x37, 0x53, 0x7e, 0x71, 0xe8, 0x67, 0xbf, 0x9d, 0x30, 0xcc, 0x0f, 0x61,
+	0x56, 0x40, 0x19, 0x65, 0x07, 0xde, 0x48, 0x3e, 0xb0, 0x83, 0x7f, 0xb3, 0xa5, 0xc3, 0x77, 0x3e,
+	0x3e, 0x9b, 0xf8, 0x11, 0x1d, 0xc8, 0x5c, 0x6d, 0x0d, 0x84, 0x97, 0xcb, 0x63, 0xf7, 0x55, 0x10,
+	0x5e, 0x04, 0x22, 0x5b, 0x5b, 0x95, 0x6d, 0x02, 0x1d, 0x7c, 0x68, 0x6b, 0x1c, 0x46, 0xf2, 0xcd,
+	0x24, 0xfb, 0x0f, 0x2d, 0xe8, 0x08, 0x46, 0x53, 0x75, 0xf2, 0xc2, 0xc0, 0x55, 0x6f, 0x2d, 0xdc,
+	0x83, 0x16, 0xfa, 0x3a, 0xd4, 0x91, 0x23, 0x82, 0xef, 0x06, 0x90, 0x8d, 0x57, 0xde, 0xee, 0x1c,
+	0xf9, 0x43, 0x41, 0xb7, 0x3a, 0x48, 0x9e, 0x5a, 0x91, 0x27, 0x92, 0xbc, 0x2c, 0x47, 0x95, 0xed,
+	0x5f, 0x5a, 0x30, 0xaf, 0x0d, 0x58, 0x30, 0xea, 0x13, 0x68, 0xaa, 0xf7, 0xec, 0xa8, 0x52, 0xaa,
+	0x96, 0x4d, 0xc9, 0x92, 0x7e, 0x66, 0x20, 0x23, 0xbd, 0x7b, 0x97, 0x38, 0xc0, 0x78, 0x32, 0x12,
+	0xda, 0x8c, 0x0e, 0x62, 0x74, 0x74, 0x41, 0xe9, 0x2b, 0x85, 0xc2, 0xf5, 0x29, 0x03, 0x86, 0x31,
+	0xa2, 0x30, 0x48, 0xce, 0x14, 0x52, 0x45, 0xc4, 0x88, 0x74, 0xa0, 0xfd, 0x5f, 0x4a, 0xb0, 0xc0,
+	0x9d, 0x6e, 0xc2, 0xd9, 0xa9, 0x9e, 0x14, 0x9a, 0xe1, 0xfe, 0x47, 0x2e, 0xb4, 0xb6, 0xaf, 0x39,
+	0xa2, 0x4c, 0xbe, 0xf9, 0x96, 0x8e, 0x42, 0x95, 0x4d, 0x36, 0x65, 0x2f, 0xca, 0x45, 0x7b, 0x71,
+	0xc5, 0x4a, 0x17, 0x85, 0xeb, 0xaa, 0xc5, 0xe1, 0xba, 0xb7, 0x0b, 0x8f, 0xe5, 0x52, 0xae, 0x66,
+	0x05, 0x96, 0x91, 0x72, 0xb5, 0x0a, 0xcb, 0x06, 0x00, 0xe5, 0xb5, 0x7f, 0xe2, 0x53, 0x99, 0xff,
+	0x3e, 0x1f, 0xd3, 0xc4, 0x35, 0x50, 0xd6, 0x67, 0xa1, 0x1a, 0xf7, 0xc3, 0x31, 0xb5, 0x97, 0x60,
+	0xd1, 0x5c, 0x5c, 0x71, 0x4a, 0xfc, 0xc2, 0x82, 0xee, 0x53, 0x7e, 0xe9, 0xc2, 0x0f, 0x4e, 0xb7,
+	0xfd, 0x38, 0x09, 0x23, 0xf5, 0xf2, 0xdb, 0x1d, 0x80, 0x38, 0xf1, 0x22, 0x61, 0x67, 0x72, 0x65,
+	0x57, 0x83, 0xb0, 0x35, 0xa2, 0xc1, 0x80, 0xd7, 0x72, 0xda, 0x50, 0xe5, 0x9c, 0x31, 0x21, 0x5c,
+	0x92, 0x86, 0x4a, 0xfe, 0x1e, 0xcf, 0x04, 0x65, 0x8b, 0x41, 0xcf, 0xf1, 0xe8, 0xe5, 0x7e, 0xbe,
+	0x0c, 0xd4, 0xfe, 0xa3, 0x12, 0xcc, 0xa5, 0x83, 0xe4, 0x99, 0xe5, 0x86, 0x00, 0x17, 0x7a, 0x78,
+	0x2a, 0xc0, 0x45, 0xf8, 0xd0, 0xf5, 0x99, 0x62, 0xae, 0x79, 0x25, 0x35, 0x28, 0xb9, 0x07, 0x0d,
+	0x59, 0x0a, 0x27, 0x89, 0xf6, 0x04, 0x93, 0x0e, 0xe6, 0x29, 0x26, 0xcc, 0x34, 0x10, 0x66, 0x8e,
+	0x28, 0xe1, 0x7b, 0x08, 0xa3, 0x04, 0xbf, 0xe4, 0x7b, 0x2a, 0x8b, 0x4c, 0xa0, 0x31, 0x9d, 0x9a,
+	0xef, 0x21, 0xea, 0xd3, 0xba, 0xae, 0x59, 0x53, 0x4f, 0x57, 0x2a, 0x9e, 0xe7, 0x2d, 0xa6, 0xc9,
+	0x76, 0x15, 0x47, 0x07, 0x49, 0xaf, 0x50, 0x38, 0x31, 0xcc, 0x5f, 0x03, 0x66, 0xff, 0x2d, 0x0b,
+	0x6e, 0x14, 0x6c, 0xa3, 0x90, 0x01, 0x9b, 0x30, 0x7f, 0xa2, 0x2a, 0xe5, 0x52, 0x73, 0x41, 0xb0,
+	0x24, 0x85, 0xab, 0xb9, 0xbc, 0x4e, 0xfe, 0x03, 0x65, 0x6e, 0xf1, 0xcd, 0x33, 0x72, 0x2b, 0xf3,
+	0x15, 0xf6, 0x01, 0xf4, 0xb6, 0x5e, 0x33, 0x91, 0xb2, 0xa1, 0xbf, 0x5f, 0x2e, 0x29, 0x6b, 0x35,
+	0x27, 0x32, 0xdf, 0xec, 0x8c, 0x3e, 0xe1, 0x19, 0x63, 0xaa, 0x2d, 0xf2, 0xf5, 0xb7, 0x6d, 0x44,
+	0xe7, 0xfe, 0xbb, 0x62, 0xd7, 0xf9, 0x03, 0xec, 0x32, 0xc3, 0x53, 0x03, 0xd9, 0xe7, 0x30, 0xf7,
+	0x7c, 0x32, 0x4c, 0xfc, 0xf4, 0x31, 0x76, 0xf2, 0x4d, 0xf1, 0x11, 0x36, 0x21, 0x97, 0xae, 0xb0,
+	0x2b, 0x1d, 0x8f, 0xad, 0xd8, 0x88, 0xb5, 0xe4, 0xe6, 0x7b, 0xcc, 0x57, 0xd8, 0x37, 0x60, 0x39,
+	0xed, 0x92, 0xaf, 0x9d, 0x3c, 0x76, 0xfe, 0xd8, 0xe2, 0x37, 0xab, 0xcd, 0xb7, 0xe1, 0xc9, 0x33,
+	0x58, 0x88, 0xfd, 0xe0, 0x74, 0x48, 0xf5, 0x76, 0x62, 0xb1, 0x12, 0xd7, 0xcd, 0xe1, 0x89, 0xf7,
+	0xe3, 0x9d, 0xa2, 0x2f, 0x18, 0x81, 0x14, 0x0f, 0x34, 0x25, 0x90, 0xcc, 0x92, 0x14, 0x4d, 0xe0,
+	0x13, 0x68, 0x9b, 0x9d, 0x91, 0xc7, 0x22, 0x75, 0x32, 0x1d, 0x59, 0x39, 0x93, 0x01, 0x97, 0x52,
+	0x86, 0x81, 0x69, 0xff, 0xcc, 0x82, 0xae, 0x43, 0x19, 0x19, 0x53, 0xad, 0x53, 0x41, 0x3d, 0x4f,
+	0x72, 0xcd, 0x4e, 0x9f, 0xb0, 0x4a, 0xc9, 0x94, 0x73, 0x5d, 0x99, 0xba, 0x29, 0xdb, 0xd7, 0x0a,
+	0x66, 0xb5, 0x5e, 0x83, 0x19, 0x31, 0xbf, 0x65, 0xb8, 0x2e, 0x86, 0x24, 0x87, 0x93, 0x86, 0x1d,
+	0x8d, 0x4e, 0x8d, 0xb0, 0x63, 0x0f, 0xba, 0xfc, 0x81, 0x3f, 0x7d, 0x1e, 0xe2, 0xc3, 0x4d, 0x20,
+	0xcf, 0xbd, 0xbe, 0x17, 0x85, 0x61, 0x70, 0x40, 0x23, 0x71, 0x49, 0x15, 0xb5, 0x4f, 0x8c, 0xca,
+	0x49, 0x45, 0x99, 0x97, 0xe4, 0x9b, 0x74, 0x61, 0x20, 0xdf, 0xfe, 0xe3, 0x25, 0xdb, 0x81, 0x85,
+	0x75, 0xef, 0x15, 0x95, 0x2d, 0xa5, 0xab, 0xd4, 0x18, 0xab, 0x46, 0xe5, 0xda, 0xcb, 0x9c, 0xeb,
+	0x7c, 0xb7, 0x8e, 0x8e, 0x6d, 0xaf, 0xc2, 0xa2, 0xd9, 0xa6, 0x10, 0x25, 0x3d, 0xa8, 0x8d, 0x04,
+	0x4c, 0x8c, 0x4e, 0x95, 0x1f, 0x7c, 0x0e, 0x0d, 0xed, 0xd1, 0x46, 0xb2, 0x0c, 0x0b, 0x2f, 0x77,
+	0x8e, 0xf6, 0xb6, 0x0e, 0x0f, 0xdd, 0x83, 0x17, 0xeb, 0x9f, 0x6e, 0x7d, 0xdf, 0xdd, 0x5e, 0x3b,
+	0xdc, 0xee, 0x5c, 0x23, 0x4b, 0x40, 0xf6, 0xb6, 0x0e, 0x8f, 0xb6, 0x36, 0x0d, 0xb8, 0x45, 0xee,
+	0x40, 0xef, 0xc5, 0xde, 0x8b, 0xc3, 0xad, 0x4d, 0xb7, 0xe8, 0xbb, 0x12, 0xb9, 0x0d, 0x37, 0x44,
+	0x7d, 0xc1, 0xe7, 0xe5, 0x07, 0x4f, 0xa0, 0x93, 0x75, 0x4b, 0x1a, 0xee, 0xdc, 0xab, 0xfc, 0xbe,
+	0x0f, 0xfe, 0x51, 0x19, 0x20, 0xbd, 0x9c, 0x4a, 0xba, 0xb0, 0xb8, 0xb9, 0x76, 0xb4, 0xb6, 0xbb,
+	0xcf, 0x06, 0xe1, 0xec, 0x1f, 0x6d, 0x6d, 0x1c, 0xb9, 0xce, 0xd6, 0x77, 0x3b, 0xd7, 0x0a, 0x6b,
+	0xf6, 0x0f, 0x98, 0xc9, 0xbe, 0x0c, 0x0b, 0x3b, 0x7b, 0x3b, 0x47, 0x3b, 0x6b, 0xbb, 0xae, 0xb3,
+	0xff, 0x62, 0x67, 0xef, 0x19, 0x7f, 0x77, 0xa5, 0x4c, 0xde, 0x81, 0x9b, 0x2f, 0x0e, 0x9e, 0x3a,
+	0xfb, 0x7b, 0x47, 0xee, 0xe1, 0xf6, 0x8b, 0xa3, 0x4d, 0x7c, 0xb5, 0x65, 0xc3, 0xd9, 0x39, 0xe0,
+	0x6d, 0x56, 0xae, 0x42, 0x60, 0x4d, 0x57, 0xd9, 0x8a, 0x3d, 0xdb, 0x3f, 0x3c, 0xdc, 0x39, 0x70,
+	0xbf, 0xfb, 0x62, 0xcb, 0xd9, 0xd9, 0x3a, 0xc4, 0x0f, 0x67, 0x0a, 0xe0, 0x0c, 0x7f, 0x96, 0xcc,
+	0x43, 0xeb, 0x68, 0xf7, 0x7b, 0xee, 0xfe, 0xde, 0xce, 0xfe, 0x1e, 0xa2, 0xd6, 0x4c, 0x10, 0xc3,
+	0xaa, 0x93, 0x1e, 0x2c, 0x6d, 0xfd, 0xfe, 0x91, 0x5b, 0xd0, 0x32, 0x4c, 0xa9, 0x63, 0xdf, 0x35,
+	0xc8, 0x0d, 0xb8, 0x7e, 0x78, 0xb4, 0x76, 0xb4, 0xb3, 0xe1, 0x8a, 0x17, 0x9f, 0xd8, 0x26, 0xb0,
+	0xcf, 0x9a, 0xc5, 0x55, 0xec, 0xab, 0x16, 0x59, 0x84, 0xce, 0xc1, 0xda, 0xf7, 0x9f, 0x6f, 0xed,
+	0x1d, 0xb9, 0x6b, 0x9b, 0x9b, 0x0e, 0x7e, 0xd0, 0xce, 0x41, 0x19, 0xee, 0x1c, 0xdb, 0xa8, 0xe7,
+	0x07, 0x07, 0x88, 0xd2, 0x91, 0x05, 0x56, 0x33, 0xbf, 0xfa, 0xb3, 0x32, 0xb4, 0x79, 0xb6, 0x00,
+	0xff, 0x15, 0x0c, 0x1a, 0x91, 0xe7, 0x30, 0x2b, 0x7e, 0x4e, 0x85, 0x5c, 0x57, 0x8f, 0x6d, 0xe8,
+	0x3f, 0xe0, 0xd2, 0x5b, 0xca, 0x82, 0x05, 0xfb, 0x2d, 0xfc, 0x95, 0xff, 0xf0, 0xdf, 0x7e, 0x5e,
+	0x6a, 0x91, 0xc6, 0xc3, 0xf3, 0x0f, 0x1f, 0x9e, 0xd2, 0x20, 0x66, 0x6d, 0xfc, 0xff, 0x00, 0xe9,
+	0x8f, 0x84, 0x90, 0xae, 0xf2, 0x3e, 0x66, 0x7e, 0x41, 0xa5, 0x77, 0xa3, 0xa0, 0x46, 0xb4, 0x7b,
+	0x03, 0xdb, 0x5d, 0xb0, 0xdb, 0xac, 0x5d, 0x3f, 0xf0, 0x13, 0xfe, 0x83, 0x21, 0x1f, 0x5b, 0x0f,
+	0xc8, 0x00, 0x9a, 0xfa, 0xcf, 0x77, 0x10, 0x19, 0xed, 0x2f, 0xf8, 0x01, 0x92, 0xde, 0xcd, 0xc2,
+	0x3a, 0x29, 0x73, 0xb0, 0x8f, 0xeb, 0x76, 0x87, 0xf5, 0x31, 0x41, 0x8c, 0xb4, 0x97, 0x21, 0x97,
+	0xc4, 0xe9, 0xaf, 0x74, 0x90, 0x5b, 0x9a, 0x70, 0xcc, 0xfd, 0x46, 0x48, 0xef, 0xf6, 0x94, 0x5a,
+	0xd1, 0xd7, 0x6d, 0xec, 0x6b, 0xd9, 0x26, 0xac, 0xaf, 0x3e, 0xe2, 0xc8, 0xdf, 0x08, 0xf9, 0xd8,
+	0x7a, 0xb0, 0xfa, 0x67, 0xf7, 0xa1, 0xae, 0x6e, 0x02, 0x91, 0x1f, 0x43, 0xcb, 0x48, 0xe7, 0x20,
+	0x72, 0x1a, 0x45, 0xd9, 0x1f, 0xbd, 0x5b, 0xc5, 0x95, 0xa2, 0xe3, 0x3b, 0xd8, 0x71, 0x97, 0x2c,
+	0xb1, 0x8e, 0x45, 0x3e, 0xc4, 0x43, 0x4c, 0x7f, 0xe2, 0x4f, 0x97, 0xbc, 0xd2, 0x4e, 0x1c, 0xde,
+	0xd9, 0xad, 0xec, 0x21, 0x60, 0xf4, 0x76, 0x7b, 0x4a, 0xad, 0xe8, 0xee, 0x16, 0x76, 0xb7, 0x44,
+	0x16, 0xf5, 0xee, 0xd4, 0xed, 0x1c, 0x8a, 0xcf, 0x07, 0xe9, 0x3f, 0x60, 0x41, 0x6e, 0xa7, 0x8f,
+	0xbb, 0x14, 0xfc, 0xb0, 0x85, 0x22, 0x91, 0xfc, 0xaf, 0x5b, 0xd8, 0x5d, 0xec, 0x8a, 0x10, 0xdc,
+	0x3e, 0xfd, 0xf7, 0x2b, 0xc8, 0x31, 0x34, 0xb4, 0x77, 0x9e, 0xc9, 0x8d, 0xa9, 0x6f, 0x52, 0xf7,
+	0x7a, 0x45, 0x55, 0x45, 0x53, 0xd1, 0xdb, 0x7f, 0xc8, 0x14, 0xd2, 0x1f, 0x42, 0x5d, 0xbd, 0x1c,
+	0x4c, 0x96, 0xb5, 0x97, 0x9c, 0xf5, 0x97, 0x8e, 0x7b, 0xdd, 0x7c, 0x45, 0x11, 0xf1, 0xe9, 0xad,
+	0x33, 0xe2, 0x7b, 0x09, 0x0d, 0xed, 0x75, 0x60, 0x35, 0x81, 0xfc, 0x0b, 0xc4, 0x6a, 0x02, 0x05,
+	0x8f, 0x09, 0xdb, 0xf3, 0xd8, 0x45, 0x83, 0xd4, 0x91, 0xbe, 0x93, 0xd7, 0x61, 0x4c, 0x76, 0xe1,
+	0xba, 0x38, 0x59, 0x8f, 0xe9, 0x17, 0xd9, 0x86, 0x82, 0xdf, 0x0c, 0x79, 0x64, 0x91, 0x27, 0x50,
+	0x93, 0x8f, 0x40, 0x93, 0xa5, 0xe2, 0xc7, 0xac, 0x7b, 0xcb, 0x39, 0xb8, 0x38, 0x06, 0xbf, 0x0f,
+	0x90, 0x3e, 0x45, 0xac, 0x84, 0x44, 0xee, 0x69, 0x63, 0x45, 0x01, 0xf9, 0x77, 0x8b, 0xed, 0x25,
+	0x9c, 0x60, 0x87, 0xa0, 0x90, 0x08, 0xe8, 0x85, 0x7c, 0xbb, 0xe2, 0x47, 0xd0, 0xd0, 0x5e, 0x23,
+	0x56, 0xcb, 0x97, 0x7f, 0xc9, 0x58, 0x2d, 0x5f, 0xc1, 0xe3, 0xc5, 0x76, 0x0f, 0x5b, 0x5f, 0xb4,
+	0xe7, 0x58, 0xeb, 0xb1, 0x7f, 0x1a, 0x8c, 0x38, 0x02, 0xdb, 0xa0, 0x33, 0x68, 0x19, 0x4f, 0x0e,
+	0x2b, 0x0e, 0x2d, 0x7a, 0xd0, 0x58, 0x71, 0x68, 0xe1, 0x2b, 0xc5, 0x92, 0xce, 0xec, 0x79, 0xd6,
+	0xcf, 0x39, 0xa2, 0x68, 0x3d, 0xfd, 0x00, 0x1a, 0xda, 0xf3, 0xc1, 0x6a, 0x2e, 0xf9, 0x97, 0x8a,
+	0xd5, 0x5c, 0x8a, 0x5e, 0x1b, 0x5e, 0xc4, 0x3e, 0xda, 0x36, 0x92, 0x02, 0xbe, 0x46, 0xc5, 0xda,
+	0xfe, 0x31, 0xb4, 0xcd, 0x07, 0x85, 0x15, 0xef, 0x17, 0x3e, 0x4d, 0xac, 0x78, 0x7f, 0xca, 0x2b,
+	0xc4, 0x82, 0xa4, 0x1f, 0x2c, 0xa8, 0x4e, 0x1e, 0xfe, 0x54, 0x5c, 0x6c, 0xfe, 0x9c, 0x7c, 0x97,
+	0x09, 0x38, 0xf1, 0x4a, 0x1a, 0x59, 0xd6, 0xa8, 0x56, 0x7f, 0x4b, 0x4d, 0xf1, 0x4b, 0xee, 0x41,
+	0x35, 0x93, 0x98, 0xf9, 0x7b, 0x5a, 0xcf, 0x60, 0x41, 0x11, 0xb3, 0x7a, 0xf5, 0x2c, 0x56, 0x73,
+	0x28, 0x7c, 0x5c, 0xad, 0xd7, 0xc9, 0xd6, 0x3e, 0xb2, 0xf8, 0xf1, 0x87, 0x6f, 0x4b, 0x69, 0xc7,
+	0x9f, 0xfe, 0xf0, 0x99, 0x76, 0xfc, 0x19, 0x4f, 0x50, 0x65, 0x8f, 0xbf, 0xc4, 0x67, 0x6d, 0x04,
+	0x30, 0x97, 0xc9, 0x90, 0x55, 0xec, 0x55, 0xfc, 0x88, 0x41, 0xef, 0xce, 0xd5, 0x89, 0xb5, 0xa6,
+	0x28, 0x92, 0xd2, 0xf4, 0xa1, 0x7c, 0x21, 0xe5, 0x0f, 0xa0, 0xa9, 0xbf, 0x83, 0x4a, 0x74, 0x99,
+	0x90, 0xed, 0xe9, 0x66, 0x61, 0x9d, 0x49, 0x25, 0xa4, 0xa9, 0x77, 0x43, 0xbe, 0x07, 0x4b, 0x6a,
+	0x99, 0xf5, 0x44, 0xc9, 0x98, 0xbc, 0x53, 0x90, 0x3e, 0x69, 0x2c, 0xf6, 0x8d, 0xa9, 0xf9, 0x95,
+	0x8f, 0x2c, 0x46, 0x7d, 0xe6, 0x1b, 0x8c, 0xe9, 0xc9, 0x53, 0xf4, 0xf4, 0x64, 0x7a, 0xf2, 0x14,
+	0x3e, 0xdc, 0x28, 0xa9, 0x8f, 0x2c, 0x18, 0x6b, 0xc4, 0xef, 0x6f, 0x91, 0x1f, 0xc0, 0x9c, 0x96,
+	0xd6, 0x7e, 0x78, 0x19, 0xf4, 0x15, 0x27, 0xe5, 0x9f, 0x30, 0xea, 0x15, 0x99, 0xa5, 0xf6, 0x32,
+	0xb6, 0x3f, 0x6f, 0x1b, 0x8b, 0xc3, 0xb8, 0x68, 0x03, 0x1a, 0x7a, 0xca, 0xfc, 0x15, 0xed, 0x2e,
+	0x6b, 0x55, 0xfa, 0xfb, 0x38, 0x8f, 0x2c, 0xb2, 0x0b, 0x9d, 0xec, 0x53, 0x1e, 0x4a, 0xa6, 0x14,
+	0x3d, 0x3f, 0xd2, 0xcb, 0x54, 0x1a, 0x0f, 0x80, 0x90, 0x03, 0x7e, 0x2b, 0x58, 0xfd, 0xb8, 0x46,
+	0x18, 0x65, 0x4f, 0x75, 0xf3, 0x47, 0x37, 0x54, 0x6b, 0x45, 0x3f, 0xb7, 0x72, 0xdf, 0x7a, 0x64,
+	0x91, 0xbf, 0x6b, 0x41, 0xd3, 0x48, 0x90, 0x37, 0xee, 0x58, 0x66, 0xe6, 0xd9, 0xd5, 0xeb, 0xf4,
+	0x89, 0xda, 0x0e, 0x2e, 0xe2, 0xee, 0x83, 0x4f, 0x8c, 0x4d, 0xfa, 0xa9, 0xe1, 0xe9, 0x5d, 0xc9,
+	0xfe, 0xc2, 0xc6, 0xe7, 0x59, 0x04, 0xfd, 0x19, 0xaa, 0xcf, 0x1f, 0x59, 0xe4, 0x9f, 0x58, 0xd0,
+	0x36, 0x43, 0x38, 0x6a, 0xba, 0x85, 0xc1, 0x22, 0x45, 0x4a, 0x53, 0xe2, 0x3e, 0x3f, 0xc0, 0x51,
+	0x1e, 0x3d, 0x70, 0x8c, 0x51, 0x8a, 0xd7, 0x43, 0x7f, 0xbd, 0xd1, 0x92, 0x8f, 0xf9, 0x0f, 0x5e,
+	0xc9, 0xe8, 0x35, 0xc9, 0xff, 0x40, 0x92, 0x22, 0x3f, 0xfd, 0xe7, 0x84, 0x70, 0x13, 0x7e, 0xc4,
+	0x7f, 0x59, 0x42, 0x86, 0x40, 0x19, 0x15, 0xbf, 0xed, 0xf7, 0xf6, 0x3d, 0x9c, 0xd3, 0x1d, 0xfb,
+	0x86, 0x31, 0xa7, 0xac, 0xe2, 0xb1, 0xc6, 0x47, 0x27, 0x7e, 0x09, 0x28, 0x3d, 0x39, 0x73, 0xbf,
+	0x0e, 0x34, 0x7d, 0x90, 0x23, 0x3e, 0x48, 0x81, 0x6e, 0xb0, 0xda, 0x5b, 0x36, 0x63, 0x3f, 0xc0,
+	0xb1, 0xde, 0xb3, 0xdf, 0x99, 0x3a, 0xd6, 0x87, 0x18, 0x88, 0x61, 0x23, 0x3e, 0x00, 0x48, 0x6f,
+	0x9b, 0x90, 0xcc, 0x4d, 0x07, 0x25, 0x80, 0xf2, 0x17, 0x52, 0x4c, 0x7e, 0x96, 0x17, 0x22, 0x58,
+	0x8b, 0x3f, 0xe4, 0xe2, 0x74, 0x47, 0xde, 0x91, 0xd0, 0xb5, 0x2f, 0xf3, 0x4a, 0x88, 0xa1, 0x7d,
+	0x65, 0xdb, 0x37, 0x84, 0xa9, 0xba, 0x70, 0xf1, 0x02, 0x5a, 0xbb, 0x61, 0xf8, 0x6a, 0x32, 0x56,
+	0xd7, 0x1f, 0xcd, 0x18, 0xe9, 0xb6, 0x17, 0x9f, 0xf5, 0x32, 0xb3, 0xb0, 0xef, 0x62, 0x53, 0x3d,
+	0xd2, 0xd5, 0x9a, 0x7a, 0xf8, 0xd3, 0xf4, 0x26, 0xcb, 0xe7, 0xc4, 0x83, 0x79, 0x25, 0xa3, 0xd5,
 	0xc0, 0x7b, 0x66, 0x33, 0x86, 0x64, 0xce, 0x76, 0x61, 0x98, 0x09, 0x72, 0xb4, 0x0f, 0x63, 0xd9,
-	0xe6, 0x23, 0x8b, 0x1c, 0x40, 0x73, 0x93, 0xf6, 0xf1, 0x52, 0x28, 0x06, 0x1a, 0x17, 0x8c, 0x60,
-	0x15, 0x8f, 0x50, 0xf6, 0x5a, 0x06, 0xd0, 0x3c, 0xb7, 0xc6, 0xde, 0x65, 0x44, 0x3f, 0x7b, 0xf8,
-	0x53, 0x11, 0xc2, 0xfc, 0x5c, 0x9e, 0x5b, 0x32, 0xc6, 0x6b, 0x9c, 0x5b, 0x99, 0xa0, 0xb0, 0x71,
-	0x6e, 0xe5, 0x82, 0xc2, 0xc6, 0x52, 0xcb, 0x18, 0x33, 0x19, 0xc2, 0x7c, 0x2e, 0x8e, 0xac, 0x8e,
-	0xac, 0x69, 0xd1, 0xe7, 0xde, 0xdd, 0xe9, 0x15, 0xcc, 0xde, 0x1e, 0x98, 0xbd, 0x1d, 0x42, 0x8b,
-	0x3f, 0x8d, 0x75, 0x4c, 0xf9, 0x7d, 0x8f, 0xcc, 0x2b, 0x0b, 0xfa, 0x6d, 0x92, 0xec, 0x01, 0x83,
-	0x38, 0x53, 0xc3, 0xe1, 0x6f, 0x6c, 0xfe, 0x10, 0x1a, 0xcf, 0x68, 0x22, 0x2f, 0x78, 0x28, 0x1d,
-	0x3b, 0x73, 0xe3, 0xa3, 0x57, 0x70, 0x3f, 0xc4, 0xa4, 0x19, 0x6c, 0xed, 0x21, 0x1d, 0x9c, 0x52,
-	0x2e, 0x9c, 0x5c, 0x7f, 0xf0, 0x39, 0xf9, 0x5d, 0x6c, 0x5c, 0x5d, 0xb7, 0x5b, 0xd2, 0xb2, 0xf5,
-	0xf5, 0xc6, 0xe7, 0x32, 0xf0, 0xa2, 0x96, 0x83, 0x70, 0x40, 0x35, 0x5d, 0x2f, 0x80, 0x86, 0x76,
-	0x5d, 0x57, 0x31, 0x50, 0xfe, 0x7a, 0xb6, 0x62, 0xa0, 0x82, 0xdb, 0xbd, 0xf6, 0x7d, 0xec, 0xc7,
-	0x26, 0x77, 0xd3, 0x7e, 0xf8, 0x8d, 0xde, 0xb4, 0xa7, 0x87, 0x3f, 0xf5, 0x46, 0xc9, 0xe7, 0xe4,
-	0x25, 0x3e, 0x54, 0xab, 0x5f, 0x60, 0x49, 0x8d, 0x86, 0xec, 0x5d, 0x17, 0xb5, 0x58, 0x1a, 0xca,
-	0x34, 0x24, 0x78, 0x57, 0xa8, 0xc9, 0x7d, 0x0b, 0xe0, 0x30, 0x09, 0xc7, 0x9b, 0x1e, 0x1d, 0x85,
-	0x41, 0x2a, 0x6b, 0xd3, 0xeb, 0x13, 0xa9, 0xfc, 0xd2, 0xee, 0x50, 0x90, 0x97, 0x9a, 0x95, 0x65,
-	0xdc, 0x01, 0x92, 0xc4, 0x35, 0xf5, 0x86, 0x85, 0x5a, 0x90, 0x82, 0x5b, 0x16, 0x8f, 0x2c, 0xb2,
-	0x06, 0x90, 0x26, 0x12, 0x28, 0x9b, 0x29, 0x97, 0xa3, 0xa0, 0xc4, 0x5e, 0x41, 0xd6, 0xc1, 0x01,
-	0xd4, 0xd3, 0xb0, 0xeb, 0x72, 0xfa, 0xfa, 0x80, 0x11, 0xa4, 0x55, 0x27, 0x78, 0x2e, 0x18, 0x6a,
-	0x77, 0x70, 0xa9, 0x80, 0xd4, 0xd8, 0x52, 0x61, 0x84, 0xd3, 0x87, 0x05, 0x3e, 0x40, 0xa5, 0x2e,
-	0x61, 0xda, 0xbf, 0x7a, 0x8f, 0x38, 0x1f, 0x90, 0x54, 0xdc, 0x5c, 0x18, 0x4f, 0x33, 0x5c, 0x3f,
-	0x8c, 0x5a, 0xf9, 0x95, 0x03, 0x26, 0x9a, 0x47, 0x30, 0x9f, 0x0b, 0xd1, 0x28, 0x96, 0x9e, 0x16,
-	0x83, 0x53, 0x2c, 0x3d, 0x35, 0xba, 0x63, 0x5f, 0xc7, 0x2e, 0xe7, 0x6c, 0x40, 0x53, 0xef, 0xc2,
-	0x4f, 0xfa, 0x67, 0xac, 0xbb, 0x3f, 0xb2, 0x60, 0xa1, 0x20, 0x02, 0x43, 0xde, 0x95, 0x5e, 0x83,
-	0xa9, 0xd1, 0x99, 0x5e, 0xa1, 0x83, 0xde, 0x3e, 0xc4, 0x7e, 0x9e, 0x93, 0x4f, 0x8d, 0x83, 0x8d,
-	0xfb, 0xc6, 0x05, 0x67, 0x5e, 0xa9, 0x54, 0x14, 0x6a, 0x14, 0x9f, 0xc1, 0x32, 0x1f, 0xc8, 0xda,
-	0x70, 0x98, 0x09, 0x1e, 0xdc, 0xc9, 0xfd, 0x76, 0xac, 0x11, 0x14, 0xe9, 0x4d, 0xff, 0x6d, 0xd9,
-	0x29, 0xea, 0x34, 0x1f, 0x2a, 0x99, 0x40, 0x27, 0xeb, 0x90, 0x27, 0xd3, 0xdb, 0xea, 0xbd, 0x63,
-	0xd8, 0xbf, 0x05, 0x4e, 0xfc, 0xdf, 0xc0, 0xce, 0xde, 0xb1, 0x7b, 0x45, 0xeb, 0xc2, 0x4d, 0x62,
-	0xb6, 0x1f, 0x7f, 0x59, 0x45, 0x0f, 0x32, 0xf3, 0x94, 0x1d, 0x4c, 0x0b, 0x77, 0x28, 0x0b, 0xbc,
-	0x38, 0xf8, 0xf0, 0x1e, 0x76, 0x7f, 0xd7, 0xbe, 0x59, 0xd4, 0x7d, 0xc4, 0x3f, 0xe1, 0xb6, 0xf8,
-	0x72, 0x96, 0xaf, 0xe5, 0x08, 0xee, 0x16, 0xed, 0xf7, 0x54, 0x5b, 0x28, 0xb3, 0xd6, 0xd7, 0x50,
-	0xb7, 0x6b, 0xea, 0xd1, 0x02, 0xc5, 0x3e, 0x05, 0x61, 0x09, 0xc5, 0x3e, 0x45, 0xe1, 0x05, 0x53,
-	0xaf, 0x91, 0x81, 0x85, 0x8f, 0xad, 0x07, 0xeb, 0xef, 0xff, 0xe0, 0x37, 0x4e, 0xfd, 0xe4, 0x6c,
-	0x72, 0xbc, 0xd2, 0x0f, 0x47, 0x0f, 0x87, 0xd2, 0xdb, 0x28, 0xae, 0xc2, 0x3d, 0x1c, 0x06, 0x83,
-	0x87, 0xd8, 0xec, 0xf1, 0x0c, 0xfe, 0xd8, 0xf5, 0x37, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0x18, 0xa4, 0xd2, 0x33, 0x1e, 0x7b, 0x00, 0x00,
+	0xe6, 0x23, 0x8b, 0x1c, 0x40, 0x73, 0x93, 0xf6, 0x31, 0x29, 0x14, 0x03, 0x8d, 0x0b, 0x46, 0xb0,
+	0x8a, 0x47, 0x28, 0x7b, 0x2d, 0x03, 0x68, 0x9e, 0x5b, 0x63, 0xef, 0x32, 0xa2, 0x9f, 0x3d, 0xfc,
+	0xa9, 0x08, 0x61, 0x7e, 0x2e, 0xcf, 0x2d, 0x19, 0xe3, 0x35, 0xce, 0xad, 0x4c, 0x50, 0xd8, 0x38,
+	0xb7, 0x72, 0x41, 0x61, 0x63, 0xa9, 0x65, 0x8c, 0x99, 0x0c, 0x61, 0x3e, 0x17, 0x47, 0x56, 0x47,
+	0xd6, 0xb4, 0xe8, 0x73, 0xef, 0xee, 0x74, 0x04, 0xb3, 0xb7, 0x07, 0x66, 0x6f, 0x87, 0xd0, 0xe2,
+	0x4f, 0x63, 0x1d, 0x53, 0x9e, 0xef, 0x91, 0x79, 0x65, 0x41, 0xcf, 0x26, 0xc9, 0x1e, 0x30, 0x58,
+	0x67, 0x6a, 0x38, 0xfc, 0x8d, 0xcd, 0x1f, 0x42, 0xe3, 0x19, 0x4d, 0x64, 0x82, 0x87, 0xd2, 0xb1,
+	0x33, 0x19, 0x1f, 0xbd, 0x82, 0xfc, 0x10, 0x93, 0x66, 0xb0, 0xb5, 0x87, 0x74, 0x70, 0x4a, 0xb9,
+	0x70, 0x72, 0xfd, 0xc1, 0xe7, 0xe4, 0xf7, 0xb1, 0x71, 0x95, 0x6e, 0xb7, 0xa4, 0xdd, 0xd6, 0xd7,
+	0x1b, 0x9f, 0xcb, 0xc0, 0x8b, 0x5a, 0x0e, 0xc2, 0x01, 0xd5, 0x74, 0xbd, 0x00, 0x1a, 0x5a, 0xba,
+	0xae, 0x62, 0xa0, 0x7c, 0x7a, 0xb6, 0x62, 0xa0, 0x82, 0xec, 0x5e, 0xfb, 0x3e, 0xf6, 0x63, 0x93,
+	0xbb, 0x69, 0x3f, 0x3c, 0xa3, 0x37, 0xed, 0xe9, 0xe1, 0x4f, 0xbd, 0x51, 0xf2, 0x39, 0x79, 0x89,
+	0x0f, 0xd5, 0xea, 0x09, 0x2c, 0xa9, 0xd1, 0x90, 0xcd, 0x75, 0x51, 0x8b, 0xa5, 0x55, 0x99, 0x86,
+	0x04, 0xef, 0x0a, 0x35, 0xb9, 0x6f, 0x02, 0x1c, 0x26, 0xe1, 0x78, 0xd3, 0xa3, 0xa3, 0x30, 0x48,
+	0x65, 0x6d, 0x9a, 0x3e, 0x91, 0xca, 0x2f, 0x2d, 0x87, 0x82, 0xbc, 0xd4, 0xac, 0x2c, 0x23, 0x07,
+	0x48, 0x12, 0xd7, 0xd4, 0x0c, 0x0b, 0xb5, 0x20, 0x05, 0x59, 0x16, 0x8f, 0x2c, 0xb2, 0x06, 0x90,
+	0x5e, 0x24, 0x50, 0x36, 0x53, 0xee, 0x8e, 0x82, 0x12, 0x7b, 0x05, 0xb7, 0x0e, 0x0e, 0xa0, 0x9e,
+	0x86, 0x5d, 0x97, 0xd3, 0xd7, 0x07, 0x8c, 0x20, 0xad, 0x3a, 0xc1, 0x73, 0xc1, 0x50, 0xbb, 0x83,
+	0x4b, 0x05, 0xa4, 0xc6, 0x96, 0x0a, 0x23, 0x9c, 0x3e, 0x2c, 0xf0, 0x01, 0x2a, 0x75, 0x09, 0xaf,
+	0xfd, 0xab, 0xf7, 0x88, 0xf3, 0x01, 0x49, 0xc5, 0xcd, 0x85, 0xf1, 0x34, 0xc3, 0xf5, 0xc3, 0xa8,
+	0x95, 0xa7, 0x1c, 0x30, 0xd1, 0x3c, 0x82, 0xf9, 0x5c, 0x88, 0x46, 0xb1, 0xf4, 0xb4, 0x18, 0x9c,
+	0x62, 0xe9, 0xa9, 0xd1, 0x1d, 0xfb, 0x3a, 0x76, 0x39, 0x67, 0x03, 0x9a, 0x7a, 0x17, 0x7e, 0xd2,
+	0x3f, 0x63, 0xdd, 0xfd, 0xb1, 0x05, 0x0b, 0x05, 0x11, 0x18, 0xf2, 0xae, 0xf4, 0x1a, 0x4c, 0x8d,
+	0xce, 0xf4, 0x0a, 0x1d, 0xf4, 0xf6, 0x21, 0xf6, 0xf3, 0x9c, 0x7c, 0x6a, 0x1c, 0x6c, 0xdc, 0x37,
+	0x2e, 0x38, 0xf3, 0x4a, 0xa5, 0xa2, 0x50, 0xa3, 0xf8, 0x0c, 0x96, 0xf9, 0x40, 0xd6, 0x86, 0xc3,
+	0x4c, 0xf0, 0xe0, 0x4e, 0xee, 0x47, 0x71, 0x8d, 0xa0, 0x48, 0x6f, 0xfa, 0x8f, 0xe6, 0x4e, 0x51,
+	0xa7, 0xf9, 0x50, 0xc9, 0x04, 0x3a, 0x59, 0x87, 0x3c, 0x99, 0xde, 0x56, 0xef, 0x1d, 0xc3, 0xfe,
+	0x2d, 0x70, 0xe2, 0x7f, 0x19, 0x3b, 0x7b, 0xc7, 0xee, 0x15, 0xad, 0x0b, 0x37, 0x89, 0xd9, 0x7e,
+	0xfc, 0x65, 0x15, 0x3d, 0xc8, 0xcc, 0x53, 0x76, 0x30, 0x2d, 0xdc, 0xa1, 0x2c, 0xf0, 0xe2, 0xe0,
+	0xc3, 0x7b, 0xd8, 0xfd, 0x5d, 0xfb, 0x66, 0x51, 0xf7, 0x11, 0xff, 0x84, 0xdb, 0xe2, 0xcb, 0x59,
+	0xbe, 0x96, 0x23, 0xb8, 0x5b, 0xb4, 0xdf, 0x53, 0x6d, 0xa1, 0xcc, 0x5a, 0x5f, 0x43, 0xdd, 0xae,
+	0xa9, 0x47, 0x0b, 0x14, 0xfb, 0x14, 0x84, 0x25, 0x14, 0xfb, 0x14, 0x85, 0x17, 0x4c, 0xbd, 0x46,
+	0x06, 0x16, 0x3e, 0xb6, 0x1e, 0xac, 0xbf, 0xff, 0x83, 0x2f, 0x9f, 0xfa, 0xc9, 0xd9, 0xe4, 0x78,
+	0xa5, 0x1f, 0x8e, 0x1e, 0x0e, 0xa5, 0xb7, 0x51, 0xa4, 0xc2, 0x3d, 0x1c, 0x06, 0x83, 0x87, 0xd8,
+	0xec, 0xf1, 0x0c, 0xfe, 0x8a, 0xf7, 0xd7, 0xff, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb7, 0x6d,
+	0x27, 0xff, 0xf7, 0x7b, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/lnrpc/rpc.proto b/lnrpc/rpc.proto
index 37a68dc2cd..8e48440be8 100644
--- a/lnrpc/rpc.proto
+++ b/lnrpc/rpc.proto
@@ -1430,6 +1430,29 @@ message ChannelCloseSummary {
 
     /// Details on how the channel was closed.
     ClosureType close_type = 10 [json_name = "close_type"];
+
+    enum Initiator {
+        UNKNOWN = 0;
+        LOCAL = 1;
+        REMOTE = 2;
+        BOTH = 3;
+    }
+
+    /**
+    Open initiator is the party that initiated opening the channel. Note that
+    this value may be unknown if the channel was closed before we migrated to
+    store open channel information after close.
+    */
+    Initiator open_initiator = 11 [json_name = "open_initiator"];
+
+    /**
+    Close initiator indicates which party initiated the close. This value will
+    be unknown for channels that were cooperatively closed before we started
+    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.
+    */
+    Initiator close_initiator = 12 [json_name = "close_initiator"];
 }
 
 message ClosedChannelsRequest {
diff --git a/lnrpc/rpc.swagger.json b/lnrpc/rpc.swagger.json
index 701d43ccf2..d4c2af0e36 100644
--- a/lnrpc/rpc.swagger.json
+++ b/lnrpc/rpc.swagger.json
@@ -1461,6 +1461,16 @@
       ],
       "default": "COOPERATIVE_CLOSE"
     },
+    "ChannelCloseSummaryInitiator": {
+      "type": "string",
+      "enum": [
+        "UNKNOWN",
+        "LOCAL",
+        "REMOTE",
+        "BOTH"
+      ],
+      "default": "UNKNOWN"
+    },
     "ChannelEventUpdateUpdateType": {
       "type": "string",
       "enum": [
@@ -2059,6 +2069,14 @@
         "close_type": {
           "$ref": "#/definitions/ChannelCloseSummaryClosureType",
           "description": "/ Details on how the channel was closed."
+        },
+        "open_initiator": {
+          "$ref": "#/definitions/ChannelCloseSummaryInitiator",
+          "description": "*\nOpen initiator is the party that initiated opening the channel. Note that\nthis value may be unknown if the channel was closed before we migrated to\nstore open channel information after close."
+        },
+        "close_initiator": {
+          "$ref": "#/definitions/ChannelCloseSummaryInitiator",
+          "description": "*\nClose 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."
         }
       }
     },

From e74b6f88b76334ad9185f70fb2216a086efa0f1a Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:24:24 +0200
Subject: [PATCH 7/8] rpcserver: display open and close initiator

---
 rpcserver.go | 104 ++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 99 insertions(+), 5 deletions(-)

diff --git a/rpcserver.go b/rpcserver.go
index 305ddc95c0..a653741ef7 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -2922,7 +2922,11 @@ func (r *rpcServer) ClosedChannels(ctx context.Context,
 			}
 		}
 
-		channel := createRPCClosedChannel(dbChannel)
+		channel, err := r.createRPCClosedChannel(dbChannel)
+		if err != nil {
+			return nil, err
+		}
+
 		resp.Channels = append(resp.Channels, channel)
 	}
 
@@ -3137,13 +3141,29 @@ func createRPCOpenChannel(r *rpcServer, graph *channeldb.ChannelGraph,
 
 // createRPCClosedChannel creates an *lnrpc.ClosedChannelSummary from a
 // *channeldb.ChannelCloseSummary.
-func createRPCClosedChannel(
-	dbChannel *channeldb.ChannelCloseSummary) *lnrpc.ChannelCloseSummary {
+func (r *rpcServer) createRPCClosedChannel(
+	dbChannel *channeldb.ChannelCloseSummary) (*lnrpc.ChannelCloseSummary, error) {
 
 	nodePub := dbChannel.RemotePub
 	nodeID := hex.EncodeToString(nodePub.SerializeCompressed())
 
-	var closeType lnrpc.ChannelCloseSummary_ClosureType
+	var (
+		closeType      lnrpc.ChannelCloseSummary_ClosureType
+		openInit       lnrpc.ChannelCloseSummary_Initiator
+		closeInitiator lnrpc.ChannelCloseSummary_Initiator
+		err            error
+	)
+
+	// Lookup local and remote cooperative initiators. If these values
+	// are not known they will just return unknown.
+	openInit, closeInitiator, err = r.getInitiators(
+		&dbChannel.ChanPoint,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	// Convert the close type to rpc type.
 	switch dbChannel.CloseType {
 	case channeldb.CooperativeClose:
 		closeType = lnrpc.ChannelCloseSummary_COOPERATIVE_CLOSE
@@ -3170,7 +3190,75 @@ func createRPCClosedChannel(
 		TimeLockedBalance: int64(dbChannel.TimeLockedBalance),
 		ChainHash:         dbChannel.ChainHash.String(),
 		ClosingTxHash:     dbChannel.ClosingTXID.String(),
+		OpenInitiator:     openInit,
+		CloseInitiator:    closeInitiator,
+	}, nil
+}
+
+// getInitiators returns an initiator enum that provides information about the
+// party that initiated channel's open and close. This information is obtained
+// from the historical channel bucket, so unknown values are returned when the
+// channel is not present (which indicates that it was closed before we started
+// writing channels to the historical close bucket).
+func (r *rpcServer) getInitiators(chanPoint *wire.OutPoint) (
+	lnrpc.ChannelCloseSummary_Initiator,
+	lnrpc.ChannelCloseSummary_Initiator, error) {
+
+	var (
+		openInitiator  = lnrpc.ChannelCloseSummary_UNKNOWN
+		closeInitiator = lnrpc.ChannelCloseSummary_UNKNOWN
+	)
+
+	// To get the close initiator for cooperative closes, we need
+	// to get the channel status from the historical channel bucket.
+	histChan, err := r.server.chanDB.FetchHistoricalChannel(chanPoint)
+	switch {
+	// The node has upgraded from a version where we did not store
+	// historical channels, and has not closed a channel since. Do
+	// not return an error, initiator values are unknown.
+	case err == channeldb.ErrNoHistoricalBucket:
+		return openInitiator, closeInitiator, nil
+
+	// The channel was closed before we started storing historical
+	// channels. Do  not return an error, initiator values are unknown.
+	case err == channeldb.ErrChannelNotFound:
+		return openInitiator, closeInitiator, nil
+
+	case err != nil:
+		return 0, 0, err
+	}
+
+	// If we successfully looked up the channel, determine initiator based
+	// on channels status.
+	if histChan.IsInitiator {
+		openInitiator = lnrpc.ChannelCloseSummary_LOCAL
+	} else {
+		openInitiator = lnrpc.ChannelCloseSummary_REMOTE
+	}
+
+	localInit := histChan.HasChanStatus(
+		channeldb.ChanStatusLocalCloseInitiator,
+	)
+
+	remoteInit := histChan.HasChanStatus(
+		channeldb.ChanStatusRemoteCloseInitiator,
+	)
+
+	switch {
+	// There is a possible case where closes were attempted by both parties.
+	// We return the initiator as both in this case to provide full
+	// information about the close.
+	case localInit && remoteInit:
+		closeInitiator = lnrpc.ChannelCloseSummary_BOTH
+
+	case localInit:
+		closeInitiator = lnrpc.ChannelCloseSummary_LOCAL
+
+	case remoteInit:
+		closeInitiator = lnrpc.ChannelCloseSummary_REMOTE
 	}
+
+	return openInitiator, closeInitiator, nil
 }
 
 // SubscribeChannelEvents returns a uni-directional stream (server -> client)
@@ -3222,7 +3310,13 @@ func (r *rpcServer) SubscribeChannelEvents(req *lnrpc.ChannelEventSubscription,
 				}
 
 			case channelnotifier.ClosedChannelEvent:
-				closedChannel := createRPCClosedChannel(event.CloseSummary)
+				closedChannel, err := r.createRPCClosedChannel(
+					event.CloseSummary,
+				)
+				if err != nil {
+					return err
+				}
+
 				update = &lnrpc.ChannelEventUpdate{
 					Type: lnrpc.ChannelEventUpdate_CLOSED_CHANNEL,
 					Channel: &lnrpc.ChannelEventUpdate_ClosedChannel{

From b3e6395635f1e674a88b19e660ae12588304e9cb Mon Sep 17 00:00:00 2001
From: carla <kirkcohenc@gmail.com>
Date: Fri, 21 Feb 2020 13:24:24 +0200
Subject: [PATCH 8/8] lntest: check close initiator in basic channel itest

Update channel updates and subscription itest to check that close
initiator is appropriately set for cooperative and force closes for the
local and remote party.
---
 lntest/itest/lnd_test.go | 65 ++++++++++++++++++++++++----------------
 1 file changed, 40 insertions(+), 25 deletions(-)

diff --git a/lntest/itest/lnd_test.go b/lntest/itest/lnd_test.go
index c18b60d9a8..665426a30f 100644
--- a/lntest/itest/lnd_test.go
+++ b/lntest/itest/lnd_test.go
@@ -6382,7 +6382,8 @@ func subscribeChannelNotifications(ctxb context.Context, t *harnessTest,
 // verifyCloseUpdate is used to verify that a closed channel update is of the
 // expected type.
 func verifyCloseUpdate(chanUpdate *lnrpc.ChannelEventUpdate,
-	force bool, forceType lnrpc.ChannelCloseSummary_ClosureType) error {
+	closeType lnrpc.ChannelCloseSummary_ClosureType,
+	closeInitiator lnrpc.ChannelCloseSummary_Initiator) error {
 
 	// We should receive one inactive and one closed notification
 	// for each channel.
@@ -6401,23 +6402,19 @@ func verifyCloseUpdate(chanUpdate *lnrpc.ChannelEventUpdate,
 				chanUpdate.Type)
 		}
 
-		switch force {
-		case true:
-			if update.ClosedChannel.CloseType != forceType {
-				return fmt.Errorf("channel closure type mismatch: "+
-					"expected %v, got %v",
-					forceType,
-					update.ClosedChannel.CloseType)
-			}
-		case false:
-			if update.ClosedChannel.CloseType !=
-				lnrpc.ChannelCloseSummary_COOPERATIVE_CLOSE {
-				return fmt.Errorf("channel closure type "+
-					"mismatch: expected %v, got %v",
-					lnrpc.ChannelCloseSummary_COOPERATIVE_CLOSE,
-					update.ClosedChannel.CloseType)
-			}
+		if update.ClosedChannel.CloseType != closeType {
+			return fmt.Errorf("channel closure type "+
+				"mismatch: expected %v, got %v",
+				closeType,
+				update.ClosedChannel.CloseType)
 		}
+
+		if update.ClosedChannel.CloseInitiator != closeInitiator {
+			return fmt.Errorf("expected close intiator: %v, got: %v",
+				closeInitiator,
+				update.ClosedChannel.CloseInitiator)
+		}
+
 	default:
 		return fmt.Errorf("channel update channel of wrong type, "+
 			"expected closed channel, got %T",
@@ -6529,18 +6526,29 @@ func testBasicChannelCreationAndUpdates(net *lntest.NetworkHarness, t *harnessTe
 	// verifyCloseUpdatesReceived is used to verify that Alice and Bob
 	// receive the correct channel updates in order.
 	verifyCloseUpdatesReceived := func(sub channelSubscription,
-		forceType lnrpc.ChannelCloseSummary_ClosureType) error {
+		forceType lnrpc.ChannelCloseSummary_ClosureType,
+		closeInitiator lnrpc.ChannelCloseSummary_Initiator) error {
 
 		// Ensure one inactive and one closed notification is received for each
 		// closed channel.
 		numChannelUpds := 0
 		for numChannelUpds < 2*numChannels {
-			// Every other channel should be force closed.
+			expectedCloseType := lnrpc.ChannelCloseSummary_COOPERATIVE_CLOSE
+
+			// Every other channel should be force closed. If this
+			// channel was force closed, set the expected close type
+			// the the type passed in.
 			force := (numChannelUpds/2)%2 == 0
+			if force {
+				expectedCloseType = forceType
+			}
 
 			select {
 			case chanUpdate := <-sub.updateChan:
-				err := verifyCloseUpdate(chanUpdate, force, forceType)
+				err := verifyCloseUpdate(
+					chanUpdate, expectedCloseType,
+					closeInitiator,
+				)
 				if err != nil {
 					return err
 				}
@@ -6549,9 +6557,10 @@ func testBasicChannelCreationAndUpdates(net *lntest.NetworkHarness, t *harnessTe
 			case err := <-sub.errChan:
 				return err
 			case <-time.After(time.Second * 10):
-				return fmt.Errorf("timeout waiting for channel "+
-					"notifications, only received %d/%d "+
-					"chanupds", numChannelUpds, 2*numChannels)
+				return fmt.Errorf("timeout waiting "+
+					"for channel notifications, only "+
+					"received %d/%d chanupds",
+					numChannelUpds, 2*numChannels)
 			}
 		}
 
@@ -6560,15 +6569,21 @@ func testBasicChannelCreationAndUpdates(net *lntest.NetworkHarness, t *harnessTe
 
 	// Verify Bob receives all closed channel notifications. He should
 	// receive a remote force close notification for force closed channels.
+	// All channels (cooperatively and force closed) should have a remote
+	// close initiator because Alice closed the channels.
 	if err := verifyCloseUpdatesReceived(bobChanSub,
-		lnrpc.ChannelCloseSummary_REMOTE_FORCE_CLOSE); err != nil {
+		lnrpc.ChannelCloseSummary_REMOTE_FORCE_CLOSE,
+		lnrpc.ChannelCloseSummary_REMOTE); err != nil {
 		t.Fatalf("errored verifying close updates: %v", err)
 	}
 
 	// Verify Alice receives all closed channel notifications. She should
 	// receive a remote force close notification for force closed channels.
+	// All channels (cooperatively and force closed) should have a local
+	// close initiator because Alice closed the channels.
 	if err := verifyCloseUpdatesReceived(aliceChanSub,
-		lnrpc.ChannelCloseSummary_LOCAL_FORCE_CLOSE); err != nil {
+		lnrpc.ChannelCloseSummary_LOCAL_FORCE_CLOSE,
+		lnrpc.ChannelCloseSummary_LOCAL); err != nil {
 		t.Fatalf("errored verifying close updates: %v", err)
 	}
 }