From 0b75c9ccbad74bdef424388bcf3dcdb6e64f6851 Mon Sep 17 00:00:00 2001 From: Rootul P Date: Mon, 30 Jan 2023 12:52:58 -0700 Subject: [PATCH] feat!: adapt tx inclusion proofs to use share inclusion proofs (#1276) Closes https://github.com/celestiaorg/celestia-core/issues/920 Closes https://github.com/celestiaorg/celestia-app/issues/1226 b/c deletes that code Closes https://github.com/celestiaorg/celestia-app/issues/1049 b/c deletes that code ## Description Previously the logic to generate tx proofs was flawed because it did not accurately identify which shares a transaction belongs to. Additionally the struct `TxProof` (originally defined by Tendermint but later modified in celestia-core) was incomplete because it did not contain proofs for the inclusion of a set of rows to the data square root. This PR modifies the TxInclusion logic to return a share inclusion proof instead of a transaction inclusion proof. The share inclusion proof does contain proofs for the rows to the data square root. In order for txs to use share inclusion proofs, `SplitTxs` was updated to keep track of the range of shares that a tx occupies. --------- Co-authored-by: CHAMI Rachid Co-authored-by: Sanaz Taheri <35961250+staheri14@users.noreply.github.com> --- app/estimate_square_size_test.go | 2 +- app/test/integration_test.go | 5 +- app/test/std_sdk_test.go | 2 +- go.mod | 2 +- go.sum | 4 +- pkg/proof/proof.go | 233 +++++------------------ pkg/proof/proof_test.go | 236 ++++++++++-------------- pkg/proof/proof_testdata.go | 5 - pkg/proof/querier.go | 20 +- pkg/shares/compact_shares_test.go | 23 ++- pkg/shares/share_merging_test.go | 22 +-- pkg/shares/share_splitting.go | 21 ++- pkg/shares/share_splitting_test.go | 179 +++++++++++++++++- pkg/shares/split_compact_shares.go | 61 +++++- pkg/shares/split_compact_shares_test.go | 141 +++++++++++++- x/qgb/client/verify.go | 2 +- 16 files changed, 564 insertions(+), 394 deletions(-) delete mode 100644 pkg/proof/proof_testdata.go diff --git a/app/estimate_square_size_test.go b/app/estimate_square_size_test.go index c9fc3577cf..ddf4925859 100644 --- a/app/estimate_square_size_test.go +++ b/app/estimate_square_size_test.go @@ -138,7 +138,7 @@ func Test_estimatePFBTxSharesUsed(t *testing.T) { require.NoError(t, err) txs[i] = wPFBTx } - _, pfbTxShares := shares.SplitTxs(txs) + _, pfbTxShares, _ := shares.SplitTxs(txs) assert.LessOrEqual(t, len(pfbTxShares), got) }) } diff --git a/app/test/integration_test.go b/app/test/integration_test.go index 9cc8905d00..bdcf2772ac 100644 --- a/app/test/integration_test.go +++ b/app/test/integration_test.go @@ -177,8 +177,7 @@ func (s *IntegrationTestSuite) TestMaxBlockSize() { heights := make(map[int64]int) for _, hash := range hashes { - // TODO: reenable fetching and verifying proofs - resp, err := queryTx(val.ClientCtx, hash, false) + resp, err := queryTx(val.ClientCtx, hash, true) assert.NoError(err) assert.NotNil(resp) if resp == nil { @@ -349,7 +348,7 @@ func (s *IntegrationTestSuite) TestShareInclusionProof() { } for _, hash := range hashes { - txResp, err := queryTx(val.ClientCtx, hash, false) + txResp, err := queryTx(val.ClientCtx, hash, true) require.NoError(err) require.Equal(abci.CodeTypeOK, txResp.TxResult.Code) diff --git a/app/test/std_sdk_test.go b/app/test/std_sdk_test.go index d610243f23..ca7bdf170d 100644 --- a/app/test/std_sdk_test.go +++ b/app/test/std_sdk_test.go @@ -208,7 +208,7 @@ func (s *StandardSDKIntegrationTestSuite) TestStandardSDK() { require.NoError(s.T(), s.cctx.WaitForNextBlock()) for _, tt := range tests { - res, err := queryTx(s.cctx.Context, tt.hash, false) + res, err := queryTx(s.cctx.Context, tt.hash, true) require.NoError(t, err) assert.Equal(t, abci.CodeTypeOK, res.TxResult.Code, tt.name) } diff --git a/go.mod b/go.mod index 307634c70a..3f183a400e 100644 --- a/go.mod +++ b/go.mod @@ -186,5 +186,5 @@ require ( replace ( github.com/cosmos/cosmos-sdk => github.com/celestiaorg/cosmos-sdk v1.6.0-sdk-v0.46.7 github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1 - github.com/tendermint/tendermint => github.com/celestiaorg/celestia-core v1.13.0-tm-v0.34.23 + github.com/tendermint/tendermint => github.com/celestiaorg/celestia-core v1.14.0-tm-v0.34.23 ) diff --git a/go.sum b/go.sum index f476ce7eca..5044ad3102 100644 --- a/go.sum +++ b/go.sum @@ -186,8 +186,8 @@ github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46f github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= github.com/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOCSiVIqS34= github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= -github.com/celestiaorg/celestia-core v1.13.0-tm-v0.34.23 h1:nMg928RIanyA2ICN3PHpIE6jgg+008BtD5XmxeObEhM= -github.com/celestiaorg/celestia-core v1.13.0-tm-v0.34.23/go.mod h1:Iu2XuSzF+QG3rzd60/sGhhk3n4wOAm8YyadU80KlcMs= +github.com/celestiaorg/celestia-core v1.14.0-tm-v0.34.23 h1:8zE523TUe5W33/nheJ9umHF2d1q6iHQlqJfMXMTPe3k= +github.com/celestiaorg/celestia-core v1.14.0-tm-v0.34.23/go.mod h1:fGDSg7aw2OH/Uze1zymop0x0y1kAPEO9OII2A2cb99Q= github.com/celestiaorg/cosmos-sdk v1.6.0-sdk-v0.46.7 h1:wP4RRK9zbVBlQXqRqJXji09e9UUFpNpwL2zorHwbJhQ= github.com/celestiaorg/cosmos-sdk v1.6.0-sdk-v0.46.7/go.mod h1:MkOIxmKiICA4d8yPWo/590S4fqpaLXfocz0xn1fxBp4= github.com/celestiaorg/merkletree v0.0.0-20210714075610-a84dc3ddbbe4 h1:CJdIpo8n5MFP2MwK0gSRcOVlDlFdQJO1p+FqdxYzmvc= diff --git a/pkg/proof/proof.go b/pkg/proof/proof.go index f6dc26c119..91152818e1 100644 --- a/pkg/proof/proof.go +++ b/pkg/proof/proof.go @@ -22,99 +22,43 @@ import ( "github.com/tendermint/tendermint/types" ) -// TxInclusion uses the provided block data to progressively generate rows -// of a data square, and then using those shares to creates nmt inclusion proofs. -// It is possible that a transaction spans more than one row. In that case, we -// have to return more than one proof. -func TxInclusion(codec rsmt2d.Codec, data types.Data, txIndex uint64) (types.TxProof, error) { - // calculate the index of the shares that contain the tx - startPos, endPos, err := TxSharePosition(data.Txs, txIndex) +// NewTxInclusionProof returns a new share inclusion proof for the given +// transaction index. +func NewTxInclusionProof(codec rsmt2d.Codec, data types.Data, txIndex uint64) (types.ShareProof, error) { + rawShares, err := shares.Split(data, true) if err != nil { - return types.TxProof{}, err + return types.ShareProof{}, err } - // use the index of the shares and the square size to determine the row that - // contains the tx we need to prove - startRow := startPos / data.SquareSize - endRow := endPos / data.SquareSize - startLeaf := startPos % data.SquareSize - endLeaf := endPos % data.SquareSize - - rowShares, err := genRowShares(codec, data, startRow, endRow) + startShare, endShare, err := TxSharePosition(data, txIndex) if err != nil { - return types.TxProof{}, err + return types.ShareProof{}, err } - var proofs []*tmproto.NMTProof //nolint:prealloc // rarely will this contain more than a single proof - var rawShares [][]byte //nolint:prealloc // rarely will this contain more than a single share - var rowRoots []tmbytes.HexBytes //nolint:prealloc // rarely will this contain more than a single root - for i, row := range rowShares { - // create an nmt to use to generate a proof - tree := wrapper.NewErasuredNamespacedMerkleTree(data.SquareSize, uint(i)) - for _, share := range row { - tree.Push( - share, - ) - } - - startLeafPos := startLeaf - endLeafPos := endLeaf - - // if this is not the first row, then start with the first leaf - if i > 0 { - startLeafPos = 0 - } - // if this is not the last row, then select for the rest of the row - if i != (len(rowShares) - 1) { - endLeafPos = data.SquareSize - 1 - } - - rawShares = append(rawShares, shares.ToBytes(row[startLeafPos:endLeafPos+1])...) - proof, err := tree.Tree().ProveRange(int(startLeafPos), int(endLeafPos+1)) - if err != nil { - return types.TxProof{}, err - } - - proofs = append(proofs, &tmproto.NMTProof{ - Start: int32(proof.Start()), - End: int32(proof.End()), - Nodes: proof.Nodes(), - LeafHash: proof.LeafHash(), - }) + namespace := getTxNamespace(data.Txs[txIndex]) + return NewShareInclusionProof(rawShares, data.SquareSize, namespace, startShare, endShare) +} - // we don't store the data availability header anywhere, so we - // regenerate the roots to each row - rowRoots = append(rowRoots, tree.Root()) +func getTxNamespace(tx types.Tx) (ns namespace.ID) { + _, isIndexWrapper := types.UnmarshalIndexWrapper(tx) + if isIndexWrapper { + return appconsts.PayForBlobNamespaceID } - - return types.TxProof{ - RowRoots: rowRoots, - Data: rawShares, - Proofs: proofs, - }, nil + return appconsts.TxNamespaceID } // TxSharePosition returns the start and end positions for the shares that // include a given txIndex. Returns an error if index is greater than the length // of txs. -func TxSharePosition(txs types.Txs, txIndex uint64) (startSharePos, endSharePos uint64, err error) { - if txIndex >= uint64(len(txs)) { - return startSharePos, endSharePos, errors.New("transaction index is greater than the number of txs") - } - - prevTxTotalLen := 0 - for i := uint64(0); i < txIndex; i++ { - txLen := len(txs[i]) - prevTxTotalLen += (shares.DelimLen(uint64(txLen)) + txLen) +func TxSharePosition(data types.Data, txIndex uint64) (startShare uint64, endShare uint64, err error) { + if int(txIndex) >= len(data.Txs) { + return 0, 0, errors.New("transaction index is greater than the number of txs") } - currentTxLen := len(txs[txIndex]) - currentTxTotalLen := shares.DelimLen(uint64(currentTxLen)) + currentTxLen - endOfCurrentTxLen := prevTxTotalLen + currentTxTotalLen + _, _, shareRanges := shares.SplitTxs(data.Txs) + shareRange := shareRanges[data.Txs[txIndex].Key()] - startSharePos = txShareIndex(prevTxTotalLen) - endSharePos = txShareIndex(endOfCurrentTxLen) - return startSharePos, endSharePos, nil + return uint64(shareRange.Start), uint64(shareRange.End), nil } // BlobShareRange returns the start and end positions for the shares @@ -158,107 +102,16 @@ func BlobShareRange(tx types.Tx) (beginShare uint64, endShare uint64, err error) return beginShare, beginShare + uint64(sharesUsed) - 1, nil } -// txShareIndex returns the index of the compact share that would contain -// transactions with totalTxLen -func txShareIndex(totalTxLen int) (index uint64) { - if totalTxLen <= appconsts.FirstCompactShareContentSize { - return 0 - } - - index++ - totalTxLen -= appconsts.FirstCompactShareContentSize - - for totalTxLen > appconsts.ContinuationCompactShareContentSize { - index++ - totalTxLen -= appconsts.ContinuationCompactShareContentSize - } - return index -} - -// genRowShares progessively generates data square rows from block data -func genRowShares(codec rsmt2d.Codec, data types.Data, startRow, endRow uint64) ([][]shares.Share, error) { - if endRow > data.SquareSize { - return nil, errors.New("cannot generate row shares past the original square size") - } - origRowShares := splitIntoRows( - data.SquareSize, - genOrigRowShares(data, startRow, endRow), - ) - - encodedRowShares := make([][]shares.Share, len(origRowShares)) - for i, row := range origRowShares { - encRow, err := codec.Encode(shares.ToBytes(row)) - if err != nil { - panic(err) - } - encodedRowShares[i] = append( - append( - make([]shares.Share, 0, len(row)+len(encRow)), - row..., - ), shares.FromBytes(encRow)..., - ) - } - - return encodedRowShares, nil -} - -// genOrigRowShares progressively generates data square rows for the original -// data square, meaning the rows only half the full square length, as there is -// not erasure data -func genOrigRowShares(data types.Data, startRow, endRow uint64) []shares.Share { - wantLen := (endRow + 1) * data.SquareSize - startPos := startRow * data.SquareSize - - rawTxShares, pfbTxShares := shares.SplitTxs(data.Txs) - rawShares := append(rawTxShares, pfbTxShares...) - // return if we have enough shares - if uint64(len(rawShares)) >= wantLen { - return rawShares[startPos:wantLen] - } - - for _, blob := range data.Blobs { - blobShares, err := shares.SplitBlobs(0, nil, []types.Blob{blob}, false) - if err != nil { - panic(err) - } - - // TODO: does this need to account for padding between compact shares - // and the first blob? - // https://github.com/celestiaorg/celestia-app/issues/1226 - rawShares = append(rawShares, blobShares...) - - // return if we have enough shares - if uint64(len(rawShares)) >= wantLen { - return rawShares[startPos:wantLen] - } - } - - tailShares := shares.TailPaddingShares(int(wantLen) - len(rawShares)) - rawShares = append(rawShares, tailShares...) - - return rawShares[startPos:wantLen] -} - -// splitIntoRows splits shares into rows of a particular square size -func splitIntoRows(squareSize uint64, s []shares.Share) [][]shares.Share { - rowCount := uint64(len(s)) / squareSize - rows := make([][]shares.Share, rowCount) - for i := uint64(0); i < rowCount; i++ { - rows[i] = s[i*squareSize : (i+1)*squareSize] - } - return rows -} - -// GenerateSharesInclusionProof generates an nmt inclusion proof for a set of shares to the data root. +// NewShareInclusionProof returns an NMT inclusion proof for a set of shares to the data root. // Expects the share range to be pre-validated. // Note: only supports inclusion proofs for shares belonging to the same namespace. -func GenerateSharesInclusionProof( +func NewShareInclusionProof( allRawShares []shares.Share, squareSize uint64, namespaceID namespace.ID, startShare uint64, endShare uint64, -) (types.SharesProof, error) { +) (types.ShareProof, error) { startRow := startShare / squareSize endRow := endShare / squareSize startLeaf := startShare % squareSize @@ -266,18 +119,18 @@ func GenerateSharesInclusionProof( eds, err := da.ExtendShares(squareSize, shares.ToBytes(allRawShares)) if err != nil { - return types.SharesProof{}, err + return types.ShareProof{}, err } edsRowRoots := eds.RowRoots() // create the binary merkle inclusion proof for all the square rows to the data root _, allProofs := merkle.ProofsFromByteSlices(append(edsRowRoots, eds.ColRoots()...)) - rowsProofs := make([]*merkle.Proof, endRow-startRow+1) - rowsRoots := make([]tmbytes.HexBytes, endRow-startRow+1) + rowProofs := make([]*merkle.Proof, endRow-startRow+1) + rowRoots := make([]tmbytes.HexBytes, endRow-startRow+1) for i := startRow; i <= endRow; i++ { - rowsProofs[i-startRow] = allProofs[i] - rowsRoots[i-startRow] = edsRowRoots[i] + rowProofs[i-startRow] = allProofs[i] + rowRoots[i-startRow] = edsRowRoots[i] } // get the extended rows containing the shares. @@ -286,7 +139,7 @@ func GenerateSharesInclusionProof( rows[i-startRow] = shares.FromBytes(eds.Row(uint(i))) } - var sharesProofs []*tmproto.NMTProof //nolint:prealloc + var shareProofs []*tmproto.NMTProof //nolint:prealloc var rawShares [][]byte for i, row := range rows { // create an nmt to generate a proof. @@ -313,10 +166,10 @@ func GenerateSharesInclusionProof( rawShares = append(rawShares, shares.ToBytes(row[startLeafPos:endLeafPos+1])...) proof, err := tree.Tree().ProveRange(int(startLeafPos), int(endLeafPos+1)) if err != nil { - return types.SharesProof{}, err + return types.ShareProof{}, err } - sharesProofs = append(sharesProofs, &tmproto.NMTProof{ + shareProofs = append(shareProofs, &tmproto.NMTProof{ Start: int32(proof.Start()), End: int32(proof.End()), Nodes: proof.Nodes(), @@ -324,20 +177,20 @@ func GenerateSharesInclusionProof( }) // make sure that the generated root is the same as the eds row root. - if !bytes.Equal(rowsRoots[i].Bytes(), tree.Root()) { - return types.SharesProof{}, errors.New("eds row root is different than tree root") + if !bytes.Equal(rowRoots[i].Bytes(), tree.Root()) { + return types.ShareProof{}, errors.New("eds row root is different than tree root") } } - return types.SharesProof{ - RowsProof: types.RowsProof{ - RowsRoots: rowsRoots, - Proofs: rowsProofs, - StartRow: uint32(startRow), - EndRow: uint32(endRow), + return types.ShareProof{ + RowProof: types.RowProof{ + RowRoots: rowRoots, + Proofs: rowProofs, + StartRow: uint32(startRow), + EndRow: uint32(endRow), }, - Data: rawShares, - SharesProofs: sharesProofs, - NamespaceID: namespaceID, + Data: rawShares, + ShareProofs: shareProofs, + NamespaceID: namespaceID, }, nil } diff --git a/pkg/proof/proof_test.go b/pkg/proof/proof_test.go index 96801bfc4c..0726474090 100644 --- a/pkg/proof/proof_test.go +++ b/pkg/proof/proof_test.go @@ -1,6 +1,7 @@ package proof import ( + "bytes" "sort" "testing" @@ -13,69 +14,67 @@ import ( "github.com/celestiaorg/celestia-app/pkg/shares" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - tmrand "github.com/tendermint/tendermint/libs/rand" "github.com/tendermint/tendermint/types" ) -func TestTxInclusion(t *testing.T) { - typicalBlockData := types.Data{ - Txs: testfactory.GenerateRandomlySizedTxs(100, 500), - Blobs: testfactory.GenerateRandomlySizedBlobs(40, 16000), - SquareSize: 64, - } - lotsOfTxsNoBlobs := types.Data{ - Txs: testfactory.GenerateRandomlySizedTxs(1000, 500), - SquareSize: 64, - } - overlappingSquareSize := 16 - overlappingRowsBlockData := types.Data{ - Txs: types.ToTxs( - [][]byte{ - tmrand.Bytes(appconsts.ContinuationCompactShareContentSize*overlappingSquareSize + 1), - tmrand.Bytes(10000), - }, - ), - SquareSize: uint64(overlappingSquareSize), - } - overlappingRowsBlockDataWithBlobs := types.Data{ - Txs: types.ToTxs( - [][]byte{ - tmrand.Bytes(appconsts.ContinuationCompactShareContentSize*overlappingSquareSize + 1), - tmrand.Bytes(10000), - }, - ), - Blobs: testfactory.GenerateRandomlySizedBlobs(8, 400), - SquareSize: uint64(overlappingSquareSize), +func TestNewTxInclusionProof(t *testing.T) { + blockData := types.Data{ + Txs: testfactory.GenerateRandomTxs(50, 500), + Blobs: []types.Blob{}, + SquareSize: appconsts.DefaultMaxSquareSize, } type test struct { - data types.Data + name string + data types.Data + txIndex uint64 + expectErr bool } tests := []test{ { - typicalBlockData, + name: "empty data returns error", + data: types.Data{}, + txIndex: 0, + expectErr: true, }, { - lotsOfTxsNoBlobs, + name: "txIndex 0 of block data", + data: blockData, + txIndex: 0, + expectErr: false, }, { - overlappingRowsBlockData, + name: "txIndex 49 of block data", + data: blockData, + txIndex: 49, + expectErr: false, }, { - overlappingRowsBlockDataWithBlobs, + name: "txIndex 50 of block data returns error because only 50 txs", + data: blockData, + txIndex: 50, + expectErr: true, }, } for _, tt := range tests { - for i := 0; i < len(tt.data.Txs); i++ { - txProof, err := TxInclusion(appconsts.DefaultCodec(), tt.data, uint64(i)) - require.NoError(t, err) - assert.True(t, txProof.VerifyProof()) - } + t.Run(tt.name, func(t *testing.T) { + proof, err := NewTxInclusionProof( + appconsts.DefaultCodec(), + tt.data, + tt.txIndex, + ) + if tt.expectErr { + assert.Error(t, err) + return + } + assert.NoError(t, err) + assert.True(t, proof.VerifyProof()) + }) } } -func TestShareInclusion(t *testing.T) { +func TestNewShareInclusionProof(t *testing.T) { blobs := append( testfactory.GenerateBlobsWithNamespace( 100, @@ -207,7 +206,7 @@ func TestShareInclusion(t *testing.T) { } require.NoError(t, err) require.Equal(t, tt.namespaceID, actualNID) - proof, err := GenerateSharesInclusionProof( + proof, err := NewShareInclusionProof( rawShares, blockData.SquareSize, tt.namespaceID, @@ -222,114 +221,73 @@ func TestShareInclusion(t *testing.T) { func TestTxSharePosition(t *testing.T) { type test struct { - name string - txs types.Txs + name string + data types.Data + txIndex uint64 + wantStart uint64 + wantEnd uint64 + wantErr bool } - tests := []test{ - { - name: "typical", - txs: testfactory.GenerateRandomlySizedTxs(44, 200), - }, - { - name: "many small tx", - txs: testfactory.GenerateRandomlySizedTxs(444, 100), - }, + txOne := types.Tx{0x1} + txTwo := types.Tx(bytes.Repeat([]byte{2}, 600)) + txThree := types.Tx(bytes.Repeat([]byte{3}, 1000)) + + testCases := []test{ { - // this is a concrete output from testfactory.GenerateRandomlySizedTxs(444, 100) - // that surfaced a bug in txSharePositions so it is included here to - // prevent regressions - name: "many small tx (without randomness)", - txs: manySmallTxsWithoutRandomness, + name: "expect err when txIndex is greater than the number of txs", + data: types.Data{ + Txs: []types.Tx{txOne}, + Blobs: []types.Blob{}, + SquareSize: appconsts.DefaultMinSquareSize, + }, + txIndex: 2, + wantStart: 0, + wantEnd: 0, }, { - name: "one small tx", - txs: testfactory.GenerateRandomlySizedTxs(1, 200), + name: "txOne occupies shares 0 to 0", + data: types.Data{ + Txs: []types.Tx{txOne}, + Blobs: []types.Blob{}, + SquareSize: appconsts.DefaultMinSquareSize, + }, + txIndex: 0, + wantStart: 0, + wantEnd: 0, }, { - name: "one large tx", - txs: testfactory.GenerateRandomlySizedTxs(1, 2000), + name: "txTwo occupies shares 0 to 1", + data: types.Data{ + Txs: []types.Tx{txTwo}, + Blobs: []types.Blob{}, + SquareSize: appconsts.DefaultMaxSquareSize, + }, + txIndex: 0, + wantStart: 0, + wantEnd: 1, }, { - name: "many large txs", - txs: testfactory.GenerateRandomlySizedTxs(100, 2000), + name: "txThree occupies shares 0 to 2", + data: types.Data{ + Txs: []types.Tx{txThree}, + Blobs: []types.Blob{}, + SquareSize: appconsts.DefaultMaxSquareSize, + }, + txIndex: 0, + wantStart: 0, + wantEnd: 2, }, } - type startEndPoints struct { - start, end uint64 - } - - for _, tt := range tests { - positions := make([]startEndPoints, len(tt.txs)) - for i := 0; i < len(tt.txs); i++ { - start, end, err := TxSharePosition(tt.txs, uint64(i)) - require.NoError(t, err) - positions[i] = startEndPoints{start: start, end: end} - } - - txShares, _ := shares.SplitTxs(tt.txs) - - for i, pos := range positions { - rawTx := []byte(tt.txs[i]) - rawTxDataForRange, err := stripCompactShares(txShares[pos.start : pos.end+1]) - assert.NoError(t, err) - assert.Contains( - t, - string(rawTxDataForRange), - string(rawTx), - tt.name, - pos, - len(tt.txs[i]), - ) - } - } -} - -func TestTxShareIndex(t *testing.T) { - type testCase struct { - totalTxLen int - wantIndex uint64 - } - - tests := []testCase{ - {0, 0}, - {10, 0}, - {100, 0}, - {appconsts.FirstCompactShareContentSize, 0}, - {appconsts.FirstCompactShareContentSize + 1, 1}, - {appconsts.FirstCompactShareContentSize + appconsts.ContinuationCompactShareContentSize, 1}, - {appconsts.FirstCompactShareContentSize + appconsts.ContinuationCompactShareContentSize + 1, 2}, - {appconsts.FirstCompactShareContentSize + (appconsts.ContinuationCompactShareContentSize * 2), 2}, - {appconsts.FirstCompactShareContentSize + (appconsts.ContinuationCompactShareContentSize * 2) + 1, 3}, - // 81 full compact shares then a partially filled out 82nd share (which is index 81 because 0-indexed) - {appconsts.FirstCompactShareContentSize + (appconsts.ContinuationCompactShareContentSize * 80) + 160, 81}, - // 82 full compact shares - {appconsts.FirstCompactShareContentSize + (appconsts.ContinuationCompactShareContentSize * 81), 81}, - // 82 full compact shares then one byte in 83rd share - {appconsts.FirstCompactShareContentSize + (appconsts.ContinuationCompactShareContentSize * 81) + 1, 82}, - // 82 compact shares then two bytes in 83rd share - {appconsts.FirstCompactShareContentSize + (appconsts.ContinuationCompactShareContentSize * 81) + 2, 82}, - } - - for _, tt := range tests { - got := txShareIndex(tt.totalTxLen) - if got != tt.wantIndex { - t.Errorf("txShareIndex(%d) got %d, want %d", tt.totalTxLen, got, tt.wantIndex) - } - } -} - -// stripCompactShares strips the universal prefix (namespace, info byte, sequence length) and -// reserved bytes from a list of compact shares and joins them into a single byte -// slice. -func stripCompactShares(compactShares []shares.Share) (result []byte, err error) { - for _, compactShare := range compactShares { - rawData, err := compactShare.RawData() - if err != nil { - return []byte{}, err - } - result = append(result, rawData...) + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + start, end, err := TxSharePosition(tc.data, tc.txIndex) + if tc.wantErr { + assert.Error(t, err) + } + assert.Equal(t, tc.wantStart, start) + assert.Equal(t, tc.wantEnd, end) + }) } - return result, nil } diff --git a/pkg/proof/proof_testdata.go b/pkg/proof/proof_testdata.go deleted file mode 100644 index 96bd8830dc..0000000000 --- a/pkg/proof/proof_testdata.go +++ /dev/null @@ -1,5 +0,0 @@ -package proof - -import "github.com/tendermint/tendermint/types" - -var manySmallTxsWithoutRandomness = types.Txs{types.Tx{0x49, 0x88, 0x8b, 0x74, 0xd9, 0x88, 0xfc, 0x10, 0x3c, 0x61, 0x53, 0xe1, 0xf, 0x1b, 0x7e, 0xc7, 0x8d, 0xd6, 0x18, 0x62, 0xc5, 0x93, 0x72, 0x85, 0x29, 0x82, 0xc, 0xad, 0x70, 0xcd, 0x5e, 0x38, 0xb4, 0x22, 0x1a, 0x96, 0x5f, 0x51, 0xbc, 0x67, 0x82, 0xab, 0x17, 0xd1, 0x6a, 0xb8, 0xc4, 0x18, 0xe, 0xd, 0xd4, 0xb, 0xf8, 0xe0, 0x94, 0x6a, 0xcd, 0x72, 0x33, 0xde, 0x6, 0x49, 0x24, 0xda, 0x69, 0x19, 0x88, 0x21, 0xe4, 0xe5, 0x5c, 0x1f, 0xe9, 0xfc, 0x4f, 0xf2, 0x85, 0xaa, 0x4e, 0x6c, 0xba, 0x99, 0xf, 0xd3, 0x12, 0x4c}, types.Tx{0xcc, 0x35, 0x13, 0x1f, 0xf6, 0x61, 0x4c, 0xed, 0x2d, 0xd5, 0x20, 0x34, 0x8b, 0x42, 0xdb, 0x18, 0xe9, 0x92, 0x57, 0x5a, 0xb, 0xf6, 0x18, 0x94, 0x9c, 0x6f, 0x19, 0x13, 0x86, 0x43, 0xc2, 0x9b, 0xc5, 0x41, 0x1d, 0xf8, 0x22}, types.Tx{0xf9, 0x68, 0x5a, 0x7e, 0x16, 0x72, 0x7c, 0x41, 0x64, 0xf2, 0x2f, 0x4d, 0x5f, 0x6b, 0x4, 0x52, 0x7e, 0xd1, 0xf4, 0x70, 0x5, 0x5b}, types.Tx{0xa8, 0xc8, 0x5b, 0xd5, 0xd2, 0x7a, 0xd2, 0xdb, 0xb4, 0x1b, 0x3e, 0x69, 0x8f, 0x2a, 0x78, 0x9f, 0x16, 0xdc, 0x6f, 0xb3, 0xab, 0xd4, 0x7d, 0xd, 0xdc, 0x3, 0xf5, 0x2f, 0xb6, 0x65, 0xfa, 0x94, 0xb3, 0x69, 0x57, 0x65, 0xd1, 0x6c, 0x2, 0xaf, 0xab, 0x67, 0xcc, 0x6e, 0x82, 0x30, 0xf, 0x20, 0x55, 0x49, 0x63, 0xdd, 0xa9, 0x38, 0x13, 0x8b, 0x5a, 0x3, 0xec}, types.Tx{0x2, 0x46, 0x8a, 0x37, 0xc0, 0x60, 0x28, 0x5b, 0xcf, 0xad, 0x78, 0xdb}, types.Tx{0xb9, 0x9c, 0xe0, 0x5f, 0x2b, 0x65, 0x5e, 0xa9, 0x5d, 0x54, 0x9, 0xe3, 0xa2, 0xd5, 0x2f, 0x59, 0x36, 0x9f, 0x7f, 0x5d, 0x5, 0x74, 0xa7, 0xeb, 0x8f, 0x6d, 0x3d, 0x4c, 0xf8, 0xc0}, types.Tx{0x17, 0x7, 0x63, 0xcf, 0xf3, 0x39, 0x6d, 0x4a, 0x44, 0xf9, 0x21, 0x6b, 0x39, 0xde, 0x1c, 0xea, 0x70, 0xe, 0x4b, 0x68, 0x66, 0xd1, 0x37, 0xfe, 0xd3, 0xba, 0xc7, 0xd1, 0x78, 0xa5, 0x8a, 0xc3, 0x3b, 0x44, 0x30, 0x89, 0x41, 0xa0, 0xe4, 0x3f, 0xa6, 0xc7, 0x2a, 0x5b, 0x75, 0x37, 0x44, 0x19, 0xd8, 0x71, 0x9b, 0x2a, 0xac, 0x2b, 0x7b, 0xa6, 0xe6}, types.Tx{0x99, 0xcf, 0x86, 0x5d, 0xb1, 0x30, 0x2, 0xc8, 0x8f, 0x10, 0xb4, 0xfb, 0xb9, 0x7d, 0x70, 0x8a, 0x16, 0xd2, 0x6b, 0x71, 0x49, 0x48, 0x5f, 0x83, 0x77, 0xeb, 0x97, 0xbc, 0x3c, 0xa2, 0x91, 0x9c, 0x61, 0x16, 0x3a, 0x56, 0x40, 0xa2, 0x2d, 0xde, 0x6f, 0x33, 0x76, 0x5f, 0x4d, 0xe0, 0xe8, 0x50, 0xd6, 0x4a, 0x92, 0x42, 0xaf, 0x8f, 0x36, 0xc9, 0x17, 0x5d, 0x38, 0xac, 0x33, 0xeb, 0x4, 0xb6, 0x29, 0x78, 0x33, 0x70, 0x4b, 0x25, 0x1, 0xb, 0x2d, 0x8c, 0xb5, 0xd8, 0x80}, types.Tx{0xe8, 0x2f, 0x64, 0x0, 0xea, 0xcb, 0xc3, 0x9e, 0x2d, 0x6e, 0xf, 0x98, 0x57, 0xa8, 0x64, 0x8c, 0xd8, 0x1c, 0x5e, 0x4b, 0xf9, 0xd, 0x48, 0xbd, 0x92, 0x3d, 0xd0, 0x9a, 0x5a, 0x59, 0x14, 0x2, 0x38, 0x81, 0xf4, 0xc2, 0x13, 0x26, 0x8d, 0x78, 0xaf, 0xd7, 0xf4, 0x86, 0x1f, 0xb8, 0x72, 0x58, 0xfc, 0x64, 0x62, 0xb4, 0x11, 0x17, 0x14, 0xff, 0xde, 0x88, 0x4b, 0x82}, types.Tx{0x32, 0x58, 0x9a, 0x8f, 0x76, 0xd3, 0xbf, 0x1b, 0x11, 0x23, 0x6d, 0xcf, 0xca, 0x80, 0x68, 0x6f, 0xae, 0x9e, 0xa1, 0xdd, 0x87}, types.Tx{0x4e, 0xdb, 0x6a, 0x8c, 0x3, 0x37, 0xed, 0xfb, 0xf1, 0x25, 0x88, 0x3d, 0x42, 0x94, 0xeb, 0x32, 0xc1, 0x87, 0x1e, 0xc5, 0xb, 0xcd, 0xaf, 0x68, 0x3c, 0x47, 0xdc, 0x54, 0x87, 0xad, 0xda, 0x72, 0xf0, 0x33, 0x51, 0x88, 0xc, 0x4b, 0xf, 0x11, 0xea, 0x18, 0xec, 0xb4, 0xce, 0x4f, 0x77, 0x4f, 0x40, 0xd1, 0x7e, 0x97, 0xf7}, types.Tx{0xad, 0xfd, 0x92, 0x9e, 0x8b, 0x8b, 0xd8, 0x58, 0x54, 0xe6, 0x20, 0x4a, 0x88, 0x3e, 0xd6, 0x7e, 0x5, 0x34, 0x1a, 0xd6, 0x30, 0xd0, 0x91, 0x7d, 0x63}, types.Tx{0xad, 0xea, 0xcc, 0x67, 0x42, 0xff, 0xd5, 0x13, 0xf, 0x3d, 0xca, 0x1a, 0x11, 0x41, 0x45, 0x50, 0x86, 0xe9, 0xf2, 0xdf, 0xe7, 0x9e, 0xe4, 0x16, 0x26, 0x8, 0xd7, 0x59}, types.Tx{0x74, 0x12, 0x43, 0x55, 0xc4, 0x40, 0xd0, 0xa4, 0x3e, 0x27, 0x14, 0x94}, types.Tx{0x6e, 0x33, 0xb3, 0xa8, 0xad, 0x8, 0x6d, 0xd2, 0x73, 0x17, 0xbf, 0x68, 0x6b, 0x58, 0xb, 0xc1, 0xd, 0x7f, 0x7f, 0x22}, types.Tx{0xdb, 0x18, 0x94, 0xc8, 0x5e, 0x5a, 0xe4, 0x89, 0x43, 0x58, 0x1e, 0xb4, 0x87, 0x1f, 0xc, 0x8d, 0x15, 0x32}, types.Tx{0x77, 0xc, 0xfd, 0xd0, 0x59, 0x76, 0xc6, 0xe5, 0xfe, 0x70, 0x41, 0x90, 0x44, 0x26, 0x81, 0xe2, 0xa9, 0x75, 0x92, 0x63, 0x3f, 0x68, 0x4c, 0x15, 0xf6, 0x63, 0xc0, 0x82, 0xb5, 0x85, 0xa4, 0x17, 0x5e, 0xf, 0x79, 0x60, 0x1a, 0x3a, 0x34, 0x63, 0x3e, 0xe8, 0x27, 0x2c, 0xab, 0xf, 0xa6, 0x8b, 0xea, 0x8a, 0x7b, 0x57, 0x35, 0xdb, 0x13, 0x5b, 0xa4, 0xbe, 0xaf, 0x7c, 0x49, 0x6f, 0xdc, 0xd9, 0x3a, 0x1b, 0x76, 0xf4, 0x71, 0x33, 0xbe, 0x6c, 0xae, 0x3a, 0xec, 0x4f, 0x67, 0xdc, 0x0, 0x9b, 0x7e, 0xe1, 0xa3, 0x28, 0x2, 0x4d, 0x47, 0x5e, 0x9b, 0x98, 0x33, 0xe7, 0x99, 0x9c, 0x6b, 0xdd, 0x38}, types.Tx{0xc3, 0x25, 0x38, 0xf3, 0x8, 0xdb, 0xb5, 0xbf, 0x90, 0x70, 0xac, 0x3, 0xd3, 0x85, 0x26}, types.Tx{0x16, 0xfa, 0x1e, 0x7a, 0xa4, 0x25, 0x6b, 0x3f, 0x15, 0xff, 0x3d, 0x24, 0x52, 0xe5, 0x6a, 0x4e, 0x81, 0x8d, 0xc4, 0x16, 0xd4, 0xe6, 0x26, 0x5e, 0x45, 0x10, 0x91, 0xf9, 0x56, 0xfa, 0xb1, 0x57, 0x22, 0xdf, 0x11, 0x92, 0xb3, 0x5e}, types.Tx{0xa2, 0xd9, 0x10, 0x65, 0x47, 0x96, 0xa3, 0xd7, 0x12, 0x2a, 0xee, 0x1, 0x5f, 0x8, 0xab, 0x35, 0xc0, 0xbf, 0xb6, 0x86, 0xc8, 0xe7, 0x39, 0xfa, 0xf4, 0xfa, 0x8d, 0x21, 0x9, 0xc1, 0xcc, 0x47, 0x32, 0xf8, 0xf0, 0x31, 0xd5, 0x81, 0x73, 0x1c, 0xae, 0x2a, 0x90}, types.Tx{0x62, 0xf7, 0xf6, 0x2f}, types.Tx{0x41, 0xa4, 0x29, 0xfc, 0x7f, 0x9d, 0x43, 0xc7, 0x25, 0x2, 0xe8, 0xff, 0x92, 0xe5, 0x94, 0x89, 0x15, 0x80, 0xc9, 0x21, 0x8b, 0xdc, 0x8d, 0xd, 0xfe, 0x9, 0x52, 0x3b, 0x2e, 0x14, 0x43, 0x6d, 0x33, 0xa3, 0x5c, 0x95, 0x7c, 0x9, 0x18, 0x1e, 0x95, 0x24, 0xb9, 0x18, 0x60, 0x97, 0xa0, 0xd5, 0x3b, 0xa5, 0x8, 0xc5, 0x87, 0x97, 0x7a, 0xb7, 0x2f, 0x19, 0x62, 0xe3, 0xfa, 0x95, 0xb7}, types.Tx{0xc0, 0xf4, 0xd1, 0xb9, 0xfc, 0x6, 0x4f, 0x70, 0xd3, 0x15, 0x12, 0x8, 0xd0, 0x54, 0x8e, 0x79, 0x89, 0xe9, 0x4b, 0xee, 0xe2, 0xf0, 0x92, 0x63, 0x47, 0x94, 0x66, 0xb4, 0x47, 0xb, 0xcf, 0x19, 0xf8, 0x17, 0x81, 0xc0, 0x9f, 0xed, 0x57, 0xfc, 0xc6, 0x5c, 0x11, 0x34, 0x98, 0x27, 0x17, 0x96, 0x8c, 0x56, 0xc0, 0xce, 0x13, 0x7f, 0x3a, 0x1e, 0xa6, 0x31, 0x77, 0x29, 0x17, 0xfe, 0xef, 0x52, 0x6e, 0x5b, 0x26, 0x1c, 0xa3, 0xa0, 0x9a, 0xf8, 0x5b, 0x6b, 0xf6, 0x38, 0x65, 0x65, 0xbe, 0xb3, 0xef, 0x9, 0xb7, 0x35, 0x72, 0x61, 0x55, 0xc4, 0x6b, 0xef, 0x6e, 0xa9, 0xed, 0x4f, 0xc9, 0x46}, types.Tx{0xc3, 0xe3, 0x65, 0x33, 0x85, 0xd3, 0xb6, 0x98, 0x3f, 0xdd, 0x89, 0xca, 0xcd, 0x12, 0xa1, 0x91, 0xe0, 0xba, 0xef, 0x9a, 0x37, 0xed, 0x0, 0xd5, 0x8c, 0xf7, 0x97, 0xc0, 0x6e, 0x84, 0x94, 0x7, 0x1a, 0x10, 0xa, 0xc5, 0x28, 0x8a, 0x6d, 0x86, 0xa5, 0x1f, 0x95, 0x10, 0xeb, 0xa0, 0x3a, 0x56, 0xe2, 0x5, 0x5a, 0x44, 0x63, 0xdc, 0x53, 0xa0, 0x4a, 0xbb, 0xb, 0x14, 0x8e, 0x9b, 0x83, 0x87, 0x1, 0x35, 0xf4, 0xda, 0x81, 0xb, 0xaa, 0xd6, 0xd9, 0x64, 0x1a, 0x59, 0x7a}, types.Tx{0xda, 0x6d, 0x41, 0xec, 0xcc}, types.Tx{0x4f, 0x91, 0xbf, 0x7c, 0x49, 0x7, 0xdf, 0xb5, 0xee, 0xa9, 0xeb, 0x8e, 0x46, 0x1b, 0x21, 0xbb, 0x17, 0x8, 0xbd, 0x4, 0x11, 0xf1, 0x8f, 0xf3, 0x27, 0x35, 0x5d, 0x7e, 0x86, 0xc7, 0xd, 0xeb, 0x4c, 0x4, 0xb4, 0x93, 0x41, 0x89, 0x27}, types.Tx{0xe3, 0x2e}, types.Tx{0x1d, 0xf1, 0x2f, 0x38, 0x54, 0xcb, 0xf8, 0x4b, 0x2f, 0x88, 0xe7, 0x3a, 0xee, 0x26, 0xd5, 0xe6, 0x90, 0x1b, 0x8c, 0xf, 0x7d, 0x2d, 0x3f}, types.Tx{0x29, 0x2a, 0x6e, 0xaf}, types.Tx{0xe5, 0xb3, 0x82, 0xd2, 0xf2, 0x11}, types.Tx{0x4a, 0xa1, 0x90, 0xff, 0xd7, 0x85, 0xb7, 0x80, 0x85, 0xb9, 0xa8, 0xc, 0x1e, 0xd7, 0x4f, 0x8d, 0x94, 0xa7, 0xa3, 0xdc, 0xf7, 0x78, 0xe1, 0x64, 0x13, 0x2f, 0xbe, 0x45, 0x6, 0x0, 0x7, 0x73, 0xe4, 0xd1, 0xe8, 0x2f, 0x76, 0x60, 0x53, 0x61, 0x9d, 0xea}, types.Tx{0x93, 0xb0, 0x3a, 0x89, 0x9f, 0x53, 0x4d, 0x6e, 0xf8, 0xe4, 0x65, 0x6f, 0x68, 0x8a, 0x99, 0xc0, 0x47, 0x33, 0x30, 0x75, 0x39, 0x96, 0x46, 0x53, 0x27, 0x28, 0xda, 0xb2, 0x56, 0xc0, 0x87, 0xe7, 0x12, 0xd2, 0x49, 0x51, 0x28, 0xbb, 0x29, 0x43, 0x70, 0xd1, 0x67, 0xdd, 0xae, 0x65, 0xfd, 0xa8, 0xaf, 0xff, 0x41, 0x14, 0x57, 0x65, 0xce, 0x9e, 0x83, 0xe1, 0xa1, 0x1e, 0xae, 0x72, 0x2a, 0x28, 0xbe, 0xbc, 0xb7, 0x5f, 0x9e, 0x38, 0x5b, 0x1e, 0x2b, 0x17, 0xf7, 0x69, 0xbf, 0x1c, 0x88, 0xbb, 0x1, 0x92, 0x5e, 0x57, 0x66, 0x6d, 0xbe, 0x88}, types.Tx{0x49, 0xf1, 0x75, 0x5d, 0xe, 0x57, 0x90, 0xd, 0xfd, 0x65, 0x75, 0xaf, 0xa9, 0x3b, 0xe8, 0xa2, 0x1a, 0x4f, 0x8b, 0x9b, 0xf8}, types.Tx{0xe5, 0xcd, 0xf, 0x9f, 0xa9, 0x8c, 0xe9, 0xe1, 0xc9}, types.Tx{0xaa, 0x34, 0x7f, 0x47, 0x2b, 0x71, 0xdb, 0xb3, 0x72, 0x3f, 0x71, 0x86, 0x10, 0xbf, 0xca, 0x1e, 0x9d, 0x9f, 0xea, 0x73, 0x69, 0xf3, 0x8, 0x66, 0xb7, 0xd1}, types.Tx{0x82, 0xd4}, types.Tx{0x5d, 0x54, 0x86, 0x27, 0xd7, 0x7e, 0x40, 0xe7, 0xd1, 0x1a, 0x95, 0x62, 0x69, 0x38, 0xa6, 0x6b, 0xb8, 0x8d, 0xe8, 0xe5, 0x92, 0x4a, 0xd3, 0xab, 0xdc, 0x4, 0x82}, types.Tx{0xda, 0xa, 0x40, 0x3d, 0x50, 0xf5, 0x1a, 0xe4, 0xc8, 0xd3, 0xe6, 0x16, 0x59, 0xdd, 0xee, 0xb4, 0xb0, 0x6b, 0xaf, 0xfd, 0x5, 0x16, 0xbe, 0x19, 0x10, 0x39, 0xef, 0x5, 0xe8, 0xd3, 0x8e, 0x40, 0x92, 0xc0, 0xd3, 0xb7, 0xba, 0x68, 0x3d, 0xb, 0x14, 0x33, 0xb4, 0x71, 0x27, 0xc8, 0xfd, 0xd1, 0xc2, 0x92, 0x31, 0x16, 0x99, 0xe8, 0x1e, 0x54, 0x18, 0xc9, 0x68, 0xef, 0x66, 0x27, 0x7d, 0xf9, 0x85, 0x8d, 0xae, 0x8f, 0x1a, 0xaf, 0x98, 0x2b, 0x89, 0xba, 0xa0, 0xe4, 0x9d, 0xb4, 0x62, 0xf7, 0xc4, 0x5e, 0x75, 0xd0, 0xe8, 0x96, 0x61, 0x51, 0x66, 0xc0, 0xd3, 0x47}, types.Tx{0x82, 0x3b}, types.Tx{0x2f, 0x3b, 0x89, 0xcd, 0xd, 0x9c, 0x99, 0x78, 0x30, 0x71, 0x4b, 0x2d}, types.Tx{0x99, 0xff, 0x89, 0x11, 0x8c, 0xa7, 0x97, 0x9d, 0x5b, 0x2e, 0xc8, 0x37, 0xd6, 0x93, 0xc3, 0xeb, 0xd5, 0xdd, 0x35, 0x28, 0x3e, 0x15, 0x62, 0x83, 0x5, 0xaa, 0x9b, 0xb1, 0xb, 0xa3, 0xd3, 0x7e, 0xa4, 0x77, 0x7, 0x76, 0xe9, 0x17, 0x79, 0xb9, 0xda, 0xe5, 0xf3, 0xc5, 0x5f, 0xdf, 0x4e, 0x5d, 0xde}, types.Tx{0xd, 0xa7, 0xc4, 0xf4, 0xa9, 0x87, 0xa1, 0x34, 0xa1, 0x49, 0x59, 0x1d, 0x88, 0x58, 0xfc, 0xa6, 0x4a, 0xe3, 0xd2, 0x5b, 0xf8, 0xb5, 0xf, 0x99, 0x45, 0x4e, 0x37, 0xfc, 0x89, 0xb1, 0x2b, 0xdc, 0xfc, 0x5a, 0x27, 0xf2, 0xd9, 0x30, 0x6f, 0x7d, 0x3b, 0xe2, 0xc3, 0xd0, 0x10, 0xbb, 0xb0, 0xde, 0x41, 0xe2, 0x71, 0x1c, 0x3, 0xa6, 0x11, 0x15, 0x2f, 0xcd, 0xb, 0x31, 0xdf, 0x33, 0xff, 0xe5, 0x63, 0xb6, 0x8f, 0x3, 0x53, 0x86, 0xa0, 0x1b, 0x7b, 0xac, 0xd1, 0x9c, 0x7b, 0x41, 0x50, 0x9c, 0x51, 0x75}, types.Tx{0x3a, 0xcf, 0xc4, 0xa1, 0x27, 0xad, 0xe0, 0x5b, 0x43, 0x3f, 0x45, 0x6d, 0x9d, 0x15, 0x8a, 0xf4, 0x29, 0xea, 0x30, 0x5b, 0x29, 0xad, 0x34, 0x8e, 0x54, 0x8c, 0xcb, 0xfc, 0x13, 0xa6}, types.Tx{0x98, 0x8, 0x38, 0x2b, 0x50, 0xfd, 0x2, 0x65, 0x2f, 0x2c, 0xcc, 0x45, 0x96, 0xd8, 0xa6, 0x7f, 0xab, 0xf8, 0xca, 0xb9, 0x38, 0x6e, 0x96, 0xd3, 0x14, 0xe8, 0x8c, 0x69, 0x2f}, types.Tx{0x93, 0x96, 0xe7}, types.Tx{0x15, 0x95, 0x69, 0xea, 0x57, 0xc, 0xc3, 0x2a, 0x10, 0x7c, 0xec, 0x4, 0xb0, 0xdb, 0x9a, 0x2c, 0xdd, 0xd4, 0x3f, 0x7d, 0xe5, 0x37, 0xa4, 0x4f, 0xde, 0xaf, 0xf9, 0x9e, 0x83, 0x8b, 0x11, 0xd8, 0x6f, 0xcf, 0xb9, 0xea, 0xb6, 0x8f, 0x27, 0x6a, 0x9a, 0x1f, 0x79, 0x34, 0xad, 0x5, 0xa1, 0x58, 0x4e, 0x21, 0x54, 0xa5, 0xd2, 0xdf, 0x91, 0xc5, 0x50, 0xcf, 0xd5, 0x82, 0x64, 0x7c, 0x7d, 0xc6, 0xc4, 0x92, 0xfe, 0xbd, 0x11, 0x42, 0x95, 0x20, 0xb0, 0x12, 0x25, 0x4, 0x2f, 0x9c, 0xff, 0x54, 0x9d, 0xe1, 0x5e, 0xf8, 0x21, 0x96, 0xcc, 0x63, 0x3a, 0x6, 0x9}, types.Tx{0x54, 0x98, 0xa4, 0x53, 0x23, 0x50, 0xe7, 0xb1, 0x51, 0xc9, 0x40, 0xf0, 0x4a, 0x83, 0xb0, 0x62, 0x91}, types.Tx{0xbe, 0xc9, 0x74, 0x70, 0x2d, 0xae}, types.Tx{0xb8, 0xa3, 0x21, 0x4c, 0x83, 0x44, 0x87, 0xb8, 0x2b, 0x10, 0x82, 0x91, 0xd7, 0xb, 0xd2, 0x10, 0xf6, 0x96, 0x46, 0xef, 0x73, 0x16, 0x89, 0x16, 0xc2, 0x77, 0x75, 0x88, 0x93, 0xda, 0xa2, 0xd4, 0x3e, 0xc4, 0xe4, 0xea, 0x1d, 0x81, 0x18, 0xfc, 0x7d, 0x7, 0x94, 0xdc, 0x2c, 0xd5, 0xc, 0x7c, 0xf8, 0x9d, 0xb, 0x99, 0x41, 0xae, 0x67, 0xcd, 0x88}, types.Tx{0x5a, 0xa2, 0xe2, 0x31, 0x4f, 0xc0, 0x77, 0x7, 0x26, 0xbf, 0x5f, 0x1d, 0xc7, 0xfe, 0x7a, 0x2e, 0xd4, 0xc8, 0x4d, 0x58, 0x90, 0x2f, 0xbf, 0x95, 0xe6, 0xbf, 0xb9, 0x44, 0xd, 0x7f, 0x2d}, types.Tx{0xfd, 0xc7, 0x1e, 0x52, 0x42, 0xe3, 0xf, 0xdc, 0x98, 0xe, 0x8b, 0x51, 0x11, 0x21, 0x89, 0xfc, 0x63, 0x9, 0xcc, 0xf0, 0x82, 0x5d, 0xbb, 0xe2, 0x18, 0xc, 0xc2, 0x9, 0xa4, 0x23, 0x89, 0xbf, 0xab, 0x50, 0x26, 0xa8, 0x42, 0xc1, 0xff, 0xdd, 0x2f, 0x5a, 0xa4, 0x3, 0x8f}, types.Tx{0x4b, 0xb8, 0x87, 0xd1, 0x8d, 0x5c, 0x4d, 0xe1, 0x82, 0x50, 0x94, 0x5b, 0xdc, 0x63, 0xc2, 0xd1, 0x79, 0x66, 0x17, 0xda, 0xf0, 0x6d, 0xb9, 0x7d, 0xb6, 0x7c, 0xac, 0xe7, 0x24, 0x5f, 0x34, 0x81, 0xdb, 0xaf, 0x60, 0x94, 0x14, 0x8d, 0x84, 0xd5, 0xb7, 0x0, 0x8d, 0xa5, 0x54, 0xa3, 0x32, 0x19, 0xe3, 0x7d, 0x33, 0x2f, 0x7f, 0xf, 0x18, 0xc4, 0xa6, 0x9e, 0x24, 0x30, 0xf7, 0x1c, 0x5c, 0xe2, 0xf1, 0xbd, 0x60, 0x48, 0xf8, 0xa8, 0x6f, 0xb4, 0xc4, 0xcb, 0x8e, 0x14, 0xd, 0x6f, 0xfb, 0xa}, types.Tx{0x40, 0x4d, 0x29, 0x4d, 0x8c, 0x3f, 0x1c, 0xcc, 0x73, 0x2f, 0x88, 0x9d, 0xa9, 0x33, 0xbd, 0xf3, 0xbf, 0x7e, 0x53, 0x36, 0xa, 0x33, 0x1f, 0x1c, 0x5a, 0x52, 0x7f, 0xed, 0x67, 0x1e, 0x21, 0x8, 0x8c, 0x18, 0xa0, 0xf2, 0x85, 0x7d, 0xd7, 0xcc, 0x77, 0xf, 0x43, 0x30, 0x1e, 0x1b, 0xa0, 0xfa, 0xd6, 0xc, 0xf, 0xa1, 0x6, 0xa9, 0xf6, 0xe5, 0xfb, 0xc0, 0x84, 0xa4, 0xd4, 0x7b, 0xa6, 0x73, 0x15, 0x62, 0x53, 0xe8, 0x61, 0x9f, 0x7c, 0xda, 0x35, 0x32, 0x44, 0xa6, 0xfe, 0x94, 0x3e, 0x8f, 0xe8, 0x1, 0xae, 0x9c, 0x43, 0xa, 0x72, 0x87, 0xcb, 0xe5, 0x75, 0xfc, 0x61, 0x81, 0x26, 0x26, 0x74, 0x45}, types.Tx{0xbc, 0x9, 0x42, 0xd4, 0x50, 0xe9, 0x2, 0x2d, 0xca, 0xf1, 0xe7, 0xa8, 0xc8, 0x13, 0x32, 0x13, 0x7c, 0x7f, 0x64, 0x87, 0x11, 0x5d, 0x51, 0xaa, 0xa0, 0x1e, 0xdc, 0x4e, 0xf8, 0xe2, 0xfd, 0xa8, 0xab, 0x4c, 0x6d, 0xc6, 0x93, 0xa, 0x14, 0x5e, 0x62, 0x56, 0x4d, 0x12, 0x43, 0x80, 0x0, 0x4f, 0x35, 0xcf, 0xf6, 0x3d, 0x3d, 0xcc, 0xda, 0xc4, 0x3b, 0x1f, 0xdd, 0xc5, 0x49, 0x54, 0xb3, 0xed, 0xe9, 0x45, 0xd4, 0x90, 0xc5, 0x9e, 0x55, 0x58, 0xcb, 0x79, 0xfd, 0xa3, 0x33, 0x3f, 0xa5, 0x21, 0xa8, 0xf3, 0x20, 0x30, 0x77, 0x31, 0x6d, 0x12, 0x55, 0x13, 0xf9, 0x4b, 0xec, 0x5a, 0xbb, 0x5c, 0xd, 0x92}, types.Tx{0xb8, 0x5d, 0x3d, 0xe3, 0xd0, 0x32, 0x5, 0xa9, 0x8e, 0x16, 0xd7, 0xff, 0xa1, 0xed, 0xa5, 0x6, 0x7a, 0xbf, 0xdd, 0x9b, 0xdb, 0x2, 0xd3, 0x5d, 0xf1, 0x9e, 0xfd, 0xda, 0x62}, types.Tx{0x97, 0x93, 0xf5, 0xca, 0x2, 0x7f, 0xfb, 0xab, 0xc4, 0x3, 0x15, 0x11, 0xce, 0xa5, 0x56, 0x35, 0x3, 0x6d, 0xea, 0x35, 0x49, 0x48, 0x2c, 0x8c, 0x3a, 0xfd, 0x59, 0x24, 0xd3, 0xd6, 0x12, 0x5d, 0x31, 0x3d, 0x93, 0x3d, 0x3, 0xb, 0x3e, 0x5f, 0x47, 0x21, 0xe5, 0x3a, 0xc3, 0xa6, 0x8c, 0x57, 0xa7, 0x9, 0x88, 0x81, 0x44, 0xb5, 0x6e, 0x75, 0xbb, 0xc4, 0x21, 0xdf, 0x3b, 0x3b, 0x40, 0xb4, 0xe2, 0x4c, 0x85, 0x91, 0x9, 0xdb, 0x68, 0x33, 0x76, 0x83, 0xea, 0xe7, 0xea, 0xea, 0x82, 0xc7, 0xe4}, types.Tx{0xce, 0xb2, 0x3c, 0x14, 0xa4, 0xe6, 0x2a, 0x6d, 0x74, 0x7d, 0x2c, 0x96, 0xeb, 0x88, 0xdf, 0x41, 0xd3, 0x4a, 0xd3, 0xb2, 0xc8, 0x1b, 0x12, 0xdf, 0x76, 0x6b, 0xe6, 0xbb, 0xaf, 0x87, 0xa4, 0xea, 0xbd, 0xcd, 0x4a, 0x46, 0xbc, 0xc1, 0xb8, 0x31, 0xeb, 0x18, 0xc9, 0xef}, types.Tx{0x6c, 0x0, 0x84, 0x8c, 0x9b, 0x82, 0x86, 0x88, 0xb, 0x9d, 0xd7, 0xca, 0x26, 0xa4, 0x8f, 0xa7, 0x3c, 0x59, 0xe8, 0x17, 0x30, 0xc1, 0x7d, 0x2b, 0xe8, 0x8e, 0x88, 0x32, 0x13, 0xa6, 0x5d, 0x9d, 0x65, 0x27, 0x38, 0x1c, 0x21, 0xc3, 0x25, 0x66, 0xb1, 0xb2, 0xc5, 0xdc, 0xaa, 0xab, 0x70, 0x9d, 0x40, 0x47, 0x8e, 0xa8, 0xd5, 0x1c, 0x94, 0x49, 0x4c, 0x6f, 0x20, 0x92, 0xe3, 0x26, 0xc5, 0x8e, 0xd3, 0x1b, 0x6a, 0xc5, 0xaf, 0x25, 0x29, 0x16, 0x13, 0x8, 0xff, 0x90, 0x89, 0xbc, 0x56, 0x5e, 0xd8, 0xfe, 0xe4, 0x8, 0x19, 0x8a}, types.Tx{0x25, 0x75, 0x77, 0xa, 0x29, 0x10, 0x2a, 0xcc, 0xd5, 0xdb, 0xba, 0xcd, 0x67, 0x3f, 0xd0, 0x93, 0x3e, 0xb7, 0x8c, 0x2, 0x46, 0x1b, 0x65, 0x9b, 0xe, 0x72, 0xfa, 0xc4, 0xfa, 0x22, 0xc4, 0xec, 0xd6, 0x66}, types.Tx{0xa3, 0x1e, 0x32, 0xa6, 0x9e, 0x17, 0x6b, 0x1a}, types.Tx{0x9f, 0xc0, 0x29, 0x43, 0x51, 0xc0, 0x1d, 0x76, 0xa6, 0x9e, 0x9c, 0xb0, 0x5d, 0xc9, 0xb1, 0x8e, 0xc4, 0x9f, 0xc4, 0xcf, 0xe1, 0x3f, 0x39, 0xbe, 0x89, 0x23, 0x4c, 0x88, 0x6c, 0x59, 0xe1, 0x8a, 0x36, 0x17, 0xc2, 0xaa, 0x23, 0x7a, 0x73, 0xf, 0xb5, 0x47, 0x93, 0xda, 0x2a, 0x98, 0xa, 0x74, 0x0, 0x7c, 0x87, 0xb4, 0x4e, 0xca, 0x9e, 0x97, 0xe7, 0x7f, 0x7e, 0xc0, 0x10, 0x5b, 0xbb, 0x93, 0xbd, 0x5b, 0xf2, 0x36, 0x9b, 0x5a, 0xb7, 0xf2, 0x37, 0x58, 0xef, 0x10, 0x10, 0x6b, 0x89, 0x6d, 0xb6, 0x14}, types.Tx{0xa6, 0xe0, 0xa6, 0x9a, 0x77, 0xee, 0xf4, 0xd9, 0x57, 0x3a, 0xdf, 0x5c, 0x8f, 0x98, 0x8d, 0x55, 0x76, 0x16, 0xc4, 0xc1, 0x75, 0x88, 0x89, 0x9b, 0xa7, 0x1f, 0x85, 0xad, 0xea, 0xe3, 0x1, 0xc7, 0xd, 0xf0, 0xd1, 0x69, 0x5c, 0xf9, 0x17, 0x7f, 0xb6, 0x2a, 0xe9, 0xb1, 0x19, 0x74, 0x81, 0x55, 0xcb, 0xc9, 0xf2, 0x8e, 0x44, 0x6c, 0xdf, 0x1d}, types.Tx{0xde, 0xb9, 0xb9, 0xed, 0x92, 0xc1, 0x33, 0x4e, 0xbb, 0x95, 0x5e, 0xd0, 0x55, 0x64, 0xc7, 0xdf, 0x3, 0x7c, 0xc, 0x79, 0x82, 0xe, 0xb0, 0xcf, 0xfe, 0xb4, 0x9c, 0x4f, 0xc7, 0x2e, 0xae, 0x9, 0xea, 0xaf, 0x9, 0xae, 0xba, 0x5d, 0xab, 0xc0, 0xce, 0x37, 0xa5, 0x25, 0x9f, 0xbb, 0xae, 0xc4, 0xd1, 0x11, 0xf7, 0x77, 0x6b, 0xed, 0xa8, 0xf0, 0x9f, 0x93, 0x6c, 0x94, 0x14, 0x87, 0xc2, 0x2c, 0x23, 0xa1, 0x50, 0xe, 0xab, 0xc6}, types.Tx{0xfa, 0x16, 0x15, 0x1, 0xb4, 0x16, 0x7b, 0x76, 0x3c, 0x8d, 0x71, 0xa2, 0x6c, 0x6d, 0xad, 0xb7, 0x5b, 0xfd, 0x40, 0x80, 0x3e, 0xc, 0x96, 0xc1, 0x8d, 0xb9, 0xf8, 0x6c, 0x26, 0x3, 0xed, 0xd4, 0xbe, 0x2d, 0x6b, 0x79, 0x63, 0x8a, 0xae, 0x3a, 0x87, 0xb1, 0xa6, 0xe6, 0x99, 0x6e, 0x14, 0x69, 0x5d, 0xba, 0xe4, 0xcf, 0x5b, 0x3a, 0x41, 0x3c, 0xe9, 0xde, 0x49, 0xab, 0x1f, 0x13, 0x72, 0x28, 0xab, 0x1f, 0xd9, 0x55, 0x91, 0x9b, 0x58, 0xfc, 0x5f, 0x45, 0x13, 0x3b, 0x80, 0x7d, 0xcf, 0xf2, 0xca, 0xc, 0x7f, 0x96, 0xff, 0xe4, 0x60, 0x32, 0xd4, 0xf3, 0x2a, 0x14, 0xa, 0xc0, 0x93}, types.Tx{0x5e, 0x20, 0xd3, 0x96, 0xc9, 0x25, 0x6d, 0x45, 0x31, 0x56, 0xbc, 0x63, 0x75, 0xd1, 0xe8, 0xa8, 0x21, 0x3a, 0xa2, 0x93, 0x2b, 0x7f, 0xd0, 0xce, 0x72, 0xe, 0xbc, 0x32, 0x35, 0xf5, 0x25, 0x75, 0xf3, 0x63, 0x54, 0xb4, 0x6a, 0xdf, 0xee, 0x38, 0x59, 0x5b, 0x7c, 0x11, 0x7e, 0x6, 0x41, 0xdb, 0x41, 0x95, 0x2d, 0x6b, 0x38, 0xb9, 0xab}, types.Tx{0x2a, 0x59, 0x90, 0x29, 0x36}, types.Tx{0x76, 0x58, 0xe7, 0x60, 0xd9, 0x8, 0x69, 0xa0, 0xb4, 0x80, 0x83, 0xc2, 0x6e, 0xc1, 0x90, 0x1c, 0xd3, 0x8, 0xef, 0x5b, 0xc, 0x5b, 0x82, 0xeb, 0x94, 0xd4, 0xe5, 0x49, 0x10, 0x74, 0x5a, 0x92, 0x72, 0x1f, 0x19, 0x60, 0x51, 0xde, 0x9d, 0x93, 0x84, 0x3, 0x1c, 0xab, 0x14, 0xe0, 0x11, 0xd6, 0x1d, 0x41, 0x7e, 0x18, 0xf6, 0x2f, 0x89, 0xc2, 0x5, 0x76, 0x9e, 0x2d, 0x5f, 0x43, 0xc4, 0xd4, 0x7a, 0x9f, 0x32, 0x14, 0xcc, 0xf7, 0xb2, 0x5d, 0xd6, 0xa5, 0x74, 0xcf, 0xd5, 0x16, 0xf8, 0x9b, 0x1a, 0xd8, 0x5, 0x44}, types.Tx{0x80, 0xde, 0x58, 0xc1, 0x7e, 0xe6, 0x56, 0x4d, 0x44, 0x78, 0x30, 0xcd, 0x62, 0x9e, 0x96, 0x6, 0xf2, 0x92, 0x9b, 0x26}, types.Tx{0xcc, 0x63, 0xa2, 0xcd, 0xfb, 0xfa, 0xa4, 0x32, 0xd6, 0x91, 0x7d, 0x83, 0x61, 0x63, 0x8d, 0x2c, 0x89, 0xda, 0xa0, 0x4a, 0x8c, 0x9a, 0xa, 0x0, 0xa0, 0x68, 0xa, 0x93, 0xf7, 0x8a, 0x33, 0x1f, 0x88, 0x6e, 0xc8, 0xce, 0x2c, 0x60, 0x13, 0x53, 0x6f, 0x12, 0x9f, 0xe2, 0xb, 0xc1, 0xf, 0x23, 0x8e, 0xd7, 0xf4, 0x36, 0xf6, 0x62, 0xa9, 0x1a, 0x91, 0x6b, 0x50, 0xed, 0xf6, 0x4d, 0x45, 0x99, 0x6f, 0xaa, 0x58, 0x5d, 0x34, 0x14, 0xf1, 0x76, 0xf6, 0x8b, 0xc3, 0x90, 0x44, 0x74, 0xca, 0x3f, 0xa5, 0xdf, 0xed, 0x5e, 0x7d, 0x3d, 0xb7, 0xe9}, types.Tx{0xfa, 0x67, 0x5, 0x39, 0x8, 0x4a, 0x3, 0x5d, 0x30, 0xb8, 0x95, 0x53, 0x92, 0xa7, 0x3f, 0x15, 0xbc, 0x8d, 0xe9, 0xd4}, types.Tx{0x28, 0x90, 0xe1, 0xc5, 0xe2, 0x70, 0x2d, 0x98}, types.Tx{0x6c, 0x44, 0xe3, 0x6d, 0x9a, 0xcc}, types.Tx{0x76, 0x18, 0x87, 0xbc, 0xdd, 0xad, 0x39, 0x1a, 0x15, 0x27, 0xed, 0x47, 0xf3, 0xea, 0x7c, 0x4b, 0x21, 0xa7, 0x1a, 0x10, 0xd2, 0xfb, 0x1, 0x43, 0x5e, 0x4f, 0x3f, 0x64, 0x8c, 0xd4, 0x88, 0xf1, 0x61, 0x5d, 0xc2, 0x64, 0xe, 0xbe, 0x63, 0xb2, 0xa9, 0x68, 0x88, 0x17, 0x2, 0x86, 0x9, 0x1e, 0x18, 0x97, 0xe7, 0xa5, 0xa7, 0xb2, 0xed, 0xc0, 0x2f, 0x33, 0x46, 0xbe, 0xbd}, types.Tx{0x32, 0x4d, 0x45, 0xc1, 0xb7, 0x41, 0x8, 0xc4, 0x4d, 0xc3, 0x15, 0x8, 0xb5, 0x86, 0x20, 0x2d, 0xe, 0x80, 0xe7, 0xf9, 0x6a, 0xc7, 0xab, 0xdd, 0x5d, 0xa8, 0x63, 0x72, 0x2, 0x78, 0xf2, 0x6d, 0xde, 0xa0, 0xfc, 0x17, 0xa2, 0xa7, 0x68, 0x8, 0xe7, 0x7f, 0xc8, 0xc, 0x6e, 0xd8, 0xea, 0x7f, 0xd3, 0x2b, 0xfe, 0xa5, 0x8a, 0xb8, 0xf2, 0xa8, 0x54, 0x5f, 0x1c, 0x2d, 0xde, 0xc1, 0xfd, 0xcb, 0xa3, 0x60, 0x37, 0xeb, 0x15, 0xdf, 0x3e, 0xc1, 0x93, 0x6d, 0xb0, 0xcc, 0xb, 0xa, 0x4b, 0x36, 0xfa, 0xa6, 0x3c, 0xbf, 0x68, 0xb8, 0x68, 0xd, 0xd8, 0x7a}, types.Tx{0x6e, 0x13, 0x15, 0x7d, 0xc3}, types.Tx{0x22, 0x59, 0xec, 0x94, 0xd7, 0xab, 0xd6, 0xdd, 0x2e, 0x3c, 0x12, 0x4b, 0x2d, 0xea, 0xbe, 0x46, 0x18, 0xdd, 0x7c, 0x70, 0x44, 0xb1, 0x32, 0x7b, 0xda, 0x48, 0xca, 0x40, 0x95, 0x10, 0x70, 0x7d, 0x6d, 0xf0, 0x14, 0x89, 0x5e, 0xe9, 0x5d, 0xfe, 0x53, 0x6c, 0x7f, 0x1f, 0xbd, 0xb2, 0x2e, 0x2c, 0x6e, 0xdb, 0xef, 0x5b, 0x55, 0x8, 0xc2, 0x91, 0xdc, 0x93, 0x7c, 0x6b, 0x18, 0xbe, 0xf9, 0x27, 0xe5, 0x3a, 0xec, 0x4f, 0x5b, 0xdb, 0x97, 0x55, 0x2, 0xf3}, types.Tx{0x4c, 0xd2, 0x2a, 0xe1, 0x9, 0x14, 0xb1, 0xf5, 0xff, 0xeb, 0x7b, 0x19, 0x66, 0x30, 0x3b, 0xd6, 0xd8, 0x84, 0x40, 0x56, 0x7e, 0x80, 0x11, 0x56, 0xb2, 0xbc, 0x2a, 0xf0, 0x2a, 0x1e, 0x6f, 0x25, 0x51, 0x7d, 0x7b, 0x3b, 0x51, 0x89, 0x79, 0xb5, 0x7f, 0x6e, 0x50, 0xbd, 0x2d, 0xfd, 0xb, 0xa7, 0x6f, 0xc1, 0xeb, 0xb5, 0x44, 0x14, 0xd4, 0x20, 0xd5, 0xe0, 0x98, 0x1d, 0x5a, 0xc1, 0x9e, 0x73, 0xca, 0xa0, 0xbe, 0xe3, 0x54, 0x37, 0xe1, 0x52, 0xed, 0x6e, 0xb3, 0x67, 0x40, 0xf7, 0x3e, 0xae, 0x20, 0x37, 0xad, 0x2e, 0x1e}, types.Tx{0xbe, 0xf0, 0x53, 0xd1, 0x7e, 0x71, 0x60, 0x61, 0xbc, 0xd1, 0xe5, 0xd8, 0x71, 0xe7, 0x73, 0x1d, 0xfb, 0xa0, 0x17, 0xa, 0x43, 0xc2, 0x31, 0x51, 0xff, 0xde, 0x45, 0xd7, 0x7a, 0x98, 0xad, 0xdd, 0x40, 0xe3, 0x16, 0x60, 0x2d, 0xf3, 0x22, 0x3f, 0xf9, 0xef, 0x13, 0x45, 0xe6, 0x6b, 0x6, 0x54, 0xb7, 0xff, 0xbe, 0xd, 0x41, 0x1d, 0x63, 0xc2, 0xf5, 0x6a, 0x8b, 0xc0, 0x2, 0x74, 0xbb, 0xd3, 0xcb, 0xd7, 0xe1, 0xfc, 0x27, 0x33, 0x34, 0x67, 0x16, 0x7d, 0x46, 0x58, 0xd7, 0x2a, 0x4c, 0x6f, 0xb8, 0x6, 0x3f, 0xe1, 0xb3, 0xe4, 0x89, 0xa0, 0xbc, 0xb2, 0x77, 0x40, 0x8, 0x59, 0x80, 0x93, 0xde, 0x5d}, types.Tx{0x2c, 0xb2, 0xf0, 0x7b, 0x2, 0xc1, 0x9a, 0x45, 0x78, 0x8a, 0xe4, 0xd8, 0x2f, 0x17, 0xbb, 0xb, 0x96, 0xd4, 0x2d, 0x99, 0xc9, 0xa5, 0x18, 0x3d, 0x92, 0x74, 0x50, 0x87, 0x1e, 0xd6, 0x72, 0x8b, 0x8f, 0xba, 0xe1, 0x30, 0xc8, 0xaf, 0x14, 0x8e, 0x13, 0x29, 0xf5, 0x7f, 0x27, 0xf7, 0x16, 0xd4, 0xfe, 0xfd, 0x55, 0xa8, 0xf6, 0x8a, 0xbc, 0x1f, 0xf0, 0xde, 0xcf, 0x97, 0x4e, 0x2b}, types.Tx{0x70, 0x18, 0x60, 0x49, 0x9d, 0x1a, 0xb7, 0xcb, 0x4e, 0xe1, 0x62, 0x3f, 0xa0, 0x35, 0x1e, 0x9e, 0xdd, 0x76, 0xa1, 0x15, 0xf4, 0x49, 0xad, 0xc, 0xea, 0xec, 0x9f, 0xa2, 0xd6, 0x29, 0x66, 0x8b, 0xe9, 0x52, 0x2a, 0x3b, 0x7f, 0xc9, 0x10, 0x3b, 0x63}, types.Tx{0x4e, 0xaf, 0x18, 0x23, 0x68, 0x65, 0xdb, 0x0, 0x20, 0xef, 0xbf, 0xb8, 0xa7, 0x9e, 0xd5, 0xc9, 0x9c, 0x4, 0x82, 0xee, 0x6d, 0x9c, 0x3c, 0xe6, 0xe5, 0x5b, 0x4a, 0xa9, 0xd9, 0x0, 0xa2, 0xea, 0x84, 0x9, 0x5b}, types.Tx{0x27, 0xb8, 0xe2, 0xf6, 0xfb, 0x59, 0xa1, 0x30, 0x97, 0x5d, 0x97, 0x25, 0x6f, 0x3a, 0xe0, 0xee, 0xa3, 0xb0, 0xd7, 0x3b, 0xe1, 0x76, 0xd4, 0xba, 0x26, 0x35, 0xc4, 0x76, 0x39}, types.Tx{0x21, 0x32, 0x34, 0x23, 0xd7, 0x33, 0x2e, 0x54, 0x18, 0xe2, 0x4, 0x4a, 0xe0, 0x46, 0x47, 0xe5, 0x37, 0xb4, 0x2, 0xc6, 0x97, 0x53, 0x46, 0x42, 0x91, 0x92, 0xb4, 0x89, 0xea, 0x25, 0x7, 0x7a, 0x37, 0x48, 0x31, 0xcd, 0x7b, 0xb1, 0x98, 0x1b, 0xc7, 0x38, 0xf3, 0xe1, 0xe2, 0x6e, 0xae, 0xc2, 0xe9, 0x30, 0x41, 0xad, 0xb5, 0xbd, 0xb7, 0xd1, 0x3c, 0xef, 0xf8, 0x2b, 0xcf, 0x7, 0x3a, 0xb7, 0x84, 0xae, 0xe5}, types.Tx{0x94, 0x10, 0xd5, 0x7e, 0x1f, 0xe6, 0xf1, 0x72, 0x91, 0xa0, 0x2d, 0xb5, 0xfc, 0xe5, 0xfe, 0x2a, 0x3a, 0x9f, 0xf1, 0x62, 0xd7, 0x60, 0xff, 0x97, 0xa0, 0xc6, 0xb7, 0xcb, 0x41, 0xc5, 0xd3, 0xb9, 0x14, 0xb6, 0xca, 0xf1, 0xf3, 0xa1, 0x18, 0xf, 0xa2, 0xee, 0xd9, 0x51, 0x1c, 0xab, 0x77, 0xc2, 0xcb, 0xb8, 0x4, 0xfc, 0x19, 0x18, 0xa1, 0xc5, 0xe7, 0x91, 0x8e, 0x81, 0x6e, 0xac, 0xfc, 0x8, 0xfe, 0xa3, 0x81, 0x5a, 0xde, 0x31, 0x42, 0x32, 0x75, 0xc4, 0x32, 0xad, 0xa1, 0x6e, 0xdb}, types.Tx{0x61, 0x62, 0x8, 0xdc, 0x2b, 0xde, 0x45, 0xb3, 0x83, 0x3f, 0x3, 0xd4, 0x9, 0x4b, 0xa7, 0x18, 0xef, 0x7d, 0x9a}, types.Tx{0x97, 0xa0}, types.Tx{0x13, 0x72, 0x6e, 0xdc, 0x78, 0xc8, 0xc9, 0x53, 0xa7, 0x72, 0x30, 0x9c, 0x94, 0x3a, 0xfb, 0x8f, 0xbb, 0x9d, 0xcf, 0x35, 0x41, 0x7a, 0xfa, 0xcb, 0x4e, 0xb2, 0x1e, 0x55, 0x60, 0xed, 0x9c, 0xec, 0x9a, 0x71, 0xd0, 0x2a, 0xa6, 0x2e, 0x19, 0xe2, 0x9c, 0xce, 0xcf, 0x99, 0x47, 0xa, 0xfd, 0x9f, 0x2a, 0xdd, 0x41, 0x90, 0x62, 0xef, 0xfc, 0x40, 0x1c, 0x10, 0x21, 0x57, 0xa2, 0x45, 0x22}, types.Tx{0xb5, 0x9, 0x52, 0x53, 0x63, 0x14, 0xc9, 0xe3, 0x5f, 0x3a, 0xdd, 0x4b, 0x26, 0xb9, 0x91, 0xd4, 0xc2, 0xc9, 0x9e, 0x21, 0x8d, 0xa, 0x71, 0x5c, 0xbc, 0xc7, 0x43, 0xec, 0x6c, 0x63, 0xdb, 0xe3, 0x75, 0xcc, 0x9d, 0xf4, 0x6e, 0xaf, 0x67, 0xe3, 0xde, 0x26, 0x11, 0x81, 0x1f, 0x76, 0x8, 0xcd, 0x5, 0xcd, 0x93, 0xac, 0xca, 0x3e, 0x3f, 0x2c, 0xeb, 0x1, 0xbc, 0x93, 0x33, 0xf9, 0xa3, 0x30, 0xdb, 0x86, 0x4, 0x1d}, types.Tx{0xcd, 0x0, 0x7b, 0x87, 0x86, 0x9f, 0xc, 0x39, 0x2c, 0xed, 0x7b, 0xbb, 0xb1, 0xff, 0xb2, 0x6e, 0xdd, 0x2f, 0x5b, 0xbd, 0x58, 0x25, 0xb1, 0xc2, 0x2d, 0xb5, 0xeb, 0x62, 0x41, 0xd9, 0x3c, 0xed, 0x3d, 0x55, 0x63, 0x8d, 0x75, 0xae, 0xbd, 0xb, 0x15, 0x58, 0xf4, 0xdc, 0xf8, 0x12, 0x35, 0xb3, 0x20, 0x34, 0x63, 0x68, 0xe8, 0xff, 0x2, 0xdf, 0xf, 0xa8, 0xd8, 0xc1, 0x66, 0x2f, 0xc6, 0xdb, 0xa2, 0xd1, 0xe1, 0x8e, 0x5e, 0xe0, 0x8f, 0x58, 0x46, 0xc8, 0x97, 0xec, 0xb1, 0x4f, 0x34, 0xfb, 0x71, 0xc9, 0x4, 0xc4, 0x2c, 0x4c}, types.Tx{0xcf, 0x85, 0x18, 0xba, 0x77, 0x23, 0xc0, 0xce, 0x20, 0xee, 0xb1, 0xbc, 0xdc, 0xc8, 0xad, 0xca, 0xb5, 0x3a, 0x5a, 0x1a, 0xef, 0xf4, 0x1c, 0x42, 0x39, 0xee, 0x7a, 0x53, 0xc0, 0xda, 0x77, 0xc5, 0x51, 0x4a, 0x70, 0xde, 0x9, 0xd1, 0x50, 0x2c}, types.Tx{0xee, 0x45, 0x99}, types.Tx{0xd2, 0x6a, 0x48, 0x82, 0x52, 0x27, 0xea, 0x20, 0x7c, 0xaf, 0xea, 0x63, 0xbc, 0x41, 0x2a, 0x2, 0x1d, 0x58, 0x8a, 0xb5, 0xee, 0x2f, 0x66, 0x4a, 0x8a}, types.Tx{0x97, 0x4, 0x14, 0x4e, 0x3b, 0x81, 0x24, 0xf1, 0xe1, 0xf9, 0xb2, 0xed, 0x26, 0xe2, 0x1d, 0x97, 0x49, 0x84, 0x48, 0x34, 0xb7, 0x32, 0xca, 0xf3, 0xe1, 0xaa, 0x52, 0xb6, 0x6b, 0x8b, 0x91, 0x9d, 0x97, 0xf3, 0xa8, 0x1, 0x71, 0x98, 0xb8, 0x98, 0xdb, 0x9a, 0x2c, 0xb6, 0xb, 0xf0, 0x1c, 0xb6, 0xf5, 0x1d, 0xd2, 0x75, 0x9e, 0x9a, 0x15, 0x4d, 0xb6, 0xc, 0xf8}, types.Tx{0x80, 0xf5, 0xaf, 0x70, 0x7e, 0x30, 0x1e, 0x63, 0xa2, 0x90, 0xc2, 0x38, 0x9b, 0xb, 0x45, 0x7a, 0xf7, 0x60, 0x4c, 0xee, 0xa6, 0x4a, 0x6, 0x6e, 0xf2, 0x5f, 0x93, 0x64, 0xc0, 0xe0, 0x8e, 0x65, 0xa9, 0x7, 0xf6, 0xfb, 0xab, 0x86, 0xbe, 0x1e, 0xc6, 0x31, 0xab, 0xc6, 0xdf, 0x66, 0x5a, 0xeb, 0x4f, 0xbc}, types.Tx{0x58, 0x33, 0xe6, 0xc1, 0x4c, 0x95, 0x25, 0x5c, 0xe7}, types.Tx{0x7d, 0xf, 0xf4, 0xae, 0x70, 0xbd, 0x87, 0x8c, 0x45, 0x76, 0x72, 0x1c, 0x4e, 0xc3, 0xd9, 0xed, 0xa5, 0xb9, 0x27, 0xab, 0xf2, 0x37, 0x75, 0xa0, 0xd3, 0x39, 0xb5, 0x70, 0x9e, 0xd5, 0x57, 0x70, 0x87, 0x57, 0x9, 0x12, 0xfc, 0x71, 0x7c, 0x7a, 0x8f, 0xbe, 0x69, 0xc4, 0x10, 0xec, 0xd8, 0x20, 0x82, 0x2, 0x15, 0xbf, 0x20, 0xbe, 0x84, 0xdd, 0x5, 0x63, 0xd, 0x40, 0x59, 0x44, 0x26, 0x94, 0xf2, 0xdd, 0x86, 0xbd, 0x3f, 0xf, 0x3e, 0x56, 0x1f, 0xfe, 0x32, 0x99, 0x35, 0x6a, 0xe0, 0xf7, 0xd8}, types.Tx{0xa0, 0x1f, 0xde, 0xd4, 0xe3, 0xe9, 0xba, 0x1, 0xca, 0x88, 0x8e, 0xb8, 0x59, 0x58, 0xe7, 0x92, 0x7d, 0xfb, 0xa9, 0xab, 0xb8, 0xf1, 0x61, 0x8, 0x64, 0x91, 0xcd, 0xc6, 0xea, 0xc0, 0xf2, 0x45, 0x44, 0xa2, 0xf6, 0x7c, 0x32, 0x86, 0x52, 0x27, 0x2d, 0x6f, 0xd0, 0xe1, 0xb3, 0x8e, 0xef, 0x10, 0xd5, 0xfc, 0xd8, 0x3a, 0x8, 0xa5, 0xd6, 0x98, 0x33, 0xb4, 0x4d, 0x13, 0x13, 0x10, 0xd, 0xe}, types.Tx{0xf, 0x5e, 0xc3, 0xb8, 0x49, 0x3c, 0xf0, 0xaf, 0x8a, 0x94, 0x99, 0x58, 0xc7, 0x1, 0x89, 0x2b, 0xb}, types.Tx{0xba, 0x63, 0xcb, 0x36, 0x44, 0x9b, 0x7, 0xa6, 0x94, 0xd9, 0x7e, 0x20, 0x6e, 0x45, 0x1e, 0x55, 0x21, 0x85, 0xbe, 0x7b, 0x45, 0x5e, 0x55, 0x63, 0xb0, 0xff, 0x62, 0x43, 0x89, 0x30, 0x3d, 0xe4, 0x43, 0x53, 0xfa, 0xb, 0xc5, 0x16, 0xfc, 0x11, 0x19, 0xb7, 0xd3, 0x4b, 0x5, 0xee, 0x7a, 0xb3, 0x19, 0x8c, 0x82, 0x84, 0xcd, 0x80, 0xcc, 0xf, 0x7, 0xac, 0xe8}, types.Tx{0x42, 0xb7, 0xc9, 0x1b, 0x66, 0x39, 0xf5, 0x97, 0x3, 0x7d, 0xb, 0x4d, 0xb, 0xea, 0x49, 0xbf, 0x2a, 0x9c, 0xa4, 0x3d, 0xf1, 0x39, 0xe8, 0xbc, 0x8f, 0x48, 0x98, 0xe7, 0xa3, 0xbc, 0x78, 0x27, 0xc9, 0x24, 0x66, 0xde, 0x11, 0x47, 0x87, 0xd9, 0xd3, 0x95, 0x56, 0x57, 0x99, 0x61, 0xf7, 0x9b, 0x85, 0x32, 0x6c, 0xe1, 0x58, 0x14, 0xaa, 0x18, 0xed, 0x6b, 0x83, 0x2f, 0xca, 0x40, 0x64, 0xe0, 0xea}, types.Tx{0x18, 0x47, 0xb0, 0xfe, 0x5d, 0x5, 0x1b, 0xd2, 0xd7, 0x18, 0x8b}, types.Tx{0x17, 0x6c, 0xfc, 0xe6, 0x70, 0x57, 0x19, 0xd0, 0x7e, 0xca, 0xff, 0x1e, 0x9d, 0xb0}, types.Tx{0x84, 0x70, 0xda, 0x2f, 0xb6}, types.Tx{0xe6, 0x3e, 0x62, 0x2b, 0xde, 0x1, 0x9d, 0xb2, 0xab, 0x4e, 0x7c, 0x22, 0x48, 0x6b, 0xb7, 0xd6, 0x48, 0xe3, 0xd1, 0xd0, 0xbb, 0xd8, 0x40, 0xde, 0x92, 0xbd, 0xc7, 0x38, 0x85, 0x10, 0x13, 0xf4, 0x76, 0x7b, 0xb0, 0x74, 0xde, 0xdb, 0x7f, 0x33, 0x95, 0x8f, 0x35, 0x5d, 0xe2, 0x70, 0x58, 0x3f, 0xb7, 0x69, 0x83, 0x6b, 0x73, 0xfd, 0xf7, 0xbf, 0xa, 0x6, 0x9, 0xfd, 0x74, 0x37, 0x1c, 0xd3, 0x71, 0xac, 0x18, 0xfa, 0x62, 0xf0, 0xb4, 0x45, 0xed, 0x1d, 0x57, 0xde, 0x62, 0x79, 0xfc, 0x95, 0xe9, 0x61, 0x62, 0xaf, 0xec, 0x3d, 0xa5, 0xaa, 0x75, 0x9b, 0xe2, 0x23, 0x2d}, types.Tx{0x1a, 0x27, 0xb7, 0xfe, 0x96, 0xe9, 0xb7, 0x59, 0x46, 0x9e, 0xc2, 0x8c, 0x6e, 0x0, 0xa4, 0x89, 0x2a}, types.Tx{0x51, 0x5f, 0x65, 0xd, 0x3e, 0xa1, 0xec, 0x9b, 0xe, 0x80, 0x4f, 0x1f, 0x3f, 0xf7, 0xad, 0x83, 0xb7, 0xfa, 0xc4, 0x6e, 0xc4, 0x4c, 0xa3, 0xbd, 0xde, 0xc6, 0xbf, 0xd2, 0x86, 0x74, 0xaa, 0xa7, 0x4f, 0x4, 0x44, 0x41, 0xc2, 0xf8, 0xdf, 0xa6, 0x8a, 0xa0, 0x93, 0xa7, 0xe2, 0xc2, 0xd2, 0xae, 0xa3, 0x79, 0xfa, 0xd4, 0x9f, 0xb6, 0xe4, 0x3a, 0x4a, 0x31, 0x8d, 0x22, 0x4b, 0x29, 0x68, 0xae, 0x99, 0x50, 0x95, 0x3, 0xe4, 0x32, 0x55, 0xa, 0x50, 0x50, 0xf7, 0x47, 0x71, 0xc7, 0x24, 0x9f, 0xbb, 0xee, 0x83, 0x7a, 0x72, 0x9e, 0x27, 0xd1, 0x76, 0x30, 0xcf, 0x42, 0xe8, 0xd1, 0xcf, 0x84}, types.Tx{0x7a, 0xbb, 0x9d, 0x4e, 0x57, 0xf3, 0x9d, 0x92, 0x94, 0xef, 0x94, 0x2e, 0x34, 0xc0, 0xa4, 0x3f, 0x4, 0x2c, 0x44, 0xdd, 0x54, 0x7, 0x1e, 0x17, 0xab, 0xcd, 0x49, 0x7e, 0xb3, 0x1d, 0x94, 0x5, 0x3b, 0x69, 0x3c, 0x77, 0x53, 0xb8, 0xa9, 0xf2, 0xf8, 0xc4, 0x89, 0x43, 0x2f, 0xa, 0x43, 0xe, 0x2f, 0x9, 0x27, 0xdb, 0xcd, 0xdc, 0xf, 0x6c, 0x46, 0xf7, 0x40, 0x31, 0xb, 0xc2, 0xe6, 0xf2, 0x3e}, types.Tx{0x44, 0xb2, 0xbd, 0xda, 0xbc, 0x11, 0xa4, 0x19, 0xa, 0x34, 0x87, 0x8c, 0x1e, 0x3e, 0xb8, 0x3b, 0xc5, 0x63, 0x13, 0xda, 0x65, 0x45, 0xe3, 0x51, 0x99, 0xd7, 0x5e, 0x83, 0x89, 0x6a, 0xb0, 0x79, 0x45, 0xe1, 0xd0, 0x92, 0x76, 0x96, 0x65, 0x7c, 0x27, 0x2a, 0x7c, 0xfd, 0x2b, 0xf1, 0x19, 0x7b, 0xc8, 0x8f, 0x22, 0x4d, 0x8b, 0x15, 0xe1, 0xee, 0x1f, 0xf0, 0xb, 0x9f, 0x5c, 0xb0, 0x96, 0x53, 0x2a, 0x60, 0x49, 0x33, 0xc0, 0x6b, 0xf3, 0x67, 0x4d, 0x91, 0xc3, 0xf3, 0x42, 0x18, 0x7e, 0x8c, 0x4c, 0xfd, 0x5f, 0xc, 0xea, 0xcf, 0xf3, 0x4f, 0x78, 0xd5, 0x41, 0xeb, 0x4f, 0xd3, 0x17, 0x58}, types.Tx{0x93, 0xa2, 0x7f, 0x3d, 0xba, 0xf3, 0x76, 0x96, 0xd0, 0x58, 0x11, 0x87, 0xa7, 0x56, 0xd4, 0xcc, 0x3d, 0xc, 0xb5, 0x10, 0xc2, 0xe1, 0xdf, 0xac, 0x3b, 0xcc, 0x3b, 0x22, 0x7b, 0xfa, 0xb5, 0xce, 0xa6, 0xb6, 0xd0, 0x94, 0x18, 0xef, 0x3b, 0xb5, 0xa9, 0xe5, 0xe5, 0x66, 0x3e, 0xc9, 0x70, 0xe5, 0x6d}, types.Tx{0x6d, 0xbf, 0x3a, 0x8c, 0x93, 0xbe, 0x7f, 0x6f, 0x23, 0xc8, 0xc6, 0x68, 0x1c, 0x8e, 0x6d, 0x9, 0x4e, 0xc2, 0x7d, 0xc0, 0xaf, 0xb9, 0xaa, 0xd3, 0xc7, 0x0, 0xd1, 0xd2, 0x63, 0xc9, 0x94, 0xa0, 0x26, 0x9c, 0x6c}, types.Tx{0xc3, 0x1f, 0xca, 0xfa, 0x9d, 0x64, 0xd5, 0x4e, 0x5, 0x9d, 0x43, 0xfa, 0x20, 0x1d, 0xba, 0x2b, 0x6c, 0x8b, 0xc6, 0x2c, 0x25, 0x76, 0x39, 0x2c, 0x94, 0x4, 0xb}, types.Tx{0xa, 0x58, 0xc3, 0x8b, 0x4, 0x36, 0x43, 0xc9, 0xbe, 0xc2, 0x62, 0xc8, 0x8e, 0x40, 0xe6, 0xdd, 0x1b, 0x19, 0x33, 0xa2, 0x4b, 0xa5, 0xc, 0xc4, 0xc8, 0x22, 0x26, 0xa7, 0xb1, 0x7d, 0x4f, 0x6d, 0xeb, 0x55, 0x4a, 0xce, 0x8, 0x32, 0x5a, 0x47, 0xda, 0xe4, 0x28, 0xd7, 0x64, 0x7b, 0xcf, 0xe, 0xa6, 0x9b, 0xf9, 0xde, 0xb0, 0x1f, 0x30, 0x30, 0x45, 0xe9, 0x10, 0xd2, 0x4b, 0x74, 0xf1}, types.Tx{0x8d, 0x39, 0xe4, 0xd0, 0x53, 0x49, 0xf9, 0x70, 0xfe, 0x45, 0xc0, 0x3d, 0xf6, 0xea, 0xd5, 0xf3, 0x95, 0x1f, 0xf1, 0xab, 0x43, 0xa4, 0xc4, 0xe7, 0x9c, 0x97, 0xc9, 0xf4, 0x46, 0xb7, 0x10, 0x4f, 0x54, 0x94, 0xe9, 0x8a, 0x14, 0xb1, 0xba, 0x8c, 0x92, 0x68, 0xd7, 0x30, 0x3a, 0x7d, 0xd4, 0x96, 0x56, 0x91, 0xc6, 0x30, 0x34, 0x43, 0x47, 0x47, 0xd1, 0xa1, 0x87, 0x9c, 0x44, 0x9, 0xfa, 0xbd, 0x8b, 0x73, 0xbc, 0xca, 0xa7, 0x5b, 0xdc, 0x2e, 0xef, 0x44, 0x22, 0x92, 0x9b, 0xa9, 0x53, 0x9e, 0xfe, 0xe0, 0x32, 0x84, 0xbc}, types.Tx{0x31, 0x6a, 0xa4, 0xc1, 0x5d, 0xe8, 0x39, 0xad, 0x43, 0xcd, 0x9f, 0x89, 0x39, 0xaf, 0xfc, 0xee, 0xbe, 0x9, 0xed, 0xe0, 0x20, 0xa1, 0x4, 0x10, 0x32, 0x50, 0xbd, 0x4e, 0x6b, 0x7a, 0x73, 0x61, 0xb9, 0xdb, 0x46, 0xbc, 0x5b, 0x32, 0xc8, 0x3e, 0xa5, 0xa7, 0xa8, 0xbd, 0xec, 0x6b, 0x31, 0xc7, 0x5b, 0x5a, 0x74, 0x7a, 0x62, 0xd, 0x88, 0x89, 0x43, 0xd2, 0x1f, 0xb0, 0x7a, 0xf0, 0xdf, 0x57, 0xf6, 0x78}, types.Tx{0x0, 0x9b, 0xce, 0xfd, 0x7e, 0xd5, 0x4a, 0xff, 0x4e, 0x23, 0xa8, 0x80, 0xc5, 0x17, 0x97, 0x8c, 0x26, 0xa9, 0xdf, 0xf6, 0xd0, 0x86, 0x24, 0x7b, 0xc7, 0xc2, 0x19, 0xa, 0x1b, 0x15, 0xc3, 0xab, 0xfd, 0x75, 0x1, 0x76, 0xc, 0xa0, 0xf5, 0x92, 0x4d, 0x77, 0x2d, 0x2, 0xdd, 0xbe, 0x72, 0x24, 0xa6, 0xb6, 0x8f, 0xb7, 0xf5, 0x59, 0x6e, 0x3e, 0x58, 0xf1, 0xf3, 0xbc, 0xd2, 0xfd, 0xe2, 0x3a, 0x19, 0xf4, 0x6c, 0x74, 0x3b, 0x9e, 0x8e, 0x2a, 0x95, 0xb6, 0xb4, 0x3d, 0x1e, 0xee, 0x33, 0xd2, 0x9f, 0x14, 0x99, 0x79, 0xe9, 0x3f, 0x4b, 0x9b, 0x9e, 0x82, 0xf2, 0xb9, 0xad, 0xfd, 0x79, 0x7a, 0xcc}, types.Tx{0x3b, 0x64, 0x91, 0x82, 0x6a, 0x24, 0x85, 0xba, 0xc3, 0xf2, 0xae, 0xda, 0x25, 0xb5, 0x5d, 0x46, 0x9a, 0x7c, 0x98, 0xbc, 0x1f, 0x7, 0x79, 0xa4, 0xed, 0x44, 0x8b, 0x29, 0x31, 0xc7, 0x5c, 0x57, 0x42, 0xca, 0x81, 0x4a, 0xb9, 0x7c, 0xb5, 0xce, 0xe2, 0x5, 0xa6, 0xc2, 0x5, 0xf8, 0x93}, types.Tx{0x2c, 0x55, 0x53, 0x4e, 0xc6, 0xef, 0xfc, 0xc7, 0x87, 0x4c, 0x2c, 0xdc, 0xec, 0x44, 0x7, 0x82, 0xb1, 0x4a, 0xc4, 0x3c, 0xa1, 0x13, 0x30, 0xaa, 0xa4, 0x17, 0xb5, 0x30, 0x48, 0xd9, 0x1e, 0x60, 0x9, 0x65, 0xb5, 0x15, 0x42, 0x66, 0x15, 0x92, 0xc1, 0x21}, types.Tx{0x12, 0x6b, 0x4c, 0x2c, 0x15, 0x82, 0xf2, 0xce, 0xa9, 0x1f, 0xb5, 0x49, 0x0, 0x65, 0x42, 0x1f, 0x1e, 0xdb, 0xde, 0x1, 0xf8, 0x45, 0xa4, 0x9f, 0xa0, 0xf8, 0x81, 0xe1, 0x50, 0xbc, 0xf0, 0xa3, 0x97, 0x8b, 0x2d, 0x4, 0xfa, 0xbd, 0xd4, 0x78, 0xcd, 0x5d, 0x6b, 0x11, 0x6e, 0x59, 0xac, 0xcc, 0x94, 0x3d, 0x67, 0x5a, 0xa7, 0xf, 0x34, 0xb0, 0xfe, 0x65, 0x89, 0xb5, 0xe3, 0xde, 0x43, 0xb2, 0xd7, 0xb1, 0xae, 0x42, 0xc2, 0x30, 0x49, 0x4, 0x96, 0xd2, 0xc7, 0x5c, 0xe9, 0xad, 0xf, 0x2e, 0xad, 0xbc, 0xa4, 0x42, 0xe1, 0x65, 0xb5, 0x96, 0x28, 0x7a, 0xd4, 0xfa}, types.Tx{0xe2, 0x5f, 0x47, 0xfe, 0x32, 0x7b, 0xfb, 0xa, 0xd5, 0xef, 0xb7, 0x8a, 0xe2, 0x40, 0xd, 0x67, 0x10, 0x26, 0x8c, 0xfd, 0xaa, 0x2e, 0xe0, 0x70, 0xe8, 0xc9, 0xd0, 0x6a, 0x8, 0x2f, 0x62, 0xc8, 0xb9, 0xca, 0xd3, 0xdc, 0xd1, 0x85, 0xbe, 0x1a, 0x53, 0xc, 0xaf, 0x9b, 0x6, 0x19, 0x54, 0x91, 0x85, 0x17, 0x1b, 0x1b, 0xd, 0xc3, 0xad, 0xe7, 0x2c, 0x29, 0xb3, 0x3b, 0xb9, 0xfb, 0x5e, 0x82, 0xe8, 0xed}, types.Tx{0x4e, 0xc0, 0xae, 0x23, 0x1f, 0xc8, 0x69, 0xa7, 0xd1, 0x8d, 0x51, 0xca, 0x5d, 0x7b, 0x4e, 0x62, 0x17, 0xed, 0x54, 0x5a, 0xd3, 0xdc, 0x2d, 0x1b, 0xca, 0xa8, 0x6c, 0xd0, 0x6e, 0x80, 0x26, 0x1e, 0xbf, 0x15, 0x1f, 0xf6, 0x30, 0x8e, 0xd0, 0xdf, 0xed, 0xf, 0xf3, 0xc4, 0x2c, 0xb0, 0x73, 0xc9, 0xb9, 0x6d, 0x0}, types.Tx{0xb4, 0x9a, 0x40, 0x49, 0x2a, 0x4c, 0x2e, 0x78}, types.Tx{0x4e, 0xa5, 0xf1, 0x4e, 0x1c, 0x3c, 0xc9, 0x13, 0xca, 0x3c, 0x51, 0xc4, 0x8f, 0x66, 0x2b, 0xbf, 0xc6, 0x24, 0x16, 0x34, 0x20, 0xe8, 0x97, 0x4, 0x6f, 0x3, 0xe3, 0xe0, 0x10, 0xc7, 0x14}, types.Tx{0xf, 0xde, 0x9b, 0x56, 0x15, 0xc4, 0xfe, 0xd8, 0xbb, 0x34, 0xf6, 0x5, 0x49, 0xa8, 0x99, 0x88, 0xa7, 0xb5, 0x1d, 0xb4, 0x10, 0x49, 0x2c, 0x37, 0x2d, 0xbd, 0xf2, 0x20, 0xb2, 0x9, 0xbf, 0x5d, 0xa2, 0x88, 0x5a, 0x6b, 0xcd, 0xea, 0x77, 0x1d, 0xb1, 0x29, 0x23, 0x61, 0xcd, 0xaa, 0xb2, 0xb7, 0x1e, 0x27, 0xc5, 0x50, 0x59, 0x3c, 0x19, 0x47, 0x1d, 0x78, 0x63, 0x1, 0x39, 0xd1, 0x2f, 0xf0, 0xb, 0x48, 0xbd, 0xe2, 0x79, 0xe1, 0xf8, 0x3e, 0x1f, 0xec, 0x38, 0x9e, 0x1b, 0xe0, 0x38, 0xb4, 0x8, 0xd2, 0x20, 0x35, 0x6, 0xf, 0x3c, 0x6d}, types.Tx{0xee, 0x5e, 0x15, 0x4, 0xe6, 0x13, 0x2, 0x5f, 0xae, 0xd5, 0x5d, 0x45, 0x43, 0x66, 0x1, 0xf3, 0xe5, 0x2b, 0x86, 0xe4, 0xdd, 0xdf, 0xfa, 0x2, 0x21, 0x6e, 0xef, 0x60, 0x46, 0x5c, 0x6f, 0xd7, 0x77, 0x1d, 0xd, 0x50, 0x6e, 0xd6, 0xa2, 0x37, 0xf7, 0x99, 0x6d, 0xed, 0x9b, 0xf7, 0x72, 0xb5, 0xce, 0x6c, 0x56, 0x21, 0x1f, 0xc8, 0xee, 0x8, 0x53, 0xf4, 0xcf, 0xd8, 0x3, 0x93, 0xa, 0x8, 0xed, 0x8, 0x33, 0xd9, 0x3d, 0x9, 0x43, 0xfe, 0x3a, 0x18, 0xb, 0x8, 0x6c}, types.Tx{0x47, 0x81, 0xdd, 0x48, 0xc9, 0xf9, 0x15, 0x62, 0xa4, 0x81, 0xdb, 0x93, 0xce, 0xd7, 0x1f, 0xc1, 0x3b, 0xc1, 0xfb, 0xc8, 0x1, 0x4d, 0x8f, 0xfc, 0x32, 0x79, 0xeb, 0x8d, 0xc2, 0xc9, 0x0, 0x5a, 0x81, 0x5d, 0xe8, 0x54, 0x8a, 0x39, 0x8b, 0x4c}, types.Tx{0xcd, 0x1e, 0xf4, 0xa6, 0x8c, 0xce, 0xae, 0x8b, 0x47, 0xbd, 0x89, 0x3a, 0xb2, 0x16, 0xce, 0x89, 0x5, 0xc0, 0xe4, 0x20, 0x75, 0x13, 0x44, 0xee, 0x46, 0xe0, 0xb5, 0x8f, 0xba, 0x46, 0xf9, 0x95, 0xff, 0xc0, 0x86, 0x88, 0xb4, 0x7e, 0x63, 0x21, 0x27, 0x65, 0x8e, 0xd4, 0x6a, 0x30, 0x78, 0x43, 0xae, 0x49, 0x7, 0x68, 0x8d, 0x7f, 0x84, 0x61, 0x26}, types.Tx{0x34, 0x89, 0x60, 0x18, 0xed, 0xe6, 0xf1, 0xa5, 0x81, 0x66, 0x4f, 0x45, 0x7, 0x59, 0x31, 0x43, 0xf2, 0xd5, 0x0, 0x5f, 0xaa, 0x3f, 0xc4, 0x3a, 0xda, 0x44, 0x1, 0x1b, 0xb, 0x90, 0x66, 0xbe, 0xb, 0xb2, 0xb6, 0xf2, 0x52, 0xe0, 0x5f, 0x9e, 0xf0, 0xc1, 0xf3, 0x1b, 0x76, 0x7c, 0x3, 0x3e, 0x70, 0xd7, 0xfc, 0xbe, 0xe1, 0xae, 0xef, 0xcd, 0x2, 0x50, 0x35, 0xda, 0x40, 0xd5, 0x1a, 0xaa, 0xf6, 0x9c, 0x4a, 0x7b, 0xae, 0x9d, 0x2f, 0xc0, 0x64, 0x17, 0x6b, 0xd2, 0x2}, types.Tx{0x5c, 0xd7, 0xdc, 0xe5, 0xbf}, types.Tx{0xf5, 0xec, 0x95, 0x2b, 0x25, 0xaf, 0xf0, 0xe8, 0x74, 0xd0, 0x72, 0x42, 0x37, 0xfb, 0xb2, 0x17, 0xb2, 0x40, 0x54, 0x65, 0x8e, 0x62, 0x6d, 0x23, 0xb2, 0x2e, 0x39, 0x20, 0xf9, 0xeb, 0x3d, 0x2f, 0x4f, 0xbe, 0xf2, 0x8c, 0xc1, 0x83, 0xb5, 0x7b, 0x32, 0xe2, 0xc5, 0x4c, 0x21, 0xe1, 0x9d, 0x49, 0xb9, 0x91, 0x37, 0x6d, 0x17, 0xf7, 0x57, 0xe4, 0x9, 0x2e, 0x9d, 0x86, 0x9b, 0x13, 0x74, 0xdb, 0x2b}, types.Tx{0x12, 0x7, 0x88, 0xd0, 0x4c, 0xb3, 0x7a, 0x6a, 0xf3, 0x11, 0xe6, 0x4d, 0x62, 0x56, 0x92, 0xaf, 0xb, 0x87, 0xe, 0xe, 0xc2, 0x21, 0x93, 0xeb, 0x9d, 0x0, 0x45, 0x73, 0xa0, 0x34, 0x8c, 0xfe, 0xc5, 0xf, 0xb9, 0x48, 0x81, 0x1b, 0x1e, 0x21, 0xb0, 0x54, 0xbe, 0x38}, types.Tx{0x6b, 0x1, 0xcf, 0x3, 0xd, 0x83, 0x2a, 0x1e, 0x32, 0x37, 0x3f, 0xc8, 0x9, 0xf6, 0xdd, 0x60, 0xbb, 0xd7, 0xf8, 0x60, 0xec, 0x62, 0x3a, 0xb9, 0xa6, 0x80, 0x83, 0x3f, 0xd9, 0x99, 0x9f, 0x96, 0x57, 0x59, 0x69, 0x51, 0xe, 0xc3, 0x69, 0xcc, 0xc4, 0x54, 0x52, 0x82, 0x3f, 0x6e, 0xc1, 0xfd, 0xb6, 0xc4, 0x77, 0xb8, 0x52, 0xe1}, types.Tx{0xbc, 0xa2, 0x5a, 0x99, 0x91, 0x25, 0x6a, 0x59, 0x57, 0xe1, 0x58, 0x63, 0x3d, 0xba, 0x42, 0xb9, 0x41, 0x5f, 0xea, 0x97, 0xa8, 0xa3, 0xb0, 0x7e, 0x57, 0xfe}, types.Tx{0x3c, 0x1, 0xa4, 0xff, 0x3d, 0x96, 0xc4, 0xef, 0xf1, 0xba, 0x5e, 0x6a, 0x79, 0xc8, 0x67, 0x96, 0xdb, 0x8a, 0x2e, 0x8d, 0xf, 0x6f, 0x84, 0xea, 0x86, 0xef, 0x9e, 0x50, 0x73, 0x79, 0x32, 0x55, 0xc, 0x31, 0xc, 0x27, 0x58, 0xdf, 0xe6, 0x80, 0xce, 0x52, 0x97, 0x9c, 0x2b, 0xea, 0x6c, 0xf5, 0x18}, types.Tx{0xde, 0x5c, 0x13, 0xe8, 0x7b, 0x29, 0xf6, 0xed, 0xed, 0xa, 0x8d, 0xf5, 0x4a, 0x2f, 0xe8, 0xf5, 0x25, 0x25, 0x98, 0xf2, 0xd0, 0x8f, 0x84, 0x13, 0x70, 0xfe, 0x2f, 0xff, 0x3e, 0x7d, 0x73, 0x66, 0xb3, 0x13, 0x50, 0x46, 0xb8, 0x9d, 0x3, 0x16, 0x9b, 0xa9, 0xa0, 0x1e, 0xc6, 0x2a, 0xf0, 0x2f, 0x18, 0xfa}, types.Tx{0x16, 0x19, 0xb7, 0xe4, 0x78, 0xdf, 0xd5, 0x83, 0x64, 0xc3, 0xf1, 0x55, 0x51, 0x6e, 0xd6, 0xed, 0x23, 0x41, 0xbf, 0x3e, 0x85, 0xcb, 0xfa, 0x20, 0x8c, 0x5f, 0xa4, 0x99, 0xb5, 0xa3, 0x7b, 0x7e, 0x87, 0x2c, 0x4b, 0xb9, 0x86, 0x28, 0x7e, 0xc, 0x87, 0xbb, 0x21, 0xb6, 0x3f, 0xb6, 0x41, 0x43, 0x99, 0xe9, 0x55, 0xa2, 0x9e, 0xd2, 0xb4}, types.Tx{0x30, 0xd7, 0x30, 0x65, 0x52, 0x1e, 0xd0, 0xb2, 0x3e, 0x8b, 0xf8, 0xe4, 0x40, 0x45, 0xeb, 0x48, 0x80, 0x3, 0x23, 0x1d, 0xf9, 0x21, 0xa6, 0xa6, 0xc2, 0x4e, 0x93, 0xed, 0x2c, 0xb6, 0xff, 0xd3, 0x42, 0xf6, 0x5e, 0x48, 0xa7, 0xd5, 0x38, 0xaa, 0x7d, 0x57, 0xec, 0x70, 0x8d, 0xb, 0x4f, 0x3a, 0xc9, 0xc, 0x45, 0xdc, 0x83, 0xf6, 0xf8, 0xf5, 0x5e, 0x34, 0x42, 0xa0, 0xd3, 0x9b, 0x42, 0x41, 0x35, 0x97, 0x50, 0xc7, 0x69, 0x91, 0x12, 0x7d, 0x1a, 0xe8, 0xc1, 0xd5, 0xcf, 0x65}, types.Tx{0xb6, 0x5, 0x45, 0xd0, 0xf6, 0xfe, 0x4c, 0x46, 0xc1, 0xf4, 0x6b, 0x42, 0xf5, 0x5e, 0x7f, 0x40, 0xd5, 0xb8, 0xde, 0xce, 0x95, 0xff, 0x33, 0x53, 0x22, 0xa9, 0x8d, 0x9b, 0x5a, 0xc3, 0x91, 0x14, 0xc3, 0x59, 0xaf, 0x56, 0xb8, 0x91, 0xcc, 0x51, 0x32, 0x7f, 0xf0, 0x64, 0x4c, 0x8c, 0xa8, 0x6e, 0x98, 0x23, 0x21, 0x46, 0xaf, 0xf2, 0xea, 0x2e, 0xe2, 0xa3}, types.Tx{0x28, 0x0, 0x31, 0x5f, 0x78}, types.Tx{0x68, 0x68, 0xe4, 0x9, 0x51, 0x31, 0x54, 0xda, 0xa1, 0x6e, 0x3c, 0x7d, 0x55, 0x6f, 0x75, 0x5e, 0xd1, 0x37, 0x78, 0x2a, 0x7, 0x1e, 0x56, 0x11, 0x1c, 0xca, 0x7, 0xfd, 0x6f, 0xbf, 0xff, 0xd2, 0x8a, 0x14, 0xa8, 0x55, 0x3b, 0xd3, 0x54, 0x72, 0x13, 0xd2, 0xb3, 0xe7, 0x74, 0xfc, 0x11, 0x47, 0x65, 0xd8, 0x8a, 0xe3, 0x5c, 0xb1, 0xf2, 0x51, 0x66, 0xd, 0xde, 0x1c, 0x44, 0x8d, 0x2c, 0x7a, 0x4e, 0x3a, 0x4a, 0x9c, 0x1, 0x8a, 0xa5, 0x9d, 0x8b, 0xd8, 0xe8, 0x57, 0xcb, 0x81, 0xec, 0x6b, 0x96, 0x4c, 0xf8, 0x76, 0xc7, 0x39, 0x48, 0x55, 0xad, 0x28, 0xbe, 0x99, 0x7d, 0xa3, 0x5a}, types.Tx{0x74, 0x75, 0x14, 0xea, 0x5d, 0x3c, 0xe2, 0x18, 0xce, 0xf7, 0x23, 0x86, 0xaf, 0x75, 0x88, 0x2c, 0x16, 0x0, 0xd2, 0x18, 0xbc, 0xed, 0xe5, 0x6c, 0xf1, 0x66, 0x48, 0x27, 0xd0, 0x7e, 0xd4, 0x29, 0x22, 0x32, 0xbe, 0x4a, 0xcf, 0x50, 0x3f, 0x3e, 0x26, 0xf, 0x96, 0xe0, 0x7c, 0xd4, 0x11, 0x12, 0x31, 0xe5, 0x6b, 0x3e, 0x6c, 0xeb, 0x5b, 0x5, 0x6c, 0x28, 0xb4, 0xa9}, types.Tx{0x42, 0xca, 0x95, 0xe0, 0x0, 0x63, 0x94, 0x96, 0x67, 0xbf, 0xe2, 0x9e, 0x6e, 0x60, 0xe, 0xfa, 0x66, 0xf7, 0xc1, 0x26, 0x4f, 0x49, 0x97, 0x3, 0x95, 0x46, 0xe7, 0x27, 0x20, 0xa7, 0x41, 0xc5, 0x6d, 0x89, 0x3a, 0x3, 0xfc, 0x83, 0xdd, 0x6e, 0xa6, 0x9f, 0x52, 0xf7, 0x2a, 0xba, 0x7a, 0x26, 0xce, 0x7, 0xf0, 0xd2, 0x98, 0x3e, 0x9f, 0x53, 0xf3, 0x4b, 0xa9, 0xef, 0xec, 0x29, 0xba, 0x51, 0xff, 0x13, 0xcd, 0xde, 0x90, 0xa5, 0x14, 0x48, 0x43, 0x64, 0x17, 0x3e, 0x48, 0x87, 0x8b}, types.Tx{0xe2, 0x13, 0x73, 0xfe, 0x11, 0xf6, 0xe8, 0xdc, 0x28, 0x56, 0x30, 0x23, 0x9a, 0x42, 0xba, 0x2b, 0xcc, 0x40, 0x38, 0x1d, 0xcd}, types.Tx{0x3c, 0x64, 0x39, 0x9b, 0xe3, 0x3d, 0xcd, 0xf0, 0x3e, 0x60, 0x53, 0x1a, 0x66, 0x38, 0x84, 0x90, 0xd, 0x8f, 0xad, 0x82, 0xa0, 0xfa, 0xcc, 0xb3, 0x79, 0x2a, 0x96, 0xfb, 0xd1, 0x4a, 0xa1, 0xc5, 0xde, 0xa1, 0x83, 0xe7, 0x2d, 0x84, 0x1, 0x8f, 0xc4, 0x90, 0xed, 0xff, 0x52, 0xb2, 0x78, 0xbf, 0xc7, 0xbe, 0xaf, 0xd2, 0x71, 0x26, 0x15, 0x66, 0x39, 0xcf, 0xab, 0x7d, 0xf, 0xfb, 0xe4, 0xa8, 0xbb, 0x98, 0x77, 0x57, 0x25, 0xf1, 0xdf, 0xb2, 0xb9, 0x58, 0x24, 0xce, 0xfc, 0xb0, 0x95, 0x5b, 0x53, 0x34, 0x3f, 0xbf, 0xe0, 0x27}, types.Tx{0xbb, 0xc4, 0xd5, 0x54, 0x75, 0xf0, 0x7, 0xec, 0x4e, 0x76, 0xec, 0x0, 0xeb, 0x46, 0x65, 0xf0, 0xea, 0xe8, 0xb7, 0x2a, 0xd3, 0x69, 0x24, 0xe6, 0x19, 0x83, 0x27, 0x80, 0xce, 0xd5, 0x39, 0x69, 0x99, 0xf2, 0xbb, 0xc3, 0xe3, 0xf1, 0x57, 0xc5, 0xda, 0xb4, 0x45, 0x31, 0xec, 0x9c, 0xbc, 0x1e, 0xf2, 0x4f, 0xab, 0x9e, 0x53, 0x0, 0x2, 0xcb, 0xbc, 0x2a, 0x69, 0xee, 0xb8, 0xbf, 0x34, 0x19, 0xfb, 0xe3, 0xa, 0x9, 0x1f, 0x48, 0xd0, 0xf3, 0x2b, 0xc8, 0xd5, 0xcb, 0x6c, 0x53, 0x2b, 0x32, 0x23, 0x5, 0x52, 0xd8, 0xa, 0x71, 0xfa, 0x8b, 0xbb, 0xc4, 0x8d, 0x8e, 0x1b, 0xed, 0xf7, 0xf9, 0x9d, 0xe1}, types.Tx{0x8, 0x82, 0x4e, 0xc6, 0x7c, 0x7b, 0xd5, 0xb7, 0x41, 0xcc, 0xfc, 0xdf, 0xe1, 0x44, 0x75, 0x4e, 0x24, 0x75, 0x82, 0x57, 0x8, 0x72, 0x3a, 0x5a, 0x6, 0x83, 0xad, 0x77, 0xcb, 0xe1, 0xce, 0xb5, 0x48, 0xac, 0xfb, 0x1c, 0x49, 0x5f, 0x5e, 0x4a, 0xb6, 0x84, 0x5, 0x7d, 0x4b, 0xd2, 0x34, 0x37, 0xd3, 0xc0, 0x5c, 0xcf, 0x46, 0x6e, 0xeb, 0x1, 0x7b, 0x4a, 0xe0, 0x51, 0x12, 0x3f, 0xc5, 0x8d, 0x3f, 0x37, 0xa9, 0x4b, 0xe7}, types.Tx{0x74, 0x6c, 0x59, 0xd1, 0xc8, 0x90, 0x9, 0xbe, 0x9a, 0x72, 0xc6, 0x75, 0xe6, 0x4c, 0x33, 0x4f, 0xbe, 0x6d, 0xf7, 0xe7, 0xbc, 0x50}, types.Tx{0xed, 0xef, 0x6b, 0xc8, 0x52, 0xb1, 0x28, 0x9f, 0xe2, 0xa, 0x30, 0x2d, 0x77, 0xef, 0x22}, types.Tx{0x2e}, types.Tx{0xf9, 0x3}, types.Tx{0x2e, 0xd8, 0xd0, 0xa3, 0xf, 0xc, 0x45, 0x11, 0x8f, 0x3}, types.Tx{0x79, 0x1c, 0xb5, 0xe5, 0x47, 0x99, 0xa2, 0xde, 0x98, 0x17, 0x35, 0x31, 0xa0, 0x20, 0x70, 0x15, 0xba, 0x1c, 0x4e, 0x81, 0x33, 0x1e, 0xcd, 0x34, 0x9f, 0x98, 0x96, 0x4c, 0x5d, 0x15, 0xc, 0x25, 0xd6, 0x2d, 0x1c, 0x5a, 0xa6, 0x95, 0x42, 0xba, 0x1c, 0x57, 0xc5, 0x16, 0x23, 0x56, 0x85, 0x35, 0xed, 0xea, 0xf8, 0xd6, 0x29, 0xaf, 0xfc, 0xc, 0x24, 0xfd, 0x67, 0xa5, 0x39, 0x5e, 0xcc, 0xfb, 0x15, 0xaf, 0x26, 0x63, 0x62, 0x90, 0xf4, 0xc9, 0x0, 0x53}, types.Tx{0x64, 0x5b, 0x7a, 0xa6, 0x5e, 0xa6, 0xcf, 0x52, 0x85, 0x8b, 0x54, 0x4d, 0xe4, 0x9e, 0x80, 0x29, 0x8c, 0xf8, 0xe, 0x13, 0xf6, 0xd5, 0xe0, 0x21, 0x63, 0xc1, 0x1f, 0x27, 0xc8, 0x37, 0xdf, 0xa1, 0x65, 0x1, 0x2a, 0x38, 0x18, 0xdb, 0xb8, 0x33, 0x63, 0x3d, 0x64, 0xf, 0xed, 0xba, 0xfd, 0xc1, 0xa5, 0xa3, 0x5b, 0x20, 0x22, 0xe9}, types.Tx{0x7c, 0x48, 0x63, 0xb5, 0x6b, 0x6b, 0xb7, 0x90, 0x5a, 0xd2, 0x35, 0x21, 0x5f, 0x70, 0x91, 0x21, 0x21, 0xc1, 0x4b, 0x9a, 0xc6, 0x48, 0xb0, 0x21, 0x6f, 0xe8, 0xc9, 0x68, 0x5d, 0xaf, 0xc7, 0x34, 0xe1, 0x52, 0x44, 0xbc}, types.Tx{0x8b, 0xa6, 0xf4, 0x13, 0x91, 0xfd, 0x2c, 0xc1, 0x9c, 0xd2, 0x26, 0xb1, 0xe1, 0xf0, 0x46, 0xb0}, types.Tx{0xd2, 0x41, 0xf0, 0xcd, 0x2d, 0x4c, 0x5f, 0xb, 0xaf, 0xed, 0xcb, 0x2b, 0x36, 0x4c, 0x14, 0x48, 0x91, 0x9e, 0xe8, 0x61, 0x4f, 0xc8}, types.Tx{0xb3, 0x23, 0x45, 0xed, 0xd3, 0xb3, 0xd1, 0xb9, 0x99, 0x7c, 0x7e, 0x9e, 0x8e, 0xd7, 0x75, 0x68, 0x93, 0x4b, 0x45, 0x9b, 0x2e, 0xcf, 0x72, 0x32, 0x65, 0x62, 0xce, 0x11, 0xa7, 0x30, 0xf, 0x16, 0xa8, 0x97, 0xc1, 0x30, 0x4d, 0xa5, 0xd9, 0xb9, 0x70, 0x6a, 0xaf, 0xb5, 0x35, 0x81, 0xa2, 0xc4, 0x4d, 0xaf, 0xc3, 0xea, 0xf0, 0x76, 0x57, 0xe4, 0x15, 0x76, 0x6b, 0x9f, 0x95, 0xc2, 0xe2, 0x5f, 0xb9, 0x29, 0x6b, 0x67, 0x4b, 0xae, 0x86, 0xdd, 0xbd, 0xd2, 0xf5, 0xb1, 0x34, 0x9, 0xf1, 0xf1, 0x50, 0x7d, 0x4c, 0xad}, types.Tx{0xfa, 0x6a, 0x28, 0x45, 0x30, 0x3b, 0xc8, 0xa0, 0xdd, 0x34, 0x9e, 0xd0, 0xbd, 0x2b, 0x9f, 0x95, 0xe2, 0x48, 0xe6, 0xb4, 0x11, 0xa8, 0x6e, 0x9b, 0x71, 0xd, 0xab, 0x96, 0xd1, 0x89, 0x45, 0xa0, 0xd4, 0x76, 0x43, 0x81, 0xa0, 0x91, 0x61, 0xb1, 0x7c, 0x8d, 0xcc, 0xcc, 0x2c}, types.Tx{0xb1, 0x51, 0x90, 0x31}, types.Tx{0x29, 0x22, 0xc2, 0x43, 0x48, 0x35, 0xc0, 0x23, 0x8a, 0xd1, 0xd3, 0x75, 0x22, 0xc4, 0x22, 0x5a, 0x70, 0xfc, 0x39, 0x9f, 0x9c, 0xe6, 0x9e, 0x2a, 0x3, 0xa6, 0x10, 0xc0, 0xa2, 0x96, 0xa7, 0x48, 0xd0, 0x1e, 0xa0, 0xc2, 0xb9, 0xa3, 0xcb, 0xd3, 0x9b, 0x9d}, types.Tx{0xce, 0x89, 0x14, 0x4b, 0xa0, 0xad, 0x94, 0xd4, 0x1e, 0x6, 0xf9, 0x98, 0xc4, 0x7b, 0x55, 0xc9, 0xea, 0xae, 0xad, 0x7d, 0x23, 0xd3, 0x88, 0x36, 0x22, 0xd4, 0xc, 0xdf, 0xfe, 0xce, 0xd3, 0xb4, 0x66, 0xc, 0x1d, 0xd9, 0xea, 0x9, 0xb4, 0xdc, 0xc, 0x9, 0x86, 0xa3, 0xf5, 0x86, 0xac, 0x20, 0xfc, 0xaa, 0x21}, types.Tx{0xb3, 0x8f, 0x25, 0xeb, 0xe1, 0xd8, 0x14, 0xe8, 0x97, 0x65, 0xc8, 0xef, 0x89, 0x45, 0xd2}, types.Tx{0xf7, 0xb9, 0xe3, 0xf3, 0xe8, 0x62, 0x6a, 0xa4, 0x63, 0x2a, 0xa1, 0xe0, 0x15, 0x7d, 0x38, 0xc, 0x24, 0xd2, 0xdc, 0x85, 0x5f, 0xa3, 0x9b, 0xd7, 0xc9, 0x3c, 0x5f, 0x56, 0x18, 0xc6, 0xd9, 0xe8, 0xd9, 0x82}, types.Tx{0xf5, 0xeb, 0xb, 0x96, 0xd6, 0xcd, 0x95, 0xda, 0xfa, 0xfb, 0x77, 0x2e, 0xc1, 0x99, 0x3d, 0xdd, 0x97, 0x95, 0xb9, 0x10, 0x52, 0x24, 0xf5, 0x41, 0x88, 0x51, 0x9d, 0x90, 0xbc, 0xc9, 0x2e, 0x78, 0x2f, 0x70, 0xd9, 0x83, 0xe3, 0x34, 0x57, 0xcd, 0x64, 0xde, 0x1f, 0x1a, 0x32, 0xe, 0xbc, 0x98, 0x66, 0xfe, 0xf4, 0x3, 0x2a}, types.Tx{0xad, 0x85, 0xaa, 0x15, 0x18, 0x81, 0x91, 0x87, 0xa6, 0xe7, 0x4c, 0x7b, 0xe6, 0xb2, 0x0, 0xa8, 0x65, 0x97, 0xa8, 0x76, 0xcd, 0x8c, 0x2d, 0xa8, 0x15, 0xe4, 0xee, 0xef, 0xa0, 0x9b, 0x57, 0xd8, 0x6f, 0x84, 0x26, 0xa3, 0x29, 0x3d, 0x12, 0x4f, 0xfe, 0x8c, 0xd2, 0x38, 0xcb, 0x81, 0x5c, 0x44, 0x5f, 0x9a, 0xc5, 0x24, 0xbc, 0x6b, 0xf7, 0xbe, 0xe4, 0x41, 0x24, 0xb4, 0x41, 0xbb, 0x77, 0xbc, 0xc0, 0x83, 0x7b, 0xa3, 0xfc, 0x53, 0x11, 0xe2, 0xa9, 0x11, 0x2f, 0x47, 0xcd, 0x67, 0xac, 0x5, 0x37, 0xb2, 0xbe, 0xb2, 0x63, 0xea, 0xdc, 0xc2, 0xed, 0x10, 0x39, 0xa1, 0xba, 0xd1, 0x3f}, types.Tx{0x51, 0x52, 0xed, 0xfd, 0xe8, 0xfa, 0x65, 0x86, 0x8f, 0x6f, 0xaf, 0x22, 0xe7, 0x87, 0x1e, 0xe6, 0xdf, 0xe3, 0x24, 0x83, 0x3a, 0xc5, 0x7a, 0x1c, 0x8d, 0x13, 0x56, 0x1a, 0x37, 0x32, 0x72, 0x87, 0x47, 0x3a, 0xba, 0x29, 0x1a, 0xf3, 0xd2, 0xfc, 0xd9, 0xc5, 0x9a, 0xd5, 0xff, 0xf6, 0x5a, 0xc3, 0x19, 0xd6, 0x75, 0x47, 0x2, 0x43, 0x3a, 0xb7, 0xce, 0xe3, 0xb5, 0xca, 0x52, 0x7, 0x5c, 0x9b, 0x88, 0xcf, 0x1f, 0xbd, 0xfe, 0x2, 0xaf, 0x65, 0x64, 0xdb, 0xea, 0x11, 0x8f, 0xa2, 0x61, 0xb2, 0x62}, types.Tx{0x11, 0x21, 0x46, 0x8e, 0xa5, 0x54, 0x7a, 0xb0, 0x82, 0xec, 0x81, 0xf6, 0x4b, 0xd1, 0x58, 0x7b}, types.Tx{0xca, 0x43, 0xb3, 0xf3, 0xda, 0x7, 0xf4, 0x8, 0x6, 0x9, 0x33, 0xef, 0x82, 0x63, 0x2d, 0xe, 0xa3, 0xec, 0x73, 0x12, 0x92, 0x8b}, types.Tx{0xc9, 0x6a, 0x11, 0x44, 0xe2, 0x21, 0xe9, 0x7e, 0x43, 0x89, 0xcd, 0xbd, 0xad, 0xcd, 0x88, 0x6, 0x7e, 0x54, 0x9f, 0x97, 0xf8, 0x76, 0xec, 0xe5, 0x2a, 0xc2, 0x42, 0xea, 0xe5, 0xd0, 0x2c, 0x0, 0x15, 0xec, 0x45, 0x5f, 0xbe, 0xf0, 0x95, 0x1a, 0xb6, 0x16, 0x4c, 0x53, 0x9, 0xcf, 0x7f, 0x45, 0x5b, 0x51, 0x8c, 0x3d, 0x8a, 0x93, 0xa1, 0xca, 0x72, 0x97, 0x91, 0x29, 0xaa, 0xb4, 0xa8, 0x8c, 0x35, 0x46, 0x9}, types.Tx{0x19, 0x5d, 0x33, 0xda, 0xe6, 0x4e, 0x87, 0x2f, 0xbe, 0x85, 0x68, 0x51, 0x28, 0xc9, 0xa2, 0x5c, 0x25, 0x91, 0xe2, 0x15, 0x63, 0x19, 0xed, 0xd5}, types.Tx{0x45, 0x17, 0x49, 0x23, 0x5f, 0x15, 0xd0, 0x37, 0x37, 0x2f, 0xe7, 0xec, 0x79, 0x2a, 0x4b, 0xba, 0xb4, 0x1d, 0x2e, 0x19, 0x36, 0x8b, 0x3b, 0xa8, 0x5c, 0xb8, 0x5b, 0x97, 0xf5, 0x0, 0x88, 0xa1, 0xd1, 0xed, 0x6, 0xbc, 0x57, 0xd0, 0x5e, 0xd2, 0x37, 0xea, 0x6f, 0x63, 0x2c, 0x57, 0x63, 0xe5, 0x0, 0xca, 0x8, 0x7, 0x51}, types.Tx{0xeb, 0x22, 0xf8, 0x58, 0x88, 0xc7, 0x3, 0xb2, 0xf8, 0x27, 0xfe, 0xa7}, types.Tx{0xd3, 0x32, 0x3c, 0xb9, 0xc3, 0x29, 0x1e, 0xea, 0x9c, 0x48, 0x89, 0xe3, 0x76, 0xc1, 0x5c, 0xf6, 0x2f, 0xdd, 0x5a, 0x23, 0x6b, 0xa7, 0xe3, 0x68, 0xb6, 0x95, 0x27, 0x20, 0xf5, 0xd, 0x46, 0x96, 0xf, 0xca, 0x72, 0x0, 0x9f, 0x8e, 0x89, 0xd0, 0xe0, 0xd6, 0xfd, 0x3a, 0x1f, 0x49, 0xfc, 0xf6, 0x95, 0xfb, 0xe2, 0xf8, 0x48, 0x23, 0xb5, 0xb7, 0x7c, 0x61, 0x2e, 0xe1, 0x9c, 0xcd, 0x8, 0x97, 0xeb, 0x53, 0x3a, 0x93, 0x36, 0x64, 0x83, 0x46, 0xeb, 0xc5, 0x87, 0x2, 0x94}, types.Tx{0xc3, 0x18, 0x1c, 0x7c, 0xe5, 0xf, 0x58, 0xba, 0xd5, 0x73, 0x5a, 0xf2, 0x52, 0x8e, 0x29, 0xc, 0x86, 0xbb, 0x7d, 0x3e, 0x54, 0xf5, 0xf, 0x2d, 0xf, 0x51, 0xe7, 0xd2, 0xff, 0x28, 0x7f, 0x48, 0x86, 0x61, 0xb1, 0x70, 0xb5, 0x4f, 0xd1, 0x30, 0x46, 0x6c, 0x4c, 0xa0, 0xa4, 0x99, 0xb7, 0x53, 0xb3, 0x1b, 0x76, 0x23, 0xe3, 0x78, 0xc6, 0x12, 0x3c, 0xd8, 0xab, 0x6f, 0x13, 0xc0, 0xd7, 0xb8, 0xe0, 0x23, 0x76, 0xe2, 0xf6, 0x31, 0xe4, 0x1b, 0xcd, 0x89, 0xf8, 0xd7, 0x7, 0xd6, 0x41, 0xa, 0xda, 0x4f, 0x63, 0xff, 0xef, 0xc3, 0xbd, 0x2a, 0xc7, 0x30, 0x43, 0xc7, 0x58}, types.Tx{0x5e, 0x61, 0x55, 0xeb, 0x91, 0xd1, 0x4a, 0x24, 0xb4, 0xf6, 0x78, 0x84, 0xf6, 0xae, 0x55, 0x2e, 0xb8, 0x12, 0xe1, 0xb6, 0x32, 0xa2, 0x17, 0xc1, 0xfb, 0xf0, 0x24, 0x12, 0x4a, 0x16, 0x4c, 0xb4, 0x6d, 0x93, 0xb7, 0x7, 0x86}, types.Tx{0x17, 0xc2, 0x3a, 0xa1, 0xf4, 0x77, 0x5f, 0x94, 0xa8, 0xe2, 0x13, 0xef, 0x41, 0x46, 0x6d, 0x57, 0x4b, 0xa8, 0x1f, 0x47, 0x13, 0x4a, 0x7b, 0xa9, 0x48, 0x92, 0xb5}, types.Tx{0xb0, 0x4c, 0x93, 0x2c, 0x17, 0xb9, 0x8a, 0x6e, 0x2e, 0xfd, 0xf0, 0xc1, 0x6e, 0xf8, 0x79, 0x2b, 0x3a, 0xa3, 0x34, 0x74, 0xdd, 0xee, 0x23, 0x16, 0xd4, 0x6c, 0xb6, 0x7d, 0x5a, 0x9e, 0x4f, 0xb6, 0x78, 0x44, 0x6c, 0x87, 0x95, 0xc2, 0x50, 0x4b, 0x81, 0x65, 0x3f, 0x27, 0xc6, 0x97, 0xd6, 0x61, 0x37, 0xce, 0x7d, 0x8, 0x7, 0xa8, 0x75, 0x46, 0x4d, 0x2d, 0x75, 0x75, 0x5a, 0x92, 0x20, 0x1f, 0x93, 0x14, 0x29, 0xa8, 0xde, 0xff, 0x3e, 0x4f, 0x3d, 0x56, 0x2d, 0x40, 0x88, 0x4b, 0xb3, 0xb0, 0x56, 0xce, 0x7, 0xf5, 0xae, 0x42}, types.Tx{0x89, 0x28, 0x6b, 0x9c, 0x7b, 0x48, 0x6a, 0xcc, 0x6f, 0x51, 0xed, 0x97, 0x7d, 0x2f, 0x80, 0x60, 0x8e, 0x53, 0x2d, 0xd7, 0xf5, 0x42, 0x34, 0x3e, 0xd7, 0x3c, 0xe4, 0x8c, 0xea, 0x20, 0x63, 0xcc, 0xd8, 0xf9, 0xa8, 0x41, 0xca, 0xbe, 0xc, 0x5c, 0xb1, 0xd7, 0x72, 0x72, 0xe6, 0xf2, 0x77, 0x2e, 0xa4, 0xbd, 0xf0, 0x6a, 0xbf, 0x36, 0x79, 0x90, 0xd2, 0xb4, 0xa, 0x1, 0x8d, 0x6, 0xf2, 0x2d, 0x29, 0xa4, 0xb6, 0xfc, 0x89, 0x5c, 0xac, 0xaf, 0x14, 0x7e, 0x40, 0x5f, 0x5b, 0xe5, 0x3f, 0x14, 0x82, 0x98, 0xdd, 0x9f, 0xca, 0x9d, 0xd9, 0x34, 0xfb, 0xed, 0x8b, 0x91, 0x98, 0xf5, 0x1e}, types.Tx{0x8b, 0xcf, 0x4d, 0xe7, 0x6b, 0x6f, 0xfa, 0x62, 0xae, 0x27}, types.Tx{0x0, 0xe1, 0xa7, 0x0, 0x7, 0x97, 0x6, 0xed, 0x6, 0x19, 0xba, 0xdb, 0x19, 0x59, 0xf3, 0xea, 0xe3, 0xa6, 0xc7, 0xda, 0xc0, 0x87, 0x3c, 0xc}, types.Tx{0x34, 0x12, 0xbd, 0x52, 0xde, 0x2, 0x8c, 0xc3, 0xc5, 0xd4, 0xfd, 0xc1, 0xb5, 0x3c, 0xc8, 0xd1, 0xcf, 0x87, 0x8d, 0x29, 0x2a, 0x9b, 0x60, 0x5b, 0x5c, 0xed, 0x68, 0xa9, 0x75, 0xc4, 0x9b, 0x9a, 0x7e, 0x58, 0x67, 0x22, 0x78, 0xb5, 0x8e, 0xb1, 0xf, 0xb9, 0x55, 0xae, 0xec, 0x2, 0xe, 0xc3, 0xab, 0xf1, 0x4, 0xdd, 0xc1, 0x76, 0xc, 0xad, 0xaa, 0x96, 0xd0, 0x1c, 0xcb, 0xe9, 0x67, 0x23}, types.Tx{0x2e, 0x37, 0x9f, 0x28, 0x9c, 0x63, 0xab, 0x35, 0xe4, 0x44, 0x6, 0xc8, 0x39, 0x9c, 0xc5, 0x9, 0x1c, 0xc9, 0xf2, 0x6c, 0x36, 0xa1}, types.Tx{0x0, 0x25, 0x76, 0x71, 0x7, 0x9, 0x5e, 0x10, 0xbe, 0x34, 0x67, 0x6a, 0x48, 0x67, 0x6f, 0x5f, 0x4f, 0x56, 0xfa, 0x7a, 0x38, 0x78, 0xc8, 0x32, 0x2e, 0x22, 0x36, 0xeb, 0xcd, 0x26, 0x0, 0x87, 0xce, 0x1, 0x90, 0x13, 0xe, 0xfc, 0x8, 0x2, 0x16, 0x33, 0x81}, types.Tx{0xb6, 0x60, 0x3a, 0xc6, 0xc9, 0xdd, 0x7a, 0x3f, 0x45, 0x5f, 0x1a, 0xc3, 0x61, 0xda, 0x27, 0xb3, 0x54, 0xf3, 0x9, 0x25, 0x8f, 0xf0, 0x95, 0x36, 0xdf, 0xb7, 0x1d, 0xee, 0xc2, 0x93, 0x63, 0x19, 0x48, 0x17, 0xf9, 0xcb, 0x66, 0x3d, 0xda, 0x6e, 0x74, 0x7f, 0x18, 0xb4}, types.Tx{0x42, 0xf7, 0x43, 0x65, 0xda, 0x8e, 0x57, 0x12, 0xc0, 0xd0, 0x64, 0x65, 0x5a, 0xc3, 0xd1, 0x32, 0xee, 0x5b, 0x9c, 0x9a, 0xa3, 0x39, 0x43, 0x19, 0x6b, 0x33, 0x2f, 0x60, 0x79, 0x3b, 0xef, 0x13, 0x9b, 0xd5, 0xab, 0x5b, 0xa9, 0xc2, 0x6e, 0xd5, 0x70, 0x9b, 0x4a, 0x9, 0x79, 0xbe, 0x10, 0x30, 0xe7, 0x9e, 0xf6, 0x4c, 0x97, 0x86, 0xd3, 0x42, 0x47, 0xa5, 0xe1, 0x44, 0xcb, 0xf9, 0x2a, 0x20, 0xe1, 0xb7, 0xcd, 0x7d, 0xe0, 0x78, 0x1f, 0xd3, 0x37, 0x46, 0xb9, 0x2f, 0xfb, 0x3e, 0x71, 0xe9, 0x6a, 0xd6, 0x3e, 0x2, 0x98, 0x61, 0x47, 0xe9, 0x1d, 0x65, 0x24, 0xc8, 0x7b, 0xd5, 0x3f, 0x29, 0xa5}, types.Tx{0x15, 0xae, 0xa9, 0x20, 0x7, 0x4c, 0x3a, 0x44, 0x34, 0x9a, 0x36, 0x2a, 0xaf, 0xc1, 0xb7, 0x83, 0x43, 0x1, 0xc9, 0x67, 0xf2, 0x44, 0xbf, 0x47, 0x8e, 0x5a, 0x21, 0x30, 0x1a, 0xe5, 0x85, 0x77, 0x53, 0x10, 0x23, 0x39, 0x49, 0x91, 0xa1, 0x65, 0x44, 0x36, 0xa8, 0xb1, 0x7, 0x21, 0x4e, 0x4c, 0x9c, 0x88, 0xd4, 0x2a, 0x4b, 0xf6, 0xcd, 0xa4, 0xaa, 0x50, 0x95, 0x9e, 0x3f, 0x22, 0x93}, types.Tx{0x38, 0x52, 0xc4, 0xba, 0x5f, 0xb2, 0xd1}, types.Tx{0x3f}, types.Tx{0xa9, 0x78, 0xdf, 0xb9, 0x8d, 0xa5, 0x63, 0x3c, 0x62, 0x51, 0x6, 0x1e, 0x9b, 0x22, 0xcf, 0xbb, 0xc0, 0xd5, 0x46, 0x23, 0xf, 0x57, 0xb6, 0xad, 0x39, 0xe7, 0x6b, 0xf9, 0xf4, 0x6b, 0x94, 0xea, 0x3b, 0xa4, 0xe5, 0x7b, 0x2d, 0x3, 0x13, 0xe5, 0x60, 0x51, 0x3d, 0x5d, 0x3a, 0x2b, 0xc6, 0x8e, 0xd6, 0x14, 0x3b, 0x96, 0x5d, 0xa0, 0xc1, 0xd5, 0x2c, 0x9a, 0x6a, 0xfe, 0x30, 0xe0, 0xc, 0xd1, 0xe, 0xc5, 0xf2, 0xb6, 0xa, 0x19, 0x98, 0xc6, 0x7d, 0x9f, 0xdf, 0x5b}, types.Tx{0xec, 0xff, 0x28, 0xf7, 0x89, 0x52, 0xc7, 0xb6, 0xec, 0x5a, 0x6c, 0x6f, 0x76, 0x7d, 0x66, 0xd3, 0xc9, 0x67, 0xe6, 0xab, 0x72, 0x98, 0x7a, 0x93, 0xef, 0xe8, 0x3f, 0x4e, 0xe7, 0xeb, 0x98, 0x66, 0x55, 0xa2, 0xb7, 0xd8, 0xf2, 0xc2, 0x48, 0xe8, 0xde, 0xcf, 0x42, 0x6e, 0xac, 0xe2, 0xa4, 0x94, 0x10, 0xb9, 0x8b, 0xf5, 0x23, 0x26, 0x75, 0xd6, 0x57, 0x35, 0x5b, 0xc5, 0xb6, 0x7e, 0xbb, 0x33, 0x65, 0x67, 0xb7, 0x85, 0xa1, 0x6f, 0xb4, 0x80, 0xcd, 0x3c, 0xcb, 0x72, 0x3f, 0xd9, 0x80}, types.Tx{0xe1, 0x8f, 0x7d, 0x6a, 0xc7, 0x30, 0x8a, 0x0, 0x10, 0xbf, 0x1f, 0x1c, 0xe9, 0x84, 0xb7, 0x8e, 0xbb, 0xf2, 0x57, 0xc4, 0xa8, 0xb, 0x24, 0xe6, 0xeb, 0x83, 0x92, 0x7b, 0xb4, 0x2, 0x26, 0xf, 0xa6, 0x43, 0xa2, 0xd, 0x46, 0x34, 0xfc, 0x89, 0x6, 0x28, 0xd1, 0xa9, 0x95, 0x18, 0xe, 0x3c, 0x25, 0xf2, 0x24, 0x48, 0x73, 0xcd, 0x33, 0x60, 0x23, 0x86, 0x18, 0x6b, 0x9c, 0x1, 0x7a, 0x15, 0x97, 0x7b, 0x4c}, types.Tx{0xf4, 0xfc, 0x61, 0xa3, 0x44, 0x80, 0x4a, 0xf, 0x6c, 0x3e, 0x19, 0xfe, 0x1f, 0x91, 0x80, 0x62, 0x41, 0xbf, 0x58, 0x61, 0x2f, 0x36, 0xb, 0x5d, 0xdd, 0xfb, 0xfd, 0xa, 0xc0, 0xaf, 0xb4, 0x23, 0x59, 0xaf, 0xa7, 0x81, 0x8, 0x73, 0xa5, 0x1b, 0x39, 0xc3, 0x19, 0x39, 0xed, 0xd1, 0x6c, 0xe2, 0xf5, 0x46, 0x86, 0x31, 0xaf, 0x3, 0x3f, 0x6c, 0x5f, 0x33, 0x87, 0x71, 0x69, 0xbd}, types.Tx{0x83, 0x16, 0x1b, 0x86, 0x49, 0x19, 0xc4, 0x43, 0xf3, 0x9d, 0x4e, 0xf0, 0xf, 0xbd, 0x4}, types.Tx{0x23, 0xe4, 0x1b, 0xf7, 0x6e, 0xd, 0xe, 0x8f, 0x33, 0x62, 0xb5, 0xe6, 0x86, 0x68, 0x5c, 0xc0, 0xe0, 0x3c, 0xd6, 0x6e, 0x1d, 0xb3, 0xfb, 0x99, 0xc0, 0xe9, 0x54, 0x51, 0x2e, 0x2b, 0xb8, 0xec, 0x45, 0x6d, 0x13, 0xed, 0xb1, 0x8, 0x81, 0xa2, 0x8c, 0x61, 0x30, 0xfb, 0x39, 0x2c, 0x4f, 0xba, 0x93, 0xaa, 0x97, 0x85}, types.Tx{0x62, 0x25, 0x1b, 0xb6, 0xf0, 0x37, 0xe5, 0xbf, 0xf9, 0x45, 0x5c, 0xdf, 0x31, 0x54, 0xc0, 0xc4, 0x7e, 0xc3, 0x1d, 0xae, 0xc9, 0xc, 0x55, 0x74, 0x29, 0xf4, 0x13, 0x63, 0x92, 0x65, 0x39, 0x9e, 0xc8, 0xe3}, types.Tx{0xf5, 0x1e, 0x88, 0x25, 0x17, 0x1f, 0x36, 0xcf, 0xda, 0xb2, 0xa5, 0x58, 0x3f, 0x87, 0x11, 0x62, 0x1b, 0xc9, 0xfc, 0x91, 0x91, 0x1d, 0x33, 0x1a, 0x9d, 0x84, 0xbc, 0x8e, 0x49, 0x3b, 0x9e, 0xc9, 0xb8, 0x7f, 0x23, 0x93, 0xcc, 0xe9, 0x47, 0x1a, 0x4b, 0xc5, 0x17, 0x4e, 0x10, 0xce, 0x66, 0x82, 0xcd, 0xe1, 0x20, 0x5b, 0x43, 0xa, 0x7a, 0xd8, 0x13, 0x28, 0x7, 0x6a}, types.Tx{0xcb, 0x60, 0x17, 0x50, 0x20, 0xce, 0xd2, 0x31, 0x1e, 0x75, 0xaf, 0x86, 0xf8, 0x7, 0x30, 0xb2, 0x90, 0x4e}, types.Tx{0x90, 0xb9, 0x2d, 0xdd, 0xd8, 0x2d}, types.Tx{0x77, 0x90, 0xc4, 0xe5, 0x41, 0xdc, 0x7f, 0x24, 0xc8, 0x5e, 0x4, 0xa1, 0xe2, 0x55, 0x2c, 0x22, 0x5e, 0x50, 0x4a, 0x6c, 0xad, 0x5, 0xc1, 0xd5, 0x93, 0x40, 0xe8, 0xd3, 0xfc, 0xe1, 0x98}, types.Tx{0x6a, 0xec, 0xbc, 0xf, 0x57, 0x4f, 0x8, 0x96, 0xf7, 0xf0, 0xf5, 0x6f, 0x78, 0xb4, 0xcf, 0x9a, 0x88, 0x34, 0xe2, 0x10, 0x83, 0x90, 0x53, 0xe6, 0x68, 0x25, 0x4b, 0x67, 0x14, 0xe6, 0xcc, 0x81, 0x11, 0x12, 0xc0, 0x63, 0xc1, 0x7f, 0x41, 0x12, 0x77, 0x6d, 0x87, 0xb8, 0x60, 0xb1, 0x15, 0x79, 0x27, 0x93, 0x9e, 0x5e, 0x8a, 0x5f, 0x29, 0x43, 0x32, 0xf5}, types.Tx{0x2a, 0xec, 0x1d, 0x47, 0x9c, 0xae, 0x93, 0x6e, 0x68, 0x29, 0x3, 0x85, 0xab, 0x63, 0x7f, 0x2f, 0xfb, 0x1b, 0x7c, 0xd0, 0x68, 0xef, 0xeb, 0xd5, 0x4c, 0xa4, 0x33, 0x7, 0xf, 0x1c, 0x89, 0xc2, 0x6f, 0xa0, 0x84, 0xef, 0xde, 0x7a, 0x0, 0x51, 0x40, 0x4c, 0x3e, 0xdd, 0x86, 0x0}, types.Tx{0xc8, 0x25, 0x4c, 0x2a, 0x16, 0xf6, 0xc7, 0x7b, 0x29, 0xf2, 0x3d, 0xa8, 0x5b, 0x2c, 0x54, 0x28, 0x65, 0xf8}, types.Tx{0xd2, 0x88, 0x8, 0x97, 0xfb, 0xb2, 0x81, 0xcf, 0xcb, 0x4, 0x40, 0x3, 0x5d, 0xa2, 0x7d, 0x2b, 0x64, 0xb6, 0x53, 0x83, 0xe3, 0x5, 0x11, 0x72, 0xbd, 0x73, 0xb9, 0x65, 0x5a, 0xe6, 0x71, 0xa8, 0x17, 0x6a, 0xd0, 0x99, 0xdd, 0x81, 0x8c, 0x14, 0x35, 0xf0, 0x6f, 0xc, 0x64, 0x1a, 0x30, 0x48, 0xb, 0xdf, 0xfe, 0x54, 0x1d, 0x9f, 0x95, 0xe0, 0x96, 0x70, 0x8d, 0x4b, 0xe0, 0x72, 0xf8, 0xc9, 0xb3, 0x2d, 0x4b, 0x3a, 0x74, 0x9, 0x63, 0x9f, 0x8c, 0x4b, 0x56, 0x9d, 0xb7, 0x14}, types.Tx{0x4c, 0x50, 0xcd, 0x42, 0x8b, 0x26, 0x94, 0x89, 0xda, 0xd2, 0x27, 0x96, 0x71, 0xdd, 0x6c, 0x81, 0x72, 0x59, 0x35, 0x15, 0x3b, 0xdc, 0x12, 0x37, 0xc8, 0x4d, 0x6f, 0x63, 0x21, 0x68, 0xc8, 0xc0, 0xce, 0x3b, 0x78, 0x67, 0xc4, 0xb0, 0xe, 0x6f, 0x70, 0x94, 0xf9, 0x35, 0x99, 0x98, 0xe5, 0x21, 0xdd, 0x6a, 0x99, 0xed, 0xb0, 0xe3, 0xb8, 0x14, 0x8d, 0x5c, 0xec, 0x3b, 0xd5, 0xde, 0x3a, 0x5c, 0x5c, 0xc3, 0x4f, 0x1e, 0x5f, 0xe4, 0x96, 0x45, 0x77, 0x9c, 0xd4, 0xa3, 0xb0, 0xa0, 0xd4, 0x27, 0xe5, 0xcc, 0xb3}, types.Tx{0x94, 0xa1, 0xfe, 0x57, 0x4f, 0xa8, 0xe5, 0xa1, 0xdc, 0xb0, 0x2b, 0xb1, 0x99, 0x19, 0x37, 0x29, 0x47, 0x8a, 0xde, 0x1d, 0x21, 0x5a, 0xe4, 0x62, 0xf2, 0x15, 0x20, 0x4f, 0x31, 0xa5, 0x97, 0xcb, 0xe1, 0xd6, 0x26, 0xe6, 0xe5, 0x9d, 0xad, 0x98, 0xa0, 0x1c, 0x5, 0x56, 0xf0, 0xe0, 0x48, 0x62, 0x88, 0x96, 0xb2, 0xa8, 0xc4, 0xba, 0xe7, 0xe4, 0x16, 0x83, 0x65, 0xe6, 0xf2, 0xd, 0xae, 0xc3, 0x8a, 0x8d, 0x61, 0xb6, 0xe, 0x7c, 0xcf, 0x9b, 0xbe, 0xa5, 0xb2}, types.Tx{0xed, 0x79, 0x2a, 0xaa, 0x85, 0xb4, 0xc, 0x4a, 0x5d, 0xe7, 0x5c, 0x92, 0xa2, 0xfa, 0x6a, 0x5e, 0x5c, 0x7c, 0x2f}, types.Tx{0x91, 0x31, 0x7d, 0x89, 0x24, 0xdc, 0x5c}, types.Tx{0x93, 0x54, 0xa6, 0xaa, 0x1b, 0xc4, 0x9f, 0xe8, 0x5, 0xde, 0xb9, 0xcd, 0xaa, 0x6b, 0x1e, 0x43, 0xfb, 0x96, 0x42, 0x2b, 0x85, 0x74, 0x4, 0xa2, 0xc1, 0x80, 0x65, 0x52, 0x7f, 0xee, 0x27, 0xc1, 0xa2, 0xca, 0x18, 0xb1, 0x9b, 0x4c, 0x3a, 0x67, 0x6d, 0xf7, 0xa1, 0xda, 0xf7, 0x12, 0x83, 0xba, 0xcc, 0x96, 0x8, 0x22, 0x72, 0xe8, 0xb2, 0x8d, 0x88, 0x9e, 0xb5, 0x41, 0xd4, 0x93, 0x43, 0xab, 0x2, 0x31, 0x5a, 0x5, 0xf0, 0x6f, 0xee, 0x13, 0xa0, 0x43}, types.Tx{0x9e, 0xef, 0xa4, 0x73, 0x2f, 0xb5, 0xe3, 0x1f, 0x2c, 0x54, 0x31, 0x35, 0xac, 0x66, 0xb3, 0x24, 0x67, 0x52, 0x64, 0xa, 0x4, 0xff, 0x84, 0x3f, 0x7d, 0xe4, 0xd6, 0xe8, 0xce, 0xd4, 0x22, 0xe4, 0x88, 0xf1, 0x29, 0x32, 0xaa, 0x7b, 0xef, 0x62, 0x8c, 0x44, 0x15, 0x37, 0xd0, 0xf1, 0x55, 0xc5, 0x3e, 0x13, 0x34, 0x1d, 0x76, 0xf5, 0x28, 0xa5, 0xf7, 0x44, 0xcf, 0xd7, 0x7b, 0x5a, 0xec, 0x24, 0xcf, 0x6a, 0xb7, 0xe0, 0xfd, 0xd3, 0x3, 0x1a, 0xaa, 0x7d, 0xfe, 0x0, 0x1c, 0xa6, 0x41, 0xf6, 0x4b, 0x8e, 0x77, 0x7a, 0xab, 0xad, 0xba, 0x6a, 0x44, 0xaf, 0xb7, 0x41, 0x24, 0xbe, 0xf8, 0x46, 0x86, 0xab, 0x7}, types.Tx{0xa8, 0x2a, 0x3b, 0x54, 0xf4, 0xc7, 0xcb, 0x29, 0x37, 0x4e, 0xc0, 0x38, 0x71, 0x50, 0xaf, 0x5c, 0x7d, 0x4b, 0xe5, 0x4f, 0xc1, 0xf0, 0xac, 0x1a, 0x4a, 0x28, 0xd6, 0x57, 0x65, 0xdb, 0xa8, 0x4f, 0x78, 0x9a, 0x4e, 0x94, 0x97, 0xd2, 0xd8, 0x1a, 0x6c, 0xa1, 0x43, 0xff, 0x51, 0x7c, 0xff, 0x13, 0xd8, 0xce, 0xe7, 0xf8, 0xe0, 0xb2, 0xe0, 0xd2, 0x2, 0xb1, 0xe3, 0xc3, 0x73, 0xb6, 0x5f, 0xf1, 0x60, 0x8f, 0xb1, 0xe2, 0x88, 0xd, 0xcd, 0xcd, 0x7d, 0x2, 0x27, 0x81, 0xde, 0xad, 0xfd, 0x58, 0x3e, 0xe6, 0xd, 0x27, 0xc3, 0xd6, 0xce}, types.Tx{0x76, 0x80, 0x49, 0x80, 0x2d, 0x31, 0x86, 0xcb, 0x71, 0x2d, 0x6b, 0xf4, 0xfb, 0xff, 0xbc, 0x3d, 0x64, 0xc7, 0x3b, 0x7f, 0xd3, 0x5c, 0x82, 0xaf, 0x71, 0x55, 0xa7, 0xb3, 0xdc, 0x11, 0x1d, 0x67, 0x30, 0xb8, 0xfc, 0x99, 0xe7, 0xfa, 0xaa, 0x4, 0x32, 0xd, 0x8d, 0x4e, 0xbe, 0xc1, 0x40, 0xb3, 0x2f, 0x27, 0x9c, 0x26, 0x2a, 0x89, 0x23, 0x14, 0x26, 0xbb, 0x69, 0xe1, 0x7, 0x9e, 0x82, 0xce, 0x87, 0x52, 0x5, 0xb0, 0x55, 0x9, 0x71, 0x61, 0x48, 0x29, 0x83, 0xbb, 0x4, 0x58, 0xa4, 0x5, 0x78, 0x37, 0x76, 0xcf, 0x56, 0xcd, 0xe3}, types.Tx{0x30, 0x3f, 0x88, 0x64, 0xcb, 0xca, 0x38, 0xc6, 0xdd, 0x2e, 0xb, 0x8c, 0xb0, 0x16, 0xf0, 0xe5, 0x4c, 0xa6, 0x8b, 0x7e, 0xea, 0x75, 0x8e, 0x6d, 0xd5, 0xd1, 0x22, 0x31, 0xf1, 0x7a, 0x34, 0xf1, 0xbc, 0x1e, 0xec, 0x44, 0x42, 0xc, 0xb5, 0xa1, 0x5c, 0x44, 0xc4, 0x3c, 0xcb, 0x62, 0xb9, 0x3e, 0x31, 0x69, 0xa4, 0xd7, 0x73, 0xee, 0x2e, 0xe, 0xa1, 0x8b, 0xfc, 0x75, 0xba, 0x2c, 0x11, 0x5d, 0x93, 0x15, 0xab, 0xea, 0x73, 0xe7, 0x9c, 0xf, 0x5a, 0x69, 0xbc, 0xb2, 0x79, 0x2d, 0x3e, 0x97, 0x78, 0x6f, 0x35, 0xe3, 0x21, 0x97, 0x10, 0x37, 0x18, 0x43, 0x6, 0xfc, 0xef, 0x49, 0x9f, 0xd9, 0x4b}, types.Tx{0x37, 0xc4, 0x37, 0x48, 0xf9, 0xe5, 0xaa, 0x73, 0xc6, 0xc7, 0x4, 0x19, 0x53, 0x2, 0x3e, 0x27, 0x83, 0x23, 0x72, 0x21, 0x18, 0xce, 0x5a, 0xd, 0x4e, 0x12, 0x59, 0xc2, 0x2a, 0x78, 0xb5, 0xf, 0xb, 0xc8, 0x2e, 0xd0, 0x34, 0xff, 0x62, 0x45, 0xde, 0xb2, 0x48, 0x5e, 0xf6, 0xb4, 0xc4, 0xfe, 0x64, 0xa7, 0xc3, 0x34, 0xea, 0x18, 0x71, 0xab, 0xed, 0xe5, 0x51, 0x59, 0x29, 0x4a, 0x2f, 0x44, 0x43, 0x5a, 0xfb, 0xb8, 0x6e, 0x6e, 0xd4, 0xf3, 0x26, 0x95, 0x6c, 0x6c, 0xa0, 0x82, 0x81}, types.Tx{0xef, 0x66, 0x7f, 0xec, 0xa0, 0x77, 0x3a, 0x14, 0x57, 0x17, 0x78, 0xd9, 0xa3, 0x85, 0x8, 0xe, 0x55, 0xa4, 0xd8, 0xb1, 0xc8, 0x26, 0xbf, 0x58, 0x4a, 0x8e, 0xc0, 0xd0, 0x34, 0xaa, 0x44, 0xcf, 0x71, 0x42, 0xaa, 0xf9, 0x98, 0xd5, 0xaf, 0x42, 0x3d, 0x25, 0xcc, 0xb6, 0xd4, 0xf, 0xde, 0xf7, 0x72, 0x77, 0x40, 0x2a, 0x2b}, types.Tx{0x63, 0xf7, 0x14, 0xd2, 0xf6, 0x1, 0xc1, 0x72, 0x86, 0x64, 0x71, 0xa7, 0x52, 0x87, 0xed, 0x41, 0xa0, 0xf0, 0xd6, 0x4a, 0x60, 0xa0, 0x3c, 0x1e, 0x4d, 0x34, 0x6, 0x5b, 0xd0, 0xae, 0xba, 0xbd, 0xeb, 0xfa, 0xd9, 0x4, 0x2f, 0xd1, 0xaa, 0x4, 0x26, 0xef, 0x96, 0xed, 0x5, 0xf6, 0xde}, types.Tx{0x8a, 0xa8, 0x2, 0x6b, 0xe9, 0x9e, 0x4e, 0x6b, 0x86, 0xc6, 0x7d, 0x8c, 0xcd, 0x6b, 0x69, 0x77, 0x15, 0x8b, 0x16, 0x25, 0xd5, 0x60, 0xa9, 0x67, 0xbb, 0xd1, 0x60, 0xfa, 0x1a, 0x1, 0x67, 0xe4, 0x68, 0x6f, 0xbd, 0xc6, 0x44, 0xf4, 0x65, 0x25, 0x26, 0xae, 0xaf, 0xb7, 0x2b, 0xa6, 0x27, 0xb3, 0x83, 0x44, 0xc1, 0xc3, 0x93, 0x45, 0xd9, 0x4c, 0x1d, 0xe3, 0x4a, 0x85, 0x85, 0xa8, 0x36, 0xa2, 0xa, 0x3a, 0xc, 0x68, 0x97, 0x32, 0x2f, 0xb0, 0x54, 0xcb}, types.Tx{0x66, 0xcd, 0xf9, 0x73, 0xbb, 0x63, 0x4d, 0x6a, 0x86, 0x1b, 0x5f, 0x16, 0x38, 0x4, 0x25, 0x61, 0xa3, 0xa7, 0xb5, 0xa5, 0x8f, 0x41, 0xd6, 0x87, 0x56, 0x7f, 0xfe, 0xe1, 0xf8, 0xd9, 0x8d, 0x6, 0x25, 0x95, 0xe3}, types.Tx{0x81, 0x99, 0x7a, 0x2f, 0x18, 0xd, 0x5e, 0x75, 0xeb, 0x64, 0xcc, 0xa, 0xb0, 0x24, 0x4c, 0x1a, 0xaa, 0xc0, 0xab, 0x6, 0x61, 0xa5, 0xcd, 0x41}, types.Tx{0xf5, 0x51, 0xe3, 0x56, 0x69, 0x2e, 0x38, 0xe3, 0x2a, 0xb2, 0xbf, 0xe2, 0xb4, 0x3, 0xa5, 0x2b, 0xbb, 0x42, 0x28, 0x27, 0x21, 0x76, 0xb0, 0x48, 0xcb, 0x78, 0x58, 0x85, 0x71, 0xd8, 0x60, 0x32, 0x8c, 0x45, 0x36, 0x75, 0x7c, 0xe8, 0x5, 0xa1, 0x93, 0xc3, 0xce, 0x2c, 0x91, 0x62, 0xe5, 0xbd, 0x28, 0x7d, 0xac, 0x81, 0xfe, 0xa4, 0xa8, 0xb9, 0xd3, 0xbb}, types.Tx{0xd1, 0xda, 0xea, 0x1, 0x4a, 0x2e}, types.Tx{0x2f, 0x74, 0xcb, 0x45, 0x69, 0x83, 0xea, 0x9d, 0x20, 0x7, 0xdd, 0x32, 0x1d, 0x1f, 0xa2, 0xb7, 0x92, 0xbb, 0x1b, 0xfa, 0xf3, 0x51, 0x45, 0xb4, 0x6b, 0xa3, 0x95, 0xbe, 0xbb, 0xd3, 0x1d, 0x84, 0x97, 0xdb, 0x90, 0x2a, 0x54, 0x3b, 0x0, 0xc3, 0x95, 0x3c, 0x49, 0xd2, 0xa5, 0xeb, 0x72, 0x91, 0xac, 0x20, 0x3b, 0xc, 0xa8, 0x5c, 0x56, 0x6b, 0x9f, 0x32, 0xe, 0x65, 0xbf, 0xf2, 0x6c, 0xaa, 0x7c, 0x51, 0xcd, 0xf6, 0x8e, 0x30, 0x59, 0xfe, 0x44, 0xc6, 0xe7, 0x3e, 0x15, 0x2b, 0xf, 0xf5}, types.Tx{0xbd, 0xf8, 0x8f, 0xa0, 0x7e, 0x9b, 0xa1, 0x1b, 0x2b, 0x57, 0x47}, types.Tx{0x7d, 0x5d, 0x7c, 0xae, 0x47, 0x21, 0xd3, 0xac, 0x80, 0x5f, 0x2f, 0x78, 0xf5, 0xe, 0x6d, 0xda, 0xc6, 0x42, 0x1e, 0x12, 0xf0, 0x89, 0xe8, 0xdf, 0x19, 0x7f, 0xea, 0xde, 0x5, 0x70, 0x45, 0xee, 0xe9, 0x66, 0x2f, 0x87, 0x36, 0x23, 0xcb, 0xd8, 0x22, 0xf1, 0xc3, 0xd5, 0x88, 0x53, 0x98, 0x9d, 0xae, 0x6f, 0xba, 0x72, 0xcf, 0xdd, 0x0, 0x12, 0x8a, 0xdc}, types.Tx{0x46, 0x52, 0x73, 0x14, 0x43, 0x2e, 0xbc}, types.Tx{0x77, 0xbe, 0x43, 0x12, 0x98, 0xc, 0x7, 0xfb, 0x0, 0xb4, 0x8c, 0x6e, 0x23, 0xa7, 0x29, 0x29, 0x1d, 0xeb, 0xc2, 0x29, 0x7c, 0x4f, 0x82, 0x26, 0x84, 0x68, 0x62, 0x90, 0xa9, 0xc0, 0x77, 0x91, 0x12, 0x51, 0x4, 0x36, 0xc9, 0x5e, 0xcf, 0x11, 0xc, 0xc2, 0x10, 0xcc, 0xc0}, types.Tx{0x9c, 0xab, 0x97, 0x5c, 0x62}, types.Tx{0x31, 0xf7, 0x27, 0xb2, 0x82, 0x10, 0x3d}, types.Tx{0xfb, 0x86, 0x13, 0x7, 0x3b, 0x3e, 0x64, 0x19, 0x3f, 0xe3, 0xab, 0xa7, 0x83, 0x86, 0xbd, 0xda, 0xfa, 0xea, 0xb3, 0xd8, 0xb8, 0x4, 0x50, 0x70, 0xd4, 0xc5, 0x30, 0x91, 0x5, 0x3, 0x58, 0xb4, 0xdf, 0xf2}, types.Tx{0x4d}, types.Tx{0x83, 0x1e, 0xf6, 0x1, 0x7d, 0x6b, 0xab, 0xa2, 0x71, 0x49, 0x20, 0x36, 0xad, 0x71, 0x3e, 0x92, 0xe2, 0x5d, 0x76, 0x8b, 0x8a, 0xb9, 0xe4, 0x10, 0xb4, 0x6f, 0xbe, 0x3c, 0x24, 0xcb, 0x9a, 0x6e, 0x61, 0xb0, 0xe0, 0x84, 0xed, 0xb8, 0x12, 0xed, 0x5b, 0xf, 0x1a, 0x7f, 0xaf, 0x7a, 0x5d, 0x5, 0x40, 0x7}, types.Tx{0x7f, 0xb1, 0x20, 0x42, 0xdb, 0x70, 0x1, 0x4c, 0xa9, 0xbe, 0xbd, 0x94, 0x89, 0x4f, 0x1a, 0xf0, 0x99, 0x66, 0xcc, 0xf4, 0xeb, 0x70, 0xe, 0x46, 0xb2, 0xe1, 0xea, 0xe2, 0x68, 0xa4, 0xeb, 0xc0, 0x86, 0x9, 0x20, 0x88, 0x68, 0x93, 0x55, 0xf8, 0x6e, 0x79, 0x38, 0xab, 0x37, 0x14, 0x3c, 0xa7, 0x39, 0x74, 0xa3, 0xbd, 0x12, 0x2, 0x18, 0xd, 0xf9, 0x89, 0xaf, 0xb2, 0x7c, 0x3c, 0xef, 0xb6, 0x9b, 0x79, 0x95}, types.Tx{0xf8, 0xa7, 0x40, 0x44, 0x91, 0x3c, 0x61, 0xce, 0xd1, 0xce, 0x34, 0x30, 0x45, 0xc2, 0xc0, 0xa9, 0x6b, 0xe7, 0xa0, 0x95, 0x59, 0xbb}, types.Tx{0xcf, 0xb1, 0x80, 0xfd, 0xe7, 0x8b, 0x2e, 0x22, 0x37, 0x77, 0x9e, 0xe1, 0x6d, 0xd6, 0x7, 0x67, 0xf6, 0x58, 0xe6, 0xad, 0xea, 0x51, 0xd8, 0xec, 0xea, 0x7, 0xf5, 0xea, 0xaf, 0x52, 0xf4, 0xbd, 0xce, 0xc2, 0x80, 0x7, 0x9e, 0x40, 0x45, 0x70, 0x59, 0xfc, 0xb8, 0x5d, 0x1a, 0xa, 0x65, 0x31, 0x5a, 0x2f, 0xb8, 0xf4, 0x62, 0xfa, 0x6, 0xa1, 0x4c, 0x11, 0x46, 0xe9, 0x1f, 0x50, 0x3b, 0xa9, 0x9e, 0xdc, 0x43, 0xcd, 0x38, 0x14, 0xd5, 0xa, 0xb5, 0x88, 0xa, 0x75, 0x93, 0x2c, 0x90, 0x88, 0xe9, 0xbf, 0x22, 0x8a, 0x45, 0xbf, 0xff, 0xdc, 0x50, 0x35, 0x42, 0x2c, 0x99}, types.Tx{0xd3, 0x28}, types.Tx{0x87, 0x11, 0x8b, 0x56}, types.Tx{0x62, 0x2e, 0x5e, 0xd4, 0xab, 0x52, 0x1e, 0x2a, 0x74, 0xc6, 0x35, 0x3b, 0xdc, 0xa5, 0x9e, 0xe9, 0x85, 0x6c, 0xcc, 0x41, 0xd3, 0x6, 0xa6, 0xdc, 0x14, 0xec, 0x8e, 0xa7, 0x6a, 0xbc, 0x6a, 0x7b, 0xcd, 0xab, 0x3d, 0xbe, 0x8e, 0xe2, 0xca, 0x7d, 0x6, 0xa1, 0xcd, 0x8b, 0xd1, 0x96, 0x52, 0x94, 0x8e, 0x45, 0xa3, 0xb2, 0x3d, 0x1, 0xb6, 0x94, 0xc5, 0x8f, 0xbc, 0xe, 0xe3, 0xbc, 0x44, 0x9d}, types.Tx{0x2b, 0x57, 0x35, 0x56, 0xc2, 0xa9, 0x7c, 0x1c, 0xc2, 0xaa, 0x85, 0x5, 0x54, 0x81, 0x5d, 0xe5, 0x1c, 0x70, 0xe9, 0x5b, 0x25, 0xfc, 0x78, 0xb0, 0x32, 0xe3, 0x2f, 0xf9, 0xd8, 0x78, 0x1, 0x23, 0xd0, 0x20, 0x18, 0xb9, 0x70, 0xc3, 0x5b, 0x2b, 0xc, 0xf3, 0x7b, 0x43, 0x5f, 0x9c, 0x90, 0xb6, 0x6d, 0x9c, 0xc1, 0x6b, 0xa2, 0xf2, 0x84, 0xc6, 0x11, 0x18, 0xc8, 0xfb, 0xf1, 0x7e, 0x77, 0x1e, 0x1d, 0x54, 0x45, 0x43, 0xab, 0xfa, 0xba, 0xe7, 0xeb, 0x98, 0xa, 0x62, 0xfb, 0x8e, 0xfd, 0x19, 0xe1, 0x1}, types.Tx{0x1d, 0x21, 0x5e, 0xe4, 0x4e, 0xc8, 0xb7, 0xa2, 0xda, 0xb8, 0xd, 0x2, 0x48, 0x17, 0x7, 0xd8, 0x8, 0x62, 0xb, 0x5e, 0xfe, 0xda, 0x36}, types.Tx{0x15, 0x64, 0x98, 0x23, 0x99, 0x42, 0x45}, types.Tx{0x1c, 0xf8, 0x72, 0xea, 0x4f, 0x15, 0xa9, 0x40, 0x1c, 0x10, 0x28, 0xbf, 0x29, 0x86, 0x7c, 0xca, 0xae, 0x5c, 0x5f, 0x8a, 0x58, 0xd4, 0x15, 0x5d, 0x95, 0xed, 0x41, 0x71, 0x0, 0x88, 0x2c, 0x64, 0x38, 0x5b, 0x43, 0xa7, 0xb2, 0xbc, 0x6b, 0x6e, 0x58, 0xff, 0x3e, 0xa5, 0xcc, 0xaf, 0xb2, 0x8c, 0xc9, 0xf3, 0x68, 0x9, 0x15, 0xc0}, types.Tx{0xe8, 0xee, 0x38, 0x65, 0x73, 0x47, 0xf6, 0x56, 0x40, 0xc6, 0xc2, 0x9d, 0xe2, 0xb0, 0x77, 0xa1, 0x9, 0x3, 0xb5, 0x29, 0xc1, 0x1b, 0x78, 0x23, 0xc6, 0x47, 0xd9, 0xed, 0xb7, 0x99, 0x96, 0x93, 0x2a, 0x11, 0xa7, 0xef, 0x37, 0x76, 0x2a, 0x7e, 0xc7, 0x80, 0x8b, 0xfe, 0x47, 0x8c, 0x93, 0xf6, 0x35, 0xcc, 0x69, 0xb1}, types.Tx{0x74, 0x77, 0xd5, 0xff, 0x72, 0x1d, 0x1c, 0xc9, 0xc9, 0x22, 0xe5, 0x7d, 0x82, 0xbe, 0xe1, 0xd1, 0xa7, 0xaf, 0xda, 0xbd, 0xa6, 0xfb, 0xbc, 0xc0, 0xa3, 0x88, 0xbe, 0x86, 0x4, 0x90, 0x77, 0xa8, 0xb9, 0xac, 0x33, 0x53, 0x5f, 0xc3, 0x3f, 0x9e, 0x1f, 0xec, 0xad, 0x3e, 0x0, 0x37, 0x44, 0x1c, 0xec, 0xfd, 0xe3, 0x7c, 0x23, 0xe1, 0xca, 0x91, 0xe9, 0x6f, 0x5f, 0x49, 0x7e, 0x76, 0xae, 0x3d, 0x4d, 0xca, 0xe3, 0x87, 0x19, 0xe0, 0x93, 0xce, 0x2d, 0xb7, 0xb8, 0x93, 0x24, 0x26, 0x84, 0xcf, 0x82, 0x8e, 0x4e, 0x86, 0xfc, 0x8a}, types.Tx{0x3e, 0xb6, 0x37, 0x4b, 0xd9, 0x38, 0xab, 0x70, 0xa3, 0xac, 0x26, 0x1a, 0x74, 0x15, 0xa0, 0xf9, 0x99, 0xf0, 0xe9, 0x78, 0x22, 0x18, 0x65, 0xd3, 0xf1, 0xc8, 0xa4, 0x83, 0xd4, 0x17, 0xbc, 0xc3, 0xb1, 0x56, 0x3c, 0xa0, 0x1c, 0xcf, 0xee, 0xb1, 0x8a, 0x7b, 0x4a, 0x46, 0x26, 0x2a, 0x6e, 0x4, 0x45, 0x5f, 0x39, 0xbd, 0x77, 0x90, 0x96, 0xbc, 0xe4, 0xda, 0x6b, 0x34, 0x37, 0x3c, 0x56, 0xc0, 0xa5, 0x7a, 0x50, 0xae, 0x4c, 0x59, 0xec, 0x18, 0x9e, 0xea, 0xfe, 0xdd, 0x14, 0xea, 0x86, 0x23, 0x71, 0x7e, 0x6, 0xdd, 0x83, 0xa9, 0x88, 0x54, 0xe2, 0x54, 0x50, 0x4d, 0x5, 0x6a, 0x85, 0x14, 0xae}, types.Tx{0x2c, 0x7, 0xbe, 0x70, 0xed, 0xba, 0x97, 0x7c, 0x76, 0xe2, 0x5e, 0x4c, 0x69, 0x42, 0x79, 0x9d, 0xff, 0xf8, 0x3c, 0x4e, 0x10, 0x49, 0xf2, 0x2, 0x6b, 0x92, 0x1a, 0xce, 0xce, 0xd6, 0x1d, 0x6, 0xfb, 0x44, 0xb1, 0xb9, 0x23, 0x38, 0x8b, 0xd2, 0xfd, 0x5f, 0x48, 0x51, 0x8, 0x78, 0x41, 0xca, 0xc5, 0x6b, 0x4b, 0x76, 0x7d, 0x5a, 0x13, 0x1e, 0x46, 0x2f, 0xc1, 0x46}, types.Tx{0xe4}, types.Tx{0x85, 0x7e, 0xb5, 0x4, 0x77, 0xb4, 0x4d, 0x20, 0x82, 0x1f, 0x19, 0xb4, 0x3b, 0x94, 0x62, 0xb0, 0x2a, 0x86, 0xa2, 0xce, 0x21, 0x34, 0x9f, 0xf5, 0x51, 0x1c, 0xdf, 0x5d, 0x6e, 0xe, 0x98, 0xd2, 0xdb, 0xc7, 0x5c, 0x37, 0x83, 0x46, 0xeb, 0xac, 0xf7, 0x6a, 0xae, 0x21, 0x16, 0x0, 0xd7, 0xe3, 0xcf, 0x44, 0xf8, 0x3c, 0xc3, 0xd4, 0xc9, 0x51}, types.Tx{0x46, 0xde, 0xe3, 0x50, 0x7a, 0x81, 0x84, 0xb9, 0xb2, 0xa8, 0xc4, 0x69, 0x6b, 0xc4, 0x7e, 0x29}, types.Tx{0x59, 0x53, 0xd2, 0x53, 0x86, 0x81, 0xcc, 0x66, 0x56, 0x3, 0x37, 0x5b, 0x85, 0x6e, 0x10, 0x5f, 0x13, 0xf8, 0xdd, 0x8b, 0x8c, 0x29, 0x67, 0xf2, 0xc, 0x54, 0x71, 0xc5, 0xdc, 0x75, 0xdf, 0xe2, 0x4b, 0x3c, 0x5e, 0x8a, 0x4e, 0x71, 0x39, 0xf, 0xf7, 0x6, 0x84, 0xc9, 0xa5, 0x80, 0x13, 0x56, 0x5a, 0xd6, 0x2f, 0xab}, types.Tx{0xe3, 0x52, 0x23, 0xf8, 0x15, 0x7, 0x38, 0xf, 0x6a, 0x5, 0xe7, 0xa5, 0x2d, 0x9d, 0x22, 0x3d, 0xe7, 0x84, 0xf0, 0x5d, 0xdb, 0x72, 0x74, 0x3d, 0x6f, 0x22, 0x86, 0xbd, 0x3b, 0x3, 0x73, 0x1e, 0x2c, 0xf, 0x29, 0x7b, 0x26, 0x40, 0x53, 0x6e, 0x59, 0x1, 0x7c, 0x9c, 0x9e, 0x58, 0xc3, 0x9d, 0x2, 0x23, 0x36, 0x41, 0x5a, 0x62, 0xef, 0x95, 0x17, 0xba, 0xee, 0x53, 0xf7, 0x76, 0xa1, 0xe2, 0xce, 0x16, 0x95, 0x47, 0x54, 0x4a, 0xe1, 0x3, 0xf0, 0xfb, 0xf4, 0x6e, 0x17, 0x14, 0x43, 0xea, 0xe4, 0x70, 0xce, 0xbb, 0x71, 0x52, 0x3c, 0x9e, 0x95, 0xf5, 0xf7, 0xf4}, types.Tx{0x92, 0xc2, 0x58, 0x6c, 0xea, 0x9, 0x6c, 0x80, 0xfe, 0xbc, 0x8e, 0x53, 0x2a, 0x7d, 0xc4, 0x2f, 0x4f, 0x77, 0x2, 0x49, 0x89, 0xf7, 0xb0, 0x97, 0x17, 0xfe, 0xbe, 0xb3, 0x2, 0x6e, 0xd, 0x72, 0x37, 0x8c, 0x2, 0xf3, 0x85, 0x44, 0x82, 0xd2, 0x94}, types.Tx{0x5a, 0x79, 0xef, 0xdf, 0xe4, 0x39, 0xe5, 0x6, 0xfd, 0x2b, 0x87, 0x5f}, types.Tx{0x3e, 0xc8, 0xc5, 0x29, 0x17, 0x11, 0x2b, 0x75, 0x3e, 0x10, 0x88, 0xd, 0xc9, 0xe0, 0x3b, 0x89, 0xc2, 0x87, 0x8d, 0x8b, 0x51, 0x64, 0x6e, 0xc6, 0x9c, 0x4a, 0xa9, 0xd4, 0x2b, 0x74, 0xf8, 0xaa, 0x7, 0xe9, 0x41, 0xf0, 0xf3, 0x73, 0x47, 0x3, 0xc9, 0xde, 0x99, 0x0, 0x75, 0x89, 0xc6, 0x47, 0x59, 0x13, 0x8, 0x8c, 0x47, 0xda, 0xb0}, types.Tx{0xe2, 0x8f, 0x83, 0xfb, 0x47, 0x2, 0x1e, 0x60, 0x10, 0x17, 0x5a, 0x31, 0x46, 0x3b, 0x33, 0x45, 0x63, 0x9c, 0x5d, 0x10, 0xe4}, types.Tx{0x96, 0xae, 0xb2, 0x1, 0x2c, 0x26, 0x71, 0x9d, 0x2d, 0xd3, 0x97, 0x95, 0x8b, 0xa7, 0xc2, 0x6f, 0xba, 0xda, 0x6a, 0x52, 0x87, 0x1f, 0x34, 0x92, 0xee, 0xeb, 0xfb, 0x36, 0xd9, 0x80, 0x91, 0xaf, 0x27, 0xb3, 0xaa, 0x57, 0xdc, 0x2, 0x9d}, types.Tx{0x32, 0x52, 0x3a, 0xa, 0x8f, 0x73, 0x59, 0x62, 0x2b, 0x87, 0xd5, 0x7d, 0xe1, 0x97, 0xa4, 0xd7, 0xd5, 0xfa, 0xd2, 0x2f, 0x43, 0x63, 0xa0, 0xfe, 0xe9, 0x1b, 0x4b, 0x9c, 0x28, 0xf6, 0xac, 0x45, 0x36, 0xaa, 0x37, 0x81, 0x9f, 0x26, 0x1d, 0x5e, 0xb3, 0xb7, 0x7c, 0xcb, 0xf8, 0xd9, 0xb8, 0xaf, 0xb8, 0x66}, types.Tx{0xf4, 0x2c, 0xd8, 0x6f, 0x8f, 0xb6, 0x50, 0xc8, 0x9, 0xd5, 0x86, 0x56, 0xdf, 0xe7, 0x34, 0x66, 0xd1, 0x7e, 0xc1, 0x82, 0xb8, 0x25, 0x35, 0xb, 0xb1, 0x7b, 0xfb, 0xe7, 0x76, 0xf9, 0x30, 0x1d, 0x6b, 0xcd, 0xed, 0x4a, 0x59, 0xa6, 0xf8, 0x91, 0x11, 0x4e, 0xe0, 0xf4, 0x92, 0x29, 0x98, 0xb2, 0xfa, 0x1d, 0x90, 0x34, 0x2b, 0x59, 0x9f, 0x7c}, types.Tx{0xc0, 0x81, 0x97, 0x55, 0x43, 0xc3, 0xdb, 0x48, 0xc7, 0x7b, 0xb0, 0x12, 0x90, 0xf3, 0xae, 0xd3, 0x60, 0x16, 0x6d, 0xbf, 0x8d, 0xe5, 0xe, 0x44, 0x31, 0xee, 0xf9, 0xd, 0x46, 0xd8, 0x43, 0x17, 0x7c, 0x11, 0x79, 0x3a, 0x1b, 0x5a, 0x52, 0x6c, 0xd9, 0xc4, 0xcd, 0xba, 0xa7, 0xf5, 0xe4, 0x0, 0xd1, 0xba, 0xdd, 0xfb, 0xf0, 0x6, 0x7, 0xb7, 0xb5, 0x22, 0xd9, 0x66, 0x61, 0xfc, 0xbe, 0x8c, 0x90, 0xb3, 0x23, 0x35, 0x5, 0x63, 0xbe, 0xab, 0xb4, 0x88, 0x5c, 0xe7, 0x3b, 0xe3, 0x26, 0x7c, 0x75, 0x5d, 0xfc, 0x8e, 0x92, 0xdc}, types.Tx{0x99, 0x27, 0x3c, 0x1c, 0x8f, 0x64, 0x35, 0xf8, 0x48, 0x26}, types.Tx{0x6b, 0x43, 0xf6, 0x2b, 0x94, 0x7, 0xb8, 0x53, 0x88, 0xff, 0xa2, 0xb9, 0x61, 0x17, 0x91, 0x59, 0x75, 0x97, 0x77, 0xf, 0x30, 0x26, 0xa5, 0x89, 0x8a, 0x54, 0x92, 0xd1, 0x47, 0xfd, 0x9b, 0x3d, 0xb6, 0x76, 0x5c, 0x4d, 0x30, 0xc, 0x63, 0xe8, 0xa, 0x8e, 0x24, 0x39, 0x54, 0xe0, 0x21, 0xc9, 0xed, 0x24, 0xcf, 0xb0, 0x8f, 0x1e, 0xb0, 0xdd, 0x59, 0xbb, 0x35, 0x3d, 0x6e, 0xa6, 0xd6, 0x3e, 0x70, 0x82, 0x86, 0xb7, 0x17, 0x1a}, types.Tx{0xb2, 0x2d, 0x59, 0x5, 0x2c, 0x8b, 0xaf, 0x97, 0xed, 0x2b, 0x3e, 0xb2, 0xd, 0x6e, 0x40, 0x6a, 0xcb, 0xf8, 0xce, 0x98, 0xf0, 0x9a, 0x59, 0x6c, 0xf, 0xc1, 0x4d, 0x1f, 0x11, 0x73, 0x82, 0x9d, 0x5e, 0xaf, 0x59, 0x13, 0x44, 0x3, 0x3b, 0xdb, 0xef, 0xce, 0x61, 0x91, 0xd1, 0xa5, 0x38, 0x59, 0x46, 0x94, 0xe6, 0x94, 0xdb, 0xf6, 0x8e, 0x7, 0xf6, 0xb0, 0x9b, 0xf2, 0x4b, 0xb4, 0x7f, 0xe6, 0x21, 0xf3, 0x90, 0xe3, 0x42, 0x67, 0x98, 0x77, 0x3a}, types.Tx{0x3a, 0x3, 0xb9, 0x98, 0xf2, 0x82, 0xb9, 0xfc, 0x17, 0xcb, 0xea, 0x84, 0x77, 0x85, 0x7c, 0x38, 0xf1, 0x57, 0x3f, 0x69, 0xd5, 0xe4, 0x59, 0x3e, 0xe8, 0xd, 0x21}, types.Tx{0x18, 0xf0, 0xf2, 0x53, 0xe9, 0x96, 0x4f, 0xa1, 0x9f, 0xc4, 0xa2, 0x3b, 0x29, 0x30, 0x18, 0xf2, 0x52, 0x99, 0x4b, 0x2f, 0x96, 0x1e, 0x35, 0x18, 0xce, 0x86, 0x92, 0xed, 0x12, 0x2e, 0x6, 0x90, 0x96, 0x9f, 0x71, 0x98, 0x7c, 0xd8, 0xb7, 0xf1, 0xc1, 0xb, 0xfc, 0xf1, 0x4f, 0x2a, 0xf5, 0xbd, 0x94, 0x17, 0xa5, 0xb6, 0x3a, 0xa0, 0xf5, 0x8f, 0x5a, 0xc5, 0x31, 0x9e, 0xfb, 0x67, 0x36, 0x69, 0xc, 0x75}, types.Tx{0x28, 0xb3, 0xe2, 0x70, 0x8f, 0x8f, 0xe2, 0x70, 0x27, 0x6b, 0x8f, 0x92, 0x57, 0x8a, 0xe4, 0x58, 0xe4, 0x69, 0x7e, 0xdf, 0xc4, 0x2, 0x90, 0x91, 0x91, 0x70, 0x42, 0xf4, 0x70, 0xe7, 0x54, 0x16, 0x17, 0xd0, 0x74, 0xf1, 0xe5, 0xad, 0x96, 0xd1, 0x60, 0x9, 0x41, 0x79, 0xe, 0xbf, 0x58, 0x9, 0x54, 0xd2, 0xc4, 0x37, 0x5c, 0x86, 0x88, 0x8d, 0xec, 0x4e, 0x80, 0xe8, 0xfa, 0xdb, 0xa2, 0x81, 0x56, 0x99, 0x7d, 0x6f, 0x43, 0xc, 0xc, 0xea, 0xc0, 0x0, 0x42, 0xc9}, types.Tx{0x9d, 0x4a, 0xc9, 0x8c, 0x85, 0xb6, 0x52, 0xa2, 0x4d, 0x1b, 0xb8, 0x65, 0x92, 0x17}, types.Tx{0xcd, 0xc9, 0x43, 0x6b, 0xdf, 0xc8, 0x7c, 0x94, 0xa0, 0x3a, 0x4c, 0x71, 0x68, 0x53, 0xb5, 0x38, 0x26, 0x2f, 0x69, 0x8a, 0xe1, 0xfc, 0xbb, 0xd1, 0x10, 0x9f, 0xd2, 0x3d, 0x8a, 0x40, 0x6c, 0x32, 0x53, 0xc8, 0x40}, types.Tx{0x1c, 0xc3, 0x49, 0x76, 0xaf, 0x30, 0xdb, 0x6b, 0x38, 0xa9, 0x15}, types.Tx{0xac, 0x9c, 0xdb, 0x65, 0xf3, 0xc7, 0xd0, 0xd2, 0xb2, 0xd2, 0x0, 0x12, 0x94, 0xbc, 0x22, 0x12, 0x84, 0x25, 0x9, 0xf1, 0xc9, 0x7c, 0xa9, 0x96, 0x84, 0xfd, 0x56, 0x4b, 0x52, 0x44, 0x23, 0x17, 0xce, 0xc9, 0x4c, 0x9d, 0xb0, 0x5, 0xf, 0x19, 0x20, 0xb3, 0x2f, 0xc8, 0x44, 0x70, 0x88, 0xc3, 0x5f, 0xfe, 0xd, 0x51, 0x27, 0xcf, 0xdf, 0x13, 0x3a, 0x39, 0x1, 0x11, 0x18, 0xb5, 0x2a, 0x75, 0x18, 0xbe, 0x3f, 0x74, 0xb3, 0x32, 0x20, 0x72, 0x8d, 0x7f, 0xed, 0x86, 0x38, 0x42, 0xfc, 0xdb, 0x2b, 0xb7, 0x5b, 0x91, 0x87, 0xad, 0x3a, 0xef, 0xcd, 0x33, 0x69, 0xf8}, types.Tx{0xda, 0x64, 0x5f, 0xd, 0xb6, 0x63, 0x53, 0xf6, 0x83, 0x94, 0xa8, 0x94, 0x31, 0x7f, 0xce, 0x12, 0xff, 0x7e, 0x3d, 0x77, 0x9, 0xe1, 0x17, 0x3b, 0x32, 0xf7, 0x84, 0x4, 0x14, 0xe, 0xd8, 0x3f, 0xa8, 0x2b, 0xf6, 0x94, 0x9d, 0x54, 0x1a, 0x9a, 0x7d, 0x9f, 0xe0, 0xfa, 0x60, 0x5c, 0x43, 0x4, 0xea, 0x38, 0xab, 0x68, 0x38, 0x1a, 0x79, 0xe1, 0x4a, 0xef, 0xaf, 0xdd, 0xa8, 0xe5, 0xc3, 0x40, 0x7d, 0x2e, 0x9b, 0x8, 0x3, 0xe8, 0xbd, 0x44, 0x85, 0xd9, 0x8, 0x1, 0xf3, 0x64, 0x43, 0x8, 0xbb, 0xe3, 0x9b, 0x4d, 0x54, 0xb8, 0x17, 0x88, 0x1b, 0x12, 0xc0, 0x37}, types.Tx{0xd6, 0xb3, 0xcc, 0x1e, 0x88, 0xe9, 0x18, 0xaa, 0x82, 0x82, 0xf3, 0xb4, 0x96, 0xcc, 0x15, 0x63, 0x67, 0x45, 0x76, 0xee, 0x1c, 0xd1, 0x59, 0x21, 0xc8, 0x29, 0x31, 0x65, 0x39, 0x6f, 0xf2, 0x50, 0x79, 0x4a, 0x48, 0xe9, 0x5a, 0x20, 0x8b, 0x31, 0x71, 0xe4, 0x3b, 0x25, 0x63, 0xc4, 0x4b, 0xfa, 0xb3, 0xd4, 0xef, 0xc5, 0x79, 0x6e, 0x1, 0xec, 0xf4, 0x1c, 0x6b, 0xff, 0x2a, 0x47, 0x1d, 0xc7, 0xd4, 0x7c, 0x2, 0x89, 0xc2, 0xf1, 0xac, 0x3e, 0xaa, 0x9, 0x7, 0x45, 0x77, 0x29, 0x2, 0xd0, 0x92, 0xe9, 0x3b, 0x30, 0x70, 0x33, 0x76, 0x53, 0x2a, 0xdf}, types.Tx{0x5d, 0xc2, 0x18, 0x6e, 0xf4, 0x1b, 0xd5, 0xb0, 0x9b, 0x9, 0xe2, 0x8a, 0xb1, 0x1, 0x4c, 0x1d, 0x1d, 0x5c, 0x93, 0x3a, 0x51, 0xa6, 0x41, 0x30, 0x3e, 0x21, 0x53, 0x79, 0xad, 0xf2}, types.Tx{0x62, 0xdb, 0xfc, 0x15, 0xa1, 0x23, 0xe0, 0x72, 0x1d, 0x4a, 0x5a, 0x34, 0xc7, 0x66, 0x6d}, types.Tx{0x9, 0x87, 0x9e, 0x98, 0x9, 0xb7, 0xb7, 0x4f, 0x5e, 0x79, 0x6c, 0xe6, 0x2e, 0x73, 0x90, 0xa0, 0x36, 0x97, 0xe8, 0x99, 0x35, 0x4f, 0x20, 0xff, 0x9a}, types.Tx{0x99, 0x22, 0xf5, 0xb2, 0x4f, 0x9}, types.Tx{0x62, 0xcd, 0xe5, 0x3a, 0xb0, 0xfa, 0x72, 0x40, 0x56, 0x8c, 0xdc, 0x9f, 0xb5, 0x78, 0x74, 0xdf, 0x42, 0x68, 0x0, 0x58, 0x7f}, types.Tx{0x64, 0x11, 0x89, 0xa8, 0xa2, 0xbb, 0x69, 0x8a, 0x28, 0xd5, 0x21, 0x14, 0xb1, 0x5f, 0x1f, 0xca, 0x94, 0x81, 0xd8, 0x61, 0x4f, 0x57, 0xa, 0x44, 0x22, 0xa5, 0xc, 0x21, 0xe3, 0x34, 0x96, 0xe7, 0x6c, 0x29}, types.Tx{0x1d, 0xe0, 0x11, 0x42, 0x7f, 0x7b, 0x1a}, types.Tx{0x94, 0xf2, 0x54, 0xf5, 0xb7, 0x7f, 0x35, 0x34}, types.Tx{0x30, 0x53, 0x92, 0x31, 0x21, 0x8, 0x3, 0x5f, 0xae, 0xe1, 0x3a, 0xdf, 0xd, 0x72, 0x5, 0x58, 0x4a, 0xd9, 0xa, 0x8b, 0x5, 0xd7, 0x5b, 0xb4, 0x9a, 0x60, 0x1, 0x2d, 0x81, 0x1, 0x91, 0x47, 0x4d, 0x91, 0x28, 0xef, 0x4d, 0x94, 0x45, 0xa8, 0x31, 0x91, 0x92, 0xcb, 0x4f, 0xc2, 0x2a, 0x15, 0x30, 0x13, 0xd, 0xfb, 0x44, 0x4a, 0xe, 0xf9, 0xde, 0x9e, 0x8b, 0x76, 0xee, 0x80, 0x61, 0xec, 0xfd, 0xab, 0x3f}, types.Tx{0x3d, 0x97, 0x31, 0xd4, 0xcd, 0x75, 0x9d, 0x4, 0xd8, 0x26, 0x72, 0x18, 0x1f, 0x42, 0xcd, 0x6d, 0x4d, 0x78}, types.Tx{0x97, 0x1e, 0xe6, 0x34, 0xd0, 0x44, 0x29, 0x37, 0xc9, 0x2a, 0x4f, 0x68, 0xe7, 0xff, 0x36, 0x75, 0x8c, 0x65, 0x7a, 0x7f, 0x44, 0xf6, 0x74, 0x3f, 0xe, 0x51, 0xc0, 0x7f, 0xbb, 0x61, 0x6c, 0x3e, 0x97, 0x37, 0xdf, 0x46, 0x83, 0x12, 0x85, 0x89, 0x79, 0xa8, 0x2b, 0x86, 0xd5, 0x3, 0xbb, 0x19, 0x32, 0xfc}, types.Tx{0x1d, 0xab, 0x67, 0xb6, 0x1a, 0x4e, 0x11, 0x7f, 0x7f, 0xd2, 0x11, 0xfa, 0xda, 0xcf, 0x66, 0x1f, 0xa2, 0x89, 0xd0, 0x9c, 0xb7, 0x4b, 0xe1, 0xd, 0xcd, 0x2b, 0xe0, 0xb9, 0x99, 0x41, 0x90, 0x3e, 0xeb, 0x63, 0x32, 0x57, 0xd2, 0x90, 0xe, 0x6a, 0x3c, 0x84, 0x98, 0xfd, 0x1f, 0x20, 0xad, 0x6, 0x88, 0x9f, 0x84, 0x8a, 0xb, 0x13, 0x50, 0xf9, 0x6, 0x2e, 0xc4, 0xf5, 0xc6, 0x31, 0x69, 0x54, 0x18, 0x73, 0x51, 0x94, 0x9b, 0xa, 0x48, 0x9b, 0xf0, 0xc9, 0xe, 0x40, 0xc1, 0xc8, 0x43, 0xd7, 0x66, 0xa2, 0x9f, 0x80, 0xc3, 0xd0, 0x9e, 0x47, 0x57, 0x1f, 0xf2, 0xb3, 0xcd, 0xf9, 0x6f, 0xd7}, types.Tx{0x9d, 0x5, 0xd2, 0xe, 0xda, 0x7a, 0xa8, 0x78, 0x70, 0x15, 0x70, 0x77, 0xbb, 0x6e, 0xd8, 0xe, 0xd1, 0x5, 0xc5, 0xc1, 0xdd, 0x9b, 0xb0, 0x36, 0x14, 0x63, 0xe0, 0x4d, 0xf4, 0xf0, 0x9f, 0xd2, 0x43, 0xf6, 0x36, 0x54, 0x92, 0xd4, 0x75, 0x88, 0xef, 0xfc, 0x74, 0x4c, 0xd0, 0x57, 0xb9, 0xc2, 0x84, 0xb6, 0x4, 0xb, 0x1, 0xe5, 0xe9, 0xac, 0x17, 0xd4, 0xaf, 0x6a, 0x53, 0x28, 0x45, 0xf7, 0x1, 0x3c, 0x76, 0xdc, 0x3f, 0x86, 0x36, 0x80, 0x64, 0xf1, 0x8e, 0x16, 0xf7, 0x9f, 0xe4, 0x5e}, types.Tx{0x65, 0x15, 0x67, 0xee, 0xf0, 0xc0, 0xa2, 0x88, 0x59, 0xc, 0xf9, 0xa, 0x21, 0xa, 0x74, 0x8b, 0x22, 0x39, 0xb5, 0x67, 0xa2, 0x79, 0x42, 0xf0, 0xbf, 0x60, 0x5f, 0xa2, 0x94, 0x5f, 0xe9, 0xf1, 0x18, 0xb3, 0xe7, 0x41, 0x5d, 0x4f, 0x8d, 0xa1, 0xe9, 0xc2, 0x46, 0x4, 0xb6, 0xc, 0x9b, 0xe, 0x22, 0x51, 0xcd, 0xb, 0x3f, 0x7, 0xdd, 0x28, 0x2a, 0xa6, 0x21, 0x96, 0x3f, 0x1c, 0xb3, 0x87, 0xfb, 0xe7, 0x9b, 0x8e, 0x2c, 0x60, 0x51, 0x4c, 0xbf, 0xc0, 0xe8, 0x12, 0xdd, 0xaf, 0xc6, 0x8b, 0x16, 0x2c, 0xfa, 0x5c, 0xe2, 0x9d, 0x19, 0x1f, 0xb1, 0xd3, 0xb6, 0xaf, 0x7a, 0x3f, 0x9a, 0x4a, 0x7f}, types.Tx{0x2a, 0x85, 0x56, 0xa9, 0x4b, 0xa1, 0x45, 0x8f, 0xe1, 0xe8, 0xe, 0x36, 0x50, 0xeb, 0x84, 0x53, 0xc6, 0x3d, 0x3f, 0x42, 0x3d, 0x74, 0xd1, 0xa6, 0x3d, 0xfb, 0xa, 0xf0, 0x17, 0xe7, 0x40, 0xa5, 0x20, 0x1a, 0xf6, 0x83, 0x12, 0x2, 0x37, 0x29, 0xea, 0xca, 0xe0, 0xcf, 0xf, 0x10, 0xf8, 0x6b}, types.Tx{0x3a, 0x7f, 0x4f, 0x52, 0x3c, 0x9f, 0xc, 0xac, 0xd8, 0xab, 0x83, 0xeb, 0x3f, 0xb6, 0x73, 0x27, 0xea, 0x4e, 0xb5, 0x3f, 0x60, 0x6c, 0x2a, 0x86, 0xa0, 0x94, 0x9d, 0x67, 0xc6, 0x4d, 0x92, 0x76, 0xc8, 0x14, 0xce, 0xdf, 0xfa, 0x28, 0x4a, 0x9e}, types.Tx{0x9f, 0xae, 0x86, 0xf7, 0x54, 0xf0, 0xe7, 0x25, 0x4e, 0xa9, 0x27, 0xad, 0x96, 0x25, 0x14, 0x7, 0x5b, 0xd4, 0xeb, 0x6, 0xeb, 0x4a, 0x78, 0x16, 0xe9, 0x96, 0xec, 0xe6, 0x74, 0xa5, 0x38, 0x25, 0x23, 0xd3, 0xd8, 0x3c, 0x5a, 0xf3, 0x3b, 0x24, 0xad, 0x8c, 0x6d, 0xfc, 0xa9, 0x20, 0xd4, 0x31, 0xc0, 0xae, 0x57, 0xb1, 0x6c, 0x6d, 0xd8, 0x9a, 0x48, 0xd1, 0xbf, 0xca, 0xa, 0x41, 0xf9, 0x1f, 0x2f, 0x7, 0x35, 0xa3}, types.Tx{0x30, 0x86, 0x17, 0x89, 0x5e, 0x6d, 0x54, 0x6b, 0x3e, 0xa6, 0xa7, 0xb9, 0xdf, 0x82, 0x99, 0x1a, 0x2d, 0x50, 0x6f, 0x10, 0x27, 0x90, 0x7e, 0xfc, 0xa9, 0x8c, 0x28, 0xbf, 0xd4, 0xca, 0x5c, 0x16, 0xd8, 0xeb, 0xc2, 0x22, 0xf2, 0x9e, 0xbb, 0x70, 0xc2, 0x48, 0x76}, types.Tx{0x94, 0xd0, 0x5c, 0x11, 0xee, 0x3a, 0x1d, 0x7c, 0xb2, 0x56, 0x54, 0xed, 0x37, 0x8c, 0x71, 0x46, 0x56, 0x15, 0xa5, 0xea, 0x25, 0x61, 0x70, 0x61, 0x2a, 0x8e, 0x14, 0xad, 0xb3, 0x1d, 0xd2, 0x67, 0xa4, 0x68, 0x96, 0x30, 0x2, 0xad, 0x25, 0x2b, 0x8, 0x72, 0x82, 0x4f, 0xd7, 0xaf}, types.Tx{0xeb, 0x55, 0xf6, 0x46, 0x2a, 0xd8, 0x20, 0x60, 0x14, 0xd5, 0x85, 0x77, 0xf3, 0xdc, 0xe1, 0xa5, 0x9c, 0x3b, 0xe, 0x83, 0x1, 0x76, 0x91, 0x56, 0x6e, 0x22, 0xda, 0xcf, 0xe6, 0x24, 0xd9, 0x9b, 0x2f, 0xba, 0x90, 0x62, 0x7e, 0xcd, 0x59, 0x32, 0xf3, 0x6b, 0x6c, 0xcd, 0xab, 0x4a, 0xaf, 0x4, 0xe4, 0xfd, 0x3b, 0x98, 0x4a, 0xb0, 0x0, 0xc5, 0x93, 0x3e, 0x17, 0x5d, 0x18, 0x54, 0xa2, 0xd7, 0x0, 0x22, 0x27, 0x6e, 0xdc, 0xbc, 0x58, 0x69, 0x6a, 0x92, 0x41, 0x74, 0xc1, 0x32}, types.Tx{0xa2, 0x13, 0x5c, 0x2d, 0x68, 0x6c, 0xdf, 0xa3, 0xfd, 0xd6, 0x28, 0x68, 0x62, 0x29, 0x69, 0x55, 0x7f, 0x5e, 0xc2, 0x1e, 0x66, 0x91, 0x7c, 0xed}, types.Tx{0x28, 0x53, 0x6b, 0xd8, 0x79, 0x55, 0x14, 0xc1, 0xbf, 0x35, 0x9b, 0x46, 0x6, 0xaa, 0xcf, 0x61, 0x4e, 0x48, 0x31, 0xc5, 0x40, 0x9a, 0x27, 0xc5, 0xc, 0x1b, 0x3d, 0xe2, 0xd8, 0x65, 0x64, 0x34, 0xc7}, types.Tx{0x7c, 0xdf, 0xe9, 0x5, 0xd2, 0x71, 0xe3, 0xe4, 0xf4, 0x11, 0x93, 0x95, 0x63, 0x4d, 0xa2, 0x4f, 0x42, 0x37, 0xc9, 0x93, 0x48, 0x6f, 0x20, 0x17, 0xf1, 0x71, 0x91, 0x29, 0xa9, 0x39, 0xbd, 0xf5, 0xc, 0x85, 0x74, 0x7d, 0xf8, 0x75, 0xb1, 0x1, 0x65, 0x60, 0xbc, 0xd1, 0x3f, 0x7d, 0x93, 0x50, 0xe4, 0xf2, 0x11, 0x13, 0xaf, 0x72, 0xdc, 0x59, 0xaf, 0xb3, 0xef, 0xd8, 0x4c, 0x18, 0x8a, 0x5a, 0x7f, 0x18, 0x2d, 0x5e, 0x5a, 0x6d, 0x32, 0x7c, 0xe8}, types.Tx{0xd3, 0xd4, 0xe2, 0x85, 0x25, 0x59, 0xcf, 0x76, 0xb, 0xc, 0x6c, 0x37, 0x55, 0x79, 0xe4, 0x81, 0x5a, 0x1c, 0x8e, 0x7b, 0xcf, 0x7a, 0x71, 0x40}, types.Tx{0x3f, 0xf2, 0x2b, 0x3b, 0x25, 0xf}, types.Tx{0x9a, 0x8b, 0xaa, 0x14, 0x4e, 0xf9, 0x8b, 0x86, 0x55, 0x50, 0xa8, 0x84, 0xf4, 0x43, 0x3b, 0xc4, 0x5, 0x4b, 0xc4, 0xda, 0x49, 0x28, 0x1b, 0xaf, 0x98, 0x98, 0x95, 0x78, 0x93, 0x37, 0x3, 0xe0, 0x97, 0xe2, 0xb8, 0x60, 0xe0, 0xc7, 0xee, 0xc, 0xcb, 0x8f, 0xd4, 0xc9, 0x70, 0xdc, 0xdc, 0xa5, 0xe, 0xe0, 0x91, 0x55, 0xd2, 0x75, 0x46, 0xc0, 0x67, 0x71, 0x69, 0x62, 0xe0, 0x4b, 0x22, 0xf2, 0x76, 0xc, 0xd3, 0xe7, 0x2d, 0x0, 0xe2, 0xe7, 0x9}, types.Tx{0x9c, 0x88, 0x3f, 0xbe, 0x98, 0x17, 0x1e, 0xc8, 0xe7, 0x37, 0x2a, 0xd0, 0x47, 0x5c, 0x6f, 0xe4, 0x12, 0xc1, 0x3a, 0x25, 0xd5, 0x29, 0x8e, 0x85, 0xcc, 0x41, 0x76, 0x7b, 0xa8, 0x6d, 0xeb, 0xaf, 0x49, 0x63, 0x2c, 0x59, 0x8a, 0xa7, 0xfb, 0x9e, 0x38, 0xe7, 0x3f, 0x4a, 0x40, 0x61, 0xc7, 0x79, 0x85, 0xd9, 0xab, 0xcb, 0xc5, 0xe4, 0x47, 0x88, 0xa, 0x35, 0x2d, 0xb3, 0x94, 0xed, 0x7a, 0x2d, 0xc2, 0x9c, 0x51, 0x32, 0xd, 0x1, 0x36, 0x37, 0xdc, 0x4c, 0x24, 0x84, 0x69, 0x4b, 0x5, 0x36, 0xea, 0x7c, 0x8a, 0xac, 0xef, 0x25, 0x2, 0xc1, 0xe6, 0xf4, 0x14, 0x5c, 0x1d, 0xb4, 0x12, 0x46, 0x17}, types.Tx{0x2a, 0x29, 0x6b, 0xd0, 0x8, 0x69, 0x1e, 0x29, 0x57, 0x41, 0xa8, 0xd0, 0x19, 0x1, 0x6a, 0x9b, 0xce, 0x42, 0x43, 0x80, 0xfe, 0xa6, 0x88, 0xaf, 0x11, 0xf2, 0xcf, 0xda, 0xd2, 0xf7, 0x28, 0x7e, 0xb6, 0x91, 0x53, 0xc4, 0xac, 0x93, 0xaa, 0x7f, 0x13, 0x9d, 0x24, 0xc2, 0xe5, 0xc2, 0x36, 0x77, 0xde, 0x9f, 0xc8}, types.Tx{0x6d, 0x87, 0xb4, 0x89, 0xfd, 0x71, 0x8e, 0x4f, 0xf8, 0x1, 0x14, 0x51, 0x29, 0x4d, 0x4a, 0x8f, 0xa4, 0x8d, 0x74, 0xba, 0xbb, 0x37, 0xb9, 0x23, 0xc5, 0x38, 0x32, 0xab}, types.Tx{0xe8, 0x5b, 0xf0, 0x96, 0xab, 0x4b, 0xb3, 0x1a, 0x27, 0xf0, 0x3b, 0x83, 0x82, 0x19, 0x3, 0xc3, 0x53, 0xdc, 0xe4, 0xb9, 0x46, 0x90, 0x13, 0xed, 0xd4, 0x16, 0x3d, 0xba, 0xe6, 0xe7, 0xf5, 0x5e, 0x6b, 0x22, 0x22, 0xc5, 0x25, 0xa3, 0x6c, 0x45, 0x0, 0x6f, 0x1c}, types.Tx{0xc7, 0x8c, 0xdf, 0xa8, 0x72, 0xb0, 0x9b, 0xe7, 0x2b, 0x93, 0x9d, 0x82, 0x44, 0xdf, 0xc5, 0x62, 0x6c, 0x70, 0x55, 0x6, 0xa, 0xf8, 0xb1, 0xe0, 0x60, 0xab, 0xea, 0x70, 0xbd, 0x82, 0xfd, 0x75, 0xe4, 0x2c, 0x90, 0xe, 0x58, 0x22, 0xf2, 0xd, 0xb5, 0x67, 0x8, 0x1, 0x59, 0x5, 0x29, 0xc3, 0x3c, 0xb4, 0x31, 0x78}, types.Tx{0xff, 0xed, 0xfb, 0x35, 0x92, 0xe5, 0xfc, 0xe1, 0xe8, 0xf1, 0xe0, 0x24, 0xf5, 0xc3}, types.Tx{0xce, 0xd5, 0x17, 0x4f, 0x14, 0xb2, 0x95, 0xcf, 0x3e, 0x25, 0x1f, 0x8, 0xd0, 0xac, 0xa2, 0xb5, 0x72, 0xc8}, types.Tx{0x21, 0x52, 0xb9, 0xcc, 0x3d, 0x8f, 0x93, 0xe0, 0xb5, 0x4f, 0x3d, 0x48, 0x94, 0x7e, 0x75, 0x31, 0x41, 0xeb, 0x89, 0xd6, 0xc3, 0x45, 0x82, 0xd4, 0x11, 0x6d}, types.Tx{0x0, 0x1b, 0x17, 0x6c, 0xb8, 0x33, 0xc6, 0xf8, 0xe6, 0x8b, 0x15, 0x22, 0x3e, 0xa9, 0x5a, 0x56, 0xc6, 0x93, 0xb6, 0xbc, 0xe1, 0xaf, 0xcc, 0x87, 0x70}, types.Tx{0x9c, 0x59, 0x9f, 0x20, 0x39, 0xf8, 0x6b, 0xba, 0xca, 0xac, 0xe8, 0x71, 0xb8, 0xb5, 0x75, 0x1, 0x53, 0x11, 0x83, 0x4c, 0xc5, 0xa0, 0x2f, 0xd8, 0x3b, 0xbc, 0xcf, 0xc8, 0x55, 0x50, 0x5d, 0x6, 0x7a, 0xc2, 0xc, 0xc8, 0x1f, 0xd9, 0xd, 0xf7, 0xb2, 0xdd, 0x2c, 0xf5, 0x98, 0x35, 0x1f, 0xbb, 0xb, 0x51, 0xa8}, types.Tx{0xd9, 0xa0, 0x80, 0x98, 0x80, 0x10, 0x83, 0x8a, 0x29, 0x45, 0xf3, 0xb8, 0x72, 0x3d, 0x8, 0xe3, 0xc9, 0x2a, 0xdc, 0x56, 0x75, 0x63, 0xf1, 0xe0, 0xc, 0xe4, 0x2d, 0xe7, 0xc0, 0x53, 0xe1, 0x3b, 0x3e, 0x1e, 0x47, 0xf, 0x52, 0x35, 0x8b, 0x10, 0xa7, 0x8e, 0xe4, 0xf0, 0x36, 0x1d, 0xc2, 0x73, 0x62, 0x3c, 0xd9, 0xfa, 0xb8, 0xf6, 0xaa, 0x94, 0xc, 0xd0, 0xfb, 0xe8, 0x3f, 0x84, 0xb1}, types.Tx{0x57, 0x51, 0xc9, 0x96, 0xd0, 0xc2, 0x3d, 0x85, 0xb3, 0x4a, 0xc0, 0xd, 0xfb, 0xf2, 0x2c, 0x92, 0x2c, 0x72, 0x98, 0xc7, 0x93, 0x86, 0x6b, 0x75, 0x23, 0xd1, 0xbf, 0xb2, 0xef, 0xf5, 0xbd, 0x83, 0x12, 0x78, 0x85, 0xcd, 0x8f, 0xd4, 0x7, 0x95, 0x58, 0xe7, 0xcd, 0x6, 0xbf}, types.Tx{0x8b, 0x50, 0x4e, 0x9e, 0x58, 0x4f, 0x33, 0x2, 0x75, 0xc, 0xdf, 0xd, 0xb0, 0x8c, 0x10, 0x55, 0x88, 0x8, 0x44, 0x81, 0x9, 0xf7, 0x75, 0xe9, 0xca, 0xf0, 0x4, 0x59, 0xd0, 0x37, 0xf2, 0x99, 0x64, 0xf3, 0x8f, 0xd9, 0x5, 0x30, 0x24, 0x97, 0xd1, 0x9e, 0x6a, 0xe5, 0x24, 0xdc, 0xe5, 0xa4, 0xd9, 0x36, 0x88, 0xec, 0x4d, 0x8f, 0xd5, 0xce, 0xa5, 0x73, 0xa2, 0xa9, 0x25, 0xa7, 0x2c, 0xe7, 0x9a, 0x38, 0x27, 0xfd, 0x3c, 0xa8, 0xb7, 0xe5, 0x95, 0xd3, 0x0}, types.Tx{0x1a, 0x50, 0xa4, 0x4f, 0xad, 0xb9, 0xcc, 0xc9, 0x24, 0xf, 0x58, 0x77, 0x93, 0xc6, 0x4d, 0xa8, 0xd5, 0x7a, 0x7b, 0x93, 0xc5, 0xab, 0x89, 0x54, 0x7e, 0x59, 0x8c, 0x26}, types.Tx{0xf3, 0xf6, 0xf7, 0x6d, 0x52, 0x68}, types.Tx{0xd3, 0x66, 0x24, 0xdd, 0xd, 0xc9, 0xba, 0x5d, 0xc2, 0x3f, 0xc1, 0x4a, 0xf3, 0x88, 0x42, 0x33, 0xf0, 0x65, 0x5d, 0x27, 0xf4, 0x0, 0xa, 0xa4, 0xd, 0x7c, 0x79, 0x42, 0x9, 0x88, 0x5e, 0x76, 0x99, 0xe3, 0x67, 0xc6, 0x92, 0x4a, 0x2, 0x33, 0x38, 0x6d, 0x99, 0xe8, 0x58, 0x77, 0x92}, types.Tx{0x41, 0x1f, 0x81, 0x65, 0xc4, 0x19, 0x86, 0x29, 0x4f, 0x4d, 0xd9, 0x1f, 0x32, 0x1, 0xcb, 0x2e, 0x2e, 0x97, 0xd0, 0xe1, 0xb, 0x62, 0x8, 0xa6, 0xeb, 0x90, 0x12, 0x28}, types.Tx{0xcf, 0x8f, 0x54, 0x48, 0x6d, 0x6a, 0xeb, 0xc2, 0x76, 0xe3, 0xc8, 0xac, 0xca, 0x95, 0x81, 0xd0, 0x38, 0xc9, 0x41, 0xb7, 0xd8, 0xea, 0x5d, 0xda, 0x8d, 0x8e}, types.Tx{0xc2, 0x65, 0x2f, 0x29, 0xbb, 0x67, 0x30, 0x56, 0x44, 0xec, 0x2b, 0x56, 0x1c, 0xe3, 0x6a, 0xb8, 0x39, 0xca, 0x1f}, types.Tx{0x0, 0xe0, 0x65, 0x1, 0xd0, 0xe6, 0x47, 0x7d, 0x1a, 0x4a, 0x18, 0xb5, 0xa4, 0x6e, 0xf1, 0x60, 0x8c, 0xc2, 0x45, 0x1e, 0xb0, 0x22, 0xc7, 0xb0}, types.Tx{0x56, 0x62, 0xf, 0x6, 0x82, 0x22, 0x83, 0x4c, 0x32, 0x50, 0x68, 0x1d, 0x93, 0xda, 0x33, 0x7, 0xa6, 0x57, 0x5a, 0x8a}, types.Tx{0xe8, 0x36, 0x60, 0x67, 0x22, 0x23, 0x52, 0x2b, 0xad, 0x9c, 0xc6, 0x1f, 0xdc, 0x16, 0xe2, 0xe9, 0x56, 0x90, 0x8d, 0x4b, 0xf8, 0x97, 0xd5, 0x2d, 0x85, 0x48, 0x5d, 0x12, 0x56, 0x73, 0xe4, 0xa9, 0xaf, 0xd, 0x38, 0x5c, 0x70, 0xb5, 0xc5, 0xda, 0xf9, 0xd9, 0x41, 0xc8, 0xa2, 0x17, 0x34, 0xf8, 0xed, 0x54, 0xb7, 0x5b, 0x94, 0xbe, 0xa0, 0xa1, 0x45, 0x8c, 0xd0, 0x9a, 0x6f, 0x35, 0xe, 0x5b, 0x46, 0x2d, 0xac, 0x8b, 0xd3, 0xcc, 0xad, 0x45, 0x6a, 0xd8, 0xe2, 0xd2, 0x79, 0xa9, 0xd5, 0x9, 0x10, 0x92, 0xc4, 0xfe, 0x1, 0x14, 0x54, 0xc, 0x3, 0xdd, 0xf1}, types.Tx{0xa3, 0xb3, 0x5d, 0x63, 0x1a, 0xb8, 0x70, 0xae, 0x85, 0x16, 0xc3, 0xf8, 0x56, 0xe8, 0x1c, 0x68, 0x2d}, types.Tx{0xb8, 0x60, 0xb3, 0x6a, 0x65, 0xbd, 0x3b, 0xd2, 0xc1, 0x17}, types.Tx{0x78, 0x37, 0xab, 0x5b, 0x3f, 0x8a, 0x46, 0xa3, 0xcf, 0x82, 0x93, 0x7a, 0x7c, 0x6d, 0x2d, 0x3f, 0x82, 0x2d, 0x38, 0x73, 0xad, 0xed, 0x4f, 0x2d, 0xee, 0x59, 0xa, 0x5, 0x89, 0x96, 0x6b, 0x1d, 0x0, 0xfc, 0xea, 0xaf, 0xef, 0x7f, 0x9c, 0xec, 0x24, 0xf8, 0x53, 0x75, 0xf0, 0xb, 0x7a, 0xb, 0x82, 0xa4, 0xd8, 0xd2, 0xb4, 0xa6, 0x81, 0x7a, 0x27, 0x91, 0xbd, 0x18, 0x3, 0x2d, 0x1, 0xb4, 0xef, 0xdc, 0x11, 0x76, 0xb1, 0x26, 0x20, 0x2e, 0x17, 0xea, 0x85, 0x55, 0x37, 0xae, 0x47, 0x6, 0xc8, 0x89, 0xb2, 0xaf, 0x39, 0xe5, 0x0}, types.Tx{0x55, 0x8c, 0xfd, 0x92, 0x7e, 0xf1, 0x5b, 0xbe, 0x98, 0x81, 0xcb, 0x22, 0x91, 0x9d, 0xd4, 0x22, 0xe8, 0x81, 0xc3, 0xd, 0x3c, 0xb7, 0xd6, 0xd7, 0xdd, 0x1, 0xd2, 0x5f, 0x2a, 0xc1, 0xc3, 0x21, 0x4d, 0x5c, 0x5a, 0x99, 0xfe, 0xc8, 0xbd, 0xe5, 0xa0, 0x28, 0x67, 0x13, 0xb4, 0x68, 0x99, 0x64, 0x2, 0x8a, 0x5a, 0xe2, 0xcb, 0x27, 0xf6, 0x15, 0x90, 0xf6, 0x7b, 0xe3, 0xea, 0xaa, 0x5f, 0x18, 0xfb, 0x42, 0xde, 0xf2, 0xce, 0xf2, 0x22, 0xef, 0x2e, 0x70, 0x38, 0x8a, 0x1c, 0xe0, 0x64, 0xf0, 0x4c, 0x32, 0xa4, 0x1d, 0x22, 0x2a, 0x77, 0x7, 0xd7, 0x4a, 0x6a, 0x49}, types.Tx{0xda, 0x8b, 0xe6, 0x89, 0x82, 0xf5, 0xb6, 0x18, 0x4d, 0xdf, 0x17, 0xb, 0xf7, 0x4a, 0x7f, 0xa7, 0x6b, 0xbc, 0xd9, 0x6c, 0xf8, 0xca, 0x9b, 0x3d, 0xb2, 0x5f, 0x59, 0x3d, 0x9b, 0xc9, 0x22, 0x79, 0x8d, 0xae, 0xf8, 0xb8, 0xe8, 0x54, 0xfb, 0xd7, 0x9c, 0x7e, 0xcf, 0xc2, 0xda, 0xb1, 0xa8, 0x51, 0xe4, 0x5f, 0x87, 0xb8, 0xb1, 0x18, 0x6e, 0x69, 0xc8, 0x13, 0x30, 0x3b, 0x80, 0xd7, 0x2c, 0x8e, 0x52, 0x73, 0xe3, 0x28, 0x98, 0xd5, 0x8f, 0x0, 0xf, 0x21, 0x81, 0x5, 0x10, 0x5a, 0xae, 0xfe, 0xbd, 0xd6, 0x1a, 0x67, 0xd3, 0x6a, 0x78, 0x25, 0x81, 0xa6, 0xe0, 0x60, 0xa4, 0x7f, 0xcd, 0x61}, types.Tx{0x4, 0x28}, types.Tx{0x9f, 0xd, 0x3d}, types.Tx{0x14, 0x33, 0x19, 0x48, 0x1, 0xa7, 0xe4, 0xe4, 0x68, 0x0, 0x61, 0xb9, 0x4, 0x4c, 0x48, 0x97, 0x1, 0xc9, 0xa6, 0xa7, 0xf0, 0xf8, 0x1d, 0xa5, 0x91, 0x60, 0x4d, 0xa9, 0x3c, 0xeb, 0x5b, 0xaa, 0x4f, 0x7c, 0x6, 0xd5, 0x81, 0x1f, 0x70, 0xb2, 0x37, 0xd4, 0x5, 0x49, 0x50, 0x60, 0xc7, 0x25, 0xd4, 0x8b, 0x63, 0x3e, 0x71, 0xf9, 0xf0, 0x2b, 0x92, 0xd9, 0xc, 0xf7, 0x79, 0x63, 0x93, 0x89, 0x6f, 0xfa, 0x4a, 0x69, 0x55, 0xc5, 0xc9, 0x18, 0x38, 0xe5, 0x5f, 0x1d, 0xc4, 0xb5, 0xa4, 0x51, 0x64, 0x77, 0xdd, 0x83, 0x66, 0x2f, 0xa1, 0xd6}, types.Tx{0xeb, 0xdb, 0x88, 0xcd, 0x3, 0x93, 0x59, 0xc5, 0xec, 0x76, 0x2f, 0xa9, 0x7a, 0xc2, 0x4d, 0x83, 0x48, 0x33, 0x98, 0x84, 0xfe, 0x83, 0xf, 0x7f, 0x1d, 0xe9, 0x6e, 0xbb, 0x6, 0x63, 0x8f, 0x4c, 0x51, 0x5a, 0x56, 0xa4, 0x49, 0x99, 0xfb, 0x33, 0x28, 0xed, 0x5c, 0xfe, 0xbb, 0x95, 0x13, 0x32, 0x69, 0xd4, 0xe1, 0xa6, 0x7f, 0x7, 0x39, 0x49, 0x4e, 0xa1, 0x43, 0x96, 0xbb, 0x35, 0xd5, 0x16, 0xf, 0xe8, 0x77, 0x8, 0x48, 0x67, 0x90, 0x10, 0x74, 0xce, 0xf7, 0xb4, 0xde, 0xc9, 0xd9, 0xfc, 0x2b, 0x41, 0xfd, 0x63, 0xc5, 0xb5, 0xef, 0x49, 0x17, 0x64, 0x26}, types.Tx{0xbc, 0xdc, 0x10, 0xf1, 0xfb, 0x3, 0x70, 0x16, 0xa0, 0x35, 0xfa, 0x4f, 0xa3, 0xef, 0x13, 0x97, 0xf7, 0xa6, 0x6f, 0x92, 0x1e, 0x52, 0x98, 0x21, 0x94, 0xd0, 0x9, 0x8b, 0x7b, 0xda, 0x31, 0xe2, 0xa5, 0xe8, 0x11, 0xb2, 0xa3, 0x48, 0xf2, 0xc4, 0xb4, 0x36, 0x4d, 0xbb, 0xc, 0xc3, 0xf8, 0x7a, 0xe4, 0x4a, 0xd8, 0xc5, 0x98, 0x2c, 0xeb, 0x52, 0x8a, 0x1, 0x48, 0x18, 0xfe, 0xc, 0xa5, 0x8, 0x8f, 0xd, 0x89, 0x34, 0xe3, 0xf5, 0xcf, 0xab, 0x82, 0x95, 0x1d, 0xa4, 0xd4, 0xa1}, types.Tx{0xdb, 0x0}, types.Tx{0x21, 0x31, 0xf7, 0xf9, 0xd0, 0x54, 0x1b, 0x9, 0x71, 0x45, 0x4e, 0xb5, 0x8e, 0xe6, 0x1a, 0x3b, 0x1b, 0x66, 0xf1, 0x6c, 0x8d, 0xbc, 0xb8, 0x87, 0xfc, 0x59, 0xbd, 0x68, 0xe6, 0x75, 0x72}, types.Tx{0x58, 0x89, 0x12, 0x92, 0x34, 0xd0, 0x7c, 0xe7, 0x3d, 0x0, 0x2b, 0xb5, 0xab, 0x6, 0x2, 0x6b, 0xf5, 0xdd, 0x52, 0xf4, 0xe4, 0xaf, 0x55, 0xb8, 0x62, 0x38, 0x1c, 0x4d, 0xd8, 0xe2, 0xd6, 0xf9, 0xf1, 0x4d, 0xa0, 0xbd, 0x23}, types.Tx{0x5a, 0xd4, 0x62, 0xb3, 0xd4, 0x2f, 0x51, 0x26, 0x55, 0xd2, 0xa7, 0x63, 0xad, 0xd1, 0xae, 0xc9, 0xf9, 0x30, 0x4e, 0x55, 0x62, 0xa1, 0x93, 0xfc, 0x16, 0xbf, 0xcc, 0xbf, 0x97, 0x54, 0xd2, 0xa5, 0xdd, 0x80, 0x1b, 0x1b, 0x51, 0xc4, 0x9, 0xce, 0xcd, 0x7c, 0x6e, 0xd, 0x6b, 0xfc, 0xce, 0xb2, 0x88, 0x78, 0x85, 0x3b, 0xfb, 0x6f, 0xfc, 0xcd, 0x45, 0x56, 0xb8, 0xe9, 0x3e, 0x4b, 0x9a, 0x20, 0x13, 0x94, 0x7e, 0x64, 0xc5, 0x7}, types.Tx{0x7d, 0x24, 0xbd, 0xc9, 0x8e, 0xca, 0xd7, 0x22, 0x3d, 0xdf, 0x6d, 0x33, 0x8f, 0x1, 0x2f, 0xe9, 0x0, 0x4a, 0x48, 0x7, 0x0, 0xe9, 0x7d, 0x9f, 0x92, 0xa4, 0x1a, 0x97, 0x41, 0xa8, 0x5d, 0xc, 0xd0, 0x26, 0x95, 0xe4, 0xd4, 0xe0, 0xb5, 0xfe, 0xe5, 0xf4, 0xe5, 0x1a, 0xed, 0x2d, 0x1c, 0xa9, 0x72, 0x91, 0x5b, 0x38, 0xce, 0x4d, 0xf2, 0xc2, 0xcd, 0xd0, 0xa6, 0xe8, 0x6c, 0x9b, 0x4b, 0x38, 0x47, 0xe0, 0xd8, 0x7, 0xcb, 0x29, 0xfa, 0x8f, 0xfc, 0x86, 0xc1, 0x31, 0xc9, 0x31, 0x4f, 0xca, 0x3f, 0xa3, 0xdf, 0x70, 0x31, 0xd0, 0x73, 0x7f}, types.Tx{0x4, 0xb, 0xea, 0xfc, 0x7c, 0x9b, 0xe4, 0xdb, 0x5f, 0xd6, 0x8b, 0xbf, 0xc7, 0x1c, 0xf6}, types.Tx{0x82, 0xcf, 0x95, 0xf2, 0x4b, 0x6c, 0x87, 0x75, 0x96, 0x8d, 0x92, 0x33, 0xcd, 0x3d, 0x55, 0xe5, 0xb5, 0xdd, 0xcc, 0xc2, 0x3e, 0x3b}, types.Tx{0xb0, 0xea, 0xe7, 0x9c, 0x7, 0xa4, 0x5a, 0x5d, 0xea, 0xdc, 0xb4, 0x5d, 0x9d, 0x26, 0xe2, 0x88, 0xf2, 0xc2, 0x34, 0x13, 0x0, 0x9, 0x20, 0xe5, 0xef, 0xcc, 0xf1, 0x80, 0x21, 0xb9, 0x9c, 0xc4, 0x32, 0x34, 0x4f, 0x73, 0x77, 0xcd, 0x3, 0x59, 0x43, 0x3e, 0x19, 0xfc, 0x86, 0x84, 0xb, 0x71, 0x17, 0xeb, 0x85, 0xe6, 0x6a, 0x6b, 0x39, 0x2c, 0x44, 0xdd, 0x32, 0xe7, 0x92, 0x91, 0xf5, 0xf7, 0x30, 0xab, 0xe0, 0xfa, 0x81, 0x89, 0x2d, 0x7d, 0x5c}, types.Tx{0x4c, 0x11, 0x74, 0xa3, 0xb6, 0xf, 0x58, 0x24, 0xd8, 0x7c, 0x66, 0x8c, 0xe6, 0x9c, 0x5f, 0xda, 0x6, 0xef, 0xce, 0xf0, 0x4f, 0xd2, 0xb0, 0x27, 0x49, 0x5c, 0xda, 0xc8, 0x45, 0x77, 0x1b, 0x86, 0xa5}, types.Tx{0xd7, 0x26, 0x5, 0xa7, 0x6e, 0x10, 0x25, 0xfe, 0xc8, 0xe5, 0x16, 0x98, 0x26, 0xe0, 0x76, 0xc, 0xba, 0xa3, 0xb0, 0x15, 0x91, 0x32, 0xad, 0x1d, 0x67, 0x77, 0x5d, 0x7c, 0xf, 0x8a, 0x53, 0xef, 0x35, 0x9b, 0x92, 0xed, 0xcc, 0x76, 0xdb, 0xa4, 0x31, 0xcc, 0x38, 0x8f, 0x84, 0xb3, 0x88, 0x7a, 0x89, 0x31, 0x5d, 0x16, 0xd5, 0xd2, 0xef, 0x47, 0x77, 0x2b, 0xa, 0xa2, 0x22, 0xfa, 0x2, 0xc5, 0x1c, 0x75, 0xac, 0xf9, 0x4d, 0x45, 0x78, 0x29, 0xe0, 0x96, 0x1d, 0x49, 0x6c, 0x46, 0xd, 0x11, 0xaf, 0x67}, types.Tx{0x8d, 0x29, 0x8, 0x62, 0x95, 0x71, 0x16, 0xcd, 0xa6, 0x96, 0x11, 0x4f, 0x44, 0xe4, 0x7f, 0x81, 0x9e, 0x20, 0x39, 0x43, 0xc4, 0x54, 0x99, 0x15, 0x38, 0x52, 0x21, 0x4a, 0x5e, 0xc7, 0xa3, 0x2e, 0x44, 0xb, 0xce, 0x31, 0xda, 0x31, 0x18, 0x4c, 0x68, 0xeb, 0x21, 0x75, 0xa9, 0x66, 0xd, 0x32, 0x90, 0x3c, 0x6f, 0x77, 0x68}, types.Tx{0x2a, 0xfc, 0x45, 0x43, 0x1a, 0xc5, 0xa2, 0xee, 0xc6, 0xdb, 0xd9, 0xac, 0x4b, 0xfa, 0x6d, 0x3a, 0xe2, 0xf6, 0x82, 0xb4, 0xeb, 0xe0, 0x10, 0xc2, 0xb2, 0x25, 0x53, 0x22, 0xa3, 0xae, 0x85, 0x21}, types.Tx{0xd, 0x53, 0xc4, 0xe8, 0x14, 0x33, 0x5b, 0x9e, 0x60, 0x43, 0xfc, 0xa0, 0xb6, 0x3e, 0xeb, 0xdd, 0x12, 0x99, 0xb9, 0x6e, 0xf3, 0xc4, 0x36, 0xfe, 0xfb, 0xd7, 0x54, 0xbb, 0xe8, 0x6c, 0x5f, 0x64, 0x75, 0x9c, 0xd, 0xde, 0x24, 0x74, 0x4f, 0x4e, 0x19, 0x94, 0x28, 0x38, 0x11, 0xd4, 0x51, 0xd8, 0xc9, 0x8b, 0xfa, 0x7}, types.Tx{0x83, 0x2b, 0x38, 0xdb, 0xa, 0xc8, 0xa, 0x1e, 0x61, 0x9a, 0xfa, 0x88, 0xb6, 0x4c, 0xe, 0xa9, 0xa1, 0xa3, 0x16, 0x68, 0x15, 0xed, 0x63, 0x79, 0x1e, 0x41, 0x4d, 0xb5, 0x5, 0xdd, 0xfe, 0xe1, 0x8b, 0x1c}, types.Tx{0x8, 0x19, 0x10, 0xbb, 0x4a, 0x86, 0x43, 0xc2, 0x37, 0x76, 0x72, 0x6e, 0x55, 0xd3, 0xcd, 0x4e, 0xa2, 0x61, 0xd2, 0xad, 0x54, 0x49, 0x20, 0x76, 0xb9, 0x11, 0x41, 0xff, 0x3b, 0xef, 0x5c, 0x56, 0xa6, 0xac, 0x81, 0x56, 0x7f, 0x56, 0x70, 0x97, 0x81, 0x38, 0xda, 0xcd, 0x6c, 0x63, 0x12, 0x27, 0xdf, 0x14, 0x24, 0xe9, 0xe, 0x9c, 0xe7, 0xa5, 0x1b, 0x2b, 0x7f, 0x5e, 0xb9, 0xc9, 0x25, 0xd8, 0x5b, 0x84, 0xe3, 0x13, 0xa3, 0xdf, 0x1a, 0x41, 0x61, 0x41, 0x3e, 0x16, 0x3d, 0xa5, 0xc, 0xcc, 0x9, 0xec, 0x42, 0x57, 0x87, 0xea, 0x6, 0xb0, 0x6c, 0x4a}, types.Tx{0xc1, 0xb, 0x6b, 0xb3, 0x2b, 0x84, 0xfa, 0xf5, 0x42, 0xb7, 0x78, 0x24, 0xe0, 0x3d, 0x84, 0xe5, 0x83, 0xac, 0xc1, 0xa, 0x33, 0x27, 0xf3, 0x82, 0xa0, 0xca, 0xa5, 0x28, 0x3d, 0xa8, 0x17, 0x6c, 0xf3, 0xeb, 0xa3, 0x10, 0x40, 0x1e, 0xa2, 0xc5, 0xca, 0xfc, 0xb4, 0x68, 0x5e, 0xd, 0x8d, 0xb9, 0x3f, 0xe2, 0xea, 0x6, 0x67, 0x9, 0x52, 0xa3, 0xa5, 0x6c, 0x9e, 0x98, 0x5e, 0x39, 0x78, 0x69, 0x96, 0xd6, 0xc6, 0x6b, 0xac, 0x69, 0xd2, 0xf3, 0x59, 0x1f, 0x83, 0xc7, 0xf0}, types.Tx{0x10, 0x2c, 0x68, 0x23, 0xe3, 0x1, 0xc5, 0x47, 0x6, 0x35, 0x3d, 0x9c, 0x25}, types.Tx{0x81, 0xe1, 0xca, 0x66, 0xd4, 0x5d, 0xc4, 0x86, 0x96, 0xd, 0x90, 0xee, 0x20, 0x69, 0xd4, 0x3, 0x47, 0x54, 0x58, 0x41, 0xf7, 0x27, 0x66, 0xe6, 0xd5, 0xc5, 0xe6, 0xac, 0x41, 0x5f, 0x19, 0x26, 0x61, 0xf8, 0x9d, 0x60, 0xd0, 0xd1, 0xfa, 0x85, 0x8d, 0x8f, 0xf2, 0x13}, types.Tx{0xd3, 0x56, 0x30, 0xd6, 0xd, 0xba, 0x69, 0x1b, 0xa3, 0x96, 0x8a, 0xce, 0xf4, 0x7a, 0xdc, 0x5, 0x12, 0xfa, 0x65, 0x51, 0xfe, 0xc0, 0xc0, 0x95, 0xe8, 0x54, 0xa8, 0xfc, 0x4f, 0x2f, 0x49, 0x4c, 0xb5, 0x68, 0xd8, 0x26, 0x7, 0x25, 0x45, 0xbc, 0x92, 0xa2, 0xd9, 0x22, 0xf4, 0x3b, 0x42, 0x3a, 0xf8, 0x5b, 0xdb, 0xae, 0xb1, 0x64, 0x36, 0x4f, 0x2f, 0x11, 0xb7, 0x36, 0x2e, 0x5e, 0x66, 0xf9, 0xd2, 0x61, 0xc9, 0xf, 0x9f, 0xb6, 0x5a, 0x30, 0xe0, 0x19, 0xb3, 0x2f, 0x75, 0xcb, 0xa4, 0x4c, 0x61}, types.Tx{0x8d, 0xcf, 0xc8, 0xfb, 0x9f, 0x8a, 0x5d, 0x4f, 0xf6, 0xd0, 0x4f, 0xe5, 0xc, 0x92, 0x5c, 0xfc, 0xef, 0x24, 0xd3, 0x3e, 0x86, 0x24, 0x4d, 0xa8, 0xc1, 0xf7, 0xba, 0x40, 0xbc, 0x2f, 0x6b, 0x15, 0x7c, 0x8, 0x88, 0x93, 0x88, 0xc8, 0x1d, 0x94, 0xa9, 0x3a, 0x6f, 0xc0, 0xfe, 0xb0, 0x14, 0xea, 0x86, 0x4b, 0xc9, 0x9e, 0x3d, 0x57, 0x6f, 0xe2, 0xcf}, types.Tx{0x4e, 0x3f, 0x86, 0x85, 0x81, 0xf3, 0x52, 0xf9, 0x88, 0x8b, 0xde, 0x2b, 0xa3, 0x3f, 0x7f, 0xc, 0x66, 0xcb, 0x9a, 0x8f, 0x9, 0x26, 0x8d, 0x2d, 0x49, 0xf2, 0x3f, 0x51, 0xbf, 0xe3, 0x2a, 0x8, 0x47, 0x8d, 0xaf, 0x7e, 0x3, 0x26, 0x96, 0xc2, 0xf1, 0x4b, 0x2b, 0x31, 0x63, 0x8b, 0xdb, 0x9b, 0xe8, 0x83, 0x3f, 0x8e, 0xaf, 0xe6, 0x5e, 0x18, 0x7f, 0xaa, 0x3e, 0x64, 0xeb, 0xe4}, types.Tx{0x2c, 0x44, 0x5a, 0x6a, 0x80, 0x81, 0xee, 0xd7, 0x7, 0xcb, 0x50, 0xc7, 0xec, 0x3f, 0xf9, 0xc, 0x17, 0x53, 0xae, 0x4a, 0x8d, 0x86, 0x1f, 0xfc, 0xc1, 0x3, 0x73, 0x2d, 0xdb, 0x86, 0x26, 0x49, 0x67, 0x9f, 0xff, 0x44, 0xef, 0xde, 0x2b, 0xd3, 0xb6, 0x70, 0xb, 0xc0, 0xd2, 0xf9, 0x59, 0x55, 0xfa, 0x1, 0x9c, 0x51, 0x4d, 0x3b, 0xaf, 0x31, 0x5e, 0xf5, 0x4d, 0xd2, 0xa4, 0xf0, 0xf2, 0xd0, 0xe4, 0xe, 0xc7, 0x87, 0xc4, 0x5, 0x0, 0x4b, 0xad, 0xe6, 0xf8, 0xe8, 0x2a, 0x4e, 0x44, 0xaa, 0xe6, 0xd6, 0x5b, 0x1b, 0xcd, 0x96, 0x90, 0xb, 0x9b, 0x8d, 0xe3, 0x97}, types.Tx{0xc6, 0xdf, 0x8b, 0x72, 0xa9, 0x22, 0xdb, 0xfd, 0xeb, 0xd4, 0x83, 0x9a, 0xa5, 0x58, 0xef, 0x1d, 0xab, 0xb2, 0x88, 0x51, 0x64, 0xc1, 0x93, 0xbc, 0x36, 0xa, 0x2f, 0x4d, 0xa2, 0x65, 0x43, 0xb9, 0x70, 0xa6, 0xc5, 0x4f, 0xdc, 0xe3, 0xc8, 0x20, 0x1a, 0xd, 0xab, 0x90, 0xf7, 0x47, 0x84, 0xf4, 0x54, 0xc7, 0x13, 0x8c, 0x27, 0x2f}, types.Tx{0x75, 0x53, 0xa4, 0x74, 0x56, 0xcd, 0xe1, 0xd6, 0x39, 0xed, 0x9b, 0x22, 0xdb, 0x6f, 0xbb, 0x4d, 0xdc, 0xd0, 0x9a, 0x26, 0x2c, 0x57, 0x61, 0xdb, 0xe3, 0x35, 0x6e, 0xc3, 0x7f, 0x33, 0x6b, 0x64, 0x76, 0x29, 0x90, 0xe4, 0x84, 0xdb, 0x3b, 0x42, 0xc3, 0xa, 0x95, 0xad, 0xc4, 0x62, 0xaa, 0xac, 0x25, 0x57, 0x4a, 0xcf, 0x9a, 0x3e, 0x35, 0x42, 0xfa, 0x97, 0xf4, 0xfd, 0xea, 0xfd, 0x55, 0x6d, 0x3c, 0xce, 0xc4, 0x40, 0x3d, 0x4f, 0xff, 0x5d, 0xcb, 0x8a, 0x3d, 0x2d}, types.Tx{0x98, 0x64, 0xbe, 0x42, 0x9c, 0x83, 0x9c, 0xb3, 0x64, 0xdd, 0x20, 0x6e, 0xca, 0x6, 0x84, 0x5d, 0xfd, 0xfa, 0x20, 0x92, 0xb6, 0x44, 0x14, 0x10, 0xec, 0x1c, 0xa3, 0x2f, 0x1b, 0x1e, 0xd2, 0x75, 0xf7, 0xfd, 0x7e, 0x9d, 0xb4, 0xdf, 0x89, 0x53, 0xd1, 0xdb, 0xa0, 0xd6, 0x17, 0xa7, 0xae, 0xa5, 0x6c, 0xba, 0x6f, 0x1e, 0xb8, 0xe3, 0xc6, 0xcd, 0x3f}, types.Tx{0xd4, 0x2a, 0x15, 0x6b, 0xf4, 0xfb, 0x87, 0x4d, 0x15, 0xb8}, types.Tx{0xe0, 0xd4, 0x95, 0x82, 0xab, 0xdb, 0xc6, 0xf4, 0xfc, 0xe4, 0xc8, 0xba, 0x8c, 0x10, 0x44, 0x6f, 0x43, 0xf2, 0x24, 0x8c, 0x5d, 0xf4, 0x37, 0xa9, 0xa0, 0xbb, 0xf3, 0xfd, 0x32, 0x63, 0xf4, 0xb6, 0x3b, 0x9, 0x46, 0xb1, 0x5b, 0x13, 0x95, 0x4f, 0x8f, 0x9f, 0xc4, 0x4f, 0xe3, 0xec, 0x3b, 0x4c, 0xec, 0xbc, 0xb1, 0xb5, 0x1f, 0xe8, 0xa1, 0x2b, 0x57, 0x4b, 0xa, 0x9b, 0xb0, 0xf4, 0xd1, 0xcd, 0x7c, 0x6e, 0xf9, 0x9c, 0xba, 0x9f, 0xa1, 0x88}, types.Tx{0x24, 0x21, 0xc6, 0xa9, 0x8b, 0xf3, 0xe7, 0xb4, 0x61, 0x3b, 0x95, 0x39, 0x7f, 0x9b, 0xad, 0x41, 0x3, 0x9c, 0xde, 0x1b, 0x8e, 0xd4, 0xb2, 0xd4, 0xa9, 0xaa, 0xdc, 0xc2, 0xae, 0xa3, 0x11, 0xe2, 0x6a, 0x8c, 0x52, 0x3a, 0xd6, 0xa0, 0xce, 0xd6, 0xaa, 0x9f, 0xfe, 0x9a, 0xfc, 0x50, 0x49, 0xa4, 0x69, 0x7c, 0x3a, 0xe0, 0xe6, 0x51, 0xf, 0xa7, 0x13, 0x6c, 0xb6, 0x10, 0xe0, 0x1f, 0xbb, 0x36, 0xc6, 0x2b, 0x10, 0x6f, 0x1e, 0x90, 0xa5, 0x1e, 0xd7, 0xbb, 0x93, 0x45, 0xa1, 0x31}, types.Tx{0x29, 0xa, 0xc8, 0xcb, 0x81, 0x3a, 0xfc, 0x15, 0x91, 0x8f, 0x77, 0x83, 0xb3, 0x36, 0x76, 0x82, 0xe9, 0xed, 0xdf, 0xd0, 0xdc, 0x68, 0x31, 0xeb, 0x8d, 0xe1, 0xb9, 0x7c, 0xd6, 0xba, 0xb8, 0x8f, 0x50, 0xd5, 0xfa, 0xca, 0xab, 0x1e, 0x87, 0xcc, 0x52, 0xdc, 0x43, 0x54, 0xb4, 0xce, 0xa7, 0xcd, 0xa5, 0x52, 0x16, 0x1c, 0x96, 0x8b, 0xbe, 0x86, 0xc8, 0x6c, 0x75, 0x1b, 0x7d, 0xb8, 0xa, 0x36, 0x8a, 0x16, 0x64, 0xfd, 0x34, 0xa, 0x4b, 0x55, 0x8d, 0x15, 0x3d, 0xa, 0xf5, 0xc9, 0xca, 0x6b, 0x14, 0xc1, 0x54}, types.Tx{0x6a, 0xc, 0x37, 0x9f, 0xe8, 0x44, 0x87, 0xcd, 0xfb, 0x29, 0xe8, 0x20, 0xe5, 0x39, 0xcd, 0xf, 0xc8, 0xa9, 0x8c, 0x97, 0xd7, 0x74, 0x7d, 0x94, 0x37, 0xe8, 0xc9, 0x36, 0x53, 0xae, 0xb9, 0xe9, 0xca, 0xbe, 0xe6, 0xd8, 0x58, 0xd1, 0x12, 0x30, 0x9, 0x18, 0x8f, 0xe, 0x66, 0x62, 0x32, 0xb9, 0x50, 0x77, 0x32, 0x84, 0xe9, 0xb, 0xba, 0xce, 0x5, 0xb8, 0xe3, 0xce, 0x7b, 0xb5, 0x9c, 0xe8, 0x40, 0x64, 0x4c, 0x2d, 0xaa, 0x3a, 0x10, 0xb8, 0xad, 0xc0, 0xda, 0xf1, 0x2d, 0x8d, 0xdb, 0x2a, 0x95, 0xef, 0x65, 0x54, 0x1b, 0x5b, 0x50, 0xb3, 0x2b, 0xe6, 0x38}, types.Tx{0xb2, 0x25, 0x14, 0xcb, 0x8c, 0x35, 0x15, 0x26, 0xce, 0xd4, 0x14, 0xd1, 0x5, 0xfe, 0x24, 0x99, 0x1b, 0xc7, 0x59, 0x5c, 0x19, 0xc8, 0x3b, 0xc0, 0x1d, 0xfa, 0x51, 0xa4, 0x2b, 0x5d, 0xc0, 0x87, 0x29, 0xd7, 0xe8, 0xbc, 0xbf, 0x23, 0xe0, 0xab, 0x8d, 0x5a, 0xff, 0xf1, 0xa, 0x7a, 0x6, 0x92}, types.Tx{0x7f, 0xba, 0x37, 0x6c, 0x4, 0x65, 0x9, 0x26, 0xb5, 0x85, 0x9a, 0x7, 0x52, 0x7b, 0x56, 0xc1, 0x65, 0x8f, 0x26, 0xdf, 0x13, 0x12, 0x32, 0x17, 0xb8, 0x71, 0x87, 0xc6, 0x14, 0x3f, 0x8f, 0xa7, 0xdc, 0xdc, 0xd8, 0xcf, 0x73, 0x12, 0xba, 0x5b, 0xf, 0xa7, 0x68, 0xb0, 0xb6, 0xf6, 0x19, 0x52, 0x36, 0x83, 0x73, 0xe, 0xdb, 0x32, 0x68, 0xba, 0x99, 0x61, 0x6, 0x18, 0xb8, 0xb2, 0xe6, 0x9}, types.Tx{0xea, 0xb9, 0xda, 0x29, 0x96, 0x34, 0xe4, 0xc9, 0x75, 0xd, 0x7, 0xfd, 0xa9, 0x40, 0x12, 0x5e, 0xd7, 0xd4, 0xbb, 0xfd, 0x7e, 0x39, 0x91, 0xba, 0x7f, 0xe8, 0x41, 0x28, 0x9a, 0x7e, 0x85, 0x19, 0x52, 0xe, 0x1d, 0xe7, 0x73, 0xbd, 0x7a, 0x44, 0x65, 0xef, 0x63, 0xb8, 0x54, 0xf9, 0x90, 0x3d, 0x94, 0x47, 0xe4, 0xe, 0xa9, 0xdd, 0x68, 0x6d, 0x61, 0x49, 0x19, 0x23, 0x7b, 0xdc, 0x7b, 0xcc, 0xf0, 0x99, 0x1f, 0x86, 0x27, 0xfe, 0xde, 0xf6, 0x7a, 0xae, 0x9e, 0x69, 0xb, 0x32, 0x6f, 0xc7, 0xcc, 0x20, 0xb5, 0x79, 0x8d, 0x46, 0x5, 0x5, 0xfc, 0xcf, 0xc9}, types.Tx{0x4c, 0x6a, 0xdd, 0x73, 0x6d, 0xc1, 0x18, 0xe8, 0x63, 0x64, 0xe4, 0xa1, 0x82, 0xa1, 0x7d, 0x3b, 0xd7, 0x5b, 0x38, 0x15, 0x5b, 0xf8, 0x3e, 0x5d, 0x90, 0x15, 0x5d}, types.Tx{0x95, 0xd8, 0xb2, 0x17, 0xd1, 0x45, 0x67, 0xeb, 0xd3, 0x38, 0xdc, 0xab, 0x72, 0xc8, 0xc5, 0xdc, 0x82, 0x94, 0xf3, 0xe8, 0xce, 0x5a}, types.Tx{0x59, 0x9d, 0x99, 0xa1, 0xb9, 0xa7, 0x64, 0x44, 0xdc, 0x15, 0x0, 0xff, 0xd1, 0x3b, 0x1a, 0xb6, 0xf9, 0xf9, 0x24, 0x1a, 0xf9, 0x4d, 0x3b, 0x30, 0x4c, 0xe, 0x18, 0x31, 0xe, 0x73, 0xb, 0x29, 0x81, 0x97, 0x1d, 0x97, 0x66, 0x36, 0x10, 0xe4, 0x42, 0xa6, 0x69, 0x3e, 0xef, 0x19, 0xff, 0x23, 0xc3, 0x35, 0x7a, 0x63, 0x80, 0xed, 0x27, 0x60, 0x1c, 0x9a, 0xee, 0xa0, 0x6b, 0xa1, 0x28, 0x23, 0x7a, 0x9e, 0xa4, 0x82, 0x2b, 0xf, 0x50, 0xa0, 0x69, 0xba, 0x71, 0xbf, 0x62}, types.Tx{0x2c, 0x51, 0x7a, 0x76, 0x9a, 0x76, 0x53, 0x12, 0xa7, 0xc1, 0x66, 0x46, 0x92, 0x38, 0xf4, 0xec, 0xc4, 0xb1, 0xf1, 0x44, 0x27, 0x36, 0x4c, 0xaf, 0xaa, 0xe6, 0xa7, 0xd1, 0x33, 0x10, 0x55, 0x14, 0x27, 0x1e, 0x31, 0x1b, 0x6c, 0xfe, 0xbf, 0x82, 0xf4, 0x8f, 0xff, 0xe6, 0x33, 0xcc, 0xf8, 0x52, 0xd2, 0x4e, 0xd7, 0x3e, 0xe1, 0x96, 0xe7, 0xee, 0x8d, 0x85, 0x35, 0xaa, 0x63, 0x49, 0x53, 0xbf, 0xb4, 0x61, 0xcc, 0xe7, 0xbd}, types.Tx{0xcd, 0xe8, 0x4f, 0x8, 0x18, 0x38, 0x46, 0xcf, 0x30, 0x73, 0x46, 0xaf, 0xed, 0x56, 0xb6, 0x6e, 0xca, 0x86, 0x7a, 0xd6, 0xb1, 0xcf, 0x36, 0x5c, 0xf5, 0xf6, 0x58, 0x80, 0x51, 0xbb, 0x69, 0x6, 0xab, 0x6b, 0x4, 0x73, 0xb5, 0x78, 0xe6, 0x6e, 0x11, 0x3c, 0x4d, 0x54, 0xcb, 0x75, 0x21, 0xac, 0x6f, 0x8f, 0xf6, 0xcc}, types.Tx{0xdb, 0x85, 0x22, 0xc4, 0x9a, 0x70, 0xb0, 0x5b, 0xa2, 0xaf, 0x1d, 0x84, 0x96, 0x46, 0x1e, 0xdd, 0xd6, 0xd3, 0xac, 0x58, 0xc, 0x9c, 0x82, 0x90, 0xe6, 0x4b, 0x21, 0x93, 0x94, 0x8b, 0x2c, 0x6e, 0x56, 0x32, 0xa2, 0x6, 0xd2, 0xb9, 0xf5, 0x21, 0x56, 0x48, 0x1f, 0xae, 0xcc, 0x2, 0xdf, 0x50, 0x2c, 0xfb, 0x52, 0x1e, 0x5, 0x5e, 0x80, 0x2b, 0x82, 0x69, 0x83, 0xb7, 0x15, 0x85, 0x4a, 0x63, 0xe5, 0x30, 0xf1, 0x90, 0x67, 0x71, 0x42, 0xd9, 0xee, 0xd0, 0x9c, 0x21, 0x17, 0x99, 0x3c, 0xe8, 0xde}, types.Tx{0xd0, 0xb2, 0x74, 0xeb, 0x3d, 0x46, 0x69, 0x6d, 0xc5, 0x4c, 0x6d, 0x7b, 0x91, 0x37, 0xe2, 0xdc, 0xac, 0x1, 0x7c, 0xae, 0x69, 0x94, 0x65, 0x21, 0x55, 0x33, 0xac, 0xbe, 0x6, 0xbb, 0xe8, 0xf8, 0x71, 0xa, 0x44, 0x8, 0xf8, 0x8d, 0xfc, 0x73, 0x38, 0xf6, 0xe, 0xbc, 0x33, 0x6e, 0x7c, 0xd8, 0x4, 0x94, 0x65}, types.Tx{0x5, 0x6, 0x49, 0x28, 0x2, 0x5d, 0x81, 0xaa, 0xab, 0xf6, 0x67, 0x20, 0xbe, 0xc, 0xb5, 0x5a, 0xbb, 0x7e, 0x28, 0x32, 0x9, 0x6c, 0x46, 0x12, 0xb5, 0x4e, 0xef, 0x75, 0x5f, 0x7d, 0xd3, 0x56, 0x8c, 0xd0, 0x71, 0x1e, 0x15, 0x22, 0x5a, 0xd6, 0xc1, 0x44, 0xc1, 0xbe, 0xff, 0x54, 0x31, 0x47, 0x37, 0x7c, 0x19, 0x76, 0x10, 0x42, 0xad, 0x5c, 0x91, 0x96, 0x31, 0x76, 0x92, 0x56, 0xd8, 0xe1, 0x14, 0xaa, 0x77, 0x20, 0x33, 0x7e, 0xc8, 0xf2, 0xab, 0x52, 0x24, 0x7a, 0x2, 0x74, 0x5b, 0x34, 0xae, 0x8b, 0x76}, types.Tx{0x9c, 0x2e, 0x6e, 0x67, 0xa4, 0x79, 0xe, 0x90, 0x84, 0xfa, 0x7f, 0xc4, 0x3, 0x48, 0x63, 0x50, 0x1c, 0x16, 0xee, 0x92, 0x89, 0xd6}, types.Tx{0x2c, 0xc1, 0x2, 0x43, 0x4e, 0xfb, 0x10, 0x3f}, types.Tx{0xb3, 0x35, 0xc5, 0x68, 0x87, 0xf4, 0x92, 0x40, 0x22, 0x37, 0x2e, 0x46, 0xa5, 0x58, 0x31, 0x7d, 0x76, 0x4d, 0x36, 0xeb, 0x20, 0x76, 0x58, 0x3e, 0x9, 0x3e, 0x8f, 0xb9, 0x17, 0x64, 0x85, 0x9f, 0x7, 0x97, 0x33, 0xca, 0x22, 0xe8, 0x4e, 0x2f, 0x9d, 0x2c, 0xb4, 0x2c, 0xa4, 0x49, 0xb6, 0xf, 0xa4, 0x84, 0xbe, 0x14, 0xe4, 0x2d, 0xbc, 0xdd, 0xfb, 0xbb, 0x1d, 0x2a, 0x7f, 0x13, 0x85, 0x66, 0xfd, 0x9d, 0x85, 0xb8, 0xfe, 0x5d, 0xab, 0x97, 0x81, 0xb2, 0xb3, 0xb, 0x7d, 0xb2, 0xfb, 0xd8, 0x95, 0xb, 0x25, 0x0, 0xd9, 0x3d, 0xf5, 0xe3, 0x2b, 0x4, 0x9f, 0x93, 0x93, 0x30, 0x99}, types.Tx{0x81, 0xd2, 0x98, 0xcc, 0x78}, types.Tx{0x18, 0xcb, 0xfb, 0x55, 0x5b, 0xe9, 0xd5, 0xd1, 0xb6, 0x1b, 0x3a, 0x83, 0x83, 0xe8, 0x4e, 0xf1, 0x1f, 0xb9, 0xbf, 0x4e, 0x74, 0xfb, 0xeb, 0xaf, 0xd9, 0x89, 0xbf, 0x88, 0x4e, 0x8c, 0x3a, 0xea, 0x32, 0x70, 0x9b, 0x7, 0x4e, 0xe6, 0x4e, 0xb, 0xd9, 0x43, 0x21, 0x54, 0xb3, 0xb2, 0xd, 0x80, 0x6d, 0xa, 0x48, 0x75, 0x51, 0x4, 0x29, 0x3c, 0x85, 0x41, 0x7a, 0x5f, 0xfd, 0x45, 0xdf, 0x13, 0x24, 0xcd, 0xeb, 0x7c, 0x4d, 0x57, 0x24, 0x19, 0x52, 0x6f, 0xb4, 0x83, 0xd5, 0x44, 0x59}, types.Tx{0x4d, 0x5e, 0x50, 0xf3, 0xa9, 0xb7, 0x43, 0x46, 0xb6, 0x6f, 0x50, 0xbf, 0x52, 0xde, 0x86, 0x62, 0x8e, 0x8e, 0xe8, 0xf7, 0x3c, 0x96, 0x93, 0xe4, 0x7, 0x4c, 0xd1, 0xbe, 0x45, 0x5f, 0x89, 0xeb, 0x54, 0x5e, 0xa1, 0x2f, 0x49, 0x94}, types.Tx{0xf1, 0x28, 0x20, 0xd4, 0xd8, 0xf, 0xaa, 0x9a, 0x65, 0x83, 0x6c, 0x0, 0x6, 0xbd, 0x92, 0x4a, 0x38, 0x17, 0x4c, 0x26, 0x2d, 0x15, 0x68, 0x35, 0x58, 0x4c, 0xeb, 0x15, 0x8e, 0x91, 0x92, 0xb1, 0x84, 0x1, 0xec, 0xf7, 0x1d, 0x3, 0x8d, 0xbe, 0xa4, 0x97, 0xec, 0x7d, 0x9b, 0xae, 0x8d, 0x51, 0xd7, 0xfa, 0x50, 0x8a, 0x40, 0x31}, types.Tx{0xf4, 0x25, 0x9c, 0xaa, 0x75, 0x7f, 0xd0, 0xa2, 0x65, 0x3c, 0x45, 0x3, 0x8f, 0xf4, 0x86, 0x16, 0x73, 0x71, 0x34, 0x7a, 0xaa, 0x3b, 0xd3, 0x25, 0x12, 0xb9, 0xd1, 0xd4, 0x9f, 0xc6, 0xf6, 0xf3, 0x78, 0xbf, 0xc7, 0x6, 0x9f, 0x8e, 0x58, 0x89, 0xa, 0x36, 0xb5, 0x0, 0xf4, 0x4d, 0x53, 0x75, 0x6, 0x6, 0x62, 0xf0, 0xe4, 0xc1, 0x51}, types.Tx{0xc2, 0x97, 0x36, 0x4c, 0x24, 0x9f, 0x9c, 0x8c, 0xff, 0x43, 0x0, 0xa6, 0xde, 0x60, 0x33, 0x3d, 0xf3, 0x8a, 0x7e, 0xee, 0x21, 0xc1, 0xfd, 0xe6, 0xae, 0x90, 0x27, 0xe6, 0x6, 0x4c, 0x33, 0x10, 0x50, 0x79, 0x5f, 0x92, 0x88, 0x58, 0xaa, 0x61, 0x42, 0x6e, 0x54, 0x4d, 0x3a, 0x46, 0x21, 0xbc, 0xb, 0x9, 0x60, 0xed, 0xcd, 0xa1, 0xa0, 0x94, 0x54, 0x6c, 0xe8, 0x7f, 0x15, 0x6b, 0x0, 0xe2, 0x90, 0x22, 0x9d, 0x36, 0xc6, 0xb9, 0x90, 0x99, 0x76, 0xf5, 0xc8, 0xf2, 0x24, 0xe8, 0xfb, 0xc8, 0xd5, 0x9f, 0xa6, 0x96, 0x43, 0x7b, 0x3a}, types.Tx{0xe5, 0x7d, 0xbe, 0x6e, 0xa4, 0x77, 0xe1, 0x5d, 0x6b, 0xbc, 0x4b, 0x46, 0xa5, 0x62, 0xd6, 0x9d, 0xc4, 0xab, 0xfc, 0xb1, 0x5f, 0xd, 0x3f, 0xe2, 0xb, 0xbe, 0xff, 0x28, 0x9, 0xd2, 0x53, 0x59, 0x65, 0xcf, 0x78, 0xcb, 0xc0, 0x4e, 0x41, 0x43, 0xf9, 0x32, 0x44, 0xd6, 0x7a, 0x1b, 0x62, 0x79, 0xf8, 0x87, 0x28, 0xcc, 0xdc, 0xcd, 0x46, 0x50, 0x56, 0x7b, 0x9b, 0x63, 0xb2, 0x10, 0xfa, 0x62, 0x9c, 0xe2, 0x2, 0x36, 0xa, 0x5e, 0x90}, types.Tx{0x1f, 0xcf, 0x23, 0xd, 0x7c, 0xa0, 0x98}, types.Tx{0xcd, 0x97, 0x50, 0xc8, 0x13, 0x74, 0xab, 0x88, 0x13, 0xb5, 0x7c, 0x51, 0xf3, 0x36, 0x88, 0x9d, 0x79, 0x61, 0x10, 0x41, 0xb7, 0x39, 0xf0, 0xf4, 0x18, 0x88, 0x16, 0x1a, 0x67, 0xf9, 0x1, 0x8b, 0xf5, 0x7, 0xb5, 0x45, 0xd2, 0x8d, 0x34, 0xf0, 0x3b, 0xda, 0xe9, 0x9a, 0x14, 0xa6, 0x77, 0xd3, 0xc4, 0xa2, 0xc4}, types.Tx{0xb5, 0xfb, 0xcc, 0xfe, 0xb9, 0xb0, 0x80, 0x62, 0x70, 0x83, 0x45, 0x36, 0xc8, 0x6f, 0x96, 0x46, 0xb0, 0x80, 0xd5, 0xba, 0x67, 0xa, 0x29, 0x65, 0xbb, 0xed, 0xef, 0xce, 0x78, 0x76, 0x13, 0x77, 0x9f, 0xd6, 0x43, 0xf, 0xa9, 0xe7, 0xe7, 0xa2, 0x41, 0x7a, 0x70, 0xaa, 0x5f, 0x6d, 0x2c, 0x13, 0x8a, 0xf8, 0x0, 0x75, 0x3, 0x45, 0x8a, 0x7d, 0x40, 0x1e, 0xee, 0xbb, 0xca, 0x63, 0xc2, 0xc5, 0x4a, 0xe1, 0x5c, 0x7b, 0xd6, 0xd, 0x94, 0xc5, 0x8b, 0xe, 0xfe, 0x6f, 0x60, 0xb2}, types.Tx{0x21, 0xac, 0xf3, 0x5c, 0x89, 0xd6, 0x68, 0xcf, 0x96, 0xe0, 0xca, 0x3e, 0x1a, 0xa2, 0xf7, 0x7a, 0x5e, 0x9a, 0x39, 0x3b, 0x6a, 0x7c, 0x4f, 0x4d, 0x1f, 0x9d, 0xa4, 0x25, 0x95, 0x4f, 0x7f, 0xc0, 0x41, 0x92, 0xf9, 0xbc, 0x6c, 0xb3, 0xfe, 0xa2, 0xdb, 0x5b, 0x54, 0x27, 0x7a, 0x5f, 0xed, 0x47, 0x38, 0xf, 0x3b, 0xaa, 0xbf, 0x76, 0xd2, 0x7b, 0xd8, 0x86, 0x74, 0xae, 0xab, 0xe5, 0xa3, 0xbd, 0x3d, 0x3f, 0x26, 0xff, 0x15, 0xbb, 0x62, 0x24, 0x45}, types.Tx{0x11, 0xa, 0xf0, 0xaf, 0x64, 0x15, 0x1f, 0xff, 0x78, 0x3c, 0x9a, 0x8b, 0x26, 0x5d, 0xdd, 0xc5, 0x27, 0x14, 0x38, 0x89, 0x6, 0xbd, 0xab, 0x11, 0x40, 0xf2, 0xf4, 0x33, 0x1b, 0xd9, 0x2c, 0xf9, 0xd8, 0x2d, 0xdf, 0x67, 0x44, 0x44, 0x33, 0x41, 0x44, 0x79, 0xfe, 0x91}, types.Tx{0xa, 0x6d}, types.Tx{0xd4, 0x7c, 0xd0, 0x3e, 0xec, 0xef, 0x9, 0xa6, 0xb7, 0xfb, 0xf9, 0x8c, 0x5f, 0xf7, 0xa2, 0xf4, 0x92, 0x14, 0x4e, 0x7, 0x78, 0x92, 0xc8, 0xfa, 0x45, 0xf5, 0xa0, 0xa1, 0xbe, 0xff, 0x6c, 0xb0, 0x38, 0xa5, 0x3b, 0x6a, 0xeb, 0x94, 0xbe, 0xff, 0x3a, 0x6a, 0xe, 0xa7, 0x3b, 0xe7, 0xf, 0xf0}, types.Tx{0xd4, 0xaf, 0x4c, 0x2c, 0x14, 0x5, 0xf, 0x7f, 0x63, 0x56, 0x7c, 0xa8, 0x88, 0x69, 0x43, 0x9f, 0x1, 0xc1, 0x6d, 0x6b, 0x74, 0xde, 0x5b, 0xd8, 0xb, 0xb8, 0xe0, 0x9, 0x8e, 0xc5, 0xb3, 0x79, 0x1d, 0xe8, 0x3f, 0xd1, 0x74, 0xfe, 0xd6, 0x4f, 0x63, 0xe1, 0x98, 0xe5, 0xf0, 0x70}, types.Tx{0x46, 0xe3, 0x83, 0x86, 0x90, 0x28, 0x1a, 0x36, 0xe, 0x30, 0xba, 0x24, 0xca, 0x88, 0x1c, 0x48, 0xf1, 0xfb, 0x71, 0xed, 0x84, 0x40, 0xce, 0x52, 0x49, 0x2c, 0xe3, 0xe7, 0x13, 0x4b, 0x3f, 0x2d, 0x6, 0x47, 0xa9, 0x11, 0xf4, 0xc2, 0xb1, 0x17, 0x78, 0xeb}, types.Tx{0x6f, 0x98, 0xac, 0xd2, 0x53, 0xee, 0xc6, 0xb, 0x71, 0xa3, 0x87, 0x7b, 0xad, 0x1a, 0xd8, 0x20, 0x90, 0xb9, 0x77, 0x22, 0x9, 0x4d, 0x98, 0x4c, 0x34, 0x2, 0x58, 0x5c, 0x64, 0xac, 0xbc, 0xcd, 0x82, 0xfc, 0x45, 0x4e, 0xbc, 0xe8, 0x40, 0x72, 0x7d, 0xeb, 0xa9, 0x84, 0xd, 0xa, 0x32, 0x21, 0x85, 0xb8, 0xb4, 0x6, 0xa3, 0x59, 0x19, 0x56, 0x67, 0xeb, 0x8e, 0x4b, 0xb1, 0x7a, 0x3f, 0x77, 0x1, 0xce, 0xeb, 0xe7, 0x8c, 0x48, 0xae, 0x23, 0xa6, 0xba}, types.Tx{0x3e, 0xaf, 0x3c, 0x7d, 0xb1, 0x95, 0x6c, 0x7e, 0x3f, 0x9d, 0xe4, 0x8c, 0x6e, 0xb0, 0x25, 0xa5, 0xe, 0x7f, 0xa1, 0xb9, 0xa7, 0xcd, 0x8e, 0xa9, 0x9, 0x7e, 0x73, 0x73, 0xf9, 0xaf, 0x6c, 0xc8, 0x69, 0x12, 0x4e, 0xd6, 0xde, 0x68, 0x8c, 0x6a, 0x2}, types.Tx{0xbe, 0x16, 0xb4, 0xf7, 0x73, 0x64, 0x8b, 0xfe, 0xd2, 0xb, 0x6f, 0xfd, 0x7b, 0xe4, 0xb9, 0x66, 0xbe, 0xfd, 0x1d, 0x51, 0xb4, 0x3e, 0xe5, 0xef, 0x31, 0xd6, 0xad, 0xf0, 0xcd, 0x87, 0x16, 0x8, 0x20, 0x9f, 0x24, 0x1a, 0xc7, 0xaf, 0x8e, 0x16, 0x2, 0x9b, 0xbc, 0xca, 0x37, 0x7c, 0x27, 0x5a, 0x6b, 0x82, 0xcc, 0xec, 0xdb, 0x89, 0x77, 0xdd, 0x69, 0x3c, 0xff, 0x6c, 0x83, 0x4d, 0x3f, 0x95, 0xc, 0x3f, 0x8, 0x90, 0xd2, 0x30, 0x51, 0xa0, 0x51, 0x11, 0xdf, 0xdc, 0xf7, 0x60, 0xf1, 0x49, 0x22, 0xaf, 0xbb, 0x6, 0x6e, 0x80}, types.Tx{0xfb, 0x68, 0x14, 0x98, 0xaa, 0x70, 0x8b, 0x29, 0x44, 0xa5, 0x11, 0xb, 0x1f, 0xd8, 0x6e, 0xe6, 0x77, 0xb0, 0x37, 0x7d, 0x74, 0x13, 0xaf, 0x69, 0x9c, 0x12, 0x6e, 0xc2, 0x9b, 0xd2, 0x48, 0x3c, 0x55, 0xbe}, types.Tx{0xf4, 0x3a, 0x94, 0x97, 0xdc, 0x8c, 0xaa, 0x4f, 0x33, 0xdf, 0xdc, 0xe4, 0x15, 0xac, 0x7d, 0xf7, 0x67, 0xd5, 0xe6, 0xbb, 0xac, 0xa0, 0xbf, 0xff, 0x2b, 0xf9, 0xb2, 0xb2, 0x9c, 0xb4, 0xd5, 0xc1, 0x9a, 0xf1, 0x7e, 0x10, 0x92, 0xb5, 0x61, 0x21, 0x30, 0x4b, 0xd1, 0x5b, 0x17, 0x28, 0xf1, 0x1b, 0x7, 0x99, 0xd8, 0xd, 0xe4, 0x82, 0xd3, 0xe3, 0x44, 0x8d, 0x1e, 0xf, 0x67, 0x87, 0xce, 0xe2, 0xc3, 0x5f, 0x7b, 0xf, 0x58, 0x6e, 0x57, 0x7a, 0x6, 0xc9, 0x95, 0xc7, 0x5c, 0x6a, 0x86, 0x64, 0xaa}, types.Tx{0x59, 0x25, 0xdd, 0xaf, 0x84, 0x23, 0x19, 0xe3, 0x1f, 0xf9, 0xec, 0xed, 0xac, 0xb4, 0x44, 0x69, 0xa8, 0x75, 0x9, 0x9f, 0x15, 0xcc, 0x31, 0x6, 0x87, 0x8a, 0x18, 0x6a, 0x87, 0x8f, 0xc0, 0x28, 0x62, 0x22, 0x12, 0x60, 0x30, 0x52, 0x5f, 0xa8, 0x8e, 0x3f, 0xb6, 0xa5, 0x84, 0xaf, 0x89, 0xdd, 0x2d, 0xf, 0xea, 0xa5, 0x49, 0x43, 0xb2, 0x35, 0xc9, 0xd4, 0xaa, 0xe3, 0x26, 0xa1, 0x2c, 0x8, 0x17, 0x25, 0xa8, 0x6c, 0xae, 0xa9, 0xfa, 0x7e, 0x94, 0xdb, 0x73, 0x85, 0x90, 0xc2, 0x4c, 0x55, 0x84, 0x4d, 0x4e, 0x7e, 0xf7, 0xa8, 0x29, 0x78, 0x6b, 0x24, 0x9f, 0x7, 0x15, 0x7b, 0xc0, 0x5a, 0xc4}, types.Tx{0x65, 0xfd, 0x40, 0x41, 0x62, 0xff, 0x51, 0x21, 0x82, 0xd3, 0x5, 0x6a, 0xb5, 0x81, 0x9c, 0xc9, 0x3b, 0xc9}, types.Tx{0xa3, 0xb2, 0x55, 0x24, 0xb, 0x13, 0x3c, 0x83, 0x1e, 0x98, 0x1e, 0x98, 0x3b, 0x99, 0x5f, 0x58, 0x92, 0x77, 0x6a, 0x4d, 0xdb, 0x1d, 0x1b, 0xcf, 0x78, 0x9c, 0x56, 0x53, 0x64, 0x3, 0xa3, 0xc5, 0xeb, 0x60, 0xbd, 0xf0, 0x2, 0x5, 0xc4, 0x21, 0x8, 0xe5, 0x5c}, types.Tx{0x30, 0x9c, 0x52, 0x32, 0x79, 0xb6, 0x52, 0xaf, 0x3c, 0x8, 0x4a, 0xfe, 0xce, 0xc1, 0xe1, 0x8c, 0x1c, 0xdd, 0xaa, 0xf6, 0x1a, 0x41, 0x9c, 0xf3, 0x17, 0xe4, 0xa2, 0xfb, 0x50, 0x7e, 0xb0, 0x8e, 0xae, 0x21, 0x19, 0x58, 0xe1, 0x4c, 0x1e, 0x72, 0xbf, 0x15, 0x1, 0x4e, 0x15, 0xea, 0x38, 0x73, 0x81, 0x11, 0x77, 0x4c, 0xd, 0x8, 0xf2, 0x51, 0xc6, 0x90, 0xea, 0x83, 0x8f, 0x32, 0xb7, 0x8f, 0xfb, 0x7d, 0xfa, 0x30, 0xf3, 0x6a, 0x75, 0x65, 0xed, 0x93}, types.Tx{0xaf, 0x4b, 0x45, 0x5f, 0x75, 0x78, 0xbc, 0xc6, 0xca, 0x33, 0x6f, 0x6, 0x91, 0x87, 0x9d, 0xdc, 0x1c, 0xb3, 0x85, 0x63, 0x8d, 0x9d, 0x49, 0xd2, 0x23, 0x6b, 0x7a, 0x67, 0xc8, 0xa1}, types.Tx{0xa0, 0x79, 0xef, 0x17, 0xc4, 0x14, 0xd4, 0xd7, 0xd, 0xb8, 0xa2, 0x84, 0xfb, 0xdb, 0x29, 0x74, 0x87, 0x79, 0x3a, 0x82, 0x26, 0xb9, 0x6a, 0xbe, 0x53, 0xaa, 0x9c, 0xcc, 0x1b, 0x48, 0x96, 0xbf, 0x6b, 0xf0, 0x5c, 0xb3, 0xb3, 0xdf, 0xcf, 0xfc, 0x64, 0xe7, 0x5}, types.Tx{0xab, 0x94, 0xe3, 0x92, 0x2, 0xa0, 0x5a, 0x61, 0xa2, 0x90, 0x2e, 0x51, 0x72, 0x30, 0x1e, 0x2e, 0x58, 0x8, 0xa8, 0x76, 0x25, 0x85, 0x1a, 0xc9, 0xc0, 0x68, 0xe4, 0xd8, 0xd7, 0x8b, 0xa7, 0xa, 0xc3, 0xd7, 0x7a, 0x30, 0x49, 0x3c, 0x2d, 0x1a, 0xb0, 0x67, 0x18, 0xa8, 0x71, 0x78, 0x7c, 0xaf, 0xea, 0x1d, 0xb, 0x94, 0x7e, 0x46, 0xdf, 0x19, 0x4f, 0x67, 0x5d, 0x36, 0x12, 0xc1, 0x2c, 0xb5, 0x57, 0x8b, 0x1a, 0x36, 0xd8, 0xaf, 0xc, 0x20, 0x80, 0x46, 0xb0}, types.Tx{0x27, 0xd1, 0x44, 0x73}, types.Tx{0x39, 0x10, 0xff, 0x61, 0x66, 0x6a, 0xc1, 0x2a, 0xe1, 0x13, 0xd, 0x7, 0xea, 0x21, 0x45, 0xf7, 0xa9, 0x34, 0xa, 0x63, 0x8d, 0x99, 0x7c, 0xc9, 0x1d, 0x2c, 0xaa, 0xec, 0x62, 0x14, 0x1d, 0xa4, 0x92, 0xeb, 0xa9, 0x2b, 0x9a, 0xa0, 0x69, 0x8e, 0x17, 0x55, 0x21, 0x41, 0x3a, 0x3c, 0x3d, 0x59, 0x18, 0x58, 0x62, 0x3f, 0xc4, 0xa5, 0xa2, 0x21, 0xb8, 0x89, 0xe8, 0x51, 0x3, 0xf2, 0x47, 0xf7, 0x2b, 0x7d, 0x10, 0x6d, 0xe2, 0xce, 0x1e, 0x3f, 0x98, 0x88, 0xf3, 0x37, 0x13, 0x4a, 0x43, 0x63, 0x6f, 0x7d, 0x22, 0x6c}, types.Tx{0x1f, 0x1, 0x94, 0x99, 0x3a, 0xaf, 0xbc, 0xa3, 0x8b, 0x84, 0x20, 0x1c, 0xa, 0xfa, 0xfe, 0x83, 0xb3, 0x81, 0xaa, 0x39, 0x66, 0x64, 0x3d, 0xf3, 0x38, 0xe3, 0xad, 0x46, 0x57, 0xbd, 0xe7, 0x8a, 0x47, 0x7d, 0x1a, 0x4f, 0x8f, 0x22, 0x53, 0x64, 0xa9, 0xf0, 0xdd, 0x48, 0x19, 0xb7, 0x38, 0x68, 0x8d, 0x44}, types.Tx{0xd8, 0x5f, 0xc2, 0xda, 0x53, 0xec, 0x4b, 0xb3, 0xf8, 0x16, 0xd5}, types.Tx{0x9a, 0x8c, 0xd, 0x43, 0x8f}, types.Tx{0xcf, 0x9c, 0x7a, 0xf, 0xbe, 0xb0, 0x15}, types.Tx{0x5b, 0x2a, 0xf4, 0x7f, 0xe8, 0xf, 0x43, 0xe8, 0xaa, 0x9d, 0xc9, 0xa7, 0x9e, 0x8f, 0xa5, 0x63, 0x49, 0xd8, 0x55, 0xa3, 0x81, 0xca, 0xc8, 0x63, 0x79, 0x9a, 0x82}, types.Tx{0xff, 0x89, 0xd1, 0xa4, 0x49, 0xf4, 0xfe, 0xbd, 0xa2, 0x22, 0x5b, 0x2, 0x58, 0xad, 0x14, 0x12, 0x51, 0x41, 0x13, 0x4e, 0xe5, 0xf6, 0xb4, 0xe4, 0x1f, 0x9a, 0x1b, 0xe, 0x2f, 0x68, 0x2c, 0x73, 0x63, 0xff, 0x89}, types.Tx{0x8c, 0x1e, 0x5d, 0xf7, 0xf0, 0x36, 0x36, 0x9a, 0x3b, 0xb3, 0xc5, 0xe6, 0x7d, 0x74, 0xed, 0x8c, 0x42, 0x37, 0xc1, 0x8, 0xe7, 0x93, 0x79, 0xd2, 0x67, 0xd9, 0xfb, 0x2b, 0xcd, 0xb8, 0xa5, 0x69, 0x9f}, types.Tx{0x68}, types.Tx{0x1e, 0xb1, 0x9f, 0x5a, 0x6f, 0xff, 0x5a, 0xd9, 0xc2, 0x23, 0x1d, 0xb4, 0xff, 0x78, 0x36, 0xe1, 0x4b, 0xa8, 0x4b, 0xe1, 0x66, 0x8c, 0xf9, 0x74, 0x98, 0xb1, 0xd2, 0x72, 0x67, 0x79, 0xdb, 0xb6, 0xcc, 0x27, 0xcc, 0xa0, 0x6a, 0xd4, 0x7d, 0xb1, 0xaa, 0x35, 0xb2, 0x25, 0x45, 0x5e, 0x8d, 0x9f, 0xbf, 0xfb, 0xb0}, types.Tx{0x95, 0xe6, 0x32, 0x9f, 0xda, 0xa1, 0xf2, 0xe3, 0x68, 0x30, 0xb9, 0xd8, 0x81, 0xc1, 0xb7, 0x88, 0xd6, 0x8e, 0x5a, 0xab, 0x4f, 0x1d, 0xef, 0xd9, 0xdc, 0x69, 0x6a, 0x3f, 0xfd, 0x7e, 0x6f, 0x26, 0xda, 0x13, 0x86, 0x41, 0xaa, 0x85, 0xa8, 0xae, 0x2f, 0xc1, 0x1, 0xb0, 0xf4, 0x85, 0x80, 0x71, 0x97, 0x93, 0xf5, 0xdc, 0x3a, 0xcf, 0xea, 0x71, 0xff, 0xa9, 0x34, 0x36, 0x6f, 0x5, 0x14, 0xe0, 0x13, 0x9f, 0x6, 0xf3, 0x83, 0xee, 0x6c, 0x7, 0x20, 0xd0, 0xe1, 0x64, 0xf9, 0xb0, 0xa8, 0x37, 0xab, 0x7a, 0xcd, 0xa1, 0x3e, 0x34, 0x4, 0x3c, 0x93, 0x0, 0x57, 0xe4, 0x3b}, types.Tx{0x56, 0xed, 0xa7, 0x16, 0xdf, 0x6f, 0xe, 0x89, 0x8d, 0x28, 0xf6, 0x21, 0x54}, types.Tx{0x2d, 0x2e, 0xc7, 0x14, 0x1e, 0x28, 0x53, 0xd9, 0xd, 0xed, 0xa1, 0x49, 0xf5, 0xc8, 0x48, 0x2a, 0x57, 0x4, 0x9c, 0x2f, 0x6f, 0x76, 0x3, 0xc4, 0xad, 0x71, 0xb3, 0x2, 0xf, 0x65, 0x43, 0xcb, 0x9f}, types.Tx{0xed, 0x6c, 0x42, 0xb3, 0xb9}, types.Tx{0xa5, 0x73, 0x4e, 0xe9, 0x9d, 0x8c, 0x5e, 0x39, 0x26, 0xac, 0xff, 0x1d, 0x80, 0x7f, 0xf3, 0xdc, 0x72, 0x3b, 0xe7, 0x18, 0xcd, 0x65, 0x5f, 0x74, 0x5d, 0xc2, 0xc9, 0x35, 0x39, 0xb1, 0xcd, 0x75, 0x58, 0x9f, 0x23, 0xf4, 0x1d, 0x84, 0x7d, 0x3c, 0xee, 0x54, 0xde, 0x36, 0x88, 0x94, 0x7c, 0xd3, 0x65, 0x41, 0x7e, 0x5f, 0x2b, 0x61, 0xe6, 0xc3, 0x17, 0xdb, 0xda, 0xe8, 0xa1, 0xbe, 0x2b, 0x17, 0x2b, 0x25, 0x63, 0x45, 0xea, 0x2f, 0xb9, 0x3e, 0x9e, 0x1a, 0x71, 0x3a, 0x2c, 0xf7, 0x44, 0x33, 0xcf, 0x34}, types.Tx{0x1f, 0xed, 0xbf, 0x8, 0xa, 0x61, 0xb3, 0xca, 0xfc, 0x17, 0x85, 0xce, 0x8a, 0xa5, 0x93, 0x9a, 0x2d, 0x41, 0xb, 0x40, 0xde, 0x21, 0xca, 0x83, 0xc4, 0x19, 0xaf, 0xfb, 0x45, 0x40, 0xfe, 0xe9, 0xcb, 0xd8, 0x75, 0xda, 0xad, 0x25, 0x91, 0xdb, 0xa1, 0x97, 0xe6, 0x71, 0xaf, 0x1f, 0x3b, 0xf6, 0x34, 0xb2, 0xc, 0xa, 0xc1, 0x8b, 0x1e, 0x13, 0x28, 0xba, 0xa2, 0x34, 0x7, 0x4c, 0x55, 0x6a, 0x60, 0x3a, 0x0, 0xe1, 0x5, 0x45, 0xf0, 0x39, 0xfd, 0x4c, 0xaf, 0x33, 0x1c, 0xe3, 0xef, 0x91, 0x46, 0x97, 0xd5, 0x3a, 0x25, 0x79, 0x76, 0xe}, types.Tx{0x1c}, types.Tx{0xf6, 0x70, 0xde, 0xa7, 0x22, 0x19, 0x55, 0x66, 0xb7, 0xd7, 0x9d, 0x77, 0xbf, 0x97, 0xfc, 0x2c, 0x86, 0x46, 0xbc, 0x66, 0xa9, 0x69, 0x42, 0x8b, 0x1c, 0xe6, 0x8c, 0x2f, 0x49, 0x48, 0xe, 0xfd, 0x2c, 0x65, 0x36, 0x23, 0x7c, 0x3e, 0x18, 0x79, 0x15, 0x4c, 0x41, 0xf4, 0x88, 0x64, 0x32, 0x20, 0x44, 0x62, 0x1c, 0x18, 0x9a, 0xcf, 0x58, 0x72, 0xbb, 0xfa, 0xf3, 0xcd, 0xc4, 0xc8, 0x13, 0xc4, 0xb, 0xa2, 0xf2, 0x63, 0x2a, 0xb6, 0x90, 0x15, 0xbb, 0x57, 0x4a, 0x24, 0xc9, 0x8a, 0x48, 0xb3, 0x18, 0xa2, 0xb2, 0x42, 0xd8, 0x45, 0x18, 0x1f, 0x33, 0xcb, 0x10, 0x61, 0x2b, 0x72}, types.Tx{0x8f, 0x7c, 0x67, 0x99, 0xd0, 0x75, 0x22, 0xaf, 0xe8, 0xac, 0x43, 0xdc, 0xef, 0x7f, 0x5f, 0xda, 0xf4, 0xc1, 0x6e, 0x88, 0x11, 0x0, 0x60, 0x2e, 0x21, 0x21, 0xb8, 0xc, 0xaf, 0x67, 0x7a, 0x17, 0x1, 0xb, 0xdb, 0x34, 0x1d, 0xc5, 0xc8, 0x4c, 0x28, 0x6c, 0x81, 0x40}, types.Tx{0x23, 0x63, 0x63, 0x24, 0x1c, 0x0, 0x52, 0xd7, 0x65, 0x5, 0x26, 0x10, 0x4d, 0xf9, 0x9d, 0x78, 0x78, 0x82, 0xa9, 0xc8, 0x39, 0xe7, 0xfc, 0x98, 0x3c, 0x3b, 0x47, 0x64, 0x10, 0xf1, 0xb2, 0x75}, types.Tx{0xe0, 0x75, 0x9f, 0xb7, 0xeb, 0x80, 0xfe, 0x73, 0x1f, 0x15, 0x96, 0x3d, 0xbc, 0xcc, 0x22, 0xa5, 0xa1, 0xd0, 0x89, 0x79, 0x3a, 0x48, 0x6b, 0xce, 0x8, 0xf, 0x39, 0x8c, 0x23, 0x9e, 0xe5, 0xa7, 0xa0, 0xb7, 0x29, 0x99, 0xc3, 0x76, 0x9b, 0x6e, 0xd, 0xcc, 0x4d, 0xbe, 0xeb, 0xd7}, types.Tx{0x8a, 0x28, 0x6, 0x80, 0x6e, 0xb0, 0xd, 0x20, 0x4c, 0xfd, 0x63, 0x58, 0x95, 0x59, 0x9, 0x7c, 0x61, 0xb0, 0x40, 0xd2, 0x2b, 0x7f, 0xc4, 0x78, 0x27, 0xbd, 0xd5, 0xe6, 0xf7, 0x9f, 0x0, 0x14, 0x19, 0x54, 0xab, 0x8d, 0x71, 0x0, 0xe5, 0x41, 0xfa, 0x8b, 0x2e, 0x7b, 0x25, 0x5a, 0xef, 0xd5, 0x63, 0xf0, 0x69, 0xe8, 0x68, 0x60, 0x6d, 0xaf, 0x63, 0xbd, 0x87, 0xab, 0xc2, 0x28, 0xeb, 0xc9, 0x60, 0xbf, 0xd, 0xcf, 0x17, 0xe9, 0xdb, 0x22, 0xc2, 0x39, 0x86, 0x81, 0xc1, 0xd6, 0xe6, 0xb7}, types.Tx{0x95, 0x61, 0x39, 0xe3, 0xce, 0x33, 0x77, 0x21, 0x3, 0x61, 0x5c, 0x74, 0x64, 0xb, 0xa1, 0xe4, 0x37, 0x15, 0x88, 0x8c, 0x7d, 0x88, 0x12, 0x24, 0x65, 0x19, 0x29, 0xb8, 0x55, 0x91, 0x36, 0x3a, 0x10, 0xfc, 0xad, 0xcd, 0xe3, 0x7f, 0xcf, 0xc0, 0x9d, 0xec, 0xfb, 0x85, 0x15, 0xaf, 0x57, 0x6b, 0x81, 0xb1, 0x88, 0x69, 0xfc, 0x6d, 0x66, 0x10, 0x25, 0xd1, 0x3a, 0xbe, 0x45, 0xed, 0xbe, 0x66, 0x8b, 0x7e, 0xe5, 0xdf, 0x95, 0x5b, 0xeb, 0x29, 0x67, 0xa5, 0xf7, 0xc4, 0xf9, 0x9f, 0xe0, 0x58, 0x0, 0x84, 0xe1, 0xe, 0x24, 0x75, 0xc3, 0xb0, 0xe4, 0x92, 0x6c, 0xb2, 0xba, 0xd4, 0xd7, 0xb1, 0x7e, 0x88}, types.Tx{0xee, 0x66, 0x8f, 0x38, 0x6b, 0x1c, 0x4c, 0xa1, 0x6b, 0xce, 0x62, 0xa9, 0xcf, 0x1d, 0xfb, 0xb, 0x2e, 0x56, 0x11, 0x1f, 0xb5, 0xd8, 0xcc, 0x61, 0xd0, 0x93, 0x4a, 0xca, 0xe8, 0x84, 0x1f, 0x5e, 0x5a, 0xcf, 0x28, 0xec, 0xc2, 0x3b, 0xd6, 0x3d, 0x4b, 0x64, 0xda, 0x50}, types.Tx{0x79, 0xba, 0x41, 0x38, 0x3a, 0xed, 0xbb, 0xc7}, types.Tx{0xf6, 0xfa, 0xa9, 0xa5, 0x15, 0xe9, 0x9d, 0xc0}, types.Tx{0xe5, 0x7a, 0x9b, 0x9e, 0x21, 0xed, 0x78, 0xdf, 0xda, 0xf8, 0x74, 0x42, 0x32, 0x61, 0xa0, 0x5b, 0x88, 0x1f, 0x4d, 0xf4, 0x7f, 0x66, 0xc5, 0x85, 0x95, 0xa5, 0xd4, 0x7e, 0xae, 0x6d, 0x98, 0x8b, 0x2f, 0xed, 0x19, 0x42, 0x6b, 0x70, 0xa4, 0x36, 0x97, 0x78, 0x23, 0x66, 0x93, 0xba, 0x1b, 0x5e, 0x2b, 0x39, 0x2, 0x4c, 0xd9, 0x16, 0x9c, 0x77, 0x54, 0x0, 0x1, 0x3b, 0x90, 0xdd, 0xe7, 0xe8, 0x31, 0x75, 0xe7, 0x93, 0x8a, 0x46, 0xab, 0xe, 0xd2, 0x8e, 0xae, 0xa7, 0x96, 0xcd}, types.Tx{0x62, 0x7d, 0xe0, 0x31, 0xcf, 0x24, 0x8, 0x65, 0xc3, 0xd2, 0xe4, 0x60, 0x4, 0x9, 0x52, 0x3b, 0x63, 0x9d, 0xb3, 0xb9, 0x7d, 0x2e, 0xd0, 0x26, 0x44, 0xb9, 0x2b, 0xb2, 0x32, 0x12, 0x7f, 0xbf, 0x84}, types.Tx{0xf6, 0x4f, 0xde, 0xa2, 0xb7, 0x39, 0x56, 0xd0, 0x5e, 0x78, 0xcc, 0xa1, 0xd8, 0x79, 0x9e, 0xb5, 0x4d, 0x6, 0x1c, 0x89, 0x9b, 0x6b, 0x75, 0x4c, 0xe9, 0x29, 0xaa, 0x9, 0xa2, 0x3e, 0xa6, 0x84, 0x69, 0x37, 0xfd, 0x2f, 0x2b, 0xfe, 0xab, 0x3f, 0xf7, 0x64, 0xbd, 0xe, 0x67, 0x5f, 0x30, 0xca, 0xfc, 0x9a, 0xc6, 0xe3, 0x5b, 0x87, 0xb1, 0xf5, 0x64, 0x3e, 0x70, 0x97, 0xc7, 0xf4, 0xaf, 0x35, 0x5e, 0x79, 0x82, 0xc2, 0xfa, 0x77, 0x5f, 0xa1, 0x12, 0xc1, 0xf6, 0x40, 0xa9, 0x7b, 0x19, 0x6c}, types.Tx{0x11, 0x9a, 0xd0, 0x60, 0x69, 0x94, 0xfb, 0x3f, 0x2a, 0x42, 0xf0, 0x9e, 0xb3, 0x3e, 0x8e, 0x1f, 0xd6, 0xbe, 0x3d, 0x72, 0x5e, 0x88, 0x80, 0x66, 0x86, 0x94, 0xfd, 0x87, 0xc1, 0x86, 0x2e, 0xfb, 0x16, 0x7, 0x44, 0xdc, 0x98, 0x98, 0x94, 0x49, 0x1e, 0x32, 0x30, 0x85, 0xf7, 0x70, 0xa1, 0x33, 0x66, 0x69, 0x6, 0xb4, 0xe8, 0xc7, 0x79, 0xf6, 0x1e, 0x3e, 0x7d, 0xe1, 0xe7, 0x5b, 0x77, 0x36}, types.Tx{0x3, 0xe5, 0x80, 0x16, 0x15, 0x20, 0x9a, 0xfa, 0x4d, 0xfd, 0x37, 0x68, 0xd2, 0x3c, 0x58, 0x84, 0x8, 0xd}, types.Tx{0xd, 0x27, 0xad}, types.Tx{0x75, 0x6f, 0xf4, 0xbb, 0xa3, 0x4, 0xe0, 0x72, 0x1, 0x4, 0x21, 0xbc, 0x4a, 0xf1, 0x82, 0x7d, 0xc6, 0xb1, 0x5c, 0xae, 0xdd, 0x7f, 0x65, 0xec, 0x1e, 0xf, 0x48, 0xe8, 0xf, 0x0, 0x7b, 0x42, 0xfb, 0x5, 0xba, 0x71, 0x46, 0xd8, 0x81, 0x6, 0x58, 0x46, 0x31, 0xeb, 0x48, 0x7c, 0x7d, 0xe4, 0x35, 0xaa, 0xdd, 0xde, 0xfe, 0x88, 0xc, 0xb5, 0x7a, 0xd5, 0x49, 0xd4, 0x6c, 0x77, 0xbf, 0x8, 0xbd, 0xa7, 0xef, 0x83, 0x9a, 0xf9, 0x18, 0xdd, 0xb6, 0xe5, 0x27, 0xe9, 0x3, 0xeb, 0x37, 0x95, 0xf2, 0x53, 0xa8, 0x80, 0x3c, 0x18, 0x33, 0xdf, 0xed}, types.Tx{0x34, 0x16, 0xfd, 0xe7, 0x6c, 0xef, 0xc5, 0xbd, 0xf1, 0x5, 0x90, 0xde, 0x59, 0x3b, 0x57, 0x2e, 0x7e, 0xaf, 0x21, 0x32, 0x43, 0xc5, 0x13, 0x26, 0xe7, 0x30, 0xb1, 0x92, 0xcf, 0x9a, 0xd9, 0xb2, 0xc, 0x2a, 0x2, 0x44, 0xf6, 0xf1, 0xed, 0xaa, 0xa, 0xb9, 0x9, 0xa0, 0x4c, 0xbb, 0xa1, 0xda, 0xdc, 0x80, 0xc5, 0x74, 0x57, 0xf8, 0xd, 0xb6, 0xdd, 0xc4, 0x19, 0xad, 0xe4, 0xf9, 0xef, 0x4b, 0xc3, 0xe6, 0xb, 0x45, 0xc0, 0x2b, 0xd4, 0x59, 0x24, 0x8c, 0x2b, 0x8e, 0xef, 0x57, 0x73, 0x74, 0xeb, 0xf2, 0xb3, 0x7c, 0x5d, 0xe4, 0x55, 0x82, 0x32, 0xd8, 0x4f, 0x68, 0xb5, 0xb8, 0x7e}, types.Tx{0xbf, 0x1f, 0x24, 0x7b, 0x40, 0xbe, 0x6e, 0x99, 0x9d, 0x4d, 0x12, 0xad, 0xe7, 0x95, 0x54, 0x6c, 0xea, 0xe0, 0x52, 0xcc, 0xc4, 0x6b, 0x62, 0x4f, 0xb3, 0x25, 0x32, 0x50, 0x9a, 0x3e, 0x7d, 0x7, 0x78, 0xb3, 0xf3, 0x8f, 0x25, 0xfb, 0x1b, 0xea, 0x74, 0xa, 0xf1, 0x9f, 0xd1, 0x87, 0xab, 0x69, 0x50, 0x9e, 0x66, 0xbe, 0x9d, 0xd9, 0x9a, 0x33, 0x4b, 0xad, 0x39, 0xb4, 0x58, 0xb8, 0xac, 0xdd, 0x21, 0xfa, 0x84, 0x42, 0x6c, 0x8e, 0x86, 0x3a, 0xad, 0x49}, types.Tx{0xc8, 0x3b, 0x44, 0xfc, 0xd6, 0xf7, 0x18, 0xd5, 0x79, 0xf1, 0x8a, 0x9b, 0xf7, 0x8b, 0x66, 0xea, 0xfb, 0x2d, 0x9d, 0xcc, 0x6, 0x18, 0x2e, 0x5e, 0xd8, 0xe4, 0xb0, 0x2a, 0x38, 0xe7, 0xc6, 0x52, 0xe6, 0x56, 0x8d, 0x29, 0x9a, 0x66, 0x85, 0x4b, 0xac, 0xf7, 0x9a, 0x91, 0xdd, 0x16, 0x2b, 0xc1, 0xe8, 0xff, 0x17, 0x75, 0x11, 0xc3, 0x95, 0xac, 0xf3, 0x8, 0xa1, 0xb4, 0xf4, 0xa0, 0xe4, 0x7, 0xe8, 0xfc, 0x1, 0x3c, 0x4c, 0x22, 0x62, 0xe2, 0x60, 0xa2, 0x87, 0xbf, 0x91, 0x9f, 0x3b, 0x40, 0xb1, 0x92, 0x90, 0x1a, 0xc6, 0x88, 0x62, 0x6a, 0xe5, 0x62, 0xb, 0x7e, 0xbf, 0xe2, 0x7, 0x45}, types.Tx{0x13, 0x32, 0x54, 0xf4, 0xd7, 0xb5, 0x7e, 0xcb, 0x18, 0xe7, 0xb, 0x1d, 0xcc, 0x2a}, types.Tx{0xa2, 0xf9, 0x67, 0x36, 0x24, 0xd, 0x38, 0xbd, 0xa2, 0xec, 0x85, 0x4e, 0x7a, 0x8f, 0x71, 0x87, 0xae, 0x30, 0xdf, 0x2a, 0x14, 0xbc, 0x82, 0xe8, 0x4d, 0xf0, 0x3c, 0x11, 0x78, 0xdc, 0xe0, 0x18, 0xfb, 0x92, 0xa4, 0x83, 0x44, 0xdf, 0x3f, 0x74, 0x62, 0x3, 0xa1, 0xa9, 0xa, 0x56, 0x0, 0x53, 0xdd, 0x5e, 0xda, 0xb, 0xd1, 0xc0, 0xf5, 0x61, 0x6a, 0xb6, 0x56, 0xcd, 0xba, 0xb8, 0x49, 0x94, 0x12, 0xc7, 0xd5, 0x41, 0x58, 0x4f, 0xa1, 0xdc, 0x66, 0x39, 0x45, 0x59, 0xf3, 0x19, 0xe4, 0x6e, 0xed, 0x94, 0x29, 0x3e, 0xa6, 0x54, 0x13, 0x48}, types.Tx{0xd9, 0x10, 0xa, 0xe8, 0xf2, 0x87, 0x55, 0x48, 0x7a, 0x57, 0xb6, 0xed, 0xcd, 0x95, 0x7b, 0xbc, 0xa9, 0xdb, 0xb5, 0xf0, 0xa2, 0x57, 0xc1, 0x7c, 0xe, 0xae, 0xfc, 0x42, 0x57, 0x27, 0x67, 0x62, 0xea, 0x3, 0xd9, 0xf4, 0x54, 0xb9, 0xa6, 0x31, 0xfe, 0x5c, 0x7e, 0x9, 0x6a, 0x77, 0x63, 0x31, 0x32, 0x28, 0x5e, 0xe8, 0xb1, 0xae, 0x3c, 0xec, 0xbb, 0x3, 0x9a, 0x37, 0xd0, 0xa0, 0xd5, 0xbc}, types.Tx{0x3a, 0x78, 0x94, 0x54, 0xf2, 0x91, 0x5e, 0x4d, 0xa3, 0x6d, 0x92, 0xa2, 0xfc, 0x7c, 0x54, 0x90, 0x62, 0xb9, 0x57, 0xd5, 0x12, 0x2, 0x7c, 0x40, 0xa4, 0x79, 0xc7, 0x2e, 0x75, 0xaa, 0x38, 0x8e, 0xec, 0xed, 0xbd, 0x12, 0x76, 0xe, 0x28, 0x2e, 0x7b, 0x17, 0xae, 0xbb, 0xbc, 0xff, 0x4d, 0x36, 0x97, 0xd9, 0x16, 0x9d, 0xaa, 0xc6, 0xcd, 0x7, 0x27, 0xc4, 0x6a, 0x4d, 0x7f, 0xc0, 0xe5, 0x97, 0xad, 0x5d}, types.Tx{0x9f, 0xf1, 0x8a, 0x32, 0xfd, 0x76, 0x23, 0x87, 0x9d, 0xa5, 0x93, 0xc0, 0xcc, 0x7d, 0xa2, 0x39, 0xc0, 0x2b, 0x56}, types.Tx{0x9f, 0x64, 0x3, 0xbe, 0xd0, 0x2b, 0xca, 0x71, 0x2a, 0x66, 0x29, 0x19, 0x44, 0xb5, 0x40, 0x68, 0xac, 0x53, 0xee, 0x3e, 0x65, 0xdc, 0x52, 0xb3, 0x4e, 0x64, 0x1f, 0x21, 0xf2, 0x72, 0xe, 0xe6, 0xa0, 0x21, 0x99, 0x38, 0xf7, 0xfe, 0x53, 0xf8, 0xeb, 0x47, 0xc4, 0x26, 0xb5, 0x21, 0xfa, 0x88, 0x2c, 0x1d, 0xa1, 0x4d, 0xfd, 0x95, 0xda, 0x2d, 0xb4, 0x6d, 0x76, 0x8f, 0x91, 0x77, 0x53, 0x1c, 0x5a, 0x61, 0xf7, 0xd1, 0x6a, 0x66, 0xdd, 0x77, 0xf3, 0x8d, 0x2b, 0x5a, 0x48, 0x8f, 0x5e, 0x46, 0x3e, 0xeb, 0xad, 0xb4, 0x1c, 0xab, 0x5a, 0x1d}, types.Tx{0x5c, 0xf}, types.Tx{0x50, 0xc0, 0x92, 0x8, 0x46, 0xa8, 0x72, 0x39, 0x95, 0xa3, 0xbb, 0xf6, 0x95, 0x2f, 0x5f, 0x37, 0x50, 0x3d, 0x79, 0xa9, 0xc9, 0x8f, 0xef, 0xfb, 0x14, 0xf6, 0x48, 0xfd, 0x51, 0xff, 0xab, 0x15, 0x83, 0x8d, 0x69, 0xc1, 0x62, 0xc2, 0x84, 0xf4, 0xe5, 0xe3, 0x62, 0x47, 0x55, 0x2, 0x65, 0x61, 0x6f, 0x3d, 0xa0, 0x99, 0x74, 0x60, 0xac, 0x8f, 0x7, 0x71, 0x56, 0x63, 0xfe}, types.Tx{0x33, 0x14, 0xa1, 0x2d, 0x82, 0xac, 0x6, 0x85, 0xa6, 0x2d, 0x3, 0xd4, 0xe8, 0x84, 0x93, 0x48, 0xa8, 0xf0, 0x77, 0x6, 0x57, 0xc8, 0x93, 0xe7, 0xb5, 0xdb, 0xff, 0xcb, 0x89, 0xe6, 0x66, 0xd9, 0x96, 0x7d, 0xe3, 0xf1, 0x53, 0xde, 0x91, 0x54, 0x2d, 0xd2, 0xbf, 0xce, 0xe2, 0x77, 0x9, 0x3f, 0x1d, 0xe4, 0xb0, 0x3f, 0x5b, 0x71}} diff --git a/pkg/proof/querier.go b/pkg/proof/querier.go index f0cfd75184..d1eaea9459 100644 --- a/pkg/proof/querier.go +++ b/pkg/proof/querier.go @@ -20,7 +20,7 @@ const TxInclusionQueryPath = "txInclusionProof" // Querier defines the logic performed when the ABCI client using the Query // method with the custom prove.QueryPath. The index of the transaction being // proved must be appended to the path. The marshalled bytes of the transaction -// proof (tmproto.TxProof) are returned. +// proof (tmproto.ShareProof) are returned. // // example path for proving the third transaction in that block: // custom/txInclusionProof/3 @@ -46,17 +46,17 @@ func QueryTxInclusionProof(_ sdk.Context, path []string, req abci.RequestQuery) } // create and marshal the tx inclusion proof, which we return in the form of []byte - txProof, err := TxInclusion(appconsts.DefaultCodec(), data, uint64(index)) + shareProof, err := NewTxInclusionProof(appconsts.DefaultCodec(), data, uint64(index)) if err != nil { return nil, err } - pTxProof := txProof.ToProto() - rawTxProof, err := pTxProof.Marshal() + pShareProof := shareProof.ToProto() + rawShareProof, err := pShareProof.Marshal() if err != nil { return nil, err } - return rawTxProof, nil + return rawShareProof, nil } const ShareInclusionQueryPath = "shareInclusionProof" @@ -100,8 +100,8 @@ func QueryShareInclusionProof(_ sdk.Context, path []string, req abci.RequestQuer return nil, err } - // create and marshal the shares inclusion proof, which we return in the form of []byte - txProof, err := GenerateSharesInclusionProof( + // create and marshal the share inclusion proof, which we return in the form of []byte + shareProof, err := NewShareInclusionProof( rawShares, data.SquareSize, nID, @@ -111,13 +111,13 @@ func QueryShareInclusionProof(_ sdk.Context, path []string, req abci.RequestQuer if err != nil { return nil, err } - pTxProof := txProof.ToProto() - rawTxProof, err := pTxProof.Marshal() + pShareProof := shareProof.ToProto() + rawShareProof, err := pShareProof.Marshal() if err != nil { return nil, err } - return rawTxProof, nil + return rawShareProof, nil } // ParseNamespaceID validates the share range, checks if it only contains one namespace and returns diff --git a/pkg/shares/compact_shares_test.go b/pkg/shares/compact_shares_test.go index 0e380258d8..40184d93e6 100644 --- a/pkg/shares/compact_shares_test.go +++ b/pkg/shares/compact_shares_test.go @@ -13,16 +13,15 @@ import ( coretypes "github.com/tendermint/tendermint/types" ) -func TestCompactShareWriter(t *testing.T) { +func TestCompactShareSplitter(t *testing.T) { // note that this test is mainly for debugging purposes, the main round trip // tests occur in TestMerge and Test_processCompactShares - w := NewCompactShareSplitter(appconsts.TxNamespaceID, appconsts.ShareVersionZero) + css := NewCompactShareSplitter(appconsts.TxNamespaceID, appconsts.ShareVersionZero) txs := testfactory.GenerateRandomTxs(33, 200) for _, tx := range txs { - rawTx, _ := MarshalDelimitedTx(tx) - w.WriteBytes(rawTx) + css.WriteTx(tx) } - shares := w.Export() + shares, _ := css.Export(0) rawShares := ToBytes(shares) rawResTxs, err := parseCompactShares(rawShares, appconsts.SupportedShareVersions) resTxs := coretypes.ToTxs(rawResTxs) @@ -77,7 +76,7 @@ func Test_processCompactShares(t *testing.T) { t.Run(fmt.Sprintf("%s idendically sized", tc.name), func(t *testing.T) { txs := testfactory.GenerateRandomTxs(tc.txCount, tc.txSize) - shares, _ := SplitTxs(txs) + shares, _, _ := SplitTxs(txs) rawShares := ToBytes(shares) parsedTxs, err := parseCompactShares(rawShares, appconsts.SupportedShareVersions) @@ -95,8 +94,8 @@ func Test_processCompactShares(t *testing.T) { t.Run(fmt.Sprintf("%s randomly sized", tc.name), func(t *testing.T) { txs := testfactory.GenerateRandomlySizedTxs(tc.txCount, tc.txSize) - shares, _ := SplitTxs(txs) - rawShares := ToBytes(shares) + txShares, _, _ := SplitTxs(txs) + rawShares := ToBytes(txShares) parsedTxs, err := parseCompactShares(rawShares, appconsts.SupportedShareVersions) if err != nil { @@ -119,7 +118,7 @@ func TestCompactShareContainsInfoByte(t *testing.T) { css.WriteTx(tx) } - shares := css.Export() + shares, _ := css.Export(0) assert.Condition(t, func() bool { return len(shares) == 1 }) infoByte := shares[0][appconsts.NamespaceSize : appconsts.NamespaceSize+appconsts.ShareInfoBytes][0] @@ -139,7 +138,7 @@ func TestContiguousCompactShareContainsInfoByte(t *testing.T) { css.WriteTx(tx) } - shares := css.Export() + shares, _ := css.Export(0) assert.Condition(t, func() bool { return len(shares) > 1 }) infoByte := shares[1][appconsts.NamespaceSize : appconsts.NamespaceSize+appconsts.ShareInfoBytes][0] @@ -158,8 +157,8 @@ func Test_parseCompactSharesErrors(t *testing.T) { } txs := testfactory.GenerateRandomTxs(2, appconsts.ContinuationCompactShareContentSize*4) - shares, _ := SplitTxs(txs) - rawShares := ToBytes(shares) + txShares, _, _ := SplitTxs(txs) + rawShares := ToBytes(txShares) unsupportedShareVersion := 5 infoByte, _ := NewInfoByte(uint8(unsupportedShareVersion), true) diff --git a/pkg/shares/share_merging_test.go b/pkg/shares/share_merging_test.go index e7e76c2e01..ba94f9853e 100644 --- a/pkg/shares/share_merging_test.go +++ b/pkg/shares/share_merging_test.go @@ -27,9 +27,9 @@ func TestParseShares(t *testing.T) { blobOneNamespace := namespace.ID{1, 1, 1, 1, 1, 1, 1, 1} blobTwoNamespace := namespace.ID{2, 2, 2, 2, 2, 2, 2, 2} - transactionShares, _ := SplitTxs(generateRandomTxs(2, 1000)) - transactionShareStart := transactionShares[0] - transactionShareContinuation := transactionShares[1] + txShares, _, _ := SplitTxs(generateRandomTxs(2, 1000)) + txShareStart := txShares[0] + txShareContinuation := txShares[1] blobOneShares, err := SplitBlobs(0, []uint32{}, []types.Blob{generateRandomBlobWithNamespace(blobOneNamespace, 1000)}, false) if err != nil { @@ -63,14 +63,14 @@ func TestParseShares(t *testing.T) { }, { "one transaction share", - [][]byte{transactionShareStart}, - []ShareSequence{{NamespaceID: appconsts.TxNamespaceID, Shares: []Share{transactionShareStart}}}, + [][]byte{txShareStart}, + []ShareSequence{{NamespaceID: appconsts.TxNamespaceID, Shares: []Share{txShareStart}}}, false, }, { "two transaction shares", - [][]byte{transactionShareStart, transactionShareContinuation}, - []ShareSequence{{NamespaceID: appconsts.TxNamespaceID, Shares: []Share{transactionShareStart, transactionShareContinuation}}}, + [][]byte{txShareStart, txShareContinuation}, + []ShareSequence{{NamespaceID: appconsts.TxNamespaceID, Shares: []Share{txShareStart, txShareContinuation}}}, false, }, { @@ -96,18 +96,18 @@ func TestParseShares(t *testing.T) { }, { "one transaction, one blob", - [][]byte{transactionShareStart, blobOneStart}, + [][]byte{txShareStart, blobOneStart}, []ShareSequence{ - {NamespaceID: appconsts.TxNamespaceID, Shares: []Share{transactionShareStart}}, + {NamespaceID: appconsts.TxNamespaceID, Shares: []Share{txShareStart}}, {NamespaceID: blobOneNamespace, Shares: []Share{blobOneStart}}, }, false, }, { "one transaction, two blobs", - [][]byte{transactionShareStart, blobOneStart, blobTwoStart}, + [][]byte{txShareStart, blobOneStart, blobTwoStart}, []ShareSequence{ - {NamespaceID: appconsts.TxNamespaceID, Shares: []Share{transactionShareStart}}, + {NamespaceID: appconsts.TxNamespaceID, Shares: []Share{txShareStart}}, {NamespaceID: blobOneNamespace, Shares: []Share{blobOneStart}}, {NamespaceID: blobTwoNamespace, Shares: []Share{blobTwoStart}}, }, diff --git a/pkg/shares/share_splitting.go b/pkg/shares/share_splitting.go index ff93687d48..ce93c3d724 100644 --- a/pkg/shares/share_splitting.go +++ b/pkg/shares/share_splitting.go @@ -7,6 +7,7 @@ import ( "github.com/celestiaorg/celestia-app/pkg/appconsts" coretypes "github.com/tendermint/tendermint/types" + "golang.org/x/exp/maps" ) var ( @@ -28,7 +29,7 @@ func Split(data coretypes.Data, useShareIndexes bool) ([]Share, error) { wantShareCount := int(data.SquareSize * data.SquareSize) currentShareCount := 0 - txShares, pfbTxShares := SplitTxs(data.Txs) + txShares, pfbTxShares, _ := SplitTxs(data.Txs) currentShareCount += len(txShares) + len(pfbTxShares) // blobIndexes will be nil if we are working with a list of txs that do not // have a blob index. This preserves backwards compatibility with old blocks @@ -97,9 +98,10 @@ func ExtractShareIndexes(txs coretypes.Txs) []uint32 { return shareIndexes } -func SplitTxs(txs coretypes.Txs) ([]Share, []Share) { +func SplitTxs(txs coretypes.Txs) (txShares []Share, pfbShares []Share, shareRanges map[coretypes.TxKey]ShareRange) { txWriter := NewCompactShareSplitter(appconsts.TxNamespaceID, appconsts.ShareVersionZero) pfbTxWriter := NewCompactShareSplitter(appconsts.PayForBlobNamespaceID, appconsts.ShareVersionZero) + for _, tx := range txs { if _, isIndexWrapper := coretypes.UnmarshalIndexWrapper(tx); isIndexWrapper { pfbTxWriter.WriteTx(tx) @@ -107,7 +109,11 @@ func SplitTxs(txs coretypes.Txs) ([]Share, []Share) { txWriter.WriteTx(tx) } } - return txWriter.Export(), pfbTxWriter.Export() + + txShares, txMap := txWriter.Export(0) + pfbShares, pfbMap := pfbTxWriter.Export(len(txShares)) + + return txShares, pfbShares, mergeMaps(txMap, pfbMap) } func SplitBlobs(cursor int, indexes []uint32, blobs []coretypes.Blob, useShareIndexes bool) ([]Share, error) { @@ -126,3 +132,12 @@ func SplitBlobs(cursor int, indexes []uint32, blobs []coretypes.Blob, useShareIn } return writer.Export(), nil } + +// mergeMaps merges two maps into a new map. If there are any duplicate keys, +// the value in the second map takes precedence. +func mergeMaps(mapOne, mapTwo map[coretypes.TxKey]ShareRange) map[coretypes.TxKey]ShareRange { + merged := make(map[coretypes.TxKey]ShareRange, len(mapOne)+len(mapTwo)) + maps.Copy(merged, mapOne) + maps.Copy(merged, mapTwo) + return merged +} diff --git a/pkg/shares/share_splitting_test.go b/pkg/shares/share_splitting_test.go index e51b3cbaa1..cf2de2076f 100644 --- a/pkg/shares/share_splitting_test.go +++ b/pkg/shares/share_splitting_test.go @@ -6,10 +6,11 @@ import ( "testing" "github.com/celestiaorg/celestia-app/pkg/appconsts" + "github.com/stretchr/testify/assert" coretypes "github.com/tendermint/tendermint/types" ) -func TestSplitTxs(t *testing.T) { +func TestSplitTxs_forTxShares(t *testing.T) { smallTransactionA := coretypes.Tx{0xa} smallTransactionB := coretypes.Tx{0xb} largeTransaction := bytes.Repeat([]byte{0xc}, 512) @@ -120,7 +121,7 @@ func TestSplitTxs(t *testing.T) { } for _, tt := range testCases { t.Run(tt.name, func(t *testing.T) { - got, _ := SplitTxs(tt.txs) + got, _, _ := SplitTxs(tt.txs) if !reflect.DeepEqual(got, tt.want) { t.Errorf("SplitTxs()\n got %#v\n want %#v", got, tt.want) } @@ -128,6 +129,114 @@ func TestSplitTxs(t *testing.T) { } } +func TestSplitTxs(t *testing.T) { + type testCase struct { + name string + txs coretypes.Txs + wantTxShares []Share + wantPfbShares []Share + wantMap map[coretypes.TxKey]ShareRange + } + + smallTx := coretypes.Tx{0xa} // spans one share + smallTxShares := []Share{ + padShare([]uint8{ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id + 0x1, // info byte + 0x0, 0x0, 0x0, 0x2, // 1 byte (unit) + 1 byte (unit length) = 2 bytes sequence length + 0x0, 0x0, 0x0, 17, // reserved bytes + 0x1, // unit length of first transaction + 0xa, // data of first transaction + }), + } + + pfbTx, err := coretypes.MarshalIndexWrapper(coretypes.Tx{0xb}, 10) // spans one share + assert.NoError(t, err) + pfbTxShares := []Share{ + padShare([]uint8{ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, // namespace id + 0x1, // info byte + 0x0, 0x0, 0x0, 13, // 1 byte (unit) + 1 byte (unit length) = 2 bytes sequence length + 0x0, 0x0, 0x0, 17, // reserved bytes + 12, // unit length of first transaction + 0xa, 0x1, 0xb, 0x12, 0x1, 0xa, 0x1a, 0x4, 0x49, 0x4e, 0x44, 0x58, // data of first transaction + }), + } + + largeTx := coretypes.Tx(bytes.Repeat([]byte{0xc}, 512)) // spans two shares + largeTxShares := []Share{ + fillShare([]uint8{ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id + 0x1, // info byte + 0x0, 0x0, 0x2, 0x2, // 512 (unit) + 2 (unit length) = 514 sequence length + 0x0, 0x0, 0x0, 17, // reserved bytes + 128, 4, // unit length of transaction is 512 + }, 0xc), // data of transaction + padShare(append([]uint8{ + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, // namespace id + 0x0, // info byte + 0x0, 0x0, 0x0, 0x0, // reserved bytes + }, bytes.Repeat([]byte{0xc}, 19)..., // continuation data of transaction + )), + } + + testCases := []testCase{ + { + name: "empty", + txs: coretypes.Txs{}, + wantTxShares: []Share{}, + wantPfbShares: []Share{}, + wantMap: map[coretypes.TxKey]ShareRange{}, + }, + { + name: "smallTx", + txs: coretypes.Txs{smallTx}, + wantTxShares: smallTxShares, + wantPfbShares: []Share{}, + wantMap: map[coretypes.TxKey]ShareRange{ + smallTx.Key(): {0, 0}, + }, + }, + { + name: "largeTx", + txs: coretypes.Txs{largeTx}, + wantTxShares: largeTxShares, + wantPfbShares: []Share{}, + wantMap: map[coretypes.TxKey]ShareRange{ + largeTx.Key(): {0, 1}, + }, + }, + { + name: "pfbTx", + txs: coretypes.Txs{pfbTx}, + wantTxShares: []Share{}, + wantPfbShares: pfbTxShares, + wantMap: map[coretypes.TxKey]ShareRange{ + pfbTx.Key(): {0, 0}, + }, + }, + { + name: "largeTx then pfbTx", + txs: coretypes.Txs{largeTx, pfbTx}, + wantTxShares: largeTxShares, + wantPfbShares: pfbTxShares, + wantMap: map[coretypes.TxKey]ShareRange{ + largeTx.Key(): {0, 1}, + pfbTx.Key(): {2, 2}, + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + txShares, pfbTxShares, gotMap := SplitTxs(tc.txs) + assert.Equal(t, tc.wantTxShares, txShares) + assert.Equal(t, tc.wantPfbShares, pfbTxShares) + assert.Equal(t, tc.wantMap, gotMap) + }) + } +} + // padShare returns a share padded with trailing zeros. func padShare(share []byte) (paddedShare []byte) { return fillShare(share, 0) @@ -138,3 +247,69 @@ func padShare(share []byte) (paddedShare []byte) { func fillShare(share []byte, filler byte) (paddedShare []byte) { return append(share, bytes.Repeat([]byte{filler}, appconsts.ShareSize-len(share))...) } + +func Test_mergeMaps(t *testing.T) { + type testCase struct { + name string + mapOne map[coretypes.TxKey]ShareRange + mapTwo map[coretypes.TxKey]ShareRange + want map[coretypes.TxKey]ShareRange + } + testCases := []testCase{ + { + name: "empty maps", + mapOne: map[coretypes.TxKey]ShareRange{}, + mapTwo: map[coretypes.TxKey]ShareRange{}, + want: map[coretypes.TxKey]ShareRange{}, + }, + { + name: "merges maps with one key each", + mapOne: map[coretypes.TxKey]ShareRange{ + {0x1}: {0, 1}, + }, + mapTwo: map[coretypes.TxKey]ShareRange{ + {0x2}: {2, 3}, + }, + want: map[coretypes.TxKey]ShareRange{ + {0x1}: {0, 1}, + {0x2}: {2, 3}, + }, + }, + { + name: "merges maps with multiple keys each", + mapOne: map[coretypes.TxKey]ShareRange{ + {0x1}: {0, 1}, + {0x2}: {2, 3}, + }, + mapTwo: map[coretypes.TxKey]ShareRange{ + {0x3}: {3, 3}, + {0x4}: {4, 4}, + }, + want: map[coretypes.TxKey]ShareRange{ + {0x1}: {0, 1}, + {0x2}: {2, 3}, + {0x3}: {3, 3}, + {0x4}: {4, 4}, + }, + }, + { + name: "merges maps with a duplicate key and the second map's value takes precedence", + mapOne: map[coretypes.TxKey]ShareRange{ + {0x1}: {0, 0}, + }, + mapTwo: map[coretypes.TxKey]ShareRange{ + {0x1}: {1, 1}, + }, + want: map[coretypes.TxKey]ShareRange{ + {0x1}: {1, 1}, + }, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + got := mergeMaps(tc.mapOne, tc.mapTwo) + assert.Equal(t, tc.want, got) + }) + } +} diff --git a/pkg/shares/split_compact_shares.go b/pkg/shares/split_compact_shares.go index 828954c1c0..2da168ac67 100644 --- a/pkg/shares/split_compact_shares.go +++ b/pkg/shares/split_compact_shares.go @@ -9,6 +9,13 @@ import ( coretypes "github.com/tendermint/tendermint/types" ) +type ShareRange struct { + // Start is the index of the first share occupied by this range. + Start int + // End is the index of the last share occupied by this range. + End int +} + // CompactShareSplitter will write raw data compactly across a progressively // increasing set of shares. It is used to lazily split block data such as // transactions or intermediate state roots into shares. @@ -16,7 +23,12 @@ type CompactShareSplitter struct { shares []Share pendingShare Share namespace namespace.ID - version uint8 + shareVersion uint8 + // shareRanges is a map from a transaction key to the range of shares it + // occupies. The range assumes this compact share splitter is the only + // thing in the data square (e.g. the range for the first tx starts at index + // 0). + shareRanges map[coretypes.TxKey]ShareRange } // NewCompactShareSplitter returns a CompactShareSplitter using the provided @@ -34,19 +46,35 @@ func NewCompactShareSplitter(ns namespace.ID, shareVersion uint8) *CompactShareS pendingShare = append(pendingShare, byte(infoByte)) pendingShare = append(pendingShare, placeholderSequenceLen...) pendingShare = append(pendingShare, placeholderReservedBytes...) - return &CompactShareSplitter{pendingShare: pendingShare, namespace: ns} + return &CompactShareSplitter{ + shares: []Share{}, + pendingShare: pendingShare, + namespace: ns, + shareVersion: shareVersion, + shareRanges: map[coretypes.TxKey]ShareRange{}, + } } +// WriteTx adds the delimited data for the provided tx to the underlying compact +// share splitter. func (css *CompactShareSplitter) WriteTx(tx coretypes.Tx) { rawData, err := MarshalDelimitedTx(tx) if err != nil { panic(fmt.Sprintf("included Tx in mem-pool that can not be encoded %v", tx)) } - css.WriteBytes(rawData) + + startShare := len(css.shares) + css.write(rawData) + endShare := css.Count() - 1 + + css.shareRanges[tx.Key()] = ShareRange{ + Start: startShare, + End: endShare, + } } -// WriteBytes adds the delimited data to the underlying compact shares. -func (css *CompactShareSplitter) WriteBytes(rawData []byte) { +// write adds the delimited data to the underlying compact shares. +func (css *CompactShareSplitter) write(rawData []byte) { css.maybeWriteReservedBytesToPendingShare() txCursor := len(rawData) @@ -86,7 +114,7 @@ func (css *CompactShareSplitter) stackPending() { css.shares = append(css.shares, css.pendingShare) newPendingShare := make([]byte, 0, appconsts.ShareSize) newPendingShare = append(newPendingShare, css.namespace...) - infoByte, err := NewInfoByte(css.version, false) + infoByte, err := NewInfoByte(css.shareVersion, false) if err != nil { panic(err) } @@ -96,10 +124,23 @@ func (css *CompactShareSplitter) stackPending() { css.pendingShare = newPendingShare } -// Export finalizes and returns the underlying compact shares. -func (css *CompactShareSplitter) Export() []Share { +// Export finalizes and returns the underlying compact shares and a map of +// shareRanges. All share ranges in the map of shareRanges will be offset (i.e. +// incremented) by the shareRangeOffset provided. shareRangeOffset should be 0 +// for the first compact share sequence in the data square (transactions) but +// should be some non-zero number for subsequent compact share sequences (e.g. +// pfb txs). +func (css *CompactShareSplitter) Export(shareRangeOffset int) ([]Share, map[coretypes.TxKey]ShareRange) { + // apply the shareRangeOffset to all share ranges + for k, v := range css.shareRanges { + css.shareRanges[k] = ShareRange{ + Start: v.Start + shareRangeOffset, + End: v.End + shareRangeOffset, + } + } + if css.isEmpty() { - return []Share{} + return []Share{}, css.shareRanges } var bytesOfPadding int @@ -111,7 +152,7 @@ func (css *CompactShareSplitter) Export() []Share { sequenceLen := css.sequenceLen(bytesOfPadding) css.writeSequenceLen(sequenceLen) - return css.shares + return css.shares, css.shareRanges } // writeSequenceLen writes the sequence length to the first share. diff --git a/pkg/shares/split_compact_shares_test.go b/pkg/shares/split_compact_shares_test.go index 9651ee66d8..041a088063 100644 --- a/pkg/shares/split_compact_shares_test.go +++ b/pkg/shares/split_compact_shares_test.go @@ -55,7 +55,7 @@ func rawTxSize(desiredSize int) int { return desiredSize - DelimLen(uint64(desiredSize)) } -func TestExport(t *testing.T) { +func TestExport_write(t *testing.T) { type testCase struct { name string want []Share @@ -111,10 +111,145 @@ func TestExport(t *testing.T) { t.Run(tc.name, func(t *testing.T) { css := NewCompactShareSplitter(appconsts.TxNamespaceID, appconsts.ShareVersionZero) for _, bytes := range tc.writeBytes { - css.WriteBytes(bytes) + css.write(bytes) } - got := css.Export() + got, _ := css.Export(0) assert.Equal(t, tc.want, got) }) } } + +func TestExport(t *testing.T) { + type testCase struct { + name string + txs []coretypes.Tx + want map[coretypes.TxKey]ShareRange + shareRangeOffset int + } + + txOne := coretypes.Tx{0x1} + txTwo := coretypes.Tx(bytes.Repeat([]byte{2}, 600)) + txThree := coretypes.Tx(bytes.Repeat([]byte{3}, 1000)) + exactlyOneShare := coretypes.Tx(bytes.Repeat([]byte{4}, subtractDelimLen(appconsts.FirstCompactShareContentSize))) + exactlyTwoShares := coretypes.Tx(bytes.Repeat([]byte{5}, subtractDelimLen(appconsts.FirstCompactShareContentSize+appconsts.ContinuationCompactShareContentSize))) + + testCases := []testCase{ + { + name: "empty", + txs: []coretypes.Tx{}, + want: map[coretypes.TxKey]ShareRange{}, + }, + { + name: "txOne occupies shares 0 to 0", + txs: []coretypes.Tx{ + txOne, + }, + want: map[coretypes.TxKey]ShareRange{ + txOne.Key(): {0, 0}, + }, + }, + { + name: "txTwo occupies shares 0 to 1", + txs: []coretypes.Tx{ + txTwo, + }, + want: map[coretypes.TxKey]ShareRange{ + txTwo.Key(): {0, 1}, + }, + }, + { + name: "txThree occupies shares 0 to 2", + txs: []coretypes.Tx{ + txThree, + }, + want: map[coretypes.TxKey]ShareRange{ + txThree.Key(): {0, 2}, + }, + }, + { + name: "txOne occupies shares 0 to 0, txTwo occupies shares 0 to 1, txThree occupies shares 1 to 3", + txs: []coretypes.Tx{ + txOne, + txTwo, + txThree, + }, + want: map[coretypes.TxKey]ShareRange{ + txOne.Key(): {0, 0}, + txTwo.Key(): {0, 1}, + txThree.Key(): {1, 3}, + }, + }, + + { + name: "exactly one share occupies shares 0 to 0", + txs: []coretypes.Tx{ + exactlyOneShare, + }, + want: map[coretypes.TxKey]ShareRange{ + exactlyOneShare.Key(): {0, 0}, + }, + }, + { + name: "exactly two shares occupies shares 0 to 1", + txs: []coretypes.Tx{ + exactlyTwoShares, + }, + want: map[coretypes.TxKey]ShareRange{ + exactlyTwoShares.Key(): {0, 1}, + }, + }, + { + name: "two shares followed by one share", + txs: []coretypes.Tx{ + exactlyTwoShares, + exactlyOneShare, + }, + want: map[coretypes.TxKey]ShareRange{ + exactlyTwoShares.Key(): {0, 1}, + exactlyOneShare.Key(): {2, 2}, + }, + }, + { + name: "one share followed by two shares", + txs: []coretypes.Tx{ + exactlyOneShare, + exactlyTwoShares, + }, + want: map[coretypes.TxKey]ShareRange{ + exactlyOneShare.Key(): {0, 0}, + exactlyTwoShares.Key(): {1, 2}, + }, + }, + { + name: "one share followed by two shares offset by 10", + txs: []coretypes.Tx{ + exactlyOneShare, + exactlyTwoShares, + }, + want: map[coretypes.TxKey]ShareRange{ + exactlyOneShare.Key(): {10, 10}, + exactlyTwoShares.Key(): {11, 12}, + }, + shareRangeOffset: 10, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + css := NewCompactShareSplitter(appconsts.TxNamespaceID, appconsts.ShareVersionZero) + for _, tx := range tc.txs { + css.WriteTx(tx) + } + + _, got := css.Export(tc.shareRangeOffset) + assert.Equal(t, tc.want, got) + }) + } +} + +// subtractDelimLen subtracts the delimiter size from numBytesDelimited. This is +// useful for determining the size of a tx prior to it being prepended with a +// delimiter. +func subtractDelimLen(numBytesDelimited int) (numBytesUndelimited int) { + return numBytesDelimited - DelimLen(uint64(numBytesDelimited)) +} diff --git a/x/qgb/client/verify.go b/x/qgb/client/verify.go index 2efb059de8..317240e030 100644 --- a/x/qgb/client/verify.go +++ b/x/qgb/client/verify.go @@ -79,7 +79,7 @@ func txCmd() *cobra.Command { return err } - beginTxShare, endTxShare, err := proof.TxSharePosition(blockRes.Block.Txs, uint64(tx.Index)) + beginTxShare, endTxShare, err := proof.TxSharePosition(blockRes.Block.Data, uint64(tx.Index)) if err != nil { return err }