Repository: lightningnetwork/lnd
Pull request #3332 (2019-07-22 15:02:01)

Chanfitness: Track peer uptime
This PR introduces a new package `chanfitness` which is used to track scores for a node's channels. 
Scores are currently kept in memory, with the intention of persisting them once the set of metrics needed to score nodes is more clearly defined.  It is related to #1253, although the issue is quite old.

This change implements tracking for peer uptime, by maintaining a log of channel events for each channel. Peer online/offline events are monitored by a goroutine on a per peer basis, and channel creation/close events are monitored by a single goroutine.

This change also includes adding a channel fitness rpc subserver, but that can be split out into another PR if the change is too big. 

#### PR Checklist
- [x] All changes are Go version 1.12 compliant (used go1.12.6)
- [x] Go fmt, commented and wrapped at 80 lines
- [x] Make check, lint and go vet ok, builds properly!
- [x] Code accompanied by tests 


carlaKC: Thanks for the review @halseth 🙏 
Agreed on monitoring all peers rather than peers on a per channel basis, makes a lot more sense. 

What do you think about adding a `peernotifier` package that provides a `subscribe.Client` like `channotifier` currently does? That way, `chanfitness` can subscribe to peer events in the same way that it does channels? 

With that approach, I'd break this (entirely too big - sorry 😅) PR down into:
1. Add `peernotifier` package in new a PR
2. Reduce this PR to just consume channel events for now (+ remove grpc)
3. Add peer monitoring to `chanfitness`
4. Add grpc subserver for querying `chanfitnes`
Sound ok?
halseth: > What do you think about adding a `peernotifier` package that provides a `subscribe.Client` like `channotifier` currently does? That way, `chanfitness` can subscribe to peer events in the same way that it does channels?

👍 

> With that approach, I'd break this (entirely too big - sorry 😅) PR down into:
> 
> 1. Add `peernotifier` package in new a PR
> 2. Reduce this PR to just consume channel events for now (+ remove grpc)
> 3. Add peer monitoring to `chanfitness`
> 4. Add grpc subserver for querying `chanfitnes`
>    Sound ok?

I would start by doing 1 and 2, then we can take a look at how big 2 becomes and what we could reasonably include there 😄 


halseth: Needs rebase!
carlaKC: Thanks for taking a look @joostjager  

> In general I think it is best if it also makes the changes end to end, so that one can verify (run the code) that the goal of the pr is met.

>  Imo that bears the risk that code get merged that needs to be revised later when doing the work in the higher level layers. It may take some creativity to define an end to end pr that is not too big, but it seems that in this new domain there must be some good opportunities.

I definitely agree on having a more horizontal PR in terms of being able to test the changes and figuring out how it will be used by higher levels. My original pass at this PR had a rpcsubserver for getting scores included, but that ended up being a pretty huge PR so I removed it. My thoughts on expanding this PR to be more than just kicking off a logical loop:
1. Re-add a RPC server so the endpoint can be called, although I don't feel like this properly covers what you mean by figuring out how it will be used on higher levels?
2. Add some opt-in channel closing behaviour to autopilot. Since we're only going to have uptime metrics available (see below), I'd say that this would have to be done with some minimum channel lifetime param (eg must be at least x days old) and threshold flap rate which is not acceptable so that we don't start maniacally closing channels. I'll give that a go and see how it looks, might end up being too much for one change. 

> Also, if the goal is to track channel open/closes on chain: it may be that that info is already available and doesn't need to be tracked. The channel point and the closing tx id are persisted in the database. Maybe the peer (tcp) up time metric would have been more suitable to kick off the fitness system.

This PR has been waiting on #3354 (which was originally included in my way too big first attempt) so that uptime can be added to the events store - that is the main goal for this PR. When peer events were split out, I updated this to just have open/close events to get an idea of what the structure would look like. I'm going to add online/offline events now that #3354 is merged - I should have made that clearer, sorry! 

In terms of having open/ close events at all, I think it still makes sense to have them while events are being kept in memory? That way the package doesn't have to touch the DB at all for now (and does not need to query it every time a score is requested). If/when we start looking at persisting score data, we can probably just get channel open/close events from chanDB. 


joostjager: I actually meant creating a vertical PR, cutting through several layers. Ok, horizontal, vertical, it isn't very self-describing, but I think we mean the same thing.

I would at least choose either channel open/close or peer online/offline, not both, for this pr. If you choose peer online/offline, maybe you can just expose a single value "average peer uptime %" over the rpc. Or even more minimalistic, just log the average peer uptime value periodically. Then at least, some business value is created and users can see that it works.

For channel open/close: I don't know if it is a requirement to not touch the database for now. If you think you'll query chandb later, it may not be worth to write the code to send channel events now and remove that again later. In general, with storing redundant information things may get out of sync. 
halseth: I think only doing peer uptime for now sounds like a good middle ground. That was what this PR originally set out to do, and would provide information we don't currently have anywhere.

The question is whether we can get away with channel events completely. Since a peer's uptime might not be very interesting if we don't have an open channel with it, it makes sense to somehow relate it to channel events. This information can _possibly_ be fetched from the DB, but I'm not sure if we have it all (we only have block heights, not timestamps, even though we can fetch these from block headers), and I can imagine this could get more complicated than the current approach, as it is quite self contained. Storing open/close events is also not that big of a deal IMO, as it is not in any way critical if it gets out of sync.

For using this information, we could start with something as simple as returning peer uptime % during a `listchannels` call :)
joostjager: One other question: how does the channel fitness subsystem relate to `lndmon`?

From `lndmon`:

>while lnd provides some information, lndmon by far does the heavy lifting with regards to metrics. With lndmon's data, you can track routing fees over time [..]

This seems to overlap with what is started in this pr. For example iterating over time series to extract useful values.
carlaKC: > One other question: how does the channel fitness subsystem relate to `lndmon`?

I haven't looked at `lndmon` in detail, but I think that `chanfitness` is a reduced, inhouse version of `lndmon` that we need for querying a specific subset of data? There are some things (like peer uptime) that could be exported to `lndmon` - which actually makes a case for tracking peer online status independent of channels in peernotifier so that we can query uptime over a period (which could be exported to `lndmon` and `chanfitness` . I think that may be overkill for now, but moving the logic in chanfitness to `peerNotifier` at a later time will be pretty trivial. 

> This seems to overlap with what is started in this pr. For example iterating over time series to extract useful values.

In terms of metrics that may be duplicated on both sides, I don't think we need to specifically track an event log for the payment level data (fees, failed/succeeded amounts) so that would minimise the amount of time series processing we do. Uptime is the only "stateful" series that made more sense to track as time series (I did implement a running counter for uptime but it was very messy). If it comes to a point where there's straight up duplication between the two, then we can look at chanfitness exporting metrics for `lndmon`?
joostjager: We had a bit more discussion on the topic. One thing that was brought up, is the case where tracking of data can trigger certain actions like auto-closing of channels. With `lndmon`, a loop would be created where `lnd` exports to `lndmon`, `lndmon` does time series/analysis/etc and then pushes the result back into `lnd` to take action. This may not be the architecture that we want.

I think the main thing is for us to be aware that the fitness subsystem and `lndmon` are related and make a deliberate decision on where to implement new functionality. 

I am a bit worried though to which extent we can actually foresee what we need. But yes, you are right, the fitness subsystem could in that case export to `lnd` to prevent duplication.

With regard to useful things to track as time series in the fitness subsystem (in the future), the metric 'channel profitability' always comes to my mind. To be able to auto-close non-profitable channels. For channel profitability, an analysis over time of local balance and fwding fees is required.
joostjager: Tagging @valentinewallace as she's been developing `lndmon`.
carlaKC: PR updated to add a few changes:
1. Include uptime in `lnrpc/Channel` which is returned by `ListChannels`
2. Record online/offline events on startup for each channel and on open channel events
- When we restart, we need to add a peer online/offline event for existing channels otherwise we will have to wait until they go online/offline to start tracking
- A channel open event is not a guarantee that a peer is online, because they can go offline while the funding tx confirms, so we need to know their starting state

There is an edge case for existing channels where peers are recorded as offline because we have not connected to them at restart time, and then online when we establish a connection, which means existing channels will have 99% uptime rather than 100%. This can be addressed by adding a wait before recording initial peer state for channels (eg sleep one minute then check status) if necessary. 
valentinewallace: >With lndmon, a loop would be created where lnd exports to lndmon, lndmon does time series/analysis/etc and then pushes the result back into lnd to take action. This may not be the architecture that we want.

I agree that sounds like an architecture to avoid :smile: 

>There are some things (like peer uptime) that could be exported to lndmon

That sounds useful. Prometheus may be able to track peer uptime already since it does know when the set of peers changes :thinking: Let me know if I can contribute more lndmon insight.
halseth: > Thinking ahead, I'm wondering whether it would be better to have a `channelEvent` interface in `chanevent.go`

That indeed sounds like a good idea IMO, but that change can possibly be done when needed? :)
Roasbeef: OP ping! 

Patch:
diff --git a/.golangci.yml b/.golangci.yml
index ca3e68818..6ac09542a 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -55,6 +55,9 @@ linters:
   # the linter.
   - prealloc
 
+  # Init functions are used by loggers throughout the codebase.
+  - gochecknoinits
+
 issues:
   # Only show newly introduced problems.
   new-from-rev: 01f696afce2f9c0d4ed854edefa3846891d01d8a
diff --git a/chanfitness/chanevent.go b/chanfitness/chanevent.go
new file mode 100644
index 000000000..b91ada037
--- /dev/null
+++ b/chanfitness/chanevent.go
@@ -0,0 +1,218 @@
+package chanfitness
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/lightningnetwork/lnd/routing/route"
+)
+
+type eventType int
+
+const (
+	peerOnlineEvent eventType = iota
+	peerOfflineEvent
+)
+
+// String provides string representations of channel events.
+func (e eventType) String() string {
+	switch e {
+	case peerOnlineEvent:
+		return "peer_online"
+
+	case peerOfflineEvent:
+		return "peer_offline"
+	}
+
+	return "unknown"
+}
+
+// channelEvent is a a timestamped event which is observed on a per channel
+// basis.
+type channelEvent struct {
+	timestamp time.Time
+	eventType eventType
+}
+
+// chanEventLog stores all events that have occurred over a channel's lifetime.
+type chanEventLog struct {
+	// id is the uint64 of the short channel ID.
+	id uint64
+
+	// peer is the compressed public key of the peer being monitored.
+	peer route.Vertex
+
+	// events is a log of timestamped events observed for the channel.
+	events []*channelEvent
+
+	// now is expected to return the current time. It is supplied as an
+	// external function to enable deterministic unit tests.
+	now func() time.Time
+
+	// openedAt tracks the first time this channel was seen. This is not
+	// necessarily the time that it confirmed on chain because channel events
+	// are not persisted at present.
+	openedAt time.Time
+
+	// closedAt is the time that the channel was closed. If the channel has not
+	// been closed yet, it is zero.
+	closedAt time.Time
+}
+
+func newEventLog(id uint64, peer route.Vertex, now func() time.Time) *chanEventLog {
+	return &chanEventLog{
+		id:   id,
+		peer: peer,
+		now:  now,
+	}
+}
+
+// close sets the closing time for an event log.
+func (e *chanEventLog) close() {
+	e.closedAt = e.now()
+}
+
+// add appends an event with the given type and current time to the event log.
+// The open time for the eventLog will be set to the event's timestamp if it is
+// not set yet.
+func (e *chanEventLog) add(eventType eventType) {
+	// If the channel is already closed, return early without adding an event.
+	if !e.closedAt.IsZero() {
+		return
+	}
+
+	// Add the event to the eventLog with the current timestamp.
+	event := &channelEvent{
+		timestamp: e.now(),
+		eventType: eventType,
+	}
+	e.events = append(e.events, event)
+
+	// If the eventLog does not have an opened time set, set it to the timestamp
+	// of the event. This has the effect of setting the eventLog's open time to
+	// the timestamp of the first event added.
+	if e.openedAt.IsZero() {
+		e.openedAt = event.timestamp
+	}
+
+	log.Debugf("Channel %v recording event: %v", e.id, eventType)
+}
+
+// onlinePeriod represents a period of time over which a peer was online.
+type onlinePeriod struct {
+	start, end time.Time
+}
+
+// getOnlinePeriods returns a list of all the periods that the event log has
+// recorded the remote peer as being online. In the unexpected case where there
+// are no events, the function returns early. Online periods are defined as a
+// peer online event which is terminated by a peer offline event. This function
+// expects the event log provided to be ordered by ascending timestamp.
+func (e *chanEventLog) getOnlinePeriods() []*onlinePeriod {
+	// Return early if there are no events, there are no online periods.
+	if len(e.events) == 0 {
+		return nil
+	}
+
+	var (
+		lastOnline    time.Time
+		offline       bool
+		onlinePeriods []*onlinePeriod
+	)
+
+	// Loop through all events to build a list of periods that the peer was
+	// online. Online periods are added when they are terminated with a peer
+	// offline event. If the log ends on an online event, the period between
+	// the online event and the present is not tracked. The type of the most
+	// recent event is tracked using the offline bool so that we can add a
+	// final online period if necessary.
+	for _, event := range e.events {
+
+		switch event.eventType {
+		case peerOnlineEvent:
+			lastOnline = event.timestamp
+			offline = false
+
+		case peerOfflineEvent:
+			offline = true
+
+			// Do not add to uptime if there is no previous online timestamp,
+			// the event log has started with an offline event
+			if lastOnline.IsZero() {
+				continue
+			}
+
+			// The eventLog has recorded an offline event, having previously
+			// been online so we add an online period to to set of online periods.
+			onlinePeriods = append(onlinePeriods, &onlinePeriod{
+				start: lastOnline,
+				end:   event.timestamp,
+			})
+		}
+	}
+
+	// If the last event was an peer offline event, we do not need to calculate
+	// a final online period and can return online periods as is.
+	if offline {
+		return onlinePeriods
+	}
+
+	// The log ended on an online event, so we need to add a final online event.
+	// If the channel is closed, this period is until channel closure. It it is
+	// still open, we calculate it until the present.
+	endTime := e.closedAt
+	if endTime.IsZero() {
+		endTime = e.now()
+	}
+
+	// Add the final online period to the set and return.
+	return append(onlinePeriods, &onlinePeriod{
+		start: lastOnline,
+		end:   endTime,
+	})
+}
+
+// uptime calculates the total uptime we have recorded for a channel over the
+// inclusive range specified. An error is returned if the end of the range is
+// before the start or a zero end time is returned.
+func (e *chanEventLog) uptime(start, end time.Time) (time.Duration, error) {
+	// Error if we are provided with an invalid range to calculate uptime for.
+	if end.Before(start) {
+		return 0, fmt.Errorf("end time: %v before start time: %v",
+			end, start)
+	}
+	if end.IsZero() {
+		return 0, fmt.Errorf("zero end time")
+	}
+
+	var uptime time.Duration
+
+	for _, p := range e.getOnlinePeriods() {
+		// The online period ends before the range we're looking at, so we can
+		// skip over it.
+		if p.end.Before(start) {
+			continue
+		}
+		// The online period starts after the range we're looking at, so can
+		// stop calculating uptime.
+		if p.start.After(end) {
+			break
+		}
+
+		// If the online period starts before our range, shift the start time up
+		// so that we only calculate uptime from the start of our range.
+		if p.start.Before(start) {
+			p.start = start
+		}
+
+		// If the online period ends before our range, shift the end time
+		// forward so that we only calculate uptime until the end of the range.
+		if p.end.After(end) {
+			p.end = end
+		}
+
+		uptime += p.end.Sub(p.start)
+	}
+
+	return uptime, nil
+}
diff --git a/chanfitness/chaneventstore.go b/chanfitness/chaneventstore.go
new file mode 100644
index 000000000..a43397652
--- /dev/null
+++ b/chanfitness/chaneventstore.go
@@ -0,0 +1,390 @@
+// Package chanfitness monitors the behaviour of channels to provide insight
+// into the health and performance of a channel. This is achieved by maintaining
+// an event store which tracks events for each channel.
+//
+// Lifespan: the period that the channel has been known to the scoring system.
+// Note that lifespan may not equal the channel's full lifetime because data is
+// not currently persisted.
+//
+// Uptime: the total time within a given period that the channel's remote peer
+// has been online.
+package chanfitness
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channelnotifier"
+	"github.com/lightningnetwork/lnd/peernotifier"
+	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/subscribe"
+)
+
+// errShuttingDown is returned when the store cannot respond to a query because
+// it has received the shutdown signal.
+var errShuttingDown = errors.New("channel event store shutting down")
+
+// ChannelEventStore maintains a set of event logs for the node's channels to
+// provide insight into the performance and health of channels.
+type ChannelEventStore struct {
+	cfg *Config
+
+	// channels maps short channel IDs to event logs.
+	channels map[uint64]*chanEventLog
+
+	// peers tracks the current online status of peers based on online/offline
+	// events.
+	peers map[route.Vertex]bool
+
+	// lifespanRequests serves requests for the lifespan of channels.
+	lifespanRequests chan lifespanRequest
+
+	// uptimeRequests serves requests for the uptime of channels.
+	uptimeRequests chan uptimeRequest
+
+	quit chan struct{}
+
+	wg sync.WaitGroup
+}
+
+// Config provides the event store with functions required to monitor channel
+// activity. All elements of the config must be non-nil for the event store to
+// operate.
+type Config struct {
+	// SubscribeChannelEvents provides a subscription client which provides a
+	// stream of channel events.
+	SubscribeChannelEvents func() (*subscribe.Client, error)
+
+	// SubscribePeerEvents provides a subscription client which provides a
+	// stream of peer online/offline events.
+	SubscribePeerEvents func() (*subscribe.Client, error)
+
+	// GetOpenChannels provides a list of existing open channels which is used
+	// to populate the ChannelEventStore with a set of channels on startup.
+	GetOpenChannels func() ([]*channeldb.OpenChannel, error)
+}
+
+// lifespanRequest contains the channel ID required to query the store for a
+// channel's lifespan and a blocking response channel on which the result is
+// sent.
+type lifespanRequest struct {
+	channelID    uint64
+	responseChan chan lifespanResponse
+}
+
+// lifespanResponse contains the response to a lifespanRequest and an error if
+// one occurred.
+type lifespanResponse struct {
+	start time.Time
+	end   time.Time
+	err   error
+}
+
+// uptimeRequest contains the parameters required to query the store for a
+// channel's uptime and a blocking response channel on which the result is sent.
+type uptimeRequest struct {
+	channelID    uint64
+	startTime    time.Time
+	endTime      time.Time
+	responseChan chan uptimeResponse
+}
+
+// uptimeResponse contains the response to an uptimeRequest and an error if one
+// occurred.
+type uptimeResponse struct {
+	uptime time.Duration
+	err    error
+}
+
+// NewChannelEventStore initializes an event store with the config provided.
+// Note that this function does not start the main event loop, Start() must be
+// called.
+func NewChannelEventStore(config *Config) *ChannelEventStore {
+	store := &ChannelEventStore{
+		cfg:              config,
+		channels:         make(map[uint64]*chanEventLog),
+		peers:            make(map[route.Vertex]bool),
+		lifespanRequests: make(chan lifespanRequest),
+		uptimeRequests:   make(chan uptimeRequest),
+		quit:             make(chan struct{}),
+	}
+
+	return store
+}
+
+// Start adds all existing open channels to the event store and starts the main
+// loop which records channel and peer events, and serves requests for
+// information from the store. If this function fails, it cancels its existing
+// subscriptions and returns an error.
+func (c *ChannelEventStore) Start() error {
+	// Create a subscription to channel events.
+	channelClient, err := c.cfg.SubscribeChannelEvents()
+	if err != nil {
+		return err
+	}
+
+	// Create a subscription to peer events. If an error occurs, cancel the
+	// existing subscription to channel events and return.
+	peerClient, err := c.cfg.SubscribePeerEvents()
+	if err != nil {
+		channelClient.Cancel()
+		return err
+	}
+
+	// cancel should be called to cancel all subscriptions if an error occurs.
+	cancel := func() {
+		channelClient.Cancel()
+		peerClient.Cancel()
+	}
+
+	// Add the existing set of channels to the event store. This is required
+	// because channel events will not be triggered for channels that exist
+	// at startup time.
+	channels, err := c.cfg.GetOpenChannels()
+	if err != nil {
+		cancel()
+		return err
+	}
+
+	log.Infof("Adding %v channels to event store", len(channels))
+
+	for _, ch := range channels {
+		peerKey, err := route.NewVertexFromBytes(
+			ch.IdentityPub.SerializeCompressed(),
+		)
+		if err != nil {
+			cancel()
+			return err
+		}
+
+		// Add existing channels to the channel store with an initial peer
+		// online or offline event.
+		c.addChannel(ch.ShortChanID().ToUint64(), peerKey)
+	}
+
+	// Start a goroutine that consumes events from all subscriptions.
+	c.wg.Add(1)
+	go c.consume(&subscriptions{
+		channelUpdates: channelClient.Updates(),
+		peerUpdates:    peerClient.Updates(),
+		cancel:         cancel,
+	})
+
+	return nil
+}
+
+// Stop terminates all goroutines started by the event store.
+func (c *ChannelEventStore) Stop() {
+	log.Info("Stopping event store")
+
+	// Stop the consume goroutine.
+	close(c.quit)
+
+	c.wg.Wait()
+}
+
+// addChannel adds a new channel to the ChannelEventStore's map of channels with
+// an initial peer online state (if the peer is online). If the channel is
+// already present in the map, the function returns early. This function should
+// be called to add existing channels on startup and when open channel events
+// are observed.
+func (c *ChannelEventStore) addChannel(channelID uint64, peer route.Vertex) {
+	// Check for the unexpected case where the channel is already in the store.
+	_, ok := c.channels[channelID]
+	if ok {
+		log.Errorf("Channel %v duplicated in channel store", channelID)
+		return
+	}
+
+	eventLog := newEventLog(channelID, peer, time.Now)
+
+	// If the peer is online, add a peer online event to indicate its starting
+	// state.
+	online := c.peers[peer]
+	if online {
+		eventLog.add(peerOnlineEvent)
+	}
+
+	c.channels[channelID] = eventLog
+}
+
+// closeChannel records a closed time for a channel, and returns early is the
+// channel is not known to the event store.
+func (c *ChannelEventStore) closeChannel(channelID uint64) {
+	// Check for the unexpected case where the channel is unknown to the store.
+	eventLog, ok := c.channels[channelID]
+	if !ok {
+		log.Errorf("Close channel %v unknown to store", channelID)
+		return
+	}
+
+	eventLog.close()
+}
+
+// peerEvent adds a peer online or offline event to all channels we currently
+// have open with a peer.
+func (c *ChannelEventStore) peerEvent(peer route.Vertex, event eventType) {
+	// Track current online status of peers in the channelEventStore.
+	c.peers[peer] = event == peerOnlineEvent
+
+	for _, eventLog := range c.channels {
+		if eventLog.peer == peer {
+			eventLog.add(event)
+		}
+	}
+}
+
+// subscriptions abstracts away from subscription clients to allow for mocking.
+type subscriptions struct {
+	channelUpdates <-chan interface{}
+	peerUpdates    <-chan interface{}
+	cancel         func()
+}
+
+// consume is the event store's main loop. It consumes subscriptions to update
+// the event store with channel and peer events, and serves requests for channel
+// uptime and lifespan.
+func (c *ChannelEventStore) consume(subscriptions *subscriptions) {
+	defer c.wg.Done()
+	defer subscriptions.cancel()
+
+	// Consume events until the channel is closed.
+	for {
+		select {
+		// Process channel opened and closed events.
+		case e := <-subscriptions.channelUpdates:
+			switch event := e.(type) {
+			// A new channel has been opened, we must add the channel to the
+			// store and record a channel open event.
+			case channelnotifier.OpenChannelEvent:
+				chanID := event.Channel.ShortChanID().ToUint64()
+
+				peerKey, err := route.NewVertexFromBytes(
+					event.Channel.IdentityPub.SerializeCompressed(),
+				)
+				if err != nil {
+					log.Errorf("Could not get vertex from: %v",
+						event.Channel.IdentityPub.SerializeCompressed())
+				}
+
+				c.addChannel(chanID, peerKey)
+
+			// A channel has been closed, we must remove the channel from the
+			// store and record a channel closed event.
+			case channelnotifier.ClosedChannelEvent:
+				c.closeChannel(event.CloseSummary.ShortChanID.ToUint64())
+			}
+
+		// Process peer online and offline events.
+		case e := <-subscriptions.peerUpdates:
+			switch event := e.(type) {
+			// We have reestablished a connection with our peer, and should
+			// record an online event for any channels with that peer.
+			case peernotifier.PeerOnlineEvent:
+				c.peerEvent(event.PubKey, peerOnlineEvent)
+
+			// We have lost a connection with our peer, and should record an
+			// offline event for any channels with that peer.
+			case peernotifier.PeerOfflineEvent:
+				c.peerEvent(event.PubKey, peerOfflineEvent)
+			}
+
+		// Serve all requests for channel lifetime.
+		case req := <-c.lifespanRequests:
+			var resp lifespanResponse
+
+			channel, ok := c.channels[req.channelID]
+			if !ok {
+				resp.err = fmt.Errorf("channel %v not found", req.channelID)
+			} else {
+				resp.start = channel.openedAt
+				resp.end = channel.closedAt
+			}
+
+			req.responseChan <- resp
+
+		// Serve requests for channel uptime.
+		case req := <-c.uptimeRequests:
+			var resp uptimeResponse
+
+			channel, ok := c.channels[req.channelID]
+			if !ok {
+				resp.err = fmt.Errorf("channel %v not found", req.channelID)
+			} else {
+				uptime, err := channel.uptime(req.startTime, req.endTime)
+				resp.uptime = uptime
+				resp.err = err
+			}
+
+			req.responseChan <- resp
+
+		// Exit if the store receives the signal to shutdown.
+		case <-c.quit:
+			return
+		}
+	}
+}
+
+// GetLifespan returns the opening and closing time observed for a channel and
+// a boolean to indicate whether the channel is known the the event store. If
+// the channel is still open, a zero close time is returned.
+func (c *ChannelEventStore) GetLifespan(chanID uint64) (time.Time, time.Time, error) {
+	request := lifespanRequest{
+		channelID:    chanID,
+		responseChan: make(chan lifespanResponse),
+	}
+
+	// Send a request for the channel's lifespan to the main event loop, or
+	// return early with an error if the store has already received a shutdown
+	// signal.
+	select {
+	case c.lifespanRequests <- request:
+	case <-c.quit:
+		return time.Time{}, time.Time{}, errShuttingDown
+	}
+
+	// Return the response we receive on the response channel or exit early if
+	// the store is instructed to exit.
+	select {
+	case resp := <-request.responseChan:
+		return resp.start, resp.end, resp.err
+
+	case <-c.quit:
+		return time.Time{}, time.Time{}, errShuttingDown
+	}
+}
+
+// GetUptime returns the uptime of a channel over a period and an error if the
+// channel cannot be found or the uptime calculation fails.
+func (c *ChannelEventStore) GetUptime(chanID uint64, startTime,
+	endTime time.Time) (time.Duration, error) {
+
+	request := uptimeRequest{
+		channelID:    chanID,
+		startTime:    startTime,
+		endTime:      endTime,
+		responseChan: make(chan uptimeResponse),
+	}
+
+	// Send a request for the channel's uptime to the main event loop, or
+	// return early with an error if the store has already received a shutdown
+	// signal.
+	select {
+	case c.uptimeRequests <- request:
+	case <-c.quit:
+		return 0, errShuttingDown
+	}
+
+	// Return the response we receive on the response channel or exit early if
+	// the store is instructed to exit.
+	select {
+	case resp := <-request.responseChan:
+		return resp.uptime, resp.err
+
+	case <-c.quit:
+		return 0, errShuttingDown
+	}
+}
diff --git a/chanfitness/log.go b/chanfitness/log.go
new file mode 100644
index 000000000..626f7538d
--- /dev/null
+++ b/chanfitness/log.go
@@ -0,0 +1,32 @@
+package chanfitness
+
+import (
+	"github.com/btcsuite/btclog"
+	"github.com/lightningnetwork/lnd/build"
+)
+
+// Subsystem defines the logging code for this subsystem.
+const Subsystem = "CHFT"
+
+// log is a logger that is initialized with no output filters.  This
+// means the package will not perform any logging by default until the caller
+// requests it.
+var log btclog.Logger
+
+// The default amount of logging is none.
+func init() {
+	UseLogger(build.NewSubLogger(Subsystem, nil))
+}
+
+// DisableLog disables all library log output.  Logging output is disabled
+// by default until UseLogger is called.
+func DisableLog() {
+	UseLogger(btclog.Disabled)
+}
+
+// UseLogger uses a specified Logger to output package logging info.
+// This should be used in preference to SetLogWriter if the caller is also
+// using btclog.
+func UseLogger(logger btclog.Logger) {
+	log = logger
+}
diff --git a/channelnotifier/channelnotifier.go b/channelnotifier/channelnotifier.go
index fa6cbcddd..b2e5c6740 100644
--- a/channelnotifier/channelnotifier.go
+++ b/channelnotifier/channelnotifier.go
@@ -73,7 +73,11 @@ func (c *ChannelNotifier) Stop() {
 }
 
 // SubscribeChannelEvents returns a subscribe.Client that will receive updates
-// any time the Server is made aware of a new event.
+// any time the Server is made aware of a new event. The subscription provides
+// channel events from the point of subscription onwards.
+//
+// TODO(carlaKC): update  to allow subscriptions to specify a block height from
+// which we would like to subscribe to events.
 func (c *ChannelNotifier) SubscribeChannelEvents() (*subscribe.Client, error) {
 	return c.ntfnServer.Subscribe()
 }
diff --git a/lnrpc/rpc.pb.go b/lnrpc/rpc.pb.go
index ba8462609..9fdd10111 100644
--- a/lnrpc/rpc.pb.go
+++ b/lnrpc/rpc.pb.go
@@ -2629,7 +2629,16 @@ type Channel struct {
 	//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"`
+	StaticRemoteKey bool `protobuf:"varint,22,opt,name=static_remote_key,proto3" json:"static_remote_key,omitempty"`
+	//*
+	//The number of seconds that the channel has been monitored by the channel
+	//scoring system. Scores are currently not persisted, so this value may be
+	//less than the lifetime of the channel [EXPERIMENTAL].
+	Lifetime int64 `protobuf:"varint,23,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
+	//*
+	//The number of seconds that the remote peer has been observed as being online
+	//by the channel scoring system over the lifetime of the channel [EXPERIMENTAL].
+	Uptime               int64    `protobuf:"varint,24,opt,name=uptime,proto3" json:"uptime,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -2814,6 +2823,20 @@ func (m *Channel) GetStaticRemoteKey() bool {
 	return false
 }
 
+func (m *Channel) GetLifetime() int64 {
+	if m != nil {
+		return m.Lifetime
+	}
+	return 0
+}
+
+func (m *Channel) GetUptime() int64 {
+	if m != nil {
+		return m.Uptime
+	}
+	return 0
+}
+
 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"`
