diff --git a/chanacceptor/acceptor_test.go b/chanacceptor/acceptor_test.go index 36c7d6b3..899d922f 100644 --- a/chanacceptor/acceptor_test.go +++ b/chanacceptor/acceptor_test.go @@ -1,156 +1,316 @@ package chanacceptor import ( - "bytes" - "sync/atomic" + "errors" + "math/big" "testing" "time" - "github.com/lightningnetwork/lnd/lnrpc" - "github.com/btcsuite/btcd/btcec" + "github.com/btcsuite/btcd/chaincfg" + "github.com/btcsuite/btcutil" + "github.com/lightningnetwork/lnd/lnrpc" + "github.com/lightningnetwork/lnd/lnwallet/chancloser" "github.com/lightningnetwork/lnd/lnwire" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) -func randKey(t *testing.T) *btcec.PublicKey { - t.Helper() +const testTimeout = time.Second - priv, err := btcec.NewPrivateKey(btcec.S256()) - if err != nil { - t.Fatalf("unable to generate new public key") - } +type channelAcceptorCtx struct { + t *testing.T - return priv.PubKey() + // extRequests is the channel that we send our channel accept requests + // into, this channel mocks sending of a request to the rpc acceptor. + // This channel should be buffered with the number of requests we want + // to send so that it does not block (like a rpc stream). + extRequests chan []byte + + // responses is a map of pending channel IDs to the response which we + // wish to mock the remote channel acceptor sending. + responses map[[32]byte]*lnrpc.ChannelAcceptResponse + + // acceptor is the channel acceptor we create for the test. + acceptor *RPCAcceptor + + // errChan is a channel that the error the channel acceptor exits with + // is sent into. + errChan chan error + + // quit is a channel that can be used to shutdown the channel acceptor + // and return errShuttingDown. + quit chan struct{} } -// requestInfo encapsulates the information sent from the RPCAcceptor to the -// receiver on the other end of the stream. -type requestInfo struct { - chanReq *ChannelAcceptRequest - responseChan chan lnrpc.ChannelAcceptResponse -} +func newChanAcceptorCtx(t *testing.T, acceptCallCount int, + responses map[[32]byte]*lnrpc.ChannelAcceptResponse) *channelAcceptorCtx { -var defaultAcceptTimeout = 5 * time.Second - -func acceptAndIncrementCtr(rpc ChannelAcceptor, req *ChannelAcceptRequest, - ctr *uint32, success chan struct{}) { - - result := rpc.Accept(req) - if !result { - return + testCtx := &channelAcceptorCtx{ + t: t, + extRequests: make(chan []byte, acceptCallCount), + responses: responses, + errChan: make(chan error), + quit: make(chan struct{}), } - val := atomic.AddUint32(ctr, 1) - if val == 3 { - success <- struct{}{} - } -} - -// TestMultipleRPCClients tests that the RPCAcceptor is able to handle multiple -// callers to its Accept method and respond to them correctly. -func TestRPCMultipleAcceptClients(t *testing.T) { - - var ( - node = randKey(t) - - firstOpenReq = &ChannelAcceptRequest{ - Node: node, - OpenChanMsg: &lnwire.OpenChannel{ - PendingChannelID: [32]byte{0}, - }, - } - - secondOpenReq = &ChannelAcceptRequest{ - Node: node, - OpenChanMsg: &lnwire.OpenChannel{ - PendingChannelID: [32]byte{1}, - }, - } - - thirdOpenReq = &ChannelAcceptRequest{ - Node: node, - OpenChanMsg: &lnwire.OpenChannel{ - PendingChannelID: [32]byte{2}, - }, - } - - counter uint32 + testCtx.acceptor = NewRPCAcceptor( + testCtx.receiveResponse, testCtx.sendRequest, testTimeout*5, + &chaincfg.TestNet3Params, testCtx.quit, ) - quit := make(chan struct{}) - defer close(quit) + return testCtx +} - // Create channels to handle requests and successes. - requests := make(chan *requestInfo) - successChan := make(chan struct{}) - errChan := make(chan struct{}, 4) +// sendRequest mocks sending a request to the channel acceptor. +func (c *channelAcceptorCtx) sendRequest(request *lnrpc.ChannelAcceptRequest) error { + select { + case c.extRequests <- request.PendingChanId: - // demultiplexReq is a closure used to abstract the RPCAcceptor's request - // and response logic. - demultiplexReq := func(req *ChannelAcceptRequest) bool { - respChan := make(chan lnrpc.ChannelAcceptResponse, 1) - - newRequest := &requestInfo{ - chanReq: req, - responseChan: respChan, - } - - // Send the newRequest to the requests channel. - select { - case requests <- newRequest: - case <-quit: - return false - } - - // Receive the response and verify that the PendingChanId matches - // the ID found in the ChannelAcceptRequest. If no response has been - // received in defaultAcceptTimeout, then return false. - select { - case resp := <-respChan: - pendingID := req.OpenChanMsg.PendingChannelID - if !bytes.Equal(pendingID[:], resp.PendingChanId) { - errChan <- struct{}{} - return false - } - - return resp.Accept - case <-time.After(defaultAcceptTimeout): - errChan <- struct{}{} - return false - case <-quit: - return false - } + case <-time.After(testTimeout): + c.t.Fatalf("timeout sending request: %v", request.PendingChanId) } - rpcAcceptor := NewRPCAcceptor(demultiplexReq) + return nil +} - // Now we call the Accept method for each request. +// receiveResponse mocks sending of a response from the channel acceptor. +func (c *channelAcceptorCtx) receiveResponse() (*lnrpc.ChannelAcceptResponse, + error) { + + select { + case id := <-c.extRequests: + scratch := [32]byte{} + copy(scratch[:], id) + + resp, ok := c.responses[scratch] + assert.True(c.t, ok) + + return resp, nil + + case <-time.After(testTimeout): + c.t.Fatalf("timeout receiving request") + return nil, errors.New("receiveResponse timeout") + + // Exit if our test acceptor closes the done channel, which indicates + // that the acceptor is shutting down. + case <-c.acceptor.done: + return nil, errors.New("acceptor shutting down") + } +} + +// start runs our channel acceptor in a goroutine which sends its exit error +// into our test error channel. +func (c *channelAcceptorCtx) start() { go func() { - acceptAndIncrementCtr(rpcAcceptor, firstOpenReq, &counter, successChan) + c.errChan <- c.acceptor.Run() }() +} - go func() { - acceptAndIncrementCtr(rpcAcceptor, secondOpenReq, &counter, successChan) - }() +// stop shuts down the test's channel acceptor and asserts that it exits with +// our expected error. +func (c *channelAcceptorCtx) stop() { + close(c.quit) - go func() { - acceptAndIncrementCtr(rpcAcceptor, thirdOpenReq, &counter, successChan) - }() + select { + case actual := <-c.errChan: + assert.Equal(c.t, errShuttingDown, actual) - for { + case <-time.After(testTimeout): + c.t.Fatal("timeout waiting for acceptor to exit") + } +} + +// queryAndAssert takes a map of open channel requests which we want to call +// Accept for to the outcome we expect from the acceptor, dispatches each +// request in a goroutine and then asserts that we get the outcome we expect. +func (c *channelAcceptorCtx) queryAndAssert(queries map[*lnwire.OpenChannel]*ChannelAcceptResponse) { + var ( + node = &btcec.PublicKey{ + X: big.NewInt(1), + Y: big.NewInt(1), + } + + responses = make(chan struct{}) + ) + + for request, expected := range queries { + request := request + expected := expected + + go func() { + resp := c.acceptor.Accept(&ChannelAcceptRequest{ + Node: node, + OpenChanMsg: request, + }) + assert.Equal(c.t, expected, resp) + responses <- struct{}{} + }() + } + + // Wait for each of our requests to return a response before we exit. + for i := 0; i < len(queries); i++ { select { - case newRequest := <-requests: - newResponse := lnrpc.ChannelAcceptResponse{ - Accept: true, - PendingChanId: newRequest.chanReq.OpenChanMsg.PendingChannelID[:], - } - - newRequest.responseChan <- newResponse - case <-errChan: - t.Fatalf("unable to accept ChannelAcceptRequest") - case <-successChan: - return - case <-quit: + case <-responses: + case <-time.After(testTimeout): + c.t.Fatalf("did not receive response") } } } + +// TestMultipleAcceptClients tests that the RPC acceptor is capable of handling +// multiple requests to its Accept function and responding to them correctly. +func TestMultipleAcceptClients(t *testing.T) { + testAddr := "bcrt1qwrmq9uca0t3dy9t9wtuq5tm4405r7tfzyqn9pp" + testUpfront, err := chancloser.ParseUpfrontShutdownAddress( + testAddr, &chaincfg.TestNet3Params, + ) + require.NoError(t, err) + + var ( + chan1 = &lnwire.OpenChannel{ + PendingChannelID: [32]byte{1}, + } + chan2 = &lnwire.OpenChannel{ + PendingChannelID: [32]byte{2}, + } + chan3 = &lnwire.OpenChannel{ + PendingChannelID: [32]byte{3}, + } + + customError = errors.New("go away") + + // Queries is a map of the channel IDs we will query Accept + // with, and the set of outcomes we expect. + queries = map[*lnwire.OpenChannel]*ChannelAcceptResponse{ + chan1: NewChannelAcceptResponse( + true, nil, testUpfront, 1, 2, 3, 4, 5, 6, + ), + chan2: NewChannelAcceptResponse( + false, errChannelRejected, nil, 0, 0, 0, + 0, 0, 0, + ), + chan3: NewChannelAcceptResponse( + false, customError, nil, 0, 0, 0, 0, 0, 0, + ), + } + + // Responses is a mocked set of responses from the remote + // channel acceptor. + responses = map[[32]byte]*lnrpc.ChannelAcceptResponse{ + chan1.PendingChannelID: { + PendingChanId: chan1.PendingChannelID[:], + Accept: true, + UpfrontShutdown: testAddr, + CsvDelay: 1, + MaxHtlcCount: 2, + MinAcceptDepth: 3, + ReserveSat: 4, + InFlightMaxMsat: 5, + MinHtlcIn: 6, + }, + chan2.PendingChannelID: { + PendingChanId: chan2.PendingChannelID[:], + Accept: false, + }, + chan3.PendingChannelID: { + PendingChanId: chan3.PendingChannelID[:], + Accept: false, + Error: customError.Error(), + }, + } + ) + + // Create and start our channel acceptor. + testCtx := newChanAcceptorCtx(t, len(queries), responses) + testCtx.start() + + // Dispatch three queries and assert that we get our expected response. + // for each. + testCtx.queryAndAssert(queries) + + // Shutdown our acceptor. + testCtx.stop() +} + +// TestInvalidResponse tests the case where our remote channel acceptor sends us +// an invalid response, so the channel acceptor stream terminates. +func TestInvalidResponse(t *testing.T) { + var ( + chan1 = [32]byte{1} + + // We make a single query, and expect it to fail with our + // generic error because our response is invalid. + queries = map[*lnwire.OpenChannel]*ChannelAcceptResponse{ + { + PendingChannelID: chan1, + }: NewChannelAcceptResponse( + false, errChannelRejected, nil, 0, 0, + 0, 0, 0, 0, + ), + } + + // Create a single response which is invalid because it accepts + // the channel but also contains an error message. + responses = map[[32]byte]*lnrpc.ChannelAcceptResponse{ + chan1: { + PendingChanId: chan1[:], + Accept: true, + Error: "has an error as well", + }, + } + ) + + // Create and start our channel acceptor. + testCtx := newChanAcceptorCtx(t, len(queries), responses) + testCtx.start() + + testCtx.queryAndAssert(queries) + + // We do not expect our channel acceptor to exit because of one invalid + // response, so we shutdown and assert here. + testCtx.stop() +} + +// TestInvalidReserve tests validation of the channel reserve proposed by the +// acceptor against the dust limit that was proposed by the remote peer. +func TestInvalidReserve(t *testing.T) { + var ( + chan1 = [32]byte{1} + + dustLimit = btcutil.Amount(1000) + reserve = dustLimit / 2 + + // We make a single query, and expect it to fail with our + // generic error because channel reserve is too low. + queries = map[*lnwire.OpenChannel]*ChannelAcceptResponse{ + { + PendingChannelID: chan1, + DustLimit: dustLimit, + }: NewChannelAcceptResponse( + false, errChannelRejected, nil, 0, 0, + 0, reserve, 0, 0, + ), + } + + // Create a single response which is invalid because the + // proposed reserve is below our dust limit. + responses = map[[32]byte]*lnrpc.ChannelAcceptResponse{ + chan1: { + PendingChanId: chan1[:], + Accept: true, + ReserveSat: uint64(reserve), + }, + } + ) + + // Create and start our channel acceptor. + testCtx := newChanAcceptorCtx(t, len(queries), responses) + testCtx.start() + + testCtx.queryAndAssert(queries) + + // We do not expect our channel acceptor to exit because of one invalid + // response, so we shutdown and assert here. + testCtx.stop() +} diff --git a/chanacceptor/chainedacceptor.go b/chanacceptor/chainedacceptor.go index 1c12a499..e7227b04 100644 --- a/chanacceptor/chainedacceptor.go +++ b/chanacceptor/chainedacceptor.go @@ -46,18 +46,48 @@ func (c *ChainedAcceptor) RemoveAcceptor(id uint64) { // and returns the conjunction of all these predicates. // // NOTE: Part of the ChannelAcceptor interface. -func (c *ChainedAcceptor) Accept(req *ChannelAcceptRequest) bool { - result := true - +func (c *ChainedAcceptor) Accept(req *ChannelAcceptRequest) *ChannelAcceptResponse { c.acceptorsMtx.RLock() - for _, acceptor := range c.acceptors { - // We call Accept first in case any acceptor (perhaps an RPCAcceptor) - // wishes to be notified about ChannelAcceptRequest. - result = acceptor.Accept(req) && result - } - c.acceptorsMtx.RUnlock() + defer c.acceptorsMtx.RUnlock() - return result + var finalResp ChannelAcceptResponse + + for _, acceptor := range c.acceptors { + // Call our acceptor to determine whether we want to accept this + // channel. + acceptorResponse := acceptor.Accept(req) + + // If we should reject the channel, we can just exit early. This + // has the effect of returning the error belonging to our first + // failed acceptor. + if acceptorResponse.RejectChannel() { + return acceptorResponse + } + + // If we have accepted the channel, we need to set the other + // fields that were set in the response. However, since we are + // dealing with multiple responses, we need to make sure that we + // have not received inconsistent values (eg a csv delay of 1 + // from one acceptor, and a delay of 120 from another). We + // set each value on our final response if it has not been set + // yet, and allow duplicate sets if the value is the same. If + // we cannot set a field, we return an error response. + var err error + finalResp, err = mergeResponse(finalResp, *acceptorResponse) + if err != nil { + log.Errorf("response for: %x has inconsistent values: %v", + req.OpenChanMsg.PendingChannelID, err) + + return NewChannelAcceptResponse( + false, errChannelRejected, nil, 0, 0, + 0, 0, 0, 0, + ) + } + } + + // If we have gone through all of our acceptors with no objections, we + // can return an acceptor with a nil error. + return &finalResp } // A compile-time constraint to ensure ChainedAcceptor implements the diff --git a/chanacceptor/errors.go b/chanacceptor/errors.go new file mode 100644 index 00000000..ac058b67 --- /dev/null +++ b/chanacceptor/errors.go @@ -0,0 +1,8 @@ +package chanacceptor + +// ChanAcceptError is an error that it returned when an external channel +// acceptor rejects a channel. Note that this error type is whitelisted and will +// be delivered to the peer initiating a channel. +type ChanAcceptError struct { + error +} diff --git a/chanacceptor/interface.go b/chanacceptor/interface.go index c0a3981c..1f0b8cdc 100644 --- a/chanacceptor/interface.go +++ b/chanacceptor/interface.go @@ -1,10 +1,20 @@ package chanacceptor import ( + "errors" + "github.com/btcsuite/btcd/btcec" + "github.com/btcsuite/btcutil" "github.com/lightningnetwork/lnd/lnwire" ) +var ( + // errChannelRejected is returned when the rpc channel acceptor rejects + // a channel due to acceptor timeout, shutdown, or because no custom + // error value is available when the channel was rejected. + errChannelRejected = errors.New("channel rejected") +) + // ChannelAcceptRequest is a struct containing the requesting node's public key // along with the lnwire.OpenChannel message that they sent when requesting an // inbound channel. This information is provided to each acceptor so that they @@ -18,8 +28,88 @@ type ChannelAcceptRequest struct { OpenChanMsg *lnwire.OpenChannel } -// ChannelAcceptor is an interface that represents a predicate on the data +// ChannelAcceptResponse is a struct containing the response to a request to +// open an inbound channel. Note that fields added to this struct must be added +// to the mergeResponse function to allow combining of responses from different +// acceptors. +type ChannelAcceptResponse struct { + // ChanAcceptError the error returned by the channel acceptor. If the + // channel was accepted, this value will be nil. + ChanAcceptError + + // UpfrontShutdown is the address that we will set as our upfront + // shutdown address. + UpfrontShutdown lnwire.DeliveryAddress + + // CSVDelay is the csv delay we require for the remote peer. + CSVDelay uint16 + + // Reserve is the amount that require the remote peer hold in reserve + // on the channel. + Reserve btcutil.Amount + + // InFlightTotal is the maximum amount that we allow the remote peer to + // hold in outstanding htlcs. + InFlightTotal lnwire.MilliSatoshi + + // HtlcLimit is the maximum number of htlcs that we allow the remote + // peer to offer us. + HtlcLimit uint16 + + // MinHtlcIn is the minimum incoming htlc value allowed on the channel. + MinHtlcIn lnwire.MilliSatoshi + + // MinAcceptDepth is the minimum depth that the initiator of the + // channel should wait before considering the channel open. + MinAcceptDepth uint16 +} + +// NewChannelAcceptResponse is a constructor for a channel accept response, +// which creates a response with an appropriately wrapped error (in the case of +// a rejection) so that the error will be whitelisted and delivered to the +// initiating peer. Accepted channels simply return a response containing a nil +// error. +func NewChannelAcceptResponse(accept bool, acceptErr error, + upfrontShutdown lnwire.DeliveryAddress, csvDelay, htlcLimit, + minDepth uint16, reserve btcutil.Amount, inFlight, + minHtlcIn lnwire.MilliSatoshi) *ChannelAcceptResponse { + + resp := &ChannelAcceptResponse{ + UpfrontShutdown: upfrontShutdown, + CSVDelay: csvDelay, + Reserve: reserve, + InFlightTotal: inFlight, + HtlcLimit: htlcLimit, + MinHtlcIn: minHtlcIn, + MinAcceptDepth: minDepth, + } + + // If we want to accept the channel, we return a response with a nil + // error. + if accept { + return resp + } + + // Use a generic error when no custom error is provided. + if acceptErr == nil { + acceptErr = errChannelRejected + } + + resp.ChanAcceptError = ChanAcceptError{ + error: acceptErr, + } + + return resp +} + +// RejectChannel returns a boolean that indicates whether we should reject the +// channel. +func (c *ChannelAcceptResponse) RejectChannel() bool { + return c.error != nil +} + +// ChannelAcceptor is an interface that represents a predicate on the data // contained in ChannelAcceptRequest. type ChannelAcceptor interface { - Accept(req *ChannelAcceptRequest) bool + Accept(req *ChannelAcceptRequest) *ChannelAcceptResponse } diff --git a/chanacceptor/log.go b/chanacceptor/log.go new file mode 100644 index 00000000..26e131c4 --- /dev/null +++ b/chanacceptor/log.go @@ -0,0 +1,32 @@ +package chanacceptor + +import ( + "github.com/btcsuite/btclog" + "github.com/lightningnetwork/lnd/build" +) + +// Subsystem defines the logging code for this subsystem. +const Subsystem = "CHAC" + +// 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/chanacceptor/merge.go b/chanacceptor/merge.go new file mode 100644 index 00000000..852329f5 --- /dev/null +++ b/chanacceptor/merge.go @@ -0,0 +1,152 @@ +package chanacceptor + +import ( + "bytes" + "fmt" + + "github.com/btcsuite/btcutil" + "github.com/lightningnetwork/lnd/lnwire" +) + +const ( + // We use field names in our errors for more readable errors. Create + // consts for them here so that we can exactly match in our unit tests. + fieldCSV = "csv delay" + fieldHtlcLimit = "htlc limit" + fieldMinDep = "min depth" + fieldReserve = "reserve" + fieldMinIn = "min htlc in" + fieldInFlightTotal = "in flight total" + fieldUpfrontShutdown = "upfront shutdown" +) + +// fieldMismatchError returns a merge error for a named field when we get two +// channel acceptor responses which have different values set. +func fieldMismatchError(name string, current, new interface{}) error { + return fmt.Errorf("multiple values set for: %v, %v and %v", + name, current, new) +} + +// mergeInt64 merges two int64 values, failing if they have different non-zero +// values. +func mergeInt64(name string, current, new int64) (int64, error) { + switch { + case current == 0: + return new, nil + + case new == 0: + return current, nil + + case current != new: + return 0, fieldMismatchError(name, current, new) + + default: + return new, nil + } +} + +// mergeMillisatoshi merges two msat values, failing if they have different +// non-zero values. +func mergeMillisatoshi(name string, current, + new lnwire.MilliSatoshi) (lnwire.MilliSatoshi, error) { + + switch { + case current == 0: + return new, nil + + case new == 0: + return current, nil + + case current != new: + return 0, fieldMismatchError(name, current, new) + + default: + return new, nil + } +} + +// mergeDeliveryAddress merges two delivery address values, failing if they have +// different non-zero values. +func mergeDeliveryAddress(name string, current, + new lnwire.DeliveryAddress) (lnwire.DeliveryAddress, error) { + + switch { + case current == nil: + return new, nil + + case new == nil: + return current, nil + + case !bytes.Equal(current, new): + return nil, fieldMismatchError(name, current, new) + + default: + return new, nil + } +} + +// mergeResponse takes two channel accept responses, and attempts to merge their +// fields, failing if any fields conflict (are non-zero and not equal). It +// returns a new response that has all the merged fields in it. +func mergeResponse(current, new ChannelAcceptResponse) (ChannelAcceptResponse, + error) { + + csv, err := mergeInt64( + fieldCSV, int64(current.CSVDelay), int64(new.CSVDelay), + ) + if err != nil { + return current, err + } + current.CSVDelay = uint16(csv) + + htlcLimit, err := mergeInt64( + fieldHtlcLimit, int64(current.HtlcLimit), + int64(new.HtlcLimit), + ) + if err != nil { + return current, err + } + current.HtlcLimit = uint16(htlcLimit) + + minDepth, err := mergeInt64( + fieldMinDep, int64(current.MinAcceptDepth), + int64(new.MinAcceptDepth), + ) + if err != nil { + return current, err + } + current.MinAcceptDepth = uint16(minDepth) + + reserve, err := mergeInt64( + fieldReserve, int64(current.Reserve), int64(new.Reserve), + ) + if err != nil { + return current, err + } + current.Reserve = btcutil.Amount(reserve) + + current.MinHtlcIn, err = mergeMillisatoshi( + fieldMinIn, current.MinHtlcIn, new.MinHtlcIn, + ) + if err != nil { + return current, err + } + + current.InFlightTotal, err = mergeMillisatoshi( + fieldInFlightTotal, current.InFlightTotal, + new.InFlightTotal, + ) + if err != nil { + return current, err + } + + current.UpfrontShutdown, err = mergeDeliveryAddress( + fieldUpfrontShutdown, current.UpfrontShutdown, + new.UpfrontShutdown, + ) + if err != nil { + return current, err + } + + return current, nil +} diff --git a/chanacceptor/merge_test.go b/chanacceptor/merge_test.go new file mode 100644 index 00000000..c32c3f30 --- /dev/null +++ b/chanacceptor/merge_test.go @@ -0,0 +1,188 @@ +package chanacceptor + +import ( + "testing" + + "github.com/lightningnetwork/lnd/lnwire" + "github.com/stretchr/testify/require" +) + +// TestMergeResponse tests merging of channel acceptor responses. +func TestMergeResponse(t *testing.T) { + var ( + addr1 = lnwire.DeliveryAddress{1} + addr2 = lnwire.DeliveryAddress{2} + + populatedResp = ChannelAcceptResponse{ + UpfrontShutdown: addr1, + CSVDelay: 2, + Reserve: 3, + InFlightTotal: 4, + HtlcLimit: 5, + MinHtlcIn: 6, + MinAcceptDepth: 7, + } + ) + + tests := []struct { + name string + current ChannelAcceptResponse + new ChannelAcceptResponse + merged ChannelAcceptResponse + err error + }{ + { + name: "same response", + current: populatedResp, + new: populatedResp, + merged: populatedResp, + err: nil, + }, + { + name: "different upfront", + current: ChannelAcceptResponse{ + UpfrontShutdown: addr1, + }, + new: ChannelAcceptResponse{ + UpfrontShutdown: addr2, + }, + err: fieldMismatchError(fieldUpfrontShutdown, addr1, addr2), + }, + { + name: "different csv", + current: ChannelAcceptResponse{ + CSVDelay: 1, + }, + new: ChannelAcceptResponse{ + CSVDelay: 2, + }, + err: fieldMismatchError(fieldCSV, 1, 2), + }, + { + name: "different reserve", + current: ChannelAcceptResponse{ + Reserve: 1, + }, + new: ChannelAcceptResponse{ + Reserve: 2, + }, + err: fieldMismatchError(fieldReserve, 1, 2), + }, + { + name: "different in flight", + current: ChannelAcceptResponse{ + InFlightTotal: 1, + }, + new: ChannelAcceptResponse{ + InFlightTotal: 2, + }, + err: fieldMismatchError( + fieldInFlightTotal, lnwire.MilliSatoshi(1), + lnwire.MilliSatoshi(2), + ), + }, + { + name: "different htlc limit", + current: ChannelAcceptResponse{ + HtlcLimit: 1, + }, + new: ChannelAcceptResponse{ + HtlcLimit: 2, + }, + err: fieldMismatchError(fieldHtlcLimit, 1, 2), + }, + { + name: "different min in", + current: ChannelAcceptResponse{ + MinHtlcIn: 1, + }, + new: ChannelAcceptResponse{ + MinHtlcIn: 2, + }, + err: fieldMismatchError( + fieldMinIn, lnwire.MilliSatoshi(1), + lnwire.MilliSatoshi(2), + ), + }, + { + name: "different depth", + current: ChannelAcceptResponse{ + MinAcceptDepth: 1, + }, + new: ChannelAcceptResponse{ + MinAcceptDepth: 2, + }, + err: fieldMismatchError(fieldMinDep, 1, 2), + }, + { + name: "merge all values", + current: ChannelAcceptResponse{ + UpfrontShutdown: lnwire.DeliveryAddress{1}, + CSVDelay: 1, + Reserve: 0, + InFlightTotal: 3, + HtlcLimit: 0, + MinHtlcIn: 5, + MinAcceptDepth: 0, + }, + new: ChannelAcceptResponse{ + UpfrontShutdown: nil, + CSVDelay: 0, + Reserve: 2, + InFlightTotal: 0, + HtlcLimit: 4, + MinHtlcIn: 0, + MinAcceptDepth: 6, + }, + merged: ChannelAcceptResponse{ + UpfrontShutdown: lnwire.DeliveryAddress{1}, + CSVDelay: 1, + Reserve: 2, + InFlightTotal: 3, + HtlcLimit: 4, + MinHtlcIn: 5, + MinAcceptDepth: 6, + }, + err: nil, + }, + { + // Test the case where fields have the same non-zero + // value, and the case where only response value is + // non-zero. + name: "empty and identical", + current: ChannelAcceptResponse{ + CSVDelay: 1, + Reserve: 2, + InFlightTotal: 0, + }, + new: ChannelAcceptResponse{ + CSVDelay: 0, + Reserve: 2, + InFlightTotal: 3, + }, + merged: ChannelAcceptResponse{ + CSVDelay: 1, + Reserve: 2, + InFlightTotal: 3, + }, + err: nil, + }, + } + + for _, test := range tests { + test := test + + t.Run(test.name, func(t *testing.T) { + resp, err := mergeResponse(test.current, test.new) + require.Equal(t, test.err, err) + + // If we expect an error, exit early rather than compare + // our result. + if test.err != nil { + return + } + + require.Equal(t, test.merged, resp) + }) + } +} diff --git a/chanacceptor/rpcacceptor.go b/chanacceptor/rpcacceptor.go index 9c4401d7..2e92ba16 100644 --- a/chanacceptor/rpcacceptor.go +++ b/chanacceptor/rpcacceptor.go @@ -1,24 +1,402 @@ package chanacceptor +import ( + "encoding/hex" + "errors" + "fmt" + "sync" + "time" + + "github.com/btcsuite/btcd/chaincfg" + "github.com/btcsuite/btcutil" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/lnrpc" + "github.com/lightningnetwork/lnd/lnwallet/chancloser" + "github.com/lightningnetwork/lnd/lnwire" +) + +var ( + errShuttingDown = errors.New("server shutting down") + + // errCustomLength is returned when our custom error's length exceeds + // our maximum. + errCustomLength = fmt.Errorf("custom error message exceeds length "+ + "limit: %v", maxErrorLength) + + // errInvalidUpfrontShutdown is returned when we cannot parse the + // upfront shutdown address returned. + errInvalidUpfrontShutdown = fmt.Errorf("could not parse upfront " + + "shutdown address") + + // errInsufficientReserve is returned when the reserve proposed by for + // a channel is less than the dust limit originally supplied. + errInsufficientReserve = fmt.Errorf("reserve lower than proposed dust " + + "limit") + + // errAcceptWithError is returned when we get a response which accepts + // a channel but ambiguously also sets a custom error message. + errAcceptWithError = errors.New("channel acceptor response accepts " + + "channel, but also includes custom error") + + // errMaxHtlcTooHigh is returned if our htlc count exceeds the number + // hard-set by BOLT 2. + errMaxHtlcTooHigh = fmt.Errorf("htlc limit exceeds spec limit of: %v", + input.MaxHTLCNumber/2) + + // maxErrorLength is the maximum error length we allow the error we + // send to our peer to be. + maxErrorLength = 500 +) + +// chanAcceptInfo contains a request for a channel acceptor decision, and a +// channel that the response should be sent on. +type chanAcceptInfo struct { + request *ChannelAcceptRequest + response chan *ChannelAcceptResponse +} + // RPCAcceptor represents the RPC-controlled variant of the ChannelAcceptor. // One RPCAcceptor allows one RPC client. type RPCAcceptor struct { - acceptClosure func(req *ChannelAcceptRequest) bool + // receive is a function from which we receive channel acceptance + // decisions. Note that this function is expected to block. + receive func() (*lnrpc.ChannelAcceptResponse, error) + + // send is a function which sends requests for channel acceptance + // decisions into our rpc stream. + send func(request *lnrpc.ChannelAcceptRequest) error + + // requests is a channel that we send requests for a acceptor response + // into. + requests chan *chanAcceptInfo + + // timeout is the amount of time we allow the channel acceptance + // decision to take. This time includes the time to send a query to the + // acceptor, and the time it takes to receive a response. + timeout time.Duration + + // params are our current chain params. + params *chaincfg.Params + + // done is closed when the rpc client terminates. + done chan struct{} + + // quit is closed when lnd is shutting down. + quit chan struct{} + + wg sync.WaitGroup } // Accept is a predicate on the ChannelAcceptRequest which is sent to the RPC -// client who will respond with the ultimate decision. This assumes an accept -// closure has been specified during creation. +// client who will respond with the ultimate decision. This function passes the +// request into the acceptor's requests channel, and returns the response it +// receives, failing the request if the timeout elapses. // // NOTE: Part of the ChannelAcceptor interface. -func (r *RPCAcceptor) Accept(req *ChannelAcceptRequest) bool { - return r.acceptClosure(req) +func (r *RPCAcceptor) Accept(req *ChannelAcceptRequest) *ChannelAcceptResponse { + respChan := make(chan *ChannelAcceptResponse, 1) + + newRequest := &chanAcceptInfo{ + request: req, + response: respChan, + } + + // timeout is the time after which ChannelAcceptRequests expire. + timeout := time.After(r.timeout) + + // Create a rejection response which we can use for the cases where we + // reject the channel. + rejectChannel := NewChannelAcceptResponse( + false, errChannelRejected, nil, 0, 0, 0, 0, 0, 0, + ) + + // Send the request to the newRequests channel. + select { + case r.requests <- newRequest: + + case <-timeout: + log.Errorf("RPCAcceptor returned false - reached timeout of %v", + r.timeout) + return rejectChannel + + case <-r.done: + return rejectChannel + + case <-r.quit: + return rejectChannel + } + + // Receive the response and return it. If no response has been received + // in AcceptorTimeout, then return false. + select { + case resp := <-respChan: + return resp + + case <-timeout: + log.Errorf("RPCAcceptor returned false - reached timeout of %v", + r.timeout) + return rejectChannel + + case <-r.done: + return rejectChannel + + case <-r.quit: + return rejectChannel + } } // NewRPCAcceptor creates and returns an instance of the RPCAcceptor. -func NewRPCAcceptor(closure func(*ChannelAcceptRequest) bool) *RPCAcceptor { +func NewRPCAcceptor(receive func() (*lnrpc.ChannelAcceptResponse, error), + send func(*lnrpc.ChannelAcceptRequest) error, timeout time.Duration, + params *chaincfg.Params, quit chan struct{}) *RPCAcceptor { + return &RPCAcceptor{ - acceptClosure: closure, + receive: receive, + send: send, + requests: make(chan *chanAcceptInfo), + timeout: timeout, + params: params, + done: make(chan struct{}), + quit: quit, + } +} + +// Run is the main loop for the RPC Acceptor. This function will block until +// it receives the signal that lnd is shutting down, or the rpc stream is +// cancelled by the client. +func (r *RPCAcceptor) Run() error { + // Wait for our goroutines to exit before we return. + defer r.wg.Wait() + + // Create a channel that responses from acceptors are sent into. + responses := make(chan lnrpc.ChannelAcceptResponse) + + // errChan is used by the receive loop to signal any errors that occur + // during reading from the stream. This is primarily used to shutdown + // the send loop in the case of an RPC client disconnecting. + errChan := make(chan error, 1) + + // Start a goroutine to receive responses from the channel acceptor. + // We expect the receive function to block, so it must be run in a + // goroutine (otherwise we could not send more than one channel accept + // request to the client). + r.wg.Add(1) + go func() { + r.receiveResponses(errChan, responses) + r.wg.Done() + }() + + return r.sendAcceptRequests(errChan, responses) +} + +// receiveResponses receives responses for our channel accept requests and +// dispatches them into the responses channel provided, sending any errors that +// occur into the error channel provided. +func (r *RPCAcceptor) receiveResponses(errChan chan error, + responses chan lnrpc.ChannelAcceptResponse) { + + for { + resp, err := r.receive() + if err != nil { + errChan <- err + return + } + + var pendingID [32]byte + copy(pendingID[:], resp.PendingChanId) + + openChanResp := lnrpc.ChannelAcceptResponse{ + Accept: resp.Accept, + PendingChanId: pendingID[:], + Error: resp.Error, + UpfrontShutdown: resp.UpfrontShutdown, + CsvDelay: resp.CsvDelay, + ReserveSat: resp.ReserveSat, + InFlightMaxMsat: resp.InFlightMaxMsat, + MaxHtlcCount: resp.MaxHtlcCount, + MinHtlcIn: resp.MinHtlcIn, + MinAcceptDepth: resp.MinAcceptDepth, + } + + // We have received a decision for one of our channel + // acceptor requests. + select { + case responses <- openChanResp: + + case <-r.done: + return + + case <-r.quit: + return + } + } +} + +// sendAcceptRequests handles channel acceptor requests sent to us by our +// Accept() function, dispatching them to our acceptor stream and coordinating +// return of responses to their callers. +func (r *RPCAcceptor) sendAcceptRequests(errChan chan error, + responses chan lnrpc.ChannelAcceptResponse) error { + + // Close the done channel to indicate that the acceptor is no longer + // listening and any in-progress requests should be terminated. + defer close(r.done) + + // Create a map of pending channel IDs to our original open channel + // request and a response channel. We keep the original chanel open + // message so that we can validate our response against it. + acceptRequests := make(map[[32]byte]*chanAcceptInfo) + + for { + select { + // Consume requests passed to us from our Accept() function and + // send them into our stream. + case newRequest := <-r.requests: + + req := newRequest.request + pendingChanID := req.OpenChanMsg.PendingChannelID + + acceptRequests[pendingChanID] = newRequest + + // A ChannelAcceptRequest has been received, send it to the client. + chanAcceptReq := &lnrpc.ChannelAcceptRequest{ + NodePubkey: req.Node.SerializeCompressed(), + ChainHash: req.OpenChanMsg.ChainHash[:], + PendingChanId: req.OpenChanMsg.PendingChannelID[:], + FundingAmt: uint64(req.OpenChanMsg.FundingAmount), + PushAmt: uint64(req.OpenChanMsg.PushAmount), + DustLimit: uint64(req.OpenChanMsg.DustLimit), + MaxValueInFlight: uint64(req.OpenChanMsg.MaxValueInFlight), + ChannelReserve: uint64(req.OpenChanMsg.ChannelReserve), + MinHtlc: uint64(req.OpenChanMsg.HtlcMinimum), + FeePerKw: uint64(req.OpenChanMsg.FeePerKiloWeight), + CsvDelay: uint32(req.OpenChanMsg.CsvDelay), + MaxAcceptedHtlcs: uint32(req.OpenChanMsg.MaxAcceptedHTLCs), + ChannelFlags: uint32(req.OpenChanMsg.ChannelFlags), + } + + if err := r.send(chanAcceptReq); err != nil { + return err + } + + // Process newly received responses from our channel acceptor, + // looking the original request up in our map of requests and + // dispatching the response. + case resp := <-responses: + // Look up the appropriate channel to send on given the + // pending ID. If a channel is found, send the response + // over it. + var pendingID [32]byte + copy(pendingID[:], resp.PendingChanId) + requestInfo, ok := acceptRequests[pendingID] + if !ok { + continue + } + + // Validate the response we have received. If it is not + // valid, we log our error and proceed to deliver the + // rejection. + accept, acceptErr, shutdown, err := r.validateAcceptorResponse( + requestInfo.request.OpenChanMsg.DustLimit, resp, + ) + if err != nil { + log.Errorf("Invalid acceptor response: %v", err) + } + + requestInfo.response <- NewChannelAcceptResponse( + accept, acceptErr, shutdown, + uint16(resp.CsvDelay), + uint16(resp.MaxHtlcCount), + uint16(resp.MinAcceptDepth), + btcutil.Amount(resp.ReserveSat), + lnwire.MilliSatoshi(resp.InFlightMaxMsat), + lnwire.MilliSatoshi(resp.MinHtlcIn), + ) + + // Delete the channel from the acceptRequests map. + delete(acceptRequests, pendingID) + + // If we failed to receive from our acceptor, we exit. + case err := <-errChan: + log.Errorf("Received an error: %v, shutting down", err) + return err + + // Exit if we are shutting down. + case <-r.quit: + return errShuttingDown + } + } +} + +// validateAcceptorResponse validates the response we get from the channel +// acceptor, returning a boolean indicating whether to accept the channel, an +// error to send to the peer, and any validation errors that occurred. +func (r *RPCAcceptor) validateAcceptorResponse(dustLimit btcutil.Amount, + req lnrpc.ChannelAcceptResponse) (bool, error, lnwire.DeliveryAddress, + error) { + + channelStr := hex.EncodeToString(req.PendingChanId) + + // Check that the max htlc count is within the BOLT 2 hard-limit of 483. + // The initiating side should fail values above this anyway, but we + // catch the invalid user input here. + if req.MaxHtlcCount > input.MaxHTLCNumber/2 { + log.Errorf("Max htlc count: %v for channel: %v is greater "+ + "than limit of: %v", req.MaxHtlcCount, channelStr, + input.MaxHTLCNumber/2) + + return false, errChannelRejected, nil, errMaxHtlcTooHigh + } + + // Ensure that the reserve that has been proposed, if it is set, is at + // least the dust limit that was proposed by the remote peer. This is + // required by BOLT 2. + reserveSat := btcutil.Amount(req.ReserveSat) + if reserveSat != 0 && reserveSat < dustLimit { + log.Errorf("Remote reserve: %v sat for channel: %v must be "+ + "at least equal to proposed dust limit: %v", + req.ReserveSat, channelStr, dustLimit) + + return false, errChannelRejected, nil, errInsufficientReserve + } + + // Attempt to parse the upfront shutdown address provided. + upfront, err := chancloser.ParseUpfrontShutdownAddress( + req.UpfrontShutdown, r.params, + ) + if err != nil { + log.Errorf("Could not parse upfront shutdown for "+ + "%v: %v", channelStr, err) + + return false, errChannelRejected, nil, errInvalidUpfrontShutdown + } + + // Check that the custom error provided is valid. + if len(req.Error) > maxErrorLength { + return false, errChannelRejected, nil, errCustomLength + } + + var haveCustomError = len(req.Error) != 0 + + switch { + // If accept is true, but we also have an error specified, we fail + // because this result is ambiguous. + case req.Accept && haveCustomError: + return false, errChannelRejected, nil, errAcceptWithError + + // If we accept without an error message, we can just return a nil + // error. + case req.Accept: + return true, nil, upfront, nil + + // If we reject the channel, and have a custom error, then we use it. + case haveCustomError: + return false, fmt.Errorf(req.Error), nil, nil + + // Otherwise, we have rejected the channel with no custom error, so we + // just use a generic error to fail the channel. + default: + return false, errChannelRejected, nil, nil } } diff --git a/chanacceptor/rpcacceptor_test.go b/chanacceptor/rpcacceptor_test.go new file mode 100644 index 00000000..d60180fa --- /dev/null +++ b/chanacceptor/rpcacceptor_test.go @@ -0,0 +1,139 @@ +package chanacceptor + +import ( + "errors" + "strings" + "testing" + + "github.com/btcsuite/btcd/chaincfg" + "github.com/btcsuite/btcutil" + "github.com/lightningnetwork/lnd/input" + "github.com/lightningnetwork/lnd/lnrpc" + "github.com/lightningnetwork/lnd/lnwallet/chancloser" + "github.com/lightningnetwork/lnd/lnwire" + "github.com/stretchr/testify/require" +) + +// TestValidateAcceptorResponse test validation of acceptor responses. +func TestValidateAcceptorResponse(t *testing.T) { + var ( + customError = errors.New("custom error") + validAddr = "bcrt1qwrmq9uca0t3dy9t9wtuq5tm4405r7tfzyqn9pp" + addr, _ = chancloser.ParseUpfrontShutdownAddress( + validAddr, &chaincfg.TestNet3Params, + ) + ) + + tests := []struct { + name string + dustLimit btcutil.Amount + response lnrpc.ChannelAcceptResponse + accept bool + acceptorErr error + error error + shutdown lnwire.DeliveryAddress + }{ + { + name: "accepted with error", + response: lnrpc.ChannelAcceptResponse{ + Accept: true, + Error: customError.Error(), + }, + accept: false, + acceptorErr: errChannelRejected, + error: errAcceptWithError, + }, + { + name: "custom error too long", + response: lnrpc.ChannelAcceptResponse{ + Accept: false, + Error: strings.Repeat(" ", maxErrorLength+1), + }, + accept: false, + acceptorErr: errChannelRejected, + error: errCustomLength, + }, + { + name: "accepted", + response: lnrpc.ChannelAcceptResponse{ + Accept: true, + UpfrontShutdown: validAddr, + }, + accept: true, + acceptorErr: nil, + error: nil, + shutdown: addr, + }, + { + name: "rejected with error", + response: lnrpc.ChannelAcceptResponse{ + Accept: false, + Error: customError.Error(), + }, + accept: false, + acceptorErr: customError, + error: nil, + }, + { + name: "rejected with no error", + response: lnrpc.ChannelAcceptResponse{ + Accept: false, + }, + accept: false, + acceptorErr: errChannelRejected, + error: nil, + }, + { + name: "invalid upfront shutdown", + response: lnrpc.ChannelAcceptResponse{ + Accept: true, + UpfrontShutdown: "invalid addr", + }, + accept: false, + acceptorErr: errChannelRejected, + error: errInvalidUpfrontShutdown, + }, + { + name: "reserve too low", + dustLimit: 100, + response: lnrpc.ChannelAcceptResponse{ + Accept: true, + ReserveSat: 10, + }, + accept: false, + acceptorErr: errChannelRejected, + error: errInsufficientReserve, + }, + { + name: "max htlcs too high", + dustLimit: 100, + response: lnrpc.ChannelAcceptResponse{ + Accept: true, + MaxHtlcCount: 1 + input.MaxHTLCNumber/2, + }, + accept: false, + acceptorErr: errChannelRejected, + error: errMaxHtlcTooHigh, + }, + } + + for _, test := range tests { + test := test + + t.Run(test.name, func(t *testing.T) { + // Create an acceptor, everything can be nil because + // we just need the params. + acceptor := NewRPCAcceptor( + nil, nil, 0, &chaincfg.TestNet3Params, nil, + ) + + accept, acceptErr, shutdown, err := acceptor.validateAcceptorResponse( + test.dustLimit, test.response, + ) + require.Equal(t, test.accept, accept) + require.Equal(t, test.acceptorErr, acceptErr) + require.Equal(t, test.error, err) + require.Equal(t, test.shutdown, shutdown) + }) + } +} diff --git a/fundingmanager.go b/fundingmanager.go index 350e5a4a..46338af3 100644 --- a/fundingmanager.go +++ b/fundingmanager.go @@ -746,6 +746,8 @@ func (f *fundingManager) failFundingFlow(peer lnpeer.Peer, tempChanID [32]byte, msg = lnwire.ErrorData(e.Error()) case lnwire.FundingError: msg = lnwire.ErrorData(e.Error()) + case chanacceptor.ChanAcceptError: + msg = lnwire.ErrorData(e.Error()) // For all other error types we just send a generic error. default: @@ -1282,10 +1284,13 @@ func (f *fundingManager) handleFundingOpen(peer lnpeer.Peer, OpenChanMsg: msg, } - if !f.cfg.OpenChannelPredicate.Accept(chanReq) { + // Query our channel acceptor to determine whether we should reject + // the channel. + acceptorResp := f.cfg.OpenChannelPredicate.Accept(chanReq) + if acceptorResp.RejectChannel() { f.failFundingFlow( peer, msg.PendingChannelID, - fmt.Errorf("open channel request rejected"), + acceptorResp.ChanAcceptError, ) return } @@ -1335,8 +1340,12 @@ func (f *fundingManager) handleFundingOpen(peer lnpeer.Peer, // that we require before both of us consider the channel open. We'll // use our mapping to derive the proper number of confirmations based on // the amount of the channel, and also if any funds are being pushed to - // us. + // us. If a depth value was set by our channel acceptor, we will use + // that value instead. numConfsReq := f.cfg.NumRequiredConfs(msg.FundingAmount, msg.PushAmount) + if acceptorResp.MinAcceptDepth != 0 { + numConfsReq = acceptorResp.MinAcceptDepth + } reservation.SetNumConfsRequired(numConfsReq) // We'll also validate and apply all the constraints the initiating @@ -1360,10 +1369,10 @@ func (f *fundingManager) handleFundingOpen(peer lnpeer.Peer, // Check whether the peer supports upfront shutdown, and get a new wallet // address if our node is configured to set shutdown addresses by default. - // A nil address is set in place of user input, because this channel open - // was not initiated by the user. + // We use the upfront shutdown script provided by our channel acceptor + // (if any) in lieu of user input. shutdown, err := getUpfrontShutdownScript( - f.cfg.EnableUpfrontShutdown, peer, nil, + f.cfg.EnableUpfrontShutdown, peer, acceptorResp.UpfrontShutdown, func() (lnwire.DeliveryAddress, error) { addr, err := f.cfg.Wallet.NewAddress(lnwallet.WitnessPubKey, false) if err != nil { @@ -1386,12 +1395,34 @@ func (f *fundingManager) handleFundingOpen(peer lnpeer.Peer, msg.PendingChannelID, amt, msg.PushAmount, commitType, msg.UpfrontShutdownScript) - // Generate our required constraints for the remote party. + // Generate our required constraints for the remote party, using the + // values provided by the channel acceptor if they are non-zero. remoteCsvDelay := f.cfg.RequiredRemoteDelay(amt) + if acceptorResp.CSVDelay != 0 { + remoteCsvDelay = acceptorResp.CSVDelay + } + chanReserve := f.cfg.RequiredRemoteChanReserve(amt, msg.DustLimit) + if acceptorResp.Reserve != 0 { + chanReserve = acceptorResp.Reserve + } + remoteMaxValue := f.cfg.RequiredRemoteMaxValue(amt) + if acceptorResp.InFlightTotal != 0 { + remoteMaxValue = acceptorResp.InFlightTotal + } + maxHtlcs := f.cfg.RequiredRemoteMaxHTLCs(amt) + if acceptorResp.HtlcLimit != 0 { + maxHtlcs = acceptorResp.HtlcLimit + } + + // Default to our default minimum hltc value, replacing it with the + // channel acceptor's value if it is set. minHtlc := f.cfg.DefaultMinHtlcIn + if acceptorResp.MinHtlcIn != 0 { + minHtlc = acceptorResp.MinHtlcIn + } // Once the reservation has been created successfully, we add it to // this peer's map of pending reservations to track this particular diff --git a/lnrpc/rpc.pb.go b/lnrpc/rpc.pb.go index 940d0802..1ff529cd 100644 --- a/lnrpc/rpc.pb.go +++ b/lnrpc/rpc.pb.go @@ -1652,7 +1652,43 @@ type ChannelAcceptResponse struct { // Whether or not the client accepts the channel. Accept bool `protobuf:"varint,1,opt,name=accept,proto3" json:"accept,omitempty"` // The pending channel id to which this response applies. - PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + PendingChanId []byte `protobuf:"bytes,2,opt,name=pending_chan_id,json=pendingChanId,proto3" json:"pending_chan_id,omitempty"` + // + //An optional error to send the initiating party to indicate why the channel + //was rejected. This field *should not* contain sensitive information, it will + //be sent to the initiating party. This field should only be set if accept is + //false, the channel will be rejected if an error is set with accept=true + //because the meaning of this response is ambiguous. Limited to 500 + //characters. + Error string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"` + // + //The upfront shutdown address to use if the initiating peer supports option + //upfront shutdown script (see ListPeers for the features supported). Note + //that the channel open will fail if this value is set for a peer that does + //not support this feature bit. + UpfrontShutdown string `protobuf:"bytes,4,opt,name=upfront_shutdown,json=upfrontShutdown,proto3" json:"upfront_shutdown,omitempty"` + // + //The csv delay (in blocks) that we require for the remote party. + CsvDelay uint32 `protobuf:"varint,5,opt,name=csv_delay,json=csvDelay,proto3" json:"csv_delay,omitempty"` + // + //The reserve amount in satoshis that we require the remote peer to adhere to. + //We require that the remote peer always have some reserve amount allocated to + //them so that there is always a disincentive to broadcast old state (if they + //hold 0 sats on their side of the channel, there is nothing to lose). + ReserveSat uint64 `protobuf:"varint,6,opt,name=reserve_sat,json=reserveSat,proto3" json:"reserve_sat,omitempty"` + // + //The maximum amount of funds in millisatoshis that we allow the remote peer + //to have in outstanding htlcs. + InFlightMaxMsat uint64 `protobuf:"varint,7,opt,name=in_flight_max_msat,json=inFlightMaxMsat,proto3" json:"in_flight_max_msat,omitempty"` + // + //The maximum number of htlcs that the remote peer can offer us. + MaxHtlcCount uint32 `protobuf:"varint,8,opt,name=max_htlc_count,json=maxHtlcCount,proto3" json:"max_htlc_count,omitempty"` + // + //The minimum value in millisatoshis for incoming htlcs on the channel. + MinHtlcIn uint64 `protobuf:"varint,9,opt,name=min_htlc_in,json=minHtlcIn,proto3" json:"min_htlc_in,omitempty"` + // + //The number of confirmations we require before we consider the channel open. + MinAcceptDepth uint32 `protobuf:"varint,10,opt,name=min_accept_depth,json=minAcceptDepth,proto3" json:"min_accept_depth,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -1697,6 +1733,62 @@ func (m *ChannelAcceptResponse) GetPendingChanId() []byte { return nil } +func (m *ChannelAcceptResponse) GetError() string { + if m != nil { + return m.Error + } + return "" +} + +func (m *ChannelAcceptResponse) GetUpfrontShutdown() string { + if m != nil { + return m.UpfrontShutdown + } + return "" +} + +func (m *ChannelAcceptResponse) GetCsvDelay() uint32 { + if m != nil { + return m.CsvDelay + } + return 0 +} + +func (m *ChannelAcceptResponse) GetReserveSat() uint64 { + if m != nil { + return m.ReserveSat + } + return 0 +} + +func (m *ChannelAcceptResponse) GetInFlightMaxMsat() uint64 { + if m != nil { + return m.InFlightMaxMsat + } + return 0 +} + +func (m *ChannelAcceptResponse) GetMaxHtlcCount() uint32 { + if m != nil { + return m.MaxHtlcCount + } + return 0 +} + +func (m *ChannelAcceptResponse) GetMinHtlcIn() uint64 { + if m != nil { + return m.MinHtlcIn + } + return 0 +} + +func (m *ChannelAcceptResponse) GetMinAcceptDepth() uint32 { + if m != nil { + return m.MinAcceptDepth + } + return 0 +} + type ChannelPoint struct { // Types that are valid to be assigned to FundingTxid: // *ChannelPoint_FundingTxidBytes @@ -12689,770 +12781,777 @@ func init() { func init() { proto.RegisterFile("rpc.proto", fileDescriptor_77a6da22d6a3feb1) } var fileDescriptor_77a6da22d6a3feb1 = []byte{ - // 12197 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0xbd, 0x5b, 0x6c, 0x23, 0xc9, - 0x7a, 0x18, 0x3c, 0xbc, 0x89, 0xe4, 0x47, 0x52, 0x6a, 0x95, 0x6e, 0x1c, 0xcd, 0xce, 0xce, 0x6c, - 0xef, 0x9e, 0xdd, 0x39, 0xb3, 0xbb, 0xda, 0xd9, 0xd9, 0x9d, 0xbd, 0x9c, 0xf9, 0x7d, 0xce, 0xa1, - 0x24, 0x6a, 0xc4, 0x33, 0x12, 0xa9, 0xd3, 0xa4, 0x76, 0xbd, 0x86, 0xed, 0x76, 0x8b, 0x2c, 0x49, - 0xfd, 0x0f, 0xd9, 0xcd, 0xed, 0x6e, 0x6a, 0xa4, 0x13, 0x04, 0xf0, 0x83, 0xe3, 0x04, 0x86, 0x11, - 0x20, 0x40, 0x1c, 0xe4, 0x66, 0xe4, 0x86, 0x24, 0x6f, 0x46, 0x00, 0x3b, 0x79, 0xca, 0x5b, 0x80, - 0x18, 0x01, 0x72, 0x41, 0x10, 0x07, 0xb9, 0xc0, 0x30, 0x10, 0x20, 0x71, 0x1e, 0x02, 0x04, 0x06, - 0xf2, 0x9a, 0x00, 0x41, 0x7d, 0x75, 0xe9, 0xea, 0x66, 0x6b, 0x66, 0xf6, 0x78, 0x73, 0x5e, 0x24, - 0xd6, 0x57, 0x5f, 0xdd, 0xab, 0xbe, 0xfa, 0x6e, 0xf5, 0x35, 0x54, 0x83, 0xe9, 0x70, 0x6b, 0x1a, - 0xf8, 0x91, 0x4f, 0x4a, 0x63, 0x2f, 0x98, 0x0e, 0xcd, 0x3f, 0xce, 0x41, 0xf1, 0x38, 0xba, 0xf4, - 0xc9, 0x23, 0xa8, 0x3b, 0xa3, 0x51, 0x40, 0xc3, 0xd0, 0x8e, 0xae, 0xa6, 0xb4, 0x99, 0xbb, 0x9b, - 0xbb, 0xb7, 0xf8, 0x90, 0x6c, 0x21, 0xda, 0x56, 0x8b, 0x67, 0x0d, 0xae, 0xa6, 0xd4, 0xaa, 0x39, - 0x71, 0x82, 0x34, 0xa1, 0x2c, 0x92, 0xcd, 0xfc, 0xdd, 0xdc, 0xbd, 0xaa, 0x25, 0x93, 0xe4, 0x36, - 0x80, 0x33, 0xf1, 0x67, 0x5e, 0x64, 0x87, 0x4e, 0xd4, 0x2c, 0xdc, 0xcd, 0xdd, 0x2b, 0x58, 0x55, - 0x0e, 0xe9, 0x3b, 0x11, 0xb9, 0x05, 0xd5, 0xe9, 0x33, 0x3b, 0x1c, 0x06, 0xee, 0x34, 0x6a, 0x16, - 0xb1, 0x68, 0x65, 0xfa, 0xac, 0x8f, 0x69, 0xf2, 0x2e, 0x54, 0xfc, 0x59, 0x34, 0xf5, 0x5d, 0x2f, - 0x6a, 0x96, 0xee, 0xe6, 0xee, 0xd5, 0x1e, 0x2e, 0x89, 0x8e, 0xf4, 0x66, 0xd1, 0x11, 0x03, 0x5b, - 0x0a, 0x81, 0xbc, 0x05, 0x8d, 0xa1, 0xef, 0x9d, 0xba, 0xc1, 0xc4, 0x89, 0x5c, 0xdf, 0x0b, 0x9b, - 0x0b, 0xd8, 0x56, 0x12, 0x68, 0xfe, 0xf3, 0x3c, 0xd4, 0x06, 0x81, 0xe3, 0x85, 0xce, 0x90, 0x01, - 0xc8, 0x06, 0x94, 0xa3, 0x4b, 0xfb, 0xdc, 0x09, 0xcf, 0x71, 0xa8, 0x55, 0x6b, 0x21, 0xba, 0xdc, - 0x77, 0xc2, 0x73, 0xb2, 0x0e, 0x0b, 0xbc, 0x97, 0x38, 0xa0, 0x82, 0x25, 0x52, 0xe4, 0x5d, 0x58, - 0xf6, 0x66, 0x13, 0x3b, 0xd9, 0x14, 0x1b, 0x56, 0xc9, 0x32, 0xbc, 0xd9, 0x64, 0x47, 0x87, 0xb3, - 0xc1, 0x9f, 0x8c, 0xfd, 0xe1, 0x33, 0xde, 0x00, 0x1f, 0x5e, 0x15, 0x21, 0xd8, 0xc6, 0x1b, 0x50, - 0x17, 0xd9, 0xd4, 0x3d, 0x3b, 0xe7, 0x63, 0x2c, 0x59, 0x35, 0x8e, 0x80, 0x20, 0x56, 0x43, 0xe4, - 0x4e, 0xa8, 0x1d, 0x46, 0xce, 0x64, 0x2a, 0x86, 0x54, 0x65, 0x90, 0x3e, 0x03, 0x60, 0xb6, 0x1f, - 0x39, 0x63, 0xfb, 0x94, 0xd2, 0xb0, 0x59, 0x16, 0xd9, 0x0c, 0xb2, 0x47, 0x69, 0x48, 0xbe, 0x03, - 0x8b, 0x23, 0x1a, 0x46, 0xb6, 0x58, 0x0c, 0x1a, 0x36, 0x2b, 0x77, 0x0b, 0xf7, 0xaa, 0x56, 0x83, - 0x41, 0x5b, 0x12, 0x48, 0x5e, 0x03, 0x08, 0x9c, 0xe7, 0x36, 0x9b, 0x08, 0x7a, 0xd9, 0xac, 0xf2, - 0x55, 0x08, 0x9c, 0xe7, 0x83, 0xcb, 0x7d, 0x7a, 0x49, 0x56, 0xa1, 0x34, 0x76, 0x4e, 0xe8, 0xb8, - 0x09, 0x98, 0xc1, 0x13, 0xe6, 0x2f, 0xc0, 0xfa, 0x13, 0x1a, 0x69, 0x53, 0x19, 0x5a, 0xf4, 0xeb, - 0x19, 0x0d, 0x23, 0x36, 0xaa, 0x30, 0x72, 0x82, 0x48, 0x8e, 0x2a, 0xc7, 0x47, 0x85, 0xb0, 0x78, - 0x54, 0xd4, 0x1b, 0x49, 0x84, 0x3c, 0x22, 0x54, 0xa9, 0x37, 0xe2, 0xd9, 0xe6, 0x01, 0x10, 0xad, - 0xe2, 0x5d, 0x1a, 0x39, 0xee, 0x38, 0x24, 0x9f, 0x40, 0x3d, 0xd2, 0x9a, 0x6b, 0xe6, 0xee, 0x16, - 0xee, 0xd5, 0xd4, 0xd6, 0xd4, 0x0a, 0x58, 0x09, 0x3c, 0xf3, 0x1c, 0x2a, 0x7b, 0x94, 0x1e, 0xb8, - 0x13, 0x37, 0x22, 0xeb, 0x50, 0x3a, 0x75, 0x2f, 0xe9, 0x08, 0x3b, 0x55, 0xd8, 0xbf, 0x61, 0xf1, - 0x24, 0xb9, 0x03, 0x80, 0x3f, 0xec, 0x89, 0xda, 0xa5, 0xfb, 0x37, 0xac, 0x2a, 0xc2, 0x0e, 0x43, - 0x27, 0x22, 0x9b, 0x50, 0x9e, 0xd2, 0x60, 0x48, 0xe5, 0x7e, 0xd8, 0xbf, 0x61, 0x49, 0xc0, 0x76, - 0x19, 0x4a, 0x63, 0x56, 0xbb, 0xf9, 0xfb, 0x25, 0xa8, 0xf5, 0xa9, 0x37, 0x92, 0x33, 0x41, 0xa0, - 0xc8, 0x26, 0x1a, 0x1b, 0xab, 0x5b, 0xf8, 0x9b, 0xbc, 0x09, 0x35, 0x5c, 0x92, 0x30, 0x0a, 0x5c, - 0xef, 0x8c, 0x9f, 0x96, 0xed, 0x7c, 0x33, 0x67, 0x01, 0x03, 0xf7, 0x11, 0x4a, 0x0c, 0x28, 0x38, - 0x13, 0x79, 0x5a, 0xd8, 0x4f, 0x72, 0x13, 0x2a, 0xce, 0x24, 0xe2, 0xdd, 0xab, 0x23, 0xb8, 0xec, - 0x4c, 0x22, 0xec, 0xda, 0x1b, 0x50, 0x9f, 0x3a, 0x57, 0x13, 0xea, 0x45, 0xf1, 0x36, 0xab, 0x5b, - 0x35, 0x01, 0xc3, 0x8d, 0xf6, 0x10, 0x56, 0x74, 0x14, 0xd9, 0x78, 0x49, 0x35, 0xbe, 0xac, 0x61, - 0x8b, 0x3e, 0xbc, 0x03, 0x4b, 0xb2, 0x4c, 0xc0, 0xc7, 0x83, 0xdb, 0xaf, 0x6a, 0x2d, 0x0a, 0xb0, - 0x1c, 0xe5, 0x3d, 0x30, 0x4e, 0x5d, 0xcf, 0x19, 0xdb, 0xc3, 0x71, 0x74, 0x61, 0x8f, 0xe8, 0x38, - 0x72, 0x70, 0x27, 0x96, 0xac, 0x45, 0x84, 0xef, 0x8c, 0xa3, 0x8b, 0x5d, 0x06, 0x25, 0xef, 0x41, - 0xf5, 0x94, 0x52, 0x1b, 0x27, 0xab, 0x59, 0x49, 0x1c, 0x68, 0xb9, 0x42, 0x56, 0xe5, 0x54, 0xae, - 0xd5, 0x7b, 0x60, 0xf8, 0xb3, 0xe8, 0xcc, 0x77, 0xbd, 0x33, 0x7b, 0x78, 0xee, 0x78, 0xb6, 0x3b, - 0xc2, 0xbd, 0x59, 0xdc, 0xce, 0x3f, 0xc8, 0x59, 0x8b, 0x32, 0x6f, 0xe7, 0xdc, 0xf1, 0x3a, 0x23, - 0xf2, 0x36, 0x2c, 0x8d, 0x9d, 0x30, 0xb2, 0xcf, 0xfd, 0xa9, 0x3d, 0x9d, 0x9d, 0x3c, 0xa3, 0x57, - 0xcd, 0x06, 0x4e, 0x44, 0x83, 0x81, 0xf7, 0xfd, 0xe9, 0x11, 0x02, 0xd9, 0xd6, 0xc3, 0x7e, 0xf2, - 0x4e, 0xb0, 0x2d, 0xdd, 0xb0, 0xaa, 0x0c, 0xc2, 0x1b, 0xfd, 0x0a, 0x56, 0x70, 0x79, 0x86, 0xb3, - 0x30, 0xf2, 0x27, 0x76, 0x40, 0x87, 0x7e, 0x30, 0x0a, 0x9b, 0x35, 0xdc, 0x6b, 0xdf, 0x15, 0x9d, - 0xd5, 0xd6, 0x78, 0x6b, 0x97, 0x86, 0xd1, 0x0e, 0x22, 0x5b, 0x1c, 0xb7, 0xed, 0x45, 0xc1, 0x95, - 0xb5, 0x3c, 0x4a, 0xc3, 0xc9, 0x7b, 0x40, 0x9c, 0xf1, 0xd8, 0x7f, 0x6e, 0x87, 0x74, 0x7c, 0x6a, - 0x8b, 0x49, 0x6c, 0x2e, 0xde, 0xcd, 0xdd, 0xab, 0x58, 0x06, 0xe6, 0xf4, 0xe9, 0xf8, 0xf4, 0x88, - 0xc3, 0xc9, 0x27, 0x80, 0x87, 0xd4, 0x3e, 0xa5, 0x4e, 0x34, 0x0b, 0x68, 0xd8, 0x5c, 0xba, 0x5b, - 0xb8, 0xb7, 0xf8, 0x70, 0x59, 0xcd, 0x17, 0x82, 0xb7, 0xdd, 0xc8, 0xaa, 0x33, 0x3c, 0x91, 0x0e, - 0x37, 0x77, 0x61, 0x3d, 0xbb, 0x4b, 0x6c, 0x53, 0xb1, 0x59, 0x61, 0x9b, 0xb1, 0x68, 0xb1, 0x9f, - 0xec, 0x64, 0x5f, 0x38, 0xe3, 0x19, 0xc5, 0x5d, 0x58, 0xb7, 0x78, 0xe2, 0x7b, 0xf9, 0xcf, 0x72, - 0xe6, 0xef, 0xe5, 0xa0, 0xce, 0x47, 0x19, 0x4e, 0x7d, 0x2f, 0xa4, 0xe4, 0x4d, 0x68, 0xc8, 0xdd, - 0x40, 0x83, 0xc0, 0x0f, 0x04, 0xb5, 0x94, 0x3b, 0xaf, 0xcd, 0x60, 0xe4, 0xbb, 0x60, 0x48, 0xa4, - 0x69, 0x40, 0xdd, 0x89, 0x73, 0x26, 0xab, 0x96, 0x5b, 0xe9, 0x48, 0x80, 0xc9, 0x87, 0x71, 0x7d, - 0x81, 0x3f, 0x8b, 0x28, 0xee, 0xf5, 0xda, 0xc3, 0xba, 0x18, 0x9e, 0xc5, 0x60, 0xaa, 0x76, 0x4c, - 0xbd, 0xc2, 0x3e, 0x37, 0x7f, 0x2b, 0x07, 0x84, 0x75, 0x7b, 0xe0, 0xf3, 0x0a, 0x62, 0x8a, 0x94, - 0x28, 0x99, 0x7b, 0xe5, 0x13, 0x92, 0x7f, 0xd1, 0x09, 0x31, 0xa1, 0xc4, 0xfb, 0x5e, 0xcc, 0xe8, - 0x3b, 0xcf, 0xfa, 0x51, 0xb1, 0x52, 0x30, 0x8a, 0xe6, 0x7f, 0x2e, 0xc0, 0x2a, 0xdb, 0xa7, 0x1e, - 0x1d, 0xb7, 0x86, 0x43, 0x3a, 0x55, 0x67, 0xe7, 0x0e, 0xd4, 0x3c, 0x7f, 0x44, 0xe5, 0x8e, 0xe5, - 0x1d, 0x03, 0x06, 0xd2, 0xb6, 0xeb, 0xb9, 0xe3, 0x7a, 0xbc, 0xe3, 0x7c, 0x32, 0xab, 0x08, 0xc1, - 0x6e, 0xbf, 0x0d, 0x4b, 0x53, 0xea, 0x8d, 0xf4, 0x23, 0x52, 0xe0, 0xbb, 0x5e, 0x80, 0xc5, 0xe9, - 0xb8, 0x03, 0xb5, 0xd3, 0x19, 0xc7, 0x63, 0x84, 0xa5, 0x88, 0x7b, 0x00, 0x04, 0xa8, 0xc5, 0xe9, - 0xcb, 0x74, 0x16, 0x9e, 0x63, 0x6e, 0x09, 0x73, 0xcb, 0x2c, 0xcd, 0xb2, 0x6e, 0x03, 0x8c, 0x66, - 0x61, 0x24, 0x4e, 0xcc, 0x02, 0x66, 0x56, 0x19, 0x84, 0x9f, 0x98, 0xf7, 0x61, 0x65, 0xe2, 0x5c, - 0xda, 0xb8, 0x77, 0x6c, 0xd7, 0xb3, 0x4f, 0xc7, 0x48, 0xd4, 0xcb, 0x88, 0x67, 0x4c, 0x9c, 0xcb, - 0x2f, 0x58, 0x4e, 0xc7, 0xdb, 0x43, 0x38, 0x23, 0x2b, 0x43, 0x3e, 0x13, 0x76, 0x40, 0x43, 0x1a, - 0x5c, 0x50, 0xa4, 0x04, 0x45, 0x6b, 0x51, 0x80, 0x2d, 0x0e, 0x65, 0x3d, 0x9a, 0xb0, 0x71, 0x47, - 0xe3, 0x21, 0x3f, 0xf6, 0x56, 0x79, 0xe2, 0x7a, 0xfb, 0xd1, 0x78, 0xc8, 0xee, 0x2b, 0x46, 0x47, - 0xa6, 0x34, 0xb0, 0x9f, 0x3d, 0xc7, 0x33, 0x5c, 0x44, 0xba, 0x71, 0x44, 0x83, 0xa7, 0xcf, 0x19, - 0x4b, 0x31, 0x0c, 0x91, 0x10, 0x39, 0x57, 0xcd, 0x1a, 0x1e, 0xf0, 0xca, 0x30, 0x64, 0x24, 0xc8, - 0xb9, 0x62, 0x87, 0x90, 0xf5, 0xd6, 0xc1, 0x55, 0xa0, 0x23, 0xac, 0x3e, 0x44, 0x8a, 0xda, 0xc0, - 0xce, 0xb6, 0x44, 0x06, 0x6b, 0x27, 0x64, 0xbb, 0x5e, 0x76, 0xf6, 0x74, 0xec, 0x9c, 0x85, 0x48, - 0x52, 0x1a, 0x56, 0x5d, 0x00, 0xf7, 0x18, 0xcc, 0xfc, 0x12, 0xd6, 0x52, 0x6b, 0x2b, 0xce, 0x0c, - 0x63, 0x21, 0x10, 0x82, 0xeb, 0x5a, 0xb1, 0x44, 0x2a, 0x6b, 0xd1, 0xf2, 0x19, 0x8b, 0x66, 0xfe, - 0x76, 0x0e, 0xea, 0xa2, 0x66, 0x64, 0x76, 0xc8, 0x16, 0x10, 0xb9, 0x8a, 0xd1, 0xa5, 0x3b, 0xb2, - 0x4f, 0xae, 0x22, 0x1a, 0xf2, 0x4d, 0xb3, 0x7f, 0xc3, 0x32, 0x44, 0xde, 0xe0, 0xd2, 0x1d, 0x6d, - 0xb3, 0x1c, 0x72, 0x1f, 0x8c, 0x04, 0x7e, 0x18, 0x05, 0x7c, 0x47, 0xef, 0xdf, 0xb0, 0x16, 0x35, - 0xec, 0x7e, 0x14, 0xb0, 0x33, 0xc2, 0x58, 0xa9, 0x59, 0x64, 0xbb, 0xde, 0x88, 0x5e, 0xe2, 0x36, - 0x6a, 0x58, 0x35, 0x0e, 0xeb, 0x30, 0xd0, 0xf6, 0x22, 0xd4, 0xf5, 0xea, 0xcc, 0x33, 0xa8, 0x48, - 0x3e, 0x0c, 0x19, 0x91, 0x54, 0x97, 0xac, 0x6a, 0xa4, 0x7a, 0x72, 0x13, 0x2a, 0xc9, 0x1e, 0x58, - 0xe5, 0xe8, 0x95, 0x1b, 0x36, 0xbf, 0x0f, 0xc6, 0x01, 0xdb, 0x3c, 0x1e, 0xdb, 0xac, 0x82, 0xaf, - 0x5c, 0x87, 0x05, 0xed, 0xd0, 0x54, 0x2d, 0x91, 0x62, 0x77, 0xee, 0xb9, 0x1f, 0x46, 0xa2, 0x15, - 0xfc, 0x6d, 0xfe, 0x7e, 0x0e, 0x48, 0x3b, 0x8c, 0xdc, 0x89, 0x13, 0xd1, 0x3d, 0xaa, 0xc8, 0x42, - 0x0f, 0xea, 0xac, 0xb6, 0x81, 0xdf, 0xe2, 0x8c, 0x1e, 0x67, 0x28, 0xde, 0x15, 0xc7, 0x78, 0xbe, - 0xc0, 0x96, 0x8e, 0xcd, 0xc9, 0x7c, 0xa2, 0x02, 0x76, 0xca, 0x22, 0x27, 0x38, 0xa3, 0x11, 0xb2, - 0x87, 0x82, 0xaf, 0x01, 0x0e, 0x62, 0x8c, 0xe1, 0xe6, 0x0f, 0x60, 0x79, 0xae, 0x0e, 0x9d, 0x2e, - 0x57, 0x33, 0xe8, 0x72, 0x41, 0xa7, 0xcb, 0x36, 0xac, 0x24, 0xfa, 0x25, 0x76, 0xda, 0x06, 0x94, - 0xd9, 0x81, 0x60, 0xcc, 0x41, 0x8e, 0x73, 0xab, 0xa7, 0x94, 0x32, 0xf6, 0xfa, 0x03, 0x58, 0x3d, - 0xa5, 0x34, 0x70, 0x22, 0xcc, 0xc4, 0x13, 0xc3, 0x56, 0x48, 0x54, 0xbc, 0x2c, 0xf2, 0xfa, 0x4e, - 0x74, 0x44, 0x03, 0xb6, 0x52, 0xe6, 0x3f, 0xcb, 0xc3, 0x12, 0xa3, 0xa0, 0x87, 0x8e, 0x77, 0x25, - 0xe7, 0xe9, 0x20, 0x73, 0x9e, 0xee, 0x69, 0x97, 0xa1, 0x86, 0xfd, 0x4d, 0x27, 0xa9, 0x90, 0x9e, - 0x24, 0x72, 0x17, 0xea, 0x89, 0xbe, 0x96, 0xb0, 0xaf, 0x10, 0xaa, 0x4e, 0xc6, 0x1c, 0xe9, 0x82, - 0xc6, 0x91, 0xb2, 0x73, 0xcf, 0x08, 0x06, 0xab, 0x35, 0x14, 0x0c, 0x08, 0xa3, 0x20, 0xac, 0xce, - 0x90, 0xb1, 0xed, 0x21, 0x3b, 0x5d, 0xf6, 0xcc, 0x13, 0xac, 0x3b, 0x1d, 0x21, 0xe1, 0xa9, 0x58, - 0x06, 0x66, 0x1c, 0xc7, 0xf0, 0x3f, 0xfd, 0x32, 0xbd, 0x0d, 0x46, 0x3c, 0x2d, 0x62, 0x8d, 0x08, - 0x14, 0xd9, 0x96, 0x17, 0x15, 0xe0, 0x6f, 0xf3, 0x7f, 0xe7, 0x38, 0xe2, 0x8e, 0xef, 0xc6, 0xfc, - 0x33, 0x81, 0x22, 0xe3, 0xd7, 0x25, 0x22, 0xfb, 0x7d, 0xad, 0x34, 0xf2, 0x2d, 0x4c, 0xe6, 0x4d, - 0xa8, 0x84, 0x6c, 0x62, 0x9c, 0x31, 0x9f, 0xcf, 0x8a, 0x55, 0x66, 0xe9, 0xd6, 0x78, 0x1c, 0xcf, - 0x73, 0xf9, 0xda, 0x79, 0xae, 0xbc, 0xca, 0x3c, 0x57, 0xb3, 0xe7, 0xd9, 0x7c, 0x07, 0x96, 0xb5, - 0xd1, 0xbf, 0x60, 0x9e, 0xba, 0x40, 0x0e, 0xdc, 0x30, 0x3a, 0xf6, 0x58, 0x15, 0xea, 0xf2, 0x4c, - 0x74, 0x24, 0x97, 0xea, 0x08, 0xcb, 0x74, 0x2e, 0x45, 0x66, 0x5e, 0x64, 0x3a, 0x97, 0x98, 0x69, - 0x7e, 0x06, 0x2b, 0x89, 0xfa, 0x44, 0xd3, 0x6f, 0x40, 0x69, 0x16, 0x5d, 0xfa, 0x52, 0xb4, 0xa8, - 0x89, 0x1d, 0xce, 0x04, 0x63, 0x8b, 0xe7, 0x98, 0x8f, 0x61, 0xb9, 0x4b, 0x9f, 0x0b, 0x22, 0x24, - 0x3b, 0xf2, 0x36, 0x14, 0x5f, 0x22, 0x2c, 0x63, 0xbe, 0xb9, 0x05, 0x44, 0x2f, 0x2c, 0x5a, 0xd5, - 0x64, 0xe7, 0x5c, 0x42, 0x76, 0x36, 0xdf, 0x06, 0xd2, 0x77, 0xcf, 0xbc, 0x43, 0x1a, 0x86, 0xce, - 0x99, 0x22, 0x5b, 0x06, 0x14, 0x26, 0xe1, 0x99, 0xa0, 0xb1, 0xec, 0xa7, 0xf9, 0x11, 0xac, 0x24, - 0xf0, 0x44, 0xc5, 0xaf, 0x41, 0x35, 0x74, 0xcf, 0x3c, 0x64, 0x0c, 0x45, 0xd5, 0x31, 0xc0, 0xdc, - 0x83, 0xd5, 0x2f, 0x68, 0xe0, 0x9e, 0x5e, 0xbd, 0xac, 0xfa, 0x64, 0x3d, 0xf9, 0x74, 0x3d, 0x6d, - 0x58, 0x4b, 0xd5, 0x23, 0x9a, 0xe7, 0xc7, 0x43, 0xac, 0x64, 0xc5, 0xe2, 0x09, 0x8d, 0x6e, 0xe7, - 0x75, 0xba, 0x6d, 0xfa, 0x40, 0x76, 0x7c, 0xcf, 0xa3, 0xc3, 0xe8, 0x88, 0xd2, 0x40, 0x76, 0xe6, - 0x5d, 0xed, 0x2c, 0xd4, 0x1e, 0x6e, 0x88, 0x99, 0x4d, 0x5f, 0x06, 0xe2, 0x90, 0x10, 0x28, 0x4e, - 0x69, 0x30, 0xc1, 0x8a, 0x2b, 0x16, 0xfe, 0x66, 0x93, 0xcb, 0xa4, 0x65, 0x7f, 0xc6, 0xa5, 0xa9, - 0xa2, 0x25, 0x93, 0xe6, 0x1a, 0xac, 0x24, 0x1a, 0xe4, 0xbd, 0x36, 0x1f, 0xc0, 0xda, 0xae, 0x1b, - 0x0e, 0xe7, 0xbb, 0xb2, 0x01, 0xe5, 0xe9, 0xec, 0xc4, 0x4e, 0xde, 0x38, 0x4f, 0xe9, 0x95, 0xd9, - 0x84, 0xf5, 0x74, 0x09, 0x51, 0xd7, 0xaf, 0xe7, 0xa1, 0xb8, 0x3f, 0x38, 0xd8, 0x21, 0x9b, 0x50, - 0x71, 0xbd, 0xa1, 0x3f, 0x61, 0x2c, 0x25, 0x9f, 0x0d, 0x95, 0xbe, 0xf6, 0x68, 0xdf, 0x82, 0x2a, - 0x72, 0xa2, 0x63, 0x7f, 0xf8, 0x4c, 0x30, 0x75, 0x15, 0x06, 0x38, 0xf0, 0x87, 0xcf, 0xd8, 0x31, - 0xa3, 0x97, 0x53, 0x37, 0x40, 0x3d, 0x83, 0x94, 0xa3, 0x8b, 0x9c, 0x8b, 0x89, 0x33, 0x62, 0x69, - 0x9b, 0xb1, 0x39, 0xe2, 0x7e, 0xe5, 0xdc, 0x5d, 0x95, 0x41, 0xf0, 0x76, 0x25, 0xef, 0x03, 0x39, - 0xf5, 0x83, 0xe7, 0x4e, 0xa0, 0x38, 0x12, 0x4f, 0x90, 0xd6, 0xa2, 0xb5, 0x1c, 0xe7, 0x08, 0x4e, - 0x84, 0x3c, 0x84, 0x35, 0x0d, 0x5d, 0xab, 0x98, 0x73, 0x7c, 0x2b, 0x71, 0xe6, 0xbe, 0x6c, 0xc2, - 0xfc, 0xb5, 0x3c, 0x10, 0x51, 0x7e, 0xc7, 0xf7, 0xc2, 0x28, 0x70, 0x5c, 0x2f, 0x0a, 0x93, 0x9c, - 0x5a, 0x2e, 0xc5, 0xa9, 0xdd, 0x03, 0x03, 0xb9, 0x23, 0xc1, 0x25, 0xe2, 0xe5, 0x96, 0x8f, 0x39, - 0x45, 0xc1, 0x26, 0xb2, 0x4b, 0xee, 0x2d, 0x58, 0x8c, 0x19, 0x54, 0xa5, 0x66, 0x2a, 0x5a, 0x75, - 0xc5, 0xa4, 0x8a, 0xab, 0x90, 0x11, 0x04, 0xc9, 0x79, 0x29, 0x69, 0x9a, 0xf3, 0xc2, 0xcb, 0x13, - 0xe7, 0xf2, 0x88, 0x4a, 0x76, 0x18, 0xe5, 0x6a, 0x13, 0x1a, 0x92, 0x01, 0xe5, 0x98, 0x7c, 0xe6, - 0x6a, 0x82, 0x0b, 0x45, 0x9c, 0x6c, 0x76, 0x72, 0x21, 0x9b, 0x9d, 0x34, 0xff, 0x43, 0x15, 0xca, - 0x72, 0x1a, 0x91, 0x39, 0x8c, 0xdc, 0x0b, 0x1a, 0x33, 0x87, 0x2c, 0xc5, 0x58, 0xce, 0x80, 0x4e, - 0xfc, 0x48, 0xc9, 0x04, 0xfc, 0x98, 0xd4, 0x39, 0x50, 0x48, 0x05, 0x1a, 0x5f, 0xca, 0xb5, 0x63, - 0x05, 0x8e, 0x34, 0xd4, 0xb9, 0xc5, 0x5b, 0x50, 0x96, 0xec, 0x65, 0x51, 0x89, 0xcd, 0x0b, 0x43, - 0x2e, 0x10, 0x6c, 0x42, 0x65, 0xe8, 0x4c, 0x9d, 0xa1, 0x1b, 0x5d, 0x89, 0x3b, 0x41, 0xa5, 0x59, - 0xed, 0x63, 0x7f, 0xe8, 0x8c, 0xed, 0x13, 0x67, 0xec, 0x78, 0x43, 0x2a, 0xd4, 0x4e, 0x75, 0x04, - 0x6e, 0x73, 0x18, 0xf9, 0x0e, 0x2c, 0x8a, 0x7e, 0x4a, 0x2c, 0xae, 0x7d, 0x12, 0xbd, 0x97, 0x68, - 0x4c, 0x7e, 0xf1, 0x27, 0x6c, 0x5d, 0x4e, 0x29, 0xe7, 0xf4, 0x0b, 0x56, 0x95, 0x43, 0xf6, 0x28, - 0x8e, 0x56, 0x64, 0x3f, 0xe7, 0x7b, 0xb8, 0xca, 0x9b, 0xe2, 0xc0, 0x2f, 0xf9, 0xfe, 0x9d, 0x67, - 0xf7, 0x0b, 0x1a, 0xbb, 0xff, 0x2e, 0x2c, 0xcf, 0xbc, 0x90, 0x46, 0xd1, 0x98, 0x8e, 0x54, 0x5f, - 0x6a, 0x88, 0x64, 0xa8, 0x0c, 0xd9, 0x9d, 0x2d, 0x58, 0xe1, 0xfa, 0xb2, 0xd0, 0x89, 0xfc, 0xf0, - 0xdc, 0x0d, 0xed, 0x90, 0x09, 0xe1, 0x5c, 0xa3, 0xb2, 0x8c, 0x59, 0x7d, 0x91, 0xd3, 0xe7, 0x52, - 0xf8, 0x46, 0x0a, 0x3f, 0xa0, 0x43, 0xea, 0x5e, 0xd0, 0x11, 0x8a, 0x02, 0x05, 0x6b, 0x2d, 0x51, - 0xc6, 0x12, 0x99, 0x28, 0xd7, 0xcd, 0x26, 0xf6, 0x6c, 0x3a, 0x72, 0x18, 0x3f, 0xbc, 0xc8, 0xe5, - 0x2d, 0x6f, 0x36, 0x39, 0xe6, 0x10, 0xf2, 0x00, 0x24, 0xb3, 0x2f, 0xf6, 0xcc, 0x52, 0xe2, 0xca, - 0x61, 0x54, 0xc3, 0xaa, 0x0b, 0x0c, 0x2e, 0x8b, 0xdc, 0xd1, 0x0f, 0x8b, 0xc1, 0x76, 0x18, 0xca, - 0xa5, 0xf1, 0x81, 0x69, 0x42, 0x79, 0x1a, 0xb8, 0x17, 0x4e, 0x44, 0x9b, 0xcb, 0xfc, 0x1e, 0x17, - 0x49, 0x46, 0xc0, 0x5d, 0xcf, 0x8d, 0x5c, 0x27, 0xf2, 0x83, 0x26, 0xc1, 0xbc, 0x18, 0x40, 0xee, - 0xc3, 0x32, 0xee, 0x93, 0x30, 0x72, 0xa2, 0x59, 0x28, 0x04, 0x9d, 0x15, 0xdc, 0x50, 0x28, 0xaa, - 0xf5, 0x11, 0x8e, 0xb2, 0x0e, 0xf9, 0x14, 0xd6, 0xf9, 0xd6, 0x98, 0x3b, 0x9a, 0xab, 0x6c, 0x3a, - 0xb0, 0x47, 0x2b, 0x88, 0xb1, 0x93, 0x3c, 0xa3, 0x9f, 0xc3, 0x86, 0xd8, 0x2e, 0x73, 0x25, 0xd7, - 0x54, 0xc9, 0x55, 0x8e, 0x92, 0x2a, 0xba, 0x05, 0xcb, 0xac, 0x6b, 0xee, 0xd0, 0x16, 0x35, 0xb0, - 0x53, 0xb1, 0xce, 0x46, 0x81, 0x85, 0x96, 0x78, 0xa6, 0x85, 0x79, 0x4f, 0xe9, 0x15, 0xf9, 0x3e, - 0x2c, 0xf1, 0xed, 0x83, 0xd2, 0x3c, 0x5e, 0xcc, 0x9b, 0x78, 0x31, 0xaf, 0x89, 0xc9, 0xdd, 0x51, - 0xb9, 0x78, 0x37, 0x2f, 0x0e, 0x13, 0x69, 0x76, 0x34, 0xc6, 0xee, 0x29, 0x65, 0xf7, 0x44, 0x73, - 0x83, 0x6f, 0x36, 0x99, 0x66, 0xa7, 0x76, 0x36, 0xc5, 0x9c, 0x26, 0x27, 0xd6, 0x3c, 0x85, 0xfb, - 0x78, 0xec, 0x87, 0x54, 0x6a, 0x5a, 0x9b, 0x37, 0xc5, 0x81, 0x64, 0x40, 0x29, 0xb2, 0x30, 0xb9, - 0x8f, 0xcb, 0xd8, 0x4a, 0x1f, 0x7e, 0x0b, 0x37, 0x46, 0x83, 0x8b, 0xda, 0x52, 0x27, 0xce, 0x98, - 0xba, 0x73, 0xe7, 0xb9, 0x24, 0xeb, 0xaf, 0x21, 0x35, 0x01, 0x06, 0x12, 0x04, 0x7d, 0x0f, 0x96, - 0xc5, 0x2a, 0xc4, 0xc4, 0xb4, 0x79, 0x1b, 0xaf, 0xc8, 0x9b, 0x72, 0x8c, 0x73, 0xd4, 0xd6, 0x32, - 0xf8, 0xba, 0x68, 0xf4, 0x77, 0x1f, 0x88, 0x5c, 0x14, 0xad, 0xa2, 0xd7, 0x5f, 0x56, 0xd1, 0xb2, - 0x58, 0xa6, 0x18, 0x64, 0xfe, 0x6e, 0x8e, 0x73, 0x54, 0x02, 0x3b, 0xd4, 0xf4, 0x1b, 0x9c, 0xae, - 0xd9, 0xbe, 0x37, 0xbe, 0x12, 0xa4, 0x0e, 0x38, 0xa8, 0xe7, 0x8d, 0x91, 0xd6, 0xb8, 0x9e, 0x8e, - 0xc2, 0x2f, 0xef, 0xba, 0x04, 0x22, 0xd2, 0x1d, 0xa8, 0x4d, 0x67, 0x27, 0x63, 0x77, 0xc8, 0x51, - 0x0a, 0xbc, 0x16, 0x0e, 0x42, 0x84, 0x37, 0xa0, 0x2e, 0xf6, 0x3a, 0xc7, 0x28, 0x22, 0x46, 0x4d, - 0xc0, 0x10, 0x05, 0x99, 0x03, 0x1a, 0x20, 0xb1, 0xab, 0x5b, 0xf8, 0xdb, 0xdc, 0x86, 0xd5, 0x64, - 0xa7, 0x05, 0xe7, 0x72, 0x1f, 0x2a, 0x82, 0x92, 0x4a, 0xcd, 0xdf, 0x62, 0x72, 0x36, 0x2c, 0x95, - 0x6f, 0xfe, 0xc7, 0x12, 0xac, 0xc8, 0x39, 0x62, 0x8b, 0xdd, 0x9f, 0x4d, 0x26, 0x4e, 0x90, 0x41, - 0xa2, 0x73, 0x2f, 0x26, 0xd1, 0xf9, 0x39, 0x12, 0x9d, 0x54, 0xfd, 0x70, 0x0a, 0x9f, 0x54, 0xfd, - 0xb0, 0xdd, 0xc5, 0xa5, 0x71, 0xdd, 0xc0, 0xd0, 0x10, 0xe0, 0x01, 0x37, 0x64, 0xcc, 0x5d, 0x28, - 0xa5, 0x8c, 0x0b, 0x45, 0xbf, 0x0e, 0x16, 0x52, 0xd7, 0xc1, 0x1b, 0xc0, 0xb7, 0xb1, 0xdc, 0x8f, - 0x65, 0x2e, 0xa0, 0x23, 0x4c, 0x6c, 0xc8, 0x77, 0x60, 0x29, 0x4d, 0x81, 0x39, 0xa9, 0x5f, 0xcc, - 0xa0, 0xbf, 0xee, 0x84, 0x22, 0x53, 0xa3, 0x21, 0x57, 0x05, 0xfd, 0x75, 0x27, 0xf4, 0x00, 0x73, - 0x24, 0x7e, 0x1b, 0x80, 0xb7, 0x8d, 0xc7, 0x18, 0xf0, 0x18, 0xbf, 0x9d, 0xda, 0x99, 0xda, 0xac, - 0x6f, 0xb1, 0xc4, 0x2c, 0xa0, 0x78, 0xae, 0xab, 0x58, 0x12, 0x8f, 0xf4, 0xa7, 0xb0, 0xe8, 0x4f, - 0xa9, 0x67, 0xc7, 0x54, 0xb0, 0x86, 0x55, 0x19, 0xa2, 0xaa, 0x8e, 0x84, 0x5b, 0x0d, 0x86, 0xa7, - 0x92, 0xe4, 0x73, 0x3e, 0xc9, 0x54, 0x2b, 0x59, 0xbf, 0xa6, 0xe4, 0x22, 0x22, 0xc6, 0x45, 0x3f, - 0x82, 0x5a, 0x40, 0x43, 0x7f, 0x3c, 0xe3, 0xd6, 0x8a, 0x06, 0xee, 0x23, 0xa9, 0xbe, 0xb5, 0x54, - 0x8e, 0xa5, 0x63, 0x99, 0xbf, 0x91, 0x83, 0x9a, 0x36, 0x06, 0xb2, 0x06, 0xcb, 0x3b, 0xbd, 0xde, - 0x51, 0xdb, 0x6a, 0x0d, 0x3a, 0x5f, 0xb4, 0xed, 0x9d, 0x83, 0x5e, 0xbf, 0x6d, 0xdc, 0x60, 0xe0, - 0x83, 0xde, 0x4e, 0xeb, 0xc0, 0xde, 0xeb, 0x59, 0x3b, 0x12, 0x9c, 0x23, 0xeb, 0x40, 0xac, 0xf6, - 0x61, 0x6f, 0xd0, 0x4e, 0xc0, 0xf3, 0xc4, 0x80, 0xfa, 0xb6, 0xd5, 0x6e, 0xed, 0xec, 0x0b, 0x48, - 0x81, 0xac, 0x82, 0xb1, 0x77, 0xdc, 0xdd, 0xed, 0x74, 0x9f, 0xd8, 0x3b, 0xad, 0xee, 0x4e, 0xfb, - 0xa0, 0xbd, 0x6b, 0x14, 0x49, 0x03, 0xaa, 0xad, 0xed, 0x56, 0x77, 0xb7, 0xd7, 0x6d, 0xef, 0x1a, - 0x25, 0xf3, 0x7f, 0xe4, 0x00, 0xe2, 0x8e, 0x32, 0xba, 0x1a, 0x77, 0x55, 0xb7, 0x0e, 0xae, 0xcd, - 0x0d, 0x8a, 0xd3, 0xd5, 0x20, 0x91, 0x26, 0x0f, 0xa1, 0xec, 0xcf, 0xa2, 0xa1, 0x3f, 0xe1, 0x42, - 0xc4, 0xe2, 0xc3, 0xe6, 0x5c, 0xb9, 0x1e, 0xcf, 0xb7, 0x24, 0x62, 0xc2, 0x02, 0x58, 0x78, 0x99, - 0x05, 0x30, 0x69, 0x6a, 0xe4, 0x7c, 0x9d, 0x66, 0x6a, 0xbc, 0x0d, 0x10, 0x3e, 0xa7, 0x74, 0x8a, - 0xca, 0x2b, 0x71, 0x0a, 0xaa, 0x08, 0x19, 0x30, 0x19, 0xf3, 0x8f, 0x72, 0xb0, 0x86, 0x7b, 0x69, - 0x94, 0x26, 0x62, 0x77, 0xa1, 0x36, 0xf4, 0xfd, 0x29, 0x65, 0x4c, 0xb5, 0xe2, 0xd7, 0x74, 0x10, - 0x23, 0x50, 0x9c, 0x20, 0x9f, 0xfa, 0xc1, 0x90, 0x0a, 0x1a, 0x06, 0x08, 0xda, 0x63, 0x10, 0x76, - 0x86, 0xc4, 0x21, 0xe4, 0x18, 0x9c, 0x84, 0xd5, 0x38, 0x8c, 0xa3, 0xac, 0xc3, 0xc2, 0x49, 0x40, - 0x9d, 0xe1, 0xb9, 0xa0, 0x5e, 0x22, 0x45, 0xbe, 0x1b, 0x2b, 0xf1, 0x86, 0xec, 0x4c, 0x8c, 0x29, - 0xef, 0x7c, 0xc5, 0x5a, 0x12, 0xf0, 0x1d, 0x01, 0x66, 0xf7, 0xbc, 0x73, 0xe2, 0x78, 0x23, 0xdf, - 0xa3, 0x23, 0x21, 0xcb, 0xc7, 0x00, 0xf3, 0x08, 0xd6, 0xd3, 0xe3, 0x13, 0xf4, 0xee, 0x13, 0x8d, - 0xde, 0x71, 0xd1, 0x77, 0xf3, 0xfa, 0x33, 0xa6, 0xd1, 0xbe, 0x7f, 0x5d, 0x84, 0x22, 0x13, 0x78, - 0xae, 0x95, 0x8d, 0x74, 0xd9, 0xb6, 0x30, 0x67, 0x17, 0x46, 0x5d, 0x21, 0x67, 0xc0, 0xc4, 0x62, - 0x21, 0x04, 0x19, 0x2f, 0x95, 0x1d, 0xd0, 0xe1, 0x85, 0x94, 0x59, 0x10, 0x62, 0xd1, 0xe1, 0x05, - 0x2a, 0x2d, 0x9c, 0x88, 0x97, 0xe5, 0xf4, 0xaa, 0x1c, 0x3a, 0x11, 0x96, 0x14, 0x59, 0x58, 0xae, - 0xac, 0xb2, 0xb0, 0x54, 0x13, 0xca, 0xae, 0x77, 0xe2, 0xcf, 0x3c, 0xa9, 0xfa, 0x91, 0x49, 0x34, - 0x43, 0x23, 0x25, 0x65, 0x57, 0x3b, 0xa7, 0x46, 0x15, 0x06, 0x18, 0xb0, 0xcb, 0xfd, 0x43, 0xa8, - 0x86, 0x57, 0xde, 0x50, 0xa7, 0x41, 0xab, 0x62, 0x7e, 0xd8, 0xe8, 0xb7, 0xfa, 0x57, 0xde, 0x10, - 0x77, 0x7c, 0x25, 0x14, 0xbf, 0xc8, 0x23, 0xa8, 0x28, 0xc3, 0x0d, 0xbf, 0x41, 0x6e, 0xea, 0x25, - 0xa4, 0xb5, 0x86, 0xeb, 0xc7, 0x14, 0x2a, 0xf9, 0x00, 0x16, 0xd0, 0xba, 0x12, 0x36, 0xeb, 0x58, - 0x48, 0x0a, 0xbc, 0xac, 0x1b, 0x68, 0x01, 0xa6, 0x23, 0xb4, 0xb4, 0x58, 0x02, 0x8d, 0x4d, 0xd3, - 0xe9, 0xd8, 0x99, 0xda, 0x43, 0x14, 0x20, 0x1b, 0xdc, 0x90, 0xca, 0x20, 0x3b, 0x28, 0x43, 0xde, - 0x85, 0x3a, 0x1a, 0xc5, 0x10, 0xc7, 0xe3, 0x7c, 0x68, 0xc1, 0x02, 0x06, 0xdb, 0x1b, 0x3b, 0xd3, - 0x6e, 0xb8, 0xf9, 0x14, 0x1a, 0x89, 0xce, 0xe8, 0x6a, 0xae, 0x06, 0x57, 0x73, 0xbd, 0xa5, 0xab, - 0xb9, 0xe2, 0xab, 0x50, 0x14, 0xd3, 0xd5, 0x5e, 0x3f, 0x80, 0x8a, 0x9c, 0x0b, 0x46, 0x73, 0x8e, - 0xbb, 0x4f, 0xbb, 0xbd, 0x2f, 0xbb, 0x76, 0xff, 0xab, 0xee, 0x8e, 0x71, 0x83, 0x2c, 0x41, 0xad, - 0xb5, 0x83, 0x64, 0x0c, 0x01, 0x39, 0x86, 0x72, 0xd4, 0xea, 0xf7, 0x15, 0x24, 0x6f, 0xee, 0x81, - 0x91, 0x1e, 0x2a, 0xdb, 0xd4, 0x91, 0x84, 0x09, 0xe3, 0x55, 0x0c, 0x20, 0xab, 0x50, 0xe2, 0xf6, - 0x28, 0x2e, 0x26, 0xf1, 0x84, 0xf9, 0x08, 0x0c, 0x76, 0xb1, 0xb3, 0xb9, 0xd6, 0xcd, 0xd2, 0x63, - 0xc6, 0x7a, 0xeb, 0x06, 0xac, 0x8a, 0x55, 0xe3, 0x30, 0x6c, 0xca, 0xfc, 0x04, 0x96, 0xb5, 0x62, - 0xb1, 0x52, 0x88, 0x31, 0x0b, 0x69, 0xa5, 0x10, 0x0a, 0xfa, 0x3c, 0xc7, 0xdc, 0x80, 0x35, 0x96, - 0x6c, 0x5f, 0x50, 0x2f, 0xea, 0xcf, 0x4e, 0xb8, 0x37, 0x83, 0xeb, 0x7b, 0xe6, 0xaf, 0xe5, 0xa0, - 0xaa, 0x72, 0xae, 0x3f, 0x25, 0x5b, 0x42, 0x7f, 0xc4, 0xc9, 0xe2, 0xa6, 0xd6, 0x02, 0x16, 0xdc, - 0xc2, 0xbf, 0x09, 0x3d, 0x52, 0x55, 0x81, 0xd8, 0xb4, 0x1e, 0xb5, 0xdb, 0x96, 0xdd, 0xeb, 0x1e, - 0x74, 0xba, 0xec, 0x72, 0x60, 0xd3, 0x8a, 0x80, 0xbd, 0x3d, 0x84, 0xe4, 0x4c, 0x03, 0x16, 0x9f, - 0xd0, 0xa8, 0xe3, 0x9d, 0xfa, 0x62, 0x32, 0xcc, 0x3f, 0xbf, 0x00, 0x4b, 0x0a, 0x14, 0xeb, 0xa1, - 0x2e, 0x68, 0x10, 0xba, 0xbe, 0x87, 0xfb, 0xa4, 0x6a, 0xc9, 0x24, 0x23, 0x6f, 0x42, 0x4a, 0x43, - 0x36, 0x63, 0x15, 0x73, 0x85, 0x5c, 0x87, 0x3c, 0xc6, 0x3b, 0xb0, 0xe4, 0x8e, 0xa8, 0x17, 0xb9, - 0xd1, 0x95, 0x9d, 0xd0, 0xca, 0x2f, 0x4a, 0xb0, 0xe0, 0x33, 0x56, 0xa1, 0xe4, 0x8c, 0x5d, 0x47, - 0x7a, 0x89, 0xf0, 0x04, 0x83, 0x0e, 0xfd, 0xb1, 0x1f, 0xa0, 0xdc, 0x52, 0xb5, 0x78, 0x82, 0x3c, - 0x80, 0x55, 0x26, 0x43, 0xe9, 0xa6, 0x12, 0xa4, 0x50, 0xdc, 0x40, 0x40, 0xbc, 0xd9, 0xe4, 0x28, - 0x36, 0x97, 0xb0, 0x1c, 0xc6, 0x5d, 0xb0, 0x12, 0x82, 0x9d, 0x54, 0x05, 0xb8, 0x5e, 0x64, 0xd9, - 0x9b, 0x4d, 0x5a, 0x98, 0xa3, 0xf0, 0x1f, 0xc2, 0x1a, 0xc3, 0x57, 0x0c, 0xa8, 0x2a, 0xb1, 0x84, - 0x25, 0x58, 0x65, 0x1d, 0x91, 0xa7, 0xca, 0xdc, 0x82, 0x2a, 0xef, 0x15, 0xdb, 0x12, 0x25, 0xae, - 0xb3, 0xc0, 0xae, 0xd0, 0x20, 0x9c, 0x73, 0xe8, 0xe0, 0x8a, 0x80, 0xb4, 0x43, 0x87, 0xe6, 0x12, - 0x52, 0x49, 0xbb, 0x84, 0x3c, 0x84, 0xb5, 0x13, 0xb6, 0x47, 0xcf, 0xa9, 0x33, 0xa2, 0x81, 0x1d, - 0xef, 0x7c, 0x2e, 0x6e, 0xae, 0xb0, 0xcc, 0x7d, 0xcc, 0x53, 0x07, 0x85, 0x71, 0x82, 0x8c, 0xf0, - 0xd0, 0x91, 0x1d, 0xf9, 0x36, 0x32, 0x88, 0x42, 0xe3, 0xda, 0xe0, 0xe0, 0x81, 0xbf, 0xc3, 0x80, - 0x49, 0xbc, 0xb3, 0xc0, 0x99, 0x9e, 0x0b, 0x61, 0x50, 0xe1, 0x3d, 0x61, 0x40, 0xf2, 0x1a, 0x94, - 0xd9, 0x99, 0xf0, 0x28, 0xb7, 0x8f, 0x73, 0x31, 0x4b, 0x82, 0xc8, 0x5b, 0xb0, 0x80, 0x6d, 0x84, - 0x4d, 0x03, 0x0f, 0x44, 0x3d, 0xbe, 0x2a, 0x5c, 0xcf, 0x12, 0x79, 0x8c, 0xdd, 0x9e, 0x05, 0x2e, - 0xa7, 0x63, 0x55, 0x0b, 0x7f, 0x93, 0x1f, 0x6a, 0x44, 0x71, 0x05, 0xcb, 0xbe, 0x25, 0xca, 0xa6, - 0xb6, 0xe2, 0x75, 0xf4, 0xf1, 0x5b, 0xa5, 0x56, 0x3f, 0x2a, 0x56, 0x6a, 0x46, 0xdd, 0x6c, 0xa2, - 0x1f, 0x8b, 0x45, 0x87, 0xfe, 0x05, 0x0d, 0xae, 0x12, 0x67, 0x24, 0x07, 0x1b, 0x73, 0x59, 0xb1, - 0x39, 0x3c, 0x10, 0x70, 0x7b, 0xe2, 0x8f, 0x24, 0x53, 0x50, 0x97, 0xc0, 0x43, 0x7f, 0xc4, 0x98, - 0x97, 0x65, 0x85, 0x74, 0xea, 0x7a, 0x6e, 0x78, 0x4e, 0x47, 0x82, 0x37, 0x30, 0x64, 0xc6, 0x9e, - 0x80, 0x33, 0x0e, 0x7c, 0x1a, 0xf8, 0x67, 0xea, 0xaa, 0xcc, 0x59, 0x2a, 0x6d, 0x7e, 0x0a, 0x25, - 0xbe, 0x82, 0xec, 0xa0, 0xe0, 0xfa, 0xe6, 0xc4, 0x41, 0x41, 0x68, 0x13, 0xca, 0x1e, 0x8d, 0x9e, - 0xfb, 0xc1, 0x33, 0x69, 0x5b, 0x13, 0x49, 0xf3, 0x27, 0xa8, 0x54, 0x55, 0x0e, 0x49, 0x5c, 0xf9, - 0xc0, 0xb6, 0x30, 0xdf, 0x82, 0xe1, 0xb9, 0x23, 0xf4, 0xbc, 0x15, 0x04, 0xf4, 0xcf, 0x9d, 0xb9, - 0x2d, 0x9c, 0x9f, 0xf7, 0x49, 0x7a, 0x0b, 0x16, 0xa5, 0x0b, 0x54, 0x68, 0x8f, 0xe9, 0x69, 0x24, - 0x8e, 0x64, 0x5d, 0xf8, 0x3f, 0x85, 0x07, 0xf4, 0x34, 0x32, 0x0f, 0x61, 0x59, 0x1c, 0x9a, 0xde, - 0x94, 0xca, 0xa6, 0x3f, 0xcb, 0x92, 0x8a, 0x6a, 0x0f, 0x57, 0x92, 0xec, 0x06, 0x67, 0xec, 0x12, - 0xa2, 0x92, 0xf9, 0xe3, 0x58, 0x83, 0xc8, 0x98, 0x11, 0x51, 0x9f, 0x90, 0x4d, 0xa4, 0x49, 0x52, - 0x5a, 0xf6, 0x95, 0x04, 0xe4, 0x8e, 0xd8, 0xec, 0x84, 0xb3, 0xe1, 0x50, 0xba, 0xa6, 0x55, 0x2c, - 0x99, 0x34, 0xff, 0x5d, 0x0e, 0x56, 0xb0, 0x32, 0x29, 0xd5, 0x89, 0x9b, 0xe2, 0xa7, 0xee, 0x24, - 0x5b, 0x1f, 0x9d, 0x03, 0xe4, 0x89, 0x6f, 0x6e, 0xa4, 0x29, 0xce, 0x19, 0x69, 0xbe, 0x0b, 0xc6, - 0x88, 0x8e, 0x5d, 0xdc, 0x4a, 0x92, 0xa1, 0xe2, 0x1c, 0xec, 0x92, 0x84, 0x0b, 0x2d, 0x83, 0xf9, - 0x57, 0x72, 0xb0, 0xcc, 0xf9, 0x35, 0xd4, 0xdb, 0x88, 0x89, 0x7a, 0x2c, 0x15, 0x14, 0x82, 0x9c, - 0x8a, 0x31, 0xc5, 0x7c, 0x0c, 0x42, 0x39, 0xf2, 0xfe, 0x0d, 0xa1, 0xb8, 0x10, 0x50, 0xf2, 0x3d, - 0x94, 0x44, 0x3d, 0x1b, 0x81, 0x82, 0x0f, 0xbf, 0x99, 0xc1, 0x21, 0xaa, 0xe2, 0x4c, 0x4c, 0xf5, - 0x10, 0xb4, 0x5d, 0x81, 0x05, 0xae, 0x05, 0x33, 0xf7, 0xa0, 0x91, 0x68, 0x26, 0x61, 0xe9, 0xa9, - 0x73, 0x4b, 0xcf, 0x9c, 0x35, 0x38, 0x3f, 0x6f, 0x0d, 0xbe, 0x82, 0x15, 0x8b, 0x3a, 0xa3, 0xab, - 0x3d, 0x3f, 0x38, 0x0a, 0x4f, 0xa2, 0x3d, 0xce, 0x04, 0xb3, 0x3b, 0x48, 0xb9, 0x38, 0x24, 0xcc, - 0x29, 0xd2, 0xd2, 0x2d, 0xd5, 0x30, 0xdf, 0x81, 0xc5, 0xd8, 0x17, 0x42, 0x53, 0xbc, 0x37, 0x94, - 0x3b, 0x04, 0xf2, 0x4e, 0x04, 0x8a, 0xd3, 0xf0, 0x24, 0x12, 0xaa, 0x77, 0xfc, 0x6d, 0xfe, 0xd5, - 0x12, 0x10, 0xb6, 0x9b, 0x53, 0x1b, 0x26, 0xe5, 0xc5, 0x91, 0x9f, 0xf3, 0xe2, 0x78, 0x00, 0x44, - 0x43, 0x90, 0xce, 0x25, 0x05, 0xe5, 0x5c, 0x62, 0xc4, 0xb8, 0xc2, 0xb7, 0xe4, 0x01, 0xac, 0x0a, - 0x89, 0x22, 0xd9, 0x55, 0xbe, 0x35, 0x08, 0x17, 0x2d, 0x12, 0xfd, 0x95, 0x1e, 0x1c, 0x52, 0x53, - 0x5d, 0xe0, 0x1e, 0x1c, 0x52, 0xa1, 0xa4, 0x6d, 0xc0, 0x85, 0x97, 0x6e, 0xc0, 0xf2, 0xdc, 0x06, - 0xd4, 0x94, 0x8b, 0x95, 0xa4, 0x72, 0x71, 0x4e, 0x4d, 0xce, 0xd9, 0xe7, 0x84, 0x9a, 0xfc, 0x1e, - 0x18, 0x52, 0xd1, 0xa4, 0x54, 0x98, 0xdc, 0xf5, 0x4a, 0x28, 0x91, 0x77, 0xa4, 0x12, 0x33, 0x61, - 0xd3, 0xab, 0xbd, 0x8a, 0x71, 0xb1, 0x9e, 0x6d, 0x5c, 0x9c, 0x57, 0xc9, 0x35, 0x32, 0x54, 0x72, - 0x8f, 0x62, 0x97, 0x86, 0xf0, 0xdc, 0x9d, 0x20, 0xe3, 0x13, 0xfb, 0x14, 0x8a, 0x09, 0xee, 0x9f, - 0xbb, 0x13, 0x4b, 0xfa, 0xcf, 0xb0, 0x04, 0xd9, 0x81, 0x3b, 0x62, 0x3c, 0x19, 0xae, 0x2f, 0x7c, - 0x16, 0x96, 0x90, 0x53, 0xdd, 0xe4, 0x68, 0x87, 0x29, 0x2f, 0x98, 0xd4, 0xa4, 0xb0, 0x4a, 0xb8, - 0x16, 0xd8, 0xd0, 0x27, 0xe5, 0xd0, 0xb9, 0xe4, 0xaa, 0x5f, 0x36, 0xc5, 0xce, 0xa5, 0x2d, 0x74, - 0x7e, 0xe1, 0x05, 0xf2, 0x49, 0x0d, 0xab, 0x36, 0x71, 0x2e, 0x0f, 0x50, 0xa7, 0x17, 0x5e, 0x98, - 0xff, 0x2b, 0x07, 0x06, 0xdb, 0x9a, 0x89, 0x53, 0xff, 0x39, 0x20, 0x7d, 0x7a, 0xc5, 0x43, 0x5f, - 0x63, 0xb8, 0xf2, 0xcc, 0x7f, 0x0a, 0x78, 0x88, 0x6d, 0x7f, 0x4a, 0x3d, 0x71, 0xe4, 0x9b, 0xc9, - 0x23, 0x1f, 0x93, 0xf5, 0xfd, 0x1b, 0x5c, 0x28, 0x64, 0x10, 0xf2, 0x39, 0x54, 0xd9, 0x59, 0xc1, - 0x8d, 0x2b, 0xbc, 0x76, 0x37, 0x95, 0xa0, 0x3f, 0x77, 0x6c, 0x59, 0xd1, 0xa9, 0x48, 0x66, 0x39, - 0xc6, 0x14, 0x33, 0x1c, 0x63, 0x34, 0x9a, 0xb2, 0x0f, 0xf0, 0x94, 0x5e, 0xb1, 0x49, 0x88, 0xfc, - 0x80, 0xf1, 0x56, 0xec, 0x78, 0x9d, 0x3a, 0x13, 0x57, 0x28, 0x1b, 0x4b, 0x56, 0xf5, 0x19, 0xbd, - 0xda, 0x43, 0x00, 0xdb, 0x5b, 0x2c, 0x3b, 0x26, 0x2c, 0x25, 0xab, 0xf2, 0x8c, 0x5e, 0x71, 0xaa, - 0x62, 0x43, 0xe3, 0x29, 0xbd, 0xda, 0xa5, 0x9c, 0x79, 0xf7, 0x03, 0x36, 0xe9, 0x81, 0xf3, 0x9c, - 0x71, 0xeb, 0x09, 0xa7, 0x96, 0x5a, 0xe0, 0x3c, 0x7f, 0x4a, 0xaf, 0xa4, 0x83, 0x4d, 0x99, 0xe5, - 0x8f, 0xfd, 0xa1, 0x60, 0x37, 0xa4, 0x7e, 0x27, 0xee, 0x94, 0xb5, 0xf0, 0x0c, 0x7f, 0x9b, 0x7f, - 0x92, 0x83, 0x06, 0xeb, 0x3f, 0xde, 0x14, 0xb8, 0x8b, 0x84, 0x97, 0x67, 0x2e, 0xf6, 0xf2, 0x7c, - 0x28, 0x08, 0x2d, 0xbf, 0x76, 0xf2, 0xd7, 0x5f, 0x3b, 0xb8, 0x36, 0xfc, 0xce, 0xf9, 0x10, 0xaa, - 0x7c, 0x63, 0x30, 0xd2, 0x53, 0x48, 0x2c, 0x70, 0x62, 0x40, 0x56, 0x05, 0xd1, 0x9e, 0x72, 0xa7, - 0x32, 0x4d, 0x95, 0xce, 0xa7, 0xb8, 0x1a, 0x28, 0x05, 0x7a, 0xc6, 0x32, 0x94, 0xae, 0x71, 0x2a, - 0xd3, 0xf5, 0xd4, 0x0b, 0x69, 0x3d, 0xb5, 0xe9, 0x41, 0x85, 0x2d, 0x35, 0x0e, 0x36, 0xa3, 0xd2, - 0x5c, 0x56, 0xa5, 0x8c, 0x39, 0x71, 0xd8, 0x3d, 0xc5, 0x68, 0x6f, 0x5e, 0x30, 0x27, 0x4e, 0x48, - 0x59, 0x45, 0xac, 0xe3, 0x9e, 0x6f, 0xa3, 0xe2, 0x57, 0xa8, 0x44, 0x2b, 0x56, 0xd5, 0xf3, 0x8f, - 0x38, 0xc0, 0xfc, 0x73, 0x39, 0xa8, 0x69, 0x67, 0x16, 0x2d, 0x01, 0x6a, 0x3a, 0xf9, 0x01, 0x4f, - 0x9e, 0x80, 0xc4, 0x7a, 0xec, 0xdf, 0xb0, 0x1a, 0xc3, 0xc4, 0x02, 0x6d, 0x89, 0xad, 0x8c, 0x25, - 0xf3, 0x09, 0xf5, 0x93, 0x1c, 0x97, 0xdc, 0xbf, 0xec, 0xf7, 0xf6, 0x02, 0x14, 0x19, 0xaa, 0xf9, - 0x18, 0x96, 0xb5, 0x6e, 0x70, 0xf5, 0xcc, 0xab, 0x4e, 0x80, 0xf9, 0x8b, 0xaa, 0x30, 0x6b, 0x83, - 0x9b, 0xd6, 0xa5, 0xff, 0x1e, 0x1d, 0xf1, 0x79, 0x11, 0x7e, 0x82, 0x1c, 0x84, 0x33, 0xf3, 0xaa, - 0x3e, 0x65, 0xbf, 0x9a, 0x83, 0x15, 0xad, 0xfa, 0x3d, 0xd7, 0x73, 0xc6, 0xee, 0x4f, 0x90, 0x47, - 0x09, 0xdd, 0x33, 0x2f, 0xd5, 0x00, 0x07, 0x7d, 0x93, 0x06, 0xd8, 0x55, 0xc2, 0xbd, 0x81, 0xb9, - 0x47, 0xb9, 0xb8, 0x3e, 0x01, 0x61, 0x96, 0xf3, 0x7c, 0x70, 0x69, 0xfe, 0xb5, 0x3c, 0xac, 0x8a, - 0x2e, 0xa0, 0xd3, 0xb6, 0xcb, 0x58, 0xd3, 0xc3, 0xf0, 0x8c, 0x7c, 0x0e, 0x0d, 0x36, 0x7d, 0x76, - 0x40, 0xcf, 0xdc, 0x30, 0xa2, 0xd2, 0xea, 0x9f, 0x41, 0x8d, 0x19, 0x87, 0xc2, 0x50, 0x2d, 0x81, - 0x49, 0x1e, 0x43, 0x0d, 0x8b, 0x72, 0x0d, 0x99, 0x58, 0xab, 0xe6, 0x7c, 0x41, 0xbe, 0x16, 0xfb, - 0x37, 0x2c, 0x08, 0xe3, 0x95, 0x79, 0x0c, 0x35, 0x5c, 0xe6, 0x0b, 0x9c, 0xeb, 0x14, 0xb1, 0x9b, - 0x5b, 0x0b, 0x56, 0x78, 0x1a, 0xaf, 0x4c, 0x0b, 0x1a, 0x9c, 0xdc, 0x89, 0x99, 0x14, 0xce, 0xa0, - 0x9b, 0xf3, 0xc5, 0xe5, 0x5c, 0xb3, 0xce, 0x4f, 0xb5, 0xf4, 0x76, 0x15, 0xca, 0x51, 0xe0, 0x9e, - 0x9d, 0xd1, 0xc0, 0x5c, 0x57, 0x53, 0xc3, 0xe8, 0x38, 0xed, 0x47, 0x74, 0xca, 0x64, 0x0e, 0xf3, - 0x5f, 0xe6, 0xa0, 0x26, 0x28, 0xf3, 0x4f, 0xed, 0x50, 0xb0, 0x99, 0xd2, 0xa5, 0x56, 0x35, 0xd5, - 0xe9, 0x3b, 0xb0, 0x34, 0x61, 0x02, 0x12, 0x13, 0xe0, 0x13, 0xde, 0x04, 0x8b, 0x12, 0x2c, 0x78, - 0xff, 0x2d, 0x58, 0x41, 0x51, 0x20, 0xb4, 0x23, 0x77, 0x6c, 0xcb, 0x4c, 0xf1, 0x72, 0x61, 0x99, - 0x67, 0x0d, 0xdc, 0xf1, 0xa1, 0xc8, 0x60, 0x1c, 0x71, 0x18, 0x39, 0x67, 0x54, 0x50, 0x07, 0x9e, - 0x60, 0x42, 0x57, 0x4a, 0x76, 0x97, 0x42, 0xd7, 0xff, 0x59, 0x86, 0x8d, 0xb9, 0x2c, 0x21, 0x74, - 0x29, 0xe3, 0xed, 0xd8, 0x9d, 0x9c, 0xf8, 0xca, 0x78, 0x90, 0xd3, 0x8c, 0xb7, 0x07, 0x2c, 0x47, - 0x1a, 0x0f, 0x28, 0xac, 0xc9, 0x2d, 0x8b, 0xda, 0x7f, 0x25, 0xde, 0xe7, 0x51, 0xf8, 0xfc, 0x30, - 0x79, 0x0d, 0xa6, 0x9b, 0x93, 0x70, 0x9d, 0xdf, 0x5b, 0x99, 0xce, 0xc1, 0x42, 0xf2, 0xff, 0x43, - 0x53, 0x9d, 0x0c, 0x21, 0x8b, 0x68, 0xba, 0x0a, 0xd6, 0xd2, 0x7b, 0x2f, 0x69, 0x29, 0xa1, 0x96, - 0x45, 0x86, 0x70, 0x5d, 0x1e, 0x2a, 0x5e, 0xa1, 0x6a, 0xeb, 0x02, 0x5e, 0x97, 0x6d, 0xa1, 0x6c, - 0x31, 0xdf, 0x62, 0xf1, 0x95, 0xc6, 0x86, 0x2a, 0xe7, 0x44, 0xb3, 0xd6, 0x2d, 0x51, 0xb1, 0xca, - 0xd2, 0xdb, 0x3d, 0x87, 0xf5, 0xe7, 0x8e, 0x1b, 0xc9, 0x31, 0x6a, 0xaa, 0x92, 0x12, 0xb6, 0xf7, - 0xf0, 0x25, 0xed, 0x7d, 0xc9, 0x0b, 0x27, 0xa4, 0xad, 0xd5, 0xe7, 0xf3, 0xc0, 0x70, 0xf3, 0xef, - 0x14, 0x60, 0x31, 0x59, 0x0b, 0x23, 0x3d, 0xe2, 0xba, 0x92, 0x4c, 0xb4, 0xe0, 0xec, 0x85, 0x61, - 0xab, 0xcb, 0x99, 0xe7, 0x79, 0x93, 0x5b, 0x3e, 0xc3, 0xe4, 0xa6, 0x5b, 0xba, 0x0a, 0x2f, 0x73, - 0x7c, 0x28, 0xbe, 0x92, 0xe3, 0x43, 0x29, 0xcb, 0xf1, 0xe1, 0xa3, 0x6b, 0x2d, 0xe5, 0x5c, 0x5f, - 0x9d, 0x69, 0x25, 0x7f, 0x74, 0xbd, 0x95, 0x9c, 0xb3, 0xe4, 0xd7, 0x59, 0xc8, 0x35, 0xfb, 0x7e, - 0xe5, 0x1a, 0xfb, 0x94, 0x66, 0xf1, 0xcf, 0xb0, 0x90, 0x57, 0xbf, 0x81, 0x85, 0x7c, 0xf3, 0x4f, - 0x72, 0x40, 0xe6, 0x4f, 0x07, 0x79, 0xc2, 0xad, 0x99, 0x1e, 0x1d, 0x0b, 0xca, 0xfd, 0xfe, 0xab, - 0x9d, 0x30, 0xb9, 0x21, 0x64, 0x69, 0xf2, 0x01, 0xac, 0xe8, 0xef, 0xab, 0x74, 0x55, 0x44, 0xc3, - 0x22, 0x7a, 0x56, 0xac, 0x54, 0xd3, 0xbc, 0x4c, 0x8a, 0x2f, 0xf5, 0x32, 0x29, 0xbd, 0xd4, 0xcb, - 0x64, 0x21, 0xe9, 0x65, 0xb2, 0xf9, 0x6f, 0x73, 0xb0, 0x92, 0xb1, 0x89, 0xbf, 0xbd, 0x31, 0xb3, - 0xbd, 0x97, 0x20, 0x6b, 0x79, 0xb1, 0xf7, 0x74, 0x8a, 0x76, 0x20, 0x15, 0xb1, 0x6c, 0x29, 0x42, - 0x71, 0x53, 0xdd, 0x7f, 0x19, 0x75, 0x89, 0x4b, 0x58, 0x7a, 0xf1, 0xcd, 0xbf, 0x97, 0x87, 0x9a, - 0x96, 0xc9, 0x66, 0x91, 0x6f, 0x59, 0xcd, 0xff, 0x92, 0xf3, 0x96, 0xa8, 0x48, 0xb9, 0x03, 0xc2, - 0x5e, 0xc5, 0xf3, 0xf9, 0xe1, 0x12, 0x8c, 0x24, 0x22, 0x6c, 0xc1, 0x8a, 0xb4, 0x34, 0xd3, 0xd8, - 0x4d, 0x5c, 0xdc, 0x35, 0xc2, 0x69, 0x40, 0x74, 0x12, 0xf1, 0x3f, 0x90, 0x32, 0x6e, 0xbc, 0x76, - 0x9a, 0xe5, 0x6e, 0x59, 0xb8, 0x2b, 0x88, 0x45, 0x64, 0xfb, 0xfc, 0x43, 0x58, 0x53, 0xfe, 0x0a, - 0x89, 0x12, 0xdc, 0x3e, 0x44, 0xa4, 0x5f, 0x82, 0x56, 0xe4, 0x87, 0x70, 0x3b, 0xd5, 0xa7, 0x54, - 0x51, 0xee, 0xe7, 0x76, 0x33, 0xd1, 0x3b, 0xbd, 0x86, 0xcd, 0x3f, 0x03, 0x8d, 0x04, 0xa1, 0xfc, - 0xf6, 0x96, 0x3c, 0xad, 0xbc, 0xe2, 0x33, 0xaa, 0x2b, 0xaf, 0x36, 0xff, 0x67, 0x01, 0xc8, 0x3c, - 0xad, 0xfe, 0x59, 0x76, 0x61, 0x7e, 0x63, 0x16, 0x32, 0x36, 0xe6, 0xff, 0x33, 0xfe, 0x21, 0xd6, - 0xa1, 0x6a, 0xee, 0x02, 0xfc, 0x70, 0x1a, 0x2a, 0x43, 0xf6, 0xe2, 0xd3, 0xb4, 0x53, 0x55, 0x25, - 0xf1, 0x44, 0x50, 0x63, 0xa0, 0x52, 0xbe, 0x55, 0xc7, 0xb0, 0xe0, 0x78, 0xc3, 0x73, 0x3f, 0x10, - 0x74, 0xf0, 0xe7, 0xbe, 0xf1, 0xf5, 0xb9, 0xd5, 0xc2, 0xf2, 0xc8, 0xb5, 0x59, 0xa2, 0x32, 0xf3, - 0x43, 0xa8, 0x69, 0x60, 0x52, 0x85, 0xd2, 0x41, 0xe7, 0x70, 0xbb, 0x67, 0xdc, 0x20, 0x0d, 0xa8, - 0x5a, 0xed, 0x9d, 0xde, 0x17, 0x6d, 0xab, 0xbd, 0x6b, 0xe4, 0x48, 0x05, 0x8a, 0x07, 0xbd, 0xfe, - 0xc0, 0xc8, 0x9b, 0x9b, 0xd0, 0x14, 0x35, 0xce, 0x5b, 0x93, 0x7e, 0xab, 0xa8, 0x74, 0xa0, 0x98, - 0x29, 0x84, 0xfc, 0x8f, 0xa0, 0xae, 0xb3, 0x37, 0x62, 0x47, 0xa4, 0x3c, 0x56, 0x98, 0x78, 0xef, - 0x6b, 0xb4, 0x7a, 0x07, 0xb8, 0xbf, 0xc2, 0x48, 0x15, 0xcb, 0x27, 0xf8, 0xd6, 0x0c, 0xc3, 0x2f, - 0xca, 0x47, 0x89, 0x6d, 0xf8, 0xff, 0xc1, 0x62, 0xd2, 0x72, 0x22, 0x28, 0x52, 0x96, 0xc8, 0xca, - 0x4a, 0x27, 0x4c, 0x29, 0xe4, 0x87, 0x60, 0xa4, 0x2d, 0x2f, 0x82, 0x79, 0xbe, 0xa6, 0xfc, 0x92, - 0x9b, 0x34, 0xc6, 0x90, 0x7d, 0x58, 0xcd, 0x62, 0xf0, 0x70, 0x7f, 0x5c, 0xaf, 0xe6, 0x20, 0xf3, - 0x4c, 0x1c, 0xf9, 0x4c, 0x58, 0xe0, 0x4a, 0xb8, 0xfc, 0x6f, 0x25, 0xdb, 0xd7, 0x26, 0x7b, 0x8b, - 0xff, 0xd3, 0x6c, 0x71, 0x17, 0x00, 0x31, 0x8c, 0x18, 0x50, 0xef, 0x1d, 0xb5, 0xbb, 0xf6, 0xce, - 0x7e, 0xab, 0xdb, 0x6d, 0x1f, 0x18, 0x37, 0x08, 0x81, 0x45, 0x74, 0xba, 0xd8, 0x55, 0xb0, 0x1c, - 0x83, 0x09, 0x4b, 0xa8, 0x84, 0xe5, 0xc9, 0x2a, 0x18, 0x9d, 0x6e, 0x0a, 0x5a, 0x20, 0x4d, 0x58, - 0x3d, 0x6a, 0x73, 0x3f, 0x8d, 0x44, 0xbd, 0x45, 0x26, 0x34, 0x88, 0xe1, 0x32, 0xa1, 0xe1, 0x4b, - 0x67, 0x3c, 0xa6, 0x91, 0x38, 0x07, 0x92, 0x97, 0xfe, 0xeb, 0x39, 0x58, 0x4b, 0x65, 0xc4, 0xe6, - 0x0b, 0xce, 0x49, 0x27, 0x79, 0xe8, 0x3a, 0x02, 0xe5, 0x69, 0x7a, 0x17, 0x96, 0x95, 0x36, 0x2d, - 0x75, 0x2b, 0x19, 0x2a, 0x43, 0x22, 0x7f, 0x00, 0x2b, 0x9a, 0x52, 0x2e, 0x45, 0x2b, 0x88, 0x96, - 0x25, 0x0a, 0x98, 0x5b, 0xb0, 0x20, 0x14, 0x97, 0x06, 0x14, 0xe4, 0xc3, 0x95, 0xa2, 0xc5, 0x7e, - 0x12, 0x02, 0xc5, 0x49, 0xec, 0xee, 0x8b, 0xbf, 0xcd, 0x0d, 0xf5, 0xca, 0x2a, 0x35, 0xca, 0x5f, - 0x2d, 0xc2, 0x7a, 0x3a, 0x47, 0x39, 0xc0, 0x97, 0x13, 0x03, 0xe4, 0x86, 0x2c, 0x01, 0x22, 0x1f, - 0xa7, 0x76, 0x4f, 0x62, 0x88, 0x88, 0xaa, 0xef, 0x14, 0x39, 0xd0, 0x87, 0x69, 0x1e, 0x91, 0x6f, - 0xf9, 0x86, 0x74, 0xfa, 0xc7, 0x31, 0xa5, 0x58, 0xc6, 0x8f, 0xe7, 0x58, 0xc6, 0x62, 0x56, 0xa1, - 0x14, 0x07, 0xd9, 0x86, 0x8d, 0xd8, 0xb1, 0x35, 0xd9, 0x66, 0x29, 0xab, 0xf8, 0x9a, 0xc2, 0x3e, - 0xd0, 0x1b, 0x7f, 0x02, 0xcd, 0xb8, 0x9a, 0x54, 0x37, 0x16, 0xb2, 0xea, 0x59, 0x57, 0xe8, 0x56, - 0xa2, 0x3f, 0x3f, 0x82, 0xcd, 0xc4, 0x7c, 0x25, 0xbb, 0x54, 0xce, 0xaa, 0x6a, 0x43, 0x9b, 0xc0, - 0x44, 0xa7, 0x0e, 0xe0, 0x56, 0xa2, 0xae, 0x54, 0xbf, 0x2a, 0x59, 0x95, 0x35, 0xb5, 0xca, 0x12, - 0x3d, 0x33, 0x7f, 0x67, 0x01, 0xc8, 0x8f, 0x67, 0x34, 0xb8, 0xc2, 0xa7, 0x97, 0xe1, 0xcb, 0x3c, - 0xf6, 0xa5, 0xe2, 0x2d, 0xff, 0x4a, 0xcf, 0xab, 0xb3, 0x9e, 0x37, 0x17, 0x5f, 0xfe, 0xbc, 0xb9, - 0xf4, 0xb2, 0xe7, 0xcd, 0x6f, 0x42, 0xc3, 0x3d, 0xf3, 0x7c, 0x76, 0xaf, 0x31, 0xb1, 0x26, 0x6c, - 0x2e, 0xdc, 0x2d, 0xdc, 0xab, 0x5b, 0x75, 0x01, 0x64, 0x42, 0x4d, 0x48, 0x1e, 0xc7, 0x48, 0x74, - 0x74, 0x86, 0x4f, 0xfc, 0xf5, 0x1b, 0xad, 0x3d, 0x3a, 0xa3, 0x42, 0xcf, 0x88, 0x1b, 0x56, 0x16, - 0x66, 0xf0, 0x90, 0xbc, 0x05, 0x8b, 0xa1, 0x3f, 0x63, 0x52, 0xa2, 0x9c, 0x06, 0x6e, 0x6e, 0xae, - 0x73, 0xe8, 0x91, 0x74, 0x3e, 0x58, 0x99, 0x85, 0xd4, 0x9e, 0xb8, 0x61, 0xc8, 0x78, 0xed, 0xa1, - 0xef, 0x45, 0x81, 0x3f, 0x16, 0x16, 0xe4, 0xe5, 0x59, 0x48, 0x0f, 0x79, 0xce, 0x0e, 0xcf, 0x20, - 0x1f, 0xc7, 0x5d, 0x9a, 0x3a, 0x6e, 0x10, 0x36, 0x01, 0xbb, 0x24, 0x47, 0x8a, 0xc2, 0x98, 0xe3, - 0x06, 0xaa, 0x2f, 0x2c, 0x11, 0xa6, 0x9e, 0x5d, 0xd7, 0xd2, 0xcf, 0xae, 0x7f, 0x25, 0xfb, 0xd9, - 0x35, 0x77, 0x9a, 0x7b, 0x20, 0xaa, 0x9e, 0x5f, 0xe2, 0x6f, 0xf4, 0xfa, 0x7a, 0xfe, 0x35, 0xf9, - 0xe2, 0x37, 0x79, 0x4d, 0xbe, 0x94, 0xf5, 0x9a, 0xfc, 0x43, 0xa8, 0xe1, 0x3b, 0x5f, 0xfb, 0x1c, - 0x5d, 0x67, 0xb9, 0x45, 0xdc, 0xd0, 0x1f, 0x02, 0xef, 0xbb, 0x5e, 0x64, 0x41, 0x20, 0x7f, 0x86, - 0xf3, 0x0f, 0xbb, 0x97, 0x7f, 0x86, 0x0f, 0xbb, 0xc5, 0x7b, 0xe4, 0x2d, 0xa8, 0xc8, 0x75, 0x62, - 0xc4, 0xf6, 0x34, 0xf0, 0x27, 0xd2, 0x0a, 0xc7, 0x7e, 0x93, 0x45, 0xc8, 0x47, 0xbe, 0x28, 0x9c, - 0x8f, 0x7c, 0xf3, 0x97, 0xa0, 0xa6, 0x6d, 0x35, 0xf2, 0x06, 0x57, 0x53, 0x33, 0x41, 0x5b, 0x08, - 0x0a, 0x7c, 0x16, 0xab, 0x02, 0xda, 0x19, 0xb1, 0xcb, 0x63, 0xe4, 0x06, 0x14, 0x43, 0x30, 0xd8, - 0x01, 0xbd, 0xa0, 0x41, 0x28, 0xad, 0xa2, 0x86, 0xca, 0xb0, 0x38, 0xdc, 0xfc, 0x65, 0x58, 0x49, - 0xac, 0xad, 0x20, 0xdf, 0x6f, 0xc1, 0x02, 0xce, 0x9b, 0x74, 0xbd, 0x49, 0x3e, 0xb0, 0x16, 0x79, - 0x18, 0x6e, 0x82, 0x1b, 0x74, 0xed, 0x69, 0xe0, 0x9f, 0x60, 0x23, 0x39, 0xab, 0x26, 0x60, 0x47, - 0x81, 0x7f, 0x62, 0xfe, 0x61, 0x01, 0x0a, 0xfb, 0xfe, 0x54, 0x77, 0xb7, 0xcd, 0xcd, 0xb9, 0xdb, - 0x0a, 0xed, 0x81, 0xad, 0xb4, 0x03, 0x42, 0x00, 0x43, 0x53, 0xa6, 0xd4, 0x10, 0xdc, 0x83, 0x45, - 0x46, 0x27, 0x22, 0xdf, 0x16, 0xcf, 0x5c, 0xf8, 0x0d, 0xc7, 0x0f, 0x9f, 0x33, 0x89, 0x06, 0xfe, - 0x1e, 0x87, 0x93, 0x55, 0x28, 0x28, 0x59, 0x14, 0xb3, 0x59, 0x92, 0xac, 0xc3, 0x02, 0x3e, 0xcf, - 0xb9, 0x12, 0xae, 0x23, 0x22, 0x45, 0xde, 0x87, 0x95, 0x64, 0xbd, 0x9c, 0x14, 0x09, 0x46, 0x57, - 0xaf, 0x18, 0x69, 0xd2, 0x4d, 0x60, 0x74, 0x84, 0xe3, 0x08, 0x1f, 0xb7, 0x53, 0x4a, 0x31, 0x4b, - 0x23, 0x7a, 0x95, 0x04, 0xd1, 0xbb, 0x03, 0xb5, 0x68, 0x7c, 0x61, 0x4f, 0x9d, 0xab, 0xb1, 0xef, - 0xc8, 0x37, 0x79, 0x10, 0x8d, 0x2f, 0x8e, 0x38, 0x84, 0x7c, 0x00, 0x30, 0x99, 0x4e, 0xc5, 0xd9, - 0x43, 0xf3, 0x5c, 0xbc, 0x95, 0x0f, 0x8f, 0x8e, 0xf8, 0x96, 0xb3, 0xaa, 0x93, 0xe9, 0x94, 0xff, - 0x24, 0xbb, 0xb0, 0x98, 0x19, 0x26, 0xe1, 0xb6, 0x7c, 0xc4, 0xe0, 0x4f, 0xb7, 0x32, 0x0e, 0x67, - 0x63, 0xa8, 0xc3, 0x36, 0x7f, 0x08, 0xe4, 0x4f, 0x19, 0xac, 0x60, 0x00, 0x55, 0xd5, 0x3f, 0xfd, - 0xad, 0x3f, 0xbe, 0x1c, 0xab, 0x25, 0xde, 0xfa, 0xb7, 0x46, 0xa3, 0x80, 0xd1, 0x45, 0xce, 0xfd, - 0x28, 0x92, 0x0f, 0x1a, 0xfb, 0x23, 0x9e, 0xff, 0x98, 0xff, 0x25, 0x07, 0x25, 0x1e, 0x78, 0xe0, - 0x6d, 0x58, 0xe2, 0xf8, 0xca, 0x75, 0x59, 0x38, 0x9c, 0x70, 0x26, 0x6a, 0x20, 0xbc, 0x96, 0xd9, - 0xb1, 0xd0, 0x82, 0xb1, 0xc4, 0x6c, 0x84, 0x16, 0x90, 0xe5, 0x0e, 0x54, 0x55, 0xd3, 0xda, 0xd6, - 0xa9, 0xc8, 0x96, 0xc9, 0xeb, 0x50, 0x3c, 0xf7, 0xa7, 0x52, 0x8d, 0x07, 0xf1, 0x4c, 0x5a, 0x08, - 0x8f, 0xfb, 0xc2, 0xda, 0x88, 0x9f, 0x25, 0x15, 0x44, 0x5f, 0x58, 0x23, 0xb8, 0x0d, 0xe6, 0xc7, - 0xb8, 0x90, 0x31, 0xc6, 0x63, 0x58, 0x62, 0x74, 0x40, 0xf3, 0x7a, 0xb9, 0xfe, 0xd2, 0xfc, 0x2e, - 0x63, 0xd7, 0x87, 0xe3, 0xd9, 0x88, 0xea, 0x8a, 0x54, 0xf4, 0x43, 0x15, 0x70, 0x29, 0x26, 0x99, - 0xbf, 0x93, 0xe3, 0xf4, 0x85, 0xd5, 0x4b, 0xee, 0x41, 0xd1, 0x93, 0x1e, 0x32, 0x31, 0x53, 0xae, - 0x9e, 0xf0, 0x31, 0x3c, 0x0b, 0x31, 0xd8, 0xd2, 0xa1, 0x5f, 0x89, 0x5e, 0x7b, 0xc3, 0xaa, 0x79, - 0xb3, 0x89, 0xd2, 0x43, 0x7e, 0x47, 0x0e, 0x2b, 0xa5, 0xc3, 0xe3, 0xa3, 0x57, 0xc7, 0x74, 0x4b, - 0x73, 0x68, 0x2d, 0x26, 0x6e, 0x4c, 0xc9, 0xd2, 0x8f, 0xce, 0xa8, 0xe6, 0xc8, 0xfa, 0x7b, 0x79, - 0x68, 0x24, 0x7a, 0x84, 0x1e, 0xbd, 0xec, 0x02, 0xe0, 0x76, 0x46, 0xb1, 0xde, 0xe8, 0x38, 0x29, - 0xa4, 0x2e, 0x6d, 0x9e, 0xf2, 0x89, 0x79, 0x52, 0x2e, 0x6e, 0x05, 0xdd, 0xc5, 0xed, 0x01, 0x54, - 0xe3, 0x20, 0x3c, 0xc9, 0x2e, 0xb1, 0xf6, 0xe4, 0x43, 0xc6, 0x18, 0x29, 0x76, 0x8a, 0x2b, 0xe9, - 0x4e, 0x71, 0xdf, 0xd7, 0x7c, 0xa8, 0x16, 0xb0, 0x1a, 0x33, 0x6b, 0x46, 0x7f, 0x26, 0x1e, 0x54, - 0xe6, 0x63, 0xa8, 0x69, 0x9d, 0xd7, 0xfd, 0x90, 0x72, 0x09, 0x3f, 0x24, 0xf5, 0xa4, 0x39, 0x1f, - 0x3f, 0x69, 0x36, 0x7f, 0x3d, 0x0f, 0x0d, 0x76, 0xbe, 0x5c, 0xef, 0xec, 0xc8, 0x1f, 0xbb, 0x43, - 0xb4, 0x3b, 0xaa, 0x13, 0x26, 0x18, 0x2d, 0x79, 0xce, 0xc4, 0x11, 0xe3, 0x7c, 0x96, 0x1e, 0x19, - 0x82, 0x13, 0x69, 0x15, 0x19, 0xc2, 0x84, 0x06, 0x23, 0x8c, 0x68, 0x41, 0x8c, 0x43, 0xf9, 0x58, - 0xb5, 0x53, 0x4a, 0xb7, 0x9d, 0x90, 0x53, 0xc8, 0xf7, 0x61, 0x85, 0xe1, 0xe0, 0xa3, 0xf8, 0x89, - 0x3b, 0x1e, 0xbb, 0xf1, 0x3b, 0xc0, 0x82, 0x65, 0x9c, 0x52, 0x6a, 0x39, 0x11, 0x3d, 0x64, 0x19, - 0x22, 0xf2, 0x4f, 0x65, 0xe4, 0x86, 0xce, 0x49, 0xec, 0x77, 0xad, 0xd2, 0xd2, 0x30, 0x1f, 0xfb, - 0x3e, 0x2c, 0x88, 0x27, 0x82, 0xdc, 0x72, 0x8f, 0xe5, 0x53, 0x3b, 0xa9, 0x9c, 0xde, 0x49, 0xe6, - 0x3f, 0xcd, 0x43, 0x4d, 0xdb, 0x96, 0xaf, 0x72, 0xbb, 0xde, 0x9e, 0xb3, 0x13, 0x57, 0x75, 0x93, - 0xf0, 0x9b, 0xc9, 0x26, 0x0b, 0xea, 0xb1, 0x98, 0xbe, 0x81, 0x6f, 0x41, 0x95, 0x9d, 0xba, 0x0f, - 0x51, 0x9f, 0x2e, 0x22, 0x6f, 0x21, 0xe0, 0x68, 0x76, 0x22, 0x33, 0x1f, 0x62, 0x66, 0x29, 0xce, - 0x7c, 0xc8, 0x32, 0x5f, 0xf4, 0x58, 0xe4, 0x53, 0xa8, 0x8b, 0x5a, 0x71, 0x4d, 0x85, 0x58, 0xb0, - 0xaa, 0xdd, 0xdc, 0x6a, 0xbd, 0xad, 0x1a, 0x6f, 0x8e, 0x2f, 0xbe, 0x28, 0xf8, 0x50, 0x16, 0xac, - 0xbc, 0xac, 0xe0, 0x43, 0x9e, 0x30, 0xf7, 0xd4, 0xfb, 0x1b, 0xf4, 0x5e, 0x94, 0x74, 0xec, 0x03, - 0x58, 0x91, 0xe4, 0x6a, 0xe6, 0x39, 0x9e, 0xe7, 0xcf, 0xbc, 0x21, 0x95, 0x6f, 0x91, 0x89, 0xc8, - 0x3a, 0x8e, 0x73, 0xcc, 0x91, 0x0a, 0xb6, 0xc1, 0xbd, 0x20, 0xef, 0x43, 0x89, 0xf3, 0xe5, 0x9c, - 0xf9, 0xc8, 0x26, 0x5c, 0x1c, 0x85, 0xdc, 0x83, 0x12, 0x67, 0xcf, 0xf3, 0xd7, 0x12, 0x1b, 0x8e, - 0x60, 0xb6, 0x80, 0xb0, 0x82, 0x87, 0x34, 0x0a, 0xdc, 0x61, 0x18, 0x3f, 0x73, 0x2e, 0x45, 0x57, - 0x53, 0xd1, 0x56, 0xac, 0x86, 0x8f, 0x31, 0x51, 0xe1, 0xc0, 0x71, 0xd8, 0xc5, 0xb4, 0x92, 0xa8, - 0x43, 0xb0, 0x4b, 0x63, 0x58, 0x3f, 0xa1, 0xd1, 0x73, 0x4a, 0x3d, 0x8f, 0x31, 0x43, 0x43, 0xea, - 0x45, 0x81, 0x33, 0x66, 0x8b, 0xc4, 0x47, 0xf0, 0x68, 0xae, 0xd6, 0x58, 0xa1, 0xb5, 0x1d, 0x17, - 0xdc, 0x51, 0xe5, 0x38, 0xed, 0x58, 0x3b, 0xc9, 0xca, 0xdb, 0xfc, 0x45, 0xd8, 0xbc, 0xbe, 0x50, - 0x46, 0xb0, 0x84, 0x7b, 0x49, 0xaa, 0xa2, 0x8c, 0xba, 0x63, 0xdf, 0x89, 0x78, 0x6f, 0x74, 0xca, - 0xd2, 0x85, 0x9a, 0x96, 0x13, 0xdf, 0xfd, 0x39, 0x64, 0xee, 0x78, 0x82, 0xdd, 0x48, 0x9e, 0x1f, - 0x4c, 0xd0, 0x88, 0x3a, 0xb2, 0xe3, 0xda, 0x73, 0xd6, 0x52, 0x0c, 0x47, 0xbf, 0x1b, 0x73, 0x0b, - 0x96, 0x90, 0xb3, 0xd7, 0x2e, 0xba, 0x17, 0x31, 0x83, 0xe6, 0x2a, 0x90, 0x2e, 0xa7, 0x5d, 0xba, - 0x47, 0xe8, 0xbf, 0x2f, 0x40, 0x4d, 0x03, 0xb3, 0xdb, 0x08, 0xdd, 0x68, 0xed, 0x91, 0xeb, 0x4c, - 0xa8, 0xb4, 0x58, 0x37, 0xac, 0x06, 0x42, 0x77, 0x05, 0x90, 0xdd, 0xc5, 0xce, 0xc5, 0x99, 0xed, - 0xcf, 0x22, 0x7b, 0x44, 0xcf, 0x02, 0x2a, 0x7b, 0x59, 0x77, 0x2e, 0xce, 0x7a, 0xb3, 0x68, 0x17, - 0x61, 0x0c, 0x8b, 0xd1, 0x12, 0x0d, 0x4b, 0x78, 0x55, 0x4e, 0x9c, 0xcb, 0x18, 0x4b, 0xb8, 0x1f, - 0xf3, 0x9d, 0x59, 0x54, 0xee, 0xc7, 0x5c, 0x5a, 0x4c, 0x5f, 0xa0, 0xa5, 0xf9, 0x0b, 0xf4, 0x63, - 0x58, 0xe7, 0x17, 0xa8, 0x20, 0xcd, 0x76, 0xea, 0x24, 0xaf, 0x62, 0xae, 0x18, 0xa4, 0xc6, 0xf6, - 0x1a, 0x6c, 0x04, 0x92, 0x2c, 0x85, 0xee, 0x4f, 0x38, 0x21, 0xcb, 0x59, 0x6c, 0x64, 0xa2, 0xf2, - 0xbe, 0xfb, 0x13, 0xca, 0x30, 0xd1, 0x7f, 0x4b, 0xc7, 0x14, 0x4f, 0xc1, 0x26, 0xae, 0x97, 0xc6, - 0x74, 0x2e, 0x93, 0x98, 0x55, 0x81, 0xe9, 0x5c, 0xea, 0x98, 0x8f, 0x60, 0x63, 0x42, 0x47, 0xae, - 0x93, 0xac, 0xd6, 0x8e, 0x19, 0xb7, 0x55, 0x9e, 0xad, 0x95, 0xe9, 0x73, 0xc1, 0x9d, 0xcd, 0xc6, - 0x4f, 0xfc, 0xc9, 0x89, 0xcb, 0x79, 0x16, 0xee, 0x51, 0x56, 0xb4, 0x16, 0xbd, 0xd9, 0xe4, 0x17, - 0x10, 0xcc, 0x8a, 0x84, 0x66, 0x03, 0x6a, 0xfd, 0xc8, 0x9f, 0xca, 0x65, 0x5e, 0x84, 0x3a, 0x4f, - 0x8a, 0x67, 0xfc, 0xb7, 0xe0, 0x26, 0x92, 0x84, 0x81, 0x3f, 0xf5, 0xc7, 0xfe, 0xd9, 0x55, 0x42, - 0x29, 0xfb, 0xaf, 0x72, 0xb0, 0x92, 0xc8, 0x15, 0xe4, 0xf5, 0x63, 0x4e, 0xcf, 0xd4, 0x13, 0xe0, - 0x5c, 0xe2, 0xfd, 0x17, 0x5b, 0x2f, 0x8e, 0xc8, 0x89, 0x99, 0x7c, 0x16, 0xdc, 0x8a, 0xa3, 0x23, - 0xc9, 0x82, 0x9c, 0xa4, 0x34, 0xe7, 0x49, 0x8a, 0x28, 0x2f, 0xe3, 0x26, 0xc9, 0x2a, 0x7e, 0x4e, - 0x3c, 0xd7, 0x1b, 0x89, 0x21, 0x17, 0x92, 0x0f, 0x7a, 0x74, 0x05, 0xae, 0xec, 0x41, 0xac, 0xd5, - 0x0d, 0xcd, 0xbf, 0x9b, 0x03, 0x88, 0x7b, 0x87, 0x4f, 0x8a, 0x14, 0xdf, 0x92, 0x43, 0x67, 0x6e, - 0x8d, 0x47, 0x79, 0x03, 0xea, 0xca, 0xef, 0x3f, 0xe6, 0x84, 0x6a, 0x12, 0xc6, 0xd8, 0xa1, 0x77, - 0x60, 0xe9, 0x6c, 0xec, 0x9f, 0x20, 0xc7, 0x2a, 0xf8, 0x16, 0xee, 0x12, 0xb2, 0xc8, 0xc1, 0x92, - 0x1b, 0x89, 0xf9, 0xa6, 0x62, 0xe6, 0xd3, 0x00, 0x9d, 0x0b, 0x32, 0xff, 0x52, 0x5e, 0x39, 0x17, - 0xc7, 0x33, 0xf1, 0x62, 0xf1, 0xee, 0xa7, 0x71, 0xad, 0x7a, 0x91, 0xad, 0xf8, 0x31, 0x2c, 0x06, - 0xfc, 0x52, 0x92, 0x37, 0x56, 0xf1, 0x05, 0x37, 0x56, 0x23, 0x48, 0x70, 0x3a, 0xdf, 0x05, 0xc3, - 0x19, 0x5d, 0xd0, 0x20, 0x72, 0xd1, 0xf4, 0x82, 0xfc, 0xb1, 0x70, 0xe7, 0xd5, 0xe0, 0xc8, 0x88, - 0xbe, 0x03, 0x4b, 0x22, 0xb4, 0x84, 0xc2, 0x14, 0x61, 0xf8, 0x62, 0x30, 0x43, 0x34, 0xff, 0xa1, - 0xf4, 0x66, 0x4e, 0xae, 0xee, 0x8b, 0x67, 0x45, 0x1f, 0x61, 0x7e, 0xde, 0x1a, 0x2e, 0x36, 0x92, - 0xb0, 0xe8, 0x08, 0x7a, 0xc4, 0x81, 0xc2, 0x9e, 0x93, 0x9c, 0xd6, 0xe2, 0xab, 0x4c, 0xab, 0xf9, - 0x6f, 0x72, 0x50, 0xde, 0xf7, 0xa7, 0xfb, 0x2e, 0x7f, 0x13, 0x83, 0xc7, 0x44, 0x19, 0x1c, 0x17, - 0x58, 0x12, 0xfd, 0xc0, 0x5e, 0xf0, 0x34, 0x36, 0x93, 0xcd, 0x6b, 0x24, 0xd9, 0xbc, 0xef, 0xc3, - 0x2d, 0xb4, 0xe7, 0x06, 0xfe, 0xd4, 0x0f, 0xd8, 0x51, 0x75, 0xc6, 0x9c, 0xdd, 0xf3, 0xbd, 0xe8, - 0x5c, 0xd2, 0xce, 0x9b, 0xa7, 0x94, 0x1e, 0x69, 0x18, 0x87, 0x0a, 0x01, 0x9f, 0xc5, 0x8f, 0xa3, - 0x0b, 0x9b, 0x4b, 0xe8, 0x82, 0x1f, 0xe5, 0x14, 0x75, 0x89, 0x65, 0xb4, 0x11, 0x8e, 0x1c, 0xa9, - 0xf9, 0x19, 0x54, 0x95, 0xb2, 0x87, 0xbc, 0x0b, 0xd5, 0x73, 0x7f, 0x2a, 0x34, 0x42, 0xb9, 0xc4, - 0xf3, 0x61, 0x31, 0x6a, 0xab, 0x72, 0xce, 0x7f, 0x84, 0xe6, 0x1f, 0x96, 0xa1, 0xdc, 0xf1, 0x2e, - 0x7c, 0x77, 0x88, 0xfe, 0xd0, 0x13, 0x3a, 0xf1, 0x65, 0xe4, 0x1b, 0xf6, 0x1b, 0x5d, 0xf5, 0xe2, - 0x60, 0x7a, 0x05, 0xe1, 0xaa, 0xa7, 0xc2, 0xe8, 0xad, 0xc1, 0x42, 0xa0, 0x47, 0xc3, 0x2b, 0x05, - 0xf8, 0x8a, 0x44, 0xdd, 0x97, 0x25, 0x2d, 0x32, 0x11, 0xab, 0x8b, 0xbb, 0xaa, 0xe2, 0x94, 0xf1, - 0xa7, 0xed, 0x55, 0x84, 0xe0, 0x84, 0xbd, 0x06, 0x65, 0xa1, 0xf7, 0xe5, 0x6f, 0x07, 0xb9, 0xb6, - 0x5c, 0x80, 0x70, 0x37, 0x04, 0x94, 0xdb, 0xe3, 0x15, 0x23, 0x5b, 0xb0, 0xea, 0x12, 0xb8, 0xcb, - 0xf6, 0xda, 0x1d, 0xa8, 0x71, 0x7c, 0x8e, 0x52, 0x11, 0x6e, 0xc4, 0x08, 0x42, 0x84, 0x8c, 0xa0, - 0x92, 0xd5, 0xcc, 0xa0, 0x92, 0xe8, 0xf0, 0xae, 0xa8, 0x2c, 0x1f, 0x22, 0xf0, 0x50, 0x82, 0x1a, - 0x5c, 0x46, 0x6a, 0x15, 0x3a, 0x15, 0x1e, 0xf5, 0x41, 0xea, 0x54, 0xde, 0x84, 0xc6, 0xa9, 0x33, - 0x1e, 0x9f, 0x38, 0xc3, 0x67, 0x5c, 0x15, 0x50, 0xe7, 0xda, 0x4f, 0x09, 0x44, 0x5d, 0xc0, 0x1d, - 0xa8, 0x69, 0xab, 0x8c, 0x3e, 0xc2, 0x45, 0x0b, 0xe2, 0xf5, 0x4d, 0x6b, 0xf8, 0x16, 0x5f, 0x41, - 0xc3, 0xa7, 0xf9, 0x4a, 0x2f, 0x25, 0x7d, 0xa5, 0x6f, 0x21, 0x35, 0x15, 0x1e, 0xa8, 0x06, 0x8f, - 0x5b, 0xe7, 0x8c, 0x46, 0x3c, 0x0e, 0xcb, 0x1b, 0x50, 0x17, 0x93, 0xc7, 0xf3, 0x97, 0xb9, 0x2c, - 0xc1, 0x61, 0x1c, 0xe5, 0x36, 0x57, 0x53, 0x4f, 0x1d, 0x77, 0x84, 0x4f, 0x77, 0x84, 0x45, 0xc3, - 0x99, 0x44, 0x47, 0x8e, 0x8b, 0xbe, 0x77, 0x32, 0x1b, 0x6f, 0xc7, 0x15, 0x3e, 0xff, 0x22, 0xbb, - 0xcf, 0x63, 0x9a, 0x28, 0x8c, 0x89, 0x0a, 0xdb, 0x60, 0xd5, 0x04, 0x0a, 0xee, 0x83, 0x0f, 0xd1, - 0x65, 0x2b, 0xa2, 0x18, 0x98, 0x61, 0xf1, 0xe1, 0x2d, 0xe5, 0x49, 0x82, 0xbb, 0x54, 0xfe, 0xe7, - 0x96, 0x4e, 0x8e, 0xc9, 0x98, 0x3b, 0x6e, 0x70, 0x5d, 0x4f, 0xf0, 0xbf, 0x02, 0x15, 0x0d, 0xae, - 0x1c, 0x81, 0x7c, 0xa6, 0xc9, 0xaf, 0x4d, 0x44, 0x7e, 0x2d, 0x55, 0xff, 0x75, 0x6f, 0x23, 0x6f, - 0x03, 0xb8, 0x21, 0xbb, 0x65, 0x42, 0xea, 0x8d, 0x30, 0xbe, 0x42, 0xc5, 0xaa, 0xba, 0xe1, 0x53, - 0x0e, 0xf8, 0x76, 0x05, 0xdb, 0x16, 0xd4, 0xf5, 0x61, 0x92, 0x0a, 0x14, 0x7b, 0x47, 0xed, 0xae, - 0x71, 0x83, 0xd4, 0xa0, 0xdc, 0x6f, 0x0f, 0x06, 0x07, 0x68, 0xb6, 0xad, 0x43, 0x45, 0xbd, 0x9e, - 0xce, 0xb3, 0x54, 0x6b, 0x67, 0xa7, 0x7d, 0x34, 0x68, 0xef, 0x1a, 0x85, 0x1f, 0x15, 0x2b, 0x79, - 0xa3, 0x60, 0xfe, 0x51, 0x01, 0x6a, 0xda, 0x2c, 0xbc, 0x98, 0x18, 0x27, 0xe3, 0xf4, 0xe4, 0xd3, - 0x71, 0x7a, 0x74, 0x1b, 0x85, 0x88, 0x65, 0x24, 0x6d, 0x14, 0x6f, 0x42, 0x83, 0x87, 0xa0, 0xd1, - 0x8d, 0xef, 0x25, 0xab, 0xce, 0x81, 0x82, 0x54, 0x63, 0x2c, 0x06, 0x44, 0xc2, 0x57, 0xae, 0x22, - 0x12, 0x18, 0x07, 0xe1, 0x3b, 0x57, 0x7c, 0xa4, 0x1c, 0xfa, 0xe3, 0x0b, 0xca, 0x31, 0x38, 0x47, - 0x58, 0x13, 0xb0, 0x81, 0x88, 0x73, 0x21, 0xe8, 0xa1, 0x16, 0x0c, 0xa0, 0x64, 0xd5, 0x39, 0x50, - 0x34, 0xf4, 0xbe, 0xdc, 0x40, 0xdc, 0x15, 0x69, 0x63, 0x7e, 0x37, 0x24, 0x36, 0xcf, 0xc1, 0x9c, - 0x1a, 0xb1, 0x8a, 0x1b, 0xe3, 0x3b, 0xf3, 0xe5, 0x5e, 0xae, 0x4e, 0x24, 0xef, 0x02, 0x99, 0x4c, - 0xa7, 0x76, 0x86, 0x82, 0xaf, 0x68, 0x2d, 0x4d, 0xa6, 0xd3, 0x81, 0xa6, 0xff, 0xfa, 0x16, 0x74, - 0x8f, 0x5f, 0x03, 0x69, 0xb1, 0x03, 0x8c, 0x5d, 0x54, 0xa2, 0x58, 0x4c, 0x96, 0x73, 0x3a, 0x59, - 0xce, 0xa0, 0x7e, 0xf9, 0x4c, 0xea, 0xf7, 0x22, 0x3a, 0x61, 0xee, 0x41, 0xed, 0x48, 0x8b, 0x5c, - 0x7a, 0x97, 0xdd, 0x10, 0x32, 0x66, 0x29, 0xbf, 0x3b, 0xb8, 0x4e, 0x31, 0x10, 0xa1, 0x4a, 0xb5, - 0xde, 0xe4, 0xb5, 0xde, 0x98, 0x7f, 0x3b, 0xc7, 0xa3, 0xaa, 0xa9, 0xce, 0xc7, 0xc1, 0x52, 0xa5, - 0x69, 0x2e, 0x8e, 0xd9, 0x51, 0x93, 0xc6, 0x37, 0x11, 0x6e, 0x03, 0xbb, 0x66, 0xfb, 0xa7, 0xa7, - 0x21, 0x95, 0x0e, 0x3b, 0x35, 0x84, 0xf5, 0x10, 0x24, 0x99, 0x6f, 0xc6, 0xe1, 0xbb, 0xbc, 0xfe, - 0x50, 0x78, 0xe9, 0x30, 0xe6, 0xfb, 0xd0, 0xb9, 0x14, 0xad, 0x86, 0x8c, 0x05, 0x11, 0xf6, 0x01, - 0xf9, 0x66, 0x5d, 0xa5, 0xcd, 0xbf, 0x21, 0xc2, 0x8a, 0xa4, 0xe7, 0xf7, 0x3e, 0x54, 0x54, 0xad, - 0xc9, 0x1b, 0x56, 0x62, 0xaa, 0x7c, 0x76, 0x8f, 0xa3, 0x32, 0x24, 0xd1, 0x63, 0x7e, 0xb8, 0xd0, - 0xc6, 0xd3, 0xd1, 0x7a, 0xfd, 0x1e, 0x90, 0x53, 0x37, 0x48, 0x23, 0xf3, 0xc3, 0x66, 0x60, 0x8e, - 0x86, 0x6d, 0x1e, 0xc3, 0x8a, 0xa4, 0x12, 0x9a, 0x44, 0x90, 0x5c, 0xbc, 0xdc, 0x4b, 0x88, 0x7c, - 0x7e, 0x8e, 0xc8, 0x9b, 0xbf, 0x51, 0x82, 0xb2, 0x8c, 0x02, 0x9c, 0x15, 0xb9, 0xb6, 0x9a, 0x8c, - 0x5c, 0xdb, 0x4c, 0x44, 0x21, 0xc4, 0xa5, 0x17, 0xf7, 0xfd, 0x3b, 0xe9, 0x2b, 0x5b, 0xb3, 0x55, - 0x24, 0xae, 0x6d, 0x61, 0xab, 0x28, 0x25, 0x6d, 0x15, 0x59, 0xd1, 0x7c, 0x39, 0xeb, 0x39, 0x17, - 0xcd, 0xf7, 0x16, 0x70, 0x3e, 0x42, 0xf3, 0x54, 0xac, 0x20, 0x40, 0xc4, 0x5d, 0xd0, 0xd8, 0x8e, - 0x4a, 0x9a, 0xed, 0x78, 0x65, 0x96, 0xe0, 0x63, 0x58, 0xe0, 0x21, 0x8a, 0xc4, 0x1b, 0x7c, 0x79, - 0x71, 0x88, 0xb9, 0x92, 0xff, 0xf9, 0x03, 0x18, 0x4b, 0xe0, 0xea, 0xa1, 0x31, 0x6b, 0x89, 0xd0, - 0x98, 0xba, 0x0d, 0xa5, 0x9e, 0xb4, 0xa1, 0xdc, 0x03, 0x43, 0x4d, 0x1c, 0x6a, 0x24, 0xbd, 0x50, - 0xbc, 0xbf, 0x5d, 0x94, 0x70, 0x46, 0x0d, 0xbb, 0x61, 0x7c, 0xf1, 0x2d, 0x26, 0x2e, 0x3e, 0x46, - 0xab, 0x5a, 0x51, 0x44, 0x27, 0xd3, 0x48, 0x5e, 0x7c, 0x5a, 0x00, 0x65, 0xbe, 0xf2, 0xfc, 0x81, - 0x90, 0x5c, 0x5e, 0xbe, 0x3b, 0xb6, 0x61, 0xf1, 0xd4, 0x71, 0xc7, 0xb3, 0x80, 0xda, 0x01, 0x75, - 0x42, 0xdf, 0xc3, 0xc3, 0x1f, 0xdf, 0xc1, 0x62, 0x88, 0x7b, 0x1c, 0xc7, 0x42, 0x14, 0xab, 0x71, - 0xaa, 0x27, 0xf1, 0x99, 0x9d, 0x3e, 0x13, 0xec, 0xca, 0x12, 0x2f, 0xf1, 0xb9, 0xe3, 0x51, 0xa7, - 0x6b, 0xef, 0x1d, 0x74, 0x9e, 0xec, 0x0f, 0x8c, 0x1c, 0x4b, 0xf6, 0x8f, 0x77, 0x76, 0xda, 0xed, - 0x5d, 0xbc, 0xc2, 0x00, 0x16, 0xf6, 0x5a, 0x9d, 0x03, 0x71, 0x81, 0x15, 0x8d, 0x92, 0xf9, 0x4f, - 0xf2, 0x50, 0xd3, 0x46, 0x43, 0x1e, 0xa9, 0x45, 0xe0, 0xb1, 0x3f, 0x6e, 0xcf, 0x8f, 0x78, 0x4b, - 0x52, 0x78, 0x6d, 0x15, 0x54, 0xa8, 0xe4, 0xfc, 0xb5, 0xa1, 0x92, 0xc9, 0xdb, 0xb0, 0xe4, 0xf0, - 0x1a, 0xd4, 0xa4, 0x0b, 0xe5, 0xbe, 0x00, 0x8b, 0x39, 0x7f, 0x5b, 0xc4, 0x21, 0x11, 0xd7, 0x14, - 0xc3, 0x2b, 0x4a, 0x0f, 0x5c, 0x75, 0x53, 0xe1, 0xda, 0x94, 0xc5, 0xcc, 0x08, 0x63, 0xbc, 0xba, - 0xf0, 0xc5, 0x7c, 0xc9, 0x6c, 0xfe, 0xf6, 0x56, 0xdb, 0xe1, 0x75, 0x4b, 0xa5, 0xcd, 0x4f, 0x00, - 0xe2, 0xf1, 0x24, 0xa7, 0xef, 0x46, 0x72, 0xfa, 0x72, 0xda, 0xf4, 0xe5, 0xcd, 0x7f, 0x20, 0x48, - 0x97, 0x58, 0x0b, 0xa5, 0xea, 0x7b, 0x1f, 0xa4, 0xf2, 0xd1, 0x46, 0x8f, 0xfd, 0xe9, 0x98, 0x46, - 0xf2, 0xf9, 0xf0, 0xb2, 0xc8, 0xe9, 0xa8, 0x8c, 0x39, 0x52, 0x9b, 0x9f, 0x27, 0xb5, 0x6f, 0x40, - 0x1d, 0x03, 0xdb, 0x89, 0x86, 0x04, 0xb9, 0xaa, 0x4d, 0x9c, 0x4b, 0xd9, 0x76, 0x82, 0xc6, 0x16, - 0x53, 0x34, 0xf6, 0x6f, 0xe6, 0x78, 0x14, 0xa4, 0xb8, 0xa3, 0x31, 0x91, 0x55, 0x75, 0x26, 0x89, - 0xac, 0x40, 0xb5, 0x54, 0xfe, 0x35, 0x84, 0x33, 0x9f, 0x4d, 0x38, 0xb3, 0x49, 0x72, 0x21, 0x93, - 0x24, 0x9b, 0x9b, 0xd0, 0xdc, 0xa5, 0x6c, 0x2a, 0x5a, 0xe3, 0x71, 0x6a, 0x2e, 0xcd, 0x5b, 0x70, - 0x33, 0x23, 0x4f, 0x68, 0x6d, 0x7e, 0x33, 0x07, 0x6b, 0x2d, 0x1e, 0xfc, 0xe4, 0x5b, 0x7b, 0xdf, - 0xfb, 0x39, 0xdc, 0x54, 0xee, 0xf7, 0xda, 0xb3, 0x41, 0x3d, 0x72, 0x95, 0xf4, 0xdc, 0xd7, 0x1e, - 0x9d, 0xb0, 0x3b, 0xd3, 0x6c, 0xc2, 0x7a, 0xba, 0x37, 0xa2, 0xa3, 0x7b, 0xb0, 0xbc, 0x4b, 0x4f, - 0x66, 0x67, 0x07, 0xf4, 0x22, 0xee, 0x23, 0x81, 0x62, 0x78, 0xee, 0x3f, 0x17, 0x1b, 0x03, 0x7f, - 0xa3, 0x7f, 0x2e, 0xc3, 0xb1, 0xc3, 0x29, 0x1d, 0x4a, 0xad, 0x3f, 0x42, 0xfa, 0x53, 0x3a, 0x34, - 0x1f, 0x01, 0xd1, 0xeb, 0x11, 0xab, 0xc8, 0x44, 0xb2, 0xd9, 0x89, 0x1d, 0x5e, 0x85, 0x11, 0x9d, - 0xc8, 0x27, 0xb1, 0x10, 0xce, 0x4e, 0xfa, 0x1c, 0x62, 0xbe, 0x03, 0xf5, 0x23, 0xe7, 0xca, 0xa2, - 0x5f, 0x8b, 0x97, 0xa7, 0x1b, 0x50, 0x9e, 0x3a, 0x57, 0x8c, 0x16, 0x2b, 0x03, 0x20, 0x66, 0x9b, - 0xff, 0xa8, 0x08, 0x0b, 0x1c, 0x93, 0xdc, 0xe5, 0x1f, 0x31, 0x70, 0x3d, 0xa4, 0x85, 0xf2, 0x56, - 0xd2, 0x40, 0x73, 0x17, 0x57, 0x7e, 0xfe, 0xe2, 0x12, 0xda, 0x4a, 0x19, 0x59, 0x4f, 0x9a, 0x6a, - 0xbc, 0xd9, 0x44, 0x86, 0xd3, 0x4b, 0xc6, 0xfe, 0x28, 0xc6, 0x1f, 0xbf, 0xe0, 0x71, 0x0f, 0x92, - 0xc6, 0xf4, 0x58, 0xf0, 0xe3, 0xbd, 0x93, 0xf7, 0xb1, 0xb8, 0xb3, 0x74, 0x50, 0xa6, 0x74, 0x59, - 0x96, 0xcf, 0xa9, 0x93, 0xd2, 0xe5, 0x9c, 0x14, 0x59, 0x79, 0xb9, 0x14, 0xc9, 0xd5, 0x98, 0x2f, - 0x90, 0x22, 0xe1, 0x15, 0xa4, 0xc8, 0x57, 0x30, 0x64, 0xdf, 0x84, 0x0a, 0x32, 0x59, 0xda, 0x15, - 0xc6, 0x98, 0x2b, 0x76, 0x85, 0x7d, 0xaa, 0xc9, 0x59, 0xdc, 0x8b, 0x46, 0xbb, 0x43, 0x2c, 0xfa, - 0xf5, 0xcf, 0xc6, 0x40, 0xf8, 0x15, 0x94, 0x05, 0x94, 0x6d, 0x68, 0xcf, 0x99, 0xc8, 0xf8, 0xb1, - 0xf8, 0x9b, 0x4d, 0x1b, 0x46, 0x54, 0xfc, 0x7a, 0xe6, 0x06, 0x74, 0x24, 0xe3, 0xba, 0xb9, 0x78, - 0xbe, 0x19, 0x84, 0x0d, 0x90, 0xc9, 0x7c, 0x9e, 0xff, 0xdc, 0x13, 0x74, 0xab, 0xec, 0x86, 0x4f, - 0x59, 0xd2, 0x24, 0x60, 0x60, 0x04, 0xec, 0xa9, 0x1f, 0x48, 0x0e, 0xc1, 0xfc, 0xdd, 0x1c, 0x18, - 0xe2, 0x74, 0xa9, 0x3c, 0x5d, 0xe4, 0x2a, 0x5d, 0xe7, 0xf4, 0xf1, 0xe2, 0x28, 0x6d, 0x26, 0x34, - 0x50, 0xd3, 0xa4, 0xd8, 0x05, 0xae, 0x29, 0xab, 0x31, 0xe0, 0x9e, 0x60, 0x19, 0x5e, 0x87, 0x9a, - 0x7c, 0x3d, 0x30, 0x71, 0xc7, 0xf2, 0x3b, 0x37, 0xfc, 0xf9, 0xc0, 0xa1, 0x3b, 0x96, 0xdc, 0x46, - 0xe0, 0x88, 0xe7, 0xfd, 0x39, 0xe4, 0x36, 0x2c, 0x27, 0xa2, 0xe6, 0x3f, 0xce, 0xc1, 0xb2, 0x36, - 0x14, 0x71, 0x6e, 0xbf, 0x07, 0x75, 0x15, 0x7a, 0x9e, 0x2a, 0x36, 0x77, 0x23, 0x49, 0xa3, 0xe2, - 0x62, 0xb5, 0xa1, 0x82, 0x84, 0xac, 0x33, 0x23, 0xe7, 0x8a, 0xbb, 0xb8, 0xcf, 0x26, 0x52, 0x92, - 0x1c, 0x39, 0x57, 0x7b, 0x94, 0xf6, 0x67, 0x13, 0x72, 0x17, 0xea, 0xcf, 0x29, 0x7d, 0xa6, 0x10, - 0x38, 0xe9, 0x05, 0x06, 0x13, 0x18, 0x26, 0x34, 0x26, 0xbe, 0x17, 0x9d, 0x2b, 0x14, 0xc1, 0xe2, - 0x23, 0x90, 0xe3, 0x98, 0x7f, 0x90, 0x87, 0x15, 0xae, 0xcf, 0x14, 0x7a, 0x64, 0x41, 0xba, 0x9a, - 0xb0, 0xc0, 0x55, 0xbb, 0x9c, 0x78, 0xed, 0xdf, 0xb0, 0x44, 0x9a, 0x7c, 0xfc, 0x8a, 0x3a, 0x58, - 0x19, 0x41, 0xe0, 0x9a, 0xe9, 0x2f, 0xcc, 0x4f, 0xff, 0xf5, 0xd3, 0x9b, 0x65, 0x55, 0x2e, 0x65, - 0x59, 0x95, 0x5f, 0xc5, 0x96, 0x3b, 0xf7, 0xd6, 0xbd, 0x3c, 0x1f, 0x12, 0xf6, 0x11, 0x6c, 0x24, - 0x70, 0x90, 0x5a, 0xbb, 0xa7, 0xae, 0x8a, 0x37, 0xbe, 0xaa, 0x61, 0xf7, 0x65, 0xde, 0x76, 0x19, - 0x4a, 0xe1, 0xd0, 0x9f, 0x52, 0x73, 0x1d, 0x56, 0x93, 0xb3, 0x2a, 0xae, 0x89, 0xdf, 0xce, 0x41, - 0x73, 0x2f, 0x8e, 0xad, 0xeb, 0x86, 0x91, 0x1f, 0xa8, 0x10, 0xed, 0xb7, 0x01, 0xf8, 0x37, 0x77, - 0x50, 0x70, 0x17, 0x51, 0x92, 0x10, 0x82, 0x62, 0xfb, 0x4d, 0xa8, 0x50, 0x6f, 0xc4, 0x33, 0xf9, - 0x6e, 0x28, 0x53, 0x6f, 0x24, 0x85, 0xfe, 0xb9, 0x6b, 0xb8, 0x91, 0x64, 0x30, 0x44, 0xbc, 0x0f, - 0x36, 0x3b, 0xf4, 0x02, 0xd9, 0x81, 0xa2, 0x8a, 0xf7, 0x71, 0xe8, 0x5c, 0xa2, 0x7b, 0x74, 0x68, - 0xfe, 0xe5, 0x3c, 0x2c, 0xc5, 0xfd, 0xe3, 0x11, 0x8f, 0x5e, 0x1c, 0xbb, 0xe9, 0xae, 0xd8, 0x0e, - 0x2e, 0x13, 0x96, 0x34, 0x2d, 0x6f, 0x85, 0x1f, 0xce, 0x8e, 0x47, 0x4c, 0xa8, 0x49, 0x0c, 0x7f, - 0x16, 0x69, 0x61, 0x6c, 0xab, 0x1c, 0xa5, 0x37, 0x8b, 0x98, 0x74, 0xcb, 0xc4, 0x7c, 0xd7, 0x13, - 0xf2, 0x65, 0xc9, 0x99, 0x44, 0x1d, 0xfc, 0xb0, 0x13, 0x03, 0xb3, 0x62, 0x7c, 0x21, 0x19, 0x16, - 0xc3, 0x37, 0xb8, 0xb0, 0xc3, 0x57, 0x0e, 0x05, 0x1d, 0x5d, 0x12, 0xe0, 0xdf, 0xa2, 0x50, 0x92, - 0xc0, 0xeb, 0x50, 0xe3, 0x95, 0xc7, 0xa1, 0x0d, 0x30, 0xa6, 0x5c, 0xd4, 0xf1, 0x30, 0x5f, 0x68, - 0xdc, 0xfc, 0x59, 0x42, 0xcf, 0x00, 0xbc, 0x29, 0x74, 0xb1, 0xf9, 0xcd, 0x1c, 0xdc, 0xcc, 0x58, - 0x36, 0x71, 0xca, 0x77, 0x40, 0x8b, 0xb0, 0x2c, 0x67, 0x97, 0x1f, 0xf5, 0x75, 0x49, 0x56, 0x93, - 0x73, 0x6a, 0x19, 0xa7, 0x49, 0x40, 0x2c, 0xe1, 0xf2, 0x15, 0x4c, 0x04, 0xce, 0x40, 0x76, 0x8a, - 0x2f, 0x23, 0x17, 0x2e, 0x8f, 0x60, 0xb3, 0x7d, 0xc9, 0x28, 0x86, 0x72, 0x99, 0x1e, 0x3e, 0x9b, - 0x49, 0xcb, 0x57, 0x4a, 0x9b, 0x9f, 0x7b, 0x25, 0x6d, 0xfe, 0x88, 0x3f, 0x6b, 0x57, 0x75, 0xfd, - 0x34, 0x95, 0xe0, 0x05, 0xca, 0xca, 0x9c, 0x60, 0x15, 0x32, 0x82, 0x06, 0x03, 0xf1, 0x4a, 0xcd, - 0x10, 0x96, 0x0e, 0x67, 0xe3, 0xc8, 0xdd, 0x51, 0x20, 0xf2, 0xb1, 0x28, 0x83, 0xed, 0xc8, 0x59, - 0xcb, 0x6c, 0x08, 0x54, 0x43, 0x38, 0x59, 0x13, 0x56, 0x91, 0x3d, 0xdf, 0xde, 0xd2, 0x24, 0xd9, - 0x82, 0x79, 0x13, 0x36, 0xe2, 0x14, 0x9f, 0x36, 0x79, 0xd5, 0xfc, 0xad, 0x1c, 0x7f, 0x8b, 0xc1, - 0xf3, 0xfa, 0x9e, 0x33, 0x0d, 0xcf, 0xfd, 0x88, 0xb4, 0x61, 0x25, 0x74, 0xbd, 0xb3, 0x31, 0xd5, - 0xab, 0x0f, 0xc5, 0x24, 0xac, 0x25, 0xfb, 0xc6, 0x8b, 0x86, 0xd6, 0x32, 0x2f, 0x11, 0xd7, 0x16, - 0x92, 0xed, 0xeb, 0x3a, 0x19, 0x6f, 0x8b, 0xd4, 0x6c, 0xcc, 0x77, 0xbe, 0x03, 0x8b, 0xc9, 0x86, - 0xc8, 0xa7, 0x22, 0x1a, 0x44, 0xdc, 0xab, 0x42, 0xea, 0x2d, 0x7c, 0xbc, 0x21, 0x6a, 0xf1, 0xdc, - 0x87, 0xe6, 0x5f, 0xcc, 0x41, 0xd3, 0xa2, 0x6c, 0xe7, 0x6a, 0xbd, 0x94, 0x7b, 0xe6, 0x7b, 0x73, - 0xb5, 0x5e, 0x3f, 0x56, 0x19, 0x64, 0x42, 0xf6, 0xe8, 0xbd, 0x6b, 0x17, 0x63, 0xff, 0xc6, 0xdc, - 0x88, 0xb6, 0x2b, 0xb0, 0xc0, 0x51, 0xcc, 0x0d, 0x58, 0x13, 0xfd, 0x91, 0x7d, 0x89, 0x4d, 0xb5, - 0x89, 0x16, 0x13, 0xa6, 0xda, 0x4d, 0x68, 0xf2, 0x47, 0xdb, 0xfa, 0x20, 0x44, 0xc1, 0x5d, 0x20, - 0x87, 0xce, 0xd0, 0x09, 0x7c, 0xdf, 0x3b, 0xa2, 0x81, 0x70, 0x86, 0x46, 0x0e, 0x13, 0x2d, 0x99, - 0x92, 0x15, 0xe6, 0x29, 0x19, 0xbc, 0xdb, 0xf7, 0xa4, 0xef, 0x17, 0x4f, 0x99, 0x01, 0xac, 0x6c, - 0x3b, 0xcf, 0xa8, 0xac, 0x49, 0x4e, 0xd1, 0x63, 0xa8, 0x4d, 0x55, 0xa5, 0x72, 0xde, 0x65, 0x00, - 0x9d, 0xf9, 0x66, 0x2d, 0x1d, 0x9b, 0x91, 0xa0, 0xc0, 0xf7, 0x23, 0x0c, 0x44, 0x21, 0x8d, 0x61, - 0x56, 0x95, 0x81, 0x9e, 0xd2, 0xab, 0xce, 0xc8, 0x7c, 0x08, 0xab, 0xc9, 0x36, 0x05, 0x69, 0xd9, - 0x84, 0xca, 0x44, 0xc0, 0x44, 0xef, 0x55, 0x9a, 0x09, 0x23, 0x4c, 0xe4, 0x93, 0x65, 0x3a, 0xbb, - 0x4a, 0xa4, 0x7a, 0x0c, 0x1b, 0x73, 0x39, 0xa2, 0xc2, 0xbb, 0x50, 0xd7, 0x3a, 0xc2, 0x87, 0x51, - 0x64, 0x2c, 0xab, 0xe8, 0x49, 0x68, 0x7e, 0x0e, 0x1b, 0x5c, 0x1e, 0x8b, 0x8b, 0xcb, 0x29, 0x48, - 0x8d, 0x22, 0x97, 0x1e, 0xc5, 0xc7, 0x52, 0xcc, 0xd3, 0x8b, 0xc6, 0x81, 0xe9, 0x46, 0x98, 0x27, - 0xdd, 0x77, 0x64, 0xd2, 0x3c, 0x86, 0xf5, 0xf9, 0xe9, 0x63, 0xfd, 0xff, 0x53, 0x4d, 0xb9, 0x9c, - 0x9e, 0x38, 0x5b, 0x4d, 0xcf, 0x7f, 0xcd, 0xf1, 0xf9, 0x49, 0x64, 0x89, 0x6e, 0x8e, 0x80, 0x4c, - 0x68, 0x74, 0xee, 0x8f, 0xec, 0xf9, 0x96, 0x1f, 0x29, 0xef, 0xa1, 0xcc, 0xb2, 0x5b, 0x87, 0x58, - 0x50, 0xcb, 0x11, 0x7e, 0xec, 0x93, 0x34, 0x7c, 0x73, 0x08, 0xeb, 0xd9, 0xc8, 0x19, 0x3e, 0x37, - 0x1f, 0x25, 0x19, 0xf5, 0xdb, 0xd7, 0x0e, 0x9f, 0x75, 0x4b, 0xe7, 0xdb, 0x7f, 0xab, 0x02, 0x65, - 0xa1, 0x25, 0x21, 0x5b, 0x50, 0x1c, 0x4a, 0xff, 0xcd, 0x38, 0x38, 0xa1, 0xc8, 0x95, 0xff, 0x77, - 0xd0, 0x8b, 0x93, 0xe1, 0x91, 0xc7, 0xb0, 0x98, 0x74, 0x61, 0x48, 0x05, 0x25, 0x49, 0xfa, 0x1e, - 0x34, 0x86, 0x29, 0x63, 0x75, 0x35, 0x66, 0xae, 0x38, 0xcf, 0x59, 0x39, 0xd7, 0xb8, 0x2f, 0xdf, - 0x63, 0xf2, 0x5a, 0x78, 0xee, 0xd8, 0x0f, 0x1f, 0x7d, 0x22, 0xa2, 0x92, 0xd4, 0x10, 0xd8, 0x3f, - 0x77, 0x1e, 0x3e, 0xfa, 0x24, 0x2d, 0x89, 0x89, 0x98, 0x24, 0x9a, 0x24, 0xb6, 0x0a, 0x25, 0x1e, - 0xe1, 0x9c, 0x3b, 0xe2, 0xf1, 0x04, 0x79, 0x00, 0xab, 0x52, 0xf1, 0x26, 0x9e, 0x4c, 0xf0, 0x5b, - 0xb4, 0xc2, 0x9f, 0x1c, 0x8b, 0xbc, 0x3e, 0x66, 0x71, 0x55, 0xdd, 0x3a, 0x2c, 0x9c, 0xc7, 0x21, - 0xeb, 0x1b, 0x96, 0x48, 0x99, 0x7f, 0x50, 0x82, 0x9a, 0x36, 0x29, 0xa4, 0x0e, 0x15, 0xab, 0xdd, - 0x6f, 0x5b, 0x5f, 0xb4, 0x77, 0x8d, 0x1b, 0xe4, 0x1e, 0xbc, 0xd5, 0xe9, 0xee, 0xf4, 0x2c, 0xab, - 0xbd, 0x33, 0xb0, 0x7b, 0x96, 0x2d, 0x43, 0x64, 0x1e, 0xb5, 0xbe, 0x3a, 0x6c, 0x77, 0x07, 0xf6, - 0x6e, 0x7b, 0xd0, 0xea, 0x1c, 0xf4, 0x8d, 0x1c, 0x79, 0x0d, 0x9a, 0x31, 0xa6, 0xcc, 0x6e, 0x1d, - 0xf6, 0x8e, 0xbb, 0x03, 0x23, 0x4f, 0xee, 0xc0, 0xad, 0xbd, 0x4e, 0xb7, 0x75, 0x60, 0xc7, 0x38, - 0x3b, 0x07, 0x83, 0x2f, 0xec, 0xf6, 0xcf, 0x1f, 0x75, 0xac, 0xaf, 0x8c, 0x42, 0x16, 0xc2, 0xfe, - 0xe0, 0x60, 0x47, 0xd6, 0x50, 0x24, 0x37, 0x61, 0x8d, 0x23, 0xf0, 0x22, 0xf6, 0xa0, 0xd7, 0xb3, - 0xfb, 0xbd, 0x5e, 0xd7, 0x28, 0x91, 0x65, 0x68, 0x74, 0xba, 0x5f, 0xb4, 0x0e, 0x3a, 0xbb, 0xb6, - 0xd5, 0x6e, 0x1d, 0x1c, 0x1a, 0x0b, 0x64, 0x05, 0x96, 0xd2, 0x78, 0x65, 0x56, 0x85, 0xc4, 0xeb, - 0x75, 0x3b, 0xbd, 0xae, 0xfd, 0x45, 0xdb, 0xea, 0x77, 0x7a, 0x5d, 0xa3, 0x42, 0xd6, 0x81, 0x24, - 0xb3, 0xf6, 0x0f, 0x5b, 0x3b, 0x46, 0x95, 0xac, 0xc1, 0x72, 0x12, 0xfe, 0xb4, 0xfd, 0x95, 0x01, - 0xa4, 0x09, 0xab, 0xbc, 0x63, 0xf6, 0x76, 0xfb, 0xa0, 0xf7, 0xa5, 0x7d, 0xd8, 0xe9, 0x76, 0x0e, - 0x8f, 0x0f, 0x8d, 0x1a, 0x06, 0x2a, 0x6e, 0xb7, 0xed, 0x4e, 0xb7, 0x7f, 0xbc, 0xb7, 0xd7, 0xd9, - 0xe9, 0xb4, 0xbb, 0x03, 0xa3, 0xce, 0x5b, 0xce, 0x1a, 0x78, 0x83, 0x15, 0x10, 0x8f, 0xe4, 0xec, - 0xdd, 0x4e, 0xbf, 0xb5, 0x7d, 0xd0, 0xde, 0x35, 0x16, 0xc9, 0x6d, 0xb8, 0x39, 0x68, 0x1f, 0x1e, - 0xf5, 0xac, 0x96, 0xf5, 0x95, 0x7c, 0x44, 0x67, 0xef, 0xb5, 0x3a, 0x07, 0xc7, 0x56, 0xdb, 0x58, - 0x22, 0x6f, 0xc0, 0x6d, 0xab, 0xfd, 0xe3, 0xe3, 0x8e, 0xd5, 0xde, 0xb5, 0xbb, 0xbd, 0xdd, 0xb6, - 0xbd, 0xd7, 0x6e, 0x0d, 0x8e, 0xad, 0xb6, 0x7d, 0xd8, 0xe9, 0xf7, 0x3b, 0xdd, 0x27, 0x86, 0x41, - 0xde, 0x82, 0xbb, 0x0a, 0x45, 0x55, 0x90, 0xc2, 0x5a, 0x66, 0xe3, 0x93, 0x4b, 0xda, 0x6d, 0xff, - 0xfc, 0xc0, 0x3e, 0x6a, 0xb7, 0x2d, 0x83, 0x90, 0x4d, 0x58, 0x8f, 0x9b, 0xe7, 0x0d, 0x88, 0xb6, - 0x57, 0x58, 0xde, 0x51, 0xdb, 0x3a, 0x6c, 0x75, 0xd9, 0x02, 0x27, 0xf2, 0x56, 0x59, 0xb7, 0xe3, - 0xbc, 0x74, 0xb7, 0xd7, 0x08, 0x81, 0x45, 0x6d, 0x55, 0xf6, 0x5a, 0x96, 0xb1, 0x4e, 0x96, 0xa0, - 0x76, 0x78, 0x74, 0x64, 0x0f, 0x3a, 0x87, 0xed, 0xde, 0xf1, 0xc0, 0xd8, 0x20, 0x6b, 0x60, 0x74, - 0xba, 0x83, 0xb6, 0xc5, 0xd6, 0x5a, 0x16, 0xfd, 0x6f, 0x65, 0xb2, 0x0a, 0x4b, 0xb2, 0xa7, 0x12, - 0xfa, 0xc7, 0x65, 0xb2, 0x01, 0xe4, 0xb8, 0x6b, 0xb5, 0x5b, 0xbb, 0x6c, 0xe2, 0x54, 0xc6, 0x7f, - 0x2f, 0x0b, 0x73, 0xe6, 0xef, 0x16, 0x14, 0xb3, 0x17, 0xfb, 0x07, 0x25, 0xbf, 0x31, 0x53, 0xd7, - 0xbe, 0x0d, 0xf3, 0xb2, 0xaf, 0xd7, 0x69, 0xa2, 0x79, 0x61, 0x4e, 0x34, 0x9f, 0xd3, 0xfd, 0x34, - 0x74, 0xd9, 0xe1, 0x4d, 0x68, 0x4c, 0xf8, 0xf7, 0x66, 0xc4, 0x07, 0x0b, 0x40, 0x38, 0xcb, 0x71, - 0x20, 0xff, 0x5a, 0xc1, 0xdc, 0xe7, 0xdb, 0x4a, 0xf3, 0x9f, 0x6f, 0xcb, 0x92, 0x0f, 0x17, 0xb2, - 0xe4, 0xc3, 0xfb, 0xb0, 0xcc, 0x49, 0x93, 0xeb, 0xb9, 0x13, 0xa9, 0x75, 0xe1, 0x52, 0xc4, 0x12, - 0x92, 0x28, 0x0e, 0x97, 0xe2, 0xa8, 0x14, 0x59, 0x05, 0x09, 0x29, 0x0b, 0x69, 0x35, 0x21, 0xa9, - 0x72, 0xca, 0xa1, 0x24, 0x55, 0xd5, 0x82, 0x73, 0x19, 0xb7, 0x50, 0xd3, 0x5a, 0xe0, 0x70, 0x6c, - 0xe1, 0x3e, 0x2c, 0xd3, 0xcb, 0x28, 0x70, 0x6c, 0x7f, 0xea, 0x7c, 0x3d, 0x43, 0x7f, 0x0b, 0x07, - 0x75, 0x40, 0x75, 0x6b, 0x09, 0x33, 0x7a, 0x08, 0xdf, 0x75, 0x22, 0xc7, 0xfc, 0x25, 0x00, 0x75, - 0xab, 0x8e, 0x18, 0x01, 0xf4, 0x7c, 0xf9, 0x24, 0xb2, 0x6e, 0xf1, 0x04, 0xae, 0x63, 0xe4, 0x07, - 0xce, 0x19, 0xed, 0xc8, 0xc0, 0x3e, 0x31, 0x80, 0xdc, 0x82, 0x82, 0x3f, 0x95, 0xae, 0x64, 0x55, - 0x19, 0x81, 0x7b, 0x6a, 0x31, 0xa8, 0xf9, 0x09, 0xe4, 0x7b, 0xd3, 0x6b, 0x59, 0xa5, 0x26, 0x94, - 0xe5, 0x07, 0x5b, 0xf3, 0xe8, 0x3e, 0x26, 0x93, 0xf7, 0xff, 0x2c, 0xd4, 0xb4, 0x4f, 0x24, 0x91, - 0x0d, 0x58, 0xf9, 0xb2, 0x33, 0xe8, 0xb6, 0xfb, 0x7d, 0xfb, 0xe8, 0x78, 0xfb, 0x69, 0xfb, 0x2b, - 0x7b, 0xbf, 0xd5, 0xdf, 0x37, 0x6e, 0x30, 0x5a, 0xd2, 0x6d, 0xf7, 0x07, 0xed, 0xdd, 0x04, 0x3c, - 0x47, 0x5e, 0x87, 0xcd, 0xe3, 0xee, 0x71, 0xbf, 0xbd, 0x6b, 0x67, 0x95, 0xcb, 0xb3, 0xc3, 0x23, - 0xf2, 0x33, 0x8a, 0x17, 0xee, 0xff, 0x32, 0x2c, 0x26, 0xc3, 0x5c, 0x10, 0x80, 0x85, 0x83, 0xf6, - 0x93, 0xd6, 0xce, 0x57, 0x3c, 0xc2, 0x7a, 0x7f, 0xd0, 0x1a, 0x74, 0x76, 0x6c, 0x11, 0x51, 0x9d, - 0x11, 0xaa, 0x1c, 0xa9, 0x41, 0xb9, 0xd5, 0xdd, 0xd9, 0xef, 0x59, 0x7d, 0x23, 0x4f, 0x5e, 0x83, - 0x0d, 0x79, 0x84, 0x76, 0x7a, 0x87, 0x87, 0x9d, 0x01, 0xd2, 0xe8, 0xc1, 0x57, 0x47, 0xec, 0xc4, - 0xdc, 0x77, 0xa0, 0x1a, 0x07, 0x83, 0x47, 0xba, 0xd7, 0x19, 0x74, 0x5a, 0x83, 0x98, 0xe8, 0x1b, - 0x37, 0x18, 0x59, 0x8d, 0xc1, 0x18, 0xd1, 0xdd, 0xc8, 0xf1, 0x97, 0xc0, 0x12, 0xc8, 0x5b, 0x37, - 0xf2, 0xec, 0xac, 0xc7, 0xd0, 0xed, 0xde, 0x80, 0x0d, 0xe1, 0x57, 0x60, 0x31, 0x19, 0x73, 0x9d, - 0x18, 0x50, 0x67, 0xed, 0x6b, 0x4d, 0x00, 0x2c, 0xf0, 0x1e, 0x1b, 0x39, 0x4e, 0xd8, 0x77, 0x7a, - 0x87, 0x9d, 0xee, 0x13, 0xbc, 0x0d, 0x8c, 0x3c, 0x03, 0xf5, 0x8e, 0x07, 0x4f, 0x7a, 0x0a, 0x54, - 0x60, 0x25, 0xf8, 0x70, 0x8c, 0xe2, 0xfd, 0xaf, 0x61, 0x79, 0x2e, 0x3a, 0x3b, 0xeb, 0x75, 0xef, - 0x78, 0xb0, 0xd3, 0x3b, 0xd4, 0xdb, 0xa9, 0x41, 0x79, 0xe7, 0xa0, 0xd5, 0x39, 0x44, 0x43, 0x48, - 0x03, 0xaa, 0xc7, 0x5d, 0x99, 0xcc, 0x27, 0xe3, 0xca, 0x17, 0x18, 0x89, 0xda, 0xeb, 0x58, 0xfd, - 0x81, 0xdd, 0x1f, 0xb4, 0x9e, 0xb4, 0x8d, 0x22, 0x2b, 0x2b, 0xe9, 0x55, 0xe9, 0xfe, 0xe7, 0xb0, - 0x98, 0xf4, 0x7b, 0x4e, 0x1a, 0xb0, 0x36, 0x61, 0x7d, 0xbb, 0x3d, 0xf8, 0xb2, 0xdd, 0xee, 0xe2, - 0x92, 0xef, 0xb4, 0xbb, 0x03, 0xab, 0x75, 0xd0, 0x19, 0x7c, 0x65, 0xe4, 0xee, 0x3f, 0x06, 0x23, - 0xed, 0x64, 0x90, 0xf0, 0xca, 0x78, 0x91, 0xfb, 0xc6, 0xfd, 0xff, 0x94, 0x83, 0xd5, 0x2c, 0xfb, - 0x1a, 0xdb, 0x98, 0x82, 0x10, 0xb2, 0xeb, 0xb0, 0xdf, 0xeb, 0xda, 0xdd, 0x1e, 0x06, 0x5a, 0xde, - 0x84, 0xf5, 0x54, 0x86, 0x1c, 0x45, 0x8e, 0xdc, 0x82, 0x8d, 0xb9, 0x42, 0xb6, 0xd5, 0x3b, 0xc6, - 0xb5, 0x6c, 0xc2, 0x6a, 0x2a, 0xb3, 0x6d, 0x59, 0x3d, 0xcb, 0x28, 0x90, 0xf7, 0xe0, 0x5e, 0x2a, - 0x67, 0x9e, 0x09, 0x90, 0x3c, 0x42, 0x91, 0xbc, 0x03, 0x6f, 0xce, 0x61, 0xc7, 0xf7, 0xa4, 0xbd, - 0xdd, 0x3a, 0x60, 0xc3, 0x33, 0x4a, 0xf7, 0xff, 0x7e, 0x01, 0x20, 0x7e, 0x58, 0xc8, 0xda, 0xdf, - 0x6d, 0x0d, 0x5a, 0x07, 0x3d, 0x76, 0x66, 0xac, 0xde, 0x80, 0xd5, 0x6e, 0xb5, 0x7f, 0x6c, 0xdc, - 0xc8, 0xcc, 0xe9, 0x1d, 0xb1, 0x01, 0x6d, 0xc0, 0x0a, 0xdf, 0x7f, 0x07, 0x6c, 0x18, 0x6c, 0xbb, - 0x60, 0xcc, 0x6e, 0xe4, 0x34, 0x8e, 0x8f, 0xf6, 0xac, 0x5e, 0x77, 0x60, 0xf7, 0xf7, 0x8f, 0x07, - 0xbb, 0x18, 0xf1, 0x7b, 0xc7, 0xea, 0x1c, 0xf1, 0x3a, 0x8b, 0x2f, 0x42, 0x60, 0x55, 0x97, 0xd8, - 0x01, 0x7f, 0xd2, 0xeb, 0xf7, 0x3b, 0x47, 0xf6, 0x8f, 0x8f, 0xdb, 0x56, 0xa7, 0xdd, 0xc7, 0x82, - 0x0b, 0x19, 0x70, 0x86, 0x5f, 0x66, 0x7b, 0x76, 0x70, 0xf0, 0x85, 0x60, 0x20, 0x18, 0x6a, 0x25, - 0x09, 0x62, 0x58, 0x55, 0xb6, 0x3a, 0xec, 0x06, 0xce, 0xa8, 0x19, 0xae, 0xc9, 0x63, 0xe5, 0x6a, - 0x8c, 0xb7, 0x98, 0x3b, 0xf9, 0x58, 0xac, 0x9e, 0x9d, 0xc5, 0x4a, 0x21, 0xdb, 0xa1, 0x98, 0xb4, - 0xdd, 0x5d, 0x0b, 0x0b, 0x2c, 0xce, 0x41, 0x19, 0xee, 0x12, 0xdb, 0x84, 0xec, 0x8a, 0x66, 0x28, - 0x86, 0x4c, 0xb0, 0x9c, 0xe5, 0x87, 0xff, 0xe2, 0x0d, 0xa8, 0xaa, 0x07, 0x06, 0xe4, 0x47, 0xd0, - 0x48, 0x3c, 0xdf, 0x27, 0x52, 0x85, 0x9f, 0xf5, 0xda, 0x7f, 0xf3, 0xb5, 0xec, 0x4c, 0x21, 0x9c, - 0x1c, 0x6a, 0xda, 0x00, 0x5e, 0xd9, 0x6b, 0x69, 0x09, 0x3d, 0x51, 0xdb, 0xed, 0x6b, 0x72, 0x45, - 0x75, 0x4f, 0x31, 0x7c, 0xb8, 0xfe, 0xf5, 0x6f, 0x72, 0x3b, 0x8e, 0xe5, 0x9c, 0xf1, 0x55, 0xf0, - 0xcd, 0x9b, 0xf3, 0xdf, 0xe9, 0x96, 0x1f, 0xf6, 0xde, 0x85, 0x9a, 0xf6, 0x51, 0x4b, 0x72, 0xf3, - 0xda, 0x0f, 0x70, 0x6e, 0x6e, 0x66, 0x65, 0x89, 0x2e, 0x7d, 0x1f, 0xaa, 0xea, 0x63, 0x82, 0x64, - 0x43, 0xfb, 0x38, 0xa5, 0xfe, 0x71, 0xc5, 0xcd, 0xe6, 0x7c, 0x86, 0x28, 0xbf, 0x0b, 0x35, 0xed, - 0x9b, 0x80, 0xaa, 0x17, 0xf3, 0xdf, 0x1d, 0x54, 0xbd, 0xc8, 0xfa, 0x84, 0xe0, 0x01, 0xac, 0x09, - 0x9d, 0xc3, 0x09, 0xfd, 0x26, 0xd3, 0x93, 0xf1, 0x19, 0xf3, 0x07, 0x39, 0xf2, 0x18, 0x2a, 0xf2, - 0x3b, 0x92, 0x64, 0x3d, 0xfb, 0x7b, 0x9b, 0x9b, 0x1b, 0x73, 0x70, 0xd1, 0x95, 0x16, 0x40, 0xfc, - 0xb5, 0x41, 0x22, 0x07, 0x3e, 0xf7, 0xf5, 0x42, 0xb5, 0x32, 0x19, 0x9f, 0x26, 0xdc, 0x85, 0x9a, - 0xf6, 0x61, 0x41, 0x35, 0x27, 0xf3, 0x1f, 0x25, 0x54, 0x73, 0x92, 0xf5, 0x1d, 0xc2, 0x1f, 0x41, - 0x23, 0xf1, 0x85, 0x40, 0xb5, 0x8f, 0xb3, 0xbe, 0x3f, 0xa8, 0xf6, 0x71, 0xf6, 0x47, 0x05, 0x77, - 0xa1, 0xa6, 0x7d, 0xb5, 0x4f, 0xf5, 0x68, 0xfe, 0xd3, 0x81, 0xaa, 0x47, 0x19, 0x1f, 0xf9, 0x63, - 0xa7, 0x21, 0xf9, 0xc9, 0x3e, 0x75, 0x1a, 0x32, 0xbf, 0xfd, 0xa7, 0x4e, 0x43, 0xf6, 0x77, 0xfe, - 0xd8, 0xd6, 0x53, 0xdf, 0x0d, 0x20, 0x1b, 0x09, 0x51, 0x3f, 0xfe, 0x00, 0x81, 0xda, 0x7a, 0xf3, - 0x9f, 0x18, 0x78, 0x02, 0x2b, 0x6a, 0xd3, 0xa8, 0xa8, 0xff, 0xa1, 0xea, 0x53, 0xe6, 0xb7, 0x05, - 0x36, 0x8d, 0x74, 0xee, 0x83, 0x1c, 0xf9, 0x0c, 0xca, 0x22, 0x94, 0x3a, 0x59, 0x4b, 0x87, 0x56, - 0xe7, 0x9d, 0x58, 0xcf, 0x8e, 0xb8, 0x4e, 0x8e, 0xf0, 0x40, 0xeb, 0xb1, 0xce, 0xf5, 0x1d, 0x9b, - 0x11, 0x1e, 0x7d, 0xf3, 0xf5, 0xeb, 0xb2, 0xe3, 0x1a, 0xd3, 0xf1, 0xf9, 0x6f, 0x5f, 0x17, 0x56, - 0x27, 0x59, 0xe3, 0x75, 0xf1, 0xff, 0x9e, 0x40, 0x5d, 0xff, 0x5c, 0x13, 0xd1, 0xcf, 0x61, 0xba, - 0xae, 0x5b, 0x99, 0x79, 0xa2, 0xa2, 0x2f, 0x60, 0x5d, 0xcd, 0xb7, 0x1e, 0xe3, 0x25, 0x24, 0x77, - 0x32, 0x22, 0xbf, 0x24, 0x66, 0xfd, 0xe6, 0xb5, 0xa1, 0x61, 0x1e, 0xe4, 0x90, 0xc8, 0x26, 0xbe, - 0xb0, 0x12, 0x13, 0xd9, 0xac, 0x0f, 0xcb, 0xc4, 0x44, 0x36, 0xfb, 0xb3, 0x2c, 0x2d, 0x58, 0xd2, - 0x62, 0xd4, 0xf4, 0xaf, 0xbc, 0xa1, 0xda, 0xef, 0xf3, 0x41, 0xa8, 0x37, 0xb3, 0x34, 0xdf, 0x64, - 0x07, 0x6a, 0x7a, 0x98, 0x9b, 0x17, 0x14, 0xdf, 0xd0, 0xb2, 0xf4, 0x18, 0xc2, 0x0f, 0x72, 0xe4, - 0x00, 0x8c, 0x74, 0x50, 0x4a, 0x75, 0x84, 0xb3, 0x02, 0x79, 0x6e, 0xa6, 0x32, 0x13, 0xa1, 0x2c, - 0xd9, 0xbe, 0x48, 0x7c, 0x2e, 0xdb, 0x0f, 0xd2, 0x57, 0x51, 0xf2, 0x33, 0xda, 0xaa, 0xb6, 0xac, - 0x0f, 0xa8, 0xdf, 0xcb, 0x3d, 0xc8, 0x91, 0x3d, 0xa8, 0x27, 0x62, 0xb2, 0x25, 0xde, 0xba, 0xa4, - 0x86, 0xd9, 0xd4, 0xf3, 0x52, 0xe3, 0x3c, 0x84, 0xc5, 0xa4, 0x8b, 0x86, 0xea, 0x58, 0xa6, 0x1f, - 0x89, 0x5a, 0xbe, 0x6c, 0xbf, 0x0e, 0xf2, 0x03, 0xa8, 0x31, 0x9a, 0x2c, 0x5d, 0xf9, 0x88, 0x46, - 0xa7, 0xd3, 0x6b, 0xa6, 0x7f, 0x6a, 0xdf, 0x2c, 0xfc, 0x85, 0x7c, 0x0e, 0xc7, 0xf5, 0x3d, 0xfe, - 0x29, 0x66, 0xe9, 0xcd, 0xc5, 0xd6, 0xff, 0x55, 0x2b, 0x21, 0x7b, 0xbc, 0x71, 0xf1, 0x21, 0xfc, - 0x98, 0x72, 0xcf, 0x7d, 0x1c, 0xff, 0x25, 0x7d, 0x68, 0xf1, 0x3e, 0x88, 0x32, 0x89, 0x3d, 0xf8, - 0x8a, 0x75, 0x91, 0x4f, 0x01, 0x62, 0x17, 0x59, 0x92, 0x72, 0xd4, 0x54, 0x07, 0x2a, 0xc3, 0x8b, - 0xb6, 0xcd, 0xcf, 0xbb, 0xf2, 0x14, 0xd5, 0xaf, 0xe4, 0xa4, 0xd3, 0x6a, 0xe2, 0x4a, 0x4e, 0x57, - 0xf3, 0x11, 0x34, 0x0e, 0x7c, 0xff, 0xd9, 0x6c, 0xaa, 0xde, 0x59, 0x24, 0xdd, 0x98, 0xf6, 0x9d, - 0xf0, 0x7c, 0x33, 0xd5, 0x2d, 0xd2, 0x82, 0x65, 0x45, 0x22, 0x62, 0x57, 0xd5, 0x24, 0x52, 0x82, - 0x30, 0xa4, 0x2a, 0x78, 0x90, 0x23, 0x0f, 0xa1, 0xbe, 0x4b, 0x87, 0x18, 0x66, 0x03, 0x9d, 0x66, - 0x56, 0x12, 0x0e, 0x18, 0xdc, 0xdb, 0x66, 0xb3, 0x91, 0x00, 0x4a, 0x12, 0x17, 0x3b, 0x6e, 0xe9, - 0x77, 0x46, 0xd2, 0xfb, 0x29, 0x41, 0xe2, 0xe6, 0x9c, 0xb7, 0xbe, 0x80, 0xe5, 0x39, 0xd7, 0x28, - 0x45, 0xdd, 0xae, 0x73, 0xa8, 0xda, 0xbc, 0x7b, 0x3d, 0x82, 0xa8, 0xf7, 0x87, 0xd0, 0xe0, 0x21, - 0xa5, 0x4f, 0x28, 0x7f, 0x26, 0x9b, 0x0a, 0x18, 0xa6, 0xbf, 0xc1, 0x4d, 0x93, 0x24, 0x5e, 0xe0, - 0x09, 0x7e, 0x8c, 0x46, 0x7b, 0x84, 0xaa, 0xd6, 0x75, 0xfe, 0x61, 0xac, 0x5a, 0xd7, 0xac, 0xf7, - 0xae, 0x9f, 0x43, 0xed, 0x09, 0x8d, 0xe4, 0xb3, 0x4e, 0xc5, 0x1f, 0xa5, 0xde, 0x79, 0x6e, 0x66, - 0x3c, 0xc6, 0x25, 0x9f, 0x60, 0x51, 0x15, 0xa2, 0x60, 0x5d, 0x6b, 0x45, 0x2f, 0xba, 0x94, 0x82, - 0x33, 0xee, 0x43, 0x0b, 0x54, 0xa2, 0x3a, 0x3e, 0x1f, 0x98, 0x46, 0x75, 0x3c, 0x2b, 0xae, 0xc9, - 0x0f, 0xf8, 0x0c, 0x68, 0x0f, 0x49, 0x63, 0x16, 0x2c, 0xfd, 0xe6, 0x54, 0x75, 0x5f, 0x47, 0x7f, - 0x04, 0xd0, 0x8f, 0xfc, 0xe9, 0xae, 0x43, 0x27, 0xbe, 0x17, 0xd3, 0x84, 0xf8, 0x09, 0x63, 0x7c, - 0x10, 0xb5, 0x77, 0x8c, 0xe4, 0x4b, 0x8d, 0x37, 0x4d, 0x2c, 0x89, 0x5c, 0xf6, 0x6b, 0x5f, 0x39, - 0xaa, 0xe1, 0x64, 0xbc, 0x74, 0x44, 0x22, 0x01, 0xb1, 0xe7, 0x99, 0xe2, 0x34, 0xe7, 0x9c, 0xda, - 0xd4, 0x59, 0xcf, 0x70, 0x53, 0xfb, 0x3e, 0x54, 0x63, 0x97, 0x9d, 0x8d, 0x38, 0x6a, 0x52, 0xc2, - 0xc1, 0x47, 0x51, 0xef, 0x79, 0x77, 0x99, 0x2e, 0xac, 0xf0, 0xee, 0xa8, 0xeb, 0x0f, 0x1f, 0xda, - 0xa9, 0x6f, 0x29, 0xcd, 0xfb, 0xa9, 0xa8, 0xf3, 0x93, 0xe5, 0x6d, 0xc1, 0xce, 0xcf, 0x9c, 0xd5, - 0x5e, 0x9d, 0x9f, 0xeb, 0xdc, 0x30, 0xd4, 0xf9, 0xb9, 0xde, 0xe0, 0xdf, 0x85, 0x95, 0x0c, 0xfb, - 0x3b, 0x79, 0x43, 0x0a, 0x36, 0xd7, 0xda, 0xe6, 0x37, 0x33, 0xed, 0xb4, 0x64, 0x00, 0x1b, 0xbc, - 0x4c, 0x6b, 0x3c, 0x4e, 0x99, 0x7b, 0x5f, 0xd7, 0x0a, 0x64, 0x98, 0xb0, 0x13, 0xac, 0x4c, 0xca, - 0x8c, 0xdd, 0x05, 0x23, 0x6d, 0x29, 0x25, 0xd7, 0xa3, 0x6f, 0xde, 0x49, 0xb0, 0xec, 0xf3, 0xd6, - 0x55, 0xf2, 0x85, 0xb2, 0xd7, 0xa6, 0xfa, 0x78, 0x27, 0xfe, 0x04, 0x60, 0xa6, 0x75, 0x59, 0x49, - 0x03, 0x99, 0xe6, 0x5e, 0xf2, 0xf3, 0xb0, 0x91, 0xde, 0xd1, 0xb2, 0xe6, 0xbb, 0x59, 0xd3, 0x75, - 0x2d, 0x2b, 0x97, 0x1c, 0xd0, 0x83, 0x1c, 0x23, 0xc4, 0xba, 0x55, 0x55, 0x6d, 0xa4, 0x0c, 0xf3, - 0xae, 0xda, 0x48, 0x99, 0x66, 0xd8, 0x23, 0x58, 0x4a, 0x19, 0x54, 0x15, 0x1b, 0x9c, 0x6d, 0x82, - 0x55, 0x6c, 0xf0, 0x75, 0x76, 0xd8, 0x3e, 0x18, 0x69, 0x53, 0xa9, 0x5a, 0xeb, 0x6b, 0xcc, 0xaf, - 0x9b, 0x77, 0xae, 0xcd, 0x4f, 0x76, 0x53, 0x33, 0x2a, 0x26, 0xba, 0x39, 0x6f, 0x0a, 0x4d, 0x74, - 0x33, 0xc3, 0xa4, 0xb9, 0xfd, 0xce, 0x2f, 0x7c, 0xe7, 0xcc, 0x8d, 0xce, 0x67, 0x27, 0x5b, 0x43, - 0x7f, 0xf2, 0xc1, 0x58, 0x6a, 0x35, 0xc4, 0xbb, 0xf3, 0x0f, 0xc6, 0xde, 0xe8, 0x03, 0xac, 0xe0, - 0x64, 0x61, 0x1a, 0xf8, 0x91, 0xff, 0xd1, 0xff, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x67, 0x9b, 0x8b, - 0x7c, 0x96, 0x8e, 0x00, 0x00, + // 12316 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0xbd, 0x6b, 0x6c, 0x23, 0xc9, + 0x76, 0x18, 0x3c, 0x7c, 0x89, 0xe4, 0xe1, 0x43, 0x54, 0xe9, 0xc5, 0xd1, 0xec, 0xec, 0xcc, 0xf6, + 0xee, 0xdd, 0x9d, 0x3b, 0xbb, 0xab, 0x9d, 0x9d, 0xdd, 0xd9, 0xc7, 0x9d, 0xcf, 0xf7, 0x5e, 0x8a, + 0xa2, 0x46, 0xbc, 0x23, 0x91, 0xba, 0x4d, 0x6a, 0xd7, 0x6b, 0xd8, 0x6e, 0xb7, 0xc8, 0x92, 0xd4, + 0xdf, 0x90, 0xdd, 0xdc, 0xee, 0xa6, 0x46, 0xba, 0x1f, 0x3e, 0xc0, 0x3f, 0x1c, 0x27, 0x30, 0x8c, + 0x00, 0x01, 0xe2, 0x20, 0x2f, 0x23, 0x2f, 0x24, 0xf9, 0x67, 0x04, 0xb0, 0x93, 0x5f, 0xf9, 0x17, + 0x20, 0x46, 0x80, 0x3c, 0x10, 0xc4, 0x41, 0x1e, 0x30, 0x0c, 0x04, 0x48, 0x9c, 0x1f, 0x01, 0x02, + 0x03, 0xfe, 0x9b, 0x00, 0x41, 0x9d, 0x7a, 0x74, 0x75, 0xb3, 0x35, 0x33, 0x7b, 0xbd, 0xb9, 0x7f, + 0x24, 0xd6, 0x39, 0xa7, 0xde, 0x55, 0xa7, 0x4e, 0x9d, 0x73, 0xea, 0x34, 0x94, 0xfd, 0xd9, 0x68, + 0x7b, 0xe6, 0x7b, 0xa1, 0x47, 0x0a, 0x13, 0xd7, 0x9f, 0x8d, 0x8c, 0x3f, 0xce, 0x40, 0xfe, 0x38, + 0xbc, 0xf4, 0xc8, 0x23, 0xa8, 0xda, 0xe3, 0xb1, 0x4f, 0x83, 0xc0, 0x0a, 0xaf, 0x66, 0xb4, 0x99, + 0xb9, 0x9b, 0xb9, 0x57, 0x7f, 0x48, 0xb6, 0x91, 0x6c, 0xbb, 0xc5, 0x51, 0xc3, 0xab, 0x19, 0x35, + 0x2b, 0x76, 0x94, 0x20, 0x4d, 0x28, 0x8a, 0x64, 0x33, 0x7b, 0x37, 0x73, 0xaf, 0x6c, 0xca, 0x24, + 0xb9, 0x0d, 0x60, 0x4f, 0xbd, 0xb9, 0x1b, 0x5a, 0x81, 0x1d, 0x36, 0x73, 0x77, 0x33, 0xf7, 0x72, + 0x66, 0x99, 0x43, 0x06, 0x76, 0x48, 0x6e, 0x41, 0x79, 0xf6, 0xcc, 0x0a, 0x46, 0xbe, 0x33, 0x0b, + 0x9b, 0x79, 0xcc, 0x5a, 0x9a, 0x3d, 0x1b, 0x60, 0x9a, 0xbc, 0x0b, 0x25, 0x6f, 0x1e, 0xce, 0x3c, + 0xc7, 0x0d, 0x9b, 0x85, 0xbb, 0x99, 0x7b, 0x95, 0x87, 0xcb, 0xa2, 0x21, 0xfd, 0x79, 0x78, 0xc4, + 0xc0, 0xa6, 0x22, 0x20, 0x6f, 0x41, 0x6d, 0xe4, 0xb9, 0xa7, 0x8e, 0x3f, 0xb5, 0x43, 0xc7, 0x73, + 0x83, 0xe6, 0x12, 0xd6, 0x15, 0x07, 0x1a, 0xff, 0x3c, 0x0b, 0x95, 0xa1, 0x6f, 0xbb, 0x81, 0x3d, + 0x62, 0x00, 0xb2, 0x09, 0xc5, 0xf0, 0xd2, 0x3a, 0xb7, 0x83, 0x73, 0xec, 0x6a, 0xd9, 0x5c, 0x0a, + 0x2f, 0xf7, 0xed, 0xe0, 0x9c, 0x6c, 0xc0, 0x12, 0x6f, 0x25, 0x76, 0x28, 0x67, 0x8a, 0x14, 0x79, + 0x17, 0x56, 0xdc, 0xf9, 0xd4, 0x8a, 0x57, 0xc5, 0xba, 0x55, 0x30, 0x1b, 0xee, 0x7c, 0xda, 0xd6, + 0xe1, 0xac, 0xf3, 0x27, 0x13, 0x6f, 0xf4, 0x8c, 0x57, 0xc0, 0xbb, 0x57, 0x46, 0x08, 0xd6, 0xf1, + 0x06, 0x54, 0x05, 0x9a, 0x3a, 0x67, 0xe7, 0xbc, 0x8f, 0x05, 0xb3, 0xc2, 0x09, 0x10, 0xc4, 0x4a, + 0x08, 0x9d, 0x29, 0xb5, 0x82, 0xd0, 0x9e, 0xce, 0x44, 0x97, 0xca, 0x0c, 0x32, 0x60, 0x00, 0x44, + 0x7b, 0xa1, 0x3d, 0xb1, 0x4e, 0x29, 0x0d, 0x9a, 0x45, 0x81, 0x66, 0x90, 0x3d, 0x4a, 0x03, 0xf2, + 0x1d, 0xa8, 0x8f, 0x69, 0x10, 0x5a, 0x62, 0x32, 0x68, 0xd0, 0x2c, 0xdd, 0xcd, 0xdd, 0x2b, 0x9b, + 0x35, 0x06, 0x6d, 0x49, 0x20, 0x79, 0x0d, 0xc0, 0xb7, 0x9f, 0x5b, 0x6c, 0x20, 0xe8, 0x65, 0xb3, + 0xcc, 0x67, 0xc1, 0xb7, 0x9f, 0x0f, 0x2f, 0xf7, 0xe9, 0x25, 0x59, 0x83, 0xc2, 0xc4, 0x3e, 0xa1, + 0x93, 0x26, 0x20, 0x82, 0x27, 0x8c, 0x5f, 0x80, 0x8d, 0x27, 0x34, 0xd4, 0x86, 0x32, 0x30, 0xe9, + 0xd7, 0x73, 0x1a, 0x84, 0xac, 0x57, 0x41, 0x68, 0xfb, 0xa1, 0xec, 0x55, 0x86, 0xf7, 0x0a, 0x61, + 0x51, 0xaf, 0xa8, 0x3b, 0x96, 0x04, 0x59, 0x24, 0x28, 0x53, 0x77, 0xcc, 0xd1, 0xc6, 0x01, 0x10, + 0xad, 0xe0, 0x5d, 0x1a, 0xda, 0xce, 0x24, 0x20, 0x9f, 0x40, 0x35, 0xd4, 0xaa, 0x6b, 0x66, 0xee, + 0xe6, 0xee, 0x55, 0xd4, 0xd2, 0xd4, 0x32, 0x98, 0x31, 0x3a, 0xe3, 0x1c, 0x4a, 0x7b, 0x94, 0x1e, + 0x38, 0x53, 0x27, 0x24, 0x1b, 0x50, 0x38, 0x75, 0x2e, 0xe9, 0x18, 0x1b, 0x95, 0xdb, 0xbf, 0x61, + 0xf2, 0x24, 0xb9, 0x03, 0x80, 0x3f, 0xac, 0xa9, 0x5a, 0xa5, 0xfb, 0x37, 0xcc, 0x32, 0xc2, 0x0e, + 0x03, 0x3b, 0x24, 0x5b, 0x50, 0x9c, 0x51, 0x7f, 0x44, 0xe5, 0x7a, 0xd8, 0xbf, 0x61, 0x4a, 0xc0, + 0x4e, 0x11, 0x0a, 0x13, 0x56, 0xba, 0xf1, 0xfb, 0x05, 0xa8, 0x0c, 0xa8, 0x3b, 0x96, 0x23, 0x41, + 0x20, 0xcf, 0x06, 0x1a, 0x2b, 0xab, 0x9a, 0xf8, 0x9b, 0xbc, 0x09, 0x15, 0x9c, 0x92, 0x20, 0xf4, + 0x1d, 0xf7, 0x8c, 0xef, 0x96, 0x9d, 0x6c, 0x33, 0x63, 0x02, 0x03, 0x0f, 0x10, 0x4a, 0x1a, 0x90, + 0xb3, 0xa7, 0x72, 0xb7, 0xb0, 0x9f, 0xe4, 0x26, 0x94, 0xec, 0x69, 0xc8, 0x9b, 0x57, 0x45, 0x70, + 0xd1, 0x9e, 0x86, 0xd8, 0xb4, 0x37, 0xa0, 0x3a, 0xb3, 0xaf, 0xa6, 0xd4, 0x0d, 0xa3, 0x65, 0x56, + 0x35, 0x2b, 0x02, 0x86, 0x0b, 0xed, 0x21, 0xac, 0xea, 0x24, 0xb2, 0xf2, 0x82, 0xaa, 0x7c, 0x45, + 0xa3, 0x16, 0x6d, 0x78, 0x07, 0x96, 0x65, 0x1e, 0x9f, 0xf7, 0x07, 0x97, 0x5f, 0xd9, 0xac, 0x0b, + 0xb0, 0xec, 0xe5, 0x3d, 0x68, 0x9c, 0x3a, 0xae, 0x3d, 0xb1, 0x46, 0x93, 0xf0, 0xc2, 0x1a, 0xd3, + 0x49, 0x68, 0xe3, 0x4a, 0x2c, 0x98, 0x75, 0x84, 0xb7, 0x27, 0xe1, 0xc5, 0x2e, 0x83, 0x92, 0xf7, + 0xa0, 0x7c, 0x4a, 0xa9, 0x85, 0x83, 0xd5, 0x2c, 0xc5, 0x36, 0xb4, 0x9c, 0x21, 0xb3, 0x74, 0x2a, + 0xe7, 0xea, 0x3d, 0x68, 0x78, 0xf3, 0xf0, 0xcc, 0x73, 0xdc, 0x33, 0x6b, 0x74, 0x6e, 0xbb, 0x96, + 0x33, 0xc6, 0xb5, 0x99, 0xdf, 0xc9, 0x3e, 0xc8, 0x98, 0x75, 0x89, 0x6b, 0x9f, 0xdb, 0x6e, 0x77, + 0x4c, 0xde, 0x86, 0xe5, 0x89, 0x1d, 0x84, 0xd6, 0xb9, 0x37, 0xb3, 0x66, 0xf3, 0x93, 0x67, 0xf4, + 0xaa, 0x59, 0xc3, 0x81, 0xa8, 0x31, 0xf0, 0xbe, 0x37, 0x3b, 0x42, 0x20, 0x5b, 0x7a, 0xd8, 0x4e, + 0xde, 0x08, 0xb6, 0xa4, 0x6b, 0x66, 0x99, 0x41, 0x78, 0xa5, 0x5f, 0xc1, 0x2a, 0x4e, 0xcf, 0x68, + 0x1e, 0x84, 0xde, 0xd4, 0xf2, 0xe9, 0xc8, 0xf3, 0xc7, 0x41, 0xb3, 0x82, 0x6b, 0xed, 0xbb, 0xa2, + 0xb1, 0xda, 0x1c, 0x6f, 0xef, 0xd2, 0x20, 0x6c, 0x23, 0xb1, 0xc9, 0x69, 0x3b, 0x6e, 0xe8, 0x5f, + 0x99, 0x2b, 0xe3, 0x24, 0x9c, 0xbc, 0x07, 0xc4, 0x9e, 0x4c, 0xbc, 0xe7, 0x56, 0x40, 0x27, 0xa7, + 0x96, 0x18, 0xc4, 0x66, 0xfd, 0x6e, 0xe6, 0x5e, 0xc9, 0x6c, 0x20, 0x66, 0x40, 0x27, 0xa7, 0x47, + 0x1c, 0x4e, 0x3e, 0x01, 0xdc, 0xa4, 0xd6, 0x29, 0xb5, 0xc3, 0xb9, 0x4f, 0x83, 0xe6, 0xf2, 0xdd, + 0xdc, 0xbd, 0xfa, 0xc3, 0x15, 0x35, 0x5e, 0x08, 0xde, 0x71, 0x42, 0xb3, 0xca, 0xe8, 0x44, 0x3a, + 0xd8, 0xda, 0x85, 0x8d, 0xf4, 0x26, 0xb1, 0x45, 0xc5, 0x46, 0x85, 0x2d, 0xc6, 0xbc, 0xc9, 0x7e, + 0xb2, 0x9d, 0x7d, 0x61, 0x4f, 0xe6, 0x14, 0x57, 0x61, 0xd5, 0xe4, 0x89, 0xef, 0x65, 0x3f, 0xcb, + 0x18, 0xbf, 0x97, 0x81, 0x2a, 0xef, 0x65, 0x30, 0xf3, 0xdc, 0x80, 0x92, 0x37, 0xa1, 0x26, 0x57, + 0x03, 0xf5, 0x7d, 0xcf, 0x17, 0xdc, 0x52, 0xae, 0xbc, 0x0e, 0x83, 0x91, 0xef, 0x42, 0x43, 0x12, + 0xcd, 0x7c, 0xea, 0x4c, 0xed, 0x33, 0x59, 0xb4, 0x5c, 0x4a, 0x47, 0x02, 0x4c, 0x3e, 0x8c, 0xca, + 0xf3, 0xbd, 0x79, 0x48, 0x71, 0xad, 0x57, 0x1e, 0x56, 0x45, 0xf7, 0x4c, 0x06, 0x53, 0xa5, 0x63, + 0xea, 0x15, 0xd6, 0xb9, 0xf1, 0x5b, 0x19, 0x20, 0xac, 0xd9, 0x43, 0x8f, 0x17, 0x10, 0x71, 0xa4, + 0x58, 0xce, 0xcc, 0x2b, 0xef, 0x90, 0xec, 0x8b, 0x76, 0x88, 0x01, 0x05, 0xde, 0xf6, 0x7c, 0x4a, + 0xdb, 0x39, 0xea, 0x47, 0xf9, 0x52, 0xae, 0x91, 0x37, 0xfe, 0x73, 0x0e, 0xd6, 0xd8, 0x3a, 0x75, + 0xe9, 0xa4, 0x35, 0x1a, 0xd1, 0x99, 0xda, 0x3b, 0x77, 0xa0, 0xe2, 0x7a, 0x63, 0x2a, 0x57, 0x2c, + 0x6f, 0x18, 0x30, 0x90, 0xb6, 0x5c, 0xcf, 0x6d, 0xc7, 0xe5, 0x0d, 0xe7, 0x83, 0x59, 0x46, 0x08, + 0x36, 0xfb, 0x6d, 0x58, 0x9e, 0x51, 0x77, 0xac, 0x6f, 0x91, 0x1c, 0x5f, 0xf5, 0x02, 0x2c, 0x76, + 0xc7, 0x1d, 0xa8, 0x9c, 0xce, 0x39, 0x1d, 0x63, 0x2c, 0x79, 0x5c, 0x03, 0x20, 0x40, 0x2d, 0xce, + 0x5f, 0x66, 0xf3, 0xe0, 0x1c, 0xb1, 0x05, 0xc4, 0x16, 0x59, 0x9a, 0xa1, 0x6e, 0x03, 0x8c, 0xe7, + 0x41, 0x28, 0x76, 0xcc, 0x12, 0x22, 0xcb, 0x0c, 0xc2, 0x77, 0xcc, 0xfb, 0xb0, 0x3a, 0xb5, 0x2f, + 0x2d, 0x5c, 0x3b, 0x96, 0xe3, 0x5a, 0xa7, 0x13, 0x64, 0xea, 0x45, 0xa4, 0x6b, 0x4c, 0xed, 0xcb, + 0x2f, 0x18, 0xa6, 0xeb, 0xee, 0x21, 0x9c, 0xb1, 0x95, 0x11, 0x1f, 0x09, 0xcb, 0xa7, 0x01, 0xf5, + 0x2f, 0x28, 0x72, 0x82, 0xbc, 0x59, 0x17, 0x60, 0x93, 0x43, 0x59, 0x8b, 0xa6, 0xac, 0xdf, 0xe1, + 0x64, 0xc4, 0xb7, 0xbd, 0x59, 0x9c, 0x3a, 0xee, 0x7e, 0x38, 0x19, 0xb1, 0xf3, 0x8a, 0xf1, 0x91, + 0x19, 0xf5, 0xad, 0x67, 0xcf, 0x71, 0x0f, 0xe7, 0x91, 0x6f, 0x1c, 0x51, 0xff, 0xe9, 0x73, 0x26, + 0x52, 0x8c, 0x02, 0x64, 0x44, 0xf6, 0x55, 0xb3, 0x82, 0x1b, 0xbc, 0x34, 0x0a, 0x18, 0x0b, 0xb2, + 0xaf, 0xd8, 0x26, 0x64, 0xad, 0xb5, 0x71, 0x16, 0xe8, 0x18, 0x8b, 0x0f, 0x90, 0xa3, 0xd6, 0xb0, + 0xb1, 0x2d, 0x81, 0x60, 0xf5, 0x04, 0x6c, 0xd5, 0xcb, 0xc6, 0x9e, 0x4e, 0xec, 0xb3, 0x00, 0x59, + 0x4a, 0xcd, 0xac, 0x0a, 0xe0, 0x1e, 0x83, 0x19, 0x7f, 0x9a, 0x85, 0xf5, 0xc4, 0xe4, 0x8a, 0x4d, + 0xc3, 0x64, 0x08, 0x84, 0xe0, 0xc4, 0x96, 0x4c, 0x91, 0x4a, 0x9b, 0xb5, 0x6c, 0xda, 0xac, 0xad, + 0x41, 0x81, 0x6f, 0xb6, 0x1c, 0x3f, 0x79, 0xa9, 0xdc, 0x65, 0xf3, 0xd9, 0xa9, 0xef, 0x31, 0x91, + 0xea, 0x7c, 0x1e, 0x8e, 0xbd, 0xe7, 0xae, 0x10, 0x2d, 0x96, 0x05, 0x7c, 0x20, 0xc0, 0xf1, 0xa1, + 0x28, 0x24, 0x86, 0xe2, 0x0e, 0x54, 0xc4, 0x0c, 0xa0, 0x68, 0xc6, 0x27, 0x16, 0x04, 0x88, 0xc9, + 0x66, 0xef, 0x02, 0x51, 0xf3, 0x69, 0xb1, 0x51, 0xc3, 0xd3, 0x87, 0x4f, 0xec, 0xb2, 0x23, 0x26, + 0xf4, 0xd0, 0xbe, 0xc4, 0x53, 0xe8, 0x2d, 0xa8, 0x33, 0x12, 0x36, 0x9e, 0xd6, 0x08, 0xe5, 0xa6, + 0x12, 0x1f, 0xab, 0xa9, 0x7d, 0xc9, 0x06, 0xb3, 0x8d, 0xd2, 0xd3, 0xeb, 0x50, 0x91, 0x93, 0x6a, + 0x39, 0xae, 0x98, 0xd7, 0xb2, 0x98, 0xd7, 0xae, 0xcb, 0xce, 0x12, 0x86, 0xe7, 0xe3, 0x64, 0x8d, + 0xe9, 0x2c, 0x3c, 0x17, 0x3c, 0xba, 0x3e, 0x75, 0x5c, 0x3e, 0xbc, 0xbb, 0x0c, 0x6a, 0xfc, 0x76, + 0x06, 0xaa, 0x62, 0xd4, 0x51, 0x12, 0x24, 0xdb, 0x40, 0xe4, 0x12, 0x0f, 0x2f, 0x9d, 0xb1, 0x75, + 0x72, 0x15, 0xd2, 0x80, 0xef, 0xa8, 0xfd, 0x1b, 0x66, 0x43, 0xe0, 0x86, 0x97, 0xce, 0x78, 0x87, + 0x61, 0xc8, 0x7d, 0x68, 0xc4, 0xe8, 0x83, 0xd0, 0xe7, 0xdb, 0x7d, 0xff, 0x86, 0x59, 0xd7, 0xa8, + 0x07, 0xa1, 0xcf, 0x18, 0x08, 0x93, 0x33, 0xe7, 0xa1, 0xe5, 0xb8, 0x63, 0x7a, 0x89, 0xf3, 0x51, + 0x33, 0x2b, 0x1c, 0xd6, 0x65, 0xa0, 0x9d, 0x3a, 0x54, 0xf5, 0xe2, 0x8c, 0x33, 0x28, 0x49, 0x21, + 0x15, 0xa5, 0xb4, 0x44, 0x93, 0xcc, 0x72, 0xa8, 0x5a, 0x72, 0x13, 0x4a, 0xf1, 0x16, 0x98, 0xc5, + 0xf0, 0x95, 0x2b, 0x36, 0xbe, 0x0f, 0x8d, 0x03, 0x36, 0x11, 0x2e, 0xdb, 0xc9, 0x42, 0xe8, 0xde, + 0x80, 0x25, 0x8d, 0xa3, 0x94, 0x4d, 0x91, 0x62, 0x02, 0xc9, 0xb9, 0x17, 0x84, 0xa2, 0x16, 0xfc, + 0x6d, 0xfc, 0x7e, 0x06, 0x48, 0x27, 0x08, 0x9d, 0xa9, 0x1d, 0xd2, 0x3d, 0xaa, 0x78, 0x66, 0x1f, + 0xaa, 0xac, 0xb4, 0xa1, 0xd7, 0xe2, 0x52, 0x30, 0x97, 0xb6, 0xde, 0x15, 0x3c, 0x6e, 0x31, 0xc3, + 0xb6, 0x4e, 0xcd, 0xcf, 0xc0, 0x58, 0x01, 0x6c, 0xb9, 0x85, 0xb6, 0x7f, 0x46, 0x43, 0x94, 0x9d, + 0x85, 0xd0, 0x07, 0x1c, 0xc4, 0xa4, 0xe6, 0xad, 0x1f, 0xc0, 0xca, 0x42, 0x19, 0xfa, 0xa1, 0x55, + 0x4e, 0x39, 0xb4, 0x72, 0xfa, 0xa1, 0x65, 0xc1, 0x6a, 0xac, 0x5d, 0x62, 0x17, 0x6e, 0x42, 0x91, + 0x71, 0x0b, 0xb6, 0x76, 0x33, 0x5c, 0x94, 0x3f, 0xa5, 0xb8, 0xbe, 0x3f, 0x80, 0xb5, 0x53, 0x4a, + 0x7d, 0x3b, 0x44, 0x24, 0xb2, 0x13, 0x36, 0x43, 0xa2, 0xe0, 0x15, 0x81, 0x1b, 0xd8, 0xe1, 0x11, + 0xf5, 0xd9, 0x4c, 0x19, 0xff, 0x2c, 0x0b, 0xcb, 0xec, 0x78, 0x39, 0xb4, 0xdd, 0x2b, 0x39, 0x4e, + 0x07, 0xa9, 0xe3, 0x74, 0x4f, 0x93, 0x14, 0x34, 0xea, 0x6f, 0x3a, 0x48, 0xb9, 0xe4, 0x20, 0x91, + 0xbb, 0x50, 0x8d, 0xb5, 0xb5, 0x80, 0x6d, 0x85, 0x40, 0x35, 0x32, 0x12, 0xd7, 0x97, 0x34, 0x71, + 0x9d, 0x71, 0x02, 0xb6, 0xb1, 0x58, 0xa9, 0x81, 0x90, 0xce, 0x18, 0x7b, 0x65, 0x65, 0x06, 0xec, + 0x4e, 0x13, 0x30, 0xce, 0x63, 0xcd, 0x5d, 0x71, 0xaf, 0xa1, 0x63, 0xdc, 0xbe, 0x25, 0xb3, 0x81, + 0x88, 0xe3, 0x08, 0xfe, 0x67, 0x9f, 0xa6, 0xb7, 0xa1, 0x11, 0x0d, 0x8b, 0x98, 0x23, 0x02, 0x79, + 0xb6, 0xe4, 0x45, 0x01, 0xf8, 0xdb, 0xf8, 0x5f, 0x19, 0x4e, 0xd8, 0xf6, 0x9c, 0xe8, 0x72, 0x41, + 0x20, 0xcf, 0x2e, 0x33, 0x92, 0x90, 0xfd, 0xbe, 0xf6, 0xaa, 0xf6, 0x2d, 0x0c, 0xe6, 0x4d, 0x28, + 0x05, 0x6c, 0x60, 0xec, 0x09, 0x1f, 0xcf, 0x92, 0x59, 0x64, 0xe9, 0xd6, 0x64, 0x12, 0x8d, 0x73, + 0xf1, 0xda, 0x71, 0x2e, 0xbd, 0xca, 0x38, 0x97, 0xd3, 0xc7, 0xd9, 0x78, 0x07, 0x56, 0xb4, 0xde, + 0xbf, 0x60, 0x9c, 0x7a, 0x40, 0x0e, 0x9c, 0x20, 0x3c, 0x76, 0x59, 0x11, 0x4a, 0xb2, 0x88, 0x35, + 0x24, 0x93, 0x68, 0x08, 0x43, 0xda, 0x97, 0x02, 0x99, 0x15, 0x48, 0xfb, 0x12, 0x91, 0xc6, 0x67, + 0xb0, 0x1a, 0x2b, 0x4f, 0x54, 0xfd, 0x06, 0x14, 0xe6, 0xe1, 0xa5, 0x27, 0xef, 0x5d, 0x15, 0xb1, + 0xc2, 0x8f, 0xc3, 0x4b, 0xcf, 0xe4, 0x18, 0xe3, 0x31, 0xac, 0xf4, 0xe8, 0x73, 0xc1, 0x84, 0x64, + 0x43, 0xde, 0x86, 0xfc, 0x4b, 0x34, 0x09, 0x88, 0x37, 0xb6, 0x81, 0xe8, 0x99, 0x45, 0xad, 0x9a, + 0x62, 0x21, 0x13, 0x53, 0x2c, 0x18, 0x6f, 0x03, 0x19, 0x38, 0x67, 0xee, 0x21, 0x0d, 0x02, 0xfb, + 0x4c, 0xb1, 0xad, 0x06, 0xe4, 0xa6, 0xc1, 0x99, 0xe0, 0xb1, 0xec, 0xa7, 0xf1, 0x11, 0xac, 0xc6, + 0xe8, 0x44, 0xc1, 0xaf, 0x41, 0x39, 0x70, 0xce, 0x5c, 0x94, 0x9a, 0x45, 0xd1, 0x11, 0xc0, 0xd8, + 0x83, 0xb5, 0x2f, 0xa8, 0xef, 0x9c, 0x5e, 0xbd, 0xac, 0xf8, 0x78, 0x39, 0xd9, 0x64, 0x39, 0x1d, + 0x58, 0x4f, 0x94, 0x23, 0xaa, 0xe7, 0xdb, 0x43, 0xcc, 0x64, 0xc9, 0xe4, 0x09, 0x8d, 0x6f, 0x67, + 0x75, 0xbe, 0x6d, 0x78, 0x40, 0xda, 0x9e, 0xeb, 0xd2, 0x51, 0x78, 0x44, 0xa9, 0x2f, 0x1b, 0xf3, + 0xae, 0xb6, 0x17, 0x2a, 0x0f, 0x37, 0xc5, 0xc8, 0x26, 0x0f, 0x03, 0xb1, 0x49, 0x08, 0xe4, 0x67, + 0xd4, 0x9f, 0x62, 0xc1, 0x25, 0x13, 0x7f, 0xb3, 0xc1, 0x0d, 0x9d, 0x29, 0xf5, 0xe6, 0xfc, 0xaa, + 0x99, 0x37, 0x65, 0xd2, 0x58, 0x87, 0xd5, 0x58, 0x85, 0xbc, 0xd5, 0xc6, 0x03, 0x58, 0xdf, 0x75, + 0x82, 0xd1, 0x62, 0x53, 0x36, 0xa1, 0x38, 0x9b, 0x9f, 0x58, 0xf1, 0x13, 0xe7, 0x29, 0xbd, 0x32, + 0x9a, 0xb0, 0x91, 0xcc, 0x21, 0xca, 0xfa, 0xf5, 0x2c, 0xe4, 0xf7, 0x87, 0x07, 0x6d, 0xb2, 0x05, + 0x25, 0xc7, 0x1d, 0x79, 0x53, 0x26, 0x6f, 0xf3, 0xd1, 0x50, 0xe9, 0x6b, 0xb7, 0xf6, 0x2d, 0x28, + 0xa3, 0x98, 0x3e, 0xf1, 0x46, 0xcf, 0x84, 0xc4, 0x5b, 0x62, 0x80, 0x03, 0x6f, 0xf4, 0x8c, 0x6d, + 0x33, 0x7a, 0x39, 0x73, 0x7c, 0x54, 0xc2, 0x48, 0x25, 0x43, 0x9e, 0x8b, 0x78, 0x11, 0x22, 0x52, + 0x45, 0x08, 0x69, 0x84, 0x9d, 0xaf, 0x5c, 0xf4, 0x2d, 0x9f, 0xa3, 0x34, 0x32, 0xa6, 0x97, 0xe4, + 0x7d, 0x20, 0xa7, 0x9e, 0xff, 0xdc, 0xf6, 0x95, 0xb4, 0xe6, 0x0a, 0xd6, 0x9a, 0x37, 0x57, 0x22, + 0x8c, 0x90, 0x44, 0xc8, 0x43, 0x58, 0xd7, 0xc8, 0xb5, 0x82, 0xb9, 0xd4, 0xb4, 0x1a, 0x21, 0xf7, + 0x65, 0x15, 0xc6, 0xaf, 0x65, 0x81, 0x88, 0xfc, 0x6d, 0xcf, 0x0d, 0x42, 0xdf, 0x76, 0xdc, 0x30, + 0x88, 0xcb, 0x6e, 0x99, 0x84, 0xec, 0x76, 0x0f, 0x1a, 0x28, 0x39, 0xea, 0x02, 0x5c, 0x36, 0x12, + 0xa3, 0xcd, 0x48, 0x88, 0x7b, 0x0b, 0xea, 0x91, 0xf4, 0xae, 0x74, 0x70, 0x79, 0xb3, 0xaa, 0x24, + 0x78, 0x71, 0x14, 0x32, 0x86, 0x20, 0xa5, 0x52, 0xa5, 0x6a, 0xe0, 0x17, 0x85, 0x95, 0xa9, 0x7d, + 0x79, 0x44, 0xe5, 0x5d, 0x01, 0xc5, 0x3d, 0x03, 0x6a, 0x4a, 0x90, 0x43, 0x4a, 0x3e, 0x72, 0x15, + 0x21, 0xca, 0x21, 0x4d, 0xba, 0xac, 0xbd, 0x94, 0x2e, 0x6b, 0x1b, 0xff, 0xa1, 0x0c, 0x45, 0x39, + 0x8c, 0x28, 0x38, 0x87, 0xce, 0x05, 0x8d, 0x04, 0x67, 0x96, 0x62, 0xf2, 0xb8, 0x4f, 0xa7, 0x5e, + 0xa8, 0x2e, 0x4c, 0x7c, 0x9b, 0x54, 0x39, 0x50, 0x5c, 0x99, 0x34, 0xa1, 0x9d, 0xab, 0x0e, 0xb9, + 0xf4, 0x2c, 0x85, 0x76, 0x2e, 0x92, 0xdd, 0x82, 0xa2, 0x14, 0xbd, 0xf3, 0x4a, 0xa7, 0xb0, 0x34, + 0xe2, 0x72, 0xf7, 0x16, 0x94, 0x46, 0xf6, 0xcc, 0x1e, 0x39, 0xe1, 0x95, 0x38, 0x13, 0x54, 0x9a, + 0x95, 0x3e, 0xf1, 0x46, 0xf6, 0xc4, 0x3a, 0xb1, 0x27, 0xb6, 0x3b, 0xa2, 0x42, 0x27, 0x57, 0x45, + 0xe0, 0x0e, 0x87, 0x91, 0xef, 0x40, 0x5d, 0xb4, 0x53, 0x52, 0x71, 0xd5, 0x9c, 0x68, 0xbd, 0x24, + 0x63, 0x97, 0x3b, 0x6f, 0xca, 0xe6, 0xe5, 0x94, 0xf2, 0x6b, 0x50, 0xce, 0x2c, 0x73, 0xc8, 0x1e, + 0xc5, 0xde, 0x0a, 0xf4, 0x73, 0xbe, 0x86, 0xcb, 0xbc, 0x2a, 0x0e, 0xfc, 0x92, 0xaf, 0xdf, 0xc5, + 0xbb, 0x50, 0x4e, 0xbb, 0x0b, 0xbd, 0x0b, 0x2b, 0x73, 0x37, 0xa0, 0x61, 0x38, 0xa1, 0x63, 0xd5, + 0x96, 0x0a, 0x12, 0x35, 0x14, 0x42, 0x36, 0x67, 0x1b, 0x56, 0xb9, 0x32, 0x31, 0xb0, 0x43, 0x2f, + 0x38, 0x77, 0x02, 0x2b, 0xa0, 0xae, 0x54, 0x37, 0xad, 0x20, 0x6a, 0x20, 0x30, 0x03, 0xae, 0xa2, + 0xd8, 0x4c, 0xd0, 0xfb, 0x74, 0x44, 0x9d, 0x0b, 0x3a, 0xc6, 0x7b, 0x52, 0xce, 0x5c, 0x8f, 0xe5, + 0x31, 0x05, 0x12, 0x2f, 0xbd, 0xf3, 0xa9, 0x35, 0x9f, 0x8d, 0x6d, 0x26, 0x0f, 0xd7, 0xf9, 0xc5, + 0xc3, 0x9d, 0x4f, 0x8f, 0x39, 0x84, 0x3c, 0x00, 0x79, 0x11, 0x12, 0x6b, 0x66, 0x39, 0x76, 0xe4, + 0x30, 0xae, 0x61, 0x56, 0x05, 0x05, 0xbf, 0xa8, 0xdd, 0xd1, 0x37, 0x4b, 0x83, 0xad, 0x30, 0xbc, + 0xb4, 0x47, 0x1b, 0xa6, 0x09, 0xc5, 0x99, 0xef, 0x5c, 0xd8, 0x21, 0x6d, 0xae, 0xf0, 0x73, 0x5c, + 0x24, 0x19, 0x03, 0x77, 0x5c, 0x27, 0x74, 0xec, 0xd0, 0xf3, 0x9b, 0x04, 0x71, 0x11, 0x80, 0xdc, + 0x87, 0x15, 0x5c, 0x27, 0x41, 0x68, 0x87, 0xf3, 0x40, 0xdc, 0x02, 0x57, 0xf9, 0x6d, 0x8b, 0x21, + 0x06, 0x08, 0xc7, 0x8b, 0x20, 0xf9, 0x14, 0x36, 0xf8, 0xd2, 0x58, 0xd8, 0x9a, 0x6b, 0x6c, 0x38, + 0xb0, 0x45, 0xab, 0x48, 0xd1, 0x8e, 0xef, 0xd1, 0xcf, 0x61, 0x53, 0x2c, 0x97, 0x85, 0x9c, 0xeb, + 0x2a, 0xe7, 0x1a, 0x27, 0x49, 0x64, 0xdd, 0x86, 0x15, 0xd6, 0x34, 0x67, 0x64, 0x89, 0x12, 0xd8, + 0xae, 0xd8, 0x60, 0xbd, 0xc0, 0x4c, 0xcb, 0x1c, 0x69, 0x22, 0xee, 0x29, 0xbd, 0x22, 0xdf, 0x87, + 0x65, 0xbe, 0x7c, 0x50, 0xd5, 0x81, 0x07, 0xf3, 0x16, 0x1e, 0xcc, 0xeb, 0x62, 0x70, 0xdb, 0x0a, + 0x8b, 0x67, 0x73, 0x7d, 0x14, 0x4b, 0xb3, 0xad, 0x31, 0x71, 0x4e, 0x29, 0x3b, 0x27, 0x9a, 0x9b, + 0x7c, 0xb1, 0xc9, 0x34, 0xdb, 0xb5, 0xf3, 0x19, 0x62, 0x9a, 0x9c, 0x59, 0xf3, 0x14, 0xae, 0xe3, + 0x89, 0x17, 0x50, 0xa9, 0x86, 0x6e, 0xde, 0x14, 0x1b, 0x92, 0x01, 0xe5, 0x95, 0x85, 0xdd, 0x89, + 0xb9, 0x02, 0x42, 0x19, 0x0b, 0x6e, 0xe1, 0xc2, 0xa8, 0x71, 0x3d, 0x84, 0x34, 0x18, 0x30, 0xa1, + 0xee, 0xdc, 0x7e, 0x2e, 0xd9, 0xfa, 0x6b, 0xc8, 0x4d, 0x80, 0x81, 0x04, 0x43, 0xdf, 0x83, 0x15, + 0x31, 0x0b, 0x11, 0x33, 0x6d, 0xde, 0xc6, 0x23, 0xf2, 0xa6, 0xec, 0xe3, 0x02, 0xb7, 0x35, 0x1b, + 0x7c, 0x5e, 0x34, 0xfe, 0xbb, 0x0f, 0x44, 0x4e, 0x8a, 0x56, 0xd0, 0xeb, 0x2f, 0x2b, 0x68, 0x45, + 0x4c, 0x53, 0x04, 0x32, 0x7e, 0x37, 0xc3, 0x25, 0x2a, 0x41, 0x1d, 0x68, 0xca, 0x1f, 0xce, 0xd7, + 0x2c, 0xcf, 0x9d, 0x5c, 0x09, 0x56, 0x07, 0x1c, 0xd4, 0x77, 0x27, 0xc8, 0x6b, 0x1c, 0x57, 0x27, + 0xe1, 0x87, 0x77, 0x55, 0x02, 0x91, 0xe8, 0x0e, 0x54, 0x66, 0xf3, 0x93, 0x89, 0x33, 0xe2, 0x24, + 0x39, 0x5e, 0x0a, 0x07, 0x21, 0xc1, 0x1b, 0x50, 0x15, 0x6b, 0x9d, 0x53, 0xe4, 0x91, 0xa2, 0x22, + 0x60, 0x48, 0x82, 0xc2, 0x01, 0xf5, 0x91, 0xd9, 0x55, 0x4d, 0xfc, 0x6d, 0xec, 0xc0, 0x5a, 0xbc, + 0xd1, 0x42, 0x72, 0xb9, 0x0f, 0x25, 0xc1, 0x49, 0xa5, 0x5a, 0xb4, 0x1e, 0x1f, 0x0d, 0x53, 0xe1, + 0x8d, 0xff, 0x58, 0x80, 0x55, 0x39, 0x46, 0x6c, 0xb2, 0x07, 0xf3, 0xe9, 0xd4, 0xf6, 0x53, 0x58, + 0x74, 0xe6, 0xc5, 0x2c, 0x3a, 0xbb, 0xc0, 0xa2, 0xe3, 0x7a, 0x31, 0xce, 0xe1, 0xe3, 0x7a, 0x31, + 0xb6, 0xba, 0xf8, 0x6d, 0x5c, 0xb7, 0xbe, 0xd4, 0x04, 0x78, 0xc8, 0xad, 0x3c, 0x0b, 0x07, 0x4a, + 0x21, 0xe5, 0x40, 0xd1, 0x8f, 0x83, 0xa5, 0xc4, 0x71, 0xf0, 0x06, 0xf0, 0x65, 0x2c, 0xd7, 0x63, + 0x91, 0x5f, 0xd0, 0x11, 0x26, 0x16, 0xe4, 0x3b, 0xb0, 0x9c, 0xe4, 0xc0, 0x9c, 0xd5, 0xd7, 0x53, + 0xf8, 0xaf, 0x33, 0xa5, 0x28, 0xd4, 0x68, 0xc4, 0x65, 0xc1, 0x7f, 0x9d, 0x29, 0x3d, 0x40, 0x8c, + 0xa4, 0xef, 0x00, 0xf0, 0xba, 0x71, 0x1b, 0x03, 0x6e, 0xe3, 0xb7, 0x13, 0x2b, 0x53, 0x1b, 0xf5, + 0x6d, 0x96, 0x98, 0xfb, 0x14, 0xf7, 0x75, 0x19, 0x73, 0xe2, 0x96, 0xfe, 0x14, 0xea, 0xde, 0x8c, + 0xba, 0x56, 0xc4, 0x05, 0x2b, 0x58, 0x54, 0x43, 0x14, 0xd5, 0x95, 0x70, 0xb3, 0xc6, 0xe8, 0x54, + 0x92, 0x7c, 0xce, 0x07, 0x99, 0x6a, 0x39, 0xab, 0xd7, 0xe4, 0xac, 0x23, 0x61, 0x94, 0xf5, 0x23, + 0xd4, 0x3d, 0x79, 0x93, 0x39, 0x37, 0xe5, 0xd4, 0x70, 0x1d, 0x49, 0xdd, 0xb6, 0xa9, 0x30, 0xa6, + 0x4e, 0x65, 0xfc, 0x46, 0x06, 0x2a, 0x5a, 0x1f, 0xc8, 0x3a, 0xac, 0xb4, 0xfb, 0xfd, 0xa3, 0x8e, + 0xd9, 0x1a, 0x76, 0xbf, 0xe8, 0x58, 0xed, 0x83, 0xfe, 0xa0, 0xd3, 0xb8, 0xc1, 0xc0, 0x07, 0xfd, + 0x76, 0xeb, 0xc0, 0xda, 0xeb, 0x9b, 0x6d, 0x09, 0xce, 0x90, 0x0d, 0x20, 0x66, 0xe7, 0xb0, 0x3f, + 0xec, 0xc4, 0xe0, 0x59, 0xd2, 0x80, 0xea, 0x8e, 0xd9, 0x69, 0xb5, 0xf7, 0x05, 0x24, 0x47, 0xd6, + 0xa0, 0xb1, 0x77, 0xdc, 0xdb, 0xed, 0xf6, 0x9e, 0x58, 0xed, 0x56, 0xaf, 0xdd, 0x39, 0xe8, 0xec, + 0x36, 0xf2, 0xa4, 0x06, 0xe5, 0xd6, 0x4e, 0xab, 0xb7, 0xdb, 0xef, 0x75, 0x76, 0x1b, 0x05, 0xe3, + 0x7f, 0x64, 0x00, 0xa2, 0x86, 0x32, 0xbe, 0x1a, 0x35, 0x55, 0x37, 0x9d, 0xae, 0x2f, 0x74, 0x8a, + 0xf3, 0x55, 0x3f, 0x96, 0x26, 0x0f, 0xa1, 0xe8, 0xcd, 0xc3, 0x91, 0x37, 0xe5, 0x97, 0x88, 0xfa, + 0xc3, 0xe6, 0x42, 0xbe, 0x3e, 0xc7, 0x9b, 0x92, 0x30, 0x66, 0x1e, 0xcd, 0xbd, 0xcc, 0x3c, 0x1a, + 0xb7, 0xc3, 0x72, 0xb9, 0x4e, 0xb3, 0xc3, 0xde, 0x06, 0x08, 0x9e, 0x53, 0x3a, 0x43, 0xe5, 0x95, + 0xd8, 0x05, 0x65, 0x84, 0x0c, 0xd9, 0x1d, 0xf3, 0x8f, 0x32, 0xb0, 0x8e, 0x6b, 0x69, 0x9c, 0x64, + 0x62, 0x77, 0xa1, 0x32, 0xf2, 0xbc, 0x19, 0x65, 0x42, 0xb5, 0x92, 0xd7, 0x74, 0x10, 0x63, 0x50, + 0x9c, 0x21, 0x9f, 0x7a, 0xfe, 0x88, 0x0a, 0x1e, 0x06, 0x08, 0xda, 0x63, 0x10, 0xb6, 0x87, 0xc4, + 0x26, 0xe4, 0x14, 0x9c, 0x85, 0x55, 0x38, 0x8c, 0x93, 0x6c, 0xc0, 0xd2, 0x89, 0x4f, 0xed, 0xd1, + 0xb9, 0xe0, 0x5e, 0x22, 0x45, 0xbe, 0x1b, 0x29, 0xf1, 0x46, 0x6c, 0x4f, 0x4c, 0x28, 0x6f, 0x7c, + 0xc9, 0x5c, 0x16, 0xf0, 0xb6, 0x00, 0xb3, 0x73, 0xde, 0x3e, 0xb1, 0xdd, 0xb1, 0xe7, 0xd2, 0xb1, + 0xb8, 0xcb, 0x47, 0x00, 0xe3, 0x08, 0x36, 0x92, 0xfd, 0x13, 0xfc, 0xee, 0x13, 0x8d, 0xdf, 0xf1, + 0xab, 0xef, 0xd6, 0xf5, 0x7b, 0x4c, 0xe3, 0x7d, 0xff, 0x3a, 0x0f, 0x79, 0x76, 0xe1, 0xb9, 0xf6, + 0x6e, 0xa4, 0xdf, 0x6d, 0x73, 0x0b, 0x46, 0x73, 0xd4, 0x15, 0x72, 0x01, 0x4c, 0x4c, 0x16, 0x42, + 0x50, 0xf0, 0x52, 0x68, 0x9f, 0x8e, 0x2e, 0xe4, 0x9d, 0x05, 0x21, 0x26, 0x1d, 0x5d, 0xa0, 0xd2, + 0xc2, 0x0e, 0x79, 0x5e, 0xce, 0xaf, 0x8a, 0x81, 0x1d, 0x62, 0x4e, 0x81, 0xc2, 0x7c, 0x45, 0x85, + 0xc2, 0x5c, 0x4d, 0x28, 0x3a, 0xee, 0x89, 0x37, 0x77, 0xa5, 0xea, 0x47, 0x26, 0xd1, 0x46, 0x8f, + 0x9c, 0x94, 0x1d, 0xed, 0x9c, 0x1b, 0x95, 0x18, 0x60, 0xc8, 0x0e, 0xf7, 0x0f, 0xa1, 0x1c, 0x5c, + 0xb9, 0x23, 0x9d, 0x07, 0xad, 0x89, 0xf1, 0x61, 0xbd, 0xdf, 0x1e, 0x5c, 0xb9, 0x23, 0x5c, 0xf1, + 0xa5, 0x40, 0xfc, 0x22, 0x8f, 0xa0, 0xa4, 0xac, 0x5a, 0xfc, 0x04, 0xb9, 0xa9, 0xe7, 0x90, 0xa6, + 0x2c, 0xae, 0x1f, 0x53, 0xa4, 0xe4, 0x03, 0x58, 0x42, 0x05, 0x78, 0xd0, 0xac, 0x62, 0x26, 0x79, + 0xe1, 0x65, 0xcd, 0x40, 0xf3, 0x38, 0x1d, 0xa3, 0x19, 0xca, 0x14, 0x64, 0x6c, 0x98, 0x4e, 0x27, + 0xf6, 0x4c, 0xa8, 0xa3, 0x6b, 0xdc, 0xca, 0xcc, 0x20, 0x5c, 0x17, 0x7d, 0x17, 0xaa, 0x68, 0x31, + 0x44, 0x1a, 0x97, 0xcb, 0xa1, 0x39, 0x13, 0x18, 0x6c, 0x6f, 0x62, 0xcf, 0x7a, 0xc1, 0xd6, 0x53, + 0xa8, 0xc5, 0x1a, 0xa3, 0xab, 0xb9, 0x6a, 0x5c, 0xcd, 0xf5, 0x96, 0xae, 0xe6, 0x8a, 0x8e, 0x42, + 0x91, 0x4d, 0x57, 0x7b, 0xfd, 0x00, 0x4a, 0x72, 0x2c, 0x18, 0xcf, 0x39, 0xee, 0x3d, 0xed, 0xf5, + 0xbf, 0xec, 0x59, 0x83, 0xaf, 0x7a, 0xed, 0xc6, 0x0d, 0xb2, 0x0c, 0x95, 0x56, 0x1b, 0xd9, 0x18, + 0x02, 0x32, 0x8c, 0xe4, 0xa8, 0x35, 0x18, 0x28, 0x48, 0xd6, 0xd8, 0x83, 0x46, 0xb2, 0xab, 0x6c, + 0x51, 0x87, 0x12, 0x26, 0x2c, 0x7b, 0x11, 0x20, 0xb2, 0x1f, 0x64, 0x35, 0xfb, 0x81, 0xf1, 0x08, + 0x1a, 0xec, 0x60, 0x67, 0x63, 0xad, 0xdb, 0xec, 0x27, 0x4c, 0xf4, 0xd6, 0xad, 0x7b, 0x25, 0xb3, + 0xc2, 0x61, 0x58, 0x95, 0xf1, 0x09, 0xac, 0x68, 0xd9, 0x22, 0xa5, 0x10, 0x13, 0x16, 0x92, 0x4a, + 0x21, 0xbc, 0xe8, 0x73, 0x8c, 0xb1, 0x09, 0xeb, 0x2c, 0xd9, 0xb9, 0xa0, 0x6e, 0x38, 0x98, 0x9f, + 0x70, 0x57, 0x0f, 0xc7, 0x73, 0x8d, 0x5f, 0xcb, 0x40, 0x59, 0x61, 0xae, 0xdf, 0x25, 0xdb, 0x42, + 0x7f, 0xc4, 0xd9, 0xe2, 0x96, 0x56, 0x03, 0x66, 0xdc, 0xc6, 0xbf, 0x31, 0x3d, 0x52, 0x59, 0x81, + 0xd8, 0xb0, 0x1e, 0x75, 0x3a, 0xa6, 0xd5, 0xef, 0x1d, 0x74, 0x7b, 0xec, 0x70, 0x60, 0xc3, 0x8a, + 0x80, 0xbd, 0x3d, 0x84, 0x64, 0x8c, 0x06, 0xd4, 0x9f, 0xd0, 0xb0, 0xeb, 0x9e, 0x7a, 0x62, 0x30, + 0x8c, 0x3f, 0xbf, 0x04, 0xcb, 0x0a, 0x14, 0xe9, 0xa1, 0x2e, 0xa8, 0x1f, 0x38, 0x9e, 0x8b, 0xeb, + 0xa4, 0x6c, 0xca, 0x24, 0x63, 0x6f, 0xe2, 0x96, 0x86, 0x62, 0xc6, 0x1a, 0x62, 0xc5, 0xbd, 0x0e, + 0x65, 0x8c, 0x77, 0x60, 0xd9, 0x19, 0x53, 0x37, 0x74, 0xc2, 0x2b, 0x2b, 0xa6, 0x95, 0xaf, 0x4b, + 0xb0, 0x90, 0x33, 0xd6, 0xa0, 0x60, 0x4f, 0x1c, 0x5b, 0xba, 0xd0, 0xf0, 0x04, 0x83, 0x8e, 0xbc, + 0x89, 0xe7, 0xe3, 0xbd, 0xa5, 0x6c, 0xf2, 0x04, 0x79, 0x00, 0x6b, 0xec, 0x0e, 0xa5, 0x9b, 0x91, + 0x90, 0x43, 0x71, 0x03, 0x01, 0x71, 0xe7, 0xd3, 0xa3, 0xc8, 0x94, 0xc4, 0x30, 0x4c, 0xba, 0x60, + 0x39, 0x84, 0x38, 0xa9, 0x32, 0x70, 0xbd, 0xc8, 0x8a, 0x3b, 0x9f, 0xb6, 0x10, 0xa3, 0xe8, 0x1f, + 0xc2, 0x3a, 0xa3, 0x57, 0x02, 0xa8, 0xca, 0xb1, 0x8c, 0x39, 0x58, 0x61, 0x5d, 0x81, 0x53, 0x79, + 0x6e, 0x41, 0x99, 0xb7, 0x8a, 0x2d, 0x09, 0x61, 0x6f, 0xc2, 0xa6, 0x50, 0x3f, 0x58, 0xf0, 0x76, + 0xe1, 0x8a, 0x80, 0xa4, 0xb7, 0x8b, 0xe6, 0x2f, 0x53, 0x4a, 0xfa, 0xcb, 0x3c, 0x84, 0xf5, 0x13, + 0xb6, 0x46, 0xcf, 0xa9, 0x3d, 0xa6, 0xbe, 0x15, 0xad, 0x7c, 0x7e, 0xdd, 0x5c, 0x65, 0xc8, 0x7d, + 0xc4, 0xa9, 0x8d, 0xc2, 0x24, 0x41, 0xc6, 0x78, 0xe8, 0xd8, 0x0a, 0x3d, 0x0b, 0x05, 0x44, 0xa1, + 0x71, 0xad, 0x71, 0xf0, 0xd0, 0x6b, 0x33, 0x60, 0x9c, 0xee, 0xcc, 0xb7, 0x67, 0xe7, 0xe2, 0x32, + 0xa8, 0xe8, 0x9e, 0x30, 0x20, 0x79, 0x0d, 0x8a, 0x6c, 0x4f, 0xb8, 0x94, 0x3b, 0x0f, 0xf0, 0x6b, + 0x96, 0x04, 0x91, 0xb7, 0x60, 0x09, 0xeb, 0x08, 0x9a, 0x0d, 0xdc, 0x10, 0xd5, 0xe8, 0xa8, 0x70, + 0x5c, 0x53, 0xe0, 0x98, 0xb8, 0x3d, 0xf7, 0x1d, 0xce, 0xc7, 0xca, 0x26, 0xfe, 0x26, 0x3f, 0xd4, + 0x98, 0xe2, 0x2a, 0xe6, 0x7d, 0x4b, 0xe4, 0x4d, 0x2c, 0xc5, 0xeb, 0xf8, 0xe3, 0xb7, 0xca, 0xad, + 0x7e, 0x94, 0x2f, 0x55, 0x1a, 0x55, 0xa3, 0x89, 0x4e, 0x3e, 0x26, 0x1d, 0x79, 0x17, 0xd4, 0xbf, + 0x8a, 0xed, 0x91, 0x0c, 0x6c, 0x2e, 0xa0, 0x22, 0x5f, 0x01, 0x5f, 0xc0, 0xad, 0xa9, 0x37, 0x96, + 0x42, 0x41, 0x55, 0x02, 0x0f, 0xbd, 0x31, 0x13, 0x5e, 0x56, 0x14, 0xd1, 0xa9, 0xe3, 0x3a, 0xc1, + 0x39, 0x1d, 0x0b, 0xd9, 0xa0, 0x21, 0x11, 0x7b, 0x02, 0xce, 0x24, 0xf0, 0x99, 0xef, 0x9d, 0xa9, + 0xa3, 0x32, 0x63, 0xaa, 0xb4, 0xf1, 0x29, 0x14, 0xf8, 0x0c, 0xb2, 0x8d, 0x82, 0xf3, 0x9b, 0x11, + 0x1b, 0x05, 0xa1, 0x4d, 0x28, 0xba, 0x34, 0x7c, 0xee, 0xf9, 0xcf, 0xa4, 0x6d, 0x4d, 0x24, 0x8d, + 0x9f, 0xa0, 0x52, 0x55, 0x79, 0x6b, 0x71, 0xe5, 0x03, 0x5b, 0xc2, 0x7c, 0x09, 0x06, 0xe7, 0xb6, + 0xd0, 0xf3, 0x96, 0x10, 0x30, 0x38, 0xb7, 0x17, 0x96, 0x70, 0x76, 0xd1, 0x61, 0xeb, 0x2d, 0xa8, + 0x4b, 0xff, 0xb0, 0xc0, 0x9a, 0xd0, 0xd3, 0x50, 0x6c, 0xc9, 0xaa, 0x70, 0x0e, 0x0b, 0x0e, 0xe8, + 0x69, 0x68, 0x1c, 0xc2, 0x8a, 0xd8, 0x34, 0xfd, 0x19, 0x95, 0x55, 0x7f, 0x96, 0x76, 0x2b, 0xaa, + 0x3c, 0x5c, 0x8d, 0x8b, 0x1b, 0x5c, 0xb0, 0x8b, 0x5d, 0x95, 0x8c, 0x1f, 0x47, 0x1a, 0x44, 0x26, + 0x8c, 0x88, 0xf2, 0xc4, 0xdd, 0x44, 0x9a, 0x24, 0xa5, 0xdb, 0x83, 0xba, 0x01, 0x39, 0x63, 0x36, + 0x3a, 0xc1, 0x7c, 0x34, 0x92, 0x7e, 0x7b, 0x25, 0x53, 0x26, 0x8d, 0x7f, 0x97, 0x81, 0x55, 0x2c, + 0x4c, 0xde, 0xea, 0xc4, 0x49, 0xf1, 0x53, 0x37, 0x92, 0xcd, 0x8f, 0x2e, 0x01, 0xf2, 0xc4, 0x37, + 0x37, 0xd2, 0xe4, 0x17, 0x8c, 0x34, 0xdf, 0x85, 0xc6, 0x98, 0x4e, 0x1c, 0x5c, 0x4a, 0x52, 0xa0, + 0xe2, 0x12, 0xec, 0xb2, 0x84, 0x0b, 0x2d, 0x83, 0xf1, 0x57, 0x32, 0xb0, 0xc2, 0xe5, 0x35, 0xd4, + 0xdb, 0x88, 0x81, 0x7a, 0x2c, 0x15, 0x14, 0x82, 0x9d, 0x8a, 0x3e, 0x45, 0x72, 0x0c, 0x42, 0x39, + 0xf1, 0xfe, 0x0d, 0xa1, 0xb8, 0x10, 0x50, 0xf2, 0x3d, 0xbc, 0x89, 0xba, 0x16, 0x02, 0x85, 0x1c, + 0x7e, 0x33, 0x45, 0x42, 0x54, 0xd9, 0xd9, 0x35, 0xd5, 0x45, 0xd0, 0x4e, 0x09, 0x96, 0xb8, 0x16, + 0xcc, 0xd8, 0x83, 0x5a, 0xac, 0x9a, 0x98, 0xa5, 0xa7, 0xca, 0x2d, 0x3d, 0x0b, 0xd6, 0xe0, 0xec, + 0xa2, 0x35, 0xf8, 0x0a, 0x56, 0x4d, 0x6a, 0x8f, 0xaf, 0xf6, 0x3c, 0xff, 0x28, 0x38, 0x09, 0xf7, + 0xb8, 0x10, 0xcc, 0xce, 0x20, 0xe5, 0xff, 0x11, 0x33, 0xa7, 0x48, 0x4b, 0xb7, 0x54, 0xc3, 0x7c, + 0x07, 0xea, 0x91, 0xa3, 0x88, 0xa6, 0x78, 0xaf, 0x29, 0x5f, 0x11, 0x94, 0x9d, 0x08, 0xe4, 0x67, + 0xc1, 0x49, 0x28, 0x54, 0xef, 0xf8, 0xdb, 0xf8, 0xab, 0x05, 0x20, 0x6c, 0x35, 0x27, 0x16, 0x4c, + 0xc2, 0xc5, 0x25, 0xbb, 0xe0, 0xe2, 0xf2, 0x00, 0x88, 0x46, 0x20, 0x3d, 0x6f, 0x72, 0xca, 0xf3, + 0xa6, 0x11, 0xd1, 0x0a, 0xc7, 0x9b, 0x07, 0xb0, 0x26, 0x6e, 0x14, 0xf1, 0xa6, 0xf2, 0xa5, 0x41, + 0xf8, 0xd5, 0x22, 0xd6, 0x5e, 0xe9, 0xde, 0x22, 0x35, 0xd5, 0x39, 0xee, 0xde, 0x22, 0x15, 0x4a, + 0xda, 0x02, 0x5c, 0x7a, 0xe9, 0x02, 0x2c, 0x2e, 0x2c, 0x40, 0x4d, 0xb9, 0x58, 0x8a, 0x2b, 0x17, + 0x17, 0xd4, 0xe4, 0x5c, 0x7c, 0x8e, 0xa9, 0xc9, 0xef, 0x41, 0x43, 0x2a, 0x9a, 0x94, 0x0a, 0x53, + 0xf8, 0x3c, 0x08, 0x5d, 0x92, 0x54, 0x62, 0xc6, 0x6c, 0x7a, 0x95, 0x57, 0x31, 0x2e, 0x56, 0xd3, + 0x8d, 0x8b, 0x8b, 0x2a, 0xb9, 0x5a, 0x8a, 0x4a, 0xee, 0x51, 0xe4, 0xd2, 0x10, 0x9c, 0x3b, 0x53, + 0x14, 0x7c, 0x22, 0x87, 0x4b, 0x31, 0xc0, 0x83, 0x73, 0x67, 0x6a, 0x4a, 0xe7, 0x22, 0x96, 0x20, + 0x6d, 0xb8, 0x23, 0xfa, 0x93, 0xe2, 0x17, 0xc4, 0x47, 0x61, 0x19, 0x25, 0xd5, 0x2d, 0x4e, 0x76, + 0x98, 0x70, 0x11, 0x4a, 0x0c, 0x8a, 0xf4, 0x2a, 0x09, 0xb8, 0x5e, 0x57, 0x0e, 0xca, 0x21, 0x77, + 0x2b, 0x09, 0x70, 0x88, 0xed, 0x4b, 0x4b, 0xe8, 0xfc, 0x82, 0x0b, 0x94, 0x93, 0x6a, 0x66, 0x65, + 0x6a, 0x5f, 0x1e, 0xa0, 0x4e, 0x2f, 0xb8, 0x30, 0xfe, 0x34, 0x03, 0x0d, 0xb6, 0x34, 0x63, 0xbb, + 0xfe, 0x73, 0x40, 0xfe, 0xf4, 0x8a, 0x9b, 0xbe, 0xc2, 0x68, 0xe5, 0x9e, 0xff, 0x14, 0x70, 0x13, + 0x5b, 0xde, 0x8c, 0xba, 0x62, 0xcb, 0x37, 0xe3, 0x5b, 0x3e, 0x62, 0xeb, 0xfb, 0x37, 0xf8, 0xa5, + 0x90, 0x41, 0xc8, 0xe7, 0x50, 0x66, 0x7b, 0x05, 0x17, 0xae, 0x70, 0x69, 0xde, 0x52, 0x17, 0xfd, + 0x85, 0x6d, 0xcb, 0xb2, 0xce, 0x44, 0x32, 0xcd, 0x69, 0x28, 0x9f, 0xe2, 0x34, 0xa4, 0xf1, 0x94, + 0x7d, 0x80, 0xa7, 0xf4, 0x8a, 0x0d, 0x42, 0xe8, 0xf9, 0x4c, 0xb6, 0x62, 0xdb, 0xeb, 0xd4, 0x9e, + 0x3a, 0x42, 0xd9, 0x58, 0x30, 0xcb, 0xcf, 0xe8, 0xd5, 0x1e, 0x02, 0xd8, 0xda, 0x62, 0xe8, 0x88, + 0xb1, 0x14, 0xcc, 0xd2, 0x33, 0x7a, 0xc5, 0xb9, 0x8a, 0x05, 0xb5, 0xa7, 0xf4, 0x6a, 0x97, 0x72, + 0xe1, 0xdd, 0xf3, 0xd9, 0xa0, 0xfb, 0xf6, 0x73, 0x26, 0xad, 0xc7, 0x9c, 0x5a, 0x2a, 0xbe, 0xfd, + 0xfc, 0x29, 0xbd, 0x92, 0x0e, 0x36, 0x45, 0x86, 0x9f, 0x78, 0x23, 0x21, 0x6e, 0x48, 0xfd, 0x4e, + 0xd4, 0x28, 0x73, 0xe9, 0x19, 0xfe, 0x36, 0xfe, 0x24, 0x03, 0x35, 0xd6, 0x7e, 0x3c, 0x29, 0x70, + 0x15, 0x09, 0x17, 0xd8, 0x4c, 0xe4, 0x02, 0xfb, 0x50, 0x30, 0x5a, 0x7e, 0xec, 0x64, 0xaf, 0x3f, + 0x76, 0x70, 0x6e, 0xf8, 0x99, 0xf3, 0x21, 0x94, 0xf9, 0xc2, 0x60, 0xac, 0x27, 0x17, 0x9b, 0xe0, + 0x58, 0x87, 0xcc, 0x12, 0x92, 0x3d, 0xe5, 0x1e, 0x77, 0x9a, 0x2a, 0x9d, 0x0f, 0x71, 0xd9, 0x57, + 0x0a, 0xf4, 0x94, 0x69, 0x28, 0x5c, 0xe3, 0x71, 0xa7, 0xeb, 0xa9, 0x97, 0x92, 0x7a, 0x6a, 0xc3, + 0x85, 0x12, 0x9b, 0x6a, 0xec, 0x6c, 0x4a, 0xa1, 0x99, 0xb4, 0x42, 0x99, 0x70, 0x62, 0xb3, 0x73, + 0x8a, 0xf1, 0xde, 0xac, 0x10, 0x4e, 0xec, 0x80, 0xb2, 0x82, 0x58, 0xc3, 0x5d, 0xcf, 0x42, 0xc5, + 0xaf, 0x50, 0x89, 0x96, 0xcc, 0xb2, 0xeb, 0x1d, 0x71, 0x80, 0xf1, 0xe7, 0x32, 0x50, 0xd1, 0xf6, + 0x2c, 0x5a, 0x02, 0xd4, 0x70, 0xf2, 0x0d, 0x1e, 0xdf, 0x01, 0xb1, 0xf9, 0xd8, 0xbf, 0x61, 0xd6, + 0x46, 0xb1, 0x09, 0xda, 0x16, 0x4b, 0x19, 0x73, 0x66, 0x63, 0xea, 0x27, 0xd9, 0x2f, 0xb9, 0x7e, + 0xd9, 0xef, 0x9d, 0x25, 0xc8, 0x33, 0x52, 0xe3, 0x31, 0xac, 0x68, 0xcd, 0xe0, 0xea, 0x99, 0x57, + 0x1d, 0x00, 0xe3, 0x17, 0x55, 0x66, 0x56, 0x07, 0x37, 0xad, 0x4b, 0xe7, 0x46, 0x3a, 0xe6, 0xe3, + 0x22, 0x9c, 0x28, 0x39, 0x08, 0x47, 0xe6, 0x15, 0xfd, 0xed, 0x8c, 0x5f, 0xcd, 0xc0, 0xaa, 0x56, + 0xfc, 0x9e, 0xe3, 0xda, 0x13, 0xe7, 0x27, 0x28, 0xa3, 0x04, 0xce, 0x99, 0x9b, 0xa8, 0x80, 0x83, + 0xbe, 0x49, 0x05, 0xec, 0x28, 0xe1, 0xae, 0xd2, 0xdc, 0xdd, 0x5e, 0x1c, 0x9f, 0x80, 0x30, 0xd3, + 0x7e, 0x3e, 0xbc, 0x34, 0xfe, 0x5a, 0x16, 0xd6, 0x44, 0x13, 0xd0, 0xa3, 0xdd, 0x61, 0xa2, 0xe9, + 0x61, 0x70, 0x46, 0x3e, 0x87, 0x1a, 0x1b, 0x3e, 0xcb, 0xa7, 0x67, 0x4e, 0x10, 0x52, 0x69, 0xf5, + 0x4f, 0xe1, 0xc6, 0x4c, 0x42, 0x61, 0xa4, 0xa6, 0xa0, 0x24, 0x8f, 0xa1, 0x82, 0x59, 0xb9, 0x86, + 0x4c, 0xcc, 0x55, 0x73, 0x31, 0x23, 0x9f, 0x8b, 0xfd, 0x1b, 0x26, 0x04, 0xd1, 0xcc, 0x3c, 0x86, + 0x0a, 0x4e, 0xf3, 0x05, 0x8e, 0x75, 0x82, 0xd9, 0x2d, 0xcc, 0x05, 0xcb, 0x3c, 0x8b, 0x66, 0xa6, + 0x05, 0x35, 0xce, 0xee, 0xc4, 0x48, 0x0a, 0x4f, 0xd9, 0xad, 0xc5, 0xec, 0x72, 0xac, 0x59, 0xe3, + 0x67, 0x5a, 0x7a, 0xa7, 0x0c, 0xc5, 0xd0, 0x77, 0xce, 0xce, 0xa8, 0x6f, 0x6c, 0xa8, 0xa1, 0x61, + 0x7c, 0x9c, 0x0e, 0x42, 0x3a, 0x63, 0x77, 0x0e, 0xe3, 0x5f, 0x66, 0xa0, 0x22, 0x38, 0xf3, 0x4f, + 0xed, 0x50, 0xb0, 0x95, 0xd0, 0xa5, 0x96, 0x35, 0xd5, 0xe9, 0x3b, 0xb0, 0x3c, 0x65, 0x17, 0x24, + 0x76, 0x81, 0x8f, 0x79, 0x13, 0xd4, 0x25, 0x58, 0xc8, 0xfe, 0xdb, 0xb0, 0x8a, 0x57, 0x81, 0xc0, + 0x0a, 0x9d, 0x89, 0x25, 0x91, 0xe2, 0x59, 0xc7, 0x0a, 0x47, 0x0d, 0x9d, 0xc9, 0xa1, 0x40, 0x30, + 0x89, 0x38, 0x08, 0xed, 0x33, 0x2a, 0xb8, 0x03, 0x4f, 0xb0, 0x4b, 0x57, 0xe2, 0xee, 0x2e, 0x2f, + 0x5d, 0xff, 0x7b, 0x05, 0x36, 0x17, 0x50, 0xe2, 0xd2, 0xa5, 0x8c, 0xb7, 0x13, 0x67, 0x7a, 0xe2, + 0x29, 0xe3, 0x41, 0x46, 0x33, 0xde, 0x1e, 0x30, 0x8c, 0x34, 0x1e, 0x50, 0x58, 0x97, 0x4b, 0x16, + 0xb5, 0xff, 0xea, 0x7a, 0x9f, 0xc5, 0xcb, 0xe7, 0x87, 0xf1, 0x63, 0x30, 0x59, 0x9d, 0x84, 0xeb, + 0xf2, 0xde, 0xea, 0x6c, 0x01, 0x16, 0x90, 0xff, 0x17, 0x9a, 0x6a, 0x67, 0x88, 0xbb, 0x88, 0xa6, + 0xab, 0x60, 0x35, 0xbd, 0xf7, 0x92, 0x9a, 0x62, 0x6a, 0x59, 0x14, 0x08, 0x37, 0xe4, 0xa6, 0xe2, + 0x05, 0xaa, 0xba, 0x2e, 0xe0, 0x75, 0x59, 0x17, 0xde, 0x2d, 0x16, 0x6b, 0xcc, 0xbf, 0x52, 0xdf, + 0x50, 0xe5, 0x1c, 0xab, 0xd6, 0xbc, 0x25, 0x0a, 0x56, 0x28, 0xbd, 0xde, 0x73, 0xd8, 0x78, 0x6e, + 0x3b, 0xa1, 0xec, 0xa3, 0xa6, 0x2a, 0x29, 0x60, 0x7d, 0x0f, 0x5f, 0x52, 0xdf, 0x97, 0x3c, 0x73, + 0xec, 0xb6, 0xb5, 0xf6, 0x7c, 0x11, 0x18, 0x6c, 0xfd, 0x9d, 0x1c, 0xd4, 0xe3, 0xa5, 0x30, 0xd6, + 0x23, 0x8e, 0x2b, 0x29, 0x44, 0x0b, 0xc9, 0x5e, 0x18, 0xb6, 0x7a, 0x5c, 0x78, 0x5e, 0x34, 0xb9, + 0x65, 0x53, 0x4c, 0x6e, 0xba, 0xa5, 0x2b, 0xf7, 0x32, 0xc7, 0x87, 0xfc, 0x2b, 0x39, 0x3e, 0x14, + 0xd2, 0x1c, 0x1f, 0x3e, 0xba, 0xd6, 0x52, 0xce, 0xf5, 0xd5, 0xa9, 0x56, 0xf2, 0x47, 0xd7, 0x5b, + 0xc9, 0xb9, 0x48, 0x7e, 0x9d, 0x85, 0x5c, 0xb3, 0xef, 0x97, 0xae, 0xb1, 0x4f, 0x69, 0x16, 0xff, + 0x14, 0x0b, 0x79, 0xf9, 0x1b, 0x58, 0xc8, 0xb7, 0xfe, 0x24, 0x03, 0x64, 0x71, 0x77, 0x90, 0x27, + 0xdc, 0x9a, 0xe9, 0xd2, 0x89, 0xe0, 0xdc, 0xef, 0xbf, 0xda, 0x0e, 0x93, 0x0b, 0x42, 0xe6, 0x26, + 0x1f, 0xc0, 0xaa, 0xfe, 0xf8, 0x4c, 0x57, 0x45, 0xd4, 0x4c, 0xa2, 0xa3, 0x22, 0xa5, 0x9a, 0xe6, + 0x65, 0x92, 0x7f, 0xa9, 0x97, 0x49, 0xe1, 0xa5, 0x5e, 0x26, 0x4b, 0x71, 0x2f, 0x93, 0xad, 0x7f, + 0x9b, 0x81, 0xd5, 0x94, 0x45, 0xfc, 0xed, 0xf5, 0x99, 0xad, 0xbd, 0x18, 0x5b, 0xcb, 0x8a, 0xb5, + 0xa7, 0x73, 0xb4, 0x03, 0xa9, 0x88, 0x65, 0x53, 0x11, 0x88, 0x93, 0xea, 0xfe, 0xcb, 0xb8, 0x4b, + 0x94, 0xc3, 0xd4, 0xb3, 0x6f, 0xfd, 0xbd, 0x2c, 0x54, 0x34, 0x24, 0x1b, 0x45, 0xbe, 0x64, 0x35, + 0xff, 0x4b, 0x2e, 0x5b, 0xa2, 0x22, 0x05, 0x9d, 0xe9, 0x71, 0x71, 0x22, 0x9e, 0x6f, 0x2e, 0x21, + 0x48, 0x22, 0xc1, 0x36, 0xac, 0x4a, 0x4b, 0x33, 0x8d, 0xdc, 0xc4, 0xc5, 0x59, 0x23, 0x9c, 0x06, + 0x44, 0x23, 0x91, 0xfe, 0x03, 0x79, 0xc7, 0x8d, 0xe6, 0x4e, 0xb3, 0xdc, 0xad, 0x08, 0x77, 0x05, + 0x31, 0x89, 0x6c, 0x9d, 0x7f, 0x08, 0xeb, 0xca, 0x5f, 0x21, 0x96, 0x83, 0xdb, 0x87, 0x88, 0xf4, + 0x4b, 0xd0, 0xb2, 0xfc, 0x10, 0x6e, 0x27, 0xda, 0x94, 0xc8, 0xca, 0xfd, 0xdc, 0x6e, 0xc6, 0x5a, + 0xa7, 0x97, 0xb0, 0xf5, 0xff, 0x41, 0x2d, 0xc6, 0x28, 0xbf, 0xbd, 0x29, 0x4f, 0x2a, 0xaf, 0xf8, + 0x88, 0xea, 0xca, 0xab, 0xad, 0xff, 0x99, 0x03, 0xb2, 0xc8, 0xab, 0x7f, 0x96, 0x4d, 0x58, 0x5c, + 0x98, 0xb9, 0x94, 0x85, 0xf9, 0x7f, 0x4d, 0x7e, 0x88, 0x74, 0xa8, 0x9a, 0xbb, 0x00, 0xdf, 0x9c, + 0x0d, 0x85, 0x90, 0xad, 0xf8, 0x34, 0xe9, 0x54, 0x55, 0x8a, 0xbd, 0x9f, 0xd4, 0x04, 0xa8, 0x84, + 0x6f, 0xd5, 0x31, 0x2c, 0xd9, 0xee, 0xe8, 0xdc, 0xf3, 0x05, 0x1f, 0xfc, 0xb9, 0x6f, 0x7c, 0x7c, + 0x6e, 0xb7, 0x30, 0x3f, 0x4a, 0x6d, 0xa6, 0x28, 0xcc, 0xf8, 0x10, 0x2a, 0x1a, 0x98, 0x94, 0xa1, + 0x70, 0xd0, 0x3d, 0xdc, 0xe9, 0x37, 0x6e, 0x90, 0x1a, 0x94, 0xcd, 0x4e, 0xbb, 0xff, 0x45, 0xc7, + 0xec, 0xec, 0x36, 0x32, 0xa4, 0x04, 0xf9, 0x83, 0xfe, 0x60, 0xd8, 0xc8, 0x1a, 0x5b, 0xd0, 0x14, + 0x25, 0x2e, 0x5a, 0x93, 0x7e, 0x2b, 0xaf, 0x74, 0xa0, 0x88, 0x14, 0x97, 0xfc, 0x8f, 0xa0, 0xaa, + 0x8b, 0x37, 0x62, 0x45, 0x24, 0x3c, 0x56, 0xd8, 0xf5, 0xde, 0xd3, 0x78, 0x75, 0x1b, 0xb8, 0xbf, + 0xc2, 0x58, 0x65, 0xcb, 0xc6, 0xe4, 0xd6, 0x14, 0xc3, 0x2f, 0xde, 0x8f, 0x62, 0xcb, 0xf0, 0xff, + 0x81, 0x7a, 0xdc, 0x72, 0x22, 0x38, 0x52, 0xda, 0x95, 0x95, 0xe5, 0x8e, 0x99, 0x52, 0xc8, 0x0f, + 0xa1, 0x91, 0xb4, 0xbc, 0x08, 0xe1, 0xf9, 0x9a, 0xfc, 0xcb, 0x4e, 0xdc, 0x18, 0x43, 0xf6, 0x61, + 0x2d, 0x4d, 0xc0, 0xc3, 0xf5, 0x71, 0xbd, 0x9a, 0x83, 0x2c, 0x0a, 0x71, 0xe4, 0x33, 0x61, 0x81, + 0x2b, 0xe0, 0xf4, 0xbf, 0x15, 0xaf, 0x5f, 0x1b, 0xec, 0x6d, 0xfe, 0x4f, 0xb3, 0xc5, 0x5d, 0x00, + 0x44, 0x30, 0xd2, 0x80, 0x6a, 0xff, 0xa8, 0xd3, 0xb3, 0xda, 0xfb, 0xad, 0x5e, 0xaf, 0x73, 0xd0, + 0xb8, 0x41, 0x08, 0xd4, 0xd1, 0xe9, 0x62, 0x57, 0xc1, 0x32, 0x0c, 0x26, 0x2c, 0xa1, 0x12, 0x96, + 0x25, 0x6b, 0xd0, 0xe8, 0xf6, 0x12, 0xd0, 0x1c, 0x69, 0xc2, 0xda, 0x51, 0x87, 0xfb, 0x69, 0xc4, + 0xca, 0xcd, 0xb3, 0x4b, 0x83, 0xe8, 0x2e, 0xbb, 0x34, 0x7c, 0x69, 0x4f, 0x26, 0x34, 0x14, 0xfb, + 0x40, 0xca, 0xd2, 0x7f, 0x3d, 0x03, 0xeb, 0x09, 0x44, 0x64, 0xbe, 0xe0, 0x92, 0x74, 0x5c, 0x86, + 0xae, 0x22, 0x50, 0xee, 0xa6, 0x77, 0x61, 0x45, 0x69, 0xd3, 0x12, 0xa7, 0x52, 0x43, 0x21, 0x24, + 0xf1, 0x07, 0xb0, 0xaa, 0x29, 0xe5, 0x12, 0xbc, 0x82, 0x68, 0x28, 0x91, 0xc1, 0xd8, 0x86, 0x25, + 0xa1, 0xb8, 0x6c, 0x40, 0x4e, 0x3e, 0x5c, 0xc9, 0x9b, 0xec, 0x27, 0x21, 0x90, 0x9f, 0x46, 0xee, + 0xbe, 0xf8, 0xdb, 0xd8, 0x54, 0x2f, 0xd0, 0x12, 0xbd, 0xfc, 0xd5, 0x3c, 0x6c, 0x24, 0x31, 0xca, + 0x01, 0xbe, 0x18, 0xeb, 0x20, 0x37, 0x64, 0x09, 0x10, 0xf9, 0x38, 0xb1, 0x7a, 0x62, 0x5d, 0x44, + 0x52, 0x7d, 0xa5, 0xc8, 0x8e, 0x3e, 0x4c, 0xca, 0x88, 0x7c, 0xc9, 0xd7, 0xa4, 0xd3, 0x3f, 0xf6, + 0x29, 0x21, 0x32, 0x7e, 0xbc, 0x20, 0x32, 0xe6, 0xd3, 0x32, 0x25, 0x24, 0xc8, 0x0e, 0x6c, 0x46, + 0x8e, 0xad, 0xf1, 0x3a, 0x0b, 0x69, 0xd9, 0xd7, 0x15, 0xf5, 0x81, 0x5e, 0xf9, 0x13, 0x68, 0x46, + 0xc5, 0x24, 0x9a, 0xb1, 0x94, 0x56, 0xce, 0x86, 0x22, 0x37, 0x63, 0xed, 0xf9, 0x11, 0x6c, 0xc5, + 0xc6, 0x2b, 0xde, 0xa4, 0x62, 0x5a, 0x51, 0x9b, 0xda, 0x00, 0xc6, 0x1a, 0x75, 0x00, 0xb7, 0x62, + 0x65, 0x25, 0xda, 0x55, 0x4a, 0x2b, 0xac, 0xa9, 0x15, 0x16, 0x6b, 0x99, 0xf1, 0x3b, 0x4b, 0x40, + 0x7e, 0x3c, 0xa7, 0xfe, 0x15, 0xbe, 0x4b, 0x0d, 0x5e, 0xe6, 0xb1, 0x2f, 0x15, 0x6f, 0xd9, 0x57, + 0x7a, 0x7b, 0x9e, 0xf6, 0xf6, 0x3b, 0xff, 0xf2, 0xb7, 0xdf, 0x85, 0x97, 0xbd, 0xfd, 0x7e, 0x13, + 0x6a, 0xce, 0x99, 0xeb, 0xb1, 0x73, 0x8d, 0x5d, 0x6b, 0x82, 0xe6, 0xd2, 0xdd, 0xdc, 0xbd, 0xaa, + 0x59, 0x15, 0x40, 0x76, 0xa9, 0x09, 0xc8, 0xe3, 0x88, 0x88, 0x8e, 0xcf, 0x30, 0xfe, 0x81, 0x7e, + 0xa2, 0x75, 0xc6, 0x67, 0x54, 0xe8, 0x19, 0x71, 0xc1, 0xca, 0xcc, 0x0c, 0x1e, 0x90, 0xb7, 0xa0, + 0x1e, 0x78, 0x73, 0x76, 0x4b, 0x94, 0xc3, 0xc0, 0xcd, 0xcd, 0x55, 0x0e, 0x3d, 0x92, 0xce, 0x07, + 0xab, 0xf3, 0x80, 0x5a, 0x53, 0x27, 0x08, 0x98, 0xac, 0x3d, 0xf2, 0xdc, 0xd0, 0xf7, 0x26, 0xc2, + 0x82, 0xbc, 0x32, 0x0f, 0xe8, 0x21, 0xc7, 0xb4, 0x39, 0x82, 0x7c, 0x1c, 0x35, 0x69, 0x66, 0x3b, + 0x7e, 0xd0, 0x04, 0x6c, 0x92, 0xec, 0x29, 0x5e, 0xc6, 0x6c, 0xc7, 0x57, 0x6d, 0x61, 0x89, 0x20, + 0xf1, 0x26, 0xbd, 0x92, 0x7c, 0x93, 0xfe, 0x2b, 0xe9, 0x6f, 0xd2, 0xb9, 0xd3, 0xdc, 0x03, 0x51, + 0xf4, 0xe2, 0x14, 0x7f, 0xa3, 0xa7, 0xe9, 0x8b, 0x4f, 0xed, 0xeb, 0xdf, 0xe4, 0xa9, 0xfd, 0x72, + 0xda, 0x53, 0xfb, 0x0f, 0xa1, 0x82, 0x8f, 0xa0, 0xad, 0x73, 0x74, 0x9d, 0xe5, 0x16, 0xf1, 0x86, + 0xfe, 0x4a, 0x7a, 0xdf, 0x71, 0x43, 0x13, 0x7c, 0xf9, 0x33, 0x58, 0x7c, 0xf5, 0xbe, 0xf2, 0x33, + 0x7c, 0xf5, 0x2e, 0x1e, 0x6b, 0x6f, 0x43, 0x49, 0xce, 0x13, 0x63, 0xb6, 0xa7, 0xbe, 0x37, 0x95, + 0x56, 0x38, 0xf6, 0x9b, 0xd4, 0x21, 0x1b, 0x7a, 0x22, 0x73, 0x36, 0xf4, 0x8c, 0x5f, 0x82, 0x8a, + 0xb6, 0xd4, 0xc8, 0x1b, 0x5c, 0x4d, 0xcd, 0x2e, 0xda, 0xe2, 0xa2, 0xc0, 0x47, 0xb1, 0x2c, 0xa0, + 0xdd, 0x31, 0x3b, 0x3c, 0xc6, 0x8e, 0x4f, 0x31, 0x3e, 0x85, 0xe5, 0xd3, 0x0b, 0xea, 0x07, 0xd2, + 0x2a, 0xda, 0x50, 0x08, 0x93, 0xc3, 0x8d, 0x5f, 0x86, 0xd5, 0xd8, 0xdc, 0x0a, 0xf6, 0xfd, 0x16, + 0x2c, 0xe1, 0xb8, 0x49, 0xd7, 0x9b, 0xf8, 0xeb, 0x73, 0x81, 0xc3, 0x58, 0x1c, 0xdc, 0xa0, 0x6b, + 0xcd, 0x7c, 0xef, 0x04, 0x2b, 0xc9, 0x98, 0x15, 0x01, 0x3b, 0xf2, 0xbd, 0x13, 0xe3, 0x0f, 0x73, + 0x90, 0xdb, 0xf7, 0x66, 0xba, 0xbb, 0x6d, 0x66, 0xc1, 0xdd, 0x56, 0x68, 0x0f, 0x2c, 0xa5, 0x1d, + 0x10, 0x17, 0x30, 0x34, 0x65, 0x4a, 0x0d, 0xc1, 0x3d, 0xa8, 0x33, 0x3e, 0x11, 0x7a, 0x96, 0x78, + 0xe6, 0xc2, 0x4f, 0x38, 0xbe, 0xf9, 0xec, 0x69, 0x38, 0xf4, 0xf6, 0x38, 0x9c, 0xac, 0x41, 0x4e, + 0xdd, 0x45, 0x11, 0xcd, 0x92, 0x64, 0x03, 0x96, 0xf0, 0x79, 0x8e, 0x7c, 0xaa, 0x2c, 0x52, 0xe4, + 0x7d, 0x58, 0x8d, 0x97, 0xcb, 0x59, 0x91, 0x10, 0x74, 0xf5, 0x82, 0x91, 0x27, 0xdd, 0x04, 0xc6, + 0x47, 0xa2, 0xc7, 0xca, 0x39, 0xb3, 0x78, 0x4a, 0x29, 0xa2, 0x34, 0xa6, 0x57, 0x8a, 0x31, 0xbd, + 0x3b, 0x50, 0x09, 0x27, 0x17, 0xd6, 0xcc, 0xbe, 0x9a, 0x78, 0xb6, 0x7c, 0x93, 0x07, 0xe1, 0xe4, + 0xe2, 0x88, 0x43, 0xc8, 0x07, 0x00, 0xd3, 0xd9, 0x4c, 0xec, 0x3d, 0x34, 0xcf, 0x45, 0x4b, 0xf9, + 0xf0, 0xe8, 0x88, 0x2f, 0x39, 0xb3, 0x3c, 0x9d, 0xcd, 0xf8, 0x4f, 0xb2, 0x0b, 0xf5, 0xd4, 0x18, + 0x12, 0xb7, 0xe5, 0x23, 0x06, 0x6f, 0xb6, 0x9d, 0xb2, 0x39, 0x6b, 0x23, 0x1d, 0xb6, 0xf5, 0x43, + 0x20, 0x7f, 0xc6, 0x48, 0x0e, 0x43, 0x28, 0xab, 0xf6, 0xe9, 0x81, 0x10, 0xf0, 0xe5, 0x58, 0x25, + 0x16, 0x08, 0xa1, 0x35, 0x1e, 0xfb, 0x8c, 0x2f, 0x72, 0xe9, 0x47, 0xb1, 0x7c, 0xd0, 0xc4, 0x1f, + 0xf1, 0xfc, 0xc7, 0xf8, 0x2f, 0x19, 0x28, 0xf0, 0xa8, 0x0c, 0x6f, 0xc3, 0x32, 0xa7, 0x57, 0xae, + 0xcb, 0xc2, 0xe1, 0x84, 0x0b, 0x51, 0x43, 0xe1, 0xb5, 0xcc, 0xb6, 0x85, 0x16, 0xa9, 0x26, 0x12, + 0x23, 0xb4, 0x68, 0x35, 0x77, 0xa0, 0xac, 0xaa, 0xd6, 0x96, 0x4e, 0x49, 0xd6, 0x4c, 0x5e, 0x87, + 0xfc, 0xb9, 0x37, 0x93, 0x6a, 0x3c, 0x88, 0x46, 0xd2, 0x44, 0x78, 0xd4, 0x16, 0x56, 0x47, 0xf4, + 0x2c, 0x29, 0x27, 0xda, 0xc2, 0x2a, 0x91, 0x6f, 0xd5, 0x13, 0x7d, 0x5c, 0x4a, 0xe9, 0xe3, 0x31, + 0x2c, 0x33, 0x3e, 0xa0, 0x79, 0xbd, 0x5c, 0x7f, 0x68, 0x7e, 0x97, 0x89, 0xeb, 0xa3, 0xc9, 0x7c, + 0x4c, 0x75, 0x45, 0x2a, 0xfa, 0xa1, 0x0a, 0xb8, 0xbc, 0x26, 0x19, 0xbf, 0x93, 0xe1, 0xfc, 0x85, + 0x95, 0x4b, 0xee, 0x41, 0xde, 0x95, 0x1e, 0x32, 0x91, 0x50, 0xae, 0x9e, 0xf0, 0x31, 0x3a, 0x13, + 0x29, 0xd8, 0xd4, 0xa1, 0x5f, 0x89, 0x5e, 0x7a, 0xcd, 0xac, 0xb8, 0xf3, 0xa9, 0xd2, 0x43, 0x7e, + 0x47, 0x76, 0x2b, 0xa1, 0xc3, 0xe3, 0xbd, 0x57, 0xdb, 0x74, 0x5b, 0x73, 0x68, 0xcd, 0xc7, 0x4e, + 0x4c, 0x29, 0xd2, 0x8f, 0xcf, 0xa8, 0xe6, 0xc8, 0xfa, 0x7b, 0x59, 0xa8, 0xc5, 0x5a, 0x84, 0x1e, + 0xbd, 0xec, 0x00, 0xe0, 0x76, 0x46, 0x31, 0xdf, 0xe8, 0x38, 0x29, 0x6e, 0x5d, 0xda, 0x38, 0x65, + 0x63, 0xe3, 0xa4, 0x5c, 0xdc, 0x72, 0xba, 0x8b, 0xdb, 0x03, 0x28, 0x47, 0x11, 0x8a, 0xe2, 0x4d, + 0x62, 0xf5, 0xc9, 0x87, 0x8c, 0x11, 0x51, 0xe4, 0x14, 0x57, 0xd0, 0x9d, 0xe2, 0xbe, 0xaf, 0xf9, + 0x50, 0x2d, 0x61, 0x31, 0x46, 0xda, 0x88, 0xfe, 0x4c, 0x3c, 0xa8, 0x8c, 0xc7, 0x50, 0xd1, 0x1a, + 0xaf, 0xfb, 0x21, 0x65, 0x62, 0x7e, 0x48, 0xea, 0x49, 0x73, 0x36, 0x7a, 0xd2, 0x6c, 0xfc, 0x7a, + 0x16, 0x6a, 0x6c, 0x7f, 0x39, 0xee, 0xd9, 0x91, 0x37, 0x71, 0x46, 0x68, 0x77, 0x54, 0x3b, 0x4c, + 0x08, 0x5a, 0x72, 0x9f, 0x89, 0x2d, 0xc6, 0xe5, 0x2c, 0x3d, 0x6c, 0x06, 0x67, 0xd2, 0x2a, 0x6c, + 0x86, 0x01, 0x35, 0xc6, 0x18, 0xd1, 0x82, 0x18, 0xc5, 0x39, 0x32, 0x2b, 0xa7, 0x94, 0xee, 0xd8, + 0x01, 0xe7, 0x90, 0xef, 0xc3, 0x2a, 0xa3, 0xc1, 0x47, 0xf1, 0x53, 0x67, 0x32, 0x71, 0xa2, 0x77, + 0x80, 0x39, 0xb3, 0x71, 0x4a, 0xa9, 0x69, 0x87, 0xf4, 0x90, 0x21, 0x44, 0x58, 0xa4, 0xd2, 0xd8, + 0x09, 0xec, 0x93, 0xc8, 0xef, 0x5a, 0xa5, 0xa5, 0x61, 0x3e, 0xf2, 0x7d, 0x58, 0x12, 0x4f, 0x04, + 0xb9, 0xe5, 0x1e, 0xf3, 0x27, 0x56, 0x52, 0x31, 0xb9, 0x92, 0x8c, 0x7f, 0x9a, 0x85, 0x8a, 0xb6, + 0x2c, 0x5f, 0xe5, 0x74, 0xbd, 0xbd, 0x60, 0x27, 0x2e, 0xeb, 0x26, 0xe1, 0x37, 0xe3, 0x55, 0xe6, + 0xd4, 0x63, 0x31, 0x7d, 0x01, 0xdf, 0x82, 0x32, 0xdb, 0x75, 0x1f, 0xa2, 0x3e, 0x5d, 0x84, 0x25, + 0x43, 0xc0, 0xd1, 0xfc, 0x44, 0x22, 0x1f, 0x22, 0xb2, 0x10, 0x21, 0x1f, 0x32, 0xe4, 0x8b, 0x1e, + 0x8b, 0x7c, 0x0a, 0x55, 0x51, 0x2a, 0xce, 0xa9, 0xb8, 0x16, 0xac, 0x69, 0x27, 0xb7, 0x9a, 0x6f, + 0xb3, 0xc2, 0xab, 0xe3, 0x93, 0x2f, 0x32, 0x3e, 0x94, 0x19, 0x4b, 0x2f, 0xcb, 0xf8, 0x90, 0x27, + 0x8c, 0x3d, 0xf5, 0xfe, 0x06, 0xbd, 0x17, 0x25, 0x1f, 0xfb, 0x00, 0x56, 0x25, 0xbb, 0x9a, 0xbb, + 0xb6, 0xeb, 0x7a, 0x73, 0x77, 0x44, 0xe5, 0x5b, 0x64, 0x22, 0x50, 0xc7, 0x11, 0xc6, 0x18, 0xab, + 0x60, 0x1b, 0xdc, 0x0b, 0xf2, 0x3e, 0x14, 0xb8, 0x5c, 0xce, 0x85, 0x8f, 0x74, 0xc6, 0xc5, 0x49, + 0xc8, 0x3d, 0x28, 0x70, 0xf1, 0x3c, 0x7b, 0x2d, 0xb3, 0xe1, 0x04, 0x46, 0x0b, 0x08, 0xcb, 0x78, + 0x48, 0x43, 0xdf, 0x19, 0x05, 0xd1, 0x33, 0xe7, 0x42, 0x78, 0x35, 0x13, 0x75, 0x45, 0x6a, 0xf8, + 0x88, 0x12, 0x15, 0x0e, 0x9c, 0x86, 0x1d, 0x4c, 0xab, 0xb1, 0x32, 0x84, 0xb8, 0x34, 0x81, 0x8d, + 0x13, 0x1a, 0x3e, 0xa7, 0xd4, 0x75, 0x99, 0x30, 0x34, 0xa2, 0x6e, 0xe8, 0xdb, 0x13, 0x36, 0x49, + 0xbc, 0x07, 0x8f, 0x16, 0x4a, 0x8d, 0x14, 0x5a, 0x3b, 0x51, 0xc6, 0xb6, 0xca, 0xc7, 0x79, 0xc7, + 0xfa, 0x49, 0x1a, 0x6e, 0xeb, 0x17, 0x61, 0xeb, 0xfa, 0x4c, 0x29, 0xc1, 0x12, 0xee, 0xc5, 0xb9, + 0x8a, 0x32, 0xea, 0x4e, 0x3c, 0x3b, 0xe4, 0xad, 0xd1, 0x39, 0x4b, 0x0f, 0x2a, 0x1a, 0x26, 0x3a, + 0xfb, 0x33, 0x28, 0xdc, 0xf1, 0x04, 0x3b, 0x91, 0x5c, 0xcf, 0x9f, 0xa2, 0x11, 0x75, 0x6c, 0x45, + 0xa5, 0x67, 0xcc, 0xe5, 0x08, 0x8e, 0x7e, 0x37, 0xc6, 0x36, 0x2c, 0xa3, 0x64, 0xaf, 0x1d, 0x74, + 0x2f, 0x12, 0x06, 0x8d, 0x35, 0x20, 0x3d, 0xce, 0xbb, 0x74, 0x8f, 0xd0, 0x7f, 0x9f, 0x83, 0x8a, + 0x06, 0x66, 0xa7, 0x11, 0xba, 0xd1, 0x5a, 0x63, 0xc7, 0x9e, 0x52, 0x69, 0xb1, 0xae, 0x99, 0x35, + 0x84, 0xee, 0x0a, 0x20, 0x3b, 0x8b, 0xed, 0x8b, 0x33, 0xcb, 0x9b, 0x87, 0xd6, 0x98, 0x9e, 0xf9, + 0x54, 0xb6, 0xb2, 0x6a, 0x5f, 0x9c, 0xf5, 0xe7, 0xe1, 0x2e, 0xc2, 0x64, 0x74, 0x19, 0x8d, 0x2a, + 0xa7, 0xa2, 0xcb, 0x44, 0x54, 0xc2, 0xfd, 0x98, 0xaf, 0xcc, 0xbc, 0x72, 0x3f, 0xe6, 0xb7, 0xc5, + 0xe4, 0x01, 0x5a, 0x58, 0x3c, 0x40, 0x3f, 0x86, 0x0d, 0x7e, 0x80, 0x0a, 0xd6, 0x6c, 0x25, 0x76, + 0xf2, 0x1a, 0x62, 0x45, 0x27, 0x35, 0xb1, 0xb7, 0xc1, 0x7a, 0x20, 0xd9, 0x52, 0xe0, 0xfc, 0x84, + 0x33, 0xb2, 0x8c, 0xc9, 0x7a, 0x26, 0x0a, 0x1f, 0x38, 0x3f, 0xa1, 0x32, 0xba, 0x4d, 0x8c, 0x52, + 0x3c, 0x05, 0x9b, 0x3a, 0x6e, 0x92, 0xd2, 0xbe, 0x8c, 0x53, 0x96, 0x05, 0xa5, 0x7d, 0xa9, 0x53, + 0x3e, 0x82, 0xcd, 0x29, 0x1d, 0x3b, 0x76, 0xbc, 0x58, 0x2b, 0x12, 0xdc, 0xd6, 0x38, 0x5a, 0xcb, + 0x33, 0xe0, 0x17, 0x77, 0x36, 0x1a, 0x3f, 0xf1, 0xa6, 0x27, 0x0e, 0x97, 0x59, 0xb8, 0x47, 0x59, + 0xde, 0xac, 0xbb, 0xf3, 0xe9, 0x2f, 0x20, 0x98, 0x65, 0x09, 0x8c, 0x1a, 0x54, 0x06, 0xa1, 0x37, + 0x93, 0xd3, 0x5c, 0x87, 0x2a, 0x4f, 0x8a, 0x67, 0xfc, 0xb7, 0xe0, 0x26, 0xb2, 0x84, 0xa1, 0x37, + 0xf3, 0x26, 0xde, 0xd9, 0x55, 0x4c, 0x29, 0xfb, 0xaf, 0x32, 0xb0, 0x1a, 0xc3, 0x0a, 0xf6, 0xfa, + 0x31, 0xe7, 0x67, 0xea, 0x09, 0x70, 0x26, 0xf6, 0xfe, 0x8b, 0xcd, 0x17, 0x27, 0xe4, 0xcc, 0x4c, + 0x3e, 0x0b, 0x6e, 0x45, 0xa1, 0xa3, 0x64, 0x46, 0xce, 0x52, 0x9a, 0x8b, 0x2c, 0x45, 0xe4, 0x97, + 0x41, 0xa5, 0x64, 0x11, 0x3f, 0x27, 0x9e, 0xeb, 0x8d, 0x45, 0x97, 0x73, 0xf1, 0x07, 0x3d, 0xba, + 0x02, 0x57, 0xb6, 0x20, 0xd2, 0xea, 0x06, 0xc6, 0xdf, 0xcd, 0x00, 0x44, 0xad, 0xc3, 0x27, 0x45, + 0x4a, 0x6e, 0xc9, 0xa0, 0x33, 0xb7, 0x26, 0xa3, 0xbc, 0x01, 0x55, 0xe5, 0xf7, 0x1f, 0x49, 0x42, + 0x15, 0x09, 0x63, 0xe2, 0xd0, 0x3b, 0xb0, 0x7c, 0x36, 0xf1, 0x4e, 0x50, 0x62, 0x15, 0x72, 0x0b, + 0x77, 0x09, 0xa9, 0x73, 0xb0, 0x94, 0x46, 0x22, 0xb9, 0x29, 0x9f, 0xfa, 0x34, 0x40, 0x97, 0x82, + 0x8c, 0xbf, 0x94, 0x55, 0xce, 0xc5, 0xd1, 0x48, 0xbc, 0xf8, 0x7a, 0xf7, 0xd3, 0xb8, 0x56, 0xbd, + 0xc8, 0x56, 0xfc, 0x18, 0xea, 0x3e, 0x3f, 0x94, 0xe4, 0x89, 0x95, 0x7f, 0xc1, 0x89, 0x55, 0xf3, + 0x63, 0x92, 0xce, 0x77, 0xa1, 0x61, 0x8f, 0x2f, 0xa8, 0x1f, 0x3a, 0x68, 0x7a, 0x41, 0xf9, 0x58, + 0xb8, 0xf3, 0x6a, 0x70, 0x14, 0x44, 0xdf, 0x81, 0x65, 0x11, 0x5a, 0x42, 0x51, 0x8a, 0x18, 0x85, + 0x11, 0x98, 0x11, 0x1a, 0xff, 0x50, 0x7a, 0x33, 0xc7, 0x67, 0xf7, 0xc5, 0xa3, 0xa2, 0xf7, 0x30, + 0xbb, 0x68, 0x0d, 0x17, 0x0b, 0x49, 0x58, 0x74, 0x04, 0x3f, 0xe2, 0x40, 0x61, 0xcf, 0x89, 0x0f, + 0x6b, 0xfe, 0x55, 0x86, 0xd5, 0xf8, 0x37, 0x19, 0x28, 0xee, 0x7b, 0xb3, 0x7d, 0x87, 0xbf, 0x89, + 0xc1, 0x6d, 0xa2, 0x0c, 0x8e, 0x4b, 0x2c, 0x89, 0x7e, 0x60, 0x2f, 0x78, 0x1a, 0x9b, 0x2a, 0xe6, + 0xd5, 0xe2, 0x62, 0xde, 0xf7, 0xe1, 0x16, 0xda, 0x73, 0x7d, 0x6f, 0xe6, 0xf9, 0x6c, 0xab, 0xda, + 0x13, 0x2e, 0xee, 0x79, 0x6e, 0x78, 0x2e, 0x79, 0xe7, 0xcd, 0x53, 0x4a, 0x8f, 0x34, 0x8a, 0x43, + 0x45, 0x80, 0xcf, 0xe2, 0x27, 0xe1, 0x85, 0xc5, 0x6f, 0xe8, 0x42, 0x1e, 0xe5, 0x1c, 0x75, 0x99, + 0x21, 0x3a, 0x08, 0x47, 0x89, 0xd4, 0xf8, 0x0c, 0xca, 0x4a, 0xd9, 0x43, 0xde, 0x85, 0xf2, 0xb9, + 0x37, 0x13, 0x1a, 0xa1, 0x4c, 0xec, 0xf9, 0xb0, 0xe8, 0xb5, 0x59, 0x3a, 0xe7, 0x3f, 0x02, 0xe3, + 0x0f, 0x8b, 0x50, 0xec, 0xba, 0x17, 0x9e, 0x33, 0x42, 0x7f, 0xe8, 0x29, 0x9d, 0x7a, 0x32, 0xf2, + 0x0d, 0xfb, 0x8d, 0xae, 0x7a, 0x51, 0xa4, 0xc1, 0x9c, 0x70, 0xd5, 0x53, 0x31, 0x06, 0xd7, 0x61, + 0xc9, 0xd7, 0x43, 0x05, 0x16, 0x7c, 0x7c, 0x45, 0xa2, 0xce, 0xcb, 0x82, 0x16, 0x99, 0x88, 0x95, + 0xc5, 0x5d, 0x55, 0x71, 0xc8, 0xf8, 0xd3, 0xf6, 0x32, 0x42, 0x70, 0xc0, 0x5e, 0x83, 0xa2, 0xd0, + 0xfb, 0xf2, 0xb7, 0x83, 0x5c, 0x5b, 0x2e, 0x40, 0xb8, 0x1a, 0x7c, 0xca, 0xed, 0xf1, 0x4a, 0x90, + 0xcd, 0x99, 0x55, 0x09, 0xdc, 0x65, 0x6b, 0xed, 0x0e, 0x54, 0x38, 0x3d, 0x27, 0x29, 0x09, 0x37, + 0x62, 0x04, 0x21, 0x41, 0x4a, 0xc4, 0xcd, 0x72, 0x6a, 0xc4, 0x4d, 0x74, 0x78, 0x57, 0x5c, 0x96, + 0x77, 0x11, 0x78, 0x9c, 0x45, 0x0d, 0x2e, 0xc3, 0xd8, 0x0a, 0x9d, 0x0a, 0x8f, 0xfa, 0x20, 0x75, + 0x2a, 0x6f, 0x42, 0xed, 0xd4, 0x9e, 0x4c, 0x4e, 0xec, 0xd1, 0x33, 0xae, 0x0a, 0xa8, 0x72, 0xed, + 0xa7, 0x04, 0xa2, 0x2e, 0xe0, 0x0e, 0x54, 0xb4, 0x59, 0x46, 0x1f, 0xe1, 0xbc, 0x09, 0xd1, 0xfc, + 0x26, 0x35, 0x7c, 0xf5, 0x57, 0xd0, 0xf0, 0x69, 0xbe, 0xd2, 0xcb, 0x71, 0x5f, 0xe9, 0x5b, 0xc8, + 0x4d, 0x85, 0x07, 0x6a, 0x83, 0x07, 0xf5, 0xb3, 0xc7, 0x63, 0x1e, 0x87, 0xe5, 0x0d, 0xa8, 0x8a, + 0xc1, 0xe3, 0xf8, 0x15, 0x7e, 0x97, 0xe0, 0x30, 0x4e, 0x72, 0x9b, 0xab, 0xa9, 0x67, 0xb6, 0x33, + 0xc6, 0xa7, 0x3b, 0xc2, 0xa2, 0x61, 0x4f, 0xc3, 0x23, 0xdb, 0x41, 0xdf, 0x3b, 0x89, 0xc6, 0xd3, + 0x71, 0x95, 0x8f, 0xbf, 0x40, 0x0f, 0x78, 0x4c, 0x13, 0x45, 0x31, 0x55, 0x61, 0x1b, 0xcc, 0x8a, + 0x20, 0xc1, 0x75, 0xf0, 0x21, 0xba, 0x6c, 0x85, 0x14, 0x03, 0x33, 0xd4, 0x1f, 0xde, 0x52, 0x9e, + 0x24, 0xb8, 0x4a, 0xe5, 0x7f, 0x6e, 0xe9, 0xe4, 0x94, 0x4c, 0xb8, 0xe3, 0x06, 0xd7, 0x8d, 0x98, + 0xfc, 0x2b, 0x48, 0xd1, 0xe0, 0xca, 0x09, 0xc8, 0x67, 0xda, 0xfd, 0xb5, 0x89, 0xc4, 0xaf, 0x25, + 0xca, 0xbf, 0xee, 0x6d, 0xe4, 0x6d, 0x00, 0x27, 0x60, 0xa7, 0x4c, 0x40, 0xdd, 0x31, 0xc6, 0x57, + 0x28, 0x99, 0x65, 0x27, 0x78, 0xca, 0x01, 0xdf, 0xee, 0xc5, 0xb6, 0x05, 0x55, 0xbd, 0x9b, 0xa4, + 0x04, 0xf9, 0xfe, 0x51, 0xa7, 0xd7, 0xb8, 0x41, 0x2a, 0x50, 0x1c, 0x74, 0x86, 0xc3, 0x03, 0x34, + 0xdb, 0x56, 0xa1, 0xa4, 0x5e, 0x4f, 0x67, 0x59, 0xaa, 0xd5, 0x6e, 0x77, 0x8e, 0x86, 0x9d, 0xdd, + 0x46, 0xee, 0x47, 0xf9, 0x52, 0xb6, 0x91, 0x33, 0xfe, 0x28, 0x07, 0x15, 0x6d, 0x14, 0x5e, 0xcc, + 0x8c, 0xe3, 0x71, 0x7a, 0xb2, 0xc9, 0x38, 0x3d, 0xba, 0x8d, 0x42, 0xc4, 0x32, 0x92, 0x36, 0x8a, + 0x37, 0xa1, 0x26, 0xe2, 0x09, 0x6a, 0xc6, 0xf7, 0x82, 0x59, 0xe5, 0x40, 0xc1, 0xaa, 0x31, 0x16, + 0x03, 0x12, 0xe1, 0x2b, 0x57, 0x11, 0x09, 0x8c, 0x83, 0xf0, 0x9d, 0x2b, 0x3e, 0x52, 0x0e, 0xbc, + 0xc9, 0x05, 0xe5, 0x14, 0x5c, 0x22, 0xac, 0x08, 0xd8, 0x50, 0xc4, 0xb9, 0x10, 0xfc, 0x50, 0x0b, + 0x06, 0x50, 0x30, 0xab, 0x1c, 0x28, 0x2a, 0x7a, 0x5f, 0x2e, 0x20, 0xee, 0x8a, 0xb4, 0xb9, 0xb8, + 0x1a, 0x62, 0x8b, 0xe7, 0x60, 0x41, 0x8d, 0x58, 0xc6, 0x85, 0xf1, 0x9d, 0xc5, 0x7c, 0x2f, 0x57, + 0x27, 0x92, 0x77, 0x81, 0x4c, 0x67, 0x33, 0x2b, 0x45, 0xc1, 0x97, 0x37, 0x97, 0xa7, 0xb3, 0xd9, + 0x50, 0xd3, 0x7f, 0x7d, 0x0b, 0xba, 0xc7, 0xaf, 0x81, 0xb4, 0xd8, 0x06, 0xc6, 0x26, 0xaa, 0xab, + 0x58, 0xc4, 0x96, 0x33, 0x3a, 0x5b, 0x4e, 0xe1, 0x7e, 0xd9, 0x54, 0xee, 0xf7, 0x22, 0x3e, 0x61, + 0xec, 0x41, 0xe5, 0x48, 0x0b, 0xeb, 0x7a, 0x97, 0x9d, 0x10, 0x32, 0xa0, 0x2b, 0x3f, 0x3b, 0xb8, + 0x4e, 0xd1, 0x17, 0x71, 0x5c, 0xb5, 0xd6, 0x64, 0xb5, 0xd6, 0x18, 0x7f, 0x3b, 0xc3, 0xa3, 0xaa, + 0xa9, 0xc6, 0x47, 0x91, 0x64, 0xa5, 0x69, 0x2e, 0x8a, 0xd9, 0x51, 0x91, 0xc6, 0x37, 0x11, 0x6e, + 0x03, 0x9b, 0x66, 0x79, 0xa7, 0xa7, 0x01, 0x95, 0x0e, 0x3b, 0x15, 0x84, 0xf5, 0x11, 0x24, 0x85, + 0x6f, 0x26, 0xe1, 0x3b, 0xbc, 0xfc, 0x40, 0x78, 0xe9, 0x30, 0xe1, 0xfb, 0xd0, 0xbe, 0x14, 0xb5, + 0x06, 0x4c, 0x04, 0x11, 0xf6, 0x01, 0xf9, 0x66, 0x5d, 0xa5, 0x8d, 0xbf, 0x21, 0xc2, 0x8a, 0x24, + 0xc7, 0xf7, 0x3e, 0x94, 0x54, 0xa9, 0xf1, 0x13, 0x56, 0x52, 0x2a, 0x3c, 0x3b, 0xc7, 0x51, 0x19, + 0x12, 0x6b, 0x31, 0xdf, 0x5c, 0x68, 0xe3, 0xe9, 0x6a, 0xad, 0x7e, 0x0f, 0xc8, 0xa9, 0xe3, 0x27, + 0x89, 0xf9, 0x66, 0x6b, 0x20, 0x46, 0xa3, 0x36, 0x8e, 0x61, 0x55, 0x72, 0x09, 0xed, 0x46, 0x10, + 0x9f, 0xbc, 0xcc, 0x4b, 0x98, 0x7c, 0x76, 0x81, 0xc9, 0x1b, 0xbf, 0x51, 0x80, 0xa2, 0x0c, 0x91, + 0x9c, 0x16, 0xd6, 0xb7, 0x1c, 0x0f, 0xeb, 0xdb, 0x8c, 0x45, 0x21, 0xc4, 0xa9, 0x17, 0xe7, 0xfd, + 0x3b, 0xc9, 0x23, 0x5b, 0xb3, 0x55, 0xc4, 0x8e, 0x6d, 0x61, 0xab, 0x28, 0xc4, 0x6d, 0x15, 0x69, + 0xa1, 0x8e, 0xb9, 0xe8, 0xb9, 0x10, 0xea, 0xf8, 0x16, 0x70, 0x39, 0x42, 0xf3, 0x54, 0x2c, 0x21, + 0x40, 0xc4, 0x5d, 0xd0, 0xc4, 0x8e, 0x52, 0x52, 0xec, 0x78, 0x65, 0x91, 0xe0, 0x63, 0x58, 0xe2, + 0x21, 0x8a, 0xc4, 0x1b, 0x7c, 0x79, 0x70, 0x88, 0xb1, 0x92, 0xff, 0xf9, 0x03, 0x18, 0x53, 0xd0, + 0xea, 0xa1, 0x31, 0x2b, 0xb1, 0xd0, 0x98, 0xba, 0x0d, 0xa5, 0x1a, 0xb7, 0xa1, 0xdc, 0x83, 0x86, + 0x1a, 0x38, 0xd4, 0x48, 0xba, 0x81, 0x78, 0x7f, 0x5b, 0x97, 0x70, 0xc6, 0x0d, 0x7b, 0x41, 0x74, + 0xf0, 0xd5, 0x63, 0x07, 0x1f, 0xe3, 0x55, 0xad, 0x30, 0xa4, 0xd3, 0x59, 0x28, 0x0f, 0x3e, 0x2d, + 0xba, 0x34, 0x9f, 0x79, 0xfe, 0x40, 0x48, 0x4e, 0x2f, 0x5f, 0x1d, 0x3b, 0x50, 0x3f, 0xb5, 0x9d, + 0xc9, 0xdc, 0xa7, 0x96, 0x4f, 0xed, 0xc0, 0x73, 0x71, 0xf3, 0x47, 0x67, 0xb0, 0xe8, 0xe2, 0x1e, + 0xa7, 0x31, 0x91, 0xc4, 0xac, 0x9d, 0xea, 0x49, 0x7c, 0x66, 0xa7, 0x8f, 0x04, 0x3b, 0xb2, 0xc4, + 0x4b, 0x7c, 0xee, 0x78, 0xd4, 0xed, 0x59, 0x7b, 0x07, 0xdd, 0x27, 0xfb, 0xc3, 0x46, 0x86, 0x25, + 0x07, 0xc7, 0xed, 0x76, 0xa7, 0xb3, 0x8b, 0x47, 0x18, 0xc0, 0xd2, 0x5e, 0xab, 0x7b, 0x20, 0x0e, + 0xb0, 0x7c, 0xa3, 0x60, 0xfc, 0x93, 0x2c, 0x54, 0xb4, 0xde, 0x90, 0x47, 0x6a, 0x12, 0x78, 0xec, + 0x8f, 0xdb, 0x8b, 0x3d, 0xde, 0x96, 0x1c, 0x5e, 0x9b, 0x05, 0x15, 0x47, 0x3a, 0x7b, 0x6d, 0x1c, + 0x69, 0xf2, 0x36, 0x2c, 0xdb, 0xbc, 0x04, 0x35, 0xe8, 0x42, 0xb9, 0x2f, 0xc0, 0x62, 0xcc, 0xdf, + 0x16, 0x71, 0x48, 0xc4, 0x31, 0xc5, 0xe8, 0xf2, 0xd2, 0x03, 0x57, 0x9d, 0x54, 0x38, 0x37, 0x45, + 0x31, 0x32, 0xc2, 0x18, 0xaf, 0x0e, 0x7c, 0x31, 0x5e, 0x12, 0xcd, 0xdf, 0xde, 0x6a, 0x2b, 0xbc, + 0x6a, 0xaa, 0xb4, 0xf1, 0x09, 0x40, 0xd4, 0x9f, 0xf8, 0xf0, 0xdd, 0x88, 0x0f, 0x5f, 0x46, 0x1b, + 0xbe, 0xac, 0xf1, 0x0f, 0x04, 0xeb, 0x12, 0x73, 0xa1, 0x54, 0x7d, 0xef, 0x83, 0x54, 0x3e, 0x5a, + 0xe8, 0xb1, 0x3f, 0x9b, 0xd0, 0x50, 0x3e, 0x1f, 0x5e, 0x11, 0x98, 0xae, 0x42, 0x2c, 0xb0, 0xda, + 0xec, 0x22, 0xab, 0x7d, 0x03, 0xaa, 0x18, 0xd8, 0x4e, 0x54, 0x24, 0xd8, 0x55, 0x65, 0x6a, 0x5f, + 0xca, 0xba, 0x63, 0x3c, 0x36, 0x9f, 0xe0, 0xb1, 0x7f, 0x33, 0xc3, 0xa3, 0x20, 0x45, 0x0d, 0x8d, + 0x98, 0xac, 0x2a, 0x33, 0xce, 0x64, 0x05, 0xa9, 0xa9, 0xf0, 0xd7, 0x30, 0xce, 0x6c, 0x3a, 0xe3, + 0x4c, 0x67, 0xc9, 0xb9, 0x54, 0x96, 0x6c, 0x6c, 0x41, 0x73, 0x97, 0xb2, 0xa1, 0x68, 0x4d, 0x26, + 0x89, 0xb1, 0x34, 0x6e, 0xc1, 0xcd, 0x14, 0x9c, 0xd0, 0xda, 0xfc, 0x66, 0x06, 0xd6, 0x5b, 0x3c, + 0xf8, 0xc9, 0xb7, 0xf6, 0xbe, 0xf7, 0x73, 0xb8, 0xa9, 0xdc, 0xef, 0xb5, 0x67, 0x83, 0x7a, 0xe4, + 0x2a, 0xe9, 0xb9, 0xaf, 0x3d, 0x3a, 0x61, 0x67, 0xa6, 0xd1, 0x84, 0x8d, 0x64, 0x6b, 0x44, 0x43, + 0xf7, 0x60, 0x65, 0x97, 0x9e, 0xcc, 0xcf, 0x0e, 0xe8, 0x45, 0xd4, 0x46, 0x02, 0xf9, 0xe0, 0xdc, + 0x7b, 0x2e, 0x16, 0x06, 0xfe, 0x46, 0xff, 0x5c, 0x46, 0x63, 0x05, 0x33, 0x3a, 0x92, 0x5a, 0x7f, + 0x84, 0x0c, 0x66, 0x74, 0x64, 0x3c, 0x02, 0xa2, 0x97, 0x23, 0x66, 0x91, 0x5d, 0xc9, 0xe6, 0x27, + 0x56, 0x70, 0x15, 0x84, 0x74, 0x2a, 0x9f, 0xc4, 0x42, 0x30, 0x3f, 0x19, 0x70, 0x88, 0xf1, 0x0e, + 0x54, 0x8f, 0xec, 0x2b, 0x93, 0x7e, 0x2d, 0x5e, 0x9e, 0x6e, 0x42, 0x71, 0x66, 0x5f, 0x31, 0x5e, + 0xac, 0x0c, 0x80, 0x88, 0x36, 0xfe, 0x51, 0x1e, 0x96, 0x38, 0x25, 0xb9, 0xcb, 0xbf, 0xf0, 0xe0, + 0xb8, 0xc8, 0x0b, 0xe5, 0xa9, 0xa4, 0x81, 0x16, 0x0e, 0xae, 0xec, 0xe2, 0xc1, 0x25, 0xb4, 0x95, + 0x32, 0xb2, 0x9e, 0x34, 0xd5, 0xb8, 0xf3, 0xa9, 0x0c, 0xa7, 0x17, 0x8f, 0xfd, 0x91, 0x8f, 0xbe, + 0x0c, 0xc2, 0xe3, 0x1e, 0xc4, 0x8d, 0xe9, 0xd1, 0xc5, 0x8f, 0xb7, 0x4e, 0x9e, 0xc7, 0xe2, 0xcc, + 0xd2, 0x41, 0xa9, 0xb7, 0xcb, 0xa2, 0x7c, 0x4e, 0x1d, 0xbf, 0x5d, 0x2e, 0xdc, 0x22, 0x4b, 0x2f, + 0xbf, 0x45, 0x72, 0x35, 0xe6, 0x0b, 0x6e, 0x91, 0xf0, 0x0a, 0xb7, 0xc8, 0x57, 0x30, 0x64, 0xdf, + 0x84, 0x12, 0x0a, 0x59, 0xda, 0x11, 0xc6, 0x84, 0x2b, 0x76, 0x84, 0x7d, 0xaa, 0xdd, 0xb3, 0xb8, + 0x17, 0x8d, 0x76, 0x86, 0x98, 0xf4, 0xeb, 0x9f, 0x8d, 0x81, 0xf0, 0x2b, 0x28, 0x0a, 0x28, 0x5b, + 0xd0, 0xae, 0x3d, 0x95, 0xf1, 0x63, 0xf1, 0x37, 0x1b, 0x36, 0x8c, 0xa8, 0xf8, 0xf5, 0xdc, 0xf1, + 0xe9, 0x58, 0xc6, 0x75, 0x73, 0x70, 0x7f, 0x33, 0x08, 0xeb, 0x20, 0xbb, 0xf3, 0xb9, 0x32, 0xfe, + 0x7b, 0xc9, 0x2c, 0x3a, 0xc1, 0x53, 0x96, 0x34, 0x08, 0x34, 0x30, 0x02, 0xf6, 0xcc, 0xf3, 0xa5, + 0x84, 0x60, 0xfc, 0x6e, 0x06, 0x1a, 0x62, 0x77, 0x29, 0x9c, 0x7e, 0xe5, 0x2a, 0x5c, 0xe7, 0xf4, + 0xf1, 0xe2, 0x28, 0x6d, 0x06, 0xd4, 0x50, 0xd3, 0xa4, 0xc4, 0x05, 0xae, 0x29, 0xab, 0x30, 0xe0, + 0x9e, 0x10, 0x19, 0x5e, 0x87, 0x8a, 0x7c, 0x3d, 0x30, 0x75, 0x26, 0xf2, 0x23, 0x40, 0xfc, 0xf9, + 0xc0, 0xa1, 0x33, 0x91, 0xd2, 0x86, 0x6f, 0x8b, 0xe7, 0xfd, 0x19, 0x94, 0x36, 0x4c, 0x3b, 0xa4, + 0xc6, 0x3f, 0xce, 0xc0, 0x8a, 0xd6, 0x15, 0xb1, 0x6f, 0xbf, 0x07, 0x55, 0x15, 0x97, 0x9f, 0x2a, + 0x31, 0x77, 0x33, 0xce, 0xa3, 0xa2, 0x6c, 0x95, 0x91, 0x82, 0x04, 0xac, 0x31, 0x63, 0xfb, 0x8a, + 0xbb, 0xb8, 0xcf, 0xa7, 0xf2, 0x26, 0x39, 0xb6, 0xaf, 0xf6, 0x28, 0x1d, 0xcc, 0xa7, 0xe4, 0x2e, + 0x54, 0x9f, 0x53, 0xfa, 0x4c, 0x11, 0x70, 0xd6, 0x0b, 0x0c, 0x26, 0x28, 0x0c, 0xa8, 0x4d, 0x3d, + 0x37, 0x3c, 0x57, 0x24, 0x42, 0xc4, 0x47, 0x20, 0xa7, 0x31, 0xfe, 0x20, 0x0b, 0xab, 0x5c, 0x9f, + 0x29, 0xf4, 0xc8, 0x82, 0x75, 0x35, 0x61, 0x89, 0xab, 0x76, 0x39, 0xf3, 0xda, 0xbf, 0x61, 0x8a, + 0x34, 0xf9, 0xf8, 0x15, 0x75, 0xb0, 0x32, 0x82, 0xc0, 0x35, 0xc3, 0x9f, 0x5b, 0x1c, 0xfe, 0xeb, + 0x87, 0x37, 0xcd, 0xaa, 0x5c, 0x48, 0xb3, 0x2a, 0xbf, 0x8a, 0x2d, 0x77, 0xe1, 0xad, 0x7b, 0x71, + 0x31, 0x24, 0xec, 0x23, 0xd8, 0x8c, 0xd1, 0x20, 0xb7, 0x76, 0x4e, 0x1d, 0x15, 0x6f, 0x7c, 0x4d, + 0xa3, 0x1e, 0x48, 0xdc, 0x4e, 0x11, 0x0a, 0xc1, 0xc8, 0x9b, 0x51, 0x63, 0x03, 0xd6, 0xe2, 0xa3, + 0x2a, 0x8e, 0x89, 0xdf, 0xce, 0x40, 0x73, 0x2f, 0x8a, 0xad, 0xeb, 0x04, 0xa1, 0xe7, 0xab, 0x10, + 0xed, 0xb7, 0x01, 0xf8, 0x07, 0x89, 0xf0, 0xe2, 0x2e, 0xa2, 0x24, 0x21, 0x04, 0xaf, 0xed, 0x37, + 0xa1, 0x44, 0xdd, 0x31, 0x47, 0xf2, 0xd5, 0x50, 0xa4, 0xee, 0x58, 0x5e, 0xfa, 0x17, 0x8e, 0xe1, + 0x5a, 0x5c, 0xc0, 0x10, 0xf1, 0x3e, 0xd8, 0xe8, 0xd0, 0x0b, 0x14, 0x07, 0xf2, 0x2a, 0xde, 0xc7, + 0xa1, 0x7d, 0x89, 0xee, 0xd1, 0x81, 0xf1, 0x97, 0xb3, 0xb0, 0x1c, 0xb5, 0x8f, 0x47, 0x3c, 0x7a, + 0x71, 0xec, 0xa6, 0xbb, 0x62, 0x39, 0x38, 0xec, 0xb2, 0xa4, 0x69, 0x79, 0x4b, 0x7c, 0x73, 0x76, + 0x5d, 0x62, 0x40, 0x45, 0x52, 0x78, 0xf3, 0x50, 0x0b, 0x63, 0x5b, 0xe6, 0x24, 0xfd, 0x79, 0xc8, + 0x6e, 0xb7, 0xec, 0x9a, 0xef, 0xb8, 0xe2, 0x7e, 0x59, 0xb0, 0xa7, 0x61, 0x17, 0xbf, 0x7a, 0xc5, + 0xc0, 0x2c, 0x1b, 0x9f, 0x48, 0x46, 0xc5, 0xe8, 0x1b, 0xfc, 0xb2, 0xc3, 0x67, 0x0e, 0x2f, 0x3a, + 0xfa, 0x4d, 0x80, 0x7f, 0xa8, 0x43, 0xdd, 0x04, 0x5e, 0x87, 0x0a, 0x2f, 0x3c, 0x0a, 0x6d, 0x80, + 0x31, 0xe5, 0xc2, 0xae, 0x8b, 0x78, 0xa1, 0x71, 0xf3, 0xe6, 0x31, 0x3d, 0x03, 0xf0, 0xaa, 0xd0, + 0xc5, 0xe6, 0x37, 0x33, 0x70, 0x33, 0x65, 0xda, 0xc4, 0x2e, 0x6f, 0x83, 0x16, 0x61, 0x59, 0x8e, + 0x2e, 0xdf, 0xea, 0x1b, 0x92, 0xad, 0xc6, 0xc7, 0xd4, 0x6c, 0x9c, 0xc6, 0x01, 0xd1, 0x0d, 0x97, + 0xcf, 0x60, 0x2c, 0x70, 0x06, 0x8a, 0x53, 0x7c, 0x1a, 0xf9, 0xe5, 0xf2, 0x08, 0xb6, 0x3a, 0x97, + 0x8c, 0x63, 0x28, 0x97, 0xe9, 0xd1, 0xb3, 0xb9, 0xb4, 0x7c, 0x25, 0xb4, 0xf9, 0x99, 0x57, 0xd2, + 0xe6, 0x8f, 0xf9, 0xb3, 0x76, 0x55, 0xd6, 0x4f, 0x53, 0x08, 0x1e, 0xa0, 0x2c, 0xcf, 0x09, 0x16, + 0x21, 0x23, 0x68, 0x30, 0x10, 0x2f, 0xd4, 0x08, 0x60, 0xf9, 0x70, 0x3e, 0x09, 0x9d, 0xb6, 0x02, + 0x91, 0x8f, 0x45, 0x1e, 0xac, 0x47, 0x8e, 0x5a, 0x6a, 0x45, 0xa0, 0x2a, 0xc2, 0xc1, 0x9a, 0xb2, + 0x82, 0xac, 0xc5, 0xfa, 0x96, 0xa7, 0xf1, 0x1a, 0x8c, 0x9b, 0xb0, 0x19, 0xa5, 0xf8, 0xb0, 0xc9, + 0xa3, 0xe6, 0x6f, 0x65, 0xf8, 0x5b, 0x0c, 0x8e, 0x1b, 0xb8, 0xf6, 0x2c, 0x38, 0xf7, 0x42, 0xd2, + 0x81, 0xd5, 0xc0, 0x71, 0xcf, 0x26, 0x54, 0x2f, 0x3e, 0x10, 0x83, 0xb0, 0x1e, 0x6f, 0x1b, 0xcf, + 0x1a, 0x98, 0x2b, 0x3c, 0x47, 0x54, 0x5a, 0x40, 0x76, 0xae, 0x6b, 0x64, 0xb4, 0x2c, 0x12, 0xa3, + 0xb1, 0xd8, 0xf8, 0x2e, 0xd4, 0xe3, 0x15, 0x91, 0x4f, 0x45, 0x34, 0x88, 0xa8, 0x55, 0xb9, 0xc4, + 0x5b, 0xf8, 0x68, 0x41, 0x54, 0xa2, 0xb1, 0x0f, 0x8c, 0xbf, 0x98, 0x81, 0xa6, 0x49, 0xd9, 0xca, + 0xd5, 0x5a, 0x29, 0xd7, 0xcc, 0xf7, 0x16, 0x4a, 0xbd, 0xbe, 0xaf, 0x32, 0xc8, 0x84, 0x6c, 0xd1, + 0x7b, 0xd7, 0x4e, 0xc6, 0xfe, 0x8d, 0x85, 0x1e, 0xed, 0x94, 0x60, 0x89, 0x93, 0x18, 0x9b, 0xb0, + 0x2e, 0xda, 0x23, 0xdb, 0x12, 0x99, 0x6a, 0x63, 0x35, 0xc6, 0x4c, 0xb5, 0x5b, 0xd0, 0xe4, 0x8f, + 0xb6, 0xf5, 0x4e, 0x88, 0x8c, 0xbb, 0x40, 0x0e, 0xed, 0x91, 0xed, 0x7b, 0x9e, 0x7b, 0x44, 0x7d, + 0xe1, 0x0c, 0x8d, 0x12, 0x26, 0x5a, 0x32, 0xa5, 0x28, 0xcc, 0x53, 0x32, 0x78, 0xb7, 0xe7, 0x4a, + 0xdf, 0x2f, 0x9e, 0x32, 0x7c, 0x58, 0xdd, 0xb1, 0x9f, 0x51, 0x59, 0x92, 0x1c, 0xa2, 0xc7, 0x50, + 0x99, 0xa9, 0x42, 0xe5, 0xb8, 0xcb, 0x00, 0x3a, 0x8b, 0xd5, 0x9a, 0x3a, 0x35, 0x63, 0x41, 0xbe, + 0xe7, 0x85, 0x18, 0x88, 0x42, 0x1a, 0xc3, 0xcc, 0x32, 0x03, 0x3d, 0xa5, 0x57, 0xdd, 0xb1, 0xf1, + 0x10, 0xd6, 0xe2, 0x75, 0x0a, 0xd6, 0xb2, 0x05, 0xa5, 0xa9, 0x80, 0x89, 0xd6, 0xab, 0x34, 0xbb, + 0x8c, 0xb0, 0x2b, 0x9f, 0xcc, 0xd3, 0xdd, 0x55, 0x57, 0xaa, 0xc7, 0xb0, 0xb9, 0x80, 0x11, 0x05, + 0xde, 0x85, 0xaa, 0xd6, 0x10, 0xde, 0x8d, 0x3c, 0x13, 0x59, 0x45, 0x4b, 0x02, 0xe3, 0x73, 0xd8, + 0xe4, 0xf7, 0xb1, 0x28, 0xbb, 0x1c, 0x82, 0x44, 0x2f, 0x32, 0xc9, 0x5e, 0x7c, 0x2c, 0xaf, 0x79, + 0x7a, 0xd6, 0x28, 0x30, 0xdd, 0x18, 0x71, 0xd2, 0x7d, 0x47, 0x26, 0x8d, 0x63, 0xd8, 0x58, 0x1c, + 0x3e, 0xd6, 0xfe, 0x3f, 0xd3, 0x90, 0xcb, 0xe1, 0x89, 0xd0, 0x6a, 0x78, 0xfe, 0x6b, 0x86, 0x8f, + 0x4f, 0x0c, 0x25, 0x9a, 0x39, 0x06, 0x32, 0xa5, 0xe1, 0xb9, 0x37, 0xb6, 0x16, 0x6b, 0x7e, 0xa4, + 0xbc, 0x87, 0x52, 0xf3, 0x6e, 0x1f, 0x62, 0x46, 0x0d, 0x23, 0xfc, 0xd8, 0xa7, 0x49, 0xf8, 0xd6, + 0x08, 0x36, 0xd2, 0x89, 0x53, 0x7c, 0x6e, 0x3e, 0x8a, 0x0b, 0xea, 0xb7, 0xaf, 0xed, 0x3e, 0x6b, + 0x96, 0x2e, 0xb7, 0xff, 0x56, 0x09, 0x8a, 0x42, 0x4b, 0x42, 0xb6, 0x21, 0x3f, 0x92, 0xfe, 0x9b, + 0x51, 0x70, 0x42, 0x81, 0x95, 0xff, 0xdb, 0xe8, 0xc5, 0xc9, 0xe8, 0xc8, 0x63, 0xa8, 0xc7, 0x5d, + 0x18, 0x12, 0x41, 0x49, 0xe2, 0xbe, 0x07, 0xb5, 0x51, 0xc2, 0x58, 0x5d, 0x8e, 0x84, 0x2b, 0x2e, + 0x73, 0x96, 0xce, 0x35, 0xe9, 0xcb, 0x73, 0xd9, 0x7d, 0x2d, 0x38, 0xb7, 0xad, 0x87, 0x8f, 0x3e, + 0x11, 0x51, 0x49, 0x2a, 0x08, 0x1c, 0x9c, 0xdb, 0x0f, 0x1f, 0x7d, 0x92, 0xbc, 0x89, 0x89, 0x98, + 0x24, 0xda, 0x4d, 0x6c, 0x0d, 0x0a, 0x3c, 0xc2, 0x39, 0x77, 0xc4, 0xe3, 0x09, 0xf2, 0x00, 0xd6, + 0xa4, 0xe2, 0x4d, 0x3c, 0x99, 0xe0, 0xa7, 0x28, 0xff, 0xc0, 0x13, 0x11, 0xb8, 0x01, 0xa2, 0xb8, + 0xaa, 0x6e, 0x03, 0x96, 0xce, 0xa3, 0x90, 0xf5, 0x35, 0x53, 0xa4, 0x8c, 0x3f, 0x28, 0x40, 0x45, + 0x1b, 0x14, 0x52, 0x85, 0x92, 0xd9, 0x19, 0x74, 0xcc, 0x2f, 0x3a, 0xbb, 0x8d, 0x1b, 0xe4, 0x1e, + 0xbc, 0xd5, 0xed, 0xb5, 0xfb, 0xa6, 0xd9, 0x69, 0x0f, 0xad, 0xbe, 0x69, 0xc9, 0x10, 0x99, 0x47, + 0xad, 0xaf, 0x0e, 0x3b, 0xbd, 0xa1, 0xb5, 0xdb, 0x19, 0xb6, 0xba, 0x07, 0x83, 0x46, 0x86, 0xbc, + 0x06, 0xcd, 0x88, 0x52, 0xa2, 0x5b, 0x87, 0xfd, 0xe3, 0xde, 0xb0, 0x91, 0x25, 0x77, 0xe0, 0xd6, + 0x5e, 0xb7, 0xd7, 0x3a, 0xb0, 0x22, 0x9a, 0xf6, 0xc1, 0xf0, 0x0b, 0xab, 0xf3, 0xf3, 0x47, 0x5d, + 0xf3, 0xab, 0x46, 0x2e, 0x8d, 0x60, 0x7f, 0x78, 0xd0, 0x96, 0x25, 0xe4, 0xc9, 0x4d, 0x58, 0xe7, + 0x04, 0x3c, 0x8b, 0x35, 0xec, 0xf7, 0xad, 0x41, 0xbf, 0xdf, 0x6b, 0x14, 0xc8, 0x0a, 0xd4, 0xba, + 0xbd, 0x2f, 0x5a, 0x07, 0xdd, 0x5d, 0xcb, 0xec, 0xb4, 0x0e, 0x0e, 0x1b, 0x4b, 0x64, 0x15, 0x96, + 0x93, 0x74, 0x45, 0x56, 0x84, 0xa4, 0xeb, 0xf7, 0xba, 0xfd, 0x9e, 0xf5, 0x45, 0xc7, 0x1c, 0x74, + 0xfb, 0xbd, 0x46, 0x89, 0x6c, 0x00, 0x89, 0xa3, 0xf6, 0x0f, 0x5b, 0xed, 0x46, 0x99, 0xac, 0xc3, + 0x4a, 0x1c, 0xfe, 0xb4, 0xf3, 0x55, 0x03, 0x48, 0x13, 0xd6, 0x78, 0xc3, 0xac, 0x9d, 0xce, 0x41, + 0xff, 0x4b, 0xeb, 0xb0, 0xdb, 0xeb, 0x1e, 0x1e, 0x1f, 0x36, 0x2a, 0x18, 0xa8, 0xb8, 0xd3, 0xb1, + 0xba, 0xbd, 0xc1, 0xf1, 0xde, 0x5e, 0xb7, 0xdd, 0xed, 0xf4, 0x86, 0x8d, 0x2a, 0xaf, 0x39, 0xad, + 0xe3, 0x35, 0x96, 0x41, 0x3c, 0x92, 0xb3, 0x76, 0xbb, 0x83, 0xd6, 0xce, 0x41, 0x67, 0xb7, 0x51, + 0x27, 0xb7, 0xe1, 0xe6, 0xb0, 0x73, 0x78, 0xd4, 0x37, 0x5b, 0xe6, 0x57, 0xf2, 0x11, 0x9d, 0xb5, + 0xd7, 0xea, 0x1e, 0x1c, 0x9b, 0x9d, 0xc6, 0x32, 0x79, 0x03, 0x6e, 0x9b, 0x9d, 0x1f, 0x1f, 0x77, + 0xcd, 0xce, 0xae, 0xd5, 0xeb, 0xef, 0x76, 0xac, 0xbd, 0x4e, 0x6b, 0x78, 0x6c, 0x76, 0xac, 0xc3, + 0xee, 0x60, 0xd0, 0xed, 0x3d, 0x69, 0x34, 0xc8, 0x5b, 0x70, 0x57, 0x91, 0xa8, 0x02, 0x12, 0x54, + 0x2b, 0xac, 0x7f, 0x72, 0x4a, 0x7b, 0x9d, 0x9f, 0x1f, 0x5a, 0x47, 0x9d, 0x8e, 0xd9, 0x20, 0x64, + 0x0b, 0x36, 0xa2, 0xea, 0x79, 0x05, 0xa2, 0xee, 0x55, 0x86, 0x3b, 0xea, 0x98, 0x87, 0xad, 0x1e, + 0x9b, 0xe0, 0x18, 0x6e, 0x8d, 0x35, 0x3b, 0xc2, 0x25, 0x9b, 0xbd, 0x4e, 0x08, 0xd4, 0xb5, 0x59, + 0xd9, 0x6b, 0x99, 0x8d, 0x0d, 0xb2, 0x0c, 0x95, 0xc3, 0xa3, 0x23, 0x6b, 0xd8, 0x3d, 0xec, 0xf4, + 0x8f, 0x87, 0x8d, 0x4d, 0xb2, 0x0e, 0x8d, 0x6e, 0x6f, 0xd8, 0x31, 0xd9, 0x5c, 0xcb, 0xac, 0xff, + 0xad, 0x48, 0xd6, 0x60, 0x59, 0xb6, 0x54, 0x42, 0xff, 0xb8, 0x48, 0x36, 0x81, 0x1c, 0xf7, 0xcc, + 0x4e, 0x6b, 0x97, 0x0d, 0x9c, 0x42, 0xfc, 0xf7, 0xa2, 0x30, 0x67, 0xfe, 0x6e, 0x4e, 0x09, 0x7b, + 0x91, 0x7f, 0x50, 0xfc, 0x1b, 0x33, 0x55, 0xed, 0xdb, 0x30, 0x2f, 0xfb, 0xb4, 0x9f, 0x76, 0x35, + 0xcf, 0x2d, 0x5c, 0xcd, 0x17, 0x74, 0x3f, 0x35, 0xfd, 0xee, 0xf0, 0x26, 0xd4, 0xa6, 0xfc, 0x7b, + 0x33, 0xe2, 0x83, 0x05, 0x20, 0x9c, 0xe5, 0x38, 0x90, 0x7f, 0xad, 0x60, 0xe1, 0xdb, 0x76, 0x85, + 0xc5, 0x6f, 0xdb, 0xa5, 0xdd, 0x0f, 0x97, 0xd2, 0xee, 0x87, 0xf7, 0x61, 0x85, 0xb3, 0x26, 0xc7, + 0x75, 0xa6, 0x52, 0xeb, 0x22, 0xbe, 0x14, 0x87, 0x2c, 0x8a, 0xc3, 0xe5, 0x75, 0x54, 0x5e, 0x59, + 0x05, 0x0b, 0x29, 0x8a, 0xdb, 0x6a, 0xec, 0xa6, 0xca, 0x39, 0x87, 0xba, 0xa9, 0xaa, 0x1a, 0xec, + 0xcb, 0xa8, 0x86, 0x8a, 0x56, 0x03, 0x87, 0x63, 0x0d, 0xf7, 0x61, 0x85, 0x5e, 0x86, 0xbe, 0x6d, + 0x79, 0x33, 0xfb, 0xeb, 0x39, 0xfa, 0x5b, 0xd8, 0xa8, 0x03, 0xaa, 0x9a, 0xcb, 0x88, 0xe8, 0x23, + 0x7c, 0xd7, 0x0e, 0x6d, 0xe3, 0x97, 0x00, 0xd4, 0xa9, 0x8a, 0x5f, 0xdc, 0x73, 0x3d, 0xf9, 0x24, + 0xb2, 0x6a, 0xf2, 0x04, 0xce, 0x63, 0xe8, 0xf9, 0xf6, 0x19, 0xed, 0xca, 0xc0, 0x3e, 0x11, 0x80, + 0xdc, 0x82, 0x9c, 0x37, 0x93, 0xae, 0x64, 0x65, 0x19, 0x81, 0x7b, 0x66, 0x32, 0xa8, 0xf1, 0x09, + 0x64, 0xfb, 0xb3, 0x6b, 0x45, 0xa5, 0x26, 0x14, 0xe5, 0xd7, 0x6c, 0xb3, 0xe8, 0x3e, 0x26, 0x93, + 0xf7, 0xff, 0x7f, 0xa8, 0x68, 0x9f, 0x48, 0x22, 0x9b, 0xb0, 0xfa, 0x65, 0x77, 0xd8, 0xeb, 0x0c, + 0x06, 0xd6, 0xd1, 0xf1, 0xce, 0xd3, 0xce, 0x57, 0xd6, 0x7e, 0x6b, 0xb0, 0xdf, 0xb8, 0xc1, 0x78, + 0x49, 0xaf, 0x33, 0x18, 0x76, 0x76, 0x63, 0xf0, 0x0c, 0x79, 0x1d, 0xb6, 0x8e, 0x7b, 0xc7, 0x83, + 0xce, 0xae, 0x95, 0x96, 0x2f, 0xcb, 0x36, 0x8f, 0xc0, 0xa7, 0x64, 0xcf, 0xdd, 0xff, 0x65, 0xa8, + 0xc7, 0xc3, 0x5c, 0x10, 0x80, 0xa5, 0x83, 0xce, 0x93, 0x56, 0xfb, 0x2b, 0x1e, 0x61, 0x7d, 0x30, + 0x6c, 0x0d, 0xbb, 0x6d, 0x4b, 0x44, 0x54, 0x67, 0x8c, 0x2a, 0x43, 0x2a, 0x50, 0x6c, 0xf5, 0xda, + 0xfb, 0x7d, 0x73, 0xd0, 0xc8, 0x92, 0xd7, 0x60, 0x53, 0x6e, 0xa1, 0x76, 0xff, 0xf0, 0xb0, 0x3b, + 0x44, 0x1e, 0x3d, 0xfc, 0xea, 0x88, 0xed, 0x98, 0xfb, 0x36, 0x94, 0xa3, 0x60, 0xf0, 0xc8, 0xf7, + 0xba, 0xc3, 0x6e, 0x6b, 0x18, 0x31, 0xfd, 0xc6, 0x0d, 0xc6, 0x56, 0x23, 0x30, 0x46, 0x74, 0x6f, + 0x64, 0xf8, 0x4b, 0x60, 0x09, 0xe4, 0xb5, 0x37, 0xb2, 0x6c, 0xaf, 0x47, 0xd0, 0x9d, 0xfe, 0x90, + 0x75, 0xe1, 0x57, 0xa0, 0x1e, 0x8f, 0xb9, 0x4e, 0x1a, 0x50, 0x65, 0xf5, 0x6b, 0x55, 0x00, 0x2c, + 0xf1, 0x16, 0x37, 0x32, 0x9c, 0xb1, 0xb7, 0xfb, 0x87, 0xdd, 0xde, 0x13, 0x3c, 0x0d, 0x1a, 0x59, + 0x06, 0xea, 0x1f, 0x0f, 0x9f, 0xf4, 0x15, 0x28, 0xc7, 0x72, 0xf0, 0xee, 0x34, 0xf2, 0xf7, 0xbf, + 0x86, 0x95, 0x85, 0xe8, 0xec, 0xac, 0xd5, 0xfd, 0xe3, 0x61, 0xbb, 0x7f, 0xa8, 0xd7, 0x53, 0x81, + 0x62, 0xfb, 0xa0, 0xd5, 0x3d, 0x44, 0x43, 0x48, 0x0d, 0xca, 0xc7, 0x3d, 0x99, 0xcc, 0xc6, 0xe3, + 0xca, 0xe7, 0x18, 0x8b, 0xda, 0xeb, 0x9a, 0x83, 0xa1, 0x35, 0x18, 0xb6, 0x9e, 0x74, 0x1a, 0x79, + 0x96, 0x57, 0xf2, 0xab, 0xc2, 0xfd, 0xcf, 0xa1, 0x1e, 0xf7, 0x7b, 0x8e, 0x1b, 0xb0, 0xb6, 0x60, + 0x63, 0xa7, 0x33, 0xfc, 0xb2, 0xd3, 0xe9, 0xe1, 0x94, 0xb7, 0x3b, 0xbd, 0xa1, 0xd9, 0x3a, 0xe8, + 0x0e, 0xbf, 0x6a, 0x64, 0xee, 0x3f, 0x86, 0x46, 0xd2, 0xc9, 0x20, 0xe6, 0x95, 0xf1, 0x22, 0xf7, + 0x8d, 0xfb, 0xff, 0x29, 0x03, 0x6b, 0x69, 0xf6, 0x35, 0xb6, 0x30, 0x05, 0x23, 0x64, 0xc7, 0xe1, + 0xa0, 0xdf, 0xb3, 0x7a, 0x7d, 0x0c, 0xb4, 0xbc, 0x05, 0x1b, 0x09, 0x84, 0xec, 0x45, 0x86, 0xdc, + 0x82, 0xcd, 0x85, 0x4c, 0x96, 0xd9, 0x3f, 0xc6, 0xb9, 0x6c, 0xc2, 0x5a, 0x02, 0xd9, 0x31, 0xcd, + 0xbe, 0xd9, 0xc8, 0x91, 0xf7, 0xe0, 0x5e, 0x02, 0xb3, 0x28, 0x04, 0x48, 0x19, 0x21, 0x4f, 0xde, + 0x81, 0x37, 0x17, 0xa8, 0xa3, 0x73, 0xd2, 0xda, 0x69, 0x1d, 0xb0, 0xee, 0x35, 0x0a, 0xf7, 0xff, + 0x7e, 0x0e, 0x20, 0x7a, 0x58, 0xc8, 0xea, 0xdf, 0x6d, 0x0d, 0x5b, 0x07, 0x7d, 0xb6, 0x67, 0xcc, + 0xfe, 0x90, 0x95, 0x6e, 0x76, 0x7e, 0xdc, 0xb8, 0x91, 0x8a, 0xe9, 0x1f, 0xb1, 0x0e, 0x6d, 0xc2, + 0x2a, 0x5f, 0x7f, 0x07, 0xac, 0x1b, 0x6c, 0xb9, 0x60, 0xcc, 0x6e, 0x94, 0x34, 0x8e, 0x8f, 0xf6, + 0xcc, 0x7e, 0x6f, 0x68, 0x0d, 0xf6, 0x8f, 0x87, 0xbb, 0x18, 0xf1, 0xbb, 0x6d, 0x76, 0x8f, 0x78, + 0x99, 0xf9, 0x17, 0x11, 0xb0, 0xa2, 0x0b, 0x6c, 0x83, 0x3f, 0xe9, 0x0f, 0x06, 0xdd, 0x23, 0xeb, + 0xc7, 0xc7, 0x1d, 0xb3, 0xdb, 0x19, 0x60, 0xc6, 0xa5, 0x14, 0x38, 0xa3, 0x2f, 0xb2, 0x35, 0x3b, + 0x3c, 0xf8, 0x42, 0x08, 0x10, 0x8c, 0xb4, 0x14, 0x07, 0x31, 0xaa, 0x32, 0x9b, 0x1d, 0x76, 0x02, + 0xa7, 0x94, 0x0c, 0xd7, 0xe0, 0x58, 0xbe, 0x0a, 0x93, 0x2d, 0x16, 0x76, 0x3e, 0x66, 0xab, 0xa6, + 0xa3, 0x58, 0x2e, 0x14, 0x3b, 0x94, 0x90, 0xb6, 0xbb, 0x6b, 0x62, 0x86, 0xfa, 0x02, 0x94, 0xd1, + 0x2e, 0xb3, 0x45, 0xc8, 0x8e, 0x68, 0x46, 0xd2, 0x90, 0x09, 0x86, 0x59, 0x79, 0xf8, 0x2f, 0xde, + 0x80, 0xb2, 0x7a, 0x60, 0x40, 0x7e, 0x04, 0xb5, 0xd8, 0xf3, 0x7d, 0x22, 0x55, 0xf8, 0x69, 0xaf, + 0xfd, 0xb7, 0x5e, 0x4b, 0x47, 0x8a, 0xcb, 0xc9, 0xa1, 0xa6, 0x0d, 0xe0, 0x85, 0xbd, 0x96, 0xbc, + 0xa1, 0xc7, 0x4a, 0xbb, 0x7d, 0x0d, 0x56, 0x14, 0xf7, 0x14, 0xc3, 0x87, 0xeb, 0x9f, 0x46, 0x27, + 0xb7, 0xa3, 0x58, 0xce, 0x29, 0x9f, 0x4c, 0xdf, 0xba, 0xb9, 0xf8, 0x11, 0x73, 0xf9, 0xd5, 0xf3, + 0x5d, 0xa8, 0x68, 0x1f, 0xb5, 0x24, 0x37, 0xaf, 0xfd, 0x00, 0xe7, 0xd6, 0x56, 0x1a, 0x4a, 0x34, + 0xe9, 0xfb, 0x50, 0x56, 0x1f, 0x13, 0x24, 0x9b, 0xda, 0xc7, 0x29, 0xf5, 0x8f, 0x2b, 0x6e, 0x35, + 0x17, 0x11, 0x22, 0xff, 0x2e, 0x54, 0xb4, 0x6f, 0x02, 0xaa, 0x56, 0x2c, 0x7e, 0x77, 0x50, 0xb5, + 0x22, 0xed, 0x13, 0x82, 0x07, 0xb0, 0x2e, 0x74, 0x0e, 0x27, 0xf4, 0x9b, 0x0c, 0x4f, 0xca, 0x37, + 0xde, 0x1f, 0x64, 0xc8, 0x63, 0x28, 0xc9, 0xef, 0x48, 0x92, 0x8d, 0xf4, 0xef, 0x6d, 0x6e, 0x6d, + 0x2e, 0xc0, 0x45, 0x53, 0x5a, 0x00, 0xd1, 0xd7, 0x06, 0x89, 0xec, 0xf8, 0xc2, 0xd7, 0x0b, 0xd5, + 0xcc, 0xa4, 0x7c, 0x9a, 0x70, 0x17, 0x2a, 0xda, 0x87, 0x05, 0xd5, 0x98, 0x2c, 0x7e, 0x94, 0x50, + 0x8d, 0x49, 0xda, 0x77, 0x08, 0x7f, 0x04, 0xb5, 0xd8, 0x17, 0x02, 0xd5, 0x3a, 0x4e, 0xfb, 0xfe, + 0xa0, 0x5a, 0xc7, 0xe9, 0x1f, 0x15, 0xdc, 0x85, 0x8a, 0xf6, 0xd5, 0x3e, 0xd5, 0xa2, 0xc5, 0x4f, + 0x07, 0xaa, 0x16, 0xa5, 0x7c, 0xe4, 0x8f, 0xed, 0x86, 0xf8, 0x27, 0xfb, 0xd4, 0x6e, 0x48, 0xfd, + 0xf6, 0x9f, 0xda, 0x0d, 0xe9, 0xdf, 0xf9, 0x63, 0x4b, 0x4f, 0x7d, 0x37, 0x80, 0x6c, 0xc6, 0xae, + 0xfa, 0xd1, 0x07, 0x08, 0xd4, 0xd2, 0x5b, 0xfc, 0xc4, 0xc0, 0x13, 0x58, 0x55, 0x8b, 0x46, 0x45, + 0xfd, 0x0f, 0x54, 0x9b, 0x52, 0xbf, 0x2d, 0xb0, 0xd5, 0x48, 0x62, 0x1f, 0x64, 0xc8, 0x67, 0x50, + 0x14, 0xa1, 0xd4, 0xc9, 0x7a, 0x32, 0xb4, 0x3a, 0x6f, 0xc4, 0x46, 0x7a, 0xc4, 0x75, 0x72, 0x84, + 0x1b, 0x5a, 0x8f, 0x75, 0xae, 0xaf, 0xd8, 0x94, 0xf0, 0xe8, 0x5b, 0xaf, 0x5f, 0x87, 0x8e, 0x4a, + 0x4c, 0xc6, 0xe7, 0xbf, 0x7d, 0x5d, 0x58, 0x9d, 0x78, 0x89, 0xd7, 0xc5, 0xff, 0x7b, 0x02, 0x55, + 0xfd, 0x73, 0x4d, 0x44, 0xdf, 0x87, 0xc9, 0xb2, 0x6e, 0xa5, 0xe2, 0x44, 0x41, 0x5f, 0xc0, 0x86, + 0x1a, 0x6f, 0x3d, 0xc6, 0x4b, 0x40, 0xee, 0xa4, 0x44, 0x7e, 0x89, 0x8d, 0xfa, 0xcd, 0x6b, 0x43, + 0xc3, 0x3c, 0xc8, 0x20, 0x93, 0x8d, 0x7d, 0x61, 0x25, 0x62, 0xb2, 0x69, 0x1f, 0x96, 0x89, 0x98, + 0x6c, 0xfa, 0x67, 0x59, 0x5a, 0xb0, 0xac, 0xc5, 0xa8, 0x19, 0x5c, 0xb9, 0x23, 0xb5, 0xde, 0x17, + 0x83, 0x50, 0x6f, 0xa5, 0x69, 0xbe, 0x49, 0x1b, 0x2a, 0x7a, 0x98, 0x9b, 0x17, 0x64, 0xdf, 0xd4, + 0x50, 0x7a, 0x0c, 0xe1, 0x07, 0x19, 0x72, 0x00, 0x8d, 0x64, 0x50, 0x4a, 0xb5, 0x85, 0xd3, 0x02, + 0x79, 0x6e, 0x25, 0x90, 0xb1, 0x50, 0x96, 0x6c, 0x5d, 0xc4, 0x3e, 0x25, 0xee, 0xf9, 0xc9, 0xa3, + 0x28, 0xfe, 0x89, 0x71, 0x55, 0x5a, 0xda, 0xd7, 0xe5, 0xef, 0x65, 0x1e, 0x64, 0xc8, 0x1e, 0x54, + 0x63, 0x31, 0xd9, 0x62, 0x6f, 0x5d, 0x12, 0xdd, 0x6c, 0xea, 0xb8, 0x44, 0x3f, 0x0f, 0xa1, 0x1e, + 0x77, 0xd1, 0x50, 0x0d, 0x4b, 0xf5, 0x23, 0x51, 0xd3, 0x97, 0xee, 0xd7, 0x41, 0x7e, 0x00, 0x15, + 0xc6, 0x93, 0xa5, 0x2b, 0x1f, 0xd1, 0xf8, 0x74, 0x72, 0xce, 0x38, 0x4c, 0xa8, 0xa2, 0x73, 0x7f, + 0x21, 0x9b, 0xc1, 0x7e, 0x7d, 0x8f, 0x7f, 0x8a, 0x59, 0x7a, 0x73, 0xb1, 0xf9, 0x7f, 0xd5, 0x42, + 0xc8, 0x1e, 0xaf, 0x7c, 0xe8, 0xf1, 0x27, 0xec, 0x37, 0x35, 0x1a, 0x01, 0x7b, 0xb5, 0x36, 0xb4, + 0x78, 0x1b, 0x44, 0x9e, 0xd8, 0x1a, 0x7c, 0xc5, 0xb2, 0xc8, 0xa7, 0x00, 0x91, 0x8b, 0x2c, 0x49, + 0x38, 0x6a, 0xaa, 0x0d, 0x95, 0xe2, 0x45, 0xdb, 0xe1, 0xfb, 0x5d, 0x79, 0x8a, 0xea, 0x47, 0x72, + 0xdc, 0x69, 0x35, 0x76, 0x24, 0x27, 0x8b, 0xf9, 0x08, 0x6a, 0x07, 0x9e, 0xf7, 0x6c, 0x3e, 0x53, + 0xef, 0x2c, 0xe2, 0x6e, 0x4c, 0xfb, 0x76, 0x70, 0xbe, 0x95, 0x68, 0x16, 0x69, 0xc1, 0x8a, 0x62, + 0x11, 0x91, 0xab, 0x6a, 0x9c, 0x28, 0xc6, 0x18, 0x12, 0x05, 0x3c, 0xc8, 0x90, 0x87, 0x50, 0xdd, + 0xa5, 0x23, 0x0c, 0xb3, 0x81, 0x4e, 0x33, 0xab, 0x31, 0x07, 0x0c, 0xee, 0x6d, 0xb3, 0x55, 0x8b, + 0x01, 0x25, 0x8b, 0x8b, 0x1c, 0xb7, 0xf4, 0x33, 0x23, 0xee, 0xfd, 0x14, 0x63, 0x71, 0x0b, 0xce, + 0x5b, 0x5f, 0xc0, 0xca, 0x82, 0x6b, 0x94, 0xe2, 0x6e, 0xd7, 0x39, 0x54, 0x6d, 0xdd, 0xbd, 0x9e, + 0x40, 0x94, 0xfb, 0x43, 0xa8, 0xf1, 0x90, 0xd2, 0x27, 0x94, 0x3f, 0x93, 0x4d, 0x04, 0x0c, 0xd3, + 0xdf, 0xe0, 0x26, 0x59, 0x12, 0xcf, 0xf0, 0x04, 0x3f, 0x46, 0xa3, 0x3d, 0x42, 0x55, 0xf3, 0xba, + 0xf8, 0x30, 0x56, 0xcd, 0x6b, 0xda, 0x7b, 0xd7, 0xcf, 0xa1, 0xf2, 0x84, 0x86, 0xf2, 0x59, 0xa7, + 0x92, 0x8f, 0x12, 0xef, 0x3c, 0xb7, 0x52, 0x1e, 0xe3, 0x92, 0x4f, 0x30, 0xab, 0x0a, 0x51, 0xb0, + 0xa1, 0xd5, 0xa2, 0x67, 0x5d, 0x4e, 0xc0, 0x99, 0xf4, 0xa1, 0x05, 0x2a, 0x51, 0x0d, 0x5f, 0x0c, + 0x4c, 0xa3, 0x1a, 0x9e, 0x16, 0xd7, 0xe4, 0x07, 0x7c, 0x04, 0xb4, 0x87, 0xa4, 0x91, 0x08, 0x96, + 0x7c, 0x73, 0xaa, 0x9a, 0xaf, 0x93, 0x3f, 0x02, 0x18, 0x84, 0xde, 0x6c, 0xd7, 0xa6, 0x53, 0xcf, + 0x8d, 0x78, 0x42, 0xf4, 0x84, 0x31, 0xda, 0x88, 0xda, 0x3b, 0x46, 0xf2, 0xa5, 0x26, 0x9b, 0xc6, + 0xa6, 0x44, 0x4e, 0xfb, 0xb5, 0xaf, 0x1c, 0x55, 0x77, 0x52, 0x5e, 0x3a, 0x22, 0x93, 0x80, 0xc8, + 0xf3, 0x4c, 0x49, 0x9a, 0x0b, 0x4e, 0x6d, 0x6a, 0xaf, 0xa7, 0xb8, 0xa9, 0x7d, 0x1f, 0xca, 0x91, + 0xcb, 0xce, 0x66, 0x14, 0x35, 0x29, 0xe6, 0xe0, 0xa3, 0xb8, 0xf7, 0xa2, 0xbb, 0x4c, 0x0f, 0x56, + 0x79, 0x73, 0xd4, 0xf1, 0x87, 0x0f, 0xed, 0xd4, 0xb7, 0x94, 0x16, 0xfd, 0x54, 0xd4, 0xfe, 0x49, + 0xf3, 0xb6, 0x60, 0xfb, 0x67, 0xc1, 0x6a, 0xaf, 0xf6, 0xcf, 0x75, 0x6e, 0x18, 0x6a, 0xff, 0x5c, + 0x6f, 0xf0, 0xef, 0xc1, 0x6a, 0x8a, 0xfd, 0x9d, 0xbc, 0x21, 0x2f, 0x36, 0xd7, 0xda, 0xe6, 0xb7, + 0x52, 0xed, 0xb4, 0x64, 0x08, 0x9b, 0x3c, 0x4f, 0x6b, 0x32, 0x49, 0x98, 0x7b, 0x5f, 0xd7, 0x32, + 0xa4, 0x98, 0xb0, 0x63, 0xa2, 0x4c, 0xc2, 0x8c, 0xdd, 0x83, 0x46, 0xd2, 0x52, 0x4a, 0xae, 0x27, + 0xdf, 0xba, 0x13, 0x13, 0xd9, 0x17, 0xad, 0xab, 0xe4, 0x0b, 0x65, 0xaf, 0x4d, 0xb4, 0xf1, 0x4e, + 0xf4, 0x09, 0xc0, 0x54, 0xeb, 0xb2, 0xba, 0x0d, 0xa4, 0x9a, 0x7b, 0xc9, 0xcf, 0xc3, 0x66, 0x72, + 0x45, 0xcb, 0x92, 0xef, 0xa6, 0x0d, 0xd7, 0xb5, 0xa2, 0x5c, 0xbc, 0x43, 0x0f, 0x32, 0x8c, 0x11, + 0xeb, 0x56, 0x55, 0xb5, 0x90, 0x52, 0xcc, 0xbb, 0x6a, 0x21, 0xa5, 0x9a, 0x61, 0x8f, 0x60, 0x39, + 0x61, 0x50, 0x55, 0x62, 0x70, 0xba, 0x09, 0x56, 0x89, 0xc1, 0xd7, 0xd9, 0x61, 0x07, 0xd0, 0x48, + 0x9a, 0x4a, 0xd5, 0x5c, 0x5f, 0x63, 0x7e, 0xdd, 0xba, 0x73, 0x2d, 0x3e, 0xde, 0x4c, 0xcd, 0xa8, + 0x18, 0x6b, 0xe6, 0xa2, 0x29, 0x34, 0xd6, 0xcc, 0x14, 0x93, 0xe6, 0xce, 0x3b, 0xbf, 0xf0, 0x9d, + 0x33, 0x27, 0x3c, 0x9f, 0x9f, 0x6c, 0x8f, 0xbc, 0xe9, 0x07, 0x13, 0xa9, 0xd5, 0x10, 0xef, 0xce, + 0x3f, 0x98, 0xb8, 0xe3, 0x0f, 0xb0, 0x80, 0x93, 0xa5, 0x99, 0xef, 0x85, 0xde, 0x47, 0xff, 0x27, + 0x00, 0x00, 0xff, 0xff, 0x68, 0xba, 0x0c, 0x04, 0xb3, 0x8f, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/lnrpc/rpc.proto b/lnrpc/rpc.proto index 12f7d427..e9af2b92 100644 --- a/lnrpc/rpc.proto +++ b/lnrpc/rpc.proto @@ -791,6 +791,58 @@ message ChannelAcceptResponse { // The pending channel id to which this response applies. bytes pending_chan_id = 2; + + /* + An optional error to send the initiating party to indicate why the channel + was rejected. This field *should not* contain sensitive information, it will + be sent to the initiating party. This field should only be set if accept is + false, the channel will be rejected if an error is set with accept=true + because the meaning of this response is ambiguous. Limited to 500 + characters. + */ + string error = 3; + + /* + The upfront shutdown address to use if the initiating peer supports option + upfront shutdown script (see ListPeers for the features supported). Note + that the channel open will fail if this value is set for a peer that does + not support this feature bit. + */ + string upfront_shutdown = 4; + + /* + The csv delay (in blocks) that we require for the remote party. + */ + uint32 csv_delay = 5; + + /* + The reserve amount in satoshis that we require the remote peer to adhere to. + We require that the remote peer always have some reserve amount allocated to + them so that there is always a disincentive to broadcast old state (if they + hold 0 sats on their side of the channel, there is nothing to lose). + */ + uint64 reserve_sat = 6; + + /* + The maximum amount of funds in millisatoshis that we allow the remote peer + to have in outstanding htlcs. + */ + uint64 in_flight_max_msat = 7; + + /* + The maximum number of htlcs that the remote peer can offer us. + */ + uint32 max_htlc_count = 8; + + /* + The minimum value in millisatoshis for incoming htlcs on the channel. + */ + uint64 min_htlc_in = 9; + + /* + The number of confirmations we require before we consider the channel open. + */ + uint32 min_accept_depth = 10; } message ChannelPoint { diff --git a/lnwallet/chancloser/chancloser.go b/lnwallet/chancloser/chancloser.go index 0b073bf7..0fe643bc 100644 --- a/lnwallet/chancloser/chancloser.go +++ b/lnwallet/chancloser/chancloser.go @@ -4,6 +4,8 @@ import ( "bytes" "fmt" + "github.com/btcsuite/btcd/chaincfg" + "github.com/btcsuite/btcd/txscript" "github.com/btcsuite/btcd/wire" "github.com/btcsuite/btcutil" "github.com/davecgh/go-spew/spew" @@ -717,3 +719,23 @@ func calcCompromiseFee(chanPoint wire.OutPoint, ourIdealFee, lastSentFee, return remoteFee } } + +// ParseUpfrontShutdownAddress attempts to parse an upfront shutdown address. +// If the address is empty, it returns nil. If it successfully decoded the +// address, it returns a script that pays out to the address. +func ParseUpfrontShutdownAddress(address string, + params *chaincfg.Params) (lnwire.DeliveryAddress, error) { + + if len(address) == 0 { + return nil, nil + } + + addr, err := btcutil.DecodeAddress( + address, params, + ) + if err != nil { + return nil, fmt.Errorf("invalid address: %v", err) + } + + return txscript.PayToAddrScript(addr) +} diff --git a/log.go b/log.go index e618fd7d..5da6c9ad 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/chainreg" + "github.com/lightningnetwork/lnd/chanacceptor" "github.com/lightningnetwork/lnd/chanbackup" "github.com/lightningnetwork/lnd/chanfitness" "github.com/lightningnetwork/lnd/channeldb" @@ -133,6 +134,7 @@ func SetupLoggers(root *build.RotatingLogWriter) { AddSubLogger(root, verrpc.Subsystem, verrpc.UseLogger) AddSubLogger(root, healthcheck.Subsystem, healthcheck.UseLogger) AddSubLogger(root, chainreg.Subsystem, chainreg.UseLogger) + AddSubLogger(root, chanacceptor.Subsystem, chanacceptor.UseLogger) } // AddSubLogger is a helper method to conveniently create and register the diff --git a/rpcserver.go b/rpcserver.go index eabd9ad1..81fabf9f 100644 --- a/rpcserver.go +++ b/rpcserver.go @@ -56,6 +56,7 @@ import ( "github.com/lightningnetwork/lnd/lnwallet" "github.com/lightningnetwork/lnd/lnwallet/btcwallet" "github.com/lightningnetwork/lnd/lnwallet/chainfee" + "github.com/lightningnetwork/lnd/lnwallet/chancloser" "github.com/lightningnetwork/lnd/lnwallet/chanfunding" "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/macaroons" @@ -1878,7 +1879,7 @@ func (r *rpcServer) parseOpenChannelReq(in *lnrpc.OpenChannelRequest, rpcsLog.Debugf("[openchannel]: using fee of %v sat/kw for funding tx", int64(feeRate)) - script, err := parseUpfrontShutdownAddress( + script, err := chancloser.ParseUpfrontShutdownAddress( in.CloseAddress, r.cfg.ActiveNetParams.Params, ) if err != nil { @@ -2053,26 +2054,6 @@ func (r *rpcServer) OpenChannelSync(ctx context.Context, } } -// parseUpfrontShutdownScript attempts to parse an upfront shutdown address. -// If the address is empty, it returns nil. If it successfully decoded the -// address, it returns a script that pays out to the address. -func parseUpfrontShutdownAddress(address string, - params *chaincfg.Params) (lnwire.DeliveryAddress, error) { - - if len(address) == 0 { - return nil, nil - } - - addr, err := btcutil.DecodeAddress( - address, params, - ) - if err != nil { - return nil, fmt.Errorf("invalid address: %v", err) - } - - return txscript.PayToAddrScript(addr) -} - // GetChanPointFundingTxid returns the given channel point's funding txid in // raw bytes. func GetChanPointFundingTxid(chanPoint *lnrpc.ChannelPoint) (*chainhash.Hash, error) { @@ -6401,14 +6382,6 @@ func (r *rpcServer) SubscribeChannelBackups(req *lnrpc.ChannelBackupSubscription } } -// chanAcceptInfo is used in the ChannelAcceptor bidirectional stream and -// encapsulates the request information sent from the RPCAcceptor to the -// RPCServer. -type chanAcceptInfo struct { - chanReq *chanacceptor.ChannelAcceptRequest - responseChan chan bool -} - // ChannelAcceptor dispatches a bi-directional streaming RPC in which // OpenChannel requests are sent to the client and the client responds with // a boolean that tells LND whether or not to accept the channel. This allows @@ -6417,153 +6390,23 @@ type chanAcceptInfo struct { func (r *rpcServer) ChannelAcceptor(stream lnrpc.Lightning_ChannelAcceptorServer) error { chainedAcceptor := r.chanPredicate - // Create two channels to handle requests and responses respectively. - newRequests := make(chan *chanAcceptInfo) - responses := make(chan lnrpc.ChannelAcceptResponse) - - // Define a quit channel that will be used to signal to the RPCAcceptor's - // closure whether the stream still exists. - quit := make(chan struct{}) - defer close(quit) - - // demultiplexReq is a closure that will be passed to the RPCAcceptor and - // acts as an intermediary between the RPCAcceptor and the RPCServer. - demultiplexReq := func(req *chanacceptor.ChannelAcceptRequest) bool { - respChan := make(chan bool, 1) - - newRequest := &chanAcceptInfo{ - chanReq: req, - responseChan: respChan, - } - - // timeout is the time after which ChannelAcceptRequests expire. - timeout := time.After(r.cfg.AcceptorTimeout) - - // Send the request to the newRequests channel. - select { - case newRequests <- newRequest: - case <-timeout: - rpcsLog.Errorf("RPCAcceptor returned false - reached timeout of %d", - r.cfg.AcceptorTimeout) - return false - case <-quit: - return false - case <-r.quit: - return false - } - - // Receive the response and return it. If no response has been received - // in AcceptorTimeout, then return false. - select { - case resp := <-respChan: - return resp - case <-timeout: - rpcsLog.Errorf("RPCAcceptor returned false - reached timeout of %d", - r.cfg.AcceptorTimeout) - return false - case <-quit: - return false - case <-r.quit: - return false - } - } - - // Create a new RPCAcceptor via the NewRPCAcceptor method. - rpcAcceptor := chanacceptor.NewRPCAcceptor(demultiplexReq) + // Create a new RPCAcceptor which will send requests into the + // newRequests channel when it receives them. + rpcAcceptor := chanacceptor.NewRPCAcceptor( + stream.Recv, stream.Send, r.cfg.AcceptorTimeout, + r.cfg.ActiveNetParams.Params, r.quit, + ) // Add the RPCAcceptor to the ChainedAcceptor and defer its removal. id := chainedAcceptor.AddAcceptor(rpcAcceptor) defer chainedAcceptor.RemoveAcceptor(id) - // errChan is used by the receive loop to signal any errors that occur - // during reading from the stream. This is primarily used to shutdown the - // send loop in the case of an RPC client disconnecting. - errChan := make(chan error, 1) - - // We need to have the stream.Recv() in a goroutine since the call is - // blocking and would prevent us from sending more ChannelAcceptRequests to - // the RPC client. - go func() { - for { - resp, err := stream.Recv() - if err != nil { - errChan <- err - return - } - - var pendingID [32]byte - copy(pendingID[:], resp.PendingChanId) - - openChanResp := lnrpc.ChannelAcceptResponse{ - Accept: resp.Accept, - PendingChanId: pendingID[:], - } - - // Now that we have the response from the RPC client, send it to - // the responses chan. - select { - case responses <- openChanResp: - case <-quit: - return - case <-r.quit: - return - } - } - }() - - acceptRequests := make(map[[32]byte]chan bool) - - for { - select { - case newRequest := <-newRequests: - - req := newRequest.chanReq - pendingChanID := req.OpenChanMsg.PendingChannelID - - acceptRequests[pendingChanID] = newRequest.responseChan - - // A ChannelAcceptRequest has been received, send it to the client. - chanAcceptReq := &lnrpc.ChannelAcceptRequest{ - NodePubkey: req.Node.SerializeCompressed(), - ChainHash: req.OpenChanMsg.ChainHash[:], - PendingChanId: req.OpenChanMsg.PendingChannelID[:], - FundingAmt: uint64(req.OpenChanMsg.FundingAmount), - PushAmt: uint64(req.OpenChanMsg.PushAmount), - DustLimit: uint64(req.OpenChanMsg.DustLimit), - MaxValueInFlight: uint64(req.OpenChanMsg.MaxValueInFlight), - ChannelReserve: uint64(req.OpenChanMsg.ChannelReserve), - MinHtlc: uint64(req.OpenChanMsg.HtlcMinimum), - FeePerKw: uint64(req.OpenChanMsg.FeePerKiloWeight), - CsvDelay: uint32(req.OpenChanMsg.CsvDelay), - MaxAcceptedHtlcs: uint32(req.OpenChanMsg.MaxAcceptedHTLCs), - ChannelFlags: uint32(req.OpenChanMsg.ChannelFlags), - } - - if err := stream.Send(chanAcceptReq); err != nil { - return err - } - case resp := <-responses: - // Look up the appropriate channel to send on given the pending ID. - // If a channel is found, send the response over it. - var pendingID [32]byte - copy(pendingID[:], resp.PendingChanId) - respChan, ok := acceptRequests[pendingID] - if !ok { - continue - } - - // Send the response boolean over the buffered response channel. - respChan <- resp.Accept - - // Delete the channel from the acceptRequests map. - delete(acceptRequests, pendingID) - case err := <-errChan: - rpcsLog.Errorf("Received an error: %v, shutting down", err) - return err - case <-r.quit: - return fmt.Errorf("RPC server is shutting down") - } - } + // Run the rpc acceptor, which will accept requests for channel + // acceptance decisions from our chained acceptor, send them to the + // channel acceptor and listen for and report responses. This function + // blocks, and will exit if the rpcserver receives the instruction to + // shutdown, or the client cancels. + return rpcAcceptor.Run() } // BakeMacaroon allows the creation of a new macaroon with custom read and write