Repository: lightningnetwork/lnd
Pull request #3365 (2019-08-01 03:31:40)

multi: implement new safu commitment format 
In this PR, we implement the current working draft of the new safu commitment format (has no tweak for the remote party's output in your commitment transaction). In short, once we roll this out, once a channel is closed by the remote party, the funds will go _directly_ into an output that you control, so there's no need for any additional action. This essentially replaces the existing DLP protocol (we still need to understand it for old nodes though), as we no longer need the remote party's last unrevoked commitment point. 

This is still labeled as **WIP**, [as the current spec draft is missing some necessary signalling cut outs](https://github.com/lightningnetwork/lightning-rfc/pull/642/files#r309489446). Beyond that, I still need to update the integration tests to cover the new format (and still the old), and possibly a debug build flag guarded RPC to force the old format. 

On the topic of how this affects our current SCB scheme, the short answer is that it only _kinda_ does. With the change in this PR, the existing SCB files in the wild can be used with new channels, with the caveat that we'll still sweep the funds into our wallet, although we don't need to. In order to cut down on this extra transaction, we can instead add the commitment key (as an address) into a sort of _look aside_ while we undergo our regular scan for keys on chain during the recovery process. I say "look aside" as we don't generate keys from the key family we use to generate commitment keys in the normal process, and it isn't expected that they'll be used in order. Therefore, we'll provide these addresses as hints, distinct from the normal look ahead process. This allows us to pick up these funds during the normal recovery process.

At a later time, we can then update the regular on-chain recovery process to also scan for these commitment keys as normal. However, it's likely that it won't locate all the funds since we can't really expect them to be used in order (you don't FIFO close your channels, it's more arbitrary).

**NOTE**: the PR as a whole mostly calls this new format "tweakless" commitments, but upon reflection I find that it isn't very descriptive since it requires you to know low level details w.r.t how the scripts are constructed. IMO "safu commitments" is gets the point across a bit better, and it's more meme-y to boot, which may promote users to update sooner to this new version: "dude, you're not using safu commitments?! wot??". 

Roasbeef: Also the commits were crafted knowing that some of them don't build in isolation, as otherwise I would've had to commit the bulk of the PR in a single commit. IMO this is undesirable, as there're portions that need to be reviewed in isolation, and having them be distinct commits creates a guide for the reviewer. 
cfromknecht: we may also need a way of signaling to the client whether the channel is tweakless or not, since we assume that it's tweaked here https://github.com/lightningnetwork/lnd/blob/a53323205ca95c2ffa8af6ada41a45798f0d22a0/watchtower/wtclient/backup_task.go#L90
Roasbeef: Responded to the initial set of comments, and added commits to update the brar logic, as well as the tower logic. Still need to update the itests (I have a format I used in #3362 that I think will work well), and then also add a new funding flag to allow negotiation at funding flow time. 
Roasbeef: > This is a big pr and therefore costly to review and re-review. A split would have been great, but that it is probably impossible. 

Yeah it's difficult given that how a commitment is constructed touches so many other areas :/ 

FWIW, most of the diff is tests, and I even left out a few additional modifications that _could_ have been made within the tests, just to make the diff smaller. I plan to make these additional modifications either during the rc phase of 0.8 or afterwards, just to make sure that we're testing as many scenarios as is possible given the current testing infrastructure in the project. 

> and ensuring every commit builds and ideally also passes tests

This can be difficult as a simple change like adding an extra arg to some spending utils, or updating the funding flow for awareness touch so many related sub-systems, that the entire PR would end up just being a handful of much larger commits. There's a tradeoff between build-ability and test alway executing (if the OP desires that) and commit size. 

> Besides that, my main question is whether more groundwork should be laid down in this PR for the next commitment format change (possibly anchor outputs). In this PR we move from a single format to two formats that are often distinguished in if/else constructs or using a tweak boolean.

I usually use switch statements ;)

As for the next planned update, we split things off so we could ship things more quickly to cover our users, ideally in this release. As far as future ground work, we have the current `lncfg` based build flags for testing infrastructure. We'll also add a new channel type (which already exists), which similar to this PR will be checked to ensure we construct the commitment properly. Rather than modify an _existing_ output, the new change will add _new_ outputs, so much of the code will be touching weight estimates, and commitment transaction construction/verification. This also won't affect breach logic, DLP logic, or tower logic like this PR did. 
Roasbeef: >  In this PR we move from a single format to two formats that are often distinguished in if/else constructs or using a tweak boolean. Many of those will probably need to be revised when the third format is added, resulting in another big diff. 

Conditional logic based on the existence of this new output type will touch mostly distinct codepaths from what's modified here. The bigger areas of impact will be fee estimation, broadcasting, and also likely some sweeper components. In short I expect that PR to be much larger than this core PR. 
joostjager: > > and ensuring every commit builds and ideally also passes tests
> 
> This can be difficult as a simple change like adding an extra arg to some spending utils, or updating the funding flow for awareness touch so many related sub-systems, that the entire PR would end up just being a handful of much larger commits. There's a tradeoff between build-ability and test properly executing (if the OP desires that) and commit size.

I don't think that it requires much to get the stack of commits in this PR building and I also don't think you need to end up with fewer commits. I looked at a few failing ones and it is mainly just a missing parameter. Having all the commits passing build allows to do `git bisect run`. I quite often use this to efficiently reduce the change set in which to look for a problem. If you'd reorganize the commits so that opening and accepting staticremotekey channels is added in one of the last, every commit would even still be a fully functioning version on its own. First all the preparatory steps are taken to commit by commit support the new tx format in all sub systems and finally it is enabled.
 
> As for the next planned update, we split things off so we could ship things more quickly to cover our users, ideally in this release. As far as future ground work, we have the current `lncfg` based build flags for testing infrastructure. We'll also add a new channel type (which already exists), which similar to this PR will be checked to ensure we construct the commitment properly. Rather than modify an _existing_ output, the new change will add _new_ outputs, so much of the code will be touching weight estimates, and commitment transaction construction/verification. This also won't affect breach logic, DLP logic, or tower logic like this PR did.

I had this idea where there would be an object that contains everything that is specific to a particular commitment tx type. This object would have an interface through which it is used by the rest of the system. Adding new commitment formats would require the creation of a new type that implements this interface. 

Patch:
diff --git a/breacharbiter.go b/breacharbiter.go
index fce38289d..6584cc17b 100644
--- a/breacharbiter.go
+++ b/breacharbiter.go
@@ -944,17 +944,24 @@ func newRetributionInfo(chanPoint *wire.OutPoint,
 
 	// First, record the breach information for the local channel point if
 	// it is not considered dust, which is signaled by a non-nil sign
-	// descriptor. Here we use CommitmentNoDelay since this output belongs
-	// to us and has no time-based constraints on spending.
+	// descriptor. Here we use CommitmentNoDelay (or
+	// CommitmentNoDelayTweakless for newer commitments) since this output
+	// belongs to us and has no time-based constraints on spending.
 	if breachInfo.LocalOutputSignDesc != nil {
+		witnessType := input.CommitmentNoDelay
+		if breachInfo.LocalOutputSignDesc.SingleTweak == nil {
+			witnessType = input.CommitSpendNoDelayTweakless
+		}
+
 		localOutput := makeBreachedOutput(
 			&breachInfo.LocalOutpoint,
-			input.CommitmentNoDelay,
+			witnessType,
 			// No second level script as this is a commitment
 			// output.
 			nil,
 			breachInfo.LocalOutputSignDesc,
-			breachInfo.BreachHeight)
+			breachInfo.BreachHeight,
+		)
 
 		breachedOutputs = append(breachedOutputs, localOutput)
 	}
@@ -972,7 +979,8 @@ func newRetributionInfo(chanPoint *wire.OutPoint,
 			// output.
 			nil,
 			breachInfo.RemoteOutputSignDesc,
-			breachInfo.BreachHeight)
+			breachInfo.BreachHeight,
+		)
 
 		breachedOutputs = append(breachedOutputs, remoteOutput)
 	}
@@ -1048,6 +1056,8 @@ func (b *breachArbiter) createJusticeTx(
 		// type is unrecognized, we will omit it from the transaction.
 		var witnessWeight int
 		switch inp.WitnessType() {
+		case input.CommitSpendNoDelayTweakless:
+			fallthrough
 		case input.CommitmentNoDelay:
 			witnessWeight = input.P2WKHWitnessSize
 
diff --git a/chanbackup/single.go b/chanbackup/single.go
index 83ddcb173..1bfb49ca3 100644
--- a/chanbackup/single.go
+++ b/chanbackup/single.go
@@ -21,11 +21,16 @@ import (
 type SingleBackupVersion byte
 
 const (
-	// DefaultSingleVersion is the defautl version of the single channel
-	// backup. The seralized version of this static channel backup is
+	// DefaultSingleVersion is the default version of the single channel
+	// backup. The serialized version of this static channel backup is
 	// simply: version || SCB. Where SCB is the known format of the
 	// version.
 	DefaultSingleVersion = 0
+
+	// TweaklessCommitVersion is the second SCB version. This version
+	// implicitly denotes that this channel uses the new tweakless commit
+	// format.
+	TweaklessCommitVersion = 1
 )
 
 // Single is a static description of an existing channel that can be used for
@@ -121,8 +126,7 @@ func NewSingle(channel *channeldb.OpenChannel,
 	// key.
 	_, shaChainPoint := btcec.PrivKeyFromBytes(btcec.S256(), b.Bytes())
 
-	return Single{
-		Version:         DefaultSingleVersion,
+	single := Single{
 		IsInitiator:     channel.IsInitiator,
 		ChainHash:       channel.ChainHash,
 		FundingOutpoint: channel.FundingOutpoint,
@@ -139,6 +143,14 @@ func NewSingle(channel *channeldb.OpenChannel,
 			},
 		},
 	}
+
+	if channel.ChanType.IsTweakless() {
+		single.Version = TweaklessCommitVersion
+	} else {
+		single.Version = DefaultSingleVersion
+	}
+
+	return single
 }
 
 // Serialize attempts to write out the serialized version of the target
@@ -148,6 +160,7 @@ func (s *Single) Serialize(w io.Writer) error {
 	// we're aware of.
 	switch s.Version {
 	case DefaultSingleVersion:
+	case TweaklessCommitVersion:
 	default:
 		return fmt.Errorf("unable to serialize w/ unknown "+
 			"version: %v", s.Version)
@@ -305,6 +318,7 @@ func (s *Single) Deserialize(r io.Reader) error {
 
 	switch s.Version {
 	case DefaultSingleVersion:
+	case TweaklessCommitVersion:
 	default:
 		return fmt.Errorf("unable to de-serialize w/ unknown "+
 			"version: %v", s.Version)
diff --git a/channeldb/channel.go b/channeldb/channel.go
index 8b5d5253b..7bc9e4806 100644
--- a/channeldb/channel.go
+++ b/channeldb/channel.go
@@ -135,14 +135,31 @@ const (
 
 	// SingleFunder represents a channel wherein one party solely funds the
 	// entire capacity of the channel.
-	SingleFunder = 0
+	SingleFunder ChannelType = 0
 
 	// DualFunder represents a channel wherein both parties contribute
 	// funds towards the total capacity of the channel. The channel may be
 	// funded symmetrically or asymmetrically.
-	DualFunder = 1
+	DualFunder ChannelType = 1
+
+	// SingleFunderTweakless is similar to the basic SingleFunder channel
+	// type, but it omits the tweak for one's key in the commitment
+	// transaction of the remote party.
+	SingleFunderTweakless ChannelType = 2
 )
 
+// IsSingleFunder returns true if the channel type if one of the known single
+// funder variants.
+func (c ChannelType) IsSingleFunder() bool {
+	return c == SingleFunder || c == SingleFunderTweakless
+}
+
+// IsTweakless returns true if the target channel uses a commitment that
+// doesn't tweak the key for the remote party.
+func (c ChannelType) IsTweakless() bool {
+	return c == SingleFunderTweakless
+}
+
 // ChannelConstraints represents a set of constraints meant to allow a node to
 // limit their exposure, enact flow control and ensure that all HTLCs are
 // economically relevant. This struct will be mirrored for both sides of the
@@ -852,6 +869,14 @@ func (c *OpenChannel) ChanSyncMsg() (*lnwire.ChannelReestablish, error) {
 	// allowing us to sweep our funds.
 	if c.hasChanStatus(ChanStatusRestored) {
 		currentCommitSecret[0] ^= 1
+
+		// If this is a tweakless channel, then we'll purposefully send
+		// a next local height taht's invalid to trigger a force close
+		// on their end. We do this as tweakless channels don't require
+		// that the commitment point is valid, only that it's present.
+		if c.ChanType.IsTweakless() {
+			nextLocalCommitHeight = 0
+		}
 	}
 
 	return &lnwire.ChannelReestablish{
@@ -2506,7 +2531,7 @@ func putChanInfo(chanBucket *bbolt.Bucket, channel *OpenChannel) error {
 	}
 
 	// For single funder channels that we initiated, write the funding txn.
-	if channel.ChanType == SingleFunder && channel.IsInitiator &&
+	if channel.ChanType.IsSingleFunder() && channel.IsInitiator &&
 		!channel.hasChanStatus(ChanStatusRestored) {
 
 		if err := WriteElement(&w, channel.FundingTxn); err != nil {
@@ -2628,7 +2653,7 @@ func fetchChanInfo(chanBucket *bbolt.Bucket, channel *OpenChannel) error {
 	}
 
 	// For single funder channels that we initiated, read the funding txn.
-	if channel.ChanType == SingleFunder && channel.IsInitiator &&
+	if channel.ChanType.IsSingleFunder() && channel.IsInitiator &&
 		!channel.hasChanStatus(ChanStatusRestored) {
 
 		if err := ReadElement(r, &channel.FundingTxn); err != nil {
diff --git a/chanrestore.go b/chanrestore.go
index f771f91ba..50ab9efd1 100644
--- a/chanrestore.go
+++ b/chanrestore.go
@@ -83,9 +83,23 @@ func (c *chanDBRestorer) openChannelShell(backup chanbackup.Single) (
 		return nil, fmt.Errorf("unable to derive htlc key: %v", err)
 	}
 
+	var chanType channeldb.ChannelType
+	switch backup.Version {
+
+	case chanbackup.DefaultSingleVersion:
+		chanType = channeldb.SingleFunder
+
+	case chanbackup.TweaklessCommitVersion:
+		chanType = channeldb.SingleFunderTweakless
+
+	default:
+		return nil, fmt.Errorf("unknown Single version: %v", err)
+	}
+
 	chanShell := channeldb.ChannelShell{
 		NodeAddrs: backup.Addresses,
 		Chan: &channeldb.OpenChannel{
+			ChanType:                chanType,
 			ChainHash:               backup.ChainHash,
 			IsInitiator:             backup.IsInitiator,
 			Capacity:                backup.Capacity,
diff --git a/contractcourt/chain_watcher.go b/contractcourt/chain_watcher.go
index 3d13c9229..7ea3da142 100644
--- a/contractcourt/chain_watcher.go
+++ b/contractcourt/chain_watcher.go
@@ -331,7 +331,7 @@ func (c *chainWatcher) SubscribeChannelEvents() *ChainEventSubscription {
 // based off of only the set of outputs included.
 func isOurCommitment(localChanCfg, remoteChanCfg channeldb.ChannelConfig,
 	commitSpend *chainntnfs.SpendDetail, broadcastStateNum uint64,
-	revocationProducer shachain.Producer) (bool, error) {
+	revocationProducer shachain.Producer, tweakless bool) (bool, error) {
 
 	// First, we'll re-derive our commitment point for this state since
 	// this is what we use to randomize each of the keys for this state.
@@ -344,14 +344,15 @@ func isOurCommitment(localChanCfg, remoteChanCfg channeldb.ChannelConfig,
 	// Now that we have the commit point, we'll derive the tweaked local
 	// and remote keys for this state. We use our point as only we can
 	// revoke our own commitment.
-	localDelayBasePoint := localChanCfg.DelayBasePoint.PubKey
-	localDelayKey := input.TweakPubKey(localDelayBasePoint, commitPoint)
-	remoteNonDelayPoint := remoteChanCfg.PaymentBasePoint.PubKey
-	remotePayKey := input.TweakPubKey(remoteNonDelayPoint, commitPoint)
+	commitKeyRing := lnwallet.DeriveCommitmentKeys(
+		commitPoint, true, tweakless, &localChanCfg, &remoteChanCfg,
+	)
 
 	// With the keys derived, we'll construct the remote script that'll be
 	// present if they have a non-dust balance on the commitment.
-	remotePkScript, err := input.CommitScriptUnencumbered(remotePayKey)
+	remotePkScript, err := input.CommitScriptUnencumbered(
+		commitKeyRing.NoDelayKey,
+	)
 	if err != nil {
 		return false, err
 	}
@@ -359,11 +360,9 @@ func isOurCommitment(localChanCfg, remoteChanCfg channeldb.ChannelConfig,
 	// Next, we'll derive our script that includes the revocation base for
 	// the remote party allowing them to claim this output before the CSV
 	// delay if we breach.
-	revocationKey := input.DeriveRevocationPubkey(
-		remoteChanCfg.RevocationBasePoint.PubKey, commitPoint,
-	)
 	localScript, err := input.CommitScriptToSelf(
-		uint32(localChanCfg.CsvDelay), localDelayKey, revocationKey,
+		uint32(localChanCfg.CsvDelay), commitKeyRing.DelayKey,
+		commitKeyRing.RevocationKey,
 	)
 	if err != nil {
 		return false, err
@@ -423,6 +422,11 @@ func (c *chainWatcher) closeObserver(spendNtfn *chainntnfs.SpendEvent) {
 		// revoked state...!!!
 		commitTxBroadcast := commitSpend.SpendingTx
 
+		// An additional piece of information we need to properly
+		// dispatch a close event if is this channel was using the
+		// tweakless remove key format or not.
+		tweaklessCommit := c.cfg.chanState.ChanType.IsTweakless()
+
 		localCommit, remoteCommit, err := c.cfg.chanState.LatestCommitments()
 		if err != nil {
 			log.Errorf("Unable to fetch channel state for "+
@@ -480,6 +484,7 @@ func (c *chainWatcher) closeObserver(spendNtfn *chainntnfs.SpendEvent) {
 			c.cfg.chanState.LocalChanCfg,
 			c.cfg.chanState.RemoteChanCfg, commitSpend,
 			broadcastStateNum, c.cfg.chanState.RevocationProducer,
+			tweaklessCommit,
 		)
 		if err != nil {
 			log.Errorf("unable to determine self commit for "+
@@ -584,48 +589,29 @@ func (c *chainWatcher) closeObserver(spendNtfn *chainntnfs.SpendEvent) {
 				"state #%v!!! Attempting recovery...",
 				broadcastStateNum, remoteStateNum)
 
-			// If we are lucky, the remote peer sent us the correct
-			// commitment point during channel sync, such that we
-			// can sweep our funds. If we cannot find the commit
-			// point, there's not much we can do other than wait
-			// for us to retrieve it. We will attempt to retrieve
-			// it from the peer each time we connect to it.
-			//
-			// TODO(halseth): actively initiate re-connection to
-			// the peer?
-			var commitPoint *btcec.PublicKey
-			backoff := minCommitPointPollTimeout
-			for {
-				commitPoint, err = c.cfg.chanState.DataLossCommitPoint()
-				if err == nil {
-					break
-				}
-
-				log.Errorf("Unable to retrieve commitment "+
-					"point for channel(%v) with lost "+
-					"state: %v. Retrying in %v.",
-					c.cfg.chanState.FundingOutpoint,
-					err, backoff)
-
-				select {
-				// Wait before retrying, with an exponential
-				// backoff.
-				case <-time.After(backoff):
-					backoff = 2 * backoff
-					if backoff > maxCommitPointPollTimeout {
-						backoff = maxCommitPointPollTimeout
-					}
-
-				case <-c.quit:
+			// If this isn't a tweakless commitment, then we'll
+			// need to wait for the remote party's latest unrevoked
+			// commitment point to be presented to us as we need
+			// this to sweep. Otherwise, we can dispatch the remote
+			// close and sweep immediately using a fake commitPoint
+			// as it isn't actually needed for recovery anymore.
+			commitPoint := c.cfg.chanState.RemoteCurrentRevocation
+			if !tweaklessCommit {
+				commitPoint = c.waitForCommitmentPoint()
+				if commitPoint == nil {
 					return
 				}
-			}
 
-			log.Infof("Recovered commit point(%x) for "+
-				"channel(%v)! Now attempting to use it to "+
-				"sweep our funds...",
-				commitPoint.SerializeCompressed(),
-				c.cfg.chanState.FundingOutpoint)
+				log.Infof("Recovered commit point(%x) for "+
+					"channel(%v)! Now attempting to use it to "+
+					"sweep our funds...",
+					commitPoint.SerializeCompressed(),
+					c.cfg.chanState.FundingOutpoint)
+
+			} else {
+				log.Infof("ChannelPoint(%v) is tweakless, " +
+					"moving to sweep directly on chain")
+			}
 
 			// Since we don't have the commitment stored for this
 			// state, we'll just pass an empty commitment within
@@ -1009,3 +995,39 @@ func (c *chainWatcher) dispatchContractBreach(spendEvent *chainntnfs.SpendDetail
 
 	return nil
 }
+
+// waitForCommitmentPoint waits for the commitment point to be inserted into
+// the local database. We'll use this method in the DLP case, to wait for the
+// remote party to send us their point, as we can't proceed until we have that.
+func (c *chainWatcher) waitForCommitmentPoint() *btcec.PublicKey {
+	// If we are lucky, the remote peer sent us the correct commitment
+	// point during channel sync, such that we can sweep our funds. If we
+	// cannot find the commit point, there's not much we can do other than
+	// wait for us to retrieve it. We will attempt to retrieve it from the
+	// peer each time we connect to it.
+	//
+	// TODO(halseth): actively initiate re-connection to the peer?
+	backoff := minCommitPointPollTimeout
+	for {
+		commitPoint, err := c.cfg.chanState.DataLossCommitPoint()
+		if err == nil {
+			return commitPoint
+		}
+
+		log.Errorf("Unable to retrieve commitment point for "+
+			"channel(%v) with lost state: %v. Retrying in %v.",
+			c.cfg.chanState.FundingOutpoint, err, backoff)
+
+		select {
+		// Wait before retrying, with an exponential backoff.
+		case <-time.After(backoff):
+			backoff = 2 * backoff
+			if backoff > maxCommitPointPollTimeout {
+				backoff = maxCommitPointPollTimeout
+			}
+
+		case <-c.quit:
+			return nil
+		}
+	}
+}
diff --git a/contractcourt/commit_sweep_resolver.go b/contractcourt/commit_sweep_resolver.go
index 1ef7e9667..4e5712728 100644
--- a/contractcourt/commit_sweep_resolver.go
+++ b/contractcourt/commit_sweep_resolver.go
@@ -89,12 +89,23 @@ func (c *commitSweepResolver) Resolve() (ContractResolver, error) {
 	isLocalCommitTx := c.commitResolution.MaturityDelay != 0
 
 	if !isLocalCommitTx {
+		// There're two types of commitments, those that have tweaks
+		// for the remote key (us in this case), and those that don't.
+		// We'll rely on the presence of the commitment tweak to to
+		// discern which type of commitment this is.
+		var witnessType input.WitnessType
+		if c.commitResolution.SelfOutputSignDesc.SingleTweak == nil {
+			witnessType = input.CommitSpendNoDelayTweakless
+		} else {
+			witnessType = input.CommitmentNoDelay
+		}
+
 		// We'll craft an input with all the information required for
 		// the sweeper to create a fully valid sweeping transaction to
 		// recover these coins.
 		inp := input.MakeBaseInput(
 			&c.commitResolution.SelfOutPoint,
-			input.CommitmentNoDelay,
+			witnessType,
 			&c.commitResolution.SelfOutputSignDesc,
 			c.broadcastHeight,
 		)
diff --git a/fundingmanager.go b/fundingmanager.go
index 05acb70a7..b61084373 100644
--- a/fundingmanager.go
+++ b/fundingmanager.go
@@ -1199,6 +1199,18 @@ func (f *fundingManager) handleFundingOpen(fmsg *fundingOpenMsg) {
 	// reservation attempt may be rejected. Note that since we're on the
 	// responding side of a single funder workflow, we don't commit any
 	// funds to the channel ourselves.
+	//
+	// Before we init the channel, we'll also check to see if we've
+	// negotiated the new tweakless commitment format. This is only the
+	// case if *both* us and the remote peer are signaling the proper
+	// feature bit.
+	localTweakless := fmsg.peer.LocalGlobalFeatures().HasFeature(
+		lnwire.StaticRemoteKeyOptional,
+	)
+	remoteTweakless := fmsg.peer.RemoteGlobalFeatures().HasFeature(
+		lnwire.StaticRemoteKeyOptional,
+	)
+	tweaklessCommitment := localTweakless && remoteTweakless
 	chainHash := chainhash.Hash(msg.ChainHash)
 	req := &lnwallet.InitFundingReserveMsg{
 		ChainHash:        &chainHash,
@@ -1211,6 +1223,7 @@ func (f *fundingManager) handleFundingOpen(fmsg *fundingOpenMsg) {
 		PushMSat:         msg.PushAmount,
 		Flags:            msg.ChannelFlags,
 		MinConfs:         1,
+		Tweakless:        tweaklessCommitment,
 	}
 
 	reservation, err := f.cfg.Wallet.InitChannelReservation(req)
@@ -1246,8 +1259,9 @@ func (f *fundingManager) handleFundingOpen(fmsg *fundingOpenMsg) {
 	}
 
 	fndgLog.Infof("Requiring %v confirmations for pendingChan(%x): "+
-		"amt=%v, push_amt=%v", numConfsReq, fmsg.msg.PendingChannelID,
-		amt, msg.PushAmount)
+		"amt=%v, push_amt=%v, tweakless=%v", numConfsReq,
+		fmsg.msg.PendingChannelID, amt, msg.PushAmount,
+		tweaklessCommitment)
 
 	// Generate our required constraints for the remote party.
 	remoteCsvDelay := f.cfg.RequiredRemoteDelay(amt)
@@ -2440,7 +2454,7 @@ func (f *fundingManager) handleFundingLocked(fmsg *fundingLockedMsg) {
 	// Launch a defer so we _ensure_ that the channel barrier is properly
 	// closed even if the target peer is no longer online at this point.
 	defer func() {
-		// Close the active channel barrier signalling the readHandler
+		// Close the active channel barrier signaling the readHandler
 		// that commitment related modifications to this channel can
 		// now proceed.
 		f.barrierMtx.Lock()
@@ -2748,6 +2762,18 @@ func (f *fundingManager) handleInitFundingMsg(msg *initFundingMsg) {
 	// Initialize a funding reservation with the local wallet. If the
 	// wallet doesn't have enough funds to commit to this channel, then the
 	// request will fail, and be aborted.
+	//
+	// Before we init the channel, we'll also check to see if we've
+	// negotiated the new tweakless commitment format. This is only the
+	// case if *both* us and the remote peer are signaling the proper
+	// feature bit.
+	localTweakless := msg.peer.LocalGlobalFeatures().HasFeature(
+		lnwire.StaticRemoteKeyOptional,
+	)
+	remoteTweakless := msg.peer.RemoteGlobalFeatures().HasFeature(
+		lnwire.StaticRemoteKeyOptional,
+	)
+	tweaklessCommitment := localTweakless && remoteTweakless
 	req := &lnwallet.InitFundingReserveMsg{
 		ChainHash:        &msg.chainHash,
 		NodeID:           peerKey,
@@ -2760,6 +2786,7 @@ func (f *fundingManager) handleInitFundingMsg(msg *initFundingMsg) {
 		PushMSat:         msg.pushAmt,
 		Flags:            channelFlags,
 		MinConfs:         msg.minConfs,
+		Tweakless:        tweaklessCommitment,
 	}
 
 	reservation, err := f.cfg.Wallet.InitChannelReservation(req)
@@ -2828,8 +2855,8 @@ func (f *fundingManager) handleInitFundingMsg(msg *initFundingMsg) {
 	maxValue := f.cfg.RequiredRemoteMaxValue(capacity)
 	maxHtlcs := f.cfg.RequiredRemoteMaxHTLCs(capacity)
 
-	fndgLog.Infof("Starting funding workflow with %v for pendingID(%x)",
-		msg.peer.Address(), chanID)
+	fndgLog.Infof("Starting funding workflow with %v for pendingID(%x), "+
+		"tweakless=%v", msg.peer.Address(), chanID, tweaklessCommitment)
 
 	fundingOpen := lnwire.OpenChannel{
 		ChainHash:            *f.cfg.Wallet.Cfg.NetParams.GenesisHash,
diff --git a/htlcswitch/interfaces.go b/htlcswitch/interfaces.go
index d4bcc0a80..5e1627958 100644
--- a/htlcswitch/interfaces.go
+++ b/htlcswitch/interfaces.go
@@ -175,6 +175,8 @@ type TowerClient interface {
 	// state. If the method returns nil, the backup is guaranteed to be
 	// successful unless the tower is unavailable and client is force quit,
 	// or the justice transaction would create dust outputs when trying to
-	// abide by the negotiated policy.
-	BackupState(*lnwire.ChannelID, *lnwallet.BreachRetribution) error
+	// abide by the negotiated policy. If the channel we're trying to back
+	// up doesn't have a tweak for the remote party's output, then
+	// isTweakless should be true.
+	BackupState(*lnwire.ChannelID, *lnwallet.BreachRetribution, bool) error
 }
diff --git a/htlcswitch/link.go b/htlcswitch/link.go
index 351a76237..0539bde18 100644
--- a/htlcswitch/link.go
+++ b/htlcswitch/link.go
@@ -954,7 +954,7 @@ func (l *channelLink) htlcManager() {
 
 			l.fail(
 				LinkFailureError{
-					code:       ErrSyncError,
+					code:       ErrRecoveryError,
 					ForceClose: false,
 				},
 				"unable to synchronize channel "+
@@ -1844,8 +1844,13 @@ func (l *channelLink) handleUpstreamMsg(msg lnwire.Message) {
 				return
 			}
 
+			chanType := l.channel.State().ChanType
+			isTweakless := chanType == channeldb.SingleFunderTweakless
+
 			chanID := l.ChanID()
-			err = l.cfg.TowerClient.BackupState(&chanID, breachInfo)
+			err = l.cfg.TowerClient.BackupState(
+				&chanID, breachInfo, isTweakless,
+			)
 			if err != nil {
 				l.fail(LinkFailureError{code: ErrInternalError},
 					"unable to queue breach backup: %v", err)
diff --git a/htlcswitch/linkfailure.go b/htlcswitch/linkfailure.go
index 2f44e4340..c806c4b26 100644
--- a/htlcswitch/linkfailure.go
+++ b/htlcswitch/linkfailure.go
@@ -34,6 +34,11 @@ const (
 	// ErrInvalidRevocation indicates that the remote peer send us an
 	// invalid revocation message.
 	ErrInvalidRevocation
+
+	// ErrRecoveryError the channel was unable to be resumed, we need the
+	// remote party to force close the channel out on chain now as a
+	// result.
+	ErrRecoveryError
 )
 
 // LinkFailureError encapsulates an error that will make us fail the current
@@ -74,6 +79,8 @@ func (e LinkFailureError) Error() string {
 		return "invalid commitment"
 	case ErrInvalidRevocation:
 		return "invalid revocation"
+	case ErrRecoveryError:
+		return "unable to resume channel, recovery required"
 	default:
 		return "unknown error"
 	}
diff --git a/htlcswitch/mock.go b/htlcswitch/mock.go
index a3174b8fc..626ebe824 100644
--- a/htlcswitch/mock.go
+++ b/htlcswitch/mock.go
@@ -597,6 +597,14 @@ func (s *mockServer) WipeChannel(*wire.OutPoint) error {
 	return nil
 }
 
+func (s *mockServer) LocalGlobalFeatures() *lnwire.FeatureVector {
+	return nil
+}
+
+func (s *mockServer) RemoteGlobalFeatures() *lnwire.FeatureVector {
+	return nil
+}
+
 func (s *mockServer) Stop() error {
 	if !atomic.CompareAndSwapInt32(&s.shutdown, 0, 1) {
 		return nil
diff --git a/input/script_utils.go b/input/script_utils.go
index 8a5a0df63..8b47b0568 100644
--- a/input/script_utils.go
+++ b/input/script_utils.go
@@ -902,13 +902,15 @@ func CommitSpendRevoke(signer Signer, signDesc *SignDescriptor,
 }
 
 // CommitSpendNoDelay constructs a valid witness allowing a node to spend their
-// settled no-delay output on the counterparty's commitment transaction.
+// settled no-delay output on the counterparty's commitment transaction. If the
+// tweakless field is true, then we'll omit the set where we tweak the pubkey
+// with a random set of bytes, and use it directly in the witness stack.
 //
 // NOTE: The passed SignDescriptor should include the raw (untweaked) public
 // key of the receiver and also the proper single tweak value based on the
 // current commitment point.
 func CommitSpendNoDelay(signer Signer, signDesc *SignDescriptor,
-	sweepTx *wire.MsgTx) (wire.TxWitness, error) {
+	sweepTx *wire.MsgTx, tweakless bool) (wire.TxWitness, error) {
 
 	if signDesc.KeyDesc.PubKey == nil {
 		return nil, fmt.Errorf("cannot generate witness with nil " +
@@ -923,14 +925,25 @@ func CommitSpendNoDelay(signer Signer, signDesc *SignDescriptor,
 	}
 
 	// Finally, we'll manually craft the witness. The witness here is the
-	// exact same as a regular p2wkh witness, but we'll need to ensure that
-	// we use the tweaked public key as the last item in the witness stack
-	// which was originally used to created the pkScript we're spending.
+	// exact same as a regular p2wkh witness, depending on the value of the
+	// tweakless bool.
 	witness := make([][]byte, 2)
 	witness[0] = append(sweepSig, byte(signDesc.HashType))
-	witness[1] = TweakPubKeyWithTweak(
-		signDesc.KeyDesc.PubKey, signDesc.SingleTweak,
-	).SerializeCompressed()
+
+	switch tweakless {
+	// If we're tweaking the key, then we use the tweaked public key as the
+	// last item in the witness stack which was originally used to created
+	// the pkScript we're spending.
+	case false:
+		witness[1] = TweakPubKeyWithTweak(
+			signDesc.KeyDesc.PubKey, signDesc.SingleTweak,
+		).SerializeCompressed()
+
+	// Otherwise, we can just use the raw pubkey, since there's no random
+	// value to be combined.
+	case true:
+		witness[1] = signDesc.KeyDesc.PubKey.SerializeCompressed()
+	}
 
 	return witness, nil
 }
diff --git a/input/witnessgen.go b/input/witnessgen.go
index 32e547c65..28a02d086 100644
--- a/input/witnessgen.go
+++ b/input/witnessgen.go
@@ -79,6 +79,11 @@ const (
 	// output that sends to a nested P2SH script that pays to a key solely
 	// under our control. The witness generated needs to include the
 	NestedWitnessKeyHash WitnessType = 11
+
+	// CommitSpendNoDelayTweakless is similar to the CommitSpendNoDelay
+	// type, but it omits the tweak that randomizes the key we need to
+	// spend with a channel peer supplied set of randomness.
+	CommitSpendNoDelayTweakless = 12
 )
 
 // Stirng returns a human readable version of the target WitnessType.
@@ -90,6 +95,9 @@ func (wt WitnessType) String() string {
 	case CommitmentNoDelay:
 		return "CommitmentNoDelay"
 
+	case CommitSpendNoDelayTweakless:
+		return "CommitmentNoDelayTweakless"
+
 	case CommitmentRevoke:
 		return "CommitmentRevoke"
 
@@ -153,7 +161,17 @@ func (wt WitnessType) GenWitnessFunc(signer Signer,
 			}, nil
 
 		case CommitmentNoDelay:
-			witness, err := CommitSpendNoDelay(signer, desc, tx)
+			witness, err := CommitSpendNoDelay(signer, desc, tx, false)
+			if err != nil {
+				return nil, err
+			}
+
+			return &Script{
+				Witness: witness,
+			}, nil
+
+		case CommitSpendNoDelayTweakless:
+			witness, err := CommitSpendNoDelay(signer, desc, tx, true)
 			if err != nil {
 				return nil, err
 			}
diff --git a/lncfg/protocol_legacy_off.go b/lncfg/protocol_legacy_off.go
index 6f5660e9a..7e1e47d32 100644
--- a/lncfg/protocol_legacy_off.go
+++ b/lncfg/protocol_legacy_off.go
@@ -14,3 +14,9 @@ type LegacyProtocol struct {
 func (l *LegacyProtocol) LegacyOnion() bool {
 	return false
 }
+
+// LegacyOnion returns true if the old commitment format should be used for new
+// funded channels.
+func (l *LegacyProtocol) LegacyCommitment() bool {
+	return false
+}
diff --git a/lncfg/protocol_legacy_on.go b/lncfg/protocol_legacy_on.go
index 52bd93880..d384adc8a 100644
--- a/lncfg/protocol_legacy_on.go
+++ b/lncfg/protocol_legacy_on.go
@@ -10,6 +10,12 @@ type LegacyProtocol struct {
 	// As a result, nodes that include us in the route won't use the new
 	// modern onion framing.
 	Onion bool `long:"onion" description:"force node to not advertise the new modern TLV onion format"`
+
+	// CommitmentTweak guards if we should use the old legacy commitment
+	// protocol, or the newer variant that doesn't have a tweak for the
+	// remote party's output in the commitment. If set to true, then we
+	// won't signal StaticRemoteKeyOptional.
+	CommitmentTweak bool `long:"committweak" description:"force node to not advertise the new commitment format"`
 }
 
 // LegacyOnion returns true if the old legacy onion format should be used when
@@ -18,3 +24,9 @@ type LegacyProtocol struct {
 func (l *LegacyProtocol) LegacyOnion() bool {
 	return l.Onion
 }
+
+// LegacyOnion returns true if the old commitment format should be used for new
+// funded channels.
+func (l *LegacyProtocol) LegacyCommitment() bool {
+	return l.CommitmentTweak
+}
diff --git a/lnpeer/peer.go b/lnpeer/peer.go
index 16cbff639..e21e27968 100644
--- a/lnpeer/peer.go
+++ b/lnpeer/peer.go
@@ -46,4 +46,16 @@ type Peer interface {
 	// using the interface to cancel any processing in the event the backing
 	// implementation exits.
 	QuitSignal() <-chan struct{}
+
+	// LocalGlobalFeatures returns the set of global features that has been
+	// advertised by the local peer. This allows sub-systems that use this
+	// interface to gate their behavior off the set of negotiated feature
+	// bits.
+	LocalGlobalFeatures() *lnwire.FeatureVector
+
+	// RemoteGlobalFeatures returns the set of global features that has
+	// been advertised by the remote peer. This allows sub-systems that use
+	// this interface to gate their behavior off the set of negotiated
+	// feature bits.
+	RemoteGlobalFeatures() *lnwire.FeatureVector
 }
diff --git a/lnrpc/rpc.pb.go b/lnrpc/rpc.pb.go
index 83a0a2250..02ffe5222 100644
--- a/lnrpc/rpc.pb.go
+++ b/lnrpc/rpc.pb.go
@@ -2622,7 +2622,13 @@ type Channel struct {
 	LocalChanReserveSat int64 `protobuf:"varint,20,opt,name=local_chan_reserve_sat,proto3" json:"local_chan_reserve_sat,omitempty"`
 	//*
 	//The minimum satoshis the other node is required to reserve in its balance.
-	RemoteChanReserveSat int64    `protobuf:"varint,21,opt,name=remote_chan_reserve_sat,proto3" json:"remote_chan_reserve_sat,omitempty"`
+	RemoteChanReserveSat int64 `protobuf:"varint,21,opt,name=remote_chan_reserve_sat,proto3" json:"remote_chan_reserve_sat,omitempty"`
+	//*
+	//If true, then this channel uses the modern commitment format where the key
+	//in the output of the remote party does not change each state. This makes
+	//back up and recovery easier as when the channel is closed, the funds go
+	//directly to that key.
+	StaticRemoteKey      bool     `protobuf:"varint,22,opt,name=static_remote_key,proto3" json:"static_remote_key,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -2800,6 +2806,13 @@ func (m *Channel) GetRemoteChanReserveSat() int64 {
 	return 0
 }
 
+func (m *Channel) GetStaticRemoteKey() bool {
+	if m != nil {
+		return m.StaticRemoteKey
+	}
+	return false
+}
+
 type ListChannelsRequest struct {
 	ActiveOnly           bool     `protobuf:"varint,1,opt,name=active_only,json=activeOnly,proto3" json:"active_only,omitempty"`
 	InactiveOnly         bool     `protobuf:"varint,2,opt,name=inactive_only,json=inactiveOnly,proto3" json:"inactive_only,omitempty"`
@@ -9159,539 +9172,540 @@ func init() {
 func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
 
 var fileDescriptor_77a6da22d6a3feb1 = []byte{
-	// 8508 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7d, 0x5b, 0x6c, 0x1c, 0xc9,
-	0xb5, 0x18, 0x7b, 0x1e, 0xe4, 0xcc, 0x99, 0xe1, 0x70, 0x58, 0xa4, 0xc8, 0xd1, 0xac, 0x56, 0xe2,
-	0xb6, 0x75, 0x25, 0x99, 0x5e, 0x93, 0x5a, 0xd9, 0xde, 0xe8, 0xee, 0xda, 0xb9, 0xa1, 0x48, 0x4a,
-	0x94, 0x97, 0x4b, 0xd1, 0x4d, 0xca, 0x8a, 0xed, 0x1b, 0xb4, 0x9b, 0x33, 0x45, 0xb2, 0xad, 0x9e,
-	0xee, 0x71, 0x77, 0x0f, 0x29, 0x7a, 0xb3, 0x01, 0x12, 0x04, 0x41, 0x70, 0x81, 0x20, 0x70, 0xf2,
-	0x93, 0x04, 0x09, 0x02, 0xd8, 0x17, 0x41, 0x2e, 0xf2, 0x91, 0xe4, 0x23, 0x41, 0x02, 0x18, 0xb8,
-	0x9f, 0xf9, 0x0a, 0x82, 0xe0, 0xfe, 0xe5, 0x23, 0x46, 0x90, 0x00, 0x89, 0x91, 0xbf, 0x00, 0xf9,
-	0x0f, 0xea, 0xd4, 0xa3, 0xab, 0xba, 0x7b, 0x24, 0xad, 0xbd, 0xb9, 0x5f, 0x9c, 0x3a, 0xe7, 0x74,
-	0x3d, 0xcf, 0x39, 0x75, 0xce, 0xa9, 0x53, 0x45, 0x68, 0xc6, 0xe3, 0xc1, 0xc6, 0x38, 0x8e, 0xd2,
-	0x88, 0xd4, 0x83, 0x30, 0x1e, 0x0f, 0xfa, 0x37, 0xce, 0xa2, 0xe8, 0x2c, 0xa0, 0x9b, 0xde, 0xd8,
-	0xdf, 0xf4, 0xc2, 0x30, 0x4a, 0xbd, 0xd4, 0x8f, 0xc2, 0x84, 0x13, 0xd9, 0x3f, 0x86, 0xce, 0x13,
-	0x1a, 0x1e, 0x51, 0x3a, 0x74, 0xe8, 0x4f, 0x27, 0x34, 0x49, 0xc9, 0xd7, 0x60, 0xd1, 0xa3, 0x3f,
-	0xa3, 0x74, 0xe8, 0x8e, 0xbd, 0x24, 0x19, 0x9f, 0xc7, 0x5e, 0x42, 0x7b, 0xd6, 0x9a, 0x75, 0xaf,
-	0xed, 0x74, 0x39, 0xe2, 0x50, 0xc1, 0xc9, 0x7b, 0xd0, 0x4e, 0x18, 0x29, 0x0d, 0xd3, 0x38, 0x1a,
-	0x5f, 0xf5, 0x2a, 0x48, 0xd7, 0x62, 0xb0, 0x5d, 0x0e, 0xb2, 0x03, 0x58, 0x50, 0x2d, 0x24, 0xe3,
-	0x28, 0x4c, 0x28, 0xb9, 0x0f, 0xcb, 0x03, 0x7f, 0x7c, 0x4e, 0x63, 0x17, 0x3f, 0x1e, 0x85, 0x74,
-	0x14, 0x85, 0xfe, 0xa0, 0x67, 0xad, 0x55, 0xef, 0x35, 0x1d, 0xc2, 0x71, 0xec, 0x8b, 0x4f, 0x05,
-	0x86, 0xdc, 0x85, 0x05, 0x1a, 0x72, 0x38, 0x1d, 0xe2, 0x57, 0xa2, 0xa9, 0x4e, 0x06, 0x66, 0x1f,
-	0xd8, 0x7f, 0xbb, 0x02, 0x8b, 0x4f, 0x43, 0x3f, 0x7d, 0xe1, 0x05, 0x01, 0x4d, 0xe5, 0x98, 0xee,
-	0xc2, 0xc2, 0x25, 0x02, 0x70, 0x4c, 0x97, 0x51, 0x3c, 0x14, 0x23, 0xea, 0x70, 0xf0, 0xa1, 0x80,
-	0x4e, 0xed, 0x59, 0x65, 0x6a, 0xcf, 0x4a, 0xa7, 0xab, 0x3a, 0x65, 0xba, 0xee, 0xc2, 0x42, 0x4c,
-	0x07, 0xd1, 0x05, 0x8d, 0xaf, 0xdc, 0x4b, 0x3f, 0x1c, 0x46, 0x97, 0xbd, 0xda, 0x9a, 0x75, 0xaf,
-	0xee, 0x74, 0x24, 0xf8, 0x05, 0x42, 0xc9, 0x23, 0x58, 0x18, 0x9c, 0x7b, 0x61, 0x48, 0x03, 0xf7,
-	0xc4, 0x1b, 0xbc, 0x9c, 0x8c, 0x93, 0x5e, 0x7d, 0xcd, 0xba, 0xd7, 0x7a, 0x70, 0x7d, 0x03, 0x57,
-	0x75, 0x63, 0xfb, 0xdc, 0x0b, 0x1f, 0x21, 0xe6, 0x28, 0xf4, 0xc6, 0xc9, 0x79, 0x94, 0x3a, 0x1d,
-	0xf1, 0x05, 0x07, 0x27, 0xf6, 0x32, 0x10, 0x7d, 0x26, 0xf8, 0xdc, 0xdb, 0xff, 0xc2, 0x82, 0xa5,
-	0xe7, 0x61, 0x10, 0x0d, 0x5e, 0xfe, 0x96, 0x53, 0x54, 0x32, 0x86, 0xca, 0xdb, 0x8e, 0xa1, 0xfa,
-	0x45, 0xc7, 0xb0, 0x02, 0xcb, 0x66, 0x67, 0xc5, 0x28, 0x28, 0x5c, 0x63, 0x5f, 0x9f, 0x51, 0xd9,
-	0x2d, 0x39, 0x8c, 0xaf, 0x42, 0x77, 0x30, 0x89, 0x63, 0x1a, 0x16, 0xc6, 0xb1, 0x20, 0xe0, 0x6a,
-	0x20, 0xef, 0x41, 0x3b, 0xa4, 0x97, 0x19, 0x99, 0xe0, 0xdd, 0x90, 0x5e, 0x4a, 0x12, 0xbb, 0x07,
-	0x2b, 0xf9, 0x66, 0x44, 0x07, 0xfe, 0x9b, 0x05, 0xb5, 0xe7, 0xe9, 0xab, 0x88, 0x6c, 0x40, 0x2d,
-	0xbd, 0x1a, 0x73, 0x09, 0xe9, 0x3c, 0x20, 0x62, 0x68, 0x5b, 0xc3, 0x61, 0x4c, 0x93, 0xe4, 0xf8,
-	0x6a, 0x4c, 0x9d, 0xb6, 0xc7, 0x0b, 0x2e, 0xa3, 0x23, 0x3d, 0x98, 0x13, 0x65, 0x6c, 0xb0, 0xe9,
-	0xc8, 0x22, 0xb9, 0x09, 0xe0, 0x8d, 0xa2, 0x49, 0x98, 0xba, 0x89, 0x97, 0xe2, 0x54, 0x55, 0x1d,
-	0x0d, 0x42, 0x6e, 0x40, 0x73, 0xfc, 0xd2, 0x4d, 0x06, 0xb1, 0x3f, 0x4e, 0x91, 0x6d, 0x9a, 0x4e,
-	0x06, 0x20, 0x5f, 0x83, 0x46, 0x34, 0x49, 0xc7, 0x91, 0x1f, 0xa6, 0x82, 0x55, 0x16, 0x44, 0x5f,
-	0x9e, 0x4d, 0xd2, 0x43, 0x06, 0x76, 0x14, 0x01, 0xb9, 0x0d, 0xf3, 0x83, 0x28, 0x3c, 0xf5, 0xe3,
-	0x11, 0x57, 0x06, 0xbd, 0x59, 0x6c, 0xcd, 0x04, 0xda, 0xff, 0xbe, 0x02, 0xad, 0xe3, 0xd8, 0x0b,
-	0x13, 0x6f, 0xc0, 0x00, 0xac, 0xeb, 0xe9, 0x2b, 0xf7, 0xdc, 0x4b, 0xce, 0x71, 0xb4, 0x4d, 0x47,
-	0x16, 0xc9, 0x0a, 0xcc, 0xf2, 0x8e, 0xe2, 0x98, 0xaa, 0x8e, 0x28, 0x91, 0xf7, 0x61, 0x31, 0x9c,
-	0x8c, 0x5c, 0xb3, 0xad, 0x2a, 0x72, 0x4b, 0x11, 0xc1, 0x26, 0xe0, 0x84, 0xad, 0x35, 0x6f, 0x82,
-	0x8f, 0x50, 0x83, 0x10, 0x1b, 0xda, 0xa2, 0x44, 0xfd, 0xb3, 0x73, 0x3e, 0xcc, 0xba, 0x63, 0xc0,
-	0x58, 0x1d, 0xa9, 0x3f, 0xa2, 0x6e, 0x92, 0x7a, 0xa3, 0xb1, 0x18, 0x96, 0x06, 0x41, 0x7c, 0x94,
-	0x7a, 0x81, 0x7b, 0x4a, 0x69, 0xd2, 0x9b, 0x13, 0x78, 0x05, 0x21, 0x77, 0xa0, 0x33, 0xa4, 0x49,
-	0xea, 0x8a, 0x45, 0xa1, 0x49, 0xaf, 0x81, 0xa2, 0x9f, 0x83, 0xb2, 0x7a, 0x62, 0xef, 0xd2, 0x65,
-	0x13, 0x40, 0x5f, 0xf5, 0x9a, 0xbc, 0xaf, 0x19, 0x84, 0x71, 0xce, 0x13, 0x9a, 0x6a, 0xb3, 0x97,
-	0x08, 0x0e, 0xb5, 0xf7, 0x81, 0x68, 0xe0, 0x1d, 0x9a, 0x7a, 0x7e, 0x90, 0x90, 0x0f, 0xa1, 0x9d,
-	0x6a, 0xc4, 0xa8, 0x0a, 0x5b, 0x8a, 0x9d, 0xb4, 0x0f, 0x1c, 0x83, 0xce, 0x7e, 0x02, 0x8d, 0xc7,
-	0x94, 0xee, 0xfb, 0x23, 0x3f, 0x25, 0x2b, 0x50, 0x3f, 0xf5, 0x5f, 0x51, 0xce, 0xf0, 0xd5, 0xbd,
-	0x19, 0x87, 0x17, 0x49, 0x1f, 0xe6, 0xc6, 0x34, 0x1e, 0x50, 0xb9, 0x3c, 0x7b, 0x33, 0x8e, 0x04,
-	0x3c, 0x9a, 0x83, 0x7a, 0xc0, 0x3e, 0xb6, 0x7f, 0x53, 0x85, 0xd6, 0x11, 0x0d, 0x95, 0x20, 0x11,
-	0xa8, 0xb1, 0x21, 0x0b, 0xe1, 0xc1, 0xdf, 0xe4, 0x16, 0xb4, 0x70, 0x1a, 0x92, 0x34, 0xf6, 0xc3,
-	0x33, 0xc1, 0xbf, 0xc0, 0x40, 0x47, 0x08, 0x21, 0x5d, 0xa8, 0x7a, 0x23, 0xc9, 0xbb, 0xec, 0x27,
-	0x13, 0xb2, 0xb1, 0x77, 0x35, 0x62, 0xf2, 0xa8, 0x56, 0xb5, 0xed, 0xb4, 0x04, 0x6c, 0x8f, 0x2d,
-	0xeb, 0x06, 0x2c, 0xe9, 0x24, 0xb2, 0xf6, 0x3a, 0xd6, 0xbe, 0xa8, 0x51, 0x8a, 0x46, 0xee, 0xc2,
-	0x82, 0xa4, 0x8f, 0x79, 0x67, 0x71, 0x9d, 0x9b, 0x4e, 0x47, 0x80, 0xe5, 0x10, 0xee, 0x41, 0xf7,
-	0xd4, 0x0f, 0xbd, 0xc0, 0x1d, 0x04, 0xe9, 0x85, 0x3b, 0xa4, 0x41, 0xea, 0xe1, 0x8a, 0xd7, 0x9d,
-	0x0e, 0xc2, 0xb7, 0x83, 0xf4, 0x62, 0x87, 0x41, 0xc9, 0xfb, 0xd0, 0x3c, 0xa5, 0xd4, 0xc5, 0x99,
-	0xe8, 0x35, 0x0c, 0xe9, 0x91, 0xb3, 0xeb, 0x34, 0x4e, 0xe5, 0x3c, 0xdf, 0x83, 0x6e, 0x34, 0x49,
-	0xcf, 0x22, 0x3f, 0x3c, 0x73, 0x99, 0xbe, 0x72, 0xfd, 0x21, 0x72, 0x40, 0xcd, 0xe9, 0x48, 0x38,
-	0xd3, 0x1a, 0x4f, 0x87, 0xe4, 0x5d, 0x00, 0x6c, 0x9b, 0x57, 0x0c, 0x6b, 0xd6, 0xbd, 0x79, 0xa7,
-	0xc9, 0x20, 0xbc, 0xa2, 0x8f, 0xa0, 0x81, 0xf3, 0x99, 0x06, 0x17, 0xbd, 0x16, 0x2e, 0xf8, 0x2d,
-	0xd1, 0xaa, 0xb6, 0x12, 0x1b, 0x3b, 0x34, 0x49, 0x8f, 0x83, 0x0b, 0xb6, 0x9f, 0x5e, 0x39, 0x73,
-	0x43, 0x5e, 0xea, 0x7f, 0x04, 0x6d, 0x1d, 0xc1, 0xa6, 0xfe, 0x25, 0xbd, 0xc2, 0xe5, 0xaa, 0x39,
-	0xec, 0x27, 0x59, 0x86, 0xfa, 0x85, 0x17, 0x4c, 0xa8, 0x50, 0x6c, 0xbc, 0xf0, 0x51, 0xe5, 0xa1,
-	0x65, 0xff, 0x3b, 0x0b, 0xda, 0xbc, 0x05, 0xb1, 0x21, 0xdf, 0x86, 0x79, 0x39, 0xa5, 0x34, 0x8e,
-	0xa3, 0x58, 0xc8, 0xb7, 0x09, 0x24, 0xeb, 0xd0, 0x95, 0x80, 0x71, 0x4c, 0xfd, 0x91, 0x77, 0x26,
-	0xeb, 0x2e, 0xc0, 0xc9, 0x83, 0xac, 0xc6, 0x38, 0x9a, 0xa4, 0x54, 0xa8, 0xfe, 0xb6, 0x18, 0x9f,
-	0xc3, 0x60, 0x8e, 0x49, 0xc2, 0xe4, 0xbb, 0x84, 0x57, 0x0c, 0x98, 0xfd, 0x73, 0x0b, 0x08, 0xeb,
-	0xfa, 0x71, 0xc4, 0xab, 0x10, 0x4b, 0x9d, 0x67, 0x33, 0xeb, 0xad, 0xd9, 0xac, 0x32, 0x8d, 0xcd,
-	0x6c, 0xa8, 0xf3, 0x9e, 0xd7, 0x4a, 0x7a, 0xce, 0x51, 0xdf, 0xad, 0x35, 0xaa, 0xdd, 0x9a, 0xfd,
-	0x5f, 0xaa, 0xb0, 0xbc, 0xcd, 0xf7, 0xad, 0xad, 0xc1, 0x80, 0x8e, 0x15, 0x03, 0xde, 0x82, 0x56,
-	0x18, 0x0d, 0xa9, 0x3b, 0x9e, 0x9c, 0xc8, 0xb5, 0x69, 0x3b, 0xc0, 0x40, 0x87, 0x08, 0x41, 0xfe,
-	0x38, 0xf7, 0xfc, 0x90, 0x77, 0x9a, 0xcf, 0x65, 0x13, 0x21, 0xd8, 0xe5, 0x3b, 0xb0, 0x30, 0xa6,
-	0xe1, 0x50, 0xe7, 0x33, 0x6e, 0x59, 0xcc, 0x0b, 0xb0, 0x60, 0xb3, 0x5b, 0xd0, 0x3a, 0x9d, 0x70,
-	0x3a, 0x26, 0x7e, 0x35, 0xe4, 0x01, 0x10, 0xa0, 0xad, 0x51, 0x4a, 0xae, 0x43, 0x63, 0x3c, 0x49,
-	0xce, 0x11, 0x5b, 0x47, 0xec, 0x1c, 0x2b, 0x33, 0xd4, 0xbb, 0x00, 0xc3, 0x49, 0x92, 0x0a, 0x16,
-	0x9d, 0x45, 0x64, 0x93, 0x41, 0x38, 0x8b, 0x7e, 0x1d, 0x96, 0x46, 0xde, 0x2b, 0x17, 0x79, 0xc7,
-	0xf5, 0x43, 0xf7, 0x34, 0x40, 0xd5, 0x3b, 0x87, 0x74, 0xdd, 0x91, 0xf7, 0xea, 0xfb, 0x0c, 0xf3,
-	0x34, 0x7c, 0x8c, 0x70, 0x26, 0x9b, 0x72, 0xcf, 0x8f, 0x69, 0x42, 0xe3, 0x0b, 0x8a, 0xe2, 0x54,
-	0x53, 0x1b, 0xbb, 0xc3, 0xa1, 0xac, 0x47, 0x23, 0x36, 0xee, 0x34, 0x18, 0x08, 0xd9, 0x99, 0x1b,
-	0xf9, 0xe1, 0x5e, 0x1a, 0x0c, 0xc8, 0x0d, 0x00, 0x26, 0x8c, 0x63, 0x1a, 0xbb, 0x2f, 0x2f, 0x51,
-	0x68, 0x6a, 0x28, 0x7c, 0x87, 0x34, 0xfe, 0xe4, 0x92, 0xbc, 0x03, 0xcd, 0x41, 0x82, 0xd2, 0xec,
-	0x5d, 0xf5, 0x5a, 0x28, 0x51, 0x8d, 0x41, 0xc2, 0xe4, 0xd8, 0xbb, 0x22, 0xef, 0x03, 0x61, 0xbd,
-	0xf5, 0x70, 0x15, 0xe8, 0x10, 0xab, 0x4f, 0x7a, 0x6d, 0xa4, 0x62, 0x9d, 0xdd, 0x12, 0x08, 0xd6,
-	0x4e, 0x42, 0xbe, 0x02, 0xf3, 0xb2, 0xb3, 0xa7, 0x81, 0x77, 0x96, 0xf4, 0xe6, 0x91, 0xb0, 0x2d,
-	0x80, 0x8f, 0x19, 0xcc, 0x7e, 0xc1, 0x2d, 0x0d, 0x6d, 0x6d, 0x85, 0xcc, 0xb0, 0x3d, 0x0f, 0x21,
-	0xb8, 0xae, 0x0d, 0x47, 0x94, 0xca, 0x16, 0xad, 0x52, 0xb2, 0x68, 0xf6, 0x2f, 0x2c, 0x68, 0x8b,
-	0x9a, 0x71, 0x7b, 0x26, 0xf7, 0x81, 0xc8, 0x55, 0x4c, 0x5f, 0xf9, 0x43, 0xf7, 0xe4, 0x2a, 0xa5,
-	0x09, 0x67, 0x9a, 0xbd, 0x19, 0xa7, 0x04, 0x47, 0xde, 0x87, 0xae, 0x01, 0x4d, 0xd2, 0x98, 0xf3,
-	0xf3, 0xde, 0x8c, 0x53, 0xc0, 0x30, 0xf1, 0x62, 0x06, 0xc0, 0x24, 0x75, 0xfd, 0x70, 0x48, 0x5f,
-	0x21, 0x2b, 0xcd, 0x3b, 0x06, 0xec, 0x51, 0x07, 0xda, 0xfa, 0x77, 0xf6, 0x4f, 0xa0, 0x21, 0xcd,
-	0x07, 0xdc, 0x3a, 0x73, 0xfd, 0x72, 0x34, 0x08, 0xe9, 0x43, 0xc3, 0xec, 0x85, 0xd3, 0xf8, 0x22,
-	0x6d, 0xdb, 0x7f, 0x11, 0xba, 0xfb, 0x8c, 0x89, 0x42, 0xc6, 0xb4, 0xc2, 0x26, 0x5a, 0x81, 0x59,
-	0x4d, 0x78, 0x9a, 0x8e, 0x28, 0xb1, 0xdd, 0xe9, 0x3c, 0x4a, 0x52, 0xd1, 0x0e, 0xfe, 0xb6, 0xff,
-	0x83, 0x05, 0x64, 0x37, 0x49, 0xfd, 0x91, 0x97, 0xd2, 0xc7, 0x54, 0xa9, 0x86, 0x67, 0xd0, 0x66,
-	0xb5, 0x1d, 0x47, 0x5b, 0xdc, 0x42, 0xe1, 0x3b, 0xeb, 0xd7, 0x84, 0x38, 0x17, 0x3f, 0xd8, 0xd0,
-	0xa9, 0xb9, 0xd2, 0x35, 0x2a, 0x60, 0xd2, 0x96, 0x7a, 0xf1, 0x19, 0x4d, 0xd1, 0x7c, 0x11, 0xc6,
-	0x2f, 0x70, 0xd0, 0x76, 0x14, 0x9e, 0xf6, 0xff, 0x00, 0x16, 0x0b, 0x75, 0xe8, 0xfa, 0xb9, 0x59,
-	0xa2, 0x9f, 0xab, 0xba, 0x7e, 0x1e, 0xc0, 0x92, 0xd1, 0x2f, 0xc1, 0x71, 0x3d, 0x98, 0x63, 0x82,
-	0xc1, 0xac, 0x43, 0xdc, 0xe1, 0x1d, 0x59, 0x24, 0x0f, 0x60, 0xf9, 0x94, 0xd2, 0xd8, 0x4b, 0xb1,
-	0x88, 0xa2, 0xc3, 0xd6, 0x44, 0xd4, 0x5c, 0x8a, 0xb3, 0xff, 0xbb, 0x05, 0x0b, 0x4c, 0x93, 0x7e,
-	0xea, 0x85, 0x57, 0x72, 0xae, 0xf6, 0x4b, 0xe7, 0xea, 0x9e, 0xb6, 0x29, 0x69, 0xd4, 0x5f, 0x74,
-	0xa2, 0xaa, 0xf9, 0x89, 0x22, 0x6b, 0xd0, 0x36, 0xba, 0x5b, 0xe7, 0xe6, 0x58, 0xe2, 0xa5, 0x87,
-	0x34, 0x7e, 0x74, 0x95, 0xd2, 0xdf, 0x7d, 0x2a, 0xef, 0x40, 0x37, 0xeb, 0xb6, 0x98, 0x47, 0x02,
-	0x35, 0xc6, 0x98, 0xa2, 0x02, 0xfc, 0x6d, 0xff, 0x63, 0x8b, 0x13, 0x6e, 0x47, 0xbe, 0x32, 0xd5,
-	0x18, 0x21, 0xb3, 0xf8, 0x24, 0x21, 0xfb, 0x3d, 0xd5, 0xd4, 0xfd, 0xdd, 0x07, 0xcb, 0x74, 0x62,
-	0x42, 0xc3, 0xa1, 0xeb, 0x05, 0x01, 0x2a, 0xe2, 0x86, 0x33, 0xc7, 0xca, 0x5b, 0x41, 0x60, 0xdf,
-	0x85, 0x45, 0xad, 0x77, 0xaf, 0x19, 0xc7, 0x01, 0x90, 0x7d, 0x3f, 0x49, 0x9f, 0x87, 0xc9, 0x58,
-	0xb3, 0x84, 0xde, 0x81, 0x26, 0xd3, 0xb6, 0xac, 0x67, 0x5c, 0x72, 0xeb, 0x0e, 0x53, 0xbf, 0xac,
-	0x5f, 0x09, 0x22, 0xbd, 0x57, 0x02, 0x59, 0x11, 0x48, 0xef, 0x15, 0x22, 0xed, 0x87, 0xb0, 0x64,
-	0xd4, 0x27, 0x9a, 0x7e, 0x0f, 0xea, 0x93, 0xf4, 0x55, 0x24, 0xed, 0xd4, 0x96, 0xe0, 0x10, 0xe6,
-	0x11, 0x39, 0x1c, 0x63, 0x7f, 0x0c, 0x8b, 0x07, 0xf4, 0x52, 0x08, 0xb2, 0xec, 0xc8, 0x9d, 0x37,
-	0x7a, 0x4b, 0x88, 0xb7, 0x37, 0x80, 0xe8, 0x1f, 0x67, 0x02, 0x20, 0x7d, 0x27, 0xcb, 0xf0, 0x9d,
-	0xec, 0x3b, 0x40, 0x8e, 0xfc, 0xb3, 0xf0, 0x53, 0x9a, 0x24, 0xde, 0x99, 0x12, 0xfd, 0x2e, 0x54,
-	0x47, 0xc9, 0x99, 0x50, 0x55, 0xec, 0xa7, 0xfd, 0x0d, 0x58, 0x32, 0xe8, 0x44, 0xc5, 0x37, 0xa0,
-	0x99, 0xf8, 0x67, 0xa1, 0x97, 0x4e, 0x62, 0x2a, 0xaa, 0xce, 0x00, 0xf6, 0x63, 0x58, 0xfe, 0x3e,
-	0x8d, 0xfd, 0xd3, 0xab, 0x37, 0x55, 0x6f, 0xd6, 0x53, 0xc9, 0xd7, 0xb3, 0x0b, 0xd7, 0x72, 0xf5,
-	0x88, 0xe6, 0x39, 0xfb, 0x8a, 0x95, 0x6c, 0x38, 0xbc, 0xa0, 0xe9, 0xbe, 0x8a, 0xae, 0xfb, 0xec,
-	0xe7, 0x40, 0xb6, 0xa3, 0x30, 0xa4, 0x83, 0xf4, 0x90, 0xd2, 0x38, 0x0b, 0xdb, 0x64, 0xbc, 0xda,
-	0x7a, 0xb0, 0x2a, 0x66, 0x36, 0xaf, 0x50, 0x05, 0x13, 0x13, 0xa8, 0x8d, 0x69, 0x3c, 0xc2, 0x8a,
-	0x1b, 0x0e, 0xfe, 0xb6, 0xaf, 0xc1, 0x92, 0x51, 0xad, 0x70, 0x74, 0x3f, 0x80, 0x6b, 0x3b, 0x7e,
-	0x32, 0x28, 0x36, 0xd8, 0x83, 0xb9, 0xf1, 0xe4, 0xc4, 0xcd, 0x24, 0x51, 0x16, 0x99, 0xef, 0x93,
-	0xff, 0x44, 0x54, 0xf6, 0xb7, 0x2c, 0xa8, 0xed, 0x1d, 0xef, 0x6f, 0xb3, 0xbd, 0xc2, 0x0f, 0x07,
-	0xd1, 0x88, 0x59, 0x60, 0x7c, 0xd0, 0xaa, 0x3c, 0x55, 0xc2, 0x6e, 0x40, 0x13, 0x0d, 0x37, 0xe6,
-	0xee, 0x09, 0x3b, 0x28, 0x03, 0x30, 0x57, 0x93, 0xbe, 0x1a, 0xfb, 0x31, 0xfa, 0x92, 0xd2, 0x43,
-	0xac, 0xe1, 0x36, 0x53, 0x44, 0xd8, 0xbf, 0x9a, 0x85, 0x39, 0xb1, 0xf9, 0xf2, 0x8d, 0x3c, 0xf5,
-	0x2f, 0x68, 0xb6, 0x91, 0xb3, 0x12, 0x33, 0x8a, 0x63, 0x3a, 0x8a, 0x52, 0x65, 0xbf, 0xf1, 0x65,
-	0x30, 0x81, 0xe8, 0x4a, 0x0b, 0x23, 0x82, 0x3b, 0xdf, 0x55, 0x4e, 0x65, 0x00, 0xd9, 0x64, 0x49,
-	0x63, 0x80, 0x5b, 0x67, 0xb2, 0xc8, 0x66, 0x62, 0xe0, 0x8d, 0xbd, 0x81, 0x9f, 0x5e, 0x09, 0x95,
-	0xa0, 0xca, 0xac, 0xee, 0x20, 0x1a, 0x78, 0x81, 0x7b, 0xe2, 0x05, 0x5e, 0x38, 0xa0, 0xd2, 0x4d,
-	0x37, 0x80, 0xcc, 0x65, 0x15, 0x5d, 0x92, 0x64, 0xdc, 0xad, 0xcd, 0x41, 0xd9, 0xfe, 0x3d, 0x88,
-	0x46, 0x23, 0x3f, 0x65, 0x9e, 0x2e, 0x9a, 0x65, 0x55, 0x47, 0x83, 0xf0, 0xa0, 0x00, 0x96, 0x2e,
-	0xf9, 0xec, 0x35, 0x65, 0x50, 0x40, 0x03, 0xb2, 0x5a, 0x72, 0xd6, 0x59, 0xd5, 0xd1, 0x20, 0x6c,
-	0x1d, 0x26, 0x61, 0x42, 0xd3, 0x34, 0xa0, 0x43, 0xd5, 0xa1, 0x16, 0x92, 0x15, 0x11, 0xe4, 0x3e,
-	0x2c, 0x71, 0xe7, 0x3b, 0xf1, 0xd2, 0x28, 0x39, 0xf7, 0x13, 0x37, 0x61, 0x6e, 0x6a, 0x1b, 0xe9,
-	0xcb, 0x50, 0xe4, 0x21, 0xac, 0xe6, 0xc0, 0x31, 0x1d, 0x50, 0xff, 0x82, 0x0e, 0xd1, 0x7c, 0xab,
-	0x3a, 0xd3, 0xd0, 0x64, 0x0d, 0x5a, 0xe1, 0x64, 0xe4, 0x4e, 0xc6, 0x43, 0x8f, 0x19, 0x30, 0x1d,
-	0x5c, 0x07, 0x1d, 0x44, 0x3e, 0x00, 0x69, 0xa3, 0x09, 0xcb, 0x71, 0xc1, 0xd0, 0x6e, 0x8c, 0x73,
-	0x1d, 0x93, 0x82, 0x31, 0x65, 0x66, 0x8e, 0x76, 0x85, 0x83, 0x27, 0x01, 0x28, 0x23, 0xb1, 0x7f,
-	0xe1, 0xa5, 0xb4, 0xb7, 0xc8, 0x15, 0xba, 0x28, 0xb2, 0xef, 0xfc, 0xd0, 0x4f, 0x7d, 0x2f, 0x8d,
-	0xe2, 0x1e, 0x41, 0x5c, 0x06, 0x60, 0x93, 0x88, 0xfc, 0x91, 0xa4, 0x5e, 0x3a, 0x49, 0x84, 0x75,
-	0xba, 0xc4, 0x3d, 0x95, 0x02, 0x82, 0x7c, 0x08, 0x2b, 0x9c, 0x23, 0x10, 0x25, 0xec, 0x6e, 0x34,
-	0x13, 0x96, 0x71, 0x46, 0xa6, 0x60, 0xd9, 0x54, 0x0a, 0x16, 0x29, 0x7c, 0x78, 0x8d, 0x4f, 0xe5,
-	0x14, 0xb4, 0xfd, 0x4f, 0x2d, 0xbe, 0x2d, 0x08, 0x11, 0x4a, 0x34, 0x87, 0x87, 0x0b, 0x8f, 0x1b,
-	0x85, 0xc1, 0x95, 0x90, 0x27, 0xe0, 0xa0, 0x67, 0x61, 0x70, 0xc5, 0x4c, 0x6e, 0x3f, 0xd4, 0x49,
-	0xb8, 0x06, 0x6a, 0x4b, 0x20, 0x12, 0xdd, 0x82, 0xd6, 0x78, 0x72, 0x12, 0xf8, 0x03, 0x4e, 0x52,
-	0xe5, 0xb5, 0x70, 0x10, 0x12, 0x30, 0x6f, 0x8f, 0xcf, 0x23, 0xa7, 0xa8, 0x21, 0x45, 0x4b, 0xc0,
-	0x18, 0x89, 0xfd, 0x08, 0x96, 0xcd, 0x0e, 0x0a, 0x55, 0xbb, 0x0e, 0x0d, 0x21, 0x99, 0x89, 0x70,
-	0xb9, 0x3b, 0x5a, 0x34, 0x92, 0x39, 0x28, 0x0a, 0x6f, 0xff, 0xdb, 0x1a, 0x2c, 0x09, 0xe8, 0x76,
-	0x10, 0x25, 0xf4, 0x68, 0x32, 0x1a, 0x79, 0x71, 0x89, 0xc8, 0x5b, 0x6f, 0x10, 0xf9, 0x8a, 0x29,
-	0xf2, 0x37, 0x0d, 0xaf, 0x8f, 0xeb, 0x0b, 0x0d, 0x42, 0xee, 0xc1, 0xc2, 0x20, 0x88, 0x12, 0x6e,
-	0x84, 0xeb, 0xc1, 0xb0, 0x3c, 0xb8, 0xa8, 0xa2, 0xea, 0x65, 0x2a, 0x4a, 0x57, 0x31, 0xb3, 0x39,
-	0x15, 0x63, 0x43, 0x9b, 0x55, 0x4a, 0xa5, 0xc6, 0x9c, 0x13, 0x2e, 0x90, 0x06, 0x63, 0xfd, 0xc9,
-	0x0b, 0x34, 0xd7, 0x1e, 0x0b, 0x65, 0xe2, 0xec, 0x8f, 0x28, 0x6a, 0x64, 0x8d, 0xba, 0x29, 0xc4,
-	0xb9, 0x88, 0x22, 0x8f, 0x01, 0x78, 0x5b, 0x68, 0x16, 0x00, 0x9a, 0x05, 0x77, 0xcc, 0x15, 0xd1,
-	0xe7, 0x7e, 0x83, 0x15, 0x26, 0x31, 0x45, 0x53, 0x41, 0xfb, 0xd2, 0xfe, 0x23, 0x0b, 0x5a, 0x1a,
-	0x8e, 0x5c, 0x83, 0xc5, 0xed, 0x67, 0xcf, 0x0e, 0x77, 0x9d, 0xad, 0xe3, 0xa7, 0xdf, 0xdf, 0x75,
-	0xb7, 0xf7, 0x9f, 0x1d, 0xed, 0x76, 0x67, 0x18, 0x78, 0xff, 0xd9, 0xf6, 0xd6, 0xbe, 0xfb, 0xf8,
-	0x99, 0xb3, 0x2d, 0xc1, 0x16, 0x59, 0x01, 0xe2, 0xec, 0x7e, 0xfa, 0xec, 0x78, 0xd7, 0x80, 0x57,
-	0x48, 0x17, 0xda, 0x8f, 0x9c, 0xdd, 0xad, 0xed, 0x3d, 0x01, 0xa9, 0x92, 0x65, 0xe8, 0x3e, 0x7e,
-	0x7e, 0xb0, 0xf3, 0xf4, 0xe0, 0x89, 0xbb, 0xbd, 0x75, 0xb0, 0xbd, 0xbb, 0xbf, 0xbb, 0xd3, 0xad,
-	0x91, 0x79, 0x68, 0x6e, 0x3d, 0xda, 0x3a, 0xd8, 0x79, 0x76, 0xb0, 0xbb, 0xd3, 0xad, 0xdb, 0xff,
-	0xd5, 0x82, 0x6b, 0xd8, 0xeb, 0x61, 0x5e, 0x40, 0xd6, 0xa0, 0x35, 0x88, 0xa2, 0x31, 0x33, 0xc7,
-	0xb3, 0x0d, 0x47, 0x07, 0x31, 0xe6, 0xe7, 0xe2, 0x7a, 0x1a, 0xc5, 0x03, 0x2a, 0xe4, 0x03, 0x10,
-	0xf4, 0x98, 0x41, 0x18, 0xf3, 0x8b, 0xe5, 0xe5, 0x14, 0x5c, 0x3c, 0x5a, 0x1c, 0xc6, 0x49, 0x56,
-	0x60, 0xf6, 0x24, 0xa6, 0xde, 0xe0, 0x5c, 0x48, 0x86, 0x28, 0x91, 0xaf, 0x66, 0xfe, 0xe2, 0x80,
-	0xcd, 0x7e, 0x40, 0x87, 0xc8, 0x31, 0x0d, 0x67, 0x41, 0xc0, 0xb7, 0x05, 0x98, 0xe9, 0x27, 0xef,
-	0xc4, 0x0b, 0x87, 0x51, 0x48, 0x87, 0xc2, 0x18, 0xcd, 0x00, 0xf6, 0x21, 0xac, 0xe4, 0xc7, 0x27,
-	0xe4, 0xeb, 0x43, 0x4d, 0xbe, 0xb8, 0x6d, 0xd8, 0x9f, 0xbe, 0x9a, 0x9a, 0xac, 0xfd, 0xba, 0x02,
-	0x35, 0x66, 0x2a, 0x4c, 0x37, 0x2b, 0x74, 0xeb, 0xaf, 0x5a, 0x88, 0x9c, 0xa3, 0x0b, 0xca, 0x37,
-	0x0f, 0x11, 0xfe, 0xc8, 0x20, 0x19, 0x3e, 0xa6, 0x83, 0x0b, 0x11, 0x00, 0xd1, 0x20, 0x4c, 0x40,
-	0x98, 0x69, 0x8e, 0x5f, 0x0b, 0x01, 0x91, 0x65, 0x89, 0xc3, 0x2f, 0xe7, 0x32, 0x1c, 0x7e, 0xd7,
-	0x83, 0x39, 0x3f, 0x3c, 0x89, 0x26, 0xe1, 0x10, 0x05, 0xa2, 0xe1, 0xc8, 0x22, 0xc6, 0xea, 0x51,
-	0x50, 0xfd, 0x91, 0x64, 0xff, 0x0c, 0x40, 0x1e, 0x40, 0x33, 0xb9, 0x0a, 0x07, 0x3a, 0xcf, 0x2f,
-	0x8b, 0x59, 0x62, 0x73, 0xb0, 0x71, 0x74, 0x15, 0x0e, 0x90, 0xc3, 0x33, 0x32, 0xfb, 0x0f, 0xa0,
-	0x21, 0xc1, 0x8c, 0x2d, 0x9f, 0x1f, 0x7c, 0x72, 0xf0, 0xec, 0xc5, 0x81, 0x7b, 0xf4, 0x83, 0x83,
-	0xed, 0xee, 0x0c, 0x59, 0x80, 0xd6, 0xd6, 0x36, 0x72, 0x3a, 0x02, 0x2c, 0x46, 0x72, 0xb8, 0x75,
-	0x74, 0xa4, 0x20, 0x15, 0x9b, 0x30, 0xf7, 0x3a, 0x41, 0x7b, 0x4c, 0xc5, 0xa2, 0x3f, 0x84, 0x45,
-	0x0d, 0x96, 0xd9, 0xf6, 0x63, 0x06, 0xc8, 0xd9, 0xf6, 0x68, 0xc8, 0x71, 0x8c, 0xdd, 0x85, 0xce,
-	0x13, 0x9a, 0x3e, 0x0d, 0x4f, 0x23, 0x59, 0xd3, 0xff, 0xac, 0xc1, 0x82, 0x02, 0x89, 0x8a, 0xee,
-	0xc1, 0x82, 0x3f, 0xa4, 0x61, 0xea, 0xa7, 0x57, 0xae, 0xe1, 0xc5, 0xe7, 0xc1, 0xcc, 0x00, 0xf6,
-	0x02, 0xdf, 0x93, 0x47, 0x22, 0xbc, 0xc0, 0xbc, 0x5a, 0xb6, 0x3b, 0xeb, 0xd1, 0x14, 0xe4, 0x2b,
-	0x1e, 0x3c, 0x28, 0xc5, 0x31, 0x0d, 0xc4, 0xe0, 0x62, 0x8b, 0x51, 0x9f, 0x70, 0x43, 0xb0, 0x0c,
-	0xc5, 0x96, 0x8a, 0xd7, 0xc4, 0x86, 0x5c, 0xe7, 0x3b, 0xb8, 0x02, 0x14, 0xce, 0x1c, 0x66, 0xb9,
-	0x7e, 0xcc, 0x9f, 0x39, 0x68, 0xe7, 0x16, 0x8d, 0xc2, 0xb9, 0x05, 0xd3, 0x9f, 0x57, 0xe1, 0x80,
-	0x0e, 0xdd, 0x34, 0x72, 0x51, 0xcf, 0x23, 0x4b, 0x34, 0x9c, 0x3c, 0x98, 0xdc, 0x80, 0xb9, 0x94,
-	0x26, 0x69, 0x48, 0x79, 0xb0, 0xb8, 0xf1, 0xa8, 0xd2, 0xb3, 0x1c, 0x09, 0x62, 0x56, 0xfb, 0x24,
-	0xf6, 0x93, 0x5e, 0x1b, 0x4f, 0x24, 0xf0, 0x37, 0xf9, 0x26, 0x5c, 0x3b, 0xa1, 0x49, 0xea, 0x9e,
-	0x53, 0x6f, 0x48, 0x63, 0x64, 0x2f, 0x7e, 0xf4, 0xc1, 0x8d, 0xa1, 0x72, 0x24, 0x63, 0xdc, 0x0b,
-	0x1a, 0x27, 0x7e, 0x14, 0xa2, 0x19, 0xd4, 0x74, 0x64, 0x91, 0xd5, 0xc7, 0x06, 0xaf, 0x36, 0x69,
-	0x35, 0x83, 0x0b, 0x38, 0xf0, 0x72, 0x24, 0xb9, 0x0d, 0xb3, 0x38, 0x80, 0xa4, 0xd7, 0x45, 0x9e,
-	0x69, 0x67, 0x32, 0xef, 0x87, 0x8e, 0xc0, 0xb1, 0x55, 0x1e, 0x44, 0x41, 0x14, 0xa3, 0x2d, 0xd4,
-	0x74, 0x78, 0xc1, 0x9c, 0x9d, 0xb3, 0xd8, 0x1b, 0x9f, 0x0b, 0x7b, 0x28, 0x0f, 0xfe, 0x6e, 0xad,
-	0xd1, 0xea, 0xb6, 0xed, 0xbf, 0x00, 0x75, 0xac, 0x16, 0xab, 0xc3, 0xc9, 0xb4, 0x44, 0x75, 0x08,
-	0xed, 0xc1, 0x5c, 0x48, 0xd3, 0xcb, 0x28, 0x7e, 0x29, 0xcf, 0xd7, 0x44, 0xd1, 0xfe, 0x19, 0xfa,
-	0x4d, 0xea, 0xbc, 0xe9, 0x39, 0x1a, 0x7d, 0xcc, 0xfb, 0xe5, 0x4b, 0x95, 0x9c, 0x7b, 0xc2, 0x95,
-	0x6b, 0x20, 0xe0, 0xe8, 0xdc, 0x63, 0xba, 0xd6, 0x58, 0x7d, 0xee, 0x1d, 0xb7, 0x10, 0xb6, 0xc7,
-	0x17, 0xff, 0x36, 0x74, 0xe4, 0x49, 0x56, 0xe2, 0x06, 0xf4, 0x34, 0x95, 0xb1, 0xad, 0x70, 0x32,
-	0x42, 0x17, 0x7a, 0x9f, 0x9e, 0xa6, 0xf6, 0x01, 0x2c, 0x0a, 0xfd, 0xf7, 0x6c, 0x4c, 0x65, 0xd3,
-	0xbf, 0x5f, 0x66, 0x47, 0xb4, 0x1e, 0x2c, 0x99, 0x0a, 0x93, 0x9f, 0xdd, 0x99, 0x94, 0xb6, 0x03,
-	0x44, 0xd7, 0xa7, 0xa2, 0x42, 0xb1, 0x99, 0xcb, 0xe8, 0x9d, 0x18, 0x8e, 0x01, 0x63, 0xf3, 0x93,
-	0x4c, 0x06, 0x03, 0x79, 0xfe, 0xd8, 0x70, 0x64, 0xd1, 0xfe, 0xe7, 0x16, 0x2c, 0x61, 0x6d, 0xd2,
-	0x12, 0x12, 0x7b, 0xd6, 0xc3, 0x2f, 0xd0, 0x4d, 0x19, 0x3b, 0xe5, 0x11, 0xc3, 0x65, 0xa8, 0xeb,
-	0xbb, 0x18, 0x2f, 0x7c, 0xf1, 0x48, 0x49, 0x2d, 0x1f, 0x29, 0xb1, 0xff, 0x81, 0x05, 0x8b, 0x7c,
-	0x23, 0x41, 0x3b, 0x58, 0x0c, 0xff, 0xdb, 0x30, 0xcf, 0x2d, 0x02, 0xa1, 0x15, 0x44, 0x47, 0x33,
-	0xd5, 0x8a, 0x50, 0x4e, 0xbc, 0x37, 0xe3, 0x98, 0xc4, 0xe4, 0x63, 0xb4, 0xca, 0x42, 0x17, 0xa1,
-	0x25, 0x27, 0xd5, 0xe6, 0x5c, 0xef, 0xcd, 0x38, 0x1a, 0xf9, 0xa3, 0x06, 0xcc, 0x72, 0x27, 0xc2,
-	0x7e, 0x02, 0xf3, 0x46, 0x43, 0x46, 0x94, 0xa6, 0xcd, 0xa3, 0x34, 0x85, 0x70, 0x68, 0xa5, 0x24,
-	0x1c, 0xfa, 0xaf, 0xab, 0x40, 0x18, 0xb3, 0xe4, 0x56, 0x63, 0xcd, 0x3c, 0x53, 0x90, 0x87, 0xd6,
-	0x19, 0x88, 0x6c, 0x00, 0xd1, 0x8a, 0xf2, 0x9c, 0x83, 0x6f, 0x99, 0x25, 0x18, 0xa6, 0x66, 0x85,
-	0xc5, 0xa1, 0xce, 0x10, 0xd0, 0xfb, 0xe6, 0xd3, 0x5e, 0x8a, 0x63, 0xbb, 0x22, 0x1e, 0x28, 0x30,
-	0x5f, 0x41, 0x78, 0xad, 0xb2, 0x9c, 0x5f, 0xdf, 0xd9, 0x37, 0xae, 0xef, 0x5c, 0x21, 0x12, 0xa6,
-	0xf9, 0x4d, 0x0d, 0xd3, 0x6f, 0xba, 0x0d, 0xf3, 0xf2, 0xdc, 0xc0, 0x1d, 0xb1, 0xd6, 0x85, 0x93,
-	0x6a, 0x00, 0xc9, 0x3a, 0x74, 0xa5, 0xeb, 0xa2, 0x9c, 0x33, 0x7e, 0xfa, 0x56, 0x80, 0x33, 0xfd,
-	0x9f, 0xc5, 0xc6, 0x5a, 0xd8, 0xd9, 0x0c, 0xc0, 0x3c, 0xb1, 0x84, 0x71, 0x88, 0x3b, 0x09, 0xc5,
-	0x61, 0x35, 0x1d, 0xa2, 0x7b, 0xda, 0x70, 0x8a, 0x08, 0xfb, 0xef, 0x59, 0xd0, 0x65, 0x6b, 0x66,
-	0xb0, 0xe5, 0x47, 0x80, 0x52, 0xf1, 0x96, 0x5c, 0x69, 0xd0, 0x92, 0x87, 0xd0, 0xc4, 0x72, 0x34,
-	0xa6, 0xa1, 0xe0, 0xc9, 0x9e, 0xc9, 0x93, 0x99, 0x3e, 0xd9, 0x9b, 0x71, 0x32, 0x62, 0x8d, 0x23,
-	0xff, 0x93, 0x05, 0x2d, 0xd1, 0xca, 0x6f, 0x1d, 0x7b, 0xe9, 0x6b, 0xd9, 0x05, 0x9c, 0x93, 0xb2,
-	0x64, 0x82, 0x7b, 0xb0, 0x30, 0xf2, 0xd2, 0x49, 0xcc, 0xf6, 0x73, 0x23, 0xee, 0x92, 0x07, 0xb3,
-	0xcd, 0x19, 0x55, 0x67, 0xe2, 0xa6, 0x7e, 0xe0, 0x4a, 0xac, 0x38, 0xc7, 0x2f, 0x43, 0x31, 0x0d,
-	0x92, 0xa4, 0xde, 0x19, 0x15, 0xfb, 0x2e, 0x2f, 0xd8, 0x3d, 0x58, 0x39, 0xcc, 0xce, 0x52, 0x34,
-	0xfb, 0xda, 0xfe, 0x97, 0xf3, 0xb0, 0x5a, 0x40, 0xa9, 0xac, 0x23, 0x11, 0x50, 0x08, 0xfc, 0xd1,
-	0x49, 0xa4, 0x9c, 0x13, 0x4b, 0x8f, 0x35, 0x18, 0x28, 0x72, 0x06, 0xd7, 0xa4, 0x81, 0xc1, 0xe6,
-	0x34, 0xdb, 0x0c, 0x2b, 0xb8, 0xcb, 0x7d, 0x60, 0x2e, 0x61, 0xbe, 0x41, 0x09, 0xd7, 0x85, 0xb8,
-	0xbc, 0x3e, 0x72, 0x0e, 0x3d, 0x65, 0xc9, 0x08, 0x65, 0xad, 0x59, 0x3b, 0xac, 0xad, 0xf7, 0xdf,
-	0xd0, 0x96, 0x61, 0x8e, 0x3b, 0x53, 0x6b, 0x23, 0x57, 0x70, 0x53, 0xe2, 0x50, 0x1b, 0x17, 0xdb,
-	0xab, 0xbd, 0xd5, 0xd8, 0xd0, 0xd1, 0x30, 0x1b, 0x7d, 0x43, 0xc5, 0xe4, 0x27, 0xb0, 0x72, 0xe9,
-	0xf9, 0xa9, 0xec, 0x96, 0x66, 0x5b, 0xd4, 0xb1, 0xc9, 0x07, 0x6f, 0x68, 0xf2, 0x05, 0xff, 0xd8,
-	0xd8, 0xa2, 0xa6, 0xd4, 0xd8, 0xff, 0x55, 0x05, 0x3a, 0x66, 0x3d, 0x8c, 0x4d, 0x85, 0xec, 0x4b,
-	0x1d, 0x28, 0xad, 0xd1, 0x1c, 0xb8, 0xe8, 0xdf, 0x57, 0xca, 0xfc, 0x7b, 0xdd, 0xab, 0xae, 0xbe,
-	0x29, 0x70, 0x57, 0x7b, 0xbb, 0xc0, 0x5d, 0xbd, 0x34, 0x70, 0x37, 0x3d, 0xbe, 0x33, 0xfb, 0xdb,
-	0xc6, 0x77, 0xe6, 0x5e, 0x1b, 0xdf, 0xe9, 0xff, 0x5f, 0x0b, 0x48, 0x91, 0x7b, 0xc9, 0x13, 0x1e,
-	0xd2, 0x08, 0x69, 0x20, 0x94, 0xd8, 0xd7, 0xdf, 0x4e, 0x02, 0xe4, 0x6a, 0xc9, 0xaf, 0x99, 0x28,
-	0xea, 0xa9, 0x3f, 0xba, 0x79, 0x35, 0xef, 0x94, 0xa1, 0x72, 0xc1, 0xcb, 0xda, 0x9b, 0x83, 0x97,
-	0xf5, 0x37, 0x07, 0x2f, 0x67, 0xf3, 0xc1, 0xcb, 0xfe, 0xdf, 0xb4, 0x60, 0xa9, 0x84, 0xcd, 0xbe,
-	0xbc, 0x81, 0x33, 0xc6, 0x30, 0xb4, 0x4f, 0x45, 0x30, 0x86, 0x0e, 0xec, 0xff, 0x55, 0x98, 0x37,
-	0x44, 0xeb, 0xcb, 0x6b, 0x3f, 0x6f, 0x21, 0x72, 0xce, 0x36, 0x60, 0xfd, 0xff, 0x5d, 0x01, 0x52,
-	0x14, 0xef, 0x3f, 0xd7, 0x3e, 0x14, 0xe7, 0xa9, 0x5a, 0x32, 0x4f, 0xff, 0x5f, 0x77, 0x9e, 0xf7,
-	0x61, 0x51, 0xe4, 0x33, 0x6a, 0x81, 0x2c, 0xce, 0x31, 0x45, 0x04, 0xb3, 0x91, 0xcd, 0xc8, 0x71,
-	0xc3, 0xc8, 0xdf, 0xd2, 0xb6, 0xdf, 0x5c, 0x00, 0xd9, 0xee, 0x43, 0x4f, 0xcc, 0xd0, 0xee, 0x05,
-	0x0d, 0xd3, 0xa3, 0xc9, 0x09, 0x4f, 0xe8, 0xf3, 0xa3, 0xd0, 0xfe, 0x37, 0x55, 0x65, 0xe6, 0x23,
-	0x52, 0x18, 0x14, 0xdf, 0x84, 0xb6, 0xbe, 0x7d, 0x88, 0xe5, 0xc8, 0xc5, 0x31, 0x99, 0x29, 0xa1,
-	0x53, 0x91, 0x1d, 0xe8, 0xa0, 0x92, 0x1c, 0xaa, 0xef, 0x2a, 0xf8, 0xdd, 0x6b, 0xe2, 0x33, 0x7b,
-	0x33, 0x4e, 0xee, 0x1b, 0xf2, 0x1d, 0xe8, 0x98, 0xce, 0x9f, 0xb0, 0x4a, 0xca, 0xbc, 0x01, 0xf6,
-	0xb9, 0x49, 0x4c, 0xb6, 0xa0, 0x9b, 0xf7, 0x1e, 0x45, 0x7e, 0xcd, 0x94, 0x0a, 0x0a, 0xe4, 0xe4,
-	0xa1, 0x38, 0x42, 0xac, 0x63, 0xdc, 0xe4, 0xb6, 0xf9, 0x99, 0x36, 0x4d, 0x1b, 0xfc, 0x8f, 0x76,
-	0xa8, 0xf8, 0x87, 0x00, 0x19, 0x8c, 0x74, 0xa1, 0xfd, 0xec, 0x70, 0xf7, 0xc0, 0xdd, 0xde, 0xdb,
-	0x3a, 0x38, 0xd8, 0xdd, 0xef, 0xce, 0x10, 0x02, 0x1d, 0x0c, 0xf3, 0xed, 0x28, 0x98, 0xc5, 0x60,
-	0x22, 0xb0, 0x22, 0x61, 0x15, 0xb2, 0x0c, 0xdd, 0xa7, 0x07, 0x39, 0x68, 0xf5, 0x51, 0x53, 0xc9,
-	0x87, 0xbd, 0x02, 0xcb, 0x3c, 0x5f, 0xf5, 0x11, 0x67, 0x0f, 0x69, 0x9d, 0xfc, 0x13, 0x0b, 0xae,
-	0xe5, 0x10, 0x59, 0x02, 0x16, 0x37, 0x40, 0x4c, 0xab, 0xc4, 0x04, 0xe2, 0xb1, 0x80, 0xb4, 0x35,
-	0x73, 0x1a, 0xa4, 0x88, 0x60, 0x3c, 0xaf, 0xd9, 0xa6, 0x39, 0x49, 0x2a, 0x43, 0xd9, 0xab, 0x2a,
-	0xd7, 0x25, 0xd7, 0xf1, 0x53, 0x9e, 0x07, 0xab, 0x23, 0xb2, 0x23, 0x59, 0xb3, 0xcb, 0xb2, 0xc8,
-	0xdc, 0x0a, 0xc3, 0xd8, 0x31, 0xfb, 0x5b, 0x8a, 0xb3, 0xff, 0xa8, 0x06, 0xe4, 0x7b, 0x13, 0x1a,
-	0x5f, 0x61, 0x96, 0x95, 0x8a, 0x9a, 0xae, 0xe6, 0x63, 0x82, 0xb3, 0xe3, 0xc9, 0xc9, 0x27, 0xf4,
-	0x4a, 0xe6, 0x1b, 0x56, 0xb2, 0x7c, 0xc3, 0xb2, 0x9c, 0xbf, 0xda, 0x9b, 0x73, 0xfe, 0xea, 0x6f,
-	0xca, 0xf9, 0xfb, 0x0a, 0xcc, 0xfb, 0x67, 0x61, 0xc4, 0x64, 0x9e, 0xd9, 0x09, 0x49, 0x6f, 0x76,
-	0xad, 0xca, 0x7c, 0x6b, 0x01, 0x3c, 0x60, 0x30, 0xf2, 0x71, 0x46, 0x44, 0x87, 0x67, 0x98, 0x5f,
-	0xaa, 0x6b, 0x81, 0xdd, 0xe1, 0x19, 0xdd, 0x8f, 0x06, 0x5e, 0x1a, 0xc5, 0x18, 0xd8, 0x91, 0x1f,
-	0x33, 0x78, 0x42, 0x6e, 0x43, 0x27, 0x89, 0x26, 0xcc, 0x72, 0x92, 0x63, 0xe5, 0x91, 0xa4, 0x36,
-	0x87, 0x1e, 0xf2, 0x11, 0x6f, 0xc0, 0xd2, 0x24, 0xa1, 0xee, 0xc8, 0x4f, 0x12, 0xb6, 0x3b, 0x0e,
-	0xa2, 0x30, 0x8d, 0xa3, 0x40, 0xc4, 0x93, 0x16, 0x27, 0x09, 0xfd, 0x94, 0x63, 0xb6, 0x39, 0x82,
-	0x7c, 0x33, 0xeb, 0xd2, 0xd8, 0xf3, 0xe3, 0xa4, 0x07, 0xd8, 0x25, 0x39, 0x52, 0xd6, 0xef, 0x43,
-	0xcf, 0x8f, 0x55, 0x5f, 0x58, 0x21, 0x21, 0x5b, 0x85, 0xc4, 0x44, 0x19, 0x93, 0x2f, 0xae, 0xce,
-	0x97, 0x9f, 0x9f, 0x28, 0xd2, 0xea, 0x36, 0xa0, 0x21, 0xbb, 0xc7, 0x9c, 0xe8, 0xd3, 0x38, 0x1a,
-	0x49, 0x27, 0x9a, 0xfd, 0x26, 0x1d, 0xa8, 0xa4, 0x91, 0xf8, 0xb8, 0x92, 0x46, 0xf6, 0x0f, 0xa0,
-	0xa5, 0xcd, 0xb0, 0xc8, 0xad, 0x43, 0x83, 0x4d, 0x78, 0xdf, 0x35, 0xee, 0x1f, 0x85, 0x34, 0x78,
-	0x3a, 0x24, 0x5f, 0x83, 0xc5, 0xa1, 0x1f, 0x53, 0x4c, 0xa3, 0x75, 0x63, 0x7a, 0x41, 0xe3, 0x44,
-	0xc6, 0x29, 0xba, 0x0a, 0xe1, 0x70, 0xb8, 0xed, 0xc2, 0x92, 0x31, 0x70, 0x25, 0xb5, 0xb3, 0x98,
-	0x07, 0x28, 0x43, 0xa5, 0x66, 0x8e, 0xa0, 0xc0, 0xb1, 0xfd, 0x4e, 0x84, 0x58, 0xdc, 0x71, 0x1c,
-	0x9d, 0x60, 0x23, 0x96, 0x63, 0xc0, 0xec, 0x7f, 0x56, 0x85, 0xea, 0x5e, 0x34, 0xd6, 0x0f, 0x8d,
-	0x2c, 0xf3, 0xd0, 0x48, 0x18, 0xa5, 0xae, 0xb2, 0x39, 0x85, 0xe5, 0x60, 0x00, 0xc9, 0x3a, 0x74,
-	0xbc, 0x51, 0xea, 0xa6, 0x11, 0x33, 0xc2, 0x2f, 0xbd, 0x98, 0x27, 0x0c, 0x56, 0x91, 0xdd, 0x72,
-	0x18, 0xb2, 0x0c, 0x55, 0x65, 0x4b, 0x21, 0x01, 0x2b, 0x32, 0x0f, 0x10, 0x8f, 0xcb, 0xaf, 0x44,
-	0x2c, 0x54, 0x94, 0x98, 0x36, 0x31, 0xbf, 0xe7, 0xee, 0x37, 0xdf, 0x11, 0xcb, 0x50, 0xcc, 0x40,
-	0x66, 0x02, 0x36, 0xca, 0xec, 0x4d, 0x55, 0xd6, 0xa3, 0xfc, 0x0d, 0x33, 0xca, 0xbf, 0x06, 0xad,
-	0x34, 0xb8, 0x70, 0xc7, 0xde, 0x55, 0x10, 0x79, 0x43, 0xc1, 0xd8, 0x3a, 0x88, 0x7c, 0x9b, 0x53,
-	0xb0, 0x4d, 0x38, 0x1e, 0x4a, 0x86, 0x96, 0xbb, 0xd8, 0x5e, 0x34, 0xde, 0x38, 0x0e, 0x2e, 0x1c,
-	0x8e, 0xe4, 0x3c, 0xa9, 0x93, 0xf7, 0xbf, 0x03, 0x0b, 0x39, 0xfc, 0x17, 0x4a, 0x9d, 0xfd, 0x8d,
-	0x05, 0x75, 0x5c, 0x5e, 0x66, 0x7c, 0x70, 0xed, 0xac, 0x8e, 0xb5, 0xb0, 0x86, 0x79, 0x27, 0x0f,
-	0x26, 0xb6, 0x91, 0x73, 0x5e, 0x51, 0xf3, 0xad, 0xe7, 0x9d, 0xaf, 0x41, 0x93, 0x97, 0x54, 0xfe,
-	0x34, 0x92, 0x64, 0x40, 0x72, 0x13, 0x6a, 0xe7, 0xd1, 0x58, 0xfa, 0x67, 0x90, 0x8d, 0xd7, 0x41,
-	0x78, 0xd6, 0x1f, 0x56, 0x1f, 0x9f, 0x75, 0x6e, 0x03, 0xe7, 0xc1, 0xcc, 0xef, 0x50, 0xd5, 0xea,
-	0xab, 0x98, 0x83, 0xda, 0xcf, 0x61, 0x81, 0x09, 0xa0, 0x16, 0xe6, 0x9f, 0xae, 0x89, 0xbf, 0xca,
-	0x36, 0xf6, 0x41, 0x30, 0x19, 0x52, 0xdd, 0x4b, 0xc6, 0x30, 0xae, 0x80, 0x4b, 0xfb, 0xd0, 0xfe,
-	0x57, 0x16, 0x17, 0x6c, 0x56, 0x2f, 0xb9, 0x07, 0x35, 0xa6, 0x4f, 0x73, 0x41, 0x11, 0x95, 0xb6,
-	0xc2, 0xe8, 0x1c, 0xa4, 0x60, 0x62, 0x84, 0x81, 0x56, 0xbd, 0x76, 0x1e, 0x66, 0xcd, 0x5c, 0x4c,
-	0x35, 0xb2, 0x9c, 0x67, 0x96, 0x83, 0x92, 0x0d, 0xed, 0x94, 0xaa, 0x66, 0xe8, 0x68, 0x69, 0x47,
-	0x0c, 0xcf, 0xa8, 0x76, 0x3a, 0xf5, 0x27, 0x16, 0xcc, 0x1b, 0x7d, 0x62, 0x6c, 0x1a, 0x78, 0x49,
-	0x2a, 0x52, 0x07, 0xc4, 0xca, 0xeb, 0x20, 0x9d, 0xc5, 0x2b, 0x26, 0x8b, 0xab, 0xd3, 0x8e, 0xaa,
-	0x7e, 0xda, 0x71, 0x1f, 0x9a, 0xd9, 0xa5, 0x03, 0xb3, 0x53, 0xac, 0x45, 0x99, 0xc0, 0x93, 0x11,
-	0x65, 0xf1, 0xf4, 0xba, 0x16, 0x4f, 0xb7, 0x3f, 0x86, 0x96, 0x46, 0xaf, 0xc7, 0xc3, 0x2d, 0x23,
-	0x1e, 0xae, 0xb2, 0xdb, 0x2a, 0x59, 0x76, 0x9b, 0xfd, 0xf3, 0x0a, 0xcc, 0x33, 0xf6, 0xf6, 0xc3,
-	0xb3, 0xc3, 0x28, 0xf0, 0x07, 0x57, 0xc8, 0x56, 0x92, 0x93, 0xc5, 0x7e, 0x2a, 0xd9, 0xdc, 0x04,
-	0x33, 0x79, 0x57, 0x29, 0xbd, 0x5c, 0x39, 0xa9, 0x32, 0xd3, 0x5e, 0x4c, 0xf6, 0x4f, 0xbc, 0x44,
-	0x28, 0x04, 0x61, 0xcf, 0x1b, 0x40, 0xa6, 0x63, 0x18, 0x00, 0x73, 0x15, 0x47, 0x7e, 0x10, 0xf8,
-	0x9c, 0x96, 0x7b, 0x7b, 0x65, 0x28, 0xd6, 0xe6, 0xd0, 0x4f, 0xbc, 0x93, 0xec, 0x24, 0x53, 0x95,
-	0x31, 0x54, 0xe8, 0xbd, 0xd2, 0x42, 0x85, 0x3c, 0xb9, 0xd9, 0x04, 0xe6, 0x17, 0x72, 0xae, 0xb0,
-	0x90, 0xf6, 0x9f, 0x56, 0xa0, 0xa5, 0xb1, 0x85, 0x38, 0xbe, 0x37, 0x37, 0x16, 0x0d, 0x22, 0xf1,
-	0x46, 0xec, 0x40, 0x83, 0x90, 0xdb, 0x66, 0x8b, 0x78, 0x5c, 0x80, 0xc2, 0x6e, 0xb0, 0xcf, 0x0d,
-	0x68, 0x32, 0xb6, 0xff, 0x00, 0x03, 0x15, 0xe2, 0xb6, 0x8f, 0x02, 0x48, 0xec, 0x03, 0xc4, 0xd6,
-	0x33, 0x2c, 0x02, 0x5e, 0x7b, 0xe0, 0xff, 0x10, 0xda, 0xa2, 0x1a, 0x5c, 0x5f, 0x1c, 0x70, 0x26,
-	0x78, 0xc6, 0xda, 0x3b, 0x06, 0xa5, 0xfc, 0xf2, 0x81, 0xfc, 0xb2, 0xf1, 0xa6, 0x2f, 0x25, 0xa5,
-	0xfd, 0x44, 0xe5, 0x51, 0x3c, 0x89, 0xbd, 0xf1, 0xb9, 0x54, 0x26, 0xf7, 0x61, 0x49, 0xea, 0x8c,
-	0x49, 0xe8, 0x85, 0x61, 0x34, 0x09, 0x07, 0x54, 0x26, 0xc1, 0x95, 0xa1, 0xec, 0xa1, 0x4a, 0x99,
-	0xc6, 0x8a, 0xc8, 0x3a, 0xd4, 0xb9, 0x35, 0xc6, 0xf7, 0xdf, 0x72, 0xf5, 0xc1, 0x49, 0xc8, 0x3d,
-	0xa8, 0x73, 0xa3, 0xac, 0x32, 0x55, 0xe0, 0x39, 0x81, 0xbd, 0x0e, 0x0b, 0x98, 0xa3, 0x6d, 0xea,
-	0x3d, 0x73, 0x5f, 0x9e, 0x1d, 0xf0, 0x2c, 0xee, 0x65, 0x20, 0x07, 0x5c, 0x9e, 0xf4, 0xd3, 0xd0,
-	0xdf, 0x54, 0xa1, 0xa5, 0x81, 0x99, 0x5e, 0xc2, 0x23, 0x2c, 0x77, 0xe8, 0x7b, 0x23, 0x9a, 0xd2,
-	0x58, 0xc8, 0x50, 0x0e, 0xca, 0xe8, 0xbc, 0x8b, 0x33, 0x37, 0x9a, 0xa4, 0xee, 0x90, 0x9e, 0xc5,
-	0x94, 0x0a, 0x63, 0x21, 0x07, 0x65, 0x74, 0x8c, 0x8b, 0x35, 0x3a, 0x7e, 0xe8, 0x94, 0x83, 0xca,
-	0xb3, 0x4d, 0x3e, 0x47, 0xb5, 0xec, 0x6c, 0x93, 0xcf, 0x48, 0x5e, 0xa3, 0xd6, 0x4b, 0x34, 0xea,
-	0x87, 0xb0, 0xc2, 0x75, 0xa7, 0xd0, 0x1a, 0x6e, 0x8e, 0xb1, 0xa6, 0x60, 0xc9, 0x3a, 0x74, 0x59,
-	0x9f, 0xa5, 0x58, 0x24, 0xfe, 0xcf, 0xb8, 0x6c, 0x59, 0x4e, 0x01, 0xce, 0x68, 0x31, 0xe0, 0xae,
-	0xd3, 0xf2, 0x04, 0x93, 0x02, 0x1c, 0x69, 0xbd, 0x57, 0x26, 0x6d, 0x53, 0xd0, 0xe6, 0xe0, 0xe4,
-	0x21, 0xac, 0x8e, 0xe8, 0xd0, 0xf7, 0xcc, 0x2a, 0x30, 0xfe, 0xc5, 0xf3, 0xd6, 0xa6, 0xa1, 0x59,
-	0x2b, 0x6c, 0x16, 0x7e, 0x16, 0x8d, 0x4e, 0x7c, 0xbe, 0xa1, 0xf1, 0xa3, 0x81, 0x9a, 0x53, 0x80,
-	0xdb, 0xf3, 0xd0, 0x3a, 0x4a, 0xa3, 0xb1, 0x5c, 0xfa, 0x0e, 0xb4, 0x79, 0x51, 0xa4, 0x3c, 0xbe,
-	0x03, 0xd7, 0x91, 0x57, 0x8f, 0xa3, 0x71, 0x14, 0x44, 0x67, 0x57, 0x86, 0x83, 0xff, 0x1f, 0x2d,
-	0x58, 0x32, 0xb0, 0x99, 0x87, 0x8f, 0xd1, 0x48, 0x99, 0xab, 0xc6, 0xd9, 0x7b, 0x51, 0xdb, 0x0e,
-	0x38, 0x21, 0x3f, 0xf8, 0x79, 0x2e, 0xd2, 0xd7, 0xb6, 0xb2, 0xcb, 0x17, 0xf2, 0x43, 0xce, 0xeb,
-	0xbd, 0x22, 0xaf, 0x8b, 0xef, 0xe5, 0xb5, 0x0c, 0x59, 0xc5, 0x77, 0x44, 0x3a, 0xd0, 0x50, 0x0c,
-	0xba, 0x6a, 0xa6, 0x70, 0xe8, 0x01, 0x21, 0xd9, 0x83, 0x81, 0x02, 0x26, 0xf6, 0x2f, 0x2c, 0x80,
-	0xac, 0x77, 0x98, 0x44, 0xa2, 0xb6, 0x34, 0x7e, 0xb9, 0x57, 0xdb, 0xbe, 0xde, 0x83, 0xb6, 0xca,
-	0x03, 0xc8, 0x76, 0xc9, 0x96, 0x84, 0x31, 0xab, 0xe2, 0x2e, 0x2c, 0x9c, 0x05, 0xd1, 0x09, 0x5a,
-	0x2f, 0x98, 0x43, 0x9b, 0x88, 0xc4, 0xcf, 0x0e, 0x07, 0x3f, 0x16, 0xd0, 0x6c, 0x4b, 0xad, 0xe9,
-	0x5b, 0x6a, 0xf9, 0x06, 0xf9, 0x77, 0x2a, 0xea, 0x30, 0x36, 0x9b, 0x89, 0xa9, 0x12, 0x4e, 0x1e,
-	0x14, 0xd4, 0xf9, 0x94, 0xb3, 0x4f, 0x74, 0x2e, 0x0e, 0xdf, 0x18, 0x1b, 0xfe, 0x18, 0x3a, 0x31,
-	0xd7, 0x95, 0x52, 0x91, 0xd6, 0x5e, 0xa3, 0x48, 0xe7, 0x63, 0x63, 0x37, 0xfe, 0x2a, 0x74, 0xbd,
-	0xe1, 0x05, 0x8d, 0x53, 0x1f, 0x63, 0x65, 0x68, 0x3a, 0xf1, 0xc1, 0x2d, 0x68, 0x70, 0xb4, 0x50,
-	0xee, 0xc2, 0x82, 0x48, 0xc1, 0x55, 0x94, 0xe2, 0x9a, 0x5c, 0x06, 0x66, 0x84, 0xf6, 0x2f, 0xe5,
-	0xb9, 0xaf, 0xb9, 0xb2, 0xd3, 0x67, 0x44, 0x1f, 0x5d, 0x25, 0x37, 0xba, 0xaf, 0x88, 0x33, 0xd8,
-	0xa1, 0x0c, 0xc8, 0x55, 0xb5, 0x84, 0xb2, 0xa1, 0x38, 0x33, 0x37, 0xa7, 0xb4, 0xf6, 0x36, 0x53,
-	0x6a, 0xff, 0x99, 0x05, 0x73, 0x7b, 0xd1, 0x78, 0x4f, 0xa4, 0xd6, 0xa1, 0x78, 0xa8, 0xdc, 0x77,
-	0x59, 0x7c, 0x4d, 0xd2, 0x5d, 0xa9, 0x05, 0x32, 0x9f, 0xb7, 0x40, 0xfe, 0x12, 0xbc, 0x83, 0xe1,
-	0xe0, 0x38, 0x1a, 0x47, 0x31, 0x13, 0x51, 0x2f, 0xe0, 0xe6, 0x46, 0x14, 0xa6, 0xe7, 0x52, 0x85,
-	0xbe, 0x8e, 0x04, 0x63, 0x34, 0x41, 0x7a, 0xe1, 0x72, 0xb7, 0x49, 0x58, 0x4c, 0x5c, 0xb3, 0x16,
-	0x11, 0xf6, 0xef, 0x43, 0x13, 0xbd, 0x09, 0x1c, 0xd6, 0xfb, 0xd0, 0x3c, 0x8f, 0xc6, 0xee, 0xb9,
-	0x1f, 0xa6, 0x52, 0xe4, 0x3b, 0x99, 0x99, 0xbf, 0x87, 0x13, 0xa2, 0x08, 0xec, 0x3f, 0x9d, 0x85,
-	0xb9, 0xa7, 0xe1, 0x45, 0xe4, 0x0f, 0xf0, 0x8c, 0x79, 0x44, 0x47, 0x91, 0xbc, 0x09, 0xc0, 0x7e,
-	0x93, 0x1b, 0x30, 0x87, 0xa9, 0xaf, 0x63, 0xce, 0xb4, 0x6d, 0x9e, 0x4b, 0x22, 0x40, 0x78, 0x7f,
-	0x35, 0xbb, 0xc5, 0xc7, 0x85, 0x4a, 0x83, 0x30, 0x37, 0x30, 0xd6, 0x6f, 0xe1, 0x89, 0x52, 0xe6,
-	0x19, 0xd5, 0xb5, 0x9b, 0x16, 0xac, 0x2d, 0x91, 0x0a, 0xc8, 0x73, 0xc5, 0x78, 0x5b, 0x02, 0x84,
-	0xae, 0x6b, 0x4c, 0x79, 0x38, 0x5f, 0x19, 0x59, 0xcc, 0x75, 0xd5, 0x81, 0xcc, 0x10, 0xe3, 0x1f,
-	0x70, 0x1a, 0xbe, 0x01, 0xe8, 0x20, 0x66, 0x8a, 0xe6, 0x2f, 0x7e, 0xf2, 0x8b, 0xb7, 0x79, 0x30,
-	0xd3, 0xdf, 0x43, 0xaa, 0xd4, 0x2c, 0x1f, 0x07, 0xf0, 0x9b, 0x8a, 0x79, 0xb8, 0xe6, 0xf0, 0xf2,
-	0x2c, 0x65, 0xe9, 0xf0, 0x32, 0x86, 0xf1, 0x82, 0xe0, 0xc4, 0x1b, 0xbc, 0xc4, 0x7b, 0xbf, 0x78,
-	0xea, 0xdb, 0x74, 0x4c, 0x20, 0x26, 0xf4, 0x65, 0xab, 0x8a, 0x59, 0x37, 0x35, 0x47, 0x07, 0x91,
-	0x07, 0xd0, 0xc2, 0x40, 0x80, 0x58, 0xd7, 0x0e, 0xae, 0x6b, 0x57, 0x8f, 0x14, 0xe0, 0xca, 0xea,
-	0x44, 0xfa, 0xf9, 0xf7, 0x42, 0x21, 0x6f, 0xd8, 0x1b, 0x0e, 0x45, 0xda, 0x40, 0x97, 0x07, 0x35,
-	0x14, 0x00, 0x43, 0x0d, 0x7c, 0xc2, 0x38, 0xc1, 0x22, 0x12, 0x18, 0x30, 0x72, 0x13, 0x1a, 0xcc,
-	0xc3, 0x1b, 0x7b, 0xfe, 0x10, 0x13, 0x6d, 0xb8, 0xa3, 0xa9, 0x60, 0xac, 0x0e, 0xf9, 0x1b, 0xb7,
-	0xca, 0x25, 0x9c, 0x15, 0x03, 0xc6, 0xe6, 0x46, 0x95, 0x47, 0x59, 0xa2, 0xb1, 0x09, 0x24, 0x1f,
-	0xe0, 0xe1, 0x6d, 0x4a, 0x31, 0x9b, 0xb8, 0xf3, 0xe0, 0x1d, 0x31, 0x66, 0xc1, 0xb4, 0xf2, 0xef,
-	0x11, 0x23, 0x71, 0x38, 0x25, 0x33, 0xd2, 0x78, 0xfc, 0x7c, 0xc5, 0x30, 0xd2, 0x04, 0x29, 0xc6,
-	0xcf, 0x39, 0x81, 0xbd, 0x05, 0x6d, 0xbd, 0x02, 0xd2, 0x80, 0xda, 0xb3, 0xc3, 0xdd, 0x83, 0xee,
-	0x0c, 0x69, 0xc1, 0xdc, 0xd1, 0xee, 0xf1, 0xf1, 0xfe, 0xee, 0x4e, 0xd7, 0x22, 0x6d, 0x68, 0xa8,
-	0x3c, 0xcd, 0x0a, 0x2b, 0x6d, 0x6d, 0x6f, 0xef, 0x1e, 0x1e, 0xef, 0xee, 0x74, 0xab, 0xf6, 0x1f,
-	0x57, 0xa0, 0xa5, 0xd5, 0xfc, 0x9a, 0xe0, 0xcb, 0x4d, 0x00, 0xf4, 0x18, 0xb2, 0x6c, 0x8d, 0x9a,
-	0xa3, 0x41, 0x98, 0x46, 0x54, 0xbe, 0x74, 0x95, 0x5f, 0x58, 0x94, 0x65, 0x9c, 0x2b, 0xbc, 0x19,
-	0xa8, 0x1f, 0x51, 0xd4, 0x1d, 0x13, 0xc8, 0xf8, 0x48, 0x00, 0x30, 0x65, 0x90, 0x4b, 0x97, 0x0e,
-	0x62, 0xeb, 0x12, 0xd3, 0x24, 0x0a, 0x2e, 0x28, 0x27, 0xe1, 0xf6, 0x97, 0x01, 0x63, 0x6d, 0x09,
-	0xf5, 0xa2, 0xa5, 0xf3, 0xd6, 0x1d, 0x13, 0x48, 0xbe, 0x2e, 0xd7, 0xa5, 0x81, 0xeb, 0xb2, 0x5a,
-	0x9c, 0x64, 0x7d, 0x4d, 0xec, 0x14, 0xc8, 0xd6, 0x70, 0x28, 0xb0, 0xfa, 0xf5, 0xc7, 0x58, 0xbf,
-	0x6b, 0x2b, 0x15, 0x44, 0x89, 0x90, 0x56, 0xca, 0x85, 0xf4, 0xb5, 0xac, 0x6c, 0xef, 0x42, 0xeb,
-	0x50, 0xbb, 0xbd, 0x8b, 0xfa, 0x4a, 0xde, 0xdb, 0x15, 0x7a, 0x4e, 0x83, 0x68, 0xdd, 0xa9, 0xe8,
-	0xdd, 0xb1, 0xff, 0xd8, 0xe2, 0x17, 0xa2, 0x54, 0xf7, 0x79, 0xdb, 0x36, 0xb4, 0x55, 0x00, 0x3a,
-	0xcb, 0x54, 0x37, 0x60, 0x8c, 0x06, 0xbb, 0xe2, 0x46, 0xa7, 0xa7, 0x09, 0x95, 0x79, 0xa5, 0x06,
-	0x4c, 0x1a, 0x8a, 0xcc, 0xf4, 0xf4, 0x79, 0x0b, 0x89, 0xc8, 0x2f, 0x2d, 0xc0, 0x19, 0x93, 0x88,
-	0x38, 0xa3, 0xcc, 0xa8, 0x55, 0x65, 0x95, 0x50, 0x9f, 0x9f, 0xe5, 0x75, 0x68, 0xa8, 0x7a, 0xcd,
-	0x1d, 0x41, 0x52, 0x2a, 0x3c, 0xdb, 0x79, 0xd0, 0x81, 0x34, 0x3a, 0xcd, 0x79, 0xb5, 0x88, 0x20,
-	0x1b, 0x40, 0x4e, 0xfd, 0x38, 0x4f, 0xce, 0x99, 0xb7, 0x04, 0x63, 0xbf, 0x80, 0x25, 0x29, 0x6f,
-	0x9a, 0x05, 0x6b, 0x2e, 0xa2, 0xf5, 0x26, 0x7d, 0x54, 0x29, 0xea, 0x23, 0xfb, 0xd7, 0x55, 0x98,
-	0x13, 0x2b, 0x5d, 0xb8, 0x01, 0xce, 0xd7, 0xd9, 0x80, 0x91, 0x9e, 0x71, 0xd7, 0x0f, 0x95, 0x97,
-	0xd8, 0x85, 0x0a, 0xfb, 0x4c, 0xb5, 0x6c, 0x9f, 0x21, 0x50, 0x1b, 0x7b, 0xe9, 0x39, 0x86, 0x58,
-	0x9a, 0x0e, 0xfe, 0x96, 0xa1, 0xd0, 0xba, 0x19, 0x0a, 0x2d, 0xbb, 0xef, 0xce, 0x4d, 0xa8, 0xe2,
-	0x7d, 0xf7, 0x1b, 0xd0, 0xe4, 0x77, 0xa4, 0xb3, 0x68, 0x67, 0x06, 0x60, 0xdc, 0xcb, 0x0b, 0xa8,
-	0x21, 0xc4, 0xd5, 0x9b, 0x0c, 0xf2, 0x05, 0x76, 0xb6, 0x6f, 0xc2, 0x2c, 0xbf, 0xfb, 0x21, 0xf2,
-	0x86, 0x6f, 0xc8, 0x13, 0x46, 0x4e, 0x27, 0xff, 0xf2, 0x04, 0x24, 0x47, 0xd0, 0xea, 0x37, 0x47,
-	0x5b, 0xe6, 0xcd, 0x51, 0x3d, 0x48, 0xdb, 0x36, 0x83, 0xb4, 0xf6, 0x63, 0x98, 0x37, 0xaa, 0x63,
-	0x9a, 0x55, 0xe4, 0x1d, 0x77, 0x67, 0xc8, 0x3c, 0x34, 0x9f, 0x1e, 0xb8, 0x8f, 0xf7, 0x9f, 0x3e,
-	0xd9, 0x3b, 0xee, 0x5a, 0xac, 0x78, 0xf4, 0x7c, 0x7b, 0x7b, 0x77, 0x77, 0x07, 0x35, 0x2d, 0xc0,
-	0xec, 0xe3, 0xad, 0xa7, 0xfb, 0xa8, 0x67, 0x77, 0x38, 0x6f, 0x8b, 0xba, 0xd4, 0xa9, 0xce, 0xd7,
-	0x81, 0x48, 0x1f, 0x1f, 0xf3, 0x8f, 0xc6, 0x01, 0x4d, 0x65, 0x4a, 0xfc, 0xa2, 0xc0, 0x3c, 0x55,
-	0x08, 0x79, 0xa3, 0x23, 0xab, 0x25, 0x13, 0x11, 0x31, 0x49, 0x79, 0x11, 0x11, 0xa4, 0x8e, 0xc2,
-	0xdb, 0x7d, 0xe8, 0xed, 0x50, 0x56, 0xdb, 0x56, 0x10, 0xe4, 0xba, 0xc3, 0x1c, 0xb5, 0x12, 0x9c,
-	0xf0, 0xe2, 0xbe, 0x07, 0xd7, 0xb6, 0x78, 0xf6, 0xfb, 0x97, 0x95, 0x1c, 0x69, 0xf7, 0x60, 0x25,
-	0x5f, 0xa5, 0x68, 0xec, 0x31, 0x2c, 0xee, 0xd0, 0x93, 0xc9, 0xd9, 0x3e, 0xbd, 0xc8, 0x1a, 0x22,
-	0x50, 0x4b, 0xce, 0xa3, 0x4b, 0x31, 0x3f, 0xf8, 0x9b, 0xbc, 0x0b, 0x10, 0x30, 0x1a, 0x37, 0x19,
-	0xd3, 0x81, 0xbc, 0x6f, 0x88, 0x90, 0xa3, 0x31, 0x1d, 0xd8, 0x1f, 0x02, 0xd1, 0xeb, 0x11, 0xf3,
-	0xc5, 0xec, 0xac, 0xc9, 0x89, 0x9b, 0x5c, 0x25, 0x29, 0x1d, 0xc9, 0x8b, 0x94, 0x3a, 0xc8, 0xbe,
-	0x0b, 0xed, 0x43, 0xef, 0xca, 0xa1, 0x3f, 0x15, 0x2f, 0x21, 0xac, 0xc2, 0xdc, 0xd8, 0xbb, 0x62,
-	0x2c, 0xa8, 0x82, 0xbe, 0x88, 0xb6, 0xff, 0x4f, 0x05, 0x66, 0x39, 0x25, 0xab, 0x75, 0x48, 0x93,
-	0xd4, 0x0f, 0x51, 0xd2, 0x64, 0xad, 0x1a, 0xa8, 0x20, 0xdb, 0x95, 0x12, 0xd9, 0x16, 0x11, 0x09,
-	0x79, 0x77, 0x4b, 0x08, 0xb0, 0x01, 0x63, 0x92, 0x96, 0x65, 0x39, 0xf3, 0xd0, 0x60, 0x06, 0xc8,
-	0x1d, 0x5f, 0x64, 0xd6, 0x1c, 0xef, 0x9f, 0x54, 0x5b, 0x42, 0x8c, 0x75, 0x50, 0xa9, 0xcd, 0x38,
-	0xc7, 0xa5, 0xbd, 0x60, 0x33, 0x16, 0x6c, 0xc3, 0xc6, 0x5b, 0xd8, 0x86, 0x3c, 0x4c, 0xf1, 0x3a,
-	0xdb, 0x10, 0xde, 0xc2, 0x36, 0xb4, 0x09, 0x74, 0xf1, 0x52, 0x38, 0xf3, 0x3e, 0x24, 0xef, 0xfe,
-	0x43, 0x0b, 0xba, 0x82, 0x8b, 0x14, 0x8e, 0xbc, 0x67, 0x78, 0x59, 0xa5, 0x77, 0x94, 0x6e, 0xc3,
-	0x3c, 0xfa, 0x3e, 0x4a, 0x05, 0x88, 0x43, 0x25, 0x03, 0xc8, 0xc6, 0x21, 0x73, 0x64, 0x46, 0x7e,
-	0x20, 0x16, 0x45, 0x07, 0x49, 0x2d, 0x12, 0x7b, 0x22, 0x5b, 0xd7, 0x72, 0x54, 0xd9, 0xfe, 0x95,
-	0x05, 0x8b, 0x5a, 0x87, 0x05, 0x17, 0x7e, 0x0c, 0x6d, 0xf5, 0xf6, 0x02, 0x55, 0x9b, 0xdb, 0xaa,
-	0x29, 0x36, 0xd9, 0x67, 0x06, 0x31, 0x2e, 0xa6, 0x77, 0x85, 0x1d, 0x4c, 0x26, 0x23, 0xb1, 0xab,
-	0xe8, 0x20, 0xc6, 0x48, 0x97, 0x94, 0xbe, 0x54, 0x24, 0x7c, 0x5f, 0x33, 0x60, 0x18, 0x1f, 0x66,
-	0x3e, 0x9b, 0x22, 0xaa, 0x89, 0xf8, 0xb0, 0x0e, 0xb4, 0xff, 0x7a, 0x05, 0x96, 0xb8, 0xf3, 0x2d,
-	0x02, 0x1e, 0xea, 0xfa, 0xeb, 0x2c, 0x8f, 0x41, 0x70, 0x89, 0xdc, 0x9b, 0x71, 0x44, 0x99, 0x7c,
-	0xeb, 0x2d, 0x03, 0x06, 0x2a, 0x85, 0x78, 0xca, 0x5a, 0x54, 0xcb, 0xd6, 0xe2, 0x35, 0x33, 0x5d,
-	0x16, 0xaa, 0xaf, 0x97, 0x87, 0xea, 0xdf, 0x2a, 0x34, 0xfe, 0x68, 0x0e, 0xea, 0xc9, 0x20, 0x1a,
-	0x53, 0x7b, 0x05, 0x96, 0xcd, 0x29, 0x10, 0x8a, 0xea, 0x17, 0x16, 0xf4, 0x1e, 0xf3, 0x23, 0x3f,
-	0x3f, 0x3c, 0xdb, 0xf3, 0x93, 0x34, 0x8a, 0xd5, 0x5b, 0x02, 0x37, 0x01, 0x92, 0xd4, 0x8b, 0x85,
-	0x41, 0x2b, 0xc2, 0xe4, 0x19, 0x84, 0x8d, 0x84, 0x86, 0x43, 0x8e, 0xe5, 0x2b, 0xa8, 0xca, 0x05,
-	0xd3, 0x4b, 0x04, 0x11, 0x0c, 0x03, 0xe6, 0x0e, 0x4f, 0xbc, 0x67, 0x5d, 0xa6, 0x17, 0xa8, 0xfd,
-	0xb9, 0x77, 0x9e, 0x83, 0xda, 0xff, 0xd9, 0x82, 0x85, 0xac, 0x93, 0x98, 0x20, 0x62, 0xea, 0x10,
-	0x61, 0xb5, 0x64, 0x3a, 0x44, 0x06, 0xf0, 0x7d, 0x66, 0xc6, 0x48, 0x6b, 0x3f, 0x83, 0xa0, 0x5c,
-	0x8b, 0x52, 0x34, 0x91, 0x76, 0xa1, 0x0e, 0xe2, 0x69, 0xb4, 0xcc, 0x80, 0x12, 0xc6, 0xa0, 0x28,
-	0xe1, 0x15, 0xa6, 0x51, 0x8a, 0x5f, 0xf1, 0x19, 0x97, 0x45, 0xd2, 0xe5, 0x16, 0x08, 0x7f, 0x57,
-	0x05, 0xad, 0x0f, 0x7d, 0x67, 0x6e, 0xa8, 0x47, 0x50, 0xf8, 0xce, 0xfc, 0x77, 0x2d, 0xb8, 0x5e,
-	0x32, 0xf1, 0x42, 0xb6, 0x76, 0x60, 0xf1, 0x54, 0x21, 0xe5, 0xe4, 0x70, 0x01, 0x5b, 0x91, 0x19,
-	0x0e, 0xe6, 0x84, 0x38, 0xc5, 0x0f, 0x94, 0x39, 0xc9, 0xa7, 0xdb, 0x48, 0x54, 0x2f, 0x22, 0xec,
-	0x43, 0xe8, 0xef, 0xbe, 0x62, 0xa2, 0xba, 0xad, 0x3f, 0xe0, 0x26, 0x79, 0xe1, 0x41, 0x41, 0x15,
-	0xbd, 0x39, 0xe0, 0x73, 0x0a, 0xf3, 0x46, 0x5d, 0xe4, 0x1b, 0x6f, 0x5b, 0x89, 0x2e, 0x55, 0x72,
-	0xad, 0xf8, 0x0b, 0x74, 0x32, 0x5d, 0x5e, 0x03, 0xd9, 0x17, 0xb0, 0xf0, 0xe9, 0x24, 0x48, 0xfd,
-	0xec, 0x35, 0x3a, 0xf2, 0x2d, 0xf1, 0x11, 0x56, 0x21, 0xa7, 0xae, 0xb4, 0x29, 0x9d, 0x8e, 0xcd,
-	0xd8, 0x88, 0xd5, 0xe4, 0x16, 0x5b, 0x2c, 0x22, 0xec, 0xeb, 0xb0, 0x9a, 0x35, 0xc9, 0xe7, 0x4e,
-	0xaa, 0xf3, 0x5f, 0x5a, 0x3c, 0xef, 0xcb, 0x7c, 0x1c, 0x8f, 0x3c, 0x81, 0xa5, 0xc4, 0x0f, 0xcf,
-	0x02, 0xaa, 0xd7, 0x93, 0x88, 0x99, 0xb8, 0x66, 0x76, 0x4f, 0x3c, 0xa0, 0xe7, 0x94, 0x7d, 0xc1,
-	0x18, 0xa4, 0xbc, 0xa3, 0x19, 0x83, 0xe4, 0xa6, 0xa4, 0x6c, 0x00, 0xdf, 0x85, 0x8e, 0xd9, 0x18,
-	0x79, 0x28, 0x32, 0xdd, 0xb3, 0x9e, 0xe9, 0xa7, 0x32, 0x26, 0x67, 0x18, 0x94, 0xf6, 0xcf, 0x2d,
-	0xe8, 0x39, 0x94, 0xb1, 0x31, 0xd5, 0x1a, 0x15, 0xdc, 0xf3, 0x71, 0xa1, 0xda, 0xe9, 0x03, 0x56,
-	0x19, 0xf4, 0x72, 0xac, 0x1b, 0x53, 0x17, 0x65, 0x6f, 0xa6, 0x64, 0x54, 0x8f, 0x1a, 0x30, 0x2b,
-	0xc6, 0xb7, 0x0a, 0xd7, 0x44, 0x97, 0x64, 0x77, 0xb2, 0x90, 0xbe, 0xd1, 0xa8, 0x11, 0xd2, 0xef,
-	0x43, 0x8f, 0x3f, 0xf2, 0xa0, 0x8f, 0x83, 0x7f, 0xb8, 0xfe, 0x39, 0xb4, 0xb4, 0xa7, 0x2e, 0xc8,
-	0x2a, 0x2c, 0xbd, 0x78, 0x7a, 0x7c, 0xb0, 0x7b, 0x74, 0xe4, 0x1e, 0x3e, 0x7f, 0xf4, 0xc9, 0xee,
-	0x0f, 0xdc, 0xbd, 0xad, 0xa3, 0xbd, 0xee, 0x0c, 0x59, 0x01, 0x72, 0xb0, 0x7b, 0x74, 0xbc, 0xbb,
-	0x63, 0xc0, 0x2d, 0x72, 0x13, 0xfa, 0xcf, 0x0f, 0x9e, 0x1f, 0xed, 0xee, 0xb8, 0x65, 0xdf, 0x55,
-	0xc8, 0xbb, 0x70, 0x5d, 0xe0, 0x4b, 0x3e, 0xaf, 0xae, 0x7f, 0x1b, 0xba, 0x79, 0x1f, 0xdf, 0x88,
-	0x88, 0xe4, 0x42, 0x27, 0xf3, 0xd0, 0xe4, 0xa1, 0x13, 0x8c, 0x9d, 0x3c, 0xf8, 0x79, 0x15, 0x3a,
-	0x3c, 0x79, 0x8d, 0xbf, 0xc8, 0x48, 0x63, 0xf2, 0x29, 0xcc, 0x89, 0xa7, 0x3d, 0x89, 0x5c, 0x0d,
-	0xf3, 0x31, 0xd1, 0xfe, 0x4a, 0x1e, 0x2c, 0xa6, 0x70, 0xe9, 0x6f, 0xfc, 0xd9, 0xff, 0xf8, 0xfb,
-	0x95, 0x79, 0xd2, 0xda, 0xbc, 0xf8, 0x60, 0xf3, 0x8c, 0x86, 0x09, 0xab, 0xe3, 0x0f, 0x01, 0xb2,
-	0x07, 0x2b, 0x49, 0x4f, 0x39, 0xba, 0xb9, 0xd7, 0x3c, 0xfb, 0xd7, 0x4b, 0x30, 0xa2, 0xde, 0xeb,
-	0x58, 0xef, 0x92, 0xdd, 0x61, 0xf5, 0xfa, 0xa1, 0x9f, 0xf2, 0xc7, 0x2b, 0x3f, 0xb2, 0xd6, 0xc9,
-	0x10, 0xda, 0xfa, 0x53, 0x92, 0x44, 0x1e, 0x6a, 0x94, 0x3c, 0x86, 0xd9, 0x7f, 0xa7, 0x14, 0x27,
-	0x97, 0x1f, 0xdb, 0xb8, 0x66, 0x77, 0x59, 0x1b, 0x13, 0xa4, 0xc8, 0x5a, 0x09, 0xb8, 0x50, 0x64,
-	0x2f, 0x46, 0x92, 0x1b, 0x1a, 0x9f, 0x16, 0xde, 0xab, 0xec, 0xbf, 0x3b, 0x05, 0x2b, 0xda, 0x7a,
-	0x17, 0xdb, 0x5a, 0xb5, 0x09, 0x6b, 0x6b, 0x80, 0x34, 0xf2, 0xbd, 0xca, 0x8f, 0xac, 0xf5, 0x07,
-	0xff, 0xeb, 0x0e, 0x34, 0xd5, 0x61, 0x27, 0xf9, 0x09, 0xcc, 0x1b, 0xd9, 0x85, 0x44, 0x0e, 0xa3,
-	0x2c, 0x19, 0xb1, 0x7f, 0xa3, 0x1c, 0x29, 0x1a, 0xbe, 0x89, 0x0d, 0xf7, 0xc8, 0x0a, 0x6b, 0x58,
-	0xa4, 0xe7, 0x6d, 0x62, 0x9e, 0x2c, 0xbf, 0x66, 0xf7, 0x52, 0x13, 0x7e, 0xde, 0xd8, 0x8d, 0xbc,
-	0x3c, 0x1a, 0xad, 0xbd, 0x3b, 0x05, 0x2b, 0x9a, 0xbb, 0x81, 0xcd, 0xad, 0x90, 0x65, 0xbd, 0x39,
-	0x75, 0x08, 0x49, 0xf1, 0x6e, 0xa9, 0xfe, 0x98, 0x22, 0x79, 0x57, 0x31, 0x56, 0xd9, 0x23, 0x8b,
-	0x8a, 0x45, 0x8a, 0x2f, 0x2d, 0xda, 0x3d, 0x6c, 0x8a, 0x10, 0x5c, 0x3e, 0xfd, 0x2d, 0x45, 0x72,
-	0x02, 0x2d, 0xed, 0xd9, 0x25, 0x72, 0x7d, 0xea, 0x13, 0x51, 0xfd, 0x7e, 0x19, 0xaa, 0x6c, 0x28,
-	0x7a, 0xfd, 0x9b, 0x6c, 0x57, 0xff, 0x11, 0x34, 0xd5, 0x43, 0x3e, 0x64, 0x55, 0x7b, 0x58, 0x49,
-	0x7f, 0x78, 0xa8, 0xdf, 0x2b, 0x22, 0xca, 0x98, 0x4f, 0xaf, 0x9d, 0x31, 0xdf, 0x0b, 0x68, 0x69,
-	0x8f, 0xf5, 0xa8, 0x01, 0x14, 0x1f, 0x04, 0x52, 0x03, 0x28, 0x79, 0xdb, 0xc7, 0x5e, 0xc4, 0x26,
-	0x5a, 0xa4, 0x89, 0xfc, 0x9d, 0xbe, 0x8a, 0x12, 0xb2, 0x0f, 0xd7, 0x84, 0x92, 0x3b, 0xa1, 0x5f,
-	0x64, 0x19, 0x4a, 0xde, 0xaf, 0xbc, 0x6f, 0x91, 0x8f, 0xa1, 0x21, 0xdf, 0x64, 0x22, 0x2b, 0xe5,
-	0x6f, 0x4b, 0xf5, 0x57, 0x0b, 0x70, 0x61, 0xdc, 0xfc, 0x00, 0x20, 0x7b, 0x19, 0x48, 0x29, 0x89,
-	0xc2, 0x4b, 0x43, 0x8a, 0x03, 0x8a, 0xcf, 0x08, 0xd9, 0x2b, 0x38, 0xc0, 0x2e, 0x41, 0x25, 0x11,
-	0xd2, 0x4b, 0x79, 0x8d, 0xfc, 0xc7, 0xd0, 0xd2, 0x1e, 0x07, 0x52, 0xd3, 0x57, 0x7c, 0x58, 0x48,
-	0x4d, 0x5f, 0xc9, 0x5b, 0x42, 0x76, 0x1f, 0x6b, 0x5f, 0xb6, 0x17, 0x58, 0xed, 0x89, 0x7f, 0x16,
-	0x8e, 0x38, 0x01, 0x5b, 0xa0, 0x73, 0x98, 0x37, 0x5e, 0x00, 0x52, 0x12, 0x5a, 0xf6, 0xbe, 0x90,
-	0x92, 0xd0, 0xd2, 0x47, 0x83, 0x24, 0x9f, 0xd9, 0x8b, 0xac, 0x9d, 0x0b, 0x24, 0xd1, 0x5a, 0xfa,
-	0x21, 0xb4, 0xb4, 0xd7, 0x7c, 0xd4, 0x58, 0x8a, 0x0f, 0x07, 0xa9, 0xb1, 0x94, 0x3d, 0xfe, 0xb3,
-	0x8c, 0x6d, 0x74, 0x6c, 0x64, 0x05, 0xbc, 0x10, 0xcd, 0xea, 0xfe, 0x09, 0x74, 0xcc, 0xf7, 0x7d,
-	0x94, 0xec, 0x97, 0xbe, 0x14, 0xa4, 0x64, 0x7f, 0xca, 0xa3, 0x40, 0x82, 0xa5, 0xd7, 0x97, 0x54,
-	0x23, 0x9b, 0x9f, 0x89, 0x54, 0xa9, 0xcf, 0xc9, 0xf7, 0x98, 0x82, 0x13, 0x37, 0xd4, 0xc9, 0xaa,
-	0xc6, 0xb5, 0xfa, 0x3d, 0x76, 0x25, 0x2f, 0x85, 0xcb, 0xec, 0x26, 0x33, 0xf3, 0x2b, 0xdd, 0xb8,
-	0x6b, 0xe1, 0x4d, 0x75, 0x6d, 0xd7, 0xd2, 0x2f, 0xb3, 0x6b, 0xbb, 0x96, 0x71, 0xa1, 0x3d, 0xbf,
-	0x6b, 0xa5, 0x3e, 0xab, 0x23, 0x84, 0x85, 0xdc, 0x0d, 0x08, 0x25, 0x15, 0xe5, 0x97, 0xd4, 0xfa,
-	0x37, 0x5f, 0x7f, 0x71, 0xc2, 0xd4, 0x20, 0x52, 0x09, 0x6e, 0xca, 0x2b, 0x81, 0x7f, 0x05, 0xda,
-	0xfa, 0xcb, 0x26, 0x44, 0x17, 0xe5, 0x7c, 0x4b, 0xef, 0x94, 0xe2, 0xcc, 0xc5, 0x25, 0x6d, 0xbd,
-	0x19, 0xf2, 0x7d, 0x58, 0x51, 0xa2, 0xae, 0x27, 0xd5, 0x27, 0xe4, 0x56, 0x49, 0xaa, 0xbd, 0x6e,
-	0xfa, 0xf4, 0xaf, 0x4f, 0xcd, 0xc5, 0xbf, 0x6f, 0x31, 0xa6, 0x31, 0x9f, 0x8c, 0xc8, 0x36, 0x8c,
-	0xb2, 0x97, 0x32, 0xb2, 0x0d, 0xa3, 0xf4, 0x9d, 0x09, 0xc9, 0x34, 0x64, 0xc9, 0x98, 0x23, 0x7e,
-	0xca, 0x4c, 0x7e, 0x08, 0x0b, 0xda, 0xb5, 0xa5, 0xa3, 0xab, 0x70, 0xa0, 0x04, 0xa0, 0x78, 0xa3,
-	0xb6, 0x5f, 0x66, 0xd8, 0xdb, 0xab, 0x58, 0xff, 0xa2, 0x6d, 0x4c, 0x0e, 0x63, 0xfe, 0x6d, 0x68,
-	0xe9, 0x57, 0xa2, 0x5e, 0x53, 0xef, 0xaa, 0x86, 0xd2, 0x2f, 0x84, 0xde, 0xb7, 0xc8, 0x21, 0xcf,
-	0x30, 0x52, 0x8f, 0x4a, 0x46, 0x71, 0x7e, 0xfb, 0x34, 0x1f, 0x9b, 0x54, 0x0b, 0x59, 0xf6, 0xcc,
-	0xe8, 0x3d, 0xeb, 0xbe, 0x45, 0xfe, 0x91, 0x05, 0x6d, 0xe3, 0xca, 0x92, 0x91, 0xb3, 0x91, 0xeb,
-	0x59, 0x4f, 0xc7, 0xe9, 0x5d, 0xb3, 0x1d, 0x1c, 0xf6, 0xfe, 0xfa, 0x77, 0x8d, 0x69, 0xfd, 0xcc,
-	0x88, 0x1a, 0x6d, 0xe4, 0x5f, 0x96, 0xfc, 0x3c, 0x4f, 0xa0, 0xdf, 0x63, 0xfe, 0xfc, 0xbe, 0x45,
-	0xfe, 0xc4, 0x82, 0x8e, 0x19, 0xeb, 0x54, 0xc3, 0x2d, 0x8d, 0xaa, 0xaa, 0xc5, 0x9f, 0x12, 0x20,
-	0xfd, 0x21, 0xf6, 0xf2, 0x78, 0xdd, 0x31, 0x7a, 0x29, 0x9e, 0x27, 0xf9, 0xdd, 0x7a, 0x4b, 0x3e,
-	0xe2, 0xcf, 0x20, 0xcb, 0x13, 0x09, 0x52, 0x7c, 0x90, 0x57, 0x31, 0x8c, 0xfe, 0x84, 0x2e, 0x2e,
-	0xc2, 0x8f, 0xf9, 0x8b, 0x8a, 0x32, 0x68, 0xce, 0xf8, 0xee, 0x6d, 0xbf, 0xb7, 0x6f, 0xe3, 0x98,
-	0x6e, 0xda, 0xd7, 0x8d, 0x31, 0xe5, 0x77, 0xf8, 0x2d, 0xde, 0x3b, 0xf1, 0xfa, 0x6d, 0xb6, 0x45,
-	0x15, 0x5e, 0xc4, 0x9d, 0xde, 0xc9, 0x11, 0xef, 0xa4, 0x20, 0x37, 0x84, 0xe3, 0x2d, 0xab, 0xb1,
-	0xd7, 0xb1, 0xaf, 0xb7, 0xed, 0x5b, 0x53, 0xfb, 0xba, 0x89, 0x11, 0x4b, 0xd6, 0xe3, 0x43, 0x80,
-	0xec, 0xf4, 0x90, 0xe4, 0x4e, 0xaf, 0x94, 0xca, 0x28, 0x1e, 0x30, 0x9a, 0x12, 0x28, 0x0f, 0xb9,
-	0x58, 0x8d, 0x3f, 0xe2, 0x0a, 0xf0, 0xa9, 0x3c, 0xf7, 0xd2, 0xcd, 0x1c, 0xf3, 0x98, 0xcf, 0x30,
-	0x73, 0xf2, 0xf5, 0x1b, 0xea, 0x4f, 0x1d, 0xa2, 0x3d, 0x87, 0xf9, 0xfd, 0x28, 0x7a, 0x39, 0x19,
-	0xab, 0xd4, 0x0a, 0xf3, 0x30, 0x61, 0xcf, 0x4b, 0xce, 0xfb, 0xb9, 0x51, 0xd8, 0x6b, 0x58, 0x55,
-	0x9f, 0xf4, 0xb4, 0xaa, 0x36, 0x3f, 0xcb, 0x4e, 0x27, 0x3f, 0x27, 0x1e, 0x2c, 0x2a, 0xad, 0xaa,
-	0x3a, 0xde, 0x37, 0xab, 0x31, 0x74, 0x69, 0xbe, 0x09, 0xc3, 0x1e, 0x97, 0xbd, 0xdd, 0x4c, 0x64,
-	0x9d, 0xa8, 0x53, 0xda, 0x3b, 0x74, 0x80, 0x17, 0x26, 0x30, 0x22, 0xbf, 0x94, 0x75, 0x5c, 0x85,
-	0xf2, 0xfb, 0xf3, 0x06, 0xd0, 0xdc, 0x69, 0xc6, 0xde, 0x55, 0x4c, 0x7f, 0xba, 0xf9, 0x99, 0x88,
-	0xf5, 0x7f, 0x2e, 0x77, 0x1a, 0x79, 0x18, 0x62, 0xec, 0x34, 0xb9, 0xd3, 0x13, 0x63, 0xa7, 0x29,
-	0x9c, 0x9e, 0x18, 0x53, 0x2d, 0x0f, 0x63, 0x48, 0x00, 0x8b, 0x85, 0x03, 0x17, 0xb5, 0xc9, 0x4c,
-	0x3b, 0xa6, 0xe9, 0xaf, 0x4d, 0x27, 0x30, 0x5b, 0x5b, 0x37, 0x5b, 0x3b, 0x82, 0xf9, 0x1d, 0xca,
-	0x27, 0x8b, 0xe7, 0x8e, 0xe6, 0xee, 0xbd, 0xe9, 0x99, 0xa9, 0xf9, 0x2d, 0x01, 0x71, 0xa6, 0x29,
-	0x81, 0x89, 0x9b, 0xe4, 0x47, 0xd0, 0x7a, 0x42, 0x53, 0x99, 0x2c, 0xaa, 0x8c, 0xd9, 0x5c, 0xf6,
-	0x68, 0xbf, 0x24, 0xd7, 0xd4, 0xe4, 0x19, 0xac, 0x6d, 0x93, 0x0e, 0xcf, 0x28, 0x57, 0x4e, 0xae,
-	0x3f, 0xfc, 0x9c, 0xfc, 0x65, 0xac, 0x5c, 0x65, 0xca, 0xaf, 0x68, 0xd9, 0x7f, 0x7a, 0xe5, 0x0b,
-	0x39, 0x78, 0x59, 0xcd, 0x61, 0x34, 0xa4, 0x9a, 0x51, 0x15, 0x42, 0x4b, 0xbb, 0xce, 0xa2, 0x04,
-	0xa8, 0x78, 0xb7, 0x47, 0x09, 0x50, 0xc9, 0xed, 0x17, 0xfb, 0x1e, 0xb6, 0x63, 0x93, 0xb5, 0xac,
-	0x1d, 0x7e, 0xe3, 0x25, 0x6b, 0x69, 0xf3, 0x33, 0x6f, 0x94, 0x7e, 0x4e, 0x5e, 0xe0, 0x73, 0x41,
-	0x7a, 0x42, 0x6c, 0x66, 0x9d, 0xe7, 0x73, 0x67, 0xd5, 0x64, 0x69, 0x28, 0xd3, 0x62, 0xe7, 0x4d,
-	0xa1, 0xed, 0xf5, 0x2d, 0x80, 0xa3, 0x34, 0x1a, 0xef, 0x78, 0x74, 0x14, 0x85, 0x99, 0xae, 0xcd,
-	0xd2, 0x31, 0x33, 0xfd, 0xa5, 0xe5, 0x64, 0x92, 0x17, 0x9a, 0x3b, 0x63, 0xe4, 0x13, 0x4b, 0xe6,
-	0x9a, 0x9a, 0xb1, 0xa9, 0x26, 0xa4, 0x24, 0x6b, 0xf3, 0xbe, 0x45, 0xb6, 0x00, 0xb2, 0x13, 0x37,
-	0xe5, 0x9c, 0x14, 0x0e, 0xf3, 0x94, 0xda, 0x2b, 0x39, 0x9e, 0x3b, 0x84, 0x66, 0x76, 0x84, 0xb3,
-	0x9a, 0x5d, 0x48, 0x33, 0x0e, 0x7c, 0xd4, 0x0e, 0x5e, 0x38, 0x58, 0xb1, 0xbb, 0x38, 0x55, 0x40,
-	0x1a, 0x6c, 0xaa, 0xf0, 0xb4, 0xc4, 0x87, 0x25, 0xde, 0x41, 0x65, 0xe0, 0x60, 0x2a, 0xa1, 0x1c,
-	0x49, 0xc9, 0xe1, 0x86, 0x92, 0xe6, 0xd2, 0xa8, 0xbf, 0x11, 0x63, 0x61, 0xdc, 0xca, 0xd3, 0x18,
-	0x99, 0x6a, 0x1e, 0xc1, 0x62, 0x21, 0x2c, 0xad, 0x44, 0x7a, 0xda, 0x49, 0x81, 0x12, 0xe9, 0xa9,
-	0x11, 0x6d, 0xfb, 0x1a, 0x36, 0xb9, 0x60, 0x03, 0xfa, 0x54, 0x97, 0x7e, 0x3a, 0x38, 0x67, 0xcd,
-	0xfd, 0xd2, 0x82, 0xa5, 0x92, 0xa8, 0x33, 0x79, 0x4f, 0xba, 0xe7, 0x53, 0x23, 0xd2, 0xfd, 0xd2,
-	0xa0, 0xa4, 0x7d, 0x84, 0xed, 0x7c, 0x4a, 0x3e, 0x31, 0x36, 0x36, 0x1e, 0x0f, 0x14, 0x92, 0xf9,
-	0x5a, 0xa3, 0xa2, 0xd4, 0xa2, 0xf8, 0x29, 0xac, 0xf2, 0x8e, 0x6c, 0x05, 0x41, 0x2e, 0x60, 0x7a,
-	0xb3, 0xf0, 0x9f, 0x50, 0x8c, 0x40, 0x70, 0x7f, 0xfa, 0x7f, 0x4a, 0x99, 0x62, 0x00, 0xf3, 0xae,
-	0x92, 0x09, 0x74, 0xf3, 0x41, 0x48, 0x32, 0xbd, 0xae, 0xfe, 0x2d, 0xc3, 0xd1, 0x2c, 0x06, 0x2e,
-	0xed, 0xdf, 0xc3, 0xc6, 0x6e, 0xd9, 0xfd, 0xb2, 0x79, 0xe1, 0xbe, 0x27, 0x5b, 0x8f, 0xbf, 0xa6,
-	0x22, 0xa6, 0xb9, 0x71, 0xca, 0x06, 0xa6, 0x85, 0x78, 0x95, 0xab, 0x5b, 0x1e, 0x70, 0xbd, 0x83,
-	0xcd, 0xaf, 0xd9, 0xef, 0x94, 0x35, 0x1f, 0xf3, 0x4f, 0xb8, 0xd3, 0xbb, 0x9a, 0x97, 0x6b, 0xd9,
-	0x83, 0xb5, 0xb2, 0xf5, 0x9e, 0xea, 0xbd, 0xe4, 0xe6, 0x7a, 0xe6, 0xbe, 0xf5, 0xe8, 0xee, 0x0f,
-	0x7f, 0xef, 0xcc, 0x4f, 0xcf, 0x27, 0x27, 0x1b, 0x83, 0x68, 0xb4, 0x19, 0xc8, 0xa0, 0x9b, 0x48,
-	0x7c, 0xdf, 0x0c, 0xc2, 0xe1, 0x26, 0x7e, 0x7f, 0x32, 0x8b, 0xff, 0x58, 0xe9, 0x1b, 0xff, 0x2f,
-	0x00, 0x00, 0xff, 0xff, 0x69, 0x0d, 0x5e, 0x90, 0x8a, 0x69, 0x00, 0x00,
+	// 8523 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7d, 0x5b, 0x6c, 0x24, 0xdb,
+	0xb5, 0x90, 0xab, 0x1f, 0x76, 0xf7, 0xea, 0x76, 0xbb, 0xbd, 0xed, 0xb1, 0x7b, 0xfa, 0xcc, 0x99,
+	0xf1, 0xa9, 0xcc, 0x9d, 0x99, 0x38, 0x27, 0xf6, 0x9c, 0x49, 0x72, 0x98, 0x7b, 0x4e, 0xc2, 0xc5,
+	0x63, 0x7b, 0xc6, 0x93, 0xe3, 0xe3, 0x71, 0xca, 0x9e, 0x0c, 0x49, 0x2e, 0xaa, 0x94, 0xbb, 0xb7,
+	0xed, 0xca, 0x54, 0x57, 0x75, 0xaa, 0xaa, 0xed, 0x71, 0x0e, 0x07, 0x09, 0x84, 0x10, 0xba, 0x12,
+	0x42, 0x81, 0x1f, 0x40, 0x20, 0xa4, 0xe4, 0x0a, 0x71, 0xc5, 0x07, 0xf0, 0x01, 0x02, 0xe9, 0x4a,
+	0xf7, 0x93, 0x2f, 0x84, 0xd0, 0xfd, 0xe3, 0x83, 0x2b, 0x04, 0x12, 0x04, 0xfe, 0x90, 0xf8, 0x47,
+	0x7b, 0xed, 0x47, 0xed, 0x5d, 0x55, 0x3d, 0x8f, 0x24, 0xf0, 0xe5, 0xde, 0x6b, 0xad, 0xda, 0xcf,
+	0xb5, 0xd6, 0x5e, 0x6b, 0xed, 0xb5, 0xb7, 0xa1, 0x19, 0x8f, 0x07, 0x1b, 0xe3, 0x38, 0x4a, 0x23,
+	0x52, 0x0f, 0xc2, 0x78, 0x3c, 0xe8, 0xdf, 0x38, 0x8b, 0xa2, 0xb3, 0x80, 0x6e, 0x7a, 0x63, 0x7f,
+	0xd3, 0x0b, 0xc3, 0x28, 0xf5, 0x52, 0x3f, 0x0a, 0x13, 0x4e, 0x64, 0xff, 0x18, 0x3a, 0x4f, 0x68,
+	0x78, 0x44, 0xe9, 0xd0, 0xa1, 0x3f, 0x9d, 0xd0, 0x24, 0x25, 0x5f, 0x83, 0x45, 0x8f, 0xfe, 0x8c,
+	0xd2, 0xa1, 0x3b, 0xf6, 0x92, 0x64, 0x7c, 0x1e, 0x7b, 0x09, 0xed, 0x59, 0x6b, 0xd6, 0xbd, 0xb6,
+	0xd3, 0xe5, 0x88, 0x43, 0x05, 0x27, 0x1f, 0x40, 0x3b, 0x61, 0xa4, 0x34, 0x4c, 0xe3, 0x68, 0x7c,
+	0xd5, 0xab, 0x20, 0x5d, 0x8b, 0xc1, 0x76, 0x39, 0xc8, 0x0e, 0x60, 0x41, 0xb5, 0x90, 0x8c, 0xa3,
+	0x30, 0xa1, 0xe4, 0x3e, 0x2c, 0x0f, 0xfc, 0xf1, 0x39, 0x8d, 0x5d, 0xfc, 0x78, 0x14, 0xd2, 0x51,
+	0x14, 0xfa, 0x83, 0x9e, 0xb5, 0x56, 0xbd, 0xd7, 0x74, 0x08, 0xc7, 0xb1, 0x2f, 0x3e, 0x17, 0x18,
+	0x72, 0x17, 0x16, 0x68, 0xc8, 0xe1, 0x74, 0x88, 0x5f, 0x89, 0xa6, 0x3a, 0x19, 0x98, 0x7d, 0x60,
+	0xff, 0xcd, 0x0a, 0x2c, 0x3e, 0x0d, 0xfd, 0xf4, 0x85, 0x17, 0x04, 0x34, 0x95, 0x63, 0xba, 0x0b,
+	0x0b, 0x97, 0x08, 0xc0, 0x31, 0x5d, 0x46, 0xf1, 0x50, 0x8c, 0xa8, 0xc3, 0xc1, 0x87, 0x02, 0x3a,
+	0xb5, 0x67, 0x95, 0xa9, 0x3d, 0x2b, 0x9d, 0xae, 0xea, 0x94, 0xe9, 0xba, 0x0b, 0x0b, 0x31, 0x1d,
+	0x44, 0x17, 0x34, 0xbe, 0x72, 0x2f, 0xfd, 0x70, 0x18, 0x5d, 0xf6, 0x6a, 0x6b, 0xd6, 0xbd, 0xba,
+	0xd3, 0x91, 0xe0, 0x17, 0x08, 0x25, 0x8f, 0x60, 0x61, 0x70, 0xee, 0x85, 0x21, 0x0d, 0xdc, 0x13,
+	0x6f, 0xf0, 0x72, 0x32, 0x4e, 0x7a, 0xf5, 0x35, 0xeb, 0x5e, 0xeb, 0xc1, 0xf5, 0x0d, 0x5c, 0xd5,
+	0x8d, 0xed, 0x73, 0x2f, 0x7c, 0x84, 0x98, 0xa3, 0xd0, 0x1b, 0x27, 0xe7, 0x51, 0xea, 0x74, 0xc4,
+	0x17, 0x1c, 0x9c, 0xd8, 0xcb, 0x40, 0xf4, 0x99, 0xe0, 0x73, 0x6f, 0xff, 0x33, 0x0b, 0x96, 0x9e,
+	0x87, 0x41, 0x34, 0x78, 0xf9, 0x6b, 0x4e, 0x51, 0xc9, 0x18, 0x2a, 0x6f, 0x3b, 0x86, 0xea, 0xbb,
+	0x8e, 0x61, 0x05, 0x96, 0xcd, 0xce, 0x8a, 0x51, 0x50, 0xb8, 0xc6, 0xbe, 0x3e, 0xa3, 0xb2, 0x5b,
+	0x72, 0x18, 0x5f, 0x85, 0xee, 0x60, 0x12, 0xc7, 0x34, 0x2c, 0x8c, 0x63, 0x41, 0xc0, 0xd5, 0x40,
+	0x3e, 0x80, 0x76, 0x48, 0x2f, 0x33, 0x32, 0xc1, 0xbb, 0x21, 0xbd, 0x94, 0x24, 0x76, 0x0f, 0x56,
+	0xf2, 0xcd, 0x88, 0x0e, 0xfc, 0x17, 0x0b, 0x6a, 0xcf, 0xd3, 0x57, 0x11, 0xd9, 0x80, 0x5a, 0x7a,
+	0x35, 0xe6, 0x12, 0xd2, 0x79, 0x40, 0xc4, 0xd0, 0xb6, 0x86, 0xc3, 0x98, 0x26, 0xc9, 0xf1, 0xd5,
+	0x98, 0x3a, 0x6d, 0x8f, 0x17, 0x5c, 0x46, 0x47, 0x7a, 0x30, 0x27, 0xca, 0xd8, 0x60, 0xd3, 0x91,
+	0x45, 0x72, 0x13, 0xc0, 0x1b, 0x45, 0x93, 0x30, 0x75, 0x13, 0x2f, 0xc5, 0xa9, 0xaa, 0x3a, 0x1a,
+	0x84, 0xdc, 0x80, 0xe6, 0xf8, 0xa5, 0x9b, 0x0c, 0x62, 0x7f, 0x9c, 0x22, 0xdb, 0x34, 0x9d, 0x0c,
+	0x40, 0xbe, 0x06, 0x8d, 0x68, 0x92, 0x8e, 0x23, 0x3f, 0x4c, 0x05, 0xab, 0x2c, 0x88, 0xbe, 0x3c,
+	0x9b, 0xa4, 0x87, 0x0c, 0xec, 0x28, 0x02, 0x72, 0x1b, 0xe6, 0x07, 0x51, 0x78, 0xea, 0xc7, 0x23,
+	0xae, 0x0c, 0x7a, 0xb3, 0xd8, 0x9a, 0x09, 0xb4, 0xff, 0x6d, 0x05, 0x5a, 0xc7, 0xb1, 0x17, 0x26,
+	0xde, 0x80, 0x01, 0x58, 0xd7, 0xd3, 0x57, 0xee, 0xb9, 0x97, 0x9c, 0xe3, 0x68, 0x9b, 0x8e, 0x2c,
+	0x92, 0x15, 0x98, 0xe5, 0x1d, 0xc5, 0x31, 0x55, 0x1d, 0x51, 0x22, 0x1f, 0xc2, 0x62, 0x38, 0x19,
+	0xb9, 0x66, 0x5b, 0x55, 0xe4, 0x96, 0x22, 0x82, 0x4d, 0xc0, 0x09, 0x5b, 0x6b, 0xde, 0x04, 0x1f,
+	0xa1, 0x06, 0x21, 0x36, 0xb4, 0x45, 0x89, 0xfa, 0x67, 0xe7, 0x7c, 0x98, 0x75, 0xc7, 0x80, 0xb1,
+	0x3a, 0x52, 0x7f, 0x44, 0xdd, 0x24, 0xf5, 0x46, 0x63, 0x31, 0x2c, 0x0d, 0x82, 0xf8, 0x28, 0xf5,
+	0x02, 0xf7, 0x94, 0xd2, 0xa4, 0x37, 0x27, 0xf0, 0x0a, 0x42, 0xee, 0x40, 0x67, 0x48, 0x93, 0xd4,
+	0x15, 0x8b, 0x42, 0x93, 0x5e, 0x03, 0x45, 0x3f, 0x07, 0x65, 0xf5, 0xc4, 0xde, 0xa5, 0xcb, 0x26,
+	0x80, 0xbe, 0xea, 0x35, 0x79, 0x5f, 0x33, 0x08, 0xe3, 0x9c, 0x27, 0x34, 0xd5, 0x66, 0x2f, 0x11,
+	0x1c, 0x6a, 0xef, 0x03, 0xd1, 0xc0, 0x3b, 0x34, 0xf5, 0xfc, 0x20, 0x21, 0x1f, 0x43, 0x3b, 0xd5,
+	0x88, 0x51, 0x15, 0xb6, 0x14, 0x3b, 0x69, 0x1f, 0x38, 0x06, 0x9d, 0xfd, 0x04, 0x1a, 0x8f, 0x29,
+	0xdd, 0xf7, 0x47, 0x7e, 0x4a, 0x56, 0xa0, 0x7e, 0xea, 0xbf, 0xa2, 0x9c, 0xe1, 0xab, 0x7b, 0x33,
+	0x0e, 0x2f, 0x92, 0x3e, 0xcc, 0x8d, 0x69, 0x3c, 0xa0, 0x72, 0x79, 0xf6, 0x66, 0x1c, 0x09, 0x78,
+	0x34, 0x07, 0xf5, 0x80, 0x7d, 0x6c, 0xff, 0xaa, 0x0a, 0xad, 0x23, 0x1a, 0x2a, 0x41, 0x22, 0x50,
+	0x63, 0x43, 0x16, 0xc2, 0x83, 0xbf, 0xc9, 0x2d, 0x68, 0xe1, 0x34, 0x24, 0x69, 0xec, 0x87, 0x67,
+	0x82, 0x7f, 0x81, 0x81, 0x8e, 0x10, 0x42, 0xba, 0x50, 0xf5, 0x46, 0x92, 0x77, 0xd9, 0x4f, 0x26,
+	0x64, 0x63, 0xef, 0x6a, 0xc4, 0xe4, 0x51, 0xad, 0x6a, 0xdb, 0x69, 0x09, 0xd8, 0x1e, 0x5b, 0xd6,
+	0x0d, 0x58, 0xd2, 0x49, 0x64, 0xed, 0x75, 0xac, 0x7d, 0x51, 0xa3, 0x14, 0x8d, 0xdc, 0x85, 0x05,
+	0x49, 0x1f, 0xf3, 0xce, 0xe2, 0x3a, 0x37, 0x9d, 0x8e, 0x00, 0xcb, 0x21, 0xdc, 0x83, 0xee, 0xa9,
+	0x1f, 0x7a, 0x81, 0x3b, 0x08, 0xd2, 0x0b, 0x77, 0x48, 0x83, 0xd4, 0xc3, 0x15, 0xaf, 0x3b, 0x1d,
+	0x84, 0x6f, 0x07, 0xe9, 0xc5, 0x0e, 0x83, 0x92, 0x0f, 0xa1, 0x79, 0x4a, 0xa9, 0x8b, 0x33, 0xd1,
+	0x6b, 0x18, 0xd2, 0x23, 0x67, 0xd7, 0x69, 0x9c, 0xca, 0x79, 0xbe, 0x07, 0xdd, 0x68, 0x92, 0x9e,
+	0x45, 0x7e, 0x78, 0xe6, 0x32, 0x7d, 0xe5, 0xfa, 0x43, 0xe4, 0x80, 0x9a, 0xd3, 0x91, 0x70, 0xa6,
+	0x35, 0x9e, 0x0e, 0xc9, 0xfb, 0x00, 0xd8, 0x36, 0xaf, 0x18, 0xd6, 0xac, 0x7b, 0xf3, 0x4e, 0x93,
+	0x41, 0x78, 0x45, 0x9f, 0x40, 0x03, 0xe7, 0x33, 0x0d, 0x2e, 0x7a, 0x2d, 0x5c, 0xf0, 0x5b, 0xa2,
+	0x55, 0x6d, 0x25, 0x36, 0x76, 0x68, 0x92, 0x1e, 0x07, 0x17, 0x6c, 0x3f, 0xbd, 0x72, 0xe6, 0x86,
+	0xbc, 0xd4, 0xff, 0x04, 0xda, 0x3a, 0x82, 0x4d, 0xfd, 0x4b, 0x7a, 0x85, 0xcb, 0x55, 0x73, 0xd8,
+	0x4f, 0xb2, 0x0c, 0xf5, 0x0b, 0x2f, 0x98, 0x50, 0xa1, 0xd8, 0x78, 0xe1, 0x93, 0xca, 0x43, 0xcb,
+	0xfe, 0x37, 0x16, 0xb4, 0x79, 0x0b, 0x62, 0x43, 0xbe, 0x0d, 0xf3, 0x72, 0x4a, 0x69, 0x1c, 0x47,
+	0xb1, 0x90, 0x6f, 0x13, 0x48, 0xd6, 0xa1, 0x2b, 0x01, 0xe3, 0x98, 0xfa, 0x23, 0xef, 0x4c, 0xd6,
+	0x5d, 0x80, 0x93, 0x07, 0x59, 0x8d, 0x71, 0x34, 0x49, 0xa9, 0x50, 0xfd, 0x6d, 0x31, 0x3e, 0x87,
+	0xc1, 0x1c, 0x93, 0x84, 0xc9, 0x77, 0x09, 0xaf, 0x18, 0x30, 0xfb, 0xe7, 0x16, 0x10, 0xd6, 0xf5,
+	0xe3, 0x88, 0x57, 0x21, 0x96, 0x3a, 0xcf, 0x66, 0xd6, 0x5b, 0xb3, 0x59, 0x65, 0x1a, 0x9b, 0xd9,
+	0x50, 0xe7, 0x3d, 0xaf, 0x95, 0xf4, 0x9c, 0xa3, 0xbe, 0x5b, 0x6b, 0x54, 0xbb, 0x35, 0xfb, 0x3f,
+	0x55, 0x61, 0x79, 0x9b, 0xef, 0x5b, 0x5b, 0x83, 0x01, 0x1d, 0x2b, 0x06, 0xbc, 0x05, 0xad, 0x30,
+	0x1a, 0x52, 0x77, 0x3c, 0x39, 0x91, 0x6b, 0xd3, 0x76, 0x80, 0x81, 0x0e, 0x11, 0x82, 0xfc, 0x71,
+	0xee, 0xf9, 0x21, 0xef, 0x34, 0x9f, 0xcb, 0x26, 0x42, 0xb0, 0xcb, 0x77, 0x60, 0x61, 0x4c, 0xc3,
+	0xa1, 0xce, 0x67, 0xdc, 0xb2, 0x98, 0x17, 0x60, 0xc1, 0x66, 0xb7, 0xa0, 0x75, 0x3a, 0xe1, 0x74,
+	0x4c, 0xfc, 0x6a, 0xc8, 0x03, 0x20, 0x40, 0x5b, 0xa3, 0x94, 0x5c, 0x87, 0xc6, 0x78, 0x92, 0x9c,
+	0x23, 0xb6, 0x8e, 0xd8, 0x39, 0x56, 0x66, 0xa8, 0xf7, 0x01, 0x86, 0x93, 0x24, 0x15, 0x2c, 0x3a,
+	0x8b, 0xc8, 0x26, 0x83, 0x70, 0x16, 0xfd, 0x3a, 0x2c, 0x8d, 0xbc, 0x57, 0x2e, 0xf2, 0x8e, 0xeb,
+	0x87, 0xee, 0x69, 0x80, 0xaa, 0x77, 0x0e, 0xe9, 0xba, 0x23, 0xef, 0xd5, 0xf7, 0x19, 0xe6, 0x69,
+	0xf8, 0x18, 0xe1, 0x4c, 0x36, 0xe5, 0x9e, 0x1f, 0xd3, 0x84, 0xc6, 0x17, 0x14, 0xc5, 0xa9, 0xa6,
+	0x36, 0x76, 0x87, 0x43, 0x59, 0x8f, 0x46, 0x6c, 0xdc, 0x69, 0x30, 0x10, 0xb2, 0x33, 0x37, 0xf2,
+	0xc3, 0xbd, 0x34, 0x18, 0x90, 0x1b, 0x00, 0x4c, 0x18, 0xc7, 0x34, 0x76, 0x5f, 0x5e, 0xa2, 0xd0,
+	0xd4, 0x50, 0xf8, 0x0e, 0x69, 0xfc, 0xd9, 0x25, 0x79, 0x0f, 0x9a, 0x83, 0x04, 0xa5, 0xd9, 0xbb,
+	0xea, 0xb5, 0x50, 0xa2, 0x1a, 0x83, 0x84, 0xc9, 0xb1, 0x77, 0x45, 0x3e, 0x04, 0xc2, 0x7a, 0xeb,
+	0xe1, 0x2a, 0xd0, 0x21, 0x56, 0x9f, 0xf4, 0xda, 0x48, 0xc5, 0x3a, 0xbb, 0x25, 0x10, 0xac, 0x9d,
+	0x84, 0x7c, 0x05, 0xe6, 0x65, 0x67, 0x4f, 0x03, 0xef, 0x2c, 0xe9, 0xcd, 0x23, 0x61, 0x5b, 0x00,
+	0x1f, 0x33, 0x98, 0xfd, 0x82, 0x5b, 0x1a, 0xda, 0xda, 0x0a, 0x99, 0x61, 0x7b, 0x1e, 0x42, 0x70,
+	0x5d, 0x1b, 0x8e, 0x28, 0x95, 0x2d, 0x5a, 0xa5, 0x64, 0xd1, 0xec, 0x5f, 0x58, 0xd0, 0x16, 0x35,
+	0xe3, 0xf6, 0x4c, 0xee, 0x03, 0x91, 0xab, 0x98, 0xbe, 0xf2, 0x87, 0xee, 0xc9, 0x55, 0x4a, 0x13,
+	0xce, 0x34, 0x7b, 0x33, 0x4e, 0x09, 0x8e, 0x7c, 0x08, 0x5d, 0x03, 0x9a, 0xa4, 0x31, 0xe7, 0xe7,
+	0xbd, 0x19, 0xa7, 0x80, 0x61, 0xe2, 0xc5, 0x0c, 0x80, 0x49, 0xea, 0xfa, 0xe1, 0x90, 0xbe, 0x42,
+	0x56, 0x9a, 0x77, 0x0c, 0xd8, 0xa3, 0x0e, 0xb4, 0xf5, 0xef, 0xec, 0x9f, 0x40, 0x43, 0x9a, 0x0f,
+	0xb8, 0x75, 0xe6, 0xfa, 0xe5, 0x68, 0x10, 0xd2, 0x87, 0x86, 0xd9, 0x0b, 0xa7, 0xf1, 0x2e, 0x6d,
+	0xdb, 0x7f, 0x1e, 0xba, 0xfb, 0x8c, 0x89, 0x42, 0xc6, 0xb4, 0xc2, 0x26, 0x5a, 0x81, 0x59, 0x4d,
+	0x78, 0x9a, 0x8e, 0x28, 0xb1, 0xdd, 0xe9, 0x3c, 0x4a, 0x52, 0xd1, 0x0e, 0xfe, 0xb6, 0xff, 0x9d,
+	0x05, 0x64, 0x37, 0x49, 0xfd, 0x91, 0x97, 0xd2, 0xc7, 0x54, 0xa9, 0x86, 0x67, 0xd0, 0x66, 0xb5,
+	0x1d, 0x47, 0x5b, 0xdc, 0x42, 0xe1, 0x3b, 0xeb, 0xd7, 0x84, 0x38, 0x17, 0x3f, 0xd8, 0xd0, 0xa9,
+	0xb9, 0xd2, 0x35, 0x2a, 0x60, 0xd2, 0x96, 0x7a, 0xf1, 0x19, 0x4d, 0xd1, 0x7c, 0x11, 0xc6, 0x2f,
+	0x70, 0xd0, 0x76, 0x14, 0x9e, 0xf6, 0x7f, 0x0f, 0x16, 0x0b, 0x75, 0xe8, 0xfa, 0xb9, 0x59, 0xa2,
+	0x9f, 0xab, 0xba, 0x7e, 0x1e, 0xc0, 0x92, 0xd1, 0x2f, 0xc1, 0x71, 0x3d, 0x98, 0x63, 0x82, 0xc1,
+	0xac, 0x43, 0xdc, 0xe1, 0x1d, 0x59, 0x24, 0x0f, 0x60, 0xf9, 0x94, 0xd2, 0xd8, 0x4b, 0xb1, 0x88,
+	0xa2, 0xc3, 0xd6, 0x44, 0xd4, 0x5c, 0x8a, 0xb3, 0xff, 0xab, 0x05, 0x0b, 0x4c, 0x93, 0x7e, 0xee,
+	0x85, 0x57, 0x72, 0xae, 0xf6, 0x4b, 0xe7, 0xea, 0x9e, 0xb6, 0x29, 0x69, 0xd4, 0xef, 0x3a, 0x51,
+	0xd5, 0xfc, 0x44, 0x91, 0x35, 0x68, 0x1b, 0xdd, 0xad, 0x73, 0x73, 0x2c, 0xf1, 0xd2, 0x43, 0x1a,
+	0x3f, 0xba, 0x4a, 0xe9, 0x6f, 0x3e, 0x95, 0x77, 0xa0, 0x9b, 0x75, 0x5b, 0xcc, 0x23, 0x81, 0x1a,
+	0x63, 0x4c, 0x51, 0x01, 0xfe, 0xb6, 0xff, 0xa1, 0xc5, 0x09, 0xb7, 0x23, 0x5f, 0x99, 0x6a, 0x8c,
+	0x90, 0x59, 0x7c, 0x92, 0x90, 0xfd, 0x9e, 0x6a, 0xea, 0xfe, 0xe6, 0x83, 0x65, 0x3a, 0x31, 0xa1,
+	0xe1, 0xd0, 0xf5, 0x82, 0x00, 0x15, 0x71, 0xc3, 0x99, 0x63, 0xe5, 0xad, 0x20, 0xb0, 0xef, 0xc2,
+	0xa2, 0xd6, 0xbb, 0xd7, 0x8c, 0xe3, 0x00, 0xc8, 0xbe, 0x9f, 0xa4, 0xcf, 0xc3, 0x64, 0xac, 0x59,
+	0x42, 0xef, 0x41, 0x93, 0x69, 0x5b, 0xd6, 0x33, 0x2e, 0xb9, 0x75, 0x87, 0xa9, 0x5f, 0xd6, 0xaf,
+	0x04, 0x91, 0xde, 0x2b, 0x81, 0xac, 0x08, 0xa4, 0xf7, 0x0a, 0x91, 0xf6, 0x43, 0x58, 0x32, 0xea,
+	0x13, 0x4d, 0x7f, 0x00, 0xf5, 0x49, 0xfa, 0x2a, 0x92, 0x76, 0x6a, 0x4b, 0x70, 0x08, 0xf3, 0x88,
+	0x1c, 0x8e, 0xb1, 0x3f, 0x85, 0xc5, 0x03, 0x7a, 0x29, 0x04, 0x59, 0x76, 0xe4, 0xce, 0x1b, 0xbd,
+	0x25, 0xc4, 0xdb, 0x1b, 0x40, 0xf4, 0x8f, 0x33, 0x01, 0x90, 0xbe, 0x93, 0x65, 0xf8, 0x4e, 0xf6,
+	0x1d, 0x20, 0x47, 0xfe, 0x59, 0xf8, 0x39, 0x4d, 0x12, 0xef, 0x4c, 0x89, 0x7e, 0x17, 0xaa, 0xa3,
+	0xe4, 0x4c, 0xa8, 0x2a, 0xf6, 0xd3, 0xfe, 0x06, 0x2c, 0x19, 0x74, 0xa2, 0xe2, 0x1b, 0xd0, 0x4c,
+	0xfc, 0xb3, 0xd0, 0x4b, 0x27, 0x31, 0x15, 0x55, 0x67, 0x00, 0xfb, 0x31, 0x2c, 0x7f, 0x9f, 0xc6,
+	0xfe, 0xe9, 0xd5, 0x9b, 0xaa, 0x37, 0xeb, 0xa9, 0xe4, 0xeb, 0xd9, 0x85, 0x6b, 0xb9, 0x7a, 0x44,
+	0xf3, 0x9c, 0x7d, 0xc5, 0x4a, 0x36, 0x1c, 0x5e, 0xd0, 0x74, 0x5f, 0x45, 0xd7, 0x7d, 0xf6, 0x73,
+	0x20, 0xdb, 0x51, 0x18, 0xd2, 0x41, 0x7a, 0x48, 0x69, 0x9c, 0x85, 0x6d, 0x32, 0x5e, 0x6d, 0x3d,
+	0x58, 0x15, 0x33, 0x9b, 0x57, 0xa8, 0x82, 0x89, 0x09, 0xd4, 0xc6, 0x34, 0x1e, 0x61, 0xc5, 0x0d,
+	0x07, 0x7f, 0xdb, 0xd7, 0x60, 0xc9, 0xa8, 0x56, 0x38, 0xba, 0x1f, 0xc1, 0xb5, 0x1d, 0x3f, 0x19,
+	0x14, 0x1b, 0xec, 0xc1, 0xdc, 0x78, 0x72, 0xe2, 0x66, 0x92, 0x28, 0x8b, 0xcc, 0xf7, 0xc9, 0x7f,
+	0x22, 0x2a, 0xfb, 0x1b, 0x16, 0xd4, 0xf6, 0x8e, 0xf7, 0xb7, 0xd9, 0x5e, 0xe1, 0x87, 0x83, 0x68,
+	0xc4, 0x2c, 0x30, 0x3e, 0x68, 0x55, 0x9e, 0x2a, 0x61, 0x37, 0xa0, 0x89, 0x86, 0x1b, 0x73, 0xf7,
+	0x84, 0x1d, 0x94, 0x01, 0x98, 0xab, 0x49, 0x5f, 0x8d, 0xfd, 0x18, 0x7d, 0x49, 0xe9, 0x21, 0xd6,
+	0x70, 0x9b, 0x29, 0x22, 0xec, 0xff, 0x39, 0x0b, 0x73, 0x62, 0xf3, 0xe5, 0x1b, 0x79, 0xea, 0x5f,
+	0xd0, 0x6c, 0x23, 0x67, 0x25, 0x66, 0x14, 0xc7, 0x74, 0x14, 0xa5, 0xca, 0x7e, 0xe3, 0xcb, 0x60,
+	0x02, 0xd1, 0x95, 0x16, 0x46, 0x04, 0x77, 0xbe, 0xab, 0x9c, 0xca, 0x00, 0xb2, 0xc9, 0x92, 0xc6,
+	0x00, 0xb7, 0xce, 0x64, 0x91, 0xcd, 0xc4, 0xc0, 0x1b, 0x7b, 0x03, 0x3f, 0xbd, 0x12, 0x2a, 0x41,
+	0x95, 0x59, 0xdd, 0x41, 0x34, 0xf0, 0x02, 0xf7, 0xc4, 0x0b, 0xbc, 0x70, 0x40, 0xa5, 0x9b, 0x6e,
+	0x00, 0x99, 0xcb, 0x2a, 0xba, 0x24, 0xc9, 0xb8, 0x5b, 0x9b, 0x83, 0xb2, 0xfd, 0x7b, 0x10, 0x8d,
+	0x46, 0x7e, 0xca, 0x3c, 0x5d, 0x34, 0xcb, 0xaa, 0x8e, 0x06, 0xe1, 0x41, 0x01, 0x2c, 0x5d, 0xf2,
+	0xd9, 0x6b, 0xca, 0xa0, 0x80, 0x06, 0x64, 0xb5, 0xe4, 0xac, 0xb3, 0xaa, 0xa3, 0x41, 0xd8, 0x3a,
+	0x4c, 0xc2, 0x84, 0xa6, 0x69, 0x40, 0x87, 0xaa, 0x43, 0x2d, 0x24, 0x2b, 0x22, 0xc8, 0x7d, 0x58,
+	0xe2, 0xce, 0x77, 0xe2, 0xa5, 0x51, 0x72, 0xee, 0x27, 0x6e, 0xc2, 0xdc, 0xd4, 0x36, 0xd2, 0x97,
+	0xa1, 0xc8, 0x43, 0x58, 0xcd, 0x81, 0x63, 0x3a, 0xa0, 0xfe, 0x05, 0x1d, 0xa2, 0xf9, 0x56, 0x75,
+	0xa6, 0xa1, 0xc9, 0x1a, 0xb4, 0xc2, 0xc9, 0xc8, 0x9d, 0x8c, 0x87, 0x1e, 0x33, 0x60, 0x3a, 0xb8,
+	0x0e, 0x3a, 0x88, 0x7c, 0x04, 0xd2, 0x46, 0x13, 0x96, 0xe3, 0x82, 0xa1, 0xdd, 0x18, 0xe7, 0x3a,
+	0x26, 0x05, 0x63, 0xca, 0xcc, 0x1c, 0xed, 0x0a, 0x07, 0x4f, 0x02, 0x50, 0x46, 0x62, 0xff, 0xc2,
+	0x4b, 0x69, 0x6f, 0x91, 0x2b, 0x74, 0x51, 0x64, 0xdf, 0xf9, 0xa1, 0x9f, 0xfa, 0x5e, 0x1a, 0xc5,
+	0x3d, 0x82, 0xb8, 0x0c, 0xc0, 0x26, 0x11, 0xf9, 0x23, 0x49, 0xbd, 0x74, 0x92, 0x08, 0xeb, 0x74,
+	0x89, 0x7b, 0x2a, 0x05, 0x04, 0xf9, 0x18, 0x56, 0x38, 0x47, 0x20, 0x4a, 0xd8, 0xdd, 0x68, 0x26,
+	0x2c, 0xe3, 0x8c, 0x4c, 0xc1, 0xb2, 0xa9, 0x14, 0x2c, 0x52, 0xf8, 0xf0, 0x1a, 0x9f, 0xca, 0x29,
+	0x68, 0xd6, 0x3f, 0xd6, 0x03, 0x7f, 0xe0, 0x0a, 0x0a, 0x26, 0x1e, 0x2b, 0x38, 0x8a, 0x22, 0xc2,
+	0xfe, 0xc7, 0x16, 0xdf, 0x44, 0x84, 0xc0, 0x25, 0x9a, 0x7b, 0xc4, 0x45, 0xcd, 0x8d, 0xc2, 0xe0,
+	0x4a, 0x48, 0x1f, 0x70, 0xd0, 0xb3, 0x30, 0xb8, 0x62, 0x06, 0xba, 0x1f, 0xea, 0x24, 0x5c, 0x5f,
+	0xb5, 0x25, 0x10, 0x89, 0x6e, 0x41, 0x6b, 0x3c, 0x39, 0x09, 0xfc, 0x01, 0x27, 0xa9, 0xf2, 0x5a,
+	0x38, 0x08, 0x09, 0x98, 0x6f, 0xc8, 0x67, 0x9d, 0x53, 0xd4, 0x90, 0xa2, 0x25, 0x60, 0x8c, 0xc4,
+	0x7e, 0x04, 0xcb, 0x66, 0x07, 0x85, 0x62, 0x5e, 0x87, 0x86, 0x90, 0xe3, 0x44, 0x38, 0xe8, 0x1d,
+	0x2d, 0x76, 0xc9, 0xdc, 0x19, 0x85, 0xb7, 0xff, 0x75, 0x0d, 0x96, 0x04, 0x74, 0x3b, 0x88, 0x12,
+	0x7a, 0x34, 0x19, 0x8d, 0xbc, 0xb8, 0x44, 0x41, 0x58, 0x6f, 0x50, 0x10, 0x15, 0x53, 0x41, 0xdc,
+	0x34, 0x7c, 0x44, 0xae, 0x5d, 0x34, 0x08, 0xb9, 0x07, 0x0b, 0x83, 0x20, 0x4a, 0xb8, 0xc9, 0xae,
+	0x87, 0xce, 0xf2, 0xe0, 0xa2, 0x42, 0xab, 0x97, 0x29, 0x34, 0x5d, 0x21, 0xcd, 0xe6, 0x14, 0x92,
+	0x0d, 0x6d, 0x56, 0x29, 0x95, 0xfa, 0x75, 0x4e, 0x38, 0x4c, 0x1a, 0x8c, 0xf5, 0x27, 0x2f, 0xfe,
+	0x5c, 0xd7, 0x2c, 0x94, 0x09, 0xbf, 0x3f, 0xa2, 0xa8, 0xbf, 0x35, 0xea, 0xa6, 0x10, 0xfe, 0x22,
+	0x8a, 0x3c, 0x06, 0xe0, 0x6d, 0xa1, 0x11, 0x01, 0x68, 0x44, 0xdc, 0x31, 0x57, 0x44, 0x9f, 0xfb,
+	0x0d, 0x56, 0x98, 0xc4, 0x14, 0x0d, 0x0b, 0xed, 0x4b, 0xfb, 0x0f, 0x2c, 0x68, 0x69, 0x38, 0x72,
+	0x0d, 0x16, 0xb7, 0x9f, 0x3d, 0x3b, 0xdc, 0x75, 0xb6, 0x8e, 0x9f, 0x7e, 0x7f, 0xd7, 0xdd, 0xde,
+	0x7f, 0x76, 0xb4, 0xdb, 0x9d, 0x61, 0xe0, 0xfd, 0x67, 0xdb, 0x5b, 0xfb, 0xee, 0xe3, 0x67, 0xce,
+	0xb6, 0x04, 0x5b, 0x64, 0x05, 0x88, 0xb3, 0xfb, 0xf9, 0xb3, 0xe3, 0x5d, 0x03, 0x5e, 0x21, 0x5d,
+	0x68, 0x3f, 0x72, 0x76, 0xb7, 0xb6, 0xf7, 0x04, 0xa4, 0x4a, 0x96, 0xa1, 0xfb, 0xf8, 0xf9, 0xc1,
+	0xce, 0xd3, 0x83, 0x27, 0xee, 0xf6, 0xd6, 0xc1, 0xf6, 0xee, 0xfe, 0xee, 0x4e, 0xb7, 0x46, 0xe6,
+	0xa1, 0xb9, 0xf5, 0x68, 0xeb, 0x60, 0xe7, 0xd9, 0xc1, 0xee, 0x4e, 0xb7, 0x6e, 0xff, 0x67, 0x0b,
+	0xae, 0x61, 0xaf, 0x87, 0x79, 0x01, 0x59, 0x83, 0xd6, 0x20, 0x8a, 0xc6, 0xcc, 0x78, 0xcf, 0xb6,
+	0x27, 0x1d, 0xc4, 0x98, 0x9f, 0x0b, 0xf7, 0x69, 0x14, 0x0f, 0xa8, 0x90, 0x0f, 0x40, 0xd0, 0x63,
+	0x06, 0x61, 0xcc, 0x2f, 0x96, 0x97, 0x53, 0x70, 0xf1, 0x68, 0x71, 0x18, 0x27, 0x59, 0x81, 0xd9,
+	0x93, 0x98, 0x7a, 0x83, 0x73, 0x21, 0x19, 0xa2, 0x44, 0xbe, 0x9a, 0x79, 0x97, 0x03, 0x36, 0xfb,
+	0x01, 0x1d, 0x22, 0xc7, 0x34, 0x9c, 0x05, 0x01, 0xdf, 0x16, 0x60, 0xa6, 0xcd, 0xbc, 0x13, 0x2f,
+	0x1c, 0x46, 0x21, 0x1d, 0x0a, 0xd3, 0x35, 0x03, 0xd8, 0x87, 0xb0, 0x92, 0x1f, 0x9f, 0x90, 0xaf,
+	0x8f, 0x35, 0xf9, 0xe2, 0x96, 0x64, 0x7f, 0xfa, 0x6a, 0x6a, 0xb2, 0xf6, 0x67, 0x15, 0xa8, 0x31,
+	0xc3, 0x62, 0xba, 0x11, 0xa2, 0xdb, 0x8a, 0xd5, 0x42, 0x9c, 0x1d, 0x1d, 0x56, 0xbe, 0xd5, 0x88,
+	0x60, 0x49, 0x06, 0xc9, 0xf0, 0x31, 0x1d, 0x5c, 0x88, 0x70, 0x89, 0x06, 0x61, 0x02, 0xc2, 0x0c,
+	0x79, 0xfc, 0x5a, 0x08, 0x88, 0x2c, 0x4b, 0x1c, 0x7e, 0x39, 0x97, 0xe1, 0xf0, 0xbb, 0x1e, 0xcc,
+	0xf9, 0xe1, 0x49, 0x34, 0x09, 0x87, 0x28, 0x10, 0x0d, 0x47, 0x16, 0x31, 0xb2, 0x8f, 0x82, 0xea,
+	0x8f, 0x24, 0xfb, 0x67, 0x00, 0xf2, 0x00, 0x9a, 0xc9, 0x55, 0x38, 0xd0, 0x79, 0x7e, 0x59, 0xcc,
+	0x12, 0x9b, 0x83, 0x8d, 0xa3, 0xab, 0x70, 0x80, 0x1c, 0x9e, 0x91, 0xd9, 0xbf, 0x07, 0x0d, 0x09,
+	0x66, 0x6c, 0xf9, 0xfc, 0xe0, 0xb3, 0x83, 0x67, 0x2f, 0x0e, 0xdc, 0xa3, 0x1f, 0x1c, 0x6c, 0x77,
+	0x67, 0xc8, 0x02, 0xb4, 0xb6, 0xb6, 0x91, 0xd3, 0x11, 0x60, 0x31, 0x92, 0xc3, 0xad, 0xa3, 0x23,
+	0x05, 0xa9, 0xd8, 0x84, 0x39, 0xe3, 0x09, 0x5a, 0x6f, 0x2a, 0x72, 0xfd, 0x31, 0x2c, 0x6a, 0xb0,
+	0xcc, 0x13, 0x18, 0x33, 0x40, 0xce, 0x13, 0x40, 0xb3, 0x8f, 0x63, 0xec, 0x2e, 0x74, 0x9e, 0xd0,
+	0xf4, 0x69, 0x78, 0x1a, 0xc9, 0x9a, 0xfe, 0x7b, 0x0d, 0x16, 0x14, 0x48, 0x54, 0x74, 0x0f, 0x16,
+	0xfc, 0x21, 0x0d, 0x53, 0x3f, 0xbd, 0x72, 0x0d, 0x9f, 0x3f, 0x0f, 0x66, 0xe6, 0xb2, 0x17, 0xf8,
+	0x9e, 0x3c, 0x40, 0xe1, 0x05, 0xe6, 0x03, 0xb3, 0xbd, 0x5c, 0x8f, 0xbd, 0x20, 0x5f, 0xf1, 0x50,
+	0x43, 0x29, 0x8e, 0x69, 0x20, 0x06, 0x17, 0x5b, 0x8c, 0xfa, 0x84, 0x9b, 0x8d, 0x65, 0x28, 0xb6,
+	0x54, 0xbc, 0x26, 0x36, 0xe4, 0x3a, 0xdf, 0xef, 0x15, 0xa0, 0x70, 0x42, 0x31, 0xcb, 0xf5, 0x63,
+	0xfe, 0x84, 0x42, 0x3b, 0xe5, 0x68, 0x14, 0x4e, 0x39, 0x98, 0xfe, 0xbc, 0x0a, 0x07, 0x74, 0xe8,
+	0xa6, 0x91, 0x8b, 0x7a, 0x1e, 0x59, 0xa2, 0xe1, 0xe4, 0xc1, 0xe4, 0x06, 0xcc, 0xa5, 0x34, 0x49,
+	0x43, 0xca, 0x43, 0xcb, 0x8d, 0x47, 0x95, 0x9e, 0xe5, 0x48, 0x10, 0xb3, 0xf1, 0x27, 0xb1, 0x9f,
+	0xf4, 0xda, 0x78, 0x7e, 0x81, 0xbf, 0xc9, 0x37, 0xe1, 0xda, 0x09, 0x4d, 0x52, 0xf7, 0x9c, 0x7a,
+	0x43, 0x1a, 0x23, 0x7b, 0xf1, 0x83, 0x12, 0x6e, 0x3a, 0x95, 0x23, 0x19, 0xe3, 0x5e, 0xd0, 0x38,
+	0xf1, 0xa3, 0x10, 0x8d, 0xa6, 0xa6, 0x23, 0x8b, 0xac, 0x3e, 0x36, 0x78, 0xb5, 0x49, 0xab, 0x19,
+	0x5c, 0xc0, 0x81, 0x97, 0x23, 0xc9, 0x6d, 0x98, 0xc5, 0x01, 0x24, 0xbd, 0x2e, 0xf2, 0x4c, 0x3b,
+	0x93, 0x79, 0x3f, 0x74, 0x04, 0x8e, 0xad, 0xf2, 0x20, 0x0a, 0xa2, 0x18, 0x2d, 0xa7, 0xa6, 0xc3,
+	0x0b, 0xe6, 0xec, 0x9c, 0xc5, 0xde, 0xf8, 0x5c, 0x58, 0x4f, 0x79, 0xf0, 0x77, 0x6b, 0x8d, 0x56,
+	0xb7, 0x6d, 0xff, 0x39, 0xa8, 0x63, 0xb5, 0x58, 0x1d, 0x4e, 0xa6, 0x25, 0xaa, 0x43, 0x68, 0x0f,
+	0xe6, 0x42, 0x9a, 0x5e, 0x46, 0xf1, 0x4b, 0x79, 0x1a, 0x27, 0x8a, 0xf6, 0xcf, 0xd0, 0xcb, 0x52,
+	0xa7, 0x53, 0xcf, 0xd1, 0x44, 0x64, 0xbe, 0x32, 0x5f, 0xaa, 0xe4, 0xdc, 0x13, 0x8e, 0x5f, 0x03,
+	0x01, 0x47, 0xe7, 0x1e, 0xd3, 0xb5, 0xc6, 0xea, 0x73, 0x5f, 0xba, 0x85, 0xb0, 0x3d, 0xbe, 0xf8,
+	0xb7, 0xa1, 0x23, 0xcf, 0xbd, 0x12, 0x37, 0xa0, 0xa7, 0xa9, 0x8c, 0x84, 0x85, 0x93, 0x11, 0x3a,
+	0xdc, 0xfb, 0xf4, 0x34, 0xb5, 0x0f, 0x60, 0x51, 0xe8, 0xbf, 0x67, 0x63, 0x2a, 0x9b, 0xfe, 0xdd,
+	0x32, 0x3b, 0xa2, 0xf5, 0x60, 0xc9, 0x54, 0x98, 0xfc, 0xa4, 0xcf, 0xa4, 0xb4, 0x1d, 0x20, 0xba,
+	0x3e, 0x15, 0x15, 0x8a, 0xcd, 0x5c, 0xc6, 0xfa, 0xc4, 0x70, 0x0c, 0x18, 0x9b, 0x9f, 0x64, 0x32,
+	0x18, 0xc8, 0xd3, 0xca, 0x86, 0x23, 0x8b, 0xf6, 0x3f, 0xb5, 0x60, 0x09, 0x6b, 0x93, 0x96, 0x90,
+	0xd8, 0xb3, 0x1e, 0xbe, 0x43, 0x37, 0x65, 0xa4, 0x95, 0xc7, 0x17, 0x97, 0xa1, 0xae, 0xef, 0x62,
+	0xbc, 0xf0, 0xee, 0x71, 0x95, 0x5a, 0x3e, 0xae, 0x62, 0xff, 0x3d, 0x0b, 0x16, 0xf9, 0x46, 0x82,
+	0x56, 0xb3, 0x18, 0xfe, 0xb7, 0x61, 0x9e, 0x5b, 0x04, 0x42, 0x2b, 0x88, 0x8e, 0x66, 0xaa, 0x15,
+	0xa1, 0x9c, 0x78, 0x6f, 0xc6, 0x31, 0x89, 0xc9, 0xa7, 0x68, 0x95, 0x85, 0x2e, 0x42, 0x4b, 0xce,
+	0xb5, 0xcd, 0xb9, 0xde, 0x9b, 0x71, 0x34, 0xf2, 0x47, 0x0d, 0x98, 0xe5, 0x2e, 0x87, 0xfd, 0x04,
+	0xe6, 0x8d, 0x86, 0x8c, 0x98, 0x4e, 0x9b, 0xc7, 0x74, 0x0a, 0xc1, 0xd3, 0x4a, 0x49, 0xf0, 0xf4,
+	0x5f, 0x56, 0x81, 0x30, 0x66, 0xc9, 0xad, 0xc6, 0x9a, 0x79, 0x02, 0x21, 0x8f, 0xb8, 0x33, 0x10,
+	0xd9, 0x00, 0xa2, 0x15, 0xe5, 0xa9, 0x08, 0xdf, 0x32, 0x4b, 0x30, 0x4c, 0xcd, 0x0a, 0x8b, 0x43,
+	0x9d, 0x38, 0xa0, 0xaf, 0xce, 0xa7, 0xbd, 0x14, 0xc7, 0x76, 0x45, 0x3c, 0x7e, 0x60, 0x9e, 0x85,
+	0xf0, 0x71, 0x65, 0x39, 0xbf, 0xbe, 0xb3, 0x6f, 0x5c, 0xdf, 0xb9, 0x42, 0xdc, 0x4c, 0xf3, 0xb2,
+	0x1a, 0xa6, 0x97, 0x75, 0x1b, 0xe6, 0xe5, 0x29, 0x83, 0x3b, 0x62, 0xad, 0x0b, 0x97, 0xd6, 0x00,
+	0x92, 0x75, 0xe8, 0x4a, 0x47, 0x47, 0xb9, 0x72, 0xfc, 0xac, 0xae, 0x00, 0x67, 0xfa, 0x3f, 0x8b,
+	0xa4, 0xb5, 0xb0, 0xb3, 0x19, 0x00, 0xfd, 0x22, 0xc6, 0x21, 0xee, 0x24, 0x14, 0x47, 0xdb, 0x74,
+	0x88, 0xce, 0x2c, 0xf3, 0x8b, 0xf2, 0x08, 0xfb, 0xef, 0x58, 0xd0, 0x65, 0x6b, 0x66, 0xb0, 0xe5,
+	0x27, 0x80, 0x52, 0xf1, 0x96, 0x5c, 0x69, 0xd0, 0x92, 0x87, 0xd0, 0xc4, 0x72, 0x34, 0xa6, 0xa1,
+	0xe0, 0xc9, 0x9e, 0xc9, 0x93, 0x99, 0x3e, 0xd9, 0x9b, 0x71, 0x32, 0x62, 0x8d, 0x23, 0xff, 0x83,
+	0x05, 0x2d, 0xd1, 0xca, 0xaf, 0x1d, 0xa9, 0xe9, 0x6b, 0xb9, 0x08, 0x9c, 0x93, 0xb2, 0xd4, 0x83,
+	0x7b, 0xb0, 0x30, 0xf2, 0xd2, 0x49, 0xcc, 0xf6, 0x73, 0x23, 0x4a, 0x93, 0x07, 0xb3, 0xcd, 0x19,
+	0x55, 0x67, 0xe2, 0xa6, 0x7e, 0xe0, 0x4a, 0xac, 0x38, 0xf5, 0x2f, 0x43, 0x31, 0x0d, 0x92, 0xa4,
+	0xde, 0x19, 0x15, 0xfb, 0x2e, 0x2f, 0xd8, 0x3d, 0x58, 0x39, 0xcc, 0x4e, 0x5e, 0x34, 0xfb, 0xda,
+	0xfe, 0xe7, 0xf3, 0xb0, 0x5a, 0x40, 0xa9, 0x1c, 0x25, 0x11, 0x7e, 0x08, 0xfc, 0xd1, 0x49, 0xa4,
+	0x9c, 0x13, 0x4b, 0x8f, 0x4c, 0x18, 0x28, 0x72, 0x06, 0xd7, 0xa4, 0x81, 0xc1, 0xe6, 0x34, 0xdb,
+	0x0c, 0x2b, 0xb8, 0xcb, 0x7d, 0x64, 0x2e, 0x61, 0xbe, 0x41, 0x09, 0xd7, 0x85, 0xb8, 0xbc, 0x3e,
+	0x72, 0x0e, 0x3d, 0x65, 0xc9, 0x08, 0x65, 0xad, 0x59, 0x3b, 0xac, 0xad, 0x0f, 0xdf, 0xd0, 0x96,
+	0x61, 0x8e, 0x3b, 0x53, 0x6b, 0x23, 0x57, 0x70, 0x53, 0xe2, 0x50, 0x1b, 0x17, 0xdb, 0xab, 0xbd,
+	0xd5, 0xd8, 0xd0, 0xd1, 0x30, 0x1b, 0x7d, 0x43, 0xc5, 0xe4, 0x27, 0xb0, 0x72, 0xe9, 0xf9, 0xa9,
+	0xec, 0x96, 0x66, 0x5b, 0xd4, 0xb1, 0xc9, 0x07, 0x6f, 0x68, 0xf2, 0x05, 0xff, 0xd8, 0xd8, 0xa2,
+	0xa6, 0xd4, 0xd8, 0xff, 0xe3, 0x0a, 0x74, 0xcc, 0x7a, 0x18, 0x9b, 0x0a, 0xd9, 0x97, 0x3a, 0x50,
+	0x5a, 0xa3, 0x39, 0x70, 0xd1, 0xbf, 0xaf, 0x94, 0xf9, 0xf7, 0xba, 0x57, 0x5d, 0x7d, 0x53, 0x98,
+	0xaf, 0xf6, 0x76, 0x61, 0xbe, 0x7a, 0x69, 0x98, 0x6f, 0x7a, 0x34, 0x68, 0xf6, 0xd7, 0x8d, 0x06,
+	0xcd, 0xbd, 0x36, 0x1a, 0xd4, 0xff, 0x3f, 0x16, 0x90, 0x22, 0xf7, 0x92, 0x27, 0x3c, 0xa4, 0x11,
+	0xd2, 0x40, 0x28, 0xb1, 0xaf, 0xbf, 0x9d, 0x04, 0xc8, 0xd5, 0x92, 0x5f, 0x33, 0x51, 0xd4, 0x13,
+	0x85, 0x74, 0xf3, 0x6a, 0xde, 0x29, 0x43, 0xe5, 0x42, 0x9d, 0xb5, 0x37, 0x87, 0x3a, 0xeb, 0x6f,
+	0x0e, 0x75, 0xce, 0xe6, 0x43, 0x9d, 0xfd, 0xbf, 0x6e, 0xc1, 0x52, 0x09, 0x9b, 0xfd, 0xf6, 0x06,
+	0xce, 0x18, 0xc3, 0xd0, 0x3e, 0x15, 0xc1, 0x18, 0x3a, 0xb0, 0xff, 0x97, 0x61, 0xde, 0x10, 0xad,
+	0xdf, 0x5e, 0xfb, 0x79, 0x0b, 0x91, 0x73, 0xb6, 0x01, 0xeb, 0xff, 0xaf, 0x0a, 0x90, 0xa2, 0x78,
+	0xff, 0x7f, 0xed, 0x43, 0x71, 0x9e, 0xaa, 0x25, 0xf3, 0xf4, 0xff, 0x74, 0xe7, 0xf9, 0x10, 0x16,
+	0x45, 0xf6, 0xa3, 0x16, 0xc8, 0xe2, 0x1c, 0x53, 0x44, 0x30, 0x1b, 0xd9, 0x8c, 0x33, 0x37, 0x8c,
+	0x6c, 0x2f, 0x6d, 0xfb, 0xcd, 0x85, 0x9b, 0xed, 0x3e, 0xf4, 0xc4, 0x0c, 0xed, 0x5e, 0xd0, 0x30,
+	0x3d, 0x9a, 0x9c, 0xf0, 0xf4, 0x3f, 0x3f, 0x0a, 0xed, 0x7f, 0x55, 0x55, 0x66, 0x3e, 0x22, 0x85,
+	0x41, 0xf1, 0x4d, 0x68, 0xeb, 0xdb, 0x87, 0x58, 0x8e, 0x5c, 0x1c, 0x93, 0x99, 0x12, 0x3a, 0x15,
+	0xd9, 0x81, 0x0e, 0x2a, 0xc9, 0xa1, 0xfa, 0xae, 0x82, 0xdf, 0xbd, 0x26, 0x3e, 0xb3, 0x37, 0xe3,
+	0xe4, 0xbe, 0x21, 0xdf, 0x81, 0x8e, 0xe9, 0xfc, 0x09, 0xab, 0xa4, 0xcc, 0x1b, 0x60, 0x9f, 0x9b,
+	0xc4, 0x64, 0x0b, 0xba, 0x79, 0xef, 0x51, 0x64, 0xe3, 0x4c, 0xa9, 0xa0, 0x40, 0x4e, 0x1e, 0x8a,
+	0x03, 0xc7, 0x3a, 0xc6, 0x4d, 0x6e, 0x9b, 0x9f, 0x69, 0xd3, 0xb4, 0xc1, 0xff, 0x68, 0x47, 0x90,
+	0xbf, 0x0f, 0x90, 0xc1, 0x48, 0x17, 0xda, 0xcf, 0x0e, 0x77, 0x0f, 0xdc, 0xed, 0xbd, 0xad, 0x83,
+	0x83, 0xdd, 0xfd, 0xee, 0x0c, 0x21, 0xd0, 0xc1, 0x30, 0xdf, 0x8e, 0x82, 0x59, 0x0c, 0x26, 0x02,
+	0x2b, 0x12, 0x56, 0x21, 0xcb, 0xd0, 0x7d, 0x7a, 0x90, 0x83, 0x56, 0x1f, 0x35, 0x95, 0x7c, 0xd8,
+	0x2b, 0xb0, 0xcc, 0xb3, 0x5b, 0x1f, 0x71, 0xf6, 0x90, 0xd6, 0xc9, 0x3f, 0xb2, 0xe0, 0x5a, 0x0e,
+	0x91, 0xa5, 0x6b, 0x71, 0x03, 0xc4, 0xb4, 0x4a, 0x4c, 0x20, 0x1e, 0x22, 0x48, 0x5b, 0x33, 0xa7,
+	0x41, 0x8a, 0x08, 0xc6, 0xf3, 0x9a, 0x6d, 0x9a, 0x93, 0xa4, 0x32, 0x94, 0xbd, 0xaa, 0x32, 0x63,
+	0x72, 0x1d, 0x3f, 0xe5, 0x59, 0xb3, 0x3a, 0x22, 0x3b, 0xc0, 0x35, 0xbb, 0x2c, 0x8b, 0xcc, 0xad,
+	0x30, 0x8c, 0x1d, 0xb3, 0xbf, 0xa5, 0x38, 0xfb, 0x0f, 0x6a, 0x40, 0xbe, 0x37, 0xa1, 0xf1, 0x15,
+	0xe6, 0x64, 0xa9, 0xa8, 0xe9, 0x6a, 0x3e, 0x26, 0x38, 0x3b, 0x9e, 0x9c, 0x7c, 0x46, 0xaf, 0x64,
+	0x76, 0x62, 0x25, 0xcb, 0x4e, 0x2c, 0xcb, 0x10, 0xac, 0xbd, 0x39, 0x43, 0xb0, 0xfe, 0xa6, 0x0c,
+	0xc1, 0xaf, 0xc0, 0xbc, 0x7f, 0x16, 0x46, 0x4c, 0xe6, 0x99, 0x9d, 0x90, 0xf4, 0x66, 0xd7, 0xaa,
+	0xcc, 0xb7, 0x16, 0xc0, 0x03, 0x06, 0x23, 0x9f, 0x66, 0x44, 0x74, 0x78, 0x86, 0xd9, 0xa8, 0xba,
+	0x16, 0xd8, 0x1d, 0x9e, 0xd1, 0xfd, 0x68, 0xe0, 0xa5, 0x51, 0x8c, 0x81, 0x1d, 0xf9, 0x31, 0x83,
+	0x27, 0xe4, 0x36, 0x74, 0x92, 0x68, 0xc2, 0x2c, 0x27, 0x39, 0x56, 0x1e, 0x49, 0x6a, 0x73, 0xe8,
+	0x21, 0x1f, 0xf1, 0x06, 0x2c, 0x4d, 0x12, 0xea, 0x8e, 0xfc, 0x24, 0x61, 0xbb, 0xe3, 0x20, 0x0a,
+	0xd3, 0x38, 0x0a, 0x44, 0x3c, 0x69, 0x71, 0x92, 0xd0, 0xcf, 0x39, 0x66, 0x9b, 0x23, 0xc8, 0x37,
+	0xb3, 0x2e, 0x8d, 0x3d, 0x3f, 0x4e, 0x7a, 0x80, 0x5d, 0x92, 0x23, 0x65, 0xfd, 0x3e, 0xf4, 0xfc,
+	0x58, 0xf5, 0x85, 0x15, 0x12, 0xb2, 0x55, 0x48, 0x63, 0x94, 0x31, 0xf9, 0xe2, 0xea, 0xfc, 0xf6,
+	0xb3, 0x19, 0x45, 0x12, 0xde, 0x06, 0x34, 0x64, 0xf7, 0x98, 0x13, 0x7d, 0x1a, 0x47, 0x23, 0xe9,
+	0x44, 0xb3, 0xdf, 0xa4, 0x03, 0x95, 0x34, 0x12, 0x1f, 0x57, 0xd2, 0xc8, 0xfe, 0x01, 0xb4, 0xb4,
+	0x19, 0x16, 0x99, 0x78, 0x68, 0xb0, 0x09, 0xef, 0xbb, 0xc6, 0xfd, 0xa3, 0x90, 0x06, 0x4f, 0x87,
+	0xe4, 0x6b, 0xb0, 0x38, 0xf4, 0x63, 0x8a, 0x49, 0xb7, 0x6e, 0x4c, 0x2f, 0x68, 0x9c, 0xc8, 0x38,
+	0x45, 0x57, 0x21, 0x1c, 0x0e, 0xb7, 0x5d, 0x58, 0x32, 0x06, 0xae, 0xa4, 0x76, 0x16, 0xb3, 0x06,
+	0x65, 0xa8, 0xd4, 0xcc, 0x28, 0x14, 0x38, 0xb6, 0xdf, 0x89, 0x10, 0x8b, 0x3b, 0x8e, 0xa3, 0x13,
+	0x6c, 0xc4, 0x72, 0x0c, 0x98, 0xfd, 0x4f, 0xaa, 0x50, 0xdd, 0x8b, 0xc6, 0xfa, 0xa1, 0x91, 0x65,
+	0x1e, 0x1a, 0x09, 0xa3, 0xd4, 0x55, 0x36, 0xa7, 0xb0, 0x1c, 0x0c, 0x20, 0x59, 0x87, 0x8e, 0x37,
+	0x4a, 0xdd, 0x34, 0x62, 0x46, 0xf8, 0xa5, 0x17, 0xf3, 0xf4, 0xc2, 0x2a, 0xb2, 0x5b, 0x0e, 0x43,
+	0x96, 0xa1, 0xaa, 0x6c, 0x29, 0x24, 0x60, 0x45, 0xe6, 0x01, 0xe2, 0xe1, 0xfa, 0x95, 0x88, 0x85,
+	0x8a, 0x12, 0xd3, 0x26, 0xe6, 0xf7, 0xdc, 0xfd, 0xe6, 0x3b, 0x62, 0x19, 0x8a, 0x19, 0xc8, 0x4c,
+	0xc0, 0x46, 0x99, 0xbd, 0xa9, 0xca, 0x7a, 0x94, 0xbf, 0x61, 0x46, 0xf9, 0xd7, 0xa0, 0x95, 0x06,
+	0x17, 0xee, 0xd8, 0xbb, 0x0a, 0x22, 0x6f, 0x28, 0x18, 0x5b, 0x07, 0x91, 0x6f, 0x73, 0x0a, 0xb6,
+	0x09, 0xc7, 0x43, 0xc9, 0xd0, 0x72, 0x17, 0xdb, 0x8b, 0xc6, 0x1b, 0xc7, 0xc1, 0x85, 0xc3, 0x91,
+	0x9c, 0x27, 0x75, 0xf2, 0xfe, 0x77, 0x60, 0x21, 0x87, 0x7f, 0xa7, 0x44, 0xdb, 0x5f, 0x59, 0x50,
+	0xc7, 0xe5, 0x65, 0xc6, 0x07, 0xd7, 0xce, 0xea, 0x58, 0x0b, 0x6b, 0x98, 0x77, 0xf2, 0x60, 0x62,
+	0x1b, 0x19, 0xea, 0x15, 0x35, 0xdf, 0x7a, 0x96, 0xfa, 0x1a, 0x34, 0x79, 0x49, 0x65, 0x5b, 0x23,
+	0x49, 0x06, 0x24, 0x37, 0xa1, 0x76, 0x1e, 0x8d, 0xa5, 0x7f, 0x06, 0xd9, 0x78, 0x1d, 0x84, 0x67,
+	0xfd, 0x61, 0xf5, 0xf1, 0x59, 0xe7, 0x36, 0x70, 0x1e, 0xcc, 0xfc, 0x0e, 0x55, 0xad, 0xbe, 0x8a,
+	0x39, 0xa8, 0xfd, 0x1c, 0x16, 0x98, 0x00, 0x6a, 0x61, 0xfe, 0xe9, 0x9a, 0xf8, 0xab, 0x6c, 0x63,
+	0x1f, 0x04, 0x93, 0x21, 0xd5, 0xbd, 0x64, 0x0c, 0xe3, 0x0a, 0xb8, 0xb4, 0x0f, 0xed, 0x7f, 0x61,
+	0x71, 0xc1, 0x66, 0xf5, 0x92, 0x7b, 0x50, 0x63, 0xfa, 0x34, 0x17, 0x14, 0x51, 0x49, 0x2e, 0x8c,
+	0xce, 0x41, 0x0a, 0x26, 0x46, 0x18, 0x68, 0xd5, 0x6b, 0xe7, 0x61, 0xd6, 0xcc, 0xc5, 0x54, 0x23,
+	0xcb, 0x79, 0x66, 0x39, 0x28, 0xd9, 0xd0, 0x4e, 0xa9, 0x6a, 0x86, 0x8e, 0x96, 0x76, 0xc4, 0xf0,
+	0x8c, 0x6a, 0xa7, 0x53, 0x7f, 0x64, 0xc1, 0xbc, 0xd1, 0x27, 0xc6, 0xa6, 0x81, 0x97, 0xa4, 0x22,
+	0xd1, 0x40, 0xac, 0xbc, 0x0e, 0xd2, 0x59, 0xbc, 0x62, 0xb2, 0xb8, 0x3a, 0xed, 0xa8, 0xea, 0xa7,
+	0x1d, 0xf7, 0xa1, 0x99, 0x5d, 0x51, 0x30, 0x3b, 0xc5, 0x5a, 0x94, 0xe9, 0x3e, 0x19, 0x51, 0x16,
+	0x4f, 0xaf, 0x6b, 0xf1, 0x74, 0xfb, 0x53, 0x68, 0x69, 0xf4, 0x7a, 0x3c, 0xdc, 0x32, 0xe2, 0xe1,
+	0x2a, 0x17, 0xae, 0x92, 0xe5, 0xc2, 0xd9, 0x3f, 0xaf, 0xc0, 0x3c, 0x63, 0x6f, 0x3f, 0x3c, 0x3b,
+	0x8c, 0x02, 0x7f, 0x70, 0x85, 0x6c, 0x25, 0x39, 0x59, 0xec, 0xa7, 0x92, 0xcd, 0x4d, 0x30, 0x93,
+	0x77, 0x95, 0x00, 0xcc, 0x95, 0x93, 0x2a, 0x33, 0xed, 0xc5, 0x64, 0xff, 0xc4, 0x4b, 0x84, 0x42,
+	0x10, 0xf6, 0xbc, 0x01, 0x64, 0x3a, 0x86, 0x01, 0x30, 0xb3, 0x71, 0xe4, 0x07, 0x81, 0xcf, 0x69,
+	0xb9, 0xb7, 0x57, 0x86, 0x62, 0x6d, 0x0e, 0xfd, 0xc4, 0x3b, 0xc9, 0x4e, 0x32, 0x55, 0x19, 0x43,
+	0x85, 0xde, 0x2b, 0x2d, 0x54, 0xc8, 0x53, 0xa1, 0x4d, 0x60, 0x7e, 0x21, 0xe7, 0x0a, 0x0b, 0x69,
+	0xff, 0x49, 0x05, 0x5a, 0x1a, 0x5b, 0x88, 0xe3, 0x7b, 0x73, 0x63, 0xd1, 0x20, 0x12, 0x6f, 0xc4,
+	0x0e, 0x34, 0x08, 0xb9, 0x6d, 0xb6, 0x88, 0xc7, 0x05, 0x28, 0xec, 0x06, 0xfb, 0xdc, 0x80, 0x26,
+	0x63, 0xfb, 0x8f, 0x30, 0x50, 0x21, 0xee, 0x06, 0x29, 0x80, 0xc4, 0x3e, 0x40, 0x6c, 0x3d, 0xc3,
+	0x22, 0xe0, 0xb5, 0x07, 0xfe, 0x0f, 0xa1, 0x2d, 0xaa, 0xc1, 0xf5, 0xc5, 0x01, 0x67, 0x82, 0x67,
+	0xac, 0xbd, 0x63, 0x50, 0xca, 0x2f, 0x1f, 0xc8, 0x2f, 0x1b, 0x6f, 0xfa, 0x52, 0x52, 0xda, 0x4f,
+	0x54, 0x1e, 0xc5, 0x93, 0xd8, 0x1b, 0x9f, 0x4b, 0x65, 0x72, 0x1f, 0x96, 0xa4, 0xce, 0x98, 0x84,
+	0x5e, 0x18, 0x46, 0x93, 0x70, 0x40, 0x65, 0xca, 0x5c, 0x19, 0xca, 0x1e, 0xaa, 0x04, 0x6b, 0xac,
+	0x88, 0xac, 0x43, 0x9d, 0x5b, 0x63, 0x7c, 0xff, 0x2d, 0x57, 0x1f, 0x9c, 0x84, 0xdc, 0x83, 0x3a,
+	0x37, 0xca, 0x2a, 0x53, 0x05, 0x9e, 0x13, 0xd8, 0xeb, 0xb0, 0x80, 0x19, 0xdd, 0xa6, 0xde, 0x33,
+	0xf7, 0xe5, 0xd9, 0x01, 0xcf, 0xf9, 0x5e, 0x06, 0x72, 0xc0, 0xe5, 0x49, 0x3f, 0x0d, 0xfd, 0x55,
+	0x15, 0x5a, 0x1a, 0x98, 0xe9, 0x25, 0x3c, 0xc2, 0x72, 0x87, 0xbe, 0x37, 0xa2, 0x29, 0x8d, 0x85,
+	0x0c, 0xe5, 0xa0, 0x8c, 0xce, 0xbb, 0x38, 0x73, 0xa3, 0x49, 0xea, 0x0e, 0xe9, 0x59, 0x4c, 0xa9,
+	0x30, 0x16, 0x72, 0x50, 0x46, 0xc7, 0xb8, 0x58, 0xa3, 0xe3, 0x87, 0x4e, 0x39, 0xa8, 0x3c, 0xdb,
+	0xe4, 0x73, 0x54, 0xcb, 0xce, 0x36, 0xf9, 0x8c, 0xe4, 0x35, 0x6a, 0xbd, 0x44, 0xa3, 0x7e, 0x0c,
+	0x2b, 0x5c, 0x77, 0x0a, 0xad, 0xe1, 0xe6, 0x18, 0x6b, 0x0a, 0x96, 0xac, 0x43, 0x97, 0xf5, 0x59,
+	0x8a, 0x45, 0xe2, 0xff, 0x8c, 0xcb, 0x96, 0xe5, 0x14, 0xe0, 0x8c, 0x16, 0x03, 0xee, 0x3a, 0x2d,
+	0x4f, 0x30, 0x29, 0xc0, 0x91, 0xd6, 0x7b, 0x65, 0xd2, 0x36, 0x05, 0x6d, 0x0e, 0x4e, 0x1e, 0xc2,
+	0xea, 0x88, 0x0e, 0x7d, 0xcf, 0xac, 0x02, 0xe3, 0x5f, 0x3c, 0xcb, 0x6d, 0x1a, 0x9a, 0xb5, 0xc2,
+	0x66, 0xe1, 0x67, 0xd1, 0xe8, 0xc4, 0xe7, 0x1b, 0x1a, 0x3f, 0x1a, 0xa8, 0x39, 0x05, 0xb8, 0x3d,
+	0x0f, 0xad, 0xa3, 0x34, 0x1a, 0xcb, 0xa5, 0xef, 0x40, 0x9b, 0x17, 0x45, 0x82, 0xe4, 0x7b, 0x70,
+	0x1d, 0x79, 0xf5, 0x38, 0x1a, 0x47, 0x41, 0x74, 0x76, 0x65, 0x38, 0xf8, 0xff, 0xde, 0x82, 0x25,
+	0x03, 0x9b, 0x79, 0xf8, 0x18, 0x8d, 0x94, 0x99, 0x6d, 0x9c, 0xbd, 0x17, 0xb5, 0xed, 0x80, 0x13,
+	0xf2, 0x83, 0x9f, 0xe7, 0x22, 0xd9, 0x6d, 0x2b, 0xbb, 0xaa, 0x21, 0x3f, 0xe4, 0xbc, 0xde, 0x2b,
+	0xf2, 0xba, 0xf8, 0x5e, 0x5e, 0xe2, 0x90, 0x55, 0x7c, 0x47, 0xa4, 0x03, 0x0d, 0xc5, 0xa0, 0xab,
+	0x66, 0x0a, 0x87, 0x1e, 0x10, 0x92, 0x3d, 0x18, 0x28, 0x60, 0x62, 0xff, 0xc2, 0x02, 0xc8, 0x7a,
+	0x87, 0x49, 0x24, 0x6a, 0x4b, 0xe3, 0x57, 0x81, 0xb5, 0xed, 0xeb, 0x03, 0x68, 0xab, 0x3c, 0x80,
+	0x6c, 0x97, 0x6c, 0x49, 0x18, 0xb3, 0x2a, 0xee, 0xc2, 0xc2, 0x59, 0x10, 0x9d, 0xa0, 0xf5, 0x82,
+	0x19, 0xb7, 0x89, 0x48, 0x13, 0xed, 0x70, 0xf0, 0x63, 0x01, 0xcd, 0xb6, 0xd4, 0x9a, 0xbe, 0xa5,
+	0x96, 0x6f, 0x90, 0x7f, 0xab, 0xa2, 0x0e, 0x63, 0xb3, 0x99, 0x98, 0x2a, 0xe1, 0xe4, 0x41, 0x41,
+	0x9d, 0x4f, 0x39, 0xfb, 0x44, 0xe7, 0xe2, 0xf0, 0x8d, 0xb1, 0xe1, 0x4f, 0xa1, 0x13, 0x73, 0x5d,
+	0x29, 0x15, 0x69, 0xed, 0x35, 0x8a, 0x74, 0x3e, 0x36, 0x76, 0xe3, 0xaf, 0x42, 0xd7, 0x1b, 0x5e,
+	0xd0, 0x38, 0xf5, 0x31, 0x56, 0x86, 0xa6, 0x13, 0x1f, 0xdc, 0x82, 0x06, 0x47, 0x0b, 0xe5, 0x2e,
+	0x2c, 0x88, 0x84, 0x5d, 0x45, 0x29, 0x2e, 0xd5, 0x65, 0x60, 0x46, 0x68, 0xff, 0x52, 0x9e, 0xfb,
+	0x9a, 0x2b, 0x3b, 0x7d, 0x46, 0xf4, 0xd1, 0x55, 0x72, 0xa3, 0xfb, 0x8a, 0x38, 0x83, 0x1d, 0xca,
+	0x80, 0x5c, 0x55, 0x4b, 0x28, 0x1b, 0x8a, 0x33, 0x73, 0x73, 0x4a, 0x6b, 0x6f, 0x33, 0xa5, 0xf6,
+	0x9f, 0x5a, 0x30, 0xb7, 0x17, 0x8d, 0xf7, 0x44, 0x6a, 0x1d, 0x8a, 0x87, 0xca, 0x94, 0x97, 0xc5,
+	0xd7, 0x24, 0xdd, 0x95, 0x5a, 0x20, 0xf3, 0x79, 0x0b, 0xe4, 0x2f, 0xc0, 0x7b, 0x18, 0x0e, 0x8e,
+	0xa3, 0x71, 0x14, 0x33, 0x11, 0xf5, 0x02, 0x6e, 0x6e, 0x44, 0x61, 0x7a, 0x2e, 0x55, 0xe8, 0xeb,
+	0x48, 0x30, 0x46, 0x13, 0xa4, 0x17, 0x2e, 0x77, 0x9b, 0x84, 0xc5, 0xc4, 0x35, 0x6b, 0x11, 0x61,
+	0xff, 0x2e, 0x34, 0xd1, 0x9b, 0xc0, 0x61, 0x7d, 0x08, 0xcd, 0xf3, 0x68, 0xec, 0x9e, 0xfb, 0x61,
+	0x2a, 0x45, 0xbe, 0x93, 0x99, 0xf9, 0x7b, 0x38, 0x21, 0x8a, 0xc0, 0xfe, 0x93, 0x59, 0x98, 0x7b,
+	0x1a, 0x5e, 0x44, 0xfe, 0x00, 0xcf, 0x98, 0x47, 0x74, 0x14, 0xc9, 0x7b, 0x03, 0xec, 0x37, 0xb9,
+	0x01, 0x73, 0x98, 0x28, 0x3b, 0xe6, 0x4c, 0xdb, 0xe6, 0xb9, 0x24, 0x02, 0x84, 0xb7, 0x5d, 0xb3,
+	0x3b, 0x7f, 0x5c, 0xa8, 0x34, 0x08, 0x73, 0x03, 0x63, 0xfd, 0xce, 0x9e, 0x28, 0x65, 0x9e, 0x51,
+	0x5d, 0xbb, 0x97, 0xc1, 0xda, 0x12, 0xa9, 0x80, 0x3c, 0x57, 0x8c, 0xb7, 0x25, 0x40, 0xe8, 0xba,
+	0xc6, 0x94, 0x87, 0xf3, 0x95, 0x91, 0xc5, 0x5c, 0x57, 0x1d, 0xc8, 0x0c, 0x31, 0xfe, 0x01, 0xa7,
+	0xe1, 0x1b, 0x80, 0x0e, 0x62, 0xa6, 0x68, 0xfe, 0x9a, 0x28, 0xbf, 0xa6, 0x9b, 0x07, 0x33, 0xfd,
+	0x3d, 0xa4, 0x4a, 0xcd, 0xf2, 0x71, 0x00, 0xbf, 0xd7, 0x98, 0x87, 0x6b, 0x0e, 0x2f, 0xcf, 0x69,
+	0x96, 0x0e, 0x2f, 0x63, 0x18, 0x2f, 0x08, 0x4e, 0xbc, 0xc1, 0x4b, 0xbc, 0x25, 0x8c, 0xa7, 0xbe,
+	0x4d, 0xc7, 0x04, 0x62, 0x42, 0x5f, 0xb6, 0xaa, 0x98, 0x75, 0x53, 0x73, 0x74, 0x10, 0x79, 0x00,
+	0x2d, 0x0c, 0x04, 0x88, 0x75, 0xed, 0xe0, 0xba, 0x76, 0xf5, 0x48, 0x01, 0xae, 0xac, 0x4e, 0xa4,
+	0x9f, 0x7f, 0x2f, 0x14, 0xb2, 0x8c, 0xbd, 0xe1, 0x50, 0xa4, 0x0d, 0x74, 0x79, 0x50, 0x43, 0x01,
+	0x30, 0xd4, 0xc0, 0x27, 0x8c, 0x13, 0x2c, 0x22, 0x81, 0x01, 0x23, 0x37, 0xa1, 0xc1, 0x3c, 0xbc,
+	0xb1, 0xe7, 0x0f, 0x31, 0xd1, 0x86, 0x3b, 0x9a, 0x0a, 0xc6, 0xea, 0x90, 0xbf, 0x71, 0xab, 0x5c,
+	0xc2, 0x59, 0x31, 0x60, 0x6c, 0x6e, 0x54, 0x79, 0x94, 0xa5, 0x25, 0x9b, 0x40, 0xf2, 0x11, 0x1e,
+	0xde, 0xa6, 0x14, 0x73, 0x8f, 0x3b, 0x0f, 0xde, 0x13, 0x63, 0x16, 0x4c, 0x2b, 0xff, 0x1e, 0x31,
+	0x12, 0x87, 0x53, 0x32, 0x23, 0x8d, 0xc7, 0xcf, 0x57, 0x0c, 0x23, 0x4d, 0x90, 0x62, 0xfc, 0x9c,
+	0x13, 0xd8, 0x5b, 0xd0, 0xd6, 0x2b, 0x20, 0x0d, 0xa8, 0x3d, 0x3b, 0xdc, 0x3d, 0xe8, 0xce, 0x90,
+	0x16, 0xcc, 0x1d, 0xed, 0x1e, 0x1f, 0xef, 0xef, 0xee, 0x74, 0x2d, 0xd2, 0x86, 0x86, 0xca, 0xd3,
+	0xac, 0xb0, 0xd2, 0xd6, 0xf6, 0xf6, 0xee, 0xe1, 0xf1, 0xee, 0x4e, 0xb7, 0x6a, 0xff, 0x61, 0x05,
+	0x5a, 0x5a, 0xcd, 0xaf, 0x09, 0xbe, 0xdc, 0x04, 0x40, 0x8f, 0x21, 0xcb, 0xd6, 0xa8, 0x39, 0x1a,
+	0x84, 0x69, 0x44, 0xe5, 0x4b, 0x57, 0xf9, 0xf5, 0x46, 0x59, 0xc6, 0xb9, 0xc2, 0x7b, 0x84, 0xfa,
+	0x11, 0x45, 0xdd, 0x31, 0x81, 0x8c, 0x8f, 0x04, 0x00, 0x53, 0x06, 0xb9, 0x74, 0xe9, 0x20, 0xb6,
+	0x2e, 0x31, 0x4d, 0xa2, 0xe0, 0x82, 0x72, 0x12, 0x6e, 0x7f, 0x19, 0x30, 0xd6, 0x96, 0x50, 0x2f,
+	0x5a, 0x3a, 0x6f, 0xdd, 0x31, 0x81, 0xe4, 0xeb, 0x72, 0x5d, 0x1a, 0xb8, 0x2e, 0xab, 0xc5, 0x49,
+	0xd6, 0xd7, 0xc4, 0x4e, 0x81, 0x6c, 0x0d, 0x87, 0x02, 0xab, 0x5f, 0x96, 0x8c, 0xf5, 0x9b, 0xb9,
+	0x52, 0x41, 0x94, 0x08, 0x69, 0xa5, 0x5c, 0x48, 0x5f, 0xcb, 0xca, 0xf6, 0x2e, 0xb4, 0x0e, 0xb5,
+	0xbb, 0xbe, 0xa8, 0xaf, 0xe4, 0x2d, 0x5f, 0xa1, 0xe7, 0x34, 0x88, 0xd6, 0x9d, 0x8a, 0xde, 0x1d,
+	0xfb, 0x0f, 0x2d, 0x7e, 0x7d, 0x4a, 0x75, 0x9f, 0xb7, 0x6d, 0x43, 0x5b, 0x05, 0xa0, 0xb3, 0x4c,
+	0x75, 0x03, 0xc6, 0x68, 0xb0, 0x2b, 0x6e, 0x74, 0x7a, 0x9a, 0x50, 0x99, 0x57, 0x6a, 0xc0, 0xa4,
+	0xa1, 0xc8, 0x4c, 0x4f, 0x9f, 0xb7, 0x90, 0x88, 0xfc, 0xd2, 0x02, 0x9c, 0x31, 0x89, 0x88, 0x33,
+	0xca, 0x8c, 0x5a, 0x55, 0x56, 0x09, 0xf5, 0xf9, 0x59, 0x5e, 0x87, 0x86, 0xaa, 0xd7, 0xdc, 0x11,
+	0x24, 0xa5, 0xc2, 0xb3, 0x9d, 0x07, 0x1d, 0x48, 0xa3, 0xd3, 0x9c, 0x57, 0x8b, 0x08, 0xb2, 0x01,
+	0xe4, 0xd4, 0x8f, 0xf3, 0xe4, 0x9c, 0x79, 0x4b, 0x30, 0xf6, 0x0b, 0x58, 0x92, 0xf2, 0xa6, 0x59,
+	0xb0, 0xe6, 0x22, 0x5a, 0x6f, 0xd2, 0x47, 0x95, 0xa2, 0x3e, 0xb2, 0xff, 0xac, 0x0a, 0x73, 0x62,
+	0xa5, 0x0b, 0xf7, 0xc5, 0xf9, 0x3a, 0x1b, 0x30, 0xd2, 0x33, 0x6e, 0x06, 0xa2, 0xf2, 0x12, 0xbb,
+	0x50, 0x61, 0x9f, 0xa9, 0x96, 0xed, 0x33, 0x04, 0x6a, 0x63, 0x2f, 0x3d, 0xc7, 0x10, 0x4b, 0xd3,
+	0xc1, 0xdf, 0x32, 0x14, 0x5a, 0x37, 0x43, 0xa1, 0x65, 0xb7, 0xe3, 0xb9, 0x09, 0x55, 0xbc, 0x1d,
+	0x7f, 0x03, 0x9a, 0xfc, 0x46, 0x75, 0x16, 0xed, 0xcc, 0x00, 0x8c, 0x7b, 0x79, 0x01, 0x35, 0x84,
+	0xb8, 0xa8, 0x93, 0x41, 0xde, 0x61, 0x67, 0xfb, 0x26, 0xcc, 0xf2, 0x9b, 0x22, 0x22, 0x6f, 0xf8,
+	0x86, 0x3c, 0x61, 0xe4, 0x74, 0xf2, 0x2f, 0x4f, 0x40, 0x72, 0x04, 0xad, 0x7e, 0xcf, 0xb4, 0x65,
+	0xde, 0x33, 0xd5, 0x83, 0xb4, 0x6d, 0x33, 0x48, 0x6b, 0x3f, 0x86, 0x79, 0xa3, 0x3a, 0xa6, 0x59,
+	0x45, 0xde, 0x71, 0x77, 0x86, 0xcc, 0x43, 0xf3, 0xe9, 0x81, 0xfb, 0x78, 0xff, 0xe9, 0x93, 0xbd,
+	0xe3, 0xae, 0xc5, 0x8a, 0x47, 0xcf, 0xb7, 0xb7, 0x77, 0x77, 0x77, 0x50, 0xd3, 0x02, 0xcc, 0x3e,
+	0xde, 0x7a, 0xba, 0x8f, 0x7a, 0x76, 0x87, 0xf3, 0xb6, 0xa8, 0x4b, 0x9d, 0xea, 0x7c, 0x1d, 0x88,
+	0xf4, 0xf1, 0x31, 0xff, 0x68, 0x1c, 0xd0, 0x54, 0xa6, 0xc4, 0x2f, 0x0a, 0xcc, 0x53, 0x85, 0x90,
+	0x37, 0x3a, 0xb2, 0x5a, 0x32, 0x11, 0x11, 0x93, 0x94, 0x17, 0x11, 0x41, 0xea, 0x28, 0xbc, 0xdd,
+	0x87, 0xde, 0x0e, 0x65, 0xb5, 0x6d, 0x05, 0x41, 0xae, 0x3b, 0xcc, 0x51, 0x2b, 0xc1, 0x09, 0x2f,
+	0xee, 0x7b, 0x70, 0x6d, 0x8b, 0x67, 0xbf, 0xff, 0xb6, 0x92, 0x23, 0xed, 0x1e, 0xac, 0xe4, 0xab,
+	0x14, 0x8d, 0x3d, 0x86, 0xc5, 0x1d, 0x7a, 0x32, 0x39, 0xdb, 0xa7, 0x17, 0x59, 0x43, 0x04, 0x6a,
+	0xc9, 0x79, 0x74, 0x29, 0xe6, 0x07, 0x7f, 0x93, 0xf7, 0x01, 0x02, 0x46, 0xe3, 0x26, 0x63, 0x3a,
+	0x90, 0xb7, 0x13, 0x11, 0x72, 0x34, 0xa6, 0x03, 0xfb, 0x63, 0x20, 0x7a, 0x3d, 0x62, 0xbe, 0x98,
+	0x9d, 0x35, 0x39, 0x71, 0x93, 0xab, 0x24, 0xa5, 0x23, 0x79, 0xed, 0x52, 0x07, 0xd9, 0x77, 0xa1,
+	0x7d, 0xe8, 0x5d, 0x39, 0xf4, 0xa7, 0xe2, 0xdd, 0x84, 0x55, 0x98, 0x1b, 0x7b, 0x57, 0x8c, 0x05,
+	0x55, 0xd0, 0x17, 0xd1, 0xf6, 0xff, 0xae, 0xc0, 0x2c, 0xa7, 0x64, 0xb5, 0x0e, 0x69, 0x92, 0xfa,
+	0x21, 0x4a, 0x9a, 0xac, 0x55, 0x03, 0x15, 0x64, 0xbb, 0x52, 0x22, 0xdb, 0x22, 0x22, 0x21, 0x6f,
+	0x7a, 0x09, 0x01, 0x36, 0x60, 0x4c, 0xd2, 0xb2, 0x2c, 0x67, 0x1e, 0x1a, 0xcc, 0x00, 0xb9, 0xe3,
+	0x8b, 0xcc, 0x9a, 0xe3, 0xfd, 0x93, 0x6a, 0x4b, 0x88, 0xb1, 0x0e, 0x2a, 0xb5, 0x19, 0xe7, 0xb8,
+	0xb4, 0x17, 0x6c, 0xc6, 0x82, 0x6d, 0xd8, 0x78, 0x0b, 0xdb, 0x90, 0x87, 0x29, 0x5e, 0x67, 0x1b,
+	0xc2, 0x5b, 0xd8, 0x86, 0x36, 0x81, 0x2e, 0x5e, 0x21, 0x67, 0xde, 0x87, 0xe4, 0xdd, 0xbf, 0x6f,
+	0x41, 0x57, 0x70, 0x91, 0xc2, 0x91, 0x0f, 0x0c, 0x2f, 0xab, 0xf4, 0x8e, 0xd2, 0x6d, 0x98, 0x47,
+	0xdf, 0x47, 0xa9, 0x00, 0x71, 0xa8, 0x64, 0x00, 0xd9, 0x38, 0x64, 0x8e, 0xcc, 0xc8, 0x0f, 0xc4,
+	0xa2, 0xe8, 0x20, 0xa9, 0x45, 0x62, 0x4f, 0x64, 0xeb, 0x5a, 0x8e, 0x2a, 0xdb, 0x7f, 0x6c, 0xc1,
+	0xa2, 0xd6, 0x61, 0xc1, 0x85, 0x9f, 0x42, 0x5b, 0xbd, 0xd4, 0x40, 0xd5, 0xe6, 0xb6, 0x6a, 0x8a,
+	0x4d, 0xf6, 0x99, 0x41, 0x8c, 0x8b, 0xe9, 0x5d, 0x61, 0x07, 0x93, 0xc9, 0x48, 0xec, 0x2a, 0x3a,
+	0x88, 0x31, 0xd2, 0x25, 0xa5, 0x2f, 0x15, 0x09, 0xdf, 0xd7, 0x0c, 0x18, 0xc6, 0x87, 0x99, 0xcf,
+	0xa6, 0x88, 0x6a, 0x22, 0x3e, 0xac, 0x03, 0xed, 0xbf, 0x5a, 0x81, 0x25, 0xee, 0x7c, 0x8b, 0x80,
+	0x87, 0xba, 0x2c, 0x3b, 0xcb, 0x63, 0x10, 0x5c, 0x22, 0xf7, 0x66, 0x1c, 0x51, 0x26, 0xdf, 0x7a,
+	0xcb, 0x80, 0x81, 0x4a, 0x21, 0x9e, 0xb2, 0x16, 0xd5, 0xb2, 0xb5, 0x78, 0xcd, 0x4c, 0x97, 0x85,
+	0xea, 0xeb, 0xe5, 0xa1, 0xfa, 0xb7, 0x0a, 0x8d, 0x3f, 0x9a, 0x83, 0x7a, 0x32, 0x88, 0xc6, 0xd4,
+	0x5e, 0x81, 0x65, 0x73, 0x0a, 0x84, 0xa2, 0xfa, 0x85, 0x05, 0xbd, 0xc7, 0xfc, 0xc8, 0xcf, 0x0f,
+	0xcf, 0xf6, 0xfc, 0x24, 0x8d, 0x62, 0xf5, 0xf2, 0xc0, 0x4d, 0x80, 0x24, 0xf5, 0x62, 0x61, 0xd0,
+	0x8a, 0x30, 0x79, 0x06, 0x61, 0x23, 0xa1, 0xe1, 0x90, 0x63, 0xf9, 0x0a, 0xaa, 0x72, 0xc1, 0xf4,
+	0x12, 0x41, 0x04, 0xc3, 0x80, 0xb9, 0xc3, 0x13, 0xef, 0x59, 0x97, 0xe9, 0x05, 0x6a, 0x7f, 0xee,
+	0x9d, 0xe7, 0xa0, 0xf6, 0x7f, 0xb4, 0x60, 0x21, 0xeb, 0x24, 0x26, 0x88, 0x98, 0x3a, 0x44, 0x58,
+	0x2d, 0x99, 0x0e, 0x91, 0x01, 0x7c, 0x9f, 0x99, 0x31, 0xd2, 0xda, 0xcf, 0x20, 0x28, 0xd7, 0xa2,
+	0x14, 0x4d, 0xa4, 0x5d, 0xa8, 0x83, 0x78, 0x1a, 0x2d, 0x33, 0xa0, 0x84, 0x31, 0x28, 0x4a, 0x78,
+	0x85, 0x69, 0x94, 0xe2, 0x57, 0x7c, 0xc6, 0x65, 0x91, 0x74, 0xb9, 0x05, 0xc2, 0x5f, 0x61, 0x41,
+	0xeb, 0x43, 0xdf, 0x99, 0x1b, 0xea, 0xc9, 0x14, 0xbe, 0x33, 0xff, 0x6d, 0x0b, 0xae, 0x97, 0x4c,
+	0xbc, 0x90, 0xad, 0x1d, 0x58, 0x3c, 0x55, 0x48, 0x39, 0x39, 0x5c, 0xc0, 0x56, 0x64, 0x86, 0x83,
+	0x39, 0x21, 0x4e, 0xf1, 0x03, 0x65, 0x4e, 0xf2, 0xe9, 0x36, 0x12, 0xd5, 0x8b, 0x08, 0xfb, 0x10,
+	0xfa, 0xbb, 0xaf, 0x98, 0xa8, 0x6e, 0xeb, 0xcf, 0xbd, 0x49, 0x5e, 0x78, 0x50, 0x50, 0x45, 0x6f,
+	0x0e, 0xf8, 0x9c, 0xc2, 0xbc, 0x51, 0x17, 0xf9, 0xc6, 0xdb, 0x56, 0xa2, 0x4b, 0x95, 0x5c, 0x2b,
+	0xfe, 0x5e, 0x9d, 0x4c, 0x97, 0xd7, 0x40, 0xf6, 0x05, 0x2c, 0x7c, 0x3e, 0x09, 0x52, 0x3f, 0x7b,
+	0xbb, 0x8e, 0x7c, 0x4b, 0x7c, 0x84, 0x55, 0xc8, 0xa9, 0x2b, 0x6d, 0x4a, 0xa7, 0x63, 0x33, 0x36,
+	0x62, 0x35, 0xb9, 0xc5, 0x16, 0x8b, 0x08, 0xfb, 0x3a, 0xac, 0x66, 0x4d, 0xf2, 0xb9, 0x93, 0xea,
+	0xfc, 0x97, 0x16, 0xcf, 0xfb, 0x32, 0x9f, 0xd2, 0x23, 0x4f, 0x60, 0x29, 0xf1, 0xc3, 0xb3, 0x80,
+	0xea, 0xf5, 0x24, 0x62, 0x26, 0xae, 0x99, 0xdd, 0x13, 0xcf, 0xed, 0x39, 0x65, 0x5f, 0x30, 0x06,
+	0x29, 0xef, 0x68, 0xc6, 0x20, 0xb9, 0x29, 0x29, 0x1b, 0xc0, 0x77, 0xa1, 0x63, 0x36, 0x46, 0x1e,
+	0x8a, 0x4c, 0xf7, 0xac, 0x67, 0xfa, 0xa9, 0x8c, 0xc9, 0x19, 0x06, 0xa5, 0xfd, 0x73, 0x0b, 0x7a,
+	0x0e, 0x65, 0x6c, 0x4c, 0xb5, 0x46, 0x05, 0xf7, 0x7c, 0x5a, 0xa8, 0x76, 0xfa, 0x80, 0x55, 0x06,
+	0xbd, 0x1c, 0xeb, 0xc6, 0xd4, 0x45, 0xd9, 0x9b, 0x29, 0x19, 0xd5, 0xa3, 0x06, 0xcc, 0x8a, 0xf1,
+	0xad, 0xc2, 0x35, 0xd1, 0x25, 0xd9, 0x9d, 0x2c, 0xa4, 0x6f, 0x34, 0x6a, 0x84, 0xf4, 0xfb, 0xd0,
+	0xe3, 0x4f, 0x42, 0xe8, 0xe3, 0xe0, 0x1f, 0xae, 0x7f, 0x09, 0x2d, 0xed, 0x61, 0x0c, 0xb2, 0x0a,
+	0x4b, 0x2f, 0x9e, 0x1e, 0x1f, 0xec, 0x1e, 0x1d, 0xb9, 0x87, 0xcf, 0x1f, 0x7d, 0xb6, 0xfb, 0x03,
+	0x77, 0x6f, 0xeb, 0x68, 0xaf, 0x3b, 0x43, 0x56, 0x80, 0x1c, 0xec, 0x1e, 0x1d, 0xef, 0xee, 0x18,
+	0x70, 0x8b, 0xdc, 0x84, 0xfe, 0xf3, 0x83, 0xe7, 0x47, 0xbb, 0x3b, 0x6e, 0xd9, 0x77, 0x15, 0xf2,
+	0x3e, 0x5c, 0x17, 0xf8, 0x92, 0xcf, 0xab, 0xeb, 0xdf, 0x86, 0x6e, 0xde, 0xc7, 0x37, 0x22, 0x22,
+	0xb9, 0xd0, 0xc9, 0x3c, 0x34, 0x79, 0xe8, 0x04, 0x63, 0x27, 0x0f, 0x7e, 0x5e, 0x85, 0x0e, 0x4f,
+	0x5e, 0xe3, 0xef, 0x37, 0xd2, 0x98, 0x7c, 0x0e, 0x73, 0xe2, 0x21, 0x50, 0x22, 0x57, 0xc3, 0x7c,
+	0x7a, 0xb4, 0xbf, 0x92, 0x07, 0x8b, 0x29, 0x5c, 0xfa, 0x6b, 0x7f, 0xfa, 0xdf, 0xfe, 0x6e, 0x65,
+	0x9e, 0xb4, 0x36, 0x2f, 0x3e, 0xda, 0x3c, 0xa3, 0x61, 0xc2, 0xea, 0xf8, 0x7d, 0x80, 0xec, 0x79,
+	0x4b, 0xd2, 0x53, 0x8e, 0x6e, 0xee, 0xed, 0xcf, 0xfe, 0xf5, 0x12, 0x8c, 0xa8, 0xf7, 0x3a, 0xd6,
+	0xbb, 0x64, 0x77, 0x58, 0xbd, 0x7e, 0xe8, 0xa7, 0xfc, 0xa9, 0xcb, 0x4f, 0xac, 0x75, 0x32, 0x84,
+	0xb6, 0xfe, 0xf0, 0x24, 0x91, 0x87, 0x1a, 0x25, 0x4f, 0x67, 0xf6, 0xdf, 0x2b, 0xc5, 0xc9, 0xe5,
+	0xc7, 0x36, 0xae, 0xd9, 0x5d, 0xd6, 0xc6, 0x04, 0x29, 0xb2, 0x56, 0x02, 0x2e, 0x14, 0xd9, 0xfb,
+	0x92, 0xe4, 0x86, 0xc6, 0xa7, 0x85, 0xd7, 0x2d, 0xfb, 0xef, 0x4f, 0xc1, 0x8a, 0xb6, 0xde, 0xc7,
+	0xb6, 0x56, 0x6d, 0xc2, 0xda, 0x1a, 0x20, 0x8d, 0x7c, 0xdd, 0xf2, 0x13, 0x6b, 0xfd, 0xc1, 0xff,
+	0xb8, 0x03, 0x4d, 0x75, 0xd8, 0x49, 0x7e, 0x02, 0xf3, 0x46, 0x76, 0x21, 0x91, 0xc3, 0x28, 0x4b,
+	0x46, 0xec, 0xdf, 0x28, 0x47, 0x8a, 0x86, 0x6f, 0x62, 0xc3, 0x3d, 0xb2, 0xc2, 0x1a, 0x16, 0xe9,
+	0x79, 0x9b, 0x98, 0x27, 0xcb, 0xaf, 0xd9, 0xbd, 0xd4, 0x84, 0x9f, 0x37, 0x76, 0x23, 0x2f, 0x8f,
+	0x46, 0x6b, 0xef, 0x4f, 0xc1, 0x8a, 0xe6, 0x6e, 0x60, 0x73, 0x2b, 0x64, 0x59, 0x6f, 0x4e, 0x1d,
+	0x42, 0x52, 0xbc, 0x5b, 0xaa, 0x3f, 0xbd, 0x48, 0xde, 0x57, 0x8c, 0x55, 0xf6, 0x24, 0xa3, 0x62,
+	0x91, 0xe2, 0xbb, 0x8c, 0x76, 0x0f, 0x9b, 0x22, 0x04, 0x97, 0x4f, 0x7f, 0x79, 0x91, 0x9c, 0x40,
+	0x4b, 0x7b, 0xa4, 0x89, 0x5c, 0x9f, 0xfa, 0xa0, 0x54, 0xbf, 0x5f, 0x86, 0x2a, 0x1b, 0x8a, 0x5e,
+	0xff, 0x26, 0xdb, 0xd5, 0x7f, 0x04, 0x4d, 0xf5, 0xec, 0x0f, 0x59, 0xd5, 0x9e, 0x61, 0xd2, 0x9f,
+	0x29, 0xea, 0xf7, 0x8a, 0x88, 0x32, 0xe6, 0xd3, 0x6b, 0x67, 0xcc, 0xf7, 0x02, 0x5a, 0xda, 0xd3,
+	0x3e, 0x6a, 0x00, 0xc5, 0xe7, 0x83, 0xd4, 0x00, 0x4a, 0x5e, 0x02, 0xb2, 0x17, 0xb1, 0x89, 0x16,
+	0x69, 0x22, 0x7f, 0xa7, 0xaf, 0xa2, 0x84, 0xec, 0xc3, 0x35, 0xa1, 0xe4, 0x4e, 0xe8, 0xbb, 0x2c,
+	0x43, 0xc9, 0x6b, 0x97, 0xf7, 0x2d, 0xf2, 0x29, 0x34, 0xe4, 0x0b, 0x4e, 0x64, 0xa5, 0xfc, 0x25,
+	0xaa, 0xfe, 0x6a, 0x01, 0x2e, 0x8c, 0x9b, 0x1f, 0x00, 0x64, 0xef, 0x08, 0x29, 0x25, 0x51, 0x78,
+	0x97, 0x48, 0x71, 0x40, 0xf1, 0xd1, 0x21, 0x7b, 0x05, 0x07, 0xd8, 0x25, 0xa8, 0x24, 0x42, 0x7a,
+	0x29, 0xaf, 0x91, 0xff, 0x18, 0x5a, 0xda, 0x53, 0x42, 0x6a, 0xfa, 0x8a, 0xcf, 0x10, 0xa9, 0xe9,
+	0x2b, 0x79, 0x79, 0xc8, 0xee, 0x63, 0xed, 0xcb, 0xf6, 0x02, 0xab, 0x3d, 0xf1, 0xcf, 0xc2, 0x11,
+	0x27, 0x60, 0x0b, 0x74, 0x0e, 0xf3, 0xc6, 0x7b, 0x41, 0x4a, 0x42, 0xcb, 0x5e, 0x23, 0x52, 0x12,
+	0x5a, 0xfa, 0xc4, 0x90, 0xe4, 0x33, 0x7b, 0x91, 0xb5, 0x73, 0x81, 0x24, 0x5a, 0x4b, 0x3f, 0x84,
+	0x96, 0xf6, 0xf6, 0x8f, 0x1a, 0x4b, 0xf1, 0x99, 0x21, 0x35, 0x96, 0xb2, 0xa7, 0x82, 0x96, 0xb1,
+	0x8d, 0x8e, 0x8d, 0xac, 0x80, 0x17, 0xa2, 0x59, 0xdd, 0x3f, 0x81, 0x8e, 0xf9, 0x1a, 0x90, 0x92,
+	0xfd, 0xd2, 0x77, 0x85, 0x94, 0xec, 0x4f, 0x79, 0x42, 0x48, 0xb0, 0xf4, 0xfa, 0x92, 0x6a, 0x64,
+	0xf3, 0x0b, 0x91, 0x2a, 0xf5, 0x25, 0xf9, 0x1e, 0x53, 0x70, 0xe2, 0x86, 0x3a, 0x59, 0xd5, 0xb8,
+	0x56, 0xbf, 0xc7, 0xae, 0xe4, 0xa5, 0x70, 0x99, 0xdd, 0x64, 0x66, 0x7e, 0xa5, 0x1b, 0x77, 0x2d,
+	0xbc, 0xa9, 0xae, 0xed, 0x5a, 0xfa, 0x65, 0x76, 0x6d, 0xd7, 0x32, 0x2e, 0xb4, 0xe7, 0x77, 0xad,
+	0xd4, 0x67, 0x75, 0x84, 0xb0, 0x90, 0xbb, 0x01, 0xa1, 0xa4, 0xa2, 0xfc, 0x92, 0x5a, 0xff, 0xe6,
+	0xeb, 0x2f, 0x4e, 0x98, 0x1a, 0x44, 0x2a, 0xc1, 0x4d, 0x79, 0x25, 0xf0, 0x2f, 0x41, 0x5b, 0x7f,
+	0xd9, 0x84, 0xe8, 0xa2, 0x9c, 0x6f, 0xe9, 0xbd, 0x52, 0x9c, 0xb9, 0xb8, 0xa4, 0xad, 0x37, 0x43,
+	0xbe, 0x0f, 0x2b, 0x4a, 0xd4, 0xf5, 0xa4, 0xfa, 0x84, 0xdc, 0x2a, 0x49, 0xb5, 0xd7, 0x4d, 0x9f,
+	0xfe, 0xf5, 0xa9, 0xb9, 0xf8, 0xf7, 0x2d, 0xc6, 0x34, 0xe6, 0x93, 0x11, 0xd9, 0x86, 0x51, 0xf6,
+	0x52, 0x46, 0xb6, 0x61, 0x94, 0xbe, 0x33, 0x21, 0x99, 0x86, 0x2c, 0x19, 0x73, 0xc4, 0x4f, 0x99,
+	0xc9, 0x0f, 0x61, 0x41, 0xbb, 0xb6, 0x74, 0x74, 0x15, 0x0e, 0x94, 0x00, 0x14, 0x6f, 0xd4, 0xf6,
+	0xcb, 0x0c, 0x7b, 0x7b, 0x15, 0xeb, 0x5f, 0xb4, 0x8d, 0xc9, 0x61, 0xcc, 0xbf, 0x0d, 0x2d, 0xfd,
+	0x4a, 0xd4, 0x6b, 0xea, 0x5d, 0xd5, 0x50, 0xfa, 0x85, 0xd0, 0xfb, 0x16, 0x39, 0xe4, 0x19, 0x46,
+	0xea, 0x09, 0xca, 0x28, 0xce, 0x6f, 0x9f, 0xe6, 0xd3, 0x94, 0x6a, 0x21, 0xcb, 0x1e, 0x25, 0xbd,
+	0x67, 0xdd, 0xb7, 0xc8, 0x3f, 0xb0, 0xa0, 0x6d, 0x5c, 0x59, 0x32, 0x72, 0x36, 0x72, 0x3d, 0xeb,
+	0xe9, 0x38, 0xbd, 0x6b, 0xb6, 0x83, 0xc3, 0xde, 0x5f, 0xff, 0xae, 0x31, 0xad, 0x5f, 0x18, 0x51,
+	0xa3, 0x8d, 0xfc, 0x3b, 0x94, 0x5f, 0xe6, 0x09, 0xf4, 0x7b, 0xcc, 0x5f, 0xde, 0xb7, 0xc8, 0x1f,
+	0x59, 0xd0, 0x31, 0x63, 0x9d, 0x6a, 0xb8, 0xa5, 0x51, 0x55, 0xb5, 0xf8, 0x53, 0x02, 0xa4, 0x3f,
+	0xc4, 0x5e, 0x1e, 0xaf, 0x3b, 0x46, 0x2f, 0xc5, 0xf3, 0x24, 0xbf, 0x59, 0x6f, 0xc9, 0x27, 0xfc,
+	0xd1, 0x64, 0x79, 0x22, 0x41, 0x8a, 0xcf, 0xf7, 0x2a, 0x86, 0xd1, 0x1f, 0xdc, 0xc5, 0x45, 0xf8,
+	0x31, 0x7f, 0x7f, 0x51, 0x06, 0xcd, 0x19, 0xdf, 0xbd, 0xed, 0xf7, 0xf6, 0x6d, 0x1c, 0xd3, 0x4d,
+	0xfb, 0xba, 0x31, 0xa6, 0xfc, 0x0e, 0xbf, 0xc5, 0x7b, 0x27, 0xde, 0xca, 0xcd, 0xb6, 0xa8, 0xc2,
+	0xfb, 0xb9, 0xd3, 0x3b, 0x39, 0xe2, 0x9d, 0x14, 0xe4, 0x86, 0x70, 0xbc, 0x65, 0x35, 0xf6, 0x3a,
+	0xf6, 0xf5, 0xb6, 0x7d, 0x6b, 0x6a, 0x5f, 0x37, 0x31, 0x62, 0xc9, 0x7a, 0x7c, 0x08, 0x90, 0x9d,
+	0x1e, 0x92, 0xdc, 0xe9, 0x95, 0x52, 0x19, 0xc5, 0x03, 0x46, 0x53, 0x02, 0xe5, 0x21, 0x17, 0xab,
+	0xf1, 0x47, 0x5c, 0x01, 0x3e, 0x95, 0xe7, 0x5e, 0xba, 0x99, 0x63, 0x1e, 0xf3, 0x19, 0x66, 0x4e,
+	0xbe, 0x7e, 0x43, 0xfd, 0xa9, 0x43, 0xb4, 0xe7, 0x30, 0xbf, 0x1f, 0x45, 0x2f, 0x27, 0x63, 0x95,
+	0x5a, 0x61, 0x1e, 0x26, 0xec, 0x79, 0xc9, 0x79, 0x3f, 0x37, 0x0a, 0x7b, 0x0d, 0xab, 0xea, 0x93,
+	0x9e, 0x56, 0xd5, 0xe6, 0x17, 0xd9, 0xe9, 0xe4, 0x97, 0xc4, 0x83, 0x45, 0xa5, 0x55, 0x55, 0xc7,
+	0xfb, 0x66, 0x35, 0x86, 0x2e, 0xcd, 0x37, 0x61, 0xd8, 0xe3, 0xb2, 0xb7, 0x9b, 0x89, 0xac, 0x13,
+	0x75, 0x4a, 0x7b, 0x87, 0x0e, 0xf0, 0xc2, 0x04, 0x46, 0xe4, 0x97, 0xb2, 0x8e, 0xab, 0x50, 0x7e,
+	0x7f, 0xde, 0x00, 0x9a, 0x3b, 0xcd, 0xd8, 0xbb, 0x8a, 0xe9, 0x4f, 0x37, 0xbf, 0x10, 0xb1, 0xfe,
+	0x2f, 0xe5, 0x4e, 0x23, 0x0f, 0x43, 0x8c, 0x9d, 0x26, 0x77, 0x7a, 0x62, 0xec, 0x34, 0x85, 0xd3,
+	0x13, 0x63, 0xaa, 0xe5, 0x61, 0x0c, 0x09, 0x60, 0xb1, 0x70, 0xe0, 0xa2, 0x36, 0x99, 0x69, 0xc7,
+	0x34, 0xfd, 0xb5, 0xe9, 0x04, 0x66, 0x6b, 0xeb, 0x66, 0x6b, 0x47, 0x30, 0xbf, 0x43, 0xf9, 0x64,
+	0xf1, 0xdc, 0xd1, 0xdc, 0xbd, 0x37, 0x3d, 0x33, 0x35, 0xbf, 0x25, 0x20, 0xce, 0x34, 0x25, 0x30,
+	0x71, 0x93, 0xfc, 0x08, 0x5a, 0x4f, 0x68, 0x2a, 0x93, 0x45, 0x95, 0x31, 0x9b, 0xcb, 0x1e, 0xed,
+	0x97, 0xe4, 0x9a, 0x9a, 0x3c, 0x83, 0xb5, 0x6d, 0xd2, 0xe1, 0x19, 0xe5, 0xca, 0xc9, 0xf5, 0x87,
+	0x5f, 0x92, 0xbf, 0x88, 0x95, 0xab, 0x4c, 0xf9, 0x15, 0x2d, 0xfb, 0x4f, 0xaf, 0x7c, 0x21, 0x07,
+	0x2f, 0xab, 0x39, 0x8c, 0x86, 0x54, 0x33, 0xaa, 0x42, 0x68, 0x69, 0xd7, 0x59, 0x94, 0x00, 0x15,
+	0xef, 0xf6, 0x28, 0x01, 0x2a, 0xb9, 0xfd, 0x62, 0xdf, 0xc3, 0x76, 0x6c, 0xb2, 0x96, 0xb5, 0xc3,
+	0x6f, 0xbc, 0x64, 0x2d, 0x6d, 0x7e, 0xe1, 0x8d, 0xd2, 0x2f, 0xc9, 0x0b, 0x7c, 0x2e, 0x48, 0x4f,
+	0x88, 0xcd, 0xac, 0xf3, 0x7c, 0xee, 0xac, 0x9a, 0x2c, 0x0d, 0x65, 0x5a, 0xec, 0xbc, 0x29, 0xb4,
+	0xbd, 0xbe, 0x05, 0x70, 0x94, 0x46, 0xe3, 0x1d, 0x8f, 0x8e, 0xa2, 0x30, 0xd3, 0xb5, 0x59, 0x3a,
+	0x66, 0xa6, 0xbf, 0xb4, 0x9c, 0x4c, 0xf2, 0x42, 0x73, 0x67, 0x8c, 0x7c, 0x62, 0xc9, 0x5c, 0x53,
+	0x33, 0x36, 0xd5, 0x84, 0x94, 0x64, 0x6d, 0xde, 0xb7, 0xc8, 0x16, 0x40, 0x76, 0xe2, 0xa6, 0x9c,
+	0x93, 0xc2, 0x61, 0x9e, 0x52, 0x7b, 0x25, 0xc7, 0x73, 0x87, 0xd0, 0xcc, 0x8e, 0x70, 0x56, 0xb3,
+	0x0b, 0x69, 0xc6, 0x81, 0x8f, 0xda, 0xc1, 0x0b, 0x07, 0x2b, 0x76, 0x17, 0xa7, 0x0a, 0x48, 0x83,
+	0x4d, 0x15, 0x9e, 0x96, 0xf8, 0xb0, 0xc4, 0x3b, 0xa8, 0x0c, 0x1c, 0x4c, 0x25, 0x94, 0x23, 0x29,
+	0x39, 0xdc, 0x50, 0xd2, 0x5c, 0x1a, 0xf5, 0x37, 0x62, 0x2c, 0x8c, 0x5b, 0x79, 0x1a, 0x23, 0x53,
+	0xcd, 0x23, 0x58, 0x2c, 0x84, 0xa5, 0x95, 0x48, 0x4f, 0x3b, 0x29, 0x50, 0x22, 0x3d, 0x35, 0xa2,
+	0x6d, 0x5f, 0xc3, 0x26, 0x17, 0x6c, 0x40, 0x9f, 0xea, 0xd2, 0x4f, 0x07, 0xe7, 0xac, 0xb9, 0x5f,
+	0x5a, 0xb0, 0x54, 0x12, 0x75, 0x26, 0x1f, 0x48, 0xf7, 0x7c, 0x6a, 0x44, 0xba, 0x5f, 0x1a, 0x94,
+	0xb4, 0x8f, 0xb0, 0x9d, 0xcf, 0xc9, 0x67, 0xc6, 0xc6, 0xc6, 0xe3, 0x81, 0x42, 0x32, 0x5f, 0x6b,
+	0x54, 0x94, 0x5a, 0x14, 0x3f, 0x85, 0x55, 0xde, 0x91, 0xad, 0x20, 0xc8, 0x05, 0x4c, 0x6f, 0x16,
+	0xfe, 0x6f, 0x8a, 0x11, 0x08, 0xee, 0x4f, 0xff, 0xbf, 0x2a, 0x53, 0x0c, 0x60, 0xde, 0x55, 0x32,
+	0x81, 0x6e, 0x3e, 0x08, 0x49, 0xa6, 0xd7, 0xd5, 0xbf, 0x65, 0x38, 0x9a, 0xc5, 0xc0, 0xa5, 0xfd,
+	0x3b, 0xd8, 0xd8, 0x2d, 0xbb, 0x5f, 0x36, 0x2f, 0xdc, 0xf7, 0x64, 0xeb, 0xf1, 0x57, 0x54, 0xc4,
+	0x34, 0x37, 0x4e, 0xd9, 0xc0, 0xb4, 0x10, 0xaf, 0x72, 0x75, 0xcb, 0x03, 0xae, 0x77, 0xb0, 0xf9,
+	0x35, 0xfb, 0xbd, 0xb2, 0xe6, 0x63, 0xfe, 0x09, 0x77, 0x7a, 0x57, 0xf3, 0x72, 0x2d, 0x7b, 0xb0,
+	0x56, 0xb6, 0xde, 0x53, 0xbd, 0x97, 0xdc, 0x5c, 0xcf, 0xdc, 0xb7, 0x1e, 0xdd, 0xfd, 0xe1, 0xef,
+	0x9c, 0xf9, 0xe9, 0xf9, 0xe4, 0x64, 0x63, 0x10, 0x8d, 0x36, 0x03, 0x19, 0x74, 0x13, 0x89, 0xef,
+	0x9b, 0x41, 0x38, 0xdc, 0xc4, 0xef, 0x4f, 0x66, 0xf1, 0xdf, 0x30, 0x7d, 0xe3, 0xff, 0x06, 0x00,
+	0x00, 0xff, 0xff, 0xc0, 0xfd, 0x98, 0x06, 0xb8, 0x69, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/lnrpc/rpc.proto b/lnrpc/rpc.proto
index 81c715ab6..22756ab5f 100644
--- a/lnrpc/rpc.proto
+++ b/lnrpc/rpc.proto
@@ -1237,6 +1237,14 @@ message Channel {
     The minimum satoshis the other node is required to reserve in its balance.
     */
     int64 remote_chan_reserve_sat = 21 [json_name = "remote_chan_reserve_sat"];
+
+    /**
+    If true, then this channel uses the modern commitment format where the key
+    in the output of the remote party does not change each state. This makes
+    back up and recovery easier as when the channel is closed, the funds go
+    directly to that key. 
+    */
+    bool static_remote_key = 22 [json_name = "static_remote_key"];
 }
 
 
diff --git a/lnrpc/rpc.swagger.json b/lnrpc/rpc.swagger.json
index 6e222888d..1e166e4af 100644
--- a/lnrpc/rpc.swagger.json
+++ b/lnrpc/rpc.swagger.json
@@ -1654,6 +1654,11 @@
           "type": "string",
           "format": "int64",
           "description": "*\nThe minimum satoshis the other node is required to reserve in its balance."
+        },
+        "static_remote_key": {
+          "type": "boolean",
+          "format": "boolean",
+          "description": "*\nIf true, then this channel uses the modern commitment format where the key\nin the output of the remote party does not change each state. This makes\nback up and recovery easier as when the channel is closed, the funds go\ndirectly to that key."
         }
       }
     },
diff --git a/lnwallet/channel.go b/lnwallet/channel.go
index 90871498a..720f5d0de 100644
--- a/lnwallet/channel.go
+++ b/lnwallet/channel.go
@@ -863,6 +863,12 @@ func (lc *LightningChannel) diskCommitToMemCommit(isLocal bool,
 	diskCommit *channeldb.ChannelCommitment, localCommitPoint,
 	remoteCommitPoint *btcec.PublicKey) (*commitment, error) {
 
+	// If this commit is tweakless, then it'll affect the way we derive our
+	// keys, which will affect the commitment transaction reconstruction.
+	// So we'll determine this first, before we do anything else.
+	tweaklessCommit := (lc.channelState.ChanType ==
+		channeldb.SingleFunderTweakless)
+
 	// First, we'll need to re-derive the commitment key ring for each
 	// party used within this particular state. If this is a pending commit
 	// (we extended but weren't able to complete the commitment dance
@@ -870,15 +876,15 @@ func (lc *LightningChannel) diskCommitToMemCommit(isLocal bool,
 	// haven't yet received a responding commitment from the remote party.
 	var localCommitKeys, remoteCommitKeys *CommitmentKeyRing
 	if localCommitPoint != nil {
-		localCommitKeys = deriveCommitmentKeys(
-			localCommitPoint, true, lc.localChanCfg,
-			lc.remoteChanCfg,
+		localCommitKeys = DeriveCommitmentKeys(
+			localCommitPoint, true, tweaklessCommit,
+			lc.localChanCfg, lc.remoteChanCfg,
 		)
 	}
 	if remoteCommitPoint != nil {
-		remoteCommitKeys = deriveCommitmentKeys(
-			remoteCommitPoint, false, lc.localChanCfg,
-			lc.remoteChanCfg,
+		remoteCommitKeys = DeriveCommitmentKeys(
+			remoteCommitPoint, false, tweaklessCommit,
+			lc.localChanCfg, lc.remoteChanCfg,
 		)
 	}
 
@@ -975,10 +981,11 @@ type CommitmentKeyRing struct {
 	RevocationKey *btcec.PublicKey
 }
 
-// deriveCommitmentKey generates a new commitment key set using the base points
+// DeriveCommitmentKey generates a new commitment key set using the base points
 // and commitment point. The keys are derived differently depending whether the
 // commitment transaction is ours or the remote peer's.
-func deriveCommitmentKeys(commitPoint *btcec.PublicKey, isOurCommit bool,
+func DeriveCommitmentKeys(commitPoint *btcec.PublicKey,
+	isOurCommit, tweaklessCommit bool,
 	localChanCfg, remoteChanCfg *channeldb.ChannelConfig) *CommitmentKeyRing {
 
 	// First, we'll derive all the keys that don't depend on the context of
@@ -1023,11 +1030,20 @@ func deriveCommitmentKeys(commitPoint *btcec.PublicKey, isOurCommit bool,
 	// With the base points assigned, we can now derive the actual keys
 	// using the base point, and the current commitment tweak.
 	keyRing.DelayKey = input.TweakPubKey(delayBasePoint, commitPoint)
-	keyRing.NoDelayKey = input.TweakPubKey(noDelayBasePoint, commitPoint)
 	keyRing.RevocationKey = input.DeriveRevocationPubkey(
 		revocationBasePoint, commitPoint,
 	)
 
+	// If this commitment should omit the tweak for the remote point, then
+	// we'll use that directly, and ignore the commitPoint tweak.
+	if tweaklessCommit {
+		keyRing.NoDelayKey = noDelayBasePoint
+	} else {
+		keyRing.NoDelayKey = input.TweakPubKey(
+			noDelayBasePoint, commitPoint,
+		)
+	}
+
 	return keyRing
 }
 
@@ -1695,9 +1711,10 @@ func (lc *LightningChannel) restoreCommitState(
 
 		// We'll also re-create the set of commitment keys needed to
 		// fully re-derive the state.
-		pendingRemoteKeyChain = deriveCommitmentKeys(
-			pendingCommitPoint, false, lc.localChanCfg,
-			lc.remoteChanCfg,
+		tweaklessCommit := lc.channelState.ChanType.IsTweakless()
+		pendingRemoteKeyChain = DeriveCommitmentKeys(
+			pendingCommitPoint, false, tweaklessCommit,
+			lc.localChanCfg, lc.remoteChanCfg,
 		)
 	}
 
@@ -1981,8 +1998,11 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 
 	// With the commitment point generated, we can now generate the four
 	// keys we'll need to reconstruct the commitment state,
-	keyRing := deriveCommitmentKeys(commitmentPoint, false,
-		&chanState.LocalChanCfg, &chanState.RemoteChanCfg)
+	tweaklessCommit := chanState.ChanType.IsTweakless()
+	keyRing := DeriveCommitmentKeys(
+		commitmentPoint, false, tweaklessCommit,
+		&chanState.LocalChanCfg, &chanState.RemoteChanCfg,
+	)
 
 	// Next, reconstruct the scripts as they were present at this state
 	// number so we can have the proper witness script to sign and include
@@ -2045,6 +2065,12 @@ func NewBreachRetribution(chanState *channeldb.OpenChannel, stateNum uint64,
 			},
 			HashType: txscript.SigHashAll,
 		}
+
+		// If this is a tweakless commitment, then we can safely blank
+		// out the SingleTweak value as it isn't needed.
+		if tweaklessCommit {
+			localSignDesc.SingleTweak = nil
+		}
 	}
 
 	// Similarly, if the remote balance exceeds the remote party's dust
@@ -3042,6 +3068,146 @@ func (lc *LightningChannel) createCommitDiff(
 	}, nil
 }
 
+// validateCommitmentSanity is used to validate the current state of the
+// commitment transaction in terms of the ChannelConstraints that we and our
+// remote peer agreed upon during the funding workflow. The predictAdded
+// parameter should be set to a valid PaymentDescriptor if we are validating
+// in the state when adding a new HTLC, or nil otherwise.
+func (lc *LightningChannel) validateCommitmentSanity(theirLogCounter,
+	ourLogCounter uint64, remoteChain bool,
+	predictAdded *PaymentDescriptor) error {
+
+	// Fetch all updates not committed.
+	view := lc.fetchHTLCView(theirLogCounter, ourLogCounter)
+
+	// If we are checking if we can add a new HTLC, we add this to the
+	// update log, in order to validate the sanity of the commitment
+	// resulting from _actually adding_ this HTLC to the state.
+	if predictAdded != nil {
+		// If we are adding an HTLC, this will be an Add to the local
+		// update log.
+		view.ourUpdates = append(view.ourUpdates, predictAdded)
+	}
+
+	commitChain := lc.localCommitChain
+	if remoteChain {
+		commitChain = lc.remoteCommitChain
+	}
+	ourInitialBalance := commitChain.tip().ourBalance
+	theirInitialBalance := commitChain.tip().theirBalance
+
+	ourBalance, theirBalance, commitWeight, filteredView := lc.computeView(
+		view, remoteChain, false,
+	)
+	feePerKw := filteredView.feePerKw
+
+	// Calculate the commitment fee, and subtract it from the initiator's
+	// balance.
+	commitFee := feePerKw.FeeForWeight(commitWeight)
+	commitFeeMsat := lnwire.NewMSatFromSatoshis(commitFee)
+	if lc.channelState.IsInitiator {
+		ourBalance -= commitFeeMsat
+	} else {
+		theirBalance -= commitFeeMsat
+	}
+
+	// As a quick sanity check, we'll ensure that if we interpret the
+	// balances as signed integers, they haven't dipped down below zero. If
+	// they have, then this indicates that a party doesn't have sufficient
+	// balance to satisfy the final evaluated HTLC's.
+	switch {
+	case int64(ourBalance) < 0:
+		return ErrBelowChanReserve
+	case int64(theirBalance) < 0:
+		return ErrBelowChanReserve
+	}
+
+	// Ensure that the fee being applied is enough to be relayed across the
+	// network in a reasonable time frame.
+	if feePerKw < FeePerKwFloor {
+		return fmt.Errorf("commitment fee per kw %v below fee floor %v",
+			feePerKw, FeePerKwFloor)
+	}
+
+	// If the added HTLCs will decrease the balance, make sure they won't
+	// dip the local and remote balances below the channel reserves.
+	switch {
+	case ourBalance < ourInitialBalance &&
+		ourBalance < lnwire.NewMSatFromSatoshis(
+			lc.localChanCfg.ChanReserve):
+
+		return ErrBelowChanReserve
+	case theirBalance < theirInitialBalance &&
+		theirBalance < lnwire.NewMSatFromSatoshis(
+			lc.remoteChanCfg.ChanReserve):
+
+		return ErrBelowChanReserve
+	}
+
+	// validateUpdates take a set of updates, and validates them against
+	// the passed channel constraints.
+	validateUpdates := func(updates []*PaymentDescriptor,
+		constraints *channeldb.ChannelConfig) error {
+
+		// We keep track of the number of HTLCs in flight for the
+		// commitment, and the amount in flight.
+		var numInFlight uint16
+		var amtInFlight lnwire.MilliSatoshi
+
+		// Go through all updates, checking that they don't violate the
+		// channel constraints.
+		for _, entry := range updates {
+			if entry.EntryType == Add {
+				// An HTLC is being added, this will add to the
+				// number and amount in flight.
+				amtInFlight += entry.Amount
+				numInFlight++
+
+				// Check that the value of the HTLC they added
+				// is above our minimum.
+				if entry.Amount < constraints.MinHTLC {
+					return ErrBelowMinHTLC
+				}
+			}
+		}
+
+		// Now that we know the total value of added HTLCs, we check
+		// that this satisfy the MaxPendingAmont contraint.
+		if amtInFlight > constraints.MaxPendingAmount {
+			return ErrMaxPendingAmount
+		}
+
+		// In this step, we verify that the total number of active
+		// HTLCs does not exceed the constraint of the maximum number
+		// of HTLCs in flight.
+		if numInFlight > constraints.MaxAcceptedHtlcs {
+			return ErrMaxHTLCNumber
+		}
+
+		return nil
+	}
+
+	// First check that the remote updates won't violate it's channel
+	// constraints.
+	err := validateUpdates(
+		filteredView.theirUpdates, lc.remoteChanCfg,
+	)
+	if err != nil {
+		return err
+	}
+
+	// Secondly check that our updates won't violate our channel
+	// constraints.
+	err = validateUpdates(
+		filteredView.ourUpdates, lc.localChanCfg,
+	)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // SignNextCommitment signs a new commitment which includes any previous
 // unsettled HTLCs, any new HTLCs, and any modifications to prior HTLCs
 // committed in previous commitment updates. Signing a new commitment
@@ -3091,8 +3257,9 @@ func (lc *LightningChannel) SignNextCommitment() (lnwire.Sig, []lnwire.Sig, []ch
 	// Grab the next commitment point for the remote party. This will be
 	// used within fetchCommitmentView to derive all the keys necessary to
 	// construct the commitment state.
-	keyRing := deriveCommitmentKeys(
-		commitPoint, false, lc.localChanCfg, lc.remoteChanCfg,
+	keyRing := DeriveCommitmentKeys(
+		commitPoint, false, lc.channelState.ChanType.IsTweakless(),
+		lc.localChanCfg, lc.remoteChanCfg,
 	)
 
 	// Create a new commitment view which will calculate the evaluated
@@ -3495,7 +3662,10 @@ func (lc *LightningChannel) ProcessChanSyncMsg(
 		commitPoint = lc.channelState.RemoteNextRevocation
 	}
 
-	if commitPoint != nil &&
+	// Only if this is a tweakless channel will we attempt to verify the
+	// commitment point, as otherwise it has no validity requirements.
+	tweakless := lc.channelState.ChanType.IsTweakless()
+	if !tweakless && commitPoint != nil &&
 		!commitPoint.IsEqual(msg.LocalUnrevokedCommitPoint) {
 
 		walletLog.Errorf("ChannelPoint(%v), sync failed: remote "+
@@ -3585,138 +3755,6 @@ func (lc *LightningChannel) computeView(view *htlcView, remoteChain bool,
 	return ourBalance, theirBalance, totalCommitWeight, filteredHTLCView
 }
 
-// validateCommitmentSanity is used to validate the current state of the
-// commitment transaction in terms of the ChannelConstraints that we and our
-// remote peer agreed upon during the funding workflow. The predictAdded
-// parameter should be set to a valid PaymentDescriptor if we are validating
-// in the state when adding a new HTLC, or nil otherwise.
-func (lc *LightningChannel) validateCommitmentSanity(theirLogCounter,
-	ourLogCounter uint64, remoteChain bool,
-	predictAdded *PaymentDescriptor) error {
-
-	// Fetch all updates not committed.
-	view := lc.fetchHTLCView(theirLogCounter, ourLogCounter)
-
-	// If we are checking if we can add a new HTLC, we add this to the
-	// update log, in order to validate the sanity of the commitment
-	// resulting from _actually adding_ this HTLC to the state.
-	if predictAdded != nil {
-		// If we are adding an HTLC, this will be an Add to the local
-		// update log.
-		view.ourUpdates = append(view.ourUpdates, predictAdded)
-	}
-
-	commitChain := lc.localCommitChain
-	if remoteChain {
-		commitChain = lc.remoteCommitChain
-	}
-	ourInitialBalance := commitChain.tip().ourBalance
-	theirInitialBalance := commitChain.tip().theirBalance
-
-	ourBalance, theirBalance, commitWeight, filteredView := lc.computeView(
-		view, remoteChain, false,
-	)
-	feePerKw := filteredView.feePerKw
-
-	// Calculate the commitment fee, and subtract it from the initiator's
-	// balance.
-	commitFee := feePerKw.FeeForWeight(commitWeight)
-	commitFeeMsat := lnwire.NewMSatFromSatoshis(commitFee)
-	if lc.channelState.IsInitiator {
-		ourBalance -= commitFeeMsat
-	} else {
-		theirBalance -= commitFeeMsat
-	}
-
-	// As a quick sanity check, we'll ensure that if we interpret the
-	// balances as signed integers, they haven't dipped down below zero. If
-	// they have, then this indicates that a party doesn't have sufficient
-	// balance to satisfy the final evaluated HTLC's.
-	switch {
-	case int64(ourBalance) < 0:
-		return ErrBelowChanReserve
-	case int64(theirBalance) < 0:
-		return ErrBelowChanReserve
-	}
-
-	// If the added HTLCs will decrease the balance, make sure they won't
-	// dip the local and remote balances below the channel reserves.
-	if ourBalance < ourInitialBalance &&
-		ourBalance < lnwire.NewMSatFromSatoshis(
-			lc.localChanCfg.ChanReserve) {
-		return ErrBelowChanReserve
-	}
-
-	if theirBalance < theirInitialBalance &&
-		theirBalance < lnwire.NewMSatFromSatoshis(
-			lc.remoteChanCfg.ChanReserve) {
-		return ErrBelowChanReserve
-	}
-
-	// validateUpdates take a set of updates, and validates them against
-	// the passed channel constraints.
-	validateUpdates := func(updates []*PaymentDescriptor,
-		constraints *channeldb.ChannelConfig) error {
-
-		// We keep track of the number of HTLCs in flight for the
-		// commitment, and the amount in flight.
-		var numInFlight uint16
-		var amtInFlight lnwire.MilliSatoshi
-
-		// Go through all updates, checking that they don't violate the
-		// channel constraints.
-		for _, entry := range updates {
-			if entry.EntryType == Add {
-				// An HTLC is being added, this will add to the
-				// number and amount in flight.
-				amtInFlight += entry.Amount
-				numInFlight++
-
-				// Check that the value of the HTLC they added
-				// is above our minimum.
-				if entry.Amount < constraints.MinHTLC {
-					return ErrBelowMinHTLC
-				}
-			}
-		}
-
-		// Now that we know the total value of added HTLCs, we check
-		// that this satisfy the MaxPendingAmont contraint.
-		if amtInFlight > constraints.MaxPendingAmount {
-			return ErrMaxPendingAmount
-		}
-
-		// In this step, we verify that the total number of active
-		// HTLCs does not exceed the constraint of the maximum number
-		// of HTLCs in flight.
-		if numInFlight > constraints.MaxAcceptedHtlcs {
-			return ErrMaxHTLCNumber
-		}
-
-		return nil
-	}
-
-	// First check that the remote updates won't violate it's channel
-	// constraints.
-	err := validateUpdates(
-		filteredView.theirUpdates, lc.remoteChanCfg,
-	)
-	if err != nil {
-		return err
-	}
-
-	// Secondly check that our updates won't violate our channel
-	// constraints.
-	err = validateUpdates(
-		filteredView.ourUpdates, lc.localChanCfg,
-	)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // genHtlcSigValidationJobs generates a series of signatures verification jobs
 // meant to verify all the signatures for HTLC's attached to a newly created
 // commitment state. The jobs generated are fully populated, and can be sent
@@ -3976,8 +4014,9 @@ func (lc *LightningChannel) ReceiveNewCommitment(commitSig lnwire.Sig,
 		return err
 	}
 	commitPoint := input.ComputeCommitmentPoint(commitSecret[:])
-	keyRing := deriveCommitmentKeys(
-		commitPoint, true, lc.localChanCfg, lc.remoteChanCfg,
+	keyRing := DeriveCommitmentKeys(
+		commitPoint, true, lc.channelState.ChanType.IsTweakless(),
+		lc.localChanCfg, lc.remoteChanCfg,
 	)
 
 	// With the current commitment point re-calculated, construct the new
@@ -5006,8 +5045,9 @@ func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer input.Si
 
 	// First, we'll generate the commitment point and the revocation point
 	// so we can re-construct the HTLC state and also our payment key.
-	keyRing := deriveCommitmentKeys(
-		commitPoint, false, &chanState.LocalChanCfg,
+	tweaklessCommit := chanState.ChanType.IsTweakless()
+	keyRing := DeriveCommitmentKeys(
+		commitPoint, false, tweaklessCommit, &chanState.LocalChanCfg,
 		&chanState.RemoteChanCfg,
 	)
 
@@ -5070,6 +5110,12 @@ func NewUnilateralCloseSummary(chanState *channeldb.OpenChannel, signer input.Si
 			},
 			MaturityDelay: 0,
 		}
+
+		// If this is a tweakless commitment, then we can safely blank
+		// out the SingleTweak value as it isn't needed.
+		if tweaklessCommit {
+			commitResolution.SelfOutputSignDesc.SingleTweak = nil
+		}
 	}
 
 	closeSummary := channeldb.ChannelCloseSummary{
@@ -5655,8 +5701,10 @@ func NewLocalForceCloseSummary(chanState *channeldb.OpenChannel, signer input.Si
 		return nil, err
 	}
 	commitPoint := input.ComputeCommitmentPoint(revocation[:])
-	keyRing := deriveCommitmentKeys(commitPoint, true, &chanState.LocalChanCfg,
-		&chanState.RemoteChanCfg)
+	keyRing := DeriveCommitmentKeys(
+		commitPoint, true, chanState.ChanType.IsTweakless(),
+		&chanState.LocalChanCfg, &chanState.RemoteChanCfg,
+	)
 	selfScript, err := input.CommitScriptToSelf(csvTimeout, keyRing.DelayKey,
 		keyRing.RevocationKey)
 	if err != nil {
diff --git a/lnwallet/reservation.go b/lnwallet/reservation.go
index 98c88d724..6ac592b9f 100644
--- a/lnwallet/reservation.go
+++ b/lnwallet/reservation.go
@@ -130,7 +130,8 @@ type ChannelReservation struct {
 func NewChannelReservation(capacity, localFundingAmt btcutil.Amount,
 	commitFeePerKw SatPerKWeight, wallet *LightningWallet,
 	id uint64, pushMSat lnwire.MilliSatoshi, chainHash *chainhash.Hash,
-	flags lnwire.FundingFlag) (*ChannelReservation, error) {
+	flags lnwire.FundingFlag,
+	tweaklessCommit bool) (*ChannelReservation, error) {
 
 	var (
 		ourBalance   lnwire.MilliSatoshi
@@ -140,7 +141,7 @@ func NewChannelReservation(capacity, localFundingAmt btcutil.Amount,
 
 	commitFee := commitFeePerKw.FeeForWeight(input.CommitWeight)
 	localFundingMSat := lnwire.NewMSatFromSatoshis(localFundingAmt)
-	// TODO(halseth): make method take remote funding amount direcly
+	// TODO(halseth): make method take remote funding amount directly
 	// instead of inferring it from capacity and local amt.
 	capacityMSat := lnwire.NewMSatFromSatoshis(capacity)
 	feeMSat := lnwire.NewMSatFromSatoshis(commitFee)
@@ -213,7 +214,11 @@ func NewChannelReservation(capacity, localFundingAmt btcutil.Amount,
 	// non-zero push amt (there's no pushing for dual funder), then this is
 	// a single-funder channel.
 	if ourBalance == 0 || theirBalance == 0 || pushMSat != 0 {
-		chanType = channeldb.SingleFunder
+		if tweaklessCommit {
+			chanType = channeldb.SingleFunderTweakless
+		} else {
+			chanType = channeldb.SingleFunder
+		}
 	} else {
 		// Otherwise, this is a dual funder channel, and no side is
 		// technically the "initiator"
diff --git a/lnwallet/wallet.go b/lnwallet/wallet.go
index c3ac26384..02321baf4 100644
--- a/lnwallet/wallet.go
+++ b/lnwallet/wallet.go
@@ -106,6 +106,10 @@ type InitFundingReserveMsg struct {
 	// output selected to fund the channel should satisfy.
 	MinConfs int32
 
+	// Tweakless indicates if the channel should use the new tweakless
+	// commitment format or not.
+	Tweakless bool
+
 	// err is a channel in which all errors will be sent across. Will be
 	// nil if this initial set is successful.
 	//
@@ -489,6 +493,7 @@ func (l *LightningWallet) handleFundingReserveRequest(req *InitFundingReserveMsg
 	reservation, err := NewChannelReservation(
 		capacity, localFundingAmt, req.CommitFeePerKw, l, id,
 		req.PushMSat, l.Cfg.NetParams.GenesisHash, req.Flags,
+		req.Tweakless,
 	)
 	if err != nil {
 		selected.unlockCoins()
@@ -655,12 +660,17 @@ func (l *LightningWallet) handleFundingCancelRequest(req *fundingReserveCancelMs
 func CreateCommitmentTxns(localBalance, remoteBalance btcutil.Amount,
 	ourChanCfg, theirChanCfg *channeldb.ChannelConfig,
 	localCommitPoint, remoteCommitPoint *btcec.PublicKey,
-	fundingTxIn wire.TxIn) (*wire.MsgTx, *wire.MsgTx, error) {
+	fundingTxIn wire.TxIn,
+	tweaklessCommit bool) (*wire.MsgTx, *wire.MsgTx, error) {
 
-	localCommitmentKeys := deriveCommitmentKeys(localCommitPoint, true,
-		ourChanCfg, theirChanCfg)
-	remoteCommitmentKeys := deriveCommitmentKeys(remoteCommitPoint, false,
-		ourChanCfg, theirChanCfg)
+	localCommitmentKeys := DeriveCommitmentKeys(
+		localCommitPoint, true, tweaklessCommit, ourChanCfg,
+		theirChanCfg,
+	)
+	remoteCommitmentKeys := DeriveCommitmentKeys(
+		remoteCommitPoint, false, tweaklessCommit, ourChanCfg,
+		theirChanCfg,
+	)
 
 	ourCommitTx, err := CreateCommitTx(fundingTxIn, localCommitmentKeys,
 		uint32(ourChanCfg.CsvDelay), localBalance, remoteBalance,
@@ -827,11 +837,13 @@ func (l *LightningWallet) handleContributionMsg(req *addContributionMsg) {
 	// With the funding tx complete, create both commitment transactions.
 	localBalance := pendingReservation.partialState.LocalCommitment.LocalBalance.ToSatoshis()
 	remoteBalance := pendingReservation.partialState.LocalCommitment.RemoteBalance.ToSatoshis()
+	tweaklessCommits := pendingReservation.partialState.ChanType.IsTweakless()
 	ourCommitTx, theirCommitTx, err := CreateCommitmentTxns(
 		localBalance, remoteBalance, ourContribution.ChannelConfig,
 		theirContribution.ChannelConfig,
 		ourContribution.FirstCommitmentPoint,
 		theirContribution.FirstCommitmentPoint, fundingTxIn,
+		tweaklessCommits,
 	)
 	if err != nil {
 		req.err <- err
@@ -842,7 +854,7 @@ func (l *LightningWallet) handleContributionMsg(req *addContributionMsg) {
 	// obfuscator then use it to encode the current state number within
 	// both commitment transactions.
 	var stateObfuscator [StateHintSize]byte
-	if chanState.ChanType == channeldb.SingleFunder {
+	if chanState.ChanType.IsSingleFunder() {
 		stateObfuscator = DeriveStateHintObfuscator(
 			ourContribution.PaymentBasePoint.PubKey,
 			theirContribution.PaymentBasePoint.PubKey,
@@ -1151,13 +1163,14 @@ func (l *LightningWallet) handleSingleFunderSigs(req *addSingleFunderSigsMsg) {
 	// remote node's commitment transactions.
 	localBalance := pendingReservation.partialState.LocalCommitment.LocalBalance.ToSatoshis()
 	remoteBalance := pendingReservation.partialState.LocalCommitment.RemoteBalance.ToSatoshis()
+	tweaklessCommits := pendingReservation.partialState.ChanType.IsTweakless()
 	ourCommitTx, theirCommitTx, err := CreateCommitmentTxns(
 		localBalance, remoteBalance,
 		pendingReservation.ourContribution.ChannelConfig,
 		pendingReservation.theirContribution.ChannelConfig,
 		pendingReservation.ourContribution.FirstCommitmentPoint,
 		pendingReservation.theirContribution.FirstCommitmentPoint,
-		*fundingTxIn,
+		*fundingTxIn, tweaklessCommits,
 	)
 	if err != nil {
 		req.err <- err
diff --git a/lnwire/features.go b/lnwire/features.go
index e86a69eec..c6e24998a 100644
--- a/lnwire/features.go
+++ b/lnwire/features.go
@@ -55,6 +55,16 @@ const (
 	// packet.
 	TLVOnionPayloadOptional FeatureBit = 9
 
+	// StaticRemoteKeyRequired is a required feature bit that signals that
+	// within one's commitment transaction, the key used for the remote
+	// party's non-delay output should not be tweaked.
+	StaticRemoteKeyRequired FeatureBit = 10
+
+	// StaticRemoteKeyOptional is an optional feature bit that signals that
+	// within one's commitment transaction, the key used for the remote
+	// party's non-delay output should not be tweaked.
+	StaticRemoteKeyOptional FeatureBit = 11
+
 	// maxAllowedSize is a maximum allowed size of feature vector.
 	//
 	// NOTE: Within the protocol, the maximum allowed message size is 65535
@@ -88,6 +98,8 @@ var LocalFeatures = map[FeatureBit]string{
 var GlobalFeatures = map[FeatureBit]string{
 	TLVOnionPayloadRequired: "tlv-onion",
 	TLVOnionPayloadOptional: "tlv-onion",
+	StaticRemoteKeyOptional: "static-remote-key",
+	StaticRemoteKeyRequired: "static-remote-key",
 }
 
 // RawFeatureVector represents a set of feature bits as defined in BOLT-09.  A
diff --git a/peer.go b/peer.go
index 7f2d9155c..c8f8ef27c 100644
--- a/peer.go
+++ b/peer.go
@@ -2410,6 +2410,24 @@ func (p *peer) handleInitMsg(msg *lnwire.Init) error {
 	return nil
 }
 
+// LocalGlobalFeatures returns the set of global features that has been
+// advertised by the local node. This allows sub-systems that use this
+// interface to gate their behavior off the set of negotiated feature bits.
+//
+// NOTE: Part of the lnpeer.Peer interface.
+func (p *peer) LocalGlobalFeatures() *lnwire.FeatureVector {
+	return p.server.globalFeatures
+}
+
+// RemoteGlobalFeatures returns the set of global features that has been
+// advertised by the remote node. This allows sub-systems that use this
+// interface to gate their behavior off the set of negotiated feature bits.
+//
+// NOTE: Part of the lnpeer.Peer interface.
+func (p *peer) RemoteGlobalFeatures() *lnwire.FeatureVector {
+	return p.remoteGlobalFeatures
+}
+
 // sendInitMsg sends init message to remote peer which contains our currently
 // supported local and global features.
 func (p *peer) sendInitMsg() error {
diff --git a/rpcserver.go b/rpcserver.go
index 42f1cbab9..0d8b90432 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -2684,6 +2684,7 @@ func createRPCOpenChannel(r *rpcServer, graph *channeldb.ChannelGraph,
 		ChanStatusFlags:       dbChannel.ChanStatus().String(),
 		LocalChanReserveSat:   int64(dbChannel.LocalChanCfg.ChanReserve),
 		RemoteChanReserveSat:  int64(dbChannel.RemoteChanCfg.ChanReserve),
+		StaticRemoteKey:       dbChannel.ChanType.IsTweakless(),
 	}
 
 	for i, htlc := range localCommit.Htlcs {
diff --git a/server.go b/server.go
index 05d8bed5b..e8f0618bc 100644
--- a/server.go
+++ b/server.go
@@ -324,6 +324,12 @@ func newServer(listenAddrs []net.Addr, chanDB *channeldb.DB,
 		globalFeatures.Set(lnwire.TLVOnionPayloadOptional)
 	}
 
+	// Similarly, we default to the new modern commitment format unless the
+	// legacy commitment config is set to true.
+	if !cfg.LegacyProtocol.LegacyCommitment() {
+		globalFeatures.Set(lnwire.StaticRemoteKeyOptional)
+	}
+
 	var serializedPubKey [33]byte
 	copy(serializedPubKey[:], privKey.PubKey().SerializeCompressed())
 
@@ -388,8 +394,9 @@ func newServer(listenAddrs []net.Addr, chanDB *channeldb.DB,
 		peerConnectedListeners:    make(map[string][]chan<- lnpeer.Peer),
 		peerDisconnectedListeners: make(map[string][]chan<- struct{}),
 
-		globalFeatures: lnwire.NewFeatureVector(globalFeatures,
-			lnwire.GlobalFeatures),
+		globalFeatures: lnwire.NewFeatureVector(
+			globalFeatures, lnwire.GlobalFeatures,
+		),
 		quit: make(chan struct{}),
 	}
 
diff --git a/sweep/txgenerator.go b/sweep/txgenerator.go
index 26a4503e7..a06dad963 100644
--- a/sweep/txgenerator.go
+++ b/sweep/txgenerator.go
@@ -259,6 +259,8 @@ func getInputWitnessSizeUpperBound(inp input.Input) (int, bool, error) {
 	switch inp.WitnessType() {
 
 	// Outputs on a remote commitment transaction that pay directly to us.
+	case input.CommitSpendNoDelayTweakless:
+		fallthrough
 	case input.WitnessKeyHash:
 		fallthrough
 	case input.CommitmentNoDelay:
diff --git a/watchtower/wtclient/backup_task.go b/watchtower/wtclient/backup_task.go
index 9f284b98a..abdabe2f9 100644
--- a/watchtower/wtclient/backup_task.go
+++ b/watchtower/wtclient/backup_task.go
@@ -54,7 +54,7 @@ type backupTask struct {
 // variables.
 func newBackupTask(chanID *lnwire.ChannelID,
 	breachInfo *lnwallet.BreachRetribution,
-	sweepPkScript []byte) *backupTask {
+	sweepPkScript []byte, isTweakless bool) *backupTask {
 
 	// Parse the non-dust outputs from the breach transaction,
 	// simultaneously computing the total amount contained in the inputs
@@ -85,12 +85,18 @@ func newBackupTask(chanID *lnwire.ChannelID,
 		totalAmt += breachInfo.RemoteOutputSignDesc.Output.Value
 	}
 	if breachInfo.LocalOutputSignDesc != nil {
+		witnessType := input.CommitmentNoDelay
+		if isTweakless {
+			witnessType = input.CommitSpendNoDelayTweakless
+		}
+
 		toRemoteInput = input.NewBaseInput(
 			&breachInfo.LocalOutpoint,
-			input.CommitmentNoDelay,
+			witnessType,
 			breachInfo.LocalOutputSignDesc,
 			0,
 		)
+
 		totalAmt += breachInfo.LocalOutputSignDesc.Output.Value
 	}
 
@@ -271,6 +277,8 @@ func (t *backupTask) craftSessionPayload(
 		case input.CommitmentRevoke:
 			copy(justiceKit.CommitToLocalSig[:], signature[:])
 
+		case input.CommitSpendNoDelayTweakless:
+			fallthrough
 		case input.CommitmentNoDelay:
 			copy(justiceKit.CommitToRemoteSig[:], signature[:])
 		}
diff --git a/watchtower/wtclient/client.go b/watchtower/wtclient/client.go
index 795f1798e..76aa2a4bc 100644
--- a/watchtower/wtclient/client.go
+++ b/watchtower/wtclient/client.go
@@ -90,8 +90,10 @@ type Client interface {
 	// state. If the method returns nil, the backup is guaranteed to be
 	// successful unless the client is force quit, or the justice
 	// transaction would create dust outputs when trying to abide by the
-	// negotiated policy.
-	BackupState(*lnwire.ChannelID, *lnwallet.BreachRetribution) error
+	// negotiated policy. If the channel we're trying to back up doesn't
+	// have a tweak for the remote party's output, then isTweakless should
+	// be true.
+	BackupState(*lnwire.ChannelID, *lnwallet.BreachRetribution, bool) error
 
 	// Start initializes the watchtower client, allowing it process requests
 	// to backup revoked channel states.
@@ -564,7 +566,7 @@ func (c *TowerClient) RegisterChannel(chanID lnwire.ChannelID) error {
 //  - breached outputs contain too little value to sweep at the target sweep fee
 //    rate.
 func (c *TowerClient) BackupState(chanID *lnwire.ChannelID,
-	breachInfo *lnwallet.BreachRetribution) error {
+	breachInfo *lnwallet.BreachRetribution, isTweakless bool) error {
 
 	// Retrieve the cached sweep pkscript used for this channel.
 	c.backupMu.Lock()
@@ -589,7 +591,9 @@ func (c *TowerClient) BackupState(chanID *lnwire.ChannelID,
 	c.chanCommitHeights[*chanID] = breachInfo.RevokedStateNum
 	c.backupMu.Unlock()
 
-	task := newBackupTask(chanID, breachInfo, summary.SweepPkScript)
+	task := newBackupTask(
+		chanID, breachInfo, summary.SweepPkScript, isTweakless,
+	)
 
 	return c.pipeline.QueueBackupTask(task)
 }


Test patch:
diff --git a/breacharbiter_test.go b/breacharbiter_test.go
index 9d95ea4f0..7f471ea2e 100644
--- a/breacharbiter_test.go
+++ b/breacharbiter_test.go
@@ -90,6 +90,11 @@ var (
 			0x2e, 0x9c, 0x51, 0x0f, 0x8e, 0xf5, 0x2b, 0xd0, 0x21,
 			0xa9, 0xa1, 0xf4, 0x80, 0x9d, 0x3b, 0x4d,
 		},
+		{0x02, 0xce, 0x0b, 0x14, 0xfb, 0x84, 0x2b, 0x1b,
+			0x2e, 0x9c, 0x51, 0x0f, 0x8e, 0xf5, 0x2b, 0xd0, 0x21,
+			0xa5, 0x49, 0xfd, 0xd6, 0x75, 0xc9, 0x80, 0x75, 0xf1,
+			0xa3, 0xa1, 0xf4, 0x80, 0x9d, 0x3b, 0x4d,
+		},
 	}
 
 	breachedOutputs = []breachedOutput{
@@ -137,6 +142,42 @@ var (
 			},
 			secondLevelWitnessScript: breachKeys[0],
 		},
+		{
+			amt:         btcutil.Amount(1e7),
+			outpoint:    breachOutPoints[0],
+			witnessType: input.CommitSpendNoDelayTweakless,
+			signDesc: input.SignDescriptor{
+				WitnessScript: []byte{
+					0x00, 0x14, 0xee, 0x91, 0x41, 0x7e,
+					0x85, 0x6c, 0xde, 0x10, 0xa2, 0x91,
+					0x1e, 0xdc, 0xbd, 0xbd, 0x69, 0xe2,
+					0xef, 0xb5, 0x71, 0x48,
+				},
+				Output: &wire.TxOut{
+					Value: 5000000000,
+					PkScript: []byte{
+						0x41, // OP_DATA_65
+						0x04, 0xd6, 0x4b, 0xdf, 0xd0,
+						0x9e, 0xb1, 0xc5, 0xfe, 0x29,
+						0x5a, 0xbd, 0xeb, 0x1d, 0xca,
+						0x42, 0x81, 0xbe, 0x98, 0x8e,
+						0x2d, 0xa0, 0xb6, 0xc1, 0xc6,
+						0xa5, 0x9d, 0xc2, 0x26, 0xc2,
+						0x86, 0x24, 0xe1, 0x81, 0x75,
+						0xe8, 0x51, 0xc9, 0x6b, 0x97,
+						0x3d, 0x81, 0xb0, 0x1c, 0xc3,
+						0x1f, 0x04, 0x78, 0x34, 0xbc,
+						0x06, 0xd6, 0xd6, 0xed, 0xf6,
+						0x20, 0xd1, 0x84, 0x24, 0x1a,
+						0x6a, 0xed, 0x8b, 0x63,
+						0xa6, // 65-byte signature
+						0xac, // OP_CHECKSIG
+					},
+				},
+				HashType: txscript.SigHashAll,
+			},
+			secondLevelWitnessScript: breachKeys[0],
+		},
 		{
 			amt:         btcutil.Amount(2e9),
 			outpoint:    breachOutPoints[1],
@@ -1339,7 +1380,8 @@ func testBreachSpends(t *testing.T, test breachTest) {
 
 	// Notify the breach arbiter about the breach.
 	retribution, err := lnwallet.NewBreachRetribution(
-		alice.State(), height, 1)
+		alice.State(), height, 1,
+	)
 	if err != nil {
 		t.Fatalf("unable to create breach retribution: %v", err)
 	}
@@ -1754,9 +1796,10 @@ func createInitChannels(revocationWindow int) (*lnwallet.LightningChannel, *lnwa
 	}
 	aliceCommitPoint := input.ComputeCommitmentPoint(aliceFirstRevoke[:])
 
-	aliceCommitTx, bobCommitTx, err := lnwallet.CreateCommitmentTxns(channelBal,
-		channelBal, &aliceCfg, &bobCfg, aliceCommitPoint, bobCommitPoint,
-		*fundingTxIn)
+	aliceCommitTx, bobCommitTx, err := lnwallet.CreateCommitmentTxns(
+		channelBal, channelBal, &aliceCfg, &bobCfg, aliceCommitPoint,
+		bobCommitPoint, *fundingTxIn, true,
+	)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -1822,7 +1865,7 @@ func createInitChannels(revocationWindow int) (*lnwallet.LightningChannel, *lnwa
 		IdentityPub:             aliceKeyPub,
 		FundingOutpoint:         *prevOut,
 		ShortChannelID:          shortChanID,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             true,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: bobCommitPoint,
@@ -1840,7 +1883,7 @@ func createInitChannels(revocationWindow int) (*lnwallet.LightningChannel, *lnwa
 		IdentityPub:             bobKeyPub,
 		FundingOutpoint:         *prevOut,
 		ShortChannelID:          shortChanID,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             false,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: aliceCommitPoint,
diff --git a/chanbackup/single_test.go b/chanbackup/single_test.go
index 41f7bca8a..ba56ece76 100644
--- a/chanbackup/single_test.go
+++ b/chanbackup/single_test.go
@@ -124,8 +124,14 @@ func genRandomOpenChannelShell() (*channeldb.OpenChannel, error) {
 		isInitiator = true
 	}
 
+	chanType := channeldb.SingleFunder
+	if rand.Int63()%2 == 0 {
+		chanType = channeldb.SingleFunderTweakless
+	}
+
 	return &channeldb.OpenChannel{
 		ChainHash:       chainHash,
+		ChanType:        chanType,
 		IsInitiator:     isInitiator,
 		FundingOutpoint: chanPoint,
 		ShortChannelID: lnwire.NewShortChanIDFromInt(
@@ -223,6 +229,12 @@ func TestSinglePackUnpack(t *testing.T) {
 			valid:   true,
 		},
 
+		// The new tweakless version, should pack/unpack with no problem.
+		{
+			version: TweaklessCommitVersion,
+			valid:   true,
+		},
+
 		// A non-default version, atm this should result in a failure.
 		{
 			version: 99,
@@ -274,7 +286,7 @@ func TestSinglePackUnpack(t *testing.T) {
 			}
 
 			rawBytes := rawSingle.Bytes()
-			rawBytes[0] ^= 1
+			rawBytes[0] ^= 5
 
 			newReader := bytes.NewReader(rawBytes)
 			err = unpackedSingle.Deserialize(newReader)
diff --git a/contractcourt/chain_arbitrator_test.go b/contractcourt/chain_arbitrator_test.go
index 4ff3d0644..38ea2a35b 100644
--- a/contractcourt/chain_arbitrator_test.go
+++ b/contractcourt/chain_arbitrator_test.go
@@ -34,7 +34,7 @@ func TestChainArbitratorRepublishCommitment(t *testing.T) {
 	const numChans = 10
 	var channels []*channeldb.OpenChannel
 	for i := 0; i < numChans; i++ {
-		lChannel, _, cleanup, err := lnwallet.CreateTestChannels()
+		lChannel, _, cleanup, err := lnwallet.CreateTestChannels(true)
 		if err != nil {
 			t.Fatal(err)
 		}
diff --git a/contractcourt/chain_watcher_test.go b/contractcourt/chain_watcher_test.go
index 2a511b653..f0e07628b 100644
--- a/contractcourt/chain_watcher_test.go
+++ b/contractcourt/chain_watcher_test.go
@@ -62,7 +62,7 @@ func TestChainWatcherRemoteUnilateralClose(t *testing.T) {
 
 	// First, we'll create two channels which already have established a
 	// commitment contract between themselves.
-	aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -149,7 +149,7 @@ func TestChainWatcherRemoteUnilateralClosePendingCommit(t *testing.T) {
 
 	// First, we'll create two channels which already have established a
 	// commitment contract between themselves.
-	aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -272,7 +272,9 @@ func TestChainWatcherDataLossProtect(t *testing.T) {
 	dlpScenario := func(t *testing.T, testCase dlpTestCase) bool {
 		// First, we'll create two channels which already have
 		// established a commitment contract between themselves.
-		aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels()
+		aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels(
+			false,
+		)
 		if err != nil {
 			t.Fatalf("unable to create test channels: %v", err)
 		}
@@ -430,7 +432,7 @@ func TestChainWatcherDataLossProtect(t *testing.T) {
 func TestChainWatcherLocalForceCloseDetect(t *testing.T) {
 	t.Parallel()
 
-	// localForceCloseScenario is the primary test we'll use to execut eout
+	// localForceCloseScenario is the primary test we'll use to execute our
 	// table driven tests. We'll assert that for any number of state
 	// updates, and if the commitment transaction has our output or not,
 	// we're able to properly detect a local force close.
@@ -439,7 +441,9 @@ func TestChainWatcherLocalForceCloseDetect(t *testing.T) {
 
 		// First, we'll create two channels which already have
 		// established a commitment contract between themselves.
-		aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels()
+		aliceChannel, bobChannel, cleanUp, err := lnwallet.CreateTestChannels(
+			false,
+		)
 		if err != nil {
 			t.Fatalf("unable to create test channels: %v", err)
 		}
diff --git a/discovery/mock_test.go b/discovery/mock_test.go
index 84ba86363..57fc319a5 100644
--- a/discovery/mock_test.go
+++ b/discovery/mock_test.go
@@ -56,6 +56,12 @@ func (p *mockPeer) Address() net.Addr { return nil }
 func (p *mockPeer) QuitSignal() <-chan struct{} {
 	return p.quit
 }
+func (p *mockPeer) LocalGlobalFeatures() *lnwire.FeatureVector {
+	return nil
+}
+func (p *mockPeer) RemoteGlobalFeatures() *lnwire.FeatureVector {
+	return nil
+}
 
 // mockMessageStore is an in-memory implementation of the MessageStore interface
 // used for the gossiper's unit tests.
diff --git a/fundingmanager_test.go b/fundingmanager_test.go
index 05c0f41c3..759f783b0 100644
--- a/fundingmanager_test.go
+++ b/fundingmanager_test.go
@@ -183,6 +183,14 @@ func (n *testNode) QuitSignal() <-chan struct{} {
 	return n.shutdownChannel
 }
 
+func (n *testNode) LocalGlobalFeatures() *lnwire.FeatureVector {
+	return lnwire.NewFeatureVector(nil, nil)
+}
+
+func (n *testNode) RemoteGlobalFeatures() *lnwire.FeatureVector {
+	return lnwire.NewFeatureVector(nil, nil)
+}
+
 func (n *testNode) AddNewChannel(channel *channeldb.OpenChannel,
 	quit <-chan struct{}) error {
 
diff --git a/htlcswitch/decayedlog_test.go b/htlcswitch/decayedlog_test.go
index 2afcdda40..6cf97c50b 100644
--- a/htlcswitch/decayedlog_test.go
+++ b/htlcswitch/decayedlog_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/lightningnetwork/lightning-onion"
+	sphinx "github.com/lightningnetwork/lightning-onion"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 )
 
diff --git a/htlcswitch/link_test.go b/htlcswitch/link_test.go
index b7cf3ed1b..b21ad5c2a 100644
--- a/htlcswitch/link_test.go
+++ b/htlcswitch/link_test.go
@@ -1651,6 +1651,12 @@ func (m *mockPeer) IdentityKey() *btcec.PublicKey {
 func (m *mockPeer) Address() net.Addr {
 	return nil
 }
+func (m *mockPeer) LocalGlobalFeatures() *lnwire.FeatureVector {
+	return nil
+}
+func (m *mockPeer) RemoteGlobalFeatures() *lnwire.FeatureVector {
+	return nil
+}
 
 func newSingleLinkTestHarness(chanAmt, chanReserve btcutil.Amount) (
 	ChannelLink, *lnwallet.LightningChannel, chan time.Time, func() error,
diff --git a/htlcswitch/test_utils.go b/htlcswitch/test_utils.go
index a908afb3b..f2f86b752 100644
--- a/htlcswitch/test_utils.go
+++ b/htlcswitch/test_utils.go
@@ -257,9 +257,10 @@ func createTestChannel(alicePrivKey, bobPrivKey []byte,
 	}
 	aliceCommitPoint := input.ComputeCommitmentPoint(aliceFirstRevoke[:])
 
-	aliceCommitTx, bobCommitTx, err := lnwallet.CreateCommitmentTxns(aliceAmount,
-		bobAmount, &aliceCfg, &bobCfg, aliceCommitPoint, bobCommitPoint,
-		*fundingTxIn)
+	aliceCommitTx, bobCommitTx, err := lnwallet.CreateCommitmentTxns(
+		aliceAmount, bobAmount, &aliceCfg, &bobCfg, aliceCommitPoint,
+		bobCommitPoint, *fundingTxIn, true,
+	)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -326,7 +327,7 @@ func createTestChannel(alicePrivKey, bobPrivKey []byte,
 		RemoteChanCfg:           bobCfg,
 		IdentityPub:             aliceKeyPub,
 		FundingOutpoint:         *prevOut,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             true,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: bobCommitPoint,
@@ -345,7 +346,7 @@ func createTestChannel(alicePrivKey, bobPrivKey []byte,
 		RemoteChanCfg:           aliceCfg,
 		IdentityPub:             bobKeyPub,
 		FundingOutpoint:         *prevOut,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             false,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: aliceCommitPoint,
diff --git a/lntest/itest/lnd_test.go b/lntest/itest/lnd_test.go
index 6c26b2a0f..e7cdfcd82 100644
--- a/lntest/itest/lnd_test.go
+++ b/lntest/itest/lnd_test.go
@@ -927,13 +927,13 @@ func testOnchainFundRecovery(net *lntest.NetworkHarness, t *harnessTest) {
 	restoreCheckBalance(6*btcutil.SatoshiPerBitcoin, 6, 20, nil)
 }
 
-// testBasicChannelFunding performs a test exercising expected behavior from a
-// basic funding workflow. The test creates a new channel between Alice and
-// Bob, then immediately closes the channel after asserting some expected post
-// conditions. Finally, the chain itself is checked to ensure the closing
-// transaction was mined.
-func testBasicChannelFunding(net *lntest.NetworkHarness, t *harnessTest) {
-	ctxb := context.Background()
+// basicChannelFundingTest is a sub-test of the main testBasicChannelFunding
+// test. Given two nodes: Alice and Bob, it'll assert proper channel creation,
+// then return a function closure that should be called to assert proper
+// channel closure.
+func basicChannelFundingTest(t *harnessTest, net *lntest.NetworkHarness,
+	alice *lntest.HarnessNode,
+	bob *lntest.HarnessNode) (*lnrpc.Channel, *lnrpc.Channel, func(), error) {
 
 	chanAmt := lnd.MaxBtcFundingAmount
 	pushAmt := btcutil.Amount(100000)
@@ -944,9 +944,10 @@ func testBasicChannelFunding(net *lntest.NetworkHarness, t *harnessTest) {
 	// open or an error occurs in the funding process. A series of
 	// assertions will be executed to ensure the funding process completed
 	// successfully.
+	ctxb := context.Background()
 	ctxt, _ := context.WithTimeout(ctxb, channelOpenTimeout)
 	chanPoint := openChannelAndAssert(
-		ctxt, t, net, net.Alice, net.Bob,
+		ctxt, t, net, alice, bob,
 		lntest.OpenChannelParams{
 			Amt:     chanAmt,
 			PushAmt: pushAmt,
@@ -954,42 +955,160 @@ func testBasicChannelFunding(net *lntest.NetworkHarness, t *harnessTest) {
 	)
 
 	ctxt, _ = context.WithTimeout(ctxb, defaultTimeout)
-	err := net.Alice.WaitForNetworkChannelOpen(ctxt, chanPoint)
+	err := alice.WaitForNetworkChannelOpen(ctxt, chanPoint)
 	if err != nil {
-		t.Fatalf("alice didn't report channel: %v", err)
+		return nil, nil, nil, fmt.Errorf("alice didn't report "+
+			"channel: %v", err)
 	}
-	err = net.Bob.WaitForNetworkChannelOpen(ctxt, chanPoint)
+	err = bob.WaitForNetworkChannelOpen(ctxt, chanPoint)
 	if err != nil {
-		t.Fatalf("bob didn't report channel: %v", err)
+		return nil, nil, nil, fmt.Errorf("bob didn't report "+
+			"channel: %v", err)
 	}
 
 	// With the channel open, ensure that the amount specified above has
 	// properly been pushed to Bob.
 	balReq := &lnrpc.ChannelBalanceRequest{}
 	ctxt, _ = context.WithTimeout(ctxb, defaultTimeout)
-	aliceBal, err := net.Alice.ChannelBalance(ctxt, balReq)
+	aliceBal, err := alice.ChannelBalance(ctxt, balReq)
 	if err != nil {
-		t.Fatalf("unable to get alice's balance: %v", err)
+		return nil, nil, nil, fmt.Errorf("unable to get alice's "+
+			"balance: %v", err)
 	}
 	ctxt, _ = context.WithTimeout(ctxb, defaultTimeout)
-	bobBal, err := net.Bob.ChannelBalance(ctxt, balReq)
+	bobBal, err := bob.ChannelBalance(ctxt, balReq)
 	if err != nil {
-		t.Fatalf("unable to get bobs's balance: %v", err)
+		return nil, nil, nil, fmt.Errorf("unable to get bobs's "+
+			"balance: %v", err)
 	}
 	if aliceBal.Balance != int64(chanAmt-pushAmt-calcStaticFee(0)) {
-		t.Fatalf("alice's balance is incorrect: expected %v got %v",
+		return nil, nil, nil, fmt.Errorf("alice's balance is "+
+			"incorrect: expected %v got %v",
 			chanAmt-pushAmt-calcStaticFee(0), aliceBal)
 	}
 	if bobBal.Balance != int64(pushAmt) {
-		t.Fatalf("bob's balance is incorrect: expected %v got %v",
-			pushAmt, bobBal.Balance)
+		return nil, nil, nil, fmt.Errorf("bob's balance is incorrect: "+
+			"expected %v got %v", pushAmt, bobBal.Balance)
 	}
 
-	// Finally, immediately close the channel. This function will also
-	// block until the channel is closed and will additionally assert the
-	// relevant channel closing post conditions.
-	ctxt, _ = context.WithTimeout(ctxb, channelCloseTimeout)
-	closeChannelAndAssert(ctxt, t, net, net.Alice, chanPoint, false)
+	req := &lnrpc.ListChannelsRequest{}
+	aliceChannel, err := alice.ListChannels(context.Background(), req)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("unable to obtain chan: %v", err)
+	}
+
+	bobChannel, err := bob.ListChannels(context.Background(), req)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("unable to obtain chan: %v", err)
+	}
+
+	closeChan := func() {
+		// Finally, immediately close the channel. This function will
+		// also block until the channel is closed and will additionally
+		// assert the relevant channel closing post conditions.
+		ctxt, _ = context.WithTimeout(ctxb, channelCloseTimeout)
+		closeChannelAndAssert(ctxt, t, net, alice, chanPoint, false)
+	}
+
+	return aliceChannel.Channels[0], bobChannel.Channels[0], closeChan, nil
+}
+
+// testBasicChannelFunding performs a test exercising expected behavior from a
+// basic funding workflow. The test creates a new channel between Alice and
+// Bob, then immediately closes the channel after asserting some expected post
+// conditions. Finally, the chain itself is checked to ensure the closing
+// transaction was mined.
+func testBasicChannelFunding(net *lntest.NetworkHarness, t *harnessTest) {
+
+	ctxb := context.Background()
+
+test:
+	// We'll test all possible combinations of the feature bit presence
+	// that both nodes can signal for this new channel type. We'll make a
+	// new Carol+Dave for each test instance as well.
+	for _, carolTweakless := range []bool{true, false} {
+		for _, daveTweakless := range []bool{true, false} {
+			// Based on the current tweak variable for Carol, we'll
+			// preferentially signal the legacy commitment format.
+			// We do the same for Dave shortly below.
+			var carolArgs []string
+			if !carolTweakless {
+				carolArgs = []string{"--legacyprotocol.committweak"}
+			}
+			carol, err := net.NewNode("Carol", carolArgs)
+			if err != nil {
+				t.Fatalf("unable to create new node: %v", err)
+			}
+
+			// Each time, we'll send Carol a new set of coins in
+			// order to fund the channel.
+			ctxt, _ := context.WithTimeout(ctxb, defaultTimeout)
+			err = net.SendCoins(ctxt, btcutil.SatoshiPerBitcoin, carol)
+			if err != nil {
+				t.Fatalf("unable to send coins to carol: %v", err)
+			}
+
+			var daveArgs []string
+			if !daveTweakless {
+				daveArgs = []string{"--legacyprotocol.committweak"}
+			}
+			dave, err := net.NewNode("Dave", daveArgs)
+			if err != nil {
+				t.Fatalf("unable to create new node: %v", err)
+			}
+
+			// Before we start the test, we'll ensure both sides
+			// are connected to the funding flow can properly be
+			// executed.
+			ctxt, _ = context.WithTimeout(ctxb, defaultTimeout)
+			err = net.EnsureConnected(ctxt, carol, dave)
+			if err != nil {
+				t.Fatalf("unable to connect peers: %v", err)
+			}
+
+			testName := fmt.Sprintf("carol_tweak=%v,dave_tweak=%v",
+				carolTweakless, daveTweakless)
+
+			ht := t
+			success := t.t.Run(testName, func(t *testing.T) {
+				carolChannel, daveChannel, closeChan, err := basicChannelFundingTest(
+					ht, net, carol, dave,
+				)
+				if err != nil {
+					t.Fatalf("failed funding flow: %v", err)
+				}
+
+				tweaklessSignalled := carolTweakless && daveTweakless
+				tweaklessChans := (carolChannel.StaticRemoteKey &&
+					daveChannel.StaticRemoteKey)
+				switch {
+				// If both sides signalled a tweakless channel, and the
+				// resulting channel doesn't reflect this, then this
+				// is a failed case.
+				case tweaklessSignalled && !tweaklessChans:
+					t.Fatalf("expected tweakless channnel, got " +
+						"non-tweaked channel")
+
+				// If both sides didn't signal a tweakless
+				// channel, and the resulting channel is
+				// tweakless, and this is also a failed case.
+				case !tweaklessSignalled && tweaklessChans:
+					t.Fatalf("expected non-tweaked channel, got " +
+						"tweakless channel")
+				}
+
+				// As we've concluded this sub-test case we'll
+				// now close out the channel for both sides.
+				closeChan()
+			})
+			if !success {
+				break test
+			}
+
+			shutdownAndAssert(net, t, carol)
+			shutdownAndAssert(net, t, dave)
+		}
+	}
 }
 
 // testUnconfirmedChannelFunding tests that our unconfirmed change outputs can
diff --git a/lnwallet/channel_test.go b/lnwallet/channel_test.go
index ca686d342..91e5e17d0 100644
--- a/lnwallet/channel_test.go
+++ b/lnwallet/channel_test.go
@@ -52,22 +52,13 @@ func assertOutputExistsByValue(t *testing.T, commitTx *wire.MsgTx,
 		spew.Sdump(commitTx))
 }
 
-// TestSimpleAddSettleWorkflow tests a simple channel scenario wherein the
-// local node (Alice in this case) creates a new outgoing HTLC to bob, commits
-// this change, then bob immediately commits a settlement of the HTLC after the
-// initial add is fully committed in both commit chains.
-//
-// TODO(roasbeef): write higher level framework to exercise various states of
-// the state machine
-//  * DSL language perhaps?
-//  * constructed via input/output files
-func TestSimpleAddSettleWorkflow(t *testing.T) {
-	t.Parallel()
-
+// testAddSettleWorkflow tests a simple channel scenario where Alice and Bob
+// add, the settle an HTLC between themselves.
+func testAddSettleWorkflow(t *testing.T, tweakless bool) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(tweakless)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -295,10 +286,10 @@ func TestSimpleAddSettleWorkflow(t *testing.T) {
 			"instead forwarding: %v", len(fwdPkg.SettleFails))
 	}
 
-	// At this point, Bob should have 6 BTC settled, with Alice still having
-	// 4 BTC. Alice's channel should show 1 BTC sent and Bob's channel
-	// should show 1 BTC received. They should also be at commitment height
-	// two, with the revocation window extended by 1 (5).
+	// At this point, Bob should have 6 BTC settled, with Alice still
+	// having 4 BTC. Alice's channel should show 1 BTC sent and Bob's
+	// channel should show 1 BTC received. They should also be at
+	// commitment height two, with the revocation window extended by 1 (5).
 	mSatTransferred := lnwire.NewMSatFromSatoshis(btcutil.SatoshiPerBitcoin)
 	if aliceChannel.channelState.TotalMSatSent != mSatTransferred {
 		t.Fatalf("alice satoshis sent incorrect %v vs %v expected",
@@ -348,6 +339,26 @@ func TestSimpleAddSettleWorkflow(t *testing.T) {
 	}
 }
 
+// TestSimpleAddSettleWorkflow tests a simple channel scenario wherein the
+// local node (Alice in this case) creates a new outgoing HTLC to bob, commits
+// this change, then bob immediately commits a settlement of the HTLC after the
+// initial add is fully committed in both commit chains.
+//
+// TODO(roasbeef): write higher level framework to exercise various states of
+// the state machine
+//  * DSL language perhaps?
+//  * constructed via input/output files
+func TestSimpleAddSettleWorkflow(t *testing.T) {
+	t.Parallel()
+
+	for _, tweakless := range []bool{true, false} {
+		tweakless := tweakless
+		t.Run(fmt.Sprintf("tweakless=%v", tweakless), func(t *testing.T) {
+			testAddSettleWorkflow(t, tweakless)
+		})
+	}
+}
+
 // TestCheckCommitTxSize checks that estimation size of commitment
 // transaction with some degree of error corresponds to the actual size.
 func TestCheckCommitTxSize(t *testing.T) {
@@ -377,7 +388,7 @@ func TestCheckCommitTxSize(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -436,7 +447,7 @@ func TestCooperativeChannelClosure(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -473,7 +484,8 @@ func TestCooperativeChannelClosure(t *testing.T) {
 	// transaction is well formed, and the signatures verify.
 	aliceCloseTx, _, err := bobChannel.CompleteCooperativeClose(
 		bobCloseSig, aliceCloseSig, bobDeliveryScript,
-		aliceDeliveryScript, bobFee)
+		aliceDeliveryScript, bobFee,
+	)
 	if err != nil {
 		t.Fatalf("unable to complete alice cooperative close: %v", err)
 	}
@@ -481,7 +493,8 @@ func TestCooperativeChannelClosure(t *testing.T) {
 
 	bobCloseTx, _, err := aliceChannel.CompleteCooperativeClose(
 		aliceCloseSig, bobCloseSig, aliceDeliveryScript,
-		bobDeliveryScript, aliceFee)
+		bobDeliveryScript, aliceFee,
+	)
 	if err != nil {
 		t.Fatalf("unable to complete bob cooperative close: %v", err)
 	}
@@ -503,7 +516,7 @@ func TestForceClose(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -787,7 +800,7 @@ func TestForceCloseDustOutput(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -905,7 +918,7 @@ func TestDustHTLCFees(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -982,7 +995,7 @@ func TestHTLCDustLimit(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -1067,7 +1080,7 @@ func TestHTLCSigNumber(t *testing.T) {
 		// Create a test channel funded evenly with Alice having 5 BTC,
 		// and Bob having 5 BTC. Alice's dustlimit is 200 sat, while
 		// Bob has 1300 sat.
-		aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+		aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 		if err != nil {
 			t.Fatalf("unable to create test channels: %v", err)
 		}
@@ -1237,7 +1250,7 @@ func TestChannelBalanceDustLimit(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -1305,7 +1318,7 @@ func TestStateUpdatePersistence(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -1353,7 +1366,7 @@ func TestStateUpdatePersistence(t *testing.T) {
 	}
 
 	// Also add a fee update to the update logs.
-	fee := SatPerKWeight(111)
+	fee := SatPerKWeight(333)
 	if err := aliceChannel.UpdateFee(fee); err != nil {
 		t.Fatalf("unable to send fee update")
 	}
@@ -1646,7 +1659,7 @@ func TestCancelHTLC(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -1760,7 +1773,7 @@ func TestCooperativeCloseDustAdherence(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -1921,7 +1934,7 @@ func TestCooperativeCloseDustAdherence(t *testing.T) {
 func TestUpdateFeeAdjustments(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -1959,7 +1972,7 @@ func TestUpdateFeeAdjustments(t *testing.T) {
 	// Finally, we'll attempt to adjust the fee down and use a fee which is
 	// smaller than the initial base fee rate. The fee application and
 	// state transition should proceed without issue.
-	newFee = SatPerKWeight(baseFeeRate / 100)
+	newFee = SatPerKWeight(baseFeeRate / 10)
 	if err := aliceChannel.UpdateFee(newFee); err != nil {
 		t.Fatalf("unable to alice update fee: %v", err)
 	}
@@ -1976,7 +1989,7 @@ func TestUpdateFeeAdjustments(t *testing.T) {
 func TestUpdateFeeFail(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -1984,7 +1997,9 @@ func TestUpdateFeeFail(t *testing.T) {
 
 	// Bob receives the update, that will apply to his commitment
 	// transaction.
-	bobChannel.ReceiveUpdateFee(111)
+	if err := bobChannel.ReceiveUpdateFee(333); err != nil {
+		t.Fatalf("unable to apply fee update: %v", err)
+	}
 
 	// Alice sends signature for commitment that does not cover any fee
 	// update.
@@ -2008,7 +2023,7 @@ func TestUpdateFeeFail(t *testing.T) {
 func TestUpdateFeeConcurrentSig(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -2033,7 +2048,7 @@ func TestUpdateFeeConcurrentSig(t *testing.T) {
 	}
 
 	// Simulate Alice sending update fee message to bob.
-	fee := SatPerKWeight(111)
+	fee := SatPerKWeight(333)
 	if err := aliceChannel.UpdateFee(fee); err != nil {
 		t.Fatalf("unable to send fee update")
 	}
@@ -2094,7 +2109,7 @@ func TestUpdateFeeSenderCommits(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -2119,7 +2134,7 @@ func TestUpdateFeeSenderCommits(t *testing.T) {
 	}
 
 	// Simulate Alice sending update fee message to bob.
-	fee := SatPerKWeight(111)
+	fee := SatPerKWeight(333)
 	aliceChannel.UpdateFee(fee)
 	bobChannel.ReceiveUpdateFee(fee)
 
@@ -2208,7 +2223,7 @@ func TestUpdateFeeReceiverCommits(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -2233,7 +2248,7 @@ func TestUpdateFeeReceiverCommits(t *testing.T) {
 	}
 
 	// Simulate Alice sending update fee message to bob
-	fee := SatPerKWeight(111)
+	fee := SatPerKWeight(333)
 	aliceChannel.UpdateFee(fee)
 	bobChannel.ReceiveUpdateFee(fee)
 
@@ -2349,7 +2364,7 @@ func TestUpdateFeeReceiverSendsUpdate(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -2357,7 +2372,7 @@ func TestUpdateFeeReceiverSendsUpdate(t *testing.T) {
 
 	// Since Alice is the channel initiator, she should fail when receiving
 	// fee update
-	fee := SatPerKWeight(111)
+	fee := SatPerKWeight(333)
 	err = aliceChannel.ReceiveUpdateFee(fee)
 	if err == nil {
 		t.Fatalf("expected alice to fail receiving fee update")
@@ -2378,15 +2393,15 @@ func TestUpdateFeeMultipleUpdates(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
 	defer cleanUp()
 
 	// Simulate Alice sending update fee message to bob.
-	fee1 := SatPerKWeight(111)
-	fee2 := SatPerKWeight(222)
+	fee1 := SatPerKWeight(333)
+	fee2 := SatPerKWeight(333)
 	fee := SatPerKWeight(333)
 	aliceChannel.UpdateFee(fee1)
 	aliceChannel.UpdateFee(fee2)
@@ -2490,7 +2505,7 @@ func TestAddHTLCNegativeBalance(t *testing.T) {
 
 	// We'll kick off the test by creating our channels which both are
 	// loaded with 5 BTC each.
-	aliceChannel, _, cleanUp, err := CreateTestChannels()
+	aliceChannel, _, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -2571,7 +2586,7 @@ func TestChanSyncFullySynced(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -2691,7 +2706,7 @@ func TestChanSyncOweCommitment(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -3005,7 +3020,7 @@ func TestChanSyncOweRevocation(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -3195,7 +3210,7 @@ func TestChanSyncOweRevocationAndCommit(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -3364,7 +3379,7 @@ func TestChanSyncOweRevocationAndCommitForceTransition(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -3593,7 +3608,7 @@ func TestChanSyncFailure(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(false)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -3846,7 +3861,7 @@ func TestFeeUpdateRejectInsaneFee(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, _, cleanUp, err := CreateTestChannels()
+	aliceChannel, _, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -3872,7 +3887,7 @@ func TestChannelRetransmissionFeeUpdate(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4055,7 +4070,7 @@ func TestFeeUpdateOldDiskFormat(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4274,7 +4289,7 @@ func TestChanSyncUnableToSync(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(false)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4311,7 +4326,7 @@ func TestChanSyncInvalidLastSecret(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(false)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4401,7 +4416,7 @@ func TestChanAvailableBandwidth(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4524,7 +4539,7 @@ func TestSignCommitmentFailNotLockedIn(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, _, cleanUp, err := CreateTestChannels()
+	aliceChannel, _, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4549,7 +4564,7 @@ func TestLockedInHtlcForwardingSkipAfterRestart(t *testing.T) {
 	t.Parallel()
 
 	// First, we'll make a channel between Alice and Bob.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4863,7 +4878,7 @@ func TestInvalidCommitSigError(t *testing.T) {
 	t.Parallel()
 
 	// First, we'll make a channel between Alice and Bob.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -4910,7 +4925,7 @@ func TestChannelUnilateralCloseHtlcResolution(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -5068,7 +5083,9 @@ func TestChannelUnilateralClosePendingCommit(t *testing.T) {
 	// Create a test channel which will be used for the duration of this
 	// unittest. The channel will be funded evenly with Alice having 5 BTC,
 	// and Bob having 5 BTC.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(
+		false,
+	)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -5166,7 +5183,7 @@ func TestChannelUnilateralClosePendingCommit(t *testing.T) {
 	})
 	aliceSignDesc.SigHashes = txscript.NewTxSigHashes(sweepTx)
 	sweepTx.TxIn[0].Witness, err = input.CommitSpendNoDelay(
-		aliceChannel.Signer, &aliceSignDesc, sweepTx,
+		aliceChannel.Signer, &aliceSignDesc, sweepTx, false,
 	)
 	if err != nil {
 		t.Fatalf("unable to generate sweep witness: %v", err)
@@ -5175,9 +5192,9 @@ func TestChannelUnilateralClosePendingCommit(t *testing.T) {
 	// If we validate the signature on the new sweep transaction, it should
 	// be fully valid.
 	vm, err := txscript.NewEngine(
-		aliceSignDesc.Output.PkScript,
-		sweepTx, 0, txscript.StandardVerifyFlags, nil,
-		nil, aliceSignDesc.Output.Value,
+		aliceSignDesc.Output.PkScript, sweepTx, 0,
+		txscript.StandardVerifyFlags, nil, nil,
+		aliceSignDesc.Output.Value,
 	)
 	if err != nil {
 		t.Fatalf("unable to create engine: %v", err)
@@ -5194,7 +5211,7 @@ func TestDesyncHTLCs(t *testing.T) {
 
 	// We'll kick off the test by creating our channels which both are
 	// loaded with 5 BTC each.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -5261,7 +5278,7 @@ func TestMaxAcceptedHTLCs(t *testing.T) {
 
 	// We'll kick off the test by creating our channels which both are
 	// loaded with 5 BTC each.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -5322,7 +5339,7 @@ func TestMaxPendingAmount(t *testing.T) {
 
 	// We'll kick off the test by creating our channels which both are
 	// loaded with 5 BTC each.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -5410,7 +5427,9 @@ func TestChanReserve(t *testing.T) {
 	setupChannels := func() (*LightningChannel, *LightningChannel, func()) {
 		// We'll kick off the test by creating our channels which both
 		// are loaded with 5 BTC each.
-		aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+		aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(
+			true,
+		)
 		if err != nil {
 			t.Fatalf("unable to create test channels: %v", err)
 		}
@@ -5626,7 +5645,7 @@ func TestMinHTLC(t *testing.T) {
 
 	// We'll kick off the test by creating our channels which both are
 	// loaded with 5 BTC each.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -5683,7 +5702,7 @@ func TestNewBreachRetributionSkipsDustHtlcs(t *testing.T) {
 
 	// We'll kick off the test by creating our channels which both are
 	// loaded with 5 BTC each.
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -5855,7 +5874,7 @@ func compareLogs(a, b *updateLog) error {
 func TestChannelRestoreUpdateLogs(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -6024,7 +6043,7 @@ func restoreAndAssert(t *testing.T, channel *LightningChannel, numAddsLocal,
 func TestChannelRestoreUpdateLogsFailedHTLC(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -6145,7 +6164,7 @@ func TestChannelRestoreUpdateLogsFailedHTLC(t *testing.T) {
 func TestDuplicateFailRejection(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -6223,7 +6242,7 @@ func TestDuplicateFailRejection(t *testing.T) {
 func TestDuplicateSettleRejection(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -6304,7 +6323,7 @@ func TestDuplicateSettleRejection(t *testing.T) {
 func TestChannelRestoreCommitHeight(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(true)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -6491,7 +6510,7 @@ func TestChannelRestoreCommitHeight(t *testing.T) {
 func TestForceCloseFailLocalDataLoss(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, _, cleanUp, err := CreateTestChannels()
+	aliceChannel, _, cleanUp, err := CreateTestChannels(false)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
@@ -6522,7 +6541,7 @@ func TestForceCloseFailLocalDataLoss(t *testing.T) {
 func TestForceCloseBorkedState(t *testing.T) {
 	t.Parallel()
 
-	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels()
+	aliceChannel, bobChannel, cleanUp, err := CreateTestChannels(false)
 	if err != nil {
 		t.Fatalf("unable to create test channels: %v", err)
 	}
diff --git a/lnwallet/interface_test.go b/lnwallet/interface_test.go
index deda71e71..16bb88e00 100644
--- a/lnwallet/interface_test.go
+++ b/lnwallet/interface_test.go
@@ -698,7 +698,7 @@ func testCancelNonExistentReservation(miner *rpctest.Harness,
 	// Create our own reservation, give it some ID.
 	res, err := lnwallet.NewChannelReservation(
 		10000, 10000, feePerKw, alice, 22, 10, &testHdSeed,
-		lnwire.FFAnnounceChannel,
+		lnwire.FFAnnounceChannel, true,
 	)
 	if err != nil {
 		t.Fatalf("unable to create res: %v", err)
@@ -736,6 +736,7 @@ func testReservationInitiatorBalanceBelowDustCancel(miner *rpctest.Harness,
 		FundingFeePerKw:  1000,
 		PushMSat:         0,
 		Flags:            lnwire.FFAnnounceChannel,
+		Tweakless:        true,
 	}
 	_, err = alice.InitChannelReservation(req)
 	switch {
@@ -790,7 +791,7 @@ func assertContributionInitPopulated(t *testing.T, c *lnwallet.ChannelContributi
 }
 
 func testSingleFunderReservationWorkflow(miner *rpctest.Harness,
-	alice, bob *lnwallet.LightningWallet, t *testing.T) {
+	alice, bob *lnwallet.LightningWallet, t *testing.T, tweakless bool) {
 
 	// For this scenario, Alice will be the channel initiator while bob
 	// will act as the responder to the workflow.
@@ -817,6 +818,7 @@ func testSingleFunderReservationWorkflow(miner *rpctest.Harness,
 		FundingFeePerKw:  feePerKw,
 		PushMSat:         pushAmt,
 		Flags:            lnwire.FFAnnounceChannel,
+		Tweakless:        tweakless,
 	}
 	aliceChanReservation, err := alice.InitChannelReservation(aliceReq)
 	if err != nil {
@@ -860,6 +862,7 @@ func testSingleFunderReservationWorkflow(miner *rpctest.Harness,
 		FundingFeePerKw:  feePerKw,
 		PushMSat:         pushAmt,
 		Flags:            lnwire.FFAnnounceChannel,
+		Tweakless:        tweakless,
 	}
 	bobChanReservation, err := bob.InitChannelReservation(bobReq)
 	if err != nil {
@@ -966,7 +969,7 @@ func testSingleFunderReservationWorkflow(miner *rpctest.Harness,
 	if !aliceChannels[0].IsInitiator {
 		t.Fatalf("alice not detected as channel initiator")
 	}
-	if aliceChannels[0].ChanType != channeldb.SingleFunder {
+	if !aliceChannels[0].ChanType.IsSingleFunder() {
 		t.Fatalf("channel type is incorrect, expected %v instead got %v",
 			channeldb.SingleFunder, aliceChannels[0].ChanType)
 	}
@@ -986,7 +989,7 @@ func testSingleFunderReservationWorkflow(miner *rpctest.Harness,
 	if bobChannels[0].IsInitiator {
 		t.Fatalf("bob not detected as channel responder")
 	}
-	if bobChannels[0].ChanType != channeldb.SingleFunder {
+	if !bobChannels[0].ChanType.IsSingleFunder() {
 		t.Fatalf("channel type is incorrect, expected %v instead got %v",
 			channeldb.SingleFunder, bobChannels[0].ChanType)
 	}
@@ -2515,7 +2518,23 @@ var walletTests = []walletTestCase{
 	},
 	{
 		name: "single funding workflow",
-		test: testSingleFunderReservationWorkflow,
+		test: func(miner *rpctest.Harness, alice,
+			bob *lnwallet.LightningWallet, t *testing.T) {
+
+			testSingleFunderReservationWorkflow(
+				miner, alice, bob, t, false,
+			)
+		},
+	},
+	{
+		name: "single funding workflow tweakless",
+		test: func(miner *rpctest.Harness, alice,
+			bob *lnwallet.LightningWallet, t *testing.T) {
+
+			testSingleFunderReservationWorkflow(
+				miner, alice, bob, t, true,
+			)
+		},
 	},
 	{
 		name: "dual funder workflow",
diff --git a/lnwallet/test_utils.go b/lnwallet/test_utils.go
index 32c6db959..efb30ac1d 100644
--- a/lnwallet/test_utils.go
+++ b/lnwallet/test_utils.go
@@ -88,8 +88,11 @@ var (
 // allocated to each side. Within the channel, Alice is the initiator. The
 // function also returns a "cleanup" function that is meant to be called once
 // the test has been finalized. The clean up function will remote all temporary
-// files created
-func CreateTestChannels() (*LightningChannel, *LightningChannel, func(), error) {
+// files created. If tweaklessCommits is true, then the commits within the
+// channels will use the new format, otherwise the legacy format.
+func CreateTestChannels(tweaklessCommits bool) (
+	*LightningChannel, *LightningChannel, func(), error) {
+
 	channelCapacity, err := btcutil.NewAmount(10)
 	if err != nil {
 		return nil, nil, nil, err
@@ -202,9 +205,10 @@ func CreateTestChannels() (*LightningChannel, *LightningChannel, func(), error)
 	}
 	aliceCommitPoint := input.ComputeCommitmentPoint(aliceFirstRevoke[:])
 
-	aliceCommitTx, bobCommitTx, err := CreateCommitmentTxns(channelBal,
-		channelBal, &aliceCfg, &bobCfg, aliceCommitPoint, bobCommitPoint,
-		*fundingTxIn)
+	aliceCommitTx, bobCommitTx, err := CreateCommitmentTxns(
+		channelBal, channelBal, &aliceCfg, &bobCfg, aliceCommitPoint,
+		bobCommitPoint, *fundingTxIn, tweaklessCommits,
+	)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -270,7 +274,7 @@ func CreateTestChannels() (*LightningChannel, *LightningChannel, func(), error)
 		IdentityPub:             aliceKeys[0].PubKey(),
 		FundingOutpoint:         *prevOut,
 		ShortChannelID:          shortChanID,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             true,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: bobCommitPoint,
@@ -288,7 +292,7 @@ func CreateTestChannels() (*LightningChannel, *LightningChannel, func(), error)
 		IdentityPub:             bobKeys[0].PubKey(),
 		FundingOutpoint:         *prevOut,
 		ShortChannelID:          shortChanID,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             false,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: aliceCommitPoint,
@@ -300,6 +304,11 @@ func CreateTestChannels() (*LightningChannel, *LightningChannel, func(), error)
 		Packager:                channeldb.NewChannelPackager(shortChanID),
 	}
 
+	if !tweaklessCommits {
+		aliceChannelState.ChanType = channeldb.SingleFunder
+		bobChannelState.ChanType = channeldb.SingleFunder
+	}
+
 	aliceSigner := &input.MockSigner{Privkeys: aliceKeys}
 	bobSigner := &input.MockSigner{Privkeys: bobKeys}
 
diff --git a/lnwallet/transactions_test.go b/lnwallet/transactions_test.go
index 50a3bdf49..ed4c533db 100644
--- a/lnwallet/transactions_test.go
+++ b/lnwallet/transactions_test.go
@@ -370,7 +370,7 @@ func TestCommitmentAndHTLCTransactions(t *testing.T) {
 
 	// Manually construct a new LightningChannel.
 	channelState := channeldb.OpenChannel{
-		ChanType:        channeldb.SingleFunder,
+		ChanType:        channeldb.SingleFunderTweakless,
 		ChainHash:       *tc.netParams.GenesisHash,
 		FundingOutpoint: tc.fundingOutpoint,
 		ShortChannelID:  tc.shortChanID,
@@ -999,18 +999,9 @@ func TestCommitTxStateHint(t *testing.T) {
 	}
 }
 
-// TestCommitmentSpendValidation test the spendability of both outputs within
-// the commitment transaction.
-//
-// The following spending cases are covered by this test:
-//   * Alice's spend from the delayed output on her commitment transaction.
-//   * Bob's spend from Alice's delayed output when she broadcasts a revoked
-//     commitment transaction.
-//   * Bob's spend from his unencumbered output within Alice's commitment
-//     transaction.
-func TestCommitmentSpendValidation(t *testing.T) {
-	t.Parallel()
-
+// testSpendValidation ensures that we're able to spend all outputs in the
+// commitment transaction that we create.
+func testSpendValidation(t *testing.T, tweakless bool) {
 	// We generate a fake output, and the corresponding txin. This output
 	// doesn't need to exist, as we'll only be validating spending from the
 	// transaction that references this.
@@ -1030,18 +1021,28 @@ func TestCommitmentSpendValidation(t *testing.T) {
 	// We also set up set some resources for the commitment transaction.
 	// Each side currently has 1 BTC within the channel, with a total
 	// channel capacity of 2BTC.
-	aliceKeyPriv, aliceKeyPub := btcec.PrivKeyFromBytes(btcec.S256(),
-		testWalletPrivKey)
-	bobKeyPriv, bobKeyPub := btcec.PrivKeyFromBytes(btcec.S256(),
-		bobsPrivKey)
+	aliceKeyPriv, aliceKeyPub := btcec.PrivKeyFromBytes(
+		btcec.S256(), testWalletPrivKey,
+	)
+	bobKeyPriv, bobKeyPub := btcec.PrivKeyFromBytes(
+		btcec.S256(), bobsPrivKey,
+	)
 
 	revocationPreimage := testHdSeed.CloneBytes()
-	commitSecret, commitPoint := btcec.PrivKeyFromBytes(btcec.S256(),
-		revocationPreimage)
+	commitSecret, commitPoint := btcec.PrivKeyFromBytes(
+		btcec.S256(), revocationPreimage,
+	)
 	revokePubKey := input.DeriveRevocationPubkey(bobKeyPub, commitPoint)
 
 	aliceDelayKey := input.TweakPubKey(aliceKeyPub, commitPoint)
+
+	// Bob will have the channel "force closed" on him, so for the sake of
+	// our commitments, if it's tweakless, his key will just be his regular
+	// pubkey.
 	bobPayKey := input.TweakPubKey(bobKeyPub, commitPoint)
+	if tweakless {
+		bobPayKey = bobKeyPub
+	}
 
 	aliceCommitTweak := input.SingleTweakBytes(commitPoint, aliceKeyPub)
 	bobCommitTweak := input.SingleTweakBytes(commitPoint, bobKeyPub)
@@ -1062,8 +1063,10 @@ func TestCommitmentSpendValidation(t *testing.T) {
 		RevocationKey: revokePubKey,
 		NoDelayKey:    bobPayKey,
 	}
-	commitmentTx, err := CreateCommitTx(*fakeFundingTxIn, keyRing, csvTimeout,
-		channelBalance, channelBalance, DefaultDustLimit())
+	commitmentTx, err := CreateCommitTx(
+		*fakeFundingTxIn, keyRing, csvTimeout, channelBalance,
+		channelBalance, DefaultDustLimit(),
+	)
 	if err != nil {
 		t.Fatalf("unable to create commitment transaction: %v", nil)
 	}
@@ -1088,8 +1091,9 @@ func TestCommitmentSpendValidation(t *testing.T) {
 	})
 
 	// First, we'll test spending with Alice's key after the timeout.
-	delayScript, err := input.CommitScriptToSelf(csvTimeout, aliceDelayKey,
-		revokePubKey)
+	delayScript, err := input.CommitScriptToSelf(
+		csvTimeout, aliceDelayKey, revokePubKey,
+	)
 	if err != nil {
 		t.Fatalf("unable to generate alice delay script: %v", err)
 	}
@@ -1107,8 +1111,9 @@ func TestCommitmentSpendValidation(t *testing.T) {
 		HashType:   txscript.SigHashAll,
 		InputIndex: 0,
 	}
-	aliceWitnessSpend, err := input.CommitSpendTimeout(aliceSelfOutputSigner,
-		signDesc, sweepTx)
+	aliceWitnessSpend, err := input.CommitSpendTimeout(
+		aliceSelfOutputSigner, signDesc, sweepTx,
+	)
 	if err != nil {
 		t.Fatalf("unable to generate delay commit spend witness: %v", err)
 	}
@@ -1177,7 +1182,6 @@ func TestCommitmentSpendValidation(t *testing.T) {
 		KeyDesc: keychain.KeyDescriptor{
 			PubKey: bobKeyPub,
 		},
-		SingleTweak:   bobCommitTweak,
 		WitnessScript: bobScriptP2WKH,
 		SigHashes:     txscript.NewTxSigHashes(sweepTx),
 		Output: &wire.TxOut{
@@ -1187,15 +1191,21 @@ func TestCommitmentSpendValidation(t *testing.T) {
 		HashType:   txscript.SigHashAll,
 		InputIndex: 0,
 	}
-	bobRegularSpend, err := input.CommitSpendNoDelay(bobSigner, signDesc,
-		sweepTx)
+	if !tweakless {
+		signDesc.SingleTweak = bobCommitTweak
+	}
+	bobRegularSpend, err := input.CommitSpendNoDelay(
+		bobSigner, signDesc, sweepTx, tweakless,
+	)
 	if err != nil {
 		t.Fatalf("unable to create bob regular spend: %v", err)
 	}
 	sweepTx.TxIn[0].Witness = bobRegularSpend
-	vm, err = txscript.NewEngine(regularOutput.PkScript,
+	vm, err = txscript.NewEngine(
+		regularOutput.PkScript,
 		sweepTx, 0, txscript.StandardVerifyFlags, nil,
-		nil, int64(channelBalance))
+		nil, int64(channelBalance),
+	)
 	if err != nil {
 		t.Fatalf("unable to create engine: %v", err)
 	}
@@ -1203,3 +1213,26 @@ func TestCommitmentSpendValidation(t *testing.T) {
 		t.Fatalf("bob p2wkh spend is invalid: %v", err)
 	}
 }
+
+// TestCommitmentSpendValidation test the spendability of both outputs within
+// the commitment transaction.
+//
+// The following spending cases are covered by this test:
+//   * Alice's spend from the delayed output on her commitment transaction.
+//   * Bob's spend from Alice's delayed output when she broadcasts a revoked
+//     commitment transaction.
+//   * Bob's spend from his unencumbered output within Alice's commitment
+//     transaction.
+func TestCommitmentSpendValidation(t *testing.T) {
+	t.Parallel()
+
+	// In the modern network, all channels use the new tweakless format,
+	// but we also need to support older nodes that want to open channels
+	// with the legacy format, so we'll test spending in both scenarios.
+	for _, tweakless := range []bool{true, false} {
+		tweakless := tweakless
+		t.Run(fmt.Sprintf("tweak=%v", tweakless), func(t *testing.T) {
+			testSpendValidation(t, tweakless)
+		})
+	}
+}
diff --git a/test_utils.go b/test_utils.go
index 7a5a1c349..671bc0f46 100644
--- a/test_utils.go
+++ b/test_utils.go
@@ -186,9 +186,10 @@ func createTestPeer(notifier chainntnfs.ChainNotifier,
 	}
 	aliceCommitPoint := input.ComputeCommitmentPoint(aliceFirstRevoke[:])
 
-	aliceCommitTx, bobCommitTx, err := lnwallet.CreateCommitmentTxns(channelBal,
-		channelBal, &aliceCfg, &bobCfg, aliceCommitPoint, bobCommitPoint,
-		*fundingTxIn)
+	aliceCommitTx, bobCommitTx, err := lnwallet.CreateCommitmentTxns(
+		channelBal, channelBal, &aliceCfg, &bobCfg, aliceCommitPoint,
+		bobCommitPoint, *fundingTxIn, true,
+	)
 	if err != nil {
 		return nil, nil, nil, nil, err
 	}
@@ -254,7 +255,7 @@ func createTestPeer(notifier chainntnfs.ChainNotifier,
 		IdentityPub:             aliceKeyPub,
 		FundingOutpoint:         *prevOut,
 		ShortChannelID:          shortChanID,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             true,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: bobCommitPoint,
@@ -271,7 +272,7 @@ func createTestPeer(notifier chainntnfs.ChainNotifier,
 		RemoteChanCfg:           aliceCfg,
 		IdentityPub:             bobKeyPub,
 		FundingOutpoint:         *prevOut,
-		ChanType:                channeldb.SingleFunder,
+		ChanType:                channeldb.SingleFunderTweakless,
 		IsInitiator:             false,
 		Capacity:                channelCapacity,
 		RemoteCurrentRevocation: aliceCommitPoint,
diff --git a/watchtower/lookout/justice_descriptor_test.go b/watchtower/lookout/justice_descriptor_test.go
index 1f880c236..7fd93c8c8 100644
--- a/watchtower/lookout/justice_descriptor_test.go
+++ b/watchtower/lookout/justice_descriptor_test.go
@@ -254,7 +254,7 @@ func testJusticeDescriptor(t *testing.T, blobType blob.Type) {
 	// DER-encoded signature under the to-remote pubkey. The sighash flag is
 	// also present, so we trim it.
 	toRemoteWitness, err := input.CommitSpendNoDelay(
-		signer, toRemoteSignDesc, justiceTxn,
+		signer, toRemoteSignDesc, justiceTxn, false,
 	)
 	if err != nil {
 		t.Fatalf("unable to sign to-remote input: %v", err)
diff --git a/watchtower/wtclient/backup_task_internal_test.go b/watchtower/wtclient/backup_task_internal_test.go
index 5bc0dbb4d..cff6f2b86 100644
--- a/watchtower/wtclient/backup_task_internal_test.go
+++ b/watchtower/wtclient/backup_task_internal_test.go
@@ -73,6 +73,7 @@ type backupTaskTest struct {
 	bindErr          error
 	expSweepScript   []byte
 	signer           input.Signer
+	tweakless        bool
 }
 
 // genTaskTest creates a instance of a backupTaskTest using the passed
@@ -89,7 +90,8 @@ func genTaskTest(
 	rewardScript []byte,
 	expSweepAmt int64,
 	expRewardAmt int64,
-	bindErr error) backupTaskTest {
+	bindErr error,
+	tweakless bool) backupTaskTest {
 
 	// Parse the key pairs for all keys used in the test.
 	revSK, revPK := btcec.PrivKeyFromBytes(
@@ -188,9 +190,15 @@ func genTaskTest(
 			Hash:  txid,
 			Index: index,
 		}
+
+		witnessType := input.CommitmentNoDelay
+		if tweakless {
+			witnessType = input.CommitSpendNoDelayTweakless
+		}
+
 		toRemoteInput = input.NewBaseInput(
 			&breachInfo.LocalOutpoint,
-			input.CommitmentNoDelay,
+			witnessType,
 			breachInfo.LocalOutputSignDesc,
 			0,
 		)
@@ -218,6 +226,7 @@ func genTaskTest(
 		bindErr:        bindErr,
 		expSweepScript: makeAddrSlice(22),
 		signer:         signer,
+		tweakless:      tweakless,
 	}
 }
 
@@ -233,153 +242,6 @@ var (
 	addrScript, _ = txscript.PayToAddrScript(addr)
 )
 
-var backupTaskTests = []backupTaskTest{
-	genTaskTest(
-		"commit no-reward, both outputs",
-		100,                    // stateNum
-		200000,                 // toLocalAmt
-		100000,                 // toRemoteAmt
-		blobTypeCommitNoReward, // blobType
-		1000,                   // sweepFeeRate
-		nil,                    // rewardScript
-		299241,                 // expSweepAmt
-		0,                      // expRewardAmt
-		nil,                    // bindErr
-	),
-	genTaskTest(
-		"commit no-reward, to-local output only",
-		1000,                   // stateNum
-		200000,                 // toLocalAmt
-		0,                      // toRemoteAmt
-		blobTypeCommitNoReward, // blobType
-		1000,                   // sweepFeeRate
-		nil,                    // rewardScript
-		199514,                 // expSweepAmt
-		0,                      // expRewardAmt
-		nil,                    // bindErr
-	),
-	genTaskTest(
-		"commit no-reward, to-remote output only",
-		1,                      // stateNum
-		0,                      // toLocalAmt
-		100000,                 // toRemoteAmt
-		blobTypeCommitNoReward, // blobType
-		1000,                   // sweepFeeRate
-		nil,                    // rewardScript
-		99561,                  // expSweepAmt
-		0,                      // expRewardAmt
-		nil,                    // bindErr
-	),
-	genTaskTest(
-		"commit no-reward, to-remote output only, creates dust",
-		1,                       // stateNum
-		0,                       // toLocalAmt
-		100000,                  // toRemoteAmt
-		blobTypeCommitNoReward,  // blobType
-		227500,                  // sweepFeeRate
-		nil,                     // rewardScript
-		0,                       // expSweepAmt
-		0,                       // expRewardAmt
-		wtpolicy.ErrCreatesDust, // bindErr
-	),
-	genTaskTest(
-		"commit no-reward, no outputs, fee rate exceeds inputs",
-		300,                          // stateNum
-		0,                            // toLocalAmt
-		0,                            // toRemoteAmt
-		blobTypeCommitNoReward,       // blobType
-		1000,                         // sweepFeeRate
-		nil,                          // rewardScript
-		0,                            // expSweepAmt
-		0,                            // expRewardAmt
-		wtpolicy.ErrFeeExceedsInputs, // bindErr
-	),
-	genTaskTest(
-		"commit no-reward, no outputs, fee rate of 0 creates dust",
-		300,                     // stateNum
-		0,                       // toLocalAmt
-		0,                       // toRemoteAmt
-		blobTypeCommitNoReward,  // blobType
-		0,                       // sweepFeeRate
-		nil,                     // rewardScript
-		0,                       // expSweepAmt
-		0,                       // expRewardAmt
-		wtpolicy.ErrCreatesDust, // bindErr
-	),
-	genTaskTest(
-		"commit reward, both outputs",
-		100,                  // stateNum
-		200000,               // toLocalAmt
-		100000,               // toRemoteAmt
-		blobTypeCommitReward, // blobType
-		1000,                 // sweepFeeRate
-		addrScript,           // rewardScript
-		296117,               // expSweepAmt
-		3000,                 // expRewardAmt
-		nil,                  // bindErr
-	),
-	genTaskTest(
-		"commit reward, to-local output only",
-		1000,                 // stateNum
-		200000,               // toLocalAmt
-		0,                    // toRemoteAmt
-		blobTypeCommitReward, // blobType
-		1000,                 // sweepFeeRate
-		addrScript,           // rewardScript
-		197390,               // expSweepAmt
-		2000,                 // expRewardAmt
-		nil,                  // bindErr
-	),
-	genTaskTest(
-		"commit reward, to-remote output only",
-		1,                    // stateNum
-		0,                    // toLocalAmt
-		100000,               // toRemoteAmt
-		blobTypeCommitReward, // blobType
-		1000,                 // sweepFeeRate
-		addrScript,           // rewardScript
-		98437,                // expSweepAmt
-		1000,                 // expRewardAmt
-		nil,                  // bindErr
-	),
-	genTaskTest(
-		"commit reward, to-remote output only, creates dust",
-		1,                       // stateNum
-		0,                       // toLocalAmt
-		100000,                  // toRemoteAmt
-		blobTypeCommitReward,    // blobType
-		175000,                  // sweepFeeRate
-		addrScript,              // rewardScript
-		0,                       // expSweepAmt
-		0,                       // expRewardAmt
-		wtpolicy.ErrCreatesDust, // bindErr
-	),
-	genTaskTest(
-		"commit reward, no outputs, fee rate exceeds inputs",
-		300,                          // stateNum
-		0,                            // toLocalAmt
-		0,                            // toRemoteAmt
-		blobTypeCommitReward,         // blobType
-		1000,                         // sweepFeeRate
-		addrScript,                   // rewardScript
-		0,                            // expSweepAmt
-		0,                            // expRewardAmt
-		wtpolicy.ErrFeeExceedsInputs, // bindErr
-	),
-	genTaskTest(
-		"commit reward, no outputs, fee rate of 0 creates dust",
-		300,                     // stateNum
-		0,                       // toLocalAmt
-		0,                       // toRemoteAmt
-		blobTypeCommitReward,    // blobType
-		0,                       // sweepFeeRate
-		addrScript,              // rewardScript
-		0,                       // expSweepAmt
-		0,                       // expRewardAmt
-		wtpolicy.ErrCreatesDust, // bindErr
-	),
-}
-
 // TestBackupTaskBind tests the initialization and binding of a backupTask to a
 // ClientSession. After a successful bind, all parameters of the justice
 // transaction should be solidified, so we assert there correctness. In an
@@ -390,8 +252,174 @@ var backupTaskTests = []backupTaskTest{
 func TestBackupTask(t *testing.T) {
 	t.Parallel()
 
+	var backupTaskTests []backupTaskTest
+	for _, tweakless := range []bool{true, false} {
+		backupTaskTests = append(backupTaskTests, []backupTaskTest{
+			genTaskTest(
+				"commit no-reward, both outputs",
+				100,                    // stateNum
+				200000,                 // toLocalAmt
+				100000,                 // toRemoteAmt
+				blobTypeCommitNoReward, // blobType
+				1000,                   // sweepFeeRate
+				nil,                    // rewardScript
+				299241,                 // expSweepAmt
+				0,                      // expRewardAmt
+				nil,                    // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit no-reward, to-local output only",
+				1000,                   // stateNum
+				200000,                 // toLocalAmt
+				0,                      // toRemoteAmt
+				blobTypeCommitNoReward, // blobType
+				1000,                   // sweepFeeRate
+				nil,                    // rewardScript
+				199514,                 // expSweepAmt
+				0,                      // expRewardAmt
+				nil,                    // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit no-reward, to-remote output only",
+				1,                      // stateNum
+				0,                      // toLocalAmt
+				100000,                 // toRemoteAmt
+				blobTypeCommitNoReward, // blobType
+				1000,                   // sweepFeeRate
+				nil,                    // rewardScript
+				99561,                  // expSweepAmt
+				0,                      // expRewardAmt
+				nil,                    // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit no-reward, to-remote output only, creates dust",
+				1,                       // stateNum
+				0,                       // toLocalAmt
+				100000,                  // toRemoteAmt
+				blobTypeCommitNoReward,  // blobType
+				227500,                  // sweepFeeRate
+				nil,                     // rewardScript
+				0,                       // expSweepAmt
+				0,                       // expRewardAmt
+				wtpolicy.ErrCreatesDust, // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit no-reward, no outputs, fee rate exceeds inputs",
+				300,                          // stateNum
+				0,                            // toLocalAmt
+				0,                            // toRemoteAmt
+				blobTypeCommitNoReward,       // blobType
+				1000,                         // sweepFeeRate
+				nil,                          // rewardScript
+				0,                            // expSweepAmt
+				0,                            // expRewardAmt
+				wtpolicy.ErrFeeExceedsInputs, // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit no-reward, no outputs, fee rate of 0 creates dust",
+				300,                     // stateNum
+				0,                       // toLocalAmt
+				0,                       // toRemoteAmt
+				blobTypeCommitNoReward,  // blobType
+				0,                       // sweepFeeRate
+				nil,                     // rewardScript
+				0,                       // expSweepAmt
+				0,                       // expRewardAmt
+				wtpolicy.ErrCreatesDust, // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit reward, both outputs",
+				100,                  // stateNum
+				200000,               // toLocalAmt
+				100000,               // toRemoteAmt
+				blobTypeCommitReward, // blobType
+				1000,                 // sweepFeeRate
+				addrScript,           // rewardScript
+				296117,               // expSweepAmt
+				3000,                 // expRewardAmt
+				nil,                  // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit reward, to-local output only",
+				1000,                 // stateNum
+				200000,               // toLocalAmt
+				0,                    // toRemoteAmt
+				blobTypeCommitReward, // blobType
+				1000,                 // sweepFeeRate
+				addrScript,           // rewardScript
+				197390,               // expSweepAmt
+				2000,                 // expRewardAmt
+				nil,                  // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit reward, to-remote output only",
+				1,                    // stateNum
+				0,                    // toLocalAmt
+				100000,               // toRemoteAmt
+				blobTypeCommitReward, // blobType
+				1000,                 // sweepFeeRate
+				addrScript,           // rewardScript
+				98437,                // expSweepAmt
+				1000,                 // expRewardAmt
+				nil,                  // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit reward, to-remote output only, creates dust",
+				1,                       // stateNum
+				0,                       // toLocalAmt
+				100000,                  // toRemoteAmt
+				blobTypeCommitReward,    // blobType
+				175000,                  // sweepFeeRate
+				addrScript,              // rewardScript
+				0,                       // expSweepAmt
+				0,                       // expRewardAmt
+				wtpolicy.ErrCreatesDust, // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit reward, no outputs, fee rate exceeds inputs",
+				300,                          // stateNum
+				0,                            // toLocalAmt
+				0,                            // toRemoteAmt
+				blobTypeCommitReward,         // blobType
+				1000,                         // sweepFeeRate
+				addrScript,                   // rewardScript
+				0,                            // expSweepAmt
+				0,                            // expRewardAmt
+				wtpolicy.ErrFeeExceedsInputs, // bindErr
+				tweakless,
+			),
+			genTaskTest(
+				"commit reward, no outputs, fee rate of 0 creates dust",
+				300,                     // stateNum
+				0,                       // toLocalAmt
+				0,                       // toRemoteAmt
+				blobTypeCommitReward,    // blobType
+				0,                       // sweepFeeRate
+				addrScript,              // rewardScript
+				0,                       // expSweepAmt
+				0,                       // expRewardAmt
+				wtpolicy.ErrCreatesDust, // bindErr
+				tweakless,
+			),
+		}...)
+	}
+
 	for _, test := range backupTaskTests {
+		test := test
+
 		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
 			testBackupTask(t, test)
 		})
 	}
@@ -399,7 +427,10 @@ func TestBackupTask(t *testing.T) {
 
 func testBackupTask(t *testing.T, test backupTaskTest) {
 	// Create a new backupTask from the channel id and breach info.
-	task := newBackupTask(&test.chanID, test.breachInfo, test.expSweepScript)
+	task := newBackupTask(
+		&test.chanID, test.breachInfo, test.expSweepScript,
+		test.tweakless,
+	)
 
 	// Assert that all parameters set during initialization are properly
 	// populated.
diff --git a/watchtower/wtclient/client_test.go b/watchtower/wtclient/client_test.go
index e9019ad96..bd16ac065 100644
--- a/watchtower/wtclient/client_test.go
+++ b/watchtower/wtclient/client_test.go
@@ -628,7 +628,7 @@ func (h *testHarness) backupState(id, i uint64, expErr error) {
 	_, retribution := h.channel(id).getState(i)
 
 	chanID := chanIDFromInt(id)
-	err := h.client.BackupState(&chanID, retribution)
+	err := h.client.BackupState(&chanID, retribution, false)
 	if err != expErr {
 		h.t.Fatalf("back error mismatch, want: %v, got: %v",
 			expErr, err)