@@ -9307,545 +9330,547 @@ func init() {
 func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) }
 
 var fileDescriptor_77a6da22d6a3feb1 = []byte{
-	// 8608 bytes of a gzipped FileDescriptorProto
+	// 8631 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7d, 0x5d, 0x6c, 0x1c, 0x5b,
-	0xb6, 0x56, 0xfa, 0xcf, 0xee, 0x5e, 0xdd, 0xb6, 0xdb, 0xdb, 0x8e, 0xdd, 0xe9, 0x93, 0x93, 0xf8,
-	0xd4, 0xe4, 0x9e, 0x64, 0x32, 0x67, 0x9c, 0x9c, 0xcc, 0xcc, 0x21, 0xf7, 0x84, 0xcb, 0xc5, 0x7f,
-	0x89, 0x33, 0xc7, 0x71, 0x3c, 0xe5, 0x64, 0xc2, 0xcc, 0xdc, 0xab, 0x9e, 0x72, 0xf7, 0xb6, 0x5d,
-	0x93, 0xee, 0xaa, 0x9e, 0xaa, 0x6a, 0x3b, 0x9e, 0xc3, 0x41, 0x02, 0x21, 0x84, 0x78, 0x41, 0x07,
-	0x5e, 0x00, 0x81, 0xae, 0x34, 0x17, 0x89, 0x7b, 0x41, 0x08, 0x78, 0x40, 0x02, 0x74, 0x25, 0x1e,
-	0x78, 0x40, 0x42, 0x42, 0x3c, 0xf0, 0x80, 0xc4, 0x03, 0x57, 0x08, 0x24, 0x34, 0x42, 0xf0, 0x80,
-	0xc4, 0x3b, 0x5a, 0x6b, 0xff, 0xd4, 0xde, 0x55, 0xd5, 0x71, 0xce, 0xcc, 0x70, 0x9f, 0xdc, 0xfb,
-	0xdb, 0xbb, 0xf6, 0xef, 0x5a, 0x6b, 0xaf, 0xb5, 0xf6, 0xda, 0xdb, 0xd0, 0x88, 0xc6, 0xfd, 0xf5,
-	0x71, 0x14, 0x26, 0x21, 0xab, 0x0d, 0x83, 0x68, 0xdc, 0xef, 0x5e, 0x3f, 0x09, 0xc3, 0x93, 0x21,
-	0xbf, 0xe7, 0x8d, 0xfd, 0x7b, 0x5e, 0x10, 0x84, 0x89, 0x97, 0xf8, 0x61, 0x10, 0x8b, 0x42, 0xce,
-	0x8f, 0x61, 0xfe, 0x09, 0x0f, 0x0e, 0x39, 0x1f, 0xb8, 0xfc, 0xa7, 0x13, 0x1e, 0x27, 0xec, 0x1b,
-	0xb0, 0xe8, 0xf1, 0x9f, 0x71, 0x3e, 0xe8, 0x8d, 0xbd, 0x38, 0x1e, 0x9f, 0x46, 0x5e, 0xcc, 0x3b,
-	0xa5, 0xb5, 0xd2, 0x9d, 0x96, 0xdb, 0x16, 0x19, 0x07, 0x1a, 0x67, 0x1f, 0x40, 0x2b, 0xc6, 0xa2,
-	0x3c, 0x48, 0xa2, 0x70, 0x7c, 0xd1, 0x29, 0x53, 0xb9, 0x26, 0x62, 0x3b, 0x02, 0x72, 0x86, 0xb0,
-	0xa0, 0x5b, 0x88, 0xc7, 0x61, 0x10, 0x73, 0x76, 0x1f, 0x96, 0xfb, 0xfe, 0xf8, 0x94, 0x47, 0x3d,
-	0xfa, 0x78, 0x14, 0xf0, 0x51, 0x18, 0xf8, 0xfd, 0x4e, 0x69, 0xad, 0x72, 0xa7, 0xe1, 0x32, 0x91,
-	0x87, 0x5f, 0x3c, 0x93, 0x39, 0xec, 0x36, 0x2c, 0xf0, 0x40, 0xe0, 0x7c, 0x40, 0x5f, 0xc9, 0xa6,
-	0xe6, 0x53, 0x18, 0x3f, 0x70, 0xfe, 0x6a, 0x19, 0x16, 0x9f, 0x06, 0x7e, 0xf2, 0xca, 0x1b, 0x0e,
-	0x79, 0xa2, 0xc6, 0x74, 0x1b, 0x16, 0xce, 0x09, 0xa0, 0x31, 0x9d, 0x87, 0xd1, 0x40, 0x8e, 0x68,
-	0x5e, 0xc0, 0x07, 0x12, 0x9d, 0xda, 0xb3, 0xf2, 0xd4, 0x9e, 0x15, 0x4e, 0x57, 0x65, 0xca, 0x74,
-	0xdd, 0x86, 0x85, 0x88, 0xf7, 0xc3, 0x33, 0x1e, 0x5d, 0xf4, 0xce, 0xfd, 0x60, 0x10, 0x9e, 0x77,
-	0xaa, 0x6b, 0xa5, 0x3b, 0x35, 0x77, 0x5e, 0xc1, 0xaf, 0x08, 0x65, 0x9b, 0xb0, 0xd0, 0x3f, 0xf5,
-	0x82, 0x80, 0x0f, 0x7b, 0x47, 0x5e, 0xff, 0xf5, 0x64, 0x1c, 0x77, 0x6a, 0x6b, 0xa5, 0x3b, 0xcd,
-	0x07, 0xd7, 0xd6, 0x69, 0x55, 0xd7, 0xb7, 0x4e, 0xbd, 0x60, 0x93, 0x72, 0x0e, 0x03, 0x6f, 0x1c,
-	0x9f, 0x86, 0x89, 0x3b, 0x2f, 0xbf, 0x10, 0x70, 0xec, 0x2c, 0x03, 0x33, 0x67, 0x42, 0xcc, 0xbd,
-	0xf3, 0x8f, 0x4a, 0xb0, 0xf4, 0x32, 0x18, 0x86, 0xfd, 0xd7, 0xbf, 0xe4, 0x14, 0x15, 0x8c, 0xa1,
-	0xfc, 0xae, 0x63, 0xa8, 0x7c, 0xd5, 0x31, 0xac, 0xc0, 0xb2, 0xdd, 0x59, 0x39, 0x0a, 0x0e, 0x57,
-	0xf1, 0xeb, 0x13, 0xae, 0xba, 0xa5, 0x86, 0xf1, 0x75, 0x68, 0xf7, 0x27, 0x51, 0xc4, 0x83, 0xdc,
-	0x38, 0x16, 0x24, 0xae, 0x07, 0xf2, 0x01, 0xb4, 0x02, 0x7e, 0x9e, 0x16, 0x93, 0xb4, 0x1b, 0xf0,
-	0x73, 0x55, 0xc4, 0xe9, 0xc0, 0x4a, 0xb6, 0x19, 0xd9, 0x81, 0xff, 0x5a, 0x82, 0xea, 0xcb, 0xe4,
-	0x4d, 0xc8, 0xd6, 0xa1, 0x9a, 0x5c, 0x8c, 0x05, 0x87, 0xcc, 0x3f, 0x60, 0x72, 0x68, 0x1b, 0x83,
-	0x41, 0xc4, 0xe3, 0xf8, 0xc5, 0xc5, 0x98, 0xbb, 0x2d, 0x4f, 0x24, 0x7a, 0x58, 0x8e, 0x75, 0x60,
-	0x56, 0xa6, 0xa9, 0xc1, 0x86, 0xab, 0x92, 0xec, 0x06, 0x80, 0x37, 0x0a, 0x27, 0x41, 0xd2, 0x8b,
-	0xbd, 0x84, 0xa6, 0xaa, 0xe2, 0x1a, 0x08, 0xbb, 0x0e, 0x8d, 0xf1, 0xeb, 0x5e, 0xdc, 0x8f, 0xfc,
-	0x71, 0x42, 0x64, 0xd3, 0x70, 0x53, 0x80, 0x7d, 0x03, 0xea, 0xe1, 0x24, 0x19, 0x87, 0x7e, 0x90,
-	0x48, 0x52, 0x59, 0x90, 0x7d, 0x79, 0x3e, 0x49, 0x0e, 0x10, 0x76, 0x75, 0x01, 0x76, 0x0b, 0xe6,
-	0xfa, 0x61, 0x70, 0xec, 0x47, 0x23, 0x21, 0x0c, 0x3a, 0x33, 0xd4, 0x9a, 0x0d, 0x3a, 0xff, 0xb2,
-	0x0c, 0xcd, 0x17, 0x91, 0x17, 0xc4, 0x5e, 0x1f, 0x01, 0xec, 0x7a, 0xf2, 0xa6, 0x77, 0xea, 0xc5,
-	0xa7, 0x34, 0xda, 0x86, 0xab, 0x92, 0x6c, 0x05, 0x66, 0x44, 0x47, 0x69, 0x4c, 0x15, 0x57, 0xa6,
-	0xd8, 0x47, 0xb0, 0x18, 0x4c, 0x46, 0x3d, 0xbb, 0xad, 0x0a, 0x51, 0x4b, 0x3e, 0x03, 0x27, 0xe0,
-	0x08, 0xd7, 0x5a, 0x34, 0x21, 0x46, 0x68, 0x20, 0xcc, 0x81, 0x96, 0x4c, 0x71, 0xff, 0xe4, 0x54,
-	0x0c, 0xb3, 0xe6, 0x5a, 0x18, 0xd6, 0x91, 0xf8, 0x23, 0xde, 0x8b, 0x13, 0x6f, 0x34, 0x96, 0xc3,
-	0x32, 0x10, 0xca, 0x0f, 0x13, 0x6f, 0xd8, 0x3b, 0xe6, 0x3c, 0xee, 0xcc, 0xca, 0x7c, 0x8d, 0xb0,
-	0x0f, 0x61, 0x7e, 0xc0, 0xe3, 0xa4, 0x27, 0x17, 0x85, 0xc7, 0x9d, 0x3a, 0xb1, 0x7e, 0x06, 0xc5,
-	0x7a, 0x22, 0xef, 0xbc, 0x87, 0x13, 0xc0, 0xdf, 0x74, 0x1a, 0xa2, 0xaf, 0x29, 0x82, 0x94, 0xf3,
-	0x84, 0x27, 0xc6, 0xec, 0xc5, 0x92, 0x42, 0x9d, 0x3d, 0x60, 0x06, 0xbc, 0xcd, 0x13, 0xcf, 0x1f,
-	0xc6, 0xec, 0x13, 0x68, 0x25, 0x46, 0x61, 0x12, 0x85, 0x4d, 0x4d, 0x4e, 0xc6, 0x07, 0xae, 0x55,
-	0xce, 0x79, 0x02, 0xf5, 0xc7, 0x9c, 0xef, 0xf9, 0x23, 0x3f, 0x61, 0x2b, 0x50, 0x3b, 0xf6, 0xdf,
-	0x70, 0x41, 0xf0, 0x95, 0xdd, 0x2b, 0xae, 0x48, 0xb2, 0x2e, 0xcc, 0x8e, 0x79, 0xd4, 0xe7, 0x6a,
-	0x79, 0x76, 0xaf, 0xb8, 0x0a, 0xd8, 0x9c, 0x85, 0xda, 0x10, 0x3f, 0x76, 0xfe, 0x57, 0x05, 0x9a,
-	0x87, 0x3c, 0xd0, 0x8c, 0xc4, 0xa0, 0x8a, 0x43, 0x96, 0xcc, 0x43, 0xbf, 0xd9, 0x4d, 0x68, 0xd2,
-	0x34, 0xc4, 0x49, 0xe4, 0x07, 0x27, 0x92, 0x7e, 0x01, 0xa1, 0x43, 0x42, 0x58, 0x1b, 0x2a, 0xde,
-	0x48, 0xd1, 0x2e, 0xfe, 0x44, 0x26, 0x1b, 0x7b, 0x17, 0x23, 0xe4, 0x47, 0xbd, 0xaa, 0x2d, 0xb7,
-	0x29, 0xb1, 0x5d, 0x5c, 0xd6, 0x75, 0x58, 0x32, 0x8b, 0xa8, 0xda, 0x6b, 0x54, 0xfb, 0xa2, 0x51,
-	0x52, 0x36, 0x72, 0x1b, 0x16, 0x54, 0xf9, 0x48, 0x74, 0x96, 0xd6, 0xb9, 0xe1, 0xce, 0x4b, 0x58,
-	0x0d, 0xe1, 0x0e, 0xb4, 0x8f, 0xfd, 0xc0, 0x1b, 0xf6, 0xfa, 0xc3, 0xe4, 0xac, 0x37, 0xe0, 0xc3,
-	0xc4, 0xa3, 0x15, 0xaf, 0xb9, 0xf3, 0x84, 0x6f, 0x0d, 0x93, 0xb3, 0x6d, 0x44, 0xd9, 0x47, 0xd0,
-	0x38, 0xe6, 0xbc, 0x47, 0x33, 0xd1, 0xa9, 0x5b, 0xdc, 0xa3, 0x66, 0xd7, 0xad, 0x1f, 0xab, 0x79,
-	0xfe, 0x08, 0xda, 0xe1, 0x24, 0x39, 0x09, 0xfd, 0xe0, 0xa4, 0x87, 0xf2, 0xaa, 0xe7, 0x0f, 0x88,
-	0x02, 0xaa, 0x9b, 0xe5, 0xfb, 0x25, 0x77, 0x5e, 0xe5, 0xa1, 0xe4, 0x78, 0x3a, 0x60, 0xef, 0x03,
-	0x50, 0xfb, 0xa2, 0x72, 0x58, 0x2b, 0xdd, 0x99, 0x73, 0x1b, 0x88, 0x88, 0xca, 0x3e, 0x85, 0x3a,
-	0xcd, 0x69, 0x32, 0x3c, 0xeb, 0x34, 0x69, 0xd1, 0x6f, 0xca, 0x96, 0x8d, 0xd5, 0x58, 0xdf, 0xe6,
-	0x71, 0xf2, 0x62, 0x78, 0x86, 0x7b, 0xea, 0x85, 0x3b, 0x3b, 0x10, 0xa9, 0xee, 0xa7, 0xd0, 0x32,
-	0x33, 0x70, 0xfa, 0x5f, 0xf3, 0x0b, 0x5a, 0xb2, 0xaa, 0x8b, 0x3f, 0xd9, 0x32, 0xd4, 0xce, 0xbc,
-	0xe1, 0x84, 0x4b, 0xe1, 0x26, 0x12, 0x9f, 0x96, 0x1f, 0x96, 0x9c, 0x7f, 0x51, 0x82, 0x96, 0x68,
-	0x41, 0x6e, 0xca, 0xb7, 0x60, 0x4e, 0x4d, 0x2b, 0x8f, 0xa2, 0x30, 0x92, 0x3c, 0x6e, 0x83, 0xec,
-	0x2e, 0xb4, 0x15, 0x30, 0x8e, 0xb8, 0x3f, 0xf2, 0x4e, 0x54, 0xdd, 0x39, 0x9c, 0x3d, 0x48, 0x6b,
-	0x8c, 0xc2, 0x49, 0xc2, 0xa5, 0xf8, 0x6f, 0xc9, 0xf1, 0xb9, 0x88, 0xb9, 0x76, 0x11, 0xe4, 0xf1,
-	0x02, 0x7a, 0xb1, 0x30, 0xe7, 0xcb, 0x12, 0x30, 0xec, 0xfa, 0x8b, 0x50, 0x54, 0x21, 0x97, 0x3b,
-	0x4b, 0x6a, 0xa5, 0x77, 0x26, 0xb5, 0xf2, 0x34, 0x52, 0x73, 0xa0, 0x26, 0x7a, 0x5e, 0x2d, 0xe8,
-	0xb9, 0xc8, 0xfa, 0x6e, 0xb5, 0x5e, 0x69, 0x57, 0x9d, 0xff, 0x5c, 0x81, 0xe5, 0x2d, 0xb1, 0x77,
-	0x6d, 0xf4, 0xfb, 0x7c, 0xac, 0x89, 0xf0, 0x26, 0x34, 0x83, 0x70, 0xc0, 0x7b, 0xe3, 0xc9, 0x91,
-	0x5a, 0x9b, 0x96, 0x0b, 0x08, 0x1d, 0x10, 0x42, 0xf4, 0x71, 0xea, 0xf9, 0x81, 0xe8, 0xb4, 0x98,
-	0xcb, 0x06, 0x21, 0xd4, 0xe5, 0x0f, 0x61, 0x61, 0xcc, 0x83, 0x81, 0x49, 0x6b, 0x42, 0xbb, 0x98,
-	0x93, 0xb0, 0x24, 0xb3, 0x9b, 0xd0, 0x3c, 0x9e, 0x88, 0x72, 0xc8, 0x82, 0x55, 0xa2, 0x01, 0x90,
-	0xd0, 0xc6, 0x28, 0x61, 0xd7, 0xa0, 0x3e, 0x9e, 0xc4, 0xa7, 0x94, 0x5b, 0xa3, 0xdc, 0x59, 0x4c,
-	0x63, 0xd6, 0xfb, 0x00, 0x83, 0x49, 0x9c, 0x48, 0x12, 0x9d, 0xa1, 0xcc, 0x06, 0x22, 0x82, 0x44,
-	0xbf, 0x09, 0x4b, 0x23, 0xef, 0x4d, 0x8f, 0x68, 0xa7, 0xe7, 0x07, 0xbd, 0xe3, 0x21, 0x89, 0xdf,
-	0x59, 0x2a, 0xd7, 0x1e, 0x79, 0x6f, 0xbe, 0x8f, 0x39, 0x4f, 0x83, 0xc7, 0x84, 0x23, 0x7f, 0xaa,
-	0x7d, 0x3f, 0xe2, 0x31, 0x8f, 0xce, 0x38, 0xb1, 0x54, 0x55, 0x6f, 0xee, 0xae, 0x40, 0xb1, 0x47,
-	0x23, 0x1c, 0x77, 0x32, 0xec, 0x0b, 0xfe, 0x71, 0x67, 0x47, 0x7e, 0xb0, 0x9b, 0x0c, 0xfb, 0xec,
-	0x3a, 0x00, 0x32, 0xe4, 0x98, 0x47, 0xbd, 0xd7, 0xe7, 0xc4, 0x34, 0x55, 0x62, 0xc0, 0x03, 0x1e,
-	0x7d, 0x76, 0xce, 0xde, 0x83, 0x46, 0x3f, 0x26, 0x8e, 0xf6, 0x2e, 0x3a, 0x4d, 0xe2, 0xa8, 0x7a,
-	0x3f, 0x46, 0x5e, 0xf6, 0x2e, 0xd8, 0x47, 0xc0, 0xb0, 0xb7, 0x1e, 0xad, 0x02, 0x1f, 0x50, 0xf5,
-	0x71, 0xa7, 0x45, 0xa5, 0xb0, 0xb3, 0x1b, 0x32, 0x03, 0xdb, 0x89, 0xd9, 0xd7, 0x60, 0x4e, 0x75,
-	0xf6, 0x78, 0xe8, 0x9d, 0xc4, 0x9d, 0x39, 0x2a, 0xd8, 0x92, 0xe0, 0x63, 0xc4, 0x9c, 0x57, 0x42,
-	0xdb, 0x30, 0xd6, 0x56, 0xf2, 0x0c, 0xee, 0x7b, 0x84, 0xd0, 0xba, 0xd6, 0x5d, 0x99, 0x2a, 0x5a,
-	0xb4, 0x72, 0xc1, 0xa2, 0x39, 0x3f, 0x2f, 0x41, 0x4b, 0xd6, 0x4c, 0x5b, 0x34, 0xbb, 0x0f, 0x4c,
-	0xad, 0x62, 0xf2, 0xc6, 0x1f, 0xf4, 0x8e, 0x2e, 0x12, 0x1e, 0x0b, 0xa2, 0xd9, 0xbd, 0xe2, 0x16,
-	0xe4, 0xa1, 0x30, 0xb2, 0xd0, 0x38, 0x89, 0x04, 0x3d, 0xef, 0x5e, 0x71, 0x73, 0x39, 0xc8, 0x5e,
-	0xa8, 0x04, 0x4c, 0x92, 0x9e, 0x1f, 0x0c, 0xf8, 0x1b, 0x22, 0xa5, 0x39, 0xd7, 0xc2, 0x36, 0xe7,
-	0xa1, 0x65, 0x7e, 0xe7, 0xfc, 0x04, 0xea, 0x4a, 0x85, 0xa0, 0xed, 0x33, 0xd3, 0x2f, 0xd7, 0x40,
-	0x58, 0x17, 0xea, 0x76, 0x2f, 0xdc, 0xfa, 0x57, 0x69, 0xdb, 0xf9, 0x33, 0xd0, 0xde, 0x43, 0x22,
-	0x0a, 0x90, 0x68, 0xa5, 0x5e, 0xb4, 0x02, 0x33, 0x06, 0xf3, 0x34, 0x5c, 0x99, 0xc2, 0x1d, 0xea,
-	0x34, 0x8c, 0x13, 0xd9, 0x0e, 0xfd, 0x76, 0xfe, 0x6d, 0x09, 0xd8, 0x4e, 0x9c, 0xf8, 0x23, 0x2f,
-	0xe1, 0x8f, 0xb9, 0x16, 0x0d, 0xcf, 0xa1, 0x85, 0xb5, 0xbd, 0x08, 0x37, 0x84, 0x96, 0x22, 0x76,
-	0xd7, 0x6f, 0x48, 0x76, 0xce, 0x7f, 0xb0, 0x6e, 0x96, 0x16, 0x42, 0xd7, 0xaa, 0x00, 0xb9, 0x2d,
-	0xf1, 0xa2, 0x13, 0x9e, 0x90, 0x0a, 0x23, 0x15, 0x60, 0x10, 0xd0, 0x56, 0x18, 0x1c, 0x77, 0x7f,
-	0x1b, 0x16, 0x73, 0x75, 0x98, 0xf2, 0xb9, 0x51, 0x20, 0x9f, 0x2b, 0xa6, 0x7c, 0xee, 0xc3, 0x92,
-	0xd5, 0x2f, 0x49, 0x71, 0x1d, 0x98, 0x45, 0xc6, 0x40, 0x0d, 0x91, 0x76, 0x79, 0x57, 0x25, 0xd9,
-	0x03, 0x58, 0x3e, 0xe6, 0x3c, 0xf2, 0x12, 0x4a, 0x12, 0xeb, 0xe0, 0x9a, 0xc8, 0x9a, 0x0b, 0xf3,
-	0x9c, 0xff, 0x56, 0x82, 0x05, 0x94, 0xa4, 0xcf, 0xbc, 0xe0, 0x42, 0xcd, 0xd5, 0x5e, 0xe1, 0x5c,
-	0xdd, 0x31, 0x36, 0x25, 0xa3, 0xf4, 0x57, 0x9d, 0xa8, 0x4a, 0x76, 0xa2, 0xd8, 0x1a, 0xb4, 0xac,
-	0xee, 0xd6, 0x84, 0x4a, 0x16, 0x7b, 0xc9, 0x01, 0x8f, 0x36, 0x2f, 0x12, 0xfe, 0xab, 0x4f, 0xe5,
-	0x87, 0xd0, 0x4e, 0xbb, 0x2d, 0xe7, 0x91, 0x41, 0x15, 0x09, 0x53, 0x56, 0x40, 0xbf, 0x9d, 0xbf,
-	0x5b, 0x12, 0x05, 0xb7, 0x42, 0x5f, 0xab, 0x6b, 0x58, 0x10, 0xb5, 0x3e, 0x55, 0x10, 0x7f, 0x4f,
-	0x55, 0x77, 0x7f, 0xf5, 0xc1, 0xa2, 0x4c, 0x8c, 0x79, 0x30, 0xe8, 0x79, 0xc3, 0x21, 0x09, 0xe2,
-	0xba, 0x3b, 0x8b, 0xe9, 0x8d, 0xe1, 0xd0, 0xb9, 0x0d, 0x8b, 0x46, 0xef, 0xde, 0x32, 0x8e, 0x7d,
-	0x60, 0x7b, 0x7e, 0x9c, 0xbc, 0x0c, 0xe2, 0xb1, 0xa1, 0x0d, 0xbd, 0x07, 0x0d, 0x94, 0xb6, 0xd8,
-	0x33, 0xc1, 0xb9, 0x35, 0x17, 0xc5, 0x2f, 0xf6, 0x2b, 0xa6, 0x4c, 0xef, 0x8d, 0xcc, 0x2c, 0xcb,
-	0x4c, 0xef, 0x0d, 0x65, 0x3a, 0x0f, 0x61, 0xc9, 0xaa, 0x4f, 0x36, 0xfd, 0x01, 0xd4, 0x26, 0xc9,
-	0x9b, 0x50, 0xe9, 0xaa, 0x4d, 0x49, 0x21, 0x68, 0x15, 0xb9, 0x22, 0xc7, 0x79, 0x04, 0x8b, 0xfb,
-	0xfc, 0x5c, 0x32, 0xb2, 0xea, 0xc8, 0x87, 0x97, 0x5a, 0x4c, 0x94, 0xef, 0xac, 0x03, 0x33, 0x3f,
-	0x4e, 0x19, 0x40, 0xd9, 0x4f, 0x25, 0xcb, 0x7e, 0x72, 0x3e, 0x04, 0x76, 0xe8, 0x9f, 0x04, 0xcf,
-	0x78, 0x1c, 0x7b, 0x27, 0x9a, 0xf5, 0xdb, 0x50, 0x19, 0xc5, 0x27, 0x52, 0x54, 0xe1, 0x4f, 0xe7,
-	0x5b, 0xb0, 0x64, 0x95, 0x93, 0x15, 0x5f, 0x87, 0x46, 0xec, 0x9f, 0x04, 0x5e, 0x32, 0x89, 0xb8,
-	0xac, 0x3a, 0x05, 0x9c, 0xc7, 0xb0, 0xfc, 0x7d, 0x1e, 0xf9, 0xc7, 0x17, 0x97, 0x55, 0x6f, 0xd7,
-	0x53, 0xce, 0xd6, 0xb3, 0x03, 0x57, 0x33, 0xf5, 0xc8, 0xe6, 0x05, 0xf9, 0xca, 0x95, 0xac, 0xbb,
-	0x22, 0x61, 0xc8, 0xbe, 0xb2, 0x29, 0xfb, 0x9c, 0x97, 0xc0, 0xb6, 0xc2, 0x20, 0xe0, 0xfd, 0xe4,
-	0x80, 0xf3, 0x28, 0x75, 0xdd, 0xa4, 0xb4, 0xda, 0x7c, 0xb0, 0x2a, 0x67, 0x36, 0x2b, 0x50, 0x25,
-	0x11, 0x33, 0xa8, 0x8e, 0x79, 0x34, 0xa2, 0x8a, 0xeb, 0x2e, 0xfd, 0x76, 0xae, 0xc2, 0x92, 0x55,
-	0xad, 0x34, 0x76, 0x3f, 0x86, 0xab, 0xdb, 0x7e, 0xdc, 0xcf, 0x37, 0xd8, 0x81, 0xd9, 0xf1, 0xe4,
-	0xa8, 0x97, 0x72, 0xa2, 0x4a, 0xa2, 0xfd, 0x93, 0xfd, 0x44, 0x56, 0xf6, 0x57, 0x4a, 0x50, 0xdd,
-	0x7d, 0xb1, 0xb7, 0x85, 0x7b, 0x85, 0x1f, 0xf4, 0xc3, 0x11, 0x6a, 0x60, 0x62, 0xd0, 0x3a, 0x3d,
-	0x95, 0xc3, 0xae, 0x43, 0x83, 0x14, 0x37, 0x34, 0xf9, 0xa4, 0x1e, 0x94, 0x02, 0x68, 0x6e, 0xf2,
-	0x37, 0x63, 0x3f, 0x22, 0x7b, 0x52, 0x59, 0x89, 0x55, 0xda, 0x66, 0xf2, 0x19, 0xce, 0xff, 0x9e,
-	0x81, 0x59, 0xb9, 0xf9, 0x8a, 0x8d, 0x3c, 0xf1, 0xcf, 0x78, 0xba, 0x91, 0x63, 0x0a, 0x95, 0xe2,
-	0x88, 0x8f, 0xc2, 0x44, 0xeb, 0x6f, 0x62, 0x19, 0x6c, 0x90, 0xcc, 0x69, 0xa9, 0x44, 0x08, 0x03,
-	0xbc, 0x22, 0x4a, 0x59, 0x20, 0xbb, 0x0e, 0xb3, 0x4a, 0x19, 0xa8, 0x6a, 0x6b, 0x41, 0x41, 0x38,
-	0x1b, 0x7d, 0x6f, 0xec, 0xf5, 0xfd, 0xe4, 0x42, 0x8a, 0x05, 0x9d, 0xc6, 0xfa, 0x87, 0x61, 0xdf,
-	0x1b, 0xf6, 0x8e, 0xbc, 0xa1, 0x17, 0xf4, 0xb9, 0x32, 0xd7, 0x2d, 0x10, 0x4d, 0x57, 0xd9, 0x2d,
-	0x55, 0x4c, 0x98, 0xb7, 0x19, 0x14, 0xf7, 0xf0, 0x7e, 0x38, 0x1a, 0xf9, 0x09, 0x5a, 0xbc, 0xa4,
-	0x9a, 0x55, 0x5c, 0x03, 0x11, 0xce, 0x01, 0x4a, 0x9d, 0x8b, 0x19, 0x6c, 0x28, 0xe7, 0x80, 0x01,
-	0x62, 0x2d, 0x19, 0x0d, 0xad, 0xe2, 0x1a, 0x08, 0xae, 0xc5, 0x24, 0x88, 0x79, 0x92, 0x0c, 0xf9,
-	0x40, 0x77, 0xa8, 0x49, 0xc5, 0xf2, 0x19, 0xec, 0x3e, 0x2c, 0x09, 0x23, 0x3c, 0xf6, 0x92, 0x30,
-	0x3e, 0xf5, 0xe3, 0x5e, 0x8c, 0xe6, 0x6a, 0x8b, 0xca, 0x17, 0x65, 0xb1, 0x87, 0xb0, 0x9a, 0x81,
-	0x23, 0xde, 0xe7, 0xfe, 0x19, 0x1f, 0x90, 0x0a, 0x57, 0x71, 0xa7, 0x65, 0xb3, 0x35, 0x68, 0x06,
-	0x93, 0x51, 0x6f, 0x32, 0x1e, 0x78, 0xa8, 0xc4, 0xcc, 0x93, 0x72, 0x69, 0x42, 0xec, 0x63, 0x50,
-	0x7a, 0x9a, 0xd4, 0x1e, 0x17, 0x2c, 0x09, 0x87, 0xd4, 0xeb, 0xda, 0x25, 0x90, 0x30, 0x53, 0x95,
-	0xb4, 0x2d, 0x8d, 0x3c, 0x05, 0x10, 0x9f, 0x44, 0xfe, 0x99, 0x97, 0xf0, 0xce, 0xa2, 0x10, 0xea,
-	0x32, 0x89, 0xdf, 0xf9, 0x81, 0x9f, 0xf8, 0x5e, 0x12, 0x46, 0x1d, 0x46, 0x79, 0x29, 0x80, 0x93,
-	0x48, 0xf4, 0x11, 0x27, 0x5e, 0x32, 0x89, 0xa5, 0x86, 0xba, 0x24, 0xac, 0x95, 0x5c, 0x06, 0xfb,
-	0x04, 0x56, 0x04, 0x45, 0x50, 0x96, 0xd4, 0xbd, 0x49, 0x55, 0x58, 0xa6, 0x19, 0x99, 0x92, 0x8b,
-	0x53, 0x29, 0x49, 0x24, 0xf7, 0xe1, 0x55, 0x31, 0x95, 0x53, 0xb2, 0xb1, 0x7f, 0xd8, 0x03, 0xbf,
-	0xdf, 0x93, 0x25, 0x90, 0x45, 0x56, 0x68, 0x14, 0xf9, 0x0c, 0xe7, 0xf7, 0x4a, 0x62, 0x23, 0x91,
-	0x4c, 0x17, 0x1b, 0x26, 0x92, 0x60, 0xb7, 0x5e, 0x18, 0x0c, 0x2f, 0x24, 0x07, 0x82, 0x80, 0x9e,
-	0x07, 0xc3, 0x0b, 0x54, 0xd2, 0xfd, 0xc0, 0x2c, 0x22, 0x64, 0x56, 0x4b, 0x81, 0x54, 0xe8, 0x26,
-	0x34, 0xc7, 0x93, 0xa3, 0xa1, 0xdf, 0x17, 0x45, 0x2a, 0xa2, 0x16, 0x01, 0x51, 0x01, 0xb4, 0x0f,
-	0xc5, 0xac, 0x8b, 0x12, 0x55, 0x2a, 0xd1, 0x94, 0x18, 0x16, 0x71, 0x36, 0x61, 0xd9, 0xee, 0xa0,
-	0x14, 0xce, 0x77, 0xa1, 0x2e, 0x79, 0x39, 0x96, 0x46, 0xfa, 0xbc, 0xe1, 0xc3, 0x44, 0x93, 0x46,
-	0xe7, 0x3b, 0xff, 0xaa, 0x0a, 0x4b, 0x12, 0xdd, 0x1a, 0x86, 0x31, 0x3f, 0x9c, 0x8c, 0x46, 0x5e,
-	0x54, 0x20, 0x24, 0x4a, 0x97, 0x08, 0x89, 0x72, 0x5e, 0x48, 0xdc, 0xb0, 0x6c, 0x45, 0x21, 0x65,
-	0x0c, 0x84, 0xdd, 0x81, 0x85, 0xfe, 0x30, 0x8c, 0x85, 0xea, 0x6e, 0xba, 0xd1, 0xb2, 0x70, 0x5e,
-	0xb0, 0xd5, 0x8a, 0x04, 0x9b, 0x29, 0x94, 0x66, 0x32, 0x42, 0xc9, 0x81, 0x16, 0x56, 0xca, 0x95,
-	0x9c, 0x9d, 0x95, 0x86, 0x93, 0x81, 0x61, 0x7f, 0xb2, 0x22, 0x40, 0xc8, 0x9b, 0x85, 0x22, 0x01,
-	0xe0, 0x8f, 0x38, 0xc9, 0x71, 0xa3, 0x74, 0x43, 0x0a, 0x80, 0x7c, 0x16, 0x7b, 0x0c, 0x20, 0xda,
-	0x22, 0x65, 0x02, 0x48, 0x99, 0xf8, 0xd0, 0x5e, 0x15, 0x73, 0xfe, 0xd7, 0x31, 0x31, 0x89, 0x38,
-	0x29, 0x18, 0xc6, 0x97, 0xce, 0x5f, 0x2b, 0x41, 0xd3, 0xc8, 0x63, 0x57, 0x61, 0x71, 0xeb, 0xf9,
-	0xf3, 0x83, 0x1d, 0x77, 0xe3, 0xc5, 0xd3, 0xef, 0xef, 0xf4, 0xb6, 0xf6, 0x9e, 0x1f, 0xee, 0xb4,
-	0xaf, 0x20, 0xbc, 0xf7, 0x7c, 0x6b, 0x63, 0xaf, 0xf7, 0xf8, 0xb9, 0xbb, 0xa5, 0xe0, 0x12, 0x5b,
-	0x01, 0xe6, 0xee, 0x3c, 0x7b, 0xfe, 0x62, 0xc7, 0xc2, 0xcb, 0xac, 0x0d, 0xad, 0x4d, 0x77, 0x67,
-	0x63, 0x6b, 0x57, 0x22, 0x15, 0xb6, 0x0c, 0xed, 0xc7, 0x2f, 0xf7, 0xb7, 0x9f, 0xee, 0x3f, 0xe9,
-	0x6d, 0x6d, 0xec, 0x6f, 0xed, 0xec, 0xed, 0x6c, 0xb7, 0xab, 0x6c, 0x0e, 0x1a, 0x1b, 0x9b, 0x1b,
-	0xfb, 0xdb, 0xcf, 0xf7, 0x77, 0xb6, 0xdb, 0x35, 0xe7, 0xbf, 0x94, 0xe0, 0x2a, 0xf5, 0x7a, 0x90,
-	0x65, 0x92, 0x35, 0x68, 0xf6, 0xc3, 0x70, 0x8c, 0x4a, 0x7c, 0xba, 0x4d, 0x99, 0x10, 0x32, 0x80,
-	0x60, 0xf0, 0xe3, 0x30, 0xea, 0x73, 0xc9, 0x23, 0x40, 0xd0, 0x63, 0x44, 0x90, 0x01, 0xe4, 0xf2,
-	0x8a, 0x12, 0x82, 0x45, 0x9a, 0x02, 0x13, 0x45, 0x56, 0x60, 0xe6, 0x28, 0xe2, 0x5e, 0xff, 0x54,
-	0x72, 0x87, 0x4c, 0xb1, 0xaf, 0xa7, 0x56, 0x66, 0x1f, 0x67, 0x7f, 0xc8, 0x07, 0x44, 0x31, 0x75,
-	0x77, 0x41, 0xe2, 0x5b, 0x12, 0x46, 0x89, 0xe6, 0x1d, 0x79, 0xc1, 0x20, 0x0c, 0xf8, 0x40, 0xaa,
-	0xb0, 0x29, 0xe0, 0x1c, 0xc0, 0x4a, 0x76, 0x7c, 0x92, 0xc7, 0x3e, 0x31, 0x78, 0x4c, 0x68, 0x94,
-	0xdd, 0xe9, 0xab, 0x69, 0xf0, 0xdb, 0x1f, 0x97, 0xa1, 0x8a, 0x0a, 0xc6, 0x74, 0x65, 0xc4, 0xd4,
-	0x19, 0x2b, 0x39, 0x9f, 0x3b, 0x19, 0xae, 0x62, 0xbb, 0x91, 0x4e, 0x93, 0x14, 0x49, 0xf3, 0x23,
-	0xde, 0x3f, 0x93, 0x6e, 0x13, 0x03, 0x41, 0x06, 0x41, 0x85, 0x9e, 0xbe, 0x96, 0x0c, 0xa2, 0xd2,
-	0x2a, 0x8f, 0xbe, 0x9c, 0x4d, 0xf3, 0xe8, 0xbb, 0x0e, 0xcc, 0xfa, 0xc1, 0x51, 0x38, 0x09, 0x06,
-	0xc4, 0x10, 0x75, 0x57, 0x25, 0xc9, 0xcb, 0x4f, 0x8c, 0xea, 0x8f, 0x14, 0xf9, 0xa7, 0x00, 0x7b,
-	0x00, 0x8d, 0xf8, 0x22, 0xe8, 0x9b, 0x34, 0xbf, 0x2c, 0x67, 0x09, 0xe7, 0x60, 0xfd, 0xf0, 0x22,
-	0xe8, 0x13, 0x85, 0xa7, 0xc5, 0x9c, 0xdf, 0x86, 0xba, 0x82, 0x91, 0x2c, 0x5f, 0xee, 0x7f, 0xb6,
-	0xff, 0xfc, 0xd5, 0x7e, 0xef, 0xf0, 0x07, 0xfb, 0x5b, 0xed, 0x2b, 0x6c, 0x01, 0x9a, 0x1b, 0x5b,
-	0x44, 0xe9, 0x04, 0x94, 0xb0, 0xc8, 0xc1, 0xc6, 0xe1, 0xa1, 0x46, 0xca, 0x0e, 0x43, 0xa3, 0x3c,
-	0x26, 0x2d, 0x4e, 0x7b, 0xb1, 0x3f, 0x81, 0x45, 0x03, 0x4b, 0x2d, 0x82, 0x31, 0x02, 0x19, 0x8b,
-	0x80, 0xd4, 0x3f, 0x91, 0xe3, 0xb4, 0x61, 0xfe, 0x09, 0x4f, 0x9e, 0x06, 0xc7, 0xa1, 0xaa, 0xe9,
-	0x7f, 0x54, 0x61, 0x41, 0x43, 0xb2, 0xa2, 0x3b, 0xb0, 0xe0, 0x0f, 0x78, 0x90, 0xf8, 0xc9, 0x45,
-	0xcf, 0xb2, 0xfd, 0xb3, 0x30, 0xaa, 0xcd, 0xde, 0xd0, 0xf7, 0xd4, 0x61, 0x8a, 0x48, 0xa0, 0x2d,
-	0x8c, 0xfb, 0xb9, 0xe9, 0x83, 0x21, 0xba, 0x12, 0x2e, 0x87, 0xc2, 0x3c, 0x94, 0x40, 0x88, 0xcb,
-	0x6d, 0x46, 0x7f, 0x22, 0xd4, 0xc7, 0xa2, 0x2c, 0x5c, 0x2a, 0x51, 0x13, 0x0e, 0xb9, 0x26, 0xf6,
-	0x7c, 0x0d, 0xe4, 0x4e, 0x2b, 0x66, 0x84, 0x7c, 0xcc, 0x9e, 0x56, 0x18, 0x27, 0x1e, 0xf5, 0xdc,
-	0x89, 0x07, 0xca, 0xcf, 0x8b, 0xa0, 0xcf, 0x07, 0xbd, 0x24, 0xec, 0x91, 0x9c, 0x27, 0x92, 0xa8,
-	0xbb, 0x59, 0x18, 0xf7, 0x8d, 0x84, 0xc7, 0x49, 0xc0, 0x85, 0x8b, 0xb9, 0xbe, 0x59, 0xee, 0x94,
-	0x5c, 0x05, 0xa1, 0xae, 0x3f, 0x89, 0xfc, 0xb8, 0xd3, 0xa2, 0xb3, 0x0c, 0xfa, 0xcd, 0xbe, 0x0d,
-	0x57, 0x8f, 0x78, 0x9c, 0xf4, 0x4e, 0xb9, 0x37, 0xe0, 0x11, 0x91, 0x97, 0x38, 0x34, 0x11, 0xea,
-	0x53, 0x71, 0x26, 0x12, 0xee, 0x19, 0x8f, 0x62, 0x3f, 0x0c, 0x48, 0x71, 0x6a, 0xb8, 0x2a, 0x89,
-	0xf5, 0xe1, 0xe0, 0xf5, 0x46, 0xad, 0x67, 0x70, 0x81, 0x06, 0x5e, 0x9c, 0xc9, 0x6e, 0xc1, 0x0c,
-	0x0d, 0x20, 0xee, 0xb4, 0x89, 0x66, 0x5a, 0x29, 0xcf, 0xfb, 0x81, 0x2b, 0xf3, 0x70, 0x95, 0xfb,
-	0xe1, 0x30, 0x8c, 0x48, 0x7b, 0x6a, 0xb8, 0x22, 0x61, 0xcf, 0xce, 0x49, 0xe4, 0x8d, 0x4f, 0xa5,
-	0x06, 0x95, 0x85, 0xbf, 0x5b, 0xad, 0x37, 0xdb, 0x2d, 0xe7, 0x4f, 0x41, 0x8d, 0xaa, 0xa5, 0xea,
-	0x68, 0x32, 0x4b, 0xb2, 0x3a, 0x42, 0x3b, 0x30, 0x1b, 0xf0, 0xe4, 0x3c, 0x8c, 0x5e, 0xab, 0x93,
-	0x39, 0x99, 0x74, 0x7e, 0x46, 0xd6, 0x96, 0x3e, 0xa9, 0x7a, 0x49, 0x6a, 0x22, 0xda, 0xcc, 0x62,
-	0xa9, 0xe2, 0x53, 0x4f, 0x1a, 0x80, 0x75, 0x02, 0x0e, 0x4f, 0x3d, 0x94, 0xb5, 0xd6, 0xea, 0x0b,
-	0x9b, 0xba, 0x49, 0xd8, 0xae, 0x58, 0xfc, 0x5b, 0x30, 0xaf, 0xce, 0xc0, 0xe2, 0xde, 0x90, 0x1f,
-	0x27, 0xca, 0x23, 0x16, 0x4c, 0x46, 0x64, 0x78, 0xef, 0xf1, 0xe3, 0xc4, 0xd9, 0x87, 0x45, 0x29,
-	0xff, 0x9e, 0x8f, 0xb9, 0x6a, 0xfa, 0x37, 0x8b, 0x74, 0x89, 0xe6, 0x83, 0x25, 0x5b, 0x60, 0x8a,
-	0x53, 0x3f, 0xbb, 0xa4, 0xe3, 0x02, 0x33, 0xe5, 0xa9, 0xac, 0x50, 0x6e, 0xe6, 0xca, 0xe7, 0x27,
-	0x87, 0x63, 0x61, 0x38, 0x3f, 0xf1, 0xa4, 0xdf, 0x57, 0x27, 0x97, 0x75, 0x57, 0x25, 0x9d, 0x3f,
-	0x28, 0xc1, 0x12, 0xd5, 0xa6, 0xb4, 0x21, 0xb9, 0x67, 0x3d, 0xfc, 0x0a, 0xdd, 0x54, 0x1e, 0x57,
-	0xe1, 0x67, 0x5c, 0x86, 0x9a, 0xb9, 0x8b, 0x89, 0xc4, 0x57, 0xf7, 0xaf, 0x54, 0xb3, 0xfe, 0x15,
-	0xe7, 0x6f, 0x95, 0x60, 0x51, 0x6c, 0x24, 0xa4, 0x39, 0xcb, 0xe1, 0xff, 0x69, 0x98, 0x13, 0x1a,
-	0x81, 0x94, 0x0a, 0xb2, 0xa3, 0xa9, 0x68, 0x25, 0x54, 0x14, 0xde, 0xbd, 0xe2, 0xda, 0x85, 0xd9,
-	0x23, 0xd2, 0xca, 0x82, 0x1e, 0xa1, 0x05, 0x67, 0xdc, 0xf6, 0x5c, 0xef, 0x5e, 0x71, 0x8d, 0xe2,
-	0x9b, 0x75, 0x98, 0x11, 0x66, 0x87, 0xf3, 0x04, 0xe6, 0xac, 0x86, 0x2c, 0xdf, 0x4e, 0x4b, 0xf8,
-	0x76, 0x72, 0x4e, 0xd4, 0x72, 0x81, 0x13, 0xf5, 0x9f, 0x55, 0x80, 0x21, 0xb1, 0x64, 0x56, 0x63,
-	0xcd, 0x3e, 0x89, 0x50, 0xc7, 0xdd, 0x29, 0xc4, 0xd6, 0x81, 0x19, 0x49, 0x75, 0x3a, 0x22, 0xb6,
-	0xcc, 0x82, 0x1c, 0x14, 0xb3, 0x52, 0xe3, 0xd0, 0x27, 0x0f, 0x64, 0xb3, 0x8b, 0x69, 0x2f, 0xcc,
-	0xc3, 0x5d, 0x91, 0x8e, 0x21, 0xd0, 0xba, 0x90, 0x76, 0xae, 0x4a, 0x67, 0xd7, 0x77, 0xe6, 0xd2,
-	0xf5, 0x9d, 0xcd, 0xf9, 0xcf, 0x0c, 0x4b, 0xab, 0x6e, 0x5b, 0x5a, 0xb7, 0x60, 0x4e, 0x9d, 0x36,
-	0xf4, 0x46, 0xd8, 0xba, 0x34, 0x6b, 0x2d, 0x90, 0xdd, 0x85, 0xb6, 0x32, 0x76, 0xb4, 0x39, 0x27,
-	0xce, 0xec, 0x72, 0x38, 0xca, 0xff, 0xd4, 0xa3, 0xd6, 0xa4, 0xce, 0xa6, 0x00, 0xd9, 0x46, 0x48,
-	0x21, 0xbd, 0x49, 0x20, 0x8f, 0xb9, 0xf9, 0x80, 0x0c, 0x5a, 0xb4, 0x8d, 0xb2, 0x19, 0xce, 0xdf,
-	0x28, 0x41, 0x1b, 0xd7, 0xcc, 0x22, 0xcb, 0x4f, 0x81, 0xb8, 0xe2, 0x1d, 0xa9, 0xd2, 0x2a, 0xcb,
-	0x1e, 0x42, 0x83, 0xd2, 0xe1, 0x98, 0x07, 0x92, 0x26, 0x3b, 0x36, 0x4d, 0xa6, 0xf2, 0x64, 0xf7,
-	0x8a, 0x9b, 0x16, 0x36, 0x28, 0xf2, 0x3f, 0x94, 0xa0, 0x29, 0x5b, 0xf9, 0xa5, 0x3d, 0x36, 0x5d,
-	0x23, 0x2e, 0x41, 0x50, 0x52, 0x1a, 0x86, 0x70, 0x07, 0x16, 0x46, 0x5e, 0x32, 0x89, 0x70, 0x3f,
-	0xb7, 0xbc, 0x35, 0x59, 0x18, 0x37, 0x67, 0x12, 0x9d, 0x71, 0x2f, 0xf1, 0x87, 0x3d, 0x95, 0x2b,
-	0x23, 0x00, 0x8a, 0xb2, 0x50, 0x82, 0xc4, 0x89, 0x77, 0xc2, 0xe5, 0xbe, 0x2b, 0x12, 0x4e, 0x07,
-	0x56, 0x0e, 0xd2, 0x13, 0x18, 0x43, 0xbf, 0x76, 0xfe, 0xc9, 0x1c, 0xac, 0xe6, 0xb2, 0x74, 0xbc,
-	0x92, 0x74, 0x41, 0x0c, 0xfd, 0xd1, 0x51, 0xa8, 0x8d, 0x93, 0x92, 0xe9, 0x9d, 0xb0, 0xb2, 0xd8,
-	0x09, 0x5c, 0x55, 0x0a, 0x06, 0xce, 0x69, 0xba, 0x19, 0x96, 0x69, 0x97, 0xfb, 0xd8, 0x5e, 0xc2,
-	0x6c, 0x83, 0x0a, 0x37, 0x99, 0xb8, 0xb8, 0x3e, 0x76, 0x0a, 0x1d, 0xad, 0xc9, 0x48, 0x61, 0x6d,
-	0x68, 0x3b, 0xd8, 0xd6, 0x47, 0x97, 0xb4, 0x65, 0xa9, 0xe3, 0xee, 0xd4, 0xda, 0xd8, 0x05, 0xdc,
-	0x50, 0x79, 0x24, 0x8d, 0xf3, 0xed, 0x55, 0xdf, 0x69, 0x6c, 0x64, 0x68, 0xd8, 0x8d, 0x5e, 0x52,
-	0x31, 0xfb, 0x09, 0xac, 0x9c, 0x7b, 0x7e, 0xa2, 0xba, 0x65, 0xe8, 0x16, 0x35, 0x6a, 0xf2, 0xc1,
-	0x25, 0x4d, 0xbe, 0x12, 0x1f, 0x5b, 0x5b, 0xd4, 0x94, 0x1a, 0xbb, 0x7f, 0x54, 0x86, 0x79, 0xbb,
-	0x1e, 0x24, 0x53, 0xc9, 0xfb, 0x4a, 0x06, 0x2a, 0x6d, 0x34, 0x03, 0xe7, 0x6d, 0xfc, 0x72, 0x91,
-	0x8d, 0x6f, 0x5a, 0xd5, 0x95, 0xcb, 0x5c, 0x7d, 0xd5, 0x77, 0x73, 0xf5, 0xd5, 0x0a, 0x5d, 0x7d,
-	0xd3, 0x3d, 0x42, 0x33, 0xbf, 0xac, 0x47, 0x68, 0xf6, 0xad, 0x1e, 0xa1, 0xee, 0xff, 0x2d, 0x01,
-	0xcb, 0x53, 0x2f, 0x7b, 0x22, 0xdc, 0x1a, 0x01, 0x1f, 0x4a, 0x21, 0xf6, 0xcd, 0x77, 0xe3, 0x00,
-	0xb5, 0x5a, 0xea, 0x6b, 0x64, 0x45, 0x33, 0x68, 0xc8, 0x54, 0xaf, 0xe6, 0xdc, 0xa2, 0xac, 0x8c,
-	0xbb, 0xb3, 0x7a, 0xb9, 0xbb, 0xb3, 0x76, 0xb9, 0xbb, 0x73, 0x26, 0xeb, 0xee, 0xec, 0xfe, 0xe5,
-	0x12, 0x2c, 0x15, 0x90, 0xd9, 0xaf, 0x6f, 0xe0, 0x48, 0x18, 0x96, 0xf4, 0x29, 0x4b, 0xc2, 0x30,
-	0xc1, 0xee, 0x9f, 0x87, 0x39, 0x8b, 0xb5, 0x7e, 0x7d, 0xed, 0x67, 0x35, 0x44, 0x41, 0xd9, 0x16,
-	0xd6, 0xfd, 0x9f, 0x65, 0x60, 0x79, 0xf6, 0xfe, 0x13, 0xed, 0x43, 0x7e, 0x9e, 0x2a, 0x05, 0xf3,
-	0xf4, 0xff, 0x75, 0xe7, 0xf9, 0x08, 0x16, 0x65, 0x24, 0xa4, 0xe1, 0xc8, 0x12, 0x14, 0x93, 0xcf,
-	0x40, 0x1d, 0xd9, 0xf6, 0x35, 0xd7, 0xad, 0xc8, 0x2f, 0x63, 0xfb, 0xcd, 0xb8, 0x9c, 0x9d, 0x2e,
-	0x74, 0xe4, 0x0c, 0xed, 0x9c, 0xf1, 0x20, 0x39, 0x9c, 0x1c, 0x89, 0x50, 0x40, 0x3f, 0x0c, 0x9c,
-	0x7f, 0x5e, 0xd1, 0x6a, 0x3e, 0x65, 0x4a, 0x85, 0xe2, 0xdb, 0xd0, 0x32, 0xb7, 0x0f, 0xb9, 0x1c,
-	0x19, 0x5f, 0x26, 0xaa, 0x12, 0x66, 0x29, 0xb6, 0x0d, 0xf3, 0x24, 0x24, 0x07, 0xfa, 0xbb, 0x32,
-	0x7d, 0xf7, 0x16, 0xff, 0xcc, 0xee, 0x15, 0x37, 0xf3, 0x0d, 0xfb, 0x2d, 0x98, 0xb7, 0x8d, 0x3f,
-	0xa9, 0x95, 0x14, 0x59, 0x03, 0xf8, 0xb9, 0x5d, 0x98, 0x6d, 0x40, 0x3b, 0x6b, 0x3d, 0xca, 0xa8,
-	0x9c, 0x29, 0x15, 0xe4, 0x8a, 0xb3, 0x87, 0xf2, 0xe0, 0xb1, 0x46, 0x7e, 0x93, 0x5b, 0xf6, 0x67,
-	0xc6, 0x34, 0xad, 0x8b, 0x3f, 0xc6, 0x51, 0xe4, 0xef, 0x00, 0xa4, 0x18, 0x6b, 0x43, 0xeb, 0xf9,
-	0xc1, 0xce, 0x7e, 0x6f, 0x6b, 0x77, 0x63, 0x7f, 0x7f, 0x67, 0xaf, 0x7d, 0x85, 0x31, 0x98, 0x27,
-	0x37, 0xdf, 0xb6, 0xc6, 0x4a, 0x88, 0x49, 0xc7, 0x8a, 0xc2, 0xca, 0x6c, 0x19, 0xda, 0x4f, 0xf7,
-	0x33, 0x68, 0x65, 0xb3, 0xa1, 0xf9, 0xc3, 0x59, 0x81, 0x65, 0x11, 0xe9, 0xba, 0x29, 0xc8, 0x43,
-	0x69, 0x27, 0x7f, 0xaf, 0x04, 0x57, 0x33, 0x19, 0x69, 0xd8, 0x96, 0x50, 0x40, 0x6c, 0xad, 0xc4,
-	0x06, 0xe9, 0x20, 0x41, 0xe9, 0x9a, 0x19, 0x09, 0x92, 0xcf, 0x40, 0x9a, 0x37, 0x74, 0xd3, 0x0c,
-	0x27, 0x15, 0x65, 0x39, 0xab, 0x3a, 0x42, 0x26, 0xd3, 0xf1, 0x63, 0x11, 0x41, 0x6b, 0x66, 0xa4,
-	0x07, 0xb9, 0x76, 0x97, 0x55, 0x12, 0xcd, 0x0a, 0x4b, 0xd9, 0xb1, 0xfb, 0x5b, 0x98, 0xe7, 0xfc,
-	0xc3, 0x0a, 0xb0, 0xef, 0x4d, 0x78, 0x74, 0x41, 0xb1, 0x59, 0xda, 0x6b, 0xba, 0x9a, 0xf5, 0x09,
-	0xce, 0x8c, 0x27, 0x47, 0x9f, 0xf1, 0x0b, 0x15, 0xa9, 0x58, 0x4e, 0x23, 0x15, 0x8b, 0xa2, 0x05,
-	0xab, 0x97, 0x47, 0x0b, 0xd6, 0x2e, 0x8b, 0x16, 0xfc, 0x1a, 0xcc, 0xf9, 0x27, 0x41, 0x88, 0x3c,
-	0x8f, 0x7a, 0x42, 0xdc, 0x99, 0x59, 0xab, 0xa0, 0x6d, 0x2d, 0xc1, 0x7d, 0xc4, 0xd8, 0xa3, 0xb4,
-	0x10, 0x1f, 0x9c, 0x50, 0x64, 0xaa, 0x29, 0x05, 0x76, 0x06, 0x27, 0x7c, 0x2f, 0xec, 0x7b, 0x49,
-	0x18, 0x91, 0x63, 0x47, 0x7d, 0x8c, 0x78, 0xcc, 0x6e, 0xc1, 0x7c, 0x1c, 0x4e, 0x50, 0x73, 0x52,
-	0x63, 0x15, 0x9e, 0xa4, 0x96, 0x40, 0x0f, 0xc4, 0x88, 0xd7, 0x61, 0x69, 0x12, 0xf3, 0xde, 0xc8,
-	0x8f, 0x63, 0xdc, 0x1d, 0xfb, 0x61, 0x90, 0x44, 0xe1, 0x50, 0xfa, 0x93, 0x16, 0x27, 0x31, 0x7f,
-	0x26, 0x72, 0xb6, 0x44, 0x06, 0xfb, 0x76, 0xda, 0xa5, 0xb1, 0xe7, 0x47, 0x71, 0x07, 0xa8, 0x4b,
-	0x6a, 0xa4, 0xd8, 0xef, 0x03, 0xcf, 0x8f, 0x74, 0x5f, 0x30, 0x11, 0x67, 0xa2, 0x1d, 0x9b, 0x99,
-	0x68, 0x47, 0x19, 0x2c, 0xb7, 0x0e, 0x75, 0xf5, 0x39, 0x1a, 0xb9, 0xc7, 0x51, 0x38, 0x52, 0x46,
-	0x2e, 0xfe, 0x66, 0xf3, 0x50, 0x4e, 0x42, 0x69, 0xa0, 0x96, 0x93, 0xd0, 0xf9, 0x5d, 0x68, 0x1a,
-	0x33, 0xc0, 0x3e, 0x10, 0xf6, 0x36, 0x2a, 0x54, 0xd2, 0x3a, 0x16, 0xc7, 0x24, 0x0d, 0x89, 0x3e,
-	0x1d, 0xb0, 0x6f, 0xc0, 0xe2, 0xc0, 0x8f, 0x38, 0x05, 0xc9, 0xf6, 0x22, 0x7e, 0xc6, 0xa3, 0x58,
-	0xf9, 0x12, 0xda, 0x3a, 0xc3, 0x15, 0xb8, 0xd3, 0x83, 0x25, 0x8b, 0x74, 0x34, 0x67, 0xcd, 0x50,
-	0x84, 0x9f, 0x72, 0x67, 0xda, 0xd1, 0x7f, 0x32, 0x0f, 0xf7, 0x24, 0xe9, 0x06, 0xe9, 0x8d, 0xa3,
-	0xf0, 0x88, 0x1a, 0x29, 0xb9, 0x16, 0xe6, 0xfc, 0xe3, 0x32, 0x54, 0x76, 0xc3, 0xb1, 0x79, 0xb8,
-	0x53, 0xca, 0x1f, 0xee, 0x48, 0xe5, 0xb1, 0xa7, 0x75, 0x43, 0xb9, 0xc3, 0x5b, 0x20, 0xbb, 0x0b,
-	0xf3, 0xde, 0x28, 0xe9, 0x25, 0x21, 0x2a, 0xcb, 0xe7, 0x5e, 0x24, 0xc2, 0x01, 0x2b, 0x44, 0x16,
-	0x99, 0x1c, 0xb6, 0x0c, 0x15, 0xad, 0xf3, 0x50, 0x01, 0x4c, 0xa2, 0xa5, 0x46, 0x87, 0xe1, 0x17,
-	0xd2, 0x67, 0x29, 0x53, 0xc8, 0xf5, 0xf6, 0xf7, 0xc2, 0x4c, 0x16, 0x3b, 0x57, 0x51, 0x16, 0x2a,
-	0xb2, 0xc8, 0x08, 0xa3, 0x54, 0x2f, 0xd4, 0x69, 0xd3, 0x1b, 0x5f, 0xb7, 0xbd, 0xf1, 0x6b, 0xd0,
-	0x4c, 0x86, 0x67, 0xbd, 0xb1, 0x77, 0x31, 0x0c, 0xbd, 0x81, 0x24, 0x40, 0x13, 0x72, 0x7e, 0x51,
-	0x82, 0x1a, 0xcd, 0x32, 0xee, 0xd3, 0x42, 0x90, 0xe9, 0x13, 0x20, 0x9a, 0xb9, 0x39, 0x37, 0x0b,
-	0x33, 0xc7, 0x0a, 0xec, 0x2e, 0xeb, 0x21, 0x9b, 0xc1, 0xdd, 0x6b, 0xd0, 0x10, 0x29, 0x1d, 0xa4,
-	0x4c, 0x45, 0x52, 0x90, 0xdd, 0x80, 0xea, 0x69, 0x38, 0x56, 0xa6, 0x0c, 0xa8, 0x03, 0xdf, 0x70,
-	0xec, 0x12, 0x9e, 0xf6, 0x07, 0xeb, 0x13, 0x03, 0x17, 0xea, 0x62, 0x16, 0x46, 0x15, 0x5d, 0x57,
-	0x6b, 0x4e, 0x64, 0x06, 0x75, 0x5e, 0xc2, 0x02, 0xf2, 0x82, 0xe1, 0x11, 0x9f, 0x2e, 0xb4, 0xbe,
-	0x8e, 0x7b, 0x60, 0x7f, 0x38, 0x19, 0x70, 0xd3, 0xa0, 0x24, 0x8f, 0xa7, 0xc4, 0x95, 0x2a, 0xe5,
-	0xfc, 0xd3, 0x92, 0xe0, 0x31, 0xac, 0x97, 0xdd, 0x81, 0x2a, 0x8a, 0x9e, 0x8c, 0xff, 0x40, 0xc7,
-	0x85, 0x60, 0x39, 0x97, 0x4a, 0x20, 0x35, 0x93, 0x4f, 0xd2, 0xac, 0x5d, 0x78, 0x24, 0x53, 0x6b,
-	0x4c, 0x8f, 0x2c, 0x63, 0xc4, 0x64, 0x50, 0xb6, 0x6e, 0x1c, 0xe8, 0x54, 0x2d, 0x71, 0xa6, 0xb6,
-	0xdc, 0xc1, 0x09, 0x37, 0x0e, 0x72, 0xfe, 0xb0, 0x04, 0x73, 0x56, 0x9f, 0x90, 0x52, 0x86, 0x5e,
-	0x9c, 0xc8, 0x73, 0x79, 0xb9, 0xf2, 0x26, 0x64, 0x52, 0x59, 0xd9, 0xa6, 0x32, 0x7d, 0x30, 0x50,
-	0x31, 0x0f, 0x06, 0xee, 0x43, 0x23, 0x8d, 0xec, 0xb7, 0x3b, 0x85, 0x2d, 0xaa, 0x08, 0x99, 0xb4,
-	0x50, 0xea, 0x7a, 0xae, 0x19, 0xae, 0x67, 0xe7, 0x11, 0x34, 0x8d, 0xf2, 0xa6, 0xeb, 0xb8, 0x64,
-	0xb9, 0x8e, 0x75, 0xf8, 0x58, 0x39, 0x0d, 0x1f, 0x73, 0xbe, 0x2c, 0xc3, 0x1c, 0x92, 0xb7, 0x1f,
-	0x9c, 0x1c, 0x84, 0x43, 0xbf, 0x7f, 0x41, 0x64, 0xa5, 0x28, 0x59, 0x6e, 0x3d, 0x8a, 0xcc, 0x6d,
-	0x18, 0x59, 0x4e, 0xc7, 0xcc, 0x0a, 0xf9, 0xa0, 0xd3, 0x28, 0x40, 0x90, 0xfd, 0x8e, 0xbc, 0x58,
-	0xf2, 0xa4, 0x54, 0x7d, 0x2d, 0x10, 0xd9, 0x1c, 0x01, 0x0a, 0x06, 0x1c, 0xf9, 0xc3, 0xa1, 0x2f,
-	0xca, 0x0a, 0xc3, 0xa8, 0x28, 0x0b, 0xdb, 0x1c, 0xf8, 0xb1, 0x77, 0x94, 0x1e, 0xfa, 0xe9, 0x34,
-	0x79, 0xd5, 0xbc, 0x37, 0x86, 0x57, 0x4d, 0x44, 0x0f, 0xdb, 0x60, 0x76, 0x21, 0x67, 0x73, 0x0b,
-	0xe9, 0xfc, 0x9b, 0x32, 0x34, 0x0d, 0xb2, 0x40, 0x76, 0x2e, 0x94, 0xf1, 0x06, 0x2a, 0x4f, 0xc3,
-	0x03, 0xcb, 0xd4, 0x36, 0x10, 0x76, 0xcb, 0x6e, 0x95, 0xbc, 0xeb, 0xc4, 0xf0, 0x16, 0x09, 0x5d,
-	0x87, 0x06, 0x92, 0xfe, 0xc7, 0x64, 0xd7, 0xcb, 0x6b, 0x35, 0x1a, 0x50, 0xb9, 0x0f, 0x28, 0xb7,
-	0x96, 0xe6, 0x12, 0xf0, 0xd6, 0xf3, 0xf1, 0x87, 0xd0, 0x92, 0xd5, 0xd0, 0x1a, 0xd3, 0xa0, 0x53,
-	0xe6, 0xb3, 0xd6, 0xdf, 0xb5, 0x4a, 0xaa, 0x2f, 0x1f, 0xa8, 0x2f, 0xeb, 0x97, 0x7d, 0xa9, 0x4a,
-	0x3a, 0x4f, 0x74, 0xe8, 0xc1, 0x93, 0xc8, 0x1b, 0x9f, 0x2a, 0x81, 0x72, 0x1f, 0x96, 0x94, 0xdc,
-	0x98, 0x04, 0x5e, 0x10, 0x84, 0x93, 0xa0, 0xcf, 0x55, 0xa4, 0x59, 0x51, 0x96, 0x33, 0xd0, 0x71,
-	0xc9, 0x54, 0x11, 0xbb, 0x0b, 0x35, 0xa1, 0xbc, 0x88, 0xad, 0xb0, 0x58, 0x84, 0x88, 0x22, 0xec,
-	0x0e, 0xd4, 0x84, 0x0e, 0x53, 0x9e, 0xca, 0xf4, 0xa2, 0x80, 0xb3, 0x0e, 0x0b, 0x14, 0x08, 0x6d,
-	0xc8, 0xbe, 0xf7, 0x8a, 0xb6, 0xc8, 0x99, 0xbe, 0x08, 0x97, 0x5e, 0x06, 0xb6, 0x2f, 0xf8, 0xca,
-	0x3c, 0x40, 0xfc, 0x45, 0x05, 0x9a, 0x06, 0x8c, 0xf2, 0x89, 0x4e, 0x7d, 0x7a, 0x03, 0xdf, 0x1b,
-	0xf1, 0x84, 0x47, 0x92, 0x97, 0x32, 0x28, 0x96, 0xf3, 0xce, 0x4e, 0x7a, 0xe1, 0x24, 0xe9, 0x0d,
-	0xf8, 0x49, 0xc4, 0xb9, 0xdc, 0xbb, 0x33, 0x28, 0x96, 0x43, 0x6a, 0x36, 0xca, 0x89, 0x73, 0x9a,
-	0x0c, 0xaa, 0x8e, 0x03, 0xc5, 0x3c, 0x55, 0xd3, 0xe3, 0x40, 0x31, 0x2b, 0x59, 0xc9, 0x5a, 0x2b,
-	0x90, 0xac, 0x9f, 0xc0, 0x8a, 0x90, 0xa1, 0x52, 0x7a, 0xf4, 0x32, 0xc4, 0x35, 0x25, 0x97, 0xdd,
-	0x85, 0x36, 0xf6, 0x59, 0xb1, 0x46, 0xec, 0xff, 0x4c, 0xf0, 0x58, 0xc9, 0xcd, 0xe1, 0x58, 0x96,
-	0x7c, 0xd4, 0x66, 0x59, 0x11, 0x93, 0x91, 0xc3, 0xa9, 0xac, 0xf7, 0xc6, 0x2e, 0xdb, 0x90, 0x65,
-	0x33, 0x38, 0x7b, 0x08, 0xab, 0x23, 0x3e, 0xf0, 0x3d, 0xbb, 0x0a, 0x72, 0x19, 0x89, 0xe0, 0xb0,
-	0x69, 0xd9, 0xd8, 0x0a, 0xce, 0xc2, 0xcf, 0xc2, 0xd1, 0x91, 0x2f, 0x36, 0x36, 0xe1, 0x4d, 0xaf,
-	0xba, 0x39, 0xdc, 0x99, 0x83, 0xe6, 0x61, 0x12, 0x8e, 0xd5, 0xd2, 0xcf, 0x43, 0x4b, 0x24, 0x65,
-	0x6c, 0xe1, 0x7b, 0x70, 0x8d, 0xe8, 0xf5, 0x45, 0x38, 0x0e, 0x87, 0xe1, 0xc9, 0x85, 0x65, 0x13,
-	0xff, 0xfb, 0x12, 0x2c, 0x59, 0xb9, 0xa9, 0x51, 0x4c, 0x0e, 0x3c, 0x15, 0x10, 0x26, 0x48, 0x7c,
-	0xd1, 0xd8, 0x16, 0x44, 0x41, 0x71, 0x56, 0xf2, 0x52, 0xc6, 0x88, 0x6d, 0xa4, 0xb7, 0x1c, 0xd4,
-	0x87, 0x82, 0xde, 0x3b, 0x79, 0x7a, 0x97, 0xdf, 0xab, 0xfb, 0x0f, 0xaa, 0x8a, 0xdf, 0x92, 0x11,
-	0x34, 0x03, 0x39, 0xe8, 0x8a, 0x1d, 0xf5, 0x60, 0xfa, 0x50, 0x54, 0x0f, 0xfa, 0x1a, 0x8c, 0x9d,
-	0x9f, 0x97, 0x00, 0xd2, 0xde, 0x51, 0xdc, 0x85, 0xde, 0xda, 0xc4, 0x4d, 0x5a, 0x63, 0x1b, 0xfb,
-	0x00, 0x5a, 0xfa, 0xe8, 0x3c, 0xdd, 0x2d, 0x9b, 0x0a, 0x43, 0xed, 0xe2, 0x36, 0x2c, 0x9c, 0x0c,
-	0xc3, 0x23, 0xd2, 0x62, 0x28, 0x58, 0x35, 0x96, 0x11, 0x96, 0xf3, 0x02, 0x7e, 0x2c, 0xd1, 0x74,
-	0x6b, 0xad, 0x9a, 0x5b, 0x6b, 0xf1, 0x46, 0xf9, 0x65, 0x59, 0x9f, 0x5f, 0xa6, 0x33, 0xf1, 0x56,
-	0x2e, 0x67, 0x0f, 0x72, 0x62, 0x7d, 0xca, 0x91, 0x21, 0xe9, 0xfb, 0x07, 0x97, 0xba, 0x54, 0x1f,
-	0xc1, 0x7c, 0x24, 0x64, 0xa6, 0x12, 0xa8, 0xd5, 0xb7, 0x08, 0xd4, 0xb9, 0xc8, 0xda, 0x99, 0xbf,
-	0x0e, 0x6d, 0x6f, 0x70, 0xc6, 0xa3, 0xc4, 0x27, 0x17, 0x13, 0xa9, 0x51, 0x62, 0x80, 0x0b, 0x06,
-	0x4e, 0xda, 0xca, 0x6d, 0x58, 0x90, 0xf1, 0xae, 0xba, 0xa4, 0xbc, 0x97, 0x96, 0xc2, 0x58, 0xd0,
-	0xf9, 0x07, 0xea, 0xb8, 0xd4, 0x5e, 0xdd, 0xb7, 0xcf, 0x8a, 0x39, 0xc2, 0x72, 0x66, 0x84, 0x5f,
-	0x93, 0xc7, 0x97, 0x03, 0xe5, 0xcb, 0xaa, 0x18, 0xb1, 0x58, 0x03, 0x79, 0xdc, 0x6c, 0x4f, 0x6b,
-	0xf5, 0x5d, 0xa6, 0xd5, 0xf9, 0x4f, 0x25, 0x98, 0xdd, 0x0d, 0xc7, 0xbb, 0x38, 0xc5, 0xa8, 0xe3,
-	0x20, 0x9b, 0xe8, 0x60, 0x73, 0x95, 0xbc, 0x24, 0x66, 0xad, 0x50, 0x2b, 0x99, 0xcb, 0x6a, 0x25,
-	0x7f, 0x16, 0xde, 0x23, 0x6f, 0x6a, 0x14, 0x8e, 0xc3, 0x08, 0xd9, 0xd5, 0x1b, 0x0a, 0x15, 0x24,
-	0x0c, 0x92, 0x53, 0x25, 0x4e, 0xdf, 0x56, 0x84, 0x5c, 0x1c, 0x68, 0x79, 0x0a, 0x6b, 0x46, 0x6a,
-	0x51, 0x42, 0xca, 0xe6, 0x33, 0x9c, 0xdf, 0x84, 0x06, 0x59, 0x18, 0x34, 0xb4, 0x8f, 0xa0, 0x71,
-	0x1a, 0x8e, 0x7b, 0xa7, 0x7e, 0x90, 0x28, 0xf6, 0x9f, 0x4f, 0x55, 0xff, 0x5d, 0x9a, 0x14, 0x5d,
-	0xc0, 0xf9, 0xd7, 0x33, 0x30, 0xfb, 0x34, 0x38, 0x0b, 0xfd, 0x3e, 0x1d, 0xd1, 0x8e, 0xf8, 0x28,
-	0x54, 0xe1, 0xf7, 0xf8, 0x1b, 0xa7, 0x83, 0x62, 0x4d, 0xc7, 0x82, 0x78, 0x5b, 0x22, 0x14, 0x43,
-	0x42, 0x74, 0x71, 0x34, 0xbd, 0x3a, 0x27, 0x18, 0xcc, 0x40, 0xd0, 0x3a, 0x8b, 0xcc, 0xab, 0x6f,
-	0x32, 0x95, 0x5e, 0x6f, 0xa8, 0x19, 0xd7, 0x1b, 0xb0, 0x2d, 0x19, 0x49, 0x27, 0x42, 0xad, 0x44,
-	0x5b, 0x12, 0x22, 0x8b, 0x32, 0xe2, 0xc2, 0x1b, 0xae, 0x15, 0x2f, 0xb4, 0x28, 0x4d, 0x10, 0x95,
-	0x33, 0xf1, 0x81, 0x28, 0x23, 0x36, 0x03, 0x13, 0x42, 0xf5, 0x34, 0x7b, 0xe3, 0x52, 0xdc, 0x78,
-	0xcd, 0xc2, 0x28, 0xcb, 0x07, 0x5c, 0x8b, 0x5c, 0x31, 0x0e, 0x10, 0xd7, 0x03, 0xb3, 0xb8, 0x61,
-	0x87, 0x8a, 0xb0, 0x60, 0x65, 0x87, 0x22, 0xc1, 0x78, 0xc3, 0xe1, 0x91, 0xd7, 0x7f, 0x4d, 0x17,
-	0x6e, 0xe9, 0xd0, 0xb4, 0xe1, 0xda, 0x20, 0xc5, 0xc3, 0xa5, 0xab, 0x4a, 0x41, 0x2b, 0x55, 0xd7,
-	0x84, 0xd8, 0x03, 0x68, 0x92, 0x8d, 0x2e, 0xd7, 0x75, 0x9e, 0xd6, 0xb5, 0x6d, 0x1a, 0xf1, 0xb4,
-	0xb2, 0x66, 0x21, 0xf3, 0xf8, 0x78, 0x21, 0x17, 0xa8, 0xeb, 0x0d, 0x06, 0xf2, 0xd4, 0xbd, 0x2d,
-	0xae, 0xc8, 0x69, 0x80, 0xbc, 0x00, 0x62, 0xc2, 0x44, 0x81, 0x45, 0x2a, 0x60, 0x61, 0xec, 0x06,
-	0xd4, 0xd1, 0xea, 0x1b, 0x7b, 0xfe, 0x80, 0xe2, 0x54, 0x84, 0xf1, 0xa9, 0x31, 0xac, 0x43, 0xfd,
-	0xa6, 0x6d, 0x73, 0x89, 0x66, 0xc5, 0xc2, 0x70, 0x6e, 0x74, 0x7a, 0x94, 0x46, 0xf6, 0xda, 0x20,
-	0xfb, 0x98, 0xce, 0x3e, 0x13, 0x4e, 0xe1, 0xbb, 0xf3, 0x0f, 0xde, 0x93, 0x63, 0x96, 0x44, 0xab,
-	0xfe, 0x1e, 0x62, 0x11, 0x57, 0x94, 0x44, 0xa5, 0x4d, 0xb8, 0x9f, 0x57, 0x2c, 0xa5, 0x4d, 0x16,
-	0x25, 0xf7, 0xb3, 0x28, 0xe0, 0x6c, 0x40, 0xcb, 0xac, 0x80, 0xd5, 0xa1, 0xfa, 0xfc, 0x60, 0x67,
-	0xbf, 0x7d, 0x85, 0x35, 0x61, 0xf6, 0x70, 0xe7, 0xc5, 0x8b, 0xbd, 0x9d, 0xed, 0x76, 0x89, 0xb5,
-	0xa0, 0xae, 0xc3, 0x1c, 0xcb, 0x98, 0xda, 0xd8, 0xda, 0xda, 0x39, 0x78, 0xb1, 0xb3, 0xdd, 0xae,
-	0x38, 0x7f, 0x50, 0x86, 0xa6, 0x51, 0xf3, 0x25, 0x7e, 0x91, 0x1b, 0x00, 0x64, 0x49, 0xa4, 0x01,
-	0x0f, 0x55, 0xd7, 0x40, 0x50, 0x32, 0x6a, 0x1b, 0xbb, 0x22, 0x6e, 0x0a, 0xaa, 0x34, 0xcd, 0x17,
-	0x5d, 0xc9, 0x33, 0xbd, 0xfc, 0x35, 0xd7, 0x06, 0x91, 0x96, 0x24, 0x40, 0x51, 0x77, 0x82, 0xc3,
-	0x4c, 0x08, 0xd7, 0x26, 0xe2, 0x71, 0x38, 0x3c, 0xe3, 0xa2, 0x88, 0xd0, 0xc7, 0x2c, 0x0c, 0xdb,
-	0x92, 0x22, 0xc6, 0x88, 0x88, 0xad, 0xb9, 0x36, 0xc8, 0xbe, 0xa9, 0xd6, 0xa6, 0x4e, 0x6b, 0xb3,
-	0x9a, 0x9f, 0x68, 0x73, 0x5d, 0x9c, 0x04, 0xd8, 0xc6, 0x60, 0x20, 0x73, 0xcd, 0x7b, 0x87, 0x91,
-	0x79, 0xc9, 0x55, 0x09, 0x89, 0x02, 0x46, 0x2d, 0x17, 0x33, 0xea, 0x5b, 0xc9, 0xd9, 0xd9, 0x81,
-	0xe6, 0x81, 0x71, 0x6d, 0x96, 0x64, 0x96, 0xba, 0x30, 0x2b, 0x65, 0x9d, 0x81, 0x18, 0xdd, 0x29,
-	0x9b, 0xdd, 0x71, 0xfe, 0x7e, 0x49, 0xdc, 0x44, 0xd2, 0xdd, 0x17, 0x6d, 0x3b, 0xd0, 0xd2, 0x3e,
-	0xdc, 0x34, 0xe0, 0xdb, 0xc2, 0xb0, 0x0c, 0x75, 0xa5, 0x17, 0x1e, 0x1f, 0xc7, 0x5c, 0x85, 0x66,
-	0x5a, 0x98, 0x52, 0x1c, 0x51, 0x15, 0xf5, 0x45, 0x0b, 0xb1, 0x0c, 0xd1, 0xcc, 0xe1, 0x48, 0x24,
-	0xd2, 0x0d, 0xa8, 0x82, 0x52, 0x75, 0x5a, 0xc7, 0xa5, 0x67, 0x67, 0xf9, 0x2e, 0xd4, 0x75, 0xbd,
-	0xf6, 0xae, 0xa0, 0x4a, 0xea, 0x7c, 0xdc, 0x7d, 0xc8, 0xa8, 0xb4, 0x3a, 0x2d, 0x68, 0x35, 0x9f,
-	0xc1, 0xd6, 0x81, 0x1d, 0xfb, 0x51, 0xb6, 0xb8, 0x20, 0xde, 0x82, 0x1c, 0xe7, 0x15, 0x2c, 0x29,
-	0x9e, 0x33, 0x34, 0x5a, 0x7b, 0x11, 0x4b, 0x97, 0xc9, 0xa4, 0x72, 0x5e, 0x26, 0x39, 0x7f, 0x5c,
-	0x81, 0x59, 0xb9, 0xd2, 0xb9, 0xab, 0xd7, 0x62, 0x9d, 0x2d, 0x8c, 0x75, 0xac, 0x4b, 0x76, 0x24,
-	0xc0, 0xe4, 0x4e, 0x94, 0xdb, 0x6b, 0x2a, 0x45, 0x7b, 0x0d, 0x83, 0xea, 0xd8, 0x4b, 0x4e, 0xc9,
-	0xf5, 0xd2, 0x70, 0xe9, 0xb7, 0xf2, 0x52, 0xd6, 0x6c, 0x2f, 0x65, 0xd1, 0x45, 0x73, 0xa1, 0x4e,
-	0xe5, 0x2f, 0x9a, 0x5f, 0x87, 0x86, 0xb8, 0x9c, 0x9c, 0x3a, 0x22, 0x53, 0x00, 0xa9, 0x57, 0x24,
-	0x48, 0x42, 0xc8, 0xfb, 0x2e, 0x29, 0xf2, 0x15, 0x76, 0xb7, 0x6f, 0xc3, 0x8c, 0xb8, 0x70, 0x21,
-	0x43, 0x6f, 0xaf, 0xab, 0x43, 0x3a, 0x51, 0x4e, 0xfd, 0x15, 0x31, 0x3c, 0xae, 0x2c, 0x6b, 0x5e,
-	0xd9, 0x6c, 0xda, 0x57, 0x36, 0x4d, 0xff, 0x69, 0xcb, 0xf6, 0x9f, 0x3a, 0x8f, 0x61, 0xce, 0xaa,
-	0x0e, 0xa5, 0xab, 0x0c, 0xdd, 0x6d, 0x5f, 0x61, 0x73, 0xd0, 0x78, 0xba, 0xdf, 0x7b, 0xbc, 0xf7,
-	0xf4, 0xc9, 0xee, 0x8b, 0x76, 0x09, 0x93, 0x87, 0x2f, 0xb7, 0xb6, 0x76, 0x76, 0xb6, 0x49, 0xda,
-	0x02, 0xcc, 0x3c, 0xde, 0x78, 0xba, 0x47, 0xb2, 0x76, 0x5b, 0xd0, 0xb6, 0xac, 0x4b, 0x1f, 0x8c,
-	0x7c, 0x13, 0x98, 0xb2, 0xfb, 0x29, 0x84, 0x67, 0x3c, 0xe4, 0x89, 0x8a, 0x2a, 0x5f, 0x94, 0x39,
-	0x4f, 0x75, 0x86, 0xba, 0x18, 0x91, 0xd6, 0x92, 0xb2, 0x88, 0x9c, 0xa4, 0x2c, 0x8b, 0xc8, 0xa2,
-	0xae, 0xce, 0x77, 0xba, 0xd0, 0xd9, 0xe6, 0x58, 0xdb, 0xc6, 0x70, 0x98, 0xe9, 0x0e, 0x1a, 0x6e,
-	0x05, 0x79, 0xd2, 0xaa, 0xfb, 0x1e, 0x5c, 0xdd, 0x10, 0x01, 0xe4, 0xbf, 0xae, 0xf8, 0x42, 0xa7,
-	0x03, 0x2b, 0xd9, 0x2a, 0x65, 0x63, 0x8f, 0x61, 0x71, 0x9b, 0x1f, 0x4d, 0x4e, 0xf6, 0xf8, 0x59,
-	0xda, 0x10, 0x83, 0x6a, 0x7c, 0x1a, 0x9e, 0xcb, 0xf9, 0xa1, 0xdf, 0xec, 0x7d, 0x80, 0x21, 0x96,
-	0xe9, 0xc5, 0x63, 0xde, 0x57, 0x17, 0xfd, 0x08, 0x39, 0x1c, 0xf3, 0xbe, 0xf3, 0x09, 0x30, 0xb3,
-	0x1e, 0x39, 0x5f, 0xa8, 0x6b, 0x4d, 0x8e, 0x7a, 0xf1, 0x45, 0x9c, 0xf0, 0x91, 0xba, 0xc1, 0x68,
-	0x42, 0xce, 0x6d, 0x68, 0x1d, 0x78, 0x17, 0x2e, 0xff, 0xa9, 0x7c, 0x82, 0x60, 0x15, 0x66, 0xc7,
-	0xde, 0x05, 0x92, 0xa0, 0x76, 0x06, 0x53, 0xb6, 0xf3, 0x7f, 0xca, 0x30, 0x23, 0x4a, 0x62, 0xad,
-	0x03, 0x1e, 0x27, 0x7e, 0x40, 0x9c, 0xa6, 0x6a, 0x35, 0xa0, 0x1c, 0x6f, 0x97, 0x0b, 0x78, 0x5b,
-	0x7a, 0x28, 0xd4, 0x85, 0x29, 0xc9, 0xc0, 0x16, 0x86, 0x9c, 0x96, 0x06, 0x0a, 0x0b, 0x97, 0x61,
-	0x0a, 0x64, 0x4e, 0x16, 0x52, 0x8d, 0x4e, 0xf4, 0x4f, 0x89, 0x2d, 0xc9, 0xc6, 0x26, 0x54, 0xa8,
-	0x37, 0xce, 0x0a, 0x6e, 0xcf, 0xe9, 0x8d, 0x39, 0xfd, 0xb0, 0xfe, 0x0e, 0xfa, 0xa1, 0x70, 0x5b,
-	0xbc, 0x4d, 0x3f, 0x84, 0x77, 0xd0, 0x0f, 0x1d, 0x06, 0x6d, 0xba, 0x8d, 0x8d, 0x16, 0x88, 0xa2,
-	0xdd, 0xbf, 0x5d, 0x82, 0xb6, 0xa4, 0x22, 0x9d, 0xa7, 0xce, 0xa8, 0xde, 0x76, 0xd5, 0xe7, 0x16,
-	0xcc, 0x91, 0xfd, 0xa3, 0x45, 0x80, 0x3c, 0xef, 0xb1, 0x40, 0x1c, 0x87, 0x0a, 0x33, 0x19, 0xf9,
-	0x43, 0xb9, 0x28, 0x26, 0xa4, 0xa4, 0x48, 0xe4, 0xc9, 0x80, 0xd7, 0x92, 0xab, 0xd3, 0xce, 0x1f,
-	0x95, 0x60, 0xd1, 0xe8, 0xb0, 0xa4, 0xc2, 0x47, 0xd0, 0xd2, 0x8f, 0x1e, 0x70, 0xbd, 0xb9, 0xad,
-	0xda, 0x6c, 0x93, 0x7e, 0x66, 0x15, 0xa6, 0xc5, 0xf4, 0x2e, 0xa8, 0x83, 0xf1, 0x64, 0x24, 0x77,
-	0x15, 0x13, 0x42, 0x42, 0x3a, 0xe7, 0xfc, 0xb5, 0x2e, 0x22, 0xf6, 0x35, 0x0b, 0x23, 0xbf, 0x31,
-	0xda, 0x6d, 0xba, 0x50, 0x55, 0xfa, 0x8d, 0x4d, 0xd0, 0xf9, 0x8b, 0x65, 0x58, 0x12, 0x86, 0xb8,
-	0x74, 0x80, 0xe8, 0x7b, 0xa7, 0x33, 0xc2, 0x27, 0x21, 0x38, 0x72, 0xf7, 0x8a, 0x2b, 0xd3, 0xec,
-	0x3b, 0xef, 0xe8, 0x3c, 0xd0, 0x51, 0xb8, 0x53, 0xd6, 0xa2, 0x52, 0xb4, 0x16, 0x6f, 0x99, 0xe9,
-	0x22, 0x17, 0x7e, 0xad, 0xd8, 0x85, 0xff, 0x4e, 0x2e, 0xf3, 0xcd, 0x59, 0xa8, 0xc5, 0xfd, 0x70,
-	0xcc, 0x9d, 0x15, 0x58, 0xb6, 0xa7, 0x40, 0x0a, 0xaa, 0x9f, 0x97, 0xa0, 0xf3, 0x58, 0x9c, 0xc6,
-	0xf9, 0xc1, 0xc9, 0xae, 0x1f, 0x27, 0x61, 0xa4, 0x2f, 0xf1, 0xdf, 0x00, 0x88, 0x13, 0x2f, 0x92,
-	0x0a, 0xad, 0x50, 0x0d, 0x0c, 0x04, 0x47, 0xc2, 0x83, 0x81, 0xc8, 0x15, 0x2b, 0xa8, 0xd3, 0x39,
-	0xd5, 0x4b, 0x3a, 0x13, 0x2c, 0x05, 0xe6, 0x43, 0x11, 0xbb, 0x8e, 0x5d, 0xe6, 0x67, 0x24, 0xfd,
-	0x85, 0x85, 0x9e, 0x41, 0x9d, 0xdf, 0x2b, 0xc3, 0x42, 0xda, 0x49, 0x8a, 0xb1, 0xb0, 0x65, 0x88,
-	0xd4, 0x5a, 0x52, 0x19, 0x22, 0x1d, 0xff, 0x3d, 0x1f, 0xd5, 0x18, 0xc3, 0x9f, 0x60, 0xa0, 0xec,
-	0x16, 0x34, 0x55, 0x2a, 0x9c, 0x24, 0xc6, 0x6d, 0x5a, 0x13, 0x16, 0x11, 0xa9, 0xa8, 0x48, 0x49,
-	0xa5, 0x50, 0xa6, 0xe8, 0x36, 0xd0, 0x28, 0xa1, 0x2f, 0xc5, 0xcc, 0xab, 0x24, 0x6b, 0x0b, 0x4d,
-	0x44, 0x3c, 0x6c, 0x42, 0x5a, 0x88, 0xb9, 0x43, 0xd7, 0xf5, 0x2b, 0x24, 0x9a, 0x33, 0x45, 0x8d,
-	0x69, 0x38, 0x71, 0xd5, 0x35, 0x21, 0x65, 0xd1, 0x85, 0x13, 0x69, 0x9d, 0x88, 0x77, 0x4c, 0x2c,
-	0xcc, 0xf9, 0xeb, 0x25, 0xb8, 0x56, 0xb0, 0x8c, 0x92, 0x53, 0xb7, 0x61, 0xf1, 0x58, 0x67, 0xaa,
-	0xa9, 0x16, 0xec, 0xba, 0xa2, 0x42, 0x0e, 0xec, 0xe9, 0x75, 0xf3, 0x1f, 0x68, 0xe5, 0x54, 0x2c,
-	0x9e, 0x15, 0x39, 0x9e, 0xcf, 0x70, 0x0e, 0xa0, 0xbb, 0xf3, 0x06, 0x19, 0x7f, 0xcb, 0x7c, 0x8b,
-	0x4d, 0x51, 0xd6, 0x83, 0x9c, 0x60, 0xbb, 0xdc, 0x8d, 0x74, 0x0c, 0x73, 0x56, 0x5d, 0xec, 0x5b,
-	0xef, 0x5a, 0x89, 0xc9, 0xa3, 0x6b, 0x72, 0xd5, 0xc5, 0x63, 0x72, 0x2a, 0x7e, 0xdd, 0x80, 0x9c,
-	0x33, 0x58, 0x78, 0x36, 0x19, 0x26, 0x7e, 0xfa, 0xb0, 0x1c, 0xfb, 0x8e, 0xfc, 0x88, 0xaa, 0x50,
-	0x53, 0x57, 0xd8, 0x94, 0x59, 0x0e, 0x67, 0x6c, 0x84, 0x35, 0xf5, 0xf2, 0x2d, 0xe6, 0x33, 0x9c,
-	0x6b, 0xb0, 0x9a, 0x36, 0x29, 0xe6, 0x4e, 0x6d, 0x0e, 0xbf, 0x5f, 0x12, 0x81, 0x58, 0xf6, 0x3b,
-	0x77, 0xec, 0x09, 0x2c, 0xc5, 0x7e, 0x70, 0x32, 0xe4, 0x66, 0x3d, 0xb1, 0x9c, 0x89, 0xab, 0x76,
-	0xf7, 0xe4, 0x5b, 0x78, 0x6e, 0xd1, 0x17, 0x48, 0x20, 0xc5, 0x1d, 0x4d, 0x09, 0x24, 0x33, 0x25,
-	0x45, 0x03, 0xf8, 0x2e, 0xcc, 0xdb, 0x8d, 0xb1, 0x87, 0x32, 0xf4, 0x3c, 0xed, 0x99, 0x79, 0xee,
-	0x63, 0x53, 0x86, 0x55, 0xd2, 0xf9, 0xb2, 0x04, 0x1d, 0x97, 0x23, 0x19, 0x73, 0xa3, 0x51, 0x49,
-	0x3d, 0x8f, 0x72, 0xd5, 0x4e, 0x1f, 0xb0, 0x0e, 0x69, 0x57, 0x63, 0x5d, 0x9f, 0xba, 0x28, 0xbb,
-	0x57, 0x0a, 0x46, 0xb5, 0x59, 0x87, 0x19, 0x39, 0xbe, 0x55, 0xb8, 0x2a, 0xbb, 0xa4, 0xba, 0x93,
-	0x1e, 0x18, 0x58, 0x8d, 0x5a, 0x07, 0x06, 0x5d, 0xe8, 0x88, 0xb7, 0x1a, 0xcc, 0x71, 0xc8, 0x0f,
-	0xb7, 0x81, 0x3d, 0xf3, 0xfa, 0x5e, 0x14, 0x86, 0xc1, 0x01, 0x8f, 0x64, 0x50, 0x0d, 0x29, 0x40,
-	0xe4, 0x4f, 0x57, 0xba, 0x9a, 0x48, 0xa9, 0xe7, 0x05, 0xc2, 0x40, 0x3d, 0xe3, 0x20, 0x52, 0x8e,
-	0x0b, 0x4b, 0x9b, 0xde, 0x6b, 0xae, 0x6a, 0x4a, 0x67, 0xa9, 0x39, 0xd6, 0x95, 0xaa, 0xb9, 0x57,
-	0x37, 0x4a, 0xf2, 0xcd, 0xba, 0x66, 0x69, 0xe7, 0x01, 0x2c, 0xdb, 0x75, 0x4a, 0x51, 0xd2, 0x85,
-	0xfa, 0x48, 0x62, 0xb2, 0x77, 0x3a, 0x7d, 0xf7, 0x0b, 0x68, 0x1a, 0xef, 0x6f, 0xb0, 0x55, 0x58,
-	0x7a, 0xf5, 0xf4, 0xc5, 0xfe, 0xce, 0xe1, 0x61, 0xef, 0xe0, 0xe5, 0xe6, 0x67, 0x3b, 0x3f, 0xe8,
-	0xed, 0x6e, 0x1c, 0xee, 0xb6, 0xaf, 0xb0, 0x15, 0x60, 0xfb, 0x3b, 0x87, 0x2f, 0x76, 0xb6, 0x2d,
-	0xbc, 0xc4, 0x6e, 0x40, 0xf7, 0xe5, 0xfe, 0xcb, 0xc3, 0x9d, 0xed, 0x5e, 0xd1, 0x77, 0x65, 0xf6,
-	0x3e, 0x5c, 0x93, 0xf9, 0x05, 0x9f, 0x57, 0xee, 0x3e, 0x82, 0x76, 0xd6, 0xff, 0x61, 0x79, 0x8c,
-	0xde, 0xe6, 0x5a, 0x7a, 0xf0, 0x65, 0x05, 0xe6, 0x45, 0x68, 0x9c, 0x78, 0x29, 0x92, 0x47, 0xec,
-	0x19, 0xcc, 0xca, 0x27, 0x47, 0x99, 0x22, 0x2d, 0xfb, 0x91, 0xd3, 0xee, 0x4a, 0x16, 0x96, 0xcb,
-	0xba, 0xf4, 0x97, 0xfe, 0xe3, 0x7f, 0xff, 0x9b, 0xe5, 0x39, 0xd6, 0xbc, 0x77, 0xf6, 0xf1, 0xbd,
-	0x13, 0x1e, 0xc4, 0x58, 0xc7, 0xef, 0x00, 0xa4, 0x0f, 0x69, 0xb2, 0x8e, 0xf6, 0x01, 0x64, 0x5e,
-	0x19, 0xed, 0x5e, 0x2b, 0xc8, 0x91, 0xf5, 0x5e, 0xa3, 0x7a, 0x97, 0x9c, 0x79, 0xac, 0xd7, 0x0f,
-	0xfc, 0x44, 0x3c, 0xaa, 0xf9, 0x69, 0xe9, 0x2e, 0x1b, 0x40, 0xcb, 0x7c, 0xe2, 0x92, 0xa9, 0xf3,
-	0x9f, 0x82, 0x47, 0x3a, 0xbb, 0xef, 0x15, 0xe6, 0x29, 0x5a, 0xa6, 0x36, 0xae, 0x3a, 0x6d, 0x6c,
-	0x63, 0x42, 0x25, 0xd2, 0x56, 0x86, 0x82, 0xc3, 0xd3, 0x97, 0x2c, 0xd9, 0x75, 0x83, 0xe9, 0x72,
-	0xef, 0x68, 0x76, 0xdf, 0x9f, 0x92, 0x2b, 0xdb, 0x7a, 0x9f, 0xda, 0x5a, 0x75, 0x18, 0xb6, 0xd5,
-	0xa7, 0x32, 0xea, 0x1d, 0xcd, 0x4f, 0x4b, 0x77, 0x1f, 0xfc, 0xbb, 0xdb, 0xd0, 0xd0, 0x67, 0xc3,
-	0xec, 0x27, 0x30, 0x67, 0xc5, 0x2e, 0x32, 0x35, 0x8c, 0xa2, 0x50, 0xc7, 0xee, 0xf5, 0xe2, 0x4c,
-	0xd9, 0xf0, 0x0d, 0x6a, 0xb8, 0xc3, 0x56, 0xb0, 0x61, 0x19, 0xfc, 0x77, 0x8f, 0xa2, 0x70, 0xc5,
-	0x25, 0xbe, 0xd7, 0x86, 0x24, 0x13, 0x8d, 0x5d, 0xcf, 0x0a, 0x17, 0xab, 0xb5, 0xf7, 0xa7, 0xe4,
-	0xca, 0xe6, 0xae, 0x53, 0x73, 0x2b, 0x6c, 0xd9, 0x6c, 0x4e, 0x9f, 0xd7, 0x72, 0xba, 0xb9, 0x6a,
-	0x3e, 0xf2, 0xc8, 0xde, 0xd7, 0x84, 0x55, 0xf4, 0xf8, 0xa3, 0x26, 0x91, 0xfc, 0x0b, 0x90, 0x4e,
-	0x87, 0x9a, 0x62, 0x8c, 0x96, 0xcf, 0x7c, 0xe3, 0x91, 0x1d, 0x41, 0xd3, 0x78, 0x0a, 0x8a, 0x5d,
-	0x9b, 0xfa, 0x6c, 0x55, 0xb7, 0x5b, 0x94, 0x55, 0x34, 0x14, 0xb3, 0xfe, 0x7b, 0xa8, 0xe8, 0xfc,
-	0x08, 0x1a, 0xfa, 0x71, 0x21, 0xb6, 0x6a, 0x3c, 0xf6, 0x64, 0x3e, 0x86, 0xd4, 0xed, 0xe4, 0x33,
-	0x8a, 0x88, 0xcf, 0xac, 0x1d, 0x89, 0xef, 0x15, 0x34, 0x8d, 0x07, 0x84, 0xf4, 0x00, 0xf2, 0x8f,
-	0x14, 0xe9, 0x01, 0x14, 0xbc, 0x37, 0xe4, 0x2c, 0x52, 0x13, 0x4d, 0xd6, 0x20, 0xfa, 0x4e, 0xde,
-	0x84, 0x31, 0xdb, 0x83, 0xab, 0x52, 0x62, 0x1f, 0xf1, 0xaf, 0xb2, 0x0c, 0x05, 0xef, 0x6a, 0xde,
-	0x2f, 0xb1, 0x47, 0x50, 0x57, 0xef, 0x44, 0xb1, 0x95, 0xe2, 0xf7, 0xae, 0xba, 0xab, 0x39, 0x5c,
-	0x8a, 0xd7, 0x1f, 0x00, 0xa4, 0xaf, 0x15, 0x69, 0x21, 0x91, 0x7b, 0xfd, 0x48, 0x53, 0x40, 0xfe,
-	0x69, 0x23, 0x67, 0x85, 0x06, 0xd8, 0x66, 0x24, 0x24, 0x02, 0x7e, 0xae, 0x2e, 0xa9, 0xff, 0x18,
-	0x9a, 0xc6, 0x83, 0x45, 0x7a, 0xfa, 0xf2, 0x8f, 0x1d, 0xe9, 0xe9, 0x2b, 0x78, 0xdf, 0xc8, 0xe9,
-	0x52, 0xed, 0xcb, 0xce, 0x02, 0xd6, 0x1e, 0xfb, 0x27, 0xc1, 0x48, 0x14, 0xc0, 0x05, 0x3a, 0x85,
-	0x39, 0xeb, 0x55, 0x22, 0xcd, 0xa1, 0x45, 0x6f, 0x1e, 0x69, 0x0e, 0x2d, 0x7c, 0xc8, 0x48, 0xd1,
-	0x99, 0xb3, 0x88, 0xed, 0x9c, 0x51, 0x11, 0xa3, 0xa5, 0x1f, 0x42, 0xd3, 0x78, 0x61, 0x48, 0x8f,
-	0x25, 0xff, 0x98, 0x91, 0x1e, 0x4b, 0xd1, 0x83, 0x44, 0xcb, 0xd4, 0xc6, 0xbc, 0x43, 0xa4, 0x40,
-	0xd7, 0xad, 0xb1, 0xee, 0x9f, 0xc0, 0xbc, 0xfd, 0xe6, 0x90, 0xe6, 0xfd, 0xc2, 0xd7, 0x8b, 0x34,
-	0xef, 0x4f, 0x79, 0xa8, 0x48, 0x92, 0xf4, 0xdd, 0x25, 0xdd, 0xc8, 0xbd, 0xcf, 0x65, 0x74, 0xd9,
-	0x17, 0xec, 0x7b, 0x28, 0xe0, 0xe4, 0xfd, 0x77, 0xb6, 0x6a, 0x50, 0xad, 0x79, 0x4b, 0x5e, 0xf3,
-	0x4b, 0xee, 0xaa, 0xbc, 0x4d, 0xcc, 0xe2, 0xc2, 0x38, 0xed, 0x5a, 0x74, 0x0f, 0xde, 0xd8, 0xb5,
-	0xcc, 0xab, 0xf2, 0xc6, 0xae, 0x65, 0x5d, 0x97, 0xcf, 0xee, 0x5a, 0x89, 0x8f, 0x75, 0x04, 0xb0,
-	0x90, 0xb9, 0x5f, 0xa1, 0xb9, 0xa2, 0xf8, 0x0a, 0x5c, 0xf7, 0xc6, 0xdb, 0xaf, 0x65, 0xd8, 0x12,
-	0x44, 0x09, 0xc1, 0x7b, 0xea, 0xc2, 0xe1, 0xef, 0x42, 0xcb, 0x7c, 0x3b, 0x85, 0x99, 0xac, 0x9c,
-	0x6d, 0xe9, 0xbd, 0xc2, 0x3c, 0x7b, 0x71, 0x59, 0xcb, 0x6c, 0x86, 0x7d, 0x1f, 0x56, 0x34, 0xab,
-	0x9b, 0x21, 0xfb, 0x31, 0xbb, 0x59, 0x10, 0xc8, 0x6f, 0xea, 0x71, 0xdd, 0x6b, 0x53, 0x23, 0xfd,
-	0xef, 0x97, 0x90, 0x68, 0xec, 0x07, 0x29, 0xd2, 0x0d, 0xa3, 0xe8, 0x1d, 0x8e, 0x74, 0xc3, 0x28,
-	0x7c, 0xc5, 0x42, 0x11, 0x0d, 0x5b, 0xb2, 0xe6, 0x48, 0x1c, 0xc4, 0xb3, 0x1f, 0xc2, 0x82, 0x71,
-	0x29, 0xea, 0xf0, 0x22, 0xe8, 0x6b, 0x06, 0xc8, 0xdf, 0xd7, 0xed, 0x16, 0x59, 0x29, 0xce, 0x2a,
-	0xd5, 0xbf, 0xe8, 0x58, 0x93, 0x83, 0xc4, 0xbf, 0x05, 0x4d, 0xf3, 0xc2, 0xd5, 0x5b, 0xea, 0x5d,
-	0x35, 0xb2, 0xcc, 0xeb, 0xa6, 0xf7, 0x4b, 0xec, 0x40, 0x04, 0x64, 0xe9, 0x87, 0x2e, 0xc3, 0x28,
-	0xbb, 0x7d, 0xda, 0x0f, 0x60, 0xea, 0x85, 0x2c, 0x7a, 0xfa, 0xf4, 0x4e, 0xe9, 0x7e, 0x89, 0xfd,
-	0x9d, 0x12, 0xb4, 0xac, 0x0b, 0x51, 0x56, 0x78, 0x4b, 0xa6, 0x67, 0x1d, 0x33, 0xcf, 0xec, 0x9a,
-	0xe3, 0xd2, 0xb0, 0xf7, 0xee, 0x7e, 0xd7, 0x9a, 0xd6, 0xcf, 0x2d, 0x87, 0xda, 0x7a, 0xf6, 0xb5,
-	0xcb, 0x2f, 0xb2, 0x05, 0xcc, 0x5b, 0xd2, 0x5f, 0xdc, 0x2f, 0xb1, 0x3f, 0x2c, 0xc1, 0xbc, 0xed,
-	0x06, 0xd6, 0xc3, 0x2d, 0x74, 0x38, 0xeb, 0xc5, 0x9f, 0xe2, 0x3b, 0xfe, 0x21, 0xf5, 0xf2, 0xc5,
-	0x5d, 0xd7, 0xea, 0xa5, 0x7c, 0xfc, 0xe4, 0x57, 0xeb, 0x2d, 0xfb, 0x54, 0x3c, 0xcf, 0xac, 0x0e,
-	0x6b, 0x58, 0xfe, 0x91, 0x60, 0x4d, 0x30, 0xe6, 0xb3, 0xbe, 0xb4, 0x08, 0x3f, 0x16, 0xaf, 0x3c,
-	0xaa, 0xf3, 0x04, 0xa4, 0xbb, 0x77, 0xfd, 0xde, 0xb9, 0x45, 0x63, 0xba, 0xe1, 0x5c, 0xb3, 0xc6,
-	0x94, 0xdd, 0xe1, 0x37, 0x44, 0xef, 0xe4, 0x8b, 0xbc, 0xe9, 0x16, 0x95, 0x7b, 0xa5, 0x77, 0x7a,
-	0x27, 0x47, 0xa2, 0x93, 0xb2, 0xb8, 0xc5, 0x1c, 0xef, 0x58, 0x8d, 0x73, 0x97, 0xfa, 0x7a, 0xcb,
-	0xb9, 0x39, 0xb5, 0xaf, 0xf7, 0xc8, 0x99, 0x8b, 0x3d, 0x3e, 0x00, 0x48, 0x0f, 0x56, 0x59, 0xe6,
-	0x60, 0x4f, 0x8b, 0x8c, 0xfc, 0xd9, 0xab, 0xcd, 0x81, 0xea, 0xfc, 0x0f, 0x6b, 0xfc, 0x91, 0x10,
-	0x80, 0x4f, 0xd5, 0x91, 0xa0, 0xa9, 0xe6, 0xd8, 0x27, 0xa0, 0x96, 0x9a, 0x93, 0xad, 0xdf, 0x12,
-	0x7f, 0xfa, 0x7c, 0xf1, 0x25, 0xcc, 0xed, 0x85, 0xe1, 0xeb, 0xc9, 0x58, 0x47, 0x9e, 0xd8, 0xe7,
-	0x2c, 0xbb, 0x5e, 0x7c, 0xda, 0xcd, 0x8c, 0xc2, 0x59, 0xa3, 0xaa, 0xba, 0xac, 0x63, 0x54, 0x75,
-	0xef, 0xf3, 0xf4, 0xe0, 0xf6, 0x0b, 0xe6, 0xc1, 0xa2, 0x96, 0xaa, 0xba, 0xe3, 0x5d, 0xbb, 0x1a,
-	0x4b, 0x96, 0x66, 0x9b, 0xb0, 0xf4, 0x71, 0xd5, 0xdb, 0x7b, 0xb1, 0xaa, 0x93, 0x64, 0x4a, 0x6b,
-	0x9b, 0xf7, 0xe9, 0xba, 0x07, 0x1d, 0x56, 0x2c, 0xa5, 0x1d, 0xd7, 0xa7, 0x1c, 0xdd, 0x39, 0x0b,
-	0xb4, 0x77, 0x9a, 0xb1, 0x77, 0x11, 0xf1, 0x9f, 0xde, 0xfb, 0x5c, 0x1e, 0x83, 0x7c, 0xa1, 0x76,
-	0x1a, 0x75, 0x4e, 0x64, 0xed, 0x34, 0x99, 0x83, 0x25, 0x6b, 0xa7, 0xc9, 0x1d, 0x2c, 0x59, 0x53,
-	0xad, 0xce, 0xa9, 0xd8, 0x10, 0x16, 0x73, 0x67, 0x51, 0x7a, 0x93, 0x99, 0x76, 0x82, 0xd5, 0x5d,
-	0x9b, 0x5e, 0xc0, 0x6e, 0xed, 0xae, 0xdd, 0xda, 0x21, 0xcc, 0x6d, 0x73, 0x31, 0x59, 0x22, 0xd4,
-	0x36, 0x73, 0xab, 0xce, 0x0c, 0xe4, 0xcd, 0x6e, 0x09, 0x94, 0x67, 0xab, 0x12, 0x14, 0xe3, 0xca,
-	0x7e, 0x04, 0xcd, 0x27, 0x3c, 0x51, 0xb1, 0xb5, 0x5a, 0x99, 0xcd, 0x04, 0xdb, 0x76, 0x0b, 0x42,
-	0x73, 0x6d, 0x9a, 0xa1, 0xda, 0xee, 0xf1, 0xc1, 0x09, 0x17, 0xc2, 0xa9, 0xe7, 0x0f, 0xbe, 0x60,
-	0x7f, 0x8e, 0x2a, 0xd7, 0x97, 0x0b, 0x56, 0x8c, 0x40, 0x49, 0xb3, 0xf2, 0x85, 0x0c, 0x5e, 0x54,
-	0x73, 0x10, 0x0e, 0xb8, 0xa1, 0x54, 0x05, 0xd0, 0x34, 0x2e, 0xe2, 0x68, 0x06, 0xca, 0xdf, 0xeb,
-	0xd2, 0x0c, 0x54, 0x70, 0x6f, 0xc7, 0xb9, 0x43, 0xed, 0x38, 0x6c, 0x2d, 0x6d, 0x47, 0xdc, 0xd5,
-	0x49, 0x5b, 0xba, 0xf7, 0xb9, 0x37, 0x4a, 0xbe, 0x60, 0xaf, 0xe8, 0x31, 0x22, 0x33, 0x76, 0x38,
-	0xd5, 0xce, 0xb3, 0x61, 0xc6, 0x7a, 0xb2, 0x8c, 0x2c, 0x5b, 0x63, 0x17, 0x4d, 0x91, 0xee, 0xf5,
-	0x1d, 0x80, 0xc3, 0x24, 0x1c, 0x6f, 0x7b, 0x7c, 0x14, 0x06, 0xa9, 0xac, 0x4d, 0x23, 0x57, 0x53,
-	0xf9, 0x65, 0x84, 0xaf, 0xb2, 0x57, 0x86, 0x39, 0x63, 0x85, 0x5f, 0x2b, 0xe2, 0x9a, 0x1a, 0xdc,
-	0xaa, 0x27, 0xa4, 0x20, 0xc0, 0xf5, 0x7e, 0x89, 0x6d, 0x00, 0xa4, 0x87, 0x91, 0xda, 0x38, 0xc9,
-	0x9d, 0x73, 0x6a, 0xb1, 0x57, 0x70, 0x72, 0x79, 0x00, 0x8d, 0xf4, 0x74, 0x6b, 0x35, 0xbd, 0xee,
-	0x66, 0x9d, 0x85, 0xe9, 0x1d, 0x3c, 0x77, 0xe6, 0xe4, 0xb4, 0x69, 0xaa, 0x80, 0xd5, 0x71, 0xaa,
-	0xe8, 0x20, 0xc9, 0x87, 0x25, 0xd1, 0x41, 0xad, 0xe0, 0x50, 0xc4, 0xa5, 0x1a, 0x49, 0xc1, 0xb9,
-	0x8f, 0xe6, 0xe6, 0xc2, 0x03, 0x11, 0xcb, 0xc7, 0x82, 0xd4, 0x2a, 0xa2, 0x3d, 0x51, 0x34, 0x8f,
-	0x60, 0x31, 0xe7, 0x63, 0xd7, 0x2c, 0x3d, 0xed, 0x10, 0x45, 0xb3, 0xf4, 0x54, 0xf7, 0xbc, 0x73,
-	0x95, 0x9a, 0x5c, 0x70, 0x80, 0x6c, 0xaa, 0x73, 0x3f, 0xe9, 0x9f, 0x62, 0x73, 0xbf, 0x5f, 0x82,
-	0xa5, 0x02, 0x17, 0x3a, 0xfb, 0x40, 0x99, 0xe7, 0x53, 0xdd, 0xeb, 0xdd, 0x42, 0x0f, 0xab, 0x73,
-	0x48, 0xed, 0x3c, 0x63, 0x9f, 0x59, 0x1b, 0x9b, 0x70, 0x6e, 0x4a, 0xce, 0x7c, 0xab, 0x52, 0x51,
-	0xa8, 0x51, 0xfc, 0x14, 0x56, 0x45, 0x47, 0x36, 0x86, 0xc3, 0x8c, 0xf7, 0xf7, 0x46, 0xee, 0x3f,
-	0xb4, 0x58, 0x5e, 0xed, 0xee, 0xf4, 0xff, 0xe0, 0x32, 0x45, 0x01, 0x16, 0x5d, 0x65, 0x13, 0x68,
-	0x67, 0x3d, 0xaa, 0x6c, 0x7a, 0x5d, 0xdd, 0x9b, 0x96, 0xa1, 0x59, 0xe0, 0x85, 0xfd, 0x0d, 0x6a,
-	0xec, 0xa6, 0xd3, 0x2d, 0x9a, 0x17, 0x61, 0x7b, 0xe2, 0x7a, 0xfc, 0x05, 0xed, 0xfe, 0xcd, 0x8c,
-	0x53, 0x35, 0x30, 0xcd, 0x5f, 0xad, 0x4d, 0xdd, 0x62, 0xef, 0xf1, 0x87, 0xd4, 0xfc, 0x9a, 0xf3,
-	0x5e, 0x51, 0xf3, 0x91, 0xf8, 0x44, 0x18, 0xbd, 0xab, 0x59, 0xbe, 0x56, 0x3d, 0x58, 0x2b, 0x5a,
-	0xef, 0xa9, 0xd6, 0x4b, 0x66, 0xae, 0xaf, 0x90, 0x6e, 0xd7, 0x32, 0xdd, 0xbd, 0x9a, 0x7d, 0x0a,
-	0xfc, 0xca, 0x9a, 0x7d, 0x8a, 0xfc, 0xc3, 0xb6, 0x5e, 0xa3, 0x3c, 0xc3, 0x9f, 0x96, 0xee, 0x6e,
-	0xde, 0xfe, 0xe1, 0x6f, 0x9c, 0xf8, 0xc9, 0xe9, 0xe4, 0x68, 0xbd, 0x1f, 0x8e, 0xee, 0x0d, 0x95,
-	0x5b, 0x4f, 0xde, 0x42, 0xb8, 0x37, 0x0c, 0x06, 0xf7, 0xa8, 0xda, 0xa3, 0x19, 0xfa, 0x97, 0x52,
-	0xdf, 0xfa, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb6, 0x0e, 0x06, 0x7d, 0x84, 0x6a, 0x00, 0x00,
+	0xb6, 0x56, 0xfa, 0xcf, 0xee, 0x5e, 0xdd, 0xb6, 0xdb, 0xdb, 0x8e, 0xdd, 0xe9, 0xe4, 0x24, 0x3e,
+	0x35, 0xb9, 0x27, 0x99, 0xcc, 0x19, 0x27, 0x27, 0x33, 0x73, 0xc8, 0x3d, 0xe1, 0x72, 0xf1, 0x5f,
+	0xe2, 0xcc, 0x38, 0x8e, 0xa7, 0x9c, 0x4c, 0x98, 0x99, 0x7b, 0xd5, 0x53, 0xee, 0xde, 0xb6, 0x6b,
+	0xd2, 0x5d, 0xd5, 0x53, 0x55, 0x6d, 0xc7, 0x73, 0x38, 0x48, 0x20, 0x84, 0x10, 0x2f, 0xe8, 0xc0,
+	0x0b, 0x20, 0xd0, 0x95, 0xe6, 0x22, 0x71, 0x2f, 0x08, 0x01, 0x0f, 0x48, 0x80, 0xae, 0xc4, 0x03,
+	0x0f, 0x48, 0x48, 0x88, 0x07, 0x1e, 0x90, 0x78, 0xe0, 0x0a, 0x81, 0x84, 0xae, 0x10, 0x2f, 0x48,
+	0xbc, 0xa3, 0xb5, 0xf6, 0x4f, 0xed, 0x5d, 0x55, 0x1d, 0xe7, 0xcc, 0x0c, 0x3c, 0xb9, 0xf7, 0xb7,
+	0x77, 0xed, 0xdf, 0xb5, 0xd6, 0x5e, 0x6b, 0xed, 0xb5, 0xb7, 0xa1, 0x11, 0x8d, 0xfb, 0xeb, 0xe3,
+	0x28, 0x4c, 0x42, 0x56, 0x1b, 0x06, 0xd1, 0xb8, 0xdf, 0xbd, 0x71, 0x12, 0x86, 0x27, 0x43, 0x7e,
+	0xdf, 0x1b, 0xfb, 0xf7, 0xbd, 0x20, 0x08, 0x13, 0x2f, 0xf1, 0xc3, 0x20, 0x16, 0x85, 0x9c, 0x9f,
+	0xc0, 0xfc, 0x53, 0x1e, 0x1c, 0x72, 0x3e, 0x70, 0xf9, 0xcf, 0x26, 0x3c, 0x4e, 0xd8, 0x37, 0x60,
+	0xd1, 0xe3, 0x3f, 0xe7, 0x7c, 0xd0, 0x1b, 0x7b, 0x71, 0x3c, 0x3e, 0x8d, 0xbc, 0x98, 0x77, 0x4a,
+	0x6b, 0xa5, 0xbb, 0x2d, 0xb7, 0x2d, 0x32, 0x0e, 0x34, 0xce, 0x3e, 0x84, 0x56, 0x8c, 0x45, 0x79,
+	0x90, 0x44, 0xe1, 0xf8, 0xa2, 0x53, 0xa6, 0x72, 0x4d, 0xc4, 0x76, 0x04, 0xe4, 0x0c, 0x61, 0x41,
+	0xb7, 0x10, 0x8f, 0xc3, 0x20, 0xe6, 0xec, 0x01, 0x2c, 0xf7, 0xfd, 0xf1, 0x29, 0x8f, 0x7a, 0xf4,
+	0xf1, 0x28, 0xe0, 0xa3, 0x30, 0xf0, 0xfb, 0x9d, 0xd2, 0x5a, 0xe5, 0x6e, 0xc3, 0x65, 0x22, 0x0f,
+	0xbf, 0x78, 0x2e, 0x73, 0xd8, 0x1d, 0x58, 0xe0, 0x81, 0xc0, 0xf9, 0x80, 0xbe, 0x92, 0x4d, 0xcd,
+	0xa7, 0x30, 0x7e, 0xe0, 0xfc, 0xd5, 0x32, 0x2c, 0x3e, 0x0b, 0xfc, 0xe4, 0xb5, 0x37, 0x1c, 0xf2,
+	0x44, 0x8d, 0xe9, 0x0e, 0x2c, 0x9c, 0x13, 0x40, 0x63, 0x3a, 0x0f, 0xa3, 0x81, 0x1c, 0xd1, 0xbc,
+	0x80, 0x0f, 0x24, 0x3a, 0xb5, 0x67, 0xe5, 0xa9, 0x3d, 0x2b, 0x9c, 0xae, 0xca, 0x94, 0xe9, 0xba,
+	0x03, 0x0b, 0x11, 0xef, 0x87, 0x67, 0x3c, 0xba, 0xe8, 0x9d, 0xfb, 0xc1, 0x20, 0x3c, 0xef, 0x54,
+	0xd7, 0x4a, 0x77, 0x6b, 0xee, 0xbc, 0x82, 0x5f, 0x13, 0xca, 0x36, 0x61, 0xa1, 0x7f, 0xea, 0x05,
+	0x01, 0x1f, 0xf6, 0x8e, 0xbc, 0xfe, 0x9b, 0xc9, 0x38, 0xee, 0xd4, 0xd6, 0x4a, 0x77, 0x9b, 0x0f,
+	0xaf, 0xad, 0xd3, 0xaa, 0xae, 0x6f, 0x9d, 0x7a, 0xc1, 0x26, 0xe5, 0x1c, 0x06, 0xde, 0x38, 0x3e,
+	0x0d, 0x13, 0x77, 0x5e, 0x7e, 0x21, 0xe0, 0xd8, 0x59, 0x06, 0x66, 0xce, 0x84, 0x98, 0x7b, 0xe7,
+	0x1f, 0x95, 0x60, 0xe9, 0x55, 0x30, 0x0c, 0xfb, 0x6f, 0x7e, 0xc9, 0x29, 0x2a, 0x18, 0x43, 0xf9,
+	0x7d, 0xc7, 0x50, 0xf9, 0xaa, 0x63, 0x58, 0x81, 0x65, 0xbb, 0xb3, 0x72, 0x14, 0x1c, 0xae, 0xe2,
+	0xd7, 0x27, 0x5c, 0x75, 0x4b, 0x0d, 0xe3, 0xeb, 0xd0, 0xee, 0x4f, 0xa2, 0x88, 0x07, 0xb9, 0x71,
+	0x2c, 0x48, 0x5c, 0x0f, 0xe4, 0x43, 0x68, 0x05, 0xfc, 0x3c, 0x2d, 0x26, 0x69, 0x37, 0xe0, 0xe7,
+	0xaa, 0x88, 0xd3, 0x81, 0x95, 0x6c, 0x33, 0xb2, 0x03, 0xff, 0xb5, 0x04, 0xd5, 0x57, 0xc9, 0xdb,
+	0x90, 0xad, 0x43, 0x35, 0xb9, 0x18, 0x0b, 0x0e, 0x99, 0x7f, 0xc8, 0xe4, 0xd0, 0x36, 0x06, 0x83,
+	0x88, 0xc7, 0xf1, 0xcb, 0x8b, 0x31, 0x77, 0x5b, 0x9e, 0x48, 0xf4, 0xb0, 0x1c, 0xeb, 0xc0, 0xac,
+	0x4c, 0x53, 0x83, 0x0d, 0x57, 0x25, 0xd9, 0x4d, 0x00, 0x6f, 0x14, 0x4e, 0x82, 0xa4, 0x17, 0x7b,
+	0x09, 0x4d, 0x55, 0xc5, 0x35, 0x10, 0x76, 0x03, 0x1a, 0xe3, 0x37, 0xbd, 0xb8, 0x1f, 0xf9, 0xe3,
+	0x84, 0xc8, 0xa6, 0xe1, 0xa6, 0x00, 0xfb, 0x06, 0xd4, 0xc3, 0x49, 0x32, 0x0e, 0xfd, 0x20, 0x91,
+	0xa4, 0xb2, 0x20, 0xfb, 0xf2, 0x62, 0x92, 0x1c, 0x20, 0xec, 0xea, 0x02, 0xec, 0x36, 0xcc, 0xf5,
+	0xc3, 0xe0, 0xd8, 0x8f, 0x46, 0x42, 0x18, 0x74, 0x66, 0xa8, 0x35, 0x1b, 0x74, 0xfe, 0x65, 0x19,
+	0x9a, 0x2f, 0x23, 0x2f, 0x88, 0xbd, 0x3e, 0x02, 0xd8, 0xf5, 0xe4, 0x6d, 0xef, 0xd4, 0x8b, 0x4f,
+	0x69, 0xb4, 0x0d, 0x57, 0x25, 0xd9, 0x0a, 0xcc, 0x88, 0x8e, 0xd2, 0x98, 0x2a, 0xae, 0x4c, 0xb1,
+	0x8f, 0x61, 0x31, 0x98, 0x8c, 0x7a, 0x76, 0x5b, 0x15, 0xa2, 0x96, 0x7c, 0x06, 0x4e, 0xc0, 0x11,
+	0xae, 0xb5, 0x68, 0x42, 0x8c, 0xd0, 0x40, 0x98, 0x03, 0x2d, 0x99, 0xe2, 0xfe, 0xc9, 0xa9, 0x18,
+	0x66, 0xcd, 0xb5, 0x30, 0xac, 0x23, 0xf1, 0x47, 0xbc, 0x17, 0x27, 0xde, 0x68, 0x2c, 0x87, 0x65,
+	0x20, 0x94, 0x1f, 0x26, 0xde, 0xb0, 0x77, 0xcc, 0x79, 0xdc, 0x99, 0x95, 0xf9, 0x1a, 0x61, 0x1f,
+	0xc1, 0xfc, 0x80, 0xc7, 0x49, 0x4f, 0x2e, 0x0a, 0x8f, 0x3b, 0x75, 0x62, 0xfd, 0x0c, 0x8a, 0xf5,
+	0x44, 0xde, 0x79, 0x0f, 0x27, 0x80, 0xbf, 0xed, 0x34, 0x44, 0x5f, 0x53, 0x04, 0x29, 0xe7, 0x29,
+	0x4f, 0x8c, 0xd9, 0x8b, 0x25, 0x85, 0x3a, 0x7b, 0xc0, 0x0c, 0x78, 0x9b, 0x27, 0x9e, 0x3f, 0x8c,
+	0xd9, 0xa7, 0xd0, 0x4a, 0x8c, 0xc2, 0x24, 0x0a, 0x9b, 0x9a, 0x9c, 0x8c, 0x0f, 0x5c, 0xab, 0x9c,
+	0xf3, 0x14, 0xea, 0x4f, 0x38, 0xdf, 0xf3, 0x47, 0x7e, 0xc2, 0x56, 0xa0, 0x76, 0xec, 0xbf, 0xe5,
+	0x82, 0xe0, 0x2b, 0xbb, 0x57, 0x5c, 0x91, 0x64, 0x5d, 0x98, 0x1d, 0xf3, 0xa8, 0xcf, 0xd5, 0xf2,
+	0xec, 0x5e, 0x71, 0x15, 0xb0, 0x39, 0x0b, 0xb5, 0x21, 0x7e, 0xec, 0xfc, 0xaf, 0x0a, 0x34, 0x0f,
+	0x79, 0xa0, 0x19, 0x89, 0x41, 0x15, 0x87, 0x2c, 0x99, 0x87, 0x7e, 0xb3, 0x5b, 0xd0, 0xa4, 0x69,
+	0x88, 0x93, 0xc8, 0x0f, 0x4e, 0x24, 0xfd, 0x02, 0x42, 0x87, 0x84, 0xb0, 0x36, 0x54, 0xbc, 0x91,
+	0xa2, 0x5d, 0xfc, 0x89, 0x4c, 0x36, 0xf6, 0x2e, 0x46, 0xc8, 0x8f, 0x7a, 0x55, 0x5b, 0x6e, 0x53,
+	0x62, 0xbb, 0xb8, 0xac, 0xeb, 0xb0, 0x64, 0x16, 0x51, 0xb5, 0xd7, 0xa8, 0xf6, 0x45, 0xa3, 0xa4,
+	0x6c, 0xe4, 0x0e, 0x2c, 0xa8, 0xf2, 0x91, 0xe8, 0x2c, 0xad, 0x73, 0xc3, 0x9d, 0x97, 0xb0, 0x1a,
+	0xc2, 0x5d, 0x68, 0x1f, 0xfb, 0x81, 0x37, 0xec, 0xf5, 0x87, 0xc9, 0x59, 0x6f, 0xc0, 0x87, 0x89,
+	0x47, 0x2b, 0x5e, 0x73, 0xe7, 0x09, 0xdf, 0x1a, 0x26, 0x67, 0xdb, 0x88, 0xb2, 0x8f, 0xa1, 0x71,
+	0xcc, 0x79, 0x8f, 0x66, 0xa2, 0x53, 0xb7, 0xb8, 0x47, 0xcd, 0xae, 0x5b, 0x3f, 0x56, 0xf3, 0xfc,
+	0x31, 0xb4, 0xc3, 0x49, 0x72, 0x12, 0xfa, 0xc1, 0x49, 0x0f, 0xe5, 0x55, 0xcf, 0x1f, 0x10, 0x05,
+	0x54, 0x37, 0xcb, 0x0f, 0x4a, 0xee, 0xbc, 0xca, 0x43, 0xc9, 0xf1, 0x6c, 0xc0, 0x3e, 0x00, 0xa0,
+	0xf6, 0x45, 0xe5, 0xb0, 0x56, 0xba, 0x3b, 0xe7, 0x36, 0x10, 0x11, 0x95, 0x7d, 0x06, 0x75, 0x9a,
+	0xd3, 0x64, 0x78, 0xd6, 0x69, 0xd2, 0xa2, 0xdf, 0x92, 0x2d, 0x1b, 0xab, 0xb1, 0xbe, 0xcd, 0xe3,
+	0xe4, 0xe5, 0xf0, 0x0c, 0xf7, 0xd4, 0x0b, 0x77, 0x76, 0x20, 0x52, 0xdd, 0xcf, 0xa0, 0x65, 0x66,
+	0xe0, 0xf4, 0xbf, 0xe1, 0x17, 0xb4, 0x64, 0x55, 0x17, 0x7f, 0xb2, 0x65, 0xa8, 0x9d, 0x79, 0xc3,
+	0x09, 0x97, 0xc2, 0x4d, 0x24, 0x3e, 0x2b, 0x3f, 0x2a, 0x39, 0xff, 0xa2, 0x04, 0x2d, 0xd1, 0x82,
+	0xdc, 0x94, 0x6f, 0xc3, 0x9c, 0x9a, 0x56, 0x1e, 0x45, 0x61, 0x24, 0x79, 0xdc, 0x06, 0xd9, 0x3d,
+	0x68, 0x2b, 0x60, 0x1c, 0x71, 0x7f, 0xe4, 0x9d, 0xa8, 0xba, 0x73, 0x38, 0x7b, 0x98, 0xd6, 0x18,
+	0x85, 0x93, 0x84, 0x4b, 0xf1, 0xdf, 0x92, 0xe3, 0x73, 0x11, 0x73, 0xed, 0x22, 0xc8, 0xe3, 0x05,
+	0xf4, 0x62, 0x61, 0xce, 0x97, 0x25, 0x60, 0xd8, 0xf5, 0x97, 0xa1, 0xa8, 0x42, 0x2e, 0x77, 0x96,
+	0xd4, 0x4a, 0xef, 0x4d, 0x6a, 0xe5, 0x69, 0xa4, 0xe6, 0x40, 0x4d, 0xf4, 0xbc, 0x5a, 0xd0, 0x73,
+	0x91, 0xf5, 0xdd, 0x6a, 0xbd, 0xd2, 0xae, 0x3a, 0xff, 0xb9, 0x02, 0xcb, 0x5b, 0x62, 0xef, 0xda,
+	0xe8, 0xf7, 0xf9, 0x58, 0x13, 0xe1, 0x2d, 0x68, 0x06, 0xe1, 0x80, 0xf7, 0xc6, 0x93, 0x23, 0xb5,
+	0x36, 0x2d, 0x17, 0x10, 0x3a, 0x20, 0x84, 0xe8, 0xe3, 0xd4, 0xf3, 0x03, 0xd1, 0x69, 0x31, 0x97,
+	0x0d, 0x42, 0xa8, 0xcb, 0x1f, 0xc1, 0xc2, 0x98, 0x07, 0x03, 0x93, 0xd6, 0x84, 0x76, 0x31, 0x27,
+	0x61, 0x49, 0x66, 0xb7, 0xa0, 0x79, 0x3c, 0x11, 0xe5, 0x90, 0x05, 0xab, 0x44, 0x03, 0x20, 0xa1,
+	0x8d, 0x51, 0xc2, 0xae, 0x41, 0x7d, 0x3c, 0x89, 0x4f, 0x29, 0xb7, 0x46, 0xb9, 0xb3, 0x98, 0xc6,
+	0xac, 0x0f, 0x00, 0x06, 0x93, 0x38, 0x91, 0x24, 0x3a, 0x43, 0x99, 0x0d, 0x44, 0x04, 0x89, 0x7e,
+	0x13, 0x96, 0x46, 0xde, 0xdb, 0x1e, 0xd1, 0x4e, 0xcf, 0x0f, 0x7a, 0xc7, 0x43, 0x12, 0xbf, 0xb3,
+	0x54, 0xae, 0x3d, 0xf2, 0xde, 0xfe, 0x00, 0x73, 0x9e, 0x05, 0x4f, 0x08, 0x47, 0xfe, 0x54, 0xfb,
+	0x7e, 0xc4, 0x63, 0x1e, 0x9d, 0x71, 0x62, 0xa9, 0xaa, 0xde, 0xdc, 0x5d, 0x81, 0x62, 0x8f, 0x46,
+	0x38, 0xee, 0x64, 0xd8, 0x17, 0xfc, 0xe3, 0xce, 0x8e, 0xfc, 0x60, 0x37, 0x19, 0xf6, 0xd9, 0x0d,
+	0x00, 0x64, 0xc8, 0x31, 0x8f, 0x7a, 0x6f, 0xce, 0x89, 0x69, 0xaa, 0xc4, 0x80, 0x07, 0x3c, 0xfa,
+	0xde, 0x39, 0xbb, 0x0e, 0x8d, 0x7e, 0x4c, 0x1c, 0xed, 0x5d, 0x74, 0x9a, 0xc4, 0x51, 0xf5, 0x7e,
+	0x8c, 0xbc, 0xec, 0x5d, 0xb0, 0x8f, 0x81, 0x61, 0x6f, 0x3d, 0x5a, 0x05, 0x3e, 0xa0, 0xea, 0xe3,
+	0x4e, 0x8b, 0x4a, 0x61, 0x67, 0x37, 0x64, 0x06, 0xb6, 0x13, 0xb3, 0xaf, 0xc1, 0x9c, 0xea, 0xec,
+	0xf1, 0xd0, 0x3b, 0x89, 0x3b, 0x73, 0x54, 0xb0, 0x25, 0xc1, 0x27, 0x88, 0x39, 0xaf, 0x85, 0xb6,
+	0x61, 0xac, 0xad, 0xe4, 0x19, 0xdc, 0xf7, 0x08, 0xa1, 0x75, 0xad, 0xbb, 0x32, 0x55, 0xb4, 0x68,
+	0xe5, 0x82, 0x45, 0x73, 0x7e, 0x51, 0x82, 0x96, 0xac, 0x99, 0xb6, 0x68, 0xf6, 0x00, 0x98, 0x5a,
+	0xc5, 0xe4, 0xad, 0x3f, 0xe8, 0x1d, 0x5d, 0x24, 0x3c, 0x16, 0x44, 0xb3, 0x7b, 0xc5, 0x2d, 0xc8,
+	0x43, 0x61, 0x64, 0xa1, 0x71, 0x12, 0x09, 0x7a, 0xde, 0xbd, 0xe2, 0xe6, 0x72, 0x90, 0xbd, 0x50,
+	0x09, 0x98, 0x24, 0x3d, 0x3f, 0x18, 0xf0, 0xb7, 0x44, 0x4a, 0x73, 0xae, 0x85, 0x6d, 0xce, 0x43,
+	0xcb, 0xfc, 0xce, 0xf9, 0x29, 0xd4, 0x95, 0x0a, 0x41, 0xdb, 0x67, 0xa6, 0x5f, 0xae, 0x81, 0xb0,
+	0x2e, 0xd4, 0xed, 0x5e, 0xb8, 0xf5, 0xaf, 0xd2, 0xb6, 0xf3, 0x67, 0xa0, 0xbd, 0x87, 0x44, 0x14,
+	0x20, 0xd1, 0x4a, 0xbd, 0x68, 0x05, 0x66, 0x0c, 0xe6, 0x69, 0xb8, 0x32, 0x85, 0x3b, 0xd4, 0x69,
+	0x18, 0x27, 0xb2, 0x1d, 0xfa, 0xed, 0xfc, 0xdb, 0x12, 0xb0, 0x9d, 0x38, 0xf1, 0x47, 0x5e, 0xc2,
+	0x9f, 0x70, 0x2d, 0x1a, 0x5e, 0x40, 0x0b, 0x6b, 0x7b, 0x19, 0x6e, 0x08, 0x2d, 0x45, 0xec, 0xae,
+	0xdf, 0x90, 0xec, 0x9c, 0xff, 0x60, 0xdd, 0x2c, 0x2d, 0x84, 0xae, 0x55, 0x01, 0x72, 0x5b, 0xe2,
+	0x45, 0x27, 0x3c, 0x21, 0x15, 0x46, 0x2a, 0xc0, 0x20, 0xa0, 0xad, 0x30, 0x38, 0xee, 0xfe, 0x36,
+	0x2c, 0xe6, 0xea, 0x30, 0xe5, 0x73, 0xa3, 0x40, 0x3e, 0x57, 0x4c, 0xf9, 0xdc, 0x87, 0x25, 0xab,
+	0x5f, 0x92, 0xe2, 0x3a, 0x30, 0x8b, 0x8c, 0x81, 0x1a, 0x22, 0xed, 0xf2, 0xae, 0x4a, 0xb2, 0x87,
+	0xb0, 0x7c, 0xcc, 0x79, 0xe4, 0x25, 0x94, 0x24, 0xd6, 0xc1, 0x35, 0x91, 0x35, 0x17, 0xe6, 0x39,
+	0xff, 0xad, 0x04, 0x0b, 0x28, 0x49, 0x9f, 0x7b, 0xc1, 0x85, 0x9a, 0xab, 0xbd, 0xc2, 0xb9, 0xba,
+	0x6b, 0x6c, 0x4a, 0x46, 0xe9, 0xaf, 0x3a, 0x51, 0x95, 0xec, 0x44, 0xb1, 0x35, 0x68, 0x59, 0xdd,
+	0xad, 0x09, 0x95, 0x2c, 0xf6, 0x92, 0x03, 0x1e, 0x6d, 0x5e, 0x24, 0xfc, 0x57, 0x9f, 0xca, 0x8f,
+	0xa0, 0x9d, 0x76, 0x5b, 0xce, 0x23, 0x83, 0x2a, 0x12, 0xa6, 0xac, 0x80, 0x7e, 0x3b, 0x7f, 0xb7,
+	0x24, 0x0a, 0x6e, 0x85, 0xbe, 0x56, 0xd7, 0xb0, 0x20, 0x6a, 0x7d, 0xaa, 0x20, 0xfe, 0x9e, 0xaa,
+	0xee, 0xfe, 0xea, 0x83, 0x45, 0x99, 0x18, 0xf3, 0x60, 0xd0, 0xf3, 0x86, 0x43, 0x12, 0xc4, 0x75,
+	0x77, 0x16, 0xd3, 0x1b, 0xc3, 0xa1, 0x73, 0x07, 0x16, 0x8d, 0xde, 0xbd, 0x63, 0x1c, 0xfb, 0xc0,
+	0xf6, 0xfc, 0x38, 0x79, 0x15, 0xc4, 0x63, 0x43, 0x1b, 0xba, 0x0e, 0x0d, 0x94, 0xb6, 0xd8, 0x33,
+	0xc1, 0xb9, 0x35, 0x17, 0xc5, 0x2f, 0xf6, 0x2b, 0xa6, 0x4c, 0xef, 0xad, 0xcc, 0x2c, 0xcb, 0x4c,
+	0xef, 0x2d, 0x65, 0x3a, 0x8f, 0x60, 0xc9, 0xaa, 0x4f, 0x36, 0xfd, 0x21, 0xd4, 0x26, 0xc9, 0xdb,
+	0x50, 0xe9, 0xaa, 0x4d, 0x49, 0x21, 0x68, 0x15, 0xb9, 0x22, 0xc7, 0x79, 0x0c, 0x8b, 0xfb, 0xfc,
+	0x5c, 0x32, 0xb2, 0xea, 0xc8, 0x47, 0x97, 0x5a, 0x4c, 0x94, 0xef, 0xac, 0x03, 0x33, 0x3f, 0x4e,
+	0x19, 0x40, 0xd9, 0x4f, 0x25, 0xcb, 0x7e, 0x72, 0x3e, 0x02, 0x76, 0xe8, 0x9f, 0x04, 0xcf, 0x79,
+	0x1c, 0x7b, 0x27, 0x9a, 0xf5, 0xdb, 0x50, 0x19, 0xc5, 0x27, 0x52, 0x54, 0xe1, 0x4f, 0xe7, 0x5b,
+	0xb0, 0x64, 0x95, 0x93, 0x15, 0xdf, 0x80, 0x46, 0xec, 0x9f, 0x04, 0x5e, 0x32, 0x89, 0xb8, 0xac,
+	0x3a, 0x05, 0x9c, 0x27, 0xb0, 0xfc, 0x03, 0x1e, 0xf9, 0xc7, 0x17, 0x97, 0x55, 0x6f, 0xd7, 0x53,
+	0xce, 0xd6, 0xb3, 0x03, 0x57, 0x33, 0xf5, 0xc8, 0xe6, 0x05, 0xf9, 0xca, 0x95, 0xac, 0xbb, 0x22,
+	0x61, 0xc8, 0xbe, 0xb2, 0x29, 0xfb, 0x9c, 0x57, 0xc0, 0xb6, 0xc2, 0x20, 0xe0, 0xfd, 0xe4, 0x80,
+	0xf3, 0x28, 0x75, 0xdd, 0xa4, 0xb4, 0xda, 0x7c, 0xb8, 0x2a, 0x67, 0x36, 0x2b, 0x50, 0x25, 0x11,
+	0x33, 0xa8, 0x8e, 0x79, 0x34, 0xa2, 0x8a, 0xeb, 0x2e, 0xfd, 0x76, 0xae, 0xc2, 0x92, 0x55, 0xad,
+	0x34, 0x76, 0x3f, 0x81, 0xab, 0xdb, 0x7e, 0xdc, 0xcf, 0x37, 0xd8, 0x81, 0xd9, 0xf1, 0xe4, 0xa8,
+	0x97, 0x72, 0xa2, 0x4a, 0xa2, 0xfd, 0x93, 0xfd, 0x44, 0x56, 0xf6, 0x57, 0x4a, 0x50, 0xdd, 0x7d,
+	0xb9, 0xb7, 0x85, 0x7b, 0x85, 0x1f, 0xf4, 0xc3, 0x11, 0x6a, 0x60, 0x62, 0xd0, 0x3a, 0x3d, 0x95,
+	0xc3, 0x6e, 0x40, 0x83, 0x14, 0x37, 0x34, 0xf9, 0xa4, 0x1e, 0x94, 0x02, 0x68, 0x6e, 0xf2, 0xb7,
+	0x63, 0x3f, 0x22, 0x7b, 0x52, 0x59, 0x89, 0x55, 0xda, 0x66, 0xf2, 0x19, 0xce, 0x2f, 0x66, 0x61,
+	0x56, 0x6e, 0xbe, 0x62, 0x23, 0x4f, 0xfc, 0x33, 0x9e, 0x6e, 0xe4, 0x98, 0x42, 0xa5, 0x38, 0xe2,
+	0xa3, 0x30, 0xd1, 0xfa, 0x9b, 0x58, 0x06, 0x1b, 0x24, 0x73, 0x5a, 0x2a, 0x11, 0xc2, 0x00, 0xaf,
+	0x88, 0x52, 0x16, 0xc8, 0x6e, 0xc0, 0xac, 0x52, 0x06, 0xaa, 0xda, 0x5a, 0x50, 0x10, 0xce, 0x46,
+	0xdf, 0x1b, 0x7b, 0x7d, 0x3f, 0xb9, 0x90, 0x62, 0x41, 0xa7, 0xb1, 0xfe, 0x61, 0xd8, 0xf7, 0x86,
+	0xbd, 0x23, 0x6f, 0xe8, 0x05, 0x7d, 0xae, 0xcc, 0x75, 0x0b, 0x44, 0xd3, 0x55, 0x76, 0x4b, 0x15,
+	0x13, 0xe6, 0x6d, 0x06, 0xc5, 0x3d, 0xbc, 0x1f, 0x8e, 0x46, 0x7e, 0x82, 0x16, 0x2f, 0xa9, 0x66,
+	0x15, 0xd7, 0x40, 0x84, 0x73, 0x80, 0x52, 0xe7, 0x62, 0x06, 0x1b, 0xca, 0x39, 0x60, 0x80, 0x58,
+	0x4b, 0x46, 0x43, 0xab, 0xb8, 0x06, 0x82, 0x6b, 0x31, 0x09, 0x62, 0x9e, 0x24, 0x43, 0x3e, 0xd0,
+	0x1d, 0x6a, 0x52, 0xb1, 0x7c, 0x06, 0x7b, 0x00, 0x4b, 0xc2, 0x08, 0x8f, 0xbd, 0x24, 0x8c, 0x4f,
+	0xfd, 0xb8, 0x17, 0xa3, 0xb9, 0xda, 0xa2, 0xf2, 0x45, 0x59, 0xec, 0x11, 0xac, 0x66, 0xe0, 0x88,
+	0xf7, 0xb9, 0x7f, 0xc6, 0x07, 0xa4, 0xc2, 0x55, 0xdc, 0x69, 0xd9, 0x6c, 0x0d, 0x9a, 0xc1, 0x64,
+	0xd4, 0x9b, 0x8c, 0x07, 0x1e, 0x2a, 0x31, 0xf3, 0xa4, 0x5c, 0x9a, 0x10, 0xfb, 0x04, 0x94, 0x9e,
+	0x26, 0xb5, 0xc7, 0x05, 0x4b, 0xc2, 0x21, 0xf5, 0xba, 0x76, 0x09, 0x24, 0xcc, 0x54, 0x25, 0x6d,
+	0x4b, 0x23, 0x4f, 0x01, 0xc4, 0x27, 0x91, 0x7f, 0xe6, 0x25, 0xbc, 0xb3, 0x28, 0x84, 0xba, 0x4c,
+	0xe2, 0x77, 0x7e, 0xe0, 0x27, 0xbe, 0x97, 0x84, 0x51, 0x87, 0x51, 0x5e, 0x0a, 0xe0, 0x24, 0x12,
+	0x7d, 0xc4, 0x89, 0x97, 0x4c, 0x62, 0xa9, 0xa1, 0x2e, 0x09, 0x6b, 0x25, 0x97, 0xc1, 0x3e, 0x85,
+	0x15, 0x41, 0x11, 0x94, 0x25, 0x75, 0x6f, 0x52, 0x15, 0x96, 0x69, 0x46, 0xa6, 0xe4, 0xe2, 0x54,
+	0x4a, 0x12, 0xc9, 0x7d, 0x78, 0x55, 0x4c, 0xe5, 0x94, 0x6c, 0xec, 0x1f, 0xf6, 0xc0, 0xef, 0xf7,
+	0x64, 0x09, 0x64, 0x91, 0x15, 0x1a, 0x45, 0x3e, 0x03, 0x49, 0x7c, 0xe8, 0x1f, 0xf3, 0xc4, 0x1f,
+	0xf1, 0xce, 0xaa, 0x20, 0x71, 0x95, 0x46, 0x06, 0x9c, 0x8c, 0x29, 0xa7, 0x23, 0x18, 0x5e, 0xa4,
+	0x9c, 0xdf, 0x2b, 0x89, 0xcd, 0x47, 0x32, 0x6a, 0x6c, 0x98, 0x55, 0x82, 0x45, 0x7b, 0x61, 0x30,
+	0xbc, 0x90, 0x5c, 0x0b, 0x02, 0x7a, 0x11, 0x0c, 0x2f, 0x50, 0xb1, 0xf7, 0x03, 0xb3, 0x88, 0x90,
+	0x73, 0x2d, 0x05, 0x52, 0xa1, 0x5b, 0xd0, 0x1c, 0x4f, 0x8e, 0x86, 0x7e, 0x5f, 0x14, 0xa9, 0x88,
+	0x5a, 0x04, 0x44, 0x05, 0xd0, 0xa6, 0x14, 0x2b, 0x25, 0x4a, 0x54, 0xa9, 0x44, 0x53, 0x62, 0x58,
+	0xc4, 0xd9, 0x84, 0x65, 0xbb, 0x83, 0x52, 0xa0, 0xdf, 0x83, 0xba, 0xe4, 0xff, 0x58, 0x1a, 0xf6,
+	0xf3, 0x86, 0xdf, 0x13, 0xcd, 0x20, 0x9d, 0xef, 0xfc, 0xab, 0x2a, 0x2c, 0x49, 0x74, 0x6b, 0x18,
+	0xc6, 0xfc, 0x70, 0x32, 0x1a, 0x79, 0x51, 0x81, 0x60, 0x29, 0x5d, 0x22, 0x58, 0xca, 0x79, 0xc1,
+	0x72, 0xd3, 0xb2, 0x2f, 0x85, 0x64, 0x32, 0x10, 0x76, 0x17, 0x16, 0xfa, 0xc3, 0x30, 0x16, 0xea,
+	0xbe, 0xe9, 0x7a, 0xcb, 0xc2, 0x79, 0x61, 0x58, 0x2b, 0x12, 0x86, 0xa6, 0x20, 0x9b, 0xc9, 0x08,
+	0x32, 0x07, 0x5a, 0x58, 0x29, 0x57, 0xb2, 0x79, 0x56, 0x1a, 0x5b, 0x06, 0x86, 0xfd, 0xc9, 0x8a,
+	0x0d, 0x21, 0xa3, 0x16, 0x8a, 0x84, 0x86, 0x3f, 0xe2, 0x24, 0xfb, 0x8d, 0xd2, 0x0d, 0x29, 0x34,
+	0xf2, 0x59, 0xec, 0x09, 0x80, 0x68, 0x8b, 0x14, 0x10, 0x20, 0x05, 0xe4, 0x23, 0x7b, 0x55, 0xcc,
+	0xf9, 0x5f, 0xc7, 0xc4, 0x24, 0xe2, 0xa4, 0x94, 0x18, 0x5f, 0x3a, 0x7f, 0xad, 0x04, 0x4d, 0x23,
+	0x8f, 0x5d, 0x85, 0xc5, 0xad, 0x17, 0x2f, 0x0e, 0x76, 0xdc, 0x8d, 0x97, 0xcf, 0x7e, 0xb0, 0xd3,
+	0xdb, 0xda, 0x7b, 0x71, 0xb8, 0xd3, 0xbe, 0x82, 0xf0, 0xde, 0x8b, 0xad, 0x8d, 0xbd, 0xde, 0x93,
+	0x17, 0xee, 0x96, 0x82, 0x4b, 0x6c, 0x05, 0x98, 0xbb, 0xf3, 0xfc, 0xc5, 0xcb, 0x1d, 0x0b, 0x2f,
+	0xb3, 0x36, 0xb4, 0x36, 0xdd, 0x9d, 0x8d, 0xad, 0x5d, 0x89, 0x54, 0xd8, 0x32, 0xb4, 0x9f, 0xbc,
+	0xda, 0xdf, 0x7e, 0xb6, 0xff, 0xb4, 0xb7, 0xb5, 0xb1, 0xbf, 0xb5, 0xb3, 0xb7, 0xb3, 0xdd, 0xae,
+	0xb2, 0x39, 0x68, 0x6c, 0x6c, 0x6e, 0xec, 0x6f, 0xbf, 0xd8, 0xdf, 0xd9, 0x6e, 0xd7, 0x9c, 0xff,
+	0x52, 0x82, 0xab, 0xd4, 0xeb, 0x41, 0x96, 0x49, 0xd6, 0xa0, 0xd9, 0x0f, 0xc3, 0x31, 0x2a, 0xfe,
+	0xe9, 0xd6, 0x66, 0x42, 0xc8, 0x00, 0x42, 0x28, 0x1c, 0x87, 0x51, 0x9f, 0x4b, 0x1e, 0x01, 0x82,
+	0x9e, 0x20, 0x82, 0x0c, 0x20, 0x97, 0x57, 0x94, 0x10, 0x2c, 0xd2, 0x14, 0x98, 0x28, 0xb2, 0x02,
+	0x33, 0x47, 0x11, 0xf7, 0xfa, 0xa7, 0x92, 0x3b, 0x64, 0x8a, 0x7d, 0x3d, 0xb5, 0x4c, 0xfb, 0x38,
+	0xfb, 0x43, 0x3e, 0x20, 0x8a, 0xa9, 0xbb, 0x0b, 0x12, 0xdf, 0x92, 0x30, 0x4a, 0x41, 0xef, 0xc8,
+	0x0b, 0x06, 0x61, 0xc0, 0x07, 0x52, 0xed, 0x4d, 0x01, 0xe7, 0x00, 0x56, 0xb2, 0xe3, 0x93, 0x3c,
+	0xf6, 0xa9, 0xc1, 0x63, 0x42, 0x0b, 0xed, 0x4e, 0x5f, 0x4d, 0x83, 0xdf, 0xfe, 0xb8, 0x0c, 0x55,
+	0x54, 0x4a, 0xa6, 0x2b, 0x30, 0xa6, 0x9e, 0x59, 0xc9, 0xf9, 0xe9, 0xc9, 0xd8, 0x15, 0x5b, 0x94,
+	0x74, 0xb4, 0xa4, 0x48, 0x9a, 0x1f, 0xf1, 0xfe, 0x99, 0x74, 0xb5, 0x18, 0x08, 0x32, 0x08, 0x1a,
+	0x01, 0xf4, 0xb5, 0x64, 0x10, 0x95, 0x56, 0x79, 0xf4, 0xe5, 0x6c, 0x9a, 0x47, 0xdf, 0x75, 0x60,
+	0xd6, 0x0f, 0x8e, 0xc2, 0x49, 0x30, 0x20, 0x86, 0xa8, 0xbb, 0x2a, 0x49, 0x27, 0x03, 0xc4, 0xa8,
+	0x28, 0x3f, 0x05, 0xf9, 0xa7, 0x00, 0x7b, 0x08, 0x8d, 0xf8, 0x22, 0xe8, 0x9b, 0x34, 0xbf, 0x2c,
+	0x67, 0x09, 0xe7, 0x60, 0xfd, 0xf0, 0x22, 0xe8, 0x13, 0x85, 0xa7, 0xc5, 0x9c, 0xdf, 0x86, 0xba,
+	0x82, 0x91, 0x2c, 0x5f, 0xed, 0x7f, 0x6f, 0xff, 0xc5, 0xeb, 0xfd, 0xde, 0xe1, 0x0f, 0xf7, 0xb7,
+	0xda, 0x57, 0xd8, 0x02, 0x34, 0x37, 0xb6, 0x88, 0xd2, 0x09, 0x28, 0x61, 0x91, 0x83, 0x8d, 0xc3,
+	0x43, 0x8d, 0x94, 0x1d, 0x86, 0x86, 0x7c, 0x4c, 0x9a, 0x9f, 0xf6, 0x7c, 0x7f, 0x0a, 0x8b, 0x06,
+	0x96, 0x5a, 0x11, 0x63, 0x04, 0x32, 0x56, 0x04, 0xa9, 0x8c, 0x22, 0xc7, 0x69, 0xc3, 0xfc, 0x53,
+	0x9e, 0x3c, 0x0b, 0x8e, 0x43, 0x55, 0xd3, 0xff, 0xa8, 0xc2, 0x82, 0x86, 0x64, 0x45, 0x77, 0x61,
+	0xc1, 0x1f, 0xf0, 0x20, 0xf1, 0x93, 0x8b, 0x9e, 0xe5, 0x2f, 0xc8, 0xc2, 0xa8, 0x6a, 0x7b, 0x43,
+	0xdf, 0x53, 0x07, 0x30, 0x22, 0x81, 0xf6, 0x33, 0xea, 0x00, 0xa6, 0xdf, 0x86, 0xe8, 0x4a, 0xb8,
+	0x29, 0x0a, 0xf3, 0x50, 0x02, 0x21, 0x2e, 0xb7, 0x19, 0xfd, 0x89, 0x50, 0x39, 0x8b, 0xb2, 0x70,
+	0xa9, 0x44, 0x4d, 0x38, 0xe4, 0x9a, 0xd0, 0x13, 0x34, 0x90, 0x3b, 0xe1, 0x98, 0x11, 0xf2, 0x31,
+	0x7b, 0xc2, 0x61, 0x9c, 0x92, 0xd4, 0x73, 0xa7, 0x24, 0x28, 0x3f, 0x2f, 0x82, 0x3e, 0x1f, 0xf4,
+	0x92, 0xb0, 0x47, 0x72, 0x9e, 0x48, 0xa2, 0xee, 0x66, 0x61, 0xdc, 0x37, 0x12, 0x1e, 0x27, 0x01,
+	0x17, 0x6e, 0xe9, 0xfa, 0x66, 0xb9, 0x53, 0x72, 0x15, 0x84, 0xf6, 0xc1, 0x24, 0xf2, 0xe3, 0x4e,
+	0x8b, 0xce, 0x3f, 0xe8, 0x37, 0xfb, 0x36, 0x5c, 0x3d, 0xe2, 0x71, 0xd2, 0x3b, 0xe5, 0xde, 0x80,
+	0x47, 0x44, 0x5e, 0xe2, 0xa0, 0x45, 0xa8, 0x5c, 0xc5, 0x99, 0x48, 0xb8, 0x67, 0x3c, 0x8a, 0xfd,
+	0x30, 0x20, 0x65, 0xab, 0xe1, 0xaa, 0x24, 0xd6, 0x87, 0x83, 0xd7, 0x1b, 0xb5, 0x9e, 0xc1, 0x05,
+	0x1a, 0x78, 0x71, 0x26, 0xbb, 0x0d, 0x33, 0x34, 0x80, 0xb8, 0xd3, 0x26, 0x9a, 0x69, 0xa5, 0x3c,
+	0xef, 0x07, 0xae, 0xcc, 0xc3, 0x55, 0xee, 0x87, 0xc3, 0x30, 0x22, 0x8d, 0xab, 0xe1, 0x8a, 0x84,
+	0x3d, 0x3b, 0x27, 0x91, 0x37, 0x3e, 0x95, 0x5a, 0x57, 0x16, 0xfe, 0x6e, 0xb5, 0xde, 0x6c, 0xb7,
+	0x9c, 0x3f, 0x05, 0x35, 0xaa, 0x96, 0xaa, 0xa3, 0xc9, 0x2c, 0xc9, 0xea, 0x08, 0xed, 0xc0, 0x6c,
+	0xc0, 0x93, 0xf3, 0x30, 0x7a, 0xa3, 0x4e, 0xf3, 0x64, 0xd2, 0xf9, 0x39, 0x59, 0x68, 0xfa, 0x74,
+	0xeb, 0x15, 0xa9, 0x96, 0x68, 0x67, 0x8b, 0xa5, 0x8a, 0x4f, 0x3d, 0x69, 0x34, 0xd6, 0x09, 0x38,
+	0x3c, 0xf5, 0x50, 0xd6, 0x5a, 0xab, 0x2f, 0xec, 0xf0, 0x26, 0x61, 0xbb, 0x62, 0xf1, 0x6f, 0xc3,
+	0xbc, 0x3a, 0x37, 0x8b, 0x7b, 0x43, 0x7e, 0x9c, 0x28, 0x2f, 0x5a, 0x30, 0x19, 0x91, 0xb1, 0xbe,
+	0xc7, 0x8f, 0x13, 0x67, 0x1f, 0x16, 0xa5, 0xfc, 0x7b, 0x31, 0xe6, 0xaa, 0xe9, 0xdf, 0x2c, 0xd2,
+	0x25, 0x9a, 0x0f, 0x97, 0x6c, 0x81, 0x29, 0x4e, 0x0a, 0xed, 0x92, 0x8e, 0x0b, 0xcc, 0x94, 0xa7,
+	0xb2, 0x42, 0xb9, 0x99, 0x2b, 0x3f, 0xa1, 0x1c, 0x8e, 0x85, 0xe1, 0xfc, 0xc4, 0x93, 0x7e, 0x5f,
+	0x9d, 0x76, 0xd6, 0x5d, 0x95, 0x74, 0xfe, 0xa0, 0x04, 0x4b, 0x54, 0x9b, 0xd2, 0x86, 0xe4, 0x9e,
+	0xf5, 0xe8, 0x2b, 0x74, 0x53, 0x79, 0x69, 0x85, 0x6f, 0x72, 0x19, 0x6a, 0xe6, 0x2e, 0x26, 0x12,
+	0x5f, 0xdd, 0x27, 0x53, 0xcd, 0xfa, 0x64, 0x9c, 0xbf, 0x55, 0x82, 0x45, 0xb1, 0x91, 0x90, 0xb6,
+	0x2d, 0x87, 0xff, 0xa7, 0x61, 0x4e, 0x68, 0x04, 0x52, 0x2a, 0xc8, 0x8e, 0xa6, 0xa2, 0x95, 0x50,
+	0x51, 0x78, 0xf7, 0x8a, 0x6b, 0x17, 0x66, 0x8f, 0x49, 0x2b, 0x0b, 0x7a, 0x84, 0x16, 0x9c, 0x8b,
+	0xdb, 0x73, 0xbd, 0x7b, 0xc5, 0x35, 0x8a, 0x6f, 0xd6, 0x51, 0x59, 0x46, 0xdc, 0x79, 0x0a, 0x73,
+	0x56, 0x43, 0x96, 0x3f, 0xa8, 0x25, 0xfc, 0x41, 0x39, 0xc7, 0x6b, 0xb9, 0xc0, 0xf1, 0xfa, 0xcf,
+	0x2a, 0xc0, 0x90, 0x58, 0x32, 0xab, 0xb1, 0x66, 0x9f, 0x5e, 0xa8, 0x23, 0xf2, 0x14, 0x62, 0xeb,
+	0xc0, 0x8c, 0xa4, 0x3a, 0x51, 0x11, 0x5b, 0x66, 0x41, 0x0e, 0x8a, 0x59, 0xa9, 0x71, 0xe8, 0xd3,
+	0x0a, 0xb2, 0xf3, 0xc5, 0xb4, 0x17, 0xe6, 0xe1, 0xae, 0x48, 0x47, 0x17, 0x68, 0x91, 0x48, 0xdb,
+	0x58, 0xa5, 0xb3, 0xeb, 0x3b, 0x73, 0xe9, 0xfa, 0xce, 0xe6, 0x7c, 0x6e, 0x86, 0x75, 0x56, 0xb7,
+	0xad, 0xb3, 0xdb, 0x30, 0xa7, 0x4e, 0x28, 0x7a, 0x23, 0x6c, 0x5d, 0x9a, 0xc2, 0x16, 0xc8, 0xee,
+	0x41, 0x5b, 0x19, 0x48, 0xda, 0x04, 0x14, 0xe7, 0x7c, 0x39, 0x1c, 0xe5, 0x7f, 0xea, 0x85, 0x6b,
+	0x52, 0x67, 0x53, 0x80, 0xec, 0x29, 0xa4, 0x90, 0xde, 0x24, 0x90, 0x47, 0xe3, 0x7c, 0x40, 0x46,
+	0x30, 0xda, 0x53, 0xd9, 0x0c, 0xe7, 0x6f, 0x94, 0xa0, 0x8d, 0x6b, 0x66, 0x91, 0xe5, 0x67, 0x40,
+	0x5c, 0xf1, 0x9e, 0x54, 0x69, 0x95, 0x65, 0x8f, 0xa0, 0x41, 0xe9, 0x70, 0xcc, 0x03, 0x49, 0x93,
+	0x1d, 0x9b, 0x26, 0x53, 0x79, 0xb2, 0x7b, 0xc5, 0x4d, 0x0b, 0x1b, 0x14, 0xf9, 0x1f, 0x4a, 0xd0,
+	0x94, 0xad, 0xfc, 0xd2, 0x5e, 0x9e, 0xae, 0x11, 0xcb, 0x20, 0x28, 0x29, 0x0d, 0x5d, 0xb8, 0x0b,
+	0x0b, 0x23, 0x2f, 0x99, 0x44, 0xb8, 0x9f, 0x5b, 0x1e, 0x9e, 0x2c, 0x8c, 0x9b, 0x33, 0x89, 0xce,
+	0xb8, 0x97, 0xf8, 0xc3, 0x9e, 0xca, 0x95, 0x51, 0x03, 0x45, 0x59, 0x28, 0x41, 0xe2, 0xc4, 0x3b,
+	0xe1, 0x72, 0xdf, 0x15, 0x09, 0xa7, 0x03, 0x2b, 0x07, 0xe9, 0xa9, 0x8d, 0xa1, 0x5f, 0x3b, 0xff,
+	0x64, 0x0e, 0x56, 0x73, 0x59, 0x3a, 0xc6, 0x49, 0xba, 0x2d, 0x86, 0xfe, 0xe8, 0x28, 0xd4, 0xc6,
+	0x49, 0xc9, 0xf4, 0x68, 0x58, 0x59, 0xec, 0x04, 0xae, 0x2a, 0x05, 0x03, 0xe7, 0x34, 0xdd, 0x0c,
+	0xcb, 0xb4, 0xcb, 0x7d, 0x62, 0x2f, 0x61, 0xb6, 0x41, 0x85, 0x9b, 0x4c, 0x5c, 0x5c, 0x1f, 0x3b,
+	0x85, 0x8e, 0xd6, 0x64, 0xa4, 0xb0, 0x36, 0xb4, 0x1d, 0x6c, 0xeb, 0xe3, 0x4b, 0xda, 0xb2, 0xd4,
+	0x71, 0x77, 0x6a, 0x6d, 0xec, 0x02, 0x6e, 0xaa, 0x3c, 0x92, 0xc6, 0xf9, 0xf6, 0xaa, 0xef, 0x35,
+	0x36, 0x32, 0x34, 0xec, 0x46, 0x2f, 0xa9, 0x98, 0xfd, 0x14, 0x56, 0xce, 0x3d, 0x3f, 0x51, 0xdd,
+	0x32, 0x74, 0x8b, 0x1a, 0x35, 0xf9, 0xf0, 0x92, 0x26, 0x5f, 0x8b, 0x8f, 0xad, 0x2d, 0x6a, 0x4a,
+	0x8d, 0xdd, 0x3f, 0x2a, 0xc3, 0xbc, 0x5d, 0x0f, 0x92, 0xa9, 0xe4, 0x7d, 0x25, 0x03, 0x95, 0x36,
+	0x9a, 0x81, 0xf3, 0x36, 0x7e, 0xb9, 0xc8, 0xc6, 0x37, 0xad, 0xea, 0xca, 0x65, 0xee, 0xc1, 0xea,
+	0xfb, 0xb9, 0x07, 0x6b, 0x85, 0xee, 0xc1, 0xe9, 0x5e, 0xa4, 0x99, 0x5f, 0xd6, 0x8b, 0x34, 0xfb,
+	0x4e, 0x2f, 0x52, 0xf7, 0xff, 0x94, 0x80, 0xe5, 0xa9, 0x97, 0x3d, 0x15, 0x6e, 0x8d, 0x80, 0x0f,
+	0xa5, 0x10, 0xfb, 0xe6, 0xfb, 0x71, 0x80, 0x5a, 0x2d, 0xf5, 0x35, 0xb2, 0xa2, 0x19, 0x68, 0x64,
+	0xaa, 0x57, 0x73, 0x6e, 0x51, 0x56, 0xc6, 0x45, 0x5a, 0xbd, 0xdc, 0x45, 0x5a, 0xbb, 0xdc, 0x45,
+	0x3a, 0x93, 0x75, 0x91, 0x76, 0xff, 0x72, 0x09, 0x96, 0x0a, 0xc8, 0xec, 0xd7, 0x37, 0x70, 0x24,
+	0x0c, 0x4b, 0xfa, 0x94, 0x25, 0x61, 0x98, 0x60, 0xf7, 0xcf, 0xc3, 0x9c, 0xc5, 0x5a, 0xbf, 0xbe,
+	0xf6, 0xb3, 0x1a, 0xa2, 0xa0, 0x6c, 0x0b, 0xeb, 0xfe, 0xcf, 0x32, 0xb0, 0x3c, 0x7b, 0xff, 0x7f,
+	0xed, 0x43, 0x7e, 0x9e, 0x2a, 0x05, 0xf3, 0xf4, 0xff, 0x74, 0xe7, 0xf9, 0x18, 0x16, 0x65, 0xf4,
+	0xa4, 0xe1, 0xc8, 0x12, 0x14, 0x93, 0xcf, 0x40, 0x1d, 0xd9, 0xf6, 0x4f, 0xd7, 0xad, 0x68, 0x31,
+	0x63, 0xfb, 0xcd, 0xb8, 0xa9, 0x9d, 0x2e, 0x74, 0xe4, 0x0c, 0xed, 0x9c, 0xf1, 0x20, 0x39, 0x9c,
+	0x1c, 0x89, 0xf0, 0x41, 0x3f, 0x0c, 0x9c, 0x7f, 0x5e, 0xd1, 0x6a, 0x3e, 0x65, 0x4a, 0x85, 0xe2,
+	0xdb, 0xd0, 0x32, 0xb7, 0x0f, 0xb9, 0x1c, 0x19, 0x5f, 0x26, 0xaa, 0x12, 0x66, 0x29, 0xb6, 0x0d,
+	0xf3, 0x24, 0x24, 0x07, 0xfa, 0xbb, 0x32, 0x7d, 0xf7, 0x0e, 0xff, 0xcc, 0xee, 0x15, 0x37, 0xf3,
+	0x0d, 0xfb, 0x2d, 0x98, 0xb7, 0x8d, 0x3f, 0xa9, 0x95, 0x14, 0x59, 0x03, 0xf8, 0xb9, 0x5d, 0x98,
+	0x6d, 0x40, 0x3b, 0x6b, 0x3d, 0xca, 0x48, 0x9e, 0x29, 0x15, 0xe4, 0x8a, 0xb3, 0x47, 0xf2, 0xb0,
+	0xb2, 0x46, 0x7e, 0x93, 0xdb, 0xf6, 0x67, 0xc6, 0x34, 0xad, 0x8b, 0x3f, 0xc6, 0xf1, 0xe5, 0xef,
+	0x00, 0xa4, 0x18, 0x6b, 0x43, 0xeb, 0xc5, 0xc1, 0xce, 0x7e, 0x6f, 0x6b, 0x77, 0x63, 0x7f, 0x7f,
+	0x67, 0xaf, 0x7d, 0x85, 0x31, 0x98, 0x27, 0x37, 0xdf, 0xb6, 0xc6, 0x4a, 0x88, 0x49, 0xc7, 0x8a,
+	0xc2, 0xca, 0x6c, 0x19, 0xda, 0xcf, 0xf6, 0x33, 0x68, 0x65, 0xb3, 0xa1, 0xf9, 0xc3, 0x59, 0x81,
+	0x65, 0x11, 0x1d, 0xbb, 0x29, 0xc8, 0x43, 0x69, 0x27, 0x7f, 0xaf, 0x04, 0x57, 0x33, 0x19, 0x69,
+	0xa8, 0x97, 0x50, 0x40, 0x6c, 0xad, 0xc4, 0x06, 0xe9, 0xf0, 0x41, 0xe9, 0x9a, 0x19, 0x09, 0x92,
+	0xcf, 0x40, 0x9a, 0x37, 0x74, 0xd3, 0x0c, 0x27, 0x15, 0x65, 0x39, 0xab, 0x3a, 0xaa, 0x26, 0xd3,
+	0xf1, 0x63, 0x11, 0x75, 0x6b, 0x66, 0xa4, 0x87, 0xbf, 0x76, 0x97, 0x55, 0x12, 0xcd, 0x0a, 0x4b,
+	0xd9, 0xb1, 0xfb, 0x5b, 0x98, 0xe7, 0xfc, 0xc3, 0x0a, 0xb0, 0xef, 0x4f, 0x78, 0x74, 0x41, 0xf1,
+	0x5c, 0xda, 0x6b, 0xba, 0x9a, 0xf5, 0x09, 0xce, 0x8c, 0x27, 0x47, 0xdf, 0xe3, 0x17, 0x2a, 0xba,
+	0xb1, 0x9c, 0x46, 0x37, 0x16, 0x45, 0x18, 0x56, 0x2f, 0x8f, 0x30, 0xac, 0x5d, 0x16, 0x61, 0xf8,
+	0x35, 0x98, 0xf3, 0x4f, 0x82, 0x10, 0x79, 0x1e, 0xf5, 0x84, 0xb8, 0x33, 0xb3, 0x56, 0x41, 0xdb,
+	0x5a, 0x82, 0xfb, 0x88, 0xb1, 0xc7, 0x69, 0x21, 0x3e, 0x38, 0xa1, 0x68, 0x56, 0x53, 0x0a, 0xec,
+	0x0c, 0x4e, 0xf8, 0x5e, 0xd8, 0xf7, 0x92, 0x30, 0x22, 0xc7, 0x8e, 0xfa, 0x18, 0xf1, 0x98, 0xdd,
+	0x86, 0xf9, 0x38, 0x9c, 0xa0, 0xe6, 0xa4, 0xc6, 0x2a, 0x3c, 0x49, 0x2d, 0x81, 0x1e, 0x88, 0x11,
+	0xaf, 0xc3, 0xd2, 0x24, 0xe6, 0xbd, 0x91, 0x1f, 0xc7, 0xb8, 0x3b, 0xf6, 0xc3, 0x20, 0x89, 0xc2,
+	0xa1, 0xf4, 0x27, 0x2d, 0x4e, 0x62, 0xfe, 0x5c, 0xe4, 0x6c, 0x89, 0x0c, 0xf6, 0xed, 0xb4, 0x4b,
+	0x63, 0xcf, 0x8f, 0xe2, 0x0e, 0x50, 0x97, 0xd4, 0x48, 0xb1, 0xdf, 0x07, 0x9e, 0x1f, 0xe9, 0xbe,
+	0x60, 0x22, 0xce, 0x44, 0x48, 0x36, 0x33, 0x11, 0x92, 0x32, 0xc0, 0x6e, 0x1d, 0xea, 0xea, 0x73,
+	0x34, 0x72, 0x8f, 0xa3, 0x70, 0xa4, 0x8c, 0x5c, 0xfc, 0xcd, 0xe6, 0xa1, 0x9c, 0x84, 0xd2, 0x40,
+	0x2d, 0x27, 0xa1, 0xf3, 0xbb, 0xd0, 0x34, 0x66, 0x80, 0x7d, 0x28, 0xec, 0x6d, 0x54, 0xa8, 0xa4,
+	0x75, 0x2c, 0x8e, 0x49, 0x1a, 0x12, 0x7d, 0x36, 0x60, 0xdf, 0x80, 0xc5, 0x81, 0x1f, 0x71, 0x0a,
+	0xac, 0xed, 0x45, 0xfc, 0x8c, 0x47, 0xb1, 0xf2, 0x25, 0xb4, 0x75, 0x86, 0x2b, 0x70, 0xa7, 0x07,
+	0x4b, 0x16, 0xe9, 0x68, 0xce, 0x9a, 0xa1, 0xa8, 0x40, 0xe5, 0xce, 0xb4, 0x23, 0x06, 0x65, 0x1e,
+	0xee, 0x49, 0xd2, 0x0d, 0xd2, 0x1b, 0x47, 0xe1, 0x11, 0x35, 0x52, 0x72, 0x2d, 0xcc, 0xf9, 0xc7,
+	0x65, 0xa8, 0xec, 0x86, 0x63, 0xf3, 0x70, 0xa7, 0x94, 0x3f, 0xdc, 0x91, 0xca, 0x63, 0x4f, 0xeb,
+	0x86, 0x72, 0x87, 0xb7, 0x40, 0x76, 0x0f, 0xe6, 0xbd, 0x51, 0xd2, 0x4b, 0x42, 0x54, 0x96, 0xcf,
+	0xbd, 0x48, 0x84, 0x10, 0x56, 0x88, 0x2c, 0x32, 0x39, 0x6c, 0x19, 0x2a, 0x5a, 0xe7, 0xa1, 0x02,
+	0x98, 0x44, 0x4b, 0x8d, 0x0e, 0xd0, 0x2f, 0xa4, 0xcf, 0x52, 0xa6, 0x90, 0xeb, 0xed, 0xef, 0x85,
+	0x99, 0x2c, 0x76, 0xae, 0xa2, 0x2c, 0x54, 0x64, 0x91, 0x11, 0x46, 0xa9, 0x5e, 0xa8, 0xd3, 0xa6,
+	0x37, 0xbe, 0x6e, 0x7b, 0xe3, 0xd7, 0xa0, 0x99, 0x0c, 0xcf, 0x7a, 0x63, 0xef, 0x62, 0x18, 0x7a,
+	0x03, 0x49, 0x80, 0x26, 0xe4, 0xfc, 0x49, 0x09, 0x6a, 0x34, 0xcb, 0xb8, 0x4f, 0x0b, 0x41, 0xa6,
+	0x4f, 0x80, 0x68, 0xe6, 0xe6, 0xdc, 0x2c, 0xcc, 0x1c, 0x2b, 0x18, 0xbc, 0xac, 0x87, 0x6c, 0x06,
+	0x84, 0xaf, 0x41, 0x43, 0xa4, 0x74, 0x60, 0x33, 0x15, 0x49, 0x41, 0x76, 0x13, 0xaa, 0xa7, 0xe1,
+	0x58, 0x99, 0x32, 0xa0, 0x0e, 0x89, 0xc3, 0xb1, 0x4b, 0x78, 0xda, 0x1f, 0xac, 0x4f, 0x0c, 0x5c,
+	0xa8, 0x8b, 0x59, 0x18, 0x55, 0x74, 0x5d, 0xad, 0x39, 0x91, 0x19, 0xd4, 0x79, 0x05, 0x0b, 0xc8,
+	0x0b, 0x86, 0x47, 0x7c, 0xba, 0xd0, 0xfa, 0x3a, 0xee, 0x81, 0xfd, 0xe1, 0x64, 0xc0, 0x4d, 0x83,
+	0x92, 0x3c, 0x9e, 0x12, 0x57, 0xaa, 0x94, 0xf3, 0x4f, 0x4b, 0x82, 0xc7, 0xb0, 0x5e, 0x76, 0x17,
+	0xaa, 0x28, 0x7a, 0x32, 0xfe, 0x03, 0x1d, 0x4b, 0x82, 0xe5, 0x5c, 0x2a, 0x81, 0xd4, 0x4c, 0x3e,
+	0x49, 0xb3, 0x76, 0xe1, 0x91, 0x4c, 0xad, 0x31, 0x3d, 0xb2, 0x8c, 0x11, 0x93, 0x41, 0xd9, 0xba,
+	0x71, 0xa0, 0x53, 0xb5, 0xc4, 0x99, 0xda, 0x72, 0x07, 0x27, 0xdc, 0x38, 0xc8, 0xf9, 0xc3, 0x12,
+	0xcc, 0x59, 0x7d, 0x42, 0x4a, 0x19, 0x7a, 0x71, 0x22, 0xcf, 0xf2, 0xe5, 0xca, 0x9b, 0x90, 0x49,
+	0x65, 0x65, 0x9b, 0xca, 0xf4, 0xc1, 0x40, 0xc5, 0x3c, 0x18, 0x78, 0x00, 0x8d, 0xf4, 0x36, 0x80,
+	0xdd, 0x29, 0x6c, 0x51, 0x45, 0xd5, 0xa4, 0x85, 0x52, 0xd7, 0x73, 0xcd, 0x70, 0x3d, 0x3b, 0x8f,
+	0xa1, 0x69, 0x94, 0x37, 0x5d, 0xc7, 0x25, 0xcb, 0x75, 0xac, 0x43, 0xce, 0xca, 0x69, 0xc8, 0x99,
+	0xf3, 0x65, 0x19, 0xe6, 0x90, 0xbc, 0xfd, 0xe0, 0xe4, 0x20, 0x1c, 0xfa, 0xfd, 0x0b, 0x22, 0x2b,
+	0x45, 0xc9, 0x72, 0xeb, 0x51, 0x64, 0x6e, 0xc3, 0xc8, 0x72, 0x3a, 0xce, 0x56, 0xc8, 0x07, 0x9d,
+	0x46, 0x01, 0x82, 0xec, 0x77, 0xe4, 0xc5, 0x92, 0x27, 0xa5, 0xea, 0x6b, 0x81, 0xc8, 0xe6, 0x08,
+	0x50, 0x00, 0xe1, 0xc8, 0x1f, 0x0e, 0x7d, 0x51, 0x56, 0x18, 0x46, 0x45, 0x59, 0xd8, 0xe6, 0xc0,
+	0x8f, 0xbd, 0xa3, 0xf4, 0xd0, 0x4f, 0xa7, 0xc9, 0xab, 0xe6, 0xbd, 0x35, 0xbc, 0x6a, 0x22, 0xe2,
+	0xd8, 0x06, 0xb3, 0x0b, 0x39, 0x9b, 0x5b, 0x48, 0xe7, 0xdf, 0x94, 0xa1, 0x69, 0x90, 0x05, 0xb2,
+	0x73, 0xa1, 0x8c, 0x37, 0x50, 0x79, 0x1a, 0x1e, 0x58, 0xa6, 0xb6, 0x81, 0xb0, 0xdb, 0x76, 0xab,
+	0xe4, 0x5d, 0x27, 0x86, 0xb7, 0x48, 0xe8, 0x06, 0x34, 0x90, 0xf4, 0x3f, 0x21, 0xbb, 0x5e, 0x5e,
+	0xc5, 0xd1, 0x80, 0xca, 0x7d, 0x48, 0xb9, 0xb5, 0x34, 0x97, 0x80, 0x77, 0x9e, 0x8f, 0x3f, 0x82,
+	0x96, 0xac, 0x86, 0xd6, 0x98, 0x06, 0x9d, 0x32, 0x9f, 0xb5, 0xfe, 0xae, 0x55, 0x52, 0x7d, 0xf9,
+	0x50, 0x7d, 0x59, 0xbf, 0xec, 0x4b, 0x55, 0xd2, 0x79, 0xaa, 0x43, 0x0f, 0x9e, 0x46, 0xde, 0xf8,
+	0x54, 0x09, 0x94, 0x07, 0xb0, 0xa4, 0xe4, 0xc6, 0x24, 0xf0, 0x82, 0x20, 0x9c, 0x04, 0x7d, 0xae,
+	0xa2, 0xd3, 0x8a, 0xb2, 0x9c, 0x81, 0x8e, 0x65, 0xa6, 0x8a, 0xd8, 0x3d, 0xa8, 0x09, 0xe5, 0x45,
+	0x6c, 0x85, 0xc5, 0x22, 0x44, 0x14, 0x61, 0x77, 0xa1, 0x26, 0x74, 0x98, 0xf2, 0x54, 0xa6, 0x17,
+	0x05, 0x9c, 0x75, 0x58, 0xa0, 0xe0, 0x69, 0x43, 0xf6, 0x5d, 0x2f, 0xda, 0x22, 0x67, 0xfa, 0x22,
+	0xc4, 0x7a, 0x19, 0xd8, 0xbe, 0xe0, 0x2b, 0xf3, 0x00, 0xf1, 0x4f, 0x2a, 0xd0, 0x34, 0x60, 0x94,
+	0x4f, 0x74, 0xea, 0xd3, 0x1b, 0xf8, 0xde, 0x88, 0x27, 0x3c, 0x92, 0xbc, 0x94, 0x41, 0xb1, 0x9c,
+	0x77, 0x76, 0xd2, 0x0b, 0x27, 0x49, 0x6f, 0xc0, 0x4f, 0x22, 0xce, 0xe5, 0xde, 0x9d, 0x41, 0xb1,
+	0x1c, 0x52, 0xb3, 0x51, 0x4e, 0x9c, 0xd3, 0x64, 0x50, 0x75, 0x1c, 0x28, 0xe6, 0xa9, 0x9a, 0x1e,
+	0x07, 0x8a, 0x59, 0xc9, 0x4a, 0xd6, 0x5a, 0x81, 0x64, 0xfd, 0x14, 0x56, 0x84, 0x0c, 0x95, 0xd2,
+	0xa3, 0x97, 0x21, 0xae, 0x29, 0xb9, 0xec, 0x1e, 0xb4, 0xb1, 0xcf, 0x8a, 0x35, 0x62, 0xff, 0xe7,
+	0x82, 0xc7, 0x4a, 0x6e, 0x0e, 0xc7, 0xb2, 0xe4, 0xa3, 0x36, 0xcb, 0x8a, 0x98, 0x8c, 0x1c, 0x4e,
+	0x65, 0xbd, 0xb7, 0x76, 0xd9, 0x86, 0x2c, 0x9b, 0xc1, 0xd9, 0x23, 0x58, 0x1d, 0xf1, 0x81, 0xef,
+	0xd9, 0x55, 0x90, 0xcb, 0x48, 0x04, 0x94, 0x4d, 0xcb, 0xc6, 0x56, 0x70, 0x16, 0x7e, 0x1e, 0x8e,
+	0x8e, 0x7c, 0xb1, 0xb1, 0x09, 0x6f, 0x7a, 0xd5, 0xcd, 0xe1, 0xce, 0x1c, 0x34, 0x0f, 0x93, 0x70,
+	0xac, 0x96, 0x7e, 0x1e, 0x5a, 0x22, 0x29, 0xe3, 0x11, 0xaf, 0xc3, 0x35, 0xa2, 0xd7, 0x97, 0xe1,
+	0x38, 0x1c, 0x86, 0x27, 0x17, 0x96, 0x4d, 0xfc, 0xef, 0x4b, 0xb0, 0x64, 0xe5, 0xa6, 0x46, 0x31,
+	0x39, 0xf0, 0x54, 0x10, 0x99, 0x20, 0xf1, 0x45, 0x63, 0x5b, 0x10, 0x05, 0xc5, 0x59, 0xc9, 0x2b,
+	0x19, 0x57, 0xb6, 0x91, 0xde, 0x8c, 0x50, 0x1f, 0x0a, 0x7a, 0xef, 0xe4, 0xe9, 0x5d, 0x7e, 0xaf,
+	0xee, 0x4c, 0xa8, 0x2a, 0x7e, 0x4b, 0x46, 0xd0, 0x0c, 0xe4, 0xa0, 0x2b, 0x76, 0xd4, 0x83, 0xe9,
+	0x43, 0x51, 0x3d, 0xe8, 0x6b, 0x30, 0x76, 0x7e, 0x51, 0x02, 0x48, 0x7b, 0x47, 0x71, 0x17, 0x7a,
+	0x6b, 0x13, 0xb7, 0x6f, 0x8d, 0x6d, 0xec, 0x43, 0x68, 0xe9, 0xa3, 0xf3, 0x74, 0xb7, 0x6c, 0x2a,
+	0x0c, 0xb5, 0x8b, 0x3b, 0xb0, 0x70, 0x32, 0x0c, 0x8f, 0x48, 0x8b, 0xa1, 0x00, 0xd7, 0x58, 0x46,
+	0x65, 0xce, 0x0b, 0xf8, 0x89, 0x44, 0xd3, 0xad, 0xb5, 0x6a, 0x6e, 0xad, 0xc5, 0x1b, 0xe5, 0x97,
+	0x65, 0x7d, 0x7e, 0x99, 0xce, 0xc4, 0x3b, 0xb9, 0x9c, 0x3d, 0xcc, 0x89, 0xf5, 0x29, 0x47, 0x86,
+	0xa4, 0xef, 0x1f, 0x5c, 0xea, 0x52, 0x7d, 0x0c, 0xf3, 0x91, 0x90, 0x99, 0x4a, 0xa0, 0x56, 0xdf,
+	0x21, 0x50, 0xe7, 0x22, 0x6b, 0x67, 0xfe, 0x3a, 0xb4, 0xbd, 0xc1, 0x19, 0x8f, 0x12, 0x9f, 0x5c,
+	0x4c, 0xa4, 0x46, 0x89, 0x01, 0x2e, 0x18, 0x38, 0x69, 0x2b, 0x77, 0x60, 0x41, 0xc6, 0xc8, 0xea,
+	0x92, 0xf2, 0x2e, 0x5b, 0x0a, 0x63, 0x41, 0xe7, 0x1f, 0xa8, 0xe3, 0x52, 0x7b, 0x75, 0xdf, 0x3d,
+	0x2b, 0xe6, 0x08, 0xcb, 0x99, 0x11, 0x7e, 0x4d, 0x1e, 0x5f, 0x0e, 0x94, 0x2f, 0xab, 0x62, 0xc4,
+	0x62, 0x0d, 0xe4, 0x71, 0xb3, 0x3d, 0xad, 0xd5, 0xf7, 0x99, 0x56, 0xe7, 0x3f, 0x95, 0x60, 0x76,
+	0x37, 0x1c, 0xef, 0xe2, 0x14, 0xa3, 0x8e, 0x83, 0x6c, 0xa2, 0x03, 0xd4, 0x55, 0xf2, 0x92, 0x98,
+	0xb5, 0x42, 0xad, 0x64, 0x2e, 0xab, 0x95, 0xfc, 0x59, 0xb8, 0x4e, 0xde, 0xd4, 0x28, 0x1c, 0x87,
+	0x11, 0xb2, 0xab, 0x37, 0x14, 0x2a, 0x48, 0x18, 0x24, 0xa7, 0x4a, 0x9c, 0xbe, 0xab, 0x08, 0xb9,
+	0x38, 0xd0, 0xf2, 0x14, 0xd6, 0x8c, 0xd4, 0xa2, 0x84, 0x94, 0xcd, 0x67, 0x38, 0xbf, 0x09, 0x0d,
+	0xb2, 0x30, 0x68, 0x68, 0x1f, 0x43, 0xe3, 0x34, 0x1c, 0xf7, 0x4e, 0xfd, 0x20, 0x51, 0xec, 0x3f,
+	0x9f, 0xaa, 0xfe, 0xbb, 0x34, 0x29, 0xba, 0x80, 0xf3, 0xaf, 0x67, 0x60, 0xf6, 0x59, 0x70, 0x16,
+	0xfa, 0x7d, 0x3a, 0xa2, 0x1d, 0xf1, 0x51, 0xa8, 0x42, 0xf6, 0xf1, 0x37, 0x4e, 0x07, 0xc5, 0xa7,
+	0x8e, 0x05, 0xf1, 0xb6, 0x44, 0x28, 0x86, 0x84, 0xe8, 0xb2, 0x69, 0x7a, 0xdd, 0x4e, 0x30, 0x98,
+	0x81, 0xa0, 0x75, 0x16, 0x99, 0xd7, 0xe5, 0x64, 0x2a, 0xbd, 0x12, 0x51, 0x33, 0xae, 0x44, 0x60,
+	0x5b, 0x32, 0x92, 0x4e, 0x84, 0x5a, 0x89, 0xb6, 0x24, 0x44, 0x16, 0x65, 0xc4, 0x85, 0x37, 0x5c,
+	0x2b, 0x5e, 0x68, 0x51, 0x9a, 0x20, 0x2a, 0x67, 0xe2, 0x03, 0x51, 0x46, 0x6c, 0x06, 0x26, 0x84,
+	0xea, 0x69, 0xf6, 0x96, 0xa6, 0xb8, 0x25, 0x9b, 0x85, 0x51, 0x96, 0x0f, 0xb8, 0x16, 0xb9, 0x62,
+	0x1c, 0x20, 0xae, 0x14, 0x66, 0x71, 0xc3, 0x0e, 0x15, 0xa1, 0xc4, 0xca, 0x0e, 0x45, 0x82, 0xf1,
+	0x86, 0xc3, 0x23, 0xaf, 0xff, 0x86, 0x2e, 0xe9, 0xd2, 0xa1, 0x69, 0xc3, 0xb5, 0x41, 0x8a, 0x87,
+	0x4b, 0x57, 0x95, 0x82, 0x56, 0xaa, 0xae, 0x09, 0xb1, 0x87, 0xd0, 0x24, 0x1b, 0x5d, 0xae, 0xeb,
+	0x3c, 0xad, 0x6b, 0xdb, 0x34, 0xe2, 0x69, 0x65, 0xcd, 0x42, 0xe6, 0xf1, 0xf1, 0x42, 0x2e, 0xb8,
+	0xd7, 0x1b, 0x0c, 0xe4, 0xa9, 0x7b, 0x5b, 0x5c, 0xab, 0xd3, 0x00, 0x79, 0x01, 0xc4, 0x84, 0x89,
+	0x02, 0x8b, 0x54, 0xc0, 0xc2, 0xd8, 0x4d, 0xa8, 0xa3, 0xd5, 0x37, 0xf6, 0xfc, 0x01, 0xc5, 0xa9,
+	0x08, 0xe3, 0x53, 0x63, 0x58, 0x87, 0xfa, 0x4d, 0xdb, 0xe6, 0x12, 0xcd, 0x8a, 0x85, 0xe1, 0xdc,
+	0xe8, 0xf4, 0x28, 0x8d, 0x06, 0xb6, 0x41, 0xf6, 0x09, 0x9d, 0x7d, 0x26, 0x9c, 0x42, 0x7e, 0xe7,
+	0x1f, 0x5e, 0x97, 0x63, 0x96, 0x44, 0xab, 0xfe, 0x1e, 0x62, 0x11, 0x57, 0x94, 0x44, 0xa5, 0x4d,
+	0xb8, 0x9f, 0x57, 0x2c, 0xa5, 0x4d, 0x16, 0x25, 0xf7, 0xb3, 0x28, 0xe0, 0x6c, 0x40, 0xcb, 0xac,
+	0x80, 0xd5, 0xa1, 0xfa, 0xe2, 0x60, 0x67, 0xbf, 0x7d, 0x85, 0x35, 0x61, 0xf6, 0x70, 0xe7, 0xe5,
+	0xcb, 0xbd, 0x9d, 0xed, 0x76, 0x89, 0xb5, 0xa0, 0xae, 0xc3, 0x1c, 0xcb, 0x98, 0xda, 0xd8, 0xda,
+	0xda, 0x39, 0x78, 0xb9, 0xb3, 0xdd, 0xae, 0x38, 0x7f, 0x50, 0x86, 0xa6, 0x51, 0xf3, 0x25, 0x7e,
+	0x91, 0x9b, 0x00, 0x64, 0x49, 0xa4, 0x01, 0x0f, 0x55, 0xd7, 0x40, 0x50, 0x32, 0x6a, 0x1b, 0xbb,
+	0x22, 0x6e, 0x17, 0xaa, 0x34, 0xcd, 0x17, 0x5d, 0xe3, 0x33, 0xbd, 0xfc, 0x35, 0xd7, 0x06, 0x91,
+	0x96, 0x24, 0x40, 0x51, 0x77, 0x82, 0xc3, 0x4c, 0x08, 0xd7, 0x26, 0xe2, 0x71, 0x38, 0x3c, 0xe3,
+	0xa2, 0x88, 0xd0, 0xc7, 0x2c, 0x0c, 0xdb, 0x92, 0x22, 0xc6, 0x88, 0x88, 0xad, 0xb9, 0x36, 0xc8,
+	0xbe, 0xa9, 0xd6, 0xa6, 0x4e, 0x6b, 0xb3, 0x9a, 0x9f, 0x68, 0x73, 0x5d, 0x9c, 0x04, 0xd8, 0xc6,
+	0x60, 0x20, 0x73, 0xcd, 0xbb, 0x8a, 0x91, 0x79, 0x31, 0x56, 0x09, 0x89, 0x02, 0x46, 0x2d, 0x17,
+	0x33, 0xea, 0x3b, 0xc9, 0xd9, 0xd9, 0x81, 0xe6, 0x81, 0x71, 0xd5, 0x96, 0x64, 0x96, 0xba, 0x64,
+	0x2b, 0x65, 0x9d, 0x81, 0x18, 0xdd, 0x29, 0x9b, 0xdd, 0x71, 0xfe, 0x7e, 0x49, 0xdc, 0x5e, 0xd2,
+	0xdd, 0x17, 0x6d, 0x3b, 0xd0, 0xd2, 0x3e, 0xdc, 0x34, 0xe0, 0xdb, 0xc2, 0xb0, 0x0c, 0x75, 0xa5,
+	0x17, 0x1e, 0x1f, 0xc7, 0x5c, 0x85, 0x66, 0x5a, 0x98, 0x52, 0x1c, 0x51, 0x15, 0xf5, 0x45, 0x0b,
+	0xb1, 0x0c, 0xd1, 0xcc, 0xe1, 0x48, 0x24, 0xd2, 0x0d, 0xa8, 0x82, 0x52, 0x75, 0x5a, 0xc7, 0xa5,
+	0x67, 0x67, 0xf9, 0x1e, 0xd4, 0x75, 0xbd, 0xf6, 0xae, 0xa0, 0x4a, 0xea, 0x7c, 0xdc, 0x7d, 0xc8,
+	0xa8, 0xb4, 0x3a, 0x2d, 0x68, 0x35, 0x9f, 0xc1, 0xd6, 0x81, 0x1d, 0xfb, 0x51, 0xb6, 0xb8, 0x20,
+	0xde, 0x82, 0x1c, 0xe7, 0x35, 0x2c, 0x29, 0x9e, 0x33, 0x34, 0x5a, 0x7b, 0x11, 0x4b, 0x97, 0xc9,
+	0xa4, 0x72, 0x5e, 0x26, 0x39, 0x7f, 0x5c, 0x81, 0x59, 0xb9, 0xd2, 0xb9, 0xeb, 0xda, 0x62, 0x9d,
+	0x2d, 0x8c, 0x75, 0xac, 0x8b, 0x79, 0x24, 0xc0, 0xe4, 0x4e, 0x94, 0xdb, 0x6b, 0x2a, 0x45, 0x7b,
+	0x0d, 0x83, 0xea, 0xd8, 0x4b, 0x4e, 0xc9, 0xf5, 0xd2, 0x70, 0xe9, 0xb7, 0xf2, 0x52, 0xd6, 0x6c,
+	0x2f, 0x65, 0xd1, 0xe5, 0x74, 0xa1, 0x4e, 0xe5, 0x2f, 0xa7, 0xdf, 0x80, 0x86, 0xb8, 0xd0, 0x9c,
+	0x3a, 0x22, 0x53, 0x00, 0xa9, 0x57, 0x24, 0x48, 0x42, 0xc8, 0x3b, 0x32, 0x29, 0xf2, 0x15, 0x76,
+	0xb7, 0x6f, 0xc3, 0x8c, 0xb8, 0xa4, 0x21, 0x43, 0x6f, 0x6f, 0xa8, 0x43, 0x3a, 0x51, 0x4e, 0xfd,
+	0x15, 0x31, 0x3c, 0xae, 0x2c, 0x6b, 0x5e, 0xf3, 0x6c, 0xda, 0xd7, 0x3c, 0x4d, 0xff, 0x69, 0xcb,
+	0xf6, 0x9f, 0x3a, 0x4f, 0x60, 0xce, 0xaa, 0x0e, 0xa5, 0xab, 0x0c, 0xdd, 0x6d, 0x5f, 0x61, 0x73,
+	0xd0, 0x78, 0xb6, 0xdf, 0x7b, 0xb2, 0xf7, 0xec, 0xe9, 0xee, 0xcb, 0x76, 0x09, 0x93, 0x87, 0xaf,
+	0xb6, 0xb6, 0x76, 0x76, 0xb6, 0x49, 0xda, 0x02, 0xcc, 0x3c, 0xd9, 0x78, 0xb6, 0x47, 0xb2, 0x76,
+	0x5b, 0xd0, 0xb6, 0xac, 0x4b, 0x1f, 0x8c, 0x7c, 0x13, 0x98, 0xb2, 0xfb, 0x29, 0x84, 0x67, 0x3c,
+	0xe4, 0x89, 0x8a, 0x2a, 0x5f, 0x94, 0x39, 0xcf, 0x74, 0x86, 0xba, 0x18, 0x91, 0xd6, 0x92, 0xb2,
+	0x88, 0x9c, 0xa4, 0x2c, 0x8b, 0xc8, 0xa2, 0xae, 0xce, 0x77, 0xba, 0xd0, 0xd9, 0xe6, 0x58, 0xdb,
+	0xc6, 0x70, 0x98, 0xe9, 0x0e, 0x1a, 0x6e, 0x05, 0x79, 0xd2, 0xaa, 0xfb, 0x3e, 0x5c, 0xdd, 0x10,
+	0x01, 0xe4, 0xbf, 0xae, 0xf8, 0x42, 0xa7, 0x03, 0x2b, 0xd9, 0x2a, 0x65, 0x63, 0x4f, 0x60, 0x71,
+	0x9b, 0x1f, 0x4d, 0x4e, 0xf6, 0xf8, 0x59, 0xda, 0x10, 0x83, 0x6a, 0x7c, 0x1a, 0x9e, 0xcb, 0xf9,
+	0xa1, 0xdf, 0xec, 0x03, 0x80, 0x21, 0x96, 0xe9, 0xc5, 0x63, 0xde, 0x57, 0x97, 0x03, 0x09, 0x39,
+	0x1c, 0xf3, 0xbe, 0xf3, 0x29, 0x30, 0xb3, 0x1e, 0x39, 0x5f, 0xa8, 0x6b, 0x4d, 0x8e, 0x7a, 0xf1,
+	0x45, 0x9c, 0xf0, 0x91, 0xba, 0xf5, 0x68, 0x42, 0xce, 0x1d, 0x68, 0x1d, 0x78, 0x17, 0x2e, 0xff,
+	0x99, 0x7c, 0xb6, 0x60, 0x15, 0x66, 0xc7, 0xde, 0x05, 0x92, 0xa0, 0x76, 0x06, 0x53, 0xb6, 0xf3,
+	0xbf, 0xcb, 0x30, 0x23, 0x4a, 0x62, 0xad, 0x03, 0x1e, 0x27, 0x7e, 0x40, 0x9c, 0xa6, 0x6a, 0x35,
+	0xa0, 0x1c, 0x6f, 0x97, 0x0b, 0x78, 0x5b, 0x7a, 0x28, 0xd4, 0x25, 0x2b, 0xc9, 0xc0, 0x16, 0x86,
+	0x9c, 0x96, 0x06, 0x0a, 0x0b, 0x97, 0x61, 0x0a, 0x64, 0x4e, 0x16, 0x52, 0x8d, 0x4e, 0xf4, 0x4f,
+	0x89, 0x2d, 0xc9, 0xc6, 0x26, 0x54, 0xa8, 0x37, 0xce, 0x0a, 0x6e, 0xcf, 0xe9, 0x8d, 0x39, 0xfd,
+	0xb0, 0xfe, 0x1e, 0xfa, 0xa1, 0x70, 0x5b, 0xbc, 0x4b, 0x3f, 0x84, 0xf7, 0xd0, 0x0f, 0x1d, 0x06,
+	0x6d, 0xba, 0xc1, 0x8d, 0x16, 0x88, 0xa2, 0xdd, 0xbf, 0x5d, 0x82, 0xb6, 0xa4, 0x22, 0x9d, 0xa7,
+	0xce, 0xa8, 0xde, 0x75, 0xd5, 0xe7, 0x36, 0xcc, 0x91, 0xfd, 0xa3, 0x45, 0x80, 0x3c, 0xef, 0xb1,
+	0x40, 0x1c, 0x87, 0x0a, 0x33, 0x19, 0xf9, 0x43, 0xb9, 0x28, 0x26, 0xa4, 0xa4, 0x48, 0xe4, 0xc9,
+	0x80, 0xd7, 0x92, 0xab, 0xd3, 0xce, 0x1f, 0x95, 0x60, 0xd1, 0xe8, 0xb0, 0xa4, 0xc2, 0xc7, 0xd0,
+	0xd2, 0x0f, 0x25, 0x70, 0xbd, 0xb9, 0xad, 0xda, 0x6c, 0x93, 0x7e, 0x66, 0x15, 0xa6, 0xc5, 0xf4,
+	0x2e, 0xa8, 0x83, 0xf1, 0x64, 0x24, 0x77, 0x15, 0x13, 0x42, 0x42, 0x3a, 0xe7, 0xfc, 0x8d, 0x2e,
+	0x22, 0xf6, 0x35, 0x0b, 0x23, 0xbf, 0x31, 0xda, 0x6d, 0xba, 0x50, 0x55, 0xfa, 0x8d, 0x4d, 0xd0,
+	0xf9, 0x8b, 0x65, 0x58, 0x12, 0x86, 0xb8, 0x74, 0x80, 0xe8, 0xbb, 0xaa, 0x33, 0xc2, 0x27, 0x21,
+	0x38, 0x72, 0xf7, 0x8a, 0x2b, 0xd3, 0xec, 0x3b, 0xef, 0xe9, 0x3c, 0xd0, 0x51, 0xb8, 0x53, 0xd6,
+	0xa2, 0x52, 0xb4, 0x16, 0xef, 0x98, 0xe9, 0x22, 0x17, 0x7e, 0xad, 0xd8, 0x85, 0xff, 0x5e, 0x2e,
+	0xf3, 0xcd, 0x59, 0xa8, 0xc5, 0xfd, 0x70, 0xcc, 0x9d, 0x15, 0x58, 0xb6, 0xa7, 0x40, 0x0a, 0xaa,
+	0x5f, 0x94, 0xa0, 0xf3, 0x44, 0x9c, 0xc6, 0xf9, 0xc1, 0xc9, 0xae, 0x1f, 0x27, 0x61, 0xa4, 0x2f,
+	0xfe, 0xdf, 0x04, 0x88, 0x13, 0x2f, 0x92, 0x0a, 0xad, 0x50, 0x0d, 0x0c, 0x04, 0x47, 0xc2, 0x83,
+	0x81, 0xc8, 0x15, 0x2b, 0xa8, 0xd3, 0x39, 0xd5, 0x4b, 0x3a, 0x13, 0x2c, 0x05, 0xe6, 0x23, 0x11,
+	0xbb, 0x8e, 0x5d, 0xe6, 0x67, 0x24, 0xfd, 0x85, 0x85, 0x9e, 0x41, 0x9d, 0xdf, 0x2b, 0xc3, 0x42,
+	0xda, 0x49, 0x8a, 0xb1, 0xb0, 0x65, 0x88, 0xd4, 0x5a, 0x52, 0x19, 0x22, 0x1d, 0xff, 0x3d, 0x1f,
+	0xd5, 0x18, 0xc3, 0x9f, 0x60, 0xa0, 0xec, 0x36, 0x34, 0x55, 0x2a, 0x9c, 0x24, 0xc6, 0x0d, 0x5c,
+	0x13, 0x16, 0x11, 0xa9, 0xa8, 0x48, 0x49, 0xa5, 0x50, 0xa6, 0xe8, 0x36, 0xd0, 0x28, 0xa1, 0x2f,
+	0xc5, 0xcc, 0xab, 0x24, 0x6b, 0x0b, 0x4d, 0x44, 0x3c, 0x86, 0x42, 0x5a, 0x88, 0xb9, 0x43, 0xd7,
+	0xf5, 0xcb, 0x25, 0x9a, 0x33, 0x45, 0x8d, 0x69, 0x38, 0x71, 0xd5, 0x35, 0x21, 0x65, 0xd1, 0x85,
+	0x13, 0x69, 0x9d, 0x88, 0xb7, 0x4f, 0x2c, 0xcc, 0xf9, 0xeb, 0x25, 0xb8, 0x56, 0xb0, 0x8c, 0x92,
+	0x53, 0xb7, 0x61, 0xf1, 0x58, 0x67, 0xaa, 0xa9, 0x16, 0xec, 0xba, 0xa2, 0x42, 0x0e, 0xec, 0xe9,
+	0x75, 0xf3, 0x1f, 0x68, 0xe5, 0x54, 0x2c, 0x9e, 0x15, 0x39, 0x9e, 0xcf, 0x70, 0x0e, 0xa0, 0xbb,
+	0xf3, 0x16, 0x19, 0x7f, 0xcb, 0x7c, 0xbf, 0x4d, 0x51, 0xd6, 0xc3, 0x9c, 0x60, 0xbb, 0xdc, 0x8d,
+	0x74, 0x0c, 0x73, 0x56, 0x5d, 0xec, 0x5b, 0xef, 0x5b, 0x89, 0xc9, 0xa3, 0x6b, 0x72, 0xd5, 0xc5,
+	0x03, 0x74, 0x2a, 0x7e, 0xdd, 0x80, 0x9c, 0x33, 0x58, 0x78, 0x3e, 0x19, 0x26, 0x7e, 0xfa, 0x18,
+	0x1d, 0xfb, 0x8e, 0xfc, 0x88, 0xaa, 0x50, 0x53, 0x57, 0xd8, 0x94, 0x59, 0x0e, 0x67, 0x6c, 0x84,
+	0x35, 0xf5, 0xf2, 0x2d, 0xe6, 0x33, 0x9c, 0x6b, 0xb0, 0x9a, 0x36, 0x29, 0xe6, 0x4e, 0x6d, 0x0e,
+	0xbf, 0x5f, 0x12, 0x81, 0x58, 0xf6, 0xdb, 0x78, 0xec, 0x29, 0x2c, 0xc5, 0x7e, 0x70, 0x32, 0xe4,
+	0x66, 0x3d, 0xb1, 0x9c, 0x89, 0xab, 0x76, 0xf7, 0xe4, 0xfb, 0x79, 0x6e, 0xd1, 0x17, 0x48, 0x20,
+	0xc5, 0x1d, 0x4d, 0x09, 0x24, 0x33, 0x25, 0x45, 0x03, 0xf8, 0x2e, 0xcc, 0xdb, 0x8d, 0xb1, 0x47,
+	0x32, 0xf4, 0x3c, 0xed, 0x99, 0x79, 0xee, 0x63, 0x53, 0x86, 0x55, 0xd2, 0xf9, 0xb2, 0x04, 0x1d,
+	0x97, 0x23, 0x19, 0x73, 0xa3, 0x51, 0x49, 0x3d, 0x8f, 0x73, 0xd5, 0x4e, 0x1f, 0xb0, 0x0e, 0x69,
+	0x57, 0x63, 0x5d, 0x9f, 0xba, 0x28, 0xbb, 0x57, 0x0a, 0x46, 0xb5, 0x59, 0x87, 0x19, 0x39, 0xbe,
+	0x55, 0xb8, 0x2a, 0xbb, 0xa4, 0xba, 0x93, 0x1e, 0x18, 0x58, 0x8d, 0x5a, 0x07, 0x06, 0x5d, 0xe8,
+	0x88, 0xf7, 0x1d, 0xcc, 0x71, 0xc8, 0x0f, 0xb7, 0x81, 0x3d, 0xf7, 0xfa, 0x5e, 0x14, 0x86, 0xc1,
+	0x01, 0x8f, 0x64, 0x50, 0x0d, 0x29, 0x40, 0xe4, 0x4f, 0x57, 0xba, 0x9a, 0x48, 0xa9, 0x27, 0x09,
+	0xc2, 0x40, 0x3d, 0xfd, 0x20, 0x52, 0x8e, 0x0b, 0x4b, 0x9b, 0xde, 0x1b, 0xae, 0x6a, 0x4a, 0x67,
+	0xa9, 0x39, 0xd6, 0x95, 0xaa, 0xb9, 0x57, 0x37, 0x4a, 0xf2, 0xcd, 0xba, 0x66, 0x69, 0xe7, 0x21,
+	0x2c, 0xdb, 0x75, 0x4a, 0x51, 0xd2, 0x85, 0xfa, 0x48, 0x62, 0xb2, 0x77, 0x3a, 0x7d, 0xef, 0x0b,
+	0x68, 0x1a, 0x6f, 0x76, 0xb0, 0x55, 0x58, 0x7a, 0xfd, 0xec, 0xe5, 0xfe, 0xce, 0xe1, 0x61, 0xef,
+	0xe0, 0xd5, 0xe6, 0xf7, 0x76, 0x7e, 0xd8, 0xdb, 0xdd, 0x38, 0xdc, 0x6d, 0x5f, 0x61, 0x2b, 0xc0,
+	0xf6, 0x77, 0x0e, 0x5f, 0xee, 0x6c, 0x5b, 0x78, 0x89, 0xdd, 0x84, 0xee, 0xab, 0xfd, 0x57, 0x87,
+	0x3b, 0xdb, 0xbd, 0xa2, 0xef, 0xca, 0xec, 0x03, 0xb8, 0x26, 0xf3, 0x0b, 0x3e, 0xaf, 0xdc, 0x7b,
+	0x0c, 0xed, 0xac, 0xff, 0xc3, 0xf2, 0x18, 0xbd, 0xcb, 0xb5, 0xf4, 0xf0, 0xcb, 0x0a, 0xcc, 0x8b,
+	0xd0, 0x38, 0xf1, 0xba, 0x24, 0x8f, 0xd8, 0x73, 0x98, 0x95, 0xcf, 0x94, 0x32, 0x45, 0x5a, 0xf6,
+	0xc3, 0xa8, 0xdd, 0x95, 0x2c, 0x2c, 0x97, 0x75, 0xe9, 0x2f, 0xfd, 0xc7, 0xff, 0xfe, 0x37, 0xcb,
+	0x73, 0xac, 0x79, 0xff, 0xec, 0x93, 0xfb, 0x27, 0x3c, 0x88, 0xb1, 0x8e, 0xdf, 0x01, 0x48, 0x1f,
+	0xdf, 0x64, 0x1d, 0xed, 0x03, 0xc8, 0xbc, 0x4c, 0xda, 0xbd, 0x56, 0x90, 0x23, 0xeb, 0xbd, 0x46,
+	0xf5, 0x2e, 0x39, 0xf3, 0x58, 0xaf, 0x1f, 0xf8, 0x89, 0x78, 0x88, 0xf3, 0xb3, 0xd2, 0x3d, 0x36,
+	0x80, 0x96, 0xf9, 0x2c, 0x26, 0x53, 0xe7, 0x3f, 0x05, 0x0f, 0x7b, 0x76, 0xaf, 0x17, 0xe6, 0x29,
+	0x5a, 0xa6, 0x36, 0xae, 0x3a, 0x6d, 0x6c, 0x63, 0x42, 0x25, 0xd2, 0x56, 0x86, 0x82, 0xc3, 0xd3,
+	0xd7, 0x2f, 0xd9, 0x0d, 0x83, 0xe9, 0x72, 0x6f, 0x6f, 0x76, 0x3f, 0x98, 0x92, 0x2b, 0xdb, 0xfa,
+	0x80, 0xda, 0x5a, 0x75, 0x18, 0xb6, 0xd5, 0xa7, 0x32, 0xea, 0xed, 0xcd, 0xcf, 0x4a, 0xf7, 0x1e,
+	0xfe, 0xbb, 0x3b, 0xd0, 0xd0, 0x67, 0xc3, 0xec, 0xa7, 0x30, 0x67, 0xc5, 0x2e, 0x32, 0x35, 0x8c,
+	0xa2, 0x50, 0xc7, 0xee, 0x8d, 0xe2, 0x4c, 0xd9, 0xf0, 0x4d, 0x6a, 0xb8, 0xc3, 0x56, 0xb0, 0x61,
+	0x19, 0xfc, 0x77, 0x9f, 0xa2, 0x70, 0xc5, 0x25, 0xbe, 0x37, 0x86, 0x24, 0x13, 0x8d, 0xdd, 0xc8,
+	0x0a, 0x17, 0xab, 0xb5, 0x0f, 0xa6, 0xe4, 0xca, 0xe6, 0x6e, 0x50, 0x73, 0x2b, 0x6c, 0xd9, 0x6c,
+	0x4e, 0x9f, 0xd7, 0x72, 0xba, 0xb9, 0x6a, 0x3e, 0x0c, 0xc9, 0x3e, 0xd0, 0x84, 0x55, 0xf4, 0x60,
+	0xa4, 0x26, 0x91, 0xfc, 0xab, 0x91, 0x4e, 0x87, 0x9a, 0x62, 0x8c, 0x96, 0xcf, 0x7c, 0x17, 0x92,
+	0x1d, 0x41, 0xd3, 0x78, 0x3e, 0x8a, 0x5d, 0x9b, 0xfa, 0xd4, 0x55, 0xb7, 0x5b, 0x94, 0x55, 0x34,
+	0x14, 0xb3, 0xfe, 0xfb, 0xa8, 0xe8, 0xfc, 0x18, 0x1a, 0xfa, 0x41, 0x22, 0xb6, 0x6a, 0x3c, 0x10,
+	0x65, 0x3e, 0xa0, 0xd4, 0xed, 0xe4, 0x33, 0x8a, 0x88, 0xcf, 0xac, 0x1d, 0x89, 0xef, 0x35, 0x34,
+	0x8d, 0x47, 0x87, 0xf4, 0x00, 0xf2, 0x0f, 0x1b, 0xe9, 0x01, 0x14, 0xbc, 0x51, 0xe4, 0x2c, 0x52,
+	0x13, 0x4d, 0xd6, 0x20, 0xfa, 0x4e, 0xde, 0x86, 0x31, 0xdb, 0x83, 0xab, 0x52, 0x62, 0x1f, 0xf1,
+	0xaf, 0xb2, 0x0c, 0x05, 0x6f, 0x71, 0x3e, 0x28, 0xb1, 0xc7, 0x50, 0x57, 0x6f, 0x4b, 0xb1, 0x95,
+	0xe2, 0x37, 0xb2, 0xba, 0xab, 0x39, 0x5c, 0x8a, 0xd7, 0x1f, 0x02, 0xa4, 0x2f, 0x1c, 0x69, 0x21,
+	0x91, 0x7b, 0x31, 0x49, 0x53, 0x40, 0xfe, 0x39, 0x24, 0x67, 0x85, 0x06, 0xd8, 0x66, 0x24, 0x24,
+	0x02, 0x7e, 0xae, 0x2e, 0xa9, 0xff, 0x04, 0x9a, 0xc6, 0x23, 0x47, 0x7a, 0xfa, 0xf2, 0x0f, 0x24,
+	0xe9, 0xe9, 0x2b, 0x78, 0x13, 0xc9, 0xe9, 0x52, 0xed, 0xcb, 0xce, 0x02, 0xd6, 0x1e, 0xfb, 0x27,
+	0xc1, 0x48, 0x14, 0xc0, 0x05, 0x3a, 0x85, 0x39, 0xeb, 0x25, 0x23, 0xcd, 0xa1, 0x45, 0xef, 0x24,
+	0x69, 0x0e, 0x2d, 0x7c, 0xfc, 0x48, 0xd1, 0x99, 0xb3, 0x88, 0xed, 0x9c, 0x51, 0x11, 0xa3, 0xa5,
+	0x1f, 0x41, 0xd3, 0x78, 0x95, 0x48, 0x8f, 0x25, 0xff, 0x00, 0x92, 0x1e, 0x4b, 0xd1, 0x23, 0x46,
+	0xcb, 0xd4, 0xc6, 0xbc, 0x43, 0xa4, 0x40, 0xd7, 0xad, 0xb1, 0xee, 0x9f, 0xc2, 0xbc, 0xfd, 0x4e,
+	0x91, 0xe6, 0xfd, 0xc2, 0x17, 0x8f, 0x34, 0xef, 0x4f, 0x79, 0xdc, 0x48, 0x92, 0xf4, 0xbd, 0x25,
+	0xdd, 0xc8, 0xfd, 0xcf, 0x65, 0x74, 0xd9, 0x17, 0xec, 0xfb, 0x28, 0xe0, 0xe4, 0xfd, 0x77, 0xb6,
+	0x6a, 0x50, 0xad, 0x79, 0x4b, 0x5e, 0xf3, 0x4b, 0xee, 0xaa, 0xbc, 0x4d, 0xcc, 0xe2, 0xc2, 0x38,
+	0xed, 0x5a, 0x74, 0x0f, 0xde, 0xd8, 0xb5, 0xcc, 0xab, 0xf2, 0xc6, 0xae, 0x65, 0x5d, 0x97, 0xcf,
+	0xee, 0x5a, 0x89, 0x8f, 0x75, 0x04, 0xb0, 0x90, 0xb9, 0x5f, 0xa1, 0xb9, 0xa2, 0xf8, 0x0a, 0x5c,
+	0xf7, 0xe6, 0xbb, 0xaf, 0x65, 0xd8, 0x12, 0x44, 0x09, 0xc1, 0xfb, 0xea, 0xc2, 0xe1, 0xef, 0x42,
+	0xcb, 0x7c, 0x3b, 0x85, 0x99, 0xac, 0x9c, 0x6d, 0xe9, 0x7a, 0x61, 0x9e, 0xbd, 0xb8, 0xac, 0x65,
+	0x36, 0xc3, 0x7e, 0x00, 0x2b, 0x9a, 0xd5, 0xcd, 0x90, 0xfd, 0x98, 0xdd, 0x2a, 0x08, 0xe4, 0x37,
+	0xf5, 0xb8, 0xee, 0xb5, 0xa9, 0x91, 0xfe, 0x0f, 0x4a, 0x48, 0x34, 0xf6, 0x83, 0x14, 0xe9, 0x86,
+	0x51, 0xf4, 0x0e, 0x47, 0xba, 0x61, 0x14, 0xbe, 0x62, 0xa1, 0x88, 0x86, 0x2d, 0x59, 0x73, 0x24,
+	0x0e, 0xe2, 0xd9, 0x8f, 0x60, 0xc1, 0xb8, 0x14, 0x75, 0x78, 0x11, 0xf4, 0x35, 0x03, 0xe4, 0xef,
+	0xeb, 0x76, 0x8b, 0xac, 0x14, 0x67, 0x95, 0xea, 0x5f, 0x74, 0xac, 0xc9, 0x41, 0xe2, 0xdf, 0x82,
+	0xa6, 0x79, 0xe1, 0xea, 0x1d, 0xf5, 0xae, 0x1a, 0x59, 0xe6, 0x75, 0xd3, 0x07, 0x25, 0x76, 0x20,
+	0x02, 0xb2, 0xf4, 0xe3, 0x98, 0x61, 0x94, 0xdd, 0x3e, 0xed, 0x47, 0x33, 0xf5, 0x42, 0x16, 0x3d,
+	0x97, 0x7a, 0xb7, 0xf4, 0xa0, 0xc4, 0xfe, 0x4e, 0x09, 0x5a, 0xd6, 0x85, 0x28, 0x2b, 0xbc, 0x25,
+	0xd3, 0xb3, 0x8e, 0x99, 0x67, 0x76, 0xcd, 0x71, 0x69, 0xd8, 0x7b, 0xf7, 0xbe, 0x6b, 0x4d, 0xeb,
+	0xe7, 0x96, 0x43, 0x6d, 0x3d, 0xfb, 0x42, 0xe6, 0x17, 0xd9, 0x02, 0xe6, 0x2d, 0xe9, 0x2f, 0x1e,
+	0x94, 0xd8, 0x1f, 0x96, 0x60, 0xde, 0x76, 0x03, 0xeb, 0xe1, 0x16, 0x3a, 0x9c, 0xf5, 0xe2, 0x4f,
+	0xf1, 0x1d, 0xff, 0x88, 0x7a, 0xf9, 0xf2, 0x9e, 0x6b, 0xf5, 0x52, 0x3e, 0x7e, 0xf2, 0xab, 0xf5,
+	0x96, 0x7d, 0x26, 0x9e, 0x74, 0x56, 0x87, 0x35, 0x2c, 0xff, 0xb0, 0xb0, 0x26, 0x18, 0xf3, 0x29,
+	0x60, 0x5a, 0x84, 0x9f, 0x88, 0x97, 0x21, 0xd5, 0x79, 0x02, 0xd2, 0xdd, 0xfb, 0x7e, 0xef, 0xdc,
+	0xa6, 0x31, 0xdd, 0x74, 0xae, 0x59, 0x63, 0xca, 0xee, 0xf0, 0x1b, 0xa2, 0x77, 0xf2, 0x15, 0xdf,
+	0x74, 0x8b, 0xca, 0xbd, 0xec, 0x3b, 0xbd, 0x93, 0x23, 0xd1, 0x49, 0x59, 0xdc, 0x62, 0x8e, 0xf7,
+	0xac, 0xc6, 0xb9, 0x47, 0x7d, 0xbd, 0xed, 0xdc, 0x9a, 0xda, 0xd7, 0xfb, 0xe4, 0xcc, 0xc5, 0x1e,
+	0x1f, 0x00, 0xa4, 0x07, 0xab, 0x2c, 0x73, 0xb0, 0xa7, 0x45, 0x46, 0xfe, 0xec, 0xd5, 0xe6, 0x40,
+	0x75, 0xfe, 0x87, 0x35, 0xfe, 0x58, 0x08, 0xc0, 0x67, 0xea, 0x48, 0xd0, 0x54, 0x73, 0xec, 0x13,
+	0x50, 0x4b, 0xcd, 0xc9, 0xd6, 0x6f, 0x89, 0x3f, 0x7d, 0xbe, 0xf8, 0x0a, 0xe6, 0xf6, 0xc2, 0xf0,
+	0xcd, 0x64, 0xac, 0x23, 0x4f, 0xec, 0x73, 0x96, 0x5d, 0x2f, 0x3e, 0xed, 0x66, 0x46, 0xe1, 0xac,
+	0x51, 0x55, 0x5d, 0xd6, 0x31, 0xaa, 0xba, 0xff, 0x79, 0x7a, 0x70, 0xfb, 0x05, 0xf3, 0x60, 0x51,
+	0x4b, 0x55, 0xdd, 0xf1, 0xae, 0x5d, 0x8d, 0x25, 0x4b, 0xb3, 0x4d, 0x58, 0xfa, 0xb8, 0xea, 0xed,
+	0xfd, 0x58, 0xd5, 0x49, 0x32, 0xa5, 0xb5, 0xcd, 0xfb, 0x74, 0xdd, 0x83, 0x0e, 0x2b, 0x96, 0xd2,
+	0x8e, 0xeb, 0x53, 0x8e, 0xee, 0x9c, 0x05, 0xda, 0x3b, 0xcd, 0xd8, 0xbb, 0x88, 0xf8, 0xcf, 0xee,
+	0x7f, 0x2e, 0x8f, 0x41, 0xbe, 0x50, 0x3b, 0x8d, 0x3a, 0x27, 0xb2, 0x76, 0x9a, 0xcc, 0xc1, 0x92,
+	0xb5, 0xd3, 0xe4, 0x0e, 0x96, 0xac, 0xa9, 0x56, 0xe7, 0x54, 0x6c, 0x08, 0x8b, 0xb9, 0xb3, 0x28,
+	0xbd, 0xc9, 0x4c, 0x3b, 0xc1, 0xea, 0xae, 0x4d, 0x2f, 0x60, 0xb7, 0x76, 0xcf, 0x6e, 0xed, 0x10,
+	0xe6, 0xb6, 0xb9, 0x98, 0x2c, 0x11, 0x6a, 0x9b, 0xb9, 0x55, 0x67, 0x06, 0xf2, 0x66, 0xb7, 0x04,
+	0xca, 0xb3, 0x55, 0x09, 0x8a, 0x71, 0x65, 0x3f, 0x86, 0xe6, 0x53, 0x9e, 0xa8, 0xd8, 0x5a, 0xad,
+	0xcc, 0x66, 0x82, 0x6d, 0xbb, 0x05, 0xa1, 0xb9, 0x36, 0xcd, 0x50, 0x6d, 0xf7, 0xf9, 0xe0, 0x84,
+	0x0b, 0xe1, 0xd4, 0xf3, 0x07, 0x5f, 0xb0, 0x3f, 0x47, 0x95, 0xeb, 0xcb, 0x05, 0x2b, 0x46, 0xa0,
+	0xa4, 0x59, 0xf9, 0x42, 0x06, 0x2f, 0xaa, 0x39, 0x08, 0x07, 0xdc, 0x50, 0xaa, 0x02, 0x68, 0x1a,
+	0x17, 0x71, 0x34, 0x03, 0xe5, 0xef, 0x75, 0x69, 0x06, 0x2a, 0xb8, 0xb7, 0xe3, 0xdc, 0xa5, 0x76,
+	0x1c, 0xb6, 0x96, 0xb6, 0x23, 0xee, 0xea, 0xa4, 0x2d, 0xdd, 0xff, 0xdc, 0x1b, 0x25, 0x5f, 0xb0,
+	0xd7, 0xf4, 0x18, 0x91, 0x19, 0x3b, 0x9c, 0x6a, 0xe7, 0xd9, 0x30, 0x63, 0x3d, 0x59, 0x46, 0x96,
+	0xad, 0xb1, 0x8b, 0xa6, 0x48, 0xf7, 0xfa, 0x0e, 0xc0, 0x61, 0x12, 0x8e, 0xb7, 0x3d, 0x3e, 0x0a,
+	0x83, 0x54, 0xd6, 0xa6, 0x91, 0xab, 0xa9, 0xfc, 0x32, 0xc2, 0x57, 0xd9, 0x6b, 0xc3, 0x9c, 0xb1,
+	0xc2, 0xaf, 0x15, 0x71, 0x4d, 0x0d, 0x6e, 0xd5, 0x13, 0x52, 0x10, 0xe0, 0xfa, 0xa0, 0xc4, 0x36,
+	0x00, 0xd2, 0xc3, 0x48, 0x6d, 0x9c, 0xe4, 0xce, 0x39, 0xb5, 0xd8, 0x2b, 0x38, 0xb9, 0x3c, 0x80,
+	0x46, 0x7a, 0xba, 0xb5, 0x9a, 0x5e, 0x77, 0xb3, 0xce, 0xc2, 0xf4, 0x0e, 0x9e, 0x3b, 0x73, 0x72,
+	0xda, 0x34, 0x55, 0xc0, 0xea, 0x38, 0x55, 0x74, 0x90, 0xe4, 0xc3, 0x92, 0xe8, 0xa0, 0x56, 0x70,
+	0x28, 0xe2, 0x52, 0x8d, 0xa4, 0xe0, 0xdc, 0x47, 0x73, 0x73, 0xe1, 0x81, 0x88, 0xe5, 0x63, 0x41,
+	0x6a, 0x15, 0xd1, 0x9e, 0x28, 0x9a, 0x47, 0xb0, 0x98, 0xf3, 0xb1, 0x6b, 0x96, 0x9e, 0x76, 0x88,
+	0xa2, 0x59, 0x7a, 0xaa, 0x7b, 0xde, 0xb9, 0x4a, 0x4d, 0x2e, 0x38, 0x40, 0x36, 0xd5, 0xb9, 0x9f,
+	0xf4, 0x4f, 0xb1, 0xb9, 0xdf, 0x2f, 0xc1, 0x52, 0x81, 0x0b, 0x9d, 0x7d, 0xa8, 0xcc, 0xf3, 0xa9,
+	0xee, 0xf5, 0x6e, 0xa1, 0x87, 0xd5, 0x39, 0xa4, 0x76, 0x9e, 0xb3, 0xef, 0x59, 0x1b, 0x9b, 0x70,
+	0x6e, 0x4a, 0xce, 0x7c, 0xa7, 0x52, 0x51, 0xa8, 0x51, 0xfc, 0x0c, 0x56, 0x45, 0x47, 0x36, 0x86,
+	0xc3, 0x8c, 0xf7, 0xf7, 0x66, 0xee, 0xbf, 0xba, 0x58, 0x5e, 0xed, 0xee, 0xf4, 0xff, 0xfa, 0x32,
+	0x45, 0x01, 0x16, 0x5d, 0x65, 0x13, 0x68, 0x67, 0x3d, 0xaa, 0x6c, 0x7a, 0x5d, 0xdd, 0x5b, 0x96,
+	0xa1, 0x59, 0xe0, 0x85, 0xfd, 0x0d, 0x6a, 0xec, 0x96, 0xd3, 0x2d, 0x9a, 0x17, 0x61, 0x7b, 0xe2,
+	0x7a, 0xfc, 0x05, 0xed, 0xfe, 0xcd, 0x8c, 0x53, 0x35, 0x30, 0xcd, 0x5f, 0xad, 0x4d, 0xdd, 0x62,
+	0xef, 0xf1, 0x47, 0xd4, 0xfc, 0x9a, 0x73, 0xbd, 0xa8, 0xf9, 0x48, 0x7c, 0x22, 0x8c, 0xde, 0xd5,
+	0x2c, 0x5f, 0xab, 0x1e, 0xac, 0x15, 0xad, 0xf7, 0x54, 0xeb, 0x25, 0x33, 0xd7, 0x57, 0x48, 0xb7,
+	0x6b, 0x99, 0xee, 0x5e, 0xcd, 0x3e, 0x05, 0x7e, 0x65, 0xcd, 0x3e, 0x45, 0xfe, 0x61, 0x5b, 0xaf,
+	0x51, 0x9e, 0xe1, 0xcf, 0x4a, 0xf7, 0x36, 0xef, 0xfc, 0xe8, 0x37, 0x4e, 0xfc, 0xe4, 0x74, 0x72,
+	0xb4, 0xde, 0x0f, 0x47, 0xf7, 0x87, 0xca, 0xad, 0x27, 0x6f, 0x21, 0xdc, 0x1f, 0x06, 0x83, 0xfb,
+	0x54, 0xed, 0xd1, 0x0c, 0xfd, 0x1b, 0xaa, 0x6f, 0xfd, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8b,
+	0x4e, 0x52, 0x4c, 0xb8, 0x6a, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
diff --git a/lnrpc/rpc.proto b/lnrpc/rpc.proto
index a2b065d8a..c1347e692 100644
--- a/lnrpc/rpc.proto
+++ b/lnrpc/rpc.proto
@@ -1258,6 +1258,19 @@ message Channel {
     directly to that key. 
     */
     bool static_remote_key = 22 [json_name = "static_remote_key"];
+
+    /**
+    The number of seconds that the channel has been monitored by the channel
+    scoring system. Scores are currently not persisted, so this value may be
+    less than the lifetime of the channel [EXPERIMENTAL].
+    */
+    int64 lifetime = 23 [json_name = "lifetime"];
+
+    /**
+    The number of seconds that the remote peer has been observed as being online
+    by the channel scoring system over the lifetime of the channel [EXPERIMENTAL].
+    */
+    int64 uptime = 24 [json_name = "uptime"];
 }
 
 
diff --git a/lnrpc/rpc.swagger.json b/lnrpc/rpc.swagger.json
index 9263dd1c9..b7d49f3cc 100644
--- a/lnrpc/rpc.swagger.json
+++ b/lnrpc/rpc.swagger.json
@@ -1715,6 +1715,16 @@
           "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."
+        },
+        "lifetime": {
+          "type": "string",
+          "format": "int64",
+          "description": "*\nThe number of seconds that the channel has been monitored by the channel\nscoring system. Scores are currently not persisted, so this value may be\nless than the lifetime of the channel [EXPERIMENTAL]."
+        },
+        "uptime": {
+          "type": "string",
+          "format": "int64",
+          "description": "*\nThe number of seconds that the remote peer has been observed as being online\nby the channel scoring system over the lifetime of the channel [EXPERIMENTAL]."
         }
       }
     },
