From 936bcc43ffc613336ecb074a1230b7c3e30b2297 Mon Sep 17 00:00:00 2001 From: Conner Fromknecht Date: Wed, 8 May 2019 02:11:32 -0700 Subject: [PATCH 01/14] watchtower/wtwire/wtwire: extend ReadElement to check read length --- watchtower/wtwire/wtwire.go | 75 ++++++++++++++++++++++++++++++++++--- 1 file changed, 70 insertions(+), 5 deletions(-) diff --git a/watchtower/wtwire/wtwire.go b/watchtower/wtwire/wtwire.go index 1af9433d5b..3d0ba95f24 100644 --- a/watchtower/wtwire/wtwire.go +++ b/watchtower/wtwire/wtwire.go @@ -2,6 +2,7 @@ package wtwire import ( "encoding/binary" + "errors" "fmt" "io" @@ -33,6 +34,13 @@ func WriteElement(w io.Writer, element interface{}) error { return err } + case *uint16: + var b [2]byte + binary.BigEndian.PutUint16(b[:], *e) + if _, err := w.Write(b[:]); err != nil { + return err + } + case blob.Type: var b [2]byte binary.BigEndian.PutUint16(b[:], uint16(e)) @@ -40,6 +48,13 @@ func WriteElement(w io.Writer, element interface{}) error { return err } + case *blob.Type: + var b [2]byte + binary.BigEndian.PutUint16(b[:], uint16(*e)) + if _, err := w.Write(b[:]); err != nil { + return err + } + case uint32: var b [4]byte binary.BigEndian.PutUint32(b[:], e) @@ -47,6 +62,13 @@ func WriteElement(w io.Writer, element interface{}) error { return err } + case *uint32: + var b [4]byte + binary.BigEndian.PutUint32(b[:], *e) + if _, err := w.Write(b[:]); err != nil { + return err + } + case uint64: var b [8]byte binary.BigEndian.PutUint64(b[:], e) @@ -54,6 +76,13 @@ func WriteElement(w io.Writer, element interface{}) error { return err } + case *uint64: + var b [8]byte + binary.BigEndian.PutUint64(b[:], *e) + if _, err := w.Write(b[:]); err != nil { + return err + } + case [16]byte: if _, err := w.Write(e[:]); err != nil { return err @@ -74,6 +103,12 @@ func WriteElement(w io.Writer, element interface{}) error { return err } + case *[]byte: + _, err := w.Write(*e) + if err != nil { + return err + } + case lnwallet.SatPerKWeight: var b [8]byte binary.BigEndian.PutUint64(b[:], uint64(e)) @@ -81,6 +116,13 @@ func WriteElement(w io.Writer, element interface{}) error { return err } + case *lnwallet.SatPerKWeight: + var b [8]byte + binary.BigEndian.PutUint64(b[:], uint64(*e)) + if _, err := w.Write(b[:]); err != nil { + return err + } + case ErrorCode: var b [2]byte binary.BigEndian.PutUint16(b[:], uint16(e)) @@ -135,7 +177,8 @@ func WriteElements(w io.Writer, elements ...interface{}) error { // ReadElement is a one-stop utility function to deserialize any datastructure // encoded using the serialization format of lnwire. -func ReadElement(r io.Reader, element interface{}) error { +func ReadElement(r io.Reader, element interface{}, length uint64) error { + var expSize uint64 switch e := element.(type) { case *uint8: var b [1]uint8 @@ -143,6 +186,7 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = b[0] + expSize = 1 case *uint16: var b [2]byte @@ -150,6 +194,7 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = binary.BigEndian.Uint16(b[:]) + expSize = 2 case *blob.Type: var b [2]byte @@ -157,6 +202,7 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = blob.Type(binary.BigEndian.Uint16(b[:])) + expSize = 2 case *uint32: var b [4]byte @@ -164,6 +210,7 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = binary.BigEndian.Uint32(b[:]) + expSize = 4 case *uint64: var b [8]byte @@ -171,28 +218,38 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = binary.BigEndian.Uint64(b[:]) + expSize = 8 case *[16]byte: if _, err := io.ReadFull(r, e[:]); err != nil { return err } + expSize = 16 case *[32]byte: if _, err := io.ReadFull(r, e[:]); err != nil { return err } + expSize = 32 case *[33]byte: if _, err := io.ReadFull(r, e[:]); err != nil { return err } + expSize = 33 case *[]byte: - bytes, err := wire.ReadVarBytes(r, 0, 66000, "[]byte") - if err != nil { + if length != 0 { + *e = make([]byte, length) + _, err := io.ReadFull(r, (*e)[:]) return err + } else { + bytes, err := wire.ReadVarBytes(r, 0, 66000, "[]byte") + if err != nil { + return err + } + *e = bytes } - *e = bytes case *lnwallet.SatPerKWeight: var b [8]byte @@ -200,6 +257,7 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = lnwallet.SatPerKWeight(binary.BigEndian.Uint64(b[:])) + expSize = 8 case *ErrorCode: var b [2]byte @@ -207,11 +265,13 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = ErrorCode(binary.BigEndian.Uint16(b[:])) + expSize = 2 case *chainhash.Hash: if _, err := io.ReadFull(r, e[:]); err != nil { return err } + expSize = 32 case **lnwire.RawFeatureVector: f := lnwire.NewRawFeatureVector() @@ -233,11 +293,16 @@ func ReadElement(r io.Reader, element interface{}) error { return err } *e = pubKey + expSize = 33 default: return fmt.Errorf("Unknown type in ReadElement: %T", e) } + if length != 0 && length != expSize { + return errors.New("short read") + } + return nil } @@ -246,7 +311,7 @@ func ReadElement(r io.Reader, element interface{}) error { // function. func ReadElements(r io.Reader, elements ...interface{}) error { for _, element := range elements { - err := ReadElement(r, element) + err := ReadElement(r, element, 0) if err != nil { return err } From fdd036810251cc0028d647774d7125e4ee6c8e3a Mon Sep 17 00:00:00 2001 From: Conner Fromknecht Date: Wed, 8 May 2019 02:12:12 -0700 Subject: [PATCH 02/14] tlv/record: adds various tlv record constructors --- tlv/record.go | 119 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 119 insertions(+) create mode 100644 tlv/record.go diff --git a/tlv/record.go b/tlv/record.go new file mode 100644 index 0000000000..50ceb4a1b1 --- /dev/null +++ b/tlv/record.go @@ -0,0 +1,119 @@ +package tlv + +import ( + "github.com/btcsuite/btcd/btcec" + "github.com/lightningnetwork/lnd/lnwire" +) + +// Type is an 8-bit identifier for a TLV Record. +type Type uint8 + +// SentinelType is the identifier for the sentinel record. It uses the highest +// possible identifier so that it always occurs at the end of a stream when +// present. +const SentinelType Type = 255 + +// SizeFunc is a function that can compute the length of a given field. Since +// the size of the underlying field can change, this allows the size of the +// field to be evaluated at the time of encoding. +type SizeFunc func() uint16 + +// SizeVarBytes is a SizeFunc that can compute the length of a byte slice. +func SizeVarBytes(e *[]byte) SizeFunc { + return func() uint16 { + return uint16(len(*e)) + } +} + +// Record holds the required information to encode or decode a TLV record. +type Record struct { + typ Type + staticSize uint16 + sizeFunc SizeFunc + value interface{} +} + +// Size returns the size of the Record's value. If no static size is known, the +// dynamic size will be evaluated. +func (f *Record) Size() uint16 { + if f.sizeFunc == nil { + return f.staticSize + } + + return f.sizeFunc() +} + +// MakeSentinelRecord creates a sentinel record with type 255. +func MakeSentinelRecord() Record { + return Record{ + typ: SentinelType, + } +} + +// MakePrimitiveRecord creates a record for common types. +func MakePrimitiveRecord(typ Type, val interface{}) Record { + var ( + staticSize uint16 + sizeFunc SizeFunc + ) + switch e := val.(type) { + case *uint8, *int8: + staticSize = 1 + case *uint16, *int16: + staticSize = 2 + case *uint32, *int32: + staticSize = 4 + case *uint64, *int64: + staticSize = 8 + case *[32]byte: + staticSize = 32 + case *[33]byte, **btcec.PublicKey: + staticSize = 33 + case *lnwire.Sig: + staticSize = 64 + case *[]byte: + sizeFunc = SizeVarBytes(e) + default: + panic("unknown static type") + } + + return makeFieldRecord(typ, staticSize, sizeFunc, val) +} + +// MakeStaticRecord creates a record for a field of fixed-size +func MakeStaticRecord(typ Type, val interface{}, size uint16) Record { + return makeFieldRecord(typ, size, nil, val) +} + +// MakeDynamicRecord creates a record whose size may vary, and will be +// determined at the time of encoding via sizeFunc. +func MakeDynamicRecord(typ Type, val interface{}, sizeFunc SizeFunc) Record { + return makeFieldRecord(typ, 0, sizeFunc, val) +} + +// makeRetainedRecord creates a record holding an static byte slice. Since no +// encoding is known for this record, the bytes will be reserialized blindly +// during encoding. +func makeRetainedRecord(typ Type, val *[]byte) Record { + return makeFieldRecord(typ, uint16(len(*val)), nil, val) +} + +// makeFieldRecord creates a Record from the given parameters. This method +// panics when trying to construct a sentinel record, which should be done only +// with MakeSentinelRecord. +func makeFieldRecord(typ Type, size uint16, sizeFunc SizeFunc, + val interface{}) Record { + + // Prevent creation of records that attempt to use the SentinelType to + // hold information for a field. + if typ == SentinelType { + panic("misuse of sentinel type") + } + + return Record{ + typ: typ, + staticSize: size, + sizeFunc: sizeFunc, + value: val, + } +} From 33de821cfd49a61406013841ff1c4d7fd44afec7 Mon Sep 17 00:00:00 2001 From: Conner Fromknecht Date: Wed, 8 May 2019 02:12:35 -0700 Subject: [PATCH 03/14] tlv/stream: adds tlv stream encoding/decoding --- tlv/stream.go | 341 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 341 insertions(+) create mode 100644 tlv/stream.go diff --git a/tlv/stream.go b/tlv/stream.go new file mode 100644 index 0000000000..5367b84f12 --- /dev/null +++ b/tlv/stream.go @@ -0,0 +1,341 @@ +package tlv + +import ( + "encoding/binary" + "errors" + "io" + "io/ioutil" +) + +var ( + // ErrInvalidSentinel signals that a sentinel record contained a + // non-zero length. + ErrInvalidSentinel = errors.New("invalid tlv sentinel") + + // ErrNotCanonicalStream signals that a decoded stream does not contain + // records sorting by monotonically-increasing type. + ErrNotCanonicalStream = errors.New("tlv stream is not canonical") +) + +// ParseMode defines various modes when decoding a TLV stream. +type ParseMode uint8 + +const ( + // ParseModeDiscard will discard unknown records during decoding. + ParseModeDiscard ParseMode = iota + + // ParseModeRetain will retain unknown records during decoding, allow a + // successfully decoded stream to be reserialized identically to how it + // was received. + ParseModeRetain +) + +// RecordEncoder specifies a codec for serializing a given field. +type RecordEncoder func(io.Writer, interface{}) error + +// RecordDecoder specifies a codec for deserializing given field. The final +// argument is the expected length, and the method should return an error if +// thee number of bytes read does not match this value. +type RecordDecoder func(io.Reader, interface{}, uint64) error + +// Stream defines a TLV stream that can be used for encoding or decoding a set +// of TLV Records. +type Stream struct { + records []Record + encoder RecordEncoder + decoder RecordDecoder + + // retained captures any records with unknown types during decoding to + // permit identical reserialization of the decoded bytes. + retained []Record +} + +// NewStream crates a new TLV Stream given an encoding code, a decoding codec, +// and a set of known records. +func NewStream(encoder RecordEncoder, decoder RecordDecoder, + records ...Record) *Stream { + + // Assert that the ordering of the Records is canonical and appear in + // ascending order of type. + var min int + for _, record := range records { + if int(record.typ) < min { + panic(ErrNotCanonicalStream.Error()) + } + min = int(record.typ) + 1 + } + + return &Stream{ + records: records, + encoder: encoder, + decoder: decoder, + } +} + +// Encode writes a Stream to the passed io.Writer. Each of the Records known to +// the Stream is written in ascending order of their type so as to be canonical. +// This method can be made to encode a sentinel record by providing a +// MakeSentinelRecord as the last Record during the Stream's creation. +// +// The stream is constructed by concatenating the individual, serialized Records +// where each record has the following format: +// [1: type] +// [2: length] +// [length: value] +// +// An error is returned if the io.Writer fails to accept bytes from the +// encoding, and nothing else. The ordering of the Records is asserted upon the +// creation of a Stream, and thus the output will be by definition canonical. +func (m Stream) Encode(w io.Writer) error { + var ( + buf [2]uint8 + typ Type + recordIdx int + retainedIdx int + ) + + // Iterate through all known and retained records, if any, serializing + // each record's type, length and value. + for recordIdx < len(m.records) || retainedIdx < len(m.retained) { + // Determine the next record to write by comparing the head of + // the remaining known and retained records. + var record *Record + switch { + case recordIdx == len(m.records): + record = &m.retained[retainedIdx] + retainedIdx++ + case retainedIdx == len(m.retained): + record = &m.records[recordIdx] + recordIdx++ + case m.records[recordIdx].typ < m.retained[retainedIdx].typ: + record = &m.records[recordIdx] + recordIdx++ + default: + record = &m.retained[retainedIdx] + retainedIdx++ + } + + // Write the record's type. + typ = record.typ + buf[0] = uint8(typ) + _, err := w.Write(buf[:1]) + if err != nil { + return err + } + + // Write the record's 2-byte length. + binary.BigEndian.PutUint16(buf[:], record.Size()) + _, err = w.Write(buf[:]) + if err != nil { + return err + } + + // There is nothing to encode for a sentinel value, and by + // definition must be the last element in the stream. Exit early + // since the codec won't know how to process a nil element and + // it must have a zero-length value. + if typ == SentinelType { + return nil + } + + // Encode the current record's value using the stream's codec. + err = m.encoder(w, record.value) + if err != nil { + return err + } + } + + return nil +} + +// Decode deserializes TLV Stream from the passed io.Reader. The Stream will +// inspect each record that is parsed and check to see if it has a corresponding +// Record to facilitate deserialization of that field. If the record is unknown, +// the Stream will discard the record's bytes and proceed to the subsequent +// record. +// +// Each record has the following format: +// [1: type] +// [2: length] +// [length: value] +// +// A series of (possibly zero) records are concatenated into a stream, +// optionally including a sentinel record. The following are examples of valid +// streams: +// +// Stream without Sentinel Record: +// (t: 0x01, l: 0x0004, v: 0xff, 0xff, 0xff, 0xff) +// +// Stream with Sentinel Record: +// (t: 0x02, l: 0x0002, v: 0xac, 0xbd) +// (t: 0xff, l: 0x0000, v: ) +// +// This method asserts that the byte stream is canonical, namely that each +// record is unique and that all records are sorted in ascending order. An +// ErrNotCanonicalStream error is returned if the encoded TLV stream is not. +// +// The sentinel record is identified via a type of SentinelType (0xff). When +// this record is encountered, the Stream will verify that the encoded length is +// zero and stop reading. If the length is not zero, an ErrInvalidSentinel error +// is returned. +// +// In the event that a TLV stream does not have a sentinel record, we permit an +// io.EOF error only when reading the type byte which signals that the last +// record was read cleanly and we should stop parsing. All other io.EOF or +// io.ErrUnexpectedEOF errors are returned. +// +// If ParseModeRetain is used, any unknown fields will be blindly copied so that +// they may be reserialized via a subsequent call to Encode. Otherwise, unknown +// fields are discarded. +func (s *Stream) Decode(r io.Reader, mode ParseMode) error { + var ( + buf [2]byte + typ Type + length uint64 + recordIdx int + retained []Record + ) + + // Iterate through all possible type identifiers. As types are read from + // the io.Reader, min will skip forward to the last read type. + for min := 0; min < 256; min++ { + // Read the next type byte. + _, err := io.ReadFull(r, buf[:1]) + switch { + + // We'll silence an EOF in this case in case the stream doesn't + // have a sentinel record. + case err == io.EOF: + s.retained = retained + return nil + + // Other unexpected errors. + case err != nil: + return err + } + + typ = Type(buf[0]) + + // Assert that this type is greater than any previously read. + // This check prevents us from accepts encodings that have + // duplicate records or from accepting an unsorted series. + if int(typ) < min { + return ErrNotCanonicalStream + } + + // Read the 2-byte length. + _, err = io.ReadFull(r, buf[:]) + if err != nil { + return err + } + length = uint64(binary.BigEndian.Uint16(buf[:])) + + // Stop reading if we receive a sentinel record. + if typ == SentinelType { + switch { + + // If we are in retain mode, we must also retain the + // sentinel record. + case mode == ParseModeRetain: + retained = append( + retained, MakeSentinelRecord(), + ) + fallthrough + + // Assert that the sentinel record has length zero. If + // so, store the retained values so they can be encoded. + case length == 0: + s.retained = retained + return nil + + // Sentinel value had a non-zero length, fail. + default: + return ErrInvalidSentinel + } + } + + // Otherwise, we are processing some non-sentinel record. Search + // the records known to the stream for this type. We'll begin + // the search and recordIdx and walk forward until we find it + // or the next record's type is larger. + field, newIdx, ok := s.getRecord(typ, recordIdx) + switch { + + // We know of this record type, proceed to decode the value. + // This method asserts that length bytes are read in the + // process, and returns an error if the number of bytes is not + // exactly length. + case ok: + err := s.decoder(r, field.value, length) + if err != nil { + return err + } + + // This record type is unknown to the stream and the parse mode + // requires we retain the value, discard exactly the number of + // bytes specified by length. + case mode == ParseModeRetain: + retainedValue := make([]byte, length) + _, err := io.ReadFull(r, retainedValue) + if err != nil { + return err + } + + retainedRecord := makeRetainedRecord(typ, &retainedValue) + retained = append(retained, retainedRecord) + + // This record type is unknown to the stream and the parse mode + // does not require retaining the value, discard exactly the + // number of bytes specified by length. + case mode == ParseModeDiscard: + _, err := io.CopyN(ioutil.Discard, r, int64(length)) + if err != nil { + return err + } + } + // Update our record index so that we can begin our next search + // from where we left off. + recordIdx = newIdx + + // Finally, set our lower bound on the next accept type to type + // just processed. On the next iteration, this value will be + // incremented ensuring the next type is greater. + min = int(typ) + } + + panic("unreachable") +} + +// getRecord searches for a record matching typ known to the stream. The boolean +// return value indicates whether the record is known to the stream. The integer +// return value carries the index from where getRecord should be invoked on the +// subsequent call. The first call to getRecord should always use an idx of 0. +func (s *Stream) getRecord(typ Type, idx int) (Record, int, bool) { + for idx < len(s.records) { + record := s.records[idx] + switch { + + // Found target record, return it to the caller. The next index + // returned points to the immediately following record. + case record.typ == typ: + return record, idx + 1, true + + // This record's type is lower than the target. Advance our + // index and continue to the next record which will have a + // strictly higher type. + case record.typ < typ: + idx++ + continue + + // This record's type is larger than the target, hence we have + // no record matching the current type. Return the current index + // so that we can start our search from here when processing the + // next tlv record. + default: + return Record{}, idx, false + } + } + + // All known records are exhausted. + return Record{}, idx, false +} From f4aad0379ccfd25ecbe984995d9a1c885ff5b6bb Mon Sep 17 00:00:00 2001 From: Conner Fromknecht Date: Wed, 8 May 2019 02:12:59 -0700 Subject: [PATCH 04/14] tlv/stream_test: add basic test and benchmark --- tlv/stream_test.go | 622 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 622 insertions(+) create mode 100644 tlv/stream_test.go diff --git a/tlv/stream_test.go b/tlv/stream_test.go new file mode 100644 index 0000000000..a7bd591381 --- /dev/null +++ b/tlv/stream_test.go @@ -0,0 +1,622 @@ +package tlv_test + +import ( + "bytes" + "io" + "io/ioutil" + "reflect" + "testing" + + "github.com/lightningnetwork/lnd/lnwallet" + "github.com/lightningnetwork/lnd/tlv" + "github.com/lightningnetwork/lnd/watchtower/blob" + "github.com/lightningnetwork/lnd/watchtower/wtwire" +) + +type testObj struct { + u16 uint16 + u32 uint32 + u64 uint64 + buf []byte +} + +type tlvTestCase struct { + name string + encGen func() (*testObj, *tlv.Stream) + decGen func() (*testObj, *tlv.Stream) + expObj *testObj + mode tlv.ParseMode +} + +var tlvTests = []tlvTestCase{ + { + name: "empty", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + expObj: &testObj{}, + }, + { + name: "empty sentinel", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakeSentinelRecord(), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + expObj: &testObj{}, + }, + { + name: "partial encode", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u32: 3, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + expObj: &testObj{ + u32: 3, + buf: bytes.Repeat([]byte{0x05}, 3), + }, + }, + { + name: "partial encode sentinel", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u32: 3, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(3, &o.buf), + tlv.MakeSentinelRecord(), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + expObj: &testObj{ + u32: 3, + buf: bytes.Repeat([]byte{0x05}, 3), + }, + }, + { + name: "partial decode", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u16: 2, + u32: 5, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(2, &o.u64), + ) + return o, s + }, + expObj: &testObj{ + u16: 2, + u64: 7, + }, + }, + { + name: "partial decode sentinel", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u16: 2, + u32: 5, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + tlv.MakeSentinelRecord(), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(2, &o.u64), + ) + return o, s + }, + expObj: &testObj{ + u16: 2, + u64: 7, + }, + }, + { + name: "partial decode retain", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u16: 2, + u32: 5, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + tlv.MakeSentinelRecord(), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(2, &o.u64), + ) + return o, s + }, + expObj: &testObj{ + u16: 2, + u64: 7, + }, + mode: tlv.ParseModeRetain, + }, + { + name: "full decode encode", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u16: 2, + u32: 3, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + expObj: &testObj{ + u16: 2, + u32: 3, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + }, + }, + { + name: "full encode decode sentinel", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u16: 2, + u32: 3, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + tlv.MakeSentinelRecord(), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + expObj: &testObj{ + u16: 2, + u32: 3, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + }, + }, + { + name: "full encode decode sentinel retain", + encGen: func() (*testObj, *tlv.Stream) { + o := &testObj{ + u16: 2, + u32: 3, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + } + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + tlv.MakeSentinelRecord(), + ) + return o, s + }, + decGen: func() (*testObj, *tlv.Stream) { + o := &testObj{} + s := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(0, &o.u16), + tlv.MakePrimitiveRecord(1, &o.u32), + tlv.MakePrimitiveRecord(2, &o.u64), + tlv.MakePrimitiveRecord(3, &o.buf), + ) + return o, s + }, + expObj: &testObj{ + u16: 2, + u32: 3, + u64: 7, + buf: bytes.Repeat([]byte{0x05}, 3), + }, + mode: tlv.ParseModeRetain, + }, +} + +func TestTLV(t *testing.T) { + for _, test := range tlvTests { + t.Run(test.name, func(t *testing.T) { + testTLV(t, test) + }) + } +} + +func testTLV(t *testing.T, test tlvTestCase) { + _, s1 := test.encGen() + + var b bytes.Buffer + err := s1.Encode(&b) + if err != nil { + t.Fatalf("unable to encode tlv stream: %v", err) + } + + obj2, s2 := test.decGen() + err = s2.Decode(bytes.NewReader(b.Bytes()), test.mode) + if err != nil { + t.Fatalf("unable to decode tlv stream: %v", err) + } + + if !reflect.DeepEqual(test.expObj, obj2) { + t.Fatalf("mismatch object, want: %v, got: %v", + test.expObj, obj2) + } + + if test.mode == tlv.ParseModeDiscard { + return + } + + var b2 bytes.Buffer + err = s2.Encode(&b2) + if err != nil { + t.Fatalf("unable to encode retained tlv stream: %v", err) + } + + if bytes.Compare(b2.Bytes(), b.Bytes()) != 0 { + t.Fatalf("mismatch retained bytes, want: %x, got: %x", + b.Bytes(), b2.Bytes()) + } +} + +type thing struct { + known uint32 + + field1 uint32 + field9 uint32 + field10 uint32 + field100 uint32 + field101 []byte + + tlvStream *tlv.Stream +} + +type CreateSessionTLV struct { + BlobType blob.Type + MaxUpdates uint16 + RewardBase uint32 + RewardRate uint32 + SweepFeeRate lnwallet.SatPerKWeight + + tlvStream *tlv.Stream +} + +func NewCreateSessionTLV() *CreateSessionTLV { + m := &CreateSessionTLV{} + m.tlvStream = tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakeStaticRecord(0, &m.BlobType, 2), + tlv.MakePrimitiveRecord(1, &m.MaxUpdates), + tlv.MakePrimitiveRecord(2, &m.RewardBase), + tlv.MakePrimitiveRecord(3, &m.RewardRate), + tlv.MakeStaticRecord(4, &m.SweepFeeRate, 8), + tlv.MakeSentinelRecord(), + ) + + return m +} + +func (c *CreateSessionTLV) Encode(w io.Writer) error { + return c.tlvStream.Encode(w) +} + +func (c *CreateSessionTLV) Decode(r io.Reader) error { + return c.tlvStream.Decode(r, tlv.ParseModeDiscard) +} + +func newThing() *thing { + t := new(thing) + + t.tlvStream = tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + []tlv.Record{ + tlv.MakePrimitiveRecord(1, &t.field1), + tlv.MakePrimitiveRecord(9, &t.field9), + tlv.MakePrimitiveRecord(10, &t.field10), + tlv.MakePrimitiveRecord(100, &t.field100), + tlv.MakePrimitiveRecord(101, &t.field101), + tlv.MakeSentinelRecord(), + }..., + ) + + return t +} + +func (t *thing) Encode(w io.Writer) error { + err := wtwire.WriteElement(w, t.known) + if err != nil { + return err + } + + return t.tlvStream.Encode(w) +} + +func (t *thing) EncodeNorm(w io.Writer) error { + return wtwire.WriteElements(w, + t.known, + t.field1, + t.field9, + t.field10, + t.field100, + t.field101, + ) +} + +func (t *thing) DecodeNorm(r io.Reader) error { + return wtwire.ReadElements(r, + &t.known, + &t.field1, + &t.field9, + &t.field10, + &t.field100, + &t.field101, + ) +} +func (t *thing) Decode(r io.Reader) error { + err := wtwire.ReadElement(r, &t.known, 0) + if err != nil { + return err + } + + return t.tlvStream.Decode(r, tlv.ParseModeDiscard) +} + +func BenchmarkEncodeTLV(t *testing.B) { + ting := newThing() + ting.field101 = bytes.Repeat([]byte{0xaa}, 32) + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + err = ting.Encode(ioutil.Discard) + } + _ = err +} + +func BenchmarkEncode(t *testing.B) { + ting := newThing() + ting.field101 = bytes.Repeat([]byte{0xaa}, 32) + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + err = ting.EncodeNorm(ioutil.Discard) + } + _ = err +} + +func BenchmarkDecodeTLV(t *testing.B) { + ting := newThing() + ting.field101 = bytes.Repeat([]byte{0xaa}, 32) + + var b bytes.Buffer + ting.Encode(&b) + r := bytes.NewReader(b.Bytes()) + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + r.Seek(0, 0) + err = ting.Decode(r) + } + _ = err +} + +func BenchmarkDecode(t *testing.B) { + ting := newThing() + ting.field101 = bytes.Repeat([]byte{0xaa}, 32) + + var b bytes.Buffer + ting.Encode(&b) + r := bytes.NewReader(b.Bytes()) + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + r.Seek(0, 0) + err = ting.DecodeNorm(r) + } + _ = err +} + +func BenchmarkEncodeCreateSession(t *testing.B) { + m := &wtwire.CreateSession{} + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + err = m.Encode(ioutil.Discard, 0) + } + _ = err +} + +func BenchmarkEncodeCreateSessionTLV(t *testing.B) { + m := NewCreateSessionTLV() + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + err = m.Encode(ioutil.Discard) + } + _ = err +} + +func BenchmarkDecodeCreateSession(t *testing.B) { + m := &wtwire.CreateSession{} + + var b bytes.Buffer + m.Encode(&b, 0) + r := bytes.NewReader(b.Bytes()) + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + r.Seek(0, 0) + err = m.Decode(r, 0) + } + _ = err +} + +func BenchmarkDecodeCreateSessionTLV(t *testing.B) { + m := NewCreateSessionTLV() + + var b bytes.Buffer + m.Encode(&b) + r := bytes.NewReader(b.Bytes()) + + t.ReportAllocs() + t.ResetTimer() + + var err error + for i := 0; i < t.N; i++ { + r.Seek(0, 0) + err = m.Decode(r) + } + _ = err +} From c90e5eba12c680cc94e550912a5d2db8e14a5f01 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 10 Jan 2019 20:01:16 -0800 Subject: [PATCH 05/14] build: temporarily point to roasbeef's lightning-onion fork --- go.mod | 2 ++ go.sum | 2 ++ 2 files changed, 4 insertions(+) diff --git a/go.mod b/go.mod index 63a78f28e6..9bc26e5f65 100644 --- a/go.mod +++ b/go.mod @@ -50,3 +50,5 @@ require ( replace github.com/lightningnetwork/lnd/ticker => ./ticker replace github.com/lightningnetwork/lnd/queue => ./queue + +replace github.com/lightningnetwork/lightning-onion v0.0.0-20190430041606-751fb4dd8b72 => github.com/roasbeef/lightning-onion v0.0.0-20190111024907-b16e0e746d70d6f19176fe321d8c392e788f6168 diff --git a/go.sum b/go.sum index 4391d91a97..dbbd8e67fd 100644 --- a/go.sum +++ b/go.sum @@ -124,6 +124,8 @@ github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+W github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU= github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/roasbeef/lightning-onion v0.0.0-20190111024907-b16e0e746d70d6f19176fe321d8c392e788f6168 h1:CRdukCpvAHhnzm7stsLDSi88h26wcTCIUxFSDSso6Vg= +github.com/roasbeef/lightning-onion v0.0.0-20190111024907-b16e0e746d70d6f19176fe321d8c392e788f6168/go.mod h1:Sooe/CoCqa85JxqHV+IBR2HW+6t2Cv+36awSmoccswM= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af h1:gu+uRPtBe88sKxUCEXRoeCvVG90TJmwhiqRpvdhQFng= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/tv42/zbase32 v0.0.0-20160707012821-501572607d02 h1:tcJ6OjwOMvExLlzrAVZute09ocAGa7KqOON60++Gz4E= From ffe1ebaa3c4c17bb380c80b796e6e501026ee99c Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 10 Jan 2019 21:23:10 -0800 Subject: [PATCH 06/14] routing: extend LightningPayment to allow user specified EOB data --- routing/pathfind_test.go | 2 +- routing/router.go | 26 +++++++++++++++++--------- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/routing/pathfind_test.go b/routing/pathfind_test.go index 7ce114c290..7ce8bea3fa 100644 --- a/routing/pathfind_test.go +++ b/routing/pathfind_test.go @@ -807,7 +807,7 @@ func testBasicGraphPathFindingCase(t *testing.T, graphInstance *testGraphInstanc // Next, we'll assert that the "next hop" field in each route payload // properly points to the channel ID that the HTLC should be forwarded // along. - sphinxPath, err := route.ToSphinxPath() + sphinxPath, err := route.ToSphinxPath(nil) if err != nil { t.Fatalf("unable to make sphinx path: %v", err) } diff --git a/routing/router.go b/routing/router.go index d49533c622..4b7f5ab876 100644 --- a/routing/router.go +++ b/routing/router.go @@ -1385,7 +1385,7 @@ func (r *ChannelRouter) FindRoute(source, target route.Vertex, // the onion route specified by the passed layer 3 route. The blob returned // from this function can immediately be included within an HTLC add packet to // be sent to the first hop within the route. -func generateSphinxPacket(rt *route.Route, paymentHash []byte) ([]byte, +func generateSphinxPacket(rt *route.Route, paymentHash, destEOB []byte) ([]byte, *sphinx.Circuit, error) { // As a sanity check, we'll ensure that the set of hops has been @@ -1396,16 +1396,16 @@ func generateSphinxPacket(rt *route.Route, paymentHash []byte) ([]byte, } // Now that we know we have an actual route, we'll map the route into a - // sphinx payument path which includes per-hop paylods for each hop + // sphinx payment path which includes per-hop payloads for each hop // that give each node within the route the necessary information // (fees, CLTV value, etc) to properly forward the payment. - sphinxPath, err := rt.ToSphinxPath() + sphinxPath, err := rt.ToSphinxPath(destEOB) if err != nil { return nil, nil, err } log.Tracef("Constructed per-hop payloads for payment_hash=%x: %v", - paymentHash[:], newLogClosure(func() string { + paymentHash, newLogClosure(func() string { return spew.Sdump(sphinxPath[:sphinxPath.TrueRouteLength()]) }), ) @@ -1500,6 +1500,12 @@ type LightningPayment struct { // hop. If nil, any channel may be used. OutgoingChannelID *uint64 + // DestinationEOB is an optional field that allows the sender to encode + // a set of opaque bytes to the final hop. This payload will be + // delivered as an EOB as will be onion encrypted just like the rest of + // the route. + DestinationEOB []byte + // TODO(roasbeef): add e2e message? } @@ -1632,6 +1638,7 @@ func (r *ChannelRouter) sendPayment(payment *LightningPayment, // indicating if more attempts are needed. preimage, final, err := r.sendPaymentAttempt( paySession, route, payment.PaymentHash, + payment.DestinationEOB, ) if final { return preimage, route, err @@ -1646,7 +1653,8 @@ func (r *ChannelRouter) sendPayment(payment *LightningPayment, // bool parameter indicates whether this is a final outcome or more attempts // should be made. func (r *ChannelRouter) sendPaymentAttempt(paySession *paymentSession, - route *route.Route, paymentHash [32]byte) ([32]byte, bool, error) { + route *route.Route, paymentHash [32]byte, + destEOB []byte) ([32]byte, bool, error) { log.Tracef("Attempting to send payment %x, using route: %v", paymentHash, newLogClosure(func() string { @@ -1654,7 +1662,7 @@ func (r *ChannelRouter) sendPaymentAttempt(paySession *paymentSession, }), ) - preimage, err := r.sendToSwitch(route, paymentHash) + preimage, err := r.sendToSwitch(route, paymentHash, destEOB) if err == nil { return preimage, true, nil } @@ -1669,14 +1677,14 @@ func (r *ChannelRouter) sendPaymentAttempt(paySession *paymentSession, // sendToSwitch sends a payment along the specified route and returns the // obtained preimage. -func (r *ChannelRouter) sendToSwitch(route *route.Route, paymentHash [32]byte) ( - [32]byte, error) { +func (r *ChannelRouter) sendToSwitch(route *route.Route, paymentHash [32]byte, + destEOB []byte) ([32]byte, error) { // Generate the raw encoded sphinx packet to be included along // with the htlcAdd message that we send directly to the // switch. onionBlob, circuit, err := generateSphinxPacket( - route, paymentHash[:], + route, paymentHash[:], destEOB, ) if err != nil { return [32]byte{}, err From c222d86f279782698e8a386377f6ee2acb24ef49 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 10 Jan 2019 21:28:18 -0800 Subject: [PATCH 07/14] htlcswitch: expose ExtraOnionBlob in HopIterator --- htlcswitch/iterator.go | 13 +++++++++++++ htlcswitch/link.go | 3 ++- htlcswitch/mock.go | 4 ++++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/htlcswitch/iterator.go b/htlcswitch/iterator.go index a068000d43..72cf4bf450 100644 --- a/htlcswitch/iterator.go +++ b/htlcswitch/iterator.go @@ -87,6 +87,11 @@ type HopIterator interface { // information given to it by the prior hop. ForwardingInstructions() ForwardingInfo + // ExtraOnionBlob returns any parsed EOB data if any. If data is + // present, then the Type field will be anything other than + // sphinx.EOBEmpty. + ExtraOnionBlob() []byte + // EncodeNextHop encodes the onion packet destined for the next hop // into the passed io.Writer. EncodeNextHop(w io.Writer) error @@ -159,6 +164,14 @@ func (r *sphinxHopIterator) ForwardingInstructions() ForwardingInfo { } } +// ExtraOnionBlob returns any parsed EOB data if any. If data is present, then +// the Type field will be anything other than sphinx.EOBEmpty. +// +// NOTE: Part of the HopIterator interface. +func (r *sphinxHopIterator) ExtraOnionBlob() []byte { + return r.processedPacket.ExtraOnionBlob +} + // ExtractErrorEncrypter decodes and returns the ErrorEncrypter for this hop, // along with a failure code to signal if the decoding was successful. The // ErrorEncrypter is used to encrypt errors back to the sender in the event that diff --git a/htlcswitch/link.go b/htlcswitch/link.go index dc50b4fd8c..050b292b52 100644 --- a/htlcswitch/link.go +++ b/htlcswitch/link.go @@ -2565,6 +2565,7 @@ func (l *channelLink) processRemoteAdds(fwdPkg *channeldb.FwdPkg, case exitHop: updated, err := l.processExitHop( pd, obfuscator, fwdInfo, heightNow, + chanIterator.ExtraOnionBlob(), ) if err != nil { l.fail(LinkFailureError{code: ErrInternalError}, @@ -2786,7 +2787,7 @@ func (l *channelLink) processExitHop(pd *lnwallet.PaymentDescriptor, event, err := l.cfg.Registry.NotifyExitHopHtlc( invoiceHash, pd.Amount, pd.Timeout, int32(heightNow), - l.hodlQueue.ChanIn(), + l.hodlQueue.ChanIn(), packetEOB, ) switch err { diff --git a/htlcswitch/mock.go b/htlcswitch/mock.go index be9c39943b..4f25e3f04d 100644 --- a/htlcswitch/mock.go +++ b/htlcswitch/mock.go @@ -280,6 +280,10 @@ func (r *mockHopIterator) ForwardingInstructions() ForwardingInfo { return h } +func (r *mockHopIterator) ExtraOnionBlob() sphinx.ExtraHopData { + return sphinx.ExtraHopData{} +} + func (r *mockHopIterator) ExtractErrorEncrypter( extracter ErrorEncrypterExtracter) (ErrorEncrypter, lnwire.FailCode) { From 4fe85ba99e8ef8452b176f0abf9876e5f16a750f Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 10 Jan 2019 21:28:57 -0800 Subject: [PATCH 08/14] lnrpc: add new KeySend option to SendPayment for spontaneous payments --- lnrpc/invoicesrpc/invoices.pb.go | 18 +- lnrpc/rpc.pb.go | 1264 +++++++++++++++--------------- lnrpc/rpc.proto | 8 + lnrpc/rpc.swagger.json | 5 + 4 files changed, 661 insertions(+), 634 deletions(-) diff --git a/lnrpc/invoicesrpc/invoices.pb.go b/lnrpc/invoicesrpc/invoices.pb.go index 3e86dfaad3..39ce3d5fa2 100644 --- a/lnrpc/invoicesrpc/invoices.pb.go +++ b/lnrpc/invoicesrpc/invoices.pb.go @@ -37,7 +37,7 @@ func (m *CancelInvoiceMsg) Reset() { *m = CancelInvoiceMsg{} } func (m *CancelInvoiceMsg) String() string { return proto.CompactTextString(m) } func (*CancelInvoiceMsg) ProtoMessage() {} func (*CancelInvoiceMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_invoices_b95f8bc86c534ce9, []int{0} + return fileDescriptor_invoices_bb85468a9582e4cb, []int{0} } func (m *CancelInvoiceMsg) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CancelInvoiceMsg.Unmarshal(m, b) @@ -74,7 +74,7 @@ func (m *CancelInvoiceResp) Reset() { *m = CancelInvoiceResp{} } func (m *CancelInvoiceResp) String() string { return proto.CompactTextString(m) } func (*CancelInvoiceResp) ProtoMessage() {} func (*CancelInvoiceResp) Descriptor() ([]byte, []int) { - return fileDescriptor_invoices_b95f8bc86c534ce9, []int{1} + return fileDescriptor_invoices_bb85468a9582e4cb, []int{1} } func (m *CancelInvoiceResp) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CancelInvoiceResp.Unmarshal(m, b) @@ -131,7 +131,7 @@ func (m *AddHoldInvoiceRequest) Reset() { *m = AddHoldInvoiceRequest{} } func (m *AddHoldInvoiceRequest) String() string { return proto.CompactTextString(m) } func (*AddHoldInvoiceRequest) ProtoMessage() {} func (*AddHoldInvoiceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_invoices_b95f8bc86c534ce9, []int{2} + return fileDescriptor_invoices_bb85468a9582e4cb, []int{2} } func (m *AddHoldInvoiceRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_AddHoldInvoiceRequest.Unmarshal(m, b) @@ -229,7 +229,7 @@ func (m *AddHoldInvoiceResp) Reset() { *m = AddHoldInvoiceResp{} } func (m *AddHoldInvoiceResp) String() string { return proto.CompactTextString(m) } func (*AddHoldInvoiceResp) ProtoMessage() {} func (*AddHoldInvoiceResp) Descriptor() ([]byte, []int) { - return fileDescriptor_invoices_b95f8bc86c534ce9, []int{3} + return fileDescriptor_invoices_bb85468a9582e4cb, []int{3} } func (m *AddHoldInvoiceResp) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_AddHoldInvoiceResp.Unmarshal(m, b) @@ -268,7 +268,7 @@ func (m *SettleInvoiceMsg) Reset() { *m = SettleInvoiceMsg{} } func (m *SettleInvoiceMsg) String() string { return proto.CompactTextString(m) } func (*SettleInvoiceMsg) ProtoMessage() {} func (*SettleInvoiceMsg) Descriptor() ([]byte, []int) { - return fileDescriptor_invoices_b95f8bc86c534ce9, []int{4} + return fileDescriptor_invoices_bb85468a9582e4cb, []int{4} } func (m *SettleInvoiceMsg) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SettleInvoiceMsg.Unmarshal(m, b) @@ -305,7 +305,7 @@ func (m *SettleInvoiceResp) Reset() { *m = SettleInvoiceResp{} } func (m *SettleInvoiceResp) String() string { return proto.CompactTextString(m) } func (*SettleInvoiceResp) ProtoMessage() {} func (*SettleInvoiceResp) Descriptor() ([]byte, []int) { - return fileDescriptor_invoices_b95f8bc86c534ce9, []int{5} + return fileDescriptor_invoices_bb85468a9582e4cb, []int{5} } func (m *SettleInvoiceResp) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SettleInvoiceResp.Unmarshal(m, b) @@ -337,7 +337,7 @@ func (m *SubscribeSingleInvoiceRequest) Reset() { *m = SubscribeSingleIn func (m *SubscribeSingleInvoiceRequest) String() string { return proto.CompactTextString(m) } func (*SubscribeSingleInvoiceRequest) ProtoMessage() {} func (*SubscribeSingleInvoiceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_invoices_b95f8bc86c534ce9, []int{6} + return fileDescriptor_invoices_bb85468a9582e4cb, []int{6} } func (m *SubscribeSingleInvoiceRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SubscribeSingleInvoiceRequest.Unmarshal(m, b) @@ -602,10 +602,10 @@ var _Invoices_serviceDesc = grpc.ServiceDesc{ } func init() { - proto.RegisterFile("invoicesrpc/invoices.proto", fileDescriptor_invoices_b95f8bc86c534ce9) + proto.RegisterFile("invoicesrpc/invoices.proto", fileDescriptor_invoices_bb85468a9582e4cb) } -var fileDescriptor_invoices_b95f8bc86c534ce9 = []byte{ +var fileDescriptor_invoices_bb85468a9582e4cb = []byte{ // 509 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x53, 0x41, 0x6f, 0xd3, 0x4c, 0x10, 0x95, 0x93, 0x34, 0x4d, 0x26, 0x6d, 0xbf, 0x7c, 0x0b, 0x44, 0x96, 0x45, 0xc1, 0x58, 0x1c, diff --git a/lnrpc/rpc.pb.go b/lnrpc/rpc.pb.go index 5c7084cff7..88c493f837 100644 --- a/lnrpc/rpc.pb.go +++ b/lnrpc/rpc.pb.go @@ -55,7 +55,7 @@ func (x AddressType) String() string { return proto.EnumName(AddressType_name, int32(x)) } func (AddressType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{0} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{0} } type ChannelCloseSummary_ClosureType int32 @@ -90,7 +90,7 @@ func (x ChannelCloseSummary_ClosureType) String() string { return proto.EnumName(ChannelCloseSummary_ClosureType_name, int32(x)) } func (ChannelCloseSummary_ClosureType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{41, 0} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{41, 0} } type Peer_SyncType int32 @@ -122,7 +122,7 @@ func (x Peer_SyncType) String() string { return proto.EnumName(Peer_SyncType_name, int32(x)) } func (Peer_SyncType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{44, 0} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{44, 0} } type ChannelEventUpdate_UpdateType int32 @@ -151,7 +151,7 @@ func (x ChannelEventUpdate_UpdateType) String() string { return proto.EnumName(ChannelEventUpdate_UpdateType_name, int32(x)) } func (ChannelEventUpdate_UpdateType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{62, 0} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{62, 0} } type Invoice_InvoiceState int32 @@ -180,7 +180,7 @@ func (x Invoice_InvoiceState) String() string { return proto.EnumName(Invoice_InvoiceState_name, int32(x)) } func (Invoice_InvoiceState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{92, 0} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{92, 0} } type GenSeedRequest struct { @@ -201,7 +201,7 @@ func (m *GenSeedRequest) Reset() { *m = GenSeedRequest{} } func (m *GenSeedRequest) String() string { return proto.CompactTextString(m) } func (*GenSeedRequest) ProtoMessage() {} func (*GenSeedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{0} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{0} } func (m *GenSeedRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GenSeedRequest.Unmarshal(m, b) @@ -256,7 +256,7 @@ func (m *GenSeedResponse) Reset() { *m = GenSeedResponse{} } func (m *GenSeedResponse) String() string { return proto.CompactTextString(m) } func (*GenSeedResponse) ProtoMessage() {} func (*GenSeedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{1} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{1} } func (m *GenSeedResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GenSeedResponse.Unmarshal(m, b) @@ -329,7 +329,7 @@ func (m *InitWalletRequest) Reset() { *m = InitWalletRequest{} } func (m *InitWalletRequest) String() string { return proto.CompactTextString(m) } func (*InitWalletRequest) ProtoMessage() {} func (*InitWalletRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{2} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{2} } func (m *InitWalletRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_InitWalletRequest.Unmarshal(m, b) @@ -394,7 +394,7 @@ func (m *InitWalletResponse) Reset() { *m = InitWalletResponse{} } func (m *InitWalletResponse) String() string { return proto.CompactTextString(m) } func (*InitWalletResponse) ProtoMessage() {} func (*InitWalletResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{3} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{3} } func (m *InitWalletResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_InitWalletResponse.Unmarshal(m, b) @@ -444,7 +444,7 @@ func (m *UnlockWalletRequest) Reset() { *m = UnlockWalletRequest{} } func (m *UnlockWalletRequest) String() string { return proto.CompactTextString(m) } func (*UnlockWalletRequest) ProtoMessage() {} func (*UnlockWalletRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{4} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{4} } func (m *UnlockWalletRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_UnlockWalletRequest.Unmarshal(m, b) @@ -495,7 +495,7 @@ func (m *UnlockWalletResponse) Reset() { *m = UnlockWalletResponse{} } func (m *UnlockWalletResponse) String() string { return proto.CompactTextString(m) } func (*UnlockWalletResponse) ProtoMessage() {} func (*UnlockWalletResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{5} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{5} } func (m *UnlockWalletResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_UnlockWalletResponse.Unmarshal(m, b) @@ -533,7 +533,7 @@ func (m *ChangePasswordRequest) Reset() { *m = ChangePasswordRequest{} } func (m *ChangePasswordRequest) String() string { return proto.CompactTextString(m) } func (*ChangePasswordRequest) ProtoMessage() {} func (*ChangePasswordRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{6} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{6} } func (m *ChangePasswordRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChangePasswordRequest.Unmarshal(m, b) @@ -577,7 +577,7 @@ func (m *ChangePasswordResponse) Reset() { *m = ChangePasswordResponse{} func (m *ChangePasswordResponse) String() string { return proto.CompactTextString(m) } func (*ChangePasswordResponse) ProtoMessage() {} func (*ChangePasswordResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{7} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{7} } func (m *ChangePasswordResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChangePasswordResponse.Unmarshal(m, b) @@ -619,7 +619,7 @@ func (m *Utxo) Reset() { *m = Utxo{} } func (m *Utxo) String() string { return proto.CompactTextString(m) } func (*Utxo) ProtoMessage() {} func (*Utxo) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{8} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{8} } func (m *Utxo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Utxo.Unmarshal(m, b) @@ -707,7 +707,7 @@ func (m *Transaction) Reset() { *m = Transaction{} } func (m *Transaction) String() string { return proto.CompactTextString(m) } func (*Transaction) ProtoMessage() {} func (*Transaction) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{9} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{9} } func (m *Transaction) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Transaction.Unmarshal(m, b) @@ -793,7 +793,7 @@ func (m *GetTransactionsRequest) Reset() { *m = GetTransactionsRequest{} func (m *GetTransactionsRequest) String() string { return proto.CompactTextString(m) } func (*GetTransactionsRequest) ProtoMessage() {} func (*GetTransactionsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{10} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{10} } func (m *GetTransactionsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetTransactionsRequest.Unmarshal(m, b) @@ -825,7 +825,7 @@ func (m *TransactionDetails) Reset() { *m = TransactionDetails{} } func (m *TransactionDetails) String() string { return proto.CompactTextString(m) } func (*TransactionDetails) ProtoMessage() {} func (*TransactionDetails) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{11} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{11} } func (m *TransactionDetails) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_TransactionDetails.Unmarshal(m, b) @@ -866,7 +866,7 @@ func (m *FeeLimit) Reset() { *m = FeeLimit{} } func (m *FeeLimit) String() string { return proto.CompactTextString(m) } func (*FeeLimit) ProtoMessage() {} func (*FeeLimit) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{12} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{12} } func (m *FeeLimit) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_FeeLimit.Unmarshal(m, b) @@ -1020,7 +1020,13 @@ type SendRequest struct { // * // An optional maximum total time lock for the route. If zero, there is no // maximum enforced. - CltvLimit uint32 `protobuf:"varint,10,opt,name=cltv_limit,json=cltvLimit,proto3" json:"cltv_limit,omitempty"` + CltvLimit uint32 `protobuf:"varint,10,opt,name=cltv_limit,json=cltvLimit,proto3" json:"cltv_limit,omitempty"` + // + // If set, then no payment hash is required. Instead, we will generate a + // payment hash ourselves, and encode the pre-image in an EOB encrypted to the + // final hop. Not that the payment request MUST NOT be specified in order for + // this flag to be parsed. If set, then the dest MUST be set. + KeySend bool `protobuf:"varint,11,opt,name=key_send,json=keySend,proto3" json:"key_send,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -1030,7 +1036,7 @@ func (m *SendRequest) Reset() { *m = SendRequest{} } func (m *SendRequest) String() string { return proto.CompactTextString(m) } func (*SendRequest) ProtoMessage() {} func (*SendRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{13} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{13} } func (m *SendRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SendRequest.Unmarshal(m, b) @@ -1120,6 +1126,13 @@ func (m *SendRequest) GetCltvLimit() uint32 { return 0 } +func (m *SendRequest) GetKeySend() bool { + if m != nil { + return m.KeySend + } + return false +} + type SendResponse struct { PaymentError string `protobuf:"bytes,1,opt,name=payment_error,proto3" json:"payment_error,omitempty"` PaymentPreimage []byte `protobuf:"bytes,2,opt,name=payment_preimage,proto3" json:"payment_preimage,omitempty"` @@ -1134,7 +1147,7 @@ func (m *SendResponse) Reset() { *m = SendResponse{} } func (m *SendResponse) String() string { return proto.CompactTextString(m) } func (*SendResponse) ProtoMessage() {} func (*SendResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{14} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{14} } func (m *SendResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SendResponse.Unmarshal(m, b) @@ -1198,7 +1211,7 @@ func (m *SendToRouteRequest) Reset() { *m = SendToRouteRequest{} } func (m *SendToRouteRequest) String() string { return proto.CompactTextString(m) } func (*SendToRouteRequest) ProtoMessage() {} func (*SendToRouteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{15} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{15} } func (m *SendToRouteRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SendToRouteRequest.Unmarshal(m, b) @@ -1255,7 +1268,7 @@ func (m *ChannelPoint) Reset() { *m = ChannelPoint{} } func (m *ChannelPoint) String() string { return proto.CompactTextString(m) } func (*ChannelPoint) ProtoMessage() {} func (*ChannelPoint) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{16} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{16} } func (m *ChannelPoint) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelPoint.Unmarshal(m, b) @@ -1401,7 +1414,7 @@ func (m *OutPoint) Reset() { *m = OutPoint{} } func (m *OutPoint) String() string { return proto.CompactTextString(m) } func (*OutPoint) ProtoMessage() {} func (*OutPoint) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{17} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{17} } func (m *OutPoint) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_OutPoint.Unmarshal(m, b) @@ -1456,7 +1469,7 @@ func (m *LightningAddress) Reset() { *m = LightningAddress{} } func (m *LightningAddress) String() string { return proto.CompactTextString(m) } func (*LightningAddress) ProtoMessage() {} func (*LightningAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{18} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{18} } func (m *LightningAddress) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_LightningAddress.Unmarshal(m, b) @@ -1504,7 +1517,7 @@ func (m *EstimateFeeRequest) Reset() { *m = EstimateFeeRequest{} } func (m *EstimateFeeRequest) String() string { return proto.CompactTextString(m) } func (*EstimateFeeRequest) ProtoMessage() {} func (*EstimateFeeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{19} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{19} } func (m *EstimateFeeRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_EstimateFeeRequest.Unmarshal(m, b) @@ -1552,7 +1565,7 @@ func (m *EstimateFeeResponse) Reset() { *m = EstimateFeeResponse{} } func (m *EstimateFeeResponse) String() string { return proto.CompactTextString(m) } func (*EstimateFeeResponse) ProtoMessage() {} func (*EstimateFeeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{20} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{20} } func (m *EstimateFeeResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_EstimateFeeResponse.Unmarshal(m, b) @@ -1602,7 +1615,7 @@ func (m *SendManyRequest) Reset() { *m = SendManyRequest{} } func (m *SendManyRequest) String() string { return proto.CompactTextString(m) } func (*SendManyRequest) ProtoMessage() {} func (*SendManyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{21} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{21} } func (m *SendManyRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SendManyRequest.Unmarshal(m, b) @@ -1655,7 +1668,7 @@ func (m *SendManyResponse) Reset() { *m = SendManyResponse{} } func (m *SendManyResponse) String() string { return proto.CompactTextString(m) } func (*SendManyResponse) ProtoMessage() {} func (*SendManyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{22} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{22} } func (m *SendManyResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SendManyResponse.Unmarshal(m, b) @@ -1705,7 +1718,7 @@ func (m *SendCoinsRequest) Reset() { *m = SendCoinsRequest{} } func (m *SendCoinsRequest) String() string { return proto.CompactTextString(m) } func (*SendCoinsRequest) ProtoMessage() {} func (*SendCoinsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{23} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{23} } func (m *SendCoinsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SendCoinsRequest.Unmarshal(m, b) @@ -1772,7 +1785,7 @@ func (m *SendCoinsResponse) Reset() { *m = SendCoinsResponse{} } func (m *SendCoinsResponse) String() string { return proto.CompactTextString(m) } func (*SendCoinsResponse) ProtoMessage() {} func (*SendCoinsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{24} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{24} } func (m *SendCoinsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SendCoinsResponse.Unmarshal(m, b) @@ -1813,7 +1826,7 @@ func (m *ListUnspentRequest) Reset() { *m = ListUnspentRequest{} } func (m *ListUnspentRequest) String() string { return proto.CompactTextString(m) } func (*ListUnspentRequest) ProtoMessage() {} func (*ListUnspentRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{25} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{25} } func (m *ListUnspentRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListUnspentRequest.Unmarshal(m, b) @@ -1859,7 +1872,7 @@ func (m *ListUnspentResponse) Reset() { *m = ListUnspentResponse{} } func (m *ListUnspentResponse) String() string { return proto.CompactTextString(m) } func (*ListUnspentResponse) ProtoMessage() {} func (*ListUnspentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{26} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{26} } func (m *ListUnspentResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListUnspentResponse.Unmarshal(m, b) @@ -1898,7 +1911,7 @@ func (m *NewAddressRequest) Reset() { *m = NewAddressRequest{} } func (m *NewAddressRequest) String() string { return proto.CompactTextString(m) } func (*NewAddressRequest) ProtoMessage() {} func (*NewAddressRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{27} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{27} } func (m *NewAddressRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NewAddressRequest.Unmarshal(m, b) @@ -1937,7 +1950,7 @@ func (m *NewAddressResponse) Reset() { *m = NewAddressResponse{} } func (m *NewAddressResponse) String() string { return proto.CompactTextString(m) } func (*NewAddressResponse) ProtoMessage() {} func (*NewAddressResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{28} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{28} } func (m *NewAddressResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NewAddressResponse.Unmarshal(m, b) @@ -1976,7 +1989,7 @@ func (m *SignMessageRequest) Reset() { *m = SignMessageRequest{} } func (m *SignMessageRequest) String() string { return proto.CompactTextString(m) } func (*SignMessageRequest) ProtoMessage() {} func (*SignMessageRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{29} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{29} } func (m *SignMessageRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SignMessageRequest.Unmarshal(m, b) @@ -2015,7 +2028,7 @@ func (m *SignMessageResponse) Reset() { *m = SignMessageResponse{} } func (m *SignMessageResponse) String() string { return proto.CompactTextString(m) } func (*SignMessageResponse) ProtoMessage() {} func (*SignMessageResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{30} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{30} } func (m *SignMessageResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_SignMessageResponse.Unmarshal(m, b) @@ -2056,7 +2069,7 @@ func (m *VerifyMessageRequest) Reset() { *m = VerifyMessageRequest{} } func (m *VerifyMessageRequest) String() string { return proto.CompactTextString(m) } func (*VerifyMessageRequest) ProtoMessage() {} func (*VerifyMessageRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{31} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{31} } func (m *VerifyMessageRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_VerifyMessageRequest.Unmarshal(m, b) @@ -2104,7 +2117,7 @@ func (m *VerifyMessageResponse) Reset() { *m = VerifyMessageResponse{} } func (m *VerifyMessageResponse) String() string { return proto.CompactTextString(m) } func (*VerifyMessageResponse) ProtoMessage() {} func (*VerifyMessageResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{32} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{32} } func (m *VerifyMessageResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_VerifyMessageResponse.Unmarshal(m, b) @@ -2153,7 +2166,7 @@ func (m *ConnectPeerRequest) Reset() { *m = ConnectPeerRequest{} } func (m *ConnectPeerRequest) String() string { return proto.CompactTextString(m) } func (*ConnectPeerRequest) ProtoMessage() {} func (*ConnectPeerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{33} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{33} } func (m *ConnectPeerRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConnectPeerRequest.Unmarshal(m, b) @@ -2197,7 +2210,7 @@ func (m *ConnectPeerResponse) Reset() { *m = ConnectPeerResponse{} } func (m *ConnectPeerResponse) String() string { return proto.CompactTextString(m) } func (*ConnectPeerResponse) ProtoMessage() {} func (*ConnectPeerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{34} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{34} } func (m *ConnectPeerResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConnectPeerResponse.Unmarshal(m, b) @@ -2229,7 +2242,7 @@ func (m *DisconnectPeerRequest) Reset() { *m = DisconnectPeerRequest{} } func (m *DisconnectPeerRequest) String() string { return proto.CompactTextString(m) } func (*DisconnectPeerRequest) ProtoMessage() {} func (*DisconnectPeerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{35} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{35} } func (m *DisconnectPeerRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_DisconnectPeerRequest.Unmarshal(m, b) @@ -2266,7 +2279,7 @@ func (m *DisconnectPeerResponse) Reset() { *m = DisconnectPeerResponse{} func (m *DisconnectPeerResponse) String() string { return proto.CompactTextString(m) } func (*DisconnectPeerResponse) ProtoMessage() {} func (*DisconnectPeerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{36} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{36} } func (m *DisconnectPeerResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_DisconnectPeerResponse.Unmarshal(m, b) @@ -2300,7 +2313,7 @@ func (m *HTLC) Reset() { *m = HTLC{} } func (m *HTLC) String() string { return proto.CompactTextString(m) } func (*HTLC) ProtoMessage() {} func (*HTLC) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{37} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{37} } func (m *HTLC) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_HTLC.Unmarshal(m, b) @@ -2415,7 +2428,7 @@ func (m *Channel) Reset() { *m = Channel{} } func (m *Channel) String() string { return proto.CompactTextString(m) } func (*Channel) ProtoMessage() {} func (*Channel) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{38} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{38} } func (m *Channel) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Channel.Unmarshal(m, b) @@ -2582,7 +2595,7 @@ func (m *ListChannelsRequest) Reset() { *m = ListChannelsRequest{} } func (m *ListChannelsRequest) String() string { return proto.CompactTextString(m) } func (*ListChannelsRequest) ProtoMessage() {} func (*ListChannelsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{39} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{39} } func (m *ListChannelsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListChannelsRequest.Unmarshal(m, b) @@ -2642,7 +2655,7 @@ func (m *ListChannelsResponse) Reset() { *m = ListChannelsResponse{} } func (m *ListChannelsResponse) String() string { return proto.CompactTextString(m) } func (*ListChannelsResponse) ProtoMessage() {} func (*ListChannelsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{40} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{40} } func (m *ListChannelsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListChannelsResponse.Unmarshal(m, b) @@ -2699,7 +2712,7 @@ func (m *ChannelCloseSummary) Reset() { *m = ChannelCloseSummary{} } func (m *ChannelCloseSummary) String() string { return proto.CompactTextString(m) } func (*ChannelCloseSummary) ProtoMessage() {} func (*ChannelCloseSummary) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{41} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{41} } func (m *ChannelCloseSummary) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelCloseSummary.Unmarshal(m, b) @@ -2805,7 +2818,7 @@ func (m *ClosedChannelsRequest) Reset() { *m = ClosedChannelsRequest{} } func (m *ClosedChannelsRequest) String() string { return proto.CompactTextString(m) } func (*ClosedChannelsRequest) ProtoMessage() {} func (*ClosedChannelsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{42} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{42} } func (m *ClosedChannelsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ClosedChannelsRequest.Unmarshal(m, b) @@ -2878,7 +2891,7 @@ func (m *ClosedChannelsResponse) Reset() { *m = ClosedChannelsResponse{} func (m *ClosedChannelsResponse) String() string { return proto.CompactTextString(m) } func (*ClosedChannelsResponse) ProtoMessage() {} func (*ClosedChannelsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{43} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{43} } func (m *ClosedChannelsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ClosedChannelsResponse.Unmarshal(m, b) @@ -2933,7 +2946,7 @@ func (m *Peer) Reset() { *m = Peer{} } func (m *Peer) String() string { return proto.CompactTextString(m) } func (*Peer) ProtoMessage() {} func (*Peer) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{44} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{44} } func (m *Peer) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Peer.Unmarshal(m, b) @@ -3026,7 +3039,7 @@ func (m *ListPeersRequest) Reset() { *m = ListPeersRequest{} } func (m *ListPeersRequest) String() string { return proto.CompactTextString(m) } func (*ListPeersRequest) ProtoMessage() {} func (*ListPeersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{45} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{45} } func (m *ListPeersRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListPeersRequest.Unmarshal(m, b) @@ -3058,7 +3071,7 @@ func (m *ListPeersResponse) Reset() { *m = ListPeersResponse{} } func (m *ListPeersResponse) String() string { return proto.CompactTextString(m) } func (*ListPeersResponse) ProtoMessage() {} func (*ListPeersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{46} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{46} } func (m *ListPeersResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListPeersResponse.Unmarshal(m, b) @@ -3095,7 +3108,7 @@ func (m *GetInfoRequest) Reset() { *m = GetInfoRequest{} } func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetInfoRequest) ProtoMessage() {} func (*GetInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{47} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{47} } func (m *GetInfoRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetInfoRequest.Unmarshal(m, b) @@ -3155,7 +3168,7 @@ func (m *GetInfoResponse) Reset() { *m = GetInfoResponse{} } func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetInfoResponse) ProtoMessage() {} func (*GetInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{48} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{48} } func (m *GetInfoResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GetInfoResponse.Unmarshal(m, b) @@ -3288,7 +3301,7 @@ func (m *Chain) Reset() { *m = Chain{} } func (m *Chain) String() string { return proto.CompactTextString(m) } func (*Chain) ProtoMessage() {} func (*Chain) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{49} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{49} } func (m *Chain) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Chain.Unmarshal(m, b) @@ -3335,7 +3348,7 @@ func (m *ConfirmationUpdate) Reset() { *m = ConfirmationUpdate{} } func (m *ConfirmationUpdate) String() string { return proto.CompactTextString(m) } func (*ConfirmationUpdate) ProtoMessage() {} func (*ConfirmationUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{50} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{50} } func (m *ConfirmationUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ConfirmationUpdate.Unmarshal(m, b) @@ -3387,7 +3400,7 @@ func (m *ChannelOpenUpdate) Reset() { *m = ChannelOpenUpdate{} } func (m *ChannelOpenUpdate) String() string { return proto.CompactTextString(m) } func (*ChannelOpenUpdate) ProtoMessage() {} func (*ChannelOpenUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{51} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{51} } func (m *ChannelOpenUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelOpenUpdate.Unmarshal(m, b) @@ -3426,7 +3439,7 @@ func (m *ChannelCloseUpdate) Reset() { *m = ChannelCloseUpdate{} } func (m *ChannelCloseUpdate) String() string { return proto.CompactTextString(m) } func (*ChannelCloseUpdate) ProtoMessage() {} func (*ChannelCloseUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{52} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{52} } func (m *ChannelCloseUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelCloseUpdate.Unmarshal(m, b) @@ -3481,7 +3494,7 @@ func (m *CloseChannelRequest) Reset() { *m = CloseChannelRequest{} } func (m *CloseChannelRequest) String() string { return proto.CompactTextString(m) } func (*CloseChannelRequest) ProtoMessage() {} func (*CloseChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{53} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{53} } func (m *CloseChannelRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CloseChannelRequest.Unmarshal(m, b) @@ -3543,7 +3556,7 @@ func (m *CloseStatusUpdate) Reset() { *m = CloseStatusUpdate{} } func (m *CloseStatusUpdate) String() string { return proto.CompactTextString(m) } func (*CloseStatusUpdate) ProtoMessage() {} func (*CloseStatusUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{54} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{54} } func (m *CloseStatusUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CloseStatusUpdate.Unmarshal(m, b) @@ -3686,7 +3699,7 @@ func (m *PendingUpdate) Reset() { *m = PendingUpdate{} } func (m *PendingUpdate) String() string { return proto.CompactTextString(m) } func (*PendingUpdate) ProtoMessage() {} func (*PendingUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{55} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{55} } func (m *PendingUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingUpdate.Unmarshal(m, b) @@ -3752,7 +3765,7 @@ func (m *OpenChannelRequest) Reset() { *m = OpenChannelRequest{} } func (m *OpenChannelRequest) String() string { return proto.CompactTextString(m) } func (*OpenChannelRequest) ProtoMessage() {} func (*OpenChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{56} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{56} } func (m *OpenChannelRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_OpenChannelRequest.Unmarshal(m, b) @@ -3863,7 +3876,7 @@ func (m *OpenStatusUpdate) Reset() { *m = OpenStatusUpdate{} } func (m *OpenStatusUpdate) String() string { return proto.CompactTextString(m) } func (*OpenStatusUpdate) ProtoMessage() {} func (*OpenStatusUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{57} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{57} } func (m *OpenStatusUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_OpenStatusUpdate.Unmarshal(m, b) @@ -4019,7 +4032,7 @@ func (m *PendingHTLC) Reset() { *m = PendingHTLC{} } func (m *PendingHTLC) String() string { return proto.CompactTextString(m) } func (*PendingHTLC) ProtoMessage() {} func (*PendingHTLC) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{58} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{58} } func (m *PendingHTLC) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingHTLC.Unmarshal(m, b) @@ -4091,7 +4104,7 @@ func (m *PendingChannelsRequest) Reset() { *m = PendingChannelsRequest{} func (m *PendingChannelsRequest) String() string { return proto.CompactTextString(m) } func (*PendingChannelsRequest) ProtoMessage() {} func (*PendingChannelsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{59} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{59} } func (m *PendingChannelsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingChannelsRequest.Unmarshal(m, b) @@ -4131,7 +4144,7 @@ func (m *PendingChannelsResponse) Reset() { *m = PendingChannelsResponse func (m *PendingChannelsResponse) String() string { return proto.CompactTextString(m) } func (*PendingChannelsResponse) ProtoMessage() {} func (*PendingChannelsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{60} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{60} } func (m *PendingChannelsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingChannelsResponse.Unmarshal(m, b) @@ -4203,7 +4216,7 @@ func (m *PendingChannelsResponse_PendingChannel) Reset() { func (m *PendingChannelsResponse_PendingChannel) String() string { return proto.CompactTextString(m) } func (*PendingChannelsResponse_PendingChannel) ProtoMessage() {} func (*PendingChannelsResponse_PendingChannel) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{60, 0} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{60, 0} } func (m *PendingChannelsResponse_PendingChannel) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingChannelsResponse_PendingChannel.Unmarshal(m, b) @@ -4290,7 +4303,7 @@ func (m *PendingChannelsResponse_PendingOpenChannel) String() string { } func (*PendingChannelsResponse_PendingOpenChannel) ProtoMessage() {} func (*PendingChannelsResponse_PendingOpenChannel) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{60, 1} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{60, 1} } func (m *PendingChannelsResponse_PendingOpenChannel) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingChannelsResponse_PendingOpenChannel.Unmarshal(m, b) @@ -4363,7 +4376,7 @@ func (m *PendingChannelsResponse_WaitingCloseChannel) String() string { } func (*PendingChannelsResponse_WaitingCloseChannel) ProtoMessage() {} func (*PendingChannelsResponse_WaitingCloseChannel) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{60, 2} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{60, 2} } func (m *PendingChannelsResponse_WaitingCloseChannel) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingChannelsResponse_WaitingCloseChannel.Unmarshal(m, b) @@ -4411,7 +4424,7 @@ func (m *PendingChannelsResponse_ClosedChannel) Reset() { *m = PendingCh func (m *PendingChannelsResponse_ClosedChannel) String() string { return proto.CompactTextString(m) } func (*PendingChannelsResponse_ClosedChannel) ProtoMessage() {} func (*PendingChannelsResponse_ClosedChannel) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{60, 3} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{60, 3} } func (m *PendingChannelsResponse_ClosedChannel) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingChannelsResponse_ClosedChannel.Unmarshal(m, b) @@ -4475,7 +4488,7 @@ func (m *PendingChannelsResponse_ForceClosedChannel) String() string { } func (*PendingChannelsResponse_ForceClosedChannel) ProtoMessage() {} func (*PendingChannelsResponse_ForceClosedChannel) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{60, 4} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{60, 4} } func (m *PendingChannelsResponse_ForceClosedChannel) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PendingChannelsResponse_ForceClosedChannel.Unmarshal(m, b) @@ -4554,7 +4567,7 @@ func (m *ChannelEventSubscription) Reset() { *m = ChannelEventSubscripti func (m *ChannelEventSubscription) String() string { return proto.CompactTextString(m) } func (*ChannelEventSubscription) ProtoMessage() {} func (*ChannelEventSubscription) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{61} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{61} } func (m *ChannelEventSubscription) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelEventSubscription.Unmarshal(m, b) @@ -4591,7 +4604,7 @@ func (m *ChannelEventUpdate) Reset() { *m = ChannelEventUpdate{} } func (m *ChannelEventUpdate) String() string { return proto.CompactTextString(m) } func (*ChannelEventUpdate) ProtoMessage() {} func (*ChannelEventUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{62} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{62} } func (m *ChannelEventUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelEventUpdate.Unmarshal(m, b) @@ -4803,7 +4816,7 @@ func (m *WalletBalanceRequest) Reset() { *m = WalletBalanceRequest{} } func (m *WalletBalanceRequest) String() string { return proto.CompactTextString(m) } func (*WalletBalanceRequest) ProtoMessage() {} func (*WalletBalanceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{63} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{63} } func (m *WalletBalanceRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_WalletBalanceRequest.Unmarshal(m, b) @@ -4839,7 +4852,7 @@ func (m *WalletBalanceResponse) Reset() { *m = WalletBalanceResponse{} } func (m *WalletBalanceResponse) String() string { return proto.CompactTextString(m) } func (*WalletBalanceResponse) ProtoMessage() {} func (*WalletBalanceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{64} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{64} } func (m *WalletBalanceResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_WalletBalanceResponse.Unmarshal(m, b) @@ -4890,7 +4903,7 @@ func (m *ChannelBalanceRequest) Reset() { *m = ChannelBalanceRequest{} } func (m *ChannelBalanceRequest) String() string { return proto.CompactTextString(m) } func (*ChannelBalanceRequest) ProtoMessage() {} func (*ChannelBalanceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{65} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{65} } func (m *ChannelBalanceRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelBalanceRequest.Unmarshal(m, b) @@ -4924,7 +4937,7 @@ func (m *ChannelBalanceResponse) Reset() { *m = ChannelBalanceResponse{} func (m *ChannelBalanceResponse) String() string { return proto.CompactTextString(m) } func (*ChannelBalanceResponse) ProtoMessage() {} func (*ChannelBalanceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{66} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{66} } func (m *ChannelBalanceResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelBalanceResponse.Unmarshal(m, b) @@ -4990,7 +5003,7 @@ func (m *QueryRoutesRequest) Reset() { *m = QueryRoutesRequest{} } func (m *QueryRoutesRequest) String() string { return proto.CompactTextString(m) } func (*QueryRoutesRequest) ProtoMessage() {} func (*QueryRoutesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{67} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{67} } func (m *QueryRoutesRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_QueryRoutesRequest.Unmarshal(m, b) @@ -5077,7 +5090,7 @@ func (m *EdgeLocator) Reset() { *m = EdgeLocator{} } func (m *EdgeLocator) String() string { return proto.CompactTextString(m) } func (*EdgeLocator) ProtoMessage() {} func (*EdgeLocator) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{68} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{68} } func (m *EdgeLocator) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_EdgeLocator.Unmarshal(m, b) @@ -5122,7 +5135,7 @@ func (m *QueryRoutesResponse) Reset() { *m = QueryRoutesResponse{} } func (m *QueryRoutesResponse) String() string { return proto.CompactTextString(m) } func (*QueryRoutesResponse) ProtoMessage() {} func (*QueryRoutesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{69} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{69} } func (m *QueryRoutesResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_QueryRoutesResponse.Unmarshal(m, b) @@ -5174,7 +5187,7 @@ func (m *Hop) Reset() { *m = Hop{} } func (m *Hop) String() string { return proto.CompactTextString(m) } func (*Hop) ProtoMessage() {} func (*Hop) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{70} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{70} } func (m *Hop) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Hop.Unmarshal(m, b) @@ -5295,7 +5308,7 @@ func (m *Route) Reset() { *m = Route{} } func (m *Route) String() string { return proto.CompactTextString(m) } func (*Route) ProtoMessage() {} func (*Route) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{71} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{71} } func (m *Route) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Route.Unmarshal(m, b) @@ -5371,7 +5384,7 @@ func (m *NodeInfoRequest) Reset() { *m = NodeInfoRequest{} } func (m *NodeInfoRequest) String() string { return proto.CompactTextString(m) } func (*NodeInfoRequest) ProtoMessage() {} func (*NodeInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{72} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{72} } func (m *NodeInfoRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NodeInfoRequest.Unmarshal(m, b) @@ -5416,7 +5429,7 @@ func (m *NodeInfo) Reset() { *m = NodeInfo{} } func (m *NodeInfo) String() string { return proto.CompactTextString(m) } func (*NodeInfo) ProtoMessage() {} func (*NodeInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{73} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{73} } func (m *NodeInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NodeInfo.Unmarshal(m, b) @@ -5477,7 +5490,7 @@ func (m *LightningNode) Reset() { *m = LightningNode{} } func (m *LightningNode) String() string { return proto.CompactTextString(m) } func (*LightningNode) ProtoMessage() {} func (*LightningNode) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{74} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{74} } func (m *LightningNode) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_LightningNode.Unmarshal(m, b) @@ -5544,7 +5557,7 @@ func (m *NodeAddress) Reset() { *m = NodeAddress{} } func (m *NodeAddress) String() string { return proto.CompactTextString(m) } func (*NodeAddress) ProtoMessage() {} func (*NodeAddress) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{75} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{75} } func (m *NodeAddress) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NodeAddress.Unmarshal(m, b) @@ -5594,7 +5607,7 @@ func (m *RoutingPolicy) Reset() { *m = RoutingPolicy{} } func (m *RoutingPolicy) String() string { return proto.CompactTextString(m) } func (*RoutingPolicy) ProtoMessage() {} func (*RoutingPolicy) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{76} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{76} } func (m *RoutingPolicy) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_RoutingPolicy.Unmarshal(m, b) @@ -5684,7 +5697,7 @@ func (m *ChannelEdge) Reset() { *m = ChannelEdge{} } func (m *ChannelEdge) String() string { return proto.CompactTextString(m) } func (*ChannelEdge) ProtoMessage() {} func (*ChannelEdge) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{77} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{77} } func (m *ChannelEdge) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelEdge.Unmarshal(m, b) @@ -5775,7 +5788,7 @@ func (m *ChannelGraphRequest) Reset() { *m = ChannelGraphRequest{} } func (m *ChannelGraphRequest) String() string { return proto.CompactTextString(m) } func (*ChannelGraphRequest) ProtoMessage() {} func (*ChannelGraphRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{78} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{78} } func (m *ChannelGraphRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelGraphRequest.Unmarshal(m, b) @@ -5817,7 +5830,7 @@ func (m *ChannelGraph) Reset() { *m = ChannelGraph{} } func (m *ChannelGraph) String() string { return proto.CompactTextString(m) } func (*ChannelGraph) ProtoMessage() {} func (*ChannelGraph) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{79} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{79} } func (m *ChannelGraph) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelGraph.Unmarshal(m, b) @@ -5866,7 +5879,7 @@ func (m *ChanInfoRequest) Reset() { *m = ChanInfoRequest{} } func (m *ChanInfoRequest) String() string { return proto.CompactTextString(m) } func (*ChanInfoRequest) ProtoMessage() {} func (*ChanInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{80} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{80} } func (m *ChanInfoRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChanInfoRequest.Unmarshal(m, b) @@ -5903,7 +5916,7 @@ func (m *NetworkInfoRequest) Reset() { *m = NetworkInfoRequest{} } func (m *NetworkInfoRequest) String() string { return proto.CompactTextString(m) } func (*NetworkInfoRequest) ProtoMessage() {} func (*NetworkInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{81} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{81} } func (m *NetworkInfoRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NetworkInfoRequest.Unmarshal(m, b) @@ -5943,7 +5956,7 @@ func (m *NetworkInfo) Reset() { *m = NetworkInfo{} } func (m *NetworkInfo) String() string { return proto.CompactTextString(m) } func (*NetworkInfo) ProtoMessage() {} func (*NetworkInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{82} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{82} } func (m *NetworkInfo) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NetworkInfo.Unmarshal(m, b) @@ -6043,7 +6056,7 @@ func (m *StopRequest) Reset() { *m = StopRequest{} } func (m *StopRequest) String() string { return proto.CompactTextString(m) } func (*StopRequest) ProtoMessage() {} func (*StopRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{83} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{83} } func (m *StopRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StopRequest.Unmarshal(m, b) @@ -6073,7 +6086,7 @@ func (m *StopResponse) Reset() { *m = StopResponse{} } func (m *StopResponse) String() string { return proto.CompactTextString(m) } func (*StopResponse) ProtoMessage() {} func (*StopResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{84} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{84} } func (m *StopResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_StopResponse.Unmarshal(m, b) @@ -6103,7 +6116,7 @@ func (m *GraphTopologySubscription) Reset() { *m = GraphTopologySubscrip func (m *GraphTopologySubscription) String() string { return proto.CompactTextString(m) } func (*GraphTopologySubscription) ProtoMessage() {} func (*GraphTopologySubscription) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{85} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{85} } func (m *GraphTopologySubscription) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GraphTopologySubscription.Unmarshal(m, b) @@ -6136,7 +6149,7 @@ func (m *GraphTopologyUpdate) Reset() { *m = GraphTopologyUpdate{} } func (m *GraphTopologyUpdate) String() string { return proto.CompactTextString(m) } func (*GraphTopologyUpdate) ProtoMessage() {} func (*GraphTopologyUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{86} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{86} } func (m *GraphTopologyUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_GraphTopologyUpdate.Unmarshal(m, b) @@ -6191,7 +6204,7 @@ func (m *NodeUpdate) Reset() { *m = NodeUpdate{} } func (m *NodeUpdate) String() string { return proto.CompactTextString(m) } func (*NodeUpdate) ProtoMessage() {} func (*NodeUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{87} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{87} } func (m *NodeUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_NodeUpdate.Unmarshal(m, b) @@ -6259,7 +6272,7 @@ func (m *ChannelEdgeUpdate) Reset() { *m = ChannelEdgeUpdate{} } func (m *ChannelEdgeUpdate) String() string { return proto.CompactTextString(m) } func (*ChannelEdgeUpdate) ProtoMessage() {} func (*ChannelEdgeUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{88} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{88} } func (m *ChannelEdgeUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelEdgeUpdate.Unmarshal(m, b) @@ -6339,7 +6352,7 @@ func (m *ClosedChannelUpdate) Reset() { *m = ClosedChannelUpdate{} } func (m *ClosedChannelUpdate) String() string { return proto.CompactTextString(m) } func (*ClosedChannelUpdate) ProtoMessage() {} func (*ClosedChannelUpdate) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{89} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{89} } func (m *ClosedChannelUpdate) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ClosedChannelUpdate.Unmarshal(m, b) @@ -6409,7 +6422,7 @@ func (m *HopHint) Reset() { *m = HopHint{} } func (m *HopHint) String() string { return proto.CompactTextString(m) } func (*HopHint) ProtoMessage() {} func (*HopHint) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{90} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{90} } func (m *HopHint) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_HopHint.Unmarshal(m, b) @@ -6478,7 +6491,7 @@ func (m *RouteHint) Reset() { *m = RouteHint{} } func (m *RouteHint) String() string { return proto.CompactTextString(m) } func (*RouteHint) ProtoMessage() {} func (*RouteHint) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{91} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{91} } func (m *RouteHint) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_RouteHint.Unmarshal(m, b) @@ -6593,7 +6606,7 @@ func (m *Invoice) Reset() { *m = Invoice{} } func (m *Invoice) String() string { return proto.CompactTextString(m) } func (*Invoice) ProtoMessage() {} func (*Invoice) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{92} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{92} } func (m *Invoice) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Invoice.Unmarshal(m, b) @@ -6785,7 +6798,7 @@ func (m *AddInvoiceResponse) Reset() { *m = AddInvoiceResponse{} } func (m *AddInvoiceResponse) String() string { return proto.CompactTextString(m) } func (*AddInvoiceResponse) ProtoMessage() {} func (*AddInvoiceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{93} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{93} } func (m *AddInvoiceResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_AddInvoiceResponse.Unmarshal(m, b) @@ -6842,7 +6855,7 @@ func (m *PaymentHash) Reset() { *m = PaymentHash{} } func (m *PaymentHash) String() string { return proto.CompactTextString(m) } func (*PaymentHash) ProtoMessage() {} func (*PaymentHash) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{94} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{94} } func (m *PaymentHash) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PaymentHash.Unmarshal(m, b) @@ -6898,7 +6911,7 @@ func (m *ListInvoiceRequest) Reset() { *m = ListInvoiceRequest{} } func (m *ListInvoiceRequest) String() string { return proto.CompactTextString(m) } func (*ListInvoiceRequest) ProtoMessage() {} func (*ListInvoiceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{95} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{95} } func (m *ListInvoiceRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListInvoiceRequest.Unmarshal(m, b) @@ -6968,7 +6981,7 @@ func (m *ListInvoiceResponse) Reset() { *m = ListInvoiceResponse{} } func (m *ListInvoiceResponse) String() string { return proto.CompactTextString(m) } func (*ListInvoiceResponse) ProtoMessage() {} func (*ListInvoiceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{96} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{96} } func (m *ListInvoiceResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListInvoiceResponse.Unmarshal(m, b) @@ -7031,7 +7044,7 @@ func (m *InvoiceSubscription) Reset() { *m = InvoiceSubscription{} } func (m *InvoiceSubscription) String() string { return proto.CompactTextString(m) } func (*InvoiceSubscription) ProtoMessage() {} func (*InvoiceSubscription) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{97} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{97} } func (m *InvoiceSubscription) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_InvoiceSubscription.Unmarshal(m, b) @@ -7091,7 +7104,7 @@ func (m *Payment) Reset() { *m = Payment{} } func (m *Payment) String() string { return proto.CompactTextString(m) } func (*Payment) ProtoMessage() {} func (*Payment) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{98} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{98} } func (m *Payment) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Payment.Unmarshal(m, b) @@ -7178,7 +7191,7 @@ func (m *ListPaymentsRequest) Reset() { *m = ListPaymentsRequest{} } func (m *ListPaymentsRequest) String() string { return proto.CompactTextString(m) } func (*ListPaymentsRequest) ProtoMessage() {} func (*ListPaymentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{99} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{99} } func (m *ListPaymentsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListPaymentsRequest.Unmarshal(m, b) @@ -7210,7 +7223,7 @@ func (m *ListPaymentsResponse) Reset() { *m = ListPaymentsResponse{} } func (m *ListPaymentsResponse) String() string { return proto.CompactTextString(m) } func (*ListPaymentsResponse) ProtoMessage() {} func (*ListPaymentsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{100} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{100} } func (m *ListPaymentsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ListPaymentsResponse.Unmarshal(m, b) @@ -7247,7 +7260,7 @@ func (m *DeleteAllPaymentsRequest) Reset() { *m = DeleteAllPaymentsReque func (m *DeleteAllPaymentsRequest) String() string { return proto.CompactTextString(m) } func (*DeleteAllPaymentsRequest) ProtoMessage() {} func (*DeleteAllPaymentsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{101} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{101} } func (m *DeleteAllPaymentsRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_DeleteAllPaymentsRequest.Unmarshal(m, b) @@ -7277,7 +7290,7 @@ func (m *DeleteAllPaymentsResponse) Reset() { *m = DeleteAllPaymentsResp func (m *DeleteAllPaymentsResponse) String() string { return proto.CompactTextString(m) } func (*DeleteAllPaymentsResponse) ProtoMessage() {} func (*DeleteAllPaymentsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{102} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{102} } func (m *DeleteAllPaymentsResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_DeleteAllPaymentsResponse.Unmarshal(m, b) @@ -7308,7 +7321,7 @@ func (m *AbandonChannelRequest) Reset() { *m = AbandonChannelRequest{} } func (m *AbandonChannelRequest) String() string { return proto.CompactTextString(m) } func (*AbandonChannelRequest) ProtoMessage() {} func (*AbandonChannelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{103} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{103} } func (m *AbandonChannelRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_AbandonChannelRequest.Unmarshal(m, b) @@ -7345,7 +7358,7 @@ func (m *AbandonChannelResponse) Reset() { *m = AbandonChannelResponse{} func (m *AbandonChannelResponse) String() string { return proto.CompactTextString(m) } func (*AbandonChannelResponse) ProtoMessage() {} func (*AbandonChannelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{104} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{104} } func (m *AbandonChannelResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_AbandonChannelResponse.Unmarshal(m, b) @@ -7377,7 +7390,7 @@ func (m *DebugLevelRequest) Reset() { *m = DebugLevelRequest{} } func (m *DebugLevelRequest) String() string { return proto.CompactTextString(m) } func (*DebugLevelRequest) ProtoMessage() {} func (*DebugLevelRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{105} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{105} } func (m *DebugLevelRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_DebugLevelRequest.Unmarshal(m, b) @@ -7422,7 +7435,7 @@ func (m *DebugLevelResponse) Reset() { *m = DebugLevelResponse{} } func (m *DebugLevelResponse) String() string { return proto.CompactTextString(m) } func (*DebugLevelResponse) ProtoMessage() {} func (*DebugLevelResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{106} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{106} } func (m *DebugLevelResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_DebugLevelResponse.Unmarshal(m, b) @@ -7461,7 +7474,7 @@ func (m *PayReqString) Reset() { *m = PayReqString{} } func (m *PayReqString) String() string { return proto.CompactTextString(m) } func (*PayReqString) ProtoMessage() {} func (*PayReqString) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{107} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{107} } func (m *PayReqString) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PayReqString.Unmarshal(m, b) @@ -7508,7 +7521,7 @@ func (m *PayReq) Reset() { *m = PayReq{} } func (m *PayReq) String() string { return proto.CompactTextString(m) } func (*PayReq) ProtoMessage() {} func (*PayReq) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{108} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{108} } func (m *PayReq) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PayReq.Unmarshal(m, b) @@ -7608,7 +7621,7 @@ func (m *FeeReportRequest) Reset() { *m = FeeReportRequest{} } func (m *FeeReportRequest) String() string { return proto.CompactTextString(m) } func (*FeeReportRequest) ProtoMessage() {} func (*FeeReportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{109} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{109} } func (m *FeeReportRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_FeeReportRequest.Unmarshal(m, b) @@ -7646,7 +7659,7 @@ func (m *ChannelFeeReport) Reset() { *m = ChannelFeeReport{} } func (m *ChannelFeeReport) String() string { return proto.CompactTextString(m) } func (*ChannelFeeReport) ProtoMessage() {} func (*ChannelFeeReport) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{110} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{110} } func (m *ChannelFeeReport) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelFeeReport.Unmarshal(m, b) @@ -7712,7 +7725,7 @@ func (m *FeeReportResponse) Reset() { *m = FeeReportResponse{} } func (m *FeeReportResponse) String() string { return proto.CompactTextString(m) } func (*FeeReportResponse) ProtoMessage() {} func (*FeeReportResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{111} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{111} } func (m *FeeReportResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_FeeReportResponse.Unmarshal(m, b) @@ -7780,7 +7793,7 @@ func (m *PolicyUpdateRequest) Reset() { *m = PolicyUpdateRequest{} } func (m *PolicyUpdateRequest) String() string { return proto.CompactTextString(m) } func (*PolicyUpdateRequest) ProtoMessage() {} func (*PolicyUpdateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{112} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{112} } func (m *PolicyUpdateRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PolicyUpdateRequest.Unmarshal(m, b) @@ -7941,7 +7954,7 @@ func (m *PolicyUpdateResponse) Reset() { *m = PolicyUpdateResponse{} } func (m *PolicyUpdateResponse) String() string { return proto.CompactTextString(m) } func (*PolicyUpdateResponse) ProtoMessage() {} func (*PolicyUpdateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{113} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{113} } func (m *PolicyUpdateResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_PolicyUpdateResponse.Unmarshal(m, b) @@ -7979,7 +7992,7 @@ func (m *ForwardingHistoryRequest) Reset() { *m = ForwardingHistoryReque func (m *ForwardingHistoryRequest) String() string { return proto.CompactTextString(m) } func (*ForwardingHistoryRequest) ProtoMessage() {} func (*ForwardingHistoryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{114} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{114} } func (m *ForwardingHistoryRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ForwardingHistoryRequest.Unmarshal(m, b) @@ -8051,7 +8064,7 @@ func (m *ForwardingEvent) Reset() { *m = ForwardingEvent{} } func (m *ForwardingEvent) String() string { return proto.CompactTextString(m) } func (*ForwardingEvent) ProtoMessage() {} func (*ForwardingEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{115} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{115} } func (m *ForwardingEvent) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ForwardingEvent.Unmarshal(m, b) @@ -8134,7 +8147,7 @@ func (m *ForwardingHistoryResponse) Reset() { *m = ForwardingHistoryResp func (m *ForwardingHistoryResponse) String() string { return proto.CompactTextString(m) } func (*ForwardingHistoryResponse) ProtoMessage() {} func (*ForwardingHistoryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{116} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{116} } func (m *ForwardingHistoryResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ForwardingHistoryResponse.Unmarshal(m, b) @@ -8180,7 +8193,7 @@ func (m *ExportChannelBackupRequest) Reset() { *m = ExportChannelBackupR func (m *ExportChannelBackupRequest) String() string { return proto.CompactTextString(m) } func (*ExportChannelBackupRequest) ProtoMessage() {} func (*ExportChannelBackupRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{117} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{117} } func (m *ExportChannelBackupRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ExportChannelBackupRequest.Unmarshal(m, b) @@ -8225,7 +8238,7 @@ func (m *ChannelBackup) Reset() { *m = ChannelBackup{} } func (m *ChannelBackup) String() string { return proto.CompactTextString(m) } func (*ChannelBackup) ProtoMessage() {} func (*ChannelBackup) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{118} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{118} } func (m *ChannelBackup) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelBackup.Unmarshal(m, b) @@ -8277,7 +8290,7 @@ func (m *MultiChanBackup) Reset() { *m = MultiChanBackup{} } func (m *MultiChanBackup) String() string { return proto.CompactTextString(m) } func (*MultiChanBackup) ProtoMessage() {} func (*MultiChanBackup) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{119} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{119} } func (m *MultiChanBackup) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_MultiChanBackup.Unmarshal(m, b) @@ -8321,7 +8334,7 @@ func (m *ChanBackupExportRequest) Reset() { *m = ChanBackupExportRequest func (m *ChanBackupExportRequest) String() string { return proto.CompactTextString(m) } func (*ChanBackupExportRequest) ProtoMessage() {} func (*ChanBackupExportRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{120} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{120} } func (m *ChanBackupExportRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChanBackupExportRequest.Unmarshal(m, b) @@ -8359,7 +8372,7 @@ func (m *ChanBackupSnapshot) Reset() { *m = ChanBackupSnapshot{} } func (m *ChanBackupSnapshot) String() string { return proto.CompactTextString(m) } func (*ChanBackupSnapshot) ProtoMessage() {} func (*ChanBackupSnapshot) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{121} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{121} } func (m *ChanBackupSnapshot) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChanBackupSnapshot.Unmarshal(m, b) @@ -8406,7 +8419,7 @@ func (m *ChannelBackups) Reset() { *m = ChannelBackups{} } func (m *ChannelBackups) String() string { return proto.CompactTextString(m) } func (*ChannelBackups) ProtoMessage() {} func (*ChannelBackups) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{122} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{122} } func (m *ChannelBackups) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelBackups.Unmarshal(m, b) @@ -8447,7 +8460,7 @@ func (m *RestoreChanBackupRequest) Reset() { *m = RestoreChanBackupReque func (m *RestoreChanBackupRequest) String() string { return proto.CompactTextString(m) } func (*RestoreChanBackupRequest) ProtoMessage() {} func (*RestoreChanBackupRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{123} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{123} } func (m *RestoreChanBackupRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_RestoreChanBackupRequest.Unmarshal(m, b) @@ -8584,7 +8597,7 @@ func (m *RestoreBackupResponse) Reset() { *m = RestoreBackupResponse{} } func (m *RestoreBackupResponse) String() string { return proto.CompactTextString(m) } func (*RestoreBackupResponse) ProtoMessage() {} func (*RestoreBackupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{124} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{124} } func (m *RestoreBackupResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_RestoreBackupResponse.Unmarshal(m, b) @@ -8614,7 +8627,7 @@ func (m *ChannelBackupSubscription) Reset() { *m = ChannelBackupSubscrip func (m *ChannelBackupSubscription) String() string { return proto.CompactTextString(m) } func (*ChannelBackupSubscription) ProtoMessage() {} func (*ChannelBackupSubscription) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{125} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{125} } func (m *ChannelBackupSubscription) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ChannelBackupSubscription.Unmarshal(m, b) @@ -8644,7 +8657,7 @@ func (m *VerifyChanBackupResponse) Reset() { *m = VerifyChanBackupRespon func (m *VerifyChanBackupResponse) String() string { return proto.CompactTextString(m) } func (*VerifyChanBackupResponse) ProtoMessage() {} func (*VerifyChanBackupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_rpc_ea34ec0435bf8f95, []int{126} + return fileDescriptor_rpc_aae6a4dae77df6ef, []int{126} } func (m *VerifyChanBackupResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_VerifyChanBackupResponse.Unmarshal(m, b) @@ -11436,491 +11449,492 @@ var _Lightning_serviceDesc = grpc.ServiceDesc{ Metadata: "rpc.proto", } -func init() { proto.RegisterFile("rpc.proto", fileDescriptor_rpc_ea34ec0435bf8f95) } - -var fileDescriptor_rpc_ea34ec0435bf8f95 = []byte{ - // 7715 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7c, 0x5d, 0x6c, 0x24, 0xd9, - 0x59, 0xa8, 0xab, 0x7f, 0xec, 0xee, 0xaf, 0xdb, 0x76, 0xfb, 0xf8, 0xaf, 0xa7, 0x67, 0x76, 0xd6, - 0x5b, 0x99, 0xcc, 0x38, 0xde, 0xbd, 0xe3, 0xd9, 0x49, 0xb2, 0x99, 0xec, 0xdc, 0xdc, 0x5c, 0xff, - 0xcd, 0x78, 0x76, 0xbd, 0x1e, 0xa7, 0x3c, 0x93, 0xb9, 0xbb, 0xc9, 0x55, 0xa7, 0xdc, 0x7d, 0xdc, - 0xae, 0x9d, 0xee, 0xaa, 0xde, 0xaa, 0x6a, 0x7b, 0x9c, 0xbd, 0x73, 0x85, 0x10, 0x02, 0x84, 0x40, - 0x28, 0x20, 0x10, 0x41, 0x20, 0x44, 0x82, 0x04, 0x11, 0x4f, 0x3c, 0x80, 0x90, 0x20, 0xcf, 0x48, - 0x91, 0x10, 0x42, 0x79, 0x44, 0x02, 0x21, 0x78, 0x41, 0x3c, 0x20, 0x90, 0x78, 0x44, 0x42, 0xe7, - 0x3b, 0x3f, 0x75, 0x4e, 0x55, 0xf5, 0x78, 0x36, 0x09, 0x3c, 0x75, 0x9f, 0xef, 0x7c, 0x75, 0x7e, - 0xbf, 0xff, 0xf3, 0x9d, 0x03, 0xd5, 0x70, 0xd8, 0xb9, 0x39, 0x0c, 0x83, 0x38, 0x20, 0xe5, 0xbe, - 0x1f, 0x0e, 0x3b, 0xad, 0x2b, 0xbd, 0x20, 0xe8, 0xf5, 0xe9, 0xba, 0x3b, 0xf4, 0xd6, 0x5d, 0xdf, - 0x0f, 0x62, 0x37, 0xf6, 0x02, 0x3f, 0xe2, 0x48, 0xf6, 0x37, 0x60, 0xe6, 0x3e, 0xf5, 0x0f, 0x29, - 0xed, 0x3a, 0xf4, 0xa3, 0x11, 0x8d, 0x62, 0xf2, 0x3a, 0xcc, 0xb9, 0xf4, 0x9b, 0x94, 0x76, 0xdb, - 0x43, 0x37, 0x8a, 0x86, 0x27, 0xa1, 0x1b, 0xd1, 0xa6, 0xb5, 0x62, 0xad, 0xd6, 0x9d, 0x06, 0xaf, - 0x38, 0x50, 0x70, 0xf2, 0x1a, 0xd4, 0x23, 0x86, 0x4a, 0xfd, 0x38, 0x0c, 0x86, 0xe7, 0xcd, 0x02, - 0xe2, 0xd5, 0x18, 0x6c, 0x87, 0x83, 0xec, 0x3e, 0xcc, 0xaa, 0x1e, 0xa2, 0x61, 0xe0, 0x47, 0x94, - 0xdc, 0x82, 0x85, 0x8e, 0x37, 0x3c, 0xa1, 0x61, 0x1b, 0x3f, 0x1e, 0xf8, 0x74, 0x10, 0xf8, 0x5e, - 0xa7, 0x69, 0xad, 0x14, 0x57, 0xab, 0x0e, 0xe1, 0x75, 0xec, 0x8b, 0xf7, 0x44, 0x0d, 0xb9, 0x01, - 0xb3, 0xd4, 0xe7, 0x70, 0xda, 0xc5, 0xaf, 0x44, 0x57, 0x33, 0x09, 0x98, 0x7d, 0x60, 0xff, 0x7c, - 0x01, 0xe6, 0x1e, 0xf8, 0x5e, 0xfc, 0xc4, 0xed, 0xf7, 0x69, 0x2c, 0xe7, 0x74, 0x03, 0x66, 0xcf, - 0x10, 0x80, 0x73, 0x3a, 0x0b, 0xc2, 0xae, 0x98, 0xd1, 0x0c, 0x07, 0x1f, 0x08, 0xe8, 0xd8, 0x91, - 0x15, 0xc6, 0x8e, 0x2c, 0x77, 0xb9, 0x8a, 0x63, 0x96, 0xeb, 0x06, 0xcc, 0x86, 0xb4, 0x13, 0x9c, - 0xd2, 0xf0, 0xbc, 0x7d, 0xe6, 0xf9, 0xdd, 0xe0, 0xac, 0x59, 0x5a, 0xb1, 0x56, 0xcb, 0xce, 0x8c, - 0x04, 0x3f, 0x41, 0x28, 0xd9, 0x84, 0xd9, 0xce, 0x89, 0xeb, 0xfb, 0xb4, 0xdf, 0x3e, 0x72, 0x3b, - 0x4f, 0x47, 0xc3, 0xa8, 0x59, 0x5e, 0xb1, 0x56, 0x6b, 0xb7, 0x2f, 0xdd, 0xc4, 0x5d, 0xbd, 0xb9, - 0x75, 0xe2, 0xfa, 0x9b, 0x58, 0x73, 0xe8, 0xbb, 0xc3, 0xe8, 0x24, 0x88, 0x9d, 0x19, 0xf1, 0x05, - 0x07, 0x47, 0xf6, 0x02, 0x10, 0x7d, 0x25, 0xf8, 0xda, 0xdb, 0x7f, 0x68, 0xc1, 0xfc, 0x63, 0xbf, - 0x1f, 0x74, 0x9e, 0xfe, 0x88, 0x4b, 0x94, 0x33, 0x87, 0xc2, 0xcb, 0xce, 0xa1, 0xf8, 0x49, 0xe7, - 0xb0, 0x04, 0x0b, 0xe6, 0x60, 0xc5, 0x2c, 0x28, 0x2c, 0xb2, 0xaf, 0x7b, 0x54, 0x0e, 0x4b, 0x4e, - 0xe3, 0x33, 0xd0, 0xe8, 0x8c, 0xc2, 0x90, 0xfa, 0x99, 0x79, 0xcc, 0x0a, 0xb8, 0x9a, 0xc8, 0x6b, - 0x50, 0xf7, 0xe9, 0x59, 0x82, 0x26, 0x68, 0xd7, 0xa7, 0x67, 0x12, 0xc5, 0x6e, 0xc2, 0x52, 0xba, - 0x1b, 0x31, 0x80, 0xbf, 0xb7, 0xa0, 0xf4, 0x38, 0x7e, 0x16, 0x90, 0x9b, 0x50, 0x8a, 0xcf, 0x87, - 0x9c, 0x43, 0x66, 0x6e, 0x13, 0x31, 0xb5, 0x8d, 0x6e, 0x37, 0xa4, 0x51, 0xf4, 0xe8, 0x7c, 0x48, - 0x9d, 0xba, 0xcb, 0x0b, 0x6d, 0x86, 0x47, 0x9a, 0x30, 0x25, 0xca, 0xd8, 0x61, 0xd5, 0x91, 0x45, - 0x72, 0x15, 0xc0, 0x1d, 0x04, 0x23, 0x3f, 0x6e, 0x47, 0x6e, 0x8c, 0x4b, 0x55, 0x74, 0x34, 0x08, - 0xb9, 0x02, 0xd5, 0xe1, 0xd3, 0x76, 0xd4, 0x09, 0xbd, 0x61, 0x8c, 0x64, 0x53, 0x75, 0x12, 0x00, - 0x79, 0x1d, 0x2a, 0xc1, 0x28, 0x1e, 0x06, 0x9e, 0x1f, 0x0b, 0x52, 0x99, 0x15, 0x63, 0x79, 0x38, - 0x8a, 0x0f, 0x18, 0xd8, 0x51, 0x08, 0xe4, 0x1a, 0x4c, 0x77, 0x02, 0xff, 0xd8, 0x0b, 0x07, 0x5c, - 0x18, 0x34, 0x27, 0xb1, 0x37, 0x13, 0x68, 0x7f, 0xbb, 0x00, 0xb5, 0x47, 0xa1, 0xeb, 0x47, 0x6e, - 0x87, 0x01, 0xd8, 0xd0, 0xe3, 0x67, 0xed, 0x13, 0x37, 0x3a, 0xc1, 0xd9, 0x56, 0x1d, 0x59, 0x24, - 0x4b, 0x30, 0xc9, 0x07, 0x8a, 0x73, 0x2a, 0x3a, 0xa2, 0x44, 0xde, 0x80, 0x39, 0x7f, 0x34, 0x68, - 0x9b, 0x7d, 0x15, 0x91, 0x5a, 0xb2, 0x15, 0x6c, 0x01, 0x8e, 0xd8, 0x5e, 0xf3, 0x2e, 0xf8, 0x0c, - 0x35, 0x08, 0xb1, 0xa1, 0x2e, 0x4a, 0xd4, 0xeb, 0x9d, 0xf0, 0x69, 0x96, 0x1d, 0x03, 0xc6, 0xda, - 0x88, 0xbd, 0x01, 0x6d, 0x47, 0xb1, 0x3b, 0x18, 0x8a, 0x69, 0x69, 0x10, 0xac, 0x0f, 0x62, 0xb7, - 0xdf, 0x3e, 0xa6, 0x34, 0x6a, 0x4e, 0x89, 0x7a, 0x05, 0x21, 0xd7, 0x61, 0xa6, 0x4b, 0xa3, 0xb8, - 0x2d, 0x36, 0x85, 0x46, 0xcd, 0x0a, 0xb2, 0x7e, 0x0a, 0xca, 0x28, 0xe3, 0x3e, 0x8d, 0xb5, 0xd5, - 0x89, 0x04, 0x05, 0xda, 0x7b, 0x40, 0x34, 0xf0, 0x36, 0x8d, 0x5d, 0xaf, 0x1f, 0x91, 0xb7, 0xa0, - 0x1e, 0x6b, 0xc8, 0x28, 0xea, 0x6a, 0x8a, 0x5c, 0xb4, 0x0f, 0x1c, 0x03, 0xcf, 0xbe, 0x0f, 0x95, - 0x7b, 0x94, 0xee, 0x79, 0x03, 0x2f, 0x26, 0x4b, 0x50, 0x3e, 0xf6, 0x9e, 0x51, 0x4e, 0xd0, 0xc5, - 0xdd, 0x09, 0x87, 0x17, 0x49, 0x0b, 0xa6, 0x86, 0x34, 0xec, 0x50, 0xb9, 0xfc, 0xbb, 0x13, 0x8e, - 0x04, 0x6c, 0x4e, 0x41, 0xb9, 0xcf, 0x3e, 0xb6, 0xff, 0xb5, 0x00, 0xb5, 0x43, 0xea, 0x2b, 0x46, - 0x21, 0x50, 0x62, 0x53, 0x12, 0xcc, 0x81, 0xff, 0xc9, 0xab, 0x50, 0xc3, 0x69, 0x46, 0x71, 0xe8, - 0xf9, 0x3d, 0x41, 0x9f, 0xc0, 0x40, 0x87, 0x08, 0x21, 0x0d, 0x28, 0xba, 0x03, 0x49, 0x9b, 0xec, - 0x2f, 0x63, 0xa2, 0xa1, 0x7b, 0x3e, 0x60, 0xfc, 0xa6, 0x76, 0xad, 0xee, 0xd4, 0x04, 0x6c, 0x97, - 0x6d, 0xdb, 0x4d, 0x98, 0xd7, 0x51, 0x64, 0xeb, 0x65, 0x6c, 0x7d, 0x4e, 0xc3, 0x14, 0x9d, 0xdc, - 0x80, 0x59, 0x89, 0x1f, 0xf2, 0xc1, 0xe2, 0x3e, 0x56, 0x9d, 0x19, 0x01, 0x96, 0x53, 0x58, 0x85, - 0xc6, 0xb1, 0xe7, 0xbb, 0xfd, 0x76, 0xa7, 0x1f, 0x9f, 0xb6, 0xbb, 0xb4, 0x1f, 0xbb, 0xb8, 0xa3, - 0x65, 0x67, 0x06, 0xe1, 0x5b, 0xfd, 0xf8, 0x74, 0x9b, 0x41, 0xc9, 0x1b, 0x50, 0x3d, 0xa6, 0xb4, - 0x8d, 0x2b, 0xd1, 0xac, 0x18, 0xdc, 0x21, 0x57, 0xd7, 0xa9, 0x1c, 0xcb, 0x75, 0x5e, 0x85, 0x46, - 0x30, 0x8a, 0x7b, 0x81, 0xe7, 0xf7, 0xda, 0x4c, 0x1e, 0xb5, 0xbd, 0x6e, 0xb3, 0xba, 0x62, 0xad, - 0x96, 0x9c, 0x19, 0x09, 0x67, 0x52, 0xe1, 0x41, 0x97, 0xbc, 0x02, 0x80, 0x7d, 0xf3, 0x86, 0x61, - 0xc5, 0x5a, 0x9d, 0x76, 0xaa, 0x0c, 0x82, 0x0d, 0xd9, 0x7f, 0x6a, 0x41, 0x9d, 0xaf, 0xb9, 0x50, - 0x7c, 0xd7, 0x60, 0x5a, 0x4e, 0x8d, 0x86, 0x61, 0x10, 0x0a, 0x3e, 0x32, 0x81, 0x64, 0x0d, 0x1a, - 0x12, 0x30, 0x0c, 0xa9, 0x37, 0x70, 0x7b, 0x54, 0x08, 0xa7, 0x0c, 0x9c, 0xdc, 0x4e, 0x5a, 0x0c, - 0x83, 0x51, 0x4c, 0x85, 0x88, 0xad, 0x8b, 0xd9, 0x39, 0x0c, 0xe6, 0x98, 0x28, 0x8c, 0x8f, 0x72, - 0xf6, 0xcc, 0x80, 0xd9, 0xdf, 0xb2, 0x80, 0xb0, 0xa1, 0x3f, 0x0a, 0x78, 0x13, 0x62, 0xc9, 0xd3, - 0xdb, 0x6d, 0xbd, 0xf4, 0x76, 0x17, 0xc6, 0x6d, 0xb7, 0x0d, 0x65, 0x3e, 0xf2, 0x52, 0xce, 0xc8, - 0x79, 0xd5, 0x3b, 0xa5, 0x4a, 0xb1, 0x51, 0xb2, 0xbf, 0x63, 0x41, 0x7d, 0x8b, 0xeb, 0x07, 0x14, - 0x68, 0xe4, 0x16, 0x90, 0xe3, 0x91, 0xdf, 0x65, 0xfb, 0x14, 0x3f, 0xf3, 0xba, 0xed, 0xa3, 0xf3, - 0x98, 0x46, 0x7c, 0x4c, 0xbb, 0x13, 0x4e, 0x4e, 0x1d, 0x79, 0x03, 0x1a, 0x06, 0x34, 0x8a, 0x43, - 0x3e, 0xb2, 0xdd, 0x09, 0x27, 0x53, 0xc3, 0x16, 0x8a, 0x89, 0xcc, 0x51, 0xdc, 0xf6, 0xfc, 0x2e, - 0x7d, 0x86, 0x6b, 0x3b, 0xed, 0x18, 0xb0, 0xcd, 0x19, 0xa8, 0xeb, 0xdf, 0xd9, 0x1f, 0x42, 0x45, - 0x0a, 0x5c, 0x14, 0x36, 0xa9, 0x71, 0x39, 0x1a, 0x84, 0xb4, 0xa0, 0x62, 0x8e, 0xc2, 0xa9, 0x7c, - 0x92, 0xbe, 0xed, 0xff, 0x05, 0x8d, 0x3d, 0x26, 0xf5, 0x7c, 0xcf, 0xef, 0x09, 0x8d, 0xc3, 0x44, - 0xf1, 0x70, 0x74, 0xf4, 0x94, 0x9e, 0x0b, 0xda, 0x12, 0x25, 0xc6, 0xef, 0x27, 0x41, 0x14, 0x8b, - 0x7e, 0xf0, 0xbf, 0xfd, 0x17, 0x16, 0x90, 0x9d, 0x28, 0xf6, 0x06, 0x6e, 0x4c, 0xef, 0x51, 0xb5, - 0xc9, 0x0f, 0xa1, 0xce, 0x5a, 0x7b, 0x14, 0x6c, 0x70, 0x99, 0xce, 0x65, 0xd5, 0xeb, 0x62, 0x63, - 0xb2, 0x1f, 0xdc, 0xd4, 0xb1, 0x99, 0xd9, 0x77, 0xee, 0x18, 0x0d, 0x30, 0xb9, 0x12, 0xbb, 0x61, - 0x8f, 0xc6, 0x28, 0xf0, 0x85, 0xb9, 0x00, 0x1c, 0xb4, 0x15, 0xf8, 0xc7, 0xad, 0x2f, 0xc3, 0x5c, - 0xa6, 0x0d, 0x26, 0x6c, 0x92, 0x69, 0xb0, 0xbf, 0x64, 0x01, 0xca, 0xa7, 0x6e, 0x7f, 0x44, 0x85, - 0x96, 0xe1, 0x85, 0xb7, 0x0b, 0x77, 0x2c, 0xbb, 0x03, 0xf3, 0xc6, 0xb8, 0x04, 0xbf, 0x35, 0x61, - 0x8a, 0xf1, 0x3d, 0xd3, 0xa7, 0x28, 0x33, 0x1d, 0x59, 0x24, 0xb7, 0x61, 0xe1, 0x98, 0xd2, 0xd0, - 0x8d, 0xb1, 0xd8, 0x1e, 0xd2, 0x10, 0xf7, 0x44, 0xb4, 0x9c, 0x5b, 0x67, 0xff, 0x83, 0x05, 0xb3, - 0x8c, 0x27, 0xde, 0x73, 0xfd, 0x73, 0xb9, 0x56, 0x7b, 0xb9, 0x6b, 0xb5, 0x2a, 0xd6, 0x2a, 0x85, - 0xfd, 0x49, 0x17, 0xaa, 0x98, 0x5e, 0x28, 0xb2, 0x02, 0x75, 0x63, 0xb8, 0x65, 0xae, 0xc0, 0x22, - 0x37, 0x3e, 0xa0, 0xe1, 0xe6, 0x79, 0x4c, 0x7f, 0xfc, 0xa5, 0xbc, 0x0e, 0x8d, 0x64, 0xd8, 0x62, - 0x1d, 0x09, 0x94, 0x18, 0x61, 0x8a, 0x06, 0xf0, 0xbf, 0xfd, 0x5b, 0x16, 0x47, 0xdc, 0x0a, 0x3c, - 0xa5, 0xfc, 0x18, 0x22, 0xd3, 0x91, 0x12, 0x91, 0xfd, 0x1f, 0x6b, 0x1c, 0xfc, 0xf8, 0x93, 0x25, - 0x97, 0xa0, 0x12, 0x51, 0xbf, 0xdb, 0x76, 0xfb, 0x7d, 0xd4, 0x11, 0x15, 0x67, 0x8a, 0x95, 0x37, - 0xfa, 0x7d, 0xfb, 0x06, 0xcc, 0x69, 0xa3, 0x7b, 0xc1, 0x3c, 0xf6, 0x81, 0xec, 0x79, 0x51, 0xfc, - 0xd8, 0x8f, 0x86, 0x9a, 0x6e, 0xb9, 0x0c, 0xd5, 0x81, 0xe7, 0xe3, 0xc8, 0x38, 0xe7, 0x96, 0x9d, - 0xca, 0xc0, 0xf3, 0xd9, 0xb8, 0x22, 0xac, 0x74, 0x9f, 0x89, 0xca, 0x82, 0xa8, 0x74, 0x9f, 0x61, - 0xa5, 0x7d, 0x07, 0xe6, 0x8d, 0xf6, 0x44, 0xd7, 0xaf, 0x41, 0x79, 0x14, 0x3f, 0x0b, 0xa4, 0xe6, - 0xaf, 0x09, 0x0a, 0x61, 0x36, 0xa4, 0xc3, 0x6b, 0xec, 0xbb, 0x30, 0xb7, 0x4f, 0xcf, 0x04, 0x23, - 0xcb, 0x81, 0x5c, 0xbf, 0xd0, 0xbe, 0xc4, 0x7a, 0xfb, 0x26, 0x10, 0xfd, 0xe3, 0x84, 0x01, 0xa4, - 0xb5, 0x69, 0x19, 0xd6, 0xa6, 0x7d, 0x1d, 0xc8, 0xa1, 0xd7, 0xf3, 0xdf, 0xa3, 0x51, 0xe4, 0xf6, - 0x14, 0xeb, 0x37, 0xa0, 0x38, 0x88, 0x7a, 0x42, 0x54, 0xb1, 0xbf, 0xf6, 0x67, 0x61, 0xde, 0xc0, - 0x13, 0x0d, 0x5f, 0x81, 0x6a, 0xe4, 0xf5, 0x7c, 0x37, 0x1e, 0x85, 0x54, 0x34, 0x9d, 0x00, 0xec, - 0x7b, 0xb0, 0xf0, 0x55, 0x1a, 0x7a, 0xc7, 0xe7, 0x17, 0x35, 0x6f, 0xb6, 0x53, 0x48, 0xb7, 0xb3, - 0x03, 0x8b, 0xa9, 0x76, 0x44, 0xf7, 0x9c, 0x7c, 0xc5, 0x4e, 0x56, 0x1c, 0x5e, 0xd0, 0x64, 0x5f, - 0x41, 0x97, 0x7d, 0xf6, 0x63, 0x20, 0x5b, 0x81, 0xef, 0xd3, 0x4e, 0x7c, 0x40, 0x69, 0x98, 0x38, - 0xba, 0x09, 0xad, 0xd6, 0x6e, 0x2f, 0x8b, 0x95, 0x4d, 0x0b, 0x54, 0x41, 0xc4, 0x04, 0x4a, 0x43, - 0x1a, 0x0e, 0xb0, 0xe1, 0x8a, 0x83, 0xff, 0xed, 0x45, 0x98, 0x37, 0x9a, 0x15, 0xae, 0xc1, 0x9b, - 0xb0, 0xb8, 0xed, 0x45, 0x9d, 0x6c, 0x87, 0x4d, 0x98, 0x1a, 0x8e, 0x8e, 0xda, 0x09, 0x27, 0xca, - 0x22, 0xb3, 0x26, 0xd3, 0x9f, 0x88, 0xc6, 0x7e, 0xd6, 0x82, 0xd2, 0xee, 0xa3, 0xbd, 0x2d, 0xa6, - 0x2b, 0x3c, 0xbf, 0x13, 0x0c, 0x98, 0x2e, 0xe5, 0x93, 0x56, 0xe5, 0xb1, 0x1c, 0x76, 0x05, 0xaa, - 0xa8, 0x82, 0x99, 0x81, 0x2c, 0x7c, 0xd2, 0x04, 0xc0, 0x8c, 0x73, 0xfa, 0x6c, 0xe8, 0x85, 0x68, - 0x7d, 0x4b, 0x9b, 0xba, 0x84, 0x6a, 0x26, 0x5b, 0x61, 0xff, 0xa0, 0x0c, 0x53, 0x42, 0xf9, 0x62, - 0x7f, 0x9d, 0xd8, 0x3b, 0xa5, 0x62, 0x24, 0xa2, 0xc4, 0xcc, 0x9b, 0x90, 0x0e, 0x82, 0x98, 0xb6, - 0x8d, 0x6d, 0x30, 0x81, 0xe8, 0x7c, 0x08, 0xbf, 0x90, 0xbb, 0x2b, 0x45, 0x8e, 0x65, 0x00, 0xd9, - 0x62, 0x49, 0xdb, 0xab, 0x84, 0xb6, 0x97, 0x2c, 0xb2, 0x95, 0xe8, 0xb8, 0x43, 0xb7, 0xe3, 0xc5, - 0xe7, 0x42, 0x24, 0xa8, 0x32, 0x6b, 0xbb, 0x1f, 0x74, 0x5c, 0xe6, 0x71, 0xf6, 0x5d, 0xbf, 0x43, - 0xa5, 0x63, 0x63, 0x00, 0x99, 0x91, 0x2f, 0x86, 0x24, 0xd1, 0xb8, 0x23, 0x90, 0x82, 0x32, 0xfd, - 0xdd, 0x09, 0x06, 0x03, 0x2f, 0x66, 0xbe, 0x01, 0xda, 0x8d, 0x45, 0x47, 0x83, 0x70, 0x37, 0x0a, - 0x4b, 0x67, 0x7c, 0xf5, 0xaa, 0xd2, 0x8d, 0xd2, 0x80, 0xac, 0x15, 0xa6, 0x75, 0x98, 0x18, 0x7b, - 0x7a, 0x86, 0x46, 0x62, 0xd1, 0xd1, 0x20, 0x6c, 0x1f, 0x46, 0x7e, 0x44, 0xe3, 0xb8, 0x4f, 0xbb, - 0x6a, 0x40, 0x35, 0x44, 0xcb, 0x56, 0x90, 0x5b, 0x30, 0xcf, 0xdd, 0x95, 0xc8, 0x8d, 0x83, 0xe8, - 0xc4, 0x8b, 0xda, 0x11, 0x33, 0xfc, 0xeb, 0x88, 0x9f, 0x57, 0x45, 0xee, 0xc0, 0x72, 0x0a, 0x1c, - 0xd2, 0x0e, 0xf5, 0x4e, 0x69, 0xb7, 0x39, 0x8d, 0x5f, 0x8d, 0xab, 0x26, 0x2b, 0x50, 0x63, 0x5e, - 0xda, 0x68, 0xd8, 0x75, 0x99, 0x01, 0x33, 0x83, 0xfb, 0xa0, 0x83, 0xc8, 0x9b, 0x30, 0x3d, 0xa4, - 0xdc, 0xfa, 0x39, 0x89, 0xfb, 0x9d, 0xa8, 0x39, 0x6b, 0x48, 0x37, 0x46, 0xb9, 0x8e, 0x89, 0xc1, - 0x88, 0xb2, 0x13, 0xa1, 0xb9, 0xee, 0x9e, 0x37, 0x1b, 0xc2, 0x64, 0x96, 0x00, 0xe4, 0x91, 0xd0, - 0x3b, 0x75, 0x63, 0xda, 0x9c, 0xe3, 0x02, 0x5d, 0x14, 0xd9, 0x77, 0x9e, 0xef, 0xc5, 0x9e, 0x1b, - 0x07, 0x61, 0x93, 0x60, 0x5d, 0x02, 0x60, 0x8b, 0x88, 0xf4, 0x11, 0xc5, 0x6e, 0x3c, 0x8a, 0xda, - 0xc7, 0x7d, 0xb7, 0x17, 0x35, 0xe7, 0xb9, 0xcd, 0x99, 0xa9, 0xb0, 0x7f, 0xc7, 0xe2, 0x42, 0x5a, - 0x10, 0xb4, 0x12, 0xb6, 0xaf, 0x42, 0x8d, 0x93, 0x72, 0x3b, 0xf0, 0xfb, 0xe7, 0x82, 0xba, 0x81, - 0x83, 0x1e, 0xfa, 0xfd, 0x73, 0xf2, 0x29, 0x98, 0xf6, 0x7c, 0x1d, 0x85, 0xcb, 0x83, 0xba, 0x04, - 0x22, 0xd2, 0xab, 0x50, 0x1b, 0x8e, 0x8e, 0xfa, 0x5e, 0x87, 0xa3, 0x14, 0x79, 0x2b, 0x1c, 0x84, - 0x08, 0xcc, 0x8a, 0xe6, 0xb3, 0xe2, 0x18, 0x25, 0xc4, 0xa8, 0x09, 0x18, 0x43, 0xb1, 0x37, 0x61, - 0xc1, 0x1c, 0xa0, 0x10, 0x7c, 0x6b, 0x50, 0x11, 0x7c, 0x12, 0x35, 0x6b, 0xb8, 0xd6, 0x33, 0x5a, - 0x34, 0xc5, 0xa7, 0x7d, 0x47, 0xd5, 0xdb, 0x7f, 0x52, 0x82, 0x79, 0x01, 0xdd, 0xea, 0x07, 0x11, - 0x3d, 0x1c, 0x0d, 0x06, 0x6e, 0x98, 0xc3, 0x80, 0xd6, 0x05, 0x0c, 0x58, 0x30, 0x19, 0x90, 0xb1, - 0xc5, 0x89, 0xeb, 0xf9, 0xdc, 0x05, 0xe0, 0xdc, 0xab, 0x41, 0xc8, 0x2a, 0xcc, 0x76, 0xfa, 0x41, - 0xc4, 0x4d, 0x62, 0xdd, 0x99, 0x4f, 0x83, 0xb3, 0x02, 0xa3, 0x9c, 0x27, 0x30, 0x74, 0x86, 0x9f, - 0x4c, 0x31, 0xbc, 0x0d, 0x75, 0xd6, 0x28, 0x95, 0xf2, 0x6b, 0x8a, 0x9b, 0xc9, 0x3a, 0x8c, 0x8d, - 0x27, 0xcd, 0x5e, 0x9c, 0x97, 0x67, 0xf3, 0x98, 0xcb, 0x1b, 0x50, 0x94, 0x8f, 0x1a, 0x76, 0x55, - 0x30, 0x57, 0xb6, 0x8a, 0xdc, 0x63, 0x1e, 0x20, 0xeb, 0x0b, 0x95, 0x34, 0xa0, 0x92, 0xbe, 0x6e, - 0xee, 0x88, 0xbe, 0xf6, 0x37, 0x59, 0x61, 0x14, 0x52, 0x54, 0xdc, 0xda, 0x97, 0xf6, 0x2f, 0x58, - 0x50, 0xd3, 0xea, 0xc8, 0x22, 0xcc, 0x6d, 0x3d, 0x7c, 0x78, 0xb0, 0xe3, 0x6c, 0x3c, 0x7a, 0xf0, - 0xd5, 0x9d, 0xf6, 0xd6, 0xde, 0xc3, 0xc3, 0x9d, 0xc6, 0x04, 0x03, 0xef, 0x3d, 0xdc, 0xda, 0xd8, - 0x6b, 0xdf, 0x7b, 0xe8, 0x6c, 0x49, 0xb0, 0x45, 0x96, 0x80, 0x38, 0x3b, 0xef, 0x3d, 0x7c, 0xb4, - 0x63, 0xc0, 0x0b, 0xa4, 0x01, 0xf5, 0x4d, 0x67, 0x67, 0x63, 0x6b, 0x57, 0x40, 0x8a, 0x64, 0x01, - 0x1a, 0xf7, 0x1e, 0xef, 0x6f, 0x3f, 0xd8, 0xbf, 0xdf, 0xde, 0xda, 0xd8, 0xdf, 0xda, 0xd9, 0xdb, - 0xd9, 0x6e, 0x94, 0xc8, 0x34, 0x54, 0x37, 0x36, 0x37, 0xf6, 0xb7, 0x1f, 0xee, 0xef, 0x6c, 0x37, - 0xca, 0xf6, 0xdf, 0x5a, 0xb0, 0x88, 0xa3, 0xee, 0xa6, 0x19, 0x64, 0x05, 0x6a, 0x9d, 0x20, 0x18, - 0x32, 0xe3, 0x38, 0x11, 0xff, 0x3a, 0x88, 0x11, 0x3f, 0x17, 0xb6, 0xc7, 0x41, 0xd8, 0xa1, 0x82, - 0x3f, 0x00, 0x41, 0xf7, 0x18, 0x84, 0x11, 0xbf, 0xd8, 0x5e, 0x8e, 0xc1, 0xd9, 0xa3, 0xc6, 0x61, - 0x1c, 0x65, 0x09, 0x26, 0x8f, 0x42, 0xea, 0x76, 0x4e, 0x04, 0x67, 0x88, 0x12, 0xf9, 0x4c, 0xe2, - 0xbd, 0x75, 0xd8, 0xea, 0xf7, 0x69, 0x17, 0x29, 0xa6, 0xe2, 0xcc, 0x0a, 0xf8, 0x96, 0x00, 0x33, - 0x69, 0xe1, 0x1e, 0xb9, 0x7e, 0x37, 0xf0, 0x69, 0x57, 0x98, 0x86, 0x09, 0xc0, 0x3e, 0x80, 0xa5, - 0xf4, 0xfc, 0x04, 0x7f, 0xbd, 0xa5, 0xf1, 0x17, 0xb7, 0xd4, 0x5a, 0xe3, 0x77, 0x53, 0xe3, 0xb5, - 0xbf, 0x2b, 0x40, 0x89, 0x29, 0xee, 0xf1, 0x4a, 0x5e, 0xb7, 0xc5, 0x8a, 0x99, 0xc8, 0x1f, 0x3a, - 0x84, 0x5c, 0x94, 0x73, 0x75, 0xa7, 0x41, 0x92, 0xfa, 0x90, 0x76, 0x4e, 0x71, 0xc6, 0xaa, 0x9e, - 0x41, 0x18, 0x83, 0x30, 0x43, 0x19, 0xbf, 0x16, 0x0c, 0x22, 0xcb, 0xb2, 0x0e, 0xbf, 0x9c, 0x4a, - 0xea, 0xf0, 0xbb, 0x26, 0x4c, 0x79, 0xfe, 0x51, 0x30, 0xf2, 0xbb, 0xc8, 0x10, 0x15, 0x47, 0x16, - 0x31, 0xd6, 0x88, 0x8c, 0xea, 0x0d, 0x24, 0xf9, 0x27, 0x00, 0x72, 0x1b, 0xaa, 0xd1, 0xb9, 0xdf, - 0xd1, 0x69, 0x7e, 0x41, 0xac, 0x12, 0x5b, 0x83, 0x9b, 0x87, 0xe7, 0x7e, 0x07, 0x29, 0x3c, 0x41, - 0xb3, 0xbf, 0x0c, 0x15, 0x09, 0x66, 0x64, 0xf9, 0x78, 0xff, 0xdd, 0xfd, 0x87, 0x4f, 0xf6, 0xdb, - 0x87, 0xef, 0xef, 0x6f, 0x35, 0x26, 0xc8, 0x2c, 0xd4, 0x36, 0xb6, 0x90, 0xd2, 0x11, 0x60, 0x31, - 0x94, 0x83, 0x8d, 0xc3, 0x43, 0x05, 0x29, 0xd8, 0x84, 0x39, 0xbb, 0x11, 0x5a, 0x47, 0x2a, 0xd6, - 0xf6, 0x16, 0xcc, 0x69, 0xb0, 0xc4, 0xd2, 0x1e, 0x32, 0x40, 0xca, 0xd2, 0x46, 0xb3, 0x8a, 0xd7, - 0xd8, 0x0d, 0x98, 0xb9, 0x4f, 0xe3, 0x07, 0xfe, 0x71, 0x20, 0x5b, 0xfa, 0xfd, 0x12, 0xcc, 0x2a, - 0x90, 0x68, 0x68, 0x15, 0x66, 0xbd, 0x2e, 0xf5, 0x63, 0x2f, 0x3e, 0x6f, 0x1b, 0x3e, 0x75, 0x1a, - 0xcc, 0xcc, 0x51, 0xb7, 0xef, 0xb9, 0x32, 0xa4, 0xcb, 0x0b, 0xcc, 0xc7, 0x64, 0xba, 0x52, 0xaa, - 0x3f, 0x45, 0x57, 0xdc, 0x95, 0xcf, 0xad, 0x63, 0x12, 0x88, 0xc1, 0x85, 0x8a, 0x51, 0x9f, 0x70, - 0xb3, 0x2c, 0xaf, 0x8a, 0x6d, 0x15, 0x6f, 0x89, 0x4d, 0xb9, 0xcc, 0xf5, 0xa9, 0x02, 0x64, 0x62, - 0xa6, 0x93, 0x5c, 0x3e, 0xa6, 0x63, 0xa6, 0x5a, 0xdc, 0xb5, 0x92, 0x89, 0xbb, 0x32, 0xf9, 0x79, - 0xee, 0x77, 0x68, 0xb7, 0x1d, 0x07, 0x6d, 0x94, 0xf3, 0x48, 0x12, 0x15, 0x27, 0x0d, 0x26, 0x57, - 0x60, 0x2a, 0xa6, 0x51, 0xec, 0x53, 0x1e, 0x0c, 0xab, 0x6c, 0x16, 0x9a, 0x96, 0x23, 0x41, 0xcc, - 0x86, 0x1e, 0x85, 0x5e, 0xd4, 0xac, 0x63, 0x44, 0x15, 0xff, 0x93, 0xcf, 0xc1, 0xe2, 0x11, 0x8d, - 0xe2, 0xf6, 0x09, 0x75, 0xbb, 0x34, 0x44, 0xf2, 0xe2, 0xa1, 0x5b, 0x6e, 0x9a, 0xe4, 0x57, 0x32, - 0xc2, 0x3d, 0xa5, 0x61, 0xe4, 0x05, 0x3e, 0x1a, 0x25, 0x55, 0x47, 0x16, 0x59, 0x7b, 0x6c, 0xf2, - 0x4a, 0x49, 0xab, 0x15, 0x9c, 0xc5, 0x89, 0xe7, 0x57, 0x92, 0x6b, 0x30, 0x89, 0x13, 0x88, 0x9a, - 0x0d, 0xa4, 0x99, 0x7a, 0xc2, 0xf3, 0x9e, 0xef, 0x88, 0xba, 0x77, 0x4a, 0x95, 0x5a, 0xa3, 0x6e, - 0x7f, 0x01, 0xca, 0x08, 0x66, 0x9b, 0xce, 0x17, 0x83, 0x13, 0x05, 0x2f, 0xb0, 0xa1, 0xf9, 0x34, - 0x3e, 0x0b, 0xc2, 0xa7, 0x32, 0xbe, 0x2f, 0x8a, 0xf6, 0x37, 0xd1, 0x0b, 0x51, 0xf1, 0xee, 0xc7, - 0x68, 0x42, 0x31, 0x5f, 0x92, 0x2f, 0x75, 0x74, 0xe2, 0x0a, 0xc7, 0xa8, 0x82, 0x80, 0xc3, 0x13, - 0x97, 0xc9, 0x4a, 0x63, 0xf7, 0xb8, 0xaf, 0x59, 0x43, 0xd8, 0x2e, 0xdf, 0xbc, 0x6b, 0x30, 0x23, - 0x23, 0xe9, 0x51, 0xbb, 0x4f, 0x8f, 0x63, 0x19, 0x29, 0xf2, 0x47, 0x03, 0x74, 0x48, 0xf7, 0xe8, - 0x71, 0x6c, 0xef, 0xc3, 0x9c, 0x90, 0x5f, 0x0f, 0x87, 0x54, 0x76, 0xfd, 0xc5, 0x3c, 0x3b, 0xa0, - 0x76, 0x7b, 0xde, 0x14, 0x78, 0xfc, 0xec, 0xc0, 0xc4, 0xb4, 0x1d, 0x20, 0xba, 0x3c, 0x14, 0x0d, - 0x0a, 0x65, 0x2c, 0x63, 0x61, 0x62, 0x3a, 0x06, 0x8c, 0xad, 0x4f, 0x34, 0xea, 0x74, 0xe4, 0xf9, - 0x07, 0xf3, 0xd8, 0x79, 0xd1, 0xfe, 0x03, 0x0b, 0xe6, 0xb1, 0x35, 0x69, 0xc9, 0x08, 0x9d, 0x73, - 0xe7, 0x13, 0x0c, 0xb3, 0xde, 0xd1, 0xe3, 0x83, 0x0b, 0x50, 0xd6, 0xb5, 0x10, 0x2f, 0x7c, 0xf2, - 0xb8, 0x43, 0x29, 0x1d, 0x77, 0xb0, 0x7f, 0xc3, 0x82, 0x39, 0xae, 0x08, 0xd0, 0xaa, 0x14, 0xd3, - 0xff, 0x9f, 0x30, 0xcd, 0x35, 0xba, 0xe0, 0x6a, 0x31, 0xd0, 0x44, 0x34, 0x22, 0x94, 0x23, 0xef, - 0x4e, 0x38, 0x26, 0x32, 0xb9, 0x8b, 0x56, 0x95, 0xdf, 0x46, 0x68, 0xce, 0x49, 0x99, 0xb9, 0xd6, - 0xbb, 0x13, 0x8e, 0x86, 0xbe, 0x59, 0x81, 0x49, 0x6e, 0x92, 0xdb, 0xf7, 0x61, 0xda, 0xe8, 0xc8, - 0x88, 0x79, 0xd4, 0x79, 0xcc, 0x23, 0x13, 0x5c, 0x2c, 0xe4, 0x04, 0x17, 0xff, 0xa8, 0x08, 0x84, - 0x11, 0x4b, 0x6a, 0x37, 0x98, 0x4f, 0x10, 0x74, 0x0d, 0x0f, 0xaf, 0xee, 0xe8, 0x20, 0x72, 0x13, - 0x88, 0x56, 0x94, 0xf1, 0x5f, 0xae, 0xf2, 0x72, 0x6a, 0x98, 0x98, 0x14, 0x16, 0x83, 0xd0, 0xed, - 0xc2, 0x97, 0xe5, 0xcb, 0x9e, 0x5b, 0xc7, 0xb4, 0xda, 0x70, 0x14, 0x9d, 0x60, 0x64, 0x4f, 0xf8, - 0x80, 0xb2, 0x9c, 0xde, 0xdf, 0xc9, 0x0b, 0xf7, 0x77, 0x2a, 0x13, 0x57, 0xd2, 0xbc, 0x90, 0x8a, - 0xe9, 0x85, 0x5c, 0x83, 0xe9, 0x01, 0xb3, 0x73, 0xe3, 0x7e, 0xa7, 0x3d, 0x60, 0xbd, 0x0b, 0x97, - 0xcf, 0x00, 0x92, 0x35, 0x68, 0x08, 0x1b, 0x27, 0x71, 0x75, 0xf8, 0xe9, 0x40, 0x06, 0xce, 0xe4, - 0x77, 0x12, 0x69, 0xaa, 0xe1, 0x60, 0x13, 0x00, 0xf3, 0x6b, 0x22, 0x46, 0x21, 0xed, 0x91, 0x2f, - 0x0e, 0xcb, 0x68, 0x17, 0x9d, 0xbd, 0x8a, 0x93, 0xad, 0xb0, 0x7f, 0xc5, 0x82, 0x06, 0xdb, 0x33, - 0x83, 0x2c, 0xdf, 0x06, 0xe4, 0x8a, 0x97, 0xa4, 0x4a, 0x03, 0x97, 0xdc, 0x81, 0x2a, 0x96, 0x83, - 0x21, 0xf5, 0x05, 0x4d, 0x36, 0x4d, 0x9a, 0x4c, 0xe4, 0xc9, 0xee, 0x84, 0x93, 0x20, 0x6b, 0x14, - 0xf9, 0x57, 0x16, 0xd4, 0x44, 0x2f, 0x3f, 0x72, 0x24, 0xa3, 0xa5, 0x9d, 0x6e, 0x72, 0x4a, 0x4a, - 0x0e, 0x33, 0x57, 0x61, 0x76, 0xe0, 0xc6, 0xa3, 0x90, 0xe9, 0x63, 0x23, 0x8a, 0x91, 0x06, 0x33, - 0xe5, 0x8a, 0xa2, 0x33, 0x6a, 0xc7, 0x5e, 0xbf, 0x2d, 0x6b, 0xc5, 0x39, 0x62, 0x5e, 0x15, 0x93, - 0x20, 0x51, 0xec, 0xf6, 0xa8, 0xd0, 0x9b, 0xbc, 0x60, 0x37, 0x61, 0x49, 0x4c, 0x28, 0x65, 0x1f, - 0xdb, 0xdf, 0xaf, 0xc3, 0x72, 0xa6, 0x4a, 0x65, 0x3d, 0x08, 0xf7, 0xbc, 0xef, 0x0d, 0x8e, 0x02, - 0xe5, 0x5c, 0x58, 0xba, 0xe7, 0x6e, 0x54, 0x91, 0x1e, 0x2c, 0x4a, 0x03, 0x81, 0xad, 0x69, 0xa2, - 0xcc, 0x0a, 0xa8, 0xa5, 0xde, 0x34, 0xb7, 0x30, 0xdd, 0xa1, 0x84, 0xeb, 0x4c, 0x9c, 0xdf, 0x1e, - 0x39, 0x81, 0xa6, 0xb2, 0x44, 0x84, 0xb0, 0xd6, 0xac, 0x15, 0xd6, 0xd7, 0x1b, 0x17, 0xf4, 0x65, - 0x98, 0xd3, 0xce, 0xd8, 0xd6, 0xc8, 0x39, 0x5c, 0x95, 0x75, 0x28, 0x8d, 0xb3, 0xfd, 0x95, 0x5e, - 0x6a, 0x6e, 0xe8, 0x28, 0x98, 0x9d, 0x5e, 0xd0, 0x30, 0xf9, 0x10, 0x96, 0xce, 0x5c, 0x2f, 0x96, - 0xc3, 0xd2, 0x6c, 0x83, 0x32, 0x76, 0x79, 0xfb, 0x82, 0x2e, 0x9f, 0xf0, 0x8f, 0x0d, 0x15, 0x35, - 0xa6, 0xc5, 0xd6, 0x0f, 0x2c, 0x98, 0x31, 0xdb, 0x61, 0x64, 0x2a, 0x78, 0x5f, 0xca, 0x40, 0x69, - 0x4d, 0xa6, 0xc0, 0x59, 0xff, 0xbc, 0x90, 0xe7, 0x9f, 0xeb, 0x5e, 0x71, 0xf1, 0xa2, 0x30, 0x58, - 0xe9, 0xe5, 0xc2, 0x60, 0xe5, 0xbc, 0x30, 0x58, 0xeb, 0xdf, 0x2d, 0x20, 0x59, 0x5a, 0x22, 0xf7, - 0x79, 0x80, 0xc0, 0xa7, 0x7d, 0x21, 0x52, 0xfe, 0xc7, 0xcb, 0xd1, 0xa3, 0x5c, 0x3b, 0xf9, 0x35, - 0x63, 0x0c, 0x3d, 0x11, 0x40, 0x37, 0x76, 0xa6, 0x9d, 0xbc, 0xaa, 0x54, 0x60, 0xae, 0x74, 0x71, - 0x60, 0xae, 0x7c, 0x71, 0x60, 0x6e, 0x32, 0x1d, 0x98, 0x6b, 0xfd, 0x8c, 0x05, 0xf3, 0x39, 0x9b, - 0xfe, 0x93, 0x9b, 0x38, 0xdb, 0x26, 0x43, 0x16, 0x14, 0xc4, 0x36, 0xe9, 0xc0, 0xd6, 0xff, 0x83, - 0x69, 0x83, 0xd0, 0x7f, 0x72, 0xfd, 0xa7, 0xed, 0x35, 0x4e, 0x67, 0x06, 0xac, 0xf5, 0xcf, 0x05, - 0x20, 0x59, 0x66, 0xfb, 0x6f, 0x1d, 0x43, 0x76, 0x9d, 0x8a, 0x39, 0xeb, 0xf4, 0x5f, 0xaa, 0x07, - 0xde, 0x80, 0x39, 0x91, 0xdd, 0xa4, 0x85, 0x85, 0x38, 0xc5, 0x64, 0x2b, 0x98, 0xc5, 0x6a, 0x46, - 0x45, 0x2b, 0x46, 0xb6, 0x87, 0xa6, 0x0c, 0x53, 0xc1, 0x51, 0xbb, 0x05, 0x4d, 0xb1, 0x42, 0x3b, - 0xa7, 0xd4, 0x8f, 0x0f, 0x47, 0x47, 0x3c, 0xbd, 0xc7, 0x0b, 0x7c, 0xfb, 0x8f, 0x8b, 0xca, 0xe8, - 0xc6, 0x4a, 0xa1, 0xde, 0x3f, 0x07, 0x75, 0x5d, 0x98, 0x8b, 0xed, 0x48, 0x45, 0x05, 0x99, 0x62, - 0xd7, 0xb1, 0xc8, 0x36, 0xcc, 0xa0, 0xc8, 0xea, 0xaa, 0xef, 0x0a, 0xf8, 0xdd, 0x0b, 0xa2, 0x1d, - 0xbb, 0x13, 0x4e, 0xea, 0x1b, 0xf2, 0x25, 0x98, 0x31, 0x5d, 0x29, 0x61, 0x23, 0xe4, 0xd9, 0xe6, - 0xec, 0x73, 0x13, 0x99, 0x6c, 0x40, 0x23, 0xed, 0x8b, 0x89, 0x2c, 0x80, 0x31, 0x0d, 0x64, 0xd0, - 0xc9, 0x1d, 0x71, 0x3c, 0x56, 0xc6, 0x28, 0xc4, 0x35, 0xf3, 0x33, 0x6d, 0x99, 0x6e, 0xf2, 0x1f, - 0xed, 0xc0, 0xec, 0xeb, 0x00, 0x09, 0x8c, 0x34, 0xa0, 0xfe, 0xf0, 0x60, 0x67, 0xbf, 0xbd, 0xb5, - 0xbb, 0xb1, 0xbf, 0xbf, 0xb3, 0xd7, 0x98, 0x20, 0x04, 0x66, 0x30, 0x68, 0xb6, 0xad, 0x60, 0x16, - 0x83, 0x89, 0x30, 0x85, 0x84, 0x15, 0xc8, 0x02, 0x34, 0x1e, 0xec, 0xa7, 0xa0, 0xc5, 0xcd, 0xaa, - 0xe2, 0x0f, 0x7b, 0x09, 0x16, 0x78, 0xf6, 0xda, 0x26, 0x27, 0x0f, 0x69, 0x2b, 0xfc, 0xb6, 0x05, - 0x8b, 0xa9, 0x8a, 0x24, 0x4d, 0x84, 0x9b, 0x03, 0xa6, 0x8d, 0x60, 0x02, 0x31, 0xe4, 0x2d, 0x2d, - 0xbf, 0x94, 0x04, 0xc9, 0x56, 0x30, 0x9a, 0xd7, 0x2c, 0xc5, 0x14, 0x27, 0xe5, 0x55, 0xd9, 0xcb, - 0x3c, 0xc7, 0x0e, 0xb3, 0xf1, 0x8c, 0x81, 0x1f, 0xf3, 0xac, 0x38, 0xbd, 0x22, 0x39, 0x6e, 0x34, - 0x87, 0x2c, 0x8b, 0xcc, 0xc8, 0x37, 0x4c, 0x0f, 0x73, 0xbc, 0xb9, 0x75, 0xf6, 0xef, 0x16, 0x80, - 0x7c, 0x65, 0x44, 0xc3, 0x73, 0xcc, 0x05, 0x51, 0x31, 0xc8, 0xe5, 0x74, 0x84, 0x6d, 0x72, 0x38, - 0x3a, 0x7a, 0x97, 0x9e, 0xcb, 0xec, 0xa4, 0x42, 0x92, 0x9d, 0x94, 0x97, 0x21, 0x54, 0xba, 0x38, - 0x43, 0xa8, 0x7c, 0x51, 0x86, 0xd0, 0xa7, 0x60, 0xda, 0xeb, 0xf9, 0x01, 0xe3, 0x79, 0xa6, 0xb5, - 0xa3, 0xe6, 0xe4, 0x4a, 0x91, 0x79, 0xba, 0x02, 0xb8, 0xcf, 0x60, 0xe4, 0x0b, 0x09, 0x12, 0xed, - 0xf6, 0x30, 0xdb, 0x4c, 0x97, 0x02, 0x3b, 0xdd, 0x1e, 0xdd, 0x0b, 0x3a, 0x6e, 0x1c, 0x84, 0xea, - 0x43, 0x06, 0x8b, 0x98, 0x4b, 0x1f, 0x05, 0x23, 0x66, 0xc3, 0xc8, 0x79, 0xf2, 0x98, 0x4c, 0x9d, - 0x43, 0x0f, 0x70, 0xb6, 0x22, 0x27, 0xe6, 0x7d, 0xa8, 0x69, 0x0d, 0x61, 0x42, 0x92, 0xb0, 0x12, - 0x84, 0xcb, 0x57, 0xe2, 0x46, 0xb9, 0x4f, 0xfb, 0x0f, 0xba, 0xe4, 0x75, 0x98, 0xeb, 0x7a, 0x21, - 0xc5, 0xdc, 0xb2, 0x76, 0x48, 0x4f, 0x69, 0x18, 0x49, 0xe7, 0xb8, 0xa1, 0x2a, 0x1c, 0x0e, 0xb7, - 0xef, 0xc2, 0xbc, 0xb1, 0xfa, 0x8a, 0x38, 0x27, 0x31, 0x29, 0x47, 0xc6, 0xd7, 0xcc, 0x84, 0x1d, - 0x51, 0x67, 0xff, 0x5c, 0x01, 0x8a, 0xbb, 0xc1, 0x50, 0x3f, 0x45, 0xb0, 0xcc, 0x53, 0x04, 0x61, - 0xe5, 0xb4, 0x95, 0x11, 0x23, 0x94, 0x9f, 0x01, 0x24, 0x6b, 0x30, 0xe3, 0x0e, 0xe2, 0x76, 0x1c, - 0x30, 0xab, 0xee, 0xcc, 0x0d, 0xbb, 0x9c, 0x62, 0x31, 0xb0, 0x94, 0xaa, 0x21, 0x0b, 0x50, 0x54, - 0xe6, 0x00, 0x22, 0xb0, 0x22, 0x73, 0x29, 0xf0, 0x34, 0xf3, 0x5c, 0x04, 0xc7, 0x44, 0x89, 0x31, - 0x84, 0xf9, 0x3d, 0xf7, 0xe7, 0xb8, 0x50, 0xcf, 0xab, 0x62, 0x16, 0x17, 0xa3, 0x11, 0x44, 0x13, - 0xa1, 0x54, 0x59, 0xd6, 0xc3, 0xbe, 0x15, 0xf3, 0x6c, 0xf7, 0x9f, 0x2c, 0x28, 0xe3, 0xda, 0x30, - 0x05, 0xc5, 0x39, 0x58, 0x1d, 0x24, 0xe0, 0x9a, 0x4c, 0x3b, 0x69, 0x30, 0xb1, 0x8d, 0x2c, 0xc5, - 0x82, 0x9a, 0x90, 0x9e, 0xa9, 0xb8, 0x02, 0x55, 0x5e, 0x52, 0x19, 0x79, 0x88, 0x92, 0x00, 0xc9, - 0x55, 0x28, 0x9d, 0x04, 0x43, 0x69, 0x51, 0x83, 0x3c, 0x93, 0x0b, 0x86, 0x0e, 0xc2, 0x93, 0xf1, - 0xb0, 0xf6, 0xf8, 0xb4, 0xb8, 0x9d, 0x94, 0x06, 0x33, 0x4b, 0x51, 0x35, 0xab, 0x2f, 0x53, 0x0a, - 0x6a, 0xaf, 0xc1, 0x2c, 0xa3, 0x7d, 0x2d, 0xb0, 0x3a, 0x96, 0x5b, 0xed, 0x9f, 0xb2, 0xa0, 0x22, - 0x91, 0xc9, 0x2a, 0x94, 0x18, 0x23, 0xa5, 0x7c, 0x53, 0x75, 0x16, 0xcf, 0xf0, 0x1c, 0xc4, 0x60, - 0xf6, 0x02, 0xc6, 0xbb, 0x12, 0x57, 0x48, 0x46, 0xbb, 0x12, 0x4b, 0x5f, 0x0d, 0x37, 0x65, 0x20, - 0xa7, 0xa0, 0xf6, 0xf7, 0x2c, 0x98, 0x36, 0xfa, 0x20, 0x2b, 0x50, 0xeb, 0xbb, 0x51, 0x2c, 0xce, - 0x37, 0xc5, 0xf6, 0xe8, 0x20, 0x7d, 0xa3, 0x0b, 0x66, 0x7c, 0x5f, 0x05, 0x81, 0x8b, 0x7a, 0x10, - 0xf8, 0x16, 0x54, 0x93, 0x5c, 0xd2, 0x92, 0x21, 0x01, 0x58, 0x8f, 0x32, 0xcb, 0x20, 0x41, 0xc2, - 0xb8, 0x62, 0xd0, 0x0f, 0x42, 0x71, 0x18, 0xc6, 0x0b, 0xf6, 0x5d, 0xa8, 0x69, 0xf8, 0x7a, 0x98, - 0xd1, 0x32, 0xc2, 0x8c, 0x2a, 0x05, 0xa7, 0x90, 0xa4, 0xe0, 0xd8, 0xff, 0x62, 0xc1, 0x34, 0xa3, - 0x41, 0xcf, 0xef, 0x1d, 0x04, 0x7d, 0xaf, 0x73, 0x8e, 0x7b, 0x2f, 0xc9, 0x4d, 0x08, 0x46, 0x49, - 0x8b, 0x26, 0x98, 0x51, 0xbd, 0x0c, 0x6e, 0x08, 0x16, 0x55, 0x65, 0xc6, 0xc3, 0x8c, 0x03, 0x8e, - 0xdc, 0x48, 0xb0, 0x85, 0x30, 0xcc, 0x0c, 0x20, 0xe3, 0x34, 0x06, 0xc0, 0x84, 0xaa, 0x81, 0xd7, - 0xef, 0x7b, 0x1c, 0x97, 0x9b, 0xed, 0x79, 0x55, 0xac, 0xcf, 0xae, 0x17, 0xb9, 0x47, 0xc9, 0x01, - 0x8f, 0x2a, 0x63, 0x04, 0xc6, 0x7d, 0xa6, 0x45, 0x60, 0x26, 0x51, 0xae, 0x98, 0x40, 0xfb, 0xcf, - 0x0a, 0x50, 0x93, 0x56, 0x40, 0xb7, 0x47, 0xc5, 0x99, 0xa5, 0x29, 0x18, 0x35, 0x88, 0xac, 0x37, - 0x1c, 0x2e, 0x0d, 0x92, 0x26, 0x8c, 0x62, 0x96, 0x30, 0xae, 0x40, 0x95, 0x11, 0xe8, 0x9b, 0xe8, - 0xd9, 0x89, 0xf4, 0x6c, 0x05, 0x90, 0xb5, 0xb7, 0xb1, 0xb6, 0x9c, 0xd4, 0x22, 0xe0, 0x85, 0x27, - 0x9c, 0x77, 0xa0, 0x2e, 0x9a, 0xc1, 0x9d, 0x43, 0xc9, 0x93, 0xb0, 0x88, 0xb1, 0xab, 0x8e, 0x81, - 0x29, 0xbf, 0xbc, 0x2d, 0xbf, 0xac, 0x5c, 0xf4, 0xa5, 0xc4, 0xb4, 0xef, 0xab, 0x83, 0xe3, 0xfb, - 0xa1, 0x3b, 0x3c, 0x91, 0xbc, 0x7c, 0x0b, 0xe6, 0x3d, 0xbf, 0xd3, 0x1f, 0x75, 0x69, 0x7b, 0xe4, - 0xbb, 0xbe, 0x1f, 0x8c, 0xfc, 0x0e, 0x95, 0x39, 0x38, 0x79, 0x55, 0x76, 0x57, 0x65, 0x6c, 0x62, - 0x43, 0x64, 0x0d, 0xca, 0x5c, 0x61, 0x72, 0xdd, 0x91, 0xcf, 0xe8, 0x1c, 0x85, 0xac, 0x42, 0x99, - 0xeb, 0xcd, 0x82, 0xc1, 0x35, 0xda, 0xae, 0x3a, 0x1c, 0x81, 0x89, 0x1d, 0x4c, 0xc8, 0x35, 0xc5, - 0x8e, 0xa9, 0x77, 0x26, 0x3b, 0x98, 0xb2, 0x6b, 0x2f, 0x00, 0xd9, 0xe7, 0x9c, 0xa2, 0x1f, 0xff, - 0x7c, 0xbf, 0x08, 0x35, 0x0d, 0xcc, 0x24, 0x48, 0x8f, 0x0d, 0xb8, 0xdd, 0xf5, 0xdc, 0x01, 0x8d, - 0x69, 0x28, 0xb8, 0x23, 0x05, 0x65, 0x78, 0xee, 0x69, 0xaf, 0x1d, 0x8c, 0xe2, 0x76, 0x97, 0xf6, - 0x42, 0xca, 0xb5, 0x29, 0x53, 0x4d, 0x06, 0x94, 0xe1, 0x31, 0xfa, 0xd4, 0xf0, 0x38, 0x05, 0xa5, - 0xa0, 0xf2, 0x30, 0x87, 0xaf, 0x51, 0x29, 0x39, 0xcc, 0xe1, 0x2b, 0x92, 0x96, 0x7d, 0xe5, 0x1c, - 0xd9, 0xf7, 0x16, 0x2c, 0x71, 0x29, 0x27, 0xe4, 0x41, 0x3b, 0x45, 0x58, 0x63, 0x6a, 0xc9, 0x1a, - 0x34, 0xd8, 0x98, 0x25, 0x4b, 0x44, 0xde, 0x37, 0x79, 0x60, 0xd4, 0x72, 0x32, 0x70, 0x86, 0x8b, - 0x11, 0x4a, 0x1d, 0x97, 0x9f, 0xa8, 0x67, 0xe0, 0x88, 0xeb, 0x3e, 0x33, 0x71, 0xab, 0x02, 0x37, - 0x05, 0x27, 0x77, 0x60, 0x79, 0x40, 0xbb, 0x9e, 0x6b, 0x36, 0x81, 0x41, 0x5e, 0x9e, 0x36, 0x33, - 0xae, 0xda, 0x9e, 0x86, 0xda, 0x61, 0x1c, 0x0c, 0xe5, 0x76, 0xce, 0x40, 0x9d, 0x17, 0x45, 0x16, - 0xd5, 0x65, 0xb8, 0x84, 0xf4, 0xf7, 0x28, 0x18, 0x06, 0xfd, 0xa0, 0x77, 0x6e, 0xf8, 0x55, 0x7f, - 0x69, 0xc1, 0xbc, 0x51, 0x9b, 0x38, 0x56, 0x18, 0x92, 0x91, 0xe9, 0x2f, 0x9c, 0x64, 0xe7, 0x34, - 0xe1, 0xcd, 0x11, 0x79, 0xf4, 0xfb, 0xb1, 0xc8, 0x88, 0xd9, 0x48, 0x6e, 0xbd, 0xc8, 0x0f, 0x39, - 0xfd, 0x36, 0xb3, 0xf4, 0x2b, 0xbe, 0x97, 0x97, 0x5e, 0x64, 0x13, 0x5f, 0x12, 0x39, 0x0d, 0xdc, - 0xcf, 0x92, 0x11, 0x38, 0xe5, 0x99, 0xe9, 0x7e, 0xb8, 0x1c, 0x41, 0x47, 0x01, 0x23, 0xfb, 0x17, - 0x2d, 0x80, 0x64, 0x74, 0x78, 0x12, 0xae, 0x14, 0x10, 0xbf, 0x61, 0xa5, 0x29, 0x9b, 0xd7, 0xa0, - 0xae, 0x0e, 0x33, 0x13, 0x9d, 0x56, 0x93, 0x30, 0x66, 0x56, 0xdf, 0x80, 0xd9, 0x5e, 0x3f, 0x38, - 0x42, 0x83, 0x00, 0xd3, 0xf2, 0x22, 0x91, 0x4b, 0x36, 0xc3, 0xc1, 0xf7, 0x04, 0x34, 0x51, 0x80, - 0x25, 0x4d, 0x01, 0xda, 0xbf, 0x54, 0x50, 0x67, 0x4f, 0xc9, 0x9c, 0xc7, 0xf2, 0x27, 0xb9, 0x9d, - 0x11, 0xc4, 0x63, 0x8e, 0x7a, 0xd0, 0xac, 0x3d, 0xb8, 0x30, 0x14, 0x76, 0x17, 0x66, 0x42, 0x2e, - 0xe9, 0xa4, 0x18, 0x2c, 0xbd, 0x40, 0x0c, 0x4e, 0x87, 0x86, 0x96, 0xfc, 0x0c, 0x34, 0xdc, 0xee, - 0x29, 0x0d, 0x63, 0x0f, 0x83, 0x11, 0x68, 0xa2, 0x70, 0xe1, 0x3d, 0xab, 0xc1, 0xd1, 0x72, 0xb8, - 0x01, 0xb3, 0x22, 0x7f, 0x4f, 0x61, 0x8a, 0x5b, 0x0b, 0x09, 0x98, 0x21, 0xda, 0xdf, 0x95, 0xc7, - 0x5c, 0xe6, 0x1e, 0x8e, 0x5f, 0x11, 0x7d, 0x76, 0x85, 0xd4, 0xec, 0x3e, 0x25, 0x8e, 0x9c, 0xba, - 0x32, 0xe2, 0x51, 0xd4, 0xf2, 0x5f, 0xba, 0xe2, 0x88, 0xd0, 0x5c, 0xd2, 0xd2, 0xcb, 0x2c, 0xa9, - 0xfd, 0x43, 0x0b, 0xa6, 0x76, 0x83, 0xe1, 0xae, 0xc8, 0x04, 0x42, 0x46, 0x50, 0x89, 0xb3, 0xb2, - 0xf8, 0x82, 0x1c, 0xa1, 0x5c, 0xcb, 0x60, 0x3a, 0x6d, 0x19, 0xfc, 0x6f, 0xb8, 0x8c, 0xf1, 0xb6, - 0x30, 0x18, 0x06, 0x21, 0x63, 0x46, 0xb7, 0xcf, 0xcd, 0x80, 0xc0, 0x8f, 0x4f, 0xa4, 0x00, 0x7c, - 0x11, 0x0a, 0x3a, 0xc1, 0xcc, 0xb7, 0xe3, 0x46, 0xbd, 0xb0, 0x64, 0xb8, 0x5c, 0xcc, 0x56, 0xd8, - 0x5f, 0x84, 0x2a, 0x9a, 0xe2, 0x38, 0xad, 0x37, 0xa0, 0x7a, 0x12, 0x0c, 0xdb, 0x27, 0x9e, 0x1f, - 0x4b, 0xe6, 0x9e, 0x49, 0x6c, 0xe4, 0x5d, 0x5c, 0x10, 0x85, 0x60, 0xff, 0xda, 0x24, 0x4c, 0x3d, - 0xf0, 0x4f, 0x03, 0xaf, 0x83, 0x47, 0x6a, 0x03, 0x3a, 0x08, 0x64, 0x1a, 0x31, 0xfb, 0x4f, 0xae, - 0xc0, 0x14, 0xe6, 0xcd, 0x0d, 0x39, 0xd1, 0xd6, 0xf9, 0xd1, 0xb7, 0x00, 0x31, 0xf3, 0x22, 0x4c, - 0x2e, 0x73, 0x70, 0xf6, 0xd1, 0x20, 0xcc, 0x49, 0x09, 0xf5, 0xcb, 0x18, 0xa2, 0x94, 0xa4, 0x69, - 0x97, 0xb5, 0x34, 0x6d, 0xd6, 0x97, 0xc8, 0x5c, 0xe2, 0xa9, 0x2d, 0xbc, 0x2f, 0x01, 0x42, 0xc7, - 0x2a, 0xa4, 0x3c, 0x5e, 0x8a, 0xc6, 0xca, 0x94, 0x70, 0xac, 0x74, 0x20, 0x33, 0x68, 0xf8, 0x07, - 0x1c, 0x87, 0x8b, 0x6f, 0x1d, 0xc4, 0x4c, 0xc4, 0xf4, 0x3d, 0x9c, 0x2a, 0xa7, 0xfd, 0x14, 0x98, - 0xc9, 0xf8, 0x2e, 0x55, 0x02, 0x95, 0xcf, 0x03, 0xf8, 0x85, 0x95, 0x34, 0x5c, 0x73, 0xc7, 0x78, - 0x8a, 0xa3, 0x74, 0xc7, 0x18, 0xc1, 0xb8, 0xfd, 0xfe, 0x91, 0xdb, 0x79, 0x8a, 0xd7, 0xac, 0xf0, - 0x90, 0xab, 0xea, 0x98, 0x40, 0xcc, 0x3f, 0x4a, 0x76, 0x15, 0x93, 0x04, 0x4a, 0x8e, 0x0e, 0x22, - 0xb7, 0xa1, 0x86, 0x2e, 0xa8, 0xd8, 0xd7, 0x19, 0xdc, 0xd7, 0x86, 0xee, 0xa3, 0xe2, 0xce, 0xea, - 0x48, 0xfa, 0x71, 0xdf, 0x6c, 0x26, 0xe9, 0xd0, 0xed, 0x76, 0xc5, 0x29, 0x69, 0x83, 0xbb, 0xd3, - 0x0a, 0xc0, 0xf4, 0xb1, 0x58, 0x30, 0x8e, 0x30, 0x87, 0x08, 0x06, 0x8c, 0x5c, 0x85, 0x0a, 0x73, - 0x8f, 0x86, 0xae, 0xd7, 0xc5, 0xac, 0x45, 0xee, 0xa5, 0x29, 0x18, 0x6b, 0x43, 0xfe, 0x47, 0x45, - 0x37, 0x8f, 0xab, 0x62, 0xc0, 0xd8, 0xda, 0xa8, 0x32, 0x32, 0xd3, 0x02, 0xdf, 0x51, 0x03, 0x48, - 0xde, 0xc4, 0xb3, 0xaa, 0x98, 0x36, 0x17, 0x31, 0x16, 0x76, 0x59, 0xcc, 0x59, 0x10, 0xad, 0xfc, - 0x3d, 0x64, 0x28, 0x0e, 0xc7, 0xb4, 0x37, 0xa0, 0xae, 0x83, 0x49, 0x05, 0x4a, 0x0f, 0x0f, 0x76, - 0xf6, 0x1b, 0x13, 0xa4, 0x06, 0x53, 0x87, 0x3b, 0x8f, 0x1e, 0xed, 0xed, 0x6c, 0x37, 0x2c, 0x52, - 0x87, 0x8a, 0x4a, 0x16, 0x2b, 0xb0, 0xd2, 0xc6, 0xd6, 0xd6, 0xce, 0xc1, 0xa3, 0x9d, 0xed, 0x46, - 0xd1, 0x8e, 0x81, 0x6c, 0x74, 0xbb, 0xa2, 0x15, 0x15, 0x24, 0x48, 0xe8, 0xd9, 0x32, 0xe8, 0x39, - 0x87, 0xa6, 0x0a, 0xf9, 0x34, 0xf5, 0xc2, 0x95, 0xb7, 0x77, 0xa0, 0x76, 0xa0, 0xdd, 0x39, 0x42, - 0xf6, 0x92, 0xb7, 0x8d, 0x04, 0x5b, 0x6a, 0x10, 0x6d, 0x38, 0x05, 0x7d, 0x38, 0xf6, 0xef, 0x59, - 0x3c, 0xf9, 0x5f, 0x0d, 0x9f, 0xf7, 0x6d, 0x43, 0x5d, 0x05, 0xa4, 0x92, 0x3c, 0x50, 0x03, 0xc6, - 0x70, 0x70, 0x28, 0xed, 0xe0, 0xf8, 0x38, 0xa2, 0x32, 0x6b, 0xcb, 0x80, 0x31, 0xbe, 0x60, 0xb6, - 0x19, 0xb3, 0x73, 0x3c, 0xde, 0x43, 0x24, 0xb2, 0xb7, 0x32, 0x70, 0x26, 0xe5, 0x45, 0x40, 0x46, - 0xe6, 0xab, 0xa9, 0xb2, 0x4a, 0x57, 0x4d, 0xaf, 0xf2, 0x1a, 0x54, 0x54, 0xbb, 0xa6, 0x00, 0x93, - 0x98, 0xaa, 0x9e, 0x09, 0x4a, 0xf4, 0x56, 0x8c, 0x41, 0x73, 0xa1, 0x9d, 0xad, 0x20, 0x37, 0x81, - 0x1c, 0x7b, 0x61, 0x1a, 0xbd, 0x88, 0xe8, 0x39, 0x35, 0xf6, 0x13, 0x98, 0x97, 0x84, 0xa4, 0x99, - 0x56, 0xe6, 0x26, 0x5a, 0x17, 0xb1, 0x4f, 0x21, 0xcb, 0x3e, 0xf6, 0x7f, 0x58, 0x30, 0x25, 0x76, - 0x3a, 0x73, 0x6f, 0x8d, 0xef, 0xb3, 0x01, 0x23, 0x4d, 0xe3, 0x5e, 0x0b, 0xf2, 0x9a, 0x10, 0x9a, - 0x19, 0xb1, 0x58, 0xcc, 0x13, 0x8b, 0x04, 0x4a, 0x43, 0x37, 0x3e, 0x41, 0x4f, 0xbd, 0xea, 0xe0, - 0x7f, 0xd2, 0xe0, 0x71, 0x25, 0x2e, 0x82, 0x31, 0xa6, 0x94, 0x77, 0x43, 0x8f, 0x6b, 0xfb, 0xec, - 0x0d, 0xbd, 0x2b, 0x50, 0xc5, 0x01, 0xb4, 0x93, 0xb0, 0x51, 0x02, 0x60, 0x94, 0xcb, 0x0b, 0xc8, - 0xd7, 0x22, 0xc5, 0x3c, 0x81, 0xd8, 0x8b, 0x7c, 0xe7, 0xc5, 0x12, 0xa8, 0x73, 0x66, 0x91, 0x1e, - 0x9c, 0x80, 0x13, 0x8a, 0x10, 0x03, 0x48, 0x53, 0x84, 0x40, 0x75, 0x54, 0xbd, 0xdd, 0x82, 0xe6, - 0x36, 0xed, 0xd3, 0x98, 0x6e, 0xf4, 0xfb, 0xe9, 0xf6, 0x2f, 0xc3, 0xa5, 0x9c, 0x3a, 0x61, 0x4d, - 0x7f, 0x05, 0x16, 0x37, 0x78, 0x2a, 0xe5, 0x4f, 0x2a, 0x53, 0xc7, 0x6e, 0xc2, 0x52, 0xba, 0x49, - 0xd1, 0xd9, 0x3d, 0x98, 0xdb, 0xa6, 0x47, 0xa3, 0xde, 0x1e, 0x3d, 0x4d, 0x3a, 0x22, 0x50, 0x8a, - 0x4e, 0x82, 0x33, 0xc1, 0x98, 0xf8, 0x9f, 0xbc, 0x02, 0xd0, 0x67, 0x38, 0xed, 0x68, 0x48, 0x3b, - 0xf2, 0x2a, 0x09, 0x42, 0x0e, 0x87, 0xb4, 0x63, 0xbf, 0x05, 0x44, 0x6f, 0x47, 0xac, 0x17, 0xd3, - 0x82, 0xa3, 0xa3, 0x76, 0x74, 0x1e, 0xc5, 0x74, 0x20, 0xef, 0xc8, 0xe8, 0x20, 0xfb, 0x06, 0xd4, - 0x0f, 0xdc, 0x73, 0x87, 0x7e, 0x24, 0xae, 0x2b, 0x2e, 0xc3, 0xd4, 0xd0, 0x3d, 0x67, 0x62, 0x4a, - 0xc5, 0xb3, 0xb0, 0xda, 0xfe, 0xb7, 0x02, 0x4c, 0x72, 0x4c, 0xd6, 0x6a, 0x97, 0x46, 0xb1, 0xe7, - 0x23, 0x61, 0xc9, 0x56, 0x35, 0x50, 0x86, 0x94, 0x0b, 0x39, 0xa4, 0x2c, 0xbc, 0x3d, 0x99, 0x96, - 0x2f, 0xe8, 0xd5, 0x80, 0x31, 0xe2, 0x4a, 0x52, 0xe6, 0x78, 0x40, 0x25, 0x01, 0xa4, 0x42, 0x9f, - 0x89, 0xae, 0xe5, 0xe3, 0x93, 0x5c, 0x2a, 0x28, 0x57, 0x07, 0xe5, 0x6a, 0xf4, 0x29, 0x4e, 0xe0, - 0x19, 0x8d, 0x9e, 0xd1, 0xdc, 0x95, 0x97, 0xd0, 0xdc, 0xdc, 0x05, 0x7c, 0x91, 0xe6, 0x86, 0x97, - 0xd0, 0xdc, 0x36, 0x81, 0x06, 0xde, 0xf7, 0x63, 0xb6, 0xa1, 0xa4, 0xdd, 0x6f, 0x5b, 0xd0, 0x10, - 0x54, 0xa4, 0xea, 0xc8, 0x6b, 0x86, 0x0d, 0x9c, 0x9b, 0xf0, 0x7e, 0x0d, 0xa6, 0xd1, 0x32, 0x55, - 0x31, 0x5e, 0x11, 0x90, 0x36, 0x80, 0x6c, 0x1e, 0xf2, 0x88, 0x78, 0xe0, 0xf5, 0xc5, 0xa6, 0xe8, - 0x20, 0x19, 0x26, 0x0e, 0x5d, 0x91, 0x3a, 0x66, 0x39, 0xaa, 0x6c, 0xff, 0xb9, 0x05, 0x73, 0xda, - 0x80, 0x05, 0x15, 0xde, 0x05, 0xc9, 0x0d, 0x3c, 0xe0, 0xcb, 0x39, 0x77, 0xd9, 0x64, 0x9b, 0xe4, - 0x33, 0x03, 0x19, 0x37, 0xd3, 0x3d, 0xc7, 0x01, 0x46, 0xa3, 0x81, 0x10, 0xa2, 0x3a, 0x88, 0x11, - 0xd2, 0x19, 0xa5, 0x4f, 0x15, 0x0a, 0x17, 0xe3, 0x06, 0x0c, 0xa3, 0x6a, 0xcc, 0xa2, 0x56, 0x48, - 0x25, 0x11, 0x55, 0xd3, 0x81, 0xf6, 0xdf, 0x58, 0x30, 0xcf, 0x5d, 0x23, 0xe1, 0x78, 0xaa, 0x9b, - 0x4d, 0x93, 0xdc, 0x17, 0xe4, 0x1c, 0xb9, 0x3b, 0xe1, 0x88, 0x32, 0xf9, 0xfc, 0x4b, 0xba, 0x73, - 0x2a, 0x9f, 0x6d, 0xcc, 0x5e, 0x14, 0xf3, 0xf6, 0xe2, 0x05, 0x2b, 0x9d, 0x17, 0xe0, 0x2c, 0xe7, - 0x06, 0x38, 0x37, 0xa7, 0xa0, 0x1c, 0x75, 0x82, 0x21, 0xb5, 0x97, 0x60, 0xc1, 0x9c, 0x9c, 0x10, - 0x41, 0xdf, 0xb1, 0xa0, 0x79, 0x8f, 0x1f, 0x04, 0x78, 0x7e, 0x6f, 0xd7, 0x8b, 0xe2, 0x20, 0x54, - 0x17, 0x40, 0xaf, 0x02, 0x44, 0xb1, 0x1b, 0xc6, 0x3c, 0x55, 0x5a, 0x04, 0x16, 0x13, 0x08, 0x1b, - 0x23, 0xf5, 0xbb, 0xbc, 0x96, 0xef, 0x8d, 0x2a, 0x67, 0x6c, 0x08, 0xe1, 0xbc, 0x19, 0x9a, 0xf8, - 0x3a, 0xcf, 0xef, 0x64, 0xb6, 0x02, 0x3d, 0x45, 0xb9, 0xce, 0xbd, 0xa2, 0x14, 0xd4, 0xfe, 0x6b, - 0x0b, 0x66, 0x93, 0x41, 0xe2, 0xc9, 0xa7, 0x29, 0x1d, 0x84, 0xfa, 0x4d, 0xa4, 0x83, 0x0c, 0x79, - 0x7a, 0x4c, 0x1f, 0x8b, 0xb1, 0x69, 0x10, 0xe4, 0x58, 0x51, 0x0a, 0x46, 0xd2, 0xc0, 0xd1, 0x41, - 0x3c, 0x5b, 0x8b, 0x59, 0x02, 0xc2, 0xaa, 0x11, 0x25, 0xcc, 0x74, 0x1f, 0xc4, 0xf8, 0x15, 0x0f, - 0xce, 0xca, 0xa2, 0x54, 0xa5, 0x53, 0x08, 0x45, 0x55, 0xaa, 0x1f, 0xaa, 0x54, 0xf8, 0xfa, 0xc8, - 0xb2, 0xfd, 0xcb, 0x16, 0x5c, 0xca, 0x59, 0x78, 0xc1, 0x35, 0xdb, 0x30, 0x77, 0xac, 0x2a, 0xe5, - 0xe2, 0x70, 0xd6, 0x59, 0x92, 0x47, 0x77, 0xe6, 0x82, 0x38, 0xd9, 0x0f, 0x94, 0x5d, 0xc4, 0x97, - 0xdb, 0xc8, 0x87, 0xcc, 0x56, 0xd8, 0x07, 0xd0, 0xda, 0x79, 0xc6, 0x98, 0x70, 0x4b, 0x7f, 0xa7, - 0x44, 0xd2, 0xc2, 0xed, 0x8c, 0x90, 0xb9, 0xd8, 0xd1, 0x3e, 0x86, 0x69, 0xa3, 0x2d, 0xf2, 0xd9, - 0x97, 0x6d, 0x24, 0x15, 0x9e, 0xc6, 0x12, 0x7f, 0x68, 0x45, 0x66, 0x65, 0x6a, 0x20, 0xfb, 0x14, - 0x66, 0xdf, 0x1b, 0xf5, 0x63, 0x2f, 0x79, 0x74, 0x85, 0x7c, 0x5e, 0x7c, 0x84, 0x4d, 0xc8, 0xa5, - 0xcb, 0xed, 0x4a, 0xc7, 0x63, 0x2b, 0x36, 0x60, 0x2d, 0xb5, 0xb3, 0x3d, 0x66, 0x2b, 0xec, 0x4b, - 0xb0, 0x9c, 0x74, 0xc9, 0xd7, 0x4e, 0x0a, 0xea, 0xef, 0x5a, 0x3c, 0xa1, 0xc1, 0x7c, 0x03, 0x86, - 0xdc, 0x87, 0xf9, 0xc8, 0xf3, 0x7b, 0x7d, 0xaa, 0xb7, 0x13, 0x89, 0x95, 0x58, 0x34, 0x87, 0x27, - 0xde, 0x89, 0x71, 0xf2, 0xbe, 0x60, 0x04, 0x92, 0x3f, 0xd0, 0x84, 0x40, 0x52, 0x4b, 0x92, 0x37, - 0x81, 0x77, 0x60, 0xc6, 0xec, 0x8c, 0xdc, 0x11, 0x09, 0x95, 0xc9, 0xc8, 0xf4, 0x58, 0xb6, 0x49, - 0x19, 0x06, 0xa6, 0xfd, 0x2d, 0x0b, 0x9a, 0x0e, 0x65, 0x64, 0x4c, 0xb5, 0x4e, 0x05, 0xf5, 0xdc, - 0xcd, 0x34, 0x3b, 0x7e, 0xc2, 0x2a, 0x51, 0x53, 0xce, 0xf5, 0xe6, 0xd8, 0x4d, 0xd9, 0x9d, 0xc8, - 0x99, 0xd5, 0x66, 0x05, 0x26, 0xc5, 0xfc, 0x96, 0x61, 0x51, 0x0c, 0x49, 0x0e, 0x27, 0x09, 0x9a, - 0x1a, 0x9d, 0x1a, 0x41, 0xd3, 0x16, 0x34, 0xf9, 0xcd, 0x5c, 0x7d, 0x1e, 0xfc, 0xc3, 0xb5, 0xe7, - 0x50, 0xd3, 0xee, 0x27, 0x93, 0x65, 0x98, 0x7f, 0xf2, 0xe0, 0xd1, 0xfe, 0xce, 0xe1, 0x61, 0xfb, - 0xe0, 0xf1, 0xe6, 0xbb, 0x3b, 0xef, 0xb7, 0x77, 0x37, 0x0e, 0x77, 0x1b, 0x13, 0x64, 0x09, 0xc8, - 0xfe, 0xce, 0xe1, 0xa3, 0x9d, 0x6d, 0x03, 0x6e, 0x91, 0xab, 0xd0, 0x7a, 0xbc, 0xff, 0xf8, 0x70, - 0x67, 0xbb, 0x9d, 0xf7, 0x5d, 0x81, 0xbc, 0x02, 0x97, 0x44, 0x7d, 0xce, 0xe7, 0xc5, 0xdb, 0xdf, - 0x2a, 0xc2, 0x0c, 0xcf, 0xab, 0xe0, 0x4f, 0x07, 0xd1, 0x90, 0xbc, 0x07, 0x53, 0xe2, 0x0d, 0x2a, - 0x22, 0xd7, 0xd3, 0x7c, 0xf5, 0xaa, 0xb5, 0x94, 0x06, 0x8b, 0x45, 0x98, 0xff, 0xe9, 0x1f, 0xfe, - 0xe3, 0xaf, 0x16, 0xa6, 0x49, 0x6d, 0xfd, 0xf4, 0xcd, 0xf5, 0x1e, 0xf5, 0x23, 0xd6, 0xc6, 0xd7, - 0x01, 0x92, 0x97, 0x95, 0x48, 0x53, 0xf9, 0x5c, 0xa9, 0x67, 0xa7, 0x5a, 0x97, 0x72, 0x6a, 0x44, - 0xbb, 0x97, 0xb0, 0xdd, 0x79, 0x7b, 0x86, 0xb5, 0xeb, 0xf9, 0x5e, 0xcc, 0x5f, 0x59, 0x7a, 0xdb, - 0x5a, 0x23, 0x5d, 0xa8, 0xeb, 0x6f, 0x1e, 0x11, 0x19, 0xf8, 0xcd, 0x79, 0xb5, 0xa9, 0x75, 0x39, - 0xb7, 0x4e, 0x6e, 0x20, 0xf6, 0xb1, 0x68, 0x37, 0x58, 0x1f, 0x23, 0xc4, 0x48, 0x7a, 0xe9, 0x73, - 0xb2, 0x4e, 0x9e, 0x36, 0x22, 0x57, 0x34, 0x4a, 0xcb, 0x3c, 0xac, 0xd4, 0x7a, 0x65, 0x4c, 0xad, - 0xe8, 0xeb, 0x15, 0xec, 0x6b, 0xd9, 0x26, 0xac, 0xaf, 0x0e, 0xe2, 0xc8, 0x87, 0x95, 0xde, 0xb6, - 0xd6, 0x6e, 0xff, 0xfa, 0x75, 0xa8, 0xaa, 0x43, 0x1e, 0xf2, 0x21, 0x4c, 0x1b, 0x89, 0x2f, 0x44, - 0x4e, 0x23, 0x2f, 0x4f, 0xa6, 0x75, 0x25, 0xbf, 0x52, 0x74, 0x7c, 0x15, 0x3b, 0x6e, 0x92, 0x25, - 0xd6, 0xb1, 0xc8, 0x1c, 0x59, 0xc7, 0x14, 0x2e, 0x7e, 0x1f, 0xe3, 0xa9, 0xc6, 0xbe, 0xbc, 0xb3, - 0x2b, 0x69, 0x8e, 0x32, 0x7a, 0x7b, 0x65, 0x4c, 0xad, 0xe8, 0xee, 0x0a, 0x76, 0xb7, 0x44, 0x16, - 0xf4, 0xee, 0xd4, 0xe1, 0x0b, 0xc5, 0x4b, 0x44, 0xfa, 0xab, 0x40, 0xe4, 0x15, 0x45, 0x58, 0x79, - 0xaf, 0x05, 0x29, 0x12, 0xc9, 0x3e, 0x19, 0x64, 0x37, 0xb1, 0x2b, 0x42, 0x70, 0xfb, 0xf4, 0x47, - 0x81, 0xc8, 0x11, 0xd4, 0xb4, 0xd7, 0x2e, 0xc8, 0xa5, 0xb1, 0x2f, 0x73, 0xb4, 0x5a, 0x79, 0x55, - 0x79, 0x53, 0xd1, 0xdb, 0x5f, 0x67, 0x7a, 0xf9, 0x6b, 0x50, 0x55, 0xef, 0x27, 0x90, 0x65, 0xed, - 0x3d, 0x0b, 0xfd, 0xbd, 0x87, 0x56, 0x33, 0x5b, 0x91, 0x47, 0x7c, 0x7a, 0xeb, 0x8c, 0xf8, 0x9e, - 0x40, 0x4d, 0x7b, 0x23, 0x41, 0x4d, 0x20, 0xfb, 0x0e, 0x83, 0x9a, 0x40, 0xce, 0x93, 0x0a, 0xf6, - 0x1c, 0x76, 0x51, 0x23, 0x55, 0xa4, 0xef, 0xf8, 0x59, 0x10, 0x91, 0x3d, 0x58, 0x14, 0x62, 0xea, - 0x88, 0x7e, 0x92, 0x6d, 0xc8, 0x79, 0x88, 0xe9, 0x96, 0x45, 0xee, 0x42, 0x45, 0x3e, 0x85, 0x41, - 0x96, 0xf2, 0x9f, 0xf4, 0x68, 0x2d, 0x67, 0xe0, 0xc2, 0x3c, 0x79, 0x1f, 0x20, 0x79, 0x90, 0x41, - 0x09, 0x89, 0xcc, 0x03, 0x0f, 0x8a, 0x02, 0xb2, 0xaf, 0x37, 0xd8, 0x4b, 0x38, 0xc1, 0x06, 0x41, - 0x21, 0xe1, 0xd3, 0x33, 0x79, 0x5f, 0xf0, 0x1b, 0x50, 0xd3, 0xde, 0x64, 0x50, 0xcb, 0x97, 0x7d, - 0xcf, 0x41, 0x2d, 0x5f, 0xce, 0x13, 0x0e, 0x76, 0x0b, 0x5b, 0x5f, 0xb0, 0x67, 0x59, 0xeb, 0x91, - 0xd7, 0xf3, 0x07, 0x1c, 0x81, 0x6d, 0xd0, 0x09, 0x4c, 0x1b, 0x0f, 0x2f, 0x28, 0x0e, 0xcd, 0x7b, - 0xd6, 0x41, 0x71, 0x68, 0xee, 0x5b, 0x0d, 0x92, 0xce, 0xec, 0x39, 0xd6, 0xcf, 0x29, 0xa2, 0x68, - 0x3d, 0x7d, 0x00, 0x35, 0xed, 0x11, 0x05, 0x35, 0x97, 0xec, 0x7b, 0x0d, 0x6a, 0x2e, 0x79, 0x6f, - 0x2e, 0x2c, 0x60, 0x1f, 0x33, 0x36, 0x92, 0x02, 0xde, 0x7c, 0x63, 0x6d, 0x7f, 0x08, 0x33, 0xe6, - 0xb3, 0x0a, 0x8a, 0xf7, 0x73, 0x1f, 0x68, 0x50, 0xbc, 0x3f, 0xe6, 0x2d, 0x06, 0x41, 0xd2, 0x6b, - 0xf3, 0xaa, 0x93, 0xf5, 0x8f, 0x45, 0xf2, 0xc7, 0x73, 0xf2, 0x15, 0x26, 0xe0, 0xc4, 0x55, 0x44, - 0xb2, 0xac, 0x51, 0xad, 0x7e, 0x61, 0x51, 0xf1, 0x4b, 0xe6, 0xd6, 0xa2, 0x49, 0xcc, 0xfc, 0xee, - 0x1e, 0x6a, 0x2d, 0xbc, 0x92, 0xa8, 0x69, 0x2d, 0xfd, 0xd6, 0xa2, 0xa6, 0xb5, 0x8c, 0x9b, 0x8b, - 0x69, 0xad, 0x15, 0x7b, 0xac, 0x0d, 0x1f, 0x66, 0x53, 0xc9, 0xb9, 0x8a, 0x2b, 0xf2, 0x6f, 0x33, - 0xb4, 0xae, 0xbe, 0x38, 0xa7, 0xd7, 0x94, 0x20, 0x52, 0x08, 0xae, 0xcb, 0xbb, 0x23, 0xff, 0x17, - 0xea, 0xfa, 0x15, 0x76, 0xa2, 0xb3, 0x72, 0xba, 0xa7, 0xcb, 0xb9, 0x75, 0xe6, 0xe6, 0x92, 0xba, - 0xde, 0x0d, 0xf9, 0x2a, 0x2c, 0x29, 0x56, 0xd7, 0xf3, 0x3d, 0x23, 0xf2, 0x6a, 0x4e, 0x16, 0xa8, - 0x6e, 0xbc, 0xb4, 0x2e, 0x8d, 0x4d, 0x13, 0xbd, 0x65, 0x31, 0xa2, 0x31, 0xef, 0x06, 0x27, 0x0a, - 0x23, 0xef, 0x4a, 0x74, 0xa2, 0x30, 0x72, 0x2f, 0x14, 0x4b, 0xa2, 0x21, 0xf3, 0xc6, 0x1a, 0xf1, - 0xf3, 0x39, 0xf2, 0x01, 0xcc, 0x6a, 0x19, 0xf5, 0x87, 0xe7, 0x7e, 0x47, 0x31, 0x40, 0xf6, 0xea, - 0x55, 0x2b, 0xcf, 0x34, 0xb7, 0x97, 0xb1, 0xfd, 0x39, 0xdb, 0x58, 0x1c, 0x46, 0xfc, 0x5b, 0x50, - 0xd3, 0xb3, 0xf5, 0x5f, 0xd0, 0xee, 0xb2, 0x56, 0xa5, 0xdf, 0x1c, 0xba, 0x65, 0x91, 0xdf, 0xb4, - 0xa0, 0x6e, 0xe4, 0xbe, 0x1b, 0xa7, 0xd0, 0xa9, 0x76, 0x9a, 0x7a, 0x9d, 0xde, 0x90, 0xed, 0xe0, - 0x20, 0xf7, 0xd6, 0xde, 0x31, 0x16, 0xe1, 0x63, 0x23, 0xfe, 0x72, 0x33, 0xfd, 0xfc, 0xd6, 0xf3, - 0x34, 0x82, 0x7e, 0x3d, 0xed, 0xf9, 0x2d, 0x8b, 0x7c, 0xcf, 0x82, 0x19, 0x33, 0x6a, 0xa8, 0xb6, - 0x2a, 0x37, 0x3e, 0xa9, 0xb6, 0x6a, 0x4c, 0xa8, 0xf1, 0x03, 0x1c, 0xe5, 0xa3, 0x35, 0xc7, 0x18, - 0xa5, 0xb8, 0x35, 0xfe, 0xe3, 0x8d, 0x96, 0xbc, 0xcd, 0x5f, 0xdf, 0x93, 0xa1, 0x6c, 0xa2, 0x69, - 0x8d, 0xf4, 0xf6, 0xea, 0x2f, 0xc6, 0xad, 0x5a, 0xb7, 0x2c, 0xf2, 0x0d, 0xfe, 0xec, 0x94, 0xf8, - 0x16, 0xa9, 0xe4, 0x65, 0xbf, 0xb7, 0xaf, 0xe1, 0x9c, 0xae, 0xda, 0x97, 0x8c, 0x39, 0xa5, 0xf5, - 0xf1, 0x06, 0x1f, 0x9d, 0x78, 0xec, 0x2d, 0x51, 0x28, 0x99, 0x07, 0xe0, 0xc6, 0x0f, 0x72, 0xc0, - 0x07, 0x29, 0xd0, 0x0d, 0x52, 0x7e, 0xc9, 0x66, 0xec, 0x35, 0x1c, 0xeb, 0x35, 0xfb, 0xd5, 0xb1, - 0x63, 0x5d, 0xc7, 0xd8, 0x1f, 0x1b, 0xf1, 0x01, 0x40, 0x72, 0xec, 0x44, 0x52, 0xc7, 0x1e, 0x8a, - 0xc1, 0xb3, 0x27, 0x53, 0x26, 0xbf, 0xc8, 0xd3, 0x11, 0xd6, 0xe2, 0xd7, 0xb8, 0xb8, 0x7a, 0x20, - 0x0f, 0x4c, 0x74, 0xa3, 0xc4, 0x3c, 0x1f, 0x32, 0x8c, 0x92, 0x74, 0xfb, 0x86, 0xb0, 0x52, 0xa7, - 0x2f, 0x8f, 0x61, 0x7a, 0x2f, 0x08, 0x9e, 0x8e, 0x86, 0xea, 0x08, 0xd9, 0x0c, 0xcb, 0xef, 0xba, - 0xd1, 0x49, 0x2b, 0x35, 0x0b, 0x7b, 0x05, 0x9b, 0x6a, 0x91, 0xa6, 0xd6, 0xd4, 0xfa, 0xc7, 0xc9, - 0xb1, 0xd6, 0x73, 0xe2, 0xc2, 0x9c, 0x92, 0x81, 0x6a, 0xe0, 0x2d, 0xb3, 0x19, 0x43, 0xf2, 0xa5, - 0xbb, 0x30, 0xac, 0x67, 0x39, 0xda, 0xf5, 0x48, 0xb6, 0x79, 0xcb, 0x22, 0x07, 0x50, 0xdf, 0xa6, - 0x9d, 0xa0, 0x4b, 0x45, 0x6c, 0x7b, 0x3e, 0x19, 0xb8, 0x0a, 0x8a, 0xb7, 0xa6, 0x0d, 0xa0, 0xa9, - 0x17, 0x86, 0xee, 0x79, 0x48, 0x3f, 0x5a, 0xff, 0x58, 0x44, 0xcd, 0x9f, 0x4b, 0xbd, 0x20, 0x8f, - 0x15, 0x0c, 0xbd, 0x90, 0x3a, 0x87, 0x30, 0xf4, 0x42, 0xe6, 0x1c, 0xc2, 0x58, 0x6a, 0x79, 0xac, - 0x41, 0xfa, 0x30, 0x97, 0x39, 0xba, 0x50, 0x2a, 0x61, 0xdc, 0x81, 0x47, 0x6b, 0x65, 0x3c, 0x82, - 0xd9, 0xdb, 0x9a, 0xd9, 0xdb, 0x21, 0x4c, 0x6f, 0x53, 0xbe, 0x58, 0x3c, 0xc3, 0x2d, 0x75, 0x81, - 0x42, 0xcf, 0x9f, 0x4b, 0x0b, 0x70, 0xac, 0x33, 0x15, 0x3f, 0xa6, 0x97, 0x91, 0xaf, 0x41, 0xed, - 0x3e, 0x8d, 0x65, 0x4a, 0x9b, 0x32, 0x3d, 0x53, 0x39, 0x6e, 0xad, 0x9c, 0x8c, 0x38, 0x93, 0x66, - 0xb0, 0xb5, 0x75, 0xda, 0xed, 0x51, 0x2e, 0x9c, 0xda, 0x5e, 0xf7, 0x39, 0xf9, 0x3f, 0xd8, 0xb8, - 0xca, 0xbc, 0x5d, 0xd2, 0xf2, 0x99, 0xf4, 0xc6, 0x67, 0x53, 0xf0, 0xbc, 0x96, 0xfd, 0xa0, 0x4b, - 0x35, 0x13, 0xc8, 0x87, 0x9a, 0x96, 0x30, 0xae, 0x18, 0x28, 0x9b, 0xc2, 0xaf, 0x18, 0x28, 0x27, - 0xbf, 0xdc, 0x5e, 0xc5, 0x7e, 0x6c, 0xb2, 0x92, 0xf4, 0xc3, 0x73, 0xca, 0x93, 0x9e, 0xd6, 0x3f, - 0x76, 0x07, 0xf1, 0x73, 0xf2, 0x04, 0x5f, 0x71, 0xd0, 0xd3, 0xf6, 0x12, 0x5b, 0x3a, 0x9d, 0xe1, - 0xa7, 0x16, 0x4b, 0xab, 0x32, 0xed, 0x6b, 0xde, 0x15, 0x5a, 0x4a, 0x9f, 0x07, 0x38, 0x8c, 0x83, - 0xe1, 0xb6, 0x4b, 0x07, 0x81, 0x9f, 0xc8, 0xda, 0x24, 0xc1, 0x2c, 0x91, 0x5f, 0x5a, 0x96, 0x19, - 0x79, 0xa2, 0x39, 0x1f, 0x46, 0xd6, 0xa3, 0x24, 0xae, 0xb1, 0x39, 0x68, 0x6a, 0x41, 0x72, 0xf2, - 0xd0, 0x6e, 0x59, 0x64, 0x03, 0x20, 0x39, 0xbb, 0x52, 0xae, 0x44, 0xe6, 0x58, 0x4c, 0x89, 0xbd, - 0x9c, 0x83, 0xae, 0x03, 0xa8, 0x26, 0x87, 0x21, 0xcb, 0xc9, 0xcd, 0x06, 0xe3, 0xe8, 0x44, 0x69, - 0xf0, 0xcc, 0x11, 0x85, 0xdd, 0xc0, 0xa5, 0x02, 0x52, 0x61, 0x4b, 0x85, 0xe7, 0x0e, 0x1e, 0xcc, - 0xf3, 0x01, 0x2a, 0x73, 0x04, 0x53, 0xa6, 0xe4, 0x4c, 0x72, 0x8e, 0x09, 0x14, 0x37, 0xe7, 0x46, - 0xd9, 0x8d, 0x88, 0x08, 0xa3, 0x56, 0x9e, 0xae, 0xc5, 0x44, 0xf3, 0x00, 0xe6, 0x32, 0x61, 0x60, - 0xc5, 0xd2, 0xe3, 0x22, 0xf3, 0x8a, 0xa5, 0xc7, 0x46, 0x90, 0xed, 0x45, 0xec, 0x72, 0xd6, 0x06, - 0xf4, 0x80, 0xce, 0xbc, 0xb8, 0x73, 0xc2, 0xba, 0xfb, 0xae, 0x05, 0xf3, 0x39, 0x51, 0x5e, 0xf2, - 0x9a, 0x74, 0xa6, 0xc7, 0x46, 0x80, 0x5b, 0xb9, 0x41, 0x40, 0xfb, 0x10, 0xfb, 0x79, 0x8f, 0xbc, - 0x6b, 0x28, 0x36, 0x1e, 0x7f, 0x13, 0x9c, 0xf9, 0x42, 0xa3, 0x22, 0xd7, 0xa2, 0xf8, 0x08, 0x96, - 0xf9, 0x40, 0x36, 0xfa, 0xfd, 0x54, 0x80, 0xf2, 0x6a, 0xe6, 0x81, 0x6d, 0x23, 0xf0, 0xda, 0x1a, - 0xff, 0x00, 0xf7, 0x18, 0x73, 0x95, 0x0f, 0x95, 0x8c, 0xa0, 0x91, 0x0e, 0xfa, 0x91, 0xf1, 0x6d, - 0xb5, 0x5e, 0x35, 0xdc, 0xc2, 0x6c, 0xa0, 0xd0, 0xfe, 0x34, 0x76, 0xf6, 0xaa, 0xdd, 0xca, 0x5b, - 0x17, 0xee, 0x29, 0xb2, 0xfd, 0xf8, 0xff, 0x2a, 0x42, 0x99, 0x9a, 0xa7, 0xec, 0x60, 0x5c, 0x48, - 0x55, 0x39, 0xa6, 0xf9, 0x01, 0xce, 0xeb, 0xd8, 0xfd, 0x8a, 0x7d, 0x39, 0xaf, 0xfb, 0x90, 0x7f, - 0xc2, 0x5d, 0xd4, 0xe5, 0x34, 0x5f, 0xcb, 0x11, 0xac, 0xe4, 0xed, 0xf7, 0x58, 0x5f, 0x23, 0xb5, - 0xd6, 0x13, 0xb7, 0xac, 0xcd, 0x1b, 0x1f, 0x7c, 0xba, 0xe7, 0xc5, 0x27, 0xa3, 0xa3, 0x9b, 0x9d, - 0x60, 0xb0, 0xde, 0x97, 0x21, 0x32, 0x91, 0x9e, 0xbb, 0xde, 0xf7, 0xbb, 0xeb, 0xf8, 0xfd, 0xd1, - 0x24, 0xbe, 0xd7, 0xff, 0xd9, 0xff, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x2c, 0x9c, 0xb9, 0xa5, 0xe1, - 0x5f, 0x00, 0x00, +func init() { proto.RegisterFile("rpc.proto", fileDescriptor_rpc_aae6a4dae77df6ef) } + +var fileDescriptor_rpc_aae6a4dae77df6ef = []byte{ + // 7737 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x7c, 0x5d, 0x6c, 0x1c, 0xc9, + 0x99, 0x18, 0x7b, 0x7e, 0xc8, 0x99, 0x6f, 0x86, 0xe4, 0xb0, 0xf8, 0x37, 0x1a, 0x69, 0xb5, 0xdc, + 0xb6, 0x2c, 0xd1, 0xdc, 0x8d, 0xa8, 0x95, 0xed, 0xb5, 0xbc, 0x8a, 0xe3, 0xf0, 0x4f, 0xa2, 0x76, + 0xb9, 0x14, 0xdd, 0x94, 0xac, 0xec, 0xda, 0xc1, 0xb8, 0x39, 0x53, 0x1c, 0xf6, 0x6a, 0xa6, 0x7b, + 0xb6, 0xbb, 0x87, 0xd4, 0x78, 0xa3, 0x20, 0x08, 0x82, 0x24, 0x08, 0x1c, 0x04, 0x4e, 0x90, 0x20, + 0x0e, 0x12, 0x04, 0xb1, 0x03, 0x24, 0x46, 0x9e, 0xf2, 0x90, 0x20, 0x40, 0xe2, 0xe7, 0x00, 0x06, + 0x82, 0xe0, 0xe0, 0xc7, 0x03, 0xee, 0x70, 0xb8, 0x7b, 0x39, 0xdc, 0xc3, 0x01, 0x07, 0xdc, 0xe3, + 0x01, 0x87, 0xfa, 0xea, 0xa7, 0xab, 0xba, 0x7b, 0x44, 0xad, 0xed, 0xbb, 0xa7, 0x99, 0xfa, 0xea, + 0xeb, 0xfa, 0xfd, 0xfe, 0xeb, 0xab, 0x82, 0x6a, 0x38, 0xec, 0xdc, 0x1e, 0x86, 0x41, 0x1c, 0x90, + 0x72, 0xdf, 0x0f, 0x87, 0x9d, 0xd6, 0xb5, 0x5e, 0x10, 0xf4, 0xfa, 0x74, 0xd3, 0x1d, 0x7a, 0x9b, + 0xae, 0xef, 0x07, 0xb1, 0x1b, 0x7b, 0x81, 0x1f, 0x71, 0x24, 0xfb, 0x07, 0x30, 0xf7, 0x90, 0xfa, + 0xc7, 0x94, 0x76, 0x1d, 0xfa, 0xd9, 0x88, 0x46, 0x31, 0x79, 0x1b, 0x16, 0x5c, 0xfa, 0x43, 0x4a, + 0xbb, 0xed, 0xa1, 0x1b, 0x45, 0xc3, 0xb3, 0xd0, 0x8d, 0x68, 0xd3, 0x5a, 0xb3, 0xd6, 0xeb, 0x4e, + 0x83, 0x57, 0x1c, 0x29, 0x38, 0x79, 0x0b, 0xea, 0x11, 0x43, 0xa5, 0x7e, 0x1c, 0x06, 0xc3, 0x71, + 0xb3, 0x80, 0x78, 0x35, 0x06, 0xdb, 0xe3, 0x20, 0xbb, 0x0f, 0xf3, 0xaa, 0x87, 0x68, 0x18, 0xf8, + 0x11, 0x25, 0x77, 0x60, 0xa9, 0xe3, 0x0d, 0xcf, 0x68, 0xd8, 0xc6, 0x8f, 0x07, 0x3e, 0x1d, 0x04, + 0xbe, 0xd7, 0x69, 0x5a, 0x6b, 0xc5, 0xf5, 0xaa, 0x43, 0x78, 0x1d, 0xfb, 0xe2, 0x23, 0x51, 0x43, + 0x6e, 0xc1, 0x3c, 0xf5, 0x39, 0x9c, 0x76, 0xf1, 0x2b, 0xd1, 0xd5, 0x5c, 0x02, 0x66, 0x1f, 0xd8, + 0xff, 0xb4, 0x00, 0x0b, 0x8f, 0x7c, 0x2f, 0x7e, 0xe6, 0xf6, 0xfb, 0x34, 0x96, 0x73, 0xba, 0x05, + 0xf3, 0x17, 0x08, 0xc0, 0x39, 0x5d, 0x04, 0x61, 0x57, 0xcc, 0x68, 0x8e, 0x83, 0x8f, 0x04, 0x74, + 0xe2, 0xc8, 0x0a, 0x13, 0x47, 0x96, 0xbb, 0x5c, 0xc5, 0x09, 0xcb, 0x75, 0x0b, 0xe6, 0x43, 0xda, + 0x09, 0xce, 0x69, 0x38, 0x6e, 0x5f, 0x78, 0x7e, 0x37, 0xb8, 0x68, 0x96, 0xd6, 0xac, 0xf5, 0xb2, + 0x33, 0x27, 0xc1, 0xcf, 0x10, 0x4a, 0xb6, 0x61, 0xbe, 0x73, 0xe6, 0xfa, 0x3e, 0xed, 0xb7, 0x4f, + 0xdc, 0xce, 0xf3, 0xd1, 0x30, 0x6a, 0x96, 0xd7, 0xac, 0xf5, 0xda, 0xdd, 0x2b, 0xb7, 0x71, 0x57, + 0x6f, 0xef, 0x9c, 0xb9, 0xfe, 0x36, 0xd6, 0x1c, 0xfb, 0xee, 0x30, 0x3a, 0x0b, 0x62, 0x67, 0x4e, + 0x7c, 0xc1, 0xc1, 0x91, 0xbd, 0x04, 0x44, 0x5f, 0x09, 0xbe, 0xf6, 0xf6, 0x7f, 0xb3, 0x60, 0xf1, + 0xa9, 0xdf, 0x0f, 0x3a, 0xcf, 0x7f, 0xcd, 0x25, 0xca, 0x99, 0x43, 0xe1, 0x75, 0xe7, 0x50, 0xfc, + 0xa2, 0x73, 0x58, 0x81, 0x25, 0x73, 0xb0, 0x62, 0x16, 0x14, 0x96, 0xd9, 0xd7, 0x3d, 0x2a, 0x87, + 0x25, 0xa7, 0xf1, 0x15, 0x68, 0x74, 0x46, 0x61, 0x48, 0xfd, 0xcc, 0x3c, 0xe6, 0x05, 0x5c, 0x4d, + 0xe4, 0x2d, 0xa8, 0xfb, 0xf4, 0x22, 0x41, 0x13, 0xb4, 0xeb, 0xd3, 0x0b, 0x89, 0x62, 0x37, 0x61, + 0x25, 0xdd, 0x8d, 0x18, 0xc0, 0x1f, 0x58, 0x50, 0x7a, 0x1a, 0xbf, 0x08, 0xc8, 0x6d, 0x28, 0xc5, + 0xe3, 0x21, 0xe7, 0x90, 0xb9, 0xbb, 0x44, 0x4c, 0x6d, 0xab, 0xdb, 0x0d, 0x69, 0x14, 0x3d, 0x19, + 0x0f, 0xa9, 0x53, 0x77, 0x79, 0xa1, 0xcd, 0xf0, 0x48, 0x13, 0x66, 0x44, 0x19, 0x3b, 0xac, 0x3a, + 0xb2, 0x48, 0xae, 0x03, 0xb8, 0x83, 0x60, 0xe4, 0xc7, 0xed, 0xc8, 0x8d, 0x71, 0xa9, 0x8a, 0x8e, + 0x06, 0x21, 0xd7, 0xa0, 0x3a, 0x7c, 0xde, 0x8e, 0x3a, 0xa1, 0x37, 0x8c, 0x91, 0x6c, 0xaa, 0x4e, + 0x02, 0x20, 0x6f, 0x43, 0x25, 0x18, 0xc5, 0xc3, 0xc0, 0xf3, 0x63, 0x41, 0x2a, 0xf3, 0x62, 0x2c, + 0x8f, 0x47, 0xf1, 0x11, 0x03, 0x3b, 0x0a, 0x81, 0xdc, 0x80, 0xd9, 0x4e, 0xe0, 0x9f, 0x7a, 0xe1, + 0x80, 0x0b, 0x83, 0xe6, 0x34, 0xf6, 0x66, 0x02, 0xed, 0x9f, 0x14, 0xa0, 0xf6, 0x24, 0x74, 0xfd, + 0xc8, 0xed, 0x30, 0x00, 0x1b, 0x7a, 0xfc, 0xa2, 0x7d, 0xe6, 0x46, 0x67, 0x38, 0xdb, 0xaa, 0x23, + 0x8b, 0x64, 0x05, 0xa6, 0xf9, 0x40, 0x71, 0x4e, 0x45, 0x47, 0x94, 0xc8, 0x3b, 0xb0, 0xe0, 0x8f, + 0x06, 0x6d, 0xb3, 0xaf, 0x22, 0x52, 0x4b, 0xb6, 0x82, 0x2d, 0xc0, 0x09, 0xdb, 0x6b, 0xde, 0x05, + 0x9f, 0xa1, 0x06, 0x21, 0x36, 0xd4, 0x45, 0x89, 0x7a, 0xbd, 0x33, 0x3e, 0xcd, 0xb2, 0x63, 0xc0, + 0x58, 0x1b, 0xb1, 0x37, 0xa0, 0xed, 0x28, 0x76, 0x07, 0x43, 0x31, 0x2d, 0x0d, 0x82, 0xf5, 0x41, + 0xec, 0xf6, 0xdb, 0xa7, 0x94, 0x46, 0xcd, 0x19, 0x51, 0xaf, 0x20, 0xe4, 0x26, 0xcc, 0x75, 0x69, + 0x14, 0xb7, 0xc5, 0xa6, 0xd0, 0xa8, 0x59, 0x41, 0xd6, 0x4f, 0x41, 0x19, 0x65, 0x3c, 0xa4, 0xb1, + 0xb6, 0x3a, 0x91, 0xa0, 0x40, 0xfb, 0x00, 0x88, 0x06, 0xde, 0xa5, 0xb1, 0xeb, 0xf5, 0x23, 0xf2, + 0x1e, 0xd4, 0x63, 0x0d, 0x19, 0x45, 0x5d, 0x4d, 0x91, 0x8b, 0xf6, 0x81, 0x63, 0xe0, 0xd9, 0x0f, + 0xa1, 0xf2, 0x80, 0xd2, 0x03, 0x6f, 0xe0, 0xc5, 0x64, 0x05, 0xca, 0xa7, 0xde, 0x0b, 0xca, 0x09, + 0xba, 0xb8, 0x3f, 0xe5, 0xf0, 0x22, 0x69, 0xc1, 0xcc, 0x90, 0x86, 0x1d, 0x2a, 0x97, 0x7f, 0x7f, + 0xca, 0x91, 0x80, 0xed, 0x19, 0x28, 0xf7, 0xd9, 0xc7, 0xf6, 0x8f, 0x8a, 0x50, 0x3b, 0xa6, 0xbe, + 0x62, 0x14, 0x02, 0x25, 0x36, 0x25, 0xc1, 0x1c, 0xf8, 0x9f, 0xbc, 0x09, 0x35, 0x9c, 0x66, 0x14, + 0x87, 0x9e, 0xdf, 0x13, 0xf4, 0x09, 0x0c, 0x74, 0x8c, 0x10, 0xd2, 0x80, 0xa2, 0x3b, 0x90, 0xb4, + 0xc9, 0xfe, 0x32, 0x26, 0x1a, 0xba, 0xe3, 0x01, 0xe3, 0x37, 0xb5, 0x6b, 0x75, 0xa7, 0x26, 0x60, + 0xfb, 0x6c, 0xdb, 0x6e, 0xc3, 0xa2, 0x8e, 0x22, 0x5b, 0x2f, 0x63, 0xeb, 0x0b, 0x1a, 0xa6, 0xe8, + 0xe4, 0x16, 0xcc, 0x4b, 0xfc, 0x90, 0x0f, 0x16, 0xf7, 0xb1, 0xea, 0xcc, 0x09, 0xb0, 0x9c, 0xc2, + 0x3a, 0x34, 0x4e, 0x3d, 0xdf, 0xed, 0xb7, 0x3b, 0xfd, 0xf8, 0xbc, 0xdd, 0xa5, 0xfd, 0xd8, 0xc5, + 0x1d, 0x2d, 0x3b, 0x73, 0x08, 0xdf, 0xe9, 0xc7, 0xe7, 0xbb, 0x0c, 0x4a, 0xde, 0x81, 0xea, 0x29, + 0xa5, 0x6d, 0x5c, 0x89, 0x66, 0xc5, 0xe0, 0x0e, 0xb9, 0xba, 0x4e, 0xe5, 0x54, 0xae, 0xf3, 0x3a, + 0x34, 0x82, 0x51, 0xdc, 0x0b, 0x3c, 0xbf, 0xd7, 0x66, 0xf2, 0xa8, 0xed, 0x75, 0x9b, 0xd5, 0x35, + 0x6b, 0xbd, 0xe4, 0xcc, 0x49, 0x38, 0x93, 0x0a, 0x8f, 0xba, 0xe4, 0x0d, 0x00, 0xec, 0x9b, 0x37, + 0x0c, 0x6b, 0xd6, 0xfa, 0xac, 0x53, 0x65, 0x10, 0xde, 0xd0, 0x15, 0xa8, 0x3c, 0xa7, 0xe3, 0x76, + 0x44, 0xfd, 0x6e, 0xb3, 0xb6, 0x66, 0xad, 0x57, 0x9c, 0x99, 0xe7, 0x74, 0xcc, 0x76, 0xc1, 0xfe, + 0x5f, 0x16, 0xd4, 0xf9, 0x76, 0x08, 0x9d, 0x78, 0x03, 0x66, 0xe5, 0xac, 0x69, 0x18, 0x06, 0xa1, + 0x60, 0x31, 0x13, 0x48, 0x36, 0xa0, 0x21, 0x01, 0xc3, 0x90, 0x7a, 0x03, 0xb7, 0x47, 0x85, 0xdc, + 0xca, 0xc0, 0xc9, 0xdd, 0xa4, 0xc5, 0x30, 0x18, 0xc5, 0x54, 0x48, 0xdf, 0xba, 0x98, 0xb8, 0xc3, + 0x60, 0x8e, 0x89, 0xc2, 0x58, 0x2c, 0x67, 0x3b, 0x0d, 0x98, 0xfd, 0x63, 0x0b, 0x08, 0x1b, 0xfa, + 0x93, 0x80, 0x37, 0x21, 0x76, 0x23, 0x4d, 0x09, 0xd6, 0x6b, 0x53, 0x42, 0x61, 0x12, 0x25, 0xd8, + 0x50, 0xe6, 0x23, 0x2f, 0xe5, 0x8c, 0x9c, 0x57, 0x7d, 0x50, 0xaa, 0x14, 0x1b, 0x25, 0xfb, 0xa7, + 0x16, 0xd4, 0x77, 0xb8, 0xea, 0x40, 0x59, 0x47, 0xee, 0x00, 0x39, 0x1d, 0xf9, 0x5d, 0xb6, 0x85, + 0xf1, 0x0b, 0xaf, 0xdb, 0x3e, 0x19, 0xc7, 0x34, 0xe2, 0x63, 0xda, 0x9f, 0x72, 0x72, 0xea, 0xc8, + 0x3b, 0xd0, 0x30, 0xa0, 0x51, 0x1c, 0xf2, 0x91, 0xed, 0x4f, 0x39, 0x99, 0x1a, 0xb6, 0x50, 0x4c, + 0x9a, 0x8e, 0xe2, 0xb6, 0xe7, 0x77, 0xe9, 0x0b, 0x5c, 0xdb, 0x59, 0xc7, 0x80, 0x6d, 0xcf, 0x41, + 0x5d, 0xff, 0xce, 0xfe, 0x14, 0x2a, 0x52, 0x16, 0xa3, 0x1c, 0x4a, 0x8d, 0xcb, 0xd1, 0x20, 0xa4, + 0x05, 0x15, 0x73, 0x14, 0x4e, 0xe5, 0x8b, 0xf4, 0x6d, 0xff, 0x2d, 0x68, 0x1c, 0x30, 0x81, 0xe8, + 0x7b, 0x7e, 0x4f, 0x28, 0x23, 0x26, 0xa5, 0x87, 0xa3, 0x93, 0xe7, 0x74, 0x2c, 0x68, 0x4b, 0x94, + 0x98, 0x28, 0x38, 0x0b, 0xa2, 0x58, 0xf4, 0x83, 0xff, 0xed, 0xff, 0x6b, 0x01, 0xd9, 0x8b, 0x62, + 0x6f, 0xe0, 0xc6, 0xf4, 0x01, 0x55, 0x9b, 0xfc, 0x18, 0xea, 0xac, 0xb5, 0x27, 0xc1, 0x16, 0x17, + 0xf7, 0x5c, 0x8c, 0xbd, 0x2d, 0x36, 0x26, 0xfb, 0xc1, 0x6d, 0x1d, 0x9b, 0x59, 0x84, 0x63, 0xc7, + 0x68, 0x80, 0x89, 0x9c, 0xd8, 0x0d, 0x7b, 0x34, 0x46, 0x5d, 0x20, 0x2c, 0x09, 0xe0, 0xa0, 0x9d, + 0xc0, 0x3f, 0x6d, 0x7d, 0x1b, 0x16, 0x32, 0x6d, 0x30, 0x39, 0x94, 0x4c, 0x83, 0xfd, 0x25, 0x4b, + 0x50, 0x3e, 0x77, 0xfb, 0x23, 0x2a, 0x14, 0x10, 0x2f, 0xbc, 0x5f, 0xb8, 0x67, 0xd9, 0x1d, 0x58, + 0x34, 0xc6, 0x25, 0xf8, 0xad, 0x09, 0x33, 0x4c, 0x24, 0x30, 0x55, 0x8b, 0xe2, 0xd4, 0x91, 0x45, + 0x72, 0x17, 0x96, 0x4e, 0x29, 0x0d, 0xdd, 0x18, 0x8b, 0xed, 0x21, 0x0d, 0x71, 0x4f, 0x44, 0xcb, + 0xb9, 0x75, 0xf6, 0x1f, 0x5a, 0x30, 0xcf, 0x78, 0xe2, 0x23, 0xd7, 0x1f, 0xcb, 0xb5, 0x3a, 0xc8, + 0x5d, 0xab, 0x75, 0xb1, 0x56, 0x29, 0xec, 0x2f, 0xba, 0x50, 0xc5, 0xf4, 0x42, 0x91, 0x35, 0xa8, + 0x1b, 0xc3, 0x2d, 0x73, 0xdd, 0x16, 0xb9, 0xf1, 0x11, 0x0d, 0xb7, 0xc7, 0x31, 0xfd, 0xcd, 0x97, + 0xf2, 0x26, 0x34, 0x92, 0x61, 0x8b, 0x75, 0x24, 0x50, 0x62, 0x84, 0x29, 0x1a, 0xc0, 0xff, 0xf6, + 0xbf, 0xb7, 0x38, 0xe2, 0x4e, 0xe0, 0x29, 0xbd, 0xc8, 0x10, 0x99, 0xfa, 0x94, 0x88, 0xec, 0xff, + 0x44, 0xbb, 0xe1, 0x37, 0x9f, 0x2c, 0x93, 0xbd, 0x4c, 0xee, 0xb6, 0xdd, 0x7e, 0x1f, 0xd5, 0x47, + 0xc5, 0x99, 0x61, 0xe5, 0xad, 0x7e, 0xdf, 0xbe, 0x05, 0x0b, 0xda, 0xe8, 0x5e, 0x31, 0x8f, 0x43, + 0x20, 0x07, 0x5e, 0x14, 0x3f, 0xf5, 0xa3, 0xa1, 0xa6, 0x76, 0xae, 0x42, 0x75, 0xe0, 0xf9, 0x38, + 0x32, 0xce, 0xb9, 0x65, 0xa7, 0x32, 0xf0, 0x7c, 0x36, 0xae, 0x08, 0x2b, 0xdd, 0x17, 0xa2, 0xb2, + 0x20, 0x2a, 0xdd, 0x17, 0x58, 0x69, 0xdf, 0x83, 0x45, 0xa3, 0x3d, 0xd1, 0xf5, 0x5b, 0x50, 0x1e, + 0xc5, 0x2f, 0x02, 0x69, 0x14, 0xd4, 0x04, 0x85, 0x30, 0xf3, 0xd2, 0xe1, 0x35, 0xf6, 0x7d, 0x58, + 0x38, 0xa4, 0x17, 0x82, 0x91, 0xe5, 0x40, 0x6e, 0x5e, 0x6a, 0x7a, 0x62, 0xbd, 0x7d, 0x1b, 0x88, + 0xfe, 0x71, 0xc2, 0x00, 0xd2, 0x10, 0xb5, 0x0c, 0x43, 0xd4, 0xbe, 0x09, 0xe4, 0xd8, 0xeb, 0xf9, + 0x1f, 0xd1, 0x28, 0x72, 0x7b, 0x8a, 0xf5, 0x1b, 0x50, 0x1c, 0x44, 0x3d, 0x21, 0xaa, 0xd8, 0x5f, + 0xfb, 0xab, 0xb0, 0x68, 0xe0, 0x89, 0x86, 0xaf, 0x41, 0x35, 0xf2, 0x7a, 0xbe, 0x1b, 0x8f, 0x42, + 0x2a, 0x9a, 0x4e, 0x00, 0xf6, 0x03, 0x58, 0xfa, 0x2e, 0x0d, 0xbd, 0xd3, 0xf1, 0x65, 0xcd, 0x9b, + 0xed, 0x14, 0xd2, 0xed, 0xec, 0xc1, 0x72, 0xaa, 0x1d, 0xd1, 0x3d, 0x27, 0x5f, 0xb1, 0x93, 0x15, + 0x87, 0x17, 0x34, 0xd9, 0x57, 0xd0, 0x65, 0x9f, 0xfd, 0x14, 0xc8, 0x4e, 0xe0, 0xfb, 0xb4, 0x13, + 0x1f, 0x51, 0x1a, 0x26, 0x3e, 0x70, 0x42, 0xab, 0xb5, 0xbb, 0xab, 0x62, 0x65, 0xd3, 0x02, 0x55, + 0x10, 0x31, 0x81, 0xd2, 0x90, 0x86, 0x03, 0x6c, 0xb8, 0xe2, 0xe0, 0x7f, 0x7b, 0x19, 0x16, 0x8d, + 0x66, 0x85, 0xd7, 0xf0, 0x2e, 0x2c, 0xef, 0x7a, 0x51, 0x27, 0xdb, 0x61, 0x13, 0x66, 0x86, 0xa3, + 0x93, 0x76, 0xc2, 0x89, 0xb2, 0xc8, 0x0c, 0xcd, 0xf4, 0x27, 0xa2, 0xb1, 0x7f, 0x6c, 0x41, 0x69, + 0xff, 0xc9, 0xc1, 0x0e, 0xd3, 0x15, 0x9e, 0xdf, 0x09, 0x06, 0x4c, 0x97, 0xf2, 0x49, 0xab, 0xf2, + 0x44, 0x0e, 0xbb, 0x06, 0x55, 0x54, 0xc1, 0xcc, 0x76, 0x16, 0xee, 0x6a, 0x02, 0x60, 0x76, 0x3b, + 0x7d, 0x31, 0xf4, 0x42, 0x34, 0xcc, 0xa5, 0xb9, 0x5d, 0x42, 0x35, 0x93, 0xad, 0xb0, 0x7f, 0x59, + 0x86, 0x19, 0xa1, 0x7c, 0xb1, 0xbf, 0x4e, 0xec, 0x9d, 0x53, 0x31, 0x12, 0x51, 0x62, 0xe6, 0x4d, + 0x48, 0x07, 0x41, 0x4c, 0xdb, 0xc6, 0x36, 0x98, 0x40, 0xf4, 0x4b, 0x84, 0xcb, 0xc8, 0x3d, 0x99, + 0x22, 0xc7, 0x32, 0x80, 0x6c, 0xb1, 0xa4, 0x59, 0x56, 0x42, 0xb3, 0x4c, 0x16, 0xd9, 0x4a, 0x74, + 0xdc, 0xa1, 0xdb, 0xf1, 0xe2, 0xb1, 0x10, 0x09, 0xaa, 0xcc, 0xda, 0xee, 0x07, 0x1d, 0x97, 0x39, + 0xa3, 0x7d, 0xd7, 0xef, 0x50, 0xe9, 0xf3, 0x18, 0x40, 0x66, 0xff, 0x8b, 0x21, 0x49, 0x34, 0xee, + 0x23, 0xa4, 0xa0, 0x4c, 0x7f, 0x77, 0x82, 0xc1, 0xc0, 0x8b, 0x99, 0xdb, 0x80, 0x26, 0x65, 0xd1, + 0xd1, 0x20, 0xdc, 0xc3, 0xc2, 0xd2, 0x05, 0x5f, 0xbd, 0xaa, 0xf4, 0xb0, 0x34, 0x20, 0x6b, 0x85, + 0x69, 0x1d, 0x26, 0xc6, 0x9e, 0x5f, 0xa0, 0xfd, 0x58, 0x74, 0x34, 0x08, 0xdb, 0x87, 0x91, 0x1f, + 0xd1, 0x38, 0xee, 0xd3, 0xae, 0x1a, 0x50, 0x0d, 0xd1, 0xb2, 0x15, 0xe4, 0x0e, 0x2c, 0x72, 0x4f, + 0x26, 0x72, 0xe3, 0x20, 0x3a, 0xf3, 0x22, 0x66, 0x79, 0xc6, 0xcd, 0x3a, 0xe2, 0xe7, 0x55, 0x91, + 0x7b, 0xb0, 0x9a, 0x02, 0x87, 0xb4, 0x43, 0xbd, 0x73, 0xda, 0x6d, 0xce, 0xe2, 0x57, 0x93, 0xaa, + 0xc9, 0x1a, 0xd4, 0x98, 0x03, 0x37, 0x1a, 0x76, 0x5d, 0x66, 0xc0, 0xcc, 0xe1, 0x3e, 0xe8, 0x20, + 0xf2, 0x2e, 0xcc, 0x0e, 0x29, 0xb7, 0x7e, 0xce, 0xe2, 0x7e, 0x27, 0x6a, 0xce, 0x1b, 0xd2, 0x8d, + 0x51, 0xae, 0x63, 0x62, 0x30, 0xa2, 0xec, 0x44, 0x68, 0xc9, 0xbb, 0xe3, 0x66, 0x43, 0x58, 0xd3, + 0x12, 0x80, 0x3c, 0x12, 0x7a, 0xe7, 0x6e, 0x4c, 0x9b, 0x0b, 0x5c, 0xa0, 0x8b, 0x22, 0xfb, 0xce, + 0xf3, 0xbd, 0xd8, 0x73, 0xe3, 0x20, 0x6c, 0x12, 0xac, 0x4b, 0x00, 0x6c, 0x11, 0x91, 0x3e, 0xa2, + 0xd8, 0x8d, 0x47, 0x51, 0xfb, 0xb4, 0xef, 0xf6, 0xa2, 0xe6, 0x22, 0xb7, 0x39, 0x33, 0x15, 0xf6, + 0x7f, 0xb4, 0xb8, 0x90, 0x16, 0x04, 0xad, 0x84, 0xed, 0x9b, 0x50, 0xe3, 0xa4, 0xdc, 0x0e, 0xfc, + 0xfe, 0x58, 0x50, 0x37, 0x70, 0xd0, 0x63, 0xbf, 0x3f, 0x26, 0x5f, 0x82, 0x59, 0xcf, 0xd7, 0x51, + 0xb8, 0x3c, 0xa8, 0x4b, 0x20, 0x22, 0xbd, 0x09, 0xb5, 0xe1, 0xe8, 0xa4, 0xef, 0x75, 0x38, 0x4a, + 0x91, 0xb7, 0xc2, 0x41, 0x88, 0xc0, 0xac, 0x68, 0x3e, 0x2b, 0x8e, 0x51, 0x42, 0x8c, 0x9a, 0x80, + 0x31, 0x14, 0x7b, 0x1b, 0x96, 0xcc, 0x01, 0x0a, 0xc1, 0xb7, 0x01, 0x15, 0xc1, 0x27, 0x51, 0xb3, + 0x86, 0x6b, 0x3d, 0xa7, 0x05, 0x5a, 0x7c, 0xda, 0x77, 0x54, 0xbd, 0xfd, 0x3f, 0x4b, 0xb0, 0x28, + 0xa0, 0x3b, 0xfd, 0x20, 0xa2, 0xc7, 0xa3, 0xc1, 0xc0, 0x0d, 0x73, 0x18, 0xd0, 0xba, 0x84, 0x01, + 0x0b, 0x26, 0x03, 0x32, 0xb6, 0x38, 0x73, 0x3d, 0x9f, 0xbb, 0x00, 0x9c, 0x7b, 0x35, 0x08, 0x59, + 0x87, 0xf9, 0x4e, 0x3f, 0x88, 0xb8, 0x49, 0xac, 0xfb, 0xf9, 0x69, 0x70, 0x56, 0x60, 0x94, 0xf3, + 0x04, 0x86, 0xce, 0xf0, 0xd3, 0x29, 0x86, 0xb7, 0xa1, 0xce, 0x1a, 0xa5, 0x52, 0x7e, 0xcd, 0x70, + 0x33, 0x59, 0x87, 0xb1, 0xf1, 0xa4, 0xd9, 0x8b, 0xf3, 0xf2, 0x7c, 0x1e, 0x73, 0x79, 0x03, 0x8a, + 0xf2, 0x51, 0xc3, 0xae, 0x0a, 0xe6, 0xca, 0x56, 0x91, 0x07, 0xcc, 0x39, 0x64, 0x7d, 0xa1, 0x92, + 0x06, 0x54, 0xd2, 0x37, 0xcd, 0x1d, 0xd1, 0xd7, 0xfe, 0x36, 0x2b, 0x8c, 0x42, 0x8a, 0x8a, 0x5b, + 0xfb, 0xd2, 0xfe, 0x67, 0x16, 0xd4, 0xb4, 0x3a, 0xb2, 0x0c, 0x0b, 0x3b, 0x8f, 0x1f, 0x1f, 0xed, + 0x39, 0x5b, 0x4f, 0x1e, 0x7d, 0x77, 0xaf, 0xbd, 0x73, 0xf0, 0xf8, 0x78, 0xaf, 0x31, 0xc5, 0xc0, + 0x07, 0x8f, 0x77, 0xb6, 0x0e, 0xda, 0x0f, 0x1e, 0x3b, 0x3b, 0x12, 0x6c, 0x91, 0x15, 0x20, 0xce, + 0xde, 0x47, 0x8f, 0x9f, 0xec, 0x19, 0xf0, 0x02, 0x69, 0x40, 0x7d, 0xdb, 0xd9, 0xdb, 0xda, 0xd9, + 0x17, 0x90, 0x22, 0x59, 0x82, 0xc6, 0x83, 0xa7, 0x87, 0xbb, 0x8f, 0x0e, 0x1f, 0xb6, 0x77, 0xb6, + 0x0e, 0x77, 0xf6, 0x0e, 0xf6, 0x76, 0x1b, 0x25, 0x32, 0x0b, 0xd5, 0xad, 0xed, 0xad, 0xc3, 0xdd, + 0xc7, 0x87, 0x7b, 0xbb, 0x8d, 0xb2, 0xfd, 0x7b, 0x16, 0x2c, 0xe3, 0xa8, 0xbb, 0x69, 0x06, 0x59, + 0x83, 0x5a, 0x27, 0x08, 0x86, 0xcc, 0x38, 0x4e, 0xc4, 0xbf, 0x0e, 0x62, 0xc4, 0xcf, 0x85, 0xed, + 0x69, 0x10, 0x76, 0xa8, 0xe0, 0x0f, 0x40, 0xd0, 0x03, 0x06, 0x61, 0xc4, 0x2f, 0xb6, 0x97, 0x63, + 0x70, 0xf6, 0xa8, 0x71, 0x18, 0x47, 0x59, 0x81, 0xe9, 0x93, 0x90, 0xba, 0x9d, 0x33, 0xc1, 0x19, + 0xa2, 0x44, 0xbe, 0x92, 0x78, 0x6f, 0x1d, 0xb6, 0xfa, 0x7d, 0xda, 0x45, 0x8a, 0xa9, 0x38, 0xf3, + 0x02, 0xbe, 0x23, 0xc0, 0x4c, 0x5a, 0xb8, 0x27, 0xae, 0xdf, 0x0d, 0x7c, 0xda, 0x15, 0xa6, 0x61, + 0x02, 0xb0, 0x8f, 0x60, 0x25, 0x3d, 0x3f, 0xc1, 0x5f, 0xef, 0x69, 0xfc, 0xc5, 0x2d, 0xb5, 0xd6, + 0xe4, 0xdd, 0xd4, 0x78, 0xed, 0xf7, 0x0b, 0x50, 0x62, 0x8a, 0x7b, 0xb2, 0x92, 0xd7, 0x6d, 0xb1, + 0x62, 0x26, 0x28, 0x88, 0x0e, 0x21, 0x17, 0xe5, 0x5c, 0xdd, 0x69, 0x90, 0xa4, 0x3e, 0xa4, 0x9d, + 0x73, 0x9c, 0xb1, 0xaa, 0x67, 0x10, 0xc6, 0x20, 0xcc, 0x50, 0xc6, 0xaf, 0x05, 0x83, 0xc8, 0xb2, + 0xac, 0xc3, 0x2f, 0x67, 0x92, 0x3a, 0xfc, 0xae, 0x09, 0x33, 0x9e, 0x7f, 0x12, 0x8c, 0xfc, 0x2e, + 0x32, 0x44, 0xc5, 0x91, 0x45, 0x0c, 0x43, 0x22, 0xa3, 0x7a, 0x03, 0x49, 0xfe, 0x09, 0x80, 0xdc, + 0x85, 0x6a, 0x34, 0xf6, 0x3b, 0x3a, 0xcd, 0x2f, 0x89, 0x55, 0x62, 0x6b, 0x70, 0xfb, 0x78, 0xec, + 0x77, 0x90, 0xc2, 0x13, 0x34, 0xfb, 0xdb, 0x50, 0x91, 0x60, 0x46, 0x96, 0x4f, 0x0f, 0x3f, 0x3c, + 0x7c, 0xfc, 0xec, 0xb0, 0x7d, 0xfc, 0xf1, 0xe1, 0x4e, 0x63, 0x8a, 0xcc, 0x43, 0x6d, 0x6b, 0x07, + 0x29, 0x1d, 0x01, 0x16, 0x43, 0x39, 0xda, 0x3a, 0x3e, 0x56, 0x90, 0x82, 0x4d, 0x98, 0xb3, 0x1b, + 0xa1, 0x75, 0xa4, 0xc2, 0x70, 0xef, 0xc1, 0x82, 0x06, 0x4b, 0x2c, 0xed, 0x21, 0x03, 0xa4, 0x2c, + 0x6d, 0x34, 0xab, 0x78, 0x8d, 0xdd, 0x80, 0xb9, 0x87, 0x34, 0x7e, 0xe4, 0x9f, 0x06, 0xb2, 0xa5, + 0xff, 0x52, 0x82, 0x79, 0x05, 0x12, 0x0d, 0xad, 0xc3, 0xbc, 0xd7, 0xa5, 0x7e, 0xec, 0xc5, 0xe3, + 0xb6, 0xe1, 0x53, 0xa7, 0xc1, 0xcc, 0x1c, 0x75, 0xfb, 0x9e, 0x2b, 0xa3, 0xbd, 0xbc, 0xc0, 0x7c, + 0x4c, 0xa6, 0x2b, 0xa5, 0xfa, 0x53, 0x74, 0xc5, 0x5d, 0xf9, 0xdc, 0x3a, 0x26, 0x81, 0x18, 0x5c, + 0xa8, 0x18, 0xf5, 0x09, 0x37, 0xcb, 0xf2, 0xaa, 0xd8, 0x56, 0xf1, 0x96, 0xd8, 0x94, 0xcb, 0x5c, + 0x9f, 0x2a, 0x40, 0x26, 0x9c, 0x3a, 0xcd, 0xe5, 0x63, 0x3a, 0x9c, 0xaa, 0x85, 0x64, 0x2b, 0x99, + 0x90, 0x2c, 0x93, 0x9f, 0x63, 0xbf, 0x43, 0xbb, 0xed, 0x38, 0x68, 0xa3, 0x9c, 0x47, 0x92, 0xa8, + 0x38, 0x69, 0x30, 0xb9, 0x06, 0x33, 0x31, 0x8d, 0x62, 0x9f, 0xf2, 0x38, 0x59, 0x65, 0xbb, 0xd0, + 0xb4, 0x1c, 0x09, 0x62, 0x36, 0xf4, 0x28, 0xf4, 0xa2, 0x66, 0x1d, 0x83, 0xad, 0xf8, 0x9f, 0x7c, + 0x0d, 0x96, 0x4f, 0x68, 0x14, 0xb7, 0xcf, 0xa8, 0xdb, 0xa5, 0x21, 0x92, 0x17, 0x8f, 0xea, 0x72, + 0xd3, 0x24, 0xbf, 0x92, 0x11, 0xee, 0x39, 0x0d, 0x23, 0x2f, 0xf0, 0xd1, 0x28, 0xa9, 0x3a, 0xb2, + 0xc8, 0xda, 0x63, 0x93, 0x57, 0x4a, 0x5a, 0xad, 0xe0, 0x3c, 0x4e, 0x3c, 0xbf, 0x92, 0xdc, 0x80, + 0x69, 0x9c, 0x40, 0xd4, 0x6c, 0x20, 0xcd, 0xd4, 0x13, 0x9e, 0xf7, 0x7c, 0x47, 0xd4, 0x7d, 0x50, + 0xaa, 0xd4, 0x1a, 0x75, 0xfb, 0x1b, 0x50, 0x46, 0x30, 0xdb, 0x74, 0xbe, 0x18, 0x9c, 0x28, 0x78, + 0x81, 0x0d, 0xcd, 0xa7, 0xf1, 0x45, 0x10, 0x3e, 0x97, 0xa1, 0x7f, 0x51, 0xb4, 0x7f, 0x88, 0x5e, + 0x88, 0x0a, 0x85, 0x3f, 0x45, 0x13, 0x8a, 0xf9, 0x92, 0x7c, 0xa9, 0xa3, 0x33, 0x57, 0x38, 0x46, + 0x15, 0x04, 0x1c, 0x9f, 0xb9, 0x4c, 0x56, 0x1a, 0xbb, 0xc7, 0x7d, 0xcd, 0x1a, 0xc2, 0xf6, 0xf9, + 0xe6, 0xdd, 0x80, 0x39, 0x19, 0x64, 0x8f, 0xda, 0x7d, 0x7a, 0x1a, 0xcb, 0x48, 0x91, 0x3f, 0x1a, + 0xa0, 0x43, 0x7a, 0x40, 0x4f, 0x63, 0xfb, 0x10, 0x16, 0x84, 0xfc, 0x7a, 0x3c, 0xa4, 0xb2, 0xeb, + 0x6f, 0xe6, 0xd9, 0x01, 0xb5, 0xbb, 0x8b, 0xa6, 0xc0, 0xe3, 0xc7, 0x0a, 0x26, 0xa6, 0xed, 0x00, + 0xd1, 0xe5, 0xa1, 0x68, 0x50, 0x28, 0x63, 0x19, 0x0b, 0x13, 0xd3, 0x31, 0x60, 0x6c, 0x7d, 0xa2, + 0x51, 0xa7, 0x23, 0x8f, 0x46, 0x98, 0xc7, 0xce, 0x8b, 0xf6, 0x7f, 0xb5, 0x60, 0x11, 0x5b, 0x93, + 0x96, 0x8c, 0xd0, 0x39, 0xf7, 0xbe, 0xc0, 0x30, 0xeb, 0x1d, 0x3d, 0x3e, 0xb8, 0x04, 0x65, 0x5d, + 0x0b, 0xf1, 0xc2, 0x17, 0x8f, 0x3b, 0x94, 0xd2, 0x71, 0x07, 0xfb, 0xdf, 0x5a, 0xb0, 0xc0, 0x15, + 0x01, 0x5a, 0x95, 0x62, 0xfa, 0x7f, 0x13, 0x66, 0xb9, 0x46, 0x17, 0x5c, 0x2d, 0x06, 0x9a, 0x88, + 0x46, 0x84, 0x72, 0xe4, 0xfd, 0x29, 0xc7, 0x44, 0x26, 0xf7, 0xd1, 0xaa, 0xf2, 0xdb, 0x08, 0xcd, + 0x39, 0x44, 0x33, 0xd7, 0x7a, 0x7f, 0xca, 0xd1, 0xd0, 0xb7, 0x2b, 0x30, 0xcd, 0x4d, 0x72, 0xfb, + 0x21, 0xcc, 0x1a, 0x1d, 0x19, 0x31, 0x8f, 0x3a, 0x8f, 0x79, 0x64, 0x82, 0x8b, 0x85, 0x9c, 0xe0, + 0xe2, 0x7f, 0x2f, 0x02, 0x61, 0xc4, 0x92, 0xda, 0x0d, 0xe6, 0x13, 0x04, 0x5d, 0xc3, 0xc3, 0xab, + 0x3b, 0x3a, 0x88, 0xdc, 0x06, 0xa2, 0x15, 0x65, 0xfc, 0x97, 0xab, 0xbc, 0x9c, 0x1a, 0x26, 0x26, + 0x85, 0xc5, 0x20, 0x74, 0xbb, 0xf0, 0x65, 0xf9, 0xb2, 0xe7, 0xd6, 0x31, 0xad, 0x36, 0x1c, 0x45, + 0x67, 0x18, 0xd9, 0x13, 0x3e, 0xa0, 0x2c, 0xa7, 0xf7, 0x77, 0xfa, 0xd2, 0xfd, 0x9d, 0xc9, 0xc4, + 0x95, 0x34, 0x2f, 0xa4, 0x62, 0x7a, 0x21, 0x37, 0x60, 0x76, 0xc0, 0xec, 0xdc, 0xb8, 0xdf, 0x69, + 0x0f, 0x58, 0xef, 0xc2, 0xe5, 0x33, 0x80, 0x64, 0x03, 0x1a, 0xc2, 0xc6, 0x49, 0x5c, 0x1d, 0x7e, + 0x70, 0x90, 0x81, 0x33, 0xf9, 0x9d, 0x44, 0x9a, 0x6a, 0x38, 0xd8, 0x04, 0xc0, 0xfc, 0x9a, 0x88, + 0x51, 0x48, 0x7b, 0xe4, 0x8b, 0x73, 0x34, 0xda, 0x45, 0x67, 0xaf, 0xe2, 0x64, 0x2b, 0xec, 0x7f, + 0x69, 0x41, 0x83, 0xed, 0x99, 0x41, 0x96, 0xef, 0x03, 0x72, 0xc5, 0x6b, 0x52, 0xa5, 0x81, 0x4b, + 0xee, 0x41, 0x15, 0xcb, 0xc1, 0x90, 0xfa, 0x82, 0x26, 0x9b, 0x26, 0x4d, 0x26, 0xf2, 0x64, 0x7f, + 0xca, 0x49, 0x90, 0x35, 0x8a, 0xfc, 0xff, 0x16, 0xd4, 0x44, 0x2f, 0xbf, 0x76, 0x24, 0xa3, 0xa5, + 0x1d, 0x7c, 0x72, 0x4a, 0x4a, 0xce, 0x39, 0xd7, 0x61, 0x7e, 0xe0, 0xc6, 0xa3, 0x90, 0xe9, 0x63, + 0x23, 0x8a, 0x91, 0x06, 0x33, 0xe5, 0x8a, 0xa2, 0x33, 0x6a, 0xc7, 0x5e, 0xbf, 0x2d, 0x6b, 0xc5, + 0x11, 0x63, 0x5e, 0x15, 0x93, 0x20, 0x51, 0xec, 0xf6, 0xa8, 0xd0, 0x9b, 0xbc, 0x60, 0x37, 0x61, + 0x45, 0x4c, 0x28, 0x65, 0x1f, 0xdb, 0xbf, 0xa8, 0xc3, 0x6a, 0xa6, 0x4a, 0x25, 0x44, 0x08, 0xf7, + 0xbc, 0xef, 0x0d, 0x4e, 0x02, 0xe5, 0x5c, 0x58, 0xba, 0xe7, 0x6e, 0x54, 0x91, 0x1e, 0x2c, 0x4b, + 0x03, 0x81, 0xad, 0x69, 0xa2, 0xcc, 0x0a, 0xa8, 0xa5, 0xde, 0x35, 0xb7, 0x30, 0xdd, 0xa1, 0x84, + 0xeb, 0x4c, 0x9c, 0xdf, 0x1e, 0x39, 0x83, 0xa6, 0xb2, 0x44, 0x84, 0xb0, 0xd6, 0xac, 0x15, 0xd6, + 0xd7, 0x3b, 0x97, 0xf4, 0x65, 0x98, 0xd3, 0xce, 0xc4, 0xd6, 0xc8, 0x18, 0xae, 0xcb, 0x3a, 0x94, + 0xc6, 0xd9, 0xfe, 0x4a, 0xaf, 0x35, 0x37, 0x74, 0x14, 0xcc, 0x4e, 0x2f, 0x69, 0x98, 0x7c, 0x0a, + 0x2b, 0x17, 0xae, 0x17, 0xcb, 0x61, 0x69, 0xb6, 0x41, 0x19, 0xbb, 0xbc, 0x7b, 0x49, 0x97, 0xcf, + 0xf8, 0xc7, 0x86, 0x8a, 0x9a, 0xd0, 0x62, 0xeb, 0x97, 0x16, 0xcc, 0x99, 0xed, 0x30, 0x32, 0x15, + 0xbc, 0x2f, 0x65, 0xa0, 0xb4, 0x26, 0x53, 0xe0, 0xac, 0x7f, 0x5e, 0xc8, 0xf3, 0xcf, 0x75, 0xaf, + 0xb8, 0x78, 0x59, 0x18, 0xac, 0xf4, 0x7a, 0x61, 0xb0, 0x72, 0x5e, 0x18, 0xac, 0xf5, 0xe7, 0x16, + 0x90, 0x2c, 0x2d, 0x91, 0x87, 0x3c, 0x40, 0xe0, 0xd3, 0xbe, 0x10, 0x29, 0x7f, 0xe3, 0xf5, 0xe8, + 0x51, 0xae, 0x9d, 0xfc, 0x9a, 0x31, 0x86, 0x9e, 0x23, 0xa0, 0x1b, 0x3b, 0xb3, 0x4e, 0x5e, 0x55, + 0x2a, 0x30, 0x57, 0xba, 0x3c, 0x30, 0x57, 0xbe, 0x3c, 0x30, 0x37, 0x9d, 0x0e, 0xcc, 0xb5, 0xfe, + 0x91, 0x05, 0x8b, 0x39, 0x9b, 0xfe, 0xdb, 0x9b, 0x38, 0xdb, 0x26, 0x43, 0x16, 0x14, 0xc4, 0x36, + 0xe9, 0xc0, 0xd6, 0xdf, 0x83, 0x59, 0x83, 0xd0, 0x7f, 0x7b, 0xfd, 0xa7, 0xed, 0x35, 0x4e, 0x67, + 0x06, 0xac, 0xf5, 0x27, 0x05, 0x20, 0x59, 0x66, 0xfb, 0x6b, 0x1d, 0x43, 0x76, 0x9d, 0x8a, 0x39, + 0xeb, 0xf4, 0x57, 0xaa, 0x07, 0xde, 0x81, 0x05, 0x91, 0xf8, 0xa4, 0x85, 0x85, 0x38, 0xc5, 0x64, + 0x2b, 0x98, 0xc5, 0x6a, 0x46, 0x45, 0x2b, 0x46, 0x22, 0x88, 0xa6, 0x0c, 0x53, 0xc1, 0x51, 0xbb, + 0x05, 0x4d, 0xb1, 0x42, 0x7b, 0xe7, 0xd4, 0x8f, 0x8f, 0x47, 0x27, 0x3c, 0xf3, 0xc7, 0x0b, 0x7c, + 0xfb, 0x7f, 0x14, 0x95, 0xd1, 0x8d, 0x95, 0x42, 0xbd, 0x7f, 0x0d, 0xea, 0xba, 0x30, 0x17, 0xdb, + 0x91, 0x8a, 0x0a, 0x32, 0xc5, 0xae, 0x63, 0x91, 0x5d, 0x98, 0x43, 0x91, 0xd5, 0x55, 0xdf, 0x15, + 0xf0, 0xbb, 0x57, 0x44, 0x3b, 0xf6, 0xa7, 0x9c, 0xd4, 0x37, 0xe4, 0x5b, 0x30, 0x67, 0xba, 0x52, + 0xc2, 0x46, 0xc8, 0xb3, 0xcd, 0xd9, 0xe7, 0x26, 0x32, 0xd9, 0x82, 0x46, 0xda, 0x17, 0x13, 0x59, + 0x00, 0x13, 0x1a, 0xc8, 0xa0, 0x93, 0x7b, 0xe2, 0x78, 0xac, 0x8c, 0x51, 0x88, 0x1b, 0xe6, 0x67, + 0xda, 0x32, 0xdd, 0xe6, 0x3f, 0xda, 0x81, 0xd9, 0xf7, 0x01, 0x12, 0x18, 0x69, 0x40, 0xfd, 0xf1, + 0xd1, 0xde, 0x61, 0x7b, 0x67, 0x7f, 0xeb, 0xf0, 0x70, 0xef, 0xa0, 0x31, 0x45, 0x08, 0xcc, 0x61, + 0xd0, 0x6c, 0x57, 0xc1, 0x2c, 0x06, 0x13, 0x61, 0x0a, 0x09, 0x2b, 0x90, 0x25, 0x68, 0x3c, 0x3a, + 0x4c, 0x41, 0x8b, 0xdb, 0x55, 0xc5, 0x1f, 0xf6, 0x0a, 0x2c, 0xf1, 0xc4, 0xb6, 0x6d, 0x4e, 0x1e, + 0xd2, 0x56, 0xf8, 0x0f, 0x16, 0x2c, 0xa7, 0x2a, 0x92, 0x34, 0x11, 0x6e, 0x0e, 0x98, 0x36, 0x82, + 0x09, 0xc4, 0x90, 0xb7, 0xb4, 0xfc, 0x52, 0x12, 0x24, 0x5b, 0xc1, 0x68, 0x5e, 0xb3, 0x14, 0x53, + 0x9c, 0x94, 0x57, 0x65, 0xaf, 0xf2, 0xf4, 0x3b, 0x4c, 0xd4, 0x33, 0x06, 0x7e, 0xca, 0x13, 0xe6, + 0xf4, 0x8a, 0xe4, 0xb8, 0xd1, 0x1c, 0xb2, 0x2c, 0x32, 0x23, 0xdf, 0x30, 0x3d, 0xcc, 0xf1, 0xe6, + 0xd6, 0xd9, 0xff, 0xa9, 0x00, 0xe4, 0x3b, 0x23, 0x1a, 0x8e, 0x31, 0x17, 0x44, 0xc5, 0x20, 0x57, + 0xd3, 0x11, 0xb6, 0xe9, 0xe1, 0xe8, 0xe4, 0x43, 0x3a, 0x96, 0x89, 0x4b, 0x85, 0x24, 0x71, 0x29, + 0x2f, 0x79, 0xa8, 0x74, 0x79, 0xf2, 0x50, 0xf9, 0xb2, 0xe4, 0xa1, 0x2f, 0xc1, 0xac, 0xd7, 0xf3, + 0x03, 0xc6, 0xf3, 0x4c, 0x6b, 0x47, 0xcd, 0xe9, 0xb5, 0x22, 0xf3, 0x74, 0x05, 0xf0, 0x90, 0xc1, + 0xc8, 0x37, 0x12, 0x24, 0xda, 0xed, 0x61, 0x22, 0x9a, 0x2e, 0x05, 0xf6, 0xba, 0x3d, 0x7a, 0x10, + 0x74, 0xdc, 0x38, 0x08, 0xd5, 0x87, 0x0c, 0x16, 0x31, 0x97, 0x3e, 0x0a, 0x46, 0xcc, 0x86, 0x91, + 0xf3, 0xe4, 0x31, 0x99, 0x3a, 0x87, 0x1e, 0xe1, 0x6c, 0x45, 0x4e, 0xcc, 0xc7, 0x50, 0xd3, 0x1a, + 0xc2, 0x5c, 0x25, 0x61, 0x25, 0x08, 0x97, 0xaf, 0xc4, 0x8d, 0x72, 0x9f, 0xf6, 0x1f, 0x75, 0xc9, + 0xdb, 0xb0, 0xd0, 0xf5, 0x42, 0x8a, 0x69, 0x67, 0xed, 0x90, 0x9e, 0xd3, 0x30, 0x92, 0xce, 0x71, + 0x43, 0x55, 0x38, 0x1c, 0x6e, 0xdf, 0x87, 0x45, 0x63, 0xf5, 0x15, 0x71, 0x4e, 0x63, 0x52, 0x8e, + 0x8c, 0xaf, 0x99, 0x09, 0x3b, 0xa2, 0xce, 0xfe, 0x27, 0x05, 0x28, 0xee, 0x07, 0x43, 0xfd, 0x14, + 0xc1, 0x32, 0x4f, 0x11, 0x84, 0x95, 0xd3, 0x56, 0x46, 0x8c, 0x50, 0x7e, 0x06, 0x90, 0x6c, 0xc0, + 0x9c, 0x3b, 0x88, 0xdb, 0x71, 0xc0, 0xac, 0xba, 0x0b, 0x37, 0xec, 0x72, 0x8a, 0xc5, 0xc0, 0x52, + 0xaa, 0x86, 0x2c, 0x41, 0x51, 0x99, 0x03, 0x88, 0xc0, 0x8a, 0xcc, 0xa5, 0xc0, 0xd3, 0xcc, 0xb1, + 0x08, 0x8e, 0x89, 0x12, 0x63, 0x08, 0xf3, 0x7b, 0xee, 0xcf, 0x71, 0xa1, 0x9e, 0x57, 0xc5, 0x2c, + 0x2e, 0x46, 0x23, 0x88, 0x26, 0x42, 0xa9, 0xb2, 0xac, 0x87, 0x7d, 0x2b, 0xe6, 0xd9, 0xee, 0x1f, + 0x5b, 0x50, 0xc6, 0xb5, 0x61, 0x0a, 0x8a, 0x73, 0xb0, 0x3a, 0x48, 0xc0, 0x35, 0x99, 0x75, 0xd2, + 0x60, 0x62, 0x1b, 0x09, 0x8c, 0x05, 0x35, 0x21, 0x3d, 0x89, 0x71, 0x0d, 0xaa, 0xbc, 0xa4, 0x92, + 0xf5, 0x10, 0x25, 0x01, 0x92, 0xeb, 0x50, 0x3a, 0x0b, 0x86, 0xd2, 0xa2, 0x06, 0x79, 0x26, 0x17, + 0x0c, 0x1d, 0x84, 0x27, 0xe3, 0x61, 0xed, 0xf1, 0x69, 0x71, 0x3b, 0x29, 0x0d, 0x66, 0x96, 0xa2, + 0x6a, 0x56, 0x5f, 0xa6, 0x14, 0xd4, 0xde, 0x80, 0x79, 0x46, 0xfb, 0x5a, 0x60, 0x75, 0x22, 0xb7, + 0xda, 0xff, 0xc0, 0x82, 0x8a, 0x44, 0x26, 0xeb, 0x50, 0x62, 0x8c, 0x94, 0xf2, 0x4d, 0xd5, 0x59, + 0x3c, 0xc3, 0x73, 0x10, 0x83, 0xd9, 0x0b, 0x18, 0xef, 0x4a, 0x5c, 0x21, 0x19, 0xed, 0x4a, 0x2c, + 0x7d, 0x35, 0xdc, 0x94, 0x81, 0x9c, 0x82, 0xda, 0x3f, 0xb7, 0x60, 0xd6, 0xe8, 0x83, 0xac, 0x41, + 0xad, 0xef, 0x46, 0xb1, 0x38, 0xdf, 0x14, 0xdb, 0xa3, 0x83, 0xf4, 0x8d, 0x2e, 0x98, 0xf1, 0x7d, + 0x15, 0x04, 0x2e, 0xea, 0x41, 0xe0, 0x3b, 0x50, 0x4d, 0xd2, 0x4c, 0x4b, 0x86, 0x04, 0x60, 0x3d, + 0xca, 0x2c, 0x83, 0x04, 0x09, 0xe3, 0x8a, 0x41, 0x3f, 0x08, 0xc5, 0x61, 0x18, 0x2f, 0xd8, 0xf7, + 0xa1, 0xa6, 0xe1, 0xeb, 0x61, 0x46, 0xcb, 0x08, 0x33, 0xaa, 0x14, 0x9c, 0x42, 0x92, 0x82, 0x63, + 0xff, 0xa9, 0x05, 0xb3, 0x8c, 0x06, 0x3d, 0xbf, 0x77, 0x14, 0xf4, 0xbd, 0xce, 0x18, 0xf7, 0x5e, + 0x92, 0x9b, 0x10, 0x8c, 0x92, 0x16, 0x4d, 0x30, 0xa3, 0x7a, 0x19, 0xdc, 0x10, 0x2c, 0xaa, 0xca, + 0x8c, 0x87, 0x19, 0x07, 0x9c, 0xb8, 0x91, 0x60, 0x0b, 0x61, 0x98, 0x19, 0x40, 0xc6, 0x69, 0x0c, + 0x80, 0x09, 0x55, 0x03, 0xaf, 0xdf, 0xf7, 0x38, 0x2e, 0x37, 0xdb, 0xf3, 0xaa, 0x58, 0x9f, 0x5d, + 0x2f, 0x72, 0x4f, 0x92, 0x03, 0x1e, 0x55, 0xc6, 0x08, 0x8c, 0xfb, 0x42, 0x8b, 0xc0, 0x4c, 0xa3, + 0x5c, 0x31, 0x81, 0xf6, 0xff, 0x2e, 0x40, 0x4d, 0x5a, 0x01, 0xdd, 0x1e, 0x15, 0x67, 0x96, 0xa6, + 0x60, 0xd4, 0x20, 0xb2, 0xde, 0x70, 0xb8, 0x34, 0x48, 0x9a, 0x30, 0x8a, 0x59, 0xc2, 0xb8, 0x06, + 0x55, 0x46, 0xa0, 0xef, 0xa2, 0x67, 0x27, 0x32, 0xb7, 0x15, 0x40, 0xd6, 0xde, 0xc5, 0xda, 0x72, + 0x52, 0x8b, 0x80, 0x57, 0x9e, 0x70, 0xde, 0x83, 0xba, 0x68, 0x06, 0x77, 0x0e, 0x25, 0x4f, 0xc2, + 0x22, 0xc6, 0xae, 0x3a, 0x06, 0xa6, 0xfc, 0xf2, 0xae, 0xfc, 0xb2, 0x72, 0xd9, 0x97, 0x12, 0xd3, + 0x7e, 0xa8, 0x0e, 0x8e, 0x1f, 0x86, 0xee, 0xf0, 0x4c, 0xf2, 0xf2, 0x1d, 0x58, 0xf4, 0xfc, 0x4e, + 0x7f, 0xd4, 0xa5, 0xed, 0x91, 0xef, 0xfa, 0x7e, 0x30, 0xf2, 0x3b, 0x54, 0xe6, 0xe0, 0xe4, 0x55, + 0xd9, 0x5d, 0x95, 0xb1, 0x89, 0x0d, 0x91, 0x0d, 0x28, 0x73, 0x85, 0xc9, 0x75, 0x47, 0x3e, 0xa3, + 0x73, 0x14, 0xb2, 0x0e, 0x65, 0xae, 0x37, 0x0b, 0x06, 0xd7, 0x68, 0xbb, 0xea, 0x70, 0x04, 0x26, + 0x76, 0x30, 0x57, 0xd7, 0x14, 0x3b, 0xa6, 0xde, 0x99, 0xee, 0x60, 0x36, 0xaf, 0xbd, 0x04, 0xe4, + 0x90, 0x73, 0x8a, 0x7e, 0xfc, 0xf3, 0x8b, 0x22, 0xd4, 0x34, 0x30, 0x93, 0x20, 0x3d, 0x36, 0xe0, + 0x76, 0xd7, 0x73, 0x07, 0x34, 0xa6, 0xa1, 0xe0, 0x8e, 0x14, 0x94, 0xe1, 0xb9, 0xe7, 0xbd, 0x76, + 0x30, 0x8a, 0xdb, 0x5d, 0xda, 0x0b, 0x29, 0xd7, 0xa6, 0x4c, 0x35, 0x19, 0x50, 0x86, 0xc7, 0xe8, + 0x53, 0xc3, 0xe3, 0x14, 0x94, 0x82, 0xca, 0xc3, 0x1c, 0xbe, 0x46, 0xa5, 0xe4, 0x30, 0x87, 0xaf, + 0x48, 0x5a, 0xf6, 0x95, 0x73, 0x64, 0xdf, 0x7b, 0xb0, 0xc2, 0xa5, 0x9c, 0x90, 0x07, 0xed, 0x14, + 0x61, 0x4d, 0xa8, 0x25, 0x1b, 0xd0, 0x60, 0x63, 0x96, 0x2c, 0x11, 0x79, 0x3f, 0xe4, 0x81, 0x51, + 0xcb, 0xc9, 0xc0, 0x19, 0x2e, 0x46, 0x28, 0x75, 0x5c, 0x7e, 0xa2, 0x9e, 0x81, 0x23, 0xae, 0xfb, + 0xc2, 0xc4, 0xad, 0x0a, 0xdc, 0x14, 0x9c, 0xdc, 0x83, 0xd5, 0x01, 0xed, 0x7a, 0xae, 0xd9, 0x04, + 0x06, 0x79, 0x79, 0xda, 0xcc, 0xa4, 0x6a, 0x7b, 0x16, 0x6a, 0xc7, 0x71, 0x30, 0x94, 0xdb, 0x39, + 0x07, 0x75, 0x5e, 0x14, 0x59, 0x54, 0x57, 0xe1, 0x0a, 0xd2, 0xdf, 0x93, 0x60, 0x18, 0xf4, 0x83, + 0xde, 0xd8, 0xf0, 0xab, 0xfe, 0x9f, 0x05, 0x8b, 0x46, 0x6d, 0xe2, 0x58, 0x61, 0x48, 0x46, 0xa6, + 0xbf, 0x70, 0x92, 0x5d, 0xd0, 0x84, 0x37, 0x47, 0xe4, 0xd1, 0xef, 0xa7, 0x22, 0x23, 0x66, 0x2b, + 0xb9, 0x10, 0x23, 0x3f, 0xe4, 0xf4, 0xdb, 0xcc, 0xd2, 0xaf, 0xf8, 0x5e, 0xde, 0x87, 0x91, 0x4d, + 0x7c, 0x4b, 0xe4, 0x34, 0x70, 0x3f, 0x4b, 0x46, 0xe0, 0x94, 0x67, 0xa6, 0xfb, 0xe1, 0x72, 0x04, + 0x1d, 0x05, 0x8c, 0xec, 0x1f, 0x59, 0x00, 0xc9, 0xe8, 0xf0, 0x24, 0x5c, 0x29, 0x20, 0x7e, 0xf9, + 0x4a, 0x53, 0x36, 0x6f, 0x41, 0x5d, 0x1d, 0x66, 0x26, 0x3a, 0xad, 0x26, 0x61, 0xcc, 0xac, 0xbe, + 0x05, 0xf3, 0xbd, 0x7e, 0x70, 0x82, 0x06, 0x01, 0xa6, 0xe5, 0x45, 0x22, 0x97, 0x6c, 0x8e, 0x83, + 0x1f, 0x08, 0x68, 0xa2, 0x00, 0x4b, 0x9a, 0x02, 0xb4, 0xff, 0x79, 0x41, 0x9d, 0x3d, 0x25, 0x73, + 0x9e, 0xc8, 0x9f, 0xe4, 0x6e, 0x46, 0x10, 0x4f, 0x38, 0xea, 0x41, 0xb3, 0xf6, 0xe8, 0xd2, 0x50, + 0xd8, 0x7d, 0x98, 0x0b, 0xb9, 0xa4, 0x93, 0x62, 0xb0, 0xf4, 0x0a, 0x31, 0x38, 0x1b, 0x1a, 0x5a, + 0xf2, 0x2b, 0xd0, 0x70, 0xbb, 0xe7, 0x34, 0x8c, 0x3d, 0x0c, 0x46, 0xa0, 0x89, 0xc2, 0x85, 0xf7, + 0xbc, 0x06, 0x47, 0xcb, 0xe1, 0x16, 0xcc, 0x8b, 0xfc, 0x3d, 0x85, 0x29, 0x2e, 0x34, 0x24, 0x60, + 0x86, 0x68, 0xff, 0x4c, 0x1e, 0x73, 0x99, 0x7b, 0x38, 0x79, 0x45, 0xf4, 0xd9, 0x15, 0x52, 0xb3, + 0xfb, 0x92, 0x38, 0x72, 0xea, 0xca, 0x88, 0x47, 0x51, 0xcb, 0x7f, 0xe9, 0x8a, 0x23, 0x42, 0x73, + 0x49, 0x4b, 0xaf, 0xb3, 0xa4, 0xf6, 0xaf, 0x2c, 0x98, 0xd9, 0x0f, 0x86, 0xfb, 0x22, 0x13, 0x08, + 0x19, 0x41, 0x25, 0xce, 0xca, 0xe2, 0x2b, 0x72, 0x84, 0x72, 0x2d, 0x83, 0xd9, 0xb4, 0x65, 0xf0, + 0xb7, 0xe1, 0x2a, 0xc6, 0xdb, 0xc2, 0x60, 0x18, 0x84, 0x8c, 0x19, 0xdd, 0x3e, 0x37, 0x03, 0x02, + 0x3f, 0x3e, 0x93, 0x02, 0xf0, 0x55, 0x28, 0xe8, 0x04, 0x33, 0xdf, 0x8e, 0x1b, 0xf5, 0xc2, 0x92, + 0xe1, 0x72, 0x31, 0x5b, 0x61, 0x7f, 0x13, 0xaa, 0x68, 0x8a, 0xe3, 0xb4, 0xde, 0x81, 0xea, 0x59, + 0x30, 0x6c, 0x9f, 0x79, 0x7e, 0x2c, 0x99, 0x7b, 0x2e, 0xb1, 0x91, 0xf7, 0x71, 0x41, 0x14, 0x82, + 0xfd, 0xaf, 0xa7, 0x61, 0xe6, 0x91, 0x7f, 0x1e, 0x78, 0x1d, 0x3c, 0x52, 0x1b, 0xd0, 0x41, 0x20, + 0xd3, 0x88, 0xd9, 0x7f, 0x72, 0x0d, 0x66, 0x30, 0x6f, 0x6e, 0xc8, 0x89, 0xb6, 0xce, 0x8f, 0xbe, + 0x05, 0x88, 0x99, 0x17, 0x61, 0x72, 0x99, 0x83, 0xb3, 0x8f, 0x06, 0x61, 0x4e, 0x4a, 0xa8, 0x5f, + 0xc6, 0x10, 0xa5, 0x24, 0x4d, 0xbb, 0xac, 0xa5, 0x69, 0xb3, 0xbe, 0x44, 0xe6, 0x12, 0x4f, 0x6d, + 0xe1, 0x7d, 0x09, 0x10, 0x3a, 0x56, 0x21, 0xe5, 0xf1, 0x52, 0x34, 0x56, 0x66, 0x84, 0x63, 0xa5, + 0x03, 0x99, 0x41, 0xc3, 0x3f, 0xe0, 0x38, 0x5c, 0x7c, 0xeb, 0x20, 0x66, 0x22, 0xa6, 0xaf, 0xe8, + 0x54, 0x39, 0xed, 0xa7, 0xc0, 0x4c, 0xc6, 0x77, 0xa9, 0x12, 0xa8, 0x7c, 0x1e, 0xc0, 0x2f, 0xac, + 0xa4, 0xe1, 0x9a, 0x3b, 0xc6, 0x53, 0x1c, 0xa5, 0x3b, 0xc6, 0x08, 0xc6, 0xed, 0xf7, 0x4f, 0xdc, + 0xce, 0x73, 0xbc, 0x81, 0x85, 0x87, 0x5c, 0x55, 0xc7, 0x04, 0x62, 0xfe, 0x51, 0xb2, 0xab, 0x98, + 0x24, 0x50, 0x72, 0x74, 0x10, 0xb9, 0x0b, 0x35, 0x74, 0x41, 0xc5, 0xbe, 0xce, 0xe1, 0xbe, 0x36, + 0x74, 0x1f, 0x15, 0x77, 0x56, 0x47, 0xd2, 0x8f, 0xfb, 0xe6, 0x33, 0x49, 0x87, 0x6e, 0xb7, 0x2b, + 0x4e, 0x49, 0x1b, 0xdc, 0x9d, 0x56, 0x00, 0xa6, 0x8f, 0xc5, 0x82, 0x71, 0x84, 0x05, 0x44, 0x30, + 0x60, 0xe4, 0x3a, 0x54, 0x98, 0x7b, 0x34, 0x74, 0xbd, 0x2e, 0x66, 0x2d, 0x72, 0x2f, 0x4d, 0xc1, + 0x58, 0x1b, 0xf2, 0x3f, 0x2a, 0xba, 0x45, 0x5c, 0x15, 0x03, 0xc6, 0xd6, 0x46, 0x95, 0x91, 0x99, + 0x96, 0xf8, 0x8e, 0x1a, 0x40, 0xf2, 0x2e, 0x9e, 0x55, 0xc5, 0xb4, 0xb9, 0x8c, 0xb1, 0xb0, 0xab, + 0x62, 0xce, 0x82, 0x68, 0xe5, 0xef, 0x31, 0x43, 0x71, 0x38, 0xa6, 0xbd, 0x05, 0x75, 0x1d, 0x4c, + 0x2a, 0x50, 0x7a, 0x7c, 0xb4, 0x77, 0xd8, 0x98, 0x22, 0x35, 0x98, 0x39, 0xde, 0x7b, 0xf2, 0xe4, + 0x60, 0x6f, 0xb7, 0x61, 0x91, 0x3a, 0x54, 0x54, 0xb2, 0x58, 0x81, 0x95, 0xb6, 0x76, 0x76, 0xf6, + 0x8e, 0x9e, 0xec, 0xed, 0x36, 0x8a, 0x76, 0x0c, 0x64, 0xab, 0xdb, 0x15, 0xad, 0xa8, 0x20, 0x41, + 0x42, 0xcf, 0x96, 0x41, 0xcf, 0x39, 0x34, 0x55, 0xc8, 0xa7, 0xa9, 0x57, 0xae, 0xbc, 0xbd, 0x07, + 0xb5, 0x23, 0xed, 0xce, 0x11, 0xb2, 0x97, 0xbc, 0x6d, 0x24, 0xd8, 0x52, 0x83, 0x68, 0xc3, 0x29, + 0xe8, 0xc3, 0xb1, 0xff, 0xb3, 0xc5, 0x93, 0xff, 0xd5, 0xf0, 0x79, 0xdf, 0x36, 0xd4, 0x55, 0x40, + 0x2a, 0xc9, 0x03, 0x35, 0x60, 0x0c, 0x07, 0x87, 0xd2, 0x0e, 0x4e, 0x4f, 0x23, 0x2a, 0xb3, 0xb6, + 0x0c, 0x18, 0xe3, 0x0b, 0x66, 0x9b, 0x31, 0x3b, 0xc7, 0xe3, 0x3d, 0x44, 0x22, 0x7b, 0x2b, 0x03, + 0x67, 0x52, 0x5e, 0x04, 0x64, 0x64, 0xbe, 0x9a, 0x2a, 0xab, 0x74, 0xd5, 0xf4, 0x2a, 0x6f, 0x40, + 0x45, 0xb5, 0x6b, 0x0a, 0x30, 0x89, 0xa9, 0xea, 0x99, 0xa0, 0x44, 0x6f, 0xc5, 0x18, 0x34, 0x17, + 0xda, 0xd9, 0x0a, 0x72, 0x1b, 0xc8, 0xa9, 0x17, 0xa6, 0xd1, 0x8b, 0x88, 0x9e, 0x53, 0x63, 0x3f, + 0x83, 0x45, 0x49, 0x48, 0x9a, 0x69, 0x65, 0x6e, 0xa2, 0x75, 0x19, 0xfb, 0x14, 0xb2, 0xec, 0x63, + 0xff, 0x85, 0x05, 0x33, 0x62, 0xa7, 0x33, 0xf7, 0xd6, 0xf8, 0x3e, 0x1b, 0x30, 0xd2, 0x34, 0xee, + 0xb5, 0x20, 0xaf, 0x09, 0xa1, 0x99, 0x11, 0x8b, 0xc5, 0x3c, 0xb1, 0x48, 0xa0, 0x34, 0x74, 0xe3, + 0x33, 0xf4, 0xd4, 0xab, 0x0e, 0xfe, 0x27, 0x0d, 0x1e, 0x57, 0xe2, 0x22, 0x18, 0x63, 0x4a, 0x79, + 0x37, 0xf4, 0xb8, 0xb6, 0xcf, 0xde, 0xd0, 0xbb, 0x06, 0x55, 0x1c, 0x40, 0x3b, 0x09, 0x1b, 0x25, + 0x00, 0x46, 0xb9, 0xbc, 0x80, 0x7c, 0x2d, 0x52, 0xcc, 0x13, 0x88, 0xbd, 0xcc, 0x77, 0x5e, 0x2c, + 0x81, 0x3a, 0x67, 0x16, 0xe9, 0xc1, 0x09, 0x38, 0xa1, 0x08, 0x31, 0x80, 0x34, 0x45, 0x08, 0x54, + 0x47, 0xd5, 0xdb, 0x2d, 0x68, 0xee, 0xd2, 0x3e, 0x8d, 0xe9, 0x56, 0xbf, 0x9f, 0x6e, 0xff, 0x2a, + 0x5c, 0xc9, 0xa9, 0x13, 0xd6, 0xf4, 0x77, 0x60, 0x79, 0x8b, 0xa7, 0x52, 0xfe, 0xb6, 0x32, 0x75, + 0xec, 0x26, 0xac, 0xa4, 0x9b, 0x14, 0x9d, 0x3d, 0x80, 0x85, 0x5d, 0x7a, 0x32, 0xea, 0x1d, 0xd0, + 0xf3, 0xa4, 0x23, 0x02, 0xa5, 0xe8, 0x2c, 0xb8, 0x10, 0x8c, 0x89, 0xff, 0xc9, 0x1b, 0x00, 0x7d, + 0x86, 0xd3, 0x8e, 0x86, 0xb4, 0x23, 0xaf, 0x92, 0x20, 0xe4, 0x78, 0x48, 0x3b, 0xf6, 0x7b, 0x40, + 0xf4, 0x76, 0xc4, 0x7a, 0x31, 0x2d, 0x38, 0x3a, 0x69, 0x47, 0xe3, 0x28, 0xa6, 0x03, 0x79, 0x47, + 0x46, 0x07, 0xd9, 0xb7, 0xa0, 0x7e, 0xe4, 0x8e, 0x1d, 0xfa, 0x99, 0xb8, 0xae, 0xb8, 0x0a, 0x33, + 0x43, 0x77, 0xcc, 0xc4, 0x94, 0x8a, 0x67, 0x61, 0xb5, 0xfd, 0x67, 0x05, 0x98, 0xe6, 0x98, 0xac, + 0xd5, 0x2e, 0x8d, 0x62, 0xcf, 0x47, 0xc2, 0x92, 0xad, 0x6a, 0xa0, 0x0c, 0x29, 0x17, 0x72, 0x48, + 0x59, 0x78, 0x7b, 0x32, 0x2d, 0x5f, 0xd0, 0xab, 0x01, 0x63, 0xc4, 0x95, 0xa4, 0xcc, 0xf1, 0x80, + 0x4a, 0x02, 0x48, 0x85, 0x3e, 0x13, 0x5d, 0xcb, 0xc7, 0x27, 0xb9, 0x54, 0x50, 0xae, 0x0e, 0xca, + 0xd5, 0xe8, 0x33, 0x9c, 0xc0, 0x33, 0x1a, 0x3d, 0xa3, 0xb9, 0x2b, 0xaf, 0xa1, 0xb9, 0xb9, 0x0b, + 0xf8, 0x2a, 0xcd, 0x0d, 0xaf, 0xa1, 0xb9, 0x6d, 0x02, 0x0d, 0xbc, 0xef, 0xc7, 0x6c, 0x43, 0x49, + 0xbb, 0x3f, 0xb1, 0xa0, 0x21, 0xa8, 0x48, 0xd5, 0x91, 0xb7, 0x0c, 0x1b, 0x38, 0x37, 0xe1, 0xfd, + 0x06, 0xcc, 0xa2, 0x65, 0xaa, 0x62, 0xbc, 0x22, 0x20, 0x6d, 0x00, 0xd9, 0x3c, 0xe4, 0x11, 0xf1, + 0xc0, 0xeb, 0x8b, 0x4d, 0xd1, 0x41, 0x32, 0x4c, 0x1c, 0xba, 0x22, 0x75, 0xcc, 0x72, 0x54, 0xd9, + 0xfe, 0x3f, 0x16, 0x2c, 0x68, 0x03, 0x16, 0x54, 0x78, 0x1f, 0x24, 0x37, 0xf0, 0x80, 0x2f, 0xe7, + 0xdc, 0x55, 0x93, 0x6d, 0x92, 0xcf, 0x0c, 0x64, 0xdc, 0x4c, 0x77, 0x8c, 0x03, 0x8c, 0x46, 0x03, + 0x21, 0x44, 0x75, 0x10, 0x23, 0xa4, 0x0b, 0x4a, 0x9f, 0x2b, 0x14, 0x2e, 0xc6, 0x0d, 0x18, 0x46, + 0xd5, 0x98, 0x45, 0xad, 0x90, 0x4a, 0x22, 0xaa, 0xa6, 0x03, 0xed, 0xdf, 0xb5, 0x60, 0x91, 0xbb, + 0x46, 0xc2, 0xf1, 0x54, 0x37, 0x9b, 0xa6, 0xb9, 0x2f, 0xc8, 0x39, 0x72, 0x7f, 0xca, 0x11, 0x65, + 0xf2, 0xf5, 0xd7, 0x74, 0xe7, 0x54, 0x3e, 0xdb, 0x84, 0xbd, 0x28, 0xe6, 0xed, 0xc5, 0x2b, 0x56, + 0x3a, 0x2f, 0xc0, 0x59, 0xce, 0x0d, 0x70, 0x6e, 0xcf, 0x40, 0x39, 0xea, 0x04, 0x43, 0x6a, 0xaf, + 0xc0, 0x92, 0x39, 0x39, 0x21, 0x82, 0x7e, 0x6a, 0x41, 0xf3, 0x01, 0x3f, 0x08, 0xf0, 0xfc, 0xde, + 0xbe, 0x17, 0xc5, 0x41, 0xa8, 0x2e, 0x80, 0x5e, 0x07, 0x88, 0x62, 0x37, 0x8c, 0x79, 0xaa, 0xb4, + 0x08, 0x2c, 0x26, 0x10, 0x36, 0x46, 0xea, 0x77, 0x79, 0x2d, 0xdf, 0x1b, 0x55, 0xce, 0xd8, 0x10, + 0xc2, 0x79, 0x33, 0x34, 0xf1, 0x4d, 0x9e, 0xdf, 0xc9, 0x6c, 0x05, 0x7a, 0x8e, 0x72, 0x9d, 0x7b, + 0x45, 0x29, 0xa8, 0xfd, 0x3b, 0x16, 0xcc, 0x27, 0x83, 0xc4, 0x93, 0x4f, 0x53, 0x3a, 0x08, 0xf5, + 0x9b, 0x48, 0x07, 0x19, 0xf2, 0xf4, 0x98, 0x3e, 0x16, 0x63, 0xd3, 0x20, 0xc8, 0xb1, 0xa2, 0x14, + 0x8c, 0xa4, 0x81, 0xa3, 0x83, 0x78, 0xb6, 0x16, 0xb3, 0x04, 0x84, 0x55, 0x23, 0x4a, 0x98, 0xe9, + 0x3e, 0x88, 0xf1, 0x2b, 0x1e, 0x9c, 0x95, 0x45, 0xa9, 0x4a, 0x67, 0x10, 0x8a, 0xaa, 0x54, 0x3f, + 0x54, 0xa9, 0xf0, 0xf5, 0x91, 0x65, 0xfb, 0x5f, 0x58, 0x70, 0x25, 0x67, 0xe1, 0x05, 0xd7, 0xec, + 0xc2, 0xc2, 0xa9, 0xaa, 0x94, 0x8b, 0xc3, 0x59, 0x67, 0x45, 0x1e, 0xdd, 0x99, 0x0b, 0xe2, 0x64, + 0x3f, 0x50, 0x76, 0x11, 0x5f, 0x6e, 0x23, 0x1f, 0x32, 0x5b, 0x61, 0x1f, 0x41, 0x6b, 0xef, 0x05, + 0x63, 0xc2, 0x1d, 0xfd, 0x09, 0x13, 0x49, 0x0b, 0x77, 0x33, 0x42, 0xe6, 0x72, 0x47, 0xfb, 0x14, + 0x66, 0x8d, 0xb6, 0xc8, 0x57, 0x5f, 0xb7, 0x91, 0x54, 0x78, 0x1a, 0x4b, 0xfc, 0x0d, 0x16, 0x99, + 0x95, 0xa9, 0x81, 0xec, 0x73, 0x98, 0xff, 0x68, 0xd4, 0x8f, 0xbd, 0xe4, 0x3d, 0x16, 0xf2, 0x75, + 0xf1, 0x11, 0x36, 0x21, 0x97, 0x2e, 0xb7, 0x2b, 0x1d, 0x8f, 0xad, 0xd8, 0x80, 0xb5, 0xd4, 0xce, + 0xf6, 0x98, 0xad, 0xb0, 0xaf, 0xc0, 0x6a, 0xd2, 0x25, 0x5f, 0x3b, 0x29, 0xa8, 0x7f, 0x66, 0xf1, + 0x84, 0x06, 0xf3, 0x79, 0x18, 0xf2, 0x10, 0x16, 0x23, 0xcf, 0xef, 0xf5, 0xa9, 0xde, 0x4e, 0x24, + 0x56, 0x62, 0xd9, 0x1c, 0x9e, 0x78, 0x42, 0xc6, 0xc9, 0xfb, 0x82, 0x11, 0x48, 0xfe, 0x40, 0x13, + 0x02, 0x49, 0x2d, 0x49, 0xde, 0x04, 0x3e, 0x80, 0x39, 0xb3, 0x33, 0x72, 0x4f, 0x24, 0x54, 0x26, + 0x23, 0xd3, 0x63, 0xd9, 0x26, 0x65, 0x18, 0x98, 0xf6, 0x8f, 0x2d, 0x68, 0x3a, 0x94, 0x91, 0x31, + 0xd5, 0x3a, 0x15, 0xd4, 0x73, 0x3f, 0xd3, 0xec, 0xe4, 0x09, 0xab, 0x44, 0x4d, 0x39, 0xd7, 0xdb, + 0x13, 0x37, 0x65, 0x7f, 0x2a, 0x67, 0x56, 0xdb, 0x15, 0x98, 0x16, 0xf3, 0x5b, 0x85, 0x65, 0x31, + 0x24, 0x39, 0x9c, 0x24, 0x68, 0x6a, 0x74, 0x6a, 0x04, 0x4d, 0x5b, 0xd0, 0xe4, 0x37, 0x73, 0xf5, + 0x79, 0xf0, 0x0f, 0x37, 0x5e, 0x42, 0x4d, 0xbb, 0x9f, 0x4c, 0x56, 0x61, 0xf1, 0xd9, 0xa3, 0x27, + 0x87, 0x7b, 0xc7, 0xc7, 0xed, 0xa3, 0xa7, 0xdb, 0x1f, 0xee, 0x7d, 0xdc, 0xde, 0xdf, 0x3a, 0xde, + 0x6f, 0x4c, 0x91, 0x15, 0x20, 0x87, 0x7b, 0xc7, 0x4f, 0xf6, 0x76, 0x0d, 0xb8, 0x45, 0xae, 0x43, + 0xeb, 0xe9, 0xe1, 0xd3, 0xe3, 0xbd, 0xdd, 0x76, 0xde, 0x77, 0x05, 0xf2, 0x06, 0x5c, 0x11, 0xf5, + 0x39, 0x9f, 0x17, 0xef, 0xfe, 0xb8, 0x08, 0x73, 0x3c, 0xaf, 0x82, 0xbf, 0x2a, 0x44, 0x43, 0xf2, + 0x11, 0xcc, 0x88, 0xe7, 0xa9, 0x88, 0x5c, 0x4f, 0xf3, 0x41, 0xac, 0xd6, 0x4a, 0x1a, 0x2c, 0x16, + 0x61, 0xf1, 0x1f, 0xfe, 0xea, 0x8f, 0xfe, 0x55, 0x61, 0x96, 0xd4, 0x36, 0xcf, 0xdf, 0xdd, 0xec, + 0x51, 0x3f, 0x62, 0x6d, 0x7c, 0x1f, 0x20, 0x79, 0x74, 0x89, 0x34, 0x95, 0xcf, 0x95, 0x7a, 0x91, + 0xaa, 0x75, 0x25, 0xa7, 0x46, 0xb4, 0x7b, 0x05, 0xdb, 0x5d, 0xb4, 0xe7, 0x58, 0xbb, 0x9e, 0xef, + 0xc5, 0xfc, 0x01, 0xa6, 0xf7, 0xad, 0x0d, 0xd2, 0x85, 0xba, 0xfe, 0x1c, 0x12, 0x91, 0x81, 0xdf, + 0x9c, 0x07, 0x9d, 0x5a, 0x57, 0x73, 0xeb, 0xe4, 0x06, 0x62, 0x1f, 0xcb, 0x76, 0x83, 0xf5, 0x31, + 0x42, 0x8c, 0xa4, 0x97, 0x3e, 0x27, 0xeb, 0xe4, 0xd5, 0x23, 0x72, 0x4d, 0xa3, 0xb4, 0xcc, 0x9b, + 0x4b, 0xad, 0x37, 0x26, 0xd4, 0x8a, 0xbe, 0xde, 0xc0, 0xbe, 0x56, 0x6d, 0xc2, 0xfa, 0xea, 0x20, + 0x8e, 0x7c, 0x73, 0xe9, 0x7d, 0x6b, 0xe3, 0xee, 0xbf, 0xb9, 0x09, 0x55, 0x75, 0xc8, 0x43, 0x3e, + 0x85, 0x59, 0x23, 0xf1, 0x85, 0xc8, 0x69, 0xe4, 0xe5, 0xc9, 0xb4, 0xae, 0xe5, 0x57, 0x8a, 0x8e, + 0xaf, 0x63, 0xc7, 0x4d, 0xb2, 0xc2, 0x3a, 0x16, 0x99, 0x23, 0x9b, 0x98, 0xc2, 0xc5, 0xef, 0x63, + 0x3c, 0xd7, 0xd8, 0x97, 0x77, 0x76, 0x2d, 0xcd, 0x51, 0x46, 0x6f, 0x6f, 0x4c, 0xa8, 0x15, 0xdd, + 0x5d, 0xc3, 0xee, 0x56, 0xc8, 0x92, 0xde, 0x9d, 0x3a, 0x7c, 0xa1, 0x78, 0x89, 0x48, 0x7f, 0x30, + 0x88, 0xbc, 0xa1, 0x08, 0x2b, 0xef, 0x21, 0x21, 0x45, 0x22, 0xd9, 0xd7, 0x84, 0xec, 0x26, 0x76, + 0x45, 0x08, 0x6e, 0x9f, 0xfe, 0x5e, 0x10, 0x39, 0x81, 0x9a, 0xf6, 0xda, 0x05, 0xb9, 0x32, 0xf1, + 0x65, 0x8e, 0x56, 0x2b, 0xaf, 0x2a, 0x6f, 0x2a, 0x7a, 0xfb, 0x9b, 0x4c, 0x2f, 0x7f, 0x0f, 0xaa, + 0xea, 0xfd, 0x04, 0xb2, 0xaa, 0xbd, 0x67, 0xa1, 0xbf, 0xf7, 0xd0, 0x6a, 0x66, 0x2b, 0xf2, 0x88, + 0x4f, 0x6f, 0x9d, 0x11, 0xdf, 0x33, 0xa8, 0x69, 0x6f, 0x24, 0xa8, 0x09, 0x64, 0xdf, 0x61, 0x50, + 0x13, 0xc8, 0x79, 0x52, 0xc1, 0x5e, 0xc0, 0x2e, 0x6a, 0xa4, 0x8a, 0xf4, 0x1d, 0xbf, 0x08, 0x22, + 0x72, 0x00, 0xcb, 0x42, 0x4c, 0x9d, 0xd0, 0x2f, 0xb2, 0x0d, 0x39, 0x6f, 0x34, 0xdd, 0xb1, 0xc8, + 0x7d, 0xa8, 0xc8, 0xa7, 0x30, 0xc8, 0x4a, 0xfe, 0x93, 0x1e, 0xad, 0xd5, 0x0c, 0x5c, 0x98, 0x27, + 0x1f, 0x03, 0x24, 0x0f, 0x32, 0x28, 0x21, 0x91, 0x79, 0xe0, 0x41, 0x51, 0x40, 0xf6, 0xf5, 0x06, + 0x7b, 0x05, 0x27, 0xd8, 0x20, 0x28, 0x24, 0x7c, 0x7a, 0x21, 0xef, 0x0b, 0xfe, 0x00, 0x6a, 0xda, + 0x9b, 0x0c, 0x6a, 0xf9, 0xb2, 0xef, 0x39, 0xa8, 0xe5, 0xcb, 0x79, 0xc2, 0xc1, 0x6e, 0x61, 0xeb, + 0x4b, 0xf6, 0x3c, 0x6b, 0x3d, 0xf2, 0x7a, 0xfe, 0x80, 0x23, 0xb0, 0x0d, 0x3a, 0x83, 0x59, 0xe3, + 0xe1, 0x05, 0xc5, 0xa1, 0x79, 0xcf, 0x3a, 0x28, 0x0e, 0xcd, 0x7d, 0xab, 0x41, 0xd2, 0x99, 0xbd, + 0xc0, 0xfa, 0x39, 0x47, 0x14, 0xad, 0xa7, 0x4f, 0xa0, 0xa6, 0x3d, 0xa2, 0xa0, 0xe6, 0x92, 0x7d, + 0xaf, 0x41, 0xcd, 0x25, 0xef, 0xcd, 0x85, 0x25, 0xec, 0x63, 0xce, 0x46, 0x52, 0xc0, 0x9b, 0x6f, + 0xac, 0xed, 0x4f, 0x61, 0xce, 0x7c, 0x56, 0x41, 0xf1, 0x7e, 0xee, 0x03, 0x0d, 0x8a, 0xf7, 0x27, + 0xbc, 0xc5, 0x20, 0x48, 0x7a, 0x63, 0x51, 0x75, 0xb2, 0xf9, 0xb9, 0x48, 0xfe, 0x78, 0x49, 0xbe, + 0xc3, 0x04, 0x9c, 0xb8, 0x8a, 0x48, 0x56, 0x35, 0xaa, 0xd5, 0x2f, 0x2c, 0x2a, 0x7e, 0xc9, 0xdc, + 0x5a, 0x34, 0x89, 0x99, 0xdf, 0xdd, 0x43, 0xad, 0x85, 0x57, 0x12, 0x35, 0xad, 0xa5, 0xdf, 0x5a, + 0xd4, 0xb4, 0x96, 0x71, 0x73, 0x31, 0xad, 0xb5, 0x62, 0x8f, 0xb5, 0xe1, 0xc3, 0x7c, 0x2a, 0x39, + 0x57, 0x71, 0x45, 0xfe, 0x6d, 0x86, 0xd6, 0xf5, 0x57, 0xe7, 0xf4, 0x9a, 0x12, 0x44, 0x0a, 0xc1, + 0x4d, 0x79, 0x77, 0xe4, 0xef, 0x42, 0x5d, 0xbf, 0xc2, 0x4e, 0x74, 0x56, 0x4e, 0xf7, 0x74, 0x35, + 0xb7, 0xce, 0xdc, 0x5c, 0x52, 0xd7, 0xbb, 0x21, 0xdf, 0x85, 0x15, 0xc5, 0xea, 0x7a, 0xbe, 0x67, + 0x44, 0xde, 0xcc, 0xc9, 0x02, 0xd5, 0x8d, 0x97, 0xd6, 0x95, 0x89, 0x69, 0xa2, 0x77, 0x2c, 0x46, + 0x34, 0xe6, 0xdd, 0xe0, 0x44, 0x61, 0xe4, 0x5d, 0x89, 0x4e, 0x14, 0x46, 0xee, 0x85, 0x62, 0x49, + 0x34, 0x64, 0xd1, 0x58, 0x23, 0x7e, 0x3e, 0x47, 0x3e, 0x81, 0x79, 0x2d, 0xa3, 0xfe, 0x78, 0xec, + 0x77, 0x14, 0x03, 0x64, 0xaf, 0x5e, 0xb5, 0xf2, 0x4c, 0x73, 0x7b, 0x15, 0xdb, 0x5f, 0xb0, 0x8d, + 0xc5, 0x61, 0xc4, 0xbf, 0x03, 0x35, 0x3d, 0x5b, 0xff, 0x15, 0xed, 0xae, 0x6a, 0x55, 0xfa, 0xcd, + 0xa1, 0x3b, 0x16, 0xf9, 0x77, 0x16, 0xd4, 0x8d, 0xdc, 0x77, 0xe3, 0x14, 0x3a, 0xd5, 0x4e, 0x53, + 0xaf, 0xd3, 0x1b, 0xb2, 0x1d, 0x1c, 0xe4, 0xc1, 0xc6, 0x07, 0xc6, 0x22, 0x7c, 0x6e, 0xc4, 0x5f, + 0x6e, 0xa7, 0x9f, 0xdf, 0x7a, 0x99, 0x46, 0xd0, 0xaf, 0xa7, 0xbd, 0xbc, 0x63, 0x91, 0x9f, 0x5b, + 0x30, 0x67, 0x46, 0x0d, 0xd5, 0x56, 0xe5, 0xc6, 0x27, 0xd5, 0x56, 0x4d, 0x08, 0x35, 0x7e, 0x82, + 0xa3, 0x7c, 0xb2, 0xe1, 0x18, 0xa3, 0x14, 0xb7, 0xc6, 0x7f, 0xb3, 0xd1, 0x92, 0xf7, 0xf9, 0xc3, + 0x7c, 0x32, 0x94, 0x4d, 0x34, 0xad, 0x91, 0xde, 0x5e, 0xfd, 0xc5, 0xb8, 0x75, 0xeb, 0x8e, 0x45, + 0x7e, 0xc0, 0x9f, 0x9d, 0x12, 0xdf, 0x22, 0x95, 0xbc, 0xee, 0xf7, 0xf6, 0x0d, 0x9c, 0xd3, 0x75, + 0xfb, 0x8a, 0x31, 0xa7, 0xb4, 0x3e, 0xde, 0xe2, 0xa3, 0x13, 0x8f, 0xbd, 0x25, 0x0a, 0x25, 0xf3, + 0x00, 0xdc, 0xe4, 0x41, 0x0e, 0xf8, 0x20, 0x05, 0xba, 0x41, 0xca, 0xaf, 0xd9, 0x8c, 0xbd, 0x81, + 0x63, 0xbd, 0x61, 0xbf, 0x39, 0x71, 0xac, 0x9b, 0x18, 0xfb, 0x63, 0x23, 0x3e, 0x02, 0x48, 0x8e, + 0x9d, 0x48, 0xea, 0xd8, 0x43, 0x31, 0x78, 0xf6, 0x64, 0xca, 0xe4, 0x17, 0x79, 0x3a, 0xc2, 0x5a, + 0xfc, 0x1e, 0x17, 0x57, 0x8f, 0xe4, 0x81, 0x89, 0x6e, 0x94, 0x98, 0xe7, 0x43, 0x86, 0x51, 0x92, + 0x6e, 0xdf, 0x10, 0x56, 0xea, 0xf4, 0xe5, 0x29, 0xcc, 0x1e, 0x04, 0xc1, 0xf3, 0xd1, 0x50, 0x1d, + 0x21, 0x9b, 0x61, 0xf9, 0x7d, 0x37, 0x3a, 0x6b, 0xa5, 0x66, 0x61, 0xaf, 0x61, 0x53, 0x2d, 0xd2, + 0xd4, 0x9a, 0xda, 0xfc, 0x3c, 0x39, 0xd6, 0x7a, 0x49, 0x5c, 0x58, 0x50, 0x32, 0x50, 0x0d, 0xbc, + 0x65, 0x36, 0x63, 0x48, 0xbe, 0x74, 0x17, 0x86, 0xf5, 0x2c, 0x47, 0xbb, 0x19, 0xc9, 0x36, 0xef, + 0x58, 0xe4, 0x08, 0xea, 0xbb, 0xb4, 0x13, 0x74, 0xa9, 0x88, 0x6d, 0x2f, 0x26, 0x03, 0x57, 0x41, + 0xf1, 0xd6, 0xac, 0x01, 0x34, 0xf5, 0xc2, 0xd0, 0x1d, 0x87, 0xf4, 0xb3, 0xcd, 0xcf, 0x45, 0xd4, + 0xfc, 0xa5, 0xd4, 0x0b, 0xf2, 0x58, 0xc1, 0xd0, 0x0b, 0xa9, 0x73, 0x08, 0x43, 0x2f, 0x64, 0xce, + 0x21, 0x8c, 0xa5, 0x96, 0xc7, 0x1a, 0xa4, 0x0f, 0x0b, 0x99, 0xa3, 0x0b, 0xa5, 0x12, 0x26, 0x1d, + 0x78, 0xb4, 0xd6, 0x26, 0x23, 0x98, 0xbd, 0x6d, 0x98, 0xbd, 0x1d, 0xc3, 0xec, 0x2e, 0xe5, 0x8b, + 0xc5, 0x33, 0xdc, 0x52, 0x17, 0x28, 0xf4, 0xfc, 0xb9, 0xb4, 0x00, 0xc7, 0x3a, 0x53, 0xf1, 0x63, + 0x7a, 0x19, 0xf9, 0x1e, 0xd4, 0x1e, 0xd2, 0x58, 0xa6, 0xb4, 0x29, 0xd3, 0x33, 0x95, 0xe3, 0xd6, + 0xca, 0xc9, 0x88, 0x33, 0x69, 0x06, 0x5b, 0xdb, 0xa4, 0xdd, 0x1e, 0xe5, 0xc2, 0xa9, 0xed, 0x75, + 0x5f, 0x92, 0xbf, 0x83, 0x8d, 0xab, 0xcc, 0xdb, 0x15, 0x2d, 0x9f, 0x49, 0x6f, 0x7c, 0x3e, 0x05, + 0xcf, 0x6b, 0xd9, 0x0f, 0xba, 0x54, 0x33, 0x81, 0x7c, 0xa8, 0x69, 0x09, 0xe3, 0x8a, 0x81, 0xb2, + 0x29, 0xfc, 0x8a, 0x81, 0x72, 0xf2, 0xcb, 0xed, 0x75, 0xec, 0xc7, 0x26, 0x6b, 0x49, 0x3f, 0x3c, + 0xa7, 0x3c, 0xe9, 0x69, 0xf3, 0x73, 0x77, 0x10, 0xbf, 0x24, 0xcf, 0xf0, 0x15, 0x07, 0x3d, 0x6d, + 0x2f, 0xb1, 0xa5, 0xd3, 0x19, 0x7e, 0x6a, 0xb1, 0xb4, 0x2a, 0xd3, 0xbe, 0xe6, 0x5d, 0xa1, 0xa5, + 0xf4, 0x75, 0x80, 0xe3, 0x38, 0x18, 0xee, 0xba, 0x74, 0x10, 0xf8, 0x89, 0xac, 0x4d, 0x12, 0xcc, + 0x12, 0xf9, 0xa5, 0x65, 0x99, 0x91, 0x67, 0x9a, 0xf3, 0x61, 0x64, 0x3d, 0x4a, 0xe2, 0x9a, 0x98, + 0x83, 0xa6, 0x16, 0x24, 0x27, 0x0f, 0xed, 0x8e, 0x45, 0xb6, 0x00, 0x92, 0xb3, 0x2b, 0xe5, 0x4a, + 0x64, 0x8e, 0xc5, 0x94, 0xd8, 0xcb, 0x39, 0xe8, 0x3a, 0x82, 0x6a, 0x72, 0x18, 0xb2, 0x9a, 0xdc, + 0x6c, 0x30, 0x8e, 0x4e, 0x94, 0x06, 0xcf, 0x1c, 0x51, 0xd8, 0x0d, 0x5c, 0x2a, 0x20, 0x15, 0xb6, + 0x54, 0x78, 0xee, 0xe0, 0xc1, 0x22, 0x1f, 0xa0, 0x32, 0x47, 0x30, 0x65, 0x4a, 0xce, 0x24, 0xe7, + 0x98, 0x40, 0x71, 0x73, 0x6e, 0x94, 0xdd, 0x88, 0x88, 0x30, 0x6a, 0xe5, 0xe9, 0x5a, 0x4c, 0x34, + 0x0f, 0x60, 0x21, 0x13, 0x06, 0x56, 0x2c, 0x3d, 0x29, 0x32, 0xaf, 0x58, 0x7a, 0x62, 0x04, 0xd9, + 0x5e, 0xc6, 0x2e, 0xe7, 0x6d, 0x40, 0x0f, 0xe8, 0xc2, 0x8b, 0x3b, 0x67, 0xac, 0xbb, 0x9f, 0x59, + 0xb0, 0x98, 0x13, 0xe5, 0x25, 0x6f, 0x49, 0x67, 0x7a, 0x62, 0x04, 0xb8, 0x95, 0x1b, 0x04, 0xb4, + 0x8f, 0xb1, 0x9f, 0x8f, 0xc8, 0x87, 0x86, 0x62, 0xe3, 0xf1, 0x37, 0xc1, 0x99, 0xaf, 0x34, 0x2a, + 0x72, 0x2d, 0x8a, 0xcf, 0x60, 0x95, 0x0f, 0x64, 0xab, 0xdf, 0x4f, 0x05, 0x28, 0xaf, 0x67, 0xde, + 0xde, 0x36, 0x02, 0xaf, 0xad, 0xc9, 0x6f, 0x73, 0x4f, 0x30, 0x57, 0xf9, 0x50, 0xc9, 0x08, 0x1a, + 0xe9, 0xa0, 0x1f, 0x99, 0xdc, 0x56, 0xeb, 0x4d, 0xc3, 0x2d, 0xcc, 0x06, 0x0a, 0xed, 0x2f, 0x63, + 0x67, 0x6f, 0xda, 0xad, 0xbc, 0x75, 0xe1, 0x9e, 0x22, 0xdb, 0x8f, 0xbf, 0xaf, 0x22, 0x94, 0xa9, + 0x79, 0xca, 0x0e, 0x26, 0x85, 0x54, 0x95, 0x63, 0x9a, 0x1f, 0xe0, 0xbc, 0x89, 0xdd, 0xaf, 0xd9, + 0x57, 0xf3, 0xba, 0x0f, 0xf9, 0x27, 0xdc, 0x45, 0x5d, 0x4d, 0xf3, 0xb5, 0x1c, 0xc1, 0x5a, 0xde, + 0x7e, 0x4f, 0xf4, 0x35, 0x52, 0x6b, 0x3d, 0x75, 0xc7, 0xda, 0xbe, 0xf5, 0xc9, 0x97, 0x7b, 0x5e, + 0x7c, 0x36, 0x3a, 0xb9, 0xdd, 0x09, 0x06, 0x9b, 0x7d, 0x19, 0x22, 0x13, 0xe9, 0xb9, 0x9b, 0x7d, + 0xbf, 0xbb, 0x89, 0xdf, 0x9f, 0x4c, 0xe3, 0x53, 0xfe, 0x5f, 0xfd, 0xcb, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xfa, 0x33, 0x1d, 0xc9, 0xfc, 0x5f, 0x00, 0x00, } diff --git a/lnrpc/rpc.proto b/lnrpc/rpc.proto index 95edc39277..0d516da9b7 100644 --- a/lnrpc/rpc.proto +++ b/lnrpc/rpc.proto @@ -880,6 +880,14 @@ message SendRequest { maximum enforced. */ uint32 cltv_limit = 10; + + /* + If set, then no payment hash is required. Instead, we will generate a + payment hash ourselves, and encode the pre-image in an EOB encrypted to the + final hop. Not that the payment request MUST NOT be specified in order for + this flag to be parsed. If set, then the dest MUST be set. + */ + bool key_send = 11; } message SendResponse { diff --git a/lnrpc/rpc.swagger.json b/lnrpc/rpc.swagger.json index 0c1f8f8644..15869af98f 100644 --- a/lnrpc/rpc.swagger.json +++ b/lnrpc/rpc.swagger.json @@ -3182,6 +3182,11 @@ "type": "integer", "format": "int64", "description": "* \nAn optional maximum total time lock for the route. If zero, there is no\nmaximum enforced." + }, + "key_send": { + "type": "boolean", + "format": "boolean", + "description": "If set, then no payment hash is required. Instead, we will generate a\npayment hash ourselves, and encode the pre-image in an EOB encrypted to the\nfinal hop. Not that the payment request MUST NOT be specified in order for\nthis flag to be parsed. If set, then the dest MUST be set." } } }, From 9eef7124341e3c5dad3bae80114b94d5e8f582e5 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 10 Jan 2019 21:30:38 -0800 Subject: [PATCH 09/14] cmd/lncli: add parsing for new key_send option to sendpayment --- cmd/lncli/commands.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/cmd/lncli/commands.go b/cmd/lncli/commands.go index 07b0a6a1fc..189c6eb170 100644 --- a/cmd/lncli/commands.go +++ b/cmd/lncli/commands.go @@ -2077,6 +2077,10 @@ var sendPaymentCommand = cli.Command{ Name: "force, f", Usage: "will skip payment request confirmation", }, + cli.BoolFlag{ + Name: "key_send", + Usage: "will generate a pre-image and encode it in the sphinx packet, a dest must be set", + }, }, Action: sendPayment, } @@ -2215,11 +2219,12 @@ func sendPayment(ctx *cli.Context) error { Dest: destNode, Amt: amount, FeeLimit: feeLimit, + KeySend: ctx.Bool("key_send"), } if ctx.Bool("debug_send") && (ctx.IsSet("payment_hash") || args.Present()) { return fmt.Errorf("do not provide a payment hash with debug send") - } else if !ctx.Bool("debug_send") { + } else if !ctx.Bool("debug_send") && !ctx.Bool("key_send") { var rHash []byte switch { From 2265ca3f5cbb37e2c762b19480cb2a72f3a1dce9 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 10 Jan 2019 21:31:38 -0800 Subject: [PATCH 10/14] rpc: add keysend payment preimage generation --- rpcserver.go | 49 ++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 46 insertions(+), 3 deletions(-) diff --git a/rpcserver.go b/rpcserver.go index 544393a28e..d3743df298 100644 --- a/rpcserver.go +++ b/rpcserver.go @@ -2,6 +2,7 @@ package lnd import ( "bytes" + crand "crypto/rand" "crypto/sha256" "crypto/tls" "encoding/hex" @@ -16,9 +17,6 @@ import ( "sync/atomic" "time" - "github.com/lightningnetwork/lnd/lnrpc/routerrpc" - "github.com/lightningnetwork/lnd/routing/route" - "github.com/btcsuite/btcd/blockchain" "github.com/btcsuite/btcd/btcec" "github.com/btcsuite/btcd/chaincfg/chainhash" @@ -42,13 +40,17 @@ import ( "github.com/lightningnetwork/lnd/lncfg" "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lnrpc/invoicesrpc" + "github.com/lightningnetwork/lnd/lnrpc/routerrpc" "github.com/lightningnetwork/lnd/lntypes" "github.com/lightningnetwork/lnd/lnwallet" "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/macaroons" "github.com/lightningnetwork/lnd/routing" + "github.com/lightningnetwork/lnd/routing/route" "github.com/lightningnetwork/lnd/signal" "github.com/lightningnetwork/lnd/sweep" + "github.com/lightningnetwork/lnd/tlv" + "github.com/lightningnetwork/lnd/watchtower/wtwire" "github.com/lightningnetwork/lnd/zpay32" "github.com/tv42/zbase32" "golang.org/x/net/context" @@ -2900,6 +2902,8 @@ type rpcPaymentIntent struct { routeHints [][]zpay32.HopHint outgoingChannelID *uint64 + eob []byte + route *route.Route } @@ -3026,6 +3030,41 @@ func extractPaymentIntent(rpcPayReq *rpcPaymentRequest) (rpcPaymentIntent, error // If the user is manually specifying payment details, then the payment // hash may be encoded as a string. switch { + // A sphinx send, so we should generate an EOB with the preimage. + case rpcPayReq.KeySend: + // TODO(roasbeef): make deterministic? also saves I/O of /dev/random + var preImage [32]byte + _, err := io.ReadFull(crand.Reader, preImage[:]) + if err != nil { + return payIntent, err + } + + rpcsLog.Infof("Sphinx payment! preimage=%x", preImage[:]) + + // Now that we have our pre-image, we'll encode it as a TLV + // record into a temporary bytes buffer that will become our + // final TLV stream. + var b bytes.Buffer + tlvStream := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord( + invoices.PreimageTLV, &preImage, + ), + tlv.MakeSentinelRecord(), + ) + if err := tlvStream.Encode(&b); err != nil { + return payIntent, err + } + + // Populate the EOB to the final hop which indicates that this + // is a spontaneous payment. + rpcsLog.Infof("TLV bytes: %x", b.Bytes()) + payIntent.eob = b.Bytes() + + // We'll also set the payment hash accordingly. + payHash := sha256.Sum256(preImage[:]) + copy(payIntent.rHash[:], payHash[:]) + case rpcPayReq.PaymentHashString != "": paymentHash, err := hex.DecodeString( rpcPayReq.PaymentHashString, @@ -3097,6 +3136,10 @@ func (r *rpcServer) dispatchPaymentIntent( OutgoingChannelID: payIntent.outgoingChannelID, } + if payIntent.eob != nil { + payment.DestinationEOB = payIntent.eob + } + // If the final CLTV value was specified, then we'll use that // rather than the default. if payIntent.cltvDelta != 0 { From c9a38a8fb955b325c4bcf4233659650320091f8c Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 16 May 2019 21:06:24 -0700 Subject: [PATCH 11/14] multi: extend NotifyExitHop to accept an opauqe EOB --- contractcourt/htlc_incoming_contest_resolver.go | 2 +- contractcourt/interfaces.go | 3 ++- htlcswitch/interfaces.go | 3 ++- htlcswitch/link.go | 5 ++--- htlcswitch/mock.go | 9 +++++---- invoices/invoiceregistry.go | 4 +++- 6 files changed, 15 insertions(+), 11 deletions(-) diff --git a/contractcourt/htlc_incoming_contest_resolver.go b/contractcourt/htlc_incoming_contest_resolver.go index 9af694d68a..54bccab522 100644 --- a/contractcourt/htlc_incoming_contest_resolver.go +++ b/contractcourt/htlc_incoming_contest_resolver.go @@ -166,7 +166,7 @@ func (h *htlcIncomingContestResolver) Resolve() (ContractResolver, error) { // identical to HTLC resolution in the link. event, err := h.Registry.NotifyExitHopHtlc( h.payHash, h.htlcAmt, h.htlcExpiry, currentHeight, - hodlChan, + hodlChan, nil, ) switch err { case channeldb.ErrInvoiceNotFound: diff --git a/contractcourt/interfaces.go b/contractcourt/interfaces.go index a18ee3d6c6..e0254e967b 100644 --- a/contractcourt/interfaces.go +++ b/contractcourt/interfaces.go @@ -22,7 +22,8 @@ type Registry interface { // the resolution is sent on the passed in hodlChan later. NotifyExitHopHtlc(payHash lntypes.Hash, paidAmount lnwire.MilliSatoshi, expiry uint32, currentHeight int32, - hodlChan chan<- interface{}) (*invoices.HodlEvent, error) + hodlChan chan<- interface{}, + destEOB []byte) (*invoices.HodlEvent, error) // HodlUnsubscribeAll unsubscribes from all hodl events. HodlUnsubscribeAll(subscriber chan<- interface{}) diff --git a/htlcswitch/interfaces.go b/htlcswitch/interfaces.go index 68350f62f3..eb700567ab 100644 --- a/htlcswitch/interfaces.go +++ b/htlcswitch/interfaces.go @@ -25,7 +25,8 @@ type InvoiceDatabase interface { // the resolution is sent on the passed in hodlChan later. NotifyExitHopHtlc(payHash lntypes.Hash, paidAmount lnwire.MilliSatoshi, expiry uint32, currentHeight int32, - hodlChan chan<- interface{}) (*invoices.HodlEvent, error) + hodlChan chan<- interface{}, + packetEOB []byte) (*invoices.HodlEvent, error) // CancelInvoice attempts to cancel the invoice corresponding to the // passed payment hash. diff --git a/htlcswitch/link.go b/htlcswitch/link.go index 050b292b52..baee6caf36 100644 --- a/htlcswitch/link.go +++ b/htlcswitch/link.go @@ -2738,8 +2738,8 @@ func (l *channelLink) processRemoteAdds(fwdPkg *channeldb.FwdPkg, // processExitHop handles an htlc for which this link is the exit hop. It // returns a boolean indicating whether the commitment tx needs an update. func (l *channelLink) processExitHop(pd *lnwallet.PaymentDescriptor, - obfuscator ErrorEncrypter, fwdInfo ForwardingInfo, heightNow uint32) ( - bool, error) { + obfuscator ErrorEncrypter, fwdInfo ForwardingInfo, heightNow uint32, + packetEOB []byte) (bool, error) { // If hodl.ExitSettle is requested, we will not validate the final hop's // ADD, nor will we settle the corresponding invoice or respond with the @@ -2784,7 +2784,6 @@ func (l *channelLink) processExitHop(pd *lnwallet.PaymentDescriptor, // after this, this code will be re-executed after restart. We will // receive back a resolution event. invoiceHash := lntypes.Hash(pd.RHash) - event, err := l.cfg.Registry.NotifyExitHopHtlc( invoiceHash, pd.Amount, pd.Timeout, int32(heightNow), l.hodlQueue.ChanIn(), packetEOB, diff --git a/htlcswitch/mock.go b/htlcswitch/mock.go index 4f25e3f04d..b63eaf12b0 100644 --- a/htlcswitch/mock.go +++ b/htlcswitch/mock.go @@ -280,8 +280,8 @@ func (r *mockHopIterator) ForwardingInstructions() ForwardingInfo { return h } -func (r *mockHopIterator) ExtraOnionBlob() sphinx.ExtraHopData { - return sphinx.ExtraHopData{} +func (r *mockHopIterator) ExtraOnionBlob() []byte { + return []byte{} } func (r *mockHopIterator) ExtractErrorEncrypter( @@ -791,10 +791,11 @@ func (i *mockInvoiceRegistry) SettleHodlInvoice(preimage lntypes.Preimage) error func (i *mockInvoiceRegistry) NotifyExitHopHtlc(rhash lntypes.Hash, amt lnwire.MilliSatoshi, expiry uint32, currentHeight int32, - hodlChan chan<- interface{}) (*invoices.HodlEvent, error) { + hodlChan chan<- interface{}, + packetEOB []byte) (*invoices.HodlEvent, error) { event, err := i.registry.NotifyExitHopHtlc( - rhash, amt, expiry, currentHeight, hodlChan, + rhash, amt, expiry, currentHeight, hodlChan, packetEOB, ) if err != nil { return nil, err diff --git a/invoices/invoiceregistry.go b/invoices/invoiceregistry.go index 5fe17d04d0..390eb06afc 100644 --- a/invoices/invoiceregistry.go +++ b/invoices/invoiceregistry.go @@ -14,6 +14,8 @@ import ( "github.com/lightningnetwork/lnd/lntypes" "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/queue" + "github.com/lightningnetwork/lnd/tlv" + "github.com/lightningnetwork/lnd/watchtower/wtwire" ) var ( @@ -563,7 +565,7 @@ func (i *InvoiceRegistry) checkHtlcParameters(invoice *channeldb.Invoice, // prevent deadlock. func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash, amtPaid lnwire.MilliSatoshi, expiry uint32, currentHeight int32, - hodlChan chan<- interface{}) (*HodlEvent, error) { + hodlChan chan<- interface{}, packetEOB []byte) (*HodlEvent, error) { i.Lock() defer i.Unlock() From 57e59a2e2d2b79b85f1213647fa45af1be97122d Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 16 May 2019 21:07:05 -0700 Subject: [PATCH 12/14] routing/route: update to use new sphinx.NewHopPayload API --- routing/route/route.go | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/routing/route/route.go b/routing/route/route.go index 6aaa4e4986..dc74001314 100644 --- a/routing/route/route.go +++ b/routing/route/route.go @@ -132,8 +132,9 @@ func NewRouteFromHops(amtToSend lnwire.MilliSatoshi, timeLock uint32, // ToSphinxPath converts a complete route into a sphinx PaymentPath that // contains the per-hop paylods used to encoding the HTLC routing data for each -// hop in the route. -func (r *Route) ToSphinxPath() (*sphinx.PaymentPath, error) { +// hop in the route. This method also accepts an optional EOB payload for the +// final hop. +func (r *Route) ToSphinxPath(destEOB []byte) (*sphinx.PaymentPath, error) { var path sphinx.PaymentPath // For each hop encoded within the route, we'll convert the hop struct @@ -147,15 +148,9 @@ func (r *Route) ToSphinxPath() (*sphinx.PaymentPath, error) { return nil, err } - path[i] = sphinx.OnionHop{ - NodePub: *pub, - HopData: sphinx.HopData{ - // TODO(roasbeef): properly set realm, make - // sphinx type an enum actually? - Realm: [1]byte{0}, - ForwardAmount: uint64(hop.AmtToForward), - OutgoingCltv: hop.OutgoingTimeLock, - }, + hopData := sphinx.HopData{ + ForwardAmount: uint64(hop.AmtToForward), + OutgoingCltv: hop.OutgoingTimeLock, } // As a base case, the next hop is set to all zeroes in order @@ -169,8 +164,18 @@ func (r *Route) ToSphinxPath() (*sphinx.PaymentPath, error) { } binary.BigEndian.PutUint64( - path[i].HopData.NextAddress[:], nextHop, + hopData.NextAddress[:], nextHop, ) + + payload, err := sphinx.NewHopPayload(0, &hopData, destEOB) + if err != nil { + return nil, err + } + + path[i] = sphinx.OnionHop{ + NodePub: *pub, + HopPayload: payload, + } } return &path, nil From b5e64fb0c383f4645ed57b4ba2e32249f729e7a7 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 16 May 2019 21:07:19 -0700 Subject: [PATCH 13/14] watchtwoer/wtire: add case for *[32]byte to WriteElement --- watchtower/wtwire/wtwire.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/watchtower/wtwire/wtwire.go b/watchtower/wtwire/wtwire.go index 3d0ba95f24..26beabf1da 100644 --- a/watchtower/wtwire/wtwire.go +++ b/watchtower/wtwire/wtwire.go @@ -93,6 +93,11 @@ func WriteElement(w io.Writer, element interface{}) error { return err } + case *[32]byte: + if _, err := w.Write(e[:]); err != nil { + return err + } + case [33]byte: if _, err := w.Write(e[:]); err != nil { return err From 2cd0f9bf27d5025690476101537a9fa3a7d11098 Mon Sep 17 00:00:00 2001 From: Olaoluwa Osuntokun Date: Thu, 16 May 2019 21:07:40 -0700 Subject: [PATCH 14/14] invoices: detect pre-images encoded in the EOB TLV and settle instantly if valid --- invoices/invoiceregistry.go | 41 +++++++++++++++++++++++++++++++++++++ invoices/tlv_types.go | 6 ++++++ 2 files changed, 47 insertions(+) create mode 100644 invoices/tlv_types.go diff --git a/invoices/invoiceregistry.go b/invoices/invoiceregistry.go index 390eb06afc..df40e7a1a4 100644 --- a/invoices/invoiceregistry.go +++ b/invoices/invoiceregistry.go @@ -574,6 +574,7 @@ func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash, log.Debugf("Invoice(%x): %v, amt=%v, expiry=%v", rHash[:], s, amtPaid, expiry) } + // First check the in-memory debug invoice index to see if this is an // existing invoice added for debugging. if invoice, ok := i.debugInvoices[rHash]; ok { @@ -587,6 +588,46 @@ func (i *InvoiceRegistry) NotifyExitHopHtlc(rHash lntypes.Hash, }, nil } + // If any EOB data was provided, then we'll attempt to decode the TLV + // information included, as it may modify when/how we settle the HTLC. + if len(packetEOB) != 0 { + log.Infof("TLV packet other: %x", packetEOB) + + // Atm, the only TLV field that we care about is the one that + // denotes a pre-image has been sent to us in the encrypted EOB, so + // we'll attempt to parse that out. + var ( + preImage [32]byte + blankPreImage [32]byte + ) + tlvStream := tlv.NewStream( + wtwire.WriteElement, wtwire.ReadElement, + tlv.MakePrimitiveRecord(PreimageTLV, &preImage), + ) + err := tlvStream.Decode( + bytes.NewReader(packetEOB), tlv.ParseModeRetain, + ) + if err != nil { + return nil, err + } + + // If something was acutally specified for this tag, then we'll + // check to see if it matches up with the payment hash. + paymentSecret := lntypes.Preimage(preImage) + if preImage != blankPreImage && paymentSecret.Matches(rHash) { + + debugLog("settled") + + // TODO(roasbeef): record settled spontaneous payment + // in DB + + return &HodlEvent{ + Hash: rHash, + Preimage: &paymentSecret, + }, nil + } + } + // If this isn't a debug invoice, then we'll attempt to settle an // invoice matching this rHash on disk (if one exists). invoice, err := i.cdb.AcceptOrSettleInvoice( diff --git a/invoices/tlv_types.go b/invoices/tlv_types.go new file mode 100644 index 0000000000..d16ff22d71 --- /dev/null +++ b/invoices/tlv_types.go @@ -0,0 +1,6 @@ +package invoices + +const ( + // PreimageTLV... + PreimageTLV = 128 +)