diff --git a/log.go b/log.go
index dc4d0247b..a6d81f262 100644
--- a/log.go
+++ b/log.go
@@ -11,6 +11,7 @@ import (
 	"github.com/lightningnetwork/lnd/build"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/chanbackup"
+	"github.com/lightningnetwork/lnd/chanfitness"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/channelnotifier"
 	"github.com/lightningnetwork/lnd/contractcourt"
@@ -98,6 +99,7 @@ func init() {
 
 	addSubLogger(routerrpc.Subsystem, routerrpc.UseLogger)
 	addSubLogger(wtclientrpc.Subsystem, wtclientrpc.UseLogger)
+	addSubLogger(chanfitness.Subsystem, chanfitness.UseLogger)
 }
 
 // addSubLogger is a helper method to conveniently create and register the
diff --git a/routing/heap.go b/routing/heap.go
index 62b3e3dd0..1cbbc5e53 100644
--- a/routing/heap.go
+++ b/routing/heap.go
@@ -3,7 +3,6 @@ package routing
 import (
 	"container/heap"
 
-	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
 )
@@ -36,15 +35,12 @@ type nodeWithDist struct {
 	// Includes the routing fees and a virtual cost factor to account for
 	// time locks.
 	weight int64
-
-	// nextHop is the edge this route comes from.
-	nextHop *channeldb.ChannelEdgePolicy
 }
 
 // distanceHeap is a min-distance heap that's used within our path finding
 // algorithm to keep track of the "closest" node to our source node.
 type distanceHeap struct {
-	nodes []*nodeWithDist
+	nodes []nodeWithDist
 
 	// pubkeyIndices maps public keys of nodes to their respective index in
 	// the heap. This is used as a way to avoid db lookups by using heap.Fix
@@ -54,10 +50,9 @@ type distanceHeap struct {
 
 // newDistanceHeap initializes a new distance heap. This is required because
 // we must initialize the pubkeyIndices map for path-finding optimizations.
-func newDistanceHeap(numNodes int) distanceHeap {
+func newDistanceHeap() distanceHeap {
 	distHeap := distanceHeap{
-		pubkeyIndices: make(map[route.Vertex]int, numNodes),
-		nodes:         make([]*nodeWithDist, 0, numNodes),
+		pubkeyIndices: make(map[route.Vertex]int),
 	}
 
 	return distHeap
@@ -89,7 +84,7 @@ func (d *distanceHeap) Swap(i, j int) {
 //
 // NOTE: This is part of the heap.Interface implementation.
 func (d *distanceHeap) Push(x interface{}) {
-	n := x.(*nodeWithDist)
+	n := x.(nodeWithDist)
 	d.nodes = append(d.nodes, n)
 	d.pubkeyIndices[n.node] = len(d.nodes) - 1
 }
@@ -101,7 +96,6 @@ func (d *distanceHeap) Push(x interface{}) {
 func (d *distanceHeap) Pop() interface{} {
 	n := len(d.nodes)
 	x := d.nodes[n-1]
-	d.nodes[n-1] = nil
 	d.nodes = d.nodes[0 : n-1]
 	delete(d.pubkeyIndices, x.node)
 	return x
@@ -112,7 +106,7 @@ func (d *distanceHeap) Pop() interface{} {
 // modify its position and reorder the heap. If the vertex does not already
 // exist in the heap, then it is pushed onto the heap. Otherwise, we will end
 // up performing more db lookups on the same node in the pathfinding algorithm.
-func (d *distanceHeap) PushOrFix(dist *nodeWithDist) {
+func (d *distanceHeap) PushOrFix(dist nodeWithDist) {
 	index, ok := d.pubkeyIndices[dist.node]
 	if !ok {
 		heap.Push(d, dist)
diff --git a/routing/pathfind.go b/routing/pathfind.go
index 743adad1d..33c452f0b 100644
--- a/routing/pathfind.go
+++ b/routing/pathfind.go
@@ -6,7 +6,6 @@ import (
 	"math"
 	"time"
 
-	"github.com/btcsuite/btcd/btcec"
 	"github.com/coreos/bbolt"
 
 	"github.com/lightningnetwork/lnd/channeldb"
@@ -37,11 +36,6 @@ const (
 	// some effect with smaller time lock values. The value may need
 	// tweaking and/or be made configurable in the future.
 	RiskFactorBillionths = 15
-
-	// estimatedNodeCount is used to preallocate the path finding structures
-	// to avoid resizing and copies. It should be number on the same order as
-	// the number of active nodes in the network.
-	estimatedNodeCount = 10000
 )
 
 // pathFinder defines the interface of a path finding algorithm.
@@ -325,40 +319,61 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		defer tx.Rollback()
 	}
 
-	if r.DestPayloadTLV {
-		// Check if the target has TLV enabled
-
-		targetKey, err := btcec.ParsePubKey(target[:], btcec.S256())
-		if err != nil {
-			return nil, err
+	// First we'll initialize an empty heap which'll help us to quickly
+	// locate the next edge we should visit next during our graph
+	// traversal.
+	nodeHeap := newDistanceHeap()
+
+	// For each node in the graph, we create an entry in the distance map
+	// for the node set with a distance of "infinity". graph.ForEachNode
+	// also returns the source node, so there is no need to add the source
+	// node explicitly.
+	distance := make(map[route.Vertex]nodeWithDist)
+	if err := g.graph.ForEachNode(tx, func(_ *bbolt.Tx,
+		node *channeldb.LightningNode) error {
+		// TODO(roasbeef): with larger graph can just use disk seeks
+		// with a visited map
+		vertex := route.Vertex(node.PubKeyBytes)
+		distance[vertex] = nodeWithDist{
+			dist: infinity,
+			node: route.Vertex(node.PubKeyBytes),
 		}
 
-		targetNode, err := g.graph.FetchLightningNode(targetKey)
-		if err != nil {
-			return nil, err
+		// If we don't have any features for this node, then we can
+		// stop here.
+		if node.Features == nil || !r.DestPayloadTLV {
+			return nil
 		}
 
-		if targetNode.Features != nil {
-			supportsTLV := targetNode.Features.HasFeature(
-				lnwire.TLVOnionPayloadOptional,
-			)
-			if !supportsTLV {
-				return nil, fmt.Errorf("destination hop doesn't " +
-					"understand new TLV paylods")
-			}
+		// We only need to perform this check for the final node, so we
+		// can exit here if this isn't them.
+		if vertex != target {
+			return nil
 		}
-	}
 
-	// First we'll initialize an empty heap which'll help us to quickly
-	// locate the next edge we should visit next during our graph
-	// traversal.
-	nodeHeap := newDistanceHeap(estimatedNodeCount)
+		// If we have any records for the final hop, then we'll check
+		// not to ensure that they are actually able to interpret them.
+		supportsTLV := node.Features.HasFeature(
+			lnwire.TLVOnionPayloadOptional,
+		)
+		if !supportsTLV {
+			return fmt.Errorf("destination hop doesn't " +
+				"understand new TLV paylods")
+		}
 
-	// Holds the current best distance for a given node.
-	distance := make(map[route.Vertex]*nodeWithDist, estimatedNodeCount)
+		return nil
+	}); err != nil {
+		return nil, err
+	}
 
 	additionalEdgesWithSrc := make(map[route.Vertex][]*edgePolicyWithSource)
 	for vertex, outgoingEdgePolicies := range g.additionalEdges {
+		// We'll also include all the nodes found within the additional
+		// edges that are not known to us yet in the distance map.
+		distance[vertex] = nodeWithDist{
+			dist: infinity,
+			node: vertex,
+		}
 
 		// Build reverse lookup to find incoming edges. Needed because
 		// search is taken place from target to source.
@@ -376,12 +391,12 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 	}
 
 	// We can't always assume that the end destination is publicly
-	// advertised to the network so we'll manually include the target node.
-	// The target node charges no fee. Distance is set to 0, because this
-	// is the starting point of the graph traversal. We are searching
-	// backwards to get the fees first time right and correctly match
-	// channel bandwidth.
-	distance[target] = &nodeWithDist{
+	// advertised to the network and included in the graph.ForEachNode call
+	// above, so we'll manually include the target node. The target node
+	// charges no fee. Distance is set to 0, because this is the starting
+	// point of the graph traversal. We are searching backwards to get the
+	// fees first time right and correctly match channel bandwidth.
+	distance[target] = nodeWithDist{
 		dist:            0,
 		weight:          0,
 		node:            target,
@@ -390,10 +405,15 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		probability:     1,
 	}
 
+	// We'll use this map as a series of "next" hop pointers. So to get
+	// from `Vertex` to the target node, we'll take the edge that it's
+	// mapped to within `next`.
+	next := make(map[route.Vertex]*channeldb.ChannelEdgePolicy)
+
 	// processEdge is a helper closure that will be used to make sure edges
 	// satisfy our specific requirements.
 	processEdge := func(fromVertex route.Vertex, bandwidth lnwire.MilliSatoshi,
-		edge *channeldb.ChannelEdgePolicy, toNodeDist *nodeWithDist) {
+		edge *channeldb.ChannelEdgePolicy, toNode route.Vertex) {
 
 		edgesExpanded++
 
@@ -420,18 +440,16 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 
 		// Calculate amount that the candidate node would have to sent
 		// out.
+		toNodeDist := distance[toNode]
 		amountToSend := toNodeDist.amountToReceive
 
 		// Request the success probability for this edge.
 		edgeProbability := r.ProbabilitySource(
-			fromVertex, toNodeDist.node, amountToSend,
+			fromVertex, toNode, amountToSend,
 		)
 
-		log.Trace(newLogClosure(func() string {
-			return fmt.Sprintf("path finding probability: fromnode=%v,"+
-				" tonode=%v, probability=%v", fromVertex, toNodeDist.node,
-				edgeProbability)
-		}))
+		log.Tracef("path finding probability: fromnode=%v, tonode=%v, "+
+			"probability=%v", fromVertex, toNode, edgeProbability)
 
 		// If the probability is zero, there is no point in trying.
 		if edgeProbability == 0 {
@@ -530,8 +548,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		// route, return. It is important to also return if the distance
 		// is equal, because otherwise the algorithm could run into an
 		// endless loop.
-		current, ok := distance[fromVertex]
-		if ok && tempDist >= current.dist {
+		if tempDist >= distance[fromVertex].dist {
 			return
 		}
 
@@ -546,21 +563,21 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		// better than the current best known distance to this node.
 		// The new better distance is recorded, and also our "next hop"
 		// map is populated with this edge.
-		withDist := &nodeWithDist{
+		distance[fromVertex] = nodeWithDist{
 			dist:            tempDist,
 			weight:          tempWeight,
 			node:            fromVertex,
 			amountToReceive: amountToReceive,
 			incomingCltv:    incomingCltv,
 			probability:     probability,
-			nextHop:         edge,
 		}
-		distance[fromVertex] = withDist
 
-		// Either push withDist onto the heap if the node
+		next[fromVertex] = edge
+
+		// Either push distance[fromVertex] onto the heap if the node
 		// represented by fromVertex is not already on the heap OR adjust
 		// its position within the heap via heap.Fix.
-		nodeHeap.PushOrFix(withDist)
+		nodeHeap.PushOrFix(distance[fromVertex])
 	}
 
 	// TODO(roasbeef): also add path caching
@@ -575,7 +592,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 
 		// Fetch the node within the smallest distance from our source
 		// from the heap.
-		partialPath := heap.Pop(&nodeHeap).(*nodeWithDist)
+		partialPath := heap.Pop(&nodeHeap).(nodeWithDist)
 		pivot := partialPath.node
 
 		// If we've reached our source (or we don't have any incoming
@@ -625,7 +642,7 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 
 			// Check if this candidate node is better than what we
 			// already have.
-			processEdge(chanSource, edgeBandwidth, inEdge, partialPath)
+			processEdge(route.Vertex(chanSource), edgeBandwidth, inEdge, pivot)
 			return nil
 		}
 
@@ -645,28 +662,30 @@ func findPath(g *graphParams, r *RestrictParams, cfg *PathFindingConfig,
 		bandWidth := partialPath.amountToReceive
 		for _, reverseEdge := range additionalEdgesWithSrc[pivot] {
 			processEdge(reverseEdge.sourceNode, bandWidth,
-				reverseEdge.edge, partialPath)
+				reverseEdge.edge, pivot)
 		}
 	}
 
-	// Use the distance map to unravel the forward path from source to
+	// If the source node isn't found in the next hop map, then a path
+	// doesn't exist, so we terminate in an error.
+	if _, ok := next[source]; !ok {
+		return nil, newErrf(ErrNoPathFound, "unable to find a path to "+
+			"destination")
+	}
+
+	// Use the nextHop map to unravel the forward path from source to
 	// target.
-	var pathEdges []*channeldb.ChannelEdgePolicy
+	pathEdges := make([]*channeldb.ChannelEdgePolicy, 0, len(next))
 	currentNode := source
 	for currentNode != target { // TODO(roasbeef): assumes no cycles
 		// Determine the next hop forward using the next map.
-		currentNodeWithDist, ok := distance[currentNode]
-		if !ok {
-			// If the node doesnt have a next hop it means we didn't find a path.
-			return nil, newErrf(ErrNoPathFound, "unable to find a "+
-				"path to destination")
-		}
+		nextNode := next[currentNode]
 
 		// Add the next hop to the list of path edges.
-		pathEdges = append(pathEdges, currentNodeWithDist.nextHop)
+		pathEdges = append(pathEdges, nextNode)
 
 		// Advance current node.
-		currentNode = currentNodeWithDist.nextHop.Node.PubKeyBytes
+		currentNode = route.Vertex(nextNode.Node.PubKeyBytes)
 	}
 
 	// The route is invalid if it spans more than 20 hops. The current
diff --git a/rpcserver.go b/rpcserver.go
index d6685e90b..667794aca 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -17,12 +17,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/lightningnetwork/lnd/chanacceptor"
-	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
-	"github.com/lightningnetwork/lnd/routing/route"
-	"github.com/lightningnetwork/lnd/tlv"
-	"github.com/lightningnetwork/lnd/watchtower"
-
 	"github.com/btcsuite/btcd/blockchain"
 	"github.com/btcsuite/btcd/btcec"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -36,6 +30,7 @@ import (
 	proxy "github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"github.com/lightningnetwork/lnd/autopilot"
 	"github.com/lightningnetwork/lnd/build"
+	"github.com/lightningnetwork/lnd/chanacceptor"
 	"github.com/lightningnetwork/lnd/chanbackup"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/channelnotifier"
@@ -46,14 +41,18 @@ import (
 	"github.com/lightningnetwork/lnd/lncfg"
 	"github.com/lightningnetwork/lnd/lnrpc"
 	"github.com/lightningnetwork/lnd/lnrpc/invoicesrpc"
+	"github.com/lightningnetwork/lnd/lnrpc/routerrpc"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwallet"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/macaroons"
 	"github.com/lightningnetwork/lnd/monitoring"
 	"github.com/lightningnetwork/lnd/routing"
+	"github.com/lightningnetwork/lnd/routing/route"
 	"github.com/lightningnetwork/lnd/signal"
 	"github.com/lightningnetwork/lnd/sweep"
+	"github.com/lightningnetwork/lnd/tlv"
+	"github.com/lightningnetwork/lnd/watchtower"
 	"github.com/lightningnetwork/lnd/zpay32"
 	"github.com/tv42/zbase32"
 	"google.golang.org/grpc"
@@ -2702,12 +2701,43 @@ func createRPCOpenChannel(r *rpcServer, graph *channeldb.ChannelGraph,
 	}
 	externalCommitFee := dbChannel.Capacity - sumOutputs
 
+	chanID := dbChannel.ShortChannelID.ToUint64()
+
+	var (
+		uptime   time.Duration
+		lifespan time.Duration
+	)
+
+	// Get the lifespan observed by the channel event store.
+	startTime, endTime, err := r.server.chanEventStore.GetLifespan(chanID)
+	if err != nil {
+		// If the channel cannot be found, log an error and do not perform
+		// further calculations for uptime and lifespan.
+		rpcsLog.Warnf("GetLifespan %v error: %v", chanID, err)
+	} else {
+		// If endTime is zero, the channel is still open, progress endTime to
+		// the present so we can calculate lifespan.
+		if endTime.IsZero() {
+			endTime = time.Now()
+		}
+		lifespan = endTime.Sub(startTime)
+
+		uptime, err = r.server.chanEventStore.GetUptime(
+			chanID,
+			startTime,
+			endTime,
+		)
+		if err != nil {
+			rpcsLog.Warnf("GetUptime %v error: %v", chanID, err)
+		}
+	}
+
 	channel := &lnrpc.Channel{
 		Active:                isActive,
 		Private:               !isPublic,
 		RemotePubkey:          nodeID,
 		ChannelPoint:          chanPoint.String(),
-		ChanId:                dbChannel.ShortChannelID.ToUint64(),
+		ChanId:                chanID,
 		Capacity:              int64(dbChannel.Capacity),
 		LocalBalance:          int64(localBalance.ToSatoshis()),
 		RemoteBalance:         int64(remoteBalance.ToSatoshis()),
@@ -2724,6 +2754,8 @@ func createRPCOpenChannel(r *rpcServer, graph *channeldb.ChannelGraph,
 		LocalChanReserveSat:   int64(dbChannel.LocalChanCfg.ChanReserve),
 		RemoteChanReserveSat:  int64(dbChannel.RemoteChanCfg.ChanReserve),
 		StaticRemoteKey:       dbChannel.ChanType.IsTweakless(),
+		Lifetime:              int64(lifespan.Seconds()),
+		Uptime:                int64(uptime.Seconds()),
 	}
 
 	for i, htlc := range localCommit.Htlcs {
diff --git a/server.go b/server.go
index b52a8f22e..15130aff1 100644
--- a/server.go
+++ b/server.go
@@ -30,6 +30,7 @@ import (
 	"github.com/lightningnetwork/lnd/brontide"
 	"github.com/lightningnetwork/lnd/chanacceptor"
 	"github.com/lightningnetwork/lnd/chanbackup"
+	"github.com/lightningnetwork/lnd/chanfitness"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/channelnotifier"
 	"github.com/lightningnetwork/lnd/contractcourt"
@@ -243,6 +244,10 @@ type server struct {
 	// channelNotifier to be notified of newly opened and closed channels.
 	chanSubSwapper *chanbackup.SubSwapper
 
+	// chanEventStore tracks the behaviour of channels and their remote peers to
+	// provide insights into their health and performance.
+	chanEventStore *chanfitness.ChannelEventStore
+
 	quit chan struct{}
 
 	wg sync.WaitGroup
@@ -1113,6 +1118,13 @@ func newServer(listenAddrs []net.Addr, chanDB *channeldb.DB,
 	// to peer online and offline events.
 	s.peerNotifier = peernotifier.New()
 
+	// Create a channel event store which monitors all open channels.
+	s.chanEventStore = chanfitness.NewChannelEventStore(&chanfitness.Config{
+		SubscribeChannelEvents: s.channelNotifier.SubscribeChannelEvents,
+		SubscribePeerEvents:    s.peerNotifier.SubscribePeerEvents,
+		GetOpenChannels:        s.chanDB.FetchAllOpenChannels,
+	})
+
 	if cfg.WtClient.Active {
 		policy := wtpolicy.DefaultPolicy()
 
@@ -1270,6 +1282,11 @@ func (s *server) Start() error {
 			return
 		}
 
+		if err := s.chanEventStore.Start(); err != nil {
+			startErr = err
+			return
+		}
+
 		// Before we start the connMgr, we'll check to see if we have
 		// any backups to recover. We do this now as we want to ensure
 		// that have all the information we need to handle channel
@@ -1385,6 +1402,7 @@ func (s *server) Stop() error {
 		s.invoices.Stop()
 		s.fundingMgr.Stop()
 		s.chanSubSwapper.Stop()
+		s.chanEventStore.Stop()
 
 		// Disconnect from each active peers to ensure that
 		// peerTerminationWatchers signal completion to each peer.


Test patch:
diff --git a/chanfitness/chanevent_test.go b/chanfitness/chanevent_test.go
new file mode 100644
index 000000000..72733dbef
--- /dev/null
+++ b/chanfitness/chanevent_test.go
@@ -0,0 +1,395 @@
+package chanfitness
+
+import (
+	"testing"
+	"time"
+)
+
+// TestAdd tests adding events to an event log. It tests the case where the
+// channel is open, and should have an event added, and the case where it is
+// closed and the event should not be added.
+func TestAdd(t *testing.T) {
+	tests := []struct {
+		name     string
+		eventLog *chanEventLog
+		event    eventType
+		expected []eventType
+	}{
+		{
+			name: "Channel open",
+			eventLog: &chanEventLog{
+				now: time.Now,
+			},
+			event:    peerOnlineEvent,
+			expected: []eventType{peerOnlineEvent},
+		},
+		{
+			name: "Channel closed, event not added",
+			eventLog: &chanEventLog{
+				now: time.Now,
+			},
+			event:    peerOnlineEvent,
+			expected: []eventType{},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			test.eventLog.add(test.event)
+
+			for i, e := range test.expected {
+				if test.eventLog.events[i].eventType != e {
+					t.Fatalf("Expected event type: %v, got: %v",
+						e, test.eventLog.events[i].eventType)
+				}
+			}
+		})
+	}
+}
+
+// TestGetOnlinePeriod tests the getOnlinePeriod function. It tests the case
+// where no events present, and the case where an additional online period
+// must be added because the event log ends on an online event.
+func TestGetOnlinePeriod(t *testing.T) {
+	// Set time for consistent testing.
+	now := time.Now()
+
+	fourHoursAgo := now.Add(time.Hour * -4)
+	threeHoursAgo := now.Add(time.Hour * -3)
+	twoHoursAgo := now.Add(time.Hour * -2)
+	oneHourAgo := now.Add(time.Hour * -1)
+
+	tests := []struct {
+		name           string
+		events         []*channelEvent
+		expectedOnline []*onlinePeriod
+		openedAt       time.Time
+		closedAt       time.Time
+	}{
+		{
+			name: "No events",
+		},
+		{
+			name: "Start on online period",
+			events: []*channelEvent{
+				{
+					timestamp: threeHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+				{
+					timestamp: twoHoursAgo,
+					eventType: peerOfflineEvent,
+				},
+			},
+			expectedOnline: []*onlinePeriod{
+				{
+					start: threeHoursAgo,
+					end:   twoHoursAgo,
+				},
+			},
+		},
+		{
+			name: "Start on offline period",
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOfflineEvent,
+				},
+			},
+		},
+		{
+			name: "End on an online period, channel not closed",
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			expectedOnline: []*onlinePeriod{
+				{
+					start: fourHoursAgo,
+					end:   now,
+				},
+			},
+		},
+		{
+			name: "End on an online period, channel closed",
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			expectedOnline: []*onlinePeriod{
+				{
+					start: fourHoursAgo,
+					end:   oneHourAgo,
+				},
+			},
+			closedAt: oneHourAgo,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			score := &chanEventLog{
+				events: test.events,
+				now: func() time.Time {
+					return now
+				},
+				openedAt: test.openedAt,
+				closedAt: test.closedAt,
+			}
+
+			online := score.getOnlinePeriods()
+
+			if len(online) != len(test.expectedOnline) {
+				t.Fatalf("Expectd: %v online periods, got: %v",
+					len(test.expectedOnline), len(online))
+			}
+
+			for i, o := range test.expectedOnline {
+				if online[i].start != o.start {
+					t.Errorf("Expected start: %v, got %v", o.start,
+						online[i].start)
+				}
+
+				if online[i].end != o.end {
+					t.Errorf("Expected end: %v, got %v", o.end,
+						online[i].end)
+				}
+			}
+		})
+
+	}
+}
+
+// TestUptime tests channel uptime calculation based on its event log.
+func TestUptime(t *testing.T) {
+	// Set time for consistent testing.
+	now := time.Now()
+
+	fourHoursAgo := now.Add(time.Hour * -4)
+	threeHoursAgo := now.Add(time.Hour * -3)
+	twoHoursAgo := now.Add(time.Hour * -2)
+	oneHourAgo := now.Add(time.Hour * -1)
+
+	tests := []struct {
+		name string
+
+		// opened at is the time the channel was recorded as being open, and is
+		// never expected to be zero.
+		openedAt time.Time
+
+		// closed at is the tim the channel was recorded as being closed, and
+		// can have a zero value if the.
+		closedAt time.Time
+
+		// events is the set of event log that we are calculating uptime for.
+		events []*channelEvent
+
+		// startTime is the beginning of the period that we are calculating
+		// uptime for, it cannot have a zero value.
+		startTime time.Time
+
+		// endTime is the end of the period that we are calculating uptime for,
+		// it cannot have a zero value.
+		endTime time.Time
+
+		// expectedUptime is the amount of uptime we expect to be calculated
+		// over the period specified by startTime and endTime.
+		expectedUptime time.Duration
+
+		// expectErr is set to true if we expect an error to be returned when
+		// calling the uptime function
+		expectErr bool
+	}{
+		{
+			name:      "End before start",
+			endTime:   threeHoursAgo,
+			startTime: now,
+			expectErr: true,
+		},
+		{
+			name:      "Zero end time",
+			expectErr: true,
+		},
+		{
+			name:     "Online event and closed",
+			openedAt: fourHoursAgo,
+			closedAt: oneHourAgo,
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			startTime:      fourHoursAgo,
+			endTime:        now,
+			expectedUptime: time.Hour * 3,
+		},
+		{
+			name:     "Online event and not closed",
+			openedAt: fourHoursAgo,
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			startTime:      fourHoursAgo,
+			endTime:        now,
+			expectedUptime: time.Hour * 4,
+		},
+		{
+			name:     "Offline event and closed",
+			openedAt: fourHoursAgo,
+			closedAt: threeHoursAgo,
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOfflineEvent,
+				},
+			},
+			startTime: fourHoursAgo,
+			endTime:   now,
+		},
+		{
+			name:     "Online event before close",
+			openedAt: fourHoursAgo,
+			closedAt: oneHourAgo,
+			events: []*channelEvent{
+				{
+					timestamp: twoHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			startTime:      fourHoursAgo,
+			endTime:        now,
+			expectedUptime: time.Hour,
+		},
+		{
+			name:     "Online then offline event",
+			openedAt: fourHoursAgo,
+			closedAt: oneHourAgo,
+			events: []*channelEvent{
+				{
+					timestamp: threeHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+				{
+					timestamp: twoHoursAgo,
+					eventType: peerOfflineEvent,
+				},
+			},
+			startTime:      fourHoursAgo,
+			endTime:        now,
+			expectedUptime: time.Hour,
+		},
+		{
+			name:     "Online event before uptime period",
+			openedAt: fourHoursAgo,
+			closedAt: oneHourAgo,
+			events: []*channelEvent{
+				{
+					timestamp: threeHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			startTime:      twoHoursAgo,
+			endTime:        now,
+			expectedUptime: time.Hour,
+		},
+		{
+			name:     "Offline event after uptime period",
+			openedAt: fourHoursAgo,
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+				{
+					timestamp: now.Add(time.Hour),
+					eventType: peerOfflineEvent,
+				},
+			},
+			startTime:      twoHoursAgo,
+			endTime:        now,
+			expectedUptime: time.Hour * 2,
+		},
+		{
+			name:     "All events within period",
+			openedAt: fourHoursAgo,
+			events: []*channelEvent{
+				{
+					timestamp: twoHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			startTime:      threeHoursAgo,
+			endTime:        oneHourAgo,
+			expectedUptime: time.Hour,
+		},
+		{
+			name:     "Multiple online and offline",
+			openedAt: now.Add(time.Hour * -8),
+			events: []*channelEvent{
+				{
+					timestamp: now.Add(time.Hour * -7),
+					eventType: peerOnlineEvent,
+				},
+				{
+					timestamp: now.Add(time.Hour * -6),
+					eventType: peerOfflineEvent,
+				},
+				{
+					timestamp: now.Add(time.Hour * -5),
+					eventType: peerOnlineEvent,
+				},
+				{
+					timestamp: now.Add(time.Hour * -4),
+					eventType: peerOfflineEvent,
+				},
+				{
+					timestamp: now.Add(time.Hour * -3),
+					eventType: peerOnlineEvent,
+				},
+			},
+			startTime:      now.Add(time.Hour * -8),
+			endTime:        oneHourAgo,
+			expectedUptime: time.Hour * 4,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			score := &chanEventLog{
+				events: test.events,
+				now: func() time.Time {
+					return now
+				},
+				openedAt: test.openedAt,
+				closedAt: test.closedAt,
+			}
+
+			uptime, err := score.uptime(test.startTime, test.endTime)
+			if test.expectErr && err == nil {
+				t.Fatal("Expected an error, got nil")
+			}
+			if !test.expectErr && err != nil {
+				t.Fatalf("Expcted no error, got: %v", err)
+			}
+
+			if uptime != test.expectedUptime {
+				t.Errorf("Expected uptime: %v, got: %v",
+					test.expectedUptime, uptime)
+			}
+		})
+	}
+}
diff --git a/chanfitness/chaneventstore_test.go b/chanfitness/chaneventstore_test.go
new file mode 100644
index 000000000..a30f7d15d
--- /dev/null
+++ b/chanfitness/chaneventstore_test.go
@@ -0,0 +1,462 @@
+package chanfitness
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/lightningnetwork/lnd/channeldb"
+	"github.com/lightningnetwork/lnd/channelnotifier"
+	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/lightningnetwork/lnd/peernotifier"
+	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/subscribe"
+)
+
+// TestStartStoreError tests the starting of the store in cases where the setup
+// functions fail. It does not test the mechanics of consuming events because
+// these are covered in a separate set of tests.
+func TestStartStoreError(t *testing.T) {
+	// Ok and erroring subscribe functions are defined here to de-clutter tests.
+	okSubscribeFunc := func() (*subscribe.Client, error) {
+		return &subscribe.Client{
+			Cancel: func() {},
+		}, nil
+	}
+
+	errSubscribeFunc := func() (client *subscribe.Client, e error) {
+		return nil, errors.New("intentional test err")
+	}
+
+	tests := []struct {
+		name          string
+		ChannelEvents func() (*subscribe.Client, error)
+		PeerEvents    func() (*subscribe.Client, error)
+		GetChannels   func() ([]*channeldb.OpenChannel, error)
+	}{
+		{
+			name:          "Channel events fail",
+			ChannelEvents: errSubscribeFunc,
+		},
+		{
+			name:          "Peer events fail",
+			ChannelEvents: okSubscribeFunc,
+			PeerEvents:    errSubscribeFunc,
+		},
+		{
+			name:          "Get open channels fails",
+			ChannelEvents: okSubscribeFunc,
+			PeerEvents:    okSubscribeFunc,
+			GetChannels: func() (channels []*channeldb.OpenChannel, e error) {
+				return nil, errors.New("intentional test err")
+			},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			store := NewChannelEventStore(&Config{
+				SubscribeChannelEvents: test.ChannelEvents,
+				SubscribePeerEvents:    test.PeerEvents,
+				GetOpenChannels:        test.GetChannels,
+			})
+
+			err := store.Start()
+			// Check that we receive an error, because the test only checks for
+			// error cases.
+			if err == nil {
+				t.Fatalf("Expected error on startup, got: nil")
+			}
+		})
+	}
+}
+
+// TestMonitorChannelEvents tests the store's handling of channel and peer
+// events. It tests for the unexpected cases where we receive a channel open for
+// an already known channel and but does not test for closing an unknown channel
+// because it would require custom logic in the test to prevent iterating
+// through an eventLog which does not exist. This test does not test handling
+// of uptime and lifespan requests, as they are tested in their own tests.
+func TestMonitorChannelEvents(t *testing.T) {
+	privKey, err := btcec.NewPrivateKey(btcec.S256())
+	if err != nil {
+		t.Fatalf("Error getting pubkey: %v", err)
+	}
+
+	pubKey, err := route.NewVertexFromBytes(
+		privKey.PubKey().SerializeCompressed(),
+	)
+	if err != nil {
+		t.Fatalf("Could not create vertex: %v", err)
+	}
+
+	shortID := lnwire.ShortChannelID{
+		BlockHeight: 1234,
+		TxIndex:     2,
+		TxPosition:  2,
+	}
+
+	tests := []struct {
+		name string
+
+		// generateEvents takes channels which represent the updates channels
+		// for subscription clients and passes events in the desired order.
+		// This function is intended to be blocking so that the test does not
+		// have a data race with event consumption, so the channels should not
+		// be buffered.
+		generateEvents func(channelEvents, peerEvents chan<- interface{})
+
+		// expectedEvents is the expected set of event types in the store.
+		expectedEvents []eventType
+	}{
+		{
+			name: "Channel opened, peer comes online",
+			generateEvents: func(channelEvents, peerEvents chan<- interface{}) {
+				// Add an open channel event
+				channelEvents <- channelnotifier.OpenChannelEvent{
+					Channel: &channeldb.OpenChannel{
+						ShortChannelID: shortID,
+						IdentityPub:    privKey.PubKey(),
+					},
+				}
+
+				// Add a peer online event.
+				peerEvents <- peernotifier.PeerOnlineEvent{PubKey: pubKey}
+			},
+			expectedEvents: []eventType{peerOnlineEvent},
+		},
+		{
+			name: "Duplicate channel open events",
+			generateEvents: func(channelEvents, peerEvents chan<- interface{}) {
+				// Add an open channel event
+				channelEvents <- channelnotifier.OpenChannelEvent{
+					Channel: &channeldb.OpenChannel{
+						ShortChannelID: shortID,
+						IdentityPub:    privKey.PubKey(),
+					},
+				}
+
+				// Add a peer online event.
+				peerEvents <- peernotifier.PeerOnlineEvent{PubKey: pubKey}
+
+				// Add a duplicate channel open event.
+				channelEvents <- channelnotifier.OpenChannelEvent{
+					Channel: &channeldb.OpenChannel{
+						ShortChannelID: shortID,
+						IdentityPub:    privKey.PubKey(),
+					},
+				}
+			},
+			expectedEvents: []eventType{peerOnlineEvent},
+		},
+		{
+			name: "Channel opened, peer already online",
+			generateEvents: func(channelEvents, peerEvents chan<- interface{}) {
+				// Add a peer online event.
+				peerEvents <- peernotifier.PeerOnlineEvent{PubKey: pubKey}
+
+				// Add an open channel event
+				channelEvents <- channelnotifier.OpenChannelEvent{
+					Channel: &channeldb.OpenChannel{
+						ShortChannelID: shortID,
+						IdentityPub:    privKey.PubKey(),
+					},
+				}
+			},
+			expectedEvents: []eventType{peerOnlineEvent},
+		},
+
+		{
+			name: "Channel opened, peer offline, closed",
+			generateEvents: func(channelEvents, peerEvents chan<- interface{}) {
+				// Add an open channel event
+				channelEvents <- channelnotifier.OpenChannelEvent{
+					Channel: &channeldb.OpenChannel{
+						ShortChannelID: shortID,
+						IdentityPub:    privKey.PubKey(),
+					},
+				}
+
+				// Add a peer online event.
+				peerEvents <- peernotifier.PeerOfflineEvent{PubKey: pubKey}
+
+				// Add a close channel event.
+				channelEvents <- channelnotifier.ClosedChannelEvent{
+					CloseSummary: &channeldb.ChannelCloseSummary{
+						ShortChanID: shortID,
+					},
+				}
+			},
+			expectedEvents: []eventType{peerOfflineEvent},
+		},
+		{
+			name: "Event after channel close not recorded",
+			generateEvents: func(channelEvents, peerEvents chan<- interface{}) {
+				// Add an open channel event
+				channelEvents <- channelnotifier.OpenChannelEvent{
+					Channel: &channeldb.OpenChannel{
+						ShortChannelID: shortID,
+						IdentityPub:    privKey.PubKey(),
+					},
+				}
+
+				// Add a close channel event.
+				channelEvents <- channelnotifier.ClosedChannelEvent{
+					CloseSummary: &channeldb.ChannelCloseSummary{
+						ShortChanID: shortID,
+					},
+				}
+
+				// Add a peer online event.
+				peerEvents <- peernotifier.PeerOfflineEvent{PubKey: pubKey}
+			},
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			// Create a store with the channels and online peers specified
+			// by the test.
+			store := NewChannelEventStore(&Config{})
+
+			// Create channels which represent the subscriptions we have to peer
+			// and client events.
+			channelEvents := make(chan interface{})
+			peerEvents := make(chan interface{})
+
+			store.wg.Add(1)
+			go store.consume(&subscriptions{
+				channelUpdates: channelEvents,
+				peerUpdates:    peerEvents,
+				cancel:         func() {},
+			})
+
+			// Add events to the store then kill the goroutine using store.Stop.
+			test.generateEvents(channelEvents, peerEvents)
+			store.Stop()
+
+			// Retrieve the eventLog for the channel and check that its
+			// contents are as expected.
+			eventLog, ok := store.channels[shortID.ToUint64()]
+			if !ok {
+				t.Fatalf("Expected to find event store")
+			}
+
+			for i, e := range eventLog.events {
+				if test.expectedEvents[i] != e.eventType {
+					t.Fatalf("Expected type: %v, got: %v",
+						test.expectedEvents[i], e.eventType)
+				}
+			}
+		})
+	}
+}
+
+// TestGetLifetime tests the GetLifetime function for the cases where a channel
+// is known and unknown to the store.
+func TestGetLifetime(t *testing.T) {
+	now := time.Now()
+
+	tests := []struct {
+		name         string
+		channelFound bool
+		chanID       uint64
+		opened       time.Time
+		closed       time.Time
+		expectErr    bool
+	}{
+		{
+			name:         "Channel found",
+			channelFound: true,
+			opened:       now,
+			closed:       now.Add(time.Hour * -1),
+			expectErr:    false,
+		},
+		{
+			name:      "Channel not found",
+			expectErr: true,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			// Create and  empty events store for testing.
+			store := NewChannelEventStore(&Config{})
+
+			// Start goroutine which consumes GetLifespan requests.
+			store.wg.Add(1)
+			go store.consume(&subscriptions{
+				channelUpdates: make(chan interface{}),
+				peerUpdates:    make(chan interface{}),
+				cancel:         func() {},
+			})
+
+			// Stop the store's go routine.
+			defer store.Stop()
+
+			// Add channel to eventStore if the test indicates that it should
+			// be present.
+			if test.channelFound {
+				store.channels[test.chanID] = &chanEventLog{
+					openedAt: test.opened,
+					closedAt: test.closed,
+				}
+			}
+
+			open, close, err := store.GetLifespan(test.chanID)
+			if test.expectErr && err == nil {
+				t.Fatal("Expected an error, got nil")
+			}
+			if !test.expectErr && err != nil {
+				t.Fatalf("Expected no error, got: %v", err)
+			}
+
+			if open != test.opened {
+				t.Errorf("Expected: %v, got %v", test.opened, open)
+			}
+
+			if close != test.closed {
+				t.Errorf("Expected: %v, got %v", test.closed, close)
+			}
+		})
+	}
+}
+
+// TestGetUptime tests the getUptime call for channels known to the event store.
+// It does not test the trivial case where a channel is unknown to the store,
+// because this is simply a zero return if an item is not found in a map. It
+// tests the unexpected edge cases where a tracked channel does not have any
+// events recorded, and when a zero time is specified for the uptime range.
+func TestGetUptime(t *testing.T) {
+	// Set time for deterministic unit tests.
+	now := time.Now()
+
+	twoHoursAgo := now.Add(time.Hour * -2)
+	fourHoursAgo := now.Add(time.Hour * -4)
+
+	tests := []struct {
+		name string
+
+		chanID uint64
+
+		// events is the set of events we expect to find in the channel store.
+		events []*channelEvent
+
+		// openedAt is the time the channel is recorded as open by the store.
+		openedAt time.Time
+
+		// closedAt is the time the channel is recorded as closed by the store.
+		// If the channel is still open, this value is zero.
+		closedAt time.Time
+
+		// channelFound is true if we expect to find the channel in the store.
+		channelFound bool
+
+		// startTime specifies the beginning of the uptime range we want to
+		// calculate.
+		startTime time.Time
+
+		// endTime specified the end of the uptime range we want to calculate.
+		endTime time.Time
+
+		expectedUptime time.Duration
+		expectErr      bool
+	}{
+		{
+			name:         "No events",
+			startTime:    twoHoursAgo,
+			endTime:      now,
+			channelFound: true,
+		},
+		{
+			name: "50% Uptime",
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+				{
+					timestamp: twoHoursAgo,
+					eventType: peerOfflineEvent,
+				},
+			},
+			openedAt:       fourHoursAgo,
+			expectedUptime: time.Hour * 2,
+			startTime:      fourHoursAgo,
+			endTime:        now,
+			channelFound:   true,
+		},
+		{
+			name: "Zero start time",
+			events: []*channelEvent{
+				{
+					timestamp: fourHoursAgo,
+					eventType: peerOnlineEvent,
+				},
+			},
+			openedAt:       fourHoursAgo,
+			expectedUptime: time.Hour * 4,
+			endTime:        now,
+			channelFound:   true,
+		},
+		{
+			name:         "Channel not found",
+			startTime:    twoHoursAgo,
+			endTime:      now,
+			channelFound: false,
+			expectErr:    true,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			// Set up event store with the events specified for the test and
+			// mocked time.
+			store := NewChannelEventStore(&Config{})
+
+			// Start goroutine which consumes GetUptime requests.
+			store.wg.Add(1)
+			go store.consume(&subscriptions{
+				channelUpdates: make(chan interface{}),
+				peerUpdates:    make(chan interface{}),
+				cancel:         func() {},
+			})
+
+			// Stop the store's goroutine.
+			defer store.Stop()
+
+			// Add the channel to the store if it is intended to be found.
+			if test.channelFound {
+				store.channels[test.chanID] = &chanEventLog{
+					events:   test.events,
+					now:      func() time.Time { return now },
+					openedAt: test.openedAt,
+					closedAt: test.closedAt,
+				}
+			}
+
+			uptime, err := store.GetUptime(test.chanID, test.startTime, test.endTime)
+			if test.expectErr && err == nil {
+				t.Fatal("Expected an error, got nil")
+			}
+			if !test.expectErr && err != nil {
+				t.Fatalf("Expcted no error, got: %v", err)
+			}
+
+			if uptime != test.expectedUptime {
+				t.Fatalf("Expected uptime percentage: %v, got %v",
+					test.expectedUptime, uptime)
+			}
+
+		})
+	}
+}
diff --git a/routing/heap_test.go b/routing/heap_test.go
index 659653f70..4214e965b 100644
--- a/routing/heap_test.go
+++ b/routing/heap_test.go
@@ -17,19 +17,19 @@ func TestHeapOrdering(t *testing.T) {
 
 	// First, create a blank heap, we'll use this to push on randomly
 	// generated items.
-	nodeHeap := newDistanceHeap(0)
+	nodeHeap := newDistanceHeap()
 
 	prand.Seed(1)
 
 	// Create 100 random entries adding them to the heap created above, but
 	// also a list that we'll sort with the entries.
 	const numEntries = 100
-	sortedEntries := make([]*nodeWithDist, 0, numEntries)
+	sortedEntries := make([]nodeWithDist, 0, numEntries)
 	for i := 0; i < numEntries; i++ {
 		var pubKey [33]byte
 		prand.Read(pubKey[:])
 
-		entry := &nodeWithDist{
+		entry := nodeWithDist{
 			node: route.Vertex(pubKey),
 			dist: prand.Int63(),
 		}
@@ -55,9 +55,9 @@ func TestHeapOrdering(t *testing.T) {
 
 	// One by one, pop of all the entries from the heap, they should come
 	// out in sorted order.
-	var poppedEntries []*nodeWithDist
+	var poppedEntries []nodeWithDist
 	for nodeHeap.Len() != 0 {
-		e := heap.Pop(&nodeHeap).(*nodeWithDist)
+		e := heap.Pop(&nodeHeap).(nodeWithDist)
 		poppedEntries = append(poppedEntries, e)
 	}